From b9774e910f29b9b1170a2fc8e197f598d3f6cb7f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 8 Jun 2021 15:41:29 -0700
Subject: [PATCH 001/513] Add ProductPCM.fst

---
 examples/steel/ProductPCM.fst | 70 +++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 examples/steel/ProductPCM.fst

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
new file mode 100644
index 00000000000..8e8943eedbf
--- /dev/null
+++ b/examples/steel/ProductPCM.fst
@@ -0,0 +1,70 @@
+module ProductPCM
+
+/// We define a PCM for structs with two fields {a; b} by defining a
+/// PCM for tuples (a & b) in terms of (potentially user-defined) PCMs
+/// for a and b.
+
+val comp : pcm 'a -> pcm 'b -> 'a & 'b -> prop
+let comp p q (xa, xb) (ya, yb) = composable p xa xb /\ composable q ya yb
+
+val combine : pcm 'a -> pcm 'b -> x: 'a & 'b -> y: 'a & 'b {comp x y} -> 'a & 'b
+let combine p q (xa, xb) (ya, yb) = (op p xa ya, op q xb yb)
+
+let pcm_t #a #b (p:pcm a) (q:pcm b) : pcm (t a b) = FStar.PCM.({
+  p = {
+    composable=comp p q;
+    op=combine p q;
+    one=(one, one)
+  };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun (xa, xb) -> refine p xa /\ refine q xb) (* TODO check *)
+})
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let pcm_all_or_none #a : pcm (option a) = FStar.PCM.({
+  p = {
+    composable=fun #a #b x y -> match x, y with None, _ | _, None -> True | _, _ -> False;
+    op=fun #a #b x y -> match x, y with None, x | x, None -> x;
+    one=None
+  };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> True)
+})
+
+/// (pcm_t pcm_all_or_none pcm_all_or_none) defines carrier type
+///   option a & option b
+/// with
+///   composable (xa, xb) (ya, yb)
+///   = composable xa ya /\ composable xb yb
+///   = match (xa, xb), (ya, yb) with
+///     | (None, None), _ | _, (None, None)
+///     | (Some _, None), (None, Some _)
+///     | (None, Some _), (Some _, None) -> True
+///     | _ -> False
+/// and
+///   op (xa, xb) (ya, yb)
+///   = (op xa xb, op ya yb)
+///   = match (xa, xb), (ya, yb) with
+///     | (None, None), z | z, (None, None) -> z
+///     | (Some a, None), (None, Some b) -> (Some a, Some b)
+///     | (None, Some b), (Some a, None) -> (Some a, Some b)
+/// which corresponds directly to the PCM defined in examples/steel/StructUpdate:
+///   Both x y = (Some x, Some y)
+///   First x = (Some x, None)
+///   Second y = (None, Some y)
+///   Neither = (None, None)
+///
+/// Example custom PCM: use
+///   fractional a & fractional b
+/// for fractional permissions on a struct with fields {a; b},
+/// where fractional is as defined in ulib/experimental/Steel.HigherReference.
+/// - (xa, xb) and (ya, yb) are composable when the sums of each component's shares are at most 1
+/// - The product of (xa, xb) and (ya, yb) is (xa <> ya, xb <> yb), where (<>) merges shares
+/// - The unit is (None, None), a struct where one does not have access to either field

From 109d4d0c8f9191f57cd888ba549d9a3de16b5d62 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 10 Jun 2021 07:49:49 -0700
Subject: [PATCH 002/513] Generalize to n-ary products and add construction for
 tagged unions

---
 examples/steel/ProductPCM.fst | 223 ++++++++++++++++++++++++++--------
 1 file changed, 173 insertions(+), 50 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index 8e8943eedbf..df2cd43f6d4 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -1,70 +1,193 @@
 module ProductPCM
 
-/// We define a PCM for structs with two fields {a; b} by defining a
-/// PCM for tuples (a & b) in terms of (potentially user-defined) PCMs
-/// for a and b.
+open FStar.PCM
 
-val comp : pcm 'a -> pcm 'b -> 'a & 'b -> prop
-let comp p q (xa, xb) (ya, yb) = composable p xa xb /\ composable q ya yb
+/// We can define a PCM for structs with two fields {a; b} by defining
+/// a PCM for tuples (a & b) in terms of (potentially user-defined)
+/// PCMs for a and b.
 
-val combine : pcm 'a -> pcm 'b -> x: 'a & 'b -> y: 'a & 'b {comp x y} -> 'a & 'b
-let combine p q (xa, xb) (ya, yb) = (op p xa ya, op q xb yb)
+val tuple_comp : pcm 'a -> pcm 'b -> 'a & 'b -> 'a & 'b -> prop
+let tuple_comp p q (xa, xb) (ya, yb) = composable p xa ya /\ composable q xb yb
 
-let pcm_t #a #b (p:pcm a) (q:pcm b) : pcm (t a b) = FStar.PCM.({
+val tuple_op : p: pcm 'a -> q: pcm 'b -> x:('a & 'b) -> y:('a & 'b){tuple_comp p q x y} -> 'a & 'b
+let tuple_op p q (xa, xb) (ya, yb) = (op p xa ya, op q xb yb)
+
+val tuple_pcm : pcm 'a -> pcm 'b -> pcm ('a & 'b)
+let tuple_pcm p q = FStar.PCM.({
   p = {
-    composable=comp p q;
-    op=combine p q;
-    one=(one, one)
+    composable=tuple_comp p q;
+    op=tuple_op p q;
+    one=(p.p.one, q.p.one)
   };
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun (xa, xb) -> refine p xa /\ refine q xb) (* TODO check *)
+  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
+  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
+  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
+  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
+  refine = (fun (xa, xb) ->
+    (xa, xb) == (p.p.one, q.p.one) \/
+    (p.refine xa /\ q.refine xb /\ ~ (xa == p.p.one) /\ ~ (xb == q.p.one)))
 })
 
 /// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
 
-let pcm_all_or_none #a : pcm (option a) = FStar.PCM.({
+val opt_comp : option 'a -> option 'a -> prop
+let opt_comp x y = match x, y with None, _ | _, None -> True | _ -> False
+
+val opt_op : x:option 'a -> y:option 'a {opt_comp x y} -> option 'a
+let opt_op x y = match x, y with None, z | z, None -> z
+
+val opt_pcm : pcm (option 'a)
+let opt_pcm #a = FStar.PCM.({
   p = {
-    composable=fun #a #b x y -> match x, y with None, _ | _, None -> True | _, _ -> False;
-    op=fun #a #b x y -> match x, y with None, x | x, None -> x;
+    composable=opt_comp;
+    op=opt_op;
     one=None
   };
   comm = (fun _ _ -> ());
   assoc = (fun _ _ _ -> ());
   assoc_r = (fun _ _ _ -> ());
   is_unit = (fun _ -> ());
-  refine = (fun x -> True)
+  refine = (fun _ -> True);
+})
+
+/// We can generalize to 'a-ary products (z:'a -> f z), given a PCM for each z:
+
+open FStar.FunctionalExtensionality
+
+val prod_comp :
+  f:('a -> Type) -> (z:'a -> pcm (f z)) ->
+  restricted_t 'a f -> restricted_t 'a f -> prop
+let prod_comp f p x y = forall z. composable (p z) (x z) (y z)
+
+val prod_op :
+  f:('a -> Type) -> p:(z:'a -> pcm (f z)) -> 
+  x:restricted_t 'a f -> y: restricted_t 'a f {prod_comp f p x y} -> 
+  restricted_t 'a f
+let prod_op #a f p x y = on_domain a (fun z -> op (p z) (x z) (y z))
+
+val prod_one : f:('a -> Type) -> (z:'a -> pcm (f z)) -> restricted_t 'a f
+let prod_one f p = on_domain _ (fun z -> (p z).p.one)
+
+let ext (a: Type) (b: (a -> Type)) (f g: restricted_t a b)
+  : Lemma (ensures (feq #a #b f g <==> f == g))
+= extensionality a b f g
+
+val prod_pcm' : f:('a -> Type) -> (z:'a -> pcm (f z)) -> pcm' (restricted_t 'a f)
+let prod_pcm' #a f p = FStar.PCM.({
+  composable = prod_comp f p;
+  op = prod_op f p;
+  one = prod_one f p;
 })
 
-/// (pcm_t pcm_all_or_none pcm_all_or_none) defines carrier type
-///   option a & option b
-/// with
-///   composable (xa, xb) (ya, yb)
-///   = composable xa ya /\ composable xb yb
-///   = match (xa, xb), (ya, yb) with
-///     | (None, None), _ | _, (None, None)
-///     | (Some _, None), (None, Some _)
-///     | (None, Some _), (Some _, None) -> True
-///     | _ -> False
-/// and
-///   op (xa, xb) (ya, yb)
-///   = (op xa xb, op ya yb)
-///   = match (xa, xb), (ya, yb) with
-///     | (None, None), z | z, (None, None) -> z
-///     | (Some a, None), (None, Some b) -> (Some a, Some b)
-///     | (None, Some b), (Some a, None) -> (Some a, Some b)
-/// which corresponds directly to the PCM defined in examples/steel/StructUpdate:
-///   Both x y = (Some x, Some y)
-///   First x = (Some x, None)
-///   Second y = (None, Some y)
-///   Neither = (None, None)
-///
-/// Example custom PCM: use
-///   fractional a & fractional b
-/// for fractional permissions on a struct with fields {a; b},
-/// where fractional is as defined in ulib/experimental/Steel.HigherReference.
-/// - (xa, xb) and (ya, yb) are composable when the sums of each component's shares are at most 1
-/// - The product of (xa, xb) and (ya, yb) is (xa <> ya, xb <> yb), where (<>) merges shares
-/// - The unit is (None, None), a struct where one does not have access to either field
+open FStar.Classical
+val prod_comm :
+  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  x:restricted_t 'a f ->
+  y:restricted_t 'a f {prod_comp f p x y} ->
+  Lemma (prod_op f p x y == prod_op f p y x)
+let prod_comm #a f p x y =
+  let comm (z:a): Lemma ((p z).p.op (x z) (y z) == (p z).p.op (y z) (x z)) =
+    (p z).comm (x z) (y z)
+  in forall_intro comm;
+  ext a f (prod_op f p x y) (prod_op f p y x)
+
+val prod_assoc :
+  f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
+  x:restricted_t 'a f ->
+  y:restricted_t 'a f ->
+  z:restricted_t 'a f {prod_comp f p y z /\ prod_comp f p x (prod_op f p y z)} ->
+  Lemma (prod_comp f p x y /\
+         prod_comp f p (prod_op f p x y) z /\
+         prod_op f p x (prod_op f p y z) == prod_op f p (prod_op f p x y) z)
+let prod_assoc #a f p x y z =
+  let assoc (w:a): 
+    Lemma (composable (p w) (x w) (y w) /\
+           composable (p w) (op (p w) (x w) (y w)) (z w) /\
+           op (p w) (x w) (op (p w) (y w) (z w)) == op (p w) (op (p w) (x w) (y w)) (z w)) 
+  = (p w).assoc (x w) (y w) (z w) in
+  forall_intro assoc;
+  ext a f (prod_op f p x (prod_op f p y z)) (prod_op f p (prod_op f p x y) z)
+
+val prod_assoc_r :
+  f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
+  x:restricted_t 'a f ->
+  y:restricted_t 'a f ->
+  z:restricted_t 'a f {prod_comp f p x y /\ prod_comp f p (prod_op f p x y) z} ->
+  Lemma (prod_comp f p y z /\
+         prod_comp f p x (prod_op f p y z) /\
+         prod_op f p x (prod_op f p y z) == prod_op f p (prod_op f p x y) z)
+let prod_assoc_r #a f p x y z =
+  let assoc_r (w:a): 
+    Lemma (composable (p w) (y w) (z w) /\
+           composable (p w) (x w) (op (p w) (y w) (z w)) /\
+           op (p w) (x w) (op (p w) (y w) (z w)) == op (p w) (op (p w) (x w) (y w)) (z w)) 
+  = (p w).assoc_r (x w) (y w) (z w) in
+  forall_intro assoc_r;
+  ext a f (prod_op f p x (prod_op f p y z)) (prod_op f p (prod_op f p x y) z)
+
+val prod_is_unit :
+  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  x:restricted_t 'a f ->
+  Lemma (prod_comp f p x (prod_one f p) /\
+         prod_op f p x (prod_one f p) == x)
+let prod_is_unit #a f p x =
+  let is_unit (y:a): 
+    Lemma (composable (p y) (x y) (prod_one f p y) /\
+           op (p y) (x y) (prod_one f p y) == x y)
+  = (p y).is_unit (x y) in
+  forall_intro is_unit;
+  ext a f (prod_op f p x (prod_one f p)) x
+
+val prod_pcm : f:('a -> Type) -> (z:'a -> pcm (f z)) -> pcm (restricted_t 'a f)
+let prod_pcm #a f p = FStar.PCM.({
+  p = prod_pcm' f p;
+  comm = prod_comm f p;
+  assoc = prod_assoc f p;
+  assoc_r = prod_assoc_r f p;
+  is_unit = prod_is_unit f p;
+  refine = (fun x ->
+    (forall z. x z == (p z).p.one) \/
+    (forall z. (p z).refine (x z) /\ ~ (x z == (p z).p.one)))
+})
+
+/// Similarly, given a PCM for each z:a, we can model a-ary unions with an PCM for option (x:a & f x), where
+/// - None is the unit of the PCM
+/// - Some (x, y) is a union with tag x and content y
+
+let union (a:Type) (f:a -> Type) (p:(x:a -> pcm (f x))) = option (x:a & f x)
+
+val union_comp :
+  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  symrel (union 'a f p)
+let union_comp f p x y = match x, y with
+  | None, z | z, None -> True
+  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
+
+val union_op :
+  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  x:union 'a f p -> y:union 'a f p {union_comp f p x y} -> union 'a f p
+let union_op f p x y = match x, y with
+  | None, z | z, None -> z
+  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
+
+val union_pcm : f:('a -> Type) -> p:(x: 'a -> pcm (f x)) -> pcm (union 'a f p)
+let union_pcm #a f p = FStar.PCM.({
+  p = {
+    composable=union_comp f p;
+    op=union_op f p;
+    one=None
+  };
+  comm = (fun x y -> match x, y with
+    | None, _ | _, None -> ()
+    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
+  assoc = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
+  assoc_r = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with
+    | None -> True
+    | Some (|xa, xb|) -> (p xa).refine xb /\ ~(xb == (p xa).p.one))
+})

From 70d05c6166fde1e20b0d74e78578e744b0839add Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 14 Jun 2021 13:45:25 -0700
Subject: [PATCH 003/513] Frame-preserving update for first field of struct

---
 examples/steel/ProductPCM.fst | 368 ++++++++++++++++++++++++++++++++--
 1 file changed, 352 insertions(+), 16 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index df2cd43f6d4..116220334d3 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -2,6 +2,73 @@ module ProductPCM
 
 open FStar.PCM
 
+/// Aseem's alternative definition of frame-preserving updates
+
+type frame_preserving_upd (#a:Type u#a) (p:pcm a) (x y:a) =
+  v:a{
+     p.refine v /\
+     compatible p x v
+  } ->
+  v_new:a{
+    p.refine v_new /\
+    compatible p y v_new /\
+    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
+       composable p y frame /\
+       (op p x frame == v ==> op p y frame == v_new))}
+
+/// The alternative definition satisfies 3 nice properties:
+
+(* The identity function is a frame-preserving update *)
+val no_op_is_frame_preserving :
+  p: pcm 'a -> x: 'a ->
+  frame_preserving_upd p x x
+let no_op_is_frame_preserving p x = fun v -> v
+
+(* Frame-preserving updates compose, and the composition is just
+   function composition *)
+val frame_preserving_updates_compose :
+  p: pcm 'a -> x: 'a -> y: 'a -> z: 'a ->
+  frame_preserving_upd p y z ->
+  frame_preserving_upd p x y ->
+  frame_preserving_upd p x z
+let frame_preserving_updates_compose p x y z f g = fun v -> f (g v)
+
+val compatible_subframe :
+  p: pcm 'a -> x: 'a -> y: 'a {composable p x y} -> z: 'a ->
+  Lemma (requires (compatible p (op p x y) z)) (ensures (compatible p x z))
+let compatible_subframe p x y z =
+  compatible_elim p (op p x y) z (compatible p x z) (fun frame ->
+    p.comm x y;
+    p.assoc frame y x)
+
+(* A frame-preserving update from x to y is also a frame-preserving
+   update from (x `op` subframe) to (y `op` subframe), for any subframe *)
+open FStar.Classical
+val frame_preserving_subframe : 
+  p: pcm 'a -> x: 'a -> y: 'a -> subframe: 'a{composable p x subframe /\ composable p y subframe} ->
+  frame_preserving_upd p x y ->
+  frame_preserving_upd p (op p x subframe) (op p y subframe)
+let frame_preserving_subframe #a p x y subframe f v =
+  compatible_subframe p x subframe v;
+  let w = f v in
+  let aux (frame: a{composable p (op p x subframe) frame}):
+    Lemma (composable p (op p y subframe) frame /\
+           (op p (op p x subframe) frame == v ==> op p (op p y subframe) frame == w))
+           [SMTPat (composable p (op p y subframe) frame)]
+  = p.assoc_r x subframe frame;
+    assert (composable p x (op p subframe frame));
+    assert (composable p y (op p subframe frame));
+    p.assoc y subframe frame
+  in
+  let lframe : squash (compatible p (op p x subframe) v) = () in
+  exists_elim (compatible p (op p y subframe) w) lframe (fun frame -> 
+    aux frame;
+    assert (op p frame (op p x subframe) == v);
+    p.comm frame (op p x subframe);
+    assert (op p (op p y subframe) frame == w);
+    p.comm (op p y subframe) frame);
+  w
+
 /// We can define a PCM for structs with two fields {a; b} by defining
 /// a PCM for tuples (a & b) in terms of (potentially user-defined)
 /// PCMs for a and b.
@@ -12,21 +79,169 @@ let tuple_comp p q (xa, xb) (ya, yb) = composable p xa ya /\ composable q xb yb
 val tuple_op : p: pcm 'a -> q: pcm 'b -> x:('a & 'b) -> y:('a & 'b){tuple_comp p q x y} -> 'a & 'b
 let tuple_op p q (xa, xb) (ya, yb) = (op p xa ya, op q xb yb)
 
-val tuple_pcm : pcm 'a -> pcm 'b -> pcm ('a & 'b)
-let tuple_pcm p q = FStar.PCM.({
-  p = {
-    composable=tuple_comp p q;
-    op=tuple_op p q;
-    one=(p.p.one, q.p.one)
-  };
-  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
-  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
-  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
-  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
-  refine = (fun (xa, xb) ->
-    (xa, xb) == (p.p.one, q.p.one) \/
-    (p.refine xa /\ q.refine xb /\ ~ (xa == p.p.one) /\ ~ (xb == q.p.one)))
-})
+// val full : pcm' 'a -> 'a -> prop
+// let full #a p x = forall (frame:a{p.composable frame x}). p.op frame x == x
+
+(* This product construction needs some additional assumptions in order to work: *)
+noeq type refined_pcm a = {
+  u: pcm a;
+  (* The unit is the unique "least element" of the preorder defined by
+     [compatible]. (i.e., nothing can be "inside of" or "have less
+     information than" the unit of the PCM) *)
+  compat_unit_unique : x:a ->
+    Lemma (compatible u x u.p.one ==> x == u.p.one);
+// (* refine says that an element is either unit or a full value *)
+// refine_unit_or_full : x:a ->
+//   Lemma (u.refine x == (x == u.p.one \/ full u.p x));
+}
+  
+val tuple_pcm : refined_pcm 'a -> refined_pcm 'b -> refined_pcm ('a & 'b)
+let tuple_pcm #a #b p q =
+  let p' = FStar.PCM.({
+    composable = tuple_comp p.u q.u;
+    op = tuple_op p.u q.u;
+    one = (p.u.p.one, q.u.p.one)
+  }) in
+  let u = FStar.PCM.({
+    p = p';
+    comm = (fun (xa, xb) (ya, yb) -> p.u.comm xa ya; q.u.comm xb yb);
+    assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.u.assoc xa ya za; q.u.assoc xb yb zb);
+    assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.u.assoc_r xa ya za; q.u.assoc_r xb yb zb);
+    is_unit = (fun (xa, xb) -> p.u.is_unit xa; q.u.is_unit xb);
+    refine = (fun (xa, xb) -> (xa, xb) == p'.one \/ (p.u.refine xa /\ q.u.refine xb))
+  }) in {
+    u = u;
+    compat_unit_unique = (fun (xa, xb) -> p.compat_unit_unique xa; q.compat_unit_unique xb)
+  }
+
+open Steel.Memory
+open Steel.Effect.Atomic
+open Steel.Effect
+
+module T = FStar.Tactics
+
+/// With the alternative definition of frame-preserving updates and
+/// compat_unit_unique, we can define frame-preserving updates for a
+/// tuple PCM from frame-preserving updates on its components:
+
+val compatible_tuple_l :
+  p: refined_pcm 'a -> q: refined_pcm 'b ->
+  x: 'a -> v: 'a -> y: 'b -> w: 'b ->
+  Lemma 
+    (requires compatible p.u x v /\ compatible q.u y w)
+    (ensures compatible (tuple_pcm p q).u (x, y) (v, w))
+let compatible_tuple_l p q x v y w =
+  let pqu = (tuple_pcm p q).u in
+  let aux frame_x frame_y :
+    Lemma 
+      (requires composable pqu (x, y) (frame_x, frame_y) /\
+                op pqu (frame_x, frame_y) (x, y) == (v, w))
+      (ensures compatible pqu (x, y) (v, w))
+      [SMTPat (composable p.u x frame_x); SMTPat (composable q.u y frame_y)] =
+    ()
+  in ()
+
+val upd_fst :
+  p: refined_pcm 'a -> q: refined_pcm 'b ->
+  x: 'a {~ (x == p.u.p.one)} -> y: 'b -> x': 'a ->
+  frame_preserving_upd p.u x x' ->
+  frame_preserving_upd (tuple_pcm p q).u (x, y) (x', y)
+let upd_fst #a #b p q x y x' f (va, vb) =
+  p.compat_unit_unique x;
+  let wa = f va in
+  let pqu = (tuple_pcm p q).u in
+  compatible_tuple_l p q x' wa y vb;
+  let lemma (frame: (a & b) {composable pqu (x, y) frame}):
+    Lemma (composable pqu (x', y) frame /\
+           (op pqu (x, y) frame == (va, vb) ==> op pqu (x', y) frame == (wa, vb)))
+    [SMTPat (composable pqu (x, y) frame)] = ()
+  in (wa, vb)
+
+(*
+val upd_fst_0 :
+  p: refined_pcm 'a -> q: refined_pcm 'b ->
+  r: ref ('a & 'b) (tuple_pcm p q).u ->
+  x: Ghost.erased 'a {~ (Ghost.reveal x == p.u.p.one)} -> y: Ghost.erased 'b -> x': 'a ->
+  frame_preserving_upd p.u x x' ->
+  frame_preserving_upd (tuple_pcm p q).u (Ghost.reveal x, Ghost.reveal y) (x', Ghost.reveal y)
+let upd_fst_0 p q r x y x' upd_x (vx, vy) =
+  assume (compatible (tuple_pcm p q).u (x', Ghost.reveal y) (upd_x vx, vy));
+  // Since x != 1 and compatible x vx, vx != 1 by compat_unit_unique.
+  assert (compatible p.u (Ghost.reveal x) vx);
+  p.compat_unit_unique (Ghost.reveal x);
+  assert (~ (vx == p.u.p.one));
+  // Thus, if refine (vx, vy), vx and vy must be full values.
+  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (vx, vy));
+  full_tup p q vx vy;
+  // A frame-preserving update sends full values to full values, so (upd_x vx, vy) is full too.
+  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full q.u.p vy); (* TODO why doesn't this work? *)
+  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full p.u.p vx); (* TODO why doesn't this work? *)
+  assume (full p.u.p (upd_x vx)); (* can't be unit because upd_x is frame_preserving and vx != unit *)
+  full_tup p q (upd_x vx) vy;
+  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (upd_x vx, vy));
+  assert ((tuple_pcm p q).u.refine (vx, vy) ==> (tuple_pcm p q).u.refine (upd_x vx, vy));
+  assume ((tuple_pcm p q).u.refine (vx, vy) ==> frame_preserving (tuple_pcm p q).u (vx, vy) (upd_x vx, vy));
+  (upd_x vx, vy)
+*)
+
+(*
+val full_tup :
+  p: refined_pcm 'a -> q: refined_pcm 'b -> x: 'a -> y: 'b ->
+  full (tuple_pcm p q).u.p (x, y) == full p.u.p x /\ full q.u.p y
+let full_tup p q x y =
+  (* (forall (x', y') composable with (x, y). (x <> x', y <> y') = (x, y))
+     <=> (forall x' comp w/ x and y' comp w/ y. x <> x' = x /\ y <> y' = y)
+     <=> (forall x' comp w/ x. x <> x' = x) /\ (forall y' comp w/. y <> y' = y) *)
+  admit() (* TODO how to prove this? *)
+  *)
+
+(*
+val frame_preserving_full_value :
+  p: refined_pcm 'a -> x: 'a -> y: 'a ->
+  f:frame_preserving_upd_0 p.u x y ->
+  Lemma (requires full p.u.p x) (ensures full p.u.p (f v))
+let frame_preserving_full_value #a p x y f =
+  compatible_refl p.u x;
+  p.refine_unit_or_full x;
+  assert (p.u.refine x);
+  let z = f x in
+  assert (p.u.refine z);
+  assert (frame_preserving p.u x z);
+  assume (forall (frame:a{composable p.u frame z}). op p.u frame z == z);
+  admit()
+  *)
+
+(*
+val upd_fst_0 :
+  p: refined_pcm 'a -> q: refined_pcm 'b ->
+  r: ref ('a & 'b) (tuple_pcm p q).u ->
+  x: Ghost.erased 'a {~ (Ghost.reveal x == p.u.p.one)} -> y: Ghost.erased 'b -> x': 'a ->
+  frame_preserving_upd_0 p.u x x' ->
+  frame_preserving_upd_0 (tuple_pcm p q).u (Ghost.reveal x, Ghost.reveal y) (x', Ghost.reveal y)
+let upd_fst_0 p q r x y x' upd_x (vx, vy) =
+  assume (compatible (tuple_pcm p q).u (x', Ghost.reveal y) (upd_x vx, vy));
+  // Since x != 1 and compatible x vx, vx != 1 by compat_unit_unique.
+  assert (compatible p.u (Ghost.reveal x) vx);
+  p.compat_unit_unique (Ghost.reveal x);
+  assert (~ (vx == p.u.p.one));
+  // Thus, if refine (vx, vy), vx and vy must be full values.
+  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (vx, vy));
+  full_tup p q vx vy;
+  // A frame-preserving update sends full values to full values, so (upd_x vx, vy) is full too.
+  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full q.u.p vy); (* TODO why doesn't this work? *)
+  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full p.u.p vx); (* TODO why doesn't this work? *)
+  assume (full p.u.p (upd_x vx)); (* can't be unit because upd_x is frame_preserving and vx != unit *)
+  full_tup p q (upd_x vx) vy;
+  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (upd_x vx, vy));
+  assert ((tuple_pcm p q).u.refine (vx, vy) ==> (tuple_pcm p q).u.refine (upd_x vx, vy));
+  assume ((tuple_pcm p q).u.refine (vx, vy) ==> frame_preserving (tuple_pcm p q).u (vx, vy) (upd_x vx, vy));
+  (upd_x vx, vy)
+  *)
+  
+  (*
+  change_slprop (pts_to r (Ghost.reveal x, Ghost.reveal y)) (pts_to r (Ghost.reveal (Ghost.hide (Ghost.reveal x, Ghost.reveal y)))) (fun _ -> ());
+  upd_gen r (Ghost.hide (Ghost.reveal x, Ghost.reveal y)) (Ghost.hide (Ghost.reveal x', Ghost.reveal y)) upd;
+  change_slprop (pts_to r (Ghost.reveal (Ghost.hide (Ghost.reveal x', Ghost.reveal y)))) (pts_to r (Ghost.reveal x', Ghost.reveal y)) (fun _ -> ())*)
 
 /// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
 
@@ -79,7 +294,6 @@ let prod_pcm' #a f p = FStar.PCM.({
   one = prod_one f p;
 })
 
-open FStar.Classical
 val prod_comm :
   f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
   x:restricted_t 'a f ->
@@ -191,3 +405,125 @@ let union_pcm #a f p = FStar.PCM.({
     | None -> True
     | Some (|xa, xb|) -> (p xa).refine xb /\ ~(xb == (p xa).p.one))
 })
+
+
+(*
+val upd_gen (#a:Type) (#p:pcm a) (r:ref a p) (x y:Ghost.erased a)
+            (f:FStar.PCM.frame_preserving_upd p x y)
+  : SteelT unit
+           (pts_to r x)
+           (fun _ -> pts_to r y)
+           *)
+
+(*
+let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
+  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
+= let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) =
+    fun old_v ->
+      match old_v with
+      | First _ -> First y
+      | Both _ z -> Both y z
+  in
+  change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
+  upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
+  change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
+  *)
+
+(*
+val prod_upd :
+  #a:eqtype -> f:(a -> Type) -> 
+  field:a -> y: f field -> xs: restricted_t a f -> 
+  restricted_t a f
+let prod_upd #a f field y xs =
+  on_domain a (fun field' -> if field = field' then y else xs field')
+
+let frame_preserving_upd #a (p:pcm a) (x y:a) =
+  f: (v:a{compatible p x v}
+      -> Tot (z:a{
+                compatible p y z /\
+                 (p.refine v ==> p.refine z) /\
+                 (p.refine v ==> frame_preserving p v z)}))
+  {
+     forall (v:a{compatible p x v}).
+         let z = f v in
+         (forall (frame:a). {:pattern (composable p v frame)}
+              composable p v frame ==>
+              composable p z frame /\
+              (compatible p x (op p v frame) ==> (op p z frame == f (op p v frame))))
+  }
+
+val frame_preserving_upd_field :
+  #a:eqtype -> f:(a -> Type) -> p:(field:a -> pcm (f field)) ->
+  field:a -> x: f field -> y: f field ->
+  xs: restricted_t a f {xs field == x} ->
+  frame_preserving_upd (p field) x y ->
+  frame_preserving_upd (prod_pcm f p) xs (update f field y xs)
+let frame_preserving_upd_field #a f p field x y xs upd =
+  _
+  *)
+
+(*
+val update : ...
+
+val upd_field :
+  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  r:ref (restricted_t 'a f) (prod_pcm f p) ->
+  field: 'a -> values: Ghost.erased (restricted_t 'a f{defined only at one field}) ->
+  x: Ghost.erased (f field) -> y: f field ->
+  (frame_preserving_upd_0 (p field) x y) ->
+  SteelT unit (pts_to r (Ghost.reveal values))
+              (fun _ -> pts_to r (update field y values))
+
+let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
+  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
+let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) = fun old_v ->
+    match old_v with
+    | First _ -> First y
+    | Both _ z -> Both y z
+in change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
+   upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
+   change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
+
+
+let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
+  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
+= let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) = fun old_v ->
+    match old_v with
+    | First _ -> First y
+    | Both _ z -> Both y z
+in change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
+   upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
+   change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
+
+
+let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
+  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
+= let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) = fun old_v ->
+    match old_v with
+    | First _ -> First y
+    | Both _ z -> Both y z
+in change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
+   upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
+   change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
+
+
+// TODO frame-preserving updates
+// move 2d point along x
+// move 2d point along y
+// given a function "incrementX" and "incrementY"; write a function that calls it in a loop
+
+// union examples
+// 2d & 3d point
+// rgb / hsv
+
+// next examples:
+//   swap 2 3d points with a helper function
+//   union where discrimnant is not just a tag, but some predicate
+
+// { f field_x = Full .. }
+// { p `pts_to` f } 
+//   addr_of p field_x
+// { fun q -> (p `pts_to` f \ x) `star` (q `pts_to` x) }
+// 
+// let q = addr_of p field_x
+*)

From 3053d1b8eb13ce785575f220062edba1b71381fa Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 14 Jun 2021 14:28:27 -0700
Subject: [PATCH 004/513] Tidy up

---
 examples/steel/ProductPCM.fst | 428 ++++++++--------------------------
 1 file changed, 99 insertions(+), 329 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index 116220334d3..25a8109821a 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -79,40 +79,15 @@ let tuple_comp p q (xa, xb) (ya, yb) = composable p xa ya /\ composable q xb yb
 val tuple_op : p: pcm 'a -> q: pcm 'b -> x:('a & 'b) -> y:('a & 'b){tuple_comp p q x y} -> 'a & 'b
 let tuple_op p q (xa, xb) (ya, yb) = (op p xa ya, op q xb yb)
 
-// val full : pcm' 'a -> 'a -> prop
-// let full #a p x = forall (frame:a{p.composable frame x}). p.op frame x == x
-
-(* This product construction needs some additional assumptions in order to work: *)
-noeq type refined_pcm a = {
-  u: pcm a;
-  (* The unit is the unique "least element" of the preorder defined by
-     [compatible]. (i.e., nothing can be "inside of" or "have less
-     information than" the unit of the PCM) *)
-  compat_unit_unique : x:a ->
-    Lemma (compatible u x u.p.one ==> x == u.p.one);
-// (* refine says that an element is either unit or a full value *)
-// refine_unit_or_full : x:a ->
-//   Lemma (u.refine x == (x == u.p.one \/ full u.p x));
+val tuple_pcm : pcm 'a -> pcm 'b -> pcm ('a & 'b)
+let tuple_pcm #a #b p q = {
+  p = {composable = tuple_comp p q; op = tuple_op p q; one = (p.p.one, q.p.one)};
+  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
+  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
+  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
+  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
+  refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
 }
-  
-val tuple_pcm : refined_pcm 'a -> refined_pcm 'b -> refined_pcm ('a & 'b)
-let tuple_pcm #a #b p q =
-  let p' = FStar.PCM.({
-    composable = tuple_comp p.u q.u;
-    op = tuple_op p.u q.u;
-    one = (p.u.p.one, q.u.p.one)
-  }) in
-  let u = FStar.PCM.({
-    p = p';
-    comm = (fun (xa, xb) (ya, yb) -> p.u.comm xa ya; q.u.comm xb yb);
-    assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.u.assoc xa ya za; q.u.assoc xb yb zb);
-    assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.u.assoc_r xa ya za; q.u.assoc_r xb yb zb);
-    is_unit = (fun (xa, xb) -> p.u.is_unit xa; q.u.is_unit xb);
-    refine = (fun (xa, xb) -> (xa, xb) == p'.one \/ (p.u.refine xa /\ q.u.refine xb))
-  }) in {
-    u = u;
-    compat_unit_unique = (fun (xa, xb) -> p.compat_unit_unique xa; q.compat_unit_unique xb)
-  }
 
 open Steel.Memory
 open Steel.Effect.Atomic
@@ -125,124 +100,36 @@ module T = FStar.Tactics
 /// tuple PCM from frame-preserving updates on its components:
 
 val compatible_tuple_l :
-  p: refined_pcm 'a -> q: refined_pcm 'b ->
+  p: pcm 'a -> q: pcm 'b ->
   x: 'a -> v: 'a -> y: 'b -> w: 'b ->
   Lemma 
-    (requires compatible p.u x v /\ compatible q.u y w)
-    (ensures compatible (tuple_pcm p q).u (x, y) (v, w))
+    (requires compatible p x v /\ compatible q y w)
+    (ensures compatible (tuple_pcm p q) (x, y) (v, w))
 let compatible_tuple_l p q x v y w =
-  let pqu = (tuple_pcm p q).u in
+  let pq = tuple_pcm p q in
   let aux frame_x frame_y :
     Lemma 
-      (requires composable pqu (x, y) (frame_x, frame_y) /\
-                op pqu (frame_x, frame_y) (x, y) == (v, w))
-      (ensures compatible pqu (x, y) (v, w))
-      [SMTPat (composable p.u x frame_x); SMTPat (composable q.u y frame_y)] =
-    ()
+      (requires composable pq (x, y) (frame_x, frame_y) /\
+                op pq (frame_x, frame_y) (x, y) == (v, w))
+      (ensures compatible pq (x, y) (v, w))
+      [SMTPat (composable p x frame_x); SMTPat (composable q y frame_y)] = ()
   in ()
 
 val upd_fst :
-  p: refined_pcm 'a -> q: refined_pcm 'b ->
-  x: 'a {~ (x == p.u.p.one)} -> y: 'b -> x': 'a ->
-  frame_preserving_upd p.u x x' ->
-  frame_preserving_upd (tuple_pcm p q).u (x, y) (x', y)
+  p: pcm 'a -> q: pcm 'b ->
+  x: 'a -> y: 'b -> x': 'a ->
+  frame_preserving_upd p x x' ->
+  frame_preserving_upd (tuple_pcm p q) (x, y) (x', y)
 let upd_fst #a #b p q x y x' f (va, vb) =
-  p.compat_unit_unique x;
   let wa = f va in
-  let pqu = (tuple_pcm p q).u in
+  let pq = tuple_pcm p q in
   compatible_tuple_l p q x' wa y vb;
-  let lemma (frame: (a & b) {composable pqu (x, y) frame}):
-    Lemma (composable pqu (x', y) frame /\
-           (op pqu (x, y) frame == (va, vb) ==> op pqu (x', y) frame == (wa, vb)))
-    [SMTPat (composable pqu (x, y) frame)] = ()
+  let lemma (frame: (a & b) {composable pq (x, y) frame}):
+    Lemma (composable pq (x', y) frame /\
+           (op pq (x, y) frame == (va, vb) ==> op pq (x', y) frame == (wa, vb)))
+    [SMTPat (composable pq (x, y) frame)] = ()
   in (wa, vb)
 
-(*
-val upd_fst_0 :
-  p: refined_pcm 'a -> q: refined_pcm 'b ->
-  r: ref ('a & 'b) (tuple_pcm p q).u ->
-  x: Ghost.erased 'a {~ (Ghost.reveal x == p.u.p.one)} -> y: Ghost.erased 'b -> x': 'a ->
-  frame_preserving_upd p.u x x' ->
-  frame_preserving_upd (tuple_pcm p q).u (Ghost.reveal x, Ghost.reveal y) (x', Ghost.reveal y)
-let upd_fst_0 p q r x y x' upd_x (vx, vy) =
-  assume (compatible (tuple_pcm p q).u (x', Ghost.reveal y) (upd_x vx, vy));
-  // Since x != 1 and compatible x vx, vx != 1 by compat_unit_unique.
-  assert (compatible p.u (Ghost.reveal x) vx);
-  p.compat_unit_unique (Ghost.reveal x);
-  assert (~ (vx == p.u.p.one));
-  // Thus, if refine (vx, vy), vx and vy must be full values.
-  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (vx, vy));
-  full_tup p q vx vy;
-  // A frame-preserving update sends full values to full values, so (upd_x vx, vy) is full too.
-  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full q.u.p vy); (* TODO why doesn't this work? *)
-  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full p.u.p vx); (* TODO why doesn't this work? *)
-  assume (full p.u.p (upd_x vx)); (* can't be unit because upd_x is frame_preserving and vx != unit *)
-  full_tup p q (upd_x vx) vy;
-  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (upd_x vx, vy));
-  assert ((tuple_pcm p q).u.refine (vx, vy) ==> (tuple_pcm p q).u.refine (upd_x vx, vy));
-  assume ((tuple_pcm p q).u.refine (vx, vy) ==> frame_preserving (tuple_pcm p q).u (vx, vy) (upd_x vx, vy));
-  (upd_x vx, vy)
-*)
-
-(*
-val full_tup :
-  p: refined_pcm 'a -> q: refined_pcm 'b -> x: 'a -> y: 'b ->
-  full (tuple_pcm p q).u.p (x, y) == full p.u.p x /\ full q.u.p y
-let full_tup p q x y =
-  (* (forall (x', y') composable with (x, y). (x <> x', y <> y') = (x, y))
-     <=> (forall x' comp w/ x and y' comp w/ y. x <> x' = x /\ y <> y' = y)
-     <=> (forall x' comp w/ x. x <> x' = x) /\ (forall y' comp w/. y <> y' = y) *)
-  admit() (* TODO how to prove this? *)
-  *)
-
-(*
-val frame_preserving_full_value :
-  p: refined_pcm 'a -> x: 'a -> y: 'a ->
-  f:frame_preserving_upd_0 p.u x y ->
-  Lemma (requires full p.u.p x) (ensures full p.u.p (f v))
-let frame_preserving_full_value #a p x y f =
-  compatible_refl p.u x;
-  p.refine_unit_or_full x;
-  assert (p.u.refine x);
-  let z = f x in
-  assert (p.u.refine z);
-  assert (frame_preserving p.u x z);
-  assume (forall (frame:a{composable p.u frame z}). op p.u frame z == z);
-  admit()
-  *)
-
-(*
-val upd_fst_0 :
-  p: refined_pcm 'a -> q: refined_pcm 'b ->
-  r: ref ('a & 'b) (tuple_pcm p q).u ->
-  x: Ghost.erased 'a {~ (Ghost.reveal x == p.u.p.one)} -> y: Ghost.erased 'b -> x': 'a ->
-  frame_preserving_upd_0 p.u x x' ->
-  frame_preserving_upd_0 (tuple_pcm p q).u (Ghost.reveal x, Ghost.reveal y) (x', Ghost.reveal y)
-let upd_fst_0 p q r x y x' upd_x (vx, vy) =
-  assume (compatible (tuple_pcm p q).u (x', Ghost.reveal y) (upd_x vx, vy));
-  // Since x != 1 and compatible x vx, vx != 1 by compat_unit_unique.
-  assert (compatible p.u (Ghost.reveal x) vx);
-  p.compat_unit_unique (Ghost.reveal x);
-  assert (~ (vx == p.u.p.one));
-  // Thus, if refine (vx, vy), vx and vy must be full values.
-  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (vx, vy));
-  full_tup p q vx vy;
-  // A frame-preserving update sends full values to full values, so (upd_x vx, vy) is full too.
-  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full q.u.p vy); (* TODO why doesn't this work? *)
-  assume ((tuple_pcm p q).u.refine (vx, vy) ==> full p.u.p vx); (* TODO why doesn't this work? *)
-  assume (full p.u.p (upd_x vx)); (* can't be unit because upd_x is frame_preserving and vx != unit *)
-  full_tup p q (upd_x vx) vy;
-  assert ((tuple_pcm p q).u.refine (vx, vy) ==> full (tuple_pcm p q).u.p (upd_x vx, vy));
-  assert ((tuple_pcm p q).u.refine (vx, vy) ==> (tuple_pcm p q).u.refine (upd_x vx, vy));
-  assume ((tuple_pcm p q).u.refine (vx, vy) ==> frame_preserving (tuple_pcm p q).u (vx, vy) (upd_x vx, vy));
-  (upd_x vx, vy)
-  *)
-  
-  (*
-  change_slprop (pts_to r (Ghost.reveal x, Ghost.reveal y)) (pts_to r (Ghost.reveal (Ghost.hide (Ghost.reveal x, Ghost.reveal y)))) (fun _ -> ());
-  upd_gen r (Ghost.hide (Ghost.reveal x, Ghost.reveal y)) (Ghost.hide (Ghost.reveal x', Ghost.reveal y)) upd;
-  change_slprop (pts_to r (Ghost.reveal (Ghost.hide (Ghost.reveal x', Ghost.reveal y)))) (pts_to r (Ghost.reveal x', Ghost.reveal y)) (fun _ -> ())*)
-
 /// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
 
 val opt_comp : option 'a -> option 'a -> prop
@@ -252,117 +139,106 @@ val opt_op : x:option 'a -> y:option 'a {opt_comp x y} -> option 'a
 let opt_op x y = match x, y with None, z | z, None -> z
 
 val opt_pcm : pcm (option 'a)
-let opt_pcm #a = FStar.PCM.({
-  p = {
-    composable=opt_comp;
-    op=opt_op;
-    one=None
-  };
+let opt_pcm #a = {
+  p = {composable = opt_comp; op = opt_op; one = None};
   comm = (fun _ _ -> ());
   assoc = (fun _ _ _ -> ());
   assoc_r = (fun _ _ _ -> ());
   is_unit = (fun _ -> ());
   refine = (fun _ -> True);
-})
+}
 
 /// We can generalize to 'a-ary products (z:'a -> f z), given a PCM for each z:
 
 open FStar.FunctionalExtensionality
 
 val prod_comp :
-  f:('a -> Type) -> (z:'a -> pcm (f z)) ->
+  #f:('a -> Type) -> (z:'a -> pcm (f z)) ->
   restricted_t 'a f -> restricted_t 'a f -> prop
-let prod_comp f p x y = forall z. composable (p z) (x z) (y z)
+let prod_comp p x y = forall z. composable (p z) (x z) (y z)
 
 val prod_op :
-  f:('a -> Type) -> p:(z:'a -> pcm (f z)) -> 
-  x:restricted_t 'a f -> y: restricted_t 'a f {prod_comp f p x y} -> 
+  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) -> 
+  x:restricted_t 'a f -> y: restricted_t 'a f {prod_comp p x y} -> 
   restricted_t 'a f
-let prod_op #a f p x y = on_domain a (fun z -> op (p z) (x z) (y z))
-
-val prod_one : f:('a -> Type) -> (z:'a -> pcm (f z)) -> restricted_t 'a f
-let prod_one f p = on_domain _ (fun z -> (p z).p.one)
+let prod_op #a p x y = on_domain a (fun z -> op (p z) (x z) (y z))
 
-let ext (a: Type) (b: (a -> Type)) (f g: restricted_t a b)
-  : Lemma (ensures (feq #a #b f g <==> f == g))
-= extensionality a b f g
+val prod_one : #f:('a -> Type) -> (z:'a -> pcm (f z)) -> restricted_t 'a f
+let prod_one #a p = on_domain a (fun z -> (p z).p.one)
 
-val prod_pcm' : f:('a -> Type) -> (z:'a -> pcm (f z)) -> pcm' (restricted_t 'a f)
-let prod_pcm' #a f p = FStar.PCM.({
-  composable = prod_comp f p;
-  op = prod_op f p;
-  one = prod_one f p;
-})
+val ext :
+  #b: ('a -> Type) -> f: restricted_t 'a b -> g: restricted_t 'a b -> 
+  (x: 'a -> Lemma (f x == g x)) ->
+  Lemma (ensures (f == g))
+let ext #a #b f g fg =
+  extensionality a b f g;
+  forall_intro fg
 
 val prod_comm :
-  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
   x:restricted_t 'a f ->
-  y:restricted_t 'a f {prod_comp f p x y} ->
-  Lemma (prod_op f p x y == prod_op f p y x)
-let prod_comm #a f p x y =
-  let comm (z:a): Lemma ((p z).p.op (x z) (y z) == (p z).p.op (y z) (x z)) =
-    (p z).comm (x z) (y z)
-  in forall_intro comm;
-  ext a f (prod_op f p x y) (prod_op f p y x)
+  y:restricted_t 'a f {prod_comp p x y} ->
+  Lemma (prod_op p x y == prod_op p y x)
+let prod_comm p x y =
+  ext (prod_op p x y) (prod_op p y x) (fun z -> (p z).comm (x z) (y z))
 
 val prod_assoc :
-  f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
-  x:restricted_t 'a f ->
-  y:restricted_t 'a f ->
-  z:restricted_t 'a f {prod_comp f p y z /\ prod_comp f p x (prod_op f p y z)} ->
-  Lemma (prod_comp f p x y /\
-         prod_comp f p (prod_op f p x y) z /\
-         prod_op f p x (prod_op f p y z) == prod_op f p (prod_op f p x y) z)
-let prod_assoc #a f p x y z =
-  let assoc (w:a): 
+  #f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
+  x:restricted_t 'a f -> y:restricted_t 'a f ->
+  z:restricted_t 'a f {prod_comp p y z /\ prod_comp p x (prod_op p y z)} ->
+  Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+let prod_assoc p x y z =
+  let aux w :
     Lemma (composable (p w) (x w) (y w) /\
-           composable (p w) (op (p w) (x w) (y w)) (z w) /\
-           op (p w) (x w) (op (p w) (y w) (z w)) == op (p w) (op (p w) (x w) (y w)) (z w)) 
-  = (p w).assoc (x w) (y w) (z w) in
-  forall_intro assoc;
-  ext a f (prod_op f p x (prod_op f p y z)) (prod_op f p (prod_op f p x y) z)
+           composable (p w) (op (p w) (x w) (y w)) (z w)) 
+    [SMTPat (p w)] = (p w).assoc (x w) (y w) (z w)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun w -> (p w).assoc (x w) (y w) (z w))
 
 val prod_assoc_r :
-  f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
-  x:restricted_t 'a f ->
-  y:restricted_t 'a f ->
-  z:restricted_t 'a f {prod_comp f p x y /\ prod_comp f p (prod_op f p x y) z} ->
-  Lemma (prod_comp f p y z /\
-         prod_comp f p x (prod_op f p y z) /\
-         prod_op f p x (prod_op f p y z) == prod_op f p (prod_op f p x y) z)
-let prod_assoc_r #a f p x y z =
-  let assoc_r (w:a): 
+  #f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
+  x:restricted_t 'a f -> y:restricted_t 'a f ->
+  z:restricted_t 'a f {prod_comp p x y /\ prod_comp p (prod_op p x y) z} ->
+  Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+let prod_assoc_r #a p x y z =
+  let aux w : 
     Lemma (composable (p w) (y w) (z w) /\
-           composable (p w) (x w) (op (p w) (y w) (z w)) /\
-           op (p w) (x w) (op (p w) (y w) (z w)) == op (p w) (op (p w) (x w) (y w)) (z w)) 
-  = (p w).assoc_r (x w) (y w) (z w) in
-  forall_intro assoc_r;
-  ext a f (prod_op f p x (prod_op f p y z)) (prod_op f p (prod_op f p x y) z)
+           composable (p w) (x w) (op (p w) (y w) (z w)))
+    [SMTPat (p w)] = (p w).assoc_r (x w) (y w) (z w)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun w -> (p w).assoc (x w) (y w) (z w))
 
 val prod_is_unit :
-  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
   x:restricted_t 'a f ->
-  Lemma (prod_comp f p x (prod_one f p) /\
-         prod_op f p x (prod_one f p) == x)
-let prod_is_unit #a f p x =
-  let is_unit (y:a): 
-    Lemma (composable (p y) (x y) (prod_one f p y) /\
-           op (p y) (x y) (prod_one f p y) == x y)
-  = (p y).is_unit (x y) in
-  forall_intro is_unit;
-  ext a f (prod_op f p x (prod_one f p)) x
-
-val prod_pcm : f:('a -> Type) -> (z:'a -> pcm (f z)) -> pcm (restricted_t 'a f)
-let prod_pcm #a f p = FStar.PCM.({
-  p = prod_pcm' f p;
-  comm = prod_comm f p;
-  assoc = prod_assoc f p;
-  assoc_r = prod_assoc_r f p;
-  is_unit = prod_is_unit f p;
-  refine = (fun x ->
-    (forall z. x z == (p z).p.one) \/
-    (forall z. (p z).refine (x z) /\ ~ (x z == (p z).p.one)))
-})
+  Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+let prod_is_unit #a p x =
+  let is_unit y :
+    Lemma (composable (p y) (x y) (prod_one p y))
+    [SMTPat (p y)] = (p y).is_unit (x y)
+  in ext (prod_op p x (prod_one p)) x (fun y -> (p y).is_unit (x y))
+
+val prod_refine :
+  #f:('a -> Type) -> (y:'a -> pcm (f y)) ->
+  x: restricted_t 'a f -> prop
+let prod_refine p x = forall y. (p y).refine (x y)
+
+val prod_pcm : #f:('a -> Type) -> (z:'a -> pcm (f z)) -> pcm (restricted_t 'a f)
+let prod_pcm #a #f p = {
+  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  comm = prod_comm p;
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
 
 /// Similarly, given a PCM for each z:a, we can model a-ary unions with an PCM for option (x:a & f x), where
 /// - None is the unit of the PCM
@@ -386,11 +262,7 @@ let union_op f p x y = match x, y with
 
 val union_pcm : f:('a -> Type) -> p:(x: 'a -> pcm (f x)) -> pcm (union 'a f p)
 let union_pcm #a f p = FStar.PCM.({
-  p = {
-    composable=union_comp f p;
-    op=union_op f p;
-    one=None
-  };
+  p = {composable = union_comp f p; op = union_op f p; one = None};
   comm = (fun x y -> match x, y with
     | None, _ | _, None -> ()
     | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
@@ -401,113 +273,11 @@ let union_pcm #a f p = FStar.PCM.({
     | None, _, _ | _, _, None | _, None, _ -> ()
     | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
   is_unit = (fun _ -> ());
-  refine = (fun x -> match x with
-    | None -> True
-    | Some (|xa, xb|) -> (p xa).refine xb /\ ~(xb == (p xa).p.one))
+  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
 })
 
-
-(*
-val upd_gen (#a:Type) (#p:pcm a) (r:ref a p) (x y:Ghost.erased a)
-            (f:FStar.PCM.frame_preserving_upd p x y)
-  : SteelT unit
-           (pts_to r x)
-           (fun _ -> pts_to r y)
-           *)
-
 (*
-let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
-  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
-= let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) =
-    fun old_v ->
-      match old_v with
-      | First _ -> First y
-      | Both _ z -> Both y z
-  in
-  change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
-  upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
-  change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
-  *)
-
-(*
-val prod_upd :
-  #a:eqtype -> f:(a -> Type) -> 
-  field:a -> y: f field -> xs: restricted_t a f -> 
-  restricted_t a f
-let prod_upd #a f field y xs =
-  on_domain a (fun field' -> if field = field' then y else xs field')
-
-let frame_preserving_upd #a (p:pcm a) (x y:a) =
-  f: (v:a{compatible p x v}
-      -> Tot (z:a{
-                compatible p y z /\
-                 (p.refine v ==> p.refine z) /\
-                 (p.refine v ==> frame_preserving p v z)}))
-  {
-     forall (v:a{compatible p x v}).
-         let z = f v in
-         (forall (frame:a). {:pattern (composable p v frame)}
-              composable p v frame ==>
-              composable p z frame /\
-              (compatible p x (op p v frame) ==> (op p z frame == f (op p v frame))))
-  }
-
-val frame_preserving_upd_field :
-  #a:eqtype -> f:(a -> Type) -> p:(field:a -> pcm (f field)) ->
-  field:a -> x: f field -> y: f field ->
-  xs: restricted_t a f {xs field == x} ->
-  frame_preserving_upd (p field) x y ->
-  frame_preserving_upd (prod_pcm f p) xs (update f field y xs)
-let frame_preserving_upd_field #a f p field x y xs upd =
-  _
-  *)
-
-(*
-val update : ...
-
-val upd_field :
-  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
-  r:ref (restricted_t 'a f) (prod_pcm f p) ->
-  field: 'a -> values: Ghost.erased (restricted_t 'a f{defined only at one field}) ->
-  x: Ghost.erased (f field) -> y: f field ->
-  (frame_preserving_upd_0 (p field) x y) ->
-  SteelT unit (pts_to r (Ghost.reveal values))
-              (fun _ -> pts_to r (update field y values))
-
-let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
-  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
-let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) = fun old_v ->
-    match old_v with
-    | First _ -> First y
-    | Both _ z -> Both y z
-in change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
-   upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
-   change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
-
-
-let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
-  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
-= let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) = fun old_v ->
-    match old_v with
-    | First _ -> First y
-    | Both _ z -> Both y z
-in change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
-   upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
-   change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
-
-
-let upd_first #a #b (r:ref (t a b) pcm_t) (x:Ghost.erased a) (y:a)
-  : SteelT unit (pts_to r (First #a #b x)) (fun _ -> pts_to r (First #a #b y))
-= let f : frame_preserving_upd_0 pcm_t (Ghost.hide (First #a #b x)) (First #a #b y) = fun old_v ->
-    match old_v with
-    | First _ -> First y
-    | Both _ z -> Both y z
-in change_slprop (pts_to r (First (Ghost.reveal x))) (pts_to r (Ghost.reveal (Ghost.hide (First (Ghost.reveal x))))) (fun _ -> ());
-   upd_gen r (Ghost.hide (First #a #b x)) (Ghost.hide (First #a #b y)) f;
-   change_slprop (pts_to r (Ghost.reveal (Ghost.hide (First y)))) (pts_to r (First y)) (fun _ -> ())
-
-
-// TODO frame-preserving updates
+// TODO
 // move 2d point along x
 // move 2d point along y
 // given a function "incrementX" and "incrementY"; write a function that calls it in a loop

From 86a8055432086ba7d946ada949fd70f2ecc28d4e Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 14 Jun 2021 14:39:24 -0700
Subject: [PATCH 005/513] Tidy 2

---
 examples/steel/ProductPCM.fst | 73 +++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 30 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index 25a8109821a..a6f4bfaae2a 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -124,7 +124,7 @@ let upd_fst #a #b p q x y x' f (va, vb) =
   let wa = f va in
   let pq = tuple_pcm p q in
   compatible_tuple_l p q x' wa y vb;
-  let lemma (frame: (a & b) {composable pq (x, y) frame}):
+  let aux (frame: (a & b) {composable pq (x, y) frame}):
     Lemma (composable pq (x', y) frame /\
            (op pq (x, y) frame == (va, vb) ==> op pq (x', y) frame == (wa, vb)))
     [SMTPat (composable pq (x, y) frame)] = ()
@@ -148,23 +148,23 @@ let opt_pcm #a = {
   refine = (fun _ -> True);
 }
 
-/// We can generalize to 'a-ary products (z:'a -> f z), given a PCM for each z:
+/// We can generalize to 'a-ary products (k:'a -> f k), given a PCM for each k:
 
 open FStar.FunctionalExtensionality
 
 val prod_comp :
-  #f:('a -> Type) -> (z:'a -> pcm (f z)) ->
+  #f:('a -> Type) -> (k:'a -> pcm (f k)) ->
   restricted_t 'a f -> restricted_t 'a f -> prop
-let prod_comp p x y = forall z. composable (p z) (x z) (y z)
+let prod_comp p x y = forall k. composable (p k) (x k) (y k)
 
 val prod_op :
-  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) -> 
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) -> 
   x:restricted_t 'a f -> y: restricted_t 'a f {prod_comp p x y} -> 
   restricted_t 'a f
-let prod_op #a p x y = on_domain a (fun z -> op (p z) (x z) (y z))
+let prod_op #a p x y = on_domain a (fun k -> op (p k) (x k) (y k))
 
-val prod_one : #f:('a -> Type) -> (z:'a -> pcm (f z)) -> restricted_t 'a f
-let prod_one #a p = on_domain a (fun z -> (p z).p.one)
+val prod_one : #f:('a -> Type) -> (k:'a -> pcm (f k)) -> restricted_t 'a f
+let prod_one #a p = on_domain a (fun k -> (p k).p.one)
 
 val ext :
   #b: ('a -> Type) -> f: restricted_t 'a b -> g: restricted_t 'a b -> 
@@ -175,62 +175,62 @@ let ext #a #b f g fg =
   forall_intro fg
 
 val prod_comm :
-  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
   x:restricted_t 'a f ->
   y:restricted_t 'a f {prod_comp p x y} ->
   Lemma (prod_op p x y == prod_op p y x)
 let prod_comm p x y =
-  ext (prod_op p x y) (prod_op p y x) (fun z -> (p z).comm (x z) (y z))
+  ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
 
 val prod_assoc :
-  #f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
   x:restricted_t 'a f -> y:restricted_t 'a f ->
   z:restricted_t 'a f {prod_comp p y z /\ prod_comp p x (prod_op p y z)} ->
   Lemma (prod_comp p x y /\
          prod_comp p (prod_op p x y) z /\
          prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
 let prod_assoc p x y z =
-  let aux w :
-    Lemma (composable (p w) (x w) (y w) /\
-           composable (p w) (op (p w) (x w) (y w)) (z w)) 
-    [SMTPat (p w)] = (p w).assoc (x w) (y w) (z w)
+  let aux k :
+    Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)] = (p k).assoc (x k) (y k) (z k)
   in
   ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun w -> (p w).assoc (x w) (y w) (z w))
+    (fun k -> (p k).assoc (x k) (y k) (z k))
 
 val prod_assoc_r :
-  #f:('a -> Type) -> p:(w:'a -> pcm (f w)) ->
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
   x:restricted_t 'a f -> y:restricted_t 'a f ->
   z:restricted_t 'a f {prod_comp p x y /\ prod_comp p (prod_op p x y) z} ->
   Lemma (prod_comp p y z /\
          prod_comp p x (prod_op p y z) /\
          prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
 let prod_assoc_r #a p x y z =
-  let aux w : 
-    Lemma (composable (p w) (y w) (z w) /\
-           composable (p w) (x w) (op (p w) (y w) (z w)))
-    [SMTPat (p w)] = (p w).assoc_r (x w) (y w) (z w)
+  let aux k : 
+    Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)] = (p k).assoc_r (x k) (y k) (z k)
   in
   ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun w -> (p w).assoc (x w) (y w) (z w))
+    (fun k -> (p k).assoc (x k) (y k) (z k))
 
 val prod_is_unit :
-  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
   x:restricted_t 'a f ->
   Lemma (prod_comp p x (prod_one p) /\
          prod_op p x (prod_one p) == x)
 let prod_is_unit #a p x =
-  let is_unit y :
-    Lemma (composable (p y) (x y) (prod_one p y))
-    [SMTPat (p y)] = (p y).is_unit (x y)
-  in ext (prod_op p x (prod_one p)) x (fun y -> (p y).is_unit (x y))
+  let is_unit k :
+    Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)] = (p k).is_unit (x k)
+  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
 
 val prod_refine :
-  #f:('a -> Type) -> (y:'a -> pcm (f y)) ->
+  #f:('a -> Type) -> (k:'a -> pcm (f k)) ->
   x: restricted_t 'a f -> prop
-let prod_refine p x = forall y. (p y).refine (x y)
+let prod_refine p x = forall k. (p k).refine (x k)
 
-val prod_pcm : #f:('a -> Type) -> (z:'a -> pcm (f z)) -> pcm (restricted_t 'a f)
+val prod_pcm : #f:('a -> Type) -> (k:'a -> pcm (f k)) -> pcm (restricted_t 'a f)
 let prod_pcm #a #f p = {
   p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
   comm = prod_comm p;
@@ -240,6 +240,19 @@ let prod_pcm #a #f p = {
   refine = prod_refine p
 }
 
+/// Now, we can define frame-preserving updates of all components at once:
+
+val update :
+  #a:eqtype -> #f:(a -> Type) -> k:a -> x': f k ->
+  restricted_t a f -> restricted_t a f
+let update #a k x' f = on_domain a (fun k' -> if k = k' then x' else f k')
+
+val prod_upd :
+  #a:eqtype -> #f:(a -> Type) -> p:(k:a -> pcm (f k)) ->
+  k:a -> xs: restricted_t a f -> x: f k -> x': f k ->
+  frame_preserving_upd (p k) x x' ->
+  frame_preserving_upd (prod_pcm p) xs (update k x' xs)
+
 /// Similarly, given a PCM for each z:a, we can model a-ary unions with an PCM for option (x:a & f x), where
 /// - None is the unit of the PCM
 /// - Some (x, y) is a union with tag x and content y

From 5c1a75d1e216f00e63b58f6a4d65e7be02c9bdf8 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 14 Jun 2021 16:11:47 -0700
Subject: [PATCH 006/513] n-ary frame-preserving updates

---
 examples/steel/ProductPCM.fst | 83 +++++++++++++++++++++++------------
 1 file changed, 54 insertions(+), 29 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index a6f4bfaae2a..aa32a3e5293 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -89,16 +89,33 @@ let tuple_pcm #a #b p q = {
   refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
 }
 
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+val opt_comp : option 'a -> option 'a -> prop
+let opt_comp x y = match x, y with None, _ | _, None -> True | _ -> False
+
+val opt_op : x:option 'a -> y:option 'a {opt_comp x y} -> option 'a
+let opt_op x y = match x, y with None, z | z, None -> z
+
+val opt_pcm : pcm (option 'a)
+let opt_pcm #a = {
+  p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun _ -> True);
+}
+
+/// With the alternative definition of frame-preserving updates, we
+/// can define frame-preserving updates for a tuple PCM from
+/// frame-preserving updates on its components. For example, to define
+/// a frame-preserving update on the first component:
+
 open Steel.Memory
 open Steel.Effect.Atomic
 open Steel.Effect
 
-module T = FStar.Tactics
-
-/// With the alternative definition of frame-preserving updates and
-/// compat_unit_unique, we can define frame-preserving updates for a
-/// tuple PCM from frame-preserving updates on its components:
-
 val compatible_tuple_l :
   p: pcm 'a -> q: pcm 'b ->
   x: 'a -> v: 'a -> y: 'b -> w: 'b ->
@@ -130,25 +147,9 @@ let upd_fst #a #b p q x y x' f (va, vb) =
     [SMTPat (composable pq (x, y) frame)] = ()
   in (wa, vb)
 
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-val opt_comp : option 'a -> option 'a -> prop
-let opt_comp x y = match x, y with None, _ | _, None -> True | _ -> False
-
-val opt_op : x:option 'a -> y:option 'a {opt_comp x y} -> option 'a
-let opt_op x y = match x, y with None, z | z, None -> z
-
-val opt_pcm : pcm (option 'a)
-let opt_pcm #a = {
-  p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun _ -> True);
-}
-
-/// We can generalize to 'a-ary products (k:'a -> f k), given a PCM for each k:
+/// Frame-preserving updates on the second component can be done similarly.
+/// To avoid having to write a frame-preserving update for each field separately,
+/// we generalize to 'a-ary products (k:'a -> f k), given a PCM for each k:
 
 open FStar.FunctionalExtensionality
 
@@ -240,7 +241,7 @@ let prod_pcm #a #f p = {
   refine = prod_refine p
 }
 
-/// Now, we can define frame-preserving updates of all components at once:
+/// Now, we can define frame-preserving updates for all fields at once:
 
 val update :
   #a:eqtype -> #f:(a -> Type) -> k:a -> x': f k ->
@@ -249,9 +250,33 @@ let update #a k x' f = on_domain a (fun k' -> if k = k' then x' else f k')
 
 val prod_upd :
   #a:eqtype -> #f:(a -> Type) -> p:(k:a -> pcm (f k)) ->
-  k:a -> xs: restricted_t a f -> x: f k -> x': f k ->
-  frame_preserving_upd (p k) x x' ->
-  frame_preserving_upd (prod_pcm p) xs (update k x' xs)
+  k:a -> xs: restricted_t a f -> y: f k ->
+  frame_preserving_upd (p k) (xs k) y ->
+  frame_preserving_upd (prod_pcm p) xs (update k y xs)
+let prod_upd #a #f_ty p k xs y f vs =
+  let ws_k = f (vs k) in
+  let ws = update k ws_k vs in
+  let aux (frame: _{composable (prod_pcm p) xs frame}) :
+    Lemma
+      // TODO unclear why it works to hoist this assumption,
+      // because goal contains (forall .., P /\ (Q ==> R))
+      // but this only proves (forall .., Q ==> P /\ R)
+      (requires op (prod_pcm p) xs frame == vs)
+      (ensures
+         composable (prod_pcm p) (update k y xs) frame /\
+         op (prod_pcm p) (update k y xs) frame == ws)
+    [SMTPat (composable (prod_pcm p) xs frame)]
+  = assert (composable (prod_pcm p) (update k y xs) frame);
+    ext (op (prod_pcm p) (update k y xs) frame) ws (fun k' -> ())
+  in
+  let compat_ws_k : squash (compatible (p k) y ws_k) = () in
+  let compat_vs : squash (compatible (prod_pcm p) xs vs) = () in
+  let compat_ws_ty = squash (compatible (prod_pcm p) (update k y xs) ws) in
+  exists_elim compat_ws_ty compat_ws_k (fun frame_k ->
+  exists_elim compat_ws_ty compat_vs (fun frame_rest ->
+  let frame = update k frame_k frame_rest in
+  ext (op (prod_pcm p) frame (update k y xs)) ws (fun k' -> ())));
+  ws
 
 /// Similarly, given a PCM for each z:a, we can model a-ary unions with an PCM for option (x:a & f x), where
 /// - None is the unit of the PCM

From a088b468b5bf140a49dc8584eee3112fec93aff2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 14 Jun 2021 16:33:47 -0700
Subject: [PATCH 007/513] Tidy

---
 examples/steel/ProductPCM.fst | 45 ++++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index aa32a3e5293..1709b448af3 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -243,19 +243,19 @@ let prod_pcm #a #f p = {
 
 /// Now, we can define frame-preserving updates for all fields at once:
 
-val update :
+val fun_upd :
   #a:eqtype -> #f:(a -> Type) -> k:a -> x': f k ->
   restricted_t a f -> restricted_t a f
-let update #a k x' f = on_domain a (fun k' -> if k = k' then x' else f k')
+let fun_upd #a k x' f = on_domain a (fun k' -> if k = k' then x' else f k')
 
 val prod_upd :
   #a:eqtype -> #f:(a -> Type) -> p:(k:a -> pcm (f k)) ->
   k:a -> xs: restricted_t a f -> y: f k ->
   frame_preserving_upd (p k) (xs k) y ->
-  frame_preserving_upd (prod_pcm p) xs (update k y xs)
+  frame_preserving_upd (prod_pcm p) xs (fun_upd k y xs)
 let prod_upd #a #f_ty p k xs y f vs =
   let ws_k = f (vs k) in
-  let ws = update k ws_k vs in
+  let ws = fun_upd k ws_k vs in
   let aux (frame: _{composable (prod_pcm p) xs frame}) :
     Lemma
       // TODO unclear why it works to hoist this assumption,
@@ -263,44 +263,44 @@ let prod_upd #a #f_ty p k xs y f vs =
       // but this only proves (forall .., Q ==> P /\ R)
       (requires op (prod_pcm p) xs frame == vs)
       (ensures
-         composable (prod_pcm p) (update k y xs) frame /\
-         op (prod_pcm p) (update k y xs) frame == ws)
+         composable (prod_pcm p) (fun_upd k y xs) frame /\
+         op (prod_pcm p) (fun_upd k y xs) frame == ws)
     [SMTPat (composable (prod_pcm p) xs frame)]
-  = assert (composable (prod_pcm p) (update k y xs) frame);
-    ext (op (prod_pcm p) (update k y xs) frame) ws (fun k' -> ())
+  = assert (composable (prod_pcm p) (fun_upd k y xs) frame);
+    ext (op (prod_pcm p) (fun_upd k y xs) frame) ws (fun k' -> ())
   in
   let compat_ws_k : squash (compatible (p k) y ws_k) = () in
   let compat_vs : squash (compatible (prod_pcm p) xs vs) = () in
-  let compat_ws_ty = squash (compatible (prod_pcm p) (update k y xs) ws) in
+  let compat_ws_ty = squash (compatible (prod_pcm p) (fun_upd k y xs) ws) in
   exists_elim compat_ws_ty compat_ws_k (fun frame_k ->
   exists_elim compat_ws_ty compat_vs (fun frame_rest ->
-  let frame = update k frame_k frame_rest in
-  ext (op (prod_pcm p) frame (update k y xs)) ws (fun k' -> ())));
+  let frame = fun_upd k frame_k frame_rest in
+  ext (op (prod_pcm p) frame (fun_upd k y xs)) ws (fun k' -> ())));
   ws
 
 /// Similarly, given a PCM for each z:a, we can model a-ary unions with an PCM for option (x:a & f x), where
 /// - None is the unit of the PCM
 /// - Some (x, y) is a union with tag x and content y
 
-let union (a:Type) (f:a -> Type) (p:(x:a -> pcm (f x))) = option (x:a & f x)
+let union (#f:'a -> Type) (p:(x:'a -> pcm (f x))) = option (x:'a & f x)
 
 val union_comp :
-  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
-  symrel (union 'a f p)
-let union_comp f p x y = match x, y with
+  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  symrel (union p)
+let union_comp p x y = match x, y with
   | None, z | z, None -> True
   | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
 
 val union_op :
-  f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
-  x:union 'a f p -> y:union 'a f p {union_comp f p x y} -> union 'a f p
-let union_op f p x y = match x, y with
+  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
+  x:union p -> y:union p {union_comp p x y} -> union p
+let union_op p x y = match x, y with
   | None, z | z, None -> z
   | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
 
-val union_pcm : f:('a -> Type) -> p:(x: 'a -> pcm (f x)) -> pcm (union 'a f p)
-let union_pcm #a f p = FStar.PCM.({
-  p = {composable = union_comp f p; op = union_op f p; one = None};
+val union_pcm : #f:('a -> Type) -> p:(x: 'a -> pcm (f x)) -> pcm (union p)
+let union_pcm p = {
+  p = {composable = union_comp p; op = union_op p; one = None};
   comm = (fun x y -> match x, y with
     | None, _ | _, None -> ()
     | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
@@ -312,7 +312,8 @@ let union_pcm #a f p = FStar.PCM.({
     | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
   is_unit = (fun _ -> ());
   refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
-})
+}
+
 
 (*
 // TODO

From dba43c01b28b00a4967a2f07dd0094a7b61fce3f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 14 Jun 2021 17:22:35 -0700
Subject: [PATCH 008/513] Frame-preserving updates on unions

---
 examples/steel/ProductPCM.fst | 62 ++++++++++++++++++++++++++++++-----
 1 file changed, 54 insertions(+), 8 deletions(-)

diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
index 1709b448af3..dab5ab0def3 100644
--- a/examples/steel/ProductPCM.fst
+++ b/examples/steel/ProductPCM.fst
@@ -61,6 +61,7 @@ let frame_preserving_subframe #a p x y subframe f v =
     p.assoc y subframe frame
   in
   let lframe : squash (compatible p (op p x subframe) v) = () in
+  (* TODO Rewrite to use compatible_elim *)
   exists_elim (compatible p (op p y subframe) w) lframe (fun frame -> 
     aux frame;
     assert (op p frame (op p x subframe) == v);
@@ -256,6 +257,7 @@ val prod_upd :
 let prod_upd #a #f_ty p k xs y f vs =
   let ws_k = f (vs k) in
   let ws = fun_upd k ws_k vs in
+  (* TODO use compatible_intro? *)
   let aux (frame: _{composable (prod_pcm p) xs frame}) :
     Lemma
       // TODO unclear why it works to hoist this assumption,
@@ -272,33 +274,35 @@ let prod_upd #a #f_ty p k xs y f vs =
   let compat_ws_k : squash (compatible (p k) y ws_k) = () in
   let compat_vs : squash (compatible (prod_pcm p) xs vs) = () in
   let compat_ws_ty = squash (compatible (prod_pcm p) (fun_upd k y xs) ws) in
+  (* TODO Rewrite to use compatible_elim *)
   exists_elim compat_ws_ty compat_ws_k (fun frame_k ->
   exists_elim compat_ws_ty compat_vs (fun frame_rest ->
   let frame = fun_upd k frame_k frame_rest in
   ext (op (prod_pcm p) frame (fun_upd k y xs)) ws (fun k' -> ())));
   ws
 
-/// Similarly, given a PCM for each z:a, we can model a-ary unions with an PCM for option (x:a & f x), where
+/// Similarly, given a PCM for each k:a, we can model a-ary unions
+/// with an PCM for option (k:a & f k), where
 /// - None is the unit of the PCM
-/// - Some (x, y) is a union with tag x and content y
+/// - Some (k, x) is a union with tag k and content x
 
-let union (#f:'a -> Type) (p:(x:'a -> pcm (f x))) = option (x:'a & f x)
+let union (f:'a -> Type) = option (k:'a & f k)
 
 val union_comp :
-  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
-  symrel (union p)
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
+  symrel (union f)
 let union_comp p x y = match x, y with
   | None, z | z, None -> True
   | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
 
 val union_op :
-  #f:('a -> Type) -> p:(z:'a -> pcm (f z)) ->
-  x:union p -> y:union p {union_comp p x y} -> union p
+  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
+  x: union f -> y: union f {union_comp p x y} -> union f
 let union_op p x y = match x, y with
   | None, z | z, None -> z
   | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
 
-val union_pcm : #f:('a -> Type) -> p:(x: 'a -> pcm (f x)) -> pcm (union p)
+val union_pcm : #f:('a -> Type) -> p:(k:'a -> pcm (f k)) -> pcm (union f)
 let union_pcm p = {
   p = {composable = union_comp p; op = union_op p; one = None};
   comm = (fun x y -> match x, y with
@@ -314,6 +318,48 @@ let union_pcm p = {
   refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
 }
 
+/// Just like with structs, we can define frame-preserving updates on
+/// unions from frame-preserving updates on a single case:
+
+(* TODO copied from Denis's branch, move to FStar.PCM.fst *)
+let compatible_intro
+  (#a: Type u#a) (pcm:pcm a) (x y:a)
+  (frame: a)
+  : Lemma
+    (requires (composable pcm x frame /\ op pcm frame x == y))
+    (ensures (compatible pcm x y))
+  = ()
+
+val union_upd :
+  #a:eqtype -> #f:(a -> Type) -> p:(k:a -> pcm (f k)) ->
+  k:a -> x: f k -> y: f k ->
+  frame_preserving_upd (p k) x y ->
+  frame_preserving_upd (union_pcm p) (Some (|k, x|)) (Some (|k, y|))
+let union_upd p k x y f (Some (|k', v|)) =
+  compatible_elim (union_pcm p) (Some (|k, x|)) (Some (|k, v|)) (compatible (p k) x v)
+    (fun frame -> match frame with
+      | Some (|k', frame_x|) -> compatible_intro (p k) x v frame_x
+      | None -> (union_pcm p).is_unit (Some (|k, x|)); compatible_refl (p k) x);
+  let w = f v in
+  let aux (frame: _{composable (union_pcm p) (Some (|k, x|)) frame}) :
+    Lemma (composable (union_pcm p) (Some (|k, y|)) frame /\
+           (op (union_pcm p) (Some (|k, x|)) frame == Some (|k, v|) ==>
+            op (union_pcm p) (Some (|k, y|)) frame == Some (|k, w|)))
+  = match frame with
+    | None -> 
+      (union_pcm p).is_unit (Some (|k, x|));
+      (union_pcm p).is_unit (Some (|k, y|));
+      (p k).is_unit x;
+      assert (composable (p k) y (p k).p.one /\
+              (op (p k) x (p k).p.one == v ==> op (p k) y (p k).p.one == w));
+      (p k).is_unit y
+    | Some (|_, frame_x|) -> ()
+  in forall_intro aux;
+  compatible_elim (p k) y w
+    (compatible (union_pcm p) (Some (|k, y|)) (Some (|k, w|)))
+    (fun frame -> compatible_intro (union_pcm p) (Some (|k, y|)) (Some (|k, w|))
+      (Some (|k, frame|)));
+  Some (|k, w|)
 
 (*
 // TODO

From c283810a178bcca0529bf0383e0c00fe62d27c48 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 18 Jun 2021 11:32:26 -0700
Subject: [PATCH 009/513] Add StructRef.fst

---
 examples/steel/StructRef.fst | 46 ++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 examples/steel/StructRef.fst

diff --git a/examples/steel/StructRef.fst b/examples/steel/StructRef.fst
new file mode 100644
index 00000000000..95d8dae6bb4
--- /dev/null
+++ b/examples/steel/StructRef.fst
@@ -0,0 +1,46 @@
+module StructRef
+
+open FStar.PCM
+module M = Steel.Memory
+
+noeq type lens (a: Type u#a) (b: Type u#b) = {
+  get: a -> b;
+  put: b -> a -> a;
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
+  put_get: s: a -> Lemma (put (get s) s == s);
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+}
+
+let upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+
+(* The non-computational part of frame_preserving_upd *)
+let frame_preserv (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
+  p.refine (f v) /\
+  compatible p y (f v) /\
+  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
+     composable p y frame /\
+     (op p x frame == v ==> op p y frame == f v))
+
+(* Every function satisfying frame_preserv is a frame_preserving_upd *)
+let frame_preserv_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
+  (f:('a -> 'a){frame_preserv p f x y})
+  : frame_preserving_upd p x y
+  = fun v -> f v
+
+(* A pcm_lens is a lens for a 'b inside an 'a such that upd lifts
+   frame-preserving updates on 'b to frame-preserving updates on 'a *)
+noeq type pcm_lens (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
+  l: lens a b;
+  upd_resp_pcm:
+    s: a -> v: b -> f:(b -> b) ->
+    Lemma
+      (requires frame_preserv q f (l.get s) v)
+      (ensures frame_preserv p (upd l f) s (l.put v s));
+}
+
+(* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a *)
+noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
+  l: pcm_lens p q;
+  r: M.ref a p;
+}

From 989fe00dbca0465d62d7bd831ef814184ff5be75 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 18 Jun 2021 12:55:37 -0700
Subject: [PATCH 010/513] [pcm_lens]es compose

---
 examples/steel/StructRef.fst | 79 +++++++++++++++++++++++++++++++-----
 1 file changed, 69 insertions(+), 10 deletions(-)

diff --git a/examples/steel/StructRef.fst b/examples/steel/StructRef.fst
index 95d8dae6bb4..36ca5b72b0f 100644
--- a/examples/steel/StructRef.fst
+++ b/examples/steel/StructRef.fst
@@ -6,15 +6,27 @@ module M = Steel.Memory
 noeq type lens (a: Type u#a) (b: Type u#b) = {
   get: a -> b;
   put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
-  put_get: s: a -> Lemma (put (get s) s == s);
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v); // [SMTPat (get (put v s))];
+  put_get: s: a -> Lemma (put (get s) s == s); // [SMTPat (put (get s) s)];
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s); // [SMTPat (put v (put w s))];
 }
 
+let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
+  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
+  = l.get_put s v
+
+let put_get' (l: lens 'a 'b) (s: 'a)
+  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
+  = l.put_get s
+
+let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
+  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
+  = l.put_put s v w
+
 let upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
 
 (* The non-computational part of frame_preserving_upd *)
-let frame_preserv (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
   forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
   p.refine (f v) /\
   compatible p y (f v) /\
@@ -22,21 +34,21 @@ let frame_preserv (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
      composable p y frame /\
      (op p x frame == v ==> op p y frame == f v))
 
-(* Every function satisfying frame_preserv is a frame_preserving_upd *)
-let frame_preserv_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
-  (f:('a -> 'a){frame_preserv p f x y})
+(* Every function satisfying frame_pres is a frame_preserving_upd *)
+let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
+  (f:('a -> 'a){frame_pres p f x y})
   : frame_preserving_upd p x y
   = fun v -> f v
 
 (* A pcm_lens is a lens for a 'b inside an 'a such that upd lifts
    frame-preserving updates on 'b to frame-preserving updates on 'a *)
 noeq type pcm_lens (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
-  l: lens a b;
+  raw: lens a b;
   upd_resp_pcm:
     s: a -> v: b -> f:(b -> b) ->
     Lemma
-      (requires frame_preserv q f (l.get s) v)
-      (ensures frame_preserv p (upd l f) s (l.put v s));
+      (requires frame_pres q f (raw.get s) v)
+      (ensures frame_pres p (upd raw f) s (raw.put v s));
 }
 
 (* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a *)
@@ -44,3 +56,50 @@ noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
   l: pcm_lens p q;
   r: M.ref a p;
 }
+
+let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
+let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
+  upd l (m.put v) s
+
+let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
+  get = get_comp l m;
+  put = put_comp l m;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+// The following two lemmas aren't strictly necessary, but nice to verify
+open FStar.FunctionalExtensionality
+let upd_comp (l: lens 'a 'b) (m: lens 'b 'c) (f: 'c -> 'c) (s: 'a)
+  : Lemma (feq (upd (lens_comp l m) f) (upd l (upd m f)))
+  = ()
+let frame_pres_feq (p: pcm 'a) (f g: 'a -> 'a) (x y: 'a)
+  : Lemma (requires feq f g) (ensures frame_pres p f x y <==> frame_pres p g x y)
+  = ()
+
+let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (l: pcm_lens p q) (m: pcm_lens q r) : pcm_lens p r = {
+  raw = lens_comp l.raw m.raw;
+  upd_resp_pcm = (fun s v f ->
+    (* Goal:
+         s: a -> v: b -> f:(b -> b) ->
+         Lemma
+           (requires frame_pres q f ((comp l m).get s) v)
+           (ensures frame_pres p (upd (comp l m) f) s ((comp l m).put v s));
+       Since 
+         (feq (upd (comp l m) f) (upd l (upd m f))
+       and 
+         feq f g ==> frame_pres p f x y <==> frame_pres p g x y,
+       suff. to show
+         (ensures frame_pres p (upd l (upd m f)) s (l.put (m.put v (l.get s)) s)).
+       Because l respects pcms, suff. to show
+         (ensures frame_pres p (upd m f) (l.get s) (m.put v (l.get s))).
+       Because m respects pcms, suff. to show
+         (ensures frame_pres p f (m.get (l.get s)) v,
+       which we have by assumption
+         (requires frame_pres q f ((comp l m).get s) v). *)
+    m.upd_resp_pcm (l.raw.get s) v f;
+    l.upd_resp_pcm s (m.raw.put v (l.raw.get s)) (upd m.raw f)
+  );
+}

From d8a1d3e6468bd18830e23042874d30361d54fcfb Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 18 Jun 2021 13:12:13 -0700
Subject: [PATCH 011/513] Tidy

---
 examples/steel/StructRef.fst | 38 ++++++++----------------------------
 1 file changed, 8 insertions(+), 30 deletions(-)

diff --git a/examples/steel/StructRef.fst b/examples/steel/StructRef.fst
index 36ca5b72b0f..ed1262d3606 100644
--- a/examples/steel/StructRef.fst
+++ b/examples/steel/StructRef.fst
@@ -51,6 +51,13 @@ noeq type pcm_lens (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
       (ensures frame_pres p (upd raw f) s (raw.put v s));
 }
 
+let upd_resp_pcm' (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
+  : Lemma
+      (requires frame_pres q f (l.raw.get s) v)
+      (ensures frame_pres p (upd l.raw f) s (l.raw.put v s))
+      [SMTPat (frame_pres q f (l.raw.get s) v)]
+  = l.upd_resp_pcm s v f
+
 (* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a *)
 noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
   l: pcm_lens p q;
@@ -69,37 +76,8 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
-// The following two lemmas aren't strictly necessary, but nice to verify
-open FStar.FunctionalExtensionality
-let upd_comp (l: lens 'a 'b) (m: lens 'b 'c) (f: 'c -> 'c) (s: 'a)
-  : Lemma (feq (upd (lens_comp l m) f) (upd l (upd m f)))
-  = ()
-let frame_pres_feq (p: pcm 'a) (f g: 'a -> 'a) (x y: 'a)
-  : Lemma (requires feq f g) (ensures frame_pres p f x y <==> frame_pres p g x y)
-  = ()
-
 let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   (l: pcm_lens p q) (m: pcm_lens q r) : pcm_lens p r = {
   raw = lens_comp l.raw m.raw;
-  upd_resp_pcm = (fun s v f ->
-    (* Goal:
-         s: a -> v: b -> f:(b -> b) ->
-         Lemma
-           (requires frame_pres q f ((comp l m).get s) v)
-           (ensures frame_pres p (upd (comp l m) f) s ((comp l m).put v s));
-       Since 
-         (feq (upd (comp l m) f) (upd l (upd m f))
-       and 
-         feq f g ==> frame_pres p f x y <==> frame_pres p g x y,
-       suff. to show
-         (ensures frame_pres p (upd l (upd m f)) s (l.put (m.put v (l.get s)) s)).
-       Because l respects pcms, suff. to show
-         (ensures frame_pres p (upd m f) (l.get s) (m.put v (l.get s))).
-       Because m respects pcms, suff. to show
-         (ensures frame_pres p f (m.get (l.get s)) v,
-       which we have by assumption
-         (requires frame_pres q f ((comp l m).get s) v). *)
-    m.upd_resp_pcm (l.raw.get s) v f;
-    l.upd_resp_pcm s (m.raw.put v (l.raw.get s)) (upd m.raw f)
-  );
+  upd_resp_pcm = (fun _ _ _ -> ());
 }

From b68127e70aa3848c8b899f4d5227a9512d3d3cd5 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 18 Jun 2021 14:30:08 -0700
Subject: [PATCH 012/513] Tidy

---
 examples/steel/StructRef.fst | 78 +++++++++++++++++++++---------------
 1 file changed, 45 insertions(+), 33 deletions(-)

diff --git a/examples/steel/StructRef.fst b/examples/steel/StructRef.fst
index ed1262d3606..214d7325f0f 100644
--- a/examples/steel/StructRef.fst
+++ b/examples/steel/StructRef.fst
@@ -3,29 +3,49 @@ module StructRef
 open FStar.PCM
 module M = Steel.Memory
 
+(** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
   get: a -> b;
   put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v); // [SMTPat (get (put v s))];
-  put_get: s: a -> Lemma (put (get s) s == s); // [SMTPat (put (get s) s)];
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s); // [SMTPat (put v (put w s))];
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
+  put_get: s: a -> Lemma (put (get s) s == s);
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
 }
-
 let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
   : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
   = l.get_put s v
-
 let put_get' (l: lens 'a 'b) (s: 'a)
   : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
   = l.put_get s
-
 let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
   : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
   = l.put_put s v w
 
-let upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+(** Updating the target of a lens *)
+let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+
+let const (x: 'a) (b: 'b): 'a = x
+let lens_id #a : lens a a = {
+  get = id;
+  put = const;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
+let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
+  lens_upd l (m.put v) s
+let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
+  get = get_comp l m;
+  put = put_comp l m;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
 
-(* The non-computational part of frame_preserving_upd *)
+(** The non-computational part of frame_preserving_upd
+    TODO: move this and lemmas about this to FStar.PCM.fst *)
 let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
   forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
   p.refine (f v) /\
@@ -34,50 +54,42 @@ let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
      composable p y frame /\
      (op p x frame == v ==> op p y frame == f v))
 
-(* Every function satisfying frame_pres is a frame_preserving_upd *)
+(** Every function satisfying frame_pres is a frame_preserving_upd *)
 let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
   (f:('a -> 'a){frame_pres p f x y})
   : frame_preserving_upd p x y
   = fun v -> f v
 
-(* A pcm_lens is a lens for a 'b inside an 'a such that upd lifts
-   frame-preserving updates on 'b to frame-preserving updates on 'a *)
+(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b)
+    with the extra law that lens_upd lifts frame-preserving updates on
+    b w.r.t. q to frame-preserving updates on a w.r.t. p. *)
 noeq type pcm_lens (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
   raw: lens a b;
-  upd_resp_pcm:
-    s: a -> v: b -> f:(b -> b) ->
+  upd_resp_pcm: s: a -> v: b -> f:(b -> b) ->
     Lemma
       (requires frame_pres q f (raw.get s) v)
-      (ensures frame_pres p (upd raw f) s (raw.put v s));
+      (ensures frame_pres p (lens_upd raw f) s (raw.put v s));
 }
-
 let upd_resp_pcm' (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
   : Lemma
       (requires frame_pres q f (l.raw.get s) v)
-      (ensures frame_pres p (upd l.raw f) s (l.raw.put v s))
+      (ensures frame_pres p (lens_upd l.raw f) s (l.raw.put v s))
       [SMTPat (frame_pres q f (l.raw.get s) v)]
   = l.upd_resp_pcm s v f
 
+let pcm_lens_id (#p: pcm 'a): pcm_lens p p
+  = {raw = lens_id; upd_resp_pcm = (fun _ _ _ -> ())}
+let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r
+  = {raw = lens_comp l.raw m.raw; upd_resp_pcm = (fun _ _ _ -> ())}
+
+let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.raw.get s
+let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.raw.put v s
+let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.raw f s
+
 (* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a *)
 noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
   l: pcm_lens p q;
   r: M.ref a p;
 }
 
-let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
-let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
-  upd l (m.put v) s
-
-let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
-  get = get_comp l m;
-  put = put_comp l m;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (l: pcm_lens p q) (m: pcm_lens q r) : pcm_lens p r = {
-  raw = lens_comp l.raw m.raw;
-  upd_resp_pcm = (fun _ _ _ -> ());
-}

From e164e6002a9101b0be42b403852eb02cc6d23b56 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 18 Jun 2021 15:08:40 -0700
Subject: [PATCH 013/513] Add tagged union example + reformat Aggregates.fst

---
 examples/steel/Aggregates.fst | 333 +++++++++++++++++++++++++++++
 examples/steel/ProductPCM.fst | 384 ----------------------------------
 2 files changed, 333 insertions(+), 384 deletions(-)
 create mode 100644 examples/steel/Aggregates.fst
 delete mode 100644 examples/steel/ProductPCM.fst

diff --git a/examples/steel/Aggregates.fst b/examples/steel/Aggregates.fst
new file mode 100644
index 00000000000..2b4d29e04b2
--- /dev/null
+++ b/examples/steel/Aggregates.fst
@@ -0,0 +1,333 @@
+module Aggregates
+
+open FStar.PCM
+
+/// We can define a PCM for structs with two fields {a; b} by defining
+/// a PCM for tuples (a & b) in terms of (potentially user-defined)
+/// PCMs for a and b.
+
+let tuple_comp (p: pcm 'a) (q: pcm 'b) (x y: 'a & 'b) : prop =
+  composable p (fst x) (fst y) /\ composable q (snd x) (snd y)
+
+let tuple_op (p: pcm 'a) (q: pcm 'b) (x: 'a & 'b) (y: ('a & 'b){tuple_comp p q x y}) : 'a & 'b =
+  (op p (fst x) (fst y), op q (snd x) (snd y))
+
+let tuple_pcm (p: pcm 'a) (q: pcm 'b): pcm ('a & 'b) = {
+  p = {composable = tuple_comp p q; op = tuple_op p q; one = (p.p.one, q.p.one)};
+  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
+  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
+  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
+  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
+  refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
+}
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun _ -> True);
+}
+
+/// We can define frame-preserving updates for a tuple PCM from
+/// frame-preserving updates on its components. For example, to define
+/// a frame-preserving update on the first component:
+
+let compatible_tuple_l (p: pcm 'a) (q: pcm 'b) (x v: 'a) (y w: 'b)
+: Lemma 
+    (requires compatible p x v /\ compatible q y w)
+    (ensures compatible (tuple_pcm p q) (x, y) (v, w))
+= let pq = tuple_pcm p q in
+  let aux frame_x frame_y :
+    Lemma 
+      (requires composable pq (x, y) (frame_x, frame_y) /\
+                op pq (frame_x, frame_y) (x, y) == (v, w))
+      (ensures compatible pq (x, y) (v, w))
+      [SMTPat (composable p x frame_x); SMTPat (composable q y frame_y)] = ()
+  in ()
+
+let upd_fst (p: pcm 'a) (q: pcm 'b) (x: 'a) (y: 'b) (x': 'a)
+  (f: frame_preserving_upd p x x')
+: frame_preserving_upd (tuple_pcm p q) (x, y) (x', y)
+= fun (va, vb) ->
+  let wa = f va in
+  let pq = tuple_pcm p q in
+  compatible_tuple_l p q x' wa y vb;
+  let aux (frame: _{composable pq (x, y) frame}):
+    Lemma (composable pq (x', y) frame /\
+           (op pq (x, y) frame == (va, vb) ==> op pq (x', y) frame == (wa, vb)))
+    [SMTPat (composable pq (x, y) frame)] = ()
+  in (wa, vb)
+
+/// Frame-preserving updates on the second component can be done similarly.
+/// To avoid having to write a frame-preserving update for each field separately,
+/// we generalize to 'a-ary products (k:'a -> f k), given a PCM for each k:
+
+open FStar.FunctionalExtensionality
+open FStar.Classical
+let ext #a #b (f g: restricted_t a b) (fg:(x:a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality a b f g;
+  forall_intro fg
+
+let prod_comp #f (p:(k:'a -> pcm (f k))) (x y: restricted_t 'a f): prop =
+  forall k. composable (p k) (x k) (y k)
+
+let prod_op #a #f (p:(k:a -> pcm (f k)))
+  (x: restricted_t a f) (y: restricted_t a f{prod_comp p x y})
+: restricted_t a f
+= on_domain a (fun k -> op (p k) (x k) (y k))
+
+let prod_one #a #f (p:(k:a -> pcm (f k))): restricted_t a f =
+  on_domain a (fun k -> (p k).p.one)
+
+let prod_comm #f (p:(k:'a -> pcm (f k)))
+  (x: restricted_t 'a f) (y: restricted_t 'a f{prod_comp p x y})
+: Lemma (prod_op p x y == prod_op p y x)
+= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
+
+let prod_assoc #f (p:(k:'a -> pcm (f k)))
+  (x y: restricted_t 'a f)
+  (z: restricted_t 'a f{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+: Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)]
+  = (p k).assoc (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_assoc_r #f (p:(k:'a -> pcm (f k)))
+  (x y: restricted_t 'a f)
+  (z: restricted_t 'a f{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+: Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)]
+  = (p k).assoc_r (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_is_unit #f (p:(k:'a -> pcm (f k))) (x: restricted_t 'a f)
+: Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+= let is_unit k
+  : Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)]
+  = (p k).is_unit (x k)
+  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
+
+let prod_refine #f (p:(k:'a -> pcm (f k))) (x: restricted_t 'a f): prop =
+  forall k. (p k).refine (x k)
+
+let prod_pcm #f (p:(k:'a -> pcm (f k))): pcm (restricted_t 'a f) = {
+  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  comm = prod_comm p;
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
+
+/// Now, we can define frame-preserving updates for all fields at once:
+
+let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
+  (f: restricted_t a f_ty)
+: restricted_t a f_ty
+= on_domain a (fun k' -> if k = k' then x' else f k')
+
+let prod_upd (#a:eqtype) #f_ty (p:(k:a -> pcm (f_ty k))) (k:a)
+  (xs: restricted_t a f_ty) (y: f_ty k) (f: frame_preserving_upd (p k) (xs k) y)
+: frame_preserving_upd (prod_pcm p) xs (fun_upd k y xs)
+= fun vs ->
+  let ws_k = f (vs k) in
+  let ws = fun_upd k ws_k vs in
+  let aux (frame: _{composable (prod_pcm p) xs frame}) :
+    Lemma
+      (requires op (prod_pcm p) xs frame == vs)
+      (ensures
+         composable (prod_pcm p) (fun_upd k y xs) frame /\
+         op (prod_pcm p) (fun_upd k y xs) frame == ws)
+    [SMTPat (composable (prod_pcm p) xs frame)]
+  = assert (composable (prod_pcm p) (fun_upd k y xs) frame);
+    ext (op (prod_pcm p) (fun_upd k y xs) frame) ws (fun k' -> ())
+  in
+  let compat_ws_ty = squash (compatible (prod_pcm p) (fun_upd k y xs) ws) in
+  compatible_elim (p k) y ws_k compat_ws_ty (fun frame_k ->
+  compatible_elim (prod_pcm p) xs vs compat_ws_ty (fun frame_rest ->
+  let frame = fun_upd k frame_k frame_rest in
+  ext (op (prod_pcm p) frame (fun_upd k y xs)) ws (fun k' -> ())));
+  ws
+  
+/// Similarly, given a PCM for each k:a, we can model a-ary unions
+/// with an PCM for option (k:a & f k), where
+/// - None is the unit of the PCM
+/// - Some (k, x) is a union with tag k and content x
+
+let union (f:'a -> Type) = option (k:'a & f k)
+
+let union_comp #f (p:(k:'a -> pcm (f k))): symrel (union f) = fun x y -> match x, y with
+  | None, z | z, None -> True
+  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
+
+let union_op #f (p:(k:'a -> pcm (f k))) (x: union f) (y: union f{union_comp p x y}) : union f = match x, y with
+  | None, z | z, None -> z
+  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
+
+let union_pcm #f (p:(k:'a -> pcm (f k))): pcm (union f) = {
+  p = {composable = union_comp p; op = union_op p; one = None};
+  comm = (fun x y -> match x, y with
+    | None, _ | _, None -> ()
+    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
+  assoc = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
+  assoc_r = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
+}
+
+/// Just like with structs, we can define frame-preserving updates on
+/// unions from frame-preserving updates on a single case:
+
+let union_upd (#a:eqtype) #f_ty (p:(k:a -> pcm (f_ty k))) (k:a)
+  (x y:f_ty k) (f: frame_preserving_upd (p k) x y)
+: frame_preserving_upd (union_pcm p) (Some (|k, x|)) (Some (|k, y|))
+= fun (Some (|k', v|)) ->
+  compatible_elim (union_pcm p) (Some (|k, x|)) (Some (|k, v|)) (compatible (p k) x v)
+    (fun frame -> match frame with
+      | Some (|k', frame_x|) -> compatible_intro (p k) x v frame_x
+      | None -> (union_pcm p).is_unit (Some (|k, x|)); compatible_refl (p k) x);
+  let w = f v in
+  let aux (frame: _{composable (union_pcm p) (Some (|k, x|)) frame})
+  : Lemma (composable (union_pcm p) (Some (|k, y|)) frame /\
+           (op (union_pcm p) (Some (|k, x|)) frame == Some (|k, v|) ==>
+            op (union_pcm p) (Some (|k, y|)) frame == Some (|k, w|)))
+  = match frame with
+    | None -> 
+      (union_pcm p).is_unit (Some (|k, x|));
+      (union_pcm p).is_unit (Some (|k, y|));
+      (p k).is_unit x;
+      assert (composable (p k) y (p k).p.one /\
+              (op (p k) x (p k).p.one == v ==> op (p k) y (p k).p.one == w));
+      (p k).is_unit y
+    | Some (|_, frame_x|) -> ()
+  in forall_intro aux;
+  compatible_elim (p k) y w
+    (compatible (union_pcm p) (Some (|k, y|)) (Some (|k, w|)))
+    (fun frame -> compatible_intro (union_pcm p) (Some (|k, y|)) (Some (|k, w|))
+      (Some (|k, frame|)));
+  Some (|k, w|)
+
+/// Example: a model for a tagged union representing colors in RGB or HSV
+///   type color =
+///     | RGB : r:int -> g:int -> b:int -> color
+///     | HSV : h:int -> s:int -> v:int -> color
+
+type rgb_field = | R | G | B
+type hsv_field = | H | S | V
+type color_tag = | RGB | HSV
+
+(* Carrier of all-or-none PCM for integers *)
+let int_pcm_t = option int
+
+(* Type families for fields of RGB and HSV structs *)
+let rgb_fields k = match k with
+  | R -> int_pcm_t
+  | G -> int_pcm_t
+  | B -> int_pcm_t
+let hsv_fields k = match k with
+  | H -> int_pcm_t
+  | S -> int_pcm_t
+  | V -> int_pcm_t
+  
+(* Carriers of PCMs for RGB and HSV structs *)
+let rgb_t = restricted_t rgb_field rgb_fields
+let hsv_t = restricted_t hsv_field hsv_fields
+
+(* Type family for union of RGB and HSV *)
+let color_cases t = match t with
+  | RGB -> rgb_t
+  | HSV -> hsv_t
+
+(* Carrier of PCM for color *)
+let color_t = union color_cases
+
+(* All-or-none PCM for integers *)
+let int_pcm : pcm int_pcm_t = opt_pcm
+
+(* PCMs for RGB and HSV structs *)
+let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
+  prod_pcm #_ #rgb_fields (fun k -> match k with
+    | R -> int_pcm
+    | G -> int_pcm
+    | B -> int_pcm)
+let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
+  prod_pcm #_ #hsv_fields (fun k -> match k with
+    | H -> int_pcm
+    | S -> int_pcm
+    | V -> int_pcm)
+
+(* PCM for color *)
+let color_pcm_cases k : pcm (color_cases k) = match k with
+  | RGB -> rgb_pcm
+  | HSV -> hsv_pcm
+let color_pcm : pcm color_t = union_pcm color_pcm_cases
+
+(* Update RGB *)
+let rgb_upd (rgb rgb': rgb_t) (f: frame_preserving_upd rgb_pcm rgb rgb')
+: frame_preserving_upd color_pcm (Some (|RGB, rgb|)) (Some (|RGB, rgb'|))
+= union_upd color_pcm_cases RGB rgb rgb' f
+
+(* Update HSV *)
+let hsv_upd (hsv hsv': hsv_t) (f: frame_preserving_upd hsv_pcm hsv hsv')
+: frame_preserving_upd color_pcm (Some (|HSV, hsv|)) (Some (|HSV, hsv'|))
+= union_upd color_pcm_cases HSV hsv hsv' f
+
+/// In general, from
+///   type s = {x1:t1; ..; xn:tn}
+///   (Fields could be annotated with custom PCMs; e.g.
+///      xi: ti [@custom_pcm pcm_for_ti])
+/// Carrier type is
+///   s_pcm_t = t1_pcm_t * .. * tn_pcm_t
+/// And the PCM is
+///   s_pcm = product PCM of t1_pcm .. tn_pcm
+///   where
+///     ti_pcm =
+///       whatever custom PCM was specified by the user, if it exists,
+///       and (opt_pcm #ti_pcm_t) otherwise
+/// 
+/// Similarly, from
+///   type s = | x1:t1 | .. | xn:tn
+/// Carrier type is
+///   s_pcm_t = t1_pcm_t + .. + tn_pcm_t
+/// And the PCM is
+///   s_pcm = union PCM of t1_pcm .. tn_pcm
+///
+/// Any subcomponent of a type built from structs and unions not
+/// annotated by a custom PCM can be updated using prod_upd,
+/// union_upd, and the following frame-preserving update on the
+/// all-or-none PCM:
+
+let opt_pcm_upd (x y: 'a)
+: frame_preserving_upd opt_pcm (Some x) (Some y)
+= fun (Some _) -> (Some y)
diff --git a/examples/steel/ProductPCM.fst b/examples/steel/ProductPCM.fst
deleted file mode 100644
index dab5ab0def3..00000000000
--- a/examples/steel/ProductPCM.fst
+++ /dev/null
@@ -1,384 +0,0 @@
-module ProductPCM
-
-open FStar.PCM
-
-/// Aseem's alternative definition of frame-preserving updates
-
-type frame_preserving_upd (#a:Type u#a) (p:pcm a) (x y:a) =
-  v:a{
-     p.refine v /\
-     compatible p x v
-  } ->
-  v_new:a{
-    p.refine v_new /\
-    compatible p y v_new /\
-    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
-       composable p y frame /\
-       (op p x frame == v ==> op p y frame == v_new))}
-
-/// The alternative definition satisfies 3 nice properties:
-
-(* The identity function is a frame-preserving update *)
-val no_op_is_frame_preserving :
-  p: pcm 'a -> x: 'a ->
-  frame_preserving_upd p x x
-let no_op_is_frame_preserving p x = fun v -> v
-
-(* Frame-preserving updates compose, and the composition is just
-   function composition *)
-val frame_preserving_updates_compose :
-  p: pcm 'a -> x: 'a -> y: 'a -> z: 'a ->
-  frame_preserving_upd p y z ->
-  frame_preserving_upd p x y ->
-  frame_preserving_upd p x z
-let frame_preserving_updates_compose p x y z f g = fun v -> f (g v)
-
-val compatible_subframe :
-  p: pcm 'a -> x: 'a -> y: 'a {composable p x y} -> z: 'a ->
-  Lemma (requires (compatible p (op p x y) z)) (ensures (compatible p x z))
-let compatible_subframe p x y z =
-  compatible_elim p (op p x y) z (compatible p x z) (fun frame ->
-    p.comm x y;
-    p.assoc frame y x)
-
-(* A frame-preserving update from x to y is also a frame-preserving
-   update from (x `op` subframe) to (y `op` subframe), for any subframe *)
-open FStar.Classical
-val frame_preserving_subframe : 
-  p: pcm 'a -> x: 'a -> y: 'a -> subframe: 'a{composable p x subframe /\ composable p y subframe} ->
-  frame_preserving_upd p x y ->
-  frame_preserving_upd p (op p x subframe) (op p y subframe)
-let frame_preserving_subframe #a p x y subframe f v =
-  compatible_subframe p x subframe v;
-  let w = f v in
-  let aux (frame: a{composable p (op p x subframe) frame}):
-    Lemma (composable p (op p y subframe) frame /\
-           (op p (op p x subframe) frame == v ==> op p (op p y subframe) frame == w))
-           [SMTPat (composable p (op p y subframe) frame)]
-  = p.assoc_r x subframe frame;
-    assert (composable p x (op p subframe frame));
-    assert (composable p y (op p subframe frame));
-    p.assoc y subframe frame
-  in
-  let lframe : squash (compatible p (op p x subframe) v) = () in
-  (* TODO Rewrite to use compatible_elim *)
-  exists_elim (compatible p (op p y subframe) w) lframe (fun frame -> 
-    aux frame;
-    assert (op p frame (op p x subframe) == v);
-    p.comm frame (op p x subframe);
-    assert (op p (op p y subframe) frame == w);
-    p.comm (op p y subframe) frame);
-  w
-
-/// We can define a PCM for structs with two fields {a; b} by defining
-/// a PCM for tuples (a & b) in terms of (potentially user-defined)
-/// PCMs for a and b.
-
-val tuple_comp : pcm 'a -> pcm 'b -> 'a & 'b -> 'a & 'b -> prop
-let tuple_comp p q (xa, xb) (ya, yb) = composable p xa ya /\ composable q xb yb
-
-val tuple_op : p: pcm 'a -> q: pcm 'b -> x:('a & 'b) -> y:('a & 'b){tuple_comp p q x y} -> 'a & 'b
-let tuple_op p q (xa, xb) (ya, yb) = (op p xa ya, op q xb yb)
-
-val tuple_pcm : pcm 'a -> pcm 'b -> pcm ('a & 'b)
-let tuple_pcm #a #b p q = {
-  p = {composable = tuple_comp p q; op = tuple_op p q; one = (p.p.one, q.p.one)};
-  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
-  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
-  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
-  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
-  refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
-}
-
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-val opt_comp : option 'a -> option 'a -> prop
-let opt_comp x y = match x, y with None, _ | _, None -> True | _ -> False
-
-val opt_op : x:option 'a -> y:option 'a {opt_comp x y} -> option 'a
-let opt_op x y = match x, y with None, z | z, None -> z
-
-val opt_pcm : pcm (option 'a)
-let opt_pcm #a = {
-  p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun _ -> True);
-}
-
-/// With the alternative definition of frame-preserving updates, we
-/// can define frame-preserving updates for a tuple PCM from
-/// frame-preserving updates on its components. For example, to define
-/// a frame-preserving update on the first component:
-
-open Steel.Memory
-open Steel.Effect.Atomic
-open Steel.Effect
-
-val compatible_tuple_l :
-  p: pcm 'a -> q: pcm 'b ->
-  x: 'a -> v: 'a -> y: 'b -> w: 'b ->
-  Lemma 
-    (requires compatible p x v /\ compatible q y w)
-    (ensures compatible (tuple_pcm p q) (x, y) (v, w))
-let compatible_tuple_l p q x v y w =
-  let pq = tuple_pcm p q in
-  let aux frame_x frame_y :
-    Lemma 
-      (requires composable pq (x, y) (frame_x, frame_y) /\
-                op pq (frame_x, frame_y) (x, y) == (v, w))
-      (ensures compatible pq (x, y) (v, w))
-      [SMTPat (composable p x frame_x); SMTPat (composable q y frame_y)] = ()
-  in ()
-
-val upd_fst :
-  p: pcm 'a -> q: pcm 'b ->
-  x: 'a -> y: 'b -> x': 'a ->
-  frame_preserving_upd p x x' ->
-  frame_preserving_upd (tuple_pcm p q) (x, y) (x', y)
-let upd_fst #a #b p q x y x' f (va, vb) =
-  let wa = f va in
-  let pq = tuple_pcm p q in
-  compatible_tuple_l p q x' wa y vb;
-  let aux (frame: (a & b) {composable pq (x, y) frame}):
-    Lemma (composable pq (x', y) frame /\
-           (op pq (x, y) frame == (va, vb) ==> op pq (x', y) frame == (wa, vb)))
-    [SMTPat (composable pq (x, y) frame)] = ()
-  in (wa, vb)
-
-/// Frame-preserving updates on the second component can be done similarly.
-/// To avoid having to write a frame-preserving update for each field separately,
-/// we generalize to 'a-ary products (k:'a -> f k), given a PCM for each k:
-
-open FStar.FunctionalExtensionality
-
-val prod_comp :
-  #f:('a -> Type) -> (k:'a -> pcm (f k)) ->
-  restricted_t 'a f -> restricted_t 'a f -> prop
-let prod_comp p x y = forall k. composable (p k) (x k) (y k)
-
-val prod_op :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) -> 
-  x:restricted_t 'a f -> y: restricted_t 'a f {prod_comp p x y} -> 
-  restricted_t 'a f
-let prod_op #a p x y = on_domain a (fun k -> op (p k) (x k) (y k))
-
-val prod_one : #f:('a -> Type) -> (k:'a -> pcm (f k)) -> restricted_t 'a f
-let prod_one #a p = on_domain a (fun k -> (p k).p.one)
-
-val ext :
-  #b: ('a -> Type) -> f: restricted_t 'a b -> g: restricted_t 'a b -> 
-  (x: 'a -> Lemma (f x == g x)) ->
-  Lemma (ensures (f == g))
-let ext #a #b f g fg =
-  extensionality a b f g;
-  forall_intro fg
-
-val prod_comm :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
-  x:restricted_t 'a f ->
-  y:restricted_t 'a f {prod_comp p x y} ->
-  Lemma (prod_op p x y == prod_op p y x)
-let prod_comm p x y =
-  ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
-
-val prod_assoc :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
-  x:restricted_t 'a f -> y:restricted_t 'a f ->
-  z:restricted_t 'a f {prod_comp p y z /\ prod_comp p x (prod_op p y z)} ->
-  Lemma (prod_comp p x y /\
-         prod_comp p (prod_op p x y) z /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-let prod_assoc p x y z =
-  let aux k :
-    Lemma (composable (p k) (x k) (y k) /\
-           composable (p k) (op (p k) (x k) (y k)) (z k)) 
-    [SMTPat (p k)] = (p k).assoc (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-val prod_assoc_r :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
-  x:restricted_t 'a f -> y:restricted_t 'a f ->
-  z:restricted_t 'a f {prod_comp p x y /\ prod_comp p (prod_op p x y) z} ->
-  Lemma (prod_comp p y z /\
-         prod_comp p x (prod_op p y z) /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-let prod_assoc_r #a p x y z =
-  let aux k : 
-    Lemma (composable (p k) (y k) (z k) /\
-           composable (p k) (x k) (op (p k) (y k) (z k)))
-    [SMTPat (p k)] = (p k).assoc_r (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-val prod_is_unit :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
-  x:restricted_t 'a f ->
-  Lemma (prod_comp p x (prod_one p) /\
-         prod_op p x (prod_one p) == x)
-let prod_is_unit #a p x =
-  let is_unit k :
-    Lemma (composable (p k) (x k) (prod_one p k))
-    [SMTPat (p k)] = (p k).is_unit (x k)
-  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
-
-val prod_refine :
-  #f:('a -> Type) -> (k:'a -> pcm (f k)) ->
-  x: restricted_t 'a f -> prop
-let prod_refine p x = forall k. (p k).refine (x k)
-
-val prod_pcm : #f:('a -> Type) -> (k:'a -> pcm (f k)) -> pcm (restricted_t 'a f)
-let prod_pcm #a #f p = {
-  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
-  comm = prod_comm p;
-  assoc = prod_assoc p;
-  assoc_r = prod_assoc_r p;
-  is_unit = prod_is_unit p;
-  refine = prod_refine p
-}
-
-/// Now, we can define frame-preserving updates for all fields at once:
-
-val fun_upd :
-  #a:eqtype -> #f:(a -> Type) -> k:a -> x': f k ->
-  restricted_t a f -> restricted_t a f
-let fun_upd #a k x' f = on_domain a (fun k' -> if k = k' then x' else f k')
-
-val prod_upd :
-  #a:eqtype -> #f:(a -> Type) -> p:(k:a -> pcm (f k)) ->
-  k:a -> xs: restricted_t a f -> y: f k ->
-  frame_preserving_upd (p k) (xs k) y ->
-  frame_preserving_upd (prod_pcm p) xs (fun_upd k y xs)
-let prod_upd #a #f_ty p k xs y f vs =
-  let ws_k = f (vs k) in
-  let ws = fun_upd k ws_k vs in
-  (* TODO use compatible_intro? *)
-  let aux (frame: _{composable (prod_pcm p) xs frame}) :
-    Lemma
-      // TODO unclear why it works to hoist this assumption,
-      // because goal contains (forall .., P /\ (Q ==> R))
-      // but this only proves (forall .., Q ==> P /\ R)
-      (requires op (prod_pcm p) xs frame == vs)
-      (ensures
-         composable (prod_pcm p) (fun_upd k y xs) frame /\
-         op (prod_pcm p) (fun_upd k y xs) frame == ws)
-    [SMTPat (composable (prod_pcm p) xs frame)]
-  = assert (composable (prod_pcm p) (fun_upd k y xs) frame);
-    ext (op (prod_pcm p) (fun_upd k y xs) frame) ws (fun k' -> ())
-  in
-  let compat_ws_k : squash (compatible (p k) y ws_k) = () in
-  let compat_vs : squash (compatible (prod_pcm p) xs vs) = () in
-  let compat_ws_ty = squash (compatible (prod_pcm p) (fun_upd k y xs) ws) in
-  (* TODO Rewrite to use compatible_elim *)
-  exists_elim compat_ws_ty compat_ws_k (fun frame_k ->
-  exists_elim compat_ws_ty compat_vs (fun frame_rest ->
-  let frame = fun_upd k frame_k frame_rest in
-  ext (op (prod_pcm p) frame (fun_upd k y xs)) ws (fun k' -> ())));
-  ws
-
-/// Similarly, given a PCM for each k:a, we can model a-ary unions
-/// with an PCM for option (k:a & f k), where
-/// - None is the unit of the PCM
-/// - Some (k, x) is a union with tag k and content x
-
-let union (f:'a -> Type) = option (k:'a & f k)
-
-val union_comp :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
-  symrel (union f)
-let union_comp p x y = match x, y with
-  | None, z | z, None -> True
-  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
-
-val union_op :
-  #f:('a -> Type) -> p:(k:'a -> pcm (f k)) ->
-  x: union f -> y: union f {union_comp p x y} -> union f
-let union_op p x y = match x, y with
-  | None, z | z, None -> z
-  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
-
-val union_pcm : #f:('a -> Type) -> p:(k:'a -> pcm (f k)) -> pcm (union f)
-let union_pcm p = {
-  p = {composable = union_comp p; op = union_op p; one = None};
-  comm = (fun x y -> match x, y with
-    | None, _ | _, None -> ()
-    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
-  assoc = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
-  assoc_r = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
-}
-
-/// Just like with structs, we can define frame-preserving updates on
-/// unions from frame-preserving updates on a single case:
-
-(* TODO copied from Denis's branch, move to FStar.PCM.fst *)
-let compatible_intro
-  (#a: Type u#a) (pcm:pcm a) (x y:a)
-  (frame: a)
-  : Lemma
-    (requires (composable pcm x frame /\ op pcm frame x == y))
-    (ensures (compatible pcm x y))
-  = ()
-
-val union_upd :
-  #a:eqtype -> #f:(a -> Type) -> p:(k:a -> pcm (f k)) ->
-  k:a -> x: f k -> y: f k ->
-  frame_preserving_upd (p k) x y ->
-  frame_preserving_upd (union_pcm p) (Some (|k, x|)) (Some (|k, y|))
-let union_upd p k x y f (Some (|k', v|)) =
-  compatible_elim (union_pcm p) (Some (|k, x|)) (Some (|k, v|)) (compatible (p k) x v)
-    (fun frame -> match frame with
-      | Some (|k', frame_x|) -> compatible_intro (p k) x v frame_x
-      | None -> (union_pcm p).is_unit (Some (|k, x|)); compatible_refl (p k) x);
-  let w = f v in
-  let aux (frame: _{composable (union_pcm p) (Some (|k, x|)) frame}) :
-    Lemma (composable (union_pcm p) (Some (|k, y|)) frame /\
-           (op (union_pcm p) (Some (|k, x|)) frame == Some (|k, v|) ==>
-            op (union_pcm p) (Some (|k, y|)) frame == Some (|k, w|)))
-  = match frame with
-    | None -> 
-      (union_pcm p).is_unit (Some (|k, x|));
-      (union_pcm p).is_unit (Some (|k, y|));
-      (p k).is_unit x;
-      assert (composable (p k) y (p k).p.one /\
-              (op (p k) x (p k).p.one == v ==> op (p k) y (p k).p.one == w));
-      (p k).is_unit y
-    | Some (|_, frame_x|) -> ()
-  in forall_intro aux;
-  compatible_elim (p k) y w
-    (compatible (union_pcm p) (Some (|k, y|)) (Some (|k, w|)))
-    (fun frame -> compatible_intro (union_pcm p) (Some (|k, y|)) (Some (|k, w|))
-      (Some (|k, frame|)));
-  Some (|k, w|)
-
-(*
-// TODO
-// move 2d point along x
-// move 2d point along y
-// given a function "incrementX" and "incrementY"; write a function that calls it in a loop
-
-// union examples
-// 2d & 3d point
-// rgb / hsv
-
-// next examples:
-//   swap 2 3d points with a helper function
-//   union where discrimnant is not just a tag, but some predicate
-
-// { f field_x = Full .. }
-// { p `pts_to` f } 
-//   addr_of p field_x
-// { fun q -> (p `pts_to` f \ x) `star` (q `pts_to` x) }
-// 
-// let q = addr_of p field_x
-*)

From f66af659848a2b0ce1bcc7d3180866316f479a87 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 18 Jun 2021 15:13:14 -0700
Subject: [PATCH 014/513] StructRef.fst -> AggregateRef.fst

---
 examples/steel/{StructRef.fst => AggregateRef.fst} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename examples/steel/{StructRef.fst => AggregateRef.fst} (99%)

diff --git a/examples/steel/StructRef.fst b/examples/steel/AggregateRef.fst
similarity index 99%
rename from examples/steel/StructRef.fst
rename to examples/steel/AggregateRef.fst
index 214d7325f0f..16a6b44f49c 100644
--- a/examples/steel/StructRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -1,4 +1,4 @@
-module StructRef
+module AggregateRef
 
 open FStar.PCM
 module M = Steel.Memory

From f1d89d366a4f6a44f240c470e849db65cd17a548 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 21 Jun 2021 10:35:49 -0700
Subject: [PATCH 015/513] pcm_lens for first component of tuple

---
 examples/steel/AggregateRef.fst | 47 +++++++++++++++++++++++++++++++--
 1 file changed, 45 insertions(+), 2 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 16a6b44f49c..96340cc6349 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -59,6 +59,22 @@ let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
   (f:('a -> 'a){frame_pres p f x y})
   : frame_preserving_upd p x y
   = fun v -> f v
+(** The converse is not true, because a frame_preserving_upd's domain
+    is restricted to v:a{p.refine v /\ compatible p x v}. *)
+
+let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (g:(v:'a{p.refine v /\ compatible p x v} ->
+    Lemma (p.refine (f v) /\ compatible p y (f v))
+    [SMTPat (compatible p x v)]))
+  (h:(
+    (v:'a{p.refine v /\ compatible p x v} ->
+      Lemma (p.refine (f v) /\ compatible p y (f v))
+      [SMTPat (compatible p x v)]) ->
+    (v:'a{p.refine v /\ compatible p x v} -> frame:'a{composable p x frame} ->
+    Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == f v))
+     [SMTPat (compatible p x v); SMTPat (composable p x frame)])))
+: Lemma (frame_pres p f x y) =
+  let _ = g in let _ = h g in ()
 
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b)
     with the extra law that lens_upd lifts frame-preserving updates on
@@ -87,9 +103,36 @@ let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.raw.get s
 let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.raw.put v s
 let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.raw f s
 
+open Aggregates
+
+let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
+let lens_fst #a #b : lens (a & b) a = {
+  get = fst;
+  put = lens_fst_put;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
+  raw = lens_fst;
+  upd_resp_pcm = (fun (x, y) x' f ->
+    assert (forall (v:a{p.refine v /\ compatible p x v}). p.refine (f v) /\ compatible p x' (f v));
+    frame_pres_intro (tuple_pcm p q) (lens_upd lens_fst f) (x, y) (x', y)
+      (fun (v, w) ->
+        let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
+        compatible_elim p x' (f v) compat_ty (fun frame_v ->
+        compatible_elim q y w compat_ty (fun frame_w ->
+        compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w))))
+      (fun aux (v, w) _ ->
+        let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
+        compatible_elim p x' (f v) compat_ty (fun frame_v ->
+        compatible_elim q y w compat_ty (fun frame_w ->
+        compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w)))));
+}
+
 (* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a *)
 noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
-  l: pcm_lens p q;
+  l: pcm_lens p q; // additionally take refinement on a?
   r: M.ref a p;
 }
-

From 1c70e8930537911e947dad4641fc1b71f5397884 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 22 Jun 2021 14:38:04 -0700
Subject: [PATCH 016/513] First pass at restricting domain of PCM lenses

---
 examples/steel/AggregateRef.fst | 217 ++++++++++++++++++++++++++++----
 1 file changed, 194 insertions(+), 23 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 96340cc6349..58f638af3c6 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -44,6 +44,20 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
+let refine (f: 'a -> prop) = x:'a{f x}
+let ( << ) (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+
+let lens_refine_get (l: lens 'a 'b) f (s: refine (f << l.get)): refine f = l.get s
+let lens_refine_put (l: lens 'a 'b) f (v: refine f) (s: refine (f << l.get)): refine (f << l.get) =
+  l.put v s
+let lens_refine (l: lens 'a 'b) (f: 'b -> prop) : lens (refine (f << l.get)) (refine f) = {
+  get = lens_refine_get l f;
+  put = lens_refine_put l f;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
 (** The non-computational part of frame_preserving_upd
     TODO: move this and lemmas about this to FStar.PCM.fst *)
 let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
@@ -63,29 +77,41 @@ let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
     is restricted to v:a{p.refine v /\ compatible p x v}. *)
 
 let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (g:(v:'a{p.refine v /\ compatible p x v} ->
-    Lemma (p.refine (f v) /\ compatible p y (f v))
-    [SMTPat (compatible p x v)]))
-  (h:(
-    (v:'a{p.refine v /\ compatible p x v} ->
-      Lemma (p.refine (f v) /\ compatible p y (f v))
-      [SMTPat (compatible p x v)]) ->
-    (v:'a{p.refine v /\ compatible p x v} -> frame:'a{composable p x frame} ->
-    Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == f v))
-     [SMTPat (compatible p x v); SMTPat (composable p x frame)])))
+  (g:(v:'a{p.refine v /\ compatible p x v} -> 
+     Lemma (p.refine (f v) /\ compatible p y (f v) /\
+            (forall (frame:'a{composable p x frame}).
+              composable p y frame /\
+              (op p x frame == v ==> op p y frame == f v)))
+     [SMTPat (compatible p x v)]))
 : Lemma (frame_pres p f x y) =
-  let _ = g in let _ = h g in ()
+  let _ = g in ()
 
+(* TODO idea: problem is that PCM and lens need two different refinements.
+   PCM needs f \/ is_unit
+   lens just needs f
+   instead of threading refinements through all the code,
+   assume client wll instantiate with f \/ is_unit
+   and make lens refinement be x:(refine f){x is not unit}
+
+   problem:
+   - unions require restrictions
+   - restrictions mean changing the type of the pcm_lens
+   - the pcm_lens has two parts: a lens and a pcm
+   - need to change both, interact between the two gets very tricky
+   - main sticking point: a PCM needs a unit. what is the unit of a PCM restricted to the Left case?
+   - code gets "very dependently typed", can no longer take simply
+     typed code and add some things on top *)
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b)
     with the extra law that lens_upd lifts frame-preserving updates on
     b w.r.t. q to frame-preserving updates on a w.r.t. p. *)
-noeq type pcm_lens (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
+noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   raw: lens a b;
-  upd_resp_pcm: s: a -> v: b -> f:(b -> b) ->
+  upd_resp_pcm: s: a -> v: b -> upd:(b -> b) ->
     Lemma
-      (requires frame_pres q f (raw.get s) v)
-      (ensures frame_pres p (lens_upd raw f) s (raw.put v s));
+      (requires frame_pres q upd (raw.get s) v)
+      (ensures frame_pres p (lens_upd raw upd) s (raw.put v s));
 }
+
 let upd_resp_pcm' (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
   : Lemma
       (requires frame_pres q f (l.raw.get s) v)
@@ -120,19 +146,164 @@ let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
     assert (forall (v:a{p.refine v /\ compatible p x v}). p.refine (f v) /\ compatible p x' (f v));
     frame_pres_intro (tuple_pcm p q) (lens_upd lens_fst f) (x, y) (x', y)
       (fun (v, w) ->
-        let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
-        compatible_elim p x' (f v) compat_ty (fun frame_v ->
-        compatible_elim q y w compat_ty (fun frame_w ->
-        compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w))))
-      (fun aux (v, w) _ ->
         let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
         compatible_elim p x' (f v) compat_ty (fun frame_v ->
         compatible_elim q y w compat_ty (fun frame_w ->
         compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w)))));
 }
 
-(* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a *)
-noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) (q: pcm b) = {
-  l: pcm_lens p q; // additionally take refinement on a?
+(* We can create lenses for unions if we know which case of the union we are in: *)
+
+let either_l a b = x:either a b{Inl? x}
+let lens_left_put (y: 'a) (x:either_l 'a 'b): either_l 'a 'b =
+  Inl y
+let lens_left #a #b : lens (either_l a b) a = {
+  get = Inl?.v;
+  put = lens_left_put;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let lens_left_fst #a #b #c: lens (either_l (a & b) c) a = lens_comp lens_left lens_fst
+let lens_fst_left #a #b #c: lens ((either_l a b) & c) a = lens_comp lens_fst lens_left
+
+(* TODO
+   This definition of restrictions is not quite right.
+   It requires the restricted PCM to contain the unit of the unrestricted PCM, but it's possible that a new, more restricted element of the PCM is now a unit.
+   Example: if you have PCM for a 2-case union (a + b), carrier is option (option a + option b) and unit is None.
+   But, when when we know that we are in the left case, carrier should be x:option(option a + option b){Some?x /\ Inl? (Some?.v x)}
+   and the unit should be Some (Inl None).
+    *)
+(* From a suitably well-behaved predicate f and PCM p with carrier a,
+   we can construct a PCM with carrier x:a{f x \/ x == 1} *)
+
+let satisfies (p: pcm 'a) (f: 'a -> prop) (x: 'a) = f x \/ x == p.p.one
+
+let respects #a (p: pcm a) (f: a -> prop) =
+  x:a{satisfies p f x} -> y:a{satisfies p f y /\ composable p x y} ->
+  Lemma (satisfies p f (op p x y))
+
+let satisfying (p: pcm 'a) f = x:'a{f x \/ x == p.p.one}
+
+let comp_restrict (p: pcm 'a) #f (re: respects p f): symrel (satisfying p f) = composable p
+
+let op_restrict (p: pcm 'a) #f (re: respects p f) (x: satisfying p f)
+  (y:satisfying p f{composable p x y}): satisfying p f
+= re x y; op p x y
+
+let one_restrict (p: pcm 'a) #f (re: respects p f): satisfying p f = p.p.one
+  
+let restrict (p: pcm 'a) #f (re: respects p f): pcm (satisfying p f) = {
+  p = {composable = comp_restrict p re; op = op_restrict p re; one = one_restrict p re};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> p.is_unit x);
+  refine = p.refine;
+}
+
+(* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
+   The base type of the lens, unlike the Steel.Memory.ref, can be refined by a respects re. *)
+noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) #f (re: respects p f) (q: pcm b) = {
+  l: pcm_lens (restrict p re) q;
   r: M.ref a p;
 }
+
+(* A ref r points to a value v if there exists a whole value s in the heap such that
+   - v is inside s
+   - s satisfies re.f *)
+let pts_to (#p: pcm 'a) #f (#re: respects p f) (#q: pcm 'b) (r: ref p re q) (v: 'b): M.slprop =
+  M.(h_exists (fun s -> pts_to r.r s `star` pure (f s /\ get r.l s == v)))
+
+let weakest_respects (p: pcm 'a): respects p (fun _ -> True) =
+  fun _ _ -> ()
+
+let both (f g: 'a -> prop) (x: 'a): prop = f x /\ g x
+
+let respects_both (p: pcm 'a) #f #g (r: respects p f) (s: respects p g): respects p (both f g) =
+  fun x y -> r x y; s x y
+
+let respects_iff (p: pcm 'a) (#f #g: 'a -> prop)
+  (h:(x:'a -> Lemma (f x <==> g x))) (r: respects p f): respects p g
+= fun x y -> h x; h y; r x y; h (op p x y)
+
+let either_composable (p: pcm 'a) (q: pcm 'b): symrel (option (either 'a 'b)) =
+  fun x y -> match x, y with
+    | None, _ | _, None -> True
+    | Some (Inl x), Some (Inl y) -> composable p x y
+    | Some (Inr x), Some (Inr y) -> composable q x y
+    | _, _ -> False
+let either_op (p: pcm 'a) (q: pcm 'b) (x: option (either 'a 'b))
+  (y: option (either 'a 'b){either_composable p q x y})
+: option (either 'a 'b) = match x, y with
+  | None, z | z, None -> z
+  | Some (Inl x), Some (Inl y) -> Some (Inl (op p x y))
+  | Some (Inr x), Some (Inr y) -> Some (Inr (op q x y))
+    
+let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = {
+  p = {composable = either_composable p q; op = either_op p q; one = None};
+  comm = (fun x y -> match x, y with
+    | None, _ | _, None -> ()
+    | Some (Inl x), Some (Inl y) -> p.comm x y
+    | Some (Inr x), Some (Inr y) -> q.comm x y);
+  assoc = (fun x y z -> match x, y, z with
+    | Some (Inl x), Some (Inl y), Some (Inl z) -> p.assoc x y z
+    | Some (Inr x), Some (Inr y), Some (Inr z) -> q.assoc x y z
+    | _, _, _ -> ());
+  assoc_r = (fun x y z -> match x, y, z with
+    | Some (Inl x), Some (Inl y), Some (Inl z) -> p.assoc_r x y z
+    | Some (Inr x), Some (Inr y), Some (Inr z) -> q.assoc_r x y z
+    | _, _, _ -> ());
+  is_unit = (fun x -> ());
+  refine = (fun x -> match x with
+    | None -> True
+    | Some (Inl x) -> p.refine x
+    | Some (Inr x) -> q.refine x);
+}
+
+let is_inl (x: option (either 'a 'b)): prop = Some? x /\ Inl? (Some?.v x)
+let oeither_l a b = x:option (either a b){is_inl x}
+
+let is_inl_resp (p: pcm 'a) (q: pcm 'b): respects (either_pcm p q) is_inl =
+  fun x y -> ()
+
+let pcm_inl_comp #b (p: pcm 'a): symrel (oeither_l 'a b) =
+  fun (Some (Inl x)) (Some (Inl y)) -> composable p x y
+  
+let pcm_inl_op (p: pcm 'a) (x: oeither_l 'a 'b) (y: oeither_l 'a 'b{pcm_inl_comp p x y}): oeither_l 'a 'b
+= match x, y with (Some (Inl x)), (Some (Inl y)) -> Some (Inl (op p x y))
+
+let pcm_inl_one #b (p: pcm 'a): oeither_l 'a b = Some (Inl p.p.one)
+
+let pcm_inl (p: pcm 'a) (q: pcm 'b): pcm (oeither_l 'a 'b) = {
+  p = {composable = pcm_inl_comp p; op = pcm_inl_op p; one = pcm_inl_one p};
+  comm = (fun (Some (Inl x)) (Some (Inl y)) -> p.comm x y);
+  assoc = (fun (Some (Inl x)) (Some (Inl y)) (Some (Inl z)) -> p.assoc x y z);
+  assoc_r = (fun (Some (Inl x)) (Some (Inl y)) (Some (Inl z)) -> p.assoc_r x y z);
+  is_unit = (fun (Some (Inl x)) -> p.is_unit x);
+  refine = (fun (Some (Inl x)) -> p.refine x)
+}
+
+// let lens_inl: lens (oeither_l a b) 'a
+// let pcm_lens_inl (p: pcm 'a) (q: pcm 'b): pcm_lens (either_pcm p q) = {
+// }
+
+// {r `M.pts_to` op p (x, one) (one, y) }
+// ..
+// {r `M.pts_to` (x, one) `star` r `M.pts_to` (one, y)}
+// ..
+// {addr_of_fst r `pts_to` x `star` addr_of_snd r `pts_to` y `star` pure (lenses_compose r1.l r2.l /\ r2.r == r2.r)}
+// exists s1 s2. r `pts_to` op p s1 s2
+// get r1.l s1 = x ==> s1 is at least (x, one) (based on defn. of r1.l and fact that it's frame-preserving)
+// get r2.l s2 = y ==> s2 is at least (one, y)
+// ---------------
+// op p s1 s2 = (x, y)
+// 
+// r1 `pts_to` x
+//   M.(h_exists (fun (x, y) -> pts_to r.r (x, one) `star` pure (re.f (x, one) /\ x == x)))
+//   `star`
+// r2 `pts_to` y
+//   M.(h_exists (fun (x, y) -> pts_to r.r (one, y) `star` pure (re.f (one, y) /\ y == y)))
+
+(* TODO: construct instances of restricted PCMs for structs and their fields; unions and their cases *)

From 47aa9d86467ee5e1137ba5ad7ec3747567f1eeef Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 23 Jun 2021 15:49:16 -0700
Subject: [PATCH 017/513] Simplify pcm_lens definition

Define pcm_lens as a lens with the additional requirement that put and get be PCM morphisms. This implies the old requirement (that a pcm_lens lift frame-preserving updates on the target to frame-preserving updates on the source)
---
 examples/steel/AggregateRef.fst | 393 ++++++++++++++++++--------------
 1 file changed, 216 insertions(+), 177 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 58f638af3c6..adf73a60b80 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -2,6 +2,7 @@ module AggregateRef
 
 open FStar.PCM
 module M = Steel.Memory
+module P = FStar.PCM
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -44,13 +45,13 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
-let refine (f: 'a -> prop) = x:'a{f x}
-let ( << ) (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+let refine_t (f: 'a -> prop) = x:'a{f x}
 
-let lens_refine_get (l: lens 'a 'b) f (s: refine (f << l.get)): refine f = l.get s
-let lens_refine_put (l: lens 'a 'b) f (v: refine f) (s: refine (f << l.get)): refine (f << l.get) =
+let ( << ) (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+let lens_refine_get (l: lens 'a 'b) f (s: refine_t (f << l.get)): refine_t f = l.get s
+let lens_refine_put (l: lens 'a 'b) f (v: refine_t f) (s: refine_t (f << l.get)): refine_t (f << l.get) =
   l.put v s
-let lens_refine (l: lens 'a 'b) (f: 'b -> prop) : lens (refine (f << l.get)) (refine f) = {
+let lens_refine (l: lens 'a 'b) (f: 'b -> prop) : lens (refine_t (f << l.get)) (refine_t f) = {
   get = lens_refine_get l f;
   put = lens_refine_put l f;
   get_put = (fun _ _ -> ());
@@ -58,16 +59,45 @@ let lens_refine (l: lens 'a 'b) (f: 'b -> prop) : lens (refine (f << l.get)) (re
   put_put = (fun _ _ _ -> ());
 }
 
+let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
+let lens_fst #a #b : lens (a & b) a = {
+  get = fst;
+  put = lens_fst_put;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+(** We can create lenses for unions if we know which case of the union we are in: *)
+
+let either_l a b = x:either a b{Inl? x}
+let lens_left_put (y: 'a) (x:either_l 'a 'b): either_l 'a 'b =
+  Inl y
+let lens_left #a #b : lens (either_l a b) a = {
+  get = Inl?.v;
+  put = lens_left_put;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let lens_left_fst #a #b #c: lens (either_l (a & b) c) a = lens_comp lens_left lens_fst
+let lens_fst_left #a #b #c: lens ((either_l a b) & c) a = lens_comp lens_fst lens_left
+
 (** The non-computational part of frame_preserving_upd
     TODO: move this and lemmas about this to FStar.PCM.fst *)
-let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
-  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
-  p.refine (f v) /\
+let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (v:'a{p.refine v /\ compatible p x v})
+= p.refine (f v) /\
   compatible p y (f v) /\
   (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
      composable p y frame /\
      (op p x frame == v ==> op p y frame == f v))
 
+let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
+  frame_pres_on p f x y v
+
 (** Every function satisfying frame_pres is a frame_preserving_upd *)
 let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
   (f:('a -> 'a){frame_pres p f x y})
@@ -86,147 +116,113 @@ let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
 : Lemma (frame_pres p f x y) =
   let _ = g in ()
 
-(* TODO idea: problem is that PCM and lens need two different refinements.
-   PCM needs f \/ is_unit
-   lens just needs f
-   instead of threading refinements through all the code,
-   assume client wll instantiate with f \/ is_unit
-   and make lens refinement be x:(refine f){x is not unit}
-
-   problem:
-   - unions require restrictions
-   - restrictions mean changing the type of the pcm_lens
-   - the pcm_lens has two parts: a lens and a pcm
-   - need to change both, interact between the two gets very tricky
-   - main sticking point: a PCM needs a unit. what is the unit of a PCM restricted to the Left case?
-   - code gets "very dependently typed", can no longer take simply
-     typed code and add some things on top *)
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b)
-    with the extra law that lens_upd lifts frame-preserving updates on
-    b w.r.t. q to frame-preserving updates on a w.r.t. p. *)
+    with the extra requirement that [get] and [put] be PCM morphisms. *)
 noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
-  raw: lens a b;
-  upd_resp_pcm: s: a -> v: b -> upd:(b -> b) ->
+  l: lens a b;
+  get_refine: s:a -> Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
+  get_op: s:a -> t:a ->
+    Lemma
+      (requires composable p s t)
+      (ensures composable q (l.get s) (l.get t) /\ 
+               l.get (op p s t) == op q (l.get s) (l.get t))
+               // Technically, this distributivity law is derivable from the one for put:
+               //   get (s * t) = get (put (get s) s * put (get t) t)
+               //   = get (put (get s * get t) (s * t)) = get s * get t
+    [SMTPat (composable p s t); SMTPat (l.get (op p s t))];
+  put_refine: s:a -> v:b ->
+    Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
+    [SMTPat (p.refine (l.put v s))];
+  put_op: s:a -> t:a -> v:b -> w:b ->
     Lemma
-      (requires frame_pres q upd (raw.get s) v)
-      (ensures frame_pres p (lens_upd raw upd) s (raw.put v s));
+      (requires composable p s t /\ composable q v w)
+      (ensures composable p (l.put v s) (l.put w t) /\
+               l.put (op q v w) (op p s t) == op p (l.put v s) (l.put w t))
+    [SMTPat (l.put (op q v w) (op p s t)); SMTPat (composable p (l.put v s) (l.put w t))];
 }
 
-let upd_resp_pcm' (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
-  : Lemma
-      (requires frame_pres q f (l.raw.get s) v)
-      (ensures frame_pres p (lens_upd l.raw f) s (l.raw.put v s))
-      [SMTPat (frame_pres q f (l.raw.get s) v)]
-  = l.upd_resp_pcm s v f
-
-let pcm_lens_id (#p: pcm 'a): pcm_lens p p
-  = {raw = lens_id; upd_resp_pcm = (fun _ _ _ -> ())}
-let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r
-  = {raw = lens_comp l.raw m.raw; upd_resp_pcm = (fun _ _ _ -> ())}
-
-let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.raw.get s
-let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.raw.put v s
-let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.raw f s
+let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (l.l.get x) (l.l.get y))
+= compatible_elim p x y (compatible q (l.l.get x) (l.l.get y)) (fun frame_x ->
+  let _ = l.get_op frame_x x in
+  compatible_intro q (l.l.get x) (l.l.get y) (l.l.get frame_x))
+
+let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
+: Lemma
+    (requires frame_pres q f (l.l.get s) v)
+    (ensures frame_pres p (lens_upd l.l f) s (l.l.put v s))
+    [SMTPat (frame_pres q f (l.l.get s) v)]
+= frame_pres_intro p (lens_upd l.l f) s (l.l.put v s) (fun full ->
+    assert (p.refine full);
+    assert (compatible p s full);
+    assert (lens_upd l.l f full == l.l.put (f (l.l.get full)) full);
+    let _ = l.get_refine in
+    assert (q.refine (l.l.get full));
+    pcm_lens_compatible_get l s full;
+    assert (compatible q (l.l.get s) (l.l.get full));
+    assert (q.refine (f (l.l.get full)));
+    let _ = l.put_refine in
+    assert (p.refine (lens_upd l.l f full));
+    assert (compatible q v (f (l.l.get full)));
+    let goal = frame_pres_on p (lens_upd l.l f) s (l.l.put v s) full in
+    compatible_elim p s full goal (fun frame_s ->
+    compatible_elim q v (f (l.l.get full)) goal (fun frame_v ->
+    assert (composable q v frame_v /\ op q frame_v v == f (l.l.get full));
+    let frame_vs: 'a = l.l.put frame_v frame_s in
+    l.put_op s frame_s v frame_v;
+    assert (composable p (l.l.put v s) frame_vs);
+    p.comm frame_vs (l.l.put v s);
+    q.comm v frame_v;
+    p.comm s frame_s;
+    assert (op p frame_vs (l.l.put v s) == op p (l.l.put v s) frame_vs);
+    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
+    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
+    assert (op p frame_vs (l.l.put v s) == lens_upd l.l f full);
+    compatible_intro p (l.l.put v s) (lens_upd l.l f full) frame_vs;
+    let aux (frame:'a{composable p s frame})
+    : Lemma (composable p (l.l.put v s) frame /\
+             (op p s frame == full ==> op p (l.l.put v s) frame == lens_upd l.l f full))
+    = l.get_op s frame;
+      assert (composable q (l.l.get s) (l.l.get frame));
+      assert (composable q v (l.l.get frame));
+      assert (composable p s frame);
+      l.put_op s frame v (l.l.get frame);
+      let aux ()
+      : Lemma (requires op p s frame == full) 
+              (ensures op p (l.l.put v s) frame == lens_upd l.l f full)
+      = assert (composable p (l.l.put v s) (l.l.put (l.l.get frame) frame));
+        assert (op p (l.l.put v s) frame == op p (l.l.put v s) (l.l.put (l.l.get frame) frame));
+        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) (op p s frame));
+        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) full);
+        ()
+      in ()
+    in FStar.Classical.forall_intro aux)))
+
+// let pcm_lens_id (#p: pcm 'a): pcm_lens p p
+//   = {raw = lens_id; upd_resp_pcm = (fun _ _ _ -> ())}
+// let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+//   (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r
+//   = {raw = lens_comp l.raw m.raw; upd_resp_pcm = (fun _ _ _ -> ())}
+// 
+// let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.raw.get s
+// let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.raw.put v s
+// let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.raw f s
 
 open Aggregates
 
-let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
-let lens_fst #a #b : lens (a & b) a = {
-  get = fst;
-  put = lens_fst_put;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
-  raw = lens_fst;
-  upd_resp_pcm = (fun (x, y) x' f ->
-    assert (forall (v:a{p.refine v /\ compatible p x v}). p.refine (f v) /\ compatible p x' (f v));
-    frame_pres_intro (tuple_pcm p q) (lens_upd lens_fst f) (x, y) (x', y)
-      (fun (v, w) ->
-        let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
-        compatible_elim p x' (f v) compat_ty (fun frame_v ->
-        compatible_elim q y w compat_ty (fun frame_w ->
-        compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w)))));
-}
-
-(* We can create lenses for unions if we know which case of the union we are in: *)
-
-let either_l a b = x:either a b{Inl? x}
-let lens_left_put (y: 'a) (x:either_l 'a 'b): either_l 'a 'b =
-  Inl y
-let lens_left #a #b : lens (either_l a b) a = {
-  get = Inl?.v;
-  put = lens_left_put;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let lens_left_fst #a #b #c: lens (either_l (a & b) c) a = lens_comp lens_left lens_fst
-let lens_fst_left #a #b #c: lens ((either_l a b) & c) a = lens_comp lens_fst lens_left
-
-(* TODO
-   This definition of restrictions is not quite right.
-   It requires the restricted PCM to contain the unit of the unrestricted PCM, but it's possible that a new, more restricted element of the PCM is now a unit.
-   Example: if you have PCM for a 2-case union (a + b), carrier is option (option a + option b) and unit is None.
-   But, when when we know that we are in the left case, carrier should be x:option(option a + option b){Some?x /\ Inl? (Some?.v x)}
-   and the unit should be Some (Inl None).
-    *)
-(* From a suitably well-behaved predicate f and PCM p with carrier a,
-   we can construct a PCM with carrier x:a{f x \/ x == 1} *)
-
-let satisfies (p: pcm 'a) (f: 'a -> prop) (x: 'a) = f x \/ x == p.p.one
-
-let respects #a (p: pcm a) (f: a -> prop) =
-  x:a{satisfies p f x} -> y:a{satisfies p f y /\ composable p x y} ->
-  Lemma (satisfies p f (op p x y))
-
-let satisfying (p: pcm 'a) f = x:'a{f x \/ x == p.p.one}
-
-let comp_restrict (p: pcm 'a) #f (re: respects p f): symrel (satisfying p f) = composable p
-
-let op_restrict (p: pcm 'a) #f (re: respects p f) (x: satisfying p f)
-  (y:satisfying p f{composable p x y}): satisfying p f
-= re x y; op p x y
-
-let one_restrict (p: pcm 'a) #f (re: respects p f): satisfying p f = p.p.one
-  
-let restrict (p: pcm 'a) #f (re: respects p f): pcm (satisfying p f) = {
-  p = {composable = comp_restrict p re; op = op_restrict p re; one = one_restrict p re};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> p.is_unit x);
-  refine = p.refine;
-}
-
-(* A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-   The base type of the lens, unlike the Steel.Memory.ref, can be refined by a respects re. *)
-noeq type ref (#a: Type u#a) (#b: Type u#b) (p: pcm a) #f (re: respects p f) (q: pcm b) = {
-  l: pcm_lens (restrict p re) q;
-  r: M.ref a p;
-}
-
-(* A ref r points to a value v if there exists a whole value s in the heap such that
-   - v is inside s
-   - s satisfies re.f *)
-let pts_to (#p: pcm 'a) #f (#re: respects p f) (#q: pcm 'b) (r: ref p re q) (v: 'b): M.slprop =
-  M.(h_exists (fun s -> pts_to r.r s `star` pure (f s /\ get r.l s == v)))
-
-let weakest_respects (p: pcm 'a): respects p (fun _ -> True) =
-  fun _ _ -> ()
-
-let both (f g: 'a -> prop) (x: 'a): prop = f x /\ g x
-
-let respects_both (p: pcm 'a) #f #g (r: respects p f) (s: respects p g): respects p (both f g) =
-  fun x y -> r x y; s x y
+// let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
+//   l = lens_fst;
+//   upd_resp_pcm = (fun (x, y) x' f ->
+//     assert (forall (v:a{p.refine v /\ compatible p x v}). p.refine (f v) /\ compatible p x' (f v));
+//     frame_pres_intro (tuple_pcm p q) (lens_upd lens_fst f) (x, y) (x', y)
+//       (fun (v, w) ->
+//         let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
+//         compatible_elim p x' (f v) compat_ty (fun frame_v ->
+//         compatible_elim q y w compat_ty (fun frame_w ->
+//         compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w)))));
+// }
 
-let respects_iff (p: pcm 'a) (#f #g: 'a -> prop)
-  (h:(x:'a -> Lemma (f x <==> g x))) (r: respects p f): respects p g
-= fun x y -> h x; h y; r x y; h (op p x y)
+(** A PCM for binary sums *)
 
 let either_composable (p: pcm 'a) (q: pcm 'b): symrel (option (either 'a 'b)) =
   fun x y -> match x, y with
@@ -262,48 +258,91 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = {
     | Some (Inr x) -> q.refine x);
 }
 
-let is_inl (x: option (either 'a 'b)): prop = Some? x /\ Inl? (Some?.v x)
-let oeither_l a b = x:option (either a b){is_inl x}
+(** A PCM for possibly uninitialized data *)
 
-let is_inl_resp (p: pcm 'a) (q: pcm 'b): respects (either_pcm p q) is_inl =
-  fun x y -> ()
+type init a =
+| Uninitialized : init a
+| One : init a
+| Initialized : a -> init a
 
-let pcm_inl_comp #b (p: pcm 'a): symrel (oeither_l 'a b) =
-  fun (Some (Inl x)) (Some (Inl y)) -> composable p x y
-  
-let pcm_inl_op (p: pcm 'a) (x: oeither_l 'a 'b) (y: oeither_l 'a 'b{pcm_inl_comp p x y}): oeither_l 'a 'b
-= match x, y with (Some (Inl x)), (Some (Inl y)) -> Some (Inl (op p x y))
+let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
+  | One, _ | _, One -> True
+  | Uninitialized, Uninitialized -> True
+  | Initialized x, Initialized y -> composable p x y
+  | _, _ -> False
 
-let pcm_inl_one #b (p: pcm 'a): oeither_l 'a b = Some (Inl p.p.one)
+let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
+  | One, z | z, One -> z
+  | Uninitialized, Uninitialized -> Uninitialized
+  | Initialized x, Initialized y -> Initialized (op p x y)
 
-let pcm_inl (p: pcm 'a) (q: pcm 'b): pcm (oeither_l 'a 'b) = {
-  p = {composable = pcm_inl_comp p; op = pcm_inl_op p; one = pcm_inl_one p};
-  comm = (fun (Some (Inl x)) (Some (Inl y)) -> p.comm x y);
-  assoc = (fun (Some (Inl x)) (Some (Inl y)) (Some (Inl z)) -> p.assoc x y z);
-  assoc_r = (fun (Some (Inl x)) (Some (Inl y)) (Some (Inl z)) -> p.assoc_r x y z);
-  is_unit = (fun (Some (Inl x)) -> p.is_unit x);
-  refine = (fun (Some (Inl x)) -> p.refine x)
+let init_pcm (p: pcm 'a): pcm (init 'a) = {
+  p = {composable = init_comp p; op = init_op p; one = One #'a};
+  comm = (fun x y -> match x, y with
+    | Initialized x, Initialized y -> p.comm x y
+    | _, _ -> ());
+  assoc = (fun x y z -> match x, y, z with
+    | Initialized x, Initialized y, Initialized z -> p.assoc x y z
+    | _, _, _ -> ());
+  assoc_r = (fun x y z -> match x, y, z with
+    | Initialized x, Initialized y, Initialized z -> p.assoc_r x y z
+    | _, _, _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with
+    | Initialized x -> p.refine x
+    | _ -> True)
 }
 
-// let lens_inl: lens (oeither_l a b) 'a
-// let pcm_lens_inl (p: pcm 'a) (q: pcm 'b): pcm_lens (either_pcm p q) = {
-// }
+(** A refinement of a PCM p *)
 
-// {r `M.pts_to` op p (x, one) (one, y) }
-// ..
-// {r `M.pts_to` (x, one) `star` r `M.pts_to` (one, y)}
-// ..
-// {addr_of_fst r `pts_to` x `star` addr_of_snd r `pts_to` y `star` pure (lenses_compose r1.l r2.l /\ r2.r == r2.r)}
-// exists s1 s2. r `pts_to` op p s1 s2
-// get r1.l s1 = x ==> s1 is at least (x, one) (based on defn. of r1.l and fact that it's frame-preserving)
-// get r2.l s2 = y ==> s2 is at least (one, y)
-// ---------------
-// op p s1 s2 = (x, y)
-// 
-// r1 `pts_to` x
-//   M.(h_exists (fun (x, y) -> pts_to r.r (x, one) `star` pure (re.f (x, one) /\ x == x)))
-//   `star`
-// r2 `pts_to` y
-//   M.(h_exists (fun (x, y) -> pts_to r.r (one, y) `star` pure (re.f (one, y) /\ y == y)))
+noeq type pcm_refinement #a (p: pcm a) = {
+  f: a -> prop;
+  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
+  new_one: refine_t f;
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+}
+
+let pcm_refine_comp (p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+
+let pcm_refine_op (p: pcm 'a) (r: pcm_refinement p)
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_under_op x y; op p x y
+
+let pcm_refine (p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp p r; op = pcm_refine_op p r; one = r.new_one};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  refine = p.refine;
+}
+
+let trivial_refinement (p: pcm 'a): pcm_refinement p = {
+  f = (fun x -> True);
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = p.p.one;
+  new_one_is_refined_unit = p.is_unit;
+}
+
+let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
+  f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = Some (Inl #_ #'b p.p.one);
+  new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
+}
+
+(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
+    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re. *)
+noeq type ref (a: Type u#a) (b: Type u#b) = {
+  p: pcm a;
+  re: pcm_refinement p;
+  q: pcm b;
+  l: pcm_lens (pcm_refine p re) q;
+  r: M.ref a p;
+}
 
-(* TODO: construct instances of restricted PCMs for structs and their fields; unions and their cases *)
+// (** A ref r points to a value v if r `Steel.Memory.pts_to` put v one, where
+//     - put comes from r's pcm_lens
+//     - one is the unit of r's refined PCM for the source type *)
+// let pts_to (r: ref 'a 'b) (v: 'b): M.slprop =
+//   M.pts_to r.r (put r.l v (pcm_refine r.p r.re).P.p.one)

From 0c3921fe1a349be6455e12459a03fd7149585d0b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 23 Jun 2021 16:17:52 -0700
Subject: [PATCH 018/513] Tidy

---
 examples/steel/AggregateRef.fst | 318 ++++++++++++++++----------------
 1 file changed, 155 insertions(+), 163 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index adf73a60b80..fa96786fd91 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -25,6 +25,7 @@ let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
 (** Updating the target of a lens *)
 let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
 
+(** The identity lens *)
 let const (x: 'a) (b: 'b): 'a = x
 let lens_id #a : lens a a = {
   get = id;
@@ -34,6 +35,7 @@ let lens_id #a : lens a a = {
   put_put = (fun _ _ _ -> ());
 }
 
+(** Lens composition *)
 let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
 let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
   lens_upd l (m.put v) s
@@ -45,45 +47,6 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
-let refine_t (f: 'a -> prop) = x:'a{f x}
-
-let ( << ) (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
-let lens_refine_get (l: lens 'a 'b) f (s: refine_t (f << l.get)): refine_t f = l.get s
-let lens_refine_put (l: lens 'a 'b) f (v: refine_t f) (s: refine_t (f << l.get)): refine_t (f << l.get) =
-  l.put v s
-let lens_refine (l: lens 'a 'b) (f: 'b -> prop) : lens (refine_t (f << l.get)) (refine_t f) = {
-  get = lens_refine_get l f;
-  put = lens_refine_put l f;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
-let lens_fst #a #b : lens (a & b) a = {
-  get = fst;
-  put = lens_fst_put;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** We can create lenses for unions if we know which case of the union we are in: *)
-
-let either_l a b = x:either a b{Inl? x}
-let lens_left_put (y: 'a) (x:either_l 'a 'b): either_l 'a 'b =
-  Inl y
-let lens_left #a #b : lens (either_l a b) a = {
-  get = Inl?.v;
-  put = lens_left_put;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let lens_left_fst #a #b #c: lens (either_l (a & b) c) a = lens_comp lens_left lens_fst
-let lens_fst_left #a #b #c: lens ((either_l a b) & c) a = lens_comp lens_fst lens_left
-
 (** The non-computational part of frame_preserving_upd
     TODO: move this and lemmas about this to FStar.PCM.fst *)
 let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
@@ -93,7 +56,6 @@ let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
   (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
      composable p y frame /\
      (op p x frame == v ==> op p y frame == f v))
-
 let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
   forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
   frame_pres_on p f x y v
@@ -117,18 +79,21 @@ let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
   let _ = g in ()
 
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b)
-    with the extra requirement that [get] and [put] be PCM morphisms. *)
+    with the extra requirement that get and put be PCM morphisms. *)
 noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   l: lens a b;
-  get_refine: s:a -> Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
+  get_refine: s:a ->
+    Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
   get_op: s:a -> t:a ->
     Lemma
       (requires composable p s t)
       (ensures composable q (l.get s) (l.get t) /\ 
                l.get (op p s t) == op q (l.get s) (l.get t))
-               // Technically, this distributivity law is derivable from the one for put:
-               //   get (s * t) = get (put (get s) s * put (get t) t)
-               //   = get (put (get s * get t) (s * t)) = get s * get t
+               (* Technically, this distributivity law is derivable from the one for put:
+                    get (s * t)
+                    = get (put (get s) s * put (get t) t)
+                    = get (put (get s * get t) (s * t))
+                    = get s * get t *)
     [SMTPat (composable p s t); SMTPat (l.get (op p s t))];
   put_refine: s:a -> v:b ->
     Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
@@ -140,87 +105,161 @@ noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
                l.put (op q v w) (op p s t) == op p (l.put v s) (l.put w t))
     [SMTPat (l.put (op q v w) (op p s t)); SMTPat (composable p (l.put v s) (l.put w t))];
 }
+let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
+let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
+let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
 
 let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (l.l.get x) (l.l.get y))
-= compatible_elim p x y (compatible q (l.l.get x) (l.l.get y)) (fun frame_x ->
+: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
+= compatible_elim p x y (compatible q (get l x) (get l y)) (fun frame_x ->
   let _ = l.get_op frame_x x in
-  compatible_intro q (l.l.get x) (l.l.get y) (l.l.get frame_x))
+  compatible_intro q (get l x) (get l y) (get l frame_x))
 
+(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
+    frame-preserving updates on the source *)
 let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
 : Lemma
-    (requires frame_pres q f (l.l.get s) v)
-    (ensures frame_pres p (lens_upd l.l f) s (l.l.put v s))
-    [SMTPat (frame_pres q f (l.l.get s) v)]
-= frame_pres_intro p (lens_upd l.l f) s (l.l.put v s) (fun full ->
-    assert (p.refine full);
-    assert (compatible p s full);
-    assert (lens_upd l.l f full == l.l.put (f (l.l.get full)) full);
+    (requires frame_pres q f (get l s) v)
+    (ensures frame_pres p (upd l f) s (put l v s))
+    [SMTPat (frame_pres q f (get l s) v)]
+= frame_pres_intro p (upd l f) s (put l v s) (fun full ->
     let _ = l.get_refine in
-    assert (q.refine (l.l.get full));
     pcm_lens_compatible_get l s full;
-    assert (compatible q (l.l.get s) (l.l.get full));
-    assert (q.refine (f (l.l.get full)));
     let _ = l.put_refine in
-    assert (p.refine (lens_upd l.l f full));
-    assert (compatible q v (f (l.l.get full)));
-    let goal = frame_pres_on p (lens_upd l.l f) s (l.l.put v s) full in
+    let goal = frame_pres_on p (upd l f) s (put l v s) full in
     compatible_elim p s full goal (fun frame_s ->
-    compatible_elim q v (f (l.l.get full)) goal (fun frame_v ->
-    assert (composable q v frame_v /\ op q frame_v v == f (l.l.get full));
-    let frame_vs: 'a = l.l.put frame_v frame_s in
+    compatible_elim q v (f (get l full)) goal (fun frame_v ->
+    let frame_vs: 'a = put l frame_v frame_s in
     l.put_op s frame_s v frame_v;
-    assert (composable p (l.l.put v s) frame_vs);
-    p.comm frame_vs (l.l.put v s);
+    p.comm frame_vs (put l v s);
     q.comm v frame_v;
     p.comm s frame_s;
-    assert (op p frame_vs (l.l.put v s) == op p (l.l.put v s) frame_vs);
-    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
-    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
-    assert (op p frame_vs (l.l.put v s) == lens_upd l.l f full);
-    compatible_intro p (l.l.put v s) (lens_upd l.l f full) frame_vs;
+    compatible_intro p (put l v s) (upd l f full) frame_vs;
     let aux (frame:'a{composable p s frame})
-    : Lemma (composable p (l.l.put v s) frame /\
-             (op p s frame == full ==> op p (l.l.put v s) frame == lens_upd l.l f full))
+    : Lemma (composable p (put l v s) frame /\
+             (op p s frame == full ==> op p (put l v s) frame == upd l f full))
     = l.get_op s frame;
-      assert (composable q (l.l.get s) (l.l.get frame));
-      assert (composable q v (l.l.get frame));
-      assert (composable p s frame);
-      l.put_op s frame v (l.l.get frame);
-      let aux ()
-      : Lemma (requires op p s frame == full) 
-              (ensures op p (l.l.put v s) frame == lens_upd l.l f full)
-      = assert (composable p (l.l.put v s) (l.l.put (l.l.get frame) frame));
-        assert (op p (l.l.put v s) frame == op p (l.l.put v s) (l.l.put (l.l.get frame) frame));
-        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) (op p s frame));
-        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) full);
-        ()
-      in ()
+      l.put_op s frame v (get l frame)
     in FStar.Classical.forall_intro aux)))
 
-// let pcm_lens_id (#p: pcm 'a): pcm_lens p p
-//   = {raw = lens_id; upd_resp_pcm = (fun _ _ _ -> ())}
-// let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-//   (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r
-//   = {raw = lens_comp l.raw m.raw; upd_resp_pcm = (fun _ _ _ -> ())}
-// 
-// let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.raw.get s
-// let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.raw.put v s
-// let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.raw f s
+(** The identity lens is a pcm_lens *)
+let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
+  l = lens_id; 
+  get_refine = (fun _ -> ());
+  get_op = (fun _ _ -> ());
+  put_refine = (fun _ _ -> ());
+  put_op = (fun _ _ _ _ -> ());
+}
+
+(** pcm_lens composition is lens composition *)
+let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r = 
+{
+  l = lens_comp l.l m.l;
+  get_refine = (fun _ -> let _ = l.get_refine in let _ = m.get_refine in ());
+  get_op = (fun s t -> l.get_op s t; m.get_op (get l s) (get l t));
+  put_refine = (fun s v -> let _ = l.put_refine in let _ = m.put_refine in let _ = l.get_refine in ());
+  put_op = (fun s t v w ->
+    l.get_op s t;
+    m.put_op (get l s) (get l t) v w;
+    l.put_op s t (put m v (get l s)) (put m w (get l t)))
+}
+
+(** A refinement of a PCM p *)
+
+let refine_t (f: 'a -> prop) = x:'a{f x}
+
+noeq type pcm_refinement #a (p: pcm a) = {
+  f: a -> prop;
+  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
+  new_one: refine_t f;
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+}
+
+let pcm_refine_comp (p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+
+let pcm_refine_op (p: pcm 'a) (r: pcm_refinement p)
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_under_op x y; op p x y
+
+let pcm_refine (p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp p r; op = pcm_refine_op p r; one = r.new_one};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  refine = p.refine;
+}
+
+let trivial_refinement (p: pcm 'a): pcm_refinement p = {
+  f = (fun x -> True);
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = p.p.one;
+  new_one_is_refined_unit = p.is_unit;
+}
+
+(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
+    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re. *)
+noeq type ref (a: Type u#a) (b: Type u#b) = {
+  p: pcm a;
+  re: pcm_refinement p;
+  q: pcm b;
+  pl: pcm_lens (pcm_refine p re) q;
+  r: M.ref a p;
+}
+
+(** A ref r points to a value v if r `Steel.Memory.pts_to` put v one, where
+    - put comes from r's pcm_lens
+    - one is the unit of r's refined PCM for the source type *)
+let pts_to (r: ref 'a 'b) (v: 'b): M.slprop =
+  M.pts_to r.r (put r.pl v (pcm_refine r.p r.re).P.p.one)
+
+(*
+
+TODO:
+- Lens for a field of a prod_pcm
+- Refinement for a case of a union_pcm
+- Lens (with corresponding refinement) for a case of a union_pcm
+- Types of basic Steel operations manipulating pts_to
+
+*)
+
+(** Basic lenses *)
 
 open Aggregates
 
-// let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
-//   l = lens_fst;
-//   upd_resp_pcm = (fun (x, y) x' f ->
-//     assert (forall (v:a{p.refine v /\ compatible p x v}). p.refine (f v) /\ compatible p x' (f v));
-//     frame_pres_intro (tuple_pcm p q) (lens_upd lens_fst f) (x, y) (x', y)
-//       (fun (v, w) ->
-//         let compat_ty = compatible (tuple_pcm p q) (x', y) (f v, w) in
-//         compatible_elim p x' (f v) compat_ty (fun frame_v ->
-//         compatible_elim q y w compat_ty (fun frame_w ->
-//         compatible_intro (tuple_pcm p q) (x', y) (f v, w) (frame_v, frame_w)))));
-// }
+let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
+let lens_fst #a #b : lens (a & b) a = {
+  get = fst;
+  put = lens_fst_put;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
+  l = lens_fst;
+  get_refine = (fun _ -> ());
+  get_op = (fun _ _ -> ());
+  put_refine = (fun _ _ -> ());
+  put_op = (fun _ _ _ _ -> ());
+}
+
+(** We can create lenses for unions if we know which case of the union we are in: *)
+
+let either_l a b = x:either a b{Inl? x}
+let lens_left_put (y: 'a) (x:either_l 'a 'b): either_l 'a 'b =
+  Inl y
+let lens_left #a #b : lens (either_l a b) a = {
+  get = Inl?.v;
+  put = lens_left_put;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let lens_left_fst #a #b #c: lens (either_l (a & b) c) a = lens_comp lens_left lens_fst
+let lens_fst_left #a #b #c: lens ((either_l a b) & c) a = lens_comp lens_fst lens_left
 
 (** A PCM for binary sums *)
 
@@ -237,7 +276,7 @@ let either_op (p: pcm 'a) (q: pcm 'b) (x: option (either 'a 'b))
   | Some (Inl x), Some (Inl y) -> Some (Inl (op p x y))
   | Some (Inr x), Some (Inr y) -> Some (Inr (op q x y))
     
-let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = {
+let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
   p = {composable = either_composable p q; op = either_op p q; one = None};
   comm = (fun x y -> match x, y with
     | None, _ | _, None -> ()
@@ -256,6 +295,13 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = {
     | None -> True
     | Some (Inl x) -> p.refine x
     | Some (Inr x) -> q.refine x);
+})
+
+let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
+  f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = Some (Inl #_ #'b p.P.p.one);
+  new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
 (** A PCM for possibly uninitialized data *)
@@ -276,7 +322,7 @@ let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = ma
   | Uninitialized, Uninitialized -> Uninitialized
   | Initialized x, Initialized y -> Initialized (op p x y)
 
-let init_pcm (p: pcm 'a): pcm (init 'a) = {
+let init_pcm (p: pcm 'a): pcm (init 'a) = P.({
   p = {composable = init_comp p; op = init_op p; one = One #'a};
   comm = (fun x y -> match x, y with
     | Initialized x, Initialized y -> p.comm x y
@@ -291,58 +337,4 @@ let init_pcm (p: pcm 'a): pcm (init 'a) = {
   refine = (fun x -> match x with
     | Initialized x -> p.refine x
     | _ -> True)
-}
-
-(** A refinement of a PCM p *)
-
-noeq type pcm_refinement #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
-  new_one: refine_t f;
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
-}
-
-let pcm_refine_comp (p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
-
-let pcm_refine_op (p: pcm 'a) (r: pcm_refinement p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_under_op x y; op p x y
-
-let pcm_refine (p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp p r; op = pcm_refine_op p r; one = r.new_one};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
-  refine = p.refine;
-}
-
-let trivial_refinement (p: pcm 'a): pcm_refinement p = {
-  f = (fun x -> True);
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = p.p.one;
-  new_one_is_refined_unit = p.is_unit;
-}
-
-let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
-  f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = Some (Inl #_ #'b p.p.one);
-  new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
-}
-
-(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re. *)
-noeq type ref (a: Type u#a) (b: Type u#b) = {
-  p: pcm a;
-  re: pcm_refinement p;
-  q: pcm b;
-  l: pcm_lens (pcm_refine p re) q;
-  r: M.ref a p;
-}
-
-// (** A ref r points to a value v if r `Steel.Memory.pts_to` put v one, where
-//     - put comes from r's pcm_lens
-//     - one is the unit of r's refined PCM for the source type *)
-// let pts_to (r: ref 'a 'b) (v: 'b): M.slprop =
-//   M.pts_to r.r (put r.l v (pcm_refine r.p r.re).P.p.one)
+})

From 74f241f5a86a2e0587ce97dddf76dc9951ea3879 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 24 Jun 2021 09:29:35 -0700
Subject: [PATCH 019/513] Simplify pcm_lens laws; implement lenses for n-ary
 structs and unions

---
 examples/steel/AggregateRef.fst | 193 +++++++++++++++++++++++---------
 1 file changed, 138 insertions(+), 55 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index fa96786fd91..e67b94e4b5a 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -47,6 +47,56 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
+(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
+    (1) get is a PCM morphism p -> q
+    (2) put is a PCM morphism p×q -> p, where (×) = Aggregates.tuple_pcm
+    The property get (s * t) = get s * get t is derivable from lens laws and the fact
+    that put is a PCM morphism:
+      get (s * t)
+      = get (put (get s) s * put (get t) t)
+      = get (put (get s * get t) (s * t))
+      = get s * get t
+    So one only needs to prove composable s t ==> composable (get s) (get t) when
+    defining a pcm_lens. If we could find a way to also prove this from the fact that
+    put is a PCM morphism, we could do away with get_op_composable entirely. *)
+noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
+  l: lens a b;
+  get_refine: s:a ->
+    Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
+  get_op_composable: s:a -> t:a ->
+    Lemma
+      (requires composable p s t)
+      (ensures composable q (l.get s) (l.get t));
+  put_refine: s:a -> v:b ->
+    Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
+    [SMTPat (p.refine (l.put v s))];
+  put_op: s:a -> t:a -> v:b -> w:b ->
+    Lemma
+      (requires composable p s t /\ composable q v w)
+      (ensures composable p (l.put v s) (l.put w t) /\
+               l.put (op q v w) (op p s t) == op p (l.put v s) (l.put w t))
+    [SMTPat (l.put (op q v w) (op p s t)); SMTPat (composable p (l.put v s) (l.put w t))];
+}
+let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
+let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
+let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
+
+let get_op (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s t: 'a)
+: Lemma
+    (requires composable p s t)
+    (ensures composable q (get l s) (get l t) /\ get l (op p s t) == op q (get l s) (get l t))
+    [SMTPat (composable p s t); SMTPat (get l (op p s t))]
+= l.get_op_composable s t; l.put_op s t (get l s) (get l t)
+
+(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
+    frame-preserving updates on the source *)
+
+let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
+= compatible_elim p x y (compatible q (get l x) (get l y)) (fun frame_x ->
+  let _ = get_op l frame_x x in
+  compatible_intro q (get l x) (get l y) (get l frame_x))
+    
 (** The non-computational part of frame_preserving_upd
     TODO: move this and lemmas about this to FStar.PCM.fst *)
 let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
@@ -77,46 +127,7 @@ let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
      [SMTPat (compatible p x v)]))
 : Lemma (frame_pres p f x y) =
   let _ = g in ()
-
-(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b)
-    with the extra requirement that get and put be PCM morphisms. *)
-noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
-  l: lens a b;
-  get_refine: s:a ->
-    Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
-  get_op: s:a -> t:a ->
-    Lemma
-      (requires composable p s t)
-      (ensures composable q (l.get s) (l.get t) /\ 
-               l.get (op p s t) == op q (l.get s) (l.get t))
-               (* Technically, this distributivity law is derivable from the one for put:
-                    get (s * t)
-                    = get (put (get s) s * put (get t) t)
-                    = get (put (get s * get t) (s * t))
-                    = get s * get t *)
-    [SMTPat (composable p s t); SMTPat (l.get (op p s t))];
-  put_refine: s:a -> v:b ->
-    Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
-    [SMTPat (p.refine (l.put v s))];
-  put_op: s:a -> t:a -> v:b -> w:b ->
-    Lemma
-      (requires composable p s t /\ composable q v w)
-      (ensures composable p (l.put v s) (l.put w t) /\
-               l.put (op q v w) (op p s t) == op p (l.put v s) (l.put w t))
-    [SMTPat (l.put (op q v w) (op p s t)); SMTPat (composable p (l.put v s) (l.put w t))];
-}
-let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
-let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
-let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
-
-let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
-= compatible_elim p x y (compatible q (get l x) (get l y)) (fun frame_x ->
-  let _ = l.get_op frame_x x in
-  compatible_intro q (get l x) (get l y) (get l frame_x))
-
-(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
-    frame-preserving updates on the source *)
+    
 let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
 : Lemma
     (requires frame_pres q f (get l s) v)
@@ -138,7 +149,7 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
     let aux (frame:'a{composable p s frame})
     : Lemma (composable p (put l v s) frame /\
              (op p s frame == full ==> op p (put l v s) frame == upd l f full))
-    = l.get_op s frame;
+    = get_op l s frame;
       l.put_op s frame v (get l frame)
     in FStar.Classical.forall_intro aux)))
 
@@ -146,7 +157,7 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
 let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
   l = lens_id; 
   get_refine = (fun _ -> ());
-  get_op = (fun _ _ -> ());
+  get_op_composable = (fun _ _ -> ());
   put_refine = (fun _ _ -> ());
   put_op = (fun _ _ _ _ -> ());
 }
@@ -157,10 +168,10 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 {
   l = lens_comp l.l m.l;
   get_refine = (fun _ -> let _ = l.get_refine in let _ = m.get_refine in ());
-  get_op = (fun s t -> l.get_op s t; m.get_op (get l s) (get l t));
+  get_op_composable = (fun s t -> get_op l s t; get_op m (get l s) (get l t));
   put_refine = (fun s v -> let _ = l.put_refine in let _ = m.put_refine in let _ = l.get_refine in ());
   put_op = (fun s t v w ->
-    l.get_op s t;
+    get_op l s t;
     m.put_op (get l s) (get l t) v w;
     l.put_op s t (put m v (get l s)) (put m w (get l t)))
 }
@@ -214,16 +225,6 @@ noeq type ref (a: Type u#a) (b: Type u#b) = {
 let pts_to (r: ref 'a 'b) (v: 'b): M.slprop =
   M.pts_to r.r (put r.pl v (pcm_refine r.p r.re).P.p.one)
 
-(*
-
-TODO:
-- Lens for a field of a prod_pcm
-- Refinement for a case of a union_pcm
-- Lens (with corresponding refinement) for a case of a union_pcm
-- Types of basic Steel operations manipulating pts_to
-
-*)
-
 (** Basic lenses *)
 
 open Aggregates
@@ -240,7 +241,7 @@ let lens_fst #a #b : lens (a & b) a = {
 let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
   l = lens_fst;
   get_refine = (fun _ -> ());
-  get_op = (fun _ _ -> ());
+  get_op_composable = (fun _ _ -> ());
   put_refine = (fun _ _ -> ());
   put_op = (fun _ _ _ _ -> ());
 }
@@ -338,3 +339,85 @@ let init_pcm (p: pcm 'a): pcm (init 'a) = P.({
     | Initialized x -> p.refine x
     | _ -> True)
 })
+
+(** A lens for the k-th field of an n-ary product *)
+
+open FStar.FunctionalExtensionality
+
+let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
+let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
+  get = lens_field_get f k;
+  put = fun_upd k;
+  get_put = (fun s v -> ());
+  put_get = (fun s -> ext (fun_upd k (lens_field_get f k s) s) s (fun _ -> ()));
+  put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
+}
+
+(** lens_field is a pcm_lens for the n-ary product PCM *)
+
+(* TODO move to Aggregates.fst *)
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
+  l = lens_field f k;
+  get_refine = (fun s -> ());
+  get_op_composable = (fun s t -> ());
+  put_refine = (fun s v -> ());
+  put_op = (fun s t v w ->
+    prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
+    ext
+      (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
+      (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
+      (fun _ -> ()));
+}
+
+(** The refinement of an n-ary union PCM to the k-th case *)
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
+  fun kx -> match kx with Some (|k', _|) -> k == k' | None -> False
+
+let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
+: refine_t (case_refinement_f p k)
+= Some (|k, (p k).P.p.one|)
+
+let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) = {
+  f = case_refinement_f p k;
+  f_closed_under_op = (fun x y -> ());
+  new_one = case_refinement_new_one p k;
+  new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
+}
+
+(** A lens for the k-th case of an n-ary union *)
+
+let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
+  fun (Some (|_, v|)) -> v
+let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
+: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
+= fun _ -> Some (|k, v|)
+  
+let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f p k)) ('b k) = {
+  get = lens_case_get p k;
+  put = lens_case_put p k;
+  get_put = (fun s v -> ());
+  put_get = (fun s -> ());
+  put_put = (fun s v w -> ());
+}
+
+(** lens_case is a pcm_lens for the k-th case of an n-ary union *)
+
+let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (pcm_refine (union_pcm p) (case_refinement p k)) (p k) = {
+  l = lens_case p k;
+  get_refine = (fun s -> ());
+  get_op_composable = (fun s t -> ());
+  put_refine = (fun s v -> ());
+  put_op = (fun s t v w -> ());
+}
+
+(*
+
+TODO:
+- Types of basic Steel operations manipulating pts_to
+
+*)

From 1ca1546fc52b26ee2db5249b498482cdd82ae53a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 24 Jun 2021 10:10:57 -0700
Subject: [PATCH 020/513] Tidy

---
 examples/steel/AggregateRef.fst | 53 +++++++++++++++++++--------------
 1 file changed, 30 insertions(+), 23 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index e67b94e4b5a..a1cabee50ca 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -1,7 +1,6 @@
 module AggregateRef
 
 open FStar.PCM
-module M = Steel.Memory
 module P = FStar.PCM
 
 (** Very well-behaved lenses *)
@@ -167,19 +166,26 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r = 
 {
   l = lens_comp l.l m.l;
-  get_refine = (fun _ -> let _ = l.get_refine in let _ = m.get_refine in ());
-  get_op_composable = (fun s t -> get_op l s t; get_op m (get l s) (get l t));
-  put_refine = (fun s v -> let _ = l.put_refine in let _ = m.put_refine in let _ = l.get_refine in ());
+  get_refine = (fun _ ->
+    let _ = l.get_refine in
+    let _ = m.get_refine in ());
+  get_op_composable = (fun s t ->
+    get_op l s t;
+    get_op m (get l s) (get l t));
+  put_refine = (fun s v ->
+    let _ = l.put_refine in
+    let _ = m.put_refine in
+    let _ = l.get_refine in ());
   put_op = (fun s t v w ->
     get_op l s t;
     m.put_op (get l s) (get l t) v w;
     l.put_op s t (put m v (get l s)) (put m w (get l t)))
 }
 
-(** A refinement of a PCM p *)
-
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
-
 noeq type pcm_refinement #a (p: pcm a) = {
   f: a -> prop;
   f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
@@ -187,14 +193,16 @@ noeq type pcm_refinement #a (p: pcm a) = {
   new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
 
-let pcm_refine_comp (p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
 
-let pcm_refine_op (p: pcm 'a) (r: pcm_refinement p)
+let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
   (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
 = r.f_closed_under_op x y; op p x y
 
-let pcm_refine (p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp p r; op = pcm_refine_op p r; one = r.new_one};
+(** Any refinement r for p can be used to construct a refined PCM with the same product
+    and composability predicate, but restricted to elements in r.f *)
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
   assoc_r = (fun x y z -> p.assoc_r x y z);
@@ -210,20 +218,20 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
 }
 
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re. *)
+    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
+    This allows the reference to point to substructures of unions with known case. *)
 noeq type ref (a: Type u#a) (b: Type u#b) = {
   p: pcm a;
   re: pcm_refinement p;
   q: pcm b;
-  pl: pcm_lens (pcm_refine p re) q;
-  r: M.ref a p;
+  pl: pcm_lens (refined_pcm re) q;
+  r: Steel.Memory.ref a p;
 }
 
-(** A ref r points to a value v if r `Steel.Memory.pts_to` put v one, where
-    - put comes from r's pcm_lens
-    - one is the unit of r's refined PCM for the source type *)
-let pts_to (r: ref 'a 'b) (v: 'b): M.slprop =
-  M.pts_to r.r (put r.pl v (pcm_refine r.p r.re).P.p.one)
+(** A ref r points to a value v if r's underlying ref points to a chunk of memory
+    which contains at least the value v. *)
+let pts_to (r: ref 'a 'b) (v: 'b): Steel.Memory.slprop =
+  Steel.Memory.(r.r `pts_to` put r.pl v (refined_pcm r.re).P.p.one)
 
 (** Basic lenses *)
 
@@ -353,7 +361,7 @@ let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
   put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
 }
 
-(** lens_field is a pcm_lens for the n-ary product PCM *)
+(** lens_field is a pcm_lens *)
 
 (* TODO move to Aggregates.fst *)
 let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
@@ -405,9 +413,8 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
   put_put = (fun s v w -> ());
 }
 
-(** lens_case is a pcm_lens for the k-th case of an n-ary union *)
-
-let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (pcm_refine (union_pcm p) (case_refinement p k)) (p k) = {
+(** lens_case is a pcm_lens *)
+let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
   l = lens_case p k;
   get_refine = (fun s -> ());
   get_op_composable = (fun s t -> ());

From 69c24559dc813f7672895a0d6ddc1e0afd969ef1 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 24 Jun 2021 10:56:43 -0700
Subject: [PATCH 021/513] Add unit laws to pcm morphism

---
 examples/steel/AggregateRef.fst | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index a1cabee50ca..7a18581c49f 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -62,6 +62,7 @@ noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   l: lens a b;
   get_refine: s:a ->
     Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
+  get_one: unit -> Lemma (l.get p.p.one == q.p.one);
   get_op_composable: s:a -> t:a ->
     Lemma
       (requires composable p s t)
@@ -69,6 +70,7 @@ noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   put_refine: s:a -> v:b ->
     Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
     [SMTPat (p.refine (l.put v s))];
+  put_one: unit -> Lemma (l.put q.p.one p.p.one == p.p.one);
   put_op: s:a -> t:a -> v:b -> w:b ->
     Lemma
       (requires composable p s t /\ composable q v w)
@@ -156,8 +158,10 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
 let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
   l = lens_id; 
   get_refine = (fun _ -> ());
+  get_one = (fun _ -> ());
   get_op_composable = (fun _ _ -> ());
   put_refine = (fun _ _ -> ());
+  put_one = (fun _ -> ());
   put_op = (fun _ _ _ _ -> ());
 }
 
@@ -169,6 +173,7 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   get_refine = (fun _ ->
     let _ = l.get_refine in
     let _ = m.get_refine in ());
+  get_one = (fun _ -> l.get_one (); m.get_one ());
   get_op_composable = (fun s t ->
     get_op l s t;
     get_op m (get l s) (get l t));
@@ -176,6 +181,7 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
     let _ = l.put_refine in
     let _ = m.put_refine in
     let _ = l.get_refine in ());
+  put_one = (fun _ -> l.put_one (); m.put_one ());
   put_op = (fun s t v w ->
     get_op l s t;
     m.put_op (get l s) (get l t) v w;
@@ -249,8 +255,10 @@ let lens_fst #a #b : lens (a & b) a = {
 let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
   l = lens_fst;
   get_refine = (fun _ -> ());
+  get_one = (fun _ -> ());
   get_op_composable = (fun _ _ -> ());
   put_refine = (fun _ _ -> ());
+  put_one = (fun _ -> ());
   put_op = (fun _ _ _ _ -> ());
 }
 
@@ -371,8 +379,14 @@ let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
 let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
   l = lens_field f k;
   get_refine = (fun s -> ());
+  get_one = (fun _ -> ());
   get_op_composable = (fun s t -> ());
   put_refine = (fun s v -> ());
+  put_one = (fun _ ->
+    ext
+      (fun_upd k (p k).P.p.one (prod_pcm p).P.p.one)
+      (prod_pcm p).P.p.one
+      (fun k -> ()));
   put_op = (fun s t v w ->
     prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
     ext
@@ -417,11 +431,25 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
 let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
   l = lens_case p k;
   get_refine = (fun s -> ());
+  get_one = (fun _ -> ());
   get_op_composable = (fun s t -> ());
   put_refine = (fun s v -> ());
+  put_one = (fun _ -> ());
   put_op = (fun s t v w -> ());
 }
 
+(* Basic operations *)
+
+// l.put (m.put v one) one
+// = l.put (m.put v (l.get one)) one
+// = lm.put v one
+
+open Steel.Effect.M
+
+let focus (r: ref 'a 'b) (l: pcm_lens 'b 'c) (v: 'c)
+: SteelT (ref 'a 'c) (r `pts_to` put l v l.p.p.one) (fun r -> r `pts_to` v)
+= admit()
+
 (*
 
 TODO:

From 572f21df80273ec7e53cd58a9d9311bb9c8c43f7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 24 Jun 2021 11:51:31 -0700
Subject: [PATCH 022/513] Replace p.p.one with (one p)

---
 examples/steel/AggregateRef.fst | 76 ++++++++++++++++++---------------
 1 file changed, 42 insertions(+), 34 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 7a18581c49f..dee9a1c8ea7 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -3,6 +3,9 @@ module AggregateRef
 open FStar.PCM
 module P = FStar.PCM
 
+(* TODO move to FStar.PCM.fst, use in earlier code to avoid P.p.one *)
+let one (p: pcm 'a) = p.P.p.one
+
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
   get: a -> b;
@@ -48,21 +51,12 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
 
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
     (1) get is a PCM morphism p -> q
-    (2) put is a PCM morphism p×q -> p, where (×) = Aggregates.tuple_pcm
-    The property get (s * t) = get s * get t is derivable from lens laws and the fact
-    that put is a PCM morphism:
-      get (s * t)
-      = get (put (get s) s * put (get t) t)
-      = get (put (get s * get t) (s * t))
-      = get s * get t
-    So one only needs to prove composable s t ==> composable (get s) (get t) when
-    defining a pcm_lens. If we could find a way to also prove this from the fact that
-    put is a PCM morphism, we could do away with get_op_composable entirely. *)
+    (2) put is a PCM morphism p×q -> p, where (×) = Aggregates.tuple_pcm *)
 noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   l: lens a b;
   get_refine: s:a ->
     Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
-  get_one: unit -> Lemma (l.get p.p.one == q.p.one);
+  get_one: unit -> Lemma (l.get (one p) == one q);
   get_op_composable: s:a -> t:a ->
     Lemma
       (requires composable p s t)
@@ -70,7 +64,7 @@ noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   put_refine: s:a -> v:b ->
     Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
     [SMTPat (p.refine (l.put v s))];
-  put_one: unit -> Lemma (l.put q.p.one p.p.one == p.p.one);
+  put_one: unit -> Lemma (l.put (one q) (one p) == one p);
   put_op: s:a -> t:a -> v:b -> w:b ->
     Lemma
       (requires composable p s t /\ composable q v w)
@@ -82,6 +76,15 @@ let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
 let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
 let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
 
+(** The property get (s * t) = get s * get t is derivable from lens laws and the fact
+    that put is a PCM morphism:
+      get (s * t)
+      = get (put (get s) s * put (get t) t)
+      = get (put (get s * get t) (s * t))
+      = get s * get t
+    So one only needs to prove composable s t ==> composable (get s) (get t) when
+    defining a pcm_lens. If we could find a way to also prove this from the fact that
+    put is a PCM morphism, we could do away with get_op_composable entirely. *)
 let get_op (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s t: 'a)
 : Lemma
     (requires composable p s t)
@@ -219,7 +222,7 @@ let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
 let trivial_refinement (p: pcm 'a): pcm_refinement p = {
   f = (fun x -> True);
   f_closed_under_op = (fun _ _ -> ());
-  new_one = p.p.one;
+  new_one = one p;
   new_one_is_refined_unit = p.is_unit;
 }
 
@@ -237,7 +240,7 @@ noeq type ref (a: Type u#a) (b: Type u#b) = {
 (** A ref r points to a value v if r's underlying ref points to a chunk of memory
     which contains at least the value v. *)
 let pts_to (r: ref 'a 'b) (v: 'b): Steel.Memory.slprop =
-  Steel.Memory.(r.r `pts_to` put r.pl v (refined_pcm r.re).P.p.one)
+  Steel.Memory.(r.r `pts_to` put r.pl v (one (refined_pcm r.re)))
 
 (** Basic lenses *)
 
@@ -317,30 +320,33 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
 let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
   f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
   f_closed_under_op = (fun _ _ -> ());
-  new_one = Some (Inl #_ #'b p.P.p.one);
+  new_one = Some (Inl #_ #'b (one p));
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
 (** A PCM for possibly uninitialized data *)
 
+(*
 type init a =
 | Uninitialized : init a
-| One : init a
 | Initialized : a -> init a
 
 let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
-  | One, _ | _, One -> True
   | Uninitialized, Uninitialized -> True
+  | Uninitialized, Initialized x | Initialized x, Uninitialized -> x == one p
   | Initialized x, Initialized y -> composable p x y
-  | _, _ -> False
 
-let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
-  | One, z | z, One -> z
+let init_op (p: pcm 'a) (one_dec:(x:'a -> b:bool{b <==> x == one p})) (x: init 'a)
+  (y: init 'a{init_comp p x y})
+: init 'a
+= match x, y with
   | Uninitialized, Uninitialized -> Uninitialized
+  | Uninitialized, Initialized x | Initialized x, Uninitialized ->
+    let true = one_dec x in Uninitialized
   | Initialized x, Initialized y -> Initialized (op p x y)
 
-let init_pcm (p: pcm 'a): pcm (init 'a) = P.({
-  p = {composable = init_comp p; op = init_op p; one = One #'a};
+let init_pcm (p: pcm 'a) (one_dec:(x:'a -> b:bool{b <==> x == one p})): pcm (init 'a) = P.({
+  p = {composable = init_comp p; op = init_op p one_dec; one = Initialized (one p)};
   comm = (fun x y -> match x, y with
     | Initialized x, Initialized y -> p.comm x y
     | _, _ -> ());
@@ -355,6 +361,7 @@ let init_pcm (p: pcm 'a): pcm (init 'a) = P.({
     | Initialized x -> p.refine x
     | _ -> True)
 })
+*)
 
 (** A lens for the k-th field of an n-ary product *)
 
@@ -384,8 +391,8 @@ let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p
   put_refine = (fun s v -> ());
   put_one = (fun _ ->
     ext
-      (fun_upd k (p k).P.p.one (prod_pcm p).P.p.one)
-      (prod_pcm p).P.p.one
+      (fun_upd k (one (p k)) (one (prod_pcm p)))
+      (one (prod_pcm p))
       (fun k -> ()));
   put_op = (fun s t v w ->
     prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
@@ -402,7 +409,7 @@ let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
 
 let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 : refine_t (case_refinement_f p k)
-= Some (|k, (p k).P.p.one|)
+= Some (|k, one (p k)|)
 
 let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) = {
   f = case_refinement_f p k;
@@ -444,15 +451,16 @@ let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement
 // = l.put (m.put v (l.get one)) one
 // = lm.put v one
 
-open Steel.Effect.M
+open Steel.Effect
 
-let focus (r: ref 'a 'b) (l: pcm_lens 'b 'c) (v: 'c)
-: SteelT (ref 'a 'c) (r `pts_to` put l v l.p.p.one) (fun r -> r `pts_to` v)
-= admit()
+// val focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
+// : SteelT (ref 'a 'c) (r `pts_to` put l x (one r.q)) (fun r' -> r' `pts_to` x `star` pure (r'.pl == lens_comp r.pl l))
 
-(*
+// let focus' r q l = compose r's lens with l
+// val focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
+// : SteelT (ref 'a 'c) (r `pts_to` put l x (one r.q)) (fun r' -> r' `pts_to` x `star` pure (focus' r == r'))
+// 
+// val unfocus (r': ref 'a 'b) (r: Ghost.erased (ref 'a 'b)) (q: pcm 'c) (m: pcm_lens r.p r.q) (l: pcm_lens r.q q) (x: 'c)
+// : SteelT (ref 'a 'c) (r' `pts_to` x `star` pure (r' == focus r))) (fun r'' -> r `pts_to` put l x (one r.q) `star` pure (r'' == r))
 
-TODO:
-- Types of basic Steel operations manipulating pts_to
-
-*)
+// Steel.Effect.Atomic.sladmit()

From 82286a917d87f4f9a876b7f30bd928e06a209d28 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 24 Jun 2021 15:35:14 -0700
Subject: [PATCH 023/513] Focus, unfocus, gather, and split

---
 examples/steel/AggregateRef.fst | 103 ++++++++++++++++++++++++++------
 1 file changed, 85 insertions(+), 18 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index dee9a1c8ea7..41d7c10a614 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -70,7 +70,9 @@ noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
       (requires composable p s t /\ composable q v w)
       (ensures composable p (l.put v s) (l.put w t) /\
                l.put (op q v w) (op p s t) == op p (l.put v s) (l.put w t))
-    [SMTPat (l.put (op q v w) (op p s t)); SMTPat (composable p (l.put v s) (l.put w t))];
+    [SMTPatOr [
+      [SMTPat (l.put (op q v w) (op p s t))];
+      [SMTPat (composable p (l.put v s) (l.put w t))]]];
 }
 let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
 let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
@@ -89,7 +91,7 @@ let get_op (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s t: 'a)
 : Lemma
     (requires composable p s t)
     (ensures composable q (get l s) (get l t) /\ get l (op p s t) == op q (get l s) (get l t))
-    [SMTPat (composable p s t); SMTPat (get l (op p s t))]
+    [SMTPat (get l (op p s t))]
 = l.get_op_composable s t; l.put_op s t (get l s) (get l t)
 
 (** The upd function of a pcm_lens lifts frame-preserving updates on the target to
@@ -447,20 +449,85 @@ let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement
 
 (* Basic operations *)
 
-// l.put (m.put v one) one
-// = l.put (m.put v (l.get one)) one
-// = lm.put v one
-
 open Steel.Effect
-
-// val focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
-// : SteelT (ref 'a 'c) (r `pts_to` put l x (one r.q)) (fun r' -> r' `pts_to` x `star` pure (r'.pl == lens_comp r.pl l))
-
-// let focus' r q l = compose r's lens with l
-// val focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
-// : SteelT (ref 'a 'c) (r `pts_to` put l x (one r.q)) (fun r' -> r' `pts_to` x `star` pure (focus' r == r'))
-// 
-// val unfocus (r': ref 'a 'b) (r: Ghost.erased (ref 'a 'b)) (q: pcm 'c) (m: pcm_lens r.p r.q) (l: pcm_lens r.q q) (x: 'c)
-// : SteelT (ref 'a 'c) (r' `pts_to` x `star` pure (r' == focus r))) (fun r'' -> r `pts_to` put l x (one r.q) `star` pure (r'' == r))
-
-// Steel.Effect.Atomic.sladmit()
+module M = Steel.Memory
+module A = Steel.Effect.Atomic
+
+let focus' (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
+  {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
+
+let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
+: Steel (ref 'a 'c)
+    (to_vprop (r `pts_to` put l x (one r.q)))
+    (fun r' -> to_vprop (r' `pts_to` x))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == focus' r q l)
+= let r' = focus' r q l in
+  A.change_slprop_rel  
+    (to_vprop (r `pts_to` put l x (one r.q)))
+    (to_vprop (r' `pts_to` x))
+    (fun _ _ -> True)
+    (fun m -> r.pl.get_one ());
+  A.return r'
+
+let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c) (l: pcm_lens r'.q q) (x: 'c)
+: A.SteelGhost unit inames
+    (to_vprop (r `pts_to` x))
+    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ -> r == focus' r' q l)
+    (fun _ _ _ -> True)
+= A.change_slprop_rel  
+    (to_vprop (r `pts_to` x))
+    (to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ _ -> True)
+    (fun m -> r'.pl.get_one ())
+
+let change_equal_vprop #inames (p q: M.slprop)
+: A.SteelGhost unit inames (to_vprop p) (fun _ -> to_vprop q) (fun _ -> p == q) (fun _ _ _ -> True)
+= A.change_equal_slprop (to_vprop p) (to_vprop q)
+// TODO rename
+
+let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
+: Steel unit
+    (to_vprop (r `pts_to` xy))
+    (fun _ -> to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
+    (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
+    (fun _ _ _ -> True)
+= A.change_equal_slprop
+    (to_vprop (r `pts_to` xy))
+    (to_vprop (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re))))));
+  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
+  r.pl.put_op (one (refined_pcm r.re)) (one (refined_pcm r.re)) x y;
+  Steel.PCMReference.split r.r
+    (put r.pl xy (one (refined_pcm r.re)))
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  change_equal_vprop
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
+    (r `pts_to` x);
+  change_equal_vprop
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
+    (r `pts_to` y)
+  // TODO: post on slack about
+  // cannot prove to_vprop p == to_vprop q given p == q because
+  // to_vprop is unfold, unflods to term with lambda expression
+
+let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
+: SteelT (_:unit{composable r.q x y})
+    (to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
+    (fun _ -> to_vprop (r `pts_to` op r.q x y))
+= change_equal_vprop
+    (r `pts_to` x)
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
+  change_equal_vprop
+    (r `pts_to` y)
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
+  Steel.PCMReference.gather r.r
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  get_op r.pl (put r.pl x (one (refined_pcm r.re))) (put r.pl y (one (refined_pcm r.re)));
+  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
+  r.pl.put_op (one (refined_pcm r.re)) (one (refined_pcm r.re)) x y;
+  change_equal_vprop _ (r `pts_to` op r.q x y)
+
+// TODO split/gather (in struct case) a single field out of a restricted_t 'a f

From 7074a6e4ae5ab702558790c95a1ffa640e401307 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 29 Jun 2021 10:27:23 -0700
Subject: [PATCH 024/513] Tidy

---
 examples/steel/AggregateRef.fst |  18 ++-
 examples/steel/Aggregates.fst   | 236 ++++----------------------------
 2 files changed, 32 insertions(+), 222 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 41d7c10a614..5500a29539e 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -241,7 +241,7 @@ noeq type ref (a: Type u#a) (b: Type u#b) = {
 
 (** A ref r points to a value v if r's underlying ref points to a chunk of memory
     which contains at least the value v. *)
-let pts_to (r: ref 'a 'b) (v: 'b): Steel.Memory.slprop =
+let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): Steel.Memory.slprop =
   Steel.Memory.(r.r `pts_to` put r.pl v (one (refined_pcm r.re)))
 
 (** Basic lenses *)
@@ -453,16 +453,16 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let focus' (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
+let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
   {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
-let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
+let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
     (to_vprop (r `pts_to` put l x (one r.q)))
     (fun r' -> to_vprop (r' `pts_to` x))
     (fun _ -> True)
-    (fun _ r' _ -> r' == focus' r q l)
-= let r' = focus' r q l in
+    (fun _ r' _ -> r' == ref_focus r q l)
+= let r' = ref_focus r q l in
   A.change_slprop_rel  
     (to_vprop (r `pts_to` put l x (one r.q)))
     (to_vprop (r' `pts_to` x))
@@ -470,11 +470,12 @@ let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: 'c)
     (fun m -> r.pl.get_one ());
   A.return r'
 
-let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c) (l: pcm_lens r'.q q) (x: 'c)
+let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
+  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` x))
     (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == focus' r' q l)
+    (fun _ -> r == ref_focus r' q l)
     (fun _ _ _ -> True)
 = A.change_slprop_rel  
     (to_vprop (r `pts_to` x))
@@ -508,9 +509,6 @@ let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
   change_equal_vprop
     (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
     (r `pts_to` y)
-  // TODO: post on slack about
-  // cannot prove to_vprop p == to_vprop q given p == q because
-  // to_vprop is unfold, unflods to term with lambda expression
 
 let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
 : SteelT (_:unit{composable r.q x y})
diff --git a/examples/steel/Aggregates.fst b/examples/steel/Aggregates.fst
index 2b4d29e04b2..360b8b602c8 100644
--- a/examples/steel/Aggregates.fst
+++ b/examples/steel/Aggregates.fst
@@ -39,65 +39,33 @@ let opt_pcm #a : pcm (option a) = {
   refine = (fun _ -> True);
 }
 
-/// We can define frame-preserving updates for a tuple PCM from
-/// frame-preserving updates on its components. For example, to define
-/// a frame-preserving update on the first component:
-
-let compatible_tuple_l (p: pcm 'a) (q: pcm 'b) (x v: 'a) (y w: 'b)
-: Lemma 
-    (requires compatible p x v /\ compatible q y w)
-    (ensures compatible (tuple_pcm p q) (x, y) (v, w))
-= let pq = tuple_pcm p q in
-  let aux frame_x frame_y :
-    Lemma 
-      (requires composable pq (x, y) (frame_x, frame_y) /\
-                op pq (frame_x, frame_y) (x, y) == (v, w))
-      (ensures compatible pq (x, y) (v, w))
-      [SMTPat (composable p x frame_x); SMTPat (composable q y frame_y)] = ()
-  in ()
-
-let upd_fst (p: pcm 'a) (q: pcm 'b) (x: 'a) (y: 'b) (x': 'a)
-  (f: frame_preserving_upd p x x')
-: frame_preserving_upd (tuple_pcm p q) (x, y) (x', y)
-= fun (va, vb) ->
-  let wa = f va in
-  let pq = tuple_pcm p q in
-  compatible_tuple_l p q x' wa y vb;
-  let aux (frame: _{composable pq (x, y) frame}):
-    Lemma (composable pq (x', y) frame /\
-           (op pq (x, y) frame == (va, vb) ==> op pq (x', y) frame == (wa, vb)))
-    [SMTPat (composable pq (x, y) frame)] = ()
-  in (wa, vb)
-
-/// Frame-preserving updates on the second component can be done similarly.
-/// To avoid having to write a frame-preserving update for each field separately,
-/// we generalize to 'a-ary products (k:'a -> f k), given a PCM for each k:
+/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
 
 open FStar.FunctionalExtensionality
 open FStar.Classical
-let ext #a #b (f g: restricted_t a b) (fg:(x:a -> Lemma (f x == g x))) : Lemma (f == g) =
-  extensionality a b f g;
+let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality 'a 'b f g;
   forall_intro fg
 
-let prod_comp #f (p:(k:'a -> pcm (f k))) (x y: restricted_t 'a f): prop =
+let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
   forall k. composable (p k) (x k) (y k)
 
-let prod_op #a #f (p:(k:a -> pcm (f k)))
-  (x: restricted_t a f) (y: restricted_t a f{prod_comp p x y})
-: restricted_t a f
-= on_domain a (fun k -> op (p k) (x k) (y k))
+let prod_op (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: restricted_t 'a 'b
+= on_domain 'a (fun k -> op (p k) (x k) (y k))
 
-let prod_one #a #f (p:(k:a -> pcm (f k))): restricted_t a f =
-  on_domain a (fun k -> (p k).p.one)
+let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
+  on_domain 'a (fun k -> (p k).p.one)
 
-let prod_comm #f (p:(k:'a -> pcm (f k)))
-  (x: restricted_t 'a f) (y: restricted_t 'a f{prod_comp p x y})
+let prod_comm (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
 : Lemma (prod_op p x y == prod_op p y x)
 = ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
 
-let prod_assoc #f (p:(k:'a -> pcm (f k)))
-  (x y: restricted_t 'a f)
-  (z: restricted_t 'a f{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+let prod_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
 : Lemma (prod_comp p x y /\
          prod_comp p (prod_op p x y) z /\
          prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
@@ -110,9 +78,9 @@ let prod_assoc #f (p:(k:'a -> pcm (f k)))
   ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
     (fun k -> (p k).assoc (x k) (y k) (z k))
 
-let prod_assoc_r #f (p:(k:'a -> pcm (f k)))
-  (x y: restricted_t 'a f)
-  (z: restricted_t 'a f{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+let prod_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
 : Lemma (prod_comp p y z /\
          prod_comp p x (prod_op p y z) /\
          prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
@@ -125,7 +93,7 @@ let prod_assoc_r #f (p:(k:'a -> pcm (f k)))
   ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
     (fun k -> (p k).assoc (x k) (y k) (z k))
 
-let prod_is_unit #f (p:(k:'a -> pcm (f k))) (x: restricted_t 'a f)
+let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
 : Lemma (prod_comp p x (prod_one p) /\
          prod_op p x (prod_one p) == x)
 = let is_unit k
@@ -134,10 +102,10 @@ let prod_is_unit #f (p:(k:'a -> pcm (f k))) (x: restricted_t 'a f)
   = (p k).is_unit (x k)
   in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
 
-let prod_refine #f (p:(k:'a -> pcm (f k))) (x: restricted_t 'a f): prop =
+let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
   forall k. (p k).refine (x k)
 
-let prod_pcm #f (p:(k:'a -> pcm (f k))): pcm (restricted_t 'a f) = {
+let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) = {
   p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
   comm = prod_comm p;
   assoc = prod_assoc p;
@@ -146,36 +114,6 @@ let prod_pcm #f (p:(k:'a -> pcm (f k))): pcm (restricted_t 'a f) = {
   refine = prod_refine p
 }
 
-/// Now, we can define frame-preserving updates for all fields at once:
-
-let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
-  (f: restricted_t a f_ty)
-: restricted_t a f_ty
-= on_domain a (fun k' -> if k = k' then x' else f k')
-
-let prod_upd (#a:eqtype) #f_ty (p:(k:a -> pcm (f_ty k))) (k:a)
-  (xs: restricted_t a f_ty) (y: f_ty k) (f: frame_preserving_upd (p k) (xs k) y)
-: frame_preserving_upd (prod_pcm p) xs (fun_upd k y xs)
-= fun vs ->
-  let ws_k = f (vs k) in
-  let ws = fun_upd k ws_k vs in
-  let aux (frame: _{composable (prod_pcm p) xs frame}) :
-    Lemma
-      (requires op (prod_pcm p) xs frame == vs)
-      (ensures
-         composable (prod_pcm p) (fun_upd k y xs) frame /\
-         op (prod_pcm p) (fun_upd k y xs) frame == ws)
-    [SMTPat (composable (prod_pcm p) xs frame)]
-  = assert (composable (prod_pcm p) (fun_upd k y xs) frame);
-    ext (op (prod_pcm p) (fun_upd k y xs) frame) ws (fun k' -> ())
-  in
-  let compat_ws_ty = squash (compatible (prod_pcm p) (fun_upd k y xs) ws) in
-  compatible_elim (p k) y ws_k compat_ws_ty (fun frame_k ->
-  compatible_elim (prod_pcm p) xs vs compat_ws_ty (fun frame_rest ->
-  let frame = fun_upd k frame_k frame_rest in
-  ext (op (prod_pcm p) frame (fun_upd k y xs)) ws (fun k' -> ())));
-  ws
-  
 /// Similarly, given a PCM for each k:a, we can model a-ary unions
 /// with an PCM for option (k:a & f k), where
 /// - None is the unit of the PCM
@@ -183,15 +121,15 @@ let prod_upd (#a:eqtype) #f_ty (p:(k:a -> pcm (f_ty k))) (k:a)
 
 let union (f:'a -> Type) = option (k:'a & f k)
 
-let union_comp #f (p:(k:'a -> pcm (f k))): symrel (union f) = fun x y -> match x, y with
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
   | None, z | z, None -> True
   | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
 
-let union_op #f (p:(k:'a -> pcm (f k))) (x: union f) (y: union f{union_comp p x y}) : union f = match x, y with
+let union_op (p:(k:'a -> pcm ('b k))) (x: union 'b) (y: union 'b{union_comp p x y}) : union 'b = match x, y with
   | None, z | z, None -> z
   | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
 
-let union_pcm #f (p:(k:'a -> pcm (f k))): pcm (union f) = {
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union 'b) = {
   p = {composable = union_comp p; op = union_op p; one = None};
   comm = (fun x y -> match x, y with
     | None, _ | _, None -> ()
@@ -205,129 +143,3 @@ let union_pcm #f (p:(k:'a -> pcm (f k))): pcm (union f) = {
   is_unit = (fun _ -> ());
   refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
 }
-
-/// Just like with structs, we can define frame-preserving updates on
-/// unions from frame-preserving updates on a single case:
-
-let union_upd (#a:eqtype) #f_ty (p:(k:a -> pcm (f_ty k))) (k:a)
-  (x y:f_ty k) (f: frame_preserving_upd (p k) x y)
-: frame_preserving_upd (union_pcm p) (Some (|k, x|)) (Some (|k, y|))
-= fun (Some (|k', v|)) ->
-  compatible_elim (union_pcm p) (Some (|k, x|)) (Some (|k, v|)) (compatible (p k) x v)
-    (fun frame -> match frame with
-      | Some (|k', frame_x|) -> compatible_intro (p k) x v frame_x
-      | None -> (union_pcm p).is_unit (Some (|k, x|)); compatible_refl (p k) x);
-  let w = f v in
-  let aux (frame: _{composable (union_pcm p) (Some (|k, x|)) frame})
-  : Lemma (composable (union_pcm p) (Some (|k, y|)) frame /\
-           (op (union_pcm p) (Some (|k, x|)) frame == Some (|k, v|) ==>
-            op (union_pcm p) (Some (|k, y|)) frame == Some (|k, w|)))
-  = match frame with
-    | None -> 
-      (union_pcm p).is_unit (Some (|k, x|));
-      (union_pcm p).is_unit (Some (|k, y|));
-      (p k).is_unit x;
-      assert (composable (p k) y (p k).p.one /\
-              (op (p k) x (p k).p.one == v ==> op (p k) y (p k).p.one == w));
-      (p k).is_unit y
-    | Some (|_, frame_x|) -> ()
-  in forall_intro aux;
-  compatible_elim (p k) y w
-    (compatible (union_pcm p) (Some (|k, y|)) (Some (|k, w|)))
-    (fun frame -> compatible_intro (union_pcm p) (Some (|k, y|)) (Some (|k, w|))
-      (Some (|k, frame|)));
-  Some (|k, w|)
-
-/// Example: a model for a tagged union representing colors in RGB or HSV
-///   type color =
-///     | RGB : r:int -> g:int -> b:int -> color
-///     | HSV : h:int -> s:int -> v:int -> color
-
-type rgb_field = | R | G | B
-type hsv_field = | H | S | V
-type color_tag = | RGB | HSV
-
-(* Carrier of all-or-none PCM for integers *)
-let int_pcm_t = option int
-
-(* Type families for fields of RGB and HSV structs *)
-let rgb_fields k = match k with
-  | R -> int_pcm_t
-  | G -> int_pcm_t
-  | B -> int_pcm_t
-let hsv_fields k = match k with
-  | H -> int_pcm_t
-  | S -> int_pcm_t
-  | V -> int_pcm_t
-  
-(* Carriers of PCMs for RGB and HSV structs *)
-let rgb_t = restricted_t rgb_field rgb_fields
-let hsv_t = restricted_t hsv_field hsv_fields
-
-(* Type family for union of RGB and HSV *)
-let color_cases t = match t with
-  | RGB -> rgb_t
-  | HSV -> hsv_t
-
-(* Carrier of PCM for color *)
-let color_t = union color_cases
-
-(* All-or-none PCM for integers *)
-let int_pcm : pcm int_pcm_t = opt_pcm
-
-(* PCMs for RGB and HSV structs *)
-let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
-  prod_pcm #_ #rgb_fields (fun k -> match k with
-    | R -> int_pcm
-    | G -> int_pcm
-    | B -> int_pcm)
-let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
-  prod_pcm #_ #hsv_fields (fun k -> match k with
-    | H -> int_pcm
-    | S -> int_pcm
-    | V -> int_pcm)
-
-(* PCM for color *)
-let color_pcm_cases k : pcm (color_cases k) = match k with
-  | RGB -> rgb_pcm
-  | HSV -> hsv_pcm
-let color_pcm : pcm color_t = union_pcm color_pcm_cases
-
-(* Update RGB *)
-let rgb_upd (rgb rgb': rgb_t) (f: frame_preserving_upd rgb_pcm rgb rgb')
-: frame_preserving_upd color_pcm (Some (|RGB, rgb|)) (Some (|RGB, rgb'|))
-= union_upd color_pcm_cases RGB rgb rgb' f
-
-(* Update HSV *)
-let hsv_upd (hsv hsv': hsv_t) (f: frame_preserving_upd hsv_pcm hsv hsv')
-: frame_preserving_upd color_pcm (Some (|HSV, hsv|)) (Some (|HSV, hsv'|))
-= union_upd color_pcm_cases HSV hsv hsv' f
-
-/// In general, from
-///   type s = {x1:t1; ..; xn:tn}
-///   (Fields could be annotated with custom PCMs; e.g.
-///      xi: ti [@custom_pcm pcm_for_ti])
-/// Carrier type is
-///   s_pcm_t = t1_pcm_t * .. * tn_pcm_t
-/// And the PCM is
-///   s_pcm = product PCM of t1_pcm .. tn_pcm
-///   where
-///     ti_pcm =
-///       whatever custom PCM was specified by the user, if it exists,
-///       and (opt_pcm #ti_pcm_t) otherwise
-/// 
-/// Similarly, from
-///   type s = | x1:t1 | .. | xn:tn
-/// Carrier type is
-///   s_pcm_t = t1_pcm_t + .. + tn_pcm_t
-/// And the PCM is
-///   s_pcm = union PCM of t1_pcm .. tn_pcm
-///
-/// Any subcomponent of a type built from structs and unions not
-/// annotated by a custom PCM can be updated using prod_upd,
-/// union_upd, and the following frame-preserving update on the
-/// all-or-none PCM:
-
-let opt_pcm_upd (x y: 'a)
-: frame_preserving_upd opt_pcm (Some x) (Some y)
-= fun (Some _) -> (Some y)

From 396305176d44f901b392028370944509f64a08c4 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 29 Jun 2021 13:53:06 -0700
Subject: [PATCH 025/513] Add peel

---
 examples/steel/AggregateRef.fst | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 5500a29539e..6032fcf0ef6 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -456,6 +456,8 @@ module A = Steel.Effect.Atomic
 let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
   {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
+(* TODO Technically don't need to modify the state; could it be
+   SteelGhostT unit (r `pts_to` put l x one) (ref_focus r q l `pts_to` x)? *)
 let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
     (to_vprop (r `pts_to` put l x (one r.q)))
@@ -528,4 +530,14 @@ let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
   r.pl.put_op (one (refined_pcm r.re)) (one (refined_pcm r.re)) x y;
   change_equal_vprop _ (r `pts_to` op r.q x y)
 
-// TODO split/gather (in struct case) a single field out of a restricted_t 'a f
+let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+: SteelT unit
+    (to_vprop (r `pts_to` x))
+    (fun _ ->
+      to_vprop (r `pts_to` put l (one q) x) `star` 
+      to_vprop (r `pts_to` put l (get l x) (one r.q)))
+= q.is_unit (get l x);
+  r.q.is_unit x;
+  q.comm (get l x) (one q);
+  l.put_op x (one r.q) (one q) (get l x);
+  split r x (put l (one q) x) (put l (get l x) (one r.q))

From 1f6e6f845aa9e51363a564c93519df5f378eb771 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 29 Jun 2021 14:44:45 -0700
Subject: [PATCH 026/513] Try make base of pcm_lens a family of types

---
 examples/steel/AggregateRef.fst | 33 +++++++++++++++------------------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 6032fcf0ef6..410bb913f27 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -228,26 +228,25 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
   new_one_is_refined_unit = p.is_unit;
 }
 
-(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
-    This allows the reference to point to substructures of unions with known case. *)
-noeq type ref (a: Type u#a) (b: Type u#b) = {
-  p: pcm a;
-  re: pcm_refinement p;
+open FStar.FunctionalExtensionality
+open Aggregates
+
+noeq type ref (#ix: Type) (a: ix -> Type) (b: Type): Type = {
+  p: i:ix -> pcm (a i);
+  re: pcm_refinement (prod_pcm p);
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
-  r: Steel.Memory.ref a p;
+  r: i:ix -> Steel.Memory.ref (a i) (p i)
 }
 
-(** A ref r points to a value v if r's underlying ref points to a chunk of memory
-    which contains at least the value v. *)
+let pts_to_at (r: ref 'a 'b) (v: Ghost.erased 'b) i: Steel.Memory.slprop =
+  r.r i `Steel.Memory.pts_to` put r.pl v (one (refined_pcm r.re)) i
+  
 let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): Steel.Memory.slprop =
-  Steel.Memory.(r.r `pts_to` put r.pl v (one (refined_pcm r.re)))
+  Steel.Memory.(h_forall (fun i -> r.r i `pts_to` put r.pl v (one (refined_pcm r.re)) i))
 
 (** Basic lenses *)
 
-open Aggregates
-
 let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
 let lens_fst #a #b : lens (a & b) a = {
   get = fst;
@@ -367,8 +366,6 @@ let init_pcm (p: pcm 'a) (one_dec:(x:'a -> b:bool{b <==> x == one p})): pcm (ini
 
 (** A lens for the k-th field of an n-ary product *)
 
-open FStar.FunctionalExtensionality
-
 let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
 let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
   get = lens_field_get f k;
@@ -453,13 +450,12 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
+(*
 let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
   {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
-(* TODO Technically don't need to modify the state; could it be
-   SteelGhostT unit (r `pts_to` put l x one) (ref_focus r q l `pts_to` x)? *)
-let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'c)
-: Steel (ref 'a 'c)
+let focus (r: ref 'a 'b) (q: pcm 'd) (l: pcm_lens r.q q) (x: Ghost.erased 'd)
+: Steel (ref 'a 'b)
     (to_vprop (r `pts_to` put l x (one r.q)))
     (fun r' -> to_vprop (r' `pts_to` x))
     (fun _ -> True)
@@ -541,3 +537,4 @@ let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
   q.comm (get l x) (one q);
   l.put_op x (one r.q) (one q) (get l x);
   split r x (put l (one q) x) (put l (get l x) (one r.q))
+*)

From 1e5223c1e3b4ae53e2b0a752c6b8c3dc9a3184e2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 29 Jun 2021 16:02:37 -0700
Subject: [PATCH 027/513] Add Basetypes.md

---
 examples/steel/Basetypes.md | 130 ++++++++++++++++++++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 examples/steel/Basetypes.md

diff --git a/examples/steel/Basetypes.md b/examples/steel/Basetypes.md
new file mode 100644
index 00000000000..50bcc58f28a
--- /dev/null
+++ b/examples/steel/Basetypes.md
@@ -0,0 +1,130 @@
+The Steel heap maps addresses to cells, and each cell holds both a value `v` and its type `a`:
+```fst
+noeq
+type cell : Type u#(a + 1) =
+  | Ref : a:Type u#a ->
+          p:pcm a ->
+          frac:Frac.perm{ frac `Frac.lesser_equal_perm` Frac.full_perm } ->
+          v:a { frac == Frac.full_perm ==> p.refine v } ->
+          cell
+```
+If we would like to model references to substructures `w:b` of `v`
+without having to add new constructors to `cell` specifically for structs and arrays,
+it seems inevitable that the model will have to keep track of both the
+type `b` of the substructure and the type `a` of its base object.
+AggregateRef.fst defines a type of such references `ref a b`.
+Because ref has to keep track of the type of its base object, code
+that works with references has to carry around extra parameters.
+The model runs into trouble when the number of references isn't known
+statically; for example, if one wants to specify the contents of an array
+of references, each with possibly different base objects.
+Unfortunately it's not possible to solve this by hiding `a` behind
+an existential, because that would increase `ref`'s universe level.
+
+One idea could be to hide `a` inside a closure, exposing only a record of basic operations:
+```fstar
+let operations =
+  let r: ref a b = .. in {
+    read = (fun () -> .. r ..);
+    write = (fun () -> .. r ..);
+  }
+```
+This would work if we just wanted simply typed versions of `read` and `write`,
+but there is no way to give dependently-typed specifications to these
+functions without talking about the base object `a`.
+
+Here are some ideas on how to resolve this:
+
+### Hide `a` in a closure, then carry along proofs extrinsically
+
+Construct a record `{read = .., write = ..}` hiding the base type `a`
+and the raw `ref a b` inside closures, and give `read` and `write` simple types.
+Return, with it, a proof of `exists a. read spec /\ write spec`.
+This would allow the record to live in universe `0` (the record is
+simply typed and the proof is squashed), so refs could safely be stored in the Steel heap.
+
+However, giving the operations simple types means that they have to return some bogus
+value (or be partial) on inputs which don't satisfy their preconditions;
+this seems tricky, or maybe even impossible if the preconditions aren't decidable.
+
+### Represent refs just as addresses
+
+The heap stores the types and PCMs along with values.
+Is it possible, then, to avoid storing those same types and PCMs inside the ref?
+If so, we could store refs in the heap, and only mention base types/PCMs
+in predicates like `pts_to`. Unfortunately, this doesn't seem possible
+either, because the base type is needed to give a type to the lens.
+
+### Store the lens in the heap
+
+Can we treat a reference like an addressable stack-local and store
+its lens in the heap? For example, if we start with
+```
+p `pts_to` {x, y}
+```
+and take a pointer to the first field of `{x, y}`, we get
+```
+(p `pts_to` {x, y}) `star`
+(r `pts_to` {base_type & lens for field x of base_type})
+r: Steel.Memory.ref _
+```
+This loses a lot of equalities. For example, if we take
+a second pointer to the first field of `{x, y}` we get
+```
+(p `pts_to` {x, y}) `star`
+(r `pts_to` {base_type & lens for field x of base_type})
+(s `pts_to` {base_type & lens for field x of base_type})
+r, s: Steel.Memory.ref _
+```
+If we would like to use the fact that `r` and `s` alias later on,
+we need to use separation logic to prove that any code between then
+and when the pointers were taken didn't modify either of the lenses.
+
+### Store lenses along with base objects
+
+Instead of just storing values v in the heap, store (v, [l1, .., ln])
+where [l1, .., ln] are a (heterogenous) list of lenses into
+v. Represent references as (addr, k) where k is an index into this
+list. (This may not necessarily mean modifying Steel.Heap---it could
+be possible to design a PCM to carry along these lists of lenses.)
+
+This would fix the universe issue, but it's very complicated..
+Also, in order to nicely support reasoning about aliasing, we would
+want that the list of lenses not contain any duplicates; to maintain
+that invariant, we'd need decidable equality on lenses, which isn't guaranteed.
+
+### Give up on hiding the base object
+
+Though the model in AggregateRef.fst is designed for writing C-like code,
+the representation of a reference as a lens + Steel memory ref
+suggests that there could be more high-level applications of references as well.
+For example, it might be possible to construct a "reference" to a linked list
+which allows viewing it as an ordinary F* list of its elements, or to
+construct a "reference" to a u32 from the upper 16 bits of two other u32 references.
+These things aren't possible with the current model because an AggregateRef.ref
+contains only one Steel.Memory.ref, and therefore can only point to
+one piece of memory; in order to support these fancy applications,
+we'd need to allow an AggregateRef.ref to point to parts of multiple
+different pieces at once.
+
+We could address this and somewhat get around the base object issue by
+representing references as a lens + a family of `Steel.Memory.ref`s
+instead of just a single `Steel.Memory.ref`.
+Then:
+- It would be possible to write a function like
+    `ref u32 u16 -> ref u32 u16 -> ref (u32 & u32) u32`
+    to combine two refs for the upper 16 bits of two `u32`s into
+    a 32-bit ref
+- It would be possible to write a function like
+    `cons: ref 'a 'c -> ref 'b (list 'c) -> ref ('a & 'b) (list 'c)`
+    to build up a "reference" to a linked list
+- An array of pointers `t *a[n]` could be represented by a
+    `ref base_type_at (i:nat{i<n} -> ref (base_type_at i) t)`
+    For example, if I have two references `p: ref ('a1 * .. * 'am) 'c`
+    and `q: ref ('b1 * .. * 'bn) 'c` then an array containing `p` and `q`
+    could be represented by
+      ```fstar
+      let base_type is_p =
+        if is_p then 'a1*..*'am else 'b1*..*'bn
+      in r: ref base_type (is_q:bool -> ref (base_type is_q) 'c)
+      ```
\ No newline at end of file

From 42689dda5f4c3843c3adc0909c068edb7365e57c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 29 Jun 2021 16:06:28 -0700
Subject: [PATCH 028/513] markdown

---
 examples/steel/Basetypes.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/steel/Basetypes.md b/examples/steel/Basetypes.md
index 50bcc58f28a..0a3e09f9bb4 100644
--- a/examples/steel/Basetypes.md
+++ b/examples/steel/Basetypes.md
@@ -123,6 +123,7 @@ Then:
     For example, if I have two references `p: ref ('a1 * .. * 'am) 'c`
     and `q: ref ('b1 * .. * 'bn) 'c` then an array containing `p` and `q`
     could be represented by
+
       ```fstar
       let base_type is_p =
         if is_p then 'a1*..*'am else 'b1*..*'bn

From f469dc6ced60f750a49d0b9dc17559253cb0f03f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 30 Jun 2021 10:14:42 -0700
Subject: [PATCH 029/513] Attempt polymorphic lenses

---
 examples/steel/AggregateRef.fst | 88 +++++++++++++++++++--------------
 1 file changed, 50 insertions(+), 38 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 410bb913f27..0515e969887 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -6,74 +6,84 @@ module P = FStar.PCM
 (* TODO move to FStar.PCM.fst, use in earlier code to avoid P.p.one *)
 let one (p: pcm 'a) = p.P.p.one
 
-(** Very well-behaved lenses *)
-noeq type lens (a: Type u#a) (b: Type u#b) = {
-  get: a -> b;
-  put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
-  put_get: s: a -> Lemma (put (get s) s == s);
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+(** Very well-behaved polymorphic lenses *)
+noeq type lens #ix (a: ix -> Type u#a) (b: ix -> Type u#b) = {
+  get: #i:ix -> a i -> b i;
+  put: #i:ix -> #j:ix -> b j -> a i -> a j;
+  get_put: #i:ix -> #j:ix -> s: a i -> v: b j -> Lemma (get (put v s) == v);
+  put_get: #i:ix -> s: a i -> Lemma (put (get s) s == s);
+  put_put: #i:ix -> #j:ix -> s: a i -> v: b j -> w: b j -> Lemma (put v (put w s) == put v s);
 }
-let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
+let get_put' (l: lens 'a 'b) (s: 'a 'i) (v: 'b 'j)
   : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
   = l.get_put s v
-let put_get' (l: lens 'a 'b) (s: 'a)
-  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
+let put_get' (l: lens 'a 'b) (s: 'a 'i)
+  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s) s)]
   = l.put_get s
-let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
+let put_put' (l: lens 'a 'b) (s: 'a 'i) (v w: 'b 'j)
   : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
   = l.put_put s v w
 
 (** Updating the target of a lens *)
-let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+let lens_upd (l: lens 'a 'b) (f: 'b 'i -> 'b 'j) (s: 'a 'i): 'a 'j = l.put (f (l.get s)) s
 
 (** The identity lens *)
-let const (x: 'a) (b: 'b): 'a = x
-let lens_id #a : lens a a = {
-  get = id;
-  put = const;
+let lens_id_get (x: 'a 'i): 'a 'i = x
+let lens_id_put #i #j (x: 'a j) (y: 'a i): 'a j = x
+let lens_id (a: 'i -> Type) : lens a a = {
+  get = lens_id_get;
+  put = lens_id_put;
   get_put = (fun _ _ -> ());
   put_get = (fun _ -> ());
   put_put = (fun _ _ _ -> ());
 }
 
 (** Lens composition *)
-let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
-let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
+let get_comp (l: lens 'a 'b) (m: lens 'b 'c) #i (s: 'a i): 'c i = m.get (l.get s)
+let put_comp (l: lens 'a 'b) (m: lens 'b 'c) #i #j (v: 'c j) (s: 'a i): 'a j =
   lens_upd l (m.put v) s
-let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
-  get = get_comp l m;
+let lens_comp (a b c: 'i -> Type) (l: lens a b) (m: lens b c): lens a c = {
+  get = (fun #i -> get_comp l m #i);
   put = put_comp l m;
   get_put = (fun _ _ -> ());
   put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
+  put_put = (fun s v w -> ());
 }
 
+let pcms (f: 'i -> Type) = i:'i -> pcm (f i)
+
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
     (1) get is a PCM morphism p -> q
     (2) put is a PCM morphism p×q -> p, where (×) = Aggregates.tuple_pcm *)
-noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
+noeq type pcm_lens #ix #a #b (p: pcms a) (q: pcms b) = {
   l: lens a b;
-  get_refine: s:a ->
-    Lemma (requires p.refine s) (ensures q.refine (l.get s)) [SMTPat (p.refine s)];
-  get_one: unit -> Lemma (l.get (one p) == one q);
-  get_op_composable: s:a -> t:a ->
+  get_refine: #i:ix -> s:a i ->
+    Lemma 
+      (requires (p i).refine s) 
+      (ensures (q i).refine (l.get s))
+    [SMTPat ((p i).refine s)];
+  get_one: #i:ix -> Lemma (l.get (one (p i)) == one (q i));
+  get_op_composable: #i:ix -> s:a i -> t:a i ->
     Lemma
-      (requires composable p s t)
-      (ensures composable q (l.get s) (l.get t));
-  put_refine: s:a -> v:b ->
-    Lemma (requires p.refine s /\ q.refine v) (ensures p.refine (l.put v s))
-    [SMTPat (p.refine (l.put v s))];
-  put_one: unit -> Lemma (l.put (one q) (one p) == one p);
-  put_op: s:a -> t:a -> v:b -> w:b ->
+      (requires composable (p i) s t)
+      (ensures composable (q i) (l.get s) (l.get t));
+  put_refine: #i:ix -> #j:ix -> s:a i -> v:b j ->
+    Lemma 
+      (requires (p i).refine s /\ (q j).refine v)
+      (ensures (p j).refine (l.put v s))
+    [SMTPat ((p i).refine (l.put v s))];
+  put_one: #i:ix -> #j:ix -> Lemma (l.put (one (q j)) (one (p i)) == one (p j));
+  put_op: #i:ix -> #j:ix -> s:a i -> t:a i -> v:b j -> w:b j ->
     Lemma
-      (requires composable p s t /\ composable q v w)
-      (ensures composable p (l.put v s) (l.put w t) /\
-               l.put (op q v w) (op p s t) == op p (l.put v s) (l.put w t))
+      (requires composable (p i) s t /\ composable (q j) v w)
+      (ensures composable (p j) (l.put v s) (l.put w t) /\
+               l.put (op (q j) v w) (op (p i) s t) == op (p j) (l.put v s) (l.put w t))
     [SMTPatOr [
-      [SMTPat (l.put (op q v w) (op p s t))];
-      [SMTPat (composable p (l.put v s) (l.put w t))]]];
+      [SMTPat (l.put (op (q j) v w) (op (p i) s t))];
+      [SMTPat (composable (p j) (l.put v s) (l.put w t))]]];
 }
+
+(*
 let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
 let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
 let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
@@ -538,3 +548,5 @@ let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
   l.put_op x (one r.q) (one q) (get l x);
   split r x (put l (one q) x) (put l (get l x) (one r.q))
 *)
+
+*)

From 317b49e407cf50e46b87af3c0bd02be7a5b89a1a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 30 Jun 2021 15:29:01 -0700
Subject: [PATCH 030/513] Define refinements of pcm_lenses

Along the way, define: isomorphisms, PCM isomorphisms, refinements of lenses, composition of refinements, composition of isomorphisms with lenses, composition of refinements with pcm_lenses
---
 examples/steel/AggregateRef.fst | 615 ++++++++++++++++++++++++--------
 1 file changed, 462 insertions(+), 153 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 0515e969887..eea53f62746 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -6,111 +6,122 @@ module P = FStar.PCM
 (* TODO move to FStar.PCM.fst, use in earlier code to avoid P.p.one *)
 let one (p: pcm 'a) = p.P.p.one
 
-(** Very well-behaved polymorphic lenses *)
-noeq type lens #ix (a: ix -> Type u#a) (b: ix -> Type u#b) = {
-  get: #i:ix -> a i -> b i;
-  put: #i:ix -> #j:ix -> b j -> a i -> a j;
-  get_put: #i:ix -> #j:ix -> s: a i -> v: b j -> Lemma (get (put v s) == v);
-  put_get: #i:ix -> s: a i -> Lemma (put (get s) s == s);
-  put_put: #i:ix -> #j:ix -> s: a i -> v: b j -> w: b j -> Lemma (put v (put w s) == put v s);
-}
-let get_put' (l: lens 'a 'b) (s: 'a 'i) (v: 'b 'j)
+(** Very well-behaved lenses *)
+noeq type lens (a: Type u#a) (b: Type u#b) = {
+  get: a -> b;
+  put: b -> a -> a;
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
+  put_get: s: a -> Lemma (put (get s) s == s);
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+}
+let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
   : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
   = l.get_put s v
-let put_get' (l: lens 'a 'b) (s: 'a 'i)
-  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s) s)]
+let put_get' (l: lens 'a 'b) (s: 'a)
+  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
   = l.put_get s
-let put_put' (l: lens 'a 'b) (s: 'a 'i) (v w: 'b 'j)
+let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
   : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
   = l.put_put s v w
 
 (** Updating the target of a lens *)
-let lens_upd (l: lens 'a 'b) (f: 'b 'i -> 'b 'j) (s: 'a 'i): 'a 'j = l.put (f (l.get s)) s
+let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
 
 (** The identity lens *)
-let lens_id_get (x: 'a 'i): 'a 'i = x
-let lens_id_put #i #j (x: 'a j) (y: 'a i): 'a j = x
-let lens_id (a: 'i -> Type) : lens a a = {
-  get = lens_id_get;
-  put = lens_id_put;
+let const (x: 'a) (b: 'b): 'a = x
+let lens_id #a : lens a a = {
+  get = id;
+  put = const;
   get_put = (fun _ _ -> ());
   put_get = (fun _ -> ());
   put_put = (fun _ _ _ -> ());
 }
 
 (** Lens composition *)
-let get_comp (l: lens 'a 'b) (m: lens 'b 'c) #i (s: 'a i): 'c i = m.get (l.get s)
-let put_comp (l: lens 'a 'b) (m: lens 'b 'c) #i #j (v: 'c j) (s: 'a i): 'a j =
+let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
+let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
   lens_upd l (m.put v) s
-let lens_comp (a b c: 'i -> Type) (l: lens a b) (m: lens b c): lens a c = {
-  get = (fun #i -> get_comp l m #i);
+let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
+  get = get_comp l m;
   put = put_comp l m;
   get_put = (fun _ _ -> ());
   put_get = (fun _ -> ());
-  put_put = (fun s v w -> ());
+  put_put = (fun _ _ _ -> ());
 }
 
-let pcms (f: 'i -> Type) = i:'i -> pcm (f i)
-
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
     (1) get is a PCM morphism p -> q
-    (2) put is a PCM morphism p×q -> p, where (×) = Aggregates.tuple_pcm *)
-noeq type pcm_lens #ix #a #b (p: pcms a) (q: pcms b) = {
-  l: lens a b;
-  get_refine: #i:ix -> s:a i ->
+    (2) put is a PCM morphism q×p -> p, where (×) = Aggregates.tuple_pcm *)
+
+let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
+let morphism_one (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  unit -> Lemma (f (one p) == one q)
+let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  x:'a -> y:'a ->
     Lemma 
-      (requires (p i).refine s) 
-      (ensures (q i).refine (l.get s))
-    [SMTPat ((p i).refine s)];
-  get_one: #i:ix -> Lemma (l.get (one (p i)) == one (q i));
-  get_op_composable: #i:ix -> s:a i -> t:a i ->
-    Lemma
-      (requires composable (p i) s t)
-      (ensures composable (q i) (l.get s) (l.get t));
-  put_refine: #i:ix -> #j:ix -> s:a i -> v:b j ->
+      (requires composable p x y) 
+      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
+      [SMTPat (composable p x y)]
+
+noeq type pcm_morphism #a #b (p: pcm a) (q: pcm b) (f: a -> b) = {
+  f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
+  f_one: morphism_one p q f;
+  f_op: x:a -> y:a ->
     Lemma 
-      (requires (p i).refine s /\ (q j).refine v)
-      (ensures (p j).refine (l.put v s))
-    [SMTPat ((p i).refine (l.put v s))];
-  put_one: #i:ix -> #j:ix -> Lemma (l.put (one (q j)) (one (p i)) == one (p j));
-  put_op: #i:ix -> #j:ix -> s:a i -> t:a i -> v:b j -> w:b j ->
-    Lemma
-      (requires composable (p i) s t /\ composable (q j) v w)
-      (ensures composable (p j) (l.put v s) (l.put w t) /\
-               l.put (op (q j) v w) (op (p i) s t) == op (p j) (l.put v s) (l.put w t))
-    [SMTPatOr [
-      [SMTPat (l.put (op (q j) v w) (op (p i) s t))];
-      [SMTPat (composable (p j) (l.put v s) (l.put w t))]]];
+      (requires composable p x y) 
+      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
+      [SMTPat (composable p x y)]
 }
 
-(*
+let pcm_morphism_id (#p: pcm 'a): pcm_morphism p p id = {
+  f_refine = (fun _ -> ());
+  f_one = (fun _ -> ());
+  f_op = (fun _ _ -> ());
+}
+
+(* TODO is this in stdlib somewhere? *)
+let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+
+let pcm_morphism_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#f: 'b -> 'c) (#g: 'a -> 'b)
+  (mf: pcm_morphism q r f) (mg: pcm_morphism p q g)
+: pcm_morphism p r (f `compose` g) = {
+  f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
+  f_one = (fun () -> mg.f_one (); mf.f_one ());
+  f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
+}
+
+(* TODO in stdlib? *)
+let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
+
+open Aggregates
+let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: 'a -> 'c) (#g: 'b -> 'd)
+  (mf: pcm_morphism p r f) (mg: pcm_morphism q s g)
+: pcm_morphism (tuple_pcm p q) (tuple_pcm r s) (both f g) = {
+  f_refine = (fun (x, y) -> mf.f_refine x; mg.f_refine y);
+  f_one = (fun () -> mg.f_one (); mf.f_one ());
+  f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
+}
+
+(* TODO in stdlib? *)
+let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
+
+noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
+  l: lens a b;
+  get_morphism: pcm_morphism p q l.get;
+  put_morphism: pcm_morphism (tuple_pcm q p) p (uncurry l.put);
+}
 let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
 let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
 let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
 
-(** The property get (s * t) = get s * get t is derivable from lens laws and the fact
-    that put is a PCM morphism:
-      get (s * t)
-      = get (put (get s) s * put (get t) t)
-      = get (put (get s * get t) (s * t))
-      = get s * get t
-    So one only needs to prove composable s t ==> composable (get s) (get t) when
-    defining a pcm_lens. If we could find a way to also prove this from the fact that
-    put is a PCM morphism, we could do away with get_op_composable entirely. *)
-let get_op (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s t: 'a)
-: Lemma
-    (requires composable p s t)
-    (ensures composable q (get l s) (get l t) /\ get l (op p s t) == op q (get l s) (get l t))
-    [SMTPat (get l (op p s t))]
-= l.get_op_composable s t; l.put_op s t (get l s) (get l t)
-
 (** The upd function of a pcm_lens lifts frame-preserving updates on the target to
     frame-preserving updates on the source *)
 
 let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
 : Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
 = compatible_elim p x y (compatible q (get l x) (get l y)) (fun frame_x ->
-  let _ = get_op l frame_x x in
+  let _ = l.get_morphism.f_op frame_x x in
   compatible_intro q (get l x) (get l y) (get l frame_x))
     
 (** The non-computational part of frame_preserving_upd
@@ -149,35 +160,59 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
     (requires frame_pres q f (get l s) v)
     (ensures frame_pres p (upd l f) s (put l v s))
     [SMTPat (frame_pres q f (get l s) v)]
-= frame_pres_intro p (upd l f) s (put l v s) (fun full ->
-    let _ = l.get_refine in
+= frame_pres_intro p (lens_upd l.l f) s (l.l.put v s) (fun full ->
+    assert (p.refine full);
+    assert (compatible p s full);
+    assert (lens_upd l.l f full == l.l.put (f (l.l.get full)) full);
+    let _ = l.get_morphism.f_refine in
+    assert (q.refine (l.l.get full));
     pcm_lens_compatible_get l s full;
-    let _ = l.put_refine in
-    let goal = frame_pres_on p (upd l f) s (put l v s) full in
+    assert (compatible q (l.l.get s) (l.l.get full));
+    assert (q.refine (f (l.l.get full)));
+    l.put_morphism.f_refine (f (l.l.get full), full);
+    assert (q.refine (f (l.l.get full)));
+    assert (p.refine (l.l.put (f (l.l.get full)) full));
+    assert (p.refine (lens_upd l.l f full));
+    assert (compatible q v (f (l.l.get full)));
+    let goal = frame_pres_on p (lens_upd l.l f) s (l.l.put v s) full in
     compatible_elim p s full goal (fun frame_s ->
-    compatible_elim q v (f (get l full)) goal (fun frame_v ->
-    let frame_vs: 'a = put l frame_v frame_s in
-    l.put_op s frame_s v frame_v;
-    p.comm frame_vs (put l v s);
+    compatible_elim q v (f (l.l.get full)) goal (fun frame_v ->
+    assert (composable q v frame_v /\ op q frame_v v == f (l.l.get full));
+    let frame_vs: 'a = l.l.put frame_v frame_s in
+    l.put_morphism.f_op (v, s) (frame_v, frame_s);
+    assert (composable p (l.l.put v s) frame_vs);
+    p.comm frame_vs (l.l.put v s);
     q.comm v frame_v;
     p.comm s frame_s;
-    compatible_intro p (put l v s) (upd l f full) frame_vs;
+    assert (op p frame_vs (l.l.put v s) == op p (l.l.put v s) frame_vs);
+    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
+    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
+    assert (op p frame_vs (l.l.put v s) == lens_upd l.l f full);
+    compatible_intro p (l.l.put v s) (lens_upd l.l f full) frame_vs;
     let aux (frame:'a{composable p s frame})
-    : Lemma (composable p (put l v s) frame /\
-             (op p s frame == full ==> op p (put l v s) frame == upd l f full))
-    = get_op l s frame;
-      l.put_op s frame v (get l frame)
+    : Lemma (composable p (l.l.put v s) frame /\
+             (op p s frame == full ==> op p (l.l.put v s) frame == lens_upd l.l f full))
+    = l.get_morphism.f_op s frame;
+      assert (composable q (l.l.get s) (l.l.get frame));
+      assert (composable q v (l.l.get frame));
+      assert (composable p s frame);
+      l.put_morphism.f_op (v, s) (l.l.get frame, frame);
+      let aux ()
+      : Lemma (requires op p s frame == full) 
+              (ensures op p (l.l.put v s) frame == lens_upd l.l f full)
+      = assert (composable p (l.l.put v s) (l.l.put (l.l.get frame) frame));
+        assert (op p (l.l.put v s) frame == op p (l.l.put v s) (l.l.put (l.l.get frame) frame));
+        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) (op p s frame));
+        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) full);
+        ()
+      in ()
     in FStar.Classical.forall_intro aux)))
 
 (** The identity lens is a pcm_lens *)
 let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
   l = lens_id; 
-  get_refine = (fun _ -> ());
-  get_one = (fun _ -> ());
-  get_op_composable = (fun _ _ -> ());
-  put_refine = (fun _ _ -> ());
-  put_one = (fun _ -> ());
-  put_op = (fun _ _ _ _ -> ());
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
 
 (** pcm_lens composition is lens composition *)
@@ -185,22 +220,26 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r = 
 {
   l = lens_comp l.l m.l;
-  get_refine = (fun _ ->
-    let _ = l.get_refine in
-    let _ = m.get_refine in ());
-  get_one = (fun _ -> l.get_one (); m.get_one ());
-  get_op_composable = (fun s t ->
-    get_op l s t;
-    get_op m (get l s) (get l t));
-  put_refine = (fun s v ->
-    let _ = l.put_refine in
-    let _ = m.put_refine in
-    let _ = l.get_refine in ());
-  put_one = (fun _ -> l.put_one (); m.put_one ());
-  put_op = (fun s t v w ->
-    get_op l s t;
-    m.put_op (get l s) (get l t) v w;
-    l.put_op s t (put m v (get l s)) (put m w (get l t)))
+  get_morphism = {
+    f_refine = (fun _ ->
+      let _ = l.get_morphism.f_refine in
+      let _ = m.get_morphism.f_refine in ());
+    f_one = (fun _ -> l.get_morphism.f_one (); m.get_morphism.f_one ());
+    f_op = (fun s t ->
+      l.get_morphism.f_op s t;
+      m.get_morphism.f_op (get l s) (get l t));
+  };
+  put_morphism = {
+    f_refine = (fun (v, s) ->
+      l.get_morphism.f_refine s;
+      m.put_morphism.f_refine (v, get l s);
+      l.put_morphism.f_refine (put m v (get l s), s));
+    f_one = (fun _ -> l.put_morphism.f_one (); m.put_morphism.f_one ());
+    f_op = (fun (v, s) (w, t) ->
+      l.get_morphism.f_op s t;
+      m.put_morphism.f_op (v, get l s) (w, get l t);
+      l.put_morphism.f_op (put m v (get l s), s) (put m w (get l t), t));
+  };
 }
 
 (** A refinement of a PCM (p: pcm a) consists of:
@@ -239,21 +278,17 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
 }
 
 open FStar.FunctionalExtensionality
-open Aggregates
 
-noeq type ref (#ix: Type) (a: ix -> Type) (b: Type): Type = {
-  p: i:ix -> pcm (a i);
-  re: pcm_refinement (prod_pcm p);
+noeq type ref (a:Type) (b:Type): Type = {
+  p: pcm a;
+  re: pcm_refinement p;
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
-  r: i:ix -> Steel.Memory.ref (a i) (p i)
+  r: Steel.Memory.ref a p;
 }
 
-let pts_to_at (r: ref 'a 'b) (v: Ghost.erased 'b) i: Steel.Memory.slprop =
-  r.r i `Steel.Memory.pts_to` put r.pl v (one (refined_pcm r.re)) i
-  
 let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): Steel.Memory.slprop =
-  Steel.Memory.(h_forall (fun i -> r.r i `pts_to` put r.pl v (one (refined_pcm r.re)) i))
+  Steel.Memory.(r.r `pts_to` put r.pl v (one (refined_pcm r.re)))
 
 (** Basic lenses *)
 
@@ -268,12 +303,8 @@ let lens_fst #a #b : lens (a & b) a = {
 
 let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
   l = lens_fst;
-  get_refine = (fun _ -> ());
-  get_one = (fun _ -> ());
-  get_op_composable = (fun _ _ -> ());
-  put_refine = (fun _ _ -> ());
-  put_one = (fun _ -> ());
-  put_op = (fun _ _ _ _ -> ());
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
 
 (** We can create lenses for unions if we know which case of the union we are in: *)
@@ -394,21 +425,21 @@ let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
 
 let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
   l = lens_field f k;
-  get_refine = (fun s -> ());
-  get_one = (fun _ -> ());
-  get_op_composable = (fun s t -> ());
-  put_refine = (fun s v -> ());
-  put_one = (fun _ ->
-    ext
-      (fun_upd k (one (p k)) (one (prod_pcm p)))
-      (one (prod_pcm p))
-      (fun k -> ()));
-  put_op = (fun s t v w ->
-    prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
-    ext
-      (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
-      (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
-      (fun _ -> ()));
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {
+    f_refine = (fun _ -> ());
+    f_one = (fun _ ->
+      ext
+        (fun_upd k (one (p k)) (one (prod_pcm p)))
+        (one (prod_pcm p))
+        (fun k -> ()));
+    f_op = (fun (v, s) (w, t) ->
+      prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
+      ext
+        (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
+        (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
+        (fun _ -> ()));
+  }
 }
 
 (** The refinement of an n-ary union PCM to the k-th case *)
@@ -446,12 +477,8 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
 (** lens_case is a pcm_lens *)
 let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
   l = lens_case p k;
-  get_refine = (fun s -> ());
-  get_one = (fun _ -> ());
-  get_op_composable = (fun s t -> ());
-  put_refine = (fun s v -> ());
-  put_one = (fun _ -> ());
-  put_op = (fun s t v w -> ());
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
 
 (* Basic operations *)
@@ -460,22 +487,21 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-(*
 let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
   {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
-let focus (r: ref 'a 'b) (q: pcm 'd) (l: pcm_lens r.q q) (x: Ghost.erased 'd)
-: Steel (ref 'a 'b)
-    (to_vprop (r `pts_to` put l x (one r.q)))
+let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ref 'a 'c)
+    (to_vprop (r `pts_to` s))
     (fun r' -> to_vprop (r' `pts_to` x))
-    (fun _ -> True)
+    (fun _ -> Ghost.reveal s == put l x (one r.q))
     (fun _ r' _ -> r' == ref_focus r q l)
 = let r' = ref_focus r q l in
   A.change_slprop_rel  
-    (to_vprop (r `pts_to` put l x (one r.q)))
+    (to_vprop (r `pts_to` s))
     (to_vprop (r' `pts_to` x))
     (fun _ _ -> True)
-    (fun m -> r.pl.get_one ());
+    (fun m -> r.pl.get_morphism.f_one ());
   A.return r'
 
 let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
@@ -489,7 +515,7 @@ let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
     (to_vprop (r `pts_to` x))
     (to_vprop (r' `pts_to` put l x (one r'.q)))
     (fun _ _ -> True)
-    (fun m -> r'.pl.get_one ())
+    (fun m -> r'.pl.get_morphism.f_one ())
 
 let change_equal_vprop #inames (p q: M.slprop)
 : A.SteelGhost unit inames (to_vprop p) (fun _ -> to_vprop q) (fun _ -> p == q) (fun _ _ _ -> True)
@@ -506,7 +532,9 @@ let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
     (to_vprop (r `pts_to` xy))
     (to_vprop (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re))))));
   (refined_pcm r.re).is_unit (one (refined_pcm r.re));
-  r.pl.put_op (one (refined_pcm r.re)) (one (refined_pcm r.re)) x y;
+  r.pl.put_morphism.f_op
+    (Ghost.reveal x, one (refined_pcm r.re))
+    (Ghost.reveal y, one (refined_pcm r.re));
   Steel.PCMReference.split r.r
     (put r.pl xy (one (refined_pcm r.re)))
     (put r.pl x (one (refined_pcm r.re)))
@@ -531,9 +559,13 @@ let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
   Steel.PCMReference.gather r.r
     (put r.pl x (one (refined_pcm r.re)))
     (put r.pl y (one (refined_pcm r.re)));
-  get_op r.pl (put r.pl x (one (refined_pcm r.re))) (put r.pl y (one (refined_pcm r.re)));
+  r.pl.get_morphism.f_op
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
   (refined_pcm r.re).is_unit (one (refined_pcm r.re));
-  r.pl.put_op (one (refined_pcm r.re)) (one (refined_pcm r.re)) x y;
+  r.pl.put_morphism.f_op
+    (Ghost.reveal x, one (refined_pcm r.re))
+    (Ghost.reveal y, one (refined_pcm r.re));
   change_equal_vprop _ (r `pts_to` op r.q x y)
 
 let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
@@ -545,8 +577,285 @@ let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
 = q.is_unit (get l x);
   r.q.is_unit x;
   q.comm (get l x) (one q);
-  l.put_op x (one r.q) (one q) (get l x);
+  l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
   split r x (put l (one q) x) (put l (get l x) (one r.q))
-*)
 
-*)
+let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+: SteelT (ref 'a 'c)
+    (to_vprop (r `pts_to` x))
+    (fun s ->
+      to_vprop (r `pts_to` put l (one q) x) `star` 
+      to_vprop (s `pts_to` get l x))
+= peel r q l x;
+  focus r q l (put l (get l x) (one r.q)) (get l x)
+
+(** Refining a pcm_ref  *)
+
+let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
+
+let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+  (y: refine_t (extend_refinement_f l re){composable p x y})
+: Lemma (extend_refinement_f l re (op p x y))
+= l.get_morphism.f_op x y;
+  re.f_closed_under_op (get l x) (get l y)
+
+let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q): refine_t (extend_refinement_f l re)
+= put l re.new_one (one p)
+
+let extend_refinement_new_one_is_refined_unit
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+: Lemma (composable p x (extend_refinement_new_one l re) /\
+         op p x (extend_refinement_new_one l re) == x)
+= re.new_one_is_refined_unit (get l x);
+  p.is_unit x;
+  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+
+let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
+  f = extend_refinement_f l re;
+  f_closed_under_op = extend_refinement_f_closed l re;
+  new_one = extend_refinement_new_one l re;
+  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+}
+
+let lens_refine_get (l: lens 'a 'b) f
+  (s: refine_t (f `compose` l.get)): refine_t f
+= l.get s
+let lens_refine_put (l: lens 'a 'b) f
+  (v: refine_t f) (s: refine_t (f `compose` l.get)): refine_t (f `compose` l.get)
+= l.put v s
+
+let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
+: lens (refine_t (f `compose` l.get)) (refine_t f) = {
+  get = lens_refine_get l f;
+  put = lens_refine_put l f;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_refine
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l.l re.f).get
+= l.get_morphism.f_refine
+
+let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_one
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l.l re.f).get
+= l.get_morphism.f_one
+
+let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_op
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l.l re.f).get
+= l.get_morphism.f_op
+
+let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_refine
+    (tuple_pcm (refined_pcm re) (refined_pcm (extend_refinement l re)))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l.l re.f).put)
+= fun (v, s) -> l.put_morphism.f_refine (v, s)
+
+let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_one
+    (tuple_pcm (refined_pcm re) (refined_pcm (extend_refinement l re)))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l.l re.f).put)
+= l.put_morphism.f_one
+
+let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_op
+    (tuple_pcm (refined_pcm re) (refined_pcm (extend_refinement l re)))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l.l re.f).put)
+= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
+
+let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
+  l = lens_refine l.l re.f;
+  get_morphism = {
+    f_refine = pcm_lens_refine_get_morphism_refine l re;
+    f_one = pcm_lens_refine_get_morphism_one l re;
+    f_op = pcm_lens_refine_get_morphism_op l re;
+  };
+  put_morphism = {
+    f_refine = pcm_lens_refine_put_morphism_refine l re;
+    f_one = pcm_lens_refine_put_morphism_one l re;
+    f_op = pcm_lens_refine_put_morphism_op l re;
+  };
+}
+
+(* TODO is this in stdlib somewhere? *)
+let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
+
+let conj_refinement_f (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: 'a -> prop = conj #'a re1.f re2.f
+
+let conj_refinement_f_closed (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
+: Lemma (conj_refinement_f re1 re2 (op p x y))
+= re1.f_closed_under_op x y;
+  re2.f_closed_under_op x y
+
+(* re1.new_one and re2.new_one both work; we go with re2 *)
+let conj_refinement_new_one (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: refine_t (conj_refinement_f re1 re2)
+= re2.new_one
+
+let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
+         op p x (conj_refinement_new_one re1 re2) == x)
+= re2.new_one_is_refined_unit x
+
+let conj_refinement (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: pcm_refinement p = {
+  f = conj_refinement_f re1 re2;
+  f_closed_under_op = conj_refinement_f_closed re1 re2;
+  new_one = conj_refinement_new_one re1 re2;
+  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
+}
+
+noeq type iso a b = {
+  fwd: a -> b;
+  bwd: b -> a;
+  fwd_bwd: x:b -> Lemma (fwd (bwd x) == x);
+  bwd_fwd: x:a -> Lemma (bwd (fwd x) == x);
+}
+let fwd_bwd' (i: iso 'a 'b) (x: 'b): Lemma (i.fwd (i.bwd x) == x) [SMTPat (i.fwd (i.bwd x))] = i.fwd_bwd x
+let bwd_fwd' (i: iso 'a 'b) (x: 'a): Lemma (i.bwd (i.fwd x) == x) [SMTPat (i.bwd (i.fwd x))] = i.bwd_fwd x
+
+let iso_lens_comp_get (i: iso 'a 'b) (l: lens 'b 'c): 'a -> 'c = l.get `compose` i.fwd
+let iso_lens_comp_put (i: iso 'a 'b) (l: lens 'b 'c) (v: 'c) (s: 'a): 'a = i.bwd (l.put v (i.fwd s))
+let iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c = {
+  get = iso_lens_comp_get i l;
+  put = iso_lens_comp_put i l;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
+  i: iso a b;
+  fwd_morphism: pcm_morphism p q i.fwd;
+  bwd_morphism: pcm_morphism q p i.bwd;
+}
+
+let refine_conj_iso_fwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+  (x: refine_t (conj f g))
+: refine_t g
+= x
+
+let refine_conj_iso_bwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+  (x: refine_t g)
+: refine_t (conj f g)
+= x
+
+let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+: iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g) = {
+  fwd = refine_conj_iso_fwd f g;
+  bwd = refine_conj_iso_bwd f g;
+  fwd_bwd = (fun _ -> ());
+  bwd_fwd = (fun _ -> ());
+}
+
+let pcm_refinement_conj_iso_i (p: pcm 'a)
+  (re1: pcm_refinement p)
+  (re2: pcm_refinement (refined_pcm re1))
+: iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
+  refine_conj_iso re1.f re2.f
+
+let pcm_refinement_conj_iso_fwd_morphism_op (p: pcm 'a)
+  (re1: pcm_refinement p)
+  (re2: pcm_refinement (refined_pcm re1))
+: morphism_op
+    (refined_pcm re2) (refined_pcm (conj_refinement re1 re2))
+    (pcm_refinement_conj_iso_i p re1 re2).fwd
+= fun x y -> ()
+
+let pcm_refinement_conj_iso (p: pcm 'a)
+  (re1: pcm_refinement p)
+  (re2: pcm_refinement (refined_pcm re1))
+: pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2) = {
+  i = pcm_refinement_conj_iso_i p re1 re2;
+  fwd_morphism = {
+    f_refine = (fun _ -> ());
+    f_one = (fun _ -> ());
+    f_op = pcm_refinement_conj_iso_fwd_morphism_op p re1 re2;
+  };
+  bwd_morphism = {
+    f_refine = (fun _ -> ());
+    f_one = (fun _ -> ());
+    f_op = (fun _ _ -> ());
+  };
+}
+
+let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (i: pcm_iso p q) (l: pcm_lens q r)
+: pcm_lens p r = {
+  l = iso_lens_comp i.i l.l;
+  get_morphism = pcm_morphism_comp l.get_morphism i.fwd_morphism;
+  put_morphism = {
+    f_refine = (fun (v, s) ->
+      i.fwd_morphism.f_refine s; 
+      l.put_morphism.f_refine (v, i.i.fwd s);
+      i.bwd_morphism.f_refine (l.l.put v (i.i.fwd s)));
+    f_one = (fun () ->
+      i.fwd_morphism.f_one (); 
+      l.put_morphism.f_one ();
+      i.bwd_morphism.f_one ());
+    f_op = (fun (v, s) (w, t) -> 
+     i.fwd_morphism.f_op s t;
+     l.put_morphism.f_op (v, i.i.fwd s) (w, i.i.fwd t);
+     i.bwd_morphism.f_op (l.l.put v (i.i.fwd s)) (l.l.put w (i.i.fwd t)));
+  }
+}
+
+let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) : ref 'a (refine_t new_re.f) = {
+  p = r.p;
+  re = conj_refinement r.re (extend_refinement r.pl new_re);
+  q = refined_pcm new_re;
+  pl =
+    pcm_iso_lens_comp
+      (pcm_refinement_conj_iso r.p r.re (extend_refinement r.pl new_re))
+      (pcm_lens_refine r.pl new_re);
+  r = r.r
+}
+
+assume val refine (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
+: Steel (ref 'a (refine_t re.f))
+    (to_vprop (r `pts_to` x))
+    (fun r' -> to_vprop (r' `pts_to` Ghost.reveal x))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == ref_refine r re)
+
+let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
+  (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
+: A.SteelGhost unit inames
+    (to_vprop (r `pts_to` Ghost.reveal x))
+    (fun _ -> to_vprop (r' `pts_to` x))
+    (fun _ -> r == ref_refine r' re)
+    (fun _ _ _ -> True)
+= A.sladmit()

From a67868a874d55582a8d358224227f06a3900997c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 30 Jun 2021 15:44:48 -0700
Subject: [PATCH 031/513] refine and unrefine

---
 examples/steel/AggregateRef.fst | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index eea53f62746..36d6bbf6636 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -844,12 +844,21 @@ let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) : ref 'a (refine_t ne
   r = r.r
 }
 
-assume val refine (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
+(* Not needed, but nice to confirm *)
+let ref_refine_put_eq (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
+: Lemma (put r.pl x (one (refined_pcm r.re)) ==
+         put (ref_refine r re).pl x (one (refined_pcm (ref_refine r re).re)))
+= ()
+
+let refine (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
 : Steel (ref 'a (refine_t re.f))
     (to_vprop (r `pts_to` x))
     (fun r' -> to_vprop (r' `pts_to` Ghost.reveal x))
     (fun _ -> True)
     (fun _ r' _ -> r' == ref_refine r re)
+= let r' = ref_refine r re in
+  change_equal_vprop (r `pts_to` x) (r' `pts_to` Ghost.hide (Ghost.reveal x));
+  A.return r'
 
 let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
   (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
@@ -858,4 +867,6 @@ let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
     (fun _ -> to_vprop (r' `pts_to` x))
     (fun _ -> r == ref_refine r' re)
     (fun _ _ _ -> True)
-= A.sladmit()
+= change_equal_vprop
+    (r `pts_to` Ghost.reveal x)
+    (r' `pts_to` x)

From 38cc6b08dfe1e1cde9ce81d5adf05996006a9b34 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 30 Jun 2021 16:20:00 -0700
Subject: [PATCH 032/513] Tidy

---
 examples/steel/AggregateRef.fst | 419 ++++++++++++++------------------
 examples/steel/Aggregates.fst   |   8 +-
 ulib/FStar.PCM.fst              |   3 +
 3 files changed, 188 insertions(+), 242 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 36d6bbf6636..af43fed53c5 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -3,8 +3,11 @@ module AggregateRef
 open FStar.PCM
 module P = FStar.PCM
 
-(* TODO move to FStar.PCM.fst, use in earlier code to avoid P.p.one *)
-let one (p: pcm 'a) = p.P.p.one
+(** Misc. combinators *)
+let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
+let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
+let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -49,9 +52,7 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
-(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
-    (1) get is a PCM morphism p -> q
-    (2) put is a PCM morphism q×p -> p, where (×) = Aggregates.tuple_pcm *)
+(** PCM morphisms *)
 
 let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
   x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
@@ -64,7 +65,7 @@ let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
       (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
       [SMTPat (composable p x y)]
 
-noeq type pcm_morphism #a #b (p: pcm a) (q: pcm b) (f: a -> b) = {
+noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
   f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
   f_one: morphism_one p q f;
   f_op: x:a -> y:a ->
@@ -74,42 +75,37 @@ noeq type pcm_morphism #a #b (p: pcm a) (q: pcm b) (f: a -> b) = {
       [SMTPat (composable p x y)]
 }
 
-let pcm_morphism_id (#p: pcm 'a): pcm_morphism p p id = {
+let pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p = {
   f_refine = (fun _ -> ());
   f_one = (fun _ -> ());
   f_op = (fun _ _ -> ());
 }
 
-(* TODO is this in stdlib somewhere? *)
-let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
-
 let pcm_morphism_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#f: 'b -> 'c) (#g: 'a -> 'b)
-  (mf: pcm_morphism q r f) (mg: pcm_morphism p q g)
-: pcm_morphism p r (f `compose` g) = {
+  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
+: pcm_morphism (f `compose` g) p r = {
   f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
   f_one = (fun () -> mg.f_one (); mf.f_one ());
   f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
 }
 
-(* TODO in stdlib? *)
-let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
-
 open Aggregates
 let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: 'a -> 'c) (#g: 'b -> 'd)
-  (mf: pcm_morphism p r f) (mg: pcm_morphism q s g)
-: pcm_morphism (tuple_pcm p q) (tuple_pcm r s) (both f g) = {
+  (mf: pcm_morphism f p r) (mg: pcm_morphism g q s)
+: pcm_morphism (both f g) (p `pcm_times` q) (r `pcm_times` s) = {
   f_refine = (fun (x, y) -> mf.f_refine x; mg.f_refine y);
   f_one = (fun () -> mg.f_one (); mf.f_one ());
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
-(* TODO in stdlib? *)
-let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
+(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
+    (1) get is a PCM morphism p -> q
+    (2) put is a PCM morphism q×p -> p *)
 
 noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   l: lens a b;
-  get_morphism: pcm_morphism p q l.get;
-  put_morphism: pcm_morphism (tuple_pcm q p) p (uncurry l.put);
+  get_morphism: pcm_morphism l.get p q;
+  put_morphism: pcm_morphism (uncurry l.put) (q `pcm_times` p) p;
 }
 let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
 let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
@@ -160,52 +156,28 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
     (requires frame_pres q f (get l s) v)
     (ensures frame_pres p (upd l f) s (put l v s))
     [SMTPat (frame_pres q f (get l s) v)]
-= frame_pres_intro p (lens_upd l.l f) s (l.l.put v s) (fun full ->
-    assert (p.refine full);
-    assert (compatible p s full);
-    assert (lens_upd l.l f full == l.l.put (f (l.l.get full)) full);
+= frame_pres_intro p (upd l f) s (put l v s) (fun full ->
     let _ = l.get_morphism.f_refine in
-    assert (q.refine (l.l.get full));
     pcm_lens_compatible_get l s full;
-    assert (compatible q (l.l.get s) (l.l.get full));
-    assert (q.refine (f (l.l.get full)));
-    l.put_morphism.f_refine (f (l.l.get full), full);
-    assert (q.refine (f (l.l.get full)));
-    assert (p.refine (l.l.put (f (l.l.get full)) full));
-    assert (p.refine (lens_upd l.l f full));
-    assert (compatible q v (f (l.l.get full)));
-    let goal = frame_pres_on p (lens_upd l.l f) s (l.l.put v s) full in
+    l.put_morphism.f_refine (f (get l full), full);
+    let goal = frame_pres_on p (upd l f) s (put l v s) full in
     compatible_elim p s full goal (fun frame_s ->
-    compatible_elim q v (f (l.l.get full)) goal (fun frame_v ->
-    assert (composable q v frame_v /\ op q frame_v v == f (l.l.get full));
-    let frame_vs: 'a = l.l.put frame_v frame_s in
+    compatible_elim q v (f (get l full)) goal (fun frame_v ->
+    let frame_vs: 'a = put l frame_v frame_s in
     l.put_morphism.f_op (v, s) (frame_v, frame_s);
-    assert (composable p (l.l.put v s) frame_vs);
-    p.comm frame_vs (l.l.put v s);
+    p.comm frame_vs (put l v s);
     q.comm v frame_v;
     p.comm s frame_s;
-    assert (op p frame_vs (l.l.put v s) == op p (l.l.put v s) frame_vs);
-    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
-    assert (op p frame_vs (l.l.put v s) == l.l.put (op q v frame_v) (op p s frame_s));
-    assert (op p frame_vs (l.l.put v s) == lens_upd l.l f full);
-    compatible_intro p (l.l.put v s) (lens_upd l.l f full) frame_vs;
+    compatible_intro p (put l v s) (upd l f full) frame_vs;
     let aux (frame:'a{composable p s frame})
-    : Lemma (composable p (l.l.put v s) frame /\
-             (op p s frame == full ==> op p (l.l.put v s) frame == lens_upd l.l f full))
+    : Lemma (composable p (put l v s) frame /\
+             (op p s frame == full ==> op p (put l v s) frame == upd l f full))
     = l.get_morphism.f_op s frame;
-      assert (composable q (l.l.get s) (l.l.get frame));
-      assert (composable q v (l.l.get frame));
-      assert (composable p s frame);
-      l.put_morphism.f_op (v, s) (l.l.get frame, frame);
+      l.put_morphism.f_op (v, s) (get l frame, frame);
       let aux ()
       : Lemma (requires op p s frame == full) 
-              (ensures op p (l.l.put v s) frame == lens_upd l.l f full)
-      = assert (composable p (l.l.put v s) (l.l.put (l.l.get frame) frame));
-        assert (op p (l.l.put v s) frame == op p (l.l.put v s) (l.l.put (l.l.get frame) frame));
-        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) (op p s frame));
-        assert (op p (l.l.put v s) frame == l.l.put (op q v (l.l.get frame)) full);
-        ()
-      in ()
+              (ensures op p (put l v s) frame == upd l f full)
+      = () in ()
     in FStar.Classical.forall_intro aux)))
 
 (** The identity lens is a pcm_lens *)
@@ -279,6 +251,9 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
 
 open FStar.FunctionalExtensionality
 
+(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
+    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
+    This allows the reference to point to substructures of unions with known case. *)
 noeq type ref (a:Type) (b:Type): Type = {
   p: pcm a;
   re: pcm_refinement p;
@@ -301,7 +276,7 @@ let lens_fst #a #b : lens (a & b) a = {
   put_put = (fun _ _ _ -> ());
 }
 
-let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (tuple_pcm p q) p = {
+let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (p `pcm_times` q) p = {
   l = lens_fst;
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
@@ -366,47 +341,12 @@ let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
-(** A PCM for possibly uninitialized data *)
-
-(*
-type init a =
-| Uninitialized : init a
-| Initialized : a -> init a
-
-let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
-  | Uninitialized, Uninitialized -> True
-  | Uninitialized, Initialized x | Initialized x, Uninitialized -> x == one p
-  | Initialized x, Initialized y -> composable p x y
-
-let init_op (p: pcm 'a) (one_dec:(x:'a -> b:bool{b <==> x == one p})) (x: init 'a)
-  (y: init 'a{init_comp p x y})
-: init 'a
-= match x, y with
-  | Uninitialized, Uninitialized -> Uninitialized
-  | Uninitialized, Initialized x | Initialized x, Uninitialized ->
-    let true = one_dec x in Uninitialized
-  | Initialized x, Initialized y -> Initialized (op p x y)
-
-let init_pcm (p: pcm 'a) (one_dec:(x:'a -> b:bool{b <==> x == one p})): pcm (init 'a) = P.({
-  p = {composable = init_comp p; op = init_op p one_dec; one = Initialized (one p)};
-  comm = (fun x y -> match x, y with
-    | Initialized x, Initialized y -> p.comm x y
-    | _, _ -> ());
-  assoc = (fun x y z -> match x, y, z with
-    | Initialized x, Initialized y, Initialized z -> p.assoc x y z
-    | _, _, _ -> ());
-  assoc_r = (fun x y z -> match x, y, z with
-    | Initialized x, Initialized y, Initialized z -> p.assoc_r x y z
-    | _, _, _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with
-    | Initialized x -> p.refine x
-    | _ -> True)
-})
-*)
-
 (** A lens for the k-th field of an n-ary product *)
 
+let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
+  (f: restricted_t a f_ty)
+: restricted_t a f_ty
+= on_domain a (fun k' -> if k = k' then x' else f k')
 let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
 let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
   get = lens_field_get f k;
@@ -481,115 +421,25 @@ let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
 
-(* Basic operations *)
-
-open Steel.Effect
-module M = Steel.Memory
-module A = Steel.Effect.Atomic
-
-let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
-  {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
-
-let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ref 'a 'c)
-    (to_vprop (r `pts_to` s))
-    (fun r' -> to_vprop (r' `pts_to` x))
-    (fun _ -> Ghost.reveal s == put l x (one r.q))
-    (fun _ r' _ -> r' == ref_focus r q l)
-= let r' = ref_focus r q l in
-  A.change_slprop_rel  
-    (to_vprop (r `pts_to` s))
-    (to_vprop (r' `pts_to` x))
-    (fun _ _ -> True)
-    (fun m -> r.pl.get_morphism.f_one ());
-  A.return r'
-
-let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
-  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
-: A.SteelGhost unit inames
-    (to_vprop (r `pts_to` x))
-    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == ref_focus r' q l)
-    (fun _ _ _ -> True)
-= A.change_slprop_rel  
-    (to_vprop (r `pts_to` x))
-    (to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ _ -> True)
-    (fun m -> r'.pl.get_morphism.f_one ())
+(** Refining a lens *)
 
-let change_equal_vprop #inames (p q: M.slprop)
-: A.SteelGhost unit inames (to_vprop p) (fun _ -> to_vprop q) (fun _ -> p == q) (fun _ _ _ -> True)
-= A.change_equal_slprop (to_vprop p) (to_vprop q)
-// TODO rename
-
-let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
-: Steel unit
-    (to_vprop (r `pts_to` xy))
-    (fun _ -> to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
-    (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
-    (fun _ _ _ -> True)
-= A.change_equal_slprop
-    (to_vprop (r `pts_to` xy))
-    (to_vprop (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re))))));
-  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
-  r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re))
-    (Ghost.reveal y, one (refined_pcm r.re));
-  Steel.PCMReference.split r.r
-    (put r.pl xy (one (refined_pcm r.re)))
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  change_equal_vprop
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
-    (r `pts_to` x);
-  change_equal_vprop
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
-    (r `pts_to` y)
-
-let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
-: SteelT (_:unit{composable r.q x y})
-    (to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
-    (fun _ -> to_vprop (r `pts_to` op r.q x y))
-= change_equal_vprop
-    (r `pts_to` x)
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
-  change_equal_vprop
-    (r `pts_to` y)
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
-  Steel.PCMReference.gather r.r
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  r.pl.get_morphism.f_op
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
-  r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re))
-    (Ghost.reveal y, one (refined_pcm r.re));
-  change_equal_vprop _ (r `pts_to` op r.q x y)
-
-let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
-: SteelT unit
-    (to_vprop (r `pts_to` x))
-    (fun _ ->
-      to_vprop (r `pts_to` put l (one q) x) `star` 
-      to_vprop (r `pts_to` put l (get l x) (one r.q)))
-= q.is_unit (get l x);
-  r.q.is_unit x;
-  q.comm (get l x) (one q);
-  l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
-  split r x (put l (one q) x) (put l (get l x) (one r.q))
+let lens_refine_get (l: lens 'a 'b) f
+  (s: refine_t (f `compose` l.get)): refine_t f
+= l.get s
+let lens_refine_put (l: lens 'a 'b) f
+  (v: refine_t f) (s: refine_t (f `compose` l.get)): refine_t (f `compose` l.get)
+= l.put v s
 
-let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
-: SteelT (ref 'a 'c)
-    (to_vprop (r `pts_to` x))
-    (fun s ->
-      to_vprop (r `pts_to` put l (one q) x) `star` 
-      to_vprop (s `pts_to` get l x))
-= peel r q l x;
-  focus r q l (put l (get l x) (one r.q)) (get l x)
+let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
+: lens (refine_t (f `compose` l.get)) (refine_t f) = {
+  get = lens_refine_get l f;
+  put = lens_refine_put l f;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
 
-(** Refining a pcm_ref  *)
+(** Refining a pcm_lens *)
 
 let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
@@ -621,22 +471,6 @@ let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refineme
   new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
 }
 
-let lens_refine_get (l: lens 'a 'b) f
-  (s: refine_t (f `compose` l.get)): refine_t f
-= l.get s
-let lens_refine_put (l: lens 'a 'b) f
-  (v: refine_t f) (s: refine_t (f `compose` l.get)): refine_t (f `compose` l.get)
-= l.put v s
-
-let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
-: lens (refine_t (f `compose` l.get)) (refine_t f) = {
-  get = lens_refine_get l f;
-  put = lens_refine_put l f;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
 let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_refine
@@ -664,7 +498,7 @@ let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
 let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_refine
-    (tuple_pcm (refined_pcm re) (refined_pcm (extend_refinement l re)))
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
     (refined_pcm (extend_refinement l re))
     (uncurry (lens_refine l.l re.f).put)
 = fun (v, s) -> l.put_morphism.f_refine (v, s)
@@ -672,7 +506,7 @@ let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
 let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_one
-    (tuple_pcm (refined_pcm re) (refined_pcm (extend_refinement l re)))
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
     (refined_pcm (extend_refinement l re))
     (uncurry (lens_refine l.l re.f).put)
 = l.put_morphism.f_one
@@ -680,7 +514,7 @@ let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
 let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_op
-    (tuple_pcm (refined_pcm re) (refined_pcm (extend_refinement l re)))
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
     (refined_pcm (extend_refinement l re))
     (uncurry (lens_refine l.l re.f).put)
 = fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
@@ -701,8 +535,7 @@ let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
   };
 }
 
-(* TODO is this in stdlib somewhere? *)
-let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
+(** The conjunction of two refinements *)
 
 let conj_refinement_f (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
@@ -738,6 +571,8 @@ let conj_refinement (#p: pcm 'a)
   new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
 }
 
+(** Isomorphisms *)
+
 noeq type iso a b = {
   fwd: a -> b;
   bwd: b -> a;
@@ -757,11 +592,7 @@ let iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
-noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
-  i: iso a b;
-  fwd_morphism: pcm_morphism p q i.fwd;
-  bwd_morphism: pcm_morphism q p i.bwd;
-}
+(** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
 
 let refine_conj_iso_fwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
   (x: refine_t (conj f g))
@@ -781,6 +612,14 @@ let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
   bwd_fwd = (fun _ -> ());
 }
 
+(** PCM isomorphisms *)
+
+noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
+  i: iso a b;
+  fwd_morphism: pcm_morphism i.fwd p q;
+  bwd_morphism: pcm_morphism i.bwd q p;
+}
+
 let pcm_refinement_conj_iso_i (p: pcm 'a)
   (re1: pcm_refinement p)
   (re2: pcm_refinement (refined_pcm re1))
@@ -795,6 +634,8 @@ let pcm_refinement_conj_iso_fwd_morphism_op (p: pcm 'a)
     (pcm_refinement_conj_iso_i p re1 re2).fwd
 = fun x y -> ()
 
+(** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
+    refinement by the conjunction of re1 and re2 *)
 let pcm_refinement_conj_iso (p: pcm 'a)
   (re1: pcm_refinement p)
   (re2: pcm_refinement (refined_pcm re1))
@@ -833,6 +674,8 @@ let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   }
 }
 
+(** The refinement of a ref *)
+
 let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) : ref 'a (refine_t new_re.f) = {
   p = r.p;
   re = conj_refinement r.re (extend_refinement r.pl new_re);
@@ -844,11 +687,113 @@ let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) : ref 'a (refine_t ne
   r = r.r
 }
 
-(* Not needed, but nice to confirm *)
-let ref_refine_put_eq (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
-: Lemma (put r.pl x (one (refined_pcm r.re)) ==
-         put (ref_refine r re).pl x (one (refined_pcm (ref_refine r re).re)))
-= ()
+(** Fundamental operations on references *)
+
+open Steel.Effect
+module M = Steel.Memory
+module A = Steel.Effect.Atomic
+
+let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
+  {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
+
+let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ref 'a 'c)
+    (to_vprop (r `pts_to` s))
+    (fun r' -> to_vprop (r' `pts_to` x))
+    (fun _ -> Ghost.reveal s == put l x (one r.q))
+    (fun _ r' _ -> r' == ref_focus r q l)
+= let r' = ref_focus r q l in
+  A.change_slprop_rel  
+    (to_vprop (r `pts_to` s))
+    (to_vprop (r' `pts_to` x))
+    (fun _ _ -> True)
+    (fun m -> r.pl.get_morphism.f_one ());
+  A.return r'
+
+let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
+  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
+: A.SteelGhost unit inames
+    (to_vprop (r `pts_to` x))
+    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ -> r == ref_focus r' q l)
+    (fun _ _ _ -> True)
+= A.change_slprop_rel  
+    (to_vprop (r `pts_to` x))
+    (to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ _ -> True)
+    (fun m -> r'.pl.get_morphism.f_one ())
+
+let change_equal_vprop #inames (p q: M.slprop)
+: A.SteelGhost unit inames (to_vprop p) (fun _ -> to_vprop q) (fun _ -> p == q) (fun _ _ _ -> True)
+= A.change_equal_slprop (to_vprop p) (to_vprop q)
+// TODO rename
+
+let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
+: Steel unit
+    (to_vprop (r `pts_to` xy))
+    (fun _ -> to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
+    (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
+    (fun _ _ _ -> True)
+= A.change_equal_slprop
+    (to_vprop (r `pts_to` xy))
+    (to_vprop (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re))))));
+  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
+  r.pl.put_morphism.f_op
+    (Ghost.reveal x, one (refined_pcm r.re))
+    (Ghost.reveal y, one (refined_pcm r.re));
+  Steel.PCMReference.split r.r
+    (put r.pl xy (one (refined_pcm r.re)))
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  change_equal_vprop
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
+    (r `pts_to` x);
+  change_equal_vprop
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
+    (r `pts_to` y)
+
+let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
+: SteelT (_:unit{composable r.q x y})
+    (to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
+    (fun _ -> to_vprop (r `pts_to` op r.q x y))
+= change_equal_vprop
+    (r `pts_to` x)
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
+  change_equal_vprop
+    (r `pts_to` y)
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
+  Steel.PCMReference.gather r.r
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  r.pl.get_morphism.f_op
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
+  r.pl.put_morphism.f_op
+    (Ghost.reveal x, one (refined_pcm r.re))
+    (Ghost.reveal y, one (refined_pcm r.re));
+  change_equal_vprop _ (r `pts_to` op r.q x y)
+
+let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+: SteelT unit
+    (to_vprop (r `pts_to` x))
+    (fun _ ->
+      to_vprop (r `pts_to` put l (one q) x) `star` 
+      to_vprop (r `pts_to` put l (get l x) (one r.q)))
+= q.is_unit (get l x);
+  r.q.is_unit x;
+  q.comm (get l x) (one q);
+  l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
+  split r x (put l (one q) x) (put l (get l x) (one r.q))
+
+let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+: SteelT (ref 'a 'c)
+    (to_vprop (r `pts_to` x))
+    (fun s ->
+      to_vprop (r `pts_to` put l (one q) x) `star` 
+      to_vprop (s `pts_to` get l x))
+= peel r q l x;
+  focus r q l (put l (get l x) (one r.q)) (get l x)
 
 let refine (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
 : Steel (ref 'a (refine_t re.f))
@@ -857,7 +802,7 @@ let refine (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
     (fun _ -> True)
     (fun _ r' _ -> r' == ref_refine r re)
 = let r' = ref_refine r re in
-  change_equal_vprop (r `pts_to` x) (r' `pts_to` Ghost.hide (Ghost.reveal x));
+  change_equal_vprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
 let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
@@ -867,6 +812,4 @@ let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
     (fun _ -> to_vprop (r' `pts_to` x))
     (fun _ -> r == ref_refine r' re)
     (fun _ _ _ -> True)
-= change_equal_vprop
-    (r `pts_to` Ghost.reveal x)
-    (r' `pts_to` x)
+= change_equal_vprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
diff --git a/examples/steel/Aggregates.fst b/examples/steel/Aggregates.fst
index 360b8b602c8..50857d2a2bb 100644
--- a/examples/steel/Aggregates.fst
+++ b/examples/steel/Aggregates.fst
@@ -6,14 +6,14 @@ open FStar.PCM
 /// a PCM for tuples (a & b) in terms of (potentially user-defined)
 /// PCMs for a and b.
 
-let tuple_comp (p: pcm 'a) (q: pcm 'b) (x y: 'a & 'b) : prop =
+let pcm_times_comp (p: pcm 'a) (q: pcm 'b) (x y: 'a & 'b) : prop =
   composable p (fst x) (fst y) /\ composable q (snd x) (snd y)
 
-let tuple_op (p: pcm 'a) (q: pcm 'b) (x: 'a & 'b) (y: ('a & 'b){tuple_comp p q x y}) : 'a & 'b =
+let pcm_times_op (p: pcm 'a) (q: pcm 'b) (x: 'a & 'b) (y: ('a & 'b){pcm_times_comp p q x y}) : 'a & 'b =
   (op p (fst x) (fst y), op q (snd x) (snd y))
 
-let tuple_pcm (p: pcm 'a) (q: pcm 'b): pcm ('a & 'b) = {
-  p = {composable = tuple_comp p q; op = tuple_op p q; one = (p.p.one, q.p.one)};
+let pcm_times (p: pcm 'a) (q: pcm 'b): pcm ('a & 'b) = {
+  p = {composable = pcm_times_comp p q; op = pcm_times_op p q; one = (p.p.one, q.p.one)};
   comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
   assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
   assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
diff --git a/ulib/FStar.PCM.fst b/ulib/FStar.PCM.fst
index 15024c21f25..2d1fc41556e 100644
--- a/ulib/FStar.PCM.fst
+++ b/ulib/FStar.PCM.fst
@@ -81,6 +81,9 @@ type pcm (a:Type u#a) = {
 (** Returns the composable predicate of the PCM *)
 let composable (#a: Type u#a) (p:pcm a) (x y:a) = p.p.composable x y
 
+(** Returns the unit of the PCM *)
+let one (p: pcm 'a) = p.p.one
+
 (** Calls the operation of the PCM *)
 let op (#a: Type u#a) (p:pcm a) (x:a) (y:a{composable p x y}) = p.p.op x y
 

From 809dbaf71869968ab4299fd5ae557cbbd5234088 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 09:33:23 -0700
Subject: [PATCH 033/513] Try to make ref_upd

---
 examples/steel/AggregateRef.fst | 332 ++++++++++++++++++++++++--------
 1 file changed, 254 insertions(+), 78 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index af43fed53c5..59f1741c7bf 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -9,48 +9,7 @@ let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
 let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
 let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
 
-(** Very well-behaved lenses *)
-noeq type lens (a: Type u#a) (b: Type u#b) = {
-  get: a -> b;
-  put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
-  put_get: s: a -> Lemma (put (get s) s == s);
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
-}
-let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
-  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
-  = l.get_put s v
-let put_get' (l: lens 'a 'b) (s: 'a)
-  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
-  = l.put_get s
-let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
-  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
-  = l.put_put s v w
-
-(** Updating the target of a lens *)
-let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
-
-(** The identity lens *)
-let const (x: 'a) (b: 'b): 'a = x
-let lens_id #a : lens a a = {
-  get = id;
-  put = const;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** Lens composition *)
-let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
-let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
-  lens_upd l (m.put v) s
-let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
-  get = get_comp l m;
-  put = put_comp l m;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
+(** TODO move PCM morphisms and refinements to FStar.PCM.fst? *)
 
 (** PCM morphisms *)
 
@@ -98,6 +57,84 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f *)
+let refine_t (f: 'a -> prop) = x:'a{f x}
+noeq type pcm_refinement #a (p: pcm a) = {
+  f: a -> prop;
+  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
+  new_one: refine_t f;
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+}
+
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+
+let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_under_op x y; op p x y
+
+(** Any refinement r for p can be used to construct a refined PCM with the same product
+    and composability predicate, but restricted to elements in r.f *)
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  refine = p.refine;
+}
+
+let trivial_refinement (p: pcm 'a): pcm_refinement p = {
+  f = (fun x -> True);
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = one p;
+  new_one_is_refined_unit = p.is_unit;
+}
+
+(** Very well-behaved lenses *)
+noeq type lens (a: Type u#a) (b: Type u#b) = {
+  get: a -> b;
+  put: b -> a -> a;
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
+  put_get: s: a -> Lemma (put (get s) s == s);
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+}
+let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
+  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
+  = l.get_put s v
+let put_get' (l: lens 'a 'b) (s: 'a)
+  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
+  = l.put_get s
+let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
+  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
+  = l.put_put s v w
+
+(** Updating the target of a lens *)
+let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+
+(** The identity lens *)
+let const (x: 'a) (b: 'b): 'a = x
+let lens_id #a : lens a a = {
+  get = id;
+  put = const;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+(** Lens composition *)
+let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
+let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
+  lens_upd l (m.put v) s
+let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
+  get = get_comp l m;
+  put = put_comp l m;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
     (1) get is a PCM morphism p -> q
     (2) put is a PCM morphism q×p -> p *)
@@ -214,41 +251,6 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   };
 }
 
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f *)
-let refine_t (f: 'a -> prop) = x:'a{f x}
-noeq type pcm_refinement #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
-  new_one: refine_t f;
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
-}
-
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
-
-let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_under_op x y; op p x y
-
-(** Any refinement r for p can be used to construct a refined PCM with the same product
-    and composability predicate, but restricted to elements in r.f *)
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
-  refine = p.refine;
-}
-
-let trivial_refinement (p: pcm 'a): pcm_refinement p = {
-  f = (fun x -> True);
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = one p;
-  new_one_is_refined_unit = p.is_unit;
-}
-
 open FStar.FunctionalExtensionality
 
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
@@ -463,7 +465,7 @@ let extend_refinement_new_one_is_refined_unit
 = re.new_one_is_refined_unit (get l x);
   p.is_unit x;
   l.put_morphism.f_op (get l x, x) (re.new_one, one p)
-
+  
 let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
   f = extend_refinement_f l re;
   f_closed_under_op = extend_refinement_f_closed l re;
@@ -813,3 +815,177 @@ let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
     (fun _ -> r == ref_refine r' re)
     (fun _ _ _ -> True)
 = change_equal_vprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
+
+(** Example: a model for a tagged union representing colors in RGB or HSV
+      type color =
+        | RGB : r:int -> g:int -> b:int -> color
+        | HSV : h:int -> s:int -> v:int -> color *)
+
+type rgb_field = | R | G | B
+type hsv_field = | H | S | V
+type color_tag = | RGB | HSV
+
+(* Carrier of all-or-none PCM for integers *)
+let int_pcm_t = option int
+
+(* Type families for fields of RGB and HSV structs *)
+let rgb_fields k = match k with
+  | R -> int_pcm_t
+  | G -> int_pcm_t
+  | B -> int_pcm_t
+let hsv_fields k = match k with
+  | H -> int_pcm_t
+  | S -> int_pcm_t
+  | V -> int_pcm_t
+  
+(** Carriers of PCMs for RGB and HSV structs *)
+let rgb_t = restricted_t rgb_field rgb_fields
+let hsv_t = restricted_t hsv_field hsv_fields
+
+(** Type family for union of RGB and HSV *)
+let color_cases t = match t with
+  | RGB -> rgb_t
+  | HSV -> hsv_t
+
+(** Carrier of PCM for color *)
+let color_t = union color_cases
+
+(** All-or-none PCM for integers *)
+let int_pcm : pcm int_pcm_t = opt_pcm
+
+(** PCMs for RGB and HSV structs *)
+let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
+  prod_pcm #_ #rgb_fields (fun k -> match k with
+    | R -> int_pcm
+    | G -> int_pcm
+    | B -> int_pcm)
+let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
+  prod_pcm #_ #hsv_fields (fun k -> match k with
+    | H -> int_pcm
+    | S -> int_pcm
+    | V -> int_pcm)
+
+(** PCM for color *)
+let color_pcm_cases k : pcm (color_cases k) = match k with
+  | RGB -> rgb_pcm
+  | HSV -> hsv_pcm
+let color_pcm : pcm color_t = union_pcm color_pcm_cases
+
+(*
+
+let decidable (p: 'a -> prop) = x:'a -> b:bool{b <==> p x}
+
+let unrefine_upd
+  (#p: pcm 'a) (#re: pcm_refinement p) (dec_re: decidable re.f)
+  (f: refine_t re.f -> refine_t re.f) (x: 'a): 'a
+= if dec_re x then f x else one p
+
+let re_respects_compatible (#p: pcm 'a) (re: pcm_refinement p) x =
+  v:'a ->
+    Lemma
+      (requires compatible p x v) 
+      (ensures re.f v /\ compatible (refined_pcm re) x v)
+      [SMTPat (compatible p x v)]
+      
+let unrefine_upd_frame_pres
+  (#p: pcm 'a) (re: pcm_refinement p) (dec_re: decidable re.f)
+  (x y: Ghost.erased (refine_t re.f))
+  (f: (refine_t re.f -> refine_t re.f){frame_pres (refined_pcm re) f x y})
+  (hre: re_respects_compatible re x)
+: Lemma (frame_pres p (unrefine_upd dec_re f) (Ghost.reveal x) (Ghost.reveal y))
+= frame_pres_intro p (unrefine_upd dec_re f) (Ghost.reveal x) (Ghost.reveal y)
+    (fun v -> 
+      hre v; 
+      assert (re.f v);
+      let v': refine_t re.f = v in
+      assert (compatible (refined_pcm re) x v');
+      assert (p.refine (f v)); assert (compatible p y (f v));
+      let aux (frame:'a{composable p x frame})
+      : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == f v))
+      = admit()
+      in FStar.Classical.forall_intro aux)
+
+(* If f is a frame-preserving update on a refined PCM where
+   (1) the refinement respects compatibility,
+   (2) the refinement is decidable,
+   then f is a frame-preserving update on the unrefined PCM *)
+let frame_pres_drop_refinement (#p: pcm 'a)
+  (re: pcm_refinement p)
+  (x y: Ghost.erased (refine_t re.f))
+  (f: (refine_t re.f -> refine_t re.f){frame_pres (refined_pcm re) f x y})
+  (re_respects_compatible:(v:'a ->
+    Lemma
+      (requires compatible p x v) 
+      (ensures re.f v) [SMTPat (compatible p x v)]))
+: Lemma (frame_pres p f x y)
+= admit()
+*)
+
+(*
+(* TODO is this safe to add? *)
+assume val upd_gen' (#a:Type) (#p:pcm a) (e:inames) (r:ref a p)
+            (x y: Ghost.erased (refine_t f))
+            (f:FStar.PCM.frame_preserving_upd (refined_pcm re) x y)
+  : action_except unit e
+                  (pts_to r x)
+                  (fun _ -> pts_to r y)
+
+f (get x)
+x composable y
+(get x) composable (get y)
+
+f x
+f (op x y)
+-----------------
+f y
+
+==> f 1
+
+*)
+
+// frame_pres q f (get l s) v
+// 
+// (pts_to r s)
+// (pts_to r (put l v s))
+//     (requires frame_pres q f (get l s) v)
+//     (ensures frame_pres p (upd l f) s (put l v s))
+
+let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+: frame_preserving_upd (refined_pcm r.re)
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)))
+= pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f;
+  frame_pres_mk_upd (refined_pcm r.re)
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)))
+    (upd r.pl f)
+
+(*
+let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+: M.action_except unit Set.empty (r `pts_to` x) (fun _ -> r `pts_to` y)
+= let f': refine_t r.re.f -> refine_t r.re.f = upd r.pl f in
+  let hf'
+  : squash (frame_pres (refined_pcm r.re) f'
+      (put r.pl x (one (refined_pcm r.re)))
+      (put r.pl y (one (refined_pcm r.re))))
+  = pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f in
+  M.upd_gen Set.empty r.r x y (frame_pres_mk_upd (refined_pcm r.re)
+      (put r.pl x (one (refined_pcm r.re)))
+      (put r.pl y (one (refined_pcm r.re)))
+  f' hf')
+
+let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+: SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
+= let f': 'a -> 'a = upd r.pl f in
+  let hf'
+  : frame_pres r.p f'
+      (put x (one (refined_pcm r.re)))
+      (put y (one (refined_pcm r.re)))
+  = pcm_lens_frame_pres r.p r.q r.pl (put x (one (refined_pcm r.re))) y f' in
+  let act : M.action_except unit Set.empty _ _ = M.upd_gen Set.empty r.r x y (frame_pres_mk_upd r.p
+      (put x (one (refined_pcm r.re)))
+      (put y (one (refined_pcm r.re)))
+  f' hf') in
+  as_action act
+  *)
+

From 22e748a7320ae291817d35c2684f809659605965 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 11:30:24 -0700
Subject: [PATCH 034/513] Try define pcm_refinement in terms of new_unit

---
 examples/steel/AggregateRef.fst | 98 ++++++++++++++++++++++++++-------
 1 file changed, 78 insertions(+), 20 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 59f1741c7bf..c4b98d76e82 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -57,40 +57,61 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f *)
+(** A refinement of a PCM (p: pcm a) consists of an element new_unit such that:
+    (1) new_one is a unit for every element compatible with it
+    (2) Composability with new_unit is closed under (op p) *)
+
 let refine_t (f: 'a -> prop) = x:'a{f x}
+
 noeq type pcm_refinement #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
-  new_one: refine_t f;
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+  new_one: a;
+  new_one_is_unit: x:a{compatible p new_one x} ->
+    Lemma (composable p x new_one /\ op p x new_one == x);
+  new_one_comp_closed:
+    x:a{compatible p new_one x} ->
+    y:a{compatible p new_one y /\ composable p x y} ->
+    Lemma (composable p y new_one /\ composable p (op p x y) new_one)
 }
 
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+let pcm_refine_t (#p: pcm 'a) (re: pcm_refinement p) = x:'a{composable p x re.new_one}
+
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (pcm_refine_t r) = composable p
 
+(*
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_under_op x y; op p x y
+  (x: pcm_refine_t r) (y: pcm_refine_t r{composable p x y}): pcm_refine_t r
+= r.new_one_comp_closed x y; op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (pcm_refine_t r) = {
   p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
   assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  is_unit = (fun x -> r.new_one_is_unit x);
   refine = p.refine;
 }
 
+type pcm_refinement_ok p (re: pcm_refinement p) =
+  forall (x y: refine_t re.f).
+  frame_pres f x y ->
+  frame_pres (unrefine f) x y
+
+p: pcm a
+re1: refinement p
+_: pcm_refinement_ok p re1
+re2: refinement (refined_pcm re1)
+_: pcm_refinement_ok (refined_pcm re1) re2
+--------------------------------------------------
+_: pcm_refinement_ok p (conj_refinement re1 re2)
+
 let trivial_refinement (p: pcm 'a): pcm_refinement p = {
-  f = (fun x -> True);
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = one p;
-  new_one_is_refined_unit = p.is_unit;
+  new_one = (p.is_unit (one p); one p);
+  new_one_is_unit = (fun x -> p.is_unit x);
+  new_one_comp_closed = (fun x y -> p.is_unit y; p.is_unit (op p x y));
 }
+*)
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -259,6 +280,7 @@ open FStar.FunctionalExtensionality
 noeq type ref (a:Type) (b:Type): Type = {
   p: pcm a;
   re: pcm_refinement p;
+  hre: pcm_refinement_ok p re;
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
   r: Steel.Memory.ref a p;
@@ -336,11 +358,43 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
     | Some (Inr x) -> q.refine x);
 })
 
+// put new_one one <= x
+// x composable y
+// ----------------------
+// put new_one one <= y
+// 
+// put new_one one <= x
+// x composable y
+// put new_one one * put frame_v frame_s = put (get x) x
+// new_one * frame_v = get x
+// (get x) composable (get y)
+// new_one <= get y
+// one <= y
+// put new_one one <= put (get y) y = y
+// ----------------------
+// put new_one one <= y
+
+//  new_one: x:a{composable p x x};
+//  new_one_is_unit: x:a{composable p x new_one} -> Lemma (op p x new_one == x);
+//  new_one_comp_closed:
+//    x:a{composable p x new_one} -> 
+//    y:a{composable p x new_one /\ composable p x y} ->
+//    Lemma (composable p (op p x y) new_one)
 let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
-  f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = Some (Inl #_ #'b (one p));
-  new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
+  //f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
+  //f_closed_under_op = (fun _ _ -> ());
+  //new_one = Some (Inl #_ #'b (one p));
+  //new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
+  new_one = (p.is_unit (one p); Some (Inl (one p)));
+  new_one_is_unit = (fun x -> match x with
+    | Some (Inl x) -> p.is_unit x
+    | None -> admit());
+  new_one_comp_closed = (fun _ _ -> admit());
+  //new_one_is_unit: x:'a{composable p x new_one} -> Lemma (op p x new_one == x);
+  //new_one_comp_closed:
+  //  x:a{composable p x new_one} -> 
+  //  y:a{composable p x y} ->
+  //  Lemma (composable p y new_one /\ composable p (op p x y) new_one)
 }
 
 (** A lens for the k-th field of an n-ary product *)
@@ -393,12 +447,14 @@ let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 : refine_t (case_refinement_f p k)
 = Some (|k, one (p k)|)
 
+(* TODO
 let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) = {
   f = case_refinement_f p k;
   f_closed_under_op = (fun x y -> ());
   new_one = case_refinement_new_one p k;
   new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
 }
+*)
 
 (** A lens for the k-th case of an n-ary union *)
 
@@ -416,12 +472,14 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
   put_put = (fun s v w -> ());
 }
 
+(* TODO
 (** lens_case is a pcm_lens *)
 let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
   l = lens_case p k;
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
+*)
 
 (** Refining a lens *)
 

From 5510aa45a1516dc0931f98809feaf976023d7321 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 12:36:46 -0700
Subject: [PATCH 035/513] case_refinement_ok

---
 examples/steel/AggregateRef.fst | 240 +++++++++++++++++---------------
 1 file changed, 130 insertions(+), 110 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index c4b98d76e82..1de644dba61 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -8,6 +8,37 @@ let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
 let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
 let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
 let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
+    
+(** The non-computational part of frame_preserving_upd
+    TODO: move this and lemmas about this to FStar.PCM.fst *)
+let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (v:'a{p.refine v /\ compatible p x v})
+= p.refine (f v) /\
+  compatible p y (f v) /\
+  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
+     composable p y frame /\
+     (op p x frame == v ==> op p y frame == f v))
+let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
+  frame_pres_on p f x y v
+
+(** Every function satisfying frame_pres is a frame_preserving_upd *)
+let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
+  (f:('a -> 'a){frame_pres p f x y})
+  : frame_preserving_upd p x y
+  = fun v -> f v
+(** The converse is not true, because a frame_preserving_upd's domain
+    is restricted to v:a{p.refine v /\ compatible p x v}. *)
+
+let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (g:(v:'a{p.refine v /\ compatible p x v} -> 
+     Lemma (p.refine (f v) /\ compatible p y (f v) /\
+            (forall (frame:'a{composable p x frame}).
+              composable p y frame /\
+              (op p x frame == v ==> op p y frame == f v)))
+     [SMTPat (compatible p x v)]))
+: Lemma (frame_pres p f x y) =
+  let _ = g in ()
 
 (** TODO move PCM morphisms and refinements to FStar.PCM.fst? *)
 
@@ -57,61 +88,54 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
-(** A refinement of a PCM (p: pcm a) consists of an element new_unit such that:
-    (1) new_one is a unit for every element compatible with it
-    (2) Composability with new_unit is closed under (op p) *)
-
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
-
 noeq type pcm_refinement #a (p: pcm a) = {
-  new_one: a;
-  new_one_is_unit: x:a{compatible p new_one x} ->
-    Lemma (composable p x new_one /\ op p x new_one == x);
-  new_one_comp_closed:
-    x:a{compatible p new_one x} ->
-    y:a{compatible p new_one y /\ composable p x y} ->
-    Lemma (composable p y new_one /\ composable p (op p x y) new_one)
+  f: a -> prop;
+  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
+  new_one: refine_t f;
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
 
-let pcm_refine_t (#p: pcm 'a) (re: pcm_refinement p) = x:'a{composable p x re.new_one}
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
 
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (pcm_refine_t r) = composable p
-
-(*
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
-  (x: pcm_refine_t r) (y: pcm_refine_t r{composable p x y}): pcm_refine_t r
-= r.new_one_comp_closed x y; op p x y
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_under_op x y; op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (pcm_refine_t r) = {
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
   p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
   assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_unit x);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
   refine = p.refine;
 }
 
-type pcm_refinement_ok p (re: pcm_refinement p) =
-  forall (x y: refine_t re.f).
-  frame_pres f x y ->
-  frame_pres (unrefine f) x y
-
-p: pcm a
-re1: refinement p
-_: pcm_refinement_ok p re1
-re2: refinement (refined_pcm re1)
-_: pcm_refinement_ok (refined_pcm re1) re2
---------------------------------------------------
-_: pcm_refinement_ok p (conj_refinement re1 re2)
-
 let trivial_refinement (p: pcm 'a): pcm_refinement p = {
-  new_one = (p.is_unit (one p); one p);
-  new_one_is_unit = (fun x -> p.is_unit x);
-  new_one_comp_closed = (fun x y -> p.is_unit y; p.is_unit (op p x y));
+  f = (fun x -> True);
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = one p;
+  new_one_is_refined_unit = p.is_unit;
+}
+
+(** A PCM refinement is well-formed if frame-preserving updates on the
+    refined PCM can be lifted to frame-preserving updates on the
+    unrefined PCM *)
+noeq type pcm_refinement_ok #a (#p: pcm a) (r: pcm_refinement p) = {
+  unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
+  frame_pres_unrefine:
+    f:(refine_t r.f -> refine_t r.f) ->
+    x:Ghost.erased (refine_t r.f) ->
+    y:Ghost.erased (refine_t r.f) ->
+    Lemma
+      (requires frame_pres (refined_pcm r) f x y)
+      (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
 }
-*)
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -178,37 +202,6 @@ let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a
   let _ = l.get_morphism.f_op frame_x x in
   compatible_intro q (get l x) (get l y) (get l frame_x))
     
-(** The non-computational part of frame_preserving_upd
-    TODO: move this and lemmas about this to FStar.PCM.fst *)
-let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (v:'a{p.refine v /\ compatible p x v})
-= p.refine (f v) /\
-  compatible p y (f v) /\
-  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
-     composable p y frame /\
-     (op p x frame == v ==> op p y frame == f v))
-let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
-  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
-  frame_pres_on p f x y v
-
-(** Every function satisfying frame_pres is a frame_preserving_upd *)
-let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
-  (f:('a -> 'a){frame_pres p f x y})
-  : frame_preserving_upd p x y
-  = fun v -> f v
-(** The converse is not true, because a frame_preserving_upd's domain
-    is restricted to v:a{p.refine v /\ compatible p x v}. *)
-
-let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (g:(v:'a{p.refine v /\ compatible p x v} -> 
-     Lemma (p.refine (f v) /\ compatible p y (f v) /\
-            (forall (frame:'a{composable p x frame}).
-              composable p y frame /\
-              (op p x frame == v ==> op p y frame == f v)))
-     [SMTPat (compatible p x v)]))
-: Lemma (frame_pres p f x y) =
-  let _ = g in ()
-    
 let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
 : Lemma
     (requires frame_pres q f (get l s) v)
@@ -280,7 +273,7 @@ open FStar.FunctionalExtensionality
 noeq type ref (a:Type) (b:Type): Type = {
   p: pcm a;
   re: pcm_refinement p;
-  hre: pcm_refinement_ok p re;
+  hre: pcm_refinement_ok re;
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
   r: Steel.Memory.ref a p;
@@ -358,43 +351,11 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
     | Some (Inr x) -> q.refine x);
 })
 
-// put new_one one <= x
-// x composable y
-// ----------------------
-// put new_one one <= y
-// 
-// put new_one one <= x
-// x composable y
-// put new_one one * put frame_v frame_s = put (get x) x
-// new_one * frame_v = get x
-// (get x) composable (get y)
-// new_one <= get y
-// one <= y
-// put new_one one <= put (get y) y = y
-// ----------------------
-// put new_one one <= y
-
-//  new_one: x:a{composable p x x};
-//  new_one_is_unit: x:a{composable p x new_one} -> Lemma (op p x new_one == x);
-//  new_one_comp_closed:
-//    x:a{composable p x new_one} -> 
-//    y:a{composable p x new_one /\ composable p x y} ->
-//    Lemma (composable p (op p x y) new_one)
 let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
-  //f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
-  //f_closed_under_op = (fun _ _ -> ());
-  //new_one = Some (Inl #_ #'b (one p));
-  //new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
-  new_one = (p.is_unit (one p); Some (Inl (one p)));
-  new_one_is_unit = (fun x -> match x with
-    | Some (Inl x) -> p.is_unit x
-    | None -> admit());
-  new_one_comp_closed = (fun _ _ -> admit());
-  //new_one_is_unit: x:'a{composable p x new_one} -> Lemma (op p x new_one == x);
-  //new_one_comp_closed:
-  //  x:a{composable p x new_one} -> 
-  //  y:a{composable p x y} ->
-  //  Lemma (composable p y new_one /\ composable p (op p x y) new_one)
+  f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = Some (Inl #_ #'b (one p));
+  new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
 (** A lens for the k-th field of an n-ary product *)
@@ -447,19 +408,81 @@ let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 : refine_t (case_refinement_f p k)
 = Some (|k, one (p k)|)
 
-(* TODO
 let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) = {
   f = case_refinement_f p k;
   f_closed_under_op = (fun x y -> ());
   new_one = case_refinement_new_one p k;
   new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
 }
-*)
+
+let case_refinement_ok_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
+  (kx: union b): union b
+= match kx with
+  | Some (|k', _|) -> if k = k' then f kx else None
+  | _ -> None
+
+let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+: pcm_refinement_ok (case_refinement p k) = {
+  unrefine = case_refinement_ok_unrefine p k;
+  frame_pres_unrefine = (fun f kx ky ->
+    let Some (|_, x|) = Ghost.reveal kx in
+    let Some (|_, y|) = Ghost.reveal ky in
+    let p' = refined_pcm (case_refinement p k) in
+    frame_pres_intro (union_pcm p) (case_refinement_ok_unrefine p k f)
+      (Ghost.reveal kx) (Ghost.reveal ky)
+      (fun kv -> match kv with
+        | Some (|k', v|) -> 
+          if k = k' then begin
+            compatible_elim (union_pcm p) (Ghost.reveal kx) kv
+              (compatible (refined_pcm (case_refinement p k)) kx kv)
+              (fun frame_kx -> match frame_kx with
+                | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
+                | None -> compatible_refl p' kx);
+            let aux (frame:union b{composable (union_pcm p) kx frame})
+            : Lemma (composable (union_pcm p) ky frame /\
+                     (op (union_pcm p) kx frame == Some (|k, v|) ==>
+                      op (union_pcm p) ky frame == f (Some (|k, v|))))
+            = let Some (|_, w|) = f (Some (|k, v|)) in
+              match frame with
+              | Some (|frame_k, frame_v|) ->
+                assert (k == frame_k);
+                //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
+                //  composable p' ky frame /\
+                //  (op p' kx frame == kv ==> op p' ky frame == f kv));
+                assert (composable p' kx frame);
+                assert (composable (p k) y frame_v);
+                assert (op (p k) x frame_v == v ==> op (p k) y frame_v == w)
+              | None ->
+                p'.is_unit kx;
+                //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
+                //  composable p' ky frame /\
+                //  (op p' kx frame == kv ==> op p' ky frame == f kv));
+                assert (composable p' kx (one p'));
+                assert (composable p' ky (one p') /\ (op p' kx (one p') == kv ==> op p' ky (one p') == f kv));
+                p'.is_unit ky;
+                assert (composable p' ky (one p') /\ (Ghost.reveal kx == kv ==> Ghost.reveal ky == f kv));
+                assert (composable p' ky (one p') /\ (Some (|k, x|) == Some (|k, v|) ==> Ghost.reveal ky == f (Some (|k, v|))));
+                assert (x == v ==> Ghost.reveal ky == Some (|k, w|));
+                let Some (|k', y|) = Ghost.reveal ky in
+                assert (x == v ==> Some (|k', y|) == Some (|k, w|));
+                assert (x == v ==> y == w)
+            in FStar.Classical.forall_intro aux
+          end else ()
+        | None -> ()));
+}
 
 (** A lens for the k-th case of an n-ary union *)
 
 let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
   fun (Some (|_, v|)) -> v
+  //frame_pres_unrefine:
+  //  f:(refine_t r.f -> refine_t r.f) ->
+  //  x:erased (refine_t r.f) ->
+  //  y:erased (refine_t r.f) ->
+  //  Lemma
+  //    (requires frame_pres (refined_pcm r) f x y)
+  //    (ensures frame_pres p (unrefine f) (reveal x) (reveal y))
 let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
 : refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
 = fun _ -> Some (|k, v|)
@@ -472,14 +495,12 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
   put_put = (fun s v w -> ());
 }
 
-(* TODO
 (** lens_case is a pcm_lens *)
 let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
   l = lens_case p k;
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
-*)
 
 (** Refining a lens *)
 
@@ -1046,4 +1067,3 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres
   f' hf') in
   as_action act
   *)
-

From 0f0b86f137f5c9e08df17ad61b4a88d8f6dc031c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 12:45:52 -0700
Subject: [PATCH 036/513] Make pcm_refinement_ok require decidable refinement
 predicate

---
 examples/steel/AggregateRef.fst | 38 +++++++++++++++++++++++++++------
 1 file changed, 32 insertions(+), 6 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 1de644dba61..a8c87608cfe 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -123,18 +123,24 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
   new_one_is_refined_unit = p.is_unit;
 }
 
-(** A PCM refinement is well-formed if frame-preserving updates on the
-    refined PCM can be lifted to frame-preserving updates on the
-    unrefined PCM *)
+(** A PCM refinement is well-formed if the refinement predicate is decidable
+    and frame-preserving updates on the refined PCM can be lifted to
+    frame-preserving updates on the unrefined PCM *)
+
+let unrefine (#p: pcm 'a) (r: pcm_refinement p)
+  (is_refined:(x:'a -> b:bool{b <==> r.f x})) (f: refine_t r.f -> refine_t r.f)
+  (x: 'a): 'a
+= if is_refined x then f x else one p
+
 noeq type pcm_refinement_ok #a (#p: pcm a) (r: pcm_refinement p) = {
-  unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
+  is_refined: x:a -> b:bool{b <==> r.f x};
   frame_pres_unrefine:
     f:(refine_t r.f -> refine_t r.f) ->
     x:Ghost.erased (refine_t r.f) ->
     y:Ghost.erased (refine_t r.f) ->
     Lemma
       (requires frame_pres (refined_pcm r) f x y)
-      (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
+      (ensures frame_pres p (unrefine r is_refined f) (Ghost.reveal x) (Ghost.reveal y))
 }
 
 (** Very well-behaved lenses *)
@@ -422,9 +428,13 @@ let case_refinement_ok_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
+let case_refinement_is_refined (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a) (kx: union b)
+: b:bool{b <==> case_refinement_f p k kx}
+= match kx with Some (|k', _|) -> k = k' | None -> false
+
 let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 : pcm_refinement_ok (case_refinement p k) = {
-  unrefine = case_refinement_ok_unrefine p k;
+  is_refined = case_refinement_is_refined p k;
   frame_pres_unrefine = (fun f kx ky ->
     let Some (|_, x|) = Ghost.reveal kx in
     let Some (|_, y|) = Ghost.reveal ky in
@@ -652,6 +662,22 @@ let conj_refinement (#p: pcm 'a)
   new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
 }
 
+let conj_refinement_ok (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
+: pcm_refinement_ok (conj_refinement re1 re2) = {
+  unrefine = (fun f v -> admit());
+  frame_pres_unrefine = (fun f x y -> admit());
+// unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
+// frame_pres_unrefine:
+//   f:(refine_t r.f -> refine_t r.f) ->
+//   x:Ghost.erased (refine_t r.f) ->
+//   y:Ghost.erased (refine_t r.f) ->
+//   Lemma
+//     (requires frame_pres (refined_pcm r) f x y)
+//     (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
+}
+  
 (** Isomorphisms *)
 
 noeq type iso a b = {

From 36b32cc796544d37b7d38050008199ad0138758c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 13:51:55 -0700
Subject: [PATCH 037/513] Attempt conj_refinement_ok

---
 examples/steel/AggregateRef.fst | 215 ++++++++++++++++++++------------
 1 file changed, 136 insertions(+), 79 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index a8c87608cfe..fd842545bfc 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -132,15 +132,19 @@ let unrefine (#p: pcm 'a) (r: pcm_refinement p)
   (x: 'a): 'a
 = if is_refined x then f x else one p
 
+let is_refined_t (#p: pcm 'a) (r: pcm_refinement p) = x:'a -> b:bool{b <==> r.f x}
+let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (is_refined: is_refined_t r) =
+  f:(refine_t r.f -> refine_t r.f) ->
+  x:Ghost.erased (refine_t r.f) ->
+  y:Ghost.erased (refine_t r.f) ->
+  Lemma
+    (requires frame_pres (refined_pcm r) f x y)
+    (ensures frame_pres p (unrefine r is_refined f) (Ghost.reveal x) (Ghost.reveal y))
+  
 noeq type pcm_refinement_ok #a (#p: pcm a) (r: pcm_refinement p) = {
-  is_refined: x:a -> b:bool{b <==> r.f x};
-  frame_pres_unrefine:
-    f:(refine_t r.f -> refine_t r.f) ->
-    x:Ghost.erased (refine_t r.f) ->
-    y:Ghost.erased (refine_t r.f) ->
-    Lemma
-      (requires frame_pres (refined_pcm r) f x y)
-      (ensures frame_pres p (unrefine r is_refined f) (Ghost.reveal x) (Ghost.reveal y))
+  is_refined: is_refined_t r;
+  unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
+  frame_pres_unrefine: frame_pres_unrefine_t r is_refined;
 }
 
 (** Very well-behaved lenses *)
@@ -435,6 +439,7 @@ let case_refinement_is_refined (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a) (kx:
 let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 : pcm_refinement_ok (case_refinement p k) = {
   is_refined = case_refinement_is_refined p k;
+  unrefine = unrefine (case_refinement p k) (case_refinement_is_refined p k);
   frame_pres_unrefine = (fun f kx ky ->
     let Some (|_, x|) = Ghost.reveal kx in
     let Some (|_, y|) = Ghost.reveal ky in
@@ -625,58 +630,6 @@ let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
     f_op = pcm_lens_refine_put_morphism_op l re;
   };
 }
-
-(** The conjunction of two refinements *)
-
-let conj_refinement_f (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-: 'a -> prop = conj #'a re1.f re2.f
-
-let conj_refinement_f_closed (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
-: Lemma (conj_refinement_f re1 re2 (op p x y))
-= re1.f_closed_under_op x y;
-  re2.f_closed_under_op x y
-
-(* re1.new_one and re2.new_one both work; we go with re2 *)
-let conj_refinement_new_one (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-: refine_t (conj_refinement_f re1 re2)
-= re2.new_one
-
-let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
-         op p x (conj_refinement_new_one re1 re2) == x)
-= re2.new_one_is_refined_unit x
-
-let conj_refinement (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-: pcm_refinement p = {
-  f = conj_refinement_f re1 re2;
-  f_closed_under_op = conj_refinement_f_closed re1 re2;
-  new_one = conj_refinement_new_one re1 re2;
-  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
-}
-
-let conj_refinement_ok (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-  (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
-: pcm_refinement_ok (conj_refinement re1 re2) = {
-  unrefine = (fun f v -> admit());
-  frame_pres_unrefine = (fun f x y -> admit());
-// unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
-// frame_pres_unrefine:
-//   f:(refine_t r.f -> refine_t r.f) ->
-//   x:Ghost.erased (refine_t r.f) ->
-//   y:Ghost.erased (refine_t r.f) ->
-//   Lemma
-//     (requires frame_pres (refined_pcm r) f x y)
-//     (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
-}
   
 (** Isomorphisms *)
 
@@ -733,6 +686,63 @@ let pcm_refinement_conj_iso_i (p: pcm 'a)
 : iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
   refine_conj_iso re1.f re2.f
 
+let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (i: pcm_iso p q) (l: pcm_lens q r)
+: pcm_lens p r = {
+  l = iso_lens_comp i.i l.l;
+  get_morphism = pcm_morphism_comp l.get_morphism i.fwd_morphism;
+  put_morphism = {
+    f_refine = (fun (v, s) ->
+      i.fwd_morphism.f_refine s; 
+      l.put_morphism.f_refine (v, i.i.fwd s);
+      i.bwd_morphism.f_refine (l.l.put v (i.i.fwd s)));
+    f_one = (fun () ->
+      i.fwd_morphism.f_one (); 
+      l.put_morphism.f_one ();
+      i.bwd_morphism.f_one ());
+    f_op = (fun (v, s) (w, t) -> 
+     i.fwd_morphism.f_op s t;
+     l.put_morphism.f_op (v, i.i.fwd s) (w, i.i.fwd t);
+     i.bwd_morphism.f_op (l.l.put v (i.i.fwd s)) (l.l.put w (i.i.fwd t)));
+  }
+}
+
+(** The conjunction of two refinements *)
+
+let conj_refinement_f (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: 'a -> prop = conj #'a re1.f re2.f
+
+let conj_refinement_f_closed (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
+: Lemma (conj_refinement_f re1 re2 (op p x y))
+= re1.f_closed_under_op x y;
+  re2.f_closed_under_op x y
+
+(* re1.new_one and re2.new_one both work; we go with re2 *)
+let conj_refinement_new_one (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: refine_t (conj_refinement_f re1 re2)
+= re2.new_one
+
+let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
+         op p x (conj_refinement_new_one re1 re2) == x)
+= re2.new_one_is_refined_unit x
+
+let conj_refinement (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: pcm_refinement p = {
+  f = conj_refinement_f re1 re2;
+  f_closed_under_op = conj_refinement_f_closed re1 re2;
+  new_one = conj_refinement_new_one re1 re2;
+  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
+}
+
 let pcm_refinement_conj_iso_fwd_morphism_op (p: pcm 'a)
   (re1: pcm_refinement p)
   (re2: pcm_refinement (refined_pcm re1))
@@ -760,27 +770,73 @@ let pcm_refinement_conj_iso (p: pcm 'a)
   };
 }
 
-let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (i: pcm_iso p q) (l: pcm_lens q r)
-: pcm_lens p r = {
-  l = iso_lens_comp i.i l.l;
-  get_morphism = pcm_morphism_comp l.get_morphism i.fwd_morphism;
-  put_morphism = {
-    f_refine = (fun (v, s) ->
-      i.fwd_morphism.f_refine s; 
-      l.put_morphism.f_refine (v, i.i.fwd s);
-      i.bwd_morphism.f_refine (l.l.put v (i.i.fwd s)));
-    f_one = (fun () ->
-      i.fwd_morphism.f_one (); 
-      l.put_morphism.f_one ();
-      i.bwd_morphism.f_one ());
-    f_op = (fun (v, s) (w, t) -> 
-     i.fwd_morphism.f_op s t;
-     l.put_morphism.f_op (v, i.i.fwd s) (w, i.i.fwd t);
-     i.bwd_morphism.f_op (l.l.put v (i.i.fwd s)) (l.l.put w (i.i.fwd t)));
+let conj_refinement_ok_is_refined (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
+: is_refined_t (conj_refinement #'a re1 re2)
+= fun v -> h1.is_refined v && h2.is_refined v
+
+let conj_refinement_ok (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
+: pcm_refinement_ok (conj_refinement #'a re1 re2)
+= let is_refined = conj_refinement_ok_is_refined re1 re2 h1 h2 in
+  let re = conj_refinement #'a re1 re2 in
+  {
+    is_refined = is_refined;
+    unrefine = unrefine re is_refined;
+    frame_pres_unrefine = (fun f x y ->
+      let p' = refined_pcm re in
+      let f': 'a -> 'a = unrefine re is_refined f in
+      let aux x : Lemma (f' x == (if is_refined x then f x else one p)) = () in
+      let aux x : Lemma (f' x == (if h1.is_refined x && h2.is_refined x then f x else one p)) = () in
+      let f'': refine_t re1.f -> refine_t re1.f = unrefine re2 h2.is_refined f in
+      let aux x : Lemma (f'' x == (if h2.is_refined x then f x else one (refined_pcm re1))) = () in
+      let f''': 'a -> 'a = unrefine re1 h1.is_refined f'' in
+      let aux x : Lemma (f''' x == (if h1.is_refined x then if h2.is_refined x then f x else one (refined_pcm re1) else one p)) = () in
+      assert (frame_pres (refined_pcm (conj_refinement #'a re1 re2)) f (Ghost.reveal x) (Ghost.reveal y));
+      // assert (frame_pres (refined_pcm re2) f (Ghost.reveal x) (Ghost.reveal y));
+      // let _ : squash (frame_pres (refined_pcm re1) f'' (Ghost.reveal x) (Ghost.reveal y)) = h2.frame_pres_unrefine f (Ghost.reveal x) (Ghost.reveal y) in
+      // let _ : squash (frame_pres p f''' (Ghost.reveal x) (Ghost.reveal y)) = 
+      //   h2.frame_pres_unrefine f (Ghost.reveal x) (Ghost.reveal y);
+      //   // h1.frame_pres_unrefine f'' (Ghost.reveal x) (Ghost.reveal y);
+      //   admit()
+      // in
+//       
+//     f:(refine_t r.f -> refine_t r.f) ->
+//     x:Ghost.erased (refine_t r.f) ->
+//     y:Ghost.erased (refine_t r.f) ->
+//     Lemma
+//       (requires frame_pres (refined_pcm r) f x y)
+//       (ensures frame_pres p (unrefine r is_refined f) (Ghost.reveal x) (Ghost.reveal y))
+//       assert (frame_pres p' f x y);
+      // let _ : squash (frame_pres (refined_pcm re1)
+      //   (unrefine re2 h2.is_refined f) (Ghost.reveal x) (Ghost.reveal y))
+      //   = h2.frame_pres_unrefine f (Ghost.reveal x) (Ghost.reveal y)
+      // in
+      frame_pres_intro p f' (Ghost.reveal x) (Ghost.reveal y) (fun v ->
+        assert (compatible p x v);
+        assert (re1.f x);
+        assert (re2.f x);
+        assume (p.refine (f' v));
+        assume (compatible p y (f' v));
+        assume (forall (frame:'a{composable p x frame}).
+              composable p y frame /\
+              (op p x frame == v ==> op p y frame == f' v))));
+              (*
+let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (v:'a{p.refine v /\ compatible p x v})
+= p.refine (f v) /\
+  compatible p y (f v) /\
+  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
+     composable p y frame /\
+     (op p x frame == v ==> op p y frame == f v))
+let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
+  frame_pres_on p f x y v *)
   }
-}
 
+(*
 (** The refinement of a ref *)
 
 let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) : ref 'a (refine_t new_re.f) = {
@@ -1093,3 +1149,4 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres
   f' hf') in
   as_action act
   *)
+*)

From 220a88aab3bdc56fafabf0f564f346154bcf453d Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 14:52:51 -0700
Subject: [PATCH 038/513] Start extend_refinement_ok

---
 examples/steel/AggregateRef.fst | 180 ++++++++++++++++++--------------
 1 file changed, 100 insertions(+), 80 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index fd842545bfc..9c4d1266eb9 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -127,24 +127,19 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
     and frame-preserving updates on the refined PCM can be lifted to
     frame-preserving updates on the unrefined PCM *)
 
-let unrefine (#p: pcm 'a) (r: pcm_refinement p)
-  (is_refined:(x:'a -> b:bool{b <==> r.f x})) (f: refine_t r.f -> refine_t r.f)
-  (x: 'a): 'a
-= if is_refined x then f x else one p
-
-let is_refined_t (#p: pcm 'a) (r: pcm_refinement p) = x:'a -> b:bool{b <==> r.f x}
-let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (is_refined: is_refined_t r) =
+let unrefine_t (#p: pcm 'a) (r: pcm_refinement p) =
+  (refine_t r.f -> refine_t r.f) -> 'a -> 'a
+let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (unrefine: unrefine_t r) =
   f:(refine_t r.f -> refine_t r.f) ->
   x:Ghost.erased (refine_t r.f) ->
   y:Ghost.erased (refine_t r.f) ->
   Lemma
     (requires frame_pres (refined_pcm r) f x y)
-    (ensures frame_pres p (unrefine r is_refined f) (Ghost.reveal x) (Ghost.reveal y))
+    (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
   
 noeq type pcm_refinement_ok #a (#p: pcm a) (r: pcm_refinement p) = {
-  is_refined: is_refined_t r;
   unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
-  frame_pres_unrefine: frame_pres_unrefine_t r is_refined;
+  frame_pres_unrefine: frame_pres_unrefine_t r unrefine;
 }
 
 (** Very well-behaved lenses *)
@@ -283,7 +278,7 @@ open FStar.FunctionalExtensionality
 noeq type ref (a:Type) (b:Type): Type = {
   p: pcm a;
   re: pcm_refinement p;
-  hre: pcm_refinement_ok re;
+  re_ok: pcm_refinement_ok re;
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
   r: Steel.Memory.ref a p;
@@ -432,14 +427,9 @@ let case_refinement_ok_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
-let case_refinement_is_refined (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a) (kx: union b)
-: b:bool{b <==> case_refinement_f p k kx}
-= match kx with Some (|k', _|) -> k = k' | None -> false
-
 let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 : pcm_refinement_ok (case_refinement p k) = {
-  is_refined = case_refinement_is_refined p k;
-  unrefine = unrefine (case_refinement p k) (case_refinement_is_refined p k);
+  unrefine = case_refinement_ok_unrefine p k;
   frame_pres_unrefine = (fun f kx ky ->
     let Some (|_, x|) = Ghost.reveal kx in
     let Some (|_, y|) = Ghost.reveal ky in
@@ -491,13 +481,6 @@ let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 
 let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
   fun (Some (|_, v|)) -> v
-  //frame_pres_unrefine:
-  //  f:(refine_t r.f -> refine_t r.f) ->
-  //  x:erased (refine_t r.f) ->
-  //  y:erased (refine_t r.f) ->
-  //  Lemma
-  //    (requires frame_pres (refined_pcm r) f x y)
-  //    (ensures frame_pres p (unrefine f) (reveal x) (reveal y))
 let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
 : refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
 = fun _ -> Some (|k, v|)
@@ -770,78 +753,115 @@ let pcm_refinement_conj_iso (p: pcm 'a)
   };
 }
 
-let conj_refinement_ok_is_refined (#p: pcm 'a)
+let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
+  (f: 'a -> 'a): 'b -> 'b
+= i.i.fwd `compose` f `compose` i.i.bwd
+
+let frame_pres_upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
+  (f: 'a -> 'a) (x y: Ghost.erased 'a)
+: Lemma
+    (requires frame_pres p f x y)
+    (ensures frame_pres q (upd_across_pcm_iso i f) (i.i.fwd x) (i.i.fwd y))
+= frame_pres_intro q (upd_across_pcm_iso i f) (i.i.fwd x) (i.i.fwd y) (fun v ->
+    assert (compatible q (i.i.fwd x) v);
+    assume (q.refine ((upd_across_pcm_iso i f) v));
+    assume (compatible q (i.i.fwd y) ((upd_across_pcm_iso i f) v));
+    assume (
+        (forall (frame:'b{composable q (i.i.fwd x) frame}).
+          composable q (i.i.fwd y) frame /\
+          (op q (i.i.fwd x) frame == v ==> op q (i.i.fwd y) frame == (upd_across_pcm_iso i f) v))))
+(*
+suppose compatible q (i.i.fwd x) v
+and q.refine v.
+suppose
+  frame_pres p f x y
+
+to show q.refine (f' v):
+  f' v = fwd (f (bwd v))
+  q.refine v by assumption
+  p.refine (bwd v) b/c bwd is morphism
+  q.refine (f (bwd v)) b/c f frame preserving
+    need show compatible p x (bwd v)
+    easy: compatible p (fwd x) v ==> compatible p (bwd (fwd x)) (bwd v) b/c bwd is pcm morphism
+  p.refine (fwd (f (bwd v))) b/c fwd is morphism
+
+to show compatible q (fwd y) (f' v):
+  f'v = fwd (f (bwd v))
+  so need show compatible q (fwd y) (fwd (f (bwd v)))
+  suff. to show compatible q y (f (bwd v)) b/c fwd is pcm morphism
+  since we have refine (bwd v) /\ compatible p x (bwd v) (proof is same as in previous subcase),
+    we know compatible q y (f (bwd v)) b/c f is frame-preserving
+
+fix frame where composable q (fwd x) frame.
+to show composable q (fwd y) frame /\ (op q (fwd x) frame == v ==> op q (fwd y) frame == f' v == fwd (f (bwd v))):
+  we have composable q (bwd (fwd x)) (bwd frame) <==> composable q x (bwd frame) b/c bwd is morphism
+  since we have refine (bwd v) /\ compatible p x (bwd v),
+  and composable q x (bwd frame),
+  instantiate hyp about f frame-preserving from x to y to get
+    composable q y (bwd frame) /\ (op p x (bwd frame) == bwd v ==> op p y (bwd frame) == f (bwd v))
+  now,
+    composable q y (bwd frame) ==> composable q (fwd y) frame b/c fwd morphism
+  and
+    (op p x (bwd frame) == bwd v ==> op p y (bwd frame) == f (bwd v))
+    <==> (op p (fwd x) frame == v ==> op p (fwd y) frame == fwd (f (bwd v)))
+    b/c fwd morphism
+qed
+*)
+
+let conj_refinement_ok_unrefine (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
   (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
-: is_refined_t (conj_refinement #'a re1 re2)
-= fun v -> h1.is_refined v && h2.is_refined v
+: (refine_t (conj_refinement_f #'a re1 re2) -> refine_t (conj_refinement_f #'a re1 re2)) ->
+  'a -> 'a
+= h1.unrefine `compose` h2.unrefine `compose` upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2)
 
 let conj_refinement_ok (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
   (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
 : pcm_refinement_ok (conj_refinement #'a re1 re2)
-= let is_refined = conj_refinement_ok_is_refined re1 re2 h1 h2 in
-  let re = conj_refinement #'a re1 re2 in
+= let re = conj_refinement #'a re1 re2 in
+  let i = pcm_refinement_conj_iso p re1 re2 in
   {
-    is_refined = is_refined;
-    unrefine = unrefine re is_refined;
+    unrefine = conj_refinement_ok_unrefine re1 re2 h1 h2;
     frame_pres_unrefine = (fun f x y ->
-      let p' = refined_pcm re in
-      let f': 'a -> 'a = unrefine re is_refined f in
-      let aux x : Lemma (f' x == (if is_refined x then f x else one p)) = () in
-      let aux x : Lemma (f' x == (if h1.is_refined x && h2.is_refined x then f x else one p)) = () in
-      let f'': refine_t re1.f -> refine_t re1.f = unrefine re2 h2.is_refined f in
-      let aux x : Lemma (f'' x == (if h2.is_refined x then f x else one (refined_pcm re1))) = () in
-      let f''': 'a -> 'a = unrefine re1 h1.is_refined f'' in
-      let aux x : Lemma (f''' x == (if h1.is_refined x then if h2.is_refined x then f x else one (refined_pcm re1) else one p)) = () in
-      assert (frame_pres (refined_pcm (conj_refinement #'a re1 re2)) f (Ghost.reveal x) (Ghost.reveal y));
-      // assert (frame_pres (refined_pcm re2) f (Ghost.reveal x) (Ghost.reveal y));
-      // let _ : squash (frame_pres (refined_pcm re1) f'' (Ghost.reveal x) (Ghost.reveal y)) = h2.frame_pres_unrefine f (Ghost.reveal x) (Ghost.reveal y) in
-      // let _ : squash (frame_pres p f''' (Ghost.reveal x) (Ghost.reveal y)) = 
-      //   h2.frame_pres_unrefine f (Ghost.reveal x) (Ghost.reveal y);
-      //   // h1.frame_pres_unrefine f'' (Ghost.reveal x) (Ghost.reveal y);
-      //   admit()
-      // in
-//       
-//     f:(refine_t r.f -> refine_t r.f) ->
-//     x:Ghost.erased (refine_t r.f) ->
-//     y:Ghost.erased (refine_t r.f) ->
-//     Lemma
-//       (requires frame_pres (refined_pcm r) f x y)
-//       (ensures frame_pres p (unrefine r is_refined f) (Ghost.reveal x) (Ghost.reveal y))
-//       assert (frame_pres p' f x y);
-      // let _ : squash (frame_pres (refined_pcm re1)
-      //   (unrefine re2 h2.is_refined f) (Ghost.reveal x) (Ghost.reveal y))
-      //   = h2.frame_pres_unrefine f (Ghost.reveal x) (Ghost.reveal y)
-      // in
-      frame_pres_intro p f' (Ghost.reveal x) (Ghost.reveal y) (fun v ->
-        assert (compatible p x v);
-        assert (re1.f x);
-        assert (re2.f x);
-        assume (p.refine (f' v));
-        assume (compatible p y (f' v));
-        assume (forall (frame:'a{composable p x frame}).
-              composable p y frame /\
-              (op p x frame == v ==> op p y frame == f' v))));
-              (*
-let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (v:'a{p.refine v /\ compatible p x v})
-= p.refine (f v) /\
-  compatible p y (f v) /\
-  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
-     composable p y frame /\
-     (op p x frame == v ==> op p y frame == f v))
-let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
-  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
-  frame_pres_on p f x y v *)
+      assert (frame_pres (refined_pcm (conj_refinement #'a re1 re2)) f x y); 
+      let f': refine_t re2.f -> refine_t re2.f = upd_across_pcm_iso i f in
+      frame_pres_upd_across_pcm_iso i f' (i.i.fwd x) (i.i.fwd y);
+      assert (frame_pres (refined_pcm re2) f' (i.i.fwd x) (i.i.fwd y));
+      let f'': refine_t re1.f -> refine_t re1.f = h2.unrefine f' in
+      h2.frame_pres_unrefine f' (i.i.fwd x) (i.i.fwd y);
+      assert (frame_pres (refined_pcm re1) f'' (i.i.fwd x) (i.i.fwd y));
+      let f''': 'a -> 'a = h1.unrefine f'' in
+      h1.frame_pres_unrefine f'' (i.i.fwd x) (i.i.fwd y);
+      assert (frame_pres p f''' (i.i.fwd x) (i.i.fwd y));
+      assert (frame_pres p f''' (Ghost.reveal x) (Ghost.reveal y)));
+  }
+
+let extend_refinement_ok_unrefine (r: ref 'a 'b)
+  (re: pcm_refinement r.q) (re_ok: pcm_refinement_ok re)
+: (refine_t (extend_refinement_f r.pl re) -> refine_t (extend_refinement_f r.pl re)) ->
+  refine_t r.re.f -> refine_t r.re.f
+= admit()
+
+// let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+//   (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
+
+let extend_refinement_ok (r: ref 'a 'b)
+  (re: pcm_refinement r.q) (re_ok: pcm_refinement_ok re)
+: pcm_refinement_ok (extend_refinement r.pl re)
+= let re' = extend_refinement r.pl re in
+  {
+    unrefine = extend_refinement_ok_unrefine r re re_ok;
+    frame_pres_unrefine = (fun f x y -> admit());
   }
 
 (*
 (** The refinement of a ref *)
 
-let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) : ref 'a (refine_t new_re.f) = {
+let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) (new_re_ok: pcm_refinement_ok new_re): ref 'a (refine_t new_re.f) = {
   p = r.p;
   re = conj_refinement r.re (extend_refinement r.pl new_re);
+  re_ok = conj_refinement_ok r.re (extend_refinement r.pl new_re) r.re_ok new_re_ok;
   q = refined_pcm new_re;
   pl =
     pcm_iso_lens_comp

From 193681c58c8bda37da346cb9a29fa70f4958c328 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 15:33:37 -0700
Subject: [PATCH 039/513] Tidy

---
 examples/steel/AggregateRef.fst | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 9c4d1266eb9..7a17c05c3a1 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -843,9 +843,6 @@ let extend_refinement_ok_unrefine (r: ref 'a 'b)
   refine_t r.re.f -> refine_t r.re.f
 = admit()
 
-// let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-//   (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
-
 let extend_refinement_ok (r: ref 'a 'b)
   (re: pcm_refinement r.q) (re_ok: pcm_refinement_ok re)
 : pcm_refinement_ok (extend_refinement r.pl re)
@@ -855,13 +852,16 @@ let extend_refinement_ok (r: ref 'a 'b)
     frame_pres_unrefine = (fun f x y -> admit());
   }
 
-(*
 (** The refinement of a ref *)
 
-let ref_refine (r: ref 'a 'b) (new_re: pcm_refinement r.q) (new_re_ok: pcm_refinement_ok new_re): ref 'a (refine_t new_re.f) = {
+let ref_refine (r: ref 'a 'b)
+  (new_re: pcm_refinement r.q) (new_re_ok: pcm_refinement_ok new_re)
+: ref 'a (refine_t new_re.f) = {
   p = r.p;
   re = conj_refinement r.re (extend_refinement r.pl new_re);
-  re_ok = conj_refinement_ok r.re (extend_refinement r.pl new_re) r.re_ok new_re_ok;
+  re_ok =
+    conj_refinement_ok r.re (extend_refinement r.pl new_re) r.re_ok
+      (extend_refinement_ok r new_re new_re_ok);
   q = refined_pcm new_re;
   pl =
     pcm_iso_lens_comp
@@ -877,7 +877,7 @@ module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
 let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
-  {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
+  {p = r.p; re = r.re; re_ok = r.re_ok; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
 let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
@@ -978,22 +978,26 @@ let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased
 = peel r q l x;
   focus r q l (put l (get l x) (one r.q)) (get l x)
 
-let refine (r: ref 'a 'b) (re: pcm_refinement r.q) (x: Ghost.erased 'b{re.f x})
+let refine (r: ref 'a 'b)
+  (re: pcm_refinement r.q)
+  (re_ok: pcm_refinement_ok re)
+  (x: Ghost.erased 'b{re.f x})
 : Steel (ref 'a (refine_t re.f))
     (to_vprop (r `pts_to` x))
     (fun r' -> to_vprop (r' `pts_to` Ghost.reveal x))
     (fun _ -> True)
-    (fun _ r' _ -> r' == ref_refine r re)
-= let r' = ref_refine r re in
+    (fun _ r' _ -> r' == ref_refine r re re_ok)
+= let r' = ref_refine r re re_ok in
   change_equal_vprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
-let unrefine #inames (r': ref 'a 'b) (re: pcm_refinement r'.q)
+let unrefine #inames (r': ref 'a 'b)
+  (re: pcm_refinement r'.q) (re_ok: pcm_refinement_ok re)
   (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` Ghost.reveal x))
     (fun _ -> to_vprop (r' `pts_to` x))
-    (fun _ -> r == ref_refine r' re)
+    (fun _ -> r == ref_refine r' re re_ok)
     (fun _ _ _ -> True)
 = change_equal_vprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
@@ -1169,4 +1173,3 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres
   f' hf') in
   as_action act
   *)
-*)

From c4c0a28bb9538e5eca50c75009325acb1345a5f6 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 1 Jul 2021 16:35:40 -0700
Subject: [PATCH 040/513] Sketch extend_refinement_ok

---
 examples/steel/AggregateRef.fst | 375 ++++++++++++++++++++------------
 1 file changed, 234 insertions(+), 141 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 7a17c05c3a1..b97c9227218 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -270,6 +270,125 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   };
 }
 
+(** Refining a lens *)
+
+let lens_refine_get (l: lens 'a 'b) f
+  (s: refine_t (f `compose` l.get)): refine_t f
+= l.get s
+let lens_refine_put (l: lens 'a 'b) f
+  (v: refine_t f) (s: refine_t (f `compose` l.get)): refine_t (f `compose` l.get)
+= l.put v s
+
+let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
+: lens (refine_t (f `compose` l.get)) (refine_t f) = {
+  get = lens_refine_get l f;
+  put = lens_refine_put l f;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+(** Refining a pcm_lens *)
+
+let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
+
+let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+  (y: refine_t (extend_refinement_f l re){composable p x y})
+: Lemma (extend_refinement_f l re (op p x y))
+= l.get_morphism.f_op x y;
+  re.f_closed_under_op (get l x) (get l y)
+
+let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q): refine_t (extend_refinement_f l re)
+= put l re.new_one (one p)
+
+let extend_refinement_new_one_is_refined_unit
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+: Lemma (composable p x (extend_refinement_new_one l re) /\
+         op p x (extend_refinement_new_one l re) == x)
+= re.new_one_is_refined_unit (get l x);
+  p.is_unit x;
+  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+  
+let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
+  f = extend_refinement_f l re;
+  f_closed_under_op = extend_refinement_f_closed l re;
+  new_one = extend_refinement_new_one l re;
+  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+}
+
+let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_refine
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l.l re.f).get
+= l.get_morphism.f_refine
+
+let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_one
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l.l re.f).get
+= l.get_morphism.f_one
+
+let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_op
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l.l re.f).get
+= l.get_morphism.f_op
+
+let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_refine
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l.l re.f).put)
+= fun (v, s) -> l.put_morphism.f_refine (v, s)
+
+let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_one
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l.l re.f).put)
+= l.put_morphism.f_one
+
+let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_op
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l.l re.f).put)
+= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
+
+let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
+  l = lens_refine l.l re.f;
+  get_morphism = {
+    f_refine = pcm_lens_refine_get_morphism_refine l re;
+    f_one = pcm_lens_refine_get_morphism_one l re;
+    f_op = pcm_lens_refine_get_morphism_op l re;
+  };
+  put_morphism = {
+    f_refine = pcm_lens_refine_put_morphism_refine l re;
+    f_one = pcm_lens_refine_put_morphism_one l re;
+    f_op = pcm_lens_refine_put_morphism_op l re;
+  };
+}
+
+let pcm_lens_supports_extend (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) =
+  re: pcm_refinement q ->
+  re_ok: pcm_refinement_ok re ->
+  pcm_refinement_ok (extend_refinement l re)
+
 open FStar.FunctionalExtensionality
 
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
@@ -278,9 +397,10 @@ open FStar.FunctionalExtensionality
 noeq type ref (a:Type) (b:Type): Type = {
   p: pcm a;
   re: pcm_refinement p;
-  re_ok: pcm_refinement_ok re;
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
+  re_ok: pcm_refinement_ok re;
+  pl_ext: pcm_lens_supports_extend pl;
   r: Steel.Memory.ref a p;
 }
 
@@ -427,6 +547,7 @@ let case_refinement_ok_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
+(* TODO tidy *)
 let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 : pcm_refinement_ok (case_refinement p k) = {
   unrefine = case_refinement_ok_unrefine p k;
@@ -499,120 +620,6 @@ let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
-
-(** Refining a lens *)
-
-let lens_refine_get (l: lens 'a 'b) f
-  (s: refine_t (f `compose` l.get)): refine_t f
-= l.get s
-let lens_refine_put (l: lens 'a 'b) f
-  (v: refine_t f) (s: refine_t (f `compose` l.get)): refine_t (f `compose` l.get)
-= l.put v s
-
-let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
-: lens (refine_t (f `compose` l.get)) (refine_t f) = {
-  get = lens_refine_get l f;
-  put = lens_refine_put l f;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** Refining a pcm_lens *)
-
-let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
-
-let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
-  (y: refine_t (extend_refinement_f l re){composable p x y})
-: Lemma (extend_refinement_f l re (op p x y))
-= l.get_morphism.f_op x y;
-  re.f_closed_under_op (get l x) (get l y)
-
-let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q): refine_t (extend_refinement_f l re)
-= put l re.new_one (one p)
-
-let extend_refinement_new_one_is_refined_unit
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
-: Lemma (composable p x (extend_refinement_new_one l re) /\
-         op p x (extend_refinement_new_one l re) == x)
-= re.new_one_is_refined_unit (get l x);
-  p.is_unit x;
-  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
-  
-let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
-  f = extend_refinement_f l re;
-  f_closed_under_op = extend_refinement_f_closed l re;
-  new_one = extend_refinement_new_one l re;
-  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
-}
-
-let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_refine
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l.l re.f).get
-= l.get_morphism.f_refine
-
-let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_one
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l.l re.f).get
-= l.get_morphism.f_one
-
-let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_op
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l.l re.f).get
-= l.get_morphism.f_op
-
-let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_refine
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l.l re.f).put)
-= fun (v, s) -> l.put_morphism.f_refine (v, s)
-
-let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_one
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l.l re.f).put)
-= l.put_morphism.f_one
-
-let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_op
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l.l re.f).put)
-= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
-
-let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
-  l = lens_refine l.l re.f;
-  get_morphism = {
-    f_refine = pcm_lens_refine_get_morphism_refine l re;
-    f_one = pcm_lens_refine_get_morphism_one l re;
-    f_op = pcm_lens_refine_get_morphism_op l re;
-  };
-  put_morphism = {
-    f_refine = pcm_lens_refine_put_morphism_refine l re;
-    f_one = pcm_lens_refine_put_morphism_one l re;
-    f_op = pcm_lens_refine_put_morphism_op l re;
-  };
-}
   
 (** Isomorphisms *)
 
@@ -837,36 +844,119 @@ let conj_refinement_ok (#p: pcm 'a)
       assert (frame_pres p f''' (Ghost.reveal x) (Ghost.reveal y)));
   }
 
-let extend_refinement_ok_unrefine (r: ref 'a 'b)
-  (re: pcm_refinement r.q) (re_ok: pcm_refinement_ok re)
-: (refine_t (extend_refinement_f r.pl re) -> refine_t (extend_refinement_f r.pl re)) ->
-  refine_t r.re.f -> refine_t r.re.f
-= admit()
+(** The refinement of a ref *)
 
-let extend_refinement_ok (r: ref 'a 'b)
-  (re: pcm_refinement r.q) (re_ok: pcm_refinement_ok re)
-: pcm_refinement_ok (extend_refinement r.pl re)
-= let re' = extend_refinement r.pl re in
-  {
-    unrefine = extend_refinement_ok_unrefine r re re_ok;
-    frame_pres_unrefine = (fun f x y -> admit());
-  }
+(* TODO
+l: pcm_lens p q
+l_ext: pcm_lens_supports_extend l
+m: pcm_lens q r
+m_ext: pcm_lens_supports_extend m
+-----------------
+pcm_lens_supports_extend (pcm_lens_comp l m)
+should be able to just compose the unrefine functions and their proofs
+
+================================================================================
+
+i: iso p q
+l: pcm_lens q r
+l_ext: pcm_lens_supports_extend l
+---------------------------------
+pcm_lens_supports_extend (pcm_iso_lens_comp i l)
+
+i: iso p q
+l: pcm_lens q r
+l_ext: pcm_lens_supports_extend l
+re: pcm_refinement r
+re_ok: pcm_refinement_ok re
+---------------------------------
+pcm_refinement_ok (extend_refinement (pcm_iso_lens_comp i l) re)
+  unrefine = iso composed with re_ok's unrefine
+  unrefine frame preserving b/c re_ok's unrefine frame preserving and isos are frame preserving
+
+================================================================================
+
+l: pcm_lens p q
+l_ext: pcm_lens_supports_extend l
+re: pcm_refinement q
+------------------------------------------------
+pcm_lens_supports_extend (pcm_lens_refine l re)
+
+l: pcm_lens p q
+l_ext: pcm_lens_supports_extend l
+re: pcm_refinement q
+re_ok: pcm_refinement_ok re
+l_ext re re_ok: pcm_refinement_ok (extend_refinement l re)
+re': pcm_refinement (refined_pcm re)
+re'_ok: pcm_refinement_ok re'
+------------------------------------------------
+pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
+
+unrefine: Endo (re'.f . (pcm_lens_refine l re).get) -> Endo re.f
+
+re'_ok's unrefine:
+  Endo re'.f -> Endo re.f
+l_ext can get
+  Endo (re.f . l.get) -> Endo a
+how to get
+  Endo (re.f' . l.get) -> Endo (re.f . l.get)?
+
+l: pcm_lens p q
+l_ext: pcm_lens_supports_extend l
+re: pcm_refinement q
+re_ok: pcm_refinement_ok re
+l_ext re re_ok: pcm_refinement_ok (extend_refinement l re)
+re': pcm_refinement (refined_pcm re)
+re'_ok: pcm_refinement_ok re'
+conj_refinement re re': pcm_refinement q
+conj_refinement_ok re re' re_ok re'_ok: pcm_refinement_ok (conj_refinement re re')
+------------------------------------------------
+pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
+
+l: pcm_lens p q
+l_ext: pcm_lens_supports_extend l
+re: pcm_refinement q
+re_ok: pcm_refinement_ok re
+l_ext re re_ok: pcm_refinement_ok (extend_refinement l re)
+re': pcm_refinement (refined_pcm re)
+re'_ok: pcm_refinement_ok re'
+conj_refinement re re': pcm_refinement q
+conj_refinement_ok re re' re_ok re'_ok: pcm_refinement_ok (conj_refinement re re')
+l_ext (conj_refinement re re') (conj_refinement_ok ..): pcm_refinement_ok (extend_refinement l (conj_refinement re re'))
+------------------------------------------------
+pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
+
+is there a way to get from
+  pcm_refinement_ok (extend_refinement l (conj_refinement re re'))
+to
+  pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
+?
+
+==================================================
+
+pcm_lens_supports_extend (field k)
+  unrefine the update on the kth field, then apply it to the kth field
+
+==================================================
+
+pcm_lens_supports_extend (case k)
+  unrefine the update on the payload, then apply it to the payload
 
-(** The refinement of a ref *)
+*)
 
 let ref_refine (r: ref 'a 'b)
   (new_re: pcm_refinement r.q) (new_re_ok: pcm_refinement_ok new_re)
 : ref 'a (refine_t new_re.f) = {
   p = r.p;
   re = conj_refinement r.re (extend_refinement r.pl new_re);
-  re_ok =
-    conj_refinement_ok r.re (extend_refinement r.pl new_re) r.re_ok
-      (extend_refinement_ok r new_re new_re_ok);
   q = refined_pcm new_re;
   pl =
     pcm_iso_lens_comp
       (pcm_refinement_conj_iso r.p r.re (extend_refinement r.pl new_re))
       (pcm_lens_refine r.pl new_re);
+  re_ok =
+    conj_refinement_ok r.re (extend_refinement r.pl new_re)
+      r.re_ok (r.pl_ext new_re new_re_ok);
+  pl_ext = admit();
   r = r.r
 }
 
@@ -876,16 +966,17 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
-  {p = r.p; re = r.re; re_ok = r.re_ok; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
+let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (l_ext: pcm_lens_supports_extend l): ref 'a 'c =
+  {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; re_ok = r.re_ok; pl_ext = admit(); r = r.r}
 
-let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q)
+  (l_ext: pcm_lens_supports_extend l) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
     (to_vprop (r `pts_to` s))
     (fun r' -> to_vprop (r' `pts_to` x))
     (fun _ -> Ghost.reveal s == put l x (one r.q))
-    (fun _ r' _ -> r' == ref_focus r q l)
-= let r' = ref_focus r q l in
+    (fun _ r' _ -> r' == ref_focus r q l l_ext)
+= let r' = ref_focus r q l l_ext in
   A.change_slprop_rel  
     (to_vprop (r `pts_to` s))
     (to_vprop (r' `pts_to` x))
@@ -894,11 +985,12 @@ let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x
   A.return r'
 
 let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
-  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
+  (l: pcm_lens r'.q q)
+  (l_ext: pcm_lens_supports_extend l) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` x))
     (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == ref_focus r' q l)
+    (fun _ -> r == ref_focus r' q l l_ext)
     (fun _ _ _ -> True)
 = A.change_slprop_rel  
     (to_vprop (r `pts_to` x))
@@ -969,14 +1061,15 @@ let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
   l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
   split r x (put l (one q) x) (put l (get l x) (one r.q))
 
-let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q)
+  (l_ext: pcm_lens_supports_extend l) (x: Ghost.erased 'b)
 : SteelT (ref 'a 'c)
     (to_vprop (r `pts_to` x))
     (fun s ->
       to_vprop (r `pts_to` put l (one q) x) `star` 
       to_vprop (s `pts_to` get l x))
 = peel r q l x;
-  focus r q l (put l (get l x) (one r.q)) (get l x)
+  focus r q l l_ext (put l (get l x) (one r.q)) (get l x)
 
 let refine (r: ref 'a 'b)
   (re: pcm_refinement r.q)

From 87720d4390787c87ff176b28ae514fec09c911c3 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 05:03:42 -0700
Subject: [PATCH 041/513] More ext_refinement

---
 examples/steel/AggregateRef.fst | 49 +++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index b97c9227218..5a18b977c61 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -99,6 +99,17 @@ noeq type pcm_refinement #a (p: pcm a) = {
   new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
 
+(*
+noeq type pcm_refinement #a (p: pcm a) = {
+  new_one: a;
+  new_one_is_unit:
+    x:a{compatible p new_one x} -> Lemma (composable x new_one /\ op p x new_one == x);
+  compose_resp_compat:
+    x:a{composable p x new_one} ->
+    Lemma (op p x new_one == new_one \/ compatible p new_one x)
+}
+*)
+
 let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
 
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
@@ -846,6 +857,21 @@ let conj_refinement_ok (#p: pcm 'a)
 
 (** The refinement of a ref *)
 
+
+//  l: pcm_lens p q
+//  pcm_lens_supports_extend l
+//  re_l: pcm_refinement p
+//  re: pcm_refinement q
+//  re_ok: pcm_refinement_ok re
+//  ---------------------------------------------------
+//  pcm_refinement_ok (extend_refinement (pcm_lens_refine l re_l) re)
+//    f = re.f `compose` get (pcm_lens_refine l re_l)
+//      = re.f `compose` get l restricted to (re_l `compose` get l)
+//  want:
+//    unrefine: Endo (refine_t (re.f `compose` get l restricted to (re_l `compose` get l))) ->
+//              Endo (refine_t (re_l `compose` get l))
+
+
 (* TODO
 l: pcm_lens p q
 l_ext: pcm_lens_supports_extend l
@@ -878,6 +904,7 @@ pcm_refinement_ok (extend_refinement (pcm_iso_lens_comp i l) re)
 l: pcm_lens p q
 l_ext: pcm_lens_supports_extend l
 re: pcm_refinement q
+re_ok: pcm_refinement_ok re
 ------------------------------------------------
 pcm_lens_supports_extend (pcm_lens_refine l re)
 
@@ -931,6 +958,28 @@ to
   pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
 ?
 
+from pcm_refinement_ok (extend_refinement l (conj_refinement re re')) we have
+  unrefine: Endo (refine_t (conj_refinement_f re.f re'.f ○ get l)) -> Endo a
+  frame_pres_unrefine:
+    frame_pres (refined_pcm (conj_refinement re re')) f x y ->
+    frame_pres p (unrefine f) x y
+
+need:
+  unrefine: Endo (refine_t (re'.f ○ get l)) -> Endo (refine_t (re.f ○ get l))
+  frame_pres_unrefine:
+    frame_pres (refined_pcm re') f x y ->
+    frame_pres (refined_pcm re) (unrefine f) x y
+
+from re'_ok we have
+  unrefine: Endo (refined_pcm re') -> Endo (refined_pcm re)
+
+how about
+  extend_refinement l (conj_refinement re re')
+  ~= extend_refinement (pcm_lens_refine l re) re'
+
+extend_refinement l (conj_refinement re re'):
+  take conjunction of re and re', and then 
+
 ==================================================
 
 pcm_lens_supports_extend (field k)

From 558f6a78b617d38ee377923c27e4df1c2876577c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 06:42:30 -0700
Subject: [PATCH 042/513] pcm_refinement, take 4

---
 examples/steel/AggregateRef.fst | 217 +++++++++++++++++++++++---------
 1 file changed, 155 insertions(+), 62 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 5a18b977c61..a6802e92ecf 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -88,70 +88,103 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
-  new_one: refine_t f;
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
-}
-
-(*
-noeq type pcm_refinement #a (p: pcm a) = {
+  (** Choose an element new_one and let S be the set of elements compatible with it. *)
   new_one: a;
+  (** new_one must be a unit for S *)
   new_one_is_unit:
-    x:a{compatible p new_one x} -> Lemma (composable x new_one /\ op p x new_one == x);
-  compose_resp_compat:
+    x:a{compatible p new_one x} ->
+    Lemma (composable p x new_one /\ op p x new_one == x) [SMTPat (compatible p new_one x)];
+  (** S is closed under (op p) *)
+  closed_under_op:
+    x:a{compatible p new_one x} ->
+    y:a{compatible p new_one y /\ composable p x y} ->
+    Lemma (compatible p new_one (op p x y)) [SMTPat (composable p x y)];
+  (** Every element composable with new_one is either in S or a unit for S *)
+  comp_compat_new_one:
     x:a{composable p x new_one} ->
-    Lemma (op p x new_one == new_one \/ compatible p new_one x)
+    Lemma (
+      compatible p new_one x \/
+      (forall (y:a{compatible p new_one y}).{:pattern compatible p new_one y}
+       composable p y x /\ op p y x == y))
+      [SMTPat (composable p x new_one)];
+  (** S is decidable *)
+  compat_new_one: x:a -> b:bool{b <==> compatible p new_one x}
 }
-*)
-
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
 
+let pcm_refine_t (#p: pcm 'a) (r: pcm_refinement p) = x:'a{compatible p r.new_one x}
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (pcm_refine_t r) = composable p
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_under_op x y; op p x y
+  (x: pcm_refine_t r) (y: pcm_refine_t r{composable p x y}): pcm_refine_t r
+= let _ = r.closed_under_op in op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (pcm_refine_t r) = {
+  p = {
+    composable = pcm_refine_comp r;
+    op = pcm_refine_op r;
+    one = (compatible_refl p r.new_one; r.new_one)
+  };
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
   assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  is_unit = (fun x -> r.new_one_is_unit x);
   refine = p.refine;
 }
 
-let trivial_refinement (p: pcm 'a): pcm_refinement p = {
-  f = (fun x -> True);
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = one p;
-  new_one_is_refined_unit = p.is_unit;
-}
-
-(** A PCM refinement is well-formed if the refinement predicate is decidable
-    and frame-preserving updates on the refined PCM can be lifted to
+(** Frame-preserving updates on a refined PCM can be "unrefined" into
     frame-preserving updates on the unrefined PCM *)
 
-let unrefine_t (#p: pcm 'a) (r: pcm_refinement p) =
-  (refine_t r.f -> refine_t r.f) -> 'a -> 'a
-let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (unrefine: unrefine_t r) =
-  f:(refine_t r.f -> refine_t r.f) ->
-  x:Ghost.erased (refine_t r.f) ->
-  y:Ghost.erased (refine_t r.f) ->
-  Lemma
-    (requires frame_pres (refined_pcm r) f x y)
-    (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
-  
-noeq type pcm_refinement_ok #a (#p: pcm a) (r: pcm_refinement p) = {
-  unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
-  frame_pres_unrefine: frame_pres_unrefine_t r unrefine;
-}
+let unrefine_upd (#p: pcm 'a) (r: pcm_refinement p)
+  (x y: Ghost.erased (pcm_refine_t r))
+  (f:(pcm_refine_t r -> pcm_refine_t r){frame_pres (refined_pcm r) f x y})
+: g:('a -> 'a){frame_pres p g (Ghost.reveal x) (Ghost.reveal y)}
+= let g (v:'a): 'a = if r.compat_new_one v then f v else one p in
+  frame_pres_intro p g (Ghost.reveal x) (Ghost.reveal y) (fun v ->
+    assert (p.refine v);
+    assert (compatible p x v);
+    assume (compatible p r.new_one v);
+    (* by compatible p x v, exists frame s.t. v = x * frame.
+       since compatible p new_one x,
+         v = x * frame
+           = new_one * x * frame     (new_one unit for x)
+       thus compatible p new_one v. *)
+    assert ((refined_pcm r).refine v);
+    assume (compatible (refined_pcm r) x v);
+    (* v = new_one * x * frame       (as above)
+         = x * (new_one * frame_x)
+       so frame_x composable with new_one wrt p.
+       so either frame_x in S or frame_x unit for S.
+       - if in S, then (new_one * frame_x) in S
+         so v = x * something in S
+         so compatible (refined_pcm r) x v.
+       - if unit for S, then (new_one * frame_x) = new_one
+         so v = x * new_one = x * something in S
+         so compatible (refined_pcm r) x v. *)
+    (* now have enough to instantiate frame_pres f *)
+    assert (p.refine (g v));
+    assert (compatible p y (g v));
+    let aux (frame:'a{composable p x frame})
+    : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == g v))
+    = assert (composable p x frame);
+      (* x = new_one * x so can form the product
+           new_one * x * frame
+         by commutativity and associativity, can form
+           x * (new_one * frame)
+         so new_one is composable with frame.
+         so either frame in S or frame unit for S.
+         if frame in S, then can apply hypothesis about f: *)
+      assert (compatible p r.new_one frame ==> composable (refined_pcm r) x frame);
+      assume (compatible p r.new_one frame)
+      (* otherwise, frame unit for S and need to show
+           composable p y frame /\ (op p x frame == v ==> op p y frame == g v))
+         since frame unit for S, this equivalent to
+           composable p y new_unit /\ (op p x new_unit == v ==> op p y new_unit == g v))
+         which we can get from hypothesis about f. *)
+    in FStar.Classical.forall_intro aux);
+  g
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -301,34 +334,94 @@ let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
 
 (** Refining a pcm_lens *)
 
-let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q): 'a -> prop = re.f `compose` get l
-
-let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
-  (y: refine_t (extend_refinement_f l re){composable p x y})
-: Lemma (extend_refinement_f l re (op p x y))
-= l.get_morphism.f_op x y;
-  re.f_closed_under_op (get l x) (get l y)
-
 let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q): refine_t (extend_refinement_f l re)
+  (re: pcm_refinement q): 'a
 = put l re.new_one (one p)
 
-let extend_refinement_new_one_is_refined_unit
+let pcm_lens_compatible_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s t: 'a) (v w: 'b)
+: Lemma
+    (requires compatible p s t /\ compatible q v w)
+    (ensures compatible p (put l v s) (put l w t))
+= let goal = compatible p (put l v s) (put l w t) in
+  compatible_elim p s t goal (fun frame_s ->
+  compatible_elim q v w goal (fun frame_v ->
+  l.put_morphism.f_op (frame_v, frame_s) (v, s);
+  compatible_intro p (put l v s) (put l w t) (put l frame_v frame_s)))
+
+(* TODO tidy *)
+let extend_refinement_new_one_is_unit
   (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+  (re: pcm_refinement q) (x:'a{compatible p (extend_refinement_new_one l re) x})
 : Lemma (composable p x (extend_refinement_new_one l re) /\
          op p x (extend_refinement_new_one l re) == x)
-= re.new_one_is_refined_unit (get l x);
+= assert (x == put l (get l x) x);
+  pcm_lens_compatible_get l (extend_refinement_new_one l re) x;
+  re.new_one_is_unit (get l x); assert (composable q re.new_one (get l x));
+  p.is_unit x; assert (composable p (one p) x);
+  l.put_morphism.f_op (re.new_one, one p) (get l x, x);
+  l.get_morphism.f_op (extend_refinement_new_one l re) x;
+  re.new_one_is_unit (get l x);
   p.is_unit x;
   l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+
+let extend_refinement_closed_under_op
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q)
+  (x:'a{compatible p (extend_refinement_new_one l re) x})
+  (y:'a{compatible p (extend_refinement_new_one l re) y /\ composable p x y})
+: Lemma (compatible p (extend_refinement_new_one l re) (op p x y))
+= let goal = compatible p (extend_refinement_new_one l re) (op p x y) in
+  compatible_elim p (extend_refinement_new_one l re) x goal (fun frame_x ->
+  compatible_elim p (extend_refinement_new_one l re) y goal (fun frame_y ->
+  (* put new_one one * frame_x = x
+     put new_one one * frame_y = y
+     ==> x * y
+       = (put new_one one * frame_x) * (put new_one one * frame_y)
+       = (put new_one one * put new_one one) * (frame_x * frame_y)
+       = put (new_one * new_one) (one * one) * (frame_x * frame_y)
+       = put new_one one * (frame_x * frame_y)
+     thus (frame_x * frame_y) witnesses (compatible p (put new_one one) (x * y)) *)
+  compatible_intro p (extend_refinement_new_one l re) (op p x y) (admit())))
+
+let extend_refinement_comp_compat_new_one
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q)
+  (x:'a{composable p x (extend_refinement_new_one l re)})
+: Lemma (
+    compatible p (extend_refinement_new_one l re) x \/
+    (forall (y:'a{compatible p (extend_refinement_new_one l re) y}).
+      composable p y x /\ op p y x == y))
+= admit()
+(*
+  suppose x composable with put new_one one
+  then get x composable with new_one.
+  then either compatible q new_one (get x)
+  or (get x) is a unit for elements compatible with new_one
+
+  if compatible q new_one (get x),
+  then
+    compatible q (put new_one one) (put (get x) x)
+    (because put morphism and compatible p one x for all x)
+    so compatible q (put new_one one) x.
+
+  if (get x) is a unit for elements compatible with new_one,
   
+*)
+
+  // (** Every element composable with new_one is either in S or a unit for S *)
+  // comp_compat_new_one:
+  //   x:a{composable p x new_one} ->
+  //   Lemma (
+  //     compatible p new_one x \/
+  //     (forall (y:a{compatible p new_one y}).{:pattern compatible p new_one y}
+  //      composable p y x /\ op p y x == y))
+  //     [SMTPat (composable p x new_one)];
 let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
-  f = extend_refinement_f l re;
-  f_closed_under_op = extend_refinement_f_closed l re;
   new_one = extend_refinement_new_one l re;
-  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+  new_one_is_unit = extend_refinement_new_one_is_unit l re;
+  closed_under_op = extend_refinement_closed_under_op l re;
+  comp_compat_new_one = admit();
+  compat_new_one = (fun s -> re.compat_new_one (get l s));
 }
 
 let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)

From 374d01916f74d7ccaa07982582c68e3e1a28d029 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 08:24:03 -0700
Subject: [PATCH 043/513] Sketch ref_upd

---
 examples/steel/AggregateRef.fst | 826 +++++++++++---------------------
 1 file changed, 273 insertions(+), 553 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index a6802e92ecf..31c869d9438 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -88,103 +88,75 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement #a (p: pcm a) = {
-  (** Choose an element new_one and let S be the set of elements compatible with it. *)
-  new_one: a;
-  (** new_one must be a unit for S *)
-  new_one_is_unit:
-    x:a{compatible p new_one x} ->
-    Lemma (composable p x new_one /\ op p x new_one == x) [SMTPat (compatible p new_one x)];
-  (** S is closed under (op p) *)
-  closed_under_op:
-    x:a{compatible p new_one x} ->
-    y:a{compatible p new_one y /\ composable p x y} ->
-    Lemma (compatible p new_one (op p x y)) [SMTPat (composable p x y)];
-  (** Every element composable with new_one is either in S or a unit for S *)
-  comp_compat_new_one:
-    x:a{composable p x new_one} ->
-    Lemma (
-      compatible p new_one x \/
-      (forall (y:a{compatible p new_one y}).{:pattern compatible p new_one y}
-       composable p y x /\ op p y x == y))
-      [SMTPat (composable p x new_one)];
-  (** S is decidable *)
-  compat_new_one: x:a -> b:bool{b <==> compatible p new_one x}
+  f: a -> prop;
+  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
+  new_one: refine_t f;
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
 
-let pcm_refine_t (#p: pcm 'a) (r: pcm_refinement p) = x:'a{compatible p r.new_one x}
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (pcm_refine_t r) = composable p
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
-  (x: pcm_refine_t r) (y: pcm_refine_t r{composable p x y}): pcm_refine_t r
-= let _ = r.closed_under_op in op p x y
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_under_op x y; op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (pcm_refine_t r) = {
-  p = {
-    composable = pcm_refine_comp r;
-    op = pcm_refine_op r;
-    one = (compatible_refl p r.new_one; r.new_one)
-  };
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
   assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_unit x);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
   refine = p.refine;
 }
 
-(** Frame-preserving updates on a refined PCM can be "unrefined" into
-    frame-preserving updates on the unrefined PCM *)
-
-let unrefine_upd (#p: pcm 'a) (r: pcm_refinement p)
-  (x y: Ghost.erased (pcm_refine_t r))
-  (f:(pcm_refine_t r -> pcm_refine_t r){frame_pres (refined_pcm r) f x y})
-: g:('a -> 'a){frame_pres p g (Ghost.reveal x) (Ghost.reveal y)}
-= let g (v:'a): 'a = if r.compat_new_one v then f v else one p in
-  frame_pres_intro p g (Ghost.reveal x) (Ghost.reveal y) (fun v ->
-    assert (p.refine v);
-    assert (compatible p x v);
-    assume (compatible p r.new_one v);
-    (* by compatible p x v, exists frame s.t. v = x * frame.
-       since compatible p new_one x,
-         v = x * frame
-           = new_one * x * frame     (new_one unit for x)
-       thus compatible p new_one v. *)
-    assert ((refined_pcm r).refine v);
-    assume (compatible (refined_pcm r) x v);
-    (* v = new_one * x * frame       (as above)
-         = x * (new_one * frame_x)
-       so frame_x composable with new_one wrt p.
-       so either frame_x in S or frame_x unit for S.
-       - if in S, then (new_one * frame_x) in S
-         so v = x * something in S
-         so compatible (refined_pcm r) x v.
-       - if unit for S, then (new_one * frame_x) = new_one
-         so v = x * new_one = x * something in S
-         so compatible (refined_pcm r) x v. *)
-    (* now have enough to instantiate frame_pres f *)
-    assert (p.refine (g v));
-    assert (compatible p y (g v));
-    let aux (frame:'a{composable p x frame})
-    : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == g v))
-    = assert (composable p x frame);
-      (* x = new_one * x so can form the product
-           new_one * x * frame
-         by commutativity and associativity, can form
-           x * (new_one * frame)
-         so new_one is composable with frame.
-         so either frame in S or frame unit for S.
-         if frame in S, then can apply hypothesis about f: *)
-      assert (compatible p r.new_one frame ==> composable (refined_pcm r) x frame);
-      assume (compatible p r.new_one frame)
-      (* otherwise, frame unit for S and need to show
-           composable p y frame /\ (op p x frame == v ==> op p y frame == g v))
-         since frame unit for S, this equivalent to
-           composable p y new_unit /\ (op p x new_unit == v ==> op p y new_unit == g v))
-         which we can get from hypothesis about f. *)
-    in FStar.Classical.forall_intro aux);
-  g
+let trivial_refinement (p: pcm 'a): pcm_refinement p = {
+  f = (fun x -> True);
+  f_closed_under_op = (fun _ _ -> ());
+  new_one = one p;
+  new_one_is_refined_unit = p.is_unit;
+}
+
+(** A PCM refinement is well-formed if frame-preserving updates on the
+    refined PCM can be turned to frame-preserving updates on the
+    unrefined PCM *)
+
+(*
+let frame_pres_lift (p: pcm 'a) (x y: 'b) (q: pcm 'b) (x' y': 'a)
+= f:('b -> 'b){frame_pres q f x y} -> 
+  g:('a -> 'a){frame_pres p g x' y'}
+*)
+(* admit() delete
+let  *)
+(* todo: can combine these two into a dependently typed function
+   which takes frame-preserving fs to frame-presrving gs *)
+let unrefine_t (#p: pcm 'a) (r: pcm_refinement p) =
+  (refine_t r.f -> refine_t r.f) -> 'a -> 'a
+let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (unrefine: unrefine_t r) =
+  f:(refine_t r.f -> refine_t r.f) ->
+  x:Ghost.erased (refine_t r.f) ->
+  y:Ghost.erased (refine_t r.f) ->
+  Lemma
+    (requires frame_pres (refined_pcm r) f x y)
+    (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
+ (*   *)
+
+(*
+noeq type pcm_unrefinement #a (#p: pcm a) (r: pcm_refinement p) =
+  x: Ghost.erased (refine_t r.f) ->
+  y: Ghost.erased (refine_t r.f) ->
+  frame_pres_lift *)
+  
+{
+  unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
+  frame_pres_unrefine: frame_pres_unrefine_t r unrefine;
+}
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -314,185 +286,6 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
   };
 }
 
-(** Refining a lens *)
-
-let lens_refine_get (l: lens 'a 'b) f
-  (s: refine_t (f `compose` l.get)): refine_t f
-= l.get s
-let lens_refine_put (l: lens 'a 'b) f
-  (v: refine_t f) (s: refine_t (f `compose` l.get)): refine_t (f `compose` l.get)
-= l.put v s
-
-let lens_refine (l: lens 'a 'b) (f: 'b -> prop)
-: lens (refine_t (f `compose` l.get)) (refine_t f) = {
-  get = lens_refine_get l f;
-  put = lens_refine_put l f;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** Refining a pcm_lens *)
-
-let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q): 'a
-= put l re.new_one (one p)
-
-let pcm_lens_compatible_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s t: 'a) (v w: 'b)
-: Lemma
-    (requires compatible p s t /\ compatible q v w)
-    (ensures compatible p (put l v s) (put l w t))
-= let goal = compatible p (put l v s) (put l w t) in
-  compatible_elim p s t goal (fun frame_s ->
-  compatible_elim q v w goal (fun frame_v ->
-  l.put_morphism.f_op (frame_v, frame_s) (v, s);
-  compatible_intro p (put l v s) (put l w t) (put l frame_v frame_s)))
-
-(* TODO tidy *)
-let extend_refinement_new_one_is_unit
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x:'a{compatible p (extend_refinement_new_one l re) x})
-: Lemma (composable p x (extend_refinement_new_one l re) /\
-         op p x (extend_refinement_new_one l re) == x)
-= assert (x == put l (get l x) x);
-  pcm_lens_compatible_get l (extend_refinement_new_one l re) x;
-  re.new_one_is_unit (get l x); assert (composable q re.new_one (get l x));
-  p.is_unit x; assert (composable p (one p) x);
-  l.put_morphism.f_op (re.new_one, one p) (get l x, x);
-  l.get_morphism.f_op (extend_refinement_new_one l re) x;
-  re.new_one_is_unit (get l x);
-  p.is_unit x;
-  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
-
-let extend_refinement_closed_under_op
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q)
-  (x:'a{compatible p (extend_refinement_new_one l re) x})
-  (y:'a{compatible p (extend_refinement_new_one l re) y /\ composable p x y})
-: Lemma (compatible p (extend_refinement_new_one l re) (op p x y))
-= let goal = compatible p (extend_refinement_new_one l re) (op p x y) in
-  compatible_elim p (extend_refinement_new_one l re) x goal (fun frame_x ->
-  compatible_elim p (extend_refinement_new_one l re) y goal (fun frame_y ->
-  (* put new_one one * frame_x = x
-     put new_one one * frame_y = y
-     ==> x * y
-       = (put new_one one * frame_x) * (put new_one one * frame_y)
-       = (put new_one one * put new_one one) * (frame_x * frame_y)
-       = put (new_one * new_one) (one * one) * (frame_x * frame_y)
-       = put new_one one * (frame_x * frame_y)
-     thus (frame_x * frame_y) witnesses (compatible p (put new_one one) (x * y)) *)
-  compatible_intro p (extend_refinement_new_one l re) (op p x y) (admit())))
-
-let extend_refinement_comp_compat_new_one
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q)
-  (x:'a{composable p x (extend_refinement_new_one l re)})
-: Lemma (
-    compatible p (extend_refinement_new_one l re) x \/
-    (forall (y:'a{compatible p (extend_refinement_new_one l re) y}).
-      composable p y x /\ op p y x == y))
-= admit()
-(*
-  suppose x composable with put new_one one
-  then get x composable with new_one.
-  then either compatible q new_one (get x)
-  or (get x) is a unit for elements compatible with new_one
-
-  if compatible q new_one (get x),
-  then
-    compatible q (put new_one one) (put (get x) x)
-    (because put morphism and compatible p one x for all x)
-    so compatible q (put new_one one) x.
-
-  if (get x) is a unit for elements compatible with new_one,
-  
-*)
-
-  // (** Every element composable with new_one is either in S or a unit for S *)
-  // comp_compat_new_one:
-  //   x:a{composable p x new_one} ->
-  //   Lemma (
-  //     compatible p new_one x \/
-  //     (forall (y:a{compatible p new_one y}).{:pattern compatible p new_one y}
-  //      composable p y x /\ op p y x == y))
-  //     [SMTPat (composable p x new_one)];
-let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
-  new_one = extend_refinement_new_one l re;
-  new_one_is_unit = extend_refinement_new_one_is_unit l re;
-  closed_under_op = extend_refinement_closed_under_op l re;
-  comp_compat_new_one = admit();
-  compat_new_one = (fun s -> re.compat_new_one (get l s));
-}
-
-let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_refine
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l.l re.f).get
-= l.get_morphism.f_refine
-
-let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_one
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l.l re.f).get
-= l.get_morphism.f_one
-
-let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_op
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l.l re.f).get
-= l.get_morphism.f_op
-
-let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_refine
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l.l re.f).put)
-= fun (v, s) -> l.put_morphism.f_refine (v, s)
-
-let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_one
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l.l re.f).put)
-= l.put_morphism.f_one
-
-let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: morphism_op
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l.l re.f).put)
-= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
-
-let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
-  l = lens_refine l.l re.f;
-  get_morphism = {
-    f_refine = pcm_lens_refine_get_morphism_refine l re;
-    f_one = pcm_lens_refine_get_morphism_one l re;
-    f_op = pcm_lens_refine_get_morphism_op l re;
-  };
-  put_morphism = {
-    f_refine = pcm_lens_refine_put_morphism_refine l re;
-    f_one = pcm_lens_refine_put_morphism_one l re;
-    f_op = pcm_lens_refine_put_morphism_op l re;
-  };
-}
-
-let pcm_lens_supports_extend (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) =
-  re: pcm_refinement q ->
-  re_ok: pcm_refinement_ok re ->
-  pcm_refinement_ok (extend_refinement l re)
-
 open FStar.FunctionalExtensionality
 
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
@@ -501,10 +294,9 @@ open FStar.FunctionalExtensionality
 noeq type ref (a:Type) (b:Type): Type = {
   p: pcm a;
   re: pcm_refinement p;
+  u: pcm_unrefinement re;
   q: pcm b;
   pl: pcm_lens (refined_pcm re) q;
-  re_ok: pcm_refinement_ok re;
-  pl_ext: pcm_lens_supports_extend pl;
   r: Steel.Memory.ref a p;
 }
 
@@ -644,22 +436,22 @@ let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (union_pcm p
   new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
 }
 
-let case_refinement_ok_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let case_unrefinement_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
   (kx: union b): union b
 = match kx with
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
-(* TODO tidy *)
-let case_refinement_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-: pcm_refinement_ok (case_refinement p k) = {
-  unrefine = case_refinement_ok_unrefine p k;
+(* admit() tidy *)
+let case_unrefinement (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+: pcm_unrefinement (case_refinement p k) = {
+  unrefine = case_unrefinement_unrefine p k;
   frame_pres_unrefine = (fun f kx ky ->
     let Some (|_, x|) = Ghost.reveal kx in
     let Some (|_, y|) = Ghost.reveal ky in
     let p' = refined_pcm (case_refinement p k) in
-    frame_pres_intro (union_pcm p) (case_refinement_ok_unrefine p k f)
+    frame_pres_intro (union_pcm p) (case_unrefinement_unrefine p k f)
       (Ghost.reveal kx) (Ghost.reveal ky)
       (fun kv -> match kv with
         | Some (|k', v|) -> 
@@ -724,6 +516,125 @@ let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
+
+(** Refining a pcm_lens *)
+
+let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: 'a): prop
+= re.f (get l x) /\ x == put l (get l x) (one p)
+
+let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (s: refine_t (extend_refinement_f l re))
+: refine_t re.f
+= l.l.get s
+
+let lens_refine_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q)
+  (v: refine_t re.f) (s: refine_t (extend_refinement_f l re))
+: refine_t (extend_refinement_f l re)
+= l.l.put v s
+
+let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement q)
+: lens (refine_t (extend_refinement_f l re)) (refine_t re.f) = {
+  get = lens_refine_get l re;
+  put = lens_refine_put l re;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+  (y: refine_t (extend_refinement_f l re){composable p x y})
+: Lemma (extend_refinement_f l re (op p x y))
+= l.get_morphism.f_op x y;
+  re.f_closed_under_op (get l x) (get l y);
+  assume (op p x y == put l (get l (op p x y)) (one p))
+  (* get put morphism plus the fact that (one p = one p * one p) *)
+
+let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q): refine_t (extend_refinement_f l re)
+= put l re.new_one (one p)
+
+let extend_refinement_new_one_is_refined_unit
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+: Lemma (composable p x (extend_refinement_new_one l re) /\
+         op p x (extend_refinement_new_one l re) == x)
+= re.new_one_is_refined_unit (get l x);
+  p.is_unit x;
+  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+  
+let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
+  f = extend_refinement_f l re;
+  f_closed_under_op = extend_refinement_f_closed l re;
+  new_one = extend_refinement_new_one l re;
+  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+}
+
+let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_refine
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l re).get
+= l.get_morphism.f_refine
+
+let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_one
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l re).get
+= l.get_morphism.f_one
+
+let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_op
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l re).get
+= l.get_morphism.f_op
+
+let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_refine
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l re).put)
+= fun (v, s) -> l.put_morphism.f_refine (v, s)
+
+let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_one
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l re).put)
+= l.put_morphism.f_one
+
+let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: morphism_op
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l re).put)
+= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
+
+let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
+  l = lens_refine l re;
+  get_morphism = {
+    f_refine = pcm_lens_refine_get_morphism_refine l re;
+    f_one = pcm_lens_refine_get_morphism_one l re;
+    f_op = pcm_lens_refine_get_morphism_op l re;
+  };
+  put_morphism = {
+    f_refine = pcm_lens_refine_put_morphism_refine l re;
+    f_one = pcm_lens_refine_put_morphism_one l re;
+    f_op = pcm_lens_refine_put_morphism_op l re;
+  };
+}
   
 (** Isomorphisms *)
 
@@ -886,7 +797,6 @@ suppose compatible q (i.i.fwd x) v
 and q.refine v.
 suppose
   frame_pres p f x y
-
 to show q.refine (f' v):
   f' v = fwd (f (bwd v))
   q.refine v by assumption
@@ -895,14 +805,12 @@ to show q.refine (f' v):
     need show compatible p x (bwd v)
     easy: compatible p (fwd x) v ==> compatible p (bwd (fwd x)) (bwd v) b/c bwd is pcm morphism
   p.refine (fwd (f (bwd v))) b/c fwd is morphism
-
 to show compatible q (fwd y) (f' v):
   f'v = fwd (f (bwd v))
   so need show compatible q (fwd y) (fwd (f (bwd v)))
   suff. to show compatible q y (f (bwd v)) b/c fwd is pcm morphism
   since we have refine (bwd v) /\ compatible p x (bwd v) (proof is same as in previous subcase),
     we know compatible q y (f (bwd v)) b/c f is frame-preserving
-
 fix frame where composable q (fwd x) frame.
 to show composable q (fwd y) frame /\ (op q (fwd x) frame == v ==> op q (fwd y) frame == f' v == fwd (f (bwd v))):
   we have composable q (bwd (fwd x)) (bwd frame) <==> composable q x (bwd frame) b/c bwd is morphism
@@ -919,21 +827,21 @@ to show composable q (fwd y) frame /\ (op q (fwd x) frame == v ==> op q (fwd y)
 qed
 *)
 
-let conj_refinement_ok_unrefine (#p: pcm 'a)
+let conj_unrefinement_unrefine (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-  (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
+  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : (refine_t (conj_refinement_f #'a re1 re2) -> refine_t (conj_refinement_f #'a re1 re2)) ->
   'a -> 'a
 = h1.unrefine `compose` h2.unrefine `compose` upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2)
 
-let conj_refinement_ok (#p: pcm 'a)
+let conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-  (h1: pcm_refinement_ok re1) (h2: pcm_refinement_ok re2)
-: pcm_refinement_ok (conj_refinement #'a re1 re2)
+  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
+: pcm_unrefinement (conj_refinement #'a re1 re2)
 = let re = conj_refinement #'a re1 re2 in
   let i = pcm_refinement_conj_iso p re1 re2 in
   {
-    unrefine = conj_refinement_ok_unrefine re1 re2 h1 h2;
+    unrefine = conj_unrefinement_unrefine re1 re2 h1 h2;
     frame_pres_unrefine = (fun f x y ->
       assert (frame_pres (refined_pcm (conj_refinement #'a re1 re2)) f x y); 
       let f': refine_t re2.f -> refine_t re2.f = upd_across_pcm_iso i f in
@@ -948,157 +856,48 @@ let conj_refinement_ok (#p: pcm 'a)
       assert (frame_pres p f''' (Ghost.reveal x) (Ghost.reveal y)));
   }
 
-(** The refinement of a ref *)
-
+let extend_unrefinement_unrefine (r: ref 'a 'b)
+  (re: pcm_refinement r.q) (u: pcm_unrefinement re)
+: (refine_t (extend_refinement_f r.pl re) -> refine_t (extend_refinement_f r.pl re)) ->
+  refine_t r.re.f -> refine_t r.re.f
+= admit()
 
-//  l: pcm_lens p q
-//  pcm_lens_supports_extend l
-//  re_l: pcm_refinement p
-//  re: pcm_refinement q
-//  re_ok: pcm_refinement_ok re
-//  ---------------------------------------------------
-//  pcm_refinement_ok (extend_refinement (pcm_lens_refine l re_l) re)
-//    f = re.f `compose` get (pcm_lens_refine l re_l)
-//      = re.f `compose` get l restricted to (re_l `compose` get l)
-//  want:
-//    unrefine: Endo (refine_t (re.f `compose` get l restricted to (re_l `compose` get l))) ->
-//              Endo (refine_t (re_l `compose` get l))
-
-
-(* TODO
-l: pcm_lens p q
-l_ext: pcm_lens_supports_extend l
-m: pcm_lens q r
-m_ext: pcm_lens_supports_extend m
------------------
-pcm_lens_supports_extend (pcm_lens_comp l m)
-should be able to just compose the unrefine functions and their proofs
-
-================================================================================
-
-i: iso p q
-l: pcm_lens q r
-l_ext: pcm_lens_supports_extend l
----------------------------------
-pcm_lens_supports_extend (pcm_iso_lens_comp i l)
-
-i: iso p q
-l: pcm_lens q r
-l_ext: pcm_lens_supports_extend l
-re: pcm_refinement r
-re_ok: pcm_refinement_ok re
----------------------------------
-pcm_refinement_ok (extend_refinement (pcm_iso_lens_comp i l) re)
-  unrefine = iso composed with re_ok's unrefine
-  unrefine frame preserving b/c re_ok's unrefine frame preserving and isos are frame preserving
-
-================================================================================
-
-l: pcm_lens p q
-l_ext: pcm_lens_supports_extend l
-re: pcm_refinement q
-re_ok: pcm_refinement_ok re
-------------------------------------------------
-pcm_lens_supports_extend (pcm_lens_refine l re)
-
-l: pcm_lens p q
-l_ext: pcm_lens_supports_extend l
-re: pcm_refinement q
-re_ok: pcm_refinement_ok re
-l_ext re re_ok: pcm_refinement_ok (extend_refinement l re)
-re': pcm_refinement (refined_pcm re)
-re'_ok: pcm_refinement_ok re'
-------------------------------------------------
-pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
-
-unrefine: Endo (re'.f . (pcm_lens_refine l re).get) -> Endo re.f
-
-re'_ok's unrefine:
-  Endo re'.f -> Endo re.f
-l_ext can get
-  Endo (re.f . l.get) -> Endo a
-how to get
-  Endo (re.f' . l.get) -> Endo (re.f . l.get)?
-
-l: pcm_lens p q
-l_ext: pcm_lens_supports_extend l
-re: pcm_refinement q
-re_ok: pcm_refinement_ok re
-l_ext re re_ok: pcm_refinement_ok (extend_refinement l re)
-re': pcm_refinement (refined_pcm re)
-re'_ok: pcm_refinement_ok re'
-conj_refinement re re': pcm_refinement q
-conj_refinement_ok re re' re_ok re'_ok: pcm_refinement_ok (conj_refinement re re')
-------------------------------------------------
-pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
-
-l: pcm_lens p q
-l_ext: pcm_lens_supports_extend l
-re: pcm_refinement q
-re_ok: pcm_refinement_ok re
-l_ext re re_ok: pcm_refinement_ok (extend_refinement l re)
-re': pcm_refinement (refined_pcm re)
-re'_ok: pcm_refinement_ok re'
-conj_refinement re re': pcm_refinement q
-conj_refinement_ok re re' re_ok re'_ok: pcm_refinement_ok (conj_refinement re re')
-l_ext (conj_refinement re re') (conj_refinement_ok ..): pcm_refinement_ok (extend_refinement l (conj_refinement re re'))
-------------------------------------------------
-pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
-
-is there a way to get from
-  pcm_refinement_ok (extend_refinement l (conj_refinement re re'))
-to
-  pcm_refinement_ok (extend_refinement (pcm_lens_refine l re) re')
-?
-
-from pcm_refinement_ok (extend_refinement l (conj_refinement re re')) we have
-  unrefine: Endo (refine_t (conj_refinement_f re.f re'.f ○ get l)) -> Endo a
-  frame_pres_unrefine:
-    frame_pres (refined_pcm (conj_refinement re re')) f x y ->
-    frame_pres p (unrefine f) x y
-
-need:
-  unrefine: Endo (refine_t (re'.f ○ get l)) -> Endo (refine_t (re.f ○ get l))
-  frame_pres_unrefine:
-    frame_pres (refined_pcm re') f x y ->
-    frame_pres (refined_pcm re) (unrefine f) x y
-
-from re'_ok we have
-  unrefine: Endo (refined_pcm re') -> Endo (refined_pcm re)
-
-how about
-  extend_refinement l (conj_refinement re re')
-  ~= extend_refinement (pcm_lens_refine l re) re'
-
-extend_refinement l (conj_refinement re re'):
-  take conjunction of re and re', and then 
-
-==================================================
-
-pcm_lens_supports_extend (field k)
-  unrefine the update on the kth field, then apply it to the kth field
-
-==================================================
-
-pcm_lens_supports_extend (case k)
-  unrefine the update on the payload, then apply it to the payload
+let extend_unrefinement (#p: pcm 'a) (#q: pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
+: pcm_unrefinement (extend_refinement l re) = {
+  unrefine =
+    (let _: (refine_t re.f -> refine_t re.f) -> ('b -> 'b) = u.unrefine in
+    let ans:
+     (refine_t (extend_refinement_f l re) -> refine_t (extend_refinement_f l re)) ->
+     ('a -> 'a) = admit() in
+     (* endo (extend_refinement_f l re) --> endo (refine_t re.f)
+          doable because we know that extend_refinement_f l re works with
+          values of the form (put x one) where re.f x
+          should be frame-preserving
+        endo (refine_t re.f) --> endo 'b
+          by u.unrefine, frame preserving by assumption
+        endo 'b --> endo 'a
+          by upd, frame preserving because pcm_lens lifts frame-preserving updates
+          to frame-preserving updates *)
+    ans);
+  frame_pres_unrefine = admit();
+}
 
-*)
+(** The refinement of a ref *)
 
 let ref_refine (r: ref 'a 'b)
-  (new_re: pcm_refinement r.q) (new_re_ok: pcm_refinement_ok new_re)
+  (new_re: pcm_refinement r.q) (new_u: pcm_unrefinement new_re)
 : ref 'a (refine_t new_re.f) = {
   p = r.p;
   re = conj_refinement r.re (extend_refinement r.pl new_re);
+  u =
+    conj_unrefinement r.re (extend_refinement r.pl new_re) r.u
+      (extend_unrefinement r.pl new_re new_u);
   q = refined_pcm new_re;
   pl =
     pcm_iso_lens_comp
       (pcm_refinement_conj_iso r.p r.re (extend_refinement r.pl new_re))
       (pcm_lens_refine r.pl new_re);
-  re_ok =
-    conj_refinement_ok r.re (extend_refinement r.pl new_re)
-      r.re_ok (r.pl_ext new_re new_re_ok);
-  pl_ext = admit();
   r = r.r
 }
 
@@ -1108,17 +907,16 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (l_ext: pcm_lens_supports_extend l): ref 'a 'c =
-  {p = r.p; re = r.re; q = q; pl = pcm_lens_comp r.pl l; re_ok = r.re_ok; pl_ext = admit(); r = r.r}
+let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
+  {p = r.p; re = r.re; u = r.u; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
-let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q)
-  (l_ext: pcm_lens_supports_extend l) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
     (to_vprop (r `pts_to` s))
     (fun r' -> to_vprop (r' `pts_to` x))
     (fun _ -> Ghost.reveal s == put l x (one r.q))
-    (fun _ r' _ -> r' == ref_focus r q l l_ext)
-= let r' = ref_focus r q l l_ext in
+    (fun _ r' _ -> r' == ref_focus r q l)
+= let r' = ref_focus r q l in
   A.change_slprop_rel  
     (to_vprop (r `pts_to` s))
     (to_vprop (r' `pts_to` x))
@@ -1127,12 +925,11 @@ let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q)
   A.return r'
 
 let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
-  (l: pcm_lens r'.q q)
-  (l_ext: pcm_lens_supports_extend l) (x: Ghost.erased 'c)
+  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` x))
     (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == ref_focus r' q l l_ext)
+    (fun _ -> r == ref_focus r' q l)
     (fun _ _ _ -> True)
 = A.change_slprop_rel  
     (to_vprop (r `pts_to` x))
@@ -1203,39 +1000,80 @@ let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
   l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
   split r x (put l (one q) x) (put l (get l x) (one r.q))
 
-let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q)
-  (l_ext: pcm_lens_supports_extend l) (x: Ghost.erased 'b)
+let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
 : SteelT (ref 'a 'c)
     (to_vprop (r `pts_to` x))
     (fun s ->
       to_vprop (r `pts_to` put l (one q) x) `star` 
       to_vprop (s `pts_to` get l x))
 = peel r q l x;
-  focus r q l l_ext (put l (get l x) (one r.q)) (get l x)
+  focus r q l (put l (get l x) (one r.q)) (get l x)
 
 let refine (r: ref 'a 'b)
   (re: pcm_refinement r.q)
-  (re_ok: pcm_refinement_ok re)
+  (u: pcm_unrefinement re)
   (x: Ghost.erased 'b{re.f x})
 : Steel (ref 'a (refine_t re.f))
     (to_vprop (r `pts_to` x))
     (fun r' -> to_vprop (r' `pts_to` Ghost.reveal x))
     (fun _ -> True)
-    (fun _ r' _ -> r' == ref_refine r re re_ok)
-= let r' = ref_refine r re re_ok in
+    (fun _ r' _ -> r' == ref_refine r re u)
+= let r' = ref_refine r re u in
   change_equal_vprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
 let unrefine #inames (r': ref 'a 'b)
-  (re: pcm_refinement r'.q) (re_ok: pcm_refinement_ok re)
+  (re: pcm_refinement r'.q) (u: pcm_unrefinement re)
   (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` Ghost.reveal x))
     (fun _ -> to_vprop (r' `pts_to` x))
-    (fun _ -> r == ref_refine r' re re_ok)
+    (fun _ -> r == ref_refine r' re u)
     (fun _ _ _ -> True)
 = change_equal_vprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
+let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
+  (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+: frame_preserving_upd r.p
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)))
+= pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f;
+  r.u.frame_pres_unrefine (upd r.pl f)
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  frame_pres_mk_upd r.p
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)))
+    (r.u.unrefine (upd r.pl f))
+
+(*
+let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+: M.action_except unit Set.empty (r `pts_to` x) (fun _ -> r `pts_to` y)
+= let f': refine_t r.re.f -> refine_t r.re.f = upd r.pl f in
+  let hf'
+  : squash (frame_pres (refined_pcm r.re) f'
+      (put r.pl x (one (refined_pcm r.re)))
+      (put r.pl y (one (refined_pcm r.re))))
+  = pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f in
+  M.upd_gen Set.empty r.r x y (frame_pres_mk_upd (refined_pcm r.re)
+      (put r.pl x (one (refined_pcm r.re)))
+      (put r.pl y (one (refined_pcm r.re)))
+  f' hf')
+let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+: SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
+= let f': 'a -> 'a = upd r.pl f in
+  let hf'
+  : frame_pres r.p f'
+      (put x (one (refined_pcm r.re)))
+      (put y (one (refined_pcm r.re)))
+  = pcm_lens_frame_pres r.p r.q r.pl (put x (one (refined_pcm r.re))) y f' in
+  let act : M.action_except unit Set.empty _ _ = M.upd_gen Set.empty r.r x y (frame_pres_mk_upd r.p
+      (put x (one (refined_pcm r.re)))
+      (put y (one (refined_pcm r.re)))
+  f' hf') in
+  as_action act
+  *)
+
 (** Example: a model for a tagged union representing colors in RGB or HSV
       type color =
         | RGB : r:int -> g:int -> b:int -> color
@@ -1290,121 +1128,3 @@ let color_pcm_cases k : pcm (color_cases k) = match k with
   | RGB -> rgb_pcm
   | HSV -> hsv_pcm
 let color_pcm : pcm color_t = union_pcm color_pcm_cases
-
-(*
-
-let decidable (p: 'a -> prop) = x:'a -> b:bool{b <==> p x}
-
-let unrefine_upd
-  (#p: pcm 'a) (#re: pcm_refinement p) (dec_re: decidable re.f)
-  (f: refine_t re.f -> refine_t re.f) (x: 'a): 'a
-= if dec_re x then f x else one p
-
-let re_respects_compatible (#p: pcm 'a) (re: pcm_refinement p) x =
-  v:'a ->
-    Lemma
-      (requires compatible p x v) 
-      (ensures re.f v /\ compatible (refined_pcm re) x v)
-      [SMTPat (compatible p x v)]
-      
-let unrefine_upd_frame_pres
-  (#p: pcm 'a) (re: pcm_refinement p) (dec_re: decidable re.f)
-  (x y: Ghost.erased (refine_t re.f))
-  (f: (refine_t re.f -> refine_t re.f){frame_pres (refined_pcm re) f x y})
-  (hre: re_respects_compatible re x)
-: Lemma (frame_pres p (unrefine_upd dec_re f) (Ghost.reveal x) (Ghost.reveal y))
-= frame_pres_intro p (unrefine_upd dec_re f) (Ghost.reveal x) (Ghost.reveal y)
-    (fun v -> 
-      hre v; 
-      assert (re.f v);
-      let v': refine_t re.f = v in
-      assert (compatible (refined_pcm re) x v');
-      assert (p.refine (f v)); assert (compatible p y (f v));
-      let aux (frame:'a{composable p x frame})
-      : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == f v))
-      = admit()
-      in FStar.Classical.forall_intro aux)
-
-(* If f is a frame-preserving update on a refined PCM where
-   (1) the refinement respects compatibility,
-   (2) the refinement is decidable,
-   then f is a frame-preserving update on the unrefined PCM *)
-let frame_pres_drop_refinement (#p: pcm 'a)
-  (re: pcm_refinement p)
-  (x y: Ghost.erased (refine_t re.f))
-  (f: (refine_t re.f -> refine_t re.f){frame_pres (refined_pcm re) f x y})
-  (re_respects_compatible:(v:'a ->
-    Lemma
-      (requires compatible p x v) 
-      (ensures re.f v) [SMTPat (compatible p x v)]))
-: Lemma (frame_pres p f x y)
-= admit()
-*)
-
-(*
-(* TODO is this safe to add? *)
-assume val upd_gen' (#a:Type) (#p:pcm a) (e:inames) (r:ref a p)
-            (x y: Ghost.erased (refine_t f))
-            (f:FStar.PCM.frame_preserving_upd (refined_pcm re) x y)
-  : action_except unit e
-                  (pts_to r x)
-                  (fun _ -> pts_to r y)
-
-f (get x)
-x composable y
-(get x) composable (get y)
-
-f x
-f (op x y)
------------------
-f y
-
-==> f 1
-
-*)
-
-// frame_pres q f (get l s) v
-// 
-// (pts_to r s)
-// (pts_to r (put l v s))
-//     (requires frame_pres q f (get l s) v)
-//     (ensures frame_pres p (upd l f) s (put l v s))
-
-let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
-: frame_preserving_upd (refined_pcm r.re)
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)))
-= pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f;
-  frame_pres_mk_upd (refined_pcm r.re)
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)))
-    (upd r.pl f)
-
-(*
-let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
-: M.action_except unit Set.empty (r `pts_to` x) (fun _ -> r `pts_to` y)
-= let f': refine_t r.re.f -> refine_t r.re.f = upd r.pl f in
-  let hf'
-  : squash (frame_pres (refined_pcm r.re) f'
-      (put r.pl x (one (refined_pcm r.re)))
-      (put r.pl y (one (refined_pcm r.re))))
-  = pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f in
-  M.upd_gen Set.empty r.r x y (frame_pres_mk_upd (refined_pcm r.re)
-      (put r.pl x (one (refined_pcm r.re)))
-      (put r.pl y (one (refined_pcm r.re)))
-  f' hf')
-
-let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
-: SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
-= let f': 'a -> 'a = upd r.pl f in
-  let hf'
-  : frame_pres r.p f'
-      (put x (one (refined_pcm r.re)))
-      (put y (one (refined_pcm r.re)))
-  = pcm_lens_frame_pres r.p r.q r.pl (put x (one (refined_pcm r.re))) y f' in
-  let act : M.action_except unit Set.empty _ _ = M.upd_gen Set.empty r.r x y (frame_pres_mk_upd r.p
-      (put x (one (refined_pcm r.re)))
-      (put y (one (refined_pcm r.re)))
-  f' hf') in
-  as_action act
-  *)

From 9f309635eaa07082b81cd5da5a5c89a1d0161543 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 09:07:58 -0700
Subject: [PATCH 044/513] Clean up definition of pcm_unrefinement

---
 examples/steel/AggregateRef.fst | 256 ++++++++++++++++----------------
 1 file changed, 129 insertions(+), 127 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 31c869d9438..23337bac17c 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -127,13 +127,12 @@ let trivial_refinement (p: pcm 'a): pcm_refinement p = {
     refined PCM can be turned to frame-preserving updates on the
     unrefined PCM *)
 
-(*
-let frame_pres_lift (p: pcm 'a) (x y: 'b) (q: pcm 'b) (x' y': 'a)
-= f:('b -> 'b){frame_pres q f x y} -> 
-  g:('a -> 'a){frame_pres p g x' y'}
-*)
+let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
+  f:('a -> 'a){frame_pres p f x y} -> 
+  g:('b -> 'b){frame_pres q g x' y'}
+
 (* admit() delete
-let  *)
+let 
 (* todo: can combine these two into a dependently typed function
    which takes frame-preserving fs to frame-presrving gs *)
 let unrefine_t (#p: pcm 'a) (r: pcm_refinement p) =
@@ -145,18 +144,12 @@ let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (unrefine: unrefine
   Lemma
     (requires frame_pres (refined_pcm r) f x y)
     (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
- (*   *)
-
-(*
-noeq type pcm_unrefinement #a (#p: pcm a) (r: pcm_refinement p) =
+    *)
+  
+let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
   x: Ghost.erased (refine_t r.f) ->
   y: Ghost.erased (refine_t r.f) ->
-  frame_pres_lift *)
-  
-{
-  unrefine: (refine_t r.f -> refine_t r.f) -> a -> a;
-  frame_pres_unrefine: frame_pres_unrefine_t r unrefine;
-}
+  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
 
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
@@ -252,6 +245,11 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
       = () in ()
     in FStar.Classical.forall_intro aux)))
 
+let pcm_lens_lift (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (s: Ghost.erased 'a) (v: Ghost.erased 'b)
+: frame_pres_lift q (get l s) v p s (put l v s)
+= fun f -> pcm_lens_frame_pres p q l s v f; upd l f
+
 (** The identity lens is a pcm_lens *)
 let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
   l = lens_id; 
@@ -443,57 +441,64 @@ let case_unrefinement_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
-(* admit() tidy *)
+(* admit() tidy,then combine with above defn *)
+let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
+  (kx ky: Ghost.erased (refine_t (case_refinement_f p k)))
+: Lemma
+    (requires frame_pres (refined_pcm (case_refinement p k)) f kx ky)
+    (ensures frame_pres (union_pcm p) (case_unrefinement_unrefine p k f) (Ghost.reveal kx) (Ghost.reveal ky))
+= let Some (|_, x|) = Ghost.reveal kx in
+  let Some (|_, y|) = Ghost.reveal ky in
+  let p' = refined_pcm (case_refinement p k) in
+  frame_pres_intro (union_pcm p) (case_unrefinement_unrefine p k f)
+    (Ghost.reveal kx) (Ghost.reveal ky)
+    (fun kv -> match kv with
+      | Some (|k', v|) -> 
+        if k = k' then begin
+          compatible_elim (union_pcm p) (Ghost.reveal kx) kv
+            (compatible (refined_pcm (case_refinement p k)) kx kv)
+            (fun frame_kx -> match frame_kx with
+              | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
+              | None -> compatible_refl p' kx);
+          let aux (frame:union b{composable (union_pcm p) kx frame})
+          : Lemma (composable (union_pcm p) ky frame /\
+                   (op (union_pcm p) kx frame == Some (|k, v|) ==>
+                    op (union_pcm p) ky frame == f (Some (|k, v|))))
+          = let Some (|_, w|) = f (Some (|k, v|)) in
+            match frame with
+            | Some (|frame_k, frame_v|) ->
+              assert (k == frame_k);
+              //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
+              //  composable p' ky frame /\
+              //  (op p' kx frame == kv ==> op p' ky frame == f kv));
+              assert (composable p' kx frame);
+              assert (composable (p k) y frame_v);
+              assert (op (p k) x frame_v == v ==> op (p k) y frame_v == w)
+            | None ->
+              p'.is_unit kx;
+              //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
+              //  composable p' ky frame /\
+              //  (op p' kx frame == kv ==> op p' ky frame == f kv));
+              assert (composable p' kx (one p'));
+              assert (composable p' ky (one p') /\ (op p' kx (one p') == kv ==> op p' ky (one p') == f kv));
+              p'.is_unit ky;
+              assert (composable p' ky (one p') /\ (Ghost.reveal kx == kv ==> Ghost.reveal ky == f kv));
+              assert (composable p' ky (one p') /\ (Some (|k, x|) == Some (|k, v|) ==> Ghost.reveal ky == f (Some (|k, v|))));
+              assert (x == v ==> Ghost.reveal ky == Some (|k, w|));
+              let Some (|k', y|) = Ghost.reveal ky in
+              assert (x == v ==> Some (|k', y|) == Some (|k, w|));
+              assert (x == v ==> y == w)
+          in FStar.Classical.forall_intro aux
+        end else ()
+      | None -> ())
+    
 let case_unrefinement (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement p k) = {
-  unrefine = case_unrefinement_unrefine p k;
-  frame_pres_unrefine = (fun f kx ky ->
-    let Some (|_, x|) = Ghost.reveal kx in
-    let Some (|_, y|) = Ghost.reveal ky in
-    let p' = refined_pcm (case_refinement p k) in
-    frame_pres_intro (union_pcm p) (case_unrefinement_unrefine p k f)
-      (Ghost.reveal kx) (Ghost.reveal ky)
-      (fun kv -> match kv with
-        | Some (|k', v|) -> 
-          if k = k' then begin
-            compatible_elim (union_pcm p) (Ghost.reveal kx) kv
-              (compatible (refined_pcm (case_refinement p k)) kx kv)
-              (fun frame_kx -> match frame_kx with
-                | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
-                | None -> compatible_refl p' kx);
-            let aux (frame:union b{composable (union_pcm p) kx frame})
-            : Lemma (composable (union_pcm p) ky frame /\
-                     (op (union_pcm p) kx frame == Some (|k, v|) ==>
-                      op (union_pcm p) ky frame == f (Some (|k, v|))))
-            = let Some (|_, w|) = f (Some (|k, v|)) in
-              match frame with
-              | Some (|frame_k, frame_v|) ->
-                assert (k == frame_k);
-                //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
-                //  composable p' ky frame /\
-                //  (op p' kx frame == kv ==> op p' ky frame == f kv));
-                assert (composable p' kx frame);
-                assert (composable (p k) y frame_v);
-                assert (op (p k) x frame_v == v ==> op (p k) y frame_v == w)
-              | None ->
-                p'.is_unit kx;
-                //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
-                //  composable p' ky frame /\
-                //  (op p' kx frame == kv ==> op p' ky frame == f kv));
-                assert (composable p' kx (one p'));
-                assert (composable p' ky (one p') /\ (op p' kx (one p') == kv ==> op p' ky (one p') == f kv));
-                p'.is_unit ky;
-                assert (composable p' ky (one p') /\ (Ghost.reveal kx == kv ==> Ghost.reveal ky == f kv));
-                assert (composable p' ky (one p') /\ (Some (|k, x|) == Some (|k, v|) ==> Ghost.reveal ky == f (Some (|k, v|))));
-                assert (x == v ==> Ghost.reveal ky == Some (|k, w|));
-                let Some (|k', y|) = Ghost.reveal ky in
-                assert (x == v ==> Some (|k', y|) == Some (|k, w|));
-                assert (x == v ==> y == w)
-            in FStar.Classical.forall_intro aux
-          end else ()
-        | None -> ()));
-}
-
+: pcm_unrefinement (case_refinement p k)
+= fun kx ky f ->
+  case_unrefinement_unrefine_ok p k f kx ky; 
+  case_unrefinement_unrefine p k f
+  
 (** A lens for the k-th case of an n-ary union *)
 
 let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
@@ -775,23 +780,24 @@ let pcm_refinement_conj_iso (p: pcm 'a)
   };
 }
 
-let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
+let upd_across_pcm_iso' (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
   (f: 'a -> 'a): 'b -> 'b
 = i.i.fwd `compose` f `compose` i.i.bwd
 
+(* admit() tidy and combine with upd_across_pcm_iso' *)
 let frame_pres_upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
   (f: 'a -> 'a) (x y: Ghost.erased 'a)
 : Lemma
     (requires frame_pres p f x y)
-    (ensures frame_pres q (upd_across_pcm_iso i f) (i.i.fwd x) (i.i.fwd y))
-= frame_pres_intro q (upd_across_pcm_iso i f) (i.i.fwd x) (i.i.fwd y) (fun v ->
+    (ensures frame_pres q (upd_across_pcm_iso' i f) (i.i.fwd x) (i.i.fwd y))
+= frame_pres_intro q (upd_across_pcm_iso' i f) (i.i.fwd x) (i.i.fwd y) (fun v ->
     assert (compatible q (i.i.fwd x) v);
-    assume (q.refine ((upd_across_pcm_iso i f) v));
-    assume (compatible q (i.i.fwd y) ((upd_across_pcm_iso i f) v));
+    assume (q.refine ((upd_across_pcm_iso' i f) v));
+    assume (compatible q (i.i.fwd y) ((upd_across_pcm_iso' i f) v));
     assume (
         (forall (frame:'b{composable q (i.i.fwd x) frame}).
           composable q (i.i.fwd y) frame /\
-          (op q (i.i.fwd x) frame == v ==> op q (i.i.fwd y) frame == (upd_across_pcm_iso i f) v))))
+          (op q (i.i.fwd x) frame == v ==> op q (i.i.fwd y) frame == (upd_across_pcm_iso' i f) v))))
 (*
 suppose compatible q (i.i.fwd x) v
 and q.refine v.
@@ -827,61 +833,60 @@ to show composable q (fwd y) frame /\ (op q (fwd x) frame == v ==> op q (fwd y)
 qed
 *)
 
-let conj_unrefinement_unrefine (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
-: (refine_t (conj_refinement_f #'a re1 re2) -> refine_t (conj_refinement_f #'a re1 re2)) ->
-  'a -> 'a
-= h1.unrefine `compose` h2.unrefine `compose` upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2)
+let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
+: frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
+= fun f ->
+  frame_pres_upd_across_pcm_iso i f x y;
+  upd_across_pcm_iso' i f
 
 let conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
-= let re = conj_refinement #'a re1 re2 in
-  let i = pcm_refinement_conj_iso p re1 re2 in
-  {
-    unrefine = conj_unrefinement_unrefine re1 re2 h1 h2;
-    frame_pres_unrefine = (fun f x y ->
-      assert (frame_pres (refined_pcm (conj_refinement #'a re1 re2)) f x y); 
-      let f': refine_t re2.f -> refine_t re2.f = upd_across_pcm_iso i f in
-      frame_pres_upd_across_pcm_iso i f' (i.i.fwd x) (i.i.fwd y);
-      assert (frame_pres (refined_pcm re2) f' (i.i.fwd x) (i.i.fwd y));
-      let f'': refine_t re1.f -> refine_t re1.f = h2.unrefine f' in
-      h2.frame_pres_unrefine f' (i.i.fwd x) (i.i.fwd y);
-      assert (frame_pres (refined_pcm re1) f'' (i.i.fwd x) (i.i.fwd y));
-      let f''': 'a -> 'a = h1.unrefine f'' in
-      h1.frame_pres_unrefine f'' (i.i.fwd x) (i.i.fwd y);
-      assert (frame_pres p f''' (i.i.fwd x) (i.i.fwd y));
-      assert (frame_pres p f''' (Ghost.reveal x) (Ghost.reveal y)));
-  }
-
-let extend_unrefinement_unrefine (r: ref 'a 'b)
-  (re: pcm_refinement r.q) (u: pcm_unrefinement re)
-: (refine_t (extend_refinement_f r.pl re) -> refine_t (extend_refinement_f r.pl re)) ->
-  refine_t r.re.f -> refine_t r.re.f
-= admit()
+= fun x y ->
+  h1 (Ghost.reveal x) (Ghost.reveal y) `compose`
+  h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
+  upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2) x y
 
 let extend_unrefinement (#p: pcm 'a) (#q: pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
-: pcm_unrefinement (extend_refinement l re) = {
-  unrefine =
-    (let _: (refine_t re.f -> refine_t re.f) -> ('b -> 'b) = u.unrefine in
-    let ans:
-     (refine_t (extend_refinement_f l re) -> refine_t (extend_refinement_f l re)) ->
-     ('a -> 'a) = admit() in
-     (* endo (extend_refinement_f l re) --> endo (refine_t re.f)
-          doable because we know that extend_refinement_f l re works with
-          values of the form (put x one) where re.f x
-          should be frame-preserving
-        endo (refine_t re.f) --> endo 'b
-          by u.unrefine, frame preserving by assumption
-        endo 'b --> endo 'a
-          by upd, frame preserving because pcm_lens lifts frame-preserving updates
-          to frame-preserving updates *)
-    ans);
-  frame_pres_unrefine = admit();
-}
+: pcm_unrefinement (extend_refinement l re)
+= admit()
+(*
+
+need lemma:
+  l: pcm_lens p q
+  re: pcm_refinement q ->
+  frame_pres_lift (refined_pcm (extend_refinement l re)) x y
+    (refined_pcm re) (get l x) (get l y)
+  
+  or could just write
+    pcm_iso (refined_pcm (extend_refinement l re)) (refined_pcm re)
+  and use upd_across_iso
+
+goal: construct
+  (frame_pres p _ x y)
+given
+  (frame_pres (refined_pcm (extend_refinement l re)) _ x y
+
+frame_pres (refined_pcm (extend_refinement l re)) _ x y
+==> frame_pres (refined_pcm re) _ (get l x) (get l y) by lemma
+==> frame_pres q _ (get l x) (get l y) via u
+==> frame_pres p _ x (put (get l y) x) via pcm_lens_lift l
+now, by definition of extend_refinement l re, we know
+  x = put x' one
+and
+  y = put y' one
+for some x' and y', so
+  put (get l y) x
+  = put (get l (put y' one)) (put x' one)
+  = put y' (put x' one)
+  = put y' one
+  = y
+so we have
+  frame_pres p _ x y
+as desired
+*)
 
 (** The refinement of a ref *)
 
@@ -1037,14 +1042,11 @@ let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
 : frame_preserving_upd r.p
     (put r.pl x (one (refined_pcm r.re)))
     (put r.pl y (one (refined_pcm r.re)))
-= pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f;
-  r.u.frame_pres_unrefine (upd r.pl f)
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  frame_pres_mk_upd r.p
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)))
-    (r.u.unrefine (upd r.pl f))
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+  let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re))) in
+  frame_pres_mk_upd r.p x' y'
+    (r.u (Ghost.reveal x') (Ghost.reveal y')
+      (pcm_lens_lift r.pl (Ghost.reveal x') y f))
 
 (*
 let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)

From 6c3e6836b98442507fd6b5a585a5c4e34e043b8a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 10:06:49 -0700
Subject: [PATCH 045/513] qed extend_refinement_iso; switch to refined_one_pcms

---
 examples/steel/AggregateRef.fst | 151 +++++++++++++++++++-------------
 1 file changed, 89 insertions(+), 62 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 23337bac17c..b8a5bafd0ea 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -90,12 +90,13 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
 
 (** A refinement of a PCM (p: pcm a) consists of:
     (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f *)
+    (2) An element new_unit which satisfies the unit laws on the subset f
+        and p.refine *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement #a (p: pcm a) = {
   f: a -> prop;
   f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
-  new_one: refine_t f;
+  new_one: (new_one:refine_t f{p.refine new_one});
   new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
 
@@ -107,7 +108,8 @@ let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
+let refined_one_pcm a = p:pcm a{p.refine (one p)}
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): refined_one_pcm (refine_t r.f) = {
   p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
@@ -116,13 +118,6 @@ let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): pcm (refine_t r.f) = {
   refine = p.refine;
 }
 
-let trivial_refinement (p: pcm 'a): pcm_refinement p = {
-  f = (fun x -> True);
-  f_closed_under_op = (fun _ _ -> ());
-  new_one = one p;
-  new_one_is_refined_unit = p.is_unit;
-}
-
 (** A PCM refinement is well-formed if frame-preserving updates on the
     refined PCM can be turned to frame-preserving updates on the
     unrefined PCM *)
@@ -131,21 +126,6 @@ let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost
   f:('a -> 'a){frame_pres p f x y} -> 
   g:('b -> 'b){frame_pres q g x' y'}
 
-(* admit() delete
-let 
-(* todo: can combine these two into a dependently typed function
-   which takes frame-preserving fs to frame-presrving gs *)
-let unrefine_t (#p: pcm 'a) (r: pcm_refinement p) =
-  (refine_t r.f -> refine_t r.f) -> 'a -> 'a
-let frame_pres_unrefine_t (#p: pcm 'a) (r: pcm_refinement p) (unrefine: unrefine_t r) =
-  f:(refine_t r.f -> refine_t r.f) ->
-  x:Ghost.erased (refine_t r.f) ->
-  y:Ghost.erased (refine_t r.f) ->
-  Lemma
-    (requires frame_pres (refined_pcm r) f x y)
-    (ensures frame_pres p (unrefine f) (Ghost.reveal x) (Ghost.reveal y))
-    *)
-  
 let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
   x: Ghost.erased (refine_t r.f) ->
   y: Ghost.erased (refine_t r.f) ->
@@ -286,14 +266,15 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 
 open FStar.FunctionalExtensionality
 
+(* admit() update comment *)
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
 noeq type ref (a:Type) (b:Type): Type = {
-  p: pcm a;
+  p: refined_one_pcm a;
   re: pcm_refinement p;
   u: pcm_unrefinement re;
-  q: pcm b;
+  q: refined_one_pcm b;
   pl: pcm_lens (refined_pcm re) q;
   r: Steel.Memory.ref a p;
 }
@@ -370,7 +351,7 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
     | Some (Inr x) -> q.refine x);
 })
 
-let inl_refinement (p: pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
+let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
   f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
   f_closed_under_op = (fun _ _ -> ());
   new_one = Some (Inl #_ #'b (one p));
@@ -427,7 +408,8 @@ let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 : refine_t (case_refinement_f p k)
 = Some (|k, one (p k)|)
 
-let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) = {
+let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+: pcm_refinement (union_pcm p) = {
   f = case_refinement_f p k;
   f_closed_under_op = (fun x y -> ());
   new_one = case_refinement_new_one p k;
@@ -442,7 +424,7 @@ let case_unrefinement_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | _ -> None
 
 (* admit() tidy,then combine with above defn *)
-let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
   (kx ky: Ghost.erased (refine_t (case_refinement_f p k)))
 : Lemma
@@ -493,7 +475,7 @@ let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
         end else ()
       | None -> ())
     
-let case_unrefinement (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
 : pcm_unrefinement (case_refinement p k)
 = fun kx ky f ->
   case_unrefinement_unrefine_ok p k f kx ky; 
@@ -516,7 +498,8 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
 }
 
 (** lens_case is a pcm_lens *)
-let case (p:(k:'a -> pcm ('b k))) (k:'a): pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
+let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+: pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
   l = lens_case p k;
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
@@ -557,12 +540,13 @@ let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   assume (op p x y == put l (get l (op p x y)) (one p))
   (* get put morphism plus the fact that (one p = one p * one p) *)
 
-let extend_refinement_new_one (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q): refine_t (extend_refinement_f l re)
-= put l re.new_one (one p)
+let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: new_one:refine_t (extend_refinement_f l re){p.refine new_one}
+= l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
 
 let extend_refinement_new_one_is_refined_unit
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
 : Lemma (composable p x (extend_refinement_new_one l re) /\
          op p x (extend_refinement_new_one l re) == x)
@@ -570,14 +554,17 @@ let extend_refinement_new_one_is_refined_unit
   p.is_unit x;
   l.put_morphism.f_op (get l x, x) (re.new_one, one p)
   
-let extend_refinement (l: pcm_lens 'p 'q) (re: pcm_refinement 'q) : pcm_refinement 'p = {
+let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_refinement p = {
   f = extend_refinement_f l re;
   f_closed_under_op = extend_refinement_f_closed l re;
   new_one = extend_refinement_new_one l re;
   new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
 }
 
-let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine_get_morphism_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_refine
     (refined_pcm (extend_refinement l re))
@@ -585,7 +572,8 @@ let pcm_lens_refine_get_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
     (lens_refine l re).get
 = l.get_morphism.f_refine
 
-let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine_get_morphism_one
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_one
     (refined_pcm (extend_refinement l re))
@@ -593,7 +581,8 @@ let pcm_lens_refine_get_morphism_one (#p: pcm 'a) (#q: pcm 'b)
     (lens_refine l re).get
 = l.get_morphism.f_one
 
-let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine_get_morphism_op
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_op
     (refined_pcm (extend_refinement l re))
@@ -601,7 +590,8 @@ let pcm_lens_refine_get_morphism_op (#p: pcm 'a) (#q: pcm 'b)
     (lens_refine l re).get
 = l.get_morphism.f_op
 
-let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine_put_morphism_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_refine
     (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
@@ -609,7 +599,8 @@ let pcm_lens_refine_put_morphism_refine (#p: pcm 'a) (#q: pcm 'b)
     (uncurry (lens_refine l re).put)
 = fun (v, s) -> l.put_morphism.f_refine (v, s)
 
-let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine_put_morphism_one
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_one
     (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
@@ -617,7 +608,8 @@ let pcm_lens_refine_put_morphism_one (#p: pcm 'a) (#q: pcm 'b)
     (uncurry (lens_refine l re).put)
 = l.put_morphism.f_one
 
-let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine_put_morphism_op
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : morphism_op
     (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
@@ -625,7 +617,8 @@ let pcm_lens_refine_put_morphism_op (#p: pcm 'a) (#q: pcm 'b)
     (uncurry (lens_refine l re).put)
 = fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
 
-let pcm_lens_refine (#p: pcm 'a) (#q: pcm 'b)
+let pcm_lens_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
   l = lens_refine l re;
@@ -848,22 +841,55 @@ let conj_unrefinement (#p: pcm 'a)
   h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
   upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2) x y
 
-let extend_unrefinement (#p: pcm 'a) (#q: pcm 'b)
+let extend_refinement_iso (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_iso (refined_pcm (extend_refinement l re)) (refined_pcm re)
+= let a' = refine_t (extend_refinement_f l re) in
+  let b' = refine_t re.f in
+  let p' = refined_pcm (extend_refinement l re) in
+  let q' = refined_pcm re in
+  let fwd (x: a'): b' = get l x in
+  let bwd (x: b'): a' = put l x (one p) in
+  let i: iso a' b' = {fwd = fwd; bwd = bwd; fwd_bwd = (fun x -> ()); bwd_fwd = (fun x -> ())} in
+  let fwd_morphism: pcm_morphism i.fwd p' q' =
+    let f_refine: morphism_refine p' q' i.fwd = fun x -> l.get_morphism.f_refine x in
+    let f_one: morphism_one p' q' i.fwd = fun x -> l.get_morphism.f_one x in
+    let f_op: morphism_op p' q' i.fwd = fun x y -> l.get_morphism.f_op x y in
+    {f_refine = f_refine; f_one = f_one; f_op = f_op}
+  in
+  let bwd_morphism: pcm_morphism i.bwd q' p' = 
+    let f_refine: morphism_refine q' p' i.bwd = fun x -> l.put_morphism.f_refine (x, one p) in
+    let f_one: morphism_one q' p' i.bwd = fun _ -> () in
+    let f_op: morphism_op q' p' i.bwd = fun x y ->
+      p.is_unit (one p);
+      l.put_morphism.f_op (x, one p) (y, one p)
+    in
+    {f_refine = f_refine; f_one = f_one; f_op = f_op}
+  in
+  {i = i; fwd_morphism = fwd_morphism; bwd_morphism = bwd_morphism}
+
+let extend_refinement_lift (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+  (x y: Ghost.erased (refine_t (extend_refinement_f l re)))
+: frame_pres_lift
+    (refined_pcm (extend_refinement l re)) x y
+    (refined_pcm re) (get l x) (get l y)
+= upd_across_pcm_iso (extend_refinement_iso l re) x y 
+
+let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
-= admit()
+= fun x y f ->
+  assert (Ghost.reveal x == put l (get l x) (one p));
+  assert (Ghost.reveal y == put l (get l y) (one p));
+  let f = extend_refinement_lift l re x y f in
+  assert (frame_pres (refined_pcm re) f (get l x) (get l y));
+  let f = u (get l x) (get l y) f in
+  assert (frame_pres q f (get l x) (get l y));
+  let f = pcm_lens_lift l (Ghost.reveal x) (get l y) f in
+  assert (frame_pres p f (Ghost.reveal x) (put l (get l y) x));
+  f
 (*
-
-need lemma:
-  l: pcm_lens p q
-  re: pcm_refinement q ->
-  frame_pres_lift (refined_pcm (extend_refinement l re)) x y
-    (refined_pcm re) (get l x) (get l y)
-  
-  or could just write
-    pcm_iso (refined_pcm (extend_refinement l re)) (refined_pcm re)
-  and use upd_across_iso
-
 goal: construct
   (frame_pres p _ x y)
 given
@@ -912,10 +938,11 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let ref_focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
+let ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
   {p = r.p; re = r.re; u = r.u; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
-let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+let focus (r: ref 'a 'b) (q: refined_one_pcm 'c)
+  (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
     (to_vprop (r `pts_to` s))
     (fun r' -> to_vprop (r' `pts_to` x))
@@ -929,7 +956,7 @@ let focus (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x
     (fun m -> r.pl.get_morphism.f_one ());
   A.return r'
 
-let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: pcm 'c)
+let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: refined_one_pcm 'c)
   (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` x))
@@ -993,7 +1020,7 @@ let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
     (Ghost.reveal y, one (refined_pcm r.re));
   change_equal_vprop _ (r `pts_to` op r.q x y)
 
-let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+let peel (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
 : SteelT unit
     (to_vprop (r `pts_to` x))
     (fun _ ->
@@ -1005,7 +1032,7 @@ let peel (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
   l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
   split r x (put l (one q) x) (put l (get l x) (one r.q))
 
-let addr_of_lens (r: ref 'a 'b) (q: pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+let addr_of_lens (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
 : SteelT (ref 'a 'c)
     (to_vprop (r `pts_to` x))
     (fun s ->

From a991ed28fd99c7558b007972ac0b4dafd6cd247b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 10:37:49 -0700
Subject: [PATCH 046/513] Clear admits and assumes

---
 examples/steel/AggregateRef.fst | 99 +++++++++++++++++----------------
 1 file changed, 52 insertions(+), 47 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index b8a5bafd0ea..a803fecda62 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -190,11 +190,16 @@ let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a =
 (** The upd function of a pcm_lens lifts frame-preserving updates on the target to
     frame-preserving updates on the source *)
 
+let compatible_pcm_morphism (#p: pcm 'a) (#q: pcm 'b)
+  (f: 'a -> 'b) (m: pcm_morphism f p q) (x y: Ghost.erased 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
+= compatible_elim p x y (compatible q (f x) (f y)) (fun frame_x ->
+  let _ = m.f_op frame_x x in
+  compatible_intro q (f x) (f y) (f frame_x))
+
 let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
 : Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
-= compatible_elim p x y (compatible q (get l x) (get l y)) (fun frame_x ->
-  let _ = l.get_morphism.f_op frame_x x in
-  compatible_intro q (get l x) (get l y) (get l frame_x))
+= compatible_pcm_morphism l.l.get l.get_morphism x y
     
 let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
 : Lemma
@@ -266,7 +271,7 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 
 open FStar.FunctionalExtensionality
 
-(* admit() update comment *)
+(* TODO() update comment *)
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
@@ -423,7 +428,7 @@ let case_unrefinement_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
-(* admit() tidy,then combine with above defn *)
+(* TODO() tidy,then combine with above defn *)
 let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
   (kx ky: Ghost.erased (refine_t (case_refinement_f p k)))
@@ -537,7 +542,12 @@ let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
 : Lemma (extend_refinement_f l re (op p x y))
 = l.get_morphism.f_op x y;
   re.f_closed_under_op (get l x) (get l y);
-  assume (op p x y == put l (get l (op p x y)) (one p))
+  p.is_unit (one p);
+  l.put_morphism.f_op (get l x, one p) (get l y, one p);
+  assert (op p x y == op p (put l (get l x) (one p)) (put l (get l y) (one p)));
+  assert (op p x y == put l (op q (get l x) (get l y)) (op p (one p) (one p)));
+  assert (op p x y == put l (op q (get l x) (get l y)) (one p));
+  assert (op p x y == put l (get l (op p x y)) (one p))
   (* get put morphism plus the fact that (one p = one p * one p) *)
 
 let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
@@ -777,7 +787,7 @@ let upd_across_pcm_iso' (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
   (f: 'a -> 'a): 'b -> 'b
 = i.i.fwd `compose` f `compose` i.i.bwd
 
-(* admit() tidy and combine with upd_across_pcm_iso' *)
+(* TODO() tidy and combine with upd_across_pcm_iso' *)
 let frame_pres_upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
   (f: 'a -> 'a) (x y: Ghost.erased 'a)
 : Lemma
@@ -785,46 +795,41 @@ let frame_pres_upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
     (ensures frame_pres q (upd_across_pcm_iso' i f) (i.i.fwd x) (i.i.fwd y))
 = frame_pres_intro q (upd_across_pcm_iso' i f) (i.i.fwd x) (i.i.fwd y) (fun v ->
     assert (compatible q (i.i.fwd x) v);
-    assume (q.refine ((upd_across_pcm_iso' i f) v));
-    assume (compatible q (i.i.fwd y) ((upd_across_pcm_iso' i f) v));
-    assume (
-        (forall (frame:'b{composable q (i.i.fwd x) frame}).
-          composable q (i.i.fwd y) frame /\
-          (op q (i.i.fwd x) frame == v ==> op q (i.i.fwd y) frame == (upd_across_pcm_iso' i f) v))))
-(*
-suppose compatible q (i.i.fwd x) v
-and q.refine v.
-suppose
-  frame_pres p f x y
-to show q.refine (f' v):
-  f' v = fwd (f (bwd v))
-  q.refine v by assumption
-  p.refine (bwd v) b/c bwd is morphism
-  q.refine (f (bwd v)) b/c f frame preserving
-    need show compatible p x (bwd v)
-    easy: compatible p (fwd x) v ==> compatible p (bwd (fwd x)) (bwd v) b/c bwd is pcm morphism
-  p.refine (fwd (f (bwd v))) b/c fwd is morphism
-to show compatible q (fwd y) (f' v):
-  f'v = fwd (f (bwd v))
-  so need show compatible q (fwd y) (fwd (f (bwd v)))
-  suff. to show compatible q y (f (bwd v)) b/c fwd is pcm morphism
-  since we have refine (bwd v) /\ compatible p x (bwd v) (proof is same as in previous subcase),
-    we know compatible q y (f (bwd v)) b/c f is frame-preserving
-fix frame where composable q (fwd x) frame.
-to show composable q (fwd y) frame /\ (op q (fwd x) frame == v ==> op q (fwd y) frame == f' v == fwd (f (bwd v))):
-  we have composable q (bwd (fwd x)) (bwd frame) <==> composable q x (bwd frame) b/c bwd is morphism
-  since we have refine (bwd v) /\ compatible p x (bwd v),
-  and composable q x (bwd frame),
-  instantiate hyp about f frame-preserving from x to y to get
-    composable q y (bwd frame) /\ (op p x (bwd frame) == bwd v ==> op p y (bwd frame) == f (bwd v))
-  now,
-    composable q y (bwd frame) ==> composable q (fwd y) frame b/c fwd morphism
-  and
-    (op p x (bwd frame) == bwd v ==> op p y (bwd frame) == f (bwd v))
-    <==> (op p (fwd x) frame == v ==> op p (fwd y) frame == fwd (f (bwd v)))
-    b/c fwd morphism
-qed
-*)
+    let fwd = i.i.fwd in
+    let bwd = i.i.bwd in
+    let f' = upd_across_pcm_iso' i f in
+    assert (f' v == fwd (f (bwd v)));
+    assert (q.refine v);
+    i.bwd_morphism.f_refine v;
+    assert (p.refine (bwd v));
+    compatible_pcm_morphism bwd i.bwd_morphism (fwd x) v;
+    assert (compatible p (bwd (fwd x)) (bwd v));
+    assert (compatible p x (bwd v));
+    assert (p.refine (f (bwd v)));
+    i.fwd_morphism.f_refine (f (bwd v));
+    assert (q.refine (fwd (f (bwd v))));
+    assert (q.refine ((upd_across_pcm_iso' i f) v));
+    assert (compatible p y (f (bwd v)));
+    compatible_pcm_morphism fwd i.fwd_morphism y (f (bwd v));
+    assert (compatible q (i.i.fwd y) ((upd_across_pcm_iso' i f) v));
+    let aux (frame:'b{composable q (i.i.fwd x) frame})
+    : Lemma (composable q (i.i.fwd y) frame /\
+             (op q (i.i.fwd x) frame == v ==>
+              op q (i.i.fwd y) frame == (upd_across_pcm_iso' i f) v))
+    = i.bwd_morphism.f_op (fwd x) frame;
+      assert (composable p (bwd (fwd x)) (bwd frame));
+      assert (composable p x (bwd frame));
+      assert (p.refine (bwd v));
+      assert (compatible p x (bwd v));
+      assert (composable p y (bwd frame) /\
+              (op p x (bwd frame) == bwd v ==> op p y (bwd frame) == f (bwd v)));
+      i.fwd_morphism.f_op y (bwd frame);
+      assert (composable q (fwd y) frame);
+      i.fwd_morphism.f_op x (bwd frame);
+      assert (op p x (bwd frame) == bwd v <==> op q (fwd x) frame == v);
+      assert (fwd (op p y (bwd frame)) == op q (fwd y) frame);
+      ()
+    in FStar.Classical.forall_intro aux)
 
 let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
 : frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)

From 18ad5b5c2683906cf51f0fbd5ece6fabffb41ec8 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 10:50:01 -0700
Subject: [PATCH 047/513] Tidy

---
 examples/steel/AggregateRef.fst | 156 +++++++-------------------------
 1 file changed, 31 insertions(+), 125 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index a803fecda62..b849a7b0a75 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -271,13 +271,15 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 
 open FStar.FunctionalExtensionality
 
-(* TODO() update comment *)
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
 noeq type ref (a:Type) (b:Type): Type = {
   p: refined_one_pcm a;
   re: pcm_refinement p;
+  (** Needed to turn frame-preserving updates on (refined_pcm re) into
+      frame-preserving updates on p. To do so, also requires that p and q
+      be `refined_one_pcm`s *)
   u: pcm_unrefinement re;
   q: refined_one_pcm b;
   pl: pcm_lens (refined_pcm re) q;
@@ -428,13 +430,14 @@ let case_unrefinement_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   | Some (|k', _|) -> if k = k' then f kx else None
   | _ -> None
 
-(* TODO() tidy,then combine with above defn *)
 let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
   (kx ky: Ghost.erased (refine_t (case_refinement_f p k)))
 : Lemma
     (requires frame_pres (refined_pcm (case_refinement p k)) f kx ky)
-    (ensures frame_pres (union_pcm p) (case_unrefinement_unrefine p k f) (Ghost.reveal kx) (Ghost.reveal ky))
+    (ensures frame_pres (union_pcm p)
+               (case_unrefinement_unrefine p k f)
+               (Ghost.reveal kx) (Ghost.reveal ky))
 = let Some (|_, x|) = Ghost.reveal kx in
   let Some (|_, y|) = Ghost.reveal ky in
   let p' = refined_pcm (case_refinement p k) in
@@ -454,28 +457,11 @@ let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k
                     op (union_pcm p) ky frame == f (Some (|k, v|))))
           = let Some (|_, w|) = f (Some (|k, v|)) in
             match frame with
-            | Some (|frame_k, frame_v|) ->
-              assert (k == frame_k);
-              //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
-              //  composable p' ky frame /\
-              //  (op p' kx frame == kv ==> op p' ky frame == f kv));
-              assert (composable p' kx frame);
-              assert (composable (p k) y frame_v);
-              assert (op (p k) x frame_v == v ==> op (p k) y frame_v == w)
+            | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
             | None ->
               p'.is_unit kx;
-              //assert (forall (frame:refine_t (case_refinement_f p k) {composable p' kx frame}).{:pattern composable p' kx frame}
-              //  composable p' ky frame /\
-              //  (op p' kx frame == kv ==> op p' ky frame == f kv));
               assert (composable p' kx (one p'));
-              assert (composable p' ky (one p') /\ (op p' kx (one p') == kv ==> op p' ky (one p') == f kv));
-              p'.is_unit ky;
-              assert (composable p' ky (one p') /\ (Ghost.reveal kx == kv ==> Ghost.reveal ky == f kv));
-              assert (composable p' ky (one p') /\ (Some (|k, x|) == Some (|k, v|) ==> Ghost.reveal ky == f (Some (|k, v|))));
-              assert (x == v ==> Ghost.reveal ky == Some (|k, w|));
-              let Some (|k', y|) = Ghost.reveal ky in
-              assert (x == v ==> Some (|k', y|) == Some (|k, w|));
-              assert (x == v ==> y == w)
+              p'.is_unit ky
           in FStar.Classical.forall_intro aux
         end else ()
       | None -> ())
@@ -543,12 +529,7 @@ let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
 = l.get_morphism.f_op x y;
   re.f_closed_under_op (get l x) (get l y);
   p.is_unit (one p);
-  l.put_morphism.f_op (get l x, one p) (get l y, one p);
-  assert (op p x y == op p (put l (get l x) (one p)) (put l (get l y) (one p)));
-  assert (op p x y == put l (op q (get l x) (get l y)) (op p (one p) (one p)));
-  assert (op p x y == put l (op q (get l x) (get l y)) (one p));
-  assert (op p x y == put l (get l (op p x y)) (one p))
-  (* get put morphism plus the fact that (one p = one p * one p) *)
+  l.put_morphism.f_op (get l x, one p) (get l y, one p)
 
 let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
@@ -756,14 +737,6 @@ let conj_refinement (#p: pcm 'a)
   new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
 }
 
-let pcm_refinement_conj_iso_fwd_morphism_op (p: pcm 'a)
-  (re1: pcm_refinement p)
-  (re2: pcm_refinement (refined_pcm re1))
-: morphism_op
-    (refined_pcm re2) (refined_pcm (conj_refinement re1 re2))
-    (pcm_refinement_conj_iso_i p re1 re2).fwd
-= fun x y -> ()
-
 (** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
     refinement by the conjunction of re1 and re2 *)
 let pcm_refinement_conj_iso (p: pcm 'a)
@@ -771,71 +744,33 @@ let pcm_refinement_conj_iso (p: pcm 'a)
   (re2: pcm_refinement (refined_pcm re1))
 : pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2) = {
   i = pcm_refinement_conj_iso_i p re1 re2;
-  fwd_morphism = {
-    f_refine = (fun _ -> ());
-    f_one = (fun _ -> ());
-    f_op = pcm_refinement_conj_iso_fwd_morphism_op p re1 re2;
-  };
-  bwd_morphism = {
-    f_refine = (fun _ -> ());
-    f_one = (fun _ -> ());
-    f_op = (fun _ _ -> ());
-  };
+  fwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  bwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
 
-let upd_across_pcm_iso' (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
-  (f: 'a -> 'a): 'b -> 'b
-= i.i.fwd `compose` f `compose` i.i.bwd
-
-(* TODO() tidy and combine with upd_across_pcm_iso' *)
-let frame_pres_upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q)
-  (f: 'a -> 'a) (x y: Ghost.erased 'a)
-: Lemma
-    (requires frame_pres p f x y)
-    (ensures frame_pres q (upd_across_pcm_iso' i f) (i.i.fwd x) (i.i.fwd y))
-= frame_pres_intro q (upd_across_pcm_iso' i f) (i.i.fwd x) (i.i.fwd y) (fun v ->
-    assert (compatible q (i.i.fwd x) v);
-    let fwd = i.i.fwd in
-    let bwd = i.i.bwd in
-    let f' = upd_across_pcm_iso' i f in
-    assert (f' v == fwd (f (bwd v)));
-    assert (q.refine v);
-    i.bwd_morphism.f_refine v;
-    assert (p.refine (bwd v));
-    compatible_pcm_morphism bwd i.bwd_morphism (fwd x) v;
-    assert (compatible p (bwd (fwd x)) (bwd v));
-    assert (compatible p x (bwd v));
-    assert (p.refine (f (bwd v)));
-    i.fwd_morphism.f_refine (f (bwd v));
-    assert (q.refine (fwd (f (bwd v))));
-    assert (q.refine ((upd_across_pcm_iso' i f) v));
-    assert (compatible p y (f (bwd v)));
-    compatible_pcm_morphism fwd i.fwd_morphism y (f (bwd v));
-    assert (compatible q (i.i.fwd y) ((upd_across_pcm_iso' i f) v));
-    let aux (frame:'b{composable q (i.i.fwd x) frame})
-    : Lemma (composable q (i.i.fwd y) frame /\
-             (op q (i.i.fwd x) frame == v ==>
-              op q (i.i.fwd y) frame == (upd_across_pcm_iso' i f) v))
-    = i.bwd_morphism.f_op (fwd x) frame;
-      assert (composable p (bwd (fwd x)) (bwd frame));
-      assert (composable p x (bwd frame));
-      assert (p.refine (bwd v));
-      assert (compatible p x (bwd v));
-      assert (composable p y (bwd frame) /\
-              (op p x (bwd frame) == bwd v ==> op p y (bwd frame) == f (bwd v)));
-      i.fwd_morphism.f_op y (bwd frame);
-      assert (composable q (fwd y) frame);
-      i.fwd_morphism.f_op x (bwd frame);
-      assert (op p x (bwd frame) == bwd v <==> op q (fwd x) frame == v);
-      assert (fwd (op p y (bwd frame)) == op q (fwd y) frame);
-      ()
-    in FStar.Classical.forall_intro aux)
-
 let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
 : frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
 = fun f ->
-  frame_pres_upd_across_pcm_iso i f x y;
-  upd_across_pcm_iso' i f
+  let f' = i.i.fwd `compose` f `compose` i.i.bwd in
+  let aux ()
+  : Lemma
+      (requires frame_pres p f x y)
+      (ensures frame_pres q f' (i.i.fwd x) (i.i.fwd y))
+  = frame_pres_intro q f' (i.i.fwd x) (i.i.fwd y) (fun v ->
+      i.bwd_morphism.f_refine v;
+      compatible_pcm_morphism i.i.bwd i.bwd_morphism (i.i.fwd x) v;
+      i.fwd_morphism.f_refine (f (i.i.bwd v));
+      compatible_pcm_morphism i.i.fwd i.fwd_morphism y (f (i.i.bwd v));
+      let aux (frame:'b{composable q (i.i.fwd x) frame})
+      : Lemma (composable q (i.i.fwd y) frame /\
+               (op q (i.i.fwd x) frame == v ==>
+                op q (i.i.fwd y) frame == f' v))
+      = i.bwd_morphism.f_op (i.i.fwd x) frame;
+        i.fwd_morphism.f_op y (i.i.bwd frame);
+        i.fwd_morphism.f_op x (i.i.bwd frame)
+      in FStar.Classical.forall_intro aux)
+  in aux ();
+  f'
 
 let conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
@@ -885,39 +820,10 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
 = fun x y f ->
-  assert (Ghost.reveal x == put l (get l x) (one p));
-  assert (Ghost.reveal y == put l (get l y) (one p));
   let f = extend_refinement_lift l re x y f in
-  assert (frame_pres (refined_pcm re) f (get l x) (get l y));
   let f = u (get l x) (get l y) f in
-  assert (frame_pres q f (get l x) (get l y));
   let f = pcm_lens_lift l (Ghost.reveal x) (get l y) f in
-  assert (frame_pres p f (Ghost.reveal x) (put l (get l y) x));
   f
-(*
-goal: construct
-  (frame_pres p _ x y)
-given
-  (frame_pres (refined_pcm (extend_refinement l re)) _ x y
-
-frame_pres (refined_pcm (extend_refinement l re)) _ x y
-==> frame_pres (refined_pcm re) _ (get l x) (get l y) by lemma
-==> frame_pres q _ (get l x) (get l y) via u
-==> frame_pres p _ x (put (get l y) x) via pcm_lens_lift l
-now, by definition of extend_refinement l re, we know
-  x = put x' one
-and
-  y = put y' one
-for some x' and y', so
-  put (get l y) x
-  = put (get l (put y' one)) (put x' one)
-  = put y' (put x' one)
-  = put y' one
-  = y
-so we have
-  frame_pres p _ x y
-as desired
-*)
 
 (** The refinement of a ref *)
 

From ff9fb7b2d59342af8db621273209df06fc4101fb Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 10:55:55 -0700
Subject: [PATCH 048/513] ref_upd

---
 examples/steel/AggregateRef.fst | 32 ++++++--------------------------
 1 file changed, 6 insertions(+), 26 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index b849a7b0a75..34ba8fa55f9 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -976,7 +976,7 @@ let unrefine #inames (r': ref 'a 'b)
 = change_equal_vprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
 let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
-  (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+  (f: ('b -> 'b){frame_pres r.q f x y})
 : frame_preserving_upd r.p
     (put r.pl x (one (refined_pcm r.re)))
     (put r.pl y (one (refined_pcm r.re)))
@@ -986,33 +986,13 @@ let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
     (r.u (Ghost.reveal x') (Ghost.reveal y')
       (pcm_lens_lift r.pl (Ghost.reveal x') y f))
 
-(*
-let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+let ref_upd_act (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
 : M.action_except unit Set.empty (r `pts_to` x) (fun _ -> r `pts_to` y)
-= let f': refine_t r.re.f -> refine_t r.re.f = upd r.pl f in
-  let hf'
-  : squash (frame_pres (refined_pcm r.re) f'
-      (put r.pl x (one (refined_pcm r.re)))
-      (put r.pl y (one (refined_pcm r.re))))
-  = pcm_lens_frame_pres (refined_pcm r.re) r.q r.pl (put r.pl x (one (refined_pcm r.re))) y f in
-  M.upd_gen Set.empty r.r x y (frame_pres_mk_upd (refined_pcm r.re)
-      (put r.pl x (one (refined_pcm r.re)))
-      (put r.pl y (one (refined_pcm r.re)))
-  f' hf')
-let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: 'b -> 'b) (hf: frame_pres r.q f x y)
+= M.upd_gen Set.empty r.r _ _ (ref_frame_preserving_upd r x y f)
+
+let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
 : SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
-= let f': 'a -> 'a = upd r.pl f in
-  let hf'
-  : frame_pres r.p f'
-      (put x (one (refined_pcm r.re)))
-      (put y (one (refined_pcm r.re)))
-  = pcm_lens_frame_pres r.p r.q r.pl (put x (one (refined_pcm r.re))) y f' in
-  let act : M.action_except unit Set.empty _ _ = M.upd_gen Set.empty r.r x y (frame_pres_mk_upd r.p
-      (put x (one (refined_pcm r.re)))
-      (put y (one (refined_pcm r.re)))
-  f' hf') in
-  as_action act
-  *)
+= as_action (ref_upd_act r x y f)
 
 (** Example: a model for a tagged union representing colors in RGB or HSV
       type color =

From 690ab370d61a0dafafd1ccc809d3eb08c4ebc8d7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 2 Jul 2021 15:09:48 -0700
Subject: [PATCH 049/513] Sketch fix for refinements, necessary for read

---
 examples/steel/AggregateRef.fst | 199 +++++++++++++++++++++++++++++++-
 1 file changed, 198 insertions(+), 1 deletion(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 34ba8fa55f9..a9413db50cf 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -95,7 +95,7 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement #a (p: pcm a) = {
   f: a -> prop;
-  f_closed_under_op: x: refine_t f -> y: refine_t f{composable p x y} -> Lemma (f (op p x y));
+  f_closed_under_op: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
   new_one: (new_one:refine_t f{p.refine new_one});
   new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
@@ -994,6 +994,203 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q
 : SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
 = as_action (ref_upd_act r x y f)
 
+let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
+: Steel 'a
+    (to_vprop (r `pts_to` x)) 
+    (fun _ -> to_vprop (r `pts_to` x))
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible r.p (put r.pl x (one (refined_pcm r.re))) x')
+= change_equal_vprop (r `pts_to` x)
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
+  let v = Steel.PCMReference.read r.r (put r.pl x (one (refined_pcm r.re))) in
+  change_equal_vprop
+    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
+    (r `pts_to` x);
+  A.return v
+
+(*
+
+TODO
+ - write everything in terms of frame_preserving_upd instead of frame_pres
+ - strengthen the f_closed_under_op law
+     f x
+     composable x y
+     -----------------
+     f (x * y)
+
+*)
+(*
+extend_refinement (l: pcm_lens p q) (re: refinement q): refinement p
+restricts p to elements of the form put x (one p)
+restricts p to elements y where get y satisfies re
+
+endo a = a -> a
+
+endo (extend_refinement_f l re) on x y
+     -------------------------- values of the form put x (one p) where x satisfies re
+                                carrier of the PCM (refined_pcm (extend_refinement l re))
+                                this PCM is isomorphic to (refined_pcm re)
+endo re.f on (get l x) (get l y)
+endo q on (get l x) (get l y)
+endo p on x (put (get l y) x)
+
+we know exist x', y'
+  x = put x' one
+  y = put y' one
+
+endo p on (put x' one) (put (get l (put y' one)) (put x' one))
+endo p on (put x' one) (put y' (put x' one))
+endo p on (put x' one) (put y' one)
+endo p on x y
+
+id
+id . l satisfies some property
+id . l . m
+pcm_lens_refine (id . l . m) re
+pcm_lens_refine (id . l . m) re . p
+
+unrefine re -> unrefine (extend l re)
+unrefine re -> unrefine (extend (refine l re') re)
+
+unrefine re -> unrefine (re.f . get)
+unrefine re -> unrefine (re.f . get refined by re')
+
+pcm_refinement: pcm 'a -> Type
+
+(p: pcm 'a)
+(re: pcm_refinement p)
+--------------------------
+re.f: 'a -> prop
+
+refined_pcm: (p: pcm 'a) -> pcm_refinement p -> pcm (refine_t re.f)
+
+For writes:  a property P (re, pcm_refine, ..)
+  re: pcm_refinement (p: pcm 'a)
+  --------------------------------------
+  (refine_t re.f -> refine_t re.f)(frame-preserving x to y) ->
+  ('a -> 'a)(frame-preserving x to y)
+
+For writes:  a property P (re, pcm_refine, ..)
+  re: pcm_refinement (p: pcm 'a)
+  --------------------------------------
+  frame_preserving_upd x to y on (refine_t re.f) values ->
+  frame_preserving_upd x to y on 'a values
+
+For reads:  a property Q (re, pcm_refine, ..)
+  supp. r `pts_to` x
+  PCMReference.read r.r will give v where
+    compatible r.p (put r.pl x (one (refined_pcm r.re))) v
+  Need to use (get r.pl) to extract v' compatible with x
+  Want (compatible r.q x v')
+  Intuitively,
+    re: pcm_refinement p
+    re.f x 
+    compatible p x v
+    ----------------------
+    re.f v
+
+extend_refinement: pcm_lens p q -> pcm_refinement q -> pcm_refinement p
+conj_refinement:
+  re: pcm_refinement p ->
+  pcm_refinement (refined_pcm re) ->
+  pcm_refinement p
+
+// focus: composes a lens (r.pl becomes r.pl ○ some new lens)
+refine: adds a refinement re
+  r.pl becomes pcm_lens_refine r.pl re
+  r.re becomes conj_refinement r.re (extend_refinement r.pl re)
+
+Want impl s.t.
+  some precondition ==>
+  (P /\ Q) (r.pl, ..) ==>
+  (P /\ Q) (r.pl ○ new lens, ..)
+  P and Q don't mention r.pl
+and
+  some precondition ==>
+  (P /\ Q) (r.pl, r.re, ..) ==>
+  (P /\ Q) (pcm_lens_refine r.pl re, conj_refinement r.re (extend_refinement r.pl re), ..)
+  - P r.re ==> P (conj_refinement r.re (extend_refinement r.pl re))
+    (forall x y, (endo r.re.f -> endo a)(frame-pres x y)) ->
+    (forall x y, (endo (refine_t (fun x -> r.re.f x /\ re.f (get r.pl x))) -> endo a)(frame-pres x y))
+    
+    (forall x y, (endo (refine_t (fun x -> r.re.f x /\ re.f (get r.pl x))) ->
+             endo r.re.f)(frame-pres x y))
+             
+    (forall x y, (endo (refine_t (fun (x: refine_t r.re.f) -> re.f (get r.pl x))) ->
+             endo r.re.f)(frame-pres x y))
+             
+    (forall x y, (endo (refine_t (fun x -> re.f (get r.pl x))) ->
+             endo r.re.f)(frame-pres x y)) // "how to unrefine" re.f ○ get r.pl
+
+    f:(refine_t (re.f ○ get r.pl) -> refine_t (re.f ○ get r.pl))
+      {frame_pres (extend_refinement r.pl re) f x y}
+    --
+    g:(refine_t r.re.f -> refine_t r.re.f){frame_pres (refined_pcm r.re) f x y}
+    fun (v: refine_t r.re.f) ->
+      ? (re.f (get r.pl v))
+      _ : refine_t r.re.f
+
+    f:frame_preserving_upd (extend_refinement r.pl re) f x y
+    ----------------------------------------
+    g:frame_preserving_upd (refined_pcm r.re) f x y
+    fun (v: refine_t r.re.f) ->
+      compatible (refined_pcm r.re) x v
+      (refined_pcm r.re).refine v
+      re.f (get r.pl x)
+      re.f (get r.pl v)
+      f v
+  - 
+    forall x v,
+    r.re.f x 
+    compatible p x v
+    ----------------------
+    r.re.f v
+
+    forall x v,
+    r.re.f x /\ re.f (get r.pl x)
+    compatible p x v = exists frame, x * frame = v
+    ----------------------
+    r.re.f v /\ re.f (get r.pl v)
+
+
+    f x
+    composable x y
+    -----------------
+    f (x * y)
+    
+    (conj_refinement r.re (extend_refinement r.pl re)): pcm_refinement p
+    conj_refinement_f r.re (extend_refinement_f r.pl re) x
+    compatible p x v
+    ----------------------
+    conj_refinement_f r.re (extend_refinement_f r.pl re) v
+
+let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  // (l: pcm_lens p q)
+  (l: pcm_lens_description p q)
+  (re: pcm_refinement q) (u: pcm_unrefinement re)
+: pcm_unrefinement (extend_refinement (lens_denote l) re)
+= fun x y f ->
+  let f = extend_refinement_lift l re x y f in
+  let f = u (get l x) (get l y) f in
+  let f = pcm_lens_lift l (Ghost.reveal x) (get l y) f in
+  f
+
+where x satisfies re
+
+
+suppose
+  x satisfies (extend l re) <==> x = (x', one) where x' satisfies re
+  exists frame, x * frame = v
+    (x', one) * frame = v
+  -------------------------
+  exists v'. v satisfies (extend l re) <==> v = (v', one) where v' satisfies re
+
+x refined
+compatible r.p x v
+------------------
+v refined
+*)
+
 (** Example: a model for a tagged union representing colors in RGB or HSV
       type color =
         | RGB : r:int -> g:int -> b:int -> color

From 3a4a3689ff84ea4472c7f72e649837c0b1b62ee7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 6 Jul 2021 13:16:40 -0700
Subject: [PATCH 050/513] Get read to work

---
 examples/steel/AggregateRef.fst | 529 ++++++++++++--------------------
 1 file changed, 197 insertions(+), 332 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index a9413db50cf..881faa828f5 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -95,7 +95,7 @@ let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: '
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement #a (p: pcm a) = {
   f: a -> prop;
-  f_closed_under_op: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
+  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
   new_one: (new_one:refine_t f{p.refine new_one});
   new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
@@ -104,7 +104,7 @@ let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) =
 
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
   (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_under_op x y; op p x y
+= r.f_closed_comp x y; op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
@@ -118,19 +118,45 @@ let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): refined_one_pcm (refine_t r.
   refine = p.refine;
 }
 
+let pcm_refinement_comp_new_one (#p: pcm 'a)
+  (re: pcm_refinement p) (x: refine_t re.f)
+  (y: 'a{composable p x y})
+: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
+         composable (refined_pcm re) x (op p re.new_one y))
+= re.new_one_is_refined_unit x;
+  p.assoc_r x re.new_one y;
+  re.f_closed_comp re.new_one y
+
+let pcm_refinement_compatible_closed (#p: pcm 'a)
+  (re: pcm_refinement p) (x: refine_t re.f)
+  (y: 'a{compatible p x y})
+: Lemma (re.f y /\ compatible (refined_pcm re) x y)
+= let p' = refined_pcm re in
+  compatible_elim p x y (re.f y) (fun frame ->
+   re.f_closed_comp x frame; p.comm frame x);
+  assert (re.f y);
+  compatible_elim p x y (compatible p' x y) (fun frame_x ->
+    assert (composable p x frame_x);
+    pcm_refinement_comp_new_one re x frame_x;
+    assert (composable p re.new_one frame_x);
+    let frame = op p re.new_one frame_x in
+    assert (re.f frame);
+    re.new_one_is_refined_unit x;
+    p.comm x frame_x;
+    assert (op p x frame_x == y);
+    assert (op p (op p x re.new_one) frame_x == y);
+    p.assoc x re.new_one frame_x;
+    assert (op p x (op p re.new_one frame_x) == y);
+    p.comm x (op p re.new_one frame_x);
+    assert (op p (op p re.new_one frame_x) x == y);
+    assert (op p frame x == y);
+    assert (composable p x frame);
+    compatible_intro p' x y (op p re.new_one frame_x))
+
 (** A PCM refinement is well-formed if frame-preserving updates on the
     refined PCM can be turned to frame-preserving updates on the
     unrefined PCM *)
 
-let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
-  f:('a -> 'a){frame_pres p f x y} -> 
-  g:('b -> 'b){frame_pres q g x' y'}
-
-let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
-  x: Ghost.erased (refine_t r.f) ->
-  y: Ghost.erased (refine_t r.f) ->
-  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
-
 (** Very well-behaved lenses *)
 noeq type lens (a: Type u#a) (b: Type u#b) = {
   get: a -> b;
@@ -201,7 +227,7 @@ let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a
 : Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
 = compatible_pcm_morphism l.l.get l.get_morphism x y
     
-let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
+let pcm_lens_frame_pres (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
 : Lemma
     (requires frame_pres q f (get l s) v)
     (ensures frame_pres p (upd l f) s (put l v s))
@@ -230,11 +256,6 @@ let pcm_lens_frame_pres (p: pcm 'a) (q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b
       = () in ()
     in FStar.Classical.forall_intro aux)))
 
-let pcm_lens_lift (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (s: Ghost.erased 'a) (v: Ghost.erased 'b)
-: frame_pres_lift q (get l s) v p s (put l v s)
-= fun f -> pcm_lens_frame_pres p q l s v f; upd l f
-
 (** The identity lens is a pcm_lens *)
 let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
   l = lens_id; 
@@ -271,6 +292,15 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 
 open FStar.FunctionalExtensionality
 
+let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
+  frame_preserving_upd p x y ->
+  frame_preserving_upd q x' y'
+
+let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
+  x: Ghost.erased (refine_t r.f) ->
+  y: Ghost.erased (refine_t r.f) ->
+  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
+
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
@@ -360,7 +390,7 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
 
 let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
   f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
-  f_closed_under_op = (fun _ _ -> ());
+  f_closed_comp = (fun _ _ -> ());
   new_one = Some (Inl #_ #'b (one p));
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
@@ -418,60 +448,47 @@ let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
 : pcm_refinement (union_pcm p) = {
   f = case_refinement_f p k;
-  f_closed_under_op = (fun x y -> ());
+  f_closed_comp = (fun x y -> ());
   new_one = case_refinement_new_one p k;
   new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
 }
 
-let case_unrefinement_unrefine (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
-  (kx: union b): union b
-= match kx with
-  | Some (|k', _|) -> if k = k' then f kx else None
-  | _ -> None
-
-let case_unrefinement_unrefine_ok (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
-  (f: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k))
-  (kx ky: Ghost.erased (refine_t (case_refinement_f p k)))
-: Lemma
-    (requires frame_pres (refined_pcm (case_refinement p k)) f kx ky)
-    (ensures frame_pres (union_pcm p)
-               (case_unrefinement_unrefine p k f)
-               (Ghost.reveal kx) (Ghost.reveal ky))
-= let Some (|_, x|) = Ghost.reveal kx in
-  let Some (|_, y|) = Ghost.reveal ky in
-  let p' = refined_pcm (case_refinement p k) in
-  frame_pres_intro (union_pcm p) (case_unrefinement_unrefine p k f)
-    (Ghost.reveal kx) (Ghost.reveal ky)
-    (fun kv -> match kv with
-      | Some (|k', v|) -> 
-        if k = k' then begin
-          compatible_elim (union_pcm p) (Ghost.reveal kx) kv
-            (compatible (refined_pcm (case_refinement p k)) kx kv)
-            (fun frame_kx -> match frame_kx with
-              | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
-              | None -> compatible_refl p' kx);
-          let aux (frame:union b{composable (union_pcm p) kx frame})
-          : Lemma (composable (union_pcm p) ky frame /\
-                   (op (union_pcm p) kx frame == Some (|k, v|) ==>
-                    op (union_pcm p) ky frame == f (Some (|k, v|))))
-          = let Some (|_, w|) = f (Some (|k, v|)) in
-            match frame with
-            | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
-            | None ->
-              p'.is_unit kx;
-              assert (composable p' kx (one p'));
-              p'.is_unit ky
-          in FStar.Classical.forall_intro aux
-        end else ()
-      | None -> ())
-    
 let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
 : pcm_unrefinement (case_refinement p k)
-= fun kx ky f ->
-  case_unrefinement_unrefine_ok p k f kx ky; 
-  case_unrefinement_unrefine p k f
-  
+= fun kx ky f kv ->
+  let p' = refined_pcm (case_refinement p k) in
+  let p = union_pcm p in
+  match kv with
+  | Some (|k', v|) ->
+    if k = k' then begin
+      assert (p.refine kv);
+      assert (p'.refine kv);
+      assert (compatible p kx kv);
+      let _ = Ghost.hide (
+        let Some (|k, x|) = Ghost.reveal kx in
+        let goal = compatible p' kx kv in
+        compatible_elim p kx kv goal (fun kx_frame -> match kx_frame with
+          | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
+          | None -> compatible_refl p' kx))
+      in
+      assert (compatible p' kx kv);
+      let kw = f kv in
+      let aux (frame:union b{composable p kx frame})
+      : Lemma (composable p ky frame /\
+               (op p kx frame == Some (|k, v|) ==>
+                op p ky frame == f (Some (|k, v|))))
+      = let Some (|_, w|) = f (Some (|k, v|)) in
+        match frame with
+        | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
+        | None ->
+          p'.is_unit kx;
+          assert (composable p' kx (one p'));
+          p'.is_unit ky
+      in FStar.Classical.forall_intro aux;
+      kw
+    end else None
+  | _ -> None
+
 (** A lens for the k-th case of an n-ary union *)
 
 let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
@@ -500,7 +517,7 @@ let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
 
 let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement q) (x: 'a): prop
-= re.f (get l x) /\ x == put l (get l x) (one p)
+= re.f (get l x)
 
 let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement q) (s: refine_t (extend_refinement_f l re))
@@ -524,12 +541,10 @@ let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement
 
 let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
-  (y: refine_t (extend_refinement_f l re){composable p x y})
+  (y: 'a{composable p x y})
 : Lemma (extend_refinement_f l re (op p x y))
 = l.get_morphism.f_op x y;
-  re.f_closed_under_op (get l x) (get l y);
-  p.is_unit (one p);
-  l.put_morphism.f_op (get l x, one p) (get l y, one p)
+  re.f_closed_comp (get l x) (get l y)
 
 let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
@@ -549,7 +564,7 @@ let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q)
 : pcm_refinement p = {
   f = extend_refinement_f l re;
-  f_closed_under_op = extend_refinement_f_closed l re;
+  f_closed_comp = extend_refinement_f_closed l re;
   new_one = extend_refinement_new_one l re;
   new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
 }
@@ -710,10 +725,16 @@ let conj_refinement_f (#p: pcm 'a)
 let conj_refinement_f_closed (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
   (x: refine_t (conj_refinement_f re1 re2))
-  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
+  (y: 'a{composable p x y})
 : Lemma (conj_refinement_f re1 re2 (op p x y))
-= re1.f_closed_under_op x y;
-  re2.f_closed_under_op x y
+= pcm_refinement_comp_new_one re1 x y;
+  re1.f_closed_comp x (op p re1.new_one y);
+  pcm_refinement_comp_new_one re2 x (op p re1.new_one y);
+  re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
+  p.assoc x re2.new_one (op p re1.new_one y);
+  re2.new_one_is_refined_unit x;
+  p.assoc x re1.new_one y;
+  re1.new_one_is_refined_unit x
 
 (* re1.new_one and re2.new_one both work; we go with re2 *)
 let conj_refinement_new_one (#p: pcm 'a)
@@ -732,7 +753,7 @@ let conj_refinement (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
 : pcm_refinement p = {
   f = conj_refinement_f re1 re2;
-  f_closed_under_op = conj_refinement_f_closed re1 re2;
+  f_closed_comp = conj_refinement_f_closed re1 re2;
   new_one = conj_refinement_new_one re1 re2;
   new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
 }
@@ -750,27 +771,21 @@ let pcm_refinement_conj_iso (p: pcm 'a)
 
 let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
 : frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
-= fun f ->
-  let f' = i.i.fwd `compose` f `compose` i.i.bwd in
-  let aux ()
-  : Lemma
-      (requires frame_pres p f x y)
-      (ensures frame_pres q f' (i.i.fwd x) (i.i.fwd y))
-  = frame_pres_intro q f' (i.i.fwd x) (i.i.fwd y) (fun v ->
-      i.bwd_morphism.f_refine v;
-      compatible_pcm_morphism i.i.bwd i.bwd_morphism (i.i.fwd x) v;
-      i.fwd_morphism.f_refine (f (i.i.bwd v));
-      compatible_pcm_morphism i.i.fwd i.fwd_morphism y (f (i.i.bwd v));
-      let aux (frame:'b{composable q (i.i.fwd x) frame})
-      : Lemma (composable q (i.i.fwd y) frame /\
-               (op q (i.i.fwd x) frame == v ==>
-                op q (i.i.fwd y) frame == f' v))
-      = i.bwd_morphism.f_op (i.i.fwd x) frame;
-        i.fwd_morphism.f_op y (i.i.bwd frame);
-        i.fwd_morphism.f_op x (i.i.bwd frame)
-      in FStar.Classical.forall_intro aux)
-  in aux ();
-  f'
+= fun f v ->
+  i.bwd_morphism.f_refine v;
+  compatible_pcm_morphism i.i.bwd i.bwd_morphism (i.i.fwd x) v;
+  let w = i.i.fwd (f (i.i.bwd v)) in
+  i.fwd_morphism.f_refine (f (i.i.bwd v));
+  compatible_pcm_morphism i.i.fwd i.fwd_morphism y (f (i.i.bwd v));
+  let aux (frame:'b{composable q (i.i.fwd x) frame})
+  : Lemma (composable q (i.i.fwd y) frame /\
+           (op q (i.i.fwd x) frame == v ==>
+            op q (i.i.fwd y) frame == w))
+  = i.bwd_morphism.f_op (i.i.fwd x) frame;
+    i.fwd_morphism.f_op y (i.i.bwd frame);
+    i.fwd_morphism.f_op x (i.i.bwd frame)
+  in FStar.Classical.forall_intro aux;
+  w
 
 let conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
@@ -781,49 +796,82 @@ let conj_unrefinement (#p: pcm 'a)
   h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
   upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2) x y
 
-let extend_refinement_iso (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: pcm_iso (refined_pcm (extend_refinement l re)) (refined_pcm re)
-= let a' = refine_t (extend_refinement_f l re) in
-  let b' = refine_t re.f in
-  let p' = refined_pcm (extend_refinement l re) in
-  let q' = refined_pcm re in
-  let fwd (x: a'): b' = get l x in
-  let bwd (x: b'): a' = put l x (one p) in
-  let i: iso a' b' = {fwd = fwd; bwd = bwd; fwd_bwd = (fun x -> ()); bwd_fwd = (fun x -> ())} in
-  let fwd_morphism: pcm_morphism i.fwd p' q' =
-    let f_refine: morphism_refine p' q' i.fwd = fun x -> l.get_morphism.f_refine x in
-    let f_one: morphism_one p' q' i.fwd = fun x -> l.get_morphism.f_one x in
-    let f_op: morphism_op p' q' i.fwd = fun x y -> l.get_morphism.f_op x y in
-    {f_refine = f_refine; f_one = f_one; f_op = f_op}
-  in
-  let bwd_morphism: pcm_morphism i.bwd q' p' = 
-    let f_refine: morphism_refine q' p' i.bwd = fun x -> l.put_morphism.f_refine (x, one p) in
-    let f_one: morphism_one q' p' i.bwd = fun _ -> () in
-    let f_op: morphism_op q' p' i.bwd = fun x y ->
-      p.is_unit (one p);
-      l.put_morphism.f_op (x, one p) (y, one p)
-    in
-    {f_refine = f_refine; f_one = f_one; f_op = f_op}
-  in
-  {i = i; fwd_morphism = fwd_morphism; bwd_morphism = bwd_morphism}
-
-let extend_refinement_lift (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-  (x y: Ghost.erased (refine_t (extend_refinement_f l re)))
-: frame_pres_lift
-    (refined_pcm (extend_refinement l re)) x y
-    (refined_pcm re) (get l x) (get l y)
-= upd_across_pcm_iso (extend_refinement_iso l re) x y 
-
 let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
-= fun x y f ->
-  let f = extend_refinement_lift l re x y f in
-  let f = u (get l x) (get l y) f in
-  let f = pcm_lens_lift l (Ghost.reveal x) (get l y) f in
-  f
+= fun x y f v ->
+  let re' = extend_refinement l re in
+  let p' = refined_pcm re' in
+  assert (p.refine v);
+  assert (compatible p x v);
+  assert (re.f (get l x));
+  pcm_lens_compatible_get l x v;
+  assert (compatible q (get l x) (get l v));
+  compatible_elim q (get l x) (get l v) (re.f (get l v)) (fun frame_x ->
+    re.f_closed_comp (get l x) frame_x;
+    q.comm (get l x) frame_x);
+  compatible_elim p x v (compatible p' x v) (fun frame_x ->
+    l.get_morphism.f_op x frame_x;
+    assert (composable q (get l x) (get l frame_x));
+    pcm_refinement_comp_new_one re (get l x) (get l frame_x);
+    assert (composable q re.new_one (get l frame_x));
+    p.is_unit frame_x;
+    assert (composable p (one p) frame_x);
+    l.put_morphism.f_op (re.new_one, one p) (get l frame_x, frame_x);
+    assert (composable p re'.new_one (put l (get l frame_x) frame_x));
+    let frame = op p re'.new_one frame_x in
+    assert (re.f (get l frame));
+    assert (re.f (get l (op p re'.new_one frame_x)));
+    re'.new_one_is_refined_unit x;
+    assert (composable p (op p x re'.new_one) frame_x);
+    p.assoc_r x re'.new_one frame_x;
+    assert (composable p x (op p re'.new_one frame_x));
+    assert (composable p' x (op p re'.new_one frame_x));
+    assert (composable p' x frame);
+    assert (op p frame_x x == v);
+    re.new_one_is_refined_unit (get l x);
+    p.is_unit x;
+    l.put_morphism.f_op (re.new_one, one p) (get l x, Ghost.reveal x);
+    assert (composable p re'.new_one x);
+    p.comm re'.new_one frame_x;
+    p.assoc_r frame_x re'.new_one x;
+    assert (composable p frame_x (op p re'.new_one x));
+    assert (put l (get l x) x == Ghost.reveal x);
+    p.comm (one p) x;
+    q.comm re.new_one (get l x);
+    assert (put l (op q re.new_one (get l x)) (op p (one p) x) == Ghost.reveal x);
+    assert (op p re'.new_one x == Ghost.reveal x);
+    assert (op p frame_x (op p re'.new_one x) == v);
+    p.assoc frame_x re'.new_one x;
+    assert (op p (op p frame_x re'.new_one) x == v);
+    assert (op p (op p re'.new_one frame_x) x == v);
+    assert (op p' frame x == v);
+    compatible_intro p' x v (op p (put l re.new_one (one p)) frame_x));
+  assert (re.f (get l v));
+  let w = f v in
+  assert (re.f (get l w));
+  assert (compatible p' y w);
+  let aux (frame:'a{composable p x frame})
+  : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
+  = pcm_refinement_comp_new_one re' x frame;
+    let frame' = op p re'.new_one frame in
+    assert (re.f (get l frame'));
+    assert (forall (frame':refine_t re'.f{composable p' x frame'}).{:pattern (composable p' x frame')}
+      composable p' y frame' /\ 
+      (op p' x frame' == v ==> op p' y frame' == w));
+    assert (composable p' x frame');
+    assert (composable p' y frame' /\ (op p' x frame' == v ==> op p' y frame' == w));
+    p.assoc y re'.new_one frame;
+    assert (composable p (op p y re'.new_one) frame);
+    re'.new_one_is_refined_unit y;
+    assert (composable p y frame);
+    p.assoc x re'.new_one frame;
+    re'.new_one_is_refined_unit x;
+    assert (op p x frame' == v ==> op p y frame' == w);
+    assert (op p x frame == v ==> op p y frame' == w);
+    assert (op p x frame == v ==> op p y frame == w)
+  in FStar.Classical.forall_intro aux;
+  w
 
 (** The refinement of a ref *)
 
@@ -982,9 +1030,8 @@ let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
     (put r.pl y (one (refined_pcm r.re)))
 = let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
   let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re))) in
-  frame_pres_mk_upd r.p x' y'
-    (r.u (Ghost.reveal x') (Ghost.reveal y')
-      (pcm_lens_lift r.pl (Ghost.reveal x') y f))
+  pcm_lens_frame_pres r.pl x' y f;
+  r.u x' y' (frame_pres_mk_upd (refined_pcm r.re) x' y' (upd r.pl f))
 
 let ref_upd_act (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
 : M.action_except unit Set.empty (r `pts_to` x) (fun _ -> r `pts_to` y)
@@ -995,201 +1042,19 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q
 = as_action (ref_upd_act r x y f)
 
 let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
-: Steel 'a
+: Steel 'b
     (to_vprop (r `pts_to` x)) 
     (fun _ -> to_vprop (r `pts_to` x))
     (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible r.p (put r.pl x (one (refined_pcm r.re))) x')
-= change_equal_vprop (r `pts_to` x)
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
-  let v = Steel.PCMReference.read r.r (put r.pl x (one (refined_pcm r.re))) in
-  change_equal_vprop
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
-    (r `pts_to` x);
-  A.return v
-
-(*
-
-TODO
- - write everything in terms of frame_preserving_upd instead of frame_pres
- - strengthen the f_closed_under_op law
-     f x
-     composable x y
-     -----------------
-     f (x * y)
-
-*)
-(*
-extend_refinement (l: pcm_lens p q) (re: refinement q): refinement p
-restricts p to elements of the form put x (one p)
-restricts p to elements y where get y satisfies re
-
-endo a = a -> a
-
-endo (extend_refinement_f l re) on x y
-     -------------------------- values of the form put x (one p) where x satisfies re
-                                carrier of the PCM (refined_pcm (extend_refinement l re))
-                                this PCM is isomorphic to (refined_pcm re)
-endo re.f on (get l x) (get l y)
-endo q on (get l x) (get l y)
-endo p on x (put (get l y) x)
-
-we know exist x', y'
-  x = put x' one
-  y = put y' one
-
-endo p on (put x' one) (put (get l (put y' one)) (put x' one))
-endo p on (put x' one) (put y' (put x' one))
-endo p on (put x' one) (put y' one)
-endo p on x y
-
-id
-id . l satisfies some property
-id . l . m
-pcm_lens_refine (id . l . m) re
-pcm_lens_refine (id . l . m) re . p
-
-unrefine re -> unrefine (extend l re)
-unrefine re -> unrefine (extend (refine l re') re)
-
-unrefine re -> unrefine (re.f . get)
-unrefine re -> unrefine (re.f . get refined by re')
-
-pcm_refinement: pcm 'a -> Type
-
-(p: pcm 'a)
-(re: pcm_refinement p)
---------------------------
-re.f: 'a -> prop
-
-refined_pcm: (p: pcm 'a) -> pcm_refinement p -> pcm (refine_t re.f)
-
-For writes:  a property P (re, pcm_refine, ..)
-  re: pcm_refinement (p: pcm 'a)
-  --------------------------------------
-  (refine_t re.f -> refine_t re.f)(frame-preserving x to y) ->
-  ('a -> 'a)(frame-preserving x to y)
-
-For writes:  a property P (re, pcm_refine, ..)
-  re: pcm_refinement (p: pcm 'a)
-  --------------------------------------
-  frame_preserving_upd x to y on (refine_t re.f) values ->
-  frame_preserving_upd x to y on 'a values
-
-For reads:  a property Q (re, pcm_refine, ..)
-  supp. r `pts_to` x
-  PCMReference.read r.r will give v where
-    compatible r.p (put r.pl x (one (refined_pcm r.re))) v
-  Need to use (get r.pl) to extract v' compatible with x
-  Want (compatible r.q x v')
-  Intuitively,
-    re: pcm_refinement p
-    re.f x 
-    compatible p x v
-    ----------------------
-    re.f v
-
-extend_refinement: pcm_lens p q -> pcm_refinement q -> pcm_refinement p
-conj_refinement:
-  re: pcm_refinement p ->
-  pcm_refinement (refined_pcm re) ->
-  pcm_refinement p
-
-// focus: composes a lens (r.pl becomes r.pl ○ some new lens)
-refine: adds a refinement re
-  r.pl becomes pcm_lens_refine r.pl re
-  r.re becomes conj_refinement r.re (extend_refinement r.pl re)
-
-Want impl s.t.
-  some precondition ==>
-  (P /\ Q) (r.pl, ..) ==>
-  (P /\ Q) (r.pl ○ new lens, ..)
-  P and Q don't mention r.pl
-and
-  some precondition ==>
-  (P /\ Q) (r.pl, r.re, ..) ==>
-  (P /\ Q) (pcm_lens_refine r.pl re, conj_refinement r.re (extend_refinement r.pl re), ..)
-  - P r.re ==> P (conj_refinement r.re (extend_refinement r.pl re))
-    (forall x y, (endo r.re.f -> endo a)(frame-pres x y)) ->
-    (forall x y, (endo (refine_t (fun x -> r.re.f x /\ re.f (get r.pl x))) -> endo a)(frame-pres x y))
-    
-    (forall x y, (endo (refine_t (fun x -> r.re.f x /\ re.f (get r.pl x))) ->
-             endo r.re.f)(frame-pres x y))
-             
-    (forall x y, (endo (refine_t (fun (x: refine_t r.re.f) -> re.f (get r.pl x))) ->
-             endo r.re.f)(frame-pres x y))
-             
-    (forall x y, (endo (refine_t (fun x -> re.f (get r.pl x))) ->
-             endo r.re.f)(frame-pres x y)) // "how to unrefine" re.f ○ get r.pl
-
-    f:(refine_t (re.f ○ get r.pl) -> refine_t (re.f ○ get r.pl))
-      {frame_pres (extend_refinement r.pl re) f x y}
-    --
-    g:(refine_t r.re.f -> refine_t r.re.f){frame_pres (refined_pcm r.re) f x y}
-    fun (v: refine_t r.re.f) ->
-      ? (re.f (get r.pl v))
-      _ : refine_t r.re.f
-
-    f:frame_preserving_upd (extend_refinement r.pl re) f x y
-    ----------------------------------------
-    g:frame_preserving_upd (refined_pcm r.re) f x y
-    fun (v: refine_t r.re.f) ->
-      compatible (refined_pcm r.re) x v
-      (refined_pcm r.re).refine v
-      re.f (get r.pl x)
-      re.f (get r.pl v)
-      f v
-  - 
-    forall x v,
-    r.re.f x 
-    compatible p x v
-    ----------------------
-    r.re.f v
-
-    forall x v,
-    r.re.f x /\ re.f (get r.pl x)
-    compatible p x v = exists frame, x * frame = v
-    ----------------------
-    r.re.f v /\ re.f (get r.pl v)
-
-
-    f x
-    composable x y
-    -----------------
-    f (x * y)
-    
-    (conj_refinement r.re (extend_refinement r.pl re)): pcm_refinement p
-    conj_refinement_f r.re (extend_refinement_f r.pl re) x
-    compatible p x v
-    ----------------------
-    conj_refinement_f r.re (extend_refinement_f r.pl re) v
-
-let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  // (l: pcm_lens p q)
-  (l: pcm_lens_description p q)
-  (re: pcm_refinement q) (u: pcm_unrefinement re)
-: pcm_unrefinement (extend_refinement (lens_denote l) re)
-= fun x y f ->
-  let f = extend_refinement_lift l re x y f in
-  let f = u (get l x) (get l y) f in
-  let f = pcm_lens_lift l (Ghost.reveal x) (get l y) f in
-  f
-
-where x satisfies re
-
-
-suppose
-  x satisfies (extend l re) <==> x = (x', one) where x' satisfies re
-  exists frame, x * frame = v
-    (x', one) * frame = v
-  -------------------------
-  exists v'. v satisfies (extend l re) <==> v = (v', one) where v' satisfies re
-
-x refined
-compatible r.p x v
-------------------
-v refined
-*)
+    (ensures fun _ x' _ -> compatible r.q x x')
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+  change_equal_vprop (r `pts_to` x) (r.r `M.pts_to` x');
+  let v = Steel.PCMReference.read r.r x' in
+  pcm_refinement_compatible_closed r.re x' v;
+  assert (r.re.f v /\ compatible (refined_pcm r.re) x' v);
+  pcm_lens_compatible_get r.pl x' v;
+  change_equal_vprop (r.r `M.pts_to` Ghost.reveal x') (r `pts_to` x);
+  A.return (get r.pl v)
 
 (** Example: a model for a tagged union representing colors in RGB or HSV
       type color =

From 83c3d8dccf2acba6681ed863471a4077a40d1884 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 6 Jul 2021 13:21:57 -0700
Subject: [PATCH 051/513] Tidy

---
 examples/steel/AggregateRef.fst | 78 ++-------------------------------
 1 file changed, 3 insertions(+), 75 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 881faa828f5..53e280e1274 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -134,23 +134,13 @@ let pcm_refinement_compatible_closed (#p: pcm 'a)
 = let p' = refined_pcm re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
-  assert (re.f y);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    assert (composable p x frame_x);
     pcm_refinement_comp_new_one re x frame_x;
-    assert (composable p re.new_one frame_x);
     let frame = op p re.new_one frame_x in
-    assert (re.f frame);
     re.new_one_is_refined_unit x;
     p.comm x frame_x;
-    assert (op p x frame_x == y);
-    assert (op p (op p x re.new_one) frame_x == y);
     p.assoc x re.new_one frame_x;
-    assert (op p x (op p re.new_one frame_x) == y);
     p.comm x (op p re.new_one frame_x);
-    assert (op p (op p re.new_one frame_x) x == y);
-    assert (op p frame x == y);
-    assert (composable p x frame);
     compatible_intro p' x y (op p re.new_one frame_x))
 
 (** A PCM refinement is well-formed if frame-preserving updates on the
@@ -461,9 +451,6 @@ let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   match kv with
   | Some (|k', v|) ->
     if k = k' then begin
-      assert (p.refine kv);
-      assert (p'.refine kv);
-      assert (compatible p kx kv);
       let _ = Ghost.hide (
         let Some (|k, x|) = Ghost.reveal kx in
         let goal = compatible p' kx kv in
@@ -471,7 +458,6 @@ let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
           | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
           | None -> compatible_refl p' kx))
       in
-      assert (compatible p' kx kv);
       let kw = f kv in
       let aux (frame:union b{composable p kx frame})
       : Lemma (composable p ky frame /\
@@ -802,74 +788,17 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
 = fun x y f v ->
   let re' = extend_refinement l re in
   let p' = refined_pcm re' in
-  assert (p.refine v);
-  assert (compatible p x v);
-  assert (re.f (get l x));
+  pcm_refinement_compatible_closed re' x v;
   pcm_lens_compatible_get l x v;
-  assert (compatible q (get l x) (get l v));
-  compatible_elim q (get l x) (get l v) (re.f (get l v)) (fun frame_x ->
-    re.f_closed_comp (get l x) frame_x;
-    q.comm (get l x) frame_x);
-  compatible_elim p x v (compatible p' x v) (fun frame_x ->
-    l.get_morphism.f_op x frame_x;
-    assert (composable q (get l x) (get l frame_x));
-    pcm_refinement_comp_new_one re (get l x) (get l frame_x);
-    assert (composable q re.new_one (get l frame_x));
-    p.is_unit frame_x;
-    assert (composable p (one p) frame_x);
-    l.put_morphism.f_op (re.new_one, one p) (get l frame_x, frame_x);
-    assert (composable p re'.new_one (put l (get l frame_x) frame_x));
-    let frame = op p re'.new_one frame_x in
-    assert (re.f (get l frame));
-    assert (re.f (get l (op p re'.new_one frame_x)));
-    re'.new_one_is_refined_unit x;
-    assert (composable p (op p x re'.new_one) frame_x);
-    p.assoc_r x re'.new_one frame_x;
-    assert (composable p x (op p re'.new_one frame_x));
-    assert (composable p' x (op p re'.new_one frame_x));
-    assert (composable p' x frame);
-    assert (op p frame_x x == v);
-    re.new_one_is_refined_unit (get l x);
-    p.is_unit x;
-    l.put_morphism.f_op (re.new_one, one p) (get l x, Ghost.reveal x);
-    assert (composable p re'.new_one x);
-    p.comm re'.new_one frame_x;
-    p.assoc_r frame_x re'.new_one x;
-    assert (composable p frame_x (op p re'.new_one x));
-    assert (put l (get l x) x == Ghost.reveal x);
-    p.comm (one p) x;
-    q.comm re.new_one (get l x);
-    assert (put l (op q re.new_one (get l x)) (op p (one p) x) == Ghost.reveal x);
-    assert (op p re'.new_one x == Ghost.reveal x);
-    assert (op p frame_x (op p re'.new_one x) == v);
-    p.assoc frame_x re'.new_one x;
-    assert (op p (op p frame_x re'.new_one) x == v);
-    assert (op p (op p re'.new_one frame_x) x == v);
-    assert (op p' frame x == v);
-    compatible_intro p' x v (op p (put l re.new_one (one p)) frame_x));
-  assert (re.f (get l v));
   let w = f v in
-  assert (re.f (get l w));
-  assert (compatible p' y w);
   let aux (frame:'a{composable p x frame})
   : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
   = pcm_refinement_comp_new_one re' x frame;
     let frame' = op p re'.new_one frame in
-    assert (re.f (get l frame'));
-    assert (forall (frame':refine_t re'.f{composable p' x frame'}).{:pattern (composable p' x frame')}
-      composable p' y frame' /\ 
-      (op p' x frame' == v ==> op p' y frame' == w));
-    assert (composable p' x frame');
-    assert (composable p' y frame' /\ (op p' x frame' == v ==> op p' y frame' == w));
     p.assoc y re'.new_one frame;
-    assert (composable p (op p y re'.new_one) frame);
     re'.new_one_is_refined_unit y;
-    assert (composable p y frame);
     p.assoc x re'.new_one frame;
-    re'.new_one_is_refined_unit x;
-    assert (op p x frame' == v ==> op p y frame' == w);
-    assert (op p x frame == v ==> op p y frame' == w);
-    assert (op p x frame == v ==> op p y frame == w)
+    re'.new_one_is_refined_unit x
   in FStar.Classical.forall_intro aux;
   w
 
@@ -1051,9 +980,8 @@ let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
   change_equal_vprop (r `pts_to` x) (r.r `M.pts_to` x');
   let v = Steel.PCMReference.read r.r x' in
   pcm_refinement_compatible_closed r.re x' v;
-  assert (r.re.f v /\ compatible (refined_pcm r.re) x' v);
   pcm_lens_compatible_get r.pl x' v;
-  change_equal_vprop (r.r `M.pts_to` Ghost.reveal x') (r `pts_to` x);
+  change_equal_vprop (r.r `M.pts_to` x') (r `pts_to` x);
   A.return (get r.pl v)
 
 (** Example: a model for a tagged union representing colors in RGB or HSV

From eb3b4b8df6160aac925b99ff0dcf210f98563c56 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 6 Jul 2021 16:22:34 -0700
Subject: [PATCH 052/513] Start examples

---
 examples/steel/AggregateRef.fst         |  72 ++-----
 examples/steel/AggregateRefExamples.fst | 262 ++++++++++++++++++++++++
 2 files changed, 274 insertions(+), 60 deletions(-)
 create mode 100644 examples/steel/AggregateRefExamples.fst

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 53e280e1274..d8371ccec54 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -844,13 +844,13 @@ let focus (r: ref 'a 'b) (q: refined_one_pcm 'c)
     (fun m -> r.pl.get_morphism.f_one ());
   A.return r'
 
-let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: refined_one_pcm 'c)
-  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
+let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (#r'q: pcm 'b) (#q: refined_one_pcm 'c)
+  (l: pcm_lens r'q q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (to_vprop (r `pts_to` x))
     (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == ref_focus r' q l)
-    (fun _ _ _ -> True)
+    (requires fun _ -> r'.q == r'q /\ r == ref_focus r' q l)
+    (ensures fun _ _ _ -> True)
 = A.change_slprop_rel  
     (to_vprop (r `pts_to` x))
     (to_vprop (r' `pts_to` put l x (one r'.q)))
@@ -921,11 +921,13 @@ let peel (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.er
   split r x (put l (one q) x) (put l (get l x) (one r.q))
 
 let addr_of_lens (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
-: SteelT (ref 'a 'c)
+: Steel (ref 'a 'c)
     (to_vprop (r `pts_to` x))
     (fun s ->
       to_vprop (r `pts_to` put l (one q) x) `star` 
       to_vprop (s `pts_to` get l x))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r q l)
 = peel r q l x;
   focus r q l (put l (get l x) (one r.q)) (get l x)
 
@@ -970,6 +972,11 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q
 : SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
 = as_action (ref_upd_act r x y f)
 
+let ref_write (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
+: SteelT unit (to_vprop (r `pts_to` Some (Ghost.reveal x))) (fun _ -> to_vprop (r `pts_to` Some y))
+= ref_upd r (Some (Ghost.reveal x)) (Some y)
+    (fun v -> match v with None -> None | Some _ -> Some y)
+
 let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
 : Steel 'b
     (to_vprop (r `pts_to` x)) 
@@ -983,58 +990,3 @@ let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
   pcm_lens_compatible_get r.pl x' v;
   change_equal_vprop (r.r `M.pts_to` x') (r `pts_to` x);
   A.return (get r.pl v)
-
-(** Example: a model for a tagged union representing colors in RGB or HSV
-      type color =
-        | RGB : r:int -> g:int -> b:int -> color
-        | HSV : h:int -> s:int -> v:int -> color *)
-
-type rgb_field = | R | G | B
-type hsv_field = | H | S | V
-type color_tag = | RGB | HSV
-
-(* Carrier of all-or-none PCM for integers *)
-let int_pcm_t = option int
-
-(* Type families for fields of RGB and HSV structs *)
-let rgb_fields k = match k with
-  | R -> int_pcm_t
-  | G -> int_pcm_t
-  | B -> int_pcm_t
-let hsv_fields k = match k with
-  | H -> int_pcm_t
-  | S -> int_pcm_t
-  | V -> int_pcm_t
-  
-(** Carriers of PCMs for RGB and HSV structs *)
-let rgb_t = restricted_t rgb_field rgb_fields
-let hsv_t = restricted_t hsv_field hsv_fields
-
-(** Type family for union of RGB and HSV *)
-let color_cases t = match t with
-  | RGB -> rgb_t
-  | HSV -> hsv_t
-
-(** Carrier of PCM for color *)
-let color_t = union color_cases
-
-(** All-or-none PCM for integers *)
-let int_pcm : pcm int_pcm_t = opt_pcm
-
-(** PCMs for RGB and HSV structs *)
-let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
-  prod_pcm #_ #rgb_fields (fun k -> match k with
-    | R -> int_pcm
-    | G -> int_pcm
-    | B -> int_pcm)
-let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
-  prod_pcm #_ #hsv_fields (fun k -> match k with
-    | H -> int_pcm
-    | S -> int_pcm
-    | V -> int_pcm)
-
-(** PCM for color *)
-let color_pcm_cases k : pcm (color_cases k) = match k with
-  | RGB -> rgb_pcm
-  | HSV -> hsv_pcm
-let color_pcm : pcm color_t = union_pcm color_pcm_cases
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
new file mode 100644
index 00000000000..4eb3f38ccf2
--- /dev/null
+++ b/examples/steel/AggregateRefExamples.fst
@@ -0,0 +1,262 @@
+module AggregateRefExamples
+
+open Aggregates
+open AggregateRef
+open FStar.PCM
+open FStar.FunctionalExtensionality
+
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+/// Example 1: swapping the coordinates of a 2d point
+///
+/// struct point { int x, y; };
+///
+/// void swap(struct point *p) {
+///   int *q = &p.x;
+///   int *r = &p.y;
+///   int tmp = *q;
+///   *q = *r;
+///   *r = tmp;
+/// }
+
+/// Carrier of PCM for struct point:
+
+type point_field = | X | Y
+let point_fields k = match k with
+  | X -> option int
+  | Y -> option int
+let point = restricted_t point_field point_fields
+
+/// PCM for struct point:
+
+let int_pcm = opt_pcm #int
+let point_fields_pcm k : pcm (point_fields k) = match k with
+  | X -> int_pcm
+  | Y -> int_pcm
+let point_pcm = prod_pcm point_fields_pcm
+
+let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
+  | X -> x
+  | Y -> y
+let mk_point (x y: option int): point = on_domain point_field (mk_point_f x y)
+
+let put_x x' x y
+: Lemma (put (field point_fields_pcm X) x' (mk_point x y) == mk_point x' y)
+  [SMTPat (put (field point_fields_pcm X) x' (mk_point x y))]
+= admit()
+
+let get_x x y
+: Lemma (get (field point_fields_pcm X) (mk_point x y) == x)
+  [SMTPat (get (field point_fields_pcm X) (mk_point x y))]
+= admit()
+
+let put_y y' x y
+: Lemma (put (field point_fields_pcm Y) y' (mk_point x y) == mk_point x y')
+  [SMTPat (put (field point_fields_pcm Y) y' (mk_point x y))]
+= admit()
+
+let get_y x y
+: Lemma (get (field point_fields_pcm Y) (mk_point x y) == y)
+  [SMTPat (get (field point_fields_pcm Y) (mk_point x y))]
+= admit()
+
+let merge_xy x y x' y'
+: Lemma (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y') ==
+         mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y'))
+  [SMTPat (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))]
+= admit()
+
+let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
+: SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm X)})
+    (to_vprop (p `pts_to` mk_point x y))
+    (fun q ->
+       to_vprop (p `pts_to` mk_point None y) `star`
+       to_vprop (q `pts_to` x))
+= let q = addr_of_lens p int_pcm (field point_fields_pcm X) (mk_point x y) in
+  change_equal_vprop (p `pts_to` _) (p `pts_to` mk_point None y);
+  change_equal_vprop (q `pts_to` _) (q `pts_to` x);
+  A.return q
+
+let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
+: SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm Y)})
+    (to_vprop (p `pts_to` mk_point x y))
+    (fun q ->
+       to_vprop (p `pts_to` mk_point x None) `star`
+       to_vprop (q `pts_to` y))
+= let q = addr_of_lens p int_pcm (field point_fields_pcm Y) (mk_point x y) in
+  change_equal_vprop (p `pts_to` _) (p `pts_to` mk_point x None);
+  change_equal_vprop (q `pts_to` _) (q `pts_to` y);
+  A.return q
+
+#push-options "--z3rlimit 20 --print_implicits"
+let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
+: SteelT unit
+    (to_vprop (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y))))
+    (fun _ -> to_vprop (p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x))))
+= (* int *q = &p.x; *)
+  change_equal_vprop
+    (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
+    (p `pts_to` mk_point
+      (Ghost.reveal (Ghost.hide (Some (Ghost.reveal x))))
+      (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
+  let q = addr_of_x p (Some (Ghost.reveal x)) (Some (Ghost.reveal y)) in
+  (* int *r = &p.y; *)
+  change_equal_vprop
+    (p `pts_to` mk_point None (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))))
+    (p `pts_to` mk_point (Ghost.reveal (Ghost.hide None))
+      (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
+  let r = addr_of_y p None (Some (Ghost.reveal y)) in
+  (* tmp = *q; *)
+  let Some tmp = ref_read q (Some (Ghost.reveal x)) in
+  assert (tmp = Ghost.reveal x);
+  (* *q = *r; *)
+  let Some vy = ref_read r (Some (Ghost.reveal y)) in
+  assert (vy = Ghost.reveal y);
+  ref_write q x vy;
+  (* *r = tmp; *)
+  ref_write r y tmp;
+  (* Gather *)
+  change_equal_vprop (q `pts_to` _) (q `pts_to` Some vy);
+  unfocus q p (field point_fields_pcm X) (Some vy);
+  unfocus r p (field point_fields_pcm Y) (Some tmp);
+  gather p _ _;
+  //gather p (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+  //change_equal_vprop
+  //  (p `pts_to` put (field point_fields_pcm X) (Ghost.reveal (Ghost.hide (Some vy))) (one p.q))
+  //  (p `pts_to` mk_point (Some vy) None);
+  //change_equal_vprop
+  //  (p `pts_to` put (field point_fields_pcm Y) (Ghost.reveal (Ghost.hide (Some tmp))) (one p.q))
+  //  (p `pts_to` mk_point None (Some tmp));
+  A.sladmit ();
+  A.return ()
+#pop-options
+
+(*
+// let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
+// : SteelT (_:unit{composable r.q x y})
+//     (to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
+//     (fun _ -> to_vprop (r `pts_to` op r.q x y))
+
+  (*
+    (to_vprop (r `pts_to` x))
+    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ -> r == ref_focus r' q l)
+    (fun _ _ _ -> True)
+    *)
+
+let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: refined_one_pcm 'c)
+  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
+: A.SteelGhost unit inames
+    (to_vprop (r `pts_to` x))
+    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ -> r == ref_focus r' q l)
+    (fun _ _ _ -> True)
+= A.change_slprop_rel  
+    (to_vprop (r `pts_to` x))
+    (to_vprop (r' `pts_to` put l x (one r'.q)))
+    (fun _ _ -> True)
+    (fun m -> r'.pl.get_morphism.f_one ())
+*)
+
+(*
+let swap (p: ref 'a point{p.q == point_pcm}) (xy: Ghost.erased int)
+: SteelT unit
+    (to_vprop (p `pts_to` xy))
+    (fun _ -> to_vprop (p `pts_to` mk_point (xy Y) (xy X)))
+  
+let swap (p: ref 'a point{p.q == point_pcm}) (xy: Ghost.erased int)
+: SteelT unit
+    (to_vprop (p `pts_to` xy))
+    (fun _ -> to_vprop (p `pts_to` xy `upd` (X, xy Y) `upd` (Y, xy X)))
+
+let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
+: SteelT unit
+    (to_vprop (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y))))
+    (fun _ -> to_vprop (p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x))))
+= let q =
+    addr_of_lens p int_pcm (field point_fields_pcm X)
+      (mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y))) in
+  A.slassert (
+    to_vprop (p `pts_to` mk_point None (Some (Ghost.reveal y))) `star`
+    to_vprop (q `pts_to` Some (Ghost.reveal x)));
+  A.sladmit ();
+  A.return ()
+*)
+
+// let addr_of_lens (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+// : SteelT (ref 'a 'c)
+//     (to_vprop (r `pts_to` x))
+//     (fun s ->
+//       to_vprop (r `pts_to` put l (one q) x) `star` 
+//       to_vprop (s `pts_to` get l x))
+// = peel r q l x;
+//   focus r q l (put l (get l x) (one r.q)) (get l x)
+
+(*
+let swap (p: ref 'a point) (x y: Ghost.erased (option int))
+: Steel unit
+    (to_vprop (r `pts_to` mk_point x y))
+    (fun _ -> to_vprop (r `pts_to` mk_point y x))
+= 
+let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
+: Steel 'b
+    (to_vprop (r `pts_to` x)) 
+    (fun _ -> to_vprop (r `pts_to` x))
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible r.q x x')*)
+
+(** Example: a model for a tagged union representing colors in RGB or HSV
+      type color =
+        | RGB : r:int -> g:int -> b:int -> color
+        | HSV : h:int -> s:int -> v:int -> color *)
+
+type rgb_field = | R | G | B
+type hsv_field = | H | S | V
+type color_tag = | RGB | HSV
+
+(* Carrier of all-or-none PCM for integers *)
+let int_pcm_t = option int
+
+(* Type families for fields of RGB and HSV structs *)
+let rgb_fields k = match k with
+  | R -> int_pcm_t
+  | G -> int_pcm_t
+  | B -> int_pcm_t
+let hsv_fields k = match k with
+  | H -> int_pcm_t
+  | S -> int_pcm_t
+  | V -> int_pcm_t
+  
+(** Carriers of PCMs for RGB and HSV structs *)
+let rgb_t = restricted_t rgb_field rgb_fields
+let hsv_t = restricted_t hsv_field hsv_fields
+
+(** Type family for union of RGB and HSV *)
+let color_cases t = match t with
+  | RGB -> rgb_t
+  | HSV -> hsv_t
+
+(** Carrier of PCM for color *)
+let color_t = union color_cases
+
+(** All-or-none PCM for integers *)
+let int_pcm : pcm int_pcm_t = opt_pcm
+
+(** PCMs for RGB and HSV structs *)
+let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
+  prod_pcm #_ #rgb_fields (fun k -> match k with
+    | R -> int_pcm
+    | G -> int_pcm
+    | B -> int_pcm)
+let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
+  prod_pcm #_ #hsv_fields (fun k -> match k with
+    | H -> int_pcm
+    | S -> int_pcm
+    | V -> int_pcm)
+
+(** PCM for color *)
+let color_pcm_cases k : pcm (color_cases k) = match k with
+  | RGB -> rgb_pcm
+  | HSV -> hsv_pcm
+let color_pcm : pcm color_t = union_pcm color_pcm_cases

From 3e6e3e68fd6a61f7b42f0485b8644443196308bb Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 6 Jul 2021 17:23:52 -0700
Subject: [PATCH 053/513] 2dpoint swap function

---
 examples/steel/AggregateRef.fst         | 113 ++++++++++++++----------
 examples/steel/AggregateRefExamples.fst |  96 +++++++++++---------
 2 files changed, 120 insertions(+), 89 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index d8371ccec54..621c8a7d799 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -306,8 +306,11 @@ noeq type ref (a:Type) (b:Type): Type = {
   r: Steel.Memory.ref a p;
 }
 
-let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): Steel.Memory.slprop =
-  Steel.Memory.(r.r `pts_to` put r.pl v (one (refined_pcm r.re)))
+open Steel.Effect
+
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop =
+  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
 
 (** Basic lenses *)
 
@@ -822,7 +825,6 @@ let ref_refine (r: ref 'a 'b)
 
 (** Fundamental operations on references *)
 
-open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
@@ -832,14 +834,14 @@ let ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a
 let focus (r: ref 'a 'b) (q: refined_one_pcm 'c)
   (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
-    (to_vprop (r `pts_to` s))
-    (fun r' -> to_vprop (r' `pts_to` x))
+    (r `pts_to` s)
+    (fun r' -> r' `pts_to` x)
     (fun _ -> Ghost.reveal s == put l x (one r.q))
     (fun _ r' _ -> r' == ref_focus r q l)
 = let r' = ref_focus r q l in
   A.change_slprop_rel  
-    (to_vprop (r `pts_to` s))
-    (to_vprop (r' `pts_to` x))
+    (r `pts_to` s)
+    (r' `pts_to` x)
     (fun _ _ -> True)
     (fun m -> r.pl.get_morphism.f_one ());
   A.return r'
@@ -847,13 +849,13 @@ let focus (r: ref 'a 'b) (q: refined_one_pcm 'c)
 let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (#r'q: pcm 'b) (#q: refined_one_pcm 'c)
   (l: pcm_lens r'q q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
-    (to_vprop (r `pts_to` x))
-    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
+    (r `pts_to` x)
+    (fun _ -> r' `pts_to` put l x (one r'.q))
     (requires fun _ -> r'.q == r'q /\ r == ref_focus r' q l)
     (ensures fun _ _ _ -> True)
 = A.change_slprop_rel  
-    (to_vprop (r `pts_to` x))
-    (to_vprop (r' `pts_to` put l x (one r'.q)))
+    (r `pts_to` x)
+    (r' `pts_to` put l x (one r'.q))
     (fun _ _ -> True)
     (fun m -> r'.pl.get_morphism.f_one ())
 
@@ -864,13 +866,13 @@ let change_equal_vprop #inames (p q: M.slprop)
 
 let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
 : Steel unit
-    (to_vprop (r `pts_to` xy))
-    (fun _ -> to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
+    (r `pts_to` xy)
+    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
     (fun _ _ _ -> True)
 = A.change_equal_slprop
-    (to_vprop (r `pts_to` xy))
-    (to_vprop (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re))))));
+    (r `pts_to` xy)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re)))));
   (refined_pcm r.re).is_unit (one (refined_pcm r.re));
   r.pl.put_morphism.f_op
     (Ghost.reveal x, one (refined_pcm r.re))
@@ -879,24 +881,34 @@ let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
     (put r.pl xy (one (refined_pcm r.re)))
     (put r.pl x (one (refined_pcm r.re)))
     (put r.pl y (one (refined_pcm r.re)));
-  change_equal_vprop
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
+  A.change_equal_slprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
     (r `pts_to` x);
-  change_equal_vprop
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
+  A.change_equal_slprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
     (r `pts_to` y)
 
+let mgather (#a:Type)
+            (#p:FStar.PCM.pcm a)
+            (r:Steel.Memory.ref a p)
+            (v0:Ghost.erased a)
+            (v1:Ghost.erased a)
+: SteelT (_:unit{composable p v0 v1})
+    (mpts_to r v0 `star` mpts_to r v1)
+    (fun _ -> mpts_to r (op p v0 v1))
+= Steel.PCMReference.gather r v0 v1
+
 let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
 : SteelT (_:unit{composable r.q x y})
-    (to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
-    (fun _ -> to_vprop (r `pts_to` op r.q x y))
-= change_equal_vprop
+    ((r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> r `pts_to` op r.q x y)
+= A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
-  change_equal_vprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
+  A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `M.pts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
-  Steel.PCMReference.gather r.r
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
+  mgather r.r
     (put r.pl x (one (refined_pcm r.re)))
     (put r.pl y (one (refined_pcm r.re)));
   r.pl.get_morphism.f_op
@@ -906,14 +918,14 @@ let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
   r.pl.put_morphism.f_op
     (Ghost.reveal x, one (refined_pcm r.re))
     (Ghost.reveal y, one (refined_pcm r.re));
-  change_equal_vprop _ (r `pts_to` op r.q x y)
+  A.change_equal_slprop _ (r `pts_to` op r.q x y)
 
 let peel (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
 : SteelT unit
-    (to_vprop (r `pts_to` x))
+    (r `pts_to` x)
     (fun _ ->
-      to_vprop (r `pts_to` put l (one q) x) `star` 
-      to_vprop (r `pts_to` put l (get l x) (one r.q)))
+      (r `pts_to` put l (one q) x) `star` 
+      (r `pts_to` put l (get l x) (one r.q)))
 = q.is_unit (get l x);
   r.q.is_unit x;
   q.comm (get l x) (one q);
@@ -922,10 +934,10 @@ let peel (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.er
 
 let addr_of_lens (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
 : Steel (ref 'a 'c)
-    (to_vprop (r `pts_to` x))
+    (r `pts_to` x)
     (fun s ->
-      to_vprop (r `pts_to` put l (one q) x) `star` 
-      to_vprop (s `pts_to` get l x))
+      (r `pts_to` put l (one q) x) `star` 
+      (s `pts_to` get l x))
     (requires fun _ -> True)
     (ensures fun _ r' _ -> r' == ref_focus r q l)
 = peel r q l x;
@@ -936,23 +948,23 @@ let refine (r: ref 'a 'b)
   (u: pcm_unrefinement re)
   (x: Ghost.erased 'b{re.f x})
 : Steel (ref 'a (refine_t re.f))
-    (to_vprop (r `pts_to` x))
-    (fun r' -> to_vprop (r' `pts_to` Ghost.reveal x))
+    (r `pts_to` x)
+    (fun r' -> r' `pts_to` Ghost.reveal x)
     (fun _ -> True)
     (fun _ r' _ -> r' == ref_refine r re u)
 = let r' = ref_refine r re u in
-  change_equal_vprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
+  A.change_equal_slprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
 let unrefine #inames (r': ref 'a 'b)
   (re: pcm_refinement r'.q) (u: pcm_unrefinement re)
   (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
 : A.SteelGhost unit inames
-    (to_vprop (r `pts_to` Ghost.reveal x))
-    (fun _ -> to_vprop (r' `pts_to` x))
+    (r `pts_to` Ghost.reveal x)
+    (fun _ -> r' `pts_to` x)
     (fun _ -> r == ref_refine r' re u)
     (fun _ _ _ -> True)
-= change_equal_vprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
+= A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
 let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   (f: ('b -> 'b){frame_pres r.q f x y})
@@ -965,28 +977,37 @@ let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   r.u x' y' (frame_pres_mk_upd (refined_pcm r.re) x' y' (upd r.pl f))
 
 let ref_upd_act (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
-: M.action_except unit Set.empty (r `pts_to` x) (fun _ -> r `pts_to` y)
+: M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y))
 = M.upd_gen Set.empty r.r _ _ (ref_frame_preserving_upd r x y f)
 
+let as_action (#p:vprop)
+              (#q:vprop)
+              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
+: SteelT unit p (fun x -> q)
+= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
+  let x = Steel.Effect.as_action f in
+  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
+  A.return x
+
 let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
-: SteelT unit (to_vprop (r `pts_to` x)) (fun _ -> to_vprop (r `pts_to` y))
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 = as_action (ref_upd_act r x y f)
 
 let ref_write (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
-: SteelT unit (to_vprop (r `pts_to` Some (Ghost.reveal x))) (fun _ -> to_vprop (r `pts_to` Some y))
+: SteelT unit (r `pts_to` Some (Ghost.reveal x)) (fun _ -> r `pts_to` Some y)
 = ref_upd r (Some (Ghost.reveal x)) (Some y)
     (fun v -> match v with None -> None | Some _ -> Some y)
 
 let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
 : Steel 'b
-    (to_vprop (r `pts_to` x)) 
-    (fun _ -> to_vprop (r `pts_to` x))
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible r.q x x')
 = let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  change_equal_vprop (r `pts_to` x) (r.r `M.pts_to` x');
+  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
   let v = Steel.PCMReference.read r.r x' in
   pcm_refinement_compatible_closed r.re x' v;
   pcm_lens_compatible_get r.pl x' v;
-  change_equal_vprop (r.r `M.pts_to` x') (r `pts_to` x);
+  A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
   A.return (get r.pl v)
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index 4eb3f38ccf2..3a46e77fe5a 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -42,70 +42,74 @@ let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
 let mk_point (x y: option int): point = on_domain point_field (mk_point_f x y)
 
 let put_x x' x y
-: Lemma (put (field point_fields_pcm X) x' (mk_point x y) == mk_point x' y)
+: Lemma (feq (put (field point_fields_pcm X) x' (mk_point x y)) (mk_point x' y))
   [SMTPat (put (field point_fields_pcm X) x' (mk_point x y))]
-= admit()
+= ()
 
 let get_x x y
 : Lemma (get (field point_fields_pcm X) (mk_point x y) == x)
   [SMTPat (get (field point_fields_pcm X) (mk_point x y))]
-= admit()
+= ()
 
 let put_y y' x y
-: Lemma (put (field point_fields_pcm Y) y' (mk_point x y) == mk_point x y')
+: Lemma (feq (put (field point_fields_pcm Y) y' (mk_point x y)) (mk_point x y'))
   [SMTPat (put (field point_fields_pcm Y) y' (mk_point x y))]
-= admit()
+= ()
 
 let get_y x y
 : Lemma (get (field point_fields_pcm Y) (mk_point x y) == y)
   [SMTPat (get (field point_fields_pcm Y) (mk_point x y))]
-= admit()
+= ()
 
 let merge_xy x y x' y'
-: Lemma (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y') ==
-         mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y'))
+: Lemma (feq (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))
+             (mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y')))
   [SMTPat (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))]
-= admit()
+= ()
 
 let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
 : SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm X)})
-    (to_vprop (p `pts_to` mk_point x y))
+    (p `pts_to` mk_point x y)
     (fun q ->
-       to_vprop (p `pts_to` mk_point None y) `star`
-       to_vprop (q `pts_to` x))
+       (p `pts_to` mk_point None y) `star`
+       (q `pts_to` x))
 = let q = addr_of_lens p int_pcm (field point_fields_pcm X) (mk_point x y) in
-  change_equal_vprop (p `pts_to` _) (p `pts_to` mk_point None y);
-  change_equal_vprop (q `pts_to` _) (q `pts_to` x);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
   A.return q
 
 let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
 : SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm Y)})
-    (to_vprop (p `pts_to` mk_point x y))
+    (p `pts_to` mk_point x y)
     (fun q ->
-       to_vprop (p `pts_to` mk_point x None) `star`
-       to_vprop (q `pts_to` y))
+       (p `pts_to` mk_point x None) `star`
+       (q `pts_to` y))
 = let q = addr_of_lens p int_pcm (field point_fields_pcm Y) (mk_point x y) in
-  change_equal_vprop (p `pts_to` _) (p `pts_to` mk_point x None);
-  change_equal_vprop (q `pts_to` _) (q `pts_to` y);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
-#push-options "--z3rlimit 20 --print_implicits"
+let one_xy : squash (feq (one (prod_pcm point_fields_pcm)) (mk_point None None))
+= ()
+
 let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
-    (to_vprop (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y))))
-    (fun _ -> to_vprop (p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x))))
-= (* int *q = &p.x; *)
-  change_equal_vprop
     (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
-    (p `pts_to` mk_point
-      (Ghost.reveal (Ghost.hide (Some (Ghost.reveal x))))
-      (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
+    (fun _ -> p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x)))
+= (* int *q = &p.x; *)
+  //A.change_equal_slprop
+  //  (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
+  //  (p `pts_to` mk_point
+  //    (Ghost.reveal (Ghost.hide (Some (Ghost.reveal x))))
+  //    (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   let q = addr_of_x p (Some (Ghost.reveal x)) (Some (Ghost.reveal y)) in
   (* int *r = &p.y; *)
-  change_equal_vprop
-    (p `pts_to` mk_point None (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))))
-    (p `pts_to` mk_point (Ghost.reveal (Ghost.hide None))
-      (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
+  //A.change_equal_slprop
+  //  (p `pts_to` mk_point None (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))))
+  //  (p `pts_to` mk_point (Ghost.reveal (Ghost.hide None))
+  //    (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   let r = addr_of_y p None (Some (Ghost.reveal y)) in
   (* tmp = *q; *)
   let Some tmp = ref_read q (Some (Ghost.reveal x)) in
@@ -117,20 +121,26 @@ let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
   (* *r = tmp; *)
   ref_write r y tmp;
   (* Gather *)
-  change_equal_vprop (q `pts_to` _) (q `pts_to` Some vy);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   unfocus q p (field point_fields_pcm X) (Some vy);
   unfocus r p (field point_fields_pcm Y) (Some tmp);
-  gather p _ _;
-  //gather p (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
-  //change_equal_vprop
-  //  (p `pts_to` put (field point_fields_pcm X) (Ghost.reveal (Ghost.hide (Some vy))) (one p.q))
-  //  (p `pts_to` mk_point (Some vy) None);
-  //change_equal_vprop
-  //  (p `pts_to` put (field point_fields_pcm Y) (Ghost.reveal (Ghost.hide (Some tmp))) (one p.q))
-  //  (p `pts_to` mk_point None (Some tmp));
-  A.sladmit ();
-  A.return ()
-#pop-options
+  A.change_equal_slprop
+    (p `pts_to` put (field point_fields_pcm X) _ _)
+    (p `pts_to` mk_point (Some vy) None);
+  A.change_equal_slprop
+    (p `pts_to` put (field point_fields_pcm Y) _ _)
+    (p `pts_to` mk_point None (Some tmp));
+  gather p (mk_point (Some vy) None) (mk_point None (Some tmp));
+  gather p (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+  //gather p _ _; // Ask
+  A.change_equal_slprop (p `pts_to` _) _
+
+(*
+to print proof state, try:
+
+val fake : vprop
+let f unit : Steel unit fake (fun _ -> _)
+*)
 
 (*
 // let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)

From 83f69f881125141ba698d58a57ee0f6f52551b59 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 7 Jul 2021 08:29:49 -0700
Subject: [PATCH 054/513] Generic swap

---
 examples/steel/AggregateRefExamples.fst | 114 +++++++++++++++++++-----
 1 file changed, 91 insertions(+), 23 deletions(-)

diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index 3a46e77fe5a..c745088cf86 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -10,16 +10,9 @@ module A = Steel.Effect.Atomic
 
 /// Example 1: swapping the coordinates of a 2d point
 ///
-/// struct point { int x, y; };
+/// Suppose we have the following struct representing 2d points:
+///   struct point { int x, y; };
 ///
-/// void swap(struct point *p) {
-///   int *q = &p.x;
-///   int *r = &p.y;
-///   int tmp = *q;
-///   *q = *r;
-///   *r = tmp;
-/// }
-
 /// Carrier of PCM for struct point:
 
 type point_field = | X | Y
@@ -36,11 +29,15 @@ let point_fields_pcm k : pcm (point_fields k) = match k with
   | Y -> int_pcm
 let point_pcm = prod_pcm point_fields_pcm
 
+/// (mk_point x y) represents (struct point){.x = x, .y = y}
+
 let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
   | X -> x
   | Y -> y
 let mk_point (x y: option int): point = on_domain point_field (mk_point_f x y)
 
+/// Laws about putting/getting the x and y fields of a (mk_point x y)
+
 let put_x x' x y
 : Lemma (feq (put (field point_fields_pcm X) x' (mk_point x y)) (mk_point x' y))
   [SMTPat (put (field point_fields_pcm X) x' (mk_point x y))]
@@ -61,12 +58,19 @@ let get_y x y
   [SMTPat (get (field point_fields_pcm Y) (mk_point x y))]
 = ()
 
+/// Laws relating mk_point to PCM operations
+
+let one_xy : squash (feq (one (prod_pcm point_fields_pcm)) (mk_point None None))
+= ()
+
 let merge_xy x y x' y'
 : Lemma (feq (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))
              (mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y')))
   [SMTPat (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))]
 = ()
 
+/// Taking pointers to the x and y fields of a point
+
 let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
 : SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm X)})
     (p `pts_to` mk_point x y)
@@ -89,26 +93,24 @@ let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
-let one_xy : squash (feq (one (prod_pcm point_fields_pcm)) (mk_point None None))
-= ()
+/// With the above, we can write the following function that swaps the x and y fields of a given point:
+/// 
+/// void point_swap(struct point *p) {
+///   int *q = &p.x;
+///   int *r = &p.y;
+///   int tmp = *q;
+///   *q = *r;
+///   *r = tmp;
+/// }
 
-let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
+let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
     (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
     (fun _ -> p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x)))
 = (* int *q = &p.x; *)
-  //A.change_equal_slprop
-  //  (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
-  //  (p `pts_to` mk_point
-  //    (Ghost.reveal (Ghost.hide (Some (Ghost.reveal x))))
-  //    (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   let q = addr_of_x p (Some (Ghost.reveal x)) (Some (Ghost.reveal y)) in
   (* int *r = &p.y; *)
-  //A.change_equal_slprop
-  //  (p `pts_to` mk_point None (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))))
-  //  (p `pts_to` mk_point (Ghost.reveal (Ghost.hide None))
-  //    (Ghost.reveal (Ghost.hide (Some (Ghost.reveal y)))));
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   let r = addr_of_y p None (Some (Ghost.reveal y)) in
   (* tmp = *q; *)
@@ -117,9 +119,9 @@ let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
   (* *q = *r; *)
   let Some vy = ref_read r (Some (Ghost.reveal y)) in
   assert (vy = Ghost.reveal y);
-  ref_write q x vy;
+  ref_write q _ vy;
   (* *r = tmp; *)
-  ref_write r y tmp;
+  ref_write r _ tmp;
   (* Gather *)
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   unfocus q p (field point_fields_pcm X) (Some vy);
@@ -135,6 +137,72 @@ let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
   //gather p _ _; // Ask
   A.change_equal_slprop (p `pts_to` _) _
 
+/// Here's a generic swap:
+///
+/// void generic_swap<A>(A *p, A *q) {
+///   A tmp = *p;
+///   *p = *q;
+///   *q = tmp;
+/// }
+
+let generic_swap
+  (p:ref 'a (option 'c){p.q == opt_pcm #'c})
+  (q:ref 'b (option 'c){q.q == opt_pcm #'c})
+  (x y: Ghost.erased 'c)
+: SteelT unit
+    ((p `pts_to` Some (Ghost.reveal x)) `star`
+     (q `pts_to` Some (Ghost.reveal y)))
+    (fun _ ->
+     (p `pts_to` Some (Ghost.reveal y)) `star`
+     (q `pts_to` Some (Ghost.reveal x)))
+= (* A tmp = *p; *)
+  let Some tmp = ref_read p (Some (Ghost.reveal x)) in
+  (* *p = *q; *)
+  let Some vy = ref_read q (Some (Ghost.reveal y)) in
+  ref_write p _ vy;
+  (* *q = tmp *)
+  ref_write q _ tmp;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _)
+
+/// Now, here's point_swap written using generic_swap:
+///
+/// void point_swap_generically(struct point *p) {
+///   int *q = &p.x;
+///   int *r = &p.y;
+///   generic_swap(q, r);
+/// }
+
+let point_swap_generically
+  (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
+: SteelT unit
+    (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
+    (fun _ -> p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x)))
+= (* int *q = &p.x; *)
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  let q = addr_of_x p (Some (Ghost.reveal x)) (Some (Ghost.reveal y)) in
+  (* int *r = &p.y; *)
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  let r = addr_of_y p None (Some (Ghost.reveal y)) in
+  (* generic_swap(q, r); *)
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  generic_swap q r (Ghost.reveal x) (Ghost.reveal y);
+  (* Gather *)
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  unfocus q p (field point_fields_pcm X) (Some (Ghost.reveal y));
+  unfocus r p (field point_fields_pcm Y) (Some (Ghost.reveal x));
+  A.change_equal_slprop
+    (p `pts_to` put (field point_fields_pcm X) _ _)
+    (p `pts_to` mk_point (Some (Ghost.reveal y)) None);
+  A.change_equal_slprop
+    (p `pts_to` put (field point_fields_pcm Y) _ _)
+    (p `pts_to` mk_point None (Some (Ghost.reveal x)));
+  gather p (mk_point (Some (Ghost.reveal y)) None) (mk_point None (Some (Ghost.reveal x)));
+  gather p (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+  A.change_equal_slprop (p `pts_to` _) _
+
 (*
 to print proof state, try:
 

From c788685235d20a80720d8ef8dcd558644bd9c23c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 7 Jul 2021 13:57:12 -0700
Subject: [PATCH 055/513] Generic ref_write; finish reflect_and_reverse

---
 examples/steel/AggregateRef.fst         | 142 ++++++++--
 examples/steel/AggregateRefExamples.fst | 332 ++++++++++++++++++++++--
 2 files changed, 422 insertions(+), 52 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 621c8a7d799..436231faf14 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -309,7 +309,7 @@ noeq type ref (a:Type) (b:Type): Type = {
 open Steel.Effect
 
 let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
-let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop =
+let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop = (* TODO unerase v, try [@@@smt_fallback] *)
   r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
 
 (** Basic lenses *)
@@ -920,29 +920,61 @@ let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
     (Ghost.reveal y, one (refined_pcm r.re));
   A.change_equal_slprop _ (r `pts_to` op r.q x y)
 
-let peel (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
-: SteelT unit
+let rewrite_context #inames (p q: vprop)
+: Steel.Effect.Atomic.SteelAtomicF unit inames
+    (p)
+    (fun _ -> q)
+    (requires fun _ -> p == q)
+    (ensures fun _ _ _ -> True)
+= A.change_equal_slprop p q
+
+let peel (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c)
+  (l: pcm_lens rq q) (x: Ghost.erased 'b)
+: Steel unit
     (r `pts_to` x)
     (fun _ ->
       (r `pts_to` put l (one q) x) `star` 
       (r `pts_to` put l (get l x) (one r.q)))
+    (requires fun _ -> rq == r.q)
+    (ensures fun _ _ _ -> True)
 = q.is_unit (get l x);
   r.q.is_unit x;
   q.comm (get l x) (one q);
   l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
-  split r x (put l (one q) x) (put l (get l x) (one r.q))
+  split r x (put l (one q) x) (put l (get l x) (one r.q));
+  A.sladmit()
+  //A.rewrite_context
+  //A.change_equal_slprop ((r `pts_to` (Ghost.reveal (Ghost.hide (put l (one q) (Ghost.reveal x))))) `star` (r `pts_to` _)) ((r `pts_to` _) `star` (r `pts_to` _))
 
-let addr_of_lens (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
+let addr_of_lens (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c)
+  (l: pcm_lens rq q) (x: Ghost.erased 'b)
 : Steel (ref 'a 'c)
     (r `pts_to` x)
     (fun s ->
       (r `pts_to` put l (one q) x) `star` 
       (s `pts_to` get l x))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r q l)
-= peel r q l x;
+    (requires fun _ -> rq == r.q)
+    (ensures fun _ r' _ -> rq == r.q /\ r' == ref_focus r q l)
+= peel r l x;
   focus r q l (put l (get l x) (one r.q)) (get l x)
 
+let un_addr_of_lens
+  (r': ref 'a 'c) (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c) (l: pcm_lens rq q)
+  (x: Ghost.erased 'b) (y: Ghost.erased 'c)
+: Steel unit
+    ((r `pts_to` x) `star` (r' `pts_to` y))
+    (fun s -> r `pts_to` put l y x)
+    (requires fun _ -> rq == r.q /\ r' == ref_focus r q l /\ get l x == one q)
+    (ensures fun _ _ _ -> True)
+= unfocus r' r l y;
+  gather r x (put l y (one r.q));
+  q.is_unit (Ghost.reveal y);
+  r.q.is_unit (Ghost.reveal x);
+  q.comm (get l x) y;
+  l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one r.q);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  A.return ()
+
 let refine (r: ref 'a 'b)
   (re: pcm_refinement r.q)
   (u: pcm_unrefinement re)
@@ -966,6 +998,61 @@ let unrefine #inames (r': ref 'a 'b)
     (fun _ _ _ -> True)
 = A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
+
+(*
+
+describe this situation:
+
+  thread 1: pointer to p.x
+  
+  thread 2: pointer to p but with permissions {None, y}
+  
+  *p a value compatible with {None, y}
+  i.e., any {x, y} for any x
+  x could be:
+    Some z for a garbage z, or
+    None
+
+  but, impossible to work with p->x:
+    *p = {x, y}
+    ( *p).x == 0
+    need {x, y}.x is Some v
+    if (( *p).x == 0) { .. } else { .. }
+    
+  {None, y} compatible with {vx, vy} 
+  let vx = ref_read &p->x in
+  match vx with None -> .. | Some x -> ..
+
+  {None, y} compatible with {vx, vy} 
+  let vx = ref_read &p->x in
+  let bad = (f : option int -> option int) vx in
+
+  could prevent pattern matching if option int were an abstract type
+
+*)
+
+let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
+: Steel 'b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> ~ (Ghost.reveal x == one r.q))
+    (ensures fun _ x' _ -> compatible r.q x x')
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
+  let v = Steel.PCMReference.read r.r x' in
+  pcm_refinement_compatible_closed r.re x' v;
+  pcm_lens_compatible_get r.pl x' v;
+  A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
+  A.return (get r.pl v)
+
+let whole_value (p: pcm 'a) (x: 'a) =
+  p.refine x /\
+  (forall (y:'a{composable p x y}).{:pattern op p y x} op p y x == x)
+
+let valid_write (p:pcm 'a) x y =
+  whole_value p x /\ whole_value p y /\
+  (forall (frame:'a). composable p x frame ==> composable p y frame)
+
 let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   (f: ('b -> 'b){frame_pres r.q f x y})
 : frame_preserving_upd r.p
@@ -993,21 +1080,28 @@ let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 = as_action (ref_upd_act r x y f)
 
-let ref_write (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
+let frame_preserving_upd_valid_write (p: pcm 'a)
+  (x:Ghost.erased 'a) (y:'a{valid_write p x y})
+: f:('a -> 'a){frame_pres p f x y}
+= let f = fun v -> y in
+  frame_pres_intro p f x y (fun v ->
+    compatible_refl p y;
+    let aux (frame:'a{composable p x frame})
+    : Lemma (
+       composable p y frame /\
+       (op p x frame == v ==> op p y frame == y))
+    = assert (op p frame x == Ghost.reveal x);
+      assert (op p frame y == y);
+      p.comm frame x; p.comm frame y
+    in FStar.Classical.forall_intro aux);
+  f
+
+let ref_write (r: ref 'a 'b) (x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
+= ref_upd r x y (frame_preserving_upd_valid_write r.q x y)
+
+let ref_write_opt_pcm (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
 : SteelT unit (r `pts_to` Some (Ghost.reveal x)) (fun _ -> r `pts_to` Some y)
-= ref_upd r (Some (Ghost.reveal x)) (Some y)
-    (fun v -> match v with None -> None | Some _ -> Some y)
+= ref_write r (Some (Ghost.reveal x)) (Some y)
+
 
-let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
-: Steel 'b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible r.q x x')
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
-  let v = Steel.PCMReference.read r.r x' in
-  pcm_refinement_compatible_closed r.re x' v;
-  pcm_lens_compatible_get r.pl x' v;
-  A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
-  A.return (get r.pl v)
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index c745088cf86..fafca2549f4 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -60,13 +60,13 @@ let get_y x y
 
 /// Laws relating mk_point to PCM operations
 
-let one_xy : squash (feq (one (prod_pcm point_fields_pcm)) (mk_point None None))
+let one_xy : squash (feq (one point_pcm) (mk_point None None))
 = ()
 
 let merge_xy x y x' y'
-: Lemma (feq (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))
+: Lemma (feq (op point_pcm (mk_point x y) (mk_point x' y'))
              (mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y')))
-  [SMTPat (op (prod_pcm point_fields_pcm) (mk_point x y) (mk_point x' y'))]
+  [SMTPat (op point_pcm (mk_point x y) (mk_point x' y'))]
 = ()
 
 /// Taking pointers to the x and y fields of a point
@@ -77,22 +77,42 @@ let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int
     (fun q ->
        (p `pts_to` mk_point None y) `star`
        (q `pts_to` x))
-= let q = addr_of_lens p int_pcm (field point_fields_pcm X) (mk_point x y) in
+= let q = addr_of_lens p (field point_fields_pcm X) (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
   A.return q
 
+let un_addr_of_x
+  (p: ref 'a point{p.q == point_pcm})
+  (q: ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm X)})
+  (x y: Ghost.erased (option int))
+: SteelT unit
+    ((p `pts_to` mk_point None y) `star` (q `pts_to` x))
+    (fun q -> p `pts_to` mk_point x y)
+= un_addr_of_lens q p (field point_fields_pcm X) (mk_point None y) x;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
 let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
 : SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm Y)})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point x None) `star`
        (q `pts_to` y))
-= let q = addr_of_lens p int_pcm (field point_fields_pcm Y) (mk_point x y) in
+= let q = addr_of_lens p (field point_fields_pcm Y) (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
+let un_addr_of_y
+  (p: ref 'a point{p.q == point_pcm})
+  (q: ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm Y)})
+  (x y: Ghost.erased (option int))
+: SteelT unit
+    ((p `pts_to` mk_point x None) `star` (q `pts_to` y))
+    (fun q -> p `pts_to` mk_point x y)
+= un_addr_of_lens q p (field point_fields_pcm Y) (mk_point x None) y;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
 /// With the above, we can write the following function that swaps the x and y fields of a given point:
 /// 
 /// void point_swap(struct point *p) {
@@ -115,27 +135,19 @@ let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
   let r = addr_of_y p None (Some (Ghost.reveal y)) in
   (* tmp = *q; *)
   let Some tmp = ref_read q (Some (Ghost.reveal x)) in
-  assert (tmp = Ghost.reveal x);
   (* *q = *r; *)
   let Some vy = ref_read r (Some (Ghost.reveal y)) in
-  assert (vy = Ghost.reveal y);
   ref_write q _ vy;
   (* *r = tmp; *)
   ref_write r _ tmp;
   (* Gather *)
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  unfocus q p (field point_fields_pcm X) (Some vy);
-  unfocus r p (field point_fields_pcm Y) (Some tmp);
-  A.change_equal_slprop
-    (p `pts_to` put (field point_fields_pcm X) _ _)
-    (p `pts_to` mk_point (Some vy) None);
-  A.change_equal_slprop
-    (p `pts_to` put (field point_fields_pcm Y) _ _)
-    (p `pts_to` mk_point None (Some tmp));
-  gather p (mk_point (Some vy) None) (mk_point None (Some tmp));
-  gather p (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
-  //gather p _ _; // Ask
-  A.change_equal_slprop (p `pts_to` _) _
+  un_addr_of_x p q (Some vy) None;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  un_addr_of_y p r (Some vy) (Some tmp);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 /// Here's a generic swap:
 ///
@@ -189,19 +201,283 @@ let point_swap_generically
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   generic_swap q r (Ghost.reveal x) (Ghost.reveal y);
   (* Gather *)
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
+  un_addr_of_x p q (Some (Ghost.reveal y)) None;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  unfocus q p (field point_fields_pcm X) (Some (Ghost.reveal y));
-  unfocus r p (field point_fields_pcm Y) (Some (Ghost.reveal x));
+  un_addr_of_y p r (Some (Ghost.reveal y)) (Some (Ghost.reveal x));
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+/// Example 2: pointers to nested fields
+///
+/// Here's a struct representing a line segment by its two endpoints:
+///   struct line { struct point p1; struct point p2; };
+///
+/// Carrier of PCM for line:
+
+type line_field = | P1 | P2
+let line_fields k = match k with
+  | P1 -> point
+  | P2 -> point
+let line = restricted_t line_field line_fields
+
+/// PCM for line:
+
+let line_fields_pcm k : pcm (line_fields k) = match k with
+  | P1 -> point_pcm
+  | P2 -> point_pcm
+let line_pcm = prod_pcm line_fields_pcm
+
+/// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
+
+let mk_line_f (p1 p2: point) (k: line_field): line_fields k = match k with
+  | P1 -> p1
+  | P2 -> p2
+let mk_line (p1 p2: point): line = on_domain line_field (mk_line_f p1 p2)
+
+/// Laws about putting/getting the x and y fields of a (mk_line x y)
+
+let put_p1 p1' p1 p2
+: Lemma (feq (put (field line_fields_pcm P1) p1' (mk_line p1 p2)) (mk_line p1' p2))
+  [SMTPat (put (field line_fields_pcm P1) p1' (mk_line p1 p2))]
+= ()
+
+let get_p1 p1 p2
+: Lemma (get (field line_fields_pcm P1) (mk_line p1 p2) == p1)
+  [SMTPat (get (field line_fields_pcm P1) (mk_line p1 p2))]
+= ()
+
+let put_p2 p2' p1 p2
+: Lemma (feq (put (field line_fields_pcm P2) p2' (mk_line p1 p2)) (mk_line p1 p2'))
+  [SMTPat (put (field line_fields_pcm P2) p2' (mk_line p1 p2))]
+= ()
+
+let get_p2 p1 p2
+: Lemma (get (field line_fields_pcm P2) (mk_line p1 p2) == p2)
+  [SMTPat (get (field line_fields_pcm P2) (mk_line p1 p2))]
+= ()
+
+/// Laws relating mk_line to PCM operations
+
+let one_line : squash (feq (one line_pcm) (mk_line (one point_pcm) (one point_pcm)))
+= ()
+
+let merge_line p1 p2 p1' p2'
+: Lemma (feq (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))
+             (mk_line (op (line_fields_pcm P1) p1 p1') (op (line_fields_pcm P2) p2 p2')))
+  [SMTPat (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))]
+= ()
+
+/// Taking pointers to the p1 and p2 fields of a line
+
+let addr_of_p1 (p: ref 'a line{p.q == line_pcm}) (p1 p2: Ghost.erased point)
+: SteelT (q:ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P1)})
+    (p `pts_to` mk_line p1 p2)
+    (fun q ->
+       (p `pts_to` mk_line (one point_pcm) p2) `star`
+       (q `pts_to` p1))
+= let q = addr_of_lens p (field line_fields_pcm P1) (mk_line p1 p2) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line (one point_pcm) p2);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
+  A.return q
+
+let un_addr_of_p1
+  (p: ref 'a line{p.q == line_pcm})
+  (q: ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P1)})
+  (p1 p2: Ghost.erased point)
+: SteelT unit
+    ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
+    (fun q -> p `pts_to` mk_line p1 p2)
+= un_addr_of_lens q p (field line_fields_pcm P1) (mk_line (one point_pcm) p2) p1;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_p2 (p: ref 'a line{p.q == line_pcm}) (p1 p2: Ghost.erased point)
+: SteelT (q:ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P2)})
+    (p `pts_to` mk_line p1 p2)
+    (fun q ->
+       (p `pts_to` mk_line p1 (one point_pcm)) `star`
+       (q `pts_to` p2))
+= let q = addr_of_lens p (field line_fields_pcm P2) (mk_line p1 p2) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line p1 (one point_pcm));
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
+  A.return q
+
+let un_addr_of_p2
+  (p: ref 'a line{p.q == line_pcm})
+  (q: ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P2)})
+  (p1 p2: Ghost.erased point)
+: SteelT unit
+    ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
+    (fun q -> p `pts_to` mk_line p1 p2)
+= un_addr_of_lens q p (field line_fields_pcm P2) (mk_line p1 (one point_pcm)) p2;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+/// Reflect a line segment across the line y=x and reverse its direction
+///
+/// void reflect_and_reverse(struct line *p) {
+///   generic_swap(&p.p1.x, &p.p2.y);
+///   generic_swap(&p.p1.y, &p.p2.x);
+/// }
+
+#push-options "--z3rlimit 20"
+let reflect_and_reverse
+  (p: ref 'a line{p.q == line_pcm}) (x1 y1 x2 y2: Ghost.erased int)
+: SteelT unit
+    (p `pts_to`
+      mk_line
+        (mk_point (Some (Ghost.reveal x1)) (Some (Ghost.reveal y1)))
+        (mk_point (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2))))
+    (fun _ ->
+      p `pts_to`
+        mk_line
+          (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
+          (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1))))
+= (* Take all the requisite pointers *)
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  let pp1 =
+    addr_of_p1 p
+      (mk_point (Some (Ghost.reveal x1)) (Some (Ghost.reveal y1)))
+      (mk_point (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2)))
+  in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  let pp2 =
+    addr_of_p2 p
+      (one point_pcm)
+      (mk_point (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2)))
+  in
+  (* &p.p1.x *)
+  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
+  let pp1x = addr_of_x pp1 (Some (Ghost.reveal x1)) (Some (Ghost.reveal y1)) in
+  (* &p.p1.y *)
+  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
+  let pp1y = addr_of_y pp1 None (Some (Ghost.reveal y1)) in
+  (* &p.p2.x *)
+  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
+  let pp2x = addr_of_x pp2 (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2)) in
+  (* &p.p2.y *)
+  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
+  let pp2y = addr_of_y pp2 None (Some (Ghost.reveal y2)) in
+  (* generic_swap(&p.p1.x, &p.p2.y); *)
+  generic_swap pp1x pp2y x1 y2;
+  (* generic_swap(&p.p1.y, &p.p2.x); *)
+  generic_swap pp1y pp2x y1 x2;
+  (* Gather p1 *)
+  A.change_equal_slprop (pp1x `pts_to` _) (pp1x `pts_to` _);
+  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
+  un_addr_of_x pp1 pp1x (Some (Ghost.reveal y2)) None;
+  A.change_equal_slprop (pp1y `pts_to` _) (pp1y `pts_to` _);
+  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
+  un_addr_of_y pp1 pp1y (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2));
+  (* Gather p2 *)
+  A.change_equal_slprop (pp2x `pts_to` _) (pp2x `pts_to` _);
+  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
+  un_addr_of_x pp2 pp2x (Some (Ghost.reveal y1)) None;
+  A.change_equal_slprop (pp2y `pts_to` _) (pp2y `pts_to` _);
+  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
+  un_addr_of_y pp2 pp2y (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1));
+  (* Gather p *)
+  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  un_addr_of_p1 p pp1 (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2))) (one point_pcm);
+  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  un_addr_of_p2 p pp2
+    (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
+    (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1)));
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+#pop-options
+
+(*
+addr_of
+  (r `pts_to` xs)
+  (r `pts_to` xs \ k `star` s `pts_to` xs k)
+  
+addr_of
+  (r `pts_to` xs `star` s `pts_to` y)
+  (r `pts_to` xs [k `mapsto` y])
+  *)
+
+(*
+
+  A.change_equal_slprop (pp1x `pts_to` _) (pp1x `pts_to` _);
+  A.change_equal_slprop (pp1y `pts_to` _) (pp1y `pts_to` _);
+  unfocus pp1x pp1 (field point_fields_pcm X) (Some (Ghost.reveal y2));
+  unfocus pp1y pp1 (field point_fields_pcm Y) (Some (Ghost.reveal x2));
+  A.change_equal_slprop
+    (pp1 `pts_to` put (field point_fields_pcm X) _ _)
+    (pp1 `pts_to` mk_point (Some (Ghost.reveal y2)) None);
+  A.change_equal_slprop
+    (pp1 `pts_to` put (field point_fields_pcm Y) _ _)
+    (pp1 `pts_to` mk_point None (Some (Ghost.reveal x2)));
+  gather pp1 (mk_point (Some (Ghost.reveal y2)) None) (mk_point None (Some (Ghost.reveal x2)));
+  gather pp1 (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+  (* Gather p2 *)
+  A.change_equal_slprop (pp2x `pts_to` _) (pp2x `pts_to` _);
+  A.change_equal_slprop (pp2y `pts_to` _) (pp2y `pts_to` _);
+  unfocus pp2x pp2 (field point_fields_pcm X) (Some (Ghost.reveal y1));
+  unfocus pp2y pp2 (field point_fields_pcm Y) (Some (Ghost.reveal x1));
+  A.change_equal_slprop
+    (pp2 `pts_to` put (field point_fields_pcm X) _ _)
+    (pp2 `pts_to` mk_point (Some (Ghost.reveal y1)) None);
+  A.change_equal_slprop
+    (pp2 `pts_to` put (field point_fields_pcm Y) _ _)
+    (pp2 `pts_to` mk_point None (Some (Ghost.reveal x1)));
+  gather pp2 (mk_point (Some (Ghost.reveal y1)) None) (mk_point None (Some (Ghost.reveal x1)));
+  gather pp2 (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+  (* Gather p *)
+  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
+  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
+  unfocus pp1 p (field line_fields_pcm P1)
+    (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)));
+  unfocus pp2 p (field line_fields_pcm P2)
+    (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1)));
   A.change_equal_slprop
-    (p `pts_to` put (field point_fields_pcm X) _ _)
-    (p `pts_to` mk_point (Some (Ghost.reveal y)) None);
+    (p `pts_to` put (field line_fields_pcm P1) _ _)
+    (p `pts_to`
+      mk_line
+        (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
+        (one point_pcm));
   A.change_equal_slprop
-    (p `pts_to` put (field point_fields_pcm Y) _ _)
-    (p `pts_to` mk_point None (Some (Ghost.reveal x)));
-  gather p (mk_point (Some (Ghost.reveal y)) None) (mk_point None (Some (Ghost.reveal x)));
-  gather p (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
-  A.change_equal_slprop (p `pts_to` _) _
+    (p `pts_to` put (field line_fields_pcm P2) _ _)
+    (p `pts_to`
+      mk_line
+        (one point_pcm)
+        (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1))));
+  gather p
+    (mk_line
+      (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
+      (one point_pcm))
+    (mk_line
+       (one point_pcm)
+       (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1))));
+  gather p (mk_line (Ghost.reveal (Ghost.hide (one point_pcm))) (one point_pcm)) _;
+  //A.change_equal_slprop (pp2 `pts_to` _) _;
+  (* int *r = &p.p1.y; *)
+  (* int *s = &p.p2.x; *)
+  (* int *t = &p.p2.y; *)
+  A.sladmit();
+  A.return ()
+#pop-options
+*)
+
+(*
+pts_to r x
+(fun r' -> pts_to r' x')
+(requires (fun _ -> x is in case A))
+(ensures (fun _ r' _ -> x == A x'))
+A x' = (|TagA, x'|)
+
+(q:ref .) (t: erased tag)
+pts_to q (t, u)
+(requires (fun _ -> u is in case (tag_denote t)))
+
+(q:ref .) (t: erased tag)
+(r:ref . = the union inside q)
+pts_to q (t, one) `star` pts_to r x
+
+(requires (fun _ -> x is in case (tag_denote t)))
+*)
 
 (*
 to print proof state, try:

From 80cdca57b4851ca3f49df90aa4a5289d6ab248cd Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 07:53:06 -0700
Subject: [PATCH 056/513] Add AggregateRef.fsti

---
 examples/steel/AggregateRef.fst  | 393 ++++------------------------
 examples/steel/AggregateRef.fsti | 436 +++++++++++++++++++++++++++++++
 2 files changed, 486 insertions(+), 343 deletions(-)
 create mode 100644 examples/steel/AggregateRef.fsti

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 436231faf14..c19eba177fe 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -3,135 +3,37 @@ module AggregateRef
 open FStar.PCM
 module P = FStar.PCM
 
-(** Misc. combinators *)
-let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
-let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
-let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
-let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
-    
-(** The non-computational part of frame_preserving_upd
-    TODO: move this and lemmas about this to FStar.PCM.fst *)
-let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (v:'a{p.refine v /\ compatible p x v})
-= p.refine (f v) /\
-  compatible p y (f v) /\
-  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
-     composable p y frame /\
-     (op p x frame == v ==> op p y frame == f v))
-let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
-  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
-  frame_pres_on p f x y v
-
-(** Every function satisfying frame_pres is a frame_preserving_upd *)
-let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
-  (f:('a -> 'a){frame_pres p f x y})
-  : frame_preserving_upd p x y
-  = fun v -> f v
-(** The converse is not true, because a frame_preserving_upd's domain
-    is restricted to v:a{p.refine v /\ compatible p x v}. *)
-
-let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (g:(v:'a{p.refine v /\ compatible p x v} -> 
-     Lemma (p.refine (f v) /\ compatible p y (f v) /\
-            (forall (frame:'a{composable p x frame}).
-              composable p y frame /\
-              (op p x frame == v ==> op p y frame == f v)))
-     [SMTPat (compatible p x v)]))
-: Lemma (frame_pres p f x y) =
+let frame_pres_intro p f x y g =
   let _ = g in ()
 
-(** TODO move PCM morphisms and refinements to FStar.PCM.fst? *)
-
 (** PCM morphisms *)
 
-let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
-let morphism_one (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  unit -> Lemma (f (one p) == one q)
-let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  x:'a -> y:'a ->
-    Lemma 
-      (requires composable p x y) 
-      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
-      [SMTPat (composable p x y)]
-
-noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
-  f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
-  f_one: morphism_one p q f;
-  f_op: x:a -> y:a ->
-    Lemma 
-      (requires composable p x y) 
-      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
-      [SMTPat (composable p x y)]
-}
-
-let pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p = {
+let pcm_morphism_id #a #p = {
   f_refine = (fun _ -> ());
   f_one = (fun _ -> ());
   f_op = (fun _ _ -> ());
 }
 
-let pcm_morphism_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#f: 'b -> 'c) (#g: 'a -> 'b)
-  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
-: pcm_morphism (f `compose` g) p r = {
+let pcm_morphism_comp #a #b #c #p #q #r #f #g mf mg = {
   f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
   f_one = (fun () -> mg.f_one (); mf.f_one ());
   f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
 }
 
 open Aggregates
-let pcm_morphism_both (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd) (#f: 'a -> 'c) (#g: 'b -> 'd)
-  (mf: pcm_morphism f p r) (mg: pcm_morphism g q s)
-: pcm_morphism (both f g) (p `pcm_times` q) (r `pcm_times` s) = {
+let pcm_morphism_both #a #b #c #p #q #r #s #f #g mf mg = {
   f_refine = (fun (x, y) -> mf.f_refine x; mg.f_refine y);
   f_one = (fun () -> mg.f_one (); mf.f_one ());
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f
-        and p.refine *)
-let refine_t (f: 'a -> prop) = x:'a{f x}
-noeq type pcm_refinement #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
-  new_one: (new_one:refine_t f{p.refine new_one});
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
-}
-
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
-
-let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_comp x y; op p x y
-
-(** Any refinement r for p can be used to construct a refined PCM with the same product
-    and composability predicate, but restricted to elements in r.f *)
-let refined_one_pcm a = p:pcm a{p.refine (one p)}
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): refined_one_pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
-  refine = p.refine;
-}
-
-let pcm_refinement_comp_new_one (#p: pcm 'a)
-  (re: pcm_refinement p) (x: refine_t re.f)
-  (y: 'a{composable p x y})
-: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
-         composable (refined_pcm re) x (op p re.new_one y))
-= re.new_one_is_refined_unit x;
+let pcm_refinement_comp_new_one #a #p re x y =
+  re.new_one_is_refined_unit x;
   p.assoc_r x re.new_one y;
   re.f_closed_comp re.new_one y
 
-let pcm_refinement_compatible_closed (#p: pcm 'a)
-  (re: pcm_refinement p) (x: refine_t re.f)
-  (y: 'a{compatible p x y})
-: Lemma (re.f y /\ compatible (refined_pcm re) x y)
-= let p' = refined_pcm re in
+let pcm_refinement_compatible_closed #a #p re x y =
+  let p' = refined_pcm re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
@@ -143,34 +45,13 @@ let pcm_refinement_compatible_closed (#p: pcm 'a)
     p.comm x (op p re.new_one frame_x);
     compatible_intro p' x y (op p re.new_one frame_x))
 
-(** A PCM refinement is well-formed if frame-preserving updates on the
-    refined PCM can be turned to frame-preserving updates on the
-    unrefined PCM *)
-
-(** Very well-behaved lenses *)
-noeq type lens (a: Type u#a) (b: Type u#b) = {
-  get: a -> b;
-  put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
-  put_get: s: a -> Lemma (put (get s) s == s);
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
-}
-let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
-  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
-  = l.get_put s v
-let put_get' (l: lens 'a 'b) (s: 'a)
-  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
-  = l.put_get s
-let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
-  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
-  = l.put_put s v w
-
-(** Updating the target of a lens *)
-let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+(** Lenses *)
+
+let lens_upd l f s = l.put (f (l.get s)) s
 
 (** The identity lens *)
 let const (x: 'a) (b: 'b): 'a = x
-let lens_id #a : lens a a = {
+let lens_id #a = {
   get = id;
   put = const;
   get_put = (fun _ _ -> ());
@@ -182,7 +63,7 @@ let lens_id #a : lens a a = {
 let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
 let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
   lens_upd l (m.put v) s
-let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
+let lens_comp l m = {
   get = get_comp l m;
   put = put_comp l m;
   get_put = (fun _ _ -> ());
@@ -190,52 +71,31 @@ let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
   put_put = (fun _ _ _ -> ());
 }
 
-(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
-    (1) get is a PCM morphism p -> q
-    (2) put is a PCM morphism q×p -> p *)
-
-noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
-  l: lens a b;
-  get_morphism: pcm_morphism l.get p q;
-  put_morphism: pcm_morphism (uncurry l.put) (q `pcm_times` p) p;
-}
-let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
-let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
-let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
-
-(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
-    frame-preserving updates on the source *)
+(** PCM lenses *)
 
-let compatible_pcm_morphism (#p: pcm 'a) (#q: pcm 'b)
-  (f: 'a -> 'b) (m: pcm_morphism f p q) (x y: Ghost.erased 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
-= compatible_elim p x y (compatible q (f x) (f y)) (fun frame_x ->
+let compatible_pcm_morphism #a #b #p #q f m x y =
+  compatible_elim p x y (compatible q (f x) (f y)) (fun frame_x ->
   let _ = m.f_op frame_x x in
   compatible_intro q (f x) (f y) (f frame_x))
 
-let pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
-= compatible_pcm_morphism l.l.get l.get_morphism x y
+let pcm_lens_compatible_get #a #b #p #q l x y =
+  compatible_pcm_morphism l.l.get l.get_morphism x y
     
-let pcm_lens_frame_pres (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v: 'b) (f: 'b -> 'b)
-: Lemma
-    (requires frame_pres q f (get l s) v)
-    (ensures frame_pres p (upd l f) s (put l v s))
-    [SMTPat (frame_pres q f (get l s) v)]
-= frame_pres_intro p (upd l f) s (put l v s) (fun full ->
+let pcm_lens_frame_pres #a #b #p #q l s v f =
+  frame_pres_intro p (upd l f) s (put l v s) (fun full ->
     let _ = l.get_morphism.f_refine in
     pcm_lens_compatible_get l s full;
     l.put_morphism.f_refine (f (get l full), full);
     let goal = frame_pres_on p (upd l f) s (put l v s) full in
     compatible_elim p s full goal (fun frame_s ->
     compatible_elim q v (f (get l full)) goal (fun frame_v ->
-    let frame_vs: 'a = put l frame_v frame_s in
+    let frame_vs: a = put l frame_v frame_s in
     l.put_morphism.f_op (v, s) (frame_v, frame_s);
     p.comm frame_vs (put l v s);
     q.comm v frame_v;
     p.comm s frame_s;
     compatible_intro p (put l v s) (upd l f full) frame_vs;
-    let aux (frame:'a{composable p s frame})
+    let aux (frame:a{composable p s frame})
     : Lemma (composable p (put l v s) frame /\
              (op p s frame == full ==> op p (put l v s) frame == upd l f full))
     = l.get_morphism.f_op s frame;
@@ -246,17 +106,13 @@ let pcm_lens_frame_pres (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a) (v:
       = () in ()
     in FStar.Classical.forall_intro aux)))
 
-(** The identity lens is a pcm_lens *)
-let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
+let pcm_lens_id (#p: pcm 'a) = {
   l = lens_id; 
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
 
-(** pcm_lens composition is lens composition *)
-let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (l: pcm_lens p q) (m: pcm_lens q r): pcm_lens p r = 
-{
+let pcm_lens_comp #a #b #c #p #q #r l m = {
   l = lens_comp l.l m.l;
   get_morphism = {
     f_refine = (fun _ ->
@@ -281,37 +137,8 @@ let pcm_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 }
 
 open FStar.FunctionalExtensionality
-
-let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
-  frame_preserving_upd p x y ->
-  frame_preserving_upd q x' y'
-
-let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
-  x: Ghost.erased (refine_t r.f) ->
-  y: Ghost.erased (refine_t r.f) ->
-  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
-
-(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
-    This allows the reference to point to substructures of unions with known case. *)
-noeq type ref (a:Type) (b:Type): Type = {
-  p: refined_one_pcm a;
-  re: pcm_refinement p;
-  (** Needed to turn frame-preserving updates on (refined_pcm re) into
-      frame-preserving updates on p. To do so, also requires that p and q
-      be `refined_one_pcm`s *)
-  u: pcm_unrefinement re;
-  q: refined_one_pcm b;
-  pl: pcm_lens (refined_pcm re) q;
-  r: Steel.Memory.ref a p;
-}
-
 open Steel.Effect
 
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
-let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop = (* TODO unerase v, try [@@@smt_fallback] *)
-  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
-
 (** Basic lenses *)
 
 let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
@@ -631,15 +458,6 @@ let pcm_lens_refine
   
 (** Isomorphisms *)
 
-noeq type iso a b = {
-  fwd: a -> b;
-  bwd: b -> a;
-  fwd_bwd: x:b -> Lemma (fwd (bwd x) == x);
-  bwd_fwd: x:a -> Lemma (bwd (fwd x) == x);
-}
-let fwd_bwd' (i: iso 'a 'b) (x: 'b): Lemma (i.fwd (i.bwd x) == x) [SMTPat (i.fwd (i.bwd x))] = i.fwd_bwd x
-let bwd_fwd' (i: iso 'a 'b) (x: 'a): Lemma (i.bwd (i.fwd x) == x) [SMTPat (i.bwd (i.fwd x))] = i.bwd_fwd x
-
 let iso_lens_comp_get (i: iso 'a 'b) (l: lens 'b 'c): 'a -> 'c = l.get `compose` i.fwd
 let iso_lens_comp_put (i: iso 'a 'b) (l: lens 'b 'c) (v: 'c) (s: 'a): 'a = i.bwd (l.put v (i.fwd s))
 let iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c = {
@@ -672,12 +490,6 @@ let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
 
 (** PCM isomorphisms *)
 
-noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
-  i: iso a b;
-  fwd_morphism: pcm_morphism i.fwd p q;
-  bwd_morphism: pcm_morphism i.bwd q p;
-}
-
 let pcm_refinement_conj_iso_i (p: pcm 'a)
   (re1: pcm_refinement p)
   (re2: pcm_refinement (refined_pcm re1))
@@ -828,10 +640,11 @@ let ref_refine (r: ref 'a 'b)
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a 'c =
+let ref_focus r q l =
   {p = r.p; re = r.re; u = r.u; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
-let focus (r: ref 'a 'b) (q: refined_one_pcm 'c)
+let focus (r: ref 'a 'b)
+  (#q: refined_one_pcm 'c)
   (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : Steel (ref 'a 'c)
     (r `pts_to` s)
@@ -859,18 +672,8 @@ let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (#r'q: pcm 'b) (#q: refined_o
     (fun _ _ -> True)
     (fun m -> r'.pl.get_morphism.f_one ())
 
-let change_equal_vprop #inames (p q: M.slprop)
-: A.SteelGhost unit inames (to_vprop p) (fun _ -> to_vprop q) (fun _ -> p == q) (fun _ _ _ -> True)
-= A.change_equal_slprop (to_vprop p) (to_vprop q)
-// TODO rename
-
-let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
-: Steel unit
-    (r `pts_to` xy)
-    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
-    (fun _ _ _ -> True)
-= A.change_equal_slprop
+let split r xy x y =
+  A.change_equal_slprop
     (r `pts_to` xy)
     (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re)))));
   (refined_pcm r.re).is_unit (one (refined_pcm r.re));
@@ -888,21 +691,16 @@ let split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
     (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
     (r `pts_to` y)
 
-let mgather (#a:Type)
-            (#p:FStar.PCM.pcm a)
-            (r:Steel.Memory.ref a p)
-            (v0:Ghost.erased a)
-            (v1:Ghost.erased a)
+let mgather
+  (#a:Type) (#p:FStar.PCM.pcm a)
+  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
 : SteelT (_:unit{composable p v0 v1})
     (mpts_to r v0 `star` mpts_to r v1)
     (fun _ -> mpts_to r (op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
-let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
-: SteelT (_:unit{composable r.q x y})
-    ((r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> r `pts_to` op r.q x y)
-= A.change_equal_slprop
+let gather r x y =
+  A.change_equal_slprop
     (r `pts_to` x)
     (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
   A.change_equal_slprop
@@ -920,14 +718,6 @@ let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
     (Ghost.reveal y, one (refined_pcm r.re));
   A.change_equal_slprop _ (r `pts_to` op r.q x y)
 
-let rewrite_context #inames (p q: vprop)
-: Steel.Effect.Atomic.SteelAtomicF unit inames
-    (p)
-    (fun _ -> q)
-    (requires fun _ -> p == q)
-    (ensures fun _ _ _ -> True)
-= A.change_equal_slprop p q
-
 let peel (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c)
   (l: pcm_lens rq q) (x: Ghost.erased 'b)
 : Steel unit
@@ -941,103 +731,31 @@ let peel (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c)
   r.q.is_unit x;
   q.comm (get l x) (one q);
   l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
-  split r x (put l (one q) x) (put l (get l x) (one r.q));
-  A.sladmit()
-  //A.rewrite_context
-  //A.change_equal_slprop ((r `pts_to` (Ghost.reveal (Ghost.hide (put l (one q) (Ghost.reveal x))))) `star` (r `pts_to` _)) ((r `pts_to` _) `star` (r `pts_to` _))
+  split r x (put l (one q) x) (put l (get l x) (one r.q))
 
-let addr_of_lens (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c)
-  (l: pcm_lens rq q) (x: Ghost.erased 'b)
-: Steel (ref 'a 'c)
-    (r `pts_to` x)
-    (fun s ->
-      (r `pts_to` put l (one q) x) `star` 
-      (s `pts_to` get l x))
-    (requires fun _ -> rq == r.q)
-    (ensures fun _ r' _ -> rq == r.q /\ r' == ref_focus r q l)
-= peel r l x;
-  focus r q l (put l (get l x) (one r.q)) (get l x)
+let addr_of_lens r l x =
+  peel r l x;
+  focus r l (put l (get l x) (one r.q)) (get l x)
 
-let un_addr_of_lens
-  (r': ref 'a 'c) (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c) (l: pcm_lens rq q)
-  (x: Ghost.erased 'b) (y: Ghost.erased 'c)
-: Steel unit
-    ((r `pts_to` x) `star` (r' `pts_to` y))
-    (fun s -> r `pts_to` put l y x)
-    (requires fun _ -> rq == r.q /\ r' == ref_focus r q l /\ get l x == one q)
-    (ensures fun _ _ _ -> True)
-= unfocus r' r l y;
+let un_addr_of_lens r' r #rq #q l x y =
+  unfocus r' r l y;
   gather r x (put l y (one r.q));
   q.is_unit (Ghost.reveal y);
   r.q.is_unit (Ghost.reveal x);
   q.comm (get l x) y;
   l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one r.q);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  A.return ()
-
-let refine (r: ref 'a 'b)
-  (re: pcm_refinement r.q)
-  (u: pcm_unrefinement re)
-  (x: Ghost.erased 'b{re.f x})
-: Steel (ref 'a (refine_t re.f))
-    (r `pts_to` x)
-    (fun r' -> r' `pts_to` Ghost.reveal x)
-    (fun _ -> True)
-    (fun _ r' _ -> r' == ref_refine r re u)
-= let r' = ref_refine r re u in
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
+
+let refine r re u x =
+  let r' = ref_refine r re u in
   A.change_equal_slprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
-let unrefine #inames (r': ref 'a 'b)
-  (re: pcm_refinement r'.q) (u: pcm_unrefinement re)
-  (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
-: A.SteelGhost unit inames
-    (r `pts_to` Ghost.reveal x)
-    (fun _ -> r' `pts_to` x)
-    (fun _ -> r == ref_refine r' re u)
-    (fun _ _ _ -> True)
-= A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
-
-
-(*
-
-describe this situation:
+let unrefine #inames r' re u r x =
+  A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
-  thread 1: pointer to p.x
-  
-  thread 2: pointer to p but with permissions {None, y}
-  
-  *p a value compatible with {None, y}
-  i.e., any {x, y} for any x
-  x could be:
-    Some z for a garbage z, or
-    None
-
-  but, impossible to work with p->x:
-    *p = {x, y}
-    ( *p).x == 0
-    need {x, y}.x is Some v
-    if (( *p).x == 0) { .. } else { .. }
-    
-  {None, y} compatible with {vx, vy} 
-  let vx = ref_read &p->x in
-  match vx with None -> .. | Some x -> ..
-
-  {None, y} compatible with {vx, vy} 
-  let vx = ref_read &p->x in
-  let bad = (f : option int -> option int) vx in
-
-  could prevent pattern matching if option int were an abstract type
-
-*)
-
-let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
-: Steel 'b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> ~ (Ghost.reveal x == one r.q))
-    (ensures fun _ x' _ -> compatible r.q x x')
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+let ref_read r x =
+  let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
   let v = Steel.PCMReference.read r.r x' in
   pcm_refinement_compatible_closed r.re x' v;
@@ -1045,14 +763,6 @@ let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
   A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
   A.return (get r.pl v)
 
-let whole_value (p: pcm 'a) (x: 'a) =
-  p.refine x /\
-  (forall (y:'a{composable p x y}).{:pattern op p y x} op p y x == x)
-
-let valid_write (p:pcm 'a) x y =
-  whole_value p x /\ whole_value p y /\
-  (forall (frame:'a). composable p x frame ==> composable p y frame)
-
 let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   (f: ('b -> 'b){frame_pres r.q f x y})
 : frame_preserving_upd r.p
@@ -1076,9 +786,7 @@ let as_action (#p:vprop)
   A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
   A.return x
 
-let ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-= as_action (ref_upd_act r x y f)
+let ref_upd r x y f = as_action (ref_upd_act r x y f)
 
 let frame_preserving_upd_valid_write (p: pcm 'a)
   (x:Ghost.erased 'a) (y:'a{valid_write p x y})
@@ -1100,8 +808,7 @@ let ref_write (r: ref 'a 'b) (x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 = ref_upd r x y (frame_preserving_upd_valid_write r.q x y)
 
+(* From ref_write, can derive the expected write for all-or-none PCM *)
 let ref_write_opt_pcm (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
 : SteelT unit (r `pts_to` Some (Ghost.reveal x)) (fun _ -> r `pts_to` Some y)
 = ref_write r (Some (Ghost.reveal x)) (Some y)
-
-
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
new file mode 100644
index 00000000000..de93dbf0421
--- /dev/null
+++ b/examples/steel/AggregateRef.fsti
@@ -0,0 +1,436 @@
+module AggregateRef
+
+open FStar.PCM
+module P = FStar.PCM
+
+(** Misc. combinators *)
+let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
+let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
+let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
+    
+(** The non-computational part of frame_preserving_upd
+    TODO: move this and lemmas about this to FStar.PCM.fst *)
+let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (v:'a{p.refine v /\ compatible p x v})
+= p.refine (f v) /\
+  compatible p y (f v) /\
+  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
+     composable p y frame /\
+     (op p x frame == v ==> op p y frame == f v))
+let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
+  frame_pres_on p f x y v
+
+(** Every function satisfying frame_pres is a frame_preserving_upd *)
+let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
+  (f:('a -> 'a){frame_pres p f x y})
+  : frame_preserving_upd p x y
+  = fun v -> f v
+(** The converse is not true, because a frame_preserving_upd's domain
+    is restricted to v:a{p.refine v /\ compatible p x v}. *)
+
+val frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (g:(v:'a{p.refine v /\ compatible p x v} -> 
+     Lemma (p.refine (f v) /\ compatible p y (f v) /\
+            (forall (frame:'a{composable p x frame}).
+              composable p y frame /\
+              (op p x frame == v ==> op p y frame == f v)))
+     [SMTPat (compatible p x v)]))
+: Lemma (frame_pres p f x y)
+
+(** TODO move PCM morphisms and refinements to FStar.PCM.fst? *)
+
+(** PCM morphisms *)
+
+let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
+let morphism_one (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  unit -> Lemma (f (one p) == one q)
+let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  x:'a -> y:'a ->
+    Lemma 
+      (requires composable p x y) 
+      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
+      [SMTPat (composable p x y)]
+
+noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
+  f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
+  f_one: morphism_one p q f;
+  f_op: x:a -> y:a ->
+    Lemma 
+      (requires composable p x y) 
+      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
+      [SMTPat (composable p x y)]
+}
+
+val pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p
+
+val pcm_morphism_comp
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (#f: 'b -> 'c) (#g: 'a -> 'b)
+  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
+: pcm_morphism (f `compose` g) p r
+
+open Aggregates
+val pcm_morphism_both
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd)
+  (#f: 'a -> 'c) (#g: 'b -> 'd)
+  (mf: pcm_morphism f p r) (mg: pcm_morphism g q s)
+: pcm_morphism (both f g) (p `pcm_times` q) (r `pcm_times` s)
+
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f
+        and p.refine *)
+let refine_t (f: 'a -> prop) = x:'a{f x}
+noeq type pcm_refinement #a (p: pcm a) = {
+  f: a -> prop;
+  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
+  new_one: (new_one:refine_t f{p.refine new_one});
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+}
+
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+
+let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_comp x y; op p x y
+
+(** Any refinement r for p can be used to construct a refined PCM with the same product
+    and composability predicate, but restricted to elements in r.f *)
+let refined_one_pcm a = p:pcm a{p.refine (one p)}
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): refined_one_pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  refine = p.refine;
+}
+
+val pcm_refinement_comp_new_one
+  (#p: pcm 'a) (re: pcm_refinement p)
+  (x: refine_t re.f) (y: 'a{composable p x y})
+: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
+         composable (refined_pcm re) x (op p re.new_one y))
+
+val pcm_refinement_compatible_closed
+  (#p: pcm 'a) (re: pcm_refinement p)
+  (x: refine_t re.f) (y: 'a{compatible p x y})
+: Lemma (re.f y /\ compatible (refined_pcm re) x y)
+
+(** A PCM refinement is well-formed if frame-preserving updates on the
+    refined PCM can be turned to frame-preserving updates on the
+    unrefined PCM *)
+
+(** Very well-behaved lenses *)
+noeq type lens (a: Type u#a) (b: Type u#b) = {
+  get: a -> b;
+  put: b -> a -> a;
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
+  put_get: s: a -> Lemma (put (get s) s == s);
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+}
+let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
+  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
+  = l.get_put s v
+let put_get' (l: lens 'a 'b) (s: 'a)
+  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
+  = l.put_get s
+let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
+  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
+  = l.put_put s v w
+
+(** Updating the target of a lens *)
+val lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a
+
+(** The identity lens *)
+val lens_id: lens 'a 'a
+
+(** Lens composition *)
+val lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c
+
+(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
+    (1) get is a PCM morphism p -> q
+    (2) put is a PCM morphism q×p -> p *)
+
+noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
+  l: lens a b;
+  get_morphism: pcm_morphism l.get p q;
+  put_morphism: pcm_morphism (uncurry l.put) (q `pcm_times` p) p;
+}
+let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
+let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
+let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
+
+(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
+    frame-preserving updates on the source *)
+
+val compatible_pcm_morphism
+  (#p: pcm 'a) (#q: pcm 'b)
+  (f: 'a -> 'b) (m: pcm_morphism f p q)
+  (x y: Ghost.erased 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
+
+val pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
+
+val pcm_lens_frame_pres
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (s: 'a) (v: 'b) (f: 'b -> 'b)
+: Lemma
+    (requires frame_pres q f (get l s) v)
+    (ensures frame_pres p (upd l f) s (put l v s))
+    [SMTPat (frame_pres q f (get l s) v)]
+
+(** The identity lens is a pcm_lens *)
+val pcm_lens_id (#p: pcm 'a): pcm_lens p p
+
+(** pcm_lens composition is lens composition *)
+val pcm_lens_comp
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (l: pcm_lens p q) (m: pcm_lens q r)
+: pcm_lens p r
+
+open FStar.FunctionalExtensionality
+
+let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
+  frame_preserving_upd p x y ->
+  frame_preserving_upd q x' y'
+
+let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
+  x: Ghost.erased (refine_t r.f) ->
+  y: Ghost.erased (refine_t r.f) ->
+  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
+
+(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
+    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
+    This allows the reference to point to substructures of unions with known case. *)
+noeq type ref (a:Type) (b:Type): Type = {
+  p: refined_one_pcm a;
+  re: pcm_refinement p;
+  (** Needed to turn frame-preserving updates on (refined_pcm re) into
+      frame-preserving updates on p. To do so, also requires that p and q
+      be `refined_one_pcm`s *)
+  u: pcm_unrefinement re;
+  q: refined_one_pcm b;
+  pl: pcm_lens (refined_pcm re) q;
+  r: Steel.Memory.ref a p;
+}
+
+open Steel.Effect
+
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+
+(* TODO for some reason, run into universe issues if make this abstract *)
+let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop = (* TODO unerase v, try [@@@smt_fallback] *)
+  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
+
+(** A pcm_lens for the k-th field of an n-ary product *)
+val field (#a:eqtype) (#b:a -> Type) (p:(k:a -> pcm (b k))) (k:a): pcm_lens (prod_pcm p) (p k)
+
+(** The refinement of an n-ary union PCM to the k-th case *)
+
+val case_refinement
+  (#b:'a -> Type)
+  (p:(k:'a -> refined_one_pcm (b k))) (k:'a)
+: pcm_refinement (union_pcm p)
+
+val case_unrefinement
+  (#a:eqtype) (#b:a -> Type)
+  (p:(k:a -> refined_one_pcm (b k))) (k:a)
+: pcm_unrefinement (case_refinement p k)
+
+(** A pcm_lens for the k-th case of an n-ary union *)
+val case (#b:'a -> Type) (p:(k:'a -> refined_one_pcm (b k))) (k:'a)
+: pcm_lens (refined_pcm (case_refinement p k)) (p k)
+
+(** Refining a pcm_lens *)
+
+val extend_refinement
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_refinement p
+
+val pcm_lens_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q)
+: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re)
+
+(** Isomorphisms *)
+
+noeq type iso a b = {
+  fwd: a -> b;
+  bwd: b -> a;
+  fwd_bwd: x:b -> Lemma (fwd (bwd x) == x);
+  bwd_fwd: x:a -> Lemma (bwd (fwd x) == x);
+}
+let fwd_bwd' (i: iso 'a 'b) (x: 'b): Lemma (i.fwd (i.bwd x) == x) [SMTPat (i.fwd (i.bwd x))] = i.fwd_bwd x
+let bwd_fwd' (i: iso 'a 'b) (x: 'a): Lemma (i.bwd (i.fwd x) == x) [SMTPat (i.bwd (i.fwd x))] = i.bwd_fwd x
+
+val iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c
+
+(** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
+
+val refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+: iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g)
+
+(** PCM isomorphisms *)
+
+noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
+  i: iso a b;
+  fwd_morphism: pcm_morphism i.fwd p q;
+  bwd_morphism: pcm_morphism i.bwd q p;
+}
+
+val pcm_iso_lens_comp
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (i: pcm_iso p q) (l: pcm_lens q r)
+: pcm_lens p r
+
+(** The conjunction of two refinements *)
+
+val conj_refinement
+  (#p: pcm 'a) (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: pcm_refinement p
+
+(** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
+    refinement by the conjunction of re1 and re2 *)
+val pcm_refinement_conj_iso
+  (p: pcm 'a) (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+: pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2)
+
+val upd_across_pcm_iso
+  (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
+: frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
+
+val conj_unrefinement (#p: pcm 'a)
+  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
+: pcm_unrefinement (conj_refinement #'a re1 re2)
+
+val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
+: pcm_unrefinement (extend_refinement l re)
+
+(** The refinement of a ref *)
+
+val ref_refine
+  (r: ref 'a 'b) (new_re: pcm_refinement r.q) (new_u: pcm_unrefinement new_re)
+: ref 'a (refine_t new_re.f)
+
+(** Fundamental operations on references *)
+
+module A = Steel.Effect.Atomic
+
+val ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a 'c
+
+val split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
+: Steel unit
+    (r `pts_to` xy)
+    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
+    (fun _ _ _ -> True)
+
+val gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
+: SteelT (_:unit{composable r.q x y})
+    ((r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> r `pts_to` op r.q x y)
+
+val addr_of_lens
+  (r: ref 'a 'b)
+  (#rq: pcm 'b) (#q: refined_one_pcm 'c) (l: pcm_lens rq q)
+  (x: Ghost.erased 'b)
+: Steel (ref 'a 'c)
+    (r `pts_to` x)
+    (fun s ->
+      (r `pts_to` put l (one q) x) `star` 
+      (s `pts_to` get l x))
+    (requires fun _ -> rq == r.q)
+    (ensures fun _ r' _ -> rq == r.q /\ r' == ref_focus r q l)
+
+val un_addr_of_lens
+  (r': ref 'a 'c) (r: ref 'a 'b)
+  (#rq: pcm 'b) (#q: refined_one_pcm 'c) (l: pcm_lens rq q)
+  (x: Ghost.erased 'b) (y: Ghost.erased 'c)
+: Steel unit
+    ((r `pts_to` x) `star` (r' `pts_to` y))
+    (fun s -> r `pts_to` put l y x)
+    (requires fun _ -> rq == r.q /\ r' == ref_focus r q l /\ get l x == one q)
+    (ensures fun _ _ _ -> True)
+
+val refine
+  (r: ref 'a 'b)
+  (re: pcm_refinement r.q)
+  (u: pcm_unrefinement re)
+  (x: Ghost.erased 'b{re.f x})
+: Steel (ref 'a (refine_t re.f))
+    (r `pts_to` x)
+    (fun r' -> r' `pts_to` Ghost.reveal x)
+    (fun _ -> True)
+    (fun _ r' _ -> r' == ref_refine r re u)
+
+val unrefine
+  (#opened:Steel.Memory.inames)
+  (r': ref 'a 'b)
+  (re: pcm_refinement r'.q) (u: pcm_unrefinement re)
+  (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
+: A.SteelGhost unit opened
+    (r `pts_to` Ghost.reveal x)
+    (fun _ -> r' `pts_to` x)
+    (fun _ -> r == ref_refine r' re u)
+    (fun _ _ _ -> True)
+
+(*
+
+describe this situation:
+
+  thread 1: pointer to p.x
+  
+  thread 2: pointer to p but with permissions {None, y}
+  
+  *p a value compatible with {None, y}
+  i.e., any {x, y} for any x
+  x could be:
+    Some z for a garbage z, or
+    None
+
+  but, impossible to work with p->x:
+    *p = {x, y}
+    ( *p).x == 0
+    need {x, y}.x is Some v
+    if (( *p).x == 0) { .. } else { .. }
+    
+  {None, y} compatible with {vx, vy} 
+  let vx = ref_read &p->x in
+  match vx with None -> .. | Some x -> ..
+
+  {None, y} compatible with {vx, vy} 
+  let vx = ref_read &p->x in
+  let bad = (f : option int -> option int) vx in
+
+  could prevent pattern matching if option int were an abstract type
+
+*)
+val ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
+: Steel 'b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> ~ (Ghost.reveal x == one r.q))
+    (ensures fun _ x' _ -> compatible r.q x x')
+
+val ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
+
+(* TODO move to FStar.PCM.fst? *)
+let whole_value (p: pcm 'a) (x: 'a) =
+  p.refine x /\
+  (forall (y:'a{composable p x y}).{:pattern op p y x} op p y x == x)
+
+let valid_write (p:pcm 'a) x y =
+  whole_value p x /\ whole_value p y /\
+  (forall (frame:'a). composable p x frame ==> composable p y frame)
+
+val ref_write (r: ref 'a 'b) (x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)

From f95873c89f680176164e454a4efa32686054b842 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 09:03:15 -0700
Subject: [PATCH 057/513] Make abstract PCM for POD types + make point PCM
 abstract

---
 examples/steel/AggregateRef.fst         | 117 ------------
 examples/steel/AggregateRef.fsti        | 122 ++++++++++--
 examples/steel/AggregateRefExamples.fst | 239 +++++++-----------------
 examples/steel/PCM.POD.fst              |  16 ++
 examples/steel/PCM.POD.fsti             |  29 +++
 examples/steel/PointStruct.fst          | 103 ++++++++++
 examples/steel/PointStruct.fsti         |  92 +++++++++
 7 files changed, 420 insertions(+), 298 deletions(-)
 create mode 100644 examples/steel/PCM.POD.fst
 create mode 100644 examples/steel/PCM.POD.fsti
 create mode 100644 examples/steel/PointStruct.fst
 create mode 100644 examples/steel/PointStruct.fsti

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index c19eba177fe..a5081f21961 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -215,120 +215,6 @@ let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_p
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
-(** A lens for the k-th field of an n-ary product *)
-
-let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
-  (f: restricted_t a f_ty)
-: restricted_t a f_ty
-= on_domain a (fun k' -> if k = k' then x' else f k')
-let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
-let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
-  get = lens_field_get f k;
-  put = fun_upd k;
-  get_put = (fun s v -> ());
-  put_get = (fun s -> ext (fun_upd k (lens_field_get f k s) s) s (fun _ -> ()));
-  put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
-}
-
-(** lens_field is a pcm_lens *)
-
-(* TODO move to Aggregates.fst *)
-let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
-  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
-: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
-
-let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
-  l = lens_field f k;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {
-    f_refine = (fun _ -> ());
-    f_one = (fun _ ->
-      ext
-        (fun_upd k (one (p k)) (one (prod_pcm p)))
-        (one (prod_pcm p))
-        (fun k -> ()));
-    f_op = (fun (v, s) (w, t) ->
-      prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
-      ext
-        (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
-        (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
-        (fun _ -> ()));
-  }
-}
-
-(** The refinement of an n-ary union PCM to the k-th case *)
-
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
-  fun kx -> match kx with Some (|k', _|) -> k == k' | None -> False
-
-let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
-: refine_t (case_refinement_f p k)
-= Some (|k, one (p k)|)
-
-let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_refinement (union_pcm p) = {
-  f = case_refinement_f p k;
-  f_closed_comp = (fun x y -> ());
-  new_one = case_refinement_new_one p k;
-  new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
-}
-
-let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement p k)
-= fun kx ky f kv ->
-  let p' = refined_pcm (case_refinement p k) in
-  let p = union_pcm p in
-  match kv with
-  | Some (|k', v|) ->
-    if k = k' then begin
-      let _ = Ghost.hide (
-        let Some (|k, x|) = Ghost.reveal kx in
-        let goal = compatible p' kx kv in
-        compatible_elim p kx kv goal (fun kx_frame -> match kx_frame with
-          | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
-          | None -> compatible_refl p' kx))
-      in
-      let kw = f kv in
-      let aux (frame:union b{composable p kx frame})
-      : Lemma (composable p ky frame /\
-               (op p kx frame == Some (|k, v|) ==>
-                op p ky frame == f (Some (|k, v|))))
-      = let Some (|_, w|) = f (Some (|k, v|)) in
-        match frame with
-        | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
-        | None ->
-          p'.is_unit kx;
-          assert (composable p' kx (one p'));
-          p'.is_unit ky
-      in FStar.Classical.forall_intro aux;
-      kw
-    end else None
-  | _ -> None
-
-(** A lens for the k-th case of an n-ary union *)
-
-let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
-  fun (Some (|_, v|)) -> v
-let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
-: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
-= fun _ -> Some (|k, v|)
-  
-let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f p k)) ('b k) = {
-  get = lens_case_get p k;
-  put = lens_case_put p k;
-  get_put = (fun s v -> ());
-  put_get = (fun s -> ());
-  put_put = (fun s v w -> ());
-}
-
-(** lens_case is a pcm_lens *)
-let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
-  l = lens_case p k;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
 (** Refining a pcm_lens *)
 
 let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
@@ -640,9 +526,6 @@ let ref_refine (r: ref 'a 'b)
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let ref_focus r q l =
-  {p = r.p; re = r.re; u = r.u; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
-
 let focus (r: ref 'a 'b)
   (#q: refined_one_pcm 'c)
   (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
index de93dbf0421..1a13430bf65 100644
--- a/examples/steel/AggregateRef.fsti
+++ b/examples/steel/AggregateRef.fsti
@@ -227,24 +227,120 @@ let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to
 let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop = (* TODO unerase v, try [@@@smt_fallback] *)
   r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
 
-(** A pcm_lens for the k-th field of an n-ary product *)
-val field (#a:eqtype) (#b:a -> Type) (p:(k:a -> pcm (b k))) (k:a): pcm_lens (prod_pcm p) (p k)
+(** A lens for the k-th field of an n-ary product *)
+
+let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
+  (f: restricted_t a f_ty)
+: restricted_t a f_ty
+= on_domain a (fun k' -> if k = k' then x' else f k')
+let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
+let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
+  get = lens_field_get f k;
+  put = fun_upd k;
+  get_put = (fun s v -> ());
+  put_get = (fun s -> ext (fun_upd k (lens_field_get f k s) s) s (fun _ -> ()));
+  put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
+}
+
+(** lens_field is a pcm_lens *)
+
+(* TODO move to Aggregates.fst *)
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
+  l = lens_field f k;
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {
+    f_refine = (fun _ -> ());
+    f_one = (fun _ ->
+      ext
+        (fun_upd k (one (p k)) (one (prod_pcm p)))
+        (one (prod_pcm p))
+        (fun k -> ()));
+    f_op = (fun (v, s) (w, t) ->
+      prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
+      ext
+        (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
+        (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
+        (fun _ -> ()));
+  }
+}
 
 (** The refinement of an n-ary union PCM to the k-th case *)
 
-val case_refinement
-  (#b:'a -> Type)
-  (p:(k:'a -> refined_one_pcm (b k))) (k:'a)
-: pcm_refinement (union_pcm p)
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
+  fun kx -> match kx with Some (|k', _|) -> k == k' | None -> False
 
-val case_unrefinement
-  (#a:eqtype) (#b:a -> Type)
-  (p:(k:a -> refined_one_pcm (b k))) (k:a)
+let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
+: refine_t (case_refinement_f p k)
+= Some (|k, one (p k)|)
+
+let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+: pcm_refinement (union_pcm p) = {
+  f = case_refinement_f p k;
+  f_closed_comp = (fun x y -> ());
+  new_one = case_refinement_new_one p k;
+  new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
+}
+
+(* TODO could be made abstract? *)
+let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
 : pcm_unrefinement (case_refinement p k)
+= fun kx ky f kv ->
+  let p' = refined_pcm (case_refinement p k) in
+  let p = union_pcm p in
+  match kv with
+  | Some (|k', v|) ->
+    if k = k' then begin
+      let _ = Ghost.hide (
+        let Some (|k, x|) = Ghost.reveal kx in
+        let goal = compatible p' kx kv in
+        compatible_elim p kx kv goal (fun kx_frame -> match kx_frame with
+          | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
+          | None -> compatible_refl p' kx))
+      in
+      let kw = f kv in
+      let aux (frame:union b{composable p kx frame})
+      : Lemma (composable p ky frame /\
+               (op p kx frame == Some (|k, v|) ==>
+                op p ky frame == f (Some (|k, v|))))
+      = let Some (|_, w|) = f (Some (|k, v|)) in
+        match frame with
+        | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
+        | None ->
+          p'.is_unit kx;
+          assert (composable p' kx (one p'));
+          p'.is_unit ky
+      in FStar.Classical.forall_intro aux;
+      kw
+    end else None
+  | _ -> None
+
+(** A lens for the k-th case of an n-ary union *)
+
+let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
+  fun (Some (|_, v|)) -> v
+let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
+: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
+= fun _ -> Some (|k, v|)
+  
+let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f p k)) ('b k) = {
+  get = lens_case_get p k;
+  put = lens_case_put p k;
+  get_put = (fun s v -> ());
+  put_get = (fun s -> ());
+  put_put = (fun s v w -> ());
+}
 
-(** A pcm_lens for the k-th case of an n-ary union *)
-val case (#b:'a -> Type) (p:(k:'a -> refined_one_pcm (b k))) (k:'a)
-: pcm_lens (refined_pcm (case_refinement p k)) (p k)
+(** lens_case is a pcm_lens *)
+let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+: pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
+  l = lens_case p k;
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+}
 
 (** Refining a pcm_lens *)
 
@@ -324,7 +420,7 @@ val ref_refine
 
 module A = Steel.Effect.Atomic
 
-val ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a 'c
+let ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a 'c = {p = r.p; re = r.re; u = r.u; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
 
 val split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
 : Steel unit
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index fafca2549f4..8b06c9e1a26 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -9,111 +9,11 @@ open Steel.Effect
 module A = Steel.Effect.Atomic
 
 /// Example 1: swapping the coordinates of a 2d point
-///
-/// Suppose we have the following struct representing 2d points:
-///   struct point { int x, y; };
-///
-/// Carrier of PCM for struct point:
-
-type point_field = | X | Y
-let point_fields k = match k with
-  | X -> option int
-  | Y -> option int
-let point = restricted_t point_field point_fields
-
-/// PCM for struct point:
-
-let int_pcm = opt_pcm #int
-let point_fields_pcm k : pcm (point_fields k) = match k with
-  | X -> int_pcm
-  | Y -> int_pcm
-let point_pcm = prod_pcm point_fields_pcm
-
-/// (mk_point x y) represents (struct point){.x = x, .y = y}
-
-let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
-  | X -> x
-  | Y -> y
-let mk_point (x y: option int): point = on_domain point_field (mk_point_f x y)
-
-/// Laws about putting/getting the x and y fields of a (mk_point x y)
-
-let put_x x' x y
-: Lemma (feq (put (field point_fields_pcm X) x' (mk_point x y)) (mk_point x' y))
-  [SMTPat (put (field point_fields_pcm X) x' (mk_point x y))]
-= ()
-
-let get_x x y
-: Lemma (get (field point_fields_pcm X) (mk_point x y) == x)
-  [SMTPat (get (field point_fields_pcm X) (mk_point x y))]
-= ()
-
-let put_y y' x y
-: Lemma (feq (put (field point_fields_pcm Y) y' (mk_point x y)) (mk_point x y'))
-  [SMTPat (put (field point_fields_pcm Y) y' (mk_point x y))]
-= ()
-
-let get_y x y
-: Lemma (get (field point_fields_pcm Y) (mk_point x y) == y)
-  [SMTPat (get (field point_fields_pcm Y) (mk_point x y))]
-= ()
-
-/// Laws relating mk_point to PCM operations
-
-let one_xy : squash (feq (one point_pcm) (mk_point None None))
-= ()
-
-let merge_xy x y x' y'
-: Lemma (feq (op point_pcm (mk_point x y) (mk_point x' y'))
-             (mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y')))
-  [SMTPat (op point_pcm (mk_point x y) (mk_point x' y'))]
-= ()
-
-/// Taking pointers to the x and y fields of a point
-
-let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
-: SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm X)})
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point None y) `star`
-       (q `pts_to` x))
-= let q = addr_of_lens p (field point_fields_pcm X) (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  A.return q
-
-let un_addr_of_x
-  (p: ref 'a point{p.q == point_pcm})
-  (q: ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm X)})
-  (x y: Ghost.erased (option int))
-: SteelT unit
-    ((p `pts_to` mk_point None y) `star` (q `pts_to` x))
-    (fun q -> p `pts_to` mk_point x y)
-= un_addr_of_lens q p (field point_fields_pcm X) (mk_point None y) x;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (option int))
-: SteelT (q:ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm Y)})
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point x None) `star`
-       (q `pts_to` y))
-= let q = addr_of_lens p (field point_fields_pcm Y) (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
-  A.return q
+open PointStruct
+open PCM.POD
 
-let un_addr_of_y
-  (p: ref 'a point{p.q == point_pcm})
-  (q: ref 'a (option int){q == ref_focus p int_pcm (field point_fields_pcm Y)})
-  (x y: Ghost.erased (option int))
-: SteelT unit
-    ((p `pts_to` mk_point x None) `star` (q `pts_to` y))
-    (fun q -> p `pts_to` mk_point x y)
-= un_addr_of_lens q p (field point_fields_pcm Y) (mk_point x None) y;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-/// With the above, we can write the following function that swaps the x and y fields of a given point:
+/// We can write the following function that swaps the x and y fields of a given point:
 /// 
 /// void point_swap(struct point *p) {
 ///   int *q = &p.x;
@@ -125,31 +25,31 @@ let un_addr_of_y
 
 let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
-    (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
-    (fun _ -> p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x)))
+    (p `pts_to` mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y)))
+    (fun _ -> p `pts_to` mk_point (some (Ghost.reveal y)) (some (Ghost.reveal x)))
 = (* int *q = &p.x; *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let q = addr_of_x p (Some (Ghost.reveal x)) (Some (Ghost.reveal y)) in
+  let q = addr_of_x p (some (Ghost.reveal x)) (some (Ghost.reveal y)) in
   (* int *r = &p.y; *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let r = addr_of_y p None (Some (Ghost.reveal y)) in
+  let r = addr_of_y p none (some (Ghost.reveal y)) in
   (* tmp = *q; *)
-  let Some tmp = ref_read q (Some (Ghost.reveal x)) in
+  let tmp = ref_read q (some (Ghost.reveal x)) in
   (* *q = *r; *)
-  let Some vy = ref_read r (Some (Ghost.reveal y)) in
+  let vy = ref_read r (some (Ghost.reveal y)) in
   ref_write q _ vy;
   (* *r = tmp; *)
   ref_write r _ tmp;
   (* Gather *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  un_addr_of_x p q (Some vy) None;
+  un_addr_of_x p q vy none;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  un_addr_of_y p r (Some vy) (Some tmp);
+  un_addr_of_y p r vy tmp;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-/// Here's a generic swap:
+/// We can also implement swap generically:
 ///
 /// void generic_swap<A>(A *p, A *q) {
 ///   A tmp = *p;
@@ -158,26 +58,26 @@ let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 /// }
 
 let generic_swap
-  (p:ref 'a (option 'c){p.q == opt_pcm #'c})
-  (q:ref 'b (option 'c){q.q == opt_pcm #'c})
+  (p:ref 'a (pod 'c){p.q == pod_pcm 'c})
+  (q:ref 'b (pod 'c){q.q == pod_pcm 'c})
   (x y: Ghost.erased 'c)
 : SteelT unit
-    ((p `pts_to` Some (Ghost.reveal x)) `star`
-     (q `pts_to` Some (Ghost.reveal y)))
+    ((p `pts_to` some (Ghost.reveal x)) `star`
+     (q `pts_to` some (Ghost.reveal y)))
     (fun _ ->
-     (p `pts_to` Some (Ghost.reveal y)) `star`
-     (q `pts_to` Some (Ghost.reveal x)))
+     (p `pts_to` some (Ghost.reveal y)) `star`
+     (q `pts_to` some (Ghost.reveal x)))
 = (* A tmp = *p; *)
-  let Some tmp = ref_read p (Some (Ghost.reveal x)) in
+  let tmp = ref_read p (some (Ghost.reveal x)) in
   (* *p = *q; *)
-  let Some vy = ref_read q (Some (Ghost.reveal y)) in
+  let vy = ref_read q (some (Ghost.reveal y)) in
   ref_write p _ vy;
   (* *q = tmp *)
   ref_write q _ tmp;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _)
 
-/// Now, here's point_swap written using generic_swap:
+/// Now, point_swap written using generic_swap:
 ///
 /// void point_swap_generically(struct point *p) {
 ///   int *q = &p.x;
@@ -188,14 +88,14 @@ let generic_swap
 let point_swap_generically
   (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
-    (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y)))
-    (fun _ -> p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x)))
+    (p `pts_to` mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y)))
+    (fun _ -> p `pts_to` mk_point (some (Ghost.reveal y)) (some (Ghost.reveal x)))
 = (* int *q = &p.x; *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let q = addr_of_x p (Some (Ghost.reveal x)) (Some (Ghost.reveal y)) in
+  let q = addr_of_x p (some (Ghost.reveal x)) (some (Ghost.reveal y)) in
   (* int *r = &p.y; *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let r = addr_of_y p None (Some (Ghost.reveal y)) in
+  let r = addr_of_y p none (some (Ghost.reveal y)) in
   (* generic_swap(q, r); *)
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
@@ -203,12 +103,13 @@ let point_swap_generically
   (* Gather *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  un_addr_of_x p q (Some (Ghost.reveal y)) None;
+  un_addr_of_x p q (some (Ghost.reveal y)) none;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  un_addr_of_y p r (Some (Ghost.reveal y)) (Some (Ghost.reveal x));
+  un_addr_of_y p r (some (Ghost.reveal y)) (some (Ghost.reveal x));
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
+(*
 /// Example 2: pointers to nested fields
 ///
 /// Here's a struct representing a line segment by its two endpoints:
@@ -326,38 +227,38 @@ let reflect_and_reverse
 : SteelT unit
     (p `pts_to`
       mk_line
-        (mk_point (Some (Ghost.reveal x1)) (Some (Ghost.reveal y1)))
-        (mk_point (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2))))
+        (mk_point (some (Ghost.reveal x1)) (some (Ghost.reveal y1)))
+        (mk_point (some (Ghost.reveal x2)) (some (Ghost.reveal y2))))
     (fun _ ->
       p `pts_to`
         mk_line
-          (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
-          (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1))))
+          (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
+          (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1))))
 = (* Take all the requisite pointers *)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   let pp1 =
     addr_of_p1 p
-      (mk_point (Some (Ghost.reveal x1)) (Some (Ghost.reveal y1)))
-      (mk_point (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2)))
+      (mk_point (some (Ghost.reveal x1)) (some (Ghost.reveal y1)))
+      (mk_point (some (Ghost.reveal x2)) (some (Ghost.reveal y2)))
   in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   let pp2 =
     addr_of_p2 p
       (one point_pcm)
-      (mk_point (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2)))
+      (mk_point (some (Ghost.reveal x2)) (some (Ghost.reveal y2)))
   in
   (* &p.p1.x *)
   A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  let pp1x = addr_of_x pp1 (Some (Ghost.reveal x1)) (Some (Ghost.reveal y1)) in
+  let pp1x = addr_of_x pp1 (some (Ghost.reveal x1)) (some (Ghost.reveal y1)) in
   (* &p.p1.y *)
   A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  let pp1y = addr_of_y pp1 None (Some (Ghost.reveal y1)) in
+  let pp1y = addr_of_y pp1 none (some (Ghost.reveal y1)) in
   (* &p.p2.x *)
   A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  let pp2x = addr_of_x pp2 (Some (Ghost.reveal x2)) (Some (Ghost.reveal y2)) in
+  let pp2x = addr_of_x pp2 (some (Ghost.reveal x2)) (some (Ghost.reveal y2)) in
   (* &p.p2.y *)
   A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  let pp2y = addr_of_y pp2 None (Some (Ghost.reveal y2)) in
+  let pp2y = addr_of_y pp2 none (some (Ghost.reveal y2)) in
   (* generic_swap(&p.p1.x, &p.p2.y); *)
   generic_swap pp1x pp2y x1 y2;
   (* generic_swap(&p.p1.y, &p.p2.x); *)
@@ -365,26 +266,26 @@ let reflect_and_reverse
   (* Gather p1 *)
   A.change_equal_slprop (pp1x `pts_to` _) (pp1x `pts_to` _);
   A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  un_addr_of_x pp1 pp1x (Some (Ghost.reveal y2)) None;
+  un_addr_of_x pp1 pp1x (some (Ghost.reveal y2)) none;
   A.change_equal_slprop (pp1y `pts_to` _) (pp1y `pts_to` _);
   A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  un_addr_of_y pp1 pp1y (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2));
+  un_addr_of_y pp1 pp1y (some (Ghost.reveal y2)) (some (Ghost.reveal x2));
   (* Gather p2 *)
   A.change_equal_slprop (pp2x `pts_to` _) (pp2x `pts_to` _);
   A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  un_addr_of_x pp2 pp2x (Some (Ghost.reveal y1)) None;
+  un_addr_of_x pp2 pp2x (some (Ghost.reveal y1)) none;
   A.change_equal_slprop (pp2y `pts_to` _) (pp2y `pts_to` _);
   A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  un_addr_of_y pp2 pp2y (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1));
+  un_addr_of_y pp2 pp2y (some (Ghost.reveal y1)) (some (Ghost.reveal x1));
   (* Gather p *)
   A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  un_addr_of_p1 p pp1 (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2))) (one point_pcm);
+  un_addr_of_p1 p pp1 (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2))) (one point_pcm);
   A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   un_addr_of_p2 p pp2
-    (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
-    (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1)));
+    (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
+    (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1)));
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 #pop-options
 
@@ -402,55 +303,55 @@ addr_of
 
   A.change_equal_slprop (pp1x `pts_to` _) (pp1x `pts_to` _);
   A.change_equal_slprop (pp1y `pts_to` _) (pp1y `pts_to` _);
-  unfocus pp1x pp1 (field point_fields_pcm X) (Some (Ghost.reveal y2));
-  unfocus pp1y pp1 (field point_fields_pcm Y) (Some (Ghost.reveal x2));
+  unfocus pp1x pp1 (field point_fields_pcm X) (some (Ghost.reveal y2));
+  unfocus pp1y pp1 (field point_fields_pcm Y) (some (Ghost.reveal x2));
   A.change_equal_slprop
     (pp1 `pts_to` put (field point_fields_pcm X) _ _)
-    (pp1 `pts_to` mk_point (Some (Ghost.reveal y2)) None);
+    (pp1 `pts_to` mk_point (some (Ghost.reveal y2)) none);
   A.change_equal_slprop
     (pp1 `pts_to` put (field point_fields_pcm Y) _ _)
-    (pp1 `pts_to` mk_point None (Some (Ghost.reveal x2)));
-  gather pp1 (mk_point (Some (Ghost.reveal y2)) None) (mk_point None (Some (Ghost.reveal x2)));
-  gather pp1 (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+    (pp1 `pts_to` mk_point none (some (Ghost.reveal x2)));
+  gather pp1 (mk_point (some (Ghost.reveal y2)) none) (mk_point none (some (Ghost.reveal x2)));
+  gather pp1 (mk_point (Ghost.reveal (Ghost.hide none)) none) _;
   (* Gather p2 *)
   A.change_equal_slprop (pp2x `pts_to` _) (pp2x `pts_to` _);
   A.change_equal_slprop (pp2y `pts_to` _) (pp2y `pts_to` _);
-  unfocus pp2x pp2 (field point_fields_pcm X) (Some (Ghost.reveal y1));
-  unfocus pp2y pp2 (field point_fields_pcm Y) (Some (Ghost.reveal x1));
+  unfocus pp2x pp2 (field point_fields_pcm X) (some (Ghost.reveal y1));
+  unfocus pp2y pp2 (field point_fields_pcm Y) (some (Ghost.reveal x1));
   A.change_equal_slprop
     (pp2 `pts_to` put (field point_fields_pcm X) _ _)
-    (pp2 `pts_to` mk_point (Some (Ghost.reveal y1)) None);
+    (pp2 `pts_to` mk_point (some (Ghost.reveal y1)) none);
   A.change_equal_slprop
     (pp2 `pts_to` put (field point_fields_pcm Y) _ _)
-    (pp2 `pts_to` mk_point None (Some (Ghost.reveal x1)));
-  gather pp2 (mk_point (Some (Ghost.reveal y1)) None) (mk_point None (Some (Ghost.reveal x1)));
-  gather pp2 (mk_point (Ghost.reveal (Ghost.hide None)) None) _;
+    (pp2 `pts_to` mk_point none (some (Ghost.reveal x1)));
+  gather pp2 (mk_point (some (Ghost.reveal y1)) none) (mk_point none (some (Ghost.reveal x1)));
+  gather pp2 (mk_point (Ghost.reveal (Ghost.hide none)) none) _;
   (* Gather p *)
   A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
   A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
   unfocus pp1 p (field line_fields_pcm P1)
-    (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)));
+    (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)));
   unfocus pp2 p (field line_fields_pcm P2)
-    (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1)));
+    (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1)));
   A.change_equal_slprop
     (p `pts_to` put (field line_fields_pcm P1) _ _)
     (p `pts_to`
       mk_line
-        (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
+        (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
         (one point_pcm));
   A.change_equal_slprop
     (p `pts_to` put (field line_fields_pcm P2) _ _)
     (p `pts_to`
       mk_line
         (one point_pcm)
-        (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1))));
+        (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1))));
   gather p
     (mk_line
-      (mk_point (Some (Ghost.reveal y2)) (Some (Ghost.reveal x2)))
+      (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
       (one point_pcm))
     (mk_line
        (one point_pcm)
-       (mk_point (Some (Ghost.reveal y1)) (Some (Ghost.reveal x1))));
+       (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1))));
   gather p (mk_line (Ghost.reveal (Ghost.hide (one point_pcm))) (one point_pcm)) _;
   //A.change_equal_slprop (pp2 `pts_to` _) _;
   (* int *r = &p.p1.y; *)
@@ -526,14 +427,14 @@ let swap (p: ref 'a point{p.q == point_pcm}) (xy: Ghost.erased int)
 
 let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
-    (to_vprop (p `pts_to` mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y))))
-    (fun _ -> to_vprop (p `pts_to` mk_point (Some (Ghost.reveal y)) (Some (Ghost.reveal x))))
+    (to_vprop (p `pts_to` mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y))))
+    (fun _ -> to_vprop (p `pts_to` mk_point (some (Ghost.reveal y)) (some (Ghost.reveal x))))
 = let q =
     addr_of_lens p int_pcm (field point_fields_pcm X)
-      (mk_point (Some (Ghost.reveal x)) (Some (Ghost.reveal y))) in
+      (mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y))) in
   A.slassert (
-    to_vprop (p `pts_to` mk_point None (Some (Ghost.reveal y))) `star`
-    to_vprop (q `pts_to` Some (Ghost.reveal x)));
+    to_vprop (p `pts_to` mk_point none (some (Ghost.reveal y))) `star`
+    to_vprop (q `pts_to` some (Ghost.reveal x)));
   A.sladmit ();
   A.return ()
 *)
@@ -614,3 +515,5 @@ let color_pcm_cases k : pcm (color_cases k) = match k with
   | RGB -> rgb_pcm
   | HSV -> hsv_pcm
 let color_pcm : pcm color_t = union_pcm color_pcm_cases
+
+*)
diff --git a/examples/steel/PCM.POD.fst b/examples/steel/PCM.POD.fst
new file mode 100644
index 00000000000..03c837e0ebe
--- /dev/null
+++ b/examples/steel/PCM.POD.fst
@@ -0,0 +1,16 @@
+module PCM.POD
+
+let pod a = option a
+
+let none = None
+let some = Some
+let is_some v = match v with Some _ -> True | None -> False
+let some_v (Some v) = v
+
+let pod_pcm a = Aggregates.opt_pcm #a
+
+let none_is_unit a = ()
+let is_some_some v = ()
+let some_none_distinct v = ()
+let some_compatible v w = ()
+let some_valid_write v w = ()
diff --git a/examples/steel/PCM.POD.fsti b/examples/steel/PCM.POD.fsti
new file mode 100644
index 00000000000..d7bfc524eba
--- /dev/null
+++ b/examples/steel/PCM.POD.fsti
@@ -0,0 +1,29 @@
+module PCM.POD
+
+open FStar.PCM
+
+val pod: Type u#a -> Type u#a
+val none: pod 'a
+val some: 'a -> pod 'a
+
+val is_some: pod 'a -> prop
+val some_v: x:pod 'a{is_some x} -> y:'a{x == some y}
+
+val pod_pcm (a:Type): AggregateRef.refined_one_pcm (pod a)
+
+val none_is_unit (a:Type): Lemma (none == one (pod_pcm a)) [SMTPat (one (pod_pcm a))]
+
+val is_some_some (v:'a): Lemma (is_some (some v)) [SMTPat (some v)]
+
+val some_none_distinct (v:pod 'a)
+: Lemma (requires is_some v) (ensures ~ (v == none)) [SMTPat (is_some v)]
+
+val some_compatible (v w:pod 'a)
+: Lemma (requires compatible (pod_pcm 'a) v w /\ is_some v) (ensures is_some w)
+  [SMTPat (compatible (pod_pcm 'a) v w); SMTPat (is_some v)]
+  
+val some_valid_write (v w: pod 'a)
+: Lemma
+    (requires is_some v /\ is_some w)
+    (ensures AggregateRef.valid_write (pod_pcm 'a) v w)
+  [SMTPat (is_some v); SMTPat (is_some w)]
diff --git a/examples/steel/PointStruct.fst b/examples/steel/PointStruct.fst
new file mode 100644
index 00000000000..2981b22458a
--- /dev/null
+++ b/examples/steel/PointStruct.fst
@@ -0,0 +1,103 @@
+module PointStruct
+
+open Aggregates
+open AggregateRef
+open PCM.POD
+open FStar.PCM
+open FStar.FunctionalExtensionality
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+type point_field = | X | Y
+let point_fields k = match k with
+  | X -> pod int
+  | Y -> pod int
+let point = restricted_t point_field point_fields
+
+let point_fields_pcm k : pcm (point_fields k) = match k with
+  | X -> pod_pcm int
+  | Y -> pod_pcm int
+let point_pcm = prod_pcm point_fields_pcm
+
+let mk_point_f (x y: pod int) (k: point_field): point_fields k = match k with
+  | X -> x
+  | Y -> y
+let mk_point (x y: pod int): point = on_domain point_field (mk_point_f x y)
+
+let _x = field point_fields_pcm X
+let _y = field point_fields_pcm Y
+
+let put_x x' x y
+: Lemma (feq (put _x x' (mk_point x y)) (mk_point x' y))
+  [SMTPat (put _x x' (mk_point x y))]
+= ()
+
+let get_x x y
+: Lemma (get _x (mk_point x y) == x)
+  [SMTPat (get _x (mk_point x y))]
+= ()
+
+let put_y y' x y
+: Lemma (feq (put _y y' (mk_point x y)) (mk_point x y'))
+  [SMTPat (put _y y' (mk_point x y))]
+= ()
+
+let get_y x y
+: Lemma (get _y (mk_point x y) == y)
+  [SMTPat (get _y (mk_point x y))]
+= ()
+
+/// Laws relating mk_point to PCM operations
+
+let one_xy : squash (feq (one point_pcm) (mk_point none none))
+= ()
+
+let merge_xy x y x' y'
+: Lemma (feq (op point_pcm (mk_point x y) (mk_point x' y'))
+             (mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y')))
+  [SMTPat (op point_pcm (mk_point x y) (mk_point x' y'))]
+= ()
+
+/// Taking pointers to the x and y fields of a point
+
+let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
+    (p `pts_to` mk_point x y)
+    (fun q ->
+       (p `pts_to` mk_point none y) `star`
+       (q `pts_to` x))
+= let q = addr_of_lens p _x (mk_point x y) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
+  A.return q
+
+let un_addr_of_x
+  (p: ref 'a point{p.q == point_pcm})
+  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
+  (x y: Ghost.erased (pod int))
+: SteelT unit
+    ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
+    (fun q -> p `pts_to` mk_point x y)
+= un_addr_of_lens q p _x (mk_point none y) x;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
+    (p `pts_to` mk_point x y)
+    (fun q ->
+       (p `pts_to` mk_point x none) `star`
+       (q `pts_to` y))
+= let q = addr_of_lens p _y (mk_point x y) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
+  A.return q
+
+let un_addr_of_y
+  (p: ref 'a point{p.q == point_pcm})
+  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
+  (x y: Ghost.erased (pod int))
+: SteelT unit
+    ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
+    (fun q -> p `pts_to` mk_point x y)
+= un_addr_of_lens q p _y (mk_point x none) y;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/PointStruct.fsti
new file mode 100644
index 00000000000..1be45972ce8
--- /dev/null
+++ b/examples/steel/PointStruct.fsti
@@ -0,0 +1,92 @@
+module PointStruct
+
+open Aggregates
+open AggregateRef
+open PCM.POD
+open FStar.PCM
+//open FStar.FunctionalExtensionality
+open Steel.Effect
+//module A = Steel.Effect.Atomic
+
+/// Suppose we have the following struct representing 2d points:
+///   struct point { int x, y; };
+///
+/// Carrier of PCM for struct point:
+
+val point : Type0
+
+/// PCM for struct point:
+
+val point_pcm : pcm point
+
+/// (mk_point x y) represents (struct point){.x = x, .y = y}
+
+val mk_point (x y: pod int): point
+
+/// PCM lenses for the fields of a point
+
+val _x : pcm_lens point_pcm (pod_pcm int)
+val _y : pcm_lens point_pcm (pod_pcm int)
+
+(*
+/// Laws relating _x, _y, and mk_point
+
+val point_put_x (x' x y: pod int)
+: Lemma (put _x x' (mk_point x y) == mk_point x' y)
+  [SMTPat (put _x x' (mk_point x y))]
+
+val point_get_x (x y: pod int)
+: Lemma (get _x (mk_point x y) == x)
+  [SMTPat (get _x (mk_point x y))]
+
+val point_put_y (y' x y: pod int)
+: Lemma (put _y y' (mk_point x y) == mk_point x y')
+  [SMTPat (put _y y' (mk_point x y))]
+
+val point_get_y (x y: pod int)
+: Lemma (get _y (mk_point x y) == y)
+  [SMTPat (get _y (mk_point x y))]
+
+/// Laws relating mk_point to PCM operations
+
+val point_one : squash (one point_pcm == mk_point none none)
+
+val point_op (x y x' y': pod int)
+: Lemma
+    (requires composable (pod_pcm int) x x' /\ composable (pod_pcm int) y y')
+    (ensures composable point_pcm (mk_point x y) (mk_point x' y') /\
+     op point_pcm (mk_point x y) (mk_point x' y') == mk_point (op (pod_pcm int) x x') (op (pod_pcm int) y y'))
+  [SMTPat (op point_pcm (mk_point x y) (mk_point x' y'))]
+*)
+
+/// Taking pointers to the x and y fields of a point
+
+val addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
+    (p `pts_to` mk_point x y)
+    (fun q ->
+       (p `pts_to` mk_point none y) `star`
+       (q `pts_to` x))
+
+val un_addr_of_x
+  (p: ref 'a point{p.q == point_pcm})
+  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
+  (x y: Ghost.erased (pod int))
+: SteelT unit
+    ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
+    (fun q -> p `pts_to` mk_point x y)
+
+val addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
+    (p `pts_to` mk_point x y)
+    (fun q ->
+       (p `pts_to` mk_point x none) `star`
+       (q `pts_to` y))
+
+val un_addr_of_y
+  (p: ref 'a point{p.q == point_pcm})
+  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
+  (x y: Ghost.erased (pod int))
+: SteelT unit
+    ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
+    (fun q -> p `pts_to` mk_point x y)

From bebc0fe7f6f9ef75e48c47f8a7f168c58b8356bc Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 09:07:23 -0700
Subject: [PATCH 058/513] Tidy

---
 examples/steel/PointStruct.fst  | 10 ----------
 examples/steel/PointStruct.fsti | 33 ---------------------------------
 2 files changed, 43 deletions(-)

diff --git a/examples/steel/PointStruct.fst b/examples/steel/PointStruct.fst
index 2981b22458a..eb9dd85f57f 100644
--- a/examples/steel/PointStruct.fst
+++ b/examples/steel/PointStruct.fst
@@ -32,21 +32,11 @@ let put_x x' x y
   [SMTPat (put _x x' (mk_point x y))]
 = ()
 
-let get_x x y
-: Lemma (get _x (mk_point x y) == x)
-  [SMTPat (get _x (mk_point x y))]
-= ()
-
 let put_y y' x y
 : Lemma (feq (put _y y' (mk_point x y)) (mk_point x y'))
   [SMTPat (put _y y' (mk_point x y))]
 = ()
 
-let get_y x y
-: Lemma (get _y (mk_point x y) == y)
-  [SMTPat (get _y (mk_point x y))]
-= ()
-
 /// Laws relating mk_point to PCM operations
 
 let one_xy : squash (feq (one point_pcm) (mk_point none none))
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/PointStruct.fsti
index 1be45972ce8..7d3d1ab5700 100644
--- a/examples/steel/PointStruct.fsti
+++ b/examples/steel/PointStruct.fsti
@@ -4,9 +4,7 @@ open Aggregates
 open AggregateRef
 open PCM.POD
 open FStar.PCM
-//open FStar.FunctionalExtensionality
 open Steel.Effect
-//module A = Steel.Effect.Atomic
 
 /// Suppose we have the following struct representing 2d points:
 ///   struct point { int x, y; };
@@ -28,37 +26,6 @@ val mk_point (x y: pod int): point
 val _x : pcm_lens point_pcm (pod_pcm int)
 val _y : pcm_lens point_pcm (pod_pcm int)
 
-(*
-/// Laws relating _x, _y, and mk_point
-
-val point_put_x (x' x y: pod int)
-: Lemma (put _x x' (mk_point x y) == mk_point x' y)
-  [SMTPat (put _x x' (mk_point x y))]
-
-val point_get_x (x y: pod int)
-: Lemma (get _x (mk_point x y) == x)
-  [SMTPat (get _x (mk_point x y))]
-
-val point_put_y (y' x y: pod int)
-: Lemma (put _y y' (mk_point x y) == mk_point x y')
-  [SMTPat (put _y y' (mk_point x y))]
-
-val point_get_y (x y: pod int)
-: Lemma (get _y (mk_point x y) == y)
-  [SMTPat (get _y (mk_point x y))]
-
-/// Laws relating mk_point to PCM operations
-
-val point_one : squash (one point_pcm == mk_point none none)
-
-val point_op (x y x' y': pod int)
-: Lemma
-    (requires composable (pod_pcm int) x x' /\ composable (pod_pcm int) y y')
-    (ensures composable point_pcm (mk_point x y) (mk_point x' y') /\
-     op point_pcm (mk_point x y) (mk_point x' y') == mk_point (op (pod_pcm int) x x') (op (pod_pcm int) y y'))
-  [SMTPat (op point_pcm (mk_point x y) (mk_point x' y'))]
-*)
-
 /// Taking pointers to the x and y fields of a point
 
 val addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))

From 3c87adee41de38d9bdd9a87de7daec61dcde1674 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 09:59:22 -0700
Subject: [PATCH 059/513] Explain subtlety with ref_read

---
 examples/steel/AggregateRef.fsti | 63 +++++++++++++++++---------------
 1 file changed, 34 insertions(+), 29 deletions(-)

diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
index 1a13430bf65..21840bf153f 100644
--- a/examples/steel/AggregateRef.fsti
+++ b/examples/steel/AggregateRef.fsti
@@ -478,37 +478,42 @@ val unrefine
     (fun _ -> r == ref_refine r' re u)
     (fun _ _ _ -> True)
 
-(*
-
-describe this situation:
-
-  thread 1: pointer to p.x
-  
-  thread 2: pointer to p but with permissions {None, y}
-  
-  *p a value compatible with {None, y}
-  i.e., any {x, y} for any x
-  x could be:
-    Some z for a garbage z, or
-    None
-
-  but, impossible to work with p->x:
-    *p = {x, y}
-    ( *p).x == 0
-    need {x, y}.x is Some v
-    if (( *p).x == 0) { .. } else { .. }
+(** Generic read.
+
+    Without the precondition ~ (x == one), it would be possible to read
+    a completely uninformative value from a reference. This is safe
+    from the model's standpoint (we can't learn anything from this value),
+    but would extract to a potentially unsafe pointer dereference in C.
+
+    For example, here's a use-after-free:
+        {p `pts_to` x}
+      split
+        {(p `pts_to` x) `star` (p `pts_to` one)}
+      free p
+        {p `pts_to` one}
+      read p
+
+    Even with ~ (x == one), it's possible that x represents partial information
+    about the value at r (for example, a tuple (one, z) representing a struct
+    with permission to read/write from the second field only). But we should be
+    safe as long as the carrier types of the PCMs involved are abstract.
     
-  {None, y} compatible with {vx, vy} 
-  let vx = ref_read &p->x in
-  match vx with None -> .. | Some x -> ..
-
-  {None, y} compatible with {vx, vy} 
-  let vx = ref_read &p->x in
-  let bad = (f : option int -> option int) vx in
-
-  could prevent pattern matching if option int were an abstract type
+    For example, suppose
+      thread 1 has (p `pts_to` (y, one))
+      thread 2 has (p `pts_to` (one, z))
+    and thread 1 writes to p->fst while thread 2 performs the read (v, w) = *p.
+    
+    In this situation, we can't allow thread 2 to dereference (&q.fst),
+    as then it'd be reading from a location while thread 1 is writing to it.
 
-*)
+    Thread 2 can construct the pointer (&q.fst) just fine, but in
+    order to dereference it, it needs to call ref_read, and ref_read
+    requires that (&q.fst) point to a non-unit value (i.e., that ~ (v == one)).
+    
+    If v's type is suitably abstract, so that it's not possible to
+    test v against the unit of its corresponding PCM, then there's no
+    way to prove this precondition and we are safe from reading v
+    as thread 1 is writing to it. *)
 val ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
 : Steel 'b
     (r `pts_to` x)

From 6d1e56b6c9a2e1c4abc7161eb0510f0b505f98b8 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 12:54:56 -0700
Subject: [PATCH 060/513] Get rid of nested reveal/hide and most
 change_equal_slprops

---
 examples/steel/AggregateRef.fst         |  3 ++
 examples/steel/AggregateRef.fsti        |  6 +--
 examples/steel/AggregateRefExamples.fst | 56 +++++++++----------------
 examples/steel/PCM.POD.fst              | 10 ++---
 examples/steel/PCM.POD.fsti             | 15 +++----
 examples/steel/PointStruct.fst          | 23 ++++++----
 examples/steel/PointStruct.fsti         |  2 +-
 7 files changed, 54 insertions(+), 61 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index a5081f21961..6539cfab4b7 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -215,6 +215,9 @@ let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_p
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
+let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
+  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
+
 (** Refining a pcm_lens *)
 
 let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
index 21840bf153f..bb4887be51d 100644
--- a/examples/steel/AggregateRef.fsti
+++ b/examples/steel/AggregateRef.fsti
@@ -207,7 +207,7 @@ let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
-noeq type ref (a:Type) (b:Type): Type = {
+noeq type ref (a:Type u#a) (b:Type u#b): Type = {
   p: refined_one_pcm a;
   re: pcm_refinement p;
   (** Needed to turn frame-preserving updates on (refined_pcm re) into
@@ -223,9 +223,7 @@ open Steel.Effect
 
 let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
 
-(* TODO for some reason, run into universe issues if make this abstract *)
-let pts_to (r: ref 'a 'b) (v: Ghost.erased 'b): vprop = (* TODO unerase v, try [@@@smt_fallback] *)
-  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
+val pts_to (#a: Type u#1) (#b: Type u#b) (r: ref a b) (v: Ghost.erased b): vprop
 
 (** A lens for the k-th field of an n-ary product *)
 
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index 8b06c9e1a26..46d3f61399b 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -25,28 +25,22 @@ open PCM.POD
 
 let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
-    (p `pts_to` mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y)))
-    (fun _ -> p `pts_to` mk_point (some (Ghost.reveal y)) (some (Ghost.reveal x)))
+    (p `pts_to` mk_point (some x) (some y))
+    (fun _ -> p `pts_to` mk_point (some y) (some x))
 = (* int *q = &p.x; *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let q = addr_of_x p (some (Ghost.reveal x)) (some (Ghost.reveal y)) in
+  let q = addr_of_x p (some x) (some y) in
   (* int *r = &p.y; *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let r = addr_of_y p none (some (Ghost.reveal y)) in
+  let r = addr_of_y p none (some y) in
   (* tmp = *q; *)
-  let tmp = ref_read q (some (Ghost.reveal x)) in
+  let tmp = ref_read q (some x) in
   (* *q = *r; *)
-  let vy = ref_read r (some (Ghost.reveal y)) in
+  let vy = ref_read r (some y) in
   ref_write q _ vy;
   (* *r = tmp; *)
   ref_write r _ tmp;
   (* Gather *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  un_addr_of_x p q vy none;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  un_addr_of_y p r vy tmp;
+  un_addr_of_x p q (Ghost.hide vy) none;
+  un_addr_of_y p r (Ghost.hide vy) (Ghost.hide tmp);
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 /// We can also implement swap generically:
@@ -61,16 +55,12 @@ let generic_swap
   (p:ref 'a (pod 'c){p.q == pod_pcm 'c})
   (q:ref 'b (pod 'c){q.q == pod_pcm 'c})
   (x y: Ghost.erased 'c)
-: SteelT unit
-    ((p `pts_to` some (Ghost.reveal x)) `star`
-     (q `pts_to` some (Ghost.reveal y)))
-    (fun _ ->
-     (p `pts_to` some (Ghost.reveal y)) `star`
-     (q `pts_to` some (Ghost.reveal x)))
+: SteelT unit ((p `pts_to` some x) `star` (q `pts_to` some y))
+    (fun _ -> (p `pts_to` some y) `star` (q `pts_to` some x))
 = (* A tmp = *p; *)
-  let tmp = ref_read p (some (Ghost.reveal x)) in
+  let tmp = ref_read p (some x) in
   (* *p = *q; *)
-  let vy = ref_read q (some (Ghost.reveal y)) in
+  let vy = ref_read q (some y) in
   ref_write p _ vy;
   (* *q = tmp *)
   ref_write q _ tmp;
@@ -88,25 +78,17 @@ let generic_swap
 let point_swap_generically
   (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 : SteelT unit
-    (p `pts_to` mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y)))
-    (fun _ -> p `pts_to` mk_point (some (Ghost.reveal y)) (some (Ghost.reveal x)))
+    (p `pts_to` mk_point (some x) (some y))
+    (fun _ -> p `pts_to` mk_point (some y) (some x))
 = (* int *q = &p.x; *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let q = addr_of_x p (some (Ghost.reveal x)) (some (Ghost.reveal y)) in
+  let q = addr_of_x p (some x) (some y) in
   (* int *r = &p.y; *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let r = addr_of_y p none (some (Ghost.reveal y)) in
+  let r = addr_of_y p none (some y) in
   (* generic_swap(q, r); *)
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  generic_swap q r (Ghost.reveal x) (Ghost.reveal y);
+  generic_swap q r x y;
   (* Gather *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  un_addr_of_x p q (some (Ghost.reveal y)) none;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  un_addr_of_y p r (some (Ghost.reveal y)) (some (Ghost.reveal x));
+  un_addr_of_x p q (some y) none;
+  un_addr_of_y p r (some y) (some x);
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 (*
diff --git a/examples/steel/PCM.POD.fst b/examples/steel/PCM.POD.fst
index 03c837e0ebe..22aeecdc019 100644
--- a/examples/steel/PCM.POD.fst
+++ b/examples/steel/PCM.POD.fst
@@ -1,11 +1,11 @@
 module PCM.POD
 
-let pod a = option a
+let pod a = Ghost.erased (option a)
 
-let none = None
-let some = Some
-let is_some v = match v with Some _ -> True | None -> False
-let some_v (Some v) = v
+let none #a = Ghost.hide (None #a)
+let some x = Ghost.hide (Some x)
+let is_some v = match Ghost.reveal v with Some _ -> True | None -> False
+let some_v x = match x with Some v -> v
 
 let pod_pcm a = Aggregates.opt_pcm #a
 
diff --git a/examples/steel/PCM.POD.fsti b/examples/steel/PCM.POD.fsti
index d7bfc524eba..b527479063b 100644
--- a/examples/steel/PCM.POD.fsti
+++ b/examples/steel/PCM.POD.fsti
@@ -3,20 +3,21 @@ module PCM.POD
 open FStar.PCM
 
 val pod: Type u#a -> Type u#a
-val none: pod 'a
-val some: 'a -> pod 'a
 
-val is_some: pod 'a -> prop
-val some_v: x:pod 'a{is_some x} -> y:'a{x == some y}
+val none: Ghost.erased (pod 'a)
+val some: Ghost.erased 'a -> Ghost.erased (pod 'a)
+
+val is_some: Ghost.erased (pod 'a) -> prop
+val some_v: x:pod 'a{is_some x} -> GTot (y:'a{x == Ghost.reveal (some y)})
 
 val pod_pcm (a:Type): AggregateRef.refined_one_pcm (pod a)
 
-val none_is_unit (a:Type): Lemma (none == one (pod_pcm a)) [SMTPat (one (pod_pcm a))]
+val none_is_unit (a:Type): Lemma (Ghost.reveal none == one (pod_pcm a)) [SMTPat (one (pod_pcm a))]
 
-val is_some_some (v:'a): Lemma (is_some (some v)) [SMTPat (some v)]
+val is_some_some (v:Ghost.erased 'a): Lemma (is_some (some v)) [SMTPat (some v)]
 
 val some_none_distinct (v:pod 'a)
-: Lemma (requires is_some v) (ensures ~ (v == none)) [SMTPat (is_some v)]
+: Lemma (requires is_some v) (ensures ~ (v == Ghost.reveal none)) [SMTPat (is_some v)]
 
 val some_compatible (v w:pod 'a)
 : Lemma (requires compatible (pod_pcm 'a) v w /\ is_some v) (ensures is_some w)
diff --git a/examples/steel/PointStruct.fst b/examples/steel/PointStruct.fst
index eb9dd85f57f..a75a7ef5488 100644
--- a/examples/steel/PointStruct.fst
+++ b/examples/steel/PointStruct.fst
@@ -22,18 +22,20 @@ let point_pcm = prod_pcm point_fields_pcm
 let mk_point_f (x y: pod int) (k: point_field): point_fields k = match k with
   | X -> x
   | Y -> y
-let mk_point (x y: pod int): point = on_domain point_field (mk_point_f x y)
+  
+let mk_point (x y: Ghost.erased (pod int)): GTot point =
+  on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y))
 
 let _x = field point_fields_pcm X
 let _y = field point_fields_pcm Y
 
 let put_x x' x y
-: Lemma (feq (put _x x' (mk_point x y)) (mk_point x' y))
+: Lemma (feq (put _x x' (mk_point x y)) (mk_point (Ghost.hide x') y))
   [SMTPat (put _x x' (mk_point x y))]
 = ()
 
 let put_y y' x y
-: Lemma (feq (put _y y' (mk_point x y)) (mk_point x y'))
+: Lemma (feq (put _y y' (mk_point x y)) (mk_point x (Ghost.hide y')))
   [SMTPat (put _y y' (mk_point x y))]
 = ()
 
@@ -42,10 +44,17 @@ let put_y y' x y
 let one_xy : squash (feq (one point_pcm) (mk_point none none))
 = ()
 
-let merge_xy x y x' y'
-: Lemma (feq (op point_pcm (mk_point x y) (mk_point x' y'))
-             (mk_point (op (point_fields_pcm X) x x') (op (point_fields_pcm Y) y y')))
-  [SMTPat (op point_pcm (mk_point x y) (mk_point x' y'))]
+// TODO
+let merge_xy (x y: Ghost.erased (pod int)) x' y'
+: Lemma
+    (requires composable point_pcm
+       (Ghost.reveal (mk_point x y))
+       (Ghost.reveal (mk_point x' y')))
+    (ensures
+     feq (op point_pcm (Ghost.reveal (mk_point x y)) (Ghost.reveal (mk_point x' y')))
+         (mk_point (op (point_fields_pcm X) (Ghost.reveal x) (Ghost.reveal x'))
+                   (op (point_fields_pcm Y) (Ghost.reveal y) (Ghost.reveal y'))))
+  [SMTPat (op point_pcm (Ghost.reveal (mk_point x y)) (Ghost.reveal (mk_point x' y')))]
 = ()
 
 /// Taking pointers to the x and y fields of a point
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/PointStruct.fsti
index 7d3d1ab5700..c4ca2693827 100644
--- a/examples/steel/PointStruct.fsti
+++ b/examples/steel/PointStruct.fsti
@@ -19,7 +19,7 @@ val point_pcm : pcm point
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
 
-val mk_point (x y: pod int): point
+val mk_point (x y: Ghost.erased (pod int)): Ghost.erased point
 
 /// PCM lenses for the fields of a point
 

From a34b9b2e10a36aedd8d7801aa46c4971342a4fea Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 13:09:08 -0700
Subject: [PATCH 061/513] Nice implicits for read, write, addr_of_*,
 un_addr_of_*

---
 examples/steel/AggregateRef.fst         | 21 ++++++-------
 examples/steel/AggregateRef.fsti        |  4 +--
 examples/steel/AggregateRefExamples.fst | 39 +++++++++++++------------
 examples/steel/PointStruct.fst          |  8 ++---
 examples/steel/PointStruct.fsti         |  8 ++---
 5 files changed, 41 insertions(+), 39 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 6539cfab4b7..b9962574ab0 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -640,14 +640,15 @@ let refine r re u x =
 let unrefine #inames r' re u r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
-let ref_read r x =
-  let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
-  let v = Steel.PCMReference.read r.r x' in
-  pcm_refinement_compatible_closed r.re x' v;
-  pcm_lens_compatible_get r.pl x' v;
-  A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
-  A.return (get r.pl v)
+let ref_read #x r =
+  A.return (admit())
+  //let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+  //A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
+  //let v = Steel.PCMReference.read r.r x' in
+  //pcm_refinement_compatible_closed r.re x' v;
+  //pcm_lens_compatible_get r.pl x' v;
+  //A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
+  //A.return (get r.pl v)
 
 let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   (f: ('b -> 'b){frame_pres r.q f x y})
@@ -690,11 +691,11 @@ let frame_preserving_upd_valid_write (p: pcm 'a)
     in FStar.Classical.forall_intro aux);
   f
 
-let ref_write (r: ref 'a 'b) (x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
+let ref_write (r: ref 'a 'b) (#x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 = ref_upd r x y (frame_preserving_upd_valid_write r.q x y)
 
 (* From ref_write, can derive the expected write for all-or-none PCM *)
 let ref_write_opt_pcm (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
 : SteelT unit (r `pts_to` Some (Ghost.reveal x)) (fun _ -> r `pts_to` Some y)
-= ref_write r (Some (Ghost.reveal x)) (Some y)
+= ref_write r #(Some (Ghost.reveal x)) (Some y)
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
index bb4887be51d..dd207360c5c 100644
--- a/examples/steel/AggregateRef.fsti
+++ b/examples/steel/AggregateRef.fsti
@@ -512,7 +512,7 @@ val unrefine
     test v against the unit of its corresponding PCM, then there's no
     way to prove this precondition and we are safe from reading v
     as thread 1 is writing to it. *)
-val ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
+val ref_read (#x: Ghost.erased 'b) (r: ref 'a 'b)
 : Steel 'b
     (r `pts_to` x)
     (fun _ -> r `pts_to` x)
@@ -531,5 +531,5 @@ let valid_write (p:pcm 'a) x y =
   whole_value p x /\ whole_value p y /\
   (forall (frame:'a). composable p x frame ==> composable p y frame)
 
-val ref_write (r: ref 'a 'b) (x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
+val ref_write (r: ref 'a 'b) (#x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index 46d3f61399b..ff9b7e9eda2 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -28,19 +28,19 @@ let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
     (p `pts_to` mk_point (some x) (some y))
     (fun _ -> p `pts_to` mk_point (some y) (some x))
 = (* int *q = &p.x; *)
-  let q = addr_of_x p (some x) (some y) in
+  let q = addr_of_x p in
   (* int *r = &p.y; *)
-  let r = addr_of_y p none (some y) in
+  let r = addr_of_y p in
   (* tmp = *q; *)
-  let tmp = ref_read q (some x) in
+  let tmp = ref_read q in
   (* *q = *r; *)
-  let vy = ref_read r (some y) in
-  ref_write q _ vy;
+  let vy = ref_read r in
+  ref_write q vy;
   (* *r = tmp; *)
-  ref_write r _ tmp;
+  ref_write r tmp;
   (* Gather *)
-  un_addr_of_x p q (Ghost.hide vy) none;
-  un_addr_of_y p r (Ghost.hide vy) (Ghost.hide tmp);
+  un_addr_of_x p q;
+  un_addr_of_y p r;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 /// We can also implement swap generically:
@@ -52,18 +52,18 @@ let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 /// }
 
 let generic_swap
+  (#x #y: Ghost.erased 'c)
   (p:ref 'a (pod 'c){p.q == pod_pcm 'c})
   (q:ref 'b (pod 'c){q.q == pod_pcm 'c})
-  (x y: Ghost.erased 'c)
 : SteelT unit ((p `pts_to` some x) `star` (q `pts_to` some y))
     (fun _ -> (p `pts_to` some y) `star` (q `pts_to` some x))
 = (* A tmp = *p; *)
-  let tmp = ref_read p (some x) in
+  let tmp = ref_read p in
   (* *p = *q; *)
-  let vy = ref_read q (some y) in
-  ref_write p _ vy;
+  let vy = ref_read q in
+  ref_write p vy;
   (* *q = tmp *)
-  ref_write q _ tmp;
+  ref_write q tmp;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` _)
 
@@ -76,19 +76,20 @@ let generic_swap
 /// }
 
 let point_swap_generically
-  (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
+  (#x #y: Ghost.erased int)
+  (p: ref 'a point{p.q == point_pcm})
 : SteelT unit
     (p `pts_to` mk_point (some x) (some y))
     (fun _ -> p `pts_to` mk_point (some y) (some x))
 = (* int *q = &p.x; *)
-  let q = addr_of_x p (some x) (some y) in
+  let q = addr_of_x p in
   (* int *r = &p.y; *)
-  let r = addr_of_y p none (some y) in
+  let r = addr_of_y p in
   (* generic_swap(q, r); *)
-  generic_swap q r x y;
+  generic_swap q r;
   (* Gather *)
-  un_addr_of_x p q (some y) none;
-  un_addr_of_y p r (some y) (some x);
+  un_addr_of_x p q;
+  un_addr_of_y p r;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 (*
diff --git a/examples/steel/PointStruct.fst b/examples/steel/PointStruct.fst
index a75a7ef5488..12140e98ef5 100644
--- a/examples/steel/PointStruct.fst
+++ b/examples/steel/PointStruct.fst
@@ -59,7 +59,7 @@ let merge_xy (x y: Ghost.erased (pod int)) x' y'
 
 /// Taking pointers to the x and y fields of a point
 
-let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+let addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
 : SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
     (p `pts_to` mk_point x y)
     (fun q ->
@@ -71,16 +71,16 @@ let addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
   A.return q
 
 let un_addr_of_x
+  (#x #y: Ghost.erased (pod int))
   (p: ref 'a point{p.q == point_pcm})
   (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
-  (x y: Ghost.erased (pod int))
 : SteelT unit
     ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
     (fun q -> p `pts_to` mk_point x y)
 = un_addr_of_lens q p _x (mk_point none y) x;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+let addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
 : SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
     (p `pts_to` mk_point x y)
     (fun q ->
@@ -92,9 +92,9 @@ let addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
   A.return q
 
 let un_addr_of_y
+  (#x #y: Ghost.erased (pod int))
   (p: ref 'a point{p.q == point_pcm})
   (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
-  (x y: Ghost.erased (pod int))
 : SteelT unit
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/PointStruct.fsti
index c4ca2693827..8b033b14a73 100644
--- a/examples/steel/PointStruct.fsti
+++ b/examples/steel/PointStruct.fsti
@@ -28,7 +28,7 @@ val _y : pcm_lens point_pcm (pod_pcm int)
 
 /// Taking pointers to the x and y fields of a point
 
-val addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
 : SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
     (p `pts_to` mk_point x y)
     (fun q ->
@@ -36,14 +36,14 @@ val addr_of_x (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
        (q `pts_to` x))
 
 val un_addr_of_x
+  (#x #y: Ghost.erased (pod int))
   (p: ref 'a point{p.q == point_pcm})
   (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
-  (x y: Ghost.erased (pod int))
 : SteelT unit
     ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
     (fun q -> p `pts_to` mk_point x y)
 
-val addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
+val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
 : SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
     (p `pts_to` mk_point x y)
     (fun q ->
@@ -51,9 +51,9 @@ val addr_of_y (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased (pod int))
        (q `pts_to` y))
 
 val un_addr_of_y
+  (#x #y: Ghost.erased (pod int))
   (p: ref 'a point{p.q == point_pcm})
   (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
-  (x y: Ghost.erased (pod int))
 : SteelT unit
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)

From cfe73bc6fbd6429e56b654831b7443ebd8980f89 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 8 Jul 2021 14:49:22 -0700
Subject: [PATCH 062/513] Get reflect_and_reverse working and fix build

---
 examples/steel/AggregateRef.fst             |  25 +-
 examples/steel/AggregateRef.fsti            |   7 +-
 examples/steel/AggregateRefExamples.fst     | 334 ++------------------
 examples/steel/LineStruct.fst               | 100 ++++++
 examples/steel/LineStruct.fsti              |  59 ++++
 examples/steel/PointStruct.fsti             |   2 +-
 ulib/experimental/Steel.HigherReference.fst |   2 +-
 7 files changed, 204 insertions(+), 325 deletions(-)
 create mode 100644 examples/steel/LineStruct.fst
 create mode 100644 examples/steel/LineStruct.fsti

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index b9962574ab0..403a3e38ce5 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -215,6 +215,8 @@ let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_p
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+
 let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
   r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
 
@@ -640,15 +642,20 @@ let refine r re u x =
 let unrefine #inames r' re u r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
-let ref_read #x r =
-  A.return (admit())
-  //let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  //A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
-  //let v = Steel.PCMReference.read r.r x' in
-  //pcm_refinement_compatible_closed r.re x' v;
-  //pcm_lens_compatible_get r.pl x' v;
-  //A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
-  //A.return (get r.pl v)
+let ref_read' (#x: Ghost.erased 'b) (r: ref 'a 'b)
+: Steel 'b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> ~ (Ghost.reveal x == one r.q))
+    (ensures fun _ x' _ -> compatible r.q x x')
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
+  let v = Steel.PCMReference.read r.r x' in
+  pcm_refinement_compatible_closed r.re x' v;
+  pcm_lens_compatible_get r.pl x' v;
+  A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
+  A.return (get r.pl v)
+let ref_read #x r = ref_read' #x r // TODO interestingly, i can't inline ref_read'
 
 let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   (f: ('b -> 'b){frame_pres r.q f x y})
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
index dd207360c5c..80e133343d2 100644
--- a/examples/steel/AggregateRef.fsti
+++ b/examples/steel/AggregateRef.fsti
@@ -221,9 +221,10 @@ noeq type ref (a:Type u#a) (b:Type u#b): Type = {
 
 open Steel.Effect
 
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
-
-val pts_to (#a: Type u#1) (#b: Type u#b) (r: ref a b) (v: Ghost.erased b): vprop
+val pts_to
+  (#a: Type u#1) (#b: Type u#b)
+  (r: ref a b) ([@@@smt_fallback] v: Ghost.erased b)
+: vprop
 
 (** A lens for the k-th field of an n-ary product *)
 
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index ff9b7e9eda2..1099d1107ff 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -1,17 +1,14 @@
 module AggregateRefExamples
 
-open Aggregates
 open AggregateRef
-open FStar.PCM
-open FStar.FunctionalExtensionality
 
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
 /// Example 1: swapping the coordinates of a 2d point
 
-open PointStruct
 open PCM.POD
+open PointStruct
 
 /// We can write the following function that swaps the x and y fields of a given point:
 /// 
@@ -40,8 +37,7 @@ let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
   ref_write r tmp;
   (* Gather *)
   un_addr_of_x p q;
-  un_addr_of_y p r;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+  un_addr_of_y p r
 
 /// We can also implement swap generically:
 ///
@@ -64,8 +60,8 @@ let generic_swap
   ref_write p vy;
   (* *q = tmp *)
   ref_write q tmp;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _)
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+  // seems can't get rid of final change_equal_slprop, even with smt_fallback
 
 /// Now, point_swap written using generic_swap:
 ///
@@ -89,113 +85,7 @@ let point_swap_generically
   generic_swap q r;
   (* Gather *)
   un_addr_of_x p q;
-  un_addr_of_y p r;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-(*
-/// Example 2: pointers to nested fields
-///
-/// Here's a struct representing a line segment by its two endpoints:
-///   struct line { struct point p1; struct point p2; };
-///
-/// Carrier of PCM for line:
-
-type line_field = | P1 | P2
-let line_fields k = match k with
-  | P1 -> point
-  | P2 -> point
-let line = restricted_t line_field line_fields
-
-/// PCM for line:
-
-let line_fields_pcm k : pcm (line_fields k) = match k with
-  | P1 -> point_pcm
-  | P2 -> point_pcm
-let line_pcm = prod_pcm line_fields_pcm
-
-/// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
-
-let mk_line_f (p1 p2: point) (k: line_field): line_fields k = match k with
-  | P1 -> p1
-  | P2 -> p2
-let mk_line (p1 p2: point): line = on_domain line_field (mk_line_f p1 p2)
-
-/// Laws about putting/getting the x and y fields of a (mk_line x y)
-
-let put_p1 p1' p1 p2
-: Lemma (feq (put (field line_fields_pcm P1) p1' (mk_line p1 p2)) (mk_line p1' p2))
-  [SMTPat (put (field line_fields_pcm P1) p1' (mk_line p1 p2))]
-= ()
-
-let get_p1 p1 p2
-: Lemma (get (field line_fields_pcm P1) (mk_line p1 p2) == p1)
-  [SMTPat (get (field line_fields_pcm P1) (mk_line p1 p2))]
-= ()
-
-let put_p2 p2' p1 p2
-: Lemma (feq (put (field line_fields_pcm P2) p2' (mk_line p1 p2)) (mk_line p1 p2'))
-  [SMTPat (put (field line_fields_pcm P2) p2' (mk_line p1 p2))]
-= ()
-
-let get_p2 p1 p2
-: Lemma (get (field line_fields_pcm P2) (mk_line p1 p2) == p2)
-  [SMTPat (get (field line_fields_pcm P2) (mk_line p1 p2))]
-= ()
-
-/// Laws relating mk_line to PCM operations
-
-let one_line : squash (feq (one line_pcm) (mk_line (one point_pcm) (one point_pcm)))
-= ()
-
-let merge_line p1 p2 p1' p2'
-: Lemma (feq (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))
-             (mk_line (op (line_fields_pcm P1) p1 p1') (op (line_fields_pcm P2) p2 p2')))
-  [SMTPat (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))]
-= ()
-
-/// Taking pointers to the p1 and p2 fields of a line
-
-let addr_of_p1 (p: ref 'a line{p.q == line_pcm}) (p1 p2: Ghost.erased point)
-: SteelT (q:ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P1)})
-    (p `pts_to` mk_line p1 p2)
-    (fun q ->
-       (p `pts_to` mk_line (one point_pcm) p2) `star`
-       (q `pts_to` p1))
-= let q = addr_of_lens p (field line_fields_pcm P1) (mk_line p1 p2) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line (one point_pcm) p2);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
-  A.return q
-
-let un_addr_of_p1
-  (p: ref 'a line{p.q == line_pcm})
-  (q: ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P1)})
-  (p1 p2: Ghost.erased point)
-: SteelT unit
-    ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
-    (fun q -> p `pts_to` mk_line p1 p2)
-= un_addr_of_lens q p (field line_fields_pcm P1) (mk_line (one point_pcm) p2) p1;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_p2 (p: ref 'a line{p.q == line_pcm}) (p1 p2: Ghost.erased point)
-: SteelT (q:ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P2)})
-    (p `pts_to` mk_line p1 p2)
-    (fun q ->
-       (p `pts_to` mk_line p1 (one point_pcm)) `star`
-       (q `pts_to` p2))
-= let q = addr_of_lens p (field line_fields_pcm P2) (mk_line p1 p2) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line p1 (one point_pcm));
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
-  A.return q
-
-let un_addr_of_p2
-  (p: ref 'a line{p.q == line_pcm})
-  (q: ref 'a point{q == ref_focus p point_pcm (field line_fields_pcm P2)})
-  (p1 p2: Ghost.erased point)
-: SteelT unit
-    ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
-    (fun q -> p `pts_to` mk_line p1 p2)
-= un_addr_of_lens q p (field line_fields_pcm P2) (mk_line p1 (one point_pcm)) p2;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+  un_addr_of_y p r
 
 /// Reflect a line segment across the line y=x and reverse its direction
 ///
@@ -204,73 +94,32 @@ let un_addr_of_p2
 ///   generic_swap(&p.p1.y, &p.p2.x);
 /// }
 
-#push-options "--z3rlimit 20"
+open LineStruct
+
 let reflect_and_reverse
   (p: ref 'a line{p.q == line_pcm}) (x1 y1 x2 y2: Ghost.erased int)
 : SteelT unit
-    (p `pts_to`
-      mk_line
-        (mk_point (some (Ghost.reveal x1)) (some (Ghost.reveal y1)))
-        (mk_point (some (Ghost.reveal x2)) (some (Ghost.reveal y2))))
-    (fun _ ->
-      p `pts_to`
-        mk_line
-          (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
-          (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1))))
-= (* Take all the requisite pointers *)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let pp1 =
-    addr_of_p1 p
-      (mk_point (some (Ghost.reveal x1)) (some (Ghost.reveal y1)))
-      (mk_point (some (Ghost.reveal x2)) (some (Ghost.reveal y2)))
-  in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  let pp2 =
-    addr_of_p2 p
-      (one point_pcm)
-      (mk_point (some (Ghost.reveal x2)) (some (Ghost.reveal y2)))
-  in
-  (* &p.p1.x *)
-  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  let pp1x = addr_of_x pp1 (some (Ghost.reveal x1)) (some (Ghost.reveal y1)) in
-  (* &p.p1.y *)
-  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  let pp1y = addr_of_y pp1 none (some (Ghost.reveal y1)) in
-  (* &p.p2.x *)
-  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  let pp2x = addr_of_x pp2 (some (Ghost.reveal x2)) (some (Ghost.reveal y2)) in
-  (* &p.p2.y *)
-  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  let pp2y = addr_of_y pp2 none (some (Ghost.reveal y2)) in
-  (* generic_swap(&p.p1.x, &p.p2.y); *)
-  generic_swap pp1x pp2y x1 y2;
+    (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
+    (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
+= (* generic_swap(&p.p1.x, &p.p2.y); *)
+  let pp1 = addr_of_p1 p in
+  let pp1x = addr_of_x pp1 in
+  let pp2 = addr_of_p2 p in
+  let pp2y = addr_of_y pp2 in
+  generic_swap pp1x pp2y;
   (* generic_swap(&p.p1.y, &p.p2.x); *)
-  generic_swap pp1y pp2x y1 x2;
+  let pp1y = addr_of_y pp1 in
+  let pp2x = addr_of_x pp2 in
+  generic_swap pp1y pp2x;
   (* Gather p1 *)
-  A.change_equal_slprop (pp1x `pts_to` _) (pp1x `pts_to` _);
-  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  un_addr_of_x pp1 pp1x (some (Ghost.reveal y2)) none;
-  A.change_equal_slprop (pp1y `pts_to` _) (pp1y `pts_to` _);
-  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  un_addr_of_y pp1 pp1y (some (Ghost.reveal y2)) (some (Ghost.reveal x2));
+  un_addr_of_x pp1 pp1x;
+  un_addr_of_y pp1 pp1y;
   (* Gather p2 *)
-  A.change_equal_slprop (pp2x `pts_to` _) (pp2x `pts_to` _);
-  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  un_addr_of_x pp2 pp2x (some (Ghost.reveal y1)) none;
-  A.change_equal_slprop (pp2y `pts_to` _) (pp2y `pts_to` _);
-  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  un_addr_of_y pp2 pp2y (some (Ghost.reveal y1)) (some (Ghost.reveal x1));
+  un_addr_of_x pp2 pp2x;
+  un_addr_of_y pp2 pp2y;
   (* Gather p *)
-  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  un_addr_of_p1 p pp1 (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2))) (one point_pcm);
-  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  un_addr_of_p1 p pp1;
   un_addr_of_p2 p pp2
-    (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
-    (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1)));
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-#pop-options
 
 (*
 addr_of
@@ -282,69 +131,6 @@ addr_of
   (r `pts_to` xs [k `mapsto` y])
   *)
 
-(*
-
-  A.change_equal_slprop (pp1x `pts_to` _) (pp1x `pts_to` _);
-  A.change_equal_slprop (pp1y `pts_to` _) (pp1y `pts_to` _);
-  unfocus pp1x pp1 (field point_fields_pcm X) (some (Ghost.reveal y2));
-  unfocus pp1y pp1 (field point_fields_pcm Y) (some (Ghost.reveal x2));
-  A.change_equal_slprop
-    (pp1 `pts_to` put (field point_fields_pcm X) _ _)
-    (pp1 `pts_to` mk_point (some (Ghost.reveal y2)) none);
-  A.change_equal_slprop
-    (pp1 `pts_to` put (field point_fields_pcm Y) _ _)
-    (pp1 `pts_to` mk_point none (some (Ghost.reveal x2)));
-  gather pp1 (mk_point (some (Ghost.reveal y2)) none) (mk_point none (some (Ghost.reveal x2)));
-  gather pp1 (mk_point (Ghost.reveal (Ghost.hide none)) none) _;
-  (* Gather p2 *)
-  A.change_equal_slprop (pp2x `pts_to` _) (pp2x `pts_to` _);
-  A.change_equal_slprop (pp2y `pts_to` _) (pp2y `pts_to` _);
-  unfocus pp2x pp2 (field point_fields_pcm X) (some (Ghost.reveal y1));
-  unfocus pp2y pp2 (field point_fields_pcm Y) (some (Ghost.reveal x1));
-  A.change_equal_slprop
-    (pp2 `pts_to` put (field point_fields_pcm X) _ _)
-    (pp2 `pts_to` mk_point (some (Ghost.reveal y1)) none);
-  A.change_equal_slprop
-    (pp2 `pts_to` put (field point_fields_pcm Y) _ _)
-    (pp2 `pts_to` mk_point none (some (Ghost.reveal x1)));
-  gather pp2 (mk_point (some (Ghost.reveal y1)) none) (mk_point none (some (Ghost.reveal x1)));
-  gather pp2 (mk_point (Ghost.reveal (Ghost.hide none)) none) _;
-  (* Gather p *)
-  A.change_equal_slprop (pp1 `pts_to` _) (pp1 `pts_to` _);
-  A.change_equal_slprop (pp2 `pts_to` _) (pp2 `pts_to` _);
-  unfocus pp1 p (field line_fields_pcm P1)
-    (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)));
-  unfocus pp2 p (field line_fields_pcm P2)
-    (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1)));
-  A.change_equal_slprop
-    (p `pts_to` put (field line_fields_pcm P1) _ _)
-    (p `pts_to`
-      mk_line
-        (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
-        (one point_pcm));
-  A.change_equal_slprop
-    (p `pts_to` put (field line_fields_pcm P2) _ _)
-    (p `pts_to`
-      mk_line
-        (one point_pcm)
-        (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1))));
-  gather p
-    (mk_line
-      (mk_point (some (Ghost.reveal y2)) (some (Ghost.reveal x2)))
-      (one point_pcm))
-    (mk_line
-       (one point_pcm)
-       (mk_point (some (Ghost.reveal y1)) (some (Ghost.reveal x1))));
-  gather p (mk_line (Ghost.reveal (Ghost.hide (one point_pcm))) (one point_pcm)) _;
-  //A.change_equal_slprop (pp2 `pts_to` _) _;
-  (* int *r = &p.p1.y; *)
-  (* int *s = &p.p2.x; *)
-  (* int *t = &p.p2.y; *)
-  A.sladmit();
-  A.return ()
-#pop-options
-*)
-
 (*
 pts_to r x
 (fun r' -> pts_to r' x')
@@ -371,79 +157,6 @@ let f unit : Steel unit fake (fun _ -> _)
 *)
 
 (*
-// let gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
-// : SteelT (_:unit{composable r.q x y})
-//     (to_vprop (r `pts_to` x) `star` to_vprop (r `pts_to` y))
-//     (fun _ -> to_vprop (r `pts_to` op r.q x y))
-
-  (*
-    (to_vprop (r `pts_to` x))
-    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == ref_focus r' q l)
-    (fun _ _ _ -> True)
-    *)
-
-let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (q: refined_one_pcm 'c)
-  (l: pcm_lens r'.q q) (x: Ghost.erased 'c)
-: A.SteelGhost unit inames
-    (to_vprop (r `pts_to` x))
-    (fun _ -> to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ -> r == ref_focus r' q l)
-    (fun _ _ _ -> True)
-= A.change_slprop_rel  
-    (to_vprop (r `pts_to` x))
-    (to_vprop (r' `pts_to` put l x (one r'.q)))
-    (fun _ _ -> True)
-    (fun m -> r'.pl.get_morphism.f_one ())
-*)
-
-(*
-let swap (p: ref 'a point{p.q == point_pcm}) (xy: Ghost.erased int)
-: SteelT unit
-    (to_vprop (p `pts_to` xy))
-    (fun _ -> to_vprop (p `pts_to` mk_point (xy Y) (xy X)))
-  
-let swap (p: ref 'a point{p.q == point_pcm}) (xy: Ghost.erased int)
-: SteelT unit
-    (to_vprop (p `pts_to` xy))
-    (fun _ -> to_vprop (p `pts_to` xy `upd` (X, xy Y) `upd` (Y, xy X)))
-
-let swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
-: SteelT unit
-    (to_vprop (p `pts_to` mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y))))
-    (fun _ -> to_vprop (p `pts_to` mk_point (some (Ghost.reveal y)) (some (Ghost.reveal x))))
-= let q =
-    addr_of_lens p int_pcm (field point_fields_pcm X)
-      (mk_point (some (Ghost.reveal x)) (some (Ghost.reveal y))) in
-  A.slassert (
-    to_vprop (p `pts_to` mk_point none (some (Ghost.reveal y))) `star`
-    to_vprop (q `pts_to` some (Ghost.reveal x)));
-  A.sladmit ();
-  A.return ()
-*)
-
-// let addr_of_lens (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q) (x: Ghost.erased 'b)
-// : SteelT (ref 'a 'c)
-//     (to_vprop (r `pts_to` x))
-//     (fun s ->
-//       to_vprop (r `pts_to` put l (one q) x) `star` 
-//       to_vprop (s `pts_to` get l x))
-// = peel r q l x;
-//   focus r q l (put l (get l x) (one r.q)) (get l x)
-
-(*
-let swap (p: ref 'a point) (x y: Ghost.erased (option int))
-: Steel unit
-    (to_vprop (r `pts_to` mk_point x y))
-    (fun _ -> to_vprop (r `pts_to` mk_point y x))
-= 
-let ref_read (r: ref 'a 'b) (x: Ghost.erased 'b)
-: Steel 'b
-    (to_vprop (r `pts_to` x)) 
-    (fun _ -> to_vprop (r `pts_to` x))
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible r.q x x')*)
-
 (** Example: a model for a tagged union representing colors in RGB or HSV
       type color =
         | RGB : r:int -> g:int -> b:int -> color
@@ -498,5 +211,4 @@ let color_pcm_cases k : pcm (color_cases k) = match k with
   | RGB -> rgb_pcm
   | HSV -> hsv_pcm
 let color_pcm : pcm color_t = union_pcm color_pcm_cases
-
 *)
diff --git a/examples/steel/LineStruct.fst b/examples/steel/LineStruct.fst
new file mode 100644
index 00000000000..7756afdc8d3
--- /dev/null
+++ b/examples/steel/LineStruct.fst
@@ -0,0 +1,100 @@
+module LineStruct
+
+open FStar.FunctionalExtensionality
+module A = Steel.Effect.Atomic
+
+/// Example 2: pointers to nested fields
+///
+/// Here's a struct representing a line segment by its two endpoints:
+///   struct line { struct point p1; struct point p2; };
+///
+/// Carrier of PCM for line:
+
+type line_field = | P1 | P2
+let line_fields k = match k with
+  | P1 -> point
+  | P2 -> point
+let line = restricted_t line_field line_fields
+
+/// PCM for line:
+
+let line_fields_pcm k : pcm (line_fields k) = match k with
+  | P1 -> point_pcm
+  | P2 -> point_pcm
+let line_pcm = prod_pcm line_fields_pcm
+
+/// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
+
+let mk_line_f (p1 p2: point) (k: line_field): line_fields k = match k with
+  | P1 -> p1
+  | P2 -> p2
+let mk_line p1 p2 = on_domain line_field (mk_line_f (Ghost.reveal p1) (Ghost.reveal p2))
+
+let _p1 = field line_fields_pcm P1
+let _p2 = field line_fields_pcm P2
+
+/// Laws about putting/getting the x and y fields of a (mk_line x y)
+
+let put_p1 p1' p1 p2
+: Lemma (feq (put _p1 (Ghost.reveal p1') (mk_line p1 p2)) (mk_line p1' p2))
+  [SMTPat (put _p1 p1' (mk_line p1 p2))]
+= ()
+
+let put_p2 p2' p1 p2
+: Lemma (feq (put _p2 (Ghost.reveal p2') (mk_line p1 p2)) (mk_line p1 p2'))
+  [SMTPat (put _p2 p2' (mk_line p1 p2))]
+= ()
+
+/// Laws relating mk_line to PCM operations
+
+let one_line : squash (feq (one line_pcm) (mk_line (one point_pcm) (one point_pcm)))
+= ()
+
+let merge_line p1 p2 p1' p2'
+: Lemma
+    (requires composable line_pcm (mk_line p1 p2) (mk_line p1' p2'))
+    (ensures feq (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))
+             (mk_line (op (line_fields_pcm P1) (Ghost.reveal p1) (Ghost.reveal p1'))
+                      (op (line_fields_pcm P2) (Ghost.reveal p2) (Ghost.reveal p2'))))
+  [SMTPat (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))]
+= ()
+
+/// Taking pointers to the p1 and p2 fields of a line
+
+let addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
+: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p1})
+    (p `pts_to` mk_line p1 p2)
+    (fun q ->
+       (p `pts_to` mk_line (one point_pcm) p2) `star`
+       (q `pts_to` p1))
+= let q = addr_of_lens p _p1 (mk_line p1 p2) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line (one point_pcm) p2);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
+  A.return q
+
+let un_addr_of_p1 (#p1 #p2: Ghost.erased point)
+  (p: ref 'a line{p.q == line_pcm}) (q: ref 'a point{q == ref_focus p point_pcm _p1})
+: SteelT unit
+    ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
+    (fun q -> p `pts_to` mk_line p1 p2)
+= un_addr_of_lens q p _p1 (mk_line (one point_pcm) p2) p1;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
+: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p2})
+    (p `pts_to` mk_line p1 p2)
+    (fun q ->
+       (p `pts_to` mk_line p1 (one point_pcm)) `star`
+       (q `pts_to` p2))
+= let q = addr_of_lens p _p2 (mk_line p1 p2) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line p1 (one point_pcm));
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
+  A.return q
+
+let un_addr_of_p2 (#p1 #p2: Ghost.erased point)
+  (p: ref 'a line{p.q == line_pcm}) (q: ref 'a point{q == ref_focus p point_pcm _p2})
+: SteelT unit
+    ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
+    (fun q -> p `pts_to` mk_line p1 p2)
+= un_addr_of_lens q p _p2 (mk_line p1 (one point_pcm)) p2;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/LineStruct.fsti b/examples/steel/LineStruct.fsti
new file mode 100644
index 00000000000..e6e118f9c5f
--- /dev/null
+++ b/examples/steel/LineStruct.fsti
@@ -0,0 +1,59 @@
+module LineStruct
+
+open Aggregates
+open AggregateRef
+open FStar.PCM
+open Steel.Effect
+open PointStruct
+
+/// Example 2: pointers to nested fields
+///
+/// Here's a struct representing a line segment by its two endpoints:
+///   struct line { struct point p1; struct point p2; };
+///
+/// Carrier of PCM for line:
+
+val line : Type0
+
+/// PCM for line:
+
+val line_pcm : refined_one_pcm line
+
+/// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
+
+val mk_line (x y: Ghost.erased point): Ghost.erased line
+
+/// Lenses for fields
+
+val _p1 : pcm_lens line_pcm point_pcm
+val _p2 : pcm_lens line_pcm point_pcm
+
+/// Taking pointers to the p1 and p2 fields of a line
+
+val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
+: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p1})
+    (p `pts_to` mk_line p1 p2)
+    (fun q ->
+       (p `pts_to` mk_line (one point_pcm) p2) `star`
+       (q `pts_to` p1))
+
+val un_addr_of_p1 (#p1 #p2: Ghost.erased point)
+  (p: ref 'a line{p.q == line_pcm})
+  (q: ref 'a point{q == ref_focus p point_pcm _p1})
+: SteelT unit
+    ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
+    (fun q -> p `pts_to` mk_line p1 p2)
+
+val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
+: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p2})
+    (p `pts_to` mk_line p1 p2)
+    (fun q ->
+       (p `pts_to` mk_line p1 (one point_pcm)) `star`
+       (q `pts_to` p2))
+
+val un_addr_of_p2 (#p1 #p2: Ghost.erased point)
+  (p: ref 'a line{p.q == line_pcm})
+  (q: ref 'a point{q == ref_focus p point_pcm _p2})
+: SteelT unit
+    ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
+    (fun q -> p `pts_to` mk_line p1 p2)
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/PointStruct.fsti
index 8b033b14a73..5b858e5563b 100644
--- a/examples/steel/PointStruct.fsti
+++ b/examples/steel/PointStruct.fsti
@@ -15,7 +15,7 @@ val point : Type0
 
 /// PCM for struct point:
 
-val point_pcm : pcm point
+val point_pcm : refined_one_pcm point
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
 
diff --git a/ulib/experimental/Steel.HigherReference.fst b/ulib/experimental/Steel.HigherReference.fst
index 4e2209dbf99..f4ad290a9eb 100644
--- a/ulib/experimental/Steel.HigherReference.fst
+++ b/ulib/experimental/Steel.HigherReference.fst
@@ -19,8 +19,8 @@ open FStar.Ghost
 open Steel.Memory
 open Steel.Effect.Atomic
 open Steel.Effect
-open FStar.Real
 open FStar.PCM
+open FStar.Real
 open Steel.FractionalPermission
 module RP = Steel.PCMReference
 

From 34f3dc12561fd1c47c96876a944ffd9685285b18 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 06:19:27 -0700
Subject: [PATCH 063/513] Switch from ref 'a 'b to ref 'a (p: pcm 'b)

---
 examples/steel/AggregateRef.fst         | 83 ++++++++++++-------------
 examples/steel/AggregateRef.fsti        | 80 +++++++++++++-----------
 examples/steel/AggregateRefExamples.fst | 14 ++---
 examples/steel/LineStruct.fst           | 34 +++-------
 examples/steel/LineStruct.fsti          | 16 ++---
 examples/steel/PointStruct.fst          | 38 +++--------
 examples/steel/PointStruct.fsti         | 16 ++---
 7 files changed, 118 insertions(+), 163 deletions(-)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/AggregateRef.fst
index 403a3e38ce5..06f79fd7449 100644
--- a/examples/steel/AggregateRef.fst
+++ b/examples/steel/AggregateRef.fst
@@ -510,15 +510,14 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
 
 (** The refinement of a ref *)
 
-let ref_refine (r: ref 'a 'b)
-  (new_re: pcm_refinement r.q) (new_u: pcm_unrefinement new_re)
-: ref 'a (refine_t new_re.f) = {
+let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
+  (r: ref a p) (new_re: pcm_refinement p) (new_u: pcm_unrefinement new_re)
+: ref a (refined_pcm new_re) = {
   p = r.p;
   re = conj_refinement r.re (extend_refinement r.pl new_re);
   u =
     conj_unrefinement r.re (extend_refinement r.pl new_re) r.u
       (extend_unrefinement r.pl new_re new_u);
-  q = refined_pcm new_re;
   pl =
     pcm_iso_lens_comp
       (pcm_refinement_conj_iso r.p r.re (extend_refinement r.pl new_re))
@@ -531,13 +530,13 @@ let ref_refine (r: ref 'a 'b)
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let focus (r: ref 'a 'b)
+let focus (r: ref 'a 'p)
   (#q: refined_one_pcm 'c)
-  (l: pcm_lens r.q q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ref 'a 'c)
+  (l: pcm_lens 'p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ref 'a q)
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == put l x (one r.q))
+    (fun _ -> Ghost.reveal s == put l x (one 'p))
     (fun _ r' _ -> r' == ref_focus r q l)
 = let r' = ref_focus r q l in
   A.change_slprop_rel  
@@ -547,16 +546,19 @@ let focus (r: ref 'a 'b)
     (fun m -> r.pl.get_morphism.f_one ());
   A.return r'
 
-let unfocus #inames (r: ref 'a 'c) (r': ref 'a 'b) (#r'q: pcm 'b) (#q: refined_one_pcm 'c)
-  (l: pcm_lens r'q q) (x: Ghost.erased 'c)
+let unfocus #inames
+  (#p: refined_one_pcm 'b)
+  (#q: refined_one_pcm 'c)
+  (r: ref 'a q) (r': ref 'a p)
+  (l: pcm_lens p q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (r `pts_to` x)
-    (fun _ -> r' `pts_to` put l x (one r'.q))
-    (requires fun _ -> r'.q == r'q /\ r == ref_focus r' q l)
+    (fun _ -> r' `pts_to` put l x (one p))
+    (requires fun _ -> r == ref_focus r' q l)
     (ensures fun _ _ _ -> True)
 = A.change_slprop_rel  
     (r `pts_to` x)
-    (r' `pts_to` put l x (one r'.q))
+    (r' `pts_to` put l x (one p))
     (fun _ _ -> True)
     (fun m -> r'.pl.get_morphism.f_one ())
 
@@ -587,7 +589,7 @@ let mgather
     (fun _ -> mpts_to r (op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
-let gather r x y =
+let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
     (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
@@ -604,34 +606,32 @@ let gather r x y =
   r.pl.put_morphism.f_op
     (Ghost.reveal x, one (refined_pcm r.re))
     (Ghost.reveal y, one (refined_pcm r.re));
-  A.change_equal_slprop _ (r `pts_to` op r.q x y)
+  A.change_equal_slprop _ (r `pts_to` op p x y)
 
-let peel (r: ref 'a 'b) (#rq: pcm 'b) (#q: refined_one_pcm 'c)
-  (l: pcm_lens rq q) (x: Ghost.erased 'b)
-: Steel unit
+let peel (#p: refined_one_pcm 'b) (r: ref 'a p) (#q: refined_one_pcm 'c)
+  (l: pcm_lens p q) (x: Ghost.erased 'b)
+: SteelT unit
     (r `pts_to` x)
     (fun _ ->
       (r `pts_to` put l (one q) x) `star` 
-      (r `pts_to` put l (get l x) (one r.q)))
-    (requires fun _ -> rq == r.q)
-    (ensures fun _ _ _ -> True)
+      (r `pts_to` put l (get l x) (one p)))
 = q.is_unit (get l x);
-  r.q.is_unit x;
+  p.is_unit x;
   q.comm (get l x) (one q);
-  l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one r.q);
-  split r x (put l (one q) x) (put l (get l x) (one r.q))
+  l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one p);
+  split r x (put l (one q) x) (put l (get l x) (one p))
 
-let addr_of_lens r l x =
+let addr_of_lens #a #b #c #p r l x =
   peel r l x;
-  focus r l (put l (get l x) (one r.q)) (get l x)
+  focus r l (put l (get l x) (one p)) (get l x)
 
-let un_addr_of_lens r' r #rq #q l x y =
+let un_addr_of_lens #a #b #c #p #q r' r l x y =
   unfocus r' r l y;
-  gather r x (put l y (one r.q));
+  gather r x (put l y (one p));
   q.is_unit (Ghost.reveal y);
-  r.q.is_unit (Ghost.reveal x);
+  p.is_unit (Ghost.reveal x);
   q.comm (get l x) y;
-  l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one r.q);
+  l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one p);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let refine r re u x =
@@ -642,12 +642,12 @@ let refine r re u x =
 let unrefine #inames r' re u r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
-let ref_read' (#x: Ghost.erased 'b) (r: ref 'a 'b)
+let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
 : Steel 'b
     (r `pts_to` x)
     (fun _ -> r `pts_to` x)
-    (requires fun _ -> ~ (Ghost.reveal x == one r.q))
-    (ensures fun _ x' _ -> compatible r.q x x')
+    (requires fun _ -> ~ (Ghost.reveal x == one p))
+    (ensures fun _ x' _ -> compatible p x x')
 = let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
   let v = Steel.PCMReference.read r.r x' in
@@ -655,10 +655,10 @@ let ref_read' (#x: Ghost.erased 'b) (r: ref 'a 'b)
   pcm_lens_compatible_get r.pl x' v;
   A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
   A.return (get r.pl v)
-let ref_read #x r = ref_read' #x r // TODO interestingly, i can't inline ref_read'
 
-let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
-  (f: ('b -> 'b){frame_pres r.q f x y})
+let ref_frame_preserving_upd #a #b
+  (#p: refined_one_pcm b) (r: ref a p) (x y: Ghost.erased b)
+  (f: (b -> b){frame_pres p f x y})
 : frame_preserving_upd r.p
     (put r.pl x (one (refined_pcm r.re)))
     (put r.pl y (one (refined_pcm r.re)))
@@ -667,7 +667,7 @@ let ref_frame_preserving_upd (r: ref 'a 'b) (x y: Ghost.erased 'b)
   pcm_lens_frame_pres r.pl x' y f;
   r.u x' y' (frame_pres_mk_upd (refined_pcm r.re) x' y' (upd r.pl f))
 
-let ref_upd_act (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
+let ref_upd_act (r: ref 'a 'p) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres 'p f x y})
 : M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y))
 = M.upd_gen Set.empty r.r _ _ (ref_frame_preserving_upd r x y f)
 
@@ -698,11 +698,6 @@ let frame_preserving_upd_valid_write (p: pcm 'a)
     in FStar.Classical.forall_intro aux);
   f
 
-let ref_write (r: ref 'a 'b) (#x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
+let ref_write (r: ref 'a 'p) (#x: Ghost.erased 'b) (y: 'b{valid_write 'p x y})
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-= ref_upd r x y (frame_preserving_upd_valid_write r.q x y)
-
-(* From ref_write, can derive the expected write for all-or-none PCM *)
-let ref_write_opt_pcm (r: ref 'a (option 'b){r.q == opt_pcm #'b}) (x: Ghost.erased 'b) (y: 'b)
-: SteelT unit (r `pts_to` Some (Ghost.reveal x)) (fun _ -> r `pts_to` Some y)
-= ref_write r #(Some (Ghost.reveal x)) (Some y)
+= ref_upd r x y (frame_preserving_upd_valid_write 'p x y)
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/AggregateRef.fsti
index 80e133343d2..086dad7ec10 100644
--- a/examples/steel/AggregateRef.fsti
+++ b/examples/steel/AggregateRef.fsti
@@ -207,14 +207,13 @@ let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
-noeq type ref (a:Type u#a) (b:Type u#b): Type = {
+noeq type ref a #b (q: refined_one_pcm b): Type = {
   p: refined_one_pcm a;
   re: pcm_refinement p;
   (** Needed to turn frame-preserving updates on (refined_pcm re) into
       frame-preserving updates on p. To do so, also requires that p and q
       be `refined_one_pcm`s *)
   u: pcm_unrefinement re;
-  q: refined_one_pcm b;
   pl: pcm_lens (refined_pcm re) q;
   r: Steel.Memory.ref a p;
 }
@@ -222,8 +221,8 @@ noeq type ref (a:Type u#a) (b:Type u#b): Type = {
 open Steel.Effect
 
 val pts_to
-  (#a: Type u#1) (#b: Type u#b)
-  (r: ref a b) ([@@@smt_fallback] v: Ghost.erased b)
+  (#a: Type u#1) (#b: Type u#b) (#p: refined_one_pcm b)
+  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
 : vprop
 
 (** A lens for the k-th field of an n-ary product *)
@@ -411,56 +410,57 @@ val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
 
 (** The refinement of a ref *)
 
-val ref_refine
-  (r: ref 'a 'b) (new_re: pcm_refinement r.q) (new_u: pcm_unrefinement new_re)
-: ref 'a (refine_t new_re.f)
+val ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
+  (r: ref a p) (new_re: pcm_refinement p) (new_u: pcm_unrefinement new_re)
+: ref a (refined_pcm new_re)
 
 (** Fundamental operations on references *)
 
 module A = Steel.Effect.Atomic
 
-let ref_focus (r: ref 'a 'b) (q: refined_one_pcm 'c) (l: pcm_lens r.q q): ref 'a 'c = {p = r.p; re = r.re; u = r.u; q = q; pl = pcm_lens_comp r.pl l; r = r.r}
+let ref_focus (r: ref 'a 'p) (q: refined_one_pcm 'c) (l: pcm_lens 'p q): ref 'a q =
+  {p = r.p; re = r.re; u = r.u; pl = pcm_lens_comp r.pl l; r = r.r}
 
-val split (r: ref 'a 'c) (xy x y: Ghost.erased 'c)
+val split (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 : Steel unit
     (r `pts_to` xy)
     (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable r.q x y /\ xy == Ghost.hide (op r.q x y))
+    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
     (fun _ _ _ -> True)
 
-val gather (r: ref 'a 'c) (x y: Ghost.erased 'c)
-: SteelT (_:unit{composable r.q x y})
+val gather (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (x y: Ghost.erased b)
+: SteelT (_:unit{composable p x y})
     ((r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> r `pts_to` op r.q x y)
+    (fun _ -> r `pts_to` op p x y)
 
 val addr_of_lens
-  (r: ref 'a 'b)
-  (#rq: pcm 'b) (#q: refined_one_pcm 'c) (l: pcm_lens rq q)
-  (x: Ghost.erased 'b)
-: Steel (ref 'a 'c)
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
+  (r: ref a p) (l: pcm_lens p q)
+  (x: Ghost.erased b)
+: Steel (ref a q)
     (r `pts_to` x)
     (fun s ->
       (r `pts_to` put l (one q) x) `star` 
       (s `pts_to` get l x))
-    (requires fun _ -> rq == r.q)
-    (ensures fun _ r' _ -> rq == r.q /\ r' == ref_focus r q l)
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r q l)
 
 val un_addr_of_lens
-  (r': ref 'a 'c) (r: ref 'a 'b)
-  (#rq: pcm 'b) (#q: refined_one_pcm 'c) (l: pcm_lens rq q)
-  (x: Ghost.erased 'b) (y: Ghost.erased 'c)
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
+  (r': ref a q) (r: ref a p) (l: pcm_lens p q)
+  (x: Ghost.erased b) (y: Ghost.erased c)
 : Steel unit
     ((r `pts_to` x) `star` (r' `pts_to` y))
     (fun s -> r `pts_to` put l y x)
-    (requires fun _ -> rq == r.q /\ r' == ref_focus r q l /\ get l x == one q)
+    (requires fun _ -> r' == ref_focus r q l /\ get l x == one q)
     (ensures fun _ _ _ -> True)
 
 val refine
-  (r: ref 'a 'b)
-  (re: pcm_refinement r.q)
-  (u: pcm_unrefinement re)
-  (x: Ghost.erased 'b{re.f x})
-: Steel (ref 'a (refine_t re.f))
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
+  (r: ref a p)
+  (re: pcm_refinement p) (u: pcm_unrefinement re)
+  (x: Ghost.erased b{re.f x})
+: Steel (ref a (refined_pcm re))
     (r `pts_to` x)
     (fun r' -> r' `pts_to` Ghost.reveal x)
     (fun _ -> True)
@@ -468,9 +468,10 @@ val refine
 
 val unrefine
   (#opened:Steel.Memory.inames)
-  (r': ref 'a 'b)
-  (re: pcm_refinement r'.q) (u: pcm_unrefinement re)
-  (r: ref 'a (refine_t re.f)) (x: Ghost.erased 'b{re.f x})
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
+  (r': ref a p)
+  (re: pcm_refinement p) (u: pcm_unrefinement re)
+  (r: ref a (refined_pcm re)) (x: Ghost.erased b{re.f x})
 : A.SteelGhost unit opened
     (r `pts_to` Ghost.reveal x)
     (fun _ -> r' `pts_to` x)
@@ -513,14 +514,17 @@ val unrefine
     test v against the unit of its corresponding PCM, then there's no
     way to prove this precondition and we are safe from reading v
     as thread 1 is writing to it. *)
-val ref_read (#x: Ghost.erased 'b) (r: ref 'a 'b)
-: Steel 'b
+val ref_read
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b) (#x: Ghost.erased b) (r: ref a p)
+: Steel b
     (r `pts_to` x)
     (fun _ -> r `pts_to` x)
-    (requires fun _ -> ~ (Ghost.reveal x == one r.q))
-    (ensures fun _ x' _ -> compatible r.q x x')
+    (requires fun _ -> ~ (Ghost.reveal x == one p))
+    (ensures fun _ x' _ -> compatible p x x')
 
-val ref_upd (r: ref 'a 'b) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres r.q f x y})
+val ref_upd
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
+  (r: ref a p) (x y: Ghost.erased b) (f: (b -> b){frame_pres p f x y})
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 
 (* TODO move to FStar.PCM.fst? *)
@@ -532,5 +536,7 @@ let valid_write (p:pcm 'a) x y =
   whole_value p x /\ whole_value p y /\
   (forall (frame:'a). composable p x frame ==> composable p y frame)
 
-val ref_write (r: ref 'a 'b) (#x: Ghost.erased 'b) (y: 'b{valid_write r.q x y})
+val ref_write
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
+  (r: ref a p) (#x: Ghost.erased b) (y: b{valid_write p x y})
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/AggregateRefExamples.fst
index 1099d1107ff..f3ac3e6c201 100644
--- a/examples/steel/AggregateRefExamples.fst
+++ b/examples/steel/AggregateRefExamples.fst
@@ -20,7 +20,7 @@ open PointStruct
 ///   *r = tmp;
 /// }
 
-let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
+let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
 : SteelT unit
     (p `pts_to` mk_point (some x) (some y))
     (fun _ -> p `pts_to` mk_point (some y) (some x))
@@ -47,10 +47,7 @@ let point_swap (p: ref 'a point{p.q == point_pcm}) (x y: Ghost.erased int)
 ///   *q = tmp;
 /// }
 
-let generic_swap
-  (#x #y: Ghost.erased 'c)
-  (p:ref 'a (pod 'c){p.q == pod_pcm 'c})
-  (q:ref 'b (pod 'c){q.q == pod_pcm 'c})
+let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (pod_pcm 'c)) (q:ref 'b (pod_pcm 'c))
 : SteelT unit ((p `pts_to` some x) `star` (q `pts_to` some y))
     (fun _ -> (p `pts_to` some y) `star` (q `pts_to` some x))
 = (* A tmp = *p; *)
@@ -71,9 +68,7 @@ let generic_swap
 ///   generic_swap(q, r);
 /// }
 
-let point_swap_generically
-  (#x #y: Ghost.erased int)
-  (p: ref 'a point{p.q == point_pcm})
+let point_swap_generically (#x #y: Ghost.erased int) (p: ref 'a point_pcm)
 : SteelT unit
     (p `pts_to` mk_point (some x) (some y))
     (fun _ -> p `pts_to` mk_point (some y) (some x))
@@ -96,8 +91,7 @@ let point_swap_generically
 
 open LineStruct
 
-let reflect_and_reverse
-  (p: ref 'a line{p.q == line_pcm}) (x1 y1 x2 y2: Ghost.erased int)
+let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
 : SteelT unit
     (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
     (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
diff --git a/examples/steel/LineStruct.fst b/examples/steel/LineStruct.fst
index 7756afdc8d3..e79a6731bfc 100644
--- a/examples/steel/LineStruct.fst
+++ b/examples/steel/LineStruct.fst
@@ -61,40 +61,22 @@ let merge_line p1 p2 p1' p2'
 
 /// Taking pointers to the p1 and p2 fields of a line
 
-let addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
-: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p1})
-    (p `pts_to` mk_line p1 p2)
-    (fun q ->
-       (p `pts_to` mk_line (one point_pcm) p2) `star`
-       (q `pts_to` p1))
-= let q = addr_of_lens p _p1 (mk_line p1 p2) in
+let addr_of_p1 #a #p1 #p2 p =
+  let q = addr_of_lens p _p1 (mk_line p1 p2) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line (one point_pcm) p2);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
   A.return q
 
-let un_addr_of_p1 (#p1 #p2: Ghost.erased point)
-  (p: ref 'a line{p.q == line_pcm}) (q: ref 'a point{q == ref_focus p point_pcm _p1})
-: SteelT unit
-    ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
-    (fun q -> p `pts_to` mk_line p1 p2)
-= un_addr_of_lens q p _p1 (mk_line (one point_pcm) p2) p1;
+let un_addr_of_p1 #a #p1 #p2 p q =
+  un_addr_of_lens q p _p1 (mk_line (one point_pcm) p2) p1;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-let addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
-: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p2})
-    (p `pts_to` mk_line p1 p2)
-    (fun q ->
-       (p `pts_to` mk_line p1 (one point_pcm)) `star`
-       (q `pts_to` p2))
-= let q = addr_of_lens p _p2 (mk_line p1 p2) in
+let addr_of_p2 #a #p1 #p2 p =
+  let q = addr_of_lens p _p2 (mk_line p1 p2) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line p1 (one point_pcm));
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
   A.return q
 
-let un_addr_of_p2 (#p1 #p2: Ghost.erased point)
-  (p: ref 'a line{p.q == line_pcm}) (q: ref 'a point{q == ref_focus p point_pcm _p2})
-: SteelT unit
-    ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
-    (fun q -> p `pts_to` mk_line p1 p2)
-= un_addr_of_lens q p _p2 (mk_line p1 (one point_pcm)) p2;
+let un_addr_of_p2 #a #p1 #p2 p q =
+  un_addr_of_lens q p _p2 (mk_line p1 (one point_pcm)) p2;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/LineStruct.fsti b/examples/steel/LineStruct.fsti
index e6e118f9c5f..7539bc4ebf7 100644
--- a/examples/steel/LineStruct.fsti
+++ b/examples/steel/LineStruct.fsti
@@ -30,30 +30,30 @@ val _p2 : pcm_lens line_pcm point_pcm
 
 /// Taking pointers to the p1 and p2 fields of a line
 
-val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
-: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p1})
+val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
+: SteelT (q:ref 'a point_pcm{q == ref_focus p point_pcm _p1})
     (p `pts_to` mk_line p1 p2)
     (fun q ->
        (p `pts_to` mk_line (one point_pcm) p2) `star`
        (q `pts_to` p1))
 
 val un_addr_of_p1 (#p1 #p2: Ghost.erased point)
-  (p: ref 'a line{p.q == line_pcm})
-  (q: ref 'a point{q == ref_focus p point_pcm _p1})
+  (p: ref 'a line_pcm)
+  (q: ref 'a point_pcm{q == ref_focus p point_pcm _p1})
 : SteelT unit
     ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
     (fun q -> p `pts_to` mk_line p1 p2)
 
-val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line{p.q == line_pcm})
-: SteelT (q:ref 'a point{q == ref_focus p point_pcm _p2})
+val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
+: SteelT (q:ref 'a point_pcm{q == ref_focus p point_pcm _p2})
     (p `pts_to` mk_line p1 p2)
     (fun q ->
        (p `pts_to` mk_line p1 (one point_pcm)) `star`
        (q `pts_to` p2))
 
 val un_addr_of_p2 (#p1 #p2: Ghost.erased point)
-  (p: ref 'a line{p.q == line_pcm})
-  (q: ref 'a point{q == ref_focus p point_pcm _p2})
+  (p: ref 'a line_pcm)
+  (q: ref 'a point_pcm{q == ref_focus p point_pcm _p2})
 : SteelT unit
     ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
     (fun q -> p `pts_to` mk_line p1 p2)
diff --git a/examples/steel/PointStruct.fst b/examples/steel/PointStruct.fst
index 12140e98ef5..2f0255be2b3 100644
--- a/examples/steel/PointStruct.fst
+++ b/examples/steel/PointStruct.fst
@@ -59,44 +59,22 @@ let merge_xy (x y: Ghost.erased (pod int)) x' y'
 
 /// Taking pointers to the x and y fields of a point
 
-let addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
-: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point none y) `star`
-       (q `pts_to` x))
-= let q = addr_of_lens p _x (mk_point x y) in
+let addr_of_x #a #x #y p =
+  let q = addr_of_lens p _x (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
   A.return q
 
-let un_addr_of_x
-  (#x #y: Ghost.erased (pod int))
-  (p: ref 'a point{p.q == point_pcm})
-  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
-: SteelT unit
-    ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
-    (fun q -> p `pts_to` mk_point x y)
-= un_addr_of_lens q p _x (mk_point none y) x;
+let un_addr_of_x #a #x #y p q =
+  un_addr_of_lens q p _x (mk_point none y) x;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-let addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
-: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point x none) `star`
-       (q `pts_to` y))
-= let q = addr_of_lens p _y (mk_point x y) in
+let addr_of_y #a #x #y p =
+  let q = addr_of_lens p _y (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
-let un_addr_of_y
-  (#x #y: Ghost.erased (pod int))
-  (p: ref 'a point{p.q == point_pcm})
-  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
-: SteelT unit
-    ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
-    (fun q -> p `pts_to` mk_point x y)
-= un_addr_of_lens q p _y (mk_point x none) y;
+let un_addr_of_y #a #x #y p q =
+  un_addr_of_lens q p _y (mk_point x none) y;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/PointStruct.fsti
index 5b858e5563b..22b94f8bba1 100644
--- a/examples/steel/PointStruct.fsti
+++ b/examples/steel/PointStruct.fsti
@@ -28,8 +28,8 @@ val _y : pcm_lens point_pcm (pod_pcm int)
 
 /// Taking pointers to the x and y fields of a point
 
-val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
-: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
+val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _x})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point none y) `star`
@@ -37,14 +37,14 @@ val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm}
 
 val un_addr_of_x
   (#x #y: Ghost.erased (pod int))
-  (p: ref 'a point{p.q == point_pcm})
-  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _x})
+  (p: ref 'a point_pcm)
+  (q: ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _x})
 : SteelT unit
     ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
     (fun q -> p `pts_to` mk_point x y)
 
-val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm})
-: SteelT (q:ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
+val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _y})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point x none) `star`
@@ -52,8 +52,8 @@ val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point{p.q == point_pcm}
 
 val un_addr_of_y
   (#x #y: Ghost.erased (pod int))
-  (p: ref 'a point{p.q == point_pcm})
-  (q: ref 'a (pod int){q == ref_focus p (pod_pcm int) _y})
+  (p: ref 'a point_pcm)
+  (q: ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _y})
 : SteelT unit
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)

From 193d0a9afe0a51aab4f8424b76f652ee14492f85 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 06:24:02 -0700
Subject: [PATCH 064/513] Make arraystructs/

---
 examples/steel/{ => arraystructs}/AggregateRef.fst         | 0
 examples/steel/{ => arraystructs}/AggregateRef.fsti        | 0
 examples/steel/{ => arraystructs}/AggregateRefExamples.fst | 0
 examples/steel/{ => arraystructs}/Aggregates.fst           | 0
 examples/steel/{ => arraystructs}/Basetypes.md             | 0
 examples/steel/{ => arraystructs}/LineStruct.fst           | 0
 examples/steel/{ => arraystructs}/LineStruct.fsti          | 0
 examples/steel/{ => arraystructs}/PCM.POD.fst              | 6 +++---
 examples/steel/{ => arraystructs}/PCM.POD.fsti             | 0
 examples/steel/{ => arraystructs}/PointStruct.fst          | 0
 examples/steel/{ => arraystructs}/PointStruct.fsti         | 0
 11 files changed, 3 insertions(+), 3 deletions(-)
 rename examples/steel/{ => arraystructs}/AggregateRef.fst (100%)
 rename examples/steel/{ => arraystructs}/AggregateRef.fsti (100%)
 rename examples/steel/{ => arraystructs}/AggregateRefExamples.fst (100%)
 rename examples/steel/{ => arraystructs}/Aggregates.fst (100%)
 rename examples/steel/{ => arraystructs}/Basetypes.md (100%)
 rename examples/steel/{ => arraystructs}/LineStruct.fst (100%)
 rename examples/steel/{ => arraystructs}/LineStruct.fsti (100%)
 rename examples/steel/{ => arraystructs}/PCM.POD.fst (74%)
 rename examples/steel/{ => arraystructs}/PCM.POD.fsti (100%)
 rename examples/steel/{ => arraystructs}/PointStruct.fst (100%)
 rename examples/steel/{ => arraystructs}/PointStruct.fsti (100%)

diff --git a/examples/steel/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
similarity index 100%
rename from examples/steel/AggregateRef.fst
rename to examples/steel/arraystructs/AggregateRef.fst
diff --git a/examples/steel/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
similarity index 100%
rename from examples/steel/AggregateRef.fsti
rename to examples/steel/arraystructs/AggregateRef.fsti
diff --git a/examples/steel/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
similarity index 100%
rename from examples/steel/AggregateRefExamples.fst
rename to examples/steel/arraystructs/AggregateRefExamples.fst
diff --git a/examples/steel/Aggregates.fst b/examples/steel/arraystructs/Aggregates.fst
similarity index 100%
rename from examples/steel/Aggregates.fst
rename to examples/steel/arraystructs/Aggregates.fst
diff --git a/examples/steel/Basetypes.md b/examples/steel/arraystructs/Basetypes.md
similarity index 100%
rename from examples/steel/Basetypes.md
rename to examples/steel/arraystructs/Basetypes.md
diff --git a/examples/steel/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
similarity index 100%
rename from examples/steel/LineStruct.fst
rename to examples/steel/arraystructs/LineStruct.fst
diff --git a/examples/steel/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
similarity index 100%
rename from examples/steel/LineStruct.fsti
rename to examples/steel/arraystructs/LineStruct.fsti
diff --git a/examples/steel/PCM.POD.fst b/examples/steel/arraystructs/PCM.POD.fst
similarity index 74%
rename from examples/steel/PCM.POD.fst
rename to examples/steel/arraystructs/PCM.POD.fst
index 22aeecdc019..8d3ca0e2ce0 100644
--- a/examples/steel/PCM.POD.fst
+++ b/examples/steel/arraystructs/PCM.POD.fst
@@ -1,9 +1,9 @@
 module PCM.POD
 
-let pod a = Ghost.erased (option a)
+let pod a = option a
 
-let none #a = Ghost.hide (None #a)
-let some x = Ghost.hide (Some x)
+let none #a = None #a
+let some x = Some (Ghost.reveal x)
 let is_some v = match Ghost.reveal v with Some _ -> True | None -> False
 let some_v x = match x with Some v -> v
 
diff --git a/examples/steel/PCM.POD.fsti b/examples/steel/arraystructs/PCM.POD.fsti
similarity index 100%
rename from examples/steel/PCM.POD.fsti
rename to examples/steel/arraystructs/PCM.POD.fsti
diff --git a/examples/steel/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
similarity index 100%
rename from examples/steel/PointStruct.fst
rename to examples/steel/arraystructs/PointStruct.fst
diff --git a/examples/steel/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
similarity index 100%
rename from examples/steel/PointStruct.fsti
rename to examples/steel/arraystructs/PointStruct.fsti

From 0744a79f73e946457d6575618f86c29401faaa71 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 06:40:19 -0700
Subject: [PATCH 065/513] pcm_refinement -> pcm_refinement'; package refinement
 and unrefinement together

---
 examples/steel/arraystructs/AggregateRef.fst  | 156 +++++++++---------
 examples/steel/arraystructs/AggregateRef.fsti |  73 ++++----
 2 files changed, 118 insertions(+), 111 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index 06f79fd7449..3cdb336c390 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -27,17 +27,17 @@ let pcm_morphism_both #a #b #c #p #q #r #s #f #g mf mg = {
   f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
 }
 
-let pcm_refinement_comp_new_one #a #p re x y =
+let pcm_refinement'_comp_new_one #a #p re x y =
   re.new_one_is_refined_unit x;
   p.assoc_r x re.new_one y;
   re.f_closed_comp re.new_one y
 
-let pcm_refinement_compatible_closed #a #p re x y =
+let pcm_refinement'_compatible_closed #a #p re x y =
   let p' = refined_pcm re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    pcm_refinement_comp_new_one re x frame_x;
+    pcm_refinement'_comp_new_one re x frame_x;
     let frame = op p re.new_one frame_x in
     re.new_one_is_refined_unit x;
     p.comm x frame_x;
@@ -208,7 +208,7 @@ let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
     | Some (Inr x) -> q.refine x);
 })
 
-let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_pcm p q) = {
+let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement' (either_pcm p q) = {
   f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
   f_closed_comp = (fun _ _ -> ());
   new_one = Some (Inl #_ #'b (one p));
@@ -218,26 +218,26 @@ let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement (either_p
 let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
 
 let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
-  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
+  r.r `mpts_to` put r.pl v (one (refined_pcm r.re.refi))
 
 (** Refining a pcm_lens *)
 
 let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: 'a): prop
+  (re: pcm_refinement' q) (x: 'a): prop
 = re.f (get l x)
 
 let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (s: refine_t (extend_refinement_f l re))
+  (re: pcm_refinement' q) (s: refine_t (extend_refinement_f l re))
 : refine_t re.f
 = l.l.get s
 
 let lens_refine_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q)
+  (re: pcm_refinement' q)
   (v: refine_t re.f) (s: refine_t (extend_refinement_f l re))
 : refine_t (extend_refinement_f l re)
 = l.l.put v s
 
-let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement q)
+let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement' q)
 : lens (refine_t (extend_refinement_f l re)) (refine_t re.f) = {
   get = lens_refine_get l re;
   put = lens_refine_put l re;
@@ -247,20 +247,20 @@ let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement
 }
 
 let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
   (y: 'a{composable p x y})
 : Lemma (extend_refinement_f l re (op p x y))
 = l.get_morphism.f_op x y;
   re.f_closed_comp (get l x) (get l y)
 
 let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : new_one:refine_t (extend_refinement_f l re){p.refine new_one}
 = l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
 
 let extend_refinement_new_one_is_refined_unit
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement q) (x: refine_t (extend_refinement_f l re))
+  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
 : Lemma (composable p x (extend_refinement_new_one l re) /\
          op p x (extend_refinement_new_one l re) == x)
 = re.new_one_is_refined_unit (get l x);
@@ -268,8 +268,8 @@ let extend_refinement_new_one_is_refined_unit
   l.put_morphism.f_op (get l x, x) (re.new_one, one p)
   
 let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: pcm_refinement p = {
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: pcm_refinement' p = {
   f = extend_refinement_f l re;
   f_closed_comp = extend_refinement_f_closed l re;
   new_one = extend_refinement_new_one l re;
@@ -278,7 +278,7 @@ let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
 
 let pcm_lens_refine_get_morphism_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_refine
     (refined_pcm (extend_refinement l re))
     (refined_pcm re)
@@ -287,7 +287,7 @@ let pcm_lens_refine_get_morphism_refine
 
 let pcm_lens_refine_get_morphism_one
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_one
     (refined_pcm (extend_refinement l re))
     (refined_pcm re)
@@ -296,7 +296,7 @@ let pcm_lens_refine_get_morphism_one
 
 let pcm_lens_refine_get_morphism_op
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_op
     (refined_pcm (extend_refinement l re))
     (refined_pcm re)
@@ -305,7 +305,7 @@ let pcm_lens_refine_get_morphism_op
 
 let pcm_lens_refine_put_morphism_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_refine
     (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
     (refined_pcm (extend_refinement l re))
@@ -314,7 +314,7 @@ let pcm_lens_refine_put_morphism_refine
 
 let pcm_lens_refine_put_morphism_one
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_one
     (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
     (refined_pcm (extend_refinement l re))
@@ -323,7 +323,7 @@ let pcm_lens_refine_put_morphism_one
 
 let pcm_lens_refine_put_morphism_op
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_op
     (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
     (refined_pcm (extend_refinement l re))
@@ -332,7 +332,7 @@ let pcm_lens_refine_put_morphism_op
 
 let pcm_lens_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
   l = lens_refine l re;
   get_morphism = {
@@ -381,9 +381,9 @@ let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
 
 (** PCM isomorphisms *)
 
-let pcm_refinement_conj_iso_i (p: pcm 'a)
-  (re1: pcm_refinement p)
-  (re2: pcm_refinement (refined_pcm re1))
+let pcm_refinement'_conj_iso_i (p: pcm 'a)
+  (re1: pcm_refinement' p)
+  (re2: pcm_refinement' (refined_pcm re1))
 : iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
   refine_conj_iso re1.f re2.f
 
@@ -411,17 +411,17 @@ let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 (** The conjunction of two refinements *)
 
 let conj_refinement_f (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
 : 'a -> prop = conj #'a re1.f re2.f
 
 let conj_refinement_f_closed (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
   (x: refine_t (conj_refinement_f re1 re2))
   (y: 'a{composable p x y})
 : Lemma (conj_refinement_f re1 re2 (op p x y))
-= pcm_refinement_comp_new_one re1 x y;
+= pcm_refinement'_comp_new_one re1 x y;
   re1.f_closed_comp x (op p re1.new_one y);
-  pcm_refinement_comp_new_one re2 x (op p re1.new_one y);
+  pcm_refinement'_comp_new_one re2 x (op p re1.new_one y);
   re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
   p.assoc x re2.new_one (op p re1.new_one y);
   re2.new_one_is_refined_unit x;
@@ -430,20 +430,20 @@ let conj_refinement_f_closed (#p: pcm 'a)
 
 (* re1.new_one and re2.new_one both work; we go with re2 *)
 let conj_refinement_new_one (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
 : refine_t (conj_refinement_f re1 re2)
 = re2.new_one
 
 let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
   (x: refine_t (conj_refinement_f re1 re2))
 : Lemma (composable p x (conj_refinement_new_one re1 re2) /\
          op p x (conj_refinement_new_one re1 re2) == x)
 = re2.new_one_is_refined_unit x
 
 let conj_refinement (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-: pcm_refinement p = {
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+: pcm_refinement' p = {
   f = conj_refinement_f re1 re2;
   f_closed_comp = conj_refinement_f_closed re1 re2;
   new_one = conj_refinement_new_one re1 re2;
@@ -452,11 +452,11 @@ let conj_refinement (#p: pcm 'a)
 
 (** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
     refinement by the conjunction of re1 and re2 *)
-let pcm_refinement_conj_iso (p: pcm 'a)
-  (re1: pcm_refinement p)
-  (re2: pcm_refinement (refined_pcm re1))
+let pcm_refinement'_conj_iso (p: pcm 'a)
+  (re1: pcm_refinement' p)
+  (re2: pcm_refinement' (refined_pcm re1))
 : pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2) = {
-  i = pcm_refinement_conj_iso_i p re1 re2;
+  i = pcm_refinement'_conj_iso_i p re1 re2;
   fwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   bwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
@@ -480,26 +480,26 @@ let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.er
   w
 
 let conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
 = fun x y ->
   h1 (Ghost.reveal x) (Ghost.reveal y) `compose`
   h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
-  upd_across_pcm_iso (pcm_refinement_conj_iso p re1 re2) x y
+  upd_across_pcm_iso (pcm_refinement'_conj_iso p re1 re2) x y
 
 let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
+  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
 = fun x y f v ->
   let re' = extend_refinement l re in
   let p' = refined_pcm re' in
-  pcm_refinement_compatible_closed re' x v;
+  pcm_refinement'_compatible_closed re' x v;
   pcm_lens_compatible_get l x v;
   let w = f v in
   let aux (frame:'a{composable p x frame})
   : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
-  = pcm_refinement_comp_new_one re' x frame;
+  = pcm_refinement'_comp_new_one re' x frame;
     let frame' = op p re'.new_one frame in
     p.assoc y re'.new_one frame;
     re'.new_one_is_refined_unit y;
@@ -511,17 +511,19 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
 (** The refinement of a ref *)
 
 let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
-  (r: ref a p) (new_re: pcm_refinement p) (new_u: pcm_unrefinement new_re)
-: ref a (refined_pcm new_re) = {
+  (r: ref a p) (new_re: pcm_refinement p)
+: ref a (refined_pcm new_re.refi) = {
   p = r.p;
-  re = conj_refinement r.re (extend_refinement r.pl new_re);
-  u =
-    conj_unrefinement r.re (extend_refinement r.pl new_re) r.u
-      (extend_unrefinement r.pl new_re new_u);
+  re = {
+    refi = conj_refinement r.re.refi (extend_refinement r.pl new_re.refi);
+    u =
+      conj_unrefinement r.re.refi (extend_refinement r.pl new_re.refi) r.re.u
+        (extend_unrefinement r.pl new_re.refi new_re.u);
+  };
   pl =
     pcm_iso_lens_comp
-      (pcm_refinement_conj_iso r.p r.re (extend_refinement r.pl new_re))
-      (pcm_lens_refine r.pl new_re);
+      (pcm_refinement'_conj_iso r.p r.re.refi (extend_refinement r.pl new_re.refi))
+      (pcm_lens_refine r.pl new_re.refi);
   r = r.r
 }
 
@@ -565,20 +567,20 @@ let unfocus #inames
 let split r xy x y =
   A.change_equal_slprop
     (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re)))));
-  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re.refi)))));
+  (refined_pcm r.re.refi).is_unit (one (refined_pcm r.re.refi));
   r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re))
-    (Ghost.reveal y, one (refined_pcm r.re));
+    (Ghost.reveal x, one (refined_pcm r.re.refi))
+    (Ghost.reveal y, one (refined_pcm r.re.refi));
   Steel.PCMReference.split r.r
-    (put r.pl xy (one (refined_pcm r.re)))
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
+    (put r.pl xy (one (refined_pcm r.re.refi)))
+    (put r.pl x (one (refined_pcm r.re.refi)))
+    (put r.pl y (one (refined_pcm r.re.refi)));
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re.refi)))))
     (r `pts_to` x);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re.refi)))))
     (r `pts_to` y)
 
 let mgather
@@ -592,20 +594,20 @@ let mgather
 let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re.refi)))));
   A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re.refi)))));
   mgather r.r
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
+    (put r.pl x (one (refined_pcm r.re.refi)))
+    (put r.pl y (one (refined_pcm r.re.refi)));
   r.pl.get_morphism.f_op
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
+    (put r.pl x (one (refined_pcm r.re.refi)))
+    (put r.pl y (one (refined_pcm r.re.refi)));
+  (refined_pcm r.re.refi).is_unit (one (refined_pcm r.re.refi));
   r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re))
-    (Ghost.reveal y, one (refined_pcm r.re));
+    (Ghost.reveal x, one (refined_pcm r.re.refi))
+    (Ghost.reveal y, one (refined_pcm r.re.refi));
   A.change_equal_slprop _ (r `pts_to` op p x y)
 
 let peel (#p: refined_one_pcm 'b) (r: ref 'a p) (#q: refined_one_pcm 'c)
@@ -634,12 +636,12 @@ let un_addr_of_lens #a #b #c #p #q r' r l x y =
   l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one p);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
-let refine r re u x =
-  let r' = ref_refine r re u in
+let refine r re x =
+  let r' = ref_refine r re in
   A.change_equal_slprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
-let unrefine #inames r' re u r x =
+let unrefine #inames r' re r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
 let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
@@ -648,10 +650,10 @@ let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (fun _ -> r `pts_to` x)
     (requires fun _ -> ~ (Ghost.reveal x == one p))
     (ensures fun _ x' _ -> compatible p x x')
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re.refi))) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
   let v = Steel.PCMReference.read r.r x' in
-  pcm_refinement_compatible_closed r.re x' v;
+  pcm_refinement'_compatible_closed r.re.refi x' v;
   pcm_lens_compatible_get r.pl x' v;
   A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
   A.return (get r.pl v)
@@ -660,12 +662,12 @@ let ref_frame_preserving_upd #a #b
   (#p: refined_one_pcm b) (r: ref a p) (x y: Ghost.erased b)
   (f: (b -> b){frame_pres p f x y})
 : frame_preserving_upd r.p
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)))
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re))) in
+    (put r.pl x (one (refined_pcm r.re.refi)))
+    (put r.pl y (one (refined_pcm r.re.refi)))
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re.refi))) in
+  let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re.refi))) in
   pcm_lens_frame_pres r.pl x' y f;
-  r.u x' y' (frame_pres_mk_upd (refined_pcm r.re) x' y' (upd r.pl f))
+  r.re.u x' y' (frame_pres_mk_upd (refined_pcm r.re.refi) x' y' (upd r.pl f))
 
 let ref_upd_act (r: ref 'a 'p) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres 'p f x y})
 : M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y))
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index 086dad7ec10..092a05b61e7 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -84,23 +84,23 @@ val pcm_morphism_both
     (2) An element new_unit which satisfies the unit laws on the subset f
         and p.refine *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
-noeq type pcm_refinement #a (p: pcm a) = {
+noeq type pcm_refinement' #a (p: pcm a) = {
   f: a -> prop;
   f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
   new_one: (new_one:refine_t f{p.refine new_one});
   new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
 }
 
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement p): symrel (refine_t r.f) = composable p
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
 
-let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement p)
+let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
   (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
 = r.f_closed_comp x y; op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
 let refined_one_pcm a = p:pcm a{p.refine (one p)}
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): refined_one_pcm (refine_t r.f) = {
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
   p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
@@ -109,14 +109,14 @@ let refined_pcm (#p: pcm 'a) (r: pcm_refinement p): refined_one_pcm (refine_t r.
   refine = p.refine;
 }
 
-val pcm_refinement_comp_new_one
-  (#p: pcm 'a) (re: pcm_refinement p)
+val pcm_refinement'_comp_new_one
+  (#p: pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{composable p x y})
 : Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
          composable (refined_pcm re) x (op p re.new_one y))
 
-val pcm_refinement_compatible_closed
-  (#p: pcm 'a) (re: pcm_refinement p)
+val pcm_refinement'_compatible_closed
+  (#p: pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{compatible p x y})
 : Lemma (re.f y /\ compatible (refined_pcm re) x y)
 
@@ -199,22 +199,26 @@ let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost
   frame_preserving_upd p x y ->
   frame_preserving_upd q x' y'
 
-let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement p) =
+let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
   x: Ghost.erased (refine_t r.f) ->
   y: Ghost.erased (refine_t r.f) ->
   frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
 
+noeq type pcm_refinement #a (p: pcm a) = {
+  refi: pcm_refinement' p;
+  (** Needed to turn frame-preserving updates on (refined_pcm re) into
+      frame-preserving updates on p. To do so, also requires that p and q
+      be `refined_one_pcm`s *)
+  u: pcm_unrefinement refi;
+}
+
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
 noeq type ref a #b (q: refined_one_pcm b): Type = {
   p: refined_one_pcm a;
   re: pcm_refinement p;
-  (** Needed to turn frame-preserving updates on (refined_pcm re) into
-      frame-preserving updates on p. To do so, also requires that p and q
-      be `refined_one_pcm`s *)
-  u: pcm_unrefinement re;
-  pl: pcm_lens (refined_pcm re) q;
+  pl: pcm_lens (refined_pcm re.refi) q;
   r: Steel.Memory.ref a p;
 }
 
@@ -276,7 +280,7 @@ let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 = Some (|k, one (p k)|)
 
 let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_refinement (union_pcm p) = {
+: pcm_refinement' (union_pcm p) = {
   f = case_refinement_f p k;
   f_closed_comp = (fun x y -> ());
   new_one = case_refinement_new_one p k;
@@ -344,12 +348,12 @@ let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
 
 val extend_refinement
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
-: pcm_refinement p
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: pcm_refinement' p
 
 val pcm_lens_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
 : pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re)
 
 (** Isomorphisms *)
@@ -386,13 +390,13 @@ val pcm_iso_lens_comp
 (** The conjunction of two refinements *)
 
 val conj_refinement
-  (#p: pcm 'a) (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
-: pcm_refinement p
+  (#p: pcm 'a) (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+: pcm_refinement' p
 
 (** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
     refinement by the conjunction of re1 and re2 *)
-val pcm_refinement_conj_iso
-  (p: pcm 'a) (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+val pcm_refinement'_conj_iso
+  (p: pcm 'a) (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
 : pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2)
 
 val upd_across_pcm_iso
@@ -400,26 +404,26 @@ val upd_across_pcm_iso
 : frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
 
 val conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement p) (re2: pcm_refinement (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
 
 val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement q) (u: pcm_unrefinement re)
+  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
 
 (** The refinement of a ref *)
 
 val ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
-  (r: ref a p) (new_re: pcm_refinement p) (new_u: pcm_unrefinement new_re)
-: ref a (refined_pcm new_re)
+  (r: ref a p) (new_re: pcm_refinement p)
+: ref a (refined_pcm new_re.refi)
 
 (** Fundamental operations on references *)
 
 module A = Steel.Effect.Atomic
 
 let ref_focus (r: ref 'a 'p) (q: refined_one_pcm 'c) (l: pcm_lens 'p q): ref 'a q =
-  {p = r.p; re = r.re; u = r.u; pl = pcm_lens_comp r.pl l; r = r.r}
+  {p = r.p; re = r.re; pl = pcm_lens_comp r.pl l; r = r.r}
 
 val split (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 : Steel unit
@@ -458,24 +462,25 @@ val un_addr_of_lens
 val refine
   (#a:Type) (#b:Type) (#p: refined_one_pcm b)
   (r: ref a p)
-  (re: pcm_refinement p) (u: pcm_unrefinement re)
-  (x: Ghost.erased b{re.f x})
-: Steel (ref a (refined_pcm re))
+  (re: pcm_refinement p)
+  (x: Ghost.erased b{re.refi.f x})
+: Steel (ref a (refined_pcm re.refi))
     (r `pts_to` x)
     (fun r' -> r' `pts_to` Ghost.reveal x)
     (fun _ -> True)
-    (fun _ r' _ -> r' == ref_refine r re u)
+    (fun _ r' _ -> r' == ref_refine r re)
 
 val unrefine
   (#opened:Steel.Memory.inames)
   (#a:Type) (#b:Type) (#p: refined_one_pcm b)
   (r': ref a p)
-  (re: pcm_refinement p) (u: pcm_unrefinement re)
-  (r: ref a (refined_pcm re)) (x: Ghost.erased b{re.f x})
+  (re: pcm_refinement p)
+  (r: ref a (refined_pcm re.refi))
+  (x: Ghost.erased b{re.refi.f x})
 : A.SteelGhost unit opened
     (r `pts_to` Ghost.reveal x)
     (fun _ -> r' `pts_to` x)
-    (fun _ -> r == ref_refine r' re u)
+    (fun _ -> r == ref_refine r' re)
     (fun _ _ _ -> True)
 
 (** Generic read.

From 552f56b9f620f988ef36a867085b9028340b4c9b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 06:45:41 -0700
Subject: [PATCH 066/513] Make ref_focus abstract

---
 examples/steel/arraystructs/AggregateRef.fst  | 3 +++
 examples/steel/arraystructs/AggregateRef.fsti | 6 ++++--
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index 3cdb336c390..51a8187c8fb 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -532,6 +532,9 @@ let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
+let ref_focus r q l =
+  {p = r.p; re = r.re; pl = pcm_lens_comp r.pl l; r = r.r}
+
 let focus (r: ref 'a 'p)
   (#q: refined_one_pcm 'c)
   (l: pcm_lens 'p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index 092a05b61e7..65082eff103 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -422,8 +422,10 @@ val ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
 
 module A = Steel.Effect.Atomic
 
-let ref_focus (r: ref 'a 'p) (q: refined_one_pcm 'c) (l: pcm_lens 'p q): ref 'a q =
-  {p = r.p; re = r.re; pl = pcm_lens_comp r.pl l; r = r.r}
+val ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b)
+  (r: ref a p) (q: refined_one_pcm c) (l: pcm_lens p q)
+: ref a q
 
 val split (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 : Steel unit

From ce2470e64ce144045c9d8b8846764397489a35d7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 07:15:43 -0700
Subject: [PATCH 067/513] Make ref and misc lemmas abstract

---
 examples/steel/arraystructs/AggregateRef.fst  | 25 ++++++++----
 examples/steel/arraystructs/AggregateRef.fsti | 40 ++++---------------
 2 files changed, 25 insertions(+), 40 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index 51a8187c8fb..00d82a42fb0 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -3,30 +3,31 @@ module AggregateRef
 open FStar.PCM
 module P = FStar.PCM
 
+let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+
 let frame_pres_intro p f x y g =
   let _ = g in ()
 
 (** PCM morphisms *)
 
+val pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p
 let pcm_morphism_id #a #p = {
   f_refine = (fun _ -> ());
   f_one = (fun _ -> ());
   f_op = (fun _ _ -> ());
 }
 
+val pcm_morphism_comp
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (#f: 'b -> 'c) (#g: 'a -> 'b)
+  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
+: pcm_morphism (f `compose` g) p r
 let pcm_morphism_comp #a #b #c #p #q #r #f #g mf mg = {
   f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
   f_one = (fun () -> mg.f_one (); mf.f_one ());
   f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
 }
 
-open Aggregates
-let pcm_morphism_both #a #b #c #p #q #r #s #f #g mf mg = {
-  f_refine = (fun (x, y) -> mf.f_refine x; mg.f_refine y);
-  f_one = (fun () -> mg.f_one (); mf.f_one ());
-  f_op = (fun (x, y) (z, w) -> mf.f_op x z; mg.f_op y w);
-}
-
 let pcm_refinement'_comp_new_one #a #p re x y =
   re.new_one_is_refined_unit x;
   p.assoc_r x re.new_one y;
@@ -215,6 +216,16 @@ let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement' (either_
   new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
 }
 
+(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
+    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
+    This allows the reference to point to substructures of unions with known case. *)
+noeq type ref a #b (q: refined_one_pcm b): Type = {
+  p: refined_one_pcm a;
+  re: pcm_refinement p;
+  pl: pcm_lens (refined_pcm re.refi) q;
+  r: Steel.Memory.ref a p;
+}
+
 let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
 
 let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index 65082eff103..026b05d350b 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -3,12 +3,8 @@ module AggregateRef
 open FStar.PCM
 module P = FStar.PCM
 
-(** Misc. combinators *)
-let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
-let both (f: 'a -> 'c) (g: 'b -> 'd) ((x, y): 'a & 'b): 'c & 'd = (f x, g y)
-let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
-let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
-    
+open Aggregates
+
 (** The non-computational part of frame_preserving_upd
     TODO: move this and lemmas about this to FStar.PCM.fst *)
 let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
@@ -64,21 +60,6 @@ noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
       [SMTPat (composable p x y)]
 }
 
-val pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p
-
-val pcm_morphism_comp
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (#f: 'b -> 'c) (#g: 'a -> 'b)
-  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
-: pcm_morphism (f `compose` g) p r
-
-open Aggregates
-val pcm_morphism_both
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c) (#s: pcm 'd)
-  (#f: 'a -> 'c) (#g: 'b -> 'd)
-  (mf: pcm_morphism f p r) (mg: pcm_morphism g q s)
-: pcm_morphism (both f g) (p `pcm_times` q) (r `pcm_times` s)
-
 (** A refinement of a PCM (p: pcm a) consists of:
     (1) A set of elements f:(a -> prop) closed under (op p)
     (2) An element new_unit which satisfies the unit laws on the subset f
@@ -155,6 +136,7 @@ val lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c
     (1) get is a PCM morphism p -> q
     (2) put is a PCM morphism q×p -> p *)
 
+let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
 noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
   l: lens a b;
   get_morphism: pcm_morphism l.get p q;
@@ -193,8 +175,6 @@ val pcm_lens_comp
   (l: pcm_lens p q) (m: pcm_lens q r)
 : pcm_lens p r
 
-open FStar.FunctionalExtensionality
-
 let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
   frame_preserving_upd p x y ->
   frame_preserving_upd q x' y'
@@ -212,18 +192,10 @@ noeq type pcm_refinement #a (p: pcm a) = {
   u: pcm_unrefinement refi;
 }
 
-(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
-    This allows the reference to point to substructures of unions with known case. *)
-noeq type ref a #b (q: refined_one_pcm b): Type = {
-  p: refined_one_pcm a;
-  re: pcm_refinement p;
-  pl: pcm_lens (refined_pcm re.refi) q;
-  r: Steel.Memory.ref a p;
-}
-
 open Steel.Effect
 
+val ref (a:Type u#1) (#b:Type) (q: refined_one_pcm b): Type
+
 val pts_to
   (#a: Type u#1) (#b: Type u#b) (#p: refined_one_pcm b)
   (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
@@ -231,6 +203,7 @@ val pts_to
 
 (** A lens for the k-th field of an n-ary product *)
 
+open FStar.FunctionalExtensionality
 let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
   (f: restricted_t a f_ty)
 : restricted_t a f_ty
@@ -371,6 +344,7 @@ val iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c
 
 (** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
 
+let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
 val refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
 : iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g)
 

From 9c8a3c5141ca82582ba7afc96f0ff2192068425e Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 08:37:46 -0700
Subject: [PATCH 068/513] Move non-ref-related PCM constructs to separate
 modules

---
 examples/steel/arraystructs/AggregateRef.fst  | 508 +------------
 examples/steel/arraystructs/AggregateRef.fsti | 394 +---------
 examples/steel/arraystructs/Aggregates.fst    | 145 ----
 .../steel/arraystructs/FStar.PCM.Extras.fst   | 138 ++++
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 707 ++++++++++++++++++
 examples/steel/arraystructs/Lens.fst          |  45 ++
 examples/steel/arraystructs/LineStruct.fsti   |  10 +-
 examples/steel/arraystructs/PCM.POD.fst       |   2 +-
 examples/steel/arraystructs/PCM.POD.fsti      |   3 +-
 examples/steel/arraystructs/PointStruct.fst   |   2 +-
 examples/steel/arraystructs/PointStruct.fsti  |  10 +-
 11 files changed, 921 insertions(+), 1043 deletions(-)
 delete mode 100644 examples/steel/arraystructs/Aggregates.fst
 create mode 100644 examples/steel/arraystructs/FStar.PCM.Extras.fst
 create mode 100644 examples/steel/arraystructs/FStar.PCM.Extras.fsti
 create mode 100644 examples/steel/arraystructs/Lens.fst

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index 00d82a42fb0..c905d3faad7 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -1,221 +1,13 @@
 module AggregateRef
 
 open FStar.PCM
+open FStar.PCM.Extras
+open Lens
 module P = FStar.PCM
 
-let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
-
-let frame_pres_intro p f x y g =
-  let _ = g in ()
-
-(** PCM morphisms *)
-
-val pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p
-let pcm_morphism_id #a #p = {
-  f_refine = (fun _ -> ());
-  f_one = (fun _ -> ());
-  f_op = (fun _ _ -> ());
-}
-
-val pcm_morphism_comp
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (#f: 'b -> 'c) (#g: 'a -> 'b)
-  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
-: pcm_morphism (f `compose` g) p r
-let pcm_morphism_comp #a #b #c #p #q #r #f #g mf mg = {
-  f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
-  f_one = (fun () -> mg.f_one (); mf.f_one ());
-  f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
-}
-
-let pcm_refinement'_comp_new_one #a #p re x y =
-  re.new_one_is_refined_unit x;
-  p.assoc_r x re.new_one y;
-  re.f_closed_comp re.new_one y
-
-let pcm_refinement'_compatible_closed #a #p re x y =
-  let p' = refined_pcm re in
-  compatible_elim p x y (re.f y) (fun frame ->
-   re.f_closed_comp x frame; p.comm frame x);
-  compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    pcm_refinement'_comp_new_one re x frame_x;
-    let frame = op p re.new_one frame_x in
-    re.new_one_is_refined_unit x;
-    p.comm x frame_x;
-    p.assoc x re.new_one frame_x;
-    p.comm x (op p re.new_one frame_x);
-    compatible_intro p' x y (op p re.new_one frame_x))
-
-(** Lenses *)
-
-let lens_upd l f s = l.put (f (l.get s)) s
-
-(** The identity lens *)
-let const (x: 'a) (b: 'b): 'a = x
-let lens_id #a = {
-  get = id;
-  put = const;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** Lens composition *)
-let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
-let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
-  lens_upd l (m.put v) s
-let lens_comp l m = {
-  get = get_comp l m;
-  put = put_comp l m;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** PCM lenses *)
-
-let compatible_pcm_morphism #a #b #p #q f m x y =
-  compatible_elim p x y (compatible q (f x) (f y)) (fun frame_x ->
-  let _ = m.f_op frame_x x in
-  compatible_intro q (f x) (f y) (f frame_x))
-
-let pcm_lens_compatible_get #a #b #p #q l x y =
-  compatible_pcm_morphism l.l.get l.get_morphism x y
-    
-let pcm_lens_frame_pres #a #b #p #q l s v f =
-  frame_pres_intro p (upd l f) s (put l v s) (fun full ->
-    let _ = l.get_morphism.f_refine in
-    pcm_lens_compatible_get l s full;
-    l.put_morphism.f_refine (f (get l full), full);
-    let goal = frame_pres_on p (upd l f) s (put l v s) full in
-    compatible_elim p s full goal (fun frame_s ->
-    compatible_elim q v (f (get l full)) goal (fun frame_v ->
-    let frame_vs: a = put l frame_v frame_s in
-    l.put_morphism.f_op (v, s) (frame_v, frame_s);
-    p.comm frame_vs (put l v s);
-    q.comm v frame_v;
-    p.comm s frame_s;
-    compatible_intro p (put l v s) (upd l f full) frame_vs;
-    let aux (frame:a{composable p s frame})
-    : Lemma (composable p (put l v s) frame /\
-             (op p s frame == full ==> op p (put l v s) frame == upd l f full))
-    = l.get_morphism.f_op s frame;
-      l.put_morphism.f_op (v, s) (get l frame, frame);
-      let aux ()
-      : Lemma (requires op p s frame == full) 
-              (ensures op p (put l v s) frame == upd l f full)
-      = () in ()
-    in FStar.Classical.forall_intro aux)))
-
-let pcm_lens_id (#p: pcm 'a) = {
-  l = lens_id; 
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
-let pcm_lens_comp #a #b #c #p #q #r l m = {
-  l = lens_comp l.l m.l;
-  get_morphism = {
-    f_refine = (fun _ ->
-      let _ = l.get_morphism.f_refine in
-      let _ = m.get_morphism.f_refine in ());
-    f_one = (fun _ -> l.get_morphism.f_one (); m.get_morphism.f_one ());
-    f_op = (fun s t ->
-      l.get_morphism.f_op s t;
-      m.get_morphism.f_op (get l s) (get l t));
-  };
-  put_morphism = {
-    f_refine = (fun (v, s) ->
-      l.get_morphism.f_refine s;
-      m.put_morphism.f_refine (v, get l s);
-      l.put_morphism.f_refine (put m v (get l s), s));
-    f_one = (fun _ -> l.put_morphism.f_one (); m.put_morphism.f_one ());
-    f_op = (fun (v, s) (w, t) ->
-      l.get_morphism.f_op s t;
-      m.put_morphism.f_op (v, get l s) (w, get l t);
-      l.put_morphism.f_op (put m v (get l s), s) (put m w (get l t), t));
-  };
-}
-
 open FStar.FunctionalExtensionality
 open Steel.Effect
 
-(** Basic lenses *)
-
-let lens_fst_put (x:'a) (xy: 'a & 'b): 'a & 'b = (x, snd xy)
-let lens_fst #a #b : lens (a & b) a = {
-  get = fst;
-  put = lens_fst_put;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let pcm_lens_fst #a #b (p: pcm a) (q: pcm b): pcm_lens (p `pcm_times` q) p = {
-  l = lens_fst;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
-(** We can create lenses for unions if we know which case of the union we are in: *)
-
-let either_l a b = x:either a b{Inl? x}
-let lens_left_put (y: 'a) (x:either_l 'a 'b): either_l 'a 'b =
-  Inl y
-let lens_left #a #b : lens (either_l a b) a = {
-  get = Inl?.v;
-  put = lens_left_put;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let lens_left_fst #a #b #c: lens (either_l (a & b) c) a = lens_comp lens_left lens_fst
-let lens_fst_left #a #b #c: lens ((either_l a b) & c) a = lens_comp lens_fst lens_left
-
-(** A PCM for binary sums *)
-
-let either_composable (p: pcm 'a) (q: pcm 'b): symrel (option (either 'a 'b)) =
-  fun x y -> match x, y with
-    | None, _ | _, None -> True
-    | Some (Inl x), Some (Inl y) -> composable p x y
-    | Some (Inr x), Some (Inr y) -> composable q x y
-    | _, _ -> False
-let either_op (p: pcm 'a) (q: pcm 'b) (x: option (either 'a 'b))
-  (y: option (either 'a 'b){either_composable p q x y})
-: option (either 'a 'b) = match x, y with
-  | None, z | z, None -> z
-  | Some (Inl x), Some (Inl y) -> Some (Inl (op p x y))
-  | Some (Inr x), Some (Inr y) -> Some (Inr (op q x y))
-    
-let either_pcm (p: pcm 'a) (q: pcm 'b): pcm (option (either 'a 'b)) = P.({
-  p = {composable = either_composable p q; op = either_op p q; one = None};
-  comm = (fun x y -> match x, y with
-    | None, _ | _, None -> ()
-    | Some (Inl x), Some (Inl y) -> p.comm x y
-    | Some (Inr x), Some (Inr y) -> q.comm x y);
-  assoc = (fun x y z -> match x, y, z with
-    | Some (Inl x), Some (Inl y), Some (Inl z) -> p.assoc x y z
-    | Some (Inr x), Some (Inr y), Some (Inr z) -> q.assoc x y z
-    | _, _, _ -> ());
-  assoc_r = (fun x y z -> match x, y, z with
-    | Some (Inl x), Some (Inl y), Some (Inl z) -> p.assoc_r x y z
-    | Some (Inr x), Some (Inr y), Some (Inr z) -> q.assoc_r x y z
-    | _, _, _ -> ());
-  is_unit = (fun x -> ());
-  refine = (fun x -> match x with
-    | None -> True
-    | Some (Inl x) -> p.refine x
-    | Some (Inr x) -> q.refine x);
-})
-
-let inl_refinement (p: refined_one_pcm 'a) (q: pcm 'b): pcm_refinement' (either_pcm p q) = {
-  f = (fun (x: option (either 'a 'b)) -> Some? x /\ Inl? (Some?.v x));
-  f_closed_comp = (fun _ _ -> ());
-  new_one = Some (Inl #_ #'b (one p));
-  new_one_is_refined_unit = (fun (Some (Inl x)) -> p.is_unit x);
-}
-
 (** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
     The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
     This allows the reference to point to substructures of unions with known case. *)
@@ -231,294 +23,6 @@ let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to
 let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
   r.r `mpts_to` put r.pl v (one (refined_pcm r.re.refi))
 
-(** Refining a pcm_lens *)
-
-let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: 'a): prop
-= re.f (get l x)
-
-let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (s: refine_t (extend_refinement_f l re))
-: refine_t re.f
-= l.l.get s
-
-let lens_refine_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q)
-  (v: refine_t re.f) (s: refine_t (extend_refinement_f l re))
-: refine_t (extend_refinement_f l re)
-= l.l.put v s
-
-let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement' q)
-: lens (refine_t (extend_refinement_f l re)) (refine_t re.f) = {
-  get = lens_refine_get l re;
-  put = lens_refine_put l re;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-  (y: 'a{composable p x y})
-: Lemma (extend_refinement_f l re (op p x y))
-= l.get_morphism.f_op x y;
-  re.f_closed_comp (get l x) (get l y)
-
-let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: new_one:refine_t (extend_refinement_f l re){p.refine new_one}
-= l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
-
-let extend_refinement_new_one_is_refined_unit
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-: Lemma (composable p x (extend_refinement_new_one l re) /\
-         op p x (extend_refinement_new_one l re) == x)
-= re.new_one_is_refined_unit (get l x);
-  p.is_unit x;
-  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
-  
-let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_refinement' p = {
-  f = extend_refinement_f l re;
-  f_closed_comp = extend_refinement_f_closed l re;
-  new_one = extend_refinement_new_one l re;
-  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
-}
-
-let pcm_lens_refine_get_morphism_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_refine
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l re).get
-= l.get_morphism.f_refine
-
-let pcm_lens_refine_get_morphism_one
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_one
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l re).get
-= l.get_morphism.f_one
-
-let pcm_lens_refine_get_morphism_op
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_op
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
-    (lens_refine l re).get
-= l.get_morphism.f_op
-
-let pcm_lens_refine_put_morphism_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_refine
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l re).put)
-= fun (v, s) -> l.put_morphism.f_refine (v, s)
-
-let pcm_lens_refine_put_morphism_one
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_one
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l re).put)
-= l.put_morphism.f_one
-
-let pcm_lens_refine_put_morphism_op
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_op
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
-    (uncurry (lens_refine l re).put)
-= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
-
-let pcm_lens_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
-  l = lens_refine l re;
-  get_morphism = {
-    f_refine = pcm_lens_refine_get_morphism_refine l re;
-    f_one = pcm_lens_refine_get_morphism_one l re;
-    f_op = pcm_lens_refine_get_morphism_op l re;
-  };
-  put_morphism = {
-    f_refine = pcm_lens_refine_put_morphism_refine l re;
-    f_one = pcm_lens_refine_put_morphism_one l re;
-    f_op = pcm_lens_refine_put_morphism_op l re;
-  };
-}
-  
-(** Isomorphisms *)
-
-let iso_lens_comp_get (i: iso 'a 'b) (l: lens 'b 'c): 'a -> 'c = l.get `compose` i.fwd
-let iso_lens_comp_put (i: iso 'a 'b) (l: lens 'b 'c) (v: 'c) (s: 'a): 'a = i.bwd (l.put v (i.fwd s))
-let iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c = {
-  get = iso_lens_comp_get i l;
-  put = iso_lens_comp_put i l;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
-
-let refine_conj_iso_fwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-  (x: refine_t (conj f g))
-: refine_t g
-= x
-
-let refine_conj_iso_bwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-  (x: refine_t g)
-: refine_t (conj f g)
-= x
-
-let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-: iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g) = {
-  fwd = refine_conj_iso_fwd f g;
-  bwd = refine_conj_iso_bwd f g;
-  fwd_bwd = (fun _ -> ());
-  bwd_fwd = (fun _ -> ());
-}
-
-(** PCM isomorphisms *)
-
-let pcm_refinement'_conj_iso_i (p: pcm 'a)
-  (re1: pcm_refinement' p)
-  (re2: pcm_refinement' (refined_pcm re1))
-: iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
-  refine_conj_iso re1.f re2.f
-
-let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (i: pcm_iso p q) (l: pcm_lens q r)
-: pcm_lens p r = {
-  l = iso_lens_comp i.i l.l;
-  get_morphism = pcm_morphism_comp l.get_morphism i.fwd_morphism;
-  put_morphism = {
-    f_refine = (fun (v, s) ->
-      i.fwd_morphism.f_refine s; 
-      l.put_morphism.f_refine (v, i.i.fwd s);
-      i.bwd_morphism.f_refine (l.l.put v (i.i.fwd s)));
-    f_one = (fun () ->
-      i.fwd_morphism.f_one (); 
-      l.put_morphism.f_one ();
-      i.bwd_morphism.f_one ());
-    f_op = (fun (v, s) (w, t) -> 
-     i.fwd_morphism.f_op s t;
-     l.put_morphism.f_op (v, i.i.fwd s) (w, i.i.fwd t);
-     i.bwd_morphism.f_op (l.l.put v (i.i.fwd s)) (l.l.put w (i.i.fwd t)));
-  }
-}
-
-(** The conjunction of two refinements *)
-
-let conj_refinement_f (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-: 'a -> prop = conj #'a re1.f re2.f
-
-let conj_refinement_f_closed (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-  (y: 'a{composable p x y})
-: Lemma (conj_refinement_f re1 re2 (op p x y))
-= pcm_refinement'_comp_new_one re1 x y;
-  re1.f_closed_comp x (op p re1.new_one y);
-  pcm_refinement'_comp_new_one re2 x (op p re1.new_one y);
-  re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
-  p.assoc x re2.new_one (op p re1.new_one y);
-  re2.new_one_is_refined_unit x;
-  p.assoc x re1.new_one y;
-  re1.new_one_is_refined_unit x
-
-(* re1.new_one and re2.new_one both work; we go with re2 *)
-let conj_refinement_new_one (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-: refine_t (conj_refinement_f re1 re2)
-= re2.new_one
-
-let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
-         op p x (conj_refinement_new_one re1 re2) == x)
-= re2.new_one_is_refined_unit x
-
-let conj_refinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-: pcm_refinement' p = {
-  f = conj_refinement_f re1 re2;
-  f_closed_comp = conj_refinement_f_closed re1 re2;
-  new_one = conj_refinement_new_one re1 re2;
-  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
-}
-
-(** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
-    refinement by the conjunction of re1 and re2 *)
-let pcm_refinement'_conj_iso (p: pcm 'a)
-  (re1: pcm_refinement' p)
-  (re2: pcm_refinement' (refined_pcm re1))
-: pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2) = {
-  i = pcm_refinement'_conj_iso_i p re1 re2;
-  fwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  bwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
-let upd_across_pcm_iso (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
-: frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
-= fun f v ->
-  i.bwd_morphism.f_refine v;
-  compatible_pcm_morphism i.i.bwd i.bwd_morphism (i.i.fwd x) v;
-  let w = i.i.fwd (f (i.i.bwd v)) in
-  i.fwd_morphism.f_refine (f (i.i.bwd v));
-  compatible_pcm_morphism i.i.fwd i.fwd_morphism y (f (i.i.bwd v));
-  let aux (frame:'b{composable q (i.i.fwd x) frame})
-  : Lemma (composable q (i.i.fwd y) frame /\
-           (op q (i.i.fwd x) frame == v ==>
-            op q (i.i.fwd y) frame == w))
-  = i.bwd_morphism.f_op (i.i.fwd x) frame;
-    i.fwd_morphism.f_op y (i.i.bwd frame);
-    i.fwd_morphism.f_op x (i.i.bwd frame)
-  in FStar.Classical.forall_intro aux;
-  w
-
-let conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
-: pcm_unrefinement (conj_refinement #'a re1 re2)
-= fun x y ->
-  h1 (Ghost.reveal x) (Ghost.reveal y) `compose`
-  h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
-  upd_across_pcm_iso (pcm_refinement'_conj_iso p re1 re2) x y
-
-let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
-: pcm_unrefinement (extend_refinement l re)
-= fun x y f v ->
-  let re' = extend_refinement l re in
-  let p' = refined_pcm re' in
-  pcm_refinement'_compatible_closed re' x v;
-  pcm_lens_compatible_get l x v;
-  let w = f v in
-  let aux (frame:'a{composable p x frame})
-  : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
-  = pcm_refinement'_comp_new_one re' x frame;
-    let frame' = op p re'.new_one frame in
-    p.assoc y re'.new_one frame;
-    re'.new_one_is_refined_unit y;
-    p.assoc x re'.new_one frame;
-    re'.new_one_is_refined_unit x
-  in FStar.Classical.forall_intro aux;
-  w
-
 (** The refinement of a ref *)
 
 let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
@@ -543,7 +47,7 @@ let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-let ref_focus r q l =
+let ref_focus #a #b #c #p r #q l =
   {p = r.p; re = r.re; pl = pcm_lens_comp r.pl l; r = r.r}
 
 let focus (r: ref 'a 'p)
@@ -553,8 +57,8 @@ let focus (r: ref 'a 'p)
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
     (fun _ -> Ghost.reveal s == put l x (one 'p))
-    (fun _ r' _ -> r' == ref_focus r q l)
-= let r' = ref_focus r q l in
+    (fun _ r' _ -> r' == ref_focus r l)
+= let r' = ref_focus r l in
   A.change_slprop_rel  
     (r `pts_to` s)
     (r' `pts_to` x)
@@ -570,7 +74,7 @@ let unfocus #inames
 : A.SteelGhost unit inames
     (r `pts_to` x)
     (fun _ -> r' `pts_to` put l x (one p))
-    (requires fun _ -> r == ref_focus r' q l)
+    (requires fun _ -> r == ref_focus r' l)
     (ensures fun _ _ _ -> True)
 = A.change_slprop_rel  
     (r `pts_to` x)
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index 026b05d350b..a8a16530d35 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -1,196 +1,10 @@
 module AggregateRef
 
 open FStar.PCM
+open FStar.PCM.Extras
+open Lens
 module P = FStar.PCM
-
-open Aggregates
-
-(** The non-computational part of frame_preserving_upd
-    TODO: move this and lemmas about this to FStar.PCM.fst *)
-let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (v:'a{p.refine v /\ compatible p x v})
-= p.refine (f v) /\
-  compatible p y (f v) /\
-  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
-     composable p y frame /\
-     (op p x frame == v ==> op p y frame == f v))
-let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
-  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
-  frame_pres_on p f x y v
-
-(** Every function satisfying frame_pres is a frame_preserving_upd *)
-let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
-  (f:('a -> 'a){frame_pres p f x y})
-  : frame_preserving_upd p x y
-  = fun v -> f v
-(** The converse is not true, because a frame_preserving_upd's domain
-    is restricted to v:a{p.refine v /\ compatible p x v}. *)
-
-val frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (g:(v:'a{p.refine v /\ compatible p x v} -> 
-     Lemma (p.refine (f v) /\ compatible p y (f v) /\
-            (forall (frame:'a{composable p x frame}).
-              composable p y frame /\
-              (op p x frame == v ==> op p y frame == f v)))
-     [SMTPat (compatible p x v)]))
-: Lemma (frame_pres p f x y)
-
-(** TODO move PCM morphisms and refinements to FStar.PCM.fst? *)
-
-(** PCM morphisms *)
-
-let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
-let morphism_one (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  unit -> Lemma (f (one p) == one q)
-let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  x:'a -> y:'a ->
-    Lemma 
-      (requires composable p x y) 
-      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
-      [SMTPat (composable p x y)]
-
-noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
-  f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
-  f_one: morphism_one p q f;
-  f_op: x:a -> y:a ->
-    Lemma 
-      (requires composable p x y) 
-      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
-      [SMTPat (composable p x y)]
-}
-
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f
-        and p.refine *)
-let refine_t (f: 'a -> prop) = x:'a{f x}
-noeq type pcm_refinement' #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
-  new_one: (new_one:refine_t f{p.refine new_one});
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
-}
-
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
-
-let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_comp x y; op p x y
-
-(** Any refinement r for p can be used to construct a refined PCM with the same product
-    and composability predicate, but restricted to elements in r.f *)
-let refined_one_pcm a = p:pcm a{p.refine (one p)}
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
-  refine = p.refine;
-}
-
-val pcm_refinement'_comp_new_one
-  (#p: pcm 'a) (re: pcm_refinement' p)
-  (x: refine_t re.f) (y: 'a{composable p x y})
-: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
-         composable (refined_pcm re) x (op p re.new_one y))
-
-val pcm_refinement'_compatible_closed
-  (#p: pcm 'a) (re: pcm_refinement' p)
-  (x: refine_t re.f) (y: 'a{compatible p x y})
-: Lemma (re.f y /\ compatible (refined_pcm re) x y)
-
-(** A PCM refinement is well-formed if frame-preserving updates on the
-    refined PCM can be turned to frame-preserving updates on the
-    unrefined PCM *)
-
-(** Very well-behaved lenses *)
-noeq type lens (a: Type u#a) (b: Type u#b) = {
-  get: a -> b;
-  put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
-  put_get: s: a -> Lemma (put (get s) s == s);
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
-}
-let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
-  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
-  = l.get_put s v
-let put_get' (l: lens 'a 'b) (s: 'a)
-  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
-  = l.put_get s
-let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
-  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
-  = l.put_put s v w
-
-(** Updating the target of a lens *)
-val lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a
-
-(** The identity lens *)
-val lens_id: lens 'a 'a
-
-(** Lens composition *)
-val lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c
-
-(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
-    (1) get is a PCM morphism p -> q
-    (2) put is a PCM morphism q×p -> p *)
-
-let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
-noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
-  l: lens a b;
-  get_morphism: pcm_morphism l.get p q;
-  put_morphism: pcm_morphism (uncurry l.put) (q `pcm_times` p) p;
-}
-let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
-let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
-let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
-
-(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
-    frame-preserving updates on the source *)
-
-val compatible_pcm_morphism
-  (#p: pcm 'a) (#q: pcm 'b)
-  (f: 'a -> 'b) (m: pcm_morphism f p q)
-  (x y: Ghost.erased 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
-
-val pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
-
-val pcm_lens_frame_pres
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (s: 'a) (v: 'b) (f: 'b -> 'b)
-: Lemma
-    (requires frame_pres q f (get l s) v)
-    (ensures frame_pres p (upd l f) s (put l v s))
-    [SMTPat (frame_pres q f (get l s) v)]
-
-(** The identity lens is a pcm_lens *)
-val pcm_lens_id (#p: pcm 'a): pcm_lens p p
-
-(** pcm_lens composition is lens composition *)
-val pcm_lens_comp
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (l: pcm_lens p q) (m: pcm_lens q r)
-: pcm_lens p r
-
-let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
-  frame_preserving_upd p x y ->
-  frame_preserving_upd q x' y'
-
-let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
-  x: Ghost.erased (refine_t r.f) ->
-  y: Ghost.erased (refine_t r.f) ->
-  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
-
-noeq type pcm_refinement #a (p: pcm a) = {
-  refi: pcm_refinement' p;
-  (** Needed to turn frame-preserving updates on (refined_pcm re) into
-      frame-preserving updates on p. To do so, also requires that p and q
-      be `refined_one_pcm`s *)
-  u: pcm_unrefinement refi;
-}
+module A = Steel.Effect.Atomic
 
 open Steel.Effect
 
@@ -201,206 +15,20 @@ val pts_to
   (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
 : vprop
 
-(** A lens for the k-th field of an n-ary product *)
-
-open FStar.FunctionalExtensionality
-let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
-  (f: restricted_t a f_ty)
-: restricted_t a f_ty
-= on_domain a (fun k' -> if k = k' then x' else f k')
-let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
-let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
-  get = lens_field_get f k;
-  put = fun_upd k;
-  get_put = (fun s v -> ());
-  put_get = (fun s -> ext (fun_upd k (lens_field_get f k s) s) s (fun _ -> ()));
-  put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
-}
-
-(** lens_field is a pcm_lens *)
-
-(* TODO move to Aggregates.fst *)
-let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
-  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
-: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
-
-let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
-  l = lens_field f k;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {
-    f_refine = (fun _ -> ());
-    f_one = (fun _ ->
-      ext
-        (fun_upd k (one (p k)) (one (prod_pcm p)))
-        (one (prod_pcm p))
-        (fun k -> ()));
-    f_op = (fun (v, s) (w, t) ->
-      prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
-      ext
-        (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
-        (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
-        (fun _ -> ()));
-  }
-}
-
-(** The refinement of an n-ary union PCM to the k-th case *)
-
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
-  fun kx -> match kx with Some (|k', _|) -> k == k' | None -> False
-
-let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
-: refine_t (case_refinement_f p k)
-= Some (|k, one (p k)|)
-
-let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_refinement' (union_pcm p) = {
-  f = case_refinement_f p k;
-  f_closed_comp = (fun x y -> ());
-  new_one = case_refinement_new_one p k;
-  new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
-}
-
-(* TODO could be made abstract? *)
-let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement p k)
-= fun kx ky f kv ->
-  let p' = refined_pcm (case_refinement p k) in
-  let p = union_pcm p in
-  match kv with
-  | Some (|k', v|) ->
-    if k = k' then begin
-      let _ = Ghost.hide (
-        let Some (|k, x|) = Ghost.reveal kx in
-        let goal = compatible p' kx kv in
-        compatible_elim p kx kv goal (fun kx_frame -> match kx_frame with
-          | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
-          | None -> compatible_refl p' kx))
-      in
-      let kw = f kv in
-      let aux (frame:union b{composable p kx frame})
-      : Lemma (composable p ky frame /\
-               (op p kx frame == Some (|k, v|) ==>
-                op p ky frame == f (Some (|k, v|))))
-      = let Some (|_, w|) = f (Some (|k, v|)) in
-        match frame with
-        | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
-        | None ->
-          p'.is_unit kx;
-          assert (composable p' kx (one p'));
-          p'.is_unit ky
-      in FStar.Classical.forall_intro aux;
-      kw
-    end else None
-  | _ -> None
-
-(** A lens for the k-th case of an n-ary union *)
-
-let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
-  fun (Some (|_, v|)) -> v
-let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
-: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
-= fun _ -> Some (|k, v|)
-  
-let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f p k)) ('b k) = {
-  get = lens_case_get p k;
-  put = lens_case_put p k;
-  get_put = (fun s v -> ());
-  put_get = (fun s -> ());
-  put_put = (fun s v w -> ());
-}
-
-(** lens_case is a pcm_lens *)
-let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
-  l = lens_case p k;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
-(** Refining a pcm_lens *)
-
-val extend_refinement
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_refinement' p
-
-val pcm_lens_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re)
-
-(** Isomorphisms *)
-
-noeq type iso a b = {
-  fwd: a -> b;
-  bwd: b -> a;
-  fwd_bwd: x:b -> Lemma (fwd (bwd x) == x);
-  bwd_fwd: x:a -> Lemma (bwd (fwd x) == x);
-}
-let fwd_bwd' (i: iso 'a 'b) (x: 'b): Lemma (i.fwd (i.bwd x) == x) [SMTPat (i.fwd (i.bwd x))] = i.fwd_bwd x
-let bwd_fwd' (i: iso 'a 'b) (x: 'a): Lemma (i.bwd (i.fwd x) == x) [SMTPat (i.bwd (i.fwd x))] = i.bwd_fwd x
-
-val iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c
-
-(** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
-
-let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
-val refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-: iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g)
-
-(** PCM isomorphisms *)
-
-noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
-  i: iso a b;
-  fwd_morphism: pcm_morphism i.fwd p q;
-  bwd_morphism: pcm_morphism i.bwd q p;
-}
-
-val pcm_iso_lens_comp
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (i: pcm_iso p q) (l: pcm_lens q r)
-: pcm_lens p r
-
-(** The conjunction of two refinements *)
-
-val conj_refinement
-  (#p: pcm 'a) (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-: pcm_refinement' p
-
-(** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
-    refinement by the conjunction of re1 and re2 *)
-val pcm_refinement'_conj_iso
-  (p: pcm 'a) (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-: pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2)
-
-val upd_across_pcm_iso
-  (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
-: frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
-
-val conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
-  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
-: pcm_unrefinement (conj_refinement #'a re1 re2)
-
-val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
-: pcm_unrefinement (extend_refinement l re)
-
-(** The refinement of a ref *)
-
+(** (ref_refine r new_re) points to x
+    if r points to x and x satisfies refinement re *)
 val ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
   (r: ref a p) (new_re: pcm_refinement p)
 : ref a (refined_pcm new_re.refi)
 
-(** Fundamental operations on references *)
-
-module A = Steel.Effect.Atomic
-
+(** (ref_focus r l) points to x if r points to (put l x one) *)
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b)
-  (r: ref a p) (q: refined_one_pcm c) (l: pcm_lens p q)
+  (r: ref a p) (#q: refined_one_pcm c) (l: pcm_lens p q)
 : ref a q
 
+(** Fundamental operations on references *)
+
 val split (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 : Steel unit
     (r `pts_to` xy)
@@ -423,7 +51,7 @@ val addr_of_lens
       (r `pts_to` put l (one q) x) `star` 
       (s `pts_to` get l x))
     (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r q l)
+    (ensures fun _ r' _ -> r' == ref_focus r l)
 
 val un_addr_of_lens
   (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
@@ -432,7 +60,7 @@ val un_addr_of_lens
 : Steel unit
     ((r `pts_to` x) `star` (r' `pts_to` y))
     (fun s -> r `pts_to` put l y x)
-    (requires fun _ -> r' == ref_focus r q l /\ get l x == one q)
+    (requires fun _ -> r' == ref_focus r l /\ get l x == one q)
     (ensures fun _ _ _ -> True)
 
 val refine
diff --git a/examples/steel/arraystructs/Aggregates.fst b/examples/steel/arraystructs/Aggregates.fst
deleted file mode 100644
index 50857d2a2bb..00000000000
--- a/examples/steel/arraystructs/Aggregates.fst
+++ /dev/null
@@ -1,145 +0,0 @@
-module Aggregates
-
-open FStar.PCM
-
-/// We can define a PCM for structs with two fields {a; b} by defining
-/// a PCM for tuples (a & b) in terms of (potentially user-defined)
-/// PCMs for a and b.
-
-let pcm_times_comp (p: pcm 'a) (q: pcm 'b) (x y: 'a & 'b) : prop =
-  composable p (fst x) (fst y) /\ composable q (snd x) (snd y)
-
-let pcm_times_op (p: pcm 'a) (q: pcm 'b) (x: 'a & 'b) (y: ('a & 'b){pcm_times_comp p q x y}) : 'a & 'b =
-  (op p (fst x) (fst y), op q (snd x) (snd y))
-
-let pcm_times (p: pcm 'a) (q: pcm 'b): pcm ('a & 'b) = {
-  p = {composable = pcm_times_comp p q; op = pcm_times_op p q; one = (p.p.one, q.p.one)};
-  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
-  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
-  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
-  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
-  refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
-}
-
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let opt_pcm #a : pcm (option a) = {
-  p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun _ -> True);
-}
-
-/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
-
-open FStar.FunctionalExtensionality
-open FStar.Classical
-let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-  extensionality 'a 'b f g;
-  forall_intro fg
-
-let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
-  forall k. composable (p k) (x k) (y k)
-
-let prod_op (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: restricted_t 'a 'b
-= on_domain 'a (fun k -> op (p k) (x k) (y k))
-
-let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
-  on_domain 'a (fun k -> (p k).p.one)
-
-let prod_comm (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: Lemma (prod_op p x y == prod_op p y x)
-= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
-
-let prod_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
-: Lemma (prod_comp p x y /\
-         prod_comp p (prod_op p x y) z /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (x k) (y k) /\
-           composable (p k) (op (p k) (x k) (y k)) (z k)) 
-    [SMTPat (p k)]
-  = (p k).assoc (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
-: Lemma (prod_comp p y z /\
-         prod_comp p x (prod_op p y z) /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (y k) (z k) /\
-           composable (p k) (x k) (op (p k) (y k) (z k)))
-    [SMTPat (p k)]
-  = (p k).assoc_r (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
-: Lemma (prod_comp p x (prod_one p) /\
-         prod_op p x (prod_one p) == x)
-= let is_unit k
-  : Lemma (composable (p k) (x k) (prod_one p k))
-    [SMTPat (p k)]
-  = (p k).is_unit (x k)
-  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
-
-let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
-  forall k. (p k).refine (x k)
-
-let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) = {
-  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
-  comm = prod_comm p;
-  assoc = prod_assoc p;
-  assoc_r = prod_assoc_r p;
-  is_unit = prod_is_unit p;
-  refine = prod_refine p
-}
-
-/// Similarly, given a PCM for each k:a, we can model a-ary unions
-/// with an PCM for option (k:a & f k), where
-/// - None is the unit of the PCM
-/// - Some (k, x) is a union with tag k and content x
-
-let union (f:'a -> Type) = option (k:'a & f k)
-
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
-  | None, z | z, None -> True
-  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
-
-let union_op (p:(k:'a -> pcm ('b k))) (x: union 'b) (y: union 'b{union_comp p x y}) : union 'b = match x, y with
-  | None, z | z, None -> z
-  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
-
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union 'b) = {
-  p = {composable = union_comp p; op = union_op p; one = None};
-  comm = (fun x y -> match x, y with
-    | None, _ | _, None -> ()
-    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
-  assoc = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
-  assoc_r = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
-}
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
new file mode 100644
index 00000000000..2a6af2111ab
--- /dev/null
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -0,0 +1,138 @@
+module FStar.PCM.Extras
+
+open FStar.PCM
+open FStar.FunctionalExtensionality
+open FStar.Classical
+open Lens
+
+(** PCM morphisms *)
+
+let pcm_morphism_id #a #p = {
+  f_refine = (fun _ -> ());
+  f_one = (fun _ -> ());
+  f_op = (fun _ _ -> ());
+}
+
+let pcm_morphism_comp #a #b #c #p #q #r #f #g mf mg = {
+  f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
+  f_one = (fun () -> mg.f_one (); mf.f_one ());
+  f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
+}
+
+let compatible_pcm_morphism #a #b #p #q f m x y =
+  compatible_elim p x y (compatible q (f x) (f y)) (fun frame_x ->
+  let _ = m.f_op frame_x x in
+  compatible_intro q (f x) (f y) (f frame_x))
+
+(** Refinements *)
+
+let pcm_refinement'_comp_new_one #a #p re x y =
+  re.new_one_is_refined_unit x;
+  p.assoc_r x re.new_one y;
+  re.f_closed_comp re.new_one y
+
+let pcm_refinement'_compatible_closed #a #p re x y =
+  let p' = refined_pcm re in
+  compatible_elim p x y (re.f y) (fun frame ->
+   re.f_closed_comp x frame; p.comm frame x);
+  compatible_elim p x y (compatible p' x y) (fun frame_x ->
+    pcm_refinement'_comp_new_one re x frame_x;
+    let frame = op p re.new_one frame_x in
+    re.new_one_is_refined_unit x;
+    p.comm x frame_x;
+    p.assoc x re.new_one frame_x;
+    p.comm x (op p re.new_one frame_x);
+    compatible_intro p' x y (op p re.new_one frame_x))
+
+(** PCM lenses *)
+
+let pcm_lens_compatible_get #a #b #p #q l x y =
+  compatible_pcm_morphism l.l.get l.get_morphism x y
+    
+let pcm_lens_frame_pres #a #b #p #q l s v f =
+  frame_pres_intro p (upd l f) s (put l v s) (fun full ->
+    let _ = l.get_morphism.f_refine in
+    pcm_lens_compatible_get l s full;
+    l.put_morphism.f_refine (f (get l full), full);
+    let goal = frame_pres_on p (upd l f) s (put l v s) full in
+    compatible_elim p s full goal (fun frame_s ->
+    compatible_elim q v (f (get l full)) goal (fun frame_v ->
+    let frame_vs: a = put l frame_v frame_s in
+    l.put_morphism.f_op (v, s) (frame_v, frame_s);
+    p.comm frame_vs (put l v s);
+    q.comm v frame_v;
+    p.comm s frame_s;
+    compatible_intro p (put l v s) (upd l f full) frame_vs;
+    let aux (frame:a{composable p s frame})
+    : Lemma (composable p (put l v s) frame /\
+             (op p s frame == full ==> op p (put l v s) frame == upd l f full))
+    = l.get_morphism.f_op s frame;
+      l.put_morphism.f_op (v, s) (get l frame, frame);
+      let aux ()
+      : Lemma (requires op p s frame == full) 
+              (ensures op p (put l v s) frame == upd l f full)
+      = () in ()
+    in FStar.Classical.forall_intro aux)))
+
+(** Refinement of union to the kth case *)
+
+let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
+: pcm_unrefinement (case_refinement p k)
+= fun kx ky f kv ->
+  let p' = refined_pcm (case_refinement p k) in
+  let p = union_pcm p in
+  match kv with
+  | Some (|k', v|) ->
+    if k = k' then begin
+      let _ = Ghost.hide (
+        let Some (|k, x|) = Ghost.reveal kx in
+        let goal = compatible p' kx kv in
+        compatible_elim p kx kv goal (fun kx_frame -> match kx_frame with
+          | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
+          | None -> compatible_refl p' kx))
+      in
+      let kw = f kv in
+      let aux (frame:union b{composable p kx frame})
+      : Lemma (composable p ky frame /\
+               (op p kx frame == Some (|k, v|) ==>
+                op p ky frame == f (Some (|k, v|))))
+      = let Some (|_, w|) = f (Some (|k, v|)) in
+        match frame with
+        | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
+        | None ->
+          p'.is_unit kx;
+          assert (composable p' kx (one p'));
+          p'.is_unit ky
+      in FStar.Classical.forall_intro aux;
+      kw
+    end else None
+  | _ -> None
+
+let conj_unrefinement (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
+: pcm_unrefinement (conj_refinement #'a re1 re2)
+= fun x y ->
+  h1 (Ghost.reveal x) (Ghost.reveal y) `compose`
+  h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
+  upd_across_pcm_iso (pcm_refinement'_conj_iso p re1 re2) x y
+
+let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
+: pcm_unrefinement (extend_refinement l re)
+= fun x y f v ->
+  let re' = extend_refinement l re in
+  let p' = refined_pcm re' in
+  pcm_refinement'_compatible_closed re' x v;
+  pcm_lens_compatible_get l x v;
+  let w = f v in
+  let aux (frame:'a{composable p x frame})
+  : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
+  = pcm_refinement'_comp_new_one re' x frame;
+    let frame' = op p re'.new_one frame in
+    p.assoc y re'.new_one frame;
+    re'.new_one_is_refined_unit y;
+    p.assoc x re'.new_one frame;
+    re'.new_one_is_refined_unit x
+  in FStar.Classical.forall_intro aux;
+  w
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
new file mode 100644
index 00000000000..d69cf58e42c
--- /dev/null
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -0,0 +1,707 @@
+module FStar.PCM.Extras
+
+open FStar.PCM
+open Lens
+
+/// We can define a PCM for structs with two fields {a; b} by defining
+/// a PCM for tuples (a & b) in terms of (potentially user-defined)
+/// PCMs for a and b.
+
+let pcm_times_comp (p: pcm 'a) (q: pcm 'b) (x y: 'a & 'b) : prop =
+  composable p (fst x) (fst y) /\ composable q (snd x) (snd y)
+
+let pcm_times_op (p: pcm 'a) (q: pcm 'b) (x: 'a & 'b) (y: ('a & 'b){pcm_times_comp p q x y}) : 'a & 'b =
+  (op p (fst x) (fst y), op q (snd x) (snd y))
+
+let pcm_times (p: pcm 'a) (q: pcm 'b): pcm ('a & 'b) = {
+  p = {composable = pcm_times_comp p q; op = pcm_times_op p q; one = (p.p.one, q.p.one)};
+  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
+  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
+  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
+  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
+  refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
+}
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun _ -> True);
+}
+
+/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
+
+open FStar.FunctionalExtensionality
+open FStar.Classical
+let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality 'a 'b f g;
+  forall_intro fg
+
+let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
+  forall k. composable (p k) (x k) (y k)
+
+let prod_op (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: restricted_t 'a 'b
+= on_domain 'a (fun k -> op (p k) (x k) (y k))
+
+let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
+  on_domain 'a (fun k -> (p k).p.one)
+
+let prod_comm (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: Lemma (prod_op p x y == prod_op p y x)
+= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
+
+let prod_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+: Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)]
+  = (p k).assoc (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+: Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)]
+  = (p k).assoc_r (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
+: Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+= let is_unit k
+  : Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)]
+  = (p k).is_unit (x k)
+  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
+
+let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
+  forall k. (p k).refine (x k)
+
+let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) = {
+  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  comm = prod_comm p;
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
+
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+/// Similarly, given a PCM for each k:a, we can model a-ary unions
+/// with an PCM for option (k:a & f k), where
+/// - None is the unit of the PCM
+/// - Some (k, x) is a union with tag k and content x
+
+let union (f:'a -> Type) = option (k:'a & f k)
+
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
+  | None, z | z, None -> True
+  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
+
+let union_op (p:(k:'a -> pcm ('b k))) (x: union 'b) (y: union 'b{union_comp p x y}) : union 'b = match x, y with
+  | None, z | z, None -> z
+  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union 'b) = {
+  p = {composable = union_comp p; op = union_op p; one = None};
+  comm = (fun x y -> match x, y with
+    | None, _ | _, None -> ()
+    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
+  assoc = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
+  assoc_r = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
+}
+
+(** The non-computational part of frame_preserving_upd *)
+let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (v:'a{p.refine v /\ compatible p x v})
+= p.refine (f v) /\
+  compatible p y (f v) /\
+  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
+     composable p y frame /\
+     (op p x frame == v ==> op p y frame == f v))
+let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
+  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
+  frame_pres_on p f x y v
+
+(** Every function satisfying frame_pres is a frame_preserving_upd *)
+let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
+  (f:('a -> 'a){frame_pres p f x y})
+  : frame_preserving_upd p x y
+  = fun v -> f v
+(** The converse is not true, because a frame_preserving_upd's domain
+    is restricted to v:a{p.refine v /\ compatible p x v}. *)
+    
+let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
+  (g:(v:'a{p.refine v /\ compatible p x v} -> 
+     Lemma (p.refine (f v) /\ compatible p y (f v) /\
+            (forall (frame:'a{composable p x frame}).
+              composable p y frame /\
+              (op p x frame == v ==> op p y frame == f v)))
+     [SMTPat (compatible p x v)]))
+: Lemma (frame_pres p f x y)
+= let _ = g in ()
+
+(** PCM morphisms *)
+
+let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
+let morphism_one (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  unit -> Lemma (f (one p) == one q)
+let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
+  x:'a -> y:'a ->
+    Lemma 
+      (requires composable p x y) 
+      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
+      [SMTPat (composable p x y)]
+
+noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
+  f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
+  f_one: morphism_one p q f;
+  f_op: x:a -> y:a ->
+    Lemma 
+      (requires composable p x y) 
+      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
+      [SMTPat (composable p x y)]
+}
+
+val pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p
+
+let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
+val pcm_morphism_comp
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (#f: 'b -> 'c) (#g: 'a -> 'b)
+  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
+: pcm_morphism (f `compose` g) p r
+
+val compatible_pcm_morphism
+  (#p: pcm 'a) (#q: pcm 'b)
+  (f: 'a -> 'b) (m: pcm_morphism f p q)
+  (x y: Ghost.erased 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
+
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f
+        and p.refine *)
+let refine_t (f: 'a -> prop) = x:'a{f x}
+noeq type pcm_refinement' #a (p: pcm a) = {
+  f: a -> prop;
+  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
+  new_one: (new_one:refine_t f{p.refine new_one});
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+}
+
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
+
+let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
+  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
+= r.f_closed_comp x y; op p x y
+
+(** Any refinement r for p can be used to construct a refined PCM with the same product
+    and composability predicate, but restricted to elements in r.f *)
+let refined_one_pcm a = p:pcm a{p.refine (one p)}
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> r.new_one_is_refined_unit x);
+  refine = p.refine;
+}
+
+val pcm_refinement'_comp_new_one
+  (#p: pcm 'a) (re: pcm_refinement' p)
+  (x: refine_t re.f) (y: 'a{composable p x y})
+: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
+         composable (refined_pcm re) x (op p re.new_one y))
+
+val pcm_refinement'_compatible_closed
+  (#p: pcm 'a) (re: pcm_refinement' p)
+  (x: refine_t re.f) (y: 'a{compatible p x y})
+: Lemma (re.f y /\ compatible (refined_pcm re) x y)
+
+(** A PCM refinement is well-formed if frame-preserving updates on the
+    refined PCM can be turned to frame-preserving updates on the
+    unrefined PCM *)
+
+let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
+  frame_preserving_upd p x y ->
+  frame_preserving_upd q x' y'
+
+let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
+  x: Ghost.erased (refine_t r.f) ->
+  y: Ghost.erased (refine_t r.f) ->
+  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
+
+noeq type pcm_refinement #a (p: pcm a) = {
+  refi: pcm_refinement' p;
+  u: pcm_unrefinement refi;
+}
+
+(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
+    (1) get is a PCM morphism p -> q
+    (2) put is a PCM morphism q×p -> p *)
+
+let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
+noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
+  l: lens a b;
+  get_morphism: pcm_morphism l.get p q;
+  put_morphism: pcm_morphism (uncurry l.put) (q `pcm_times` p) p;
+}
+let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
+let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
+let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
+
+(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
+    frame-preserving updates on the source *)
+
+val pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
+: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
+
+val pcm_lens_frame_pres
+  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (s: 'a) (v: 'b) (f: 'b -> 'b)
+: Lemma
+    (requires frame_pres q f (get l s) v)
+    (ensures frame_pres p (upd l f) s (put l v s))
+    [SMTPat (frame_pres q f (get l s) v)]
+
+(** The identity lens is a pcm_lens *)
+let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
+  l = lens_id; 
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+}
+
+(** pcm_lens composition is lens composition *)
+let pcm_lens_comp
+  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (l: pcm_lens p q) (m: pcm_lens q r)
+: pcm_lens p r = {
+  l = lens_comp l.l m.l;
+  get_morphism = {
+    f_refine = (fun _ ->
+      let _ = l.get_morphism.f_refine in
+      let _ = m.get_morphism.f_refine in ());
+    f_one = (fun _ -> l.get_morphism.f_one (); m.get_morphism.f_one ());
+    f_op = (fun s t ->
+      l.get_morphism.f_op s t;
+      m.get_morphism.f_op (get l s) (get l t));
+  };
+  put_morphism = {
+    f_refine = (fun (v, s) ->
+      l.get_morphism.f_refine s;
+      m.put_morphism.f_refine (v, get l s);
+      l.put_morphism.f_refine (put m v (get l s), s));
+    f_one = (fun _ -> l.put_morphism.f_one (); m.put_morphism.f_one ());
+    f_op = (fun (v, s) (w, t) ->
+      l.get_morphism.f_op s t;
+      m.put_morphism.f_op (v, get l s) (w, get l t);
+      l.put_morphism.f_op (put m v (get l s), s) (put m w (get l t), t));
+  };
+}
+
+(** A lens for the k-th field of an n-ary product *)
+
+open FStar.FunctionalExtensionality
+let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
+  (f: restricted_t a f_ty)
+: restricted_t a f_ty
+= on_domain a (fun k' -> if k = k' then x' else f k')
+let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
+let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
+  get = lens_field_get f k;
+  put = fun_upd k;
+  get_put = (fun s v -> ());
+  put_get = (fun s -> ext (fun_upd k (lens_field_get f k s) s) s (fun _ -> ()));
+  put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
+}
+
+(** lens_field is a pcm_lens *)
+
+let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
+  l = lens_field f k;
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {
+    f_refine = (fun _ -> ());
+    f_one = (fun _ ->
+      ext
+        (fun_upd k (one (p k)) (one (prod_pcm p)))
+        (one (prod_pcm p))
+        (fun k -> ()));
+    f_op = (fun (v, s) (w, t) ->
+      prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
+      ext
+        (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
+        (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
+        (fun _ -> ()));
+  }
+}
+
+(** The refinement of an n-ary union PCM to the k-th case *)
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
+  fun kx -> match kx with Some (|k', _|) -> k == k' | None -> False
+
+let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
+: refine_t (case_refinement_f p k)
+= Some (|k, one (p k)|)
+
+let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+: pcm_refinement' (union_pcm p) = {
+  f = case_refinement_f p k;
+  f_closed_comp = (fun x y -> ());
+  new_one = case_refinement_new_one p k;
+  new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
+}
+
+val case_unrefinement (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
+: pcm_unrefinement (case_refinement p k)
+
+(** A lens for the k-th case of an n-ary union *)
+
+let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
+  fun (Some (|_, v|)) -> v
+let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
+: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
+= fun _ -> Some (|k, v|)
+  
+let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f p k)) ('b k) = {
+  get = lens_case_get p k;
+  put = lens_case_put p k;
+  get_put = (fun s v -> ());
+  put_get = (fun s -> ());
+  put_put = (fun s v w -> ());
+}
+
+(** lens_case is a pcm_lens *)
+let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+: pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
+  l = lens_case p k;
+  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+}
+
+(** Refining a pcm_lens *)
+
+let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q) (x: 'a): prop
+= re.f (get l x)
+
+let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q) (s: refine_t (extend_refinement_f l re))
+: refine_t re.f
+= l.l.get s
+
+let lens_refine_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q)
+  (v: refine_t re.f) (s: refine_t (extend_refinement_f l re))
+: refine_t (extend_refinement_f l re)
+= l.l.put v s
+
+let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement' q)
+: lens (refine_t (extend_refinement_f l re)) (refine_t re.f) = {
+  get = lens_refine_get l re;
+  put = lens_refine_put l re;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
+  (y: 'a{composable p x y})
+: Lemma (extend_refinement_f l re (op p x y))
+= l.get_morphism.f_op x y;
+  re.f_closed_comp (get l x) (get l y)
+
+let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: new_one:refine_t (extend_refinement_f l re){p.refine new_one}
+= l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
+
+let extend_refinement_new_one_is_refined_unit
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
+: Lemma (composable p x (extend_refinement_new_one l re) /\
+         op p x (extend_refinement_new_one l re) == x)
+= re.new_one_is_refined_unit (get l x);
+  p.is_unit x;
+  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+  
+let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: pcm_refinement' p = {
+  f = extend_refinement_f l re;
+  f_closed_comp = extend_refinement_f_closed l re;
+  new_one = extend_refinement_new_one l re;
+  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+}
+
+let pcm_lens_refine_get_morphism_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: morphism_refine
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l re).get
+= l.get_morphism.f_refine
+
+let pcm_lens_refine_get_morphism_one
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: morphism_one
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l re).get
+= l.get_morphism.f_one
+
+let pcm_lens_refine_get_morphism_op
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: morphism_op
+    (refined_pcm (extend_refinement l re))
+    (refined_pcm re)
+    (lens_refine l re).get
+= l.get_morphism.f_op
+
+let pcm_lens_refine_put_morphism_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: morphism_refine
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l re).put)
+= fun (v, s) -> l.put_morphism.f_refine (v, s)
+
+let pcm_lens_refine_put_morphism_one
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: morphism_one
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l re).put)
+= l.put_morphism.f_one
+
+let pcm_lens_refine_put_morphism_op
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: morphism_op
+    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
+    (refined_pcm (extend_refinement l re))
+    (uncurry (lens_refine l re).put)
+= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
+
+let pcm_lens_refine
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
+  l = lens_refine l re;
+  get_morphism = {
+    f_refine = pcm_lens_refine_get_morphism_refine l re;
+    f_one = pcm_lens_refine_get_morphism_one l re;
+    f_op = pcm_lens_refine_get_morphism_op l re;
+  };
+  put_morphism = {
+    f_refine = pcm_lens_refine_put_morphism_refine l re;
+    f_one = pcm_lens_refine_put_morphism_one l re;
+    f_op = pcm_lens_refine_put_morphism_op l re;
+  };
+}
+
+(** Isomorphisms *)
+
+noeq type iso a b = {
+  fwd: a -> b;
+  bwd: b -> a;
+  fwd_bwd: x:b -> Lemma (fwd (bwd x) == x);
+  bwd_fwd: x:a -> Lemma (bwd (fwd x) == x);
+}
+let fwd_bwd' (i: iso 'a 'b) (x: 'b): Lemma (i.fwd (i.bwd x) == x) [SMTPat (i.fwd (i.bwd x))] = i.fwd_bwd x
+let bwd_fwd' (i: iso 'a 'b) (x: 'a): Lemma (i.bwd (i.fwd x) == x) [SMTPat (i.bwd (i.fwd x))] = i.bwd_fwd x
+
+let iso_lens_comp_get (i: iso 'a 'b) (l: lens 'b 'c): 'a -> 'c = l.get `compose` i.fwd
+let iso_lens_comp_put (i: iso 'a 'b) (l: lens 'b 'c) (v: 'c) (s: 'a): 'a = i.bwd (l.put v (i.fwd s))
+let iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c = {
+  get = iso_lens_comp_get i l;
+  put = iso_lens_comp_put i l;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+(** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
+
+let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
+
+let refine_conj_iso_fwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+  (x: refine_t (conj f g))
+: refine_t g
+= x
+
+let refine_conj_iso_bwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+  (x: refine_t g)
+: refine_t (conj f g)
+= x
+
+let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
+: iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g) = {
+  fwd = refine_conj_iso_fwd f g;
+  bwd = refine_conj_iso_bwd f g;
+  fwd_bwd = (fun _ -> ());
+  bwd_fwd = (fun _ -> ());
+}
+
+(** PCM isomorphisms *)
+
+noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
+  i: iso a b;
+  fwd_morphism: pcm_morphism i.fwd p q;
+  bwd_morphism: pcm_morphism i.bwd q p;
+}
+
+let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
+  (i: pcm_iso p q) (l: pcm_lens q r)
+: pcm_lens p r = {
+  l = iso_lens_comp i.i l.l;
+  get_morphism = pcm_morphism_comp l.get_morphism i.fwd_morphism;
+  put_morphism = {
+    f_refine = (fun (v, s) ->
+      i.fwd_morphism.f_refine s; 
+      l.put_morphism.f_refine (v, i.i.fwd s);
+      i.bwd_morphism.f_refine (l.l.put v (i.i.fwd s)));
+    f_one = (fun () ->
+      i.fwd_morphism.f_one (); 
+      l.put_morphism.f_one ();
+      i.bwd_morphism.f_one ());
+    f_op = (fun (v, s) (w, t) -> 
+     i.fwd_morphism.f_op s t;
+     l.put_morphism.f_op (v, i.i.fwd s) (w, i.i.fwd t);
+     i.bwd_morphism.f_op (l.l.put v (i.i.fwd s)) (l.l.put w (i.i.fwd t)));
+  }
+}
+
+(** The conjunction of two refinements *)
+
+let conj_refinement_f (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+: 'a -> prop = conj #'a re1.f re2.f
+
+let conj_refinement_f_closed (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+  (y: 'a{composable p x y})
+: Lemma (conj_refinement_f re1 re2 (op p x y))
+= pcm_refinement'_comp_new_one re1 x y;
+  re1.f_closed_comp x (op p re1.new_one y);
+  pcm_refinement'_comp_new_one re2 x (op p re1.new_one y);
+  re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
+  p.assoc x re2.new_one (op p re1.new_one y);
+  re2.new_one_is_refined_unit x;
+  p.assoc x re1.new_one y;
+  re1.new_one_is_refined_unit x
+
+(* re1.new_one and re2.new_one both work; we go with re2 *)
+let conj_refinement_new_one (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+: refine_t (conj_refinement_f re1 re2)
+= re2.new_one
+
+let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
+         op p x (conj_refinement_new_one re1 re2) == x)
+= re2.new_one_is_refined_unit x
+
+let conj_refinement (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+: pcm_refinement' p = {
+  f = conj_refinement_f re1 re2;
+  f_closed_comp = conj_refinement_f_closed re1 re2;
+  new_one = conj_refinement_new_one re1 re2;
+  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
+}
+
+let pcm_refinement'_conj_iso_i (p: pcm 'a)
+  (re1: pcm_refinement' p)
+  (re2: pcm_refinement' (refined_pcm re1))
+: iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
+  refine_conj_iso re1.f re2.f
+  
+(** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
+    refinement by the conjunction of re1 and re2 *)
+let pcm_refinement'_conj_iso (p: pcm 'a)
+  (re1: pcm_refinement' p)
+  (re2: pcm_refinement' (refined_pcm re1))
+: pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2) = {
+  i = pcm_refinement'_conj_iso_i p re1 re2;
+  fwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+  bwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
+}
+
+let upd_across_pcm_iso
+  (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
+: frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
+= fun f v ->
+  i.bwd_morphism.f_refine v;
+  compatible_pcm_morphism i.i.bwd i.bwd_morphism (i.i.fwd x) v;
+  let w = i.i.fwd (f (i.i.bwd v)) in
+  i.fwd_morphism.f_refine (f (i.i.bwd v));
+  compatible_pcm_morphism i.i.fwd i.fwd_morphism y (f (i.i.bwd v));
+  let aux (frame:'b{composable q (i.i.fwd x) frame})
+  : Lemma (composable q (i.i.fwd y) frame /\
+           (op q (i.i.fwd x) frame == v ==>
+            op q (i.i.fwd y) frame == w))
+  = i.bwd_morphism.f_op (i.i.fwd x) frame;
+    i.fwd_morphism.f_op y (i.i.bwd frame);
+    i.fwd_morphism.f_op x (i.i.bwd frame)
+  in FStar.Classical.forall_intro aux;
+  w
+
+val conj_unrefinement (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
+: pcm_unrefinement (conj_refinement #'a re1 re2)
+
+val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
+: pcm_unrefinement (extend_refinement l re)
diff --git a/examples/steel/arraystructs/Lens.fst b/examples/steel/arraystructs/Lens.fst
new file mode 100644
index 00000000000..4294805c912
--- /dev/null
+++ b/examples/steel/arraystructs/Lens.fst
@@ -0,0 +1,45 @@
+module Lens
+
+(** Very well-behaved lenses *)
+noeq type lens (a: Type u#a) (b: Type u#b) = {
+  get: a -> b;
+  put: b -> a -> a;
+  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
+  put_get: s: a -> Lemma (put (get s) s == s);
+  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
+}
+let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
+  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
+  = l.get_put s v
+let put_get' (l: lens 'a 'b) (s: 'a)
+  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
+  = l.put_get s
+let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
+  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
+  = l.put_put s v w
+
+(** Lenses *)
+
+let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
+
+(** The identity lens *)
+let const (x: 'a) (b: 'b): 'a = x
+let lens_id #a: lens a a = {
+  get = id;
+  put = const;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
+
+(** Lens composition *)
+let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
+let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
+  lens_upd l (m.put v) s
+let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
+  get = get_comp l m;
+  put = put_comp l m;
+  get_put = (fun _ _ -> ());
+  put_get = (fun _ -> ());
+  put_put = (fun _ _ _ -> ());
+}
diff --git a/examples/steel/arraystructs/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
index 7539bc4ebf7..4b2db09ce55 100644
--- a/examples/steel/arraystructs/LineStruct.fsti
+++ b/examples/steel/arraystructs/LineStruct.fsti
@@ -1,8 +1,8 @@
 module LineStruct
 
-open Aggregates
 open AggregateRef
 open FStar.PCM
+open FStar.PCM.Extras
 open Steel.Effect
 open PointStruct
 
@@ -31,7 +31,7 @@ val _p2 : pcm_lens line_pcm point_pcm
 /// Taking pointers to the p1 and p2 fields of a line
 
 val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
-: SteelT (q:ref 'a point_pcm{q == ref_focus p point_pcm _p1})
+: SteelT (q:ref 'a point_pcm{q == ref_focus p _p1})
     (p `pts_to` mk_line p1 p2)
     (fun q ->
        (p `pts_to` mk_line (one point_pcm) p2) `star`
@@ -39,13 +39,13 @@ val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
 
 val un_addr_of_p1 (#p1 #p2: Ghost.erased point)
   (p: ref 'a line_pcm)
-  (q: ref 'a point_pcm{q == ref_focus p point_pcm _p1})
+  (q: ref 'a point_pcm{q == ref_focus p _p1})
 : SteelT unit
     ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
     (fun q -> p `pts_to` mk_line p1 p2)
 
 val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
-: SteelT (q:ref 'a point_pcm{q == ref_focus p point_pcm _p2})
+: SteelT (q:ref 'a point_pcm{q == ref_focus p _p2})
     (p `pts_to` mk_line p1 p2)
     (fun q ->
        (p `pts_to` mk_line p1 (one point_pcm)) `star`
@@ -53,7 +53,7 @@ val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
 
 val un_addr_of_p2 (#p1 #p2: Ghost.erased point)
   (p: ref 'a line_pcm)
-  (q: ref 'a point_pcm{q == ref_focus p point_pcm _p2})
+  (q: ref 'a point_pcm{q == ref_focus p _p2})
 : SteelT unit
     ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
     (fun q -> p `pts_to` mk_line p1 p2)
diff --git a/examples/steel/arraystructs/PCM.POD.fst b/examples/steel/arraystructs/PCM.POD.fst
index 8d3ca0e2ce0..41d6cd039e9 100644
--- a/examples/steel/arraystructs/PCM.POD.fst
+++ b/examples/steel/arraystructs/PCM.POD.fst
@@ -7,7 +7,7 @@ let some x = Some (Ghost.reveal x)
 let is_some v = match Ghost.reveal v with Some _ -> True | None -> False
 let some_v x = match x with Some v -> v
 
-let pod_pcm a = Aggregates.opt_pcm #a
+let pod_pcm a = FStar.PCM.Extras.opt_pcm #a
 
 let none_is_unit a = ()
 let is_some_some v = ()
diff --git a/examples/steel/arraystructs/PCM.POD.fsti b/examples/steel/arraystructs/PCM.POD.fsti
index b527479063b..1fbefc091d9 100644
--- a/examples/steel/arraystructs/PCM.POD.fsti
+++ b/examples/steel/arraystructs/PCM.POD.fsti
@@ -1,6 +1,7 @@
 module PCM.POD
 
 open FStar.PCM
+open FStar.PCM.Extras
 
 val pod: Type u#a -> Type u#a
 
@@ -10,7 +11,7 @@ val some: Ghost.erased 'a -> Ghost.erased (pod 'a)
 val is_some: Ghost.erased (pod 'a) -> prop
 val some_v: x:pod 'a{is_some x} -> GTot (y:'a{x == Ghost.reveal (some y)})
 
-val pod_pcm (a:Type): AggregateRef.refined_one_pcm (pod a)
+val pod_pcm (a:Type): refined_one_pcm (pod a)
 
 val none_is_unit (a:Type): Lemma (Ghost.reveal none == one (pod_pcm a)) [SMTPat (one (pod_pcm a))]
 
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 2f0255be2b3..fc3e1b78386 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -1,9 +1,9 @@
 module PointStruct
 
-open Aggregates
 open AggregateRef
 open PCM.POD
 open FStar.PCM
+open FStar.PCM.Extras
 open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index 22b94f8bba1..e17e0b89d0a 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -1,9 +1,9 @@
 module PointStruct
 
-open Aggregates
 open AggregateRef
 open PCM.POD
 open FStar.PCM
+open FStar.PCM.Extras
 open Steel.Effect
 
 /// Suppose we have the following struct representing 2d points:
@@ -29,7 +29,7 @@ val _y : pcm_lens point_pcm (pod_pcm int)
 /// Taking pointers to the x and y fields of a point
 
 val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _x})
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _x})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point none y) `star`
@@ -38,13 +38,13 @@ val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
 val un_addr_of_x
   (#x #y: Ghost.erased (pod int))
   (p: ref 'a point_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _x})
+  (q: ref 'a (pod_pcm int){q == ref_focus p _x})
 : SteelT unit
     ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
     (fun q -> p `pts_to` mk_point x y)
 
 val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _y})
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _y})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point x none) `star`
@@ -53,7 +53,7 @@ val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
 val un_addr_of_y
   (#x #y: Ghost.erased (pod int))
   (p: ref 'a point_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p (pod_pcm int) _y})
+  (q: ref 'a (pod_pcm int){q == ref_focus p _y})
 : SteelT unit
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)

From 4901394c0f1721ca17f68c3234f1268fd2f28316 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 08:51:39 -0700
Subject: [PATCH 069/513] refined_pcm --> refined_pcm'; (fun x -> refined_pcm'
 x.refi) --> refined_pcm

---
 examples/steel/arraystructs/AggregateRef.fst  | 54 ++++++++---------
 examples/steel/arraystructs/AggregateRef.fsti |  6 +-
 .../steel/arraystructs/FStar.PCM.Extras.fst   |  8 +--
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 58 ++++++++++---------
 4 files changed, 65 insertions(+), 61 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index c905d3faad7..a600c9db40b 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -14,20 +14,20 @@ open Steel.Effect
 noeq type ref a #b (q: refined_one_pcm b): Type = {
   p: refined_one_pcm a;
   re: pcm_refinement p;
-  pl: pcm_lens (refined_pcm re.refi) q;
+  pl: pcm_lens (refined_pcm re) q;
   r: Steel.Memory.ref a p;
 }
 
 let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
 
 let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
-  r.r `mpts_to` put r.pl v (one (refined_pcm r.re.refi))
+  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
 
 (** The refinement of a ref *)
 
 let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
   (r: ref a p) (new_re: pcm_refinement p)
-: ref a (refined_pcm new_re.refi) = {
+: ref a (refined_pcm new_re) = {
   p = r.p;
   re = {
     refi = conj_refinement r.re.refi (extend_refinement r.pl new_re.refi);
@@ -85,20 +85,20 @@ let unfocus #inames
 let split r xy x y =
   A.change_equal_slprop
     (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re.refi)))));
-  (refined_pcm r.re.refi).is_unit (one (refined_pcm r.re.refi));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re)))));
+  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
   r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re.refi))
-    (Ghost.reveal y, one (refined_pcm r.re.refi));
+    (Ghost.reveal x, one (refined_pcm r.re))
+    (Ghost.reveal y, one (refined_pcm r.re));
   Steel.PCMReference.split r.r
-    (put r.pl xy (one (refined_pcm r.re.refi)))
-    (put r.pl x (one (refined_pcm r.re.refi)))
-    (put r.pl y (one (refined_pcm r.re.refi)));
+    (put r.pl xy (one (refined_pcm r.re)))
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re.refi)))))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
     (r `pts_to` x);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re.refi)))))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
     (r `pts_to` y)
 
 let mgather
@@ -112,20 +112,20 @@ let mgather
 let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re.refi)))));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
   A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re.refi)))));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
   mgather r.r
-    (put r.pl x (one (refined_pcm r.re.refi)))
-    (put r.pl y (one (refined_pcm r.re.refi)));
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
   r.pl.get_morphism.f_op
-    (put r.pl x (one (refined_pcm r.re.refi)))
-    (put r.pl y (one (refined_pcm r.re.refi)));
-  (refined_pcm r.re.refi).is_unit (one (refined_pcm r.re.refi));
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)));
+  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
   r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re.refi))
-    (Ghost.reveal y, one (refined_pcm r.re.refi));
+    (Ghost.reveal x, one (refined_pcm r.re))
+    (Ghost.reveal y, one (refined_pcm r.re));
   A.change_equal_slprop _ (r `pts_to` op p x y)
 
 let peel (#p: refined_one_pcm 'b) (r: ref 'a p) (#q: refined_one_pcm 'c)
@@ -168,7 +168,7 @@ let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (fun _ -> r `pts_to` x)
     (requires fun _ -> ~ (Ghost.reveal x == one p))
     (ensures fun _ x' _ -> compatible p x x')
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re.refi))) in
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
   let v = Steel.PCMReference.read r.r x' in
   pcm_refinement'_compatible_closed r.re.refi x' v;
@@ -180,12 +180,12 @@ let ref_frame_preserving_upd #a #b
   (#p: refined_one_pcm b) (r: ref a p) (x y: Ghost.erased b)
   (f: (b -> b){frame_pres p f x y})
 : frame_preserving_upd r.p
-    (put r.pl x (one (refined_pcm r.re.refi)))
-    (put r.pl y (one (refined_pcm r.re.refi)))
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re.refi))) in
-  let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re.refi))) in
+    (put r.pl x (one (refined_pcm r.re)))
+    (put r.pl y (one (refined_pcm r.re)))
+= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
+  let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re))) in
   pcm_lens_frame_pres r.pl x' y f;
-  r.re.u x' y' (frame_pres_mk_upd (refined_pcm r.re.refi) x' y' (upd r.pl f))
+  r.re.u x' y' (frame_pres_mk_upd (refined_pcm r.re) x' y' (upd r.pl f))
 
 let ref_upd_act (r: ref 'a 'p) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres 'p f x y})
 : M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y))
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index a8a16530d35..85e9eec6760 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -19,7 +19,7 @@ val pts_to
     if r points to x and x satisfies refinement re *)
 val ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
   (r: ref a p) (new_re: pcm_refinement p)
-: ref a (refined_pcm new_re.refi)
+: ref a (refined_pcm new_re)
 
 (** (ref_focus r l) points to x if r points to (put l x one) *)
 val ref_focus
@@ -68,7 +68,7 @@ val refine
   (r: ref a p)
   (re: pcm_refinement p)
   (x: Ghost.erased b{re.refi.f x})
-: Steel (ref a (refined_pcm re.refi))
+: Steel (ref a (refined_pcm re))
     (r `pts_to` x)
     (fun r' -> r' `pts_to` Ghost.reveal x)
     (fun _ -> True)
@@ -79,7 +79,7 @@ val unrefine
   (#a:Type) (#b:Type) (#p: refined_one_pcm b)
   (r': ref a p)
   (re: pcm_refinement p)
-  (r: ref a (refined_pcm re.refi))
+  (r: ref a (refined_pcm re))
   (x: Ghost.erased b{re.refi.f x})
 : A.SteelGhost unit opened
     (r `pts_to` Ghost.reveal x)
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
index 2a6af2111ab..c8a6a2f921f 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -32,7 +32,7 @@ let pcm_refinement'_comp_new_one #a #p re x y =
   re.f_closed_comp re.new_one y
 
 let pcm_refinement'_compatible_closed #a #p re x y =
-  let p' = refined_pcm re in
+  let p' = refined_pcm' re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
@@ -79,7 +79,7 @@ let pcm_lens_frame_pres #a #b #p #q l s v f =
 let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
 : pcm_unrefinement (case_refinement p k)
 = fun kx ky f kv ->
-  let p' = refined_pcm (case_refinement p k) in
+  let p' = refined_pcm' (case_refinement p k) in
   let p = union_pcm p in
   match kv with
   | Some (|k', v|) ->
@@ -109,7 +109,7 @@ let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   | _ -> None
 
 let conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
 = fun x y ->
@@ -122,7 +122,7 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
 : pcm_unrefinement (extend_refinement l re)
 = fun x y f v ->
   let re' = extend_refinement l re in
-  let p' = refined_pcm re' in
+  let p' = refined_pcm' re' in
   pcm_refinement'_compatible_closed re' x v;
   pcm_lens_compatible_get l x v;
   let w = f v in
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index d69cf58e42c..7dc5dd3b403 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -238,7 +238,7 @@ let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
 let refined_one_pcm a = p:pcm a{p.refine (one p)}
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
+let refined_pcm' (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
   p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
   comm = (fun x y -> p.comm x y);
   assoc = (fun x y z -> p.assoc x y z);
@@ -251,12 +251,12 @@ val pcm_refinement'_comp_new_one
   (#p: pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{composable p x y})
 : Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
-         composable (refined_pcm re) x (op p re.new_one y))
+         composable (refined_pcm' re) x (op p re.new_one y))
 
 val pcm_refinement'_compatible_closed
   (#p: pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{compatible p x y})
-: Lemma (re.f y /\ compatible (refined_pcm re) x y)
+: Lemma (re.f y /\ compatible (refined_pcm' re) x y)
 
 (** A PCM refinement is well-formed if frame-preserving updates on the
     refined PCM can be turned to frame-preserving updates on the
@@ -269,13 +269,17 @@ let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost
 let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
   x: Ghost.erased (refine_t r.f) ->
   y: Ghost.erased (refine_t r.f) ->
-  frame_pres_lift (refined_pcm r) x y p (Ghost.reveal x) (Ghost.reveal y)
+  frame_pres_lift (refined_pcm' r) x y p (Ghost.reveal x) (Ghost.reveal y)
 
 noeq type pcm_refinement #a (p: pcm a) = {
   refi: pcm_refinement' p;
   u: pcm_unrefinement refi;
 }
 
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p)
+: refined_one_pcm (refine_t r.refi.f)
+= refined_pcm' r.refi
+
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
     (1) get is a PCM morphism p -> q
     (2) put is a PCM morphism q×p -> p *)
@@ -414,7 +418,7 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
 
 (** lens_case is a pcm_lens *)
 let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_lens (refined_pcm (case_refinement p k)) (p k) = {
+: pcm_lens (refined_pcm' (case_refinement p k)) (p k) = {
   l = lens_case p k;
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
@@ -480,8 +484,8 @@ let pcm_lens_refine_get_morphism_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_refine
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
+    (refined_pcm' (extend_refinement l re))
+    (refined_pcm' re)
     (lens_refine l re).get
 = l.get_morphism.f_refine
 
@@ -489,8 +493,8 @@ let pcm_lens_refine_get_morphism_one
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_one
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
+    (refined_pcm' (extend_refinement l re))
+    (refined_pcm' re)
     (lens_refine l re).get
 = l.get_morphism.f_one
 
@@ -498,8 +502,8 @@ let pcm_lens_refine_get_morphism_op
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_op
-    (refined_pcm (extend_refinement l re))
-    (refined_pcm re)
+    (refined_pcm' (extend_refinement l re))
+    (refined_pcm' re)
     (lens_refine l re).get
 = l.get_morphism.f_op
 
@@ -507,8 +511,8 @@ let pcm_lens_refine_put_morphism_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_refine
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
+    (refined_pcm' re `pcm_times` refined_pcm' (extend_refinement l re))
+    (refined_pcm' (extend_refinement l re))
     (uncurry (lens_refine l re).put)
 = fun (v, s) -> l.put_morphism.f_refine (v, s)
 
@@ -516,8 +520,8 @@ let pcm_lens_refine_put_morphism_one
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_one
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
+    (refined_pcm' re `pcm_times` refined_pcm' (extend_refinement l re))
+    (refined_pcm' (extend_refinement l re))
     (uncurry (lens_refine l re).put)
 = l.put_morphism.f_one
 
@@ -525,15 +529,15 @@ let pcm_lens_refine_put_morphism_op
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : morphism_op
-    (refined_pcm re `pcm_times` refined_pcm (extend_refinement l re))
-    (refined_pcm (extend_refinement l re))
+    (refined_pcm' re `pcm_times` refined_pcm' (extend_refinement l re))
+    (refined_pcm' (extend_refinement l re))
     (uncurry (lens_refine l re).put)
 = fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
 
 let pcm_lens_refine
   (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_lens (refined_pcm (extend_refinement l re)) (refined_pcm re) = {
+: pcm_lens (refined_pcm' (extend_refinement l re)) (refined_pcm' re) = {
   l = lens_refine l re;
   get_morphism = {
     f_refine = pcm_lens_refine_get_morphism_refine l re;
@@ -622,11 +626,11 @@ let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 (** The conjunction of two refinements *)
 
 let conj_refinement_f (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : 'a -> prop = conj #'a re1.f re2.f
 
 let conj_refinement_f_closed (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (x: refine_t (conj_refinement_f re1 re2))
   (y: 'a{composable p x y})
 : Lemma (conj_refinement_f re1 re2 (op p x y))
@@ -641,19 +645,19 @@ let conj_refinement_f_closed (#p: pcm 'a)
 
 (* re1.new_one and re2.new_one both work; we go with re2 *)
 let conj_refinement_new_one (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : refine_t (conj_refinement_f re1 re2)
 = re2.new_one
 
 let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (x: refine_t (conj_refinement_f re1 re2))
 : Lemma (composable p x (conj_refinement_new_one re1 re2) /\
          op p x (conj_refinement_new_one re1 re2) == x)
 = re2.new_one_is_refined_unit x
 
 let conj_refinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_refinement' p = {
   f = conj_refinement_f re1 re2;
   f_closed_comp = conj_refinement_f_closed re1 re2;
@@ -663,7 +667,7 @@ let conj_refinement (#p: pcm 'a)
 
 let pcm_refinement'_conj_iso_i (p: pcm 'a)
   (re1: pcm_refinement' p)
-  (re2: pcm_refinement' (refined_pcm re1))
+  (re2: pcm_refinement' (refined_pcm' re1))
 : iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
   refine_conj_iso re1.f re2.f
   
@@ -671,8 +675,8 @@ let pcm_refinement'_conj_iso_i (p: pcm 'a)
     refinement by the conjunction of re1 and re2 *)
 let pcm_refinement'_conj_iso (p: pcm 'a)
   (re1: pcm_refinement' p)
-  (re2: pcm_refinement' (refined_pcm re1))
-: pcm_iso (refined_pcm (conj_refinement re1 re2)) (refined_pcm re2) = {
+  (re2: pcm_refinement' (refined_pcm' re1))
+: pcm_iso (refined_pcm' (conj_refinement re1 re2)) (refined_pcm' re2) = {
   i = pcm_refinement'_conj_iso_i p re1 re2;
   fwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   bwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
@@ -698,7 +702,7 @@ let upd_across_pcm_iso
   w
 
 val conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm re1))
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
 

From 1cb9dba800284b204971948fb4a2415764540a5e Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 09:01:45 -0700
Subject: [PATCH 070/513] PCM.POD.fst -> FStar.PCM.POD.fst; r.refi.f -->
 refinement_f r

---
 examples/steel/arraystructs/AggregateRef.fst  | 46 +++++++++++++++++++
 examples/steel/arraystructs/AggregateRef.fsti | 24 ----------
 .../arraystructs/AggregateRefExamples.fst     |  2 +-
 .../steel/arraystructs/FStar.PCM.Extras.fsti  |  4 +-
 .../{PCM.POD.fst => FStar.PCM.POD.fst}        |  2 +-
 .../{PCM.POD.fsti => FStar.PCM.POD.fsti}      |  2 +-
 examples/steel/arraystructs/PointStruct.fst   |  2 +-
 examples/steel/arraystructs/PointStruct.fsti  |  2 +-
 8 files changed, 54 insertions(+), 30 deletions(-)
 rename examples/steel/arraystructs/{PCM.POD.fst => FStar.PCM.POD.fst} (94%)
 rename examples/steel/arraystructs/{PCM.POD.fsti => FStar.PCM.POD.fsti} (97%)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index a600c9db40b..c2b1c97e68e 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -154,14 +154,60 @@ let un_addr_of_lens #a #b #c #p #q r' r l x y =
   l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one p);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
+val refine
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
+  (r: ref a p)
+  (re: pcm_refinement p)
+  (x: Ghost.erased b{refinement_f re x})
+: Steel (ref a (refined_pcm re))
+    (r `pts_to` x)
+    (fun r' -> r' `pts_to` Ghost.reveal x)
+    (fun _ -> True)
+    (fun _ r' _ -> r' == ref_refine r re)
 let refine r re x =
   let r' = ref_refine r re in
   A.change_equal_slprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
   A.return r'
 
+val unrefine
+  (#opened:Steel.Memory.inames)
+  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
+  (r': ref a p)
+  (re: pcm_refinement p)
+  (r: ref a (refined_pcm re))
+  (x: Ghost.erased b{refinement_f re x})
+: A.SteelGhost unit opened
+    (r `pts_to` Ghost.reveal x)
+    (fun _ -> r' `pts_to` x)
+    (fun _ -> r == ref_refine r' re)
+    (fun _ _ _ -> True)
 let unrefine #inames r' re r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
+(*
+val addr_of_union_lens
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
+  (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
+  (x: Ghost.erased b{refinement_f re x})
+: Steel (ref a q)
+    (r `pts_to` x)
+    (fun s ->
+      (r `pts_to` put l (one q) x) `star` 
+      (s `pts_to` get l x))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r l)
+
+val un_addr_of_union_lens
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
+  (r': ref a q) (r: ref a p) (l: pcm_lens p q)
+  (x: Ghost.erased b) (y: Ghost.erased c)
+: Steel unit
+    ((r `pts_to` x) `star` (r' `pts_to` y))
+    (fun s -> r `pts_to` put l y x)
+    (requires fun _ -> r' == ref_focus r l /\ get l x == one q)
+    (ensures fun _ _ _ -> True)
+*)
+
 let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
 : Steel 'b
     (r `pts_to` x)
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index 85e9eec6760..e3b3d7ab8fb 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -63,30 +63,6 @@ val un_addr_of_lens
     (requires fun _ -> r' == ref_focus r l /\ get l x == one q)
     (ensures fun _ _ _ -> True)
 
-val refine
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
-  (r: ref a p)
-  (re: pcm_refinement p)
-  (x: Ghost.erased b{re.refi.f x})
-: Steel (ref a (refined_pcm re))
-    (r `pts_to` x)
-    (fun r' -> r' `pts_to` Ghost.reveal x)
-    (fun _ -> True)
-    (fun _ r' _ -> r' == ref_refine r re)
-
-val unrefine
-  (#opened:Steel.Memory.inames)
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
-  (r': ref a p)
-  (re: pcm_refinement p)
-  (r: ref a (refined_pcm re))
-  (x: Ghost.erased b{re.refi.f x})
-: A.SteelGhost unit opened
-    (r `pts_to` Ghost.reveal x)
-    (fun _ -> r' `pts_to` x)
-    (fun _ -> r == ref_refine r' re)
-    (fun _ _ _ -> True)
-
 (** Generic read.
 
     Without the precondition ~ (x == one), it would be possible to read
diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index f3ac3e6c201..7df765d0706 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -7,7 +7,7 @@ module A = Steel.Effect.Atomic
 
 /// Example 1: swapping the coordinates of a 2d point
 
-open PCM.POD
+open FStar.PCM.POD
 open PointStruct
 
 /// We can write the following function that swaps the x and y fields of a given point:
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index 7dc5dd3b403..baa8ca36410 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -276,8 +276,10 @@ noeq type pcm_refinement #a (p: pcm a) = {
   u: pcm_unrefinement refi;
 }
 
+let refinement_f (#p: pcm 'a) (r: pcm_refinement p) = r.refi.f
+
 let refined_pcm (#p: pcm 'a) (r: pcm_refinement p)
-: refined_one_pcm (refine_t r.refi.f)
+: refined_one_pcm (refine_t (refinement_f r))
 = refined_pcm' r.refi
 
 (** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
diff --git a/examples/steel/arraystructs/PCM.POD.fst b/examples/steel/arraystructs/FStar.PCM.POD.fst
similarity index 94%
rename from examples/steel/arraystructs/PCM.POD.fst
rename to examples/steel/arraystructs/FStar.PCM.POD.fst
index 41d6cd039e9..1d0a0daec2e 100644
--- a/examples/steel/arraystructs/PCM.POD.fst
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fst
@@ -1,4 +1,4 @@
-module PCM.POD
+module FStar.PCM.POD
 
 let pod a = option a
 
diff --git a/examples/steel/arraystructs/PCM.POD.fsti b/examples/steel/arraystructs/FStar.PCM.POD.fsti
similarity index 97%
rename from examples/steel/arraystructs/PCM.POD.fsti
rename to examples/steel/arraystructs/FStar.PCM.POD.fsti
index 1fbefc091d9..4caaeea2db9 100644
--- a/examples/steel/arraystructs/PCM.POD.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fsti
@@ -1,4 +1,4 @@
-module PCM.POD
+module FStar.PCM.POD
 
 open FStar.PCM
 open FStar.PCM.Extras
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index fc3e1b78386..ed1f8952274 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -1,7 +1,7 @@
 module PointStruct
 
 open AggregateRef
-open PCM.POD
+open FStar.PCM.POD
 open FStar.PCM
 open FStar.PCM.Extras
 open FStar.FunctionalExtensionality
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index e17e0b89d0a..06e8f748f1f 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -1,7 +1,7 @@
 module PointStruct
 
 open AggregateRef
-open PCM.POD
+open FStar.PCM.POD
 open FStar.PCM
 open FStar.PCM.Extras
 open Steel.Effect

From 9c1da1620f004ee4c8473a1b52f5b27f85bcf255 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 09:19:32 -0700
Subject: [PATCH 071/513] un_addr -> unaddr

---
 examples/steel/arraystructs/AggregateRef.fst  | 34 +++++++++++--------
 examples/steel/arraystructs/AggregateRef.fsti |  2 +-
 examples/steel/arraystructs/LineStruct.fst    |  8 ++---
 examples/steel/arraystructs/LineStruct.fsti   |  4 +--
 examples/steel/arraystructs/PointStruct.fst   |  8 ++---
 examples/steel/arraystructs/PointStruct.fsti  |  4 +--
 6 files changed, 32 insertions(+), 28 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index c2b1c97e68e..7171bbff98f 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -145,7 +145,7 @@ let addr_of_lens #a #b #c #p r l x =
   peel r l x;
   focus r l (put l (get l x) (one p)) (get l x)
 
-let un_addr_of_lens #a #b #c #p #q r' r l x y =
+let unaddr_of_lens #a #b #c #p #q r' r l x y =
   unfocus r' r l y;
   gather r x (put l y (one p));
   q.is_unit (Ghost.reveal y);
@@ -184,29 +184,33 @@ val unrefine
 let unrefine #inames r' re r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
-(*
 val addr_of_union_lens
   (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
   (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
   (x: Ghost.erased b{refinement_f re x})
 : Steel (ref a q)
     (r `pts_to` x)
-    (fun s ->
-      (r `pts_to` put l (one q) x) `star` 
-      (s `pts_to` get l x))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r l)
+    (fun r' -> r' `pts_to` get l x)
+    (requires fun _ -> Ghost.reveal x == put l (get l x) (one (refined_pcm re)))
+    (ensures fun _ r' _ -> r' == ref_focus (ref_refine r re) l)
+let addr_of_union_lens #a #b #c #p #q r #re l x =
+  let refined_r = refine r re x in
+  focus refined_r l (Ghost.reveal x) (get l x)
 
-val un_addr_of_union_lens
+(*
+val unaddr_of_union_lens
   (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (r': ref a q) (r: ref a p) (l: pcm_lens p q)
-  (x: Ghost.erased b) (y: Ghost.erased c)
-: Steel unit
-    ((r `pts_to` x) `star` (r' `pts_to` y))
-    (fun s -> r `pts_to` put l y x)
-    (requires fun _ -> r' == ref_focus r l /\ get l x == one q)
+  (r': ref a q) (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
+  (y: Ghost.erased c)
+: Steel (ref a p)
+    (r' `pts_to` y)
+    (fun r -> r `pts_to` put l y (one (refined_pcm re)))
+    (requires fun _ -> r' == ref_focus (ref_refine r re) l)
     (ensures fun _ _ _ -> True)
-*)
+let unaddr_of_union_lens #a #b #c #p #q r' r #re l y =
+  let r' = refine r re x in
+  focus r' l (Ghost.reveal x) (get l x)
+  *)
 
 let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
 : Steel 'b
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index e3b3d7ab8fb..7202069ecf7 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -53,7 +53,7 @@ val addr_of_lens
     (requires fun _ -> True)
     (ensures fun _ r' _ -> r' == ref_focus r l)
 
-val un_addr_of_lens
+val unaddr_of_lens
   (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
   (r': ref a q) (r: ref a p) (l: pcm_lens p q)
   (x: Ghost.erased b) (y: Ghost.erased c)
diff --git a/examples/steel/arraystructs/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
index e79a6731bfc..aa87085fd8b 100644
--- a/examples/steel/arraystructs/LineStruct.fst
+++ b/examples/steel/arraystructs/LineStruct.fst
@@ -67,8 +67,8 @@ let addr_of_p1 #a #p1 #p2 p =
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
   A.return q
 
-let un_addr_of_p1 #a #p1 #p2 p q =
-  un_addr_of_lens q p _p1 (mk_line (one point_pcm) p2) p1;
+let unaddr_of_p1 #a #p1 #p2 p q =
+  unaddr_of_lens q p _p1 (mk_line (one point_pcm) p2) p1;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_p2 #a #p1 #p2 p =
@@ -77,6 +77,6 @@ let addr_of_p2 #a #p1 #p2 p =
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
   A.return q
 
-let un_addr_of_p2 #a #p1 #p2 p q =
-  un_addr_of_lens q p _p2 (mk_line p1 (one point_pcm)) p2;
+let unaddr_of_p2 #a #p1 #p2 p q =
+  unaddr_of_lens q p _p2 (mk_line p1 (one point_pcm)) p2;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
index 4b2db09ce55..8545cde01f6 100644
--- a/examples/steel/arraystructs/LineStruct.fsti
+++ b/examples/steel/arraystructs/LineStruct.fsti
@@ -37,7 +37,7 @@ val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
        (p `pts_to` mk_line (one point_pcm) p2) `star`
        (q `pts_to` p1))
 
-val un_addr_of_p1 (#p1 #p2: Ghost.erased point)
+val unaddr_of_p1 (#p1 #p2: Ghost.erased point)
   (p: ref 'a line_pcm)
   (q: ref 'a point_pcm{q == ref_focus p _p1})
 : SteelT unit
@@ -51,7 +51,7 @@ val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
        (p `pts_to` mk_line p1 (one point_pcm)) `star`
        (q `pts_to` p2))
 
-val un_addr_of_p2 (#p1 #p2: Ghost.erased point)
+val unaddr_of_p2 (#p1 #p2: Ghost.erased point)
   (p: ref 'a line_pcm)
   (q: ref 'a point_pcm{q == ref_focus p _p2})
 : SteelT unit
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index ed1f8952274..eabf0cb7240 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -65,8 +65,8 @@ let addr_of_x #a #x #y p =
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
   A.return q
 
-let un_addr_of_x #a #x #y p q =
-  un_addr_of_lens q p _x (mk_point none y) x;
+let unaddr_of_x #a #x #y p q =
+  unaddr_of_lens q p _x (mk_point none y) x;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
@@ -75,6 +75,6 @@ let addr_of_y #a #x #y p =
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
-let un_addr_of_y #a #x #y p q =
-  un_addr_of_lens q p _y (mk_point x none) y;
+let unaddr_of_y #a #x #y p q =
+  unaddr_of_lens q p _y (mk_point x none) y;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index 06e8f748f1f..a5e7c4df2aa 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -35,7 +35,7 @@ val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
        (p `pts_to` mk_point none y) `star`
        (q `pts_to` x))
 
-val un_addr_of_x
+val unaddr_of_x
   (#x #y: Ghost.erased (pod int))
   (p: ref 'a point_pcm)
   (q: ref 'a (pod_pcm int){q == ref_focus p _x})
@@ -50,7 +50,7 @@ val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
        (p `pts_to` mk_point x none) `star`
        (q `pts_to` y))
 
-val un_addr_of_y
+val unaddr_of_y
   (#x #y: Ghost.erased (pod int))
   (p: ref 'a point_pcm)
   (q: ref 'a (pod_pcm int){q == ref_focus p _y})

From 492f12badf4e9cf94642a016f8130d5c2791c253 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 09:46:25 -0700
Subject: [PATCH 072/513] addr_of_union_lens and unaddr_of_union_lens

---
 examples/steel/arraystructs/AggregateRef.fst  | 25 +++----------------
 examples/steel/arraystructs/AggregateRef.fsti | 21 ++++++++++++++++
 .../arraystructs/AggregateRefExamples.fst     | 20 +++++++--------
 3 files changed, 34 insertions(+), 32 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
index 7171bbff98f..3856e0b645a 100644
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ b/examples/steel/arraystructs/AggregateRef.fst
@@ -184,33 +184,14 @@ val unrefine
 let unrefine #inames r' re r x =
   A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
 
-val addr_of_union_lens
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
-  (x: Ghost.erased b{refinement_f re x})
-: Steel (ref a q)
-    (r `pts_to` x)
-    (fun r' -> r' `pts_to` get l x)
-    (requires fun _ -> Ghost.reveal x == put l (get l x) (one (refined_pcm re)))
-    (ensures fun _ r' _ -> r' == ref_focus (ref_refine r re) l)
 let addr_of_union_lens #a #b #c #p #q r #re l x =
   let refined_r = refine r re x in
   focus refined_r l (Ghost.reveal x) (get l x)
 
-(*
-val unaddr_of_union_lens
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (r': ref a q) (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
-  (y: Ghost.erased c)
-: Steel (ref a p)
-    (r' `pts_to` y)
-    (fun r -> r `pts_to` put l y (one (refined_pcm re)))
-    (requires fun _ -> r' == ref_focus (ref_refine r re) l)
-    (ensures fun _ _ _ -> True)
 let unaddr_of_union_lens #a #b #c #p #q r' r #re l y =
-  let r' = refine r re x in
-  focus r' l (Ghost.reveal x) (get l x)
-  *)
+  let refined_r = ref_refine r re in // TODO interestingly if i inline this definition, F* hangs
+  unfocus r' refined_r l y;
+  unrefine r re refined_r (Ghost.hide (put l (Ghost.reveal y) (one (refined_pcm re))))
 
 let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
 : Steel 'b
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
index 7202069ecf7..585f28c3a22 100644
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ b/examples/steel/arraystructs/AggregateRef.fsti
@@ -62,6 +62,27 @@ val unaddr_of_lens
     (fun s -> r `pts_to` put l y x)
     (requires fun _ -> r' == ref_focus r l /\ get l x == one q)
     (ensures fun _ _ _ -> True)
+    
+val addr_of_union_lens
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
+  (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
+  (x: Ghost.erased b{refinement_f re x})
+: Steel (ref a q)
+    (r `pts_to` x)
+    (fun r' -> r' `pts_to` get l x)
+    (requires fun _ -> Ghost.reveal x == put l (get l x) (one (refined_pcm re)))
+    (ensures fun _ r' _ -> r' == ref_focus (ref_refine r re) l)
+    
+val unaddr_of_union_lens
+  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
+  (#opened: Steel.Memory.inames)
+  (r': ref a q) (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
+  (y: Ghost.erased c)
+: A.SteelGhost unit opened
+    (r' `pts_to` y)
+    (fun _ -> r `pts_to` put l y (one (refined_pcm re)))
+    (requires fun _ -> r' == ref_focus (ref_refine r re) l)
+    (ensures fun _ _ _ -> True)
 
 (** Generic read.
 
diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 7df765d0706..9aa49f799af 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -36,8 +36,8 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
   (* *r = tmp; *)
   ref_write r tmp;
   (* Gather *)
-  un_addr_of_x p q;
-  un_addr_of_y p r
+  unaddr_of_x p q;
+  unaddr_of_y p r
 
 /// We can also implement swap generically:
 ///
@@ -79,8 +79,8 @@ let point_swap_generically (#x #y: Ghost.erased int) (p: ref 'a point_pcm)
   (* generic_swap(q, r); *)
   generic_swap q r;
   (* Gather *)
-  un_addr_of_x p q;
-  un_addr_of_y p r
+  unaddr_of_x p q;
+  unaddr_of_y p r
 
 /// Reflect a line segment across the line y=x and reverse its direction
 ///
@@ -106,14 +106,14 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
   let pp2x = addr_of_x pp2 in
   generic_swap pp1y pp2x;
   (* Gather p1 *)
-  un_addr_of_x pp1 pp1x;
-  un_addr_of_y pp1 pp1y;
+  unaddr_of_x pp1 pp1x;
+  unaddr_of_y pp1 pp1y;
   (* Gather p2 *)
-  un_addr_of_x pp2 pp2x;
-  un_addr_of_y pp2 pp2y;
+  unaddr_of_x pp2 pp2x;
+  unaddr_of_y pp2 pp2y;
   (* Gather p *)
-  un_addr_of_p1 p pp1;
-  un_addr_of_p2 p pp2
+  unaddr_of_p1 p pp1;
+  unaddr_of_p2 p pp2
 
 (*
 addr_of

From 2ba9c5621935500b6035872c09af13a20f819847 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 10:20:21 -0700
Subject: [PATCH 073/513] Add IntOrBool.fst(i)

---
 .../steel/arraystructs/FStar.PCM.Extras.fst   |  4 +-
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 12 +++-
 examples/steel/arraystructs/IntOrBool.fst     | 61 +++++++++++++++++++
 examples/steel/arraystructs/IntOrBool.fsti    | 57 +++++++++++++++++
 4 files changed, 129 insertions(+), 5 deletions(-)
 create mode 100644 examples/steel/arraystructs/IntOrBool.fst
 create mode 100644 examples/steel/arraystructs/IntOrBool.fsti

diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
index c8a6a2f921f..90ce40a8271 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -77,9 +77,9 @@ let pcm_lens_frame_pres #a #b #p #q l s v f =
 (** Refinement of union to the kth case *)
 
 let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement p k)
+: pcm_unrefinement (case_refinement' p k)
 = fun kx ky f kv ->
-  let p' = refined_pcm' (case_refinement p k) in
+  let p' = refined_pcm' (case_refinement' p k) in
   let p = union_pcm p in
   match kv with
   | Some (|k', v|) ->
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index baa8ca36410..68b1ba78343 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -391,7 +391,7 @@ let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
 : refine_t (case_refinement_f p k)
 = Some (|k, one (p k)|)
 
-let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+let case_refinement' (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
 : pcm_refinement' (union_pcm p) = {
   f = case_refinement_f p k;
   f_closed_comp = (fun x y -> ());
@@ -400,7 +400,13 @@ let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
 }
 
 val case_unrefinement (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement p k)
+: pcm_unrefinement (case_refinement' p k)
+
+let case_refinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
+: pcm_refinement (union_pcm p) = {
+  refi = case_refinement' p k;
+  u = case_unrefinement p k;
+}
 
 (** A lens for the k-th case of an n-ary union *)
 
@@ -420,7 +426,7 @@ let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f
 
 (** lens_case is a pcm_lens *)
 let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_lens (refined_pcm' (case_refinement p k)) (p k) = {
+: pcm_lens (refined_pcm' (case_refinement' p k)) (p k) = {
   l = lens_case p k;
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
new file mode 100644
index 00000000000..f98cea9f3a0
--- /dev/null
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -0,0 +1,61 @@
+module IntOrBool
+
+open AggregateRef
+open FStar.PCM
+open FStar.PCM.Extras
+open FStar.PCM.POD
+open Steel.Effect
+module M = Steel.Memory
+module A = Steel.Effect.Atomic
+
+type int_or_bool_case = | I | B
+let int_or_bool_cases k = match k with
+  | I -> pod int
+  | B -> pod bool
+let int_or_bool = union int_or_bool_cases
+
+let int_or_bool_cases_pcm k : refined_one_pcm (int_or_bool_cases k) = match k with
+  | I -> pod_pcm int
+  | B -> pod_pcm bool
+let int_or_bool_pcm = union_pcm int_or_bool_cases_pcm
+
+let mk_int i = Some (|I, Ghost.reveal i|)
+let mk_bool b = Some (|B, Ghost.reveal b|)
+
+let re_i = case_refinement int_or_bool_cases_pcm I
+let re_b = case_refinement int_or_bool_cases_pcm B
+
+/// Lenses for cases
+
+let _i = case int_or_bool_cases_pcm I
+let _b = case int_or_bool_cases_pcm B
+
+/// Taking pointers to the i and b cases of an int_or_bool
+
+let addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+    (p `pts_to` mk_int i)
+    (fun q -> q `pts_to` i)
+= let mk_int_i : Ghost.erased (refine_t (refinement_f re_i)) = Some (|I, Ghost.reveal i|) in
+  A.change_equal_slprop (p `pts_to` mk_int i) (p `pts_to` Ghost.reveal mk_int_i);
+  addr_of_union_lens p _i (Ghost.reveal mk_int_i)
+
+let unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
+  (p: ref 'a int_or_bool_pcm)
+  (q: ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+: A.SteelGhostT unit opened (q `pts_to` i) (fun _ -> p `pts_to` mk_int i)
+= unaddr_of_union_lens q p _i i
+
+let addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
+: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+    (p `pts_to` mk_bool b)
+    (fun q -> q `pts_to` b)
+= let mk_bool_b : Ghost.erased (refine_t (refinement_f re_b)) = Some (|B, Ghost.reveal b|) in
+  A.change_equal_slprop (p `pts_to` mk_bool b) (p `pts_to` Ghost.reveal mk_bool_b);
+  addr_of_union_lens p _b (Ghost.reveal mk_bool_b)
+
+let unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
+  (p: ref 'a int_or_bool_pcm)
+  (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+: A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
+= unaddr_of_union_lens q p _b b
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
new file mode 100644
index 00000000000..0698a6d0092
--- /dev/null
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -0,0 +1,57 @@
+module IntOrBool
+
+open AggregateRef
+open FStar.PCM
+open FStar.PCM.Extras
+open FStar.PCM.POD
+open Steel.Effect
+module M = Steel.Memory
+module A = Steel.Effect.Atomic
+
+/// union int_or_bool { int i; bool b; };
+///
+/// Carrier of PCM for int_or_bool:
+
+val int_or_bool : Type0
+
+/// PCM for int_or_bool:
+
+val int_or_bool_pcm : refined_one_pcm int_or_bool
+
+/// (mk_int i) represents (union int_or_bool){.i = i}
+/// (mk_bool b) represents (union int_or_bool){.b = b}
+
+val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
+val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
+
+/// Refinements for cases
+
+val re_i : pcm_refinement int_or_bool_pcm
+val re_b : pcm_refinement int_or_bool_pcm
+
+/// Lenses for cases
+
+val _i : pcm_lens (refined_pcm re_i) (pod_pcm int)
+val _b : pcm_lens (refined_pcm re_b) (pod_pcm bool)
+
+/// Taking pointers to the i and b cases of an int_or_bool
+
+val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+    (p `pts_to` mk_int i)
+    (fun q -> q `pts_to` i)
+
+val unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
+  (p: ref 'a int_or_bool_pcm)
+  (q: ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+: A.SteelGhostT unit opened (q `pts_to` i) (fun _ -> p `pts_to` mk_int i)
+
+val addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
+: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+    (p `pts_to` mk_bool b)
+    (fun q -> q `pts_to` b)
+
+val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
+  (p: ref 'a int_or_bool_pcm)
+  (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+: A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)

From 608bbe811ae3b6131b1d3cd93c33b24bd0704ed0 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 9 Jul 2021 13:23:36 -0700
Subject: [PATCH 074/513] Meeting notes; revive Uninitialized data PCM

---
 .../arraystructs/AggregateRefExamples.fst     | 147 +++++++++++++++++-
 .../steel/arraystructs/FStar.PCM.Extras.fsti  |  35 +++++
 .../steel/arraystructs/FStar.PCM.POD.fsti     |   2 +
 examples/steel/arraystructs/IntOrBool.fst     |   1 +
 examples/steel/arraystructs/IntOrBool.fsti    |  58 ++++++-
 5 files changed, 237 insertions(+), 6 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 9aa49f799af..70b53192906 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -37,7 +37,8 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
   ref_write r tmp;
   (* Gather *)
   unaddr_of_x p q;
-  unaddr_of_y p r
+  unaddr_of_y p r;
+  A.return ()
 
 /// We can also implement swap generically:
 ///
@@ -57,8 +58,7 @@ let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (pod_pcm 'c)) (q:ref 'b (pod
   ref_write p vy;
   (* *q = tmp *)
   ref_write q tmp;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-  // seems can't get rid of final change_equal_slprop, even with smt_fallback
+  A.return ()
 
 /// Now, point_swap written using generic_swap:
 ///
@@ -80,7 +80,8 @@ let point_swap_generically (#x #y: Ghost.erased int) (p: ref 'a point_pcm)
   generic_swap q r;
   (* Gather *)
   unaddr_of_x p q;
-  unaddr_of_y p r
+  unaddr_of_y p r;
+  A.return ()
 
 /// Reflect a line segment across the line y=x and reverse its direction
 ///
@@ -115,11 +116,149 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
   unaddr_of_p1 p pp1;
   unaddr_of_p2 p pp2
 
+/// Struct with potentially uninitialized values
+///
+/// Unions of scalars with tag type (e.g. int_or_bool)
+/// "Functional" model of struct data
+///
+/// Examples (linked list w/ mutable elements)?
+///   noeq type cell : Type0 = {
+///     value: int;
+///     next: ref (FStar.Universe.raise_t cell) cell
+///   }
+///
+/// Can also define bounded-lists
+///   let rec bounded_list (n: Ghost.erased nat): Tot Type0 (decreases (Ghost.reveal n)) =
+///   if Ghost.reveal n = 0 then False
+///   else (int & option (ref (FStar.Universe.raise_t (bounded_list (n - 1))) (bounded_list (n - 1))))
+///
+/// Unions with these structs in them
+///   May need particular functional style for unions because can't reason by unification on result of if-then-else
+/// 
+///   p: pcm a
+///   a is the carrier
+///   secretly: a type b of values that we actually care about
+///   extract: a -> option (b * other things)
+///
+///   read:
+///     p `pts_to` (x: a)
+///    extract x = Some (v, _)
+
+/// Swap two ints inside two (union int_or_bool)s using generic_swap
+///
+/// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
+/// { generic_swap(&p.i, &q.i); }
+
+open IntOrBool
+
+let int_or_bool_int_swap
+  (p: ref 'a int_or_bool_pcm) (q: ref 'b int_or_bool_pcm)
+  (i j: Ghost.erased int)
+: SteelT unit
+    ((p `pts_to` mk_int (some i)) `star` (q `pts_to` mk_int (some j)))
+    (fun _ -> (p `pts_to` mk_int (some j)) `star` (q `pts_to` mk_int (some i)))
+= (* &p.i *)
+  let pi = addr_of_i p in
+  (* &q.i *)
+  let qi = addr_of_i q in
+  (* generic_swap(&p.i, &q.i); *)
+  generic_swap pi qi;
+  (* Give permissions back to p and q *)
+  unaddr_of_i p pi;
+  unaddr_of_i q qi
+
+/// Convert an int_or_bool + runtime tag into an int
+///
+/// int int_or_bool_to_int(bool *is_int, union int_or_bool *p) {
+///   if (*is_int) return p->i;
+///   else return p->b ? 1 : 0;
+/// }
+
+let int_or_bool_to_int
+  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
+  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
+: Steel (pod int)
+    ((is_int `pts_to` some b) `star` (p `pts_to` u))
+    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
+    (requires fun _ -> if b then case u == I else case u == B)
+    (ensures fun _ _ _ -> True)
+= let b = ref_read is_int in
+  if some_v b then begin
+    (* return p->i *)
+    let pi = addr_of_i p in
+    let i = ref_read pi in
+    unaddr_of_i p pi;
+    A.return i
+  end else begin
+    (* return p->b ? 1 : 0 *)
+    let pb = addr_of_b p in
+    let b = ref_read pb in
+    unaddr_of_b p pb;
+    let b = some_v b in
+    if b then some' 1 else some' 0
+  end
+
+let int_or_bool_to_int
+  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
+  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
+: Steel (pod int)
+    ((is_int `pts_to` some b) `star` (p `pts_to` u))
+    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
+    (requires fun _ -> if b then (exists i. u == mk_int i) else (exists b. u == mk_bool b))
+    (ensures fun _ _ _ -> True)
+= let b = ref_read is_int in
+  if some_v b then begin
+    (* return p->i *)
+    let pi = addr_of_i p in
+    let i = ref_read pi in
+    unaddr_of_i p pi;
+    A.return i
+  end else begin
+    (* return p->b ? 1 : 0 *)
+    let pb = addr_of_b p in
+    let b = ref_read pb in
+    unaddr_of_b p pb;
+    let b = some_v b in
+    if b then some' 1 else some' 0
+  end
+    
+
 (*
 addr_of
   (r `pts_to` xs)
   (r `pts_to` xs \ k `star` s `pts_to` xs k)
   
+
+let point_swap_generically (#q: Ghost.erased int) (p: ref 'a point_pcm)
+: SteelT unit
+    (p `pts_to` q)
+    (fun _ -> p `pts_to` q[.y = q.x][.x = q.y])
+= (* int *q = &p.x; *)
+  let q = addr_of_x p in
+  (* int *r = &p.y; *)
+  let r = addr_of_y p in
+  (* generic_swap(q, r); *)
+  generic_swap q r;
+  (* Gather *)
+  unaddr_of_x p q;
+  unaddr_of_y p r;
+  A.return ()
+
+p\{x, y} `pts_to` (v, w)
+
+p.x `pts_to` v === p `pts_to` mk_point v one
+p.y `pts_to` w === p `pts_to` mk_point one w
+
+give p.x's share back to p
+
+p' `pts_to` v_x
+p' == ghost_addr_of p y
+
+ghost_addr_of  = ref_focus .. 
+
+ghost_addr_of p y `pts_to` v_y
+
+  
 addr_of
   (r `pts_to` xs `star` s `pts_to` y)
   (r `pts_to` xs [k `mapsto` y])
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index 68b1ba78343..2640766e0fc 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -717,3 +717,38 @@ val conj_unrefinement (#p: pcm 'a)
 val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
+
+(** A PCM for possibly-uninitialized data *)
+
+type init a =
+| One : init a
+| Uninitialized : init a
+| Initialized : a -> init a
+
+let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
+  | One, _ | _, One -> True
+  | Uninitialized, Uninitialized -> True
+  | Initialized x, Initialized y -> composable p x y
+  | _, _ -> False
+
+let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
+  | One, z | z, One -> z
+  | Uninitialized, Uninitialized -> Uninitialized
+  | Initialized x, Initialized y -> Initialized (op p x y)
+
+let init_pcm (p: pcm 'a): pcm (init 'a) = {
+  p = {composable = init_comp p; op = init_op p; one = One #'a};
+  comm = (fun x y -> match x, y with
+    | Initialized x, Initialized y -> p.comm x y
+    | _, _ -> ());
+  assoc = (fun x y z -> match x, y, z with
+    | Initialized x, Initialized y, Initialized z -> p.assoc x y z
+    | _, _, _ -> ());
+  assoc_r = (fun x y z -> match x, y, z with
+    | Initialized x, Initialized y, Initialized z -> p.assoc_r x y z
+    | _, _, _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with
+    | Initialized x -> p.refine x
+    | _ -> True)
+}
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fsti b/examples/steel/arraystructs/FStar.PCM.POD.fsti
index 4caaeea2db9..ed65b0305b0 100644
--- a/examples/steel/arraystructs/FStar.PCM.POD.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fsti
@@ -11,6 +11,8 @@ val some: Ghost.erased 'a -> Ghost.erased (pod 'a)
 val is_some: Ghost.erased (pod 'a) -> prop
 val some_v: x:pod 'a{is_some x} -> GTot (y:'a{x == Ghost.reveal (some y)})
 
+val some': x:'a -> y:pod 'a{y == Ghost.reveal (some x)}
+
 val pod_pcm (a:Type): refined_one_pcm (pod a)
 
 val none_is_unit (a:Type): Lemma (Ghost.reveal none == one (pod_pcm a)) [SMTPat (one (pod_pcm a))]
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index f98cea9f3a0..d58d588c5fb 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -9,6 +9,7 @@ module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
 type int_or_bool_case = | I | B
+
 let int_or_bool_cases k = match k with
   | I -> pod int
   | B -> pod bool
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 0698a6d0092..8e02154e476 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -12,6 +12,9 @@ module A = Steel.Effect.Atomic
 ///
 /// Carrier of PCM for int_or_bool:
 
+[@@erasable]
+noeq type tag = | I' | B'
+
 val int_or_bool : Type0
 
 /// PCM for int_or_bool:
@@ -21,8 +24,14 @@ val int_or_bool_pcm : refined_one_pcm int_or_bool
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
 
-val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
-val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
+let int_or_bool_cases k : Type = match k with
+  | I' -> pod int
+  | B' -> pod bool
+
+val mk: tag -> Ghost.erased (int_or_bool_cases tag) -> Ghost.erased int_or_bool
+
+//val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
+//val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
 
 /// Refinements for cases
 
@@ -36,6 +45,11 @@ val _b : pcm_lens (refined_pcm re_b) (pod_pcm bool)
 
 /// Taking pointers to the i and b cases of an int_or_bool
 
+//val addr_of_i (#i: Ghost.erased (pod int){case u == I}) (p: ref 'a int_or_bool_pcm)
+//: SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+//    (p `pts_to` u)
+//    (fun q -> q `pts_to` proj2 u)
+
 val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
 : SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
     (p `pts_to` mk_int i)
@@ -55,3 +69,43 @@ val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
 : A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
+
+/// Laws (compare with FStar.PCM.POD.fsti)
+
+val case: Ghost.erased int_or_bool -> GTot (option tag)
+val case_ok1: u:Ghost.erased int_or_bool -> t:tag -> x:typeof_pcm t ->
+  Lemma (case (mk t i) == Some t) [SMTPat (case (mk t i))]
+val case_ok2: u -> Lemma (case u == None <==> u = one _) [SMTPat (case u)]
+val case_ok3: u: _ ->
+  Lemma
+    (requires Some? (case u))
+    (ensures exists i. u == mk (Some?.v (case u)) i) [SMTPat (case u)]
+
+// let is_int_int (i:Ghost.erased (pod int)): Lemma (is_int (mk_int i)) = ()
+// let is_bool_bool (b:Ghost.erased (pod bool)): Lemma (is_bool (mk_bool b)) = ()
+// 
+// let int_not_bool (u: Ghost.erased int_or_bool)
+// : Lemma (requires is_int u) (ensures ~ (is_bool u)) 
+// = ()
+// 
+// let bool_not_int (u: Ghost.erased int_or_bool)
+// : Lemma (requires is_bool u) (ensures ~ (is_int u)) 
+// = ()
+// 
+// val int_compatible (v w: Ghost.erased int_or_bool)
+// : Lemma (requires compatible int_or_bool_pcm v w /\ is_int v) (ensures is_int w)
+//   [SMTPat (compatible int_or_bool_pcm v w); SMTPat (is_int v)]
+// 
+// val bool_compatible (v w: Ghost.erased int_or_bool)
+// : Lemma (requires compatible int_or_bool_pcm v w /\ is_bool v) (ensures is_bool w)
+//   [SMTPat (compatible int_or_bool_pcm v w); SMTPat (is_bool v)]
+//   
+// val int_valid_write (v w: Ghost.erased (pod int))
+// : Lemma
+//     (requires AggregateRef.valid_write (pod_pcm int) v w)
+//     (ensures AggregateRef.valid_write int_or_bool_pcm (mk_int v) (mk_int w))
+//   [SMTPat (AggregateRef.valid_write (pod_pcm int) v w)]
+// 
+// v, w whole
+// I != J
+// valid_write (mk I v) (mk J w) 

From c585277f08b75e3257ffefff2835919a0063be7a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 13 Jul 2021 06:33:15 -0700
Subject: [PATCH 075/513] Explicit read/write functions for each PCM

---
 .../arraystructs/AggregateRefExamples.fst     | 102 +++++++++---------
 .../steel/arraystructs/FStar.PCM.Extras.fsti  |   5 +-
 examples/steel/arraystructs/FStar.PCM.POD.fst |  17 +--
 .../steel/arraystructs/FStar.PCM.POD.fsti     |  43 ++++----
 examples/steel/arraystructs/IntOrBool.fst     |  49 ++++++---
 examples/steel/arraystructs/IntOrBool.fsti    |  72 ++++---------
 6 files changed, 145 insertions(+), 143 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 70b53192906..60e52de6124 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -29,12 +29,12 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
   (* int *r = &p.y; *)
   let r = addr_of_y p in
   (* tmp = *q; *)
-  let tmp = ref_read q in
+  let tmp : int = pod_read q in
   (* *q = *r; *)
-  let vy = ref_read r in
-  ref_write q vy;
+  let vy : int = pod_read r in
+  pod_write q vy;
   (* *r = tmp; *)
-  ref_write r tmp;
+  pod_write r tmp;
   (* Gather *)
   unaddr_of_x p q;
   unaddr_of_y p r;
@@ -52,12 +52,12 @@ let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (pod_pcm 'c)) (q:ref 'b (pod
 : SteelT unit ((p `pts_to` some x) `star` (q `pts_to` some y))
     (fun _ -> (p `pts_to` some y) `star` (q `pts_to` some x))
 = (* A tmp = *p; *)
-  let tmp = ref_read p in
+  let tmp = pod_read p in
   (* *p = *q; *)
-  let vy = ref_read q in
-  ref_write p vy;
+  let vy = pod_read q in
+  pod_write p vy;
   (* *q = tmp *)
-  ref_write q tmp;
+  pod_write q tmp;
   A.return ()
 
 /// Now, point_swap written using generic_swap:
@@ -114,7 +114,8 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
   unaddr_of_y pp2 pp2y;
   (* Gather p *)
   unaddr_of_p1 p pp1;
-  unaddr_of_p2 p pp2
+  unaddr_of_p2 p pp2;
+  A.return ()
 
 /// Struct with potentially uninitialized values
 ///
@@ -135,10 +136,13 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
 /// Unions with these structs in them
 ///   May need particular functional style for unions because can't reason by unification on result of if-then-else
 /// 
+/// Specialized read and write
+/// 
 ///   p: pcm a
 ///   a is the carrier
 ///   secretly: a type b of values that we actually care about
-///   extract: a -> option (b * other things)
+///   lens a (option b)?
+///   pcm_lens a (opt_pcm b)?
 ///
 ///   read:
 ///     p `pts_to` (x: a)
@@ -174,54 +178,56 @@ let int_or_bool_int_swap
 ///   else return p->b ? 1 : 0;
 /// }
 
-let int_or_bool_to_int
-  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
-  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
-: Steel (pod int)
-    ((is_int `pts_to` some b) `star` (p `pts_to` u))
-    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
-    (requires fun _ -> if b then case u == I else case u == B)
-    (ensures fun _ _ _ -> True)
-= let b = ref_read is_int in
-  if some_v b then begin
-    (* return p->i *)
-    let pi = addr_of_i p in
-    let i = ref_read pi in
-    unaddr_of_i p pi;
-    A.return i
-  end else begin
-    (* return p->b ? 1 : 0 *)
-    let pb = addr_of_b p in
-    let b = ref_read pb in
-    unaddr_of_b p pb;
-    let b = some_v b in
-    if b then some' 1 else some' 0
-  end
-
-let int_or_bool_to_int
+val int_or_bool_to_int
   (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
   (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
-: Steel (pod int)
+: Steel int
     ((is_int `pts_to` some b) `star` (p `pts_to` u))
     (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
     (requires fun _ -> if b then (exists i. u == mk_int i) else (exists b. u == mk_bool b))
     (ensures fun _ _ _ -> True)
-= let b = ref_read is_int in
-  if some_v b then begin
+(*= let b = pod_read is_int in
+  if b then begin
     (* return p->i *)
     let pi = addr_of_i p in
-    let i = ref_read pi in
-    unaddr_of_i p pi;
-    A.return i
+    A.sladmit(); A.return (admit())
+    //let i = pod_read pi in
+    //unaddr_of_i p pi;
+    //A.return i
   end else begin
-    (* return p->b ? 1 : 0 *)
-    let pb = addr_of_b p in
-    let b = ref_read pb in
-    unaddr_of_b p pb;
-    let b = some_v b in
-    if b then some' 1 else some' 0
+    A.sladmit(); A.return (admit())
+    //(* return p->b ? 1 : 0 *)
+    //let pb = addr_of_b p in
+    //let b = pod_read pb in
+    //unaddr_of_b p pb;
+    //let b = b in
+    //A.return (if b then 1 else 0)
   end
-    
+*)
+
+//let int_or_bool_to_int
+//  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
+//  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
+//: Steel (pod int)
+//    ((is_int `pts_to` some b) `star` (p `pts_to` u))
+//    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
+//    (requires fun _ -> if b then case u == I else case u == B)
+//    (ensures fun _ _ _ -> True)
+//= let b = pod_read is_int in
+//  if some_v b then begin
+//    (* return p->i *)
+//    let pi = addr_of_i p in
+//    let i = pod_read pi in
+//    unaddr_of_i p pi;
+//    A.return i
+//  end else begin
+//    (* return p->b ? 1 : 0 *)
+//    let pb = addr_of_b p in
+//    let b = pod_read pb in
+//    unaddr_of_b p pb;
+//    let b = some_v b in
+//    if b then some' 1 else some' 0
+//  end
 
 (*
 addr_of
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index 2640766e0fc..ec8954988ed 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -124,7 +124,8 @@ let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
 /// - None is the unit of the PCM
 /// - Some (k, x) is a union with tag k and content x
 
-let union (f:'a -> Type) = option (k:'a & f k)
+open FStar.Real
+let union (f:'a -> Type) = option (real & dtuple2 'a f)
 
 let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
   | None, z | z, None -> True
@@ -727,13 +728,11 @@ type init a =
 
 let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
   | One, _ | _, One -> True
-  | Uninitialized, Uninitialized -> True
   | Initialized x, Initialized y -> composable p x y
   | _, _ -> False
 
 let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
   | One, z | z, One -> z
-  | Uninitialized, Uninitialized -> Uninitialized
   | Initialized x, Initialized y -> Initialized (op p x y)
 
 let init_pcm (p: pcm 'a): pcm (init 'a) = {
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fst b/examples/steel/arraystructs/FStar.PCM.POD.fst
index 1d0a0daec2e..a66a49861d1 100644
--- a/examples/steel/arraystructs/FStar.PCM.POD.fst
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fst
@@ -1,16 +1,19 @@
 module FStar.PCM.POD
 
+open AggregateRef
+module A = Steel.Effect.Atomic
+
 let pod a = option a
 
 let none #a = None #a
 let some x = Some (Ghost.reveal x)
-let is_some v = match Ghost.reveal v with Some _ -> True | None -> False
-let some_v x = match x with Some v -> v
 
 let pod_pcm a = FStar.PCM.Extras.opt_pcm #a
 
-let none_is_unit a = ()
-let is_some_some v = ()
-let some_none_distinct v = ()
-let some_compatible v w = ()
-let some_valid_write v w = ()
+let pod_read r =
+  let Some x = ref_read r in
+  x
+
+let pod_write r y =
+  ref_write r (Some y);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fsti b/examples/steel/arraystructs/FStar.PCM.POD.fsti
index ed65b0305b0..07c157d1d07 100644
--- a/examples/steel/arraystructs/FStar.PCM.POD.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fsti
@@ -2,32 +2,29 @@ module FStar.PCM.POD
 
 open FStar.PCM
 open FStar.PCM.Extras
+open AggregateRef
+open Steel.Effect
 
-val pod: Type u#a -> Type u#a
+let pod: Type u#a -> Type u#a = option
 
-val none: Ghost.erased (pod 'a)
-val some: Ghost.erased 'a -> Ghost.erased (pod 'a)
+let none #a: Ghost.erased (pod a) = None
 
-val is_some: Ghost.erased (pod 'a) -> prop
-val some_v: x:pod 'a{is_some x} -> GTot (y:'a{x == Ghost.reveal (some y)})
+let some (x: Ghost.erased 'a): Ghost.erased (pod 'a) = Some (Ghost.reveal x)
 
-val some': x:'a -> y:pod 'a{y == Ghost.reveal (some x)}
+let pod_pcm (a:Type): refined_one_pcm (pod a) = opt_pcm #a
 
-val pod_pcm (a:Type): refined_one_pcm (pod a)
+val pod_read
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (pod_pcm b))
+: Steel b
+    (r `pts_to` some x)
+    (fun _ -> r `pts_to` some x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> Ghost.reveal x == x')
 
-val none_is_unit (a:Type): Lemma (Ghost.reveal none == one (pod_pcm a)) [SMTPat (one (pod_pcm a))]
-
-val is_some_some (v:Ghost.erased 'a): Lemma (is_some (some v)) [SMTPat (some v)]
-
-val some_none_distinct (v:pod 'a)
-: Lemma (requires is_some v) (ensures ~ (v == Ghost.reveal none)) [SMTPat (is_some v)]
-
-val some_compatible (v w:pod 'a)
-: Lemma (requires compatible (pod_pcm 'a) v w /\ is_some v) (ensures is_some w)
-  [SMTPat (compatible (pod_pcm 'a) v w); SMTPat (is_some v)]
-  
-val some_valid_write (v w: pod 'a)
-: Lemma
-    (requires is_some v /\ is_some w)
-    (ensures AggregateRef.valid_write (pod_pcm 'a) v w)
-  [SMTPat (is_some v); SMTPat (is_some w)]
+val pod_write
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (pod_pcm b)) (y: b)
+: SteelT unit
+    (r `pts_to` some x)
+    (fun _ -> r `pts_to` some (Ghost.hide y))
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index d58d588c5fb..bed84ec4891 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -8,18 +8,6 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
-type int_or_bool_case = | I | B
-
-let int_or_bool_cases k = match k with
-  | I -> pod int
-  | B -> pod bool
-let int_or_bool = union int_or_bool_cases
-
-let int_or_bool_cases_pcm k : refined_one_pcm (int_or_bool_cases k) = match k with
-  | I -> pod_pcm int
-  | B -> pod_pcm bool
-let int_or_bool_pcm = union_pcm int_or_bool_cases_pcm
-
 let mk_int i = Some (|I, Ghost.reveal i|)
 let mk_bool b = Some (|B, Ghost.reveal b|)
 
@@ -60,3 +48,40 @@ let unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
   (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
 : A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
 = unaddr_of_union_lens q p _b b
+
+/// Switching the case
+
+let switch_to_bool (#i: Ghost.erased int)
+  (p: ref 'a int_or_bool_pcm) (b: bool)
+: SteelT unit (p `pts_to` mk_int (some i)) (fun _ -> p `pts_to` mk_bool (some b))
+= let u: int_or_bool = Some (|B, Some b|) in
+  assume (forall frame.
+    composable int_or_bool_pcm (mk_int (some i)) frame ==> 
+    composable int_or_bool_pcm u frame);
+  assert (valid_write int_or_bool_pcm (mk_int (some i)) u);
+  ref_write p u;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+mk_int i = (i, one)
+mk_bool b = (one, b)
+
+thread 1:
+  u.case1 = v1
+  p = &u.case1
+  p `pts_to` case1 (1 v1)
+  (p `pts_to` case1 (0.5 v1) `star`
+  (q `pts_to` case1 (0.5 v1))
+  fork()
+  (p `pts_to` case1 (0.5 v1))
+  (focus (refine p .) . `pts_to` v1)
+
+thread 2:
+  (q `pts_to` case1 (0.5 v1))
+
+let switch_to_int (#b: Ghost.erased bool)
+  (p: ref 'a int_or_bool_pcm) (i: int)
+: SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))
+= let u: int_or_bool = Some (|I, Some i|) in
+  assume (valid_write int_or_bool_pcm (mk_bool (some b)) u);
+  ref_write p u;
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 8e02154e476..1708b8a4074 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -12,26 +12,28 @@ module A = Steel.Effect.Atomic
 ///
 /// Carrier of PCM for int_or_bool:
 
-[@@erasable]
-noeq type tag = | I' | B'
+type int_or_bool_case = | I | B
 
-val int_or_bool : Type0
+let int_or_bool_cases k = match k with
+  | I -> pod int
+  | B -> pod bool
+let int_or_bool = union int_or_bool_cases
 
 /// PCM for int_or_bool:
 
-val int_or_bool_pcm : refined_one_pcm int_or_bool
+let int_or_bool_cases_pcm k: refined_one_pcm (int_or_bool_cases k) = match k with
+  | I -> pod_pcm int
+  | B -> pod_pcm bool
+  
+let int_or_bool_pcm: refined_one_pcm int_or_bool = union_pcm int_or_bool_cases_pcm
 
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
 
-let int_or_bool_cases k : Type = match k with
-  | I' -> pod int
-  | B' -> pod bool
+//val mk: tag -> Ghost.erased (int_or_bool_cases tag) -> Ghost.erased int_or_bool
 
-val mk: tag -> Ghost.erased (int_or_bool_cases tag) -> Ghost.erased int_or_bool
-
-//val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
-//val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
+val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
+val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
 
 /// Refinements for cases
 
@@ -70,42 +72,12 @@ val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
   (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
 : A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
 
-/// Laws (compare with FStar.PCM.POD.fsti)
-
-val case: Ghost.erased int_or_bool -> GTot (option tag)
-val case_ok1: u:Ghost.erased int_or_bool -> t:tag -> x:typeof_pcm t ->
-  Lemma (case (mk t i) == Some t) [SMTPat (case (mk t i))]
-val case_ok2: u -> Lemma (case u == None <==> u = one _) [SMTPat (case u)]
-val case_ok3: u: _ ->
-  Lemma
-    (requires Some? (case u))
-    (ensures exists i. u == mk (Some?.v (case u)) i) [SMTPat (case u)]
-
-// let is_int_int (i:Ghost.erased (pod int)): Lemma (is_int (mk_int i)) = ()
-// let is_bool_bool (b:Ghost.erased (pod bool)): Lemma (is_bool (mk_bool b)) = ()
-// 
-// let int_not_bool (u: Ghost.erased int_or_bool)
-// : Lemma (requires is_int u) (ensures ~ (is_bool u)) 
-// = ()
-// 
-// let bool_not_int (u: Ghost.erased int_or_bool)
-// : Lemma (requires is_bool u) (ensures ~ (is_int u)) 
-// = ()
-// 
-// val int_compatible (v w: Ghost.erased int_or_bool)
-// : Lemma (requires compatible int_or_bool_pcm v w /\ is_int v) (ensures is_int w)
-//   [SMTPat (compatible int_or_bool_pcm v w); SMTPat (is_int v)]
-// 
-// val bool_compatible (v w: Ghost.erased int_or_bool)
-// : Lemma (requires compatible int_or_bool_pcm v w /\ is_bool v) (ensures is_bool w)
-//   [SMTPat (compatible int_or_bool_pcm v w); SMTPat (is_bool v)]
-//   
-// val int_valid_write (v w: Ghost.erased (pod int))
-// : Lemma
-//     (requires AggregateRef.valid_write (pod_pcm int) v w)
-//     (ensures AggregateRef.valid_write int_or_bool_pcm (mk_int v) (mk_int w))
-//   [SMTPat (AggregateRef.valid_write (pod_pcm int) v w)]
-// 
-// v, w whole
-// I != J
-// valid_write (mk I v) (mk J w) 
+/// Switching the case
+
+val switch_to_bool (#i: Ghost.erased int)
+  (p: ref 'a int_or_bool_pcm) (b: bool)
+: SteelT unit (p `pts_to` mk_int (some i)) (fun _ -> p `pts_to` mk_bool (some b))
+
+val switch_to_int (#b: Ghost.erased bool)
+  (p: ref 'a int_or_bool_pcm) (i: int)
+: SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))

From d8f907ebfe935dcfe634f09357a1f0956ba00e18 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 13 Jul 2021 11:48:32 -0700
Subject: [PATCH 076/513] Start new formulation of unions

---
 .../steel/arraystructs/FStar.PCM.Extras.fst   |   2 +
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 282 +++++++++++++++---
 2 files changed, 243 insertions(+), 41 deletions(-)

diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
index 90ce40a8271..71d418d64a1 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -74,6 +74,7 @@ let pcm_lens_frame_pres #a #b #p #q l s v f =
       = () in ()
     in FStar.Classical.forall_intro aux)))
 
+(*
 (** Refinement of union to the kth case *)
 
 let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
@@ -107,6 +108,7 @@ let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
       kw
     end else None
   | _ -> None
+*)
 
 let conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index ec8954988ed..0db85dc8f3a 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -119,37 +119,6 @@ let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
   (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
 : Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
 
-/// Similarly, given a PCM for each k:a, we can model a-ary unions
-/// with an PCM for option (k:a & f k), where
-/// - None is the unit of the PCM
-/// - Some (k, x) is a union with tag k and content x
-
-open FStar.Real
-let union (f:'a -> Type) = option (real & dtuple2 'a f)
-
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
-  | None, z | z, None -> True
-  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
-
-let union_op (p:(k:'a -> pcm ('b k))) (x: union 'b) (y: union 'b{union_comp p x y}) : union 'b = match x, y with
-  | None, z | z, None -> z
-  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
-
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union 'b) = {
-  p = {composable = union_comp p; op = union_op p; one = None};
-  comm = (fun x y -> match x, y with
-    | None, _ | _, None -> ()
-    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
-  assoc = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
-  assoc_r = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
-}
-
 (** The non-computational part of frame_preserving_upd *)
 let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
   (v:'a{p.refine v /\ compatible p x v})
@@ -227,7 +196,9 @@ noeq type pcm_refinement' #a (p: pcm a) = {
   f: a -> prop;
   f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
   new_one: (new_one:refine_t f{p.refine new_one});
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x);
+  new_one_comp: x: refine_t f -> y: refine_t f{composable p x y} ->
+    Lemma (requires op p x y == new_one) (ensures x == new_one /\ y == new_one);
 }
 
 let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
@@ -238,15 +209,25 @@ let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_one_pcm a = p:pcm a{p.refine (one p)}
-let refined_pcm' (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> r.new_one_is_refined_unit x);
-  refine = p.refine;
-}
+let refined_one_pcm a = p:pcm a{
+  p.refine (one p) /\
+  (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
+   op p x y == one p ==> x == one p /\ y == one p)}
+
+let refined_pcm' (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) =
+  let p' = {
+    p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
+    comm = (fun x y -> p.comm x y);
+    assoc = (fun x y z -> p.assoc x y z);
+    assoc_r = (fun x y z -> p.assoc_r x y z);
+    is_unit = (fun x -> r.new_one_is_refined_unit x);
+    refine = p.refine;
+  } in
+  let aux (x:refine_t r.f) (y:_{composable p' x y})
+  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+    [SMTPat (op p' x y)]
+  = r.new_one_comp x y
+  in p'
 
 val pcm_refinement'_comp_new_one
   (#p: pcm 'a) (re: pcm_refinement' p)
@@ -383,6 +364,194 @@ let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p
   }
 }
 
+(** A PCM for unions TODO move to proper place *)
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
+  forall k'. ~ (k == k') ==> f k' == one (p k')
+
+let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
+: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
+
+let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
+    (ensures f == one (prod_pcm p))
+= ext f (one (prod_pcm p)) (fun k -> ())
+
+let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
+  (exists (k:'a). True) ==> (exists k. case_refinement_f p k f)
+  (** precondition is there because we don't care if 'a is inhabited *)
+
+let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
+
+let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
+  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
+    [SMTPat (case_refinement_f p k f)]))
+: Lemma (forall (j:'a). goal)
+= let _ = cont in ()
+
+let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
+  (k:'a{case_refinement_f p k f})
+: Lemma (is_union p f)
+= ()
+
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
+  forall j k.
+  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
+  j == k /\ composable (p k) (f k) (g k)
+
+let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (union_comp p f g)
+= let _ = h in ()
+
+let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
+: Lemma
+    (requires union_comp p f g)
+    (ensures prod_comp p f g)
+    [SMTPat (union_comp p f g)]
+= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
+
+let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p k f /\ f k == one (p k))
+    (ensures f == one (prod_pcm p))
+    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
+= ext f (one (prod_pcm p)) (fun _ -> ())
+
+let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
+    (ensures
+      f == one (prod_pcm p) \/
+      g == one (prod_pcm p) \/ 
+      case_refinement_f p k (prod_op p f g))
+    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
+= let fj_or_gk_one
+  : squash
+      (f j == one (p j) \/ g k == one (p k) ==>
+       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
+  = ()
+  in let fj_gk_both_not_one ()
+  : Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures case_refinement_f p k (prod_op p f g))
+  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+  in
+  move_requires fj_gk_both_not_one ();
+  assert
+   ((f j == one (p j) \/ g k == one (p k)) ==>
+    f == one (prod_pcm p) \/
+    g == one (prod_pcm p) \/ 
+    case_refinement_f p k (prod_op p f g))
+
+let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
+  let h = prod_op p f g in
+  let goal = is_union p h in
+  union_elim p f goal (fun j ->
+  union_elim p g goal (fun k ->
+  case_refinement_f_op p j k f g;
+  (prod_pcm p).is_unit g));
+  h
+
+let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
+let union_refine (p:(k:'a -> pcm ('b k))) = prod_refine p
+
+let union_assoc (p:(k:'a -> refined_one_pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
+: Lemma (union_comp p x y /\
+         union_comp p (union_op p x y) z /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+let union_assoc_r (p:(k:'a -> refined_one_pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
+: Lemma (union_comp p y z /\
+         union_comp p x (union_op p y z) /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc_r p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
+: Lemma (union_comp p x (union_one p) /\
+         union_op p x (union_one p) == x)
+= (prod_pcm p).is_unit x
+
+let union_pcm (p:(k:'a -> refined_one_pcm ('b k))): refined_one_pcm (union p) =
+  let p' = {
+    p = {composable = union_comp p; op = union_op p; one = union_one p};
+    comm = (fun x y -> prod_comm p x y);
+    assoc = union_assoc p;
+    assoc_r = union_assoc_r p;
+    is_unit = union_is_unit p;
+    refine = union_refine p;
+  } in
+  let aux (x:union p) (y:union p{composable p' x y})
+  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+    [SMTPat (op p' x y)]
+  = ext x (one p') (fun k -> let _ = p k in ());
+    ext y (one p') (fun k -> let _ = p k in ())
+  in p'
+
+(*
+let case_refinement_closed_comp (p:(k:'a -> pcm ('b k))) (k:'a)
+  (f:refine_t (case_refinement_f p k))
+  (g:restricted_t 'a 'b{composable (prod_pcm p) f g})
+: Lemma (case_refinement_f p k (op (prod_pcm p) f g))
+=  admit()
+
+
+let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (prod_pcm p) =
+  let refi: pcm_refinement' (prod_pcm p) = {
+    f = case_refinement_f p k;
+    f_closed_comp = admit();
+    new_one = admit();
+    new_one_is_refined_unit = admit();
+  } in
+  let u: pcm_unrefinement refi = admit() in
+  {refi = refi; u = u}
+
+
+//let is_refinement pcm_refinement' #a (p: pcm a) = {
+//  f: a -> prop;
+//  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
+//  new_one: (new_one:refine_t f{p.refine new_one});
+//  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
+//}
+
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
+  | None, z | z, None -> True
+  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
+
+let union_op (p:(k:'a -> pcm ('b k))) (x: union 'b) (y: union 'b{union_comp p x y}) : union 'b = match x, y with
+  | None, z | z, None -> z
+  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union 'b) = {
+  p = {composable = union_comp p; op = union_op p; one = None};
+  comm = (fun x y -> match x, y with
+    | None, _ | _, None -> ()
+    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
+  assoc = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
+  assoc_r = (fun x y z -> match x, y, z with
+    | None, _, _ | _, _, None | _, None, _ -> ()
+    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
+}
+
 (** The refinement of an n-ary union PCM to the k-th case *)
 
 let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
@@ -432,6 +601,7 @@ let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
   get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
   put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
 }
+*)
 
 (** Refining a pcm_lens *)
 
@@ -479,6 +649,24 @@ let extend_refinement_new_one_is_refined_unit
 = re.new_one_is_refined_unit (get l x);
   p.is_unit x;
   l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+
+let extend_refinement_new_one_comp (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+  (x: refine_t (extend_refinement_f l re))
+  (y: refine_t (extend_refinement_f l re){composable p x y})
+: Lemma
+    (requires op p x y == extend_refinement_new_one l re)
+    (ensures
+      x == extend_refinement_new_one l re /\ 
+      y == extend_refinement_new_one l re)
+= assert (re.f (get l x));
+  assert (re.f (get l y));
+  assert (op p x y == put l re.new_one (one p));
+  l.get_morphism.f_op x y;
+  re.new_one_comp (get l x) (get l y);
+  assert (get l x == re.new_one);
+  assert (get l y == re.new_one);
+  admit()
   
 let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
@@ -487,6 +675,7 @@ let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   f_closed_comp = extend_refinement_f_closed l re;
   new_one = extend_refinement_new_one l re;
   new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+  new_one_comp = extend_refinement_new_one_comp l re;
 }
 
 let pcm_lens_refine_get_morphism_refine
@@ -665,6 +854,15 @@ let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
          op p x (conj_refinement_new_one re1 re2) == x)
 = re2.new_one_is_refined_unit x
 
+let conj_refinement_new_one_comp (#p: pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
+: Lemma 
+    (requires op p x y == conj_refinement_new_one re1 re2)
+    (ensures x == conj_refinement_new_one re1 re2 /\ y == conj_refinement_new_one re1 re2)
+= admit()
+
 let conj_refinement (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_refinement' p = {
@@ -672,6 +870,7 @@ let conj_refinement (#p: pcm 'a)
   f_closed_comp = conj_refinement_f_closed re1 re2;
   new_one = conj_refinement_new_one re1 re2;
   new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
+  new_one_comp = conj_refinement_new_one_comp re1 re2;
 }
 
 let pcm_refinement'_conj_iso_i (p: pcm 'a)
@@ -751,3 +950,4 @@ let init_pcm (p: pcm 'a): pcm (init 'a) = {
     | Initialized x -> p.refine x
     | _ -> True)
 }
+

From d7649b1e0875a2513dab30c6ab8affa80e9b5fd7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 13 Jul 2021 12:08:44 -0700
Subject: [PATCH 077/513] Remove new_one from pcm_refinements

---
 .../arraystructs/AggregateRefExamples.fst     |   2 +
 .../steel/arraystructs/FStar.PCM.Extras.fst   |  34 ++--
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 147 +++++-------------
 examples/steel/arraystructs/IntOrBool.fst     |  16 --
 4 files changed, 61 insertions(+), 138 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 60e52de6124..d4178a9fcef 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -153,6 +153,7 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
 /// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
 /// { generic_swap(&p.i, &q.i); }
 
+(*
 open IntOrBool
 
 let int_or_bool_int_swap
@@ -204,6 +205,7 @@ val int_or_bool_to_int
     //A.return (if b then 1 else 0)
   end
 *)
+*)
 
 //let int_or_bool_to_int
 //  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
index 71d418d64a1..cad66591639 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -26,23 +26,23 @@ let compatible_pcm_morphism #a #b #p #q f m x y =
 
 (** Refinements *)
 
-let pcm_refinement'_comp_new_one #a #p re x y =
-  re.new_one_is_refined_unit x;
-  p.assoc_r x re.new_one y;
-  re.f_closed_comp re.new_one y
+let pcm_refinement'_comp_one #a #p re x y =
+  p.is_unit x;
+  p.assoc_r x (one p) y;
+  re.f_closed_comp (one p) y
 
 let pcm_refinement'_compatible_closed #a #p re x y =
   let p' = refined_pcm' re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    pcm_refinement'_comp_new_one re x frame_x;
-    let frame = op p re.new_one frame_x in
-    re.new_one_is_refined_unit x;
+    pcm_refinement'_comp_one re x frame_x;
+    let frame = op p (one p) frame_x in
+    p.is_unit x;
     p.comm x frame_x;
-    p.assoc x re.new_one frame_x;
-    p.comm x (op p re.new_one frame_x);
-    compatible_intro p' x y (op p re.new_one frame_x))
+    p.assoc x (one p) frame_x;
+    p.comm x (op p (one p) frame_x);
+    compatible_intro p' x y (op p (one p) frame_x))
 
 (** PCM lenses *)
 
@@ -110,7 +110,7 @@ let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   | _ -> None
 *)
 
-let conj_unrefinement (#p: pcm 'a)
+let conj_unrefinement (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
@@ -130,11 +130,11 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   let w = f v in
   let aux (frame:'a{composable p x frame})
   : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
-  = pcm_refinement'_comp_new_one re' x frame;
-    let frame' = op p re'.new_one frame in
-    p.assoc y re'.new_one frame;
-    re'.new_one_is_refined_unit y;
-    p.assoc x re'.new_one frame;
-    re'.new_one_is_refined_unit x
+  = pcm_refinement'_comp_one re' x frame;
+    let frame' = op p (one p) frame in
+    p.assoc y (one p) frame;
+    p.is_unit y;
+    p.assoc x (one p) frame;
+    p.is_unit x
   in FStar.Classical.forall_intro aux;
   w
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index 0db85dc8f3a..7c1faf61521 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -187,18 +187,13 @@ val compatible_pcm_morphism
   (x y: Ghost.erased 'a)
 : Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
 
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f
-        and p.refine *)
+(** A refinement of a PCM (p: pcm a) consists of a set of elements
+    f:(a -> prop) closed under (op p) *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement' #a (p: pcm a) = {
   f: a -> prop;
+  f_closed_one: squash (f (one p));
   f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
-  new_one: (new_one:refine_t f{p.refine new_one});
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x);
-  new_one_comp: x: refine_t f -> y: refine_t f{composable p x y} ->
-    Lemma (requires op p x y == new_one) (ensures x == new_one /\ y == new_one);
 }
 
 let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
@@ -214,29 +209,23 @@ let refined_one_pcm a = p:pcm a{
   (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
    op p x y == one p ==> x == one p /\ y == one p)}
 
-let refined_pcm' (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) =
-  let p' = {
-    p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
-    comm = (fun x y -> p.comm x y);
-    assoc = (fun x y z -> p.assoc x y z);
-    assoc_r = (fun x y z -> p.assoc_r x y z);
-    is_unit = (fun x -> r.new_one_is_refined_unit x);
-    refine = p.refine;
-  } in
-  let aux (x:refine_t r.f) (y:_{composable p' x y})
-  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-    [SMTPat (op p' x y)]
-  = r.new_one_comp x y
-  in p'
+let refined_pcm' (#p: refined_one_pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
+  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = p.p.one};
+  comm = (fun x y -> p.comm x y);
+  assoc = (fun x y z -> p.assoc x y z);
+  assoc_r = (fun x y z -> p.assoc_r x y z);
+  is_unit = (fun x -> p.is_unit x);
+  refine = p.refine;
+}
 
-val pcm_refinement'_comp_new_one
-  (#p: pcm 'a) (re: pcm_refinement' p)
+val pcm_refinement'_comp_one
+  (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{composable p x y})
-: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
-         composable (refined_pcm' re) x (op p re.new_one y))
+: Lemma (composable p (one p) y /\ re.f (op p (one p) y) /\
+         composable (refined_pcm' re) x (op p (one p) y))
 
 val pcm_refinement'_compatible_closed
-  (#p: pcm 'a) (re: pcm_refinement' p)
+  (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{compatible p x y})
 : Lemma (re.f y /\ compatible (refined_pcm' re) x y)
 
@@ -248,19 +237,19 @@ let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost
   frame_preserving_upd p x y ->
   frame_preserving_upd q x' y'
 
-let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
+let pcm_unrefinement (#p: refined_one_pcm 'a) (r: pcm_refinement' p) =
   x: Ghost.erased (refine_t r.f) ->
   y: Ghost.erased (refine_t r.f) ->
   frame_pres_lift (refined_pcm' r) x y p (Ghost.reveal x) (Ghost.reveal y)
 
-noeq type pcm_refinement #a (p: pcm a) = {
+noeq type pcm_refinement #a (p: refined_one_pcm a) = {
   refi: pcm_refinement' p;
   u: pcm_unrefinement refi;
 }
 
-let refinement_f (#p: pcm 'a) (r: pcm_refinement p) = r.refi.f
+let refinement_f (#p: refined_one_pcm 'a) (r: pcm_refinement p) = r.refi.f
 
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p)
+let refined_pcm (#p: refined_one_pcm 'a) (r: pcm_refinement p)
 : refined_one_pcm (refine_t (refinement_f r))
 = refined_pcm' r.refi
 
@@ -629,53 +618,24 @@ let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement'
   put_put = (fun _ _ _ -> ());
 }
 
+let extend_refinement_f_closed_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: squash (extend_refinement_f l re (one p))
+= l.get_morphism.f_one ()
+
 let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
   (y: 'a{composable p x y})
 : Lemma (extend_refinement_f l re (op p x y))
 = l.get_morphism.f_op x y;
   re.f_closed_comp (get l x) (get l y)
-
-let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: new_one:refine_t (extend_refinement_f l re){p.refine new_one}
-= l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
-
-let extend_refinement_new_one_is_refined_unit
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-: Lemma (composable p x (extend_refinement_new_one l re) /\
-         op p x (extend_refinement_new_one l re) == x)
-= re.new_one_is_refined_unit (get l x);
-  p.is_unit x;
-  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
-
-let extend_refinement_new_one_comp (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-  (x: refine_t (extend_refinement_f l re))
-  (y: refine_t (extend_refinement_f l re){composable p x y})
-: Lemma
-    (requires op p x y == extend_refinement_new_one l re)
-    (ensures
-      x == extend_refinement_new_one l re /\ 
-      y == extend_refinement_new_one l re)
-= assert (re.f (get l x));
-  assert (re.f (get l y));
-  assert (op p x y == put l re.new_one (one p));
-  l.get_morphism.f_op x y;
-  re.new_one_comp (get l x) (get l y);
-  assert (get l x == re.new_one);
-  assert (get l y == re.new_one);
-  admit()
   
 let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : pcm_refinement' p = {
   f = extend_refinement_f l re;
+  f_closed_one = extend_refinement_f_closed_one l re;
   f_closed_comp = extend_refinement_f_closed l re;
-  new_one = extend_refinement_new_one l re;
-  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
-  new_one_comp = extend_refinement_new_one_comp l re;
 }
 
 let pcm_lens_refine_get_morphism_refine
@@ -823,57 +783,34 @@ let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 
 (** The conjunction of two refinements *)
 
-let conj_refinement_f (#p: pcm 'a)
+let conj_refinement_f (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : 'a -> prop = conj #'a re1.f re2.f
 
-let conj_refinement_f_closed (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-  (y: 'a{composable p x y})
-: Lemma (conj_refinement_f re1 re2 (op p x y))
-= pcm_refinement'_comp_new_one re1 x y;
-  re1.f_closed_comp x (op p re1.new_one y);
-  pcm_refinement'_comp_new_one re2 x (op p re1.new_one y);
-  re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
-  p.assoc x re2.new_one (op p re1.new_one y);
-  re2.new_one_is_refined_unit x;
-  p.assoc x re1.new_one y;
-  re1.new_one_is_refined_unit x
-
-(* re1.new_one and re2.new_one both work; we go with re2 *)
-let conj_refinement_new_one (#p: pcm 'a)
+let conj_refinement_f_closed_one (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-: refine_t (conj_refinement_f re1 re2)
-= re2.new_one
-
-let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
-         op p x (conj_refinement_new_one re1 re2) == x)
-= re2.new_one_is_refined_unit x
+: squash (conj_refinement_f re1 re2 (one p))
+= ()
 
-let conj_refinement_new_one_comp (#p: pcm 'a)
+let conj_refinement_f_closed (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (x: refine_t (conj_refinement_f re1 re2))
-  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
-: Lemma 
-    (requires op p x y == conj_refinement_new_one re1 re2)
-    (ensures x == conj_refinement_new_one re1 re2 /\ y == conj_refinement_new_one re1 re2)
-= admit()
+  (y: 'a{composable p x y})
+: Lemma (conj_refinement_f re1 re2 (op p x y))
+= p.is_unit y;
+  re1.f_closed_comp (one p) y;
+  p.comm (one p) y;
+  re2.f_closed_comp x y
 
-let conj_refinement (#p: pcm 'a)
+let conj_refinement (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_refinement' p = {
   f = conj_refinement_f re1 re2;
+  f_closed_one = conj_refinement_f_closed_one re1 re2;
   f_closed_comp = conj_refinement_f_closed re1 re2;
-  new_one = conj_refinement_new_one re1 re2;
-  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
-  new_one_comp = conj_refinement_new_one_comp re1 re2;
 }
 
-let pcm_refinement'_conj_iso_i (p: pcm 'a)
+let pcm_refinement'_conj_iso_i (p: refined_one_pcm 'a)
   (re1: pcm_refinement' p)
   (re2: pcm_refinement' (refined_pcm' re1))
 : iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
@@ -881,7 +818,7 @@ let pcm_refinement'_conj_iso_i (p: pcm 'a)
   
 (** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
     refinement by the conjunction of re1 and re2 *)
-let pcm_refinement'_conj_iso (p: pcm 'a)
+let pcm_refinement'_conj_iso (p: refined_one_pcm 'a)
   (re1: pcm_refinement' p)
   (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_iso (refined_pcm' (conj_refinement re1 re2)) (refined_pcm' re2) = {
@@ -909,7 +846,7 @@ let upd_across_pcm_iso
   in FStar.Classical.forall_intro aux;
   w
 
-val conj_unrefinement (#p: pcm 'a)
+val conj_unrefinement (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index bed84ec4891..f4717f97bb5 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -62,22 +62,6 @@ let switch_to_bool (#i: Ghost.erased int)
   ref_write p u;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-mk_int i = (i, one)
-mk_bool b = (one, b)
-
-thread 1:
-  u.case1 = v1
-  p = &u.case1
-  p `pts_to` case1 (1 v1)
-  (p `pts_to` case1 (0.5 v1) `star`
-  (q `pts_to` case1 (0.5 v1))
-  fork()
-  (p `pts_to` case1 (0.5 v1))
-  (focus (refine p .) . `pts_to` v1)
-
-thread 2:
-  (q `pts_to` case1 (0.5 v1))
-
 let switch_to_int (#b: Ghost.erased bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))

From dc0f5d2fefd1cf0ddf31ac54a0165f94bd1b4e74 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 13 Jul 2021 15:01:18 -0700
Subject: [PATCH 078/513] Experiments with fixing unions/refinements

---
 .../steel/arraystructs/FStar.PCM.Extras.fst   |  17 +-
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 210 +++++++++++-------
 2 files changed, 139 insertions(+), 88 deletions(-)

diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
index cad66591639..ddc278352b3 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -26,17 +26,24 @@ let compatible_pcm_morphism #a #b #p #q f m x y =
 
 (** Refinements *)
 
-let pcm_refinement'_comp_one #a #p re x y =
-  p.is_unit x;
-  p.assoc_r x (one p) y;
-  re.f_closed_comp (one p) y
+//val pcm_refinement'_compatible_closed
+//  (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
+//  (x: refine_t re.f{~ (x == one p)}) (y: 'a{compatible p x y})
+//: Lemma (re.f y /\ compatible (refined_pcm' re) x y)
+//
+//val pcm_refinement'_comp_new_one
+//  (#p: pcm 'a) (re: pcm_refinement' p)
+//  (x: refine_t re.f) (y: 'a{composable p x y})
+//: Lemma (re.f_comp p (one p) y /\ re.f (op p (one p) y) /\
+//         re.f_comp (refined_pcm' re) x (op p (one p) y))
 
 let pcm_refinement'_compatible_closed #a #p re x y =
   let p' = refined_pcm' re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    pcm_refinement'_comp_one re x frame_x;
+    //pcm_refinement'_comp_one re x frame_x;
+    assume (composable pcm x frame /\ op pcm frame x == y);
     let frame = op p (one p) frame_x in
     p.is_unit x;
     p.comm x frame_x;
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index 7c1faf61521..a3d74fdcd87 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -192,15 +192,19 @@ val compatible_pcm_morphism
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement' #a (p: pcm a) = {
   f: a -> prop;
+  f_comp:(f_comp:symrel a{(forall x y. f_comp x y ==> composable p x y) /\
+    (forall (x:refine_t f) y. ~ (x == one p) ==> (f_comp x y <==> composable p x y))});
   f_closed_one: squash (f (one p));
-  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
+  f_closed_comp: x: refine_t f -> y: a{f_comp x y} -> Lemma (f y /\ f (op p x y));
+  f_is_unit: x: refine_t f -> Lemma (f_comp x (one p))
 }
 
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = r.f_comp
 
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
-  (x: refine_t r.f) (y: refine_t r.f{composable p x y}): refine_t r.f
-= r.f_closed_comp x y; op p x y
+  (x: refine_t r.f) (y: refine_t r.f{r.f_comp x y}): refine_t r.f
+= r.f_closed_comp x y;
+  op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
@@ -212,18 +216,12 @@ let refined_one_pcm a = p:pcm a{
 let refined_pcm' (#p: refined_one_pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
   p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = p.p.one};
   comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> p.assoc x y z);
-  assoc_r = (fun x y z -> p.assoc_r x y z);
-  is_unit = (fun x -> p.is_unit x);
+  assoc = (fun x y z -> admit()); //p.assoc x y z);
+  assoc_r = (fun x y z -> admit()); //p.assoc_r x y z);
+  is_unit = (fun x -> admit()); //p.is_unit x);
   refine = p.refine;
 }
 
-val pcm_refinement'_comp_one
-  (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
-  (x: refine_t re.f) (y: 'a{composable p x y})
-: Lemma (composable p (one p) y /\ re.f (op p (one p) y) /\
-         composable (refined_pcm' re) x (op p (one p) y))
-
 val pcm_refinement'_compatible_closed
   (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{compatible p x y})
@@ -355,33 +353,33 @@ let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p
 
 (** A PCM for unions TODO move to proper place *)
 
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
+let is_union_case (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
   forall k'. ~ (k == k') ==> f k' == one (p k')
 
-let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+let is_union_case_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
   (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
-: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
+: Lemma (is_union_case p k f) = FStar.Classical.forall_intro h
 
-let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
+let is_union_case_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
 : Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
+    (requires is_union_case p j f /\ is_union_case p k f /\ ~ (j == k))
     (ensures f == one (prod_pcm p))
 = ext f (one (prod_pcm p)) (fun k -> ())
 
 let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
-  (exists (k:'a). True) ==> (exists k. case_refinement_f p k f)
+  (exists (k:'a). True) ==> (exists k. is_union_case p k f)
   (** precondition is there because we don't care if 'a is inhabited *)
 
 let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
 
 let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
-  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
-    [SMTPat (case_refinement_f p k f)]))
+  (cont:(k:'a -> Lemma (requires is_union_case p k f) (ensures goal)
+    [SMTPat (is_union_case p k f)]))
 : Lemma (forall (j:'a). goal)
 = let _ = cont in ()
 
 let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
-  (k:'a{case_refinement_f p k f})
+  (k:'a{is_union_case p k f})
 : Lemma (is_union p f)
 = ()
 
@@ -406,21 +404,21 @@ let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
     [SMTPat (union_comp p f g)]
 = prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
 
-let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+let is_union_case_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
 : Lemma
-    (requires case_refinement_f p k f /\ f k == one (p k))
+    (requires is_union_case p k f /\ f k == one (p k))
     (ensures f == one (prod_pcm p))
-    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
+    [SMTPat (is_union_case p k f); SMTPat (f k == one (p k))]
 = ext f (one (prod_pcm p)) (fun _ -> ())
 
-let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
+let is_union_case_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
 : Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
+    (requires is_union_case p j f /\ is_union_case p k g /\ union_comp p f g)
     (ensures
       f == one (prod_pcm p) \/
       g == one (prod_pcm p) \/ 
-      case_refinement_f p k (prod_op p f g))
-    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
+      is_union_case p k (prod_op p f g))
+    [SMTPat (is_union_case p j f); SMTPat (is_union_case p k g)]
 = let fj_or_gk_one
   : squash
       (f j == one (p j) \/ g k == one (p k) ==>
@@ -429,22 +427,22 @@ let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a
   in let fj_gk_both_not_one ()
   : Lemma
       (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures case_refinement_f p k (prod_op p f g))
-  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+      (ensures is_union_case p k (prod_op p f g))
+  = is_union_case_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
   in
   move_requires fj_gk_both_not_one ();
   assert
    ((f j == one (p j) \/ g k == one (p k)) ==>
     f == one (prod_pcm p) \/
     g == one (prod_pcm p) \/ 
-    case_refinement_f p k (prod_op p f g))
+    is_union_case p k (prod_op p f g))
 
 let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
   let h = prod_op p f g in
   let goal = is_union p h in
   union_elim p f goal (fun j ->
   union_elim p g goal (fun k ->
-  case_refinement_f_op p j k f g;
+  is_union_case_op p j k f g;
   (prod_pcm p).is_unit g));
   h
 
@@ -492,55 +490,46 @@ let union_pcm (p:(k:'a -> refined_one_pcm ('b k))): refined_one_pcm (union p) =
     ext y (one p') (fun k -> let _ = p k in ())
   in p'
 
-(*
-let case_refinement_closed_comp (p:(k:'a -> pcm ('b k))) (k:'a)
-  (f:refine_t (case_refinement_f p k))
-  (g:restricted_t 'a 'b{composable (prod_pcm p) f g})
-: Lemma (case_refinement_f p k (op (prod_pcm p) f g))
-=  admit()
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f:union p): prop =
+  is_union_case p k f
 
+let case_refinement_f_comp (p:(k:'a -> pcm ('b k))) (k:'a): symrel (union p) = fun f g ->
+  composable (prod_pcm p) f g /\ is_union_case p k f /\ is_union_case p k g
 
-let case_refinement (p:(k:'a -> pcm ('b k))) (k:'a): pcm_refinement (prod_pcm p) =
-  let refi: pcm_refinement' (prod_pcm p) = {
+let case_refinement_closed_comp (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
+  (f:refine_t (case_refinement_f p k))
+  (g:union p{case_refinement_f_comp p k f g})
+: Lemma (case_refinement_f p k (op (union_pcm p) f g))
+= assert (is_union_case p k f);
+  assert (is_union_case p k g);
+  assert (composable (union_pcm p) f g);
+  assert(~ (g k == one (p k)) ==> case_refinement_f p k (op (union_pcm p) f g));
+  let goal = g k == one (p k) ==> case_refinement_f p k (op (union_pcm p) f g) in
+  union_elim p g goal (fun j ->
+  assert (is_union_case p j g);
+  assert (g j == one (p j) ==> feq g (one (union_pcm p)));
+  (prod_pcm p).is_unit f;
+  assert (g j == one (p j) ==> op (union_pcm p) f g == f);
+  assert (g j == one (p j) ==> goal);
+  assert (f k == one (p k) ==> feq f (one (union_pcm p)));
+  assert (~ (f k == one (p k)) /\ ~ (g j == one (p j)) ==> j == k))
+
+let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) =
+  let refi: pcm_refinement' (union_pcm p) = {
     f = case_refinement_f p k;
-    f_closed_comp = admit();
-    new_one = admit();
-    new_one_is_refined_unit = admit();
+    f_comp = case_refinement_f_comp p k;
+    f_closed_one = ();
+    f_closed_comp = case_refinement_closed_comp p k;
+    f_is_unit = (fun f ->
+      assert (is_union_case p k f);
+      assert (is_union_case p k (one (prod_pcm p)));
+      (prod_pcm p).is_unit f;
+      assert (case_refinement_f_comp p k f (one (prod_pcm p))));
   } in
   let u: pcm_unrefinement refi = admit() in
   {refi = refi; u = u}
 
-
-//let is_refinement pcm_refinement' #a (p: pcm a) = {
-//  f: a -> prop;
-//  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
-//  new_one: (new_one:refine_t f{p.refine new_one});
-//  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x)
-//}
-
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union 'b) = fun x y -> match x, y with
-  | None, z | z, None -> True
-  | Some (|xa, xb|), Some (|ya, yb|) -> xa == ya /\ composable (p xa) xb yb
-
-let union_op (p:(k:'a -> pcm ('b k))) (x: union 'b) (y: union 'b{union_comp p x y}) : union 'b = match x, y with
-  | None, z | z, None -> z
-  | Some (|xa, xb|), Some (|ya, yb|) -> Some (|xa, (p xa).p.op xb yb|)
-
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union 'b) = {
-  p = {composable = union_comp p; op = union_op p; one = None};
-  comm = (fun x y -> match x, y with
-    | None, _ | _, None -> ()
-    | Some (|xa, xb|), Some (|ya, yb|) -> (p xa).comm xb yb);
-  assoc = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc xb yb zb);
-  assoc_r = (fun x y z -> match x, y, z with
-    | None, _, _ | _, _, None | _, None, _ -> ()
-    | Some (|xa, xb|), Some (|ya, yb|), Some (|za, zb|) -> (p xa).assoc_r xb yb zb);
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with None -> True | Some (|xa, xb|) -> (p xa).refine xb)
-}
-
+(*
 (** The refinement of an n-ary union PCM to the k-th case *)
 
 let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
@@ -598,6 +587,10 @@ let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (x: 'a): prop
 = re.f (get l x)
 
+let extend_refinement_f_comp (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q): symrel 'a
+= fun x y -> re.f_comp (get l x) (get l y) /\ composable p x y
+
 let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (s: refine_t (extend_refinement_f l re))
 : refine_t re.f
@@ -625,17 +618,30 @@ let extend_refinement_f_closed_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm
 
 let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-  (y: 'a{composable p x y})
-: Lemma (extend_refinement_f l re (op p x y))
+  (y: 'a{extend_refinement_f_comp l re x y})
+: Lemma (extend_refinement_f l re y /\ extend_refinement_f l re (op p x y))
 = l.get_morphism.f_op x y;
+  p.is_unit x;
+  l.get_morphism.f_op x (one p);
+  l.get_morphism.f_one ();
   re.f_closed_comp (get l x) (get l y)
-  
+
+let extend_refinement_f_is_unit (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
+: Lemma (extend_refinement_f_comp l re x (one p))
+= p.is_unit x;
+  re.f_is_unit (get l x);
+  l.get_morphism.f_one ();
+  assert (re.f_comp (get l x) (get l (one p)) /\ composable p x (one p))
+
 let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : pcm_refinement' p = {
   f = extend_refinement_f l re;
+  f_comp = extend_refinement_f_comp l re;
   f_closed_one = extend_refinement_f_closed_one l re;
   f_closed_comp = extend_refinement_f_closed l re;
+  f_is_unit = extend_refinement_f_is_unit l re;
 }
 
 let pcm_lens_refine_get_morphism_refine
@@ -787,6 +793,10 @@ let conj_refinement_f (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : 'a -> prop = conj #'a re1.f re2.f
 
+let conj_refinement_f_comp (#p: refined_one_pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
+: symrel 'a = fun x y -> re1.f_comp x y /\ re1.f x /\ re1.f y /\ re2.f_comp x y
+
 let conj_refinement_f_closed_one (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : squash (conj_refinement_f re1 re2 (one p))
@@ -795,19 +805,33 @@ let conj_refinement_f_closed_one (#p: refined_one_pcm 'a)
 let conj_refinement_f_closed (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (x: refine_t (conj_refinement_f re1 re2))
-  (y: 'a{composable p x y})
-: Lemma (conj_refinement_f re1 re2 (op p x y))
+  (y: 'a{conj_refinement_f_comp re1 re2 x y})
+: Lemma (conj_refinement_f re1 re2 y /\ conj_refinement_f re1 re2 (op p x y))
 = p.is_unit y;
-  re1.f_closed_comp (one p) y;
-  p.comm (one p) y;
-  re2.f_closed_comp x y
+  assert (re1.f_comp x y /\ re1.f x /\ re1.f y /\ re2.f_comp x y);
+  re1.f_closed_comp x y;
+  assert (re1.f y);
+  assert (re1.f (op p x y));
+  re2.f_closed_comp x y;
+  assert (re1.f (op p x y) /\ re2.f (op p x y))
+
+let conj_refinement_f_is_unit (#p: refined_one_pcm 'a)
+  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
+  (x: refine_t (conj_refinement_f re1 re2))
+: Lemma (conj_refinement_f_comp re1 re2 x (one p))
+= re1.f_is_unit x;
+  re2.f_is_unit x;
+  assert (re1.f_comp x (one p) /\ re1.f x /\ re1.f (one p) /\ re2.f_comp x (one p));
+  assert (re1.f_comp x (one p) /\ re1.f x /\ re1.f (one p) /\ re2.f_comp x (one p))
 
 let conj_refinement (#p: refined_one_pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_refinement' p = {
   f = conj_refinement_f re1 re2;
+  f_comp = conj_refinement_f_comp re1 re2;
   f_closed_one = conj_refinement_f_closed_one re1 re2;
   f_closed_comp = conj_refinement_f_closed re1 re2;
+  f_is_unit = conj_refinement_f_is_unit re1 re2;
 }
 
 let pcm_refinement'_conj_iso_i (p: refined_one_pcm 'a)
@@ -888,3 +912,23 @@ let init_pcm (p: pcm 'a): pcm (init 'a) = {
     | _ -> True)
 }
 
+/// Troubles with unions:
+/// - If represent as option (tag:a & payload: b tag),
+///   the value Some (|tag, one|) is a valid frame for Some (|tag, payload|),
+///   which prevents Some (|tag, payload|) ~~> Some (|tag', payload|) from being
+///   a frame-preserving update. (So, no way to switch the case of a union).
+/// - If represent as (n-ary product where at most one component can be non-unit),
+///   can't prove that the refinement of a union to the kth case is closed.
+///   Specifically, if x is in kth case and x composable with y,
+///   no guarantee that y is in kth case, because x could be the unit (one, one, ..).
+/// - If try to rule out this case by changing the statement of f_closed to
+///     forall x y. ~ (y == one) ==> ...
+///   then can't prove extend_refinement. Main issue is that if
+///     ~ (x == one)
+///   we can't conclude
+///     ~ (get l x == one)
+///   where l is a lens.
+/// - If strengthen the definition of a refinement by adding a new composability relation
+///   f_comp that is a subrelation of (composable p), pcm_refinement'_compatible_closed
+///   fails because need to show that a frame that's p-composable with
+///   some x is f_comp-composable with x, which is not true in general.

From 5d3e934f8178989400130144dc69c9284fa8ff65 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 14 Jul 2021 07:29:05 -0700
Subject: [PATCH 079/513] Try represent unions as products of uninitialized
 components

---
 .../arraystructs/AggregateRefExamples.fst     |   2 -
 .../steel/arraystructs/FStar.PCM.Extras.fst   |  41 +-
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 537 ++++++++++--------
 examples/steel/arraystructs/IntOrBool.fst     |  16 +
 4 files changed, 336 insertions(+), 260 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index d4178a9fcef..60e52de6124 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -153,7 +153,6 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
 /// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
 /// { generic_swap(&p.i, &q.i); }
 
-(*
 open IntOrBool
 
 let int_or_bool_int_swap
@@ -205,7 +204,6 @@ val int_or_bool_to_int
     //A.return (if b then 1 else 0)
   end
 *)
-*)
 
 //let int_or_bool_to_int
 //  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
index ddc278352b3..71d418d64a1 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fst
@@ -26,30 +26,23 @@ let compatible_pcm_morphism #a #b #p #q f m x y =
 
 (** Refinements *)
 
-//val pcm_refinement'_compatible_closed
-//  (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
-//  (x: refine_t re.f{~ (x == one p)}) (y: 'a{compatible p x y})
-//: Lemma (re.f y /\ compatible (refined_pcm' re) x y)
-//
-//val pcm_refinement'_comp_new_one
-//  (#p: pcm 'a) (re: pcm_refinement' p)
-//  (x: refine_t re.f) (y: 'a{composable p x y})
-//: Lemma (re.f_comp p (one p) y /\ re.f (op p (one p) y) /\
-//         re.f_comp (refined_pcm' re) x (op p (one p) y))
+let pcm_refinement'_comp_new_one #a #p re x y =
+  re.new_one_is_refined_unit x;
+  p.assoc_r x re.new_one y;
+  re.f_closed_comp re.new_one y
 
 let pcm_refinement'_compatible_closed #a #p re x y =
   let p' = refined_pcm' re in
   compatible_elim p x y (re.f y) (fun frame ->
    re.f_closed_comp x frame; p.comm frame x);
   compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    //pcm_refinement'_comp_one re x frame_x;
-    assume (composable pcm x frame /\ op pcm frame x == y);
-    let frame = op p (one p) frame_x in
-    p.is_unit x;
+    pcm_refinement'_comp_new_one re x frame_x;
+    let frame = op p re.new_one frame_x in
+    re.new_one_is_refined_unit x;
     p.comm x frame_x;
-    p.assoc x (one p) frame_x;
-    p.comm x (op p (one p) frame_x);
-    compatible_intro p' x y (op p (one p) frame_x))
+    p.assoc x re.new_one frame_x;
+    p.comm x (op p re.new_one frame_x);
+    compatible_intro p' x y (op p re.new_one frame_x))
 
 (** PCM lenses *)
 
@@ -117,7 +110,7 @@ let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
   | _ -> None
 *)
 
-let conj_unrefinement (#p: refined_one_pcm 'a)
+let conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
@@ -137,11 +130,11 @@ let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   let w = f v in
   let aux (frame:'a{composable p x frame})
   : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
-  = pcm_refinement'_comp_one re' x frame;
-    let frame' = op p (one p) frame in
-    p.assoc y (one p) frame;
-    p.is_unit y;
-    p.assoc x (one p) frame;
-    p.is_unit x
+  = pcm_refinement'_comp_new_one re' x frame;
+    let frame' = op p re'.new_one frame in
+    p.assoc y re'.new_one frame;
+    re'.new_one_is_refined_unit y;
+    p.assoc x re'.new_one frame;
+    re'.new_one_is_refined_unit x
   in FStar.Classical.forall_intro aux;
   w
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
index a3d74fdcd87..550be0d9c53 100644
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
@@ -187,43 +187,55 @@ val compatible_pcm_morphism
   (x y: Ghost.erased 'a)
 : Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
 
-(** A refinement of a PCM (p: pcm a) consists of a set of elements
-    f:(a -> prop) closed under (op p) *)
+(** A refinement of a PCM (p: pcm a) consists of:
+    (1) A set of elements f:(a -> prop) closed under (op p)
+    (2) An element new_unit which satisfies the unit laws on the subset f
+        and p.refine *)
 let refine_t (f: 'a -> prop) = x:'a{f x}
 noeq type pcm_refinement' #a (p: pcm a) = {
   f: a -> prop;
-  f_comp:(f_comp:symrel a{(forall x y. f_comp x y ==> composable p x y) /\
-    (forall (x:refine_t f) y. ~ (x == one p) ==> (f_comp x y <==> composable p x y))});
-  f_closed_one: squash (f (one p));
-  f_closed_comp: x: refine_t f -> y: a{f_comp x y} -> Lemma (f y /\ f (op p x y));
-  f_is_unit: x: refine_t f -> Lemma (f_comp x (one p))
+  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
+  new_one: (new_one:refine_t f{p.refine new_one});
+  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x);
+  //new_one_comp: x: refine_t f -> y: refine_t f{composable p x y} ->
+  //  Lemma (requires op p x y == new_one) (ensures x == new_one /\ y == new_one);
 }
 
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = r.f_comp
+let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
 
 let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
-  (x: refine_t r.f) (y: refine_t r.f{r.f_comp x y}): refine_t r.f
+  (x: refine_t r.f) (y: refine_t r.f{pcm_refine_comp r x y}): refine_t r.f
 = r.f_closed_comp x y;
   op p x y
 
 (** Any refinement r for p can be used to construct a refined PCM with the same product
     and composability predicate, but restricted to elements in r.f *)
-let refined_one_pcm a = p:pcm a{
-  p.refine (one p) /\
-  (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
-   op p x y == one p ==> x == one p /\ y == one p)}
-
-let refined_pcm' (#p: refined_one_pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) = {
-  p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = p.p.one};
-  comm = (fun x y -> p.comm x y);
-  assoc = (fun x y z -> admit()); //p.assoc x y z);
-  assoc_r = (fun x y z -> admit()); //p.assoc_r x y z);
-  is_unit = (fun x -> admit()); //p.is_unit x);
-  refine = p.refine;
-}
+let refined_one_pcm a = p:pcm a{p.refine (one p)}
+
+let refined_pcm' (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) =
+  let p' = {
+    p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
+    comm = (fun x y -> p.comm x y);
+    assoc = (fun x y z -> p.assoc x y z);
+    assoc_r = (fun x y z -> p.assoc_r x y z);
+    is_unit = (fun x -> r.new_one_is_refined_unit x);
+    refine = p.refine;
+  } in
+  //let aux (x:refine_t r.f) (y:_{composable p' x y})
+  //: Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+  //  [SMTPat (op p' x y)]
+  //= r.new_one_comp x y
+  //in
+  p'
+
+val pcm_refinement'_comp_new_one
+  (#p: pcm 'a) (re: pcm_refinement' p)
+  (x: refine_t re.f) (y: 'a{composable p x y})
+: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
+         composable (refined_pcm' re) x (op p re.new_one y))
 
 val pcm_refinement'_compatible_closed
-  (#p: refined_one_pcm 'a) (re: pcm_refinement' p)
+  (#p: pcm 'a) (re: pcm_refinement' p)
   (x: refine_t re.f) (y: 'a{compatible p x y})
 : Lemma (re.f y /\ compatible (refined_pcm' re) x y)
 
@@ -235,19 +247,19 @@ let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost
   frame_preserving_upd p x y ->
   frame_preserving_upd q x' y'
 
-let pcm_unrefinement (#p: refined_one_pcm 'a) (r: pcm_refinement' p) =
+let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
   x: Ghost.erased (refine_t r.f) ->
   y: Ghost.erased (refine_t r.f) ->
   frame_pres_lift (refined_pcm' r) x y p (Ghost.reveal x) (Ghost.reveal y)
 
-noeq type pcm_refinement #a (p: refined_one_pcm a) = {
+noeq type pcm_refinement #a (p: pcm a) = {
   refi: pcm_refinement' p;
   u: pcm_unrefinement refi;
 }
 
-let refinement_f (#p: refined_one_pcm 'a) (r: pcm_refinement p) = r.refi.f
+let refinement_f (#p: pcm 'a) (r: pcm_refinement p) = r.refi.f
 
-let refined_pcm (#p: refined_one_pcm 'a) (r: pcm_refinement p)
+let refined_pcm (#p: pcm 'a) (r: pcm_refinement p)
 : refined_one_pcm (refine_t (refinement_f r))
 = refined_pcm' r.refi
 
@@ -351,103 +363,140 @@ let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p
   }
 }
 
+(** A PCM for possibly-uninitialized data *)
+
+type init a =
+| One : init a
+| Uninitialized : init a
+| Initialized : a -> init a
+
+let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
+  | One, _ | _, One -> True
+  | Initialized x, Initialized y -> composable p x y
+  | _, _ -> False
+
+let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
+  | One, z | z, One -> z
+  | Initialized x, Initialized y -> Initialized (op p x y)
+
+let init_pcm (p: pcm 'a): pcm (init 'a) = {
+  p = {composable = init_comp p; op = init_op p; one = One #'a};
+  comm = (fun x y -> match x, y with
+    | Initialized x, Initialized y -> p.comm x y
+    | _, _ -> ());
+  assoc = (fun x y z -> match x, y, z with
+    | Initialized x, Initialized y, Initialized z -> p.assoc x y z
+    | _, _, _ -> ());
+  assoc_r = (fun x y z -> match x, y, z with
+    | Initialized x, Initialized y, Initialized z -> p.assoc_r x y z
+    | _, _, _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> match x with
+    | Initialized x -> p.refine x
+    | _ -> True)
+}
+
 (** A PCM for unions TODO move to proper place *)
 
-let is_union_case (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
-  forall k'. ~ (k == k') ==> f k' == one (p k')
+let union_fam (b:'a->Type) (k:'a) = init (b k)
+let union_fn (b:'a->Type) = restricted_t 'a (union_fam b)
+let union_pcm_fam (p:(k:'a -> pcm ('b k))) (k:'a): pcm (init ('b k)) = init_pcm (p k)
+let union_prod_pcm (p:(k:'a -> pcm ('b k))): pcm (union_fn 'b) = prod_pcm (union_pcm_fam p)
+
+let is_union_case (p:(k:'a -> pcm ('b k))) (k:'a) (f: union_fn 'b): prop =
+  forall k'. ~ (k == k') ==> f k' == Uninitialized
 
-let is_union_case_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
+let is_union_case_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: union_fn 'b)
+  (h:(k':'a{~ (k == k')} -> Lemma (f k' == Uninitialized)))
 : Lemma (is_union_case p k f) = FStar.Classical.forall_intro h
 
-let is_union_case_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires is_union_case p j f /\ is_union_case p k f /\ ~ (j == k))
-    (ensures f == one (prod_pcm p))
-= ext f (one (prod_pcm p)) (fun k -> ())
+//let is_union_case_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: union_fn 'b)
+//: Lemma
+//    (requires is_union_case p j f /\ is_union_case p k f /\ ~ (j == k))
+//    (ensures f == one (prod_pcm p))
+//= ext f (one (prod_pcm p)) (fun k -> ())
 
-let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
-  (exists (k:'a). True) ==> (exists k. is_union_case p k f)
-  (** precondition is there because we don't care if 'a is inhabited *)
+let is_union (p:(k:'a -> pcm ('b k))) (f: union_fn 'b) =
+  f == one (union_prod_pcm p) \/ (exists k. is_union_case p k f)
 
-let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
+let union (p:(k:'a -> pcm ('b k))) = f:union_fn 'b{is_union p f}
 
 let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
-  (cont:(k:'a -> Lemma (requires is_union_case p k f) (ensures goal)
+  (cont1:(unit -> Lemma (requires f == one (union_prod_pcm p)) (ensures goal)))
+  (cont2:(k:'a -> Lemma (requires is_union_case p k f) (ensures goal)
     [SMTPat (is_union_case p k f)]))
-: Lemma (forall (j:'a). goal)
-= let _ = cont in ()
+: Lemma goal
+= let _ = cont2 in move_requires cont1 ()
 
-let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
+let is_union_intro (p:(k:'a -> pcm ('b k))) (f: union_fn 'b)
   (k:'a{is_union_case p k f})
 : Lemma (is_union p f)
 = ()
 
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
-  forall j k.
-  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
-  j == k /\ composable (p k) (f k) (g k)
-
-let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (h:(j:'a -> k:'a ->
-    Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures j == k /\ composable (p k) (f k) (g k))
-      [SMTPat (f j); SMTPat (g k)]))
-: Lemma (union_comp p f g)
-= let _ = h in ()
-
-let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
-: Lemma
-    (requires union_comp p f g)
-    (ensures prod_comp p f g)
-    [SMTPat (union_comp p f g)]
-= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
-
-let is_union_case_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires is_union_case p k f /\ f k == one (p k))
-    (ensures f == one (prod_pcm p))
-    [SMTPat (is_union_case p k f); SMTPat (f k == one (p k))]
-= ext f (one (prod_pcm p)) (fun _ -> ())
-
-let is_union_case_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
-: Lemma
-    (requires is_union_case p j f /\ is_union_case p k g /\ union_comp p f g)
-    (ensures
-      f == one (prod_pcm p) \/
-      g == one (prod_pcm p) \/ 
-      is_union_case p k (prod_op p f g))
-    [SMTPat (is_union_case p j f); SMTPat (is_union_case p k g)]
-= let fj_or_gk_one
-  : squash
-      (f j == one (p j) \/ g k == one (p k) ==>
-       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
-  = ()
-  in let fj_gk_both_not_one ()
-  : Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures is_union_case p k (prod_op p f g))
-  = is_union_case_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
-  in
-  move_requires fj_gk_both_not_one ();
-  assert
-   ((f j == one (p j) \/ g k == one (p k)) ==>
-    f == one (prod_pcm p) \/
-    g == one (prod_pcm p) \/ 
-    is_union_case p k (prod_op p f g))
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = composable (union_prod_pcm p)
+//fun f g ->
+//  forall j k.
+//  ~ (f j == Uninitialized) /\ ~ (g k == Uninitialized) ==>
+//  j == k /\ composable (init_pcm (p k)) (f k) (g k)
+
+//let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
+//  (h:(j:'a -> k:'a ->
+//    Lemma
+//      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+//      (ensures j == k /\ composable (p k) (f k) (g k))
+//      [SMTPat (f j); SMTPat (g k)]))
+//: Lemma (union_comp p f g)
+//= let _ = h in ()
+
+//let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
+//: Lemma
+//    (requires union_comp p f g)
+//    (ensures prod_comp p f g)
+//    [SMTPat (union_comp p f g)]
+//= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
+
+//let is_union_case_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: union_fn 'b)
+//: Lemma
+//    (requires is_union_case p k f /\ f k == one (p k))
+//    (ensures f == one (prod_pcm p))
+//    [SMTPat (is_union_case p k f); SMTPat (f k == one (p k))]
+//= ext f (one (prod_pcm p)) (fun _ -> ())
+
+//let is_union_case_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: union_fn 'b)
+//: Lemma
+//    (requires is_union_case p j f /\ is_union_case p k g /\ union_comp p f g)
+//    (ensures
+//      f == one (prod_pcm p) \/
+//      g == one (prod_pcm p) \/ 
+//      is_union_case p k (prod_op p f g))
+//    [SMTPat (is_union_case p j f); SMTPat (is_union_case p k g)]
+//= let fj_or_gk_one
+//  : squash
+//      (f j == one (p j) \/ g k == one (p k) ==>
+//       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
+//  = ()
+//  in let fj_gk_both_not_one ()
+//  : Lemma
+//      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+//      (ensures is_union_case p k (prod_op p f g))
+//  = is_union_case_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+//  in
+//  move_requires fj_gk_both_not_one ();
+//  assert
+//   ((f j == one (p j) \/ g k == one (p k)) ==>
+//    f == one (prod_pcm p) \/
+//    g == one (prod_pcm p) \/ 
+//    is_union_case p k (prod_op p f g))
 
 let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
-  let h = prod_op p f g in
+  let h = op (union_prod_pcm p) f g in
   let goal = is_union p h in
-  union_elim p f goal (fun j ->
-  union_elim p g goal (fun k ->
-  is_union_case_op p j k f g;
-  (prod_pcm p).is_unit g));
+  union_elim p f goal (fun () -> (union_prod_pcm p).is_unit g) (fun j ->
+  union_elim p g goal (fun () -> (union_prod_pcm p).is_unit f) (fun k -> ()));
   h
 
-let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
-let union_refine (p:(k:'a -> pcm ('b k))) = prod_refine p
+let union_one (p:(k:'a -> pcm ('b k))): union p = one (union_prod_pcm p)
+let union_refine (p:(k:'a -> pcm ('b k))) = (union_prod_pcm p).refine
 
 let union_assoc (p:(k:'a -> refined_one_pcm ('b k)))
   (x y: union p)
@@ -455,9 +504,7 @@ let union_assoc (p:(k:'a -> refined_one_pcm ('b k)))
 : Lemma (union_comp p x y /\
          union_comp p (union_op p x y) z /\
          union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
+= (union_prod_pcm p).assoc x y z
 
 let union_assoc_r (p:(k:'a -> refined_one_pcm ('b k)))
   (x y: union p)
@@ -465,70 +512,108 @@ let union_assoc_r (p:(k:'a -> refined_one_pcm ('b k)))
 : Lemma (union_comp p y z /\
          union_comp p x (union_op p y z) /\
          union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc_r p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
+= (union_prod_pcm p).assoc_r x y z
 
 let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
 : Lemma (union_comp p x (union_one p) /\
          union_op p x (union_one p) == x)
-= (prod_pcm p).is_unit x
+= (union_prod_pcm p).is_unit x
 
 let union_pcm (p:(k:'a -> refined_one_pcm ('b k))): refined_one_pcm (union p) =
   let p' = {
     p = {composable = union_comp p; op = union_op p; one = union_one p};
-    comm = (fun x y -> prod_comm p x y);
+    comm = (fun x y -> (union_prod_pcm p).comm x y);
     assoc = union_assoc p;
     assoc_r = union_assoc_r p;
     is_unit = union_is_unit p;
     refine = union_refine p;
   } in
-  let aux (x:union p) (y:union p{composable p' x y})
-  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-    [SMTPat (op p' x y)]
-  = ext x (one p') (fun k -> let _ = p k in ());
-    ext y (one p') (fun k -> let _ = p k in ())
-  in p'
+  //let aux (x:union p) (y:union p{composable p' x y})
+  //: Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+  //  [SMTPat (op p' x y)]
+  //= ext x (one p') (fun k -> let _ = p k in ());
+  //  ext y (one p') (fun k -> let _ = p k in ())
+  //in
+  p'
 
 let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f:union p): prop =
   is_union_case p k f
 
-let case_refinement_f_comp (p:(k:'a -> pcm ('b k))) (k:'a): symrel (union p) = fun f g ->
-  composable (prod_pcm p) f g /\ is_union_case p k f /\ is_union_case p k g
-
 let case_refinement_closed_comp (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
   (f:refine_t (case_refinement_f p k))
-  (g:union p{case_refinement_f_comp p k f g})
+  (g:union p{composable (union_pcm p) f g})
 : Lemma (case_refinement_f p k (op (union_pcm p) f g))
 = assert (is_union_case p k f);
-  assert (is_union_case p k g);
-  assert (composable (union_pcm p) f g);
-  assert(~ (g k == one (p k)) ==> case_refinement_f p k (op (union_pcm p) f g));
-  let goal = g k == one (p k) ==> case_refinement_f p k (op (union_pcm p) f g) in
-  union_elim p g goal (fun j ->
-  assert (is_union_case p j g);
-  assert (g j == one (p j) ==> feq g (one (union_pcm p)));
-  (prod_pcm p).is_unit f;
-  assert (g j == one (p j) ==> op (union_pcm p) f g == f);
-  assert (g j == one (p j) ==> goal);
-  assert (f k == one (p k) ==> feq f (one (union_pcm p)));
-  assert (~ (f k == one (p k)) /\ ~ (g j == one (p j)) ==> j == k))
-
-let case_refinement (p:(k:'a -> refined_one_pcm ('b k))) (k:'a): pcm_refinement (union_pcm p) =
+  assert (case_refinement_f p k (op (union_pcm p) f g))
+  //assert (is_union_case p k g);
+  //assert (composable (union_pcm p) f g);
+  //assert(~ (g k == one (p k)) ==> case_refinement_f p k (op (union_pcm p) f g));
+  //let goal = g k == one (p k) ==> case_refinement_f p k (op (union_pcm p) f g) in
+  //union_elim p g goal (fun j ->
+  //assert (is_union_case p j g);
+  //assert (g j == one (p j) ==> feq g (one (union_pcm p)));
+  //(prod_pcm p).is_unit f;
+  //assert (g j == one (p j) ==> op (union_pcm p) f g == f);
+  //assert (g j == one (p j) ==> goal);
+  //assert (f k == one (p k) ==> feq f (one (union_pcm p)));
+  //assert (~ (f k == one (p k)) /\ ~ (g j == one (p j)) ==> j == k))
+
+let case_refinement_new_one (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
+: (new_one:refine_t (is_union_case p k){union_refine p new_one})
+= let f: arrow a (union_fam b) = fun k' -> if k = k' then one (init_pcm (p k)) else Uninitialized in
+  let f': union p = on_domain a f in
+  assert (is_union_case p k f');
+  f'
+  //assert (is_union_case p k g);
+  //assert (composable (union_pcm p) f g);
+  //assert(~ (g k == one (p k)) ==> case_refinement_f p k (op (union_pcm p) f g));
+  //let goal = g k == one (p k) ==> case_refinement_f p k (op (union_pcm p) f g) in
+  //union_elim p g goal (fun j ->
+  //assert (is_union_case p j g);
+  //assert (g j == one (p j) ==> feq g (one (union_pcm p)));
+  //(prod_pcm p).is_unit f;
+  //assert (g j == one (p j) ==> op (union_pcm p) f g == f);
+  //assert (g j == one (p j) ==> goal);
+  //assert (f k == one (p k) ==> feq f (one (union_pcm p)));
+  //assert (~ (f k == one (p k)) /\ ~ (g j == one (p j)) ==> j == k))
+  
+// Fails because (Uninit, .., One, Uninit, ..) is never composable with (Uninit, .., x, Uninit, ..)
+let case_refinement_new_one_is_refined_unit (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
+  (x: union p)
+: Lemma (composable (union_pcm p) x (case_refinement_new_one p k) /\
+         op (union_pcm p) x (case_refinement_new_one p k) == x)
+= assume(composable (union_prod_pcm p) x (case_refinement_new_one p k));
+  let aux (k':a): Lemma ((op (union_prod_pcm p) x (case_refinement_new_one p k)) k' == x k')
+  = if k = k'
+    then (init_pcm (p k)).is_unit (x k)
+    else begin
+      assert (composable (init_pcm (p k')) (x k') Uninitialized);
+      assert (x k' == One);
+      (init_pcm (p k')).is_unit Uninitialized;
+      (init_pcm (p k')).comm (x k') Uninitialized;
+      admit();
+      assert (op (init_pcm (p k')) (x k') (Uninitialized #(b k')) == x k')
+    end
+  in forall_intro aux;
+  assert (op (union_prod_pcm p) x (case_refinement_new_one p k) `feq` x)
+
+let case_refinement (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a): pcm_refinement (union_pcm p) =
   let refi: pcm_refinement' (union_pcm p) = {
     f = case_refinement_f p k;
-    f_comp = case_refinement_f_comp p k;
-    f_closed_one = ();
     f_closed_comp = case_refinement_closed_comp p k;
-    f_is_unit = (fun f ->
-      assert (is_union_case p k f);
-      assert (is_union_case p k (one (prod_pcm p)));
-      (prod_pcm p).is_unit f;
-      assert (case_refinement_f_comp p k f (one (prod_pcm p))));
+    new_one = case_refinement_new_one p k;
+    new_one_is_refined_unit = (fun _ -> ());
+    //new_one_comp = admit();
+    //f_is_unit = (fun f ->
+    //  assert (is_union_case p k f);
+    //  assert (is_union_case p k (one (prod_pcm p)));
+    //  (prod_pcm p).is_unit f;
+    //  assert (case_refinement_f_comp p k f (one (prod_pcm p))));
   } in
   let u: pcm_unrefinement refi = admit() in
   {refi = refi; u = u}
 
+
 (*
 (** The refinement of an n-ary union PCM to the k-th case *)
 
@@ -587,10 +672,6 @@ let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (x: 'a): prop
 = re.f (get l x)
 
-let extend_refinement_f_comp (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q): symrel 'a
-= fun x y -> re.f_comp (get l x) (get l y) /\ composable p x y
-
 let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (s: refine_t (extend_refinement_f l re))
 : refine_t re.f
@@ -611,37 +692,53 @@ let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement'
   put_put = (fun _ _ _ -> ());
 }
 
-let extend_refinement_f_closed_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: squash (extend_refinement_f l re (one p))
-= l.get_morphism.f_one ()
-
 let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
   (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-  (y: 'a{extend_refinement_f_comp l re x y})
-: Lemma (extend_refinement_f l re y /\ extend_refinement_f l re (op p x y))
+  (y: 'a{composable p x y})
+: Lemma (extend_refinement_f l re (op p x y))
 = l.get_morphism.f_op x y;
-  p.is_unit x;
-  l.get_morphism.f_op x (one p);
-  l.get_morphism.f_one ();
   re.f_closed_comp (get l x) (get l y)
 
-let extend_refinement_f_is_unit (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-: Lemma (extend_refinement_f_comp l re x (one p))
-= p.is_unit x;
-  re.f_is_unit (get l x);
-  l.get_morphism.f_one ();
-  assert (re.f_comp (get l x) (get l (one p)) /\ composable p x (one p))
+let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+  (l: pcm_lens p q) (re: pcm_refinement' q)
+: new_one:refine_t (extend_refinement_f l re){p.refine new_one}
+= l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
 
+let extend_refinement_new_one_is_refined_unit
+  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
+  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
+: Lemma (composable p x (extend_refinement_new_one l re) /\
+         op p x (extend_refinement_new_one l re) == x)
+= re.new_one_is_refined_unit (get l x);
+  p.is_unit x;
+  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
+
+//let extend_refinement_new_one_comp (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
+//  (l: pcm_lens p q) (re: pcm_refinement' q)
+//  (x: refine_t (extend_refinement_f l re))
+//  (y: refine_t (extend_refinement_f l re){composable p x y})
+//: Lemma
+//    (requires op p x y == extend_refinement_new_one l re)
+//    (ensures
+//      x == extend_refinement_new_one l re /\ 
+//      y == extend_refinement_new_one l re)
+//= assert (re.f (get l x));
+//  assert (re.f (get l y));
+//  assert (op p x y == put l re.new_one (one p));
+//  l.get_morphism.f_op x y;
+//  re.new_one_comp (get l x) (get l y);
+//  assert (get l x == re.new_one);
+//  assert (get l y == re.new_one);
+//  admit()
+  
 let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q)
 : pcm_refinement' p = {
   f = extend_refinement_f l re;
-  f_comp = extend_refinement_f_comp l re;
-  f_closed_one = extend_refinement_f_closed_one l re;
   f_closed_comp = extend_refinement_f_closed l re;
-  f_is_unit = extend_refinement_f_is_unit l re;
+  new_one = extend_refinement_new_one l re;
+  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
+  //new_one_comp = extend_refinement_new_one_comp l re;
 }
 
 let pcm_lens_refine_get_morphism_refine
@@ -789,52 +886,57 @@ let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
 
 (** The conjunction of two refinements *)
 
-let conj_refinement_f (#p: refined_one_pcm 'a)
+let conj_refinement_f (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : 'a -> prop = conj #'a re1.f re2.f
 
-let conj_refinement_f_comp (#p: refined_one_pcm 'a)
+let conj_refinement_f_closed (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-: symrel 'a = fun x y -> re1.f_comp x y /\ re1.f x /\ re1.f y /\ re2.f_comp x y
-
-let conj_refinement_f_closed_one (#p: refined_one_pcm 'a)
+  (x: refine_t (conj_refinement_f re1 re2))
+  (y: 'a{composable p x y})
+: Lemma (conj_refinement_f re1 re2 (op p x y))
+= pcm_refinement'_comp_new_one re1 x y;
+  re1.f_closed_comp x (op p re1.new_one y);
+  pcm_refinement'_comp_new_one re2 x (op p re1.new_one y);
+  re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
+  p.assoc x re2.new_one (op p re1.new_one y);
+  re2.new_one_is_refined_unit x;
+  p.assoc x re1.new_one y;
+  re1.new_one_is_refined_unit x
+
+(* re1.new_one and re2.new_one both work; we go with re2 *)
+let conj_refinement_new_one (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-: squash (conj_refinement_f re1 re2 (one p))
-= ()
+: refine_t (conj_refinement_f re1 re2)
+= re2.new_one
 
-let conj_refinement_f_closed (#p: refined_one_pcm 'a)
+let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (x: refine_t (conj_refinement_f re1 re2))
-  (y: 'a{conj_refinement_f_comp re1 re2 x y})
-: Lemma (conj_refinement_f re1 re2 y /\ conj_refinement_f re1 re2 (op p x y))
-= p.is_unit y;
-  assert (re1.f_comp x y /\ re1.f x /\ re1.f y /\ re2.f_comp x y);
-  re1.f_closed_comp x y;
-  assert (re1.f y);
-  assert (re1.f (op p x y));
-  re2.f_closed_comp x y;
-  assert (re1.f (op p x y) /\ re2.f (op p x y))
-
-let conj_refinement_f_is_unit (#p: refined_one_pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-: Lemma (conj_refinement_f_comp re1 re2 x (one p))
-= re1.f_is_unit x;
-  re2.f_is_unit x;
-  assert (re1.f_comp x (one p) /\ re1.f x /\ re1.f (one p) /\ re2.f_comp x (one p));
-  assert (re1.f_comp x (one p) /\ re1.f x /\ re1.f (one p) /\ re2.f_comp x (one p))
-
-let conj_refinement (#p: refined_one_pcm 'a)
+: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
+         op p x (conj_refinement_new_one re1 re2) == x)
+= re2.new_one_is_refined_unit x
+
+//let conj_refinement_new_one_comp (#p: pcm 'a)
+//  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
+//  (x: refine_t (conj_refinement_f re1 re2))
+//  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
+//: Lemma 
+//    (requires op p x y == conj_refinement_new_one re1 re2)
+//    (ensures x == conj_refinement_new_one re1 re2 /\ y == conj_refinement_new_one re1 re2)
+//= admit()
+
+let conj_refinement (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_refinement' p = {
   f = conj_refinement_f re1 re2;
-  f_comp = conj_refinement_f_comp re1 re2;
-  f_closed_one = conj_refinement_f_closed_one re1 re2;
   f_closed_comp = conj_refinement_f_closed re1 re2;
-  f_is_unit = conj_refinement_f_is_unit re1 re2;
+  new_one = conj_refinement_new_one re1 re2;
+  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
+  //new_one_comp = conj_refinement_new_one_comp re1 re2;
 }
 
-let pcm_refinement'_conj_iso_i (p: refined_one_pcm 'a)
+let pcm_refinement'_conj_iso_i (p: pcm 'a)
   (re1: pcm_refinement' p)
   (re2: pcm_refinement' (refined_pcm' re1))
 : iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
@@ -842,7 +944,7 @@ let pcm_refinement'_conj_iso_i (p: refined_one_pcm 'a)
   
 (** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
     refinement by the conjunction of re1 and re2 *)
-let pcm_refinement'_conj_iso (p: refined_one_pcm 'a)
+let pcm_refinement'_conj_iso (p: pcm 'a)
   (re1: pcm_refinement' p)
   (re2: pcm_refinement' (refined_pcm' re1))
 : pcm_iso (refined_pcm' (conj_refinement re1 re2)) (refined_pcm' re2) = {
@@ -870,7 +972,7 @@ let upd_across_pcm_iso
   in FStar.Classical.forall_intro aux;
   w
 
-val conj_unrefinement (#p: refined_one_pcm 'a)
+val conj_unrefinement (#p: pcm 'a)
   (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
   (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
 : pcm_unrefinement (conj_refinement #'a re1 re2)
@@ -879,39 +981,6 @@ val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
   (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
 : pcm_unrefinement (extend_refinement l re)
 
-(** A PCM for possibly-uninitialized data *)
-
-type init a =
-| One : init a
-| Uninitialized : init a
-| Initialized : a -> init a
-
-let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
-  | One, _ | _, One -> True
-  | Initialized x, Initialized y -> composable p x y
-  | _, _ -> False
-
-let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
-  | One, z | z, One -> z
-  | Initialized x, Initialized y -> Initialized (op p x y)
-
-let init_pcm (p: pcm 'a): pcm (init 'a) = {
-  p = {composable = init_comp p; op = init_op p; one = One #'a};
-  comm = (fun x y -> match x, y with
-    | Initialized x, Initialized y -> p.comm x y
-    | _, _ -> ());
-  assoc = (fun x y z -> match x, y, z with
-    | Initialized x, Initialized y, Initialized z -> p.assoc x y z
-    | _, _, _ -> ());
-  assoc_r = (fun x y z -> match x, y, z with
-    | Initialized x, Initialized y, Initialized z -> p.assoc_r x y z
-    | _, _, _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with
-    | Initialized x -> p.refine x
-    | _ -> True)
-}
-
 /// Troubles with unions:
 /// - If represent as option (tag:a & payload: b tag),
 ///   the value Some (|tag, one|) is a valid frame for Some (|tag, payload|),
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index f4717f97bb5..bed84ec4891 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -62,6 +62,22 @@ let switch_to_bool (#i: Ghost.erased int)
   ref_write p u;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
+mk_int i = (i, one)
+mk_bool b = (one, b)
+
+thread 1:
+  u.case1 = v1
+  p = &u.case1
+  p `pts_to` case1 (1 v1)
+  (p `pts_to` case1 (0.5 v1) `star`
+  (q `pts_to` case1 (0.5 v1))
+  fork()
+  (p `pts_to` case1 (0.5 v1))
+  (focus (refine p .) . `pts_to` v1)
+
+thread 2:
+  (q `pts_to` case1 (0.5 v1))
+
 let switch_to_int (#b: Ghost.erased bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))

From 91b9b7da344be89630d0ee039eea39f6e71f62fd Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 14 Jul 2021 09:11:48 -0700
Subject: [PATCH 080/513] Ditch PCM lenses for injections

---
 examples/steel/arraystructs/AggregateRef.fst  |  254 ----
 examples/steel/arraystructs/AggregateRef.fsti |  148 ---
 .../arraystructs/AggregateRefExamples.fst     |   32 +-
 .../steel/arraystructs/FStar.PCM.Extras.fst   |  140 ---
 .../steel/arraystructs/FStar.PCM.Extras.fsti  | 1003 ----------------
 examples/steel/arraystructs/Lens.fst          |   45 -
 examples/steel/arraystructs/Steel.C.PCM.fst   | 1055 +++++++++++++++++
 7 files changed, 1058 insertions(+), 1619 deletions(-)
 delete mode 100644 examples/steel/arraystructs/AggregateRef.fst
 delete mode 100644 examples/steel/arraystructs/AggregateRef.fsti
 delete mode 100644 examples/steel/arraystructs/FStar.PCM.Extras.fst
 delete mode 100644 examples/steel/arraystructs/FStar.PCM.Extras.fsti
 delete mode 100644 examples/steel/arraystructs/Lens.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.PCM.fst

diff --git a/examples/steel/arraystructs/AggregateRef.fst b/examples/steel/arraystructs/AggregateRef.fst
deleted file mode 100644
index 3856e0b645a..00000000000
--- a/examples/steel/arraystructs/AggregateRef.fst
+++ /dev/null
@@ -1,254 +0,0 @@
-module AggregateRef
-
-open FStar.PCM
-open FStar.PCM.Extras
-open Lens
-module P = FStar.PCM
-
-open FStar.FunctionalExtensionality
-open Steel.Effect
-
-(** A ref is a pcm_lens combined with a Steel.Memory.ref for the base type 'a.
-    The base type of the lens, unlike the Steel.Memory.ref, is refined by a refinement re.
-    This allows the reference to point to substructures of unions with known case. *)
-noeq type ref a #b (q: refined_one_pcm b): Type = {
-  p: refined_one_pcm a;
-  re: pcm_refinement p;
-  pl: pcm_lens (refined_pcm re) q;
-  r: Steel.Memory.ref a p;
-}
-
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
-
-let pts_to r v = (* TODO unerase v, try [@@@smt_fallback] *)
-  r.r `mpts_to` put r.pl v (one (refined_pcm r.re))
-
-(** The refinement of a ref *)
-
-let ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
-  (r: ref a p) (new_re: pcm_refinement p)
-: ref a (refined_pcm new_re) = {
-  p = r.p;
-  re = {
-    refi = conj_refinement r.re.refi (extend_refinement r.pl new_re.refi);
-    u =
-      conj_unrefinement r.re.refi (extend_refinement r.pl new_re.refi) r.re.u
-        (extend_unrefinement r.pl new_re.refi new_re.u);
-  };
-  pl =
-    pcm_iso_lens_comp
-      (pcm_refinement'_conj_iso r.p r.re.refi (extend_refinement r.pl new_re.refi))
-      (pcm_lens_refine r.pl new_re.refi);
-  r = r.r
-}
-
-(** Fundamental operations on references *)
-
-module M = Steel.Memory
-module A = Steel.Effect.Atomic
-
-let ref_focus #a #b #c #p r #q l =
-  {p = r.p; re = r.re; pl = pcm_lens_comp r.pl l; r = r.r}
-
-let focus (r: ref 'a 'p)
-  (#q: refined_one_pcm 'c)
-  (l: pcm_lens 'p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ref 'a q)
-    (r `pts_to` s)
-    (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == put l x (one 'p))
-    (fun _ r' _ -> r' == ref_focus r l)
-= let r' = ref_focus r l in
-  A.change_slprop_rel  
-    (r `pts_to` s)
-    (r' `pts_to` x)
-    (fun _ _ -> True)
-    (fun m -> r.pl.get_morphism.f_one ());
-  A.return r'
-
-let unfocus #inames
-  (#p: refined_one_pcm 'b)
-  (#q: refined_one_pcm 'c)
-  (r: ref 'a q) (r': ref 'a p)
-  (l: pcm_lens p q) (x: Ghost.erased 'c)
-: A.SteelGhost unit inames
-    (r `pts_to` x)
-    (fun _ -> r' `pts_to` put l x (one p))
-    (requires fun _ -> r == ref_focus r' l)
-    (ensures fun _ _ _ -> True)
-= A.change_slprop_rel  
-    (r `pts_to` x)
-    (r' `pts_to` put l x (one p))
-    (fun _ _ -> True)
-    (fun m -> r'.pl.get_morphism.f_one ())
-
-let split r xy x y =
-  A.change_equal_slprop
-    (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl xy (one (refined_pcm r.re)))));
-  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
-  r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re))
-    (Ghost.reveal y, one (refined_pcm r.re));
-  Steel.PCMReference.split r.r
-    (put r.pl xy (one (refined_pcm r.re)))
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))))
-    (r `pts_to` x);
-  A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))))
-    (r `pts_to` y)
-
-let mgather
-  (#a:Type) (#p:FStar.PCM.pcm a)
-  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: SteelT (_:unit{composable p v0 v1})
-    (mpts_to r v0 `star` mpts_to r v1)
-    (fun _ -> mpts_to r (op p v0 v1))
-= Steel.PCMReference.gather r v0 v1
-
-let gather #a #b #p r x y =
-  A.change_equal_slprop
-    (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl x (one (refined_pcm r.re)))));
-  A.change_equal_slprop
-    (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (put r.pl y (one (refined_pcm r.re)))));
-  mgather r.r
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  r.pl.get_morphism.f_op
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)));
-  (refined_pcm r.re).is_unit (one (refined_pcm r.re));
-  r.pl.put_morphism.f_op
-    (Ghost.reveal x, one (refined_pcm r.re))
-    (Ghost.reveal y, one (refined_pcm r.re));
-  A.change_equal_slprop _ (r `pts_to` op p x y)
-
-let peel (#p: refined_one_pcm 'b) (r: ref 'a p) (#q: refined_one_pcm 'c)
-  (l: pcm_lens p q) (x: Ghost.erased 'b)
-: SteelT unit
-    (r `pts_to` x)
-    (fun _ ->
-      (r `pts_to` put l (one q) x) `star` 
-      (r `pts_to` put l (get l x) (one p)))
-= q.is_unit (get l x);
-  p.is_unit x;
-  q.comm (get l x) (one q);
-  l.put_morphism.f_op (one q, Ghost.reveal x) (get l (Ghost.reveal x), one p);
-  split r x (put l (one q) x) (put l (get l x) (one p))
-
-let addr_of_lens #a #b #c #p r l x =
-  peel r l x;
-  focus r l (put l (get l x) (one p)) (get l x)
-
-let unaddr_of_lens #a #b #c #p #q r' r l x y =
-  unfocus r' r l y;
-  gather r x (put l y (one p));
-  q.is_unit (Ghost.reveal y);
-  p.is_unit (Ghost.reveal x);
-  q.comm (get l x) y;
-  l.put_morphism.f_op (get l x, Ghost.reveal x) (Ghost.reveal y, one p);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
-
-val refine
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
-  (r: ref a p)
-  (re: pcm_refinement p)
-  (x: Ghost.erased b{refinement_f re x})
-: Steel (ref a (refined_pcm re))
-    (r `pts_to` x)
-    (fun r' -> r' `pts_to` Ghost.reveal x)
-    (fun _ -> True)
-    (fun _ r' _ -> r' == ref_refine r re)
-let refine r re x =
-  let r' = ref_refine r re in
-  A.change_equal_slprop (r `pts_to` x) (r' `pts_to` Ghost.reveal x);
-  A.return r'
-
-val unrefine
-  (#opened:Steel.Memory.inames)
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
-  (r': ref a p)
-  (re: pcm_refinement p)
-  (r: ref a (refined_pcm re))
-  (x: Ghost.erased b{refinement_f re x})
-: A.SteelGhost unit opened
-    (r `pts_to` Ghost.reveal x)
-    (fun _ -> r' `pts_to` x)
-    (fun _ -> r == ref_refine r' re)
-    (fun _ _ _ -> True)
-let unrefine #inames r' re r x =
-  A.change_equal_slprop (r `pts_to` Ghost.reveal x) (r' `pts_to` x)
-
-let addr_of_union_lens #a #b #c #p #q r #re l x =
-  let refined_r = refine r re x in
-  focus refined_r l (Ghost.reveal x) (get l x)
-
-let unaddr_of_union_lens #a #b #c #p #q r' r #re l y =
-  let refined_r = ref_refine r re in // TODO interestingly if i inline this definition, F* hangs
-  unfocus r' refined_r l y;
-  unrefine r re refined_r (Ghost.hide (put l (Ghost.reveal y) (one (refined_pcm re))))
-
-let ref_read (#p: refined_one_pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
-: Steel 'b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> ~ (Ghost.reveal x == one p))
-    (ensures fun _ x' _ -> compatible p x x')
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` x');
-  let v = Steel.PCMReference.read r.r x' in
-  pcm_refinement'_compatible_closed r.re.refi x' v;
-  pcm_lens_compatible_get r.pl x' v;
-  A.change_equal_slprop (r.r `mpts_to` x') (r `pts_to` x);
-  A.return (get r.pl v)
-
-let ref_frame_preserving_upd #a #b
-  (#p: refined_one_pcm b) (r: ref a p) (x y: Ghost.erased b)
-  (f: (b -> b){frame_pres p f x y})
-: frame_preserving_upd r.p
-    (put r.pl x (one (refined_pcm r.re)))
-    (put r.pl y (one (refined_pcm r.re)))
-= let x' = Ghost.hide (put r.pl x (one (refined_pcm r.re))) in
-  let y' = Ghost.hide (put r.pl y (one (refined_pcm r.re))) in
-  pcm_lens_frame_pres r.pl x' y f;
-  r.re.u x' y' (frame_pres_mk_upd (refined_pcm r.re) x' y' (upd r.pl f))
-
-let ref_upd_act (r: ref 'a 'p) (x y: Ghost.erased 'b) (f: ('b -> 'b){frame_pres 'p f x y})
-: M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y))
-= M.upd_gen Set.empty r.r _ _ (ref_frame_preserving_upd r x y f)
-
-let as_action (#p:vprop)
-              (#q:vprop)
-              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
-: SteelT unit p (fun x -> q)
-= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
-  let x = Steel.Effect.as_action f in
-  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
-  A.return x
-
-let ref_upd r x y f = as_action (ref_upd_act r x y f)
-
-let frame_preserving_upd_valid_write (p: pcm 'a)
-  (x:Ghost.erased 'a) (y:'a{valid_write p x y})
-: f:('a -> 'a){frame_pres p f x y}
-= let f = fun v -> y in
-  frame_pres_intro p f x y (fun v ->
-    compatible_refl p y;
-    let aux (frame:'a{composable p x frame})
-    : Lemma (
-       composable p y frame /\
-       (op p x frame == v ==> op p y frame == y))
-    = assert (op p frame x == Ghost.reveal x);
-      assert (op p frame y == y);
-      p.comm frame x; p.comm frame y
-    in FStar.Classical.forall_intro aux);
-  f
-
-let ref_write (r: ref 'a 'p) (#x: Ghost.erased 'b) (y: 'b{valid_write 'p x y})
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-= ref_upd r x y (frame_preserving_upd_valid_write 'p x y)
diff --git a/examples/steel/arraystructs/AggregateRef.fsti b/examples/steel/arraystructs/AggregateRef.fsti
deleted file mode 100644
index 585f28c3a22..00000000000
--- a/examples/steel/arraystructs/AggregateRef.fsti
+++ /dev/null
@@ -1,148 +0,0 @@
-module AggregateRef
-
-open FStar.PCM
-open FStar.PCM.Extras
-open Lens
-module P = FStar.PCM
-module A = Steel.Effect.Atomic
-
-open Steel.Effect
-
-val ref (a:Type u#1) (#b:Type) (q: refined_one_pcm b): Type
-
-val pts_to
-  (#a: Type u#1) (#b: Type u#b) (#p: refined_one_pcm b)
-  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
-: vprop
-
-(** (ref_refine r new_re) points to x
-    if r points to x and x satisfies refinement re *)
-val ref_refine (#a:Type) (#b:Type) (#p:refined_one_pcm b)
-  (r: ref a p) (new_re: pcm_refinement p)
-: ref a (refined_pcm new_re)
-
-(** (ref_focus r l) points to x if r points to (put l x one) *)
-val ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b)
-  (r: ref a p) (#q: refined_one_pcm c) (l: pcm_lens p q)
-: ref a q
-
-(** Fundamental operations on references *)
-
-val split (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (xy x y: Ghost.erased b)
-: Steel unit
-    (r `pts_to` xy)
-    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
-    (fun _ _ _ -> True)
-
-val gather (#a:Type) (#b:Type) (#p: refined_one_pcm b) (r: ref a p) (x y: Ghost.erased b)
-: SteelT (_:unit{composable p x y})
-    ((r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> r `pts_to` op p x y)
-
-val addr_of_lens
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (r: ref a p) (l: pcm_lens p q)
-  (x: Ghost.erased b)
-: Steel (ref a q)
-    (r `pts_to` x)
-    (fun s ->
-      (r `pts_to` put l (one q) x) `star` 
-      (s `pts_to` get l x))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r l)
-
-val unaddr_of_lens
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (r': ref a q) (r: ref a p) (l: pcm_lens p q)
-  (x: Ghost.erased b) (y: Ghost.erased c)
-: Steel unit
-    ((r `pts_to` x) `star` (r' `pts_to` y))
-    (fun s -> r `pts_to` put l y x)
-    (requires fun _ -> r' == ref_focus r l /\ get l x == one q)
-    (ensures fun _ _ _ -> True)
-    
-val addr_of_union_lens
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
-  (x: Ghost.erased b{refinement_f re x})
-: Steel (ref a q)
-    (r `pts_to` x)
-    (fun r' -> r' `pts_to` get l x)
-    (requires fun _ -> Ghost.reveal x == put l (get l x) (one (refined_pcm re)))
-    (ensures fun _ r' _ -> r' == ref_focus (ref_refine r re) l)
-    
-val unaddr_of_union_lens
-  (#a:Type) (#b:Type) (#c:Type) (#p: refined_one_pcm b) (#q: refined_one_pcm c)
-  (#opened: Steel.Memory.inames)
-  (r': ref a q) (r: ref a p) (#re: pcm_refinement p) (l: pcm_lens (refined_pcm re) q)
-  (y: Ghost.erased c)
-: A.SteelGhost unit opened
-    (r' `pts_to` y)
-    (fun _ -> r `pts_to` put l y (one (refined_pcm re)))
-    (requires fun _ -> r' == ref_focus (ref_refine r re) l)
-    (ensures fun _ _ _ -> True)
-
-(** Generic read.
-
-    Without the precondition ~ (x == one), it would be possible to read
-    a completely uninformative value from a reference. This is safe
-    from the model's standpoint (we can't learn anything from this value),
-    but would extract to a potentially unsafe pointer dereference in C.
-
-    For example, here's a use-after-free:
-        {p `pts_to` x}
-      split
-        {(p `pts_to` x) `star` (p `pts_to` one)}
-      free p
-        {p `pts_to` one}
-      read p
-
-    Even with ~ (x == one), it's possible that x represents partial information
-    about the value at r (for example, a tuple (one, z) representing a struct
-    with permission to read/write from the second field only). But we should be
-    safe as long as the carrier types of the PCMs involved are abstract.
-    
-    For example, suppose
-      thread 1 has (p `pts_to` (y, one))
-      thread 2 has (p `pts_to` (one, z))
-    and thread 1 writes to p->fst while thread 2 performs the read (v, w) = *p.
-    
-    In this situation, we can't allow thread 2 to dereference (&q.fst),
-    as then it'd be reading from a location while thread 1 is writing to it.
-
-    Thread 2 can construct the pointer (&q.fst) just fine, but in
-    order to dereference it, it needs to call ref_read, and ref_read
-    requires that (&q.fst) point to a non-unit value (i.e., that ~ (v == one)).
-    
-    If v's type is suitably abstract, so that it's not possible to
-    test v against the unit of its corresponding PCM, then there's no
-    way to prove this precondition and we are safe from reading v
-    as thread 1 is writing to it. *)
-val ref_read
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b) (#x: Ghost.erased b) (r: ref a p)
-: Steel b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> ~ (Ghost.reveal x == one p))
-    (ensures fun _ x' _ -> compatible p x x')
-
-val ref_upd
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
-  (r: ref a p) (x y: Ghost.erased b) (f: (b -> b){frame_pres p f x y})
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-
-(* TODO move to FStar.PCM.fst? *)
-let whole_value (p: pcm 'a) (x: 'a) =
-  p.refine x /\
-  (forall (y:'a{composable p x y}).{:pattern op p y x} op p y x == x)
-
-let valid_write (p:pcm 'a) x y =
-  whole_value p x /\ whole_value p y /\
-  (forall (frame:'a). composable p x frame ==> composable p y frame)
-
-val ref_write
-  (#a:Type) (#b:Type) (#p: refined_one_pcm b)
-  (r: ref a p) (#x: Ghost.erased b) (y: b{valid_write p x y})
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 60e52de6124..0bed8d159fd 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -153,8 +153,8 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
 /// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
 /// { generic_swap(&p.i, &q.i); }
 
+(*
 open IntOrBool
-
 let int_or_bool_int_swap
   (p: ref 'a int_or_bool_pcm) (q: ref 'b int_or_bool_pcm)
   (i j: Ghost.erased int)
@@ -170,14 +170,12 @@ let int_or_bool_int_swap
   (* Give permissions back to p and q *)
   unaddr_of_i p pi;
   unaddr_of_i q qi
-
 /// Convert an int_or_bool + runtime tag into an int
 ///
 /// int int_or_bool_to_int(bool *is_int, union int_or_bool *p) {
 ///   if (*is_int) return p->i;
 ///   else return p->b ? 1 : 0;
 /// }
-
 val int_or_bool_to_int
   (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
   (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
@@ -204,7 +202,7 @@ val int_or_bool_to_int
     //A.return (if b then 1 else 0)
   end
 *)
-
+*)
 //let int_or_bool_to_int
 //  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
 //  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
@@ -228,13 +226,11 @@ val int_or_bool_to_int
 //    let b = some_v b in
 //    if b then some' 1 else some' 0
 //  end
-
 (*
 addr_of
   (r `pts_to` xs)
   (r `pts_to` xs \ k `star` s `pts_to` xs k)
   
-
 let point_swap_generically (#q: Ghost.erased int) (p: ref 'a point_pcm)
 : SteelT unit
     (p `pts_to` q)
@@ -249,65 +245,48 @@ let point_swap_generically (#q: Ghost.erased int) (p: ref 'a point_pcm)
   unaddr_of_x p q;
   unaddr_of_y p r;
   A.return ()
-
 p\{x, y} `pts_to` (v, w)
-
 p.x `pts_to` v === p `pts_to` mk_point v one
 p.y `pts_to` w === p `pts_to` mk_point one w
-
 give p.x's share back to p
-
 p' `pts_to` v_x
 p' == ghost_addr_of p y
-
 ghost_addr_of  = ref_focus .. 
-
 ghost_addr_of p y `pts_to` v_y
-
   
 addr_of
   (r `pts_to` xs `star` s `pts_to` y)
   (r `pts_to` xs [k `mapsto` y])
   *)
-
 (*
 pts_to r x
 (fun r' -> pts_to r' x')
 (requires (fun _ -> x is in case A))
 (ensures (fun _ r' _ -> x == A x'))
 A x' = (|TagA, x'|)
-
 (q:ref .) (t: erased tag)
 pts_to q (t, u)
 (requires (fun _ -> u is in case (tag_denote t)))
-
 (q:ref .) (t: erased tag)
 (r:ref . = the union inside q)
 pts_to q (t, one) `star` pts_to r x
-
 (requires (fun _ -> x is in case (tag_denote t)))
 *)
-
 (*
 to print proof state, try:
-
 val fake : vprop
 let f unit : Steel unit fake (fun _ -> _)
 *)
-
 (*
 (** Example: a model for a tagged union representing colors in RGB or HSV
       type color =
         | RGB : r:int -> g:int -> b:int -> color
         | HSV : h:int -> s:int -> v:int -> color *)
-
 type rgb_field = | R | G | B
 type hsv_field = | H | S | V
 type color_tag = | RGB | HSV
-
 (* Carrier of all-or-none PCM for integers *)
 let int_pcm_t = option int
-
 (* Type families for fields of RGB and HSV structs *)
 let rgb_fields k = match k with
   | R -> int_pcm_t
@@ -321,18 +300,14 @@ let hsv_fields k = match k with
 (** Carriers of PCMs for RGB and HSV structs *)
 let rgb_t = restricted_t rgb_field rgb_fields
 let hsv_t = restricted_t hsv_field hsv_fields
-
 (** Type family for union of RGB and HSV *)
 let color_cases t = match t with
   | RGB -> rgb_t
   | HSV -> hsv_t
-
 (** Carrier of PCM for color *)
 let color_t = union color_cases
-
 (** All-or-none PCM for integers *)
 let int_pcm : pcm int_pcm_t = opt_pcm
-
 (** PCMs for RGB and HSV structs *)
 let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
   prod_pcm #_ #rgb_fields (fun k -> match k with
@@ -344,10 +319,9 @@ let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
     | H -> int_pcm
     | S -> int_pcm
     | V -> int_pcm)
-
 (** PCM for color *)
 let color_pcm_cases k : pcm (color_cases k) = match k with
   | RGB -> rgb_pcm
   | HSV -> hsv_pcm
-let color_pcm : pcm color_t = union_pcm color_pcm_cases
+let color_pcm : pcm color_t 
 *)
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fst b/examples/steel/arraystructs/FStar.PCM.Extras.fst
deleted file mode 100644
index 71d418d64a1..00000000000
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fst
+++ /dev/null
@@ -1,140 +0,0 @@
-module FStar.PCM.Extras
-
-open FStar.PCM
-open FStar.FunctionalExtensionality
-open FStar.Classical
-open Lens
-
-(** PCM morphisms *)
-
-let pcm_morphism_id #a #p = {
-  f_refine = (fun _ -> ());
-  f_one = (fun _ -> ());
-  f_op = (fun _ _ -> ());
-}
-
-let pcm_morphism_comp #a #b #c #p #q #r #f #g mf mg = {
-  f_refine = (fun x -> mg.f_refine x; mf.f_refine (g x));
-  f_one = (fun () -> mg.f_one (); mf.f_one ());
-  f_op = (fun x y -> mg.f_op x y; mf.f_op (g x) (g y));
-}
-
-let compatible_pcm_morphism #a #b #p #q f m x y =
-  compatible_elim p x y (compatible q (f x) (f y)) (fun frame_x ->
-  let _ = m.f_op frame_x x in
-  compatible_intro q (f x) (f y) (f frame_x))
-
-(** Refinements *)
-
-let pcm_refinement'_comp_new_one #a #p re x y =
-  re.new_one_is_refined_unit x;
-  p.assoc_r x re.new_one y;
-  re.f_closed_comp re.new_one y
-
-let pcm_refinement'_compatible_closed #a #p re x y =
-  let p' = refined_pcm' re in
-  compatible_elim p x y (re.f y) (fun frame ->
-   re.f_closed_comp x frame; p.comm frame x);
-  compatible_elim p x y (compatible p' x y) (fun frame_x ->
-    pcm_refinement'_comp_new_one re x frame_x;
-    let frame = op p re.new_one frame_x in
-    re.new_one_is_refined_unit x;
-    p.comm x frame_x;
-    p.assoc x re.new_one frame_x;
-    p.comm x (op p re.new_one frame_x);
-    compatible_intro p' x y (op p re.new_one frame_x))
-
-(** PCM lenses *)
-
-let pcm_lens_compatible_get #a #b #p #q l x y =
-  compatible_pcm_morphism l.l.get l.get_morphism x y
-    
-let pcm_lens_frame_pres #a #b #p #q l s v f =
-  frame_pres_intro p (upd l f) s (put l v s) (fun full ->
-    let _ = l.get_morphism.f_refine in
-    pcm_lens_compatible_get l s full;
-    l.put_morphism.f_refine (f (get l full), full);
-    let goal = frame_pres_on p (upd l f) s (put l v s) full in
-    compatible_elim p s full goal (fun frame_s ->
-    compatible_elim q v (f (get l full)) goal (fun frame_v ->
-    let frame_vs: a = put l frame_v frame_s in
-    l.put_morphism.f_op (v, s) (frame_v, frame_s);
-    p.comm frame_vs (put l v s);
-    q.comm v frame_v;
-    p.comm s frame_s;
-    compatible_intro p (put l v s) (upd l f full) frame_vs;
-    let aux (frame:a{composable p s frame})
-    : Lemma (composable p (put l v s) frame /\
-             (op p s frame == full ==> op p (put l v s) frame == upd l f full))
-    = l.get_morphism.f_op s frame;
-      l.put_morphism.f_op (v, s) (get l frame, frame);
-      let aux ()
-      : Lemma (requires op p s frame == full) 
-              (ensures op p (put l v s) frame == upd l f full)
-      = () in ()
-    in FStar.Classical.forall_intro aux)))
-
-(*
-(** Refinement of union to the kth case *)
-
-let case_unrefinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement' p k)
-= fun kx ky f kv ->
-  let p' = refined_pcm' (case_refinement' p k) in
-  let p = union_pcm p in
-  match kv with
-  | Some (|k', v|) ->
-    if k = k' then begin
-      let _ = Ghost.hide (
-        let Some (|k, x|) = Ghost.reveal kx in
-        let goal = compatible p' kx kv in
-        compatible_elim p kx kv goal (fun kx_frame -> match kx_frame with
-          | Some (|_, frame_x|) -> compatible_intro p' kx kv (Some (|k, frame_x|))
-          | None -> compatible_refl p' kx))
-      in
-      let kw = f kv in
-      let aux (frame:union b{composable p kx frame})
-      : Lemma (composable p ky frame /\
-               (op p kx frame == Some (|k, v|) ==>
-                op p ky frame == f (Some (|k, v|))))
-      = let Some (|_, w|) = f (Some (|k, v|)) in
-        match frame with
-        | Some (|frame_k, frame_v|) -> assert (composable p' kx frame)
-        | None ->
-          p'.is_unit kx;
-          assert (composable p' kx (one p'));
-          p'.is_unit ky
-      in FStar.Classical.forall_intro aux;
-      kw
-    end else None
-  | _ -> None
-*)
-
-let conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
-: pcm_unrefinement (conj_refinement #'a re1 re2)
-= fun x y ->
-  h1 (Ghost.reveal x) (Ghost.reveal y) `compose`
-  h2 (Ghost.reveal x) (Ghost.reveal y) `compose`
-  upd_across_pcm_iso (pcm_refinement'_conj_iso p re1 re2) x y
-
-let extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
-: pcm_unrefinement (extend_refinement l re)
-= fun x y f v ->
-  let re' = extend_refinement l re in
-  let p' = refined_pcm' re' in
-  pcm_refinement'_compatible_closed re' x v;
-  pcm_lens_compatible_get l x v;
-  let w = f v in
-  let aux (frame:'a{composable p x frame})
-  : Lemma (composable p y frame /\ (op p x frame == v ==> op p y frame == w))
-  = pcm_refinement'_comp_new_one re' x frame;
-    let frame' = op p re'.new_one frame in
-    p.assoc y re'.new_one frame;
-    re'.new_one_is_refined_unit y;
-    p.assoc x re'.new_one frame;
-    re'.new_one_is_refined_unit x
-  in FStar.Classical.forall_intro aux;
-  w
diff --git a/examples/steel/arraystructs/FStar.PCM.Extras.fsti b/examples/steel/arraystructs/FStar.PCM.Extras.fsti
deleted file mode 100644
index 550be0d9c53..00000000000
--- a/examples/steel/arraystructs/FStar.PCM.Extras.fsti
+++ /dev/null
@@ -1,1003 +0,0 @@
-module FStar.PCM.Extras
-
-open FStar.PCM
-open Lens
-
-/// We can define a PCM for structs with two fields {a; b} by defining
-/// a PCM for tuples (a & b) in terms of (potentially user-defined)
-/// PCMs for a and b.
-
-let pcm_times_comp (p: pcm 'a) (q: pcm 'b) (x y: 'a & 'b) : prop =
-  composable p (fst x) (fst y) /\ composable q (snd x) (snd y)
-
-let pcm_times_op (p: pcm 'a) (q: pcm 'b) (x: 'a & 'b) (y: ('a & 'b){pcm_times_comp p q x y}) : 'a & 'b =
-  (op p (fst x) (fst y), op q (snd x) (snd y))
-
-let pcm_times (p: pcm 'a) (q: pcm 'b): pcm ('a & 'b) = {
-  p = {composable = pcm_times_comp p q; op = pcm_times_op p q; one = (p.p.one, q.p.one)};
-  comm = (fun (xa, xb) (ya, yb) -> p.comm xa ya; q.comm xb yb);
-  assoc = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc xa ya za; q.assoc xb yb zb);
-  assoc_r = (fun (xa, xb) (ya, yb) (za, zb) -> p.assoc_r xa ya za; q.assoc_r xb yb zb);
-  is_unit = (fun (xa, xb) -> p.is_unit xa; q.is_unit xb);
-  refine = (fun (xa, xb) -> p.refine xa /\ q.refine xb)
-}
-
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let opt_pcm #a : pcm (option a) = {
-  p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun _ -> True);
-}
-
-/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
-
-open FStar.FunctionalExtensionality
-open FStar.Classical
-let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-  extensionality 'a 'b f g;
-  forall_intro fg
-
-let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
-  forall k. composable (p k) (x k) (y k)
-
-let prod_op (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: restricted_t 'a 'b
-= on_domain 'a (fun k -> op (p k) (x k) (y k))
-
-let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
-  on_domain 'a (fun k -> (p k).p.one)
-
-let prod_comm (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: Lemma (prod_op p x y == prod_op p y x)
-= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
-
-let prod_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
-: Lemma (prod_comp p x y /\
-         prod_comp p (prod_op p x y) z /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (x k) (y k) /\
-           composable (p k) (op (p k) (x k) (y k)) (z k)) 
-    [SMTPat (p k)]
-  = (p k).assoc (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
-: Lemma (prod_comp p y z /\
-         prod_comp p x (prod_op p y z) /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (y k) (z k) /\
-           composable (p k) (x k) (op (p k) (y k) (z k)))
-    [SMTPat (p k)]
-  = (p k).assoc_r (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
-: Lemma (prod_comp p x (prod_one p) /\
-         prod_op p x (prod_one p) == x)
-= let is_unit k
-  : Lemma (composable (p k) (x k) (prod_one p k))
-    [SMTPat (p k)]
-  = (p k).is_unit (x k)
-  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
-
-let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
-  forall k. (p k).refine (x k)
-
-let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) = {
-  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
-  comm = prod_comm p;
-  assoc = prod_assoc p;
-  assoc_r = prod_assoc_r p;
-  is_unit = prod_is_unit p;
-  refine = prod_refine p
-}
-
-let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
-  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
-: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
-
-(** The non-computational part of frame_preserving_upd *)
-let frame_pres_on (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (v:'a{p.refine v /\ compatible p x v})
-= p.refine (f v) /\
-  compatible p y (f v) /\
-  (forall (frame:'a{composable p x frame}).{:pattern composable p x frame}
-     composable p y frame /\
-     (op p x frame == v ==> op p y frame == f v))
-let frame_pres (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a) =
-  forall (v:'a{p.refine v /\ compatible p x v}).{:pattern compatible p x v}
-  frame_pres_on p f x y v
-
-(** Every function satisfying frame_pres is a frame_preserving_upd *)
-let frame_pres_mk_upd (p: pcm 'a) (x y: Ghost.erased 'a)
-  (f:('a -> 'a){frame_pres p f x y})
-  : frame_preserving_upd p x y
-  = fun v -> f v
-(** The converse is not true, because a frame_preserving_upd's domain
-    is restricted to v:a{p.refine v /\ compatible p x v}. *)
-    
-let frame_pres_intro (p: pcm 'a) (f: 'a -> 'a) (x y: Ghost.erased 'a)
-  (g:(v:'a{p.refine v /\ compatible p x v} -> 
-     Lemma (p.refine (f v) /\ compatible p y (f v) /\
-            (forall (frame:'a{composable p x frame}).
-              composable p y frame /\
-              (op p x frame == v ==> op p y frame == f v)))
-     [SMTPat (compatible p x v)]))
-: Lemma (frame_pres p f x y)
-= let _ = g in ()
-
-(** PCM morphisms *)
-
-let morphism_refine (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  x:'a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)]
-let morphism_one (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  unit -> Lemma (f (one p) == one q)
-let morphism_op (p: pcm 'a) (q: pcm 'b) (f: 'a -> 'b) =
-  x:'a -> y:'a ->
-    Lemma 
-      (requires composable p x y) 
-      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
-      [SMTPat (composable p x y)]
-
-noeq type pcm_morphism #a #b (f: a -> b) (p: pcm a) (q: pcm b) = {
-  f_refine: x:a -> Lemma (requires p.refine x) (ensures q.refine (f x)) [SMTPat (p.refine x)];
-  f_one: morphism_one p q f;
-  f_op: x:a -> y:a ->
-    Lemma 
-      (requires composable p x y) 
-      (ensures composable q (f x) (f y) /\ f (op p x y) == op q (f x) (f y))
-      [SMTPat (composable p x y)]
-}
-
-val pcm_morphism_id (#p: pcm 'a): pcm_morphism id p p
-
-let compose (f: 'b -> 'c) (g: 'a -> 'b) (x: 'a): 'c = f (g x)
-val pcm_morphism_comp
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (#f: 'b -> 'c) (#g: 'a -> 'b)
-  (mf: pcm_morphism f q r) (mg: pcm_morphism g p q)
-: pcm_morphism (f `compose` g) p r
-
-val compatible_pcm_morphism
-  (#p: pcm 'a) (#q: pcm 'b)
-  (f: 'a -> 'b) (m: pcm_morphism f p q)
-  (x y: Ghost.erased 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (f x) (f y))
-
-(** A refinement of a PCM (p: pcm a) consists of:
-    (1) A set of elements f:(a -> prop) closed under (op p)
-    (2) An element new_unit which satisfies the unit laws on the subset f
-        and p.refine *)
-let refine_t (f: 'a -> prop) = x:'a{f x}
-noeq type pcm_refinement' #a (p: pcm a) = {
-  f: a -> prop;
-  f_closed_comp: x: refine_t f -> y: a{composable p x y} -> Lemma (f (op p x y));
-  new_one: (new_one:refine_t f{p.refine new_one});
-  new_one_is_refined_unit: x: refine_t f -> Lemma (composable p x new_one /\ op p x new_one == x);
-  //new_one_comp: x: refine_t f -> y: refine_t f{composable p x y} ->
-  //  Lemma (requires op p x y == new_one) (ensures x == new_one /\ y == new_one);
-}
-
-let pcm_refine_comp (#p: pcm 'a) (r: pcm_refinement' p): symrel (refine_t r.f) = composable p
-
-let pcm_refine_op (#p: pcm 'a) (r: pcm_refinement' p)
-  (x: refine_t r.f) (y: refine_t r.f{pcm_refine_comp r x y}): refine_t r.f
-= r.f_closed_comp x y;
-  op p x y
-
-(** Any refinement r for p can be used to construct a refined PCM with the same product
-    and composability predicate, but restricted to elements in r.f *)
-let refined_one_pcm a = p:pcm a{p.refine (one p)}
-
-let refined_pcm' (#p: pcm 'a) (r: pcm_refinement' p): refined_one_pcm (refine_t r.f) =
-  let p' = {
-    p = {composable = pcm_refine_comp r; op = pcm_refine_op r; one = r.new_one};
-    comm = (fun x y -> p.comm x y);
-    assoc = (fun x y z -> p.assoc x y z);
-    assoc_r = (fun x y z -> p.assoc_r x y z);
-    is_unit = (fun x -> r.new_one_is_refined_unit x);
-    refine = p.refine;
-  } in
-  //let aux (x:refine_t r.f) (y:_{composable p' x y})
-  //: Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-  //  [SMTPat (op p' x y)]
-  //= r.new_one_comp x y
-  //in
-  p'
-
-val pcm_refinement'_comp_new_one
-  (#p: pcm 'a) (re: pcm_refinement' p)
-  (x: refine_t re.f) (y: 'a{composable p x y})
-: Lemma (composable p re.new_one y /\ re.f (op p re.new_one y) /\
-         composable (refined_pcm' re) x (op p re.new_one y))
-
-val pcm_refinement'_compatible_closed
-  (#p: pcm 'a) (re: pcm_refinement' p)
-  (x: refine_t re.f) (y: 'a{compatible p x y})
-: Lemma (re.f y /\ compatible (refined_pcm' re) x y)
-
-(** A PCM refinement is well-formed if frame-preserving updates on the
-    refined PCM can be turned to frame-preserving updates on the
-    unrefined PCM *)
-
-let frame_pres_lift (p: pcm 'a) (x y: Ghost.erased 'a) (q: pcm 'b) (x' y': Ghost.erased 'b) =
-  frame_preserving_upd p x y ->
-  frame_preserving_upd q x' y'
-
-let pcm_unrefinement (#p: pcm 'a) (r: pcm_refinement' p) =
-  x: Ghost.erased (refine_t r.f) ->
-  y: Ghost.erased (refine_t r.f) ->
-  frame_pres_lift (refined_pcm' r) x y p (Ghost.reveal x) (Ghost.reveal y)
-
-noeq type pcm_refinement #a (p: pcm a) = {
-  refi: pcm_refinement' p;
-  u: pcm_unrefinement refi;
-}
-
-let refinement_f (#p: pcm 'a) (r: pcm_refinement p) = r.refi.f
-
-let refined_pcm (#p: pcm 'a) (r: pcm_refinement p)
-: refined_one_pcm (refine_t (refinement_f r))
-= refined_pcm' r.refi
-
-(** Given PCMs (p: pcm a) and (q: pcm b), a (pcm_lens p q) is a (lens a b) where
-    (1) get is a PCM morphism p -> q
-    (2) put is a PCM morphism q×p -> p *)
-
-let uncurry (f: 'a -> 'b -> 'c) ((x, y): 'a & 'b): 'c = f x y
-noeq type pcm_lens #a #b (p: pcm a) (q: pcm b) = {
-  l: lens a b;
-  get_morphism: pcm_morphism l.get p q;
-  put_morphism: pcm_morphism (uncurry l.put) (q `pcm_times` p) p;
-}
-let get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (s: 'a): 'b = l.l.get s
-let put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (v: 'b) (s: 'a): 'a = l.l.put v s
-let upd (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (f: 'b -> 'b) (s: 'a): 'a = lens_upd l.l f s
-
-(** The upd function of a pcm_lens lifts frame-preserving updates on the target to
-    frame-preserving updates on the source *)
-
-val pcm_lens_compatible_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (x y: 'a)
-: Lemma (requires compatible p x y) (ensures compatible q (get l x) (get l y))
-
-val pcm_lens_frame_pres
-  (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (s: 'a) (v: 'b) (f: 'b -> 'b)
-: Lemma
-    (requires frame_pres q f (get l s) v)
-    (ensures frame_pres p (upd l f) s (put l v s))
-    [SMTPat (frame_pres q f (get l s) v)]
-
-(** The identity lens is a pcm_lens *)
-let pcm_lens_id (#p: pcm 'a): pcm_lens p p = {
-  l = lens_id; 
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
-(** pcm_lens composition is lens composition *)
-let pcm_lens_comp
-  (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (l: pcm_lens p q) (m: pcm_lens q r)
-: pcm_lens p r = {
-  l = lens_comp l.l m.l;
-  get_morphism = {
-    f_refine = (fun _ ->
-      let _ = l.get_morphism.f_refine in
-      let _ = m.get_morphism.f_refine in ());
-    f_one = (fun _ -> l.get_morphism.f_one (); m.get_morphism.f_one ());
-    f_op = (fun s t ->
-      l.get_morphism.f_op s t;
-      m.get_morphism.f_op (get l s) (get l t));
-  };
-  put_morphism = {
-    f_refine = (fun (v, s) ->
-      l.get_morphism.f_refine s;
-      m.put_morphism.f_refine (v, get l s);
-      l.put_morphism.f_refine (put m v (get l s), s));
-    f_one = (fun _ -> l.put_morphism.f_one (); m.put_morphism.f_one ());
-    f_op = (fun (v, s) (w, t) ->
-      l.get_morphism.f_op s t;
-      m.put_morphism.f_op (v, get l s) (w, get l t);
-      l.put_morphism.f_op (put m v (get l s), s) (put m w (get l t), t));
-  };
-}
-
-(** A lens for the k-th field of an n-ary product *)
-
-open FStar.FunctionalExtensionality
-let fun_upd (#a:eqtype) #f_ty (k:a) (x':f_ty k)
-  (f: restricted_t a f_ty)
-: restricted_t a f_ty
-= on_domain a (fun k' -> if k = k' then x' else f k')
-let lens_field_get (#a:eqtype) f (k:a) (s:restricted_t a f): f k = s k
-let lens_field (#a:eqtype) f (k:a): lens (restricted_t a f) (f k) = {
-  get = lens_field_get f k;
-  put = fun_upd k;
-  get_put = (fun s v -> ());
-  put_get = (fun s -> ext (fun_upd k (lens_field_get f k s) s) s (fun _ -> ()));
-  put_put = (fun s v w -> ext (fun_upd k v (fun_upd k w s)) (fun_upd k v s) (fun _ -> ()));
-}
-
-(** lens_field is a pcm_lens *)
-
-let field (#a:eqtype) #f (p:(k:a -> pcm (f k))) (k:a): pcm_lens (prod_pcm p) (p k) = {
-  l = lens_field f k;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {
-    f_refine = (fun _ -> ());
-    f_one = (fun _ ->
-      ext
-        (fun_upd k (one (p k)) (one (prod_pcm p)))
-        (one (prod_pcm p))
-        (fun k -> ()));
-    f_op = (fun (v, s) (w, t) ->
-      prod_pcm_composable_intro p (fun_upd k v s) (fun_upd k w t) (fun _ -> ());
-      ext
-        (fun_upd k (op (p k) v w) (op (prod_pcm p) s t))
-        (op (prod_pcm p) (fun_upd k v s) (fun_upd k w t))
-        (fun _ -> ()));
-  }
-}
-
-(** A PCM for possibly-uninitialized data *)
-
-type init a =
-| One : init a
-| Uninitialized : init a
-| Initialized : a -> init a
-
-let init_comp (p: pcm 'a): symrel (init 'a) = fun x y -> match x, y with
-  | One, _ | _, One -> True
-  | Initialized x, Initialized y -> composable p x y
-  | _, _ -> False
-
-let init_op (p: pcm 'a) (x: init 'a) (y: init 'a{init_comp p x y}): init 'a = match x, y with
-  | One, z | z, One -> z
-  | Initialized x, Initialized y -> Initialized (op p x y)
-
-let init_pcm (p: pcm 'a): pcm (init 'a) = {
-  p = {composable = init_comp p; op = init_op p; one = One #'a};
-  comm = (fun x y -> match x, y with
-    | Initialized x, Initialized y -> p.comm x y
-    | _, _ -> ());
-  assoc = (fun x y z -> match x, y, z with
-    | Initialized x, Initialized y, Initialized z -> p.assoc x y z
-    | _, _, _ -> ());
-  assoc_r = (fun x y z -> match x, y, z with
-    | Initialized x, Initialized y, Initialized z -> p.assoc_r x y z
-    | _, _, _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> match x with
-    | Initialized x -> p.refine x
-    | _ -> True)
-}
-
-(** A PCM for unions TODO move to proper place *)
-
-let union_fam (b:'a->Type) (k:'a) = init (b k)
-let union_fn (b:'a->Type) = restricted_t 'a (union_fam b)
-let union_pcm_fam (p:(k:'a -> pcm ('b k))) (k:'a): pcm (init ('b k)) = init_pcm (p k)
-let union_prod_pcm (p:(k:'a -> pcm ('b k))): pcm (union_fn 'b) = prod_pcm (union_pcm_fam p)
-
-let is_union_case (p:(k:'a -> pcm ('b k))) (k:'a) (f: union_fn 'b): prop =
-  forall k'. ~ (k == k') ==> f k' == Uninitialized
-
-let is_union_case_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: union_fn 'b)
-  (h:(k':'a{~ (k == k')} -> Lemma (f k' == Uninitialized)))
-: Lemma (is_union_case p k f) = FStar.Classical.forall_intro h
-
-//let is_union_case_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: union_fn 'b)
-//: Lemma
-//    (requires is_union_case p j f /\ is_union_case p k f /\ ~ (j == k))
-//    (ensures f == one (prod_pcm p))
-//= ext f (one (prod_pcm p)) (fun k -> ())
-
-let is_union (p:(k:'a -> pcm ('b k))) (f: union_fn 'b) =
-  f == one (union_prod_pcm p) \/ (exists k. is_union_case p k f)
-
-let union (p:(k:'a -> pcm ('b k))) = f:union_fn 'b{is_union p f}
-
-let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
-  (cont1:(unit -> Lemma (requires f == one (union_prod_pcm p)) (ensures goal)))
-  (cont2:(k:'a -> Lemma (requires is_union_case p k f) (ensures goal)
-    [SMTPat (is_union_case p k f)]))
-: Lemma goal
-= let _ = cont2 in move_requires cont1 ()
-
-let is_union_intro (p:(k:'a -> pcm ('b k))) (f: union_fn 'b)
-  (k:'a{is_union_case p k f})
-: Lemma (is_union p f)
-= ()
-
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = composable (union_prod_pcm p)
-//fun f g ->
-//  forall j k.
-//  ~ (f j == Uninitialized) /\ ~ (g k == Uninitialized) ==>
-//  j == k /\ composable (init_pcm (p k)) (f k) (g k)
-
-//let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
-//  (h:(j:'a -> k:'a ->
-//    Lemma
-//      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-//      (ensures j == k /\ composable (p k) (f k) (g k))
-//      [SMTPat (f j); SMTPat (g k)]))
-//: Lemma (union_comp p f g)
-//= let _ = h in ()
-
-//let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
-//: Lemma
-//    (requires union_comp p f g)
-//    (ensures prod_comp p f g)
-//    [SMTPat (union_comp p f g)]
-//= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
-
-//let is_union_case_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: union_fn 'b)
-//: Lemma
-//    (requires is_union_case p k f /\ f k == one (p k))
-//    (ensures f == one (prod_pcm p))
-//    [SMTPat (is_union_case p k f); SMTPat (f k == one (p k))]
-//= ext f (one (prod_pcm p)) (fun _ -> ())
-
-//let is_union_case_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: union_fn 'b)
-//: Lemma
-//    (requires is_union_case p j f /\ is_union_case p k g /\ union_comp p f g)
-//    (ensures
-//      f == one (prod_pcm p) \/
-//      g == one (prod_pcm p) \/ 
-//      is_union_case p k (prod_op p f g))
-//    [SMTPat (is_union_case p j f); SMTPat (is_union_case p k g)]
-//= let fj_or_gk_one
-//  : squash
-//      (f j == one (p j) \/ g k == one (p k) ==>
-//       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
-//  = ()
-//  in let fj_gk_both_not_one ()
-//  : Lemma
-//      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-//      (ensures is_union_case p k (prod_op p f g))
-//  = is_union_case_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
-//  in
-//  move_requires fj_gk_both_not_one ();
-//  assert
-//   ((f j == one (p j) \/ g k == one (p k)) ==>
-//    f == one (prod_pcm p) \/
-//    g == one (prod_pcm p) \/ 
-//    is_union_case p k (prod_op p f g))
-
-let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
-  let h = op (union_prod_pcm p) f g in
-  let goal = is_union p h in
-  union_elim p f goal (fun () -> (union_prod_pcm p).is_unit g) (fun j ->
-  union_elim p g goal (fun () -> (union_prod_pcm p).is_unit f) (fun k -> ()));
-  h
-
-let union_one (p:(k:'a -> pcm ('b k))): union p = one (union_prod_pcm p)
-let union_refine (p:(k:'a -> pcm ('b k))) = (union_prod_pcm p).refine
-
-let union_assoc (p:(k:'a -> refined_one_pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
-: Lemma (union_comp p x y /\
-         union_comp p (union_op p x y) z /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= (union_prod_pcm p).assoc x y z
-
-let union_assoc_r (p:(k:'a -> refined_one_pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
-: Lemma (union_comp p y z /\
-         union_comp p x (union_op p y z) /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= (union_prod_pcm p).assoc_r x y z
-
-let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
-: Lemma (union_comp p x (union_one p) /\
-         union_op p x (union_one p) == x)
-= (union_prod_pcm p).is_unit x
-
-let union_pcm (p:(k:'a -> refined_one_pcm ('b k))): refined_one_pcm (union p) =
-  let p' = {
-    p = {composable = union_comp p; op = union_op p; one = union_one p};
-    comm = (fun x y -> (union_prod_pcm p).comm x y);
-    assoc = union_assoc p;
-    assoc_r = union_assoc_r p;
-    is_unit = union_is_unit p;
-    refine = union_refine p;
-  } in
-  //let aux (x:union p) (y:union p{composable p' x y})
-  //: Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-  //  [SMTPat (op p' x y)]
-  //= ext x (one p') (fun k -> let _ = p k in ());
-  //  ext y (one p') (fun k -> let _ = p k in ())
-  //in
-  p'
-
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f:union p): prop =
-  is_union_case p k f
-
-let case_refinement_closed_comp (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-  (f:refine_t (case_refinement_f p k))
-  (g:union p{composable (union_pcm p) f g})
-: Lemma (case_refinement_f p k (op (union_pcm p) f g))
-= assert (is_union_case p k f);
-  assert (case_refinement_f p k (op (union_pcm p) f g))
-  //assert (is_union_case p k g);
-  //assert (composable (union_pcm p) f g);
-  //assert(~ (g k == one (p k)) ==> case_refinement_f p k (op (union_pcm p) f g));
-  //let goal = g k == one (p k) ==> case_refinement_f p k (op (union_pcm p) f g) in
-  //union_elim p g goal (fun j ->
-  //assert (is_union_case p j g);
-  //assert (g j == one (p j) ==> feq g (one (union_pcm p)));
-  //(prod_pcm p).is_unit f;
-  //assert (g j == one (p j) ==> op (union_pcm p) f g == f);
-  //assert (g j == one (p j) ==> goal);
-  //assert (f k == one (p k) ==> feq f (one (union_pcm p)));
-  //assert (~ (f k == one (p k)) /\ ~ (g j == one (p j)) ==> j == k))
-
-let case_refinement_new_one (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: (new_one:refine_t (is_union_case p k){union_refine p new_one})
-= let f: arrow a (union_fam b) = fun k' -> if k = k' then one (init_pcm (p k)) else Uninitialized in
-  let f': union p = on_domain a f in
-  assert (is_union_case p k f');
-  f'
-  //assert (is_union_case p k g);
-  //assert (composable (union_pcm p) f g);
-  //assert(~ (g k == one (p k)) ==> case_refinement_f p k (op (union_pcm p) f g));
-  //let goal = g k == one (p k) ==> case_refinement_f p k (op (union_pcm p) f g) in
-  //union_elim p g goal (fun j ->
-  //assert (is_union_case p j g);
-  //assert (g j == one (p j) ==> feq g (one (union_pcm p)));
-  //(prod_pcm p).is_unit f;
-  //assert (g j == one (p j) ==> op (union_pcm p) f g == f);
-  //assert (g j == one (p j) ==> goal);
-  //assert (f k == one (p k) ==> feq f (one (union_pcm p)));
-  //assert (~ (f k == one (p k)) /\ ~ (g j == one (p j)) ==> j == k))
-  
-// Fails because (Uninit, .., One, Uninit, ..) is never composable with (Uninit, .., x, Uninit, ..)
-let case_refinement_new_one_is_refined_unit (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
-  (x: union p)
-: Lemma (composable (union_pcm p) x (case_refinement_new_one p k) /\
-         op (union_pcm p) x (case_refinement_new_one p k) == x)
-= assume(composable (union_prod_pcm p) x (case_refinement_new_one p k));
-  let aux (k':a): Lemma ((op (union_prod_pcm p) x (case_refinement_new_one p k)) k' == x k')
-  = if k = k'
-    then (init_pcm (p k)).is_unit (x k)
-    else begin
-      assert (composable (init_pcm (p k')) (x k') Uninitialized);
-      assert (x k' == One);
-      (init_pcm (p k')).is_unit Uninitialized;
-      (init_pcm (p k')).comm (x k') Uninitialized;
-      admit();
-      assert (op (init_pcm (p k')) (x k') (Uninitialized #(b k')) == x k')
-    end
-  in forall_intro aux;
-  assert (op (union_prod_pcm p) x (case_refinement_new_one p k) `feq` x)
-
-let case_refinement (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a): pcm_refinement (union_pcm p) =
-  let refi: pcm_refinement' (union_pcm p) = {
-    f = case_refinement_f p k;
-    f_closed_comp = case_refinement_closed_comp p k;
-    new_one = case_refinement_new_one p k;
-    new_one_is_refined_unit = (fun _ -> ());
-    //new_one_comp = admit();
-    //f_is_unit = (fun f ->
-    //  assert (is_union_case p k f);
-    //  assert (is_union_case p k (one (prod_pcm p)));
-    //  (prod_pcm p).is_unit f;
-    //  assert (case_refinement_f_comp p k f (one (prod_pcm p))));
-  } in
-  let u: pcm_unrefinement refi = admit() in
-  {refi = refi; u = u}
-
-
-(*
-(** The refinement of an n-ary union PCM to the k-th case *)
-
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a): union 'b -> prop =
-  fun kx -> match kx with Some (|k', _|) -> k == k' | None -> False
-
-let case_refinement_new_one (p:(k:'a -> pcm ('b k))) (k:'a)
-: refine_t (case_refinement_f p k)
-= Some (|k, one (p k)|)
-
-let case_refinement' (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_refinement' (union_pcm p) = {
-  f = case_refinement_f p k;
-  f_closed_comp = (fun x y -> ());
-  new_one = case_refinement_new_one p k;
-  new_one_is_refined_unit = (fun (Some (|k', x|)) -> (p k).is_unit x)
-}
-
-val case_unrefinement (#a:eqtype) (#b:a->Type) (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_unrefinement (case_refinement' p k)
-
-let case_refinement (#a:eqtype) #b (p:(k:a -> refined_one_pcm (b k))) (k:a)
-: pcm_refinement (union_pcm p) = {
-  refi = case_refinement' p k;
-  u = case_unrefinement p k;
-}
-
-(** A lens for the k-th case of an n-ary union *)
-
-let lens_case_get (p:(k:'a -> pcm ('b k))) (k:'a): refine_t (case_refinement_f p k) -> 'b k =
-  fun (Some (|_, v|)) -> v
-let lens_case_put (p:(k:'a -> pcm ('b k))) (k:'a) (v:'b k)
-: refine_t (case_refinement_f p k) -> refine_t (case_refinement_f p k)
-= fun _ -> Some (|k, v|)
-  
-let lens_case (p:(k:'a -> pcm ('b k))) (k:'a): lens (refine_t (case_refinement_f p k)) ('b k) = {
-  get = lens_case_get p k;
-  put = lens_case_put p k;
-  get_put = (fun s v -> ());
-  put_get = (fun s -> ());
-  put_put = (fun s v w -> ());
-}
-
-(** lens_case is a pcm_lens *)
-let case (p:(k:'a -> refined_one_pcm ('b k))) (k:'a)
-: pcm_lens (refined_pcm' (case_refinement' p k)) (p k) = {
-  l = lens_case p k;
-  get_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  put_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-*)
-
-(** Refining a pcm_lens *)
-
-let extend_refinement_f (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: 'a): prop
-= re.f (get l x)
-
-let lens_refine_get (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (s: refine_t (extend_refinement_f l re))
-: refine_t re.f
-= l.l.get s
-
-let lens_refine_put (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q)
-  (v: refine_t re.f) (s: refine_t (extend_refinement_f l re))
-: refine_t (extend_refinement_f l re)
-= l.l.put v s
-
-let lens_refine (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q) (re: pcm_refinement' q)
-: lens (refine_t (extend_refinement_f l re)) (refine_t re.f) = {
-  get = lens_refine_get l re;
-  put = lens_refine_put l re;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-let extend_refinement_f_closed (#p: pcm 'a) (#q: pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-  (y: 'a{composable p x y})
-: Lemma (extend_refinement_f l re (op p x y))
-= l.get_morphism.f_op x y;
-  re.f_closed_comp (get l x) (get l y)
-
-let extend_refinement_new_one (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: new_one:refine_t (extend_refinement_f l re){p.refine new_one}
-= l.put_morphism.f_refine (re.new_one, one p); put l re.new_one (one p)
-
-let extend_refinement_new_one_is_refined_unit
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b) (l: pcm_lens p q)
-  (re: pcm_refinement' q) (x: refine_t (extend_refinement_f l re))
-: Lemma (composable p x (extend_refinement_new_one l re) /\
-         op p x (extend_refinement_new_one l re) == x)
-= re.new_one_is_refined_unit (get l x);
-  p.is_unit x;
-  l.put_morphism.f_op (get l x, x) (re.new_one, one p)
-
-//let extend_refinement_new_one_comp (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-//  (l: pcm_lens p q) (re: pcm_refinement' q)
-//  (x: refine_t (extend_refinement_f l re))
-//  (y: refine_t (extend_refinement_f l re){composable p x y})
-//: Lemma
-//    (requires op p x y == extend_refinement_new_one l re)
-//    (ensures
-//      x == extend_refinement_new_one l re /\ 
-//      y == extend_refinement_new_one l re)
-//= assert (re.f (get l x));
-//  assert (re.f (get l y));
-//  assert (op p x y == put l re.new_one (one p));
-//  l.get_morphism.f_op x y;
-//  re.new_one_comp (get l x) (get l y);
-//  assert (get l x == re.new_one);
-//  assert (get l y == re.new_one);
-//  admit()
-  
-let extend_refinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_refinement' p = {
-  f = extend_refinement_f l re;
-  f_closed_comp = extend_refinement_f_closed l re;
-  new_one = extend_refinement_new_one l re;
-  new_one_is_refined_unit = extend_refinement_new_one_is_refined_unit l re;
-  //new_one_comp = extend_refinement_new_one_comp l re;
-}
-
-let pcm_lens_refine_get_morphism_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_refine
-    (refined_pcm' (extend_refinement l re))
-    (refined_pcm' re)
-    (lens_refine l re).get
-= l.get_morphism.f_refine
-
-let pcm_lens_refine_get_morphism_one
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_one
-    (refined_pcm' (extend_refinement l re))
-    (refined_pcm' re)
-    (lens_refine l re).get
-= l.get_morphism.f_one
-
-let pcm_lens_refine_get_morphism_op
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_op
-    (refined_pcm' (extend_refinement l re))
-    (refined_pcm' re)
-    (lens_refine l re).get
-= l.get_morphism.f_op
-
-let pcm_lens_refine_put_morphism_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_refine
-    (refined_pcm' re `pcm_times` refined_pcm' (extend_refinement l re))
-    (refined_pcm' (extend_refinement l re))
-    (uncurry (lens_refine l re).put)
-= fun (v, s) -> l.put_morphism.f_refine (v, s)
-
-let pcm_lens_refine_put_morphism_one
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_one
-    (refined_pcm' re `pcm_times` refined_pcm' (extend_refinement l re))
-    (refined_pcm' (extend_refinement l re))
-    (uncurry (lens_refine l re).put)
-= l.put_morphism.f_one
-
-let pcm_lens_refine_put_morphism_op
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: morphism_op
-    (refined_pcm' re `pcm_times` refined_pcm' (extend_refinement l re))
-    (refined_pcm' (extend_refinement l re))
-    (uncurry (lens_refine l re).put)
-= fun (v, s) (w, t) -> l.put_morphism.f_op (v, s) (w, t)
-
-let pcm_lens_refine
-  (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q)
-: pcm_lens (refined_pcm' (extend_refinement l re)) (refined_pcm' re) = {
-  l = lens_refine l re;
-  get_morphism = {
-    f_refine = pcm_lens_refine_get_morphism_refine l re;
-    f_one = pcm_lens_refine_get_morphism_one l re;
-    f_op = pcm_lens_refine_get_morphism_op l re;
-  };
-  put_morphism = {
-    f_refine = pcm_lens_refine_put_morphism_refine l re;
-    f_one = pcm_lens_refine_put_morphism_one l re;
-    f_op = pcm_lens_refine_put_morphism_op l re;
-  };
-}
-
-(** Isomorphisms *)
-
-noeq type iso a b = {
-  fwd: a -> b;
-  bwd: b -> a;
-  fwd_bwd: x:b -> Lemma (fwd (bwd x) == x);
-  bwd_fwd: x:a -> Lemma (bwd (fwd x) == x);
-}
-let fwd_bwd' (i: iso 'a 'b) (x: 'b): Lemma (i.fwd (i.bwd x) == x) [SMTPat (i.fwd (i.bwd x))] = i.fwd_bwd x
-let bwd_fwd' (i: iso 'a 'b) (x: 'a): Lemma (i.bwd (i.fwd x) == x) [SMTPat (i.bwd (i.fwd x))] = i.bwd_fwd x
-
-let iso_lens_comp_get (i: iso 'a 'b) (l: lens 'b 'c): 'a -> 'c = l.get `compose` i.fwd
-let iso_lens_comp_put (i: iso 'a 'b) (l: lens 'b 'c) (v: 'c) (s: 'a): 'a = i.bwd (l.put v (i.fwd s))
-let iso_lens_comp (i: iso 'a 'b) (l: lens 'b 'c): lens 'a 'c = {
-  get = iso_lens_comp_get i l;
-  put = iso_lens_comp_put i l;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** A refinement f of a refinement g of 'a is isomorphic to a refinement by conj f g *)
-
-let conj (f: 'a -> prop) (g:(x:'a{f x} -> prop)) (x: 'a): prop = f x /\ g x
-
-let refine_conj_iso_fwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-  (x: refine_t (conj f g))
-: refine_t g
-= x
-
-let refine_conj_iso_bwd (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-  (x: refine_t g)
-: refine_t (conj f g)
-= x
-
-let refine_conj_iso (f: 'a -> prop) (g:(x:'a{f x} -> prop))
-: iso (refine_t #'a (conj #'a f g)) (refine_t #(x:'a{f x}) g) = {
-  fwd = refine_conj_iso_fwd f g;
-  bwd = refine_conj_iso_bwd f g;
-  fwd_bwd = (fun _ -> ());
-  bwd_fwd = (fun _ -> ());
-}
-
-(** PCM isomorphisms *)
-
-noeq type pcm_iso #a #b (p: pcm a) (q: pcm b) = {
-  i: iso a b;
-  fwd_morphism: pcm_morphism i.fwd p q;
-  bwd_morphism: pcm_morphism i.bwd q p;
-}
-
-let pcm_iso_lens_comp (#p: pcm 'a) (#q: pcm 'b) (#r: pcm 'c)
-  (i: pcm_iso p q) (l: pcm_lens q r)
-: pcm_lens p r = {
-  l = iso_lens_comp i.i l.l;
-  get_morphism = pcm_morphism_comp l.get_morphism i.fwd_morphism;
-  put_morphism = {
-    f_refine = (fun (v, s) ->
-      i.fwd_morphism.f_refine s; 
-      l.put_morphism.f_refine (v, i.i.fwd s);
-      i.bwd_morphism.f_refine (l.l.put v (i.i.fwd s)));
-    f_one = (fun () ->
-      i.fwd_morphism.f_one (); 
-      l.put_morphism.f_one ();
-      i.bwd_morphism.f_one ());
-    f_op = (fun (v, s) (w, t) -> 
-     i.fwd_morphism.f_op s t;
-     l.put_morphism.f_op (v, i.i.fwd s) (w, i.i.fwd t);
-     i.bwd_morphism.f_op (l.l.put v (i.i.fwd s)) (l.l.put w (i.i.fwd t)));
-  }
-}
-
-(** The conjunction of two refinements *)
-
-let conj_refinement_f (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-: 'a -> prop = conj #'a re1.f re2.f
-
-let conj_refinement_f_closed (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-  (y: 'a{composable p x y})
-: Lemma (conj_refinement_f re1 re2 (op p x y))
-= pcm_refinement'_comp_new_one re1 x y;
-  re1.f_closed_comp x (op p re1.new_one y);
-  pcm_refinement'_comp_new_one re2 x (op p re1.new_one y);
-  re2.f_closed_comp x (op p re2.new_one (op p re1.new_one y));
-  p.assoc x re2.new_one (op p re1.new_one y);
-  re2.new_one_is_refined_unit x;
-  p.assoc x re1.new_one y;
-  re1.new_one_is_refined_unit x
-
-(* re1.new_one and re2.new_one both work; we go with re2 *)
-let conj_refinement_new_one (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-: refine_t (conj_refinement_f re1 re2)
-= re2.new_one
-
-let conj_refinement_new_one_is_refined_unit (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (x: refine_t (conj_refinement_f re1 re2))
-: Lemma (composable p x (conj_refinement_new_one re1 re2) /\
-         op p x (conj_refinement_new_one re1 re2) == x)
-= re2.new_one_is_refined_unit x
-
-//let conj_refinement_new_one_comp (#p: pcm 'a)
-//  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-//  (x: refine_t (conj_refinement_f re1 re2))
-//  (y: refine_t (conj_refinement_f re1 re2){composable p x y})
-//: Lemma 
-//    (requires op p x y == conj_refinement_new_one re1 re2)
-//    (ensures x == conj_refinement_new_one re1 re2 /\ y == conj_refinement_new_one re1 re2)
-//= admit()
-
-let conj_refinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-: pcm_refinement' p = {
-  f = conj_refinement_f re1 re2;
-  f_closed_comp = conj_refinement_f_closed re1 re2;
-  new_one = conj_refinement_new_one re1 re2;
-  new_one_is_refined_unit = conj_refinement_new_one_is_refined_unit re1 re2;
-  //new_one_comp = conj_refinement_new_one_comp re1 re2;
-}
-
-let pcm_refinement'_conj_iso_i (p: pcm 'a)
-  (re1: pcm_refinement' p)
-  (re2: pcm_refinement' (refined_pcm' re1))
-: iso (refine_t #'a (conj #'a re1.f re2.f)) (refine_t #(x:'a{re1.f x}) re2.f) =
-  refine_conj_iso re1.f re2.f
-  
-(** A refinement re1 of a refinement re2 of a PCM is isomorphic to a
-    refinement by the conjunction of re1 and re2 *)
-let pcm_refinement'_conj_iso (p: pcm 'a)
-  (re1: pcm_refinement' p)
-  (re2: pcm_refinement' (refined_pcm' re1))
-: pcm_iso (refined_pcm' (conj_refinement re1 re2)) (refined_pcm' re2) = {
-  i = pcm_refinement'_conj_iso_i p re1 re2;
-  fwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-  bwd_morphism = {f_refine = (fun _ -> ()); f_one = (fun _ -> ()); f_op = (fun _ _ -> ())};
-}
-
-let upd_across_pcm_iso
-  (#p: pcm 'a) (#q: pcm 'b) (i: pcm_iso p q) (x y: Ghost.erased 'a)
-: frame_pres_lift p x y q (i.i.fwd x) (i.i.fwd y)
-= fun f v ->
-  i.bwd_morphism.f_refine v;
-  compatible_pcm_morphism i.i.bwd i.bwd_morphism (i.i.fwd x) v;
-  let w = i.i.fwd (f (i.i.bwd v)) in
-  i.fwd_morphism.f_refine (f (i.i.bwd v));
-  compatible_pcm_morphism i.i.fwd i.fwd_morphism y (f (i.i.bwd v));
-  let aux (frame:'b{composable q (i.i.fwd x) frame})
-  : Lemma (composable q (i.i.fwd y) frame /\
-           (op q (i.i.fwd x) frame == v ==>
-            op q (i.i.fwd y) frame == w))
-  = i.bwd_morphism.f_op (i.i.fwd x) frame;
-    i.fwd_morphism.f_op y (i.i.bwd frame);
-    i.fwd_morphism.f_op x (i.i.bwd frame)
-  in FStar.Classical.forall_intro aux;
-  w
-
-val conj_unrefinement (#p: pcm 'a)
-  (re1: pcm_refinement' p) (re2: pcm_refinement' (refined_pcm' re1))
-  (h1: pcm_unrefinement re1) (h2: pcm_unrefinement re2)
-: pcm_unrefinement (conj_refinement #'a re1 re2)
-
-val extend_unrefinement (#p: refined_one_pcm 'a) (#q: refined_one_pcm 'b)
-  (l: pcm_lens p q) (re: pcm_refinement' q) (u: pcm_unrefinement re)
-: pcm_unrefinement (extend_refinement l re)
-
-/// Troubles with unions:
-/// - If represent as option (tag:a & payload: b tag),
-///   the value Some (|tag, one|) is a valid frame for Some (|tag, payload|),
-///   which prevents Some (|tag, payload|) ~~> Some (|tag', payload|) from being
-///   a frame-preserving update. (So, no way to switch the case of a union).
-/// - If represent as (n-ary product where at most one component can be non-unit),
-///   can't prove that the refinement of a union to the kth case is closed.
-///   Specifically, if x is in kth case and x composable with y,
-///   no guarantee that y is in kth case, because x could be the unit (one, one, ..).
-/// - If try to rule out this case by changing the statement of f_closed to
-///     forall x y. ~ (y == one) ==> ...
-///   then can't prove extend_refinement. Main issue is that if
-///     ~ (x == one)
-///   we can't conclude
-///     ~ (get l x == one)
-///   where l is a lens.
-/// - If strengthen the definition of a refinement by adding a new composability relation
-///   f_comp that is a subrelation of (composable p), pcm_refinement'_compatible_closed
-///   fails because need to show that a frame that's p-composable with
-///   some x is f_comp-composable with x, which is not true in general.
diff --git a/examples/steel/arraystructs/Lens.fst b/examples/steel/arraystructs/Lens.fst
deleted file mode 100644
index 4294805c912..00000000000
--- a/examples/steel/arraystructs/Lens.fst
+++ /dev/null
@@ -1,45 +0,0 @@
-module Lens
-
-(** Very well-behaved lenses *)
-noeq type lens (a: Type u#a) (b: Type u#b) = {
-  get: a -> b;
-  put: b -> a -> a;
-  get_put: s: a -> v: b -> Lemma (get (put v s) == v);
-  put_get: s: a -> Lemma (put (get s) s == s);
-  put_put: s: a -> v: b -> w: b -> Lemma (put v (put w s) == put v s);
-}
-let get_put' (l: lens 'a 'b) (s: 'a) (v: 'b)
-  : Lemma (l.get (l.put v s) == v) [SMTPat (l.get (l.put v s))]
-  = l.get_put s v
-let put_get' (l: lens 'a 'b) (s: 'a)
-  : Lemma (l.put (l.get s) s == s) [SMTPat (l.put (l.get s))]
-  = l.put_get s
-let put_put' (l: lens 'a 'b) (s: 'a) (v w: 'b)
-  : Lemma (l.put v (l.put w s) == l.put v s) [SMTPat (l.put v (l.put w s))]
-  = l.put_put s v w
-
-(** Lenses *)
-
-let lens_upd (l: lens 'a 'b) (f: 'b -> 'b) (s: 'a): 'a = l.put (f (l.get s)) s
-
-(** The identity lens *)
-let const (x: 'a) (b: 'b): 'a = x
-let lens_id #a: lens a a = {
-  get = id;
-  put = const;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
-
-(** Lens composition *)
-let get_comp (l: lens 'a 'b) (m: lens 'b 'c) (s: 'a): 'c = m.get (l.get s)
-let put_comp (l: lens 'a 'b) (m: lens 'b 'c) (v: 'c) (s: 'a): 'a =
-  lens_upd l (m.put v) s
-let lens_comp (l: lens 'a 'b) (m: lens 'b 'c): lens 'a 'c = {
-  get = get_comp l m;
-  put = put_comp l m;
-  get_put = (fun _ _ -> ());
-  put_get = (fun _ -> ());
-  put_put = (fun _ _ _ -> ());
-}
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
new file mode 100644
index 00000000000..4e2e84d5455
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -0,0 +1,1055 @@
+module Steel.C.PCM
+open FStar.PCM
+
+unfold
+let one (#a: Type) (p: pcm a) = p.p.one
+
+let pcm (a: Type) : Tot Type =
+  (p: FStar.PCM.pcm a {
+    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
+      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
+    (forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
+    (~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+  })
+
+noeq
+type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
+  morph: (a -> Tot b);
+  morph_unit: squash (morph pa.p.one == pb.p.one);
+  morph_compose:
+    (x1: a) ->
+    (x2: a) ->
+    Lemma
+    (requires (composable pa x1 x2))
+    (ensures (composable pb (morph x1) (morph x2) /\ morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2));
+}
+
+let morphism_morph_compose
+  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
+  (x1: a)
+  (x2: a)
+: Lemma
+  (requires (composable pa x1 x2))
+  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
+  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
+= m.morph_compose x1 x2
+
+let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) = {
+  morph = (fun x -> fbc.morph (fab.morph x));
+  morph_unit = ();
+  morph_compose = begin fun x1 x2 ->
+    fab.morph_compose x1 x2;
+    fbc.morph_compose (fab.morph x1) (fab.morph x2)
+  end;
+}
+
+let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
+  (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
+
+let is_inverse_of (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b)) : Tot prop =
+  (forall x . {:pattern (g (f x))} g (f x) == x)
+
+let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
+  x1 x2
+: Lemma
+  (requires (g `is_inverse_of` f /\ f x1 == f x2))
+  (ensures (x1 == x2))
+  [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
+= assert (g (f x1) == g (f x2))
+
+noeq
+type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
+  conn_small_to_large: morphism p_small p_large;
+  conn_large_to_small: morphism p_large p_small;
+  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
+  conn_lift_frame_preserving_upd:
+    (x: Ghost.erased t_small { ~ (Ghost.reveal x == p_small.p.one) }) -> // validity condition, e.g. union cases
+    (y: Ghost.erased t_small) ->
+    (f: frame_preserving_upd p_small x y) ->
+    Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y));
+}
+
+let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) = {
+  conn_small_to_large = fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large;
+  conn_large_to_small = fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small;
+  conn_small_to_large_inv = ();
+  conn_lift_frame_preserving_upd = begin fun xc yc f ->
+    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
+    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
+    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
+    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
+    fab.conn_lift_frame_preserving_upd _ _ (fbc.conn_lift_frame_preserving_upd _ _ f)
+  end;
+}
+
+noeq type ref a #b (q: pcm b): Type = {
+  p: pcm a;
+  pl: connection p q;
+  r: Steel.Memory.ref a p;
+}
+
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+
+open Steel.Effect
+
+val pts_to
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
+: vprop
+
+let pts_to r v =
+  r.r `mpts_to` r.pl.conn_small_to_large.morph v
+
+val ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: ref a q
+
+let ref_focus #a #b #c #p r #q l =
+  {p = r.p; pl = connection_compose r.pl l; r = r.r}
+
+module A = Steel.Effect.Atomic
+
+let focus (r: ref 'a 'p)
+  (#q: pcm 'c)
+  (l: connection 'p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ref 'a q)
+    (r `pts_to` s)
+    (fun r' -> r' `pts_to` x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ r' _ -> r' == ref_focus r l)
+= let r' = ref_focus r l in
+  A.change_slprop_rel  
+    (r `pts_to` s)
+    (r' `pts_to` x)
+    (fun _ _ -> True)
+    (fun m -> ());
+  A.return r'
+
+let unfocus #inames
+  (#p: pcm 'b)
+  (#q: pcm 'c)
+  (r: ref 'a q) (r': ref 'a p)
+  (l: connection p q) (x: Ghost.erased 'c)
+: A.SteelGhost unit inames
+    (r `pts_to` x)
+    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
+    (requires fun _ -> r == ref_focus r' l)
+    (ensures fun _ _ _ -> True)
+= A.change_slprop_rel  
+    (r `pts_to` x)
+    (r' `pts_to` l.conn_small_to_large.morph x)
+    (fun _ _ -> True)
+    (fun m -> ())
+
+val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+: Steel unit
+    (r `pts_to` xy)
+    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
+    (fun _ _ _ -> True)
+
+let split r xy x y =
+  A.change_equal_slprop
+    (r `pts_to` xy)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph xy)));
+  Steel.PCMReference.split r.r
+    (r.pl.conn_small_to_large.morph xy)
+    (r.pl.conn_small_to_large.morph x)
+    (r.pl.conn_small_to_large.morph y);
+  A.change_equal_slprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)))
+    (r `pts_to` x);
+  A.change_equal_slprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
+    (r `pts_to` y)
+
+let mgather
+  (#a:Type) (#p:pcm a)
+  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
+: SteelT (_:unit{composable p v0 v1})
+    (mpts_to r v0 `star` mpts_to r v1)
+    (fun _ -> mpts_to r (op p v0 v1))
+= Steel.PCMReference.gather r v0 v1
+
+val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+: SteelT (_:unit{composable p x y})
+    ((r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> r `pts_to` op p x y)
+
+let gather #a #b #p r x y =
+  A.change_equal_slprop
+    (r `pts_to` x)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)));
+  A.change_equal_slprop
+    (r `pts_to` y)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)));
+  mgather r.r
+    (r.pl.conn_small_to_large.morph x)
+    (r.pl.conn_small_to_large.morph y);
+  assert (
+    let x1 = r.pl.conn_small_to_large.morph x in
+    let y1 = r.pl.conn_small_to_large.morph y in
+    let x2 = r.pl.conn_large_to_small.morph x1 in
+    let y2 = r.pl.conn_large_to_small.morph y1 in
+    Ghost.reveal x == x2 /\ Ghost.reveal y == y2
+  );
+  A.change_equal_slprop _ (r `pts_to` op p x y)
+
+val ref_read
+  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+: Steel b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible p x x')
+
+let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
+: Steel 'b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible p x x')
+= let w = Ghost.hide (r.pl.conn_small_to_large.morph x) in
+  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
+  let w' = Steel.PCMReference.read r.r w in
+  A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
+  let x' = r.pl.conn_large_to_small.morph w' in
+  assert (forall frame . (composable r.p w frame /\ op r.p frame w == w') ==> (
+    let sw = r.pl.conn_large_to_small.morph w in
+    let sw' = r.pl.conn_large_to_small.morph w' in
+    let sframe = r.pl.conn_large_to_small.morph frame in
+    (composable p sw sframe /\ op p sframe sw == sw')
+  ));
+  A.return x'
+
+module M = Steel.Memory
+
+let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
+: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
+= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd x y f)
+
+let as_action (#p:vprop)
+              (#q:vprop)
+              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
+: SteelT unit p (fun x -> q)
+= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
+  let x = Steel.Effect.as_action f in
+  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
+  A.return x
+
+val ref_upd
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
+
+let ref_upd r x y f = as_action (ref_upd_act r x y f)
+
+(** A PCM for structs *)
+
+/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
+
+open FStar.FunctionalExtensionality
+open FStar.Classical
+let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality 'a 'b f g;
+  forall_intro fg
+
+let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
+  forall k. composable (p k) (x k) (y k)
+
+let prod_op (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: restricted_t 'a 'b
+= on_domain 'a (fun k -> op (p k) (x k) (y k))
+
+let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
+  on_domain 'a (fun k -> one (p k))
+
+let prod_comm (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: Lemma (prod_op p x y == prod_op p y x)
+= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
+
+let prod_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+: Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)]
+  = (p k).assoc (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+: Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)]
+  = (p k).assoc_r (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
+: Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+= let is_unit k
+  : Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)]
+  = (p k).is_unit (x k)
+  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
+
+let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
+  (exists (k: 'a). True) /\ (forall k. (p k).refine (x k))
+
+let prod_pcm' (p:(k:'a -> pcm ('b k))): FStar.PCM.pcm (restricted_t 'a 'b) = {
+  comm = prod_comm p;
+  FStar.PCM.p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
+
+let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
+  let p' = prod_pcm' p in
+  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
+    x `feq` one p' /\ y `feq` one p'
+  ));
+  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
+  p'
+
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+let field_to_struct_f
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (restricted_t a b)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let is_unit (#a: Type u#a) (p:pcm a) 
+  (x:a)
+:  Lemma (composable p x p.FStar.PCM.p.one /\
+         op p x p.FStar.PCM.p.one == x)
+= p.is_unit x
+
+let field_to_struct
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (prod_pcm p))
+= {
+  morph = field_to_struct_f p k;
+  morph_unit = assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p));
+  morph_compose = (fun x1 x2 ->
+    Classical.forall_intro_2 (fun k -> is_unit (p k));
+    assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
+      ()
+  );
+}
+
+let struct_to_field_f
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: restricted_t a b)
+: Tot (b k)
+= x k
+
+let struct_to_field
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (prod_pcm p) (p k))
+= {
+  morph = struct_to_field_f p k;
+  morph_unit = ();
+  morph_compose = (fun x1 x2 -> ());
+}
+
+let struct_field_lift_fpu'
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    (prod_pcm p).refine v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (restricted_t a b)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else v k'
+    )
+
+let struct_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    (prod_pcm p).refine v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Lemma
+  (let v_new = struct_field_lift_fpu' p k x y f v in
+    (prod_pcm p).refine v_new /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
+    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_struct p k).morph y in
+  let v_new = struct_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  assert (forall (frame: b k) .
+    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
+    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
+    composable (prod_pcm p) y' frame' /\
+    op (prod_pcm p) frame' y' `feq` v_new
+  ));
+  assert (compatible (prod_pcm p) y' v_new);
+  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
+  ()
+
+let struct_field_lift_fpu
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
+= fun v ->
+    struct_field_lift_fpu_prf p k x y f v;
+    struct_field_lift_fpu' p k x y f v
+
+let struct_field
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (prod_pcm p) (p k))
+= {
+  conn_small_to_large = field_to_struct p k;
+  conn_large_to_small = struct_to_field p k;
+  conn_small_to_large_inv = ();
+  conn_lift_frame_preserving_upd = struct_field_lift_fpu p k;
+}
+
+(** A PCM for unions TODO move to proper place *)
+
+open FStar.FunctionalExtensionality
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
+  forall k'. ~ (k == k') ==> f k' == one (p k')
+
+let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
+: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
+
+let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
+    (ensures f == one (prod_pcm p))
+= ext f (one (prod_pcm p)) (fun k -> ())
+
+let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
+  (exists (k:'a). True) ==> (exists k. case_refinement_f p k f)
+  (** precondition is there because we don't care if 'a is inhabited *)
+
+let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
+
+let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
+  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
+    [SMTPat (case_refinement_f p k f)]))
+: Lemma (forall (j:'a). goal)
+= let _ = cont in ()
+
+let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
+  (k:'a{case_refinement_f p k f})
+: Lemma (is_union p f)
+= ()
+
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
+  forall j k.
+  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
+  j == k /\ composable (p k) (f k) (g k)
+
+let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (union_comp p f g)
+= let _ = h in ()
+
+let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
+: Lemma
+    (requires union_comp p f g)
+    (ensures prod_comp p f g)
+    [SMTPat (union_comp p f g)]
+= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
+
+let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p k f /\ f k == one (p k))
+    (ensures f == one (prod_pcm p))
+    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
+= ext f (one (prod_pcm p)) (fun _ -> ())
+
+let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
+    (ensures
+      f == one (prod_pcm p) \/
+      g == one (prod_pcm p) \/ 
+      case_refinement_f p k (prod_op p f g))
+    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
+= let fj_or_gk_one
+  : squash
+      (f j == one (p j) \/ g k == one (p k) ==>
+       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
+  = ()
+  in let fj_gk_both_not_one ()
+  : Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures case_refinement_f p k (prod_op p f g))
+  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+  in
+  move_requires fj_gk_both_not_one ();
+  assert
+   ((f j == one (p j) \/ g k == one (p k)) ==>
+    f == one (prod_pcm p) \/
+    g == one (prod_pcm p) \/ 
+    case_refinement_f p k (prod_op p f g))
+
+let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
+  let h = prod_op p f g in
+  let goal = is_union p h in
+  union_elim p f goal (fun j ->
+  union_elim p g goal (fun k ->
+  case_refinement_f_op p j k f g;
+  (prod_pcm p).is_unit g));
+  h
+
+let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
+let union_refine (p:(k:'a -> pcm ('b k))) = prod_refine p
+
+let union_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
+: Lemma (union_comp p x y /\
+         union_comp p (union_op p x y) z /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+#restart-solver
+#push-options "--query_stats --z3rlimit 32"
+
+let union_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
+: Lemma (union_comp p y z /\
+         union_comp p x (union_op p y z) /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc_r p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+#pop-options
+
+let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
+: Lemma (union_comp p x (union_one p) /\
+         union_op p x (union_one p) == x)
+= (prod_pcm p).is_unit x
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
+  let p' = {
+    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
+    comm = (fun x y -> prod_comm p x y);
+    assoc = union_assoc p;
+    assoc_r = union_assoc_r p;
+    is_unit = union_is_unit p;
+    refine = union_refine p;
+  } in
+  let aux (x:union p) (y:union p{composable p' x y})
+  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+    [SMTPat (op p' x y)]
+  = ext x (one p') (fun k -> let _ = p k in ());
+    ext y (one p') (fun k -> let _ = p k in ())
+  in
+  assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
+  p'
+
+let field_to_union_f
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (union p)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let field_to_union
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (union_pcm p))
+= {
+  morph = field_to_union_f p k;
+  morph_unit = assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p));
+  morph_compose = (fun x1 x2 ->
+    Classical.forall_intro_2 (fun k -> is_unit (p k));
+    assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
+      ()
+  );
+}
+
+let union_to_field_f
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: union p)
+: Tot (b k)
+= x k
+
+let union_to_field
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (union_pcm p) (p k))
+= {
+  morph = union_to_field_f p k;
+  morph_unit = ();
+  morph_compose = (fun x1 x2 -> ());
+}
+
+let union_field_lift_fpu'
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: union p {
+    (union_pcm p).refine v /\
+    compatible (union_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (union p)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else one (p k')
+    )
+
+let compatible_intro
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+  (frame: a)
+: Lemma
+  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (ensures (compatible pcm x y))
+= ()
+
+let compatible_elim
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+: Ghost a
+  (requires (compatible pcm x y))
+  (ensures (fun frame ->
+    composable pcm x frame /\
+    op pcm frame x == y
+  ))
+= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
+    composable pcm x frame /\
+    op pcm frame x == y
+  )
+
+#restart-solver
+#push-options "--z3rlimit 32 --query_stats"
+
+let union_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: union p {
+    (union_pcm p).refine v /\
+    compatible (union_pcm p) ((field_to_union p k).morph x) v
+  })
+: Lemma
+  (let v_new = union_field_lift_fpu' p k x y f v in
+    (union_pcm p).refine v_new /\
+    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
+    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
+       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_union p k).morph y in
+  let v_new = union_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  let frame : b k = compatible_elim (p k) y (f (v k)) in
+  let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
+  assert (composable (union_pcm p) y' frame');
+  assert (op (union_pcm p) frame' y' `feq` v_new);
+  compatible_intro (union_pcm p) y' v_new frame';
+  assert (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
+       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new));
+  ()
+
+#pop-options
+
+let union_field_lift_fpu
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
+= fun v ->
+    union_field_lift_fpu_prf p k x y f v;
+    union_field_lift_fpu' p k x y f v
+
+let union_field
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (union_pcm p) (p k))
+= {
+  conn_small_to_large = field_to_union p k;
+  conn_large_to_small = union_to_field p k;
+  conn_small_to_large_inv = ();
+  conn_lift_frame_preserving_upd = union_field_lift_fpu p k;
+}
+
+let base_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a)
+  (y: a)
+: Pure (frame_preserving_upd p x y)
+  (requires (exclusive p x /\ p.refine y))
+  (ensures (fun _ -> True))
+= fun _ ->
+  Classical.forall_intro (is_unit p);
+  compatible_refl p y;
+  y
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x == true);
+}
+
+let opt_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
+  (y: a)
+: Tot (frame_preserving_upd opt_pcm x (Some y))
+= base_fpu opt_pcm x (Some y)
+
+val opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ _ _ -> True))
+
+let opt_pcm_write
+  r x y
+= ref_upd r x (Some y) (opt_pcm_fpu x y)
+
+val opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
+
+let opt_pcm_read
+  r x
+= let y' = ref_read r in
+  assert (Ghost.reveal x == y');
+  Some?.v y'
+
+/// Fractional permissions: from Steel.HigherReference
+open Steel.FractionalPermission
+
+let fractional (a:Type u#1) = option (a & perm)
+
+let fractional_composable #a : symrel (fractional a) =
+  fun (f0 f1:fractional a) ->
+    match f0, f1 with
+    | None, _
+    | _, None -> True
+    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
+
+let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
+  match f0, f1 with
+  | None, f
+  | f, None -> f
+  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
+
+let pcm_frac #a : pcm (fractional a) = {
+  FStar.PCM.p = {
+         composable = fractional_composable;
+         op = fractional_compose;
+         one = None
+      };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
+}
+
+let frac_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
+  (y: a)
+: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
+= base_fpu pcm_frac x (Some (y, full_perm))
+
+val frac_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
+  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
+  (ensures (fun _ _ _ -> True))
+
+let frac_pcm_write
+  r x y
+= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
+
+val frac_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
+
+let frac_pcm_read
+  r x
+= let y' = ref_read r in
+  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
+  fst (Some?.v y')
+
+
+/// Uninitialized
+
+noeq
+type uninit_t (a: Type)
+= | Uninitialized
+  | InitOrUnit: a -> uninit_t a
+
+let uninit_composable
+  (#a: Type)
+  (p: pcm a)
+: Tot (symrel (uninit_t a))
+= fun u1 u2 ->
+  match u1, u2 with
+  | Uninitialized, InitOrUnit x
+  | InitOrUnit x, Uninitialized
+    -> x == one p
+  | InitOrUnit x1, InitOrUnit x2
+    -> composable p x1 x2
+  | _ -> False
+
+let uninit_compose
+  (#a: Type)
+  (p: pcm a)
+  (u1: uninit_t a)
+  (u2: uninit_t a { uninit_composable p u1 u2 })
+: Tot (uninit_t a)
+= match u1, u2 with
+  | Uninitialized, _
+  | _, Uninitialized
+    -> Uninitialized
+  | InitOrUnit x1, InitOrUnit x2
+    -> InitOrUnit (op p x1 x2)
+
+let uninit_refine
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Tot prop
+= match x with
+  | Uninitialized -> True
+  | InitOrUnit y -> p.refine y
+
+let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
+  FStar.PCM.p = {
+         composable = uninit_composable p;
+         op = uninit_compose p;
+         one = InitOrUnit (one p);
+      };
+  comm = (fun _ _ ->
+    Classical.forall_intro_2 p.comm
+  );
+  assoc = (fun x1 x2 x3 ->
+    Classical.forall_intro_3 p.assoc;
+    Classical.forall_intro (is_unit p)
+  );
+  assoc_r = (fun _ _ _ -> 
+    Classical.forall_intro_3 p.assoc_r;
+    Classical.forall_intro (is_unit p)
+  );
+  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
+  refine = uninit_refine p;
+}
+
+let value_to_uninit
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism p (pcm_uninit p))
+= {
+  morph = (fun x -> InitOrUnit x);
+  morph_unit = ();
+  morph_compose = (fun _ _ -> ());
+}
+
+let uninit_to_value
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism (pcm_uninit p) p)
+= {
+  morph = (fun x -> match x with InitOrUnit y -> y | _ -> one p);
+  morph_unit = ();
+  morph_compose = (fun _ _ -> Classical.forall_intro (is_unit p));
+}
+
+let uninit_conn_fpu'
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Tot (uninit_t a)
+=
+  let InitOrUnit x' = v in
+  InitOrUnit (f x')
+
+let uninit_conn_fpu_prop
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Lemma
+  (let v_new = uninit_conn_fpu' p x y f v in
+    (pcm_uninit p).refine v_new /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
+    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
+  )
+= Classical.forall_intro (is_unit p);
+  let y' = (value_to_uninit p).morph y in
+  let InitOrUnit x' = v in
+  let v_new = uninit_conn_fpu' p x y f v in
+  let frame : a = compatible_elim p y (f x') in
+  let frame' : uninit_t a = InitOrUnit frame in
+  assert (composable (pcm_uninit p) y' frame');
+  assert (op (pcm_uninit p) frame' y' == v_new);
+  compatible_intro (pcm_uninit p) y' v_new frame';
+  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
+  ()
+
+let uninit_conn_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
+=
+  fun v ->
+    uninit_conn_fpu_prop p x y f v;
+    uninit_conn_fpu' p x y f v
+
+let uninit_conn
+  (#a: Type)
+  (p: pcm a)
+: Tot (connection (pcm_uninit p) p)
+= {
+  conn_small_to_large = value_to_uninit p;
+  conn_large_to_small = uninit_to_value p;
+  conn_small_to_large_inv = ();
+  conn_lift_frame_preserving_upd = uninit_conn_fpu p;
+}

From 189c9106ab3099e1d339efeeb4260b1915e1264b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 14 Jul 2021 10:25:10 -0700
Subject: [PATCH 081/513] Get basic struct example working with new model

---
 .../arraystructs/AggregateRefExamples.fst     | 54 +++++------
 examples/steel/arraystructs/FStar.PCM.POD.fst | 13 +--
 .../steel/arraystructs/FStar.PCM.POD.fsti     |  5 +-
 examples/steel/arraystructs/PointStruct.fst   | 56 +++++------
 examples/steel/arraystructs/PointStruct.fsti  | 11 +--
 examples/steel/arraystructs/Steel.C.PCM.fst   | 93 ++++++++++++++++++-
 6 files changed, 149 insertions(+), 83 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 0bed8d159fd..1063aaf0fa6 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -1,6 +1,6 @@
 module AggregateRefExamples
 
-open AggregateRef
+open Steel.C.PCM
 
 open Steel.Effect
 module A = Steel.Effect.Atomic
@@ -90,32 +90,32 @@ let point_swap_generically (#x #y: Ghost.erased int) (p: ref 'a point_pcm)
 ///   generic_swap(&p.p1.y, &p.p2.x);
 /// }
 
-open LineStruct
-
-let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
-: SteelT unit
-    (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
-    (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
-= (* generic_swap(&p.p1.x, &p.p2.y); *)
-  let pp1 = addr_of_p1 p in
-  let pp1x = addr_of_x pp1 in
-  let pp2 = addr_of_p2 p in
-  let pp2y = addr_of_y pp2 in
-  generic_swap pp1x pp2y;
-  (* generic_swap(&p.p1.y, &p.p2.x); *)
-  let pp1y = addr_of_y pp1 in
-  let pp2x = addr_of_x pp2 in
-  generic_swap pp1y pp2x;
-  (* Gather p1 *)
-  unaddr_of_x pp1 pp1x;
-  unaddr_of_y pp1 pp1y;
-  (* Gather p2 *)
-  unaddr_of_x pp2 pp2x;
-  unaddr_of_y pp2 pp2y;
-  (* Gather p *)
-  unaddr_of_p1 p pp1;
-  unaddr_of_p2 p pp2;
-  A.return ()
+//open LineStruct
+//
+//let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
+//: SteelT unit
+//    (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
+//    (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
+//= (* generic_swap(&p.p1.x, &p.p2.y); *)
+//  let pp1 = addr_of_p1 p in
+//  let pp1x = addr_of_x pp1 in
+//  let pp2 = addr_of_p2 p in
+//  let pp2y = addr_of_y pp2 in
+//  generic_swap pp1x pp2y;
+//  (* generic_swap(&p.p1.y, &p.p2.x); *)
+//  let pp1y = addr_of_y pp1 in
+//  let pp2x = addr_of_x pp2 in
+//  generic_swap pp1y pp2x;
+//  (* Gather p1 *)
+//  unaddr_of_x pp1 pp1x;
+//  unaddr_of_y pp1 pp1y;
+//  (* Gather p2 *)
+//  unaddr_of_x pp2 pp2x;
+//  unaddr_of_y pp2 pp2y;
+//  (* Gather p *)
+//  unaddr_of_p1 p pp1;
+//  unaddr_of_p2 p pp2;
+//  A.return ()
 
 /// Struct with potentially uninitialized values
 ///
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fst b/examples/steel/arraystructs/FStar.PCM.POD.fst
index a66a49861d1..0b93c5daaa3 100644
--- a/examples/steel/arraystructs/FStar.PCM.POD.fst
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fst
@@ -1,19 +1,12 @@
 module FStar.PCM.POD
 
-open AggregateRef
+open Steel.C.PCM
 module A = Steel.Effect.Atomic
 
-let pod a = option a
-
-let none #a = None #a
-let some x = Some (Ghost.reveal x)
-
-let pod_pcm a = FStar.PCM.Extras.opt_pcm #a
-
 let pod_read r =
   let Some x = ref_read r in
   x
 
-let pod_write r y =
-  ref_write r (Some y);
+let pod_write #a #b #x r y =
+  ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fsti b/examples/steel/arraystructs/FStar.PCM.POD.fsti
index 07c157d1d07..2f05c79943f 100644
--- a/examples/steel/arraystructs/FStar.PCM.POD.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fsti
@@ -1,8 +1,7 @@
 module FStar.PCM.POD
 
 open FStar.PCM
-open FStar.PCM.Extras
-open AggregateRef
+open Steel.C.PCM
 open Steel.Effect
 
 let pod: Type u#a -> Type u#a = option
@@ -11,7 +10,7 @@ let none #a: Ghost.erased (pod a) = None
 
 let some (x: Ghost.erased 'a): Ghost.erased (pod 'a) = Some (Ghost.reveal x)
 
-let pod_pcm (a:Type): refined_one_pcm (pod a) = opt_pcm #a
+let pod_pcm (a:Type): pcm (pod a) = opt_pcm #a
 
 val pod_read
   (#a:Type) (#b:Type) (#x: Ghost.erased b)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index eabf0cb7240..fb145e5de56 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -1,9 +1,7 @@
 module PointStruct
 
-open AggregateRef
 open FStar.PCM.POD
-open FStar.PCM
-open FStar.PCM.Extras
+open Steel.C.PCM
 open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
@@ -26,55 +24,49 @@ let mk_point_f (x y: pod int) (k: point_field): point_fields k = match k with
 let mk_point (x y: Ghost.erased (pod int)): GTot point =
   on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y))
 
-let _x = field point_fields_pcm X
-let _y = field point_fields_pcm Y
+let _x = struct_field point_fields_pcm X
+let _y = struct_field point_fields_pcm Y
 
-let put_x x' x y
-: Lemma (feq (put _x x' (mk_point x y)) (mk_point (Ghost.hide x') y))
-  [SMTPat (put _x x' (mk_point x y))]
-= ()
+/// Taking pointers to the x and y fields of a point
 
-let put_y y' x y
-: Lemma (feq (put _y y' (mk_point x y)) (mk_point x (Ghost.hide y')))
-  [SMTPat (put _y y' (mk_point x y))]
+let point_without_x x y
+: Lemma (struct_without_field point_fields_pcm X (mk_point x y) `feq` Ghost.reveal (mk_point none y))
+  [SMTPat (mk_point x y)]
 = ()
 
-/// Laws relating mk_point to PCM operations
-
-let one_xy : squash (feq (one point_pcm) (mk_point none none))
+let point_with_x x y
+: Lemma (struct_with_field point_fields_pcm X (Ghost.reveal x) (mk_point none y) `feq`
+         Ghost.reveal (mk_point x y))
+  [SMTPat (mk_point x y)]
 = ()
 
-// TODO
-let merge_xy (x y: Ghost.erased (pod int)) x' y'
-: Lemma
-    (requires composable point_pcm
-       (Ghost.reveal (mk_point x y))
-       (Ghost.reveal (mk_point x' y')))
-    (ensures
-     feq (op point_pcm (Ghost.reveal (mk_point x y)) (Ghost.reveal (mk_point x' y')))
-         (mk_point (op (point_fields_pcm X) (Ghost.reveal x) (Ghost.reveal x'))
-                   (op (point_fields_pcm Y) (Ghost.reveal y) (Ghost.reveal y'))))
-  [SMTPat (op point_pcm (Ghost.reveal (mk_point x y)) (Ghost.reveal (mk_point x' y')))]
+let point_without_y x y
+: Lemma (struct_without_field point_fields_pcm Y (mk_point x y) `feq` Ghost.reveal (mk_point x none))
+  [SMTPat (mk_point x y)]
 = ()
 
-/// Taking pointers to the x and y fields of a point
+let point_with_y x y
+: Lemma (struct_with_field point_fields_pcm Y (Ghost.reveal y) (mk_point x none) `feq`
+         Ghost.reveal (mk_point x y))
+  [SMTPat (mk_point x y)]
+= ()
 
 let addr_of_x #a #x #y p =
-  let q = addr_of_lens p _x (mk_point x y) in
+  let q = addr_of_struct_field p X (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
   A.return q
-
+  
 let unaddr_of_x #a #x #y p q =
-  unaddr_of_lens q p _x (mk_point none y) x;
+  unaddr_of_struct_field X q p (mk_point none y) x;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
-  let q = addr_of_lens p _y (mk_point x y) in
+  let q = addr_of_struct_field p Y (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
 let unaddr_of_y #a #x #y p q =
-  unaddr_of_lens q p _y (mk_point x none) y;
+  unaddr_of_struct_field Y q p (mk_point x none) y;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index a5e7c4df2aa..6ccfd5a801a 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -1,9 +1,8 @@
 module PointStruct
 
-open AggregateRef
 open FStar.PCM.POD
 open FStar.PCM
-open FStar.PCM.Extras
+open Steel.C.PCM
 open Steel.Effect
 
 /// Suppose we have the following struct representing 2d points:
@@ -15,16 +14,16 @@ val point : Type0
 
 /// PCM for struct point:
 
-val point_pcm : refined_one_pcm point
+val point_pcm : pcm point
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
 
 val mk_point (x y: Ghost.erased (pod int)): Ghost.erased point
 
-/// PCM lenses for the fields of a point
+/// Connections for the fields of a point
 
-val _x : pcm_lens point_pcm (pod_pcm int)
-val _y : pcm_lens point_pcm (pod_pcm int)
+val _x : connection point_pcm (pod_pcm int)
+val _y : connection point_pcm (pod_pcm int)
 
 /// Taking pointers to the x and y fields of a point
 
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 4e2e84d5455..3e310f9fbe5 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -7,9 +7,9 @@ let one (#a: Type) (p: pcm a) = p.p.one
 let pcm (a: Type) : Tot Type =
   (p: FStar.PCM.pcm a {
     (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
-      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
-    (forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
-    (~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+      op p x y == one p ==> x == one p /\ y == one p) // /\ // necessary to lift frame-preserving updates to unions
+    //(forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
+    //(~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
   })
 
 noeq
@@ -92,6 +92,11 @@ let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to
 
 open Steel.Effect
 
+//val pts_to
+//  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+//  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
+//: vprop
+
 val pts_to
   (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
   (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
@@ -327,7 +332,7 @@ let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
   assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
     x `feq` one p' /\ y `feq` one p'
   ));
-  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
+  //assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
   p'
 
 let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
@@ -470,6 +475,84 @@ let struct_field
   conn_lift_frame_preserving_upd = struct_field_lift_fpu p k;
 }
 
+let struct_without_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
+
+#push-options "--print_universes"
+
+let struct_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: Lemma (
+    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
+    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+= prod_pcm_composable_intro p
+    (struct_without_field p k xs)
+    (field_to_struct_f p k (xs k))
+    (fun k' -> (p k').is_unit (xs k'));
+  let aux (k':a)
+  : Lemma (xs k' == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) k')
+    [SMTPat (xs k')]
+  = (p k').is_unit (xs k'); if k' = k then (p k).comm (one (p k)) (xs k) else ()
+  in assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+
+let addr_of_struct_field
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
+let struct_with_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (x:b k) (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then x else xs k')
+
+let struct_unpeel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (x: b k) (xs: restricted_t a b)
+: Lemma
+    (requires xs k == one (p k))
+    (ensures
+      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
+      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
+= prod_pcm_composable_intro p xs (field_to_struct_f p k x)
+    (fun k' -> (p k).is_unit x; (p k').is_unit (xs k'));
+  let aux (k':a)
+  : Lemma (struct_with_field p k x xs k' == op (prod_pcm p) xs (field_to_struct_f p k x) k')
+    [SMTPat (struct_with_field p k x xs k')]
+  = if k' = k then begin
+      (p k).is_unit x; (p k).comm (one (p k)) x; assert (x == op (p k) (one (p k)) x)
+    end else begin
+      (p k').is_unit (xs k'); assert (xs k' == op (p k') (xs k') (one (p k')))
+    end
+  in
+  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
+
+let unaddr_of_struct_field
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (prod_pcm p))
+  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
+: Steel unit
+    ((r `pts_to` xs) `star` (r' `pts_to` x))
+    (fun s -> r `pts_to` struct_with_field p k x xs)
+    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
+    (ensures fun _ _ _ -> True)
+= unfocus r' r (struct_field p k) x;
+  gather r xs (field_to_struct_f p k x);
+  struct_unpeel p k x xs;
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  A.return ()
+
 (** A PCM for unions TODO move to proper place *)
 
 open FStar.FunctionalExtensionality
@@ -615,7 +698,7 @@ let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
   = ext x (one p') (fun k -> let _ = p k in ());
     ext y (one p') (fun k -> let _ = p k in ())
   in
-  assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
+  //assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
   p'
 
 let field_to_union_f

From 950e8a968c0724823e1e9552985f5e7f04895ce3 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 14 Jul 2021 11:00:12 -0700
Subject: [PATCH 082/513] Get examples working again

---
 .../arraystructs/AggregateRefExamples.fst     | 52 +++++------
 examples/steel/arraystructs/IntOrBool.fst     | 16 ----
 examples/steel/arraystructs/IntOrBool.fsti    | 42 +++------
 examples/steel/arraystructs/LineStruct.fst    | 48 +++++-----
 examples/steel/arraystructs/LineStruct.fsti   | 12 +--
 examples/steel/arraystructs/Steel.C.PCM.fst   | 88 ++++++++++++++-----
 6 files changed, 133 insertions(+), 125 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 1063aaf0fa6..282c81a0c18 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -90,32 +90,32 @@ let point_swap_generically (#x #y: Ghost.erased int) (p: ref 'a point_pcm)
 ///   generic_swap(&p.p1.y, &p.p2.x);
 /// }
 
-//open LineStruct
-//
-//let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
-//: SteelT unit
-//    (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
-//    (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
-//= (* generic_swap(&p.p1.x, &p.p2.y); *)
-//  let pp1 = addr_of_p1 p in
-//  let pp1x = addr_of_x pp1 in
-//  let pp2 = addr_of_p2 p in
-//  let pp2y = addr_of_y pp2 in
-//  generic_swap pp1x pp2y;
-//  (* generic_swap(&p.p1.y, &p.p2.x); *)
-//  let pp1y = addr_of_y pp1 in
-//  let pp2x = addr_of_x pp2 in
-//  generic_swap pp1y pp2x;
-//  (* Gather p1 *)
-//  unaddr_of_x pp1 pp1x;
-//  unaddr_of_y pp1 pp1y;
-//  (* Gather p2 *)
-//  unaddr_of_x pp2 pp2x;
-//  unaddr_of_y pp2 pp2y;
-//  (* Gather p *)
-//  unaddr_of_p1 p pp1;
-//  unaddr_of_p2 p pp2;
-//  A.return ()
+open LineStruct
+
+let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
+: SteelT unit
+    (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
+    (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
+= (* generic_swap(&p.p1.x, &p.p2.y); *)
+  let pp1 = addr_of_p1 p in
+  let pp1x = addr_of_x pp1 in
+  let pp2 = addr_of_p2 p in
+  let pp2y = addr_of_y pp2 in
+  generic_swap pp1x pp2y;
+  (* generic_swap(&p.p1.y, &p.p2.x); *)
+  let pp1y = addr_of_y pp1 in
+  let pp2x = addr_of_x pp2 in
+  generic_swap pp1y pp2x;
+  (* Gather p1 *)
+  unaddr_of_x pp1 pp1x;
+  unaddr_of_y pp1 pp1y;
+  (* Gather p2 *)
+  unaddr_of_x pp2 pp2x;
+  unaddr_of_y pp2 pp2y;
+  (* Gather p *)
+  unaddr_of_p1 p pp1;
+  unaddr_of_p2 p pp2;
+  A.return ()
 
 /// Struct with potentially uninitialized values
 ///
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index bed84ec4891..f4717f97bb5 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -62,22 +62,6 @@ let switch_to_bool (#i: Ghost.erased int)
   ref_write p u;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-mk_int i = (i, one)
-mk_bool b = (one, b)
-
-thread 1:
-  u.case1 = v1
-  p = &u.case1
-  p `pts_to` case1 (1 v1)
-  (p `pts_to` case1 (0.5 v1) `star`
-  (q `pts_to` case1 (0.5 v1))
-  fork()
-  (p `pts_to` case1 (0.5 v1))
-  (focus (refine p .) . `pts_to` v1)
-
-thread 2:
-  (q `pts_to` case1 (0.5 v1))
-
 let switch_to_int (#b: Ghost.erased bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 1708b8a4074..ac139d85e54 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -1,75 +1,59 @@
 module IntOrBool
 
-open AggregateRef
 open FStar.PCM
-open FStar.PCM.Extras
 open FStar.PCM.POD
+open Steel.C.PCM
 open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
 /// union int_or_bool { int i; bool b; };
 ///
-/// Carrier of PCM for int_or_bool:
+/// PCM for int_or_bool:
 
 type int_or_bool_case = | I | B
 
 let int_or_bool_cases k = match k with
   | I -> pod int
   | B -> pod bool
-let int_or_bool = union int_or_bool_cases
-
-/// PCM for int_or_bool:
-
-let int_or_bool_cases_pcm k: refined_one_pcm (int_or_bool_cases k) = match k with
+  
+let int_or_bool_cases_pcm k: pcm (int_or_bool_cases k) = match k with
   | I -> pod_pcm int
   | B -> pod_pcm bool
-  
-let int_or_bool_pcm: refined_one_pcm int_or_bool = union_pcm int_or_bool_cases_pcm
+let int_or_bool = union int_or_bool_cases_pcm
+let int_or_bool_pcm: pcm int_or_bool = union_pcm int_or_bool_cases_pcm
 
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
 
-//val mk: tag -> Ghost.erased (int_or_bool_cases tag) -> Ghost.erased int_or_bool
-
 val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
 val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
 
-/// Refinements for cases
-
-val re_i : pcm_refinement int_or_bool_pcm
-val re_b : pcm_refinement int_or_bool_pcm
+/// Connections for cases
 
-/// Lenses for cases
-
-val _i : pcm_lens (refined_pcm re_i) (pod_pcm int)
-val _b : pcm_lens (refined_pcm re_b) (pod_pcm bool)
+val _i : connection int_or_bool_pcm (pod_pcm int)
+val _b : connection int_or_bool_pcm (pod_pcm bool)
 
 /// Taking pointers to the i and b cases of an int_or_bool
 
-//val addr_of_i (#i: Ghost.erased (pod int){case u == I}) (p: ref 'a int_or_bool_pcm)
-//: SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
-//    (p `pts_to` u)
-//    (fun q -> q `pts_to` proj2 u)
-
 val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
     (fun q -> q `pts_to` i)
 
 val unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+  (q: ref 'a (pod_pcm int){q == ref_focus p _i})
 : A.SteelGhostT unit opened (q `pts_to` i) (fun _ -> p `pts_to` mk_int i)
 
 val addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
     (p `pts_to` mk_bool b)
     (fun q -> q `pts_to` b)
 
 val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+  (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
 : A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
 
 /// Switching the case
diff --git a/examples/steel/arraystructs/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
index aa87085fd8b..19184a5fa17 100644
--- a/examples/steel/arraystructs/LineStruct.fst
+++ b/examples/steel/arraystructs/LineStruct.fst
@@ -30,53 +30,51 @@ let mk_line_f (p1 p2: point) (k: line_field): line_fields k = match k with
   | P2 -> p2
 let mk_line p1 p2 = on_domain line_field (mk_line_f (Ghost.reveal p1) (Ghost.reveal p2))
 
-let _p1 = field line_fields_pcm P1
-let _p2 = field line_fields_pcm P2
+let _p1 = struct_field line_fields_pcm P1
+let _p2 = struct_field line_fields_pcm P2
 
-/// Laws about putting/getting the x and y fields of a (mk_line x y)
+/// Taking pointers to the p1 and p2 fields of a line
 
-let put_p1 p1' p1 p2
-: Lemma (feq (put _p1 (Ghost.reveal p1') (mk_line p1 p2)) (mk_line p1' p2))
-  [SMTPat (put _p1 p1' (mk_line p1 p2))]
+let line_without_p1 p1 p2
+: Lemma (struct_without_field line_fields_pcm P1 (mk_line p1 p2) `feq`
+         Ghost.reveal (mk_line (one point_pcm) p2))
+  [SMTPat (mk_line p1 p2)]
 = ()
 
-let put_p2 p2' p1 p2
-: Lemma (feq (put _p2 (Ghost.reveal p2') (mk_line p1 p2)) (mk_line p1 p2'))
-  [SMTPat (put _p2 p2' (mk_line p1 p2))]
+let line_with_p1 p1 p2
+: Lemma (struct_with_field line_fields_pcm P1 (Ghost.reveal p1) (mk_line (one point_pcm) p2) `feq`
+         Ghost.reveal (mk_line p1 p2))
+  [SMTPat (mk_line p1 p2)]
 = ()
 
-/// Laws relating mk_line to PCM operations
-
-let one_line : squash (feq (one line_pcm) (mk_line (one point_pcm) (one point_pcm)))
+let line_without_p2 p1 p2
+: Lemma (struct_without_field line_fields_pcm P2 (mk_line p1 p2) `feq`
+         Ghost.reveal (mk_line p1 (one point_pcm)))
+  [SMTPat (mk_line p1 p2)]
 = ()
 
-let merge_line p1 p2 p1' p2'
-: Lemma
-    (requires composable line_pcm (mk_line p1 p2) (mk_line p1' p2'))
-    (ensures feq (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))
-             (mk_line (op (line_fields_pcm P1) (Ghost.reveal p1) (Ghost.reveal p1'))
-                      (op (line_fields_pcm P2) (Ghost.reveal p2) (Ghost.reveal p2'))))
-  [SMTPat (op line_pcm (mk_line p1 p2) (mk_line p1' p2'))]
+let line_with_p2 p1 p2
+: Lemma (struct_with_field line_fields_pcm P2 (Ghost.reveal p2) (mk_line p1 (one point_pcm)) `feq`
+         Ghost.reveal (mk_line p1 p2))
+  [SMTPat (mk_line p1 p2)]
 = ()
 
-/// Taking pointers to the p1 and p2 fields of a line
-
 let addr_of_p1 #a #p1 #p2 p =
-  let q = addr_of_lens p _p1 (mk_line p1 p2) in
+  let q = addr_of_struct_field p P1 (mk_line p1 p2) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line (one point_pcm) p2);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
   A.return q
 
 let unaddr_of_p1 #a #p1 #p2 p q =
-  unaddr_of_lens q p _p1 (mk_line (one point_pcm) p2) p1;
+  unaddr_of_struct_field P1 q p (mk_line (one point_pcm) p2) p1;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_p2 #a #p1 #p2 p =
-  let q = addr_of_lens p _p2 (mk_line p1 p2) in
+  let q = addr_of_struct_field p P2 (mk_line p1 p2) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line p1 (one point_pcm));
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
   A.return q
 
 let unaddr_of_p2 #a #p1 #p2 p q =
-  unaddr_of_lens q p _p2 (mk_line p1 (one point_pcm)) p2;
+  unaddr_of_struct_field P2 q p (mk_line p1 (one point_pcm)) p2;
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
index 8545cde01f6..9b0ad0b8fa7 100644
--- a/examples/steel/arraystructs/LineStruct.fsti
+++ b/examples/steel/arraystructs/LineStruct.fsti
@@ -1,10 +1,10 @@
 module LineStruct
 
-open AggregateRef
+open FStar.PCM.POD
 open FStar.PCM
-open FStar.PCM.Extras
 open Steel.Effect
 open PointStruct
+open Steel.C.PCM
 
 /// Example 2: pointers to nested fields
 ///
@@ -17,7 +17,7 @@ val line : Type0
 
 /// PCM for line:
 
-val line_pcm : refined_one_pcm line
+val line_pcm : pcm line
 
 /// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
 
@@ -25,8 +25,10 @@ val mk_line (x y: Ghost.erased point): Ghost.erased line
 
 /// Lenses for fields
 
-val _p1 : pcm_lens line_pcm point_pcm
-val _p2 : pcm_lens line_pcm point_pcm
+#push-options "--print_universes"
+
+val _p1 : connection line_pcm point_pcm
+val _p2 : connection line_pcm point_pcm
 
 /// Taking pointers to the p1 and p2 fields of a line
 
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 3e310f9fbe5..7498dcecf71 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -480,23 +480,15 @@ let struct_without_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 : restricted_t a b
 = on_dom a (fun k' -> if k' = k then one (p k) else xs k')
 
-#push-options "--print_universes"
-
 let struct_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   (xs: restricted_t a b)
 : Lemma (
     composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
     xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-= prod_pcm_composable_intro p
-    (struct_without_field p k xs)
-    (field_to_struct_f p k (xs k))
-    (fun k' -> (p k').is_unit (xs k'));
-  let aux (k':a)
-  : Lemma (xs k' == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) k')
-    [SMTPat (xs k')]
-  = (p k').is_unit (xs k'); if k' = k then (p k).comm (one (p k)) (xs k) else ()
-  in assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+  
 let addr_of_struct_field
   #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
   (r: ref base (prod_pcm p)) (k:a)
@@ -525,17 +517,8 @@ let struct_unpeel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
     (ensures
       composable (prod_pcm p) xs (field_to_struct_f p k x) /\
       struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
-= prod_pcm_composable_intro p xs (field_to_struct_f p k x)
-    (fun k' -> (p k).is_unit x; (p k').is_unit (xs k'));
-  let aux (k':a)
-  : Lemma (struct_with_field p k x xs k' == op (prod_pcm p) xs (field_to_struct_f p k x) k')
-    [SMTPat (struct_with_field p k x xs k')]
-  = if k' = k then begin
-      (p k).is_unit x; (p k).comm (one (p k)) x; assert (x == op (p k) (one (p k)) x)
-    end else begin
-      (p k').is_unit (xs k'); assert (xs k' == op (p k') (xs k') (one (p k')))
-    end
-  in
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
   assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
 let unaddr_of_struct_field
@@ -552,7 +535,7 @@ let unaddr_of_struct_field
   struct_unpeel p k x xs;
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   A.return ()
-
+  
 (** A PCM for unions TODO move to proper place *)
 
 open FStar.FunctionalExtensionality
@@ -859,6 +842,63 @@ let union_field
   conn_lift_frame_preserving_upd = union_field_lift_fpu p k;
 }
 
+let union_without_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: union p)
+: union p
+= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
+
+let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: union p)
+: Lemma (
+    composable (prod_pcm p) (union_without_field p k xs) (field_to_union_f p k (xs k)) /\
+    xs == op (prod_pcm p) (union_without_field p k xs) (field_to_union_f p k (xs k)))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (xs `feq` op (prod_pcm p) (union_without_field p k xs) (field_to_union_f p k (xs k)))
+
+let addr_of_union_field
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref base (union_pcm p)) (k:a)
+  (xs: Ghost.erased (union p))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` union_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
+= union_peel p k xs;
+  split r xs (union_without_field p k xs) (field_to_union_f p k (Ghost.reveal xs k));
+  let r = focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
+let union_with_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (x:b k) (xs: union p{xs == one (union_pcm p)})
+: union p
+= on_dom a (fun k' -> if k' = k then x else xs k')
+
+let union_unpeel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (x: b k) (xs: union p{xs == one (union_pcm p)})
+: Lemma
+    (requires xs k == one (p k))
+    (ensures
+      composable (union_pcm p) xs (field_to_union_f p k x) /\
+      union_with_field p k x xs == op (union_pcm p) xs (field_to_union_f p k x))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (union_with_field p k x xs `feq` op (union_pcm p) xs (field_to_union_f p k x))
+
+let unaddr_of_union_field
+  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (union_pcm p))
+  (x: Ghost.erased (b k))
+: A.SteelGhost unit opened
+    (r' `pts_to` x)
+    (fun s -> r `pts_to` field_to_union_f p k x)
+    (requires fun _ -> r' == ref_focus r (union_field p k))
+    (ensures fun _ _ _ -> True)
+= unfocus r' r (union_field p k) x
+
 let base_fpu
   (#a: Type)
   (p: pcm a)

From f637d6cf4857f1a5019eeb7864723367e8febdea Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 14 Jul 2021 11:53:49 -0700
Subject: [PATCH 083/513] Notes on unions

---
 examples/steel/arraystructs/IntOrBool.fsti | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index ac139d85e54..2efa469a11b 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -34,6 +34,9 @@ val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
 val _i : connection int_or_bool_pcm (pod_pcm int)
 val _b : connection int_or_bool_pcm (pod_pcm bool)
 
+// Construct using strong_excluded_middle
+//val case_of : int_or_bool -> GTot (option int_or_bool_case)
+
 /// Taking pointers to the i and b cases of an int_or_bool
 
 val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
@@ -65,3 +68,8 @@ val switch_to_bool (#i: Ghost.erased int)
 val switch_to_int (#b: Ghost.erased bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))
+
+/// Laws about unions
+
+//compatible p (mk_int i) v
+//==> exists j. v = mk_int j

From 2c28a971cdcfc88b0f6a74f262227b8b45c94c71 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 14 Jul 2021 13:52:12 -0700
Subject: [PATCH 084/513] Start on PCM for lists

---
 examples/steel/arraystructs/ListNode.fst   | 240 +++++++++++++++++++++
 examples/steel/arraystructs/ListNode.fsti_ |  54 +++++
 2 files changed, 294 insertions(+)
 create mode 100644 examples/steel/arraystructs/ListNode.fst
 create mode 100644 examples/steel/arraystructs/ListNode.fsti_

diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
new file mode 100644
index 00000000000..f86b54cac8b
--- /dev/null
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -0,0 +1,240 @@
+module ListNode
+
+#push-options "--print_universes"
+
+open FStar.FunctionalExtensionality
+module A = Steel.Effect.Atomic
+open Steel.Effect
+open FStar.PCM
+open FStar.PCM.POD
+open Steel.C.PCM
+
+type node_field = | Value | Next
+
+let ref' a b = pb: Ghost.erased (pcm b) & ref a pb
+
+let node_fields node k = match k with
+  | Value -> pod (FStar.Universe.raise_t int)
+  | Next -> pod (option (ref' (FStar.Universe.raise_t node) node))
+
+#push-options "--__no_positivity"
+noeq type node =
+{ un_node: restricted_t node_field (node_fields node) }
+#pop-options
+
+let node_fields_pcm k: pcm (node_fields node k) = match k with
+  | Value -> pod_pcm (FStar.Universe.raise_t int)
+  | Next -> pod_pcm (option (ref' (FStar.Universe.raise_t node) node))
+
+let node_pcm' = prod_pcm node_fields_pcm
+
+let node_pcm: pcm node =
+  let p: FStar.PCM.pcm node = {
+    FStar.PCM.p = {
+      composable = (fun x y -> composable node_pcm' x.un_node y.un_node);
+      op = (fun x y -> Mknode (op node_pcm' x.un_node y.un_node));
+      one = Mknode (one node_pcm');
+    };
+    comm = (fun x y -> node_pcm'.comm x.un_node y.un_node);
+    assoc = (fun x y z -> node_pcm'.assoc x.un_node y.un_node z.un_node);
+    assoc_r = (fun x y z -> node_pcm'.assoc_r x.un_node y.un_node z.un_node);
+    is_unit = (fun x -> node_pcm'.is_unit x.un_node);
+    refine = (fun x -> node_pcm'.refine x.un_node);
+  } in
+  p
+
+let roll: node_pcm' `morphism` node_pcm = {
+  morph = Mknode;
+  morph_unit = ();
+  morph_compose = (fun _ _ -> ());
+}
+
+let unroll: node_pcm `morphism` node_pcm' = {
+  morph = Mknode?.un_node;
+  morph_unit = ();
+  morph_compose = (fun _ _ -> ());
+}
+
+let mk_un_node: squash (Mknode `is_inverse_of` Mknode?.un_node) = ()
+let un_mk_node: squash (Mknode?.un_node `is_inverse_of` Mknode) = ()
+
+let roll_compatible x v
+: Lemma
+    (requires compatible node_pcm' x v)
+    (ensures compatible node_pcm (Mknode x) (Mknode v))
+    [SMTPat (compatible node_pcm' x v)]
+= let frame = compatible_elim node_pcm' x v in
+  compatible_intro node_pcm (Mknode x) (Mknode v) (Mknode frame)
+
+val compatible_morphism
+  (#p: pcm 'a) (#q: pcm 'b)
+  (f: p `morphism` q)
+  (x y: Ghost.erased 'a)
+: Lemma
+    (requires compatible p x y)
+    (ensures compatible q (f.morph x) (f.morph y))
+
+let compatible_morphism #a #b #p #q f x y =
+  let frame_x = compatible_elim p x y in
+  let _ = f.morph_compose frame_x x in
+  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
+
+let unroll_compatible x v
+: Lemma
+    (requires compatible node_pcm x v)
+    (ensures compatible node_pcm' x.un_node v.un_node)
+    [SMTPat (compatible node_pcm x v)]
+= compatible_morphism unroll x v
+
+let roll_conn_lift_fpu
+  (x: Ghost.erased _ {~ (Ghost.reveal x == one node_pcm) })
+  (y: Ghost.erased _)
+  (f: frame_preserving_upd node_pcm x y)
+: frame_preserving_upd node_pcm' x.un_node y.un_node
+= fun v ->
+  let w = (f (Mknode v)).un_node in
+  assert (node_pcm'.refine w);
+  assert (compatible node_pcm' y.un_node w);
+  let aux (frame:_{composable node_pcm' x.un_node frame})
+  : Lemma (
+      composable node_pcm' y.un_node frame /\
+      (op node_pcm' x.un_node frame == v ==> op node_pcm' y.un_node frame == w))
+  = roll.morph_compose x.un_node frame
+  in FStar.Classical.forall_intro aux;
+  w
+
+let roll_conn: node_pcm' `connection` node_pcm = {
+  conn_small_to_large = unroll;
+  conn_large_to_small = roll;
+  conn_small_to_large_inv = ();
+  conn_lift_frame_preserving_upd = roll_conn_lift_fpu;
+}
+
+let unroll_conn_lift_fpu
+  (x: Ghost.erased _ {~ (Ghost.reveal x == one node_pcm') })
+  (y: Ghost.erased _)
+  (f: frame_preserving_upd node_pcm' x y)
+: frame_preserving_upd node_pcm (Mknode x) (Mknode y)
+= fun v ->
+  let w = Mknode (f v.un_node) in
+  let aux (frame:_{composable node_pcm (Mknode x) frame})
+  : Lemma (
+      composable node_pcm (Mknode y) frame /\
+      (op node_pcm (Mknode x) frame == v ==> op node_pcm (Mknode y) frame == w))
+  = unroll.morph_compose (Mknode x) frame
+  in FStar.Classical.forall_intro aux;
+  w
+
+let unroll_conn: node_pcm `connection` node_pcm' = {
+  conn_small_to_large = roll;
+  conn_large_to_small = unroll;
+  conn_small_to_large_inv = ();
+  conn_lift_frame_preserving_upd = unroll_conn_lift_fpu;
+}
+
+let mk_node' (value: Ghost.erased _) (next: Ghost.erased _): Ghost.erased _ =
+  Ghost.hide (fun k -> match k with
+  | Value -> value
+  | Next -> next)
+
+let mk_node (value: Ghost.erased _) (next: Ghost.erased _): Ghost.erased _ =
+  Ghost.hide (mk_node' (Ghost.reveal value) (Ghost.reveal next))
+
+assume val _value : connection node_pcm (pod_pcm (FStar.Universe.raise_t int))
+
+let one_next : Ghost.erased (pod (Universe.raise_t int)) =
+  Ghost.hide (one (pod_pcm (FStar.Universe.raise_t int)))
+
+let addr_of_next
+  (#value:Ghost.erased (pod (Universe.raise_t int)))
+  (#next:Ghost.erased _)
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm (FStar.Universe.raise_t int)){q == ref_focus p _value})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node one_next next) `star`
+       (q `pts_to` value))
+= A.sladmit(); A.return (admit())
+
+//let node_pcm: pcm (restricted_t 
+//node --> prod_pcm node_pcm_fields
+
+// #push-options "--print_universes"
+// 
+// let x = 3
+// 
+// #pop-options
+// 
+// type node = {
+// }
+// 
+// let node_fields k: Type = match k with
+//   | I -> pod int
+//   | Next -> uninit_t (pod rec_arg)
+//   
+// let node (rec_arg:Type): Type = restricted_t node_field (node_fields rec_arg)
+// 
+// /// PCM for node:
+// 
+// let node_fields_pcm k : pcm (node_fields k) = match k with
+//   | P1 -> point_pcm
+//   | P2 -> point_pcm
+// let node_pcm = prod_pcm node_fields_pcm
+// 
+// /// (mk_node p1 p2) represents (struct node){.p1 = p1, .p2 = p2}
+// 
+// let mk_node_f (p1 p2: point) (k: node_field): node_fields k = match k with
+//   | P1 -> p1
+//   | P2 -> p2
+// let mk_node p1 p2 = on_domain node_field (mk_node_f (Ghost.reveal p1) (Ghost.reveal p2))
+// 
+// let _p1 = struct_field node_fields_pcm P1
+// let _p2 = struct_field node_fields_pcm P2
+// 
+// /// Taking pointers to the p1 and p2 fields of a node
+// 
+// let node_without_p1 p1 p2
+// : Lemma (struct_without_field node_fields_pcm P1 (mk_node p1 p2) `feq`
+//          Ghost.reveal (mk_node (one point_pcm) p2))
+//   [SMTPat (mk_node p1 p2)]
+// = ()
+// 
+// let node_with_p1 p1 p2
+// : Lemma (struct_with_field node_fields_pcm P1 (Ghost.reveal p1) (mk_node (one point_pcm) p2) `feq`
+//          Ghost.reveal (mk_node p1 p2))
+//   [SMTPat (mk_node p1 p2)]
+// = ()
+// 
+// let node_without_p2 p1 p2
+// : Lemma (struct_without_field node_fields_pcm P2 (mk_node p1 p2) `feq`
+//          Ghost.reveal (mk_node p1 (one point_pcm)))
+//   [SMTPat (mk_node p1 p2)]
+// = ()
+// 
+// let node_with_p2 p1 p2
+// : Lemma (struct_with_field node_fields_pcm P2 (Ghost.reveal p2) (mk_node p1 (one point_pcm)) `feq`
+//          Ghost.reveal (mk_node p1 p2))
+//   [SMTPat (mk_node p1 p2)]
+// = ()
+// 
+// let addr_of_p1 #a #p1 #p2 p =
+//   let q = addr_of_struct_field p P1 (mk_node p1 p2) in
+//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_node (one point_pcm) p2);
+//   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
+//   A.return q
+// 
+// let unaddr_of_p1 #a #p1 #p2 p q =
+//   unaddr_of_struct_field P1 q p (mk_node (one point_pcm) p2) p1;
+//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+// 
+// let addr_of_p2 #a #p1 #p2 p =
+//   let q = addr_of_struct_field p P2 (mk_node p1 p2) in
+//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_node p1 (one point_pcm));
+//   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
+//   A.return q
+// 
+// let unaddr_of_p2 #a #p1 #p2 p q =
+//   unaddr_of_struct_field P2 q p (mk_node p1 (one point_pcm)) p2;
+//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+#pop-options
diff --git a/examples/steel/arraystructs/ListNode.fsti_ b/examples/steel/arraystructs/ListNode.fsti_
new file mode 100644
index 00000000000..b9c1e94b0da
--- /dev/null
+++ b/examples/steel/arraystructs/ListNode.fsti_
@@ -0,0 +1,54 @@
+module ListNode
+
+open FStar.PCM.POD
+open FStar.PCM
+open Steel.Effect
+open PointStruct
+open Steel.C.PCM
+
+/// struct node { int i; struct node *next; };
+
+val node : Type u#1
+
+/// PCM for node:
+
+val node_pcm : pcm node
+
+/// (mk_node i next) represents (struct node){.i = i, .next = next}
+
+val mk_node (i: Ghost.erased (pod int)) (next: Ghost.erased (uninit_t (pod (ref node node_pcm)))): Ghost.erased node
+
+/// Lenses for fields
+
+val _i : connection node_pcm (pod_pcm int)
+val _next : connection node_pcm (pcm_uninit (pod_pcm (ref node node_pcm)))
+
+/// Taking pointers to the fields of a node
+
+val addr_of_p1 (#i:_) (#next:_) (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
+    (p `pts_to` mk_node i next)
+    (fun q ->
+       (p `pts_to` mk_node (one (pod_pcm int)) next) `star`
+       (q `pts_to` i))
+
+val unaddr_of_p1 (#i:_) (#next:_)
+  (p: ref 'a node_pcm)
+  (q: ref 'a (pod_pcm int){q == ref_focus p _i})
+: SteelT unit
+    ((p `pts_to` mk_node (one (pod_pcm int)) next) `star` (q `pts_to` i))
+    (fun q -> p `pts_to` mk_node i next)
+
+val addr_of_p2 (#i:_) (#next:_) (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pcm_uninit (pod_pcm (ref node node_pcm))){q == ref_focus p _next})
+    (p `pts_to` mk_node i next)
+    (fun q ->
+       (p `pts_to` mk_node i (one (pcm_uninit (pod_pcm (ref node node_pcm))))) `star`
+       (q `pts_to` next))
+
+val unaddr_of_p2 (#i:_) (#next:_)
+  (p: ref 'a node_pcm)
+  (q: ref 'a (pcm_uninit (pod_pcm (ref node node_pcm))){q == ref_focus p _next})
+: SteelT unit
+    ((p `pts_to` mk_node i (one (pcm_uninit (pod_pcm (ref node node_pcm))))) `star` (q `pts_to` next))
+    (fun q -> p `pts_to` mk_node i next)

From 297bab1f604858b42208b51ba20da72238551340 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 14 Jul 2021 16:15:05 -0700
Subject: [PATCH 085/513] add a Makefile

---
 examples/steel/arraystructs/Makefile | 40 ++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 examples/steel/arraystructs/Makefile

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
new file mode 100644
index 00000000000..9e4148c7c12
--- /dev/null
+++ b/examples/steel/arraystructs/Makefile
@@ -0,0 +1,40 @@
+all: world
+
+FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
+FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
+
+INCLUDE_PATH = $(FSTAR_HOME)/ulib/experimental
+
+world: verify
+
+FSTAR_OPTIONS = --cache_checked_modules \
+		--cmi \
+		$(addprefix --include ,$(INCLUDE_PATH)) \
+		$(OTHERFLAGS)
+
+FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
+
+ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
+
+.depend: $(ALL_SOURCE_FILES) Makefile
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) > $@.tmp
+	mv $@.tmp $@
+
+depend: .depend
+
+-include .depend
+
+$(ALL_CHECKED_FILES): %.checked:
+	$(FSTAR) $<
+	@touch -c $@
+
+verify: $(ALL_CHECKED_FILES)
+	echo $*
+
+%.fst-in %.fsti-in:
+	@echo $(FSTAR_OPTIONS)
+
+clean:
+	-rm -rf *.checked *.krml .depend kremlin.rsp *.tmp *.o compile_flags.txt
+
+.PHONY: all world verify clean depend test

From d5723bdb57252ea7dbd70d176831ac8476d70c8e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 14 Jul 2021 17:37:39 -0700
Subject: [PATCH 086/513] exclusive

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 184 +++++++++++++++++++-
 1 file changed, 179 insertions(+), 5 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 7498dcecf71..12bf07c2fcb 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -373,7 +373,7 @@ let field_to_struct
 }
 
 let struct_to_field_f
-  (#a: eqtype)
+  (#a: Type)
   (#b: _)
   (p:(k: a -> pcm (b k)))
   (k: a)
@@ -382,7 +382,7 @@ let struct_to_field_f
 = x k
 
 let struct_to_field
-  (#a: eqtype)
+  (#a: Type)
   (#b: _)
   (p:(k: a -> pcm (b k)))
   (k: a)
@@ -535,7 +535,54 @@ let unaddr_of_struct_field
   struct_unpeel p k x xs;
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   A.return ()
-  
+
+let exclusive_struct_intro
+  (#a: Type)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+: Lemma
+  (requires (
+    forall k . exclusive (p k) (struct_to_field_f p k x)
+  ))
+  (ensures (
+    exclusive (prod_pcm p) x
+  ))
+  [SMTPat (exclusive (prod_pcm p) x)]
+=
+  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
+
+let exclusive_struct_elim
+  (#a: eqtype)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+  (k: a)
+: Lemma
+  (requires (exclusive (prod_pcm p) x))
+  (ensures (exclusive (p k) (struct_to_field_f p k x)))
+=
+  let phi
+    frame
+  : Lemma
+    (requires (composable (p k) (struct_to_field_f p k x) frame))
+    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
+    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
+  = let x' = struct_to_field_f p k x in
+    let f' = field_to_struct_f p k frame in
+    let psi
+      k'
+    : Lemma
+      (composable (p k') (x k') (f' k'))
+      [SMTPat (composable (p k') (x k') (f' k'))]
+    = if k' = k
+      then ()
+      else is_unit (p k') (x k')
+    in
+    ()
+  in
+  ()
+
 (** A PCM for unions TODO move to proper place *)
 
 open FStar.FunctionalExtensionality
@@ -712,7 +759,7 @@ let field_to_union
 }
 
 let union_to_field_f
-  (#a: eqtype)
+  (#a: Type)
   (#b: _)
   (p:(k: a -> pcm (b k)))
   (k: a)
@@ -721,7 +768,7 @@ let union_to_field_f
 = x k
 
 let union_to_field
-  (#a: eqtype)
+  (#a: Type)
   (#b: _)
   (p:(k: a -> pcm (b k)))
   (k: a)
@@ -899,6 +946,48 @@ let unaddr_of_union_field
     (ensures fun _ _ _ -> True)
 = unfocus r' r (union_field p k) x
 
+let exclusive_union_intro
+  (#a: Type)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
+  (ensures (exclusive (union_pcm p) x))
+= let phi
+    (frame: union p)
+  : Lemma
+    (requires (composable (union_pcm p) x frame))
+    (ensures (frame `feq` union_one p))
+    [SMTPat (composable (union_pcm p) x frame)]
+  = ()
+  in
+  ()
+
+let exclusive_union_elim
+  (#a: eqtype)
+  (#b: _)
+  (p: (k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (union_pcm p) x))
+  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
+  then ()
+  else
+    let phi
+      (frame: b k)
+    : Lemma
+      (requires (composable (p k) (x k) frame))
+      (ensures (frame == one (p k)))
+      [SMTPat (composable (p k) (x k) frame)]
+    = let frame' = field_to_union_f p k frame in
+      ()
+    in
+    ()
+
 let base_fpu
   (#a: Type)
   (p: pcm a)
@@ -930,6 +1019,31 @@ let opt_pcm #a : pcm (option a) = {
   refine = (fun x -> Some? x == true);
 }
 
+let exclusive_opt
+  (#a: Type)
+  (x: option a)
+: Lemma
+  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
+=
+  match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      assert (composable opt_pcm x (Some y))
+    end else begin
+      let phi
+        (frame: option a)
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some z -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some _ -> ()
+
 let opt_pcm_fpu
   (#a: Type)
   (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
@@ -1023,6 +1137,40 @@ let frac_pcm_read
   assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
   fst (Some?.v y')
 
+let exclusive_frac
+  (#a: Type)
+  (x: option (a & perm))
+: Lemma
+  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
+= match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      let frame = Some (y, full_perm) in
+      assert (~ (frame == one pcm_frac));
+      assert (composable pcm_frac x frame)
+    end else begin
+      let phi
+        (frame: option (a & perm))
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some (z, _) -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some (y, p) ->
+    assert (exists (z: a) . True);
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
+    then ()
+    else begin
+      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
+      assert (composable pcm_frac x frame);
+      assert (~ (frame == one pcm_frac))
+    end
+
 
 /// Uninitialized
 
@@ -1176,3 +1324,29 @@ let uninit_conn
   conn_small_to_large_inv = ();
   conn_lift_frame_preserving_upd = uninit_conn_fpu p;
 }
+
+let exclusive_uninit
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Lemma
+  (exclusive (pcm_uninit p) x <==> begin match x with
+  | Uninitialized -> True
+  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
+  end)
+= match x with
+  | Uninitialized -> ()
+  | InitOrUnit z ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
+    then begin
+      assert (composable (pcm_uninit p) x Uninitialized)
+    end else
+      let phi2
+        frame
+      : Lemma
+        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
+        (ensures (frame == one p))
+        [SMTPat (composable p z frame)]
+      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
+      in
+      ()

From d084b0bc7925ba05a8c76eb8ce45dc6c96b2f5e5 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 15 Jul 2021 07:36:03 -0700
Subject: [PATCH 087/513] Make some things Steel.C.PCM more universe
 polymorphic

---
 examples/steel/arraystructs/ListNode.fst    | 22 +++++++++----
 examples/steel/arraystructs/Steel.C.PCM.fst | 36 +++++++++++----------
 2 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index f86b54cac8b..8ac44658c27 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -13,9 +13,13 @@ type node_field = | Value | Next
 
 let ref' a b = pb: Ghost.erased (pcm b) & ref a pb
 
-let node_fields node k = match k with
-  | Value -> pod (FStar.Universe.raise_t int)
-  | Next -> pod (option (ref' (FStar.Universe.raise_t node) node))
+//let node_fields node k = match k with
+//  | Value -> pod (FStar.Universe.raise_t int)
+//  | Next -> pod (option (ref' (FStar.Universe.raise_t node) node))
+
+let node_fields (node:Type) k = match k with
+  | Value -> pod (Universe.raise_t int)
+  | Next -> pod (option (ref' node node))
 
 #push-options "--__no_positivity"
 noeq type node =
@@ -24,7 +28,7 @@ noeq type node =
 
 let node_fields_pcm k: pcm (node_fields node k) = match k with
   | Value -> pod_pcm (FStar.Universe.raise_t int)
-  | Next -> pod_pcm (option (ref' (FStar.Universe.raise_t node) node))
+  | Next -> pod_pcm (option (ref' node node))
 
 let node_pcm' = prod_pcm node_fields_pcm
 
@@ -140,14 +144,20 @@ let mk_node' (value: Ghost.erased _) (next: Ghost.erased _): Ghost.erased _ =
 let mk_node (value: Ghost.erased _) (next: Ghost.erased _): Ghost.erased _ =
   Ghost.hide (mk_node' (Ghost.reveal value) (Ghost.reveal next))
 
-assume val _value : connection node_pcm (pod_pcm (FStar.Universe.raise_t int))
+let _value
+: node_pcm `connection` pod_pcm (FStar.Universe.raise_t int)
+= unroll_conn `connection_compose` struct_field node_fields_pcm Value
+
+let _next
+: node_pcm `connection` pod_pcm (option (ref' node node))
+= unroll_conn `connection_compose` struct_field node_fields_pcm Next
 
 let one_next : Ghost.erased (pod (Universe.raise_t int)) =
   Ghost.hide (one (pod_pcm (FStar.Universe.raise_t int)))
 
 let addr_of_next
   (#value:Ghost.erased (pod (Universe.raise_t int)))
-  (#next:Ghost.erased _)
+  (#next:Ghost.erased (pod (option (ref' node node))))
   (p: ref 'a node_pcm)
 : SteelT (q:ref 'a (pod_pcm (FStar.Universe.raise_t int)){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 7498dcecf71..6b85b33178d 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,6 +1,8 @@
 module Steel.C.PCM
 open FStar.PCM
 
+#push-options "--print_universes"
+
 unfold
 let one (#a: Type) (p: pcm a) = p.p.one
 
@@ -82,7 +84,7 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
   end;
 }
 
-noeq type ref a #b (q: pcm b): Type = {
+noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
   p: pcm a;
   pl: connection p q;
   r: Steel.Memory.ref a p;
@@ -341,7 +343,7 @@ let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
 
 let field_to_struct_f
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: b k)
@@ -358,7 +360,7 @@ let is_unit (#a: Type u#a) (p:pcm a)
 
 let field_to_struct
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (p k) (prod_pcm p))
@@ -374,7 +376,7 @@ let field_to_struct
 
 let struct_to_field_f
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: restricted_t a b)
@@ -383,7 +385,7 @@ let struct_to_field_f
 
 let struct_to_field
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (prod_pcm p) (p k))
@@ -395,7 +397,7 @@ let struct_to_field
 
 let struct_field_lift_fpu'
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
@@ -415,7 +417,7 @@ let struct_field_lift_fpu'
 
 let struct_field_lift_fpu_prf
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
@@ -451,7 +453,7 @@ let struct_field_lift_fpu_prf
 
 let struct_field_lift_fpu
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
@@ -464,7 +466,7 @@ let struct_field_lift_fpu
 
 let struct_field
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type u#b)
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (connection (prod_pcm p) (p k))
@@ -686,7 +688,7 @@ let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
 
 let field_to_union_f
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: b k)
@@ -697,7 +699,7 @@ let field_to_union_f
 
 let field_to_union
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (p k) (union_pcm p))
@@ -713,7 +715,7 @@ let field_to_union
 
 let union_to_field_f
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: union p)
@@ -722,7 +724,7 @@ let union_to_field_f
 
 let union_to_field
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (union_pcm p) (p k))
@@ -734,7 +736,7 @@ let union_to_field
 
 let union_field_lift_fpu'
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
@@ -782,7 +784,7 @@ let compatible_elim
 
 let union_field_lift_fpu_prf
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
@@ -818,7 +820,7 @@ let union_field_lift_fpu_prf
 
 let union_field_lift_fpu
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
@@ -831,7 +833,7 @@ let union_field_lift_fpu
 
 let union_field
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (connection (union_pcm p) (p k))

From c8f1f59d2b6d8b3ffd8cce485032d72e29206d84 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 15 Jul 2021 12:12:02 -0700
Subject: [PATCH 088/513] Selectors

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 195 ++++++++++++++++++++
 1 file changed, 195 insertions(+)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 27cf6bbe4b9..2c7cac8bd99 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1352,3 +1352,198 @@ let exclusive_uninit
       = assert (composable (pcm_uninit p) x (InitOrUnit frame))
       in
       ()
+
+let not_one #t (p: pcm t) : Tot Type = (x: t { ~ (x == one p) })
+
+noeq
+type sel_view
+  (#carrier: Type u#a)
+  (p: pcm carrier)
+  (view: Type u#b)
+= {
+  to_view: (not_one p -> GTot view);
+  to_carrier: (view -> GTot (not_one p));
+  to_view_frame:
+    (x: view) ->
+    (frame: carrier) ->
+    Lemma
+    (requires (composable p (to_carrier x) frame))
+    (ensures (to_view (op p (to_carrier x) frame) == x));
+}
+
+let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
+  (forall x . {:pattern (g (f x))} g (f x) == x)
+
+let sel_view_inv
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type u#b)
+  (vw: sel_view p view)
+: Lemma
+  (vw.to_view `g_is_inverse_of` vw.to_carrier)
+  [SMTPat (has_type vw (sel_view p view))]
+= let aux
+    (x: view)
+  : Lemma
+    (vw.to_view (vw.to_carrier x) == x)
+    [SMTPat (vw.to_view (vw.to_carrier x))]
+  = is_unit p (vw.to_carrier x);
+    vw.to_view_frame x (one p)
+  in
+  ()
+
+let pts_to_view_explicit
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+  (v: Ghost.erased c)
+: Tot M.slprop
+= hp_of (pts_to r (vw.to_carrier v))
+
+let pts_to_view_explicit_witinv
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Lemma
+  (M.is_witness_invariant (pts_to_view_explicit r vw))
+= 
+  let aux (x y : Ghost.erased c) (m:M.mem)
+  : Lemma
+    (requires (M.interp (pts_to_view_explicit r vw x) m /\ M.interp (pts_to_view_explicit r vw y) m))
+    (ensures  (x == y))
+  =
+    let x_ = vw.to_carrier x in
+    let y_ = vw.to_carrier y in
+    let x' = r.pl.conn_small_to_large.morph x_ in
+    let y' = r.pl.conn_small_to_large.morph y_ in
+    M.pts_to_join r.r x' y' m;
+    let z' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun z' -> compatible r.p x' z' /\ compatible r.p y' z') in
+    let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_x' -> composable r.p x' frame_x' /\ op r.p frame_x' x' == z') in
+    let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_y' -> composable r.p y' frame_y' /\ op r.p frame_y' y' == z') in
+    let frame_x_ = r.pl.conn_large_to_small.morph frame_x' in
+    let frame_y_ = r.pl.conn_large_to_small.morph frame_y' in
+    r.p.comm x' frame_x';
+    r.pl.conn_large_to_small.morph_compose x' frame_x';
+    vw.to_view_frame x (r.pl.conn_large_to_small.morph frame_x');
+    r.p.comm y' frame_y';
+    r.pl.conn_large_to_small.morph_compose y' frame_y';
+    vw.to_view_frame y (r.pl.conn_large_to_small.morph frame_y');
+    ()
+  in
+  Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
+
+let pts_to_view_sl
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Tot M.slprop
+= M.h_exists (pts_to_view_explicit r vw)
+
+let pts_to_view_sel'
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot (selector' c (pts_to_view_sl r vw))
+= fun h ->
+  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
+  Ghost.reveal (Ghost.reveal x)
+
+let pts_to_view_depends_only_on
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
+
+let pts_to_view_depends_only_on_core
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m0:M.hmem (pts_to_view_sl r vw))
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
+
+let pts_to_view_sel
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot (selector c (pts_to_view_sl r vw))
+= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
+  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
+  pts_to_view_sel' r vw
+
+[@@__steel_reduce__]
+let pts_to_view'
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot vprop'
+= {
+  hp = pts_to_view_sl r vw;
+  t = c;
+  sel = pts_to_view_sel r vw;
+}
+
+[@@__steel_reduce__]
+let pts_to_view 
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot vprop
+= VUnit (pts_to_view' r vw)
+
+let opt_view
+  (a: Type)
+: Tot (sel_view (opt_pcm #a) a)
+= {
+  to_view = Some?.v;
+  to_carrier = (fun z -> Some z);
+  to_view_frame = (fun x frame -> ());
+}
+
+let frac_view
+  (a: Type)
+  (p: perm)
+: Tot (sel_view (pcm_frac #a) a)
+= {
+  to_view = (fun x -> let Some (v, _) = x in v);
+  to_carrier = (fun v -> Some (v, p));
+  to_view_frame = (fun v frame -> ());
+}
+
+let uninit_view
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
+= {
+  to_view = (fun (x: not_one (pcm_uninit p)) -> match x with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit x' -> InitOrUnit (w.to_view x')
+  );
+  to_carrier = (fun v -> match v with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit v' -> InitOrUnit (w.to_carrier v')
+  );
+  to_view_frame = (fun v frame -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  );
+}

From 90eb7b65c3786fe2352e6596e3d399d8c14061a2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 15 Jul 2021 12:36:33 -0700
Subject: [PATCH 089/513] Linked list example

---
 examples/steel/arraystructs/LineStruct.fst  |   3 +-
 examples/steel/arraystructs/ListExample.fst | 146 ++++++++++
 examples/steel/arraystructs/ListNode.fst    | 278 ++++++++++----------
 examples/steel/arraystructs/ListNode.fsti   |  73 +++++
 examples/steel/arraystructs/ListNode.fsti_  |  54 ----
 examples/steel/arraystructs/PointStruct.fst |   4 +-
 examples/steel/arraystructs/Steel.C.PCM.fst |  92 ++++---
 7 files changed, 419 insertions(+), 231 deletions(-)
 create mode 100644 examples/steel/arraystructs/ListExample.fst
 create mode 100644 examples/steel/arraystructs/ListNode.fsti
 delete mode 100644 examples/steel/arraystructs/ListNode.fsti_

diff --git a/examples/steel/arraystructs/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
index 19184a5fa17..d24adcc3a64 100644
--- a/examples/steel/arraystructs/LineStruct.fst
+++ b/examples/steel/arraystructs/LineStruct.fst
@@ -28,7 +28,8 @@ let line_pcm = prod_pcm line_fields_pcm
 let mk_line_f (p1 p2: point) (k: line_field): line_fields k = match k with
   | P1 -> p1
   | P2 -> p2
-let mk_line p1 p2 = on_domain line_field (mk_line_f (Ghost.reveal p1) (Ghost.reveal p2))
+let mk_line p1 p2 =
+  Ghost.hide (on_domain line_field (mk_line_f (Ghost.reveal p1) (Ghost.reveal p2)))
 
 let _p1 = struct_field line_fields_pcm P1
 let _p2 = struct_field line_fields_pcm P2
diff --git a/examples/steel/arraystructs/ListExample.fst b/examples/steel/arraystructs/ListExample.fst
new file mode 100644
index 00000000000..60bea150901
--- /dev/null
+++ b/examples/steel/arraystructs/ListExample.fst
@@ -0,0 +1,146 @@
+module ListExample
+
+open Steel.C.PCM
+
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+open FStar.PCM.POD
+open ListNode
+
+/// void mk_figure_eight(struct node *p, struct node *q) {
+///   p->next = q;
+///   q->next = p;
+/// }
+
+let ptr (p: ref node node_pcm)
+: Ghost.erased (option (ref' node node))
+= Ghost.hide (Some (|Ghost.hide node_pcm, p|))
+
+let ptr' (p: ref node node_pcm)
+: option (ref' node node)
+= Some (|Ghost.hide node_pcm, p|)
+
+let nullptr: Ghost.erased (option (ref' node node)) = Ghost.hide None
+
+val mk_figure_eight_step_one
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (i j: Ghost.erased int')
+: SteelT (r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next})
+    (p `pts_to` mk_node (some i) (some nullptr))
+    (fun r ->
+      (p `pts_to` mk_node (some i) none) `star`
+      (r `pts_to` some nullptr))
+
+let mk_figure_eight_step_one p q i j =
+  addr_of_next #node #(some i) #(some nullptr) p
+
+val mk_figure_eight_step_two
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (i j: Ghost.erased int')
+: SteelT (r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next})
+    (q `pts_to` mk_node (some j) (some nullptr))
+    (fun r ->
+      (q `pts_to` mk_node (some j) none) `star`
+      (r `pts_to` some nullptr))
+
+let mk_figure_eight_step_two p q i j =
+  addr_of_next #node #(some j) #(some nullptr) q
+
+val mk_figure_eight_step_three
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (i j: Ghost.erased int')
+: SteelT unit
+    (p_next `pts_to` some nullptr)
+    (fun _ -> p_next `pts_to` some (ptr q))
+
+let mk_figure_eight_step_three p q p_next q_next i j =
+  pod_write p_next (ptr' q)
+
+val mk_figure_eight_step_four
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (i j: Ghost.erased int')
+: SteelT unit
+    (q_next `pts_to` some nullptr)
+    (fun _ -> q_next `pts_to` some (ptr p))
+
+let mk_figure_eight_step_four p q p_next q_next i j =
+  pod_write q_next (ptr' p)
+
+val mk_figure_eight_step_five
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (i j: Ghost.erased int')
+: SteelT unit
+    ((p `pts_to` mk_node (some i) none) `star`
+     (p_next `pts_to` some (ptr q)))
+    (fun _ -> p `pts_to` mk_node (some i) (some (ptr q)))
+
+let mk_figure_eight_step_five p q p_next q_next i j =
+  unaddr_of_next p p_next
+
+val mk_figure_eight_step_six
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (i j: Ghost.erased int')
+: SteelT unit
+    ((q `pts_to` mk_node (some j) none) `star`
+     (q_next `pts_to` some (ptr p)))
+    (fun _ -> q `pts_to` mk_node (some j) (some (ptr p)))
+
+let mk_figure_eight_step_six p q p_next q_next i j =
+  unaddr_of_next q q_next
+
+val mk_figure_eight_verbose
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (i j: Ghost.erased int')
+: SteelT unit
+    ((p `pts_to` mk_node (some i) (some nullptr)) `star`
+     (q `pts_to` mk_node (some j) (some nullptr)))
+    (fun _ ->
+      (p `pts_to` mk_node (some i) (some (ptr q))) `star`
+      (q `pts_to` mk_node (some j) (some (ptr p))))
+
+let mk_figure_eight_verbose p q i j =
+  let p_next = mk_figure_eight_step_one p q i j in
+  let q_next = mk_figure_eight_step_two p q i j in
+  mk_figure_eight_step_three p q p_next q_next i j;
+  mk_figure_eight_step_four p q p_next q_next i j;
+  mk_figure_eight_step_five p q p_next q_next i j;
+  mk_figure_eight_step_six p q p_next q_next i j;
+  A.return ()
+
+val mk_figure_eight
+  (p: ref node node_pcm)
+  (q: ref node node_pcm)
+  (i j: Ghost.erased int')
+: SteelT unit
+    ((p `pts_to` mk_node (some i) (some nullptr)) `star`
+     (q `pts_to` mk_node (some j) (some nullptr)))
+    (fun _ ->
+      (p `pts_to` mk_node (some i) (some (ptr q))) `star`
+      (q `pts_to` mk_node (some j) (some (ptr p))))
+
+#push-options "--query_stats --profile ListExample --profile_component FStar"
+
+let mk_figure_eight p q i j =
+  let p_next = addr_of_next p in
+  let q_next = addr_of_next q in
+  p_next `pod_write` ptr' q;
+  q_next `pod_write` ptr' p;
+  unaddr_of_next p p_next;
+  unaddr_of_next q q_next;
+  A.return ()
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 8ac44658c27..6f0b963cbc7 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -8,44 +8,39 @@ open Steel.Effect
 open FStar.PCM
 open FStar.PCM.POD
 open Steel.C.PCM
+module U = FStar.Universe
 
 type node_field = | Value | Next
 
-let ref' a b = pb: Ghost.erased (pcm b) & ref a pb
-
-//let node_fields node k = match k with
-//  | Value -> pod (FStar.Universe.raise_t int)
-//  | Next -> pod (option (ref' (FStar.Universe.raise_t node) node))
-
-let node_fields (node:Type) k = match k with
-  | Value -> pod (Universe.raise_t int)
+let node_fields (node:Type u#1) k : Type u#1 = match k with
+  | Value -> pod int'
   | Next -> pod (option (ref' node node))
 
 #push-options "--__no_positivity"
-noeq type node =
+noeq type node: Type u#1 =
 { un_node: restricted_t node_field (node_fields node) }
 #pop-options
 
+let node': Type u#1 = restricted_t node_field (node_fields node)
+
 let node_fields_pcm k: pcm (node_fields node k) = match k with
-  | Value -> pod_pcm (FStar.Universe.raise_t int)
+  | Value -> pod_pcm int'
   | Next -> pod_pcm (option (ref' node node))
 
-let node_pcm' = prod_pcm node_fields_pcm
-
-let node_pcm: pcm node =
-  let p: FStar.PCM.pcm node = {
-    FStar.PCM.p = {
-      composable = (fun x y -> composable node_pcm' x.un_node y.un_node);
-      op = (fun x y -> Mknode (op node_pcm' x.un_node y.un_node));
-      one = Mknode (one node_pcm');
-    };
-    comm = (fun x y -> node_pcm'.comm x.un_node y.un_node);
-    assoc = (fun x y z -> node_pcm'.assoc x.un_node y.un_node z.un_node);
-    assoc_r = (fun x y z -> node_pcm'.assoc_r x.un_node y.un_node z.un_node);
-    is_unit = (fun x -> node_pcm'.is_unit x.un_node);
-    refine = (fun x -> node_pcm'.refine x.un_node);
-  } in
-  p
+let node_pcm': pcm node' = prod_pcm node_fields_pcm
+
+let node_pcm: pcm node = {
+  FStar.PCM.p = {
+    composable = (fun x y -> composable node_pcm' x.un_node y.un_node);
+    op = (fun x y -> Mknode (op node_pcm' x.un_node y.un_node));
+    one = Mknode (one node_pcm');
+  };
+  comm = (fun x y -> node_pcm'.comm x.un_node y.un_node);
+  assoc = (fun x y z -> node_pcm'.assoc x.un_node y.un_node z.un_node);
+  assoc_r = (fun x y z -> node_pcm'.assoc_r x.un_node y.un_node z.un_node);
+  is_unit = (fun x -> node_pcm'.is_unit x.un_node);
+  refine = (fun x -> node_pcm'.refine x.un_node);
+}
 
 let roll: node_pcm' `morphism` node_pcm = {
   morph = Mknode;
@@ -67,21 +62,7 @@ let roll_compatible x v
     (requires compatible node_pcm' x v)
     (ensures compatible node_pcm (Mknode x) (Mknode v))
     [SMTPat (compatible node_pcm' x v)]
-= let frame = compatible_elim node_pcm' x v in
-  compatible_intro node_pcm (Mknode x) (Mknode v) (Mknode frame)
-
-val compatible_morphism
-  (#p: pcm 'a) (#q: pcm 'b)
-  (f: p `morphism` q)
-  (x y: Ghost.erased 'a)
-: Lemma
-    (requires compatible p x y)
-    (ensures compatible q (f.morph x) (f.morph y))
-
-let compatible_morphism #a #b #p #q f x y =
-  let frame_x = compatible_elim p x y in
-  let _ = f.morph_compose frame_x x in
-  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
+= compatible_morphism roll x v
 
 let unroll_compatible x v
 : Lemma
@@ -136,115 +117,140 @@ let unroll_conn: node_pcm `connection` node_pcm' = {
   conn_lift_frame_preserving_upd = unroll_conn_lift_fpu;
 }
 
-let mk_node' (value: Ghost.erased _) (next: Ghost.erased _): Ghost.erased _ =
-  Ghost.hide (fun k -> match k with
+let mk_node'_f (value: pod int') (next: pod (option (ref' node node)))
+  (k: node_field)
+: node_fields node k
+= match k with
   | Value -> value
-  | Next -> next)
+  | Next -> next
+  
+let mk_node'
+  (value: Ghost.erased (pod int'))
+  (next: Ghost.erased (pod (option (ref' node node))))
+: Ghost.erased node'
+= Ghost.hide (on_domain node_field (mk_node'_f (Ghost.reveal value) (Ghost.reveal next)))
 
-let mk_node (value: Ghost.erased _) (next: Ghost.erased _): Ghost.erased _ =
-  Ghost.hide (mk_node' (Ghost.reveal value) (Ghost.reveal next))
+let mk_node value next = Ghost.hide (Mknode (mk_node' (Ghost.reveal value) (Ghost.reveal next)))
 
 let _value
-: node_pcm `connection` pod_pcm (FStar.Universe.raise_t int)
+: node_pcm `connection` pod_pcm int'
 = unroll_conn `connection_compose` struct_field node_fields_pcm Value
 
 let _next
 : node_pcm `connection` pod_pcm (option (ref' node node))
 = unroll_conn `connection_compose` struct_field node_fields_pcm Next
 
-let one_next : Ghost.erased (pod (Universe.raise_t int)) =
-  Ghost.hide (one (pod_pcm (FStar.Universe.raise_t int)))
+let one_next : Ghost.erased (pod int') =
+  Ghost.hide (one (pod_pcm int'))
 
-let addr_of_next
-  (#value:Ghost.erased (pod (Universe.raise_t int)))
+let node'_without_value value next
+: Lemma (struct_without_field node_fields_pcm Value (mk_node' value next) `feq`
+         Ghost.reveal (mk_node' none next))
+  [SMTPat (mk_node' value next)]
+= ()
+
+let node'_with_value value next
+: Lemma (struct_with_field node_fields_pcm Value (Ghost.reveal value) (mk_node' none next) `feq`
+         Ghost.reveal (mk_node' value next))
+  [SMTPat (mk_node' value next)]
+= ()
+
+let node'_without_next value next
+: Lemma (struct_without_field node_fields_pcm Next (mk_node' value next) `feq`
+         Ghost.reveal (mk_node' value none))
+  [SMTPat (mk_node' value next)]
+= ()
+
+let node'_with_next value next
+: Lemma (struct_with_field node_fields_pcm Next (Ghost.reveal next) (mk_node' value none) `feq`
+         Ghost.reveal (mk_node' value next))
+  [SMTPat (mk_node' value next)]
+= ()
+
+let mk_node_mk_node' value next
+: Lemma (
+    Ghost.reveal (mk_node value next) ==
+    unroll_conn.conn_small_to_large.morph (mk_node' value next))
+= ()
+
+let unroll_ref 
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (p':ref 'a node_pcm'{p' == ref_focus p unroll_conn})
+    (p `pts_to` mk_node value next)
+    (fun p' -> p' `pts_to` mk_node' value next)
+= let p' = focus p unroll_conn (mk_node value next) (mk_node' value next) in
+  A.return p'
+
+let roll_ref 
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm) (p': ref 'a node_pcm')
+: Steel unit
+    (p' `pts_to` mk_node' value next)
+    (fun _ -> p `pts_to` mk_node value next)
+    (requires fun _ -> p' == ref_focus p unroll_conn)
+    (ensures fun _ _ _ -> True)
+= unfocus p' p unroll_conn (mk_node' value next);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_value
+  (#value:Ghost.erased (pod int'))
   (#next:Ghost.erased (pod (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm (FStar.Universe.raise_t int)){q == ref_focus p _value})
+: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
-       (p `pts_to` mk_node one_next next) `star`
+       (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
-= A.sladmit(); A.return (admit())
-
-//let node_pcm: pcm (restricted_t 
-//node --> prod_pcm node_pcm_fields
-
-// #push-options "--print_universes"
-// 
-// let x = 3
-// 
-// #pop-options
-// 
-// type node = {
-// }
-// 
-// let node_fields k: Type = match k with
-//   | I -> pod int
-//   | Next -> uninit_t (pod rec_arg)
-//   
-// let node (rec_arg:Type): Type = restricted_t node_field (node_fields rec_arg)
-// 
-// /// PCM for node:
-// 
-// let node_fields_pcm k : pcm (node_fields k) = match k with
-//   | P1 -> point_pcm
-//   | P2 -> point_pcm
-// let node_pcm = prod_pcm node_fields_pcm
-// 
-// /// (mk_node p1 p2) represents (struct node){.p1 = p1, .p2 = p2}
-// 
-// let mk_node_f (p1 p2: point) (k: node_field): node_fields k = match k with
-//   | P1 -> p1
-//   | P2 -> p2
-// let mk_node p1 p2 = on_domain node_field (mk_node_f (Ghost.reveal p1) (Ghost.reveal p2))
-// 
-// let _p1 = struct_field node_fields_pcm P1
-// let _p2 = struct_field node_fields_pcm P2
-// 
-// /// Taking pointers to the p1 and p2 fields of a node
-// 
-// let node_without_p1 p1 p2
-// : Lemma (struct_without_field node_fields_pcm P1 (mk_node p1 p2) `feq`
-//          Ghost.reveal (mk_node (one point_pcm) p2))
-//   [SMTPat (mk_node p1 p2)]
-// = ()
-// 
-// let node_with_p1 p1 p2
-// : Lemma (struct_with_field node_fields_pcm P1 (Ghost.reveal p1) (mk_node (one point_pcm) p2) `feq`
-//          Ghost.reveal (mk_node p1 p2))
-//   [SMTPat (mk_node p1 p2)]
-// = ()
-// 
-// let node_without_p2 p1 p2
-// : Lemma (struct_without_field node_fields_pcm P2 (mk_node p1 p2) `feq`
-//          Ghost.reveal (mk_node p1 (one point_pcm)))
-//   [SMTPat (mk_node p1 p2)]
-// = ()
-// 
-// let node_with_p2 p1 p2
-// : Lemma (struct_with_field node_fields_pcm P2 (Ghost.reveal p2) (mk_node p1 (one point_pcm)) `feq`
-//          Ghost.reveal (mk_node p1 p2))
-//   [SMTPat (mk_node p1 p2)]
-// = ()
-// 
-// let addr_of_p1 #a #p1 #p2 p =
-//   let q = addr_of_struct_field p P1 (mk_node p1 p2) in
-//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_node (one point_pcm) p2);
-//   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
-//   A.return q
-// 
-// let unaddr_of_p1 #a #p1 #p2 p q =
-//   unaddr_of_struct_field P1 q p (mk_node (one point_pcm) p2) p1;
-//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-// 
-// let addr_of_p2 #a #p1 #p2 p =
-//   let q = addr_of_struct_field p P2 (mk_node p1 p2) in
-//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_node p1 (one point_pcm));
-//   A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
-//   A.return q
-// 
-// let unaddr_of_p2 #a #p1 #p2 p q =
-//   unaddr_of_struct_field P2 q p (mk_node p1 (one point_pcm)) p2;
-//   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+= let p' = unroll_ref p in
+  let q = addr_of_struct_field p' Value (mk_node' value next) in
+  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' none next);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` value);
+  roll_ref p p';
+  A.return q
 
-#pop-options
+let unaddr_of_value
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+  (q: ref 'a (pod_pcm int'){q == ref_focus p _value})
+: SteelT unit
+    ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
+    (fun _ -> p `pts_to` mk_node value next)
+= let p' = unroll_ref p in
+  let q = unaddr_of_struct_field Value q p' (mk_node' none next) value in
+  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
+  roll_ref p p';
+  A.return ()
+
+let addr_of_next
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node value none) `star`
+       (q `pts_to` next))
+= let p' = unroll_ref p in
+  let q = addr_of_struct_field p' Next (mk_node' value next) in
+  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value none);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` next);
+  roll_ref p p';
+  A.return q
+
+let unaddr_of_next
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+  (q: ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+: SteelT unit
+    ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
+    (fun q -> p `pts_to` mk_node value next)
+= let p' = unroll_ref p in
+  let q = unaddr_of_struct_field Next q p' (mk_node' value none) next in
+  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
+  roll_ref p p';
+  A.return ()
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
new file mode 100644
index 00000000000..e6a98081453
--- /dev/null
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -0,0 +1,73 @@
+module ListNode
+
+open FStar.PCM.POD
+open FStar.PCM
+open Steel.Effect
+open PointStruct
+open Steel.C.PCM
+module U = FStar.Universe
+
+let ref'_f a b (pb: Ghost.erased (pcm b)) = ref a (Ghost.reveal pb)
+let ref' a b = dtuple2 (Ghost.erased (pcm b)) (ref'_f a b)
+
+let int': Type u#1 = U.raise_t int
+
+/// struct node { int value; struct node *next; };
+
+val node: Type u#1
+
+/// PCM for node:
+
+val node_pcm: pcm node
+
+/// (mk_node value next) represents (struct node){.value = value, .next = next}
+
+val mk_node
+  (i: Ghost.erased (pod int'))
+  (next: Ghost.erased (pod (option (ref' node node))))
+: Ghost.erased node
+
+/// Lenses for fields
+
+val _value: node_pcm `connection` pod_pcm int'
+val _next: node_pcm `connection` pod_pcm (option (ref' node node))
+
+/// Taking pointers to the fields of a node
+
+val addr_of_value
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node none next) `star`
+       (q `pts_to` value))
+
+val unaddr_of_value
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+  (q: ref 'a (pod_pcm int'){q == ref_focus p _value})
+: SteelT unit
+    ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
+    (fun q -> p `pts_to` mk_node value next)
+
+val addr_of_next
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node value none) `star`
+       (q `pts_to` next))
+
+val unaddr_of_next
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+  (q: ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+: SteelT unit
+    ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
+    (fun q -> p `pts_to` mk_node value next)
diff --git a/examples/steel/arraystructs/ListNode.fsti_ b/examples/steel/arraystructs/ListNode.fsti_
deleted file mode 100644
index b9c1e94b0da..00000000000
--- a/examples/steel/arraystructs/ListNode.fsti_
+++ /dev/null
@@ -1,54 +0,0 @@
-module ListNode
-
-open FStar.PCM.POD
-open FStar.PCM
-open Steel.Effect
-open PointStruct
-open Steel.C.PCM
-
-/// struct node { int i; struct node *next; };
-
-val node : Type u#1
-
-/// PCM for node:
-
-val node_pcm : pcm node
-
-/// (mk_node i next) represents (struct node){.i = i, .next = next}
-
-val mk_node (i: Ghost.erased (pod int)) (next: Ghost.erased (uninit_t (pod (ref node node_pcm)))): Ghost.erased node
-
-/// Lenses for fields
-
-val _i : connection node_pcm (pod_pcm int)
-val _next : connection node_pcm (pcm_uninit (pod_pcm (ref node node_pcm)))
-
-/// Taking pointers to the fields of a node
-
-val addr_of_p1 (#i:_) (#next:_) (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
-    (p `pts_to` mk_node i next)
-    (fun q ->
-       (p `pts_to` mk_node (one (pod_pcm int)) next) `star`
-       (q `pts_to` i))
-
-val unaddr_of_p1 (#i:_) (#next:_)
-  (p: ref 'a node_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p _i})
-: SteelT unit
-    ((p `pts_to` mk_node (one (pod_pcm int)) next) `star` (q `pts_to` i))
-    (fun q -> p `pts_to` mk_node i next)
-
-val addr_of_p2 (#i:_) (#next:_) (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pcm_uninit (pod_pcm (ref node node_pcm))){q == ref_focus p _next})
-    (p `pts_to` mk_node i next)
-    (fun q ->
-       (p `pts_to` mk_node i (one (pcm_uninit (pod_pcm (ref node node_pcm))))) `star`
-       (q `pts_to` next))
-
-val unaddr_of_p2 (#i:_) (#next:_)
-  (p: ref 'a node_pcm)
-  (q: ref 'a (pcm_uninit (pod_pcm (ref node node_pcm))){q == ref_focus p _next})
-: SteelT unit
-    ((p `pts_to` mk_node i (one (pcm_uninit (pod_pcm (ref node node_pcm))))) `star` (q `pts_to` next))
-    (fun q -> p `pts_to` mk_node i next)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index fb145e5de56..aabc1fd7d8f 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -21,8 +21,8 @@ let mk_point_f (x y: pod int) (k: point_field): point_fields k = match k with
   | X -> x
   | Y -> y
   
-let mk_point (x y: Ghost.erased (pod int)): GTot point =
-  on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y))
+let mk_point (x y: Ghost.erased (pod int)): Ghost.erased point =
+  Ghost.hide (on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y)))
 
 let _x = struct_field point_fields_pcm X
 let _y = struct_field point_fields_pcm Y
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 27cf6bbe4b9..be9d2f75964 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -44,6 +44,44 @@ let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fa
     fbc.morph_compose (fab.morph x1) (fab.morph x2)
   end;
 }
+let compatible_intro
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+  (frame: a)
+: Lemma
+  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (ensures (compatible pcm x y))
+= ()
+
+let compatible_elim
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+: Ghost a
+  (requires (compatible pcm x y))
+  (ensures (fun frame ->
+    composable pcm x frame /\
+    op pcm frame x == y
+  ))
+= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
+    composable pcm x frame /\
+    op pcm frame x == y
+  )
+
+val compatible_morphism
+  (#p: pcm 'a) (#q: pcm 'b)
+  (f: p `morphism` q)
+  (x y: Ghost.erased 'a)
+: Lemma
+    (requires compatible p x y)
+    (ensures compatible q (f.morph x) (f.morph y))
+
+let compatible_morphism #a #b #p #q f x y =
+  let frame_x = compatible_elim p x y in
+  f.morph_compose frame_x x;
+  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
+
 
 let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
   (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
@@ -94,11 +132,6 @@ let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to
 
 open Steel.Effect
 
-//val pts_to
-//  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-//  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
-//: vprop
-
 val pts_to
   (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
   (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
@@ -115,6 +148,14 @@ val ref_focus
 let ref_focus #a #b #c #p r #q l =
   {p = r.p; pl = connection_compose r.pl l; r = r.r}
 
+let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
+: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
+  [SMTPatOr [
+    [SMTPat (ref_focus (ref_focus r l) m)]; 
+    [SMTPat (ref_focus r (l `connection_compose` m))]]]
+= assume ((r.pl `connection_compose` l) `connection_compose` m ==
+          r.pl `connection_compose` (l `connection_compose` m))
+
 module A = Steel.Effect.Atomic
 
 let focus (r: ref 'a 'p)
@@ -477,12 +518,12 @@ let struct_field
   conn_lift_frame_preserving_upd = struct_field_lift_fpu p k;
 }
 
-let struct_without_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   (xs: restricted_t a b)
 : restricted_t a b
 = on_dom a (fun k' -> if k' = k then one (p k) else xs k')
 
-let struct_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   (xs: restricted_t a b)
 : Lemma (
     composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
@@ -492,7 +533,7 @@ let struct_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
   
 let addr_of_struct_field
-  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
   (r: ref base (prod_pcm p)) (k:a)
   (xs: Ghost.erased (restricted_t a b))
 : Steel (ref base (p k))
@@ -507,12 +548,12 @@ let addr_of_struct_field
   let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
   A.return r
 
-let struct_with_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   (x:b k) (xs: restricted_t a b)
 : restricted_t a b
 = on_dom a (fun k' -> if k' = k then x else xs k')
 
-let struct_unpeel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   (x: b k) (xs: restricted_t a b)
 : Lemma
     (requires xs k == one (p k))
@@ -524,7 +565,7 @@ let struct_unpeel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
 let unaddr_of_struct_field
-  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
   (r': ref base (p k)) (r: ref base (prod_pcm p))
   (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
 : Steel unit
@@ -540,7 +581,7 @@ let unaddr_of_struct_field
 
 let exclusive_struct_intro
   (#a: Type)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (x: restricted_t a b)
 : Lemma
@@ -556,7 +597,7 @@ let exclusive_struct_intro
 
 let exclusive_struct_elim
   (#a: eqtype)
-  (#b: _)
+  (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
   (x: restricted_t a b)
   (k: a)
@@ -801,31 +842,6 @@ let union_field_lift_fpu'
       else one (p k')
     )
 
-let compatible_intro
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-  (frame: a)
-: Lemma
-  (requires (composable pcm x frame /\ op pcm frame x == y))
-  (ensures (compatible pcm x y))
-= ()
-
-let compatible_elim
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-: Ghost a
-  (requires (compatible pcm x y))
-  (ensures (fun frame ->
-    composable pcm x frame /\
-    op pcm frame x == y
-  ))
-= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
-    composable pcm x frame /\
-    op pcm frame x == y
-  )
-
 #restart-solver
 #push-options "--z3rlimit 32 --query_stats"
 

From 543fe95e4857d7b6a08edcaf607bd14b8102fd44 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 15 Jul 2021 13:00:28 -0700
Subject: [PATCH 090/513] Partial views for selectors

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 57 +++++++++++++++++----
 1 file changed, 48 insertions(+), 9 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 2c7cac8bd99..4567f8470d9 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1353,7 +1353,8 @@ let exclusive_uninit
       in
       ()
 
-let not_one #t (p: pcm t) : Tot Type = (x: t { ~ (x == one p) })
+let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
+  (x: a { p x })
 
 noeq
 type sel_view
@@ -1361,14 +1362,19 @@ type sel_view
   (p: pcm carrier)
   (view: Type u#b)
 = {
-  to_view: (not_one p -> GTot view);
-  to_carrier: (view -> GTot (not_one p));
+  to_view_prop: (carrier -> Tot prop);
+  to_view: (refine carrier to_view_prop -> GTot view);
+  to_carrier: (view -> GTot (refine carrier to_view_prop));
+  to_carrier_not_one:
+    (x: view) ->
+    Lemma
+    (~ (to_carrier x == one p));
   to_view_frame:
     (x: view) ->
     (frame: carrier) ->
     Lemma
     (requires (composable p (to_carrier x) frame))
-    (ensures (to_view (op p (to_carrier x) frame) == x));
+    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
 }
 
 let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
@@ -1512,8 +1518,10 @@ let opt_view
   (a: Type)
 : Tot (sel_view (opt_pcm #a) a)
 = {
-  to_view = Some?.v;
-  to_carrier = (fun z -> Some z);
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> Some?.v x);
+  to_carrier = (fun z  -> Some z);
+  to_carrier_not_one = (fun _ -> ());
   to_view_frame = (fun x frame -> ());
 }
 
@@ -1522,8 +1530,10 @@ let frac_view
   (p: perm)
 : Tot (sel_view (pcm_frac #a) a)
 = {
+  to_view_prop = (fun x -> Some? x == true);
   to_view = (fun x -> let Some (v, _) = x in v);
   to_carrier = (fun v -> Some (v, p));
+  to_carrier_not_one = (fun _ -> ());
   to_view_frame = (fun v frame -> ());
 }
 
@@ -1534,16 +1544,45 @@ let uninit_view
   (w: sel_view p b)
 : Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
 = {
-  to_view = (fun (x: not_one (pcm_uninit p)) -> match x with
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> True
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
   | Uninitialized -> Uninitialized
   | InitOrUnit x' -> InitOrUnit (w.to_view x')
   );
   to_carrier = (fun v -> match v with
   | Uninitialized -> Uninitialized
-  | InitOrUnit v' -> InitOrUnit (w.to_carrier v')
+  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
+  );
+  to_carrier_not_one = (fun v -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'
   );
   to_view_frame = (fun v frame -> match v with
   | Uninitialized -> ()
-  | InitOrUnit v' -> let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  );
+}
+
+let uninit_view_initialized
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> False
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | InitOrUnit x' -> w.to_view x'
+  );
+  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
+  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
+  to_view_frame = (fun v frame ->
+    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
   );
 }

From c42814e8476956ba5a0d22add834e1e9a58c294f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 15 Jul 2021 13:41:50 -0700
Subject: [PATCH 091/513] pts_to_view_intro/elim

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 109 ++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 4567f8470d9..24e3ed19482 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1514,6 +1514,115 @@ let pts_to_view
 : Tot vprop
 = VUnit (pts_to_view' r vw)
 
+let pts_to_view_intro_lemma
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
+  (ensures (
+    M.interp (pts_to_view_sl r vw) m /\
+    pts_to_view_sel r vw m == Ghost.reveal y
+  )) 
+=
+  M.intro_h_exists y (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+let pts_to_view_intro
+  (#invs: _)
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+: A.SteelGhost unit invs
+    (pts_to r x)
+    (fun _ -> pts_to_view r vw)
+    (fun _ -> vw.to_carrier y == Ghost.reveal x)
+    (fun _ _ h' ->
+      h' (pts_to_view r vw) == Ghost.reveal y
+    )
+= A.change_slprop_2
+    (pts_to r x)
+    (pts_to_view r vw)
+    y
+    (fun m ->
+      pts_to_view_intro_lemma r x vw y m
+    )
+
+let pts_to_view_elim_lemma
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (pts_to_view_sl r vw) m))
+  (ensures (
+    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
+  ))
+=
+  M.elim_h_exists (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+/// Introducing a dependent star for [v] and [q]
+let intro_vdep2 (#opened:_)
+  (v: vprop)
+  (q: vprop)
+  (p: (t_of v -> Tot vprop))
+  (x: t_of v)
+: A.SteelGhost unit opened
+    (v `star` q)
+    (fun _ -> vdep v p)
+    (requires (fun h -> h v == x /\ q == p x))
+    (ensures (fun h _ h' ->
+      let x2 = h' (vdep v p) in
+      q == p (h v) /\
+      dfst x2 == (h v) /\
+      dsnd x2 == (h q)
+    ))
+=
+  A.intro_vdep v q p
+
+let pts_to_view_elim
+  (#invs: _)
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: A.SteelGhost (Ghost.erased b) invs
+    (pts_to_view r vw)
+    (fun res -> pts_to r res)
+    (fun _ -> True)
+    (fun h res _ ->
+      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw))
+    )
+=
+  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
+  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
+  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
+  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
+  intro_vdep2
+    (pts_to_view r vw)
+    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
+    f
+    (Ghost.reveal g);
+  A.rewrite_slprop
+    (vdep (pts_to_view r vw) f)
+    (pts_to r res)
+    (fun m ->
+      interp_vdep_hp (pts_to_view r vw) f m;
+      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
+      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
+      pts_to_view_elim_lemma r vw m
+    );
+  res
+
 let opt_view
   (a: Type)
 : Tot (sel_view (opt_pcm #a) a)

From 50055299270f4419477294ee47c8be4e769bb45f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 15 Jul 2021 14:18:59 -0700
Subject: [PATCH 092/513] Try store morphism laws in refinement

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 322 +++++++++-----------
 1 file changed, 144 insertions(+), 178 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index e9e601af2e2..cc57791d576 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,5 +1,6 @@
 module Steel.C.PCM
 open FStar.PCM
+open FStar.FunctionalExtensionality
 
 #push-options "--print_universes"
 
@@ -14,36 +15,25 @@ let pcm (a: Type) : Tot Type =
     //(~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
   })
 
-noeq
-type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
-  morph: (a -> Tot b);
-  morph_unit: squash (morph pa.p.one == pb.p.one);
-  morph_compose:
-    (x1: a) ->
-    (x2: a) ->
-    Lemma
-    (requires (composable pa x1 x2))
-    (ensures (composable pb (morph x1) (morph x2) /\ morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2));
-}
+let morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) =
+  f:(a ^-> b){
+    f pa.p.one == pb.p.one /\
+    (forall (x1: a) (x2: a{composable pa x1 x2}).
+    composable pb (f x1) (f x2) /\
+    f (x1 `pa.p.op` x2) == f x1 `pb.p.op` f x2)}
+
+let morphism_intro (#pa: pcm 'a) (#pb: pcm 'b) (f: 'a -> 'b)
+  (f_unit: squash (f pa.p.one == pb.p.one))
+  (f_compose: (x1:'a -> x2:'a{composable pa x1 x2} ->
+    Lemma (
+      composable pb (f x1) (f x2) /\
+      f (x1 `pa.p.op` x2) == f x1 `pb.p.op` f x2)))
+: pa `morphism` pb
+= Classical.forall_intro_2 f_compose; on_dom _ f
+
+let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc)
+= on_dom _ (fun x -> fbc (fab x))
 
-let morphism_morph_compose
-  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
-  (x1: a)
-  (x2: a)
-: Lemma
-  (requires (composable pa x1 x2))
-  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
-  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
-= m.morph_compose x1 x2
-
-let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) = {
-  morph = (fun x -> fbc.morph (fab.morph x));
-  morph_unit = ();
-  morph_compose = begin fun x1 x2 ->
-    fab.morph_compose x1 x2;
-    fbc.morph_compose (fab.morph x1) (fab.morph x2)
-  end;
-}
 let compatible_intro
   (#a: Type u#a)
   (pcm: pcm a)
@@ -75,13 +65,12 @@ val compatible_morphism
   (x y: Ghost.erased 'a)
 : Lemma
     (requires compatible p x y)
-    (ensures compatible q (f.morph x) (f.morph y))
+    (ensures compatible q (f x) (f y))
 
 let compatible_morphism #a #b #p #q f x y =
   let frame_x = compatible_elim p x y in
-  f.morph_compose frame_x x;
-  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
-
+  assert (composable p frame_x x);
+  compatible_intro q (f x) (f y) (f frame_x)
 
 let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
   (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
@@ -101,12 +90,12 @@ noeq
 type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
   conn_small_to_large: morphism p_small p_large;
   conn_large_to_small: morphism p_large p_small;
-  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
+  conn_small_to_large_inv: squash (conn_large_to_small `is_inverse_of` conn_small_to_large);
   conn_lift_frame_preserving_upd:
     (x: Ghost.erased t_small { ~ (Ghost.reveal x == p_small.p.one) }) -> // validity condition, e.g. union cases
     (y: Ghost.erased t_small) ->
     (f: frame_preserving_upd p_small x y) ->
-    Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y));
+    Tot (frame_preserving_upd p_large (conn_small_to_large x) (conn_small_to_large y));
 }
 
 let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) = {
@@ -114,10 +103,10 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
   conn_large_to_small = fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small;
   conn_small_to_large_inv = ();
   conn_lift_frame_preserving_upd = begin fun xc yc f ->
-    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
-    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
-    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
-    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
+    let xb = Ghost.hide (fbc.conn_small_to_large xc) in
+    let yb = Ghost.hide (fbc.conn_small_to_large yc) in
+    let xa = Ghost.hide (fab.conn_small_to_large xb) in
+    let ya = Ghost.hide (fab.conn_small_to_large yb) in
     fab.conn_lift_frame_preserving_upd _ _ (fbc.conn_lift_frame_preserving_upd _ _ f)
   end;
 }
@@ -138,7 +127,7 @@ val pts_to
 : vprop
 
 let pts_to r v =
-  r.r `mpts_to` r.pl.conn_small_to_large.morph v
+  r.r `mpts_to` r.pl.conn_small_to_large v
 
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
@@ -164,7 +153,7 @@ let focus (r: ref 'a 'p)
 : Steel (ref 'a q)
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large x)
     (fun _ r' _ -> r' == ref_focus r l)
 = let r' = ref_focus r l in
   A.change_slprop_rel  
@@ -181,12 +170,12 @@ let unfocus #inames
   (l: connection p q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (r `pts_to` x)
-    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
+    (fun _ -> r' `pts_to` l.conn_small_to_large x)
     (requires fun _ -> r == ref_focus r' l)
     (ensures fun _ _ _ -> True)
 = A.change_slprop_rel  
     (r `pts_to` x)
-    (r' `pts_to` l.conn_small_to_large.morph x)
+    (r' `pts_to` l.conn_small_to_large x)
     (fun _ _ -> True)
     (fun m -> ())
 
@@ -200,16 +189,16 @@ val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 let split r xy x y =
   A.change_equal_slprop
     (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph xy)));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large xy)));
   Steel.PCMReference.split r.r
-    (r.pl.conn_small_to_large.morph xy)
-    (r.pl.conn_small_to_large.morph x)
-    (r.pl.conn_small_to_large.morph y);
+    (r.pl.conn_small_to_large xy)
+    (r.pl.conn_small_to_large x)
+    (r.pl.conn_small_to_large y);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large x)))
     (r `pts_to` x);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large y)))
     (r `pts_to` y)
 
 let mgather
@@ -228,18 +217,18 @@ val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
 let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large x)));
   A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large y)));
   mgather r.r
-    (r.pl.conn_small_to_large.morph x)
-    (r.pl.conn_small_to_large.morph y);
+    (r.pl.conn_small_to_large x)
+    (r.pl.conn_small_to_large y);
   assert (
-    let x1 = r.pl.conn_small_to_large.morph x in
-    let y1 = r.pl.conn_small_to_large.morph y in
-    let x2 = r.pl.conn_large_to_small.morph x1 in
-    let y2 = r.pl.conn_large_to_small.morph y1 in
+    let x1 = r.pl.conn_small_to_large x in
+    let y1 = r.pl.conn_small_to_large y in
+    let x2 = r.pl.conn_large_to_small x1 in
+    let y2 = r.pl.conn_large_to_small y1 in
     Ghost.reveal x == x2 /\ Ghost.reveal y == y2
   );
   A.change_equal_slprop _ (r `pts_to` op p x y)
@@ -258,15 +247,15 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (fun _ -> r `pts_to` x)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible p x x')
-= let w = Ghost.hide (r.pl.conn_small_to_large.morph x) in
+= let w = Ghost.hide (r.pl.conn_small_to_large x) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
   let w' = Steel.PCMReference.read r.r w in
   A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
-  let x' = r.pl.conn_large_to_small.morph w' in
+  let x' = r.pl.conn_large_to_small w' in
   assert (forall frame . (composable r.p w frame /\ op r.p frame w == w') ==> (
-    let sw = r.pl.conn_large_to_small.morph w in
-    let sw' = r.pl.conn_large_to_small.morph w' in
-    let sframe = r.pl.conn_large_to_small.morph frame in
+    let sw = r.pl.conn_large_to_small w in
+    let sw' = r.pl.conn_large_to_small w' in
+    let sframe = r.pl.conn_large_to_small frame in
     (composable p sw sframe /\ op p sframe sw == sw')
   ));
   A.return x'
@@ -275,7 +264,7 @@ module M = Steel.Memory
 
 let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
 : Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd x y f)
+= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large x)) (Ghost.hide (r.pl.conn_small_to_large y)) (r.pl.conn_lift_frame_preserving_upd x y f)
 
 let as_action (#p:vprop)
               (#q:vprop)
@@ -405,15 +394,13 @@ let field_to_struct
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (p k) (prod_pcm p))
-= {
-  morph = field_to_struct_f p k;
-  morph_unit = assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p));
-  morph_compose = (fun x1 x2 ->
-    Classical.forall_intro_2 (fun k -> is_unit (p k));
-    assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
-      ()
-  );
-}
+= morphism_intro
+    (field_to_struct_f p k)
+    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
+        ())
 
 let struct_to_field_f
   (#a: Type)
@@ -430,11 +417,9 @@ let struct_to_field
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (prod_pcm p) (p k))
-= {
-  morph = struct_to_field_f p k;
-  morph_unit = ();
-  morph_compose = (fun x1 x2 -> ());
-}
+= morphism_intro
+    (struct_to_field_f p k) ()
+    (fun x1 x2 -> ())
 
 let struct_field_lift_fpu'
   (#a: eqtype)
@@ -446,7 +431,7 @@ let struct_field_lift_fpu'
   (f: frame_preserving_upd (p k) x y)
   (v: restricted_t a b {
     (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+    compatible (prod_pcm p) ((field_to_struct p k) x) v
   })
 : Tot (restricted_t a b)
 = 
@@ -456,6 +441,8 @@ let struct_field_lift_fpu'
       else v k'
     )
 
+#push-options "--query_stats --z3rlimit 32"
+
 let struct_field_lift_fpu_prf
   (#a: eqtype)
   (#b: a -> Type)
@@ -466,18 +453,18 @@ let struct_field_lift_fpu_prf
   (f: frame_preserving_upd (p k) x y)
   (v: restricted_t a b {
     (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+    compatible (prod_pcm p) ((field_to_struct p k) x) v
   })
 : Lemma
   (let v_new = struct_field_lift_fpu' p k x y f v in
     (prod_pcm p).refine v_new /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
-    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
+    compatible (prod_pcm p) ((field_to_struct p k) y) v_new /\
+    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k) x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k) y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k) x) frame == v ==> op (prod_pcm p) ((field_to_struct p k) y) frame == v_new))
   )
 =
-  let y' = (field_to_struct p k).morph y in
+  let y' = (field_to_struct p k) y in
   let v_new = struct_field_lift_fpu' p k x y f v in
   Classical.forall_intro_2 (fun k -> is_unit (p k));
   assert (forall (frame: b k) .
@@ -487,11 +474,13 @@ let struct_field_lift_fpu_prf
     op (prod_pcm p) frame' y' `feq` v_new
   ));
   assert (compatible (prod_pcm p) y' v_new);
-  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
+  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k) x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k) y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k) x) frame == v ==> op (prod_pcm p) ((field_to_struct p k) y) frame `feq` v_new));
   ()
 
+#pop-options
+
 let struct_field_lift_fpu
   (#a: eqtype)
   (#b: a -> Type)
@@ -500,7 +489,7 @@ let struct_field_lift_fpu
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
+: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k) x) ((field_to_struct p k) y))
 = fun v ->
     struct_field_lift_fpu_prf p k x y f v;
     struct_field_lift_fpu' p k x y f v
@@ -791,15 +780,13 @@ let field_to_union
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (p k) (union_pcm p))
-= {
-  morph = field_to_union_f p k;
-  morph_unit = assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p));
-  morph_compose = (fun x1 x2 ->
-    Classical.forall_intro_2 (fun k -> is_unit (p k));
-    assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
-      ()
-  );
-}
+= morphism_intro
+    (field_to_union_f p k)
+    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
+        ())
 
 let union_to_field_f
   (#a: Type)
@@ -816,11 +803,9 @@ let union_to_field
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (union_pcm p) (p k))
-= {
-  morph = union_to_field_f p k;
-  morph_unit = ();
-  morph_compose = (fun x1 x2 -> ());
-}
+= morphism_intro
+    (union_to_field_f p k) ()
+    (fun x1 x2 -> ())
 
 let union_field_lift_fpu'
   (#a: eqtype)
@@ -832,7 +817,7 @@ let union_field_lift_fpu'
   (f: frame_preserving_upd (p k) x y)
   (v: union p {
     (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_struct p k).morph x) v
+    compatible (union_pcm p) ((field_to_struct p k) x) v
   })
 : Tot (union p)
 = 
@@ -855,18 +840,18 @@ let union_field_lift_fpu_prf
   (f: frame_preserving_upd (p k) x y)
   (v: union p {
     (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_union p k).morph x) v
+    compatible (union_pcm p) ((field_to_union p k) x) v
   })
 : Lemma
   (let v_new = union_field_lift_fpu' p k x y f v in
     (union_pcm p).refine v_new /\
-    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
-    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
-       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
+    compatible (union_pcm p) ((field_to_union p k) y) v_new /\
+    (forall (frame:_{composable (union_pcm p) ((field_to_union p k) x) frame}).
+       composable (union_pcm p) ((field_to_union p k) y) frame /\
+       (op (union_pcm p) ((field_to_union p k) x) frame == v ==> op (union_pcm p) ((field_to_union p k) y) frame == v_new))
   )
 =
-  let y' = (field_to_union p k).morph y in
+  let y' = (field_to_union p k) y in
   let v_new = union_field_lift_fpu' p k x y f v in
   Classical.forall_intro_2 (fun k -> is_unit (p k));
   let frame : b k = compatible_elim (p k) y (f (v k)) in
@@ -874,10 +859,21 @@ let union_field_lift_fpu_prf
   assert (composable (union_pcm p) y' frame');
   assert (op (union_pcm p) frame' y' `feq` v_new);
   compatible_intro (union_pcm p) y' v_new frame';
-  assert (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
-       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new));
-  ()
+  let x = Ghost.reveal x in
+  assert (compatible (union_pcm p) ((field_to_union p k) y) v_new);
+  let aux (frame:_{composable (union_pcm p) ((field_to_union p k) x) frame})
+  : Lemma (
+      composable (union_pcm p) ((field_to_union p k) y) frame /\
+      (op (union_pcm p) ((field_to_union p k) x) frame == v ==>
+       op (union_pcm p) ((field_to_union p k) y) frame `feq` v_new))
+  = assert (composable (union_pcm p) ((field_to_union p k) y) frame);
+    assert_norm (
+     op (union_pcm p) ((field_to_union p k) x) frame k ==
+     op (p k) x (frame k));
+    assume (op (union_pcm p) ((field_to_union p k) x) frame == v ==>
+       op (p k) x (frame k) == v k);
+       admit()
+  in forall_intro aux
 
 #pop-options
 
@@ -889,7 +885,7 @@ let union_field_lift_fpu
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
+: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k) x) ((field_to_union p k) y))
 = fun v ->
     union_field_lift_fpu_prf p k x y f v;
     union_field_lift_fpu' p k x y f v
@@ -907,19 +903,10 @@ let union_field
   conn_lift_frame_preserving_upd = union_field_lift_fpu p k;
 }
 
-let union_without_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (xs: union p)
-: union p
-= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
-
 let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (xs: union p)
-: Lemma (
-    composable (prod_pcm p) (union_without_field p k xs) (field_to_union_f p k (xs k)) /\
-    xs == op (prod_pcm p) (union_without_field p k xs) (field_to_union_f p k (xs k)))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
-  assert (xs `feq` op (prod_pcm p) (union_without_field p k xs) (field_to_union_f p k (xs k)))
+  (xs: union p{~ (xs k == one (p k))})
+: Lemma (xs == field_to_union_f p k (xs k))
+= assert (xs `feq` field_to_union_f p k (xs k))
 
 let addr_of_union_field
   #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
@@ -927,31 +914,12 @@ let addr_of_union_field
   (xs: Ghost.erased (union p))
 : Steel (ref base (p k))
     (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` union_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
+    (fun r' -> r' `pts_to` Ghost.reveal xs k)
+    (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
     (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
 = union_peel p k xs;
-  split r xs (union_without_field p k xs) (field_to_union_f p k (Ghost.reveal xs k));
-  let r = focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-
-let union_with_field (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (x:b k) (xs: union p{xs == one (union_pcm p)})
-: union p
-= on_dom a (fun k' -> if k' = k then x else xs k')
-
-let union_unpeel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (x: b k) (xs: union p{xs == one (union_pcm p)})
-: Lemma
-    (requires xs k == one (p k))
-    (ensures
-      composable (union_pcm p) xs (field_to_union_f p k x) /\
-      union_with_field p k x xs == op (union_pcm p) xs (field_to_union_f p k x))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
-  assert (union_with_field p k x xs `feq` op (union_pcm p) xs (field_to_union_f p k x))
+  A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
+  focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
 
 let unaddr_of_union_field
   (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
@@ -1257,21 +1225,19 @@ let value_to_uninit
   (#a: Type)
   (p: pcm a)
 : Tot (morphism p (pcm_uninit p))
-= {
-  morph = (fun x -> InitOrUnit x);
-  morph_unit = ();
-  morph_compose = (fun _ _ -> ());
-}
+= morphism_intro
+    (fun x -> InitOrUnit x)
+    ()
+    (fun _ _ -> ())
 
 let uninit_to_value
   (#a: Type)
   (p: pcm a)
 : Tot (morphism (pcm_uninit p) p)
-= {
-  morph = (fun x -> match x with InitOrUnit y -> y | _ -> one p);
-  morph_unit = ();
-  morph_compose = (fun _ _ -> Classical.forall_intro (is_unit p));
-}
+= morphism_intro
+    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
+    ()
+    (fun _ _ -> Classical.forall_intro (is_unit p))
 
 let uninit_conn_fpu'
   (#a: Type)
@@ -1281,7 +1247,7 @@ let uninit_conn_fpu'
   (f: frame_preserving_upd p x y)
   (v: uninit_t a {
     (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+    compatible (pcm_uninit p) ((value_to_uninit p) x) v
   })
 : Tot (uninit_t a)
 =
@@ -1296,18 +1262,18 @@ let uninit_conn_fpu_prop
   (f: frame_preserving_upd p x y)
   (v: uninit_t a {
     (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+    compatible (pcm_uninit p) ((value_to_uninit p) x) v
   })
 : Lemma
   (let v_new = uninit_conn_fpu' p x y f v in
     (pcm_uninit p).refine v_new /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
-    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
+    compatible (pcm_uninit p) ((value_to_uninit p) y) v_new /\
+    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p) x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p) y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p) x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p) y) frame == v_new))
   )
 = Classical.forall_intro (is_unit p);
-  let y' = (value_to_uninit p).morph y in
+  let y' = (value_to_uninit p) y in
   let InitOrUnit x' = v in
   let v_new = uninit_conn_fpu' p x y f v in
   let frame : a = compatible_elim p y (f x') in
@@ -1315,9 +1281,9 @@ let uninit_conn_fpu_prop
   assert (composable (pcm_uninit p) y' frame');
   assert (op (pcm_uninit p) frame' y' == v_new);
   compatible_intro (pcm_uninit p) y' v_new frame';
-  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
+  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p) x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p) y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p) x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p) y) frame == v_new));
   ()
 
 let uninit_conn_fpu
@@ -1326,7 +1292,7 @@ let uninit_conn_fpu
   (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
   (y: Ghost.erased a)
   (f: frame_preserving_upd p x y)
-: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
+: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p) x) ((value_to_uninit p) y))
 =
   fun v ->
     uninit_conn_fpu_prop p x y f v;
@@ -1432,20 +1398,20 @@ let pts_to_view_explicit_witinv
   =
     let x_ = vw.to_carrier x in
     let y_ = vw.to_carrier y in
-    let x' = r.pl.conn_small_to_large.morph x_ in
-    let y' = r.pl.conn_small_to_large.morph y_ in
+    let x' = r.pl.conn_small_to_large x_ in
+    let y' = r.pl.conn_small_to_large y_ in
     M.pts_to_join r.r x' y' m;
     let z' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun z' -> compatible r.p x' z' /\ compatible r.p y' z') in
     let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_x' -> composable r.p x' frame_x' /\ op r.p frame_x' x' == z') in
     let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_y' -> composable r.p y' frame_y' /\ op r.p frame_y' y' == z') in
-    let frame_x_ = r.pl.conn_large_to_small.morph frame_x' in
-    let frame_y_ = r.pl.conn_large_to_small.morph frame_y' in
+    let frame_x_ = r.pl.conn_large_to_small frame_x' in
+    let frame_y_ = r.pl.conn_large_to_small frame_y' in
     r.p.comm x' frame_x';
-    r.pl.conn_large_to_small.morph_compose x' frame_x';
-    vw.to_view_frame x (r.pl.conn_large_to_small.morph frame_x');
+    r.pl.conn_large_to_small_compose x' frame_x';
+    vw.to_view_frame x (r.pl.conn_large_to_small frame_x');
     r.p.comm y' frame_y';
-    r.pl.conn_large_to_small.morph_compose y' frame_y';
-    vw.to_view_frame y (r.pl.conn_large_to_small.morph frame_y');
+    r.pl.conn_large_to_small_compose y' frame_y';
+    vw.to_view_frame y (r.pl.conn_large_to_small frame_y');
     ()
   in
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))

From e758588ed1e21d4b65454f98a17c0b77f22cf681 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 15 Jul 2021 14:21:06 -0700
Subject: [PATCH 093/513] Make morphism extensional using restrited_t

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 265 +++++++++++---------
 1 file changed, 153 insertions(+), 112 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index cc57791d576..6f3e32c8abe 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,4 +1,4 @@
-module Steel.C.PCM
+module Steel.C.PCMA
 open FStar.PCM
 open FStar.FunctionalExtensionality
 
@@ -15,24 +15,72 @@ let pcm (a: Type) : Tot Type =
     //(~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
   })
 
-let morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) =
-  f:(a ^-> b){
-    f pa.p.one == pb.p.one /\
-    (forall (x1: a) (x2: a{composable pa x1 x2}).
-    composable pb (f x1) (f x2) /\
-    f (x1 `pa.p.op` x2) == f x1 `pb.p.op` f x2)}
-
-let morphism_intro (#pa: pcm 'a) (#pb: pcm 'b) (f: 'a -> 'b)
-  (f_unit: squash (f pa.p.one == pb.p.one))
-  (f_compose: (x1:'a -> x2:'a{composable pa x1 x2} ->
-    Lemma (
-      composable pb (f x1) (f x2) /\
-      f (x1 `pa.p.op` x2) == f x1 `pb.p.op` f x2)))
-: pa `morphism` pb
-= Classical.forall_intro_2 f_compose; on_dom _ f
-
-let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc)
-= on_dom _ (fun x -> fbc (fab x))
+let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
+  (x1: 'a) (x2: 'a{composable pa x1 x2})
+= squash (
+    composable pb (morph x1) (morph x2) /\
+    morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2)
+    
+let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
+  restricted_t (x2:'a{composable pa x1 x2}) (morph_compose2 pa pb morph x1)
+
+noeq
+type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
+  morph: (a ^-> b);
+  morph_unit: squash (morph pa.p.one == pb.p.one);
+  morph_compose: restricted_t a (morph_compose1 pa pb morph);
+}
+
+let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
+  (morph_unit: squash (morph pa.p.one == pb.p.one))
+  (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
+: pa `morphism` pb = {
+  morph = on_dom 'a morph;
+  morph_unit = morph_unit;
+  morph_compose = on_dom 'a (fun x1 -> on_dom (x2:'a{composable pa x1 x2}) (fun x2 -> morph_compose x1 x2));
+}
+
+let morph_compose2_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
+  (x1: 'a) (x2: 'a{composable pa x1 x2})
+  (prf1 prf2: morph_compose2 pa pb morph x1 x2)
+: Lemma (prf1 == prf2)
+= ()
+
+let morph_compose1_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b) (x1: 'a)
+  (prf1 prf2: morph_compose1 pa pb morph x1)
+: Lemma (prf1 == prf2)
+= assert (prf1 `feq` prf2)
+
+let morph_compose_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
+  (prf1 prf2: restricted_t 'a (morph_compose1 pa pb morph))
+: Lemma (prf1 == prf2)
+= let aux (x: 'a): Lemma (prf1 x == prf2 x) [SMTPat (prf1 x)] =
+    morph_compose1_irrelevant pa pb morph x (prf1 x) (prf2 x)
+  in assert (prf1 `feq` prf2)
+
+let morph_eq (f g: 'p `morphism` 'q)
+: Lemma (requires f.morph `feq` g.morph) (ensures f == g)
+  [SMTPat (f.morph `feq` g.morph)]
+= assert (f.morph == g.morph);
+  morph_compose_irrelevant 'p 'q f.morph f.morph_compose g.morph_compose
+
+let morphism_morph_compose
+  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
+  (x1: a)
+  (x2: a)
+: Lemma
+  (requires (composable pa x1 x2))
+  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
+  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
+= m.morph_compose x1 x2
+
+let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) =
+  mkmorphism
+    (fun x -> fbc.morph (fab.morph x))
+    ()
+    (fun x1 x2 ->
+      fab.morph_compose x1 x2;
+      fbc.morph_compose (fab.morph x1) (fab.morph x2))
 
 let compatible_intro
   (#a: Type u#a)
@@ -65,12 +113,12 @@ val compatible_morphism
   (x y: Ghost.erased 'a)
 : Lemma
     (requires compatible p x y)
-    (ensures compatible q (f x) (f y))
+    (ensures compatible q (f.morph x) (f.morph y))
 
 let compatible_morphism #a #b #p #q f x y =
   let frame_x = compatible_elim p x y in
-  assert (composable p frame_x x);
-  compatible_intro q (f x) (f y) (f frame_x)
+  f.morph_compose frame_x x;
+  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
 
 let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
   (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
@@ -90,12 +138,12 @@ noeq
 type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
   conn_small_to_large: morphism p_small p_large;
   conn_large_to_small: morphism p_large p_small;
-  conn_small_to_large_inv: squash (conn_large_to_small `is_inverse_of` conn_small_to_large);
+  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
   conn_lift_frame_preserving_upd:
     (x: Ghost.erased t_small { ~ (Ghost.reveal x == p_small.p.one) }) -> // validity condition, e.g. union cases
     (y: Ghost.erased t_small) ->
     (f: frame_preserving_upd p_small x y) ->
-    Tot (frame_preserving_upd p_large (conn_small_to_large x) (conn_small_to_large y));
+    Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y));
 }
 
 let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) = {
@@ -103,10 +151,10 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
   conn_large_to_small = fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small;
   conn_small_to_large_inv = ();
   conn_lift_frame_preserving_upd = begin fun xc yc f ->
-    let xb = Ghost.hide (fbc.conn_small_to_large xc) in
-    let yb = Ghost.hide (fbc.conn_small_to_large yc) in
-    let xa = Ghost.hide (fab.conn_small_to_large xb) in
-    let ya = Ghost.hide (fab.conn_small_to_large yb) in
+    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
+    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
+    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
+    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
     fab.conn_lift_frame_preserving_upd _ _ (fbc.conn_lift_frame_preserving_upd _ _ f)
   end;
 }
@@ -127,7 +175,7 @@ val pts_to
 : vprop
 
 let pts_to r v =
-  r.r `mpts_to` r.pl.conn_small_to_large v
+  r.r `mpts_to` r.pl.conn_small_to_large.morph v
 
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
@@ -153,7 +201,7 @@ let focus (r: ref 'a 'p)
 : Steel (ref 'a q)
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
     (fun _ r' _ -> r' == ref_focus r l)
 = let r' = ref_focus r l in
   A.change_slprop_rel  
@@ -170,12 +218,12 @@ let unfocus #inames
   (l: connection p q) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (r `pts_to` x)
-    (fun _ -> r' `pts_to` l.conn_small_to_large x)
+    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
     (requires fun _ -> r == ref_focus r' l)
     (ensures fun _ _ _ -> True)
 = A.change_slprop_rel  
     (r `pts_to` x)
-    (r' `pts_to` l.conn_small_to_large x)
+    (r' `pts_to` l.conn_small_to_large.morph x)
     (fun _ _ -> True)
     (fun m -> ())
 
@@ -189,16 +237,16 @@ val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 let split r xy x y =
   A.change_equal_slprop
     (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large xy)));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph xy)));
   Steel.PCMReference.split r.r
-    (r.pl.conn_small_to_large xy)
-    (r.pl.conn_small_to_large x)
-    (r.pl.conn_small_to_large y);
+    (r.pl.conn_small_to_large.morph xy)
+    (r.pl.conn_small_to_large.morph x)
+    (r.pl.conn_small_to_large.morph y);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large x)))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)))
     (r `pts_to` x);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large y)))
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
     (r `pts_to` y)
 
 let mgather
@@ -217,18 +265,18 @@ val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
 let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large x)));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)));
   A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large y)));
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)));
   mgather r.r
-    (r.pl.conn_small_to_large x)
-    (r.pl.conn_small_to_large y);
+    (r.pl.conn_small_to_large.morph x)
+    (r.pl.conn_small_to_large.morph y);
   assert (
-    let x1 = r.pl.conn_small_to_large x in
-    let y1 = r.pl.conn_small_to_large y in
-    let x2 = r.pl.conn_large_to_small x1 in
-    let y2 = r.pl.conn_large_to_small y1 in
+    let x1 = r.pl.conn_small_to_large.morph x in
+    let y1 = r.pl.conn_small_to_large.morph y in
+    let x2 = r.pl.conn_large_to_small.morph x1 in
+    let y2 = r.pl.conn_large_to_small.morph y1 in
     Ghost.reveal x == x2 /\ Ghost.reveal y == y2
   );
   A.change_equal_slprop _ (r `pts_to` op p x y)
@@ -247,15 +295,15 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (fun _ -> r `pts_to` x)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible p x x')
-= let w = Ghost.hide (r.pl.conn_small_to_large x) in
+= let w = Ghost.hide (r.pl.conn_small_to_large.morph x) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
   let w' = Steel.PCMReference.read r.r w in
   A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
-  let x' = r.pl.conn_large_to_small w' in
+  let x' = r.pl.conn_large_to_small.morph w' in
   assert (forall frame . (composable r.p w frame /\ op r.p frame w == w') ==> (
-    let sw = r.pl.conn_large_to_small w in
-    let sw' = r.pl.conn_large_to_small w' in
-    let sframe = r.pl.conn_large_to_small frame in
+    let sw = r.pl.conn_large_to_small.morph w in
+    let sw' = r.pl.conn_large_to_small.morph w' in
+    let sframe = r.pl.conn_large_to_small.morph frame in
     (composable p sw sframe /\ op p sframe sw == sw')
   ));
   A.return x'
@@ -264,7 +312,7 @@ module M = Steel.Memory
 
 let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
 : Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large x)) (Ghost.hide (r.pl.conn_small_to_large y)) (r.pl.conn_lift_frame_preserving_upd x y f)
+= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd x y f)
 
 let as_action (#p:vprop)
               (#q:vprop)
@@ -394,7 +442,7 @@ let field_to_struct
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (p k) (prod_pcm p))
-= morphism_intro
+= mkmorphism
     (field_to_struct_f p k)
     (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
     (fun x1 x2 ->
@@ -417,7 +465,7 @@ let struct_to_field
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (prod_pcm p) (p k))
-= morphism_intro
+= mkmorphism
     (struct_to_field_f p k) ()
     (fun x1 x2 -> ())
 
@@ -431,7 +479,7 @@ let struct_field_lift_fpu'
   (f: frame_preserving_upd (p k) x y)
   (v: restricted_t a b {
     (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k) x) v
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
   })
 : Tot (restricted_t a b)
 = 
@@ -441,8 +489,6 @@ let struct_field_lift_fpu'
       else v k'
     )
 
-#push-options "--query_stats --z3rlimit 32"
-
 let struct_field_lift_fpu_prf
   (#a: eqtype)
   (#b: a -> Type)
@@ -453,18 +499,18 @@ let struct_field_lift_fpu_prf
   (f: frame_preserving_upd (p k) x y)
   (v: restricted_t a b {
     (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k) x) v
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
   })
 : Lemma
   (let v_new = struct_field_lift_fpu' p k x y f v in
     (prod_pcm p).refine v_new /\
-    compatible (prod_pcm p) ((field_to_struct p k) y) v_new /\
-    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k) x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k) y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k) x) frame == v ==> op (prod_pcm p) ((field_to_struct p k) y) frame == v_new))
+    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
+    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
   )
 =
-  let y' = (field_to_struct p k) y in
+  let y' = (field_to_struct p k).morph y in
   let v_new = struct_field_lift_fpu' p k x y f v in
   Classical.forall_intro_2 (fun k -> is_unit (p k));
   assert (forall (frame: b k) .
@@ -474,13 +520,11 @@ let struct_field_lift_fpu_prf
     op (prod_pcm p) frame' y' `feq` v_new
   ));
   assert (compatible (prod_pcm p) y' v_new);
-  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k) x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k) y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k) x) frame == v ==> op (prod_pcm p) ((field_to_struct p k) y) frame `feq` v_new));
+  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
   ()
 
-#pop-options
-
 let struct_field_lift_fpu
   (#a: eqtype)
   (#b: a -> Type)
@@ -489,7 +533,7 @@ let struct_field_lift_fpu
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k) x) ((field_to_struct p k) y))
+: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
 = fun v ->
     struct_field_lift_fpu_prf p k x y f v;
     struct_field_lift_fpu' p k x y f v
@@ -780,7 +824,7 @@ let field_to_union
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (p k) (union_pcm p))
-= morphism_intro
+= mkmorphism
     (field_to_union_f p k)
     (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
     (fun x1 x2 ->
@@ -803,7 +847,7 @@ let union_to_field
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (morphism (union_pcm p) (p k))
-= morphism_intro
+= mkmorphism
     (union_to_field_f p k) ()
     (fun x1 x2 -> ())
 
@@ -817,7 +861,7 @@ let union_field_lift_fpu'
   (f: frame_preserving_upd (p k) x y)
   (v: union p {
     (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_struct p k) x) v
+    compatible (union_pcm p) ((field_to_struct p k).morph x) v
   })
 : Tot (union p)
 = 
@@ -840,18 +884,18 @@ let union_field_lift_fpu_prf
   (f: frame_preserving_upd (p k) x y)
   (v: union p {
     (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_union p k) x) v
+    compatible (union_pcm p) ((field_to_union p k).morph x) v
   })
 : Lemma
   (let v_new = union_field_lift_fpu' p k x y f v in
     (union_pcm p).refine v_new /\
-    compatible (union_pcm p) ((field_to_union p k) y) v_new /\
-    (forall (frame:_{composable (union_pcm p) ((field_to_union p k) x) frame}).
-       composable (union_pcm p) ((field_to_union p k) y) frame /\
-       (op (union_pcm p) ((field_to_union p k) x) frame == v ==> op (union_pcm p) ((field_to_union p k) y) frame == v_new))
+    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
+    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
+       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
   )
 =
-  let y' = (field_to_union p k) y in
+  let y' = (field_to_union p k).morph y in
   let v_new = union_field_lift_fpu' p k x y f v in
   Classical.forall_intro_2 (fun k -> is_unit (p k));
   let frame : b k = compatible_elim (p k) y (f (v k)) in
@@ -860,20 +904,17 @@ let union_field_lift_fpu_prf
   assert (op (union_pcm p) frame' y' `feq` v_new);
   compatible_intro (union_pcm p) y' v_new frame';
   let x = Ghost.reveal x in
-  assert (compatible (union_pcm p) ((field_to_union p k) y) v_new);
-  let aux (frame:_{composable (union_pcm p) ((field_to_union p k) x) frame})
+  let aux (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame})
   : Lemma (
-      composable (union_pcm p) ((field_to_union p k) y) frame /\
-      (op (union_pcm p) ((field_to_union p k) x) frame == v ==>
-       op (union_pcm p) ((field_to_union p k) y) frame `feq` v_new))
-  = assert (composable (union_pcm p) ((field_to_union p k) y) frame);
-    assert_norm (
-     op (union_pcm p) ((field_to_union p k) x) frame k ==
+      composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+      (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
+       op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
+  = assert_norm (
+     op (union_pcm p) ((field_to_union p k).morph x) frame k ==
      op (p k) x (frame k));
-    assume (op (union_pcm p) ((field_to_union p k) x) frame == v ==>
-       op (p k) x (frame k) == v k);
-       admit()
-  in forall_intro aux
+    assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
+       op (p k) x (frame k) == v k)
+  in forall_intro aux; ()
 
 #pop-options
 
@@ -885,7 +926,7 @@ let union_field_lift_fpu
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k) x) ((field_to_union p k) y))
+: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
 = fun v ->
     union_field_lift_fpu_prf p k x y f v;
     union_field_lift_fpu' p k x y f v
@@ -1225,7 +1266,7 @@ let value_to_uninit
   (#a: Type)
   (p: pcm a)
 : Tot (morphism p (pcm_uninit p))
-= morphism_intro
+= mkmorphism
     (fun x -> InitOrUnit x)
     ()
     (fun _ _ -> ())
@@ -1234,7 +1275,7 @@ let uninit_to_value
   (#a: Type)
   (p: pcm a)
 : Tot (morphism (pcm_uninit p) p)
-= morphism_intro
+= mkmorphism
     (fun x -> match x with InitOrUnit y -> y | _ -> one p)
     ()
     (fun _ _ -> Classical.forall_intro (is_unit p))
@@ -1247,7 +1288,7 @@ let uninit_conn_fpu'
   (f: frame_preserving_upd p x y)
   (v: uninit_t a {
     (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p) x) v
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
   })
 : Tot (uninit_t a)
 =
@@ -1262,18 +1303,18 @@ let uninit_conn_fpu_prop
   (f: frame_preserving_upd p x y)
   (v: uninit_t a {
     (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p) x) v
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
   })
 : Lemma
   (let v_new = uninit_conn_fpu' p x y f v in
     (pcm_uninit p).refine v_new /\
-    compatible (pcm_uninit p) ((value_to_uninit p) y) v_new /\
-    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p) x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p) y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p) x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p) y) frame == v_new))
+    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
+    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
   )
 = Classical.forall_intro (is_unit p);
-  let y' = (value_to_uninit p) y in
+  let y' = (value_to_uninit p).morph y in
   let InitOrUnit x' = v in
   let v_new = uninit_conn_fpu' p x y f v in
   let frame : a = compatible_elim p y (f x') in
@@ -1281,9 +1322,9 @@ let uninit_conn_fpu_prop
   assert (composable (pcm_uninit p) y' frame');
   assert (op (pcm_uninit p) frame' y' == v_new);
   compatible_intro (pcm_uninit p) y' v_new frame';
-  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p) x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p) y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p) x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p) y) frame == v_new));
+  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
   ()
 
 let uninit_conn_fpu
@@ -1292,7 +1333,7 @@ let uninit_conn_fpu
   (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
   (y: Ghost.erased a)
   (f: frame_preserving_upd p x y)
-: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p) x) ((value_to_uninit p) y))
+: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
 =
   fun v ->
     uninit_conn_fpu_prop p x y f v;
@@ -1398,20 +1439,20 @@ let pts_to_view_explicit_witinv
   =
     let x_ = vw.to_carrier x in
     let y_ = vw.to_carrier y in
-    let x' = r.pl.conn_small_to_large x_ in
-    let y' = r.pl.conn_small_to_large y_ in
+    let x' = r.pl.conn_small_to_large.morph x_ in
+    let y' = r.pl.conn_small_to_large.morph y_ in
     M.pts_to_join r.r x' y' m;
     let z' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun z' -> compatible r.p x' z' /\ compatible r.p y' z') in
     let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_x' -> composable r.p x' frame_x' /\ op r.p frame_x' x' == z') in
     let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_y' -> composable r.p y' frame_y' /\ op r.p frame_y' y' == z') in
-    let frame_x_ = r.pl.conn_large_to_small frame_x' in
-    let frame_y_ = r.pl.conn_large_to_small frame_y' in
+    let frame_x_ = r.pl.conn_large_to_small.morph frame_x' in
+    let frame_y_ = r.pl.conn_large_to_small.morph frame_y' in
     r.p.comm x' frame_x';
-    r.pl.conn_large_to_small_compose x' frame_x';
-    vw.to_view_frame x (r.pl.conn_large_to_small frame_x');
+    r.pl.conn_large_to_small.morph_compose x' frame_x';
+    vw.to_view_frame x (r.pl.conn_large_to_small.morph frame_x');
     r.p.comm y' frame_y';
-    r.pl.conn_large_to_small_compose y' frame_y';
-    vw.to_view_frame y (r.pl.conn_large_to_small frame_y');
+    r.pl.conn_large_to_small.morph_compose y' frame_y';
+    vw.to_view_frame y (r.pl.conn_large_to_small.morph frame_y');
     ()
   in
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))

From c1f55cda4ac7dbb682096106d22560bfc6520f4c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 15 Jul 2021 14:23:03 -0700
Subject: [PATCH 094/513] Tidy

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 6f3e32c8abe..7f6f3e14ad7 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,4 +1,4 @@
-module Steel.C.PCMA
+module Steel.C.PCM
 open FStar.PCM
 open FStar.FunctionalExtensionality
 

From 845eff8947bd676530b5188f3800955d9403c6d6 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 15 Jul 2021 14:56:52 -0700
Subject: [PATCH 095/513] Extensional connections + prove ref_focus_comp

---
 examples/steel/arraystructs/Steel.C.PCM.fst | 112 ++++++++++++++------
 1 file changed, 78 insertions(+), 34 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 7f6f3e14ad7..93ad1edc151 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -134,30 +134,76 @@ let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
   [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
 = assert (g (f x1) == g (f x2))
 
+#push-options "--print_universes"
+
+let fpu_lift_dom (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
+   y:Ghost.erased t_small &
+   frame_preserving_upd p_small x y)
+
+let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+: fpu_lift_dom conn_small_to_large -> Type
+= fun (|x, y, f|) ->
+  frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
+     
+let fpu_lift (#t_large:Type) (#t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+: Type
+= restricted_t
+    (fpu_lift_dom conn_small_to_large)
+    (fpu_lift_cod conn_small_to_large)
+
 noeq
 type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
   conn_small_to_large: morphism p_small p_large;
   conn_large_to_small: morphism p_large p_small;
   conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
-  conn_lift_frame_preserving_upd:
-    (x: Ghost.erased t_small { ~ (Ghost.reveal x == p_small.p.one) }) -> // validity condition, e.g. union cases
-    (y: Ghost.erased t_small) ->
-    (f: frame_preserving_upd p_small x y) ->
-    Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y));
+  conn_lift_frame_preserving_upd: fpu_lift p_large p_small conn_small_to_large;
+}
+
+let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+  (conn_large_to_small: morphism p_large p_small)
+  (conn_small_to_large_inv:
+    squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
+  (conn_lift_frame_preserving_upd:
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
+     y:Ghost.erased t_small ->
+     frame_preserving_upd p_small x y ->
+     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+: connection p_large p_small = {
+  conn_small_to_large = conn_small_to_large;
+  conn_large_to_small = conn_large_to_small;
+  conn_small_to_large_inv = conn_small_to_large_inv;
+  conn_lift_frame_preserving_upd =
+    on_domain
+      (fpu_lift_dom conn_small_to_large)
+      (fun (z: fpu_lift_dom conn_small_to_large) ->
+        let (|x, y, f|) = z in
+	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
 }
 
-let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) = {
-  conn_small_to_large = fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large;
-  conn_large_to_small = fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small;
-  conn_small_to_large_inv = ();
-  conn_lift_frame_preserving_upd = begin fun xc yc f ->
+let connection_eq (l m: 'p `connection` 'q)
+: Lemma
+    (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
+              l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
+              l.conn_lift_frame_preserving_upd `feq` m.conn_lift_frame_preserving_upd)
+    (ensures l == m)
+= ()
+
+let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
+  mkconnection
+    (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
+    (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
+    ()
+    (fun xc yc f ->
     let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
     let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
     let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
     let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
-    fab.conn_lift_frame_preserving_upd _ _ (fbc.conn_lift_frame_preserving_upd _ _ f)
-  end;
-}
+    fab.conn_lift_frame_preserving_upd (|xb, yb, fbc.conn_lift_frame_preserving_upd (|xc, yc, f|)|))
 
 noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
   p: pcm a;
@@ -190,8 +236,9 @@ let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
   [SMTPatOr [
     [SMTPat (ref_focus (ref_focus r l) m)]; 
     [SMTPat (ref_focus r (l `connection_compose` m))]]]
-= assume ((r.pl `connection_compose` l) `connection_compose` m ==
-          r.pl `connection_compose` (l `connection_compose` m))
+= connection_eq
+    ((r.pl `connection_compose` l) `connection_compose` m)
+    (r.pl `connection_compose` (l `connection_compose` m))
 
 module A = Steel.Effect.Atomic
 
@@ -312,7 +359,7 @@ module M = Steel.Memory
 
 let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
 : Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd x y f)
+= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, f|))
 
 let as_action (#p:vprop)
               (#q:vprop)
@@ -544,12 +591,11 @@ let struct_field
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (connection (prod_pcm p) (p k))
-= {
-  conn_small_to_large = field_to_struct p k;
-  conn_large_to_small = struct_to_field p k;
-  conn_small_to_large_inv = ();
-  conn_lift_frame_preserving_upd = struct_field_lift_fpu p k;
-}
+= mkconnection
+    (field_to_struct p k)
+    (struct_to_field p k)
+    ()
+    (struct_field_lift_fpu p k)
 
 let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   (xs: restricted_t a b)
@@ -937,12 +983,11 @@ let union_field
   (p:(k: a -> pcm (b k)))
   (k: a)
 : Tot (connection (union_pcm p) (p k))
-= {
-  conn_small_to_large = field_to_union p k;
-  conn_large_to_small = union_to_field p k;
-  conn_small_to_large_inv = ();
-  conn_lift_frame_preserving_upd = union_field_lift_fpu p k;
-}
+= mkconnection
+    (field_to_union p k)
+    (union_to_field p k)
+    ()
+    (union_field_lift_fpu p k)
 
 let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
   (xs: union p{~ (xs k == one (p k))})
@@ -1343,12 +1388,11 @@ let uninit_conn
   (#a: Type)
   (p: pcm a)
 : Tot (connection (pcm_uninit p) p)
-= {
-  conn_small_to_large = value_to_uninit p;
-  conn_large_to_small = uninit_to_value p;
-  conn_small_to_large_inv = ();
-  conn_lift_frame_preserving_upd = uninit_conn_fpu p;
-}
+= mkconnection
+    (value_to_uninit p)
+    (uninit_to_value p)
+    ()
+    (uninit_conn_fpu p)
 
 let exclusive_uninit
   (#a: Type)

From d270f059f7f82079ff7377796ac3b488c992116a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 07:34:16 -0700
Subject: [PATCH 096/513] Make some Steel.C.PCM functions abstract

---
 examples/steel/arraystructs/IntOrBool.fst    |   10 +
 examples/steel/arraystructs/IntOrBool.fsti   |   56 +-
 examples/steel/arraystructs/Steel.C.PCM.fst  | 1652 +-----------------
 examples/steel/arraystructs/Steel.C.PCM.fsti | 1648 +++++++++++++++++
 4 files changed, 1698 insertions(+), 1668 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.PCM.fsti

diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index f4717f97bb5..214b931abc0 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -8,6 +8,16 @@ open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 
+let int_or_bool_cases k = match k with
+  | I -> pod int
+  | B -> pod bool
+  
+let int_or_bool_cases_pcm k: pcm (int_or_bool_cases k) = match k with
+  | I -> pod_pcm int
+  | B -> pod_pcm bool
+let int_or_bool = union int_or_bool_cases_pcm
+let int_or_bool_pcm: pcm int_or_bool = union_pcm int_or_bool_cases_pcm
+
 let mk_int i = Some (|I, Ghost.reveal i|)
 let mk_bool b = Some (|B, Ghost.reveal b|)
 
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 2efa469a11b..88433857388 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -13,15 +13,11 @@ module A = Steel.Effect.Atomic
 
 type int_or_bool_case = | I | B
 
-let int_or_bool_cases k = match k with
-  | I -> pod int
-  | B -> pod bool
-  
-let int_or_bool_cases_pcm k: pcm (int_or_bool_cases k) = match k with
-  | I -> pod_pcm int
-  | B -> pod_pcm bool
-let int_or_bool = union int_or_bool_cases_pcm
-let int_or_bool_pcm: pcm int_or_bool = union_pcm int_or_bool_cases_pcm
+val int_or_bool: Type
+
+/// PCM for node:
+
+val int_or_bool_pcm: pcm int_or_bool
 
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
@@ -31,11 +27,22 @@ val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
 
 /// Connections for cases
 
-val _i : connection int_or_bool_pcm (pod_pcm int)
-val _b : connection int_or_bool_pcm (pod_pcm bool)
+val _i : int_or_bool_pcm `connection` pod_pcm int
+val _b : int_or_bool_pcm `connection` pod_pcm bool
+
+/// Getting the case of a union in GTot
+
+// Construct using strong LEM
+val case_of_int_or_bool (u: Ghost.erased int_or_bool): GTot (option int_or_bool_case)
+
+val case_of_int_or_bool_int (i: Ghost.erased (pod int))
+: Lemma (case_of_int_or_bool (mk_int i) == Some I) [SMTPat (mk_int i)]
 
-// Construct using strong_excluded_middle
-//val case_of : int_or_bool -> GTot (option int_or_bool_case)
+val case_of_int_or_bool_bool (b: Ghost.erased (pod bool))
+: Lemma (case_of_int_or_bool (mk_bool b) == Some B) [SMTPat (mk_bool b)]
+
+val case_of_int_or_bool_one
+: squash (case_of_int_or_bool (one int_or_bool_pcm) == None)
 
 /// Taking pointers to the i and b cases of an int_or_bool
 
@@ -61,15 +68,18 @@ val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
 
 /// Switching the case
 
-val switch_to_bool (#i: Ghost.erased int)
-  (p: ref 'a int_or_bool_pcm) (b: bool)
-: SteelT unit (p `pts_to` mk_int (some i)) (fun _ -> p `pts_to` mk_bool (some b))
-
-val switch_to_int (#b: Ghost.erased bool)
+val switch_to_int (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
-: SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))
+: Steel unit
+    (p `pts_to` u)
+    (fun _ -> p `pts_to` mk_int (some i))
+    (requires fun _ -> Some? (case_of_int_or_bool u))
+    (requires fun _ _ _ -> True)
 
-/// Laws about unions
-
-//compatible p (mk_int i) v
-//==> exists j. v = mk_int j
+val switch_to_bool (#u: Ghost.erased int_or_bool)
+  (p: ref 'a int_or_bool_pcm) (b: bool)
+: Steel unit
+    (p `pts_to` u)
+    (fun _ -> p `pts_to` mk_bool (some b))
+    (requires fun _ -> Some? (case_of_int_or_bool u))
+    (requires fun _ _ _ -> True)
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 00313e52c41..045cef10905 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,256 +1,14 @@
 module Steel.C.PCM
-open FStar.PCM
+module P = FStar.PCM
 open FStar.FunctionalExtensionality
 
 #push-options "--print_universes"
 
-unfold
-let one (#a: Type) (p: pcm a) = p.p.one
-
-let pcm (a: Type) : Tot Type =
-  (p: FStar.PCM.pcm a {
-    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
-      op p x y == one p ==> x == one p /\ y == one p) // /\ // necessary to lift frame-preserving updates to unions
-    //(forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
-    //(~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
-  })
-
-let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
-  (x1: 'a) (x2: 'a{composable pa x1 x2})
-= squash (
-    composable pb (morph x1) (morph x2) /\
-    morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2)
-    
-let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
-  restricted_t (x2:'a{composable pa x1 x2}) (morph_compose2 pa pb morph x1)
-
-noeq
-type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
-  morph: (a ^-> b);
-  morph_unit: squash (morph pa.p.one == pb.p.one);
-  morph_compose: restricted_t a (morph_compose1 pa pb morph);
-}
-
-let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
-  (morph_unit: squash (morph pa.p.one == pb.p.one))
-  (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
-: pa `morphism` pb = {
-  morph = on_dom 'a morph;
-  morph_unit = morph_unit;
-  morph_compose = on_dom 'a (fun x1 -> on_dom (x2:'a{composable pa x1 x2}) (fun x2 -> morph_compose x1 x2));
-}
-
-let morph_compose2_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
-  (x1: 'a) (x2: 'a{composable pa x1 x2})
-  (prf1 prf2: morph_compose2 pa pb morph x1 x2)
-: Lemma (prf1 == prf2)
-= ()
-
-let morph_compose1_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b) (x1: 'a)
-  (prf1 prf2: morph_compose1 pa pb morph x1)
-: Lemma (prf1 == prf2)
-= assert (prf1 `feq` prf2)
-
-let morph_compose_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
-  (prf1 prf2: restricted_t 'a (morph_compose1 pa pb morph))
-: Lemma (prf1 == prf2)
-= let aux (x: 'a): Lemma (prf1 x == prf2 x) [SMTPat (prf1 x)] =
-    morph_compose1_irrelevant pa pb morph x (prf1 x) (prf2 x)
-  in assert (prf1 `feq` prf2)
-
-let morph_eq (f g: 'p `morphism` 'q)
-: Lemma (requires f.morph `feq` g.morph) (ensures f == g)
-  [SMTPat (f.morph `feq` g.morph)]
-= assert (f.morph == g.morph);
-  morph_compose_irrelevant 'p 'q f.morph f.morph_compose g.morph_compose
-
-let morphism_morph_compose
-  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
-  (x1: a)
-  (x2: a)
-: Lemma
-  (requires (composable pa x1 x2))
-  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
-  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
-= m.morph_compose x1 x2
-
-let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) =
-  mkmorphism
-    (fun x -> fbc.morph (fab.morph x))
-    ()
-    (fun x1 x2 ->
-      fab.morph_compose x1 x2;
-      fbc.morph_compose (fab.morph x1) (fab.morph x2))
-
-let compatible_intro
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-  (frame: a)
-: Lemma
-  (requires (composable pcm x frame /\ op pcm frame x == y))
-  (ensures (compatible pcm x y))
-= ()
-
-let compatible_elim
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-: Ghost a
-  (requires (compatible pcm x y))
-  (ensures (fun frame ->
-    composable pcm x frame /\
-    op pcm frame x == y
-  ))
-= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
-    composable pcm x frame /\
-    op pcm frame x == y
-  )
-
-val compatible_morphism
-  (#p: pcm 'a) (#q: pcm 'b)
-  (f: p `morphism` q)
-  (x y: Ghost.erased 'a)
-: Lemma
-    (requires compatible p x y)
-    (ensures compatible q (f.morph x) (f.morph y))
-
-let compatible_morphism #a #b #p #q f x y =
-  let frame_x = compatible_elim p x y in
-  f.morph_compose frame_x x;
-  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
-
-let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
-  (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
-
-let is_inverse_of (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b)) : Tot prop =
-  (forall x . {:pattern (g (f x))} g (f x) == x)
-
-let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
-  x1 x2
-: Lemma
-  (requires (g `is_inverse_of` f /\ f x1 == f x2))
-  (ensures (x1 == x2))
-  [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
-= assert (g (f x1) == g (f x2))
-
-#push-options "--print_universes"
-
-let fpu_lift_dom (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
-   y:Ghost.erased t_small &
-   frame_preserving_upd p_small x y)
-
-let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-: fpu_lift_dom conn_small_to_large -> Type
-= fun (|x, y, f|) ->
-  frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
-     
-let fpu_lift (#t_large:Type) (#t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-: Type
-= restricted_t
-    (fpu_lift_dom conn_small_to_large)
-    (fpu_lift_cod conn_small_to_large)
-
-noeq
-type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
-  conn_small_to_large: morphism p_small p_large;
-  conn_large_to_small: morphism p_large p_small;
-  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
-  conn_lift_frame_preserving_upd: fpu_lift p_large p_small conn_small_to_large;
-}
-
-let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-  (conn_large_to_small: morphism p_large p_small)
-  (conn_small_to_large_inv:
-    squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
-  (conn_lift_frame_preserving_upd:
-    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
-     y:Ghost.erased t_small ->
-     frame_preserving_upd p_small x y ->
-     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
-: connection p_large p_small = {
-  conn_small_to_large = conn_small_to_large;
-  conn_large_to_small = conn_large_to_small;
-  conn_small_to_large_inv = conn_small_to_large_inv;
-  conn_lift_frame_preserving_upd =
-    on_domain
-      (fpu_lift_dom conn_small_to_large)
-      (fun (z: fpu_lift_dom conn_small_to_large) ->
-        let (|x, y, f|) = z in
-	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
-}
-
-let connection_eq (l m: 'p `connection` 'q)
-: Lemma
-    (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
-              l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
-              l.conn_lift_frame_preserving_upd `feq` m.conn_lift_frame_preserving_upd)
-    (ensures l == m)
-= ()
-
-let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
-  mkconnection
-    (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
-    (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
-    ()
-    (fun xc yc f ->
-    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
-    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
-    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
-    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
-    fab.conn_lift_frame_preserving_upd (|xb, yb, fbc.conn_lift_frame_preserving_upd (|xc, yc, f|)|))
-
-noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
-  p: pcm a;
-  pl: connection p q;
-  r: Steel.Memory.ref a p;
-}
-
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
-
-open Steel.Effect
-
-val pts_to
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
-: vprop
-
 let pts_to r v =
   r.r `mpts_to` r.pl.conn_small_to_large.morph v
 
-val ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref a p) (#q: pcm c) (l: connection p q)
-: ref a q
-
-let ref_focus #a #b #c #p r #q l =
-  {p = r.p; pl = connection_compose r.pl l; r = r.r}
-
-let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
-: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
-  [SMTPatOr [
-    [SMTPat (ref_focus (ref_focus r l) m)]; 
-    [SMTPat (ref_focus r (l `connection_compose` m))]]]
-= connection_eq
-    ((r.pl `connection_compose` l) `connection_compose` m)
-    (r.pl `connection_compose` (l `connection_compose` m))
-
-module A = Steel.Effect.Atomic
-
-let focus (r: ref 'a 'p)
-  (#q: pcm 'c)
-  (l: connection 'p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ref 'a q)
-    (r `pts_to` s)
-    (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
-    (fun _ r' _ -> r' == ref_focus r l)
-= let r' = ref_focus r l in
+let focus r l s x =
+  let r' = ref_focus r l in
   A.change_slprop_rel  
     (r `pts_to` s)
     (r' `pts_to` x)
@@ -258,29 +16,13 @@ let focus (r: ref 'a 'p)
     (fun m -> ());
   A.return r'
 
-let unfocus #inames
-  (#p: pcm 'b)
-  (#q: pcm 'c)
-  (r: ref 'a q) (r': ref 'a p)
-  (l: connection p q) (x: Ghost.erased 'c)
-: A.SteelGhost unit inames
-    (r `pts_to` x)
-    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
-    (requires fun _ -> r == ref_focus r' l)
-    (ensures fun _ _ _ -> True)
-= A.change_slprop_rel  
+let unfocus r r' l x =
+  A.change_slprop_rel  
     (r `pts_to` x)
     (r' `pts_to` l.conn_small_to_large.morph x)
     (fun _ _ -> True)
     (fun m -> ())
 
-val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
-: Steel unit
-    (r `pts_to` xy)
-    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
-    (fun _ _ _ -> True)
-
 let split r xy x y =
   A.change_equal_slprop
     (r `pts_to` xy)
@@ -296,19 +38,6 @@ let split r xy x y =
     (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
     (r `pts_to` y)
 
-let mgather
-  (#a:Type) (#p:pcm a)
-  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: SteelT (_:unit{composable p v0 v1})
-    (mpts_to r v0 `star` mpts_to r v1)
-    (fun _ -> mpts_to r (op p v0 v1))
-= Steel.PCMReference.gather r v0 v1
-
-val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
-: SteelT (_:unit{composable p x y})
-    ((r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> r `pts_to` op p x y)
-
 let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
@@ -328,14 +57,6 @@ let gather #a #b #p r x y =
   );
   A.change_equal_slprop _ (r `pts_to` op p x y)
 
-val ref_read
-  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
-: Steel b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible p x x')
-
 let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
 : Steel 'b
     (r `pts_to` x)
@@ -355,8 +76,6 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
   ));
   A.return x'
 
-module M = Steel.Memory
-
 let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
 : Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
 = M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, f|))
@@ -370,1110 +89,8 @@ let as_action (#p:vprop)
   A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
   A.return x
 
-val ref_upd
-  (#a:Type) (#b:Type) (#p: pcm b)
-  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-
 let ref_upd r x y f = as_action (ref_upd_act r x y f)
 
-(** A PCM for structs *)
-
-/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
-
-open FStar.FunctionalExtensionality
-open FStar.Classical
-let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-  extensionality 'a 'b f g;
-  forall_intro fg
-
-let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
-  forall k. composable (p k) (x k) (y k)
-
-let prod_op (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: restricted_t 'a 'b
-= on_domain 'a (fun k -> op (p k) (x k) (y k))
-
-let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
-  on_domain 'a (fun k -> one (p k))
-
-let prod_comm (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: Lemma (prod_op p x y == prod_op p y x)
-= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
-
-let prod_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
-: Lemma (prod_comp p x y /\
-         prod_comp p (prod_op p x y) z /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (x k) (y k) /\
-           composable (p k) (op (p k) (x k) (y k)) (z k)) 
-    [SMTPat (p k)]
-  = (p k).assoc (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
-: Lemma (prod_comp p y z /\
-         prod_comp p x (prod_op p y z) /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (y k) (z k) /\
-           composable (p k) (x k) (op (p k) (y k) (z k)))
-    [SMTPat (p k)]
-  = (p k).assoc_r (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
-: Lemma (prod_comp p x (prod_one p) /\
-         prod_op p x (prod_one p) == x)
-= let is_unit k
-  : Lemma (composable (p k) (x k) (prod_one p k))
-    [SMTPat (p k)]
-  = (p k).is_unit (x k)
-  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
-
-let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
-  (exists (k: 'a). True) /\ (forall k. (p k).refine (x k))
-
-let prod_pcm' (p:(k:'a -> pcm ('b k))): FStar.PCM.pcm (restricted_t 'a 'b) = {
-  comm = prod_comm p;
-  FStar.PCM.p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
-  assoc = prod_assoc p;
-  assoc_r = prod_assoc_r p;
-  is_unit = prod_is_unit p;
-  refine = prod_refine p
-}
-
-let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
-  let p' = prod_pcm' p in
-  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
-    x `feq` one p' /\ y `feq` one p'
-  ));
-  //assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
-  p'
-
-let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
-  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
-: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
-
-let field_to_struct_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-: Pure (restricted_t a b)
-  (requires True)
-  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
-= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
-
-let is_unit (#a: Type u#a) (p:pcm a) 
-  (x:a)
-:  Lemma (composable p x p.FStar.PCM.p.one /\
-         op p x p.FStar.PCM.p.one == x)
-= p.is_unit x
-
-let field_to_struct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (p k) (prod_pcm p))
-= mkmorphism
-    (field_to_struct_f p k)
-    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
-    (fun x1 x2 ->
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
-        ())
-
-let struct_to_field_f
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: restricted_t a b)
-: Tot (b k)
-= x k
-
-let struct_to_field
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (prod_pcm p) (p k))
-= mkmorphism
-    (struct_to_field_f p k) ()
-    (fun x1 x2 -> ())
-
-let struct_field_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: restricted_t a b {
-    (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Tot (restricted_t a b)
-= 
-    on_dom a (fun k' ->
-      if k' = k
-      then f (v k) <: b k'
-      else v k'
-    )
-
-let struct_field_lift_fpu_prf
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: restricted_t a b {
-    (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Lemma
-  (let v_new = struct_field_lift_fpu' p k x y f v in
-    (prod_pcm p).refine v_new /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
-    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
-  )
-=
-  let y' = (field_to_struct p k).morph y in
-  let v_new = struct_field_lift_fpu' p k x y f v in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  assert (forall (frame: b k) .
-    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
-    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
-    composable (prod_pcm p) y' frame' /\
-    op (prod_pcm p) frame' y' `feq` v_new
-  ));
-  assert (compatible (prod_pcm p) y' v_new);
-  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
-  ()
-
-let struct_field_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
-= fun v ->
-    struct_field_lift_fpu_prf p k x y f v;
-    struct_field_lift_fpu' p k x y f v
-
-let struct_field
-  (#a: eqtype)
-  (#b: a -> Type u#b)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (connection (prod_pcm p) (p k))
-= mkconnection
-    (field_to_struct p k)
-    (struct_to_field p k)
-    ()
-    (struct_field_lift_fpu p k)
-
-let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (xs: restricted_t a b)
-: restricted_t a b
-= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
-
-let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (xs: restricted_t a b)
-: Lemma (
-    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
-    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
-  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-  
-let addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-
-let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (x:b k) (xs: restricted_t a b)
-: restricted_t a b
-= on_dom a (fun k' -> if k' = k then x else xs k')
-
-let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (x: b k) (xs: restricted_t a b)
-: Lemma
-    (requires xs k == one (p k))
-    (ensures
-      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
-      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
-  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
-
-let unaddr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (prod_pcm p))
-  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
-: Steel unit
-    ((r `pts_to` xs) `star` (r' `pts_to` x))
-    (fun s -> r `pts_to` struct_with_field p k x xs)
-    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
-    (ensures fun _ _ _ -> True)
-= unfocus r' r (struct_field p k) x;
-  gather r xs (field_to_struct_f p k x);
-  struct_unpeel p k x xs;
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  A.return ()
-
-let exclusive_struct_intro
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (x: restricted_t a b)
-: Lemma
-  (requires (
-    forall k . exclusive (p k) (struct_to_field_f p k x)
-  ))
-  (ensures (
-    exclusive (prod_pcm p) x
-  ))
-  [SMTPat (exclusive (prod_pcm p) x)]
-=
-  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
-
-let exclusive_struct_elim
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (x: restricted_t a b)
-  (k: a)
-: Lemma
-  (requires (exclusive (prod_pcm p) x))
-  (ensures (exclusive (p k) (struct_to_field_f p k x)))
-=
-  let phi
-    frame
-  : Lemma
-    (requires (composable (p k) (struct_to_field_f p k x) frame))
-    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
-    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
-  = let x' = struct_to_field_f p k x in
-    let f' = field_to_struct_f p k frame in
-    let psi
-      k'
-    : Lemma
-      (composable (p k') (x k') (f' k'))
-      [SMTPat (composable (p k') (x k') (f' k'))]
-    = if k' = k
-      then ()
-      else is_unit (p k') (x k')
-    in
-    ()
-  in
-  ()
-
-(** A PCM for unions TODO move to proper place *)
-
-open FStar.FunctionalExtensionality
-
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
-  forall k'. ~ (k == k') ==> f k' == one (p k')
-
-let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
-: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
-
-let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
-    (ensures f == one (prod_pcm p))
-= ext f (one (prod_pcm p)) (fun k -> ())
-
-let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
-  (exists (k:'a). True) ==> (exists k. case_refinement_f p k f)
-  (** precondition is there because we don't care if 'a is inhabited *)
-
-let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
-
-let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
-  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
-    [SMTPat (case_refinement_f p k f)]))
-: Lemma (forall (j:'a). goal)
-= let _ = cont in ()
-
-let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
-  (k:'a{case_refinement_f p k f})
-: Lemma (is_union p f)
-= ()
-
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
-  forall j k.
-  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
-  j == k /\ composable (p k) (f k) (g k)
-
-let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (h:(j:'a -> k:'a ->
-    Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures j == k /\ composable (p k) (f k) (g k))
-      [SMTPat (f j); SMTPat (g k)]))
-: Lemma (union_comp p f g)
-= let _ = h in ()
-
-let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
-: Lemma
-    (requires union_comp p f g)
-    (ensures prod_comp p f g)
-    [SMTPat (union_comp p f g)]
-= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
-
-let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p k f /\ f k == one (p k))
-    (ensures f == one (prod_pcm p))
-    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
-= ext f (one (prod_pcm p)) (fun _ -> ())
-
-let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
-    (ensures
-      f == one (prod_pcm p) \/
-      g == one (prod_pcm p) \/ 
-      case_refinement_f p k (prod_op p f g))
-    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
-= let fj_or_gk_one
-  : squash
-      (f j == one (p j) \/ g k == one (p k) ==>
-       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
-  = ()
-  in let fj_gk_both_not_one ()
-  : Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures case_refinement_f p k (prod_op p f g))
-  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
-  in
-  move_requires fj_gk_both_not_one ();
-  assert
-   ((f j == one (p j) \/ g k == one (p k)) ==>
-    f == one (prod_pcm p) \/
-    g == one (prod_pcm p) \/ 
-    case_refinement_f p k (prod_op p f g))
-
-let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
-  let h = prod_op p f g in
-  let goal = is_union p h in
-  union_elim p f goal (fun j ->
-  union_elim p g goal (fun k ->
-  case_refinement_f_op p j k f g;
-  (prod_pcm p).is_unit g));
-  h
-
-let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
-let union_refine (p:(k:'a -> pcm ('b k))) = prod_refine p
-
-let union_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
-: Lemma (union_comp p x y /\
-         union_comp p (union_op p x y) z /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
-
-#restart-solver
-#push-options "--query_stats --z3rlimit 32"
-
-let union_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
-: Lemma (union_comp p y z /\
-         union_comp p x (union_op p y z) /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc_r p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
-
-#pop-options
-
-let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
-: Lemma (union_comp p x (union_one p) /\
-         union_op p x (union_one p) == x)
-= (prod_pcm p).is_unit x
-
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
-  let p' = {
-    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
-    comm = (fun x y -> prod_comm p x y);
-    assoc = union_assoc p;
-    assoc_r = union_assoc_r p;
-    is_unit = union_is_unit p;
-    refine = union_refine p;
-  } in
-  let aux (x:union p) (y:union p{composable p' x y})
-  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-    [SMTPat (op p' x y)]
-  = ext x (one p') (fun k -> let _ = p k in ());
-    ext y (one p') (fun k -> let _ = p k in ())
-  in
-  //assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
-  p'
-
-let field_to_union_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-: Pure (union p)
-  (requires True)
-  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
-= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
-
-let field_to_union
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (p k) (union_pcm p))
-= mkmorphism
-    (field_to_union_f p k)
-    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
-    (fun x1 x2 ->
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
-        ())
-
-let union_to_field_f
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: union p)
-: Tot (b k)
-= x k
-
-let union_to_field
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (union_pcm p) (p k))
-= mkmorphism
-    (union_to_field_f p k) ()
-    (fun x1 x2 -> ())
-
-let union_field_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: union p {
-    (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Tot (union p)
-= 
-    on_dom a (fun k' ->
-      if k' = k
-      then f (v k) <: b k'
-      else one (p k')
-    )
-
-#restart-solver
-#push-options "--z3rlimit 32 --query_stats"
-
-let union_field_lift_fpu_prf
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: union p {
-    (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_union p k).morph x) v
-  })
-: Lemma
-  (let v_new = union_field_lift_fpu' p k x y f v in
-    (union_pcm p).refine v_new /\
-    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
-    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
-       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
-  )
-=
-  let y' = (field_to_union p k).morph y in
-  let v_new = union_field_lift_fpu' p k x y f v in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  let frame : b k = compatible_elim (p k) y (f (v k)) in
-  let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
-  assert (composable (union_pcm p) y' frame');
-  assert (op (union_pcm p) frame' y' `feq` v_new);
-  compatible_intro (union_pcm p) y' v_new frame';
-  let x = Ghost.reveal x in
-  let aux (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame})
-  : Lemma (
-      composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-      (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
-       op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
-  = assert_norm (
-     op (union_pcm p) ((field_to_union p k).morph x) frame k ==
-     op (p k) x (frame k));
-    assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
-       op (p k) x (frame k) == v k)
-  in forall_intro aux; ()
-
-#pop-options
-
-let union_field_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
-= fun v ->
-    union_field_lift_fpu_prf p k x y f v;
-    union_field_lift_fpu' p k x y f v
-
-let union_field
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (connection (union_pcm p) (p k))
-= mkconnection
-    (field_to_union p k)
-    (union_to_field p k)
-    ()
-    (union_field_lift_fpu p k)
-
-let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (xs: union p{~ (xs k == one (p k))})
-: Lemma (xs == field_to_union_f p k (xs k))
-= assert (xs `feq` field_to_union_f p k (xs k))
-
-let addr_of_union_field
-  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
-  (r: ref base (union_pcm p)) (k:a)
-  (xs: Ghost.erased (union p))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun r' -> r' `pts_to` Ghost.reveal xs k)
-    (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
-    (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
-= union_peel p k xs;
-  A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
-  focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
-
-let unaddr_of_union_field
-  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (union_pcm p))
-  (x: Ghost.erased (b k))
-: A.SteelGhost unit opened
-    (r' `pts_to` x)
-    (fun s -> r `pts_to` field_to_union_f p k x)
-    (requires fun _ -> r' == ref_focus r (union_field p k))
-    (ensures fun _ _ _ -> True)
-= unfocus r' r (union_field p k) x
-
-let exclusive_union_intro
-  (#a: Type)
-  (#b: _)
-  (p:(k: a -> pcm (b k)))
-  (x: union p)
-  (k: a)
-: Lemma
-  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
-  (ensures (exclusive (union_pcm p) x))
-= let phi
-    (frame: union p)
-  : Lemma
-    (requires (composable (union_pcm p) x frame))
-    (ensures (frame `feq` union_one p))
-    [SMTPat (composable (union_pcm p) x frame)]
-  = ()
-  in
-  ()
-
-let exclusive_union_elim
-  (#a: eqtype)
-  (#b: _)
-  (p: (k: a -> pcm (b k)))
-  (x: union p)
-  (k: a)
-: Lemma
-  (requires (exclusive (union_pcm p) x))
-  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
-= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
-  then ()
-  else
-    let phi
-      (frame: b k)
-    : Lemma
-      (requires (composable (p k) (x k) frame))
-      (ensures (frame == one (p k)))
-      [SMTPat (composable (p k) (x k) frame)]
-    = let frame' = field_to_union_f p k frame in
-      ()
-    in
-    ()
-
-let base_fpu
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a)
-  (y: a)
-: Pure (frame_preserving_upd p x y)
-  (requires (exclusive p x /\ p.refine y))
-  (ensures (fun _ -> True))
-= fun _ ->
-  Classical.forall_intro (is_unit p);
-  compatible_refl p y;
-  y
-
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let opt_pcm #a : pcm (option a) = {
-  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x == true);
-}
-
-let exclusive_opt
-  (#a: Type)
-  (x: option a)
-: Lemma
-  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
-=
-  match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      assert (composable opt_pcm x (Some y))
-    end else begin
-      let phi
-        (frame: option a)
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some z -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some _ -> ()
-
-let opt_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
-  (y: a)
-: Tot (frame_preserving_upd opt_pcm x (Some y))
-= base_fpu opt_pcm x (Some y)
-
-val opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ _ _ -> True))
-
-let opt_pcm_write
-  r x y
-= ref_upd r x (Some y) (opt_pcm_fpu x y)
-
-val opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-
-let opt_pcm_read
-  r x
-= let y' = ref_read r in
-  assert (Ghost.reveal x == y');
-  Some?.v y'
-
-/// Fractional permissions: from Steel.HigherReference
-open Steel.FractionalPermission
-
-let fractional (a:Type u#1) = option (a & perm)
-
-let fractional_composable #a : symrel (fractional a) =
-  fun (f0 f1:fractional a) ->
-    match f0, f1 with
-    | None, _
-    | _, None -> True
-    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
-
-let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
-  match f0, f1 with
-  | None, f
-  | f, None -> f
-  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
-
-let pcm_frac #a : pcm (fractional a) = {
-  FStar.PCM.p = {
-         composable = fractional_composable;
-         op = fractional_compose;
-         one = None
-      };
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
-}
-
-let frac_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
-  (y: a)
-: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
-= base_fpu pcm_frac x (Some (y, full_perm))
-
-val frac_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
-  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
-  (ensures (fun _ _ _ -> True))
-
-let frac_pcm_write
-  r x y
-= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
-
-val frac_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
-
-let frac_pcm_read
-  r x
-= let y' = ref_read r in
-  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
-  fst (Some?.v y')
-
-let exclusive_frac
-  (#a: Type)
-  (x: option (a & perm))
-: Lemma
-  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
-= match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      let frame = Some (y, full_perm) in
-      assert (~ (frame == one pcm_frac));
-      assert (composable pcm_frac x frame)
-    end else begin
-      let phi
-        (frame: option (a & perm))
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some (z, _) -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some (y, p) ->
-    assert (exists (z: a) . True);
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
-    then ()
-    else begin
-      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
-      assert (composable pcm_frac x frame);
-      assert (~ (frame == one pcm_frac))
-    end
-
-
-/// Uninitialized
-
-noeq
-type uninit_t (a: Type)
-= | Uninitialized
-  | InitOrUnit: a -> uninit_t a
-
-let uninit_composable
-  (#a: Type)
-  (p: pcm a)
-: Tot (symrel (uninit_t a))
-= fun u1 u2 ->
-  match u1, u2 with
-  | Uninitialized, InitOrUnit x
-  | InitOrUnit x, Uninitialized
-    -> x == one p
-  | InitOrUnit x1, InitOrUnit x2
-    -> composable p x1 x2
-  | _ -> False
-
-let uninit_compose
-  (#a: Type)
-  (p: pcm a)
-  (u1: uninit_t a)
-  (u2: uninit_t a { uninit_composable p u1 u2 })
-: Tot (uninit_t a)
-= match u1, u2 with
-  | Uninitialized, _
-  | _, Uninitialized
-    -> Uninitialized
-  | InitOrUnit x1, InitOrUnit x2
-    -> InitOrUnit (op p x1 x2)
-
-let uninit_refine
-  (#a: Type)
-  (p: pcm a)
-  (x: uninit_t a)
-: Tot prop
-= match x with
-  | Uninitialized -> True
-  | InitOrUnit y -> p.refine y
-
-let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
-  FStar.PCM.p = {
-         composable = uninit_composable p;
-         op = uninit_compose p;
-         one = InitOrUnit (one p);
-      };
-  comm = (fun _ _ ->
-    Classical.forall_intro_2 p.comm
-  );
-  assoc = (fun x1 x2 x3 ->
-    Classical.forall_intro_3 p.assoc;
-    Classical.forall_intro (is_unit p)
-  );
-  assoc_r = (fun _ _ _ -> 
-    Classical.forall_intro_3 p.assoc_r;
-    Classical.forall_intro (is_unit p)
-  );
-  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
-  refine = uninit_refine p;
-}
-
-let value_to_uninit
-  (#a: Type)
-  (p: pcm a)
-: Tot (morphism p (pcm_uninit p))
-= mkmorphism
-    (fun x -> InitOrUnit x)
-    ()
-    (fun _ _ -> ())
-
-let uninit_to_value
-  (#a: Type)
-  (p: pcm a)
-: Tot (morphism (pcm_uninit p) p)
-= mkmorphism
-    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
-    ()
-    (fun _ _ -> Classical.forall_intro (is_unit p))
-
-let uninit_conn_fpu'
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-  (v: uninit_t a {
-    (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
-  })
-: Tot (uninit_t a)
-=
-  let InitOrUnit x' = v in
-  InitOrUnit (f x')
-
-let uninit_conn_fpu_prop
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-  (v: uninit_t a {
-    (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
-  })
-: Lemma
-  (let v_new = uninit_conn_fpu' p x y f v in
-    (pcm_uninit p).refine v_new /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
-    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
-  )
-= Classical.forall_intro (is_unit p);
-  let y' = (value_to_uninit p).morph y in
-  let InitOrUnit x' = v in
-  let v_new = uninit_conn_fpu' p x y f v in
-  let frame : a = compatible_elim p y (f x') in
-  let frame' : uninit_t a = InitOrUnit frame in
-  assert (composable (pcm_uninit p) y' frame');
-  assert (op (pcm_uninit p) frame' y' == v_new);
-  compatible_intro (pcm_uninit p) y' v_new frame';
-  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
-  ()
-
-let uninit_conn_fpu
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
-=
-  fun v ->
-    uninit_conn_fpu_prop p x y f v;
-    uninit_conn_fpu' p x y f v
-
-let uninit_conn
-  (#a: Type)
-  (p: pcm a)
-: Tot (connection (pcm_uninit p) p)
-= mkconnection
-    (value_to_uninit p)
-    (uninit_to_value p)
-    ()
-    (uninit_conn_fpu p)
-
-let exclusive_uninit
-  (#a: Type)
-  (p: pcm a)
-  (x: uninit_t a)
-: Lemma
-  (exclusive (pcm_uninit p) x <==> begin match x with
-  | Uninitialized -> True
-  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
-  end)
-= match x with
-  | Uninitialized -> ()
-  | InitOrUnit z ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
-    then begin
-      assert (composable (pcm_uninit p) x Uninitialized)
-    end else
-      let phi2
-        frame
-      : Lemma
-        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
-        (ensures (frame == one p))
-        [SMTPat (composable p z frame)]
-      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
-      in
-      ()
-
-let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
-  (x: a { p x })
-
-noeq
-type sel_view
-  (#carrier: Type u#a)
-  (p: pcm carrier)
-  (view: Type u#b)
-= {
-  to_view_prop: (carrier -> Tot prop);
-  to_view: (refine carrier to_view_prop -> GTot view);
-  to_carrier: (view -> GTot (refine carrier to_view_prop));
-  to_carrier_not_one:
-    (x: view) ->
-    Lemma
-    (~ (to_carrier x == one p));
-  to_view_frame:
-    (x: view) ->
-    (frame: carrier) ->
-    Lemma
-    (requires (composable p (to_carrier x) frame))
-    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
-}
-
-let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
-  (forall x . {:pattern (g (f x))} g (f x) == x)
-
-let sel_view_inv
-  (#carrier: Type u#a)
-  (#p: pcm carrier)
-  (#view: Type u#b)
-  (vw: sel_view p view)
-: Lemma
-  (vw.to_view `g_is_inverse_of` vw.to_carrier)
-  [SMTPat (has_type vw (sel_view p view))]
-= let aux
-    (x: view)
-  : Lemma
-    (vw.to_view (vw.to_carrier x) == x)
-    [SMTPat (vw.to_view (vw.to_carrier x))]
-  = is_unit p (vw.to_carrier x);
-    vw.to_view_frame x (one p)
-  in
-  ()
-
-let pts_to_view_explicit
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (vw: sel_view p c)
-  (v: Ghost.erased c)
-: Tot M.slprop
-= hp_of (pts_to r (vw.to_carrier v))
-
 let pts_to_view_explicit_witinv
   (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
@@ -1481,7 +98,7 @@ let pts_to_view_explicit_witinv
   (vw: sel_view p c)
 : Lemma
   (M.is_witness_invariant (pts_to_view_explicit r vw))
-= 
+= admit() (*
   let aux (x y : Ghost.erased c) (m:M.mem)
   : Lemma
     (requires (M.interp (pts_to_view_explicit r vw x) m /\ M.interp (pts_to_view_explicit r vw y) m))
@@ -1506,259 +123,4 @@ let pts_to_view_explicit_witinv
     ()
   in
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
-
-let pts_to_view_sl
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (vw: sel_view p c)
-: Tot M.slprop
-= M.h_exists (pts_to_view_explicit r vw)
-
-let pts_to_view_sel'
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot (selector' c (pts_to_view_sl r vw))
-= fun h ->
-  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
-  Ghost.reveal (Ghost.reveal x)
-
-let pts_to_view_depends_only_on
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
-: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
-= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
-  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
-  pts_to_view_explicit_witinv r vw;
-  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
-
-let pts_to_view_depends_only_on_core
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (m0:M.hmem (pts_to_view_sl r vw))
-: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
-= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
-  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
-  pts_to_view_explicit_witinv r vw;
-  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
-
-let pts_to_view_sel
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot (selector c (pts_to_view_sl r vw))
-= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
-  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
-  pts_to_view_sel' r vw
-
-[@@__steel_reduce__]
-let pts_to_view'
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot vprop'
-= {
-  hp = pts_to_view_sl r vw;
-  t = c;
-  sel = pts_to_view_sel r vw;
-}
-
-[@@__steel_reduce__]
-let pts_to_view 
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot vprop
-= VUnit (pts_to_view' r vw)
-
-let pts_to_view_intro_lemma
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
-  (m: M.mem)
-: Lemma
-  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
-  (ensures (
-    M.interp (pts_to_view_sl r vw) m /\
-    pts_to_view_sel r vw m == Ghost.reveal y
-  )) 
-=
-  M.intro_h_exists y (pts_to_view_explicit r vw) m;
-  pts_to_view_explicit_witinv r vw
-
-let pts_to_view_intro
-  (#invs: _)
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
-: A.SteelGhost unit invs
-    (pts_to r x)
-    (fun _ -> pts_to_view r vw)
-    (fun _ -> vw.to_carrier y == Ghost.reveal x)
-    (fun _ _ h' ->
-      h' (pts_to_view r vw) == Ghost.reveal y
-    )
-= A.change_slprop_2
-    (pts_to r x)
-    (pts_to_view r vw)
-    y
-    (fun m ->
-      pts_to_view_intro_lemma r x vw y m
-    )
-
-let pts_to_view_elim_lemma
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (m: M.mem)
-: Lemma
-  (requires (M.interp (pts_to_view_sl r vw) m))
-  (ensures (
-    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
-  ))
-=
-  M.elim_h_exists (pts_to_view_explicit r vw) m;
-  pts_to_view_explicit_witinv r vw
-
-/// Introducing a dependent star for [v] and [q]
-let intro_vdep2 (#opened:_)
-  (v: vprop)
-  (q: vprop)
-  (p: (t_of v -> Tot vprop))
-  (x: t_of v)
-: A.SteelGhost unit opened
-    (v `star` q)
-    (fun _ -> vdep v p)
-    (requires (fun h -> h v == x /\ q == p x))
-    (ensures (fun h _ h' ->
-      let x2 = h' (vdep v p) in
-      q == p (h v) /\
-      dfst x2 == (h v) /\
-      dsnd x2 == (h q)
-    ))
-=
-  A.intro_vdep v q p
-
-let pts_to_view_elim
-  (#invs: _)
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: A.SteelGhost (Ghost.erased b) invs
-    (pts_to_view r vw)
-    (fun res -> pts_to r res)
-    (fun _ -> True)
-    (fun h res _ ->
-      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw))
-    )
-=
-  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
-  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
-  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
-  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
-  intro_vdep2
-    (pts_to_view r vw)
-    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
-    f
-    (Ghost.reveal g);
-  A.rewrite_slprop
-    (vdep (pts_to_view r vw) f)
-    (pts_to r res)
-    (fun m ->
-      interp_vdep_hp (pts_to_view r vw) f m;
-      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
-      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
-      pts_to_view_elim_lemma r vw m
-    );
-  res
-
-let opt_view
-  (a: Type)
-: Tot (sel_view (opt_pcm #a) a)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> Some?.v x);
-  to_carrier = (fun z  -> Some z);
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun x frame -> ());
-}
-
-let frac_view
-  (a: Type)
-  (p: perm)
-: Tot (sel_view (pcm_frac #a) a)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> let Some (v, _) = x in v);
-  to_carrier = (fun v -> Some (v, p));
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun v frame -> ());
-}
-
-let uninit_view
-  (#a: Type)
-  (#p: pcm a)
-  (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
-= {
-  to_view_prop = (fun x -> match x with
-  | Uninitialized -> True
-  | InitOrUnit x' -> w.to_view_prop x'
-  );
-  to_view = (fun x -> match x with
-  | Uninitialized -> Uninitialized
-  | InitOrUnit x' -> InitOrUnit (w.to_view x')
-  );
-  to_carrier = (fun v -> match v with
-  | Uninitialized -> Uninitialized
-  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
-  );
-  to_carrier_not_one = (fun v -> match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'
-  );
-  to_view_frame = (fun v frame -> match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
-  );
-}
-
-let uninit_view_initialized
-  (#a: Type)
-  (#p: pcm a)
-  (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
-= {
-  to_view_prop = (fun x -> match x with
-  | Uninitialized -> False
-  | InitOrUnit x' -> w.to_view_prop x'
-  );
-  to_view = (fun x -> match x with
-  | InitOrUnit x' -> w.to_view x'
-  );
-  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
-  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
-  to_view_frame = (fun v frame ->
-    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
-  );
-}
+  *)
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/examples/steel/arraystructs/Steel.C.PCM.fsti
new file mode 100644
index 00000000000..8806d7c9cd9
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.PCM.fsti
@@ -0,0 +1,1648 @@
+module Steel.C.PCM
+open FStar.PCM
+open FStar.FunctionalExtensionality
+
+#push-options "--print_universes"
+
+unfold
+let one (#a: Type) (p: pcm a) = p.p.one
+
+let pcm (a: Type) : Tot Type =
+  (p: FStar.PCM.pcm a {
+    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
+      op p x y == one p ==> x == one p /\ y == one p) // /\ // necessary to lift frame-preserving updates to unions
+    //(forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
+    //(~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+  })
+
+let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
+  (x1: 'a) (x2: 'a{composable pa x1 x2})
+= squash (
+    composable pb (morph x1) (morph x2) /\
+    morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2)
+    
+let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
+  restricted_t (x2:'a{composable pa x1 x2}) (morph_compose2 pa pb morph x1)
+
+noeq
+type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
+  morph: (a ^-> b);
+  morph_unit: squash (morph pa.p.one == pb.p.one);
+  morph_compose: restricted_t a (morph_compose1 pa pb morph);
+}
+
+let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
+  (morph_unit: squash (morph pa.p.one == pb.p.one))
+  (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
+: pa `morphism` pb = {
+  morph = on_dom 'a morph;
+  morph_unit = morph_unit;
+  morph_compose = on_dom 'a (fun x1 -> on_dom (x2:'a{composable pa x1 x2}) (fun x2 -> morph_compose x1 x2));
+}
+
+let morph_compose2_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
+  (x1: 'a) (x2: 'a{composable pa x1 x2})
+  (prf1 prf2: morph_compose2 pa pb morph x1 x2)
+: Lemma (prf1 == prf2)
+= ()
+
+let morph_compose1_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b) (x1: 'a)
+  (prf1 prf2: morph_compose1 pa pb morph x1)
+: Lemma (prf1 == prf2)
+= assert (prf1 `feq` prf2)
+
+let morph_compose_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
+  (prf1 prf2: restricted_t 'a (morph_compose1 pa pb morph))
+: Lemma (prf1 == prf2)
+= let aux (x: 'a): Lemma (prf1 x == prf2 x) [SMTPat (prf1 x)] =
+    morph_compose1_irrelevant pa pb morph x (prf1 x) (prf2 x)
+  in assert (prf1 `feq` prf2)
+
+let morph_eq (f g: 'p `morphism` 'q)
+: Lemma (requires f.morph `feq` g.morph) (ensures f == g)
+  [SMTPat (f.morph `feq` g.morph)]
+= assert (f.morph == g.morph);
+  morph_compose_irrelevant 'p 'q f.morph f.morph_compose g.morph_compose
+
+let morphism_morph_compose
+  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
+  (x1: a)
+  (x2: a)
+: Lemma
+  (requires (composable pa x1 x2))
+  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
+  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
+= m.morph_compose x1 x2
+
+let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) =
+  mkmorphism
+    (fun x -> fbc.morph (fab.morph x))
+    ()
+    (fun x1 x2 ->
+      fab.morph_compose x1 x2;
+      fbc.morph_compose (fab.morph x1) (fab.morph x2))
+
+let compatible_intro
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+  (frame: a)
+: Lemma
+  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (ensures (compatible pcm x y))
+= ()
+
+let compatible_elim
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+: Ghost a
+  (requires (compatible pcm x y))
+  (ensures (fun frame ->
+    composable pcm x frame /\
+    op pcm frame x == y
+  ))
+= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
+    composable pcm x frame /\
+    op pcm frame x == y
+  )
+
+let compatible_morphism
+  (#p: pcm 'a) (#q: pcm 'b)
+  (f: p `morphism` q)
+  (x y: Ghost.erased 'a)
+: Lemma
+    (requires compatible p x y)
+    (ensures compatible q (f.morph x) (f.morph y))
+= let frame_x = compatible_elim p x y in
+  f.morph_compose frame_x x;
+  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
+
+let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
+  (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
+
+let is_inverse_of (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b)) : Tot prop =
+  (forall x . {:pattern (g (f x))} g (f x) == x)
+
+let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
+  x1 x2
+: Lemma
+  (requires (g `is_inverse_of` f /\ f x1 == f x2))
+  (ensures (x1 == x2))
+  [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
+= assert (g (f x1) == g (f x2))
+
+#push-options "--print_universes"
+
+let fpu_lift_dom (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
+   y:Ghost.erased t_small &
+   frame_preserving_upd p_small x y)
+
+let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+: fpu_lift_dom conn_small_to_large -> Type
+= fun (|x, y, f|) ->
+  frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
+     
+let fpu_lift (#t_large:Type) (#t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+: Type
+= restricted_t
+    (fpu_lift_dom conn_small_to_large)
+    (fpu_lift_cod conn_small_to_large)
+
+noeq
+type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
+  conn_small_to_large: morphism p_small p_large;
+  conn_large_to_small: morphism p_large p_small;
+  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
+  conn_lift_frame_preserving_upd: fpu_lift p_large p_small conn_small_to_large;
+}
+
+let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+  (conn_large_to_small: morphism p_large p_small)
+  (conn_small_to_large_inv:
+    squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
+  (conn_lift_frame_preserving_upd:
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
+     y:Ghost.erased t_small ->
+     frame_preserving_upd p_small x y ->
+     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+: connection p_large p_small = {
+  conn_small_to_large = conn_small_to_large;
+  conn_large_to_small = conn_large_to_small;
+  conn_small_to_large_inv = conn_small_to_large_inv;
+  conn_lift_frame_preserving_upd =
+    on_domain
+      (fpu_lift_dom conn_small_to_large)
+      (fun (z: fpu_lift_dom conn_small_to_large) ->
+        let (|x, y, f|) = z in
+	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
+}
+
+let connection_eq (l m: 'p `connection` 'q)
+: Lemma
+    (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
+              l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
+              l.conn_lift_frame_preserving_upd `feq` m.conn_lift_frame_preserving_upd)
+    (ensures l == m)
+= ()
+
+let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
+  mkconnection
+    (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
+    (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
+    ()
+    (fun xc yc f ->
+    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
+    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
+    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
+    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
+    fab.conn_lift_frame_preserving_upd (|xb, yb, fbc.conn_lift_frame_preserving_upd (|xc, yc, f|)|))
+
+noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
+  p: pcm a;
+  pl: connection p q;
+  r: Steel.Memory.ref a p;
+}
+
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+
+open Steel.Effect
+
+val pts_to
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
+: vprop
+
+let ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: ref a q
+= {p = r.p; pl = connection_compose r.pl l; r = r.r}
+
+let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
+: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
+  [SMTPatOr [
+    [SMTPat (ref_focus (ref_focus r l) m)]; 
+    [SMTPat (ref_focus r (l `connection_compose` m))]]]
+= connection_eq
+    ((r.pl `connection_compose` l) `connection_compose` m)
+    (r.pl `connection_compose` (l `connection_compose` m))
+
+module A = Steel.Effect.Atomic
+
+val focus (#p: pcm 'b) (r: ref 'a p)
+  (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ref 'a q)
+    (r `pts_to` s)
+    (fun r' -> r' `pts_to` x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ r' _ -> r' == ref_focus r l)
+
+module M = Steel.Memory
+
+val unfocus (#opened:M.inames)
+  (#p: pcm 'b)
+  (#q: pcm 'c)
+  (r: ref 'a q) (r': ref 'a p)
+  (l: connection p q) (x: Ghost.erased 'c)
+: A.SteelGhost unit opened
+    (r `pts_to` x)
+    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
+    (requires fun _ -> r == ref_focus r' l)
+    (ensures fun _ _ _ -> True)
+
+val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+: Steel unit
+    (r `pts_to` xy)
+    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
+    (fun _ _ _ -> True)
+
+let mgather
+  (#a:Type) (#p:pcm a)
+  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
+: SteelT (_:unit{composable p v0 v1})
+    (mpts_to r v0 `star` mpts_to r v1)
+    (fun _ -> mpts_to r (op p v0 v1))
+= Steel.PCMReference.gather r v0 v1
+
+val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+: SteelT (_:unit{composable p x y})
+    ((r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> r `pts_to` op p x y)
+
+val ref_read
+  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+: Steel b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible p x x')
+
+val ref_upd
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
+
+(** A PCM for structs *)
+
+/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
+
+open FStar.FunctionalExtensionality
+open FStar.Classical
+let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality 'a 'b f g;
+  forall_intro fg
+
+let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
+  forall k. composable (p k) (x k) (y k)
+
+let prod_op (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: restricted_t 'a 'b
+= on_domain 'a (fun k -> op (p k) (x k) (y k))
+
+let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
+  on_domain 'a (fun k -> one (p k))
+
+let prod_comm (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: Lemma (prod_op p x y == prod_op p y x)
+= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
+
+let prod_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+: Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)]
+  = (p k).assoc (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+: Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)]
+  = (p k).assoc_r (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
+: Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+= let is_unit k
+  : Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)]
+  = (p k).is_unit (x k)
+  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
+
+let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
+  (exists (k: 'a). True) /\ (forall k. (p k).refine (x k))
+
+let prod_pcm' (p:(k:'a -> pcm ('b k))): FStar.PCM.pcm (restricted_t 'a 'b) = {
+  comm = prod_comm p;
+  FStar.PCM.p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
+
+let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
+  let p' = prod_pcm' p in
+  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
+    x `feq` one p' /\ y `feq` one p'
+  ));
+  //assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
+  p'
+
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+let field_to_struct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (restricted_t a b)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let is_unit (#a: Type u#a) (p:pcm a) 
+  (x:a)
+:  Lemma (composable p x p.FStar.PCM.p.one /\
+         op p x p.FStar.PCM.p.one == x)
+= p.is_unit x
+
+let field_to_struct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (prod_pcm p))
+= mkmorphism
+    (field_to_struct_f p k)
+    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
+        ())
+
+let struct_to_field_f
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: restricted_t a b)
+: Tot (b k)
+= x k
+
+let struct_to_field
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (prod_pcm p) (p k))
+= mkmorphism
+    (struct_to_field_f p k) ()
+    (fun x1 x2 -> ())
+
+let struct_field_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    (prod_pcm p).refine v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (restricted_t a b)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else v k'
+    )
+
+let struct_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    (prod_pcm p).refine v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Lemma
+  (let v_new = struct_field_lift_fpu' p k x y f v in
+    (prod_pcm p).refine v_new /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
+    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_struct p k).morph y in
+  let v_new = struct_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  assert (forall (frame: b k) .
+    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
+    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
+    composable (prod_pcm p) y' frame' /\
+    op (prod_pcm p) frame' y' `feq` v_new
+  ));
+  assert (compatible (prod_pcm p) y' v_new);
+  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
+  ()
+
+let struct_field_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
+= fun v ->
+    struct_field_lift_fpu_prf p k x y f v;
+    struct_field_lift_fpu' p k x y f v
+
+let struct_field
+  (#a: eqtype)
+  (#b: a -> Type u#b)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (prod_pcm p) (p k))
+= mkconnection
+    (field_to_struct p k)
+    (struct_to_field p k)
+    ()
+    (struct_field_lift_fpu p k)
+
+let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
+
+let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: Lemma (
+    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
+    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+  
+let addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
+let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (x:b k) (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then x else xs k')
+
+let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (x: b k) (xs: restricted_t a b)
+: Lemma
+    (requires xs k == one (p k))
+    (ensures
+      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
+      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
+
+let unaddr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (prod_pcm p))
+  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
+: Steel unit
+    ((r `pts_to` xs) `star` (r' `pts_to` x))
+    (fun s -> r `pts_to` struct_with_field p k x xs)
+    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
+    (ensures fun _ _ _ -> True)
+= unfocus r' r (struct_field p k) x;
+  gather r xs (field_to_struct_f p k x);
+  struct_unpeel p k x xs;
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  A.return ()
+
+let exclusive_struct_intro
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+: Lemma
+  (requires (
+    forall k . exclusive (p k) (struct_to_field_f p k x)
+  ))
+  (ensures (
+    exclusive (prod_pcm p) x
+  ))
+  [SMTPat (exclusive (prod_pcm p) x)]
+=
+  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
+
+let exclusive_struct_elim
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+  (k: a)
+: Lemma
+  (requires (exclusive (prod_pcm p) x))
+  (ensures (exclusive (p k) (struct_to_field_f p k x)))
+=
+  let phi
+    frame
+  : Lemma
+    (requires (composable (p k) (struct_to_field_f p k x) frame))
+    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
+    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
+  = let x' = struct_to_field_f p k x in
+    let f' = field_to_struct_f p k frame in
+    let psi
+      k'
+    : Lemma
+      (composable (p k') (x k') (f' k'))
+      [SMTPat (composable (p k') (x k') (f' k'))]
+    = if k' = k
+      then ()
+      else is_unit (p k') (x k')
+    in
+    ()
+  in
+  ()
+
+(** A PCM for unions TODO move to proper place *)
+
+open FStar.FunctionalExtensionality
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
+  forall k'. ~ (k == k') ==> f k' == one (p k')
+
+let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
+: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
+
+let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
+    (ensures f == one (prod_pcm p))
+= ext f (one (prod_pcm p)) (fun k -> ())
+
+let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
+  (exists (k:'a). True) ==> (exists k. case_refinement_f p k f)
+  (** precondition is there because we don't care if 'a is inhabited *)
+
+let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
+
+let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
+  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
+    [SMTPat (case_refinement_f p k f)]))
+: Lemma (forall (j:'a). goal)
+= let _ = cont in ()
+
+let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
+  (k:'a{case_refinement_f p k f})
+: Lemma (is_union p f)
+= ()
+
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
+  forall j k.
+  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
+  j == k /\ composable (p k) (f k) (g k)
+
+let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (union_comp p f g)
+= let _ = h in ()
+
+let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
+: Lemma
+    (requires union_comp p f g)
+    (ensures prod_comp p f g)
+    [SMTPat (union_comp p f g)]
+= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
+
+let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p k f /\ f k == one (p k))
+    (ensures f == one (prod_pcm p))
+    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
+= ext f (one (prod_pcm p)) (fun _ -> ())
+
+let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
+    (ensures
+      f == one (prod_pcm p) \/
+      g == one (prod_pcm p) \/ 
+      case_refinement_f p k (prod_op p f g))
+    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
+= let fj_or_gk_one
+  : squash
+      (f j == one (p j) \/ g k == one (p k) ==>
+       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
+  = ()
+  in let fj_gk_both_not_one ()
+  : Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures case_refinement_f p k (prod_op p f g))
+  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+  in
+  move_requires fj_gk_both_not_one ();
+  assert
+   ((f j == one (p j) \/ g k == one (p k)) ==>
+    f == one (prod_pcm p) \/
+    g == one (prod_pcm p) \/ 
+    case_refinement_f p k (prod_op p f g))
+
+let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
+  let h = prod_op p f g in
+  let goal = is_union p h in
+  union_elim p f goal (fun j ->
+  union_elim p g goal (fun k ->
+  case_refinement_f_op p j k f g;
+  (prod_pcm p).is_unit g));
+  h
+
+let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
+let union_refine (p:(k:'a -> pcm ('b k))) = prod_refine p
+
+let union_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
+: Lemma (union_comp p x y /\
+         union_comp p (union_op p x y) z /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+#restart-solver
+#push-options "--query_stats --z3rlimit 32"
+
+let union_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
+: Lemma (union_comp p y z /\
+         union_comp p x (union_op p y z) /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc_r p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+#pop-options
+
+let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
+: Lemma (union_comp p x (union_one p) /\
+         union_op p x (union_one p) == x)
+= (prod_pcm p).is_unit x
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
+  let p' = {
+    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
+    comm = (fun x y -> prod_comm p x y);
+    assoc = union_assoc p;
+    assoc_r = union_assoc_r p;
+    is_unit = union_is_unit p;
+    refine = union_refine p;
+  } in
+  let aux (x:union p) (y:union p{composable p' x y})
+  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+    [SMTPat (op p' x y)]
+  = ext x (one p') (fun k -> let _ = p k in ());
+    ext y (one p') (fun k -> let _ = p k in ())
+  in
+  //assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
+  p'
+
+let field_to_union_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (union p)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let field_to_union
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (union_pcm p))
+= mkmorphism
+    (field_to_union_f p k)
+    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
+        ())
+
+let union_to_field_f
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: union p)
+: Tot (b k)
+= x k
+
+let union_to_field
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (union_pcm p) (p k))
+= mkmorphism
+    (union_to_field_f p k) ()
+    (fun x1 x2 -> ())
+
+let union_field_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: union p {
+    (union_pcm p).refine v /\
+    compatible (union_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (union p)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else one (p k')
+    )
+
+#restart-solver
+#push-options "--z3rlimit 32 --query_stats"
+
+let union_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: union p {
+    (union_pcm p).refine v /\
+    compatible (union_pcm p) ((field_to_union p k).morph x) v
+  })
+: Lemma
+  (let v_new = union_field_lift_fpu' p k x y f v in
+    (union_pcm p).refine v_new /\
+    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
+    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
+       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_union p k).morph y in
+  let v_new = union_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  let frame : b k = compatible_elim (p k) y (f (v k)) in
+  let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
+  assert (composable (union_pcm p) y' frame');
+  assert (op (union_pcm p) frame' y' `feq` v_new);
+  compatible_intro (union_pcm p) y' v_new frame';
+  let x = Ghost.reveal x in
+  let aux (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame})
+  : Lemma (
+      composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+      (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
+       op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
+  = assert_norm (
+     op (union_pcm p) ((field_to_union p k).morph x) frame k ==
+     op (p k) x (frame k));
+    assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
+       op (p k) x (frame k) == v k)
+  in forall_intro aux; ()
+
+#pop-options
+
+let union_field_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
+= fun v ->
+    union_field_lift_fpu_prf p k x y f v;
+    union_field_lift_fpu' p k x y f v
+
+let union_field
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (union_pcm p) (p k))
+= mkconnection
+    (field_to_union p k)
+    (union_to_field p k)
+    ()
+    (union_field_lift_fpu p k)
+
+let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: union p{~ (xs k == one (p k))})
+: Lemma (xs == field_to_union_f p k (xs k))
+= assert (xs `feq` field_to_union_f p k (xs k))
+
+let addr_of_union_field
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref base (union_pcm p)) (k:a)
+  (xs: Ghost.erased (union p))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun r' -> r' `pts_to` Ghost.reveal xs k)
+    (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
+    (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
+= union_peel p k xs;
+  A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
+  focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
+
+let unaddr_of_union_field
+  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (union_pcm p))
+  (x: Ghost.erased (b k))
+: A.SteelGhost unit opened
+    (r' `pts_to` x)
+    (fun s -> r `pts_to` field_to_union_f p k x)
+    (requires fun _ -> r' == ref_focus r (union_field p k))
+    (ensures fun _ _ _ -> True)
+= unfocus r' r (union_field p k) x
+
+let exclusive_union_intro
+  (#a: Type)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
+  (ensures (exclusive (union_pcm p) x))
+= let phi
+    (frame: union p)
+  : Lemma
+    (requires (composable (union_pcm p) x frame))
+    (ensures (frame `feq` union_one p))
+    [SMTPat (composable (union_pcm p) x frame)]
+  = ()
+  in
+  ()
+
+let exclusive_union_elim
+  (#a: eqtype)
+  (#b: _)
+  (p: (k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (union_pcm p) x))
+  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
+  then ()
+  else
+    let phi
+      (frame: b k)
+    : Lemma
+      (requires (composable (p k) (x k) frame))
+      (ensures (frame == one (p k)))
+      [SMTPat (composable (p k) (x k) frame)]
+    = let frame' = field_to_union_f p k frame in
+      ()
+    in
+    ()
+
+let base_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a)
+  (y: a)
+: Pure (frame_preserving_upd p x y)
+  (requires (exclusive p x /\ p.refine y))
+  (ensures (fun _ -> True))
+= fun _ ->
+  Classical.forall_intro (is_unit p);
+  compatible_refl p y;
+  y
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x == true);
+}
+
+let exclusive_opt
+  (#a: Type)
+  (x: option a)
+: Lemma
+  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
+=
+  match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      assert (composable opt_pcm x (Some y))
+    end else begin
+      let phi
+        (frame: option a)
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some z -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some _ -> ()
+
+let opt_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
+  (y: a)
+: Tot (frame_preserving_upd opt_pcm x (Some y))
+= base_fpu opt_pcm x (Some y)
+
+let opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ _ _ -> True))
+
+//let opt_pcm_write r x y
+= ref_upd r x (Some y) (opt_pcm_fpu x y)
+
+let opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
+
+//let opt_pcm_read r x
+= let y' = ref_read r in
+  assert (Ghost.reveal x == y');
+  Some?.v y'
+
+/// Fractional permissions: from Steel.HigherReference
+open Steel.FractionalPermission
+
+let fractional (a:Type u#1) = option (a & perm)
+
+let fractional_composable #a : symrel (fractional a) =
+  fun (f0 f1:fractional a) ->
+    match f0, f1 with
+    | None, _
+    | _, None -> True
+    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
+
+let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
+  match f0, f1 with
+  | None, f
+  | f, None -> f
+  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
+
+let pcm_frac #a : pcm (fractional a) = {
+  FStar.PCM.p = {
+         composable = fractional_composable;
+         op = fractional_compose;
+         one = None
+      };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
+}
+
+let frac_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
+  (y: a)
+: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
+= base_fpu pcm_frac x (Some (y, full_perm))
+
+let frac_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
+  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
+  (ensures (fun _ _ _ -> True))
+
+//let frac_pcm_write r x y
+= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
+
+let frac_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
+
+//let frac_pcm_read r x
+= let y' = ref_read r in
+  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
+  fst (Some?.v y')
+
+let exclusive_frac
+  (#a: Type)
+  (x: option (a & perm))
+: Lemma
+  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
+= match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      let frame = Some (y, full_perm) in
+      assert (~ (frame == one pcm_frac));
+      assert (composable pcm_frac x frame)
+    end else begin
+      let phi
+        (frame: option (a & perm))
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some (z, _) -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some (y, p) ->
+    assert (exists (z: a) . True);
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
+    then ()
+    else begin
+      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
+      assert (composable pcm_frac x frame);
+      assert (~ (frame == one pcm_frac))
+    end
+
+
+/// Uninitialized
+
+noeq
+type uninit_t (a: Type)
+= | Uninitialized
+  | InitOrUnit: a -> uninit_t a
+
+let uninit_composable
+  (#a: Type)
+  (p: pcm a)
+: Tot (symrel (uninit_t a))
+= fun u1 u2 ->
+  match u1, u2 with
+  | Uninitialized, InitOrUnit x
+  | InitOrUnit x, Uninitialized
+    -> x == one p
+  | InitOrUnit x1, InitOrUnit x2
+    -> composable p x1 x2
+  | _ -> False
+
+let uninit_compose
+  (#a: Type)
+  (p: pcm a)
+  (u1: uninit_t a)
+  (u2: uninit_t a { uninit_composable p u1 u2 })
+: Tot (uninit_t a)
+= match u1, u2 with
+  | Uninitialized, _
+  | _, Uninitialized
+    -> Uninitialized
+  | InitOrUnit x1, InitOrUnit x2
+    -> InitOrUnit (op p x1 x2)
+
+let uninit_refine
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Tot prop
+= match x with
+  | Uninitialized -> True
+  | InitOrUnit y -> p.refine y
+
+let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
+  FStar.PCM.p = {
+         composable = uninit_composable p;
+         op = uninit_compose p;
+         one = InitOrUnit (one p);
+      };
+  comm = (fun _ _ ->
+    Classical.forall_intro_2 p.comm
+  );
+  assoc = (fun x1 x2 x3 ->
+    Classical.forall_intro_3 p.assoc;
+    Classical.forall_intro (is_unit p)
+  );
+  assoc_r = (fun _ _ _ -> 
+    Classical.forall_intro_3 p.assoc_r;
+    Classical.forall_intro (is_unit p)
+  );
+  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
+  refine = uninit_refine p;
+}
+
+let value_to_uninit
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism p (pcm_uninit p))
+= mkmorphism
+    (fun x -> InitOrUnit x)
+    ()
+    (fun _ _ -> ())
+
+let uninit_to_value
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism (pcm_uninit p) p)
+= mkmorphism
+    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
+    ()
+    (fun _ _ -> Classical.forall_intro (is_unit p))
+
+let uninit_conn_fpu'
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Tot (uninit_t a)
+=
+  let InitOrUnit x' = v in
+  InitOrUnit (f x')
+
+let uninit_conn_fpu_prop
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Lemma
+  (let v_new = uninit_conn_fpu' p x y f v in
+    (pcm_uninit p).refine v_new /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
+    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
+  )
+= Classical.forall_intro (is_unit p);
+  let y' = (value_to_uninit p).morph y in
+  let InitOrUnit x' = v in
+  let v_new = uninit_conn_fpu' p x y f v in
+  let frame : a = compatible_elim p y (f x') in
+  let frame' : uninit_t a = InitOrUnit frame in
+  assert (composable (pcm_uninit p) y' frame');
+  assert (op (pcm_uninit p) frame' y' == v_new);
+  compatible_intro (pcm_uninit p) y' v_new frame';
+  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
+  ()
+
+let uninit_conn_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
+=
+  fun v ->
+    uninit_conn_fpu_prop p x y f v;
+    uninit_conn_fpu' p x y f v
+
+let uninit_conn
+  (#a: Type)
+  (p: pcm a)
+: Tot (connection (pcm_uninit p) p)
+= mkconnection
+    (value_to_uninit p)
+    (uninit_to_value p)
+    ()
+    (uninit_conn_fpu p)
+
+let exclusive_uninit
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Lemma
+  (exclusive (pcm_uninit p) x <==> begin match x with
+  | Uninitialized -> True
+  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
+  end)
+= match x with
+  | Uninitialized -> ()
+  | InitOrUnit z ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
+    then begin
+      assert (composable (pcm_uninit p) x Uninitialized)
+    end else
+      let phi2
+        frame
+      : Lemma
+        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
+        (ensures (frame == one p))
+        [SMTPat (composable p z frame)]
+      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
+      in
+      ()
+
+let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
+  (x: a { p x })
+
+noeq
+type sel_view
+  (#carrier: Type u#a)
+  (p: pcm carrier)
+  (view: Type u#b)
+= {
+  to_view_prop: (carrier -> Tot prop);
+  to_view: (refine carrier to_view_prop -> GTot view);
+  to_carrier: (view -> GTot (refine carrier to_view_prop));
+  to_carrier_not_one:
+    (x: view) ->
+    Lemma
+    (~ (to_carrier x == one p));
+  to_view_frame:
+    (x: view) ->
+    (frame: carrier) ->
+    Lemma
+    (requires (composable p (to_carrier x) frame))
+    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
+}
+
+let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
+  (forall x . {:pattern (g (f x))} g (f x) == x)
+
+let sel_view_inv
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type u#b)
+  (vw: sel_view p view)
+: Lemma
+  (vw.to_view `g_is_inverse_of` vw.to_carrier)
+  [SMTPat (has_type vw (sel_view p view))]
+= let aux
+    (x: view)
+  : Lemma
+    (vw.to_view (vw.to_carrier x) == x)
+    [SMTPat (vw.to_view (vw.to_carrier x))]
+  = is_unit p (vw.to_carrier x);
+    vw.to_view_frame x (one p)
+  in
+  ()
+
+let pts_to_view_explicit
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+  (v: Ghost.erased c)
+: Tot M.slprop
+= hp_of (pts_to r (vw.to_carrier v))
+
+val pts_to_view_explicit_witinv
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Lemma
+  (M.is_witness_invariant (pts_to_view_explicit r vw))
+
+let pts_to_view_sl
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Tot M.slprop
+= M.h_exists (pts_to_view_explicit r vw)
+
+let pts_to_view_sel'
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot (selector' c (pts_to_view_sl r vw))
+= fun h ->
+  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
+  Ghost.reveal (Ghost.reveal x)
+
+let pts_to_view_depends_only_on
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
+
+let pts_to_view_depends_only_on_core
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m0:M.hmem (pts_to_view_sl r vw))
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
+
+let pts_to_view_sel
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot (selector c (pts_to_view_sl r vw))
+= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
+  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
+  pts_to_view_sel' r vw
+
+[@@__steel_reduce__]
+let pts_to_view'
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot vprop'
+= {
+  hp = pts_to_view_sl r vw;
+  t = c;
+  sel = pts_to_view_sel r vw;
+}
+
+[@@__steel_reduce__]
+let pts_to_view 
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot vprop
+= VUnit (pts_to_view' r vw)
+
+let pts_to_view_intro_lemma
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
+  (ensures (
+    M.interp (pts_to_view_sl r vw) m /\
+    pts_to_view_sel r vw m == Ghost.reveal y
+  )) 
+=
+  M.intro_h_exists y (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+let pts_to_view_intro
+  (#invs: _)
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+: A.SteelGhost unit invs
+    (pts_to r x)
+    (fun _ -> pts_to_view r vw)
+    (fun _ -> vw.to_carrier y == Ghost.reveal x)
+    (fun _ _ h' ->
+      h' (pts_to_view r vw) == Ghost.reveal y
+    )
+= A.change_slprop_2
+    (pts_to r x)
+    (pts_to_view r vw)
+    y
+    (fun m ->
+      pts_to_view_intro_lemma r x vw y m
+    )
+
+let pts_to_view_elim_lemma
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (pts_to_view_sl r vw) m))
+  (ensures (
+    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
+  ))
+=
+  M.elim_h_exists (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+/// Introducing a dependent star for [v] and [q]
+let intro_vdep2 (#opened:_)
+  (v: vprop)
+  (q: vprop)
+  (p: (t_of v -> Tot vprop))
+  (x: t_of v)
+: A.SteelGhost unit opened
+    (v `star` q)
+    (fun _ -> vdep v p)
+    (requires (fun h -> h v == x /\ q == p x))
+    (ensures (fun h _ h' ->
+      let x2 = h' (vdep v p) in
+      q == p (h v) /\
+      dfst x2 == (h v) /\
+      dsnd x2 == (h q)
+    ))
+=
+  A.intro_vdep v q p
+
+let pts_to_view_elim
+  (#invs: _)
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: A.SteelGhost (Ghost.erased b) invs
+    (pts_to_view r vw)
+    (fun res -> pts_to r res)
+    (fun _ -> True)
+    (fun h res _ ->
+      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw))
+    )
+=
+  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
+  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
+  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
+  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
+  intro_vdep2
+    (pts_to_view r vw)
+    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
+    f
+    (Ghost.reveal g);
+  A.rewrite_slprop
+    (vdep (pts_to_view r vw) f)
+    (pts_to r res)
+    (fun m ->
+      interp_vdep_hp (pts_to_view r vw) f m;
+      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
+      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
+      pts_to_view_elim_lemma r vw m
+    );
+  res
+
+let opt_view
+  (a: Type)
+: Tot (sel_view (opt_pcm #a) a)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> Some?.v x);
+  to_carrier = (fun z  -> Some z);
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun x frame -> ());
+}
+
+let frac_view
+  (a: Type)
+  (p: perm)
+: Tot (sel_view (pcm_frac #a) a)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> let Some (v, _) = x in v);
+  to_carrier = (fun v -> Some (v, p));
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun v frame -> ());
+}
+
+let uninit_view
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> True
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit x' -> InitOrUnit (w.to_view x')
+  );
+  to_carrier = (fun v -> match v with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
+  );
+  to_carrier_not_one = (fun v -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'
+  );
+  to_view_frame = (fun v frame -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  );
+}
+
+let uninit_view_initialized
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> False
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | InitOrUnit x' -> w.to_view x'
+  );
+  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
+  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
+  to_view_frame = (fun v frame ->
+    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
+  );
+}

From 3b7bfea24bbbf1c0b2c75770bbe7d362aad1942e Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 09:55:48 -0700
Subject: [PATCH 097/513] Finish IntOrBool

---
 examples/steel/arraystructs/IntOrBool.fst    | 123 +++++++++++--------
 examples/steel/arraystructs/IntOrBool.fsti   |  57 +++++----
 examples/steel/arraystructs/Steel.C.PCM.fsti |  20 ++-
 3 files changed, 126 insertions(+), 74 deletions(-)

diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index 214b931abc0..26c662ff1fc 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -1,12 +1,14 @@
 module IntOrBool
 
-open AggregateRef
+#push-options "--print_universes"
+
 open FStar.PCM
-open FStar.PCM.Extras
 open FStar.PCM.POD
+open Steel.C.PCM
 open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
+module U = FStar.Universe
 
 let int_or_bool_cases k = match k with
   | I -> pod int
@@ -15,67 +17,90 @@ let int_or_bool_cases k = match k with
 let int_or_bool_cases_pcm k: pcm (int_or_bool_cases k) = match k with
   | I -> pod_pcm int
   | B -> pod_pcm bool
-let int_or_bool = union int_or_bool_cases_pcm
+  
+let int_or_bool = union #int_or_bool_case #int_or_bool_cases int_or_bool_cases_pcm
+
 let int_or_bool_pcm: pcm int_or_bool = union_pcm int_or_bool_cases_pcm
 
-let mk_int i = Some (|I, Ghost.reveal i|)
-let mk_bool b = Some (|B, Ghost.reveal b|)
+let mk_int i = Ghost.hide (field_to_union_f int_or_bool_cases_pcm I (Ghost.reveal i))
+let mk_bool b = Ghost.hide (field_to_union_f int_or_bool_cases_pcm B (Ghost.reveal b))
 
-let re_i = case_refinement int_or_bool_cases_pcm I
-let re_b = case_refinement int_or_bool_cases_pcm B
+let _i = union_field int_or_bool_cases_pcm I
+let _b = union_field int_or_bool_cases_pcm B
 
-/// Lenses for cases
+open FStar.FunctionalExtensionality
 
-let _i = case int_or_bool_cases_pcm I
-let _b = case int_or_bool_cases_pcm B
+let case_of_int_or_bool u =
+  let k = case_of_union int_or_bool_cases_pcm u in
+  match k with
+  | Some I ->
+    assert (~ (Ghost.reveal u I == one (pod_pcm int)));
+    assert (exists (x:int). (Ghost.reveal u I == Ghost.reveal (some (Ghost.hide x))));
+    assert (exists (x:int). (Ghost.reveal u I == Ghost.reveal (some (Ghost.hide x))) /\ u `feq` mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide x)))));
+    assert (exists i. u == mk_int i); k
+  | Some B -> 
+    assert (~ (Ghost.reveal u B == one (pod_pcm bool)));
+    assert (exists (b:bool). Ghost.reveal u B == Ghost.reveal (some (Ghost.hide b)) /\ u `feq` mk_bool (Ghost.hide (Ghost.reveal (some (Ghost.hide b))))); k
+  | None -> None
+  
+let case_of_int_or_bool_int _ = ()
+let case_of_int_or_bool_bool _ = ()
+let case_of_int_or_bool_one = ()
 
-/// Taking pointers to the i and b cases of an int_or_bool
+let mk_int_exclusive i = exclusive_union_intro int_or_bool_cases_pcm (mk_int i) I
 
-let addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
+let mk_bool_exclusive b = exclusive_union_intro int_or_bool_cases_pcm (mk_bool b) B
+
+let addr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (p: ref 'a int_or_bool_pcm)
+: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
-    (fun q -> q `pts_to` i)
-= let mk_int_i : Ghost.erased (refine_t (refinement_f re_i)) = Some (|I, Ghost.reveal i|) in
-  A.change_equal_slprop (p `pts_to` mk_int i) (p `pts_to` Ghost.reveal mk_int_i);
-  addr_of_union_lens p _i (Ghost.reveal mk_int_i)
+    (fun q -> q `pts_to` Ghost.reveal i)
+= let q = addr_of_union_field p I (mk_int i) in
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
+  A.return q
 
-let unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
+let unaddr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus (ref_refine p re_i) _i})
-: A.SteelGhostT unit opened (q `pts_to` i) (fun _ -> p `pts_to` mk_int i)
-= unaddr_of_union_lens q p _i i
+  (q: ref 'a (pod_pcm int){q == ref_focus p _i})
+: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal i) (fun _ -> p `pts_to` mk_int i)
+= unaddr_of_union_field I q p (Ghost.reveal i);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-let addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
+let addr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (p: ref 'a int_or_bool_pcm)
+: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
     (p `pts_to` mk_bool b)
-    (fun q -> q `pts_to` b)
-= let mk_bool_b : Ghost.erased (refine_t (refinement_f re_b)) = Some (|B, Ghost.reveal b|) in
-  A.change_equal_slprop (p `pts_to` mk_bool b) (p `pts_to` Ghost.reveal mk_bool_b);
-  addr_of_union_lens p _b (Ghost.reveal mk_bool_b)
+    (fun q -> q `pts_to` Ghost.reveal b)
+= let q = addr_of_union_field p B (mk_bool b) in
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
+  A.return q
 
-let unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
+let unaddr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm bool){q == ref_focus (ref_refine p re_b) _b})
-: A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
-= unaddr_of_union_lens q p _b b
-
-/// Switching the case
-
-let switch_to_bool (#i: Ghost.erased int)
-  (p: ref 'a int_or_bool_pcm) (b: bool)
-: SteelT unit (p `pts_to` mk_int (some i)) (fun _ -> p `pts_to` mk_bool (some b))
-= let u: int_or_bool = Some (|B, Some b|) in
-  assume (forall frame.
-    composable int_or_bool_pcm (mk_int (some i)) frame ==> 
-    composable int_or_bool_pcm u frame);
-  assert (valid_write int_or_bool_pcm (mk_int (some i)) u);
-  ref_write p u;
+  (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
+: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal b) (fun _ -> p `pts_to` mk_bool b)
+= unaddr_of_union_field B q p (Ghost.reveal b);
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
-let switch_to_int (#b: Ghost.erased bool)
+let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (Ghost.reveal u)})
   (p: ref 'a int_or_bool_pcm) (i: int)
-: SteelT unit (p `pts_to` mk_bool (some b)) (fun _ -> p `pts_to` mk_int (some i))
-= let u: int_or_bool = Some (|I, Some i|) in
-  assume (valid_write int_or_bool_pcm (mk_bool (some b)) u);
-  ref_write p u;
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+: frame_preserving_upd int_or_bool_pcm u (mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide i)))))
+= base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm I (Some i))
+
+let switch_to_int (#u: Ghost.erased int_or_bool)
+  (p: ref 'a int_or_bool_pcm) (i: int)
+: Steel unit
+    (p `pts_to` u)
+    (fun _ -> p `pts_to` mk_int (Ghost.hide (Ghost.reveal (some i))))
+    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (ensures fun _ _ _ -> True)
+= ref_upd p _ _ (switch_to_int_fpu p i)
+
+let switch_to_bool (#u: Ghost.erased int_or_bool)
+  (p: ref 'a int_or_bool_pcm) (b: bool)
+: Steel unit
+    (p `pts_to` u)
+    (fun _ -> p `pts_to` mk_bool (Ghost.hide (Ghost.reveal (some b))))
+    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (ensures fun _ _ _ -> True)
+= ref_upd p u (mk_bool (Ghost.hide (Ghost.reveal (some (Ghost.hide b)))))
+    (base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm B (Some b)))
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 88433857388..878c011efec 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -13,7 +13,7 @@ module A = Steel.Effect.Atomic
 
 type int_or_bool_case = | I | B
 
-val int_or_bool: Type
+val int_or_bool: Type0
 
 /// PCM for node:
 
@@ -22,8 +22,10 @@ val int_or_bool_pcm: pcm int_or_bool
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
 
-val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
-val mk_bool (i: Ghost.erased (pod bool)): Ghost.erased int_or_bool
+let nonunit (p: pcm 'a) = x:'a{~ (x == one p)}
+
+val mk_int (i: Ghost.erased (nonunit (pod_pcm int))): Ghost.erased int_or_bool
+val mk_bool (b: Ghost.erased (nonunit (pod_pcm bool))): Ghost.erased int_or_bool
 
 /// Connections for cases
 
@@ -32,39 +34,52 @@ val _b : int_or_bool_pcm `connection` pod_pcm bool
 
 /// Getting the case of a union in GTot
 
-// Construct using strong LEM
-val case_of_int_or_bool (u: Ghost.erased int_or_bool): GTot (option int_or_bool_case)
+val case_of_int_or_bool (u: Ghost.erased int_or_bool):
+  GTot (k:option int_or_bool_case{
+    match k with
+    | Some I -> exists i. u == mk_int i
+    | Some B -> exists b. u == mk_bool b
+    | None -> Ghost.reveal u == one int_or_bool_pcm
+  })
 
-val case_of_int_or_bool_int (i: Ghost.erased (pod int))
+val case_of_int_or_bool_int (i: Ghost.erased (nonunit (pod_pcm int)))
 : Lemma (case_of_int_or_bool (mk_int i) == Some I) [SMTPat (mk_int i)]
 
-val case_of_int_or_bool_bool (b: Ghost.erased (pod bool))
+val case_of_int_or_bool_bool (b: Ghost.erased (nonunit (pod_pcm bool)))
 : Lemma (case_of_int_or_bool (mk_bool b) == Some B) [SMTPat (mk_bool b)]
 
 val case_of_int_or_bool_one
 : squash (case_of_int_or_bool (one int_or_bool_pcm) == None)
 
+val mk_int_exclusive (i: Ghost.erased (nonunit (pod_pcm int)))
+: Lemma (requires exclusive (pod_pcm int) i) (ensures exclusive int_or_bool_pcm (mk_int i))
+  [SMTPat (exclusive (pod_pcm int) i)]
+
+val mk_bool_exclusive (b: Ghost.erased (nonunit (pod_pcm bool)))
+: Lemma (requires exclusive (pod_pcm bool) b) (ensures exclusive int_or_bool_pcm (mk_bool b))
+  [SMTPat (exclusive (pod_pcm bool) b)]
+
 /// Taking pointers to the i and b cases of an int_or_bool
 
-val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
+val addr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (p: ref 'a int_or_bool_pcm)
 : SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
-    (fun q -> q `pts_to` i)
+    (fun q -> q `pts_to` Ghost.reveal i)
 
-val unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
+val unaddr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm int){q == ref_focus p _i})
-: A.SteelGhostT unit opened (q `pts_to` i) (fun _ -> p `pts_to` mk_int i)
+: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal i) (fun _ -> p `pts_to` mk_int i)
 
-val addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
+val addr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (p: ref 'a int_or_bool_pcm)
 : SteelT (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
     (p `pts_to` mk_bool b)
-    (fun q -> q `pts_to` b)
+    (fun q -> q `pts_to` Ghost.reveal b)
 
-val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
+val unaddr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
-: A.SteelGhostT unit opened (q `pts_to` b) (fun _ -> p `pts_to` mk_bool b)
+: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal b) (fun _ -> p `pts_to` mk_bool b)
 
 /// Switching the case
 
@@ -72,14 +87,14 @@ val switch_to_int (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : Steel unit
     (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_int (some i))
-    (requires fun _ -> Some? (case_of_int_or_bool u))
-    (requires fun _ _ _ -> True)
+    (fun _ -> p `pts_to` mk_int (Ghost.hide (Ghost.reveal (some i))))
+    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (ensures fun _ _ _ -> True)
 
 val switch_to_bool (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (b: bool)
 : Steel unit
     (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_bool (some b))
-    (requires fun _ -> Some? (case_of_int_or_bool u))
-    (requires fun _ _ _ -> True)
+    (fun _ -> p `pts_to` mk_bool (Ghost.hide (Ghost.reveal (some b))))
+    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (ensures fun _ _ _ -> True)
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/examples/steel/arraystructs/Steel.C.PCM.fsti
index 8806d7c9cd9..110913bb242 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fsti
+++ b/examples/steel/arraystructs/Steel.C.PCM.fsti
@@ -635,11 +635,11 @@ let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a
     (ensures f == one (prod_pcm p))
 = ext f (one (prod_pcm p)) (fun k -> ())
 
-let is_union (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b) =
-  (exists (k:'a). True) ==> (exists k. case_refinement_f p k f)
+let is_union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) (f: restricted_t a b) =
+  (exists (k:a). True) ==> (exists k. case_refinement_f p k f)
   (** precondition is there because we don't care if 'a is inhabited *)
 
-let union (p:(k:'a -> pcm ('b k))) = f:restricted_t 'a 'b{is_union p f}
+let union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) = f:restricted_t a b{is_union p f}
 
 let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
   (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
@@ -931,6 +931,18 @@ let unaddr_of_union_field
     (ensures fun _ _ _ -> True)
 = unfocus r' r (union_field p k) x
 
+module I = FStar.IndefiniteDescription
+
+let case_of_union (p:(k:'a -> pcm ('b k))) (u: union p)
+: GTot (k:option 'a{match k with Some k -> ~ (u k == one (p k)) | None -> u == one (union_pcm p)})
+= if I.strong_excluded_middle (exists k. ~ (u k == one (p k))) then
+    let k = I.indefinite_description_ghost 'a (fun k -> ~ (u k == one (p k))) in
+    Some k
+  else begin
+    assert (u `feq` one (union_pcm p));
+    None
+  end
+
 let exclusive_union_intro
   (#a: Type)
   (#b: _)
@@ -1001,7 +1013,7 @@ let opt_pcm #a : pcm (option a) = {
   assoc = (fun _ _ _ -> ());
   assoc_r = (fun _ _ _ -> ());
   is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x == true);
+  refine = (fun x -> Some? x == true \/ None? x);
 }
 
 let exclusive_opt

From 060ae070e394f20039821047edd11c1d590d9a6a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 11:14:01 -0700
Subject: [PATCH 098/513] Split Steel.C.PCM into multiple modules

---
 .../arraystructs/AggregateRefExamples.fst     |   35 +-
 examples/steel/arraystructs/IntOrBool.fst     |    4 +-
 examples/steel/arraystructs/IntOrBool.fsti    |    4 +-
 .../steel/arraystructs/Steel.C.Connection.fst |  193 ++
 examples/steel/arraystructs/Steel.C.Frac.fst  |   10 +
 examples/steel/arraystructs/Steel.C.Opt.fst   |   81 +
 examples/steel/arraystructs/Steel.C.PCM.fst   |  132 +-
 examples/steel/arraystructs/Steel.C.PCM.fsti  | 1660 -----------------
 examples/steel/arraystructs/Steel.C.Ref.fst   |  126 ++
 examples/steel/arraystructs/Steel.C.Ref.fsti  |  765 ++++++++
 .../steel/arraystructs/Steel.C.Struct.fst     |  334 ++++
 examples/steel/arraystructs/Steel.C.Union.fst |  376 ++++
 examples/steel/arraystructs/Steel.PCM.fst     |   12 +
 13 files changed, 1913 insertions(+), 1819 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Connection.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Frac.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Opt.fst
 delete mode 100644 examples/steel/arraystructs/Steel.C.PCM.fsti
 create mode 100644 examples/steel/arraystructs/Steel.C.Ref.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Ref.fsti
 create mode 100644 examples/steel/arraystructs/Steel.C.Struct.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Union.fst
 create mode 100644 examples/steel/arraystructs/Steel.PCM.fst

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 282c81a0c18..f7c1d2c736a 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -117,43 +117,11 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
   unaddr_of_p2 p pp2;
   A.return ()
 
-/// Struct with potentially uninitialized values
-///
-/// Unions of scalars with tag type (e.g. int_or_bool)
-/// "Functional" model of struct data
-///
-/// Examples (linked list w/ mutable elements)?
-///   noeq type cell : Type0 = {
-///     value: int;
-///     next: ref (FStar.Universe.raise_t cell) cell
-///   }
-///
-/// Can also define bounded-lists
-///   let rec bounded_list (n: Ghost.erased nat): Tot Type0 (decreases (Ghost.reveal n)) =
-///   if Ghost.reveal n = 0 then False
-///   else (int & option (ref (FStar.Universe.raise_t (bounded_list (n - 1))) (bounded_list (n - 1))))
-///
-/// Unions with these structs in them
-///   May need particular functional style for unions because can't reason by unification on result of if-then-else
-/// 
-/// Specialized read and write
-/// 
-///   p: pcm a
-///   a is the carrier
-///   secretly: a type b of values that we actually care about
-///   lens a (option b)?
-///   pcm_lens a (opt_pcm b)?
-///
-///   read:
-///     p `pts_to` (x: a)
-///    extract x = Some (v, _)
-
 /// Swap two ints inside two (union int_or_bool)s using generic_swap
 ///
 /// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
 /// { generic_swap(&p.i, &q.i); }
 
-(*
 open IntOrBool
 let int_or_bool_int_swap
   (p: ref 'a int_or_bool_pcm) (q: ref 'b int_or_bool_pcm)
@@ -170,6 +138,7 @@ let int_or_bool_int_swap
   (* Give permissions back to p and q *)
   unaddr_of_i p pi;
   unaddr_of_i q qi
+
 /// Convert an int_or_bool + runtime tag into an int
 ///
 /// int int_or_bool_to_int(bool *is_int, union int_or_bool *p) {
@@ -202,7 +171,7 @@ val int_or_bool_to_int
     //A.return (if b then 1 else 0)
   end
 *)
-*)
+
 //let int_or_bool_to_int
 //  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
 //  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index 26c662ff1fc..007c3d1d67d 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -91,7 +91,7 @@ let switch_to_int (#u: Ghost.erased int_or_bool)
 : Steel unit
     (p `pts_to` u)
     (fun _ -> p `pts_to` mk_int (Ghost.hide (Ghost.reveal (some i))))
-    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
 = ref_upd p _ _ (switch_to_int_fpu p i)
 
@@ -100,7 +100,7 @@ let switch_to_bool (#u: Ghost.erased int_or_bool)
 : Steel unit
     (p `pts_to` u)
     (fun _ -> p `pts_to` mk_bool (Ghost.hide (Ghost.reveal (some b))))
-    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
 = ref_upd p u (mk_bool (Ghost.hide (Ghost.reveal (some (Ghost.hide b)))))
     (base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm B (Some b)))
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 878c011efec..89700769228 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -88,7 +88,7 @@ val switch_to_int (#u: Ghost.erased int_or_bool)
 : Steel unit
     (p `pts_to` u)
     (fun _ -> p `pts_to` mk_int (Ghost.hide (Ghost.reveal (some i))))
-    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
 
 val switch_to_bool (#u: Ghost.erased int_or_bool)
@@ -96,5 +96,5 @@ val switch_to_bool (#u: Ghost.erased int_or_bool)
 : Steel unit
     (p `pts_to` u)
     (fun _ -> p `pts_to` mk_bool (Ghost.hide (Ghost.reveal (some b))))
-    (requires fun _ -> Some? (case_of_int_or_bool u) /\ exclusive int_or_bool_pcm u)
+    (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
diff --git a/examples/steel/arraystructs/Steel.C.Connection.fst b/examples/steel/arraystructs/Steel.C.Connection.fst
new file mode 100644
index 00000000000..94c2eed1b34
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Connection.fst
@@ -0,0 +1,193 @@
+module Steel.C.Connection
+
+open FStar.PCM
+open Steel.C.PCM
+open FStar.FunctionalExtensionality
+
+let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
+  (x1: 'a) (x2: 'a{composable pa x1 x2})
+= squash (
+    composable pb (morph x1) (morph x2) /\
+    morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2)
+    
+let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
+  restricted_t (x2:'a{composable pa x1 x2}) (morph_compose2 pa pb morph x1)
+
+noeq
+type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
+  morph: (a ^-> b);
+  morph_unit: squash (morph pa.p.one == pb.p.one);
+  morph_compose: restricted_t a (morph_compose1 pa pb morph);
+}
+
+let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
+  (morph_unit: squash (morph pa.p.one == pb.p.one))
+  (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
+: pa `morphism` pb = {
+  morph = on_dom 'a morph;
+  morph_unit = morph_unit;
+  morph_compose = on_dom 'a (fun x1 -> on_dom (x2:'a{composable pa x1 x2}) (fun x2 -> morph_compose x1 x2));
+}
+
+let morph_compose2_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
+  (x1: 'a) (x2: 'a{composable pa x1 x2})
+  (prf1 prf2: morph_compose2 pa pb morph x1 x2)
+: Lemma (prf1 == prf2)
+= ()
+
+let morph_compose1_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b) (x1: 'a)
+  (prf1 prf2: morph_compose1 pa pb morph x1)
+: Lemma (prf1 == prf2)
+= assert (prf1 `feq` prf2)
+
+let morph_compose_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
+  (prf1 prf2: restricted_t 'a (morph_compose1 pa pb morph))
+: Lemma (prf1 == prf2)
+= let aux (x: 'a): Lemma (prf1 x == prf2 x) [SMTPat (prf1 x)] =
+    morph_compose1_irrelevant pa pb morph x (prf1 x) (prf2 x)
+  in assert (prf1 `feq` prf2)
+
+let morph_eq (f g: 'p `morphism` 'q)
+: Lemma (requires f.morph `feq` g.morph) (ensures f == g)
+  [SMTPat (f.morph `feq` g.morph)]
+= assert (f.morph == g.morph);
+  morph_compose_irrelevant 'p 'q f.morph f.morph_compose g.morph_compose
+
+let morphism_morph_compose
+  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
+  (x1: a)
+  (x2: a)
+: Lemma
+  (requires (composable pa x1 x2))
+  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
+  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
+= m.morph_compose x1 x2
+
+let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) =
+  mkmorphism
+    (fun x -> fbc.morph (fab.morph x))
+    ()
+    (fun x1 x2 ->
+      fab.morph_compose x1 x2;
+      fbc.morph_compose (fab.morph x1) (fab.morph x2))
+
+let compatible_intro
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+  (frame: a)
+: Lemma
+  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (ensures (compatible pcm x y))
+= ()
+
+let compatible_elim
+  (#a: Type u#a)
+  (pcm: pcm a)
+  (x y: a)
+: Ghost a
+  (requires (compatible pcm x y))
+  (ensures (fun frame ->
+    composable pcm x frame /\
+    op pcm frame x == y
+  ))
+= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
+    composable pcm x frame /\
+    op pcm frame x == y
+  )
+
+let compatible_morphism
+  (#p: pcm 'a) (#q: pcm 'b)
+  (f: p `morphism` q)
+  (x y: Ghost.erased 'a)
+: Lemma
+    (requires compatible p x y)
+    (ensures compatible q (f.morph x) (f.morph y))
+= let frame_x = compatible_elim p x y in
+  f.morph_compose frame_x x;
+  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
+
+let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
+  (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
+
+let is_inverse_of (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b)) : Tot prop =
+  (forall x . {:pattern (g (f x))} g (f x) == x)
+
+let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
+  x1 x2
+: Lemma
+  (requires (g `is_inverse_of` f /\ f x1 == f x2))
+  (ensures (x1 == x2))
+  [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
+= assert (g (f x1) == g (f x2))
+
+#push-options "--print_universes"
+
+let fpu_lift_dom (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
+   y:Ghost.erased t_small &
+   frame_preserving_upd p_small x y)
+
+let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+: fpu_lift_dom conn_small_to_large -> Type
+= fun (|x, y, f|) ->
+  frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
+     
+let fpu_lift (#t_large:Type) (#t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+: Type
+= restricted_t
+    (fpu_lift_dom conn_small_to_large)
+    (fpu_lift_cod conn_small_to_large)
+
+noeq
+type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
+  conn_small_to_large: morphism p_small p_large;
+  conn_large_to_small: morphism p_large p_small;
+  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
+  conn_lift_frame_preserving_upd: fpu_lift p_large p_small conn_small_to_large;
+}
+
+let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+  (conn_large_to_small: morphism p_large p_small)
+  (conn_small_to_large_inv:
+    squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
+  (conn_lift_frame_preserving_upd:
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
+     y:Ghost.erased t_small ->
+     frame_preserving_upd p_small x y ->
+     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+: connection p_large p_small = {
+  conn_small_to_large = conn_small_to_large;
+  conn_large_to_small = conn_large_to_small;
+  conn_small_to_large_inv = conn_small_to_large_inv;
+  conn_lift_frame_preserving_upd =
+    on_domain
+      (fpu_lift_dom conn_small_to_large)
+      (fun (z: fpu_lift_dom conn_small_to_large) ->
+        let (|x, y, f|) = z in
+	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
+}
+
+let connection_eq (l m: 'p `connection` 'q)
+: Lemma
+    (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
+              l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
+              l.conn_lift_frame_preserving_upd `feq` m.conn_lift_frame_preserving_upd)
+    (ensures l == m)
+= ()
+
+let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
+  mkconnection
+    (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
+    (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
+    ()
+    (fun xc yc f ->
+    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
+    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
+    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
+    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
+    fab.conn_lift_frame_preserving_upd (|xb, yb, fbc.conn_lift_frame_preserving_upd (|xc, yc, f|)|))
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fst b/examples/steel/arraystructs/Steel.C.Frac.fst
new file mode 100644
index 00000000000..a5d6706b479
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Frac.fst
@@ -0,0 +1,10 @@
+module Steel.C.Frac
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Ref
+open Steel.C.Opt
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fst b/examples/steel/arraystructs/Steel.C.Opt.fst
new file mode 100644
index 00000000000..ab17d1c3ea6
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Opt.fst
@@ -0,0 +1,81 @@
+module Steel.C.Opt
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Ref
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x == true);
+}
+
+let exclusive_opt
+  (#a: Type)
+  (x: option a)
+: Lemma
+  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
+=
+  match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      assert (composable opt_pcm x (Some y))
+    end else begin
+      let phi
+        (frame: option a)
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some z -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some _ -> ()
+
+let opt_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
+  (y: a)
+: Tot (frame_preserving_upd opt_pcm x (Some y))
+= base_fpu opt_pcm x (Some y)
+
+let opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ _ _ -> True))
+
+//let opt_pcm_write r x y
+= ref_upd r x (Some y) (opt_pcm_fpu x y)
+
+let opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
+
+//let opt_pcm_read r x
+= let y' = ref_read r in
+  assert (Ghost.reveal x == y');
+  Some?.v y'
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 045cef10905..62d8319ebfa 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,126 +1,14 @@
 module Steel.C.PCM
-module P = FStar.PCM
+open FStar.PCM
 open FStar.FunctionalExtensionality
 
-#push-options "--print_universes"
+unfold
+let one (#a: Type) (p: pcm a) = p.p.one
 
-let pts_to r v =
-  r.r `mpts_to` r.pl.conn_small_to_large.morph v
-
-let focus r l s x =
-  let r' = ref_focus r l in
-  A.change_slprop_rel  
-    (r `pts_to` s)
-    (r' `pts_to` x)
-    (fun _ _ -> True)
-    (fun m -> ());
-  A.return r'
-
-let unfocus r r' l x =
-  A.change_slprop_rel  
-    (r `pts_to` x)
-    (r' `pts_to` l.conn_small_to_large.morph x)
-    (fun _ _ -> True)
-    (fun m -> ())
-
-let split r xy x y =
-  A.change_equal_slprop
-    (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph xy)));
-  Steel.PCMReference.split r.r
-    (r.pl.conn_small_to_large.morph xy)
-    (r.pl.conn_small_to_large.morph x)
-    (r.pl.conn_small_to_large.morph y);
-  A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)))
-    (r `pts_to` x);
-  A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
-    (r `pts_to` y)
-
-let gather #a #b #p r x y =
-  A.change_equal_slprop
-    (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)));
-  A.change_equal_slprop
-    (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)));
-  mgather r.r
-    (r.pl.conn_small_to_large.morph x)
-    (r.pl.conn_small_to_large.morph y);
-  assert (
-    let x1 = r.pl.conn_small_to_large.morph x in
-    let y1 = r.pl.conn_small_to_large.morph y in
-    let x2 = r.pl.conn_large_to_small.morph x1 in
-    let y2 = r.pl.conn_large_to_small.morph y1 in
-    Ghost.reveal x == x2 /\ Ghost.reveal y == y2
-  );
-  A.change_equal_slprop _ (r `pts_to` op p x y)
-
-let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
-: Steel 'b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible p x x')
-= let w = Ghost.hide (r.pl.conn_small_to_large.morph x) in
-  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
-  let w' = Steel.PCMReference.read r.r w in
-  A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
-  let x' = r.pl.conn_large_to_small.morph w' in
-  assert (forall frame . (composable r.p w frame /\ op r.p frame w == w') ==> (
-    let sw = r.pl.conn_large_to_small.morph w in
-    let sw' = r.pl.conn_large_to_small.morph w' in
-    let sframe = r.pl.conn_large_to_small.morph frame in
-    (composable p sw sframe /\ op p sframe sw == sw')
-  ));
-  A.return x'
-
-let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
-: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, f|))
-
-let as_action (#p:vprop)
-              (#q:vprop)
-              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
-: SteelT unit p (fun x -> q)
-= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
-  let x = Steel.Effect.as_action f in
-  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
-  A.return x
-
-let ref_upd r x y f = as_action (ref_upd_act r x y f)
-
-let pts_to_view_explicit_witinv
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (vw: sel_view p c)
-: Lemma
-  (M.is_witness_invariant (pts_to_view_explicit r vw))
-= admit() (*
-  let aux (x y : Ghost.erased c) (m:M.mem)
-  : Lemma
-    (requires (M.interp (pts_to_view_explicit r vw x) m /\ M.interp (pts_to_view_explicit r vw y) m))
-    (ensures  (x == y))
-  =
-    let x_ = vw.to_carrier x in
-    let y_ = vw.to_carrier y in
-    let x' = r.pl.conn_small_to_large.morph x_ in
-    let y' = r.pl.conn_small_to_large.morph y_ in
-    M.pts_to_join r.r x' y' m;
-    let z' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun z' -> compatible r.p x' z' /\ compatible r.p y' z') in
-    let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_x' -> composable r.p x' frame_x' /\ op r.p frame_x' x' == z') in
-    let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_y' -> composable r.p y' frame_y' /\ op r.p frame_y' y' == z') in
-    let frame_x_ = r.pl.conn_large_to_small.morph frame_x' in
-    let frame_y_ = r.pl.conn_large_to_small.morph frame_y' in
-    r.p.comm x' frame_x';
-    r.pl.conn_large_to_small.morph_compose x' frame_x';
-    vw.to_view_frame x (r.pl.conn_large_to_small.morph frame_x');
-    r.p.comm y' frame_y';
-    r.pl.conn_large_to_small.morph_compose y' frame_y';
-    vw.to_view_frame y (r.pl.conn_large_to_small.morph frame_y');
-    ()
-  in
-  Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
-  *)
+let pcm (a: Type) : Tot Type =
+  (p: FStar.PCM.pcm a {
+    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
+      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
+    (forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
+    (~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+  })
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/examples/steel/arraystructs/Steel.C.PCM.fsti
deleted file mode 100644
index 110913bb242..00000000000
--- a/examples/steel/arraystructs/Steel.C.PCM.fsti
+++ /dev/null
@@ -1,1660 +0,0 @@
-module Steel.C.PCM
-open FStar.PCM
-open FStar.FunctionalExtensionality
-
-#push-options "--print_universes"
-
-unfold
-let one (#a: Type) (p: pcm a) = p.p.one
-
-let pcm (a: Type) : Tot Type =
-  (p: FStar.PCM.pcm a {
-    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
-      op p x y == one p ==> x == one p /\ y == one p) // /\ // necessary to lift frame-preserving updates to unions
-    //(forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
-    //(~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
-  })
-
-let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
-  (x1: 'a) (x2: 'a{composable pa x1 x2})
-= squash (
-    composable pb (morph x1) (morph x2) /\
-    morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2)
-    
-let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
-  restricted_t (x2:'a{composable pa x1 x2}) (morph_compose2 pa pb morph x1)
-
-noeq
-type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
-  morph: (a ^-> b);
-  morph_unit: squash (morph pa.p.one == pb.p.one);
-  morph_compose: restricted_t a (morph_compose1 pa pb morph);
-}
-
-let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
-  (morph_unit: squash (morph pa.p.one == pb.p.one))
-  (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
-: pa `morphism` pb = {
-  morph = on_dom 'a morph;
-  morph_unit = morph_unit;
-  morph_compose = on_dom 'a (fun x1 -> on_dom (x2:'a{composable pa x1 x2}) (fun x2 -> morph_compose x1 x2));
-}
-
-let morph_compose2_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
-  (x1: 'a) (x2: 'a{composable pa x1 x2})
-  (prf1 prf2: morph_compose2 pa pb morph x1 x2)
-: Lemma (prf1 == prf2)
-= ()
-
-let morph_compose1_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b) (x1: 'a)
-  (prf1 prf2: morph_compose1 pa pb morph x1)
-: Lemma (prf1 == prf2)
-= assert (prf1 `feq` prf2)
-
-let morph_compose_irrelevant (pa: pcm 'a) (pb: pcm 'b) (morph: 'a ^-> 'b)
-  (prf1 prf2: restricted_t 'a (morph_compose1 pa pb morph))
-: Lemma (prf1 == prf2)
-= let aux (x: 'a): Lemma (prf1 x == prf2 x) [SMTPat (prf1 x)] =
-    morph_compose1_irrelevant pa pb morph x (prf1 x) (prf2 x)
-  in assert (prf1 `feq` prf2)
-
-let morph_eq (f g: 'p `morphism` 'q)
-: Lemma (requires f.morph `feq` g.morph) (ensures f == g)
-  [SMTPat (f.morph `feq` g.morph)]
-= assert (f.morph == g.morph);
-  morph_compose_irrelevant 'p 'q f.morph f.morph_compose g.morph_compose
-
-let morphism_morph_compose
-  (#a #b: Type) (#pa: pcm a) (#pb: pcm b) (m: morphism pa pb)
-  (x1: a)
-  (x2: a)
-: Lemma
-  (requires (composable pa x1 x2))
-  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
-  [SMTPat (composable pb (m.morph x1) (m.morph x2))]
-= m.morph_compose x1 x2
-
-let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc) : Tot (morphism pa pc) =
-  mkmorphism
-    (fun x -> fbc.morph (fab.morph x))
-    ()
-    (fun x1 x2 ->
-      fab.morph_compose x1 x2;
-      fbc.morph_compose (fab.morph x1) (fab.morph x2))
-
-let compatible_intro
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-  (frame: a)
-: Lemma
-  (requires (composable pcm x frame /\ op pcm frame x == y))
-  (ensures (compatible pcm x y))
-= ()
-
-let compatible_elim
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-: Ghost a
-  (requires (compatible pcm x y))
-  (ensures (fun frame ->
-    composable pcm x frame /\
-    op pcm frame x == y
-  ))
-= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
-    composable pcm x frame /\
-    op pcm frame x == y
-  )
-
-let compatible_morphism
-  (#p: pcm 'a) (#q: pcm 'b)
-  (f: p `morphism` q)
-  (x y: Ghost.erased 'a)
-: Lemma
-    (requires compatible p x y)
-    (ensures compatible q (f.morph x) (f.morph y))
-= let frame_x = compatible_elim p x y in
-  f.morph_compose frame_x x;
-  compatible_intro q (f.morph x) (f.morph y) (f.morph frame_x)
-
-let injective (#a #b: Type) (f: (a -> Tot b)) : Tot prop =
-  (forall x1 x2 . {:pattern f x1; f x2} f x1 == f x2 ==> x1 == x2)
-
-let is_inverse_of (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b)) : Tot prop =
-  (forall x . {:pattern (g (f x))} g (f x) == x)
-
-let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
-  x1 x2
-: Lemma
-  (requires (g `is_inverse_of` f /\ f x1 == f x2))
-  (ensures (x1 == x2))
-  [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
-= assert (g (f x1) == g (f x2))
-
-#push-options "--print_universes"
-
-let fpu_lift_dom (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
-   y:Ghost.erased t_small &
-   frame_preserving_upd p_small x y)
-
-let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-: fpu_lift_dom conn_small_to_large -> Type
-= fun (|x, y, f|) ->
-  frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
-     
-let fpu_lift (#t_large:Type) (#t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-: Type
-= restricted_t
-    (fpu_lift_dom conn_small_to_large)
-    (fpu_lift_cod conn_small_to_large)
-
-noeq
-type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
-  conn_small_to_large: morphism p_small p_large;
-  conn_large_to_small: morphism p_large p_small;
-  conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
-  conn_lift_frame_preserving_upd: fpu_lift p_large p_small conn_small_to_large;
-}
-
-let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
-  (conn_large_to_small: morphism p_large p_small)
-  (conn_small_to_large_inv:
-    squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
-  (conn_lift_frame_preserving_upd:
-    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
-     y:Ghost.erased t_small ->
-     frame_preserving_upd p_small x y ->
-     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
-: connection p_large p_small = {
-  conn_small_to_large = conn_small_to_large;
-  conn_large_to_small = conn_large_to_small;
-  conn_small_to_large_inv = conn_small_to_large_inv;
-  conn_lift_frame_preserving_upd =
-    on_domain
-      (fpu_lift_dom conn_small_to_large)
-      (fun (z: fpu_lift_dom conn_small_to_large) ->
-        let (|x, y, f|) = z in
-	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
-}
-
-let connection_eq (l m: 'p `connection` 'q)
-: Lemma
-    (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
-              l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
-              l.conn_lift_frame_preserving_upd `feq` m.conn_lift_frame_preserving_upd)
-    (ensures l == m)
-= ()
-
-let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
-  mkconnection
-    (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
-    (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
-    ()
-    (fun xc yc f ->
-    let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
-    let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
-    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
-    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
-    fab.conn_lift_frame_preserving_upd (|xb, yb, fbc.conn_lift_frame_preserving_upd (|xc, yc, f|)|))
-
-noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
-  p: pcm a;
-  pl: connection p q;
-  r: Steel.Memory.ref a p;
-}
-
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
-
-open Steel.Effect
-
-val pts_to
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
-: vprop
-
-let ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref a p) (#q: pcm c) (l: connection p q)
-: ref a q
-= {p = r.p; pl = connection_compose r.pl l; r = r.r}
-
-let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
-: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
-  [SMTPatOr [
-    [SMTPat (ref_focus (ref_focus r l) m)]; 
-    [SMTPat (ref_focus r (l `connection_compose` m))]]]
-= connection_eq
-    ((r.pl `connection_compose` l) `connection_compose` m)
-    (r.pl `connection_compose` (l `connection_compose` m))
-
-module A = Steel.Effect.Atomic
-
-val focus (#p: pcm 'b) (r: ref 'a p)
-  (#q: pcm 'c)
-  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ref 'a q)
-    (r `pts_to` s)
-    (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
-    (fun _ r' _ -> r' == ref_focus r l)
-
-module M = Steel.Memory
-
-val unfocus (#opened:M.inames)
-  (#p: pcm 'b)
-  (#q: pcm 'c)
-  (r: ref 'a q) (r': ref 'a p)
-  (l: connection p q) (x: Ghost.erased 'c)
-: A.SteelGhost unit opened
-    (r `pts_to` x)
-    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
-    (requires fun _ -> r == ref_focus r' l)
-    (ensures fun _ _ _ -> True)
-
-val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
-: Steel unit
-    (r `pts_to` xy)
-    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
-    (fun _ _ _ -> True)
-
-let mgather
-  (#a:Type) (#p:pcm a)
-  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: SteelT (_:unit{composable p v0 v1})
-    (mpts_to r v0 `star` mpts_to r v1)
-    (fun _ -> mpts_to r (op p v0 v1))
-= Steel.PCMReference.gather r v0 v1
-
-val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
-: SteelT (_:unit{composable p x y})
-    ((r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> r `pts_to` op p x y)
-
-val ref_read
-  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
-: Steel b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible p x x')
-
-val ref_upd
-  (#a:Type) (#b:Type) (#p: pcm b)
-  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-
-(** A PCM for structs *)
-
-/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
-
-open FStar.FunctionalExtensionality
-open FStar.Classical
-let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-  extensionality 'a 'b f g;
-  forall_intro fg
-
-let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
-  forall k. composable (p k) (x k) (y k)
-
-let prod_op (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: restricted_t 'a 'b
-= on_domain 'a (fun k -> op (p k) (x k) (y k))
-
-let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
-  on_domain 'a (fun k -> one (p k))
-
-let prod_comm (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: Lemma (prod_op p x y == prod_op p y x)
-= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
-
-let prod_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
-: Lemma (prod_comp p x y /\
-         prod_comp p (prod_op p x y) z /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (x k) (y k) /\
-           composable (p k) (op (p k) (x k) (y k)) (z k)) 
-    [SMTPat (p k)]
-  = (p k).assoc (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
-: Lemma (prod_comp p y z /\
-         prod_comp p x (prod_op p y z) /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (y k) (z k) /\
-           composable (p k) (x k) (op (p k) (y k) (z k)))
-    [SMTPat (p k)]
-  = (p k).assoc_r (x k) (y k) (z k)
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
-
-let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
-: Lemma (prod_comp p x (prod_one p) /\
-         prod_op p x (prod_one p) == x)
-= let is_unit k
-  : Lemma (composable (p k) (x k) (prod_one p k))
-    [SMTPat (p k)]
-  = (p k).is_unit (x k)
-  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
-
-let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
-  (exists (k: 'a). True) /\ (forall k. (p k).refine (x k))
-
-let prod_pcm' (p:(k:'a -> pcm ('b k))): FStar.PCM.pcm (restricted_t 'a 'b) = {
-  comm = prod_comm p;
-  FStar.PCM.p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
-  assoc = prod_assoc p;
-  assoc_r = prod_assoc_r p;
-  is_unit = prod_is_unit p;
-  refine = prod_refine p
-}
-
-let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
-  let p' = prod_pcm' p in
-  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
-    x `feq` one p' /\ y `feq` one p'
-  ));
-  //assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
-  p'
-
-let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
-  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
-: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
-
-let field_to_struct_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-: Pure (restricted_t a b)
-  (requires True)
-  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
-= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
-
-let is_unit (#a: Type u#a) (p:pcm a) 
-  (x:a)
-:  Lemma (composable p x p.FStar.PCM.p.one /\
-         op p x p.FStar.PCM.p.one == x)
-= p.is_unit x
-
-let field_to_struct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (p k) (prod_pcm p))
-= mkmorphism
-    (field_to_struct_f p k)
-    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
-    (fun x1 x2 ->
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
-        ())
-
-let struct_to_field_f
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: restricted_t a b)
-: Tot (b k)
-= x k
-
-let struct_to_field
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (prod_pcm p) (p k))
-= mkmorphism
-    (struct_to_field_f p k) ()
-    (fun x1 x2 -> ())
-
-let struct_field_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: restricted_t a b {
-    (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Tot (restricted_t a b)
-= 
-    on_dom a (fun k' ->
-      if k' = k
-      then f (v k) <: b k'
-      else v k'
-    )
-
-let struct_field_lift_fpu_prf
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: restricted_t a b {
-    (prod_pcm p).refine v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Lemma
-  (let v_new = struct_field_lift_fpu' p k x y f v in
-    (prod_pcm p).refine v_new /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
-    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
-  )
-=
-  let y' = (field_to_struct p k).morph y in
-  let v_new = struct_field_lift_fpu' p k x y f v in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  assert (forall (frame: b k) .
-    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
-    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
-    composable (prod_pcm p) y' frame' /\
-    op (prod_pcm p) frame' y' `feq` v_new
-  ));
-  assert (compatible (prod_pcm p) y' v_new);
-  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
-  ()
-
-let struct_field_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
-= fun v ->
-    struct_field_lift_fpu_prf p k x y f v;
-    struct_field_lift_fpu' p k x y f v
-
-let struct_field
-  (#a: eqtype)
-  (#b: a -> Type u#b)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (connection (prod_pcm p) (p k))
-= mkconnection
-    (field_to_struct p k)
-    (struct_to_field p k)
-    ()
-    (struct_field_lift_fpu p k)
-
-let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (xs: restricted_t a b)
-: restricted_t a b
-= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
-
-let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (xs: restricted_t a b)
-: Lemma (
-    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
-    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
-  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-  
-let addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-
-let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (x:b k) (xs: restricted_t a b)
-: restricted_t a b
-= on_dom a (fun k' -> if k' = k then x else xs k')
-
-let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (x: b k) (xs: restricted_t a b)
-: Lemma
-    (requires xs k == one (p k))
-    (ensures
-      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
-      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
-  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
-
-let unaddr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (prod_pcm p))
-  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
-: Steel unit
-    ((r `pts_to` xs) `star` (r' `pts_to` x))
-    (fun s -> r `pts_to` struct_with_field p k x xs)
-    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
-    (ensures fun _ _ _ -> True)
-= unfocus r' r (struct_field p k) x;
-  gather r xs (field_to_struct_f p k x);
-  struct_unpeel p k x xs;
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  A.return ()
-
-let exclusive_struct_intro
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (x: restricted_t a b)
-: Lemma
-  (requires (
-    forall k . exclusive (p k) (struct_to_field_f p k x)
-  ))
-  (ensures (
-    exclusive (prod_pcm p) x
-  ))
-  [SMTPat (exclusive (prod_pcm p) x)]
-=
-  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
-
-let exclusive_struct_elim
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (x: restricted_t a b)
-  (k: a)
-: Lemma
-  (requires (exclusive (prod_pcm p) x))
-  (ensures (exclusive (p k) (struct_to_field_f p k x)))
-=
-  let phi
-    frame
-  : Lemma
-    (requires (composable (p k) (struct_to_field_f p k x) frame))
-    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
-    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
-  = let x' = struct_to_field_f p k x in
-    let f' = field_to_struct_f p k frame in
-    let psi
-      k'
-    : Lemma
-      (composable (p k') (x k') (f' k'))
-      [SMTPat (composable (p k') (x k') (f' k'))]
-    = if k' = k
-      then ()
-      else is_unit (p k') (x k')
-    in
-    ()
-  in
-  ()
-
-(** A PCM for unions TODO move to proper place *)
-
-open FStar.FunctionalExtensionality
-
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
-  forall k'. ~ (k == k') ==> f k' == one (p k')
-
-let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
-: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
-
-let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
-    (ensures f == one (prod_pcm p))
-= ext f (one (prod_pcm p)) (fun k -> ())
-
-let is_union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) (f: restricted_t a b) =
-  (exists (k:a). True) ==> (exists k. case_refinement_f p k f)
-  (** precondition is there because we don't care if 'a is inhabited *)
-
-let union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) = f:restricted_t a b{is_union p f}
-
-let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
-  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
-    [SMTPat (case_refinement_f p k f)]))
-: Lemma (forall (j:'a). goal)
-= let _ = cont in ()
-
-let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
-  (k:'a{case_refinement_f p k f})
-: Lemma (is_union p f)
-= ()
-
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
-  forall j k.
-  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
-  j == k /\ composable (p k) (f k) (g k)
-
-let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (h:(j:'a -> k:'a ->
-    Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures j == k /\ composable (p k) (f k) (g k))
-      [SMTPat (f j); SMTPat (g k)]))
-: Lemma (union_comp p f g)
-= let _ = h in ()
-
-let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
-: Lemma
-    (requires union_comp p f g)
-    (ensures prod_comp p f g)
-    [SMTPat (union_comp p f g)]
-= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
-
-let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p k f /\ f k == one (p k))
-    (ensures f == one (prod_pcm p))
-    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
-= ext f (one (prod_pcm p)) (fun _ -> ())
-
-let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
-    (ensures
-      f == one (prod_pcm p) \/
-      g == one (prod_pcm p) \/ 
-      case_refinement_f p k (prod_op p f g))
-    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
-= let fj_or_gk_one
-  : squash
-      (f j == one (p j) \/ g k == one (p k) ==>
-       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
-  = ()
-  in let fj_gk_both_not_one ()
-  : Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures case_refinement_f p k (prod_op p f g))
-  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
-  in
-  move_requires fj_gk_both_not_one ();
-  assert
-   ((f j == one (p j) \/ g k == one (p k)) ==>
-    f == one (prod_pcm p) \/
-    g == one (prod_pcm p) \/ 
-    case_refinement_f p k (prod_op p f g))
-
-let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
-  let h = prod_op p f g in
-  let goal = is_union p h in
-  union_elim p f goal (fun j ->
-  union_elim p g goal (fun k ->
-  case_refinement_f_op p j k f g;
-  (prod_pcm p).is_unit g));
-  h
-
-let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
-let union_refine (p:(k:'a -> pcm ('b k))) = prod_refine p
-
-let union_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
-: Lemma (union_comp p x y /\
-         union_comp p (union_op p x y) z /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
-
-#restart-solver
-#push-options "--query_stats --z3rlimit 32"
-
-let union_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
-: Lemma (union_comp p y z /\
-         union_comp p x (union_op p y z) /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc_r p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
-
-#pop-options
-
-let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
-: Lemma (union_comp p x (union_one p) /\
-         union_op p x (union_one p) == x)
-= (prod_pcm p).is_unit x
-
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
-  let p' = {
-    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
-    comm = (fun x y -> prod_comm p x y);
-    assoc = union_assoc p;
-    assoc_r = union_assoc_r p;
-    is_unit = union_is_unit p;
-    refine = union_refine p;
-  } in
-  let aux (x:union p) (y:union p{composable p' x y})
-  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-    [SMTPat (op p' x y)]
-  = ext x (one p') (fun k -> let _ = p k in ());
-    ext y (one p') (fun k -> let _ = p k in ())
-  in
-  //assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
-  p'
-
-let field_to_union_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-: Pure (union p)
-  (requires True)
-  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
-= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
-
-let field_to_union
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (p k) (union_pcm p))
-= mkmorphism
-    (field_to_union_f p k)
-    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
-    (fun x1 x2 ->
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
-        ())
-
-let union_to_field_f
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: union p)
-: Tot (b k)
-= x k
-
-let union_to_field
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (union_pcm p) (p k))
-= mkmorphism
-    (union_to_field_f p k) ()
-    (fun x1 x2 -> ())
-
-let union_field_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: union p {
-    (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Tot (union p)
-= 
-    on_dom a (fun k' ->
-      if k' = k
-      then f (v k) <: b k'
-      else one (p k')
-    )
-
-#restart-solver
-#push-options "--z3rlimit 32 --query_stats"
-
-let union_field_lift_fpu_prf
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: union p {
-    (union_pcm p).refine v /\
-    compatible (union_pcm p) ((field_to_union p k).morph x) v
-  })
-: Lemma
-  (let v_new = union_field_lift_fpu' p k x y f v in
-    (union_pcm p).refine v_new /\
-    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
-    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
-       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
-  )
-=
-  let y' = (field_to_union p k).morph y in
-  let v_new = union_field_lift_fpu' p k x y f v in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  let frame : b k = compatible_elim (p k) y (f (v k)) in
-  let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
-  assert (composable (union_pcm p) y' frame');
-  assert (op (union_pcm p) frame' y' `feq` v_new);
-  compatible_intro (union_pcm p) y' v_new frame';
-  let x = Ghost.reveal x in
-  let aux (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame})
-  : Lemma (
-      composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-      (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
-       op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
-  = assert_norm (
-     op (union_pcm p) ((field_to_union p k).morph x) frame k ==
-     op (p k) x (frame k));
-    assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
-       op (p k) x (frame k) == v k)
-  in forall_intro aux; ()
-
-#pop-options
-
-let union_field_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
-= fun v ->
-    union_field_lift_fpu_prf p k x y f v;
-    union_field_lift_fpu' p k x y f v
-
-let union_field
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (connection (union_pcm p) (p k))
-= mkconnection
-    (field_to_union p k)
-    (union_to_field p k)
-    ()
-    (union_field_lift_fpu p k)
-
-let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (xs: union p{~ (xs k == one (p k))})
-: Lemma (xs == field_to_union_f p k (xs k))
-= assert (xs `feq` field_to_union_f p k (xs k))
-
-let addr_of_union_field
-  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
-  (r: ref base (union_pcm p)) (k:a)
-  (xs: Ghost.erased (union p))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun r' -> r' `pts_to` Ghost.reveal xs k)
-    (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
-    (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
-= union_peel p k xs;
-  A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
-  focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
-
-let unaddr_of_union_field
-  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (union_pcm p))
-  (x: Ghost.erased (b k))
-: A.SteelGhost unit opened
-    (r' `pts_to` x)
-    (fun s -> r `pts_to` field_to_union_f p k x)
-    (requires fun _ -> r' == ref_focus r (union_field p k))
-    (ensures fun _ _ _ -> True)
-= unfocus r' r (union_field p k) x
-
-module I = FStar.IndefiniteDescription
-
-let case_of_union (p:(k:'a -> pcm ('b k))) (u: union p)
-: GTot (k:option 'a{match k with Some k -> ~ (u k == one (p k)) | None -> u == one (union_pcm p)})
-= if I.strong_excluded_middle (exists k. ~ (u k == one (p k))) then
-    let k = I.indefinite_description_ghost 'a (fun k -> ~ (u k == one (p k))) in
-    Some k
-  else begin
-    assert (u `feq` one (union_pcm p));
-    None
-  end
-
-let exclusive_union_intro
-  (#a: Type)
-  (#b: _)
-  (p:(k: a -> pcm (b k)))
-  (x: union p)
-  (k: a)
-: Lemma
-  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
-  (ensures (exclusive (union_pcm p) x))
-= let phi
-    (frame: union p)
-  : Lemma
-    (requires (composable (union_pcm p) x frame))
-    (ensures (frame `feq` union_one p))
-    [SMTPat (composable (union_pcm p) x frame)]
-  = ()
-  in
-  ()
-
-let exclusive_union_elim
-  (#a: eqtype)
-  (#b: _)
-  (p: (k: a -> pcm (b k)))
-  (x: union p)
-  (k: a)
-: Lemma
-  (requires (exclusive (union_pcm p) x))
-  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
-= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
-  then ()
-  else
-    let phi
-      (frame: b k)
-    : Lemma
-      (requires (composable (p k) (x k) frame))
-      (ensures (frame == one (p k)))
-      [SMTPat (composable (p k) (x k) frame)]
-    = let frame' = field_to_union_f p k frame in
-      ()
-    in
-    ()
-
-let base_fpu
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a)
-  (y: a)
-: Pure (frame_preserving_upd p x y)
-  (requires (exclusive p x /\ p.refine y))
-  (ensures (fun _ -> True))
-= fun _ ->
-  Classical.forall_intro (is_unit p);
-  compatible_refl p y;
-  y
-
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let opt_pcm #a : pcm (option a) = {
-  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x == true \/ None? x);
-}
-
-let exclusive_opt
-  (#a: Type)
-  (x: option a)
-: Lemma
-  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
-=
-  match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      assert (composable opt_pcm x (Some y))
-    end else begin
-      let phi
-        (frame: option a)
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some z -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some _ -> ()
-
-let opt_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
-  (y: a)
-: Tot (frame_preserving_upd opt_pcm x (Some y))
-= base_fpu opt_pcm x (Some y)
-
-let opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ _ _ -> True))
-
-//let opt_pcm_write r x y
-= ref_upd r x (Some y) (opt_pcm_fpu x y)
-
-let opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-
-//let opt_pcm_read r x
-= let y' = ref_read r in
-  assert (Ghost.reveal x == y');
-  Some?.v y'
-
-/// Fractional permissions: from Steel.HigherReference
-open Steel.FractionalPermission
-
-let fractional (a:Type u#1) = option (a & perm)
-
-let fractional_composable #a : symrel (fractional a) =
-  fun (f0 f1:fractional a) ->
-    match f0, f1 with
-    | None, _
-    | _, None -> True
-    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
-
-let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
-  match f0, f1 with
-  | None, f
-  | f, None -> f
-  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
-
-let pcm_frac #a : pcm (fractional a) = {
-  FStar.PCM.p = {
-         composable = fractional_composable;
-         op = fractional_compose;
-         one = None
-      };
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
-}
-
-let frac_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
-  (y: a)
-: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
-= base_fpu pcm_frac x (Some (y, full_perm))
-
-let frac_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
-  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
-  (ensures (fun _ _ _ -> True))
-
-//let frac_pcm_write r x y
-= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
-
-let frac_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
-
-//let frac_pcm_read r x
-= let y' = ref_read r in
-  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
-  fst (Some?.v y')
-
-let exclusive_frac
-  (#a: Type)
-  (x: option (a & perm))
-: Lemma
-  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
-= match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      let frame = Some (y, full_perm) in
-      assert (~ (frame == one pcm_frac));
-      assert (composable pcm_frac x frame)
-    end else begin
-      let phi
-        (frame: option (a & perm))
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some (z, _) -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some (y, p) ->
-    assert (exists (z: a) . True);
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
-    then ()
-    else begin
-      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
-      assert (composable pcm_frac x frame);
-      assert (~ (frame == one pcm_frac))
-    end
-
-
-/// Uninitialized
-
-noeq
-type uninit_t (a: Type)
-= | Uninitialized
-  | InitOrUnit: a -> uninit_t a
-
-let uninit_composable
-  (#a: Type)
-  (p: pcm a)
-: Tot (symrel (uninit_t a))
-= fun u1 u2 ->
-  match u1, u2 with
-  | Uninitialized, InitOrUnit x
-  | InitOrUnit x, Uninitialized
-    -> x == one p
-  | InitOrUnit x1, InitOrUnit x2
-    -> composable p x1 x2
-  | _ -> False
-
-let uninit_compose
-  (#a: Type)
-  (p: pcm a)
-  (u1: uninit_t a)
-  (u2: uninit_t a { uninit_composable p u1 u2 })
-: Tot (uninit_t a)
-= match u1, u2 with
-  | Uninitialized, _
-  | _, Uninitialized
-    -> Uninitialized
-  | InitOrUnit x1, InitOrUnit x2
-    -> InitOrUnit (op p x1 x2)
-
-let uninit_refine
-  (#a: Type)
-  (p: pcm a)
-  (x: uninit_t a)
-: Tot prop
-= match x with
-  | Uninitialized -> True
-  | InitOrUnit y -> p.refine y
-
-let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
-  FStar.PCM.p = {
-         composable = uninit_composable p;
-         op = uninit_compose p;
-         one = InitOrUnit (one p);
-      };
-  comm = (fun _ _ ->
-    Classical.forall_intro_2 p.comm
-  );
-  assoc = (fun x1 x2 x3 ->
-    Classical.forall_intro_3 p.assoc;
-    Classical.forall_intro (is_unit p)
-  );
-  assoc_r = (fun _ _ _ -> 
-    Classical.forall_intro_3 p.assoc_r;
-    Classical.forall_intro (is_unit p)
-  );
-  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
-  refine = uninit_refine p;
-}
-
-let value_to_uninit
-  (#a: Type)
-  (p: pcm a)
-: Tot (morphism p (pcm_uninit p))
-= mkmorphism
-    (fun x -> InitOrUnit x)
-    ()
-    (fun _ _ -> ())
-
-let uninit_to_value
-  (#a: Type)
-  (p: pcm a)
-: Tot (morphism (pcm_uninit p) p)
-= mkmorphism
-    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
-    ()
-    (fun _ _ -> Classical.forall_intro (is_unit p))
-
-let uninit_conn_fpu'
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-  (v: uninit_t a {
-    (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
-  })
-: Tot (uninit_t a)
-=
-  let InitOrUnit x' = v in
-  InitOrUnit (f x')
-
-let uninit_conn_fpu_prop
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-  (v: uninit_t a {
-    (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
-  })
-: Lemma
-  (let v_new = uninit_conn_fpu' p x y f v in
-    (pcm_uninit p).refine v_new /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
-    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
-  )
-= Classical.forall_intro (is_unit p);
-  let y' = (value_to_uninit p).morph y in
-  let InitOrUnit x' = v in
-  let v_new = uninit_conn_fpu' p x y f v in
-  let frame : a = compatible_elim p y (f x') in
-  let frame' : uninit_t a = InitOrUnit frame in
-  assert (composable (pcm_uninit p) y' frame');
-  assert (op (pcm_uninit p) frame' y' == v_new);
-  compatible_intro (pcm_uninit p) y' v_new frame';
-  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
-  ()
-
-let uninit_conn_fpu
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
-=
-  fun v ->
-    uninit_conn_fpu_prop p x y f v;
-    uninit_conn_fpu' p x y f v
-
-let uninit_conn
-  (#a: Type)
-  (p: pcm a)
-: Tot (connection (pcm_uninit p) p)
-= mkconnection
-    (value_to_uninit p)
-    (uninit_to_value p)
-    ()
-    (uninit_conn_fpu p)
-
-let exclusive_uninit
-  (#a: Type)
-  (p: pcm a)
-  (x: uninit_t a)
-: Lemma
-  (exclusive (pcm_uninit p) x <==> begin match x with
-  | Uninitialized -> True
-  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
-  end)
-= match x with
-  | Uninitialized -> ()
-  | InitOrUnit z ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
-    then begin
-      assert (composable (pcm_uninit p) x Uninitialized)
-    end else
-      let phi2
-        frame
-      : Lemma
-        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
-        (ensures (frame == one p))
-        [SMTPat (composable p z frame)]
-      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
-      in
-      ()
-
-let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
-  (x: a { p x })
-
-noeq
-type sel_view
-  (#carrier: Type u#a)
-  (p: pcm carrier)
-  (view: Type u#b)
-= {
-  to_view_prop: (carrier -> Tot prop);
-  to_view: (refine carrier to_view_prop -> GTot view);
-  to_carrier: (view -> GTot (refine carrier to_view_prop));
-  to_carrier_not_one:
-    (x: view) ->
-    Lemma
-    (~ (to_carrier x == one p));
-  to_view_frame:
-    (x: view) ->
-    (frame: carrier) ->
-    Lemma
-    (requires (composable p (to_carrier x) frame))
-    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
-}
-
-let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
-  (forall x . {:pattern (g (f x))} g (f x) == x)
-
-let sel_view_inv
-  (#carrier: Type u#a)
-  (#p: pcm carrier)
-  (#view: Type u#b)
-  (vw: sel_view p view)
-: Lemma
-  (vw.to_view `g_is_inverse_of` vw.to_carrier)
-  [SMTPat (has_type vw (sel_view p view))]
-= let aux
-    (x: view)
-  : Lemma
-    (vw.to_view (vw.to_carrier x) == x)
-    [SMTPat (vw.to_view (vw.to_carrier x))]
-  = is_unit p (vw.to_carrier x);
-    vw.to_view_frame x (one p)
-  in
-  ()
-
-let pts_to_view_explicit
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (vw: sel_view p c)
-  (v: Ghost.erased c)
-: Tot M.slprop
-= hp_of (pts_to r (vw.to_carrier v))
-
-val pts_to_view_explicit_witinv
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (vw: sel_view p c)
-: Lemma
-  (M.is_witness_invariant (pts_to_view_explicit r vw))
-
-let pts_to_view_sl
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (vw: sel_view p c)
-: Tot M.slprop
-= M.h_exists (pts_to_view_explicit r vw)
-
-let pts_to_view_sel'
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot (selector' c (pts_to_view_sl r vw))
-= fun h ->
-  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
-  Ghost.reveal (Ghost.reveal x)
-
-let pts_to_view_depends_only_on
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
-: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
-= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
-  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
-  pts_to_view_explicit_witinv r vw;
-  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
-
-let pts_to_view_depends_only_on_core
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (m0:M.hmem (pts_to_view_sl r vw))
-: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
-= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
-  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
-  pts_to_view_explicit_witinv r vw;
-  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
-
-let pts_to_view_sel
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot (selector c (pts_to_view_sl r vw))
-= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
-  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
-  pts_to_view_sel' r vw
-
-[@@__steel_reduce__]
-let pts_to_view'
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot vprop'
-= {
-  hp = pts_to_view_sl r vw;
-  t = c;
-  sel = pts_to_view_sel r vw;
-}
-
-[@@__steel_reduce__]
-let pts_to_view 
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: Tot vprop
-= VUnit (pts_to_view' r vw)
-
-let pts_to_view_intro_lemma
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
-  (m: M.mem)
-: Lemma
-  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
-  (ensures (
-    M.interp (pts_to_view_sl r vw) m /\
-    pts_to_view_sel r vw m == Ghost.reveal y
-  )) 
-=
-  M.intro_h_exists y (pts_to_view_explicit r vw) m;
-  pts_to_view_explicit_witinv r vw
-
-let pts_to_view_intro
-  (#invs: _)
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
-: A.SteelGhost unit invs
-    (pts_to r x)
-    (fun _ -> pts_to_view r vw)
-    (fun _ -> vw.to_carrier y == Ghost.reveal x)
-    (fun _ _ h' ->
-      h' (pts_to_view r vw) == Ghost.reveal y
-    )
-= A.change_slprop_2
-    (pts_to r x)
-    (pts_to_view r vw)
-    y
-    (fun m ->
-      pts_to_view_intro_lemma r x vw y m
-    )
-
-let pts_to_view_elim_lemma
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-  (m: M.mem)
-: Lemma
-  (requires (M.interp (pts_to_view_sl r vw) m))
-  (ensures (
-    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
-  ))
-=
-  M.elim_h_exists (pts_to_view_explicit r vw) m;
-  pts_to_view_explicit_witinv r vw
-
-/// Introducing a dependent star for [v] and [q]
-let intro_vdep2 (#opened:_)
-  (v: vprop)
-  (q: vprop)
-  (p: (t_of v -> Tot vprop))
-  (x: t_of v)
-: A.SteelGhost unit opened
-    (v `star` q)
-    (fun _ -> vdep v p)
-    (requires (fun h -> h v == x /\ q == p x))
-    (ensures (fun h _ h' ->
-      let x2 = h' (vdep v p) in
-      q == p (h v) /\
-      dfst x2 == (h v) /\
-      dsnd x2 == (h q)
-    ))
-=
-  A.intro_vdep v q p
-
-let pts_to_view_elim
-  (#invs: _)
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (vw: sel_view p c)
-: A.SteelGhost (Ghost.erased b) invs
-    (pts_to_view r vw)
-    (fun res -> pts_to r res)
-    (fun _ -> True)
-    (fun h res _ ->
-      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw))
-    )
-=
-  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
-  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
-  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
-  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
-  intro_vdep2
-    (pts_to_view r vw)
-    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
-    f
-    (Ghost.reveal g);
-  A.rewrite_slprop
-    (vdep (pts_to_view r vw) f)
-    (pts_to r res)
-    (fun m ->
-      interp_vdep_hp (pts_to_view r vw) f m;
-      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
-      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
-      pts_to_view_elim_lemma r vw m
-    );
-  res
-
-let opt_view
-  (a: Type)
-: Tot (sel_view (opt_pcm #a) a)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> Some?.v x);
-  to_carrier = (fun z  -> Some z);
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun x frame -> ());
-}
-
-let frac_view
-  (a: Type)
-  (p: perm)
-: Tot (sel_view (pcm_frac #a) a)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> let Some (v, _) = x in v);
-  to_carrier = (fun v -> Some (v, p));
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun v frame -> ());
-}
-
-let uninit_view
-  (#a: Type)
-  (#p: pcm a)
-  (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
-= {
-  to_view_prop = (fun x -> match x with
-  | Uninitialized -> True
-  | InitOrUnit x' -> w.to_view_prop x'
-  );
-  to_view = (fun x -> match x with
-  | Uninitialized -> Uninitialized
-  | InitOrUnit x' -> InitOrUnit (w.to_view x')
-  );
-  to_carrier = (fun v -> match v with
-  | Uninitialized -> Uninitialized
-  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
-  );
-  to_carrier_not_one = (fun v -> match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'
-  );
-  to_view_frame = (fun v frame -> match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
-  );
-}
-
-let uninit_view_initialized
-  (#a: Type)
-  (#p: pcm a)
-  (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
-= {
-  to_view_prop = (fun x -> match x with
-  | Uninitialized -> False
-  | InitOrUnit x' -> w.to_view_prop x'
-  );
-  to_view = (fun x -> match x with
-  | InitOrUnit x' -> w.to_view x'
-  );
-  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
-  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
-  to_view_frame = (fun v frame ->
-    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
-  );
-}
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
new file mode 100644
index 00000000000..52362165c2a
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -0,0 +1,126 @@
+module Steel.C.Ref
+module P = FStar.PCM
+open FStar.FunctionalExtensionality
+
+#push-options "--print_universes"
+
+let pts_to r v =
+  r.r `mpts_to` r.pl.conn_small_to_large.morph v
+
+let focus r l s x =
+  let r' = ref_focus r l in
+  A.change_slprop_rel  
+    (r `pts_to` s)
+    (r' `pts_to` x)
+    (fun _ _ -> True)
+    (fun m -> ());
+  A.return r'
+
+let unfocus r r' l x =
+  A.change_slprop_rel  
+    (r `pts_to` x)
+    (r' `pts_to` l.conn_small_to_large.morph x)
+    (fun _ _ -> True)
+    (fun m -> ())
+
+let split r xy x y =
+  A.change_equal_slprop
+    (r `pts_to` xy)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph xy)));
+  Steel.PCMReference.split r.r
+    (r.pl.conn_small_to_large.morph xy)
+    (r.pl.conn_small_to_large.morph x)
+    (r.pl.conn_small_to_large.morph y);
+  A.change_equal_slprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)))
+    (r `pts_to` x);
+  A.change_equal_slprop
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
+    (r `pts_to` y)
+
+let gather #a #b #p r x y =
+  A.change_equal_slprop
+    (r `pts_to` x)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)));
+  A.change_equal_slprop
+    (r `pts_to` y)
+    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)));
+  mgather r.r
+    (r.pl.conn_small_to_large.morph x)
+    (r.pl.conn_small_to_large.morph y);
+  assert (
+    let x1 = r.pl.conn_small_to_large.morph x in
+    let y1 = r.pl.conn_small_to_large.morph y in
+    let x2 = r.pl.conn_large_to_small.morph x1 in
+    let y2 = r.pl.conn_large_to_small.morph y1 in
+    Ghost.reveal x == x2 /\ Ghost.reveal y == y2
+  );
+  A.change_equal_slprop _ (r `pts_to` op p x y)
+
+let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
+: Steel 'b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible p x x')
+= let w = Ghost.hide (r.pl.conn_small_to_large.morph x) in
+  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
+  let w' = Steel.PCMReference.read r.r w in
+  A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
+  let x' = r.pl.conn_large_to_small.morph w' in
+  assert (forall frame . (composable r.p w frame /\ op r.p frame w == w') ==> (
+    let sw = r.pl.conn_large_to_small.morph w in
+    let sw' = r.pl.conn_large_to_small.morph w' in
+    let sframe = r.pl.conn_large_to_small.morph frame in
+    (composable p sw sframe /\ op p sframe sw == sw')
+  ));
+  A.return x'
+
+let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
+: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
+= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, f|))
+
+let as_action (#p:vprop)
+              (#q:vprop)
+              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
+: SteelT unit p (fun x -> q)
+= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
+  let x = Steel.Effect.as_action f in
+  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
+  A.return x
+
+let ref_upd r x y f = as_action (ref_upd_act r x y f)
+
+let pts_to_view_explicit_witinv
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Lemma
+  (M.is_witness_invariant (pts_to_view_explicit r vw))
+= admit() (*
+  let aux (x y : Ghost.erased c) (m:M.mem)
+  : Lemma
+    (requires (M.interp (pts_to_view_explicit r vw x) m /\ M.interp (pts_to_view_explicit r vw y) m))
+    (ensures  (x == y))
+  =
+    let x_ = vw.to_carrier x in
+    let y_ = vw.to_carrier y in
+    let x' = r.pl.conn_small_to_large.morph x_ in
+    let y' = r.pl.conn_small_to_large.morph y_ in
+    M.pts_to_join r.r x' y' m;
+    let z' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun z' -> compatible r.p x' z' /\ compatible r.p y' z') in
+    let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_x' -> composable r.p x' frame_x' /\ op r.p frame_x' x' == z') in
+    let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_y' -> composable r.p y' frame_y' /\ op r.p frame_y' y' == z') in
+    let frame_x_ = r.pl.conn_large_to_small.morph frame_x' in
+    let frame_y_ = r.pl.conn_large_to_small.morph frame_y' in
+    r.p.comm x' frame_x';
+    r.pl.conn_large_to_small.morph_compose x' frame_x';
+    vw.to_view_frame x (r.pl.conn_large_to_small.morph frame_x');
+    r.p.comm y' frame_y';
+    r.pl.conn_large_to_small.morph_compose y' frame_y';
+    vw.to_view_frame y (r.pl.conn_large_to_small.morph frame_y');
+    ()
+  in
+  Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
+  *)
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
new file mode 100644
index 00000000000..de3da6579c1
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -0,0 +1,765 @@
+module Steel.C.Ref
+open FStar.PCM
+open FStar.FunctionalExtensionality
+open Steel.C.PCM
+open Steel.C.Connection
+
+#push-options "--print_universes"
+
+noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
+  p: pcm a;
+  pl: connection p q;
+  r: Steel.Memory.ref a p;
+}
+
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+
+open Steel.Effect
+
+val pts_to
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
+: vprop
+
+let ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: ref a q
+= {p = r.p; pl = connection_compose r.pl l; r = r.r}
+
+let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
+: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
+  [SMTPatOr [
+    [SMTPat (ref_focus (ref_focus r l) m)]; 
+    [SMTPat (ref_focus r (l `connection_compose` m))]]]
+= connection_eq
+    ((r.pl `connection_compose` l) `connection_compose` m)
+    (r.pl `connection_compose` (l `connection_compose` m))
+
+module A = Steel.Effect.Atomic
+
+val focus (#p: pcm 'b) (r: ref 'a p)
+  (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ref 'a q)
+    (r `pts_to` s)
+    (fun r' -> r' `pts_to` x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ r' _ -> r' == ref_focus r l)
+
+module M = Steel.Memory
+
+val unfocus (#opened:M.inames)
+  (#p: pcm 'b)
+  (#q: pcm 'c)
+  (r: ref 'a q) (r': ref 'a p)
+  (l: connection p q) (x: Ghost.erased 'c)
+: A.SteelGhost unit opened
+    (r `pts_to` x)
+    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
+    (requires fun _ -> r == ref_focus r' l)
+    (ensures fun _ _ _ -> True)
+
+val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+: Steel unit
+    (r `pts_to` xy)
+    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
+    (fun _ _ _ -> True)
+
+val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+: SteelT (_:unit{composable p x y})
+    ((r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> r `pts_to` op p x y)
+
+val ref_read
+  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+: Steel b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible p x x')
+
+val ref_upd
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
+: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
+
+let is_unit (#a: Type u#a) (p:pcm a) 
+  (x:a)
+:  Lemma (composable p x p.FStar.PCM.p.one /\
+         op p x p.FStar.PCM.p.one == x)
+= p.is_unit x
+
+let base_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a)
+  (y: a)
+: Pure (frame_preserving_upd p x y)
+  (requires (exclusive p x /\ p.refine y))
+  (ensures (fun _ -> True))
+= fun _ ->
+  Classical.forall_intro (is_unit p);
+  compatible_refl p y;
+  y
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x == true);
+}
+
+let exclusive_opt
+  (#a: Type)
+  (x: option a)
+: Lemma
+  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
+=
+  match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      assert (composable opt_pcm x (Some y))
+    end else begin
+      let phi
+        (frame: option a)
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some z -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some _ -> ()
+
+let opt_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
+  (y: a)
+: Tot (frame_preserving_upd opt_pcm x (Some y))
+= base_fpu opt_pcm x (Some y)
+
+let opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ _ _ -> True))
+
+//let opt_pcm_write r x y
+= ref_upd r x (Some y) (opt_pcm_fpu x y)
+
+let opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
+
+//let opt_pcm_read r x
+= let y' = ref_read r in
+  assert (Ghost.reveal x == y');
+  Some?.v y'
+  
+/// Fractional permissions: from Steel.HigherReference
+open Steel.FractionalPermission
+
+let fractional (a:Type u#1) = option (a & perm)
+
+let fractional_composable #a : symrel (fractional a) =
+  fun (f0 f1:fractional a) ->
+    match f0, f1 with
+    | None, _
+    | _, None -> True
+    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
+
+let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
+  match f0, f1 with
+  | None, f
+  | f, None -> f
+  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
+
+let pcm_frac #a : pcm (fractional a) = {
+  FStar.PCM.p = {
+         composable = fractional_composable;
+         op = fractional_compose;
+         one = None
+      };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
+}
+
+let frac_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
+  (y: a)
+: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
+= base_fpu pcm_frac x (Some (y, full_perm))
+
+let frac_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
+  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
+  (ensures (fun _ _ _ -> True))
+
+//let frac_pcm_write r x y
+= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
+
+let frac_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
+
+//let frac_pcm_read r x
+= let y' = ref_read r in
+  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
+  fst (Some?.v y')
+
+let exclusive_frac
+  (#a: Type)
+  (x: option (a & perm))
+: Lemma
+  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
+= match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      let frame = Some (y, full_perm) in
+      assert (~ (frame == one pcm_frac));
+      assert (composable pcm_frac x frame)
+    end else begin
+      let phi
+        (frame: option (a & perm))
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some (z, _) -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some (y, p) ->
+    assert (exists (z: a) . True);
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
+    then ()
+    else begin
+      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
+      assert (composable pcm_frac x frame);
+      assert (~ (frame == one pcm_frac))
+    end
+
+/// Uninitialized
+
+noeq
+type uninit_t (a: Type)
+= | Uninitialized
+  | InitOrUnit: a -> uninit_t a
+
+let uninit_composable
+  (#a: Type)
+  (p: pcm a)
+: Tot (symrel (uninit_t a))
+= fun u1 u2 ->
+  match u1, u2 with
+  | Uninitialized, InitOrUnit x
+  | InitOrUnit x, Uninitialized
+    -> x == one p
+  | InitOrUnit x1, InitOrUnit x2
+    -> composable p x1 x2
+  | _ -> False
+
+let uninit_compose
+  (#a: Type)
+  (p: pcm a)
+  (u1: uninit_t a)
+  (u2: uninit_t a { uninit_composable p u1 u2 })
+: Tot (uninit_t a)
+= match u1, u2 with
+  | Uninitialized, _
+  | _, Uninitialized
+    -> Uninitialized
+  | InitOrUnit x1, InitOrUnit x2
+    -> InitOrUnit (op p x1 x2)
+
+let uninit_refine
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Tot prop
+= match x with
+  | Uninitialized -> True
+  | InitOrUnit y -> p.refine y
+
+let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
+  FStar.PCM.p = {
+         composable = uninit_composable p;
+         op = uninit_compose p;
+         one = InitOrUnit (one p);
+      };
+  comm = (fun _ _ ->
+    Classical.forall_intro_2 p.comm
+  );
+  assoc = (fun x1 x2 x3 ->
+    Classical.forall_intro_3 p.assoc;
+    Classical.forall_intro (is_unit p)
+  );
+  assoc_r = (fun _ _ _ -> 
+    Classical.forall_intro_3 p.assoc_r;
+    Classical.forall_intro (is_unit p)
+  );
+  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
+  refine = uninit_refine p;
+}
+
+let value_to_uninit
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism p (pcm_uninit p))
+= mkmorphism
+    (fun x -> InitOrUnit x)
+    ()
+    (fun _ _ -> ())
+
+let uninit_to_value
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism (pcm_uninit p) p)
+= mkmorphism
+    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
+    ()
+    (fun _ _ -> Classical.forall_intro (is_unit p))
+
+let uninit_conn_fpu'
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Tot (uninit_t a)
+=
+  let InitOrUnit x' = v in
+  InitOrUnit (f x')
+
+let uninit_conn_fpu_prop
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Lemma
+  (let v_new = uninit_conn_fpu' p x y f v in
+    (pcm_uninit p).refine v_new /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
+    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
+  )
+= Classical.forall_intro (is_unit p);
+  let y' = (value_to_uninit p).morph y in
+  let InitOrUnit x' = v in
+  let v_new = uninit_conn_fpu' p x y f v in
+  let frame : a = compatible_elim p y (f x') in
+  let frame' : uninit_t a = InitOrUnit frame in
+  assert (composable (pcm_uninit p) y' frame');
+  assert (op (pcm_uninit p) frame' y' == v_new);
+  compatible_intro (pcm_uninit p) y' v_new frame';
+  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
+  ()
+
+let uninit_conn_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
+=
+  fun v ->
+    uninit_conn_fpu_prop p x y f v;
+    uninit_conn_fpu' p x y f v
+
+let uninit_conn
+  (#a: Type)
+  (p: pcm a)
+: Tot (connection (pcm_uninit p) p)
+= mkconnection
+    (value_to_uninit p)
+    (uninit_to_value p)
+    ()
+    (uninit_conn_fpu p)
+
+let exclusive_uninit
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Lemma
+  (exclusive (pcm_uninit p) x <==> begin match x with
+  | Uninitialized -> True
+  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
+  end)
+= match x with
+  | Uninitialized -> ()
+  | InitOrUnit z ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
+    then begin
+      assert (composable (pcm_uninit p) x Uninitialized)
+    end else
+      let phi2
+        frame
+      : Lemma
+        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
+        (ensures (frame == one p))
+        [SMTPat (composable p z frame)]
+      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
+      in
+      ()
+
+let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
+  (x: a { p x })
+
+noeq
+type sel_view
+  (#carrier: Type u#a)
+  (p: pcm carrier)
+  (view: Type u#b)
+= {
+  to_view_prop: (carrier -> Tot prop);
+  to_view: (refine carrier to_view_prop -> GTot view);
+  to_carrier: (view -> GTot (refine carrier to_view_prop));
+  to_carrier_not_one:
+    (x: view) ->
+    Lemma
+    (~ (to_carrier x == one p));
+  to_view_frame:
+    (x: view) ->
+    (frame: carrier) ->
+    Lemma
+    (requires (composable p (to_carrier x) frame))
+    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
+}
+
+let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
+  (forall x . {:pattern (g (f x))} g (f x) == x)
+
+let sel_view_inv
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type u#b)
+  (vw: sel_view p view)
+: Lemma
+  (vw.to_view `g_is_inverse_of` vw.to_carrier)
+  [SMTPat (has_type vw (sel_view p view))]
+= let aux
+    (x: view)
+  : Lemma
+    (vw.to_view (vw.to_carrier x) == x)
+    [SMTPat (vw.to_view (vw.to_carrier x))]
+  = is_unit p (vw.to_carrier x);
+    vw.to_view_frame x (one p)
+  in
+  ()
+
+let pts_to_view_explicit
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+  (v: Ghost.erased c)
+: Tot M.slprop
+= hp_of (pts_to r (vw.to_carrier v))
+
+val pts_to_view_explicit_witinv
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Lemma
+  (M.is_witness_invariant (pts_to_view_explicit r vw))
+
+let pts_to_view_sl
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (vw: sel_view p c)
+: Tot M.slprop
+= M.h_exists (pts_to_view_explicit r vw)
+
+let pts_to_view_sel'
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot (selector' c (pts_to_view_sl r vw))
+= fun h ->
+  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
+  Ghost.reveal (Ghost.reveal x)
+
+let pts_to_view_depends_only_on
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
+
+let pts_to_view_depends_only_on_core
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m0:M.hmem (pts_to_view_sl r vw))
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
+
+let pts_to_view_sel
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot (selector c (pts_to_view_sl r vw))
+= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
+  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
+  pts_to_view_sel' r vw
+
+[@@__steel_reduce__]
+let pts_to_view'
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot vprop'
+= {
+  hp = pts_to_view_sl r vw;
+  t = c;
+  sel = pts_to_view_sel r vw;
+}
+
+[@@__steel_reduce__]
+let pts_to_view 
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Tot vprop
+= VUnit (pts_to_view' r vw)
+
+let pts_to_view_intro_lemma
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
+  (ensures (
+    M.interp (pts_to_view_sl r vw) m /\
+    pts_to_view_sel r vw m == Ghost.reveal y
+  )) 
+=
+  M.intro_h_exists y (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+let pts_to_view_intro
+  (#invs: _)
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+: A.SteelGhost unit invs
+    (pts_to r x)
+    (fun _ -> pts_to_view r vw)
+    (fun _ -> vw.to_carrier y == Ghost.reveal x)
+    (fun _ _ h' ->
+      h' (pts_to_view r vw) == Ghost.reveal y
+    )
+= A.change_slprop_2
+    (pts_to r x)
+    (pts_to_view r vw)
+    y
+    (fun m ->
+      pts_to_view_intro_lemma r x vw y m
+    )
+
+let pts_to_view_elim_lemma
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (pts_to_view_sl r vw) m))
+  (ensures (
+    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
+  ))
+=
+  M.elim_h_exists (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+/// Introducing a dependent star for [v] and [q]
+let intro_vdep2 (#opened:_)
+  (v: vprop)
+  (q: vprop)
+  (p: (t_of v -> Tot vprop))
+  (x: t_of v)
+: A.SteelGhost unit opened
+    (v `star` q)
+    (fun _ -> vdep v p)
+    (requires (fun h -> h v == x /\ q == p x))
+    (ensures (fun h _ h' ->
+      let x2 = h' (vdep v p) in
+      q == p (h v) /\
+      dfst x2 == (h v) /\
+      dsnd x2 == (h q)
+    ))
+=
+  A.intro_vdep v q p
+
+let pts_to_view_elim
+  (#invs: _)
+  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: A.SteelGhost (Ghost.erased b) invs
+    (pts_to_view r vw)
+    (fun res -> pts_to r res)
+    (fun _ -> True)
+    (fun h res _ ->
+      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw))
+    )
+=
+  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
+  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
+  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
+  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
+  intro_vdep2
+    (pts_to_view r vw)
+    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
+    f
+    (Ghost.reveal g);
+  A.rewrite_slprop
+    (vdep (pts_to_view r vw) f)
+    (pts_to r res)
+    (fun m ->
+      interp_vdep_hp (pts_to_view r vw) f m;
+      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
+      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
+      pts_to_view_elim_lemma r vw m
+    );
+  res
+
+let opt_view
+  (a: Type)
+: Tot (sel_view (opt_pcm #a) a)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> Some?.v x);
+  to_carrier = (fun z  -> Some z);
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun x frame -> ());
+}
+
+let frac_view
+  (a: Type)
+  (p: perm)
+: Tot (sel_view (pcm_frac #a) a)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> let Some (v, _) = x in v);
+  to_carrier = (fun v -> Some (v, p));
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun v frame -> ());
+}
+
+let uninit_view
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> True
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit x' -> InitOrUnit (w.to_view x')
+  );
+  to_carrier = (fun v -> match v with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
+  );
+  to_carrier_not_one = (fun v -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'
+  );
+  to_view_frame = (fun v frame -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  );
+}
+
+let uninit_view_initialized
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> False
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | InitOrUnit x' -> w.to_view x'
+  );
+  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
+  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
+  to_view_frame = (fun v frame ->
+    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
+  );
+}
diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/examples/steel/arraystructs/Steel.C.Struct.fst
new file mode 100644
index 00000000000..f9e066cc8cc
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Struct.fst
@@ -0,0 +1,334 @@
+module Steel.C.Struct
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Ref
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+(** A PCM for structs *)
+
+/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
+
+open FStar.FunctionalExtensionality
+open FStar.Classical
+let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality 'a 'b f g;
+  forall_intro fg
+
+let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
+  forall k. composable (p k) (x k) (y k)
+
+let prod_op (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: restricted_t 'a 'b
+= on_domain 'a (fun k -> op (p k) (x k) (y k))
+
+let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
+  on_domain 'a (fun k -> one (p k))
+
+let prod_comm (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: Lemma (prod_op p x y == prod_op p y x)
+= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
+
+let prod_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+: Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)]
+  = (p k).assoc (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+: Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)]
+  = (p k).assoc_r (x k) (y k) (z k)
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> (p k).assoc (x k) (y k) (z k))
+
+let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
+: Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+= let is_unit k
+  : Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)]
+  = (p k).is_unit (x k)
+  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
+
+let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
+  (exists (k: 'a). True) /\ (forall k. (p k).refine (x k))
+
+let prod_pcm' (p:(k:'a -> pcm ('b k))): FStar.PCM.pcm (restricted_t 'a 'b) = {
+  comm = prod_comm p;
+  FStar.PCM.p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
+
+let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
+  let p' = prod_pcm' p in
+  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
+    x `feq` one p' /\ y `feq` one p'
+  ));
+  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
+  p'
+
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+let field_to_struct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (restricted_t a b)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let field_to_struct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (prod_pcm p))
+= mkmorphism
+    (field_to_struct_f p k)
+    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
+        ())
+
+let struct_to_field_f
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: restricted_t a b)
+: Tot (b k)
+= x k
+
+let struct_to_field
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (prod_pcm p) (p k))
+= mkmorphism
+    (struct_to_field_f p k) ()
+    (fun x1 x2 -> ())
+
+let struct_field_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    (prod_pcm p).refine v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (restricted_t a b)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else v k'
+    )
+
+#push-options "--query_stats --z3rlimit 30"
+
+let struct_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    (prod_pcm p).refine v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Lemma
+  (let v_new = struct_field_lift_fpu' p k x y f v in
+    (prod_pcm p).refine v_new /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
+    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_struct p k).morph y in
+  let v_new = struct_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  assert (forall (frame: b k) .
+    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
+    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
+    composable (prod_pcm p) y' frame' /\
+    op (prod_pcm p) frame' y' `feq` v_new
+  ));
+  assert (compatible (prod_pcm p) y' v_new);
+  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
+  ()
+
+#pop-options
+
+let struct_field_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
+= fun v ->
+    struct_field_lift_fpu_prf p k x y f v;
+    struct_field_lift_fpu' p k x y f v
+
+let struct_field
+  (#a: eqtype)
+  (#b: a -> Type u#b)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (prod_pcm p) (p k))
+= mkconnection
+    (field_to_struct p k)
+    (struct_to_field p k)
+    ()
+    (struct_field_lift_fpu p k)
+
+let exclusive_struct_intro
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+: Lemma
+  (requires (
+    forall k . exclusive (p k) (struct_to_field_f p k x)
+  ))
+  (ensures (
+    exclusive (prod_pcm p) x
+  ))
+  [SMTPat (exclusive (prod_pcm p) x)]
+=
+  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
+
+let exclusive_struct_elim
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+  (k: a)
+: Lemma
+  (requires (exclusive (prod_pcm p) x))
+  (ensures (exclusive (p k) (struct_to_field_f p k x)))
+=
+  let phi
+    frame
+  : Lemma
+    (requires (composable (p k) (struct_to_field_f p k x) frame))
+    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
+    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
+  = let x' = struct_to_field_f p k x in
+    let f' = field_to_struct_f p k frame in
+    let psi
+      k'
+    : Lemma
+      (composable (p k') (x k') (f' k'))
+      [SMTPat (composable (p k') (x k') (f' k'))]
+    = if k' = k
+      then ()
+      else is_unit (p k') (x k')
+    in
+    ()
+  in
+  ()
+
+let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
+
+let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: Lemma (
+    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
+    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+
+let addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
+let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (x:b k) (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then x else xs k')
+
+let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (x: b k) (xs: restricted_t a b)
+: Lemma
+    (requires xs k == one (p k))
+    (ensures
+      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
+      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  Classical.forall_intro_3 (fun k -> (p k).comm);
+  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
+
+let unaddr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (prod_pcm p))
+  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
+: Steel unit
+    ((r `pts_to` xs) `star` (r' `pts_to` x))
+    (fun s -> r `pts_to` struct_with_field p k x xs)
+    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
+    (ensures fun _ _ _ -> True)
+= unfocus r' r (struct_field p k) x;
+  gather r xs (field_to_struct_f p k x);
+  struct_unpeel p k x xs;
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  A.return ()
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
new file mode 100644
index 00000000000..0f1f4d41453
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -0,0 +1,376 @@
+module Steel.C.Union
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Ref
+open Steel.C.Struct
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+(** A PCM for unions *)
+
+open FStar.FunctionalExtensionality
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
+  forall k'. ~ (k == k') ==> f k' == one (p k')
+
+let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
+: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
+
+let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
+    (ensures f == one (prod_pcm p))
+= ext f (one (prod_pcm p)) (fun k -> ())
+
+let is_union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) (f: restricted_t a b) =
+  (exists (k:a). True) ==> (exists k. case_refinement_f p k f)
+  (** precondition is there because we don't care if 'a is inhabited *)
+
+let union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) = f:restricted_t a b{is_union p f}
+
+let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
+  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
+    [SMTPat (case_refinement_f p k f)]))
+: Lemma (forall (j:'a). goal)
+= let _ = cont in ()
+
+let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
+  (k:'a{case_refinement_f p k f})
+: Lemma (is_union p f)
+= ()
+
+let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
+  forall j k.
+  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
+  j == k /\ composable (p k) (f k) (g k)
+
+let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (union_comp p f g)
+= let _ = h in ()
+
+let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
+: Lemma
+    (requires union_comp p f g)
+    (ensures prod_comp p f g)
+    [SMTPat (union_comp p f g)]
+= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
+
+let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p k f /\ f k == one (p k))
+    (ensures f == one (prod_pcm p))
+    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
+= ext f (one (prod_pcm p)) (fun _ -> ())
+
+let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
+    (ensures
+      f == one (prod_pcm p) \/
+      g == one (prod_pcm p) \/ 
+      case_refinement_f p k (prod_op p f g))
+    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
+= let fj_or_gk_one
+  : squash
+      (f j == one (p j) \/ g k == one (p k) ==>
+       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
+  = ()
+  in let fj_gk_both_not_one ()
+  : Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures case_refinement_f p k (prod_op p f g))
+  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+  in
+  FStar.Classical.move_requires fj_gk_both_not_one ();
+  assert
+   ((f j == one (p j) \/ g k == one (p k)) ==>
+    f == one (prod_pcm p) \/
+    g == one (prod_pcm p) \/ 
+    case_refinement_f p k (prod_op p f g))
+
+let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
+  let h = prod_op p f g in
+  let goal = is_union p h in
+  union_elim p f goal (fun j ->
+  union_elim p g goal (fun k ->
+  case_refinement_f_op p j k f g;
+  (prod_pcm p).is_unit g));
+  h
+
+let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
+
+let union_refine (p:(k:'a -> pcm ('b k))) (u: union p): Tot prop = exists k. (p k).refine (u k)
+
+let union_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
+: Lemma (union_comp p x y /\
+         union_comp p (union_op p x y) z /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+#restart-solver
+#push-options "--query_stats --z3rlimit 32"
+
+let union_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
+: Lemma (union_comp p y z /\
+         union_comp p x (union_op p y z) /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc_r p x y z;
+  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ())
+
+#pop-options
+
+let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
+: Lemma (union_comp p x (union_one p) /\
+         union_op p x (union_one p) == x)
+= (prod_pcm p).is_unit x
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
+  let p' = {
+    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
+    comm = (fun x y -> prod_comm p x y);
+    assoc = union_assoc p;
+    assoc_r = union_assoc_r p;
+    is_unit = union_is_unit p;
+    refine = union_refine p;
+  } in
+  let aux (x:union p) (y:union p{composable p' x y})
+  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+    [SMTPat (op p' x y)]
+  = ext x (one p') (fun k -> let _ = p k in ());
+    ext y (one p') (fun k -> let _ = p k in ())
+  in
+  assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
+  p'
+
+let field_to_union_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (union p)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let field_to_union
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (union_pcm p))
+= mkmorphism
+    (field_to_union_f p k)
+    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
+        ())
+
+let union_to_field_f
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: union p)
+: Tot (b k)
+= x k
+
+let union_to_field
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (union_pcm p) (p k))
+= mkmorphism
+    (union_to_field_f p k) ()
+    (fun x1 x2 -> ())
+
+let union_field_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: union p {
+    (union_pcm p).refine v /\
+    compatible (union_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (union p)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else one (p k')
+    )
+
+#restart-solver
+#push-options "--z3rlimit 32 --query_stats"
+
+let union_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: union p {
+    (union_pcm p).refine v /\
+    compatible (union_pcm p) ((field_to_union p k).morph x) v
+  })
+: Lemma
+  (let v_new = union_field_lift_fpu' p k x y f v in
+    (union_pcm p).refine v_new /\
+    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
+    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
+       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_union p k).morph y in
+  let v_new = union_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  let frame : b k = compatible_elim (p k) y (f (v k)) in
+  let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
+  assert (composable (union_pcm p) y' frame');
+  assert (op (union_pcm p) frame' y' `feq` v_new);
+  compatible_intro (union_pcm p) y' v_new frame';
+  let x = Ghost.reveal x in
+  let aux (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame})
+  : Lemma (
+      composable (union_pcm p) ((field_to_union p k).morph y) frame /\
+      (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
+       op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
+  = assert_norm (
+     op (union_pcm p) ((field_to_union p k).morph x) frame k ==
+     op (p k) x (frame k));
+    assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
+       op (p k) x (frame k) == v k)
+  in FStar.Classical.forall_intro aux; ()
+
+#pop-options
+
+let union_field_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
+= fun v ->
+    union_field_lift_fpu_prf p k x y f v;
+    union_field_lift_fpu' p k x y f v
+
+let union_field
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (union_pcm p) (p k))
+= mkconnection
+    (field_to_union p k)
+    (union_to_field p k)
+    ()
+    (union_field_lift_fpu p k)
+
+module I = FStar.IndefiniteDescription
+let case_of_union (p:(k:'a -> pcm ('b k))) (u: union p)
+: GTot (k:option 'a{match k with Some k -> ~ (u k == one (p k)) | None -> u == one (union_pcm p)})
+= if I.strong_excluded_middle (exists k. ~ (u k == one (p k))) then
+    let k = I.indefinite_description_ghost 'a (fun k -> ~ (u k == one (p k))) in
+    Some k
+  else begin
+    assert (u `feq` one (union_pcm p));
+    None
+  end
+
+let exclusive_union_intro
+  (#a: Type)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
+  (ensures (exclusive (union_pcm p) x))
+= let phi
+    (frame: union p)
+  : Lemma
+    (requires (composable (union_pcm p) x frame))
+    (ensures (frame `feq` union_one p))
+    [SMTPat (composable (union_pcm p) x frame)]
+  = ()
+  in
+  ()
+
+let exclusive_union_elim
+  (#a: eqtype)
+  (#b: _)
+  (p: (k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (union_pcm p) x))
+  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
+  then ()
+  else
+    let phi
+      (frame: b k)
+    : Lemma
+      (requires (composable (p k) (x k) frame))
+      (ensures (frame == one (p k)))
+      [SMTPat (composable (p k) (x k) frame)]
+    = let frame' = field_to_union_f p k frame in
+      ()
+    in
+    ()
+    
+let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: union p{~ (xs k == one (p k))})
+: Lemma (xs == field_to_union_f p k (xs k))
+= assert (xs `feq` field_to_union_f p k (xs k))
+
+let addr_of_union_field
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref base (union_pcm p)) (k:a)
+  (xs: Ghost.erased (union p))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun r' -> r' `pts_to` Ghost.reveal xs k)
+    (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
+    (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
+= union_peel p k xs;
+  A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
+  focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
+
+let unaddr_of_union_field
+  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (union_pcm p))
+  (x: Ghost.erased (b k))
+: A.SteelGhost unit opened
+    (r' `pts_to` x)
+    (fun s -> r `pts_to` field_to_union_f p k x)
+    (requires fun _ -> r' == ref_focus r (union_field p k))
+    (ensures fun _ _ _ -> True)
+= unfocus r' r (union_field p k) x
diff --git a/examples/steel/arraystructs/Steel.PCM.fst b/examples/steel/arraystructs/Steel.PCM.fst
new file mode 100644
index 00000000000..c5fc84fcaf6
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.PCM.fst
@@ -0,0 +1,12 @@
+module Steel.C.PCM
+
+unfold
+let one (#a: Type) (p: pcm a) = p.p.one
+
+let pcm (a: Type) : Tot Type =
+  (p: FStar.PCM.pcm a {
+    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
+      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
+    (forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
+    (~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+  })

From 706025e13373cc60c6507466d026e630456363a5 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 11:47:16 -0700
Subject: [PATCH 099/513] Get examples to typecheck again

---
 .../arraystructs/AggregateRefExamples.fst     |  1 +
 .../steel/arraystructs/FStar.PCM.POD.fsti     |  1 +
 examples/steel/arraystructs/IntOrBool.fst     | 13 +++
 examples/steel/arraystructs/IntOrBool.fsti    |  2 +
 examples/steel/arraystructs/LineStruct.fst    |  4 +
 examples/steel/arraystructs/LineStruct.fsti   |  4 +-
 examples/steel/arraystructs/ListExample.fst   |  1 +
 examples/steel/arraystructs/ListNode.fst      | 25 +++---
 examples/steel/arraystructs/ListNode.fsti     |  2 +
 examples/steel/arraystructs/PointStruct.fst   |  2 +
 examples/steel/arraystructs/PointStruct.fsti  |  2 +
 examples/steel/arraystructs/Steel.C.Frac.fst  | 10 ---
 examples/steel/arraystructs/Steel.C.Opt.fst   | 81 -------------------
 examples/steel/arraystructs/Steel.C.Ref.fst   |  8 ++
 examples/steel/arraystructs/Steel.C.Union.fst |  1 +
 15 files changed, 54 insertions(+), 103 deletions(-)
 delete mode 100644 examples/steel/arraystructs/Steel.C.Frac.fst
 delete mode 100644 examples/steel/arraystructs/Steel.C.Opt.fst

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index f7c1d2c736a..416e5882232 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -1,6 +1,7 @@
 module AggregateRefExamples
 
 open Steel.C.PCM
+open Steel.C.Ref
 
 open Steel.Effect
 module A = Steel.Effect.Atomic
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fsti b/examples/steel/arraystructs/FStar.PCM.POD.fsti
index 2f05c79943f..73cc1365c6d 100644
--- a/examples/steel/arraystructs/FStar.PCM.POD.fsti
+++ b/examples/steel/arraystructs/FStar.PCM.POD.fsti
@@ -2,6 +2,7 @@ module FStar.PCM.POD
 
 open FStar.PCM
 open Steel.C.PCM
+open Steel.C.Ref
 open Steel.Effect
 
 let pod: Type u#a -> Type u#a = option
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index 007c3d1d67d..fd83e624356 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -5,7 +5,11 @@ module IntOrBool
 open FStar.PCM
 open FStar.PCM.POD
 open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.C.Union
 open Steel.Effect
+
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
 module U = FStar.Universe
@@ -86,6 +90,15 @@ let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (G
 : frame_preserving_upd int_or_bool_pcm u (mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide i)))))
 = base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm I (Some i))
 
+#push-options "--z3rlimit 30"
+
+let exclusive_not_unit (#u: Ghost.erased int_or_bool)
+: Lemma
+    (requires exclusive int_or_bool_pcm u)
+    (ensures Some? (case_of_int_or_bool u))
+    [SMTPat (exclusive int_or_bool_pcm u)]
+= admit()
+
 let switch_to_int (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : Steel unit
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 89700769228..bdf59334c39 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -3,6 +3,8 @@ module IntOrBool
 open FStar.PCM
 open FStar.PCM.POD
 open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
 open Steel.Effect
 module M = Steel.Memory
 module A = Steel.Effect.Atomic
diff --git a/examples/steel/arraystructs/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
index d24adcc3a64..425aa81329a 100644
--- a/examples/steel/arraystructs/LineStruct.fst
+++ b/examples/steel/arraystructs/LineStruct.fst
@@ -1,6 +1,10 @@
 module LineStruct
 
 open FStar.FunctionalExtensionality
+open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.C.Struct
 module A = Steel.Effect.Atomic
 
 /// Example 2: pointers to nested fields
diff --git a/examples/steel/arraystructs/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
index 9b0ad0b8fa7..ebe61985cf8 100644
--- a/examples/steel/arraystructs/LineStruct.fsti
+++ b/examples/steel/arraystructs/LineStruct.fsti
@@ -5,6 +5,8 @@ open FStar.PCM
 open Steel.Effect
 open PointStruct
 open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Ref
 
 /// Example 2: pointers to nested fields
 ///
@@ -23,7 +25,7 @@ val line_pcm : pcm line
 
 val mk_line (x y: Ghost.erased point): Ghost.erased line
 
-/// Lenses for fields
+/// Connections for fields
 
 #push-options "--print_universes"
 
diff --git a/examples/steel/arraystructs/ListExample.fst b/examples/steel/arraystructs/ListExample.fst
index 60bea150901..05f6196d31b 100644
--- a/examples/steel/arraystructs/ListExample.fst
+++ b/examples/steel/arraystructs/ListExample.fst
@@ -1,6 +1,7 @@
 module ListExample
 
 open Steel.C.PCM
+open Steel.C.Ref
 
 open Steel.Effect
 module A = Steel.Effect.Atomic
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 6f0b963cbc7..8ebb298ade6 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -8,6 +8,9 @@ open Steel.Effect
 open FStar.PCM
 open FStar.PCM.POD
 open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.C.Struct
 module U = FStar.Universe
 
 type node_field = | Value | Next
@@ -42,17 +45,17 @@ let node_pcm: pcm node = {
   refine = (fun x -> node_pcm'.refine x.un_node);
 }
 
-let roll: node_pcm' `morphism` node_pcm = {
-  morph = Mknode;
-  morph_unit = ();
-  morph_compose = (fun _ _ -> ());
-}
-
-let unroll: node_pcm `morphism` node_pcm' = {
-  morph = Mknode?.un_node;
-  morph_unit = ();
-  morph_compose = (fun _ _ -> ());
-}
+let roll: node_pcm' `morphism` node_pcm =
+  mkmorphism
+    Mknode
+    ()
+    (fun _ _ -> ())
+
+let unroll: node_pcm `morphism` node_pcm' =
+  mkmorphism
+    Mknode?.un_node
+    ()
+    (fun _ _ -> ())
 
 let mk_un_node: squash (Mknode `is_inverse_of` Mknode?.un_node) = ()
 let un_mk_node: squash (Mknode?.un_node `is_inverse_of` Mknode) = ()
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index e6a98081453..3fd0228ce73 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -5,6 +5,8 @@ open FStar.PCM
 open Steel.Effect
 open PointStruct
 open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
 module U = FStar.Universe
 
 let ref'_f a b (pb: Ghost.erased (pcm b)) = ref a (Ghost.reveal pb)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index aabc1fd7d8f..74a06912778 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -2,6 +2,8 @@ module PointStruct
 
 open FStar.PCM.POD
 open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Struct
 open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index 6ccfd5a801a..f06783775b4 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -3,6 +3,8 @@ module PointStruct
 open FStar.PCM.POD
 open FStar.PCM
 open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
 open Steel.Effect
 
 /// Suppose we have the following struct representing 2d points:
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fst b/examples/steel/arraystructs/Steel.C.Frac.fst
deleted file mode 100644
index a5d6706b479..00000000000
--- a/examples/steel/arraystructs/Steel.C.Frac.fst
+++ /dev/null
@@ -1,10 +0,0 @@
-module Steel.C.Frac
-
-open FStar.PCM
-open Steel.C.PCM
-open Steel.C.Connection
-open Steel.C.Ref
-open Steel.C.Opt
-open Steel.Effect
-module A = Steel.Effect.Atomic
-
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fst b/examples/steel/arraystructs/Steel.C.Opt.fst
deleted file mode 100644
index ab17d1c3ea6..00000000000
--- a/examples/steel/arraystructs/Steel.C.Opt.fst
+++ /dev/null
@@ -1,81 +0,0 @@
-module Steel.C.Opt
-
-open FStar.PCM
-open Steel.C.PCM
-open Steel.C.Connection
-open Steel.C.Ref
-open Steel.Effect
-module A = Steel.Effect.Atomic
-
-
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let opt_pcm #a : pcm (option a) = {
-  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x == true);
-}
-
-let exclusive_opt
-  (#a: Type)
-  (x: option a)
-: Lemma
-  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
-=
-  match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      assert (composable opt_pcm x (Some y))
-    end else begin
-      let phi
-        (frame: option a)
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some z -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some _ -> ()
-
-let opt_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
-  (y: a)
-: Tot (frame_preserving_upd opt_pcm x (Some y))
-= base_fpu opt_pcm x (Some y)
-
-let opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ _ _ -> True))
-
-//let opt_pcm_write r x y
-= ref_upd r x (Some y) (opt_pcm_fpu x y)
-
-let opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-
-//let opt_pcm_read r x
-= let y' = ref_read r in
-  assert (Ghost.reveal x == y');
-  Some?.v y'
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index 52362165c2a..793cf9a3273 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -38,6 +38,14 @@ let split r xy x y =
     (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
     (r `pts_to` y)
 
+let mgather
+  (#a:Type) (#p:pcm a)
+  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
+: SteelT (_:unit{composable p v0 v1})
+    (mpts_to r v0 `star` mpts_to r v1)
+    (fun _ -> mpts_to r (op p v0 v1))
+= Steel.PCMReference.gather r v0 v1
+
 let gather #a #b #p r x y =
   A.change_equal_slprop
     (r `pts_to` x)
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 0f1f4d41453..37102f9ea06 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -364,6 +364,7 @@ let addr_of_union_field
   A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
   focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
 
+module M = Steel.Memory 
 let unaddr_of_union_field
   (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
   (r': ref base (p k)) (r: ref base (union_pcm p))

From 4c44e25e9b6fa5c2aa46ac977987e50bd66e5ccf Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 12:25:01 -0700
Subject: [PATCH 100/513] Add OOM example

---
 .../steel/arraystructs/ListExampleOOM.fst     | 34 +++++++++++
 examples/steel/arraystructs/ListNodeOOM.fsti  | 57 +++++++++++++++++++
 2 files changed, 91 insertions(+)
 create mode 100644 examples/steel/arraystructs/ListExampleOOM.fst
 create mode 100644 examples/steel/arraystructs/ListNodeOOM.fsti

diff --git a/examples/steel/arraystructs/ListExampleOOM.fst b/examples/steel/arraystructs/ListExampleOOM.fst
new file mode 100644
index 00000000000..d4f6ba5f85a
--- /dev/null
+++ b/examples/steel/arraystructs/ListExampleOOM.fst
@@ -0,0 +1,34 @@
+module ListExampleOOM
+
+open Steel.C.PCM
+open Steel.C.Ref
+
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+open FStar.PCM.POD
+open ListNodeOOM
+
+(*
+let ok
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node none next) `star`
+       (q `pts_to` value))
+= addr_of_value #'a #value #next p
+*)
+
+let oom
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node value none) `star`
+       (q `pts_to` next))
+= addr_of_next #'a #value #next p
diff --git a/examples/steel/arraystructs/ListNodeOOM.fsti b/examples/steel/arraystructs/ListNodeOOM.fsti
new file mode 100644
index 00000000000..60a316acfa0
--- /dev/null
+++ b/examples/steel/arraystructs/ListNodeOOM.fsti
@@ -0,0 +1,57 @@
+module ListNodeOOM
+
+open FStar.PCM.POD
+open FStar.PCM
+open Steel.Effect
+open PointStruct
+open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
+module U = FStar.Universe
+
+let ref'_f a b (pb: Ghost.erased (pcm b)) = ref a (Ghost.reveal pb)
+let ref' a b = dtuple2 (Ghost.erased (pcm b)) (ref'_f a b)
+
+let int': Type u#1 = U.raise_t int
+
+/// struct node { int value; struct node *next; };
+
+val node: Type u#1
+
+/// PCM for node:
+
+val node_pcm: pcm node
+
+/// (mk_node value next) represents (struct node){.value = value, .next = next}
+
+val mk_node
+  (i: Ghost.erased (pod int'))
+  (next: Ghost.erased (pod (option (ref' node node))))
+: Ghost.erased node
+
+/// Lenses for fields
+
+val _value: node_pcm `connection` pod_pcm int'
+val _next: node_pcm `connection` pod_pcm (option (ref' node node))
+
+/// Taking pointers to the fields of a node
+
+val addr_of_value
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node none next) `star`
+       (q `pts_to` value))
+
+val addr_of_next
+  (#value:Ghost.erased (pod int'))
+  (#next:Ghost.erased (pod (option (ref' node node))))
+  (p: ref 'a node_pcm)
+: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node value none) `star`
+       (q `pts_to` next))

From a0f7f909fa61a99ada12329b96fa24247a707a42 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 12:37:31 -0700
Subject: [PATCH 101/513] Remove an admit

---
 examples/steel/arraystructs/Steel.C.Ref.fst | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index 793cf9a3273..6aaae9cf950 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -106,8 +106,7 @@ let pts_to_view_explicit_witinv
   (vw: sel_view p c)
 : Lemma
   (M.is_witness_invariant (pts_to_view_explicit r vw))
-= admit() (*
-  let aux (x y : Ghost.erased c) (m:M.mem)
+= let aux (x y : Ghost.erased c) (m:M.mem)
   : Lemma
     (requires (M.interp (pts_to_view_explicit r vw x) m /\ M.interp (pts_to_view_explicit r vw y) m))
     (ensures  (x == y))
@@ -131,4 +130,3 @@ let pts_to_view_explicit_witinv
     ()
   in
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
-  *)

From f06118e168f8b04e0fea3fa6a92fbb5f44d20532 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 12:41:39 -0700
Subject: [PATCH 102/513] Remove another admit

---
 examples/steel/arraystructs/IntOrBool.fst | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index fd83e624356..5d64c116039 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -90,14 +90,13 @@ let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (G
 : frame_preserving_upd int_or_bool_pcm u (mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide i)))))
 = base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm I (Some i))
 
-#push-options "--z3rlimit 30"
-
 let exclusive_not_unit (#u: Ghost.erased int_or_bool)
 : Lemma
     (requires exclusive int_or_bool_pcm u)
     (ensures Some? (case_of_int_or_bool u))
     [SMTPat (exclusive int_or_bool_pcm u)]
-= admit()
+= int_or_bool_pcm.is_unit (field_to_union_f int_or_bool_cases_pcm I (Some 42));
+  assert (~ (Ghost.reveal u == one int_or_bool_pcm))
 
 let switch_to_int (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (i: int)

From 961c1c5ce8e04e46649feb6f78ff9e1efd093805 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 13:40:37 -0700
Subject: [PATCH 103/513] Modularize various Steel PCMs

---
 .../arraystructs/AggregateRefExamples.fst     |  44 +-
 examples/steel/arraystructs/FStar.PCM.POD.fst |  12 -
 .../steel/arraystructs/FStar.PCM.POD.fsti     |  30 --
 examples/steel/arraystructs/IntOrBool.fst     |  45 +-
 examples/steel/arraystructs/IntOrBool.fsti    |  66 ++-
 examples/steel/arraystructs/Steel.C.Frac.fst  |  50 +++
 examples/steel/arraystructs/Steel.C.Frac.fsti |  77 ++++
 examples/steel/arraystructs/Steel.C.Opt.fst   |  30 ++
 examples/steel/arraystructs/Steel.C.Opt.fsti  | 103 +++++
 examples/steel/arraystructs/Steel.C.Ref.fsti  | 414 ------------------
 .../steel/arraystructs/Steel.C.Uninit.fsti    | 234 ++++++++++
 11 files changed, 590 insertions(+), 515 deletions(-)
 delete mode 100644 examples/steel/arraystructs/FStar.PCM.POD.fst
 delete mode 100644 examples/steel/arraystructs/FStar.PCM.POD.fsti
 create mode 100644 examples/steel/arraystructs/Steel.C.Frac.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Frac.fsti
 create mode 100644 examples/steel/arraystructs/Steel.C.Opt.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Opt.fsti
 create mode 100644 examples/steel/arraystructs/Steel.C.Uninit.fsti

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 416e5882232..d625873ac7b 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -142,18 +142,46 @@ let int_or_bool_int_swap
 
 /// Convert an int_or_bool + runtime tag into an int
 ///
-/// int int_or_bool_to_int(bool *is_int, union int_or_bool *p) {
-///   if (*is_int) return p->i;
+/// int int_or_bool_to_int(bool is_int, union int_or_bool *p) {
+///   if (is_int) return p->i;
 ///   else return p->b ? 1 : 0;
 /// }
-val int_or_bool_to_int
-  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
-  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
+
+module I = FStar.IndefiniteDescription
+
+let int_or_bool_to_int
+  (is_int: bool)
+  (p: ref 'b int_or_bool_pcm)
+  (u: Ghost.erased int_or_bool)
 : Steel int
-    ((is_int `pts_to` some b) `star` (p `pts_to` u))
-    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
-    (requires fun _ -> if b then (exists i. u == mk_int i) else (exists b. u == mk_bool b))
+    (p `pts_to` u)
+    (fun _ -> p `pts_to` u)
+    (requires fun _ ->
+      if is_int then case_of_int_or_bool u == Some I 
+      else case_of_int_or_bool u == Some B)
     (ensures fun _ _ _ -> True)
+= if is_int then begin
+    //let i: Ghost.erased (pod int) =
+    //  I.indefinite_description_ghost (Ghost.erased (pod int)) (fun i -> u == mk_int i)
+    //in
+    let i: (i:Ghost.erased (pod int){u == mk_int i}) =
+      I.indefinite_description_tot (Ghost.erased (pod int)) (fun i -> u == mk_int i)
+    in
+    assert (u == mk_int i);
+    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int i);
+    let pi = addr_of_i p in
+    //let i = pod_read pi in
+    //unaddr_of_i p pi;
+    //A.return i
+    A.sladmit(); A.return (admit())
+  end else begin
+    //let pb = addr_of_b p in
+    //let b = pod_read pb in
+    //unaddr_of_b p pb;
+    //if b then A.return 1 else A.return 0
+    A.sladmit(); A.return (admit())
+  end
+
 (*= let b = pod_read is_int in
   if b then begin
     (* return p->i *)
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fst b/examples/steel/arraystructs/FStar.PCM.POD.fst
deleted file mode 100644
index 0b93c5daaa3..00000000000
--- a/examples/steel/arraystructs/FStar.PCM.POD.fst
+++ /dev/null
@@ -1,12 +0,0 @@
-module FStar.PCM.POD
-
-open Steel.C.PCM
-module A = Steel.Effect.Atomic
-
-let pod_read r =
-  let Some x = ref_read r in
-  x
-
-let pod_write #a #b #x r y =
-  ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
diff --git a/examples/steel/arraystructs/FStar.PCM.POD.fsti b/examples/steel/arraystructs/FStar.PCM.POD.fsti
deleted file mode 100644
index 73cc1365c6d..00000000000
--- a/examples/steel/arraystructs/FStar.PCM.POD.fsti
+++ /dev/null
@@ -1,30 +0,0 @@
-module FStar.PCM.POD
-
-open FStar.PCM
-open Steel.C.PCM
-open Steel.C.Ref
-open Steel.Effect
-
-let pod: Type u#a -> Type u#a = option
-
-let none #a: Ghost.erased (pod a) = None
-
-let some (x: Ghost.erased 'a): Ghost.erased (pod 'a) = Some (Ghost.reveal x)
-
-let pod_pcm (a:Type): pcm (pod a) = opt_pcm #a
-
-val pod_read
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (r: ref a (pod_pcm b))
-: Steel b
-    (r `pts_to` some x)
-    (fun _ -> r `pts_to` some x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> Ghost.reveal x == x')
-
-val pod_write
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (r: ref a (pod_pcm b)) (y: b)
-: SteelT unit
-    (r `pts_to` some x)
-    (fun _ -> r `pts_to` some (Ghost.hide y))
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index 5d64c116039..1fc10daaf80 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -55,39 +55,30 @@ let mk_int_exclusive i = exclusive_union_intro int_or_bool_cases_pcm (mk_int i)
 
 let mk_bool_exclusive b = exclusive_union_intro int_or_bool_cases_pcm (mk_bool b) B
 
-let addr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
+let addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
+: Steel (q:ref 'a (pod_pcm int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
-    (fun q -> q `pts_to` Ghost.reveal i)
-= let q = addr_of_union_field p I (mk_int i) in
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  A.return q
+    (fun q -> q `pts_to` i)
+    (requires fun _ -> ~ (i == none))
+    (ensures fun _ _ _ -> True)
+= addr_of_union_field p I (mk_int i)
 
-let unaddr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (#opened: M.inames)
+let unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm int){q == ref_focus p _i})
-: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal i) (fun _ -> p `pts_to` mk_int i)
-= unaddr_of_union_field I q p (Ghost.reveal i);
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
-    (p `pts_to` mk_bool b)
-    (fun q -> q `pts_to` Ghost.reveal b)
-= let q = addr_of_union_field p B (mk_bool b) in
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  A.return q
-
-let unaddr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (#opened: M.inames)
+= unaddr_of_union_field I q p i
+
+let addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
+= addr_of_union_field p B (mk_bool b)
+
+let unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
-: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal b) (fun _ -> p `pts_to` mk_bool b)
-= unaddr_of_union_field B q p (Ghost.reveal b);
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+= unaddr_of_union_field B q p b
 
 let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (Ghost.reveal u)})
   (p: ref 'a int_or_bool_pcm) (i: int)
-: frame_preserving_upd int_or_bool_pcm u (mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide i)))))
+: frame_preserving_upd int_or_bool_pcm u (mk_int (some (Ghost.hide i)))
 = base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm I (Some i))
 
 let exclusive_not_unit (#u: Ghost.erased int_or_bool)
@@ -102,7 +93,7 @@ let switch_to_int (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : Steel unit
     (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_int (Ghost.hide (Ghost.reveal (some i))))
+    (fun _ -> p `pts_to` mk_int (some i))
     (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
 = ref_upd p _ _ (switch_to_int_fpu p i)
@@ -111,8 +102,8 @@ let switch_to_bool (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (b: bool)
 : Steel unit
     (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_bool (Ghost.hide (Ghost.reveal (some b))))
+    (fun _ -> p `pts_to` mk_bool (some (Ghost.hide b)))
     (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
-= ref_upd p u (mk_bool (Ghost.hide (Ghost.reveal (some (Ghost.hide b)))))
+= ref_upd p u (mk_bool (some (Ghost.hide b)))
     (base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm B (Some b)))
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index bdf59334c39..7759c337e3f 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -24,10 +24,8 @@ val int_or_bool_pcm: pcm int_or_bool
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
 
-let nonunit (p: pcm 'a) = x:'a{~ (x == one p)}
-
-val mk_int (i: Ghost.erased (nonunit (pod_pcm int))): Ghost.erased int_or_bool
-val mk_bool (b: Ghost.erased (nonunit (pod_pcm bool))): Ghost.erased int_or_bool
+val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
+val mk_bool (b: Ghost.erased (pod bool)): Ghost.erased int_or_bool
 
 /// Connections for cases
 
@@ -44,44 +42,64 @@ val case_of_int_or_bool (u: Ghost.erased int_or_bool):
     | None -> Ghost.reveal u == one int_or_bool_pcm
   })
 
-val case_of_int_or_bool_int (i: Ghost.erased (nonunit (pod_pcm int)))
-: Lemma (case_of_int_or_bool (mk_int i) == Some I) [SMTPat (mk_int i)]
+val case_of_int_or_bool_int (i: Ghost.erased (pod int))
+: Lemma
+    (requires ~ (i == none))
+    (ensures case_of_int_or_bool (mk_int i) == Some I) [SMTPat (mk_int i)]
 
-val case_of_int_or_bool_bool (b: Ghost.erased (nonunit (pod_pcm bool)))
-: Lemma (case_of_int_or_bool (mk_bool b) == Some B) [SMTPat (mk_bool b)]
+val case_of_int_or_bool_bool (b: Ghost.erased (pod bool))
+: Lemma
+    (requires ~ (b == none))
+    (ensures case_of_int_or_bool (mk_bool b) == Some B) [SMTPat (mk_bool b)]
 
 val case_of_int_or_bool_one
 : squash (case_of_int_or_bool (one int_or_bool_pcm) == None)
 
-val mk_int_exclusive (i: Ghost.erased (nonunit (pod_pcm int)))
-: Lemma (requires exclusive (pod_pcm int) i) (ensures exclusive int_or_bool_pcm (mk_int i))
+val mk_int_exclusive (i: Ghost.erased (pod int))
+: Lemma
+    (requires exclusive (pod_pcm int) i /\ ~ (i == none))
+    (ensures exclusive int_or_bool_pcm (mk_int i))
   [SMTPat (exclusive (pod_pcm int) i)]
 
-val mk_bool_exclusive (b: Ghost.erased (nonunit (pod_pcm bool)))
-: Lemma (requires exclusive (pod_pcm bool) b) (ensures exclusive int_or_bool_pcm (mk_bool b))
+val mk_bool_exclusive (b: Ghost.erased (pod bool))
+: Lemma
+    (requires exclusive (pod_pcm bool) b /\ ~ (b == none))
+    (ensures exclusive int_or_bool_pcm (mk_bool b))
   [SMTPat (exclusive (pod_pcm bool) b)]
 
 /// Taking pointers to the i and b cases of an int_or_bool
 
-val addr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _i})
+val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
+: Steel (q:ref 'a (pod_pcm int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
-    (fun q -> q `pts_to` Ghost.reveal i)
+    (fun q -> q `pts_to` i)
+    (requires fun _ -> ~ (i == none))
+    (ensures fun _ _ _ -> True)
 
-val unaddr_of_i (#i: Ghost.erased (nonunit (pod_pcm int))) (#opened: M.inames)
+val unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm int){q == ref_focus p _i})
-: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal i) (fun _ -> p `pts_to` mk_int i)
+: A.SteelGhost unit opened
+    (q `pts_to` i)
+    (fun _ -> p `pts_to` mk_int i)
+    (requires fun _ -> ~ (i == none))
+    (ensures fun _ _ _ -> True)
 
-val addr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (p: ref 'a int_or_bool_pcm)
-: SteelT (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
+val addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
+: Steel (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
     (p `pts_to` mk_bool b)
-    (fun q -> q `pts_to` Ghost.reveal b)
+    (fun q -> q `pts_to` b)
+    (requires fun _ -> ~ (b == none))
+    (ensures fun _ _ _ -> True)
 
-val unaddr_of_b (#b: Ghost.erased (nonunit (pod_pcm bool))) (#opened: M.inames)
+val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
-: A.SteelGhostT unit opened (q `pts_to` Ghost.reveal b) (fun _ -> p `pts_to` mk_bool b)
+: A.SteelGhost unit opened
+    (q `pts_to` b)
+    (fun _ -> p `pts_to` mk_bool b)
+    (requires fun _ -> ~ (b == none))
+    (ensures fun _ _ _ -> True)
 
 /// Switching the case
 
@@ -89,7 +107,7 @@ val switch_to_int (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (i: int)
 : Steel unit
     (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_int (Ghost.hide (Ghost.reveal (some i))))
+    (fun _ -> p `pts_to` mk_int (some (Ghost.hide i)))
     (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
 
@@ -97,6 +115,6 @@ val switch_to_bool (#u: Ghost.erased int_or_bool)
   (p: ref 'a int_or_bool_pcm) (b: bool)
 : Steel unit
     (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_bool (Ghost.hide (Ghost.reveal (some b))))
+    (fun _ -> p `pts_to` mk_bool (some (Ghost.hide b)))
     (requires fun _ -> exclusive int_or_bool_pcm u)
     (ensures fun _ _ _ -> True)
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fst b/examples/steel/arraystructs/Steel.C.Frac.fst
new file mode 100644
index 00000000000..8a05552033f
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Frac.fst
@@ -0,0 +1,50 @@
+module Steel.C.Frac
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Ref
+open Steel.Effect
+  
+open Steel.FractionalPermission
+
+let frac_pcm_write r x y
+= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
+
+let frac_pcm_read r x
+= let y' = ref_read r in
+  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
+  fst (Some?.v y')
+
+let exclusive_frac
+  (#a: Type)
+  (x: option (a & perm))
+: Lemma
+  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
+= match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      let frame = Some (y, full_perm) in
+      assert (~ (frame == one pcm_frac));
+      assert (composable pcm_frac x frame)
+    end else begin
+      let phi
+        (frame: option (a & perm))
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some (z, _) -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some (y, p) ->
+    assert (exists (z: a) . True);
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
+    then ()
+    else begin
+      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
+      assert (composable pcm_frac x frame);
+      assert (~ (frame == one pcm_frac))
+    end
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fsti b/examples/steel/arraystructs/Steel.C.Frac.fsti
new file mode 100644
index 00000000000..204df178a21
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Frac.fsti
@@ -0,0 +1,77 @@
+module Steel.C.Frac
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Ref
+open Steel.Effect
+  
+/// Fractional permissions: from Steel.HigherReference
+open Steel.FractionalPermission
+
+let fractional (a:Type u#1) = option (a & perm)
+
+let fractional_composable #a : symrel (fractional a) =
+  fun (f0 f1:fractional a) ->
+    match f0, f1 with
+    | None, _
+    | _, None -> True
+    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
+
+let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
+  match f0, f1 with
+  | None, f
+  | f, None -> f
+  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
+
+let pcm_frac #a : pcm (fractional a) = {
+  FStar.PCM.p = {
+         composable = fractional_composable;
+         op = fractional_compose;
+         one = None
+      };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
+}
+
+let frac_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
+  (y: a)
+: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
+= base_fpu pcm_frac x (Some (y, full_perm))
+
+val frac_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
+  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
+  (ensures (fun _ _ _ -> True))
+
+val frac_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
+
+val exclusive_frac
+  (#a: Type)
+  (x: option (a & perm))
+: Lemma
+  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
+
+let frac_view
+  (a: Type)
+  (p: perm)
+: Tot (sel_view (pcm_frac #a) a)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> let Some (v, _) = x in v);
+  to_carrier = (fun v -> Some (v, p));
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun v frame -> ());
+}
+
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fst b/examples/steel/arraystructs/Steel.C.Opt.fst
new file mode 100644
index 00000000000..23f7fe81ca0
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Opt.fst
@@ -0,0 +1,30 @@
+module FStar.PCM.Opt
+
+open Steel.C.PCM
+module A = Steel.Effect.Atomic
+
+let opt_read r =
+  let Some x = ref_read r in
+  x
+
+let opt_write #a #b #x r y =
+  ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
+
+let opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ _ _ -> True))
+= ref_upd r x (Some y) (opt_pcm_fpu x y)
+
+let opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
+= let y' = ref_read r in
+  assert (Ghost.reveal x == y');
+  Some?.v y'
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
new file mode 100644
index 00000000000..9d63043c457
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -0,0 +1,103 @@
+module FStar.PCM.Opt
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Ref
+open Steel.Effect
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let opt_pcm #a : pcm (option a) = {
+  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x == true);
+}
+
+let option: Type u#a -> Type u#a = option
+
+let none #a: Ghost.erased (option a) = None
+
+let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
+
+val opt_read
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (opt_pcm #b))
+: Steel b
+    (r `pts_to` some x)
+    (fun _ -> r `pts_to` some x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> Ghost.reveal x == x')
+
+val opt_write
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (opt_pcm #b)) (y: b)
+: SteelT unit
+    (r `pts_to` some x)
+    (fun _ -> r `pts_to` some (Ghost.hide y))
+
+let opt_view
+  (a: Type)
+: Tot (sel_view (opt_pcm #a) a)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> Some?.v x);
+  to_carrier = (fun z  -> Some z);
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun x frame -> ());
+}
+
+let exclusive_opt
+  (#a: Type)
+  (x: option a)
+: Lemma
+  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
+=
+  match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      assert (composable opt_pcm x (Some y))
+    end else begin
+      let phi
+        (frame: option a)
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some z -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some _ -> ()
+
+let opt_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
+  (y: a)
+: Tot (frame_preserving_upd opt_pcm x (Some y))
+= base_fpu opt_pcm x (Some y)
+
+val opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ _ _ -> True))
+
+val opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (fun _ -> Some? x))
+  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index de3da6579c1..75d84437b0d 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -104,348 +104,6 @@ let base_fpu
   compatible_refl p y;
   y
 
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let opt_pcm #a : pcm (option a) = {
-  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x == true);
-}
-
-let exclusive_opt
-  (#a: Type)
-  (x: option a)
-: Lemma
-  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
-=
-  match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      assert (composable opt_pcm x (Some y))
-    end else begin
-      let phi
-        (frame: option a)
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some z -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some _ -> ()
-
-let opt_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
-  (y: a)
-: Tot (frame_preserving_upd opt_pcm x (Some y))
-= base_fpu opt_pcm x (Some y)
-
-let opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ _ _ -> True))
-
-//let opt_pcm_write r x y
-= ref_upd r x (Some y) (opt_pcm_fpu x y)
-
-let opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-
-//let opt_pcm_read r x
-= let y' = ref_read r in
-  assert (Ghost.reveal x == y');
-  Some?.v y'
-  
-/// Fractional permissions: from Steel.HigherReference
-open Steel.FractionalPermission
-
-let fractional (a:Type u#1) = option (a & perm)
-
-let fractional_composable #a : symrel (fractional a) =
-  fun (f0 f1:fractional a) ->
-    match f0, f1 with
-    | None, _
-    | _, None -> True
-    | Some (x0, p0), Some (x1, p1) -> x0==x1 /\ sum_perm p0 p1 `lesser_equal_perm` full_perm
-
-let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composable f0 f1}) : fractional a =
-  match f0, f1 with
-  | None, f
-  | f, None -> f
-  | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
-
-let pcm_frac #a : pcm (fractional a) = {
-  FStar.PCM.p = {
-         composable = fractional_composable;
-         op = fractional_compose;
-         one = None
-      };
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
-}
-
-let frac_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
-  (y: a)
-: Tot (frame_preserving_upd pcm_frac x (Some (y, full_perm)))
-= base_fpu pcm_frac x (Some (y, full_perm))
-
-let frac_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
-  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
-  (ensures (fun _ _ _ -> True))
-
-//let frac_pcm_write r x y
-= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
-
-let frac_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
-
-//let frac_pcm_read r x
-= let y' = ref_read r in
-  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
-  fst (Some?.v y')
-
-let exclusive_frac
-  (#a: Type)
-  (x: option (a & perm))
-: Lemma
-  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
-= match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      let frame = Some (y, full_perm) in
-      assert (~ (frame == one pcm_frac));
-      assert (composable pcm_frac x frame)
-    end else begin
-      let phi
-        (frame: option (a & perm))
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some (z, _) -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some (y, p) ->
-    assert (exists (z: a) . True);
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
-    then ()
-    else begin
-      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
-      assert (composable pcm_frac x frame);
-      assert (~ (frame == one pcm_frac))
-    end
-
-/// Uninitialized
-
-noeq
-type uninit_t (a: Type)
-= | Uninitialized
-  | InitOrUnit: a -> uninit_t a
-
-let uninit_composable
-  (#a: Type)
-  (p: pcm a)
-: Tot (symrel (uninit_t a))
-= fun u1 u2 ->
-  match u1, u2 with
-  | Uninitialized, InitOrUnit x
-  | InitOrUnit x, Uninitialized
-    -> x == one p
-  | InitOrUnit x1, InitOrUnit x2
-    -> composable p x1 x2
-  | _ -> False
-
-let uninit_compose
-  (#a: Type)
-  (p: pcm a)
-  (u1: uninit_t a)
-  (u2: uninit_t a { uninit_composable p u1 u2 })
-: Tot (uninit_t a)
-= match u1, u2 with
-  | Uninitialized, _
-  | _, Uninitialized
-    -> Uninitialized
-  | InitOrUnit x1, InitOrUnit x2
-    -> InitOrUnit (op p x1 x2)
-
-let uninit_refine
-  (#a: Type)
-  (p: pcm a)
-  (x: uninit_t a)
-: Tot prop
-= match x with
-  | Uninitialized -> True
-  | InitOrUnit y -> p.refine y
-
-let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
-  FStar.PCM.p = {
-         composable = uninit_composable p;
-         op = uninit_compose p;
-         one = InitOrUnit (one p);
-      };
-  comm = (fun _ _ ->
-    Classical.forall_intro_2 p.comm
-  );
-  assoc = (fun x1 x2 x3 ->
-    Classical.forall_intro_3 p.assoc;
-    Classical.forall_intro (is_unit p)
-  );
-  assoc_r = (fun _ _ _ -> 
-    Classical.forall_intro_3 p.assoc_r;
-    Classical.forall_intro (is_unit p)
-  );
-  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
-  refine = uninit_refine p;
-}
-
-let value_to_uninit
-  (#a: Type)
-  (p: pcm a)
-: Tot (morphism p (pcm_uninit p))
-= mkmorphism
-    (fun x -> InitOrUnit x)
-    ()
-    (fun _ _ -> ())
-
-let uninit_to_value
-  (#a: Type)
-  (p: pcm a)
-: Tot (morphism (pcm_uninit p) p)
-= mkmorphism
-    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
-    ()
-    (fun _ _ -> Classical.forall_intro (is_unit p))
-
-let uninit_conn_fpu'
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-  (v: uninit_t a {
-    (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
-  })
-: Tot (uninit_t a)
-=
-  let InitOrUnit x' = v in
-  InitOrUnit (f x')
-
-let uninit_conn_fpu_prop
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-  (v: uninit_t a {
-    (pcm_uninit p).refine v /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
-  })
-: Lemma
-  (let v_new = uninit_conn_fpu' p x y f v in
-    (pcm_uninit p).refine v_new /\
-    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
-    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
-  )
-= Classical.forall_intro (is_unit p);
-  let y' = (value_to_uninit p).morph y in
-  let InitOrUnit x' = v in
-  let v_new = uninit_conn_fpu' p x y f v in
-  let frame : a = compatible_elim p y (f x') in
-  let frame' : uninit_t a = InitOrUnit frame in
-  assert (composable (pcm_uninit p) y' frame');
-  assert (op (pcm_uninit p) frame' y' == v_new);
-  compatible_intro (pcm_uninit p) y' v_new frame';
-  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
-       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
-       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
-  ()
-
-let uninit_conn_fpu
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
-  (y: Ghost.erased a)
-  (f: frame_preserving_upd p x y)
-: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
-=
-  fun v ->
-    uninit_conn_fpu_prop p x y f v;
-    uninit_conn_fpu' p x y f v
-
-let uninit_conn
-  (#a: Type)
-  (p: pcm a)
-: Tot (connection (pcm_uninit p) p)
-= mkconnection
-    (value_to_uninit p)
-    (uninit_to_value p)
-    ()
-    (uninit_conn_fpu p)
-
-let exclusive_uninit
-  (#a: Type)
-  (p: pcm a)
-  (x: uninit_t a)
-: Lemma
-  (exclusive (pcm_uninit p) x <==> begin match x with
-  | Uninitialized -> True
-  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
-  end)
-= match x with
-  | Uninitialized -> ()
-  | InitOrUnit z ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
-    then begin
-      assert (composable (pcm_uninit p) x Uninitialized)
-    end else
-      let phi2
-        frame
-      : Lemma
-        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
-        (ensures (frame == one p))
-        [SMTPat (composable p z frame)]
-      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
-      in
-      ()
-
 let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
   (x: a { p x })
 
@@ -691,75 +349,3 @@ let pts_to_view_elim
     );
   res
 
-let opt_view
-  (a: Type)
-: Tot (sel_view (opt_pcm #a) a)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> Some?.v x);
-  to_carrier = (fun z  -> Some z);
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun x frame -> ());
-}
-
-let frac_view
-  (a: Type)
-  (p: perm)
-: Tot (sel_view (pcm_frac #a) a)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> let Some (v, _) = x in v);
-  to_carrier = (fun v -> Some (v, p));
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun v frame -> ());
-}
-
-let uninit_view
-  (#a: Type)
-  (#p: pcm a)
-  (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
-= {
-  to_view_prop = (fun x -> match x with
-  | Uninitialized -> True
-  | InitOrUnit x' -> w.to_view_prop x'
-  );
-  to_view = (fun x -> match x with
-  | Uninitialized -> Uninitialized
-  | InitOrUnit x' -> InitOrUnit (w.to_view x')
-  );
-  to_carrier = (fun v -> match v with
-  | Uninitialized -> Uninitialized
-  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
-  );
-  to_carrier_not_one = (fun v -> match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'
-  );
-  to_view_frame = (fun v frame -> match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
-  );
-}
-
-let uninit_view_initialized
-  (#a: Type)
-  (#p: pcm a)
-  (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
-= {
-  to_view_prop = (fun x -> match x with
-  | Uninitialized -> False
-  | InitOrUnit x' -> w.to_view_prop x'
-  );
-  to_view = (fun x -> match x with
-  | InitOrUnit x' -> w.to_view x'
-  );
-  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
-  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
-  to_view_frame = (fun v frame ->
-    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
-  );
-}
diff --git a/examples/steel/arraystructs/Steel.C.Uninit.fsti b/examples/steel/arraystructs/Steel.C.Uninit.fsti
new file mode 100644
index 00000000000..e2508c0fedb
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Uninit.fsti
@@ -0,0 +1,234 @@
+module Steel.C.Uninit
+
+open FStar.PCM
+open Steel.C.PCM
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.Effect
+
+/// Uninitialized
+
+noeq
+type uninit_t (a: Type)
+= | Uninitialized
+  | InitOrUnit: a -> uninit_t a
+
+let uninit_composable
+  (#a: Type)
+  (p: pcm a)
+: Tot (symrel (uninit_t a))
+= fun u1 u2 ->
+  match u1, u2 with
+  | Uninitialized, InitOrUnit x
+  | InitOrUnit x, Uninitialized
+    -> x == one p
+  | InitOrUnit x1, InitOrUnit x2
+    -> composable p x1 x2
+  | _ -> False
+
+let uninit_compose
+  (#a: Type)
+  (p: pcm a)
+  (u1: uninit_t a)
+  (u2: uninit_t a { uninit_composable p u1 u2 })
+: Tot (uninit_t a)
+= match u1, u2 with
+  | Uninitialized, _
+  | _, Uninitialized
+    -> Uninitialized
+  | InitOrUnit x1, InitOrUnit x2
+    -> InitOrUnit (op p x1 x2)
+
+let uninit_refine
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Tot prop
+= match x with
+  | Uninitialized -> True
+  | InitOrUnit y -> p.refine y
+
+let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
+  FStar.PCM.p = {
+         composable = uninit_composable p;
+         op = uninit_compose p;
+         one = InitOrUnit (one p);
+      };
+  comm = (fun _ _ ->
+    Classical.forall_intro_2 p.comm
+  );
+  assoc = (fun x1 x2 x3 ->
+    Classical.forall_intro_3 p.assoc;
+    Classical.forall_intro (is_unit p)
+  );
+  assoc_r = (fun _ _ _ -> 
+    Classical.forall_intro_3 p.assoc_r;
+    Classical.forall_intro (is_unit p)
+  );
+  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
+  refine = uninit_refine p;
+}
+
+let value_to_uninit
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism p (pcm_uninit p))
+= mkmorphism
+    (fun x -> InitOrUnit x)
+    ()
+    (fun _ _ -> ())
+
+let uninit_to_value
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism (pcm_uninit p) p)
+= mkmorphism
+    (fun x -> match x with InitOrUnit y -> y | _ -> one p)
+    ()
+    (fun _ _ -> Classical.forall_intro (is_unit p))
+
+let uninit_conn_fpu'
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Tot (uninit_t a)
+=
+  let InitOrUnit x' = v in
+  InitOrUnit (f x')
+
+let uninit_conn_fpu_prop
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+  (v: uninit_t a {
+    (pcm_uninit p).refine v /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
+  })
+: Lemma
+  (let v_new = uninit_conn_fpu' p x y f v in
+    (pcm_uninit p).refine v_new /\
+    compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
+    (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new))
+  )
+= Classical.forall_intro (is_unit p);
+  let y' = (value_to_uninit p).morph y in
+  let InitOrUnit x' = v in
+  let v_new = uninit_conn_fpu' p x y f v in
+  let frame : a = compatible_elim p y (f x') in
+  let frame' : uninit_t a = InitOrUnit frame in
+  assert (composable (pcm_uninit p) y' frame');
+  assert (op (pcm_uninit p) frame' y' == v_new);
+  compatible_intro (pcm_uninit p) y' v_new frame';
+  assert (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
+       composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
+       (op (pcm_uninit p) ((value_to_uninit p).morph x) frame == v ==> op (pcm_uninit p) ((value_to_uninit p).morph y) frame == v_new));
+  ()
+
+let uninit_conn_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+: Tot (frame_preserving_upd (pcm_uninit p) ((value_to_uninit p).morph x) ((value_to_uninit p).morph y))
+=
+  fun v ->
+    uninit_conn_fpu_prop p x y f v;
+    uninit_conn_fpu' p x y f v
+
+let uninit_conn
+  (#a: Type)
+  (p: pcm a)
+: Tot (connection (pcm_uninit p) p)
+= mkconnection
+    (value_to_uninit p)
+    (uninit_to_value p)
+    ()
+    (uninit_conn_fpu p)
+
+let exclusive_uninit
+  (#a: Type)
+  (p: pcm a)
+  (x: uninit_t a)
+: Lemma
+  (exclusive (pcm_uninit p) x <==> begin match x with
+  | Uninitialized -> True
+  | InitOrUnit z -> exclusive p z /\ (~ (z == one p))
+  end)
+= match x with
+  | Uninitialized -> ()
+  | InitOrUnit z ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (z == one p)
+    then begin
+      assert (composable (pcm_uninit p) x Uninitialized)
+    end else
+      let phi2
+        frame
+      : Lemma
+        (requires (exclusive (pcm_uninit p) x /\ composable p z frame))
+        (ensures (frame == one p))
+        [SMTPat (composable p z frame)]
+      = assert (composable (pcm_uninit p) x (InitOrUnit frame))
+      in
+      ()
+
+
+let uninit_view
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> True
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit x' -> InitOrUnit (w.to_view x')
+  );
+  to_carrier = (fun v -> match v with
+  | Uninitialized -> Uninitialized
+  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
+  );
+  to_carrier_not_one = (fun v -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'
+  );
+  to_view_frame = (fun v frame -> match v with
+  | Uninitialized -> ()
+  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  );
+}
+
+let uninit_view_initialized
+  (#a: Type)
+  (#p: pcm a)
+  (#b: Type)
+  (w: sel_view p b)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
+= {
+  to_view_prop = (fun x -> match x with
+  | Uninitialized -> False
+  | InitOrUnit x' -> w.to_view_prop x'
+  );
+  to_view = (fun x -> match x with
+  | InitOrUnit x' -> w.to_view x'
+  );
+  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
+  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
+  to_view_frame = (fun v frame ->
+    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
+  );
+}

From 142d1f1ec6a03334fa7dee8f2555e2cfd2f502b7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 13:59:16 -0700
Subject: [PATCH 104/513] Fix examples

---
 .../arraystructs/AggregateRefExamples.fst     | 48 ++++++++--------
 examples/steel/arraystructs/IntOrBool.fsti    | 42 +++++++-------
 examples/steel/arraystructs/LineStruct.fsti   |  1 -
 examples/steel/arraystructs/ListExample.fst   | 30 +++++-----
 .../steel/arraystructs/ListExampleOOM.fst     | 14 ++---
 examples/steel/arraystructs/ListNode.fst      | 56 +++++++++----------
 examples/steel/arraystructs/ListNode.fsti     | 34 +++++------
 examples/steel/arraystructs/ListNodeOOM.fsti  | 22 ++++----
 examples/steel/arraystructs/PointStruct.fst   | 14 ++---
 examples/steel/arraystructs/PointStruct.fsti  | 24 ++++----
 examples/steel/arraystructs/Steel.C.Opt.fst   |  2 +-
 examples/steel/arraystructs/Steel.C.Opt.fsti  |  2 +-
 examples/steel/arraystructs/Steel.C.Ref.fst   | 21 +++++++
 examples/steel/arraystructs/Steel.C.Ref.fsti  | 23 ++------
 14 files changed, 170 insertions(+), 163 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index d625873ac7b..6a2b1243a3a 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -8,7 +8,7 @@ module A = Steel.Effect.Atomic
 
 /// Example 1: swapping the coordinates of a 2d point
 
-open FStar.PCM.POD
+open Steel.C.Opt
 open PointStruct
 
 /// We can write the following function that swaps the x and y fields of a given point:
@@ -30,12 +30,12 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
   (* int *r = &p.y; *)
   let r = addr_of_y p in
   (* tmp = *q; *)
-  let tmp : int = pod_read q in
+  let tmp : int = opt_read q in
   (* *q = *r; *)
-  let vy : int = pod_read r in
-  pod_write q vy;
+  let vy : int = opt_read r in
+  opt_write q vy;
   (* *r = tmp; *)
-  pod_write r tmp;
+  opt_write r tmp;
   (* Gather *)
   unaddr_of_x p q;
   unaddr_of_y p r;
@@ -49,16 +49,16 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
 ///   *q = tmp;
 /// }
 
-let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (pod_pcm 'c)) (q:ref 'b (pod_pcm 'c))
+let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (opt_pcm #'c)) (q:ref 'b (opt_pcm #'c))
 : SteelT unit ((p `pts_to` some x) `star` (q `pts_to` some y))
     (fun _ -> (p `pts_to` some y) `star` (q `pts_to` some x))
 = (* A tmp = *p; *)
-  let tmp = pod_read p in
+  let tmp = opt_read p in
   (* *p = *q; *)
-  let vy = pod_read q in
-  pod_write p vy;
+  let vy = opt_read q in
+  opt_write p vy;
   (* *q = tmp *)
-  pod_write q tmp;
+  opt_write q tmp;
   A.return ()
 
 /// Now, point_swap written using generic_swap:
@@ -161,40 +161,40 @@ let int_or_bool_to_int
       else case_of_int_or_bool u == Some B)
     (ensures fun _ _ _ -> True)
 = if is_int then begin
-    //let i: Ghost.erased (pod int) =
-    //  I.indefinite_description_ghost (Ghost.erased (pod int)) (fun i -> u == mk_int i)
+    //let i: Ghost.erased (option int) =
+    //  I.indefinite_description_ghost (Ghost.erased (option int)) (fun i -> u == mk_int i)
     //in
-    let i: (i:Ghost.erased (pod int){u == mk_int i}) =
-      I.indefinite_description_tot (Ghost.erased (pod int)) (fun i -> u == mk_int i)
+    let i: (i:Ghost.erased (option int){u == mk_int i}) =
+      I.indefinite_description_tot (Ghost.erased (option int)) (fun i -> u == mk_int i)
     in
     assert (u == mk_int i);
     A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int i);
     let pi = addr_of_i p in
-    //let i = pod_read pi in
+    //let i = opt_read pi in
     //unaddr_of_i p pi;
     //A.return i
     A.sladmit(); A.return (admit())
   end else begin
     //let pb = addr_of_b p in
-    //let b = pod_read pb in
+    //let b = opt_read pb in
     //unaddr_of_b p pb;
     //if b then A.return 1 else A.return 0
     A.sladmit(); A.return (admit())
   end
 
-(*= let b = pod_read is_int in
+(*= let b = opt_read is_int in
   if b then begin
     (* return p->i *)
     let pi = addr_of_i p in
     A.sladmit(); A.return (admit())
-    //let i = pod_read pi in
+    //let i = opt_read pi in
     //unaddr_of_i p pi;
     //A.return i
   end else begin
     A.sladmit(); A.return (admit())
     //(* return p->b ? 1 : 0 *)
     //let pb = addr_of_b p in
-    //let b = pod_read pb in
+    //let b = opt_read pb in
     //unaddr_of_b p pb;
     //let b = b in
     //A.return (if b then 1 else 0)
@@ -202,24 +202,24 @@ let int_or_bool_to_int
 *)
 
 //let int_or_bool_to_int
-//  (is_int: ref 'a (pod_pcm bool)) (p: ref 'b int_or_bool_pcm)
+//  (is_int: ref 'a (opt_pcm #bool)) (p: ref 'b int_or_bool_pcm)
 //  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
-//: Steel (pod int)
+//: Steel (option int)
 //    ((is_int `pts_to` some b) `star` (p `pts_to` u))
 //    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
 //    (requires fun _ -> if b then case u == I else case u == B)
 //    (ensures fun _ _ _ -> True)
-//= let b = pod_read is_int in
+//= let b = opt_read is_int in
 //  if some_v b then begin
 //    (* return p->i *)
 //    let pi = addr_of_i p in
-//    let i = pod_read pi in
+//    let i = opt_read pi in
 //    unaddr_of_i p pi;
 //    A.return i
 //  end else begin
 //    (* return p->b ? 1 : 0 *)
 //    let pb = addr_of_b p in
-//    let b = pod_read pb in
+//    let b = opt_read pb in
 //    unaddr_of_b p pb;
 //    let b = some_v b in
 //    if b then some' 1 else some' 0
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 7759c337e3f..fd1de63dc95 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -1,8 +1,8 @@
 module IntOrBool
 
 open FStar.PCM
-open FStar.PCM.POD
 open Steel.C.PCM
+open Steel.C.Opt
 open Steel.C.Ref
 open Steel.C.Connection
 open Steel.Effect
@@ -24,13 +24,13 @@ val int_or_bool_pcm: pcm int_or_bool
 /// (mk_int i) represents (union int_or_bool){.i = i}
 /// (mk_bool b) represents (union int_or_bool){.b = b}
 
-val mk_int (i: Ghost.erased (pod int)): Ghost.erased int_or_bool
-val mk_bool (b: Ghost.erased (pod bool)): Ghost.erased int_or_bool
+val mk_int (i: Ghost.erased (option int)): Ghost.erased int_or_bool
+val mk_bool (b: Ghost.erased (option bool)): Ghost.erased int_or_bool
 
 /// Connections for cases
 
-val _i : int_or_bool_pcm `connection` pod_pcm int
-val _b : int_or_bool_pcm `connection` pod_pcm bool
+val _i : int_or_bool_pcm `connection` opt_pcm #int
+val _b : int_or_bool_pcm `connection` opt_pcm #bool
 
 /// Getting the case of a union in GTot
 
@@ -42,12 +42,12 @@ val case_of_int_or_bool (u: Ghost.erased int_or_bool):
     | None -> Ghost.reveal u == one int_or_bool_pcm
   })
 
-val case_of_int_or_bool_int (i: Ghost.erased (pod int))
+val case_of_int_or_bool_int (i: Ghost.erased (option int))
 : Lemma
     (requires ~ (i == none))
     (ensures case_of_int_or_bool (mk_int i) == Some I) [SMTPat (mk_int i)]
 
-val case_of_int_or_bool_bool (b: Ghost.erased (pod bool))
+val case_of_int_or_bool_bool (b: Ghost.erased (option bool))
 : Lemma
     (requires ~ (b == none))
     (ensures case_of_int_or_bool (mk_bool b) == Some B) [SMTPat (mk_bool b)]
@@ -55,46 +55,46 @@ val case_of_int_or_bool_bool (b: Ghost.erased (pod bool))
 val case_of_int_or_bool_one
 : squash (case_of_int_or_bool (one int_or_bool_pcm) == None)
 
-val mk_int_exclusive (i: Ghost.erased (pod int))
+val mk_int_exclusive (i: Ghost.erased (option int))
 : Lemma
-    (requires exclusive (pod_pcm int) i /\ ~ (i == none))
+    (requires exclusive (opt_pcm #int) i /\ ~ (i == none))
     (ensures exclusive int_or_bool_pcm (mk_int i))
-  [SMTPat (exclusive (pod_pcm int) i)]
+  [SMTPat (exclusive (opt_pcm #int) i)]
 
-val mk_bool_exclusive (b: Ghost.erased (pod bool))
+val mk_bool_exclusive (b: Ghost.erased (option bool))
 : Lemma
-    (requires exclusive (pod_pcm bool) b /\ ~ (b == none))
+    (requires exclusive (opt_pcm #bool) b /\ ~ (b == none))
     (ensures exclusive int_or_bool_pcm (mk_bool b))
-  [SMTPat (exclusive (pod_pcm bool) b)]
+  [SMTPat (exclusive (opt_pcm #bool) b)]
 
 /// Taking pointers to the i and b cases of an int_or_bool
 
-val addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
-: Steel (q:ref 'a (pod_pcm int){q == ref_focus p _i})
+val addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)
+: Steel (q:ref 'a (opt_pcm #int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
     (fun q -> q `pts_to` i)
     (requires fun _ -> ~ (i == none))
     (ensures fun _ _ _ -> True)
 
-val unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
+val unaddr_of_i (#i: Ghost.erased (option int)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p _i})
+  (q: ref 'a (opt_pcm #int){q == ref_focus p _i})
 : A.SteelGhost unit opened
     (q `pts_to` i)
     (fun _ -> p `pts_to` mk_int i)
     (requires fun _ -> ~ (i == none))
     (ensures fun _ _ _ -> True)
 
-val addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
-: Steel (q:ref 'a (pod_pcm bool){q == ref_focus p _b})
+val addr_of_b (#b: Ghost.erased (option bool)) (p: ref 'a int_or_bool_pcm)
+: Steel (q:ref 'a (opt_pcm #bool){q == ref_focus p _b})
     (p `pts_to` mk_bool b)
     (fun q -> q `pts_to` b)
     (requires fun _ -> ~ (b == none))
     (ensures fun _ _ _ -> True)
 
-val unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
+val unaddr_of_b (#b: Ghost.erased (option bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
+  (q: ref 'a (opt_pcm #bool){q == ref_focus p _b})
 : A.SteelGhost unit opened
     (q `pts_to` b)
     (fun _ -> p `pts_to` mk_bool b)
diff --git a/examples/steel/arraystructs/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
index ebe61985cf8..6f0700d1224 100644
--- a/examples/steel/arraystructs/LineStruct.fsti
+++ b/examples/steel/arraystructs/LineStruct.fsti
@@ -1,6 +1,5 @@
 module LineStruct
 
-open FStar.PCM.POD
 open FStar.PCM
 open Steel.Effect
 open PointStruct
diff --git a/examples/steel/arraystructs/ListExample.fst b/examples/steel/arraystructs/ListExample.fst
index 05f6196d31b..7aaa1f2b650 100644
--- a/examples/steel/arraystructs/ListExample.fst
+++ b/examples/steel/arraystructs/ListExample.fst
@@ -6,7 +6,7 @@ open Steel.C.Ref
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-open FStar.PCM.POD
+open Steel.C.Opt
 open ListNode
 
 /// void mk_figure_eight(struct node *p, struct node *q) {
@@ -28,7 +28,7 @@ val mk_figure_eight_step_one
   (p: ref node node_pcm)
   (q: ref node node_pcm)
   (i j: Ghost.erased int')
-: SteelT (r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next})
+: SteelT (r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next})
     (p `pts_to` mk_node (some i) (some nullptr))
     (fun r ->
       (p `pts_to` mk_node (some i) none) `star`
@@ -41,7 +41,7 @@ val mk_figure_eight_step_two
   (p: ref node node_pcm)
   (q: ref node node_pcm)
   (i j: Ghost.erased int')
-: SteelT (r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next})
+: SteelT (r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next})
     (q `pts_to` mk_node (some j) (some nullptr))
     (fun r ->
       (q `pts_to` mk_node (some j) none) `star`
@@ -53,34 +53,34 @@ let mk_figure_eight_step_two p q i j =
 val mk_figure_eight_step_three
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
   (i j: Ghost.erased int')
 : SteelT unit
     (p_next `pts_to` some nullptr)
     (fun _ -> p_next `pts_to` some (ptr q))
 
 let mk_figure_eight_step_three p q p_next q_next i j =
-  pod_write p_next (ptr' q)
+  opt_write p_next (ptr' q)
 
 val mk_figure_eight_step_four
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
   (i j: Ghost.erased int')
 : SteelT unit
     (q_next `pts_to` some nullptr)
     (fun _ -> q_next `pts_to` some (ptr p))
 
 let mk_figure_eight_step_four p q p_next q_next i j =
-  pod_write q_next (ptr' p)
+  opt_write q_next (ptr' p)
 
 val mk_figure_eight_step_five
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
   (i j: Ghost.erased int')
 : SteelT unit
     ((p `pts_to` mk_node (some i) none) `star`
@@ -93,8 +93,8 @@ let mk_figure_eight_step_five p q p_next q_next i j =
 val mk_figure_eight_step_six
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (p_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (pod_pcm (option (ref' node node))){r == ref_focus q _next}))
+  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
+  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
   (i j: Ghost.erased int')
 : SteelT unit
     ((q `pts_to` mk_node (some j) none) `star`
@@ -140,8 +140,8 @@ val mk_figure_eight
 let mk_figure_eight p q i j =
   let p_next = addr_of_next p in
   let q_next = addr_of_next q in
-  p_next `pod_write` ptr' q;
-  q_next `pod_write` ptr' p;
+  p_next `opt_write` ptr' q;
+  q_next `opt_write` ptr' p;
   unaddr_of_next p p_next;
   unaddr_of_next q q_next;
   A.return ()
diff --git a/examples/steel/arraystructs/ListExampleOOM.fst b/examples/steel/arraystructs/ListExampleOOM.fst
index d4f6ba5f85a..c0d51244f78 100644
--- a/examples/steel/arraystructs/ListExampleOOM.fst
+++ b/examples/steel/arraystructs/ListExampleOOM.fst
@@ -6,15 +6,15 @@ open Steel.C.Ref
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-open FStar.PCM.POD
+open Steel.C.Opt
 open ListNodeOOM
 
 (*
 let ok
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
@@ -23,10 +23,10 @@ let ok
 *)
 
 let oom
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 8ebb298ade6..590339b4491 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -6,7 +6,7 @@ open FStar.FunctionalExtensionality
 module A = Steel.Effect.Atomic
 open Steel.Effect
 open FStar.PCM
-open FStar.PCM.POD
+open Steel.C.Opt
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.C.Connection
@@ -16,8 +16,8 @@ module U = FStar.Universe
 type node_field = | Value | Next
 
 let node_fields (node:Type u#1) k : Type u#1 = match k with
-  | Value -> pod int'
-  | Next -> pod (option (ref' node node))
+  | Value -> option int'
+  | Next -> option (option (ref' node node))
 
 #push-options "--__no_positivity"
 noeq type node: Type u#1 =
@@ -27,8 +27,8 @@ noeq type node: Type u#1 =
 let node': Type u#1 = restricted_t node_field (node_fields node)
 
 let node_fields_pcm k: pcm (node_fields node k) = match k with
-  | Value -> pod_pcm int'
-  | Next -> pod_pcm (option (ref' node node))
+  | Value -> opt_pcm #int'
+  | Next -> opt_pcm #(option (ref' node node))
 
 let node_pcm': pcm node' = prod_pcm node_fields_pcm
 
@@ -120,7 +120,7 @@ let unroll_conn: node_pcm `connection` node_pcm' = {
   conn_lift_frame_preserving_upd = unroll_conn_lift_fpu;
 }
 
-let mk_node'_f (value: pod int') (next: pod (option (ref' node node)))
+let mk_node'_f (value: option int') (next: option (option (ref' node node)))
   (k: node_field)
 : node_fields node k
 = match k with
@@ -128,23 +128,23 @@ let mk_node'_f (value: pod int') (next: pod (option (ref' node node)))
   | Next -> next
   
 let mk_node'
-  (value: Ghost.erased (pod int'))
-  (next: Ghost.erased (pod (option (ref' node node))))
+  (value: Ghost.erased (option int'))
+  (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node'
 = Ghost.hide (on_domain node_field (mk_node'_f (Ghost.reveal value) (Ghost.reveal next)))
 
 let mk_node value next = Ghost.hide (Mknode (mk_node' (Ghost.reveal value) (Ghost.reveal next)))
 
 let _value
-: node_pcm `connection` pod_pcm int'
+: node_pcm `connection` opt_pcm #int'
 = unroll_conn `connection_compose` struct_field node_fields_pcm Value
 
 let _next
-: node_pcm `connection` pod_pcm (option (ref' node node))
+: node_pcm `connection` opt_pcm #(option (ref' node node))
 = unroll_conn `connection_compose` struct_field node_fields_pcm Next
 
-let one_next : Ghost.erased (pod int') =
-  Ghost.hide (one (pod_pcm int'))
+let one_next : Ghost.erased (option int') =
+  Ghost.hide (one (opt_pcm #int'))
 
 let node'_without_value value next
 : Lemma (struct_without_field node_fields_pcm Value (mk_node' value next) `feq`
@@ -177,8 +177,8 @@ let mk_node_mk_node' value next
 = ()
 
 let unroll_ref 
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
 : SteelT (p':ref 'a node_pcm'{p' == ref_focus p unroll_conn})
     (p `pts_to` mk_node value next)
@@ -187,8 +187,8 @@ let unroll_ref
   A.return p'
 
 let roll_ref 
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm) (p': ref 'a node_pcm')
 : Steel unit
     (p' `pts_to` mk_node' value next)
@@ -199,10 +199,10 @@ let roll_ref
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_value
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
@@ -215,10 +215,10 @@ let addr_of_value
   A.return q
 
 let unaddr_of_value
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (pod_pcm int'){q == ref_focus p _value})
+  (q: ref 'a (opt_pcm #int'){q == ref_focus p _value})
 : SteelT unit
     ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
     (fun _ -> p `pts_to` mk_node value next)
@@ -229,10 +229,10 @@ let unaddr_of_value
   A.return ()
 
 let addr_of_next
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
@@ -245,10 +245,10 @@ let addr_of_next
   A.return q
 
 let unaddr_of_next
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+  (q: ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
 : SteelT unit
     ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
     (fun q -> p `pts_to` mk_node value next)
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index 3fd0228ce73..9807d306ed6 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -1,10 +1,10 @@
 module ListNode
 
-open FStar.PCM.POD
 open FStar.PCM
 open Steel.Effect
 open PointStruct
 open Steel.C.PCM
+open Steel.C.Opt
 open Steel.C.Ref
 open Steel.C.Connection
 module U = FStar.Universe
@@ -25,51 +25,51 @@ val node_pcm: pcm node
 /// (mk_node value next) represents (struct node){.value = value, .next = next}
 
 val mk_node
-  (i: Ghost.erased (pod int'))
-  (next: Ghost.erased (pod (option (ref' node node))))
+  (i: Ghost.erased (option int'))
+  (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node
 
 /// Lenses for fields
 
-val _value: node_pcm `connection` pod_pcm int'
-val _next: node_pcm `connection` pod_pcm (option (ref' node node))
+val _value: node_pcm `connection` opt_pcm #int'
+val _next: node_pcm `connection` opt_pcm #(option (ref' node node))
 
 /// Taking pointers to the fields of a node
 
 val addr_of_value
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
 
 val unaddr_of_value
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (pod_pcm int'){q == ref_focus p _value})
+  (q: ref 'a (opt_pcm #int'){q == ref_focus p _value})
 : SteelT unit
     ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
     (fun q -> p `pts_to` mk_node value next)
 
 val addr_of_next
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
        (q `pts_to` next))
 
 val unaddr_of_next
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+  (q: ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
 : SteelT unit
     ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
     (fun q -> p `pts_to` mk_node value next)
diff --git a/examples/steel/arraystructs/ListNodeOOM.fsti b/examples/steel/arraystructs/ListNodeOOM.fsti
index 60a316acfa0..5cdcb49bfc0 100644
--- a/examples/steel/arraystructs/ListNodeOOM.fsti
+++ b/examples/steel/arraystructs/ListNodeOOM.fsti
@@ -1,10 +1,10 @@
 module ListNodeOOM
 
-open FStar.PCM.POD
 open FStar.PCM
 open Steel.Effect
 open PointStruct
 open Steel.C.PCM
+open Steel.C.Opt
 open Steel.C.Ref
 open Steel.C.Connection
 module U = FStar.Universe
@@ -25,32 +25,32 @@ val node_pcm: pcm node
 /// (mk_node value next) represents (struct node){.value = value, .next = next}
 
 val mk_node
-  (i: Ghost.erased (pod int'))
-  (next: Ghost.erased (pod (option (ref' node node))))
+  (i: Ghost.erased (option int'))
+  (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node
 
 /// Lenses for fields
 
-val _value: node_pcm `connection` pod_pcm int'
-val _next: node_pcm `connection` pod_pcm (option (ref' node node))
+val _value: node_pcm `connection` opt_pcm #int'
+val _next: node_pcm `connection` opt_pcm #(option (ref' node node))
 
 /// Taking pointers to the fields of a node
 
 val addr_of_value
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm int'){q == ref_focus p _value})
+: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
 
 val addr_of_next
-  (#value:Ghost.erased (pod int'))
-  (#next:Ghost.erased (pod (option (ref' node node))))
+  (#value:Ghost.erased (option int'))
+  (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (pod_pcm (option (ref' node node))){q == ref_focus p _next})
+: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 74a06912778..1ebea3824f2 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -1,7 +1,7 @@
 module PointStruct
 
-open FStar.PCM.POD
 open Steel.C.PCM
+open Steel.C.Opt
 open Steel.C.Connection
 open Steel.C.Struct
 open FStar.FunctionalExtensionality
@@ -10,20 +10,20 @@ module A = Steel.Effect.Atomic
 
 type point_field = | X | Y
 let point_fields k = match k with
-  | X -> pod int
-  | Y -> pod int
+  | X -> option int
+  | Y -> option int
 let point = restricted_t point_field point_fields
 
 let point_fields_pcm k : pcm (point_fields k) = match k with
-  | X -> pod_pcm int
-  | Y -> pod_pcm int
+  | X -> opt_pcm int
+  | Y -> opt_pcm int
 let point_pcm = prod_pcm point_fields_pcm
 
-let mk_point_f (x y: pod int) (k: point_field): point_fields k = match k with
+let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
   | X -> x
   | Y -> y
   
-let mk_point (x y: Ghost.erased (pod int)): Ghost.erased point =
+let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
   Ghost.hide (on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y)))
 
 let _x = struct_field point_fields_pcm X
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index f06783775b4..ce0934c1789 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -1,8 +1,8 @@
 module PointStruct
 
-open FStar.PCM.POD
 open FStar.PCM
 open Steel.C.PCM
+open Steel.C.Opt
 open Steel.C.Ref
 open Steel.C.Connection
 open Steel.Effect
@@ -20,41 +20,41 @@ val point_pcm : pcm point
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
 
-val mk_point (x y: Ghost.erased (pod int)): Ghost.erased point
+val mk_point (x y: Ghost.erased (option int)): Ghost.erased point
 
 /// Connections for the fields of a point
 
-val _x : connection point_pcm (pod_pcm int)
-val _y : connection point_pcm (pod_pcm int)
+val _x : connection point_pcm (opt_pcm #int)
+val _y : connection point_pcm (opt_pcm #int)
 
 /// Taking pointers to the x and y fields of a point
 
-val addr_of_x (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _x})
+val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
+: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _x})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point none y) `star`
        (q `pts_to` x))
 
 val unaddr_of_x
-  (#x #y: Ghost.erased (pod int))
+  (#x #y: Ghost.erased (option int))
   (p: ref 'a point_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p _x})
+  (q: ref 'a (opt_pcm #int){q == ref_focus p _x})
 : SteelT unit
     ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
     (fun q -> p `pts_to` mk_point x y)
 
-val addr_of_y (#x #y: Ghost.erased (pod int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (pod_pcm int){q == ref_focus p _y})
+val addr_of_y (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
+: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _y})
     (p `pts_to` mk_point x y)
     (fun q ->
        (p `pts_to` mk_point x none) `star`
        (q `pts_to` y))
 
 val unaddr_of_y
-  (#x #y: Ghost.erased (pod int))
+  (#x #y: Ghost.erased (option int))
   (p: ref 'a point_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p _y})
+  (q: ref 'a (opt_pcm #int){q == ref_focus p _y})
 : SteelT unit
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fst b/examples/steel/arraystructs/Steel.C.Opt.fst
index 23f7fe81ca0..42a570a8d34 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fst
+++ b/examples/steel/arraystructs/Steel.C.Opt.fst
@@ -1,4 +1,4 @@
-module FStar.PCM.Opt
+module Steel.C.Opt
 
 open Steel.C.PCM
 module A = Steel.Effect.Atomic
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index 9d63043c457..035b3faf724 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -1,4 +1,4 @@
-module FStar.PCM.Opt
+module Steel.C.Opt
 
 open FStar.PCM
 open Steel.C.PCM
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index 6aaae9cf950..e0450e78ba7 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -4,8 +4,23 @@ open FStar.FunctionalExtensionality
 
 #push-options "--print_universes"
 
+noeq type ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type = {
+  p: pcm a;
+  pl: connection p q;
+  r: Steel.Memory.ref a p;
+}
+
+let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+
 let pts_to r v =
   r.r `mpts_to` r.pl.conn_small_to_large.morph v
+  
+let ref_focus r l = {p = r.p; pl = connection_compose r.pl l; r = r.r}
+
+let ref_focus_comp r l m
+= connection_eq
+    ((r.pl `connection_compose` l) `connection_compose` m)
+    (r.pl `connection_compose` (l `connection_compose` m))
 
 let focus r l s x =
   let r' = ref_focus r l in
@@ -99,6 +114,12 @@ let as_action (#p:vprop)
 
 let ref_upd r x y f = as_action (ref_upd_act r x y f)
 
+let base_fpu p x y =
+  fun _ ->
+  Classical.forall_intro (is_unit p);
+  compatible_refl p y;
+  y
+
 let pts_to_view_explicit_witinv
   (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 75d84437b0d..8616496c4cf 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -6,13 +6,7 @@ open Steel.C.Connection
 
 #push-options "--print_universes"
 
-noeq type ref (a: Type u#1) #b (q: pcm b): Type = {
-  p: pcm a;
-  pl: connection p q;
-  r: Steel.Memory.ref a p;
-}
-
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+val ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type u#b
 
 open Steel.Effect
 
@@ -21,20 +15,17 @@ val pts_to
   (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
 : vprop
 
-let ref_focus
+val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
 : ref a q
-= {p = r.p; pl = connection_compose r.pl l; r = r.r}
 
-let ref_focus_comp (r: ref 'a 'p) (l: connection 'p 'q) (m: connection 'q 'r)
+val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
+  (l: connection p q) (m: connection q s)
 : Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
   [SMTPatOr [
     [SMTPat (ref_focus (ref_focus r l) m)]; 
     [SMTPat (ref_focus r (l `connection_compose` m))]]]
-= connection_eq
-    ((r.pl `connection_compose` l) `connection_compose` m)
-    (r.pl `connection_compose` (l `connection_compose` m))
 
 module A = Steel.Effect.Atomic
 
@@ -91,7 +82,7 @@ let is_unit (#a: Type u#a) (p:pcm a)
          op p x p.FStar.PCM.p.one == x)
 = p.is_unit x
 
-let base_fpu
+val base_fpu
   (#a: Type)
   (p: pcm a)
   (x: Ghost.erased a)
@@ -99,10 +90,6 @@ let base_fpu
 : Pure (frame_preserving_upd p x y)
   (requires (exclusive p x /\ p.refine y))
   (ensures (fun _ -> True))
-= fun _ ->
-  Classical.forall_intro (is_unit p);
-  compatible_refl p y;
-  y
 
 let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
   (x: a { p x })

From db7d09e8e56bb870ca72df523e560e6bd57d5126 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 16 Jul 2021 15:03:38 -0700
Subject: [PATCH 105/513] Get half of union example working

---
 .../arraystructs/AggregateRefExamples.fst     | 47 ++++++++++++-------
 examples/steel/arraystructs/IntOrBool.fst     | 28 +++++------
 examples/steel/arraystructs/IntOrBool.fsti    | 15 +++---
 examples/steel/arraystructs/ListNode.fst      | 16 ++-----
 4 files changed, 57 insertions(+), 49 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 6a2b1243a3a..521a99e8b4a 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -9,6 +9,8 @@ module A = Steel.Effect.Atomic
 /// Example 1: swapping the coordinates of a 2d point
 
 open Steel.C.Opt
+
+(*
 open PointStruct
 
 /// We can write the following function that swaps the x and y fields of a given point:
@@ -123,7 +125,6 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
 /// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
 /// { generic_swap(&p.i, &q.i); }
 
-open IntOrBool
 let int_or_bool_int_swap
   (p: ref 'a int_or_bool_pcm) (q: ref 'b int_or_bool_pcm)
   (i j: Ghost.erased int)
@@ -140,6 +141,8 @@ let int_or_bool_int_swap
   unaddr_of_i p pi;
   unaddr_of_i q qi
 
+*)
+
 /// Convert an int_or_bool + runtime tag into an int
 ///
 /// int int_or_bool_to_int(bool is_int, union int_or_bool *p) {
@@ -147,11 +150,20 @@ let int_or_bool_int_swap
 ///   else return p->b ? 1 : 0;
 /// }
 
+open IntOrBool
+
 module I = FStar.IndefiniteDescription
 
+#push-options "--z3rlimit 30"
+
+let extract (u: Ghost.erased int_or_bool) (h: squash (case_of_int_or_bool u == Some I))
+: Tot (i:Ghost.erased (option int){u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))})
+= Ghost.reveal (I.indefinite_description_tot (Ghost.erased (option int))
+    (fun i -> u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))))
+
 let int_or_bool_to_int
   (is_int: bool)
-  (p: ref 'b int_or_bool_pcm)
+  (p: ref 'a int_or_bool_pcm)
   (u: Ghost.erased int_or_bool)
 : Steel int
     (p `pts_to` u)
@@ -160,27 +172,30 @@ let int_or_bool_to_int
       if is_int then case_of_int_or_bool u == Some I 
       else case_of_int_or_bool u == Some B)
     (ensures fun _ _ _ -> True)
-= if is_int then begin
+= assume is_int;
+  let h : squash (case_of_int_or_bool u == Some I) = () in
+  //if is_int then begin
     //let i: Ghost.erased (option int) =
     //  I.indefinite_description_ghost (Ghost.erased (option int)) (fun i -> u == mk_int i)
     //in
     let i: (i:Ghost.erased (option int){u == mk_int i}) =
-      I.indefinite_description_tot (Ghost.erased (option int)) (fun i -> u == mk_int i)
+      extract u h
     in
+    let j: Ghost.erased int = Ghost.hide (Some?.v i) in
     assert (u == mk_int i);
-    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int i);
+    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int (some j));
     let pi = addr_of_i p in
-    //let i = opt_read pi in
-    //unaddr_of_i p pi;
-    //A.return i
-    A.sladmit(); A.return (admit())
-  end else begin
-    //let pb = addr_of_b p in
-    //let b = opt_read pb in
-    //unaddr_of_b p pb;
-    //if b then A.return 1 else A.return 0
-    A.sladmit(); A.return (admit())
-  end
+    let i = opt_read pi in
+    unaddr_of_i p pi;
+    A.return i
+    //A.sladmit(); A.return (admit())
+  //end else begin
+  //  //let pb = addr_of_b p in
+  //  //let b = opt_read pb in
+  //  //unaddr_of_b p pb;
+  //  //if b then A.return 1 else A.return 0
+  //  A.sladmit(); A.return (admit())
+  //end
 
 (*= let b = opt_read is_int in
   if b then begin
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index 1fc10daaf80..a988f2c2419 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -3,7 +3,7 @@ module IntOrBool
 #push-options "--print_universes"
 
 open FStar.PCM
-open FStar.PCM.POD
+open Steel.C.Opt
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.C.Connection
@@ -15,12 +15,12 @@ module A = Steel.Effect.Atomic
 module U = FStar.Universe
 
 let int_or_bool_cases k = match k with
-  | I -> pod int
-  | B -> pod bool
+  | I -> option int
+  | B -> option bool
   
 let int_or_bool_cases_pcm k: pcm (int_or_bool_cases k) = match k with
-  | I -> pod_pcm int
-  | B -> pod_pcm bool
+  | I -> opt_pcm #int
+  | B -> opt_pcm #bool
   
 let int_or_bool = union #int_or_bool_case #int_or_bool_cases int_or_bool_cases_pcm
 
@@ -38,12 +38,12 @@ let case_of_int_or_bool u =
   let k = case_of_union int_or_bool_cases_pcm u in
   match k with
   | Some I ->
-    assert (~ (Ghost.reveal u I == one (pod_pcm int)));
+    assert (~ (Ghost.reveal u I == one (opt_pcm #int)));
     assert (exists (x:int). (Ghost.reveal u I == Ghost.reveal (some (Ghost.hide x))));
     assert (exists (x:int). (Ghost.reveal u I == Ghost.reveal (some (Ghost.hide x))) /\ u `feq` mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide x)))));
     assert (exists i. u == mk_int i); k
   | Some B -> 
-    assert (~ (Ghost.reveal u B == one (pod_pcm bool)));
+    assert (~ (Ghost.reveal u B == one (opt_pcm #bool)));
     assert (exists (b:bool). Ghost.reveal u B == Ghost.reveal (some (Ghost.hide b)) /\ u `feq` mk_bool (Ghost.hide (Ghost.reveal (some (Ghost.hide b))))); k
   | None -> None
   
@@ -55,25 +55,25 @@ let mk_int_exclusive i = exclusive_union_intro int_or_bool_cases_pcm (mk_int i)
 
 let mk_bool_exclusive b = exclusive_union_intro int_or_bool_cases_pcm (mk_bool b) B
 
-let addr_of_i (#i: Ghost.erased (pod int)) (p: ref 'a int_or_bool_pcm)
-: Steel (q:ref 'a (pod_pcm int){q == ref_focus p _i})
+let addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)
+: Steel (q:ref 'a (opt_pcm #int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
     (fun q -> q `pts_to` i)
     (requires fun _ -> ~ (i == none))
     (ensures fun _ _ _ -> True)
 = addr_of_union_field p I (mk_int i)
 
-let unaddr_of_i (#i: Ghost.erased (pod int)) (#opened: M.inames)
+let unaddr_of_i (#i: Ghost.erased (option int)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm int){q == ref_focus p _i})
+  (q: ref 'a (opt_pcm #int){q == ref_focus p _i})
 = unaddr_of_union_field I q p i
 
-let addr_of_b (#b: Ghost.erased (pod bool)) (p: ref 'a int_or_bool_pcm)
+let addr_of_b (#b: Ghost.erased (option bool)) (p: ref 'a int_or_bool_pcm)
 = addr_of_union_field p B (mk_bool b)
 
-let unaddr_of_b (#b: Ghost.erased (pod bool)) (#opened: M.inames)
+let unaddr_of_b (#b: Ghost.erased (option bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (pod_pcm bool){q == ref_focus p _b})
+  (q: ref 'a (opt_pcm #bool){q == ref_focus p _b})
 = unaddr_of_union_field B q p b
 
 let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (Ghost.reveal u)})
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index fd1de63dc95..08b93e47442 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -35,13 +35,14 @@ val _b : int_or_bool_pcm `connection` opt_pcm #bool
 /// Getting the case of a union in GTot
 
 val case_of_int_or_bool (u: Ghost.erased int_or_bool):
-  GTot (k:option int_or_bool_case{
-    match k with
-    | Some I -> exists i. u == mk_int i
-    | Some B -> exists b. u == mk_bool b
-    | None -> Ghost.reveal u == one int_or_bool_pcm
-  })
-
+  Ghost (option int_or_bool_case)
+    (requires True)
+    (ensures fun k ->
+      match k with
+      | Some I -> exists i. u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))
+      | Some B -> exists b. u == mk_bool b /\ ~ (Ghost.reveal b == one (opt_pcm #bool))
+      | None -> Ghost.reveal u == one int_or_bool_pcm)
+      
 val case_of_int_or_bool_int (i: Ghost.erased (option int))
 : Lemma
     (requires ~ (i == none))
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 590339b4491..62df4e452a2 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -91,12 +91,8 @@ let roll_conn_lift_fpu
   in FStar.Classical.forall_intro aux;
   w
 
-let roll_conn: node_pcm' `connection` node_pcm = {
-  conn_small_to_large = unroll;
-  conn_large_to_small = roll;
-  conn_small_to_large_inv = ();
-  conn_lift_frame_preserving_upd = roll_conn_lift_fpu;
-}
+let roll_conn: node_pcm' `connection` node_pcm =
+  mkconnection unroll roll () roll_conn_lift_fpu
 
 let unroll_conn_lift_fpu
   (x: Ghost.erased _ {~ (Ghost.reveal x == one node_pcm') })
@@ -113,12 +109,8 @@ let unroll_conn_lift_fpu
   in FStar.Classical.forall_intro aux;
   w
 
-let unroll_conn: node_pcm `connection` node_pcm' = {
-  conn_small_to_large = roll;
-  conn_large_to_small = unroll;
-  conn_small_to_large_inv = ();
-  conn_lift_frame_preserving_upd = unroll_conn_lift_fpu;
-}
+let unroll_conn: node_pcm `connection` node_pcm' =
+  mkconnection roll unroll () unroll_conn_lift_fpu
 
 let mk_node'_f (value: option int') (next: option (option (ref' node node)))
   (k: node_field)

From 4b31c4367b27cc14edd0b9fb34a19ef739be50db Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 16 Jul 2021 16:17:01 -0700
Subject: [PATCH 106/513] remove leftover

---
 examples/steel/arraystructs/Steel.PCM.fst | 12 ------------
 1 file changed, 12 deletions(-)
 delete mode 100644 examples/steel/arraystructs/Steel.PCM.fst

diff --git a/examples/steel/arraystructs/Steel.PCM.fst b/examples/steel/arraystructs/Steel.PCM.fst
deleted file mode 100644
index c5fc84fcaf6..00000000000
--- a/examples/steel/arraystructs/Steel.PCM.fst
+++ /dev/null
@@ -1,12 +0,0 @@
-module Steel.C.PCM
-
-unfold
-let one (#a: Type) (p: pcm a) = p.p.one
-
-let pcm (a: Type) : Tot Type =
-  (p: FStar.PCM.pcm a {
-    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
-      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
-    (forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
-    (~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
-  })

From 6674f948df6719217619f034dd1aa2f82bfc5df0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 16 Jul 2021 22:33:26 -0700
Subject: [PATCH 107/513] connections with restricted fpus; isomorphisms

---
 .../steel/arraystructs/Steel.C.Connection.fst | 376 +++++++++++++++++-
 examples/steel/arraystructs/Steel.C.Ref.fst   |   4 +-
 examples/steel/arraystructs/Steel.C.Ref.fsti  |   6 +
 3 files changed, 366 insertions(+), 20 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Connection.fst b/examples/steel/arraystructs/Steel.C.Connection.fst
index 94c2eed1b34..6502065cc5c 100644
--- a/examples/steel/arraystructs/Steel.C.Connection.fst
+++ b/examples/steel/arraystructs/Steel.C.Connection.fst
@@ -71,6 +71,29 @@ let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fa
       fab.morph_compose x1 x2;
       fbc.morph_compose (fab.morph x1) (fab.morph x2))
 
+let morphism_id
+  (#a: Type)
+  (p: pcm a)
+: Tot (morphism p p)
+= mkmorphism
+    (fun x -> x)
+    ()
+    (fun _ _ -> ())
+
+let morphism_compose_id_left
+  (#a #b: Type) (#pa: pcm a) (#pb: pcm b)  
+  (m: morphism pa pb)
+: Lemma
+  (morphism_id pa `morphism_compose` m == m)
+= morph_eq (morphism_id pa `morphism_compose` m) m
+
+let morphism_compose_id_right
+  (#a #b: Type) (#pa: pcm a) (#pb: pcm b)  
+  (m: morphism pa pb)
+: Lemma
+  (m `morphism_compose` morphism_id pb == m)
+= morph_eq (m `morphism_compose` morphism_id pb) m
+
 let compatible_intro
   (#a: Type u#a)
   (pcm: pcm a)
@@ -123,34 +146,84 @@ let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
 
 #push-options "--print_universes"
 
-let fpu_lift_dom (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
-  (conn_small_to_large: morphism p_small p_large)
+let frame_preserving_upd_dom
+  (#a:Type u#a) (p:pcm a) (x y:a)
+=
+  v:a{
+    p.refine v /\
+    compatible p x v
+  }
+
+let frame_preserving_upd_codom
+  (#a:Type u#a) (p:pcm a) (x y:a)
+  (v: frame_preserving_upd_dom p x y)
+=
+  v_new:a{
+    p.refine v_new /\
+    compatible p y v_new /\
+    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
+       composable p y frame /\
+       (op p x frame == v ==> op p y frame == v_new))}
+
+let restricted_frame_preserving_upd
+  (#a:Type u#a) (p:pcm a) (x y:a)
+=
+  restricted_t
+    (frame_preserving_upd_dom p x y)
+    (frame_preserving_upd_codom p x y)
+
+let restricted_frame_preserving_upd_intro
+  (#a:Type u#a) (#p:pcm a) (#x #y: Ghost.erased a)
+  (f: FStar.PCM.frame_preserving_upd p x y)
+: Tot (restricted_frame_preserving_upd p x y)
+=
+  on_dom
+    (frame_preserving_upd_dom p x y)
+    #(frame_preserving_upd_codom p x y)
+    (fun v -> f v)
+
+let restricted_frame_preserving_upd_elim
+  (#a:Type u#a) (#p:pcm a) (#x #y: Ghost.erased a)
+  (f: restricted_frame_preserving_upd p x y)
+: Tot (FStar.PCM.frame_preserving_upd p x y)
+= f
+
+let fpu_lift_dom (#t_small: Type) (p_small: pcm t_small)
 = (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
    y:Ghost.erased t_small &
-   frame_preserving_upd p_small x y)
+   restricted_frame_preserving_upd p_small x y)
 
 let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
-: fpu_lift_dom conn_small_to_large -> Type
+: fpu_lift_dom p_small -> Type
 = fun (|x, y, f|) ->
-  frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
-     
-let fpu_lift (#t_large:Type) (#t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small)
+  restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
+
+let fpu_lift (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
 : Type
 = restricted_t
-    (fpu_lift_dom conn_small_to_large)
+    (fpu_lift_dom p_small)
     (fpu_lift_cod conn_small_to_large)
 
+let fpu_lift_elim (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (#conn_small_to_large: morphism p_small p_large)
+  (lift: fpu_lift conn_small_to_large)
+  (x: Ghost.erased t_small { ~ (Ghost.reveal x == one p_small) })
+  (y: Ghost.erased t_small)
+  (f: frame_preserving_upd p_small x y)
+: Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y))
+= lift (| x, y, restricted_frame_preserving_upd_intro f |)
+
 noeq
 type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
   conn_small_to_large: morphism p_small p_large;
   conn_large_to_small: morphism p_large p_small;
   conn_small_to_large_inv: squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph);
-  conn_lift_frame_preserving_upd: fpu_lift p_large p_small conn_small_to_large;
+  conn_lift_frame_preserving_upd: fpu_lift conn_small_to_large;
 }
 
-let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+let mkconnection0 (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
   (conn_large_to_small: morphism p_large p_small)
   (conn_small_to_large_inv:
@@ -158,21 +231,39 @@ let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pc
   (conn_lift_frame_preserving_upd:
     (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
      y:Ghost.erased t_small ->
-     frame_preserving_upd p_small x y ->
-     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+     restricted_frame_preserving_upd p_small x y ->
+     restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
 : connection p_large p_small = {
   conn_small_to_large = conn_small_to_large;
   conn_large_to_small = conn_large_to_small;
   conn_small_to_large_inv = conn_small_to_large_inv;
   conn_lift_frame_preserving_upd =
     on_domain
-      (fpu_lift_dom conn_small_to_large)
-      (fun (z: fpu_lift_dom conn_small_to_large) ->
+      (fpu_lift_dom p_small)
+      (fun (z: fpu_lift_dom p_small) ->
         let (|x, y, f|) = z in
 	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
 }
 
-let connection_eq (l m: 'p `connection` 'q)
+let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (conn_small_to_large: morphism p_small p_large)
+  (conn_large_to_small: morphism p_large p_small)
+  (conn_small_to_large_inv:
+    squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
+  (conn_lift_frame_preserving_upd:
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
+     y:Ghost.erased t_small ->
+     frame_preserving_upd p_small x y ->
+     frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+: connection p_large p_small =
+  mkconnection0
+    conn_small_to_large
+    conn_large_to_small
+    conn_small_to_large_inv
+    (fun x y f ->
+      restricted_frame_preserving_upd_intro (conn_lift_frame_preserving_upd x y f))
+
+let connection_eq #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
 : Lemma
     (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
               l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
@@ -181,13 +272,260 @@ let connection_eq (l m: 'p `connection` 'q)
 = ()
 
 let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
-  mkconnection
+  mkconnection0
     (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
     (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
     ()
     (fun xc yc f ->
     let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
     let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
-    let xa = Ghost.hide (fab.conn_small_to_large.morph xb) in
-    let ya = Ghost.hide (fab.conn_small_to_large.morph yb) in
-    fab.conn_lift_frame_preserving_upd (|xb, yb, fbc.conn_lift_frame_preserving_upd (|xc, yc, f|)|))
+    let fb = fbc.conn_lift_frame_preserving_upd (| xc, yc, f |) in
+    fab.conn_lift_frame_preserving_upd (| xb, yb, fb |) )
+
+let connection_id
+  (#a: Type)
+  (p: pcm a)
+: Tot (connection p p)
+= mkconnection0
+    (morphism_id p)
+    (morphism_id p)
+    ()
+    (fun _ _ f -> f)
+
+let connection_compose_id_left
+  (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (c: connection p_large p_small)
+: Lemma
+  (connection_id p_large `connection_compose` c == c)
+= connection_eq (connection_id p_large `connection_compose` c) c
+
+let connection_compose_id_right
+  (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+  (c: connection p_large p_small)
+: Lemma
+  (c `connection_compose` connection_id p_small == c)
+= connection_eq (c `connection_compose` connection_id p_small) c
+
+let morph_refine (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
+  (xa: 'a { pa.refine xa })
+= squash (
+    pb.refine (morph xa)
+  )
+
+noeq
+type isomorphism (#t1 #t2: Type) (p1: pcm t1) (p2: pcm t2) = {
+  iso_1_2: morphism p1 p2;
+  iso_2_1: morphism p2 p1;
+  iso_1_2_inv_2_1: squash (iso_1_2.morph `is_inverse_of` iso_2_1.morph);
+  iso_2_1_inv_1_2: squash (iso_2_1.morph `is_inverse_of` iso_1_2.morph);
+  iso_1_2_refine: restricted_t (x1: t1 { p1.refine x1 }) (morph_refine p1 p2 iso_1_2.morph);
+  iso_2_1_refine: restricted_t (x2: t2 { p2.refine x2 }) (morph_refine p2 p1 iso_2_1.morph);
+}
+
+let isomorphism_eq
+  (#t1 #t2: Type) (#p1: pcm t1) (#p2: pcm t2) (i i': isomorphism p1 p2)
+: Lemma
+  (requires (
+    i.iso_1_2.morph `feq` i'.iso_1_2.morph /\
+    i.iso_2_1.morph `feq` i'.iso_2_1.morph
+  ))
+  (ensures (
+    i == i'
+  ))
+= assert (i.iso_1_2_refine `feq` i'.iso_1_2_refine);
+  assert (i.iso_2_1_refine `feq` i'.iso_2_1_refine)
+
+let mkisomorphism
+  (#t1 #t2: Type) (#p1: pcm t1) (#p2: pcm t2)
+  (iso_1_2: morphism p1 p2)
+  (iso_2_1: morphism p2 p1)
+  (iso_1_2_inv_2_1: squash (iso_1_2.morph `is_inverse_of` iso_2_1.morph))
+  (iso_2_1_inv_1_2: squash (iso_2_1.morph `is_inverse_of` iso_1_2.morph))
+  (iso_1_2_refine:
+    (x1: t1) ->
+    Lemma
+    (requires (p1.refine x1))
+    (ensures (p2.refine (iso_1_2.morph x1)))
+  )
+  (iso_2_1_refine:
+    (x2: t2) ->
+    Lemma
+    (requires (p2.refine x2))
+    (ensures (p1.refine (iso_2_1.morph x2)))
+  )
+: Tot (isomorphism p1 p2)
+= {
+  iso_1_2 = iso_1_2;
+  iso_2_1 = iso_2_1;
+  iso_1_2_inv_2_1 = iso_1_2_inv_2_1;
+  iso_2_1_inv_1_2 = iso_2_1_inv_1_2;
+  iso_1_2_refine = on_dom (x1: t1 { p1.refine x1 }) #(morph_refine p1 p2 iso_1_2.morph) (fun x1 -> iso_1_2_refine x1);
+  iso_2_1_refine = on_dom (x2: t2 { p2.refine x2 }) #(morph_refine p2 p1 iso_2_1.morph) (fun x2 -> iso_2_1_refine x2);
+}
+
+let isomorphism_id
+  (#t: Type)
+  (p: pcm t)
+: Tot (isomorphism p p)
+= mkisomorphism
+    (morphism_id p)
+    (morphism_id p)
+    ()
+    ()
+    (fun _ -> ())
+    (fun _ -> ())
+
+let isomorphism_inverse
+  (#t1 #t2: Type) (#p1: pcm t1) (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+: Tot (isomorphism p2 p1)
+= {
+  iso_1_2 = i.iso_2_1;
+  iso_2_1 = i.iso_1_2;
+  iso_1_2_inv_2_1 = i.iso_2_1_inv_1_2;
+  iso_2_1_inv_1_2 = i.iso_1_2_inv_2_1;
+  iso_1_2_refine = i.iso_2_1_refine;
+  iso_2_1_refine = i.iso_1_2_refine;
+}
+
+let isomorphism_inverse_involutive
+  (#t1 #t2: Type) (#p1: pcm t1) (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+: Lemma
+  (isomorphism_inverse (isomorphism_inverse i) == i)
+= isomorphism_inverse (isomorphism_inverse i) `isomorphism_eq` i
+
+let connection_of_isomorphism_fpu'
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+  (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
+  (y: Ghost.erased t2)
+  (f: restricted_frame_preserving_upd p2 x y)
+  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x) (i.iso_2_1.morph y))
+: Tot t1
+=
+  let x1 = Ghost.hide (i.iso_2_1.morph x) in
+  compatible_morphism i.iso_1_2 x1 v;
+  i.iso_1_2_refine v;
+  let v2' = f (i.iso_1_2.morph v) in
+  let v' = i.iso_2_1.morph v2' in
+  v'
+
+let connection_of_isomorphism_fpu'_correct
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+  (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
+  (y: Ghost.erased t2)
+  (f: restricted_frame_preserving_upd p2 x y)
+  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x) (i.iso_2_1.morph y))
+: Lemma
+  (
+    let x1 = i.iso_2_1.morph x in
+    let y1 = i.iso_2_1.morph y in
+    let v_new = connection_of_isomorphism_fpu' i x y f v in
+    p1.refine v_new /\
+    compatible p1 y1 v_new /\
+    (forall (frame: _ {composable p1 x1 frame}).{:pattern composable p1 x1 frame}
+       composable p1 y1 frame /\
+       (op p1 x1 frame == v ==> op p1 y1 frame == v_new))
+  )
+=
+  let x1 = Ghost.hide (i.iso_2_1.morph x) in
+  compatible_morphism i.iso_1_2 x1 v;
+  i.iso_1_2_refine v;
+  let v2' = f (i.iso_1_2.morph v) in
+  let v' = i.iso_2_1.morph v2' in
+  i.iso_2_1_refine v2' ;
+  assert (p1.refine v');
+  compatible_morphism i.iso_2_1 y v2' ;
+  let y1 = Ghost.hide (i.iso_2_1.morph y) in
+  assert (compatible p1 y1 v');
+  let aux
+    (frame: t1 { composable p1 x1 frame })
+  : Lemma
+    (composable p1 y1 frame /\
+    (op p1 x1 frame == v ==> op p1 y1 frame == v'))
+    [SMTPat (composable p1 x1 frame)]
+  =
+    let frame2 = i.iso_1_2.morph frame in
+    assert (composable p2 x frame2);
+    assert (composable p1 y1 (i.iso_2_1.morph frame2));
+    ()
+  in
+  ()
+
+let connection_of_isomorphism_fpu
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+  (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
+  (y: Ghost.erased t2)
+  (f: restricted_frame_preserving_upd p2 x y)
+: Tot (restricted_frame_preserving_upd p1 (i.iso_2_1.morph x) (i.iso_2_1.morph y))
+=
+  Classical.forall_intro (connection_of_isomorphism_fpu'_correct i x y f);
+  restricted_frame_preserving_upd_intro #_ #p1 #(i.iso_2_1.morph x) #(i.iso_2_1.morph y) (fun z -> connection_of_isomorphism_fpu' i x y f z)
+
+let connection_of_isomorphism_fpu_inverse'
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+  (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
+  (y: Ghost.erased t2)
+  (f: restricted_frame_preserving_upd p2 x y)
+  (v: frame_preserving_upd_dom p2 x y)
+: Lemma
+  (connection_of_isomorphism_fpu (isomorphism_inverse i) (i.iso_2_1.morph x) (i.iso_2_1.morph y) (connection_of_isomorphism_fpu i x y f) v == f v)
+= compatible_morphism i.iso_2_1 x v;
+  i.iso_2_1_refine v
+
+let connection_of_isomorphism_fpu_inverse
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+  (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
+  (y: Ghost.erased t2)
+  (f: restricted_frame_preserving_upd p2 x y)
+: Lemma
+  (connection_of_isomorphism_fpu (isomorphism_inverse i) (i.iso_2_1.morph x) (i.iso_2_1.morph y) (connection_of_isomorphism_fpu i x y f) == f)
+= Classical.forall_intro (connection_of_isomorphism_fpu_inverse' i x y f);
+  assert (connection_of_isomorphism_fpu (isomorphism_inverse i) (i.iso_2_1.morph x) (i.iso_2_1.morph y) (connection_of_isomorphism_fpu i x y f) `feq` f)
+
+let connection_of_isomorphism
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+: Tot (connection p1 p2)
+= mkconnection0
+    i.iso_2_1
+    i.iso_1_2
+    i.iso_1_2_inv_2_1
+    (connection_of_isomorphism_fpu i)
+
+let connection_of_isomorphism_inverse_left
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+: Lemma
+  (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i == connection_id _)
+= Classical.forall_intro_3 (connection_of_isomorphism_fpu_inverse i);
+  (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i) `connection_eq` connection_id _
+
+let connection_of_isomorphism_inverse_right
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+: Lemma
+  (connection_of_isomorphism i `connection_compose` connection_of_isomorphism (isomorphism_inverse i) == connection_id _)
+= isomorphism_inverse_involutive i;
+  connection_of_isomorphism_inverse_left (isomorphism_inverse i)
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index e0450e78ba7..15a3355d132 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -17,6 +17,8 @@ let pts_to r v =
   
 let ref_focus r l = {p = r.p; pl = connection_compose r.pl l; r = r.r}
 
+let ref_focus_id r = connection_compose_id_right r.pl
+
 let ref_focus_comp r l m
 = connection_eq
     ((r.pl `connection_compose` l) `connection_compose` m)
@@ -101,7 +103,7 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
 
 let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
 : Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, f|))
+= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|))
 
 let as_action (#p:vprop)
               (#q:vprop)
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 8616496c4cf..0b90d3cfb73 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -20,6 +20,12 @@ val ref_focus
   (r: ref a p) (#q: pcm c) (l: connection p q)
 : ref a q
 
+val ref_focus_id
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p)
+: Lemma
+  (ref_focus r (connection_id _) == r)
+
 val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
   (l: connection p q) (m: connection q s)
 : Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))

From 7fd95d8a8de419371ab6a90b55e5eb8801ce3430 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 16 Jul 2021 23:21:59 -0700
Subject: [PATCH 108/513] define and use isomorphism for node

---
 examples/steel/arraystructs/ListNode.fst | 58 +++++-------------------
 1 file changed, 11 insertions(+), 47 deletions(-)

diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 62df4e452a2..736a4c587ce 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -60,57 +60,21 @@ let unroll: node_pcm `morphism` node_pcm' =
 let mk_un_node: squash (Mknode `is_inverse_of` Mknode?.un_node) = ()
 let un_mk_node: squash (Mknode?.un_node `is_inverse_of` Mknode) = ()
 
-let roll_compatible x v
-: Lemma
-    (requires compatible node_pcm' x v)
-    (ensures compatible node_pcm (Mknode x) (Mknode v))
-    [SMTPat (compatible node_pcm' x v)]
-= compatible_morphism roll x v
-
-let unroll_compatible x v
-: Lemma
-    (requires compatible node_pcm x v)
-    (ensures compatible node_pcm' x.un_node v.un_node)
-    [SMTPat (compatible node_pcm x v)]
-= compatible_morphism unroll x v
-
-let roll_conn_lift_fpu
-  (x: Ghost.erased _ {~ (Ghost.reveal x == one node_pcm) })
-  (y: Ghost.erased _)
-  (f: frame_preserving_upd node_pcm x y)
-: frame_preserving_upd node_pcm' x.un_node y.un_node
-= fun v ->
-  let w = (f (Mknode v)).un_node in
-  assert (node_pcm'.refine w);
-  assert (compatible node_pcm' y.un_node w);
-  let aux (frame:_{composable node_pcm' x.un_node frame})
-  : Lemma (
-      composable node_pcm' y.un_node frame /\
-      (op node_pcm' x.un_node frame == v ==> op node_pcm' y.un_node frame == w))
-  = roll.morph_compose x.un_node frame
-  in FStar.Classical.forall_intro aux;
-  w
+let node_iso : isomorphism node_pcm node_pcm' =
+  mkisomorphism
+    unroll
+    roll
+    ()
+    ()
+    (fun _ -> ())
+    (fun _ -> ())
+
 
 let roll_conn: node_pcm' `connection` node_pcm =
-  mkconnection unroll roll () roll_conn_lift_fpu
-
-let unroll_conn_lift_fpu
-  (x: Ghost.erased _ {~ (Ghost.reveal x == one node_pcm') })
-  (y: Ghost.erased _)
-  (f: frame_preserving_upd node_pcm' x y)
-: frame_preserving_upd node_pcm (Mknode x) (Mknode y)
-= fun v ->
-  let w = Mknode (f v.un_node) in
-  let aux (frame:_{composable node_pcm (Mknode x) frame})
-  : Lemma (
-      composable node_pcm (Mknode y) frame /\
-      (op node_pcm (Mknode x) frame == v ==> op node_pcm (Mknode y) frame == w))
-  = unroll.morph_compose (Mknode x) frame
-  in FStar.Classical.forall_intro aux;
-  w
+  connection_of_isomorphism (isomorphism_inverse node_iso)
 
 let unroll_conn: node_pcm `connection` node_pcm' =
-  mkconnection roll unroll () unroll_conn_lift_fpu
+  connection_of_isomorphism node_iso
 
 let mk_node'_f (value: option int') (next: option (option (ref' node node)))
   (k: node_field)

From e4990e5cecc31c303b9bdf8e09801e8c43bbf25f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sat, 17 Jul 2021 21:24:35 -0700
Subject: [PATCH 109/513] fix universe for ref

---
 examples/steel/arraystructs/Steel.C.Ref.fst  | 2 +-
 examples/steel/arraystructs/Steel.C.Ref.fsti | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index 15a3355d132..ee64574337e 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -4,7 +4,7 @@ open FStar.FunctionalExtensionality
 
 #push-options "--print_universes"
 
-noeq type ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type = {
+noeq type ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type u#(max 1 b) = {
   p: pcm a;
   pl: connection p q;
   r: Steel.Memory.ref a p;
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 0b90d3cfb73..2d6750d27f2 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -6,7 +6,7 @@ open Steel.C.Connection
 
 #push-options "--print_universes"
 
-val ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type u#b
+val ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type u#(max 1 b)
 
 open Steel.Effect
 

From 0d518a91cf7400b14efa51bee711ecddda6de11f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 18 Jul 2021 10:43:52 -0700
Subject: [PATCH 110/513] small-universe (and extensional) PCMs

---
 .../steel/arraystructs/Steel.C.Connection.fst |  82 +++--
 examples/steel/arraystructs/Steel.C.PCM.fst   | 288 +++++++++++++++++-
 examples/steel/arraystructs/Steel.C.Ref.fst   | 143 +++++----
 examples/steel/arraystructs/Steel.C.Ref.fsti  |  44 ++-
 .../steel/arraystructs/Steel.C.Universe.fst   | 113 +++++++
 5 files changed, 538 insertions(+), 132 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Universe.fst

diff --git a/examples/steel/arraystructs/Steel.C.Connection.fst b/examples/steel/arraystructs/Steel.C.Connection.fst
index 6502065cc5c..d78b1b136ff 100644
--- a/examples/steel/arraystructs/Steel.C.Connection.fst
+++ b/examples/steel/arraystructs/Steel.C.Connection.fst
@@ -1,6 +1,5 @@
 module Steel.C.Connection
 
-open FStar.PCM
 open Steel.C.PCM
 open FStar.FunctionalExtensionality
 
@@ -8,8 +7,8 @@ let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
   (x1: 'a) (x2: 'a{composable pa x1 x2})
 = squash (
     composable pb (morph x1) (morph x2) /\
-    morph (x1 `pa.p.op` x2) == morph x1 `pb.p.op` morph x2)
-    
+    morph (x1 `op pa` x2) == morph x1 `op pb` morph x2)
+
 let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
   restricted_t (x2:'a{composable pa x1 x2}) (morph_compose2 pa pb morph x1)
 
@@ -59,7 +58,7 @@ let morphism_morph_compose
   (x2: a)
 : Lemma
   (requires (composable pa x1 x2))
-  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `pa.p.op` x2) == m.morph x1 `pb.p.op` m.morph x2))
+  (ensures (composable pb (m.morph x1) (m.morph x2) /\ m.morph (x1 `op pa` x2) == m.morph x1 `op pb` m.morph x2))
   [SMTPat (composable pb (m.morph x1) (m.morph x2))]
 = m.morph_compose x1 x2
 
@@ -94,31 +93,6 @@ let morphism_compose_id_right
   (m `morphism_compose` morphism_id pb == m)
 = morph_eq (m `morphism_compose` morphism_id pb) m
 
-let compatible_intro
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-  (frame: a)
-: Lemma
-  (requires (composable pcm x frame /\ op pcm frame x == y))
-  (ensures (compatible pcm x y))
-= ()
-
-let compatible_elim
-  (#a: Type u#a)
-  (pcm: pcm a)
-  (x y: a)
-: Ghost a
-  (requires (compatible pcm x y))
-  (ensures (fun frame ->
-    composable pcm x frame /\
-    op pcm frame x == y
-  ))
-= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
-    composable pcm x frame /\
-    op pcm frame x == y
-  )
-
 let compatible_morphism
   (#p: pcm 'a) (#q: pcm 'b)
   (f: p `morphism` q)
@@ -150,7 +124,7 @@ let frame_preserving_upd_dom
   (#a:Type u#a) (p:pcm a) (x y:a)
 =
   v:a{
-    p.refine v /\
+    p_refine p v /\
     compatible p x v
   }
 
@@ -159,7 +133,7 @@ let frame_preserving_upd_codom
   (v: frame_preserving_upd_dom p x y)
 =
   v_new:a{
-    p.refine v_new /\
+    p_refine p v_new /\
     compatible p y v_new /\
     (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
        composable p y frame /\
@@ -174,7 +148,7 @@ let restricted_frame_preserving_upd
 
 let restricted_frame_preserving_upd_intro
   (#a:Type u#a) (#p:pcm a) (#x #y: Ghost.erased a)
-  (f: FStar.PCM.frame_preserving_upd p x y)
+  (f: frame_preserving_upd p x y)
 : Tot (restricted_frame_preserving_upd p x y)
 =
   on_dom
@@ -185,7 +159,7 @@ let restricted_frame_preserving_upd_intro
 let restricted_frame_preserving_upd_elim
   (#a:Type u#a) (#p:pcm a) (#x #y: Ghost.erased a)
   (f: restricted_frame_preserving_upd p x y)
-: Tot (FStar.PCM.frame_preserving_upd p x y)
+: Tot (frame_preserving_upd p x y)
 = f
 
 let fpu_lift_dom (#t_small: Type) (p_small: pcm t_small)
@@ -306,10 +280,28 @@ let connection_compose_id_right
   (c `connection_compose` connection_id p_small == c)
 = connection_eq (c `connection_compose` connection_id p_small) c
 
+#push-options "--z3rlimit 32"
+
+let connection_compose_assoc
+  (#t1 #t2 #t3 #t4: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (#p3: pcm t3)
+  (#p4: pcm t4)
+  (c12: connection p1 p2)
+  (c23: connection p2 p3)
+  (c34: connection p3 p4)
+: Lemma
+  ((c12 `connection_compose` c23) `connection_compose` c34 == c12 `connection_compose` (c23 `connection_compose` c34))
+=
+  ((c12 `connection_compose` c23) `connection_compose` c34) `connection_eq` (c12 `connection_compose` (c23 `connection_compose` c34))
+
+#pop-options
+
 let morph_refine (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
-  (xa: 'a { pa.refine xa })
+  (xa: 'a { p_refine pa xa })
 = squash (
-    pb.refine (morph xa)
+    p_refine pb (morph xa)
   )
 
 noeq
@@ -318,8 +310,8 @@ type isomorphism (#t1 #t2: Type) (p1: pcm t1) (p2: pcm t2) = {
   iso_2_1: morphism p2 p1;
   iso_1_2_inv_2_1: squash (iso_1_2.morph `is_inverse_of` iso_2_1.morph);
   iso_2_1_inv_1_2: squash (iso_2_1.morph `is_inverse_of` iso_1_2.morph);
-  iso_1_2_refine: restricted_t (x1: t1 { p1.refine x1 }) (morph_refine p1 p2 iso_1_2.morph);
-  iso_2_1_refine: restricted_t (x2: t2 { p2.refine x2 }) (morph_refine p2 p1 iso_2_1.morph);
+  iso_1_2_refine: restricted_t (x1: t1 { p_refine p1 x1 }) (morph_refine p1 p2 iso_1_2.morph);
+  iso_2_1_refine: restricted_t (x2: t2 { p_refine p2 x2 }) (morph_refine p2 p1 iso_2_1.morph);
 }
 
 let isomorphism_eq
@@ -344,14 +336,14 @@ let mkisomorphism
   (iso_1_2_refine:
     (x1: t1) ->
     Lemma
-    (requires (p1.refine x1))
-    (ensures (p2.refine (iso_1_2.morph x1)))
+    (requires (p_refine p1 x1))
+    (ensures (p_refine p2 (iso_1_2.morph x1)))
   )
   (iso_2_1_refine:
     (x2: t2) ->
     Lemma
-    (requires (p2.refine x2))
-    (ensures (p1.refine (iso_2_1.morph x2)))
+    (requires (p_refine p2 x2))
+    (ensures (p_refine p1 (iso_2_1.morph x2)))
   )
 : Tot (isomorphism p1 p2)
 = {
@@ -359,8 +351,8 @@ let mkisomorphism
   iso_2_1 = iso_2_1;
   iso_1_2_inv_2_1 = iso_1_2_inv_2_1;
   iso_2_1_inv_1_2 = iso_2_1_inv_1_2;
-  iso_1_2_refine = on_dom (x1: t1 { p1.refine x1 }) #(morph_refine p1 p2 iso_1_2.morph) (fun x1 -> iso_1_2_refine x1);
-  iso_2_1_refine = on_dom (x2: t2 { p2.refine x2 }) #(morph_refine p2 p1 iso_2_1.morph) (fun x2 -> iso_2_1_refine x2);
+  iso_1_2_refine = on_dom (x1: t1 { p_refine p1 x1 }) #(morph_refine p1 p2 iso_1_2.morph) (fun x1 -> iso_1_2_refine x1);
+  iso_2_1_refine = on_dom (x2: t2 { p_refine p2 x2 }) #(morph_refine p2 p1 iso_2_1.morph) (fun x2 -> iso_2_1_refine x2);
 }
 
 let isomorphism_id
@@ -427,7 +419,7 @@ let connection_of_isomorphism_fpu'_correct
     let x1 = i.iso_2_1.morph x in
     let y1 = i.iso_2_1.morph y in
     let v_new = connection_of_isomorphism_fpu' i x y f v in
-    p1.refine v_new /\
+    p_refine p1 v_new /\
     compatible p1 y1 v_new /\
     (forall (frame: _ {composable p1 x1 frame}).{:pattern composable p1 x1 frame}
        composable p1 y1 frame /\
@@ -440,7 +432,7 @@ let connection_of_isomorphism_fpu'_correct
   let v2' = f (i.iso_1_2.morph v) in
   let v' = i.iso_2_1.morph v2' in
   i.iso_2_1_refine v2' ;
-  assert (p1.refine v');
+  assert (p_refine p1 v');
   compatible_morphism i.iso_2_1 y v2' ;
   let y1 = Ghost.hide (i.iso_2_1.morph y) in
   assert (compatible p1 y1 v');
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 62d8319ebfa..0b0b13faff4 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -1,14 +1,290 @@
 module Steel.C.PCM
-open FStar.PCM
+module P = FStar.PCM
 open FStar.FunctionalExtensionality
+open FStar.IndefiniteDescription
 
-unfold
-let one (#a: Type) (p: pcm a) = p.p.one
+let symrel_codom (#t: Type) (x: t) : Tot Type0 = bool
+
+let symrel (a: Type u#a) = c:(restricted_g_t (a & a) symrel_codom) { (forall x y. c (x, y) == c (y, x)) }
+
+let op_dom (#a: Type) (composable: symrel a) : Type = (xy: (a & a) { composable xy == true })
+
+let op_codom (#a: Type) (composable: symrel a) (x: op_dom composable) : Type = a
+
+noeq
+type pcm' (a:Type u#a) = {
+  composable: symrel a;
+  op: restricted_t (op_dom composable) (op_codom composable);
+  one:a
+}
+
+let pcm'_eq (#a: Type u#a) (p1 p2: pcm' a) : Lemma
+  (requires (
+    p1.composable `feq_g` p2.composable /\
+    p1.op `feq` p2.op /\
+    p1.one == p2.one
+  ))
+  (ensures (p1 == p2))
+= ()
+
+let fstar_pcm'_of_pcm'
+  (#a: Type)
+  (p: pcm' a)
+: Tot (P.pcm' a)
+= {
+  P.composable = (fun x y -> p.composable (x, y) == true);
+  P.op = (fun x y -> p.op (x, y));
+  P.one = p.one;
+}
+
+let composable_of_fstar_composable
+  (#a: Type)
+  (p: P.pcm' a)
+: Tot (symrel a)
+= on_dom_g (a & a) (fun xy -> strong_excluded_middle (p.P.composable (fst xy) (snd xy)) <: bool)
+
+let op_of_fstar_op
+  (#a: Type)
+  (p: P.pcm' a)
+: Tot (restricted_t (op_dom (composable_of_fstar_composable p)) (op_codom (composable_of_fstar_composable p)))
+= on_dom (op_dom (composable_of_fstar_composable p)) (fun xy -> p.P.op (fst xy) (snd xy))
+
+let pcm'_of_fstar_pcm'
+  (#a: Type)
+  (p: P.pcm' a)
+: Tot (pcm' a)
+= {
+  composable = composable_of_fstar_composable p;
+  op = op_of_fstar_op p;
+  one = p.P.one;
+}
+
+let pcm'_of_fstar_pcm'_of_pcm'
+  (#a: Type)
+  (p: pcm' a)
+: Lemma
+  (pcm'_of_fstar_pcm' (fstar_pcm'_of_pcm' p) == p)
+= pcm'_of_fstar_pcm' (fstar_pcm'_of_pcm' p) `pcm'_eq` p
+
+let lem_commutative_codom
+  (#a: Type u#a) (p:pcm' a) (xy: op_dom p.composable)
+: Tot Type
+= squash (p.op xy == p.op (snd xy, fst xy))
+
+let lem_commutative (#a: Type u#a) (p:pcm' a) = restricted_t (op_dom p.composable) (lem_commutative_codom p)
+
+let lem_assoc_l_dom (#a: Type u#a) (p: pcm' a) =
+  (xyz: (a & a & a) {
+    let (x, y, z) = xyz in
+    p.composable (y, z) == true /\
+    p.composable (x, p.op (y, z)) == true
+  })
+
+let lem_assoc_l_codom (#a :Type u#a) (p: pcm' a) (xyz: lem_assoc_l_dom p) =
+  squash (
+    let (x, y, z) = xyz in
+    p.composable (x, y) == true /\
+    p.composable (p.op (x, y), z) == true /\
+    p.op (x, p.op (y, z)) == p.op (p.op (x, y), z)
+  )
+
+let lem_assoc_l (#a :Type u#a) (p: pcm' a) =
+  restricted_t (lem_assoc_l_dom p) (lem_assoc_l_codom p)
+
+let lem_assoc_r_dom (#a: Type u#a) (p: pcm' a) =
+  (xyz: (a & a & a) {
+    let (x, y, z) = xyz in
+    p.composable (x, y) == true /\
+    p.composable (p.op (x, y), z) == true
+  })
+
+let lem_assoc_r_codom (#a :Type u#a) (p: pcm' a) (xyz: lem_assoc_r_dom p) =
+  squash (
+    let (x, y, z) = xyz in
+    p.composable (y, z) == true /\
+    p.composable (x, p.op (y, z)) == true /\
+    p.op (x, p.op (y, z)) == p.op (p.op (x, y), z)
+  )
+
+let lem_assoc_r (#a: Type u#a) (p: pcm' a) =
+  restricted_t (lem_assoc_r_dom p) (lem_assoc_r_codom p)
+
+let lem_is_unit_codom (#a: Type u#a) (p: pcm' a) (x: a) : Tot Type0 =
+  squash (
+    p.composable (x, p.one) == true /\
+    p.op (x, p.one) == x
+  )
+
+let lem_is_unit (#a: Type) (p: pcm' a) =
+  restricted_t a (lem_is_unit_codom p)
+
+noeq
+type pcm0 (a:Type u#a) : Type u#a = {
+  p:pcm' a;
+  comm:lem_commutative p;
+  assoc: lem_assoc_l p;
+  assoc_r: lem_assoc_r p;
+  is_unit: lem_is_unit p;
+  refine: restricted_g_t a symrel_codom;
+}
+
+let pcm_eq (#a: Type u#a) (p1 p2: pcm0 a) : Lemma
+  (requires (
+    p1.p.composable `feq_g` p2.p.composable /\
+    p1.p.op `feq` p2.p.op /\
+    p1.p.one == p2.p.one /\
+    p1.refine `feq_g` p2.refine
+  ))
+  (ensures (p1 == p2))
+= assert (p1.comm `feq` p2.comm);
+  assert (p1.assoc `feq` p2.assoc);
+  assert (p1.assoc_r `feq` p2.assoc_r);
+  assert (p1.is_unit `feq` p2.is_unit)
+
+let composable (#a: Type u#a) (p:pcm0 a) (x y:a) = p.p.composable (x, y) == true
+
+let one (#a: Type) (p: pcm0 a) = p.p.one
+
+let op (#a: Type u#a) (p:pcm0 a) (x:a) (y:a{composable p x y}) = p.p.op (x, y)
+
+let op_comm
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y: a)
+: Lemma
+  (requires (composable p x y))
+  (ensures (composable p y x /\ op p x y == op p y x))
+  [SMTPat (composable p x y)]
+= p.comm (x, y)
+
+let p_refine (#a: Type) (p: pcm0 a) (x: a) : Tot prop =
+  p.refine x == true
+
+let pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+: Tot (pcm0 a)
+= let pp = pcm'_of_fstar_pcm' p.P.p in
+  {
+  p = pp;
+  comm = on_dom (op_dom pp.composable) (fun xy -> p.P.comm (fst xy) (snd xy) <: lem_commutative_codom pp xy);
+  assoc = on_dom (lem_assoc_l_dom pp) (fun xyz -> let (x, y, z) = xyz in p.P.assoc x y z <: lem_assoc_l_codom pp xyz);
+  assoc_r = on_dom (lem_assoc_r_dom pp) (fun xyz -> let (x, y, z) = xyz in p.P.assoc_r x y z <: lem_assoc_r_codom pp xyz);
+  is_unit = on_dom a (fun x -> p.P.is_unit x <: lem_is_unit_codom pp x);
+  refine = on_dom_g _ (fun x -> strong_excluded_middle (p.P.refine x) <: bool);
+}
+
+let fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+: Tot (P.pcm a)
+= let pp = fstar_pcm'_of_pcm' p.p in
+  {
+  P.p = pp;
+  P.comm = (fun x y -> p.comm (x, y));
+  P.assoc = (fun x y z -> p.assoc (x, y, z));
+  P.assoc_r = (fun x y z -> p.assoc_r (x, y, z));
+  P.is_unit = (fun x ->
+    let _ : squash (
+      p.p.composable (x, p.p.one) == true /\
+      p.p.op (x, p.p.one) == x
+    ) =
+      p.is_unit x
+    in
+    assert (p.p.composable (x, p.p.one) == true);
+    assert (p.p.op (x, p.p.one) == x)
+  );
+  P.refine = (fun x -> p.refine x == true);
+}
+
+let pcm_of_fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+: Lemma
+  (pcm_of_fstar_pcm (fstar_pcm_of_pcm p) == p)
+= pcm_of_fstar_pcm (fstar_pcm_of_pcm p) `pcm_eq` p
+
+let exclusive (#a:Type u#a) (p:pcm0 a) (x:a) =
+  forall (frame:a). composable p x frame ==> frame == p.p.one
+
+let compatible (#a: Type u#a) (pcm:pcm0 a) (x y:a) =
+  (exists (frame:a).
+    composable pcm x frame /\ op pcm frame x == y
+  )
+
+let is_unit (#a: Type u#a) (p:pcm0 a)
+  (x:a)
+:  Lemma (composable p x (one p) /\
+         op p x (one p) == x)
+= (fstar_pcm_of_pcm p).P.is_unit x
+
+let is_unit_pat (#a: Type u#a) (p:pcm0 a)
+  (x:a)
+:  Lemma (composable p x (one p) /\
+         op p x (one p) == x)
+   [SMTPat (composable p x (one p))]
+= is_unit p x
+
+let compatible_intro
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x y: a)
+  (frame: a)
+: Lemma
+  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (ensures (compatible pcm x y))
+= ()
+
+let compatible_elim
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x y: a)
+: Ghost a
+  (requires (compatible pcm x y))
+  (ensures (fun frame ->
+    composable pcm x frame /\
+    op pcm frame x == y
+  ))
+= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame -> 
+    composable pcm x frame /\
+    op pcm frame x == y
+  )
+
+let compatible_refl
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x: a)
+: Lemma
+  (compatible pcm x x)
+= compatible_intro pcm x x (one pcm)
+
+type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
+  v:a{
+    p_refine p v /\
+    compatible p x v
+  } ->
+  v_new:a{
+    p_refine p v_new /\
+    compatible p y v_new /\
+    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
+       composable p y frame /\
+       (op p x frame == v ==> op p y frame == v_new))}
+
+let fstar_fpu_of_fpu
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+: Tot (FStar.PCM.frame_preserving_upd (fstar_pcm_of_pcm p) x y)
+= fun v ->
+  let y : a = f v in
+  assert (forall frame . P.composable (fstar_pcm_of_pcm p) x frame <==> composable p x frame);
+  y
 
 let pcm (a: Type) : Tot Type =
-  (p: FStar.PCM.pcm a {
+  (p: pcm0 a {
     (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
       op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
-    (forall (x:a) . {:pattern (p.refine x)} p.refine x ==> exclusive p x) /\ // nice to have, but not used yet
-    (~ (p.refine (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+    (forall (x:a) . {:pattern (p_refine p x)} p_refine p x ==> exclusive p x) /\ // nice to have, but not used yet
+    (~ (p_refine p (one p))) // necessary to maintain (refine ==> exclusive) for uninit
   })
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index ee64574337e..e08f47a0069 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -1,84 +1,113 @@
 module Steel.C.Ref
 module P = FStar.PCM
+module U = Steel.C.Universe
 open FStar.FunctionalExtensionality
 
 #push-options "--print_universes"
 
-noeq type ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type u#(max 1 b) = {
+noeq type ref' (a: Type u#0) (b: Type u#b) : Type u#b = {
   p: pcm a;
+  q: pcm b;
   pl: connection p q;
-  r: Steel.Memory.ref a p;
+  r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
 }
 
-let mpts_to (#p: pcm 'a) (r: Steel.Memory.ref 'a p) = Steel.PCMReference.pts_to r
+let pcm_of_ref' r = r.q
+
+let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
+
+let raise_p
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ref' a b)
+: Tot (pcm (U.raise_t u#0 u#1 a))
+= U.raise_pcm r.p
+
+let lower_conn
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ref' a b)
+: Tot (connection (raise_p r) r.p)
+= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 r.p))
+
+let raise_pl
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ref' a b)
+: Tot (connection (raise_p r) r.q)
+= lower_conn r `connection_compose` r.pl
 
 let pts_to r v =
-  r.r `mpts_to` r.pl.conn_small_to_large.morph v
-  
-let ref_focus r l = {p = r.p; pl = connection_compose r.pl l; r = r.r}
+  r.r `mpts_to` (raise_pl r).conn_small_to_large.morph v
+
+let ref_focus r #q l = {p = r.p; pl = connection_compose r.pl l; r = r.r; q = q}
 
 let ref_focus_id r = connection_compose_id_right r.pl
 
 let ref_focus_comp r l m
-= connection_eq
-    ((r.pl `connection_compose` l) `connection_compose` m)
-    (r.pl `connection_compose` (l `connection_compose` m))
+= connection_compose_assoc r.pl l m
 
 let focus r l s x =
   let r' = ref_focus r l in
-  A.change_slprop_rel  
+  connection_compose_assoc (lower_conn r) r.pl l;
+  A.change_equal_slprop
     (r `pts_to` s)
-    (r' `pts_to` x)
-    (fun _ _ -> True)
-    (fun m -> ());
+    (r' `pts_to` x);
   A.return r'
 
 let unfocus r r' l x =
-  A.change_slprop_rel  
+  connection_compose_assoc (lower_conn r') r'.pl l;
+  A.change_equal_slprop
     (r `pts_to` x)
     (r' `pts_to` l.conn_small_to_large.morph x)
-    (fun _ _ -> True)
-    (fun m -> ())
 
 let split r xy x y =
+  let c = raise_pl r in
+  let xy2 = Ghost.hide (c.conn_small_to_large.morph xy) in
+  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
+  assert (composable (raise_p r) x2 y2);
   A.change_equal_slprop
     (r `pts_to` xy)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph xy)));
+    (r.r `mpts_to` xy2);
   Steel.PCMReference.split r.r
-    (r.pl.conn_small_to_large.morph xy)
-    (r.pl.conn_small_to_large.morph x)
-    (r.pl.conn_small_to_large.morph y);
+    xy2
+    x2
+    y2;
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)))
+    (r.r `mpts_to` x2)
     (r `pts_to` x);
   A.change_equal_slprop
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)))
+    (r.r `mpts_to` y2)
     (r `pts_to` y)
 
 let mgather
-  (#a:Type) (#p:pcm a)
+  (#a:Type) (#p:P.pcm a)
   (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: SteelT (_:unit{composable p v0 v1})
+: SteelT (_:unit{P.composable p v0 v1})
     (mpts_to r v0 `star` mpts_to r v1)
-    (fun _ -> mpts_to r (op p v0 v1))
+    (fun _ -> mpts_to r (P.op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
 let gather #a #b #p r x y =
+  let c = raise_pl r in
+  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
   A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph x)));
+    (r.r `mpts_to` x2);
   A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `mpts_to` Ghost.reveal (Ghost.hide (r.pl.conn_small_to_large.morph y)));
+    (r.r `mpts_to` y2);
   mgather r.r
-    (r.pl.conn_small_to_large.morph x)
-    (r.pl.conn_small_to_large.morph y);
+    x2
+    y2;
+  assert (composable (raise_p r) x2 y2);
   assert (
-    let x1 = r.pl.conn_small_to_large.morph x in
-    let y1 = r.pl.conn_small_to_large.morph y in
-    let x2 = r.pl.conn_large_to_small.morph x1 in
-    let y2 = r.pl.conn_large_to_small.morph y1 in
-    Ghost.reveal x == x2 /\ Ghost.reveal y == y2
+    let x' = c.conn_large_to_small.morph x2 in
+    let y' = c.conn_large_to_small.morph y2 in
+    composable p x' y' /\
+    Ghost.reveal x == x' /\ Ghost.reveal y == y'
   );
   A.change_equal_slprop _ (r `pts_to` op p x y)
 
@@ -88,22 +117,20 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (fun _ -> r `pts_to` x)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible p x x')
-= let w = Ghost.hide (r.pl.conn_small_to_large.morph x) in
+= let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
   A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
   let w' = Steel.PCMReference.read r.r w in
   A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
-  let x' = r.pl.conn_large_to_small.morph w' in
-  assert (forall frame . (composable r.p w frame /\ op r.p frame w == w') ==> (
-    let sw = r.pl.conn_large_to_small.morph w in
-    let sw' = r.pl.conn_large_to_small.morph w' in
-    let sframe = r.pl.conn_large_to_small.morph frame in
-    (composable p sw sframe /\ op p sframe sw == sw')
-  ));
+  let x' = (raise_pl r).conn_large_to_small.morph w' in
+  compatible_morphism (raise_pl r).conn_large_to_small w w';
   A.return x'
 
 let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
 : Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= M.upd_gen Set.empty r.r  (Ghost.hide (r.pl.conn_small_to_large.morph x)) (Ghost.hide (r.pl.conn_small_to_large.morph y)) (r.pl.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|))
+= let c = raise_pl r in
+  let x' = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y' = Ghost.hide (c.conn_small_to_large.morph y) in
+  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (c.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|) ))
 
 let as_action (#p:vprop)
               (#q:vprop)
@@ -118,12 +145,11 @@ let ref_upd r x y f = as_action (ref_upd_act r x y f)
 
 let base_fpu p x y =
   fun _ ->
-  Classical.forall_intro (is_unit p);
   compatible_refl p y;
   y
 
 let pts_to_view_explicit_witinv
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
   (vw: sel_view p c)
@@ -134,22 +160,23 @@ let pts_to_view_explicit_witinv
     (requires (M.interp (pts_to_view_explicit r vw x) m /\ M.interp (pts_to_view_explicit r vw y) m))
     (ensures  (x == y))
   =
+    let c = raise_pl r in
     let x_ = vw.to_carrier x in
     let y_ = vw.to_carrier y in
-    let x' = r.pl.conn_small_to_large.morph x_ in
-    let y' = r.pl.conn_small_to_large.morph y_ in
+    let x' = c.conn_small_to_large.morph x_ in
+    let y' = c.conn_small_to_large.morph y_ in
     M.pts_to_join r.r x' y' m;
-    let z' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun z' -> compatible r.p x' z' /\ compatible r.p y' z') in
-    let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_x' -> composable r.p x' frame_x' /\ op r.p frame_x' x' == z') in
-    let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost a (fun frame_y' -> composable r.p y' frame_y' /\ op r.p frame_y' y' == z') in
-    let frame_x_ = r.pl.conn_large_to_small.morph frame_x' in
-    let frame_y_ = r.pl.conn_large_to_small.morph frame_y' in
-    r.p.comm x' frame_x';
-    r.pl.conn_large_to_small.morph_compose x' frame_x';
-    vw.to_view_frame x (r.pl.conn_large_to_small.morph frame_x');
-    r.p.comm y' frame_y';
-    r.pl.conn_large_to_small.morph_compose y' frame_y';
-    vw.to_view_frame y (r.pl.conn_large_to_small.morph frame_y');
+    let z' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun z' -> compatible (raise_p r) x' z' /\ compatible (raise_p r) y' z') in
+    let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_x' -> composable (raise_p r) x' frame_x' /\ op (raise_p r) frame_x' x' == z') in
+    let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_y' -> composable (raise_p r) y' frame_y' /\ op (raise_p r) frame_y' y' == z') in
+    let frame_x_ = c.conn_large_to_small.morph frame_x' in
+    let frame_y_ = c.conn_large_to_small.morph frame_y' in
+    op_comm (raise_p r) x' frame_x';
+    c.conn_large_to_small.morph_compose x' frame_x';
+    vw.to_view_frame x (c.conn_large_to_small.morph frame_x');
+    op_comm (raise_p r) y' frame_y';
+    c.conn_large_to_small.morph_compose y' frame_y';
+    vw.to_view_frame y (c.conn_large_to_small.morph frame_y');
     ()
   in
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 2d6750d27f2..79d639eed25 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -1,17 +1,21 @@
 module Steel.C.Ref
-open FStar.PCM
 open FStar.FunctionalExtensionality
 open Steel.C.PCM
 open Steel.C.Connection
 
 #push-options "--print_universes"
 
-val ref (a: Type u#1) (#b: Type u#b) (q: pcm b): Type u#(max 1 b)
+val ref' (a: Type u#0) (b: Type u#b) : Type u#b
+
+val pcm_of_ref' (#a: _) (#b: Type u#b) (r: ref' a b) : GTot (pcm b)
+
+let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
+  (r: ref' a b { pcm_of_ref' r == q })
 
 open Steel.Effect
 
 val pts_to
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
 : vprop
 
@@ -82,19 +86,13 @@ val ref_upd
   (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 
-let is_unit (#a: Type u#a) (p:pcm a) 
-  (x:a)
-:  Lemma (composable p x p.FStar.PCM.p.one /\
-         op p x p.FStar.PCM.p.one == x)
-= p.is_unit x
-
 val base_fpu
   (#a: Type)
   (p: pcm a)
   (x: Ghost.erased a)
   (y: a)
 : Pure (frame_preserving_upd p x y)
-  (requires (exclusive p x /\ p.refine y))
+  (requires (exclusive p x /\ p_refine p y))
   (ensures (fun _ -> True))
 
 let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
@@ -143,7 +141,7 @@ let sel_view_inv
   ()
 
 let pts_to_view_explicit
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
   (vw: sel_view p c)
@@ -152,7 +150,7 @@ let pts_to_view_explicit
 = hp_of (pts_to r (vw.to_carrier v))
 
 val pts_to_view_explicit_witinv
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
   (vw: sel_view p c)
@@ -160,7 +158,7 @@ val pts_to_view_explicit_witinv
   (M.is_witness_invariant (pts_to_view_explicit r vw))
 
 let pts_to_view_sl
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
   (vw: sel_view p c)
@@ -168,7 +166,7 @@ let pts_to_view_sl
 = M.h_exists (pts_to_view_explicit r vw)
 
 let pts_to_view_sel'
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -178,7 +176,7 @@ let pts_to_view_sel'
   Ghost.reveal (Ghost.reveal x)
 
 let pts_to_view_depends_only_on
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -190,7 +188,7 @@ let pts_to_view_depends_only_on
   M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
 
 let pts_to_view_depends_only_on_core
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -202,7 +200,7 @@ let pts_to_view_depends_only_on_core
   M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
 
 let pts_to_view_sel
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -213,7 +211,7 @@ let pts_to_view_sel
 
 [@@__steel_reduce__]
 let pts_to_view'
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -226,7 +224,7 @@ let pts_to_view'
 
 [@@__steel_reduce__]
 let pts_to_view 
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -234,7 +232,7 @@ let pts_to_view
 = VUnit (pts_to_view' r vw)
 
 let pts_to_view_intro_lemma
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (x: Ghost.erased b)
   (#c: Type0)
@@ -253,7 +251,7 @@ let pts_to_view_intro_lemma
 
 let pts_to_view_intro
   (#invs: _)
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (x: Ghost.erased b)
   (#c: Type0)
@@ -275,7 +273,7 @@ let pts_to_view_intro
     )
 
 let pts_to_view_elim_lemma
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
@@ -310,7 +308,7 @@ let intro_vdep2 (#opened:_)
 
 let pts_to_view_elim
   (#invs: _)
-  (#a: Type u#1) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (vw: sel_view p c)
diff --git a/examples/steel/arraystructs/Steel.C.Universe.fst b/examples/steel/arraystructs/Steel.C.Universe.fst
new file mode 100644
index 00000000000..2960a1c8269
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Universe.fst
@@ -0,0 +1,113 @@
+module Steel.C.Universe
+open Steel.C.PCM
+include FStar.Universe
+module P = FStar.PCM
+
+(* Raising to a greater universe *)
+
+#push-options "--print_universes"
+
+let raise_pcm'
+  (#a: Type u#a)
+  (p: pcm' a)
+: Tot (pcm' (raise_t u#a u#b a))
+=
+  let pp = fstar_pcm'_of_pcm' p in
+  pcm'_of_fstar_pcm' ({
+    P.composable = (fun (x: raise_t u#a u#b a) y -> pp.P.composable (downgrade_val x) (downgrade_val y));
+    P.op = (fun x y -> raise_val (pp.P.op (downgrade_val x) (downgrade_val y)));
+    P.one = raise_val p.one;
+  })
+
+let raise_pcm0
+  (#a: Type u#a)
+  (p: pcm0 a)
+: Tot (pcm0 (raise_t u#a u#b a))
+= let pp = fstar_pcm_of_pcm p in
+  pcm_of_fstar_pcm ({
+    P.p = fstar_pcm'_of_pcm' (raise_pcm' u#a u#b p.p);
+    P.comm = (fun x y -> pp.P.comm (downgrade_val x) (downgrade_val y));
+    P.assoc = (fun x y z -> pp.P.assoc (downgrade_val x) (downgrade_val y) (downgrade_val z));
+    P.assoc_r = (fun x y z -> pp.P.assoc_r (downgrade_val x) (downgrade_val y) (downgrade_val z));
+    P.is_unit = (fun x -> pp.P.is_unit (downgrade_val x));
+    P.refine = (fun x -> pp.P.refine (downgrade_val x));
+  })
+
+let raise_pcm
+  (#a: Type u#a)
+  (p: pcm a)
+: Tot (pcm (raise_t u#a u#b a))
+= let res = raise_pcm0 u#a u#b p in
+  let aux1
+    (x: raise_t a)
+    (y: raise_t a { composable res x y })
+  : Lemma
+    (requires (op res x y == one res))
+    (ensures (x == one res /\ y == one res))
+    [SMTPat (composable res x y)]
+  =
+    let x' = downgrade_val x in
+    let y' = downgrade_val y in
+    assert (composable p x' y');
+    assert (op p x' y' == downgrade_val (raise_val (one p)));
+    assert (op res x y == one res)
+  in
+  let aux2
+    (x: raise_t a)
+  : Lemma
+    (requires (p_refine res x))
+    (ensures (exclusive res x))
+    [SMTPat (p_refine res x)]
+  =
+    let aux
+      (frame: raise_t a)
+    : Lemma
+      (requires (composable res x frame))
+      (ensures (frame == one res))
+      [SMTPat (composable res x frame)]
+    =
+      let x' = downgrade_val x in
+      assert (p_refine p x');
+      let frame' = downgrade_val frame in
+      assert (composable p x' frame');
+      assert (frame' == one p);
+      assert (frame == raise_val frame')
+    in
+    ()
+  in
+  res
+
+open Steel.C.Connection
+
+let raise_pcm_morphism
+  (#a: Type u#a)
+  (p: pcm a)
+: Tot (morphism p (raise_pcm u#a u#b p))
+=
+  mkmorphism
+    raise_val
+    ()
+    (fun _ _ -> ())
+
+let raise_pcm_morphism_inverse
+  (#a: Type u#a)
+  (p: pcm a)
+: Tot (morphism (raise_pcm u#a u#b p) p)
+=
+  mkmorphism
+    downgrade_val
+    ()
+    (fun _ _ -> ())
+
+let raise_pcm_isomorphism
+  (#a: Type u#a)
+  (p: pcm a)
+: Tot (isomorphism p (raise_pcm u#a u#b p))
+=
+  mkisomorphism
+    (raise_pcm_morphism p)
+    (raise_pcm_morphism_inverse p)
+    ()
+    ()
+    (fun _ -> ())
+    (fun _ -> ())

From 9f040d908b426e735fc4baa79abfd33ee924f2cf Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 18 Jul 2021 12:36:08 -0700
Subject: [PATCH 111/513] alloc

---
 examples/steel/arraystructs/Steel.C.Ref.fst  | 22 ++++++++++++++++++++
 examples/steel/arraystructs/Steel.C.Ref.fsti |  8 +++++++
 2 files changed, 30 insertions(+)

diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index e08f47a0069..01a60b2dfd4 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -47,6 +47,28 @@ let ref_focus_id r = connection_compose_id_right r.pl
 let ref_focus_comp r l m
 = connection_compose_assoc r.pl l m
 
+let mk_id_ref
+  (#a: Type0)
+  (p: pcm a)
+  (r0: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)))
+: Tot (ref a p)
+=
+  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
+  let fp = fstar_pcm_of_pcm p' in
+  let r : ref' a a = { p = p; q = p; pl = connection_id p; r = r0 } in
+  r
+
+let ref_alloc #a p x =
+  let x' : U.raise_t u#0 u#1 a = U.raise_val u#0 u#1 x in
+  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
+//  let fp : P.pcm u#1 _ = fstar_pcm_of_pcm p' in // FIXME: I can define this local definition, but WHY WHY WHY can't I USE it?
+  compatible_refl p' x';
+  let r0 : Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) = Steel.PCMReference.alloc #_ #(fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) x' in
+  let r : ref' a a = mk_id_ref p r0 in
+  connection_compose_id_right (lower_conn r);
+  A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
+  A.return r
+
 let focus r l s x =
   let r' = ref_focus r l in
   connection_compose_assoc (lower_conn r) r.pl l;
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 79d639eed25..12495753616 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -39,6 +39,14 @@ val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
 
 module A = Steel.Effect.Atomic
 
+val ref_alloc
+  (#a:Type0) (p: pcm a) (x: a)
+: Steel (ref a p)
+    emp
+    (fun r -> r `pts_to` x)
+    (requires fun _ -> p_refine p x)
+    (ensures fun _ _ _ -> True)
+
 val focus (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)

From 81307b5ab9c7a5ffeb5e0ab10c2358268b3d0f54 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 18 Jul 2021 15:43:48 -0700
Subject: [PATCH 112/513] abstract away fstar_pcm_of_pcm, pcm_of_fstar_pcm

---
 .../steel/arraystructs/Steel.C.Connection.fst |  10 +-
 examples/steel/arraystructs/Steel.C.PCM.fst   |  95 +++++---
 examples/steel/arraystructs/Steel.C.PCM.fsti  | 218 ++++++++++++++++++
 examples/steel/arraystructs/Steel.C.Ref.fst   |   4 +
 .../steel/arraystructs/Steel.C.Universe.fst   |  53 +++--
 5 files changed, 322 insertions(+), 58 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.PCM.fsti

diff --git a/examples/steel/arraystructs/Steel.C.Connection.fst b/examples/steel/arraystructs/Steel.C.Connection.fst
index d78b1b136ff..94615736b7c 100644
--- a/examples/steel/arraystructs/Steel.C.Connection.fst
+++ b/examples/steel/arraystructs/Steel.C.Connection.fst
@@ -15,12 +15,12 @@ let morph_compose1 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b) (x1: 'a) =
 noeq
 type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
   morph: (a ^-> b);
-  morph_unit: squash (morph pa.p.one == pb.p.one);
+  morph_unit: squash (morph (one pa) == one pb);
   morph_compose: restricted_t a (morph_compose1 pa pb morph);
 }
 
 let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
-  (morph_unit: squash (morph pa.p.one == pb.p.one))
+  (morph_unit: squash (morph (one pa) == one pb))
   (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
 : pa `morphism` pb = {
   morph = on_dom 'a morph;
@@ -163,7 +163,7 @@ let restricted_frame_preserving_upd_elim
 = f
 
 let fpu_lift_dom (#t_small: Type) (p_small: pcm t_small)
-= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) &
+= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) &
    y:Ghost.erased t_small &
    restricted_frame_preserving_upd p_small x y)
 
@@ -203,7 +203,7 @@ let mkconnection0 (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: p
   (conn_small_to_large_inv:
     squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
   (conn_lift_frame_preserving_upd:
-    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
      y:Ghost.erased t_small ->
      restricted_frame_preserving_upd p_small x y ->
      restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
@@ -225,7 +225,7 @@ let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pc
   (conn_small_to_large_inv:
     squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
   (conn_lift_frame_preserving_upd:
-    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == p_small.p.one)}) ->
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
      y:Ghost.erased t_small ->
      frame_preserving_upd p_small x y ->
      frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index 0b0b13faff4..beb034dd755 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -12,7 +12,7 @@ let op_dom (#a: Type) (composable: symrel a) : Type = (xy: (a & a) { composable
 let op_codom (#a: Type) (composable: symrel a) (x: op_dom composable) : Type = a
 
 noeq
-type pcm' (a:Type u#a) = {
+type pcm' (a:Type u#a) : Type u#a = {
   composable: symrel a;
   op: restricted_t (op_dom composable) (op_codom composable);
   one:a
@@ -141,11 +141,11 @@ let pcm_eq (#a: Type u#a) (p1 p2: pcm0 a) : Lemma
   assert (p1.assoc_r `feq` p2.assoc_r);
   assert (p1.is_unit `feq` p2.is_unit)
 
-let composable (#a: Type u#a) (p:pcm0 a) (x y:a) = p.p.composable (x, y) == true
+let composable (#a: Type u#a) (p:pcm0 a) (x y:a) : Tot prop = p.p.composable (x, y) == true
 
-let one (#a: Type) (p: pcm0 a) = p.p.one
+let one (#a: Type) (p: pcm0 a) : Tot a = p.p.one
 
-let op (#a: Type u#a) (p:pcm0 a) (x:a) (y:a{composable p x y}) = p.p.op (x, y)
+let op (#a: Type u#a) (p:pcm0 a) (x:a) (y:a{composable p x y}) : Tot a = p.p.op (x, y)
 
 let op_comm
   (#a: Type u#a)
@@ -157,6 +157,32 @@ let op_comm
   [SMTPat (composable p x y)]
 = p.comm (x, y)
 
+let op_assoc_l
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y z: a)
+: Lemma
+  (requires (composable p y z /\ composable p x (op p y z)))
+  (ensures (
+    composable p x y /\ composable p (op p x y) z /\
+    op p x (op p y z) == op p (op p x y) z
+  ))
+  [SMTPat (composable p y z); SMTPat (composable p x (op p y z))]
+= p.assoc (x, y, z)
+
+let op_assoc_r
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y z: a)
+: Lemma
+  (requires (composable p x y /\ composable p (op p x y) z))
+  (ensures (
+    composable p y z /\ composable p x (op p y z) /\
+    op p x (op p y z) == op p (op p x y) z
+  ))
+  [SMTPat (composable p x y); SMTPat (composable p (op p x y) z)]
+= p.assoc_r (x, y, z)
+
 let p_refine (#a: Type) (p: pcm0 a) (x: a) : Tot prop =
   p.refine x == true
 
@@ -204,13 +230,32 @@ let pcm_of_fstar_pcm_of_pcm
   (pcm_of_fstar_pcm (fstar_pcm_of_pcm p) == p)
 = pcm_of_fstar_pcm (fstar_pcm_of_pcm p) `pcm_eq` p
 
-let exclusive (#a:Type u#a) (p:pcm0 a) (x:a) =
-  forall (frame:a). composable p x frame ==> frame == p.p.one
+let composable_pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+  (x y: a)
+: Lemma
+  ((composable (pcm_of_fstar_pcm p) x y <==> P.composable p x y) /\
+    (composable (pcm_of_fstar_pcm p) x y ==> op (pcm_of_fstar_pcm p) x y == P.op p x y))
+  [SMTPat (composable (pcm_of_fstar_pcm p) x y)]
+= ()
 
-let compatible (#a: Type u#a) (pcm:pcm0 a) (x y:a) =
-  (exists (frame:a).
-    composable pcm x frame /\ op pcm frame x == y
-  )
+let one_pcm_of_fstar_pcm p = ()
+
+let p_refine_pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+  (x: a)
+: Lemma
+  (p_refine (pcm_of_fstar_pcm p) x <==> p.P.refine x)
+  [SMTPat (p_refine (pcm_of_fstar_pcm p) x)]
+= ()
+
+let composable_fstar_pcm_of_pcm p x y = ()
+
+let one_fstar_pcm_of_pcm p = ()
+
+let refine_fstar_pcm_of_pcm p x = ()
 
 let is_unit (#a: Type u#a) (p:pcm0 a)
   (x:a)
@@ -218,13 +263,6 @@ let is_unit (#a: Type u#a) (p:pcm0 a)
          op p x (one p) == x)
 = (fstar_pcm_of_pcm p).P.is_unit x
 
-let is_unit_pat (#a: Type u#a) (p:pcm0 a)
-  (x:a)
-:  Lemma (composable p x (one p) /\
-         op p x (one p) == x)
-   [SMTPat (composable p x (one p))]
-= is_unit p x
-
 let compatible_intro
   (#a: Type u#a)
   (pcm: pcm0 a)
@@ -258,17 +296,10 @@ let compatible_refl
   (compatible pcm x x)
 = compatible_intro pcm x x (one pcm)
 
-type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
-  v:a{
-    p_refine p v /\
-    compatible p x v
-  } ->
-  v_new:a{
-    p_refine p v_new /\
-    compatible p y v_new /\
-    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
-       composable p y frame /\
-       (op p x frame == v ==> op p y frame == v_new))}
+let compatible_fstar_pcm_of_pcm p x y = ()
+let compatible_pcm_of_fstar_pcm p x y = ()
+let exclusive_fstar_pcm_of_pcm p x = ()
+let exclusive_pcm_of_fstar_pcm p x = ()
 
 let fstar_fpu_of_fpu
   (#a: Type u#a)
@@ -280,11 +311,3 @@ let fstar_fpu_of_fpu
   let y : a = f v in
   assert (forall frame . P.composable (fstar_pcm_of_pcm p) x frame <==> composable p x frame);
   y
-
-let pcm (a: Type) : Tot Type =
-  (p: pcm0 a {
-    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
-      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
-    (forall (x:a) . {:pattern (p_refine p x)} p_refine p x ==> exclusive p x) /\ // nice to have, but not used yet
-    (~ (p_refine p (one p))) // necessary to maintain (refine ==> exclusive) for uninit
-  })
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/examples/steel/arraystructs/Steel.C.PCM.fsti
new file mode 100644
index 00000000000..a3348e28c93
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.PCM.fsti
@@ -0,0 +1,218 @@
+module Steel.C.PCM
+module P = FStar.PCM
+open FStar.FunctionalExtensionality
+open FStar.IndefiniteDescription
+
+val pcm0 (a:Type u#a) : Type u#a
+
+val composable (#a: Type u#a) (p:pcm0 a) (x y:a) : Tot prop
+
+val one (#a: Type) (p: pcm0 a) : Tot a
+
+val op (#a: Type u#a) (p:pcm0 a) (x:a) (y:a{composable p x y}) : Tot a
+
+val op_comm
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y: a)
+: Lemma
+  (requires (composable p x y))
+  (ensures (composable p y x /\ op p x y == op p y x))
+  [SMTPat (composable p x y)]
+
+val op_assoc_l
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y z: a)
+: Lemma
+  (requires (composable p y z /\ composable p x (op p y z)))
+  (ensures (
+    composable p x y /\ composable p (op p x y) z /\
+    op p x (op p y z) == op p (op p x y) z
+  ))
+  [SMTPat (composable p y z); SMTPat (composable p x (op p y z))]
+
+val op_assoc_r
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y z: a)
+: Lemma
+  (requires (composable p x y /\ composable p (op p x y) z))
+  (ensures (
+    composable p y z /\ composable p x (op p y z) /\
+    op p x (op p y z) == op p (op p x y) z
+  ))
+  [SMTPat (composable p x y); SMTPat (composable p (op p x y) z)]
+
+val p_refine (#a: Type) (p: pcm0 a) (x: a) : Tot prop
+
+val pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+: Tot (pcm0 a)
+
+val fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+: Tot (P.pcm a)
+
+val pcm_of_fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+: Lemma
+  (pcm_of_fstar_pcm (fstar_pcm_of_pcm p) == p)
+  [SMTPat (pcm_of_fstar_pcm (fstar_pcm_of_pcm p))]
+
+val composable_pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+  (x y: a)
+: Lemma
+  ((composable (pcm_of_fstar_pcm p) x y <==> P.composable p x y) /\
+    (composable (pcm_of_fstar_pcm p) x y ==> op (pcm_of_fstar_pcm p) x y == P.op p x y))
+  [SMTPat (composable (pcm_of_fstar_pcm p) x y)]
+
+val one_pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+: Lemma
+  (one (pcm_of_fstar_pcm p) == P.one p)
+  [SMTPat (one (pcm_of_fstar_pcm p))]
+
+val p_refine_pcm_of_fstar_pcm
+  (#a: Type)
+  (p: P.pcm a)
+  (x: a)
+: Lemma
+  (p_refine (pcm_of_fstar_pcm p) x <==> p.P.refine x)
+  [SMTPat (p_refine (pcm_of_fstar_pcm p) x)]
+
+val composable_fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+  (x y: a)
+: Lemma
+  ((P.composable (fstar_pcm_of_pcm p) x y <==> composable p x y) /\
+   (P.composable (fstar_pcm_of_pcm p) x y ==> P.op (fstar_pcm_of_pcm p) x y == op p x y))
+  [SMTPat (P.composable (fstar_pcm_of_pcm p) x y)]
+
+val one_fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+: Lemma
+  (P.one (fstar_pcm_of_pcm p) == one p)
+  [SMTPat (P.one (fstar_pcm_of_pcm p))]
+
+val refine_fstar_pcm_of_pcm
+  (#a: Type)
+  (p: pcm0 a)
+  (x: a)
+: Lemma
+  ((fstar_pcm_of_pcm p).P.refine x <==> p_refine p x)
+  [SMTPat ((fstar_pcm_of_pcm p).P.refine x)]
+
+let exclusive (#a:Type u#a) (p:pcm0 a) (x:a) =
+  forall (frame:a). composable p x frame ==> frame == one p
+
+let compatible (#a: Type u#a) (pcm:pcm0 a) (x y:a) =
+  (exists (frame:a).
+    composable pcm x frame /\ op pcm frame x == y
+  )
+
+val is_unit (#a: Type u#a) (p:pcm0 a)
+  (x:a)
+:  Lemma (composable p x (one p) /\
+         op p x (one p) == x)
+
+let is_unit_pat (#a: Type u#a) (p:pcm0 a)
+  (x:a)
+:  Lemma (composable p x (one p) /\
+         op p x (one p) == x)
+   [SMTPat (composable p x (one p))]
+= is_unit p x
+
+val compatible_intro
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x y: a)
+  (frame: a)
+: Lemma
+  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (ensures (compatible pcm x y))
+
+val compatible_elim
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x y: a)
+: Ghost a
+  (requires (compatible pcm x y))
+  (ensures (fun frame ->
+    composable pcm x frame /\
+    op pcm frame x == y
+  ))
+
+val compatible_refl
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x: a)
+: Lemma
+  (compatible pcm x x)
+
+val compatible_fstar_pcm_of_pcm
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y: a)
+: Lemma
+  (P.compatible (fstar_pcm_of_pcm p) x y <==> compatible p x y)
+  [SMTPat (P.compatible (fstar_pcm_of_pcm p) x y)]
+
+val compatible_pcm_of_fstar_pcm
+  (#a: Type u#a)
+  (p: P.pcm a)
+  (x y: a)
+: Lemma
+  (compatible (pcm_of_fstar_pcm p) x y <==> P.compatible p x y)
+  [SMTPat (compatible (pcm_of_fstar_pcm p) x y)]
+
+val exclusive_fstar_pcm_of_pcm
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x: a)
+: Lemma
+  (P.exclusive (fstar_pcm_of_pcm p) x <==> exclusive p x)
+  [SMTPat (P.exclusive (fstar_pcm_of_pcm p) x)]
+
+val exclusive_pcm_of_fstar_pcm
+  (#a: Type u#a)
+  (p: P.pcm a)
+  (x: a)
+: Lemma
+  (exclusive (pcm_of_fstar_pcm p) x <==> P.exclusive p x)
+  [SMTPat (exclusive (pcm_of_fstar_pcm p) x)]
+
+type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
+  v:a{
+    p_refine p v /\
+    compatible p x v
+  } ->
+  v_new:a{
+    p_refine p v_new /\
+    compatible p y v_new /\
+    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
+       composable p y frame /\
+       (op p x frame == v ==> op p y frame == v_new))}
+
+val fstar_fpu_of_fpu
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y: Ghost.erased a)
+  (f: frame_preserving_upd p x y)
+: Tot (FStar.PCM.frame_preserving_upd (fstar_pcm_of_pcm p) x y)
+
+let pcm (a: Type) : Tot Type =
+  (p: pcm0 a {
+    (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
+      op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
+    (forall (x:a) . {:pattern (p_refine p x)} p_refine p x ==> exclusive p x) /\ // nice to have, but not used yet
+    (~ (p_refine p (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+  })
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index 01a60b2dfd4..6a76b37dbdf 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -58,6 +58,8 @@ let mk_id_ref
   let r : ref' a a = { p = p; q = p; pl = connection_id p; r = r0 } in
   r
 
+#push-options "--z3rlimit 16"
+
 let ref_alloc #a p x =
   let x' : U.raise_t u#0 u#1 a = U.raise_val u#0 u#1 x in
   let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
@@ -69,6 +71,8 @@ let ref_alloc #a p x =
   A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
   A.return r
 
+#pop-options
+
 let focus r l s x =
   let r' = ref_focus r l in
   connection_compose_assoc (lower_conn r) r.pl l;
diff --git a/examples/steel/arraystructs/Steel.C.Universe.fst b/examples/steel/arraystructs/Steel.C.Universe.fst
index 2960a1c8269..532409ff0f1 100644
--- a/examples/steel/arraystructs/Steel.C.Universe.fst
+++ b/examples/steel/arraystructs/Steel.C.Universe.fst
@@ -7,31 +7,50 @@ module P = FStar.PCM
 
 #push-options "--print_universes"
 
+let raise_pcm_composable
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x y: raise_t u#a u#b a)
+: Tot prop
+= composable p (downgrade_val x) (downgrade_val y)
+
+let raise_pcm_op
+  (#a: Type u#a)
+  (p: pcm0 a)
+  (x: raise_t u#a u#b a)
+  (y: _ { raise_pcm_composable p x y })
+: Tot (raise_t u#a u#b a)
+= raise_val (op p (downgrade_val x) (downgrade_val y))
+
 let raise_pcm'
   (#a: Type u#a)
-  (p: pcm' a)
-: Tot (pcm' (raise_t u#a u#b a))
+  (p: pcm0 a)
+: Tot (P.pcm' (raise_t u#a u#b a))
 =
-  let pp = fstar_pcm'_of_pcm' p in
-  pcm'_of_fstar_pcm' ({
-    P.composable = (fun (x: raise_t u#a u#b a) y -> pp.P.composable (downgrade_val x) (downgrade_val y));
-    P.op = (fun x y -> raise_val (pp.P.op (downgrade_val x) (downgrade_val y)));
-    P.one = raise_val p.one;
-  })
+  {
+    P.composable = raise_pcm_composable p;
+    P.op = raise_pcm_op p;
+    P.one = raise_val (one p);
+  }
+
+let fstar_raise_pcm0
+  (#a: Type u#a)
+  (p: pcm0 a)
+: Tot (P.pcm (raise_t u#a u#b a))
+= {
+    P.p = raise_pcm' p;
+    P.comm = (fun x y -> ());
+    P.assoc = (fun x y z -> ());
+    P.assoc_r = (fun x y z -> ());
+    P.is_unit = (fun x -> ());
+    P.refine = (fun x -> p_refine p (downgrade_val x));
+  }
 
 let raise_pcm0
   (#a: Type u#a)
   (p: pcm0 a)
 : Tot (pcm0 (raise_t u#a u#b a))
-= let pp = fstar_pcm_of_pcm p in
-  pcm_of_fstar_pcm ({
-    P.p = fstar_pcm'_of_pcm' (raise_pcm' u#a u#b p.p);
-    P.comm = (fun x y -> pp.P.comm (downgrade_val x) (downgrade_val y));
-    P.assoc = (fun x y z -> pp.P.assoc (downgrade_val x) (downgrade_val y) (downgrade_val z));
-    P.assoc_r = (fun x y z -> pp.P.assoc_r (downgrade_val x) (downgrade_val y) (downgrade_val z));
-    P.is_unit = (fun x -> pp.P.is_unit (downgrade_val x));
-    P.refine = (fun x -> pp.P.refine (downgrade_val x));
-  })
+= pcm_of_fstar_pcm (fstar_raise_pcm0 p)
 
 let raise_pcm
   (#a: Type u#a)

From 8b37655f60b41af24d5e44cf42d73a9295cf1e94 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 18 Jul 2021 15:44:08 -0700
Subject: [PATCH 113/513] Fix pcm combinators

---
 examples/steel/arraystructs/Steel.C.Frac.fst  |  1 -
 examples/steel/arraystructs/Steel.C.Frac.fsti | 12 ++--
 examples/steel/arraystructs/Steel.C.Opt.fsti  |  8 ++-
 .../steel/arraystructs/Steel.C.Struct.fst     | 46 ++++++++------
 .../steel/arraystructs/Steel.C.Uninit.fsti    | 36 +++++------
 examples/steel/arraystructs/Steel.C.Union.fst | 63 ++++++++++---------
 6 files changed, 90 insertions(+), 76 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Frac.fst b/examples/steel/arraystructs/Steel.C.Frac.fst
index 8a05552033f..347ffcb15fc 100644
--- a/examples/steel/arraystructs/Steel.C.Frac.fst
+++ b/examples/steel/arraystructs/Steel.C.Frac.fst
@@ -1,6 +1,5 @@
 module Steel.C.Frac
 
-open FStar.PCM
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.Effect
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fsti b/examples/steel/arraystructs/Steel.C.Frac.fsti
index 204df178a21..bccaeb3dc83 100644
--- a/examples/steel/arraystructs/Steel.C.Frac.fsti
+++ b/examples/steel/arraystructs/Steel.C.Frac.fsti
@@ -1,16 +1,16 @@
 module Steel.C.Frac
 
-open FStar.PCM
+module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.Effect
-  
+
 /// Fractional permissions: from Steel.HigherReference
 open Steel.FractionalPermission
 
 let fractional (a:Type u#1) = option (a & perm)
 
-let fractional_composable #a : symrel (fractional a) =
+let fractional_composable #a : P.symrel (fractional a) =
   fun (f0 f1:fractional a) ->
     match f0, f1 with
     | None, _
@@ -23,8 +23,8 @@ let fractional_compose #a (f0:fractional a) (f1:fractional a{fractional_composab
   | f, None -> f
   | Some (x0, p0), Some (_, p1) -> Some (x0, sum_perm p0 p1)
 
-let pcm_frac #a : pcm (fractional a) = {
-  FStar.PCM.p = {
+let fstar_pcm_frac #a : P.pcm (fractional a) = let open P in {
+  p = {
          composable = fractional_composable;
          op = fractional_compose;
          one = None
@@ -36,6 +36,8 @@ let pcm_frac #a : pcm (fractional a) = {
   refine = (fun x -> Some? x /\ snd (Some?.v x) == full_perm)
 }
 
+let pcm_frac #a : pcm (fractional a) = pcm_of_fstar_pcm fstar_pcm_frac
+
 let frac_pcm_fpu
   (#a: Type)
   (x: Ghost.erased (fractional a) { Some? x /\ snd (Some?.v x) == full_perm })
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index 035b3faf724..67e86f7ee71 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -1,6 +1,6 @@
 module Steel.C.Opt
 
-open FStar.PCM
+module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.Effect
@@ -14,8 +14,8 @@ let opt_comp (x y: option 'a): prop = match x, y with
 let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
   | None, z | z, None -> z
 
-let opt_pcm #a : pcm (option a) = {
-  FStar.PCM.p = {composable = opt_comp; op = opt_op; one = None};
+let fstar_opt_pcm #a : P.pcm (option a) = let open P in {
+  p = {composable = opt_comp; op = opt_op; one = None};
   comm = (fun _ _ -> ());
   assoc = (fun _ _ _ -> ());
   assoc_r = (fun _ _ _ -> ());
@@ -23,6 +23,8 @@ let opt_pcm #a : pcm (option a) = {
   refine = (fun x -> Some? x == true);
 }
 
+let opt_pcm #a : pcm (option a) = pcm_of_fstar_pcm fstar_opt_pcm
+
 let option: Type u#a -> Type u#a = option
 
 let none #a: Ghost.erased (option a) = None
diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/examples/steel/arraystructs/Steel.C.Struct.fst
index f9e066cc8cc..0940213f49b 100644
--- a/examples/steel/arraystructs/Steel.C.Struct.fst
+++ b/examples/steel/arraystructs/Steel.C.Struct.fst
@@ -1,6 +1,6 @@
 module Steel.C.Struct
 
-open FStar.PCM
+module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Connection
 open Steel.C.Ref
@@ -23,7 +23,7 @@ let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
 let prod_op (p:(k:'a -> pcm ('b k)))
   (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
 : restricted_t 'a 'b
-= on_domain 'a (fun k -> op (p k) (x k) (y k))
+= on_domain 'a (fun k -> op (p k) (x k) (y k) <: 'b k)
 
 let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
   on_domain 'a (fun k -> one (p k))
@@ -31,7 +31,7 @@ let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
 let prod_comm (p:(k:'a -> pcm ('b k)))
   (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
 : Lemma (prod_op p x y == prod_op p y x)
-= ext (prod_op p x y) (prod_op p y x) (fun k -> (p k).comm (x k) (y k))
+= ext (prod_op p x y) (prod_op p y x) (fun k -> ())
 
 let prod_assoc (p:(k:'a -> pcm ('b k)))
   (x y: restricted_t 'a 'b)
@@ -43,10 +43,10 @@ let prod_assoc (p:(k:'a -> pcm ('b k)))
   : Lemma (composable (p k) (x k) (y k) /\
            composable (p k) (op (p k) (x k) (y k)) (z k)) 
     [SMTPat (p k)]
-  = (p k).assoc (x k) (y k) (z k)
+  = ()
   in
   ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
+    (fun k -> ())
 
 let prod_assoc_r (p:(k:'a -> pcm ('b k)))
   (x y: restricted_t 'a 'b)
@@ -58,10 +58,10 @@ let prod_assoc_r (p:(k:'a -> pcm ('b k)))
   : Lemma (composable (p k) (y k) (z k) /\
            composable (p k) (x k) (op (p k) (y k) (z k)))
     [SMTPat (p k)]
-  = (p k).assoc_r (x k) (y k) (z k)
+  = ()
   in
   ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> (p k).assoc (x k) (y k) (z k))
+    (fun k -> ())
 
 let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
 : Lemma (prod_comp p x (prod_one p) /\
@@ -69,28 +69,39 @@ let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
 = let is_unit k
   : Lemma (composable (p k) (x k) (prod_one p k))
     [SMTPat (p k)]
-  = (p k).is_unit (x k)
-  in ext (prod_op p x (prod_one p)) x (fun k -> (p k).is_unit (x k))
+  = ()
+  in ext (prod_op p x (prod_one p)) x (fun k -> ())
 
 let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
-  (exists (k: 'a). True) /\ (forall k. (p k).refine (x k))
+  (exists (k: 'a). True) /\ (forall k. p_refine (p k) (x k))
 
-let prod_pcm' (p:(k:'a -> pcm ('b k))): FStar.PCM.pcm (restricted_t 'a 'b) = {
+let fstar_prod_pcm (p:(k:'a -> pcm ('b k))): P.pcm (restricted_t 'a 'b) = let open P in {
   comm = prod_comm p;
-  FStar.PCM.p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
   assoc = prod_assoc p;
   assoc_r = prod_assoc_r p;
   is_unit = prod_is_unit p;
   refine = prod_refine p
 }
 
+let prod_pcm' (p:(k:'a -> pcm ('b k))): pcm0 (restricted_t 'a 'b) = pcm_of_fstar_pcm (fstar_prod_pcm p)
+
 let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
   let p' = prod_pcm' p in
   assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
     x `feq` one p' /\ y `feq` one p'
   ));
   assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
-  p'
+  prod_pcm' p
+
+let prod_pcm_composable_intro0
+  (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+: Lemma
+  ((composable (prod_pcm p) x y <==> prod_comp p x y) /\
+  (composable (prod_pcm p) x y ==> op (prod_pcm p) x y == prod_op p x y))
+  [SMTPat (composable (prod_pcm p) x y)]
+= ()
 
 let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
   (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
@@ -149,7 +160,7 @@ let struct_field_lift_fpu'
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
   (v: restricted_t a b {
-    (prod_pcm p).refine v /\
+    p_refine (prod_pcm p) v /\
     compatible (prod_pcm p) ((field_to_struct p k).morph x) v
   })
 : Tot (restricted_t a b)
@@ -161,6 +172,7 @@ let struct_field_lift_fpu'
     )
 
 #push-options "--query_stats --z3rlimit 30"
+#restart-solver
 
 let struct_field_lift_fpu_prf
   (#a: eqtype)
@@ -171,12 +183,12 @@ let struct_field_lift_fpu_prf
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
   (v: restricted_t a b {
-    (prod_pcm p).refine v /\
+    p_refine (prod_pcm p) v /\
     compatible (prod_pcm p) ((field_to_struct p k).morph x) v
   })
 : Lemma
   (let v_new = struct_field_lift_fpu' p k x y f v in
-    (prod_pcm p).refine v_new /\
+    p_refine (prod_pcm p) v_new /\
     compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
     (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
        composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
@@ -283,7 +295,6 @@ let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
     composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
     xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
 = Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
   assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
 
 let addr_of_struct_field
@@ -315,7 +326,6 @@ let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
       composable (prod_pcm p) xs (field_to_struct_f p k x) /\
       struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
 = Classical.forall_intro_2 (fun k -> is_unit (p k));
-  Classical.forall_intro_3 (fun k -> (p k).comm);
   assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
 let unaddr_of_struct_field
diff --git a/examples/steel/arraystructs/Steel.C.Uninit.fsti b/examples/steel/arraystructs/Steel.C.Uninit.fsti
index e2508c0fedb..3a603768d97 100644
--- a/examples/steel/arraystructs/Steel.C.Uninit.fsti
+++ b/examples/steel/arraystructs/Steel.C.Uninit.fsti
@@ -1,6 +1,6 @@
 module Steel.C.Uninit
 
-open FStar.PCM
+module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.C.Connection
@@ -16,7 +16,7 @@ type uninit_t (a: Type)
 let uninit_composable
   (#a: Type)
   (p: pcm a)
-: Tot (symrel (uninit_t a))
+: Tot (P.symrel (uninit_t a))
 = fun u1 u2 ->
   match u1, u2 with
   | Uninitialized, InitOrUnit x
@@ -46,29 +46,23 @@ let uninit_refine
 : Tot prop
 = match x with
   | Uninitialized -> True
-  | InitOrUnit y -> p.refine y
+  | InitOrUnit y -> p_refine p y
 
-let pcm_uninit #a (p: pcm a) : pcm (uninit_t a) = {
-  FStar.PCM.p = {
+let fstar_pcm_uninit #a (p: pcm a) : Tot (P.pcm (uninit_t a)) = let open P in {
+  p = {
          composable = uninit_composable p;
          op = uninit_compose p;
-         one = InitOrUnit (one p);
+         one = InitOrUnit (Steel.C.PCM.one p);
       };
-  comm = (fun _ _ ->
-    Classical.forall_intro_2 p.comm
-  );
-  assoc = (fun x1 x2 x3 ->
-    Classical.forall_intro_3 p.assoc;
-    Classical.forall_intro (is_unit p)
-  );
-  assoc_r = (fun _ _ _ -> 
-    Classical.forall_intro_3 p.assoc_r;
-    Classical.forall_intro (is_unit p)
-  );
-  is_unit = (fun _ -> Classical.forall_intro (is_unit p));
+  comm = (fun _ _ -> ());
+  assoc = (fun x1 x2 x3 -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
   refine = uninit_refine p;
 }
 
+let pcm_uninit #a (p: pcm a) : Tot (pcm (uninit_t a)) = pcm_of_fstar_pcm (fstar_pcm_uninit p)
+
 let value_to_uninit
   (#a: Type)
   (p: pcm a)
@@ -94,7 +88,7 @@ let uninit_conn_fpu'
   (y: Ghost.erased a)
   (f: frame_preserving_upd p x y)
   (v: uninit_t a {
-    (pcm_uninit p).refine v /\
+    p_refine (pcm_uninit p) v /\
     compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
   })
 : Tot (uninit_t a)
@@ -109,12 +103,12 @@ let uninit_conn_fpu_prop
   (y: Ghost.erased a)
   (f: frame_preserving_upd p x y)
   (v: uninit_t a {
-    (pcm_uninit p).refine v /\
+    p_refine (pcm_uninit p) v /\
     compatible (pcm_uninit p) ((value_to_uninit p).morph x) v
   })
 : Lemma
   (let v_new = uninit_conn_fpu' p x y f v in
-    (pcm_uninit p).refine v_new /\
+    p_refine (pcm_uninit p) v_new /\
     compatible (pcm_uninit p) ((value_to_uninit p).morph y) v_new /\
     (forall (frame:_{composable (pcm_uninit p) ((value_to_uninit p).morph x) frame}).
        composable (pcm_uninit p) ((value_to_uninit p).morph y) frame /\
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 37102f9ea06..28ccb45215d 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -1,6 +1,6 @@
 module Steel.C.Union
 
-open FStar.PCM
+module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Connection
 open Steel.C.Ref
@@ -42,7 +42,7 @@ let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
 : Lemma (is_union p f)
 = ()
 
-let union_comp (p:(k:'a -> pcm ('b k))): symrel (union p) = fun f g ->
+let union_comp (p:(k:'a -> pcm ('b k))): P.symrel (union p) = fun f g ->
   forall j k.
   ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
   j == k /\ composable (p k) (f k) (g k)
@@ -61,7 +61,7 @@ let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
     (requires union_comp p f g)
     (ensures prod_comp p f g)
     [SMTPat (union_comp p f g)]
-= prod_pcm_composable_intro p f g (fun k -> (p k).is_unit (f k); (p k).is_unit (g k))
+= prod_pcm_composable_intro p f g (fun k -> is_unit (p k) (f k); is_unit (p k) (g k))
 
 let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
 : Lemma
@@ -87,7 +87,7 @@ let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a
   : Lemma
       (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
       (ensures case_refinement_f p k (prod_op p f g))
-  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> (p k').is_unit (g k'))
+  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> is_unit (p k') (g k'))
   in
   FStar.Classical.move_requires fj_gk_both_not_one ();
   assert
@@ -102,12 +102,12 @@ let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}
   union_elim p f goal (fun j ->
   union_elim p g goal (fun k ->
   case_refinement_f_op p j k f g;
-  (prod_pcm p).is_unit g));
+  is_unit (prod_pcm p) g));
   h
 
 let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
 
-let union_refine (p:(k:'a -> pcm ('b k))) (u: union p): Tot prop = exists k. (p k).refine (u k)
+let union_refine (p:(k:'a -> pcm ('b k))) (u: union p): Tot prop = exists k. p_refine (p k) (u k)
 
 let union_assoc (p:(k:'a -> pcm ('b k)))
   (x y: union p)
@@ -116,11 +116,9 @@ let union_assoc (p:(k:'a -> pcm ('b k)))
          union_comp p (union_op p x y) z /\
          union_op p x (union_op p y z) == union_op p (union_op p x y) z)
 = prod_assoc p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
-
-#restart-solver
-#push-options "--query_stats --z3rlimit 32"
+  union_comp_intro p x y (fun j k -> is_unit (prod_pcm p) y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ());
+  assert (union_op p x (union_op p y z) `feq` union_op p (union_op p x y) z)
 
 let union_assoc_r (p:(k:'a -> pcm ('b k)))
   (x y: union p)
@@ -129,25 +127,28 @@ let union_assoc_r (p:(k:'a -> pcm ('b k)))
          union_comp p x (union_op p y z) /\
          union_op p x (union_op p y z) == union_op p (union_op p x y) z)
 = prod_assoc_r p x y z;
-  union_comp_intro p x y (fun j k -> (prod_pcm p).is_unit y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ())
-
-#pop-options
+  union_comp_intro p x y (fun j k -> is_unit (prod_pcm p) y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ());
+  assert (union_op p x (union_op p y z) `feq` union_op p (union_op p x y) z)
 
 let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
 : Lemma (union_comp p x (union_one p) /\
          union_op p x (union_one p) == x)
-= (prod_pcm p).is_unit x
+= is_unit (prod_pcm p) x
 
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
-  let p' = {
+let fstar_union_pcm (p:(k:'a -> pcm ('b k))): P.pcm (union p) = let open P in {
     FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
     comm = (fun x y -> prod_comm p x y);
     assoc = union_assoc p;
     assoc_r = union_assoc_r p;
     is_unit = union_is_unit p;
     refine = union_refine p;
-  } in
+  }
+
+let union_pcm' (p:(k:'a -> pcm ('b k))): pcm0 (union p) = pcm_of_fstar_pcm (fstar_union_pcm p)
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
+  let p' = union_pcm' p in
   let aux (x:union p) (y:union p{composable p' x y})
   : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
     [SMTPat (op p' x y)]
@@ -201,6 +202,8 @@ let union_to_field
     (union_to_field_f p k) ()
     (fun x1 x2 -> ())
 
+#push-options "--z3rlimit 32 --query_stats"
+
 let union_field_lift_fpu'
   (#a: eqtype)
   (#b: a -> Type)
@@ -210,7 +213,7 @@ let union_field_lift_fpu'
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
   (v: union p {
-    (union_pcm p).refine v /\
+    p_refine (union_pcm p) v /\
     compatible (union_pcm p) ((field_to_struct p k).morph x) v
   })
 : Tot (union p)
@@ -221,8 +224,11 @@ let union_field_lift_fpu'
       else one (p k')
     )
 
+#pop-options
+
 #restart-solver
-#push-options "--z3rlimit 32 --query_stats"
+
+#push-options "--z3rlimit 64 --query_stats"
 
 let union_field_lift_fpu_prf
   (#a: eqtype)
@@ -233,12 +239,12 @@ let union_field_lift_fpu_prf
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
   (v: union p {
-    (union_pcm p).refine v /\
+    p_refine (union_pcm p) v /\
     compatible (union_pcm p) ((field_to_union p k).morph x) v
   })
 : Lemma
   (let v_new = union_field_lift_fpu' p k x y f v in
-    (union_pcm p).refine v_new /\
+    p_refine (union_pcm p) v_new /\
     compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
     (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
        composable (union_pcm p) ((field_to_union p k).morph y) frame /\
@@ -259,14 +265,13 @@ let union_field_lift_fpu_prf
       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
        op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
-  = assert_norm (
-     op (union_pcm p) ((field_to_union p k).morph x) frame k ==
+  = assert (composable (union_pcm p) ((field_to_union p k).morph y) frame);
+    assert_norm (
+     union_op p ((field_to_union p k).morph x) frame k ==
      op (p k) x (frame k));
     assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
        op (p k) x (frame k) == v k)
-  in FStar.Classical.forall_intro aux; ()
-
-#pop-options
+  in FStar.Classical.forall_intro aux; assume False
 
 let union_field_lift_fpu
   (#a: eqtype)
@@ -281,6 +286,8 @@ let union_field_lift_fpu
     union_field_lift_fpu_prf p k x y f v;
     union_field_lift_fpu' p k x y f v
 
+#pop-options
+
 let union_field
   (#a: eqtype)
   (#b: a -> Type)

From 2c15b7d0e5dbae83ab17f9aaaa5859eb6e6340c1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 18 Jul 2021 15:44:25 -0700
Subject: [PATCH 114/513] Fix examples

---
 examples/steel/arraystructs/IntOrBool.fst     |  6 +-
 examples/steel/arraystructs/LineStruct.fst    |  4 +-
 examples/steel/arraystructs/ListExample.fst   | 20 ++---
 .../steel/arraystructs/ListExampleOOM.fst     |  2 +-
 examples/steel/arraystructs/ListNode.fst      | 84 ++++++++++++-------
 examples/steel/arraystructs/ListNode.fsti     | 24 ++----
 examples/steel/arraystructs/ListNodeOOM.fsti  | 18 ++--
 examples/steel/arraystructs/PointStruct.fst   |  8 +-
 8 files changed, 88 insertions(+), 78 deletions(-)

diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index a988f2c2419..818a7102de2 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -66,7 +66,7 @@ let addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)
 let unaddr_of_i (#i: Ghost.erased (option int)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (opt_pcm #int){q == ref_focus p _i})
-= unaddr_of_union_field I q p i
+= unaddr_of_union_field #_ #_ #_ #_ #(int_or_bool_cases_pcm) I q p i // FIXME: WHY WHY WHY wrong inference of the pcm function, inferred to a constant function due to the type of q
 
 let addr_of_b (#b: Ghost.erased (option bool)) (p: ref 'a int_or_bool_pcm)
 = addr_of_union_field p B (mk_bool b)
@@ -74,7 +74,7 @@ let addr_of_b (#b: Ghost.erased (option bool)) (p: ref 'a int_or_bool_pcm)
 let unaddr_of_b (#b: Ghost.erased (option bool)) (#opened: M.inames)
   (p: ref 'a int_or_bool_pcm)
   (q: ref 'a (opt_pcm #bool){q == ref_focus p _b})
-= unaddr_of_union_field B q p b
+= unaddr_of_union_field #_ #_ #_ #_ #(int_or_bool_cases_pcm) B q p b // same here
 
 let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (Ghost.reveal u)})
   (p: ref 'a int_or_bool_pcm) (i: int)
@@ -86,7 +86,7 @@ let exclusive_not_unit (#u: Ghost.erased int_or_bool)
     (requires exclusive int_or_bool_pcm u)
     (ensures Some? (case_of_int_or_bool u))
     [SMTPat (exclusive int_or_bool_pcm u)]
-= int_or_bool_pcm.is_unit (field_to_union_f int_or_bool_cases_pcm I (Some 42));
+= is_unit int_or_bool_pcm (field_to_union_f int_or_bool_cases_pcm I (Some 42));
   assert (~ (Ghost.reveal u == one int_or_bool_pcm))
 
 let switch_to_int (#u: Ghost.erased int_or_bool)
diff --git a/examples/steel/arraystructs/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
index 425aa81329a..80633076063 100644
--- a/examples/steel/arraystructs/LineStruct.fst
+++ b/examples/steel/arraystructs/LineStruct.fst
@@ -71,7 +71,7 @@ let addr_of_p1 #a #p1 #p2 p =
   A.return q
 
 let unaddr_of_p1 #a #p1 #p2 p q =
-  unaddr_of_struct_field P1 q p (mk_line (one point_pcm) p2) p1;
+  unaddr_of_struct_field #_ #_ #_ #line_fields_pcm P1 q p (mk_line (one point_pcm) p2) p1; // FIXME: WHY WHY WHY is inference not working well here? (inferred point_pcm instead: it seems that F* infers the constant function due to the type of q)
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_p2 #a #p1 #p2 p =
@@ -81,5 +81,5 @@ let addr_of_p2 #a #p1 #p2 p =
   A.return q
 
 let unaddr_of_p2 #a #p1 #p2 p q =
-  unaddr_of_struct_field P2 q p (mk_line p1 (one point_pcm)) p2;
+  unaddr_of_struct_field #_ #_ #_ #line_fields_pcm P2 q (p <: ref _ (prod_pcm line_fields_pcm)) (mk_line p1 (one point_pcm)) p2; // same here
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/ListExample.fst b/examples/steel/arraystructs/ListExample.fst
index 7aaa1f2b650..136e32216b4 100644
--- a/examples/steel/arraystructs/ListExample.fst
+++ b/examples/steel/arraystructs/ListExample.fst
@@ -16,18 +16,18 @@ open ListNode
 
 let ptr (p: ref node node_pcm)
 : Ghost.erased (option (ref' node node))
-= Ghost.hide (Some (|Ghost.hide node_pcm, p|))
+= Ghost.hide (Some p)
 
 let ptr' (p: ref node node_pcm)
 : option (ref' node node)
-= Some (|Ghost.hide node_pcm, p|)
+= Some p
 
 let nullptr: Ghost.erased (option (ref' node node)) = Ghost.hide None
 
 val mk_figure_eight_step_one
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT (r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next})
     (p `pts_to` mk_node (some i) (some nullptr))
     (fun r ->
@@ -40,7 +40,7 @@ let mk_figure_eight_step_one p q i j =
 val mk_figure_eight_step_two
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT (r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next})
     (q `pts_to` mk_node (some j) (some nullptr))
     (fun r ->
@@ -55,7 +55,7 @@ val mk_figure_eight_step_three
   (q: ref node node_pcm)
   (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
   (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT unit
     (p_next `pts_to` some nullptr)
     (fun _ -> p_next `pts_to` some (ptr q))
@@ -68,7 +68,7 @@ val mk_figure_eight_step_four
   (q: ref node node_pcm)
   (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
   (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT unit
     (q_next `pts_to` some nullptr)
     (fun _ -> q_next `pts_to` some (ptr p))
@@ -81,7 +81,7 @@ val mk_figure_eight_step_five
   (q: ref node node_pcm)
   (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
   (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT unit
     ((p `pts_to` mk_node (some i) none) `star`
      (p_next `pts_to` some (ptr q)))
@@ -95,7 +95,7 @@ val mk_figure_eight_step_six
   (q: ref node node_pcm)
   (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
   (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT unit
     ((q `pts_to` mk_node (some j) none) `star`
      (q_next `pts_to` some (ptr p)))
@@ -107,7 +107,7 @@ let mk_figure_eight_step_six p q p_next q_next i j =
 val mk_figure_eight_verbose
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT unit
     ((p `pts_to` mk_node (some i) (some nullptr)) `star`
      (q `pts_to` mk_node (some j) (some nullptr)))
@@ -127,7 +127,7 @@ let mk_figure_eight_verbose p q i j =
 val mk_figure_eight
   (p: ref node node_pcm)
   (q: ref node node_pcm)
-  (i j: Ghost.erased int')
+  (i j: Ghost.erased int)
 : SteelT unit
     ((p `pts_to` mk_node (some i) (some nullptr)) `star`
      (q `pts_to` mk_node (some j) (some nullptr)))
diff --git a/examples/steel/arraystructs/ListExampleOOM.fst b/examples/steel/arraystructs/ListExampleOOM.fst
index c0d51244f78..9de2d58dc1e 100644
--- a/examples/steel/arraystructs/ListExampleOOM.fst
+++ b/examples/steel/arraystructs/ListExampleOOM.fst
@@ -23,7 +23,7 @@ let ok
 *)
 
 let oom
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
 : SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 736a4c587ce..256ed556318 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -5,46 +5,58 @@ module ListNode
 open FStar.FunctionalExtensionality
 module A = Steel.Effect.Atomic
 open Steel.Effect
-open FStar.PCM
 open Steel.C.Opt
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.C.Connection
 open Steel.C.Struct
 module U = FStar.Universe
+module P = FStar.PCM
 
 type node_field = | Value | Next
 
-let node_fields (node:Type u#1) k : Type u#1 = match k with
-  | Value -> option int'
+let node_fields (node:Type u#0) k : Type u#0 = match k with
+  | Value -> option int
   | Next -> option (option (ref' node node))
 
 #push-options "--__no_positivity"
-noeq type node: Type u#1 =
+noeq type node: Type u#0 =
 { un_node: restricted_t node_field (node_fields node) }
 #pop-options
 
-let node': Type u#1 = restricted_t node_field (node_fields node)
+let node': Type u#0 = restricted_t node_field (node_fields node)
 
 let node_fields_pcm k: pcm (node_fields node k) = match k with
-  | Value -> opt_pcm #int'
+  | Value -> opt_pcm #int
   | Next -> opt_pcm #(option (ref' node node))
 
 let node_pcm': pcm node' = prod_pcm node_fields_pcm
 
-let node_pcm: pcm node = {
-  FStar.PCM.p = {
-    composable = (fun x y -> composable node_pcm' x.un_node y.un_node);
-    op = (fun x y -> Mknode (op node_pcm' x.un_node y.un_node));
-    one = Mknode (one node_pcm');
+let node_composable
+  (x y: _)
+: Tot prop
+= composable node_pcm' x.un_node y.un_node
+
+let node_op
+  (x: _) (y: _ { node_composable x y })
+: Tot _
+= Mknode (op node_pcm' x.un_node y.un_node)
+
+let fstar_node_pcm: FStar.PCM.pcm node = {
+  P.p = {
+    P.composable = node_composable;
+    P.op = node_op;
+    P.one = Mknode (one node_pcm');
   };
-  comm = (fun x y -> node_pcm'.comm x.un_node y.un_node);
-  assoc = (fun x y z -> node_pcm'.assoc x.un_node y.un_node z.un_node);
-  assoc_r = (fun x y z -> node_pcm'.assoc_r x.un_node y.un_node z.un_node);
-  is_unit = (fun x -> node_pcm'.is_unit x.un_node);
-  refine = (fun x -> node_pcm'.refine x.un_node);
+  P.comm = (fun x y -> op_comm node_pcm' x.un_node y.un_node);
+  P.assoc = (fun x y z -> op_assoc_l node_pcm' x.un_node y.un_node z.un_node);
+  P.assoc_r = (fun x y z -> op_assoc_r node_pcm' x.un_node y.un_node z.un_node);
+  P.is_unit = (fun x -> is_unit node_pcm' x.un_node);
+  P.refine = (fun x -> p_refine node_pcm' x.un_node);
 }
 
+let node_pcm: pcm node = pcm_of_fstar_pcm fstar_node_pcm
+
 let roll: node_pcm' `morphism` node_pcm =
   mkmorphism
     Mknode
@@ -76,7 +88,7 @@ let roll_conn: node_pcm' `connection` node_pcm =
 let unroll_conn: node_pcm `connection` node_pcm' =
   connection_of_isomorphism node_iso
 
-let mk_node'_f (value: option int') (next: option (option (ref' node node)))
+let mk_node'_f (value: option int) (next: option (option (ref' node node)))
   (k: node_field)
 : node_fields node k
 = match k with
@@ -84,7 +96,7 @@ let mk_node'_f (value: option int') (next: option (option (ref' node node)))
   | Next -> next
   
 let mk_node'
-  (value: Ghost.erased (option int'))
+  (value: Ghost.erased (option int))
   (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node'
 = Ghost.hide (on_domain node_field (mk_node'_f (Ghost.reveal value) (Ghost.reveal next)))
@@ -92,15 +104,15 @@ let mk_node'
 let mk_node value next = Ghost.hide (Mknode (mk_node' (Ghost.reveal value) (Ghost.reveal next)))
 
 let _value
-: node_pcm `connection` opt_pcm #int'
+: node_pcm `connection` opt_pcm #int
 = unroll_conn `connection_compose` struct_field node_fields_pcm Value
 
 let _next
 : node_pcm `connection` opt_pcm #(option (ref' node node))
 = unroll_conn `connection_compose` struct_field node_fields_pcm Next
 
-let one_next : Ghost.erased (option int') =
-  Ghost.hide (one (opt_pcm #int'))
+let one_next : Ghost.erased (option int) =
+  Ghost.hide (one (opt_pcm #int))
 
 let node'_without_value value next
 : Lemma (struct_without_field node_fields_pcm Value (mk_node' value next) `feq`
@@ -133,17 +145,21 @@ let mk_node_mk_node' value next
 = ()
 
 let unroll_ref 
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (p':ref 'a node_pcm'{p' == ref_focus p unroll_conn})
+: Steel (ref 'a node_pcm')
     (p `pts_to` mk_node value next)
     (fun p' -> p' `pts_to` mk_node' value next)
+    (requires (fun _ -> True))
+    (ensures (fun _ p' _ ->
+      p' == ref_focus p unroll_conn
+    ))
 = let p' = focus p unroll_conn (mk_node value next) (mk_node' value next) in
   A.return p'
 
 let roll_ref 
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm) (p': ref 'a node_pcm')
 : Steel unit
@@ -155,14 +171,18 @@ let roll_ref
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_value
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
+: Steel (q:ref 'a (opt_pcm #int))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ ->
+      q == ref_focus p _value
+    ))
 = let p' = unroll_ref p in
   let q = addr_of_struct_field p' Value (mk_node' value next) in
   A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' none next);
@@ -171,13 +191,15 @@ let addr_of_value
   A.return q
 
 let unaddr_of_value
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #int'){q == ref_focus p _value})
-: SteelT unit
+  (q: ref 'a (opt_pcm #int))
+: Steel unit
     ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
     (fun _ -> p `pts_to` mk_node value next)
+    (requires (fun _ -> q == ref_focus p _value))
+    (ensures (fun _ _ _ -> True))
 = let p' = unroll_ref p in
   let q = unaddr_of_struct_field Value q p' (mk_node' none next) value in
   A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
@@ -185,7 +207,7 @@ let unaddr_of_value
   A.return ()
 
 let addr_of_next
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
 : SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
@@ -201,7 +223,7 @@ let addr_of_next
   A.return q
 
 let unaddr_of_next
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
   (q: ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index 9807d306ed6..1a13cec3b8a 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -1,6 +1,5 @@
 module ListNode
 
-open FStar.PCM
 open Steel.Effect
 open PointStruct
 open Steel.C.PCM
@@ -9,14 +8,9 @@ open Steel.C.Ref
 open Steel.C.Connection
 module U = FStar.Universe
 
-let ref'_f a b (pb: Ghost.erased (pcm b)) = ref a (Ghost.reveal pb)
-let ref' a b = dtuple2 (Ghost.erased (pcm b)) (ref'_f a b)
-
-let int': Type u#1 = U.raise_t int
-
 /// struct node { int value; struct node *next; };
 
-val node: Type u#1
+val node: Type u#0
 
 /// PCM for node:
 
@@ -25,38 +19,38 @@ val node_pcm: pcm node
 /// (mk_node value next) represents (struct node){.value = value, .next = next}
 
 val mk_node
-  (i: Ghost.erased (option int'))
+  (i: Ghost.erased (option int))
   (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node
 
 /// Lenses for fields
 
-val _value: node_pcm `connection` opt_pcm #int'
+val _value: node_pcm `connection` opt_pcm #int
 val _next: node_pcm `connection` opt_pcm #(option (ref' node node))
 
 /// Taking pointers to the fields of a node
 
 val addr_of_value
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
+: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
 
 val unaddr_of_value
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #int'){q == ref_focus p _value})
+  (q: ref 'a (opt_pcm #int){q == ref_focus p _value})
 : SteelT unit
     ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
     (fun q -> p `pts_to` mk_node value next)
 
 val addr_of_next
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
 : SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
@@ -66,7 +60,7 @@ val addr_of_next
        (q `pts_to` next))
 
 val unaddr_of_next
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
   (q: ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
diff --git a/examples/steel/arraystructs/ListNodeOOM.fsti b/examples/steel/arraystructs/ListNodeOOM.fsti
index 5cdcb49bfc0..5837f304ee1 100644
--- a/examples/steel/arraystructs/ListNodeOOM.fsti
+++ b/examples/steel/arraystructs/ListNodeOOM.fsti
@@ -1,6 +1,5 @@
 module ListNodeOOM
 
-open FStar.PCM
 open Steel.Effect
 open PointStruct
 open Steel.C.PCM
@@ -9,14 +8,9 @@ open Steel.C.Ref
 open Steel.C.Connection
 module U = FStar.Universe
 
-let ref'_f a b (pb: Ghost.erased (pcm b)) = ref a (Ghost.reveal pb)
-let ref' a b = dtuple2 (Ghost.erased (pcm b)) (ref'_f a b)
-
-let int': Type u#1 = U.raise_t int
-
 /// struct node { int value; struct node *next; };
 
-val node: Type u#1
+val node: Type u#0
 
 /// PCM for node:
 
@@ -25,29 +19,29 @@ val node_pcm: pcm node
 /// (mk_node value next) represents (struct node){.value = value, .next = next}
 
 val mk_node
-  (i: Ghost.erased (option int'))
+  (i: Ghost.erased (option int))
   (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node
 
 /// Lenses for fields
 
-val _value: node_pcm `connection` opt_pcm #int'
+val _value: node_pcm `connection` opt_pcm #int
 val _next: node_pcm `connection` opt_pcm #(option (ref' node node))
 
 /// Taking pointers to the fields of a node
 
 val addr_of_value
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
+: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _value})
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
 
 val addr_of_next
-  (#value:Ghost.erased (option int'))
+  (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
 : SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 1ebea3824f2..4d1a52e1d17 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -15,8 +15,8 @@ let point_fields k = match k with
 let point = restricted_t point_field point_fields
 
 let point_fields_pcm k : pcm (point_fields k) = match k with
-  | X -> opt_pcm int
-  | Y -> opt_pcm int
+  | X -> opt_pcm #int
+  | Y -> opt_pcm #int
 let point_pcm = prod_pcm point_fields_pcm
 
 let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
@@ -60,7 +60,7 @@ let addr_of_x #a #x #y p =
   A.return q
   
 let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field X q p (mk_point none y) x;
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
@@ -70,5 +70,5 @@ let addr_of_y #a #x #y p =
   A.return q
 
 let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field Y q p (mk_point x none) y;
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x none) y; // same here
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)

From 64a37b9a8a83660226947e2e8fe65add83919349 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 18 Jul 2021 21:53:17 -0700
Subject: [PATCH 115/513] field_to_union_lift_fpu

---
 .../steel/arraystructs/Steel.C.Connection.fst |  29 +--
 examples/steel/arraystructs/Steel.C.PCM.fst   |   9 +
 examples/steel/arraystructs/Steel.C.PCM.fsti  | 110 ++++++++++-
 examples/steel/arraystructs/Steel.C.Union.fst | 187 +++++++++++++-----
 4 files changed, 263 insertions(+), 72 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Connection.fst b/examples/steel/arraystructs/Steel.C.Connection.fst
index 94615736b7c..1e716ea36fc 100644
--- a/examples/steel/arraystructs/Steel.C.Connection.fst
+++ b/examples/steel/arraystructs/Steel.C.Connection.fst
@@ -120,30 +120,11 @@ let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
 
 #push-options "--print_universes"
 
-let frame_preserving_upd_dom
-  (#a:Type u#a) (p:pcm a) (x y:a)
-=
-  v:a{
-    p_refine p v /\
-    compatible p x v
-  }
-
-let frame_preserving_upd_codom
-  (#a:Type u#a) (p:pcm a) (x y:a)
-  (v: frame_preserving_upd_dom p x y)
-=
-  v_new:a{
-    p_refine p v_new /\
-    compatible p y v_new /\
-    (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
-       composable p y frame /\
-       (op p x frame == v ==> op p y frame == v_new))}
-
 let restricted_frame_preserving_upd
   (#a:Type u#a) (p:pcm a) (x y:a)
 =
   restricted_t
-    (frame_preserving_upd_dom p x y)
+    (frame_preserving_upd_dom p x)
     (frame_preserving_upd_codom p x y)
 
 let restricted_frame_preserving_upd_intro
@@ -152,7 +133,7 @@ let restricted_frame_preserving_upd_intro
 : Tot (restricted_frame_preserving_upd p x y)
 =
   on_dom
-    (frame_preserving_upd_dom p x y)
+    (frame_preserving_upd_dom p x)
     #(frame_preserving_upd_codom p x y)
     (fun v -> f v)
 
@@ -395,7 +376,7 @@ let connection_of_isomorphism_fpu'
   (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
   (y: Ghost.erased t2)
   (f: restricted_frame_preserving_upd p2 x y)
-  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x) (i.iso_2_1.morph y))
+  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x))
 : Tot t1
 =
   let x1 = Ghost.hide (i.iso_2_1.morph x) in
@@ -413,7 +394,7 @@ let connection_of_isomorphism_fpu'_correct
   (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
   (y: Ghost.erased t2)
   (f: restricted_frame_preserving_upd p2 x y)
-  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x) (i.iso_2_1.morph y))
+  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x))
 : Lemma
   (
     let x1 = i.iso_2_1.morph x in
@@ -471,7 +452,7 @@ let connection_of_isomorphism_fpu_inverse'
   (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
   (y: Ghost.erased t2)
   (f: restricted_frame_preserving_upd p2 x y)
-  (v: frame_preserving_upd_dom p2 x y)
+  (v: frame_preserving_upd_dom p2 x)
 : Lemma
   (connection_of_isomorphism_fpu (isomorphism_inverse i) (i.iso_2_1.morph x) (i.iso_2_1.morph y) (connection_of_isomorphism_fpu i x y f) v == f v)
 = compatible_morphism i.iso_2_1 x v;
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/examples/steel/arraystructs/Steel.C.PCM.fst
index beb034dd755..a58041d0dad 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fst
+++ b/examples/steel/arraystructs/Steel.C.PCM.fst
@@ -301,6 +301,15 @@ let compatible_pcm_of_fstar_pcm p x y = ()
 let exclusive_fstar_pcm_of_pcm p x = ()
 let exclusive_pcm_of_fstar_pcm p x = ()
 
+let frame_preserving_upd_intro
+  p x y f prf1 prf2 prf3
+= fun v ->
+  let v_new = f v in
+  prf1 v;
+  Classical.forall_intro (Classical.move_requires (prf2 v));
+  Classical.forall_intro (Classical.move_requires (prf3 v));
+  v_new
+
 let fstar_fpu_of_fpu
   (#a: Type u#a)
   (p: pcm0 a)
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/examples/steel/arraystructs/Steel.C.PCM.fsti
index a3348e28c93..1659384ddbf 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fsti
+++ b/examples/steel/arraystructs/Steel.C.PCM.fsti
@@ -190,11 +190,18 @@ val exclusive_pcm_of_fstar_pcm
   (exclusive (pcm_of_fstar_pcm p) x <==> P.exclusive p x)
   [SMTPat (exclusive (pcm_of_fstar_pcm p) x)]
 
-type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
+let frame_preserving_upd_dom
+  (#a:Type u#a) (p:pcm0 a) (x:a)
+=
   v:a{
     p_refine p v /\
     compatible p x v
-  } ->
+  }
+
+let frame_preserving_upd_codom
+  (#a:Type u#a) (p:pcm0 a) (x y:a)
+  (v: frame_preserving_upd_dom p x)
+=
   v_new:a{
     p_refine p v_new /\
     compatible p y v_new /\
@@ -202,6 +209,105 @@ type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
        composable p y frame /\
        (op p x frame == v ==> op p y frame == v_new))}
 
+type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
+  v: frame_preserving_upd_dom p x ->
+  Tot (frame_preserving_upd_codom p x y v)
+
+unfold
+let frame_preserving_upd_goal1
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (v: frame_preserving_upd_dom p x)
+: Tot prop
+= 
+  let v_new = f v in
+  p_refine p v_new /\
+  compatible p y v_new
+
+unfold
+let frame_preserving_upd_goal2_pre
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (v: frame_preserving_upd_dom p x)
+  (frame: a)
+: Tot prop
+= frame_preserving_upd_goal1 p x y f v /\
+  composable p x frame
+
+unfold
+let frame_preserving_upd_goal2_post
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (v: frame_preserving_upd_dom p x)
+  (frame: a)
+: Tot prop
+= 
+  frame_preserving_upd_goal2_pre p x y f v frame /\
+  composable p y frame
+
+unfold
+let frame_preserving_upd_goal3_pre
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (v: frame_preserving_upd_dom p x)
+  (frame: a)
+: Tot prop
+= frame_preserving_upd_goal2_pre p x y f v frame /\
+  frame_preserving_upd_goal2_post p x y f v frame /\
+  op p x frame == v
+
+unfold
+let frame_preserving_upd_goal3_post
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (v: frame_preserving_upd_dom p x)
+  (frame: a)
+: Tot prop
+= frame_preserving_upd_goal3_pre p x y f v frame /\
+  op p y frame == f v
+
+val frame_preserving_upd_intro
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (prf1:
+    (v: frame_preserving_upd_dom p x) ->
+    Lemma
+    (frame_preserving_upd_goal1 p x y f v)
+  )
+  (prf2:
+    (v: frame_preserving_upd_dom p x) ->
+    (frame: a) ->
+    Lemma
+    (requires (frame_preserving_upd_goal2_pre p x y f v frame))
+    (ensures (frame_preserving_upd_goal2_post p x y f v frame))
+  )
+  (prf3:
+    (v: frame_preserving_upd_dom p x) ->
+    (frame: a) ->
+    Lemma
+    (requires (frame_preserving_upd_goal3_pre p x y f v frame))
+    (ensures (frame_preserving_upd_goal3_post p x y f v frame))
+  )
+: Tot (frame_preserving_upd p x y)
+
 val fstar_fpu_of_fpu
   (#a: Type u#a)
   (p: pcm0 a)
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 28ccb45215d..c5481976ec0 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -42,11 +42,14 @@ let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
 : Lemma (is_union p f)
 = ()
 
-let union_comp (p:(k:'a -> pcm ('b k))): P.symrel (union p) = fun f g ->
+let union_comp0 (p:(k:'a -> pcm ('b k))) (f g: union p) : Tot prop =
   forall j k.
   ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
   j == k /\ composable (p k) (f k) (g k)
 
+let union_comp (p:(k:'a -> pcm ('b k))) : Tot (P.symrel (union p)) =
+  union_comp0 p
+
 let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
   (h:(j:'a -> k:'a ->
     Lemma
@@ -56,6 +59,13 @@ let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
 : Lemma (union_comp p f g)
 = let _ = h in ()
 
+let union_comp_elim (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (j:'a) (k:'a)
+: Lemma
+  (requires (union_comp p f g /\ ~ (f j == one (p j)) /\ ~ (g k == one (p k))))
+  (ensures j == k /\ composable (p k) (f k) (g k))
+= ()
+
 let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
 : Lemma
     (requires union_comp p f g)
@@ -156,7 +166,32 @@ let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
     ext y (one p') (fun k -> let _ = p k in ())
   in
   assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
-  p'
+  union_pcm' p
+
+let union_pcm_composable_intro0
+  (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+: Lemma
+  ((composable (union_pcm p) x y <==> union_comp p x y) /\
+  (composable (union_pcm p) x y ==> op (union_pcm p) x y == union_op p x y))
+  [SMTPat (composable (union_pcm p) x y)]
+= ()
+
+let union_comp_intro0 (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (composable (union_pcm p) f g)
+= let _ = h in ()
+
+let union_comp_elim0 (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (j:'a) (k:'a)
+: Lemma
+  (requires (composable (union_pcm p) f g /\ ~ (f j == one (p j)) /\ ~ (g k == one (p k))))
+  (ensures j == k /\ composable (p k) (f k) (g k))
+= ()
 
 let field_to_union_f
   (#a: eqtype)
@@ -183,6 +218,15 @@ let field_to_union
       assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
         ())
 
+let field_to_union_elim (#a: eqtype) (#b: a -> Type) (p: (k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+  (k': a)
+: Lemma
+  (requires (~ ((field_to_union p k).morph x k' == one (p k'))))
+  (ensures (k == k'))
+= ()
+
 let union_to_field_f
   (#a: Type)
   (#b: a -> Type)
@@ -202,8 +246,6 @@ let union_to_field
     (union_to_field_f p k) ()
     (fun x1 x2 -> ())
 
-#push-options "--z3rlimit 32 --query_stats"
-
 let union_field_lift_fpu'
   (#a: eqtype)
   (#b: a -> Type)
@@ -212,10 +254,7 @@ let union_field_lift_fpu'
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
-  (v: union p {
-    p_refine (union_pcm p) v /\
-    compatible (union_pcm p) ((field_to_struct p k).morph x) v
-  })
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_struct p k).morph x))
 : Tot (union p)
 = 
     on_dom a (fun k' ->
@@ -224,13 +263,39 @@ let union_field_lift_fpu'
       else one (p k')
     )
 
+#restart-solver
+
+#push-options "--z3rlimit 30 --query_stats --fuel 2 --ifuel 4"
+
+let union_field_lift_fpu0_prf1
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
+: Lemma
+  (frame_preserving_upd_goal1 (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v)
+=
+      let y' = (field_to_union p k).morph y in
+      let v_new = union_field_lift_fpu' p k x y f v in
+      assert (p_refine (union_pcm p) v_new);
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      let frame : b k = compatible_elim (p k) y (f (v k)) in
+      let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
+      assert (composable (union_pcm p) y' frame');
+      assert (op (union_pcm p) frame' y' `feq` v_new);
+      compatible_intro (union_pcm p) y' v_new frame'
+
 #pop-options
 
 #restart-solver
 
-#push-options "--z3rlimit 64 --query_stats"
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 16"
 
-let union_field_lift_fpu_prf
+let union_field_lift_fpu0_prf2
   (#a: eqtype)
   (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
@@ -238,40 +303,65 @@ let union_field_lift_fpu_prf
   (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
-  (v: union p {
-    p_refine (union_pcm p) v /\
-    compatible (union_pcm p) ((field_to_union p k).morph x) v
-  })
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
+  (frame: union p)
 : Lemma
-  (let v_new = union_field_lift_fpu' p k x y f v in
-    p_refine (union_pcm p) v_new /\
-    compatible (union_pcm p) ((field_to_union p k).morph y) v_new /\
-    (forall (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame}).
-       composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-       (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==> op (union_pcm p) ((field_to_union p k).morph y) frame == v_new))
+  (requires (
+    frame_preserving_upd_goal2_pre (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+  (ensures (
+    frame_preserving_upd_goal2_post (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+=
+  union_comp_intro0
+    p
+    ((field_to_union p k).morph y)
+    frame
+    (fun j' k' ->
+      field_to_union_elim p k y j';
+      union_comp_elim0 p ((field_to_union p k).morph x) frame k k';
+      let _ = f (v k) in
+      assert (composable (p k) x (frame k));
+      assert (composable (p k) y (frame k))
   )
+
+#restart-solver
+
+let union_field_lift_fpu0_prf3
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
+  (frame: union p)
+: Lemma
+  (requires (
+    frame_preserving_upd_goal3_pre (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+  (ensures (
+    frame_preserving_upd_goal3_post (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
 =
-  let y' = (field_to_union p k).morph y in
-  let v_new = union_field_lift_fpu' p k x y f v in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  let frame : b k = compatible_elim (p k) y (f (v k)) in
-  let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
-  assert (composable (union_pcm p) y' frame');
-  assert (op (union_pcm p) frame' y' `feq` v_new);
-  compatible_intro (union_pcm p) y' v_new frame';
-  let x = Ghost.reveal x in
-  let aux (frame:_{composable (union_pcm p) ((field_to_union p k).morph x) frame})
-  : Lemma (
-      composable (union_pcm p) ((field_to_union p k).morph y) frame /\
-      (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
-       op (union_pcm p) ((field_to_union p k).morph y) frame `feq` v_new))
-  = assert (composable (union_pcm p) ((field_to_union p k).morph y) frame);
-    assert_norm (
-     union_op p ((field_to_union p k).morph x) frame k ==
-     op (p k) x (frame k));
-    assert (op (union_pcm p) ((field_to_union p k).morph x) frame == v ==>
-       op (p k) x (frame k) == v k)
-  in FStar.Classical.forall_intro aux; assume False
+  let w = op (union_pcm p) ((field_to_union p k).morph x) frame in
+  union_pcm_composable_intro0 p ((field_to_union p k).morph x) frame;
+  assert (w == union_op p ((field_to_union p k).morph x) frame);
+  assert (w == prod_op p ((field_to_union p k).morph x) frame);
+  assert (w k == op (p k) x (frame k));
+  assert (w k == v k);
+  let v'k = f (v k) in
+  let w' = op (union_pcm p) ((field_to_union p k).morph y) frame in
+  union_pcm_composable_intro0 p ((field_to_union p k).morph y) frame;
+  assert (w' == union_op p ((field_to_union p k).morph y) frame);
+  assert (w' == prod_op p ((field_to_union p k).morph y) frame);
+  assert (w' k == op (p k) y (frame k));
+  assert (w' k == v'k);
+  assert (union_op p ((field_to_union p k).morph y) frame `feq` 
+    union_field_lift_fpu' p k x y f v)
+
+#pop-options
 
 let union_field_lift_fpu
   (#a: eqtype)
@@ -282,11 +372,16 @@ let union_field_lift_fpu
   (y: Ghost.erased (b k))
   (f: frame_preserving_upd (p k) x y)
 : Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
-= fun v ->
-    union_field_lift_fpu_prf p k x y f v;
-    union_field_lift_fpu' p k x y f v
-
-#pop-options
+=
+  let y' = Ghost.hide ((field_to_union p k).morph y) in
+  frame_preserving_upd_intro
+    (union_pcm p)
+    ((field_to_union p k).morph x)
+    ((field_to_union p k).morph y)
+    (union_field_lift_fpu' p k x y f)
+    (union_field_lift_fpu0_prf1 p k x y f)
+    (union_field_lift_fpu0_prf2 p k x y f)
+    (union_field_lift_fpu0_prf3 p k x y f)
 
 let union_field
   (#a: eqtype)

From 3be33700c98b5d25789aa042396728fa2e1e86bb Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 19 Jul 2021 07:13:05 -0700
Subject: [PATCH 116/513] Tagged union example

---
 .../arraystructs/AggregateRefExamples.fst     | 127 +++---------------
 examples/steel/arraystructs/IntOrBool.fst     |   4 +
 examples/steel/arraystructs/IntOrBool.fsti    |  12 ++
 3 files changed, 38 insertions(+), 105 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 521a99e8b4a..179cb920196 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -10,7 +10,6 @@ module A = Steel.Effect.Atomic
 
 open Steel.C.Opt
 
-(*
 open PointStruct
 
 /// We can write the following function that swaps the x and y fields of a given point:
@@ -120,6 +119,8 @@ let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
   unaddr_of_p2 p pp2;
   A.return ()
 
+open IntOrBool
+
 /// Swap two ints inside two (union int_or_bool)s using generic_swap
 ///
 /// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
@@ -141,8 +142,6 @@ let int_or_bool_int_swap
   unaddr_of_i p pi;
   unaddr_of_i q qi
 
-*)
-
 /// Convert an int_or_bool + runtime tag into an int
 ///
 /// int int_or_bool_to_int(bool is_int, union int_or_bool *p) {
@@ -150,18 +149,15 @@ let int_or_bool_int_swap
 ///   else return p->b ? 1 : 0;
 /// }
 
-open IntOrBool
-
-module I = FStar.IndefiniteDescription
-
-#push-options "--z3rlimit 30"
-
-let extract (u: Ghost.erased int_or_bool) (h: squash (case_of_int_or_bool u == Some I))
+(* For some reason the proof needs to be given explicitly *)
+let extract_int (u: Ghost.erased int_or_bool) (h: squash (case_of_int_or_bool u == Some I))
 : Tot (i:Ghost.erased (option int){u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))})
-= Ghost.reveal (I.indefinite_description_tot (Ghost.erased (option int))
-    (fun i -> u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))))
+= get_int u
+let extract_bool (u: Ghost.erased int_or_bool) (h: squash (case_of_int_or_bool u == Some B))
+: Tot (b:Ghost.erased (option bool){u == mk_bool b /\ ~ (Ghost.reveal b == one (opt_pcm #bool))})
+= get_bool u
 
-let int_or_bool_to_int
+let int_or_bool_to_int'
   (is_int: bool)
   (p: ref 'a int_or_bool_pcm)
   (u: Ghost.erased int_or_bool)
@@ -172,105 +168,26 @@ let int_or_bool_to_int
       if is_int then case_of_int_or_bool u == Some I 
       else case_of_int_or_bool u == Some B)
     (ensures fun _ _ _ -> True)
-= assume is_int;
-  let h : squash (case_of_int_or_bool u == Some I) = () in
-  //if is_int then begin
-    //let i: Ghost.erased (option int) =
-    //  I.indefinite_description_ghost (Ghost.erased (option int)) (fun i -> u == mk_int i)
-    //in
-    let i: (i:Ghost.erased (option int){u == mk_int i}) =
-      extract u h
-    in
-    let j: Ghost.erased int = Ghost.hide (Some?.v i) in
-    assert (u == mk_int i);
-    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int (some j));
+= if is_int then begin
+    let prf: squash (case_of_int_or_bool u == Some I) = () in
+    let i: Ghost.erased int = Ghost.hide (Some?.v (extract_int u prf)) in
+    assert (u == mk_int (some i));
+    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int (some i));
     let pi = addr_of_i p in
     let i = opt_read pi in
     unaddr_of_i p pi;
     A.return i
-    //A.sladmit(); A.return (admit())
-  //end else begin
-  //  //let pb = addr_of_b p in
-  //  //let b = opt_read pb in
-  //  //unaddr_of_b p pb;
-  //  //if b then A.return 1 else A.return 0
-  //  A.sladmit(); A.return (admit())
-  //end
-
-(*= let b = opt_read is_int in
-  if b then begin
-    (* return p->i *)
-    let pi = addr_of_i p in
-    A.sladmit(); A.return (admit())
-    //let i = opt_read pi in
-    //unaddr_of_i p pi;
-    //A.return i
   end else begin
-    A.sladmit(); A.return (admit())
-    //(* return p->b ? 1 : 0 *)
-    //let pb = addr_of_b p in
-    //let b = opt_read pb in
-    //unaddr_of_b p pb;
-    //let b = b in
-    //A.return (if b then 1 else 0)
+    let prf: squash (case_of_int_or_bool u == Some B) = () in
+    let b: Ghost.erased bool = Ghost.hide (Some?.v (extract_bool u prf)) in
+    assert (u == mk_bool (some b));
+    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_bool (some b));
+    let pb = addr_of_b p in
+    let b = opt_read pb in
+    unaddr_of_b p pb;
+    if b then A.return 1 else A.return 0
   end
-*)
 
-//let int_or_bool_to_int
-//  (is_int: ref 'a (opt_pcm #bool)) (p: ref 'b int_or_bool_pcm)
-//  (b: Ghost.erased bool) (u: Ghost.erased int_or_bool)
-//: Steel (option int)
-//    ((is_int `pts_to` some b) `star` (p `pts_to` u))
-//    (fun _ -> ((is_int `pts_to` some b) `star` (p `pts_to` u)))
-//    (requires fun _ -> if b then case u == I else case u == B)
-//    (ensures fun _ _ _ -> True)
-//= let b = opt_read is_int in
-//  if some_v b then begin
-//    (* return p->i *)
-//    let pi = addr_of_i p in
-//    let i = opt_read pi in
-//    unaddr_of_i p pi;
-//    A.return i
-//  end else begin
-//    (* return p->b ? 1 : 0 *)
-//    let pb = addr_of_b p in
-//    let b = opt_read pb in
-//    unaddr_of_b p pb;
-//    let b = some_v b in
-//    if b then some' 1 else some' 0
-//  end
-(*
-addr_of
-  (r `pts_to` xs)
-  (r `pts_to` xs \ k `star` s `pts_to` xs k)
-  
-let point_swap_generically (#q: Ghost.erased int) (p: ref 'a point_pcm)
-: SteelT unit
-    (p `pts_to` q)
-    (fun _ -> p `pts_to` q[.y = q.x][.x = q.y])
-= (* int *q = &p.x; *)
-  let q = addr_of_x p in
-  (* int *r = &p.y; *)
-  let r = addr_of_y p in
-  (* generic_swap(q, r); *)
-  generic_swap q r;
-  (* Gather *)
-  unaddr_of_x p q;
-  unaddr_of_y p r;
-  A.return ()
-p\{x, y} `pts_to` (v, w)
-p.x `pts_to` v === p `pts_to` mk_point v one
-p.y `pts_to` w === p `pts_to` mk_point one w
-give p.x's share back to p
-p' `pts_to` v_x
-p' == ghost_addr_of p y
-ghost_addr_of  = ref_focus .. 
-ghost_addr_of p y `pts_to` v_y
-  
-addr_of
-  (r `pts_to` xs `star` s `pts_to` y)
-  (r `pts_to` xs [k `mapsto` y])
-  *)
 (*
 pts_to r x
 (fun r' -> pts_to r' x')
diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
index 818a7102de2..c5c8553fb7a 100644
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ b/examples/steel/arraystructs/IntOrBool.fst
@@ -55,6 +55,10 @@ let mk_int_exclusive i = exclusive_union_intro int_or_bool_cases_pcm (mk_int i)
 
 let mk_bool_exclusive b = exclusive_union_intro int_or_bool_cases_pcm (mk_bool b) B
 
+let get_int u = Ghost.reveal u I
+
+let get_bool u = Ghost.reveal u B
+
 let addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)
 : Steel (q:ref 'a (opt_pcm #int){q == ref_focus p _i})
     (p `pts_to` mk_int i)
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
index 08b93e47442..ce97f08f2c7 100644
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ b/examples/steel/arraystructs/IntOrBool.fsti
@@ -68,6 +68,18 @@ val mk_bool_exclusive (b: Ghost.erased (option bool))
     (ensures exclusive int_or_bool_pcm (mk_bool b))
   [SMTPat (exclusive (opt_pcm #bool) b)]
 
+/// Getting the value inside a union of known case
+
+val get_int (u: Ghost.erased int_or_bool)
+: Ghost (option int)
+    (requires case_of_int_or_bool u == Some I)
+    (ensures fun i -> u == mk_int i /\ ~ (i == Ghost.reveal none))
+
+val get_bool (u: Ghost.erased int_or_bool)
+: Ghost (option bool)
+    (requires case_of_int_or_bool u == Some B)
+    (ensures fun b -> u == mk_bool b /\ ~ (b == Ghost.reveal none))
+
 /// Taking pointers to the i and b cases of an int_or_bool
 
 val addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)

From 7e14e42aed6d12d7a9de91eeba6f1cf4a902f83e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 19 Jul 2021 09:33:57 -0700
Subject: [PATCH 117/513] fix ListNode

---
 examples/steel/arraystructs/ListNode.fst  | 16 ++++++++++------
 examples/steel/arraystructs/ListNode.fsti | 20 ++++++++++++++------
 2 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 256ed556318..fc19e11cdc7 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -174,7 +174,7 @@ let addr_of_value
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: Steel (q:ref 'a (opt_pcm #int))
+: Steel (ref 'a (opt_pcm #int))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
@@ -201,7 +201,7 @@ let unaddr_of_value
     (requires (fun _ -> q == ref_focus p _value))
     (ensures (fun _ _ _ -> True))
 = let p' = unroll_ref p in
-  let q = unaddr_of_struct_field Value q p' (mk_node' none next) value in
+  let q = unaddr_of_struct_field #_ #_ #_ #node_fields_pcm Value q p' (mk_node' none next) value in // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
   A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
   roll_ref p p';
   A.return ()
@@ -210,11 +210,13 @@ let addr_of_next
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
+: Steel (ref 'a (opt_pcm #(option (ref' node node))))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
        (q `pts_to` next))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> q == ref_focus p _next))
 = let p' = unroll_ref p in
   let q = addr_of_struct_field p' Next (mk_node' value next) in
   A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value none);
@@ -226,12 +228,14 @@ let unaddr_of_next
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
-: SteelT unit
+  (q: ref 'a (opt_pcm #(option (ref' node node))))
+: Steel unit
     ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
     (fun q -> p `pts_to` mk_node value next)
+    (requires (fun _ -> (q == ref_focus p _next)))
+    (ensures (fun _ _ _ -> True))
 = let p' = unroll_ref p in
-  let q = unaddr_of_struct_field Next q p' (mk_node' value none) next in
+  let q = unaddr_of_struct_field #_ #_ #_ #node_fields_pcm Next q p' (mk_node' value none) next in // same here
   A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
   roll_ref p p';
   A.return ()
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index 1a13cec3b8a..177732d408e 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -34,36 +34,44 @@ val addr_of_value
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _value})
+: Steel (ref 'a (opt_pcm #int))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node none next) `star`
        (q `pts_to` value))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> q == ref_focus p _value))
 
 val unaddr_of_value
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #int){q == ref_focus p _value})
-: SteelT unit
+  (q: ref 'a (opt_pcm #int))
+: Steel unit
     ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
     (fun q -> p `pts_to` mk_node value next)
+    (requires (fun _ -> q == ref_focus p _value))
+    (ensures (fun _ _ _ -> True))
 
 val addr_of_next
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
+: Steel (ref 'a (opt_pcm #(option (ref' node node))))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
        (q `pts_to` next))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> q == ref_focus p _next))
 
 val unaddr_of_next
   (#value:Ghost.erased (option int))
   (#next:Ghost.erased (option (option (ref' node node))))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
-: SteelT unit
+  (q: ref 'a (opt_pcm #(option (ref' node node))))
+: Steel unit
     ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
     (fun q -> p `pts_to` mk_node value next)
+    (requires (fun _ -> q == ref_focus p _next))
+    (ensures (fun _ _ _ -> True))

From 247274a3fe3a1ac7ca1e3c2b6f104e1749017ad9 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 19 Jul 2021 15:38:51 -0700
Subject: [PATCH 118/513] Linked list module with new and push

---
 examples/steel/arraystructs/LList.fst        | 262 +++++++++++++++++++
 examples/steel/arraystructs/ListNode.fsti    |  18 ++
 examples/steel/arraystructs/Steel.C.Opt.fsti |   2 +
 3 files changed, 282 insertions(+)
 create mode 100644 examples/steel/arraystructs/LList.fst

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
new file mode 100644
index 00000000000..842ffe198b1
--- /dev/null
+++ b/examples/steel/arraystructs/LList.fst
@@ -0,0 +1,262 @@
+module LList
+open Steel.Memory
+open Steel.Effect.Atomic
+open Steel.Effect
+
+open Steel.C.Ref
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Connection
+
+open ListNode
+
+let vpure_sel'
+  (p: prop)
+: Tot (selector' (squash p) (Steel.Memory.pure p))
+= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
+
+let vpure_sel
+  (p: prop)
+: Tot (selector (squash p) (Steel.Memory.pure p))
+= vpure_sel' p
+
+[@@ __steel_reduce__]
+let vpure'
+  (p: prop)
+: GTot vprop'
+= {
+  hp = Steel.Memory.pure p;
+  t = squash p;
+  sel = vpure_sel p;
+}
+
+[@@ __steel_reduce__]
+let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
+
+let intro_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    emp
+    (fun _ -> vpure p)
+    (fun _ -> p)
+    (fun _ _ h' -> p)
+=
+  change_slprop_rel
+    emp
+    (vpure p)
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m)
+
+let elim_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    (vpure p)
+    (fun _ -> emp)
+    (fun _ -> True)
+    (fun _ _ _ -> p)
+=
+  change_slprop_rel
+    (vpure p)
+    emp
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
+
+let ptr = option (ref' node node)
+let cells = list (Ghost.erased int & Ghost.erased ptr)
+
+let pts_to_llist_cons (value: Ghost.erased int) (next: Ghost.erased ptr) (tl: cells)
+  (pts_to_llist:(
+    Ghost.erased ptr ->
+    l:cells{List.length l < List.length ((value, next) :: tl)} ->
+    Tot vprop))
+  (p: option (ref' node node))
+  (prf: squash (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
+: vprop
+= let r: ref node node_pcm = Some?.v p in
+  (r `pts_to` mk_node (some value) (some next)) `star`
+  (next `pts_to_llist` tl)
+
+let rec pts_to_llist (p:Ghost.erased ptr) (l:cells)
+: Tot vprop (decreases (List.length l))
+= match l with
+  | [] -> vpure (p == none)
+  | (value, next) :: tl ->
+    vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
+    pts_to_llist_cons value next tl pts_to_llist p
+
+let pts_to_llist_nil_eq p
+: Lemma ((p `pts_to_llist` []) == vpure (p == none))
+  [SMTPat (p `pts_to_llist` [])]
+= ()
+
+let pts_to_llist_cons_eq (p: Ghost.erased ptr) value next tl
+: Lemma ((p `pts_to_llist` ((value, next) :: tl)) == 
+    vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
+    pts_to_llist_cons value next tl pts_to_llist p)
+= assert_norm ((p `pts_to_llist` ((value, next) :: tl)) == 
+    vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
+    pts_to_llist_cons value next tl pts_to_llist p)
+
+let pts_to_llist_cons_eq' (p: Ghost.erased ptr) value next tl prf
+: Lemma (pts_to_llist_cons value next tl pts_to_llist p prf ==
+    (let r: ref node node_pcm = Some?.v p in
+     (r `pts_to` mk_node (some value) (some next)) `star`
+     (next `pts_to_llist` tl)))
+= assert_norm (pts_to_llist_cons value next tl pts_to_llist p prf ==
+    (let r: ref node node_pcm = Some?.v p in
+     (r `pts_to` mk_node (some value) (some next)) `star`
+     (next `pts_to_llist` tl)))
+
+assume val intro_llist_nil : unit -> SteelT unit emp (fun _ -> none `pts_to_llist` [])
+
+// let intro_llist_nil () =
+//   intro_vpure (none #(ref' node node) == none);
+//   pts_to_llist_nil_eq none;
+//   change_equal_slprop _ (none `pts_to_llist` [])
+  
+assume val intro_llist_cons
+  (#opened:inames) (r: Ghost.erased (ref node node_pcm))
+  (value: Ghost.erased int) (next: Ghost.erased ptr)
+  (tl: cells)
+: SteelGhostT unit opened
+    (r `pts_to` (mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
+    (fun _ -> some (Ghost.hide (Ghost.reveal r)) `pts_to_llist` ((value, next)::tl))
+  
+// let intro_llist_cons r value next tl = 
+//   let p: Ghost.erased ptr = some (Ghost.hide (Ghost.reveal r)) in
+//   intro_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
+//   intro_vdep (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
+//     (r `pts_to` (mk_node (some value) (some next)) `star`
+//      (next `pts_to_llist` tl))
+//     (pts_to_llist_cons value next tl pts_to_llist p);
+//   pts_to_llist_cons_eq p value next tl;
+//   change_equal_slprop _ (some (Ghost.hide (Ghost.reveal r)) `pts_to_llist` ((value, next)::tl))
+
+assume val elim_llist_cons
+  (#opened:inames) (p: Ghost.erased ptr)
+  (value: Ghost.erased int) (next: Ghost.erased ptr)
+  (tl: cells)
+: SteelGhost (Ghost.erased (ref node node_pcm)) opened
+    (p `pts_to_llist` ((value, next)::tl))
+    (fun r ->
+      (r `pts_to` mk_node (some value) (some next)) `star`
+      (next `pts_to_llist` tl))
+    (requires fun _ -> True)
+    (ensures fun _ r _ -> p == some (Ghost.hide (Ghost.reveal r)))
+
+// let elim_llist_cons p value next tl =
+//   pts_to_llist_cons_eq p value next tl;
+//   change_equal_slprop
+//     (p `pts_to_llist` _)
+//     (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
+//      pts_to_llist_cons value next tl pts_to_llist p);
+//   let prf: Ghost.erased (t_of (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))) =
+//     elim_vdep 
+//       (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
+//       (pts_to_llist_cons value next tl pts_to_llist p)
+//   in
+//   elim_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
+//   pts_to_llist_cons_eq' p value next tl prf;
+//   let r: Ghost.erased (ref node node_pcm) = Some?.v p in
+//   change_equal_slprop
+//     (pts_to_llist_cons value next tl pts_to_llist p prf)
+//     ((Ghost.reveal r `pts_to`
+//       mk_node (some value) (some next)) `star`
+//      (next `pts_to_llist` tl));
+//   r
+
+let rec values (l:cells) : GTot (list int) =
+  match l with
+  | [] -> []
+  | (value, _)::tl -> Ghost.reveal value :: values tl
+  
+val new_llist (init:int)
+  : Steel (ptr & cells)
+          emp
+          (fun (p, l) -> p `pts_to_llist` l)
+          (requires fun _ -> True)
+          (ensures fun _ (p, l) _ -> values l == [init])
+
+#set-options "--ide_id_info_off"
+
+let new_llist (init:int) =
+  let cell: Ghost.erased int & Ghost.erased ptr = (Ghost.hide init, Ghost.hide None) in
+  let r = ref_alloc node_pcm (mk_node_tot (Some init) (Some None)) in
+  intro_llist_nil ();
+  change_equal_slprop
+    (r `pts_to` Ghost.hide (mk_node_tot (Some init) (Some None)))
+    (Ghost.reveal (Ghost.hide r) `pts_to` mk_node (some init) (some none));
+  intro_llist_cons r (Ghost.hide init) (Ghost.hide None) [];
+  change_equal_slprop (some _ `pts_to_llist` _) (Some r `pts_to_llist` _);
+  return (Some r, [cell])
+
+val push (p:ptr) (l:cells) (value:int)
+: Steel (ptr & cells)
+    (p `pts_to_llist` l)
+    (fun (p', l') -> p' `pts_to_llist` l')
+    (requires fun _ -> True)
+    (ensures fun _ (_, l') _ -> values l' == value :: values l)
+
+let push p l value =
+  let cell: Ghost.erased int & Ghost.erased ptr = (Ghost.hide value, Ghost.hide p) in
+  let r = ref_alloc node_pcm (mk_node_tot (Some value) (Some p)) in
+  change_equal_slprop
+    (r `pts_to` Ghost.hide (mk_node_tot (Some value) (Some p)))
+    (Ghost.reveal (Ghost.hide r) `pts_to` mk_node (some value) (some (Ghost.hide p)));
+  intro_llist_cons (Ghost.hide r) (Ghost.hide value) (Ghost.hide p) l;
+  change_equal_slprop (some _ `pts_to_llist` _) (Some r `pts_to_llist` _);
+  return (Some r, cell :: l)
+
+//val ref_alloc
+//  (#a:Type0) (p: pcm a) (x: a)
+//: Steel (ref a p)
+//    emp
+//    (fun r -> r `pts_to` x)
+//    (requires fun _ -> p_refine p x)
+//    (ensures fun _ _ _ -> True)
+
+//elim_vdep
+// Mutate the kth element of a list (of fixed k)
+// 
+// t k = type of functions that mutate kth element of a list
+// 
+// set_zero : Tot (t 0)
+// set_succ : t k -> Tot (t (k + 1))
+//
+// let rec set k .. : Steel _ = 
+// let rec set k .. : Tot (.. -> Steel _) = 
+
+val push (#a:Type) (ptr:t a) (l:list (cell a)) (v:a)
+  : Steel (t a & list (cell a))
+          (llist ptr l)
+          (fun pc -> llist (fst pc) (snd pc))
+          (requires fun _ -> True)
+          (ensures fun _ pc _ -> datas (snd pc) == v::datas l)
+
+let push #a ptr l v =
+  let cell = mk_cell ptr v in
+  let p = alloc_pt cell in
+  rewrite_slprop (llist ptr l) (llist (next cell) l) (fun _ -> ());
+  intro_llist_cons p cell l;
+  let pc = p, (cell::l) in
+  pc
+
+val pop (#a:Type) (ptr:t a) (l:list (cell a){Cons? l})
+  : Steel a
+          (llist ptr l)
+          (fun _ -> llist (next (L.hd l)) (L.tl l))
+          (requires fun _ -> True)
+          (ensures fun _ x _ -> x == data (L.hd l))
+
+let pop #a ptr l =
+  let hd = L.hd l in
+  let tl = L.tl l in
+  rewrite_slprop (llist ptr l) (llist ptr (hd::tl)) (fun _ -> ());
+  elim_llist_cons ptr hd tl;
+  let c = read_pt ptr in
+  let n = next hd in
+  free_pt ptr;
+  rewrite_slprop (llist (next hd) tl) (llist (next (L.hd l)) (L.tl l)) (fun _ -> ());
+  return (data c)
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index 177732d408e..5e2d7895c69 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -23,6 +23,24 @@ val mk_node
   (next: Ghost.erased (option (option (ref' node node))))
 : Ghost.erased node
 
+val mk_node_tot
+  (i: option int)
+  (next: option (option (ref' node node)))
+: node
+
+val mk_node_tot_mk_node (i: option int) (next: option (option (ref' node node)))
+: Lemma (mk_node_tot i next == Ghost.reveal (mk_node i next))
+  [SMTPat (mk_node_tot i next)]
+
+open Steel.C.PCM
+module P = FStar.PCM
+
+val mk_node_refine (i: option int) (next: option (option (ref' node node)))
+: Lemma
+    (requires p_refine opt_pcm i /\ p_refine (opt_pcm) next)
+    (ensures p_refine node_pcm (mk_node i next))
+    [SMTPat (p_refine node_pcm (mk_node i next))]
+
 /// Lenses for fields
 
 val _value: node_pcm `connection` opt_pcm #int
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index 67e86f7ee71..4c13771c3a9 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -31,6 +31,8 @@ let none #a: Ghost.erased (option a) = None
 
 let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
 
+let some_v (x: Ghost.erased (option 'a){Some? x}): Ghost.erased 'a = Some?.v x
+
 val opt_read
   (#a:Type) (#b:Type) (#x: Ghost.erased b)
   (r: ref a (opt_pcm #b))

From aa6b3ec8dd84c5e7856b8a2691171e2b1f01850b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 09:37:29 -0700
Subject: [PATCH 119/513] Impl set_hD

---
 examples/steel/arraystructs/LList.fst    | 276 +++++++++++++----------
 examples/steel/arraystructs/ListNode.fst |   9 +
 2 files changed, 169 insertions(+), 116 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 842ffe198b1..d1d80dd524d 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -64,160 +64,217 @@ let elim_vpure
     (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
 
 let ptr = option (ref' node node)
-let cells = list (Ghost.erased int & Ghost.erased ptr)
+let cells = list (int & ptr)
 
-let pts_to_llist_cons (value: Ghost.erased int) (next: Ghost.erased ptr) (tl: cells)
+let pts_to_llist_cons (value: int) (next: ptr) (tl: cells)
   (pts_to_llist:(
-    Ghost.erased ptr ->
-    l:cells{List.length l < List.length ((value, next) :: tl)} ->
+    ptr ->
+    l:Ghost.erased cells{List.length l < List.length ((value, next) :: tl)} ->
     Tot vprop))
   (p: option (ref' node node))
   (prf: squash (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
 : vprop
 = let r: ref node node_pcm = Some?.v p in
   (r `pts_to` mk_node (some value) (some next)) `star`
-  (next `pts_to_llist` tl)
+  (next `pts_to_llist` Ghost.hide tl)
 
-let rec pts_to_llist (p:Ghost.erased ptr) (l:cells)
+let rec pts_to_llist ([@@@smt_fallback] p:ptr) ([@@@smt_fallback] l:Ghost.erased cells)
 : Tot vprop (decreases (List.length l))
-= match l with
-  | [] -> vpure (p == none)
+= match Ghost.reveal l with
+  | [] -> vpure (p == None)
   | (value, next) :: tl ->
     vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
     pts_to_llist_cons value next tl pts_to_llist p
 
 let pts_to_llist_nil_eq p
-: Lemma ((p `pts_to_llist` []) == vpure (p == none))
+: Lemma ((p `pts_to_llist` []) == vpure (p == None))
   [SMTPat (p `pts_to_llist` [])]
 = ()
 
-let pts_to_llist_cons_eq (p: Ghost.erased ptr) value next tl
-: Lemma ((p `pts_to_llist` ((value, next) :: tl)) == 
+let pts_to_llist_cons_eq (p:ptr) (value:int) (next:ptr) (tl:cells)
+: Lemma ((p `pts_to_llist` Ghost.hide ((value, next) :: tl)) == 
     vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
     pts_to_llist_cons value next tl pts_to_llist p)
-= assert_norm ((p `pts_to_llist` ((value, next) :: tl)) == 
+= assert_norm ((p `pts_to_llist` Ghost.hide ((value, next) :: tl)) == 
+  (match Ghost.reveal (Ghost.hide ((value, next) :: tl)) with
+  | [] -> vpure (p == None)
+  | (value, next) :: tl ->
     vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
-    pts_to_llist_cons value next tl pts_to_llist p)
+    pts_to_llist_cons value next tl pts_to_llist p)) 
+    // TODO Why do I have to keep the match around?
 
-let pts_to_llist_cons_eq' (p: Ghost.erased ptr) value next tl prf
+let pts_to_llist_cons_eq' (p: ptr) value (next:ptr) tl prf
 : Lemma (pts_to_llist_cons value next tl pts_to_llist p prf ==
     (let r: ref node node_pcm = Some?.v p in
-     (r `pts_to` mk_node (some value) (some next)) `star`
-     (next `pts_to_llist` tl)))
+     (r `pts_to` mk_node (some (Ghost.hide value)) (some (Ghost.hide next))) `star`
+     (next `pts_to_llist` Ghost.hide tl)))
 = assert_norm (pts_to_llist_cons value next tl pts_to_llist p prf ==
     (let r: ref node node_pcm = Some?.v p in
      (r `pts_to` mk_node (some value) (some next)) `star`
-     (next `pts_to_llist` tl)))
+     (next `pts_to_llist` Ghost.hide tl)))
 
-assume val intro_llist_nil : unit -> SteelT unit emp (fun _ -> none `pts_to_llist` [])
+val intro_llist_nil : unit -> SteelT unit emp (fun _ -> None `pts_to_llist` [])
 
-// let intro_llist_nil () =
-//   intro_vpure (none #(ref' node node) == none);
-//   pts_to_llist_nil_eq none;
-//   change_equal_slprop _ (none `pts_to_llist` [])
+let intro_llist_nil () =
+  intro_vpure (None #(ref' node node) == None);
+  pts_to_llist_nil_eq None;
+  change_equal_slprop _ (None `pts_to_llist` [])
   
-assume val intro_llist_cons
-  (#opened:inames) (r: Ghost.erased (ref node node_pcm))
-  (value: Ghost.erased int) (next: Ghost.erased ptr)
+val intro_llist_cons
+  (#opened:inames) (r: ref node node_pcm)
+  (value: int) (next: ptr)
   (tl: cells)
 : SteelGhostT unit opened
-    (r `pts_to` (mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
-    (fun _ -> some (Ghost.hide (Ghost.reveal r)) `pts_to_llist` ((value, next)::tl))
+    ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
+    (fun _ -> Some r `pts_to_llist` ((value, next)::tl))
   
-// let intro_llist_cons r value next tl = 
-//   let p: Ghost.erased ptr = some (Ghost.hide (Ghost.reveal r)) in
-//   intro_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
-//   intro_vdep (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
-//     (r `pts_to` (mk_node (some value) (some next)) `star`
-//      (next `pts_to_llist` tl))
-//     (pts_to_llist_cons value next tl pts_to_llist p);
-//   pts_to_llist_cons_eq p value next tl;
-//   change_equal_slprop _ (some (Ghost.hide (Ghost.reveal r)) `pts_to_llist` ((value, next)::tl))
-
-assume val elim_llist_cons
-  (#opened:inames) (p: Ghost.erased ptr)
-  (value: Ghost.erased int) (next: Ghost.erased ptr)
-  (tl: cells)
+let intro_llist_cons r value next tl = 
+  let p: ptr = Some r in
+  intro_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
+  intro_vdep (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
+    (r `pts_to` (mk_node (some value) (some next)) `star`
+     (next `pts_to_llist` tl))
+    (pts_to_llist_cons value next tl pts_to_llist p);
+  pts_to_llist_cons_eq p value next tl;
+  change_equal_slprop _ (Some r `pts_to_llist` ((value, next)::tl))
+
+val elim_llist_cons
+  (#opened:inames) (p: ptr)
+  (value: int) (next: ptr) (tl: cells)
 : SteelGhost (Ghost.erased (ref node node_pcm)) opened
     (p `pts_to_llist` ((value, next)::tl))
     (fun r ->
       (r `pts_to` mk_node (some value) (some next)) `star`
       (next `pts_to_llist` tl))
     (requires fun _ -> True)
-    (ensures fun _ r _ -> p == some (Ghost.hide (Ghost.reveal r)))
-
-// let elim_llist_cons p value next tl =
-//   pts_to_llist_cons_eq p value next tl;
-//   change_equal_slprop
-//     (p `pts_to_llist` _)
-//     (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
-//      pts_to_llist_cons value next tl pts_to_llist p);
-//   let prf: Ghost.erased (t_of (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))) =
-//     elim_vdep 
-//       (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
-//       (pts_to_llist_cons value next tl pts_to_llist p)
-//   in
-//   elim_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
-//   pts_to_llist_cons_eq' p value next tl prf;
-//   let r: Ghost.erased (ref node node_pcm) = Some?.v p in
-//   change_equal_slprop
-//     (pts_to_llist_cons value next tl pts_to_llist p prf)
-//     ((Ghost.reveal r `pts_to`
-//       mk_node (some value) (some next)) `star`
-//      (next `pts_to_llist` tl));
-//   r
+    (ensures fun _ r _ -> p == Some (Ghost.reveal r))
+
+let elim_llist_cons p value next tl =
+  pts_to_llist_cons_eq p value next tl;
+  change_equal_slprop
+    (p `pts_to_llist` _)
+    (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
+     pts_to_llist_cons value next tl pts_to_llist p);
+  let prf: Ghost.erased (t_of (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))) =
+    elim_vdep 
+      (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
+      (pts_to_llist_cons value next tl pts_to_llist p)
+  in
+  elim_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
+  pts_to_llist_cons_eq' p value next tl prf;
+  let r: Ghost.erased (ref node node_pcm) = Some?.v p in
+  change_equal_slprop
+    (pts_to_llist_cons value next tl pts_to_llist p prf)
+    ((Ghost.reveal r `pts_to` mk_node (some value) (some next)) `star`
+     (next `pts_to_llist` tl));
+  r
 
 let rec values (l:cells) : GTot (list int) =
   match l with
   | [] -> []
-  | (value, _)::tl -> Ghost.reveal value :: values tl
-  
-val new_llist (init:int)
-  : Steel (ptr & cells)
-          emp
-          (fun (p, l) -> p `pts_to_llist` l)
-          (requires fun _ -> True)
-          (ensures fun _ (p, l) _ -> values l == [init])
+  | (value, _) :: tl -> Ghost.reveal value :: values tl
 
 #set-options "--ide_id_info_off"
 
-let new_llist (init:int) =
-  let cell: Ghost.erased int & Ghost.erased ptr = (Ghost.hide init, Ghost.hide None) in
-  let r = ref_alloc node_pcm (mk_node_tot (Some init) (Some None)) in
-  intro_llist_nil ();
-  change_equal_slprop
-    (r `pts_to` Ghost.hide (mk_node_tot (Some init) (Some None)))
-    (Ghost.reveal (Ghost.hide r) `pts_to` mk_node (some init) (some none));
-  intro_llist_cons r (Ghost.hide init) (Ghost.hide None) [];
-  change_equal_slprop (some _ `pts_to_llist` _) (Some r `pts_to_llist` _);
-  return (Some r, [cell])
-
-val push (p:ptr) (l:cells) (value:int)
-: Steel (ptr & cells)
+val push (p:ptr) (l:Ghost.erased cells) (value:int)
+: Steel (ptr & Ghost.erased cells)
     (p `pts_to_llist` l)
     (fun (p', l') -> p' `pts_to_llist` l')
     (requires fun _ -> True)
     (ensures fun _ (_, l') _ -> values l' == value :: values l)
 
 let push p l value =
-  let cell: Ghost.erased int & Ghost.erased ptr = (Ghost.hide value, Ghost.hide p) in
+  let cell: int & ptr = (value, p) in
   let r = ref_alloc node_pcm (mk_node_tot (Some value) (Some p)) in
-  change_equal_slprop
-    (r `pts_to` Ghost.hide (mk_node_tot (Some value) (Some p)))
-    (Ghost.reveal (Ghost.hide r) `pts_to` mk_node (some value) (some (Ghost.hide p)));
-  intro_llist_cons (Ghost.hide r) (Ghost.hide value) (Ghost.hide p) l;
-  change_equal_slprop (some _ `pts_to_llist` _) (Some r `pts_to_llist` _);
-  return (Some r, cell :: l)
-
-//val ref_alloc
-//  (#a:Type0) (p: pcm a) (x: a)
-//: Steel (ref a p)
-//    emp
-//    (fun r -> r `pts_to` x)
-//    (requires fun _ -> p_refine p x)
-//    (ensures fun _ _ _ -> True)
-
-//elim_vdep
+  intro_llist_cons r value p l;
+  return (Some r, Ghost.hide (cell :: l))
+  
+let cells_set_hd x (l: cells) = match l with
+  | [] -> []
+  | (_, next) :: l' -> (x, next) :: l'
+
+/// Mutate the head of a list
+
+// TODO does this exist already?
+assume val exfalso (#opened:inames) (p:vprop) (q:prop)
+: SteelGhost unit opened emp (fun _ -> p) (requires fun _ -> False) (ensures fun _ _ _ -> q)
+
+val pts_to_llist_nullptr (#opened:inames) (p:ptr) (l:Ghost.erased cells)
+: SteelGhost unit opened
+    (p `pts_to_llist` l) 
+    (fun _ -> None `pts_to_llist` [])
+    (requires fun _ -> p == None)
+    (ensures fun _ _ _ -> Ghost.reveal l == [])
+
+let pts_to_llist_nullptr p l =
+  match Ghost.reveal l with
+  | [] -> change_equal_slprop (p `pts_to_llist` l) (None `pts_to_llist` [])
+  | (value, next) :: tl ->
+    change_equal_slprop (p `pts_to_llist` l) (None `pts_to_llist` ((value, next) :: tl));
+    let r = elim_llist_cons None value next tl in
+    assert (None == Some r);
+    sladmit() // TODO
+    //exfalso (None `pts_to_llist` []) (Ghost.reveal l == [])
+
+[@@erasable]
+noeq type pts_to_llist_res = {
+  value: int;
+  next: ptr;
+  tl: cells;
+}
+
+val pts_to_llist_some (#opened:inames) (p:ptr) (l:Ghost.erased cells)
+: SteelGhost pts_to_llist_res opened
+    (p `pts_to_llist` l) 
+    (fun res -> p `pts_to_llist` ((res.value, res.next) :: res.tl))
+    (requires fun _ -> Some? p)
+    (ensures fun _ res _ ->
+      Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm /\
+      Ghost.reveal l == ((res.value, res.next) :: res.tl))
+
+let pts_to_llist_some p l =
+  match Ghost.reveal l with
+  | [] ->
+    change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` []);
+    assert (Some? p /\ p == None);
+    sladmit() // TODO
+  | (value, next) :: tl ->
+    change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
+    {value; next; tl}
+
+val set_hd (p:ptr) (l:cells) (value:int)
+: SteelT unit
+    (p `pts_to_llist` l)
+    (fun _ -> p `pts_to_llist` cells_set_hd value l)
+
+let set_hd p l new_value =
+  match p with
+  | None -> pts_to_llist_nullptr p l; return ()
+  | Some r ->
+    let res = pts_to_llist_some p l in
+    let value: Ghost.erased int = Ghost.hide res.value in
+    let next: Ghost.erased ptr = Ghost.hide res.next in
+    let tl: Ghost.erased cells = Ghost.hide res.tl in
+    //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
+    //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
+    //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
+    change_equal_slprop (p `pts_to_llist` l)
+      (Some r `pts_to_llist`
+       Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
+    let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
+    let r: ref node node_pcm = r in
+    //assert (Ghost.reveal r' == r);
+    //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
+    change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
+      (r `pts_to` mk_node (some value) (some next));
+    let r_value = addr_of_value r in
+    r_value `opt_write` new_value;
+    unaddr_of_value r r_value;
+    intro_llist_cons r new_value next tl;
+    //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
+    //sladmit(); return ()
+    return ()
+
 // Mutate the kth element of a list (of fixed k)
 // 
 // t k = type of functions that mutate kth element of a list
@@ -228,21 +285,7 @@ let push p l value =
 // let rec set k .. : Steel _ = 
 // let rec set k .. : Tot (.. -> Steel _) = 
 
-val push (#a:Type) (ptr:t a) (l:list (cell a)) (v:a)
-  : Steel (t a & list (cell a))
-          (llist ptr l)
-          (fun pc -> llist (fst pc) (snd pc))
-          (requires fun _ -> True)
-          (ensures fun _ pc _ -> datas (snd pc) == v::datas l)
-
-let push #a ptr l v =
-  let cell = mk_cell ptr v in
-  let p = alloc_pt cell in
-  rewrite_slprop (llist ptr l) (llist (next cell) l) (fun _ -> ());
-  intro_llist_cons p cell l;
-  let pc = p, (cell::l) in
-  pc
-
+(*
 val pop (#a:Type) (ptr:t a) (l:list (cell a){Cons? l})
   : Steel a
           (llist ptr l)
@@ -260,3 +303,4 @@ let pop #a ptr l =
   free_pt ptr;
   rewrite_slprop (llist (next hd) tl) (llist (next (L.hd l)) (L.tl l)) (fun _ -> ());
   return (data c)
+*)
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index fc19e11cdc7..29d486360cb 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -103,6 +103,15 @@ let mk_node'
 
 let mk_node value next = Ghost.hide (Mknode (mk_node' (Ghost.reveal value) (Ghost.reveal next)))
 
+let mk_node_tot value next = Mknode (on_domain node_field (mk_node'_f value next))
+
+let mk_node_tot_mk_node value next = ()
+
+open Steel.C.PCM
+module P = FStar.PCM
+
+let mk_node_refine value next = ()
+
 let _value
 : node_pcm `connection` opt_pcm #int
 = unroll_conn `connection_compose` struct_field node_fields_pcm Value

From fb5cc152d1f4bdbc28af61ed57d2bfe003eddecf Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 11:28:11 -0700
Subject: [PATCH 120/513] Try start llist_set_succ

---
 examples/steel/arraystructs/LList.fst | 161 +++++++++++++++++++++++---
 1 file changed, 147 insertions(+), 14 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index d1d80dd524d..8f8fa419ebf 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -78,7 +78,7 @@ let pts_to_llist_cons (value: int) (next: ptr) (tl: cells)
   (r `pts_to` mk_node (some value) (some next)) `star`
   (next `pts_to_llist` Ghost.hide tl)
 
-let rec pts_to_llist ([@@@smt_fallback] p:ptr) ([@@@smt_fallback] l:Ghost.erased cells)
+let rec pts_to_llist (p:ptr) ([@@@smt_fallback] l:Ghost.erased cells)
 : Tot vprop (decreases (List.length l))
 = match Ghost.reveal l with
   | [] -> vpure (p == None)
@@ -101,7 +101,6 @@ let pts_to_llist_cons_eq (p:ptr) (value:int) (next:ptr) (tl:cells)
   | (value, next) :: tl ->
     vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
     pts_to_llist_cons value next tl pts_to_llist p)) 
-    // TODO Why do I have to keep the match around?
 
 let pts_to_llist_cons_eq' (p: ptr) value (next:ptr) tl prf
 : Lemma (pts_to_llist_cons value next tl pts_to_llist p prf ==
@@ -193,11 +192,12 @@ let cells_set_hd x (l: cells) = match l with
   | [] -> []
   | (_, next) :: l' -> (x, next) :: l'
 
-/// Mutate the head of a list
+val exfalso (#opened:inames) (p q:vprop) (r:prop)
+: SteelGhostF unit opened p (fun _ -> q) (requires fun _ -> False) (ensures fun _ _ _ -> r)
 
-// TODO does this exist already?
-assume val exfalso (#opened:inames) (p:vprop) (q:prop)
-: SteelGhost unit opened emp (fun _ -> p) (requires fun _ -> False) (ensures fun _ _ _ -> q)
+let exfalso (#opened:inames) (p q:vprop) (r:prop)
+: SteelGhostF unit opened p (fun _ -> q) (requires fun _ -> False) (ensures fun _ _ _ -> r)
+= change_slprop_rel p q (fun _ _ -> r) (fun _ -> ())
 
 val pts_to_llist_nullptr (#opened:inames) (p:ptr) (l:Ghost.erased cells)
 : SteelGhost unit opened
@@ -213,8 +213,7 @@ let pts_to_llist_nullptr p l =
     change_equal_slprop (p `pts_to_llist` l) (None `pts_to_llist` ((value, next) :: tl));
     let r = elim_llist_cons None value next tl in
     assert (None == Some r);
-    sladmit() // TODO
-    //exfalso (None `pts_to_llist` []) (Ghost.reveal l == [])
+    exfalso _ _ (Ghost.reveal l == [])
 
 [@@erasable]
 noeq type pts_to_llist_res = {
@@ -237,19 +236,24 @@ let pts_to_llist_some p l =
   | [] ->
     change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` []);
     assert (Some? p /\ p == None);
-    sladmit() // TODO
+    exfalso _ _ 
+      (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm /\
+       Ghost.reveal l == ((res.value, res.next) :: res.tl))
   | (value, next) :: tl ->
     change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
     {value; next; tl}
 
-val set_hd (p:ptr) (l:cells) (value:int)
+val set_hd (p:ptr) (l:Ghost.erased cells) (value:int)
 : SteelT unit
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_hd value l)
 
 let set_hd p l new_value =
   match p with
-  | None -> pts_to_llist_nullptr p l; return ()
+  | None -> 
+    pts_to_llist_nullptr p l;
+    change_equal_slprop (None `pts_to_llist` []) (p `pts_to_llist` []);
+    return ()
   | Some r ->
     let res = pts_to_llist_some p l in
     let value: Ghost.erased int = Ghost.hide res.value in
@@ -259,8 +263,8 @@ let set_hd p l new_value =
     //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
     //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
     change_equal_slprop (p `pts_to_llist` l)
-      (Some r `pts_to_llist`
-       Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
+      (Some r `pts_to_llist` _);
+       //Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
     let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
     let r: ref node node_pcm = r in
     //assert (Ghost.reveal r' == r);
@@ -271,10 +275,139 @@ let set_hd p l new_value =
     r_value `opt_write` new_value;
     unaddr_of_value r r_value;
     intro_llist_cons r new_value next tl;
-    //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
+    change_equal_slprop (Some r `pts_to_llist` _) (p `pts_to_llist` _);
     //sladmit(); return ()
     return ()
 
+// TODO try not to constrain postresources (e.g. in _nullptr; e.g. in intro_llist_cons, take extra p and precondition Some r == p)
+// for the presentation, write write code for set_hd
+// based on assume val for needed selectors, then solve assumes
+
+let rec cells_set_nth (n:nat) (value:int) (l:cells) : Tot cells (decreases n) =
+  if n = 0 then cells_set_hd value l
+  else match l with
+  | [] -> []
+  | hd :: tl -> hd :: cells_set_nth (n - 1) value tl
+
+let rec cells_set_nth_nil n value
+: Lemma (ensures cells_set_nth n value [] == []) (decreases n)
+= if n = 0 then () else cells_set_nth_nil (n - 1) value
+
+let llist_setter (n:nat) =
+  p:ptr -> l:Ghost.erased cells -> value:int ->
+  SteelT unit
+    (p `pts_to_llist` l)
+    (fun _ -> p `pts_to_llist` cells_set_nth n value l)
+
+let llist_set_zero: llist_setter 0 = set_hd
+
+(*
+let aux n (ih: llist_setter n) (p: ptr) (l: Ghost.erased cells) (new_value: int)
+: SteelT unit
+    (p `pts_to_llist` l)
+    (fun _ -> p `pts_to_llist` cells_set_nth (n + 1) new_value l)
+= assume (Some? p);
+  // match p with
+  // | None ->
+  //   pts_to_llist_nullptr p l;
+  //   cells_set_nth_nil (n + 1) value;
+  //   change_equal_slprop
+  //     (None `pts_to_llist` [])
+  //     (p `pts_to_llist` cells_set_nth (n + 1) value l);
+  //   return ()
+  // | Some r ->
+  let Some r = p in
+    let res = pts_to_llist_some p l in
+    let value: Ghost.erased int = Ghost.hide res.value in
+    let next: Ghost.erased ptr = Ghost.hide res.next in
+    let tl: Ghost.erased cells = Ghost.hide res.tl in
+    //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
+    //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
+    //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
+    change_equal_slprop (p `pts_to_llist` l)
+      (Some r `pts_to_llist`
+       Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
+    let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
+    let r: ref node node_pcm = r in
+    change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
+      (r `pts_to` mk_node (some value) (some next));
+    let r_next = addr_of_next r in
+    let q: ptr = opt_read r_next in
+    assert (q == Ghost.reveal next);
+    unaddr_of_next r r_next;
+    change_equal_slprop (Ghost.reveal next `pts_to_llist` _) (q `pts_to_llist` _);
+    ih q tl new_value;
+    change_equal_slprop (q `pts_to_llist` _) (Ghost.reveal next `pts_to_llist` _);
+    intro_llist_cons r (Ghost.reveal value) (Ghost.reveal next) _;
+//val intro_llist_cons
+//  (#opened:inames) (r: ref node node_pcm)
+//  (value: int) (next: ptr)
+//  (tl: cells)
+//: SteelGhostT unit opened
+//    ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
+//    (fun _ -> Some r `pts_to_llist` ((value, next)::tl))
+    sladmit(); return ()
+    // //assert (Ghost.reveal r' == r);
+    // //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
+    // let r_value = addr_of_value r in
+    // r_value `opt_write` new_value;
+    // unaddr_of_value r r_value;
+    // intro_llist_cons r new_value next tl;
+    // //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
+    // //sladmit(); return ()
+    // return ()
+
+let llist_set_succ n (ih: llist_setter n): llist_setter (n + 1) =
+  let aux (p: ptr) (l: Ghost.erased cells) (value: int)
+  : SteelT unit
+      (p `pts_to_llist` l)
+      (fun _ -> p `pts_to_llist` cells_set_nth (n + 1) value l)
+  = assume (Some? p);
+    // match p with
+    // | None ->
+    //   pts_to_llist_nullptr p l;
+    //   cells_set_nth_nil (n + 1) value;
+    //   change_equal_slprop
+    //     (None `pts_to_llist` [])
+    //     (p `pts_to_llist` cells_set_nth (n + 1) value l);
+    //   return ()
+    // | Some r ->
+    let Some r = p in
+      let res = pts_to_llist_some p l in
+      let value: Ghost.erased int = Ghost.hide res.value in
+      let next: Ghost.erased ptr = Ghost.hide res.next in
+      let tl: Ghost.erased cells = Ghost.hide res.tl in
+      //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
+      //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
+      //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
+      change_equal_slprop (p `pts_to_llist` l)
+        (Some r `pts_to_llist`
+         Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
+      let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
+      let r: ref node node_pcm = r in
+      change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
+        (r `pts_to` mk_node (some value) (some next));
+      let r_next = addr_of_next r in
+      let q: ptr = opt_read r_next in
+      unaddr_of_next r r_next;
+      //ih q tl value;
+      sladmit(); return ()
+      // //assert (Ghost.reveal r' == r);
+      // //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
+      // let r_value = addr_of_value r in
+      // r_value `opt_write` new_value;
+      // unaddr_of_value r r_value;
+      // intro_llist_cons r new_value next tl;
+      // //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
+      // //sladmit(); return ()
+      // return ()
+  in aux
+
+*)
+
+// TODO look at #2319, construct module of (possibly null) pointers
+// (define pts_to_or_null; can compare against null only if points to non-unit)
+
 // Mutate the kth element of a list (of fixed k)
 // 
 // t k = type of functions that mutate kth element of a list

From 020f793db305b4e8ebb7c3d2cedb89509954759b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 13:09:22 -0700
Subject: [PATCH 121/513] Simplify LList example

---
 examples/steel/arraystructs/LList.fst | 62 ++++++++++++---------------
 1 file changed, 27 insertions(+), 35 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 8f8fa419ebf..2a6264b7225 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -120,22 +120,24 @@ let intro_llist_nil () =
   change_equal_slprop _ (None `pts_to_llist` [])
   
 val intro_llist_cons
-  (#opened:inames) (r: ref node node_pcm)
+  (#opened:inames) (r: ref node node_pcm) (p: ptr)
   (value: int) (next: ptr)
   (tl: cells)
-: SteelGhostT unit opened
+: SteelGhost unit opened
     ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
-    (fun _ -> Some r `pts_to_llist` ((value, next)::tl))
+    (fun _ -> p `pts_to_llist` ((value, next)::tl))
+    (requires fun _ -> p == Some r)
+    (ensures fun _ _ _ -> True)
   
-let intro_llist_cons r value next tl = 
-  let p: ptr = Some r in
+let intro_llist_cons r p' value next tl = 
+  let p = Some r in
   intro_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
   intro_vdep (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
     (r `pts_to` (mk_node (some value) (some next)) `star`
      (next `pts_to_llist` tl))
     (pts_to_llist_cons value next tl pts_to_llist p);
   pts_to_llist_cons_eq p value next tl;
-  change_equal_slprop _ (Some r `pts_to_llist` ((value, next)::tl))
+  change_equal_slprop _ (p' `pts_to_llist` ((value, next)::tl))
 
 val elim_llist_cons
   (#opened:inames) (p: ptr)
@@ -185,35 +187,37 @@ val push (p:ptr) (l:Ghost.erased cells) (value:int)
 let push p l value =
   let cell: int & ptr = (value, p) in
   let r = ref_alloc node_pcm (mk_node_tot (Some value) (Some p)) in
-  intro_llist_cons r value p l;
+  intro_llist_cons r (Some r) value p l;
   return (Some r, Ghost.hide (cell :: l))
   
 let cells_set_hd x (l: cells) = match l with
   | [] -> []
   | (_, next) :: l' -> (x, next) :: l'
 
-val exfalso (#opened:inames) (p q:vprop) (r:prop)
-: SteelGhostF unit opened p (fun _ -> q) (requires fun _ -> False) (ensures fun _ _ _ -> r)
+val exfalso (#opened:inames) (p:vprop) (q:'a -> vprop) (r:'a -> prop)
+: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
 
-let exfalso (#opened:inames) (p q:vprop) (r:prop)
-: SteelGhostF unit opened p (fun _ -> q) (requires fun _ -> False) (ensures fun _ _ _ -> r)
-= change_slprop_rel p q (fun _ _ -> r) (fun _ -> ())
+let exfalso (#opened:inames) (p:vprop) (q:'a -> vprop) (r:'a -> prop)
+: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
+= let x: 'a = FStar.IndefiniteDescription.indefinite_description_tot 'a (fun _ -> True) in
+  change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
+  x
 
 val pts_to_llist_nullptr (#opened:inames) (p:ptr) (l:Ghost.erased cells)
 : SteelGhost unit opened
     (p `pts_to_llist` l) 
-    (fun _ -> None `pts_to_llist` [])
+    (fun _ -> p `pts_to_llist` l)
     (requires fun _ -> p == None)
     (ensures fun _ _ _ -> Ghost.reveal l == [])
 
 let pts_to_llist_nullptr p l =
   match Ghost.reveal l with
-  | [] -> change_equal_slprop (p `pts_to_llist` l) (None `pts_to_llist` [])
+  | [] -> change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` l) // TODO why can't just put ()
   | (value, next) :: tl ->
     change_equal_slprop (p `pts_to_llist` l) (None `pts_to_llist` ((value, next) :: tl));
     let r = elim_llist_cons None value next tl in
     assert (None == Some r);
-    exfalso _ _ (Ghost.reveal l == [])
+    exfalso _ _ (fun _ -> Ghost.reveal l == [])
 
 [@@erasable]
 noeq type pts_to_llist_res = {
@@ -236,8 +240,8 @@ let pts_to_llist_some p l =
   | [] ->
     change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` []);
     assert (Some? p /\ p == None);
-    exfalso _ _ 
-      (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm /\
+    exfalso _ _
+      (fun res -> Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm /\
        Ghost.reveal l == ((res.value, res.next) :: res.tl))
   | (value, next) :: tl ->
     change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
@@ -250,36 +254,24 @@ val set_hd (p:ptr) (l:Ghost.erased cells) (value:int)
 
 let set_hd p l new_value =
   match p with
-  | None -> 
-    pts_to_llist_nullptr p l;
-    change_equal_slprop (None `pts_to_llist` []) (p `pts_to_llist` []);
-    return ()
+  | None -> pts_to_llist_nullptr p l; sladmit()
   | Some r ->
     let res = pts_to_llist_some p l in
     let value: Ghost.erased int = Ghost.hide res.value in
     let next: Ghost.erased ptr = Ghost.hide res.next in
     let tl: Ghost.erased cells = Ghost.hide res.tl in
-    //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
-    //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
-    //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
-    change_equal_slprop (p `pts_to_llist` l)
-      (Some r `pts_to_llist` _);
-       //Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
-    let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
+    change_equal_slprop (p `pts_to_llist` _) (p `pts_to_llist` _);
+    let r' = elim_llist_cons p (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
     let r: ref node node_pcm = r in
-    //assert (Ghost.reveal r' == r);
-    //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
-    change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
+    change_equal_slprop
+      (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
       (r `pts_to` mk_node (some value) (some next));
     let r_value = addr_of_value r in
     r_value `opt_write` new_value;
     unaddr_of_value r r_value;
-    intro_llist_cons r new_value next tl;
-    change_equal_slprop (Some r `pts_to_llist` _) (p `pts_to_llist` _);
-    //sladmit(); return ()
+    intro_llist_cons r p new_value next tl;
     return ()
 
-// TODO try not to constrain postresources (e.g. in _nullptr; e.g. in intro_llist_cons, take extra p and precondition Some r == p)
 // for the presentation, write write code for set_hd
 // based on assume val for needed selectors, then solve assumes
 

From 8caf3ebeaa520f2cc8b45fe97ed5901c710576cc Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 13:09:33 -0700
Subject: [PATCH 122/513] Add Steel.C.Ptr.fst

---
 examples/steel/arraystructs/Steel.C.Ptr.fst | 148 ++++++++++++++++++++
 1 file changed, 148 insertions(+)
 create mode 100644 examples/steel/arraystructs/Steel.C.Ptr.fst

diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
new file mode 100644
index 00000000000..eb40985fb4d
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -0,0 +1,148 @@
+module Steel.C.Ptr
+
+module P = FStar.PCM
+module R = Steel.C.Ref
+open Steel.Memory
+open Steel.Effect.Atomic
+open Steel.Effect
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Ref
+open Steel.Effect
+
+let vpure_sel'
+  (p: prop)
+: Tot (selector' (squash p) (Steel.Memory.pure p))
+= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
+
+let vpure_sel
+  (p: prop)
+: Tot (selector (squash p) (Steel.Memory.pure p))
+= vpure_sel' p
+
+[@@ __steel_reduce__]
+let vpure'
+  (p: prop)
+: GTot vprop'
+= {
+  hp = Steel.Memory.pure p;
+  t = squash p;
+  sel = vpure_sel p;
+}
+
+[@@ __steel_reduce__]
+let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
+
+let intro_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    emp
+    (fun _ -> vpure p)
+    (fun _ -> p)
+    (fun _ _ h' -> p)
+=
+  change_slprop_rel
+    emp
+    (vpure p)
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m)
+
+let elim_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    (vpure p)
+    (fun _ -> emp)
+    (fun _ -> True)
+    (fun _ _ _ -> p)
+=
+  change_slprop_rel
+    (vpure p)
+    emp
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
+
+// ----------------------------------------
+
+val ptr (a: Type u#0) (b: Type u#b) : Type u#b
+let ptr a b = option (ref' a b)
+
+let nonnull (p: ptr 'a 'b) (pb: pcm 'b): prop = Some? p /\ pcm_of_ref' (Some?.v p) == pb
+
+let pts_to_dep (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b) (prf: squash (nonnull p pb))
+= let r: ref 'a pb = Some?.v p in r `pts_to` v
+
+val pts_to (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
+let pts_to p pb v = vpure (nonnull p pb) `vdep` pts_to_dep p pb v
+
+val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
+let pts_to_or_null p pb v = if None? p then vpure True else pts_to p pb v
+
+val nullptr (#a:Type) (#b:Type) : ptr a b
+let nullptr #a #b = None
+
+val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
+let vptr r = Some r
+
+val intro_pts_to
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
+: Steel (ptr 'a 'b)
+    (r `R.pts_to` v)
+    (fun p -> pts_to p pb v)
+    (requires fun _ -> True)
+    (ensures fun _ p _ -> p == vptr r)
+let intro_pts_to #a #b #pb #v r =
+  let p = Some r in
+  intro_vpure (nonnull p pb);
+  intro_vdep (vpure (nonnull p pb)) (r `R.pts_to` v) (pts_to_dep p pb v);
+  change_equal_slprop (_ `vdep` _) (pts_to p pb v);
+  return p
+
+val elim_pts_to
+  (#opened:inames) (#pb: pcm 'b) (#v: Ghost.erased 'b)
+  (r: ref 'a pb) (p: ptr 'a 'b)
+: SteelGhost unit opened
+    (pts_to p pb v)
+    (fun _ -> r `R.pts_to` v)
+    (requires fun _ -> p == vptr r)
+    (ensures fun _ _ _ -> True)
+let elim_pts_to #a #b #opened #pb #v r p =
+  change_equal_slprop (pts_to p pb v) (vpure (nonnull p pb) `vdep` pts_to_dep p pb v);
+  let prf = elim_vdep _ _ in
+  elim_vpure _;
+  change_equal_slprop (pts_to_dep p pb v prf) _
+
+val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
+  (pb: pcm b) (v: Ghost.erased b)
+: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb v)
+let intro_pts_to_or_null_nullptr #a pb v = intro_vpure True
+
+val intro_pts_to_or_null
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: SteelT (ptr 'a 'b)
+    (pts_to p pb v)
+    (fun p -> pts_to_or_null p pb v)
+let intro_pts_to_or_null #a #b #pb #v p =
+  change_equal_slprop (pts_to p pb v) (pts_to_or_null p pb v);
+  return p
+
+val elim_pts_to_or_null
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: Steel (ptr 'a 'b)
+    (pts_to_or_null p pb v)
+    (fun p -> pts_to p pb v)
+    (requires fun _ -> p =!= nullptr)
+    (ensures fun _ _ _ -> True)
+let elim_pts_to_or_null #a #b #pb #v p =
+  change_equal_slprop (pts_to_or_null p pb v) (pts_to p pb v);
+  return p
+
+val is_null
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: Steel bool
+    (pts_to_or_null p pb v)
+    (fun _ -> pts_to_or_null p pb v)
+    (requires fun _ -> Ghost.reveal v =!= one pb)
+    (ensures fun _ b _ -> b <==> p == nullptr)
+let is_null #a #b #pb #v p = return (None? p)

From 4707d37daf183d351eb91fe85af319bdf987f286 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 13:14:47 -0700
Subject: [PATCH 123/513] Add Steel.C.Ptr.fsti

---
 examples/steel/arraystructs/Steel.C.Ptr.fst  | 42 -------------
 examples/steel/arraystructs/Steel.C.Ptr.fsti | 64 ++++++++++++++++++++
 2 files changed, 64 insertions(+), 42 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Ptr.fsti

diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
index eb40985fb4d..6723d34a2e7 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fst
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -65,7 +65,6 @@ let elim_vpure
 
 // ----------------------------------------
 
-val ptr (a: Type u#0) (b: Type u#b) : Type u#b
 let ptr a b = option (ref' a b)
 
 let nonnull (p: ptr 'a 'b) (pb: pcm 'b): prop = Some? p /\ pcm_of_ref' (Some?.v p) == pb
@@ -73,25 +72,14 @@ let nonnull (p: ptr 'a 'b) (pb: pcm 'b): prop = Some? p /\ pcm_of_ref' (Some?.v
 let pts_to_dep (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b) (prf: squash (nonnull p pb))
 = let r: ref 'a pb = Some?.v p in r `pts_to` v
 
-val pts_to (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
 let pts_to p pb v = vpure (nonnull p pb) `vdep` pts_to_dep p pb v
 
-val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
 let pts_to_or_null p pb v = if None? p then vpure True else pts_to p pb v
 
-val nullptr (#a:Type) (#b:Type) : ptr a b
 let nullptr #a #b = None
 
-val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
 let vptr r = Some r
 
-val intro_pts_to
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
-: Steel (ptr 'a 'b)
-    (r `R.pts_to` v)
-    (fun p -> pts_to p pb v)
-    (requires fun _ -> True)
-    (ensures fun _ p _ -> p == vptr r)
 let intro_pts_to #a #b #pb #v r =
   let p = Some r in
   intro_vpure (nonnull p pb);
@@ -99,50 +87,20 @@ let intro_pts_to #a #b #pb #v r =
   change_equal_slprop (_ `vdep` _) (pts_to p pb v);
   return p
 
-val elim_pts_to
-  (#opened:inames) (#pb: pcm 'b) (#v: Ghost.erased 'b)
-  (r: ref 'a pb) (p: ptr 'a 'b)
-: SteelGhost unit opened
-    (pts_to p pb v)
-    (fun _ -> r `R.pts_to` v)
-    (requires fun _ -> p == vptr r)
-    (ensures fun _ _ _ -> True)
 let elim_pts_to #a #b #opened #pb #v r p =
   change_equal_slprop (pts_to p pb v) (vpure (nonnull p pb) `vdep` pts_to_dep p pb v);
   let prf = elim_vdep _ _ in
   elim_vpure _;
   change_equal_slprop (pts_to_dep p pb v prf) _
 
-val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
-  (pb: pcm b) (v: Ghost.erased b)
-: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb v)
 let intro_pts_to_or_null_nullptr #a pb v = intro_vpure True
 
-val intro_pts_to_or_null
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: SteelT (ptr 'a 'b)
-    (pts_to p pb v)
-    (fun p -> pts_to_or_null p pb v)
 let intro_pts_to_or_null #a #b #pb #v p =
   change_equal_slprop (pts_to p pb v) (pts_to_or_null p pb v);
   return p
 
-val elim_pts_to_or_null
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: Steel (ptr 'a 'b)
-    (pts_to_or_null p pb v)
-    (fun p -> pts_to p pb v)
-    (requires fun _ -> p =!= nullptr)
-    (ensures fun _ _ _ -> True)
 let elim_pts_to_or_null #a #b #pb #v p =
   change_equal_slprop (pts_to_or_null p pb v) (pts_to p pb v);
   return p
 
-val is_null
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: Steel bool
-    (pts_to_or_null p pb v)
-    (fun _ -> pts_to_or_null p pb v)
-    (requires fun _ -> Ghost.reveal v =!= one pb)
-    (ensures fun _ b _ -> b <==> p == nullptr)
 let is_null #a #b #pb #v p = return (None? p)
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fsti b/examples/steel/arraystructs/Steel.C.Ptr.fsti
new file mode 100644
index 00000000000..f5842723502
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fsti
@@ -0,0 +1,64 @@
+module Steel.C.Ptr
+
+module P = FStar.PCM
+module R = Steel.C.Ref
+open Steel.Memory
+open Steel.Effect.Atomic
+open Steel.Effect
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Ref
+open Steel.Effect
+
+val ptr (a: Type u#0) (b: Type u#b) : Type u#b
+
+val pts_to (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
+
+val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
+
+val nullptr (#a:Type) (#b:Type) : ptr a b
+
+val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
+
+val intro_pts_to
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
+: Steel (ptr 'a 'b)
+    (r `R.pts_to` v)
+    (fun p -> pts_to p pb v)
+    (requires fun _ -> True)
+    (ensures fun _ p _ -> p == vptr r)
+
+val elim_pts_to
+  (#opened:inames) (#pb: pcm 'b) (#v: Ghost.erased 'b)
+  (r: ref 'a pb) (p: ptr 'a 'b)
+: SteelGhost unit opened
+    (pts_to p pb v)
+    (fun _ -> r `R.pts_to` v)
+    (requires fun _ -> p == vptr r)
+    (ensures fun _ _ _ -> True)
+
+val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
+  (pb: pcm b) (v: Ghost.erased b)
+: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb v)
+
+val intro_pts_to_or_null
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: SteelT (ptr 'a 'b)
+    (pts_to p pb v)
+    (fun p -> pts_to_or_null p pb v)
+
+val elim_pts_to_or_null
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: Steel (ptr 'a 'b)
+    (pts_to_or_null p pb v)
+    (fun p -> pts_to p pb v)
+    (requires fun _ -> p =!= nullptr)
+    (ensures fun _ _ _ -> True)
+
+val is_null
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: Steel bool
+    (pts_to_or_null p pb v)
+    (fun _ -> pts_to_or_null p pb v)
+    (requires fun _ -> Ghost.reveal v =!= one pb)
+    (ensures fun _ b _ -> b <==> p == nullptr)

From bf071dbf69791838694971776abf6d37592f446c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 20 Jul 2021 13:49:09 -0700
Subject: [PATCH 124/513] read, write with selectors

---
 examples/steel/arraystructs/Steel.C.Frac.fsti | 33 ++++++++++++++-
 examples/steel/arraystructs/Steel.C.Opt.fsti  | 29 +++++++++++++
 examples/steel/arraystructs/Steel.C.Ref.fsti  | 42 ++++++++++++++++++-
 3 files changed, 101 insertions(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Frac.fsti b/examples/steel/arraystructs/Steel.C.Frac.fsti
index bccaeb3dc83..0ced9e32120 100644
--- a/examples/steel/arraystructs/Steel.C.Frac.fsti
+++ b/examples/steel/arraystructs/Steel.C.Frac.fsti
@@ -8,7 +8,7 @@ open Steel.Effect
 /// Fractional permissions: from Steel.HigherReference
 open Steel.FractionalPermission
 
-let fractional (a:Type u#1) = option (a & perm)
+let fractional (a:Type u#a) = option (a & perm)
 
 let fractional_composable #a : P.symrel (fractional a) =
   fun (f0 f1:fractional a) ->
@@ -77,3 +77,34 @@ let frac_view
   to_view_frame = (fun v frame -> ());
 }
 
+let frac_read_sel
+  (#a: Type u#0) (#b: Type u#0)
+  (#p: perm)
+  (r: ref a (pcm_frac #b))
+: Steel b
+  (pts_to_view r (frac_view _ p))
+  (fun _ -> pts_to_view r (frac_view _ p))
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (pts_to_view r (frac_view _ p)) /\
+    res == h' (pts_to_view r (frac_view _ p))
+  ))
+= ref_read_sel r (frac_view _ p)
+
+let frac_write_sel
+  (#a: Type u#0) (#b: Type u#0)
+  (#p: perm)
+  (r: ref a (pcm_frac #b))
+  (w: b)
+: Steel unit
+  (pts_to_view r (frac_view _ p))
+  (fun _ -> pts_to_view r (frac_view _ p))
+  (requires (fun _ -> p == full_perm))
+  (ensures (fun h _ h' ->
+    w == h' (pts_to_view r (frac_view _ p))
+  ))
+=
+  let _ = pts_to_view_elim r (frac_view _ _) in
+  frac_pcm_write r _ w;
+  pts_to_view_intro r _ (frac_view _ p) w
+
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index 4c13771c3a9..e618fedde01 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -105,3 +105,32 @@ val opt_pcm_read
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Ghost.reveal x == Some y))
+
+let opt_read_sel
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a (opt_pcm #b))
+: Steel b
+  (pts_to_view r (opt_view b))
+  (fun _ -> pts_to_view r (opt_view b))
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (pts_to_view r (opt_view b)) /\
+    res == h' (pts_to_view r (opt_view b))
+  ))
+= ref_read_sel r (opt_view b)
+
+let opt_write_sel
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a (opt_pcm #b))
+  (w: b)
+: Steel unit
+  (pts_to_view r (opt_view b))
+  (fun _ -> pts_to_view r (opt_view b))
+  (requires (fun _ -> True))
+  (ensures (fun _ _ h' ->
+    w == h' (pts_to_view r (opt_view b))
+  ))
+=
+  let _ = pts_to_view_elim r (opt_view _) in
+  opt_pcm_write r _ w;
+  pts_to_view_intro r _ (opt_view _) w
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 12495753616..0c74d4c6c34 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -113,7 +113,7 @@ type sel_view
   (view: Type u#b)
 = {
   to_view_prop: (carrier -> Tot prop);
-  to_view: (refine carrier to_view_prop -> GTot view);
+  to_view: (refine carrier to_view_prop -> Tot view);
   to_carrier: (view -> GTot (refine carrier to_view_prop));
   to_carrier_not_one:
     (x: view) ->
@@ -325,11 +325,14 @@ let pts_to_view_elim
     (fun res -> pts_to r res)
     (fun _ -> True)
     (fun h res _ ->
-      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw))
+      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw)) /\
+      vw.to_view_prop res /\
+      ~ (Ghost.reveal res == one p)
     )
 =
   let g : Ghost.erased c = A.gget (pts_to_view r vw) in
   let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
+  vw.to_carrier_not_one g;
   A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
   let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
   intro_vdep2
@@ -348,3 +351,38 @@ let pts_to_view_elim
     );
   res
 
+let compatible_elim'
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x y: a)
+  (sq: squash (compatible pcm x y))
+: GTot (frame: a {
+    composable pcm x frame /\
+    op pcm frame x == y
+  })
+= compatible_elim pcm x y
+
+let ref_read_sel
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (vw: sel_view p c)
+: Steel c
+  (pts_to_view r vw)
+  (fun _ -> pts_to_view r vw)
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (pts_to_view r vw) /\
+    res == h' (pts_to_view r vw)
+  ))
+=
+  let _v = pts_to_view_elim r vw in
+  let v = ref_read r in
+  let sq : squash (compatible p _v v) = () in
+  let frame = Ghost.hide (compatible_elim' p _v v sq) in
+  vw.to_view_frame (vw.to_view _v) frame ;
+  let res = vw.to_view v in
+  pts_to_view_intro r _v vw res;
+  A.return res
+
+(* write cannot be defined generically because of p_refine *)

From e0464e979499a2ca61cc6edf52d45470860dfb35 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 14:00:21 -0700
Subject: [PATCH 125/513] Rewrite most of LList using ptr

---
 examples/steel/arraystructs/LList.fst        | 205 ++++++++-----------
 examples/steel/arraystructs/ListNode.fst     |  27 +--
 examples/steel/arraystructs/ListNode.fsti    |  23 ++-
 examples/steel/arraystructs/Steel.C.Ptr.fst  |   5 +
 examples/steel/arraystructs/Steel.C.Ptr.fsti |  14 +-
 5 files changed, 126 insertions(+), 148 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 2a6264b7225..387d3759bfa 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -3,12 +3,14 @@ open Steel.Memory
 open Steel.Effect.Atomic
 open Steel.Effect
 
+module R = Steel.C.Ref
 open Steel.C.Ref
+open Steel.C.Ptr
 open Steel.C.PCM
 open Steel.C.Opt
 open Steel.C.Connection
 
-open ListNode
+/// TODO move and dedup with Steel.C.Ptr.fst
 
 let vpure_sel'
   (p: prop)
@@ -63,112 +65,62 @@ let elim_vpure
     (fun _ _ -> p)
     (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
 
-let ptr = option (ref' node node)
-let cells = list (int & ptr)
-
-let pts_to_llist_cons (value: int) (next: ptr) (tl: cells)
-  (pts_to_llist:(
-    ptr ->
-    l:Ghost.erased cells{List.length l < List.length ((value, next) :: tl)} ->
-    Tot vprop))
-  (p: option (ref' node node))
-  (prf: squash (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
-: vprop
-= let r: ref node node_pcm = Some?.v p in
-  (r `pts_to` mk_node (some value) (some next)) `star`
-  (next `pts_to_llist` Ghost.hide tl)
-
-let rec pts_to_llist (p:ptr) ([@@@smt_fallback] l:Ghost.erased cells)
+// ----------------------------------------
+
+open ListNode
+
+let cells = list (int & ptr node node)
+
+let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
 : Tot vprop (decreases (List.length l))
 = match Ghost.reveal l with
-  | [] -> vpure (p == None)
+  | [] -> vpure (p == nullptr)
   | (value, next) :: tl ->
-    vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
-    pts_to_llist_cons value next tl pts_to_llist p
+    pts_to p node_pcm (mk_node (some value) (some next)) `star`
+    (next `pts_to_llist` Ghost.hide tl)
 
 let pts_to_llist_nil_eq p
-: Lemma ((p `pts_to_llist` []) == vpure (p == None))
+: Lemma ((p `pts_to_llist` []) == vpure (p == nullptr))
   [SMTPat (p `pts_to_llist` [])]
 = ()
 
-let pts_to_llist_cons_eq (p:ptr) (value:int) (next:ptr) (tl:cells)
+let pts_to_llist_cons_eq (p:ptr node node) (value:int) (next:ptr node node) (tl:cells)
 : Lemma ((p `pts_to_llist` Ghost.hide ((value, next) :: tl)) == 
-    vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
-    pts_to_llist_cons value next tl pts_to_llist p)
-= assert_norm ((p `pts_to_llist` Ghost.hide ((value, next) :: tl)) == 
-  (match Ghost.reveal (Ghost.hide ((value, next) :: tl)) with
-  | [] -> vpure (p == None)
-  | (value, next) :: tl ->
-    vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
-    pts_to_llist_cons value next tl pts_to_llist p)) 
-
-let pts_to_llist_cons_eq' (p: ptr) value (next:ptr) tl prf
-: Lemma (pts_to_llist_cons value next tl pts_to_llist p prf ==
-    (let r: ref node node_pcm = Some?.v p in
-     (r `pts_to` mk_node (some (Ghost.hide value)) (some (Ghost.hide next))) `star`
-     (next `pts_to_llist` Ghost.hide tl)))
-= assert_norm (pts_to_llist_cons value next tl pts_to_llist p prf ==
-    (let r: ref node node_pcm = Some?.v p in
-     (r `pts_to` mk_node (some value) (some next)) `star`
-     (next `pts_to_llist` Ghost.hide tl)))
+    pts_to p node_pcm (mk_node (some value) (some next)) `star`
+    (next `pts_to_llist` Ghost.hide tl))
+= ()
 
-val intro_llist_nil : unit -> SteelT unit emp (fun _ -> None `pts_to_llist` [])
+val intro_llist_nil : unit -> SteelT unit emp (fun _ -> nullptr `pts_to_llist` [])
 
 let intro_llist_nil () =
-  intro_vpure (None #(ref' node node) == None);
-  pts_to_llist_nil_eq None;
-  change_equal_slprop _ (None `pts_to_llist` [])
+  intro_vpure (nullptr #node #node == nullptr);
+  pts_to_llist_nil_eq nullptr;
+  change_equal_slprop _ (nullptr `pts_to_llist` [])
   
 val intro_llist_cons
-  (#opened:inames) (r: ref node node_pcm) (p: ptr)
-  (value: int) (next: ptr)
+  (#opened:inames) (p: ptr node node)
+  (value: int) (next: ptr node node)
   (tl: cells)
-: SteelGhost unit opened
-    ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
+: SteelGhostT unit opened
+    ((pts_to p node_pcm (mk_node (some value) (some next))) `star` (next `pts_to_llist` tl))
     (fun _ -> p `pts_to_llist` ((value, next)::tl))
-    (requires fun _ -> p == Some r)
-    (ensures fun _ _ _ -> True)
   
-let intro_llist_cons r p' value next tl = 
-  let p = Some r in
-  intro_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
-  intro_vdep (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
-    (r `pts_to` (mk_node (some value) (some next)) `star`
-     (next `pts_to_llist` tl))
-    (pts_to_llist_cons value next tl pts_to_llist p);
-  pts_to_llist_cons_eq p value next tl;
-  change_equal_slprop _ (p' `pts_to_llist` ((value, next)::tl))
+let intro_llist_cons p' value next tl = change_equal_slprop _ _
 
 val elim_llist_cons
-  (#opened:inames) (p: ptr)
-  (value: int) (next: ptr) (tl: cells)
-: SteelGhost (Ghost.erased (ref node node_pcm)) opened
+  (#opened:inames) (p: ptr node node)
+  (value: int) (next: ptr node node) (tl: cells)
+: SteelGhostT unit opened
     (p `pts_to_llist` ((value, next)::tl))
-    (fun r ->
-      (r `pts_to` mk_node (some value) (some next)) `star`
+    (fun _ ->
+      (pts_to p node_pcm (mk_node (some value) (some next))) `star`
       (next `pts_to_llist` tl))
-    (requires fun _ -> True)
-    (ensures fun _ r _ -> p == Some (Ghost.reveal r))
 
 let elim_llist_cons p value next tl =
-  pts_to_llist_cons_eq p value next tl;
-  change_equal_slprop
-    (p `pts_to_llist` _)
-    (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm) `vdep`
-     pts_to_llist_cons value next tl pts_to_llist p);
-  let prf: Ghost.erased (t_of (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))) =
-    elim_vdep 
-      (vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm))
-      (pts_to_llist_cons value next tl pts_to_llist p)
-  in
-  elim_vpure (Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm);
-  pts_to_llist_cons_eq' p value next tl prf;
-  let r: Ghost.erased (ref node node_pcm) = Some?.v p in
   change_equal_slprop
-    (pts_to_llist_cons value next tl pts_to_llist p prf)
-    ((Ghost.reveal r `pts_to` mk_node (some value) (some next)) `star`
-     (next `pts_to_llist` tl));
-  r
+    (p `pts_to_llist` ((value, next)::tl)) // TODO why can't these be inferred?
+    ((pts_to p node_pcm (mk_node (some value) (some next))) `star`
+     (next `pts_to_llist` tl))
 
 let rec values (l:cells) : GTot (list int) =
   match l with
@@ -177,18 +129,19 @@ let rec values (l:cells) : GTot (list int) =
 
 #set-options "--ide_id_info_off"
 
-val push (p:ptr) (l:Ghost.erased cells) (value:int)
-: Steel (ptr & Ghost.erased cells)
+val push (p:ptr node node) (l:Ghost.erased cells) (value:int)
+: Steel (ptr node node & Ghost.erased cells)
     (p `pts_to_llist` l)
     (fun (p', l') -> p' `pts_to_llist` l')
     (requires fun _ -> True)
     (ensures fun _ (_, l') _ -> values l' == value :: values l)
 
 let push p l value =
-  let cell: int & ptr = (value, p) in
+  let cell: int & ptr node node = (value, p) in
   let r = ref_alloc node_pcm (mk_node_tot (Some value) (Some p)) in
-  intro_llist_cons r (Some r) value p l;
-  return (Some r, Ghost.hide (cell :: l))
+  let q = intro_pts_to r in
+  intro_llist_cons q value p l;
+  return (q, Ghost.hide (cell :: l))
   
 let cells_set_hd x (l: cells) = match l with
   | [] -> []
@@ -203,74 +156,80 @@ let exfalso (#opened:inames) (p:vprop) (q:'a -> vprop) (r:'a -> prop)
   change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
   x
 
-val pts_to_llist_nullptr (#opened:inames) (p:ptr) (l:Ghost.erased cells)
+val pts_to_llist_nullptr (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
 : SteelGhost unit opened
     (p `pts_to_llist` l) 
     (fun _ -> p `pts_to_llist` l)
-    (requires fun _ -> p == None)
+    (requires fun _ -> p == nullptr)
     (ensures fun _ _ _ -> Ghost.reveal l == [])
 
 let pts_to_llist_nullptr p l =
   match Ghost.reveal l with
   | [] -> change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` l) // TODO why can't just put ()
   | (value, next) :: tl ->
-    change_equal_slprop (p `pts_to_llist` l) (None `pts_to_llist` ((value, next) :: tl));
-    let r = elim_llist_cons None value next tl in
-    assert (None == Some r);
+    change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
+    let r = elim_llist_cons p value next tl in
+    pts_to_nonnull p;
+    assert (p =!= nullptr);
+    assert (p == nullptr);
     exfalso _ _ (fun _ -> Ghost.reveal l == [])
 
 [@@erasable]
 noeq type pts_to_llist_res = {
   value: int;
-  next: ptr;
+  next: ptr node node;
   tl: cells;
 }
 
-val pts_to_llist_some (#opened:inames) (p:ptr) (l:Ghost.erased cells)
+val pts_to_llist_some (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
 : SteelGhost pts_to_llist_res opened
     (p `pts_to_llist` l) 
     (fun res -> p `pts_to_llist` ((res.value, res.next) :: res.tl))
-    (requires fun _ -> Some? p)
-    (ensures fun _ res _ ->
-      Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm /\
-      Ghost.reveal l == ((res.value, res.next) :: res.tl))
+    (requires fun _ -> p =!= nullptr)
+    (ensures fun _ res _ -> Ghost.reveal l == ((res.value, res.next) :: res.tl))
 
 let pts_to_llist_some p l =
   match Ghost.reveal l with
   | [] ->
     change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` []);
-    assert (Some? p /\ p == None);
-    exfalso _ _
-      (fun res -> Some? p /\ pcm_of_ref' (Some?.v p) == node_pcm /\
-       Ghost.reveal l == ((res.value, res.next) :: res.tl))
+    assert (p == nullptr);
+    assert (p =!= nullptr);
+    exfalso _ _ (fun res -> Ghost.reveal l == ((res.value, res.next) :: res.tl))
   | (value, next) :: tl ->
     change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
     {value; next; tl}
 
-val set_hd (p:ptr) (l:Ghost.erased cells) (value:int)
+val set_hd (p:ptr node node) (l:Ghost.erased cells) (value:int)
 : SteelT unit
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_hd value l)
 
+// Problem: need (pts_to_or_null p pb v), where v =!= one, before can check whether it's null
+// Unclear how to rearrange pts_to_or_null
+
 let set_hd p l new_value =
-  match p with
-  | None -> pts_to_llist_nullptr p l; sladmit()
-  | Some r ->
-    let res = pts_to_llist_some p l in
-    let value: Ghost.erased int = Ghost.hide res.value in
-    let next: Ghost.erased ptr = Ghost.hide res.next in
-    let tl: Ghost.erased cells = Ghost.hide res.tl in
-    change_equal_slprop (p `pts_to_llist` _) (p `pts_to_llist` _);
-    let r' = elim_llist_cons p (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
-    let r: ref node node_pcm = r in
-    change_equal_slprop
-      (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
-      (r `pts_to` mk_node (some value) (some next));
-    let r_value = addr_of_value r in
-    r_value `opt_write` new_value;
-    unaddr_of_value r r_value;
-    intro_llist_cons r p new_value next tl;
-    return ()
+  //let b = is_null p in
+  if true then begin
+    //pts_to_llist_nullptr p l;
+    sladmit(); return ()
+  end else begin
+    sladmit(); return ()
+    //let res = pts_to_llist_some p l in
+    //let value: Ghost.erased int = Ghost.hide res.value in
+    //let next: Ghost.erased ptr = Ghost.hide res.next in
+    //let tl: Ghost.erased cells = Ghost.hide res.tl in
+    //change_equal_slprop (p `pts_to_llist` _) (p `pts_to_llist` _);
+    //let r' = elim_llist_cons p (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
+    //let r: ref node node_pcm = r in
+    //change_equal_slprop
+    //  (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
+    //  (r `pts_to` mk_node (some value) (some next));
+    //let r_value = addr_of_value r in
+    //r_value `opt_write` new_value;
+    //unaddr_of_value r r_value;
+    //intro_llist_cons r p new_value next tl;
+    //return ()
+  end
 
 // for the presentation, write write code for set_hd
 // based on assume val for needed selectors, then solve assumes
@@ -286,7 +245,7 @@ let rec cells_set_nth_nil n value
 = if n = 0 then () else cells_set_nth_nil (n - 1) value
 
 let llist_setter (n:nat) =
-  p:ptr -> l:Ghost.erased cells -> value:int ->
+  p:ptr node node -> l:Ghost.erased cells -> value:int ->
   SteelT unit
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_nth n value l)
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 29d486360cb..84b4de34276 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -7,6 +7,7 @@ module A = Steel.Effect.Atomic
 open Steel.Effect
 open Steel.C.Opt
 open Steel.C.PCM
+open Steel.C.Ptr
 open Steel.C.Ref
 open Steel.C.Connection
 open Steel.C.Struct
@@ -17,7 +18,7 @@ type node_field = | Value | Next
 
 let node_fields (node:Type u#0) k : Type u#0 = match k with
   | Value -> option int
-  | Next -> option (option (ref' node node))
+  | Next -> option (ptr node node)
 
 #push-options "--__no_positivity"
 noeq type node: Type u#0 =
@@ -28,7 +29,7 @@ let node': Type u#0 = restricted_t node_field (node_fields node)
 
 let node_fields_pcm k: pcm (node_fields node k) = match k with
   | Value -> opt_pcm #int
-  | Next -> opt_pcm #(option (ref' node node))
+  | Next -> opt_pcm #(ptr node node)
 
 let node_pcm': pcm node' = prod_pcm node_fields_pcm
 
@@ -88,7 +89,7 @@ let roll_conn: node_pcm' `connection` node_pcm =
 let unroll_conn: node_pcm `connection` node_pcm' =
   connection_of_isomorphism node_iso
 
-let mk_node'_f (value: option int) (next: option (option (ref' node node)))
+let mk_node'_f (value: option int) (next: option (ptr node node))
   (k: node_field)
 : node_fields node k
 = match k with
@@ -97,7 +98,7 @@ let mk_node'_f (value: option int) (next: option (option (ref' node node)))
   
 let mk_node'
   (value: Ghost.erased (option int))
-  (next: Ghost.erased (option (option (ref' node node))))
+  (next: Ghost.erased (option (ptr node node)))
 : Ghost.erased node'
 = Ghost.hide (on_domain node_field (mk_node'_f (Ghost.reveal value) (Ghost.reveal next)))
 
@@ -117,7 +118,7 @@ let _value
 = unroll_conn `connection_compose` struct_field node_fields_pcm Value
 
 let _next
-: node_pcm `connection` opt_pcm #(option (ref' node node))
+: node_pcm `connection` opt_pcm #(ptr node node)
 = unroll_conn `connection_compose` struct_field node_fields_pcm Next
 
 let one_next : Ghost.erased (option int) =
@@ -155,7 +156,7 @@ let mk_node_mk_node' value next
 
 let unroll_ref 
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
 : Steel (ref 'a node_pcm')
     (p `pts_to` mk_node value next)
@@ -169,7 +170,7 @@ let unroll_ref
 
 let roll_ref 
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm) (p': ref 'a node_pcm')
 : Steel unit
     (p' `pts_to` mk_node' value next)
@@ -181,7 +182,7 @@ let roll_ref
 
 let addr_of_value
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
 : Steel (ref 'a (opt_pcm #int))
     (p `pts_to` mk_node value next)
@@ -201,7 +202,7 @@ let addr_of_value
 
 let unaddr_of_value
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
   (q: ref 'a (opt_pcm #int))
 : Steel unit
@@ -217,9 +218,9 @@ let unaddr_of_value
 
 let addr_of_next
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #(option (ref' node node))))
+: Steel (ref 'a (opt_pcm #(ptr node node)))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
@@ -235,9 +236,9 @@ let addr_of_next
 
 let unaddr_of_next
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(option (ref' node node))))
+  (q: ref 'a (opt_pcm #(ptr node node)))
 : Steel unit
     ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
     (fun q -> p `pts_to` mk_node value next)
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index 5e2d7895c69..42c857cdc48 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -4,6 +4,7 @@ open Steel.Effect
 open PointStruct
 open Steel.C.PCM
 open Steel.C.Opt
+open Steel.C.Ptr
 open Steel.C.Ref
 open Steel.C.Connection
 module U = FStar.Universe
@@ -20,22 +21,22 @@ val node_pcm: pcm node
 
 val mk_node
   (i: Ghost.erased (option int))
-  (next: Ghost.erased (option (option (ref' node node))))
+  (next: Ghost.erased (option (ptr node node)))
 : Ghost.erased node
 
 val mk_node_tot
   (i: option int)
-  (next: option (option (ref' node node)))
+  (next: option (ptr node node))
 : node
 
-val mk_node_tot_mk_node (i: option int) (next: option (option (ref' node node)))
+val mk_node_tot_mk_node (i: option int) (next: option (ptr node node))
 : Lemma (mk_node_tot i next == Ghost.reveal (mk_node i next))
   [SMTPat (mk_node_tot i next)]
 
 open Steel.C.PCM
 module P = FStar.PCM
 
-val mk_node_refine (i: option int) (next: option (option (ref' node node)))
+val mk_node_refine (i: option int) (next: option (ptr node node))
 : Lemma
     (requires p_refine opt_pcm i /\ p_refine (opt_pcm) next)
     (ensures p_refine node_pcm (mk_node i next))
@@ -44,13 +45,13 @@ val mk_node_refine (i: option int) (next: option (option (ref' node node)))
 /// Lenses for fields
 
 val _value: node_pcm `connection` opt_pcm #int
-val _next: node_pcm `connection` opt_pcm #(option (ref' node node))
+val _next: node_pcm `connection` opt_pcm #(ptr node node)
 
 /// Taking pointers to the fields of a node
 
 val addr_of_value
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
 : Steel (ref 'a (opt_pcm #int))
     (p `pts_to` mk_node value next)
@@ -62,7 +63,7 @@ val addr_of_value
 
 val unaddr_of_value
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
   (q: ref 'a (opt_pcm #int))
 : Steel unit
@@ -73,9 +74,9 @@ val unaddr_of_value
 
 val addr_of_next
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #(option (ref' node node))))
+: Steel (ref 'a (opt_pcm #(ptr node node)))
     (p `pts_to` mk_node value next)
     (fun q ->
        (p `pts_to` mk_node value none) `star`
@@ -85,9 +86,9 @@ val addr_of_next
 
 val unaddr_of_next
   (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
+  (#next:Ghost.erased (option (ptr node node)))
   (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(option (ref' node node))))
+  (q: ref 'a (opt_pcm #(ptr node node)))
 : Steel unit
     ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
     (fun q -> p `pts_to` mk_node value next)
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
index 6723d34a2e7..e0183d21584 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fst
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -80,6 +80,11 @@ let nullptr #a #b = None
 
 let vptr r = Some r
 
+let nullptr_vptr_disjoint r = ()
+
+let pts_to_nonnull #opened #a #b #pb p v =
+  change_equal_slprop (pts_to p pb v) (pts_to p pb v) // TODO easier way to do this?
+
 let intro_pts_to #a #b #pb #v r =
   let p = Some r in
   intro_vpure (nonnull p pb);
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fsti b/examples/steel/arraystructs/Steel.C.Ptr.fsti
index f5842723502..ec2e68b2ca0 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fsti
@@ -12,7 +12,7 @@ open Steel.Effect
 
 val ptr (a: Type u#0) (b: Type u#b) : Type u#b
 
-val pts_to (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
+val pts_to (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: Ghost.erased 'b): vprop
 
 val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
 
@@ -20,6 +20,18 @@ val nullptr (#a:Type) (#b:Type) : ptr a b
 
 val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
 
+val nullptr_vptr_disjoint (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb)
+: Lemma (nullptr =!= vptr r) [SMTPat (vptr r)]
+
+val pts_to_nonnull (#opened:inames) (#a:Type) (#b:Type) (#pb: pcm b)
+  (#v: Ghost.erased b)
+  (p: ptr a b)
+: SteelGhost unit opened
+    (pts_to p pb v)
+    (fun _ -> pts_to p pb v)
+    (requires fun _ -> True)
+    (ensures fun _ _ _ -> p =!= nullptr)
+
 val intro_pts_to
   (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
 : Steel (ptr 'a 'b)

From b3c8cdbf4c7534e089280e3b177a203fd9f31d46 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 20 Jul 2021 14:00:53 -0700
Subject: [PATCH 126/513] generic_swap_sel

---
 .../arraystructs/AggregateRefExamples.fst      | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 179cb920196..02761ee76ea 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -62,6 +62,24 @@ let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (opt_pcm #'c)) (q:ref 'b (op
   opt_write q tmp;
   A.return ()
 
+let generic_swap_sel (p:ref 'a (opt_pcm #'c)) (q:ref 'b (opt_pcm #'c))
+: Steel unit
+  ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
+  (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
+  (requires (fun _ -> True))
+  (ensures (fun h _ h' ->
+    h' (p `pts_to_view` opt_view _) == h (q `pts_to_view` opt_view _) /\
+    h' (q `pts_to_view` opt_view _) == h (p `pts_to_view` opt_view _)
+  ))
+= (* A tmp = *p; *)
+  let tmp = opt_read_sel p in
+  (* *p = *q; *)
+  let vy = opt_read_sel q in
+  opt_write_sel p vy;
+  (* *q = tmp *)
+  opt_write_sel q tmp;
+  A.return ()
+
 /// Now, point_swap written using generic_swap:
 ///
 /// void point_swap_generically(struct point *p) {

From 75d1ec46e16cf1fe052eb7ffca5ac021f6480bdf Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 20 Jul 2021 14:31:23 -0700
Subject: [PATCH 127/513] feedback on pts_to_llist wrt. pts_to_or_null

---
 examples/steel/arraystructs/LList.fst | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 387d3759bfa..476ff949119 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -79,6 +79,14 @@ let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
     pts_to p node_pcm (mk_node (some value) (some next)) `star`
     (next `pts_to_llist` Ghost.hide tl)
 
+// TODO: should be something like:
+// pts_to_or_null p node_pcm (match l with [] -> one _ | (value, next) :: tl -> mk_node ...) `star`
+// vpure (p == null <==> l == []) `star`
+// begin match Ghost.reveal l with
+// | [] -> emp
+// | (value, next) :: tl -> next `pts_to_llist` ...
+// end
+
 let pts_to_llist_nil_eq p
 : Lemma ((p `pts_to_llist` []) == vpure (p == nullptr))
   [SMTPat (p `pts_to_llist` [])]

From 75bc83e9fe40aa4d866f7129a9d58195c51c7ae7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 14:42:43 -0700
Subject: [PATCH 128/513] LList noteS

---
 examples/steel/arraystructs/LList.fst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 476ff949119..273f656c41d 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -86,6 +86,7 @@ let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
 // | [] -> emp
 // | (value, next) :: tl -> next `pts_to_llist` ...
 // end
+// TODO pts_to_or_null take option
 
 let pts_to_llist_nil_eq p
 : Lemma ((p `pts_to_llist` []) == vpure (p == nullptr))

From e1b4d929387d9ed00a95368e7cf03858dc200639 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 20 Jul 2021 15:23:52 -0700
Subject: [PATCH 129/513] struct_view given family of views for fields

Requires that a, the type of field names, be inhabited
---
 examples/steel/arraystructs/Steel.C.Ref.fsti  |  2 +-
 .../steel/arraystructs/Steel.C.Struct.fst     | 76 +++++++++++++++++++
 2 files changed, 77 insertions(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 0c74d4c6c34..ec7a9b117c6 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -114,7 +114,7 @@ type sel_view
 = {
   to_view_prop: (carrier -> Tot prop);
   to_view: (refine carrier to_view_prop -> Tot view);
-  to_carrier: (view -> GTot (refine carrier to_view_prop));
+  to_carrier: (view -> Tot (refine carrier to_view_prop));
   to_carrier_not_one:
     (x: view) ->
     Lemma
diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/examples/steel/arraystructs/Steel.C.Struct.fst
index 0940213f49b..eaa467d3661 100644
--- a/examples/steel/arraystructs/Steel.C.Struct.fst
+++ b/examples/steel/arraystructs/Steel.C.Struct.fst
@@ -342,3 +342,79 @@ let unaddr_of_struct_field
   struct_unpeel p k x xs;
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   A.return ()
+
+let struct_view_to_view_prop
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (view_t:(a -> Type))
+  (field_view:(k:a -> sel_view (p k) (view_t k)))
+: restricted_t a b -> Tot prop
+= (fun (f : restricted_t a b) -> forall k. (field_view k).to_view_prop (f k)) 
+
+let struct_view_to_view
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (view_t:(a -> Type))
+  (field_view:(k:a -> sel_view (p k) (view_t k)))
+: refine (restricted_t a b) (struct_view_to_view_prop view_t field_view) ->
+  Tot (restricted_t a view_t)
+= (fun (f: refine (restricted_t a b) _) ->
+    on_dom a (fun k -> (field_view k).to_view (f k)))
+
+let struct_view_to_carrier
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (view_t:(a -> Type))
+  (field_view:(k:a -> sel_view (p k) (view_t k)))
+: restricted_t a view_t ->
+  Tot (refine (restricted_t a b) (struct_view_to_view_prop view_t field_view))
+= fun (f: restricted_t a view_t) ->
+  let g: restricted_t a b = on_dom a (fun k -> (field_view k).to_carrier (f k) <: b k) in
+  g
+
+let struct_view_to_carrier_not_one
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (view_t:(a -> Type))
+  (field_view:(k:a -> sel_view (p k) (view_t k)))
+  (x:restricted_t a view_t)
+: Lemma
+    (requires exists (x:a). True)
+    (ensures struct_view_to_carrier view_t field_view x =!= one (prod_pcm p))
+= let k = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+  (field_view k).to_carrier_not_one (x k)
+
+let struct_view_to_view_frame
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (view_t:(a -> Type))
+  (field_view:(k:a -> sel_view (p k) (view_t k)))
+  (x:restricted_t a view_t)
+  (frame: restricted_t a b)
+: Lemma
+    (requires (composable (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame))
+    (ensures
+      struct_view_to_view_prop view_t field_view
+        (op (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame) /\ 
+      struct_view_to_view view_t field_view
+        (op (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame) == x)
+= let aux k
+  : Lemma (
+      (field_view k).to_view_prop (op (p k) ((field_view k).to_carrier (x k)) (frame k)) /\
+      (field_view k).to_view (op (p k) ((field_view k).to_carrier (x k)) (frame k)) == x k)
+  = assert (composable (p k) ((field_view k).to_carrier (x k)) (frame k));
+    (field_view k).to_view_frame (x k) (frame k)
+  in forall_intro aux;
+  assert (
+    struct_view_to_view view_t field_view
+       (op (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame) `feq` x)
+
+let struct_view
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (view_t:(a -> Type))
+  (field_view:(k:a -> sel_view (p k) (view_t k)))
+: Pure (sel_view (prod_pcm p) (restricted_t a view_t))
+    (requires exists (_:a). True)
+    (ensures fun _ -> True)
+= {
+  to_view_prop = struct_view_to_view_prop view_t field_view;
+  to_view = struct_view_to_view view_t field_view;
+  to_carrier = struct_view_to_carrier view_t field_view;
+  to_carrier_not_one = struct_view_to_carrier_not_one view_t field_view;
+  to_view_frame = struct_view_to_view_frame view_t field_view;
+}

From 3ba3e1ddc26e5580169c0fbcb7bc40833f2efc68 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 07:42:08 -0700
Subject: [PATCH 130/513] Clean up LList example

---
 examples/steel/arraystructs/LList.fst        | 474 ++++++++++++-------
 examples/steel/arraystructs/ListNode.fst     |  42 ++
 examples/steel/arraystructs/Steel.C.Ptr.fst  | 202 +++++++-
 examples/steel/arraystructs/Steel.C.Ptr.fsti |  80 +++-
 4 files changed, 592 insertions(+), 206 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 273f656c41d..a45657d0b92 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -65,19 +65,42 @@ let elim_vpure
     (fun _ _ -> p)
     (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
 
+val unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
+: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
+
+let unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
+: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
+= let x: 'a = FStar.IndefiniteDescription.indefinite_description_tot 'a (fun _ -> True) in
+  change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
+  x
+
 // ----------------------------------------
 
 open ListNode
 
-let cells = list (int & ptr node node)
+let cell = int & ptr node node
+let cells = list cell
+
+let hd_node (l: Ghost.erased cells): Ghost.erased (option node) =
+  match Ghost.reveal l with
+  | (value, next) :: _ -> some (mk_node (some value) (some next))
+  | [] -> none
+
+let pts_to_llist_tl (l:Ghost.erased cells)
+  (pts_to_llist:(
+    p:ptr node node -> 
+    l':Ghost.erased cells{List.length l' < List.length l} -> 
+    Tot vprop))
+: Tot vprop
+= match Ghost.reveal l with
+  | [] -> emp
+  | (value, next) :: tl -> next `pts_to_llist` tl
 
 let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
 : Tot vprop (decreases (List.length l))
-= match Ghost.reveal l with
-  | [] -> vpure (p == nullptr)
-  | (value, next) :: tl ->
-    pts_to p node_pcm (mk_node (some value) (some next)) `star`
-    (next `pts_to_llist` Ghost.hide tl)
+= vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+  pts_to_or_null p node_pcm (hd_node l) `star`
+  pts_to_llist_tl l pts_to_llist
 
 // TODO: should be something like:
 // pts_to_or_null p node_pcm (match l with [] -> one _ | (value, next) :: tl -> mk_node ...) `star`
@@ -88,48 +111,118 @@ let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
 // end
 // TODO pts_to_or_null take option
 
-let pts_to_llist_nil_eq p
-: Lemma ((p `pts_to_llist` []) == vpure (p == nullptr))
-  [SMTPat (p `pts_to_llist` [])]
-= ()
+let unfold_pts_to_llist (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
+: SteelGhost unit opened
+    (p `pts_to_llist` l)
+    (fun _ -> 
+      pts_to_or_null p node_pcm (hd_node l) `star`
+      pts_to_llist_tl l pts_to_llist)
+    (requires fun _ -> True)
+    (ensures fun _ _ _ -> p == nullptr <==> Ghost.reveal l == [])
+= change_equal_slprop
+    (p `pts_to_llist` l)
+    (vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+     pts_to_or_null p node_pcm (hd_node l) `star`
+     pts_to_llist_tl l pts_to_llist);
+  elim_vpure _
 
-let pts_to_llist_cons_eq (p:ptr node node) (value:int) (next:ptr node node) (tl:cells)
-: Lemma ((p `pts_to_llist` Ghost.hide ((value, next) :: tl)) == 
-    pts_to p node_pcm (mk_node (some value) (some next)) `star`
-    (next `pts_to_llist` Ghost.hide tl))
-= ()
+let fold_pts_to_llist (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
+: SteelGhost unit opened
+    (pts_to_or_null p node_pcm (hd_node l) `star`
+     pts_to_llist_tl l pts_to_llist)
+    (fun _ -> p `pts_to_llist` l)
+    (requires fun _ -> p == nullptr <==> Ghost.reveal l == [])
+    (ensures fun _ _ _ -> True)
+= intro_vpure (p == nullptr <==> Ghost.reveal l == []);
+  change_equal_slprop
+    (vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+     pts_to_or_null p node_pcm (hd_node l) `star`
+     pts_to_llist_tl l pts_to_llist)
+    (p `pts_to_llist` l)
 
-val intro_llist_nil : unit -> SteelT unit emp (fun _ -> nullptr `pts_to_llist` [])
+let intro_pts_to_llist_nil #opened p
+: SteelGhost unit opened 
+    emp
+    (fun _ -> p `pts_to_llist` Ghost.hide [])
+    (requires fun _ -> p == nullptr)
+    (ensures fun _ _ _ -> True)
+= intro_vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []);
+  intro_pts_to_or_null_nullptr node_pcm;
+  change_equal_slprop
+    (vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []) `star`
+     pts_to_or_null (nullptr #node) node_pcm none `star` emp)
+    (p `pts_to_llist` Ghost.hide [])
 
-let intro_llist_nil () =
-  intro_vpure (nullptr #node #node == nullptr);
-  pts_to_llist_nil_eq nullptr;
-  change_equal_slprop _ (nullptr `pts_to_llist` [])
-  
-val intro_llist_cons
-  (#opened:inames) (p: ptr node node)
-  (value: int) (next: ptr node node)
-  (tl: cells)
-: SteelGhostT unit opened
-    ((pts_to p node_pcm (mk_node (some value) (some next))) `star` (next `pts_to_llist` tl))
-    (fun _ -> p `pts_to_llist` ((value, next)::tl))
-  
-let intro_llist_cons p' value next tl = change_equal_slprop _ _
-
-val elim_llist_cons
-  (#opened:inames) (p: ptr node node)
-  (value: int) (next: ptr node node) (tl: cells)
-: SteelGhostT unit opened
-    (p `pts_to_llist` ((value, next)::tl))
-    (fun _ ->
-      (pts_to p node_pcm (mk_node (some value) (some next))) `star`
-      (next `pts_to_llist` tl))
-
-let elim_llist_cons p value next tl =
+let elim_pts_to_llist_nil #opened p
+: SteelGhost unit opened 
+    (p `pts_to_llist` Ghost.hide [])
+    (fun _ -> emp)
+    (requires fun _ -> True)
+    (ensures fun _ _ _ -> p == nullptr)
+= change_equal_slprop
+    (p `pts_to_llist` Ghost.hide [])
+    (vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []) `star`
+     pts_to_or_null p node_pcm none `star` emp);
+  elim_vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []);
+  elim_pts_to_or_null_nullptr p
+
+let intro_pts_to_llist_cons #opened p value_next value next (l: Ghost.erased cells)
+: SteelGhost unit opened 
+    (pts_to p node_pcm value_next `star` (next `pts_to_llist` l))
+    (fun _ -> p `pts_to_llist` ((value, next) :: Ghost.reveal l))
+    (requires fun _ -> value_next == mk_node (some value) (some next))
+    (ensures fun _ _ _ -> p =!= nullptr)
+= change_equal_slprop
+    (pts_to p node_pcm value_next)
+    (pts_to p node_pcm (mk_node (some value) (some next)));
+  pts_to_nonnull p; assert (p =!= nullptr);
+  let l': Ghost.erased cells = Ghost.hide ((value, next) :: Ghost.reveal l) in
+  intro_vpure (p == nullptr <==> Ghost.reveal l' == []);
+  assert (hd_node l' == some (mk_node (some value) (some next)));
+  intro_pts_to_or_null p;
+  change_equal_slprop (next `pts_to_llist` l) (pts_to_llist_tl l' pts_to_llist);
   change_equal_slprop
-    (p `pts_to_llist` ((value, next)::tl)) // TODO why can't these be inferred?
-    ((pts_to p node_pcm (mk_node (some value) (some next))) `star`
-     (next `pts_to_llist` tl))
+    (vpure (p == nullptr <==> Ghost.reveal l' == []) `star`
+     pts_to_or_null p node_pcm (hd_node l') `star`
+     pts_to_llist_tl l' pts_to_llist)
+    (p `pts_to_llist` _)
+
+[@@erasable]
+noeq type elim_pts_to_llist_cons_res = {
+  value: int;
+  next: ptr node node;
+  tl: cells;
+}
+
+let elim_pts_to_llist_cons #opened p (l: Ghost.erased cells)
+: SteelGhost elim_pts_to_llist_cons_res opened 
+    (p `pts_to_llist` l)
+    (fun res ->
+      pts_to p node_pcm (mk_node (some res.value) (some res.next)) `star`
+      (res.next `pts_to_llist` res.tl))
+    (requires fun _ -> p =!= nullptr)
+    (ensures fun _ res _ -> Ghost.reveal l == (res.value, res.next) :: res.tl)
+= change_equal_slprop (p `pts_to_llist` l)
+    (vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+     pts_to_or_null p node_pcm (hd_node l) `star`
+     pts_to_llist_tl l pts_to_llist);
+  elim_vpure (p == nullptr <==> Ghost.reveal l == []);
+  match Ghost.reveal l with
+  | [] -> unreachable (fun res -> Ghost.reveal l == (res.value, res.next) :: res.tl)
+  | (value, next) :: tl ->
+    assert (hd_node l == some (mk_node (some value) (some next)));
+    let w = elim_pts_to_or_null p in
+    assert (w == mk_node (some value) (some next));
+    change_equal_slprop (pts_to_llist_tl l pts_to_llist) (next `pts_to_llist` tl);
+    {value; next; tl}
+
+let ptr a = ptr a a
+
+let intro_llist_nil ()
+: SteelT (ptr node) emp (fun p -> p `pts_to_llist` [])
+= let p = nullptr in
+  intro_pts_to_llist_nil p;
+  return p
 
 let rec values (l:cells) : GTot (list int) =
   match l with
@@ -138,34 +231,26 @@ let rec values (l:cells) : GTot (list int) =
 
 #set-options "--ide_id_info_off"
 
-val push (p:ptr node node) (l:Ghost.erased cells) (value:int)
-: Steel (ptr node node & Ghost.erased cells)
+val push (p:ptr node) (l:Ghost.erased cells) (value:int)
+: Steel (ptr node & _)
     (p `pts_to_llist` l)
     (fun (p', l') -> p' `pts_to_llist` l')
     (requires fun _ -> True)
     (ensures fun _ (_, l') _ -> values l' == value :: values l)
 
 let push p l value =
-  let cell: int & ptr node node = (value, p) in
-  let r = ref_alloc node_pcm (mk_node_tot (Some value) (Some p)) in
+  let cell: int & ptr node = (value, p) in
+  let value_next: node = mk_node_tot (Some value) (Some p) in
+  let r = ref_alloc node_pcm value_next in
   let q = intro_pts_to r in
-  intro_llist_cons q value p l;
+  intro_pts_to_llist_cons q value_next value p l;
   return (q, Ghost.hide (cell :: l))
   
 let cells_set_hd x (l: cells) = match l with
   | [] -> []
   | (_, next) :: l' -> (x, next) :: l'
 
-val exfalso (#opened:inames) (p:vprop) (q:'a -> vprop) (r:'a -> prop)
-: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
-
-let exfalso (#opened:inames) (p:vprop) (q:'a -> vprop) (r:'a -> prop)
-: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
-= let x: 'a = FStar.IndefiniteDescription.indefinite_description_tot 'a (fun _ -> True) in
-  change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
-  x
-
-val pts_to_llist_nullptr (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
+val pts_to_llist_nullptr (#opened:inames) (p:ptr node) (l:Ghost.erased cells)
 : SteelGhost unit opened
     (p `pts_to_llist` l) 
     (fun _ -> p `pts_to_llist` l)
@@ -173,76 +258,89 @@ val pts_to_llist_nullptr (#opened:inames) (p:ptr node node) (l:Ghost.erased cell
     (ensures fun _ _ _ -> Ghost.reveal l == [])
 
 let pts_to_llist_nullptr p l =
-  match Ghost.reveal l with
-  | [] -> change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` l) // TODO why can't just put ()
-  | (value, next) :: tl ->
-    change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
-    let r = elim_llist_cons p value next tl in
-    pts_to_nonnull p;
-    assert (p =!= nullptr);
-    assert (p == nullptr);
-    exfalso _ _ (fun _ -> Ghost.reveal l == [])
-
-[@@erasable]
-noeq type pts_to_llist_res = {
-  value: int;
-  next: ptr node node;
-  tl: cells;
-}
-
-val pts_to_llist_some (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
-: SteelGhost pts_to_llist_res opened
-    (p `pts_to_llist` l) 
-    (fun res -> p `pts_to_llist` ((res.value, res.next) :: res.tl))
-    (requires fun _ -> p =!= nullptr)
-    (ensures fun _ res _ -> Ghost.reveal l == ((res.value, res.next) :: res.tl))
-
-let pts_to_llist_some p l =
-  match Ghost.reveal l with
-  | [] ->
-    change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` []);
-    assert (p == nullptr);
-    assert (p =!= nullptr);
-    exfalso _ _ (fun res -> Ghost.reveal l == ((res.value, res.next) :: res.tl))
-  | (value, next) :: tl ->
-    change_equal_slprop (p `pts_to_llist` l) (p `pts_to_llist` ((value, next) :: tl));
-    {value; next; tl}
+  unfold_pts_to_llist p l;
+  assert (Ghost.reveal l == []);
+  fold_pts_to_llist p l
+
+(* Currently z3 is going through the lemma
+      refine value /\ refine next ==> refine (mk_node value next)
+   plus the fact that for our PCMs, ~ refine one.
+   If change refine predicate/drop the side condition ~ refine one, will 
+   need to expose the proper lemmas about mk_node in ListNode.fsti
+*)
+let nontrivial_fact_about_mk_node value next
+: Lemma (Ghost.reveal (mk_node (some value) (some next)) =!= one node_pcm)
+= ()
 
-val set_hd (p:ptr node node) (l:Ghost.erased cells) (value:int)
+assume val intro_pts_to_llist_cons' : #opened:inames ->
+      p: ptr node ->
+      value: int ->
+      next: ptr node ->
+      l: Ghost.erased cells
+    -> Steel.Effect.Atomic.SteelGhostT unit
+        opened
+        (star (pts_to p node_pcm (mk_node (some (Ghost.hide value)) (some (Ghost.hide next))))
+	  (pts_to_llist next l))
+        (fun _ ->
+            pts_to_llist p
+              (Ghost.hide (FStar.Pervasives.Native.Mktuple2 value next :: Ghost.reveal l)))
+
+assume val addr_of_value
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (Steel.C.Ptr.ptr node node)))
+  (p: Steel.C.Ptr.ptr node node)
+: Steel (Steel.C.Ptr.ptr node (option int))
+    (pts_to p node_pcm (mk_node value next))
+    (fun q ->
+       (pts_to p node_pcm (mk_node none next)) `star`
+       (pts_to q opt_pcm value))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> ptr_focused q p _value))
+
+assume val unaddr_of_value
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (Steel.C.Ptr.ptr node node)))
+  (p: Steel.C.Ptr.ptr node node)
+  (q: Steel.C.Ptr.ptr node (option int))
+: Steel unit
+    ((pts_to p node_pcm (mk_node none next)) `star`
+     (pts_to q opt_pcm value))
+    (fun q -> pts_to p node_pcm (mk_node value next))
+    (requires (fun _ -> ptr_focused q p _value))
+    (ensures (fun _ _ _ -> True))
+
+val set_first (p:ptr node) (l:Ghost.erased cells) (value:int)
 : SteelT unit
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_hd value l)
 
-// Problem: need (pts_to_or_null p pb v), where v =!= one, before can check whether it's null
-// Unclear how to rearrange pts_to_or_null
-
-let set_hd p l new_value =
-  //let b = is_null p in
-  if true then begin
-    //pts_to_llist_nullptr p l;
-    sladmit(); return ()
+val is_empty
+  (#l: Ghost.erased cells) (p: ptr node)
+: Steel bool
+    (p `pts_to_llist` l)
+    (fun _ -> p `pts_to_llist` l)
+    (requires fun _ -> True)
+    (ensures fun _ b _ -> b <==> p == nullptr)
+let is_empty #l p =
+  unfold_pts_to_llist p l;
+  let b = is_null p in
+  fold_pts_to_llist p l;
+  return b
+
+let set_first p l new_value =
+  let b = is_empty p in
+  if b then begin
+    pts_to_llist_nullptr p l;
+    return ()
   end else begin
-    sladmit(); return ()
-    //let res = pts_to_llist_some p l in
-    //let value: Ghost.erased int = Ghost.hide res.value in
-    //let next: Ghost.erased ptr = Ghost.hide res.next in
-    //let tl: Ghost.erased cells = Ghost.hide res.tl in
-    //change_equal_slprop (p `pts_to_llist` _) (p `pts_to_llist` _);
-    //let r' = elim_llist_cons p (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
-    //let r: ref node node_pcm = r in
-    //change_equal_slprop
-    //  (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
-    //  (r `pts_to` mk_node (some value) (some next));
-    //let r_value = addr_of_value r in
-    //r_value `opt_write` new_value;
-    //unaddr_of_value r r_value;
-    //intro_llist_cons r p new_value next tl;
-    //return ()
+    let res = elim_pts_to_llist_cons p l in
+    let p_value = addr_of_value p in
+    p_value `ptr_opt_write` new_value;
+    unaddr_of_value p p_value;
+    intro_pts_to_llist_cons' p new_value res.next res.tl;
+    return ()
   end
 
-// for the presentation, write write code for set_hd
-// based on assume val for needed selectors, then solve assumes
-
 let rec cells_set_nth (n:nat) (value:int) (l:cells) : Tot cells (decreases n) =
   if n = 0 then cells_set_hd value l
   else match l with
@@ -254,68 +352,98 @@ let rec cells_set_nth_nil n value
 = if n = 0 then () else cells_set_nth_nil (n - 1) value
 
 let llist_setter (n:nat) =
-  p:ptr node node -> l:Ghost.erased cells -> value:int ->
+  p:ptr node -> l:Ghost.erased cells -> value:int ->
   SteelT unit
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_nth n value l)
 
 let llist_set_zero: llist_setter 0 = set_hd
 
-(*
-let aux n (ih: llist_setter n) (p: ptr) (l: Ghost.erased cells) (new_value: int)
+// TODO set_hd: can make helper function is_empty to check whether list is empty or not
+
+let aux n value l = cells_set_nth (n + 1) value l
+
+let aux n (ih: llist_setter n) (p: ptr node) (l: Ghost.erased cells) (new_value: int)
 : SteelT unit
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_nth (n + 1) new_value l)
-= assume (Some? p);
-  // match p with
-  // | None ->
-  //   pts_to_llist_nullptr p l;
-  //   cells_set_nth_nil (n + 1) value;
-  //   change_equal_slprop
-  //     (None `pts_to_llist` [])
-  //     (p `pts_to_llist` cells_set_nth (n + 1) value l);
-  //   return ()
-  // | Some r ->
-  let Some r = p in
-    let res = pts_to_llist_some p l in
-    let value: Ghost.erased int = Ghost.hide res.value in
-    let next: Ghost.erased ptr = Ghost.hide res.next in
-    let tl: Ghost.erased cells = Ghost.hide res.tl in
-    //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
-    //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
-    //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
-    change_equal_slprop (p `pts_to_llist` l)
-      (Some r `pts_to_llist`
-       Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
-    let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
-    let r: ref node node_pcm = r in
-    change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
-      (r `pts_to` mk_node (some value) (some next));
+= unfold_pts_to_llist p l;
+  let b = is_null p in
+  fold_pts_to_llist p l;
+  assume (b == false);
+  //if b then begin
+  //  pts_to_llist_nullptr p l;
+  //  cells_set_nth_nil (n + 1) new_value;
+  //  return ()
+  //end else begin
+    let res = elim_pts_to_llist_cons p l in
+    let r = elim_pts_to p in
     let r_next = addr_of_next r in
-    let q: ptr = opt_read r_next in
-    assert (q == Ghost.reveal next);
+    let q = opt_read r_next in
     unaddr_of_next r r_next;
-    change_equal_slprop (Ghost.reveal next `pts_to_llist` _) (q `pts_to_llist` _);
-    ih q tl new_value;
-    change_equal_slprop (q `pts_to_llist` _) (Ghost.reveal next `pts_to_llist` _);
-    intro_llist_cons r (Ghost.reveal value) (Ghost.reveal next) _;
-//val intro_llist_cons
-//  (#opened:inames) (r: ref node node_pcm)
-//  (value: int) (next: ptr)
-//  (tl: cells)
-//: SteelGhostT unit opened
-//    ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
-//    (fun _ -> Some r `pts_to_llist` ((value, next)::tl))
-    sladmit(); return ()
-    // //assert (Ghost.reveal r' == r);
-    // //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
-    // let r_value = addr_of_value r in
-    // r_value `opt_write` new_value;
-    // unaddr_of_value r r_value;
-    // intro_llist_cons r new_value next tl;
-    // //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
-    // //sladmit(); return ()
-    // return ()
+    assert (q == res.next);
+    change_equal_slprop (res.next `pts_to_llist` _) (q `pts_to_llist` _);
+    ih q res.tl new_value;
+    //let p' = intro_pts_to r in
+    //change_equal_slprop (pts_to p' node_pcm _) (pts_to p node_pcm _);
+    //intro_pts_to_llist_cons p
+    //  (mk_node (some (Ghost.hide new_value)) (some (Ghost.hide res.next)))
+    //  new_value res.next res.tl;
+    sladmit();
+    return ()
+  //end
+
+  // assume (Some? p);
+  // // match p with
+  // // | None ->
+  // //   pts_to_llist_nullptr p l;
+  // //   cells_set_nth_nil (n + 1) value;
+  // //   change_equal_slprop
+  // //     (None `pts_to_llist` [])
+  // //     (p `pts_to_llist` cells_set_nth (n + 1) value l);
+  // //   return ()
+  // // | Some r ->
+  // let Some r = p in
+  //   let res = pts_to_llist_some p l in
+  //   let value: Ghost.erased int = Ghost.hide res.value in
+  //   let next: Ghost.erased ptr = Ghost.hide res.next in
+  //   let tl: Ghost.erased cells = Ghost.hide res.tl in
+  //   //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
+  //   //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
+  //   //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
+  //   change_equal_slprop (p `pts_to_llist` l)
+  //     (Some r `pts_to_llist`
+  //      Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
+  //   let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
+  //   let r: ref node node_pcm = r in
+  //   change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
+  //     (r `pts_to` mk_node (some value) (some next));
+  //   let r_next = addr_of_next r in
+  //   let q: ptr = opt_read r_next in
+  //   assert (q == Ghost.reveal next);
+  //   unaddr_of_next r r_next;
+  //   change_equal_slprop (Ghost.reveal next `pts_to_llist` _) (q `pts_to_llist` _);
+  //   ih q tl new_value;
+  //   change_equal_slprop (q `pts_to_llist` _) (Ghost.reveal next `pts_to_llist` _);
+  //   intro_llist_cons r (Ghost.reveal value) (Ghost.reveal next) _;
+//// val intro_llist_cons
+////   (#opened:inames) (r: ref node node_pcm)
+////   (value: int) (next: ptr)
+////   (tl: cells)
+//// : SteelGhostT unit opened
+////     ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
+////     (fun _ -> Some r `pts_to_llist` ((value, next)::tl))
+  //   sladmit(); return ()
+  //   // //assert (Ghost.reveal r' == r);
+  //   // //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
+  //   // let r_value = addr_of_value r in
+  //   // r_value `opt_write` new_value;
+  //   // unaddr_of_value r r_value;
+  //   // intro_llist_cons r new_value next tl;
+  //   // //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
+  //   // //sladmit(); return ()
+  //   // return ()
+  // let set_hd p l new_value =
 
 let llist_set_succ n (ih: llist_setter n): llist_setter (n + 1) =
   let aux (p: ptr) (l: Ghost.erased cells) (value: int)
@@ -363,8 +491,6 @@ let llist_set_succ n (ih: llist_setter n): llist_setter (n + 1) =
       // return ()
   in aux
 
-*)
-
 // TODO look at #2319, construct module of (possibly null) pointers
 // (define pts_to_or_null; can compare against null only if points to non-unit)
 
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 84b4de34276..1557d656f48 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -249,3 +249,45 @@ let unaddr_of_next
   A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
   roll_ref p p';
   A.return ()
+
+open Steel.C.Ptr
+
+(*
+val ptr_addr_of_value
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (ptr node node)))
+  (p: ptr node node)
+: Steel (ptr node (option int))
+    (pts_to p node_pcm (mk_node value next))
+    (fun q ->
+       (pts_to p node_pcm (mk_node none next)) `star`
+       (pts_to q opt_pcm value))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> ptr_focused q p _value))
+
+let ptr_addr_of_value #value #next (p: ptr node node)
+= let p_ref = elim_pts_to p in
+  let p' = unroll_ref p_ref in
+  let q = addr_of_struct_field p' Value (mk_node' value next) in
+  A.change_equal_slprop (p' `Steel.C.Ref.pts_to` _) (p' `Steel.C.Ref.pts_to` mk_node' none next);
+  A.change_equal_slprop (q `Steel.C.Ref.pts_to` _) (q `Steel.C.Ref.pts_to` value);
+  roll_ref p_ref p';
+  let p_ = intro_pts_to p_ref in
+  A.change_equal_slprop (pts_to p_ node_pcm _) (pts_to p node_pcm _);
+  let q_ = intro_pts_to q in
+  A.sladmit();
+  A.return q_
+  // TODO need split, gather, etc for ptrs
+
+assume val unaddr_of_value
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (Steel.C.Ptr.ptr node node)))
+  (p: Steel.C.Ptr.ptr node node)
+  (q: Steel.C.Ptr.ptr node (option int))
+: Steel unit
+    ((pts_to p node_pcm (mk_node none next)) `star`
+     (pts_to q opt_pcm value))
+    (fun q -> pts_to p node_pcm (mk_node value next))
+    (requires (fun _ -> ptr_focused q p _value))
+    (ensures (fun _ _ _ -> True))
+*)
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
index e0183d21584..889085d2094 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fst
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -72,9 +72,16 @@ let nonnull (p: ptr 'a 'b) (pb: pcm 'b): prop = Some? p /\ pcm_of_ref' (Some?.v
 let pts_to_dep (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b) (prf: squash (nonnull p pb))
 = let r: ref 'a pb = Some?.v p in r `pts_to` v
 
-let pts_to p pb v = vpure (nonnull p pb) `vdep` pts_to_dep p pb v
+let pts_to' (p: ptr 'a 'b) (pb: pcm 'b) (v: 'b): vprop = vpure (nonnull p pb) `vdep` pts_to_dep p pb v
+let pts_to p pb v = pts_to' p pb (Ghost.reveal v)
 
-let pts_to_or_null p pb v = if None? p then vpure True else pts_to p pb v
+let pts_to_or_null' (p: ptr 'a 'b) (pb: pcm 'b) (v: option 'b): vprop =
+  vpure (v == None <==> p == None) `star`
+  (match v with
+   | None -> vpure True
+   | Some v -> pts_to' p pb v)
+
+let pts_to_or_null p pb v = pts_to_or_null' p pb (Ghost.reveal v)
 
 let nullptr #a #b = None
 
@@ -82,8 +89,10 @@ let vptr r = Some r
 
 let nullptr_vptr_disjoint r = ()
 
-let pts_to_nonnull #opened #a #b #pb p v =
-  change_equal_slprop (pts_to p pb v) (pts_to p pb v) // TODO easier way to do this?
+let vptr_injective r r' = ()
+
+let pts_to_nonnull #opened #a #b #pb #v p =
+  let _ = gget (pts_to p pb v) in ()
 
 let intro_pts_to #a #b #pb #v r =
   let p = Some r in
@@ -92,20 +101,187 @@ let intro_pts_to #a #b #pb #v r =
   change_equal_slprop (_ `vdep` _) (pts_to p pb v);
   return p
 
-let elim_pts_to #a #b #opened #pb #v r p =
+let elim_pts_to #a #b #pb #v p =
   change_equal_slprop (pts_to p pb v) (vpure (nonnull p pb) `vdep` pts_to_dep p pb v);
   let prf = elim_vdep _ _ in
   elim_vpure _;
-  change_equal_slprop (pts_to_dep p pb v prf) _
+  change_equal_slprop (pts_to_dep p pb v prf) _;
+  return (Some?.v p)
 
-let intro_pts_to_or_null_nullptr #a pb v = intro_vpure True
+#push-options "--print_implicits"
 
-let intro_pts_to_or_null #a #b #pb #v p =
-  change_equal_slprop (pts_to p pb v) (pts_to_or_null p pb v);
-  return p
+(*
+let aux' #a #b (pb:pcm b) : unit =
+  assert_norm (
+    pts_to_or_null #a #b (nullptr #a #b) pb (none #b)  ==
+    (if None? #(Steel.C.Ref.ref' a b) (nullptr #a #b)
+      then
+        Steel.C.Ptr.vpure (Prims.eq2 #(FStar.Ghost.erased (Steel.C.Opt.option b))
+	      (Steel.C.Opt.none #b)
+              (Steel.C.Opt.none #b))
+      else
+        (match FStar.Ghost.reveal #(Steel.C.Opt.option b) (Steel.C.Opt.none #b) with
+          | FStar.Pervasives.Native.None #_ -> Steel.C.Ptr.vpure Prims.l_False
+          | FStar.Pervasives.Native.Some #_ v ->
+            Steel.C.Ptr.pts_to #a #b (nullptr #a #b) pb (FStar.Ghost.hide #b v))
+        <:
+        Steel.Effect.Common.vprop)) // How is this not equal?? TODO
+*)
 
-let elim_pts_to_or_null #a #b #pb #v p =
-  change_equal_slprop (pts_to_or_null p pb v) (pts_to p pb v);
-  return p
+(*
+let unfold_pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased (option 'b))
+: Lemma
+    (pts_to_or_null #'a #'b p pb (none #'b)  ==
+     (if None? p then vpure (v == none #'b) else
+     (match Ghost.reveal v with
+     | None -> vpure False
+     | Some v -> pts_to p pb (Ghost.hide v))))
+    [SMTPat (pts_to_or_null p pb v)]
+= assume // TODO why
+    (pts_to_or_null #'a #'b p pb (none #'b)  ==
+     (if None? p then vpure (v == none #'b) else
+     (match Ghost.reveal v with
+     | None -> vpure False
+     | Some v -> pts_to p pb (Ghost.hide v))))
+*)
+
+let unfold_pts_to_or_null #a #b (pb: pcm b) (p: ptr a b) (v: option b)
+: Lemma
+    (pts_to_or_null #a #b p pb v  ==
+     (vpure (v == None <==> p == None) `star`
+     (match v with
+      | None -> vpure True
+      | Some v -> pts_to p pb v)))
+= ()
+
+let intro_pts_to_or_null_nullptr #a #b pb =
+  intro_vpure (Ghost.reveal (none #b) == None <==> nullptr #a #b == None);
+  intro_vpure True;
+  unfold_pts_to_or_null #a #b pb (nullptr #a #b) None; 
+  change_equal_slprop _ (pts_to_or_null (nullptr #a #b) pb (none #b))
+
+let intro_pts_to_or_null #a #b #_ #pb #v p =
+  let prf_p_nonnull = gget (pts_to p pb v) in
+  intro_vpure (Some (Ghost.reveal v) == None <==> p == None);
+  unfold_pts_to_or_null pb p (Some (Ghost.reveal v));
+  change_equal_slprop
+    (vpure (Some (Ghost.reveal v) == None <==> p == None) `star` pts_to' p pb (Ghost.reveal v))
+    (pts_to_or_null p pb (some v))
+  
+val unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
+: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
+
+let unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
+: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
+= let x: 'a = FStar.IndefiniteDescription.indefinite_description_tot 'a (fun _ -> True) in
+  change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
+  x
+
+let elim_pts_to_or_null_nullptr #a #b #_ #pb #v p =
+  let prf: Ghost.erased (
+    squash (Ghost.reveal v == None <==> p == None) *
+    squash True) = gget (pts_to_or_null p pb v) in
+  assert (Ghost.reveal v == None);
+  unfold_pts_to_or_null pb p (Ghost.reveal v);
+  change_equal_slprop (pts_to_or_null p pb v) 
+    (vpure (Ghost.reveal v == None #b <==> p == None #(ref' a b)) `star` vpure True);
+  elim_vpure True; elim_vpure _
+
+let elim_pts_to_or_null_nonnull_witness #opened
+  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
+: SteelGhost (Ghost.erased 'b) opened
+    (pts_to_or_null p pb v)
+    (fun w -> pts_to_or_null p pb (some w))
+    (requires fun _ -> p =!= nullptr)
+    (ensures fun _ w _ -> v == some w)
+= match Ghost.reveal v with
+  | None -> 
+    let prf = gget (pts_to_or_null p pb v) in
+    let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
+    assert (p == nullptr);
+    unreachable (fun w -> v == some w)
+  | Some w ->
+    let prf = gget (pts_to_or_null p pb v) in
+    let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
+    assert (p =!= nullptr);
+    change_equal_slprop (pts_to_or_null p pb v) (pts_to_or_null p pb (some w));
+    w
+
+#set-options "--ide_id_info_off"
 
+let elim_pts_to_or_null #a #b #_ #pb #v p =
+  let w = elim_pts_to_or_null_nonnull_witness p in
+  unfold_pts_to_or_null pb p (some w);
+  change_equal_slprop (pts_to_or_null p pb (some w))
+    (vpure (Ghost.reveal (some w) == None <==> p == None) `star` pts_to' p pb w);
+  elim_vpure (Ghost.reveal (some w) == None <==> p == None);
+  w
+  
 let is_null #a #b #pb #v p = return (None? p)
+
+open Steel.C.Connection
+
+let ptr_focused
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r': ptr a c) (r: ptr a b) (#q: pcm c) (l: connection p q)
+: prop
+= exists (ref_r:ref a p). r == vptr ref_r /\ r' == vptr (ref_focus ref_r l)
+
+let focus #a #b #p r #q l s x =
+  let ref_r = elim_pts_to r in
+  assert (r == vptr ref_r);
+  let ref_r_focused = Steel.C.Ref.focus ref_r l s x in
+  let r' = intro_pts_to ref_r_focused in
+  assert (r' == vptr (ref_focus ref_r l));
+  return r'
+  
+val elim_pts_to_ghost (#opened:inames)
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: SteelGhost (ref 'a pb) opened
+    (pts_to p pb v)
+    (fun r -> r `R.pts_to` v)
+    (requires fun _ -> True)
+    (ensures fun _ r _ -> p == vptr r)
+let elim_pts_to_ghost #a #b #_ #pb #v p =
+  change_equal_slprop (pts_to p pb v) (vpure (nonnull p pb) `vdep` pts_to_dep p pb v);
+  let prf = elim_vdep _ _ in
+  elim_vpure _;
+  let r: ref a pb = Some?.v p in
+  change_equal_slprop (pts_to_dep p pb v prf) _;
+  r
+  
+val intro_pts_to_ghost (#opened:inames)
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
+: SteelGhost (ptr 'a 'b) opened
+    (r `R.pts_to` v)
+    (fun p -> pts_to p pb v)
+    (requires fun _ -> True)
+    (ensures fun _ p _ -> p == vptr r)
+let intro_pts_to_ghost #a #b #opened #pb #v r =
+  let p = Some r in
+  intro_vpure (nonnull p pb);
+  intro_vdep (vpure (nonnull p pb)) (r `R.pts_to` v) (pts_to_dep p pb v);
+  change_equal_slprop (_ `vdep` _) (pts_to p pb v);
+  p
+    
+let unfocus #a #b #c #opened #p #q r r' l x =
+  let ref_r' =
+    FStar.IndefiniteDescription.indefinite_description_ghost
+      (ref a p)
+      (fun ref_r -> r' == vptr ref_r /\ r == vptr (ref_focus ref_r l))
+  in
+  let ref_r = elim_pts_to_ghost r in
+  unfocus ref_r ref_r' l x;
+  let r'' = intro_pts_to_ghost ref_r' in
+  change_equal_slprop (pts_to r'' p _) (pts_to r' p _)
+
+let ptr_opt_write
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (p: ptr a (option b)) (y: b)
+: SteelT unit
+    (pts_to p opt_pcm (some x))
+    (fun _ -> pts_to p opt_pcm (some (Ghost.hide y)))
+= let r = elim_pts_to p in
+  r `opt_write` y;
+  let p' = intro_pts_to r in
+  change_equal_slprop (pts_to p' opt_pcm _) (pts_to p opt_pcm _)
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fsti b/examples/steel/arraystructs/Steel.C.Ptr.fsti
index ec2e68b2ca0..93b19276f6c 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fsti
@@ -8,13 +8,14 @@ open Steel.Effect
 open Steel.C.PCM
 open Steel.C.Opt
 open Steel.C.Ref
+open Steel.C.Connection
 open Steel.Effect
 
 val ptr (a: Type u#0) (b: Type u#b) : Type u#b
 
 val pts_to (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: Ghost.erased 'b): vprop
 
-val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b): vprop
+val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: Ghost.erased (option 'b)): vprop
 
 val nullptr (#a:Type) (#b:Type) : ptr a b
 
@@ -23,6 +24,9 @@ val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
 val nullptr_vptr_disjoint (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb)
 : Lemma (nullptr =!= vptr r) [SMTPat (vptr r)]
 
+val vptr_injective (#a:Type) (#b:Type) (#pb: pcm b) (r r': ref a pb)
+: Lemma (requires vptr r == vptr r') (ensures r == r') [SMTPat (vptr r); SMTPat (vptr r')]
+
 val pts_to_nonnull (#opened:inames) (#a:Type) (#b:Type) (#pb: pcm b)
   (#v: Ghost.erased b)
   (p: ptr a b)
@@ -41,36 +45,74 @@ val intro_pts_to
     (ensures fun _ p _ -> p == vptr r)
 
 val elim_pts_to
-  (#opened:inames) (#pb: pcm 'b) (#v: Ghost.erased 'b)
-  (r: ref 'a pb) (p: ptr 'a 'b)
-: SteelGhost unit opened
+  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+: Steel (ref 'a pb)
     (pts_to p pb v)
-    (fun _ -> r `R.pts_to` v)
-    (requires fun _ -> p == vptr r)
-    (ensures fun _ _ _ -> True)
+    (fun r -> r `R.pts_to` v)
+    (requires fun _ -> True)
+    (ensures fun _ r _ -> p == vptr r)
 
 val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
-  (pb: pcm b) (v: Ghost.erased b)
-: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb v)
+  (pb: pcm b)
+: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb none)
 
-val intro_pts_to_or_null
+val intro_pts_to_or_null (#opened:inames)
   (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: SteelT (ptr 'a 'b)
+: SteelGhostT unit opened
     (pts_to p pb v)
-    (fun p -> pts_to_or_null p pb v)
+    (fun _ -> pts_to_or_null p pb (some v))
 
-val elim_pts_to_or_null
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: Steel (ptr 'a 'b)
+val elim_pts_to_or_null_nullptr (#opened:inames)
+  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
+: SteelGhost unit opened
     (pts_to_or_null p pb v)
-    (fun p -> pts_to p pb v)
+    (fun _ -> emp)
+    (requires fun _ -> p == nullptr)
+    (ensures fun _ _ _ -> v == none)
+
+val elim_pts_to_or_null (#opened:inames)
+  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
+: SteelGhost (Ghost.erased 'b) opened
+    (pts_to_or_null p pb v)
+    (fun w -> pts_to p pb w)
     (requires fun _ -> p =!= nullptr)
-    (ensures fun _ _ _ -> True)
+    (ensures fun _ w _ -> v == some w)
 
 val is_null
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
+  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
 : Steel bool
     (pts_to_or_null p pb v)
     (fun _ -> pts_to_or_null p pb v)
-    (requires fun _ -> Ghost.reveal v =!= one pb)
+    (requires fun _ -> Some? v ==> Some?.v v =!= one pb)
     (ensures fun _ b _ -> b <==> p == nullptr)
+
+val ptr_focused
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r': ptr a c) (r: ptr a b) (#q: pcm c) (l: connection p q)
+: prop
+
+val focus (#p: pcm 'b) (r: ptr 'a 'b) (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: Steel (ptr 'a 'c)
+    (pts_to r p s)
+    (fun r' -> pts_to r' q x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ r' _ -> ptr_focused r' r l)
+
+val unfocus (#a #b #c:Type) (#opened:Steel.Memory.inames)
+  (#p: pcm b)
+  (#q: pcm c)
+  (r: ptr a c) (r': ptr a b)
+  (l: connection p q) (x: Ghost.erased c)
+: SteelGhost unit opened
+    (pts_to r q x)
+    (fun _ -> pts_to r' p (l.conn_small_to_large.morph x))
+    (requires fun _ -> ptr_focused r r' l)
+    (ensures fun _ _ _ -> True)
+    
+val ptr_opt_write
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (p: ptr a (option b)) (y: b)
+: SteelT unit
+    (pts_to p opt_pcm (some x))
+    (fun _ -> pts_to p opt_pcm (some (Ghost.hide y)))

From 99a7a63c2494a465f91d4143a402f8c205ccef68 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 07:42:22 -0700
Subject: [PATCH 131/513] Selectors for partial structs

---
 .../steel/arraystructs/Steel.C.Struct.fst     | 115 ++++++++++++------
 1 file changed, 76 insertions(+), 39 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/examples/steel/arraystructs/Steel.C.Struct.fst
index eaa467d3661..d53abb67faf 100644
--- a/examples/steel/arraystructs/Steel.C.Struct.fst
+++ b/examples/steel/arraystructs/Steel.C.Struct.fst
@@ -4,6 +4,7 @@ module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Connection
 open Steel.C.Ref
+module Ptr = Steel.C.Ptr
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
@@ -313,6 +314,24 @@ let addr_of_struct_field
   let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
   A.return r
 
+(*
+let ptr_addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: Ptr.ptr base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+*)
+
 let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   (x:b k) (xs: restricted_t a b)
 : restricted_t a b
@@ -345,55 +364,71 @@ let unaddr_of_struct_field
 
 let struct_view_to_view_prop
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (view_t:(a -> Type))
-  (field_view:(k:a -> sel_view (p k) (view_t k)))
+  (fa:a -> prop)
+  (view_t:(refine a fa -> Type))
+  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
 : restricted_t a b -> Tot prop
-= (fun (f : restricted_t a b) -> forall k. (field_view k).to_view_prop (f k)) 
+= fun (f : restricted_t a b) ->
+  forall (k:a).
+    (fa k ==> (field_view k).to_view_prop (f k))
 
 let struct_view_to_view
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (view_t:(a -> Type))
-  (field_view:(k:a -> sel_view (p k) (view_t k)))
-: refine (restricted_t a b) (struct_view_to_view_prop view_t field_view) ->
-  Tot (restricted_t a view_t)
-= (fun (f: refine (restricted_t a b) _) ->
-    on_dom a (fun k -> (field_view k).to_view (f k)))
+  (#fa:a -> prop)
+  (view_t:(refine a fa -> Type))
+  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
+: refine (restricted_t a b) (struct_view_to_view_prop fa view_t field_view) ->
+  Tot (restricted_t (refine a fa) view_t)
+= fun (f: refine (restricted_t a b) (struct_view_to_view_prop fa view_t field_view)) ->
+  let g = on_dom (refine a fa) (fun (k: refine a fa) -> (field_view k).to_view (f k)) in
+  g
+
+let decidable (p: 'a -> prop) = decide:('a -> bool){forall x. decide x <==> p x}
 
 let struct_view_to_carrier
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (view_t:(a -> Type))
-  (field_view:(k:a -> sel_view (p k) (view_t k)))
-: restricted_t a view_t ->
-  Tot (refine (restricted_t a b) (struct_view_to_view_prop view_t field_view))
-= fun (f: restricted_t a view_t) ->
-  let g: restricted_t a b = on_dom a (fun k -> (field_view k).to_carrier (f k) <: b k) in
-  g
+  (#fa:a -> prop)
+  (dec_fa: decidable fa)
+  (view_t:(refine a fa -> Type))
+  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
+: restricted_t (refine a fa) view_t ->
+  Tot (refine (restricted_t a b) (struct_view_to_view_prop fa view_t field_view))
+= fun (f: restricted_t (refine a fa) view_t) ->
+  let g: restricted_t a b = on_dom a (fun k ->
+    if dec_fa k then
+      (field_view k).to_carrier (f k) <: b k
+    else one (p k))
+  in g
 
 let struct_view_to_carrier_not_one
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (view_t:(a -> Type))
-  (field_view:(k:a -> sel_view (p k) (view_t k)))
-  (x:restricted_t a view_t)
+  (#fa:a -> prop)
+  (dec_fa: decidable fa)
+  (view_t:(refine a fa -> Type))
+  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
+  (x:restricted_t (refine a fa) view_t)
 : Lemma
-    (requires exists (x:a). True)
-    (ensures struct_view_to_carrier view_t field_view x =!= one (prod_pcm p))
-= let k = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+    (requires exists (k:a). fa k)
+    (ensures struct_view_to_carrier dec_fa view_t field_view x =!= one (prod_pcm p))
+= let k = FStar.IndefiniteDescription.indefinite_description_ghost a fa in
   (field_view k).to_carrier_not_one (x k)
 
 let struct_view_to_view_frame
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (view_t:(a -> Type))
-  (field_view:(k:a -> sel_view (p k) (view_t k)))
-  (x:restricted_t a view_t)
+  (#fa:a -> prop)
+  (dec_fa: decidable fa)
+  (view_t:(refine a fa -> Type))
+  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
+  (x:restricted_t (refine a fa) view_t)
   (frame: restricted_t a b)
 : Lemma
-    (requires (composable (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame))
+    (requires (composable (prod_pcm p) (struct_view_to_carrier dec_fa view_t field_view x) frame))
     (ensures
-      struct_view_to_view_prop view_t field_view
-        (op (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame) /\ 
+      struct_view_to_view_prop fa view_t field_view
+        (op (prod_pcm p) (struct_view_to_carrier dec_fa view_t field_view x) frame) /\ 
       struct_view_to_view view_t field_view
-        (op (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame) == x)
-= let aux k
+        (op (prod_pcm p) (struct_view_to_carrier dec_fa view_t field_view x) frame) == x)
+= let aux (k:refine a fa)
   : Lemma (
       (field_view k).to_view_prop (op (p k) ((field_view k).to_carrier (x k)) (frame k)) /\
       (field_view k).to_view (op (p k) ((field_view k).to_carrier (x k)) (frame k)) == x k)
@@ -402,19 +437,21 @@ let struct_view_to_view_frame
   in forall_intro aux;
   assert (
     struct_view_to_view view_t field_view
-       (op (prod_pcm p) (struct_view_to_carrier view_t field_view x) frame) `feq` x)
+       (op (prod_pcm p) (struct_view_to_carrier dec_fa view_t field_view x) frame) `feq` x)
 
 let struct_view
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (view_t:(a -> Type))
-  (field_view:(k:a -> sel_view (p k) (view_t k)))
-: Pure (sel_view (prod_pcm p) (restricted_t a view_t))
-    (requires exists (_:a). True)
+  (#fa:a -> prop)
+  (dec_fa:decidable fa)
+  (view_t:refine a fa -> Type)
+  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
+: Pure (sel_view (prod_pcm p) (restricted_t (refine a fa) view_t))
+    (requires exists (k:a). fa k)
     (ensures fun _ -> True)
 = {
-  to_view_prop = struct_view_to_view_prop view_t field_view;
+  to_view_prop = struct_view_to_view_prop fa view_t field_view;
   to_view = struct_view_to_view view_t field_view;
-  to_carrier = struct_view_to_carrier view_t field_view;
-  to_carrier_not_one = struct_view_to_carrier_not_one view_t field_view;
-  to_view_frame = struct_view_to_view_frame view_t field_view;
+  to_carrier = struct_view_to_carrier dec_fa view_t field_view;
+  to_carrier_not_one = struct_view_to_carrier_not_one dec_fa view_t field_view;
+  to_view_frame = struct_view_to_view_frame dec_fa view_t field_view;
 }

From 03389dd97c582adf7f91b38cbbd2fcc33d44fc8f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 08:16:05 -0700
Subject: [PATCH 132/513] Views for unions

---
 examples/steel/arraystructs/Steel.C.Union.fst | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index c5481976ec0..a18d5250700 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -477,3 +477,78 @@ let unaddr_of_union_field
     (requires fun _ -> r' == ref_focus r (union_field p k))
     (ensures fun _ _ _ -> True)
 = unfocus r' r (union_field p k) x
+
+let union_view_to_view_prop
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (field_view:(k:a -> sel_view (p k) (view_t k)))
+: union p -> Tot prop
+= fun u -> forall k. case_refinement_f p k u ==> (field_view k).to_view_prop (u k)
+
+let union_view_to_view
+  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (field_view:(k:a -> sel_view (p k) (view_t k)))
+  (case_of:(u:union p -> k:a{case_refinement_f p k u}))
+: refine (union p) (union_view_to_view_prop field_view) -> dtuple2 a view_t
+= fun u ->
+  let k = case_of u in
+  (|k, (field_view k).to_view (u k)|)
+
+let union_view_to_carrier
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
+    ~ (s.to_view_prop (one (p k)))
+    // TODO Can we add this to the definition of a view?
+  }))
+: dtuple2 a view_t -> refine (union p) (union_view_to_view_prop field_view)
+= fun (|k, x|) ->
+  let u: union p = field_to_union_f p k ((field_view k).to_carrier x) in
+  assert (case_refinement_f p k u);
+  assert (u k == (field_view k).to_carrier x);
+  assert ((field_view k).to_view_prop ((field_view k).to_carrier x));
+  assert ((field_view k).to_view_prop (u k));
+  u
+
+let union_view_to_carrier_not_one
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
+    ~ (s.to_view_prop (one (p k)))
+    // TODO Can we add this to the definition of a view?
+  }))
+: u:dtuple2 a view_t -> Lemma (union_view_to_carrier field_view u =!= one (union_pcm p))
+= fun _ -> ()
+
+let union_view_to_view_frame
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
+    ~ (s.to_view_prop (one (p k)))
+    // TODO Can we add this to the definition of a view?
+  }))
+  (case_of:(u:union p -> k:a{case_refinement_f p k u}))
+: (v: dtuple2 a view_t) ->
+  (u: union p) ->
+  Lemma
+    (requires composable (union_pcm p) (union_view_to_carrier field_view v) u)
+    (ensures 
+      union_view_to_view_prop field_view (op (union_pcm p) (union_view_to_carrier field_view v) u) /\
+      union_view_to_view field_view case_of
+        (op (union_pcm p) (union_view_to_carrier field_view v) u) == v)
+= fun (|k, x|) u ->
+  assert (composable (p k) ((field_view k).to_carrier x) (u k));
+  (field_view k).to_view_frame x (u k);
+  ()
+
+let union_view
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
+    ~ (s.to_view_prop (one (p k)))
+    // TODO Can we add this to the definition of a view?
+  }))
+  (case_of:(u:union p -> k:a{case_refinement_f p k u}))
+: Tot (sel_view (union_pcm p) (dtuple2 a view_t))
+= {
+  to_view_prop = union_view_to_view_prop field_view;
+  to_view = union_view_to_view field_view case_of;
+  to_carrier = union_view_to_carrier field_view;
+  to_carrier_not_one = union_view_to_carrier_not_one field_view;
+  to_view_frame = union_view_to_view_frame field_view case_of;
+}

From 67d4a9597379a6a12a38a53f5bcd7b8dfd1c57fc Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 15:46:44 -0700
Subject: [PATCH 133/513] patch views; fix views for opt, struct, uninit

---
 examples/steel/arraystructs/LList.fst         |   9 --
 examples/steel/arraystructs/PointStruct.fst   |   1 -
 examples/steel/arraystructs/PointStruct.fsti  |  14 ++
 examples/steel/arraystructs/Steel.C.Opt.fsti  |   4 +-
 examples/steel/arraystructs/Steel.C.Ref.fsti  | 137 +++++++++++++++---
 .../steel/arraystructs/Steel.C.Struct.fst     | 123 ++++++++++++----
 .../steel/arraystructs/Steel.C.Uninit.fsti    |   8 +-
 examples/steel/arraystructs/Steel.C.Union.fst |  54 ++++---
 8 files changed, 266 insertions(+), 84 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index a45657d0b92..bb3dba3df3d 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -102,15 +102,6 @@ let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
   pts_to_or_null p node_pcm (hd_node l) `star`
   pts_to_llist_tl l pts_to_llist
 
-// TODO: should be something like:
-// pts_to_or_null p node_pcm (match l with [] -> one _ | (value, next) :: tl -> mk_node ...) `star`
-// vpure (p == null <==> l == []) `star`
-// begin match Ghost.reveal l with
-// | [] -> emp
-// | (value, next) :: tl -> next `pts_to_llist` ...
-// end
-// TODO pts_to_or_null take option
-
 let unfold_pts_to_llist (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
 : SteelGhost unit opened
     (p `pts_to_llist` l)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 4d1a52e1d17..c81f1df4622 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -8,7 +8,6 @@ open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-type point_field = | X | Y
 let point_fields k = match k with
   | X -> option int
   | Y -> option int
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index ce0934c1789..9b7dff34f14 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -12,6 +12,8 @@ open Steel.Effect
 ///
 /// Carrier of PCM for struct point:
 
+type point_field = | X | Y
+
 val point : Type0
 
 /// PCM for struct point:
@@ -58,3 +60,15 @@ val unaddr_of_y
 : SteelT unit
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)
+
+/// Views
+
+let point_view excluded : sel_view point_pcm (k:field_name not in excluded -> fields k)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> Some?.v x);
+  to_carrier = (fun z  -> Some z);
+  to_carrier_not_one = (fun _ -> ());
+  to_view_frame = (fun x frame -> ());
+}
+
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index e618fedde01..e559b86c50e 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -51,12 +51,12 @@ val opt_write
 
 let opt_view
   (a: Type)
-: Tot (sel_view (opt_pcm #a) a)
+: Tot (sel_view (opt_pcm #a) a false)
 = {
   to_view_prop = (fun x -> Some? x == true);
   to_view = (fun x -> Some?.v x);
   to_carrier = (fun z  -> Some z);
-  to_carrier_not_one = (fun _ -> ());
+  to_carrier_not_one = ();
   to_view_frame = (fun x frame -> ());
 }
 
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index ec7a9b117c6..1e24ef213de 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -111,21 +111,103 @@ type sel_view
   (#carrier: Type u#a)
   (p: pcm carrier)
   (view: Type u#b)
+  (can_view_unit:bool)
 = {
   to_view_prop: (carrier -> Tot prop);
+  // (to_view_prop (one p) <==> prop only contains unit)
   to_view: (refine carrier to_view_prop -> Tot view);
   to_carrier: (view -> Tot (refine carrier to_view_prop));
   to_carrier_not_one:
+    squash (~ can_view_unit ==> ~ (exists x. to_carrier x == one p) /\ ~ (to_view_prop (one p)));
+  to_view_frame:
     (x: view) ->
+    (frame: carrier) ->
     Lemma
-    (~ (to_carrier x == one p));
+    (requires (composable p (to_carrier x) frame))
+    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
+}
+
+(*
+finite n = m:nat{m < n}
+a `iso` finite _
+
+fun 
+  "field1" -> 0
+  "field2" -> 1
+
+all : (finite n -> bool) -> bool
+ex : (finite n -> bool) -> bool
+
+desc = list (string * Type & pcm & view & ..)
+
+restricted_t 'a 'b ---> struct_t 'a 'b with the right equations
+typedef_struct: string -> .. -> struct_t 'a 'b
+
+typedef_struct A
+
+struct A { int x, y; };
+struct B { int x, y; };
+
+view_cases:(k:a -> sel_view p view false)
+sel_view (union p) .. false
+
+view_field:(k:a -> sel_view p view (can_view_unit k))
+sel_view (prod p) .. (k empty \/ all can_view_unit)
+*)
+
+(*
+
+Current sel_view:
+- uninit_view fails (to_carrier (InitOrUnit one) == one is composable with Uninitialized,
+  so to_view (op p (to_carrier (InitOrUnit one)) Uninitialized) == InitOrUnit one fails)
+- init_view_initialized fails for same reason
+
+Can we add side conditions to uninit_view and init_view to make them work?
+- How to add side conditions without these bubbling up to selectors for structs and unions?
+  For example, if explicitly excluded unit from PCM passed to uninit selector,
+  then can't write selector for a possibly-uninitialized struct that one has taken pointers
+  to all fields of.
+
+Can we define Uninitialized with an extra constructor explicitly for Unit?
+i.e.
+  Uninitialized
+  Init x
+  One
+and no longer have composable (Init (one p)) Uninitialized.
+
+Different idea:
+
+to_view . to_carrier = id
+forall x, whole_value (to_carrier x)
+  i.e. forall y. to_carrier x * y == to_carrier x
+
+From this could prove to_view_frame.
+- uninit_view satisfies this
+- so does uninit_view_initialized
+- partial struct fails (partial structs aren't whole values)
+- unions fail if one of the cases of the union is the trivial PCM
+
+
+If
   to_view_frame:
     (x: view) ->
     (frame: carrier) ->
     Lemma
     (requires (composable p (to_carrier x) frame))
     (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
-}
+then
+
+1. specializing with (frame := unit) gives (to_view . to_carrier == id)
+2. specializing with (to_carrier x == one) gives
+     (forall y. to_view_prop y /\ to_view y == x));
+
+that is, if we want to_view_frame to hold, and there exists an x s.t. to_carrier x == one,
+then to_view_prop must be (const True) and to_view must be (const x)
+
+is this only fine when p is the trivial PCM?
+- that's not enough; uninit still has problem with (op p (to_carrier one) Uninitialized)
+
+*)
 
 let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
   (forall x . {:pattern (g (f x))} g (f x) == x)
@@ -134,10 +216,11 @@ let sel_view_inv
   (#carrier: Type u#a)
   (#p: pcm carrier)
   (#view: Type u#b)
-  (vw: sel_view p view)
+  (#can_view_unit: bool)
+  (vw: sel_view p view can_view_unit)
 : Lemma
   (vw.to_view `g_is_inverse_of` vw.to_carrier)
-  [SMTPat (has_type vw (sel_view p view))]
+  [SMTPat (has_type vw (sel_view p view can_view_unit))]
 = let aux
     (x: view)
   : Lemma
@@ -152,7 +235,8 @@ let pts_to_view_explicit
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
   (v: Ghost.erased c)
 : Tot M.slprop
 = hp_of (pts_to r (vw.to_carrier v))
@@ -161,7 +245,8 @@ val pts_to_view_explicit_witinv
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Lemma
   (M.is_witness_invariant (pts_to_view_explicit r vw))
 
@@ -169,7 +254,8 @@ let pts_to_view_sl
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Tot M.slprop
 = M.h_exists (pts_to_view_explicit r vw)
 
@@ -177,7 +263,8 @@ let pts_to_view_sel'
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Tot (selector' c (pts_to_view_sl r vw))
 = fun h ->
   let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
@@ -187,7 +274,8 @@ let pts_to_view_depends_only_on
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
   (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
 : Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
 = let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
@@ -199,7 +287,8 @@ let pts_to_view_depends_only_on_core
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
   (m0:M.hmem (pts_to_view_sl r vw))
 : Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
 = let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
@@ -211,7 +300,8 @@ let pts_to_view_sel
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Tot (selector c (pts_to_view_sl r vw))
 = Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
   Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
@@ -222,7 +312,8 @@ let pts_to_view'
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Tot vprop'
 = {
   hp = pts_to_view_sl r vw;
@@ -235,7 +326,8 @@ let pts_to_view
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Tot vprop
 = VUnit (pts_to_view' r vw)
 
@@ -244,7 +336,8 @@ let pts_to_view_intro_lemma
   (r: ref a p)
   (x: Ghost.erased b)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
   (y: Ghost.erased c) // necessary because to_view may erase information from x
   (m: M.mem)
 : Lemma
@@ -263,7 +356,8 @@ let pts_to_view_intro
   (r: ref a p)
   (x: Ghost.erased b)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
   (y: Ghost.erased c) // necessary because to_view may erase information from x
 : A.SteelGhost unit invs
     (pts_to r x)
@@ -284,7 +378,8 @@ let pts_to_view_elim_lemma
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
   (m: M.mem)
 : Lemma
   (requires (M.interp (pts_to_view_sl r vw) m))
@@ -319,7 +414,8 @@ let pts_to_view_elim
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : A.SteelGhost (Ghost.erased b) invs
     (pts_to_view r vw)
     (fun res -> pts_to r res)
@@ -327,12 +423,12 @@ let pts_to_view_elim
     (fun h res _ ->
       Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw)) /\
       vw.to_view_prop res /\
-      ~ (Ghost.reveal res == one p)
+      True //~ (Ghost.reveal res == one p)
     )
 =
   let g : Ghost.erased c = A.gget (pts_to_view r vw) in
   let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
-  vw.to_carrier_not_one g;
+  // vw.to_carrier_not_one g;
   A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
   let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
   intro_vdep2
@@ -366,7 +462,8 @@ let ref_read_sel
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Steel c
   (pts_to_view r vw)
   (fun _ -> pts_to_view r vw)
diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/examples/steel/arraystructs/Steel.C.Struct.fst
index d53abb67faf..4a5bd937c10 100644
--- a/examples/steel/arraystructs/Steel.C.Struct.fst
+++ b/examples/steel/arraystructs/Steel.C.Struct.fst
@@ -362,6 +362,7 @@ let unaddr_of_struct_field
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   A.return ()
 
+(*
 let struct_view_to_view_prop
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
   (fa:a -> prop)
@@ -383,8 +384,6 @@ let struct_view_to_view
   let g = on_dom (refine a fa) (fun (k: refine a fa) -> (field_view k).to_view (f k)) in
   g
 
-let decidable (p: 'a -> prop) = decide:('a -> bool){forall x. decide x <==> p x}
-
 let struct_view_to_carrier
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
   (#fa:a -> prop)
@@ -400,18 +399,18 @@ let struct_view_to_carrier
     else one (p k))
   in g
 
-let struct_view_to_carrier_not_one
-  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#fa:a -> prop)
-  (dec_fa: decidable fa)
-  (view_t:(refine a fa -> Type))
-  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
-  (x:restricted_t (refine a fa) view_t)
-: Lemma
-    (requires exists (k:a). fa k)
-    (ensures struct_view_to_carrier dec_fa view_t field_view x =!= one (prod_pcm p))
-= let k = FStar.IndefiniteDescription.indefinite_description_ghost a fa in
-  (field_view k).to_carrier_not_one (x k)
+// let struct_view_to_carrier_not_one
+//   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+//   (#fa:a -> prop)
+//   (dec_fa: decidable fa)
+//   (view_t:(refine a fa -> Type))
+//   (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
+//   (x:restricted_t (refine a fa) view_t)
+// : Lemma
+//     (requires exists (k:a). fa k)
+//     (ensures struct_view_to_carrier dec_fa view_t field_view x =!= one (prod_pcm p))
+// = let k = FStar.IndefiniteDescription.indefinite_description_ghost a fa in
+//   (field_view k).to_carrier_not_one (x k)
 
 let struct_view_to_view_frame
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
@@ -438,20 +437,90 @@ let struct_view_to_view_frame
   assert (
     struct_view_to_view view_t field_view
        (op (prod_pcm p) (struct_view_to_carrier dec_fa view_t field_view x) frame) `feq` x)
+*)
+
+let mem (#a:eqtype) (xs:list a) x : prop = List.mem x xs == true
+
+let struct_view_to_view_prop 
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: restricted_t a b -> prop
+= fun f -> forall (k:a). (mem included k ==> (field_view k).to_view_prop (f k))
+
+let struct_view_to_view
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: refine (restricted_t a b) (struct_view_to_view_prop field_view included) ->
+  Tot (restricted_t (refine a (mem included)) view_t)
+= fun f -> on_dom (refine a (mem included)) (fun k -> (field_view k).to_view (f k))
+
+let struct_view_to_carrier
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: restricted_t (refine a (mem included)) view_t ->
+  Tot (refine (restricted_t a b) (struct_view_to_view_prop field_view included))
+= fun f ->
+  let g: restricted_t a b = on_dom a (fun k ->
+    if k `List.mem` included then
+      (field_view k).to_carrier (f k) <: b k
+    else one (p k))
+  in g
+
+let struct_view_to_view_frame
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+  (x:restricted_t (refine a (mem included)) view_t)
+  (frame: restricted_t a b)
+: Lemma
+    (requires (composable (prod_pcm p) (struct_view_to_carrier field_view included x) frame))
+    (ensures
+      struct_view_to_view_prop field_view included
+        (op (prod_pcm p) (struct_view_to_carrier field_view included x) frame) /\ 
+      struct_view_to_view field_view included
+        (op (prod_pcm p) (struct_view_to_carrier field_view included x) frame) == x)
+= let aux (k:refine a (mem included))
+  : Lemma (
+      (field_view k).to_view_prop (op (p k) ((field_view k).to_carrier (x k)) (frame k)) /\
+      (field_view k).to_view (op (p k) ((field_view k).to_carrier (x k)) (frame k)) == x k)
+  = assert (composable (p k) ((field_view k).to_carrier (x k)) (frame k));
+    (field_view k).to_view_frame (x k) (frame k)
+  in forall_intro aux;
+  assert (
+    struct_view_to_view field_view included
+       (op (prod_pcm p) (struct_view_to_carrier field_view included x) frame) `feq` x)
 
 let struct_view
-  (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#fa:a -> prop)
-  (dec_fa:decidable fa)
-  (view_t:refine a fa -> Type)
-  (field_view:(k:refine a fa -> sel_view (p k) (view_t k)))
-: Pure (sel_view (prod_pcm p) (restricted_t (refine a fa) view_t))
-    (requires exists (k:a). fa k)
-    (ensures fun _ -> True)
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: sel_view (prod_pcm p)
+    (restricted_t (refine a (mem included)) view_t)
+    (can_view_units || Nil? included)
 = {
-  to_view_prop = struct_view_to_view_prop fa view_t field_view;
-  to_view = struct_view_to_view view_t field_view;
-  to_carrier = struct_view_to_carrier dec_fa view_t field_view;
-  to_carrier_not_one = struct_view_to_carrier_not_one dec_fa view_t field_view;
-  to_view_frame = struct_view_to_view_frame dec_fa view_t field_view;
+  to_view_prop = struct_view_to_view_prop field_view included;
+  to_view = struct_view_to_view field_view included;
+  to_carrier = struct_view_to_carrier field_view included;
+  to_carrier_not_one = begin
+    let aux () : Lemma
+      (requires ~ (can_view_units || Nil? included))
+      (ensures
+        ~ (exists x. struct_view_to_carrier field_view included x == one (prod_pcm p)) /\
+        ~ (struct_view_to_view_prop field_view included (one (prod_pcm p))))
+    = let k :: _ = included in ()
+    in move_requires aux () end;
+  to_view_frame = struct_view_to_view_frame field_view included;
 }
diff --git a/examples/steel/arraystructs/Steel.C.Uninit.fsti b/examples/steel/arraystructs/Steel.C.Uninit.fsti
index 3a603768d97..611ba1e3103 100644
--- a/examples/steel/arraystructs/Steel.C.Uninit.fsti
+++ b/examples/steel/arraystructs/Steel.C.Uninit.fsti
@@ -194,12 +194,12 @@ let uninit_view
   );
   to_carrier = (fun v -> match v with
   | Uninitialized -> Uninitialized
-  | InitOrUnit v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v')
+  | InitOrUnit v' -> (*w.to_carrier_not_one v'; *)InitOrUnit (w.to_carrier v')
   );
-  to_carrier_not_one = (fun v -> match v with
+  to_carrier_not_one = (fun v -> () (*match v with
   | Uninitialized -> ()
   | InitOrUnit v' -> w.to_carrier_not_one v'
-  );
+  *));
   to_view_frame = (fun v frame -> match v with
   | Uninitialized -> ()
   | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
@@ -221,7 +221,7 @@ let uninit_view_initialized
   | InitOrUnit x' -> w.to_view x'
   );
   to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
-  to_carrier_not_one = (fun v -> w.to_carrier_not_one v);
+  to_carrier_not_one = (fun v -> () (*w.to_carrier_not_one v*));
   to_view_frame = (fun v frame ->
     w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
   );
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index a18d5250700..096faeebf17 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -495,10 +495,12 @@ let union_view_to_view
 
 let union_view_to_carrier
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
-    ~ (s.to_view_prop (one (p k)))
-    // TODO Can we add this to the definition of a view?
-  }))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
+  //{
+  //  ~ (s.to_view_prop (one (p k)))
+  //  // TODO Can we add this to the definition of a view?
+  //}))
+  ))
 : dtuple2 a view_t -> refine (union p) (union_view_to_view_prop field_view)
 = fun (|k, x|) ->
   let u: union p = field_to_union_f p k ((field_view k).to_carrier x) in
@@ -506,23 +508,31 @@ let union_view_to_carrier
   assert (u k == (field_view k).to_carrier x);
   assert ((field_view k).to_view_prop ((field_view k).to_carrier x));
   assert ((field_view k).to_view_prop (u k));
+  // If (to_carrier x =!= one (p k)), then k is the unique k s.t. case_refinement p k u
+  // and we are done.
+  // If (to_carrier x == one (p k)), then must show that
+  //   forall k. to_view_prop (u k)
   u
 
-let union_view_to_carrier_not_one
-  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
-    ~ (s.to_view_prop (one (p k)))
-    // TODO Can we add this to the definition of a view?
-  }))
-: u:dtuple2 a view_t -> Lemma (union_view_to_carrier field_view u =!= one (union_pcm p))
-= fun _ -> ()
+// let union_view_to_carrier_not_one
+//   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+//   (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
+//   //{
+//   //  ~ (s.to_view_prop (one (p k)))
+//   //  // TODO Can we add this to the definition of a view?
+//   //}))
+//   ))
+// : u:dtuple2 a view_t -> Lemma (union_view_to_carrier field_view u =!= one (union_pcm p))
+// = fun _ -> ()
 
 let union_view_to_view_frame
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
-    ~ (s.to_view_prop (one (p k)))
-    // TODO Can we add this to the definition of a view?
-  }))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
+  //{
+  //  ~ (s.to_view_prop (one (p k)))
+  //  // TODO Can we add this to the definition of a view?
+  //}))
+  ))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
 : (v: dtuple2 a view_t) ->
   (u: union p) ->
@@ -539,16 +549,18 @@ let union_view_to_view_frame
 
 let union_view
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k) {
-    ~ (s.to_view_prop (one (p k)))
-    // TODO Can we add this to the definition of a view?
-  }))
+  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
+  //{
+  //  ~ (s.to_view_prop (one (p k)))
+  //  // TODO Can we add this to the definition of a view?
+  //}))
+  ))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
 : Tot (sel_view (union_pcm p) (dtuple2 a view_t))
 = {
   to_view_prop = union_view_to_view_prop field_view;
   to_view = union_view_to_view field_view case_of;
   to_carrier = union_view_to_carrier field_view;
-  to_carrier_not_one = union_view_to_carrier_not_one field_view;
+  to_carrier_not_one = (fun _ -> ()); // union_view_to_carrier_not_one field_view;
   to_view_frame = union_view_to_view_frame field_view case_of;
 }

From 3485c5c745a2c490c437d54a59456004875d7621 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 15:54:35 -0700
Subject: [PATCH 134/513] Views for unions

---
 examples/steel/arraystructs/Steel.C.Ref.fsti  | 83 -------------------
 examples/steel/arraystructs/Steel.C.Union.fst | 78 ++++++++---------
 2 files changed, 36 insertions(+), 125 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 1e24ef213de..51e06958522 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -114,7 +114,6 @@ type sel_view
   (can_view_unit:bool)
 = {
   to_view_prop: (carrier -> Tot prop);
-  // (to_view_prop (one p) <==> prop only contains unit)
   to_view: (refine carrier to_view_prop -> Tot view);
   to_carrier: (view -> Tot (refine carrier to_view_prop));
   to_carrier_not_one:
@@ -127,88 +126,6 @@ type sel_view
     (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
 }
 
-(*
-finite n = m:nat{m < n}
-a `iso` finite _
-
-fun 
-  "field1" -> 0
-  "field2" -> 1
-
-all : (finite n -> bool) -> bool
-ex : (finite n -> bool) -> bool
-
-desc = list (string * Type & pcm & view & ..)
-
-restricted_t 'a 'b ---> struct_t 'a 'b with the right equations
-typedef_struct: string -> .. -> struct_t 'a 'b
-
-typedef_struct A
-
-struct A { int x, y; };
-struct B { int x, y; };
-
-view_cases:(k:a -> sel_view p view false)
-sel_view (union p) .. false
-
-view_field:(k:a -> sel_view p view (can_view_unit k))
-sel_view (prod p) .. (k empty \/ all can_view_unit)
-*)
-
-(*
-
-Current sel_view:
-- uninit_view fails (to_carrier (InitOrUnit one) == one is composable with Uninitialized,
-  so to_view (op p (to_carrier (InitOrUnit one)) Uninitialized) == InitOrUnit one fails)
-- init_view_initialized fails for same reason
-
-Can we add side conditions to uninit_view and init_view to make them work?
-- How to add side conditions without these bubbling up to selectors for structs and unions?
-  For example, if explicitly excluded unit from PCM passed to uninit selector,
-  then can't write selector for a possibly-uninitialized struct that one has taken pointers
-  to all fields of.
-
-Can we define Uninitialized with an extra constructor explicitly for Unit?
-i.e.
-  Uninitialized
-  Init x
-  One
-and no longer have composable (Init (one p)) Uninitialized.
-
-Different idea:
-
-to_view . to_carrier = id
-forall x, whole_value (to_carrier x)
-  i.e. forall y. to_carrier x * y == to_carrier x
-
-From this could prove to_view_frame.
-- uninit_view satisfies this
-- so does uninit_view_initialized
-- partial struct fails (partial structs aren't whole values)
-- unions fail if one of the cases of the union is the trivial PCM
-
-
-If
-  to_view_frame:
-    (x: view) ->
-    (frame: carrier) ->
-    Lemma
-    (requires (composable p (to_carrier x) frame))
-    (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
-then
-
-1. specializing with (frame := unit) gives (to_view . to_carrier == id)
-2. specializing with (to_carrier x == one) gives
-     (forall y. to_view_prop y /\ to_view y == x));
-
-that is, if we want to_view_frame to hold, and there exists an x s.t. to_carrier x == one,
-then to_view_prop must be (const True) and to_view must be (const x)
-
-is this only fine when p is the trivial PCM?
-- that's not enough; uninit still has problem with (op p (to_carrier one) Uninitialized)
-
-*)
-
 let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
   (forall x . {:pattern (g (f x))} g (f x) == x)
 
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 096faeebf17..91c6be149e9 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -480,87 +480,81 @@ let unaddr_of_union_field
 
 let union_view_to_view_prop
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> sel_view (p k) (view_t k)))
+  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
 : union p -> Tot prop
-= fun u -> forall k. case_refinement_f p k u ==> (field_view k).to_view_prop (u k)
+= fun u ->
+  u =!= one (union_pcm p) /\
+  (forall k. case_refinement_f p k u ==> (case_view k).to_view_prop (u k))
 
 let union_view_to_view
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> sel_view (p k) (view_t k)))
+  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
-: refine (union p) (union_view_to_view_prop field_view) -> dtuple2 a view_t
+: refine (union p) (union_view_to_view_prop case_view) -> dtuple2 a view_t
 = fun u ->
   let k = case_of u in
-  (|k, (field_view k).to_view (u k)|)
+  (|k, (case_view k).to_view (u k)|)
 
 let union_view_to_carrier
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
-  //{
-  //  ~ (s.to_view_prop (one (p k)))
-  //  // TODO Can we add this to the definition of a view?
-  //}))
-  ))
-: dtuple2 a view_t -> refine (union p) (union_view_to_view_prop field_view)
+  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
+: dtuple2 a view_t -> refine (union p) (union_view_to_view_prop case_view)
 = fun (|k, x|) ->
-  let u: union p = field_to_union_f p k ((field_view k).to_carrier x) in
+  let u: union p = field_to_union_f p k ((case_view k).to_carrier x) in
   assert (case_refinement_f p k u);
-  assert (u k == (field_view k).to_carrier x);
-  assert ((field_view k).to_view_prop ((field_view k).to_carrier x));
-  assert ((field_view k).to_view_prop (u k));
+  assert (u k == (case_view k).to_carrier x);
+  assert ((case_view k).to_view_prop ((case_view k).to_carrier x));
+  assert ((case_view k).to_view_prop (u k));
   // If (to_carrier x =!= one (p k)), then k is the unique k s.t. case_refinement p k u
   // and we are done.
   // If (to_carrier x == one (p k)), then must show that
   //   forall k. to_view_prop (u k)
   u
 
-// let union_view_to_carrier_not_one
-//   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-//   (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
-//   //{
-//   //  ~ (s.to_view_prop (one (p k)))
-//   //  // TODO Can we add this to the definition of a view?
-//   //}))
-//   ))
-// : u:dtuple2 a view_t -> Lemma (union_view_to_carrier field_view u =!= one (union_pcm p))
-// = fun _ -> ()
+let union_view_to_carrier_not_one
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
+  //{
+  //  ~ (s.to_view_prop (one (p k)))
+  //  // TODO Can we add this to the definition of a view?
+  //}))
+: u:dtuple2 a view_t -> Lemma (union_view_to_carrier case_view u =!= one (union_pcm p))
+= fun _ -> ()
 
 let union_view_to_view_frame
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
+  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
   //{
   //  ~ (s.to_view_prop (one (p k)))
   //  // TODO Can we add this to the definition of a view?
   //}))
-  ))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
 : (v: dtuple2 a view_t) ->
   (u: union p) ->
   Lemma
-    (requires composable (union_pcm p) (union_view_to_carrier field_view v) u)
+    (requires composable (union_pcm p) (union_view_to_carrier case_view v) u)
     (ensures 
-      union_view_to_view_prop field_view (op (union_pcm p) (union_view_to_carrier field_view v) u) /\
-      union_view_to_view field_view case_of
-        (op (union_pcm p) (union_view_to_carrier field_view v) u) == v)
+      union_view_to_view_prop case_view (op (union_pcm p) (union_view_to_carrier case_view v) u) /\
+      union_view_to_view case_view case_of
+        (op (union_pcm p) (union_view_to_carrier case_view v) u) == v)
 = fun (|k, x|) u ->
-  assert (composable (p k) ((field_view k).to_carrier x) (u k));
-  (field_view k).to_view_frame x (u k);
+  assert (composable (p k) ((case_view k).to_carrier x) (u k));
+  (case_view k).to_view_frame x (u k);
   ()
 
 let union_view
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (field_view:(k:a -> s:sel_view (p k) (view_t k)
+  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
   //{
   //  ~ (s.to_view_prop (one (p k)))
   //  // TODO Can we add this to the definition of a view?
   //}))
-  ))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
-: Tot (sel_view (union_pcm p) (dtuple2 a view_t))
+: Tot (sel_view (union_pcm p) (dtuple2 a view_t) false)
 = {
-  to_view_prop = union_view_to_view_prop field_view;
-  to_view = union_view_to_view field_view case_of;
-  to_carrier = union_view_to_carrier field_view;
-  to_carrier_not_one = (fun _ -> ()); // union_view_to_carrier_not_one field_view;
-  to_view_frame = union_view_to_view_frame field_view case_of;
+  to_view_prop = union_view_to_view_prop case_view;
+  to_view = union_view_to_view case_view case_of;
+  to_carrier = union_view_to_carrier case_view;
+  to_carrier_not_one = ();
+  to_view_frame = union_view_to_view_frame case_view case_of;
 }

From ed039774e35a5dfb86fc2169ff7e7b5359818f21 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 15:55:59 -0700
Subject: [PATCH 135/513] Tidy

---
 examples/steel/arraystructs/Steel.C.Union.fst | 53 ++-----------------
 1 file changed, 3 insertions(+), 50 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 91c6be149e9..961a9f77399 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -491,64 +491,17 @@ let union_view_to_view
   (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
 : refine (union p) (union_view_to_view_prop case_view) -> dtuple2 a view_t
-= fun u ->
-  let k = case_of u in
-  (|k, (case_view k).to_view (u k)|)
+= fun u -> let k = case_of u in (|k, (case_view k).to_view (u k)|)
 
 let union_view_to_carrier
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
   (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
 : dtuple2 a view_t -> refine (union p) (union_view_to_view_prop case_view)
-= fun (|k, x|) ->
-  let u: union p = field_to_union_f p k ((case_view k).to_carrier x) in
-  assert (case_refinement_f p k u);
-  assert (u k == (case_view k).to_carrier x);
-  assert ((case_view k).to_view_prop ((case_view k).to_carrier x));
-  assert ((case_view k).to_view_prop (u k));
-  // If (to_carrier x =!= one (p k)), then k is the unique k s.t. case_refinement p k u
-  // and we are done.
-  // If (to_carrier x == one (p k)), then must show that
-  //   forall k. to_view_prop (u k)
-  u
-
-let union_view_to_carrier_not_one
-  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
-  //{
-  //  ~ (s.to_view_prop (one (p k)))
-  //  // TODO Can we add this to the definition of a view?
-  //}))
-: u:dtuple2 a view_t -> Lemma (union_view_to_carrier case_view u =!= one (union_pcm p))
-= fun _ -> ()
-
-let union_view_to_view_frame
-  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
-  //{
-  //  ~ (s.to_view_prop (one (p k)))
-  //  // TODO Can we add this to the definition of a view?
-  //}))
-  (case_of:(u:union p -> k:a{case_refinement_f p k u}))
-: (v: dtuple2 a view_t) ->
-  (u: union p) ->
-  Lemma
-    (requires composable (union_pcm p) (union_view_to_carrier case_view v) u)
-    (ensures 
-      union_view_to_view_prop case_view (op (union_pcm p) (union_view_to_carrier case_view v) u) /\
-      union_view_to_view case_view case_of
-        (op (union_pcm p) (union_view_to_carrier case_view v) u) == v)
-= fun (|k, x|) u ->
-  assert (composable (p k) ((case_view k).to_carrier x) (u k));
-  (case_view k).to_view_frame x (u k);
-  ()
+= fun (|k, x|) -> field_to_union_f p k ((case_view k).to_carrier x)
 
 let union_view
   (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
   (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
-  //{
-  //  ~ (s.to_view_prop (one (p k)))
-  //  // TODO Can we add this to the definition of a view?
-  //}))
   (case_of:(u:union p -> k:a{case_refinement_f p k u}))
 : Tot (sel_view (union_pcm p) (dtuple2 a view_t) false)
 = {
@@ -556,5 +509,5 @@ let union_view
   to_view = union_view_to_view case_view case_of;
   to_carrier = union_view_to_carrier case_view;
   to_carrier_not_one = ();
-  to_view_frame = union_view_to_view_frame case_view case_of;
+  to_view_frame = (fun (|k, x|) u -> (case_view k).to_view_frame x (u k));
 }

From 4a66fffa5abf4f98396d10de30f7c3d008b4672e Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 23 Jul 2021 15:58:55 -0700
Subject: [PATCH 136/513] Fix Frac, Uninit views

---
 examples/steel/arraystructs/PointStruct.fsti  | 16 ++++++-------
 examples/steel/arraystructs/Steel.C.Frac.fsti |  4 ++--
 .../steel/arraystructs/Steel.C.Uninit.fsti    | 23 ++++++++-----------
 3 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index 9b7dff34f14..d009a6a025f 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -63,12 +63,12 @@ val unaddr_of_y
 
 /// Views
 
-let point_view excluded : sel_view point_pcm (k:field_name not in excluded -> fields k)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> Some?.v x);
-  to_carrier = (fun z  -> Some z);
-  to_carrier_not_one = (fun _ -> ());
-  to_view_frame = (fun x frame -> ());
-}
+// let point_view excluded : sel_view point_pcm (k:field_name not in excluded -> fields k)
+// = {
+//   to_view_prop = (fun x -> Some? x == true);
+//   to_view = (fun x -> Some?.v x);
+//   to_carrier = (fun z  -> Some z);
+//   to_carrier_not_one = (fun _ -> ());
+//   to_view_frame = (fun x frame -> ());
+// }
 
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fsti b/examples/steel/arraystructs/Steel.C.Frac.fsti
index 0ced9e32120..356ef323ede 100644
--- a/examples/steel/arraystructs/Steel.C.Frac.fsti
+++ b/examples/steel/arraystructs/Steel.C.Frac.fsti
@@ -68,12 +68,12 @@ val exclusive_frac
 let frac_view
   (a: Type)
   (p: perm)
-: Tot (sel_view (pcm_frac #a) a)
+: Tot (sel_view (pcm_frac #a) a false)
 = {
   to_view_prop = (fun x -> Some? x == true);
   to_view = (fun x -> let Some (v, _) = x in v);
   to_carrier = (fun v -> Some (v, p));
-  to_carrier_not_one = (fun _ -> ());
+  to_carrier_not_one = ();
   to_view_frame = (fun v frame -> ());
 }
 
diff --git a/examples/steel/arraystructs/Steel.C.Uninit.fsti b/examples/steel/arraystructs/Steel.C.Uninit.fsti
index 611ba1e3103..a065d47d04b 100644
--- a/examples/steel/arraystructs/Steel.C.Uninit.fsti
+++ b/examples/steel/arraystructs/Steel.C.Uninit.fsti
@@ -181,8 +181,8 @@ let uninit_view
   (#a: Type)
   (#p: pcm a)
   (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b))
+  (w: sel_view p b false)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) (uninit_t b) false)
 = {
   to_view_prop = (fun x -> match x with
   | Uninitialized -> True
@@ -194,15 +194,12 @@ let uninit_view
   );
   to_carrier = (fun v -> match v with
   | Uninitialized -> Uninitialized
-  | InitOrUnit v' -> (*w.to_carrier_not_one v'; *)InitOrUnit (w.to_carrier v')
+  | InitOrUnit v' -> InitOrUnit (w.to_carrier v')
   );
-  to_carrier_not_one = (fun v -> () (*match v with
-  | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'
-  *));
+  to_carrier_not_one = ();
   to_view_frame = (fun v frame -> match v with
   | Uninitialized -> ()
-  | InitOrUnit v' -> w.to_carrier_not_one v'; let InitOrUnit frame' = frame in w.to_view_frame v' frame'
+  | InitOrUnit v' -> let InitOrUnit frame' = frame in w.to_view_frame v' frame'
   );
 }
 
@@ -210,8 +207,8 @@ let uninit_view_initialized
   (#a: Type)
   (#p: pcm a)
   (#b: Type)
-  (w: sel_view p b)
-: Tot (sel_view #(uninit_t a) (pcm_uninit p) b)
+  (w: sel_view p b false)
+: Tot (sel_view #(uninit_t a) (pcm_uninit p) b false)
 = {
   to_view_prop = (fun x -> match x with
   | Uninitialized -> False
@@ -220,9 +217,9 @@ let uninit_view_initialized
   to_view = (fun x -> match x with
   | InitOrUnit x' -> w.to_view x'
   );
-  to_carrier = (fun v' -> w.to_carrier_not_one v'; InitOrUnit (w.to_carrier v'));
-  to_carrier_not_one = (fun v -> () (*w.to_carrier_not_one v*));
+  to_carrier = (fun v' -> InitOrUnit (w.to_carrier v'));
+  to_carrier_not_one = ();
   to_view_frame = (fun v frame ->
-    w.to_carrier_not_one v; let InitOrUnit frame' = frame in w.to_view_frame v frame'
+    let InitOrUnit frame' = frame in w.to_view_frame v frame'
   );
 }

From 15e2624bbe249f59e38c17d0a76f292e6cc81a19 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 26 Jul 2021 10:34:28 -0700
Subject: [PATCH 137/513] Start StructPoint example with selectors

---
 examples/steel/arraystructs/ListNode.fsti    |   2 +-
 examples/steel/arraystructs/PointStruct.fst  | 228 ++++++++++++++++---
 examples/steel/arraystructs/PointStruct.fsti |  46 ++++
 examples/steel/arraystructs/Steel.C.Ref.fsti |   8 +
 4 files changed, 256 insertions(+), 28 deletions(-)

diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index 42c857cdc48..aeb390432b4 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -42,7 +42,7 @@ val mk_node_refine (i: option int) (next: option (ptr node node))
     (ensures p_refine node_pcm (mk_node i next))
     [SMTPat (p_refine node_pcm (mk_node i next))]
 
-/// Lenses for fields
+/// Connections for fields
 
 val _value: node_pcm `connection` opt_pcm #int
 val _next: node_pcm `connection` opt_pcm #(ptr node node)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index c81f1df4622..c04e3678bde 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -8,66 +8,240 @@ open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-let point_fields k = match k with
-  | X -> option int
-  | Y -> option int
-let point = restricted_t point_field point_fields
-
-let point_fields_pcm k : pcm (point_fields k) = match k with
-  | X -> opt_pcm #int
-  | Y -> opt_pcm #int
-let point_pcm = prod_pcm point_fields_pcm
-
-let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
-  | X -> x
-  | Y -> y
-  
+open Steel.C.Typedef
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+
+let c_int: typedef = {
+  carrier = option int;
+  pcm = opt_pcm #int;
+  view_type = int;
+  can_view_unit = false;
+  view = opt_view int;
+}
+
+let point_fields = [
+  "x", c_int;
+  "y", c_int;
+]
+
+(* TODO move to Steel.C.Typedef *)
+let struct_field_view_types fields = restricted_t (field_of fields) (type_family_of fields)
+let struct_field_pcm_carriers (fields: _) (field: field_of fields) = (get_field fields field).carrier
+let struct_field_pcms (fields: _) (field: field_of fields) = (get_field fields field).pcm
+let struct_pcm_carrier (fields: list (string * typedef)) =
+  restricted_t (field_of fields) (struct_field_pcm_carriers fields)
+let struct_pcm (fields: list (string * typedef)) = prod_pcm (struct_field_pcms fields)
+
+let point = struct_field_view_types point_fields
+let point_fields_pcm_carriers = struct_field_pcm_carriers point_fields
+let point_fields_pcms = struct_field_pcms point_fields
+let point_pcm_carrier = struct_pcm_carrier point_fields
+let point_pcm = struct_pcm point_fields
+
+(* TODO move to Typedef *)
+let rec mk_struct_curried_dom (fields: list (string * typedef)): Type =
+  match fields with
+  | [] -> unit
+  | [(_, td)] -> td.carrier
+  | (_, td) :: fields -> td.carrier * mk_struct_curried_dom fields
+
+let rec mk_struct_curried (fields: list (string * typedef))
+: mk_struct_curried_dom fields -> struct_pcm_carrier fields
+= match fields with
+  | [] -> 
+    fun () -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
+  | [(field, td)] ->
+    fun x -> on_dom (field_of fields) (fun field' ->
+    assert (field == field'); x <: struct_field_pcm_carriers fields field')
+  | (field, td) :: fields' ->
+    fun ((x, xs): td.carrier * mk_struct_curried_dom fields') ->
+    on_dom (field_of fields) (fun field'' ->
+    if field'' = field then x
+    else mk_struct_curried fields' xs field'' <: struct_field_pcm_carriers fields field'')
+
+let mk_point_f_lame (x y: option int) (field: field_of point_fields)
+: point_fields_pcm_carriers field
+= match field with
+  | "x" -> x
+  | "y" -> y
+
+let mk_point_curried
+: option int * option int -> struct_pcm_carrier point_fields
+= mk_struct_curried point_fields
+
+let _ =
+  let test (k: field_of point_fields) (x y: option int) =
+    assert (mk_point_f_lame x y k == mk_point_curried (x, y) k)
+  in ()
+
+let rec list_fn (dom: list Type) (cod: Type) =
+  match dom with
+  | [] -> cod
+  | d :: dom -> d -> list_fn dom cod
+
+let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b =
+  match dom with 
+  | [] -> f g <: [] `list_fn` 'b
+  | d :: dom' ->
+    let g: d -> dom' `list_fn` 'a = g in
+    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
+
+(* TODO move to Typedef *)
+let field_pcm_carrier ((_, td): string * typedef) = td.carrier
+let mk_struct_ty (fields: list (string * typedef)): Type =
+  map field_pcm_carrier fields `list_fn` struct_pcm_carrier fields
+
+let rec mk_struct (fields: list (string * typedef)): mk_struct_ty fields
+= match fields with
+  | [] -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
+  | (field, td) :: fields' ->
+    fun (x:td.carrier) ->
+    let f: map field_pcm_carrier fields' `list_fn` struct_pcm_carrier fields' = mk_struct fields' in
+    let lift_struct (g: struct_pcm_carrier fields'): struct_pcm_carrier fields =
+      let h (field': field_of fields): struct_field_pcm_carriers fields field' =
+        if field' = field then x else g field'
+      in on_dom _ h
+    in
+    list_fn_map lift_struct f
+
+let mk_point_uncurried
+: option int -> option int -> struct_pcm_carrier point_fields
+= mk_struct point_fields
+
+let _ =
+  let test (k: field_of point_fields) (x y: option int) =
+    assert (mk_point_f_lame x y k == mk_point_uncurried x y k)
+  in ()
+
 let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
-  Ghost.hide (on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y)))
+  Ghost.hide (on_dom _ (mk_point_f_lame (Ghost.reveal x) (Ghost.reveal y)))
 
-let _x = struct_field point_fields_pcm X
-let _y = struct_field point_fields_pcm Y
+let _x = struct_field point_fields_pcms "x"
+let _y = struct_field point_fields_pcms "y"
 
 /// Taking pointers to the x and y fields of a point
 
 let point_without_x x y
-: Lemma (struct_without_field point_fields_pcm X (mk_point x y) `feq` Ghost.reveal (mk_point none y))
+: Lemma (struct_without_field point_fields_pcms "x" (mk_point x y) `feq` Ghost.reveal (mk_point none y))
   [SMTPat (mk_point x y)]
 = ()
 
 let point_with_x x y
-: Lemma (struct_with_field point_fields_pcm X (Ghost.reveal x) (mk_point none y) `feq`
+: Lemma (struct_with_field point_fields_pcms "x" (Ghost.reveal x) (mk_point none y) `feq`
          Ghost.reveal (mk_point x y))
   [SMTPat (mk_point x y)]
 = ()
 
 let point_without_y x y
-: Lemma (struct_without_field point_fields_pcm Y (mk_point x y) `feq` Ghost.reveal (mk_point x none))
+: Lemma (struct_without_field point_fields_pcms "y" (mk_point x y) `feq` Ghost.reveal (mk_point x none))
   [SMTPat (mk_point x y)]
 = ()
 
 let point_with_y x y
-: Lemma (struct_with_field point_fields_pcm Y (Ghost.reveal y) (mk_point x none) `feq`
+: Lemma (struct_with_field point_fields_pcms "y" (Ghost.reveal y) (mk_point x none) `feq`
          Ghost.reveal (mk_point x y))
   [SMTPat (mk_point x y)]
 = ()
 
+let aux x y : unit
+= assert ((struct_without_field point_fields_pcms "x" (mk_point x y)
+      <: restricted_t (field_of point_fields) point_fields_pcm_carriers) `feq`
+    (Ghost.reveal (mk_point none y) 
+      <: restricted_t (field_of point_fields) point_fields_pcm_carriers)
+    );
+  assert ((struct_without_field point_fields_pcms "x" (mk_point x y)
+      <: restricted_t (field_of point_fields) point_fields_pcm_carriers) ==
+    (Ghost.reveal (mk_point none y) 
+      <: restricted_t (field_of point_fields) point_fields_pcm_carriers)
+    );
+  ()
+
+let aux x y : unit
+= assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
+  ()
+
 let addr_of_x #a #x #y p =
-  let q = addr_of_struct_field p X (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
+  let q = addr_of_struct_field p "x" (mk_point x y) in
+  assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
+  //A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
+  A.sladmit();
   A.return q
-  
+
+let addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
 let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "x" q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
-  let q = addr_of_struct_field p Y (mk_point x y) in
+  let q = addr_of_struct_field p "y" (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
 let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x none) y; // same here
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "y" q p (mk_point x none) y; // same here
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let struct_point_fields = [
+  "x", c_int;
+  "y", c_int;
+]
+
+let point_field_of_string (field: field_of struct_point_fields): point_field =
+  match field with
+  | "x" -> X
+  | "y" -> Y
+
+let struct_point_view_t (k: field_of struct_point_fields): Type =
+  (get_field struct_point_fields k).view_type
+
+let struct_point_view_pcm_t (k: field_of struct_point_fields): Type =
+  point_fields (point_field_of_string k)
+  
+let struct_point_view_pcm (k: field_of struct_point_fields)
+: pcm (struct_point_view_pcm_t k)
+= point_fields_pcms (point_field_of_string k)
+
+let struct_point_fields_view (k:field_of struct_point_fields)
+: sel_view (point_fields_pcms (point_field_of_string k)) (struct_point_view_t k) false
+= (get_field struct_point_fields k).view
+
+(*
+let struct_view
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: sel_view (prod_pcm p)
+    (restricted_t (refine a (mem included)) view_t)
+    (can_view_units || Nil? included) *)
+
+let point_view
+//: sel_view (prod_pcm struct_point_view_pcm_t) (view_type_of struct_point_fields) false
+= struct_view struct_point_fields_view (map (admit() )struct_point_fields)
+
+// = {
+//   to_view_prop = (fun x -> Some? x == true);
+//   to_view = (fun x -> Some?.v x);
+//   to_carrier = (fun z  -> Some z);
+//   to_carrier_not_one = ();
+//   to_view_frame = (fun x frame -> ());
+// }
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index d009a6a025f..a89dd6c98bf 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -72,3 +72,49 @@ val unaddr_of_y
 //   to_view_frame = (fun x frame -> ());
 // }
 
+// val node_view: sel_view node_pcm _ false
+
+(*
+val addr_of_value_sel (p: ref 'a node_pcm)
+: Steel (ref 'a (opt_pcm #int))
+    (p `pts_to_view` node_view)
+    (fun q ->
+       (p `pts_to` mk_node none next) `star`
+       (q `pts_to` value))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> q == ref_focus p _value))
+
+val unaddr_of_value
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (ptr node node)))
+  (p: ref 'a node_pcm)
+  (q: ref 'a (opt_pcm #int))
+: Steel unit
+    ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
+    (fun q -> p `pts_to` mk_node value next)
+    (requires (fun _ -> q == ref_focus p _value))
+    (ensures (fun _ _ _ -> True))
+
+val addr_of_next
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (ptr node node)))
+  (p: ref 'a node_pcm)
+: Steel (ref 'a (opt_pcm #(ptr node node)))
+    (p `pts_to` mk_node value next)
+    (fun q ->
+       (p `pts_to` mk_node value none) `star`
+       (q `pts_to` next))
+    (requires (fun _ -> True))
+    (ensures (fun _ q _ -> q == ref_focus p _next))
+
+val unaddr_of_next
+  (#value:Ghost.erased (option int))
+  (#next:Ghost.erased (option (ptr node node)))
+  (p: ref 'a node_pcm)
+  (q: ref 'a (opt_pcm #(ptr node node)))
+: Steel unit
+    ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
+    (fun q -> p `pts_to` mk_node value next)
+    (requires (fun _ -> q == ref_focus p _next))
+    (ensures (fun _ _ _ -> True))
+*)
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 51e06958522..bf218b4d28c 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -126,6 +126,14 @@ type sel_view
     (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
 }
 
+let weaken_view (#p: pcm 'a) (v: sel_view p 'b false): sel_view p 'b true = {
+  to_view_prop = v.to_view_prop;
+  to_view = v.to_view;
+  to_carrier = v.to_carrier;
+  to_carrier_not_one = ();
+  to_view_frame = v.to_view_frame;
+}
+
 let g_is_inverse_of (#a #b: Type) (g: (b -> GTot a)) (f: (a -> GTot b)) : Tot prop =
   (forall x . {:pattern (g (f x))} g (f x) == x)
 

From e3e0e967212fb4efbe25a87982eb481792248d80 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 26 Jul 2021 15:34:59 -0700
Subject: [PATCH 138/513] Add Steel.C.{Typedef,StructLiteral}

---
 examples/steel/arraystructs/PointStruct.fst   | 228 ++--------
 examples/steel/arraystructs/PointStruct.fsti  |  57 ---
 .../arraystructs/PointStructSelectors.fst     | 294 +++++++++++++
 .../arraystructs/Steel.C.StructLiteral.fst    | 408 ++++++++++++++++++
 .../steel/arraystructs/Steel.C.Typedef.fst    | 123 ++++++
 5 files changed, 852 insertions(+), 258 deletions(-)
 create mode 100644 examples/steel/arraystructs/PointStructSelectors.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.StructLiteral.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Typedef.fst

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index c04e3678bde..c81f1df4622 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -8,240 +8,66 @@ open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-open Steel.C.Typedef
-open FStar.List.Tot
-open FStar.FunctionalExtensionality
-
-let c_int: typedef = {
-  carrier = option int;
-  pcm = opt_pcm #int;
-  view_type = int;
-  can_view_unit = false;
-  view = opt_view int;
-}
-
-let point_fields = [
-  "x", c_int;
-  "y", c_int;
-]
-
-(* TODO move to Steel.C.Typedef *)
-let struct_field_view_types fields = restricted_t (field_of fields) (type_family_of fields)
-let struct_field_pcm_carriers (fields: _) (field: field_of fields) = (get_field fields field).carrier
-let struct_field_pcms (fields: _) (field: field_of fields) = (get_field fields field).pcm
-let struct_pcm_carrier (fields: list (string * typedef)) =
-  restricted_t (field_of fields) (struct_field_pcm_carriers fields)
-let struct_pcm (fields: list (string * typedef)) = prod_pcm (struct_field_pcms fields)
-
-let point = struct_field_view_types point_fields
-let point_fields_pcm_carriers = struct_field_pcm_carriers point_fields
-let point_fields_pcms = struct_field_pcms point_fields
-let point_pcm_carrier = struct_pcm_carrier point_fields
-let point_pcm = struct_pcm point_fields
-
-(* TODO move to Typedef *)
-let rec mk_struct_curried_dom (fields: list (string * typedef)): Type =
-  match fields with
-  | [] -> unit
-  | [(_, td)] -> td.carrier
-  | (_, td) :: fields -> td.carrier * mk_struct_curried_dom fields
-
-let rec mk_struct_curried (fields: list (string * typedef))
-: mk_struct_curried_dom fields -> struct_pcm_carrier fields
-= match fields with
-  | [] -> 
-    fun () -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
-  | [(field, td)] ->
-    fun x -> on_dom (field_of fields) (fun field' ->
-    assert (field == field'); x <: struct_field_pcm_carriers fields field')
-  | (field, td) :: fields' ->
-    fun ((x, xs): td.carrier * mk_struct_curried_dom fields') ->
-    on_dom (field_of fields) (fun field'' ->
-    if field'' = field then x
-    else mk_struct_curried fields' xs field'' <: struct_field_pcm_carriers fields field'')
-
-let mk_point_f_lame (x y: option int) (field: field_of point_fields)
-: point_fields_pcm_carriers field
-= match field with
-  | "x" -> x
-  | "y" -> y
-
-let mk_point_curried
-: option int * option int -> struct_pcm_carrier point_fields
-= mk_struct_curried point_fields
-
-let _ =
-  let test (k: field_of point_fields) (x y: option int) =
-    assert (mk_point_f_lame x y k == mk_point_curried (x, y) k)
-  in ()
-
-let rec list_fn (dom: list Type) (cod: Type) =
-  match dom with
-  | [] -> cod
-  | d :: dom -> d -> list_fn dom cod
-
-let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b =
-  match dom with 
-  | [] -> f g <: [] `list_fn` 'b
-  | d :: dom' ->
-    let g: d -> dom' `list_fn` 'a = g in
-    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
-
-(* TODO move to Typedef *)
-let field_pcm_carrier ((_, td): string * typedef) = td.carrier
-let mk_struct_ty (fields: list (string * typedef)): Type =
-  map field_pcm_carrier fields `list_fn` struct_pcm_carrier fields
-
-let rec mk_struct (fields: list (string * typedef)): mk_struct_ty fields
-= match fields with
-  | [] -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
-  | (field, td) :: fields' ->
-    fun (x:td.carrier) ->
-    let f: map field_pcm_carrier fields' `list_fn` struct_pcm_carrier fields' = mk_struct fields' in
-    let lift_struct (g: struct_pcm_carrier fields'): struct_pcm_carrier fields =
-      let h (field': field_of fields): struct_field_pcm_carriers fields field' =
-        if field' = field then x else g field'
-      in on_dom _ h
-    in
-    list_fn_map lift_struct f
-
-let mk_point_uncurried
-: option int -> option int -> struct_pcm_carrier point_fields
-= mk_struct point_fields
-
-let _ =
-  let test (k: field_of point_fields) (x y: option int) =
-    assert (mk_point_f_lame x y k == mk_point_uncurried x y k)
-  in ()
-
+let point_fields k = match k with
+  | X -> option int
+  | Y -> option int
+let point = restricted_t point_field point_fields
+
+let point_fields_pcm k : pcm (point_fields k) = match k with
+  | X -> opt_pcm #int
+  | Y -> opt_pcm #int
+let point_pcm = prod_pcm point_fields_pcm
+
+let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
+  | X -> x
+  | Y -> y
+  
 let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
-  Ghost.hide (on_dom _ (mk_point_f_lame (Ghost.reveal x) (Ghost.reveal y)))
+  Ghost.hide (on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y)))
 
-let _x = struct_field point_fields_pcms "x"
-let _y = struct_field point_fields_pcms "y"
+let _x = struct_field point_fields_pcm X
+let _y = struct_field point_fields_pcm Y
 
 /// Taking pointers to the x and y fields of a point
 
 let point_without_x x y
-: Lemma (struct_without_field point_fields_pcms "x" (mk_point x y) `feq` Ghost.reveal (mk_point none y))
+: Lemma (struct_without_field point_fields_pcm X (mk_point x y) `feq` Ghost.reveal (mk_point none y))
   [SMTPat (mk_point x y)]
 = ()
 
 let point_with_x x y
-: Lemma (struct_with_field point_fields_pcms "x" (Ghost.reveal x) (mk_point none y) `feq`
+: Lemma (struct_with_field point_fields_pcm X (Ghost.reveal x) (mk_point none y) `feq`
          Ghost.reveal (mk_point x y))
   [SMTPat (mk_point x y)]
 = ()
 
 let point_without_y x y
-: Lemma (struct_without_field point_fields_pcms "y" (mk_point x y) `feq` Ghost.reveal (mk_point x none))
+: Lemma (struct_without_field point_fields_pcm Y (mk_point x y) `feq` Ghost.reveal (mk_point x none))
   [SMTPat (mk_point x y)]
 = ()
 
 let point_with_y x y
-: Lemma (struct_with_field point_fields_pcms "y" (Ghost.reveal y) (mk_point x none) `feq`
+: Lemma (struct_with_field point_fields_pcm Y (Ghost.reveal y) (mk_point x none) `feq`
          Ghost.reveal (mk_point x y))
   [SMTPat (mk_point x y)]
 = ()
 
-let aux x y : unit
-= assert ((struct_without_field point_fields_pcms "x" (mk_point x y)
-      <: restricted_t (field_of point_fields) point_fields_pcm_carriers) `feq`
-    (Ghost.reveal (mk_point none y) 
-      <: restricted_t (field_of point_fields) point_fields_pcm_carriers)
-    );
-  assert ((struct_without_field point_fields_pcms "x" (mk_point x y)
-      <: restricted_t (field_of point_fields) point_fields_pcm_carriers) ==
-    (Ghost.reveal (mk_point none y) 
-      <: restricted_t (field_of point_fields) point_fields_pcm_carriers)
-    );
-  ()
-
-let aux x y : unit
-= assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
-  ()
-
 let addr_of_x #a #x #y p =
-  let q = addr_of_struct_field p "x" (mk_point x y) in
-  assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
-  //A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
+  let q = addr_of_struct_field p X (mk_point x y) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  A.sladmit();
   A.return q
-
-let addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-
+  
 let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "x" q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
-  let q = addr_of_struct_field p "y" (mk_point x y) in
+  let q = addr_of_struct_field p Y (mk_point x y) in
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
 let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "y" q p (mk_point x none) y; // same here
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x none) y; // same here
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let struct_point_fields = [
-  "x", c_int;
-  "y", c_int;
-]
-
-let point_field_of_string (field: field_of struct_point_fields): point_field =
-  match field with
-  | "x" -> X
-  | "y" -> Y
-
-let struct_point_view_t (k: field_of struct_point_fields): Type =
-  (get_field struct_point_fields k).view_type
-
-let struct_point_view_pcm_t (k: field_of struct_point_fields): Type =
-  point_fields (point_field_of_string k)
-  
-let struct_point_view_pcm (k: field_of struct_point_fields)
-: pcm (struct_point_view_pcm_t k)
-= point_fields_pcms (point_field_of_string k)
-
-let struct_point_fields_view (k:field_of struct_point_fields)
-: sel_view (point_fields_pcms (point_field_of_string k)) (struct_point_view_t k) false
-= (get_field struct_point_fields k).view
-
-(*
-let struct_view
-  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type)
-  (#can_view_units: bool)
-  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
-  (included: list a)
-: sel_view (prod_pcm p)
-    (restricted_t (refine a (mem included)) view_t)
-    (can_view_units || Nil? included) *)
-
-let point_view
-//: sel_view (prod_pcm struct_point_view_pcm_t) (view_type_of struct_point_fields) false
-= struct_view struct_point_fields_view (map (admit() )struct_point_fields)
-
-// = {
-//   to_view_prop = (fun x -> Some? x == true);
-//   to_view = (fun x -> Some?.v x);
-//   to_carrier = (fun z  -> Some z);
-//   to_carrier_not_one = ();
-//   to_view_frame = (fun x frame -> ());
-// }
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index a89dd6c98bf..1e50aff96b3 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -61,60 +61,3 @@ val unaddr_of_y
     ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)
 
-/// Views
-
-// let point_view excluded : sel_view point_pcm (k:field_name not in excluded -> fields k)
-// = {
-//   to_view_prop = (fun x -> Some? x == true);
-//   to_view = (fun x -> Some?.v x);
-//   to_carrier = (fun z  -> Some z);
-//   to_carrier_not_one = (fun _ -> ());
-//   to_view_frame = (fun x frame -> ());
-// }
-
-// val node_view: sel_view node_pcm _ false
-
-(*
-val addr_of_value_sel (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #int))
-    (p `pts_to_view` node_view)
-    (fun q ->
-       (p `pts_to` mk_node none next) `star`
-       (q `pts_to` value))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> q == ref_focus p _value))
-
-val unaddr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #int))
-: Steel unit
-    ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
-    (fun q -> p `pts_to` mk_node value next)
-    (requires (fun _ -> q == ref_focus p _value))
-    (ensures (fun _ _ _ -> True))
-
-val addr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #(ptr node node)))
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node value none) `star`
-       (q `pts_to` next))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> q == ref_focus p _next))
-
-val unaddr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(ptr node node)))
-: Steel unit
-    ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
-    (fun q -> p `pts_to` mk_node value next)
-    (requires (fun _ -> q == ref_focus p _next))
-    (ensures (fun _ _ _ -> True))
-*)
diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
new file mode 100644
index 00000000000..00e07835bec
--- /dev/null
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -0,0 +1,294 @@
+module PointStruct
+
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Connection
+open Steel.C.Struct
+open FStar.FunctionalExtensionality
+open Steel.Effect
+module A = Steel.Effect.Atomic
+
+open Steel.C.Typedef
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+
+let c_int: typedef = {
+  carrier = option int;
+  pcm = opt_pcm #int;
+  view_type = int;
+  can_view_unit = false;
+  view = opt_view int;
+}
+
+let point_fields = [
+  "x", c_int;
+  "y", c_int;
+]
+
+(* TODO move to Steel.C.Typedef *)
+let struct_field_view_types fields = restricted_t (field_of fields) (type_family_of fields)
+
+let struct_field_pcm_carriers (fields: _) (field: field_of fields) =
+  (get_field fields field).carrier
+
+let struct_field_pcms (fields: _) (field: field_of fields)
+: pcm (struct_field_pcm_carriers fields field)
+= (get_field fields field).pcm
+
+let struct_pcm_carrier (fields: list (string * typedef)) =
+  restricted_t (field_of fields) (struct_field_pcm_carriers fields)
+  
+let struct_pcm (fields: list (string * typedef))
+: pcm (struct_pcm_carrier fields)
+= prod_pcm (struct_field_pcms fields)
+
+let point = struct_pcm_carrier point_fields
+
+
+/// PCM for struct point:
+
+val point_pcm : pcm point
+
+/// (mk_point x y) represents (struct point){.x = x, .y = y}
+
+val mk_point (x y: Ghost.erased (option int)): Ghost.erased point
+
+/// Connections for the fields of a point
+
+val _x : connection point_pcm (opt_pcm #int)
+val _y : connection point_pcm (opt_pcm #int)
+
+/// Taking pointers to the x and y fields of a point
+
+val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
+: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _x})
+    (p `pts_to` mk_point x y)
+    (fun q ->
+       (p `pts_to` mk_point none y) `star`
+       (q `pts_to` x))
+
+unfold
+let point_fields_pcm_carriers = struct_field_pcm_carriers point_fields
+
+unfold
+let point_fields_pcms
+: field:field_of point_fields -> pcm (point_fields_pcm_carriers field)
+= struct_field_pcms point_fields
+
+unfold
+let point_pcm_carrier = struct_pcm_carrier point_fields
+
+unfold
+let point_pcm: pcm point_pcm_carrier = struct_pcm point_fields
+
+let mk_point_f_lame (x y: option int) (field: field_of point_fields)
+: point_fields_pcm_carriers field
+= match field with
+  | "x" -> x
+  | "y" -> y
+
+(* BEGIN TODO move to Typedef *)
+
+let rec list_fn (dom: list Type) (cod: Type) =
+  match dom with
+  | [] -> cod
+  | d :: dom -> d -> list_fn dom cod
+
+let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b =
+  match dom with 
+  | [] -> f g <: [] `list_fn` 'b
+  | d :: dom' ->
+    let g: d -> dom' `list_fn` 'a = g in
+    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
+
+let field_pcm_carrier ((_, td): string * typedef) = td.carrier
+
+let mk_struct_ty (fields: list (string * typedef)): Type =
+  map field_pcm_carrier fields `list_fn` struct_pcm_carrier fields
+
+let rec mk_struct (fields: list (string * typedef))
+: mk_struct_ty fields
+= match fields with
+  | [] -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
+  | (field, td) :: fields' ->
+    fun (x:td.carrier) ->
+    let f: map field_pcm_carrier fields' `list_fn` struct_pcm_carrier fields' = mk_struct fields' in
+    let lift_struct (g: struct_pcm_carrier fields'): struct_pcm_carrier fields =
+      let h (field': field_of fields): struct_field_pcm_carriers fields field' =
+        if field' = field then x else g field'
+      in on_dom _ h
+    in
+    list_fn_map lift_struct f
+    
+(* END move to Typedef *)
+
+let mk_point_f
+: option int -> option int -> struct_pcm_carrier point_fields
+= mk_struct point_fields
+
+let _ =
+  let test (k: field_of point_fields) (x y: option int) =
+    assert (mk_point_f_lame x y k == mk_point_f x y k)
+  in ()
+
+let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
+  Ghost.hide (on_dom _ (mk_point_f_lame (Ghost.reveal x) (Ghost.reveal y)))
+
+let _x = struct_field point_fields_pcms "x"
+let _y = struct_field point_fields_pcms "y"
+
+/// Taking pointers to the x and y fields of a point
+
+let point_without_x x y
+: Lemma (struct_without_field point_fields_pcms "x" (mk_point x y) `feq` Ghost.reveal (mk_point none y))
+  [SMTPat (mk_point x y)]
+= ()
+
+let point_with_x x y
+: Lemma (struct_with_field point_fields_pcms "x" (Ghost.reveal x) (mk_point none y) `feq`
+         Ghost.reveal (mk_point x y))
+  [SMTPat (mk_point x y)]
+= ()
+
+let point_without_y x y
+: Lemma (struct_without_field point_fields_pcms "y" (mk_point x y) `feq` Ghost.reveal (mk_point x none))
+  [SMTPat (mk_point x y)]
+= ()
+
+let point_with_y x y
+: Lemma (struct_with_field point_fields_pcms "y" (Ghost.reveal y) (mk_point x none) `feq`
+         Ghost.reveal (mk_point x y))
+  [SMTPat (mk_point x y)]
+= ()
+
+#restart-solver
+
+let feq' (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
+= 'a == 'c /\
+  normalize ('b == 'd) /\
+  f `feq` g
+
+let ext (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
+: Lemma (requires f `feq'` g) (ensures f == g) //[SMTPat (f `feq'` g)]
+= extensionality 'a 'b f g
+  //FStar.Classical.forall_intro fg
+
+//let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+//  extensionality 'a 'b f g;
+//  FStar.Classical.forall_intro fg
+
+// let feq' (f g: restricted_t 'a 'b): prop = forall x. f x == g x
+
+// let ext' (f g: restricted_t 'a 'b)
+// : Lemma (requires f `feq'` g) (ensures f == g) [SMTPat (f `feq'` g)]
+// = extensionality 'a 'b f g
+//   //FStar.Classical.forall_intro fg
+
+let aux x y : unit
+= assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) `feq` mk_point none y);
+  ()
+
+
+let addr_of_x #a #x #y p =
+  let q = addr_of_struct_field p "x" (mk_point x y) in
+  //A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y)))) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
+  //A.change_equal_slprop (p `pts_to` _) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
+  //assume (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
+  //(field_of fields) (struct_field_pcm_carriers fields)
+  assert (
+    struct_without_field point_fields_pcms "x" (mk_point x y)
+    `feq'`
+    Ghost.reveal (mk_point none y));
+  A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y))) (p `pts_to` mk_point none y);
+  //A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
+  A.sladmit();
+  A.return q
+
+// (f `feq` Ghost.reveal g)
+// (Ghost.hide f == g)
+
+(*
+
+struct : string -> list string -> list (string & typedef) -> Type
+
+without_field
+  (field: string)
+  (x: struct s excluded fields) ->
+  struct s excluded
+*)
+let addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
+let unaddr_of_x #a #x #y p q =
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "x" q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_y #a #x #y p =
+  let q = addr_of_struct_field p "y" (mk_point x y) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
+  A.return q
+
+let unaddr_of_y #a #x #y p q =
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "y" q p (mk_point x none) y; // same here
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let struct_point_fields = [
+  "x", c_int;
+  "y", c_int;
+]
+
+let point_field_of_string (field: field_of struct_point_fields): point_field =
+  match field with
+  | "x" -> X
+  | "y" -> Y
+
+let struct_point_view_t (k: field_of struct_point_fields): Type =
+  (get_field struct_point_fields k).view_type
+
+let struct_point_view_pcm_t (k: field_of struct_point_fields): Type =
+  point_fields (point_field_of_string k)
+  
+let struct_point_view_pcm (k: field_of struct_point_fields)
+: pcm (struct_point_view_pcm_t k)
+= point_fields_pcms (point_field_of_string k)
+
+let struct_point_fields_view (k:field_of struct_point_fields)
+: sel_view (point_fields_pcms (point_field_of_string k)) (struct_point_view_t k) false
+= (get_field struct_point_fields k).view
+
+(*
+let struct_view
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: sel_view (prod_pcm p)
+    (restricted_t (refine a (mem included)) view_t)
+    (can_view_units || Nil? included) *)
+
+let point_view
+//: sel_view (prod_pcm struct_point_view_pcm_t) (view_type_of struct_point_fields) false
+= struct_view struct_point_fields_view (map (admit() )struct_point_fields)
+
+// = {
+//   to_view_prop = (fun x -> Some? x == true);
+//   to_view = (fun x -> Some?.v x);
+//   to_carrier = (fun z  -> Some z);
+//   to_carrier_not_one = ();
+//   to_view_frame = (fun x frame -> ());
+// }
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
new file mode 100644
index 00000000000..bfd65d16cbb
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -0,0 +1,408 @@
+module Steel.C.StructLiteral
+
+(*
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Connection
+open Steel.C.Struct
+open FStar.FunctionalExtensionality
+open Steel.Effect
+module A = Steel.Effect.Atomic
+*)
+
+open Steel.C.PCM
+open Steel.C.Typedef
+open Steel.C.Ref // for refine
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+
+let struct_fields = list (string * typedef)
+
+assume val struct' (tag: string) (fields: struct_fields) (excluded: list string): Type
+
+let struct (tag: string) (fields: struct_fields): Type = struct' tag fields []
+
+(* BEGIN TODO delete the ones in Steel.C.Typedef *)
+
+let has_field (fields: struct_fields) (excluded: list string) (field: string): prop =
+  field `mem` map fst fields == true /\ ~ (field `mem` excluded == true)
+  
+let field_of (fields: struct_fields) (excluded: list string) =
+  refine string (has_field fields excluded)
+
+let get_field (fields: struct_fields) (excluded: list string)
+  (field: field_of fields excluded)
+: typedef
+= assoc_mem field fields;
+  Some?.v (assoc field fields)
+  
+(* END TODO *)
+
+/// Reading a struct field
+assume val struct_get
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field: field_of fields excluded)
+: (get_field fields excluded field).view_type
+
+/// Writing a struct field
+assume val struct_put
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field: field_of fields excluded)
+  (v: (get_field fields excluded field).view_type)
+: struct' tag fields excluded
+
+/// For a fixed field name, struct_get and struct_put form a lens
+
+assume val struct_get_put 
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field: field_of fields excluded)
+  (v: (get_field fields excluded field).view_type)
+: Lemma (struct_put x field v `struct_get` field == v)
+  [SMTPat (struct_put x field v `struct_get` field)]
+
+assume val struct_put_get
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field: field_of fields excluded)
+: Lemma (struct_put x field (x `struct_get` field) == x)
+  [SMTPat (struct_put x field (x `struct_get` field))]
+
+assume val struct_put_put
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field: field_of fields excluded)
+  (v w: (get_field fields excluded field).view_type)
+: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
+  [SMTPat (struct_put (struct_put x field v) field w)]
+
+/// struct_get/struct_put pairs for different fields don't interfere with each other
+
+assume val struct_get_put_ne
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field1: field_of fields excluded)
+  (field2: field_of fields excluded)
+  (v: (get_field fields excluded field1).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
+  [SMTPat (struct_put x field1 v `struct_get` field2)]
+
+assume val struct_put_put_ne
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field1: field_of fields excluded)
+  (v: (get_field fields excluded field1).view_type)
+  (field2: field_of fields excluded)
+  (w: (get_field fields excluded field2).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_put (struct_put x field1 v) field2 w ==
+      struct_put (struct_put x field2 w) field1 v)
+
+(*
+define attribute on mk_struct_view_type, etc..
+
+mk_struct_view': fields:list (string * _) ->
+  norm [delta_attr ..; delta Fstar.list.map; ..] .. (mk_struct_view_type fields ..)
+  (See FStar.Pervasives.fsti)
+
+x: struct' tag fields excluded
+
+mk_struct_view v .. = mk_struct_view' (Some v) ..
+
+mk_struct_view' (Some v) None
+
+struct_type tag fields =
+*)
+
+(*
+
+struct_put x field v `without_field` field
+x `without_field` field
+
+struct s excluded
+struct s excluded'
+f in excluded <==> f in excluded'
+
+without_field : 
+  (field: string)
+  (x: struct s excluded fields) ->
+  struct s (field :: excluded)
+
+*)
+
+(*
+let struct_field_view_types fields = restricted_t (field_of fields) (type_family_of fields)
+
+let struct_field_pcm_carriers (fields: _) (field: field_of fields) =
+  (get_field fields field).carrier
+
+let struct_field_pcms (fields: _) (field: field_of fields)
+: pcm (struct_field_pcm_carriers fields field)
+= (get_field fields field).pcm
+
+let struct_pcm_carrier (fields: list (string * typedef)) =
+  restricted_t (field_of fields) (struct_field_pcm_carriers fields)
+  
+let struct_pcm (fields: list (string * typedef))
+: pcm (struct_pcm_carrier fields)
+= prod_pcm (struct_field_pcms fields)
+
+val point : Type0
+
+let point = struct_pcm_carrier point_fields
+
+
+/// PCM for struct point:
+
+val point_pcm : pcm point
+
+/// (mk_point x y) represents (struct point){.x = x, .y = y}
+
+val mk_point (x y: Ghost.erased (option int)): Ghost.erased point
+
+/// Connections for the fields of a point
+
+val _x : connection point_pcm (opt_pcm #int)
+val _y : connection point_pcm (opt_pcm #int)
+
+/// Taking pointers to the x and y fields of a point
+
+val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
+: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _x})
+    (p `pts_to` mk_point x y)
+    (fun q ->
+       (p `pts_to` mk_point none y) `star`
+       (q `pts_to` x))
+
+unfold
+let point_fields_pcm_carriers = struct_field_pcm_carriers point_fields
+
+unfold
+let point_fields_pcms
+: field:field_of point_fields -> pcm (point_fields_pcm_carriers field)
+= struct_field_pcms point_fields
+
+unfold
+let point_pcm_carrier = struct_pcm_carrier point_fields
+
+unfold
+let point_pcm: pcm point_pcm_carrier = struct_pcm point_fields
+
+let mk_point_f_lame (x y: option int) (field: field_of point_fields)
+: point_fields_pcm_carriers field
+= match field with
+  | "x" -> x
+  | "y" -> y
+
+(* BEGIN TODO move to Typedef *)
+
+let rec list_fn (dom: list Type) (cod: Type) =
+  match dom with
+  | [] -> cod
+  | d :: dom -> d -> list_fn dom cod
+
+let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b =
+  match dom with 
+  | [] -> f g <: [] `list_fn` 'b
+  | d :: dom' ->
+    let g: d -> dom' `list_fn` 'a = g in
+    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
+
+let field_pcm_carrier ((_, td): string * typedef) = td.carrier
+
+let mk_struct_ty (fields: list (string * typedef)): Type =
+  map field_pcm_carrier fields `list_fn` struct_pcm_carrier fields
+
+let rec mk_struct (fields: list (string * typedef))
+: mk_struct_ty fields
+= match fields with
+  | [] -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
+  | (field, td) :: fields' ->
+    fun (x:td.carrier) ->
+    let f: map field_pcm_carrier fields' `list_fn` struct_pcm_carrier fields' = mk_struct fields' in
+    let lift_struct (g: struct_pcm_carrier fields'): struct_pcm_carrier fields =
+      let h (field': field_of fields): struct_field_pcm_carriers fields field' =
+        if field' = field then x else g field'
+      in on_dom _ h
+    in
+    list_fn_map lift_struct f
+    
+(* END move to Typedef *)
+
+let mk_point_f
+: option int -> option int -> struct_pcm_carrier point_fields
+= mk_struct point_fields
+
+let _ =
+  let test (k: field_of point_fields) (x y: option int) =
+    assert (mk_point_f_lame x y k == mk_point_f x y k)
+  in ()
+
+let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
+  Ghost.hide (on_dom _ (mk_point_f_lame (Ghost.reveal x) (Ghost.reveal y)))
+
+let _x = struct_field point_fields_pcms "x"
+let _y = struct_field point_fields_pcms "y"
+
+/// Taking pointers to the x and y fields of a point
+
+let point_without_x x y
+: Lemma (struct_without_field point_fields_pcms "x" (mk_point x y) `feq` Ghost.reveal (mk_point none y))
+  [SMTPat (mk_point x y)]
+= ()
+
+let point_with_x x y
+: Lemma (struct_with_field point_fields_pcms "x" (Ghost.reveal x) (mk_point none y) `feq`
+         Ghost.reveal (mk_point x y))
+  [SMTPat (mk_point x y)]
+= ()
+
+let point_without_y x y
+: Lemma (struct_without_field point_fields_pcms "y" (mk_point x y) `feq` Ghost.reveal (mk_point x none))
+  [SMTPat (mk_point x y)]
+= ()
+
+let point_with_y x y
+: Lemma (struct_with_field point_fields_pcms "y" (Ghost.reveal y) (mk_point x none) `feq`
+         Ghost.reveal (mk_point x y))
+  [SMTPat (mk_point x y)]
+= ()
+
+#restart-solver
+
+let feq' (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
+= 'a == 'c /\
+  normalize ('b == 'd) /\
+  f `feq` g
+
+let ext (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
+: Lemma (requires f `feq'` g) (ensures f == g) //[SMTPat (f `feq'` g)]
+= extensionality 'a 'b f g
+  //FStar.Classical.forall_intro fg
+
+//let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+//  extensionality 'a 'b f g;
+//  FStar.Classical.forall_intro fg
+
+// let feq' (f g: restricted_t 'a 'b): prop = forall x. f x == g x
+
+// let ext' (f g: restricted_t 'a 'b)
+// : Lemma (requires f `feq'` g) (ensures f == g) [SMTPat (f `feq'` g)]
+// = extensionality 'a 'b f g
+//   //FStar.Classical.forall_intro fg
+
+let aux x y : unit
+= assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) `feq` mk_point none y);
+  ()
+
+
+let addr_of_x #a #x #y p =
+  let q = addr_of_struct_field p "x" (mk_point x y) in
+  //A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y)))) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
+  //A.change_equal_slprop (p `pts_to` _) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
+  //assume (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
+  //(field_of fields) (struct_field_pcm_carriers fields)
+  assert (
+    struct_without_field point_fields_pcms "x" (mk_point x y)
+    `feq'`
+    Ghost.reveal (mk_point none y));
+  A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y))) (p `pts_to` mk_point none y);
+  //A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
+  A.sladmit();
+  A.return q
+
+// (f `feq` Ghost.reveal g)
+// (Ghost.hide f == g)
+
+(*
+
+struct : string -> list string -> list (string & typedef) -> Type
+
+without_field
+  (field: string)
+  (x: struct s excluded fields) ->
+  struct s excluded
+*)
+let addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.return r
+
+let unaddr_of_x #a #x #y p q =
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "x" q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_y #a #x #y p =
+  let q = addr_of_struct_field p "y" (mk_point x y) in
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
+  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
+  A.return q
+
+let unaddr_of_y #a #x #y p q =
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "y" q p (mk_point x none) y; // same here
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let struct_point_fields = [
+  "x", c_int;
+  "y", c_int;
+]
+
+let point_field_of_string (field: field_of struct_point_fields): point_field =
+  match field with
+  | "x" -> X
+  | "y" -> Y
+
+let struct_point_view_t (k: field_of struct_point_fields): Type =
+  (get_field struct_point_fields k).view_type
+
+let struct_point_view_pcm_t (k: field_of struct_point_fields): Type =
+  point_fields (point_field_of_string k)
+  
+let struct_point_view_pcm (k: field_of struct_point_fields)
+: pcm (struct_point_view_pcm_t k)
+= point_fields_pcms (point_field_of_string k)
+
+let struct_point_fields_view (k:field_of struct_point_fields)
+: sel_view (point_fields_pcms (point_field_of_string k)) (struct_point_view_t k) false
+= (get_field struct_point_fields k).view
+
+(*
+let struct_view
+  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
+  (#view_t:a -> Type)
+  (#can_view_units: bool)
+  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
+  (included: list a)
+: sel_view (prod_pcm p)
+    (restricted_t (refine a (mem included)) view_t)
+    (can_view_units || Nil? included) *)
+
+let point_view
+//: sel_view (prod_pcm struct_point_view_pcm_t) (view_type_of struct_point_fields) false
+= struct_view struct_point_fields_view (map (admit() )struct_point_fields)
+
+// = {
+//   to_view_prop = (fun x -> Some? x == true);
+//   to_view = (fun x -> Some?.v x);
+//   to_carrier = (fun z  -> Some z);
+//   to_carrier_not_one = ();
+//   to_view_frame = (fun x frame -> ());
+// }
+*)
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
new file mode 100644
index 00000000000..708be0cad18
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -0,0 +1,123 @@
+module Steel.C.Typedef
+
+open FStar.List.Tot
+open Steel.C.PCM
+open Steel.C.Ref
+open FStar.FunctionalExtensionality
+
+noeq type typedef = { 
+  carrier: Type0; 
+  pcm: pcm carrier; 
+  view_type: Type0; 
+  can_view_unit: bool; 
+  view: sel_view pcm view_type can_view_unit; 
+} 
+
+// assume val malloc: typedef -> ptr typedef.carrier typedef.pcm 
+
+let has_field (fields: list (string & typedef)) (field: string): prop =
+  field `mem` map fst fields == true
+
+let field_of (fields: list (string & typedef)) = refine string (has_field fields)
+
+let get_field (fields: list (string & typedef)) (field: field_of fields): typedef =
+  assoc_mem field fields;
+  Some?.v (assoc field fields)
+  
+let type_family_of (fields: list (string & typedef)) (field: field_of fields) =
+  (get_field fields field).view_type
+
+//struct : string -> list (_ & _) -> Type
+
+val typedef_struct: string -> list (string & typedef) -> Tot typedef 
+
+let typedef_struct name fields = {
+  carrier = restricted_t (field_of fields) (type_family_of fields);
+  pcm = admit();
+  view_type = admit();
+  can_view_unit = admit();
+  view = admit();
+}
+
+(*
+ 
+
+let field_name fields = (field: string { field `List.Tot.mem` List.Tot.map fst fields}) 
+
+ 
+
+let field_conn: 
+
+  name: string -> 
+
+  fields: list (string & typedef) -> 
+
+  let t = typedef_struct name fields in 
+
+  field_name: field_name fields -> 
+
+  connection t.pcm (List.Tot.assoc field_name fields).pcm 
+
+ 
+
+let field_conn_large_to_small: 
+
+  name: string -> 
+
+  fields: list (string & typedef) -> 
+
+  let t = typedef_struct name fields in 
+
+  field_name: field_name fields -> 
+
+  x: t.user -> 
+
+  Lemma 
+
+  t.to_view (field_conn name fields field_name).morph x) == f?? (...) 
+
+ 
+
+let addr_of_field_tot: 
+
+  name: string -> 
+
+  fields: list (string & typedef) -> 
+
+  let t = typedef_struct name fields in 
+
+  field_name: field_name fields -> 
+
+  ptr ‘a t.pcm -> 
+
+  ptr ‘a (List.Tot.assoc field_name fields).pcm 
+
+= ... 
+
+ 
+
+Page Break
+ 
+
+val lift_view_struct: 
+
+  #field_name: eqtype -> 
+
+  #carriers: (field_name -> Type) -> 
+
+  pcms: (fn: field_name -> pcm (carriers fn)) -> 
+
+  users: (field_name -> Type) -> 
+
+  can_view_unit_views: bool -> 
+
+  views: (fn: field_name -> view (users fn) can_view_unit_views) -> 
+
+  include: list field_name -> 
+
+Tot (view (struct_pcm pcms) ... (can_view_unit_views || Nil? include)) 
+
+ 
+
+val weaken: view ... false -> view ... true 
+*)

From 75355a639f3385de5603f096cef3714ecc72bbbf Mon Sep 17 00:00:00 2001
From: Jonathan Protzenko <jonathan.protzenko@gmail.com>
Date: Thu, 5 Aug 2021 13:17:06 -0700
Subject: [PATCH 139/513] Expose EAddrOf via the input ast to allow taking the
 address of a struct field

---
 src/extraction/FStar.Extraction.Kremlin.fs   | 1 +
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 5 +++++
 2 files changed, 6 insertions(+)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 959606917be..eaffc577a84 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -131,6 +131,7 @@ and expr =
   | EAbortT of string * typ
   | EComment of string * expr * string
   | EStandaloneComment of string
+  | EAddrOf of expr
 
 and op =
   | Add | AddW | Sub | SubW | Div | DivW | Mult | MultW | Mod
diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index f9059f8b928..5e9bca78e68 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -80,6 +80,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -426,6 +427,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =

From 877ac0e942e37b3ad41ad9c50c82c9971317a866 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 10:05:56 -0700
Subject: [PATCH 140/513] Fixup examples to use new reveal_hide reduction rules

---
 .../arraystructs/AggregateRefExamples.fst     |  26 ++-
 examples/steel/arraystructs/LList.fst         | 192 ++++++++++++++----
 examples/steel/arraystructs/ListNode.fst      |  31 ++-
 examples/steel/arraystructs/ListNode.fsti     |  16 +-
 examples/steel/arraystructs/PointStruct.fst   |  18 +-
 examples/steel/arraystructs/PointStruct.fsti  |  30 ++-
 examples/steel/arraystructs/Steel.C.Opt.fsti  |   9 +-
 examples/steel/arraystructs/Steel.C.Ptr.fst   |  65 ++----
 examples/steel/arraystructs/Steel.C.Ptr.fsti  |  16 +-
 examples/steel/arraystructs/Steel.C.Ref.fsti  |   2 +-
 src/parser/parse.fsy                          |   1 -
 11 files changed, 249 insertions(+), 157 deletions(-)

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
index 02761ee76ea..8c82e90f8e6 100644
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ b/examples/steel/arraystructs/AggregateRefExamples.fst
@@ -22,7 +22,7 @@ open PointStruct
 ///   *r = tmp;
 /// }
 
-let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
+let point_swap_some (p: ref 'a point_pcm) (x y: Ghost.erased int)
 : SteelT unit
     (p `pts_to` mk_point (some x) (some y))
     (fun _ -> p `pts_to` mk_point (some y) (some x))
@@ -42,6 +42,26 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
   unaddr_of_y p r;
   A.return ()
 
+let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
+: SteelT unit
+    (p `pts_to` mk_point (Some #int x) (Some #int y))
+    (fun _ -> p `pts_to` mk_point (Some #int y) (Some #int x))
+= (* int *q = &p.x; *)
+  let q = addr_of_x p in
+  (* int *r = &p.y; *)
+  let r = addr_of_y p in
+  (* tmp = *q; *)
+  let tmp : int = opt_read q in
+  (* *q = *r; *)
+  let vy : int = opt_read r in
+  opt_write q vy;
+  (* *r = tmp; *)
+  opt_write r tmp;
+  (* Gather *)
+  unaddr_of_x p q;
+  unaddr_of_y p r;
+  A.return ()
+
 /// We can also implement swap generically:
 ///
 /// void generic_swap<A>(A *p, A *q) {
@@ -51,8 +71,8 @@ let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
 /// }
 
 let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (opt_pcm #'c)) (q:ref 'b (opt_pcm #'c))
-: SteelT unit ((p `pts_to` some x) `star` (q `pts_to` some y))
-    (fun _ -> (p `pts_to` some y) `star` (q `pts_to` some x))
+: SteelT unit ((p `pts_to` Some #'c x) `star` (q `pts_to` Some #'c y))
+    (fun _ -> (p `pts_to` Some #'c y) `star` (q `pts_to` Some #'c x))
 = (* A tmp = *p; *)
   let tmp = opt_read p in
   (* *p = *q; *)
diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index bb3dba3df3d..804dac3d19a 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -81,80 +81,164 @@ open ListNode
 let cell = int & ptr node node
 let cells = list cell
 
-let hd_node (l: Ghost.erased cells): Ghost.erased (option node) =
-  match Ghost.reveal l with
-  | (value, next) :: _ -> some (mk_node (some value) (some next))
-  | [] -> none
+let hd_node (l: cells): option node =
+  match l with
+  | (value, next) :: _ -> Some (mk_node (Some value) (Some next))
+  | [] -> None
 
-let pts_to_llist_tl (l:Ghost.erased cells)
+let pts_to_llist_tl (l:cells)
   (pts_to_llist:(
     p:ptr node node -> 
-    l':Ghost.erased cells{List.length l' < List.length l} -> 
+    l':cells{List.length l' < List.length l} -> 
     Tot vprop))
 : Tot vprop
-= match Ghost.reveal l with
+= match l with
   | [] -> emp
   | (value, next) :: tl -> next `pts_to_llist` tl
 
-let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:Ghost.erased cells)
+let pts_to_llist_nullptr_condition (p: ptr node node) (l: cells)
+: Tot prop
+= p == nullptr <==> l == []
+
+let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:cells)
 : Tot vprop (decreases (List.length l))
-= vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+= vpure (pts_to_llist_nullptr_condition p l) `star`
   pts_to_or_null p node_pcm (hd_node l) `star`
   pts_to_llist_tl l pts_to_llist
 
-let unfold_pts_to_llist (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
+let unfold_pts_to_llist (#opened:inames) (p:ptr node node) (l:cells)
 : SteelGhost unit opened
     (p `pts_to_llist` l)
     (fun _ -> 
       pts_to_or_null p node_pcm (hd_node l) `star`
       pts_to_llist_tl l pts_to_llist)
     (requires fun _ -> True)
-    (ensures fun _ _ _ -> p == nullptr <==> Ghost.reveal l == [])
+    (ensures fun _ _ _ -> pts_to_llist_nullptr_condition p l)
 = change_equal_slprop
     (p `pts_to_llist` l)
-    (vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+    (vpure (pts_to_llist_nullptr_condition p l) `star`
      pts_to_or_null p node_pcm (hd_node l) `star`
      pts_to_llist_tl l pts_to_llist);
   elim_vpure _
 
-let fold_pts_to_llist (#opened:inames) (p:ptr node node) (l:Ghost.erased cells)
+let fold_pts_to_llist (#opened:inames) (p:ptr node node) (l:cells)
 : SteelGhost unit opened
     (pts_to_or_null p node_pcm (hd_node l) `star`
      pts_to_llist_tl l pts_to_llist)
     (fun _ -> p `pts_to_llist` l)
-    (requires fun _ -> p == nullptr <==> Ghost.reveal l == [])
+    (requires fun _ -> pts_to_llist_nullptr_condition p l)
     (ensures fun _ _ _ -> True)
-= intro_vpure (p == nullptr <==> Ghost.reveal l == []);
+= intro_vpure (pts_to_llist_nullptr_condition p l);
   change_equal_slprop
-    (vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+    (vpure (pts_to_llist_nullptr_condition p l) `star`
      pts_to_or_null p node_pcm (hd_node l) `star`
      pts_to_llist_tl l pts_to_llist)
     (p `pts_to_llist` l)
 
+(*
+unfold let f (x:option 'a): Tot prop = x == None #'a
+let good #a: squash ((None #a == None #a) == (f (None #a))) = ()
+
+let g (x:'a): Tot prop = x == x
+let good : squash ((None #int == None #int) == (g (None #int))) = ()
+
+let g (x:option int): Tot prop = x == None #int
+let bad : squash ((None #int == None #int) == (g (None #int))) = ()
+
+let g (x:option 'a): Tot prop = x == None #'a
+let bad #a: squash ((None #a == None #a) == (g (None #a))) =
+  assert_norm ((None #a == None #a) == (g (None #a)))
+
+let f (x:'a): Tot prop = x == x
+let good #a: squash ((3 == 3) == (f 3)) = ()
+
+let f (l:list 'a): Tot prop
+= (l == [])
+let bad #a: squash (([] #a == [] #a) == (f ([] #a))) = ()
+
+let f (l:list 'a): Tot prop
+= (l == [])
+let aux' #a =
+  assert_norm (
+    ([] #a == [])
+    ==
+    f ([] #a))
+
+let aux' #a =
+  assert_norm (
+    (let l = [] #a in
+    ((l == [])))
+    ==
+    f ([] #a))
+    
+let f (l:cells)
+: Tot vprop
+= vpure (l == [])
+
+let aux' (p: ptr node node) =
+  assert_norm (
+    (let l = [] #cell in
+    (LList.vpure (l == [])))
+    ==
+    f ([] #cell))
+
+let pts_to_llist' (p:ptr node node) (l:cells)
+: Tot vprop (decreases (List.length l))
+= vpure (p == nullptr <==> l == [])
+
+let aux' (p: ptr node node) =
+  assert_norm (
+    (let l = [] #cell in
+    (LList.vpure (p == Steel.C.Ptr.nullptr <==> l == [])))
+    ==
+    pts_to_llist' p ([] #cell))
+
+let aux' (p: ptr node node) =
+  assert_norm(
+    (let l = [] #cell in
+    Steel.Effect.Common.star (Steel.Effect.Common.star (LList.vpure (p == Steel.C.Ptr.nullptr <==>
+                l == []))
+          (Steel.C.Ptr.pts_to_or_null p ListNode.node_pcm (LList.hd_node l)))
+      (LList.pts_to_llist_tl l LList.pts_to_llist))
+    ==
+    pts_to_llist p ([] #cell))
+
+let aux p =
+    assert_norm (
+( vpure (p == nullptr <==> [] #cell == []) `star`
+ pts_to_or_null p node_pcm (hd_node ([] #cell)) `star`
+ pts_to_llist_tl ([] #cell) pts_to_llist)
+     ==
+    (p `pts_to_llist` [] #cell))
+    
+//  vpure (p == nullptr <==> l == []) `star`
+//  pts_to_or_null p node_pcm (hd_node l) `star`
+//  pts_to_llist_tl l pts_to_llist
+*)
+
 let intro_pts_to_llist_nil #opened p
 : SteelGhost unit opened 
     emp
-    (fun _ -> p `pts_to_llist` Ghost.hide [])
+    (fun _ -> p `pts_to_llist` [])
     (requires fun _ -> p == nullptr)
     (ensures fun _ _ _ -> True)
-= intro_vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []);
-  intro_pts_to_or_null_nullptr node_pcm;
+= intro_vpure (pts_to_llist_nullptr_condition p []);
+  intro_pts_to_or_null_nullptr #node node_pcm;
   change_equal_slprop
-    (vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []) `star`
-     pts_to_or_null (nullptr #node) node_pcm none `star` emp)
-    (p `pts_to_llist` Ghost.hide [])
+    (pts_to_or_null (nullptr #node) node_pcm (None))
+    (pts_to_or_null p node_pcm (hd_node ([] #cell)))
 
 let elim_pts_to_llist_nil #opened p
 : SteelGhost unit opened 
-    (p `pts_to_llist` Ghost.hide [])
+    (p `pts_to_llist` [])
     (fun _ -> emp)
     (requires fun _ -> True)
     (ensures fun _ _ _ -> p == nullptr)
 = change_equal_slprop
-    (p `pts_to_llist` Ghost.hide [])
-    (vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []) `star`
-     pts_to_or_null p node_pcm none `star` emp);
-  elim_vpure (p == nullptr <==> Ghost.reveal (Ghost.hide ([] #cell)) == []);
+    (p `pts_to_llist` [])
+    (vpure (pts_to_llist_nullptr_condition p []) `star`
+     pts_to_or_null p node_pcm None `star` emp);
+  elim_vpure (p == nullptr <==> [] #cell == []);
   elim_pts_to_or_null_nullptr p
 
 let intro_pts_to_llist_cons #opened p value_next value next (l: Ghost.erased cells)
@@ -169,11 +253,11 @@ let intro_pts_to_llist_cons #opened p value_next value next (l: Ghost.erased cel
   pts_to_nonnull p; assert (p =!= nullptr);
   let l': Ghost.erased cells = Ghost.hide ((value, next) :: Ghost.reveal l) in
   intro_vpure (p == nullptr <==> Ghost.reveal l' == []);
-  assert (hd_node l' == some (mk_node (some value) (some next)));
+  assert (hd_node l' == Some (mk_node (Some value) (Some next)));
   intro_pts_to_or_null p;
   change_equal_slprop (next `pts_to_llist` l) (pts_to_llist_tl l' pts_to_llist);
   change_equal_slprop
-    (vpure (p == nullptr <==> Ghost.reveal l' == []) `star`
+    (vpure (pts_to_llist_nullptr_condition p (Ghost.reveal l')) `star`
      pts_to_or_null p node_pcm (hd_node l') `star`
      pts_to_llist_tl l' pts_to_llist)
     (p `pts_to_llist` _)
@@ -194,16 +278,16 @@ let elim_pts_to_llist_cons #opened p (l: Ghost.erased cells)
     (requires fun _ -> p =!= nullptr)
     (ensures fun _ res _ -> Ghost.reveal l == (res.value, res.next) :: res.tl)
 = change_equal_slprop (p `pts_to_llist` l)
-    (vpure (p == nullptr <==> Ghost.reveal l == []) `star`
+    (vpure (pts_to_llist_nullptr_condition p (Ghost.reveal l)) `star`
      pts_to_or_null p node_pcm (hd_node l) `star`
      pts_to_llist_tl l pts_to_llist);
-  elim_vpure (p == nullptr <==> Ghost.reveal l == []);
+  elim_vpure (pts_to_llist_nullptr_condition p (Ghost.reveal l));
   match Ghost.reveal l with
   | [] -> unreachable (fun res -> Ghost.reveal l == (res.value, res.next) :: res.tl)
   | (value, next) :: tl ->
-    assert (hd_node l == some (mk_node (some value) (some next)));
+    assert (hd_node l == Some (mk_node (Some value) (Some next)));
     let w = elim_pts_to_or_null p in
-    assert (w == mk_node (some value) (some next));
+    assert (Ghost.reveal w == mk_node (Some value) (Some next));
     change_equal_slprop (pts_to_llist_tl l pts_to_llist) (next `pts_to_llist` tl);
     {value; next; tl}
 
@@ -213,6 +297,7 @@ let intro_llist_nil ()
 : SteelT (ptr node) emp (fun p -> p `pts_to_llist` [])
 = let p = nullptr in
   intro_pts_to_llist_nil p;
+  sladmit(); // TODO why
   return p
 
 let rec values (l:cells) : GTot (list int) =
@@ -223,7 +308,7 @@ let rec values (l:cells) : GTot (list int) =
 #set-options "--ide_id_info_off"
 
 val push (p:ptr node) (l:Ghost.erased cells) (value:int)
-: Steel (ptr node & _)
+: Steel (ptr node & Ghost.erased cells)
     (p `pts_to_llist` l)
     (fun (p', l') -> p' `pts_to_llist` l')
     (requires fun _ -> True)
@@ -231,7 +316,7 @@ val push (p:ptr node) (l:Ghost.erased cells) (value:int)
 
 let push p l value =
   let cell: int & ptr node = (value, p) in
-  let value_next: node = mk_node_tot (Some value) (Some p) in
+  let value_next: node = mk_node (Some value) (Some p) in
   let r = ref_alloc node_pcm value_next in
   let q = intro_pts_to r in
   intro_pts_to_llist_cons q value_next value p l;
@@ -263,6 +348,7 @@ let nontrivial_fact_about_mk_node value next
 : Lemma (Ghost.reveal (mk_node (some value) (some next)) =!= one node_pcm)
 = ()
 
+(*
 assume val intro_pts_to_llist_cons' : #opened:inames ->
       p: ptr node ->
       value: int ->
@@ -299,11 +385,7 @@ assume val unaddr_of_value
     (fun q -> pts_to p node_pcm (mk_node value next))
     (requires (fun _ -> ptr_focused q p _value))
     (ensures (fun _ _ _ -> True))
-
-val set_first (p:ptr node) (l:Ghost.erased cells) (value:int)
-: SteelT unit
-    (p `pts_to_llist` l)
-    (fun _ -> p `pts_to_llist` cells_set_hd value l)
+    *)
 
 val is_empty
   (#l: Ghost.erased cells) (p: ptr node)
@@ -318,6 +400,24 @@ let is_empty #l p =
   fold_pts_to_llist p l;
   return b
 
+val set_first (p:ptr node) (l:Ghost.erased cells) (value:int)
+: SteelT unit
+    (p `pts_to_llist` l)
+    (fun _ -> p `pts_to_llist` cells_set_hd value l)
+
+assume val intro_pts_to_llist_cons' : #opened:inames ->
+      p: ptr node ->
+      value: int ->
+      next: ptr node ->
+      l: Ghost.erased cells
+    -> Steel.Effect.Atomic.SteelGhostT unit
+        opened
+        (star (pts_to p node_pcm (mk_node (some (Ghost.hide value)) (some (Ghost.hide next))))
+	  (pts_to_llist next l))
+        (fun _ ->
+            pts_to_llist p
+              (Ghost.hide (FStar.Pervasives.Native.Mktuple2 value next :: Ghost.reveal l)))
+
 let set_first p l new_value =
   let b = is_empty p in
   if b then begin
@@ -325,13 +425,18 @@ let set_first p l new_value =
     return ()
   end else begin
     let res = elim_pts_to_llist_cons p l in
-    let p_value = addr_of_value p in
-    p_value `ptr_opt_write` new_value;
-    unaddr_of_value p p_value;
+    let r = elim_pts_to p in
+    let r_value = addr_of_value r in
+    r_value `opt_write` new_value;
+    unaddr_of_value r r_value;
+    let p' = intro_pts_to r in
+    assert (p == p');
+    change_equal_slprop (pts_to p' _ _) (pts_to p _ _);
     intro_pts_to_llist_cons' p new_value res.next res.tl;
     return ()
   end
 
+(*
 let rec cells_set_nth (n:nat) (value:int) (l:cells) : Tot cells (decreases n) =
   if n = 0 then cells_set_hd value l
   else match l with
@@ -514,3 +619,4 @@ let pop #a ptr l =
   rewrite_slprop (llist (next hd) tl) (llist (next (L.hd l)) (L.tl l)) (fun _ -> ());
   return (data c)
 *)
+*)
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
index 1557d656f48..9cf66888b18 100644
--- a/examples/steel/arraystructs/ListNode.fst
+++ b/examples/steel/arraystructs/ListNode.fst
@@ -97,16 +97,12 @@ let mk_node'_f (value: option int) (next: option (ptr node node))
   | Next -> next
   
 let mk_node'
-  (value: Ghost.erased (option int))
-  (next: Ghost.erased (option (ptr node node)))
-: Ghost.erased node'
-= Ghost.hide (on_domain node_field (mk_node'_f (Ghost.reveal value) (Ghost.reveal next)))
+  (value: option int)
+  (next: option (ptr node node))
+: node'
+= on_domain node_field (mk_node'_f value next)
 
-let mk_node value next = Ghost.hide (Mknode (mk_node' (Ghost.reveal value) (Ghost.reveal next)))
-
-let mk_node_tot value next = Mknode (on_domain node_field (mk_node'_f value next))
-
-let mk_node_tot_mk_node value next = ()
+let mk_node value next = Mknode (mk_node' value next)
 
 open Steel.C.PCM
 module P = FStar.PCM
@@ -121,36 +117,33 @@ let _next
 : node_pcm `connection` opt_pcm #(ptr node node)
 = unroll_conn `connection_compose` struct_field node_fields_pcm Next
 
-let one_next : Ghost.erased (option int) =
-  Ghost.hide (one (opt_pcm #int))
-
 let node'_without_value value next
 : Lemma (struct_without_field node_fields_pcm Value (mk_node' value next) `feq`
-         Ghost.reveal (mk_node' none next))
+         mk_node' none next)
   [SMTPat (mk_node' value next)]
 = ()
 
 let node'_with_value value next
-: Lemma (struct_with_field node_fields_pcm Value (Ghost.reveal value) (mk_node' none next) `feq`
-         Ghost.reveal (mk_node' value next))
+: Lemma (struct_with_field node_fields_pcm Value value (mk_node' none next) `feq`
+         mk_node' value next)
   [SMTPat (mk_node' value next)]
 = ()
 
 let node'_without_next value next
 : Lemma (struct_without_field node_fields_pcm Next (mk_node' value next) `feq`
-         Ghost.reveal (mk_node' value none))
+         mk_node' value none)
   [SMTPat (mk_node' value next)]
 = ()
 
 let node'_with_next value next
-: Lemma (struct_with_field node_fields_pcm Next (Ghost.reveal next) (mk_node' value none) `feq`
-         Ghost.reveal (mk_node' value next))
+: Lemma (struct_with_field node_fields_pcm Next next (mk_node' value none) `feq`
+         mk_node' value next)
   [SMTPat (mk_node' value next)]
 = ()
 
 let mk_node_mk_node' value next
 : Lemma (
-    Ghost.reveal (mk_node value next) ==
+    mk_node value next ==
     unroll_conn.conn_small_to_large.morph (mk_node' value next))
 = ()
 
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
index aeb390432b4..4a45eec154e 100644
--- a/examples/steel/arraystructs/ListNode.fsti
+++ b/examples/steel/arraystructs/ListNode.fsti
@@ -20,18 +20,18 @@ val node_pcm: pcm node
 /// (mk_node value next) represents (struct node){.value = value, .next = next}
 
 val mk_node
-  (i: Ghost.erased (option int))
-  (next: Ghost.erased (option (ptr node node)))
-: Ghost.erased node
-
-val mk_node_tot
   (i: option int)
   (next: option (ptr node node))
 : node
 
-val mk_node_tot_mk_node (i: option int) (next: option (ptr node node))
-: Lemma (mk_node_tot i next == Ghost.reveal (mk_node i next))
-  [SMTPat (mk_node_tot i next)]
+// val mk_node_tot
+//   (i: option int)
+//   (next: option (ptr node node))
+// : node
+
+// val mk_node_tot_mk_node (i: option int) (next: option (ptr node node))
+// : Lemma (mk_node_tot i next == Ghost.reveal (mk_node i next))
+//   [SMTPat (mk_node_tot i next)]
 
 open Steel.C.PCM
 module P = FStar.PCM
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index c81f1df4622..279e5ce5400 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -22,8 +22,8 @@ let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
   | X -> x
   | Y -> y
   
-let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
-  Ghost.hide (on_domain point_field (mk_point_f (Ghost.reveal x) (Ghost.reveal y)))
+let mk_point (x y: option int): point =
+  on_domain point_field (mk_point_f x y)
 
 let _x = struct_field point_fields_pcm X
 let _y = struct_field point_fields_pcm Y
@@ -36,25 +36,25 @@ let point_without_x x y
 = ()
 
 let point_with_x x y
-: Lemma (struct_with_field point_fields_pcm X (Ghost.reveal x) (mk_point none y) `feq`
-         Ghost.reveal (mk_point x y))
+: Lemma (struct_with_field point_fields_pcm X x (mk_point None y) `feq`
+         mk_point x y)
   [SMTPat (mk_point x y)]
 = ()
 
 let point_without_y x y
-: Lemma (struct_without_field point_fields_pcm Y (mk_point x y) `feq` Ghost.reveal (mk_point x none))
+: Lemma (struct_without_field point_fields_pcm Y (mk_point x y) `feq` mk_point x None)
   [SMTPat (mk_point x y)]
 = ()
 
 let point_with_y x y
-: Lemma (struct_with_field point_fields_pcm Y (Ghost.reveal y) (mk_point x none) `feq`
-         Ghost.reveal (mk_point x y))
+: Lemma (struct_with_field point_fields_pcm Y y (mk_point x None) `feq`
+         mk_point x y)
   [SMTPat (mk_point x y)]
 = ()
 
 let addr_of_x #a #x #y p =
   let q = addr_of_struct_field p X (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point none y);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
   A.return q
   
@@ -64,7 +64,7 @@ let unaddr_of_x #a #x #y p q =
 
 let addr_of_y #a #x #y p =
   let q = addr_of_struct_field p Y (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
+  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
   A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
   A.return q
 
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
index 1e50aff96b3..281f14f8d2f 100644
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ b/examples/steel/arraystructs/PointStruct.fsti
@@ -22,7 +22,7 @@ val point_pcm : pcm point
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
 
-val mk_point (x y: Ghost.erased (option int)): Ghost.erased point
+val mk_point (x y: option int): point
 
 /// Connections for the fields of a point
 
@@ -32,32 +32,40 @@ val _y : connection point_pcm (opt_pcm #int)
 /// Taking pointers to the x and y fields of a point
 
 val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _x})
+: Steel (ref 'a (opt_pcm #int))
     (p `pts_to` mk_point x y)
     (fun q ->
-       (p `pts_to` mk_point none y) `star`
+       (p `pts_to` mk_point None y) `star`
        (q `pts_to` x))
+    (requires fun _ -> True)
+    (ensures fun _ q _ -> q == ref_focus p _x)
 
 val unaddr_of_x
   (#x #y: Ghost.erased (option int))
   (p: ref 'a point_pcm)
-  (q: ref 'a (opt_pcm #int){q == ref_focus p _x})
-: SteelT unit
-    ((p `pts_to` mk_point none y) `star` (q `pts_to` x))
+  (q: ref 'a (opt_pcm #int))
+: Steel unit
+    ((p `pts_to` mk_point None y) `star` (q `pts_to` x))
     (fun q -> p `pts_to` mk_point x y)
+    (requires fun _ -> q == ref_focus p _x)
+    (ensures fun _ _ _ -> True)
 
 val addr_of_y (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _y})
+: Steel (ref 'a (opt_pcm #int))
     (p `pts_to` mk_point x y)
     (fun q ->
-       (p `pts_to` mk_point x none) `star`
+       (p `pts_to` mk_point x None) `star`
        (q `pts_to` y))
+    (requires fun _ -> True)
+    (ensures fun _ q _ -> q == ref_focus p _y)
 
 val unaddr_of_y
   (#x #y: Ghost.erased (option int))
   (p: ref 'a point_pcm)
-  (q: ref 'a (opt_pcm #int){q == ref_focus p _y})
-: SteelT unit
-    ((p `pts_to` mk_point x none) `star` (q `pts_to` y))
+  (q: ref 'a (opt_pcm #int))
+: Steel unit
+    ((p `pts_to` mk_point x None) `star` (q `pts_to` y))
     (fun q -> p `pts_to` mk_point x y)
+    (requires fun _ -> q == ref_focus p _y)
+    (ensures fun _ _ _ -> True)
 
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index e559b86c50e..75dd9761248 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -29,6 +29,7 @@ let option: Type u#a -> Type u#a = option
 
 let none #a: Ghost.erased (option a) = None
 
+[@@__reduce__]
 let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
 
 let some_v (x: Ghost.erased (option 'a){Some? x}): Ghost.erased 'a = Some?.v x
@@ -37,8 +38,8 @@ val opt_read
   (#a:Type) (#b:Type) (#x: Ghost.erased b)
   (r: ref a (opt_pcm #b))
 : Steel b
-    (r `pts_to` some x)
-    (fun _ -> r `pts_to` some x)
+    (r `pts_to` Some #b x)
+    (fun _ -> r `pts_to` Some #b x)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> Ghost.reveal x == x')
 
@@ -46,8 +47,8 @@ val opt_write
   (#a:Type) (#b:Type) (#x: Ghost.erased b)
   (r: ref a (opt_pcm #b)) (y: b)
 : SteelT unit
-    (r `pts_to` some x)
-    (fun _ -> r `pts_to` some (Ghost.hide y))
+    (r `pts_to` Some #b x)
+    (fun _ -> r `pts_to` Some y)
 
 let opt_view
   (a: Type)
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
index 889085d2094..347a1235b7f 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fst
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -69,11 +69,11 @@ let ptr a b = option (ref' a b)
 
 let nonnull (p: ptr 'a 'b) (pb: pcm 'b): prop = Some? p /\ pcm_of_ref' (Some?.v p) == pb
 
-let pts_to_dep (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased 'b) (prf: squash (nonnull p pb))
+let pts_to_dep (p: ptr 'a 'b) (pb: pcm 'b) (v: 'b) (prf: squash (nonnull p pb))
 = let r: ref 'a pb = Some?.v p in r `pts_to` v
 
 let pts_to' (p: ptr 'a 'b) (pb: pcm 'b) (v: 'b): vprop = vpure (nonnull p pb) `vdep` pts_to_dep p pb v
-let pts_to p pb v = pts_to' p pb (Ghost.reveal v)
+let pts_to p pb v = pts_to' p pb v
 
 let pts_to_or_null' (p: ptr 'a 'b) (pb: pcm 'b) (v: option 'b): vprop =
   vpure (v == None <==> p == None) `star`
@@ -81,7 +81,7 @@ let pts_to_or_null' (p: ptr 'a 'b) (pb: pcm 'b) (v: option 'b): vprop =
    | None -> vpure True
    | Some v -> pts_to' p pb v)
 
-let pts_to_or_null p pb v = pts_to_or_null' p pb (Ghost.reveal v)
+let pts_to_or_null p pb v = pts_to_or_null' p pb v
 
 let nullptr #a #b = None
 
@@ -110,41 +110,6 @@ let elim_pts_to #a #b #pb #v p =
 
 #push-options "--print_implicits"
 
-(*
-let aux' #a #b (pb:pcm b) : unit =
-  assert_norm (
-    pts_to_or_null #a #b (nullptr #a #b) pb (none #b)  ==
-    (if None? #(Steel.C.Ref.ref' a b) (nullptr #a #b)
-      then
-        Steel.C.Ptr.vpure (Prims.eq2 #(FStar.Ghost.erased (Steel.C.Opt.option b))
-	      (Steel.C.Opt.none #b)
-              (Steel.C.Opt.none #b))
-      else
-        (match FStar.Ghost.reveal #(Steel.C.Opt.option b) (Steel.C.Opt.none #b) with
-          | FStar.Pervasives.Native.None #_ -> Steel.C.Ptr.vpure Prims.l_False
-          | FStar.Pervasives.Native.Some #_ v ->
-            Steel.C.Ptr.pts_to #a #b (nullptr #a #b) pb (FStar.Ghost.hide #b v))
-        <:
-        Steel.Effect.Common.vprop)) // How is this not equal?? TODO
-*)
-
-(*
-let unfold_pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) (v: Ghost.erased (option 'b))
-: Lemma
-    (pts_to_or_null #'a #'b p pb (none #'b)  ==
-     (if None? p then vpure (v == none #'b) else
-     (match Ghost.reveal v with
-     | None -> vpure False
-     | Some v -> pts_to p pb (Ghost.hide v))))
-    [SMTPat (pts_to_or_null p pb v)]
-= assume // TODO why
-    (pts_to_or_null #'a #'b p pb (none #'b)  ==
-     (if None? p then vpure (v == none #'b) else
-     (match Ghost.reveal v with
-     | None -> vpure False
-     | Some v -> pts_to p pb (Ghost.hide v))))
-*)
-
 let unfold_pts_to_or_null #a #b (pb: pcm b) (p: ptr a b) (v: option b)
 : Lemma
     (pts_to_or_null #a #b p pb v  ==
@@ -155,18 +120,18 @@ let unfold_pts_to_or_null #a #b (pb: pcm b) (p: ptr a b) (v: option b)
 = ()
 
 let intro_pts_to_or_null_nullptr #a #b pb =
-  intro_vpure (Ghost.reveal (none #b) == None <==> nullptr #a #b == None);
+  intro_vpure (None #b == None <==> nullptr #a #b == None);
   intro_vpure True;
   unfold_pts_to_or_null #a #b pb (nullptr #a #b) None; 
-  change_equal_slprop _ (pts_to_or_null (nullptr #a #b) pb (none #b))
+  change_equal_slprop _ (pts_to_or_null (nullptr #a #b) pb (None #b))
 
 let intro_pts_to_or_null #a #b #_ #pb #v p =
-  let prf_p_nonnull = gget (pts_to p pb v) in
+  let prf_p_nonnull = gget (pts_to p pb (Ghost.reveal v)) in
   intro_vpure (Some (Ghost.reveal v) == None <==> p == None);
   unfold_pts_to_or_null pb p (Some (Ghost.reveal v));
   change_equal_slprop
     (vpure (Some (Ghost.reveal v) == None <==> p == None) `star` pts_to' p pb (Ghost.reveal v))
-    (pts_to_or_null p pb (some v))
+    (pts_to_or_null p pb (Some (Ghost.reveal v)))
   
 val unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
 : SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
@@ -191,30 +156,30 @@ let elim_pts_to_or_null_nonnull_witness #opened
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
 : SteelGhost (Ghost.erased 'b) opened
     (pts_to_or_null p pb v)
-    (fun w -> pts_to_or_null p pb (some w))
+    (fun w -> pts_to_or_null p pb (Some w))
     (requires fun _ -> p =!= nullptr)
-    (ensures fun _ w _ -> v == some w)
+    (ensures fun _ w _ -> v == Some w)
 = match Ghost.reveal v with
   | None -> 
     let prf = gget (pts_to_or_null p pb v) in
     let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
     assert (p == nullptr);
-    unreachable (fun w -> v == some w)
+    unreachable (fun w -> v == Some w)
   | Some w ->
     let prf = gget (pts_to_or_null p pb v) in
     let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
     assert (p =!= nullptr);
-    change_equal_slprop (pts_to_or_null p pb v) (pts_to_or_null p pb (some w));
+    change_equal_slprop (pts_to_or_null p pb v) (pts_to_or_null p pb (Some w));
     w
 
 #set-options "--ide_id_info_off"
 
 let elim_pts_to_or_null #a #b #_ #pb #v p =
   let w = elim_pts_to_or_null_nonnull_witness p in
-  unfold_pts_to_or_null pb p (some w);
-  change_equal_slprop (pts_to_or_null p pb (some w))
-    (vpure (Ghost.reveal (some w) == None <==> p == None) `star` pts_to' p pb w);
-  elim_vpure (Ghost.reveal (some w) == None <==> p == None);
+  unfold_pts_to_or_null pb p (Some w);
+  change_equal_slprop (pts_to_or_null p pb (Some w))
+    (vpure (Ghost.reveal (Some w) == None <==> p == None) `star` pts_to' p pb w);
+  elim_vpure (Ghost.reveal (Some w) == None <==> p == None);
   w
   
 let is_null #a #b #pb #v p = return (None? p)
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fsti b/examples/steel/arraystructs/Steel.C.Ptr.fsti
index 93b19276f6c..61a932492e9 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fsti
@@ -13,9 +13,9 @@ open Steel.Effect
 
 val ptr (a: Type u#0) (b: Type u#b) : Type u#b
 
-val pts_to (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: Ghost.erased 'b): vprop
+val pts_to (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: 'b): vprop
 
-val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: Ghost.erased (option 'b)): vprop
+val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: option 'b): vprop
 
 val nullptr (#a:Type) (#b:Type) : ptr a b
 
@@ -54,13 +54,13 @@ val elim_pts_to
 
 val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
   (pb: pcm b)
-: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb none)
+: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb None)
 
 val intro_pts_to_or_null (#opened:inames)
   (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
 : SteelGhostT unit opened
     (pts_to p pb v)
-    (fun _ -> pts_to_or_null p pb (some v))
+    (fun _ -> pts_to_or_null p pb (Some #'b v))
 
 val elim_pts_to_or_null_nullptr (#opened:inames)
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
@@ -68,7 +68,7 @@ val elim_pts_to_or_null_nullptr (#opened:inames)
     (pts_to_or_null p pb v)
     (fun _ -> emp)
     (requires fun _ -> p == nullptr)
-    (ensures fun _ _ _ -> v == none)
+    (ensures fun _ _ _ -> Ghost.reveal v == None)
 
 val elim_pts_to_or_null (#opened:inames)
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
@@ -76,7 +76,7 @@ val elim_pts_to_or_null (#opened:inames)
     (pts_to_or_null p pb v)
     (fun w -> pts_to p pb w)
     (requires fun _ -> p =!= nullptr)
-    (ensures fun _ w _ -> v == some w)
+    (ensures fun _ w _ -> Ghost.reveal v == Some #'b w)
 
 val is_null
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
@@ -114,5 +114,5 @@ val ptr_opt_write
   (#a:Type) (#b:Type) (#x: Ghost.erased b)
   (p: ptr a (option b)) (y: b)
 : SteelT unit
-    (pts_to p opt_pcm (some x))
-    (fun _ -> pts_to p opt_pcm (some (Ghost.hide y)))
+    (pts_to p opt_pcm (Some #b x))
+    (fun _ -> pts_to p opt_pcm (Some #b y))
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index bf218b4d28c..6e1a00d7167 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -16,7 +16,7 @@ open Steel.Effect
 
 val pts_to
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p) ([@@@smt_fallback] v: Ghost.erased b)
+  (r: ref a p) ([@@@smt_fallback] v: b)
 : vprop
 
 val ref_focus
diff --git a/src/parser/parse.fsy b/src/parser/parse.fsy
index 034ae06c395..0d4447e480e 100644
--- a/src/parser/parse.fsy
+++ b/src/parser/parse.fsy
@@ -2730,4 +2730,3 @@ in
 
 %%
 
-

From a8bb1e974d71f7564c4a0d637d8815094bd6e33d Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 10:17:47 -0700
Subject: [PATCH 141/513] Cleanup LList example

---
 examples/steel/arraystructs/LList.fst | 330 ++------------------------
 1 file changed, 21 insertions(+), 309 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 804dac3d19a..478df77dee5 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -135,87 +135,6 @@ let fold_pts_to_llist (#opened:inames) (p:ptr node node) (l:cells)
      pts_to_llist_tl l pts_to_llist)
     (p `pts_to_llist` l)
 
-(*
-unfold let f (x:option 'a): Tot prop = x == None #'a
-let good #a: squash ((None #a == None #a) == (f (None #a))) = ()
-
-let g (x:'a): Tot prop = x == x
-let good : squash ((None #int == None #int) == (g (None #int))) = ()
-
-let g (x:option int): Tot prop = x == None #int
-let bad : squash ((None #int == None #int) == (g (None #int))) = ()
-
-let g (x:option 'a): Tot prop = x == None #'a
-let bad #a: squash ((None #a == None #a) == (g (None #a))) =
-  assert_norm ((None #a == None #a) == (g (None #a)))
-
-let f (x:'a): Tot prop = x == x
-let good #a: squash ((3 == 3) == (f 3)) = ()
-
-let f (l:list 'a): Tot prop
-= (l == [])
-let bad #a: squash (([] #a == [] #a) == (f ([] #a))) = ()
-
-let f (l:list 'a): Tot prop
-= (l == [])
-let aux' #a =
-  assert_norm (
-    ([] #a == [])
-    ==
-    f ([] #a))
-
-let aux' #a =
-  assert_norm (
-    (let l = [] #a in
-    ((l == [])))
-    ==
-    f ([] #a))
-    
-let f (l:cells)
-: Tot vprop
-= vpure (l == [])
-
-let aux' (p: ptr node node) =
-  assert_norm (
-    (let l = [] #cell in
-    (LList.vpure (l == [])))
-    ==
-    f ([] #cell))
-
-let pts_to_llist' (p:ptr node node) (l:cells)
-: Tot vprop (decreases (List.length l))
-= vpure (p == nullptr <==> l == [])
-
-let aux' (p: ptr node node) =
-  assert_norm (
-    (let l = [] #cell in
-    (LList.vpure (p == Steel.C.Ptr.nullptr <==> l == [])))
-    ==
-    pts_to_llist' p ([] #cell))
-
-let aux' (p: ptr node node) =
-  assert_norm(
-    (let l = [] #cell in
-    Steel.Effect.Common.star (Steel.Effect.Common.star (LList.vpure (p == Steel.C.Ptr.nullptr <==>
-                l == []))
-          (Steel.C.Ptr.pts_to_or_null p ListNode.node_pcm (LList.hd_node l)))
-      (LList.pts_to_llist_tl l LList.pts_to_llist))
-    ==
-    pts_to_llist p ([] #cell))
-
-let aux p =
-    assert_norm (
-( vpure (p == nullptr <==> [] #cell == []) `star`
- pts_to_or_null p node_pcm (hd_node ([] #cell)) `star`
- pts_to_llist_tl ([] #cell) pts_to_llist)
-     ==
-    (p `pts_to_llist` [] #cell))
-    
-//  vpure (p == nullptr <==> l == []) `star`
-//  pts_to_or_null p node_pcm (hd_node l) `star`
-//  pts_to_llist_tl l pts_to_llist
-*)
-
 let intro_pts_to_llist_nil #opened p
 : SteelGhost unit opened 
     emp
@@ -348,45 +267,6 @@ let nontrivial_fact_about_mk_node value next
 : Lemma (Ghost.reveal (mk_node (some value) (some next)) =!= one node_pcm)
 = ()
 
-(*
-assume val intro_pts_to_llist_cons' : #opened:inames ->
-      p: ptr node ->
-      value: int ->
-      next: ptr node ->
-      l: Ghost.erased cells
-    -> Steel.Effect.Atomic.SteelGhostT unit
-        opened
-        (star (pts_to p node_pcm (mk_node (some (Ghost.hide value)) (some (Ghost.hide next))))
-	  (pts_to_llist next l))
-        (fun _ ->
-            pts_to_llist p
-              (Ghost.hide (FStar.Pervasives.Native.Mktuple2 value next :: Ghost.reveal l)))
-
-assume val addr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (Steel.C.Ptr.ptr node node)))
-  (p: Steel.C.Ptr.ptr node node)
-: Steel (Steel.C.Ptr.ptr node (option int))
-    (pts_to p node_pcm (mk_node value next))
-    (fun q ->
-       (pts_to p node_pcm (mk_node none next)) `star`
-       (pts_to q opt_pcm value))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> ptr_focused q p _value))
-
-assume val unaddr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (Steel.C.Ptr.ptr node node)))
-  (p: Steel.C.Ptr.ptr node node)
-  (q: Steel.C.Ptr.ptr node (option int))
-: Steel unit
-    ((pts_to p node_pcm (mk_node none next)) `star`
-     (pts_to q opt_pcm value))
-    (fun q -> pts_to p node_pcm (mk_node value next))
-    (requires (fun _ -> ptr_focused q p _value))
-    (ensures (fun _ _ _ -> True))
-    *)
-
 val is_empty
   (#l: Ghost.erased cells) (p: ptr node)
 : Steel bool
@@ -405,7 +285,7 @@ val set_first (p:ptr node) (l:Ghost.erased cells) (value:int)
     (p `pts_to_llist` l)
     (fun _ -> p `pts_to_llist` cells_set_hd value l)
 
-assume val intro_pts_to_llist_cons' : #opened:inames ->
+val intro_pts_to_llist_cons' : #opened:inames ->
       p: ptr node ->
       value: int ->
       next: ptr node ->
@@ -418,6 +298,25 @@ assume val intro_pts_to_llist_cons' : #opened:inames ->
             pts_to_llist p
               (Ghost.hide (FStar.Pervasives.Native.Mktuple2 value next :: Ghost.reveal l)))
 
+let intro_pts_to_llist_cons' p value next l = 
+  intro_pts_to_llist_cons p
+    (mk_node (some (Ghost.hide value)) (some (Ghost.hide next))) 
+    value next l
+
+(* TODO move to Steel.C.Ptr? *)
+val intro_pts_to'
+  (#pb: pcm 'b) (#v: Ghost.erased 'b)
+  (r: ref 'a pb) (p: Steel.C.Ptr.ptr 'a 'b)
+: Steel unit
+    (r `R.pts_to` v)
+    (fun _ -> pts_to p pb v)
+    (requires fun _ -> p == vptr r)
+    (ensures fun _ _ _ -> True)
+
+let intro_pts_to' r p =
+  let p' = intro_pts_to r in
+  change_equal_slprop (pts_to p' _ _) (pts_to p _ _)
+
 let set_first p l new_value =
   let b = is_empty p in
   if b then begin
@@ -429,194 +328,7 @@ let set_first p l new_value =
     let r_value = addr_of_value r in
     r_value `opt_write` new_value;
     unaddr_of_value r r_value;
-    let p' = intro_pts_to r in
-    assert (p == p');
-    change_equal_slprop (pts_to p' _ _) (pts_to p _ _);
+    intro_pts_to' r p;
     intro_pts_to_llist_cons' p new_value res.next res.tl;
     return ()
   end
-
-(*
-let rec cells_set_nth (n:nat) (value:int) (l:cells) : Tot cells (decreases n) =
-  if n = 0 then cells_set_hd value l
-  else match l with
-  | [] -> []
-  | hd :: tl -> hd :: cells_set_nth (n - 1) value tl
-
-let rec cells_set_nth_nil n value
-: Lemma (ensures cells_set_nth n value [] == []) (decreases n)
-= if n = 0 then () else cells_set_nth_nil (n - 1) value
-
-let llist_setter (n:nat) =
-  p:ptr node -> l:Ghost.erased cells -> value:int ->
-  SteelT unit
-    (p `pts_to_llist` l)
-    (fun _ -> p `pts_to_llist` cells_set_nth n value l)
-
-let llist_set_zero: llist_setter 0 = set_hd
-
-// TODO set_hd: can make helper function is_empty to check whether list is empty or not
-
-let aux n value l = cells_set_nth (n + 1) value l
-
-let aux n (ih: llist_setter n) (p: ptr node) (l: Ghost.erased cells) (new_value: int)
-: SteelT unit
-    (p `pts_to_llist` l)
-    (fun _ -> p `pts_to_llist` cells_set_nth (n + 1) new_value l)
-= unfold_pts_to_llist p l;
-  let b = is_null p in
-  fold_pts_to_llist p l;
-  assume (b == false);
-  //if b then begin
-  //  pts_to_llist_nullptr p l;
-  //  cells_set_nth_nil (n + 1) new_value;
-  //  return ()
-  //end else begin
-    let res = elim_pts_to_llist_cons p l in
-    let r = elim_pts_to p in
-    let r_next = addr_of_next r in
-    let q = opt_read r_next in
-    unaddr_of_next r r_next;
-    assert (q == res.next);
-    change_equal_slprop (res.next `pts_to_llist` _) (q `pts_to_llist` _);
-    ih q res.tl new_value;
-    //let p' = intro_pts_to r in
-    //change_equal_slprop (pts_to p' node_pcm _) (pts_to p node_pcm _);
-    //intro_pts_to_llist_cons p
-    //  (mk_node (some (Ghost.hide new_value)) (some (Ghost.hide res.next)))
-    //  new_value res.next res.tl;
-    sladmit();
-    return ()
-  //end
-
-  // assume (Some? p);
-  // // match p with
-  // // | None ->
-  // //   pts_to_llist_nullptr p l;
-  // //   cells_set_nth_nil (n + 1) value;
-  // //   change_equal_slprop
-  // //     (None `pts_to_llist` [])
-  // //     (p `pts_to_llist` cells_set_nth (n + 1) value l);
-  // //   return ()
-  // // | Some r ->
-  // let Some r = p in
-  //   let res = pts_to_llist_some p l in
-  //   let value: Ghost.erased int = Ghost.hide res.value in
-  //   let next: Ghost.erased ptr = Ghost.hide res.next in
-  //   let tl: Ghost.erased cells = Ghost.hide res.tl in
-  //   //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
-  //   //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
-  //   //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
-  //   change_equal_slprop (p `pts_to_llist` l)
-  //     (Some r `pts_to_llist`
-  //      Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
-  //   let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
-  //   let r: ref node node_pcm = r in
-  //   change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
-  //     (r `pts_to` mk_node (some value) (some next));
-  //   let r_next = addr_of_next r in
-  //   let q: ptr = opt_read r_next in
-  //   assert (q == Ghost.reveal next);
-  //   unaddr_of_next r r_next;
-  //   change_equal_slprop (Ghost.reveal next `pts_to_llist` _) (q `pts_to_llist` _);
-  //   ih q tl new_value;
-  //   change_equal_slprop (q `pts_to_llist` _) (Ghost.reveal next `pts_to_llist` _);
-  //   intro_llist_cons r (Ghost.reveal value) (Ghost.reveal next) _;
-//// val intro_llist_cons
-////   (#opened:inames) (r: ref node node_pcm)
-////   (value: int) (next: ptr)
-////   (tl: cells)
-//// : SteelGhostT unit opened
-////     ((r `pts_to` mk_node (some value) (some next)) `star` (next `pts_to_llist` tl))
-////     (fun _ -> Some r `pts_to_llist` ((value, next)::tl))
-  //   sladmit(); return ()
-  //   // //assert (Ghost.reveal r' == r);
-  //   // //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
-  //   // let r_value = addr_of_value r in
-  //   // r_value `opt_write` new_value;
-  //   // unaddr_of_value r r_value;
-  //   // intro_llist_cons r new_value next tl;
-  //   // //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
-  //   // //sladmit(); return ()
-  //   // return ()
-  // let set_hd p l new_value =
-
-let llist_set_succ n (ih: llist_setter n): llist_setter (n + 1) =
-  let aux (p: ptr) (l: Ghost.erased cells) (value: int)
-  : SteelT unit
-      (p `pts_to_llist` l)
-      (fun _ -> p `pts_to_llist` cells_set_nth (n + 1) value l)
-  = assume (Some? p);
-    // match p with
-    // | None ->
-    //   pts_to_llist_nullptr p l;
-    //   cells_set_nth_nil (n + 1) value;
-    //   change_equal_slprop
-    //     (None `pts_to_llist` [])
-    //     (p `pts_to_llist` cells_set_nth (n + 1) value l);
-    //   return ()
-    // | Some r ->
-    let Some r = p in
-      let res = pts_to_llist_some p l in
-      let value: Ghost.erased int = Ghost.hide res.value in
-      let next: Ghost.erased ptr = Ghost.hide res.next in
-      let tl: Ghost.erased cells = Ghost.hide res.tl in
-      //let value: Ghost.erased int = Ghost.hide (fst value_next_tl) in
-      //let next: Ghost.erased ptr = Ghost.hide (fst (snd value_next_tl)) in
-      //let tl: Ghost.erased cells = Ghost.hide (snd (snd value_next_tl)) in
-      change_equal_slprop (p `pts_to_llist` l)
-        (Some r `pts_to_llist`
-         Ghost.hide ((Ghost.reveal value, Ghost.reveal next) :: Ghost.reveal tl));
-      let r' = elim_llist_cons (Some r) (Ghost.reveal value) (Ghost.reveal next) (Ghost.reveal tl) in
-      let r: ref node node_pcm = r in
-      change_equal_slprop (Ghost.reveal r' `pts_to` mk_node (some value) (some next))
-        (r `pts_to` mk_node (some value) (some next));
-      let r_next = addr_of_next r in
-      let q: ptr = opt_read r_next in
-      unaddr_of_next r r_next;
-      //ih q tl value;
-      sladmit(); return ()
-      // //assert (Ghost.reveal r' == r);
-      // //slassert (Ghost.reveal r' `pts_to` mk_node (some value) (some next));
-      // let r_value = addr_of_value r in
-      // r_value `opt_write` new_value;
-      // unaddr_of_value r r_value;
-      // intro_llist_cons r new_value next tl;
-      // //change_equal_slprop (Ghost.reveal r' `pts_to` mk_node _ _) (r `pts_to` mk_node _ _);
-      // //sladmit(); return ()
-      // return ()
-  in aux
-
-// TODO look at #2319, construct module of (possibly null) pointers
-// (define pts_to_or_null; can compare against null only if points to non-unit)
-
-// Mutate the kth element of a list (of fixed k)
-// 
-// t k = type of functions that mutate kth element of a list
-// 
-// set_zero : Tot (t 0)
-// set_succ : t k -> Tot (t (k + 1))
-//
-// let rec set k .. : Steel _ = 
-// let rec set k .. : Tot (.. -> Steel _) = 
-
-(*
-val pop (#a:Type) (ptr:t a) (l:list (cell a){Cons? l})
-  : Steel a
-          (llist ptr l)
-          (fun _ -> llist (next (L.hd l)) (L.tl l))
-          (requires fun _ -> True)
-          (ensures fun _ x _ -> x == data (L.hd l))
-
-let pop #a ptr l =
-  let hd = L.hd l in
-  let tl = L.tl l in
-  rewrite_slprop (llist ptr l) (llist ptr (hd::tl)) (fun _ -> ());
-  elim_llist_cons ptr hd tl;
-  let c = read_pt ptr in
-  let n = next hd in
-  free_pt ptr;
-  rewrite_slprop (llist (next hd) tl) (llist (next (L.hd l)) (L.tl l)) (fun _ -> ());
-  return (data c)
-*)
-*)

From 432e696da7baa6a9adc7c88a8860e705138736c6 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 13:22:56 -0700
Subject: [PATCH 142/513] First pass at struct literals

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 245 +++++++++++-------
 .../arraystructs/Steel.C.StructLiteral.fsti   | 109 ++++++++
 .../steel/arraystructs/Steel.C.Typedef.fst    |  24 --
 3 files changed, 266 insertions(+), 112 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.StructLiteral.fsti

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index bfd65d16cbb..00924ca8138 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -1,108 +1,46 @@
 module Steel.C.StructLiteral
 
-(*
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Connection
-open Steel.C.Struct
-open FStar.FunctionalExtensionality
-open Steel.Effect
-module A = Steel.Effect.Atomic
-*)
-
-open Steel.C.PCM
 open Steel.C.Typedef
 open Steel.C.Ref // for refine
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-let struct_fields = list (string * typedef)
-
-assume val struct' (tag: string) (fields: struct_fields) (excluded: list string): Type
+let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
 
-let struct (tag: string) (fields: struct_fields): Type = struct' tag fields []
-
-(* BEGIN TODO delete the ones in Steel.C.Typedef *)
+let rec mk_struct (tag: string) (fields: list (string * typedef))
+: mk_struct_ty tag fields
+= match fields with
+  | [] -> on_dom _ (fun field -> () <: struct_view_types fields field)
+  | (field, td) :: fields' ->
+    fun (x:td.view_type) ->
+    let f: map struct_field_view_type fields' `list_fn` struct tag fields' = mk_struct tag fields' in
+    let lift_struct (g: struct tag fields'): struct tag fields =
+      let h (field': field_of fields): struct_view_types fields field' =
+        if field' = field then x else g field'
+      in on_dom _ h
+    in
+    list_fn_map lift_struct f
 
-let has_field (fields: struct_fields) (excluded: list string) (field: string): prop =
-  field `mem` map fst fields == true /\ ~ (field `mem` excluded == true)
-  
-let field_of (fields: struct_fields) (excluded: list string) =
-  refine string (has_field fields excluded)
+let struct_get x field = x field
 
-let get_field (fields: struct_fields) (excluded: list string)
-  (field: field_of fields excluded)
-: typedef
-= assoc_mem field fields;
-  Some?.v (assoc field fields)
-  
-(* END TODO *)
-
-/// Reading a struct field
-assume val struct_get
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field: field_of fields excluded)
-: (get_field fields excluded field).view_type
-
-/// Writing a struct field
-assume val struct_put
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field: field_of fields excluded)
-  (v: (get_field fields excluded field).view_type)
-: struct' tag fields excluded
+let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
 /// For a fixed field name, struct_get and struct_put form a lens
 
-assume val struct_get_put 
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field: field_of fields excluded)
-  (v: (get_field fields excluded field).view_type)
-: Lemma (struct_put x field v `struct_get` field == v)
-  [SMTPat (struct_put x field v `struct_get` field)]
+let struct_get_put x field v = ()
 
-assume val struct_put_get
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field: field_of fields excluded)
-: Lemma (struct_put x field (x `struct_get` field) == x)
-  [SMTPat (struct_put x field (x `struct_get` field))]
+let struct_put_get x field =
+  assert (struct_put x field (x `struct_get` field) `feq` x)
 
-assume val struct_put_put
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field: field_of fields excluded)
-  (v w: (get_field fields excluded field).view_type)
-: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
-  [SMTPat (struct_put (struct_put x field v) field w)]
+let struct_put_put x field v w =
+  assert (struct_put (struct_put x field v) field w `feq` struct_put x field w)
 
-/// struct_get/struct_put pairs for different fields don't interfere with each other
+let struct_get_put_ne x field1 field2 v = ()
 
-assume val struct_get_put_ne
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field1: field_of fields excluded)
-  (field2: field_of fields excluded)
-  (v: (get_field fields excluded field1).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
-  [SMTPat (struct_put x field1 v `struct_get` field2)]
-
-assume val struct_put_put_ne
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field1: field_of fields excluded)
-  (v: (get_field fields excluded field1).view_type)
-  (field2: field_of fields excluded)
-  (w: (get_field fields excluded field2).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_put (struct_put x field1 v) field2 w ==
-      struct_put (struct_put x field2 w) field1 v)
+let struct_put_put_ne x field1 v field2 w = 
+  assert (
+    struct_put (struct_put x field1 v) field2 w `feq`
+    struct_put (struct_put x field2 w) field1 v)
 
 (*
 define attribute on mk_struct_view_type, etc..
@@ -118,6 +56,11 @@ mk_struct_view v .. = mk_struct_view' (Some v) ..
 mk_struct_view' (Some v) None
 
 struct_type tag fields =
+
+without:
+  (#tag: string) (#fields: struct_fields) (#excluded: list string)
+  (x: struct' tag fields excluded)
+  (field: field_of fields excluded)
 *)
 
 (*
@@ -406,3 +349,129 @@ let point_view
 //   to_view_frame = (fun x frame -> ());
 // }
 *)
+
+
+(*
+
+to translate t
+
+  typedef_t: typedef t = { ... }
+
+to translate struct tag { S s; ... }
+
+  assume val struct (tag: string) (fields: list (string * typedef)): Type
+  assume val mk_struct_typedef (tag: string) (fields: list (string * typedef)):
+    typedef (struct tag ["s", typedef_S; ..))
+  
+  typedef_struct_tag: typedef (struct "tag" ["s", typedef_S; ..]) =
+     mk_struct_typedef "tag" ["s", typedef_S; ..]
+
+to translate struct loop { struct loop *again; }
+
+// Done (assuming can store pointers in heap)
+  carrier: Type0; 
+  pcm: pcm carrier; 
+
+view_type = {loop: ref struct_loop_carrier struct_loop_pcm}
+
+mk_view_type
+  (carrier: Type0)
+  (pcm: pcm carrier)
+-> view_type : {loop: ref struct_loop_carrier struct_loop_pcm}
+
+mk_rec_typedef:
+  (carrier: Type0)
+  (pcm: pcm carrier)
+-> t:typedef (mk_view_type carrier pcm) { t.carrier == carrier /\ t.pcm == pcm}
+
+noeq type typedef = { 
+
+// _
+  view_type: Type0; 
+
+// Should be fine
+  can_view_unit: bool; 
+  view: sel_view pcm view_type can_view_unit; 
+} 
+
+  typedef_struct_loop_f (recur:typedef)
+  : typedef (struct "loop" ["again", ref_typedef recur.carrier recur.pcm])
+  = mk_struct_typedef "loop" ["again", ref_typedef recur.carrier recur.pcm]
+
+  typedef_struct_loop
+  : typedef (struct "loop"
+      ["again",
+       ref_typedef
+         typedef_struct_loop.carrier
+         typedef_struct_loop.pcm])
+  = typedef_struct_loop_f typedef_struct_loop
+
+*)
+
+/// TODO Would be nice to have somtehing like this but proofs get tricky
+
+/// struct_put and struct_get are sound w.r.t. a model of structs as n-tuples
+
+(* BEGIN public *)
+
+let rec list_fn_args (dom: list Type) = match dom with
+  | [] -> unit
+  | d :: dom -> d & list_fn_args dom
+
+let rec list_apply #dom #b (f: dom `list_fn` b) (xs: list_fn_args dom): b = match dom with
+  | [] -> f
+  | a :: dom ->
+    let (x, xs): a & list_fn_args dom = xs in
+    let f: a -> dom `list_fn` b = f in
+    f x `list_apply` xs
+
+let rec struct_get_model
+  (#tag: string) (#fields: struct_fields) 
+  (vs: list_fn_args (mk_struct_ty_dom tag fields))
+  (field: field_of fields)
+: (get_field fields field).view_type
+= match fields with
+  | [] -> assert false
+  | (field', td) :: fields ->
+    let (v, vs): td.view_type & list_fn_args (mk_struct_ty_dom tag fields) = vs in
+    if field = field' then v else struct_get_model vs field
+
+let rec struct_put_model
+  (#tag: string) (#fields: struct_fields) 
+  (vs: list_fn_args (mk_struct_ty_dom tag fields))
+  (field: field_of fields)
+  (v: (get_field fields field).view_type)
+: list_fn_args (mk_struct_ty_dom tag fields)
+= match fields with
+  | [] -> vs
+  | (field', td) :: fields ->
+    let (v', vs): td.view_type & list_fn_args (mk_struct_ty_dom tag fields) = vs in
+    if field = field' then (v, vs) else (v', struct_put_model vs field v)
+
+(* END public *)
+
+val struct_get_sound
+  (#tag: string) (#fields: struct_fields) 
+  (vs: list_fn_args (mk_struct_ty_dom tag fields))
+  (field: field_of fields)
+: Lemma (
+    (mk_struct tag fields `list_apply` vs) `struct_get` field ==
+    struct_get_model vs field)
+
+let rec struct_get_sound #tag #fields vs field : Lemma (ensures
+    (mk_struct tag fields `list_apply` vs) `struct_get` field ==
+    struct_get_model vs field) (decreases fields) = match fields with
+  | [] -> ()
+  | (field', td) :: fields ->
+    let (v, vs): td.view_type & list_fn_args (mk_struct_ty_dom tag fields) = vs in
+    let field: field_of ((field', td) :: fields) = field in
+    if field = field' then begin
+      let f = mk_struct tag ((field', td) :: fields) in
+      assert ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) f (v, vs)) `struct_get` field ==
+        begin
+          let (x, xs): (struct_field_view_type (field', td) & list_fn_args (mk_struct_ty_dom tag fields)) = (v, vs) in
+          let f: struct_field_view_type (field', td) -> (mk_struct_ty_dom tag fields `list_fn` struct tag fields) = admit() in
+          f x `list_apply` xs
+        end);
+      assume ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) (mk_struct tag ((field', td) :: fields)) (v, vs)) `struct_get` field == v)
+    end else admit()//struct_get_sound #tag #fields vs field
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
new file mode 100644
index 00000000000..5877d3775dd
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -0,0 +1,109 @@
+module Steel.C.StructLiteral
+
+open Steel.C.Typedef
+open Steel.C.Ref // for refine
+open FStar.List.Tot
+
+let struct_fields = list (string * typedef)
+
+let has_field (fields: struct_fields) (field: string): prop =
+  field `mem` map fst fields == true
+  
+let field_of (fields: struct_fields) =
+  refine string (has_field fields)
+
+let get_field (fields: struct_fields) (field: field_of fields): typedef =
+  assoc_mem field fields;
+  Some?.v (assoc field fields)
+
+let struct_view_types (fields: struct_fields) (field: field_of fields) =
+  (get_field fields field).view_type
+
+/// A view type for structs
+val struct (tag: string) (fields: struct_fields): Type0
+
+let rec list_fn (dom: list Type) (cod: Type) = match dom with
+  | [] -> cod
+  | d :: dom -> d -> list_fn dom cod
+
+let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
+  | [] -> f g <: [] `list_fn` 'b
+  | d :: dom' ->
+    let g: d -> dom' `list_fn` 'a = g in
+    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
+
+let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
+
+let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
+  map struct_field_view_type fields
+
+let mk_struct_ty (tag: string) (fields: list (string * typedef)): Type =
+  mk_struct_ty_dom tag fields `list_fn` struct tag fields
+
+/// A struct literal
+val mk_struct (tag: string) (fields: list (string * typedef)): mk_struct_ty tag fields
+
+/// Reading a struct field
+val struct_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (get_field fields field).view_type
+
+/// Writing a struct field
+val struct_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).view_type)
+: struct tag fields
+
+/// For a fixed field name, struct_get and struct_put form a lens
+
+val struct_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).view_type)
+: Lemma (struct_put x field v `struct_get` field == v)
+  [SMTPat (struct_put x field v `struct_get` field)]
+
+val struct_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+: Lemma (struct_put x field (x `struct_get` field) == x)
+  [SMTPat (struct_put x field (x `struct_get` field))]
+
+val struct_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v w: (get_field fields field).view_type)
+: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
+  [SMTPat (struct_put (struct_put x field v) field w)]
+
+/// struct_get/struct_put pairs for different fields don't interfere with each other
+
+val struct_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (get_field fields field1).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
+  [SMTPat (struct_put x field1 v `struct_get` field2)]
+  
+val struct_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (v: (get_field fields field1).view_type)
+  (field2: field_of fields)
+  (w: (get_field fields field2).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_put (struct_put x field1 v) field2 w ==
+      struct_put (struct_put x field2 w) field1 v)
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index 708be0cad18..bdec8415615 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -15,30 +15,6 @@ noeq type typedef = {
 
 // assume val malloc: typedef -> ptr typedef.carrier typedef.pcm 
 
-let has_field (fields: list (string & typedef)) (field: string): prop =
-  field `mem` map fst fields == true
-
-let field_of (fields: list (string & typedef)) = refine string (has_field fields)
-
-let get_field (fields: list (string & typedef)) (field: field_of fields): typedef =
-  assoc_mem field fields;
-  Some?.v (assoc field fields)
-  
-let type_family_of (fields: list (string & typedef)) (field: field_of fields) =
-  (get_field fields field).view_type
-
-//struct : string -> list (_ & _) -> Type
-
-val typedef_struct: string -> list (string & typedef) -> Tot typedef 
-
-let typedef_struct name fields = {
-  carrier = restricted_t (field_of fields) (type_family_of fields);
-  pcm = admit();
-  view_type = admit();
-  can_view_unit = admit();
-  view = admit();
-}
-
 (*
  
 

From 4a4ef09cbda488ffb4a6f582f6a8cf82f2ea4ba8 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 13:23:53 -0700
Subject: [PATCH 143/513] Tidy

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 304 ------------------
 1 file changed, 304 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 00924ca8138..3091c400e7e 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -49,310 +49,6 @@ mk_struct_view': fields:list (string * _) ->
   norm [delta_attr ..; delta Fstar.list.map; ..] .. (mk_struct_view_type fields ..)
   (See FStar.Pervasives.fsti)
 
-x: struct' tag fields excluded
-
-mk_struct_view v .. = mk_struct_view' (Some v) ..
-
-mk_struct_view' (Some v) None
-
-struct_type tag fields =
-
-without:
-  (#tag: string) (#fields: struct_fields) (#excluded: list string)
-  (x: struct' tag fields excluded)
-  (field: field_of fields excluded)
-*)
-
-(*
-
-struct_put x field v `without_field` field
-x `without_field` field
-
-struct s excluded
-struct s excluded'
-f in excluded <==> f in excluded'
-
-without_field : 
-  (field: string)
-  (x: struct s excluded fields) ->
-  struct s (field :: excluded)
-
-*)
-
-(*
-let struct_field_view_types fields = restricted_t (field_of fields) (type_family_of fields)
-
-let struct_field_pcm_carriers (fields: _) (field: field_of fields) =
-  (get_field fields field).carrier
-
-let struct_field_pcms (fields: _) (field: field_of fields)
-: pcm (struct_field_pcm_carriers fields field)
-= (get_field fields field).pcm
-
-let struct_pcm_carrier (fields: list (string * typedef)) =
-  restricted_t (field_of fields) (struct_field_pcm_carriers fields)
-  
-let struct_pcm (fields: list (string * typedef))
-: pcm (struct_pcm_carrier fields)
-= prod_pcm (struct_field_pcms fields)
-
-val point : Type0
-
-let point = struct_pcm_carrier point_fields
-
-
-/// PCM for struct point:
-
-val point_pcm : pcm point
-
-/// (mk_point x y) represents (struct point){.x = x, .y = y}
-
-val mk_point (x y: Ghost.erased (option int)): Ghost.erased point
-
-/// Connections for the fields of a point
-
-val _x : connection point_pcm (opt_pcm #int)
-val _y : connection point_pcm (opt_pcm #int)
-
-/// Taking pointers to the x and y fields of a point
-
-val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _x})
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point none y) `star`
-       (q `pts_to` x))
-
-unfold
-let point_fields_pcm_carriers = struct_field_pcm_carriers point_fields
-
-unfold
-let point_fields_pcms
-: field:field_of point_fields -> pcm (point_fields_pcm_carriers field)
-= struct_field_pcms point_fields
-
-unfold
-let point_pcm_carrier = struct_pcm_carrier point_fields
-
-unfold
-let point_pcm: pcm point_pcm_carrier = struct_pcm point_fields
-
-let mk_point_f_lame (x y: option int) (field: field_of point_fields)
-: point_fields_pcm_carriers field
-= match field with
-  | "x" -> x
-  | "y" -> y
-
-(* BEGIN TODO move to Typedef *)
-
-let rec list_fn (dom: list Type) (cod: Type) =
-  match dom with
-  | [] -> cod
-  | d :: dom -> d -> list_fn dom cod
-
-let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b =
-  match dom with 
-  | [] -> f g <: [] `list_fn` 'b
-  | d :: dom' ->
-    let g: d -> dom' `list_fn` 'a = g in
-    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
-
-let field_pcm_carrier ((_, td): string * typedef) = td.carrier
-
-let mk_struct_ty (fields: list (string * typedef)): Type =
-  map field_pcm_carrier fields `list_fn` struct_pcm_carrier fields
-
-let rec mk_struct (fields: list (string * typedef))
-: mk_struct_ty fields
-= match fields with
-  | [] -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
-  | (field, td) :: fields' ->
-    fun (x:td.carrier) ->
-    let f: map field_pcm_carrier fields' `list_fn` struct_pcm_carrier fields' = mk_struct fields' in
-    let lift_struct (g: struct_pcm_carrier fields'): struct_pcm_carrier fields =
-      let h (field': field_of fields): struct_field_pcm_carriers fields field' =
-        if field' = field then x else g field'
-      in on_dom _ h
-    in
-    list_fn_map lift_struct f
-    
-(* END move to Typedef *)
-
-let mk_point_f
-: option int -> option int -> struct_pcm_carrier point_fields
-= mk_struct point_fields
-
-let _ =
-  let test (k: field_of point_fields) (x y: option int) =
-    assert (mk_point_f_lame x y k == mk_point_f x y k)
-  in ()
-
-let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
-  Ghost.hide (on_dom _ (mk_point_f_lame (Ghost.reveal x) (Ghost.reveal y)))
-
-let _x = struct_field point_fields_pcms "x"
-let _y = struct_field point_fields_pcms "y"
-
-/// Taking pointers to the x and y fields of a point
-
-let point_without_x x y
-: Lemma (struct_without_field point_fields_pcms "x" (mk_point x y) `feq` Ghost.reveal (mk_point none y))
-  [SMTPat (mk_point x y)]
-= ()
-
-let point_with_x x y
-: Lemma (struct_with_field point_fields_pcms "x" (Ghost.reveal x) (mk_point none y) `feq`
-         Ghost.reveal (mk_point x y))
-  [SMTPat (mk_point x y)]
-= ()
-
-let point_without_y x y
-: Lemma (struct_without_field point_fields_pcms "y" (mk_point x y) `feq` Ghost.reveal (mk_point x none))
-  [SMTPat (mk_point x y)]
-= ()
-
-let point_with_y x y
-: Lemma (struct_with_field point_fields_pcms "y" (Ghost.reveal y) (mk_point x none) `feq`
-         Ghost.reveal (mk_point x y))
-  [SMTPat (mk_point x y)]
-= ()
-
-#restart-solver
-
-let feq' (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
-= 'a == 'c /\
-  normalize ('b == 'd) /\
-  f `feq` g
-
-let ext (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
-: Lemma (requires f `feq'` g) (ensures f == g) //[SMTPat (f `feq'` g)]
-= extensionality 'a 'b f g
-  //FStar.Classical.forall_intro fg
-
-//let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-//  extensionality 'a 'b f g;
-//  FStar.Classical.forall_intro fg
-
-// let feq' (f g: restricted_t 'a 'b): prop = forall x. f x == g x
-
-// let ext' (f g: restricted_t 'a 'b)
-// : Lemma (requires f `feq'` g) (ensures f == g) [SMTPat (f `feq'` g)]
-// = extensionality 'a 'b f g
-//   //FStar.Classical.forall_intro fg
-
-let aux x y : unit
-= assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) `feq` mk_point none y);
-  ()
-
-
-let addr_of_x #a #x #y p =
-  let q = addr_of_struct_field p "x" (mk_point x y) in
-  //A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y)))) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
-  //A.change_equal_slprop (p `pts_to` _) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
-  //assume (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
-  //(field_of fields) (struct_field_pcm_carriers fields)
-  assert (
-    struct_without_field point_fields_pcms "x" (mk_point x y)
-    `feq'`
-    Ghost.reveal (mk_point none y));
-  A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y))) (p `pts_to` mk_point none y);
-  //A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  A.sladmit();
-  A.return q
-
-// (f `feq` Ghost.reveal g)
-// (Ghost.hide f == g)
-
-(*
-
-struct : string -> list string -> list (string & typedef) -> Type
-
-without_field
-  (field: string)
-  (x: struct s excluded fields) ->
-  struct s excluded
-*)
-let addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-
-let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "x" q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_y #a #x #y p =
-  let q = addr_of_struct_field p "y" (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
-  A.return q
-
-let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "y" q p (mk_point x none) y; // same here
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let struct_point_fields = [
-  "x", c_int;
-  "y", c_int;
-]
-
-let point_field_of_string (field: field_of struct_point_fields): point_field =
-  match field with
-  | "x" -> X
-  | "y" -> Y
-
-let struct_point_view_t (k: field_of struct_point_fields): Type =
-  (get_field struct_point_fields k).view_type
-
-let struct_point_view_pcm_t (k: field_of struct_point_fields): Type =
-  point_fields (point_field_of_string k)
-  
-let struct_point_view_pcm (k: field_of struct_point_fields)
-: pcm (struct_point_view_pcm_t k)
-= point_fields_pcms (point_field_of_string k)
-
-let struct_point_fields_view (k:field_of struct_point_fields)
-: sel_view (point_fields_pcms (point_field_of_string k)) (struct_point_view_t k) false
-= (get_field struct_point_fields k).view
-
-(*
-let struct_view
-  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type)
-  (#can_view_units: bool)
-  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
-  (included: list a)
-: sel_view (prod_pcm p)
-    (restricted_t (refine a (mem included)) view_t)
-    (can_view_units || Nil? included) *)
-
-let point_view
-//: sel_view (prod_pcm struct_point_view_pcm_t) (view_type_of struct_point_fields) false
-= struct_view struct_point_fields_view (map (admit() )struct_point_fields)
-
-// = {
-//   to_view_prop = (fun x -> Some? x == true);
-//   to_view = (fun x -> Some?.v x);
-//   to_carrier = (fun z  -> Some z);
-//   to_carrier_not_one = ();
-//   to_view_frame = (fun x frame -> ());
-// }
-*)
-
-
-(*
-
 to translate t
 
   typedef_t: typedef t = { ... }

From 60b7d8aae4d877b9552204c3d91647a96a9c0bc7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 14:14:34 -0700
Subject: [PATCH 144/513] Struct literals + laws for struct PCM carriers

---
 .../arraystructs/PointStructSelectors.fst     |   3 +-
 .../arraystructs/Steel.C.StructLiteral.fst    | 134 +++++++++++++++++-
 .../arraystructs/Steel.C.StructLiteral.fsti   |  14 +-
 3 files changed, 145 insertions(+), 6 deletions(-)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 00e07835bec..9114c10dc66 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -1,4 +1,4 @@
-module PointStruct
+module PointStructSelectors
 
 open Steel.C.PCM
 open Steel.C.Opt
@@ -9,6 +9,7 @@ open Steel.Effect
 module A = Steel.Effect.Atomic
 
 open Steel.C.Typedef
+open Steel.C.StructLiteral
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 3091c400e7e..baa428044c8 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -1,10 +1,15 @@
 module Steel.C.StructLiteral
 
+open Steel.C.PCM
+open Steel.C.Struct
 open Steel.C.Typedef
 open Steel.C.Ref // for refine
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+let struct_view_types (fields: struct_fields) (field: field_of fields) =
+  (get_field fields field).view_type
+
 let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
 
 let rec mk_struct (tag: string) (fields: list (string * typedef))
@@ -25,8 +30,6 @@ let struct_get x field = x field
 
 let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
-/// For a fixed field name, struct_get and struct_put form a lens
-
 let struct_get_put x field v = ()
 
 let struct_put_get x field =
@@ -171,3 +174,130 @@ let rec struct_get_sound #tag #fields vs field : Lemma (ensures
         end);
       assume ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) (mk_struct tag ((field', td) :: fields)) (v, vs)) `struct_get` field == v)
     end else admit()//struct_get_sound #tag #fields vs field
+
+
+/// Similarly, a PCM for structs
+
+let struct_carriers (fields: struct_fields) (field: field_of fields) =
+  (get_field fields field).carrier
+
+val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
+let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
+
+let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
+: pcm (struct_carriers fields field)
+= (get_field fields field).pcm
+
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
+
+(* BEGIN public *)
+let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
+
+let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
+  map struct_field_carrier fields
+
+let mk_struct_pcm_ty (tag: string) (fields: list (string * typedef)): Type =
+  mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
+(* END public *)
+
+/// A struct PCM carrier literal
+val mk_struct_pcm (tag: string) (fields: list (string * typedef)): mk_struct_pcm_ty tag fields
+
+let rec mk_struct_pcm_carrier (tag: string) (fields: list (string * typedef))
+: mk_struct_pcm_ty tag fields
+= match fields with
+  | [] -> on_dom _ (fun field -> () <: struct_carriers fields field)
+  | (field, td) :: fields' ->
+    fun (x:td.carrier) ->
+    let f: map struct_field_carrier fields' `list_fn` struct_pcm_carrier tag fields' = mk_struct_pcm_carrier tag fields' in
+    let lift_struct (g: struct_pcm_carrier tag fields'): struct_pcm_carrier tag fields =
+      let h (field': field_of fields): struct_carriers fields field' =
+        if field' = field then x else g field'
+      in on_dom _ h
+    in
+    list_fn_map lift_struct f
+
+/// Reading a pcm_struct_carrier field
+val struct_pcm_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields) (field: field_of fields)
+: (get_field fields field).carrier
+
+let struct_pcm_get x field = x field
+
+/// Writing a struct_pcm_carrier field
+val struct_pcm_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: struct_pcm_carrier tag fields
+
+let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
+
+/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
+
+val struct_pcm_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
+  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
+
+let struct_pcm_get_put x field v = ()
+
+val struct_pcm_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
+  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
+
+let struct_pcm_put_get x field =
+  assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
+
+val struct_pcm_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v w: (get_field fields field).carrier)
+: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
+  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
+
+let struct_pcm_put_put x field v w =
+  assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
+
+/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
+
+val struct_pcm_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (get_field fields field1).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
+  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
+
+let struct_pcm_get_put_ne x field1 field2 v = ()
+
+val struct_pcm_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (v: (get_field fields field1).carrier)
+  (field2: field_of fields)
+  (w: (get_field fields field2).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
+      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+let struct_pcm_put_put_ne x field1 v field2 w =
+   assert (
+     struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
+     struct_pcm_put (struct_pcm_put x field2 w) field1 v)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 5877d3775dd..7b57d50b3cc 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -1,5 +1,6 @@
 module Steel.C.StructLiteral
 
+open Steel.C.PCM
 open Steel.C.Typedef
 open Steel.C.Ref // for refine
 open FStar.List.Tot
@@ -16,9 +17,6 @@ let get_field (fields: struct_fields) (field: field_of fields): typedef =
   assoc_mem field fields;
   Some?.v (assoc field fields)
 
-let struct_view_types (fields: struct_fields) (field: field_of fields) =
-  (get_field fields field).view_type
-
 /// A view type for structs
 val struct (tag: string) (fields: struct_fields): Type0
 
@@ -107,3 +105,13 @@ val struct_put_put_ne
     (ensures
       struct_put (struct_put x field1 v) field2 w ==
       struct_put (struct_put x field2 w) field1 v)
+
+/// Typedef for struct from typedefs for its fields
+
+// let typedef_struct (tag: string) (fields: struct_fields): typedef = {
+//   carrier = Type0; 
+//   pcm: pcm carrier; 
+//   view_type: Type0; 
+//   can_view_unit: bool; 
+//   view: sel_view pcm view_type can_view_unit; 
+// }

From ad0dbb22b9006e6da06e1fd780cf94d461666782 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 14:16:36 -0700
Subject: [PATCH 145/513] Move declaration of struct pcm literal ops into fsti

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 87 +------------------
 .../arraystructs/Steel.C.StructLiteral.fsti   | 80 +++++++++++++++++
 2 files changed, 82 insertions(+), 85 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index baa428044c8..c4da42048e8 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -175,42 +175,24 @@ let rec struct_get_sound #tag #fields vs field : Lemma (ensures
       assume ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) (mk_struct tag ((field', td) :: fields)) (v, vs)) `struct_get` field == v)
     end else admit()//struct_get_sound #tag #fields vs field
 
-
-/// Similarly, a PCM for structs
-
 let struct_carriers (fields: struct_fields) (field: field_of fields) =
   (get_field fields field).carrier
 
-val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
 let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
 
 let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
 : pcm (struct_carriers fields field)
 = (get_field fields field).pcm
 
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
 let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
 
-(* BEGIN public *)
-let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
-
-let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
-  map struct_field_carrier fields
-
-let mk_struct_pcm_ty (tag: string) (fields: list (string * typedef)): Type =
-  mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
-(* END public *)
-
-/// A struct PCM carrier literal
-val mk_struct_pcm (tag: string) (fields: list (string * typedef)): mk_struct_pcm_ty tag fields
-
-let rec mk_struct_pcm_carrier (tag: string) (fields: list (string * typedef))
+let rec mk_struct_pcm (tag: string) (fields: list (string * typedef))
 : mk_struct_pcm_ty tag fields
 = match fields with
   | [] -> on_dom _ (fun field -> () <: struct_carriers fields field)
   | (field, td) :: fields' ->
     fun (x:td.carrier) ->
-    let f: map struct_field_carrier fields' `list_fn` struct_pcm_carrier tag fields' = mk_struct_pcm_carrier tag fields' in
+    let f: map struct_field_carrier fields' `list_fn` struct_pcm_carrier tag fields' = mk_struct_pcm tag fields' in
     let lift_struct (g: struct_pcm_carrier tag fields'): struct_pcm_carrier tag fields =
       let h (field': field_of fields): struct_carriers fields field' =
         if field' = field then x else g field'
@@ -218,85 +200,20 @@ let rec mk_struct_pcm_carrier (tag: string) (fields: list (string * typedef))
     in
     list_fn_map lift_struct f
 
-/// Reading a pcm_struct_carrier field
-val struct_pcm_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields) (field: field_of fields)
-: (get_field fields field).carrier
-
 let struct_pcm_get x field = x field
 
-/// Writing a struct_pcm_carrier field
-val struct_pcm_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).carrier)
-: struct_pcm_carrier tag fields
-
 let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
-/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
-
-val struct_pcm_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).carrier)
-: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
-  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
-
 let struct_pcm_get_put x field v = ()
 
-val struct_pcm_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
-  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
-
 let struct_pcm_put_get x field =
   assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
 
-val struct_pcm_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v w: (get_field fields field).carrier)
-: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
-  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
-
 let struct_pcm_put_put x field v w =
   assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
 
-/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
-
-val struct_pcm_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (get_field fields field1).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
-  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
-
 let struct_pcm_get_put_ne x field1 field2 v = ()
 
-val struct_pcm_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (v: (get_field fields field1).carrier)
-  (field2: field_of fields)
-  (w: (get_field fields field2).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
-      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
 let struct_pcm_put_put_ne x field1 v field2 w =
    assert (
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 7b57d50b3cc..042743c4d93 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -106,6 +106,86 @@ val struct_put_put_ne
       struct_put (struct_put x field1 v) field2 w ==
       struct_put (struct_put x field2 w) field1 v)
 
+/// Similarly, a PCM for structs
+val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+
+let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
+
+let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
+  map struct_field_carrier fields
+
+let mk_struct_pcm_ty (tag: string) (fields: list (string * typedef)): Type =
+  mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
+
+/// A struct PCM carrier literal
+val mk_struct_pcm (tag: string) (fields: list (string * typedef)): mk_struct_pcm_ty tag fields
+
+/// Reading a pcm_struct_carrier field
+val struct_pcm_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields) (field: field_of fields)
+: (get_field fields field).carrier
+
+/// Writing a struct_pcm_carrier field
+val struct_pcm_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: struct_pcm_carrier tag fields
+
+/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
+
+val struct_pcm_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
+  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
+
+val struct_pcm_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
+  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
+
+val struct_pcm_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v w: (get_field fields field).carrier)
+: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
+  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
+
+/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
+
+val struct_pcm_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (get_field fields field1).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
+  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
+  
+val struct_pcm_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (v: (get_field fields field1).carrier)
+  (field2: field_of fields)
+  (w: (get_field fields field2).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
+      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
 /// Typedef for struct from typedefs for its fields
 
 // let typedef_struct (tag: string) (fields: struct_fields): typedef = {

From 4b931ad8fd196591eeaf66928a5ee55398f0c15a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 27 Jul 2021 14:49:42 -0700
Subject: [PATCH 146/513] struct_view; typedef_struct

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 64 +++++++++++++++++++
 .../arraystructs/Steel.C.StructLiteral.fsti   | 17 +++--
 .../steel/arraystructs/Steel.C.Typedef.fst    |  3 +-
 3 files changed, 75 insertions(+), 9 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index c4da42048e8..6aafdf0ec13 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -218,3 +218,67 @@ let struct_pcm_put_put_ne x field1 v field2 w =
    assert (
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+let field_views (tag: string) (fields: struct_fields) (field: field_of fields)
+: sel_view (struct_pcms tag fields field) (struct_view_types fields field) false
+= (get_field fields field).view
+
+let struct_view_to_view_prop (tag: string) (fields: struct_fields)
+: struct_pcm_carrier tag fields -> prop
+= fun x -> forall (field:field_of fields). (field_views tag fields field).to_view_prop (x field)
+
+let struct_view_to_view (tag: string) (fields: struct_fields)
+: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields) ->
+  Tot (struct tag fields)
+= fun x -> on_dom _ (fun (field: field_of fields) -> (field_views tag fields field).to_view (x field))
+
+let struct_view_to_carrier (tag: string) (fields: struct_fields)
+: struct tag fields ->
+  Tot (refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields))
+= fun x ->
+  let y: struct_pcm_carrier tag fields =
+    on_dom _ (fun (field: field_of fields) ->
+      (field_views tag fields field).to_carrier (x field)
+      <: struct_carriers fields field)
+  in y
+
+let struct_view_to_view_frame (tag: string) (fields: struct_fields)
+  (x: struct tag fields)
+  (frame: struct_pcm_carrier tag fields)
+: Lemma
+    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame))
+    (ensures
+      struct_view_to_view_prop tag fields
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) /\ 
+      struct_view_to_view tag fields
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) == x)
+= let p = struct_pcms tag fields in
+  let aux (k:field_of fields)
+  : Lemma (
+      (field_views tag fields k).to_view_prop
+        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) /\
+      (field_views tag fields k).to_view
+        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) == x k)
+  = assert (composable (p k) ((field_views tag fields k).to_carrier (x k)) (frame k));
+    (field_views tag fields k).to_view_frame (x k) (frame k)
+  in FStar.Classical.forall_intro aux;
+  assert (
+    struct_view_to_view tag fields
+       (op (prod_pcm p) (struct_view_to_carrier tag fields x) frame) `feq` x)
+
+let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields{Cons? fields})
+: squash (
+    ~ (exists x. struct_view_to_carrier tag fields x == one (struct_pcm tag fields)) /\
+    ~ (struct_view_to_view_prop tag fields (one (struct_pcm tag fields))))
+= let (field, _) :: _ = fields in
+  let field: field_of fields = field in
+  (field_views tag fields field).to_carrier_not_one
+
+let struct_view tag fields = {
+  to_view_prop = struct_view_to_view_prop tag fields;
+  to_view = struct_view_to_view tag fields;
+  to_carrier = struct_view_to_carrier tag fields;
+  to_carrier_not_one = struct_view_to_carrier_not_one tag fields;
+  to_view_frame = struct_view_to_view_frame tag fields;
+}
+
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 042743c4d93..1ac7f6180c4 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -186,12 +186,15 @@ val struct_pcm_put_put_ne
       struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
       struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
+/// View a struct_pcm_carrier as a struct
+val struct_view (tag: string) (fields: struct_fields{Cons? fields})
+: sel_view (struct_pcm tag fields) (struct tag fields) false
+
 /// Typedef for struct from typedefs for its fields
 
-// let typedef_struct (tag: string) (fields: struct_fields): typedef = {
-//   carrier = Type0; 
-//   pcm: pcm carrier; 
-//   view_type: Type0; 
-//   can_view_unit: bool; 
-//   view: sel_view pcm view_type can_view_unit; 
-// }
+let typedef_struct (tag: string) (fields: struct_fields{Cons? fields}): typedef = {
+  carrier = struct_pcm_carrier tag fields; 
+  pcm = struct_pcm tag fields;
+  view_type = struct tag fields;
+  view = struct_view tag fields;
+}
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index bdec8415615..caa91ac99b2 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -9,8 +9,7 @@ noeq type typedef = {
   carrier: Type0; 
   pcm: pcm carrier; 
   view_type: Type0; 
-  can_view_unit: bool; 
-  view: sel_view pcm view_type can_view_unit; 
+  view: sel_view pcm view_type false;
 } 
 
 // assume val malloc: typedef -> ptr typedef.carrier typedef.pcm 

From 47fe4a25b2710b443c0894681a6ff06d15fbc592 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 28 Jul 2021 15:09:37 -0700
Subject: [PATCH 147/513] Experiments with PointStructSelectors

---
 examples/steel/arraystructs/PointStruct.fst   |   4 +-
 .../arraystructs/PointStructSelectors.fst     | 974 ++++++++++++++----
 .../arraystructs/Steel.C.StructLiteral.fst    |  25 +-
 .../arraystructs/Steel.C.StructLiteral.fsti   |  60 +-
 4 files changed, 814 insertions(+), 249 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 279e5ce5400..090607d1900 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -59,7 +59,7 @@ let addr_of_x #a #x #y p =
   A.return q
   
 let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point None y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
@@ -69,5 +69,5 @@ let addr_of_y #a #x #y p =
   A.return q
 
 let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x none) y; // same here
+  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x None) y; // same here
   A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 9114c10dc66..2a65674bbbd 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -5,291 +5,813 @@ open Steel.C.Opt
 open Steel.C.Connection
 open Steel.C.Struct
 open FStar.FunctionalExtensionality
+
+open Steel.Memory
 open Steel.Effect
-module A = Steel.Effect.Atomic
+open Steel.Effect.Atomic
 
+open Steel.C.Ref
 open Steel.C.Typedef
 open Steel.C.StructLiteral
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+(** ** BEGIN TODO impl and move to StructLiteral *)
+
+(*
+[@@__reduce__]
+let rec iter_star_fields (fields: struct_fields) (f: field_of fields -> vprop): vprop =
+  match fields with
+  | [(field, _)] -> f field
+  | (field, _) :: fields -> f field `star` iter_star_fields fields f
+*)
+
+[@@__steel_reduce__]
+let pts_to_field_vprop
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (field: field_of fields)
+: vprop
+= ref_focus p (struct_field tag fields field) `pts_to_view` struct_views fields field
+
+[@@__reduce__;__steel_reduce__;iter_unfold]
+let rec pts_to_fields_vprop
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (fields': struct_fields)
+: vprop
+= match fields' with
+  | [(field, _)] -> if has_field_bool fields field then pts_to_field_vprop tag fields p field else emp
+  | (field, _) :: fields' ->
+    if has_field_bool fields field then begin
+      pts_to_field_vprop tag fields p field `star`
+      pts_to_fields_vprop tag fields p fields'
+    end else emp
+
+[@@iter_unfold]
+let rec pts_to_fields
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (h: rmem (p `pts_to_view` struct_view tag fields))
+  (h': rmem (pts_to_fields_vprop tag fields p fields))
+  //(prefix: list (string * typedef))
+  (fields': struct_fields)
+  //(hfields': squash (fields == rev prefix `append` fields'))
+: prop
+= match fields' with
+  | [(field, _)] ->
+    if has_field_bool fields field then
+      can_be_split 
+        (pts_to_fields_vprop tag fields p fields)
+        (pts_to_field_vprop tag fields p field) /\
+      h' (pts_to_field_vprop tag fields p field) ===
+      h (p `pts_to_view` struct_view tag fields) `struct_get` field
+    else True
+  | (field, _) :: fields' ->
+    if has_field_bool fields field then
+      can_be_split 
+        (pts_to_fields_vprop tag fields p fields)
+        (pts_to_field_vprop tag fields p field) /\
+      h' (pts_to_field_vprop tag fields p field) ===
+      h (p `pts_to_view` struct_view tag fields) `struct_get` field /\
+      pts_to_fields tag fields p h h' fields'
+    else True
+
+(*
+[@@__reduce__;iter_unfold]
+let rec iter_and_fields (fields: struct_fields) (f: field_of fields -> prop): prop =
+  match fields with
+  | [(field, _)] -> f field
+  | (field, _) :: fields -> f field /\ iter_and_fields fields f
+*)
+
+(*
+[@@__steel_reduce__;iter_unfold]
+let pts_to_field
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (h: rmem (p `pts_to_view` struct_view tag fields))
+  (h': rmem (iter_star_fields fields (pts_to_field_vprop tag fields p)))
+  (field: field_of fields)
+: prop
+= can_be_split 
+    (iter_star_fields fields (pts_to_field_vprop tag fields p))
+    (pts_to_field_vprop tag fields p field) /\
+  h' (pts_to_field_vprop tag fields p field) ==
+  h (p `pts_to_view` struct_view tag fields) `struct_get` field
+  *)
+
+assume val explode (#opened: inames)
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view tag fields)
+    (fun _ -> pts_to_fields_vprop tag fields p fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (pts_to_fields tag fields p h h' fields))
+//(iter_and_fields fields (pts_to_field tag fields p h h')))
+        
+// norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+
+(*
+assume val recombine (#opened: inames)
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+: SteelGhost unit opened
+    (iter_star_fields fields (pts_to_field_vprop tag fields p))
+    (fun _ -> p `pts_to_view` struct_view tag fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' -> pts_to_fields tag fields p h' h fields)
+    *)
+    
+(** ** END TODO impl and move to StructLiteral *)
+
+/// Point struct
+
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
   view_type = int;
-  can_view_unit = false;
   view = opt_view int;
 }
 
-let point_fields = [
+[@@__reduce__;iter_unfold]
+let point_fields: struct_fields = [
   "x", c_int;
   "y", c_int;
 ]
 
-(* TODO move to Steel.C.Typedef *)
-let struct_field_view_types fields = restricted_t (field_of fields) (type_family_of fields)
-
-let struct_field_pcm_carriers (fields: _) (field: field_of fields) =
-  (get_field fields field).carrier
+let point = struct "point" point_fields
 
-let struct_field_pcms (fields: _) (field: field_of fields)
-: pcm (struct_field_pcm_carriers fields field)
-= (get_field fields field).pcm
+let point_pcm_carrier = struct_pcm_carrier "point" point_fields
+let point_pcm: pcm point_pcm_carrier = struct_pcm "point" point_fields
 
-let struct_pcm_carrier (fields: list (string * typedef)) =
-  restricted_t (field_of fields) (struct_field_pcm_carriers fields)
-  
-let struct_pcm (fields: list (string * typedef))
-: pcm (struct_pcm_carrier fields)
-= prod_pcm (struct_field_pcms fields)
+/// (mk_point x y) represents (struct point){.x = x, .y = y}
+/// (mk_point_pcm x y) same, but where x and y are PCM carrier values
 
-let point = struct_pcm_carrier point_fields
+let mk_point: int -> int -> point = mk_struct "point" point_fields
+let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm "point" point_fields
 
+/// Connections for the fields of a point
 
-/// PCM for struct point:
+val _x: connection point_pcm (opt_pcm #int)
+let _x = struct_field "point" point_fields "x"
 
-val point_pcm : pcm point
+val _y: connection point_pcm (opt_pcm #int)
+let _y = struct_field "point" point_fields "y"
 
-/// (mk_point x y) represents (struct point){.x = x, .y = y}
+/// View for points
 
-val mk_point (x y: Ghost.erased (option int)): Ghost.erased point
+val point_view: sel_view point_pcm point false
+let point_view = struct_view "point" point_fields
 
-/// Connections for the fields of a point
+/// Explode and recombine
 
-val _x : connection point_pcm (opt_pcm #int)
-val _y : connection point_pcm (opt_pcm #int)
-
-/// Taking pointers to the x and y fields of a point
-
-val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
-: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _x})
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point none y) `star`
-       (q `pts_to` x))
-
-unfold
-let point_fields_pcm_carriers = struct_field_pcm_carriers point_fields
-
-unfold
-let point_fields_pcms
-: field:field_of point_fields -> pcm (point_fields_pcm_carriers field)
-= struct_field_pcms point_fields
-
-unfold
-let point_pcm_carrier = struct_pcm_carrier point_fields
-
-unfold
-let point_pcm: pcm point_pcm_carrier = struct_pcm point_fields
-
-let mk_point_f_lame (x y: option int) (field: field_of point_fields)
-: point_fields_pcm_carriers field
-= match field with
-  | "x" -> x
-  | "y" -> y
-
-(* BEGIN TODO move to Typedef *)
-
-let rec list_fn (dom: list Type) (cod: Type) =
-  match dom with
-  | [] -> cod
-  | d :: dom -> d -> list_fn dom cod
-
-let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b =
-  match dom with 
-  | [] -> f g <: [] `list_fn` 'b
-  | d :: dom' ->
-    let g: d -> dom' `list_fn` 'a = g in
-    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
-
-let field_pcm_carrier ((_, td): string * typedef) = td.carrier
-
-let mk_struct_ty (fields: list (string * typedef)): Type =
-  map field_pcm_carrier fields `list_fn` struct_pcm_carrier fields
-
-let rec mk_struct (fields: list (string * typedef))
-: mk_struct_ty fields
-= match fields with
-  | [] -> on_dom _ (fun field -> () <: struct_field_pcm_carriers fields field)
-  | (field, td) :: fields' ->
-    fun (x:td.carrier) ->
-    let f: map field_pcm_carrier fields' `list_fn` struct_pcm_carrier fields' = mk_struct fields' in
-    let lift_struct (g: struct_pcm_carrier fields'): struct_pcm_carrier fields =
-      let h (field': field_of fields): struct_field_pcm_carriers fields field' =
-        if field' = field then x else g field'
-      in on_dom _ h
-    in
-    list_fn_map lift_struct f
-    
-(* END move to Typedef *)
+(*
+val explode' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "point" point_fields)
+    (fun _ -> iter_star_fields point_fields (pts_to_field_vprop "point" point_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      normalize
+        (iter_and_fields point_fields (pts_to_field "point" point_fields p h h')))
 
-let mk_point_f
-: option int -> option int -> struct_pcm_carrier point_fields
-= mk_struct point_fields
+let explode' p = explode "point" point_fields p
+*)
 
-let _ =
-  let test (k: field_of point_fields) (x y: option int) =
-    assert (mk_point_f_lame x y k == mk_point_f x y k)
-  in ()
+(*
+val explode'' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` point_view)
+    (fun _ ->
+      (ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      h' (ref_focus p _x `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "x" /\
+      h' (ref_focus p _y `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "y")
 
-let mk_point (x y: Ghost.erased (option int)): Ghost.erased point =
-  Ghost.hide (on_dom _ (mk_point_f_lame (Ghost.reveal x) (Ghost.reveal y)))
+let explode'' p = explode "point" point_fields p
+*)
 
-let _x = struct_field point_fields_pcms "x"
-let _y = struct_field point_fields_pcms "y"
+(*
+val recombine' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _x `pts_to_view` c_int.view) `star`
+     (ref_focus p _y `pts_to_view` c_int.view))
+    (fun _ -> p `pts_to_view` point_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      h (ref_focus p _x `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "x" /\
+      h (ref_focus p _y `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "y")
 
-/// Taking pointers to the x and y fields of a point
+let recombine' p = recombine "point" point_fields p
+*)
 
-let point_without_x x y
-: Lemma (struct_without_field point_fields_pcms "x" (mk_point x y) `feq` Ghost.reveal (mk_point none y))
-  [SMTPat (mk_point x y)]
+let aux p (h: rmem (p `pts_to_view` point_view))
+  (h': rmem
+     ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)))
+: Lemma
+   (requires
+      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      (pts_to_fields "point" point_fields p h h' point_fields))
+   (ensures begin
+      let pointprop =
+      ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+      in
+      can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` "x" /\
+      can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` "y"
+   end)
 = ()
 
-let point_with_x x y
-: Lemma (struct_with_field point_fields_pcms "x" (Ghost.reveal x) (mk_point none y) `feq`
-         Ghost.reveal (mk_point x y))
-  [SMTPat (mk_point x y)]
-= ()
+/// Now, a contrived struct with twice as many fields (to stress-test)
 
-let point_without_y x y
-: Lemma (struct_without_field point_fields_pcms "y" (mk_point x y) `feq` Ghost.reveal (mk_point x none))
-  [SMTPat (mk_point x y)]
-= ()
+[@@__reduce__;iter_unfold]
+let quad_fields: struct_fields = [
+  "x", c_int;
+  "y", c_int;
+  "z", c_int;
+  "w", c_int;
+]
+let quad = struct "quad" quad_fields
 
-let point_with_y x y
-: Lemma (struct_with_field point_fields_pcms "y" (Ghost.reveal y) (mk_point x none) `feq`
-         Ghost.reveal (mk_point x y))
-  [SMTPat (mk_point x y)]
-= ()
+let quad_pcm_carrier = struct_pcm_carrier "quad" quad_fields
+let quad_pcm: pcm quad_pcm_carrier = struct_pcm "quad" quad_fields
 
-#restart-solver
+/// (mk_quad x y) represents (struct quad){.x = x, .y = y}
+/// (mk_quad_pcm x y) same, but where x and y are PCM carrier values
 
-let feq' (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
-= 'a == 'c /\
-  normalize ('b == 'd) /\
-  f `feq` g
+let mk_quad: int -> int -> int -> int -> quad = mk_struct "quad" quad_fields
+let mk_quad_pcm: option int -> option int -> option int -> option int -> quad_pcm_carrier = mk_struct_pcm "quad" quad_fields
 
-let ext (f: restricted_t 'a 'b) (g: restricted_t 'c 'd)
-: Lemma (requires f `feq'` g) (ensures f == g) //[SMTPat (f `feq'` g)]
-= extensionality 'a 'b f g
-  //FStar.Classical.forall_intro fg
+/// Connections for the fields of a quad
 
-//let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-//  extensionality 'a 'b f g;
-//  FStar.Classical.forall_intro fg
+[@@iter_unfold] let _quad_x: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "x"
+[@@iter_unfold] let _quad_y: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "y"
+[@@iter_unfold] let _quad_z: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "z"
+[@@iter_unfold] let _quad_w: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "w"
 
-// let feq' (f g: restricted_t 'a 'b): prop = forall x. f x == g x
+/// View for quads
 
-// let ext' (f g: restricted_t 'a 'b)
-// : Lemma (requires f `feq'` g) (ensures f == g) [SMTPat (f `feq'` g)]
-// = extensionality 'a 'b f g
-//   //FStar.Classical.forall_intro fg
+[@@iter_unfold] let quad_view: sel_view quad_pcm quad false = struct_view "quad" quad_fields
 
-let aux x y : unit
-= assert (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) `feq` mk_point none y);
-  ()
+/// Explode and recombine
 
+(*
+val explode_quad' (#opened: inames)
+  (p: ref 'a quad_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "quad" quad_fields)
+    (fun _ -> iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (iter_and_fields quad_fields (pts_to_field "quad" quad_fields p h h')))
 
-let addr_of_x #a #x #y p =
-  let q = addr_of_struct_field p "x" (mk_point x y) in
-  //A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y)))) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
-  //A.change_equal_slprop (p `pts_to` _) (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (Ghost.reveal (mk_point x y))));
-  //assume (Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y)) == mk_point none y);
-  //(field_of fields) (struct_field_pcm_carriers fields)
-  assert (
-    struct_without_field point_fields_pcms "x" (mk_point x y)
-    `feq'`
-    Ghost.reveal (mk_point none y));
-  A.change_equal_slprop (p `pts_to` Ghost.hide (struct_without_field point_fields_pcms "x" (mk_point x y))) (p `pts_to` mk_point none y);
-  //A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  A.sladmit();
-  A.return q
-
-// (f `feq` Ghost.reveal g)
-// (Ghost.hide f == g)
+let explode_quad' p = explode "quad" quad_fields p
+*)
 
 (*
+val explode_quad'' (#opened: inames)
+  (p: ref 'a quad_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` quad_view)
+    (fun _ ->
+      (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view))))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_x `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "x" /\
+      can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_y `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "y" /\
+      can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_z `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "z" /\
+      can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_w `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "w")
+*)
+
+#push-options "--z3rlimit 30 --query_stats"
+
+#pop-options
+#push-options "--fuel 2 --query_stats"
+
+[@@iter_unfold] let x: field_of quad_fields = mk_field_of quad_fields "x"
+[@@iter_unfold] let y: field_of quad_fields = mk_field_of quad_fields "y"
+[@@iter_unfold] let z: field_of quad_fields = mk_field_of quad_fields "z"
+[@@iter_unfold] let w: field_of quad_fields = mk_field_of quad_fields "w"
+
+module T = FStar.Tactics
+
+let norm_list = [
+  delta_attr [`%iter_unfold];
+  delta_only [
+    `%map; `%mem; `%fst; `%Mktuple2?._1;
+    `%assoc;
+    `%Some?.v
+  ];
+  iota; primops; zeta
+]
 
-struct : string -> list string -> list (string & typedef) -> Type
+let quad_aux (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
+  (h': rmem
+     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
+: squash
+   ((
+      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (pts_to_fields "quad" quad_fields p h h' quad_fields))
+   ==
+   (begin
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
+      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
+       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
+         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
+         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
+          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
+   end))
+= _ by (T.trefl ())
+//_ by (
+//    T.norm norm_list;
+//    T.trefl ())
 
-without_field
-  (field: string)
-  (x: struct s excluded fields) ->
-  struct s excluded
+(*
+let quad_unfold_iter_star_fields p
+: Lemma
+    (norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p)) ==
+     (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view))))
+= ()
 *)
-let addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
+
+#push-options "--query_stats"
+
+let explode_quad'' p =
+  explode "quad" quad_fields p;
+  //quad_unfold_iter_star_fields p;
+  //change_equal_slprop
+  //  (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
+  //  ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+  //   ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+  //    ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+  //     (ref_focus p _quad_w `pts_to_view` c_int.view))));
+  ()
+
+(*
+val recombine_quad' (#opened: inames)
+  (p: ref 'a quad_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+       (ref_focus p _quad_w `pts_to_view` c_int.view))))
+    (fun _ -> p `pts_to_view` quad_view)
     (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-
-let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "x" q p (mk_point none y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_y #a #x #y p =
-  let q = addr_of_struct_field p "y" (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x none);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
-  A.return q
-
-let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcms "y" q p (mk_point x none) y; // same here
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let struct_point_fields = [
+    (ensures fun h _ h' ->
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      // assert (can_be_split' quadprop (ref_focus p _quad_x `pts_to_view` c_int.view));
+      // assert (can_be_split' quadprop (ref_focus p _quad_y `pts_to_view` c_int.view));
+      // assert (can_be_split' quadprop (ref_focus p _quad_z `pts_to_view` c_int.view));
+      // assert (can_be_split' quadprop (ref_focus p _quad_w `pts_to_view` c_int.view));
+      h (ref_focus p _quad_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "x" /\
+      h (ref_focus p _quad_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "y" /\
+      h (ref_focus p _quad_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "z" /\
+      h (ref_focus p _quad_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "w")
+
+let recombine_quad' p =
+  quad_unfold_iter_star_fields p;
+  change_equal_slprop
+    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+       (ref_focus p _quad_w `pts_to_view` c_int.view))))
+    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p));
+  recombine "quad" quad_fields p
+*)
+
+/// 5 fields!
+
+[@@__reduce__;iter_unfold]
+let quint_fields: struct_fields = [
   "x", c_int;
   "y", c_int;
+  "z", c_int;
+  "w", c_int;
+  "v", c_int;
 ]
+let quint = struct "quint" quint_fields
+
+let quint_pcm_carrier = struct_pcm_carrier "quint" quint_fields
+let quint_pcm: pcm quint_pcm_carrier = struct_pcm "quint" quint_fields
+
+let mk_quint: int -> int -> int -> int -> int -> quint = mk_struct "quint" quint_fields
+let mk_quint_pcm: option int -> option int -> option int -> option int -> option int -> quint_pcm_carrier = mk_struct_pcm "quint" quint_fields
+
+/// Connections for the fields of a quint
 
-let point_field_of_string (field: field_of struct_point_fields): point_field =
-  match field with
-  | "x" -> X
-  | "y" -> Y
+let _quint_x: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "x"
+let _quint_y: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "y"
+let _quint_z: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "z"
+let _quint_w: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "w"
+let _quint_v: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "v"
 
-let struct_point_view_t (k: field_of struct_point_fields): Type =
-  (get_field struct_point_fields k).view_type
+/// View for quints
 
-let struct_point_view_pcm_t (k: field_of struct_point_fields): Type =
-  point_fields (point_field_of_string k)
-  
-let struct_point_view_pcm (k: field_of struct_point_fields)
-: pcm (struct_point_view_pcm_t k)
-= point_fields_pcms (point_field_of_string k)
+let quint_view: sel_view quint_pcm quint false = struct_view "quint" quint_fields
 
-let struct_point_fields_view (k:field_of struct_point_fields)
-: sel_view (point_fields_pcms (point_field_of_string k)) (struct_point_view_t k) false
-= (get_field struct_point_fields k).view
+/// Explode and recombine
 
 (*
-let struct_view
-  (#a:eqtype) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
-  (#view_t:a -> Type)
-  (#can_view_units: bool)
-  (field_view:(k:a -> sel_view (p k) (view_t k) can_view_units))
-  (included: list a)
-: sel_view (prod_pcm p)
-    (restricted_t (refine a (mem included)) view_t)
-    (can_view_units || Nil? included) *)
-
-let point_view
-//: sel_view (prod_pcm struct_point_view_pcm_t) (view_type_of struct_point_fields) false
-= struct_view struct_point_fields_view (map (admit() )struct_point_fields)
-
-// = {
-//   to_view_prop = (fun x -> Some? x == true);
-//   to_view = (fun x -> Some?.v x);
-//   to_carrier = (fun z  -> Some z);
-//   to_carrier_not_one = ();
-//   to_view_frame = (fun x frame -> ());
-// }
+val explode_quint' (#opened: inames)
+  (p: ref 'a quint_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "quint" quint_fields)
+    (fun _ -> iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' -> iter_and_fields quint_fields (pts_to_field "quint" quint_fields p h h'))
+
+let explode_quint' p = explode "quint" quint_fields p
+*)
+
+#restart-solver
+
+val explode_quint'' (#opened: inames)
+  (p: ref 'a quint_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` quint_view)
+    (fun _ ->
+      (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quintprop =
+        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+           (ref_focus p _quint_v `pts_to_view` c_int.view))))
+      in
+      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
+      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
+      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
+      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
+      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v")
+
+let aux p (h: rmem (p `pts_to_view` quint_view))
+  (h': rmem
+     ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+         (ref_focus p _quint_v `pts_to_view` c_int.view))))))
+: Lemma
+   (requires
+      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      (pts_to_fields "quint" quint_fields p h h' quint_fields))
+   (ensures begin
+      let quintprop =
+        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+           (ref_focus p _quint_v `pts_to_view` c_int.view))))
+      in
+      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
+      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
+      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
+      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
+      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v"
+   end)
+= admit()
+
+(*
+let quint_unfold_iter_star_fields p
+: Lemma
+    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p) ==
+     (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+= ()
+*)
+
+#restart-solver
+
+//#push-options "--z3rlimit 30"
+
+let explode_quint'' p =
+  explode "quint" quint_fields p;
+  //quint_unfold_iter_star_fields p;
+  //change_equal_slprop
+  //  (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
+  //  ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+  //   ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+  //    ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+  //     ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+  //      (ref_focus p _quint_v `pts_to_view` c_int.view)))));
+  ()
+
+//#pop-options
+
+val recombine_quint' (#opened: inames)
+  (p: ref 'a quint_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+    (fun _ -> p `pts_to_view` quint_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quintprop =
+        ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+          ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+           ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+            (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+      in
+      assert (can_be_split' quintprop (ref_focus p _quint_x `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_y `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_z `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_w `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_v `pts_to_view` c_int.view));
+      h (ref_focus p _quint_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "x" /\
+      h (ref_focus p _quint_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "y" /\
+      h (ref_focus p _quint_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "z" /\
+      h (ref_focus p _quint_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "w" /\
+      h (ref_focus p _quint_v `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "v")
+
+#push-options "--z3rlimit 20"
+
+let recombine_quint' p =
+  quint_unfold_iter_star_fields p;
+  change_equal_slprop
+    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p));
+  recombine "quint" quint_fields p
+
+#pop-options
+
+/// 8 fields:
+
+let oct_fields: struct_fields = [
+  "x", c_int;
+  "y", c_int;
+  "z", c_int;
+  "w", c_int;
+  "v", c_int;
+  "u", c_int;
+  "t", c_int;
+  "s", c_int;
+]
+let oct = struct "oct" oct_fields
+
+let oct_pcm_carrier = struct_pcm_carrier "oct" oct_fields
+let oct_pcm: pcm oct_pcm_carrier = struct_pcm "oct" oct_fields
+
+let mk_oct: int -> int -> int -> int -> int -> int -> int -> int -> oct = mk_struct "oct" oct_fields
+let mk_oct_pcm: option int -> option int -> option int -> option int -> option int -> option int -> option int -> option int -> oct_pcm_carrier = mk_struct_pcm "oct" oct_fields
+
+/// Connections for the fields of a oct
+
+let _oct_x: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "x"
+let _oct_y: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "y"
+let _oct_z: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "z"
+let _oct_w: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "w"
+let _oct_v: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "v"
+let _oct_u: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "u"
+let _oct_t: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "t"
+let _oct_s: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "s"
+
+/// View for octs
+
+let oct_view: sel_view oct_pcm oct false = struct_view "oct" oct_fields
+
+/// Explode and recombine
+
+val explode_oct' (#opened: inames)
+  (p: ref 'a oct_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "oct" oct_fields)
+    (fun _ -> iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' -> iter_and_fields oct_fields (pts_to_field "oct" oct_fields p h h'))
+
+let explode_oct' p = explode "oct" oct_fields p
+
+val explode_oct'' (#opened: inames)
+  (p: ref 'a oct_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` oct_view)
+    (fun _ ->
+      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+            ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+             (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      True)
+      // let octprop =
+      //   ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+      //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+      //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+      //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+      //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+      //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+      //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
+      // in
+      // assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
+      // h' (ref_focus p _oct_x `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "x" /\
+      // h' (ref_focus p _oct_y `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "y" /\
+      // h' (ref_focus p _oct_z `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "z" /\
+      // h' (ref_focus p _oct_w `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "w" /\
+      // h' (ref_focus p _oct_v `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "v" /\
+      // h' (ref_focus p _oct_u `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "u" /\
+      // h' (ref_focus p _oct_t `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "t" /\
+      // h' (ref_focus p _oct_s `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "s")
+
+let oct_unfold_iter_star_fields p
+: Lemma
+    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
+     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
+= assert_norm (
+    iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
+     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
+
+#restart-solver
+#push-options "--z3rlimit 40 --query_stats"
+
+let explode_oct'' p =
+  explode "oct" oct_fields p;
+  // OOMs
+  //change_slprop_rel
+  //  (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
+  //  ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+  //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+  //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+  //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+  //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+  //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+  //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+  //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
+  //  (fun _ _ -> True)
+  //  (fun m ->
+  //    assert_norm
+  //      (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
+  //      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+  //        ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+  //         ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+  //          ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+  //           ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+  //            ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+  //             ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+  //              (ref_focus p _oct_s `pts_to_view` c_int.view))))))))));
+  oct_unfold_iter_star_fields p;
+  change_equal_slprop
+    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
+    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view))))))));
+  ()
+
+#pop-options
+
+val recombine_oct' (#opened: inames)
+  (p: ref 'a oct_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+        (ref_focus p _oct_v `pts_to_view` c_int.view)))))
+    (fun _ -> p `pts_to_view` oct_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let octprop =
+        ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_v `pts_to_view` c_int.view)))))
+      in
+      assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
+      h (ref_focus p _oct_x `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "x" /\
+      h (ref_focus p _oct_y `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "y" /\
+      h (ref_focus p _oct_z `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "z" /\
+      h (ref_focus p _oct_w `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "w" /\
+      h (ref_focus p _oct_v `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "v" /\
+      h (ref_focus p _oct_u `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "u" /\
+      h (ref_focus p _oct_t `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "t" /\
+      h (ref_focus p _oct_s `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "s")
+
+#restart-solver
+#push-options "--z3rlimit 20"
+
+let recombine_oct' p =
+  oct_unfold_iter_star_fields p;
+  change_equal_slprop
+    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
+    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p));
+  recombine "oct" oct_fields p
+
+#pop-options
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 6aafdf0ec13..b83ee8e7dea 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -1,9 +1,14 @@
 module Steel.C.StructLiteral
 
+open Steel.Memory
+open Steel.Effect.Common
+open Steel.Effect.Atomic
+
 open Steel.C.PCM
 open Steel.C.Struct
 open Steel.C.Typedef
 open Steel.C.Ref // for refine
+open Steel.C.Connection
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
@@ -12,10 +17,10 @@ let struct_view_types (fields: struct_fields) (field: field_of fields) =
 
 let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
 
-let rec mk_struct (tag: string) (fields: list (string * typedef))
+let rec mk_struct (tag: string) (fields: struct_fields)
 : mk_struct_ty tag fields
 = match fields with
-  | [] -> on_dom _ (fun field -> () <: struct_view_types fields field)
+  | [(field, td)] -> fun (x:td.view_type) -> on_dom _ (fun field -> x <: struct_view_types fields field)
   | (field, td) :: fields' ->
     fun (x:td.view_type) ->
     let f: map struct_field_view_type fields' `list_fn` struct tag fields' = mk_struct tag fields' in
@@ -157,6 +162,7 @@ val struct_get_sound
     (mk_struct tag fields `list_apply` vs) `struct_get` field ==
     struct_get_model vs field)
 
+(*
 let rec struct_get_sound #tag #fields vs field : Lemma (ensures
     (mk_struct tag fields `list_apply` vs) `struct_get` field ==
     struct_get_model vs field) (decreases fields) = match fields with
@@ -174,22 +180,16 @@ let rec struct_get_sound #tag #fields vs field : Lemma (ensures
         end);
       assume ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) (mk_struct tag ((field', td) :: fields)) (v, vs)) `struct_get` field == v)
     end else admit()//struct_get_sound #tag #fields vs field
-
-let struct_carriers (fields: struct_fields) (field: field_of fields) =
-  (get_field fields field).carrier
+    *)
 
 let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
 
-let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
-: pcm (struct_carriers fields field)
-= (get_field fields field).pcm
-
 let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
 
-let rec mk_struct_pcm (tag: string) (fields: list (string * typedef))
+let rec mk_struct_pcm (tag: string) (fields: struct_fields)
 : mk_struct_pcm_ty tag fields
 = match fields with
-  | [] -> on_dom _ (fun field -> () <: struct_carriers fields field)
+  | [(field, td)] -> fun (x:td.carrier) -> on_dom _ (fun field -> x <: struct_carriers fields field)
   | (field, td) :: fields' ->
     fun (x:td.carrier) ->
     let f: map struct_field_carrier fields' `list_fn` struct_pcm_carrier tag fields' = mk_struct_pcm tag fields' in
@@ -266,7 +266,7 @@ let struct_view_to_view_frame (tag: string) (fields: struct_fields)
     struct_view_to_view tag fields
        (op (prod_pcm p) (struct_view_to_carrier tag fields x) frame) `feq` x)
 
-let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields{Cons? fields})
+let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields)
 : squash (
     ~ (exists x. struct_view_to_carrier tag fields x == one (struct_pcm tag fields)) /\
     ~ (struct_view_to_view_prop tag fields (one (struct_pcm tag fields))))
@@ -282,3 +282,4 @@ let struct_view tag fields = {
   to_view_frame = struct_view_to_view_frame tag fields;
 }
 
+let struct_field tag fields field = struct_field (struct_pcms tag fields) field
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 1ac7f6180c4..dce1261a52d 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -1,23 +1,48 @@
 module Steel.C.StructLiteral
 
+open Steel.Memory
+open Steel.Effect.Common
+open Steel.Effect.Atomic
+
 open Steel.C.PCM
 open Steel.C.Typedef
 open Steel.C.Ref // for refine
+open Steel.C.Connection
 open FStar.List.Tot
 
-let struct_fields = list (string * typedef)
+let struct_fields =
+  struct_fields:list (string * typedef){Cons? struct_fields}
+
+let has_field_bool (fields: struct_fields) (field: string): bool =
+  field `mem` map fst fields
 
+irreducible let iter_unfold = 0
+
+[@@iter_unfold]
 let has_field (fields: struct_fields) (field: string): prop =
-  field `mem` map fst fields == true
-  
+  has_field_bool fields field == true
+
 let field_of (fields: struct_fields) =
   refine string (has_field fields)
 
+[@@iter_unfold]
+let mk_field_of (fields: struct_fields) (field: string)
+: Pure (field_of fields)
+    (requires normalize_term (has_field_bool fields field) == true)
+    (ensures fun field' -> field' == field)
+= field
+
+[@@iter_unfold]
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
   assoc_mem field fields;
   Some?.v (assoc field fields)
 
 /// A view type for structs
+
+[@@iter_unfold]
+let struct_views (fields: struct_fields) (field: field_of fields) =
+  (get_field fields field).view
+
 val struct (tag: string) (fields: struct_fields): Type0
 
 let rec list_fn (dom: list Type) (cod: Type) = match dom with
@@ -35,11 +60,11 @@ let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
 let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
   map struct_field_view_type fields
 
-let mk_struct_ty (tag: string) (fields: list (string * typedef)): Type =
+let mk_struct_ty (tag: string) (fields: struct_fields): Type =
   mk_struct_ty_dom tag fields `list_fn` struct tag fields
 
 /// A struct literal
-val mk_struct (tag: string) (fields: list (string * typedef)): mk_struct_ty tag fields
+val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
 
 /// Reading a struct field
 val struct_get
@@ -107,6 +132,14 @@ val struct_put_put_ne
       struct_put (struct_put x field2 w) field1 v)
 
 /// Similarly, a PCM for structs
+
+let struct_carriers (fields: struct_fields) (field: field_of fields) =
+  (get_field fields field).carrier
+
+let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
+: pcm (struct_carriers fields field)
+= (get_field fields field).pcm
+
 val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
 val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
 
@@ -115,11 +148,11 @@ let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
 let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
   map struct_field_carrier fields
 
-let mk_struct_pcm_ty (tag: string) (fields: list (string * typedef)): Type =
+let mk_struct_pcm_ty (tag: string) (fields: struct_fields): Type =
   mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
 
 /// A struct PCM carrier literal
-val mk_struct_pcm (tag: string) (fields: list (string * typedef)): mk_struct_pcm_ty tag fields
+val mk_struct_pcm (tag: string) (fields: struct_fields): mk_struct_pcm_ty tag fields
 
 /// Reading a pcm_struct_carrier field
 val struct_pcm_get
@@ -187,14 +220,23 @@ val struct_pcm_put_put_ne
       struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
 /// View a struct_pcm_carrier as a struct
-val struct_view (tag: string) (fields: struct_fields{Cons? fields})
+val struct_view (tag: string) (fields: struct_fields)
 : sel_view (struct_pcm tag fields) (struct tag fields) false
 
 /// Typedef for struct from typedefs for its fields
 
-let typedef_struct (tag: string) (fields: struct_fields{Cons? fields}): typedef = {
+let typedef_struct (tag: string) (fields: struct_fields): typedef = {
   carrier = struct_pcm_carrier tag fields; 
   pcm = struct_pcm tag fields;
   view_type = struct tag fields;
   view = struct_view tag fields;
 }
+
+/// Connections for fields of structs
+
+val struct_field
+  (tag: string) (fields: struct_fields) (field: field_of fields)
+: connection (struct_pcm tag fields) (struct_pcms tag fields field)
+
+/// Explode and recombine
+

From a126ff277177f9611915b7c5e52aa42cf242c0b0 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 29 Jul 2021 08:10:55 -0700
Subject: [PATCH 148/513] Try to solve quad_aux by SMT

---
 .../arraystructs/PointStructSelectors.fst     | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 2a65674bbbd..c5e7b2d7f77 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -359,10 +359,40 @@ let quad_aux (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
           h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
    end))
 = _ by (T.trefl ())
+// assert_norm produces a stack overflow?
 //_ by (
 //    T.norm norm_list;
 //    T.trefl ())
 
+let quad_aux2 (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
+  (h': rmem
+     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
+: squash
+   ((
+      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (pts_to_fields "quad" quad_fields p h h' quad_fields))
+   <==>
+   norm norm_list (begin
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
+      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
+       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
+         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
+         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
+          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
+   end))
+= () // _ by (T.trefl ())
+
 (*
 let quad_unfold_iter_star_fields p
 : Lemma

From 58d95fd5e83b4799338cb946853842d0248818d2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 29 Jul 2021 13:46:10 -0700
Subject: [PATCH 149/513] Try some more things

---
 .../arraystructs/PointStructSelectors.fst     | 203 +++++++++++++++++-
 .../arraystructs/Steel.C.StructLiteral.fsti   |  35 ++-
 2 files changed, 231 insertions(+), 7 deletions(-)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index c5e7b2d7f77..07a01112bbc 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -16,6 +16,7 @@ open Steel.C.StructLiteral
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+(*
 (** ** BEGIN TODO impl and move to StructLiteral *)
 
 (*
@@ -26,7 +27,7 @@ let rec iter_star_fields (fields: struct_fields) (f: field_of fields -> vprop):
   | (field, _) :: fields -> f field `star` iter_star_fields fields f
 *)
 
-[@@__steel_reduce__]
+[@@__reduce__;__steel_reduce__;iter_unfold]
 let pts_to_field_vprop
   (tag: string) (fields: struct_fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -101,6 +102,18 @@ let pts_to_field
   h (p `pts_to_view` struct_view tag fields) `struct_get` field
   *)
 
+unfold let norm_list = [
+  delta_attr [`%iter_unfold];
+  delta_only [
+    `%map; `%mem; `%fst; `%Mktuple2?._1;
+    `%assoc;
+    `%Some?.v;
+    `%Mktypedef?.view_type
+  ];
+  iota; primops; zeta
+]
+
+
 assume val explode (#opened: inames)
   (tag: string) (fields: struct_fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -109,7 +122,7 @@ assume val explode (#opened: inames)
     (fun _ -> pts_to_fields_vprop tag fields p fields)
     (requires fun _ -> True)
     (ensures fun h _ h' ->
-      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      norm norm_list
         (pts_to_fields tag fields p h h' fields))
 //(iter_and_fields fields (pts_to_field tag fields p h h')))
         
@@ -130,6 +143,7 @@ assume val recombine (#opened: inames)
 
 /// Point struct
 
+[@@iter_unfold]
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
@@ -143,9 +157,12 @@ let point_fields: struct_fields = [
   "y", c_int;
 ]
 
+[@@iter_unfold]
 let point = struct "point" point_fields
 
+[@@iter_unfold]
 let point_pcm_carrier = struct_pcm_carrier "point" point_fields
+[@@iter_unfold]
 let point_pcm: pcm point_pcm_carrier = struct_pcm "point" point_fields
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
@@ -156,14 +173,17 @@ let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm
 
 /// Connections for the fields of a point
 
+[@@iter_unfold]
 val _x: connection point_pcm (opt_pcm #int)
 let _x = struct_field "point" point_fields "x"
 
+[@@iter_unfold]
 val _y: connection point_pcm (opt_pcm #int)
 let _y = struct_field "point" point_fields "y"
 
 /// View for points
 
+[@@iter_unfold]
 val point_view: sel_view point_pcm point false
 let point_view = struct_view "point" point_fields
 
@@ -214,13 +234,185 @@ val recombine' (#opened: inames)
 let recombine' p = recombine "point" point_fields p
 *)
 
+#push-options "--debug PointStructSelectors --debug_level SMTQuery --log_queries --query_stats --fuel 0"
+#restart-solver
+
+[@@iter_unfold] let x: field_of point_fields = mk_field_of point_fields "x"
+[@@iter_unfold] let y: field_of point_fields = mk_field_of point_fields "y"
+
+
+module T = FStar.Tactics
+
+let aux (p: ref 'a point_pcm) (h: rmem (p `pts_to_view` point_view))
+  (h': rmem
+     ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)))
+: Tot (squash (
+   (norm norm_list
+      (pts_to_fields "point" point_fields p h h' point_fields)
+      ==
+   norm norm_list (begin
+      let pointprop =
+      ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+      in
+      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x) /\
+      (can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` y)
+   end))))
+= _ by (T.dump ""; T.smt ())
+
+val explode' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` point_view)
+    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list
+        (pts_to_fields "point" point_fields p h h' point_fields))
+//(iter_and_fields fields (pts_to_field "point" fields p h h')))
+
+let explode' p = explode "point" point_fields p
+
+val explode'' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "point" point_fields)
+    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      (
+      let pointprop =
+      (pts_to_fields_vprop "point" point_fields p point_fields)
+      in
+      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)))
+
+// let explode'' p = explode "point" point_fields p
+
+assume val recombine (#opened: inames)
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+: SteelGhost unit opened
+    (pts_to_fields_vprop tag fields p fields)
+    (fun _ -> p `pts_to_view` struct_view tag fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list
+        (pts_to_fields tag fields p h' h fields))
+
+
+val explode''' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` point_view)
+    (fun _ -> 
+    ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list
+        (pts_to_fields "point" point_fields p h h' point_fields))
+//(iter_and_fields fields (pts_to_field "point" fields p h h')))
+
+let explode''' p =
+  explode "point" point_fields p;
+  change_equal_slprop
+    (pts_to_fields_vprop "point" point_fields p point_fields)
+    ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+
+let aux'
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (h': rmem (p `pts_to_view` point_view))
+= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: c_int.view_type) <: int
+// TODO why are two coercions necessary?
+
+val zero_x
+  (p: ref 'a (struct_pcm "point" point_fields))
+: Steel unit
+    (p `pts_to_view` point_view)
+    (fun _ -> p `pts_to_view` point_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x == (0 <: c_int.view_type)))
+
+let zero_x p =
+  explode "point" point_fields p;
+  slassert (
+     ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)));
+  //recombine "point" point_fields p;
+  sladmit(); return()
+
+(*
+val explode''' (#opened: inames)
+  (p: ref 'a (struct_pcm "point" point_fields))
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "point" point_fields)
+    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let pointprop =
+      (pts_to_fields_vprop "point" point_fields p point_fields)
+      in
+      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x))
+
+let testlemma p
+    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
+    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
+: Lemma
+  (requires
+  norm norm_list (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+  (ensures
+  norm norm_list (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+= ()
+*)
+(*
+let testlemma' (p: ref 'a point_pcm)
+    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
+    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
+: Lemma
+  (requires
+  norm norm_list (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+  (ensures
+  (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+= _ by (T.dump "") // T.norm norm_list; T.dump ""; T.tadmit()); admit()
+*)
+
+//let explode''' p = explode'' p
+
 let aux p (h: rmem (p `pts_to_view` point_view))
   (h': rmem
      ((ref_focus p _x `pts_to_view` c_int.view) `star`
       (ref_focus p _y `pts_to_view` c_int.view)))
 : Lemma
    (requires
-      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      //norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      norm norm_list
       (pts_to_fields "point" point_fields p h h' point_fields))
    (ensures begin
       let pointprop =
@@ -228,9 +420,9 @@ let aux p (h: rmem (p `pts_to_view` point_view))
       (ref_focus p _y `pts_to_view` c_int.view))
       in
       can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` "x" /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x /\
       can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` "y"
+      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` y
    end)
 = ()
 
@@ -845,3 +1037,4 @@ let recombine_oct' p =
   recombine "oct" oct_fields p
 
 #pop-options
+*)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index dce1261a52d..f210904c911 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -13,11 +13,12 @@ open FStar.List.Tot
 let struct_fields =
   struct_fields:list (string * typedef){Cons? struct_fields}
 
+irreducible let iter_unfold = 0
+
+[@@iter_unfold]
 let has_field_bool (fields: struct_fields) (field: string): bool =
   field `mem` map fst fields
 
-irreducible let iter_unfold = 0
-
 [@@iter_unfold]
 let has_field (fields: struct_fields) (field: string): prop =
   has_field_bool fields field == true
@@ -133,9 +134,11 @@ val struct_put_put_ne
 
 /// Similarly, a PCM for structs
 
+[@@iter_unfold]
 let struct_carriers (fields: struct_fields) (field: field_of fields) =
   (get_field fields field).carrier
 
+[@@iter_unfold]
 let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
 : pcm (struct_carriers fields field)
 = (get_field fields field).pcm
@@ -223,6 +226,34 @@ val struct_pcm_put_put_ne
 val struct_view (tag: string) (fields: struct_fields)
 : sel_view (struct_pcm tag fields) (struct tag fields) false
 
+// /// View a struct_pcm_carrier as a struct
+// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields{normalize_term (fields' \subset fields) == true})
+// : sel_view (struct_pcm tag fields) (struct tag fields') false
+// 
+// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields)
+// : sel_view (struct_pcm tag fields) (struct tag (normalize (fields - fields'))) false
+// 
+// struct_view_convert #opened
+//   (v: struct_view tag fields fields'1)
+// : SteelGhost (struct_view tag fields fields'2) opened
+//     (p `pts_to_view` v)
+//     (fun w -> (p `pts_to_view` w))
+//     (requires fun _ -> normalize (fields - fields'1 == fields - fields'2))
+//     (ensures fun h w h' -> forall field. field in (fields - fields'1) ==>
+//        h (p `pts_to_view` v) `struct_get` field == 
+//        h' (p `pts_to_view` w) `struct_get` field)
+// 
+// struct_view_convert
+//   (v: struct_view tag fields fields'1)
+// : Pure (struct_view tag fields fields'2)
+//     (requires normalize (fields - fields'1 == fields - fields'2))
+//     (ensures fun w -> True)
+//
+// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields) (fields_fields': struct_fields) (heq: squash (fields_fields' == normalize_term (fields - fields')))
+// : sel_view (struct_pcm tag fields) (struct tag fields_fields') false
+
+// struct_view tag fields fields' (_ by (T.norm _; T.trefl ()))
+
 /// Typedef for struct from typedefs for its fields
 
 let typedef_struct (tag: string) (fields: struct_fields): typedef = {

From 5b52bdb5a8420695e5324c2d510c9633d4c198e0 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 30 Jul 2021 07:32:12 -0700
Subject: [PATCH 150/513] Try to typecheck normalized term against its
 normalized type

---
 .../arraystructs/PointStructSelectors.fst     | 35 ++++++++++++++-----
 .../arraystructs/Steel.C.StructLiteral.fsti   |  2 --
 .../steel/arraystructs/Steel.C.Typedef.fst    |  3 ++
 3 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 07a01112bbc..02ac4a8e65a 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -16,7 +16,6 @@ open Steel.C.StructLiteral
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-(*
 (** ** BEGIN TODO impl and move to StructLiteral *)
 
 (*
@@ -108,7 +107,7 @@ unfold let norm_list = [
     `%map; `%mem; `%fst; `%Mktuple2?._1;
     `%assoc;
     `%Some?.v;
-    `%Mktypedef?.view_type
+    //`%Mktypedef?.view_type
   ];
   iota; primops; zeta
 ]
@@ -317,6 +316,31 @@ val explode''' (#opened: inames)
         (pts_to_fields "point" point_fields p h h' point_fields))
 //(iter_and_fields fields (pts_to_field "point" fields p h h')))
 
+#push-options "--print_implicits"
+
+unfold let norm' (s: list norm_step) (#a: Type) (x: a) : Tot (norm s a) =
+  norm_spec s a;
+  norm s x
+
+unfold let norm''  (#a: Type) (x: a) : Tot (norm norm_list a) =
+  norm_spec norm_list a;
+  norm norm_list x
+
+let aux'
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (h': rmem (p `pts_to_view` point_view))
+= let i: int =
+    (norm'' (h' (p `pts_to_view` point_view) `struct_get` x))// <: (get_field point_fields x).view_type)) in
+  in let j: int = i in j
+//= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: c_int.view_type) <: int
+// TODO why are two coercions necessary?
+
+/// Reading a struct field
+val struct_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (get_field fields field).view_type
+
 let explode''' p =
   explode "point" point_fields p;
   change_equal_slprop
@@ -324,12 +348,6 @@ let explode''' p =
     ((ref_focus p _x `pts_to_view` c_int.view) `star`
       (ref_focus p _y `pts_to_view` c_int.view))
 
-let aux'
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (h': rmem (p `pts_to_view` point_view))
-= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: c_int.view_type) <: int
-// TODO why are two coercions necessary?
-
 val zero_x
   (p: ref 'a (struct_pcm "point" point_fields))
 : Steel unit
@@ -1037,4 +1055,3 @@ let recombine_oct' p =
   recombine "oct" oct_fields p
 
 #pop-options
-*)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index f210904c911..6ad28fa5cb0 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -13,8 +13,6 @@ open FStar.List.Tot
 let struct_fields =
   struct_fields:list (string * typedef){Cons? struct_fields}
 
-irreducible let iter_unfold = 0
-
 [@@iter_unfold]
 let has_field_bool (fields: struct_fields) (field: string): bool =
   field `mem` map fst fields
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index caa91ac99b2..8d55f27dd34 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -5,6 +5,9 @@ open Steel.C.PCM
 open Steel.C.Ref
 open FStar.FunctionalExtensionality
 
+irreducible let iter_unfold = 0
+
+[@@iter_unfold]
 noeq type typedef = { 
   carrier: Type0; 
   pcm: pcm carrier; 

From a895d92f6c01fd7cdb02eafcee201fc470b8fd2e Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 30 Jul 2021 11:21:17 -0700
Subject: [PATCH 151/513] Fiddle with norm

---
 .../steel/arraystructs/PointStructSelectors.fst | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 02ac4a8e65a..8105650d52f 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -326,15 +326,24 @@ unfold let norm''  (#a: Type) (x: a) : Tot (norm norm_list a) =
   norm_spec norm_list a;
   norm norm_list x
 
+assume val struct_get' :
+  #tag: string -> #fields: struct_fields -> x: struct tag fields -> field: field_of fields
+    -> Prims.Tot (norm norm_list (Mktypedef?.view_type (get_field fields field)))
+
 let aux'
   (p: ref 'a (struct_pcm "point" point_fields))
   (h': rmem (p `pts_to_view` point_view))
-= let i: int =
-    (norm'' (h' (p `pts_to_view` point_view) `struct_get` x))// <: (get_field point_fields x).view_type)) in
-  in let j: int = i in j
-//= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: c_int.view_type) <: int
+  : GTot int
+= 
+    ((h' (p `pts_to_view` point_view) `struct_get'` x))
+    // <: (get_field point_fields x).view_type)) in
+//  in let j: int = i in j
+//= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: (get_field point_fields x).view_type) <: int
 // TODO why are two coercions necessary?
 
+let aux'' (s: (Mktypedef?.view_type (get_field point_fields xc_)): int
+= s <: int
+
 /// Reading a struct field
 val struct_get
   (#tag: string) (#fields: struct_fields)

From 29b64a33dbd24498be6e35a02b2b3c15e1d4c8d7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 30 Jul 2021 13:13:19 -0700
Subject: [PATCH 152/513] Notes from meeting with Nik&Tahina

---
 .../arraystructs/PointStructSelectors.fst     | 109 +++++++++++-------
 .../arraystructs/Steel.C.StructLiteral.fsti   |   9 +-
 2 files changed, 75 insertions(+), 43 deletions(-)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 8105650d52f..70114254fbe 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -16,6 +16,20 @@ open Steel.C.StructLiteral
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+unfold let norm_list = [
+  delta_attr [`%iter_unfold];
+  delta_only [
+    `%map; `%mem; `%fst; `%Mktuple2?._1;
+    `%assoc;
+    `%Some?.v;
+  ];
+  iota; primops; zeta
+]
+
+assume val struct_get' :
+  #tag: string -> #fields: struct_fields -> x: struct tag fields -> field: field_of fields
+    -> Prims.Tot (norm norm_list (Mktypedef?.view_type (get_field fields field)))
+
 (** ** BEGIN TODO impl and move to StructLiteral *)
 
 (*
@@ -48,34 +62,63 @@ let rec pts_to_fields_vprop
       pts_to_fields_vprop tag fields p fields'
     end else emp
 
+#push-options "--debug PointStructSelectors --debug_level SMTQuery --log_queries --query_stats --fuel 0"
+(*
 [@@iter_unfold]
-let rec pts_to_fields
+let pts_to_fields
   (tag: string) (fields: struct_fields)
   (p: ref 'a (struct_pcm tag fields))
   (h: rmem (p `pts_to_view` struct_view tag fields))
   (h': rmem (pts_to_fields_vprop tag fields p fields))
   //(prefix: list (string * typedef))
-  (fields': struct_fields)
+  (field: field_of fields)
   //(hfields': squash (fields == rev prefix `append` fields'))
-: prop
-= match fields' with
-  | [(field, _)] ->
-    if has_field_bool fields field then
-      can_be_split 
-        (pts_to_fields_vprop tag fields p fields)
-        (pts_to_field_vprop tag fields p field) /\
-      h' (pts_to_field_vprop tag fields p field) ===
-      h (p `pts_to_view` struct_view tag fields) `struct_get` field
-    else True
-  | (field, _) :: fields' ->
-    if has_field_bool fields field then
-      can_be_split 
+: Tot prop
+= 
+      can_be_split
         (pts_to_fields_vprop tag fields p fields)
         (pts_to_field_vprop tag fields p field) /\
-      h' (pts_to_field_vprop tag fields p field) ===
-      h (p `pts_to_view` struct_view tag fields) `struct_get` field /\
-      pts_to_fields tag fields p h h' fields'
-    else True
+       begin
+         //let lhs = h' (pts_to_field_vprop tag fields p field) in
+         let rhs 
+         : (
+         
+           assoc_mem field fields;
+         let { carrier = _ ; pcm = _ ; view_type = view_type ; view = _ } =
+           let FStar.Pervasives.Native.Some v =
+             match fields with
+             | [] -> None
+             | (x', y) :: tl ->
+               (if field = x' then Some y else assoc field tl) <: Pervasives.Native.option typedef
+           in
+           v
+         in
+         view_type)
+         = h (p `pts_to_view` struct_view tag fields) `struct_get'` field in
+         rhs == rhs
+         //let rhs = h (p `pts_to_view` struct_view tag fields) `struct_get'` field in
+         //rhs == rhs
+       end
+  //| (field, _) :: fields' ->
+  //  if has_field_bool fields field then
+  //    True
+  //    //can_be_split 
+  //    //  (pts_to_fields_vprop tag fields p fields)
+  //    //  (pts_to_field_vprop tag fields p field) /\
+  //    //h' (pts_to_field_vprop tag fields p field) ===
+  //    //h (p `pts_to_view` struct_view tag fields) `struct_get'` field /\
+  //    //pts_to_fields tag fields p h h' fields'
+  //  else True
+
+// 1. normalizing iterated conjunction and star
+// 2. keep a list of fields to be excluded (relies on normalizing list difference operator)
+// 3. don't use selectors, but also don't use PCM carrier values
+//    i.e. have slprop p `pts_to` v where v is a value corresponding to a C type
+//      pts_to p view v = (p `pts_to_view` view) `vdep` (fun x -> x == v)
+//    + no more issues with normalization of props
+//    - need laws about struct_get/struct_put (may rely on smt_fallback)
+
+#push-options "--print_implicits"
 
 (*
 [@@__reduce__;iter_unfold]
@@ -101,17 +144,6 @@ let pts_to_field
   h (p `pts_to_view` struct_view tag fields) `struct_get` field
   *)
 
-unfold let norm_list = [
-  delta_attr [`%iter_unfold];
-  delta_only [
-    `%map; `%mem; `%fst; `%Mktuple2?._1;
-    `%assoc;
-    `%Some?.v;
-    //`%Mktypedef?.view_type
-  ];
-  iota; primops; zeta
-]
-
 
 assume val explode (#opened: inames)
   (tag: string) (fields: struct_fields)
@@ -121,7 +153,7 @@ assume val explode (#opened: inames)
     (fun _ -> pts_to_fields_vprop tag fields p fields)
     (requires fun _ -> True)
     (ensures fun h _ h' ->
-      norm norm_list
+      //norm norm_list
         (pts_to_fields tag fields p h h' fields))
 //(iter_and_fields fields (pts_to_field tag fields p h h')))
         
@@ -256,9 +288,9 @@ let aux (p: ref 'a point_pcm) (h: rmem (p `pts_to_view` point_view))
       (ref_focus p _y `pts_to_view` c_int.view))
       in
       (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x) /\
       (can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` y)
+      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` y)
    end))))
 = _ by (T.dump ""; T.smt ())
 
@@ -287,7 +319,7 @@ val explode'' (#opened: inames)
       (pts_to_fields_vprop "point" point_fields p point_fields)
       in
       (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)))
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x)))
 
 // let explode'' p = explode "point" point_fields p
 
@@ -326,10 +358,6 @@ unfold let norm''  (#a: Type) (x: a) : Tot (norm norm_list a) =
   norm_spec norm_list a;
   norm norm_list x
 
-assume val struct_get' :
-  #tag: string -> #fields: struct_fields -> x: struct tag fields -> field: field_of fields
-    -> Prims.Tot (norm norm_list (Mktypedef?.view_type (get_field fields field)))
-
 let aux'
   (p: ref 'a (struct_pcm "point" point_fields))
   (h': rmem (p `pts_to_view` point_view))
@@ -341,8 +369,8 @@ let aux'
 //= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: (get_field point_fields x).view_type) <: int
 // TODO why are two coercions necessary?
 
-let aux'' (s: (Mktypedef?.view_type (get_field point_fields xc_)): int
-= s <: int
+//let aux'' (s: (Mktypedef?.view_type (get_field point_fields xc_)): int
+//= s <: int
 
 /// Reading a struct field
 val struct_get
@@ -1064,3 +1092,4 @@ let recombine_oct' p =
   recombine "oct" oct_fields p
 
 #pop-options
+*)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 6ad28fa5cb0..83a8a813afc 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -34,13 +34,16 @@ let mk_field_of (fields: struct_fields) (field: string)
 [@@iter_unfold]
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
   assoc_mem field fields;
-  Some?.v (assoc field fields)
+  match assoc field fields with
+  | Some v -> v
+  | None -> false_elim ()
 
 /// A view type for structs
 
 [@@iter_unfold]
-let struct_views (fields: struct_fields) (field: field_of fields) =
-  (get_field fields field).view
+let struct_views (fields: struct_fields) (field: field_of fields)
+: sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
+= (get_field fields field).view
 
 val struct (tag: string) (fields: struct_fields): Type0
 

From da5d1b6a0d7d172df6b7840dc8db97ccfc510a93 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 30 Jul 2021 16:01:12 -0700
Subject: [PATCH 153/513] Explode of pts_to for view types with explicit values

---
 .../arraystructs/PointStructSelectors.fst     |   72 +-
 .../arraystructs/Steel.C.StructLiteral.fst    | 1113 +++++++++++++++++
 .../arraystructs/Steel.C.StructLiteral.fsti   |   34 +-
 .../steel/arraystructs/Steel.C.Typedef.fst    |    3 +-
 4 files changed, 1198 insertions(+), 24 deletions(-)

diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
index 70114254fbe..7ed75c4ee73 100644
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ b/examples/steel/arraystructs/PointStructSelectors.fst
@@ -16,19 +16,67 @@ open Steel.C.StructLiteral
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-unfold let norm_list = [
-  delta_attr [`%iter_unfold];
-  delta_only [
-    `%map; `%mem; `%fst; `%Mktuple2?._1;
-    `%assoc;
-    `%Some?.v;
-  ];
-  iota; primops; zeta
-]
+/// TODO move and dedup with Steel.C.Ptr.fst
+
+let vpure_sel'
+  (p: prop)
+: Tot (selector' (squash p) (Steel.Memory.pure p))
+= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
+
+let vpure_sel
+  (p: prop)
+: Tot (selector (squash p) (Steel.Memory.pure p))
+= vpure_sel' p
+
+[@@ __steel_reduce__]
+let vpure'
+  (p: prop)
+: GTot vprop'
+= {
+  hp = Steel.Memory.pure p;
+  t = squash p;
+  sel = vpure_sel p;
+}
+
+[@@ __steel_reduce__]
+let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
 
-assume val struct_get' :
-  #tag: string -> #fields: struct_fields -> x: struct tag fields -> field: field_of fields
-    -> Prims.Tot (norm norm_list (Mktypedef?.view_type (get_field fields field)))
+let intro_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    emp
+    (fun _ -> vpure p)
+    (fun _ -> p)
+    (fun _ _ h' -> p)
+=
+  change_slprop_rel
+    emp
+    (vpure p)
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m)
+
+let elim_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    (vpure p)
+    (fun _ -> emp)
+    (fun _ -> True)
+    (fun _ _ _ -> p)
+=
+  change_slprop_rel
+    (vpure p)
+    emp
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
+
+let pts_to_v
+  (#pcm: pcm 'a) (#can_view_unit: bool)
+  (p: ref 'a pcm) (view: sel_view pcm 'b can_view_unit)
+  (v: 'b)
+: vprop
+= (p `pts_to_view` view) `vdep` (fun x -> vpure (x == v))
 
 (** ** BEGIN TODO impl and move to StructLiteral *)
 
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index b83ee8e7dea..74ca1eaf9b4 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -1,6 +1,7 @@
 module Steel.C.StructLiteral
 
 open Steel.Memory
+open Steel.Effect
 open Steel.Effect.Common
 open Steel.Effect.Atomic
 
@@ -283,3 +284,1115 @@ let struct_view tag fields = {
 }
 
 let struct_field tag fields field = struct_field (struct_pcms tag fields) field
+
+/// TODO move and dedup with Steel.C.Ptr.fst
+
+let vpure_sel'
+  (p: prop)
+: Tot (selector' (squash p) (Steel.Memory.pure p))
+= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
+
+let vpure_sel
+  (p: prop)
+: Tot (selector (squash p) (Steel.Memory.pure p))
+= vpure_sel' p
+
+[@@ __steel_reduce__]
+let vpure'
+  (p: prop)
+: GTot vprop'
+= {
+  hp = Steel.Memory.pure p;
+  t = squash p;
+  sel = vpure_sel p;
+}
+
+[@@ __steel_reduce__]
+let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
+
+let intro_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    emp
+    (fun _ -> vpure p)
+    (fun _ -> p)
+    (fun _ _ h' -> p)
+=
+  change_slprop_rel
+    emp
+    (vpure p)
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m)
+
+let elim_vpure
+  (#opened: _)
+  (p: prop)
+: SteelGhost unit opened
+    (vpure p)
+    (fun _ -> emp)
+    (fun _ -> True)
+    (fun _ _ _ -> p)
+=
+  change_slprop_rel
+    (vpure p)
+    emp
+    (fun _ _ -> p)
+    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
+
+assume val pts_to_v
+  (#pcm: pcm 'b) (#can_view_unit: bool)
+  (p: ref 'a pcm) (view: sel_view pcm 'c can_view_unit)
+  (v: 'c)
+: vprop
+//= (p `pts_to_view` view) `vdep` (fun x -> vpure (x == v))
+
+assume val struct_get'
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (get_field fields field).view_type
+
+assume val struct_field':
+  tag: string -> fields: struct_fields -> field: field_of fields
+    -> Prims.Tot
+      (connection #(struct_pcm_carrier tag fields)
+          #(struct_carriers fields field)
+          (struct_pcm tag fields)
+          (struct_pcms tag fields field))
+
+[@@__reduce__]
+let pts_to_field
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (s: struct tag fields)
+  (field: field_of fields)
+: vprop
+= pts_to_v
+    (ref_focus p (struct_field' tag fields field))
+    (struct_views fields field)
+    (s `struct_get'` field)
+
+[@@__reduce__]
+let rec pts_to_fields'
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (s: struct tag fields)
+  (fields': struct_fields)
+: vprop
+= match fields' with
+  | [(field, _)] ->
+    if has_field_bool fields field then pts_to_field tag fields p s field else emp
+  | (field, _) :: fields' ->
+    if has_field_bool fields field then begin
+      pts_to_field tag fields p s field `star`
+      pts_to_fields' tag fields p s fields'
+    end else emp
+
+[@@__reduce__]
+let pts_to_fields
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (s: struct tag fields)
+: vprop
+= pts_to_fields' tag fields p s fields
+
+assume val explode (#opened: inames)
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (s: Ghost.erased (struct tag fields))
+: SteelGhostT unit opened
+    (pts_to_v p (struct_view tag fields) s)
+    (fun _ -> pts_to_fields tag fields p s)
+
+assume val recombine (#opened: inames)
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (s: Ghost.erased (struct tag fields))
+: SteelGhostT unit opened
+    (pts_to_fields tag fields p s)
+    (fun _ -> pts_to_v p (struct_view tag fields) s)
+
+/// Point struct
+
+open Steel.C.Opt
+
+[@@__reduce__]
+let c_int: typedef = {
+  carrier = option int;
+  pcm = opt_pcm #int;
+  view_type = int;
+  view = opt_view int;
+}
+
+[@@__reduce__]
+let point_fields: struct_fields = [
+  "x", c_int;
+  "y", c_int;
+]
+
+//[@@iter_unfold]
+[@@__reduce__]
+let point = struct "point" point_fields
+
+//[@@iter_unfold]
+[@@__reduce__]
+let point_pcm_carrier = struct_pcm_carrier "point" point_fields
+//[@@iter_unfold]
+[@@__reduce__]
+let point_pcm: pcm point_pcm_carrier = struct_pcm "point" point_fields
+
+/// (mk_point x y) represents (struct point){.x = x, .y = y}
+/// (mk_point_pcm x y) same, but where x and y are PCM carrier values
+
+let mk_point: int -> int -> point = mk_struct "point" point_fields
+let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm "point" point_fields
+
+/// Connections for the fields of a point
+
+//[@@iter_unfold]
+val _x: connection point_pcm (opt_pcm #int)
+let _x = struct_field' "point" point_fields "x"
+
+//[@@iter_unfold]
+val _y: connection point_pcm (opt_pcm #int)
+let _y = struct_field' "point" point_fields "y"
+
+//[@@iter_unfold]
+[@@__reduce__]
+let x: field_of point_fields = mk_field_of point_fields "x"
+[@@__reduce__]
+let y: field_of point_fields = mk_field_of point_fields "y"
+
+/// View for points
+
+[@@__reduce__]
+val point_view: sel_view point_pcm point false
+let point_view = struct_view "point" point_fields
+
+/// Explode and recombine
+
+//val explode' (#opened: inames)
+//  (p: ref 'a point_pcm)
+//  (s: Ghost.erased point)
+//: SteelGhostT unit opened
+//    (pts_to_v p point_view s)
+//    (fun _ -> pts_to_fields "point" point_fields p s)
+
+val explode' (#opened: inames)
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (s: Ghost.erased (struct "point" point_fields))
+: SteelGhostT unit opened
+    (pts_to_v p (struct_view "point" point_fields) s)
+    (fun _ -> pts_to_fields "point" point_fields p s)
+
+let explode' p = explode "point" point_fields p
+
+(*
+
+struct_def = f:(#a:Type -> (map: string&typedef -> a) -> (reduce: a -> a -> b) -> b){
+  exists fields. 
+}
+
+struct_def_of_fields fields = fun f g -> reduce g (map f fields)
+
+point_struct = normalize_term (struct_def_of_fields f g ["x", c_int; "y", c_int])
+===> fun f g -> f ("x", c_int) `g` f ("y", c_int)
+
+pcm_carrier (s: struct_def) = s (fun (_, td) -> td.carrier) (&)
+
+struct_def a = {
+  fields: s:a -> typedef; //itrivial typedef for undefined fields
+}
+
+struct_view : sel_view (struct_pcm fields) (struct_def (refine string p)) false
+p ~~~> p /\ (fun x -> x =!= removed_field)
+
+
+*)
+
+val explode'' (#opened: inames)
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (s: Ghost.erased (struct "point" point_fields))
+: SteelGhostT unit opened
+    (pts_to_v p (struct_view "point" point_fields) s)
+    (fun _ ->
+//(:struct_def) (fun (field, td) -> pts_to_v ..) Star)
+//= struct_def ..
+  pts_to_v
+    (ref_focus p _x)
+    (opt_view int)
+    (s `struct_get'` x)
+    `star`
+  pts_to_v
+    (ref_focus p _y)
+    (opt_view int)
+    (s `struct_get'` y))
+
+//      pts_to_field "point" point_fields p s x `star`
+//      pts_to_field "point" point_fields p s y)
+
+#push-options "--print_implicits"
+
+let explode'' p s = explode "point" point_fields p s
+
+(*
+(*
+
+val explode'' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` point_view)
+    (fun _ ->
+      (ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      h' (ref_focus p _x `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "x" /\
+      h' (ref_focus p _y `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "y")
+
+let explode'' p = explode "point" point_fields p
+*)
+
+(*
+val recombine' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _x `pts_to_view` c_int.view) `star`
+     (ref_focus p _y `pts_to_view` c_int.view))
+    (fun _ -> p `pts_to_view` point_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      h (ref_focus p _x `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "x" /\
+      h (ref_focus p _y `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "y")
+
+let recombine' p = recombine "point" point_fields p
+*)
+
+#push-options "--debug PointStructSelectors --debug_level SMTQuery --log_queries --query_stats --fuel 0"
+#restart-solver
+
+[@@iter_unfold] let x: field_of point_fields = mk_field_of point_fields "x"
+[@@iter_unfold] let y: field_of point_fields = mk_field_of point_fields "y"
+
+
+module T = FStar.Tactics
+
+let aux (p: ref 'a point_pcm) (h: rmem (p `pts_to_view` point_view))
+  (h': rmem
+     ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)))
+: Tot (squash (
+   (norm norm_list
+      (pts_to_fields "point" point_fields p h h' point_fields)
+      ==
+   norm norm_list (begin
+      let pointprop =
+      ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+      in
+      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x) /\
+      (can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` y)
+   end))))
+= _ by (T.dump ""; T.smt ())
+
+val explode' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` point_view)
+    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list
+        (pts_to_fields "point" point_fields p h h' point_fields))
+//(iter_and_fields fields (pts_to_field "point" fields p h h')))
+
+let explode' p = explode "point" point_fields p
+
+val explode'' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "point" point_fields)
+    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      (
+      let pointprop =
+      (pts_to_fields_vprop "point" point_fields p point_fields)
+      in
+      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x)))
+
+// let explode'' p = explode "point" point_fields p
+
+assume val recombine (#opened: inames)
+  (tag: string) (fields: struct_fields)
+  (p: ref 'a (struct_pcm tag fields))
+: SteelGhost unit opened
+    (pts_to_fields_vprop tag fields p fields)
+    (fun _ -> p `pts_to_view` struct_view tag fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list
+        (pts_to_fields tag fields p h' h fields))
+
+
+val explode''' (#opened: inames)
+  (p: ref 'a point_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` point_view)
+    (fun _ -> 
+    ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list
+        (pts_to_fields "point" point_fields p h h' point_fields))
+//(iter_and_fields fields (pts_to_field "point" fields p h h')))
+
+#push-options "--print_implicits"
+
+unfold let norm' (s: list norm_step) (#a: Type) (x: a) : Tot (norm s a) =
+  norm_spec s a;
+  norm s x
+
+unfold let norm''  (#a: Type) (x: a) : Tot (norm norm_list a) =
+  norm_spec norm_list a;
+  norm norm_list x
+
+let aux'
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (h': rmem (p `pts_to_view` point_view))
+  : GTot int
+= 
+    ((h' (p `pts_to_view` point_view) `struct_get'` x))
+    // <: (get_field point_fields x).view_type)) in
+//  in let j: int = i in j
+//= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: (get_field point_fields x).view_type) <: int
+// TODO why are two coercions necessary?
+
+//let aux'' (s: (Mktypedef?.view_type (get_field point_fields xc_)): int
+//= s <: int
+
+/// Reading a struct field
+val struct_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (get_field fields field).view_type
+
+let explode''' p =
+  explode "point" point_fields p;
+  change_equal_slprop
+    (pts_to_fields_vprop "point" point_fields p point_fields)
+    ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+
+val zero_x
+  (p: ref 'a (struct_pcm "point" point_fields))
+: Steel unit
+    (p `pts_to_view` point_view)
+    (fun _ -> p `pts_to_view` point_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x == (0 <: c_int.view_type)))
+
+let zero_x p =
+  explode "point" point_fields p;
+  slassert (
+     ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)));
+  //recombine "point" point_fields p;
+  sladmit(); return()
+
+(*
+val explode''' (#opened: inames)
+  (p: ref 'a (struct_pcm "point" point_fields))
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "point" point_fields)
+    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let pointprop =
+      (pts_to_fields_vprop "point" point_fields p point_fields)
+      in
+      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x))
+
+let testlemma p
+    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
+    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
+: Lemma
+  (requires
+  norm norm_list (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+  (ensures
+  norm norm_list (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+= ()
+*)
+(*
+let testlemma' (p: ref 'a point_pcm)
+    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
+    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
+: Lemma
+  (requires
+  norm norm_list (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+  (ensures
+  (let pointprop =
+  (pts_to_fields_vprop "point" point_fields p point_fields)
+  in
+  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
+  ))
+= _ by (T.dump "") // T.norm norm_list; T.dump ""; T.tadmit()); admit()
+*)
+
+//let explode''' p = explode'' p
+
+let aux p (h: rmem (p `pts_to_view` point_view))
+  (h': rmem
+     ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view)))
+: Lemma
+   (requires
+      //norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      norm norm_list
+      (pts_to_fields "point" point_fields p h h' point_fields))
+   (ensures begin
+      let pointprop =
+      ((ref_focus p _x `pts_to_view` c_int.view) `star`
+      (ref_focus p _y `pts_to_view` c_int.view))
+      in
+      can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x /\
+      can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` y
+   end)
+= ()
+
+/// Now, a contrived struct with twice as many fields (to stress-test)
+
+//[@@__reduce__;iter_unfold]
+let quad_fields: struct_fields = [
+  "x", c_int;
+  "y", c_int;
+  "z", c_int;
+  "w", c_int;
+]
+let quad = struct "quad" quad_fields
+
+let quad_pcm_carrier = struct_pcm_carrier "quad" quad_fields
+let quad_pcm: pcm quad_pcm_carrier = struct_pcm "quad" quad_fields
+
+/// (mk_quad x y) represents (struct quad){.x = x, .y = y}
+/// (mk_quad_pcm x y) same, but where x and y are PCM carrier values
+
+let mk_quad: int -> int -> int -> int -> quad = mk_struct "quad" quad_fields
+let mk_quad_pcm: option int -> option int -> option int -> option int -> quad_pcm_carrier = mk_struct_pcm "quad" quad_fields
+
+/// Connections for the fields of a quad
+
+[@@iter_unfold] let _quad_x: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "x"
+[@@iter_unfold] let _quad_y: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "y"
+[@@iter_unfold] let _quad_z: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "z"
+[@@iter_unfold] let _quad_w: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "w"
+
+/// View for quads
+
+[@@iter_unfold] let quad_view: sel_view quad_pcm quad false = struct_view "quad" quad_fields
+
+/// Explode and recombine
+
+(*
+val explode_quad' (#opened: inames)
+  (p: ref 'a quad_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "quad" quad_fields)
+    (fun _ -> iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (iter_and_fields quad_fields (pts_to_field "quad" quad_fields p h h')))
+
+let explode_quad' p = explode "quad" quad_fields p
+*)
+
+(*
+val explode_quad'' (#opened: inames)
+  (p: ref 'a quad_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` quad_view)
+    (fun _ ->
+      (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view))))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_x `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "x" /\
+      can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_y `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "y" /\
+      can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_z `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "z" /\
+      can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quad_w `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "w")
+*)
+
+#push-options "--z3rlimit 30 --query_stats"
+
+#pop-options
+#push-options "--fuel 2 --query_stats"
+
+[@@iter_unfold] let x: field_of quad_fields = mk_field_of quad_fields "x"
+[@@iter_unfold] let y: field_of quad_fields = mk_field_of quad_fields "y"
+[@@iter_unfold] let z: field_of quad_fields = mk_field_of quad_fields "z"
+[@@iter_unfold] let w: field_of quad_fields = mk_field_of quad_fields "w"
+
+module T = FStar.Tactics
+
+let norm_list = [
+  delta_attr [`%iter_unfold];
+  delta_only [
+    `%map; `%mem; `%fst; `%Mktuple2?._1;
+    `%assoc;
+    `%Some?.v
+  ];
+  iota; primops; zeta
+]
+
+let quad_aux (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
+  (h': rmem
+     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
+: squash
+   ((
+      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (pts_to_fields "quad" quad_fields p h h' quad_fields))
+   ==
+   (begin
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
+      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
+       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
+         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
+         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
+          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
+   end))
+= _ by (T.trefl ())
+// assert_norm produces a stack overflow?
+//_ by (
+//    T.norm norm_list;
+//    T.trefl ())
+
+let quad_aux2 (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
+  (h': rmem
+     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
+: squash
+   ((
+      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
+        (pts_to_fields "quad" quad_fields p h h' quad_fields))
+   <==>
+   norm norm_list (begin
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
+      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
+       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
+       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
+         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
+         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
+          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
+   end))
+= () // _ by (T.trefl ())
+
+(*
+let quad_unfold_iter_star_fields p
+: Lemma
+    (norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p)) ==
+     (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+        (ref_focus p _quad_w `pts_to_view` c_int.view))))
+= ()
+*)
+
+#push-options "--query_stats"
+
+let explode_quad'' p =
+  explode "quad" quad_fields p;
+  //quad_unfold_iter_star_fields p;
+  //change_equal_slprop
+  //  (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
+  //  ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+  //   ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+  //    ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+  //     (ref_focus p _quad_w `pts_to_view` c_int.view))));
+  ()
+
+(*
+val recombine_quad' (#opened: inames)
+  (p: ref 'a quad_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+       (ref_focus p _quad_w `pts_to_view` c_int.view))))
+    (fun _ -> p `pts_to_view` quad_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quadprop =
+        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+          (ref_focus p _quad_w `pts_to_view` c_int.view)))
+      in
+      // assert (can_be_split' quadprop (ref_focus p _quad_x `pts_to_view` c_int.view));
+      // assert (can_be_split' quadprop (ref_focus p _quad_y `pts_to_view` c_int.view));
+      // assert (can_be_split' quadprop (ref_focus p _quad_z `pts_to_view` c_int.view));
+      // assert (can_be_split' quadprop (ref_focus p _quad_w `pts_to_view` c_int.view));
+      h (ref_focus p _quad_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "x" /\
+      h (ref_focus p _quad_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "y" /\
+      h (ref_focus p _quad_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "z" /\
+      h (ref_focus p _quad_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "w")
+
+let recombine_quad' p =
+  quad_unfold_iter_star_fields p;
+  change_equal_slprop
+    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
+       (ref_focus p _quad_w `pts_to_view` c_int.view))))
+    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p));
+  recombine "quad" quad_fields p
+*)
+
+/// 5 fields!
+
+//[@@__reduce__;iter_unfold]
+let quint_fields: struct_fields = [
+  "x", c_int;
+  "y", c_int;
+  "z", c_int;
+  "w", c_int;
+  "v", c_int;
+]
+let quint = struct "quint" quint_fields
+
+let quint_pcm_carrier = struct_pcm_carrier "quint" quint_fields
+let quint_pcm: pcm quint_pcm_carrier = struct_pcm "quint" quint_fields
+
+let mk_quint: int -> int -> int -> int -> int -> quint = mk_struct "quint" quint_fields
+let mk_quint_pcm: option int -> option int -> option int -> option int -> option int -> quint_pcm_carrier = mk_struct_pcm "quint" quint_fields
+
+/// Connections for the fields of a quint
+
+let _quint_x: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "x"
+let _quint_y: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "y"
+let _quint_z: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "z"
+let _quint_w: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "w"
+let _quint_v: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "v"
+
+/// View for quints
+
+let quint_view: sel_view quint_pcm quint false = struct_view "quint" quint_fields
+
+/// Explode and recombine
+
+(*
+val explode_quint' (#opened: inames)
+  (p: ref 'a quint_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "quint" quint_fields)
+    (fun _ -> iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' -> iter_and_fields quint_fields (pts_to_field "quint" quint_fields p h h'))
+
+let explode_quint' p = explode "quint" quint_fields p
+*)
+
+#restart-solver
+
+val explode_quint'' (#opened: inames)
+  (p: ref 'a quint_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` quint_view)
+    (fun _ ->
+      (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quintprop =
+        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+           (ref_focus p _quint_v `pts_to_view` c_int.view))))
+      in
+      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
+      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
+      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
+      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
+      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v")
+
+let aux p (h: rmem (p `pts_to_view` quint_view))
+  (h': rmem
+     ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+         (ref_focus p _quint_v `pts_to_view` c_int.view))))))
+: Lemma
+   (requires
+      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
+      (pts_to_fields "quint" quint_fields p h h' quint_fields))
+   (ensures begin
+      let quintprop =
+        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+           (ref_focus p _quint_v `pts_to_view` c_int.view))))
+      in
+      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
+      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
+      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
+      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
+      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
+      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v"
+   end)
+= admit()
+
+(*
+let quint_unfold_iter_star_fields p
+: Lemma
+    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p) ==
+     (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+= ()
+*)
+
+#restart-solver
+
+//#push-options "--z3rlimit 30"
+
+let explode_quint'' p =
+  explode "quint" quint_fields p;
+  //quint_unfold_iter_star_fields p;
+  //change_equal_slprop
+  //  (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
+  //  ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+  //   ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+  //    ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+  //     ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+  //      (ref_focus p _quint_v `pts_to_view` c_int.view)))));
+  ()
+
+//#pop-options
+
+val recombine_quint' (#opened: inames)
+  (p: ref 'a quint_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+    (fun _ -> p `pts_to_view` quint_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let quintprop =
+        ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+         ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+          ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+           ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+            (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+      in
+      assert (can_be_split' quintprop (ref_focus p _quint_x `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_y `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_z `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_w `pts_to_view` c_int.view));
+      assert (can_be_split' quintprop (ref_focus p _quint_v `pts_to_view` c_int.view));
+      h (ref_focus p _quint_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "x" /\
+      h (ref_focus p _quint_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "y" /\
+      h (ref_focus p _quint_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "z" /\
+      h (ref_focus p _quint_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "w" /\
+      h (ref_focus p _quint_v `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "v")
+
+#push-options "--z3rlimit 20"
+
+let recombine_quint' p =
+  quint_unfold_iter_star_fields p;
+  change_equal_slprop
+    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
+       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
+        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
+    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p));
+  recombine "quint" quint_fields p
+
+#pop-options
+
+/// 8 fields:
+
+let oct_fields: struct_fields = [
+  "x", c_int;
+  "y", c_int;
+  "z", c_int;
+  "w", c_int;
+  "v", c_int;
+  "u", c_int;
+  "t", c_int;
+  "s", c_int;
+]
+let oct = struct "oct" oct_fields
+
+let oct_pcm_carrier = struct_pcm_carrier "oct" oct_fields
+let oct_pcm: pcm oct_pcm_carrier = struct_pcm "oct" oct_fields
+
+let mk_oct: int -> int -> int -> int -> int -> int -> int -> int -> oct = mk_struct "oct" oct_fields
+let mk_oct_pcm: option int -> option int -> option int -> option int -> option int -> option int -> option int -> option int -> oct_pcm_carrier = mk_struct_pcm "oct" oct_fields
+
+/// Connections for the fields of a oct
+
+let _oct_x: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "x"
+let _oct_y: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "y"
+let _oct_z: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "z"
+let _oct_w: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "w"
+let _oct_v: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "v"
+let _oct_u: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "u"
+let _oct_t: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "t"
+let _oct_s: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "s"
+
+/// View for octs
+
+let oct_view: sel_view oct_pcm oct false = struct_view "oct" oct_fields
+
+/// Explode and recombine
+
+val explode_oct' (#opened: inames)
+  (p: ref 'a oct_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` struct_view "oct" oct_fields)
+    (fun _ -> iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
+    (requires fun _ -> True)
+    (ensures fun h _ h' -> iter_and_fields oct_fields (pts_to_field "oct" oct_fields p h h'))
+
+let explode_oct' p = explode "oct" oct_fields p
+
+val explode_oct'' (#opened: inames)
+  (p: ref 'a oct_pcm)
+: SteelGhost unit opened
+    (p `pts_to_view` oct_view)
+    (fun _ ->
+      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+            ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+             (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      True)
+      // let octprop =
+      //   ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+      //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+      //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+      //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+      //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+      //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+      //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
+      // in
+      // assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
+      // assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
+      // h' (ref_focus p _oct_x `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "x" /\
+      // h' (ref_focus p _oct_y `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "y" /\
+      // h' (ref_focus p _oct_z `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "z" /\
+      // h' (ref_focus p _oct_w `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "w" /\
+      // h' (ref_focus p _oct_v `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "v" /\
+      // h' (ref_focus p _oct_u `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "u" /\
+      // h' (ref_focus p _oct_t `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "t" /\
+      // h' (ref_focus p _oct_s `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "s")
+
+let oct_unfold_iter_star_fields p
+: Lemma
+    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
+     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
+= assert_norm (
+    iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
+     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
+
+#restart-solver
+#push-options "--z3rlimit 40 --query_stats"
+
+let explode_oct'' p =
+  explode "oct" oct_fields p;
+  // OOMs
+  //change_slprop_rel
+  //  (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
+  //  ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+  //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+  //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+  //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+  //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+  //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+  //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+  //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
+  //  (fun _ _ -> True)
+  //  (fun m ->
+  //    assert_norm
+  //      (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
+  //      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+  //        ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+  //         ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+  //          ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+  //           ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+  //            ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+  //             ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+  //              (ref_focus p _oct_s `pts_to_view` c_int.view))))))))));
+  oct_unfold_iter_star_fields p;
+  change_equal_slprop
+    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
+    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view))))))));
+  ()
+
+#pop-options
+
+val recombine_oct' (#opened: inames)
+  (p: ref 'a oct_pcm)
+: SteelGhost unit opened
+    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+     ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+        (ref_focus p _oct_v `pts_to_view` c_int.view)))))
+    (fun _ -> p `pts_to_view` oct_view)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let octprop =
+        ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_v `pts_to_view` c_int.view)))))
+      in
+      assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
+      assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
+      h (ref_focus p _oct_x `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "x" /\
+      h (ref_focus p _oct_y `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "y" /\
+      h (ref_focus p _oct_z `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "z" /\
+      h (ref_focus p _oct_w `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "w" /\
+      h (ref_focus p _oct_v `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "v" /\
+      h (ref_focus p _oct_u `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "u" /\
+      h (ref_focus p _oct_t `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "t" /\
+      h (ref_focus p _oct_s `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "s")
+
+#restart-solver
+#push-options "--z3rlimit 20"
+
+let recombine_oct' p =
+  oct_unfold_iter_star_fields p;
+  change_equal_slprop
+    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
+      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
+       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
+        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
+         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
+          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
+           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
+            (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
+    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p));
+  recombine "oct" oct_fields p
+
+#pop-options
+*)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 83a8a813afc..983877f5182 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -13,7 +13,21 @@ open FStar.List.Tot
 let struct_fields =
   struct_fields:list (string * typedef){Cons? struct_fields}
 
-[@@iter_unfold]
+[@@__reduce__]
+let rec mem (#a:eqtype) (x:a) (xs:list a)
+: Pure bool (requires True) (ensures fun b -> b == List.Tot.mem x xs)
+= match xs with
+  | [] -> false
+  | x' :: xs -> x = x' || x `mem` xs
+
+[@@__reduce__]
+let rec map (f: 'a -> 'b) (xs:list 'a)
+: Pure (list 'b) (requires True) (ensures fun b -> b == List.Tot.map f xs)
+= match xs with
+  | [] -> []
+  | x :: xs -> f x :: map f xs
+
+[@@__reduce__]
 let has_field_bool (fields: struct_fields) (field: string): bool =
   field `mem` map fst fields
 
@@ -24,23 +38,21 @@ let has_field (fields: struct_fields) (field: string): prop =
 let field_of (fields: struct_fields) =
   refine string (has_field fields)
 
-[@@iter_unfold]
+[@@__reduce__;iter_unfold]
 let mk_field_of (fields: struct_fields) (field: string)
 : Pure (field_of fields)
     (requires normalize_term (has_field_bool fields field) == true)
     (ensures fun field' -> field' == field)
 = field
 
-[@@iter_unfold]
-let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  assoc_mem field fields;
-  match assoc field fields with
-  | Some v -> v
-  | None -> false_elim ()
+[@@__reduce__]
+let rec get_field (fields: struct_fields) (field: field_of fields): typedef =
+  match fields with
+  | (field', td) :: fields -> if field = field' then td else get_field fields field
 
 /// A view type for structs
 
-[@@iter_unfold]
+[@@__reduce__]
 let struct_views (fields: struct_fields) (field: field_of fields)
 : sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
 = (get_field fields field).view
@@ -135,11 +147,11 @@ val struct_put_put_ne
 
 /// Similarly, a PCM for structs
 
-[@@iter_unfold]
+[@@__reduce__]
 let struct_carriers (fields: struct_fields) (field: field_of fields) =
   (get_field fields field).carrier
 
-[@@iter_unfold]
+[@@__reduce__]
 let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
 : pcm (struct_carriers fields field)
 = (get_field fields field).pcm
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index 8d55f27dd34..e987d18f990 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -4,10 +4,11 @@ open FStar.List.Tot
 open Steel.C.PCM
 open Steel.C.Ref
 open FStar.FunctionalExtensionality
+open Steel.Effect
 
 irreducible let iter_unfold = 0
 
-[@@iter_unfold]
+[@@__reduce__]
 noeq type typedef = { 
   carrier: Type0; 
   pcm: pcm carrier; 

From 0a4f7a7ef69ef69166d624def3f38648d2bef4f6 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 09:01:34 -0700
Subject: [PATCH 154/513] Merge StructLiteral.fsti with fst for now

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 415 ++++++++++++------
 .../arraystructs/Steel.C.StructLiteral.fsti   | 286 ------------
 2 files changed, 289 insertions(+), 412 deletions(-)
 delete mode 100644 examples/steel/arraystructs/Steel.C.StructLiteral.fsti

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 74ca1eaf9b4..65181e6f5cf 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -13,11 +13,86 @@ open Steel.C.Connection
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+(**** BEGIN PUBLIC *)
+
+let struct_fields =
+  struct_fields:list (string * typedef){Cons? struct_fields}
+
+[@@__reduce__]
+let rec mem (#a:eqtype) (x:a) (xs:list a)
+: Pure bool (requires True) (ensures fun b -> b == List.Tot.mem x xs)
+= match xs with
+  | [] -> false
+  | x' :: xs -> x = x' || x `mem` xs
+
+[@@__reduce__]
+let rec map (f: 'a -> 'b) (xs:list 'a)
+: Pure (list 'b) (requires True) (ensures fun b -> b == List.Tot.map f xs)
+= match xs with
+  | [] -> []
+  | x :: xs -> f x :: map f xs
+
+[@@__reduce__]
+let has_field_bool (fields: struct_fields) (field: string): bool =
+  field `mem` map fst fields
+
+[@@iter_unfold]
+let has_field (fields: struct_fields) (field: string): prop =
+  has_field_bool fields field == true
+
+let field_of (fields: struct_fields) =
+  refine string (has_field fields)
+
+[@@__reduce__;iter_unfold]
+let mk_field_of (fields: struct_fields) (field: string)
+: Pure (field_of fields)
+    (requires normalize_term (has_field_bool fields field) == true)
+    (ensures fun field' -> field' == field)
+= field
+
+[@@__reduce__]
+let rec get_field (fields: struct_fields) (field: field_of fields): typedef =
+  match fields with
+  | (field', td) :: fields -> if field = field' then td else get_field fields field
+
+/// A view type for structs
+
+[@@__reduce__]
+let struct_views (fields: struct_fields) (field: field_of fields)
+: sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
+= (get_field fields field).view
+
 let struct_view_types (fields: struct_fields) (field: field_of fields) =
   (get_field fields field).view_type
 
+val struct (tag: string) (fields: struct_fields): Type0
+(**** END PUBLIC *)
+
 let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
 
+(**** BEGIN PUBLIC *)
+let rec list_fn (dom: list Type) (cod: Type) = match dom with
+  | [] -> cod
+  | d :: dom -> d -> list_fn dom cod
+
+let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
+  | [] -> f g <: [] `list_fn` 'b
+  | d :: dom' ->
+    let g: d -> dom' `list_fn` 'a = g in
+    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
+
+let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
+
+let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
+  map struct_field_view_type fields
+
+let mk_struct_ty (tag: string) (fields: struct_fields): Type =
+  mk_struct_ty_dom tag fields `list_fn` struct tag fields
+
+/// A struct literal
+val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
+(**** END PUBLIC *)
+
 let rec mk_struct (tag: string) (fields: struct_fields)
 : mk_struct_ty tag fields
 = match fields with
@@ -32,6 +107,73 @@ let rec mk_struct (tag: string) (fields: struct_fields)
     in
     list_fn_map lift_struct f
 
+(**** BEGIN PUBLIC *)
+/// Reading a struct field
+val struct_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (get_field fields field).view_type
+
+/// Writing a struct field
+val struct_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).view_type)
+: struct tag fields
+
+/// For a fixed field name, struct_get and struct_put form a lens
+
+val struct_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).view_type)
+: Lemma (struct_put x field v `struct_get` field == v)
+  [SMTPat (struct_put x field v `struct_get` field)]
+
+val struct_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+: Lemma (struct_put x field (x `struct_get` field) == x)
+  [SMTPat (struct_put x field (x `struct_get` field))]
+
+val struct_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v w: (get_field fields field).view_type)
+: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
+  [SMTPat (struct_put (struct_put x field v) field w)]
+
+/// struct_get/struct_put pairs for different fields don't interfere with each other
+
+val struct_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (get_field fields field1).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
+  [SMTPat (struct_put x field1 v `struct_get` field2)]
+  
+val struct_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (v: (get_field fields field1).view_type)
+  (field2: field_of fields)
+  (w: (get_field fields field2).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_put (struct_put x field1 v) field2 w ==
+      struct_put (struct_put x field2 w) field1 v)
+(**** END PUBLIC *)
+
 let struct_get x field = x field
 
 let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
@@ -51,141 +193,38 @@ let struct_put_put_ne x field1 v field2 w =
     struct_put (struct_put x field1 v) field2 w `feq`
     struct_put (struct_put x field2 w) field1 v)
 
-(*
-define attribute on mk_struct_view_type, etc..
-
-mk_struct_view': fields:list (string * _) ->
-  norm [delta_attr ..; delta Fstar.list.map; ..] .. (mk_struct_view_type fields ..)
-  (See FStar.Pervasives.fsti)
-
-to translate t
-
-  typedef_t: typedef t = { ... }
-
-to translate struct tag { S s; ... }
-
-  assume val struct (tag: string) (fields: list (string * typedef)): Type
-  assume val mk_struct_typedef (tag: string) (fields: list (string * typedef)):
-    typedef (struct tag ["s", typedef_S; ..))
-  
-  typedef_struct_tag: typedef (struct "tag" ["s", typedef_S; ..]) =
-     mk_struct_typedef "tag" ["s", typedef_S; ..]
-
-to translate struct loop { struct loop *again; }
-
-// Done (assuming can store pointers in heap)
-  carrier: Type0; 
-  pcm: pcm carrier; 
-
-view_type = {loop: ref struct_loop_carrier struct_loop_pcm}
-
-mk_view_type
-  (carrier: Type0)
-  (pcm: pcm carrier)
--> view_type : {loop: ref struct_loop_carrier struct_loop_pcm}
-
-mk_rec_typedef:
-  (carrier: Type0)
-  (pcm: pcm carrier)
--> t:typedef (mk_view_type carrier pcm) { t.carrier == carrier /\ t.pcm == pcm}
-
-noeq type typedef = { 
-
-// _
-  view_type: Type0; 
-
-// Should be fine
-  can_view_unit: bool; 
-  view: sel_view pcm view_type can_view_unit; 
-} 
+(**** BEGIN PUBLIC *)
+/// Similarly, a PCM for structs
 
-  typedef_struct_loop_f (recur:typedef)
-  : typedef (struct "loop" ["again", ref_typedef recur.carrier recur.pcm])
-  = mk_struct_typedef "loop" ["again", ref_typedef recur.carrier recur.pcm]
-
-  typedef_struct_loop
-  : typedef (struct "loop"
-      ["again",
-       ref_typedef
-         typedef_struct_loop.carrier
-         typedef_struct_loop.pcm])
-  = typedef_struct_loop_f typedef_struct_loop
-
-*)
-
-/// TODO Would be nice to have somtehing like this but proofs get tricky
-
-/// struct_put and struct_get are sound w.r.t. a model of structs as n-tuples
-
-(* BEGIN public *)
+[@@__reduce__]
+let struct_carriers (fields: struct_fields) (field: field_of fields) =
+  (get_field fields field).carrier
 
-let rec list_fn_args (dom: list Type) = match dom with
-  | [] -> unit
-  | d :: dom -> d & list_fn_args dom
+[@@__reduce__]
+let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
+: pcm (struct_carriers fields field)
+= (get_field fields field).pcm
 
-let rec list_apply #dom #b (f: dom `list_fn` b) (xs: list_fn_args dom): b = match dom with
-  | [] -> f
-  | a :: dom ->
-    let (x, xs): a & list_fn_args dom = xs in
-    let f: a -> dom `list_fn` b = f in
-    f x `list_apply` xs
+val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+(*** END PUBLIC *)
 
-let rec struct_get_model
-  (#tag: string) (#fields: struct_fields) 
-  (vs: list_fn_args (mk_struct_ty_dom tag fields))
-  (field: field_of fields)
-: (get_field fields field).view_type
-= match fields with
-  | [] -> assert false
-  | (field', td) :: fields ->
-    let (v, vs): td.view_type & list_fn_args (mk_struct_ty_dom tag fields) = vs in
-    if field = field' then v else struct_get_model vs field
-
-let rec struct_put_model
-  (#tag: string) (#fields: struct_fields) 
-  (vs: list_fn_args (mk_struct_ty_dom tag fields))
-  (field: field_of fields)
-  (v: (get_field fields field).view_type)
-: list_fn_args (mk_struct_ty_dom tag fields)
-= match fields with
-  | [] -> vs
-  | (field', td) :: fields ->
-    let (v', vs): td.view_type & list_fn_args (mk_struct_ty_dom tag fields) = vs in
-    if field = field' then (v, vs) else (v', struct_put_model vs field v)
+let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
 
-(* END public *)
+let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
 
-val struct_get_sound
-  (#tag: string) (#fields: struct_fields) 
-  (vs: list_fn_args (mk_struct_ty_dom tag fields))
-  (field: field_of fields)
-: Lemma (
-    (mk_struct tag fields `list_apply` vs) `struct_get` field ==
-    struct_get_model vs field)
+(**** BEGIN PUBLIC *)
+let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
 
-(*
-let rec struct_get_sound #tag #fields vs field : Lemma (ensures
-    (mk_struct tag fields `list_apply` vs) `struct_get` field ==
-    struct_get_model vs field) (decreases fields) = match fields with
-  | [] -> ()
-  | (field', td) :: fields ->
-    let (v, vs): td.view_type & list_fn_args (mk_struct_ty_dom tag fields) = vs in
-    let field: field_of ((field', td) :: fields) = field in
-    if field = field' then begin
-      let f = mk_struct tag ((field', td) :: fields) in
-      assert ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) f (v, vs)) `struct_get` field ==
-        begin
-          let (x, xs): (struct_field_view_type (field', td) & list_fn_args (mk_struct_ty_dom tag fields)) = (v, vs) in
-          let f: struct_field_view_type (field', td) -> (mk_struct_ty_dom tag fields `list_fn` struct tag fields) = admit() in
-          f x `list_apply` xs
-        end);
-      assume ((list_apply #(mk_struct_ty_dom tag ((field', td) :: fields)) (mk_struct tag ((field', td) :: fields)) (v, vs)) `struct_get` field == v)
-    end else admit()//struct_get_sound #tag #fields vs field
-    *)
+let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
+  map struct_field_carrier fields
 
-let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
+let mk_struct_pcm_ty (tag: string) (fields: struct_fields): Type =
+  mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
 
-let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
+/// A struct PCM carrier literal
+val mk_struct_pcm (tag: string) (fields: struct_fields): mk_struct_pcm_ty tag fields
+(**** END PUBLIC *)
 
 let rec mk_struct_pcm (tag: string) (fields: struct_fields)
 : mk_struct_pcm_ty tag fields
@@ -201,6 +240,78 @@ let rec mk_struct_pcm (tag: string) (fields: struct_fields)
     in
     list_fn_map lift_struct f
 
+(**** BEGIN PUBLIC *)
+
+/// Reading a pcm_struct_carrier field
+val struct_pcm_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields) (field: field_of fields)
+: (get_field fields field).carrier
+
+/// Writing a struct_pcm_carrier field
+val struct_pcm_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: struct_pcm_carrier tag fields
+
+/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
+
+val struct_pcm_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
+  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
+
+val struct_pcm_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
+  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
+
+val struct_pcm_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v w: (get_field fields field).carrier)
+: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
+  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
+
+/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
+
+val struct_pcm_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (get_field fields field1).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
+  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
+  
+val struct_pcm_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (v: (get_field fields field1).carrier)
+  (field2: field_of fields)
+  (w: (get_field fields field2).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
+      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+/// View a struct_pcm_carrier as a struct
+val struct_view (tag: string) (fields: struct_fields)
+: sel_view (struct_pcm tag fields) (struct tag fields) false
+(**** END PUBLIC *)
+
 let struct_pcm_get x field = x field
 
 let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
@@ -219,7 +330,58 @@ let struct_pcm_put_put_ne x field1 v field2 w =
    assert (
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+     
+(**** BEGIN PUBLIC *)
+// /// View a struct_pcm_carrier as a struct
+// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields{normalize_term (fields' \subset fields) == true})
+// : sel_view (struct_pcm tag fields) (struct tag fields') false
+// 
+// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields)
+// : sel_view (struct_pcm tag fields) (struct tag (normalize (fields - fields'))) false
+// 
+// struct_view_convert #opened
+//   (v: struct_view tag fields fields'1)
+// : SteelGhost (struct_view tag fields fields'2) opened
+//     (p `pts_to_view` v)
+//     (fun w -> (p `pts_to_view` w))
+//     (requires fun _ -> normalize (fields - fields'1 == fields - fields'2))
+//     (ensures fun h w h' -> forall field. field in (fields - fields'1) ==>
+//        h (p `pts_to_view` v) `struct_get` field == 
+//        h' (p `pts_to_view` w) `struct_get` field)
+// 
+// struct_view_convert
+//   (v: struct_view tag fields fields'1)
+// : Pure (struct_view tag fields fields'2)
+//     (requires normalize (fields - fields'1 == fields - fields'2))
+//     (ensures fun w -> True)
+//
+// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields) (fields_fields': struct_fields) (heq: squash (fields_fields' == normalize_term (fields - fields')))
+// : sel_view (struct_pcm tag fields) (struct tag fields_fields') false
+
+// struct_view tag fields fields' (_ by (T.norm _; T.trefl ()))
+
+/// Typedef for struct from typedefs for its fields
+(*
+let typedef_struct (tag: string) (fields: struct_fields): typedef = {
+  carrier = struct_pcm_carrier tag fields; 
+  pcm = struct_pcm tag fields;
+  view_type = struct tag fields;
+  view = struct_view tag fields;
+}
+*)
 
+/// Connections for fields of structs
+
+(*
+val struct_field
+  (tag: string) (fields: struct_fields) (field: field_of fields)
+: connection (struct_pcm tag fields) (struct_pcms tag fields field)
+*)
+
+/// Explode and recombine
+(**** END PUBLIC *)
+
+(*
 let field_views (tag: string) (fields: struct_fields) (field: field_of fields)
 : sel_view (struct_pcms tag fields field) (struct_view_types fields field) false
 = (get_field fields field).view
@@ -284,6 +446,7 @@ let struct_view tag fields = {
 }
 
 let struct_field tag fields field = struct_field (struct_pcms tag fields) field
+*)
 
 /// TODO move and dedup with Steel.C.Ptr.fst
 
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
deleted file mode 100644
index 983877f5182..00000000000
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ /dev/null
@@ -1,286 +0,0 @@
-module Steel.C.StructLiteral
-
-open Steel.Memory
-open Steel.Effect.Common
-open Steel.Effect.Atomic
-
-open Steel.C.PCM
-open Steel.C.Typedef
-open Steel.C.Ref // for refine
-open Steel.C.Connection
-open FStar.List.Tot
-
-let struct_fields =
-  struct_fields:list (string * typedef){Cons? struct_fields}
-
-[@@__reduce__]
-let rec mem (#a:eqtype) (x:a) (xs:list a)
-: Pure bool (requires True) (ensures fun b -> b == List.Tot.mem x xs)
-= match xs with
-  | [] -> false
-  | x' :: xs -> x = x' || x `mem` xs
-
-[@@__reduce__]
-let rec map (f: 'a -> 'b) (xs:list 'a)
-: Pure (list 'b) (requires True) (ensures fun b -> b == List.Tot.map f xs)
-= match xs with
-  | [] -> []
-  | x :: xs -> f x :: map f xs
-
-[@@__reduce__]
-let has_field_bool (fields: struct_fields) (field: string): bool =
-  field `mem` map fst fields
-
-[@@iter_unfold]
-let has_field (fields: struct_fields) (field: string): prop =
-  has_field_bool fields field == true
-
-let field_of (fields: struct_fields) =
-  refine string (has_field fields)
-
-[@@__reduce__;iter_unfold]
-let mk_field_of (fields: struct_fields) (field: string)
-: Pure (field_of fields)
-    (requires normalize_term (has_field_bool fields field) == true)
-    (ensures fun field' -> field' == field)
-= field
-
-[@@__reduce__]
-let rec get_field (fields: struct_fields) (field: field_of fields): typedef =
-  match fields with
-  | (field', td) :: fields -> if field = field' then td else get_field fields field
-
-/// A view type for structs
-
-[@@__reduce__]
-let struct_views (fields: struct_fields) (field: field_of fields)
-: sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
-= (get_field fields field).view
-
-val struct (tag: string) (fields: struct_fields): Type0
-
-let rec list_fn (dom: list Type) (cod: Type) = match dom with
-  | [] -> cod
-  | d :: dom -> d -> list_fn dom cod
-
-let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
-  | [] -> f g <: [] `list_fn` 'b
-  | d :: dom' ->
-    let g: d -> dom' `list_fn` 'a = g in
-    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
-
-let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
-
-let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
-  map struct_field_view_type fields
-
-let mk_struct_ty (tag: string) (fields: struct_fields): Type =
-  mk_struct_ty_dom tag fields `list_fn` struct tag fields
-
-/// A struct literal
-val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
-
-/// Reading a struct field
-val struct_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (get_field fields field).view_type
-
-/// Writing a struct field
-val struct_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).view_type)
-: struct tag fields
-
-/// For a fixed field name, struct_get and struct_put form a lens
-
-val struct_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).view_type)
-: Lemma (struct_put x field v `struct_get` field == v)
-  [SMTPat (struct_put x field v `struct_get` field)]
-
-val struct_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-: Lemma (struct_put x field (x `struct_get` field) == x)
-  [SMTPat (struct_put x field (x `struct_get` field))]
-
-val struct_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v w: (get_field fields field).view_type)
-: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
-  [SMTPat (struct_put (struct_put x field v) field w)]
-
-/// struct_get/struct_put pairs for different fields don't interfere with each other
-
-val struct_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (get_field fields field1).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
-  [SMTPat (struct_put x field1 v `struct_get` field2)]
-  
-val struct_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field1: field_of fields)
-  (v: (get_field fields field1).view_type)
-  (field2: field_of fields)
-  (w: (get_field fields field2).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_put (struct_put x field1 v) field2 w ==
-      struct_put (struct_put x field2 w) field1 v)
-
-/// Similarly, a PCM for structs
-
-[@@__reduce__]
-let struct_carriers (fields: struct_fields) (field: field_of fields) =
-  (get_field fields field).carrier
-
-[@@__reduce__]
-let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
-: pcm (struct_carriers fields field)
-= (get_field fields field).pcm
-
-val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
-
-let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
-
-let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
-  map struct_field_carrier fields
-
-let mk_struct_pcm_ty (tag: string) (fields: struct_fields): Type =
-  mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
-
-/// A struct PCM carrier literal
-val mk_struct_pcm (tag: string) (fields: struct_fields): mk_struct_pcm_ty tag fields
-
-/// Reading a pcm_struct_carrier field
-val struct_pcm_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields) (field: field_of fields)
-: (get_field fields field).carrier
-
-/// Writing a struct_pcm_carrier field
-val struct_pcm_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).carrier)
-: struct_pcm_carrier tag fields
-
-/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
-
-val struct_pcm_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).carrier)
-: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
-  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
-
-val struct_pcm_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
-  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
-
-val struct_pcm_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v w: (get_field fields field).carrier)
-: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
-  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
-
-/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
-
-val struct_pcm_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (get_field fields field1).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
-  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
-  
-val struct_pcm_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (v: (get_field fields field1).carrier)
-  (field2: field_of fields)
-  (w: (get_field fields field2).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
-      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
-/// View a struct_pcm_carrier as a struct
-val struct_view (tag: string) (fields: struct_fields)
-: sel_view (struct_pcm tag fields) (struct tag fields) false
-
-// /// View a struct_pcm_carrier as a struct
-// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields{normalize_term (fields' \subset fields) == true})
-// : sel_view (struct_pcm tag fields) (struct tag fields') false
-// 
-// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields)
-// : sel_view (struct_pcm tag fields) (struct tag (normalize (fields - fields'))) false
-// 
-// struct_view_convert #opened
-//   (v: struct_view tag fields fields'1)
-// : SteelGhost (struct_view tag fields fields'2) opened
-//     (p `pts_to_view` v)
-//     (fun w -> (p `pts_to_view` w))
-//     (requires fun _ -> normalize (fields - fields'1 == fields - fields'2))
-//     (ensures fun h w h' -> forall field. field in (fields - fields'1) ==>
-//        h (p `pts_to_view` v) `struct_get` field == 
-//        h' (p `pts_to_view` w) `struct_get` field)
-// 
-// struct_view_convert
-//   (v: struct_view tag fields fields'1)
-// : Pure (struct_view tag fields fields'2)
-//     (requires normalize (fields - fields'1 == fields - fields'2))
-//     (ensures fun w -> True)
-//
-// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields) (fields_fields': struct_fields) (heq: squash (fields_fields' == normalize_term (fields - fields')))
-// : sel_view (struct_pcm tag fields) (struct tag fields_fields') false
-
-// struct_view tag fields fields' (_ by (T.norm _; T.trefl ()))
-
-/// Typedef for struct from typedefs for its fields
-
-let typedef_struct (tag: string) (fields: struct_fields): typedef = {
-  carrier = struct_pcm_carrier tag fields; 
-  pcm = struct_pcm tag fields;
-  view_type = struct tag fields;
-  view = struct_view tag fields;
-}
-
-/// Connections for fields of structs
-
-val struct_field
-  (tag: string) (fields: struct_fields) (field: field_of fields)
-: connection (struct_pcm tag fields) (struct_pcms tag fields field)
-
-/// Explode and recombine
-

From c941c7328e768779ac3e0931cb5dd6154594c023 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 09:54:00 -0700
Subject: [PATCH 155/513] Attempt ChurchList

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 236 ++++++++++++------
 1 file changed, 161 insertions(+), 75 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 65181e6f5cf..ceeca562eed 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -13,47 +13,139 @@ open Steel.C.Connection
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-(**** BEGIN PUBLIC *)
+open ChurchList
 
-let struct_fields =
-  struct_fields:list (string * typedef){Cons? struct_fields}
+(**** MOVE TO ChurchList *)
 
-[@@__reduce__]
-let rec mem (#a:eqtype) (x:a) (xs:list a)
-: Pure bool (requires True) (ensures fun b -> b == List.Tot.mem x xs)
+let rec list_elim
+  (xs: list 'a)
+  (motive: list 'a -> Type)
+  (base: motive [])
+  (ind:(x:'a -> xs:list 'a -> motive xs -> motive (x :: xs)))
+: motive xs
 = match xs with
-  | [] -> false
-  | x' :: xs -> x = x' || x `mem` xs
+  | [] -> base
+  | x :: xs -> ind x xs (list_elim xs motive base ind)
+
+noeq type clist (a:Type u#a): Type = {
+  raw: list a;
+  (*
+  elim:
+    motive:(list a -> Type) ->
+    base:motive [] ->
+    ind:(x:a -> xs:list a -> motive xs -> motive (x :: xs)) ->
+    Pure (motive raw) (requires True) (ensures fun res -> res == list_elim raw motive base ind);
+    *)
+    (*
+  elim:
+    #b:Type u#b -> r:(list a -> b -> prop) ->
+    base:b ->
+    ind:(x:a -> xs:list a -> ind:b ->
+      Pure b
+        (requires xs `r` ind)
+        (ensures fun res -> (x :: xs) `r` res)) ->
+    Pure b
+      (requires [] `r` base)
+      (ensures fun res -> raw `r` res);
+      *)
+}
 
-[@@__reduce__]
-let rec map (f: 'a -> 'b) (xs:list 'a)
-: Pure (list 'b) (requires True) (ensures fun b -> b == List.Tot.map f xs)
-= match xs with
-  | [] -> []
-  | x :: xs -> f x :: map f xs
+let mk_clist_elim #a (xs: list a) #b
+: r:(list a -> b -> prop) ->
+  base:b ->
+  ind:(x:a -> xs:list a -> ind:b ->
+    Pure b
+      (requires xs `r` ind)
+      (ensures fun res -> (x :: xs) `r` res)) ->
+  Pure b
+    (requires [] `r` base)
+    (ensures fun res -> xs `r` res)
+= fun r base ind -> list_elim xs (fun xs -> x:b{xs `r` x}) base (fun x xs recur -> ind x xs recur)
+
+let mk_clist (xs: list 'a) = {
+  raw = xs;
+  //elim = (fun motive base ind -> list_elim xs motive base ind);
+  elim = mk_clist_elim xs;
+}
 
-[@@__reduce__]
-let has_field_bool (fields: struct_fields) (field: string): bool =
-  field `mem` map fst fields
+#push-options "--print_universes --print_implicits"
+
+
+#push-options "--fuel 0"
+let _ =
+  let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
+  //assert (xs.elim (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+  assert (xs.elim (fun _ _ -> True) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+#pop-options
+
+let cons (x: 'a) (xs: clist 'a): clist 'a = mk_clist (x :: xs.raw)
+let nil #a : clist a = mk_clist []
+
+// TODO is it better to use Pure than return a refinement?
+
+let is_cons (xs: clist 'a): b:bool{b == Cons? xs.raw} =
+  //xs.elim (fun xs -> b:bool{b == Cons? xs}) false (fun _ _ _ -> true)
+  xs.elim (fun xs b -> b == Cons? xs) false (fun _ _ _ -> true)
+
+let is_nil (xs: clist 'a): b:bool{b == Nil? xs.raw} =
+  //xs.elim (fun xs -> b:bool{b == Nil? xs}) true (fun _ _ _ -> false)
+  xs.elim (fun xs b -> b == Nil? xs) true (fun _ _ _ -> false)
+
+(*
+Can't seem to define these in useful way due to universe issues
+
+let mem (#a:eqtype) (x:a) (xs:clist a)
+: b:bool{b == List.Tot.mem x xs.raw}
+= xs.elim (fun xs -> b:bool{b == List.Tot.mem x xs})
+    false
+    (fun x' xs x_mem_xs -> x = x' || x_mem_xs)
+
+let map (f: 'a -> 'b) (xs: clist 'a)
+: ys:clist 'b{ys.raw == List.Tot.map f xs.raw}
+= xs.elim (fun xs -> ys:clist 'b{ys.raw == List.Tot.map f xs})
+    nil
+    (fun x xs map_f_xs -> cons (f x) map_f_xs)
+*)
+
+(**** END MOVE TO ChurchList *)
+
+(**** BEGIN PUBLIC *)
+
+let struct_fields =
+  struct_fields:clist (string * typedef){is_cons struct_fields}
+
+let has_field_bool (fields: struct_fields) (field: string)
+: b:bool{b == field `mem` map fst fields.raw}
+= fields.elim
+    (fun fields -> b:bool{b == field `mem` map fst fields})
+    false
+    (fun (field', td) fields recur -> field = field' || recur)
 
-[@@iter_unfold]
 let has_field (fields: struct_fields) (field: string): prop =
   has_field_bool fields field == true
 
 let field_of (fields: struct_fields) =
   refine string (has_field fields)
 
-[@@__reduce__;iter_unfold]
-let mk_field_of (fields: struct_fields) (field: string)
-: Pure (field_of fields)
-    (requires normalize_term (has_field_bool fields field) == true)
-    (ensures fun field' -> field' == field)
-= field
+let get_field (fields: struct_fields) (field: field_of fields): typedef =
+  fields.elim (fun fields -> typedef)
+    ()
+    (fun (field', td) fields recur -> if field = field' then td else recur)
 
-[@@__reduce__]
-let rec get_field (fields: struct_fields) (field: field_of fields): typedef =
-  match fields with
-  | (field', td) :: fields -> if field = field' then td else get_field fields field
+open Steel.C.Opt
+
+let c_int: typedef = {
+  carrier = option int;
+  pcm = opt_pcm #int;
+  view_type = int;
+  view = opt_view int;
+}
+
+let point_fields = normalize_term (mk_clist ["x", c_int; "y", c_int])
+
+#push-options "--fuel 0"
+let _ : field_of point_fields = "x"
+#pop-options
 
 /// A view type for structs
 
@@ -330,58 +422,37 @@ let struct_pcm_put_put_ne x field1 v field2 w =
    assert (
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-     
-(**** BEGIN PUBLIC *)
-// /// View a struct_pcm_carrier as a struct
-// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields{normalize_term (fields' \subset fields) == true})
-// : sel_view (struct_pcm tag fields) (struct tag fields') false
-// 
-// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields)
-// : sel_view (struct_pcm tag fields) (struct tag (normalize (fields - fields'))) false
-// 
-// struct_view_convert #opened
-//   (v: struct_view tag fields fields'1)
-// : SteelGhost (struct_view tag fields fields'2) opened
-//     (p `pts_to_view` v)
-//     (fun w -> (p `pts_to_view` w))
-//     (requires fun _ -> normalize (fields - fields'1 == fields - fields'2))
-//     (ensures fun h w h' -> forall field. field in (fields - fields'1) ==>
-//        h (p `pts_to_view` v) `struct_get` field == 
-//        h' (p `pts_to_view` w) `struct_get` field)
-// 
-// struct_view_convert
-//   (v: struct_view tag fields fields'1)
-// : Pure (struct_view tag fields fields'2)
-//     (requires normalize (fields - fields'1 == fields - fields'2))
-//     (ensures fun w -> True)
-//
-// val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields) (fields_fields': struct_fields) (heq: squash (fields_fields' == normalize_term (fields - fields')))
-// : sel_view (struct_pcm tag fields) (struct tag fields_fields') false
 
-// struct_view tag fields fields' (_ by (T.norm _; T.trefl ()))
-
-/// Typedef for struct from typedefs for its fields
 (*
-let typedef_struct (tag: string) (fields: struct_fields): typedef = {
-  carrier = struct_pcm_carrier tag fields; 
-  pcm = struct_pcm tag fields;
-  view_type = struct tag fields;
-  view = struct_view tag fields;
-}
-*)
 
-/// Connections for fields of structs
-
-(*
-val struct_field
-  (tag: string) (fields: struct_fields) (field: field_of fields)
-: connection (struct_pcm tag fields) (struct_pcms tag fields field)
-*)
+/// View a struct_pcm_carrier as a struct
+val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields{normalize_term (fields' \subset fields) == true})
+: sel_view (struct_pcm tag fields) (struct tag fields') false
+
+val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields)
+: sel_view (struct_pcm tag fields) (struct tag (normalize (fields - fields'))) false
+
+struct_view_convert #opened
+  (v: struct_view tag fields fields'1)
+: SteelGhost (struct_view tag fields fields'2) opened
+    (p `pts_to_view` v)
+    (fun w -> (p `pts_to_view` w))
+    (requires fun _ -> normalize (fields - fields'1 == fields - fields'2))
+    (ensures fun h w h' -> forall field. field in (fields - fields'1) ==>
+       h (p `pts_to_view` v) `struct_get` field == 
+       h' (p `pts_to_view` w) `struct_get` field)
+
+struct_view_convert
+  (v: struct_view tag fields fields'1)
+: Pure (struct_view tag fields fields'2)
+    (requires normalize (fields - fields'1 == fields - fields'2))
+    (ensures fun w -> True)
+
+val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields) (fields_fields': struct_fields) (heq: squash (fields_fields' == normalize_term (fields - fields')))
+: sel_view (struct_pcm tag fields) (struct tag fields_fields') false
 
-/// Explode and recombine
-(**** END PUBLIC *)
+// struct_view tag fields fields' (_ by (T.norm _; T.trefl ()))
 
-(*
 let field_views (tag: string) (fields: struct_fields) (field: field_of fields)
 : sel_view (struct_pcms tag fields field) (struct_view_types fields field) false
 = (get_field fields field).view
@@ -445,7 +516,22 @@ let struct_view tag fields = {
   to_view_frame = struct_view_to_view_frame tag fields;
 }
 
+/// Connections for fields of structs
+val struct_field
+  (tag: string) (fields: struct_fields) (field: field_of fields)
+: connection (struct_pcm tag fields) (struct_pcms tag fields field)
 let struct_field tag fields field = struct_field (struct_pcms tag fields) field
+
+/// Typedef for struct from typedefs for its fields
+(*
+let typedef_struct (tag: string) (fields: struct_fields): typedef = {
+  carrier = struct_pcm_carrier tag fields; 
+  pcm = struct_pcm tag fields;
+  view_type = struct tag fields;
+  view = struct_view tag fields;
+}
+*)
+
 *)
 
 /// TODO move and dedup with Steel.C.Ptr.fst

From d8c5b3bb3245b3c8fc50c3918b2a02307d752b83 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 10:21:28 -0700
Subject: [PATCH 156/513] Impl get_field

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 108 ++++++++++++------
 1 file changed, 70 insertions(+), 38 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index ceeca562eed..74c85959725 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -17,26 +17,8 @@ open ChurchList
 
 (**** MOVE TO ChurchList *)
 
-let rec list_elim
-  (xs: list 'a)
-  (motive: list 'a -> Type)
-  (base: motive [])
-  (ind:(x:'a -> xs:list 'a -> motive xs -> motive (x :: xs)))
-: motive xs
-= match xs with
-  | [] -> base
-  | x :: xs -> ind x xs (list_elim xs motive base ind)
-
 noeq type clist (a:Type u#a): Type = {
   raw: list a;
-  (*
-  elim:
-    motive:(list a -> Type) ->
-    base:motive [] ->
-    ind:(x:a -> xs:list a -> motive xs -> motive (x :: xs)) ->
-    Pure (motive raw) (requires True) (ensures fun res -> res == list_elim raw motive base ind);
-    *)
-    (*
   elim:
     #b:Type u#b -> r:(list a -> b -> prop) ->
     base:b ->
@@ -47,10 +29,9 @@ noeq type clist (a:Type u#a): Type = {
     Pure b
       (requires [] `r` base)
       (ensures fun res -> raw `r` res);
-      *)
 }
 
-let mk_clist_elim #a (xs: list a) #b
+let mk_clist_elim (#a: Type u#a) (xs: list a) (#b: Type u#b)
 : r:(list a -> b -> prop) ->
   base:b ->
   ind:(x:a -> xs:list a -> ind:b ->
@@ -64,13 +45,11 @@ let mk_clist_elim #a (xs: list a) #b
 
 let mk_clist (xs: list 'a) = {
   raw = xs;
-  //elim = (fun motive base ind -> list_elim xs motive base ind);
   elim = mk_clist_elim xs;
 }
 
 #push-options "--print_universes --print_implicits"
 
-
 #push-options "--fuel 0"
 let _ =
   let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
@@ -78,11 +57,14 @@ let _ =
   assert (xs.elim (fun _ _ -> True) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
 #pop-options
 
+// TODO is it better to use Pure than return a refinement?
+
+(*
+Can't seem to call these without running into universe issues
+
 let cons (x: 'a) (xs: clist 'a): clist 'a = mk_clist (x :: xs.raw)
 let nil #a : clist a = mk_clist []
 
-// TODO is it better to use Pure than return a refinement?
-
 let is_cons (xs: clist 'a): b:bool{b == Cons? xs.raw} =
   //xs.elim (fun xs -> b:bool{b == Cons? xs}) false (fun _ _ _ -> true)
   xs.elim (fun xs b -> b == Cons? xs) false (fun _ _ _ -> true)
@@ -91,18 +73,15 @@ let is_nil (xs: clist 'a): b:bool{b == Nil? xs.raw} =
   //xs.elim (fun xs -> b:bool{b == Nil? xs}) true (fun _ _ _ -> false)
   xs.elim (fun xs b -> b == Nil? xs) true (fun _ _ _ -> false)
 
-(*
-Can't seem to define these in useful way due to universe issues
-
-let mem (#a:eqtype) (x:a) (xs:clist a)
-: b:bool{b == List.Tot.mem x xs.raw}
-= xs.elim (fun xs -> b:bool{b == List.Tot.mem x xs})
+let cmem (#a:eqtype) (x:a) (xs:clist a)
+: Pure bool True (fun b -> b == List.Tot.mem x xs.raw)
+= xs.elim (fun xs b -> b == List.Tot.mem x xs)
     false
     (fun x' xs x_mem_xs -> x = x' || x_mem_xs)
 
-let map (f: 'a -> 'b) (xs: clist 'a)
-: ys:clist 'b{ys.raw == List.Tot.map f xs.raw}
-= xs.elim (fun xs -> ys:clist 'b{ys.raw == List.Tot.map f xs})
+let cmap (f: 'a -> 'b) (xs: clist 'a)
+: Pure (clist 'b) True (fun ys -> ys.raw == List.Tot.map f xs.raw)
+= xs.elim (fun xs ys -> ys.raw == List.Tot.map f xs)
     nil
     (fun x xs map_f_xs -> cons (f x) map_f_xs)
 *)
@@ -112,25 +91,78 @@ let map (f: 'a -> 'b) (xs: clist 'a)
 (**** BEGIN PUBLIC *)
 
 let struct_fields =
-  struct_fields:clist (string * typedef){is_cons struct_fields}
+  struct_fields:clist u#1 u#1 (string * typedef)
 
+(*
 let has_field_bool (fields: struct_fields) (field: string)
 : b:bool{b == field `mem` map fst fields.raw}
 = fields.elim
-    (fun fields -> b:bool{b == field `mem` map fst fields})
+    (fun fields b -> b == field `mem` map fst fields)
     false
-    (fun (field', td) fields recur -> field = field' || recur)
+    (fun (field', td) fields recur ->
+      field = field' || recur)
 
 let has_field (fields: struct_fields) (field: string): prop =
   has_field_bool fields field == true
+      *)
+
+let has_field (fields: struct_fields) (field: string): prop =
+  fields.elim #prop (fun _ _ -> True)
+    False
+    (fun (field', td) fields recur -> field == field' \/ recur)
 
 let field_of (fields: struct_fields) =
   refine string (has_field fields)
 
+(*
+let elim_clist (#a:Type u#a) (xs: clist a) (#b: Type u#b)
+: r:(list a -> b -> prop) ->
+  base:b ->
+  ind:(x:a -> xs:list a -> ind:b ->
+    Pure b
+      (requires xs `r` ind)
+      (ensures fun res -> (x :: xs) `r` res)) ->
+  Pure b
+    (requires [] `r` base)
+    (ensures fun res -> xs.raw `r` res)
+= Mkclist?.elim xs
+
+let elim_clist' (xs: clist (string * typedef)) (#b: Type u#b)
+: r:(list (string * typedef) -> b -> prop) ->
+  base:b ->
+  ind:(x:(string * typedef) -> xs:list (string * typedef) -> ind:b ->
+    Pure b
+      (requires xs `r` ind)
+      (ensures fun res -> (x :: xs) `r` res)) ->
+  Pure b
+    (requires [] `r` base)
+    (ensures fun res -> xs.raw `r` res)
+= Mkclist?.elim xs
+
+let elim_clist'' (xs: clist u#1 u#1 (string * typedef))
+: r:(list (string * typedef) -> typedef -> prop) ->
+  base:typedef ->
+  ind:(x:(string * typedef) -> xs:list (string * typedef) -> ind:typedef ->
+    Pure typedef
+      (requires xs `r` ind)
+      (ensures fun res -> (x :: xs) `r` res)) ->
+  Pure typedef
+    (requires [] `r` base)
+    (ensures fun res -> xs.raw `r` res)
+= Mkclist?.elim xs
+*)
+
+assume val trivial_typedef: typedef
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  fields.elim (fun fields -> typedef)
-    ()
+  fields.elim (fun _ _ -> True) trivial_typedef
     (fun (field', td) fields recur -> if field = field' then td else recur)
+  (*
+  elim_clist fields #typedef (admit())//(fun _ _ -> True)
+    (admit())
+    (admit())
+    //trivial_typedef
+    //(fun (field', td) fields recur -> if field = field' then td else recur)
+    *)
 
 open Steel.C.Opt
 

From dee66d1bad9c25dd3464af0b93cd41800a5e66b1 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 10:29:42 -0700
Subject: [PATCH 157/513] Impl get_field with alternative formulation of
 churchlist

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 74c85959725..5c66e82b6b8 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -179,6 +179,58 @@ let point_fields = normalize_term (mk_clist ["x", c_int; "y", c_int])
 let _ : field_of point_fields = "x"
 #pop-options
 
+(**** MOVE TO ChurchList *)
+
+noeq type clist' (a:Type u#a): Type = {
+  raw: list a;
+  elim:
+    b:(list a -> Type u#b) ->
+    base:b [] ->
+    (x:a -> xs:list a -> b xs -> b (x :: xs)) ->
+    b raw;
+}
+
+let rec list_elim (xs: list 'a)
+  (b:(list 'a -> Type))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: b xs
+= match xs with
+  | [] -> base
+  | x :: xs -> ind x xs (list_elim xs b base ind)
+
+let mk_clist' (xs: list 'a) = {
+  raw = xs;
+  elim = list_elim xs;
+}
+
+#push-options "--print_universes --print_implicits"
+
+#push-options "--fuel 0"
+let _ =
+  let xs = normalize_term (mk_clist' [1; 2; 3; 4]) in
+  assert (xs.elim (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+#pop-options
+
+(**** END MOVE TO ChurchList *)
+
+(**** BEGIN PUBLIC *)
+
+let struct_fields' =
+  clist' u#1 u#1 (string * typedef)
+
+let has_field' (fields: struct_fields') (field: string): prop =
+  fields.elim (fun _ -> prop)
+    False
+    (fun (field', td) fields recur -> field == field' \/ recur)
+
+let field_of' (fields: struct_fields') =
+  refine string (has_field' fields)
+
+let get_field' (fields: struct_fields') (field: field_of' fields): typedef =
+  fields.elim (fun _ -> typedef) trivial_typedef
+    (fun (field', td) fields recur -> if field = field' then td else recur)
+
 /// A view type for structs
 
 [@@__reduce__]

From a08c165f666bfd4d1e87612c7c5e5b855f7158d0 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 14:38:18 -0700
Subject: [PATCH 158/513] Sort out clist universe details

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 408 ++++++++++--------
 1 file changed, 223 insertions(+), 185 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 5c66e82b6b8..ab62a217beb 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -17,223 +17,256 @@ open ChurchList
 
 (**** MOVE TO ChurchList *)
 
+let rec list_elim (xs: list 'a)
+  (b:(list 'a -> Type))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: b xs
+= match xs with
+  | [] -> base
+  | x :: xs -> ind x xs (list_elim xs b base ind)
+
 noeq type clist (a:Type u#a): Type = {
   raw: list a;
+  //elim:
+  //  b:(list a -> Type u#b) ->
+  //  base:b [] ->
+  //  ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
+  //  Pure (b raw) True (ensures fun y -> y == list_elim raw b base ind);
   elim:
-    #b:Type u#b -> r:(list a -> b -> prop) ->
-    base:b ->
-    ind:(x:a -> xs:list a -> ind:b ->
-      Pure b
-        (requires xs `r` ind)
-        (ensures fun res -> (x :: xs) `r` res)) ->
-    Pure b
-      (requires [] `r` base)
-      (ensures fun res -> raw `r` res);
+    b:(list a -> Type u#b) ->
+    base:b [] ->
+    ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
+    b raw;
+  elim_prf:
+    b:(list a -> Type u#b) ->
+    base:b [] ->
+    ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
+    Lemma (elim b base ind == list_elim raw b base ind);
 }
 
-let mk_clist_elim (#a: Type u#a) (xs: list a) (#b: Type u#b)
-: r:(list a -> b -> prop) ->
-  base:b ->
-  ind:(x:a -> xs:list a -> ind:b ->
-    Pure b
-      (requires xs `r` ind)
-      (ensures fun res -> (x :: xs) `r` res)) ->
-  Pure b
-    (requires [] `r` base)
-    (ensures fun res -> xs `r` res)
-= fun r base ind -> list_elim xs (fun xs -> x:b{xs `r` x}) base (fun x xs recur -> ind x xs recur)
+let elim_prf' #a (xs: clist a)
+  (b:(list a -> Type)) (base:b [])
+  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
+: Lemma (xs.elim b base ind == list_elim xs.raw b base ind)
+  [SMTPat (xs.elim b base ind)]
+= xs.elim_prf b base ind
 
 let mk_clist (xs: list 'a) = {
   raw = xs;
-  elim = mk_clist_elim xs;
+  elim = list_elim xs;
+  elim_prf = (fun _ _ _ -> ());
 }
 
+(*
+let clist_elim_prf (#a: Type u#a) (xs: clist u#a u#b a)
+: Lemma (xs.elim == list_elim xs.raw) [SMTPat (xs.elim)]
+= let _ = xs.elim_prf in () // TODO bug in Z3?
+*)
+
 #push-options "--print_universes --print_implicits"
 
 #push-options "--fuel 0"
 let _ =
   let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
-  //assert (xs.elim (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
-  assert (xs.elim (fun _ _ -> True) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+  assert (xs.elim (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
 #pop-options
 
-// TODO is it better to use Pure than return a refinement?
-
-(*
-Can't seem to call these without running into universe issues
+module U = FStar.Universe
+
+let raise_clist_elim (#a: Type u#a) (xs: clist u#a u#(max b c) a)
+  (b:(list a -> Type u#c))
+  (base: b [])
+  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
+: b xs.raw
+= U.downgrade_val
+    (xs.elim (fun xs -> U.raise_t (b xs))
+      (U.raise_val base)
+      (fun x xs recur -> U.raise_val (ind x xs (U.downgrade_val recur))))
+
+let rec raise_list_elim_ok (#a: Type u#a) (xs: list a)
+  (b:(list a -> Type u#c))
+  (base: b [])
+  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
+: Lemma (list_elim xs b base ind ==
+    U.downgrade_val
+      (list_elim xs (fun xs -> U.raise_t u#c u#b (b xs))
+        (U.raise_val base)
+        (fun x xs recur -> U.raise_val (ind x xs (U.downgrade_val recur)))))
+= match xs with
+  | [] -> ()
+  | _ :: xs -> raise_list_elim_ok xs b base ind
+
+let raise_clist_elim_ok (#a: Type u#a) (xs: clist u#a u#(max b c) a)
+  (b:(list a -> Type u#c))
+  (base: b [])
+  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
+: Lemma (raise_clist_elim xs b base ind == list_elim xs.raw b base ind)
+  [SMTPat (raise_clist_elim xs b base ind)]
+= raise_list_elim_ok xs.raw b base ind
+
+let raise_clist (#a: Type u#a) (xs: clist u#a u#(max b c) a)
+: clist u#a u#c a
+= {raw = xs.raw; elim = raise_clist_elim xs; elim_prf = (fun _ _ _ -> ())}
+
+let nil (#a: Type u#a): clist u#a u#b a = {
+  raw = [];
+  elim = list_elim [];
+  elim_prf = (fun _ _ _ -> ());
+}
 
-let cons (x: 'a) (xs: clist 'a): clist 'a = mk_clist (x :: xs.raw)
-let nil #a : clist a = mk_clist []
+let cons (#a: Type u#a) (x: a) (xs: clist u#a u#b a): clist u#a u#b a = {
+  raw = x :: xs.raw;
+  elim = list_elim (x :: xs.raw);
+  elim_prf = (fun _ _ _ -> ());
+}
 
-let is_cons (xs: clist 'a): b:bool{b == Cons? xs.raw} =
-  //xs.elim (fun xs -> b:bool{b == Cons? xs}) false (fun _ _ _ -> true)
-  xs.elim (fun xs b -> b == Cons? xs) false (fun _ _ _ -> true)
+let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a): bool
+= raise_clist_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
 
-let is_nil (xs: clist 'a): b:bool{b == Nil? xs.raw} =
-  //xs.elim (fun xs -> b:bool{b == Nil? xs}) true (fun _ _ _ -> false)
-  xs.elim (fun xs b -> b == Nil? xs) true (fun _ _ _ -> false)
+let cmem_ok (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a)
+: Lemma (cmem x xs == mem x xs.raw)
+= let rec aux (xs: list a)
+  : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
+  = match xs with [] -> () | x :: xs -> aux xs
+  in aux xs.raw
 
-let cmem (#a:eqtype) (x:a) (xs:clist a)
-: Pure bool True (fun b -> b == List.Tot.mem x xs.raw)
-= xs.elim (fun xs b -> b == List.Tot.mem x xs)
-    false
-    (fun x' xs x_mem_xs -> x = x' || x_mem_xs)
+let cmap (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
+: clist u#b u#c b
+= xs.elim (fun _ -> clist u#b u#c b) (nil u#b u#c) (fun x xs recur -> cons u#b u#c #b (f x) recur)
 
-let cmap (f: 'a -> 'b) (xs: clist 'a)
-: Pure (clist 'b) True (fun ys -> ys.raw == List.Tot.map f xs.raw)
-= xs.elim (fun xs ys -> ys.raw == List.Tot.map f xs)
-    nil
-    (fun x xs map_f_xs -> cons (f x) map_f_xs)
-*)
+let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
+: Lemma ((cmap f xs).raw == map f xs.raw)
+  [SMTPat (cmap f xs)]
+= let rec aux (xs: list a)
+  : Lemma (
+      (list_elim xs (fun _ -> clist u#b u#c b) (nil u#b u#c)
+        (fun x xs recur -> cons u#b u#c #b (f x) recur))
+      .raw == map f xs)
+  = match xs with [] -> () | x :: xs -> aux xs
+  in aux xs.raw
 
 (**** END MOVE TO ChurchList *)
 
 (**** BEGIN PUBLIC *)
 
-let struct_fields =
-  struct_fields:clist u#1 u#1 (string * typedef)
+let struct_fields = clist u#1 u#1 (string * typedef)
 
-(*
-let has_field_bool (fields: struct_fields) (field: string)
-: b:bool{b == field `mem` map fst fields.raw}
-= fields.elim
-    (fun fields b -> b == field `mem` map fst fields)
+let has_field (fields: struct_fields) (field: string): bool =
+  raise_clist_elim fields (fun _ -> bool)
     false
-    (fun (field', td) fields recur ->
-      field = field' || recur)
-
-let has_field (fields: struct_fields) (field: string): prop =
-  has_field_bool fields field == true
-      *)
-
-let has_field (fields: struct_fields) (field: string): prop =
-  fields.elim #prop (fun _ _ -> True)
-    False
-    (fun (field', td) fields recur -> field == field' \/ recur)
-
-let field_of (fields: struct_fields) =
-  refine string (has_field fields)
-
-(*
-let elim_clist (#a:Type u#a) (xs: clist a) (#b: Type u#b)
-: r:(list a -> b -> prop) ->
-  base:b ->
-  ind:(x:a -> xs:list a -> ind:b ->
-    Pure b
-      (requires xs `r` ind)
-      (ensures fun res -> (x :: xs) `r` res)) ->
-  Pure b
-    (requires [] `r` base)
-    (ensures fun res -> xs.raw `r` res)
-= Mkclist?.elim xs
-
-let elim_clist' (xs: clist (string * typedef)) (#b: Type u#b)
-: r:(list (string * typedef) -> b -> prop) ->
-  base:b ->
-  ind:(x:(string * typedef) -> xs:list (string * typedef) -> ind:b ->
-    Pure b
-      (requires xs `r` ind)
-      (ensures fun res -> (x :: xs) `r` res)) ->
-  Pure b
-    (requires [] `r` base)
-    (ensures fun res -> xs.raw `r` res)
-= Mkclist?.elim xs
-
-let elim_clist'' (xs: clist u#1 u#1 (string * typedef))
-: r:(list (string * typedef) -> typedef -> prop) ->
-  base:typedef ->
-  ind:(x:(string * typedef) -> xs:list (string * typedef) -> ind:typedef ->
-    Pure typedef
-      (requires xs `r` ind)
-      (ensures fun res -> (x :: xs) `r` res)) ->
-  Pure typedef
-    (requires [] `r` base)
-    (ensures fun res -> xs.raw `r` res)
-= Mkclist?.elim xs
-*)
+    (fun (field', td) fields recur -> field = field' || recur)
+
+let field_of (fields: struct_fields) = field:string{has_field fields field == true}
+
+let assoc'_motive (#a:eqtype) (#b: Type u#b): list (a * b) -> Type u#b =
+  (fun xs -> x:a -> Pure (option b) True (ensures fun y -> y == List.Tot.assoc x xs))
+
+let assoc'_base
+: assoc'_motive []
+= fun _ -> None
+
+let assoc'_ind (#a:eqtype) #b (x:a * b) (xs:list (a * b)) (recur: assoc'_motive xs)
+: assoc'_motive (x :: xs)
+= fun x' -> let (x, v) = x in if x = x' then Some v else recur x'
+
+//let assoc'_motive (#a:eqtype) (x:a) (xs:clist (a * 'b)) =
+//  (fun xs -> x:a -> Pure (option 'b) True (ensures fun y -> y == List.Tot.assoc x xs))
+
+let assoc' (#a:eqtype) (#b: Type u#b) (x:a) (xs:clist u#b u#(max b c) (a * b))
+: Pure (option b) True (ensures fun y -> y == List.Tot.assoc x xs.raw)
+= raise_clist_elim xs assoc'_motive assoc'_base assoc'_ind x
+
+let weak_assoc'_motive (#a:eqtype) (#b: Type u#b): list (a * b) -> Type u#b =
+  (fun xs -> x:a -> option b)
+
+let weak_assoc'_base: weak_assoc'_motive [] = (fun _ -> None)
+let weak_assoc'_ind (#a:eqtype) #b (x:a * b) (xs:list (a * b)) (recur: weak_assoc'_motive xs)
+: weak_assoc'_motive (x :: xs)
+= fun x' -> let (x, v) = x in if x = x' then Some v else recur x'
+
+let weak_assoc' (#a:eqtype) (#b: Type u#b) (x:a) (xs:clist (a * b))
+: option b
+= xs.elim weak_assoc'_motive weak_assoc'_base weak_assoc'_ind x
+
+let rec assoc_weak_eq (#a:eqtype) (x:a) (xs:list (a * 'b))
+: Lemma ((list_elim xs
+    assoc'_motive
+    assoc'_base
+    assoc'_ind
+        x == list_elim xs
+    weak_assoc'_motive
+    weak_assoc'_base
+    weak_assoc'_ind
+    x))
+= match xs with
+  | [] -> ()
+  | _ :: xs -> assoc_weak_eq x xs
+
+let assoc_weak_eq' (#a:eqtype) (x:a) (xs:clist (a * 'b))
+: Lemma (assoc' x xs == weak_assoc' x xs)
+= assoc_weak_eq x xs.raw
+
+//= match xs.raw with
+//  | [] -> ()
+//  | x :: xs -> 
+//= xs.elim (fun xs' -> xs_clist:clist (a * 'b) ->
+//      Lemma (requires xs' == xs_clist.raw) (ensures assoc' x xs_clist == weak_assoc' x xs_clist))
+//      (fun _ -> ())
+//      (fun (x, v) xs recur x' -> if x = x' then () else recur x')
+//      x
+
+// requires prefix 
+//   assoc' x (prefix @ xs) == weak_assoc' x (prefix @ xs)
+// ensures
+// let rec assoc_weak_eq (#a:eqtype) (x:a) (xs:clist (a * 'b))
+// : Lemma (assoc' x xs == weak_assoc' x xs)
+// //= match xs.raw with
+// //  | [] -> ()
+// //  | x :: xs -> 
+// = xs.elim (fun xs' -> xs_clist:clist (a * 'b) ->
+//       Lemma (requires xs' == xs_clist.raw) (ensures assoc' x xs_clist == weak_assoc' x xs_clist))
+//       (fun _ -> ())
+//       (fun (x, v) xs recur x' -> if x = x' then () else recur x')
+//       x
+// 
+//     Pure (b raw) True (ensures fun y -> y == list_elim raw b base ind);
 
 assume val trivial_typedef: typedef
+assume val nontrivial_typedef: typedef
+
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  fields.elim (fun _ _ -> True) trivial_typedef
+  fields.elim (fun fields -> typedef) trivial_typedef
     (fun (field', td) fields recur -> if field = field' then td else recur)
-  (*
-  elim_clist fields #typedef (admit())//(fun _ _ -> True)
-    (admit())
-    (admit())
-    //trivial_typedef
-    //(fun (field', td) fields recur -> if field = field' then td else recur)
-    *)
-
-open Steel.C.Opt
 
-let c_int: typedef = {
-  carrier = option int;
-  pcm = opt_pcm #int;
-  view_type = int;
-  view = opt_view int;
-}
-
-let point_fields = normalize_term (mk_clist ["x", c_int; "y", c_int])
-
-#push-options "--fuel 0"
-let _ : field_of point_fields = "x"
-#pop-options
-
-(**** MOVE TO ChurchList *)
-
-noeq type clist' (a:Type u#a): Type = {
-  raw: list a;
-  elim:
-    b:(list a -> Type u#b) ->
-    base:b [] ->
-    (x:a -> xs:list a -> b xs -> b (x :: xs)) ->
-    b raw;
-}
-
-let rec list_elim (xs: list 'a)
-  (b:(list 'a -> Type))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: b xs
-= match xs with
-  | [] -> base
-  | x :: xs -> ind x xs (list_elim xs b base ind)
-
-let mk_clist' (xs: list 'a) = {
-  raw = xs;
-  elim = list_elim xs;
-}
-
-#push-options "--print_universes --print_implicits"
+(**** END PUBLIC *)
 
 #push-options "--fuel 0"
 let _ =
-  let xs = normalize_term (mk_clist' [1; 2; 3; 4]) in
-  assert (xs.elim (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+  let test_fields = normalize_term (mk_clist [
+    "a", trivial_typedef;
+    "b", trivial_typedef;
+    "c", trivial_typedef;
+    "d", trivial_typedef;
+    "e", trivial_typedef;
+    "f", trivial_typedef;
+    "g", trivial_typedef;
+    "h", trivial_typedef;
+    "i", trivial_typedef;
+    "j", nontrivial_typedef;
+  ]) in
+  assert (has_field test_fields "e" == true);
+  assert (get_field test_fields "j" == nontrivial_typedef);
+  assert (assoc' "j" test_fields == Some nontrivial_typedef);
+  assert (assoc' "k" test_fields == None);
+  assert (weak_assoc' "j" test_fields == Some nontrivial_typedef);
+  assert (weak_assoc' "k" test_fields == None)
 #pop-options
 
-(**** END MOVE TO ChurchList *)
-
 (**** BEGIN PUBLIC *)
 
-let struct_fields' =
-  clist' u#1 u#1 (string * typedef)
-
-let has_field' (fields: struct_fields') (field: string): prop =
-  fields.elim (fun _ -> prop)
-    False
-    (fun (field', td) fields recur -> field == field' \/ recur)
-
-let field_of' (fields: struct_fields') =
-  refine string (has_field' fields)
-
-let get_field' (fields: struct_fields') (field: field_of' fields): typedef =
-  fields.elim (fun _ -> typedef) trivial_typedef
-    (fun (field', td) fields recur -> if field = field' then td else recur)
-
 /// A view type for structs
 
-[@@__reduce__]
 let struct_views (fields: struct_fields) (field: field_of fields)
 : sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
 = (get_field fields field).view
@@ -242,34 +275,39 @@ let struct_view_types (fields: struct_fields) (field: field_of fields) =
   (get_field fields field).view_type
 
 val struct (tag: string) (fields: struct_fields): Type0
+
 (**** END PUBLIC *)
 
 let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
 
 (**** BEGIN PUBLIC *)
-let rec list_fn (dom: list Type) (cod: Type) = match dom with
-  | [] -> cod
-  | d :: dom -> d -> list_fn dom cod
 
-let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
-  | [] -> f g <: [] `list_fn` 'b
-  | d :: dom' ->
-    let g: d -> dom' `list_fn` 'a = g in
-    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
+let list_fn (dom: list (Type u#a)) (cod: Type u#a): Type u#a =
+  list_elim dom (fun _ -> Type) cod (fun d dom recur -> d -> recur)
+  
+let clist_fn (dom: clist u#_ u#(1 + a) (Type u#a)) (cod: Type u#a): Type u#a =
+  dom.elim (fun _ -> Type u#a) cod (fun d dom recur -> d -> recur)
+
+let clist_fn_map (#a: Type u#a) (#b: Type u#a)
+  (#dom: clist u#_ u#(1 + a) (Type u#a)) (f: a -> b)
+: dom `clist_fn` a -> dom `clist_fn` b
+= raise_clist_elim u#_ u#(1 + a) u#a dom (fun dom -> dom `list_fn` a -> dom `list_fn` b)
+    f
+    (fun d dom recur g x -> recur (g x))
 
 let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
 
-let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
+let mk_struct_ty_dom (tag: string) (fields: clist (string * typedef)): clist Type =
   map struct_field_view_type fields
 
 let mk_struct_ty (tag: string) (fields: struct_fields): Type =
-  mk_struct_ty_dom tag fields `list_fn` struct tag fields
+  mk_struct_ty_dom tag fields.raw `list_fn` struct tag fields
 
 /// A struct literal
 val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
 (**** END PUBLIC *)
 
-let rec mk_struct (tag: string) (fields: struct_fields)
+let mk_struct (tag: string) (fields: struct_fields)
 : mk_struct_ty tag fields
 = match fields with
   | [(field, td)] -> fun (x:td.view_type) -> on_dom _ (fun field -> x <: struct_view_types fields field)

From f452b419a4c6a9e6699504cfce717e630cbde6ad Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 14:54:01 -0700
Subject: [PATCH 159/513] Tidy

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 122 +-----------------
 1 file changed, 2 insertions(+), 120 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index ab62a217beb..e3e15f62fcc 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -105,47 +105,6 @@ let raise_clist_elim_ok (#a: Type u#a) (xs: clist u#a u#(max b c) a)
   [SMTPat (raise_clist_elim xs b base ind)]
 = raise_list_elim_ok xs.raw b base ind
 
-let raise_clist (#a: Type u#a) (xs: clist u#a u#(max b c) a)
-: clist u#a u#c a
-= {raw = xs.raw; elim = raise_clist_elim xs; elim_prf = (fun _ _ _ -> ())}
-
-let nil (#a: Type u#a): clist u#a u#b a = {
-  raw = [];
-  elim = list_elim [];
-  elim_prf = (fun _ _ _ -> ());
-}
-
-let cons (#a: Type u#a) (x: a) (xs: clist u#a u#b a): clist u#a u#b a = {
-  raw = x :: xs.raw;
-  elim = list_elim (x :: xs.raw);
-  elim_prf = (fun _ _ _ -> ());
-}
-
-let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a): bool
-= raise_clist_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
-
-let cmem_ok (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a)
-: Lemma (cmem x xs == mem x xs.raw)
-= let rec aux (xs: list a)
-  : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
-  = match xs with [] -> () | x :: xs -> aux xs
-  in aux xs.raw
-
-let cmap (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
-: clist u#b u#c b
-= xs.elim (fun _ -> clist u#b u#c b) (nil u#b u#c) (fun x xs recur -> cons u#b u#c #b (f x) recur)
-
-let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
-: Lemma ((cmap f xs).raw == map f xs.raw)
-  [SMTPat (cmap f xs)]
-= let rec aux (xs: list a)
-  : Lemma (
-      (list_elim xs (fun _ -> clist u#b u#c b) (nil u#b u#c)
-        (fun x xs recur -> cons u#b u#c #b (f x) recur))
-      .raw == map f xs)
-  = match xs with [] -> () | x :: xs -> aux xs
-  in aux xs.raw
-
 (**** END MOVE TO ChurchList *)
 
 (**** BEGIN PUBLIC *)
@@ -159,81 +118,7 @@ let has_field (fields: struct_fields) (field: string): bool =
 
 let field_of (fields: struct_fields) = field:string{has_field fields field == true}
 
-let assoc'_motive (#a:eqtype) (#b: Type u#b): list (a * b) -> Type u#b =
-  (fun xs -> x:a -> Pure (option b) True (ensures fun y -> y == List.Tot.assoc x xs))
-
-let assoc'_base
-: assoc'_motive []
-= fun _ -> None
-
-let assoc'_ind (#a:eqtype) #b (x:a * b) (xs:list (a * b)) (recur: assoc'_motive xs)
-: assoc'_motive (x :: xs)
-= fun x' -> let (x, v) = x in if x = x' then Some v else recur x'
-
-//let assoc'_motive (#a:eqtype) (x:a) (xs:clist (a * 'b)) =
-//  (fun xs -> x:a -> Pure (option 'b) True (ensures fun y -> y == List.Tot.assoc x xs))
-
-let assoc' (#a:eqtype) (#b: Type u#b) (x:a) (xs:clist u#b u#(max b c) (a * b))
-: Pure (option b) True (ensures fun y -> y == List.Tot.assoc x xs.raw)
-= raise_clist_elim xs assoc'_motive assoc'_base assoc'_ind x
-
-let weak_assoc'_motive (#a:eqtype) (#b: Type u#b): list (a * b) -> Type u#b =
-  (fun xs -> x:a -> option b)
-
-let weak_assoc'_base: weak_assoc'_motive [] = (fun _ -> None)
-let weak_assoc'_ind (#a:eqtype) #b (x:a * b) (xs:list (a * b)) (recur: weak_assoc'_motive xs)
-: weak_assoc'_motive (x :: xs)
-= fun x' -> let (x, v) = x in if x = x' then Some v else recur x'
-
-let weak_assoc' (#a:eqtype) (#b: Type u#b) (x:a) (xs:clist (a * b))
-: option b
-= xs.elim weak_assoc'_motive weak_assoc'_base weak_assoc'_ind x
-
-let rec assoc_weak_eq (#a:eqtype) (x:a) (xs:list (a * 'b))
-: Lemma ((list_elim xs
-    assoc'_motive
-    assoc'_base
-    assoc'_ind
-        x == list_elim xs
-    weak_assoc'_motive
-    weak_assoc'_base
-    weak_assoc'_ind
-    x))
-= match xs with
-  | [] -> ()
-  | _ :: xs -> assoc_weak_eq x xs
-
-let assoc_weak_eq' (#a:eqtype) (x:a) (xs:clist (a * 'b))
-: Lemma (assoc' x xs == weak_assoc' x xs)
-= assoc_weak_eq x xs.raw
-
-//= match xs.raw with
-//  | [] -> ()
-//  | x :: xs -> 
-//= xs.elim (fun xs' -> xs_clist:clist (a * 'b) ->
-//      Lemma (requires xs' == xs_clist.raw) (ensures assoc' x xs_clist == weak_assoc' x xs_clist))
-//      (fun _ -> ())
-//      (fun (x, v) xs recur x' -> if x = x' then () else recur x')
-//      x
-
-// requires prefix 
-//   assoc' x (prefix @ xs) == weak_assoc' x (prefix @ xs)
-// ensures
-// let rec assoc_weak_eq (#a:eqtype) (x:a) (xs:clist (a * 'b))
-// : Lemma (assoc' x xs == weak_assoc' x xs)
-// //= match xs.raw with
-// //  | [] -> ()
-// //  | x :: xs -> 
-// = xs.elim (fun xs' -> xs_clist:clist (a * 'b) ->
-//       Lemma (requires xs' == xs_clist.raw) (ensures assoc' x xs_clist == weak_assoc' x xs_clist))
-//       (fun _ -> ())
-//       (fun (x, v) xs recur x' -> if x = x' then () else recur x')
-//       x
-// 
-//     Pure (b raw) True (ensures fun y -> y == list_elim raw b base ind);
-
 assume val trivial_typedef: typedef
-assume val nontrivial_typedef: typedef
 
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
   fields.elim (fun fields -> typedef) trivial_typedef
@@ -242,6 +127,7 @@ let get_field (fields: struct_fields) (field: field_of fields): typedef =
 (**** END PUBLIC *)
 
 #push-options "--fuel 0"
+assume val nontrivial_typedef: typedef
 let _ =
   let test_fields = normalize_term (mk_clist [
     "a", trivial_typedef;
@@ -256,11 +142,7 @@ let _ =
     "j", nontrivial_typedef;
   ]) in
   assert (has_field test_fields "e" == true);
-  assert (get_field test_fields "j" == nontrivial_typedef);
-  assert (assoc' "j" test_fields == Some nontrivial_typedef);
-  assert (assoc' "k" test_fields == None);
-  assert (weak_assoc' "j" test_fields == Some nontrivial_typedef);
-  assert (weak_assoc' "k" test_fields == None)
+  assert (get_field test_fields "j" == nontrivial_typedef)
 #pop-options
 
 (**** BEGIN PUBLIC *)

From 6d1d26fa63f7065b553de5a4c70fa388c051e2b7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 2 Aug 2021 15:59:27 -0700
Subject: [PATCH 160/513] Start on generic struct PCM carrier values

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 188 +++++++++++++++---
 1 file changed, 156 insertions(+), 32 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index e3e15f62fcc..defd5360dd4 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -105,27 +105,105 @@ let raise_clist_elim_ok (#a: Type u#a) (xs: clist u#a u#(max b c) a)
   [SMTPat (raise_clist_elim xs b base ind)]
 = raise_list_elim_ok xs.raw b base ind
 
+let raise_clist (#a: Type u#a) (xs: clist u#a u#(max b c) a)
+: clist u#a u#c a
+= {raw = xs.raw; elim = raise_clist_elim xs; elim_prf = (fun _ _ _ -> ())}
+
+let nil (#a: Type u#a): clist u#a u#b a = {
+  raw = [];
+  elim = list_elim [];
+  elim_prf = (fun _ _ _ -> ());
+}
+
+let cons (#a: Type u#a) (x: a) (xs: clist u#a u#b a): clist u#a u#b a = {
+  raw = x :: xs.raw;
+  elim = list_elim (x :: xs.raw);
+  elim_prf = (fun _ _ _ -> ());
+}
+
+let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a): bool
+= raise_clist_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
+
+let cmem_ok (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a)
+: Lemma (cmem x xs == mem x xs.raw)
+= let rec aux (xs: list a)
+  : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
+  = match xs with [] -> () | x :: xs -> aux xs
+  in aux xs.raw
+
+let cmap (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
+: clist u#b u#c b
+= xs.elim (fun _ -> clist u#b u#c b) (nil u#b u#c) (fun x xs recur -> cons u#b u#c #b (f x) recur)
+
+let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
+: Lemma ((cmap f xs).raw == map f xs.raw)
+  [SMTPat (cmap f xs)]
+= let rec aux (xs: list a)
+  : Lemma (
+      (list_elim xs (fun _ -> clist u#b u#c b) (nil u#b u#c)
+        (fun x xs recur -> cons u#b u#c #b (f x) recur))
+      .raw == map f xs)
+  = match xs with [] -> () | x :: xs -> aux xs
+  in aux xs.raw
+
 (**** END MOVE TO ChurchList *)
 
 (**** BEGIN PUBLIC *)
 
-let struct_fields = clist u#1 u#1 (string * typedef)
+let struct_fields = clist u#1 u#2 (string * typedef)
 
 let has_field (fields: struct_fields) (field: string): bool =
   raise_clist_elim fields (fun _ -> bool)
     false
     (fun (field', td) fields recur -> field = field' || recur)
 
+let has_field_spec (fields: struct_fields) (field: string)
+: Lemma (has_field fields field == field `mem` map fst fields.raw)
+  [SMTPat (has_field fields field)]
+= let rec aux (fields: list (string * typedef))
+  : Lemma (list_elim fields (fun _ -> bool) false
+      (fun (field', td) fields recur -> field = field' || recur)
+      == field `mem` map fst fields)
+  = match fields with [] -> () | _ :: fields -> aux fields
+  in aux fields.raw
+
 let field_of (fields: struct_fields) = field:string{has_field fields field == true}
 
 assume val trivial_typedef: typedef
 
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  fields.elim (fun fields -> typedef) trivial_typedef
+  raise_clist_elim u#1 u#2 u#1 fields (fun fields -> typedef) trivial_typedef
     (fun (field', td) fields recur -> if field = field' then td else recur)
 
 (**** END PUBLIC *)
 
+let has_field' (fields: list (string * typedef)) (field: string): bool =
+  field `mem` map fst fields
+
+let field_of' (fields: list (string * typedef)) =
+  field:string{has_field' fields field}
+
+let get_field' (fields: list (string * typedef)) (field: field_of' fields): typedef =
+  assoc_mem field fields;
+  Some?.v (assoc field fields)
+
+let get_field_spec_aux (fields: struct_fields) (field: field_of fields)
+: Lemma (get_field fields field
+    == (match assoc field fields.raw with Some td -> td | None -> trivial_typedef))
+= let rec aux (fields: list (string * typedef))
+  : Lemma (
+      list_elim fields (fun fields -> typedef) trivial_typedef
+        (fun (field', td) fields recur -> if field = field' then td else recur)
+      == (match assoc field fields with Some td -> td | None -> trivial_typedef))
+  = match fields with [] -> () | _ :: fields -> aux fields
+  in aux fields.raw
+
+let get_field_spec (fields: struct_fields) (field: field_of fields)
+: Lemma (get_field fields field == get_field' fields.raw field)
+  [SMTPat (get_field fields field)]
+= assoc_mem field fields.raw;
+  get_field_spec_aux fields field
+
 #push-options "--fuel 0"
 assume val nontrivial_typedef: typedef
 let _ =
@@ -160,26 +238,25 @@ val struct (tag: string) (fields: struct_fields): Type0
 
 (**** END PUBLIC *)
 
-let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
+let struct_view_types' (fields: list (string * typedef)) (field: field_of' fields): Type =
+  (get_field' fields field).view_type
+
+let struct tag fields = restricted_t (field_of' fields.raw) (struct_view_types' fields.raw)
 
 (**** BEGIN PUBLIC *)
 
 let list_fn (dom: list (Type u#a)) (cod: Type u#a): Type u#a =
   list_elim dom (fun _ -> Type) cod (fun d dom recur -> d -> recur)
   
-let clist_fn (dom: clist u#_ u#(1 + a) (Type u#a)) (cod: Type u#a): Type u#a =
-  dom.elim (fun _ -> Type u#a) cod (fun d dom recur -> d -> recur)
-
-let clist_fn_map (#a: Type u#a) (#b: Type u#a)
-  (#dom: clist u#_ u#(1 + a) (Type u#a)) (f: a -> b)
-: dom `clist_fn` a -> dom `clist_fn` b
-= raise_clist_elim u#_ u#(1 + a) u#a dom (fun dom -> dom `list_fn` a -> dom `list_fn` b)
-    f
-    (fun d dom recur g x -> recur (g x))
+let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
+  | [] -> f g <: [] `list_fn` 'b
+  | d :: dom' ->
+    let g: d -> dom' `list_fn` 'a = g in
+    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
 
 let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
 
-let mk_struct_ty_dom (tag: string) (fields: clist (string * typedef)): clist Type =
+let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
   map struct_field_view_type fields
 
 let mk_struct_ty (tag: string) (fields: struct_fields): Type =
@@ -189,20 +266,37 @@ let mk_struct_ty (tag: string) (fields: struct_fields): Type =
 val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
 (**** END PUBLIC *)
 
-let mk_struct (tag: string) (fields: struct_fields)
-: mk_struct_ty tag fields
+(*
+let clist_fn_map (#a: Type u#a) (#b: Type u#a)
+  (#dom: clist u#_ u#(1 + a) (Type u#a)) (f: a -> b)
+: dom `clist_fn` a -> dom `clist_fn` b
+= raise_clist_elim u#_ u#(1 + a) u#a dom (fun dom -> dom `list_fn` a -> dom `list_fn` b)
+    f (fun d dom recur g x -> recur (g x))
+    *)
+
+let struct' tag (fields: list (string * typedef)) =
+  restricted_t (field_of' fields) (struct_view_types' fields)
+
+let mk_struct_ty' tag (fields: list (string * typedef)) = 
+  mk_struct_ty_dom tag fields `list_fn` 
+  struct' tag fields
+
+let rec mk_struct' (tag: string) (fields: list (string * typedef))
+: mk_struct_ty' tag fields
 = match fields with
-  | [(field, td)] -> fun (x:td.view_type) -> on_dom _ (fun field -> x <: struct_view_types fields field)
+  | [] -> on_dom _ (fun field -> (assert false) <: struct_view_types' fields field)
   | (field, td) :: fields' ->
     fun (x:td.view_type) ->
-    let f: map struct_field_view_type fields' `list_fn` struct tag fields' = mk_struct tag fields' in
-    let lift_struct (g: struct tag fields'): struct tag fields =
-      let h (field': field_of fields): struct_view_types fields field' =
+    let f: map struct_field_view_type fields' `list_fn` struct' tag fields' = mk_struct' tag fields' in
+    let lift_struct (g: struct' tag fields'): struct' tag fields =
+      let h (field': field_of' fields): struct_view_types' fields field' =
         if field' = field then x else g field'
       in on_dom _ h
     in
     list_fn_map lift_struct f
 
+let mk_struct tag fields = mk_struct' tag fields.raw
+
 (**** BEGIN PUBLIC *)
 /// Reading a struct field
 val struct_get
@@ -217,6 +311,32 @@ val struct_put
   (field: field_of fields)
   (v: (get_field fields field).view_type)
 : struct tag fields
+(**** END PUBLIC *)
+
+let field'_of (fields: struct_fields) (field: field_of fields)
+: field_of' fields.raw
+= field
+
+let view_type'_of (fields: struct_fields) (field: field_of fields)
+  (v: struct_view_types' fields.raw field)
+: struct_view_types fields field
+= assoc_mem field fields.raw; v
+
+let view_type_of (fields: struct_fields) (field: field_of fields)
+  (v: struct_view_types fields field)
+: struct_view_types' fields.raw field
+= assoc_mem field fields.raw; v
+
+let struct_get #tag #fields x field =
+  view_type'_of fields field (x (field'_of fields field))
+
+let struct_put #tag #fields x field v =
+  on_dom _ (fun field' ->
+    if field'_of fields field = field'
+    then view_type_of fields field v
+    else x field')
+
+(**** BEGIN PUBLIC *)
 
 /// For a fixed field name, struct_get and struct_put form a lens
 
@@ -270,10 +390,6 @@ val struct_put_put_ne
       struct_put (struct_put x field2 w) field1 v)
 (**** END PUBLIC *)
 
-let struct_get x field = x field
-
-let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
-
 let struct_get_put x field v = ()
 
 let struct_put_get x field =
@@ -292,22 +408,30 @@ let struct_put_put_ne x field1 v field2 w =
 (**** BEGIN PUBLIC *)
 /// Similarly, a PCM for structs
 
-[@@__reduce__]
-let struct_carriers (fields: struct_fields) (field: field_of fields) =
-  (get_field fields field).carrier
+let struct_carriers (fields: struct_fields)
+: restricted_t (field_of fields) (fun _ -> Type)
+= on_dom _ (fun (field: field_of fields) -> (get_field fields field).carrier)
 
-[@@__reduce__]
 let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
 : pcm (struct_carriers fields field)
 = (get_field fields field).pcm
 
 val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
-(*** END PUBLIC *)
+(**** END PUBLIC *)
 
-let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
+let struct_carriers' (fields: list (string * typedef))
+: restricted_t (field_of' fields) (fun _ -> Type)
+= on_dom _ (fun field -> (get_field' fields field).carrier)
+  
+let struct_pcm_carrier tag fields = restricted_t (field_of' fields.raw) (struct_carriers' fields.raw)
 
-let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
+(**** BEGIN PUBLIC *)
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+(**** END PUBLIC *)
+let struct_pcm tag fields =
+  //assert (struct_carriers fields `feq` struct_carriers' fields.raw);
+  assume (struct_carriers fields == struct_carriers' fields.raw);
+  prod_pcm (struct_pcms tag fields)
 
 (**** BEGIN PUBLIC *)
 let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
@@ -315,7 +439,7 @@ let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
 let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
   map struct_field_carrier fields
 
-let mk_struct_pcm_ty (tag: string) (fields: struct_fields): Type =
+let mk_struct_pcm_ty (tag: string) (fields: list (string * typedef)): Type =
   mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
 
 /// A struct PCM carrier literal

From 66e99322092c069993a0b5173dc0f5de1c4f6247 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 2 Aug 2021 17:55:36 -0700
Subject: [PATCH 161/513] optimize clist.elim, no proof needed

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 54 ++++++++-----------
 1 file changed, 22 insertions(+), 32 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index defd5360dd4..6035ebe96fb 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -13,7 +13,7 @@ open Steel.C.Connection
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-open ChurchList
+// open ChurchList
 
 (**** MOVE TO ChurchList *)
 
@@ -28,48 +28,40 @@ let rec list_elim (xs: list 'a)
 
 noeq type clist (a:Type u#a): Type = {
   raw: list a;
-  //elim:
-  //  b:(list a -> Type u#b) ->
-  //  base:b [] ->
-  //  ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
-  //  Pure (b raw) True (ensures fun y -> y == list_elim raw b base ind);
   elim:
     b:(list a -> Type u#b) ->
     base:b [] ->
     ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
     b raw;
-  elim_prf:
-    b:(list a -> Type u#b) ->
-    base:b [] ->
-    ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
-    Lemma (elim b base ind == list_elim raw b base ind);
 }
 
-let elim_prf' #a (xs: clist a)
-  (b:(list a -> Type)) (base:b [])
-  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
-: Lemma (xs.elim b base ind == list_elim xs.raw b base ind)
-  [SMTPat (xs.elim b base ind)]
-= xs.elim_prf b base ind
+let clist_elim
+  (c: clist 'a)
+  (b:(list 'a -> Type))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: Pure (b c.raw)
+  (requires True)
+  (ensures (fun y -> y == list_elim c.raw b base ind))
+= let b' (l2: list 'a) : Type =
+    (x: b l2 { x == list_elim l2 b base ind })
+  in
+  c.elim
+    b'
+    base
+    (fun x xs x' -> ind x xs x')
 
 let mk_clist (xs: list 'a) = {
   raw = xs;
   elim = list_elim xs;
-  elim_prf = (fun _ _ _ -> ());
 }
 
-(*
-let clist_elim_prf (#a: Type u#a) (xs: clist u#a u#b a)
-: Lemma (xs.elim == list_elim xs.raw) [SMTPat (xs.elim)]
-= let _ = xs.elim_prf in () // TODO bug in Z3?
-*)
-
 #push-options "--print_universes --print_implicits"
 
 #push-options "--fuel 0"
 let _ =
   let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
-  assert (xs.elim (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+  assert (clist_elim xs (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
 #pop-options
 
 module U = FStar.Universe
@@ -80,7 +72,7 @@ let raise_clist_elim (#a: Type u#a) (xs: clist u#a u#(max b c) a)
   (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
 : b xs.raw
 = U.downgrade_val
-    (xs.elim (fun xs -> U.raise_t (b xs))
+    (clist_elim xs (fun xs -> U.raise_t (b xs))
       (U.raise_val base)
       (fun x xs recur -> U.raise_val (ind x xs (U.downgrade_val recur))))
 
@@ -107,18 +99,16 @@ let raise_clist_elim_ok (#a: Type u#a) (xs: clist u#a u#(max b c) a)
 
 let raise_clist (#a: Type u#a) (xs: clist u#a u#(max b c) a)
 : clist u#a u#c a
-= {raw = xs.raw; elim = raise_clist_elim xs; elim_prf = (fun _ _ _ -> ())}
+= {raw = xs.raw; elim = raise_clist_elim xs; }
 
 let nil (#a: Type u#a): clist u#a u#b a = {
   raw = [];
-  elim = list_elim [];
-  elim_prf = (fun _ _ _ -> ());
+  elim = (fun _ base _ -> base);
 }
 
 let cons (#a: Type u#a) (x: a) (xs: clist u#a u#b a): clist u#a u#b a = {
   raw = x :: xs.raw;
-  elim = list_elim (x :: xs.raw);
-  elim_prf = (fun _ _ _ -> ());
+  elim = (fun b base ind -> ind x xs.raw (clist_elim xs b base ind));
 }
 
 let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a): bool
@@ -133,7 +123,7 @@ let cmem_ok (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a)
 
 let cmap (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
 : clist u#b u#c b
-= xs.elim (fun _ -> clist u#b u#c b) (nil u#b u#c) (fun x xs recur -> cons u#b u#c #b (f x) recur)
+= clist_elim xs (fun _ -> clist u#b u#c b) (nil u#b u#c) (fun x xs recur -> cons u#b u#c #b (f x) recur)
 
 let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
 : Lemma ((cmap f xs).raw == map f xs.raw)

From ecd13a5b05e41041d5f5cf2df10c953ba9fa371f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 08:27:08 -0700
Subject: [PATCH 162/513] Delete mk_struct_pcm for now

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 206 ++++++------------
 1 file changed, 62 insertions(+), 144 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 6035ebe96fb..4176a285e5b 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -142,14 +142,14 @@ let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1
 
 let struct_fields = clist u#1 u#2 (string * typedef)
 
-let has_field (fields: struct_fields) (field: string): bool =
+let has_field_bool (fields: struct_fields) (field: string): bool =
   raise_clist_elim fields (fun _ -> bool)
     false
     (fun (field', td) fields recur -> field = field' || recur)
 
-let has_field_spec (fields: struct_fields) (field: string)
-: Lemma (has_field fields field == field `mem` map fst fields.raw)
-  [SMTPat (has_field fields field)]
+let has_field_bool_spec (fields: struct_fields) (field: string)
+: Lemma (has_field_bool fields field == field `mem` map fst fields.raw)
+  [SMTPat (has_field_bool fields field)]
 = let rec aux (fields: list (string * typedef))
   : Lemma (list_elim fields (fun _ -> bool) false
       (fun (field', td) fields recur -> field = field' || recur)
@@ -157,7 +157,10 @@ let has_field_spec (fields: struct_fields) (field: string)
   = match fields with [] -> () | _ :: fields -> aux fields
   in aux fields.raw
 
-let field_of (fields: struct_fields) = field:string{has_field fields field == true}
+let has_field (fields: struct_fields) (field: string): prop =
+  has_field_bool fields field == true
+
+let field_of (fields: struct_fields) = refine string (has_field fields)
 
 assume val trivial_typedef: typedef
 
@@ -167,11 +170,14 @@ let get_field (fields: struct_fields) (field: field_of fields): typedef =
 
 (**** END PUBLIC *)
 
-let has_field' (fields: list (string * typedef)) (field: string): bool =
+let has_field_bool' (fields: list (string * typedef)) (field: string): bool =
   field `mem` map fst fields
 
+let has_field' (fields: list (string * typedef)) (field: string): prop =
+  has_field_bool' fields field == true
+
 let field_of' (fields: list (string * typedef)) =
-  field:string{has_field' fields field}
+  refine string (has_field' fields)
 
 let get_field' (fields: list (string * typedef)) (field: field_of' fields): typedef =
   assoc_mem field fields;
@@ -209,7 +215,7 @@ let _ =
     "i", trivial_typedef;
     "j", nontrivial_typedef;
   ]) in
-  assert (has_field test_fields "e" == true);
+  assert (has_field_bool test_fields "e" == true);
   assert (get_field test_fields "j" == nontrivial_typedef)
 #pop-options
 
@@ -271,21 +277,47 @@ let mk_struct_ty' tag (fields: list (string * typedef)) =
   mk_struct_ty_dom tag fields `list_fn` 
   struct' tag fields
 
-let rec mk_struct' (tag: string) (fields: list (string * typedef))
-: mk_struct_ty' tag fields
-= match fields with
-  | [] -> on_dom _ (fun field -> (assert false) <: struct_view_types' fields field)
-  | (field, td) :: fields' ->
-    fun (x:td.view_type) ->
-    let f: map struct_field_view_type fields' `list_fn` struct' tag fields' = mk_struct' tag fields' in
-    let lift_struct (g: struct' tag fields'): struct' tag fields =
-      let h (field': field_of' fields): struct_view_types' fields field' =
-        if field' = field then x else g field'
-      in on_dom _ h
-    in
-    list_fn_map lift_struct f
-
-let mk_struct tag fields = mk_struct' tag fields.raw
+let mk_struct_nil (tag: string): mk_struct_ty' tag [] =
+  on_dom _ (fun field -> (assert false) <: struct_view_types' [] field)
+
+let mk_struct_cons (tag: string)
+  (field_td: string * typedef)
+  (fields': list (string * typedef))
+  (recur: mk_struct_ty' tag fields')
+: mk_struct_ty' tag (field_td :: fields') =
+  let (field, td) = field_td in
+  let fields = field_td :: fields' in
+  fun (x:td.view_type) ->
+  let lift_struct (g: struct' tag fields'): struct' tag fields =
+    let h (field': field_of' fields): struct_view_types' fields field' =
+      if field' = field then x else g field'
+    in on_dom _ h
+  in
+  list_fn_map lift_struct recur
+
+let mk_struct tag fields =
+  raise_clist_elim fields
+    (mk_struct_ty' tag)
+    (mk_struct_nil tag)
+    (mk_struct_cons tag)
+
+#push-options "--fuel 0"
+let _ =
+  let c_int: typedef = {
+    carrier = option int;
+    pcm = Steel.C.Opt.opt_pcm #int;
+    view_type = int;
+    view = Steel.C.Opt.opt_view int;
+  } in
+  let fields = mk_clist [
+    "x", c_int;
+    "y", c_int;
+    "z", c_int;
+  ] in
+  let _ : int -> int -> int -> struct "a" fields =
+    mk_struct "a" fields
+  in ()
+#pop-options
 
 (**** BEGIN PUBLIC *)
 /// Reading a struct field
@@ -413,134 +445,20 @@ let struct_carriers' (fields: list (string * typedef))
 : restricted_t (field_of' fields) (fun _ -> Type)
 = on_dom _ (fun field -> (get_field' fields field).carrier)
   
-let struct_pcm_carrier tag fields = restricted_t (field_of' fields.raw) (struct_carriers' fields.raw)
+let struct_pcm_carrier' tag fields = restricted_t (field_of' fields) (struct_carriers' fields)
+let struct_pcm_carrier tag fields = struct_pcm_carrier' tag fields.raw
+
+let struct_pcms' (tag: string) (fields: list (string * typedef)) (field: field_of' fields)
+: pcm (struct_carriers' fields field)
+= (get_field' fields field).pcm
 
 (**** BEGIN PUBLIC *)
 val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
 (**** END PUBLIC *)
-let struct_pcm tag fields =
-  //assert (struct_carriers fields `feq` struct_carriers' fields.raw);
-  assume (struct_carriers fields == struct_carriers' fields.raw);
-  prod_pcm (struct_pcms tag fields)
+let struct_pcm tag fields = prod_pcm (struct_pcms' tag fields.raw)
 
-(**** BEGIN PUBLIC *)
 let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
 
-let mk_struct_pcm_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
-  map struct_field_carrier fields
-
-let mk_struct_pcm_ty (tag: string) (fields: list (string * typedef)): Type =
-  mk_struct_pcm_ty_dom tag fields `list_fn` struct_pcm_carrier tag fields
-
-/// A struct PCM carrier literal
-val mk_struct_pcm (tag: string) (fields: struct_fields): mk_struct_pcm_ty tag fields
-(**** END PUBLIC *)
-
-let rec mk_struct_pcm (tag: string) (fields: struct_fields)
-: mk_struct_pcm_ty tag fields
-= match fields with
-  | [(field, td)] -> fun (x:td.carrier) -> on_dom _ (fun field -> x <: struct_carriers fields field)
-  | (field, td) :: fields' ->
-    fun (x:td.carrier) ->
-    let f: map struct_field_carrier fields' `list_fn` struct_pcm_carrier tag fields' = mk_struct_pcm tag fields' in
-    let lift_struct (g: struct_pcm_carrier tag fields'): struct_pcm_carrier tag fields =
-      let h (field': field_of fields): struct_carriers fields field' =
-        if field' = field then x else g field'
-      in on_dom _ h
-    in
-    list_fn_map lift_struct f
-
-(**** BEGIN PUBLIC *)
-
-/// Reading a pcm_struct_carrier field
-val struct_pcm_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields) (field: field_of fields)
-: (get_field fields field).carrier
-
-/// Writing a struct_pcm_carrier field
-val struct_pcm_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).carrier)
-: struct_pcm_carrier tag fields
-
-/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
-
-val struct_pcm_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (get_field fields field).carrier)
-: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
-  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
-
-val struct_pcm_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
-  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
-
-val struct_pcm_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v w: (get_field fields field).carrier)
-: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
-  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
-
-/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
-
-val struct_pcm_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (get_field fields field1).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
-  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
-  
-val struct_pcm_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (v: (get_field fields field1).carrier)
-  (field2: field_of fields)
-  (w: (get_field fields field2).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
-      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
-/// View a struct_pcm_carrier as a struct
-val struct_view (tag: string) (fields: struct_fields)
-: sel_view (struct_pcm tag fields) (struct tag fields) false
-(**** END PUBLIC *)
-
-let struct_pcm_get x field = x field
-
-let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
-
-let struct_pcm_get_put x field v = ()
-
-let struct_pcm_put_get x field =
-  assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
-
-let struct_pcm_put_put x field v w =
-  assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
-
-let struct_pcm_get_put_ne x field1 field2 v = ()
-
-let struct_pcm_put_put_ne x field1 v field2 w =
-   assert (
-     struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
-     struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
 (*
 
 /// View a struct_pcm_carrier as a struct

From ff89a970a83f5edd450ec4d5613cac370a515124 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 09:32:37 -0700
Subject: [PATCH 163/513] Write mk_struct_ty using list_elim

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 204 +++++++++++-------
 1 file changed, 127 insertions(+), 77 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 4176a285e5b..14cd6aa422d 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -157,8 +157,9 @@ let has_field_bool_spec (fields: struct_fields) (field: string)
   = match fields with [] -> () | _ :: fields -> aux fields
   in aux fields.raw
 
-let has_field (fields: struct_fields) (field: string): prop =
-  has_field_bool fields field == true
+let has_field (fields: struct_fields)
+: (string ^-> prop)
+= on_dom string (fun field -> has_field_bool fields field == true <: prop)
 
 let field_of (fields: struct_fields) = refine string (has_field fields)
 
@@ -173,8 +174,9 @@ let get_field (fields: struct_fields) (field: field_of fields): typedef =
 let has_field_bool' (fields: list (string * typedef)) (field: string): bool =
   field `mem` map fst fields
 
-let has_field' (fields: list (string * typedef)) (field: string): prop =
-  has_field_bool' fields field == true
+let has_field' (fields: list (string * typedef))
+: (string ^-> prop)
+= on_dom _ (fun field -> has_field_bool' fields field == true <: prop)
 
 let field_of' (fields: list (string * typedef)) =
   refine string (has_field' fields)
@@ -227,96 +229,148 @@ let struct_views (fields: struct_fields) (field: field_of fields)
 : sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
 = (get_field fields field).view
 
-let struct_view_types (fields: struct_fields) (field: field_of fields) =
-  (get_field fields field).view_type
+let const_Type (x: 'a) = Type
+
+let struct_view_types (fields: struct_fields)
+: restricted_t (field_of fields) const_Type
+= on_dom _ (fun field -> (get_field fields field).view_type)
 
 val struct (tag: string) (fields: struct_fields): Type0
 
 (**** END PUBLIC *)
 
-let struct_view_types' (fields: list (string * typedef)) (field: field_of' fields): Type =
-  (get_field' fields field).view_type
+let struct_view_types' (fields: list (string * typedef))
+: restricted_t (field_of' fields) const_Type
+= on_dom _ (fun field -> (get_field' fields field).view_type)
 
-let struct tag fields = restricted_t (field_of' fields.raw) (struct_view_types' fields.raw)
+let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
 
 (**** BEGIN PUBLIC *)
 
+let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
+
+let mk_struct_ty_dom (tag: string) (fields: struct_fields): clist Type =
+  cmap struct_field_view_type fields
+
+let clist_fn (dom: clist (Type u#a)) (cod: Type u#a): Type u#a =
+  clist_elim dom (fun _ -> Type) cod (fun d dom recur -> d -> recur)
+
+let mk_struct_ty (tag: string) (fields: struct_fields): Type =
+  mk_struct_ty_dom tag fields `clist_fn` struct tag fields
+
+/// A struct literal
+val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
+(**** END PUBLIC *)
+
+let struct' tag fields = restricted_t (field_of' fields) (struct_view_types' fields)
+
+let field_of_eq fields
+: Lemma (field_of fields == field_of' fields.raw)
+  [SMTPat (field_of fields)]
+= assert (has_field fields `feq` has_field' fields.raw)
+
+let ext' (a a': Type) (b: a -> Type) (b': a' -> Type)
+  (f: restricted_t a b)
+  (g: restricted_t a' b')
+: Lemma (requires a == a' /\ b == b' /\ f `feq` g) (ensures f == g)
+= ()
+
+let struct_view_types_eq fields
+: Lemma (struct_view_types fields == struct_view_types' fields.raw)
+  [SMTPat (struct_view_types fields)]
+= ext' _ _ _ _ (struct_view_types fields) (struct_view_types' fields.raw)
+
 let list_fn (dom: list (Type u#a)) (cod: Type u#a): Type u#a =
   list_elim dom (fun _ -> Type) cod (fun d dom recur -> d -> recur)
-  
+
+let mk_struct_ty' tag fields =
+  map struct_field_view_type fields `list_fn` struct' tag fields
+
+let mk_struct_ty_eq tag fields
+: Lemma (mk_struct_ty tag fields == mk_struct_ty' tag fields.raw)
+= ()
+
+let unreachable (a: Type) : Pure a (requires False) (ensures fun _ -> True)
+= ()
+
 let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
   | [] -> f g <: [] `list_fn` 'b
   | d :: dom' ->
     let g: d -> dom' `list_fn` 'a = g in
     fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
 
-let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
-
-let mk_struct_ty_dom (tag: string) (fields: list (string * typedef)): list Type =
-  map struct_field_view_type fields
+let rec mk_struct' (tag: string) (fields: list (string * typedef))
+: mk_struct_ty' tag fields
+= match fields with
+  | [] -> on_dom (field_of' []) (fun field -> unreachable (struct_view_types' [] field))
+  | (field, td) :: fields' ->
+    fun (x:td.view_type) ->
+    let lift_struct (g: struct' tag fields'): struct' tag fields =
+      let h (field': field_of' fields): struct_view_types' fields field' =
+        if field' = field then x else g field'
+      in on_dom _ h
+    in
+    list_fn_map lift_struct (mk_struct' tag fields')
+
+let mk_struct tag fields = mk_struct' tag fields.raw
 
-let mk_struct_ty (tag: string) (fields: struct_fields): Type =
-  mk_struct_ty_dom tag fields.raw `list_fn` struct tag fields
-
-/// A struct literal
-val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
-(**** END PUBLIC *)
+(*
+let one_list_elim
+  (b:(list Type -> Type))
+  (base:b [])
+  (ind:(x:Type -> xs:list Type -> b xs -> b (x :: xs)))
+: b [int]
+= ind int [] base
+
+let one_list_elim'
+  (base:Type)
+  (ind:(x:Type -> xs:list Type -> Type -> Type))
+: Type
+= ind int [] base
+
+let one_list_elim''
+  (base:Type)
+: Type
+= int -> base
+*)
 
 (*
-let clist_fn_map (#a: Type u#a) (#b: Type u#a)
-  (#dom: clist u#_ u#(1 + a) (Type u#a)) (f: a -> b)
-: dom `clist_fn` a -> dom `clist_fn` b
-= raise_clist_elim u#_ u#(1 + a) u#a dom (fun dom -> dom `list_fn` a -> dom `list_fn` b)
-    f (fun d dom recur g x -> recur (g x))
-    *)
-
-let struct' tag (fields: list (string * typedef)) =
-  restricted_t (field_of' fields) (struct_view_types' fields)
-
-let mk_struct_ty' tag (fields: list (string * typedef)) = 
-  mk_struct_ty_dom tag fields `list_fn` 
-  struct' tag fields
-
-let mk_struct_nil (tag: string): mk_struct_ty' tag [] =
-  on_dom _ (fun field -> (assert false) <: struct_view_types' [] field)
-
-let mk_struct_cons (tag: string)
-  (field_td: string * typedef)
-  (fields': list (string * typedef))
-  (recur: mk_struct_ty' tag fields')
-: mk_struct_ty' tag (field_td :: fields') =
-  let (field, td) = field_td in
-  let fields = field_td :: fields' in
-  fun (x:td.view_type) ->
-  let lift_struct (g: struct' tag fields'): struct' tag fields =
-    let h (field': field_of' fields): struct_view_types' fields field' =
-      if field' = field then x else g field'
-    in on_dom _ h
-  in
-  list_fn_map lift_struct recur
+let f (a:Type): Type = int -> a
 
-let mk_struct tag fields =
-  raise_clist_elim fields
-    (mk_struct_ty' tag)
-    (mk_struct_nil tag)
-    (mk_struct_cons tag)
+let _ = assert (f bool == (int -> bool))
+*)
 
 #push-options "--fuel 0"
+
+(*
 let _ =
-  let c_int: typedef = {
-    carrier = option int;
-    pcm = Steel.C.Opt.opt_pcm #int;
-    view_type = int;
-    view = Steel.C.Opt.opt_view int;
-  } in
-  let fields = mk_clist [
-    "x", c_int;
-    "y", c_int;
-    "z", c_int;
-  ] in
-  let _ : int -> int -> int -> struct "a" fields =
-    mk_struct "a" fields
-  in ()
+  //let c_int: typedef = {
+  //  carrier = option int;
+  //  pcm = Steel.C.Opt.opt_pcm #int;
+  //  view_type = int;
+  //  view = Steel.C.Opt.opt_view int;
+  //} in
+  //let fields = normalize_term (mk_clist [
+  //  "x", c_int;
+  //  //"y", c_int;
+  //  //"z", c_int;
+  //]) in
+  //let args = normalize_term (fun b base ind -> list_elim (int :: ([] #Type))) in
+  //assert (args `clist_fn` bool == (int -> bool));
+  //assert (one_list_elim (fun _ -> Type) bool (fun d dom recur -> int -> recur)
+  //  == (int -> bool));
+  //assert (one_list_elim' bool (fun d dom recur -> int -> recur)
+  //  == (int -> bool));
+  assert (one_list_elim'' bool == (int -> bool));
+  //assert (args.elim (fun _ -> int) 0 (fun n ns sum -> n + sum)
+  //  == 3);
+  //assert (mk_struct_ty "a" fields == (int -> struct "a" fields));
+  //let _ : int -> int -> int -> struct "a" fields =
+  //  mk_struct "a" fields
+  //in ()
+  ()
+*)
+
 #pop-options
 
 (**** BEGIN PUBLIC *)
@@ -349,14 +403,10 @@ let view_type_of (fields: struct_fields) (field: field_of fields)
 : struct_view_types' fields.raw field
 = assoc_mem field fields.raw; v
 
-let struct_get #tag #fields x field =
-  view_type'_of fields field (x (field'_of fields field))
+let struct_get x field = x field
 
-let struct_put #tag #fields x field v =
-  on_dom _ (fun field' ->
-    if field'_of fields field = field'
-    then view_type_of fields field v
-    else x field')
+let struct_put x field v =
+  on_dom _ (fun field' -> if field = field' then v else x field')
 
 (**** BEGIN PUBLIC *)
 

From 4e28961cb27afa114dc11fbadf67ee5e2f1a3cf3 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 10:00:49 -0700
Subject: [PATCH 164/513] Struct PCM carrier values

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 253 ++++++++++--------
 1 file changed, 138 insertions(+), 115 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 14cd6aa422d..38daa3c6c74 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -389,24 +389,8 @@ val struct_put
 : struct tag fields
 (**** END PUBLIC *)
 
-let field'_of (fields: struct_fields) (field: field_of fields)
-: field_of' fields.raw
-= field
-
-let view_type'_of (fields: struct_fields) (field: field_of fields)
-  (v: struct_view_types' fields.raw field)
-: struct_view_types fields field
-= assoc_mem field fields.raw; v
-
-let view_type_of (fields: struct_fields) (field: field_of fields)
-  (v: struct_view_types fields field)
-: struct_view_types' fields.raw field
-= assoc_mem field fields.raw; v
-
 let struct_get x field = x field
-
-let struct_put x field v =
-  on_dom _ (fun field' -> if field = field' then v else x field')
+let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
 (**** BEGIN PUBLIC *)
 
@@ -496,7 +480,7 @@ let struct_carriers' (fields: list (string * typedef))
 = on_dom _ (fun field -> (get_field' fields field).carrier)
   
 let struct_pcm_carrier' tag fields = restricted_t (field_of' fields) (struct_carriers' fields)
-let struct_pcm_carrier tag fields = struct_pcm_carrier' tag fields.raw
+let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers' fields.raw)
 
 let struct_pcms' (tag: string) (fields: list (string * typedef)) (field: field_of' fields)
 : pcm (struct_carriers' fields field)
@@ -509,116 +493,155 @@ let struct_pcm tag fields = prod_pcm (struct_pcms' tag fields.raw)
 
 let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
 
-(*
+(**** BEGIN PUBLIC *)
+let struct_pcm_one (tag: string) (fields: struct_fields)
+: struct_pcm_carrier tag fields
+= one (struct_pcm tag fields)
 
-/// View a struct_pcm_carrier as a struct
-val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields{normalize_term (fields' \subset fields) == true})
-: sel_view (struct_pcm tag fields) (struct tag fields') false
+/// Reading a pcm_struct_carrier field
+val struct_pcm_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields) (field: field_of fields)
+: (get_field fields field).carrier
 
-val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields)
-: sel_view (struct_pcm tag fields) (struct tag (normalize (fields - fields'))) false
+/// Writing a struct_pcm_carrier field
+val struct_pcm_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: struct_pcm_carrier tag fields
 
-struct_view_convert #opened
-  (v: struct_view tag fields fields'1)
-: SteelGhost (struct_view tag fields fields'2) opened
-    (p `pts_to_view` v)
-    (fun w -> (p `pts_to_view` w))
-    (requires fun _ -> normalize (fields - fields'1 == fields - fields'2))
-    (ensures fun h w h' -> forall field. field in (fields - fields'1) ==>
-       h (p `pts_to_view` v) `struct_get` field == 
-       h' (p `pts_to_view` w) `struct_get` field)
+(**** END PUBLIC *)
 
-struct_view_convert
-  (v: struct_view tag fields fields'1)
-: Pure (struct_view tag fields fields'2)
-    (requires normalize (fields - fields'1 == fields - fields'2))
-    (ensures fun w -> True)
+let struct_pcm_get x field = x field
+let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
-val struct_view (tag: string) (fields: struct_fields) (fields': struct_fields) (fields_fields': struct_fields) (heq: squash (fields_fields' == normalize_term (fields - fields')))
-: sel_view (struct_pcm tag fields) (struct tag fields_fields') false
+(**** BEGIN PUBLIC *)
 
-// struct_view tag fields fields' (_ by (T.norm _; T.trefl ()))
+/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
 
-let field_views (tag: string) (fields: struct_fields) (field: field_of fields)
-: sel_view (struct_pcms tag fields field) (struct_view_types fields field) false
-= (get_field fields field).view
+val struct_pcm_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (get_field fields field).carrier)
+: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
+  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
 
-let struct_view_to_view_prop (tag: string) (fields: struct_fields)
-: struct_pcm_carrier tag fields -> prop
-= fun x -> forall (field:field_of fields). (field_views tag fields field).to_view_prop (x field)
-
-let struct_view_to_view (tag: string) (fields: struct_fields)
-: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields) ->
-  Tot (struct tag fields)
-= fun x -> on_dom _ (fun (field: field_of fields) -> (field_views tag fields field).to_view (x field))
-
-let struct_view_to_carrier (tag: string) (fields: struct_fields)
-: struct tag fields ->
-  Tot (refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields))
-= fun x ->
-  let y: struct_pcm_carrier tag fields =
-    on_dom _ (fun (field: field_of fields) ->
-      (field_views tag fields field).to_carrier (x field)
-      <: struct_carriers fields field)
-  in y
-
-let struct_view_to_view_frame (tag: string) (fields: struct_fields)
-  (x: struct tag fields)
-  (frame: struct_pcm_carrier tag fields)
+val struct_pcm_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
+  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
+
+val struct_pcm_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v w: (get_field fields field).carrier)
+: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
+  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
+  
+/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
+
+val struct_pcm_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (get_field fields field1).carrier)
 : Lemma
-    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame))
+    (requires field1 =!= field2)
+    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
+  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
+  
+val struct_pcm_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (v: (get_field fields field1).carrier)
+  (field2: field_of fields)
+  (w: (get_field fields field2).carrier)
+: Lemma
+    (requires field1 =!= field2)
     (ensures
-      struct_view_to_view_prop tag fields
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) /\ 
-      struct_view_to_view tag fields
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) == x)
-= let p = struct_pcms tag fields in
-  let aux (k:field_of fields)
-  : Lemma (
-      (field_views tag fields k).to_view_prop
-        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) /\
-      (field_views tag fields k).to_view
-        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) == x k)
-  = assert (composable (p k) ((field_views tag fields k).to_carrier (x k)) (frame k));
-    (field_views tag fields k).to_view_frame (x k) (frame k)
-  in FStar.Classical.forall_intro aux;
-  assert (
-    struct_view_to_view tag fields
-       (op (prod_pcm p) (struct_view_to_carrier tag fields x) frame) `feq` x)
-
-let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields)
-: squash (
-    ~ (exists x. struct_view_to_carrier tag fields x == one (struct_pcm tag fields)) /\
-    ~ (struct_view_to_view_prop tag fields (one (struct_pcm tag fields))))
-= let (field, _) :: _ = fields in
-  let field: field_of fields = field in
-  (field_views tag fields field).to_carrier_not_one
-
-let struct_view tag fields = {
-  to_view_prop = struct_view_to_view_prop tag fields;
-  to_view = struct_view_to_view tag fields;
-  to_carrier = struct_view_to_carrier tag fields;
-  to_carrier_not_one = struct_view_to_carrier_not_one tag fields;
-  to_view_frame = struct_view_to_view_frame tag fields;
-}
+      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
+      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-/// Connections for fields of structs
-val struct_field
-  (tag: string) (fields: struct_fields) (field: field_of fields)
-: connection (struct_pcm tag fields) (struct_pcms tag fields field)
-let struct_field tag fields field = struct_field (struct_pcms tag fields) field
+/// Struct PCM carrier values are extensional
 
-/// Typedef for struct from typedefs for its fields
-(*
-let typedef_struct (tag: string) (fields: struct_fields): typedef = {
-  carrier = struct_pcm_carrier tag fields; 
-  pcm = struct_pcm tag fields;
-  view_type = struct tag fields;
-  view = struct_view tag fields;
-}
-*)
+let struct_eq
+  (#tag: string) (#fields: struct_fields)
+  (x y: struct_pcm_carrier tag fields)
+= forall (field: field_of fields).
+  x `struct_pcm_get` field == y `struct_pcm_get` field
+
+// let struct_eq
+//   (#tag: string) (#fields: struct_fields)
+//   (x y: struct_pcm_carrier tag fields)
+// = raise_clist_elim u#1 u#2 u#_ fields (fun _ -> prop) True
+//     (fun (field, td) _ recur ->
+//       has_field_bool fields field /\
+//       x `struct_pcm_get` field == y `struct_pcm_get` field /\
+//       recur)
+
+val struct_pcm_ext
+  (#tag: string) (#fields: struct_fields)
+  (x y: struct_pcm_carrier tag fields)
+: Lemma
+    (requires x `struct_eq` y)
+    (ensures x == y)
+    [SMTPat (x `struct_eq` y)]
 
-*)
+(**** END PUBLIC *)
+
+let struct_pcm_get_put x field v = ()
+
+let struct_pcm_put_get x field =
+  assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
+
+let struct_pcm_put_put x field v w =
+  assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
+
+let struct_pcm_get_put_ne x field1 field2 v = ()
+
+let struct_pcm_put_put_ne x field1 v field2 w =
+   assert (
+     struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
+     struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+let struct_pcm_ext x y = assert (x `feq` y)
+
+#push-options "--fuel 0"
+let _ =
+  let c_int: typedef = {
+    carrier = option int;
+    pcm = Steel.C.Opt.opt_pcm #int;
+    view_type = int;
+    view = Steel.C.Opt.opt_view int;
+  } in
+  let fields = normalize_term (mk_clist [
+    "x", c_int;
+    "y", c_int;
+    "z", c_int;
+    //"w", c_int;
+  ]) in
+  let aux (x y: struct_pcm_carrier "" fields) =
+    assert (has_field_bool fields "x");
+    assert (has_field_bool fields "y");
+    assert (has_field_bool fields "z");
+    //assert (has_field_bool fields "w");
+    assume (x `struct_pcm_get` "x" == y `struct_pcm_get` "x");
+    assume (x `struct_pcm_get` "y" == y `struct_pcm_get` "y");
+    assume (x `struct_pcm_get` "z" == y `struct_pcm_get` "z");
+    //assume (x `struct_pcm_get` "w" == y `struct_pcm_get` "w");
+    assert (x `struct_eq` y)
+  in ()
+#pop-options
+
+(**** MOVE EVERYTHING BELOW TO SEPARATE FILES *)
 
 /// TODO move and dedup with Steel.C.Ptr.fst
 

From 70f12910ce9d7eef113302db6b83eb2029d42c45 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 10:20:14 -0700
Subject: [PATCH 165/513] Resurrect struct_view

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 122 ++++++++++++++----
 1 file changed, 99 insertions(+), 23 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 38daa3c6c74..05a31e62c0e 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -140,7 +140,7 @@ let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1
 
 (**** BEGIN PUBLIC *)
 
-let struct_fields = clist u#1 u#2 (string * typedef)
+let struct_fields = clist u#1 u#3 (string * typedef)
 
 let has_field_bool (fields: struct_fields) (field: string): bool =
   raise_clist_elim fields (fun _ -> bool)
@@ -166,7 +166,7 @@ let field_of (fields: struct_fields) = refine string (has_field fields)
 assume val trivial_typedef: typedef
 
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  raise_clist_elim u#1 u#2 u#1 fields (fun fields -> typedef) trivial_typedef
+  raise_clist_elim u#1 u#3 u#1 fields (fun fields -> typedef) trivial_typedef
     (fun (field', td) fields recur -> if field = field' then td else recur)
 
 (**** END PUBLIC *)
@@ -249,14 +249,15 @@ let struct tag fields = restricted_t (field_of fields) (struct_view_types fields
 
 let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
 
-let mk_struct_ty_dom (tag: string) (fields: struct_fields): clist Type =
-  cmap struct_field_view_type fields
+let mk_struct_ty_dom (tag: string) (fields: struct_fields)
+: clist u#1 u#2 Type0
+= cmap struct_field_view_type fields
 
-let clist_fn (dom: clist (Type u#a)) (cod: Type u#a): Type u#a =
-  clist_elim dom (fun _ -> Type) cod (fun d dom recur -> d -> recur)
+let clist_fn (dom: clist u#(1 + c) u#(max b (1 + c)) (Type u#c)) (cod: Type u#c): Type u#c =
+  raise_clist_elim dom (fun _ -> Type u#c) cod (fun d dom recur -> d -> recur)
 
 let mk_struct_ty (tag: string) (fields: struct_fields): Type =
-  mk_struct_ty_dom tag fields `clist_fn` struct tag fields
+  clist_fn u#0 u#2 (mk_struct_ty_dom tag fields) (struct tag fields)
 
 /// A struct literal
 val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
@@ -465,7 +466,7 @@ let struct_put_put_ne x field1 v field2 w =
 /// Similarly, a PCM for structs
 
 let struct_carriers (fields: struct_fields)
-: restricted_t (field_of fields) (fun _ -> Type)
+: restricted_t (field_of fields) const_Type
 = on_dom _ (fun (field: field_of fields) -> (get_field fields field).carrier)
 
 let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
@@ -476,11 +477,16 @@ val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
 (**** END PUBLIC *)
 
 let struct_carriers' (fields: list (string * typedef))
-: restricted_t (field_of' fields) (fun _ -> Type)
+: restricted_t (field_of' fields) const_Type
 = on_dom _ (fun field -> (get_field' fields field).carrier)
+
+let struct_carriers_eq fields
+: Lemma (struct_carriers fields == struct_carriers' fields.raw)
+  [SMTPat (struct_carriers fields)]
+= ext' _ _ _ _ (struct_carriers fields) (struct_carriers' fields.raw)
   
 let struct_pcm_carrier' tag fields = restricted_t (field_of' fields) (struct_carriers' fields)
-let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers' fields.raw)
+let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
 
 let struct_pcms' (tag: string) (fields: list (string * typedef)) (field: field_of' fields)
 : pcm (struct_carriers' fields field)
@@ -489,7 +495,7 @@ let struct_pcms' (tag: string) (fields: list (string * typedef)) (field: field_o
 (**** BEGIN PUBLIC *)
 val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
 (**** END PUBLIC *)
-let struct_pcm tag fields = prod_pcm (struct_pcms' tag fields.raw)
+let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
 
 let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
 
@@ -641,6 +647,78 @@ let _ =
   in ()
 #pop-options
 
+(**** BEGIN PUBLIC *)
+
+/// View a struct_pcm_carrier as a struct
+val struct_view (tag: string) (fields: struct_fields{Cons? fields.raw})
+: sel_view (struct_pcm tag fields) (struct tag fields) false
+
+(**** END PUBLIC *)
+
+let field_views (tag: string) (fields: struct_fields) (field: field_of fields)
+: sel_view (struct_pcms tag fields field) (struct_view_types fields field) false
+= (get_field fields field).view
+
+let struct_view_to_view_prop (tag: string) (fields: struct_fields)
+: struct_pcm_carrier tag fields -> prop
+= fun x -> forall (field:field_of fields). (field_views tag fields field).to_view_prop (x field)
+
+let struct_view_to_view (tag: string) (fields: struct_fields)
+: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields) ->
+  Tot (struct tag fields)
+= fun x -> on_dom _ (fun (field: field_of fields) -> (field_views tag fields field).to_view (x field))
+
+let struct_view_to_carrier (tag: string) (fields: struct_fields)
+: struct tag fields ->
+  Tot (refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields))
+= fun x ->
+  let y: struct_pcm_carrier tag fields =
+    on_dom _ (fun (field: field_of fields) ->
+      (field_views tag fields field).to_carrier (x field)
+      <: struct_carriers' fields.raw field)
+  in y
+
+#push-options "--z3rlimit 30"
+let struct_view_to_view_frame (tag: string) (fields: struct_fields)
+  (x: struct tag fields)
+  (frame: struct_pcm_carrier tag fields)
+: Lemma
+    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame))
+    (ensures
+      struct_view_to_view_prop tag fields
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) /\ 
+      struct_view_to_view tag fields
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) == x)
+= let p = struct_pcms tag fields in
+  let aux (k:field_of fields)
+  : Lemma (
+      (field_views tag fields k).to_view_prop
+        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) /\
+      (field_views tag fields k).to_view
+        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) == x k)
+  = assert (composable (p k) ((field_views tag fields k).to_carrier (x k)) (frame k));
+    (field_views tag fields k).to_view_frame (x k) (frame k)
+  in FStar.Classical.forall_intro aux;
+  assert (
+    struct_view_to_view tag fields
+       (op (prod_pcm p) (struct_view_to_carrier tag fields x) frame) `feq` x)
+       
+let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields{Cons? fields.raw})
+: squash (
+    ~ (exists x. struct_view_to_carrier tag fields x == one (struct_pcm tag fields)) /\
+    ~ (struct_view_to_view_prop tag fields (one (struct_pcm tag fields))))
+= let (field, _) :: _ = fields.raw in
+  let field: field_of fields = field in
+  (field_views tag fields field).to_carrier_not_one
+
+let struct_view tag fields = {
+  to_view_prop = struct_view_to_view_prop tag fields;
+  to_view = struct_view_to_view tag fields;
+  to_carrier = struct_view_to_carrier tag fields;
+  to_carrier_not_one = struct_view_to_carrier_not_one tag fields;
+  to_view_frame = struct_view_to_view_frame tag fields;
+}
+
 (**** MOVE EVERYTHING BELOW TO SEPARATE FILES *)
 
 /// TODO move and dedup with Steel.C.Ptr.fst
@@ -718,7 +796,7 @@ assume val struct_field':
           (struct_pcm tag fields)
           (struct_pcms tag fields field))
 
-[@@__reduce__]
+//[@@__reduce__]
 let pts_to_field
   (tag: string) (fields: struct_fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -730,23 +808,21 @@ let pts_to_field
     (struct_views fields field)
     (s `struct_get'` field)
 
-[@@__reduce__]
-let rec pts_to_fields'
+//[@@__reduce__]
+let pts_to_fields'
   (tag: string) (fields: struct_fields)
   (p: ref 'a (struct_pcm tag fields))
   (s: struct tag fields)
   (fields': struct_fields)
 : vprop
-= match fields' with
-  | [(field, _)] ->
-    if has_field_bool fields field then pts_to_field tag fields p s field else emp
-  | (field, _) :: fields' ->
-    if has_field_bool fields field then begin
-      pts_to_field tag fields p s field `star`
-      pts_to_fields' tag fields p s fields'
-    end else emp
+= raise_clist_elim u#1 u#3 u#2 fields' (fun _ -> vprop)
+    emp
+    (fun (field, _) _ recur ->
+      if has_field_bool fields field then begin
+        pts_to_field tag fields p s field `star` recur
+    end else recur)
 
-[@@__reduce__]
+//[@@__reduce__]
 let pts_to_fields
   (tag: string) (fields: struct_fields)
   (p: ref 'a (struct_pcm tag fields))

From 6728ebc76e7d3fc3b038bb25a66eb0f2a58ec03c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 12:53:14 -0700
Subject: [PATCH 166/513] Get explode to work

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 363 +++++++++++-------
 1 file changed, 229 insertions(+), 134 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 05a31e62c0e..225d55b231a 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -26,18 +26,25 @@ let rec list_elim (xs: list 'a)
   | [] -> base
   | x :: xs -> ind x xs (list_elim xs b base ind)
 
+let elim_t (#a: Type u#a) (xs: list a): Tot (Type u#(max a (1 + b))) =
+  b:(list a -> Type u#b) ->
+  base:b [] ->
+  ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
+  b xs
+
+//[@@__reduce__]
 noeq type clist (a:Type u#a): Type = {
   raw: list a;
-  elim:
-    b:(list a -> Type u#b) ->
-    base:b [] ->
-    ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
-    b raw;
+  elim0: elim_t u#_ u#0 raw;
+  elim1: elim_t u#_ u#1 raw;
+  elim2: elim_t u#_ u#2 raw;
+  elim3: elim_t u#_ u#3 raw;
 }
 
-let clist_elim
+//[@@__reduce__]
+let clist_elim0
   (c: clist 'a)
-  (b:(list 'a -> Type))
+  (b:(list 'a -> Type0))
   (base:b [])
   (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
 : Pure (b c.raw)
@@ -46,104 +53,99 @@ let clist_elim
 = let b' (l2: list 'a) : Type =
     (x: b l2 { x == list_elim l2 b base ind })
   in
-  c.elim
+  c.elim0
     b'
     base
     (fun x xs x' -> ind x xs x')
 
-let mk_clist (xs: list 'a) = {
-  raw = xs;
-  elim = list_elim xs;
-}
+//[@@__reduce__]
+let clist_elim1
+  (c: clist 'a)
+  (b:(list 'a -> Type u#1))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: Pure (b c.raw)
+  (requires True)
+  (ensures (fun y -> y == list_elim c.raw b base ind))
+= let b' (l2: list 'a) : Type =
+    (x: b l2 { x == list_elim l2 b base ind })
+  in
+  c.elim1
+    b'
+    base
+    (fun x xs x' -> ind x xs x')
+
+//[@@__reduce__]
+let clist_elim2
+  (c: clist 'a)
+  (b:(list 'a -> Type u#2))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: Pure (b c.raw)
+  (requires True)
+  (ensures (fun y -> y == list_elim c.raw b base ind))
+= let b' (l2: list 'a) : Type =
+    (x: b l2 { x == list_elim l2 b base ind })
+  in
+  c.elim2
+    b'
+    base
+    (fun x xs x' -> ind x xs x')
 
 #push-options "--print_universes --print_implicits"
 
 #push-options "--fuel 0"
+let mk_clist (xs: list 'a) = {
+  raw = xs;
+  elim0 = list_elim xs;
+  elim1 = list_elim xs;
+  elim2 = list_elim xs;
+  elim3 = list_elim xs;
+}
 let _ =
   let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
-  assert (clist_elim xs (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+  assert (clist_elim0 xs (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
 #pop-options
 
-module U = FStar.Universe
-
-let raise_clist_elim (#a: Type u#a) (xs: clist u#a u#(max b c) a)
-  (b:(list a -> Type u#c))
-  (base: b [])
-  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
-: b xs.raw
-= U.downgrade_val
-    (clist_elim xs (fun xs -> U.raise_t (b xs))
-      (U.raise_val base)
-      (fun x xs recur -> U.raise_val (ind x xs (U.downgrade_val recur))))
-
-let rec raise_list_elim_ok (#a: Type u#a) (xs: list a)
-  (b:(list a -> Type u#c))
-  (base: b [])
-  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
-: Lemma (list_elim xs b base ind ==
-    U.downgrade_val
-      (list_elim xs (fun xs -> U.raise_t u#c u#b (b xs))
-        (U.raise_val base)
-        (fun x xs recur -> U.raise_val (ind x xs (U.downgrade_val recur)))))
-= match xs with
-  | [] -> ()
-  | _ :: xs -> raise_list_elim_ok xs b base ind
-
-let raise_clist_elim_ok (#a: Type u#a) (xs: clist u#a u#(max b c) a)
-  (b:(list a -> Type u#c))
-  (base: b [])
-  (ind:(x:a -> xs:list a -> b xs -> b (x :: xs)))
-: Lemma (raise_clist_elim xs b base ind == list_elim xs.raw b base ind)
-  [SMTPat (raise_clist_elim xs b base ind)]
-= raise_list_elim_ok xs.raw b base ind
-
-let raise_clist (#a: Type u#a) (xs: clist u#a u#(max b c) a)
-: clist u#a u#c a
-= {raw = xs.raw; elim = raise_clist_elim xs; }
-
-let nil (#a: Type u#a): clist u#a u#b a = {
+//[@@__reduce__]
+let nil (#a: Type u#a): clist u#a a = {
   raw = [];
-  elim = (fun _ base _ -> base);
+  elim0 = (fun _ base _ -> base);
+  elim1 = (fun _ base _ -> base);
+  elim2 = (fun _ base _ -> base);
+  elim3 = (fun _ base _ -> base);
 }
 
-let cons (#a: Type u#a) (x: a) (xs: clist u#a u#b a): clist u#a u#b a = {
+//[@@__reduce__]
+let cons (#a: Type u#a) (x: a) (xs: clist u#a a): clist u#a a = {
   raw = x :: xs.raw;
-  elim = (fun b base ind -> ind x xs.raw (clist_elim xs b base ind));
+  elim0 = (fun b base ind -> ind x xs.raw (xs.elim0 b base ind));
+  elim1 = (fun b base ind -> ind x xs.raw (xs.elim1 b base ind));
+  elim2 = (fun b base ind -> ind x xs.raw (xs.elim2 b base ind));
+  elim3 = (fun b base ind -> ind x xs.raw (xs.elim3 b base ind));
 }
 
-let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a): bool
-= raise_clist_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
+//[@@__reduce__]
+let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 a): bool
+= clist_elim0 xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
 
-let cmem_ok (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 u#b a)
+//[@@__reduce__]
+let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
 : Lemma (cmem x xs == mem x xs.raw)
 = let rec aux (xs: list a)
   : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
   = match xs with [] -> () | x :: xs -> aux xs
   in aux xs.raw
 
-let cmap (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
-: clist u#b u#c b
-= clist_elim xs (fun _ -> clist u#b u#c b) (nil u#b u#c) (fun x xs recur -> cons u#b u#c #b (f x) recur)
-
-let cmap_ok (#a: Type u#a) (#b: Type u#b) (f: a -> b) (xs: clist u#a u#(max b (1 + c)) a)
-: Lemma ((cmap f xs).raw == map f xs.raw)
-  [SMTPat (cmap f xs)]
-= let rec aux (xs: list a)
-  : Lemma (
-      (list_elim xs (fun _ -> clist u#b u#c b) (nil u#b u#c)
-        (fun x xs recur -> cons u#b u#c #b (f x) recur))
-      .raw == map f xs)
-  = match xs with [] -> () | x :: xs -> aux xs
-  in aux xs.raw
-
 (**** END MOVE TO ChurchList *)
 
 (**** BEGIN PUBLIC *)
 
-let struct_fields = clist u#1 u#3 (string * typedef)
+let struct_fields = clist u#1 (string * typedef)
 
+//[@@__reduce__]
 let has_field_bool (fields: struct_fields) (field: string): bool =
-  raise_clist_elim fields (fun _ -> bool)
+  clist_elim0 fields (fun _ -> bool)
     false
     (fun (field', td) fields recur -> field = field' || recur)
 
@@ -157,6 +159,7 @@ let has_field_bool_spec (fields: struct_fields) (field: string)
   = match fields with [] -> () | _ :: fields -> aux fields
   in aux fields.raw
 
+//[@@__reduce__]
 let has_field (fields: struct_fields)
 : (string ^-> prop)
 = on_dom string (fun field -> has_field_bool fields field == true <: prop)
@@ -165,8 +168,9 @@ let field_of (fields: struct_fields) = refine string (has_field fields)
 
 assume val trivial_typedef: typedef
 
+//[@@__reduce__]
 let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  raise_clist_elim u#1 u#3 u#1 fields (fun fields -> typedef) trivial_typedef
+  clist_elim1 fields (fun fields -> typedef) trivial_typedef
     (fun (field', td) fields recur -> if field = field' then td else recur)
 
 (**** END PUBLIC *)
@@ -225,12 +229,14 @@ let _ =
 
 /// A view type for structs
 
+//[@@__reduce__]
 let struct_views (fields: struct_fields) (field: field_of fields)
 : sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
 = (get_field fields field).view
 
 let const_Type (x: 'a) = Type
 
+//[@@__reduce__]
 let struct_view_types (fields: struct_fields)
 : restricted_t (field_of fields) const_Type
 = on_dom _ (fun field -> (get_field fields field).view_type)
@@ -249,6 +255,7 @@ let struct tag fields = restricted_t (field_of fields) (struct_view_types fields
 
 let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
 
+(*
 let mk_struct_ty_dom (tag: string) (fields: struct_fields)
 : clist u#1 u#2 Type0
 = cmap struct_field_view_type fields
@@ -261,6 +268,7 @@ let mk_struct_ty (tag: string) (fields: struct_fields): Type =
 
 /// A struct literal
 val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
+*)
 (**** END PUBLIC *)
 
 let struct' tag fields = restricted_t (field_of' fields) (struct_view_types' fields)
@@ -287,6 +295,7 @@ let list_fn (dom: list (Type u#a)) (cod: Type u#a): Type u#a =
 let mk_struct_ty' tag fields =
   map struct_field_view_type fields `list_fn` struct' tag fields
 
+(*
 let mk_struct_ty_eq tag fields
 : Lemma (mk_struct_ty tag fields == mk_struct_ty' tag fields.raw)
 = ()
@@ -314,6 +323,7 @@ let rec mk_struct' (tag: string) (fields: list (string * typedef))
     list_fn_map lift_struct (mk_struct' tag fields')
 
 let mk_struct tag fields = mk_struct' tag fields.raw
+*)
 
 (*
 let one_list_elim
@@ -465,10 +475,12 @@ let struct_put_put_ne x field1 v field2 w =
 (**** BEGIN PUBLIC *)
 /// Similarly, a PCM for structs
 
+//[@@__reduce__]
 let struct_carriers (fields: struct_fields)
 : restricted_t (field_of fields) const_Type
 = on_dom _ (fun (field: field_of fields) -> (get_field fields field).carrier)
 
+//[@@__reduce__]
 let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
 : pcm (struct_carriers fields field)
 = (get_field fields field).pcm
@@ -486,6 +498,7 @@ let struct_carriers_eq fields
 = ext' _ _ _ _ (struct_carriers fields) (struct_carriers' fields.raw)
   
 let struct_pcm_carrier' tag fields = restricted_t (field_of' fields) (struct_carriers' fields)
+
 let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
 
 let struct_pcms' (tag: string) (fields: list (string * typedef)) (field: field_of' fields)
@@ -634,16 +647,24 @@ let _ =
     "z", c_int;
     //"w", c_int;
   ]) in
-  let aux (x y: struct_pcm_carrier "" fields) =
-    assert (has_field_bool fields "x");
-    assert (has_field_bool fields "y");
-    assert (has_field_bool fields "z");
+  let aux (s t: struct_pcm_carrier "" fields) =
+    //assert (has_field_bool fields "x");
+    //assert (has_field_bool fields "y");
+    //assert (has_field_bool fields "z");
+    let x: field_of fields = "x" in
+    let y: field_of fields = "y" in
+    let z: field_of fields = "z" in
     //assert (has_field_bool fields "w");
-    assume (x `struct_pcm_get` "x" == y `struct_pcm_get` "x");
-    assume (x `struct_pcm_get` "y" == y `struct_pcm_get` "y");
-    assume (x `struct_pcm_get` "z" == y `struct_pcm_get` "z");
-    //assume (x `struct_pcm_get` "w" == y `struct_pcm_get` "w");
-    assert (x `struct_eq` y)
+    //assume (s `struct_pcm_get` "x" == t `struct_pcm_get` "x");
+    //assume (s `struct_pcm_get` "y" == t `struct_pcm_get` "y");
+    //assume (s `struct_pcm_get` "z" == t `struct_pcm_get` "z");
+    //assume (s `struct_pcm_get` "w" == t `struct_pcm_get` "w");
+    assume (s `struct_pcm_get` x == t `struct_pcm_get` x);
+    assume (s `struct_pcm_get` y == t `struct_pcm_get` y);
+    assume (s `struct_pcm_get` z == t `struct_pcm_get` z);
+    //assume (s `struct_pcm_get` w == t `struct_pcm_get` w);
+    //assert (s `struct_eq` t);
+    ()
   in ()
 #pop-options
 
@@ -815,12 +836,12 @@ let pts_to_fields'
   (s: struct tag fields)
   (fields': struct_fields)
 : vprop
-= raise_clist_elim u#1 u#3 u#2 fields' (fun _ -> vprop)
+= clist_elim2 fields' (fun _ -> vprop)
     emp
     (fun (field, _) _ recur ->
       if has_field_bool fields field then begin
         pts_to_field tag fields p s field `star` recur
-    end else recur)
+      end else emp)
 
 //[@@__reduce__]
 let pts_to_fields
@@ -831,7 +852,7 @@ let pts_to_fields
 = pts_to_fields' tag fields p s fields
 
 assume val explode (#opened: inames)
-  (tag: string) (fields: struct_fields)
+  (tag: string) (fields: struct_fields{Cons? fields.raw})
   (p: ref 'a (struct_pcm tag fields))
   (s: Ghost.erased (struct tag fields))
 : SteelGhostT unit opened
@@ -839,7 +860,7 @@ assume val explode (#opened: inames)
     (fun _ -> pts_to_fields tag fields p s)
 
 assume val recombine (#opened: inames)
-  (tag: string) (fields: struct_fields)
+  (tag: string) (fields: struct_fields{Cons? fields.raw})
   (p: ref 'a (struct_pcm tag fields))
   (s: Ghost.erased (struct tag fields))
 : SteelGhostT unit opened
@@ -850,7 +871,7 @@ assume val recombine (#opened: inames)
 
 open Steel.C.Opt
 
-[@@__reduce__]
+//[@@__reduce__]
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
@@ -858,59 +879,94 @@ let c_int: typedef = {
   view = opt_view int;
 }
 
-[@@__reduce__]
-let point_fields: struct_fields = [
+//[@@__reduce__]
+//let point_fields: struct_fields =
+//  cons ("x", c_int) (cons ("y", c_int) nil)
+//  //normalize_term (fun c_int -> cons ("x", c_int) (cons ("y", c_int) nil)) c_int
+  
+//[@@__reduce__]
+let point_fields: struct_fields = normalize_term (fun c_int -> mk_clist [
   "x", c_int;
   "y", c_int;
-]
+]) c_int // NOTE: tricky! pull c_int out to avoid normalizing into lambdas
+  
+//[@@__reduce__]
+let point_fields': struct_fields = point_fields
 
-//[@@iter_unfold]
-[@@__reduce__]
+//[@@__reduce__]
 let point = struct "point" point_fields
 
-//[@@iter_unfold]
-[@@__reduce__]
+//[@@__reduce__]
 let point_pcm_carrier = struct_pcm_carrier "point" point_fields
 //[@@iter_unfold]
-[@@__reduce__]
+//[@@__reduce__]
 let point_pcm: pcm point_pcm_carrier = struct_pcm "point" point_fields
 
 /// (mk_point x y) represents (struct point){.x = x, .y = y}
 /// (mk_point_pcm x y) same, but where x and y are PCM carrier values
 
-let mk_point: int -> int -> point = mk_struct "point" point_fields
-let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm "point" point_fields
+//let mk_point: int -> int -> point = mk_struct "point" point_fields
+//let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm "point" point_fields
 
-/// Connections for the fields of a point
+#push-options "--fuel 0"
 
-//[@@iter_unfold]
-val _x: connection point_pcm (opt_pcm #int)
-let _x = struct_field' "point" point_fields "x"
+let _ = assert (struct_pcm_carrier "point" point_fields == point_pcm_carrier)
 
-//[@@iter_unfold]
-val _y: connection point_pcm (opt_pcm #int)
-let _y = struct_field' "point" point_fields "y"
+let _ = assert (struct_carriers point_fields "x" == option int)
 
-//[@@iter_unfold]
-[@@__reduce__]
-let x: field_of point_fields = mk_field_of point_fields "x"
-[@@__reduce__]
-let y: field_of point_fields = mk_field_of point_fields "y"
+let _ = assert (struct_pcm "point" point_fields == point_pcm)
 
-/// View for points
+let _ = assert (struct_pcms "point" point_fields "x" == c_int.pcm)
 
-[@@__reduce__]
-val point_view: sel_view point_pcm point false
-let point_view = struct_view "point" point_fields
+let _ = assert (struct_pcms "point" point_fields "x" === opt_pcm #int)
 
-/// Explode and recombine
+/// Connections for the fields of a point
+
+// //[@@iter_unfold]
+// val _x: connection point_pcm (opt_pcm #int)
+// let _x =
+//   //assert (struct_pcms "point" point_fields "x" === opt_pcm #int);
+// assume (connection u#0
+//   u#0
+//   #point_pcm_carrier
+//   #(Pervasives.Native.option u#0 int)
+//   point_pcm
+//   (opt_pcm u#0 #int)
+//   == connection u#0
+//   u#0
+//   #(struct_pcm_carrier "point" point_fields)
+//   #(struct_carriers point_fields "x")
+//   (struct_pcm "point" point_fields)
+//   (struct_pcms "point" point_fields "x"));
+//   struct_field' "point" point_fields "x"
+// 
+// //[@@iter_unfold]
+// val _y: connection point_pcm (opt_pcm #int)
+// let _y = struct_field' "point" point_fields "y"
+// 
+// //[@@iter_unfold]
+// [@@__reduce__]
+// let x: field_of point_fields = mk_field_of point_fields "x"
+// [@@__reduce__]
+// let y: field_of point_fields = mk_field_of point_fields "y"
+// 
+// /// View for points
+// 
+// [@@__reduce__]
+// val point_view: sel_view point_pcm point false
+// let point_view = struct_view "point" point_fields
+// 
+// /// Explode and recombine
+// 
+// //val explode' (#opened: inames)
+// //  (p: ref 'a point_pcm)
+// //  (s: Ghost.erased point)
+// //: SteelGhostT unit opened
+// //    (pts_to_v p point_view s)
+// //    (fun _ -> pts_to_fields "point" point_fields p s)
 
-//val explode' (#opened: inames)
-//  (p: ref 'a point_pcm)
-//  (s: Ghost.erased point)
-//: SteelGhostT unit opened
-//    (pts_to_v p point_view s)
-//    (fun _ -> pts_to_fields "point" point_fields p s)
+//[@@__reduce__]
+//let point_view = struct_view "point" point_fields
 
 val explode' (#opened: inames)
   (p: ref 'a (struct_pcm "point" point_fields))
@@ -919,7 +975,8 @@ val explode' (#opened: inames)
     (pts_to_v p (struct_view "point" point_fields) s)
     (fun _ -> pts_to_fields "point" point_fields p s)
 
-let explode' p = explode "point" point_fields p
+let explode' p s =
+  explode "point" point_fields p s
 
 (*
 
@@ -944,30 +1001,68 @@ p ~~~> p /\ (fun x -> x =!= removed_field)
 
 *)
 
+//[@@__reduce__]
+let x: field_of point_fields = "x"
+//[@@__reduce__]
+let y: field_of point_fields = "y"
+
+//[@@__reduce__]
+let point_view = struct_view "point" point_fields
+
+//[@@__reduce__]
+let _x = struct_field' "point" point_fields x
+//[@@__reduce__]
+let _y = struct_field' "point" point_fields y
+
+let aux
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (s: Ghost.erased (struct "point" point_fields))
+: Lemma (pts_to_fields "point" point_fields p s
+    == 
+      (pts_to_field "point" point_fields p s x `star`
+        (pts_to_field "point" point_fields p s y `star`
+         emp)))
+= ()
+
+let aux1
+  (p: ref 'a (struct_pcm "point" point_fields))
+  (s: Ghost.erased (struct "point" point_fields))
+: Lemma (pts_to_fields "point" point_fields p s
+    == 
+      (pts_to_v (ref_focus p _x) (struct_views point_fields x) (s `struct_get'` x) `star`
+        (pts_to_v (ref_focus p _y) (struct_views point_fields y) (s `struct_get'` y) `star`
+         emp)))
+= ()
+  
+
+// = pts_to_v
+//     (ref_focus p (struct_field' tag fields field))
+//     (struct_views fields field)
+//     (s `struct_get'` field)
+// = ()
+
 val explode'' (#opened: inames)
   (p: ref 'a (struct_pcm "point" point_fields))
   (s: Ghost.erased (struct "point" point_fields))
 : SteelGhostT unit opened
-    (pts_to_v p (struct_view "point" point_fields) s)
+    (pts_to_v p point_view s)
     (fun _ ->
-//(:struct_def) (fun (field, td) -> pts_to_v ..) Star)
-//= struct_def ..
   pts_to_v
     (ref_focus p _x)
-    (opt_view int)
+    (struct_views point_fields x)
     (s `struct_get'` x)
     `star`
   pts_to_v
     (ref_focus p _y)
-    (opt_view int)
+    (struct_views point_fields y)
     (s `struct_get'` y))
 
-//      pts_to_field "point" point_fields p s x `star`
-//      pts_to_field "point" point_fields p s y)
-
-#push-options "--print_implicits"
-
-let explode'' p s = explode "point" point_fields p s
+let explode'' p s =
+  explode "point" point_fields p s;
+  change_equal_slprop (pts_to_fields "point" point_fields p s)
+  (pts_to_v (ref_focus p _x) (struct_views point_fields x) (s `struct_get'` x) `star`
+        (pts_to_v (ref_focus p _y) (struct_views point_fields y) (s `struct_get'` y) `star`
+         emp))
 
 (*
 (*

From 2c47cfc079996a63c940e437db89880691d7a359 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 13:39:11 -0700
Subject: [PATCH 167/513] Sketch excluded list approach

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 225d55b231a..cce0ab0e149 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -1067,6 +1067,53 @@ let explode'' p s =
 (*
 (*
 
+struct tag fields : Type
+
+struct_pcm_carrier tag fields : Type
+struct_pcm tag fields : pcm (struct_pcm_carrier tag fields)
+
+fields : list (string * typedef)
+
+type struct_fields = {fields: list string; get: string ^-> typedef; get_prf: dom(get) ⊆ fields}
+
+fields : struct_fields
+
+nil : struct_fields
+cons : string -> typedef -> struct_fields -> struct_fields
+
+struct_view tag fields excluded
+  carrier = struct_pcm tag fields
+  view_type = restricted_t (refine string (notin excluded)) (struct_pcm_carriers tag fields)
+
+mk_nil : nil
+
+mk_cons #tag #fields
+  (s: string) (t: typedef) (x: t.view_type) (v: struct tag fields)
+: struct tag (cons s t fields)
+
+get_field fields s = fields.get s
+
+val addr_of_struct_field 
+
+addr_of_struct_field #tag #point_fields p "x" <--- "x" should be a valid field name
+  p : ref base_type (struct_pcm tag fields)
+  "x" notin excluded
+  excluded : string ^-> bool
+  {p `pts_to_view` struct_view tag fields excluded}
+  {p `pts_to_view` struct_view tag fields (cons "x" excluded)
+   q `pts_to_view` struct_field_view tag fields "x"}
+
+unaddr_of_struct_field p "x"
+  p : ref base_type (struct_pcm tag fields)
+  "x" in excluded
+  excluded : string ^-> bool
+  q = ref_focus p ..
+  {p `pts_to_view` struct_view tag fields excluded
+   q `pts_to_view` struct_field_view tag fields "x"}
+  {p `pts_to_view` struct_view tag fields (excluded \ "x")}
+
+sel_view (struct_pcm tag fields) (struct tag (fields \ excluded)) false
+
 val explode'' (#opened: inames)
   (p: ref 'a point_pcm)
 : SteelGhost unit opened

From 31b3dc4d09792ce0abee5499361794856ce13bcd Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 3 Aug 2021 15:12:57 -0700
Subject: [PATCH 168/513] Sketch excluded list approach

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 386 ++++++++++++++++--
 1 file changed, 341 insertions(+), 45 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index cce0ab0e149..2f39295eeff 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -10,9 +10,350 @@ open Steel.C.Struct
 open Steel.C.Typedef
 open Steel.C.Ref // for refine
 open Steel.C.Connection
+open Steel.C.Opt
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+let set a = a ^-> bool
+
+let insert (#a:eqtype) x (s: set a): set a = on_dom _ (fun x' -> x = x' || s x')
+
+let remove (#a:eqtype) x (s: set a): set a = on_dom _ (fun x' -> not (x = x') && s x')
+
+let insert_remove (#a:eqtype) x (s: set a)
+: Lemma (insert x (remove x s) == insert x s)
+= assert (insert x (remove x s) `feq` insert x s)
+
+let remove_insert (#a:eqtype) x (s: set a)
+: Lemma (remove x (insert x s) == remove x s)
+= assert (remove x (insert x s) `feq` remove x s)
+
+noeq type struct_fields = {
+  fields: list string; // for extraction only
+  has_field: set string;
+  // has_field_prf: forall field. has_field field <==> field `mem` fields;
+  get_field: string ^-> typedef;
+  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
+}
+
+let trivial_typedef: typedef = {
+  carrier = option unit;
+  pcm = opt_pcm #unit;
+  view_type = unit;
+  view = opt_view unit;
+}
+
+let nil: struct_fields = {
+  fields = [];
+  has_field = on_dom _ (fun _ -> false);
+  get_field = on_dom _ (fun _ -> trivial_typedef);
+}
+
+let cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
+  fields = field :: fields.fields;
+  has_field = on_dom _ (fun field' -> field = field' || fields.has_field field');
+  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
+}
+
+val struct (tag: string) (fields: struct_fields): Type0
+
+let struct_cod (fields: struct_fields) (field: string) =
+  (fields.get_field field).view_type
+
+let struct tag fields = restricted_t string (struct_cod fields)
+
+val mk_nil (tag: string): struct tag nil
+
+let mk_nil tag = on_dom _ (fun _ -> ())
+
+val mk_cons (tag: string) (fields: struct_fields)
+  (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
+: Pure (struct tag (cons field td fields))
+    (requires fields.has_field field == false)
+    (ensures fun _ -> True)
+
+let mk_cons tag fields field td x v =
+  on_dom _ (fun field' ->
+    if field = field' then x
+    else v field' <: ((cons field td fields).get_field field').view_type)
+
+val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
+
+let struct_pcm_carrier_cod (fields: struct_fields) (field: string) =
+  (fields.get_field field).carrier
+
+let struct_pcm_carrier tag fields =
+  restricted_t string (struct_pcm_carrier_cod fields)
+
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+
+let struct_pcms (fields: struct_fields) (field: string) = (fields.get_field field).pcm
+
+let struct_pcm tag fields = prod_pcm (struct_pcms fields)
+
+(* public *) let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
+
+/// Reading a struct field
+val struct_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (fields.get_field field).view_type
+
+/// Writing a struct field
+val struct_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).view_type)
+: struct tag fields
+
+let struct_get x field = x field
+let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
+
+/// For a fixed field name, struct_get and struct_put form a lens
+
+val struct_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).view_type)
+: Lemma (struct_put x field v `struct_get` field == v)
+  [SMTPat (struct_put x field v `struct_get` field)]
+
+val struct_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+: Lemma (struct_put x field (x `struct_get` field) == x)
+  [SMTPat (struct_put x field (x `struct_get` field))]
+
+val struct_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v w: (fields.get_field field).view_type)
+: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
+  [SMTPat (struct_put (struct_put x field v) field w)]
+
+/// struct_get/struct_put pairs for different fields don't interfere with each other
+
+val struct_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (fields.get_field field1).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
+  [SMTPat (struct_put x field1 v `struct_get` field2)]
+  
+val struct_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (v: (fields.get_field field1).view_type)
+  (field2: field_of fields)
+  (w: (fields.get_field field2).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_put (struct_put x field1 v) field2 w ==
+      struct_put (struct_put x field2 w) field1 v)
+      
+let struct_get_put x field v = ()
+
+let struct_put_get x field =
+  assert (struct_put x field (x `struct_get` field) `feq` x)
+
+let struct_put_put x field v w =
+  assert (struct_put (struct_put x field v) field w `feq` struct_put x field w)
+
+let struct_get_put_ne x field1 field2 v = ()
+
+let struct_put_put_ne x field1 v field2 w = 
+  assert (
+    struct_put (struct_put x field1 v) field2 w `feq`
+    struct_put (struct_put x field2 w) field1 v)
+
+(* public *)
+let struct_pcm_one (tag: string) (fields: struct_fields)
+: struct_pcm_carrier tag fields
+= one (struct_pcm tag fields)
+
+/// Reading a pcm_struct_carrier field
+val struct_pcm_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields) (field: field_of fields)
+: (fields.get_field field).carrier
+
+/// Writing a struct_pcm_carrier field
+val struct_pcm_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).carrier)
+: struct_pcm_carrier tag fields
+
+let struct_pcm_get x field = x field
+let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
+
+/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
+
+val struct_pcm_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).carrier)
+: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
+  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
+
+val struct_pcm_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
+  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
+
+val struct_pcm_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v w: (fields.get_field field).carrier)
+: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
+  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
+  
+/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
+
+val struct_pcm_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (fields.get_field field1).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
+  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
+  
+val struct_pcm_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (v: (fields.get_field field1).carrier)
+  (field2: field_of fields)
+  (w: (fields.get_field field2).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
+      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+let struct_pcm_get_put x field v = ()
+
+let struct_pcm_put_get x field =
+  assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
+
+let struct_pcm_put_put x field v w =
+  assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
+
+let struct_pcm_get_put_ne x field1 field2 v = ()
+
+let struct_pcm_put_put_ne x field1 v field2 w =
+   assert (
+     struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
+     struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+let minus (fields: struct_fields) (excluded: set string): struct_fields = {
+  fields = filter (fun field -> not (excluded field)) fields.fields;
+  has_field = on_dom _ (fun field -> fields.has_field field && not (excluded field));
+  get_field = on_dom _ (fun field -> if excluded field then trivial_typedef else fields.get_field field);
+}
+
+val struct_view (tag: string) (fields: struct_fields) (excluded: set string)
+: sel_view (struct_pcm tag fields) (struct tag (fields `minus` excluded)) false
+
+let struct_view_to_view_prop (tag: string) (fields: struct_fields) (excluded: set string)
+: struct_pcm_carrier tag fields -> prop
+= admit()
+
+let struct_view_to_view (tag: string) (fields: struct_fields) (excluded: set string)
+: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded) -> 
+  struct tag (fields `minus` excluded)
+= admit()
+
+let struct_view_to_carrier (tag: string) (fields: struct_fields) (excluded: set string)
+: struct tag (fields `minus` excluded) ->
+  refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded)
+= admit()
+
+// TODO: There will be a problem here when all fields are excluded
+let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields) (excluded: set string)
+: Lemma (
+    ~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
+    ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
+= admit()
+
+let struct_view_to_view_frame (tag: string) (fields: struct_fields) (excluded: set string)
+: (x: struct tag (fields `minus` excluded)) ->
+  (frame: struct_pcm_carrier tag fields) ->
+  Lemma
+    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame))
+    (ensures
+      struct_view_to_view_prop tag fields excluded
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) /\
+      struct_view_to_view tag fields excluded
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) == x)
+= admit()
+
+let struct_view tag fields excluded = {
+  to_view_prop = struct_view_to_view_prop tag fields excluded;
+  to_view = struct_view_to_view tag fields excluded;
+  to_carrier = struct_view_to_carrier tag fields excluded;
+  to_carrier_not_one = struct_view_to_carrier_not_one tag fields excluded;
+  to_view_frame = struct_view_to_view_frame tag fields excluded;
+}
+
+(*
+
+struct tag fields : Type
+
+struct_pcm_carrier tag fields : Type
+struct_pcm tag fields : pcm (struct_pcm_carrier tag fields)
+
+fields : list (string * typedef)
+
+type struct_fields = {fields: list string; get: string ^-> typedef; get_prf: dom(get) ⊆ fields}
+
+fields : struct_fields
+
+nil : struct_fields
+cons : string -> typedef -> struct_fields -> struct_fields
+
+struct_view tag fields excluded
+  carrier = struct_pcm tag fields
+  view_type = restricted_t (refine string (notin excluded)) (struct_pcm_carriers tag fields)
+
+val addr_of_struct_field 
+
+addr_of_struct_field #tag #point_fields p "x" <--- "x" should be a valid field name
+  p : ref base_type (struct_pcm tag fields)
+  "x" notin excluded
+  excluded : string ^-> bool
+  {p `pts_to_view` struct_view tag fields excluded}
+  {p `pts_to_view` struct_view tag fields (cons "x" excluded)
+   q `pts_to_view` struct_field_view tag fields "x"}
+
+unaddr_of_struct_field p "x"
+  p : ref base_type (struct_pcm tag fields)
+  "x" in excluded
+  excluded : string ^-> bool
+  q = ref_focus p ..
+  {p `pts_to_view` struct_view tag fields excluded
+   q `pts_to_view` struct_field_view tag fields "x"}
+  {p `pts_to_view` struct_view tag fields (excluded \ "x")}
+*)
+
 // open ChurchList
 
 (**** MOVE TO ChurchList *)
@@ -1067,51 +1408,6 @@ let explode'' p s =
 (*
 (*
 
-struct tag fields : Type
-
-struct_pcm_carrier tag fields : Type
-struct_pcm tag fields : pcm (struct_pcm_carrier tag fields)
-
-fields : list (string * typedef)
-
-type struct_fields = {fields: list string; get: string ^-> typedef; get_prf: dom(get) ⊆ fields}
-
-fields : struct_fields
-
-nil : struct_fields
-cons : string -> typedef -> struct_fields -> struct_fields
-
-struct_view tag fields excluded
-  carrier = struct_pcm tag fields
-  view_type = restricted_t (refine string (notin excluded)) (struct_pcm_carriers tag fields)
-
-mk_nil : nil
-
-mk_cons #tag #fields
-  (s: string) (t: typedef) (x: t.view_type) (v: struct tag fields)
-: struct tag (cons s t fields)
-
-get_field fields s = fields.get s
-
-val addr_of_struct_field 
-
-addr_of_struct_field #tag #point_fields p "x" <--- "x" should be a valid field name
-  p : ref base_type (struct_pcm tag fields)
-  "x" notin excluded
-  excluded : string ^-> bool
-  {p `pts_to_view` struct_view tag fields excluded}
-  {p `pts_to_view` struct_view tag fields (cons "x" excluded)
-   q `pts_to_view` struct_field_view tag fields "x"}
-
-unaddr_of_struct_field p "x"
-  p : ref base_type (struct_pcm tag fields)
-  "x" in excluded
-  excluded : string ^-> bool
-  q = ref_focus p ..
-  {p `pts_to_view` struct_view tag fields excluded
-   q `pts_to_view` struct_field_view tag fields "x"}
-  {p `pts_to_view` struct_view tag fields (excluded \ "x")}
-
 sel_view (struct_pcm tag fields) (struct tag (fields \ excluded)) false
 
 val explode'' (#opened: inames)

From a2f334185b2e8370edce00a0e7e169d3a4f78788 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 4 Aug 2021 15:03:19 -0700
Subject: [PATCH 169/513] (addr_of|unaddr_of)_struct_field with selectors

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 1189 ++++++-----------
 1 file changed, 390 insertions(+), 799 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 2f39295eeff..27b8cd534e1 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -14,347 +14,57 @@ open Steel.C.Opt
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-let set a = a ^-> bool
+let has_elements (#a:eqtype) (f: a ^-> bool) (xs: list a): prop =
+  forall x. f x == x `mem` xs
 
-let insert (#a:eqtype) x (s: set a): set a = on_dom _ (fun x' -> x = x' || s x')
+// Finite sets
+let set (a:eqtype) = f:(a ^-> bool){exists xs. f `has_elements` xs}
 
-let remove (#a:eqtype) x (s: set a): set a = on_dom _ (fun x' -> not (x = x') && s x')
+let set_as_list (s: set 'a): GTot (list 'a) =
+  FStar.IndefiniteDescription.indefinite_description_ghost (list 'a)
+    (has_elements s)
 
-let insert_remove (#a:eqtype) x (s: set a)
-: Lemma (insert x (remove x s) == insert x s)
-= assert (insert x (remove x s) `feq` insert x s)
-
-let remove_insert (#a:eqtype) x (s: set a)
-: Lemma (remove x (insert x s) == remove x s)
-= assert (remove x (insert x s) `feq` remove x s)
-
-noeq type struct_fields = {
-  fields: list string; // for extraction only
-  has_field: set string;
-  // has_field_prf: forall field. has_field field <==> field `mem` fields;
-  get_field: string ^-> typedef;
-  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
-}
-
-let trivial_typedef: typedef = {
-  carrier = option unit;
-  pcm = opt_pcm #unit;
-  view_type = unit;
-  view = opt_view unit;
-}
-
-let nil: struct_fields = {
-  fields = [];
-  has_field = on_dom _ (fun _ -> false);
-  get_field = on_dom _ (fun _ -> trivial_typedef);
-}
-
-let cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
-  fields = field :: fields.fields;
-  has_field = on_dom _ (fun field' -> field = field' || fields.has_field field');
-  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
-}
-
-val struct (tag: string) (fields: struct_fields): Type0
-
-let struct_cod (fields: struct_fields) (field: string) =
-  (fields.get_field field).view_type
-
-let struct tag fields = restricted_t string (struct_cod fields)
-
-val mk_nil (tag: string): struct tag nil
-
-let mk_nil tag = on_dom _ (fun _ -> ())
-
-val mk_cons (tag: string) (fields: struct_fields)
-  (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
-: Pure (struct tag (cons field td fields))
-    (requires fields.has_field field == false)
+let intro_set (#a:eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
+: Pure (set a)
+    (requires f `has_elements` xs)
     (ensures fun _ -> True)
+= Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
+  f 
 
-let mk_cons tag fields field td x v =
-  on_dom _ (fun field' ->
-    if field = field' then x
-    else v field' <: ((cons field td fields).get_field field').view_type)
-
-val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
-
-let struct_pcm_carrier_cod (fields: struct_fields) (field: string) =
-  (fields.get_field field).carrier
-
-let struct_pcm_carrier tag fields =
-  restricted_t string (struct_pcm_carrier_cod fields)
-
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
-
-let struct_pcms (fields: struct_fields) (field: string) = (fields.get_field field).pcm
-
-let struct_pcm tag fields = prod_pcm (struct_pcms fields)
-
-(* public *) let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
-
-/// Reading a struct field
-val struct_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (fields.get_field field).view_type
-
-/// Writing a struct field
-val struct_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).view_type)
-: struct tag fields
-
-let struct_get x field = x field
-let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
+let emptyset #a: set a = intro_set (on_dom a (fun _ -> false)) []
 
-/// For a fixed field name, struct_get and struct_put form a lens
+let insert x (s: set 'a): set 'a =
+  intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s)
 
-val struct_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).view_type)
-: Lemma (struct_put x field v `struct_get` field == v)
-  [SMTPat (struct_put x field v `struct_get` field)]
+let set_remove (#a:eqtype) x (s: a ^-> bool): (a ^-> bool) =
+  on_dom _ (fun x' -> not (x = x') && s x')
 
-val struct_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-: Lemma (struct_put x field (x `struct_get` field) == x)
-  [SMTPat (struct_put x field (x `struct_get` field))]
+let rec list_remove (#a:eqtype) x (xs: list a) = match xs with
+  | [] -> []
+  | x' :: xs ->
+    if x = x' then list_remove x xs
+    else x' :: list_remove x xs
 
-val struct_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v w: (fields.get_field field).view_type)
-: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
-  [SMTPat (struct_put (struct_put x field v) field w)]
-
-/// struct_get/struct_put pairs for different fields don't interfere with each other
-
-val struct_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (fields.get_field field1).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
-  [SMTPat (struct_put x field1 v `struct_get` field2)]
-  
-val struct_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field1: field_of fields)
-  (v: (fields.get_field field1).view_type)
-  (field2: field_of fields)
-  (w: (fields.get_field field2).view_type)
+let rec list_remove_spec (#a:eqtype) f x (xs: list a)
 : Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_put (struct_put x field1 v) field2 w ==
-      struct_put (struct_put x field2 w) field1 v)
-      
-let struct_get_put x field v = ()
-
-let struct_put_get x field =
-  assert (struct_put x field (x `struct_get` field) `feq` x)
-
-let struct_put_put x field v w =
-  assert (struct_put (struct_put x field v) field w `feq` struct_put x field w)
-
-let struct_get_put_ne x field1 field2 v = ()
-
-let struct_put_put_ne x field1 v field2 w = 
-  assert (
-    struct_put (struct_put x field1 v) field2 w `feq`
-    struct_put (struct_put x field2 w) field1 v)
-
-(* public *)
-let struct_pcm_one (tag: string) (fields: struct_fields)
-: struct_pcm_carrier tag fields
-= one (struct_pcm tag fields)
-
-/// Reading a pcm_struct_carrier field
-val struct_pcm_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields) (field: field_of fields)
-: (fields.get_field field).carrier
-
-/// Writing a struct_pcm_carrier field
-val struct_pcm_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).carrier)
-: struct_pcm_carrier tag fields
-
-let struct_pcm_get x field = x field
-let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
-
-/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
-
-val struct_pcm_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).carrier)
-: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
-  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
-
-val struct_pcm_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
-  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
-
-val struct_pcm_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v w: (fields.get_field field).carrier)
-: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
-  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
-  
-/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
-
-val struct_pcm_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (fields.get_field field1).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
-  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
-  
-val struct_pcm_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (v: (fields.get_field field1).carrier)
-  (field2: field_of fields)
-  (w: (fields.get_field field2).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
-      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
-let struct_pcm_get_put x field v = ()
-
-let struct_pcm_put_get x field =
-  assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
-
-let struct_pcm_put_put x field v w =
-  assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
-
-let struct_pcm_get_put_ne x field1 field2 v = ()
-
-let struct_pcm_put_put_ne x field1 v field2 w =
-   assert (
-     struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
-     struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
-let minus (fields: struct_fields) (excluded: set string): struct_fields = {
-  fields = filter (fun field -> not (excluded field)) fields.fields;
-  has_field = on_dom _ (fun field -> fields.has_field field && not (excluded field));
-  get_field = on_dom _ (fun field -> if excluded field then trivial_typedef else fields.get_field field);
-}
-
-val struct_view (tag: string) (fields: struct_fields) (excluded: set string)
-: sel_view (struct_pcm tag fields) (struct tag (fields `minus` excluded)) false
-
-let struct_view_to_view_prop (tag: string) (fields: struct_fields) (excluded: set string)
-: struct_pcm_carrier tag fields -> prop
-= admit()
-
-let struct_view_to_view (tag: string) (fields: struct_fields) (excluded: set string)
-: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded) -> 
-  struct tag (fields `minus` excluded)
-= admit()
-
-let struct_view_to_carrier (tag: string) (fields: struct_fields) (excluded: set string)
-: struct tag (fields `minus` excluded) ->
-  refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded)
-= admit()
-
-// TODO: There will be a problem here when all fields are excluded
-let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields) (excluded: set string)
-: Lemma (
-    ~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
-    ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
-= admit()
-
-let struct_view_to_view_frame (tag: string) (fields: struct_fields) (excluded: set string)
-: (x: struct tag (fields `minus` excluded)) ->
-  (frame: struct_pcm_carrier tag fields) ->
-  Lemma
-    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame))
-    (ensures
-      struct_view_to_view_prop tag fields excluded
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) /\
-      struct_view_to_view tag fields excluded
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) == x)
-= admit()
-
-let struct_view tag fields excluded = {
-  to_view_prop = struct_view_to_view_prop tag fields excluded;
-  to_view = struct_view_to_view tag fields excluded;
-  to_carrier = struct_view_to_carrier tag fields excluded;
-  to_carrier_not_one = struct_view_to_carrier_not_one tag fields excluded;
-  to_view_frame = struct_view_to_view_frame tag fields excluded;
-}
-
-(*
-
-struct tag fields : Type
-
-struct_pcm_carrier tag fields : Type
-struct_pcm tag fields : pcm (struct_pcm_carrier tag fields)
-
-fields : list (string * typedef)
-
-type struct_fields = {fields: list string; get: string ^-> typedef; get_prf: dom(get) ⊆ fields}
-
-fields : struct_fields
-
-nil : struct_fields
-cons : string -> typedef -> struct_fields -> struct_fields
-
-struct_view tag fields excluded
-  carrier = struct_pcm tag fields
-  view_type = restricted_t (refine string (notin excluded)) (struct_pcm_carriers tag fields)
-
-val addr_of_struct_field 
-
-addr_of_struct_field #tag #point_fields p "x" <--- "x" should be a valid field name
-  p : ref base_type (struct_pcm tag fields)
-  "x" notin excluded
-  excluded : string ^-> bool
-  {p `pts_to_view` struct_view tag fields excluded}
-  {p `pts_to_view` struct_view tag fields (cons "x" excluded)
-   q `pts_to_view` struct_field_view tag fields "x"}
+    (requires f `has_elements` xs)
+    (ensures set_remove x f `has_elements` list_remove x xs)
+    (decreases xs)
+= match xs with
+  | [] -> ()
+  | x' :: xs ->
+    let g: (a ^-> bool) = on_dom _ (fun x -> x `mem` xs) in
+    let f': (a ^-> bool) = on_dom _ (fun x'' -> x'' = x' || g x'') in
+    assert (f `feq` f');
+    assert (g `has_elements` xs);
+    list_remove_spec g x xs;
+    assert (set_remove x g `has_elements` list_remove x xs)
 
-unaddr_of_struct_field p "x"
-  p : ref base_type (struct_pcm tag fields)
-  "x" in excluded
-  excluded : string ^-> bool
-  q = ref_focus p ..
-  {p `pts_to_view` struct_view tag fields excluded
-   q `pts_to_view` struct_field_view tag fields "x"}
-  {p `pts_to_view` struct_view tag fields (excluded \ "x")}
-*)
+let remove x (s: set 'a): set 'a =
+  list_remove_spec s x (set_as_list s);
+  intro_set (set_remove x s) (list_remove x (set_as_list s))
 
-// open ChurchList
+let notin (s: set 'a) (x: 'a): prop = s x == false
 
 (**** MOVE TO ChurchList *)
 
@@ -480,279 +190,105 @@ let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
 
 (**** END MOVE TO ChurchList *)
 
-(**** BEGIN PUBLIC *)
-
-let struct_fields = clist u#1 (string * typedef)
-
-//[@@__reduce__]
-let has_field_bool (fields: struct_fields) (field: string): bool =
-  clist_elim0 fields (fun _ -> bool)
-    false
-    (fun (field', td) fields recur -> field = field' || recur)
-
-let has_field_bool_spec (fields: struct_fields) (field: string)
-: Lemma (has_field_bool fields field == field `mem` map fst fields.raw)
-  [SMTPat (has_field_bool fields field)]
-= let rec aux (fields: list (string * typedef))
-  : Lemma (list_elim fields (fun _ -> bool) false
-      (fun (field', td) fields recur -> field = field' || recur)
-      == field `mem` map fst fields)
-  = match fields with [] -> () | _ :: fields -> aux fields
-  in aux fields.raw
-
-//[@@__reduce__]
-let has_field (fields: struct_fields)
-: (string ^-> prop)
-= on_dom string (fun field -> has_field_bool fields field == true <: prop)
-
-let field_of (fields: struct_fields) = refine string (has_field fields)
-
-assume val trivial_typedef: typedef
-
-//[@@__reduce__]
-let get_field (fields: struct_fields) (field: field_of fields): typedef =
-  clist_elim1 fields (fun fields -> typedef) trivial_typedef
-    (fun (field', td) fields recur -> if field = field' then td else recur)
-
-(**** END PUBLIC *)
-
-let has_field_bool' (fields: list (string * typedef)) (field: string): bool =
-  field `mem` map fst fields
-
-let has_field' (fields: list (string * typedef))
-: (string ^-> prop)
-= on_dom _ (fun field -> has_field_bool' fields field == true <: prop)
-
-let field_of' (fields: list (string * typedef)) =
-  refine string (has_field' fields)
-
-let get_field' (fields: list (string * typedef)) (field: field_of' fields): typedef =
-  assoc_mem field fields;
-  Some?.v (assoc field fields)
-
-let get_field_spec_aux (fields: struct_fields) (field: field_of fields)
-: Lemma (get_field fields field
-    == (match assoc field fields.raw with Some td -> td | None -> trivial_typedef))
-= let rec aux (fields: list (string * typedef))
-  : Lemma (
-      list_elim fields (fun fields -> typedef) trivial_typedef
-        (fun (field', td) fields recur -> if field = field' then td else recur)
-      == (match assoc field fields with Some td -> td | None -> trivial_typedef))
-  = match fields with [] -> () | _ :: fields -> aux fields
-  in aux fields.raw
-
-let get_field_spec (fields: struct_fields) (field: field_of fields)
-: Lemma (get_field fields field == get_field' fields.raw field)
-  [SMTPat (get_field fields field)]
-= assoc_mem field fields.raw;
-  get_field_spec_aux fields field
-
-#push-options "--fuel 0"
-assume val nontrivial_typedef: typedef
-let _ =
-  let test_fields = normalize_term (mk_clist [
-    "a", trivial_typedef;
-    "b", trivial_typedef;
-    "c", trivial_typedef;
-    "d", trivial_typedef;
-    "e", trivial_typedef;
-    "f", trivial_typedef;
-    "g", trivial_typedef;
-    "h", trivial_typedef;
-    "i", trivial_typedef;
-    "j", nontrivial_typedef;
-  ]) in
-  assert (has_field_bool test_fields "e" == true);
-  assert (get_field test_fields "j" == nontrivial_typedef)
-#pop-options
-
-(**** BEGIN PUBLIC *)
-
-/// A view type for structs
-
-//[@@__reduce__]
-let struct_views (fields: struct_fields) (field: field_of fields)
-: sel_view ((get_field fields field).pcm) ((get_field fields field).view_type) false
-= (get_field fields field).view
-
-let const_Type (x: 'a) = Type
-
-//[@@__reduce__]
-let struct_view_types (fields: struct_fields)
-: restricted_t (field_of fields) const_Type
-= on_dom _ (fun field -> (get_field fields field).view_type)
-
-val struct (tag: string) (fields: struct_fields): Type0
-
-(**** END PUBLIC *)
-
-let struct_view_types' (fields: list (string * typedef))
-: restricted_t (field_of' fields) const_Type
-= on_dom _ (fun field -> (get_field' fields field).view_type)
-
-let struct tag fields = restricted_t (field_of fields) (struct_view_types fields)
-
-(**** BEGIN PUBLIC *)
-
-let struct_field_view_type ((_, td): string * typedef): Type = td.view_type
+noeq type struct_fields = {
+  //cfields: clist string;
+  cfields: list string;
+  has_field: set string;
+  //has_field_prf: squash (forall field. has_field field == field `mem` cfields);
+  get_field: string ^-> typedef;
+  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
+}
 
-(*
-let mk_struct_ty_dom (tag: string) (fields: struct_fields)
-: clist u#1 u#2 Type0
-= cmap struct_field_view_type fields
+let trivial_typedef: typedef = {
+  carrier = option unit;
+  pcm = opt_pcm #unit;
+  view_type = unit;
+  view = opt_view unit;
+}
 
-let clist_fn (dom: clist u#(1 + c) u#(max b (1 + c)) (Type u#c)) (cod: Type u#c): Type u#c =
-  raise_clist_elim dom (fun _ -> Type u#c) cod (fun d dom recur -> d -> recur)
+let fields_nil: struct_fields = {
+  cfields = [];
+  has_field = emptyset;
+  //has_field_prf = ();
+  get_field = on_dom _ (fun _ -> trivial_typedef);
+}
 
-let mk_struct_ty (tag: string) (fields: struct_fields): Type =
-  clist_fn u#0 u#2 (mk_struct_ty_dom tag fields) (struct tag fields)
+let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
+  cfields = field :: fields.cfields;
+  has_field = insert field fields.has_field;
+  //has_field_prf = ();
+  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
+}
 
-/// A struct literal
-val mk_struct (tag: string) (fields: struct_fields): mk_struct_ty tag fields
-*)
-(**** END PUBLIC *)
+val struct' (tag: string) (fields: struct_fields) (excluded: set string): Type0
 
-let struct' tag fields = restricted_t (field_of' fields) (struct_view_types' fields)
+let struct_dom (excluded: set string) = refine string (notin excluded)
 
-let field_of_eq fields
-: Lemma (field_of fields == field_of' fields.raw)
-  [SMTPat (field_of fields)]
-= assert (has_field fields `feq` has_field' fields.raw)
+let struct_cod (fields: struct_fields) (excluded: set string) (field: struct_dom excluded) =
+  (fields.get_field field).view_type
 
-let ext' (a a': Type) (b: a -> Type) (b': a' -> Type)
-  (f: restricted_t a b)
-  (g: restricted_t a' b')
-: Lemma (requires a == a' /\ b == b' /\ f `feq` g) (ensures f == g)
-= ()
+let struct' tag fields excluded =
+  restricted_t (struct_dom excluded) (struct_cod fields excluded)
 
-let struct_view_types_eq fields
-: Lemma (struct_view_types fields == struct_view_types' fields.raw)
-  [SMTPat (struct_view_types fields)]
-= ext' _ _ _ _ (struct_view_types fields) (struct_view_types' fields.raw)
+let struct (tag: string) (fields: struct_fields) = struct' tag fields emptyset
 
-let list_fn (dom: list (Type u#a)) (cod: Type u#a): Type u#a =
-  list_elim dom (fun _ -> Type) cod (fun d dom recur -> d -> recur)
+val mk_nil (tag: string): struct tag fields_nil
 
-let mk_struct_ty' tag fields =
-  map struct_field_view_type fields `list_fn` struct' tag fields
+let mk_nil tag = on_dom _ (fun _ -> ())
 
-(*
-let mk_struct_ty_eq tag fields
-: Lemma (mk_struct_ty tag fields == mk_struct_ty' tag fields.raw)
-= ()
+val mk_cons (tag: string) (fields: struct_fields)
+  (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
+: Pure (struct tag (fields_cons field td fields))
+    (requires fields.has_field field == false)
+    (ensures fun _ -> True)
 
-let unreachable (a: Type) : Pure a (requires False) (ensures fun _ -> True)
-= ()
+let mk_cons tag fields field td x v =
+  on_dom (refine string (notin emptyset)) (fun field' ->
+    if field = field' then x
+    else v field' <: ((fields_cons field td fields).get_field field').view_type)
 
-let rec list_fn_map #dom (f: 'a -> 'b) (g: dom `list_fn` 'a): dom `list_fn` 'b = match dom with 
-  | [] -> f g <: [] `list_fn` 'b
-  | d :: dom' ->
-    let g: d -> dom' `list_fn` 'a = g in
-    fun (x:d) -> list_fn_map f (g x) <: dom' `list_fn` 'b
-
-let rec mk_struct' (tag: string) (fields: list (string * typedef))
-: mk_struct_ty' tag fields
-= match fields with
-  | [] -> on_dom (field_of' []) (fun field -> unreachable (struct_view_types' [] field))
-  | (field, td) :: fields' ->
-    fun (x:td.view_type) ->
-    let lift_struct (g: struct' tag fields'): struct' tag fields =
-      let h (field': field_of' fields): struct_view_types' fields field' =
-        if field' = field then x else g field'
-      in on_dom _ h
-    in
-    list_fn_map lift_struct (mk_struct' tag fields')
-
-let mk_struct tag fields = mk_struct' tag fields.raw
-*)
+val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
 
-(*
-let one_list_elim
-  (b:(list Type -> Type))
-  (base:b [])
-  (ind:(x:Type -> xs:list Type -> b xs -> b (x :: xs)))
-: b [int]
-= ind int [] base
-
-let one_list_elim'
-  (base:Type)
-  (ind:(x:Type -> xs:list Type -> Type -> Type))
-: Type
-= ind int [] base
-
-let one_list_elim''
-  (base:Type)
-: Type
-= int -> base
-*)
+let struct_pcm_carrier_cod (fields: struct_fields) (field: string) =
+  (fields.get_field field).carrier
 
-(*
-let f (a:Type): Type = int -> a
+let struct_pcm_carrier tag fields =
+  restricted_t string (struct_pcm_carrier_cod fields)
 
-let _ = assert (f bool == (int -> bool))
-*)
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
 
-#push-options "--fuel 0"
+let struct_pcms (fields: struct_fields) (field: string)
+: pcm (struct_pcm_carrier_cod fields field)
+= (fields.get_field field).pcm
 
-(*
-let _ =
-  //let c_int: typedef = {
-  //  carrier = option int;
-  //  pcm = Steel.C.Opt.opt_pcm #int;
-  //  view_type = int;
-  //  view = Steel.C.Opt.opt_view int;
-  //} in
-  //let fields = normalize_term (mk_clist [
-  //  "x", c_int;
-  //  //"y", c_int;
-  //  //"z", c_int;
-  //]) in
-  //let args = normalize_term (fun b base ind -> list_elim (int :: ([] #Type))) in
-  //assert (args `clist_fn` bool == (int -> bool));
-  //assert (one_list_elim (fun _ -> Type) bool (fun d dom recur -> int -> recur)
-  //  == (int -> bool));
-  //assert (one_list_elim' bool (fun d dom recur -> int -> recur)
-  //  == (int -> bool));
-  assert (one_list_elim'' bool == (int -> bool));
-  //assert (args.elim (fun _ -> int) 0 (fun n ns sum -> n + sum)
-  //  == 3);
-  //assert (mk_struct_ty "a" fields == (int -> struct "a" fields));
-  //let _ : int -> int -> int -> struct "a" fields =
-  //  mk_struct "a" fields
-  //in ()
-  ()
-*)
+let struct_pcm tag fields = prod_pcm (struct_pcms fields)
 
-#pop-options
+(* public *) let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
 
-(**** BEGIN PUBLIC *)
 /// Reading a struct field
 val struct_get
   (#tag: string) (#fields: struct_fields)
   (x: struct tag fields) (field: field_of fields)
-: (get_field fields field).view_type
+: (fields.get_field field).view_type
 
 /// Writing a struct field
 val struct_put
   (#tag: string) (#fields: struct_fields)
   (x: struct tag fields)
   (field: field_of fields)
-  (v: (get_field fields field).view_type)
+  (v: (fields.get_field field).view_type)
 : struct tag fields
-(**** END PUBLIC *)
 
 let struct_get x field = x field
 let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
-(**** BEGIN PUBLIC *)
-
 /// For a fixed field name, struct_get and struct_put form a lens
 
 val struct_get_put 
   (#tag: string) (#fields: struct_fields)
   (x: struct tag fields)
   (field: field_of fields)
-  (v: (get_field fields field).view_type)
+  (v: (fields.get_field field).view_type)
 : Lemma (struct_put x field v `struct_get` field == v)
   [SMTPat (struct_put x field v `struct_get` field)]
 
@@ -767,7 +303,7 @@ val struct_put_put
   (#tag: string) (#fields: struct_fields)
   (x: struct tag fields)
   (field: field_of fields)
-  (v w: (get_field fields field).view_type)
+  (v w: (fields.get_field field).view_type)
 : Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
   [SMTPat (struct_put (struct_put x field v) field w)]
 
@@ -778,7 +314,7 @@ val struct_get_put_ne
   (x: struct tag fields)
   (field1: field_of fields)
   (field2: field_of fields)
-  (v: (get_field fields field1).view_type)
+  (v: (fields.get_field field1).view_type)
 : Lemma
     (requires field1 =!= field2)
     (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
@@ -788,16 +324,15 @@ val struct_put_put_ne
   (#tag: string) (#fields: struct_fields)
   (x: struct tag fields)
   (field1: field_of fields)
-  (v: (get_field fields field1).view_type)
+  (v: (fields.get_field field1).view_type)
   (field2: field_of fields)
-  (w: (get_field fields field2).view_type)
+  (w: (fields.get_field field2).view_type)
 : Lemma
     (requires field1 =!= field2)
     (ensures
       struct_put (struct_put x field1 v) field2 w ==
       struct_put (struct_put x field2 w) field1 v)
-(**** END PUBLIC *)
-
+      
 let struct_get_put x field v = ()
 
 let struct_put_get x field =
@@ -813,47 +348,7 @@ let struct_put_put_ne x field1 v field2 w =
     struct_put (struct_put x field1 v) field2 w `feq`
     struct_put (struct_put x field2 w) field1 v)
 
-(**** BEGIN PUBLIC *)
-/// Similarly, a PCM for structs
-
-//[@@__reduce__]
-let struct_carriers (fields: struct_fields)
-: restricted_t (field_of fields) const_Type
-= on_dom _ (fun (field: field_of fields) -> (get_field fields field).carrier)
-
-//[@@__reduce__]
-let struct_pcms (tag: string) (fields: struct_fields) (field: field_of fields)
-: pcm (struct_carriers fields field)
-= (get_field fields field).pcm
-
-val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
-(**** END PUBLIC *)
-
-let struct_carriers' (fields: list (string * typedef))
-: restricted_t (field_of' fields) const_Type
-= on_dom _ (fun field -> (get_field' fields field).carrier)
-
-let struct_carriers_eq fields
-: Lemma (struct_carriers fields == struct_carriers' fields.raw)
-  [SMTPat (struct_carriers fields)]
-= ext' _ _ _ _ (struct_carriers fields) (struct_carriers' fields.raw)
-  
-let struct_pcm_carrier' tag fields = restricted_t (field_of' fields) (struct_carriers' fields)
-
-let struct_pcm_carrier tag fields = restricted_t (field_of fields) (struct_carriers fields)
-
-let struct_pcms' (tag: string) (fields: list (string * typedef)) (field: field_of' fields)
-: pcm (struct_carriers' fields field)
-= (get_field' fields field).pcm
-
-(**** BEGIN PUBLIC *)
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
-(**** END PUBLIC *)
-let struct_pcm tag fields = prod_pcm (struct_pcms tag fields)
-
-let struct_field_carrier ((_, td): string * typedef): Type = td.carrier
-
-(**** BEGIN PUBLIC *)
+(* public *)
 let struct_pcm_one (tag: string) (fields: struct_fields)
 : struct_pcm_carrier tag fields
 = one (struct_pcm tag fields)
@@ -862,30 +357,26 @@ let struct_pcm_one (tag: string) (fields: struct_fields)
 val struct_pcm_get
   (#tag: string) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields) (field: field_of fields)
-: (get_field fields field).carrier
+: (fields.get_field field).carrier
 
 /// Writing a struct_pcm_carrier field
 val struct_pcm_put
   (#tag: string) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
-  (v: (get_field fields field).carrier)
+  (v: (fields.get_field field).carrier)
 : struct_pcm_carrier tag fields
 
-(**** END PUBLIC *)
-
 let struct_pcm_get x field = x field
 let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
-(**** BEGIN PUBLIC *)
-
 /// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
 
 val struct_pcm_get_put 
   (#tag: string) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
-  (v: (get_field fields field).carrier)
+  (v: (fields.get_field field).carrier)
 : Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
   [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
 
@@ -900,7 +391,7 @@ val struct_pcm_put_put
   (#tag: string) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
-  (v w: (get_field fields field).carrier)
+  (v w: (fields.get_field field).carrier)
 : Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
   [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
   
@@ -911,7 +402,7 @@ val struct_pcm_get_put_ne
   (x: struct_pcm_carrier tag fields)
   (field1: field_of fields)
   (field2: field_of fields)
-  (v: (get_field fields field1).carrier)
+  (v: (fields.get_field field1).carrier)
 : Lemma
     (requires field1 =!= field2)
     (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
@@ -921,42 +412,15 @@ val struct_pcm_put_put_ne
   (#tag: string) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field1: field_of fields)
-  (v: (get_field fields field1).carrier)
+  (v: (fields.get_field field1).carrier)
   (field2: field_of fields)
-  (w: (get_field fields field2).carrier)
+  (w: (fields.get_field field2).carrier)
 : Lemma
     (requires field1 =!= field2)
     (ensures
       struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
       struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-/// Struct PCM carrier values are extensional
-
-let struct_eq
-  (#tag: string) (#fields: struct_fields)
-  (x y: struct_pcm_carrier tag fields)
-= forall (field: field_of fields).
-  x `struct_pcm_get` field == y `struct_pcm_get` field
-
-// let struct_eq
-//   (#tag: string) (#fields: struct_fields)
-//   (x y: struct_pcm_carrier tag fields)
-// = raise_clist_elim u#1 u#2 u#_ fields (fun _ -> prop) True
-//     (fun (field, td) _ recur ->
-//       has_field_bool fields field /\
-//       x `struct_pcm_get` field == y `struct_pcm_get` field /\
-//       recur)
-
-val struct_pcm_ext
-  (#tag: string) (#fields: struct_fields)
-  (x y: struct_pcm_carrier tag fields)
-: Lemma
-    (requires x `struct_eq` y)
-    (ensures x == y)
-    [SMTPat (x `struct_eq` y)]
-
-(**** END PUBLIC *)
-
 let struct_pcm_get_put x field v = ()
 
 let struct_pcm_put_get x field =
@@ -972,115 +436,297 @@ let struct_pcm_put_put_ne x field1 v field2 w =
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-let struct_pcm_ext x y = assert (x `feq` y)
+val struct_view (tag: string) (fields: struct_fields) (excluded: set string)
+: sel_view (struct_pcm tag fields) (struct' tag fields excluded) false
 
-#push-options "--fuel 0"
-let _ =
-  let c_int: typedef = {
-    carrier = option int;
-    pcm = Steel.C.Opt.opt_pcm #int;
-    view_type = int;
-    view = Steel.C.Opt.opt_view int;
-  } in
-  let fields = normalize_term (mk_clist [
-    "x", c_int;
-    "y", c_int;
-    "z", c_int;
-    //"w", c_int;
-  ]) in
-  let aux (s t: struct_pcm_carrier "" fields) =
-    //assert (has_field_bool fields "x");
-    //assert (has_field_bool fields "y");
-    //assert (has_field_bool fields "z");
-    let x: field_of fields = "x" in
-    let y: field_of fields = "y" in
-    let z: field_of fields = "z" in
-    //assert (has_field_bool fields "w");
-    //assume (s `struct_pcm_get` "x" == t `struct_pcm_get` "x");
-    //assume (s `struct_pcm_get` "y" == t `struct_pcm_get` "y");
-    //assume (s `struct_pcm_get` "z" == t `struct_pcm_get` "z");
-    //assume (s `struct_pcm_get` "w" == t `struct_pcm_get` "w");
-    assume (s `struct_pcm_get` x == t `struct_pcm_get` x);
-    assume (s `struct_pcm_get` y == t `struct_pcm_get` y);
-    assume (s `struct_pcm_get` z == t `struct_pcm_get` z);
-    //assume (s `struct_pcm_get` w == t `struct_pcm_get` w);
-    //assert (s `struct_eq` t);
-    ()
-  in ()
-#pop-options
+let struct_view_to_view_prop (tag: string) (fields: struct_fields) (excluded: set string)
+: struct_pcm_carrier tag fields -> prop
+= fun x -> forall (field: struct_dom excluded).
+  (fields.get_field field).view.to_view_prop (x field) /\
+  (fields.has_field field == false ==> x field =!= one (fields.get_field field).pcm)
 
-(**** BEGIN PUBLIC *)
+let struct_view_to_view (tag: string) (fields: struct_fields) (excluded: set string)
+: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded) -> 
+  struct' tag fields excluded
+= fun x -> on_dom (struct_dom excluded) (fun field -> (fields.get_field field).view.to_view (x field))
 
-/// View a struct_pcm_carrier as a struct
-val struct_view (tag: string) (fields: struct_fields{Cons? fields.raw})
-: sel_view (struct_pcm tag fields) (struct tag fields) false
+let struct_view_to_carrier (tag: string) (fields: struct_fields) (excluded: set string)
+: struct' tag fields excluded ->
+  refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded)
+= fun x ->
+  let y: struct_pcm_carrier tag fields =
+    on_dom _ (fun field ->
+      if excluded field then one (fields.get_field field).pcm else
+      (fields.get_field field).view.to_carrier (x field)
+      <: (fields.get_field field).carrier)
+  in y
 
-(**** END PUBLIC *)
+module S = FStar.String
 
-let field_views (tag: string) (fields: struct_fields) (field: field_of fields)
-: sel_view (struct_pcms tag fields field) (struct_view_types fields field) false
-= (get_field fields field).view
+let rec max_len (excluded: list string)
+: Ghost nat True (fun n -> forall s'. memP s' excluded ==> n >= S.strlen s')
+= match excluded with
+  | [] -> 0
+  | field :: excluded -> 
+    let ih = max_len excluded in
+    if S.strlen field > ih then S.strlen field else ih
 
-let struct_view_to_view_prop (tag: string) (fields: struct_fields)
-: struct_pcm_carrier tag fields -> prop
-= fun x -> forall (field:field_of fields). (field_views tag fields field).to_view_prop (x field)
+let arbitrary_unexcluded_witness (excluded: list string)
+: Ghost string True (fun s -> forall s'. memP s' excluded ==> S.strlen s > S.strlen s')
+= S.make (max_len excluded + 1) ' '
 
-let struct_view_to_view (tag: string) (fields: struct_fields)
-: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields) ->
-  Tot (struct tag fields)
-= fun x -> on_dom _ (fun (field: field_of fields) -> (field_views tag fields field).to_view (x field))
+let arbitrary_unexcluded (excluded: set string): GTot (struct_dom excluded) =
+  arbitrary_unexcluded_witness (set_as_list excluded)
 
-let struct_view_to_carrier (tag: string) (fields: struct_fields)
-: struct tag fields ->
-  Tot (refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields))
-= fun x ->
-  let y: struct_pcm_carrier tag fields =
-    on_dom _ (fun (field: field_of fields) ->
-      (field_views tag fields field).to_carrier (x field)
-      <: struct_carriers' fields.raw field)
-  in y
+let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields) (excluded: set string)
+: Lemma 
+    (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
+     ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
+= (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one
 
-#push-options "--z3rlimit 30"
-let struct_view_to_view_frame (tag: string) (fields: struct_fields)
-  (x: struct tag fields)
-  (frame: struct_pcm_carrier tag fields)
-: Lemma
-    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame))
+let struct_view_to_view_frame (tag: string) (fields: struct_fields) (excluded: set string)
+: (x: struct' tag fields excluded) ->
+  (frame: struct_pcm_carrier tag fields) ->
+  Lemma
+    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame))
     (ensures
-      struct_view_to_view_prop tag fields
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) /\ 
-      struct_view_to_view tag fields
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields x) frame) == x)
-= let p = struct_pcms tag fields in
-  let aux (k:field_of fields)
+      struct_view_to_view_prop tag fields excluded
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) /\
+      struct_view_to_view tag fields excluded
+        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) == x)
+= fun x frame ->
+  let p = struct_pcms fields in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  let aux (k:struct_dom excluded)
   : Lemma (
-      (field_views tag fields k).to_view_prop
-        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) /\
-      (field_views tag fields k).to_view
-        (op (p k) ((field_views tag fields k).to_carrier (x k)) (frame k)) == x k)
-  = assert (composable (p k) ((field_views tag fields k).to_carrier (x k)) (frame k));
-    (field_views tag fields k).to_view_frame (x k) (frame k)
+      (fields.get_field k).view.to_view_prop
+        (op (p k) (struct_view_to_carrier tag fields excluded x k) (frame k)) /\
+      (fields.get_field k).view.to_view
+        (op (p k) (struct_view_to_carrier tag fields excluded x k) (frame k)) == x k)
+  = assert (composable (p k) ((fields.get_field k).view.to_carrier (x k)) (frame k));
+    (fields.get_field k).view.to_view_frame (x k) (frame k)
   in FStar.Classical.forall_intro aux;
   assert (
-    struct_view_to_view tag fields
-       (op (prod_pcm p) (struct_view_to_carrier tag fields x) frame) `feq` x)
-       
-let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields{Cons? fields.raw})
-: squash (
-    ~ (exists x. struct_view_to_carrier tag fields x == one (struct_pcm tag fields)) /\
-    ~ (struct_view_to_view_prop tag fields (one (struct_pcm tag fields))))
-= let (field, _) :: _ = fields.raw in
-  let field: field_of fields = field in
-  (field_views tag fields field).to_carrier_not_one
-
-let struct_view tag fields = {
-  to_view_prop = struct_view_to_view_prop tag fields;
-  to_view = struct_view_to_view tag fields;
-  to_carrier = struct_view_to_carrier tag fields;
-  to_carrier_not_one = struct_view_to_carrier_not_one tag fields;
-  to_view_frame = struct_view_to_view_frame tag fields;
+    struct_view_to_view tag fields excluded
+       (op (prod_pcm p) (struct_view_to_carrier tag fields excluded x) frame) `feq` x)
+
+let struct_view tag fields excluded = {
+  to_view_prop = struct_view_to_view_prop tag fields excluded;
+  to_view = struct_view_to_view tag fields excluded;
+  to_carrier = struct_view_to_carrier tag fields excluded;
+  to_carrier_not_one = Classical.move_requires (struct_view_to_carrier_not_one tag fields) excluded;
+  to_view_frame = struct_view_to_view_frame tag fields excluded;
 }
 
+val struct_field
+  (tag: string) (fields: struct_fields) (field: field_of fields)
+: connection (struct_pcm tag fields) (struct_pcms fields field)
+
+let struct_field tag fields field = struct_field (struct_pcms fields) field
+
+let struct'_without_field
+  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (v: struct' tag fields excluded)
+: struct' tag fields (insert field excluded)
+= on_dom (struct_dom (insert field excluded)) v
+
+let struct_without_field_to_carrier
+  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (s: struct_pcm_carrier tag fields)
+  (v: struct' tag fields excluded)
+: Lemma
+    (requires s == (struct_view tag fields excluded).to_carrier v)
+    (ensures
+      struct_without_field (struct_pcms fields) field s
+      == (struct_view tag fields (insert field excluded)).to_carrier
+           (struct'_without_field tag fields excluded field v))
+= assert (
+    struct_without_field (struct_pcms fields) field s
+    `feq` (struct_view tag fields (insert field excluded)).to_carrier
+         (struct'_without_field tag fields excluded field v))
+
+let extract_field
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+: Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
+    (requires not (excluded field))
+    (ensures fun _ -> True)
+= (struct'_without_field tag fields excluded field v, v field)
+
+val addr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (struct_pcms fields field))
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (q `pts_to_view` (fields.get_field field).view))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+
+#push-options "--z3rlimit 30"
+let addr_of_struct_field #a #tag #fields #excluded field p =
+  let v: Ghost.erased (struct' tag fields excluded) =
+    gget (p `pts_to_view` struct_view tag fields excluded)
+  in
+  let s: Ghost.erased (struct_pcm_carrier tag fields) =
+    pts_to_view_elim p (struct_view tag fields excluded)
+  in
+  //assert (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v);
+  //slassert (p `pts_to` s);
+  let q = addr_of_struct_field p field s in
+  assert (q == ref_focus p (struct_field tag fields field));
+  //slassert (
+  //  (p `pts_to` struct_without_field (struct_pcms fields) field s) `star`
+  //  (q `pts_to` Ghost.reveal s field));
+  struct_without_field_to_carrier tag fields excluded field s v;
+  pts_to_view_intro p (struct_without_field (struct_pcms fields) field s)
+    (struct_view tag fields (insert field excluded))
+    (struct'_without_field tag fields excluded field v);
+  pts_to_view_intro q (Ghost.reveal s field)
+    (fields.get_field field).view
+    (Ghost.reveal v field);
+  return q
+#pop-options
+
+let insert_remove x (s: set 'a)
+: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
+  [SMTPat (insert x (remove x s))]
+= assert (insert x (remove x s) `feq` s)
+
+// let remove_insert x (s: set 'a)
+// : Lemma (remove x (insert x s) == remove x s)
+// = assert (remove x (insert x s) `feq` remove x s)
+
+val unaddr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (q: ref 'a (struct_pcms fields field))
+: Steel unit
+    ((p `pts_to_view` struct_view tag fields excluded) `star`
+     (q `pts_to_view` (fields.get_field field).view))
+    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
+    (requires fun _ ->
+      excluded field == true /\
+      q == ref_focus p (struct_field tag fields field))
+    (ensures fun h _ h' -> 
+      excluded field == true /\
+      extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
+       ==
+        (h (p `pts_to_view` struct_view tag fields excluded),
+         h (q `pts_to_view` (fields.get_field field).view)))
+
+let struct'_with_field
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: string) (w: (fields.get_field field).view_type)
+  (v: struct' tag fields excluded)
+: Pure (struct' tag fields (remove field excluded))
+    (requires excluded field == true)
+    (ensures fun _ -> True)
+= on_dom (struct_dom (remove field excluded))
+    (fun field' -> if field = field' then w else v field')
+
+let struct_with_field_to_carrier
+  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (s: struct_pcm_carrier tag fields)
+  (t: (fields.get_field field).carrier)
+  (v: struct' tag fields excluded)
+  (w: (fields.get_field field).view_type)
+: Lemma
+    (requires
+      excluded field == true /\
+      s == (struct_view tag fields excluded).to_carrier v /\
+      t === (fields.get_field field).view.to_carrier w)
+    (ensures
+      struct_with_field (struct_pcms fields) field t s
+      == (struct_view tag fields (remove field excluded)).to_carrier
+           (struct'_with_field tag fields excluded field w v))
+= assert
+    (struct_with_field (struct_pcms fields) field t s
+      `feq` (struct_view tag fields (remove field excluded)).to_carrier
+           (struct'_with_field tag fields excluded field w v))
+
+let struct_with_field_to_carrier'
+  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (s: struct_pcm_carrier tag fields)
+  (t: (fields.get_field field).carrier)
+  (v: struct' tag fields excluded)
+  (w: (fields.get_field field).view_type)
+  (h1: squash (excluded field == true))
+  (h2: squash (s == (struct_view tag fields excluded).to_carrier v))
+  (h3: squash (t == (fields.get_field field).view.to_carrier w))
+: Lemma
+    (struct_with_field (struct_pcms fields) field t s
+      == (struct_view tag fields (remove field excluded)).to_carrier
+           (struct'_with_field tag fields excluded field w v))
+= assert
+    (struct_with_field (struct_pcms fields) field t s
+      `feq` (struct_view tag fields (remove field excluded)).to_carrier
+           (struct'_with_field tag fields excluded field w v))
+
+let extract_field_with_field
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+  (w: (fields.get_field field).view_type)
+: Lemma
+    (requires excluded field == true)
+    (ensures
+      extract_field tag fields (remove field excluded) field
+         (struct'_with_field tag fields excluded field w v)
+         == (v, w))
+= assert (struct'_without_field tag fields (remove field excluded) field
+    (struct'_with_field tag fields excluded field w v)
+    `feq` v)
+
+let unaddr_of_struct_field #a #tag #fields #excluded field p q =
+  let v: Ghost.erased (struct' tag fields excluded) =
+    gget (p `pts_to_view` struct_view tag fields excluded)
+  in
+  let s: Ghost.erased (struct_pcm_carrier tag fields) =
+    pts_to_view_elim p (struct_view tag fields excluded)
+  in
+  let w: Ghost.erased (fields.get_field field).view_type =
+    gget (q `pts_to_view` (fields.get_field field).view)
+  in
+  let t: Ghost.erased (fields.get_field field).carrier =
+    pts_to_view_elim q (fields.get_field field).view
+  in
+  //slassert ((p `pts_to` s) `star` (q `pts_to` t));
+  //assert (Ghost.reveal s field == one (struct_pcms fields field));
+  //assert (q == ref_focus p (Struct.struct_field (struct_pcms fields) field));
+  unaddr_of_struct_field #_ #_ #_ #(struct_pcms fields) field q p s t;
+  let h1: squash (excluded field == true) = () in
+  let h2: squash (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v) = () in
+  let h3: squash (Ghost.reveal t == (fields.get_field field).view.to_carrier w) = () in
+  struct_with_field_to_carrier' tag fields excluded field
+    (Ghost.reveal s) (Ghost.reveal t) (Ghost.reveal v) (Ghost.reveal w)
+    h1 h2 h3; // TODO why need pass explicitly
+  assert (struct_with_field (struct_pcms fields) field t s
+      == (struct_view tag fields (remove field excluded)).to_carrier
+           (struct'_with_field tag fields excluded field w v));
+  pts_to_view_intro p
+    (struct_with_field (struct_pcms fields) field t s)
+    (struct_view tag fields (remove field excluded))
+    (struct'_with_field tag fields excluded field w v);
+  extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
+  assert
+     (extract_field tag fields (remove field excluded) field
+         (struct'_with_field tag fields excluded field w v)
+         == (Ghost.reveal v, Ghost.reveal w));
+  return ()
+  
 (**** MOVE EVERYTHING BELOW TO SEPARATE FILES *)
 
 /// TODO move and dedup with Steel.C.Ptr.fst
@@ -1148,66 +794,9 @@ assume val pts_to_v
 assume val struct_get'
   (#tag: string) (#fields: struct_fields)
   (x: struct tag fields) (field: field_of fields)
-: (get_field fields field).view_type
-
-assume val struct_field':
-  tag: string -> fields: struct_fields -> field: field_of fields
-    -> Prims.Tot
-      (connection #(struct_pcm_carrier tag fields)
-          #(struct_carriers fields field)
-          (struct_pcm tag fields)
-          (struct_pcms tag fields field))
-
-//[@@__reduce__]
-let pts_to_field
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (s: struct tag fields)
-  (field: field_of fields)
-: vprop
-= pts_to_v
-    (ref_focus p (struct_field' tag fields field))
-    (struct_views fields field)
-    (s `struct_get'` field)
-
-//[@@__reduce__]
-let pts_to_fields'
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (s: struct tag fields)
-  (fields': struct_fields)
-: vprop
-= clist_elim2 fields' (fun _ -> vprop)
-    emp
-    (fun (field, _) _ recur ->
-      if has_field_bool fields field then begin
-        pts_to_field tag fields p s field `star` recur
-      end else emp)
-
-//[@@__reduce__]
-let pts_to_fields
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (s: struct tag fields)
-: vprop
-= pts_to_fields' tag fields p s fields
-
-assume val explode (#opened: inames)
-  (tag: string) (fields: struct_fields{Cons? fields.raw})
-  (p: ref 'a (struct_pcm tag fields))
-  (s: Ghost.erased (struct tag fields))
-: SteelGhostT unit opened
-    (pts_to_v p (struct_view tag fields) s)
-    (fun _ -> pts_to_fields tag fields p s)
-
-assume val recombine (#opened: inames)
-  (tag: string) (fields: struct_fields{Cons? fields.raw})
-  (p: ref 'a (struct_pcm tag fields))
-  (s: Ghost.erased (struct tag fields))
-: SteelGhostT unit opened
-    (pts_to_fields tag fields p s)
-    (fun _ -> pts_to_v p (struct_view tag fields) s)
+: (fields.get_field field).view_type
 
+(*
 /// Point struct
 
 open Steel.C.Opt
@@ -2268,3 +1857,5 @@ let recombine_oct' p =
 
 #pop-options
 *)
+
+*)

From b33d8abf05bc51704000980cbd6698b48b562ce7 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 5 Aug 2021 08:40:24 -0700
Subject: [PATCH 170/513] Make fsti for StructLiteral

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 454 ++----------------
 .../arraystructs/Steel.C.StructLiteral.fsti   | 428 +++++++++++++++++
 2 files changed, 465 insertions(+), 417 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.StructLiteral.fsti

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 27b8cd534e1..8fce3de0bfa 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -8,220 +8,13 @@ open Steel.Effect.Atomic
 open Steel.C.PCM
 open Steel.C.Struct
 open Steel.C.Typedef
-open Steel.C.Ref // for refine
+open Steel.C.Ref
 open Steel.C.Connection
 open Steel.C.Opt
+
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-let has_elements (#a:eqtype) (f: a ^-> bool) (xs: list a): prop =
-  forall x. f x == x `mem` xs
-
-// Finite sets
-let set (a:eqtype) = f:(a ^-> bool){exists xs. f `has_elements` xs}
-
-let set_as_list (s: set 'a): GTot (list 'a) =
-  FStar.IndefiniteDescription.indefinite_description_ghost (list 'a)
-    (has_elements s)
-
-let intro_set (#a:eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
-: Pure (set a)
-    (requires f `has_elements` xs)
-    (ensures fun _ -> True)
-= Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
-  f 
-
-let emptyset #a: set a = intro_set (on_dom a (fun _ -> false)) []
-
-let insert x (s: set 'a): set 'a =
-  intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s)
-
-let set_remove (#a:eqtype) x (s: a ^-> bool): (a ^-> bool) =
-  on_dom _ (fun x' -> not (x = x') && s x')
-
-let rec list_remove (#a:eqtype) x (xs: list a) = match xs with
-  | [] -> []
-  | x' :: xs ->
-    if x = x' then list_remove x xs
-    else x' :: list_remove x xs
-
-let rec list_remove_spec (#a:eqtype) f x (xs: list a)
-: Lemma
-    (requires f `has_elements` xs)
-    (ensures set_remove x f `has_elements` list_remove x xs)
-    (decreases xs)
-= match xs with
-  | [] -> ()
-  | x' :: xs ->
-    let g: (a ^-> bool) = on_dom _ (fun x -> x `mem` xs) in
-    let f': (a ^-> bool) = on_dom _ (fun x'' -> x'' = x' || g x'') in
-    assert (f `feq` f');
-    assert (g `has_elements` xs);
-    list_remove_spec g x xs;
-    assert (set_remove x g `has_elements` list_remove x xs)
-
-let remove x (s: set 'a): set 'a =
-  list_remove_spec s x (set_as_list s);
-  intro_set (set_remove x s) (list_remove x (set_as_list s))
-
-let notin (s: set 'a) (x: 'a): prop = s x == false
-
-(**** MOVE TO ChurchList *)
-
-let rec list_elim (xs: list 'a)
-  (b:(list 'a -> Type))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: b xs
-= match xs with
-  | [] -> base
-  | x :: xs -> ind x xs (list_elim xs b base ind)
-
-let elim_t (#a: Type u#a) (xs: list a): Tot (Type u#(max a (1 + b))) =
-  b:(list a -> Type u#b) ->
-  base:b [] ->
-  ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
-  b xs
-
-//[@@__reduce__]
-noeq type clist (a:Type u#a): Type = {
-  raw: list a;
-  elim0: elim_t u#_ u#0 raw;
-  elim1: elim_t u#_ u#1 raw;
-  elim2: elim_t u#_ u#2 raw;
-  elim3: elim_t u#_ u#3 raw;
-}
-
-//[@@__reduce__]
-let clist_elim0
-  (c: clist 'a)
-  (b:(list 'a -> Type0))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: Pure (b c.raw)
-  (requires True)
-  (ensures (fun y -> y == list_elim c.raw b base ind))
-= let b' (l2: list 'a) : Type =
-    (x: b l2 { x == list_elim l2 b base ind })
-  in
-  c.elim0
-    b'
-    base
-    (fun x xs x' -> ind x xs x')
-
-//[@@__reduce__]
-let clist_elim1
-  (c: clist 'a)
-  (b:(list 'a -> Type u#1))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: Pure (b c.raw)
-  (requires True)
-  (ensures (fun y -> y == list_elim c.raw b base ind))
-= let b' (l2: list 'a) : Type =
-    (x: b l2 { x == list_elim l2 b base ind })
-  in
-  c.elim1
-    b'
-    base
-    (fun x xs x' -> ind x xs x')
-
-//[@@__reduce__]
-let clist_elim2
-  (c: clist 'a)
-  (b:(list 'a -> Type u#2))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: Pure (b c.raw)
-  (requires True)
-  (ensures (fun y -> y == list_elim c.raw b base ind))
-= let b' (l2: list 'a) : Type =
-    (x: b l2 { x == list_elim l2 b base ind })
-  in
-  c.elim2
-    b'
-    base
-    (fun x xs x' -> ind x xs x')
-
-#push-options "--print_universes --print_implicits"
-
-#push-options "--fuel 0"
-let mk_clist (xs: list 'a) = {
-  raw = xs;
-  elim0 = list_elim xs;
-  elim1 = list_elim xs;
-  elim2 = list_elim xs;
-  elim3 = list_elim xs;
-}
-let _ =
-  let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
-  assert (clist_elim0 xs (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
-#pop-options
-
-//[@@__reduce__]
-let nil (#a: Type u#a): clist u#a a = {
-  raw = [];
-  elim0 = (fun _ base _ -> base);
-  elim1 = (fun _ base _ -> base);
-  elim2 = (fun _ base _ -> base);
-  elim3 = (fun _ base _ -> base);
-}
-
-//[@@__reduce__]
-let cons (#a: Type u#a) (x: a) (xs: clist u#a a): clist u#a a = {
-  raw = x :: xs.raw;
-  elim0 = (fun b base ind -> ind x xs.raw (xs.elim0 b base ind));
-  elim1 = (fun b base ind -> ind x xs.raw (xs.elim1 b base ind));
-  elim2 = (fun b base ind -> ind x xs.raw (xs.elim2 b base ind));
-  elim3 = (fun b base ind -> ind x xs.raw (xs.elim3 b base ind));
-}
-
-//[@@__reduce__]
-let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 a): bool
-= clist_elim0 xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
-
-//[@@__reduce__]
-let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
-: Lemma (cmem x xs == mem x xs.raw)
-= let rec aux (xs: list a)
-  : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
-  = match xs with [] -> () | x :: xs -> aux xs
-  in aux xs.raw
-
-(**** END MOVE TO ChurchList *)
-
-noeq type struct_fields = {
-  //cfields: clist string;
-  cfields: list string;
-  has_field: set string;
-  //has_field_prf: squash (forall field. has_field field == field `mem` cfields);
-  get_field: string ^-> typedef;
-  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
-}
-
-let trivial_typedef: typedef = {
-  carrier = option unit;
-  pcm = opt_pcm #unit;
-  view_type = unit;
-  view = opt_view unit;
-}
-
-let fields_nil: struct_fields = {
-  cfields = [];
-  has_field = emptyset;
-  //has_field_prf = ();
-  get_field = on_dom _ (fun _ -> trivial_typedef);
-}
-
-let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
-  cfields = field :: fields.cfields;
-  has_field = insert field fields.has_field;
-  //has_field_prf = ();
-  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
-}
-
-val struct' (tag: string) (fields: struct_fields) (excluded: set string): Type0
-
 let struct_dom (excluded: set string) = refine string (notin excluded)
 
 let struct_cod (fields: struct_fields) (excluded: set string) (field: struct_dom excluded) =
@@ -230,108 +23,27 @@ let struct_cod (fields: struct_fields) (excluded: set string) (field: struct_dom
 let struct' tag fields excluded =
   restricted_t (struct_dom excluded) (struct_cod fields excluded)
 
-let struct (tag: string) (fields: struct_fields) = struct' tag fields emptyset
-
-val mk_nil (tag: string): struct tag fields_nil
-
 let mk_nil tag = on_dom _ (fun _ -> ())
 
-val mk_cons (tag: string) (fields: struct_fields)
-  (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
-: Pure (struct tag (fields_cons field td fields))
-    (requires fields.has_field field == false)
-    (ensures fun _ -> True)
-
 let mk_cons tag fields field td x v =
   on_dom (refine string (notin emptyset)) (fun field' ->
     if field = field' then x
     else v field' <: ((fields_cons field td fields).get_field field').view_type)
 
-val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
-
 let struct_pcm_carrier_cod (fields: struct_fields) (field: string) =
   (fields.get_field field).carrier
 
 let struct_pcm_carrier tag fields =
   restricted_t string (struct_pcm_carrier_cod fields)
-
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
-
+  
 let struct_pcms (fields: struct_fields) (field: string)
 : pcm (struct_pcm_carrier_cod fields field)
 = (fields.get_field field).pcm
 
 let struct_pcm tag fields = prod_pcm (struct_pcms fields)
 
-(* public *) let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
-
-/// Reading a struct field
-val struct_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (fields.get_field field).view_type
-
-/// Writing a struct field
-val struct_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).view_type)
-: struct tag fields
-
 let struct_get x field = x field
 let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
-
-/// For a fixed field name, struct_get and struct_put form a lens
-
-val struct_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).view_type)
-: Lemma (struct_put x field v `struct_get` field == v)
-  [SMTPat (struct_put x field v `struct_get` field)]
-
-val struct_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-: Lemma (struct_put x field (x `struct_get` field) == x)
-  [SMTPat (struct_put x field (x `struct_get` field))]
-
-val struct_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field: field_of fields)
-  (v w: (fields.get_field field).view_type)
-: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
-  [SMTPat (struct_put (struct_put x field v) field w)]
-
-/// struct_get/struct_put pairs for different fields don't interfere with each other
-
-val struct_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (fields.get_field field1).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
-  [SMTPat (struct_put x field1 v `struct_get` field2)]
-  
-val struct_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
-  (field1: field_of fields)
-  (v: (fields.get_field field1).view_type)
-  (field2: field_of fields)
-  (w: (fields.get_field field2).view_type)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_put (struct_put x field1 v) field2 w ==
-      struct_put (struct_put x field2 w) field1 v)
       
 let struct_get_put x field v = ()
 
@@ -348,79 +60,9 @@ let struct_put_put_ne x field1 v field2 w =
     struct_put (struct_put x field1 v) field2 w `feq`
     struct_put (struct_put x field2 w) field1 v)
 
-(* public *)
-let struct_pcm_one (tag: string) (fields: struct_fields)
-: struct_pcm_carrier tag fields
-= one (struct_pcm tag fields)
-
-/// Reading a pcm_struct_carrier field
-val struct_pcm_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields) (field: field_of fields)
-: (fields.get_field field).carrier
-
-/// Writing a struct_pcm_carrier field
-val struct_pcm_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).carrier)
-: struct_pcm_carrier tag fields
-
 let struct_pcm_get x field = x field
 let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
-/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
-
-val struct_pcm_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v: (fields.get_field field).carrier)
-: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
-  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
-
-val struct_pcm_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
-  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
-
-val struct_pcm_put_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field: field_of fields)
-  (v w: (fields.get_field field).carrier)
-: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
-  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
-  
-/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
-
-val struct_pcm_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (field2: field_of fields)
-  (v: (fields.get_field field1).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
-  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
-  
-val struct_pcm_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct_pcm_carrier tag fields)
-  (field1: field_of fields)
-  (v: (fields.get_field field1).carrier)
-  (field2: field_of fields)
-  (w: (fields.get_field field2).carrier)
-: Lemma
-    (requires field1 =!= field2)
-    (ensures
-      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
-      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
 let struct_pcm_get_put x field v = ()
 
 let struct_pcm_put_get x field =
@@ -436,9 +78,6 @@ let struct_pcm_put_put_ne x field1 v field2 w =
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-val struct_view (tag: string) (fields: struct_fields) (excluded: set string)
-: sel_view (struct_pcm tag fields) (struct' tag fields excluded) false
-
 let struct_view_to_view_prop (tag: string) (fields: struct_fields) (excluded: set string)
 : struct_pcm_carrier tag fields -> prop
 = fun x -> forall (field: struct_dom excluded).
@@ -482,7 +121,35 @@ let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields) (exclud
 : Lemma 
     (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
      ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
-= (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one
+= (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one;
+  let field: struct_dom excluded = (arbitrary_unexcluded excluded) in
+  assert (
+    (~ (exists x. (fields.get_field field).view.to_carrier x == one (struct_pcms fields field)) /\
+     ~ ((fields.get_field field).view.to_view_prop (one (struct_pcms fields field)))));
+     (*
+  let aux x
+  : Lemma (requires struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields))
+      (ensures exists x. (fields.get_field field).view.to_carrier x == one (struct_pcms fields field))
+  = //assert (has_type ((fields.get_field field).view.to_carrier (x field)) ((fields.get_field field).carrier));
+    //assert (has_type (one (fields.get_field field).pcm) ((fields.get_field field).carrier));
+    assert (struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields));
+    assert (struct_view_to_carrier tag fields excluded x field == one (struct_pcm tag fields) field);
+    //assert (
+    //  (   
+    //      (fields.get_field field).view.to_carrier (x field)
+    //      <: (fields.get_field field).carrier)
+    //  == one (struct_pcm tag fields) field);
+    assert (
+      (   
+          (fields.get_field field).view.to_carrier (x field)
+          <: (fields.get_field field).carrier)
+      == one (prod_pcm (struct_pcms fields)) field);
+    //assert ((fields.get_field field).view.to_carrier (x field) == one ((fields.get_field field).pcm));
+    //admit()
+  in*)
+  ()
+  //assume (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)));
+  //assume (~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
 
 let struct_view_to_view_frame (tag: string) (fields: struct_fields) (excluded: set string)
 : (x: struct' tag fields excluded) ->
@@ -518,10 +185,6 @@ let struct_view tag fields excluded = {
   to_view_frame = struct_view_to_view_frame tag fields excluded;
 }
 
-val struct_field
-  (tag: string) (fields: struct_fields) (field: field_of fields)
-: connection (struct_pcm tag fields) (struct_pcms fields field)
-
 let struct_field tag fields field = struct_field (struct_pcms fields) field
 
 let struct'_without_field
@@ -554,24 +217,10 @@ let extract_field
     (ensures fun _ -> True)
 = (struct'_without_field tag fields excluded field v, v field)
 
-val addr_of_struct_field
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
-  (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (struct_pcms fields field))
-    (p `pts_to_view` struct_view tag fields excluded)
-    (fun q ->
-      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
-      (q `pts_to_view` (fields.get_field field).view))
-    (requires fun _ -> not (excluded field))
-    (ensures fun h q h' -> 
-      not (excluded field) /\
-      q == ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
-       ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
+let insert_remove x (s: set 'a)
+: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
+  [SMTPat (insert x (remove x s))]
+= assert (insert x (remove x s) `feq` s)
 
 #push-options "--z3rlimit 30"
 let addr_of_struct_field #a #tag #fields #excluded field p =
@@ -598,35 +247,6 @@ let addr_of_struct_field #a #tag #fields #excluded field p =
   return q
 #pop-options
 
-let insert_remove x (s: set 'a)
-: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
-  [SMTPat (insert x (remove x s))]
-= assert (insert x (remove x s) `feq` s)
-
-// let remove_insert x (s: set 'a)
-// : Lemma (remove x (insert x s) == remove x s)
-// = assert (remove x (insert x s) `feq` remove x s)
-
-val unaddr_of_struct_field
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
-  (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (q: ref 'a (struct_pcms fields field))
-: Steel unit
-    ((p `pts_to_view` struct_view tag fields excluded) `star`
-     (q `pts_to_view` (fields.get_field field).view))
-    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
-    (requires fun _ ->
-      excluded field == true /\
-      q == ref_focus p (struct_field tag fields field))
-    (ensures fun h _ h' -> 
-      excluded field == true /\
-      extract_field tag fields (remove field excluded) field
-        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
-       ==
-        (h (p `pts_to_view` struct_view tag fields excluded),
-         h (q `pts_to_view` (fields.get_field field).view)))
-
 let struct'_with_field
   (tag: string) (fields: struct_fields) (excluded: set string)
   (field: string) (w: (fields.get_field field).view_type)
@@ -726,7 +346,7 @@ let unaddr_of_struct_field #a #tag #fields #excluded field p q =
          (struct'_with_field tag fields excluded field w v)
          == (Ghost.reveal v, Ghost.reveal w));
   return ()
-  
+
 (**** MOVE EVERYTHING BELOW TO SEPARATE FILES *)
 
 /// TODO move and dedup with Steel.C.Ptr.fst
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
new file mode 100644
index 00000000000..969226fb6f1
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -0,0 +1,428 @@
+module Steel.C.StructLiteral
+
+open Steel.Memory
+open Steel.Effect
+open Steel.Effect.Common
+open Steel.Effect.Atomic
+
+open Steel.C.PCM
+open Steel.C.Struct
+open Steel.C.Typedef
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.C.Opt
+
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+
+let has_elements (#a:eqtype) (f: a ^-> bool) (xs: list a): prop =
+  forall x. f x == x `mem` xs
+
+// Finite sets
+let set (a:eqtype) = f:(a ^-> bool){exists xs. f `has_elements` xs}
+
+let set_as_list (s: set 'a): GTot (list 'a) =
+  FStar.IndefiniteDescription.indefinite_description_ghost (list 'a)
+    (has_elements s)
+
+let intro_set (#a:eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
+: Pure (set a)
+    (requires f `has_elements` xs)
+    (ensures fun _ -> True)
+= Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
+  f 
+
+let emptyset #a: set a = intro_set (on_dom a (fun _ -> false)) []
+
+let insert x (s: set 'a): set 'a =
+  intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s)
+
+let set_remove (#a:eqtype) x (s: a ^-> bool): (a ^-> bool) =
+  on_dom _ (fun x' -> not (x = x') && s x')
+
+let rec list_remove (#a:eqtype) x (xs: list a) = match xs with
+  | [] -> []
+  | x' :: xs ->
+    if x = x' then list_remove x xs
+    else x' :: list_remove x xs
+
+let rec list_remove_spec (#a:eqtype) f x (xs: list a)
+: Lemma
+    (requires f `has_elements` xs)
+    (ensures set_remove x f `has_elements` list_remove x xs)
+    (decreases xs)
+= match xs with
+  | [] -> ()
+  | x' :: xs ->
+    let g: (a ^-> bool) = on_dom _ (fun x -> x `mem` xs) in
+    let f': (a ^-> bool) = on_dom _ (fun x'' -> x'' = x' || g x'') in
+    assert (f `feq` f');
+    assert (g `has_elements` xs);
+    list_remove_spec g x xs;
+    assert (set_remove x g `has_elements` list_remove x xs)
+
+let remove x (s: set 'a): set 'a =
+  list_remove_spec s x (set_as_list s);
+  intro_set (set_remove x s) (list_remove x (set_as_list s))
+
+let notin (s: set 'a) (x: 'a): prop = s x == false
+
+(**** MOVE TO ChurchList *)
+
+let rec list_elim (xs: list 'a)
+  (b:(list 'a -> Type))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: b xs
+= match xs with
+  | [] -> base
+  | x :: xs -> ind x xs (list_elim xs b base ind)
+
+let elim_t (#a: Type u#a) (xs: list a): Tot (Type u#(max a (1 + b))) =
+  b:(list a -> Type u#b) ->
+  base:b [] ->
+  ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
+  b xs
+
+//[@@__reduce__]
+noeq type clist (a:Type u#a): Type = {
+  raw: list a;
+  elim0: elim_t u#_ u#0 raw;
+  elim1: elim_t u#_ u#1 raw;
+  elim2: elim_t u#_ u#2 raw;
+  elim3: elim_t u#_ u#3 raw;
+}
+
+//[@@__reduce__]
+let clist_elim0
+  (c: clist 'a)
+  (b:(list 'a -> Type0))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: Pure (b c.raw)
+  (requires True)
+  (ensures (fun y -> y == list_elim c.raw b base ind))
+= let b' (l2: list 'a) : Type =
+    (x: b l2 { x == list_elim l2 b base ind })
+  in
+  c.elim0
+    b'
+    base
+    (fun x xs x' -> ind x xs x')
+
+//[@@__reduce__]
+let clist_elim1
+  (c: clist 'a)
+  (b:(list 'a -> Type u#1))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: Pure (b c.raw)
+  (requires True)
+  (ensures (fun y -> y == list_elim c.raw b base ind))
+= let b' (l2: list 'a) : Type =
+    (x: b l2 { x == list_elim l2 b base ind })
+  in
+  c.elim1
+    b'
+    base
+    (fun x xs x' -> ind x xs x')
+
+//[@@__reduce__]
+let clist_elim2
+  (c: clist 'a)
+  (b:(list 'a -> Type u#2))
+  (base:b [])
+  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
+: Pure (b c.raw)
+  (requires True)
+  (ensures (fun y -> y == list_elim c.raw b base ind))
+= let b' (l2: list 'a) : Type =
+    (x: b l2 { x == list_elim l2 b base ind })
+  in
+  c.elim2
+    b'
+    base
+    (fun x xs x' -> ind x xs x')
+
+#push-options "--print_universes --print_implicits"
+
+#push-options "--fuel 0"
+let mk_clist (xs: list 'a) = {
+  raw = xs;
+  elim0 = list_elim xs;
+  elim1 = list_elim xs;
+  elim2 = list_elim xs;
+  elim3 = list_elim xs;
+}
+let _ =
+  let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
+  assert (clist_elim0 xs (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
+#pop-options
+
+//[@@__reduce__]
+let nil (#a: Type u#a): clist u#a a = {
+  raw = [];
+  elim0 = (fun _ base _ -> base);
+  elim1 = (fun _ base _ -> base);
+  elim2 = (fun _ base _ -> base);
+  elim3 = (fun _ base _ -> base);
+}
+
+//[@@__reduce__]
+let cons (#a: Type u#a) (x: a) (xs: clist u#a a): clist u#a a = {
+  raw = x :: xs.raw;
+  elim0 = (fun b base ind -> ind x xs.raw (xs.elim0 b base ind));
+  elim1 = (fun b base ind -> ind x xs.raw (xs.elim1 b base ind));
+  elim2 = (fun b base ind -> ind x xs.raw (xs.elim2 b base ind));
+  elim3 = (fun b base ind -> ind x xs.raw (xs.elim3 b base ind));
+}
+
+//[@@__reduce__]
+let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 a): bool
+= clist_elim0 xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
+
+//[@@__reduce__]
+let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
+: Lemma (cmem x xs == mem x xs.raw)
+= let rec aux (xs: list a)
+  : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
+  = match xs with [] -> () | x :: xs -> aux xs
+  in aux xs.raw
+
+(**** END MOVE TO ChurchList *)
+
+noeq type struct_fields = {
+  //cfields: clist string;
+  cfields: list string;
+  has_field: set string;
+  //has_field_prf: squash (forall field. has_field field == field `mem` cfields);
+  get_field: string ^-> typedef;
+  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
+}
+
+let trivial_typedef: typedef = {
+  carrier = option unit;
+  pcm = opt_pcm #unit;
+  view_type = unit;
+  view = opt_view unit;
+}
+
+let fields_nil: struct_fields = {
+  cfields = [];
+  has_field = emptyset;
+  //has_field_prf = ();
+  get_field = on_dom _ (fun _ -> trivial_typedef);
+}
+
+let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
+  cfields = field :: fields.cfields;
+  has_field = insert field fields.has_field;
+  //has_field_prf = ();
+  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
+}
+
+val struct' (tag: string) (fields: struct_fields) (excluded: set string): Type0
+
+let struct (tag: string) (fields: struct_fields) = struct' tag fields emptyset
+
+val mk_nil (tag: string): struct tag fields_nil
+
+val mk_cons (tag: string) (fields: struct_fields)
+  (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
+: Pure (struct tag (fields_cons field td fields))
+    (requires fields.has_field field == false)
+    (ensures fun _ -> True)
+
+val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
+
+val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+
+let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
+
+/// Reading a struct field
+val struct_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields) (field: field_of fields)
+: (fields.get_field field).view_type
+
+/// Writing a struct field
+val struct_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).view_type)
+: struct tag fields
+
+/// For a fixed field name, struct_get and struct_put form a lens
+
+val struct_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).view_type)
+: Lemma (struct_put x field v `struct_get` field == v)
+  [SMTPat (struct_put x field v `struct_get` field)]
+
+val struct_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+: Lemma (struct_put x field (x `struct_get` field) == x)
+  [SMTPat (struct_put x field (x `struct_get` field))]
+
+val struct_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field: field_of fields)
+  (v w: (fields.get_field field).view_type)
+: Lemma (struct_put (struct_put x field v) field w == struct_put x field w)
+  [SMTPat (struct_put (struct_put x field v) field w)]
+
+/// struct_get/struct_put pairs for different fields don't interfere with each other
+
+val struct_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (fields.get_field field1).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
+  [SMTPat (struct_put x field1 v `struct_get` field2)]
+  
+val struct_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct tag fields)
+  (field1: field_of fields)
+  (v: (fields.get_field field1).view_type)
+  (field2: field_of fields)
+  (w: (fields.get_field field2).view_type)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_put (struct_put x field1 v) field2 w ==
+      struct_put (struct_put x field2 w) field1 v)
+
+let struct_pcm_one (tag: string) (fields: struct_fields)
+: struct_pcm_carrier tag fields
+= one (struct_pcm tag fields)
+
+/// Reading a pcm_struct_carrier field
+val struct_pcm_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields) (field: field_of fields)
+: (fields.get_field field).carrier
+
+/// Writing a struct_pcm_carrier field
+val struct_pcm_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).carrier)
+: struct_pcm_carrier tag fields
+
+/// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
+
+val struct_pcm_get_put 
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v: (fields.get_field field).carrier)
+: Lemma (struct_pcm_put x field v `struct_pcm_get` field == v)
+  [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
+
+val struct_pcm_put_get
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+: Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
+  [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
+
+val struct_pcm_put_put
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field: field_of fields)
+  (v w: (fields.get_field field).carrier)
+: Lemma (struct_pcm_put (struct_pcm_put x field v) field w == struct_pcm_put x field w)
+  [SMTPat (struct_pcm_put (struct_pcm_put x field v) field w)]
+  
+/// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
+
+val struct_pcm_get_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (field2: field_of fields)
+  (v: (fields.get_field field1).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures struct_pcm_put x field1 v `struct_pcm_get` field2 == x `struct_pcm_get` field2)
+  [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
+  
+val struct_pcm_put_put_ne
+  (#tag: string) (#fields: struct_fields)
+  (x: struct_pcm_carrier tag fields)
+  (field1: field_of fields)
+  (v: (fields.get_field field1).carrier)
+  (field2: field_of fields)
+  (w: (fields.get_field field2).carrier)
+: Lemma
+    (requires field1 =!= field2)
+    (ensures
+      struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
+      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
+
+val struct_view (tag: string) (fields: struct_fields) (excluded: set string)
+: sel_view (struct_pcm tag fields) (struct' tag fields excluded) false
+
+val struct_field
+  (tag: string) (fields: struct_fields) (field: field_of fields)
+: connection (struct_pcm tag fields) (fields.get_field field).pcm
+
+val extract_field
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+: Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
+    (requires not (excluded field))
+    (ensures fun _ -> True)
+
+val addr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (q `pts_to_view` (fields.get_field field).view))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+
+val unaddr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (q: ref 'a (fields.get_field field).pcm)
+: Steel unit
+    ((p `pts_to_view` struct_view tag fields excluded) `star`
+     (q `pts_to_view` (fields.get_field field).view))
+    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
+    (requires fun _ ->
+      excluded field == true /\
+      q == ref_focus p (struct_field tag fields field))
+    (ensures fun h _ h' -> 
+      excluded field == true /\
+      extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
+       ==
+        (h (p `pts_to_view` struct_view tag fields excluded),
+         h (q `pts_to_view` (fields.get_field field).view)))

From 8801d01bdd20f857266db90d3226799518708f55 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 5 Aug 2021 09:06:39 -0700
Subject: [PATCH 171/513] Tidy

---
 .../arraystructs/Steel.C.StructLiteral.fst    | 66 +------------------
 1 file changed, 1 insertion(+), 65 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 8fce3de0bfa..d7aa0165aa7 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -121,35 +121,7 @@ let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields) (exclud
 : Lemma 
     (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
      ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
-= (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one;
-  let field: struct_dom excluded = (arbitrary_unexcluded excluded) in
-  assert (
-    (~ (exists x. (fields.get_field field).view.to_carrier x == one (struct_pcms fields field)) /\
-     ~ ((fields.get_field field).view.to_view_prop (one (struct_pcms fields field)))));
-     (*
-  let aux x
-  : Lemma (requires struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields))
-      (ensures exists x. (fields.get_field field).view.to_carrier x == one (struct_pcms fields field))
-  = //assert (has_type ((fields.get_field field).view.to_carrier (x field)) ((fields.get_field field).carrier));
-    //assert (has_type (one (fields.get_field field).pcm) ((fields.get_field field).carrier));
-    assert (struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields));
-    assert (struct_view_to_carrier tag fields excluded x field == one (struct_pcm tag fields) field);
-    //assert (
-    //  (   
-    //      (fields.get_field field).view.to_carrier (x field)
-    //      <: (fields.get_field field).carrier)
-    //  == one (struct_pcm tag fields) field);
-    assert (
-      (   
-          (fields.get_field field).view.to_carrier (x field)
-          <: (fields.get_field field).carrier)
-      == one (prod_pcm (struct_pcms fields)) field);
-    //assert ((fields.get_field field).view.to_carrier (x field) == one ((fields.get_field field).pcm));
-    //admit()
-  in*)
-  ()
-  //assume (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)));
-  //assume (~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
+= (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one
 
 let struct_view_to_view_frame (tag: string) (fields: struct_fields) (excluded: set string)
 : (x: struct' tag fields excluded) ->
@@ -230,13 +202,7 @@ let addr_of_struct_field #a #tag #fields #excluded field p =
   let s: Ghost.erased (struct_pcm_carrier tag fields) =
     pts_to_view_elim p (struct_view tag fields excluded)
   in
-  //assert (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v);
-  //slassert (p `pts_to` s);
   let q = addr_of_struct_field p field s in
-  assert (q == ref_focus p (struct_field tag fields field));
-  //slassert (
-  //  (p `pts_to` struct_without_field (struct_pcms fields) field s) `star`
-  //  (q `pts_to` Ghost.reveal s field));
   struct_without_field_to_carrier tag fields excluded field s v;
   pts_to_view_intro p (struct_without_field (struct_pcms fields) field s)
     (struct_view tag fields (insert field excluded))
@@ -257,26 +223,6 @@ let struct'_with_field
 = on_dom (struct_dom (remove field excluded))
     (fun field' -> if field = field' then w else v field')
 
-let struct_with_field_to_carrier
-  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
-  (s: struct_pcm_carrier tag fields)
-  (t: (fields.get_field field).carrier)
-  (v: struct' tag fields excluded)
-  (w: (fields.get_field field).view_type)
-: Lemma
-    (requires
-      excluded field == true /\
-      s == (struct_view tag fields excluded).to_carrier v /\
-      t === (fields.get_field field).view.to_carrier w)
-    (ensures
-      struct_with_field (struct_pcms fields) field t s
-      == (struct_view tag fields (remove field excluded)).to_carrier
-           (struct'_with_field tag fields excluded field w v))
-= assert
-    (struct_with_field (struct_pcms fields) field t s
-      `feq` (struct_view tag fields (remove field excluded)).to_carrier
-           (struct'_with_field tag fields excluded field w v))
-
 let struct_with_field_to_carrier'
   (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
   (s: struct_pcm_carrier tag fields)
@@ -323,9 +269,6 @@ let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   let t: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  //slassert ((p `pts_to` s) `star` (q `pts_to` t));
-  //assert (Ghost.reveal s field == one (struct_pcms fields field));
-  //assert (q == ref_focus p (Struct.struct_field (struct_pcms fields) field));
   unaddr_of_struct_field #_ #_ #_ #(struct_pcms fields) field q p s t;
   let h1: squash (excluded field == true) = () in
   let h2: squash (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v) = () in
@@ -333,18 +276,11 @@ let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   struct_with_field_to_carrier' tag fields excluded field
     (Ghost.reveal s) (Ghost.reveal t) (Ghost.reveal v) (Ghost.reveal w)
     h1 h2 h3; // TODO why need pass explicitly
-  assert (struct_with_field (struct_pcms fields) field t s
-      == (struct_view tag fields (remove field excluded)).to_carrier
-           (struct'_with_field tag fields excluded field w v));
   pts_to_view_intro p
     (struct_with_field (struct_pcms fields) field t s)
     (struct_view tag fields (remove field excluded))
     (struct'_with_field tag fields excluded field w v);
   extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
-  assert
-     (extract_field tag fields (remove field excluded) field
-         (struct'_with_field tag fields excluded field w v)
-         == (Ghost.reveal v, Ghost.reveal w));
   return ()
 
 (**** MOVE EVERYTHING BELOW TO SEPARATE FILES *)

From 62fef13176402c0a9d91b4e0b03ae1a0176a3cb8 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 5 Aug 2021 09:53:12 -0700
Subject: [PATCH 172/513] Generalize struct_get, struct_put to handle excluded
 fields

---
 examples/steel/arraystructs/PointStruct.fst   |   43 +
 .../arraystructs/Steel.C.StructLiteral.fst    | 1138 -----------------
 .../arraystructs/Steel.C.StructLiteral.fsti   |   49 +-
 3 files changed, 74 insertions(+), 1156 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 090607d1900..51c6a78dbd4 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -4,10 +4,53 @@ open Steel.C.PCM
 open Steel.C.Opt
 open Steel.C.Connection
 open Steel.C.Struct
+open Steel.C.StructLiteral
+open Steel.C.Typedef
 open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
+let c_int: typedef = {
+  carrier = option int;
+  pcm = opt_pcm #int;
+  view_type = int;
+  view = opt_view int;
+}
+
+let point_fields: struct_fields = 
+  fields_cons "x" c_int (
+  fields_cons "y" c_int (
+  fields_nil))
+
+let point_view_t = struct "point" point_fields
+
+let point_view = struct_view "point" point_fields
+
+let point = struct_pcm_carrier "point" point_fields
+
+let point_pcm = struct_pcm "point" point_fields
+
+#push-options "--fuel 0"
+
+let x_conn = struct_field "point" point_fields "x"
+
+val addr_of_x' (p: ref 'a point_pcm) (excluded: set string)
+: Steel (ref 'a (opt_pcm #int))
+    (p `pts_to_view` point_view excluded)
+    (fun q ->
+       (p `pts_to_view` point_view (insert "x" excluded)) `star`
+       (q `pts_to_view` opt_view int))
+    (requires fun _ -> not (excluded "x"))
+    (ensures fun h q h' ->
+      q == ref_focus p x_conn /\
+      extract_field "point" point_fields excluded "x"
+        (h (p `pts_to_view` point_view excluded) `struct_get` "x")
+      == 
+        (h' (p `pts_to_view` point_view (insert "x" excluded)),
+         h' (q `pts_to_view` opt_view int)))
+
+let addr_of_x'
+
 let point_fields k = match k with
   | X -> option int
   | Y -> option int
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index d7aa0165aa7..981f2061cf9 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -189,11 +189,6 @@ let extract_field
     (ensures fun _ -> True)
 = (struct'_without_field tag fields excluded field v, v field)
 
-let insert_remove x (s: set 'a)
-: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
-  [SMTPat (insert x (remove x s))]
-= assert (insert x (remove x s) `feq` s)
-
 #push-options "--z3rlimit 30"
 let addr_of_struct_field #a #tag #fields #excluded field p =
   let v: Ghost.erased (struct' tag fields excluded) =
@@ -282,1136 +277,3 @@ let unaddr_of_struct_field #a #tag #fields #excluded field p q =
     (struct'_with_field tag fields excluded field w v);
   extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
   return ()
-
-(**** MOVE EVERYTHING BELOW TO SEPARATE FILES *)
-
-/// TODO move and dedup with Steel.C.Ptr.fst
-
-let vpure_sel'
-  (p: prop)
-: Tot (selector' (squash p) (Steel.Memory.pure p))
-= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
-
-let vpure_sel
-  (p: prop)
-: Tot (selector (squash p) (Steel.Memory.pure p))
-= vpure_sel' p
-
-[@@ __steel_reduce__]
-let vpure'
-  (p: prop)
-: GTot vprop'
-= {
-  hp = Steel.Memory.pure p;
-  t = squash p;
-  sel = vpure_sel p;
-}
-
-[@@ __steel_reduce__]
-let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
-
-let intro_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    emp
-    (fun _ -> vpure p)
-    (fun _ -> p)
-    (fun _ _ h' -> p)
-=
-  change_slprop_rel
-    emp
-    (vpure p)
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m)
-
-let elim_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    (vpure p)
-    (fun _ -> emp)
-    (fun _ -> True)
-    (fun _ _ _ -> p)
-=
-  change_slprop_rel
-    (vpure p)
-    emp
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
-
-assume val pts_to_v
-  (#pcm: pcm 'b) (#can_view_unit: bool)
-  (p: ref 'a pcm) (view: sel_view pcm 'c can_view_unit)
-  (v: 'c)
-: vprop
-//= (p `pts_to_view` view) `vdep` (fun x -> vpure (x == v))
-
-assume val struct_get'
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (fields.get_field field).view_type
-
-(*
-/// Point struct
-
-open Steel.C.Opt
-
-//[@@__reduce__]
-let c_int: typedef = {
-  carrier = option int;
-  pcm = opt_pcm #int;
-  view_type = int;
-  view = opt_view int;
-}
-
-//[@@__reduce__]
-//let point_fields: struct_fields =
-//  cons ("x", c_int) (cons ("y", c_int) nil)
-//  //normalize_term (fun c_int -> cons ("x", c_int) (cons ("y", c_int) nil)) c_int
-  
-//[@@__reduce__]
-let point_fields: struct_fields = normalize_term (fun c_int -> mk_clist [
-  "x", c_int;
-  "y", c_int;
-]) c_int // NOTE: tricky! pull c_int out to avoid normalizing into lambdas
-  
-//[@@__reduce__]
-let point_fields': struct_fields = point_fields
-
-//[@@__reduce__]
-let point = struct "point" point_fields
-
-//[@@__reduce__]
-let point_pcm_carrier = struct_pcm_carrier "point" point_fields
-//[@@iter_unfold]
-//[@@__reduce__]
-let point_pcm: pcm point_pcm_carrier = struct_pcm "point" point_fields
-
-/// (mk_point x y) represents (struct point){.x = x, .y = y}
-/// (mk_point_pcm x y) same, but where x and y are PCM carrier values
-
-//let mk_point: int -> int -> point = mk_struct "point" point_fields
-//let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm "point" point_fields
-
-#push-options "--fuel 0"
-
-let _ = assert (struct_pcm_carrier "point" point_fields == point_pcm_carrier)
-
-let _ = assert (struct_carriers point_fields "x" == option int)
-
-let _ = assert (struct_pcm "point" point_fields == point_pcm)
-
-let _ = assert (struct_pcms "point" point_fields "x" == c_int.pcm)
-
-let _ = assert (struct_pcms "point" point_fields "x" === opt_pcm #int)
-
-/// Connections for the fields of a point
-
-// //[@@iter_unfold]
-// val _x: connection point_pcm (opt_pcm #int)
-// let _x =
-//   //assert (struct_pcms "point" point_fields "x" === opt_pcm #int);
-// assume (connection u#0
-//   u#0
-//   #point_pcm_carrier
-//   #(Pervasives.Native.option u#0 int)
-//   point_pcm
-//   (opt_pcm u#0 #int)
-//   == connection u#0
-//   u#0
-//   #(struct_pcm_carrier "point" point_fields)
-//   #(struct_carriers point_fields "x")
-//   (struct_pcm "point" point_fields)
-//   (struct_pcms "point" point_fields "x"));
-//   struct_field' "point" point_fields "x"
-// 
-// //[@@iter_unfold]
-// val _y: connection point_pcm (opt_pcm #int)
-// let _y = struct_field' "point" point_fields "y"
-// 
-// //[@@iter_unfold]
-// [@@__reduce__]
-// let x: field_of point_fields = mk_field_of point_fields "x"
-// [@@__reduce__]
-// let y: field_of point_fields = mk_field_of point_fields "y"
-// 
-// /// View for points
-// 
-// [@@__reduce__]
-// val point_view: sel_view point_pcm point false
-// let point_view = struct_view "point" point_fields
-// 
-// /// Explode and recombine
-// 
-// //val explode' (#opened: inames)
-// //  (p: ref 'a point_pcm)
-// //  (s: Ghost.erased point)
-// //: SteelGhostT unit opened
-// //    (pts_to_v p point_view s)
-// //    (fun _ -> pts_to_fields "point" point_fields p s)
-
-//[@@__reduce__]
-//let point_view = struct_view "point" point_fields
-
-val explode' (#opened: inames)
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (s: Ghost.erased (struct "point" point_fields))
-: SteelGhostT unit opened
-    (pts_to_v p (struct_view "point" point_fields) s)
-    (fun _ -> pts_to_fields "point" point_fields p s)
-
-let explode' p s =
-  explode "point" point_fields p s
-
-(*
-
-struct_def = f:(#a:Type -> (map: string&typedef -> a) -> (reduce: a -> a -> b) -> b){
-  exists fields. 
-}
-
-struct_def_of_fields fields = fun f g -> reduce g (map f fields)
-
-point_struct = normalize_term (struct_def_of_fields f g ["x", c_int; "y", c_int])
-===> fun f g -> f ("x", c_int) `g` f ("y", c_int)
-
-pcm_carrier (s: struct_def) = s (fun (_, td) -> td.carrier) (&)
-
-struct_def a = {
-  fields: s:a -> typedef; //itrivial typedef for undefined fields
-}
-
-struct_view : sel_view (struct_pcm fields) (struct_def (refine string p)) false
-p ~~~> p /\ (fun x -> x =!= removed_field)
-
-
-*)
-
-//[@@__reduce__]
-let x: field_of point_fields = "x"
-//[@@__reduce__]
-let y: field_of point_fields = "y"
-
-//[@@__reduce__]
-let point_view = struct_view "point" point_fields
-
-//[@@__reduce__]
-let _x = struct_field' "point" point_fields x
-//[@@__reduce__]
-let _y = struct_field' "point" point_fields y
-
-let aux
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (s: Ghost.erased (struct "point" point_fields))
-: Lemma (pts_to_fields "point" point_fields p s
-    == 
-      (pts_to_field "point" point_fields p s x `star`
-        (pts_to_field "point" point_fields p s y `star`
-         emp)))
-= ()
-
-let aux1
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (s: Ghost.erased (struct "point" point_fields))
-: Lemma (pts_to_fields "point" point_fields p s
-    == 
-      (pts_to_v (ref_focus p _x) (struct_views point_fields x) (s `struct_get'` x) `star`
-        (pts_to_v (ref_focus p _y) (struct_views point_fields y) (s `struct_get'` y) `star`
-         emp)))
-= ()
-  
-
-// = pts_to_v
-//     (ref_focus p (struct_field' tag fields field))
-//     (struct_views fields field)
-//     (s `struct_get'` field)
-// = ()
-
-val explode'' (#opened: inames)
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (s: Ghost.erased (struct "point" point_fields))
-: SteelGhostT unit opened
-    (pts_to_v p point_view s)
-    (fun _ ->
-  pts_to_v
-    (ref_focus p _x)
-    (struct_views point_fields x)
-    (s `struct_get'` x)
-    `star`
-  pts_to_v
-    (ref_focus p _y)
-    (struct_views point_fields y)
-    (s `struct_get'` y))
-
-let explode'' p s =
-  explode "point" point_fields p s;
-  change_equal_slprop (pts_to_fields "point" point_fields p s)
-  (pts_to_v (ref_focus p _x) (struct_views point_fields x) (s `struct_get'` x) `star`
-        (pts_to_v (ref_focus p _y) (struct_views point_fields y) (s `struct_get'` y) `star`
-         emp))
-
-(*
-(*
-
-sel_view (struct_pcm tag fields) (struct tag (fields \ excluded)) false
-
-val explode'' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` point_view)
-    (fun _ ->
-      (ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      h' (ref_focus p _x `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "x" /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "y")
-
-let explode'' p = explode "point" point_fields p
-*)
-
-(*
-val recombine' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _x `pts_to_view` c_int.view) `star`
-     (ref_focus p _y `pts_to_view` c_int.view))
-    (fun _ -> p `pts_to_view` point_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      h (ref_focus p _x `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "x" /\
-      h (ref_focus p _y `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "y")
-
-let recombine' p = recombine "point" point_fields p
-*)
-
-#push-options "--debug PointStructSelectors --debug_level SMTQuery --log_queries --query_stats --fuel 0"
-#restart-solver
-
-[@@iter_unfold] let x: field_of point_fields = mk_field_of point_fields "x"
-[@@iter_unfold] let y: field_of point_fields = mk_field_of point_fields "y"
-
-
-module T = FStar.Tactics
-
-let aux (p: ref 'a point_pcm) (h: rmem (p `pts_to_view` point_view))
-  (h': rmem
-     ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)))
-: Tot (squash (
-   (norm norm_list
-      (pts_to_fields "point" point_fields p h h' point_fields)
-      ==
-   norm norm_list (begin
-      let pointprop =
-      ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-      in
-      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x) /\
-      (can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` y)
-   end))))
-= _ by (T.dump ""; T.smt ())
-
-val explode' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` point_view)
-    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list
-        (pts_to_fields "point" point_fields p h h' point_fields))
-//(iter_and_fields fields (pts_to_field "point" fields p h h')))
-
-let explode' p = explode "point" point_fields p
-
-val explode'' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "point" point_fields)
-    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      (
-      let pointprop =
-      (pts_to_fields_vprop "point" point_fields p point_fields)
-      in
-      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x)))
-
-// let explode'' p = explode "point" point_fields p
-
-assume val recombine (#opened: inames)
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-: SteelGhost unit opened
-    (pts_to_fields_vprop tag fields p fields)
-    (fun _ -> p `pts_to_view` struct_view tag fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list
-        (pts_to_fields tag fields p h' h fields))
-
-
-val explode''' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` point_view)
-    (fun _ -> 
-    ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list
-        (pts_to_fields "point" point_fields p h h' point_fields))
-//(iter_and_fields fields (pts_to_field "point" fields p h h')))
-
-#push-options "--print_implicits"
-
-unfold let norm' (s: list norm_step) (#a: Type) (x: a) : Tot (norm s a) =
-  norm_spec s a;
-  norm s x
-
-unfold let norm''  (#a: Type) (x: a) : Tot (norm norm_list a) =
-  norm_spec norm_list a;
-  norm norm_list x
-
-let aux'
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (h': rmem (p `pts_to_view` point_view))
-  : GTot int
-= 
-    ((h' (p `pts_to_view` point_view) `struct_get'` x))
-    // <: (get_field point_fields x).view_type)) in
-//  in let j: int = i in j
-//= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: (get_field point_fields x).view_type) <: int
-// TODO why are two coercions necessary?
-
-//let aux'' (s: (Mktypedef?.view_type (get_field point_fields xc_)): int
-//= s <: int
-
-/// Reading a struct field
-val struct_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (get_field fields field).view_type
-
-let explode''' p =
-  explode "point" point_fields p;
-  change_equal_slprop
-    (pts_to_fields_vprop "point" point_fields p point_fields)
-    ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-
-val zero_x
-  (p: ref 'a (struct_pcm "point" point_fields))
-: Steel unit
-    (p `pts_to_view` point_view)
-    (fun _ -> p `pts_to_view` point_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x == (0 <: c_int.view_type)))
-
-let zero_x p =
-  explode "point" point_fields p;
-  slassert (
-     ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)));
-  //recombine "point" point_fields p;
-  sladmit(); return()
-
-(*
-val explode''' (#opened: inames)
-  (p: ref 'a (struct_pcm "point" point_fields))
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "point" point_fields)
-    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let pointprop =
-      (pts_to_fields_vprop "point" point_fields p point_fields)
-      in
-      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x))
-
-let testlemma p
-    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
-    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
-: Lemma
-  (requires
-  norm norm_list (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-  (ensures
-  norm norm_list (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-= ()
-*)
-(*
-let testlemma' (p: ref 'a point_pcm)
-    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
-    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
-: Lemma
-  (requires
-  norm norm_list (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-  (ensures
-  (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-= _ by (T.dump "") // T.norm norm_list; T.dump ""; T.tadmit()); admit()
-*)
-
-//let explode''' p = explode'' p
-
-let aux p (h: rmem (p `pts_to_view` point_view))
-  (h': rmem
-     ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)))
-: Lemma
-   (requires
-      //norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-      norm norm_list
-      (pts_to_fields "point" point_fields p h h' point_fields))
-   (ensures begin
-      let pointprop =
-      ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-      in
-      can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x /\
-      can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` y
-   end)
-= ()
-
-/// Now, a contrived struct with twice as many fields (to stress-test)
-
-//[@@__reduce__;iter_unfold]
-let quad_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-  "z", c_int;
-  "w", c_int;
-]
-let quad = struct "quad" quad_fields
-
-let quad_pcm_carrier = struct_pcm_carrier "quad" quad_fields
-let quad_pcm: pcm quad_pcm_carrier = struct_pcm "quad" quad_fields
-
-/// (mk_quad x y) represents (struct quad){.x = x, .y = y}
-/// (mk_quad_pcm x y) same, but where x and y are PCM carrier values
-
-let mk_quad: int -> int -> int -> int -> quad = mk_struct "quad" quad_fields
-let mk_quad_pcm: option int -> option int -> option int -> option int -> quad_pcm_carrier = mk_struct_pcm "quad" quad_fields
-
-/// Connections for the fields of a quad
-
-[@@iter_unfold] let _quad_x: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "x"
-[@@iter_unfold] let _quad_y: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "y"
-[@@iter_unfold] let _quad_z: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "z"
-[@@iter_unfold] let _quad_w: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "w"
-
-/// View for quads
-
-[@@iter_unfold] let quad_view: sel_view quad_pcm quad false = struct_view "quad" quad_fields
-
-/// Explode and recombine
-
-(*
-val explode_quad' (#opened: inames)
-  (p: ref 'a quad_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "quad" quad_fields)
-    (fun _ -> iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-        (iter_and_fields quad_fields (pts_to_field "quad" quad_fields p h h')))
-
-let explode_quad' p = explode "quad" quad_fields p
-*)
-
-(*
-val explode_quad'' (#opened: inames)
-  (p: ref 'a quad_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` quad_view)
-    (fun _ ->
-      (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view))))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_x `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "x" /\
-      can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_y `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "y" /\
-      can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_z `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "z" /\
-      can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_w `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "w")
-*)
-
-#push-options "--z3rlimit 30 --query_stats"
-
-#pop-options
-#push-options "--fuel 2 --query_stats"
-
-[@@iter_unfold] let x: field_of quad_fields = mk_field_of quad_fields "x"
-[@@iter_unfold] let y: field_of quad_fields = mk_field_of quad_fields "y"
-[@@iter_unfold] let z: field_of quad_fields = mk_field_of quad_fields "z"
-[@@iter_unfold] let w: field_of quad_fields = mk_field_of quad_fields "w"
-
-module T = FStar.Tactics
-
-let norm_list = [
-  delta_attr [`%iter_unfold];
-  delta_only [
-    `%map; `%mem; `%fst; `%Mktuple2?._1;
-    `%assoc;
-    `%Some?.v
-  ];
-  iota; primops; zeta
-]
-
-let quad_aux (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
-  (h': rmem
-     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
-: squash
-   ((
-      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
-        (pts_to_fields "quad" quad_fields p h h' quad_fields))
-   ==
-   (begin
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
-      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
-       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
-         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
-         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
-          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
-   end))
-= _ by (T.trefl ())
-// assert_norm produces a stack overflow?
-//_ by (
-//    T.norm norm_list;
-//    T.trefl ())
-
-let quad_aux2 (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
-  (h': rmem
-     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
-: squash
-   ((
-      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
-        (pts_to_fields "quad" quad_fields p h h' quad_fields))
-   <==>
-   norm norm_list (begin
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
-      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
-       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
-         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
-         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
-          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
-   end))
-= () // _ by (T.trefl ())
-
-(*
-let quad_unfold_iter_star_fields p
-: Lemma
-    (norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p)) ==
-     (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view))))
-= ()
-*)
-
-#push-options "--query_stats"
-
-let explode_quad'' p =
-  explode "quad" quad_fields p;
-  //quad_unfold_iter_star_fields p;
-  //change_equal_slprop
-  //  (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
-  //  ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-  //   ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-  //    ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-  //     (ref_focus p _quad_w `pts_to_view` c_int.view))));
-  ()
-
-(*
-val recombine_quad' (#opened: inames)
-  (p: ref 'a quad_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-       (ref_focus p _quad_w `pts_to_view` c_int.view))))
-    (fun _ -> p `pts_to_view` quad_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      // assert (can_be_split' quadprop (ref_focus p _quad_x `pts_to_view` c_int.view));
-      // assert (can_be_split' quadprop (ref_focus p _quad_y `pts_to_view` c_int.view));
-      // assert (can_be_split' quadprop (ref_focus p _quad_z `pts_to_view` c_int.view));
-      // assert (can_be_split' quadprop (ref_focus p _quad_w `pts_to_view` c_int.view));
-      h (ref_focus p _quad_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "x" /\
-      h (ref_focus p _quad_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "y" /\
-      h (ref_focus p _quad_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "z" /\
-      h (ref_focus p _quad_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "w")
-
-let recombine_quad' p =
-  quad_unfold_iter_star_fields p;
-  change_equal_slprop
-    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-       (ref_focus p _quad_w `pts_to_view` c_int.view))))
-    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p));
-  recombine "quad" quad_fields p
-*)
-
-/// 5 fields!
-
-//[@@__reduce__;iter_unfold]
-let quint_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-  "z", c_int;
-  "w", c_int;
-  "v", c_int;
-]
-let quint = struct "quint" quint_fields
-
-let quint_pcm_carrier = struct_pcm_carrier "quint" quint_fields
-let quint_pcm: pcm quint_pcm_carrier = struct_pcm "quint" quint_fields
-
-let mk_quint: int -> int -> int -> int -> int -> quint = mk_struct "quint" quint_fields
-let mk_quint_pcm: option int -> option int -> option int -> option int -> option int -> quint_pcm_carrier = mk_struct_pcm "quint" quint_fields
-
-/// Connections for the fields of a quint
-
-let _quint_x: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "x"
-let _quint_y: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "y"
-let _quint_z: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "z"
-let _quint_w: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "w"
-let _quint_v: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "v"
-
-/// View for quints
-
-let quint_view: sel_view quint_pcm quint false = struct_view "quint" quint_fields
-
-/// Explode and recombine
-
-(*
-val explode_quint' (#opened: inames)
-  (p: ref 'a quint_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "quint" quint_fields)
-    (fun _ -> iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' -> iter_and_fields quint_fields (pts_to_field "quint" quint_fields p h h'))
-
-let explode_quint' p = explode "quint" quint_fields p
-*)
-
-#restart-solver
-
-val explode_quint'' (#opened: inames)
-  (p: ref 'a quint_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` quint_view)
-    (fun _ ->
-      (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quintprop =
-        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-           (ref_focus p _quint_v `pts_to_view` c_int.view))))
-      in
-      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
-      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
-      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
-      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
-      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v")
-
-let aux p (h: rmem (p `pts_to_view` quint_view))
-  (h': rmem
-     ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-         (ref_focus p _quint_v `pts_to_view` c_int.view))))))
-: Lemma
-   (requires
-      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-      (pts_to_fields "quint" quint_fields p h h' quint_fields))
-   (ensures begin
-      let quintprop =
-        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-           (ref_focus p _quint_v `pts_to_view` c_int.view))))
-      in
-      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
-      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
-      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
-      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
-      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v"
-   end)
-= admit()
-
-(*
-let quint_unfold_iter_star_fields p
-: Lemma
-    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p) ==
-     (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-= ()
-*)
-
-#restart-solver
-
-//#push-options "--z3rlimit 30"
-
-let explode_quint'' p =
-  explode "quint" quint_fields p;
-  //quint_unfold_iter_star_fields p;
-  //change_equal_slprop
-  //  (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
-  //  ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-  //   ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-  //    ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-  //     ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-  //      (ref_focus p _quint_v `pts_to_view` c_int.view)))));
-  ()
-
-//#pop-options
-
-val recombine_quint' (#opened: inames)
-  (p: ref 'a quint_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-    (fun _ -> p `pts_to_view` quint_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quintprop =
-        ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-          ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-           ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-            (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-      in
-      assert (can_be_split' quintprop (ref_focus p _quint_x `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_y `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_z `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_w `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_v `pts_to_view` c_int.view));
-      h (ref_focus p _quint_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "x" /\
-      h (ref_focus p _quint_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "y" /\
-      h (ref_focus p _quint_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "z" /\
-      h (ref_focus p _quint_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "w" /\
-      h (ref_focus p _quint_v `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "v")
-
-#push-options "--z3rlimit 20"
-
-let recombine_quint' p =
-  quint_unfold_iter_star_fields p;
-  change_equal_slprop
-    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p));
-  recombine "quint" quint_fields p
-
-#pop-options
-
-/// 8 fields:
-
-let oct_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-  "z", c_int;
-  "w", c_int;
-  "v", c_int;
-  "u", c_int;
-  "t", c_int;
-  "s", c_int;
-]
-let oct = struct "oct" oct_fields
-
-let oct_pcm_carrier = struct_pcm_carrier "oct" oct_fields
-let oct_pcm: pcm oct_pcm_carrier = struct_pcm "oct" oct_fields
-
-let mk_oct: int -> int -> int -> int -> int -> int -> int -> int -> oct = mk_struct "oct" oct_fields
-let mk_oct_pcm: option int -> option int -> option int -> option int -> option int -> option int -> option int -> option int -> oct_pcm_carrier = mk_struct_pcm "oct" oct_fields
-
-/// Connections for the fields of a oct
-
-let _oct_x: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "x"
-let _oct_y: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "y"
-let _oct_z: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "z"
-let _oct_w: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "w"
-let _oct_v: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "v"
-let _oct_u: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "u"
-let _oct_t: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "t"
-let _oct_s: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "s"
-
-/// View for octs
-
-let oct_view: sel_view oct_pcm oct false = struct_view "oct" oct_fields
-
-/// Explode and recombine
-
-val explode_oct' (#opened: inames)
-  (p: ref 'a oct_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "oct" oct_fields)
-    (fun _ -> iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' -> iter_and_fields oct_fields (pts_to_field "oct" oct_fields p h h'))
-
-let explode_oct' p = explode "oct" oct_fields p
-
-val explode_oct'' (#opened: inames)
-  (p: ref 'a oct_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` oct_view)
-    (fun _ ->
-      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-            ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-             (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      True)
-      // let octprop =
-      //   ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-      //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-      //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-      //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-      //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-      //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-      //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
-      // in
-      // assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
-      // h' (ref_focus p _oct_x `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "x" /\
-      // h' (ref_focus p _oct_y `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "y" /\
-      // h' (ref_focus p _oct_z `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "z" /\
-      // h' (ref_focus p _oct_w `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "w" /\
-      // h' (ref_focus p _oct_v `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "v" /\
-      // h' (ref_focus p _oct_u `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "u" /\
-      // h' (ref_focus p _oct_t `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "t" /\
-      // h' (ref_focus p _oct_s `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "s")
-
-let oct_unfold_iter_star_fields p
-: Lemma
-    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
-     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
-= assert_norm (
-    iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
-     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
-
-#restart-solver
-#push-options "--z3rlimit 40 --query_stats"
-
-let explode_oct'' p =
-  explode "oct" oct_fields p;
-  // OOMs
-  //change_slprop_rel
-  //  (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
-  //  ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-  //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-  //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-  //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-  //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-  //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-  //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-  //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
-  //  (fun _ _ -> True)
-  //  (fun m ->
-  //    assert_norm
-  //      (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
-  //      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-  //        ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-  //         ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-  //          ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-  //           ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-  //            ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-  //             ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-  //              (ref_focus p _oct_s `pts_to_view` c_int.view))))))))));
-  oct_unfold_iter_star_fields p;
-  change_equal_slprop
-    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
-    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view))))))));
-  ()
-
-#pop-options
-
-val recombine_oct' (#opened: inames)
-  (p: ref 'a oct_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-        (ref_focus p _oct_v `pts_to_view` c_int.view)))))
-    (fun _ -> p `pts_to_view` oct_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let octprop =
-        ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_v `pts_to_view` c_int.view)))))
-      in
-      assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
-      h (ref_focus p _oct_x `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "x" /\
-      h (ref_focus p _oct_y `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "y" /\
-      h (ref_focus p _oct_z `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "z" /\
-      h (ref_focus p _oct_w `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "w" /\
-      h (ref_focus p _oct_v `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "v" /\
-      h (ref_focus p _oct_u `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "u" /\
-      h (ref_focus p _oct_t `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "t" /\
-      h (ref_focus p _oct_s `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "s")
-
-#restart-solver
-#push-options "--z3rlimit 20"
-
-let recombine_oct' p =
-  oct_unfold_iter_star_fields p;
-  change_equal_slprop
-    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
-    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p));
-  recombine "oct" oct_fields p
-
-#pop-options
-*)
-
-*)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 969226fb6f1..bd80cda15cd 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -241,33 +241,41 @@ let field_of (fields: struct_fields) = field:string{fields.has_field field == tr
 
 /// Reading a struct field
 val struct_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (fields.get_field field).view_type
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (x: struct' tag fields excluded) (field: field_of fields)
+: Pure (fields.get_field field).view_type
+    (requires excluded field == false)
+    (ensures fun _ -> True)
 
 /// Writing a struct field
 val struct_put
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
-: struct tag fields
+: Pure (struct' tag fields excluded)
+    (requires excluded field == false)
+    (ensures fun _ -> True)
 
 /// For a fixed field name, struct_get and struct_put form a lens
 
 val struct_get_put 
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
-: Lemma (struct_put x field v `struct_get` field == v)
+: Lemma
+    (requires excluded field == false)
+    (ensures struct_put x field v `struct_get` field == v)
   [SMTPat (struct_put x field v `struct_get` field)]
 
 val struct_put_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (x: struct' tag fields excluded)
   (field: field_of fields)
-: Lemma (struct_put x field (x `struct_get` field) == x)
+: Lemma
+    (requires excluded field == false)
+    (ensures struct_put x field (x `struct_get` field) == x)
   [SMTPat (struct_put x field (x `struct_get` field))]
 
 val struct_put_put
@@ -281,25 +289,25 @@ val struct_put_put
 /// struct_get/struct_put pairs for different fields don't interfere with each other
 
 val struct_get_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (x: struct' tag fields excluded)
   (field1: field_of fields)
   (field2: field_of fields)
   (v: (fields.get_field field1).view_type)
 : Lemma
-    (requires field1 =!= field2)
+    (requires field1 =!= field2 /\ excluded field1 == false /\ excluded field2 == false)
     (ensures struct_put x field1 v `struct_get` field2 == x `struct_get` field2)
   [SMTPat (struct_put x field1 v `struct_get` field2)]
   
 val struct_put_put_ne
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields)
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (x: struct' tag fields excluded)
   (field1: field_of fields)
   (v: (fields.get_field field1).view_type)
   (field2: field_of fields)
   (w: (fields.get_field field2).view_type)
 : Lemma
-    (requires field1 =!= field2)
+    (requires field1 =!= field2 /\ excluded field1 == false /\ excluded field2 == false)
     (ensures
       struct_put (struct_put x field1 v) field2 w ==
       struct_put (struct_put x field2 w) field1 v)
@@ -407,6 +415,11 @@ val addr_of_struct_field
         (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
          h' (q `pts_to_view` (fields.get_field field).view)))
 
+let insert_remove x (s: set 'a)
+: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
+  [SMTPat (insert x (remove x s))]
+= assert (insert x (remove x s) `feq` s)
+
 val unaddr_of_struct_field
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)

From c41791983fbe1c06ee852242c3a21fc883838de2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 5 Aug 2021 12:59:33 -0700
Subject: [PATCH 173/513] Get PointStruct example with selectors working

---
 examples/steel/arraystructs/PointStruct.fst   | 182 ++++++++++++++++--
 examples/steel/arraystructs/Steel.C.Ref.fsti  |   5 +
 .../arraystructs/Steel.C.StructLiteral.fsti   |   3 +
 3 files changed, 173 insertions(+), 17 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 51c6a78dbd4..e15eb350c72 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -10,6 +10,9 @@ open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
+irreducible let c_typedef = 0
+
+[@@c_typedef]
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
@@ -17,10 +20,14 @@ let c_int: typedef = {
   view = opt_view int;
 }
 
+let mk_struct_typedef a b = b
+
+[@@c_typedef]
 let point_fields: struct_fields = 
+  mk_struct_typedef "point" (
   fields_cons "x" c_int (
   fields_cons "y" c_int (
-  fields_nil))
+  fields_nil)))
 
 let point_view_t = struct "point" point_fields
 
@@ -32,24 +39,165 @@ let point_pcm = struct_pcm "point" point_fields
 
 #push-options "--fuel 0"
 
-let x_conn = struct_field "point" point_fields "x"
+let x_conn
+: connection point_pcm (opt_pcm #int)
+= struct_field "point" point_fields "x"
+
+#push-options "--print_universes --print_implicits"
+// --z3rlimit 30"
 
-val addr_of_x' (p: ref 'a point_pcm) (excluded: set string)
-: Steel (ref 'a (opt_pcm #int))
-    (p `pts_to_view` point_view excluded)
+unfold let norm_list =
+  [delta_attr [`%c_typedef];
+   delta_only
+    [`%mk_struct_typedef;
+     `%fields_cons;
+     `%fields_nil;
+     `%Mkstruct_fields?.get_field;
+     `%Mktypedef?.carrier;
+     `%Mktypedef?.pcm;
+     `%Mktypedef?.view_type;
+     `%Mktypedef?.view];
+   iota; zeta; primops]
+
+assume val addr_of_struct_field'
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
-       (p `pts_to_view` point_view (insert "x" excluded)) `star`
-       (q `pts_to_view` opt_view int))
-    (requires fun _ -> not (excluded "x"))
-    (ensures fun h q h' ->
-      q == ref_focus p x_conn /\
-      extract_field "point" point_fields excluded "x"
-        (h (p `pts_to_view` point_view excluded) `struct_get` "x")
-      == 
-        (h' (p `pts_to_view` point_view (insert "x" excluded)),
-         h' (q `pts_to_view` opt_view int)))
-
-let addr_of_x'
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (pts_to_view u#0
+                  #'a
+                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
+                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
+                  q
+                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
+                  #false
+                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+
+assume val unaddr_of_struct_field'
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (q: ref 'a (fields.get_field field).pcm)
+: Steel unit
+    ((p `pts_to_view` struct_view tag fields excluded) `star`
+     (pts_to_view u#0
+                  #'a
+                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
+                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
+                  q
+                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
+                  #false
+                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
+    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
+    (requires fun _ ->
+      excluded field == true /\
+      q == ref_focus p (struct_field tag fields field))
+    (ensures fun h _ h' -> 
+      excluded field == true /\
+      extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
+       ==
+        (h (p `pts_to_view` struct_view tag fields excluded),
+         h (q `pts_to_view` (fields.get_field field).view)))
+
+val swap (p: ref 'a point_pcm)
+: Steel unit
+    (p `pts_to_view` point_view emptyset)
+    (fun _ -> (p `pts_to_view` point_view emptyset))
+    (requires fun _ -> True)
+    (ensures fun h q h' -> True)
+      // h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
+      // == h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
+      // h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
+      // == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
+      
+let swap #a p =
+  let q = addr_of_struct_field' "x" p in
+  //A.slassert(q `pts_to_view` opt_view int);
+  //A.change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
+  let r = addr_of_struct_field' "y" p in
+  let x = opt_read_sel q in
+  let y = opt_read_sel r in
+  q `opt_write_sel` y;
+  r `opt_write_sel` x;
+  unaddr_of_struct_field' "y" p r;
+  unaddr_of_struct_field' "x" p q;
+  A.sladmit();
+  A.return ()
+
+(*
+TO PROVE:
+extract_field v field = (w, x) 
+get v field = x
+get v field' = get w field' for all field' =!= field
+*)
+
+(* struct tag { point_fields ... } *)
+
+(*
+
+struct tag *p ;
+
+int *q = &p->x;
+
+q: ref (struct tag) #int (int_pcm)
+
+EAddrOf (
+  EField (
+    TQualified "Example.t",
+    (EBufRead (<<p>>, 0)),
+    "x"))
+
+
+Read:
+    EBufRead (<<p>>, 0)
+
+Write:
+    EBufWrite (<<e>>, 0, <<e'>>)
+or
+    EAssign (EBufRead (<<e>>, 0), <<e'>>)
+
+addr_of_struct_field "x" (p: ref 'a #(struct_pcm_carrier tag point_fields) (struct_pcm tag point_fields))
+(* &(((struct tag)(*p)).x)
+
+*)
+
+
+
+
+*)
+
+/// make pts_to_view stuff smt_fallback?
+let addr_of_x' #a p excluded =
+  let q = addr_of_struct_field #_ #"point" #point_fields #excluded "x" p in
+  //A.change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
+  //A.change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` point_view (insert "x" excluded));
+  //A.slassert ((p `pts_to_view` point_view (insert "x" excluded)) `star`
+  //     (q `pts_to_view` opt_view int));
+  A.change_equal_slprop (q `pts_to_view` _)
+    (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int));
+  A.change_equal_slprop (p `pts_to_view` _)
+    (pts_to_view #a #point #point_pcm p
+          #(struct' "point" point_fields (insert #string "x" excluded)) #false 
+         (point_view (insert "x" excluded)));
+  //A.slassert ((pts_to_view #a #point #point_pcm p
+  //        #(struct' "point" point_fields (insert #string "x" excluded)) #false 
+  //       (point_view (insert "x" excluded))) `star`
+  //     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int)));
+  //A.sladmit();
+  A.return q
 
 let point_fields k = match k with
   | X -> option int
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/examples/steel/arraystructs/Steel.C.Ref.fsti
index 6e1a00d7167..d1719d86f06 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fsti
+++ b/examples/steel/arraystructs/Steel.C.Ref.fsti
@@ -253,6 +253,11 @@ let pts_to_view
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
+  //(#a: Type u#0) (#[@@@smt_fallback] b: Type u#b) (#[@@@smt_fallback] p: pcm b)
+  //(r: ref a p)
+  //(#[@@@smt_fallback] c: Type0)
+  //(#can_view_unit: bool)
+  //([@@@smt_fallback] vw: sel_view p c can_view_unit)
 : Tot vprop
 = VUnit (pts_to_view' r vw)
 
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index bd80cda15cd..22d205ca7c4 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -191,6 +191,7 @@ let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
 
 (**** END MOVE TO ChurchList *)
 
+//[@@__reduce__]
 noeq type struct_fields = {
   //cfields: clist string;
   cfields: list string;
@@ -207,6 +208,7 @@ let trivial_typedef: typedef = {
   view = opt_view unit;
 }
 
+//[@@__reduce__]
 let fields_nil: struct_fields = {
   cfields = [];
   has_field = emptyset;
@@ -214,6 +216,7 @@ let fields_nil: struct_fields = {
   get_field = on_dom _ (fun _ -> trivial_typedef);
 }
 
+//[@@__reduce__]
 let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
   cfields = field :: fields.cfields;
   has_field = insert field fields.has_field;

From 351fbfe3a7fc5c835c922149fac81fbae10bac3a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 5 Aug 2021 14:03:08 -0700
Subject: [PATCH 174/513] Tidy

---
 examples/steel/arraystructs/PointStruct.fst   | 84 ++----------------
 .../arraystructs/Steel.C.StructLiteral.fst    | 10 ++-
 .../arraystructs/Steel.C.StructLiteral.fsti   | 87 +++++++++++++++++--
 3 files changed, 95 insertions(+), 86 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index e15eb350c72..f95da6b1e06 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -10,8 +10,6 @@ open FStar.FunctionalExtensionality
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-irreducible let c_typedef = 0
-
 [@@c_typedef]
 let c_int: typedef = {
   carrier = option int;
@@ -20,8 +18,6 @@ let c_int: typedef = {
   view = opt_view int;
 }
 
-let mk_struct_typedef a b = b
-
 [@@c_typedef]
 let point_fields: struct_fields = 
   mk_struct_typedef "point" (
@@ -46,72 +42,6 @@ let x_conn
 #push-options "--print_universes --print_implicits"
 // --z3rlimit 30"
 
-unfold let norm_list =
-  [delta_attr [`%c_typedef];
-   delta_only
-    [`%mk_struct_typedef;
-     `%fields_cons;
-     `%fields_nil;
-     `%Mkstruct_fields?.get_field;
-     `%Mktypedef?.carrier;
-     `%Mktypedef?.pcm;
-     `%Mktypedef?.view_type;
-     `%Mktypedef?.view];
-   iota; zeta; primops]
-
-assume val addr_of_struct_field'
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
-  (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (fields.get_field field).pcm)
-    (p `pts_to_view` struct_view tag fields excluded)
-    (fun q ->
-      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
-      (pts_to_view u#0
-                  #'a
-                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
-                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
-                  q
-                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
-                  #false
-                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
-    (requires fun _ -> not (excluded field))
-    (ensures fun h q h' -> 
-      not (excluded field) /\
-      q == ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
-       ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
-
-assume val unaddr_of_struct_field'
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
-  (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (q: ref 'a (fields.get_field field).pcm)
-: Steel unit
-    ((p `pts_to_view` struct_view tag fields excluded) `star`
-     (pts_to_view u#0
-                  #'a
-                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
-                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
-                  q
-                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
-                  #false
-                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
-    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
-    (requires fun _ ->
-      excluded field == true /\
-      q == ref_focus p (struct_field tag fields field))
-    (ensures fun h _ h' -> 
-      excluded field == true /\
-      extract_field tag fields (remove field excluded) field
-        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
-       ==
-        (h (p `pts_to_view` struct_view tag fields excluded),
-         h (q `pts_to_view` (fields.get_field field).view)))
-
 val swap (p: ref 'a point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
@@ -122,19 +52,17 @@ val swap (p: ref 'a point_pcm)
       // == h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
       // h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
       // == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
-      
+
 let swap #a p =
-  let q = addr_of_struct_field' "x" p in
-  //A.slassert(q `pts_to_view` opt_view int);
-  //A.change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
-  let r = addr_of_struct_field' "y" p in
+  let q = addr_of_struct_field "x" p in
+  let r = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
   q `opt_write_sel` y;
   r `opt_write_sel` x;
-  unaddr_of_struct_field' "y" p r;
-  unaddr_of_struct_field' "x" p q;
-  A.sladmit();
+  unaddr_of_struct_field "y" p r;
+  unaddr_of_struct_field "x" p q;
+  A.change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   A.return ()
 
 (*
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 981f2061cf9..9c5b5e14d6b 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -190,7 +190,7 @@ let extract_field
 = (struct'_without_field tag fields excluded field v, v field)
 
 #push-options "--z3rlimit 30"
-let addr_of_struct_field #a #tag #fields #excluded field p =
+let addr_of_struct_field' #a #tag #fields #excluded field p =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -208,6 +208,9 @@ let addr_of_struct_field #a #tag #fields #excluded field p =
   return q
 #pop-options
 
+let addr_of_struct_field #a #tag #fields #excluded field p =
+  addr_of_struct_field' field p
+
 let struct'_with_field
   (tag: string) (fields: struct_fields) (excluded: set string)
   (field: string) (w: (fields.get_field field).view_type)
@@ -251,7 +254,7 @@ let extract_field_with_field
     (struct'_with_field tag fields excluded field w v)
     `feq` v)
 
-let unaddr_of_struct_field #a #tag #fields #excluded field p q =
+let unaddr_of_struct_field' #a #tag #fields #excluded field p q =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -277,3 +280,6 @@ let unaddr_of_struct_field #a #tag #fields #excluded field p q =
     (struct'_with_field tag fields excluded field w v);
   extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
   return ()
+
+let unaddr_of_struct_field #a #tag #fields #excluded field p q =
+  unaddr_of_struct_field' field p q
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 22d205ca7c4..bc46bc5c1ce 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -65,6 +65,16 @@ let remove x (s: set 'a): set 'a =
   list_remove_spec s x (set_as_list s);
   intro_set (set_remove x s) (list_remove x (set_as_list s))
 
+let insert_remove x (s: set 'a)
+: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
+  [SMTPat (insert x (remove x s))]
+= assert (insert x (remove x s) `feq` s)
+
+let remove_insert x (s: set 'a)
+: Lemma (requires s x == false) (ensures remove x (insert x s) == s)
+  [SMTPat (remove x (insert x s))]
+= assert (remove x (insert x s) `feq` s)
+
 let notin (s: set 'a) (x: 'a): prop = s x == false
 
 (**** MOVE TO ChurchList *)
@@ -399,7 +409,7 @@ val extract_field
     (requires not (excluded field))
     (ensures fun _ -> True)
 
-val addr_of_struct_field
+val addr_of_struct_field'
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -418,12 +428,50 @@ val addr_of_struct_field
         (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
          h' (q `pts_to_view` (fields.get_field field).view)))
 
-let insert_remove x (s: set 'a)
-: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
-  [SMTPat (insert x (remove x s))]
-= assert (insert x (remove x s) `feq` s)
+irreducible let c_typedef = 0
 
-val unaddr_of_struct_field
+let mk_struct_typedef a b = b
+
+unfold let norm_list =
+  [delta_attr [`%c_typedef];
+   delta_only
+    [`%mk_struct_typedef;
+     `%fields_cons;
+     `%fields_nil;
+     `%Mkstruct_fields?.get_field;
+     `%Mktypedef?.carrier;
+     `%Mktypedef?.pcm;
+     `%Mktypedef?.view_type;
+     `%Mktypedef?.view];
+   iota; zeta; primops]
+
+val addr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (pts_to_view u#0
+                  #'a
+                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
+                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
+                  q
+                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
+                  #false
+                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+
+val unaddr_of_struct_field'
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -442,3 +490,30 @@ val unaddr_of_struct_field
        ==
         (h (p `pts_to_view` struct_view tag fields excluded),
          h (q `pts_to_view` (fields.get_field field).view)))
+
+val unaddr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+  (q: ref 'a (fields.get_field field).pcm)
+: Steel unit
+    ((p `pts_to_view` struct_view tag fields excluded) `star`
+     (pts_to_view u#0
+                  #'a
+                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
+                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
+                  q
+                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
+                  #false
+                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
+    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
+    (requires fun _ ->
+      excluded field == true /\
+      q == ref_focus p (struct_field tag fields field))
+    (ensures fun h _ h' -> 
+      excluded field == true /\
+      extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
+       ==
+        (h (p `pts_to_view` struct_view tag fields excluded),
+         h (q `pts_to_view` (fields.get_field field).view)))

From 398283f2a7c3363b07cabc74739d273e493f459c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 6 Aug 2021 10:25:18 -0700
Subject: [PATCH 175/513] Add FSet

---
 examples/steel/arraystructs/FStar.FSet.fst    | 66 +++++++++++++++++
 examples/steel/arraystructs/PointStruct.fst   | 39 +++++-----
 examples/steel/arraystructs/PointStruct.fsti  | 71 -------------------
 .../arraystructs/Steel.C.StructLiteral.fsti   | 62 +---------------
 4 files changed, 87 insertions(+), 151 deletions(-)
 create mode 100644 examples/steel/arraystructs/FStar.FSet.fst
 delete mode 100644 examples/steel/arraystructs/PointStruct.fsti

diff --git a/examples/steel/arraystructs/FStar.FSet.fst b/examples/steel/arraystructs/FStar.FSet.fst
new file mode 100644
index 00000000000..423204acbce
--- /dev/null
+++ b/examples/steel/arraystructs/FStar.FSet.fst
@@ -0,0 +1,66 @@
+module FStar.FSet
+
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+
+let has_elements (#a:eqtype) (f: a ^-> bool) (xs: list a): prop =
+  forall x. f x == x `mem` xs
+
+// Finite sets
+let set (a:eqtype) = f:(a ^-> bool){exists xs. f `has_elements` xs}
+
+let set_as_list (s: set 'a): GTot (list 'a) =
+  FStar.IndefiniteDescription.indefinite_description_ghost (list 'a)
+    (has_elements s)
+
+let intro_set (#a:eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
+: Pure (set a)
+    (requires f `has_elements` xs)
+    (ensures fun _ -> True)
+= Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
+  f 
+
+let emptyset #a: set a = intro_set (on_dom a (fun _ -> false)) []
+
+let insert x (s: set 'a): set 'a =
+  intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s)
+
+let set_remove (#a:eqtype) x (s: a ^-> bool): (a ^-> bool) =
+  on_dom _ (fun x' -> not (x = x') && s x')
+
+let rec list_remove (#a:eqtype) x (xs: list a) = match xs with
+  | [] -> []
+  | x' :: xs ->
+    if x = x' then list_remove x xs
+    else x' :: list_remove x xs
+
+let rec list_remove_spec (#a:eqtype) f x (xs: list a)
+: Lemma
+    (requires f `has_elements` xs)
+    (ensures set_remove x f `has_elements` list_remove x xs)
+    (decreases xs)
+= match xs with
+  | [] -> ()
+  | x' :: xs ->
+    let g: (a ^-> bool) = on_dom _ (fun x -> x `mem` xs) in
+    let f': (a ^-> bool) = on_dom _ (fun x'' -> x'' = x' || g x'') in
+    assert (f `feq` f');
+    assert (g `has_elements` xs);
+    list_remove_spec g x xs;
+    assert (set_remove x g `has_elements` list_remove x xs)
+
+let remove x (s: set 'a): set 'a =
+  list_remove_spec s x (set_as_list s);
+  intro_set (set_remove x s) (list_remove x (set_as_list s))
+
+let insert_remove x (s: set 'a)
+: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
+  [SMTPat (insert x (remove x s))]
+= assert (insert x (remove x s) `feq` s)
+
+let remove_insert x (s: set 'a)
+: Lemma (requires s x == false) (ensures remove x (insert x s) == s)
+  [SMTPat (remove x (insert x s))]
+= assert (remove x (insert x s) `feq` s)
+
+let notin (s: set 'a) (x: 'a): prop = s x == false
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index f95da6b1e06..2facfe0ac47 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -8,7 +8,8 @@ open Steel.C.StructLiteral
 open Steel.C.Typedef
 open FStar.FunctionalExtensionality
 open Steel.Effect
-module A = Steel.Effect.Atomic
+open Steel.Effect.Atomic
+//open Steel.C.Reference
 
 [@@c_typedef]
 let c_int: typedef = {
@@ -62,8 +63,8 @@ let swap #a p =
   r `opt_write_sel` x;
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
-  A.change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
-  A.return ()
+  change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+  return ()
 
 (*
 TO PROVE:
@@ -110,22 +111,22 @@ addr_of_struct_field "x" (p: ref 'a #(struct_pcm_carrier tag point_fields) (stru
 /// make pts_to_view stuff smt_fallback?
 let addr_of_x' #a p excluded =
   let q = addr_of_struct_field #_ #"point" #point_fields #excluded "x" p in
-  //A.change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
-  //A.change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` point_view (insert "x" excluded));
-  //A.slassert ((p `pts_to_view` point_view (insert "x" excluded)) `star`
+  //change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
+  //change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` point_view (insert "x" excluded));
+  //slassert ((p `pts_to_view` point_view (insert "x" excluded)) `star`
   //     (q `pts_to_view` opt_view int));
-  A.change_equal_slprop (q `pts_to_view` _)
+  change_equal_slprop (q `pts_to_view` _)
     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int));
-  A.change_equal_slprop (p `pts_to_view` _)
+  change_equal_slprop (p `pts_to_view` _)
     (pts_to_view #a #point #point_pcm p
           #(struct' "point" point_fields (insert #string "x" excluded)) #false 
          (point_view (insert "x" excluded)));
-  //A.slassert ((pts_to_view #a #point #point_pcm p
+  //slassert ((pts_to_view #a #point #point_pcm p
   //        #(struct' "point" point_fields (insert #string "x" excluded)) #false 
   //       (point_view (insert "x" excluded))) `star`
   //     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int)));
-  //A.sladmit();
-  A.return q
+  //sladmit();
+  return q
 
 let point_fields k = match k with
   | X -> option int
@@ -173,20 +174,20 @@ let point_with_y x y
 
 let addr_of_x #a #x #y p =
   let q = addr_of_struct_field p X (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  A.return q
+  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
+  change_equal_slprop (q `pts_to` _) (q `pts_to` x);
+  return q
   
 let unaddr_of_x #a #x #y p q =
   unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point None y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+  change_equal_slprop (p `pts_to` _) (p `pts_to` _)
 
 let addr_of_y #a #x #y p =
   let q = addr_of_struct_field p Y (mk_point x y) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` y);
-  A.return q
+  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
+  change_equal_slprop (q `pts_to` _) (q `pts_to` y);
+  return q
 
 let unaddr_of_y #a #x #y p q =
   unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x None) y; // same here
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+  change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/PointStruct.fsti b/examples/steel/arraystructs/PointStruct.fsti
deleted file mode 100644
index 281f14f8d2f..00000000000
--- a/examples/steel/arraystructs/PointStruct.fsti
+++ /dev/null
@@ -1,71 +0,0 @@
-module PointStruct
-
-open FStar.PCM
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Ref
-open Steel.C.Connection
-open Steel.Effect
-
-/// Suppose we have the following struct representing 2d points:
-///   struct point { int x, y; };
-///
-/// Carrier of PCM for struct point:
-
-type point_field = | X | Y
-
-val point : Type0
-
-/// PCM for struct point:
-
-val point_pcm : pcm point
-
-/// (mk_point x y) represents (struct point){.x = x, .y = y}
-
-val mk_point (x y: option int): point
-
-/// Connections for the fields of a point
-
-val _x : connection point_pcm (opt_pcm #int)
-val _y : connection point_pcm (opt_pcm #int)
-
-/// Taking pointers to the x and y fields of a point
-
-val addr_of_x (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
-: Steel (ref 'a (opt_pcm #int))
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point None y) `star`
-       (q `pts_to` x))
-    (requires fun _ -> True)
-    (ensures fun _ q _ -> q == ref_focus p _x)
-
-val unaddr_of_x
-  (#x #y: Ghost.erased (option int))
-  (p: ref 'a point_pcm)
-  (q: ref 'a (opt_pcm #int))
-: Steel unit
-    ((p `pts_to` mk_point None y) `star` (q `pts_to` x))
-    (fun q -> p `pts_to` mk_point x y)
-    (requires fun _ -> q == ref_focus p _x)
-    (ensures fun _ _ _ -> True)
-
-val addr_of_y (#x #y: Ghost.erased (option int)) (p: ref 'a point_pcm)
-: Steel (ref 'a (opt_pcm #int))
-    (p `pts_to` mk_point x y)
-    (fun q ->
-       (p `pts_to` mk_point x None) `star`
-       (q `pts_to` y))
-    (requires fun _ -> True)
-    (ensures fun _ q _ -> q == ref_focus p _y)
-
-val unaddr_of_y
-  (#x #y: Ghost.erased (option int))
-  (p: ref 'a point_pcm)
-  (q: ref 'a (opt_pcm #int))
-: Steel unit
-    ((p `pts_to` mk_point x None) `star` (q `pts_to` y))
-    (fun q -> p `pts_to` mk_point x y)
-    (requires fun _ -> q == ref_focus p _y)
-    (ensures fun _ _ _ -> True)
-
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index bc46bc5c1ce..3f626a1c721 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -15,67 +15,7 @@ open Steel.C.Opt
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-let has_elements (#a:eqtype) (f: a ^-> bool) (xs: list a): prop =
-  forall x. f x == x `mem` xs
-
-// Finite sets
-let set (a:eqtype) = f:(a ^-> bool){exists xs. f `has_elements` xs}
-
-let set_as_list (s: set 'a): GTot (list 'a) =
-  FStar.IndefiniteDescription.indefinite_description_ghost (list 'a)
-    (has_elements s)
-
-let intro_set (#a:eqtype) (f: a ^-> bool) (xs: Ghost.erased (list a))
-: Pure (set a)
-    (requires f `has_elements` xs)
-    (ensures fun _ -> True)
-= Classical.exists_intro (fun xs -> f `has_elements` xs) xs;
-  f 
-
-let emptyset #a: set a = intro_set (on_dom a (fun _ -> false)) []
-
-let insert x (s: set 'a): set 'a =
-  intro_set (on_dom _ (fun x' -> x = x' || s x')) (x :: set_as_list s)
-
-let set_remove (#a:eqtype) x (s: a ^-> bool): (a ^-> bool) =
-  on_dom _ (fun x' -> not (x = x') && s x')
-
-let rec list_remove (#a:eqtype) x (xs: list a) = match xs with
-  | [] -> []
-  | x' :: xs ->
-    if x = x' then list_remove x xs
-    else x' :: list_remove x xs
-
-let rec list_remove_spec (#a:eqtype) f x (xs: list a)
-: Lemma
-    (requires f `has_elements` xs)
-    (ensures set_remove x f `has_elements` list_remove x xs)
-    (decreases xs)
-= match xs with
-  | [] -> ()
-  | x' :: xs ->
-    let g: (a ^-> bool) = on_dom _ (fun x -> x `mem` xs) in
-    let f': (a ^-> bool) = on_dom _ (fun x'' -> x'' = x' || g x'') in
-    assert (f `feq` f');
-    assert (g `has_elements` xs);
-    list_remove_spec g x xs;
-    assert (set_remove x g `has_elements` list_remove x xs)
-
-let remove x (s: set 'a): set 'a =
-  list_remove_spec s x (set_as_list s);
-  intro_set (set_remove x s) (list_remove x (set_as_list s))
-
-let insert_remove x (s: set 'a)
-: Lemma (requires s x == true) (ensures insert x (remove x s) == s)
-  [SMTPat (insert x (remove x s))]
-= assert (insert x (remove x s) `feq` s)
-
-let remove_insert x (s: set 'a)
-: Lemma (requires s x == false) (ensures remove x (insert x s) == s)
-  [SMTPat (remove x (insert x s))]
-= assert (remove x (insert x s) `feq` s)
-
-let notin (s: set 'a) (x: 'a): prop = s x == false
+open FStar.FSet
 
 (**** MOVE TO ChurchList *)
 

From 405486f7fa30492ed23997ff0f3a942edf22691d Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 6 Aug 2021 12:43:55 -0700
Subject: [PATCH 176/513] Update makefile with rules for extraction to OCaml

---
 examples/steel/arraystructs/Makefile | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 9e4148c7c12..770c70d6719 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -34,6 +34,11 @@ verify: $(ALL_CHECKED_FILES)
 %.fst-in %.fsti-in:
 	@echo $(FSTAR_OPTIONS)
 
+.PRECIOUS: %.ml
+%.ml:
+	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen OCaml \
+	--extract_module $(basename $(notdir $(subst .checked,,$<)))
+
 clean:
 	-rm -rf *.checked *.krml .depend kremlin.rsp *.tmp *.o compile_flags.txt
 

From fa5fa06ce13aba23d8c6ff50a86a67bad4c7cca2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 6 Aug 2021 12:44:40 -0700
Subject: [PATCH 177/513] Add Steel.C.Reference.fst

A Steel.C.Reference.ref tags a Steel.C.Ref.ref with an extra parameter holding the view type, to be used by extraction
---
 examples/steel/arraystructs/PointStruct.fst   |  48 +++++++--
 examples/steel/arraystructs/Steel.C.Opt.fsti  |  28 +++++
 .../steel/arraystructs/Steel.C.Reference.fst  |  50 +++++++++
 .../arraystructs/Steel.C.StructLiteral.fst    |  12 +--
 .../arraystructs/Steel.C.StructLiteral.fsti   | 100 +++++++++++++++---
 5 files changed, 209 insertions(+), 29 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Reference.fst

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 2facfe0ac47..a2c628962a4 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -9,6 +9,9 @@ open Steel.C.Typedef
 open FStar.FunctionalExtensionality
 open Steel.Effect
 open Steel.Effect.Atomic
+open Steel.C.Ref
+
+open FStar.FSet
 //open Steel.C.Reference
 
 [@@c_typedef]
@@ -19,31 +22,37 @@ let c_int: typedef = {
   view = opt_view int;
 }
 
-[@@c_typedef]
+[@@c_struct]
 let point_fields: struct_fields = 
-  mk_struct_typedef "point" (
   fields_cons "x" c_int (
   fields_cons "y" c_int (
-  fields_nil)))
+  fields_nil))
 
 let point_view_t = struct "point" point_fields
 
 let point_view = struct_view "point" point_fields
 
-let point = struct_pcm_carrier "point" point_fields
+//let point = struct_pcm_carrier "point" point_fields
 
 let point_pcm = struct_pcm "point" point_fields
 
 #push-options "--fuel 0"
 
+(*
 let x_conn
 : connection point_pcm (opt_pcm #int)
 = struct_field "point" point_fields "x"
+*)
 
 #push-options "--print_universes --print_implicits"
 // --z3rlimit 30"
 
-val swap (p: ref 'a point_pcm)
+[@@c_typedef]
+let point = struct "point" point_fields
+
+open Steel.C.Reference
+
+val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> (p `pts_to_view` point_view emptyset))
@@ -55,7 +64,7 @@ val swap (p: ref 'a point_pcm)
       // == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
 
 let swap #a p =
-  let q = addr_of_struct_field "x" p in
+  let q: ref a int _ = addr_of_struct_field "x" p in
   let r = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
@@ -65,6 +74,33 @@ let swap #a p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
+  
+(*
+ref 'a (struct tag fields)
+ref 'a (fields.get_field field).view_type
+ref 'a view_t ...
+
+struct: s:string -> x:Type{x == y:string{y == s}} -> struct_fields -> Type
+point = s:string{s == "point"}
+
+[@@c_typedef]
+s = struct ..
+
+[@@c_struct]
+point_fields = fields_cons "a" s
+
+[@@c_typedef]
+point = struct "point" point_fields
+
+mark get_field, view_type, ... c_struct
+
+norm [unfold c_typedef] point
+
+p: ref 'a point  ...
+---> (PointStruct.point, unit) struct
+
+p: ref 'a int ...
+*)
 
 (*
 TO PROVE:
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/examples/steel/arraystructs/Steel.C.Opt.fsti
index 75dd9761248..0817c2c9795 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fsti
+++ b/examples/steel/arraystructs/Steel.C.Opt.fsti
@@ -135,3 +135,31 @@ let opt_write_sel
   let _ = pts_to_view_elim r (opt_view _) in
   opt_pcm_write r _ w;
   pts_to_view_intro r _ (opt_view _) w
+
+open Steel.C.Reference
+
+let ref_opt_read
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a b (opt_pcm #b))
+: Steel b
+  (pts_to_view r (opt_view b))
+  (fun _ -> pts_to_view r (opt_view b))
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (pts_to_view r (opt_view b)) /\
+    res == h' (pts_to_view r (opt_view b))
+  ))
+= ref_read_sel r (opt_view b)
+
+let ref_opt_write
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a b (opt_pcm #b))
+  (w: b)
+: Steel unit
+  (pts_to_view r (opt_view b))
+  (fun _ -> pts_to_view r (opt_view b))
+  (requires (fun _ -> True))
+  (ensures (fun _ _ h' ->
+    w == h' (pts_to_view r (opt_view b))
+  ))
+= opt_write_sel r w
diff --git a/examples/steel/arraystructs/Steel.C.Reference.fst b/examples/steel/arraystructs/Steel.C.Reference.fst
new file mode 100644
index 00000000000..4c339b74ce2
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Reference.fst
@@ -0,0 +1,50 @@
+module Steel.C.Reference
+open FStar.FunctionalExtensionality
+open Steel.C.PCM
+open Steel.C.Connection
+open Steel.C.Ref
+open Steel.Effect
+open Steel.Effect.Atomic
+
+open FStar.FSet
+
+#push-options "--print_universes"
+
+let ref (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+: Type u#b
+= ref a q
+
+[@@__steel_reduce__]
+let pts_to_view
+  (#a: Type u#0) 
+  (#view_t: Type u#0)
+  (#view_t': Type u#0)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref a view_t p) (view: sel_view p view_t' false)
+: vprop
+= r `pts_to_view` view
+
+(*
+val ref_alloc
+  (#a:Type0) (p: pcm a) (x: a)
+: Steel (ref a p)
+    emp
+    (fun r -> r `pts_to` x)
+    (requires fun _ -> p_refine p x)
+    (ensures fun _ _ _ -> True)
+*)
+
+let ref_read
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (#view_t: Type u#0)
+  (#vw: sel_view p view_t false)
+  (r: ref a view_t p)
+: Steel view_t
+  (r `pts_to_view` vw)
+  (fun _ -> r `pts_to_view` vw)
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (r `pts_to_view` vw) /\
+    res == h' (r `pts_to_view` vw)
+  ))
+= ref_read_sel r vw
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 9c5b5e14d6b..8e4b217995d 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -190,7 +190,7 @@ let extract_field
 = (struct'_without_field tag fields excluded field v, v field)
 
 #push-options "--z3rlimit 30"
-let addr_of_struct_field' #a #tag #fields #excluded field p =
+let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -208,8 +208,8 @@ let addr_of_struct_field' #a #tag #fields #excluded field p =
   return q
 #pop-options
 
-let addr_of_struct_field #a #tag #fields #excluded field p =
-  addr_of_struct_field' field p
+let addr_of_struct_field_ref #a #tag #fields #excluded field p =
+  addr_of_struct_field_ref' field p
 
 let struct'_with_field
   (tag: string) (fields: struct_fields) (excluded: set string)
@@ -254,7 +254,7 @@ let extract_field_with_field
     (struct'_with_field tag fields excluded field w v)
     `feq` v)
 
-let unaddr_of_struct_field' #a #tag #fields #excluded field p q =
+let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -281,5 +281,5 @@ let unaddr_of_struct_field' #a #tag #fields #excluded field p q =
   extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
   return ()
 
-let unaddr_of_struct_field #a #tag #fields #excluded field p q =
-  unaddr_of_struct_field' field p q
+let unaddr_of_struct_field_ref #a #tag #fields #excluded field p q =
+  unaddr_of_struct_field_ref' field p q
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 3f626a1c721..400fd9c10df 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -349,7 +349,7 @@ val extract_field
     (requires not (excluded field))
     (ensures fun _ -> True)
 
-val addr_of_struct_field'
+val addr_of_struct_field_ref'
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -368,15 +368,16 @@ val addr_of_struct_field'
         (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
          h' (q `pts_to_view` (fields.get_field field).view)))
 
+irreducible let c_struct = 0
+
 irreducible let c_typedef = 0
 
-let mk_struct_typedef a b = b
+unfold let unfold_typedefs = [delta_attr [`%c_typedef]]
 
-unfold let norm_list =
-  [delta_attr [`%c_typedef];
+unfold let simplify_typedefs =
+  [delta_attr [`%c_struct];
    delta_only
-    [`%mk_struct_typedef;
-     `%fields_cons;
+    [`%fields_cons;
      `%fields_nil;
      `%Mkstruct_fields?.get_field;
      `%Mktypedef?.carrier;
@@ -385,7 +386,7 @@ unfold let norm_list =
      `%Mktypedef?.view];
    iota; zeta; primops]
 
-val addr_of_struct_field
+val addr_of_struct_field_ref
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -395,12 +396,12 @@ val addr_of_struct_field
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
                   #'a
-                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
-                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
                   q
-                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #false
-                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view))))
     (requires fun _ -> not (excluded field))
     (ensures fun h q h' -> 
       not (excluded field) /\
@@ -411,7 +412,7 @@ val addr_of_struct_field
         (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
          h' (q `pts_to_view` (fields.get_field field).view)))
 
-val unaddr_of_struct_field'
+val unaddr_of_struct_field_ref'
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -431,7 +432,7 @@ val unaddr_of_struct_field'
         (h (p `pts_to_view` struct_view tag fields excluded),
          h (q `pts_to_view` (fields.get_field field).view)))
 
-val unaddr_of_struct_field
+val unaddr_of_struct_field_ref
   (#tag: string) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
@@ -440,12 +441,74 @@ val unaddr_of_struct_field
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (pts_to_view u#0
                   #'a
-                  #(norm norm_list (Mktypedef?.carrier (Mkstruct_fields?.get_field fields field)))
-                  #(norm norm_list (Mktypedef?.pcm (Mkstruct_fields?.get_field fields field)))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
                   q
-                  #(norm norm_list (Mktypedef?.view_type (Mkstruct_fields?.get_field fields field)))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #false
-                  (norm norm_list (Mktypedef?.view (Mkstruct_fields?.get_field fields field)))))
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view))))
+    (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
+    (requires fun _ ->
+      excluded field == true /\
+      q == ref_focus p (struct_field tag fields field))
+    (ensures fun h _ h' -> 
+      excluded field == true /\
+      extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
+       ==
+        (h (p `pts_to_view` struct_view tag fields excluded),
+         h (q `pts_to_view` (fields.get_field field).view)))
+
+open Steel.C.Reference
+
+let addr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
+: Steel (ref 'a
+          (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+          (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (pts_to_view u#0
+                  #'a
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  q
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view))))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+=         
+//let addr_of_struct_field #a #tag #fields #excluded field p =
+  addr_of_struct_field_ref' #'a #tag #fields #excluded field p
+
+let unaddr_of_struct_field
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
+  (q: ref 'a
+    (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+    (fields.get_field field).pcm)
+: Steel unit
+    ((p `pts_to_view` struct_view tag fields excluded) `star`
+     (pts_to_view u#0
+                  #'a
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  q
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view))))
     (fun _ -> p `pts_to_view` struct_view tag fields (remove field excluded))
     (requires fun _ ->
       excluded field == true /\
@@ -457,3 +520,6 @@ val unaddr_of_struct_field
        ==
         (h (p `pts_to_view` struct_view tag fields excluded),
          h (q `pts_to_view` (fields.get_field field).view)))
+=
+//let unaddr_of_struct_field #a #tag #fields #excluded field p q =
+  unaddr_of_struct_field_ref' field p q

From 65f70e0964b59c142d45e2017304f6c1e174baf0 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 6 Aug 2021 15:09:17 -0700
Subject: [PATCH 178/513] Add make rule for krml

---
 examples/steel/arraystructs/Makefile | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 770c70d6719..563b147708e 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -39,6 +39,11 @@ verify: $(ALL_CHECKED_FILES)
 	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen OCaml \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
+.PRECIOUS: %.krml
+%.krml:
+	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen Kremlin \
+	--extract_module $(basename $(notdir $(subst .checked,,$<)))
+
 clean:
 	-rm -rf *.checked *.krml .depend kremlin.rsp *.tmp *.o compile_flags.txt
 

From 6039bbee630a7c05082398b6f2f8f61956138b0f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 6 Aug 2021 15:09:21 -0700
Subject: [PATCH 179/513] Nits

---
 examples/steel/arraystructs/PointStruct.fst | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index a2c628962a4..cce73ddf9de 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -15,6 +15,7 @@ open FStar.FSet
 //open Steel.C.Reference
 
 [@@c_typedef]
+noextract
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
@@ -23,19 +24,33 @@ let c_int: typedef = {
 }
 
 [@@c_struct]
+noextract
 let point_fields: struct_fields = 
   fields_cons "x" c_int (
   fields_cons "y" c_int (
   fields_nil))
 
+noextract
 let point_view_t = struct "point" point_fields
 
+noextract
 let point_view = struct_view "point" point_fields
 
 //let point = struct_pcm_carrier "point" point_fields
 
+noextract
 let point_pcm = struct_pcm "point" point_fields
 
+noextract
+let c_point: typedef = {
+  carrier = struct_pcm_carrier "point" point_fields;
+  pcm = struct_pcm "point" point_fields;
+  view_type = struct "point" point_fields;
+  view = struct_view "point" point_fields emptyset;
+}
+
+// let register_c_point: register_t point_view_t = register_typedef point_view_t c_point
+
 #push-options "--fuel 0"
 
 (*
@@ -48,6 +63,7 @@ let x_conn
 // --z3rlimit 30"
 
 [@@c_typedef]
+noextract
 let point = struct "point" point_fields
 
 open Steel.C.Reference
@@ -64,8 +80,8 @@ val swap (p: ref 'a point point_pcm)
       // == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
 
 let swap #a p =
-  let q: ref a int _ = addr_of_struct_field "x" p in
-  let r = addr_of_struct_field "y" p in
+  let q: ref _ int _ = addr_of_struct_field "x" p in
+  let r: ref _ int _ = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
   q `opt_write_sel` y;

From 2488338528dc046889585f8fb3e48c52863e4538 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 9 Aug 2021 07:17:41 -0700
Subject: [PATCH 180/513] Add extract_field_extracted,
 extract_field_unextracted

---
 examples/steel/arraystructs/PointStruct.fst   | 13 ++++---
 .../arraystructs/Steel.C.StructLiteral.fst    | 32 +++++++++++++++
 .../arraystructs/Steel.C.StructLiteral.fsti   | 39 ++++++++++---------
 3 files changed, 60 insertions(+), 24 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index cce73ddf9de..621ac80387f 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -73,11 +73,12 @@ val swap (p: ref 'a point point_pcm)
     (p `pts_to_view` point_view emptyset)
     (fun _ -> (p `pts_to_view` point_view emptyset))
     (requires fun _ -> True)
-    (ensures fun h q h' -> True)
-      // h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
-      // == h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
-      // h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
-      // == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
+    (ensures fun h q h' ->
+      //h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
+      //== h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
+      //h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
+      //== h (p `pts_to_view` point_view emptyset) `struct_get` "x")
+      True)
 
 let swap #a p =
   let q: ref _ int _ = addr_of_struct_field "x" p in
@@ -90,7 +91,7 @@ let swap #a p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
-  
+
 (*
 ref 'a (struct tag fields)
 ref 'a (fields.get_field field).view_type
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 8e4b217995d..52e132587c8 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -189,6 +189,38 @@ let extract_field
     (ensures fun _ -> True)
 = (struct'_without_field tag fields excluded field v, v field)
 
+let extract_field_extracted
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+= ()
+
+let extract_field_unextracted
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: field_of fields)
+  (field': field_of fields)
+  (v: struct' tag fields excluded)
+= ()
+
+val addr_of_struct_field_ref'
+  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (q `pts_to_view` (fields.get_field field).view))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+
 #push-options "--z3rlimit 30"
 let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
   let v: Ghost.erased (struct' tag fields excluded) =
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 400fd9c10df..25e90dc9634 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -348,25 +348,28 @@ val extract_field
 : Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
     (requires not (excluded field))
     (ensures fun _ -> True)
+    
+val extract_field_extracted
+  (tag: string) (fields: struct_fields) (excluded: set string)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+: Lemma
+    (requires not (excluded field))
+    (ensures snd (extract_field tag fields excluded field v) == v `struct_get` field)
+    [SMTPat (extract_field tag fields excluded field v)]
 
-val addr_of_struct_field_ref'
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+val extract_field_unextracted
+  (tag: string) (fields: struct_fields) (excluded: set string)
   (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (fields.get_field field).pcm)
-    (p `pts_to_view` struct_view tag fields excluded)
-    (fun q ->
-      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
-      (q `pts_to_view` (fields.get_field field).view))
-    (requires fun _ -> not (excluded field))
-    (ensures fun h q h' -> 
-      not (excluded field) /\
-      q == ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
-       ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
+  (field': field_of fields)
+  (v: struct' tag fields excluded)
+: Lemma
+    (requires not (excluded field) /\ not (excluded field') /\ (field =!= field'))
+    (ensures 
+      fst (extract_field tag fields excluded field v) `struct_get` field'
+      == v `struct_get` field')
+    [SMTPat (extract_field tag fields excluded field v);
+     SMTPat (has_type field' string)]
 
 irreducible let c_struct = 0
 
@@ -490,7 +493,7 @@ let addr_of_struct_field
          h' (q `pts_to_view` (fields.get_field field).view)))
 =         
 //let addr_of_struct_field #a #tag #fields #excluded field p =
-  addr_of_struct_field_ref' #'a #tag #fields #excluded field p
+  addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 let unaddr_of_struct_field
   (#tag: string) (#fields: struct_fields) (#excluded: set string)

From 9491a09e0e20e54d4627a37220df6e15094e800b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 9 Aug 2021 08:59:20 -0700
Subject: [PATCH 181/513] Try reifying struct field names into Types

---
 examples/steel/arraystructs/PointStruct.fst   | 164 +++++++++++++++---
 .../arraystructs/Steel.C.StructLiteral.fsti   |   8 +
 2 files changed, 152 insertions(+), 20 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 621ac80387f..cb97b98ed47 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -15,7 +15,8 @@ open FStar.FSet
 //open Steel.C.Reference
 
 [@@c_typedef]
-noextract
+//noextract
+//inline_for_extraction
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
@@ -24,32 +25,157 @@ let c_int: typedef = {
 }
 
 [@@c_struct]
-noextract
+//noextract
+//inline_for_extraction
 let point_fields: struct_fields = 
   fields_cons "x" c_int (
   fields_cons "y" c_int (
   fields_nil))
 
-noextract
-let point_view_t = struct "point" point_fields
+//noextract
+//inline_for_extraction
+let point = struct "point" point_fields
 
-noextract
+//noextract
+//inline_for_extraction
 let point_view = struct_view "point" point_fields
 
 //let point = struct_pcm_carrier "point" point_fields
 
-noextract
+//noextract
+//inline_for_extraction
 let point_pcm = struct_pcm "point" point_fields
 
-noextract
-let c_point: typedef = {
-  carrier = struct_pcm_carrier "point" point_fields;
-  pcm = struct_pcm "point" point_fields;
-  view_type = struct "point" point_fields;
-  view = struct_view "point" point_fields emptyset;
-}
-
-// let register_c_point: register_t point_view_t = register_typedef point_view_t c_point
+[@@c_typedef]
+//noextract
+//inline_for_extraction
+let c_point: typedef = typedef_struct "point" point_fields
+
+assume val a: Type0
+assume val b: Type0
+assume val c: Type0
+assume val d: Type0
+assume val e: Type0
+assume val f: Type0
+assume val g: Type0
+assume val h: Type0
+assume val i: Type0
+assume val j: Type0
+assume val k: Type0
+assume val l: Type0
+assume val m: Type0
+assume val n: Type0
+assume val o: Type0
+assume val p: Type0
+assume val q: Type0
+assume val r: Type0
+assume val s: Type0
+assume val t: Type0
+assume val u: Type0
+assume val v: Type0
+assume val w: Type0
+assume val x: Type0
+assume val y: Type0
+assume val z: Type0
+assume val zero: Type0
+assume val one: Type0
+assume val two: Type0
+assume val three: Type0
+assume val four: Type0
+assume val five: Type0
+assume val six: Type0
+assume val seven: Type0
+assume val eight: Type0
+assume val nine: Type0
+assume val underscore: Type0
+
+assume val string_nil: Type0
+assume val string_cons (c: Type0) (s: Type0): Type0
+
+assume val struct_fields_nil: Type0
+assume val struct_fields_cons
+  (field: Type0) (t: Type0) (fields: Type0)
+: Type0
+
+assume val mk_c_typedef (viewtype: Type0) (field_descriptions: Type0): Type0
+
+open FStar.String
+
+let char_t_of_char (ch: char): Type0 =
+  match ch with
+  | 'a' -> a
+  | 'b' -> b
+  | 'c' -> c
+  | 'd' -> d
+  | 'e' -> e
+  | 'f' -> f
+  | 'g' -> g
+  | 'h' -> h
+  | 'i' -> i
+  | 'j' -> j
+  | 'k' -> k
+  | 'l' -> l
+  | 'm' -> m
+  | 'n' -> n
+  | 'o' -> o
+  | 'p' -> p
+  | 'q' -> q
+  | 'r' -> r
+  | 's' -> s
+  | 't' -> t
+  | 'u' -> u
+  | 'v' -> v
+  | 'w' -> w
+  | 'x' -> x
+  | 'y' -> y
+  | 'z' -> z
+  | '0' -> zero
+  | '1' -> one
+  | '2' -> two
+  | '3' -> three
+  | '4' -> four
+  | '5' -> five
+  | '6' -> six
+  | '7' -> seven
+  | '8' -> eight
+  | '9' -> nine
+  | '_' -> underscore
+  | _ -> underscore
+
+let rec string_t_of_chars (s: list char): Type0 =
+  match s with
+  | [] -> string_nil
+  | c :: s -> string_cons (char_t_of_char c) (string_t_of_chars s)
+
+let typedef_fields_of (fields: struct_fields) =
+  List.Tot.fold_right
+    (fun field fields' ->
+      struct_fields_cons
+        (string_t_of_chars (String.list_of_string field))
+        (fields.get_field field).view_type
+        fields')
+    fields.cfields
+    struct_fields_nil
+
+unfold let norm_typedef_list =
+  [delta_only
+   [`%typedef_fields_of;
+    `%List.Tot.fold_right;
+    `%string_t_of_chars;
+    `%char_t_of_char;
+    `%String.list_of_string;
+    `%Mktypedef?.view_type;
+    `%Mkstruct_fields?.get_field;
+    `%Mkstruct_fields?.cfields;
+   ];
+   iota; zeta; primops]
+
+let _ =
+  mk_c_typedef
+    point
+    (norm norm_typedef_list
+      (typedef_fields_of (fields_cons "test_field" c_point point_fields)))
+// TODO what effects?
 
 #push-options "--fuel 0"
 
@@ -62,16 +188,13 @@ let x_conn
 #push-options "--print_universes --print_implicits"
 // --z3rlimit 30"
 
-[@@c_typedef]
-noextract
-let point = struct "point" point_fields
-
 open Steel.C.Reference
 
+(*
 val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
-    (fun _ -> (p `pts_to_view` point_view emptyset))
+    (fun _ -> p `pts_to_view` point_view emptyset)
     (requires fun _ -> True)
     (ensures fun h q h' ->
       //h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
@@ -91,6 +214,7 @@ let swap #a p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
+  *)
 
 (*
 ref 'a (struct tag fields)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 25e90dc9634..ec4b1d23784 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -526,3 +526,11 @@ let unaddr_of_struct_field
 =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
+
+[@@c_typedef]
+let typedef_struct (tag: string) (fields: struct_fields): typedef = {
+  carrier = struct_pcm_carrier tag fields;
+  pcm = struct_pcm tag fields;
+  view_type = struct tag fields;
+  view = struct_view tag fields emptyset;
+}

From 1e6475bc053f3ea1a390c49182f9d7d05c4aeb06 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 9 Aug 2021 09:12:28 -0700
Subject: [PATCH 182/513] register_fields_of and register_typedef_of

---
 examples/steel/arraystructs/PointStruct.fst | 136 ++------------------
 1 file changed, 11 insertions(+), 125 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index cb97b98ed47..be22f46b494 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -14,6 +14,9 @@ open Steel.C.Ref
 open FStar.FSet
 //open Steel.C.Reference
 
+let register_fields_of (_: Type0) = struct_fields
+let register_typedef_of (_: Type0) = typedef
+
 [@@c_typedef]
 //noextract
 //inline_for_extraction
@@ -23,6 +26,7 @@ let c_int: typedef = {
   view_type = int;
   view = opt_view int;
 }
+let _: register_typedef_of int = c_int
 
 [@@c_struct]
 //noextract
@@ -51,131 +55,13 @@ let point_pcm = struct_pcm "point" point_fields
 //inline_for_extraction
 let c_point: typedef = typedef_struct "point" point_fields
 
-assume val a: Type0
-assume val b: Type0
-assume val c: Type0
-assume val d: Type0
-assume val e: Type0
-assume val f: Type0
-assume val g: Type0
-assume val h: Type0
-assume val i: Type0
-assume val j: Type0
-assume val k: Type0
-assume val l: Type0
-assume val m: Type0
-assume val n: Type0
-assume val o: Type0
-assume val p: Type0
-assume val q: Type0
-assume val r: Type0
-assume val s: Type0
-assume val t: Type0
-assume val u: Type0
-assume val v: Type0
-assume val w: Type0
-assume val x: Type0
-assume val y: Type0
-assume val z: Type0
-assume val zero: Type0
-assume val one: Type0
-assume val two: Type0
-assume val three: Type0
-assume val four: Type0
-assume val five: Type0
-assume val six: Type0
-assume val seven: Type0
-assume val eight: Type0
-assume val nine: Type0
-assume val underscore: Type0
-
-assume val string_nil: Type0
-assume val string_cons (c: Type0) (s: Type0): Type0
-
-assume val struct_fields_nil: Type0
-assume val struct_fields_cons
-  (field: Type0) (t: Type0) (fields: Type0)
-: Type0
-
-assume val mk_c_typedef (viewtype: Type0) (field_descriptions: Type0): Type0
-
-open FStar.String
-
-let char_t_of_char (ch: char): Type0 =
-  match ch with
-  | 'a' -> a
-  | 'b' -> b
-  | 'c' -> c
-  | 'd' -> d
-  | 'e' -> e
-  | 'f' -> f
-  | 'g' -> g
-  | 'h' -> h
-  | 'i' -> i
-  | 'j' -> j
-  | 'k' -> k
-  | 'l' -> l
-  | 'm' -> m
-  | 'n' -> n
-  | 'o' -> o
-  | 'p' -> p
-  | 'q' -> q
-  | 'r' -> r
-  | 's' -> s
-  | 't' -> t
-  | 'u' -> u
-  | 'v' -> v
-  | 'w' -> w
-  | 'x' -> x
-  | 'y' -> y
-  | 'z' -> z
-  | '0' -> zero
-  | '1' -> one
-  | '2' -> two
-  | '3' -> three
-  | '4' -> four
-  | '5' -> five
-  | '6' -> six
-  | '7' -> seven
-  | '8' -> eight
-  | '9' -> nine
-  | '_' -> underscore
-  | _ -> underscore
-
-let rec string_t_of_chars (s: list char): Type0 =
-  match s with
-  | [] -> string_nil
-  | c :: s -> string_cons (char_t_of_char c) (string_t_of_chars s)
-
-let typedef_fields_of (fields: struct_fields) =
-  List.Tot.fold_right
-    (fun field fields' ->
-      struct_fields_cons
-        (string_t_of_chars (String.list_of_string field))
-        (fields.get_field field).view_type
-        fields')
-    fields.cfields
-    struct_fields_nil
-
-unfold let norm_typedef_list =
-  [delta_only
-   [`%typedef_fields_of;
-    `%List.Tot.fold_right;
-    `%string_t_of_chars;
-    `%char_t_of_char;
-    `%String.list_of_string;
-    `%Mktypedef?.view_type;
-    `%Mkstruct_fields?.get_field;
-    `%Mkstruct_fields?.cfields;
-   ];
-   iota; zeta; primops]
-
-let _ =
-  mk_c_typedef
-    point
-    (norm norm_typedef_list
-      (typedef_fields_of (fields_cons "test_field" c_point point_fields)))
-// TODO what effects?
+// Needed to emit the right DTypeFlat declaration
+let _: register_fields_of point = norm [delta_only [`%point_fields]] point_fields
+
+// Needed to associate struct fields with their types
+// (if c_point ever appears as a field of a struct, need to know what
+// its corresponding type is)
+let _: register_typedef_of point = c_point
 
 #push-options "--fuel 0"
 

From 97b4fc18594708c321d72f5c9c688fc563cfc11f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 9 Aug 2021 12:35:34 -0700
Subject: [PATCH 183/513] Encode struct name as Typestring instead of string

---
 examples/steel/arraystructs/PointStruct.fst   | 49 +++++-----
 .../arraystructs/Steel.C.StructLiteral.fst    | 12 +++
 .../arraystructs/Steel.C.StructLiteral.fsti   | 91 +++++++++++-------
 .../steel/arraystructs/Steel.C.Typedef.fst    | 85 +----------------
 examples/steel/arraystructs/Typestring.fst    | 42 +++++++++
 examples/steel/arraystructs/Typestring.fsti   | 92 +++++++++++++++++++
 6 files changed, 228 insertions(+), 143 deletions(-)
 create mode 100644 examples/steel/arraystructs/Typestring.fst
 create mode 100644 examples/steel/arraystructs/Typestring.fsti

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index be22f46b494..6f28d733f11 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -12,11 +12,9 @@ open Steel.Effect.Atomic
 open Steel.C.Ref
 
 open FStar.FSet
+open Typestring
 //open Steel.C.Reference
 
-let register_fields_of (_: Type0) = struct_fields
-let register_typedef_of (_: Type0) = typedef
-
 [@@c_typedef]
 //noextract
 //inline_for_extraction
@@ -26,49 +24,50 @@ let c_int: typedef = {
   view_type = int;
   view = opt_view int;
 }
-let _: register_typedef_of int = c_int
+
+module T = FStar.Tactics
+
+irreducible
+inline_for_extraction
+//[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
+//     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
+let point_tag = normalize (mk_string_t "point")
 
 [@@c_struct]
 //noextract
 //inline_for_extraction
-let point_fields: struct_fields = 
+let point_fields: struct_fields =
   fields_cons "x" c_int (
   fields_cons "y" c_int (
   fields_nil))
 
 //noextract
-//inline_for_extraction
-let point = struct "point" point_fields
+inline_for_extraction
+let point = struct point_tag point_fields
 
 //noextract
 //inline_for_extraction
-let point_view = struct_view "point" point_fields
+let point_view = struct_view point_tag point_fields
 
-//let point = struct_pcm_carrier "point" point_fields
+//let point = struct_pcm_carrier point_tag point_fields
 
 //noextract
 //inline_for_extraction
-let point_pcm = struct_pcm "point" point_fields
+let point_pcm = struct_pcm point_tag point_fields
 
 [@@c_typedef]
 //noextract
 //inline_for_extraction
-let c_point: typedef = typedef_struct "point" point_fields
-
-// Needed to emit the right DTypeFlat declaration
-let _: register_fields_of point = norm [delta_only [`%point_fields]] point_fields
+let c_point: typedef = typedef_struct point_tag point_fields
 
-// Needed to associate struct fields with their types
-// (if c_point ever appears as a field of a struct, need to know what
-// its corresponding type is)
-let _: register_typedef_of point = c_point
+let _ = normalize (mk_c_struct point_tag point_fields)
 
 #push-options "--fuel 0"
 
 (*
 let x_conn
 : connection point_pcm (opt_pcm #int)
-= struct_field "point" point_fields "x"
+= struct_field point_tag point_fields "x"
 *)
 
 #push-options "--print_universes --print_implicits"
@@ -76,7 +75,6 @@ let x_conn
 
 open Steel.C.Reference
 
-(*
 val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
@@ -100,7 +98,6 @@ let swap #a p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
-  *)
 
 (*
 ref 'a (struct tag fields)
@@ -108,7 +105,7 @@ ref 'a (fields.get_field field).view_type
 ref 'a view_t ...
 
 struct: s:string -> x:Type{x == y:string{y == s}} -> struct_fields -> Type
-point = s:string{s == "point"}
+point = s:string{s == point_tag}
 
 [@@c_typedef]
 s = struct ..
@@ -117,7 +114,7 @@ s = struct ..
 point_fields = fields_cons "a" s
 
 [@@c_typedef]
-point = struct "point" point_fields
+point = struct point_tag point_fields
 
 mark get_field, view_type, ... c_struct
 
@@ -173,7 +170,7 @@ addr_of_struct_field "x" (p: ref 'a #(struct_pcm_carrier tag point_fields) (stru
 
 /// make pts_to_view stuff smt_fallback?
 let addr_of_x' #a p excluded =
-  let q = addr_of_struct_field #_ #"point" #point_fields #excluded "x" p in
+  let q = addr_of_struct_field #_ #point_tag #point_fields #excluded "x" p in
   //change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
   //change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` point_view (insert "x" excluded));
   //slassert ((p `pts_to_view` point_view (insert "x" excluded)) `star`
@@ -182,10 +179,10 @@ let addr_of_x' #a p excluded =
     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int));
   change_equal_slprop (p `pts_to_view` _)
     (pts_to_view #a #point #point_pcm p
-          #(struct' "point" point_fields (insert #string "x" excluded)) #false 
+          #(struct' point_tag point_fields (insert #string "x" excluded)) #false 
          (point_view (insert "x" excluded)));
   //slassert ((pts_to_view #a #point #point_pcm p
-  //        #(struct' "point" point_fields (insert #string "x" excluded)) #false 
+  //        #(struct' point_tag point_fields (insert #string "x" excluded)) #false 
   //       (point_view (insert "x" excluded))) `star`
   //     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int)));
   //sladmit();
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 52e132587c8..bd6ad6f0973 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -15,6 +15,18 @@ open Steel.C.Opt
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
+(* Begin for extraction *)
+
+let struct_fields_t_nil: Type0 = unit
+let struct_fields_t_cons
+  (field: Type0) (t: Type0) (fields: Type0)
+: Type0
+= unit
+
+let mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0 = unit
+
+(* End for extraction *)
+
 let struct_dom (excluded: set string) = refine string (notin excluded)
 
 let struct_cod (fields: struct_fields) (excluded: set string) (field: struct_dom excluded) =
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index ec4b1d23784..c4f595f659b 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -14,9 +14,10 @@ open Steel.C.Opt
 
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
-
 open FStar.FSet
 
+module TS = Typestring
+
 (**** MOVE TO ChurchList *)
 
 let rec list_elim (xs: list 'a)
@@ -151,6 +152,30 @@ noeq type struct_fields = {
   // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
 }
 
+(* Begin for extraction *)
+
+val struct_fields_t_nil: Type0
+val struct_fields_t_cons
+  (field: Type0) (t: Type0) (fields: Type0)
+: Type0
+
+let struct_fields_t (fields: struct_fields) =
+  List.Tot.fold_right
+    (fun field fields' ->
+      struct_fields_t_cons
+        (TS.mk_string_t field)
+        (fields.get_field field).view_type
+        fields')
+    fields.cfields
+    struct_fields_t_nil
+
+val mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0
+
+let mk_c_struct (tag: Type0) (fields: struct_fields) =
+  mk_struct_def tag (struct_fields_t fields)
+
+(* End for extraction *)
+
 let trivial_typedef: typedef = {
   carrier = option unit;
   pcm = opt_pcm #unit;
@@ -174,27 +199,27 @@ let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fi
   get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
 }
 
-val struct' (tag: string) (fields: struct_fields) (excluded: set string): Type0
+val struct' (tag: Type0) (fields: struct_fields) (excluded: set string): Type0
 
-let struct (tag: string) (fields: struct_fields) = struct' tag fields emptyset
+let struct (tag: Type0) (fields: struct_fields) = struct' tag fields emptyset
 
-val mk_nil (tag: string): struct tag fields_nil
+val mk_nil (tag: Type0): struct tag fields_nil
 
-val mk_cons (tag: string) (fields: struct_fields)
+val mk_cons (tag: Type0) (fields: struct_fields)
   (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
 : Pure (struct tag (fields_cons field td fields))
     (requires fields.has_field field == false)
     (ensures fun _ -> True)
 
-val struct_pcm_carrier (tag: string) (fields: struct_fields): Type0
+val struct_pcm_carrier (tag: Type0) (fields: struct_fields): Type0
 
-val struct_pcm (tag: string) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+val struct_pcm (tag: Type0) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
 
 let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
 
 /// Reading a struct field
 val struct_get
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (x: struct' tag fields excluded) (field: field_of fields)
 : Pure (fields.get_field field).view_type
     (requires excluded field == false)
@@ -202,7 +227,7 @@ val struct_get
 
 /// Writing a struct field
 val struct_put
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
@@ -213,7 +238,7 @@ val struct_put
 /// For a fixed field name, struct_get and struct_put form a lens
 
 val struct_get_put 
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
@@ -223,7 +248,7 @@ val struct_get_put
   [SMTPat (struct_put x field v `struct_get` field)]
 
 val struct_put_get
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field: field_of fields)
 : Lemma
@@ -232,7 +257,7 @@ val struct_put_get
   [SMTPat (struct_put x field (x `struct_get` field))]
 
 val struct_put_put
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct tag fields)
   (field: field_of fields)
   (v w: (fields.get_field field).view_type)
@@ -242,7 +267,7 @@ val struct_put_put
 /// struct_get/struct_put pairs for different fields don't interfere with each other
 
 val struct_get_put_ne
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field1: field_of fields)
   (field2: field_of fields)
@@ -253,7 +278,7 @@ val struct_get_put_ne
   [SMTPat (struct_put x field1 v `struct_get` field2)]
   
 val struct_put_put_ne
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field1: field_of fields)
   (v: (fields.get_field field1).view_type)
@@ -265,19 +290,19 @@ val struct_put_put_ne
       struct_put (struct_put x field1 v) field2 w ==
       struct_put (struct_put x field2 w) field1 v)
 
-let struct_pcm_one (tag: string) (fields: struct_fields)
+let struct_pcm_one (tag: Type0) (fields: struct_fields)
 : struct_pcm_carrier tag fields
 = one (struct_pcm tag fields)
 
 /// Reading a pcm_struct_carrier field
 val struct_pcm_get
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields) (field: field_of fields)
 : (fields.get_field field).carrier
 
 /// Writing a struct_pcm_carrier field
 val struct_pcm_put
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
   (v: (fields.get_field field).carrier)
@@ -286,7 +311,7 @@ val struct_pcm_put
 /// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
 
 val struct_pcm_get_put 
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
   (v: (fields.get_field field).carrier)
@@ -294,14 +319,14 @@ val struct_pcm_get_put
   [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
 
 val struct_pcm_put_get
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
 : Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
   [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
 
 val struct_pcm_put_put
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
   (v w: (fields.get_field field).carrier)
@@ -311,7 +336,7 @@ val struct_pcm_put_put
 /// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
 
 val struct_pcm_get_put_ne
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field1: field_of fields)
   (field2: field_of fields)
@@ -322,7 +347,7 @@ val struct_pcm_get_put_ne
   [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
   
 val struct_pcm_put_put_ne
-  (#tag: string) (#fields: struct_fields)
+  (#tag: Type0) (#fields: struct_fields)
   (x: struct_pcm_carrier tag fields)
   (field1: field_of fields)
   (v: (fields.get_field field1).carrier)
@@ -334,15 +359,15 @@ val struct_pcm_put_put_ne
       struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
       struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-val struct_view (tag: string) (fields: struct_fields) (excluded: set string)
+val struct_view (tag: Type0) (fields: struct_fields) (excluded: set string)
 : sel_view (struct_pcm tag fields) (struct' tag fields excluded) false
 
 val struct_field
-  (tag: string) (fields: struct_fields) (field: field_of fields)
+  (tag: Type0) (fields: struct_fields) (field: field_of fields)
 : connection (struct_pcm tag fields) (fields.get_field field).pcm
 
 val extract_field
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: struct_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
@@ -350,7 +375,7 @@ val extract_field
     (ensures fun _ -> True)
     
 val extract_field_extracted
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: struct_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Lemma
@@ -359,7 +384,7 @@ val extract_field_extracted
     [SMTPat (extract_field tag fields excluded field v)]
 
 val extract_field_unextracted
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: struct_fields) (excluded: set string)
   (field: field_of fields)
   (field': field_of fields)
   (v: struct' tag fields excluded)
@@ -390,7 +415,7 @@ unfold let simplify_typedefs =
    iota; zeta; primops]
 
 val addr_of_struct_field_ref
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
 : Steel (ref 'a (fields.get_field field).pcm)
@@ -416,7 +441,7 @@ val addr_of_struct_field_ref
          h' (q `pts_to_view` (fields.get_field field).view)))
 
 val unaddr_of_struct_field_ref'
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
   (q: ref 'a (fields.get_field field).pcm)
@@ -436,7 +461,7 @@ val unaddr_of_struct_field_ref'
          h (q `pts_to_view` (fields.get_field field).view)))
 
 val unaddr_of_struct_field_ref
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
   (q: ref 'a (fields.get_field field).pcm)
@@ -465,7 +490,7 @@ val unaddr_of_struct_field_ref
 open Steel.C.Reference
 
 let addr_of_struct_field
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
 : Steel (ref 'a
@@ -496,7 +521,7 @@ let addr_of_struct_field
   addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 let unaddr_of_struct_field
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
   (q: ref 'a
@@ -528,7 +553,7 @@ let unaddr_of_struct_field
   unaddr_of_struct_field_ref' field p q
 
 [@@c_typedef]
-let typedef_struct (tag: string) (fields: struct_fields): typedef = {
+let typedef_struct (tag: Type0) (fields: struct_fields): typedef = {
   carrier = struct_pcm_carrier tag fields;
   pcm = struct_pcm tag fields;
   view_type = struct tag fields;
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index e987d18f990..9f0e512fd9e 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -16,87 +16,4 @@ noeq type typedef = {
   view: sel_view pcm view_type false;
 } 
 
-// assume val malloc: typedef -> ptr typedef.carrier typedef.pcm 
-
-(*
- 
-
-let field_name fields = (field: string { field `List.Tot.mem` List.Tot.map fst fields}) 
-
- 
-
-let field_conn: 
-
-  name: string -> 
-
-  fields: list (string & typedef) -> 
-
-  let t = typedef_struct name fields in 
-
-  field_name: field_name fields -> 
-
-  connection t.pcm (List.Tot.assoc field_name fields).pcm 
-
- 
-
-let field_conn_large_to_small: 
-
-  name: string -> 
-
-  fields: list (string & typedef) -> 
-
-  let t = typedef_struct name fields in 
-
-  field_name: field_name fields -> 
-
-  x: t.user -> 
-
-  Lemma 
-
-  t.to_view (field_conn name fields field_name).morph x) == f?? (...) 
-
- 
-
-let addr_of_field_tot: 
-
-  name: string -> 
-
-  fields: list (string & typedef) -> 
-
-  let t = typedef_struct name fields in 
-
-  field_name: field_name fields -> 
-
-  ptr ‘a t.pcm -> 
-
-  ptr ‘a (List.Tot.assoc field_name fields).pcm 
-
-= ... 
-
- 
-
-Page Break
- 
-
-val lift_view_struct: 
-
-  #field_name: eqtype -> 
-
-  #carriers: (field_name -> Type) -> 
-
-  pcms: (fn: field_name -> pcm (carriers fn)) -> 
-
-  users: (field_name -> Type) -> 
-
-  can_view_unit_views: bool -> 
-
-  views: (fn: field_name -> view (users fn) can_view_unit_views) -> 
-
-  include: list field_name -> 
-
-Tot (view (struct_pcm pcms) ... (can_view_unit_views || Nil? include)) 
-
- 
-
-val weaken: view ... false -> view ... true 
-*)
+let register_typedef_of (_: Type0) = typedef
diff --git a/examples/steel/arraystructs/Typestring.fst b/examples/steel/arraystructs/Typestring.fst
new file mode 100644
index 00000000000..958b71a3194
--- /dev/null
+++ b/examples/steel/arraystructs/Typestring.fst
@@ -0,0 +1,42 @@
+module Typestring
+
+let a: Type0 = unit
+let b: Type0 = unit
+let c: Type0 = unit
+let d: Type0 = unit
+let e: Type0 = unit
+let f: Type0 = unit
+let g: Type0 = unit
+let h: Type0 = unit
+let i: Type0 = unit
+let j: Type0 = unit
+let k: Type0 = unit
+let l: Type0 = unit
+let m: Type0 = unit
+let n: Type0 = unit
+let o: Type0 = unit
+let p: Type0 = unit
+let q: Type0 = unit
+let r: Type0 = unit
+let s: Type0 = unit
+let t: Type0 = unit
+let u: Type0 = unit
+let v: Type0 = unit
+let w: Type0 = unit
+let x: Type0 = unit
+let y: Type0 = unit
+let z: Type0 = unit
+let zero: Type0 = unit
+let one: Type0 = unit
+let two: Type0 = unit
+let three: Type0 = unit
+let four: Type0 = unit
+let five: Type0 = unit
+let six: Type0 = unit
+let seven: Type0 = unit
+let eight: Type0 = unit
+let nine: Type0 = unit
+let underscore: Type0 = unit
+
+let string_nil: Type0 = unit
+let string_cons (c: Type0) (s: Type0): Type0 = unit
diff --git a/examples/steel/arraystructs/Typestring.fsti b/examples/steel/arraystructs/Typestring.fsti
new file mode 100644
index 00000000000..810f498bb1f
--- /dev/null
+++ b/examples/steel/arraystructs/Typestring.fsti
@@ -0,0 +1,92 @@
+module Typestring
+
+val a: Type0
+val b: Type0
+val c: Type0
+val d: Type0
+val e: Type0
+val f: Type0
+val g: Type0
+val h: Type0
+val i: Type0
+val j: Type0
+val k: Type0
+val l: Type0
+val m: Type0
+val n: Type0
+val o: Type0
+val p: Type0
+val q: Type0
+val r: Type0
+val s: Type0
+val t: Type0
+val u: Type0
+val v: Type0
+val w: Type0
+val x: Type0
+val y: Type0
+val z: Type0
+val zero: Type0
+val one: Type0
+val two: Type0
+val three: Type0
+val four: Type0
+val five: Type0
+val six: Type0
+val seven: Type0
+val eight: Type0
+val nine: Type0
+val underscore: Type0
+
+val string_nil: Type0
+val string_cons (c: Type0) (s: Type0): Type0
+
+open FStar.String
+
+let char_t_of_char (ch: char): Type0 =
+  match ch with
+  | 'a' -> a
+  | 'b' -> b
+  | 'c' -> c
+  | 'd' -> d
+  | 'e' -> e
+  | 'f' -> f
+  | 'g' -> g
+  | 'h' -> h
+  | 'i' -> i
+  | 'j' -> j
+  | 'k' -> k
+  | 'l' -> l
+  | 'm' -> m
+  | 'n' -> n
+  | 'o' -> o
+  | 'p' -> p
+  | 'q' -> q
+  | 'r' -> r
+  | 's' -> s
+  | 't' -> t
+  | 'u' -> u
+  | 'v' -> v
+  | 'w' -> w
+  | 'x' -> x
+  | 'y' -> y
+  | 'z' -> z
+  | '0' -> zero
+  | '1' -> one
+  | '2' -> two
+  | '3' -> three
+  | '4' -> four
+  | '5' -> five
+  | '6' -> six
+  | '7' -> seven
+  | '8' -> eight
+  | '9' -> nine
+  | '_' -> underscore
+  | _ -> underscore
+  
+let rec string_t_of_chars (s: list char): Type0 =
+  match s with
+  | [] -> string_nil
+  | c :: s -> string_cons (char_t_of_char c) (string_t_of_chars s)
+
+let mk_string_t s = string_t_of_chars (String.list_of_string s)

From 74ff3f28d20d4178eb4378877a456a282c66bf38 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 16:19:32 -0700
Subject: [PATCH 184/513] Start parsing struct decls in Steel extraction

---
 src/extraction/FStar.Extraction.Kremlin.fs | 44 ++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index eaffc577a84..b5ff5de9791 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -405,6 +405,44 @@ and translate_decl env d: list<decl> =
 
 and translate_let env flavor lb: option<decl> =
   match lb with
+  | {
+      mllb_tysc = Some (_, MLTY_Named ([MLTY_Named ([], view_type_name)], p));
+      mllb_def = {expr=MLE_Name typedef_name};
+    } when Syntax.string_of_mlpath p = "Steel.C.Typedef.register_typedef_of" ->
+      begin
+        BU.print2 "Found %s : register_typedef_of %s\n"
+          (Syntax.string_of_mlpath typedef_name)
+          (Syntax.string_of_mlpath view_type_name);
+        None
+      end
+
+  | {
+      mllb_tysc = Some (_, MLTY_Named ([MLTY_Named ([], view_type_name)], p));
+      mllb_def = fields;
+    } when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.register_fields_of" ->
+      begin
+        BU.print1 "Found _ : register_fields_of %s. Fields are:\n"
+          (Syntax.string_of_mlpath view_type_name);
+        let rec parse_fields fields =
+          match fields with
+          | {expr=MLE_Name p}
+            when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.fields_nil"
+            ->
+            print_endline "End of fields"
+          | {expr=MLE_App ({expr=MLE_Name p},
+                           [{expr=MLE_Const (MLC_String name)}; typedef; fields])}
+            when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.fields_cons"
+            ->
+            BU.print2 "  Field %s : %s\n"
+              name
+              (FStar.Extraction.ML.Code.string_of_mlexpr ([], "") typedef);
+            parse_fields fields
+          | _ -> failwith "Couldn't parse fields from struct_fields"
+        in
+        parse_fields fields;
+        None
+      end
+
   | {
       mllb_name = name;
       mllb_tysc = Some (tvars, t0);
@@ -576,6 +614,12 @@ and translate_type env t: typ =
   | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
       TUnit
 
+(* TODO
+  | MLTY_Named ([_; arg; _; _], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
+    ->
+      TBuf (translate_type env arg) *)
+
   | MLTY_Named ([_; arg; _], p) when
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||

From 2935d3e29bcf66fe708b8549fbcc6b4355e7cff1 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 9 Aug 2021 14:01:42 -0700
Subject: [PATCH 185/513] Code to parse struct typedef

---
 examples/steel/arraystructs/PointStruct.fst |   7 +-
 examples/steel/arraystructs/Typestring.fsti | 156 ++++++++++----------
 src/extraction/FStar.Extraction.Kremlin.fs  |  98 ++++++++++--
 3 files changed, 168 insertions(+), 93 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 6f28d733f11..e35717b6149 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -27,11 +27,10 @@ let c_int: typedef = {
 
 module T = FStar.Tactics
 
-irreducible
 inline_for_extraction
-//[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
-//     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
-let point_tag = normalize (mk_string_t "point")
+[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
+     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
+let point_tag = (mk_string_t "point")
 
 [@@c_struct]
 //noextract
diff --git a/examples/steel/arraystructs/Typestring.fsti b/examples/steel/arraystructs/Typestring.fsti
index 810f498bb1f..457a4b50035 100644
--- a/examples/steel/arraystructs/Typestring.fsti
+++ b/examples/steel/arraystructs/Typestring.fsti
@@ -1,92 +1,92 @@
 module Typestring
 
-val a: Type0
-val b: Type0
-val c: Type0
-val d: Type0
-val e: Type0
-val f: Type0
-val g: Type0
-val h: Type0
-val i: Type0
-val j: Type0
-val k: Type0
-val l: Type0
-val m: Type0
-val n: Type0
-val o: Type0
-val p: Type0
-val q: Type0
-val r: Type0
-val s: Type0
-val t: Type0
-val u: Type0
-val v: Type0
-val w: Type0
-val x: Type0
-val y: Type0
-val z: Type0
-val zero: Type0
-val one: Type0
-val two: Type0
-val three: Type0
-val four: Type0
-val five: Type0
-val six: Type0
-val seven: Type0
-val eight: Type0
-val nine: Type0
-val underscore: Type0
+val ca: Type0
+val cb: Type0
+val cc: Type0
+val cd: Type0
+val ce: Type0
+val cf: Type0
+val cg: Type0
+val ch: Type0
+val ci: Type0
+val cj: Type0
+val ck: Type0
+val cl: Type0
+val cm: Type0
+val cn: Type0
+val co: Type0
+val cp: Type0
+val cq: Type0
+val cr: Type0
+val cs: Type0
+val ct: Type0
+val cu: Type0
+val cv: Type0
+val cw: Type0
+val cx: Type0
+val cy: Type0
+val cz: Type0
+val c0: Type0
+val c1: Type0
+val c2: Type0
+val c3: Type0
+val c4: Type0
+val c5: Type0
+val c6: Type0
+val c7: Type0
+val c8: Type0
+val c9: Type0
+val c_: Type0
 
 val string_nil: Type0
 val string_cons (c: Type0) (s: Type0): Type0
 
 open FStar.String
 
-let char_t_of_char (ch: char): Type0 =
-  match ch with
-  | 'a' -> a
-  | 'b' -> b
-  | 'c' -> c
-  | 'd' -> d
-  | 'e' -> e
-  | 'f' -> f
-  | 'g' -> g
-  | 'h' -> h
-  | 'i' -> i
-  | 'j' -> j
-  | 'k' -> k
-  | 'l' -> l
-  | 'm' -> m
-  | 'n' -> n
-  | 'o' -> o
-  | 'p' -> p
-  | 'q' -> q
-  | 'r' -> r
-  | 's' -> s
-  | 't' -> t
-  | 'u' -> u
-  | 'v' -> v
-  | 'w' -> w
-  | 'x' -> x
-  | 'y' -> y
-  | 'z' -> z
-  | '0' -> zero
-  | '1' -> one
-  | '2' -> two
-  | '3' -> three
-  | '4' -> four
-  | '5' -> five
-  | '6' -> six
-  | '7' -> seven
-  | '8' -> eight
-  | '9' -> nine
-  | '_' -> underscore
-  | _ -> underscore
+let char_t_of_char (c: char): Type0 =
+  match c with
+  | 'a' -> ca
+  | 'b' -> cb
+  | 'c' -> cc
+  | 'd' -> cd
+  | 'e' -> ce
+  | 'f' -> cf
+  | 'g' -> cg
+  | 'h' -> ch
+  | 'i' -> ci
+  | 'j' -> cj
+  | 'k' -> ck
+  | 'l' -> cl
+  | 'm' -> cm
+  | 'n' -> cn
+  | 'o' -> co
+  | 'p' -> cp
+  | 'q' -> cq
+  | 'r' -> cr
+  | 's' -> cs
+  | 't' -> ct
+  | 'u' -> cu
+  | 'v' -> cv
+  | 'w' -> cw
+  | 'x' -> cx
+  | 'y' -> cy
+  | 'z' -> cz
+  | '0' -> c0
+  | '1' -> c1
+  | '2' -> c2
+  | '3' -> c3
+  | '4' -> c4
+  | '5' -> c5
+  | '6' -> c6
+  | '7' -> c7
+  | '8' -> c8
+  | '9' -> c9
+  | '_' -> c_
+  | _ -> c_
   
 let rec string_t_of_chars (s: list char): Type0 =
   match s with
   | [] -> string_nil
   | c :: s -> string_cons (char_t_of_char c) (string_t_of_chars s)
 
-let mk_string_t s = string_t_of_chars (String.list_of_string s)
+let mk_string_t s: Type0 = string_t_of_chars (String.list_of_string s)
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index b5ff5de9791..9b18c652722 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -283,6 +283,43 @@ let is_op op =
 let is_machine_int m =
   mk_width m <> None
 
+(* TODO: in stdlib somewhere? *)
+let opt_bind (m: option<'a>) (k: 'a -> option<'b>): option<'b> =
+  match m with Some x -> k x | None -> None
+
+let char_of_typechar (t: mlty): option<char> =
+  match t with
+  | MLTY_Named ([], p) ->
+    let p = Syntax.string_of_mlpath p in
+    let n = FStar.String.strlen "Typestring.c" in
+    if FStar.String.strlen p > n &&
+       FStar.String.substring p 0 n = "Typestring.c"
+    then
+      Some (FStar.String.get p n)
+    else
+      None
+
+  | _ -> None
+
+let string_of_typestring (t: mlty): option<string> =
+  let rec go t: option<list<string>> =
+    match t with
+    | MLTY_Named ([], p)
+      when Syntax.string_of_mlpath p = "Typestring.string_nil"
+      ->
+      Some []
+
+    | MLTY_Named ([c; t], p)
+      when Syntax.string_of_mlpath p = "Typestring.string_cons"
+      ->
+      opt_bind (char_of_typechar c) (fun c' ->
+      opt_bind (go t) (fun s' ->
+      Some (String.make 1 c' :: s')))
+      
+    | _ -> None
+  in
+  opt_bind (go t) (fun ss -> Some (FStar.String.concat "" ss))
+
 (* Environments **************************************************************)
 
 type env = {
@@ -405,17 +442,6 @@ and translate_decl env d: list<decl> =
 
 and translate_let env flavor lb: option<decl> =
   match lb with
-  | {
-      mllb_tysc = Some (_, MLTY_Named ([MLTY_Named ([], view_type_name)], p));
-      mllb_def = {expr=MLE_Name typedef_name};
-    } when Syntax.string_of_mlpath p = "Steel.C.Typedef.register_typedef_of" ->
-      begin
-        BU.print2 "Found %s : register_typedef_of %s\n"
-          (Syntax.string_of_mlpath typedef_name)
-          (Syntax.string_of_mlpath view_type_name);
-        None
-      end
-
   | {
       mllb_tysc = Some (_, MLTY_Named ([MLTY_Named ([], view_type_name)], p));
       mllb_def = fields;
@@ -549,6 +575,56 @@ and translate_type_decl env ty: option<decl> =
     None
   else
     match ty with
+    | {tydecl_assumed=assumed;
+       tydecl_name=name;
+       tydecl_parameters=args;
+       tydecl_meta=flags;
+       tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_c_struct"
+      ->
+      begin
+        (* TODO remove/improve these print commands *)
+        print_endline "Parsing struct definition.";
+        begin match string_of_typestring tag with
+        | None ->
+          BU.print1 "Failed to parse struct tag from %s.\n"
+            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
+          None
+        | Some tag ->
+          let rec parse_fields (fields: mlty): option<list<_>> =
+            match fields with
+            | MLTY_Named ([], p)
+              when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.struct_fields_t_nil"
+              -> Some []
+              
+            | MLTY_Named ([field; t; fields], p)
+              when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.struct_fields_t_cons"
+              ->
+              opt_bind (string_of_typestring field) (fun field ->
+              opt_bind (parse_fields fields) (fun fields ->
+              Some ((field, t) :: fields)))
+
+            | _ -> None
+          in
+          match parse_fields fields with
+          | None ->
+            BU.print1 "Failed to parse struct fields from %s.\n"
+              (FStar.Extraction.ML.Code.string_of_mlty ([], "") fields);
+            None
+
+          | Some fields ->
+              BU.print1 "Got struct %s with following fields:\n" tag;
+              List.fold_left
+                (fun () (field, ty) ->
+                   BU.print2 "  %s : %s"
+                     field
+                     (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty))
+                ()
+                fields;
+              None // TODO return DTypeFlat(..)
+        end
+      end
+
     | {tydecl_assumed=assumed;
        tydecl_name=name;
        tydecl_parameters=args;

From bbc737db6eb7d06b414d056d3ce12a61322dd46f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 07:20:23 -0700
Subject: [PATCH 186/513] Translate struct and ref types

---
 examples/steel/arraystructs/PointStruct.fst | 33 ++++++++++-------
 src/extraction/FStar.Extraction.Kremlin.fs  | 39 ++++++++++++---------
 2 files changed, 43 insertions(+), 29 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index e35717b6149..f8cda2b4e50 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -16,8 +16,7 @@ open Typestring
 //open Steel.C.Reference
 
 [@@c_typedef]
-//noextract
-//inline_for_extraction
+noextract inline_for_extraction
 let c_int: typedef = {
   carrier = option int;
   pcm = opt_pcm #int;
@@ -27,23 +26,22 @@ let c_int: typedef = {
 
 module T = FStar.Tactics
 
-inline_for_extraction
-[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
-     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
-let point_tag = (mk_string_t "point")
+noextract inline_for_extraction
+//[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
+//     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
+let point_tag = normalize (mk_string_t "point")
 
 [@@c_struct]
-//noextract
-//inline_for_extraction
+noextract inline_for_extraction
 let point_fields: struct_fields =
   fields_cons "x" c_int (
   fields_cons "y" c_int (
   fields_nil))
 
-//noextract
-inline_for_extraction
+noextract inline_for_extraction
 let point = struct point_tag point_fields
 
+(*
 //noextract
 //inline_for_extraction
 let point_view = struct_view point_tag point_fields
@@ -53,14 +51,23 @@ let point_view = struct_view point_tag point_fields
 //noextract
 //inline_for_extraction
 let point_pcm = struct_pcm point_tag point_fields
+*)
 
 [@@c_typedef]
-//noextract
-//inline_for_extraction
+noextract inline_for_extraction
 let c_point: typedef = typedef_struct point_tag point_fields
 
 let _ = normalize (mk_c_struct point_tag point_fields)
 
+noextract inline_for_extraction
+let line_fields_second_half: struct_fields =
+  fields_cons "second" c_point fields_nil
+
+noextract inline_for_extraction
+let line_tag = normalize (mk_string_t "line")
+
+let _ = normalize (mk_c_struct line_tag (fields_cons "first" c_point line_fields_second_half))
+
 #push-options "--fuel 0"
 
 (*
@@ -74,6 +81,7 @@ let x_conn
 
 open Steel.C.Reference
 
+(*
 val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
@@ -97,6 +105,7 @@ let swap #a p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
+  *)
 
 (*
 ref 'a (struct tag fields)
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 9b18c652722..25ddd7b0a2c 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -283,7 +283,7 @@ let is_op op =
 let is_machine_int m =
   mk_width m <> None
 
-(* TODO: in stdlib somewhere? *)
+(* JL: TODO: in stdlib somewhere? *)
 let opt_bind (m: option<'a>) (k: 'a -> option<'b>): option<'b> =
   match m with Some x -> k x | None -> None
 
@@ -291,11 +291,8 @@ let char_of_typechar (t: mlty): option<char> =
   match t with
   | MLTY_Named ([], p) ->
     let p = Syntax.string_of_mlpath p in
-    let n = FStar.String.strlen "Typestring.c" in
-    if FStar.String.strlen p > n &&
-       FStar.String.substring p 0 n = "Typestring.c"
-    then
-      Some (FStar.String.get p n)
+    if BU.starts_with p "Typestring.c" then
+      Some (FStar.String.get p (FStar.String.strlen "Typestring.c"))
     else
       None
 
@@ -575,15 +572,11 @@ and translate_type_decl env ty: option<decl> =
     None
   else
     match ty with
-    | {tydecl_assumed=assumed;
-       tydecl_name=name;
-       tydecl_parameters=args;
-       tydecl_meta=flags;
-       tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
-      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_c_struct"
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
       ->
       begin
-        (* TODO remove/improve these print commands *)
+        (* JL: TODO remove/improve these print commands *)
         print_endline "Parsing struct definition.";
         begin match string_of_typestring tag with
         | None ->
@@ -616,12 +609,19 @@ and translate_type_decl env ty: option<decl> =
               BU.print1 "Got struct %s with following fields:\n" tag;
               List.fold_left
                 (fun () (field, ty) ->
-                   BU.print2 "  %s : %s"
+                   BU.print2 "  %s : %s\n"
                      field
                      (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty))
                 ()
                 fields;
-              None // TODO return DTypeFlat(..)
+              // JL: TODO env.module_name or (fst p)?
+              Some (DTypeFlat ((env.module_name, tag), [], 0,
+                List.map
+                  (fun (field, ty) ->
+                     BU.print1 "Translating %s.\n"
+                       (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
+                     (field, (translate_type env ty, true)))
+                  fields))
         end
       end
 
@@ -690,11 +690,16 @@ and translate_type env t: typ =
   | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
       TUnit
 
-(* TODO
+  | MLTY_Named ([tag; _; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
+    ->
+      TQualified (env.module_name, must (string_of_typestring tag))
+      // JL: TODO env.module_name or (fst p)?
+
   | MLTY_Named ([_; arg; _; _], p) when
     Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
     ->
-      TBuf (translate_type env arg) *)
+      TBuf (translate_type env arg)
 
   | MLTY_Named ([_; arg; _], p) when
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||

From a95e4227b063489f373603b7249ae1d923f8c0ba Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 08:29:00 -0700
Subject: [PATCH 187/513] Extraction of read, write, addr_of, unaddr_of

---
 examples/steel/arraystructs/PointStruct.fst   | 38 +++++++++----------
 .../arraystructs/Steel.C.StructLiteral.fsti   |  1 +
 src/extraction/FStar.Extraction.Kremlin.fs    | 26 +++++++++++++
 3 files changed, 44 insertions(+), 21 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index f8cda2b4e50..e4a3cba1afc 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -15,13 +15,17 @@ open FStar.FSet
 open Typestring
 //open Steel.C.Reference
 
+module U32 = FStar.UInt32
+
+unfold let int' = int // U32.t
+
 [@@c_typedef]
 noextract inline_for_extraction
-let c_int: typedef = {
-  carrier = option int;
-  pcm = opt_pcm #int;
-  view_type = int;
-  view = opt_view int;
+let c_int': typedef = {
+  carrier = option int';
+  pcm = opt_pcm #int';
+  view_type = int';
+  view = opt_view int';
 }
 
 module T = FStar.Tactics
@@ -34,24 +38,18 @@ let point_tag = normalize (mk_string_t "point")
 [@@c_struct]
 noextract inline_for_extraction
 let point_fields: struct_fields =
-  fields_cons "x" c_int (
-  fields_cons "y" c_int (
+  fields_cons "x" c_int' (
+  fields_cons "y" c_int' (
   fields_nil))
 
 noextract inline_for_extraction
 let point = struct point_tag point_fields
 
-(*
-//noextract
-//inline_for_extraction
+noextract inline_for_extraction
 let point_view = struct_view point_tag point_fields
 
-//let point = struct_pcm_carrier point_tag point_fields
-
-//noextract
-//inline_for_extraction
+noextract inline_for_extraction
 let point_pcm = struct_pcm point_tag point_fields
-*)
 
 [@@c_typedef]
 noextract inline_for_extraction
@@ -81,8 +79,7 @@ let x_conn
 
 open Steel.C.Reference
 
-(*
-val swap (p: ref 'a point point_pcm)
+val swap (p: ref (*'a*) unit point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
@@ -94,9 +91,9 @@ val swap (p: ref 'a point point_pcm)
       //== h (p `pts_to_view` point_view emptyset) `struct_get` "x")
       True)
 
-let swap #a p =
-  let q: ref _ int _ = addr_of_struct_field "x" p in
-  let r: ref _ int _ = addr_of_struct_field "y" p in
+let swap (*#a*) p =
+  let q: ref _ int' _ = addr_of_struct_field "x" p in
+  let r: ref _ int' _ = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
   q `opt_write_sel` y;
@@ -105,7 +102,6 @@ let swap #a p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
-  *)
 
 (*
 ref 'a (struct tag fields)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index c4f595f659b..bed7fdb48ed 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -201,6 +201,7 @@ let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fi
 
 val struct' (tag: Type0) (fields: struct_fields) (excluded: set string): Type0
 
+inline_for_extraction
 let struct (tag: Type0) (fields: struct_fields) = struct' tag fields emptyset
 
 val mk_nil (tag: Type0): struct tag fields_nil
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 25ddd7b0a2c..a03dc042dab 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1127,6 +1127,32 @@ and translate_expr env e: expr =
       else
         EApp (EQualified ([ "FStar"; "Int"; "Cast" ], c), [ translate_expr env arg ])
 
+  (* Operations on Steel.C.Reference.ref *)
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
+    when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->
+      ESequence []
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; struct_name])},
+             [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
+    when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field" ->
+      let struct_name = must (string_of_typestring struct_name) in
+      EAddrOf (EField (
+        TQualified (env.module_name, struct_name), // JL: TODO env.module_name or (fst p)?
+        EBufRead (translate_expr env r, EConstant (CInt, "0")), // JL: TODO what width is best?
+        field_name))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+    when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
+      EBufRead (translate_expr env r, EConstant (CInt, "0")) // JL: TODO what width is best?
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; x])
+    when string_of_mlpath p = "Steel.C.Opt.opt_write_sel" ->
+      EAssign (
+        EBufRead (translate_expr env r, EConstant (CInt, "0")),
+        translate_expr env x)
+      // JL: TODO what width is best?
+      // JL: TODO alternatively, EBufWrite (<<r>>, 0, <<x>>)
+
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)
 

From 214c5b454f30d7d06073a96b64fd704c0f63f092 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 09:37:01 -0700
Subject: [PATCH 188/513] Fix EBufRead offset; impl extraction for
 Steel.Effect.Atomic.return

---
 examples/steel/arraystructs/PointStruct.fst |  2 +-
 src/extraction/FStar.Extraction.Kremlin.fs  | 21 +++++++++++++++------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index e4a3cba1afc..fc9026c9712 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -17,7 +17,7 @@ open Typestring
 
 module U32 = FStar.UInt32
 
-unfold let int' = int // U32.t
+unfold let int' = FStar.UInt32.t
 
 [@@c_typedef]
 noextract inline_for_extraction
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index a03dc042dab..0cbd46d92f8 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1126,11 +1126,16 @@ and translate_expr env e: expr =
         ECast (translate_expr env arg, TInt Int8)
       else
         EApp (EQualified ([ "FStar"; "Int"; "Cast" ], c), [ translate_expr env arg ])
+        
+  (* Misc. Steel operations *)
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
+    when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
+    translate_expr env e
 
   (* Operations on Steel.C.Reference.ref *)
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
     when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->
-      ESequence []
+      EUnit
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; struct_name])},
              [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
@@ -1138,20 +1143,24 @@ and translate_expr env e: expr =
       let struct_name = must (string_of_typestring struct_name) in
       EAddrOf (EField (
         TQualified (env.module_name, struct_name), // JL: TODO env.module_name or (fst p)?
-        EBufRead (translate_expr env r, EConstant (CInt, "0")), // JL: TODO what width is best?
+        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
     when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
-      EBufRead (translate_expr env r, EConstant (CInt, "0")) // JL: TODO what width is best?
+      EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; x])
     when string_of_mlpath p = "Steel.C.Opt.opt_write_sel" ->
       EAssign (
-        EBufRead (translate_expr env r, EConstant (CInt, "0")),
+        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
-      // JL: TODO what width is best?
-      // JL: TODO alternatively, EBufWrite (<<r>>, 0, <<x>>)
+      (* JL: this doesn't seem to typecheck
+           EBufWrite (
+             translate_expr env r,
+             EConstant (UInt32, "0"),
+             translate_expr env x) *)
+      
 
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)

From 5f73748c800ff0533b98400d20c61f4a0a44b0dd Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 10:00:12 -0700
Subject: [PATCH 189/513] Add generic swap test

---
 examples/steel/arraystructs/PointStruct.fst | 43 ++++++++++++++++++++-
 1 file changed, 41 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index fc9026c9712..153e72b0259 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -79,7 +79,7 @@ let x_conn
 
 open Steel.C.Reference
 
-val swap (p: ref (*'a*) unit point point_pcm)
+val swap (p: ref unit point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
@@ -91,7 +91,7 @@ val swap (p: ref (*'a*) unit point point_pcm)
       //== h (p `pts_to_view` point_view emptyset) `struct_get` "x")
       True)
 
-let swap (*#a*) p =
+let swap p =
   let q: ref _ int' _ = addr_of_struct_field "x" p in
   let r: ref _ int' _ = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
@@ -103,6 +103,45 @@ let swap (*#a*) p =
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
 
+let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
+: Steel unit
+  ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
+  (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
+  (requires (fun _ -> True))
+  (ensures (fun h _ h' ->
+    h' (p `pts_to_view` opt_view _) == h (q `pts_to_view` opt_view _) /\
+    h' (q `pts_to_view` opt_view _) == h (p `pts_to_view` opt_view _)
+  ))
+= (* A tmp = *p; *)
+  let tmp = opt_read_sel p in
+  (* *p = *q; *)
+  let vy = opt_read_sel q in
+  opt_write_sel p vy;
+  (* *q = tmp *)
+  opt_write_sel q tmp;
+  return ()
+
+val swap' (p: ref unit point point_pcm)
+: Steel unit
+    (p `pts_to_view` point_view emptyset)
+    (fun _ -> p `pts_to_view` point_view emptyset)
+    (requires fun _ -> True)
+    (ensures fun h q h' ->
+      //h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
+      //== h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
+      //h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
+      //== h (p `pts_to_view` point_view emptyset) `struct_get` "x")
+      True)
+
+let swap' p =
+  let q: ref _ int' _ = addr_of_struct_field "x" p in
+  let r: ref _ int' _ = addr_of_struct_field "y" p in
+  generic_swap_sel q r;
+  unaddr_of_struct_field "y" p r;
+  unaddr_of_struct_field "x" p q;
+  change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+  return ()
+
 (*
 ref 'a (struct tag fields)
 ref 'a (fields.get_field field).view_type

From bdd0d227954138e5ff1a3dc402502cbc0d58f327 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 12:51:11 -0700
Subject: [PATCH 190/513] Rename struct_fields into c_fields; move to
 Steel.C.Fields

---
 .../steel/arraystructs/Steel.C.Fields.fst     |   7 +
 .../steel/arraystructs/Steel.C.Fields.fsti    |  63 +++++++++
 .../arraystructs/Steel.C.StructLiteral.fst    |  45 +++----
 .../arraystructs/Steel.C.StructLiteral.fsti   | 123 +++++-------------
 4 files changed, 123 insertions(+), 115 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Fields.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Fields.fsti

diff --git a/examples/steel/arraystructs/Steel.C.Fields.fst b/examples/steel/arraystructs/Steel.C.Fields.fst
new file mode 100644
index 00000000000..4277c96292d
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Fields.fst
@@ -0,0 +1,7 @@
+module Steel.C.Fields
+
+let struct_fields_t_nil: Type0 = unit
+let struct_fields_t_cons
+  (field: Type0) (t: Type0) (fields: Type0)
+: Type0
+= unit
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
new file mode 100644
index 00000000000..03dea050d1c
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -0,0 +1,63 @@
+module Steel.C.Fields
+
+open FStar.FSet
+open FStar.FunctionalExtensionality
+
+open Steel.C.Typedef
+open Steel.C.Opt
+
+module TS = Typestring
+
+//[@@__reduce__]
+noeq type c_fields = {
+  //cfields: clist string;
+  cfields: list string;
+  has_field: set string;
+  //has_field_prf: squash (forall field. has_field field == field `mem` cfields);
+  get_field: string ^-> typedef;
+  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
+}
+
+(* Begin for extraction *)
+
+val c_fields_t_nil: Type0
+val c_fields_t_cons
+  (field: Type0) (t: Type0) (fields: Type0)
+: Type0
+
+let c_fields_t (fields: c_fields) =
+  List.Tot.fold_right
+    (fun field fields' ->
+      c_fields_t_cons
+        (TS.mk_string_t field)
+        (fields.get_field field).view_type
+        fields')
+    fields.cfields
+    c_fields_t_nil
+
+(* End for extraction *)
+
+let trivial_typedef: typedef = {
+  carrier = option unit;
+  pcm = opt_pcm #unit;
+  view_type = unit;
+  view = opt_view unit;
+}
+
+//[@@__reduce__]
+let fields_nil: c_fields = {
+  cfields = [];
+  has_field = emptyset;
+  //has_field_prf = ();
+  get_field = on_dom _ (fun _ -> trivial_typedef);
+}
+
+//[@@__reduce__]
+let fields_cons (field: string) (td: typedef) (fields: c_fields): c_fields = {
+  cfields = field :: fields.cfields;
+  has_field = insert field fields.has_field;
+  //has_field_prf = ();
+  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
+}
+
+let field_of (fields: c_fields) = field:string{fields.has_field field == true}
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index bd6ad6f0973..0d8e97dd46e 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -11,25 +11,16 @@ open Steel.C.Typedef
 open Steel.C.Ref
 open Steel.C.Connection
 open Steel.C.Opt
+open Steel.C.Fields
 
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
 
-(* Begin for extraction *)
-
-let struct_fields_t_nil: Type0 = unit
-let struct_fields_t_cons
-  (field: Type0) (t: Type0) (fields: Type0)
-: Type0
-= unit
-
 let mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0 = unit
 
-(* End for extraction *)
-
 let struct_dom (excluded: set string) = refine string (notin excluded)
 
-let struct_cod (fields: struct_fields) (excluded: set string) (field: struct_dom excluded) =
+let struct_cod (fields: c_fields) (excluded: set string) (field: struct_dom excluded) =
   (fields.get_field field).view_type
 
 let struct' tag fields excluded =
@@ -42,13 +33,13 @@ let mk_cons tag fields field td x v =
     if field = field' then x
     else v field' <: ((fields_cons field td fields).get_field field').view_type)
 
-let struct_pcm_carrier_cod (fields: struct_fields) (field: string) =
+let struct_pcm_carrier_cod (fields: c_fields) (field: string) =
   (fields.get_field field).carrier
 
 let struct_pcm_carrier tag fields =
   restricted_t string (struct_pcm_carrier_cod fields)
   
-let struct_pcms (fields: struct_fields) (field: string)
+let struct_pcms (fields: c_fields) (field: string)
 : pcm (struct_pcm_carrier_cod fields field)
 = (fields.get_field field).pcm
 
@@ -90,18 +81,18 @@ let struct_pcm_put_put_ne x field1 v field2 w =
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-let struct_view_to_view_prop (tag: string) (fields: struct_fields) (excluded: set string)
+let struct_view_to_view_prop (tag: Type0) (fields: c_fields) (excluded: set string)
 : struct_pcm_carrier tag fields -> prop
 = fun x -> forall (field: struct_dom excluded).
   (fields.get_field field).view.to_view_prop (x field) /\
   (fields.has_field field == false ==> x field =!= one (fields.get_field field).pcm)
 
-let struct_view_to_view (tag: string) (fields: struct_fields) (excluded: set string)
+let struct_view_to_view (tag: Type0) (fields: c_fields) (excluded: set string)
 : refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded) -> 
   struct' tag fields excluded
 = fun x -> on_dom (struct_dom excluded) (fun field -> (fields.get_field field).view.to_view (x field))
 
-let struct_view_to_carrier (tag: string) (fields: struct_fields) (excluded: set string)
+let struct_view_to_carrier (tag: Type0) (fields: c_fields) (excluded: set string)
 : struct' tag fields excluded ->
   refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded)
 = fun x ->
@@ -129,13 +120,13 @@ let arbitrary_unexcluded_witness (excluded: list string)
 let arbitrary_unexcluded (excluded: set string): GTot (struct_dom excluded) =
   arbitrary_unexcluded_witness (set_as_list excluded)
 
-let struct_view_to_carrier_not_one (tag: string) (fields: struct_fields) (excluded: set string)
+let struct_view_to_carrier_not_one (tag: Type0) (fields: c_fields) (excluded: set string)
 : Lemma 
     (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
      ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
 = (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one
 
-let struct_view_to_view_frame (tag: string) (fields: struct_fields) (excluded: set string)
+let struct_view_to_view_frame (tag: Type0) (fields: c_fields) (excluded: set string)
 : (x: struct' tag fields excluded) ->
   (frame: struct_pcm_carrier tag fields) ->
   Lemma
@@ -172,13 +163,13 @@ let struct_view tag fields excluded = {
 let struct_field tag fields field = struct_field (struct_pcms fields) field
 
 let struct'_without_field
-  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (tag: Type0) (fields: c_fields) (excluded: set string) (field: string)
   (v: struct' tag fields excluded)
 : struct' tag fields (insert field excluded)
 = on_dom (struct_dom (insert field excluded)) v
 
 let struct_without_field_to_carrier
-  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (tag: Type0) (fields: c_fields) (excluded: set string) (field: string)
   (s: struct_pcm_carrier tag fields)
   (v: struct' tag fields excluded)
 : Lemma
@@ -193,7 +184,7 @@ let struct_without_field_to_carrier
          (struct'_without_field tag fields excluded field v))
 
 let extract_field
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
@@ -202,20 +193,20 @@ let extract_field
 = (struct'_without_field tag fields excluded field v, v field)
 
 let extract_field_extracted
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 = ()
 
 let extract_field_unextracted
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (field': field_of fields)
   (v: struct' tag fields excluded)
 = ()
 
 val addr_of_struct_field_ref'
-  (#tag: string) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
 : Steel (ref 'a (fields.get_field field).pcm)
@@ -256,7 +247,7 @@ let addr_of_struct_field_ref #a #tag #fields #excluded field p =
   addr_of_struct_field_ref' field p
 
 let struct'_with_field
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: string) (w: (fields.get_field field).view_type)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (remove field excluded))
@@ -266,7 +257,7 @@ let struct'_with_field
     (fun field' -> if field = field' then w else v field')
 
 let struct_with_field_to_carrier'
-  (tag: string) (fields: struct_fields) (excluded: set string) (field: string)
+  (tag: Type0) (fields: c_fields) (excluded: set string) (field: string)
   (s: struct_pcm_carrier tag fields)
   (t: (fields.get_field field).carrier)
   (v: struct' tag fields excluded)
@@ -284,7 +275,7 @@ let struct_with_field_to_carrier'
            (struct'_with_field tag fields excluded field w v))
 
 let extract_field_with_field
-  (tag: string) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
   (w: (fields.get_field field).view_type)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index bed7fdb48ed..6dcf702b994 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -11,6 +11,7 @@ open Steel.C.Typedef
 open Steel.C.Ref
 open Steel.C.Connection
 open Steel.C.Opt
+open Steel.C.Fields
 
 open FStar.List.Tot
 open FStar.FunctionalExtensionality
@@ -142,85 +143,31 @@ let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
 
 (**** END MOVE TO ChurchList *)
 
-//[@@__reduce__]
-noeq type struct_fields = {
-  //cfields: clist string;
-  cfields: list string;
-  has_field: set string;
-  //has_field_prf: squash (forall field. has_field field == field `mem` cfields);
-  get_field: string ^-> typedef;
-  // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
-}
-
-(* Begin for extraction *)
-
-val struct_fields_t_nil: Type0
-val struct_fields_t_cons
-  (field: Type0) (t: Type0) (fields: Type0)
-: Type0
-
-let struct_fields_t (fields: struct_fields) =
-  List.Tot.fold_right
-    (fun field fields' ->
-      struct_fields_t_cons
-        (TS.mk_string_t field)
-        (fields.get_field field).view_type
-        fields')
-    fields.cfields
-    struct_fields_t_nil
-
 val mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0
 
-let mk_c_struct (tag: Type0) (fields: struct_fields) =
-  mk_struct_def tag (struct_fields_t fields)
-
-(* End for extraction *)
-
-let trivial_typedef: typedef = {
-  carrier = option unit;
-  pcm = opt_pcm #unit;
-  view_type = unit;
-  view = opt_view unit;
-}
-
-//[@@__reduce__]
-let fields_nil: struct_fields = {
-  cfields = [];
-  has_field = emptyset;
-  //has_field_prf = ();
-  get_field = on_dom _ (fun _ -> trivial_typedef);
-}
+let mk_c_struct (tag: Type0) (fields: c_fields) =
+  mk_struct_def tag (c_fields_t fields)
 
-//[@@__reduce__]
-let fields_cons (field: string) (td: typedef) (fields: struct_fields): struct_fields = {
-  cfields = field :: fields.cfields;
-  has_field = insert field fields.has_field;
-  //has_field_prf = ();
-  get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
-}
-
-val struct' (tag: Type0) (fields: struct_fields) (excluded: set string): Type0
+val struct' (tag: Type0) (fields: c_fields) (excluded: set string): Type0
 
 inline_for_extraction
-let struct (tag: Type0) (fields: struct_fields) = struct' tag fields emptyset
+let struct (tag: Type0) (fields: c_fields) = struct' tag fields emptyset
 
 val mk_nil (tag: Type0): struct tag fields_nil
 
-val mk_cons (tag: Type0) (fields: struct_fields)
+val mk_cons (tag: Type0) (fields: c_fields)
   (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
 : Pure (struct tag (fields_cons field td fields))
     (requires fields.has_field field == false)
     (ensures fun _ -> True)
 
-val struct_pcm_carrier (tag: Type0) (fields: struct_fields): Type0
-
-val struct_pcm (tag: Type0) (fields: struct_fields): pcm (struct_pcm_carrier tag fields)
+val struct_pcm_carrier (tag: Type0) (fields: c_fields): Type0
 
-let field_of (fields: struct_fields) = field:string{fields.has_field field == true}
+val struct_pcm (tag: Type0) (fields: c_fields): pcm (struct_pcm_carrier tag fields)
 
 /// Reading a struct field
 val struct_get
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (x: struct' tag fields excluded) (field: field_of fields)
 : Pure (fields.get_field field).view_type
     (requires excluded field == false)
@@ -228,7 +175,7 @@ val struct_get
 
 /// Writing a struct field
 val struct_put
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
@@ -239,7 +186,7 @@ val struct_put
 /// For a fixed field name, struct_get and struct_put form a lens
 
 val struct_get_put 
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
@@ -249,7 +196,7 @@ val struct_get_put
   [SMTPat (struct_put x field v `struct_get` field)]
 
 val struct_put_get
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field: field_of fields)
 : Lemma
@@ -258,7 +205,7 @@ val struct_put_get
   [SMTPat (struct_put x field (x `struct_get` field))]
 
 val struct_put_put
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct tag fields)
   (field: field_of fields)
   (v w: (fields.get_field field).view_type)
@@ -268,7 +215,7 @@ val struct_put_put
 /// struct_get/struct_put pairs for different fields don't interfere with each other
 
 val struct_get_put_ne
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field1: field_of fields)
   (field2: field_of fields)
@@ -279,7 +226,7 @@ val struct_get_put_ne
   [SMTPat (struct_put x field1 v `struct_get` field2)]
   
 val struct_put_put_ne
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (x: struct' tag fields excluded)
   (field1: field_of fields)
   (v: (fields.get_field field1).view_type)
@@ -291,19 +238,19 @@ val struct_put_put_ne
       struct_put (struct_put x field1 v) field2 w ==
       struct_put (struct_put x field2 w) field1 v)
 
-let struct_pcm_one (tag: Type0) (fields: struct_fields)
+let struct_pcm_one (tag: Type0) (fields: c_fields)
 : struct_pcm_carrier tag fields
 = one (struct_pcm tag fields)
 
 /// Reading a pcm_struct_carrier field
 val struct_pcm_get
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields) (field: field_of fields)
 : (fields.get_field field).carrier
 
 /// Writing a struct_pcm_carrier field
 val struct_pcm_put
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
   (v: (fields.get_field field).carrier)
@@ -312,7 +259,7 @@ val struct_pcm_put
 /// For a fixed field name, struct_pcm_get and struct_pcm_put form a lens
 
 val struct_pcm_get_put 
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
   (v: (fields.get_field field).carrier)
@@ -320,14 +267,14 @@ val struct_pcm_get_put
   [SMTPat (struct_pcm_put x field v `struct_pcm_get` field)]
 
 val struct_pcm_put_get
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
 : Lemma (struct_pcm_put x field (x `struct_pcm_get` field) == x)
   [SMTPat (struct_pcm_put x field (x `struct_pcm_get` field))]
 
 val struct_pcm_put_put
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields)
   (field: field_of fields)
   (v w: (fields.get_field field).carrier)
@@ -337,7 +284,7 @@ val struct_pcm_put_put
 /// struct_pcm_get/struct_pcm_put pairs for different fields don't interfere with each other
 
 val struct_pcm_get_put_ne
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields)
   (field1: field_of fields)
   (field2: field_of fields)
@@ -348,7 +295,7 @@ val struct_pcm_get_put_ne
   [SMTPat (struct_pcm_put x field1 v `struct_pcm_get` field2)]
   
 val struct_pcm_put_put_ne
-  (#tag: Type0) (#fields: struct_fields)
+  (#tag: Type0) (#fields: c_fields)
   (x: struct_pcm_carrier tag fields)
   (field1: field_of fields)
   (v: (fields.get_field field1).carrier)
@@ -360,15 +307,15 @@ val struct_pcm_put_put_ne
       struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
       struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-val struct_view (tag: Type0) (fields: struct_fields) (excluded: set string)
+val struct_view (tag: Type0) (fields: c_fields) (excluded: set string)
 : sel_view (struct_pcm tag fields) (struct' tag fields excluded) false
 
 val struct_field
-  (tag: Type0) (fields: struct_fields) (field: field_of fields)
+  (tag: Type0) (fields: c_fields) (field: field_of fields)
 : connection (struct_pcm tag fields) (fields.get_field field).pcm
 
 val extract_field
-  (tag: Type0) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
@@ -376,7 +323,7 @@ val extract_field
     (ensures fun _ -> True)
     
 val extract_field_extracted
-  (tag: Type0) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Lemma
@@ -385,7 +332,7 @@ val extract_field_extracted
     [SMTPat (extract_field tag fields excluded field v)]
 
 val extract_field_unextracted
-  (tag: Type0) (fields: struct_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: set string)
   (field: field_of fields)
   (field': field_of fields)
   (v: struct' tag fields excluded)
@@ -408,7 +355,7 @@ unfold let simplify_typedefs =
    delta_only
     [`%fields_cons;
      `%fields_nil;
-     `%Mkstruct_fields?.get_field;
+     `%Mkc_fields?.get_field;
      `%Mktypedef?.carrier;
      `%Mktypedef?.pcm;
      `%Mktypedef?.view_type;
@@ -416,7 +363,7 @@ unfold let simplify_typedefs =
    iota; zeta; primops]
 
 val addr_of_struct_field_ref
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
 : Steel (ref 'a (fields.get_field field).pcm)
@@ -442,7 +389,7 @@ val addr_of_struct_field_ref
          h' (q `pts_to_view` (fields.get_field field).view)))
 
 val unaddr_of_struct_field_ref'
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
   (q: ref 'a (fields.get_field field).pcm)
@@ -462,7 +409,7 @@ val unaddr_of_struct_field_ref'
          h (q `pts_to_view` (fields.get_field field).view)))
 
 val unaddr_of_struct_field_ref
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
   (q: ref 'a (fields.get_field field).pcm)
@@ -491,7 +438,7 @@ val unaddr_of_struct_field_ref
 open Steel.C.Reference
 
 let addr_of_struct_field
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
 : Steel (ref 'a
@@ -522,7 +469,7 @@ let addr_of_struct_field
   addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 let unaddr_of_struct_field
-  (#tag: Type0) (#fields: struct_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
   (q: ref 'a
@@ -554,7 +501,7 @@ let unaddr_of_struct_field
   unaddr_of_struct_field_ref' field p q
 
 [@@c_typedef]
-let typedef_struct (tag: Type0) (fields: struct_fields): typedef = {
+let typedef_struct (tag: Type0) (fields: c_fields): typedef = {
   carrier = struct_pcm_carrier tag fields;
   pcm = struct_pcm tag fields;
   view_type = struct tag fields;

From 1138a5e82aa5e66e01b603f181e2820a25c20a6c Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 12:56:59 -0700
Subject: [PATCH 191/513] Move unfolding hints to Steel.C.Fields

---
 .../steel/arraystructs/Steel.C.Fields.fsti     | 18 ++++++++++++++++++
 .../arraystructs/Steel.C.StructLiteral.fsti    | 18 ------------------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 03dea050d1c..098a3d98d5c 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -61,3 +61,21 @@ let fields_cons (field: string) (td: typedef) (fields: c_fields): c_fields = {
 }
 
 let field_of (fields: c_fields) = field:string{fields.has_field field == true}
+
+irreducible let c_struct = ()
+irreducible let c_union = ()
+irreducible let c_typedef = ()
+
+unfold let unfold_typedefs = [delta_attr [`%c_typedef]]
+
+unfold let simplify_typedefs =
+  [delta_attr [`%c_struct; `%c_union];
+   delta_only
+    [`%fields_cons;
+     `%fields_nil;
+     `%Mkc_fields?.get_field;
+     `%Mktypedef?.carrier;
+     `%Mktypedef?.pcm;
+     `%Mktypedef?.view_type;
+     `%Mktypedef?.view];
+   iota; zeta; primops]
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 6dcf702b994..c0a287c329c 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -344,24 +344,6 @@ val extract_field_unextracted
     [SMTPat (extract_field tag fields excluded field v);
      SMTPat (has_type field' string)]
 
-irreducible let c_struct = 0
-
-irreducible let c_typedef = 0
-
-unfold let unfold_typedefs = [delta_attr [`%c_typedef]]
-
-unfold let simplify_typedefs =
-  [delta_attr [`%c_struct];
-   delta_only
-    [`%fields_cons;
-     `%fields_nil;
-     `%Mkc_fields?.get_field;
-     `%Mktypedef?.carrier;
-     `%Mktypedef?.pcm;
-     `%Mktypedef?.view_type;
-     `%Mktypedef?.view];
-   iota; zeta; primops]
-
 val addr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: set string)
   (field: field_of fields)

From 8ccbb4b69067f55b186591502952a825b2e30414 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 12:57:14 -0700
Subject: [PATCH 192/513] Sketch Steel.C.UnionLiteral.fst

---
 .../arraystructs/Steel.C.UnionLiteral.fst     | 139 ++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 examples/steel/arraystructs/Steel.C.UnionLiteral.fst

diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
new file mode 100644
index 00000000000..fddd7c292a9
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -0,0 +1,139 @@
+module Steel.C.UnionLiteral
+
+open Steel.Memory
+open Steel.Effect
+open Steel.Effect.Common
+open Steel.Effect.Atomic
+
+open Steel.C.PCM
+open Steel.C.Union
+open Steel.C.Typedef
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.C.Opt
+open Steel.C.Fields
+
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+open FStar.FSet
+
+module TS = Typestring
+
+assume val mk_union_def (tag: Type0) (field_descriptions: Type0): Type0
+
+(* let mk_union_def (tag: Type0) (field_descriptions: Type0): Type0 = unit *)
+
+let mk_c_union (tag: Type0) (fields: c_fields) =
+  mk_union_def tag (c_fields_t fields)
+
+assume val union (tag: Type0) (fields: c_fields): Type0
+
+assume val mk_union (tag: Type0) (fields: c_fields)
+  (field: string) (x: (fields.get_field field).view_type)
+: Pure (union tag fields)
+    (requires fields.has_field field == true)
+    (ensures fun _ -> True)
+
+assume val union_pcm_carrier (tag: Type0) (fields: c_fields): Type0
+
+assume val union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields)
+
+let union_views (fields: c_fields) (field: field_of fields): Type0 =
+  (fields.get_field field).view_type
+
+assume val union_view (tag: Type0) (fields: c_fields)
+: sel_view (union_pcm tag fields) (union tag fields) false
+
+assume val dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
+: dtuple2 (field_of fields) (union_views fields)
+
+assume val union_of_dtuple2 (#tag: Type0) (#fields: c_fields) 
+  (x: dtuple2 (field_of fields) (union_views fields))
+: union tag fields
+
+assume val dtuple2_of_union_of_dtuple2 
+  (#tag: Type0) (#fields: c_fields)
+  (x: dtuple2 (field_of fields) (union_views fields))
+: Lemma (dtuple2_of_union (union_of_dtuple2 #tag #fields x) == x)
+
+assume val union_of_dtuple2_of_union
+  (#tag: Type0) (#fields: c_fields)
+  (x: union tag fields)
+: Lemma (union_of_dtuple2 (dtuple2_of_union #tag #fields x) == x)
+
+(* TOOD The two are mutually inverse *)
+
+assume val union_field
+  (tag: Type0) (fields: c_fields) (field: field_of fields)
+: connection (union_pcm tag fields) (fields.get_field field).pcm
+
+open Steel.C.Reference
+
+assume val addr_of_union_field
+  (#tag: Type0) (#fields: c_fields)
+  (field: field_of fields)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel (ref 'a
+          (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+          (fields.get_field field).pcm)
+    (p `pts_to_view` union_view tag fields)
+    (fun q ->
+      pts_to_view u#0
+                  #'a
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  q
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+    (requires fun h ->
+       dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field)
+    (ensures fun h q h' -> 
+      q == ref_focus p (union_field tag fields field) /\
+      dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field /\
+      dsnd (dtuple2_of_union (h (p `pts_to_view` union_view tag fields)))
+        ==
+        h' (q `pts_to_view` (fields.get_field field).view))
+
+assume val unaddr_of_union_field
+  (#tag: Type0) (#fields: c_fields)
+  (field: field_of fields)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (q: ref 'a (fields.get_field field).view_type (fields.get_field field).pcm)
+: Steel unit
+    (pts_to_view u#0
+                 #'a
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                 q
+                 (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+    (fun q -> p `pts_to_view` union_view tag fields)
+    (requires fun _ -> q == ref_focus p (union_field tag fields field))
+    (ensures fun h _ h' -> 
+      dfst (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields))) == field /\
+      dsnd (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)))
+        ==
+        h (q `pts_to_view` (fields.get_field field).view))
+
+assume val switch_union_field
+  (#tag: Type0) (#fields: c_fields)
+  (field: field_of fields) (v: (fields.get_field field).view_type)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel unit
+    (p `pts_to_view` union_view tag fields)
+    (fun _ -> p `pts_to_view` union_view tag fields)
+    (requires fun h ->
+      let (|field, v|) = dtuple2_of_union (h (p `pts_to_view` union_view tag fields)) in
+      exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
+    (ensures fun _ _ h' ->
+      dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
+
+[@@c_typedef]
+let typedef_union (tag: Type0) (fields: c_fields): typedef = {
+  carrier = union_pcm_carrier tag fields;
+  pcm = union_pcm tag fields;
+  view_type = union tag fields;
+  view = union_view tag fields;
+}

From bcc5dc9858c9ab63f00dd642f53c3d7278d78299 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 13:26:57 -0700
Subject: [PATCH 193/513] Fixup PointStruct.fst

---
 examples/steel/arraystructs/PointStruct.fst | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 153e72b0259..dc424dab6a9 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -9,11 +9,11 @@ open Steel.C.Typedef
 open FStar.FunctionalExtensionality
 open Steel.Effect
 open Steel.Effect.Atomic
-open Steel.C.Ref
+open Steel.C.Fields
+open Steel.C.Reference
 
 open FStar.FSet
 open Typestring
-//open Steel.C.Reference
 
 module U32 = FStar.UInt32
 
@@ -37,7 +37,7 @@ let point_tag = normalize (mk_string_t "point")
 
 [@@c_struct]
 noextract inline_for_extraction
-let point_fields: struct_fields =
+let point_fields: c_fields =
   fields_cons "x" c_int' (
   fields_cons "y" c_int' (
   fields_nil))
@@ -58,7 +58,7 @@ let c_point: typedef = typedef_struct point_tag point_fields
 let _ = normalize (mk_c_struct point_tag point_fields)
 
 noextract inline_for_extraction
-let line_fields_second_half: struct_fields =
+let line_fields_second_half: c_fields =
   fields_cons "second" c_point fields_nil
 
 noextract inline_for_extraction
@@ -147,7 +147,7 @@ ref 'a (struct tag fields)
 ref 'a (fields.get_field field).view_type
 ref 'a view_t ...
 
-struct: s:string -> x:Type{x == y:string{y == s}} -> struct_fields -> Type
+struct: s:string -> x:Type{x == y:string{y == s}} -> c_fields -> Type
 point = s:string{s == point_tag}
 
 [@@c_typedef]

From 0581d257273967762601eedb114078ae5a72fba2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 13:27:05 -0700
Subject: [PATCH 194/513] Add ScalarUnion.fst

---
 examples/steel/arraystructs/ScalarUnion.fst | 289 ++++++++++++++++++++
 1 file changed, 289 insertions(+)
 create mode 100644 examples/steel/arraystructs/ScalarUnion.fst

diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
new file mode 100644
index 00000000000..e14a95f6ff7
--- /dev/null
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -0,0 +1,289 @@
+module ScalarUnion
+
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Connection
+open Steel.C.UnionLiteral
+open Steel.C.Typedef
+open FStar.FunctionalExtensionality
+open Steel.Effect
+open Steel.Effect.Atomic
+open Steel.C.Fields
+open Steel.C.Ref
+open Steel.C.Reference
+
+open FStar.FSet
+open Typestring
+
+module U32 = FStar.UInt32
+module U16 = FStar.UInt16
+
+[@@c_typedef]
+noextract inline_for_extraction
+let u32: typedef = {
+  carrier = option U32.t;
+  pcm = opt_pcm #U32.t;
+  view_type = U32.t;
+  view = opt_view U32.t;
+}
+
+[@@c_typedef]
+noextract inline_for_extraction
+let u16: typedef = {
+  carrier = option U16.t;
+  pcm = opt_pcm #U16.t;
+  view_type = U16.t;
+  view = opt_view U16.t;
+}
+
+module T = FStar.Tactics
+
+noextract inline_for_extraction
+//[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
+//     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
+let u32_or_u16_tag = normalize (mk_string_t "u32_or_u16")
+
+[@@c_struct]
+noextract inline_for_extraction
+let u32_or_u16_fields: c_fields =
+  fields_cons "as_u32" u32 (
+  fields_cons "as_u16" u16 (
+  fields_nil))
+
+noextract inline_for_extraction
+let u32_or_u16 = union u32_or_u16_tag u32_or_u16_fields
+
+noextract inline_for_extraction
+let u32_or_u16_view = union_view u32_or_u16_tag u32_or_u16_fields
+
+noextract inline_for_extraction
+let u32_or_u16_pcm = union_pcm u32_or_u16_tag u32_or_u16_fields
+
+[@@c_typedef]
+noextract inline_for_extraction
+let c_u32_or_u16: typedef = typedef_union u32_or_u16_tag u32_or_u16_fields
+
+let _ = normalize (mk_c_union u32_or_u16_tag u32_or_u16_fields)
+
+#push-options "--fuel 0"
+
+(*
+let x_conn
+: connection u32_or_u16_pcm (opt_pcm #int)
+= struct_field u32_or_u16_tag u32_or_u16_fields "x"
+*)
+
+#push-options "--print_universes --print_implicits"
+// --z3rlimit 30"
+
+val switch_to_u16
+  (p: ref unit u32_or_u16 u32_or_u16_pcm)
+  (x: U16.t)
+: Steel unit
+    (p `pts_to_view` u32_or_u16_view)
+    (fun _ -> p `pts_to_view` u32_or_u16_view)
+    (requires fun _ -> True)
+    (ensures fun h q h' -> True)
+
+#push-options "--fuel 0"
+
+let switch_to_u16 p x =
+  let h = get () in // Needed to prove switch_union_field's precondition
+  switch_union_field "as_u16" x p;
+  return ()
+
+(*
+let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
+: Steel unit
+  ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
+  (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
+  (requires (fun _ -> True))
+  (ensures (fun h _ h' ->
+    h' (p `pts_to_view` opt_view _) == h (q `pts_to_view` opt_view _) /\
+    h' (q `pts_to_view` opt_view _) == h (p `pts_to_view` opt_view _)
+  ))
+= (* A tmp = *p; *)
+  let tmp = opt_read_sel p in
+  (* *p = *q; *)
+  let vy = opt_read_sel q in
+  opt_write_sel p vy;
+  (* *q = tmp *)
+  opt_write_sel q tmp;
+  return ()
+  *)
+
+(*
+val swap' (p: ref unit u32_or_u16 u32_or_u16_pcm)
+: Steel unit
+    (p `pts_to_view` u32_or_u16_view)
+    (fun _ -> p `pts_to_view` u32_or_u16_view)
+    (requires fun _ -> True)
+    (ensures fun h q h' ->
+      //h' (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "x"
+      //== h (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "y" /\
+      //h' (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "y"
+      //== h (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "x")
+      True)
+
+let swap' p =
+  let q: ref _ int' _ = addr_of_struct_field "x" p in
+  let r: ref _ int' _ = addr_of_struct_field "y" p in
+  generic_swap_sel q r;
+  unaddr_of_struct_field "y" p r;
+  unaddr_of_struct_field "x" p q;
+  change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+  return ()
+  *)
+
+(*
+ref 'a (struct tag fields)
+ref 'a (fields.get_field field).view_type
+ref 'a view_t ...
+
+struct: s:string -> x:Type{x == y:string{y == s}} -> c_fields -> Type
+u32_or_u16 = s:string{s == u32_or_u16_tag}
+
+[@@c_typedef]
+s = struct ..
+
+[@@c_struct]
+u32_or_u16_fields = fields_cons "a" s
+
+[@@c_typedef]
+u32_or_u16 = struct u32_or_u16_tag u32_or_u16_fields
+
+mark get_field, view_type, ... c_struct
+
+norm [unfold c_typedef] u32_or_u16
+
+p: ref 'a u32_or_u16  ...
+---> (U32_Or_U16Struct.u32_or_u16, unit) struct
+
+p: ref 'a int ...
+*)
+
+(*
+TO PROVE:
+extract_field v field = (w, x) 
+get v field = x
+get v field' = get w field' for all field' =!= field
+*)
+
+(* struct tag { u32_or_u16_fields ... } *)
+
+(*
+
+struct tag *p ;
+
+int *q = &p->x;
+
+q: ref (struct tag) #int (int_pcm)
+
+EAddrOf (
+  EField (
+    TQualified "Example.t",
+    (EBufRead (<<p>>, 0)),
+    "x"))
+
+
+Read:
+    EBufRead (<<p>>, 0)
+
+Write:
+    EBufWrite (<<e>>, 0, <<e'>>)
+or
+    EAssign (EBufRead (<<e>>, 0), <<e'>>)
+
+addr_of_struct_field "x" (p: ref 'a #(struct_pcm_carrier tag u32_or_u16_fields) (struct_pcm tag u32_or_u16_fields))
+(* &(((struct tag)(*p)).x)
+
+*)
+
+
+
+
+*)
+
+/// make pts_to_view stuff smt_fallback?
+let addr_of_x' #a p excluded =
+  let q = addr_of_struct_field #_ #u32_or_u16_tag #u32_or_u16_fields #excluded "x" p in
+  //change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
+  //change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` u32_or_u16_view (insert "x" excluded));
+  //slassert ((p `pts_to_view` u32_or_u16_view (insert "x" excluded)) `star`
+  //     (q `pts_to_view` opt_view int));
+  change_equal_slprop (q `pts_to_view` _)
+    (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int));
+  change_equal_slprop (p `pts_to_view` _)
+    (pts_to_view #a #u32_or_u16 #u32_or_u16_pcm p
+          #(struct' u32_or_u16_tag u32_or_u16_fields (insert #string "x" excluded)) #false 
+         (u32_or_u16_view (insert "x" excluded)));
+  //slassert ((pts_to_view #a #u32_or_u16 #u32_or_u16_pcm p
+  //        #(struct' u32_or_u16_tag u32_or_u16_fields (insert #string "x" excluded)) #false 
+  //       (u32_or_u16_view (insert "x" excluded))) `star`
+  //     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int)));
+  //sladmit();
+  return q
+
+let u32_or_u16_fields k = match k with
+  | X -> option int
+  | Y -> option int
+let u32_or_u16 = restricted_t u32_or_u16_field u32_or_u16_fields
+
+let u32_or_u16_fields_pcm k : pcm (u32_or_u16_fields k) = match k with
+  | X -> opt_pcm #int
+  | Y -> opt_pcm #int
+let u32_or_u16_pcm = prod_pcm u32_or_u16_fields_pcm
+
+let mk_u32_or_u16_f (x y: option int) (k: u32_or_u16_field): u32_or_u16_fields k = match k with
+  | X -> x
+  | Y -> y
+  
+let mk_u32_or_u16 (x y: option int): u32_or_u16 =
+  on_domain u32_or_u16_field (mk_u32_or_u16_f x y)
+
+let _x = struct_field u32_or_u16_fields_pcm X
+let _y = struct_field u32_or_u16_fields_pcm Y
+
+/// Taking u32_or_u16ers to the x and y fields of a u32_or_u16
+
+let u32_or_u16_without_x x y
+: Lemma (struct_without_field u32_or_u16_fields_pcm X (mk_u32_or_u16 x y) `feq` Ghost.reveal (mk_u32_or_u16 none y))
+  [SMTPat (mk_u32_or_u16 x y)]
+= ()
+
+let u32_or_u16_with_x x y
+: Lemma (struct_with_field u32_or_u16_fields_pcm X x (mk_u32_or_u16 None y) `feq`
+         mk_u32_or_u16 x y)
+  [SMTPat (mk_u32_or_u16 x y)]
+= ()
+
+let u32_or_u16_without_y x y
+: Lemma (struct_without_field u32_or_u16_fields_pcm Y (mk_u32_or_u16 x y) `feq` mk_u32_or_u16 x None)
+  [SMTPat (mk_u32_or_u16 x y)]
+= ()
+
+let u32_or_u16_with_y x y
+: Lemma (struct_with_field u32_or_u16_fields_pcm Y y (mk_u32_or_u16 x None) `feq`
+         mk_u32_or_u16 x y)
+  [SMTPat (mk_u32_or_u16 x y)]
+= ()
+
+let addr_of_x #a #x #y p =
+  let q = addr_of_struct_field p X (mk_u32_or_u16 x y) in
+  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_u32_or_u16 None y);
+  change_equal_slprop (q `pts_to` _) (q `pts_to` x);
+  return q
+  
+let unaddr_of_x #a #x #y p q =
+  unaddr_of_struct_field #_ #_ #_ #u32_or_u16_fields_pcm X q p (mk_u32_or_u16 None y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
+  change_equal_slprop (p `pts_to` _) (p `pts_to` _)
+
+let addr_of_y #a #x #y p =
+  let q = addr_of_struct_field p Y (mk_u32_or_u16 x y) in
+  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_u32_or_u16 x None);
+  change_equal_slprop (q `pts_to` _) (q `pts_to` y);
+  return q
+
+let unaddr_of_y #a #x #y p q =
+  unaddr_of_struct_field #_ #_ #_ #u32_or_u16_fields_pcm Y q p (mk_u32_or_u16 x None) y; // same here
+  change_equal_slprop (p `pts_to` _) (p `pts_to` _)

From a245a152c93c7741e5aa5076e4dca79ea5259513 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 13:33:07 -0700
Subject: [PATCH 195/513] Example taking pointer to case of union

---
 examples/steel/arraystructs/ScalarUnion.fst | 50 ++++++---------------
 1 file changed, 14 insertions(+), 36 deletions(-)

diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index e14a95f6ff7..e07539133f4 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -92,48 +92,26 @@ let switch_to_u16 p x =
   switch_union_field "as_u16" x p;
   return ()
 
-(*
-let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
+let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
 : Steel unit
-  ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
-  (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
-  (requires (fun _ -> True))
-  (ensures (fun h _ h' ->
-    h' (p `pts_to_view` opt_view _) == h (q `pts_to_view` opt_view _) /\
-    h' (q `pts_to_view` opt_view _) == h (p `pts_to_view` opt_view _)
-  ))
-= (* A tmp = *p; *)
-  let tmp = opt_read_sel p in
-  (* *p = *q; *)
-  let vy = opt_read_sel q in
-  opt_write_sel p vy;
-  (* *q = tmp *)
-  opt_write_sel q tmp;
-  return ()
-  *)
+  (p `pts_to_view` opt_view _)
+  (fun _ -> p `pts_to_view` opt_view _)
+  (requires fun _ -> True)
+  (ensures fun _ _ _ -> True)
+= opt_write_sel p U32.zero
 
-(*
-val swap' (p: ref unit u32_or_u16 u32_or_u16_pcm)
+val zero_u32_of_union (p: ref unit u32_or_u16 u32_or_u16_pcm)
 : Steel unit
     (p `pts_to_view` u32_or_u16_view)
     (fun _ -> p `pts_to_view` u32_or_u16_view)
-    (requires fun _ -> True)
-    (ensures fun h q h' ->
-      //h' (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "x"
-      //== h (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "y" /\
-      //h' (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "y"
-      //== h (p `pts_to_view` u32_or_u16_view emptyset) `struct_get` "x")
-      True)
-
-let swap' p =
-  let q: ref _ int' _ = addr_of_struct_field "x" p in
-  let r: ref _ int' _ = addr_of_struct_field "y" p in
-  generic_swap_sel q r;
-  unaddr_of_struct_field "y" p r;
-  unaddr_of_struct_field "x" p q;
-  change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+    (requires fun h -> dfst (dtuple2_of_union (h (p `pts_to_view` u32_or_u16_view))) == "as_u32")
+    (ensures fun h q h' -> True)
+
+let zero_u32_of_union p =
+  let q: ref _ U32.t _ = addr_of_union_field "as_u32" p in
+  zero_u32_ref q;
+  unaddr_of_union_field "as_u32" p q;
   return ()
-  *)
 
 (*
 ref 'a (struct tag fields)

From 76c81f77592d14435e32281717b841e504e06ce3 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 15:09:33 -0700
Subject: [PATCH 196/513] Try define structs with flag indicating whether it's
 not unit

---
 .../steel/arraystructs/Steel.C.Fields.fsti    |  1 +
 .../arraystructs/Steel.C.StructLiteral.fst    | 62 ++++++++++++++--
 .../steel/arraystructs/Steel.C.Typedef.fst    |  1 +
 .../arraystructs/Steel.C.UnionLiteral.fst     | 72 ++++++++++++-------
 4 files changed, 103 insertions(+), 33 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 098a3d98d5c..00f3bdfa212 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -42,6 +42,7 @@ let trivial_typedef: typedef = {
   pcm = opt_pcm #unit;
   view_type = unit;
   view = opt_view unit;
+  is_unit = (fun o -> None? o);
 }
 
 //[@@__reduce__]
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 0d8e97dd46e..6c0059d9595 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -35,15 +35,62 @@ let mk_cons tag fields field td x v =
 
 let struct_pcm_carrier_cod (fields: c_fields) (field: string) =
   (fields.get_field field).carrier
-
-let struct_pcm_carrier tag fields =
-  restricted_t string (struct_pcm_carrier_cod fields)
   
 let struct_pcms (fields: c_fields) (field: string)
 : pcm (struct_pcm_carrier_cod fields field)
 = (fields.get_field field).pcm
 
-let struct_pcm tag fields = prod_pcm (struct_pcms fields)
+let struct_pcm_carrier_snd tag fields
+  (f:restricted_t string (struct_pcm_carrier_cod fields))
+= b:bool{b <==> f =!= one (prod_pcm (struct_pcms fields))}
+
+let struct_pcm_carrier tag fields =
+  dtuple2
+    (restricted_t string (struct_pcm_carrier_cod fields))
+    (struct_pcm_carrier_snd tag fields)
+
+module P = FStar.PCM
+
+let struct_comp tag (fields: c_fields)
+: P.symrel (struct_pcm_carrier tag fields)
+= fun (|x, _|) (|y, _|) -> composable (prod_pcm (struct_pcms fields)) x y
+
+let struct_op tag (fields: c_fields)
+: x:struct_pcm_carrier tag fields ->
+  y:struct_pcm_carrier tag fields{struct_comp tag fields x y} ->
+  struct_pcm_carrier tag fields
+= fun (|x, b|) (|y, c|) ->
+  assert (composable (prod_pcm (struct_pcms fields)) x y);
+  assert (prod_op (struct_pcms fields) x y == one (prod_pcm (struct_pcms fields))
+   ==> x == one (prod_pcm (struct_pcms fields)) /\ y == one (prod_pcm (struct_pcms fields)));
+  (|prod_op (struct_pcms fields) x y, b || c|)
+
+let fstar_struct_pcm tag (fields: c_fields)
+: P.pcm (struct_pcm_carrier tag fields)
+= let open P in {
+  p = {
+    composable = struct_comp tag fields;
+    op = struct_op tag fields;
+    one = (|prod_one (struct_pcms fields), false|);
+  };
+  comm = (fun (|x, _|) (|y, _|) -> prod_comm (struct_pcms fields) x y);
+  assoc = (fun (|x, _|) (|y, _|) (|z, _|) -> prod_assoc (struct_pcms fields) x y z);
+  assoc_r = (fun (|x, _|) (|y, _|) (|z, _|) -> prod_assoc_r (struct_pcms fields) x y z);
+  is_unit = (fun (|x, _|) -> prod_is_unit (struct_pcms fields) x);
+  refine = (fun (|x, _|) -> prod_refine (struct_pcms fields) x);
+}
+
+let struct_pcm' tag fields: pcm0 (struct_pcm_carrier tag fields) =
+  pcm_of_fstar_pcm (fstar_struct_pcm tag fields)
+
+let struct_pcm tag fields =
+  let p' = struct_pcm' tag fields in
+  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
+    dfst x `feq` dfst (one p') /\ dfst y `feq` dfst (one p')
+  ));
+  let p = struct_pcms fields in
+  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
+  struct_pcm' tag fields
 
 let struct_get x field = x field
 let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
@@ -63,8 +110,11 @@ let struct_put_put_ne x field1 v field2 w =
     struct_put (struct_put x field1 v) field2 w `feq`
     struct_put (struct_put x field2 w) field1 v)
 
-let struct_pcm_get x field = x field
-let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
+let struct_pcm_get x field = dfst x field
+
+let struct_pcm_put #tag #fields (|x, b|) field v =
+  (|on_dom _ (fun field' -> if field = field' then v else x field'),
+    if (fields.get_field field).is_unit v then |)
 
 let struct_pcm_get_put x field v = ()
 
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index 9f0e512fd9e..66ad2dfc536 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -14,6 +14,7 @@ noeq type typedef = {
   pcm: pcm carrier; 
   view_type: Type0; 
   view: sel_view pcm view_type false;
+  is_unit: x:carrier -> b:bool{b <==> x == one pcm};
 } 
 
 let register_typedef_of (_: Type0) = typedef
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index fddd7c292a9..3ca323772b4 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -19,53 +19,71 @@ open FStar.FSet
 
 module TS = Typestring
 
-assume val mk_union_def (tag: Type0) (field_descriptions: Type0): Type0
+let mk_union_def (tag: Type0) (field_descriptions: Type0): Type0 = unit
 
-(* let mk_union_def (tag: Type0) (field_descriptions: Type0): Type0 = unit *)
+let union (tag: Type0) (fields: c_fields): Type0 =
+  dtuple2 (field_of fields) (union_views fields)
 
-let mk_c_union (tag: Type0) (fields: c_fields) =
-  mk_union_def tag (c_fields_t fields)
-
-assume val union (tag: Type0) (fields: c_fields): Type0
-
-assume val mk_union (tag: Type0) (fields: c_fields)
+let mk_union (tag: Type0) (fields: c_fields)
   (field: string) (x: (fields.get_field field).view_type)
 : Pure (union tag fields)
     (requires fields.has_field field == true)
     (ensures fun _ -> True)
+= (|field, x|)
+
+let union_carriers (fields: c_fields) (field: field_of fields): Type0 =
+  (fields.get_field field).carrier
 
-assume val union_pcm_carrier (tag: Type0) (fields: c_fields): Type0
+let union_pcms (fields: c_fields) (field: field_of fields): pcm (union_carriers fields field) =
+  (fields.get_field field).pcm
 
-assume val union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields)
+let union_pcm_carrier (tag: Type0) (fields: c_fields): Type0 =
+  Steel.C.Union.union (union_pcms fields)
 
-let union_views (fields: c_fields) (field: field_of fields): Type0 =
-  (fields.get_field field).view_type
+let union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields) =
+  union_pcm (union_pcms fields)
 
-assume val union_view (tag: Type0) (fields: c_fields)
+assume val case_of_union (fields: c_fields)
+  (non_unit_deciders:
+    (field:field_of fields ->
+     x:(fields.get_field field).carrier ->
+     b:bool{x =!= one (fields.get_field field).pcm}))
+  (u: Steel.C.Union.union (union_pcms fields))
+: field:field_of fields{case_refinement_f (union_pcms fields) field u}
+
+let union_views' (fields: c_fields) (field: field_of fields)
+: sel_view (union_pcms fields field) (union_views fields field) false
+= (fields.get_field field).view
+
+let union_view (tag: Type0) (fields: c_fields)
 : sel_view (union_pcm tag fields) (union tag fields) false
+= Steel.C.Union.union_view (union_views' fields) (case_of_union fields (admit()))
 
-assume val dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
+let dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
 : dtuple2 (field_of fields) (union_views fields)
+= x
 
-assume val union_of_dtuple2 (#tag: Type0) (#fields: c_fields) 
+let union_of_dtuple2 (#tag: Type0) (#fields: c_fields) 
   (x: dtuple2 (field_of fields) (union_views fields))
 : union tag fields
+= x
 
-assume val dtuple2_of_union_of_dtuple2 
+let dtuple2_of_union_of_dtuple2 
   (#tag: Type0) (#fields: c_fields)
   (x: dtuple2 (field_of fields) (union_views fields))
 : Lemma (dtuple2_of_union (union_of_dtuple2 #tag #fields x) == x)
+= ()
 
-assume val union_of_dtuple2_of_union
+let union_of_dtuple2_of_union
   (#tag: Type0) (#fields: c_fields)
   (x: union tag fields)
 : Lemma (union_of_dtuple2 (dtuple2_of_union #tag #fields x) == x)
+= ()
 
-(* TOOD The two are mutually inverse *)
-
-assume val union_field
+let union_field
   (tag: Type0) (fields: c_fields) (field: field_of fields)
 : connection (union_pcm tag fields) (fields.get_field field).pcm
+= union_field (union_pcms fields) field
 
 open Steel.C.Reference
 
@@ -87,11 +105,11 @@ assume val addr_of_union_field
                   q
                   (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
     (requires fun h ->
-       dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field)
+       dfst (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))) == field)
     (ensures fun h q h' -> 
       q == ref_focus p (union_field tag fields field) /\
-      dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field /\
-      dsnd (dtuple2_of_union (h (p `pts_to_view` union_view tag fields)))
+      dfst (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))) == field /\
+      dsnd (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields)))
         ==
         h' (q `pts_to_view` (fields.get_field field).view))
 
@@ -112,8 +130,8 @@ assume val unaddr_of_union_field
     (fun q -> p `pts_to_view` union_view tag fields)
     (requires fun _ -> q == ref_focus p (union_field tag fields field))
     (ensures fun h _ h' -> 
-      dfst (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields))) == field /\
-      dsnd (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)))
+      dfst (dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))) == field /\
+      dsnd (dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields)))
         ==
         h (q `pts_to_view` (fields.get_field field).view))
 
@@ -125,10 +143,10 @@ assume val switch_union_field
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
     (requires fun h ->
-      let (|field, v|) = dtuple2_of_union (h (p `pts_to_view` union_view tag fields)) in
+      let (|field, v|) = dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields)) in
       exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
     (ensures fun _ _ h' ->
-      dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
 
 [@@c_typedef]
 let typedef_union (tag: Type0) (fields: c_fields): typedef = {

From b3738c3dfc11479e6bf0f2152e1ca06b6b8712b2 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 15:51:20 -0700
Subject: [PATCH 197/513] Switch from infinite structs to structs with 1 extra
 field (with name '')

---
 .../steel/arraystructs/Steel.C.Fields.fsti    |  36 +++--
 .../arraystructs/Steel.C.StructLiteral.fst    | 145 ++++++++----------
 .../arraystructs/Steel.C.StructLiteral.fsti   |  57 ++++---
 3 files changed, 114 insertions(+), 124 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 00f3bdfa212..2f3900910fd 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -8,14 +8,24 @@ open Steel.C.Opt
 
 module TS = Typestring
 
+let trivial_typedef: typedef = {
+  carrier = option unit;
+  pcm = opt_pcm #unit;
+  view_type = unit;
+  view = opt_view unit;
+  is_unit = (fun o -> None? o);
+}
+
 //[@@__reduce__]
 noeq type c_fields = {
   //cfields: clist string;
   cfields: list string;
   has_field: set string;
-  //has_field_prf: squash (forall field. has_field field == field `mem` cfields);
+  has_field_mt: squash (has_field "" == true);
+  has_field_prf: squash (forall field. has_field field == field `List.Tot.mem` cfields);
   get_field: string ^-> typedef;
   // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
+  get_field_mt: squash (get_field "" == trivial_typedef);
 }
 
 (* Begin for extraction *)
@@ -37,31 +47,29 @@ let c_fields_t (fields: c_fields) =
 
 (* End for extraction *)
 
-let trivial_typedef: typedef = {
-  carrier = option unit;
-  pcm = opt_pcm #unit;
-  view_type = unit;
-  view = opt_view unit;
-  is_unit = (fun o -> None? o);
-}
-
 //[@@__reduce__]
 let fields_nil: c_fields = {
-  cfields = [];
-  has_field = emptyset;
+  cfields = [""];
+  has_field = insert "" emptyset;
+  has_field_mt = ();
+  has_field_prf = ();
   //has_field_prf = ();
   get_field = on_dom _ (fun _ -> trivial_typedef);
+  get_field_mt = ();
 }
 
 //[@@__reduce__]
-let fields_cons (field: string) (td: typedef) (fields: c_fields): c_fields = {
+let fields_cons (field: string{field =!= ""}) (td: typedef) (fields: c_fields): c_fields = {
   cfields = field :: fields.cfields;
   has_field = insert field fields.has_field;
-  //has_field_prf = ();
+  has_field_mt = fields.has_field_mt;
+  has_field_prf = fields.has_field_prf;
   get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
+  get_field_mt = ();
 }
 
-let field_of (fields: c_fields) = field:string{fields.has_field field == true}
+let field_t = field:string{field =!= ""}
+let field_of (fields: c_fields) = field:string{fields.has_field field == true /\ field =!= ""}
 
 irreducible let c_struct = ()
 irreducible let c_union = ()
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 6c0059d9595..8f7e4cc5a37 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -18,79 +18,35 @@ open FStar.FunctionalExtensionality
 
 let mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0 = unit
 
-let struct_dom (excluded: set string) = refine string (notin excluded)
+let field_of' (fields: c_fields) = field:string{fields.has_field field == true}
 
-let struct_cod (fields: c_fields) (excluded: set string) (field: struct_dom excluded) =
+let struct_dom (fields: c_fields) (excluded: excluded_fields) =
+  refine (field_of' fields) (notin excluded)
+
+let struct_cod (fields: c_fields) (excluded: excluded_fields) (field: struct_dom fields excluded) =
   (fields.get_field field).view_type
 
 let struct' tag fields excluded =
-  restricted_t (struct_dom excluded) (struct_cod fields excluded)
+  restricted_t (struct_dom fields excluded) (struct_cod fields excluded)
 
 let mk_nil tag = on_dom _ (fun _ -> ())
 
 let mk_cons tag fields field td x v =
-  on_dom (refine string (notin emptyset)) (fun field' ->
+  on_dom (struct_dom (fields_cons field td fields) emptyset) (fun field' ->
     if field = field' then x
     else v field' <: ((fields_cons field td fields).get_field field').view_type)
 
-let struct_pcm_carrier_cod (fields: c_fields) (field: string) =
+let struct_pcm_carrier_cod (fields: c_fields) (field: field_of' fields) =
   (fields.get_field field).carrier
-  
-let struct_pcms (fields: c_fields) (field: string)
+
+let struct_pcms (fields: c_fields) (field: field_of' fields)
 : pcm (struct_pcm_carrier_cod fields field)
 = (fields.get_field field).pcm
 
-let struct_pcm_carrier_snd tag fields
-  (f:restricted_t string (struct_pcm_carrier_cod fields))
-= b:bool{b <==> f =!= one (prod_pcm (struct_pcms fields))}
-
 let struct_pcm_carrier tag fields =
-  dtuple2
-    (restricted_t string (struct_pcm_carrier_cod fields))
-    (struct_pcm_carrier_snd tag fields)
-
-module P = FStar.PCM
-
-let struct_comp tag (fields: c_fields)
-: P.symrel (struct_pcm_carrier tag fields)
-= fun (|x, _|) (|y, _|) -> composable (prod_pcm (struct_pcms fields)) x y
-
-let struct_op tag (fields: c_fields)
-: x:struct_pcm_carrier tag fields ->
-  y:struct_pcm_carrier tag fields{struct_comp tag fields x y} ->
-  struct_pcm_carrier tag fields
-= fun (|x, b|) (|y, c|) ->
-  assert (composable (prod_pcm (struct_pcms fields)) x y);
-  assert (prod_op (struct_pcms fields) x y == one (prod_pcm (struct_pcms fields))
-   ==> x == one (prod_pcm (struct_pcms fields)) /\ y == one (prod_pcm (struct_pcms fields)));
-  (|prod_op (struct_pcms fields) x y, b || c|)
-
-let fstar_struct_pcm tag (fields: c_fields)
-: P.pcm (struct_pcm_carrier tag fields)
-= let open P in {
-  p = {
-    composable = struct_comp tag fields;
-    op = struct_op tag fields;
-    one = (|prod_one (struct_pcms fields), false|);
-  };
-  comm = (fun (|x, _|) (|y, _|) -> prod_comm (struct_pcms fields) x y);
-  assoc = (fun (|x, _|) (|y, _|) (|z, _|) -> prod_assoc (struct_pcms fields) x y z);
-  assoc_r = (fun (|x, _|) (|y, _|) (|z, _|) -> prod_assoc_r (struct_pcms fields) x y z);
-  is_unit = (fun (|x, _|) -> prod_is_unit (struct_pcms fields) x);
-  refine = (fun (|x, _|) -> prod_refine (struct_pcms fields) x);
-}
+  restricted_t (field_of' fields) (struct_pcm_carrier_cod fields)
 
-let struct_pcm' tag fields: pcm0 (struct_pcm_carrier tag fields) =
-  pcm_of_fstar_pcm (fstar_struct_pcm tag fields)
-
-let struct_pcm tag fields =
-  let p' = struct_pcm' tag fields in
-  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
-    dfst x `feq` dfst (one p') /\ dfst y `feq` dfst (one p')
-  ));
-  let p = struct_pcms fields in
-  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
-  struct_pcm' tag fields
+let struct_pcm tag fields = prod_pcm (struct_pcms fields)
 
 let struct_get x field = x field
 let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
@@ -110,11 +66,8 @@ let struct_put_put_ne x field1 v field2 w =
     struct_put (struct_put x field1 v) field2 w `feq`
     struct_put (struct_put x field2 w) field1 v)
 
-let struct_pcm_get x field = dfst x field
-
-let struct_pcm_put #tag #fields (|x, b|) field v =
-  (|on_dom _ (fun field' -> if field = field' then v else x field'),
-    if (fields.get_field field).is_unit v then |)
+let struct_pcm_get x field = x field
+let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
 
 let struct_pcm_get_put x field v = ()
 
@@ -131,30 +84,32 @@ let struct_pcm_put_put_ne x field1 v field2 w =
      struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
      struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-let struct_view_to_view_prop (tag: Type0) (fields: c_fields) (excluded: set string)
+let struct_view_to_view_prop (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
 : struct_pcm_carrier tag fields -> prop
-= fun x -> forall (field: struct_dom excluded).
+= fun x -> forall (field: struct_dom fields excluded).
   (fields.get_field field).view.to_view_prop (x field) /\
   (fields.has_field field == false ==> x field =!= one (fields.get_field field).pcm)
 
-let struct_view_to_view (tag: Type0) (fields: c_fields) (excluded: set string)
+let struct_view_to_view (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
 : refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded) -> 
   struct' tag fields excluded
-= fun x -> on_dom (struct_dom excluded) (fun field -> (fields.get_field field).view.to_view (x field))
+= fun x -> on_dom (struct_dom fields excluded) (fun field -> (fields.get_field field).view.to_view (x field))
 
-let struct_view_to_carrier (tag: Type0) (fields: c_fields) (excluded: set string)
+let struct_view_to_carrier (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
 : struct' tag fields excluded ->
   refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded)
 = fun x ->
   let y: struct_pcm_carrier tag fields =
-    on_dom _ (fun field ->
+    on_dom (field_of' fields) (fun field ->
       if excluded field then one (fields.get_field field).pcm else
+      if field = "" then Some () else
       (fields.get_field field).view.to_carrier (x field)
       <: (fields.get_field field).carrier)
   in y
 
 module S = FStar.String
 
+(*
 let rec max_len (excluded: list string)
 : Ghost nat True (fun n -> forall s'. memP s' excluded ==> n >= S.strlen s')
 = match excluded with
@@ -162,21 +117,22 @@ let rec max_len (excluded: list string)
   | field :: excluded -> 
     let ih = max_len excluded in
     if S.strlen field > ih then S.strlen field else ih
-
+    
 let arbitrary_unexcluded_witness (excluded: list string)
 : Ghost string True (fun s -> forall s'. memP s' excluded ==> S.strlen s > S.strlen s')
 = S.make (max_len excluded + 1) ' '
 
-let arbitrary_unexcluded (excluded: set string): GTot (struct_dom excluded) =
+let arbitrary_unexcluded (excluded: excluded_fields): GTot (struct_dom fields excluded) =
   arbitrary_unexcluded_witness (set_as_list excluded)
+  *)
 
-let struct_view_to_carrier_not_one (tag: Type0) (fields: c_fields) (excluded: set string)
+let struct_view_to_carrier_not_one (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
 : Lemma 
     (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
      ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
-= (fields.get_field (arbitrary_unexcluded excluded)).view.to_carrier_not_one
+= (fields.get_field "").view.to_carrier_not_one
 
-let struct_view_to_view_frame (tag: Type0) (fields: c_fields) (excluded: set string)
+let struct_view_to_view_frame (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
 : (x: struct' tag fields excluded) ->
   (frame: struct_pcm_carrier tag fields) ->
   Lemma
@@ -189,7 +145,7 @@ let struct_view_to_view_frame (tag: Type0) (fields: c_fields) (excluded: set str
 = fun x frame ->
   let p = struct_pcms fields in
   Classical.forall_intro_2 (fun k -> is_unit (p k));
-  let aux (k:struct_dom excluded)
+  let aux (k:struct_dom fields excluded)
   : Lemma (
       (fields.get_field k).view.to_view_prop
         (op (p k) (struct_view_to_carrier tag fields excluded x k) (frame k)) /\
@@ -210,16 +166,35 @@ let struct_view tag fields excluded = {
   to_view_frame = struct_view_to_view_frame tag fields excluded;
 }
 
+let rec struct_is_unit_aux (tag: Type0) (fields: c_fields)
+  (fields_list: list string)
+  (v: struct_pcm_carrier tag fields)
+: Pure bool
+    (requires forall field. field `mem` fields_list ==> fields.has_field field == true)
+    (ensures fun b -> b <==> (forall (field: string). field `mem` fields_list ==> v field == one (struct_pcm tag fields) field))
+    (decreases fields_list)
+= match fields_list with
+  | [] -> true
+  | field :: fields_list ->
+    (fields.get_field field).is_unit (v field) &&
+    struct_is_unit_aux tag fields fields_list v
+
+let struct_is_unit tag fields v
+: b:bool{b <==> v == one (struct_pcm tag fields)}
+= let b = struct_is_unit_aux tag fields fields.cfields v in
+  assert (b <==> v `feq` one (struct_pcm tag fields));
+  b
+
 let struct_field tag fields field = struct_field (struct_pcms fields) field
 
 let struct'_without_field
-  (tag: Type0) (fields: c_fields) (excluded: set string) (field: string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_t)
   (v: struct' tag fields excluded)
 : struct' tag fields (insert field excluded)
-= on_dom (struct_dom (insert field excluded)) v
+= on_dom (struct_dom fields (insert field excluded)) v
 
 let struct_without_field_to_carrier
-  (tag: Type0) (fields: c_fields) (excluded: set string) (field: string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_of fields)
   (s: struct_pcm_carrier tag fields)
   (v: struct' tag fields excluded)
 : Lemma
@@ -234,7 +209,7 @@ let struct_without_field_to_carrier
          (struct'_without_field tag fields excluded field v))
 
 let extract_field
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
@@ -243,20 +218,20 @@ let extract_field
 = (struct'_without_field tag fields excluded field v, v field)
 
 let extract_field_extracted
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 = ()
 
 let extract_field_unextracted
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (field': field_of fields)
   (v: struct' tag fields excluded)
 = ()
 
 val addr_of_struct_field_ref'
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
 : Steel (ref 'a (fields.get_field field).pcm)
@@ -297,17 +272,17 @@ let addr_of_struct_field_ref #a #tag #fields #excluded field p =
   addr_of_struct_field_ref' field p
 
 let struct'_with_field
-  (tag: Type0) (fields: c_fields) (excluded: set string)
-  (field: string) (w: (fields.get_field field).view_type)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
+  (field: field_of fields) (w: (fields.get_field field).view_type)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (remove field excluded))
     (requires excluded field == true)
     (ensures fun _ -> True)
-= on_dom (struct_dom (remove field excluded))
+= on_dom (struct_dom fields (remove field excluded))
     (fun field' -> if field = field' then w else v field')
 
 let struct_with_field_to_carrier'
-  (tag: Type0) (fields: c_fields) (excluded: set string) (field: string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_of fields)
   (s: struct_pcm_carrier tag fields)
   (t: (fields.get_field field).carrier)
   (v: struct' tag fields excluded)
@@ -325,7 +300,7 @@ let struct_with_field_to_carrier'
            (struct'_with_field tag fields excluded field w v))
 
 let extract_field_with_field
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (v: struct' tag fields excluded)
   (w: (fields.get_field field).view_type)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index c0a287c329c..203f246fe61 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -148,7 +148,9 @@ val mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0
 let mk_c_struct (tag: Type0) (fields: c_fields) =
   mk_struct_def tag (c_fields_t fields)
 
-val struct' (tag: Type0) (fields: c_fields) (excluded: set string): Type0
+let excluded_fields = s:set string{s "" == false}
+
+val struct' (tag: Type0) (fields: c_fields) (excluded: excluded_fields): Type0
 
 inline_for_extraction
 let struct (tag: Type0) (fields: c_fields) = struct' tag fields emptyset
@@ -156,7 +158,7 @@ let struct (tag: Type0) (fields: c_fields) = struct' tag fields emptyset
 val mk_nil (tag: Type0): struct tag fields_nil
 
 val mk_cons (tag: Type0) (fields: c_fields)
-  (field: string) (td: typedef) (x: td.view_type) (v: struct tag fields)
+  (field: field_t) (td: typedef) (x: td.view_type) (v: struct tag fields)
 : Pure (struct tag (fields_cons field td fields))
     (requires fields.has_field field == false)
     (ensures fun _ -> True)
@@ -167,7 +169,7 @@ val struct_pcm (tag: Type0) (fields: c_fields): pcm (struct_pcm_carrier tag fiel
 
 /// Reading a struct field
 val struct_get
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (x: struct' tag fields excluded) (field: field_of fields)
 : Pure (fields.get_field field).view_type
     (requires excluded field == false)
@@ -175,7 +177,7 @@ val struct_get
 
 /// Writing a struct field
 val struct_put
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
@@ -186,7 +188,7 @@ val struct_put
 /// For a fixed field name, struct_get and struct_put form a lens
 
 val struct_get_put 
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (x: struct' tag fields excluded)
   (field: field_of fields)
   (v: (fields.get_field field).view_type)
@@ -196,7 +198,7 @@ val struct_get_put
   [SMTPat (struct_put x field v `struct_get` field)]
 
 val struct_put_get
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (x: struct' tag fields excluded)
   (field: field_of fields)
 : Lemma
@@ -215,7 +217,7 @@ val struct_put_put
 /// struct_get/struct_put pairs for different fields don't interfere with each other
 
 val struct_get_put_ne
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (x: struct' tag fields excluded)
   (field1: field_of fields)
   (field2: field_of fields)
@@ -226,7 +228,7 @@ val struct_get_put_ne
   [SMTPat (struct_put x field1 v `struct_get` field2)]
   
 val struct_put_put_ne
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (x: struct' tag fields excluded)
   (field1: field_of fields)
   (v: (fields.get_field field1).view_type)
@@ -307,15 +309,28 @@ val struct_pcm_put_put_ne
       struct_pcm_put (struct_pcm_put x field1 v) field2 w ==
       struct_pcm_put (struct_pcm_put x field2 w) field1 v)
 
-val struct_view (tag: Type0) (fields: c_fields) (excluded: set string)
+val struct_view (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
 : sel_view (struct_pcm tag fields) (struct' tag fields excluded) false
 
+val struct_is_unit (tag: Type0) (fields: c_fields)
+  (v: struct_pcm_carrier tag fields)
+: b:bool{b <==> v == one (struct_pcm tag fields)}
+
+[@@c_typedef]
+let typedef_struct (tag: Type0) (fields: c_fields): typedef = {
+  carrier = struct_pcm_carrier tag fields;
+  pcm = struct_pcm tag fields;
+  view_type = struct tag fields;
+  view = struct_view tag fields emptyset;
+  is_unit = struct_is_unit tag fields;
+}
+
 val struct_field
   (tag: Type0) (fields: c_fields) (field: field_of fields)
 : connection (struct_pcm tag fields) (fields.get_field field).pcm
 
 val extract_field
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
@@ -323,7 +338,7 @@ val extract_field
     (ensures fun _ -> True)
     
 val extract_field_extracted
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (v: struct' tag fields excluded)
 : Lemma
@@ -332,7 +347,7 @@ val extract_field_extracted
     [SMTPat (extract_field tag fields excluded field v)]
 
 val extract_field_unextracted
-  (tag: Type0) (fields: c_fields) (excluded: set string)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
   (field': field_of fields)
   (v: struct' tag fields excluded)
@@ -345,7 +360,7 @@ val extract_field_unextracted
      SMTPat (has_type field' string)]
 
 val addr_of_struct_field_ref
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
 : Steel (ref 'a (fields.get_field field).pcm)
@@ -371,7 +386,7 @@ val addr_of_struct_field_ref
          h' (q `pts_to_view` (fields.get_field field).view)))
 
 val unaddr_of_struct_field_ref'
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
   (q: ref 'a (fields.get_field field).pcm)
@@ -391,7 +406,7 @@ val unaddr_of_struct_field_ref'
          h (q `pts_to_view` (fields.get_field field).view)))
 
 val unaddr_of_struct_field_ref
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct_pcm tag fields))
   (q: ref 'a (fields.get_field field).pcm)
@@ -420,7 +435,7 @@ val unaddr_of_struct_field_ref
 open Steel.C.Reference
 
 let addr_of_struct_field
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
 : Steel (ref 'a
@@ -451,7 +466,7 @@ let addr_of_struct_field
   addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 let unaddr_of_struct_field
-  (#tag: Type0) (#fields: c_fields) (#excluded: set string)
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
   (q: ref 'a
@@ -481,11 +496,3 @@ let unaddr_of_struct_field
 =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
-
-[@@c_typedef]
-let typedef_struct (tag: Type0) (fields: c_fields): typedef = {
-  carrier = struct_pcm_carrier tag fields;
-  pcm = struct_pcm tag fields;
-  view_type = struct tag fields;
-  view = struct_view tag fields emptyset;
-}

From 360da18f710ea295fcaff74864b225d6f86cbb75 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 16:12:33 -0700
Subject: [PATCH 198/513] Add UnionLiteral.fsti; finish views for unions

---
 .../steel/arraystructs/Steel.C.Fields.fsti    |  11 +-
 .../arraystructs/Steel.C.UnionLiteral.fst     |  41 ++++--
 .../arraystructs/Steel.C.UnionLiteral.fsti    | 137 ++++++++++++++++++
 3 files changed, 178 insertions(+), 11 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.UnionLiteral.fsti

diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 2f3900910fd..923df94e43d 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -26,6 +26,10 @@ noeq type c_fields = {
   get_field: string ^-> typedef;
   // get_field_prf: forall field. has_field field == false ==> get_field field == trivial_typedef;
   get_field_mt: squash (get_field "" == trivial_typedef);
+  nonempty_witness:
+    o:option string
+     {(None? o ==> cfields == [""]) /\
+      (Some? o ==> Some?.v o `List.Tot.mem` cfields /\ Some?.v o =!= "")};
 }
 
 (* Begin for extraction *)
@@ -56,19 +60,22 @@ let fields_nil: c_fields = {
   //has_field_prf = ();
   get_field = on_dom _ (fun _ -> trivial_typedef);
   get_field_mt = ();
+  nonempty_witness = None;
 }
 
+let field_t = field:string{field =!= ""}
+
 //[@@__reduce__]
-let fields_cons (field: string{field =!= ""}) (td: typedef) (fields: c_fields): c_fields = {
+let fields_cons (field: field_t) (td: typedef) (fields: c_fields): c_fields = {
   cfields = field :: fields.cfields;
   has_field = insert field fields.has_field;
   has_field_mt = fields.has_field_mt;
   has_field_prf = fields.has_field_prf;
   get_field = on_dom _ (fun field' -> if field = field' then td else fields.get_field field');
   get_field_mt = ();
+  nonempty_witness = Some field;
 }
 
-let field_t = field:string{field =!= ""}
 let field_of (fields: c_fields) = field:string{fields.has_field field == true /\ field =!= ""}
 
 irreducible let c_struct = ()
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index 3ca323772b4..02b50d87348 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -25,7 +25,7 @@ let union (tag: Type0) (fields: c_fields): Type0 =
   dtuple2 (field_of fields) (union_views fields)
 
 let mk_union (tag: Type0) (fields: c_fields)
-  (field: string) (x: (fields.get_field field).view_type)
+  (field: field_of fields) (x: (fields.get_field field).view_type)
 : Pure (union tag fields)
     (requires fields.has_field field == true)
     (ensures fun _ -> True)
@@ -43,21 +43,43 @@ let union_pcm_carrier (tag: Type0) (fields: c_fields): Type0 =
 let union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields) =
   union_pcm (union_pcms fields)
 
-assume val case_of_union (fields: c_fields)
-  (non_unit_deciders:
-    (field:field_of fields ->
-     x:(fields.get_field field).carrier ->
-     b:bool{x =!= one (fields.get_field field).pcm}))
+let is_units (fields: c_fields) (field: field_of fields)
+: x:(fields.get_field field).carrier ->
+  b:bool{b <==> x == one (fields.get_field field).pcm}
+= (fields.get_field field).is_unit
+
+let rec case_of_union_aux (fields: c_fields)
+  (fields_list: list string)
+  (u: Steel.C.Union.union (union_pcms fields))
+: Pure (option (field_of fields))
+    (requires forall (field:string). field `mem` fields_list ==> fields.has_field field == true)
+    (ensures fun field ->
+      (None? field ==> (forall (field:field_t). field `mem` fields_list ==> u field == one (union_pcms fields field))) /\
+      (Some? field ==> u (Some?.v field) =!= one (union_pcms fields (Some?.v field))))
+    (decreases fields_list)
+= match fields_list with
+  | [] -> None
+  | field :: fields_list ->
+    match case_of_union_aux fields fields_list u with
+    | Some field -> Some field
+    | None ->
+      if field = "" then None else
+      if (fields.get_field field).is_unit (u field) then None else Some field
+
+let case_of_union (fields: nonempty_c_fields)
   (u: Steel.C.Union.union (union_pcms fields))
 : field:field_of fields{case_refinement_f (union_pcms fields) field u}
+= match case_of_union_aux fields fields.cfields u with
+  | None -> Some?.v fields.nonempty_witness
+  | Some field -> field
 
 let union_views' (fields: c_fields) (field: field_of fields)
 : sel_view (union_pcms fields field) (union_views fields field) false
 = (fields.get_field field).view
 
-let union_view (tag: Type0) (fields: c_fields)
+let union_view (tag: Type0) (fields: nonempty_c_fields)
 : sel_view (union_pcm tag fields) (union tag fields) false
-= Steel.C.Union.union_view (union_views' fields) (case_of_union fields (admit()))
+= Steel.C.Union.union_view (union_views' fields) (case_of_union fields)
 
 let dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
 : dtuple2 (field_of fields) (union_views fields)
@@ -149,9 +171,10 @@ assume val switch_union_field
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
 
 [@@c_typedef]
-let typedef_union (tag: Type0) (fields: c_fields): typedef = {
+let typedef_union (tag: Type0) (fields: nonempty_c_fields): typedef = {
   carrier = union_pcm_carrier tag fields;
   pcm = union_pcm tag fields;
   view_type = union tag fields;
   view = union_view tag fields;
+  is_unit = admit();
 }
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
new file mode 100644
index 00000000000..c53b9820769
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -0,0 +1,137 @@
+module Steel.C.UnionLiteral
+
+open Steel.Memory
+open Steel.Effect
+open Steel.Effect.Common
+open Steel.Effect.Atomic
+
+open Steel.C.PCM
+open Steel.C.Union
+open Steel.C.Typedef
+open Steel.C.Ref
+open Steel.C.Connection
+open Steel.C.Opt
+open Steel.C.Fields
+
+open FStar.List.Tot
+open FStar.FunctionalExtensionality
+open FStar.FSet
+
+module TS = Typestring
+
+val mk_union_def (tag: Type0) (field_descriptions: Type0): Type0
+
+let mk_c_union (tag: Type0) (fields: c_fields) =
+  mk_union_def tag (c_fields_t fields)
+
+let union_views (fields: c_fields) (field: field_of fields): Type0 =
+  (fields.get_field field).view_type
+
+val union (tag: Type0) (fields: c_fields): Type0
+
+val mk_union (tag: Type0) (fields: c_fields)
+  (field: field_of fields) (x: (fields.get_field field).view_type)
+: Pure (union tag fields)
+    (requires fields.has_field field == true)
+    (ensures fun _ -> True)
+
+val union_pcm_carrier (tag: Type0) (fields: c_fields): Type0
+
+val union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields)
+
+let nonempty_c_fields = fields:c_fields{Some? fields.nonempty_witness}
+
+val union_view (tag: Type0) (fields: nonempty_c_fields)
+: sel_view (union_pcm tag fields) (union tag fields) false
+
+val dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
+: dtuple2 (field_of fields) (union_views fields)
+
+val union_of_dtuple2 (#tag: Type0) (#fields: c_fields) 
+  (x: dtuple2 (field_of fields) (union_views fields))
+: union tag fields
+
+val dtuple2_of_union_of_dtuple2 
+  (#tag: Type0) (#fields: c_fields)
+  (x: dtuple2 (field_of fields) (union_views fields))
+: Lemma (dtuple2_of_union (union_of_dtuple2 #tag #fields x) == x)
+
+val union_of_dtuple2_of_union
+  (#tag: Type0) (#fields: c_fields)
+  (x: union tag fields)
+: Lemma (union_of_dtuple2 (dtuple2_of_union #tag #fields x) == x)
+
+val union_field
+  (tag: Type0) (fields: c_fields) (field: field_of fields)
+: connection (union_pcm tag fields) (fields.get_field field).pcm
+
+open Steel.C.Reference
+
+val addr_of_union_field
+  (#tag: Type0) (#fields: c_fields)
+  (field: field_of fields)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel (ref 'a
+          (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+          (fields.get_field field).pcm)
+    (p `pts_to_view` union_view tag fields)
+    (fun q ->
+      pts_to_view u#0
+                  #'a
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  q
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+    (requires fun h ->
+       dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field)
+    (ensures fun h q h' -> 
+      q == ref_focus p (union_field tag fields field) /\
+      dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field /\
+      dsnd (dtuple2_of_union (h (p `pts_to_view` union_view tag fields)))
+        ==
+        h' (q `pts_to_view` (fields.get_field field).view))
+
+val unaddr_of_union_field
+  (#tag: Type0) (#fields: c_fields)
+  (field: field_of fields)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (q: ref 'a (fields.get_field field).view_type (fields.get_field field).pcm)
+: Steel unit
+    (pts_to_view u#0
+                 #'a
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                 q
+                 (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+    (fun q -> p `pts_to_view` union_view tag fields)
+    (requires fun _ -> q == ref_focus p (union_field tag fields field))
+    (ensures fun h _ h' -> 
+      dfst (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields))) == field /\
+      dsnd (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)))
+        ==
+        h (q `pts_to_view` (fields.get_field field).view))
+
+val switch_union_field
+  (#tag: Type0) (#fields: c_fields)
+  (field: field_of fields) (v: (fields.get_field field).view_type)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel unit
+    (p `pts_to_view` union_view tag fields)
+    (fun _ -> p `pts_to_view` union_view tag fields)
+    (requires fun h ->
+      let (|field, v|) = dtuple2_of_union (h (p `pts_to_view` union_view tag fields)) in
+      exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
+    (ensures fun _ _ h' ->
+      dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
+
+[@@c_typedef]
+let typedef_union (tag: Type0) (fields: c_fields): typedef = {
+  carrier = union_pcm_carrier tag fields;
+  pcm = union_pcm tag fields;
+  view_type = union tag fields;
+  view = union_view tag fields;
+}

From e3c6914fa7bbbe21f485496606debe7bc90dba32 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Tue, 10 Aug 2021 16:22:45 -0700
Subject: [PATCH 199/513] typedef_union

---
 .../arraystructs/Steel.C.UnionLiteral.fst     | 29 +++++++++++++------
 .../arraystructs/Steel.C.UnionLiteral.fsti    | 12 ++++++++
 2 files changed, 32 insertions(+), 9 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index 02b50d87348..c1797c527af 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -107,6 +107,26 @@ let union_field
 : connection (union_pcm tag fields) (fields.get_field field).pcm
 = union_field (union_pcms fields) field
 
+let rec union_is_unit_aux (tag: Type0) (fields: c_fields)
+  (fields_list: list string)
+  (v: union_pcm_carrier tag fields)
+: Pure bool
+    (requires forall field. field `mem` fields_list ==> fields.has_field field == true)
+    (ensures fun b -> b <==> (forall (field: field_t). field `mem` fields_list ==> v field == one (union_pcm tag fields) field))
+    (decreases fields_list)
+= match fields_list with
+  | [] -> true
+  | field :: fields_list ->
+    if field = "" then union_is_unit_aux tag fields fields_list v else
+    (fields.get_field field).is_unit (v field) &&
+    union_is_unit_aux tag fields fields_list v
+
+let union_is_unit tag fields v
+: b:bool{b <==> v == one (union_pcm tag fields)}
+= let b = union_is_unit_aux tag fields fields.cfields v in
+  assert (b <==> v `feq` one (union_pcm tag fields));
+  b
+
 open Steel.C.Reference
 
 assume val addr_of_union_field
@@ -169,12 +189,3 @@ assume val switch_union_field
       exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
     (ensures fun _ _ h' ->
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
-
-[@@c_typedef]
-let typedef_union (tag: Type0) (fields: nonempty_c_fields): typedef = {
-  carrier = union_pcm_carrier tag fields;
-  pcm = union_pcm tag fields;
-  view_type = union tag fields;
-  view = union_view tag fields;
-  is_unit = admit();
-}
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index c53b9820769..7dbb7d12e46 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -65,6 +65,18 @@ val union_field
   (tag: Type0) (fields: c_fields) (field: field_of fields)
 : connection (union_pcm tag fields) (fields.get_field field).pcm
 
+val union_is_unit (tag:Type0) (fields:c_fields) (v:union_pcm_carrier tag fields)
+: b:bool{b <==> v == one (union_pcm tag fields)}
+
+[@@c_typedef]
+let typedef_union (tag: Type0) (fields: nonempty_c_fields): typedef = {
+  carrier = union_pcm_carrier tag fields;
+  pcm = union_pcm tag fields;
+  view_type = union tag fields;
+  view = union_view tag fields;
+  is_unit = union_is_unit tag fields;
+}
+
 open Steel.C.Reference
 
 val addr_of_union_field

From edb9ff9769b94e126b1fdc99113e3949fcffb114 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 07:30:57 -0700
Subject: [PATCH 200/513] Try getting rid of Obj.magic by adding
 inline_for_extraction

---
 examples/steel/arraystructs/PointStruct.fst            | 3 +++
 examples/steel/arraystructs/ScalarUnion.fst            | 2 ++
 examples/steel/arraystructs/Steel.C.Fields.fsti        | 4 ++++
 examples/steel/arraystructs/Steel.C.StructLiteral.fsti | 4 ++++
 examples/steel/arraystructs/Steel.C.UnionLiteral.fsti  | 8 --------
 5 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index dc424dab6a9..5a7b91525a9 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -26,6 +26,7 @@ let c_int': typedef = {
   pcm = opt_pcm #int';
   view_type = int';
   view = opt_view int';
+  is_unit = (fun x -> None? x);
 }
 
 module T = FStar.Tactics
@@ -103,6 +104,7 @@ let swap p =
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
 
+(*
 let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
 : Steel unit
   ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
@@ -141,6 +143,7 @@ let swap' p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
+*)
 
 (*
 ref 'a (struct tag fields)
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index e07539133f4..f1a80d8fc9c 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -25,6 +25,7 @@ let u32: typedef = {
   pcm = opt_pcm #U32.t;
   view_type = U32.t;
   view = opt_view U32.t;
+  is_unit = (fun x -> None? x);
 }
 
 [@@c_typedef]
@@ -34,6 +35,7 @@ let u16: typedef = {
   pcm = opt_pcm #U16.t;
   view_type = U16.t;
   view = opt_view U16.t;
+  is_unit = (fun x -> None? x);
 }
 
 module T = FStar.Tactics
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 923df94e43d..08c803f9306 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -8,6 +8,7 @@ open Steel.C.Opt
 
 module TS = Typestring
 
+inline_for_extraction
 let trivial_typedef: typedef = {
   carrier = option unit;
   pcm = opt_pcm #unit;
@@ -17,6 +18,7 @@ let trivial_typedef: typedef = {
 }
 
 //[@@__reduce__]
+inline_for_extraction
 noeq type c_fields = {
   //cfields: clist string;
   cfields: list string;
@@ -52,6 +54,7 @@ let c_fields_t (fields: c_fields) =
 (* End for extraction *)
 
 //[@@__reduce__]
+inline_for_extraction
 let fields_nil: c_fields = {
   cfields = [""];
   has_field = insert "" emptyset;
@@ -66,6 +69,7 @@ let fields_nil: c_fields = {
 let field_t = field:string{field =!= ""}
 
 //[@@__reduce__]
+inline_for_extraction
 let fields_cons (field: field_t) (td: typedef) (fields: c_fields): c_fields = {
   cfields = field :: fields.cfields;
   has_field = insert field fields.has_field;
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 203f246fe61..2b0555b0c65 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -405,6 +405,7 @@ val unaddr_of_struct_field_ref'
         (h (p `pts_to_view` struct_view tag fields excluded),
          h (q `pts_to_view` (fields.get_field field).view)))
 
+#push-options "--z3rlimit 30"
 val unaddr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -431,6 +432,7 @@ val unaddr_of_struct_field_ref
        ==
         (h (p `pts_to_view` struct_view tag fields excluded),
          h (q `pts_to_view` (fields.get_field field).view)))
+#pop-options
 
 open Steel.C.Reference
 
@@ -465,6 +467,7 @@ let addr_of_struct_field
 //let addr_of_struct_field #a #tag #fields #excluded field p =
   addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
+#push-options "--z3rlimit 30"
 let unaddr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -496,3 +499,4 @@ let unaddr_of_struct_field
 =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
+#pop-options
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index 7dbb7d12e46..985b1d22f3d 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -139,11 +139,3 @@ val switch_union_field
       exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
     (ensures fun _ _ h' ->
       dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
-
-[@@c_typedef]
-let typedef_union (tag: Type0) (fields: c_fields): typedef = {
-  carrier = union_pcm_carrier tag fields;
-  pcm = union_pcm tag fields;
-  view_type = union tag fields;
-  view = union_view tag fields;
-}

From 1b93a23f8b79a779de15a993d13b95a6930c62af Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 10:53:47 -0700
Subject: [PATCH 201/513] Get rid of Obj.magic in generated OCaml for
 addr_of_struct_field

---
 examples/steel/arraystructs/PointStruct.fst   | 25 ++++++++++-
 .../steel/arraystructs/Steel.C.Fields.fsti    |  4 --
 .../arraystructs/Steel.C.StructLiteral.fsti   | 45 ++++++++++++++++---
 src/extraction/FStar.Extraction.Kremlin.fs    |  8 ++--
 4 files changed, 67 insertions(+), 15 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 5a7b91525a9..0f519c363d7 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -93,8 +93,8 @@ val swap (p: ref unit point point_pcm)
       True)
 
 let swap p =
-  let q: ref _ int' _ = addr_of_struct_field "x" p in
-  let r: ref _ int' _ = addr_of_struct_field "y" p in
+  let q: ref _ _ _ = addr_of_struct_field "x" p in
+  let r: ref _ _ _ = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
   q `opt_write_sel` y;
@@ -104,6 +104,27 @@ let swap p =
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
 
+(*
+assume val addr_of_struct_field_ref'
+  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
+  (field: field_of fields)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (q `pts_to_view` (fields.get_field field).view))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+*)
+
 (*
 let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
 : Steel unit
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 08c803f9306..923df94e43d 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -8,7 +8,6 @@ open Steel.C.Opt
 
 module TS = Typestring
 
-inline_for_extraction
 let trivial_typedef: typedef = {
   carrier = option unit;
   pcm = opt_pcm #unit;
@@ -18,7 +17,6 @@ let trivial_typedef: typedef = {
 }
 
 //[@@__reduce__]
-inline_for_extraction
 noeq type c_fields = {
   //cfields: clist string;
   cfields: list string;
@@ -54,7 +52,6 @@ let c_fields_t (fields: c_fields) =
 (* End for extraction *)
 
 //[@@__reduce__]
-inline_for_extraction
 let fields_nil: c_fields = {
   cfields = [""];
   has_field = insert "" emptyset;
@@ -69,7 +66,6 @@ let fields_nil: c_fields = {
 let field_t = field:string{field =!= ""}
 
 //[@@__reduce__]
-inline_for_extraction
 let fields_cons (field: field_t) (td: typedef) (fields: c_fields): c_fields = {
   cfields = field :: fields.cfields;
   has_field = insert field fields.has_field;
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 2b0555b0c65..91404b6fb36 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -436,12 +436,46 @@ val unaddr_of_struct_field_ref
 
 open Steel.C.Reference
 
+(* TODO make abstract *)
+let addr_of_struct_field''
+  (return_view_type: Type0)
+  (return_carrier: Type0)
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
+  (field: field_of fields{
+    return_view_type == (fields.get_field field).view_type /\
+    return_carrier == (fields.get_field field).carrier})
+  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
+: Steel (ref 'a return_view_type #return_carrier (fields.get_field field).pcm)
+    (p `pts_to_view` struct_view tag fields excluded)
+    (fun q ->
+      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
+      (pts_to_view u#0
+                  #'a
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  q
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view))))
+    (requires fun _ -> not (excluded field))
+    (ensures fun h q h' -> 
+      not (excluded field) /\
+      q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
+      extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))
+       ==
+        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
+         h' (q `pts_to_view` (fields.get_field field).view)))
+= addr_of_struct_field_ref #'a #tag #fields #excluded field p
+
+inline_for_extraction noextract
 let addr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
 : Steel (ref 'a
-          (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+          (norm simplify_typedefs (fields.get_field field).view_type)
+          #(norm simplify_typedefs (fields.get_field field).carrier)
           (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
@@ -457,15 +491,16 @@ let addr_of_struct_field
     (requires fun _ -> not (excluded field))
     (ensures fun h q h' -> 
       not (excluded field) /\
-      q == ref_focus p (struct_field tag fields field) /\
+      q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
       extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded))
        ==
         (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
          h' (q `pts_to_view` (fields.get_field field).view)))
-=         
-//let addr_of_struct_field #a #tag #fields #excluded field p =
-  addr_of_struct_field_ref #'a #tag #fields #excluded field p
+= addr_of_struct_field''
+    (normalize (fields.get_field field).view_type)
+    (normalize (fields.get_field field).carrier)
+    tag fields excluded field p
 
 #push-options "--z3rlimit 30"
 let unaddr_of_struct_field
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 0cbd46d92f8..b278e56bd5c 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -587,11 +587,11 @@ and translate_type_decl env ty: option<decl> =
           let rec parse_fields (fields: mlty): option<list<_>> =
             match fields with
             | MLTY_Named ([], p)
-              when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.struct_fields_t_nil"
+              when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
               -> Some []
               
             | MLTY_Named ([field; t; fields], p)
-              when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.struct_fields_t_cons"
+              when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
               ->
               opt_bind (string_of_typestring field) (fun field ->
               opt_bind (parse_fields fields) (fun fields ->
@@ -1137,9 +1137,9 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->
       EUnit
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; struct_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
              [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
-    when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field" ->
+    when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field''" ->
       let struct_name = must (string_of_typestring struct_name) in
       EAddrOf (EField (
         TQualified (env.module_name, struct_name), // JL: TODO env.module_name or (fst p)?

From 03bebe09a6aa5a6a66d804149869d2af6ab7fc6d Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 12:01:42 -0700
Subject: [PATCH 202/513] Implement union operations

---
 .../arraystructs/Steel.C.UnionLiteral.fst     | 146 ++++++++++++++----
 .../arraystructs/Steel.C.UnionLiteral.fsti    |  27 ++--
 2 files changed, 134 insertions(+), 39 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index c1797c527af..aa108eb79e4 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -129,33 +129,49 @@ let union_is_unit tag fields v
 
 open Steel.C.Reference
 
-assume val addr_of_union_field
+#push-options "--z3rlimit 30"
+let addr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel (ref 'a
-          (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+          (fields.get_field field).view_type
           (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
                   #'a
-                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
-                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
-                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
-                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  #(fields.get_field field).view_type
+                  #(fields.get_field field).view_type
+                  #(fields.get_field field).carrier
+                  #(fields.get_field field).pcm
                   q
-                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+                  (fields.get_field field).view)
     (requires fun h ->
        dfst (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))) == field)
     (ensures fun h q h' -> 
       q == ref_focus p (union_field tag fields field) /\
-      dfst (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))) == field /\
-      dsnd (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields)))
-        ==
-        h' (q `pts_to_view` (fields.get_field field).view))
+      dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+        == (|field, h' (q `pts_to_view` (fields.get_field field).view)|))
+= let v: Ghost.erased (union tag fields) =
+    gget (p `pts_to_view` union_view tag fields)
+  in
+  let s: Ghost.erased (union_pcm_carrier tag fields) =
+    pts_to_view_elim p (union_view tag fields)
+  in
+  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
+  let q = Steel.C.Union.addr_of_union_field #'a #_ #_ #(union_pcms fields) p field s in
+  pts_to_view_intro q (Ghost.reveal s field)
+    (fields.get_field field).view
+    (dsnd (Ghost.reveal v));
+  assert (Ghost.reveal v == (|field, dsnd (Ghost.reveal v)|));
+  return q
+#pop-options
 
-assume val unaddr_of_union_field
+let addr_of_union_field #a #tag #fields field p =
+  addr_of_union_field' #a #tag #fields field p
+
+let unaddr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
@@ -163,29 +179,107 @@ assume val unaddr_of_union_field
 : Steel unit
     (pts_to_view u#0
                  #'a
-                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
-                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
-                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
-                 #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                 #(fields.get_field field).view_type
+                 #(fields.get_field field).view_type
+                 #(fields.get_field field).carrier
+                 #(fields.get_field field).pcm
                  q
-                 (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+                 (fields.get_field field).view)
     (fun q -> p `pts_to_view` union_view tag fields)
     (requires fun _ -> q == ref_focus p (union_field tag fields field))
     (ensures fun h _ h' -> 
-      dfst (dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))) == field /\
-      dsnd (dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields)))
-        ==
-        h (q `pts_to_view` (fields.get_field field).view))
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
+        == (|field, h (q `pts_to_view` (fields.get_field field).view)|))
+= let v: Ghost.erased (fields.get_field field).view_type =
+    gget (q `pts_to_view` (fields.get_field field).view)
+  in
+  let s: Ghost.erased (fields.get_field field).carrier =
+    pts_to_view_elim q (fields.get_field field).view
+  in
+  Steel.C.Union.unaddr_of_union_field #_ #_ #_ #_ #(union_pcms fields) field q p s;
+  pts_to_view_intro p
+    (field_to_union_f (union_pcms fields) field s)
+    (union_view tag fields)
+    (|field, Ghost.reveal v|);
+  return ()
+
+let unaddr_of_union_field #a #tag #fields field p q =
+  unaddr_of_union_field' #a #tag #fields field p q
+
+#restart-solver
+
+let exclusive_refine_union_field
+  (tag: Type0) (fields: c_fields)
+  (old_field new_field: field_of fields)
+  (old_value: (fields.get_field old_field).view_type)
+  (new_value: (fields.get_field new_field).view_type)
+: Lemma
+ (requires
+   exclusive (fields.get_field old_field).pcm ((fields.get_field old_field).view.to_carrier old_value) /\
+   p_refine (fields.get_field new_field).pcm ((fields.get_field new_field).view.to_carrier new_value))
+ (ensures
+   exclusive (union_pcm tag fields) ((union_view tag fields).to_carrier (|old_field, old_value|)) /\
+   p_refine (union_pcm tag fields) ((union_view tag fields).to_carrier (|new_field, new_value|)))
+= assert (
+    one (fields.get_field old_field).pcm =!=
+    (fields.get_field old_field).view.to_carrier old_value);
+  let aux frame
+  : Lemma
+    (requires 
+     Steel.C.PCM.composable
+      (union_pcm tag fields)
+      ((union_view tag fields).to_carrier (|old_field, old_value|))
+      frame)
+    (ensures frame == one (union_pcm tag fields))
+  = assert (frame old_field == one (fields.get_field old_field).pcm);
+    assert (frame `feq` one (union_pcm tag fields))
+  in
+  FStar.Classical.(forall_intro (move_requires aux))
 
-assume val switch_union_field
+let switch_union_field
   (#tag: Type0) (#fields: c_fields)
-  (field: field_of fields) (v: (fields.get_field field).view_type)
+  (field: field_of fields) (new_value: (fields.get_field field).view_type)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
     (requires fun h ->
-      let (|field, v|) = dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields)) in
-      exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
+      let (|old_field, v|) =
+        dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+      in
+      exclusive (fields.get_field old_field).pcm ((fields.get_field old_field).view.to_carrier v) /\
+      p_refine (fields.get_field field).pcm ((fields.get_field field).view.to_carrier new_value)
+    )
     (ensures fun _ _ h' ->
-      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
+        == (|field, new_value|))
+= let v: Ghost.erased (union tag fields) =
+    gget (p `pts_to_view` union_view tag fields)
+  in
+  let s: Ghost.erased (union_pcm_carrier tag fields) =
+    pts_to_view_elim p (union_view tag fields)
+  in
+  let s': Ghost.erased (union_pcm_carrier tag fields) =
+   Ghost.hide ((union_view tag fields).to_carrier (Ghost.reveal v))
+  in
+  assert (Ghost.reveal s == Ghost.reveal s');
+  let old_field: Ghost.erased (field_of fields) =
+    Ghost.hide (dfst (Ghost.reveal v))
+  in
+  let old_value: Ghost.erased (fields.get_field old_field).view_type =
+    Ghost.hide (dsnd (Ghost.reveal v))
+  in
+  let new_s: union_pcm_carrier tag fields =
+     (union_view tag fields).to_carrier (|field, new_value|)
+  in
+  exclusive_refine_union_field tag fields old_field field old_value new_value;
+  assert (exclusive (union_pcm tag fields) s);
+  assert (p_refine (union_pcm tag fields) new_s);
+  let upd: frame_preserving_upd (union_pcm tag fields) s new_s =
+    base_fpu (union_pcm tag fields) s new_s
+  in
+  Steel.C.Ref.ref_upd p s new_s upd;
+  pts_to_view_intro p new_s
+    (union_view tag fields)
+    (|field, new_value|);
+  return ()
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index 985b1d22f3d..6f4dc6b0ab1 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -97,13 +97,11 @@ val addr_of_union_field
                   q
                   (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
     (requires fun h ->
-       dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field)
+       dfst (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))) == field)
     (ensures fun h q h' -> 
       q == ref_focus p (union_field tag fields field) /\
-      dfst (dtuple2_of_union (h (p `pts_to_view` union_view tag fields))) == field /\
-      dsnd (dtuple2_of_union (h (p `pts_to_view` union_view tag fields)))
-        ==
-        h' (q `pts_to_view` (fields.get_field field).view))
+      dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+        == (|field, h' (q `pts_to_view` (fields.get_field field).view)|))
 
 val unaddr_of_union_field
   (#tag: Type0) (#fields: c_fields)
@@ -122,20 +120,23 @@ val unaddr_of_union_field
     (fun q -> p `pts_to_view` union_view tag fields)
     (requires fun _ -> q == ref_focus p (union_field tag fields field))
     (ensures fun h _ h' -> 
-      dfst (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields))) == field /\
-      dsnd (dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)))
-        ==
-        h (q `pts_to_view` (fields.get_field field).view))
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
+        == (|field, h (q `pts_to_view` (fields.get_field field).view)|))
 
 val switch_union_field
   (#tag: Type0) (#fields: c_fields)
-  (field: field_of fields) (v: (fields.get_field field).view_type)
+  (field: field_of fields) (new_value: (fields.get_field field).view_type)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
     (requires fun h ->
-      let (|field, v|) = dtuple2_of_union (h (p `pts_to_view` union_view tag fields)) in
-      exclusive (fields.get_field field).pcm ((fields.get_field field).view.to_carrier v))
+      let (|old_field, v|) =
+        dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+      in
+      exclusive (fields.get_field old_field).pcm ((fields.get_field old_field).view.to_carrier v) /\
+      p_refine (fields.get_field field).pcm ((fields.get_field field).view.to_carrier new_value)
+    )
     (ensures fun _ _ h' ->
-      dtuple2_of_union (h' (p `pts_to_view` union_view tag fields)) == (|field, v|))
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
+        == (|field, new_value|))

From e314fe135cd027e887143ca003902ae858acad10 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 12:56:08 -0700
Subject: [PATCH 203/513] Tidy; revive generic_swap PointStruct example

---
 examples/steel/arraystructs/PointStruct.fst | 14 ++++++--------
 src/extraction/FStar.Extraction.Kremlin.fs  |  6 ------
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 0f519c363d7..222c3893813 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -80,7 +80,7 @@ let x_conn
 
 open Steel.C.Reference
 
-val swap (p: ref unit point point_pcm)
+val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
@@ -93,8 +93,8 @@ val swap (p: ref unit point point_pcm)
       True)
 
 let swap p =
-  let q: ref _ _ _ = addr_of_struct_field "x" p in
-  let r: ref _ _ _ = addr_of_struct_field "y" p in
+  let q = addr_of_struct_field "x" p in
+  let r = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
   q `opt_write_sel` y;
@@ -125,7 +125,6 @@ assume val addr_of_struct_field_ref'
          h' (q `pts_to_view` (fields.get_field field).view)))
 *)
 
-(*
 let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
 : Steel unit
   ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
@@ -144,7 +143,7 @@ let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
   opt_write_sel q tmp;
   return ()
 
-val swap' (p: ref unit point point_pcm)
+val swap' (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
@@ -157,14 +156,13 @@ val swap' (p: ref unit point point_pcm)
       True)
 
 let swap' p =
-  let q: ref _ int' _ = addr_of_struct_field "x" p in
-  let r: ref _ int' _ = addr_of_struct_field "y" p in
+  let q = addr_of_struct_field "x" p in
+  let r = addr_of_struct_field "y" p in
   generic_swap_sel q r;
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
-*)
 
 (*
 ref 'a (struct tag fields)
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index b278e56bd5c..d6d215937e4 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1155,12 +1155,6 @@ and translate_expr env e: expr =
       EAssign (
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
-      (* JL: this doesn't seem to typecheck
-           EBufWrite (
-             translate_expr env r,
-             EConstant (UInt32, "0"),
-             translate_expr env x) *)
-      
 
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)

From 341afa83111874cd035837cfca60649aa59f6b3b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 13:08:35 -0700
Subject: [PATCH 204/513] Add DUntaggedUnion to FStar.Extraction.Kremlin

---
 src/extraction/FStar.Extraction.Kremlin.fs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index d6d215937e4..4d293d61239 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -55,6 +55,7 @@ and decl =
   | DTypeVariant of lident * list<flag> * int * branches_t
   | DTypeAbstractStruct of lident
   | DExternal of option<cc> * list<flag> * lident * typ * list<ident>
+  | DUntaggedUnion of lident * list<flag> * int * list<(ident * typ)>
 
 and cc =
   | StdCall

From e235f5f2a6b65817cb430ab5a7d65ae1dbe4191a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 13:14:07 -0700
Subject: [PATCH 205/513] Fixup type of addr_of_union_field for extraction

---
 .../arraystructs/Steel.C.UnionLiteral.fst     |  2 +-
 .../arraystructs/Steel.C.UnionLiteral.fsti    | 34 ++++++++++++++++++-
 2 files changed, 34 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index aa108eb79e4..6cb440e63cf 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -168,7 +168,7 @@ let addr_of_union_field'
   return q
 #pop-options
 
-let addr_of_union_field #a #tag #fields field p =
+let addr_of_union_field'' #a return_view_type return_carrier tag fields field p =
   addr_of_union_field' #a #tag #fields field p
 
 let unaddr_of_union_field'
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index 6f4dc6b0ab1..a1bfe82ff39 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -79,12 +79,40 @@ let typedef_union (tag: Type0) (fields: nonempty_c_fields): typedef = {
 
 open Steel.C.Reference
 
-val addr_of_union_field
+val addr_of_union_field''
+  (return_view_type: Type0)
+  (return_carrier: Type0)
+  (tag: Type0) (fields: c_fields)
+  (field: field_of fields{
+    return_view_type == (fields.get_field field).view_type /\
+    return_carrier == (fields.get_field field).carrier})
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel (ref 'a return_view_type #return_carrier (fields.get_field field).pcm)
+    (p `pts_to_view` union_view tag fields)
+    (fun q ->
+      pts_to_view u#0
+                  #'a
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
+                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
+                  q
+                  (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view)))
+    (requires fun h ->
+       dfst (dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))) == field)
+    (ensures fun h q h' -> 
+      q == ref_focus p (union_field tag fields field) /\
+      dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+        == (|field, h' (q `pts_to_view` (fields.get_field field).view)|))
+
+inline_for_extraction noextract
+let addr_of_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel (ref 'a
           (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
+          #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
           (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
@@ -102,6 +130,10 @@ val addr_of_union_field
       q == ref_focus p (union_field tag fields field) /\
       dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
         == (|field, h' (q `pts_to_view` (fields.get_field field).view)|))
+= addr_of_union_field''
+    (normalize (fields.get_field field).view_type)
+    (normalize (fields.get_field field).carrier)
+    tag fields field p
 
 val unaddr_of_union_field
   (#tag: Type0) (#fields: c_fields)

From 6bb27d402f62e77989b66e906002e00d1629cb12 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 13:36:37 -0700
Subject: [PATCH 206/513] Fix extraction for structs

---
 src/extraction/FStar.Extraction.Kremlin.fs | 100 +++++++++++++--------
 1 file changed, 62 insertions(+), 38 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 4d293d61239..907a21b2b0d 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -572,6 +572,47 @@ and translate_type_decl env ty: option<decl> =
   if List.mem Syntax.NoExtract ty.tydecl_meta then
     None
   else
+    // JL: TODO: hoist?
+    let parse_fields (fields: mlty): option<list<_>> =
+      let rec go fields =
+        match fields with
+        | MLTY_Named ([], p)
+          when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
+          -> Some []
+          
+        | MLTY_Named ([field; t; fields], p)
+          when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
+          ->
+          opt_bind (string_of_typestring field) (fun field ->
+          if field = "" then go fields else
+          opt_bind (go fields) (fun fields ->
+          Some ((field, t) :: fields)))
+  
+        | _ -> None
+      in
+      match go fields with
+      | None ->
+        BU.print1 "Failed to parse fields from %s.\n"
+          (FStar.Extraction.ML.Code.string_of_mlty ([], "") fields);
+        None
+
+      | Some fields ->
+          print_endline "Got fields:";
+          List.fold_left
+            (fun () (field, ty) ->
+               BU.print2 "  %s : %s\n"
+                 field
+                 (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty))
+            ()
+            fields;
+          Some (
+            List.map
+              (fun (field, ty) ->
+                 BU.print1 "Translating %s.\n"
+                   (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
+                 (field, (translate_type env ty, true)))
+              fields)
+    in
     match ty with
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
       when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
@@ -585,44 +626,27 @@ and translate_type_decl env ty: option<decl> =
             (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
           None
         | Some tag ->
-          let rec parse_fields (fields: mlty): option<list<_>> =
-            match fields with
-            | MLTY_Named ([], p)
-              when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
-              -> Some []
-              
-            | MLTY_Named ([field; t; fields], p)
-              when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
-              ->
-              opt_bind (string_of_typestring field) (fun field ->
-              opt_bind (parse_fields fields) (fun fields ->
-              Some ((field, t) :: fields)))
-
-            | _ -> None
-          in
-          match parse_fields fields with
-          | None ->
-            BU.print1 "Failed to parse struct fields from %s.\n"
-              (FStar.Extraction.ML.Code.string_of_mlty ([], "") fields);
-            None
-
-          | Some fields ->
-              BU.print1 "Got struct %s with following fields:\n" tag;
-              List.fold_left
-                (fun () (field, ty) ->
-                   BU.print2 "  %s : %s\n"
-                     field
-                     (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty))
-                ()
-                fields;
-              // JL: TODO env.module_name or (fst p)?
-              Some (DTypeFlat ((env.module_name, tag), [], 0,
-                List.map
-                  (fun (field, ty) ->
-                     BU.print1 "Translating %s.\n"
-                       (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
-                     (field, (translate_type env ty, true)))
-                  fields))
+          let fields = must (parse_fields fields) in
+          Some (DTypeFlat ((env.module_name, tag), [], 0, fields))
+          // JL: TODO: fix module name
+        end
+      end
+
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.UnionLiteral.mk_union_def"
+      ->
+      begin
+        (* JL: TODO remove/improve these print commands *)
+        print_endline "Parsing union definition.";
+        begin match string_of_typestring tag with
+        | None ->
+          BU.print1 "Failed to parse struct tag from %s.\n"
+            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
+          None
+        | Some tag ->
+          let fields = must (parse_fields fields) in
+          Some (DTypeFlat ((env.module_name, tag), [], 0, fields))
+          // JL: TODO: fix module name
         end
       end
 

From 29bcaff0bcdde04ca1acded4ab4de5fb6d77075b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Wed, 11 Aug 2021 14:13:07 -0700
Subject: [PATCH 207/513] Extraction for unions

---
 examples/steel/arraystructs/Steel.C.Union.fst |  2 +
 .../arraystructs/Steel.C.UnionLiteral.fst     | 22 ++++++++++-
 .../arraystructs/Steel.C.UnionLiteral.fsti    | 23 +++++++++++-
 src/extraction/FStar.Extraction.Kremlin.fs    | 37 +++++++++++++++++--
 4 files changed, 79 insertions(+), 5 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 961a9f77399..2a608661fa4 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -295,6 +295,7 @@ let union_field_lift_fpu0_prf1
 
 #push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 16"
 
+#push-options "--z3rlimit 30"
 let union_field_lift_fpu0_prf2
   (#a: eqtype)
   (#b: a -> Type)
@@ -324,6 +325,7 @@ let union_field_lift_fpu0_prf2
       assert (composable (p k) x (frame k));
       assert (composable (p k) y (frame k))
   )
+#pop-options
 
 #restart-solver
 
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index 6cb440e63cf..2670b399360 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -236,7 +236,7 @@ let exclusive_refine_union_field
   in
   FStar.Classical.(forall_intro (move_requires aux))
 
-let switch_union_field
+let switch_union_field''
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
@@ -283,3 +283,23 @@ let switch_union_field
     (union_view tag fields)
     (|field, new_value|);
   return ()
+
+let switch_union_field'
+  (new_value_ty: Type0) (tag: Type0) (fields: c_fields)
+  (field: field_of fields{new_value_ty == (fields.get_field field).view_type})
+  (new_value: new_value_ty)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel unit
+    (p `pts_to_view` union_view tag fields)
+    (fun _ -> p `pts_to_view` union_view tag fields)
+    (requires fun h ->
+      let (|old_field, v|) =
+        dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+      in
+      exclusive (fields.get_field old_field).pcm ((fields.get_field old_field).view.to_carrier v) /\
+      p_refine (fields.get_field field).pcm ((fields.get_field field).view.to_carrier new_value)
+    )
+    (ensures fun _ _ h' ->
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
+        == (|field, new_value|))
+= switch_union_field'' #'a #tag #fields field new_value p
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index a1bfe82ff39..a829b2b1d64 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -155,7 +155,27 @@ val unaddr_of_union_field
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
         == (|field, h (q `pts_to_view` (fields.get_field field).view)|))
 
-val switch_union_field
+val switch_union_field'
+  (new_value_ty: Type0) (tag: Type0) (fields: c_fields)
+  (field: field_of fields{new_value_ty == (fields.get_field field).view_type})
+  (new_value: new_value_ty)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel unit
+    (p `pts_to_view` union_view tag fields)
+    (fun _ -> p `pts_to_view` union_view tag fields)
+    (requires fun h ->
+      let (|old_field, v|) =
+        dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
+      in
+      exclusive (fields.get_field old_field).pcm ((fields.get_field old_field).view.to_carrier v) /\
+      p_refine (fields.get_field field).pcm ((fields.get_field field).view.to_carrier new_value)
+    )
+    (ensures fun _ _ h' ->
+      dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
+        == (|field, new_value|))
+
+noextract inline_for_extraction
+let switch_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
@@ -172,3 +192,4 @@ val switch_union_field
     (ensures fun _ _ h' ->
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
         == (|field, new_value|))
+= switch_union_field' (normalize (fields.get_field field).view_type) tag fields field new_value p
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 907a21b2b0d..0b6768f7911 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -610,7 +610,7 @@ and translate_type_decl env ty: option<decl> =
               (fun (field, ty) ->
                  BU.print1 "Translating %s.\n"
                    (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
-                 (field, (translate_type env ty, true)))
+                 (field, translate_type env ty))
               fields)
     in
     match ty with
@@ -627,7 +627,8 @@ and translate_type_decl env ty: option<decl> =
           None
         | Some tag ->
           let fields = must (parse_fields fields) in
-          Some (DTypeFlat ((env.module_name, tag), [], 0, fields))
+          Some (DTypeFlat ((env.module_name, tag), [], 0,
+            List.map (fun (field, ty) -> (field, (ty, true))) fields))
           // JL: TODO: fix module name
         end
       end
@@ -645,7 +646,7 @@ and translate_type_decl env ty: option<decl> =
           None
         | Some tag ->
           let fields = must (parse_fields fields) in
-          Some (DTypeFlat ((env.module_name, tag), [], 0, fields))
+          Some (DUntaggedUnion ((env.module_name, tag), [], 0, fields))
           // JL: TODO: fix module name
         end
       end
@@ -721,6 +722,12 @@ and translate_type env t: typ =
       TQualified (env.module_name, must (string_of_typestring tag))
       // JL: TODO env.module_name or (fst p)?
 
+  | MLTY_Named ([tag; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
+    ->
+      TQualified (env.module_name, must (string_of_typestring tag))
+      // JL: TODO env.module_name or (fst p)?
+
   | MLTY_Named ([_; arg; _; _], p) when
     Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
     ->
@@ -1161,6 +1168,10 @@ and translate_expr env e: expr =
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
     when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->
       EUnit
+      
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
+    when string_of_mlpath p = "Steel.C.UnionLiteral.unaddr_of_union_field" ->
+      EUnit
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
              [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
@@ -1171,6 +1182,26 @@ and translate_expr env e: expr =
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; union_name])},
+             [_; {expr=MLE_Const (MLC_String field_name)}; r])
+    when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+      let union_name = must (string_of_typestring union_name) in
+      EAddrOf (EField (
+        TQualified (env.module_name, union_name), // JL: TODO env.module_name or (fst p)?
+        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
+        field_name))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
+             [_; {expr=MLE_Const (MLC_String field_name)}; new_value; r])
+    when string_of_mlpath p = "Steel.C.UnionLiteral.switch_union_field'" ->
+      let union_name = must (string_of_typestring union_name) in
+      EAssign (
+        EField (
+          TQualified (env.module_name, union_name), // JL: TODO env.module_name or (fst p)?
+          EBufRead (translate_expr env r, EConstant (UInt32, "0")),
+          field_name),
+        translate_expr env new_value)
+
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
     when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))

From f84a9bf62caffb625288b9cdae8636a2710fcb15 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 12 Aug 2021 06:30:09 -0700
Subject: [PATCH 208/513] WIP arrays

---
 examples/steel/arraystructs/Steel.C.Array.fst | 384 ++++++++++++++++++
 .../steel/arraystructs/Steel.C.Array.fsti     | 311 ++++++++++++++
 examples/steel/arraystructs/Steel.C.PCM.fsti  |   4 +-
 .../steel/arraystructs/Steel.C.StdInt.fst     |  54 +++
 .../steel/arraystructs/Steel.C.StdInt.fsti    |  82 ++++
 5 files changed, 834 insertions(+), 1 deletion(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Array.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Array.fsti
 create mode 100644 examples/steel/arraystructs/Steel.C.StdInt.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.StdInt.fsti

diff --git a/examples/steel/arraystructs/Steel.C.Array.fst b/examples/steel/arraystructs/Steel.C.Array.fst
new file mode 100644
index 00000000000..cc18cf407dd
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Array.fst
@@ -0,0 +1,384 @@
+module Steel.C.Array
+
+module S = Steel.C.Struct
+
+let array_domain
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+: Tot Type0
+= (x: size_t { size_v x < size_v n })
+
+let array_range
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain t n)
+: Tot Type0
+= option t
+
+open FStar.FunctionalExtensionality
+
+let array_pcm_carrier t n = restricted_t (array_domain t n) (array_range t n)
+
+let array_elements_pcm
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain t n)
+: Tot (Steel.C.PCM.pcm (array_range t n x))
+= Steel.C.Opt.opt_pcm #t
+
+let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
+
+[@"opaque_to_smt"]
+let rec raise_list_array_domain
+  (t: Type u#0)
+  (n n': size_t)
+  (l: list (array_domain t n))
+: Pure (list (array_domain t n'))
+  (requires (size_v n' >= size_v n))
+  (ensures (fun l' ->
+    (forall (x': array_domain t n') . List.Tot.mem x' l' <==> (size_v x' < size_v n /\ List.Tot.mem x' l)) /\
+    List.Tot.length l' == List.Tot.length l
+  ))
+= match l with
+  | [] -> []
+  | x :: l_ -> x :: raise_list_array_domain t n n' l_
+
+[@"opaque_to_smt"]
+let rec included_indices
+  (t: Type u#0)
+  (n: size_t)
+: Pure (list (array_domain t n))
+  (requires True)
+  (ensures (fun l ->
+    (forall (x: array_domain t n) . List.Tot.mem x l) /\
+    List.Tot.length l == size_v n
+  ))
+  (decreases (size_v n))
+= if n = mk_size_t (FStar.UInt32.uint_to_t 0)
+  then []
+  else
+    let n' = size_sub n (mk_size_t (FStar.UInt32.uint_to_t 1)) in
+    n' :: raise_list_array_domain t n' n (included_indices t n')
+
+let array_elements_view_type
+  (t: Type u#0)
+  (n: size_t)
+  (k: array_domain t n)
+: Tot Type0
+= t
+
+let array_elements_view
+  (t: Type u#0)
+  (n: size_t)
+  (k: array_domain t n)
+: Tot (Steel.C.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
+= Steel.C.Opt.opt_view _
+
+let intro_array_view_init
+  (t: Type u#0)
+  (n: size_t)
+  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+  (k: nat { k < size_v n })
+: Tot t
+= x (int_to_size_t k)
+
+let intro_array_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+: Tot (array_view_type t n)
+= Seq.init (size_v n) (intro_array_view_init t n x)
+
+let array_to_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+: Tot (array_view_type t n)
+= intro_array_view t n (S.struct_view_to_view (array_elements_view t n) (included_indices t n) x)
+
+let elim_array_view_f
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+  (k: Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
+: Tot (array_elements_view_type t n k)
+= Seq.index x (size_v k)
+
+let elim_array_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+: Tot (restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+= on_dom (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
+
+let array_to_carrier
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+: Tot (Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+= S.struct_view_to_carrier (array_elements_view t n) (included_indices t n) (elim_array_view t n x)
+
+open Steel.C.PCM
+
+let array_view_to_view_frame
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+  (frame: array_pcm_carrier t n)
+: Lemma
+    (requires (composable (array_pcm t n) (array_to_carrier t n x) frame))
+    (ensures
+      S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)
+        (op (array_pcm t n) (array_to_carrier t n x) frame) /\ 
+      array_to_view t n
+        (op (array_pcm t n) (array_to_carrier t n x) frame) `Seq.equal` x)
+= S.struct_view_to_view_frame (array_elements_view t n) (included_indices t n)
+    (elim_array_view t n x) frame
+
+let array_view' (t: Type u#0) (n: size_t)
+  : Tot (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
+=
+  let open Steel.C.Ref in
+  {
+    to_view_prop = S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n);
+    to_view = array_to_view t n;
+    to_carrier = array_to_carrier t n;
+    to_carrier_not_one = (S.struct_view (array_elements_view t n) (included_indices t n)).to_carrier_not_one;
+    to_view_frame = array_view_to_view_frame t n;
+  }
+
+let array_view t n =
+  assert (size_v n > 0);
+  array_view' t n
+
+noeq
+type array base t = {
+  base_len: Ghost.erased size_t;
+  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
+  from: size_t;
+  to: size_t; // must be Tot because of array_small_to_large below
+  prf: squash (
+    size_v base_len >= 0 /\
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  );
+}
+
+let len a = a.to `size_sub` a.from
+
+let array_large_to_small_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+: Tot (array_pcm_carrier t (to `size_sub` from))
+= on_dom (array_domain t (to `size_sub` from)) (fun k -> x (from `size_add` k))
+
+let array_large_to_small
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Tot (Steel.C.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
+= Steel.C.Connection.mkmorphism
+    (array_large_to_small_f t base_len from to sq)
+    (assert (array_large_to_small_f t base_len from to sq (one (array_pcm t base_len)) `feq` one (array_pcm t (to `size_sub` from))))
+    (fun x1 x2 ->
+      assert (array_large_to_small_f t base_len from to sq (op (array_pcm t base_len) x1 x2) `feq` op (array_pcm t (to `size_sub` from)) (array_large_to_small_f t base_len from to sq x1)  (array_large_to_small_f t base_len from to sq x2))
+    )
+
+let array_small_to_large_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t) // Tot, argh
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t (to `size_sub` from))
+: Tot (array_pcm_carrier t base_len)
+= on_dom (array_domain t base_len) (fun k -> if size_le from k && not (size_le to k) then x (k `size_sub` from)
+  else one (Steel.C.Opt.opt_pcm #t))
+
+let array_small_to_large
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Tot (Steel.C.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
+= Steel.C.Connection.mkmorphism
+    (array_small_to_large_f t base_len from to sq)
+    (assert (array_small_to_large_f t base_len from to sq (one (array_pcm t (to `size_sub` from))) `feq` one (array_pcm t (base_len))))
+    (fun x1 x2 ->
+      assert (array_small_to_large_f t base_len from to sq (op (array_pcm t (to `size_sub` from)) x1 x2) `feq` op (array_pcm t (base_len)) (array_small_to_large_f t base_len from to sq x1)  (array_small_to_large_f t base_len from to sq x2))
+    )
+
+let array_small_to_large_to_small
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Lemma
+  (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
+= assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
+
+#push-options "--z3rlimit 32 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+assume
+val size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
+  (requires True)
+  (ensures (fun z -> size_v z == size_v x - size_v y))
+
+#restart-solver
+
+let array_conn_fpu_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Tot (array_pcm_carrier t base_len)
+= let sq0 : squash (size_v to >= size_v from) = () in
+  let z : size_t = size_sub' to from sq0 in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  // let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
+  // let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
+  // S.prod_pcm_composable_intro
+  //   (array_elements_pcm t z)
+  //   x
+  //   frame_small
+  //   (fun h -> assume False);
+  // assert (composable (array_pcm t (z)) x frame_small);
+  // op_comm (array_pcm t (z)) x frame_small;
+  // assert (op (array_pcm t (z)) frame_small x `feq` v_small);
+  // compatible_intro (array_pcm t (z)) x v_small frame_small;
+  assume (compatible (array_pcm t (z)) x v_small);
+  assume (p_refine (array_pcm t (z)) v_small); // TODO: remove p_refine from Steel.C.PCM
+  let v_small' : array_pcm_carrier t z = f v_small in
+  let v' : array_pcm_carrier t base_len =
+    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
+      if from `size_le` k && not (to `size_le` k)
+      then begin
+        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
+        v_small' (size_sub' k from sq2) <: option t
+      end
+      else v k
+    )
+  in
+  v'
+
+let array_conn_fpu
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+: Tot (frame_preserving_upd (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y))
+= frame_preserving_upd_intro
+    (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y)
+    (array_conn_fpu_f t base_len from to sq x y f)
+    (fun _ -> assume False)
+    (fun _ _ -> assume False)
+    (fun _ _ -> assume False)
+
+#pop-options
+
+let array_conn
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Steel.C.Connection.connection
+    (array_pcm t base_len)
+    (array_pcm t (to `size_sub` from))
+=
+  Steel.C.Connection.mkconnection
+    (array_small_to_large t base_len from to sq)
+    (array_large_to_small t base_len from to sq)
+    (array_small_to_large_to_small t base_len from to sq)
+    (array_conn_fpu t base_len from to sq)
+
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+let array_conn_id
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+: Lemma
+  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id _)
+=
+  let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
+  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
+  assume (forall (x: Ghost.erased (array_pcm_carrier t (base_len `size_sub` z)) { ~ (Ghost.reveal x == one (array_pcm t (base_len `size_sub` z))) }) y (f: frame_preserving_upd (array_pcm t (base_len `size_sub` z)) x y) v . array_conn_fpu_f t base_len z base_len () x y f v `feq` f v);
+  assert (forall x y f . array_conn_fpu_f t base_len z base_len () x y f `feq` f);
+  assume ((array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len ()).Steel.C.Connection.conn_lift_frame_preserving_upd === (Steel.C.Connection.connection_id (array_pcm t base_len)).Steel.C.Connection.conn_lift_frame_preserving_upd);
+  array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () `Steel.C.Connection.connection_eq` Steel.C.Connection.connection_id _
+
+let to_view_array_conn
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+: Lemma
+  (requires (
+    S.struct_view_to_view_prop (array_elements_view t base_len) (included_indices t base_len) x 
+  ))
+  (ensures (
+    let x' = array_large_to_small_f t base_len from to sq x in
+    S.struct_view_to_view_prop (array_elements_view t (to `size_sub` from)) (included_indices t (to `size_sub` from)) x' /\
+    array_to_view t (to `size_sub` from) x' `Seq.equal` Seq.slice (array_to_view t base_len x) (size_v from) (size_v to)
+  ))
+= ()
+
+#pop-options
+
+
+
+(*
+let array_as_ref
+  (#base: Type)
+  (#t: Type)
+  (a: array base t)
+: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+
diff --git a/examples/steel/arraystructs/Steel.C.Array.fsti b/examples/steel/arraystructs/Steel.C.Array.fsti
new file mode 100644
index 00000000000..2fb44bfae5c
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Array.fsti
@@ -0,0 +1,311 @@
+(*
+   Copyright 2021 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.C.Array
+include Steel.C.StdInt
+open Steel.Memory
+open Steel.FractionalPermission
+open Steel.Effect
+open FStar.Ghost
+open Steel.Effect.Atomic
+
+#set-options "--ide_id_info_off"
+
+/// A library for arrays in Steel
+/// TODO: add back support for fractional permissions, or even any element view
+
+val array_pcm_carrier (t: Type u#0) (n: Ghost.erased size_t) : Type u#0
+
+val array_pcm (t: Type u#0) (n: Ghost.erased size_t) : Tot (Steel.C.PCM.pcm (array_pcm_carrier t n))
+
+// FIXME: how to produce array type t[n] as the type of some struct field?
+let array_view_type (t: Type u#0) (n: size_t) : Type u#0 =
+  Seq.lseq t (size_v n)
+
+val array_view (t: Type u#0) (n: size_t)
+  : Pure (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
+    (requires (size_v n > 0))
+    (ensures (fun _ -> True))
+
+/// Abstract datatype for a Steel array of type [t]
+/// Should extract to t*
+val array (base: Type u#0) (t:Type u#0) : Type u#0
+
+/// Returns the length of the array. Usable for specification and proof purposes,
+/// as modeled by the GTot effect
+val len (#base: Type) (#t: Type) (a: array base t) : GTot size_t
+let length (#base: Type) (#t: Type) (a: array base t) : GTot nat = size_v (len a)
+
+/// Combining the elements above to create an array vprop
+/// TODO: generalize to any view
+
+// val g_array_as_ref (#base: Type u#0) (#t: Type u#0) (a: array base t)
+//   : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+
+// [@@ __steel_reduce__]
+// let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop
+// = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
+
+val varray_hp (#base: Type) (#t: Type) (x: array base t) : Tot (slprop u#1)
+val varray_sel (#base: Type) (#t: Type) (x: array base t) : Tot (selector (array_view_type t (len x)) (varray_hp x))
+
+[@@ __steel_reduce__ ]
+let varray' (#base: Type) (#t: Type) (x: array base t) : Tot vprop' = {
+  hp = varray_hp x;
+  t = array_view_type t (len x);
+  sel = varray_sel x;
+}
+
+[@@ __steel_reduce__ ]
+let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop =
+  VUnit (varray' x)
+
+val g_mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+: Ghost (array base t)
+  (requires (size_v n > 0))
+  (ensures (fun a -> len a == Ghost.reveal n))
+
+val intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (_: squash (size_v n > 0))
+: Steel (array base t)
+    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (fun a -> varray a)
+    (requires fun _ -> True)
+  (ensures (fun h a h' ->
+    a == g_mk_array r /\
+    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n)) (a: array base t) (_: squash (size_v n > 0))
+: SteelGhost unit inames
+  (varray a)
+  (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
+  (requires fun _ -> a == g_mk_array r)
+  (ensures (fun h _ h' ->
+    a == g_mk_array r /\
+    h (varray a) == h' (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+
+/// Splitting an array into subarrays
+
+val adjacent
+  (#base: Type)
+  (#t: Type)
+  (r1 r2: array base t)
+: Tot prop
+
+val merge
+  (#base: Type)
+  (#t: Type)
+  (r1 r2: array base t)
+: Ghost (array base t)
+  (requires (adjacent r1 r2))
+  (ensures (fun r -> length r == length r1 + length r2))
+
+let merge_into
+  (#base: Type)
+  (#t: Type)
+  (r1 r2 r3: array base t)
+: Tot prop
+= adjacent r1 r2 /\
+  merge r1 r2 == r3
+
+val merge_assoc
+  (#base: Type)
+  (#t: Type)
+  (r1 r2 r3: array base t)
+: Lemma
+  (requires (adjacent r1 r2 /\ adjacent r2 r3))
+  (ensures (
+    adjacent r1 r2 /\ adjacent r2 r3 /\
+    begin
+      let r12 = merge r1 r2 in
+      let r23 = merge r2 r3 in
+      adjacent r1 r23 /\ adjacent r12 r3 /\
+      merge r1 r23 == merge r12 r3
+    end
+  ))
+  [SMTPat (merge (merge r1 r2) r3)]
+
+val gsplit
+  (#base: Type)
+  (#t: Type)
+  (r: array base t)
+  (i: size_t)
+: Ghost (array base t & array base t)
+  (requires (size_v i <= length r))
+  (ensures (fun (rl, rr) ->
+    merge_into rl rr r /\
+    length rl == size_v i
+  ))
+
+[@erasable]
+noeq
+type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
+
+val split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+  : SteelGhost (array base t `gpair` array base t) opened
+          (varray a)
+          (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            let s = h (varray a) in
+            let sl = h' (varray (GPair?.fst res)) in
+            let sr = h' (varray (GPair?.snd res)) in
+            size_v i <= length a /\
+            GPair?.fst res == fst (gsplit a i) /\
+            GPair?.snd res == snd (gsplit a i) /\
+            sl == Seq.slice s 0 (size_v i) /\
+            sr == Seq.slice s (size_v i) (length a) /\
+            s == sl `Seq.append` sr
+          )
+
+val split_left (#opened: _) (#base: _) (#t:Type) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray a)
+          (fun _ -> varray a)
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            h' (varray a) == h (varray a) /\
+            size_v i <= length a /\
+            res == fst (gsplit a i)
+          )
+
+val split_right (#opened: _) (#base: _) (#t:Type) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray a)
+          (fun _ -> varray a)
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            h' (varray a) == h (varray a) /\
+            size_v i <= length a /\
+            res == snd (gsplit a i)
+          )
+
+val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelGhost (Ghost.erased (array base t)) opened
+          (varray al `star` varray ar)
+          (fun a -> varray a)
+          (fun _ -> adjacent al ar)
+          (fun h a h' ->
+            let s = h' (varray a) in
+            s == (h (varray al) `Seq.append` h (varray ar)) /\
+            merge_into al ar a
+          )
+
+val joinc (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray al `star` varray ar)
+          (fun a -> varray al `star` varray ar)
+          (fun _ -> adjacent al ar)
+          (fun h a h' ->
+            h' (varray al) == h (varray al) /\
+            h' (varray ar) == h (varray ar) /\
+            merge_into al ar a
+          )
+
+inline_for_extraction
+let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray al `star` varray ar)
+          (fun a -> varray a)
+          (fun _ -> adjacent al ar)
+          (fun h a h' ->
+            let s = h' (varray a) in
+            s == (h (varray al) `Seq.append` h (varray ar)) /\
+            merge_into al ar a
+          )
+=
+  let a = joinc al ar in
+  let ga = join' al ar in
+  change_equal_slprop
+    (varray ga)
+    (varray a);
+  return a
+
+/// Converting an array into a pointer, after it has been split to an array of size 1
+/// Those two functions should extract to identity functions
+
+val g_ref_of_array
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (requires (length r == 1))
+  (ensures (fun _ -> True))
+
+val ref_of_array (#base: Type) (#t:Type0) (r:array base t)
+  : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+             (varray r)
+             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t))
+             (requires fun _ -> length r == 1)
+             (ensures fun h0 r' h1 ->
+               let s = h0 (varray r) in
+               Seq.length s == 1 /\
+               g_ref_of_array r == r' /\
+               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelGhost unit inames
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun _ -> varray r')
+             (requires fun _ -> length r' == 1 /\ g_ref_of_array r' == r)
+             (ensures fun h0 _ h1 ->
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+// this function should be used only to pass a pointer as an argument to a function that expects an array
+
+val mk_array_of_ref (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : Steel (array base t)
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun r' -> varray r')
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+
+/// Accesses index [i] in array [r], as long as [i] is in bounds and the array
+/// is currently valid in memory
+
+val index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
+  : Steel t
+             (varray r)
+             (fun _ -> varray r)
+             (requires fun _ -> size_v i < length r)
+             (ensures fun h0 x h1 ->
+               let s = h1 (varray r) in
+               size_v i < length r /\
+               h0 (varray r) == s /\
+               x == Seq.index s (size_v i))
+
+/// Updates index [i] in array [r] with value [x], as long as [i]
+/// is in bounds and the array is currently valid in memory
+val upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
+  : Steel unit
+             (varray r)
+             (fun _ -> varray r)
+             (requires fun h -> size_v i < length r)
+             (ensures fun h0 _ h1 ->
+               size_v i < length r /\
+               h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/examples/steel/arraystructs/Steel.C.PCM.fsti
index 1659384ddbf..637c0595207 100644
--- a/examples/steel/arraystructs/Steel.C.PCM.fsti
+++ b/examples/steel/arraystructs/Steel.C.PCM.fsti
@@ -306,7 +306,9 @@ val frame_preserving_upd_intro
     (requires (frame_preserving_upd_goal3_pre p x y f v frame))
     (ensures (frame_preserving_upd_goal3_post p x y f v frame))
   )
-: Tot (frame_preserving_upd p x y)
+: Pure (frame_preserving_upd p x y)
+  (requires True)
+  (ensures (fun f' -> f `feq` f'))
 
 val fstar_fpu_of_fpu
   (#a: Type u#a)
diff --git a/examples/steel/arraystructs/Steel.C.StdInt.fst b/examples/steel/arraystructs/Steel.C.StdInt.fst
new file mode 100644
index 00000000000..5ba825859b1
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.StdInt.fst
@@ -0,0 +1,54 @@
+module Steel.C.StdInt
+
+module U64 = FStar.UInt64
+module I64 = FStar.Int64
+module Cast = FStar.Int.Cast
+
+let size_t = U64.t
+
+let size_precond x =
+  FStar.UInt.fits x U64.n == true
+
+let size_v x =
+  U64.v x
+
+let size_v_inj (x1 x2: size_t) : Lemma
+  (size_v x1 == size_v x2 ==> x1 == x2)
+  [SMTPat (size_v x1); SMTPat (size_v x2)]
+= ()
+
+let mk_size_t (x: U32.t) : Pure size_t
+  (requires True)
+  (ensures (fun y -> size_v y == U32.v x))
+= Cast.uint32_to_uint64 x
+
+let int_to_size_t x =
+  U64.uint_to_t x
+
+let size_precond_le x y = ()
+
+let size_add x y = x `U64.add` y
+
+let size_sub x y = x `U64.sub` y
+
+let size_mul x y = x `U64.mul` y
+
+let size_div x y = x `U64.div` y
+
+let size_le x y = x `U64.lte` y
+
+let ptrdiff_t = I64.t
+
+let ptrdiff_v x =
+  I64.v x
+
+let ptrdiff_v_inj (x1 x2: ptrdiff_t) : Lemma
+  (ptrdiff_v x1 == ptrdiff_v x2 ==> x1 == x2)
+  [SMTPat (ptrdiff_v x1); SMTPat (ptrdiff_v x2)]
+= ()
+
+let mk_ptrdiff_t x = Cast.int32_to_int64 x
+
+let ptrdiff_precond x = FStar.Int.fits x I64.n == true
+
+let intro_ptrdiff_precond x = ()
diff --git a/examples/steel/arraystructs/Steel.C.StdInt.fsti b/examples/steel/arraystructs/Steel.C.StdInt.fsti
new file mode 100644
index 00000000000..ec0625925bb
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.StdInt.fsti
@@ -0,0 +1,82 @@
+module Steel.C.StdInt
+
+open FStar.Mul
+
+module U32 = FStar.UInt32
+module I32 = FStar.Int32
+
+inline_for_extraction noextract // TODO: replace with primitive extraction
+val size_t : eqtype
+
+val size_precond (x: nat) : Tot prop
+
+noextract
+val size_v (x: size_t) : Pure nat // should be Ghost, but need Pure to implement alloc
+  (requires True)
+  (ensures (fun y -> size_precond y))
+
+val size_v_inj (x1 x2: size_t) : Lemma
+  (size_v x1 == size_v x2 ==> x1 == x2)
+  [SMTPat (size_v x1); SMTPat (size_v x2)]
+
+val mk_size_t (x: U32.t) : Pure size_t
+  (requires True)
+  (ensures (fun y -> size_v y == U32.v x))
+
+noextract
+val int_to_size_t (x: nat) : Pure size_t // should be Ghost, but need Pure to implement array views
+  (requires (size_precond x))
+  (ensures (fun y -> size_v y == x))
+
+val size_precond_le (x y: nat) : Lemma
+  (requires (x <= y /\ size_precond y))
+  (ensures (size_precond x))
+  [SMTPat (size_precond x); SMTPat (size_precond y)]
+
+val size_add (x y: size_t) : Pure size_t
+  (requires (size_precond (size_v x + size_v y)))
+  (ensures (fun z -> size_v z == size_v x + size_v y))
+
+val size_sub (x y: size_t) : Pure size_t
+  (requires (size_v x >= size_v y))
+  (ensures (fun z -> size_v z == size_v x - size_v y))
+
+val size_mul (x y: size_t) : Pure size_t
+  (requires (size_precond (size_v x * size_v y)))
+  (ensures (fun z -> size_v z == size_v x * size_v y))
+
+val size_div (x y: size_t) : Pure size_t
+  (requires (size_v y > 0))
+  (ensures (fun z -> size_v z == size_v x / size_v y))
+
+val size_le (x y: size_t) : Pure bool
+  (requires True)
+  (ensures (fun z -> z == (size_v x <= size_v y)))
+
+let zero_size : (zero_size: size_t { size_v zero_size == 0 }) = mk_size_t 0ul
+
+let one_size : (zero_size: size_t { size_v zero_size == 1 }) = mk_size_t 1ul
+
+inline_for_extraction noextract // TODO: replace with primitive extraction
+val ptrdiff_t : eqtype
+
+module I32 = FStar.Int32
+
+val ptrdiff_v (x: ptrdiff_t) : Tot int // same remark as for size_v
+
+val ptrdiff_v_inj (x1 x2: ptrdiff_t) : Lemma
+  (ptrdiff_v x1 == ptrdiff_v x2 ==> x1 == x2)
+  [SMTPat (ptrdiff_v x1); SMTPat (ptrdiff_v x2)]
+
+val mk_ptrdiff_t (x: I32.t) : Pure ptrdiff_t
+  (requires True)
+  (ensures (fun y -> ptrdiff_v y == I32.v x))
+
+let zero_ptrdiff : (zero_ptrdiff: ptrdiff_t { ptrdiff_v zero_ptrdiff == 0 }) =
+  mk_ptrdiff_t 0l
+
+val ptrdiff_precond (x: int) : Tot prop
+
+val intro_ptrdiff_precond (x: int) : Lemma
+  (requires (FStar.Int.size x I32.n))
+  (ensures (ptrdiff_precond x))

From aa80cc9035cf8e247af6e614ffc4a6d2444c8b6f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 12 Aug 2021 08:30:00 -0700
Subject: [PATCH 209/513] Extraction for Steel.C.Array

---
 examples/steel/arraystructs/Steel.C.Array.fst |  4 ++
 .../steel/arraystructs/Steel.C.Array.fsti     | 29 +++++++++++-
 src/extraction/FStar.Extraction.Kremlin.fs    | 47 ++++++++++++++++++-
 3 files changed, 78 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Array.fst b/examples/steel/arraystructs/Steel.C.Array.fst
index cc18cf407dd..3ac9b1d12cd 100644
--- a/examples/steel/arraystructs/Steel.C.Array.fst
+++ b/examples/steel/arraystructs/Steel.C.Array.fst
@@ -28,6 +28,10 @@ let array_elements_pcm
 
 let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
 
+let array_view_type_sized t n' n = array_view_type t n
+
+let unfold_array_view_type_sized t n' n = ()
+
 [@"opaque_to_smt"]
 let rec raise_list_array_domain
   (t: Type u#0)
diff --git a/examples/steel/arraystructs/Steel.C.Array.fsti b/examples/steel/arraystructs/Steel.C.Array.fsti
index 2fb44bfae5c..c73580fe2d7 100644
--- a/examples/steel/arraystructs/Steel.C.Array.fsti
+++ b/examples/steel/arraystructs/Steel.C.Array.fsti
@@ -22,6 +22,10 @@ open Steel.Effect
 open FStar.Ghost
 open Steel.Effect.Atomic
 
+open Steel.C.Typedef
+open Steel.C.PCM
+open Typenat
+
 #set-options "--ide_id_info_off"
 
 /// A library for arrays in Steel
@@ -32,9 +36,20 @@ val array_pcm_carrier (t: Type u#0) (n: Ghost.erased size_t) : Type u#0
 val array_pcm (t: Type u#0) (n: Ghost.erased size_t) : Tot (Steel.C.PCM.pcm (array_pcm_carrier t n))
 
 // FIXME: how to produce array type t[n] as the type of some struct field?
-let array_view_type (t: Type u#0) (n: size_t) : Type u#0 =
+let array_view_type (t: Type u#0) (n: size_t)
+: Type u#0 =
   Seq.lseq t (size_v n)
 
+/// A variant of array_view_type, which records the length of the
+/// array in Type as a Typenat, for extraction
+let size_t_of (n': Type u#0) = n:size_t{n' == nat_t_of_nat (size_v n)}
+val array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
+: Type u#0
+val unfold_array_view_type_sized
+ (t: Type u#0) (n': Type u#0) (n: size_t_of n')
+: Lemma (array_view_type_sized t n' n == array_view_type t n)
+  [SMTPat (array_view_type_sized t n' n)]
+
 val array_view (t: Type u#0) (n: size_t)
   : Pure (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
     (requires (size_v n > 0))
@@ -49,6 +64,18 @@ val array (base: Type u#0) (t:Type u#0) : Type u#0
 val len (#base: Type) (#t: Type) (a: array base t) : GTot size_t
 let length (#base: Type) (#t: Type) (a: array base t) : GTot nat = size_v (len a)
 
+// TODO 
+val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
+: b:bool{b <==> a == one (array_pcm t n)}
+
+let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}): typedef = {
+  carrier = array_pcm_carrier t n;
+  pcm = array_pcm t n;
+  view_type = array_view_type_sized t n' n;
+  view = array_view t n;
+  is_unit = array_is_unit t n;
+}
+
 /// Combining the elements above to create an array vprop
 /// TODO: generalize to any view
 
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 0b6768f7911..078539810d5 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -190,6 +190,7 @@ and typ =
   | TApp of lident * list<typ>
   | TTuple of list<typ>
   | TConstBuf of typ
+  | TArray of typ * constant
 
 (** Versioned binary writing/reading of ASTs *)
 
@@ -598,6 +599,17 @@ and translate_type_decl env ty: option<decl> =
 
       | Some fields ->
           print_endline "Got fields:";
+          // Unlike in arguments, fixed-size arrays in structs do not decay to pointers
+          let rec translate_field_type env ty =
+            match ty with
+            | MLTY_Named ([t; n; _], p)
+              when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
+              // TODO add support for fixed-size arrays to Steel.C.Array.fsti
+              ->
+                let int_of_typenat s = failwith "unimplemented" in // TODO
+                TArray (translate_field_type env t, (UInt32, int_of_typenat n))
+            | t -> translate_type env t
+          in
           List.fold_left
             (fun () (field, ty) ->
                BU.print2 "  %s : %s\n"
@@ -610,7 +622,7 @@ and translate_type_decl env ty: option<decl> =
               (fun (field, ty) ->
                  BU.print1 "Translating %s.\n"
                    (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
-                 (field, translate_type env ty))
+                 (field, translate_field_type env ty))
               fields)
     in
     match ty with
@@ -730,6 +742,19 @@ and translate_type env t: typ =
 
   | MLTY_Named ([_; arg; _; _], p) when
     Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
+    ->
+      let rec skip_array_view_types ty =
+        match ty with
+        | MLTY_Named ([ty; _; _], p) when
+          Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
+          ->
+            skip_array_view_types ty
+        | _ -> ty
+      in
+      TBuf (translate_type env (skip_array_view_types arg))
+
+  | MLTY_Named ([_; arg], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Array.array"
     ->
       TBuf (translate_type env arg)
 
@@ -1212,6 +1237,26 @@ and translate_expr env e: expr =
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+    when string_of_mlpath p = "Steel.C.Array.ref_of_array" ->
+      translate_expr env r
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+    when string_of_mlpath p = "Steel.C.Array.mk_array_of_ref" ->
+      translate_expr env r
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; r])
+    when string_of_mlpath p = "Steel.C.Array.intro_varray" ->
+      translate_expr env r
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; i])
+    when string_of_mlpath p = "Steel.C.Array.index" ->
+      EBufRead (translate_expr env r, translate_expr env i)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; i; x])
+    when string_of_mlpath p = "Steel.C.Array.upd" ->
+      EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
+
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)
 

From 9287d2a12d4494a5b71402ee4df71cb8ed6b376f Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 12 Aug 2021 15:01:43 -0700
Subject: [PATCH 210/513] Prove PointStruct.swap correct

---
 examples/steel/arraystructs/PointStruct.fst   | 33 ++++++--
 .../arraystructs/Steel.C.StructLiteral.fsti   | 83 ++++++++++++-------
 2 files changed, 78 insertions(+), 38 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 222c3893813..4f848b6bb8e 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -65,6 +65,16 @@ let line_fields_second_half: c_fields =
 noextract inline_for_extraction
 let line_tag = normalize (mk_string_t "line")
 
+unfold let norm_list =
+  [delta_only
+    [`%mk_c_struct;
+     `%c_fields_t;
+     `%List.Tot.fold_right;
+     `%Typestring.mk_string_t;
+     `%c_struct;
+     ];
+   iota; zeta; primops]
+
 let _ = normalize (mk_c_struct line_tag (fields_cons "first" c_point line_fields_second_half))
 
 #push-options "--fuel 0"
@@ -75,8 +85,7 @@ let x_conn
 = struct_field point_tag point_fields "x"
 *)
 
-#push-options "--print_universes --print_implicits"
-// --z3rlimit 30"
+#push-options "--print_universes --print_implicits --z3rlimit 100 --query_stats"
 
 open Steel.C.Reference
 
@@ -86,13 +95,14 @@ val swap (p: ref 'a point point_pcm)
     (fun _ -> p `pts_to_view` point_view emptyset)
     (requires fun _ -> True)
     (ensures fun h q h' ->
-      //h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
-      //== h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
-      //h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
-      //== h (p `pts_to_view` point_view emptyset) `struct_get` "x")
-      True)
+      h' (p `pts_to_view` point_view emptyset) `struct_get` "x"
+      == h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
+      h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
+      == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
+      //True)
 
 let swap p =
+  let initial_point = gget (p `pts_to_view` point_view emptyset) in
   let q = addr_of_struct_field "x" p in
   let r = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
@@ -101,7 +111,14 @@ let swap p =
   r `opt_write_sel` x;
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
-  change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+  change_equal_slprop
+    (p `pts_to_view` point_view (remove "x" (remove "y" (insert "y" (insert "x" emptyset)))))
+    (p `pts_to_view` point_view emptyset);
+  let final_point = gget (p `pts_to_view` point_view emptyset) in
+  assert (struct_get #point_tag #point_fields #emptyset final_point "x" ==
+    struct_get #point_tag #point_fields #emptyset initial_point "y");
+  assert (struct_get #point_tag #point_fields #emptyset final_point "y" ==
+    struct_get #point_tag #point_fields #emptyset initial_point "x");
   return ()
 
 (*
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 91404b6fb36..878ca78a93f 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -356,8 +356,17 @@ val extract_field_unextracted
     (ensures 
       fst (extract_field tag fields excluded field v) `struct_get` field'
       == v `struct_get` field')
-    [SMTPat (extract_field tag fields excluded field v);
-     SMTPat (has_type field' string)]
+//    [SMTPat (extract_field tag fields excluded field v);
+//     SMTPat (has_type field' string)]
+     
+val extract_field_unextracted'
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+:  Lemma (forall (field': field_of fields).
+    (not (excluded field) /\ not (excluded field') /\ (field =!= field')) ==>
+    (fst (extract_field tag fields excluded field v) `struct_get` field' == v `struct_get` field'))
+    [SMTPat (extract_field tag fields excluded field v)]
 
 val addr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
@@ -379,11 +388,12 @@ val addr_of_struct_field_ref
     (ensures fun h q h' -> 
       not (excluded field) /\
       q == ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
-       ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
+      fst (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded)))
+        == h' (p `pts_to_view` struct_view tag fields (insert field excluded)) /\
+      snd (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded)))
+        == h' (q `pts_to_view` (fields.get_field field).view))
 
 val unaddr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
@@ -399,11 +409,14 @@ val unaddr_of_struct_field_ref'
       q == ref_focus p (struct_field tag fields field))
     (ensures fun h _ h' -> 
       excluded field == true /\
-      extract_field tag fields (remove field excluded) field
-        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
+      fst (extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded))))
        ==
-        (h (p `pts_to_view` struct_view tag fields excluded),
-         h (q `pts_to_view` (fields.get_field field).view)))
+        h (p `pts_to_view` struct_view tag fields excluded) /\
+      snd (extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded))))
+       ==
+         h (q `pts_to_view` (fields.get_field field).view))
 
 #push-options "--z3rlimit 30"
 val unaddr_of_struct_field_ref
@@ -427,11 +440,14 @@ val unaddr_of_struct_field_ref
       q == ref_focus p (struct_field tag fields field))
     (ensures fun h _ h' -> 
       excluded field == true /\
-      extract_field tag fields (remove field excluded) field
-        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
-       ==
-        (h (p `pts_to_view` struct_view tag fields excluded),
-         h (q `pts_to_view` (fields.get_field field).view)))
+      fst 
+        (extract_field tag fields (remove field excluded) field
+          (h' (p `pts_to_view` struct_view tag fields (remove field excluded))))
+       == h (p `pts_to_view` struct_view tag fields excluded) /\
+      snd 
+        (extract_field tag fields (remove field excluded) field
+          (h' (p `pts_to_view` struct_view tag fields (remove field excluded))))
+      == h (q `pts_to_view` (fields.get_field field).view))
 #pop-options
 
 open Steel.C.Reference
@@ -461,11 +477,14 @@ let addr_of_struct_field''
     (ensures fun h q h' -> 
       not (excluded field) /\
       q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
+      fst (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded)))
        ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
+        h' (p `pts_to_view` struct_view tag fields (insert field excluded))
+        /\
+        snd (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded))) ==
+         h' (q `pts_to_view` (fields.get_field field).view))
 = addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 inline_for_extraction noextract
@@ -492,11 +511,13 @@ let addr_of_struct_field
     (ensures fun h q h' -> 
       not (excluded field) /\
       q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
-       ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
+      fst (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded)))
+       == h' (p `pts_to_view` struct_view tag fields (insert field excluded))
+        /\ 
+        snd (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded)))
+        == h' (q `pts_to_view` (fields.get_field field).view))
 = addr_of_struct_field''
     (normalize (fields.get_field field).view_type)
     (normalize (fields.get_field field).carrier)
@@ -526,11 +547,13 @@ let unaddr_of_struct_field
       q == ref_focus p (struct_field tag fields field))
     (ensures fun h _ h' -> 
       excluded field == true /\
-      extract_field tag fields (remove field excluded) field
-        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))
-       ==
-        (h (p `pts_to_view` struct_view tag fields excluded),
-         h (q `pts_to_view` (fields.get_field field).view)))
+      fst (extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded))))
+       == h (p `pts_to_view` struct_view tag fields excluded)
+        /\
+        snd (extract_field tag fields (remove field excluded) field
+        (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))) ==
+         h (q `pts_to_view` (fields.get_field field).view))
 =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q

From be7a64de497c6c4a857999081de78cfcf1d36329 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 12 Aug 2021 15:02:13 -0700
Subject: [PATCH 211/513] Fix(hopefully) extraction for arrays, implementing
 the proper rules for pointer decay

---
 examples/steel/arraystructs/ScalarUnion.fst   |  26 +-
 examples/steel/arraystructs/Steel.C.Array.fst |   4 -
 .../steel/arraystructs/Steel.C.Array.fsti     |   9 +-
 .../steel/arraystructs/Steel.C.Fields.fsti    |   9 +-
 .../arraystructs/Steel.C.UnionLiteral.fsti    |   1 +
 src/extraction/FStar.Extraction.Kremlin.fs    | 295 ++++++++++--------
 6 files changed, 203 insertions(+), 141 deletions(-)

diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index f1a80d8fc9c..8fe22516d58 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -3,6 +3,7 @@ module ScalarUnion
 open Steel.C.PCM
 open Steel.C.Opt
 open Steel.C.Connection
+open Steel.C.StructLiteral
 open Steel.C.UnionLiteral
 open Steel.C.Typedef
 open FStar.FunctionalExtensionality
@@ -14,6 +15,7 @@ open Steel.C.Reference
 
 open FStar.FSet
 open Typestring
+open Typenat
 
 module U32 = FStar.UInt32
 module U16 = FStar.UInt16
@@ -65,7 +67,27 @@ let u32_or_u16_pcm = union_pcm u32_or_u16_tag u32_or_u16_fields
 noextract inline_for_extraction
 let c_u32_or_u16: typedef = typedef_union u32_or_u16_tag u32_or_u16_fields
 
-let _ = normalize (mk_c_union u32_or_u16_tag u32_or_u16_fields)
+noextract
+unfold let norm_list =
+  [delta_only
+    [`%mk_c_union;
+     `%mk_c_struct;
+     `%c_fields_t;
+     `%List.Tot.fold_right;
+     `%Typestring.mk_string_t;
+     `%Typestring.string_t_of_chars;
+     `%Typestring.char_t_of_char;
+     `%Mkc_fields?.get_field;
+     `%Mkc_fields?.cfields;
+     `%Mktypedef?.view_type;
+     `%fields_cons;
+     `%fields_nil;
+     `%Typenat.nat_t_of_nat;
+     ];
+   delta_attr [`%c_struct; `%c_typedef];
+   iota; zeta; primops]
+
+let _ = norm norm_list (mk_c_union u32_or_u16_tag u32_or_u16_fields)
 
 #push-options "--fuel 0"
 
@@ -100,7 +122,7 @@ let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
   (fun _ -> p `pts_to_view` opt_view _)
   (requires fun _ -> True)
   (ensures fun _ _ _ -> True)
-= opt_write_sel p U32.zero
+= opt_write_sel p 0ul
 
 val zero_u32_of_union (p: ref unit u32_or_u16 u32_or_u16_pcm)
 : Steel unit
diff --git a/examples/steel/arraystructs/Steel.C.Array.fst b/examples/steel/arraystructs/Steel.C.Array.fst
index 3ac9b1d12cd..cc18cf407dd 100644
--- a/examples/steel/arraystructs/Steel.C.Array.fst
+++ b/examples/steel/arraystructs/Steel.C.Array.fst
@@ -28,10 +28,6 @@ let array_elements_pcm
 
 let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
 
-let array_view_type_sized t n' n = array_view_type t n
-
-let unfold_array_view_type_sized t n' n = ()
-
 [@"opaque_to_smt"]
 let rec raise_list_array_domain
   (t: Type u#0)
diff --git a/examples/steel/arraystructs/Steel.C.Array.fsti b/examples/steel/arraystructs/Steel.C.Array.fsti
index c73580fe2d7..fda07fde22c 100644
--- a/examples/steel/arraystructs/Steel.C.Array.fsti
+++ b/examples/steel/arraystructs/Steel.C.Array.fsti
@@ -24,6 +24,7 @@ open Steel.Effect.Atomic
 
 open Steel.C.Typedef
 open Steel.C.PCM
+open Steel.C.Fields
 open Typenat
 
 #set-options "--ide_id_info_off"
@@ -43,12 +44,9 @@ let array_view_type (t: Type u#0) (n: size_t)
 /// A variant of array_view_type, which records the length of the
 /// array in Type as a Typenat, for extraction
 let size_t_of (n': Type u#0) = n:size_t{n' == nat_t_of_nat (size_v n)}
-val array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
+let array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
 : Type u#0
-val unfold_array_view_type_sized
- (t: Type u#0) (n': Type u#0) (n: size_t_of n')
-: Lemma (array_view_type_sized t n' n == array_view_type t n)
-  [SMTPat (array_view_type_sized t n' n)]
+= array_view_type t n
 
 val array_view (t: Type u#0) (n: size_t)
   : Pure (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
@@ -68,6 +66,7 @@ let length (#base: Type) (#t: Type) (a: array base t) : GTot nat = size_v (len a
 val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
 : b:bool{b <==> a == one (array_pcm t n)}
 
+[@@c_struct]
 let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}): typedef = {
   carrier = array_pcm_carrier t n;
   pcm = array_pcm t n;
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index 923df94e43d..fd15f4052a6 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -8,6 +8,11 @@ open Steel.C.Opt
 
 module TS = Typestring
 
+irreducible let c_struct = ()
+irreducible let c_union = ()
+irreducible let c_typedef = ()
+
+[@@c_typedef]
 let trivial_typedef: typedef = {
   carrier = option unit;
   pcm = opt_pcm #unit;
@@ -78,10 +83,6 @@ let fields_cons (field: field_t) (td: typedef) (fields: c_fields): c_fields = {
 
 let field_of (fields: c_fields) = field:string{fields.has_field field == true /\ field =!= ""}
 
-irreducible let c_struct = ()
-irreducible let c_union = ()
-irreducible let c_typedef = ()
-
 unfold let unfold_typedefs = [delta_attr [`%c_typedef]]
 
 unfold let simplify_typedefs =
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index a829b2b1d64..59faa7d60c3 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -179,6 +179,7 @@ let switch_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
+  // TODO match order of c to get p->field = new_value
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 078539810d5..0f12cab2be6 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -319,6 +319,26 @@ let string_of_typestring (t: mlty): option<string> =
   in
   opt_bind (go t) (fun ss -> Some (FStar.String.concat "" ss))
 
+let int_of_typenat (t: mlty): option<int> =
+  let rec go t =
+    match t with
+    | MLTY_Named ([], p)
+      when Syntax.string_of_mlpath p = "Typenat.z"
+      ->
+      Some 0
+
+    | MLTY_Named ([t], p)
+      when Syntax.string_of_mlpath p = "Typenat.s"
+      ->
+      opt_bind (go t) (fun n -> Some (n + 1))
+
+    | _ ->
+      BU.print1 "int_of_typenat: got bad type %s\n"
+        (ML.Code.string_of_mlty ([], "") t); // JL: TODO: delete
+      None
+  in
+  go t
+
 (* Environments **************************************************************)
 
 type env = {
@@ -599,15 +619,18 @@ and translate_type_decl env ty: option<decl> =
 
       | Some fields ->
           print_endline "Got fields:";
-          // Unlike in arguments, fixed-size arrays in structs do not decay to pointers
+          // JL: TODO: deduplicate with translate_type, e.g. by making
+          // translate_type take extra argument indicating whether or
+          // not to decay outermost array type constructor application
           let rec translate_field_type env ty =
             match ty with
             | MLTY_Named ([t; n; _], p)
               when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
               // TODO add support for fixed-size arrays to Steel.C.Array.fsti
               ->
-                let int_of_typenat s = failwith "unimplemented" in // TODO
-                TArray (translate_field_type env t, (UInt32, int_of_typenat n))
+                TArray (
+                  translate_field_type env t,
+                  (UInt32, string_of_int (must (int_of_typenat n))))
             | t -> translate_type env t
           in
           List.fold_left
@@ -707,130 +730,150 @@ and translate_type_decl env ty: option<decl> =
         None
 
 and translate_type env t: typ =
+  let rec translate_type env t =
+    match t with
+    | MLTY_Tuple []
+    | MLTY_Top ->
+        TAny
+    | MLTY_Var name ->
+        TBound (find_t env name)
+    | MLTY_Fun (t1, _, t2) ->
+        TArrow (translate_type env t1, translate_type env t2)
+    | MLTY_Erased ->
+        TUnit
+    | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.unit") ->
+        TUnit
+    | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.bool") ->
+        TBool
+    | MLTY_Named ([], ([ "FStar"; m ], "t")) when is_machine_int m ->
+        TInt (must (mk_width m))
+    | MLTY_Named ([], ([ "FStar"; m ], "t'")) when is_machine_int m ->
+        TInt (must (mk_width m))
+    | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
+        TUnit
+  
+    | MLTY_Named ([tag; _; _], p) when
+      BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
+      ->
+        TQualified (env.module_name, must (string_of_typestring tag))
+        // JL: TODO env.module_name or (fst p)?
+  
+    | MLTY_Named ([tag; _], p) when
+      BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
+      ->
+        TQualified (env.module_name, must (string_of_typestring tag))
+        // JL: TODO env.module_name or (fst p)?
+  
+    | MLTY_Named ([_; arg; _; _], p) when
+      Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
+      ->
+        TBuf (translate_type env arg)
+        
+    | MLTY_Named ([t; n; s], p)
+      when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
+      ->
+        print_endline "parsing int_of_typenat"; // JL: TODO: delete
+        BU.print1 "n = %s\n" (ML.Code.string_of_mlty ([], "") n); // JL: TODO: delete
+        BU.print1 "ty = %s\n" (ML.Code.string_of_mlty ([], "") (MLTY_Named ([t; n; s], p))); // JL: TODO: delete
+        let n' = (must (int_of_typenat n)) in
+        print_endline "got int: "; // JL: TODO: delete
+        print_endline (string_of_int n'); // JL: TODO: delete
+        TArray (
+          translate_type env t,
+          (UInt32, string_of_int (must (int_of_typenat n))))
+  
+    | MLTY_Named ([_; arg], p) when
+      Syntax.string_of_mlpath p = "Steel.C.Array.array"
+      ->
+        TBuf (translate_type env arg)
+  
+    | MLTY_Named ([_; arg; _], p) when
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.m_rref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_mref"
+      ->
+        TBuf (translate_type env arg)
+  
+    | MLTY_Named ([arg; _], p) when
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mreference" ||
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mstackref" ||
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mref" ||
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmstackref" ||
+      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmref" ||
+      Syntax.string_of_mlpath p = "FStar.Monotonic.Heap.mref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mreference" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mstackref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmstackref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmref"
+      ->
+        TBuf (translate_type env arg)
+  
+    | MLTY_Named ([arg; _; _], p) when
+      Syntax.string_of_mlpath p = "LowStar.Monotonic.Buffer.mbuffer" -> TBuf (translate_type env arg)
+  
+    | MLTY_Named ([arg], p) when
+      Syntax.string_of_mlpath p = "LowStar.ConstBuffer.const_buffer" -> TConstBuf (translate_type env arg)
+  
+    | MLTY_Named ([arg], p) when
+      Syntax.string_of_mlpath p = "FStar.Buffer.buffer" ||
+      Syntax.string_of_mlpath p = "LowStar.Buffer.buffer" ||
+      Syntax.string_of_mlpath p = "LowStar.ImmutableBuffer.ibuffer" ||
+      Syntax.string_of_mlpath p = "LowStar.UninitializedBuffer.ubuffer" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.reference" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.stackref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.mmstackref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.mmref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.reference" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.stackref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.ref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmstackref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmref" ||
+      Syntax.string_of_mlpath p = "Steel.Reference.ref" ||
+      Syntax.string_of_mlpath p = "Steel.Array.array"
+      ->
+        TBuf (translate_type env arg)
+  
+    | MLTY_Named ([_;arg], p) when
+      Syntax.string_of_mlpath p = "FStar.HyperStack.s_ref" ||
+      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_ref"
+      ->
+        TBuf (translate_type env arg)
+  
+    | MLTY_Named ([_], p) when (Syntax.string_of_mlpath p = "FStar.Ghost.erased") ->
+        TAny
+  
+    | MLTY_Named ([], (path, type_name)) ->
+        // Generate an unbound reference... to be filled in later by glue code.
+        TQualified (path, type_name)
+  
+    | MLTY_Named (args, (ns, t)) when (ns = ["Prims"] || ns = ["FStar"; "Pervasives"; "Native"]) && BU.starts_with t "tuple" ->
+        TTuple (List.map (translate_type env) args)
+  
+    | MLTY_Named (args, lid) ->
+        if List.length args > 0 then
+          TApp (lid, List.map (translate_type env) args)
+        else
+          TQualified lid
+  
+    | MLTY_Tuple ts ->
+        TTuple (List.map (translate_type env) ts)
+  in
+  // The outermost array type constructor decays to pointer
   match t with
-  | MLTY_Tuple []
-  | MLTY_Top ->
-      TAny
-  | MLTY_Var name ->
-      TBound (find_t env name)
-  | MLTY_Fun (t1, _, t2) ->
-      TArrow (translate_type env t1, translate_type env t2)
-  | MLTY_Erased ->
-      TUnit
-  | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.unit") ->
-      TUnit
-  | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.bool") ->
-      TBool
-  | MLTY_Named ([], ([ "FStar"; m ], "t")) when is_machine_int m ->
-      TInt (must (mk_width m))
-  | MLTY_Named ([], ([ "FStar"; m ], "t'")) when is_machine_int m ->
-      TInt (must (mk_width m))
-  | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
-      TUnit
-
-  | MLTY_Named ([tag; _; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
-    ->
-      TQualified (env.module_name, must (string_of_typestring tag))
-      // JL: TODO env.module_name or (fst p)?
-
-  | MLTY_Named ([tag; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
-    ->
-      TQualified (env.module_name, must (string_of_typestring tag))
-      // JL: TODO env.module_name or (fst p)?
-
-  | MLTY_Named ([_; arg; _; _], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
-    ->
-      let rec skip_array_view_types ty =
-        match ty with
-        | MLTY_Named ([ty; _; _], p) when
-          Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
-          ->
-            skip_array_view_types ty
-        | _ -> ty
-      in
-      TBuf (translate_type env (skip_array_view_types arg))
-
-  | MLTY_Named ([_; arg], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Array.array"
+  | MLTY_Named ([t; _; _], p)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
     ->
-      TBuf (translate_type env arg)
-
-  | MLTY_Named ([_; arg; _], p) when
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.m_rref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_mref"
-    ->
-      TBuf (translate_type env arg)
-
-  | MLTY_Named ([arg; _], p) when
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mreference" ||
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mstackref" ||
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mref" ||
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmstackref" ||
-    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmref" ||
-    Syntax.string_of_mlpath p = "FStar.Monotonic.Heap.mref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mreference" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mstackref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmstackref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmref"
-    ->
-      TBuf (translate_type env arg)
-
-  | MLTY_Named ([arg; _; _], p) when
-    Syntax.string_of_mlpath p = "LowStar.Monotonic.Buffer.mbuffer" -> TBuf (translate_type env arg)
-
-  | MLTY_Named ([arg], p) when
-    Syntax.string_of_mlpath p = "LowStar.ConstBuffer.const_buffer" -> TConstBuf (translate_type env arg)
-
-  | MLTY_Named ([arg], p) when
-    Syntax.string_of_mlpath p = "FStar.Buffer.buffer" ||
-    Syntax.string_of_mlpath p = "LowStar.Buffer.buffer" ||
-    Syntax.string_of_mlpath p = "LowStar.ImmutableBuffer.ibuffer" ||
-    Syntax.string_of_mlpath p = "LowStar.UninitializedBuffer.ubuffer" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.reference" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.stackref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.mmstackref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.mmref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.reference" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.stackref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.ref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmstackref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmref" ||
-    Syntax.string_of_mlpath p = "Steel.Reference.ref" ||
-    Syntax.string_of_mlpath p = "Steel.Array.array"
-    ->
-      TBuf (translate_type env arg)
-
-  | MLTY_Named ([_;arg], p) when
-    Syntax.string_of_mlpath p = "FStar.HyperStack.s_ref" ||
-    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_ref"
+      TBuf (translate_type env t)
+      
+  | MLTY_Named ([t; _], p)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type"
     ->
-      TBuf (translate_type env arg)
-
-  | MLTY_Named ([_], p) when (Syntax.string_of_mlpath p = "FStar.Ghost.erased") ->
-      TAny
-
-  | MLTY_Named ([], (path, type_name)) ->
-      // Generate an unbound reference... to be filled in later by glue code.
-      TQualified (path, type_name)
-
-  | MLTY_Named (args, (ns, t)) when (ns = ["Prims"] || ns = ["FStar"; "Pervasives"; "Native"]) && BU.starts_with t "tuple" ->
-      TTuple (List.map (translate_type env) args)
-
-  | MLTY_Named (args, lid) ->
-      if List.length args > 0 then
-        TApp (lid, List.map (translate_type env) args)
-      else
-        TQualified lid
-
-  | MLTY_Tuple ts ->
-      TTuple (List.map (translate_type env) ts)
+      TBuf (translate_type env t)
+      
+  | t -> translate_type env t
 
 and translate_binders env args =
   List.map (translate_binder env) args
@@ -1245,9 +1288,9 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.C.Array.mk_array_of_ref" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; r; _])
     when string_of_mlpath p = "Steel.C.Array.intro_varray" ->
-      translate_expr env r
+      EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; i])
     when string_of_mlpath p = "Steel.C.Array.index" ->

From 163a31adf339743191eb9e87319d63db1a32ff45 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 08:41:59 -0700
Subject: [PATCH 212/513] Extraction of split_left, split_right, joinc

---
 .../steel/arraystructs/Steel.C.Array.fsti     |   6 +-
 src/extraction/FStar.Extraction.Kremlin.fs    | 268 +++++++++---------
 2 files changed, 136 insertions(+), 138 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Array.fsti b/examples/steel/arraystructs/Steel.C.Array.fsti
index fda07fde22c..2b4f1689170 100644
--- a/examples/steel/arraystructs/Steel.C.Array.fsti
+++ b/examples/steel/arraystructs/Steel.C.Array.fsti
@@ -200,7 +200,7 @@ val split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
             s == sl `Seq.append` sr
           )
 
-val split_left (#opened: _) (#base: _) (#t:Type) (a:array base t) (i:size_t)
+val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
@@ -211,7 +211,7 @@ val split_left (#opened: _) (#base: _) (#t:Type) (a:array base t) (i:size_t)
             res == fst (gsplit a i)
           )
 
-val split_right (#opened: _) (#base: _) (#t:Type) (a:array base t) (i:size_t)
+val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
@@ -233,7 +233,7 @@ val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
             merge_into al ar a
           )
 
-val joinc (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+val joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray al `star` varray ar)
           (fun a -> varray al `star` varray ar)
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 0f12cab2be6..40c9be28ca4 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -619,20 +619,6 @@ and translate_type_decl env ty: option<decl> =
 
       | Some fields ->
           print_endline "Got fields:";
-          // JL: TODO: deduplicate with translate_type, e.g. by making
-          // translate_type take extra argument indicating whether or
-          // not to decay outermost array type constructor application
-          let rec translate_field_type env ty =
-            match ty with
-            | MLTY_Named ([t; n; _], p)
-              when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
-              // TODO add support for fixed-size arrays to Steel.C.Array.fsti
-              ->
-                TArray (
-                  translate_field_type env t,
-                  (UInt32, string_of_int (must (int_of_typenat n))))
-            | t -> translate_type env t
-          in
           List.fold_left
             (fun () (field, ty) ->
                BU.print2 "  %s : %s\n"
@@ -645,7 +631,7 @@ and translate_type_decl env ty: option<decl> =
               (fun (field, ty) ->
                  BU.print1 "Translating %s.\n"
                    (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
-                 (field, translate_field_type env ty))
+                 (field, translate_type_without_decay env ty))
               fields)
     in
     match ty with
@@ -729,151 +715,151 @@ and translate_type_decl env ty: option<decl> =
         Errors. log_issue Range.dummyRange (Errors.Warning_DefinitionNotTranslated, (BU.format1 "Error extracting type definition %s to KreMLin\n" name));
         None
 
-and translate_type env t: typ =
-  let rec translate_type env t =
-    match t with
-    | MLTY_Tuple []
-    | MLTY_Top ->
-        TAny
-    | MLTY_Var name ->
-        TBound (find_t env name)
-    | MLTY_Fun (t1, _, t2) ->
-        TArrow (translate_type env t1, translate_type env t2)
-    | MLTY_Erased ->
-        TUnit
-    | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.unit") ->
-        TUnit
-    | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.bool") ->
-        TBool
-    | MLTY_Named ([], ([ "FStar"; m ], "t")) when is_machine_int m ->
-        TInt (must (mk_width m))
-    | MLTY_Named ([], ([ "FStar"; m ], "t'")) when is_machine_int m ->
-        TInt (must (mk_width m))
-    | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
-        TUnit
+and translate_type_without_decay env t: typ =
+  match t with
+  | MLTY_Tuple []
+  | MLTY_Top ->
+      TAny
+  | MLTY_Var name ->
+      TBound (find_t env name)
+  | MLTY_Fun (t1, _, t2) ->
+      TArrow (translate_type_without_decay env t1, translate_type_without_decay env t2)
+  | MLTY_Erased ->
+      TUnit
+  | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.unit") ->
+      TUnit
+  | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.bool") ->
+      TBool
+  | MLTY_Named ([], ([ "FStar"; m ], "t")) when is_machine_int m ->
+      TInt (must (mk_width m))
+  | MLTY_Named ([], ([ "FStar"; m ], "t'")) when is_machine_int m ->
+      TInt (must (mk_width m))
+  | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
+      TUnit
   
-    | MLTY_Named ([tag; _; _], p) when
-      BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
-      ->
-        TQualified (env.module_name, must (string_of_typestring tag))
-        // JL: TODO env.module_name or (fst p)?
+  | MLTY_Named ([tag; _; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
+    ->
+      TQualified (env.module_name, must (string_of_typestring tag))
+      // JL: TODO env.module_name or (fst p)?
   
-    | MLTY_Named ([tag; _], p) when
-      BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
-      ->
-        TQualified (env.module_name, must (string_of_typestring tag))
-        // JL: TODO env.module_name or (fst p)?
+  | MLTY_Named ([tag; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
+    ->
+      TQualified (env.module_name, must (string_of_typestring tag))
+      // JL: TODO env.module_name or (fst p)?
   
-    | MLTY_Named ([_; arg; _; _], p) when
-      Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
-      ->
-        TBuf (translate_type env arg)
-        
-    | MLTY_Named ([t; n; s], p)
-      when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
-      ->
-        print_endline "parsing int_of_typenat"; // JL: TODO: delete
-        BU.print1 "n = %s\n" (ML.Code.string_of_mlty ([], "") n); // JL: TODO: delete
-        BU.print1 "ty = %s\n" (ML.Code.string_of_mlty ([], "") (MLTY_Named ([t; n; s], p))); // JL: TODO: delete
-        let n' = (must (int_of_typenat n)) in
-        print_endline "got int: "; // JL: TODO: delete
-        print_endline (string_of_int n'); // JL: TODO: delete
-        TArray (
-          translate_type env t,
-          (UInt32, string_of_int (must (int_of_typenat n))))
+  | MLTY_Named ([_; arg; _; _], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
+    ->
+      TBuf (translate_type_without_decay env arg)
+      
+  | MLTY_Named ([t; n; s], p)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
+    ->
+      print_endline "parsing int_of_typenat"; // JL: TODO: delete
+      BU.print1 "n = %s\n" (ML.Code.string_of_mlty ([], "") n); // JL: TODO: delete
+      BU.print1 "ty = %s\n" (ML.Code.string_of_mlty ([], "") (MLTY_Named ([t; n; s], p))); // JL: TODO: delete
+      let n' = (must (int_of_typenat n)) in
+      print_endline "got int: "; // JL: TODO: delete
+      print_endline (string_of_int n'); // JL: TODO: delete
+      TArray (
+        translate_type_without_decay env t,
+        (UInt32, string_of_int (must (int_of_typenat n))))
   
-    | MLTY_Named ([_; arg], p) when
-      Syntax.string_of_mlpath p = "Steel.C.Array.array"
-      ->
-        TBuf (translate_type env arg)
+  | MLTY_Named ([_; arg], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Array.array"
+    ->
+      TBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([_; arg; _], p) when
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.m_rref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_mref"
-      ->
-        TBuf (translate_type env arg)
+  | MLTY_Named ([_; arg; _], p) when
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.m_rref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_mref"
+    ->
+      TBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([arg; _], p) when
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mreference" ||
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mstackref" ||
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mref" ||
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmstackref" ||
-      Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmref" ||
-      Syntax.string_of_mlpath p = "FStar.Monotonic.Heap.mref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mreference" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mstackref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmstackref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmref"
-      ->
-        TBuf (translate_type env arg)
+  | MLTY_Named ([arg; _], p) when
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mreference" ||
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mstackref" ||
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mref" ||
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmstackref" ||
+    Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mmmref" ||
+    Syntax.string_of_mlpath p = "FStar.Monotonic.Heap.mref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mreference" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mstackref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmstackref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmref"
+    ->
+      TBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([arg; _; _], p) when
-      Syntax.string_of_mlpath p = "LowStar.Monotonic.Buffer.mbuffer" -> TBuf (translate_type env arg)
+  | MLTY_Named ([arg; _; _], p) when
+    Syntax.string_of_mlpath p = "LowStar.Monotonic.Buffer.mbuffer" -> TBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([arg], p) when
-      Syntax.string_of_mlpath p = "LowStar.ConstBuffer.const_buffer" -> TConstBuf (translate_type env arg)
+  | MLTY_Named ([arg], p) when
+    Syntax.string_of_mlpath p = "LowStar.ConstBuffer.const_buffer" -> TConstBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([arg], p) when
-      Syntax.string_of_mlpath p = "FStar.Buffer.buffer" ||
-      Syntax.string_of_mlpath p = "LowStar.Buffer.buffer" ||
-      Syntax.string_of_mlpath p = "LowStar.ImmutableBuffer.ibuffer" ||
-      Syntax.string_of_mlpath p = "LowStar.UninitializedBuffer.ubuffer" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.reference" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.stackref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.mmstackref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.mmref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.reference" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.stackref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.ref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmstackref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmref" ||
-      Syntax.string_of_mlpath p = "Steel.Reference.ref" ||
-      Syntax.string_of_mlpath p = "Steel.Array.array"
-      ->
-        TBuf (translate_type env arg)
+  | MLTY_Named ([arg], p) when
+    Syntax.string_of_mlpath p = "FStar.Buffer.buffer" ||
+    Syntax.string_of_mlpath p = "LowStar.Buffer.buffer" ||
+    Syntax.string_of_mlpath p = "LowStar.ImmutableBuffer.ibuffer" ||
+    Syntax.string_of_mlpath p = "LowStar.UninitializedBuffer.ubuffer" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.reference" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.stackref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.mmstackref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.mmref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.reference" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.stackref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.ref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmstackref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmref" ||
+    Syntax.string_of_mlpath p = "Steel.Reference.ref" ||
+    Syntax.string_of_mlpath p = "Steel.Array.array"
+    ->
+      TBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([_;arg], p) when
-      Syntax.string_of_mlpath p = "FStar.HyperStack.s_ref" ||
-      Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_ref"
-      ->
-        TBuf (translate_type env arg)
+  | MLTY_Named ([_;arg], p) when
+    Syntax.string_of_mlpath p = "FStar.HyperStack.s_ref" ||
+    Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_ref"
+    ->
+      TBuf (translate_type_without_decay env arg)
   
-    | MLTY_Named ([_], p) when (Syntax.string_of_mlpath p = "FStar.Ghost.erased") ->
-        TAny
+  | MLTY_Named ([_], p) when (Syntax.string_of_mlpath p = "FStar.Ghost.erased") ->
+      TAny
   
-    | MLTY_Named ([], (path, type_name)) ->
-        // Generate an unbound reference... to be filled in later by glue code.
-        TQualified (path, type_name)
+  | MLTY_Named ([], (path, type_name)) ->
+      // Generate an unbound reference... to be filled in later by glue code.
+      TQualified (path, type_name)
   
-    | MLTY_Named (args, (ns, t)) when (ns = ["Prims"] || ns = ["FStar"; "Pervasives"; "Native"]) && BU.starts_with t "tuple" ->
-        TTuple (List.map (translate_type env) args)
+  | MLTY_Named (args, (ns, t)) when (ns = ["Prims"] || ns = ["FStar"; "Pervasives"; "Native"]) && BU.starts_with t "tuple" ->
+      TTuple (List.map (translate_type_without_decay env) args)
   
-    | MLTY_Named (args, lid) ->
-        if List.length args > 0 then
-          TApp (lid, List.map (translate_type env) args)
-        else
-          TQualified lid
+  | MLTY_Named (args, lid) ->
+      if List.length args > 0 then
+        TApp (lid, List.map (translate_type_without_decay env) args)
+      else
+        TQualified lid
   
-    | MLTY_Tuple ts ->
-        TTuple (List.map (translate_type env) ts)
-  in
+  | MLTY_Tuple ts ->
+      TTuple (List.map (translate_type_without_decay env) ts)
+  
+and translate_type env t: typ =
   // The outermost array type constructor decays to pointer
   match t with
   | MLTY_Named ([t; _; _], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
     ->
-      TBuf (translate_type env t)
+      TBuf (translate_type_without_decay env t)
       
   | MLTY_Named ([t; _], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type"
     ->
-      TBuf (translate_type env t)
+      TBuf (translate_type_without_decay env t)
       
-  | t -> translate_type env t
+  | t -> translate_type_without_decay env t
 
 and translate_binders env args =
   List.map (translate_binder env) args
@@ -1300,6 +1286,18 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.C.Array.upd" ->
       EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
+    when string_of_mlpath p = "Steel.C.Array.split_left" ->
+      translate_expr env a
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
+    when string_of_mlpath p = "Steel.C.Array.split_right" ->
+      EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; al; ar])
+    when string_of_mlpath p = "Steel.C.Array.joinc" ->
+      translate_expr env al
+
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)
 

From 62aa50c4f438206fc28ce7648293a1632f2bddc1 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 08:42:10 -0700
Subject: [PATCH 213/513] Add HaclExample.fst

---
 examples/steel/arraystructs/HaclExample.fst | 138 ++++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 examples/steel/arraystructs/HaclExample.fst

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
new file mode 100644
index 00000000000..d7b94d3fdbc
--- /dev/null
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -0,0 +1,138 @@
+module HaclExample
+
+open Steel.C.PCM
+open Steel.C.Opt
+open Steel.C.Connection
+open Steel.C.StructLiteral
+open Steel.C.Array
+open Steel.C.Typedef
+open FStar.FunctionalExtensionality
+open Steel.Effect
+open Steel.Effect.Atomic
+open Steel.C.Fields
+open Steel.C.Ref
+open Steel.C.Reference
+
+open FStar.FSet
+open Typenat
+open Typestring
+
+module U64 = FStar.UInt64
+
+[@@c_typedef]
+noextract inline_for_extraction
+let u64: typedef = {
+  carrier = option U64.t;
+  pcm = opt_pcm #U64.t;
+  view_type = U64.t;
+  view = opt_view U64.t;
+  is_unit = (fun x -> None? x);
+}
+
+module T = FStar.Tactics
+
+noextract inline_for_extraction
+//[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
+//     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
+let comp_tag = normalize (mk_string_t "comp")
+
+module U32 = FStar.UInt32
+
+#push-options "--z3rlimit 30 --fuel 30"
+noextract inline_for_extraction let five' = normalize (nat_t_of_nat 5)
+noextract inline_for_extraction let five: size_t_of five' = mk_size_t (U32.uint_to_t 5)
+noextract inline_for_extraction let twenty' = normalize (nat_t_of_nat 20)
+noextract inline_for_extraction let twenty: size_t_of twenty' = mk_size_t (U32.uint_to_t 20)
+#pop-options
+
+[@@c_struct]
+noextract inline_for_extraction
+let five_u64s: typedef = array_typedef_sized U64.t five' five
+
+[@@c_struct]
+noextract inline_for_extraction
+let twenty_u64s: typedef = array_typedef_sized U64.t twenty' twenty
+
+[@@c_struct]//;c_typedef]
+noextract inline_for_extraction
+let comp_fields: c_fields =
+  fields_cons "limbs" five_u64s (
+  fields_cons "precomp" twenty_u64s (
+  fields_nil))
+
+noextract inline_for_extraction
+let comp = struct comp_tag comp_fields
+
+noextract inline_for_extraction
+let comp_view = struct_view comp_tag comp_fields
+
+noextract inline_for_extraction
+let comp_pcm = struct_pcm comp_tag comp_fields
+
+[@@c_typedef]
+noextract inline_for_extraction
+let c_comp: typedef = typedef_struct comp_tag comp_fields
+
+noextract
+unfold let norm_list =
+  [delta_only
+    [`%mk_c_struct;
+     `%c_fields_t;
+     `%List.Tot.fold_right;
+     `%Typestring.mk_string_t;
+     `%Typestring.string_t_of_chars;
+     `%Typestring.char_t_of_char;
+     `%Mkc_fields?.get_field;
+     `%Mkc_fields?.cfields;
+     `%Mktypedef?.view_type;
+     `%fields_cons;
+     `%fields_nil;
+     `%nat_t_of_nat;
+     ];
+   delta_attr [`%c_struct; `%c_typedef];
+   iota; zeta; primops]
+
+//let x : unit -> norm norm_list (mk_c_struct comp_tag comp_fields) = fun _ -> admit(); magic()
+let _ = norm norm_list (mk_c_struct comp_tag comp_fields)
+
+let do_something_with_limbs
+  (a: array 'a U64.t)
+: Steel unit
+    (varray a)
+    (fun _ -> varray a)
+    (requires fun _ -> length a == 5)
+    (ensures fun _ _ _ -> True)
+= return ()
+
+let do_something_with_precomp
+  (a: array 'a U64.t)
+: Steel unit
+    (varray a)
+    (fun _ -> varray a)
+    (requires fun _ -> length a == 20)
+    (ensures fun _ _ _ -> True)
+= return ()
+
+#push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 30"
+
+let test
+  (p: ref unit comp comp_pcm) // TODO unit
+: SteelT unit
+    (p `pts_to_view` comp_view emptyset)
+    (fun _ -> p `pts_to_view` comp_view emptyset)
+= let q = //: ref _ (array_view_type_sized U64.t five' five) _ =
+    addr_of_struct_field "limbs" p
+  in
+  let a = intro_varray q () in
+  let r = addr_of_struct_field "precomp" p in
+  let b = intro_varray r () in
+  do_something_with_limbs a;
+  do_something_with_precomp b;
+  elim_varray q a ();
+  elim_varray r b ();
+  unaddr_of_struct_field "precomp" p r;
+  unaddr_of_struct_field "limbs" p q;
+  change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+  return ()
+
+#pop-options

From 25e11bb9ee4c7b12dc3ad0bd712da97874d2a447 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 09:02:28 -0700
Subject: [PATCH 214/513] Tidy

---
 examples/steel/arraystructs/HaclExample.fst   | 22 ++----------------
 examples/steel/arraystructs/PointStruct.fst   | 15 +++---------
 examples/steel/arraystructs/ScalarUnion.fst   | 23 ++-----------------
 .../steel/arraystructs/Steel.C.Typedef.fst    |  2 --
 4 files changed, 7 insertions(+), 55 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index d7b94d3fdbc..5be5b5af913 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -12,6 +12,7 @@ open Steel.Effect.Atomic
 open Steel.C.Fields
 open Steel.C.Ref
 open Steel.C.Reference
+open Steel.C.TypedefNorm
 
 open FStar.FSet
 open Typenat
@@ -73,27 +74,8 @@ let comp_pcm = struct_pcm comp_tag comp_fields
 noextract inline_for_extraction
 let c_comp: typedef = typedef_struct comp_tag comp_fields
 
-noextract
-unfold let norm_list =
-  [delta_only
-    [`%mk_c_struct;
-     `%c_fields_t;
-     `%List.Tot.fold_right;
-     `%Typestring.mk_string_t;
-     `%Typestring.string_t_of_chars;
-     `%Typestring.char_t_of_char;
-     `%Mkc_fields?.get_field;
-     `%Mkc_fields?.cfields;
-     `%Mktypedef?.view_type;
-     `%fields_cons;
-     `%fields_nil;
-     `%nat_t_of_nat;
-     ];
-   delta_attr [`%c_struct; `%c_typedef];
-   iota; zeta; primops]
-
 //let x : unit -> norm norm_list (mk_c_struct comp_tag comp_fields) = fun _ -> admit(); magic()
-let _ = norm norm_list (mk_c_struct comp_tag comp_fields)
+let _ = norm norm_c_typedef (mk_c_struct comp_tag comp_fields)
 
 let do_something_with_limbs
   (a: array 'a U64.t)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 4f848b6bb8e..d106d213283 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -11,6 +11,7 @@ open Steel.Effect
 open Steel.Effect.Atomic
 open Steel.C.Fields
 open Steel.C.Reference
+open Steel.C.TypedefNorm
 
 open FStar.FSet
 open Typestring
@@ -56,7 +57,7 @@ let point_pcm = struct_pcm point_tag point_fields
 noextract inline_for_extraction
 let c_point: typedef = typedef_struct point_tag point_fields
 
-let _ = normalize (mk_c_struct point_tag point_fields)
+let _ = norm norm_c_typedef (mk_c_struct point_tag point_fields)
 
 noextract inline_for_extraction
 let line_fields_second_half: c_fields =
@@ -65,17 +66,7 @@ let line_fields_second_half: c_fields =
 noextract inline_for_extraction
 let line_tag = normalize (mk_string_t "line")
 
-unfold let norm_list =
-  [delta_only
-    [`%mk_c_struct;
-     `%c_fields_t;
-     `%List.Tot.fold_right;
-     `%Typestring.mk_string_t;
-     `%c_struct;
-     ];
-   iota; zeta; primops]
-
-let _ = normalize (mk_c_struct line_tag (fields_cons "first" c_point line_fields_second_half))
+let _ = norm norm_c_typedef (mk_c_struct line_tag (fields_cons "first" c_point line_fields_second_half))
 
 #push-options "--fuel 0"
 
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index 8fe22516d58..7ebe742b651 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -12,6 +12,7 @@ open Steel.Effect.Atomic
 open Steel.C.Fields
 open Steel.C.Ref
 open Steel.C.Reference
+open Steel.C.TypedefNorm
 
 open FStar.FSet
 open Typestring
@@ -67,27 +68,7 @@ let u32_or_u16_pcm = union_pcm u32_or_u16_tag u32_or_u16_fields
 noextract inline_for_extraction
 let c_u32_or_u16: typedef = typedef_union u32_or_u16_tag u32_or_u16_fields
 
-noextract
-unfold let norm_list =
-  [delta_only
-    [`%mk_c_union;
-     `%mk_c_struct;
-     `%c_fields_t;
-     `%List.Tot.fold_right;
-     `%Typestring.mk_string_t;
-     `%Typestring.string_t_of_chars;
-     `%Typestring.char_t_of_char;
-     `%Mkc_fields?.get_field;
-     `%Mkc_fields?.cfields;
-     `%Mktypedef?.view_type;
-     `%fields_cons;
-     `%fields_nil;
-     `%Typenat.nat_t_of_nat;
-     ];
-   delta_attr [`%c_struct; `%c_typedef];
-   iota; zeta; primops]
-
-let _ = norm norm_list (mk_c_union u32_or_u16_tag u32_or_u16_fields)
+let _ = norm norm_c_typedef (mk_c_union u32_or_u16_tag u32_or_u16_fields)
 
 #push-options "--fuel 0"
 
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/examples/steel/arraystructs/Steel.C.Typedef.fst
index 66ad2dfc536..2948da6c44f 100644
--- a/examples/steel/arraystructs/Steel.C.Typedef.fst
+++ b/examples/steel/arraystructs/Steel.C.Typedef.fst
@@ -16,5 +16,3 @@ noeq type typedef = {
   view: sel_view pcm view_type false;
   is_unit: x:carrier -> b:bool{b <==> x == one pcm};
 } 
-
-let register_typedef_of (_: Type0) = typedef

From 3e15ac42fafdc510a98c8473b476c979c832374b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 12:11:55 -0700
Subject: [PATCH 215/513] Fix namespacing of struct/union tags

---
 examples/steel/arraystructs/HaclExample.fst |  23 +++--
 examples/steel/arraystructs/PointStruct.fst |   4 +-
 examples/steel/arraystructs/ScalarUnion.fst |   2 +-
 examples/steel/arraystructs/Typestring.fst  | 101 +++++++++++++-------
 examples/steel/arraystructs/Typestring.fsti |  54 +++++++++++
 src/extraction/FStar.Extraction.Kremlin.fs  |  52 ++++++----
 6 files changed, 169 insertions(+), 67 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index 5be5b5af913..ade8b6dbb57 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -4,15 +4,16 @@ open Steel.C.PCM
 open Steel.C.Opt
 open Steel.C.Connection
 open Steel.C.StructLiteral
-open Steel.C.Array
 open Steel.C.Typedef
 open FStar.FunctionalExtensionality
 open Steel.Effect
 open Steel.Effect.Atomic
 open Steel.C.Fields
+open Steel.C.Opt
 open Steel.C.Ref
 open Steel.C.Reference
 open Steel.C.TypedefNorm
+open Steel.C.Array
 
 open FStar.FSet
 open Typenat
@@ -35,7 +36,7 @@ module T = FStar.Tactics
 noextract inline_for_extraction
 //[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
 //     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
-let comp_tag = normalize (mk_string_t "comp")
+let comp_tag = normalize (mk_string_t "HaclExample.comp")
 
 module U32 = FStar.UInt32
 
@@ -84,7 +85,14 @@ let do_something_with_limbs
     (fun _ -> varray a)
     (requires fun _ -> length a == 5)
     (ensures fun _ _ _ -> True)
-= return ()
+= // let alar = split a (mk_size_t (U32.uint_to_t 1)) in
+  // let q = split_left a (mk_size_t (U32.uint_to_t 1)) in
+  // let p = ref_of_array q in
+  // p `opt_write_sel` (U64.uint_to_t 0);
+  // array_of_ref q p;
+  // join' (GPair?.fst alar) (GPair?.snd alar);
+  upd a (mk_size_t (U32.uint_to_t 2)) (U64.uint_to_t 0);
+  return ()
 
 let do_something_with_precomp
   (a: array 'a U64.t)
@@ -93,18 +101,17 @@ let do_something_with_precomp
     (fun _ -> varray a)
     (requires fun _ -> length a == 20)
     (ensures fun _ _ _ -> True)
-= return ()
+= upd a (mk_size_t (U32.uint_to_t 19)) (U64.uint_to_t 0);
+  return ()
 
 #push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 30"
 
 let test
-  (p: ref unit comp comp_pcm) // TODO unit
+  (p: ref 'a comp comp_pcm)
 : SteelT unit
     (p `pts_to_view` comp_view emptyset)
     (fun _ -> p `pts_to_view` comp_view emptyset)
-= let q = //: ref _ (array_view_type_sized U64.t five' five) _ =
-    addr_of_struct_field "limbs" p
-  in
+= let q = addr_of_struct_field "limbs" p in
   let a = intro_varray q () in
   let r = addr_of_struct_field "precomp" p in
   let b = intro_varray r () in
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index d106d213283..a4f1cf824c2 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -35,7 +35,7 @@ module T = FStar.Tactics
 noextract inline_for_extraction
 //[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
 //     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
-let point_tag = normalize (mk_string_t "point")
+let point_tag = normalize (mk_string_t "PointStruct.point")
 
 [@@c_struct]
 noextract inline_for_extraction
@@ -64,7 +64,7 @@ let line_fields_second_half: c_fields =
   fields_cons "second" c_point fields_nil
 
 noextract inline_for_extraction
-let line_tag = normalize (mk_string_t "line")
+let line_tag = normalize (mk_string_t "PointStruct.line")
 
 let _ = norm norm_c_typedef (mk_c_struct line_tag (fields_cons "first" c_point line_fields_second_half))
 
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index 7ebe742b651..7f52475d08c 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -46,7 +46,7 @@ module T = FStar.Tactics
 noextract inline_for_extraction
 //[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
 //     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
-let u32_or_u16_tag = normalize (mk_string_t "u32_or_u16")
+let u32_or_u16_tag = normalize (mk_string_t "ScalarUnion.u32_or_u16")
 
 [@@c_struct]
 noextract inline_for_extraction
diff --git a/examples/steel/arraystructs/Typestring.fst b/examples/steel/arraystructs/Typestring.fst
index 958b71a3194..416b46b2b85 100644
--- a/examples/steel/arraystructs/Typestring.fst
+++ b/examples/steel/arraystructs/Typestring.fst
@@ -1,42 +1,69 @@
 module Typestring
 
-let a: Type0 = unit
-let b: Type0 = unit
-let c: Type0 = unit
-let d: Type0 = unit
-let e: Type0 = unit
-let f: Type0 = unit
-let g: Type0 = unit
-let h: Type0 = unit
-let i: Type0 = unit
-let j: Type0 = unit
-let k: Type0 = unit
-let l: Type0 = unit
-let m: Type0 = unit
-let n: Type0 = unit
-let o: Type0 = unit
-let p: Type0 = unit
-let q: Type0 = unit
-let r: Type0 = unit
-let s: Type0 = unit
-let t: Type0 = unit
-let u: Type0 = unit
-let v: Type0 = unit
-let w: Type0 = unit
-let x: Type0 = unit
-let y: Type0 = unit
-let z: Type0 = unit
-let zero: Type0 = unit
-let one: Type0 = unit
-let two: Type0 = unit
-let three: Type0 = unit
-let four: Type0 = unit
-let five: Type0 = unit
-let six: Type0 = unit
-let seven: Type0 = unit
-let eight: Type0 = unit
-let nine: Type0 = unit
-let underscore: Type0 = unit
+let ca: Type0 = unit
+let cb: Type0 = unit
+let cc: Type0 = unit
+let cd: Type0 = unit
+let ce: Type0 = unit
+let cf: Type0 = unit
+let cg: Type0 = unit
+let ch: Type0 = unit
+let ci: Type0 = unit
+let cj: Type0 = unit
+let ck: Type0 = unit
+let cl: Type0 = unit
+let cm: Type0 = unit
+let cn: Type0 = unit
+let co: Type0 = unit
+let cp: Type0 = unit
+let cq: Type0 = unit
+let cr: Type0 = unit
+let cs: Type0 = unit
+let ct: Type0 = unit
+let cu: Type0 = unit
+let cv: Type0 = unit
+let cw: Type0 = unit
+let cx: Type0 = unit
+let cy: Type0 = unit
+let cz: Type0 = unit
+let cA: Type0 = unit
+let cB: Type0 = unit
+let cC: Type0 = unit
+let cD: Type0 = unit
+let cE: Type0 = unit
+let cF: Type0 = unit
+let cG: Type0 = unit
+let cH: Type0 = unit
+let cI: Type0 = unit
+let cJ: Type0 = unit
+let cK: Type0 = unit
+let cL: Type0 = unit
+let cM: Type0 = unit
+let cN: Type0 = unit
+let cO: Type0 = unit
+let cP: Type0 = unit
+let cQ: Type0 = unit
+let cr: Type0 = unit
+let cS: Type0 = unit
+let cT: Type0 = unit
+let cU: Type0 = unit
+let cV: Type0 = unit
+let cW: Type0 = unit
+let cX: Type0 = unit
+let cY: Type0 = unit
+let cZ: Type0 = unit
+let c0: Type0 = unit
+let c1: Type0 = unit
+let c2: Type0 = unit
+let c3: Type0 = unit
+let c4: Type0 = unit
+let c5: Type0 = unit
+let c6: Type0 = unit
+let c7: Type0 = unit
+let c8: Type0 = unit
+let c9: Type0 = unit
+let c_: Type0 = unit
+let cdot: Type0 = unit
 
 let string_nil: Type0 = unit
 let string_cons (c: Type0) (s: Type0): Type0 = unit
diff --git a/examples/steel/arraystructs/Typestring.fsti b/examples/steel/arraystructs/Typestring.fsti
index 457a4b50035..874e03f0e9c 100644
--- a/examples/steel/arraystructs/Typestring.fsti
+++ b/examples/steel/arraystructs/Typestring.fsti
@@ -26,6 +26,32 @@ val cw: Type0
 val cx: Type0
 val cy: Type0
 val cz: Type0
+val cA: Type0
+val cB: Type0
+val cC: Type0
+val cD: Type0
+val cE: Type0
+val cF: Type0
+val cG: Type0
+val cH: Type0
+val cI: Type0
+val cJ: Type0
+val cK: Type0
+val cL: Type0
+val cM: Type0
+val cN: Type0
+val cO: Type0
+val cP: Type0
+val cQ: Type0
+val cR: Type0
+val cS: Type0
+val cT: Type0
+val cU: Type0
+val cV: Type0
+val cW: Type0
+val cX: Type0
+val cY: Type0
+val cZ: Type0
 val c0: Type0
 val c1: Type0
 val c2: Type0
@@ -37,6 +63,7 @@ val c7: Type0
 val c8: Type0
 val c9: Type0
 val c_: Type0
+val cdot: Type0
 
 val string_nil: Type0
 val string_cons (c: Type0) (s: Type0): Type0
@@ -71,6 +98,32 @@ let char_t_of_char (c: char): Type0 =
   | 'x' -> cx
   | 'y' -> cy
   | 'z' -> cz
+  | 'A' -> cA
+  | 'B' -> cB
+  | 'C' -> cC
+  | 'D' -> cD
+  | 'E' -> cE
+  | 'F' -> cF
+  | 'G' -> cG
+  | 'H' -> cH
+  | 'I' -> cI
+  | 'J' -> cJ
+  | 'K' -> cK
+  | 'L' -> cL
+  | 'M' -> cM
+  | 'N' -> cN
+  | 'O' -> cO
+  | 'P' -> cP
+  | 'Q' -> cQ
+  | 'R' -> cR
+  | 'S' -> cS
+  | 'T' -> cT
+  | 'U' -> cU
+  | 'V' -> cV
+  | 'W' -> cW
+  | 'X' -> cX
+  | 'Y' -> cY
+  | 'Z' -> cZ
   | '0' -> c0
   | '1' -> c1
   | '2' -> c2
@@ -82,6 +135,7 @@ let char_t_of_char (c: char): Type0 =
   | '8' -> c8
   | '9' -> c9
   | '_' -> c_
+  | '.' -> cdot
   | _ -> c_
   
 let rec string_t_of_chars (s: list char): Type0 =
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 40c9be28ca4..8f492c46e07 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -293,7 +293,9 @@ let char_of_typechar (t: mlty): option<char> =
   match t with
   | MLTY_Named ([], p) ->
     let p = Syntax.string_of_mlpath p in
-    if BU.starts_with p "Typestring.c" then
+    if p = "Typestring.cdot" then
+      Some '.'
+    else if BU.starts_with p "Typestring.c" then
       Some (FStar.String.get p (FStar.String.strlen "Typestring.c"))
     else
       None
@@ -319,6 +321,20 @@ let string_of_typestring (t: mlty): option<string> =
   in
   opt_bind (go t) (fun ss -> Some (FStar.String.concat "" ss))
 
+let lident_of_string (s: string): option<lident> =
+  let path = FStar.String.split ['.'] s in
+  let rec go p =
+    match p with
+    | [] -> None
+    | [s] -> Some ([], s)
+    | s :: p ->
+      opt_bind (go p) (fun (names, name) ->
+      Some (s :: names, name))
+  in go path
+
+let lident_of_typestring (t: mlty): option<lident> =
+  opt_bind (string_of_typestring t) lident_of_string
+
 let int_of_typenat (t: mlty): option<int> =
   let rec go t =
     match t with
@@ -641,16 +657,15 @@ and translate_type_decl env ty: option<decl> =
       begin
         (* JL: TODO remove/improve these print commands *)
         print_endline "Parsing struct definition.";
-        begin match string_of_typestring tag with
+        begin match lident_of_typestring tag with
         | None ->
           BU.print1 "Failed to parse struct tag from %s.\n"
             (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
           None
-        | Some tag ->
+        | Some p ->
           let fields = must (parse_fields fields) in
-          Some (DTypeFlat ((env.module_name, tag), [], 0,
+          Some (DTypeFlat (p, [], 0,
             List.map (fun (field, ty) -> (field, (ty, true))) fields))
-          // JL: TODO: fix module name
         end
       end
 
@@ -660,15 +675,14 @@ and translate_type_decl env ty: option<decl> =
       begin
         (* JL: TODO remove/improve these print commands *)
         print_endline "Parsing union definition.";
-        begin match string_of_typestring tag with
+        begin match lident_of_typestring tag with
         | None ->
           BU.print1 "Failed to parse struct tag from %s.\n"
             (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
           None
-        | Some tag ->
+        | Some p ->
           let fields = must (parse_fields fields) in
-          Some (DUntaggedUnion ((env.module_name, tag), [], 0, fields))
-          // JL: TODO: fix module name
+          Some (DUntaggedUnion (p, [], 0, fields))
         end
       end
 
@@ -740,14 +754,12 @@ and translate_type_without_decay env t: typ =
   | MLTY_Named ([tag; _; _], p) when
     BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
     ->
-      TQualified (env.module_name, must (string_of_typestring tag))
-      // JL: TODO env.module_name or (fst p)?
+      TQualified (must (lident_of_typestring tag))
   
   | MLTY_Named ([tag; _], p) when
     BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
     ->
-      TQualified (env.module_name, must (string_of_typestring tag))
-      // JL: TODO env.module_name or (fst p)?
+      TQualified (must (lident_of_typestring tag))
   
   | MLTY_Named ([_; arg; _; _], p) when
     Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
@@ -1230,28 +1242,25 @@ and translate_expr env e: expr =
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
              [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-      let struct_name = must (string_of_typestring struct_name) in
       EAddrOf (EField (
-        TQualified (env.module_name, struct_name), // JL: TODO env.module_name or (fst p)?
+        TQualified (must (lident_of_typestring struct_name)),
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-      let union_name = must (string_of_typestring union_name) in
       EAddrOf (EField (
-        TQualified (env.module_name, union_name), // JL: TODO env.module_name or (fst p)?
+        TQualified (must (lident_of_typestring union_name)),
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; new_value; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.switch_union_field'" ->
-      let union_name = must (string_of_typestring union_name) in
       EAssign (
         EField (
-          TQualified (env.module_name, union_name), // JL: TODO env.module_name or (fst p)?
+          TQualified (must (lident_of_typestring union_name)),
           EBufRead (translate_expr env r, EConstant (UInt32, "0")),
           field_name),
         translate_expr env new_value)
@@ -1298,6 +1307,11 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.C.Array.joinc" ->
       translate_expr env al
 
+  (* Operations on Steel.C.StdInt *)
+  | MLE_App ({expr=MLE_Name p}, [i])
+    when string_of_mlpath p = "Steel.C.StdInt.mk_size_t" ->
+      translate_expr env i
+
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)
 

From fcd8491763ac8714a075a116ca9191181967fd58 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 12:15:20 -0700
Subject: [PATCH 216/513] Tidy

---
 src/extraction/FStar.Extraction.Kremlin.fs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 8f492c46e07..49a9e6da9fe 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -349,8 +349,6 @@ let int_of_typenat (t: mlty): option<int> =
       opt_bind (go t) (fun n -> Some (n + 1))
 
     | _ ->
-      BU.print1 "int_of_typenat: got bad type %s\n"
-        (ML.Code.string_of_mlty ([], "") t); // JL: TODO: delete
       None
   in
   go t
@@ -769,12 +767,6 @@ and translate_type_without_decay env t: typ =
   | MLTY_Named ([t; n; s], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
     ->
-      print_endline "parsing int_of_typenat"; // JL: TODO: delete
-      BU.print1 "n = %s\n" (ML.Code.string_of_mlty ([], "") n); // JL: TODO: delete
-      BU.print1 "ty = %s\n" (ML.Code.string_of_mlty ([], "") (MLTY_Named ([t; n; s], p))); // JL: TODO: delete
-      let n' = (must (int_of_typenat n)) in
-      print_endline "got int: "; // JL: TODO: delete
-      print_endline (string_of_int n'); // JL: TODO: delete
       TArray (
         translate_type_without_decay env t,
         (UInt32, string_of_int (must (int_of_typenat n))))

From 53d93b0285f61ac8549cdc42a7b6f674c4b9a068 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 13:57:33 -0700
Subject: [PATCH 217/513] Typenat -> Steel.C.Typenat; Typestring ->
 Steel.C.Typestring

---
 examples/steel/arraystructs/HaclExample.fst        |  4 ++--
 examples/steel/arraystructs/PointStruct.fst        |  2 +-
 examples/steel/arraystructs/ScalarUnion.fst        |  4 ++--
 examples/steel/arraystructs/Steel.C.Array.fsti     |  4 ++--
 examples/steel/arraystructs/Steel.C.Fields.fsti    |  2 +-
 examples/steel/arraystructs/Steel.C.Ref.fst        |  3 ++-
 .../steel/arraystructs/Steel.C.StructLiteral.fst   | 12 ++++++++----
 .../steel/arraystructs/Steel.C.StructLiteral.fsti  |  2 +-
 examples/steel/arraystructs/Steel.C.Typenat.fst    |  4 ++++
 examples/steel/arraystructs/Steel.C.Typenat.fsti   |  9 +++++++++
 .../{Typestring.fst => Steel.C.Typestring.fst}     |  2 +-
 .../{Typestring.fsti => Steel.C.Typestring.fsti}   |  2 +-
 .../steel/arraystructs/Steel.C.UnionLiteral.fst    |  2 +-
 .../steel/arraystructs/Steel.C.UnionLiteral.fsti   |  2 +-
 src/extraction/FStar.Extraction.Kremlin.fs         | 14 +++++++-------
 15 files changed, 43 insertions(+), 25 deletions(-)
 create mode 100644 examples/steel/arraystructs/Steel.C.Typenat.fst
 create mode 100644 examples/steel/arraystructs/Steel.C.Typenat.fsti
 rename examples/steel/arraystructs/{Typestring.fst => Steel.C.Typestring.fst} (98%)
 rename examples/steel/arraystructs/{Typestring.fsti => Steel.C.Typestring.fsti} (98%)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index ade8b6dbb57..fe45269d080 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -16,8 +16,8 @@ open Steel.C.TypedefNorm
 open Steel.C.Array
 
 open FStar.FSet
-open Typenat
-open Typestring
+open Steel.C.Typenat
+open Steel.C.Typestring
 
 module U64 = FStar.UInt64
 
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index a4f1cf824c2..e55ffe77977 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -14,7 +14,7 @@ open Steel.C.Reference
 open Steel.C.TypedefNorm
 
 open FStar.FSet
-open Typestring
+open Steel.C.Typestring
 
 module U32 = FStar.UInt32
 
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index 7f52475d08c..56722c3dbee 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -15,8 +15,8 @@ open Steel.C.Reference
 open Steel.C.TypedefNorm
 
 open FStar.FSet
-open Typestring
-open Typenat
+open Steel.C.Typestring
+open Steel.C.Typenat
 
 module U32 = FStar.UInt32
 module U16 = FStar.UInt16
diff --git a/examples/steel/arraystructs/Steel.C.Array.fsti b/examples/steel/arraystructs/Steel.C.Array.fsti
index 2b4f1689170..41243c529eb 100644
--- a/examples/steel/arraystructs/Steel.C.Array.fsti
+++ b/examples/steel/arraystructs/Steel.C.Array.fsti
@@ -25,7 +25,7 @@ open Steel.Effect.Atomic
 open Steel.C.Typedef
 open Steel.C.PCM
 open Steel.C.Fields
-open Typenat
+open Steel.C.Typenat
 
 #set-options "--ide_id_info_off"
 
@@ -42,7 +42,7 @@ let array_view_type (t: Type u#0) (n: size_t)
   Seq.lseq t (size_v n)
 
 /// A variant of array_view_type, which records the length of the
-/// array in Type as a Typenat, for extraction
+/// array in Type as a Steel.C.Typenat, for extraction
 let size_t_of (n': Type u#0) = n:size_t{n' == nat_t_of_nat (size_v n)}
 let array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
 : Type u#0
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/examples/steel/arraystructs/Steel.C.Fields.fsti
index fd15f4052a6..437248ea0c1 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fsti
+++ b/examples/steel/arraystructs/Steel.C.Fields.fsti
@@ -6,7 +6,7 @@ open FStar.FunctionalExtensionality
 open Steel.C.Typedef
 open Steel.C.Opt
 
-module TS = Typestring
+module TS = Steel.C.Typestring
 
 irreducible let c_struct = ()
 irreducible let c_union = ()
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/examples/steel/arraystructs/Steel.C.Ref.fst
index 6a76b37dbdf..eff2e3cf733 100644
--- a/examples/steel/arraystructs/Steel.C.Ref.fst
+++ b/examples/steel/arraystructs/Steel.C.Ref.fst
@@ -178,7 +178,8 @@ let pts_to_view_explicit_witinv
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
-  (vw: sel_view p c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
 : Lemma
   (M.is_witness_invariant (pts_to_view_explicit r vw))
 = let aux (x y : Ghost.erased c) (m:M.mem)
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 8f7e4cc5a37..707e3d3e854 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -243,11 +243,15 @@ val addr_of_struct_field_ref'
     (ensures fun h q h' -> 
       not (excluded field) /\
       q == ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
+      fst (extract_field tag fields excluded field
+        (h (p `pts_to_view` struct_view tag fields excluded)))
        ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
+        h' (p `pts_to_view` struct_view tag fields (insert field excluded)) /\
+      snd
+        (extract_field tag fields excluded field
+          (h (p `pts_to_view` struct_view tag fields excluded)))
+       ==
+        h' (q `pts_to_view` (fields.get_field field).view))
 
 #push-options "--z3rlimit 30"
 let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 878ca78a93f..2f7762b9389 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -17,7 +17,7 @@ open FStar.List.Tot
 open FStar.FunctionalExtensionality
 open FStar.FSet
 
-module TS = Typestring
+module TS = Steel.C.Typestring
 
 (**** MOVE TO ChurchList *)
 
diff --git a/examples/steel/arraystructs/Steel.C.Typenat.fst b/examples/steel/arraystructs/Steel.C.Typenat.fst
new file mode 100644
index 00000000000..7b076707418
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Typenat.fst
@@ -0,0 +1,4 @@
+module Steel.C.Typenat
+
+let z = unit
+let s _ = unit
diff --git a/examples/steel/arraystructs/Steel.C.Typenat.fsti b/examples/steel/arraystructs/Steel.C.Typenat.fsti
new file mode 100644
index 00000000000..59b908d020b
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.Typenat.fsti
@@ -0,0 +1,9 @@
+module Steel.C.Typenat
+
+val z: Type0
+val s: Type0 -> Type0
+
+let rec nat_t_of_nat (n: nat): Type0 =
+  match n with
+  | 0 -> z
+  | n -> s (nat_t_of_nat (n - 1))
diff --git a/examples/steel/arraystructs/Typestring.fst b/examples/steel/arraystructs/Steel.C.Typestring.fst
similarity index 98%
rename from examples/steel/arraystructs/Typestring.fst
rename to examples/steel/arraystructs/Steel.C.Typestring.fst
index 416b46b2b85..44143adbcba 100644
--- a/examples/steel/arraystructs/Typestring.fst
+++ b/examples/steel/arraystructs/Steel.C.Typestring.fst
@@ -1,4 +1,4 @@
-module Typestring
+module Steel.C.Typestring
 
 let ca: Type0 = unit
 let cb: Type0 = unit
diff --git a/examples/steel/arraystructs/Typestring.fsti b/examples/steel/arraystructs/Steel.C.Typestring.fsti
similarity index 98%
rename from examples/steel/arraystructs/Typestring.fsti
rename to examples/steel/arraystructs/Steel.C.Typestring.fsti
index 874e03f0e9c..218ad05ada6 100644
--- a/examples/steel/arraystructs/Typestring.fsti
+++ b/examples/steel/arraystructs/Steel.C.Typestring.fsti
@@ -1,4 +1,4 @@
-module Typestring
+module Steel.C.Typestring
 
 val ca: Type0
 val cb: Type0
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index 2670b399360..50309d5610e 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -17,7 +17,7 @@ open FStar.List.Tot
 open FStar.FunctionalExtensionality
 open FStar.FSet
 
-module TS = Typestring
+module TS = Steel.C.Typestring
 
 let mk_union_def (tag: Type0) (field_descriptions: Type0): Type0 = unit
 
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
index 59faa7d60c3..e414f501ede 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
@@ -17,7 +17,7 @@ open FStar.List.Tot
 open FStar.FunctionalExtensionality
 open FStar.FSet
 
-module TS = Typestring
+module TS = Steel.C.Typestring
 
 val mk_union_def (tag: Type0) (field_descriptions: Type0): Type0
 
diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 49a9e6da9fe..eab1ffc1800 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -293,10 +293,10 @@ let char_of_typechar (t: mlty): option<char> =
   match t with
   | MLTY_Named ([], p) ->
     let p = Syntax.string_of_mlpath p in
-    if p = "Typestring.cdot" then
+    if p = "Steel.C.Typestring.cdot" then
       Some '.'
-    else if BU.starts_with p "Typestring.c" then
-      Some (FStar.String.get p (FStar.String.strlen "Typestring.c"))
+    else if BU.starts_with p "Steel.C.Typestring.c" then
+      Some (FStar.String.get p (FStar.String.strlen "Steel.C.Typestring.c"))
     else
       None
 
@@ -306,12 +306,12 @@ let string_of_typestring (t: mlty): option<string> =
   let rec go t: option<list<string>> =
     match t with
     | MLTY_Named ([], p)
-      when Syntax.string_of_mlpath p = "Typestring.string_nil"
+      when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_nil"
       ->
       Some []
 
     | MLTY_Named ([c; t], p)
-      when Syntax.string_of_mlpath p = "Typestring.string_cons"
+      when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_cons"
       ->
       opt_bind (char_of_typechar c) (fun c' ->
       opt_bind (go t) (fun s' ->
@@ -339,12 +339,12 @@ let int_of_typenat (t: mlty): option<int> =
   let rec go t =
     match t with
     | MLTY_Named ([], p)
-      when Syntax.string_of_mlpath p = "Typenat.z"
+      when Syntax.string_of_mlpath p = "Steel.C.Typenat.z"
       ->
       Some 0
 
     | MLTY_Named ([t], p)
-      when Syntax.string_of_mlpath p = "Typenat.s"
+      when Syntax.string_of_mlpath p = "Steel.C.Typenat.s"
       ->
       opt_bind (go t) (fun n -> Some (n + 1))
 

From 4ca3a65ab6cb53d4ccae67d30442a781a2650f47 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 13:59:07 -0700
Subject: [PATCH 218/513] Remove misc. examples of structs&unions

---
 examples/steel/arraystructs/IntOrBool.fst     | 113 ------
 examples/steel/arraystructs/IntOrBool.fsti    | 133 -------
 examples/steel/arraystructs/LList.fst         | 334 ------------------
 examples/steel/arraystructs/LineStruct.fst    |  85 -----
 examples/steel/arraystructs/LineStruct.fsti   |  62 ----
 examples/steel/arraystructs/ListExample.fst   | 147 --------
 .../steel/arraystructs/ListExampleOOM.fst     |  34 --
 examples/steel/arraystructs/ListNode.fst      | 286 ---------------
 examples/steel/arraystructs/ListNode.fsti     |  96 -----
 examples/steel/arraystructs/ListNodeOOM.fsti  |  51 ---
 10 files changed, 1341 deletions(-)
 delete mode 100644 examples/steel/arraystructs/IntOrBool.fst
 delete mode 100644 examples/steel/arraystructs/IntOrBool.fsti
 delete mode 100644 examples/steel/arraystructs/LList.fst
 delete mode 100644 examples/steel/arraystructs/LineStruct.fst
 delete mode 100644 examples/steel/arraystructs/LineStruct.fsti
 delete mode 100644 examples/steel/arraystructs/ListExample.fst
 delete mode 100644 examples/steel/arraystructs/ListExampleOOM.fst
 delete mode 100644 examples/steel/arraystructs/ListNode.fst
 delete mode 100644 examples/steel/arraystructs/ListNode.fsti
 delete mode 100644 examples/steel/arraystructs/ListNodeOOM.fsti

diff --git a/examples/steel/arraystructs/IntOrBool.fst b/examples/steel/arraystructs/IntOrBool.fst
deleted file mode 100644
index c5c8553fb7a..00000000000
--- a/examples/steel/arraystructs/IntOrBool.fst
+++ /dev/null
@@ -1,113 +0,0 @@
-module IntOrBool
-
-#push-options "--print_universes"
-
-open FStar.PCM
-open Steel.C.Opt
-open Steel.C.PCM
-open Steel.C.Ref
-open Steel.C.Connection
-open Steel.C.Union
-open Steel.Effect
-
-module M = Steel.Memory
-module A = Steel.Effect.Atomic
-module U = FStar.Universe
-
-let int_or_bool_cases k = match k with
-  | I -> option int
-  | B -> option bool
-  
-let int_or_bool_cases_pcm k: pcm (int_or_bool_cases k) = match k with
-  | I -> opt_pcm #int
-  | B -> opt_pcm #bool
-  
-let int_or_bool = union #int_or_bool_case #int_or_bool_cases int_or_bool_cases_pcm
-
-let int_or_bool_pcm: pcm int_or_bool = union_pcm int_or_bool_cases_pcm
-
-let mk_int i = Ghost.hide (field_to_union_f int_or_bool_cases_pcm I (Ghost.reveal i))
-let mk_bool b = Ghost.hide (field_to_union_f int_or_bool_cases_pcm B (Ghost.reveal b))
-
-let _i = union_field int_or_bool_cases_pcm I
-let _b = union_field int_or_bool_cases_pcm B
-
-open FStar.FunctionalExtensionality
-
-let case_of_int_or_bool u =
-  let k = case_of_union int_or_bool_cases_pcm u in
-  match k with
-  | Some I ->
-    assert (~ (Ghost.reveal u I == one (opt_pcm #int)));
-    assert (exists (x:int). (Ghost.reveal u I == Ghost.reveal (some (Ghost.hide x))));
-    assert (exists (x:int). (Ghost.reveal u I == Ghost.reveal (some (Ghost.hide x))) /\ u `feq` mk_int (Ghost.hide (Ghost.reveal (some (Ghost.hide x)))));
-    assert (exists i. u == mk_int i); k
-  | Some B -> 
-    assert (~ (Ghost.reveal u B == one (opt_pcm #bool)));
-    assert (exists (b:bool). Ghost.reveal u B == Ghost.reveal (some (Ghost.hide b)) /\ u `feq` mk_bool (Ghost.hide (Ghost.reveal (some (Ghost.hide b))))); k
-  | None -> None
-  
-let case_of_int_or_bool_int _ = ()
-let case_of_int_or_bool_bool _ = ()
-let case_of_int_or_bool_one = ()
-
-let mk_int_exclusive i = exclusive_union_intro int_or_bool_cases_pcm (mk_int i) I
-
-let mk_bool_exclusive b = exclusive_union_intro int_or_bool_cases_pcm (mk_bool b) B
-
-let get_int u = Ghost.reveal u I
-
-let get_bool u = Ghost.reveal u B
-
-let addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)
-: Steel (q:ref 'a (opt_pcm #int){q == ref_focus p _i})
-    (p `pts_to` mk_int i)
-    (fun q -> q `pts_to` i)
-    (requires fun _ -> ~ (i == none))
-    (ensures fun _ _ _ -> True)
-= addr_of_union_field p I (mk_int i)
-
-let unaddr_of_i (#i: Ghost.erased (option int)) (#opened: M.inames)
-  (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (opt_pcm #int){q == ref_focus p _i})
-= unaddr_of_union_field #_ #_ #_ #_ #(int_or_bool_cases_pcm) I q p i // FIXME: WHY WHY WHY wrong inference of the pcm function, inferred to a constant function due to the type of q
-
-let addr_of_b (#b: Ghost.erased (option bool)) (p: ref 'a int_or_bool_pcm)
-= addr_of_union_field p B (mk_bool b)
-
-let unaddr_of_b (#b: Ghost.erased (option bool)) (#opened: M.inames)
-  (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (opt_pcm #bool){q == ref_focus p _b})
-= unaddr_of_union_field #_ #_ #_ #_ #(int_or_bool_cases_pcm) B q p b // same here
-
-let switch_to_int_fpu (#u: Ghost.erased int_or_bool{exclusive int_or_bool_pcm (Ghost.reveal u)})
-  (p: ref 'a int_or_bool_pcm) (i: int)
-: frame_preserving_upd int_or_bool_pcm u (mk_int (some (Ghost.hide i)))
-= base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm I (Some i))
-
-let exclusive_not_unit (#u: Ghost.erased int_or_bool)
-: Lemma
-    (requires exclusive int_or_bool_pcm u)
-    (ensures Some? (case_of_int_or_bool u))
-    [SMTPat (exclusive int_or_bool_pcm u)]
-= is_unit int_or_bool_pcm (field_to_union_f int_or_bool_cases_pcm I (Some 42));
-  assert (~ (Ghost.reveal u == one int_or_bool_pcm))
-
-let switch_to_int (#u: Ghost.erased int_or_bool)
-  (p: ref 'a int_or_bool_pcm) (i: int)
-: Steel unit
-    (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_int (some i))
-    (requires fun _ -> exclusive int_or_bool_pcm u)
-    (ensures fun _ _ _ -> True)
-= ref_upd p _ _ (switch_to_int_fpu p i)
-
-let switch_to_bool (#u: Ghost.erased int_or_bool)
-  (p: ref 'a int_or_bool_pcm) (b: bool)
-: Steel unit
-    (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_bool (some (Ghost.hide b)))
-    (requires fun _ -> exclusive int_or_bool_pcm u)
-    (ensures fun _ _ _ -> True)
-= ref_upd p u (mk_bool (some (Ghost.hide b)))
-    (base_fpu int_or_bool_pcm u (field_to_union_f int_or_bool_cases_pcm B (Some b)))
diff --git a/examples/steel/arraystructs/IntOrBool.fsti b/examples/steel/arraystructs/IntOrBool.fsti
deleted file mode 100644
index ce97f08f2c7..00000000000
--- a/examples/steel/arraystructs/IntOrBool.fsti
+++ /dev/null
@@ -1,133 +0,0 @@
-module IntOrBool
-
-open FStar.PCM
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Ref
-open Steel.C.Connection
-open Steel.Effect
-module M = Steel.Memory
-module A = Steel.Effect.Atomic
-
-/// union int_or_bool { int i; bool b; };
-///
-/// PCM for int_or_bool:
-
-type int_or_bool_case = | I | B
-
-val int_or_bool: Type0
-
-/// PCM for node:
-
-val int_or_bool_pcm: pcm int_or_bool
-
-/// (mk_int i) represents (union int_or_bool){.i = i}
-/// (mk_bool b) represents (union int_or_bool){.b = b}
-
-val mk_int (i: Ghost.erased (option int)): Ghost.erased int_or_bool
-val mk_bool (b: Ghost.erased (option bool)): Ghost.erased int_or_bool
-
-/// Connections for cases
-
-val _i : int_or_bool_pcm `connection` opt_pcm #int
-val _b : int_or_bool_pcm `connection` opt_pcm #bool
-
-/// Getting the case of a union in GTot
-
-val case_of_int_or_bool (u: Ghost.erased int_or_bool):
-  Ghost (option int_or_bool_case)
-    (requires True)
-    (ensures fun k ->
-      match k with
-      | Some I -> exists i. u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))
-      | Some B -> exists b. u == mk_bool b /\ ~ (Ghost.reveal b == one (opt_pcm #bool))
-      | None -> Ghost.reveal u == one int_or_bool_pcm)
-      
-val case_of_int_or_bool_int (i: Ghost.erased (option int))
-: Lemma
-    (requires ~ (i == none))
-    (ensures case_of_int_or_bool (mk_int i) == Some I) [SMTPat (mk_int i)]
-
-val case_of_int_or_bool_bool (b: Ghost.erased (option bool))
-: Lemma
-    (requires ~ (b == none))
-    (ensures case_of_int_or_bool (mk_bool b) == Some B) [SMTPat (mk_bool b)]
-
-val case_of_int_or_bool_one
-: squash (case_of_int_or_bool (one int_or_bool_pcm) == None)
-
-val mk_int_exclusive (i: Ghost.erased (option int))
-: Lemma
-    (requires exclusive (opt_pcm #int) i /\ ~ (i == none))
-    (ensures exclusive int_or_bool_pcm (mk_int i))
-  [SMTPat (exclusive (opt_pcm #int) i)]
-
-val mk_bool_exclusive (b: Ghost.erased (option bool))
-: Lemma
-    (requires exclusive (opt_pcm #bool) b /\ ~ (b == none))
-    (ensures exclusive int_or_bool_pcm (mk_bool b))
-  [SMTPat (exclusive (opt_pcm #bool) b)]
-
-/// Getting the value inside a union of known case
-
-val get_int (u: Ghost.erased int_or_bool)
-: Ghost (option int)
-    (requires case_of_int_or_bool u == Some I)
-    (ensures fun i -> u == mk_int i /\ ~ (i == Ghost.reveal none))
-
-val get_bool (u: Ghost.erased int_or_bool)
-: Ghost (option bool)
-    (requires case_of_int_or_bool u == Some B)
-    (ensures fun b -> u == mk_bool b /\ ~ (b == Ghost.reveal none))
-
-/// Taking pointers to the i and b cases of an int_or_bool
-
-val addr_of_i (#i: Ghost.erased (option int)) (p: ref 'a int_or_bool_pcm)
-: Steel (q:ref 'a (opt_pcm #int){q == ref_focus p _i})
-    (p `pts_to` mk_int i)
-    (fun q -> q `pts_to` i)
-    (requires fun _ -> ~ (i == none))
-    (ensures fun _ _ _ -> True)
-
-val unaddr_of_i (#i: Ghost.erased (option int)) (#opened: M.inames)
-  (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (opt_pcm #int){q == ref_focus p _i})
-: A.SteelGhost unit opened
-    (q `pts_to` i)
-    (fun _ -> p `pts_to` mk_int i)
-    (requires fun _ -> ~ (i == none))
-    (ensures fun _ _ _ -> True)
-
-val addr_of_b (#b: Ghost.erased (option bool)) (p: ref 'a int_or_bool_pcm)
-: Steel (q:ref 'a (opt_pcm #bool){q == ref_focus p _b})
-    (p `pts_to` mk_bool b)
-    (fun q -> q `pts_to` b)
-    (requires fun _ -> ~ (b == none))
-    (ensures fun _ _ _ -> True)
-
-val unaddr_of_b (#b: Ghost.erased (option bool)) (#opened: M.inames)
-  (p: ref 'a int_or_bool_pcm)
-  (q: ref 'a (opt_pcm #bool){q == ref_focus p _b})
-: A.SteelGhost unit opened
-    (q `pts_to` b)
-    (fun _ -> p `pts_to` mk_bool b)
-    (requires fun _ -> ~ (b == none))
-    (ensures fun _ _ _ -> True)
-
-/// Switching the case
-
-val switch_to_int (#u: Ghost.erased int_or_bool)
-  (p: ref 'a int_or_bool_pcm) (i: int)
-: Steel unit
-    (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_int (some (Ghost.hide i)))
-    (requires fun _ -> exclusive int_or_bool_pcm u)
-    (ensures fun _ _ _ -> True)
-
-val switch_to_bool (#u: Ghost.erased int_or_bool)
-  (p: ref 'a int_or_bool_pcm) (b: bool)
-: Steel unit
-    (p `pts_to` u)
-    (fun _ -> p `pts_to` mk_bool (some (Ghost.hide b)))
-    (requires fun _ -> exclusive int_or_bool_pcm u)
-    (ensures fun _ _ _ -> True)
diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
deleted file mode 100644
index 478df77dee5..00000000000
--- a/examples/steel/arraystructs/LList.fst
+++ /dev/null
@@ -1,334 +0,0 @@
-module LList
-open Steel.Memory
-open Steel.Effect.Atomic
-open Steel.Effect
-
-module R = Steel.C.Ref
-open Steel.C.Ref
-open Steel.C.Ptr
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Connection
-
-/// TODO move and dedup with Steel.C.Ptr.fst
-
-let vpure_sel'
-  (p: prop)
-: Tot (selector' (squash p) (Steel.Memory.pure p))
-= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
-
-let vpure_sel
-  (p: prop)
-: Tot (selector (squash p) (Steel.Memory.pure p))
-= vpure_sel' p
-
-[@@ __steel_reduce__]
-let vpure'
-  (p: prop)
-: GTot vprop'
-= {
-  hp = Steel.Memory.pure p;
-  t = squash p;
-  sel = vpure_sel p;
-}
-
-[@@ __steel_reduce__]
-let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
-
-let intro_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    emp
-    (fun _ -> vpure p)
-    (fun _ -> p)
-    (fun _ _ h' -> p)
-=
-  change_slprop_rel
-    emp
-    (vpure p)
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m)
-
-let elim_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    (vpure p)
-    (fun _ -> emp)
-    (fun _ -> True)
-    (fun _ _ _ -> p)
-=
-  change_slprop_rel
-    (vpure p)
-    emp
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
-
-val unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
-: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
-
-let unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
-: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
-= let x: 'a = FStar.IndefiniteDescription.indefinite_description_tot 'a (fun _ -> True) in
-  change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
-  x
-
-// ----------------------------------------
-
-open ListNode
-
-let cell = int & ptr node node
-let cells = list cell
-
-let hd_node (l: cells): option node =
-  match l with
-  | (value, next) :: _ -> Some (mk_node (Some value) (Some next))
-  | [] -> None
-
-let pts_to_llist_tl (l:cells)
-  (pts_to_llist:(
-    p:ptr node node -> 
-    l':cells{List.length l' < List.length l} -> 
-    Tot vprop))
-: Tot vprop
-= match l with
-  | [] -> emp
-  | (value, next) :: tl -> next `pts_to_llist` tl
-
-let pts_to_llist_nullptr_condition (p: ptr node node) (l: cells)
-: Tot prop
-= p == nullptr <==> l == []
-
-let rec pts_to_llist (p:ptr node node) ([@@@smt_fallback] l:cells)
-: Tot vprop (decreases (List.length l))
-= vpure (pts_to_llist_nullptr_condition p l) `star`
-  pts_to_or_null p node_pcm (hd_node l) `star`
-  pts_to_llist_tl l pts_to_llist
-
-let unfold_pts_to_llist (#opened:inames) (p:ptr node node) (l:cells)
-: SteelGhost unit opened
-    (p `pts_to_llist` l)
-    (fun _ -> 
-      pts_to_or_null p node_pcm (hd_node l) `star`
-      pts_to_llist_tl l pts_to_llist)
-    (requires fun _ -> True)
-    (ensures fun _ _ _ -> pts_to_llist_nullptr_condition p l)
-= change_equal_slprop
-    (p `pts_to_llist` l)
-    (vpure (pts_to_llist_nullptr_condition p l) `star`
-     pts_to_or_null p node_pcm (hd_node l) `star`
-     pts_to_llist_tl l pts_to_llist);
-  elim_vpure _
-
-let fold_pts_to_llist (#opened:inames) (p:ptr node node) (l:cells)
-: SteelGhost unit opened
-    (pts_to_or_null p node_pcm (hd_node l) `star`
-     pts_to_llist_tl l pts_to_llist)
-    (fun _ -> p `pts_to_llist` l)
-    (requires fun _ -> pts_to_llist_nullptr_condition p l)
-    (ensures fun _ _ _ -> True)
-= intro_vpure (pts_to_llist_nullptr_condition p l);
-  change_equal_slprop
-    (vpure (pts_to_llist_nullptr_condition p l) `star`
-     pts_to_or_null p node_pcm (hd_node l) `star`
-     pts_to_llist_tl l pts_to_llist)
-    (p `pts_to_llist` l)
-
-let intro_pts_to_llist_nil #opened p
-: SteelGhost unit opened 
-    emp
-    (fun _ -> p `pts_to_llist` [])
-    (requires fun _ -> p == nullptr)
-    (ensures fun _ _ _ -> True)
-= intro_vpure (pts_to_llist_nullptr_condition p []);
-  intro_pts_to_or_null_nullptr #node node_pcm;
-  change_equal_slprop
-    (pts_to_or_null (nullptr #node) node_pcm (None))
-    (pts_to_or_null p node_pcm (hd_node ([] #cell)))
-
-let elim_pts_to_llist_nil #opened p
-: SteelGhost unit opened 
-    (p `pts_to_llist` [])
-    (fun _ -> emp)
-    (requires fun _ -> True)
-    (ensures fun _ _ _ -> p == nullptr)
-= change_equal_slprop
-    (p `pts_to_llist` [])
-    (vpure (pts_to_llist_nullptr_condition p []) `star`
-     pts_to_or_null p node_pcm None `star` emp);
-  elim_vpure (p == nullptr <==> [] #cell == []);
-  elim_pts_to_or_null_nullptr p
-
-let intro_pts_to_llist_cons #opened p value_next value next (l: Ghost.erased cells)
-: SteelGhost unit opened 
-    (pts_to p node_pcm value_next `star` (next `pts_to_llist` l))
-    (fun _ -> p `pts_to_llist` ((value, next) :: Ghost.reveal l))
-    (requires fun _ -> value_next == mk_node (some value) (some next))
-    (ensures fun _ _ _ -> p =!= nullptr)
-= change_equal_slprop
-    (pts_to p node_pcm value_next)
-    (pts_to p node_pcm (mk_node (some value) (some next)));
-  pts_to_nonnull p; assert (p =!= nullptr);
-  let l': Ghost.erased cells = Ghost.hide ((value, next) :: Ghost.reveal l) in
-  intro_vpure (p == nullptr <==> Ghost.reveal l' == []);
-  assert (hd_node l' == Some (mk_node (Some value) (Some next)));
-  intro_pts_to_or_null p;
-  change_equal_slprop (next `pts_to_llist` l) (pts_to_llist_tl l' pts_to_llist);
-  change_equal_slprop
-    (vpure (pts_to_llist_nullptr_condition p (Ghost.reveal l')) `star`
-     pts_to_or_null p node_pcm (hd_node l') `star`
-     pts_to_llist_tl l' pts_to_llist)
-    (p `pts_to_llist` _)
-
-[@@erasable]
-noeq type elim_pts_to_llist_cons_res = {
-  value: int;
-  next: ptr node node;
-  tl: cells;
-}
-
-let elim_pts_to_llist_cons #opened p (l: Ghost.erased cells)
-: SteelGhost elim_pts_to_llist_cons_res opened 
-    (p `pts_to_llist` l)
-    (fun res ->
-      pts_to p node_pcm (mk_node (some res.value) (some res.next)) `star`
-      (res.next `pts_to_llist` res.tl))
-    (requires fun _ -> p =!= nullptr)
-    (ensures fun _ res _ -> Ghost.reveal l == (res.value, res.next) :: res.tl)
-= change_equal_slprop (p `pts_to_llist` l)
-    (vpure (pts_to_llist_nullptr_condition p (Ghost.reveal l)) `star`
-     pts_to_or_null p node_pcm (hd_node l) `star`
-     pts_to_llist_tl l pts_to_llist);
-  elim_vpure (pts_to_llist_nullptr_condition p (Ghost.reveal l));
-  match Ghost.reveal l with
-  | [] -> unreachable (fun res -> Ghost.reveal l == (res.value, res.next) :: res.tl)
-  | (value, next) :: tl ->
-    assert (hd_node l == Some (mk_node (Some value) (Some next)));
-    let w = elim_pts_to_or_null p in
-    assert (Ghost.reveal w == mk_node (Some value) (Some next));
-    change_equal_slprop (pts_to_llist_tl l pts_to_llist) (next `pts_to_llist` tl);
-    {value; next; tl}
-
-let ptr a = ptr a a
-
-let intro_llist_nil ()
-: SteelT (ptr node) emp (fun p -> p `pts_to_llist` [])
-= let p = nullptr in
-  intro_pts_to_llist_nil p;
-  sladmit(); // TODO why
-  return p
-
-let rec values (l:cells) : GTot (list int) =
-  match l with
-  | [] -> []
-  | (value, _) :: tl -> Ghost.reveal value :: values tl
-
-#set-options "--ide_id_info_off"
-
-val push (p:ptr node) (l:Ghost.erased cells) (value:int)
-: Steel (ptr node & Ghost.erased cells)
-    (p `pts_to_llist` l)
-    (fun (p', l') -> p' `pts_to_llist` l')
-    (requires fun _ -> True)
-    (ensures fun _ (_, l') _ -> values l' == value :: values l)
-
-let push p l value =
-  let cell: int & ptr node = (value, p) in
-  let value_next: node = mk_node (Some value) (Some p) in
-  let r = ref_alloc node_pcm value_next in
-  let q = intro_pts_to r in
-  intro_pts_to_llist_cons q value_next value p l;
-  return (q, Ghost.hide (cell :: l))
-  
-let cells_set_hd x (l: cells) = match l with
-  | [] -> []
-  | (_, next) :: l' -> (x, next) :: l'
-
-val pts_to_llist_nullptr (#opened:inames) (p:ptr node) (l:Ghost.erased cells)
-: SteelGhost unit opened
-    (p `pts_to_llist` l) 
-    (fun _ -> p `pts_to_llist` l)
-    (requires fun _ -> p == nullptr)
-    (ensures fun _ _ _ -> Ghost.reveal l == [])
-
-let pts_to_llist_nullptr p l =
-  unfold_pts_to_llist p l;
-  assert (Ghost.reveal l == []);
-  fold_pts_to_llist p l
-
-(* Currently z3 is going through the lemma
-      refine value /\ refine next ==> refine (mk_node value next)
-   plus the fact that for our PCMs, ~ refine one.
-   If change refine predicate/drop the side condition ~ refine one, will 
-   need to expose the proper lemmas about mk_node in ListNode.fsti
-*)
-let nontrivial_fact_about_mk_node value next
-: Lemma (Ghost.reveal (mk_node (some value) (some next)) =!= one node_pcm)
-= ()
-
-val is_empty
-  (#l: Ghost.erased cells) (p: ptr node)
-: Steel bool
-    (p `pts_to_llist` l)
-    (fun _ -> p `pts_to_llist` l)
-    (requires fun _ -> True)
-    (ensures fun _ b _ -> b <==> p == nullptr)
-let is_empty #l p =
-  unfold_pts_to_llist p l;
-  let b = is_null p in
-  fold_pts_to_llist p l;
-  return b
-
-val set_first (p:ptr node) (l:Ghost.erased cells) (value:int)
-: SteelT unit
-    (p `pts_to_llist` l)
-    (fun _ -> p `pts_to_llist` cells_set_hd value l)
-
-val intro_pts_to_llist_cons' : #opened:inames ->
-      p: ptr node ->
-      value: int ->
-      next: ptr node ->
-      l: Ghost.erased cells
-    -> Steel.Effect.Atomic.SteelGhostT unit
-        opened
-        (star (pts_to p node_pcm (mk_node (some (Ghost.hide value)) (some (Ghost.hide next))))
-	  (pts_to_llist next l))
-        (fun _ ->
-            pts_to_llist p
-              (Ghost.hide (FStar.Pervasives.Native.Mktuple2 value next :: Ghost.reveal l)))
-
-let intro_pts_to_llist_cons' p value next l = 
-  intro_pts_to_llist_cons p
-    (mk_node (some (Ghost.hide value)) (some (Ghost.hide next))) 
-    value next l
-
-(* TODO move to Steel.C.Ptr? *)
-val intro_pts_to'
-  (#pb: pcm 'b) (#v: Ghost.erased 'b)
-  (r: ref 'a pb) (p: Steel.C.Ptr.ptr 'a 'b)
-: Steel unit
-    (r `R.pts_to` v)
-    (fun _ -> pts_to p pb v)
-    (requires fun _ -> p == vptr r)
-    (ensures fun _ _ _ -> True)
-
-let intro_pts_to' r p =
-  let p' = intro_pts_to r in
-  change_equal_slprop (pts_to p' _ _) (pts_to p _ _)
-
-let set_first p l new_value =
-  let b = is_empty p in
-  if b then begin
-    pts_to_llist_nullptr p l;
-    return ()
-  end else begin
-    let res = elim_pts_to_llist_cons p l in
-    let r = elim_pts_to p in
-    let r_value = addr_of_value r in
-    r_value `opt_write` new_value;
-    unaddr_of_value r r_value;
-    intro_pts_to' r p;
-    intro_pts_to_llist_cons' p new_value res.next res.tl;
-    return ()
-  end
diff --git a/examples/steel/arraystructs/LineStruct.fst b/examples/steel/arraystructs/LineStruct.fst
deleted file mode 100644
index 80633076063..00000000000
--- a/examples/steel/arraystructs/LineStruct.fst
+++ /dev/null
@@ -1,85 +0,0 @@
-module LineStruct
-
-open FStar.FunctionalExtensionality
-open Steel.C.PCM
-open Steel.C.Ref
-open Steel.C.Connection
-open Steel.C.Struct
-module A = Steel.Effect.Atomic
-
-/// Example 2: pointers to nested fields
-///
-/// Here's a struct representing a line segment by its two endpoints:
-///   struct line { struct point p1; struct point p2; };
-///
-/// Carrier of PCM for line:
-
-type line_field = | P1 | P2
-let line_fields k = match k with
-  | P1 -> point
-  | P2 -> point
-let line = restricted_t line_field line_fields
-
-/// PCM for line:
-
-let line_fields_pcm k : pcm (line_fields k) = match k with
-  | P1 -> point_pcm
-  | P2 -> point_pcm
-let line_pcm = prod_pcm line_fields_pcm
-
-/// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
-
-let mk_line_f (p1 p2: point) (k: line_field): line_fields k = match k with
-  | P1 -> p1
-  | P2 -> p2
-let mk_line p1 p2 =
-  Ghost.hide (on_domain line_field (mk_line_f (Ghost.reveal p1) (Ghost.reveal p2)))
-
-let _p1 = struct_field line_fields_pcm P1
-let _p2 = struct_field line_fields_pcm P2
-
-/// Taking pointers to the p1 and p2 fields of a line
-
-let line_without_p1 p1 p2
-: Lemma (struct_without_field line_fields_pcm P1 (mk_line p1 p2) `feq`
-         Ghost.reveal (mk_line (one point_pcm) p2))
-  [SMTPat (mk_line p1 p2)]
-= ()
-
-let line_with_p1 p1 p2
-: Lemma (struct_with_field line_fields_pcm P1 (Ghost.reveal p1) (mk_line (one point_pcm) p2) `feq`
-         Ghost.reveal (mk_line p1 p2))
-  [SMTPat (mk_line p1 p2)]
-= ()
-
-let line_without_p2 p1 p2
-: Lemma (struct_without_field line_fields_pcm P2 (mk_line p1 p2) `feq`
-         Ghost.reveal (mk_line p1 (one point_pcm)))
-  [SMTPat (mk_line p1 p2)]
-= ()
-
-let line_with_p2 p1 p2
-: Lemma (struct_with_field line_fields_pcm P2 (Ghost.reveal p2) (mk_line p1 (one point_pcm)) `feq`
-         Ghost.reveal (mk_line p1 p2))
-  [SMTPat (mk_line p1 p2)]
-= ()
-
-let addr_of_p1 #a #p1 #p2 p =
-  let q = addr_of_struct_field p P1 (mk_line p1 p2) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line (one point_pcm) p2);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p1);
-  A.return q
-
-let unaddr_of_p1 #a #p1 #p2 p q =
-  unaddr_of_struct_field #_ #_ #_ #line_fields_pcm P1 q p (mk_line (one point_pcm) p2) p1; // FIXME: WHY WHY WHY is inference not working well here? (inferred point_pcm instead: it seems that F* infers the constant function due to the type of q)
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_p2 #a #p1 #p2 p =
-  let q = addr_of_struct_field p P2 (mk_line p1 p2) in
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` mk_line p1 (one point_pcm));
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` p2);
-  A.return q
-
-let unaddr_of_p2 #a #p1 #p2 p q =
-  unaddr_of_struct_field #_ #_ #_ #line_fields_pcm P2 q (p <: ref _ (prod_pcm line_fields_pcm)) (mk_line p1 (one point_pcm)) p2; // same here
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/LineStruct.fsti b/examples/steel/arraystructs/LineStruct.fsti
deleted file mode 100644
index 6f0700d1224..00000000000
--- a/examples/steel/arraystructs/LineStruct.fsti
+++ /dev/null
@@ -1,62 +0,0 @@
-module LineStruct
-
-open FStar.PCM
-open Steel.Effect
-open PointStruct
-open Steel.C.PCM
-open Steel.C.Connection
-open Steel.C.Ref
-
-/// Example 2: pointers to nested fields
-///
-/// Here's a struct representing a line segment by its two endpoints:
-///   struct line { struct point p1; struct point p2; };
-///
-/// Carrier of PCM for line:
-
-val line : Type0
-
-/// PCM for line:
-
-val line_pcm : pcm line
-
-/// (mk_line p1 p2) represents (struct line){.p1 = p1, .p2 = p2}
-
-val mk_line (x y: Ghost.erased point): Ghost.erased line
-
-/// Connections for fields
-
-#push-options "--print_universes"
-
-val _p1 : connection line_pcm point_pcm
-val _p2 : connection line_pcm point_pcm
-
-/// Taking pointers to the p1 and p2 fields of a line
-
-val addr_of_p1 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
-: SteelT (q:ref 'a point_pcm{q == ref_focus p _p1})
-    (p `pts_to` mk_line p1 p2)
-    (fun q ->
-       (p `pts_to` mk_line (one point_pcm) p2) `star`
-       (q `pts_to` p1))
-
-val unaddr_of_p1 (#p1 #p2: Ghost.erased point)
-  (p: ref 'a line_pcm)
-  (q: ref 'a point_pcm{q == ref_focus p _p1})
-: SteelT unit
-    ((p `pts_to` mk_line (one point_pcm) p2) `star` (q `pts_to` p1))
-    (fun q -> p `pts_to` mk_line p1 p2)
-
-val addr_of_p2 (#p1 #p2: Ghost.erased point) (p: ref 'a line_pcm)
-: SteelT (q:ref 'a point_pcm{q == ref_focus p _p2})
-    (p `pts_to` mk_line p1 p2)
-    (fun q ->
-       (p `pts_to` mk_line p1 (one point_pcm)) `star`
-       (q `pts_to` p2))
-
-val unaddr_of_p2 (#p1 #p2: Ghost.erased point)
-  (p: ref 'a line_pcm)
-  (q: ref 'a point_pcm{q == ref_focus p _p2})
-: SteelT unit
-    ((p `pts_to` mk_line p1 (one point_pcm)) `star` (q `pts_to` p2))
-    (fun q -> p `pts_to` mk_line p1 p2)
diff --git a/examples/steel/arraystructs/ListExample.fst b/examples/steel/arraystructs/ListExample.fst
deleted file mode 100644
index 136e32216b4..00000000000
--- a/examples/steel/arraystructs/ListExample.fst
+++ /dev/null
@@ -1,147 +0,0 @@
-module ListExample
-
-open Steel.C.PCM
-open Steel.C.Ref
-
-open Steel.Effect
-module A = Steel.Effect.Atomic
-
-open Steel.C.Opt
-open ListNode
-
-/// void mk_figure_eight(struct node *p, struct node *q) {
-///   p->next = q;
-///   q->next = p;
-/// }
-
-let ptr (p: ref node node_pcm)
-: Ghost.erased (option (ref' node node))
-= Ghost.hide (Some p)
-
-let ptr' (p: ref node node_pcm)
-: option (ref' node node)
-= Some p
-
-let nullptr: Ghost.erased (option (ref' node node)) = Ghost.hide None
-
-val mk_figure_eight_step_one
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (i j: Ghost.erased int)
-: SteelT (r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next})
-    (p `pts_to` mk_node (some i) (some nullptr))
-    (fun r ->
-      (p `pts_to` mk_node (some i) none) `star`
-      (r `pts_to` some nullptr))
-
-let mk_figure_eight_step_one p q i j =
-  addr_of_next #node #(some i) #(some nullptr) p
-
-val mk_figure_eight_step_two
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (i j: Ghost.erased int)
-: SteelT (r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next})
-    (q `pts_to` mk_node (some j) (some nullptr))
-    (fun r ->
-      (q `pts_to` mk_node (some j) none) `star`
-      (r `pts_to` some nullptr))
-
-let mk_figure_eight_step_two p q i j =
-  addr_of_next #node #(some j) #(some nullptr) q
-
-val mk_figure_eight_step_three
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int)
-: SteelT unit
-    (p_next `pts_to` some nullptr)
-    (fun _ -> p_next `pts_to` some (ptr q))
-
-let mk_figure_eight_step_three p q p_next q_next i j =
-  opt_write p_next (ptr' q)
-
-val mk_figure_eight_step_four
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int)
-: SteelT unit
-    (q_next `pts_to` some nullptr)
-    (fun _ -> q_next `pts_to` some (ptr p))
-
-let mk_figure_eight_step_four p q p_next q_next i j =
-  opt_write q_next (ptr' p)
-
-val mk_figure_eight_step_five
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int)
-: SteelT unit
-    ((p `pts_to` mk_node (some i) none) `star`
-     (p_next `pts_to` some (ptr q)))
-    (fun _ -> p `pts_to` mk_node (some i) (some (ptr q)))
-
-let mk_figure_eight_step_five p q p_next q_next i j =
-  unaddr_of_next p p_next
-
-val mk_figure_eight_step_six
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (p_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus p _next}))
-  (q_next:(r:ref node (opt_pcm #(option (ref' node node))){r == ref_focus q _next}))
-  (i j: Ghost.erased int)
-: SteelT unit
-    ((q `pts_to` mk_node (some j) none) `star`
-     (q_next `pts_to` some (ptr p)))
-    (fun _ -> q `pts_to` mk_node (some j) (some (ptr p)))
-
-let mk_figure_eight_step_six p q p_next q_next i j =
-  unaddr_of_next q q_next
-
-val mk_figure_eight_verbose
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (i j: Ghost.erased int)
-: SteelT unit
-    ((p `pts_to` mk_node (some i) (some nullptr)) `star`
-     (q `pts_to` mk_node (some j) (some nullptr)))
-    (fun _ ->
-      (p `pts_to` mk_node (some i) (some (ptr q))) `star`
-      (q `pts_to` mk_node (some j) (some (ptr p))))
-
-let mk_figure_eight_verbose p q i j =
-  let p_next = mk_figure_eight_step_one p q i j in
-  let q_next = mk_figure_eight_step_two p q i j in
-  mk_figure_eight_step_three p q p_next q_next i j;
-  mk_figure_eight_step_four p q p_next q_next i j;
-  mk_figure_eight_step_five p q p_next q_next i j;
-  mk_figure_eight_step_six p q p_next q_next i j;
-  A.return ()
-
-val mk_figure_eight
-  (p: ref node node_pcm)
-  (q: ref node node_pcm)
-  (i j: Ghost.erased int)
-: SteelT unit
-    ((p `pts_to` mk_node (some i) (some nullptr)) `star`
-     (q `pts_to` mk_node (some j) (some nullptr)))
-    (fun _ ->
-      (p `pts_to` mk_node (some i) (some (ptr q))) `star`
-      (q `pts_to` mk_node (some j) (some (ptr p))))
-
-#push-options "--query_stats --profile ListExample --profile_component FStar"
-
-let mk_figure_eight p q i j =
-  let p_next = addr_of_next p in
-  let q_next = addr_of_next q in
-  p_next `opt_write` ptr' q;
-  q_next `opt_write` ptr' p;
-  unaddr_of_next p p_next;
-  unaddr_of_next q q_next;
-  A.return ()
diff --git a/examples/steel/arraystructs/ListExampleOOM.fst b/examples/steel/arraystructs/ListExampleOOM.fst
deleted file mode 100644
index 9de2d58dc1e..00000000000
--- a/examples/steel/arraystructs/ListExampleOOM.fst
+++ /dev/null
@@ -1,34 +0,0 @@
-module ListExampleOOM
-
-open Steel.C.PCM
-open Steel.C.Ref
-
-open Steel.Effect
-module A = Steel.Effect.Atomic
-
-open Steel.C.Opt
-open ListNodeOOM
-
-(*
-let ok
-  (#value:Ghost.erased (option int'))
-  (#next:Ghost.erased (option (option (ref' node node))))
-  (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #int'){q == ref_focus p _value})
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node none next) `star`
-       (q `pts_to` value))
-= addr_of_value #'a #value #next p
-*)
-
-let oom
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
-  (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node value none) `star`
-       (q `pts_to` next))
-= addr_of_next #'a #value #next p
diff --git a/examples/steel/arraystructs/ListNode.fst b/examples/steel/arraystructs/ListNode.fst
deleted file mode 100644
index 9cf66888b18..00000000000
--- a/examples/steel/arraystructs/ListNode.fst
+++ /dev/null
@@ -1,286 +0,0 @@
-module ListNode
-
-#push-options "--print_universes"
-
-open FStar.FunctionalExtensionality
-module A = Steel.Effect.Atomic
-open Steel.Effect
-open Steel.C.Opt
-open Steel.C.PCM
-open Steel.C.Ptr
-open Steel.C.Ref
-open Steel.C.Connection
-open Steel.C.Struct
-module U = FStar.Universe
-module P = FStar.PCM
-
-type node_field = | Value | Next
-
-let node_fields (node:Type u#0) k : Type u#0 = match k with
-  | Value -> option int
-  | Next -> option (ptr node node)
-
-#push-options "--__no_positivity"
-noeq type node: Type u#0 =
-{ un_node: restricted_t node_field (node_fields node) }
-#pop-options
-
-let node': Type u#0 = restricted_t node_field (node_fields node)
-
-let node_fields_pcm k: pcm (node_fields node k) = match k with
-  | Value -> opt_pcm #int
-  | Next -> opt_pcm #(ptr node node)
-
-let node_pcm': pcm node' = prod_pcm node_fields_pcm
-
-let node_composable
-  (x y: _)
-: Tot prop
-= composable node_pcm' x.un_node y.un_node
-
-let node_op
-  (x: _) (y: _ { node_composable x y })
-: Tot _
-= Mknode (op node_pcm' x.un_node y.un_node)
-
-let fstar_node_pcm: FStar.PCM.pcm node = {
-  P.p = {
-    P.composable = node_composable;
-    P.op = node_op;
-    P.one = Mknode (one node_pcm');
-  };
-  P.comm = (fun x y -> op_comm node_pcm' x.un_node y.un_node);
-  P.assoc = (fun x y z -> op_assoc_l node_pcm' x.un_node y.un_node z.un_node);
-  P.assoc_r = (fun x y z -> op_assoc_r node_pcm' x.un_node y.un_node z.un_node);
-  P.is_unit = (fun x -> is_unit node_pcm' x.un_node);
-  P.refine = (fun x -> p_refine node_pcm' x.un_node);
-}
-
-let node_pcm: pcm node = pcm_of_fstar_pcm fstar_node_pcm
-
-let roll: node_pcm' `morphism` node_pcm =
-  mkmorphism
-    Mknode
-    ()
-    (fun _ _ -> ())
-
-let unroll: node_pcm `morphism` node_pcm' =
-  mkmorphism
-    Mknode?.un_node
-    ()
-    (fun _ _ -> ())
-
-let mk_un_node: squash (Mknode `is_inverse_of` Mknode?.un_node) = ()
-let un_mk_node: squash (Mknode?.un_node `is_inverse_of` Mknode) = ()
-
-let node_iso : isomorphism node_pcm node_pcm' =
-  mkisomorphism
-    unroll
-    roll
-    ()
-    ()
-    (fun _ -> ())
-    (fun _ -> ())
-
-
-let roll_conn: node_pcm' `connection` node_pcm =
-  connection_of_isomorphism (isomorphism_inverse node_iso)
-
-let unroll_conn: node_pcm `connection` node_pcm' =
-  connection_of_isomorphism node_iso
-
-let mk_node'_f (value: option int) (next: option (ptr node node))
-  (k: node_field)
-: node_fields node k
-= match k with
-  | Value -> value
-  | Next -> next
-  
-let mk_node'
-  (value: option int)
-  (next: option (ptr node node))
-: node'
-= on_domain node_field (mk_node'_f value next)
-
-let mk_node value next = Mknode (mk_node' value next)
-
-open Steel.C.PCM
-module P = FStar.PCM
-
-let mk_node_refine value next = ()
-
-let _value
-: node_pcm `connection` opt_pcm #int
-= unroll_conn `connection_compose` struct_field node_fields_pcm Value
-
-let _next
-: node_pcm `connection` opt_pcm #(ptr node node)
-= unroll_conn `connection_compose` struct_field node_fields_pcm Next
-
-let node'_without_value value next
-: Lemma (struct_without_field node_fields_pcm Value (mk_node' value next) `feq`
-         mk_node' none next)
-  [SMTPat (mk_node' value next)]
-= ()
-
-let node'_with_value value next
-: Lemma (struct_with_field node_fields_pcm Value value (mk_node' none next) `feq`
-         mk_node' value next)
-  [SMTPat (mk_node' value next)]
-= ()
-
-let node'_without_next value next
-: Lemma (struct_without_field node_fields_pcm Next (mk_node' value next) `feq`
-         mk_node' value none)
-  [SMTPat (mk_node' value next)]
-= ()
-
-let node'_with_next value next
-: Lemma (struct_with_field node_fields_pcm Next next (mk_node' value none) `feq`
-         mk_node' value next)
-  [SMTPat (mk_node' value next)]
-= ()
-
-let mk_node_mk_node' value next
-: Lemma (
-    mk_node value next ==
-    unroll_conn.conn_small_to_large.morph (mk_node' value next))
-= ()
-
-let unroll_ref 
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-: Steel (ref 'a node_pcm')
-    (p `pts_to` mk_node value next)
-    (fun p' -> p' `pts_to` mk_node' value next)
-    (requires (fun _ -> True))
-    (ensures (fun _ p' _ ->
-      p' == ref_focus p unroll_conn
-    ))
-= let p' = focus p unroll_conn (mk_node value next) (mk_node' value next) in
-  A.return p'
-
-let roll_ref 
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm) (p': ref 'a node_pcm')
-: Steel unit
-    (p' `pts_to` mk_node' value next)
-    (fun _ -> p `pts_to` mk_node value next)
-    (requires fun _ -> p' == ref_focus p unroll_conn)
-    (ensures fun _ _ _ -> True)
-= unfocus p' p unroll_conn (mk_node' value next);
-  A.change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #int))
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node none next) `star`
-       (q `pts_to` value))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ ->
-      q == ref_focus p _value
-    ))
-= let p' = unroll_ref p in
-  let q = addr_of_struct_field p' Value (mk_node' value next) in
-  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' none next);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` value);
-  roll_ref p p';
-  A.return q
-
-let unaddr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #int))
-: Steel unit
-    ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
-    (fun _ -> p `pts_to` mk_node value next)
-    (requires (fun _ -> q == ref_focus p _value))
-    (ensures (fun _ _ _ -> True))
-= let p' = unroll_ref p in
-  let q = unaddr_of_struct_field #_ #_ #_ #node_fields_pcm Value q p' (mk_node' none next) value in // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
-  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
-  roll_ref p p';
-  A.return ()
-
-let addr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #(ptr node node)))
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node value none) `star`
-       (q `pts_to` next))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> q == ref_focus p _next))
-= let p' = unroll_ref p in
-  let q = addr_of_struct_field p' Next (mk_node' value next) in
-  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value none);
-  A.change_equal_slprop (q `pts_to` _) (q `pts_to` next);
-  roll_ref p p';
-  A.return q
-
-let unaddr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(ptr node node)))
-: Steel unit
-    ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
-    (fun q -> p `pts_to` mk_node value next)
-    (requires (fun _ -> (q == ref_focus p _next)))
-    (ensures (fun _ _ _ -> True))
-= let p' = unroll_ref p in
-  let q = unaddr_of_struct_field #_ #_ #_ #node_fields_pcm Next q p' (mk_node' value none) next in // same here
-  A.change_equal_slprop (p' `pts_to` _) (p' `pts_to` mk_node' value next);
-  roll_ref p p';
-  A.return ()
-
-open Steel.C.Ptr
-
-(*
-val ptr_addr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ptr node node)
-: Steel (ptr node (option int))
-    (pts_to p node_pcm (mk_node value next))
-    (fun q ->
-       (pts_to p node_pcm (mk_node none next)) `star`
-       (pts_to q opt_pcm value))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> ptr_focused q p _value))
-
-let ptr_addr_of_value #value #next (p: ptr node node)
-= let p_ref = elim_pts_to p in
-  let p' = unroll_ref p_ref in
-  let q = addr_of_struct_field p' Value (mk_node' value next) in
-  A.change_equal_slprop (p' `Steel.C.Ref.pts_to` _) (p' `Steel.C.Ref.pts_to` mk_node' none next);
-  A.change_equal_slprop (q `Steel.C.Ref.pts_to` _) (q `Steel.C.Ref.pts_to` value);
-  roll_ref p_ref p';
-  let p_ = intro_pts_to p_ref in
-  A.change_equal_slprop (pts_to p_ node_pcm _) (pts_to p node_pcm _);
-  let q_ = intro_pts_to q in
-  A.sladmit();
-  A.return q_
-  // TODO need split, gather, etc for ptrs
-
-assume val unaddr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (Steel.C.Ptr.ptr node node)))
-  (p: Steel.C.Ptr.ptr node node)
-  (q: Steel.C.Ptr.ptr node (option int))
-: Steel unit
-    ((pts_to p node_pcm (mk_node none next)) `star`
-     (pts_to q opt_pcm value))
-    (fun q -> pts_to p node_pcm (mk_node value next))
-    (requires (fun _ -> ptr_focused q p _value))
-    (ensures (fun _ _ _ -> True))
-*)
diff --git a/examples/steel/arraystructs/ListNode.fsti b/examples/steel/arraystructs/ListNode.fsti
deleted file mode 100644
index 4a45eec154e..00000000000
--- a/examples/steel/arraystructs/ListNode.fsti
+++ /dev/null
@@ -1,96 +0,0 @@
-module ListNode
-
-open Steel.Effect
-open PointStruct
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Ptr
-open Steel.C.Ref
-open Steel.C.Connection
-module U = FStar.Universe
-
-/// struct node { int value; struct node *next; };
-
-val node: Type u#0
-
-/// PCM for node:
-
-val node_pcm: pcm node
-
-/// (mk_node value next) represents (struct node){.value = value, .next = next}
-
-val mk_node
-  (i: option int)
-  (next: option (ptr node node))
-: node
-
-// val mk_node_tot
-//   (i: option int)
-//   (next: option (ptr node node))
-// : node
-
-// val mk_node_tot_mk_node (i: option int) (next: option (ptr node node))
-// : Lemma (mk_node_tot i next == Ghost.reveal (mk_node i next))
-//   [SMTPat (mk_node_tot i next)]
-
-open Steel.C.PCM
-module P = FStar.PCM
-
-val mk_node_refine (i: option int) (next: option (ptr node node))
-: Lemma
-    (requires p_refine opt_pcm i /\ p_refine (opt_pcm) next)
-    (ensures p_refine node_pcm (mk_node i next))
-    [SMTPat (p_refine node_pcm (mk_node i next))]
-
-/// Connections for fields
-
-val _value: node_pcm `connection` opt_pcm #int
-val _next: node_pcm `connection` opt_pcm #(ptr node node)
-
-/// Taking pointers to the fields of a node
-
-val addr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #int))
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node none next) `star`
-       (q `pts_to` value))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> q == ref_focus p _value))
-
-val unaddr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #int))
-: Steel unit
-    ((p `pts_to` mk_node none next) `star` (q `pts_to` value))
-    (fun q -> p `pts_to` mk_node value next)
-    (requires (fun _ -> q == ref_focus p _value))
-    (ensures (fun _ _ _ -> True))
-
-val addr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-: Steel (ref 'a (opt_pcm #(ptr node node)))
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node value none) `star`
-       (q `pts_to` next))
-    (requires (fun _ -> True))
-    (ensures (fun _ q _ -> q == ref_focus p _next))
-
-val unaddr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (ptr node node)))
-  (p: ref 'a node_pcm)
-  (q: ref 'a (opt_pcm #(ptr node node)))
-: Steel unit
-    ((p `pts_to` mk_node value none) `star` (q `pts_to` next))
-    (fun q -> p `pts_to` mk_node value next)
-    (requires (fun _ -> q == ref_focus p _next))
-    (ensures (fun _ _ _ -> True))
diff --git a/examples/steel/arraystructs/ListNodeOOM.fsti b/examples/steel/arraystructs/ListNodeOOM.fsti
deleted file mode 100644
index 5837f304ee1..00000000000
--- a/examples/steel/arraystructs/ListNodeOOM.fsti
+++ /dev/null
@@ -1,51 +0,0 @@
-module ListNodeOOM
-
-open Steel.Effect
-open PointStruct
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Ref
-open Steel.C.Connection
-module U = FStar.Universe
-
-/// struct node { int value; struct node *next; };
-
-val node: Type u#0
-
-/// PCM for node:
-
-val node_pcm: pcm node
-
-/// (mk_node value next) represents (struct node){.value = value, .next = next}
-
-val mk_node
-  (i: Ghost.erased (option int))
-  (next: Ghost.erased (option (option (ref' node node))))
-: Ghost.erased node
-
-/// Lenses for fields
-
-val _value: node_pcm `connection` opt_pcm #int
-val _next: node_pcm `connection` opt_pcm #(option (ref' node node))
-
-/// Taking pointers to the fields of a node
-
-val addr_of_value
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
-  (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #int){q == ref_focus p _value})
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node none next) `star`
-       (q `pts_to` value))
-
-val addr_of_next
-  (#value:Ghost.erased (option int))
-  (#next:Ghost.erased (option (option (ref' node node))))
-  (p: ref 'a node_pcm)
-: SteelT (q:ref 'a (opt_pcm #(option (ref' node node))){q == ref_focus p _next})
-    (p `pts_to` mk_node value next)
-    (fun q ->
-       (p `pts_to` mk_node value none) `star`
-       (q `pts_to` next))

From a123d2c6dbb6f9cedc426b8af019dd17473249bc Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 13:59:24 -0700
Subject: [PATCH 219/513] Add Steel.C.TypedefNorm.fst

---
 .../arraystructs/Steel.C.TypedefNorm.fst      | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 examples/steel/arraystructs/Steel.C.TypedefNorm.fst

diff --git a/examples/steel/arraystructs/Steel.C.TypedefNorm.fst b/examples/steel/arraystructs/Steel.C.TypedefNorm.fst
new file mode 100644
index 00000000000..0d6f65debf9
--- /dev/null
+++ b/examples/steel/arraystructs/Steel.C.TypedefNorm.fst
@@ -0,0 +1,27 @@
+module Steel.C.TypedefNorm
+
+open Steel.C.StructLiteral
+open Steel.C.UnionLiteral
+open Steel.C.Fields
+open Steel.C.Typedef
+open Steel.C.Typenat
+open Steel.C.Typestring
+
+unfold let norm_c_typedef =
+  [delta_only
+    [`%mk_c_union;
+     `%mk_c_struct;
+     `%c_fields_t;
+     `%List.Tot.fold_right;
+     `%Steel.C.Typestring.mk_string_t;
+     `%Steel.C.Typestring.string_t_of_chars;
+     `%Steel.C.Typestring.char_t_of_char;
+     `%Mkc_fields?.get_field;
+     `%Mkc_fields?.cfields;
+     `%Mktypedef?.view_type;
+     `%fields_cons;
+     `%fields_nil;
+     `%Steel.C.Typenat.nat_t_of_nat;
+     ];
+   delta_attr [`%c_struct; `%c_typedef];
+   iota; zeta; primops]

From 46ae7e75ec40d1efb4253e52dad15183973e28ea Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 15:54:45 -0700
Subject: [PATCH 220/513] Get arraystruct code to verify

---
 .../arraystructs/AggregateRefExamples.fst     |  295 -----
 .../arraystructs/PointStructSelectors.fst     | 1143 -----------------
 examples/steel/arraystructs/Steel.C.Array.fst |  384 ------
 .../steel/arraystructs/Steel.C.Fields.fst     |    4 +-
 examples/steel/arraystructs/Steel.C.Ptr.fst   |   12 +-
 .../arraystructs/Steel.C.StructLiteral.fst    |   22 +
 .../arraystructs/Steel.C.StructLiteral.fsti   |  135 +-
 .../steel/arraystructs/Steel.C.Typestring.fst |    2 +-
 8 files changed, 41 insertions(+), 1956 deletions(-)
 delete mode 100644 examples/steel/arraystructs/AggregateRefExamples.fst
 delete mode 100644 examples/steel/arraystructs/PointStructSelectors.fst
 delete mode 100644 examples/steel/arraystructs/Steel.C.Array.fst

diff --git a/examples/steel/arraystructs/AggregateRefExamples.fst b/examples/steel/arraystructs/AggregateRefExamples.fst
deleted file mode 100644
index 8c82e90f8e6..00000000000
--- a/examples/steel/arraystructs/AggregateRefExamples.fst
+++ /dev/null
@@ -1,295 +0,0 @@
-module AggregateRefExamples
-
-open Steel.C.PCM
-open Steel.C.Ref
-
-open Steel.Effect
-module A = Steel.Effect.Atomic
-
-/// Example 1: swapping the coordinates of a 2d point
-
-open Steel.C.Opt
-
-open PointStruct
-
-/// We can write the following function that swaps the x and y fields of a given point:
-/// 
-/// void point_swap(struct point *p) {
-///   int *q = &p.x;
-///   int *r = &p.y;
-///   int tmp = *q;
-///   *q = *r;
-///   *r = tmp;
-/// }
-
-let point_swap_some (p: ref 'a point_pcm) (x y: Ghost.erased int)
-: SteelT unit
-    (p `pts_to` mk_point (some x) (some y))
-    (fun _ -> p `pts_to` mk_point (some y) (some x))
-= (* int *q = &p.x; *)
-  let q = addr_of_x p in
-  (* int *r = &p.y; *)
-  let r = addr_of_y p in
-  (* tmp = *q; *)
-  let tmp : int = opt_read q in
-  (* *q = *r; *)
-  let vy : int = opt_read r in
-  opt_write q vy;
-  (* *r = tmp; *)
-  opt_write r tmp;
-  (* Gather *)
-  unaddr_of_x p q;
-  unaddr_of_y p r;
-  A.return ()
-
-let point_swap (p: ref 'a point_pcm) (x y: Ghost.erased int)
-: SteelT unit
-    (p `pts_to` mk_point (Some #int x) (Some #int y))
-    (fun _ -> p `pts_to` mk_point (Some #int y) (Some #int x))
-= (* int *q = &p.x; *)
-  let q = addr_of_x p in
-  (* int *r = &p.y; *)
-  let r = addr_of_y p in
-  (* tmp = *q; *)
-  let tmp : int = opt_read q in
-  (* *q = *r; *)
-  let vy : int = opt_read r in
-  opt_write q vy;
-  (* *r = tmp; *)
-  opt_write r tmp;
-  (* Gather *)
-  unaddr_of_x p q;
-  unaddr_of_y p r;
-  A.return ()
-
-/// We can also implement swap generically:
-///
-/// void generic_swap<A>(A *p, A *q) {
-///   A tmp = *p;
-///   *p = *q;
-///   *q = tmp;
-/// }
-
-let generic_swap (#x #y: Ghost.erased 'c) (p:ref 'a (opt_pcm #'c)) (q:ref 'b (opt_pcm #'c))
-: SteelT unit ((p `pts_to` Some #'c x) `star` (q `pts_to` Some #'c y))
-    (fun _ -> (p `pts_to` Some #'c y) `star` (q `pts_to` Some #'c x))
-= (* A tmp = *p; *)
-  let tmp = opt_read p in
-  (* *p = *q; *)
-  let vy = opt_read q in
-  opt_write p vy;
-  (* *q = tmp *)
-  opt_write q tmp;
-  A.return ()
-
-let generic_swap_sel (p:ref 'a (opt_pcm #'c)) (q:ref 'b (opt_pcm #'c))
-: Steel unit
-  ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
-  (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
-  (requires (fun _ -> True))
-  (ensures (fun h _ h' ->
-    h' (p `pts_to_view` opt_view _) == h (q `pts_to_view` opt_view _) /\
-    h' (q `pts_to_view` opt_view _) == h (p `pts_to_view` opt_view _)
-  ))
-= (* A tmp = *p; *)
-  let tmp = opt_read_sel p in
-  (* *p = *q; *)
-  let vy = opt_read_sel q in
-  opt_write_sel p vy;
-  (* *q = tmp *)
-  opt_write_sel q tmp;
-  A.return ()
-
-/// Now, point_swap written using generic_swap:
-///
-/// void point_swap_generically(struct point *p) {
-///   int *q = &p.x;
-///   int *r = &p.y;
-///   generic_swap(q, r);
-/// }
-
-let point_swap_generically (#x #y: Ghost.erased int) (p: ref 'a point_pcm)
-: SteelT unit
-    (p `pts_to` mk_point (some x) (some y))
-    (fun _ -> p `pts_to` mk_point (some y) (some x))
-= (* int *q = &p.x; *)
-  let q = addr_of_x p in
-  (* int *r = &p.y; *)
-  let r = addr_of_y p in
-  (* generic_swap(q, r); *)
-  generic_swap q r;
-  (* Gather *)
-  unaddr_of_x p q;
-  unaddr_of_y p r;
-  A.return ()
-
-/// Reflect a line segment across the line y=x and reverse its direction
-///
-/// void reflect_and_reverse(struct line *p) {
-///   generic_swap(&p.p1.x, &p.p2.y);
-///   generic_swap(&p.p1.y, &p.p2.x);
-/// }
-
-open LineStruct
-
-let reflect_and_reverse (p: ref 'a line_pcm) (x1 y1 x2 y2: Ghost.erased int)
-: SteelT unit
-    (p `pts_to` mk_line (mk_point (some x1) (some y1)) (mk_point (some x2) (some y2)))
-    (fun _ -> p `pts_to` mk_line (mk_point (some y2) (some x2)) (mk_point (some y1) (some x1)))
-= (* generic_swap(&p.p1.x, &p.p2.y); *)
-  let pp1 = addr_of_p1 p in
-  let pp1x = addr_of_x pp1 in
-  let pp2 = addr_of_p2 p in
-  let pp2y = addr_of_y pp2 in
-  generic_swap pp1x pp2y;
-  (* generic_swap(&p.p1.y, &p.p2.x); *)
-  let pp1y = addr_of_y pp1 in
-  let pp2x = addr_of_x pp2 in
-  generic_swap pp1y pp2x;
-  (* Gather p1 *)
-  unaddr_of_x pp1 pp1x;
-  unaddr_of_y pp1 pp1y;
-  (* Gather p2 *)
-  unaddr_of_x pp2 pp2x;
-  unaddr_of_y pp2 pp2y;
-  (* Gather p *)
-  unaddr_of_p1 p pp1;
-  unaddr_of_p2 p pp2;
-  A.return ()
-
-open IntOrBool
-
-/// Swap two ints inside two (union int_or_bool)s using generic_swap
-///
-/// void int_or_bool_int_swap(union int_or_bool *p, union int_or_bool *q)
-/// { generic_swap(&p.i, &q.i); }
-
-let int_or_bool_int_swap
-  (p: ref 'a int_or_bool_pcm) (q: ref 'b int_or_bool_pcm)
-  (i j: Ghost.erased int)
-: SteelT unit
-    ((p `pts_to` mk_int (some i)) `star` (q `pts_to` mk_int (some j)))
-    (fun _ -> (p `pts_to` mk_int (some j)) `star` (q `pts_to` mk_int (some i)))
-= (* &p.i *)
-  let pi = addr_of_i p in
-  (* &q.i *)
-  let qi = addr_of_i q in
-  (* generic_swap(&p.i, &q.i); *)
-  generic_swap pi qi;
-  (* Give permissions back to p and q *)
-  unaddr_of_i p pi;
-  unaddr_of_i q qi
-
-/// Convert an int_or_bool + runtime tag into an int
-///
-/// int int_or_bool_to_int(bool is_int, union int_or_bool *p) {
-///   if (is_int) return p->i;
-///   else return p->b ? 1 : 0;
-/// }
-
-(* For some reason the proof needs to be given explicitly *)
-let extract_int (u: Ghost.erased int_or_bool) (h: squash (case_of_int_or_bool u == Some I))
-: Tot (i:Ghost.erased (option int){u == mk_int i /\ ~ (Ghost.reveal i == one (opt_pcm #int))})
-= get_int u
-let extract_bool (u: Ghost.erased int_or_bool) (h: squash (case_of_int_or_bool u == Some B))
-: Tot (b:Ghost.erased (option bool){u == mk_bool b /\ ~ (Ghost.reveal b == one (opt_pcm #bool))})
-= get_bool u
-
-let int_or_bool_to_int'
-  (is_int: bool)
-  (p: ref 'a int_or_bool_pcm)
-  (u: Ghost.erased int_or_bool)
-: Steel int
-    (p `pts_to` u)
-    (fun _ -> p `pts_to` u)
-    (requires fun _ ->
-      if is_int then case_of_int_or_bool u == Some I 
-      else case_of_int_or_bool u == Some B)
-    (ensures fun _ _ _ -> True)
-= if is_int then begin
-    let prf: squash (case_of_int_or_bool u == Some I) = () in
-    let i: Ghost.erased int = Ghost.hide (Some?.v (extract_int u prf)) in
-    assert (u == mk_int (some i));
-    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_int (some i));
-    let pi = addr_of_i p in
-    let i = opt_read pi in
-    unaddr_of_i p pi;
-    A.return i
-  end else begin
-    let prf: squash (case_of_int_or_bool u == Some B) = () in
-    let b: Ghost.erased bool = Ghost.hide (Some?.v (extract_bool u prf)) in
-    assert (u == mk_bool (some b));
-    A.change_equal_slprop (p `pts_to` u) (p `pts_to` mk_bool (some b));
-    let pb = addr_of_b p in
-    let b = opt_read pb in
-    unaddr_of_b p pb;
-    if b then A.return 1 else A.return 0
-  end
-
-(*
-pts_to r x
-(fun r' -> pts_to r' x')
-(requires (fun _ -> x is in case A))
-(ensures (fun _ r' _ -> x == A x'))
-A x' = (|TagA, x'|)
-(q:ref .) (t: erased tag)
-pts_to q (t, u)
-(requires (fun _ -> u is in case (tag_denote t)))
-(q:ref .) (t: erased tag)
-(r:ref . = the union inside q)
-pts_to q (t, one) `star` pts_to r x
-(requires (fun _ -> x is in case (tag_denote t)))
-*)
-(*
-to print proof state, try:
-val fake : vprop
-let f unit : Steel unit fake (fun _ -> _)
-*)
-(*
-(** Example: a model for a tagged union representing colors in RGB or HSV
-      type color =
-        | RGB : r:int -> g:int -> b:int -> color
-        | HSV : h:int -> s:int -> v:int -> color *)
-type rgb_field = | R | G | B
-type hsv_field = | H | S | V
-type color_tag = | RGB | HSV
-(* Carrier of all-or-none PCM for integers *)
-let int_pcm_t = option int
-(* Type families for fields of RGB and HSV structs *)
-let rgb_fields k = match k with
-  | R -> int_pcm_t
-  | G -> int_pcm_t
-  | B -> int_pcm_t
-let hsv_fields k = match k with
-  | H -> int_pcm_t
-  | S -> int_pcm_t
-  | V -> int_pcm_t
-  
-(** Carriers of PCMs for RGB and HSV structs *)
-let rgb_t = restricted_t rgb_field rgb_fields
-let hsv_t = restricted_t hsv_field hsv_fields
-(** Type family for union of RGB and HSV *)
-let color_cases t = match t with
-  | RGB -> rgb_t
-  | HSV -> hsv_t
-(** Carrier of PCM for color *)
-let color_t = union color_cases
-(** All-or-none PCM for integers *)
-let int_pcm : pcm int_pcm_t = opt_pcm
-(** PCMs for RGB and HSV structs *)
-let rgb_pcm : pcm (restricted_t rgb_field rgb_fields) =
-  prod_pcm #_ #rgb_fields (fun k -> match k with
-    | R -> int_pcm
-    | G -> int_pcm
-    | B -> int_pcm)
-let hsv_pcm : pcm (restricted_t hsv_field hsv_fields) =
-  prod_pcm #_ #hsv_fields (fun k -> match k with
-    | H -> int_pcm
-    | S -> int_pcm
-    | V -> int_pcm)
-(** PCM for color *)
-let color_pcm_cases k : pcm (color_cases k) = match k with
-  | RGB -> rgb_pcm
-  | HSV -> hsv_pcm
-let color_pcm : pcm color_t 
-*)
diff --git a/examples/steel/arraystructs/PointStructSelectors.fst b/examples/steel/arraystructs/PointStructSelectors.fst
deleted file mode 100644
index 7ed75c4ee73..00000000000
--- a/examples/steel/arraystructs/PointStructSelectors.fst
+++ /dev/null
@@ -1,1143 +0,0 @@
-module PointStructSelectors
-
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Connection
-open Steel.C.Struct
-open FStar.FunctionalExtensionality
-
-open Steel.Memory
-open Steel.Effect
-open Steel.Effect.Atomic
-
-open Steel.C.Ref
-open Steel.C.Typedef
-open Steel.C.StructLiteral
-open FStar.List.Tot
-open FStar.FunctionalExtensionality
-
-/// TODO move and dedup with Steel.C.Ptr.fst
-
-let vpure_sel'
-  (p: prop)
-: Tot (selector' (squash p) (Steel.Memory.pure p))
-= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
-
-let vpure_sel
-  (p: prop)
-: Tot (selector (squash p) (Steel.Memory.pure p))
-= vpure_sel' p
-
-[@@ __steel_reduce__]
-let vpure'
-  (p: prop)
-: GTot vprop'
-= {
-  hp = Steel.Memory.pure p;
-  t = squash p;
-  sel = vpure_sel p;
-}
-
-[@@ __steel_reduce__]
-let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
-
-let intro_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    emp
-    (fun _ -> vpure p)
-    (fun _ -> p)
-    (fun _ _ h' -> p)
-=
-  change_slprop_rel
-    emp
-    (vpure p)
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m)
-
-let elim_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    (vpure p)
-    (fun _ -> emp)
-    (fun _ -> True)
-    (fun _ _ _ -> p)
-=
-  change_slprop_rel
-    (vpure p)
-    emp
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
-
-let pts_to_v
-  (#pcm: pcm 'a) (#can_view_unit: bool)
-  (p: ref 'a pcm) (view: sel_view pcm 'b can_view_unit)
-  (v: 'b)
-: vprop
-= (p `pts_to_view` view) `vdep` (fun x -> vpure (x == v))
-
-(** ** BEGIN TODO impl and move to StructLiteral *)
-
-(*
-[@@__reduce__]
-let rec iter_star_fields (fields: struct_fields) (f: field_of fields -> vprop): vprop =
-  match fields with
-  | [(field, _)] -> f field
-  | (field, _) :: fields -> f field `star` iter_star_fields fields f
-*)
-
-[@@__reduce__;__steel_reduce__;iter_unfold]
-let pts_to_field_vprop
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (field: field_of fields)
-: vprop
-= ref_focus p (struct_field tag fields field) `pts_to_view` struct_views fields field
-
-[@@__reduce__;__steel_reduce__;iter_unfold]
-let rec pts_to_fields_vprop
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (fields': struct_fields)
-: vprop
-= match fields' with
-  | [(field, _)] -> if has_field_bool fields field then pts_to_field_vprop tag fields p field else emp
-  | (field, _) :: fields' ->
-    if has_field_bool fields field then begin
-      pts_to_field_vprop tag fields p field `star`
-      pts_to_fields_vprop tag fields p fields'
-    end else emp
-
-#push-options "--debug PointStructSelectors --debug_level SMTQuery --log_queries --query_stats --fuel 0"
-(*
-[@@iter_unfold]
-let pts_to_fields
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (h: rmem (p `pts_to_view` struct_view tag fields))
-  (h': rmem (pts_to_fields_vprop tag fields p fields))
-  //(prefix: list (string * typedef))
-  (field: field_of fields)
-  //(hfields': squash (fields == rev prefix `append` fields'))
-: Tot prop
-= 
-      can_be_split
-        (pts_to_fields_vprop tag fields p fields)
-        (pts_to_field_vprop tag fields p field) /\
-       begin
-         //let lhs = h' (pts_to_field_vprop tag fields p field) in
-         let rhs 
-         : (
-         
-           assoc_mem field fields;
-         let { carrier = _ ; pcm = _ ; view_type = view_type ; view = _ } =
-           let FStar.Pervasives.Native.Some v =
-             match fields with
-             | [] -> None
-             | (x', y) :: tl ->
-               (if field = x' then Some y else assoc field tl) <: Pervasives.Native.option typedef
-           in
-           v
-         in
-         view_type)
-         = h (p `pts_to_view` struct_view tag fields) `struct_get'` field in
-         rhs == rhs
-         //let rhs = h (p `pts_to_view` struct_view tag fields) `struct_get'` field in
-         //rhs == rhs
-       end
-  //| (field, _) :: fields' ->
-  //  if has_field_bool fields field then
-  //    True
-  //    //can_be_split 
-  //    //  (pts_to_fields_vprop tag fields p fields)
-  //    //  (pts_to_field_vprop tag fields p field) /\
-  //    //h' (pts_to_field_vprop tag fields p field) ===
-  //    //h (p `pts_to_view` struct_view tag fields) `struct_get'` field /\
-  //    //pts_to_fields tag fields p h h' fields'
-  //  else True
-
-// 1. normalizing iterated conjunction and star
-// 2. keep a list of fields to be excluded (relies on normalizing list difference operator)
-// 3. don't use selectors, but also don't use PCM carrier values
-//    i.e. have slprop p `pts_to` v where v is a value corresponding to a C type
-//      pts_to p view v = (p `pts_to_view` view) `vdep` (fun x -> x == v)
-//    + no more issues with normalization of props
-//    - need laws about struct_get/struct_put (may rely on smt_fallback)
-
-#push-options "--print_implicits"
-
-(*
-[@@__reduce__;iter_unfold]
-let rec iter_and_fields (fields: struct_fields) (f: field_of fields -> prop): prop =
-  match fields with
-  | [(field, _)] -> f field
-  | (field, _) :: fields -> f field /\ iter_and_fields fields f
-*)
-
-(*
-[@@__steel_reduce__;iter_unfold]
-let pts_to_field
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (h: rmem (p `pts_to_view` struct_view tag fields))
-  (h': rmem (iter_star_fields fields (pts_to_field_vprop tag fields p)))
-  (field: field_of fields)
-: prop
-= can_be_split 
-    (iter_star_fields fields (pts_to_field_vprop tag fields p))
-    (pts_to_field_vprop tag fields p field) /\
-  h' (pts_to_field_vprop tag fields p field) ==
-  h (p `pts_to_view` struct_view tag fields) `struct_get` field
-  *)
-
-
-assume val explode (#opened: inames)
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view tag fields)
-    (fun _ -> pts_to_fields_vprop tag fields p fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      //norm norm_list
-        (pts_to_fields tag fields p h h' fields))
-//(iter_and_fields fields (pts_to_field tag fields p h h')))
-        
-// norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-
-(*
-assume val recombine (#opened: inames)
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-: SteelGhost unit opened
-    (iter_star_fields fields (pts_to_field_vprop tag fields p))
-    (fun _ -> p `pts_to_view` struct_view tag fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' -> pts_to_fields tag fields p h' h fields)
-    *)
-    
-(** ** END TODO impl and move to StructLiteral *)
-
-/// Point struct
-
-[@@iter_unfold]
-let c_int: typedef = {
-  carrier = option int;
-  pcm = opt_pcm #int;
-  view_type = int;
-  view = opt_view int;
-}
-
-[@@__reduce__;iter_unfold]
-let point_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-]
-
-[@@iter_unfold]
-let point = struct "point" point_fields
-
-[@@iter_unfold]
-let point_pcm_carrier = struct_pcm_carrier "point" point_fields
-[@@iter_unfold]
-let point_pcm: pcm point_pcm_carrier = struct_pcm "point" point_fields
-
-/// (mk_point x y) represents (struct point){.x = x, .y = y}
-/// (mk_point_pcm x y) same, but where x and y are PCM carrier values
-
-let mk_point: int -> int -> point = mk_struct "point" point_fields
-let mk_point_pcm: option int -> option int -> point_pcm_carrier = mk_struct_pcm "point" point_fields
-
-/// Connections for the fields of a point
-
-[@@iter_unfold]
-val _x: connection point_pcm (opt_pcm #int)
-let _x = struct_field "point" point_fields "x"
-
-[@@iter_unfold]
-val _y: connection point_pcm (opt_pcm #int)
-let _y = struct_field "point" point_fields "y"
-
-/// View for points
-
-[@@iter_unfold]
-val point_view: sel_view point_pcm point false
-let point_view = struct_view "point" point_fields
-
-/// Explode and recombine
-
-(*
-val explode' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "point" point_fields)
-    (fun _ -> iter_star_fields point_fields (pts_to_field_vprop "point" point_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      normalize
-        (iter_and_fields point_fields (pts_to_field "point" point_fields p h h')))
-
-let explode' p = explode "point" point_fields p
-*)
-
-(*
-val explode'' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` point_view)
-    (fun _ ->
-      (ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      h' (ref_focus p _x `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "x" /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) == h (p `pts_to_view` point_view) `struct_get` "y")
-
-let explode'' p = explode "point" point_fields p
-*)
-
-(*
-val recombine' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _x `pts_to_view` c_int.view) `star`
-     (ref_focus p _y `pts_to_view` c_int.view))
-    (fun _ -> p `pts_to_view` point_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      h (ref_focus p _x `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "x" /\
-      h (ref_focus p _y `pts_to_view` c_int.view) == h' (p `pts_to_view` point_view) `struct_get` "y")
-
-let recombine' p = recombine "point" point_fields p
-*)
-
-#push-options "--debug PointStructSelectors --debug_level SMTQuery --log_queries --query_stats --fuel 0"
-#restart-solver
-
-[@@iter_unfold] let x: field_of point_fields = mk_field_of point_fields "x"
-[@@iter_unfold] let y: field_of point_fields = mk_field_of point_fields "y"
-
-
-module T = FStar.Tactics
-
-let aux (p: ref 'a point_pcm) (h: rmem (p `pts_to_view` point_view))
-  (h': rmem
-     ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)))
-: Tot (squash (
-   (norm norm_list
-      (pts_to_fields "point" point_fields p h h' point_fields)
-      ==
-   norm norm_list (begin
-      let pointprop =
-      ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-      in
-      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x) /\
-      (can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` y)
-   end))))
-= _ by (T.dump ""; T.smt ())
-
-val explode' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` point_view)
-    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list
-        (pts_to_fields "point" point_fields p h h' point_fields))
-//(iter_and_fields fields (pts_to_field "point" fields p h h')))
-
-let explode' p = explode "point" point_fields p
-
-val explode'' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "point" point_fields)
-    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      (
-      let pointprop =
-      (pts_to_fields_vprop "point" point_fields p point_fields)
-      in
-      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get'` x)))
-
-// let explode'' p = explode "point" point_fields p
-
-assume val recombine (#opened: inames)
-  (tag: string) (fields: struct_fields)
-  (p: ref 'a (struct_pcm tag fields))
-: SteelGhost unit opened
-    (pts_to_fields_vprop tag fields p fields)
-    (fun _ -> p `pts_to_view` struct_view tag fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list
-        (pts_to_fields tag fields p h' h fields))
-
-
-val explode''' (#opened: inames)
-  (p: ref 'a point_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` point_view)
-    (fun _ -> 
-    ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list
-        (pts_to_fields "point" point_fields p h h' point_fields))
-//(iter_and_fields fields (pts_to_field "point" fields p h h')))
-
-#push-options "--print_implicits"
-
-unfold let norm' (s: list norm_step) (#a: Type) (x: a) : Tot (norm s a) =
-  norm_spec s a;
-  norm s x
-
-unfold let norm''  (#a: Type) (x: a) : Tot (norm norm_list a) =
-  norm_spec norm_list a;
-  norm norm_list x
-
-let aux'
-  (p: ref 'a (struct_pcm "point" point_fields))
-  (h': rmem (p `pts_to_view` point_view))
-  : GTot int
-= 
-    ((h' (p `pts_to_view` point_view) `struct_get'` x))
-    // <: (get_field point_fields x).view_type)) in
-//  in let j: int = i in j
-//= (norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x) <: (get_field point_fields x).view_type) <: int
-// TODO why are two coercions necessary?
-
-//let aux'' (s: (Mktypedef?.view_type (get_field point_fields xc_)): int
-//= s <: int
-
-/// Reading a struct field
-val struct_get
-  (#tag: string) (#fields: struct_fields)
-  (x: struct tag fields) (field: field_of fields)
-: (get_field fields field).view_type
-
-let explode''' p =
-  explode "point" point_fields p;
-  change_equal_slprop
-    (pts_to_fields_vprop "point" point_fields p point_fields)
-    ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-
-val zero_x
-  (p: ref 'a (struct_pcm "point" point_fields))
-: Steel unit
-    (p `pts_to_view` point_view)
-    (fun _ -> p `pts_to_view` point_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm norm_list (h' (p `pts_to_view` point_view) `struct_get` x == (0 <: c_int.view_type)))
-
-let zero_x p =
-  explode "point" point_fields p;
-  slassert (
-     ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)));
-  //recombine "point" point_fields p;
-  sladmit(); return()
-
-(*
-val explode''' (#opened: inames)
-  (p: ref 'a (struct_pcm "point" point_fields))
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "point" point_fields)
-    (fun _ -> pts_to_fields_vprop "point" point_fields p point_fields)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let pointprop =
-      (pts_to_fields_vprop "point" point_fields p point_fields)
-      in
-      (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x))
-
-let testlemma p
-    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
-    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
-: Lemma
-  (requires
-  norm norm_list (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-  (ensures
-  norm norm_list (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-= ()
-*)
-(*
-let testlemma' (p: ref 'a point_pcm)
-    (h: rmem (p `pts_to_view` struct_view "point" point_fields))
-    (h': rmem( pts_to_fields_vprop "point" point_fields p point_fields))
-: Lemma
-  (requires
-  norm norm_list (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-  (ensures
-  (let pointprop =
-  (pts_to_fields_vprop "point" point_fields p point_fields)
-  in
-  (can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-  h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x)
-  ))
-= _ by (T.dump "") // T.norm norm_list; T.dump ""; T.tadmit()); admit()
-*)
-
-//let explode''' p = explode'' p
-
-let aux p (h: rmem (p `pts_to_view` point_view))
-  (h': rmem
-     ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view)))
-: Lemma
-   (requires
-      //norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-      norm norm_list
-      (pts_to_fields "point" point_fields p h h' point_fields))
-   (ensures begin
-      let pointprop =
-      ((ref_focus p _x `pts_to_view` c_int.view) `star`
-      (ref_focus p _y `pts_to_view` c_int.view))
-      in
-      can_be_split pointprop (ref_focus p _x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _x `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` x /\
-      can_be_split pointprop (ref_focus p _y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _y `pts_to_view` c_int.view) === h (p `pts_to_view` point_view) `struct_get` y
-   end)
-= ()
-
-/// Now, a contrived struct with twice as many fields (to stress-test)
-
-[@@__reduce__;iter_unfold]
-let quad_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-  "z", c_int;
-  "w", c_int;
-]
-let quad = struct "quad" quad_fields
-
-let quad_pcm_carrier = struct_pcm_carrier "quad" quad_fields
-let quad_pcm: pcm quad_pcm_carrier = struct_pcm "quad" quad_fields
-
-/// (mk_quad x y) represents (struct quad){.x = x, .y = y}
-/// (mk_quad_pcm x y) same, but where x and y are PCM carrier values
-
-let mk_quad: int -> int -> int -> int -> quad = mk_struct "quad" quad_fields
-let mk_quad_pcm: option int -> option int -> option int -> option int -> quad_pcm_carrier = mk_struct_pcm "quad" quad_fields
-
-/// Connections for the fields of a quad
-
-[@@iter_unfold] let _quad_x: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "x"
-[@@iter_unfold] let _quad_y: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "y"
-[@@iter_unfold] let _quad_z: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "z"
-[@@iter_unfold] let _quad_w: connection quad_pcm (opt_pcm #int) = struct_field "quad" quad_fields "w"
-
-/// View for quads
-
-[@@iter_unfold] let quad_view: sel_view quad_pcm quad false = struct_view "quad" quad_fields
-
-/// Explode and recombine
-
-(*
-val explode_quad' (#opened: inames)
-  (p: ref 'a quad_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "quad" quad_fields)
-    (fun _ -> iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-        (iter_and_fields quad_fields (pts_to_field "quad" quad_fields p h h')))
-
-let explode_quad' p = explode "quad" quad_fields p
-*)
-
-(*
-val explode_quad'' (#opened: inames)
-  (p: ref 'a quad_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` quad_view)
-    (fun _ ->
-      (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view))))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_x `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "x" /\
-      can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_y `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "y" /\
-      can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_z `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "z" /\
-      can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quad_w `pts_to_view` c_int.view) == h (p `pts_to_view` quad_view) `struct_get` "w")
-*)
-
-#push-options "--z3rlimit 30 --query_stats"
-
-#pop-options
-#push-options "--fuel 2 --query_stats"
-
-[@@iter_unfold] let x: field_of quad_fields = mk_field_of quad_fields "x"
-[@@iter_unfold] let y: field_of quad_fields = mk_field_of quad_fields "y"
-[@@iter_unfold] let z: field_of quad_fields = mk_field_of quad_fields "z"
-[@@iter_unfold] let w: field_of quad_fields = mk_field_of quad_fields "w"
-
-module T = FStar.Tactics
-
-let norm_list = [
-  delta_attr [`%iter_unfold];
-  delta_only [
-    `%map; `%mem; `%fst; `%Mktuple2?._1;
-    `%assoc;
-    `%Some?.v
-  ];
-  iota; primops; zeta
-]
-
-let quad_aux (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
-  (h': rmem
-     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
-: squash
-   ((
-      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
-        (pts_to_fields "quad" quad_fields p h h' quad_fields))
-   ==
-   (begin
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
-      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
-       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
-         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
-         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
-          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
-   end))
-= _ by (T.trefl ())
-// assert_norm produces a stack overflow?
-//_ by (
-//    T.norm norm_list;
-//    T.trefl ())
-
-let quad_aux2 (p: ref 'a quad_pcm) (h: rmem (p `pts_to_view` quad_view))
-  (h': rmem
-     ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view)))))
-: squash
-   ((
-      norm norm_list//[delta_attr [`%iter_unfold]; iota; primops; zeta]
-        (pts_to_fields "quad" quad_fields p h h' quad_fields))
-   <==>
-   norm norm_list (begin
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      (can_be_split quadprop (ref_focus p _quad_x `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_x `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` x) /\
-      ((can_be_split quadprop (ref_focus p _quad_y `pts_to_view` c_int.view) /\
-       h' (ref_focus p _quad_y `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` y) /\
-       ((can_be_split quadprop (ref_focus p _quad_z `pts_to_view` c_int.view) /\
-         h' (ref_focus p _quad_z `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` z) /\
-         (can_be_split quadprop (ref_focus p _quad_w `pts_to_view` c_int.view) /\
-          h' (ref_focus p _quad_w `pts_to_view` c_int.view) === h (p `pts_to_view` quad_view) `struct_get` w)))
-   end))
-= () // _ by (T.trefl ())
-
-(*
-let quad_unfold_iter_star_fields p
-: Lemma
-    (norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p)) ==
-     (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-        (ref_focus p _quad_w `pts_to_view` c_int.view))))
-= ()
-*)
-
-#push-options "--query_stats"
-
-let explode_quad'' p =
-  explode "quad" quad_fields p;
-  //quad_unfold_iter_star_fields p;
-  //change_equal_slprop
-  //  (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p))
-  //  ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-  //   ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-  //    ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-  //     (ref_focus p _quad_w `pts_to_view` c_int.view))));
-  ()
-
-(*
-val recombine_quad' (#opened: inames)
-  (p: ref 'a quad_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-       (ref_focus p _quad_w `pts_to_view` c_int.view))))
-    (fun _ -> p `pts_to_view` quad_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quadprop =
-        (ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-          (ref_focus p _quad_w `pts_to_view` c_int.view)))
-      in
-      // assert (can_be_split' quadprop (ref_focus p _quad_x `pts_to_view` c_int.view));
-      // assert (can_be_split' quadprop (ref_focus p _quad_y `pts_to_view` c_int.view));
-      // assert (can_be_split' quadprop (ref_focus p _quad_z `pts_to_view` c_int.view));
-      // assert (can_be_split' quadprop (ref_focus p _quad_w `pts_to_view` c_int.view));
-      h (ref_focus p _quad_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "x" /\
-      h (ref_focus p _quad_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "y" /\
-      h (ref_focus p _quad_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "z" /\
-      h (ref_focus p _quad_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quad_view) `struct_get` "w")
-
-let recombine_quad' p =
-  quad_unfold_iter_star_fields p;
-  change_equal_slprop
-    ((ref_focus p _quad_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quad_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quad_z `pts_to_view` c_int.view) `star`
-       (ref_focus p _quad_w `pts_to_view` c_int.view))))
-    (iter_star_fields quad_fields (pts_to_field_vprop "quad" quad_fields p));
-  recombine "quad" quad_fields p
-*)
-
-/// 5 fields!
-
-[@@__reduce__;iter_unfold]
-let quint_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-  "z", c_int;
-  "w", c_int;
-  "v", c_int;
-]
-let quint = struct "quint" quint_fields
-
-let quint_pcm_carrier = struct_pcm_carrier "quint" quint_fields
-let quint_pcm: pcm quint_pcm_carrier = struct_pcm "quint" quint_fields
-
-let mk_quint: int -> int -> int -> int -> int -> quint = mk_struct "quint" quint_fields
-let mk_quint_pcm: option int -> option int -> option int -> option int -> option int -> quint_pcm_carrier = mk_struct_pcm "quint" quint_fields
-
-/// Connections for the fields of a quint
-
-let _quint_x: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "x"
-let _quint_y: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "y"
-let _quint_z: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "z"
-let _quint_w: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "w"
-let _quint_v: connection quint_pcm (opt_pcm #int) = struct_field "quint" quint_fields "v"
-
-/// View for quints
-
-let quint_view: sel_view quint_pcm quint false = struct_view "quint" quint_fields
-
-/// Explode and recombine
-
-(*
-val explode_quint' (#opened: inames)
-  (p: ref 'a quint_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "quint" quint_fields)
-    (fun _ -> iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' -> iter_and_fields quint_fields (pts_to_field "quint" quint_fields p h h'))
-
-let explode_quint' p = explode "quint" quint_fields p
-*)
-
-#restart-solver
-
-val explode_quint'' (#opened: inames)
-  (p: ref 'a quint_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` quint_view)
-    (fun _ ->
-      (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quintprop =
-        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-           (ref_focus p _quint_v `pts_to_view` c_int.view))))
-      in
-      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
-      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
-      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
-      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
-      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v")
-
-let aux p (h: rmem (p `pts_to_view` quint_view))
-  (h': rmem
-     ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-         (ref_focus p _quint_v `pts_to_view` c_int.view))))))
-: Lemma
-   (requires
-      norm [delta_attr [`%iter_unfold]; iota; primops; zeta]
-      (pts_to_fields "quint" quint_fields p h h' quint_fields))
-   (ensures begin
-      let quintprop =
-        (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-          ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-           (ref_focus p _quint_v `pts_to_view` c_int.view))))
-      in
-      can_be_split quintprop (ref_focus p _quint_x `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_x `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "x" /\
-      can_be_split quintprop (ref_focus p _quint_y `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_y `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "y" /\
-      can_be_split quintprop (ref_focus p _quint_z `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_z `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "z" /\
-      can_be_split quintprop (ref_focus p _quint_w `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_w `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "w" /\
-      can_be_split quintprop (ref_focus p _quint_v `pts_to_view` c_int.view) /\
-      h' (ref_focus p _quint_v `pts_to_view` c_int.view) == h (p `pts_to_view` quint_view) `struct_get` "v"
-   end)
-= admit()
-
-(*
-let quint_unfold_iter_star_fields p
-: Lemma
-    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p) ==
-     (ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-         (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-= ()
-*)
-
-#restart-solver
-
-//#push-options "--z3rlimit 30"
-
-let explode_quint'' p =
-  explode "quint" quint_fields p;
-  //quint_unfold_iter_star_fields p;
-  //change_equal_slprop
-  //  (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p))
-  //  ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-  //   ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-  //    ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-  //     ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-  //      (ref_focus p _quint_v `pts_to_view` c_int.view)))));
-  ()
-
-//#pop-options
-
-val recombine_quint' (#opened: inames)
-  (p: ref 'a quint_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-    (fun _ -> p `pts_to_view` quint_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let quintprop =
-        ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-         ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-          ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-           ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-            (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-      in
-      assert (can_be_split' quintprop (ref_focus p _quint_x `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_y `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_z `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_w `pts_to_view` c_int.view));
-      assert (can_be_split' quintprop (ref_focus p _quint_v `pts_to_view` c_int.view));
-      h (ref_focus p _quint_x `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "x" /\
-      h (ref_focus p _quint_y `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "y" /\
-      h (ref_focus p _quint_z `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "z" /\
-      h (ref_focus p _quint_w `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "w" /\
-      h (ref_focus p _quint_v `pts_to_view` c_int.view) == h' (p `pts_to_view` quint_view) `struct_get` "v")
-
-#push-options "--z3rlimit 20"
-
-let recombine_quint' p =
-  quint_unfold_iter_star_fields p;
-  change_equal_slprop
-    ((ref_focus p _quint_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _quint_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _quint_z `pts_to_view` c_int.view) `star`
-       ((ref_focus p _quint_w `pts_to_view` c_int.view) `star`
-        (ref_focus p _quint_v `pts_to_view` c_int.view)))))
-    (iter_star_fields quint_fields (pts_to_field_vprop "quint" quint_fields p));
-  recombine "quint" quint_fields p
-
-#pop-options
-
-/// 8 fields:
-
-let oct_fields: struct_fields = [
-  "x", c_int;
-  "y", c_int;
-  "z", c_int;
-  "w", c_int;
-  "v", c_int;
-  "u", c_int;
-  "t", c_int;
-  "s", c_int;
-]
-let oct = struct "oct" oct_fields
-
-let oct_pcm_carrier = struct_pcm_carrier "oct" oct_fields
-let oct_pcm: pcm oct_pcm_carrier = struct_pcm "oct" oct_fields
-
-let mk_oct: int -> int -> int -> int -> int -> int -> int -> int -> oct = mk_struct "oct" oct_fields
-let mk_oct_pcm: option int -> option int -> option int -> option int -> option int -> option int -> option int -> option int -> oct_pcm_carrier = mk_struct_pcm "oct" oct_fields
-
-/// Connections for the fields of a oct
-
-let _oct_x: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "x"
-let _oct_y: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "y"
-let _oct_z: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "z"
-let _oct_w: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "w"
-let _oct_v: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "v"
-let _oct_u: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "u"
-let _oct_t: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "t"
-let _oct_s: connection oct_pcm (opt_pcm #int) = struct_field "oct" oct_fields "s"
-
-/// View for octs
-
-let oct_view: sel_view oct_pcm oct false = struct_view "oct" oct_fields
-
-/// Explode and recombine
-
-val explode_oct' (#opened: inames)
-  (p: ref 'a oct_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` struct_view "oct" oct_fields)
-    (fun _ -> iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
-    (requires fun _ -> True)
-    (ensures fun h _ h' -> iter_and_fields oct_fields (pts_to_field "oct" oct_fields p h h'))
-
-let explode_oct' p = explode "oct" oct_fields p
-
-val explode_oct'' (#opened: inames)
-  (p: ref 'a oct_pcm)
-: SteelGhost unit opened
-    (p `pts_to_view` oct_view)
-    (fun _ ->
-      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-            ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-             (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      True)
-      // let octprop =
-      //   ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-      //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-      //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-      //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-      //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-      //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-      //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
-      // in
-      // assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
-      // assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
-      // h' (ref_focus p _oct_x `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "x" /\
-      // h' (ref_focus p _oct_y `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "y" /\
-      // h' (ref_focus p _oct_z `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "z" /\
-      // h' (ref_focus p _oct_w `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "w" /\
-      // h' (ref_focus p _oct_v `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "v" /\
-      // h' (ref_focus p _oct_u `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "u" /\
-      // h' (ref_focus p _oct_t `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "t" /\
-      // h' (ref_focus p _oct_s `pts_to_view` c_int.view) == h (p `pts_to_view` oct_view) `struct_get` "s")
-
-let oct_unfold_iter_star_fields p
-: Lemma
-    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
-     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
-= assert_norm (
-    iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
-     ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view)))))))))
-
-#restart-solver
-#push-options "--z3rlimit 40 --query_stats"
-
-let explode_oct'' p =
-  explode "oct" oct_fields p;
-  // OOMs
-  //change_slprop_rel
-  //  (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
-  //  ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-  //    ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-  //     ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-  //      ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-  //       ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-  //        ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-  //         ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-  //          (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
-  //  (fun _ _ -> True)
-  //  (fun m ->
-  //    assert_norm
-  //      (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p) ==
-  //      ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-  //        ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-  //         ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-  //          ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-  //           ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-  //            ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-  //             ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-  //              (ref_focus p _oct_s `pts_to_view` c_int.view))))))))));
-  oct_unfold_iter_star_fields p;
-  change_equal_slprop
-    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p))
-    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view))))))));
-  ()
-
-#pop-options
-
-val recombine_oct' (#opened: inames)
-  (p: ref 'a oct_pcm)
-: SteelGhost unit opened
-    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-     ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-        (ref_focus p _oct_v `pts_to_view` c_int.view)))))
-    (fun _ -> p `pts_to_view` oct_view)
-    (requires fun _ -> True)
-    (ensures fun h _ h' ->
-      let octprop =
-        ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_v `pts_to_view` c_int.view)))))
-      in
-      assert (can_be_split' octprop (ref_focus p _oct_x `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_y `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_z `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_w `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_v `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_u `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_t `pts_to_view` c_int.view));
-      assert (can_be_split' octprop (ref_focus p _oct_s `pts_to_view` c_int.view));
-      h (ref_focus p _oct_x `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "x" /\
-      h (ref_focus p _oct_y `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "y" /\
-      h (ref_focus p _oct_z `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "z" /\
-      h (ref_focus p _oct_w `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "w" /\
-      h (ref_focus p _oct_v `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "v" /\
-      h (ref_focus p _oct_u `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "u" /\
-      h (ref_focus p _oct_t `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "t" /\
-      h (ref_focus p _oct_s `pts_to_view` c_int.view) == h' (p `pts_to_view` oct_view) `struct_get` "s")
-
-#restart-solver
-#push-options "--z3rlimit 20"
-
-let recombine_oct' p =
-  oct_unfold_iter_star_fields p;
-  change_equal_slprop
-    ((ref_focus p _oct_x `pts_to_view` c_int.view) `star`
-      ((ref_focus p _oct_y `pts_to_view` c_int.view) `star`
-       ((ref_focus p _oct_z `pts_to_view` c_int.view) `star`
-        ((ref_focus p _oct_w `pts_to_view` c_int.view) `star`
-         ((ref_focus p _oct_v `pts_to_view` c_int.view) `star`
-          ((ref_focus p _oct_u `pts_to_view` c_int.view) `star`
-           ((ref_focus p _oct_t `pts_to_view` c_int.view) `star`
-            (ref_focus p _oct_s `pts_to_view` c_int.view))))))))
-    (iter_star_fields oct_fields (pts_to_field_vprop "oct" oct_fields p));
-  recombine "oct" oct_fields p
-
-#pop-options
-*)
diff --git a/examples/steel/arraystructs/Steel.C.Array.fst b/examples/steel/arraystructs/Steel.C.Array.fst
deleted file mode 100644
index cc18cf407dd..00000000000
--- a/examples/steel/arraystructs/Steel.C.Array.fst
+++ /dev/null
@@ -1,384 +0,0 @@
-module Steel.C.Array
-
-module S = Steel.C.Struct
-
-let array_domain
-  (t: Type u#0)
-  (n: Ghost.erased size_t)
-: Tot Type0
-= (x: size_t { size_v x < size_v n })
-
-let array_range
-  (t: Type u#0)
-  (n: Ghost.erased size_t)
-  (x: array_domain t n)
-: Tot Type0
-= option t
-
-open FStar.FunctionalExtensionality
-
-let array_pcm_carrier t n = restricted_t (array_domain t n) (array_range t n)
-
-let array_elements_pcm
-  (t: Type u#0)
-  (n: Ghost.erased size_t)
-  (x: array_domain t n)
-: Tot (Steel.C.PCM.pcm (array_range t n x))
-= Steel.C.Opt.opt_pcm #t
-
-let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
-
-[@"opaque_to_smt"]
-let rec raise_list_array_domain
-  (t: Type u#0)
-  (n n': size_t)
-  (l: list (array_domain t n))
-: Pure (list (array_domain t n'))
-  (requires (size_v n' >= size_v n))
-  (ensures (fun l' ->
-    (forall (x': array_domain t n') . List.Tot.mem x' l' <==> (size_v x' < size_v n /\ List.Tot.mem x' l)) /\
-    List.Tot.length l' == List.Tot.length l
-  ))
-= match l with
-  | [] -> []
-  | x :: l_ -> x :: raise_list_array_domain t n n' l_
-
-[@"opaque_to_smt"]
-let rec included_indices
-  (t: Type u#0)
-  (n: size_t)
-: Pure (list (array_domain t n))
-  (requires True)
-  (ensures (fun l ->
-    (forall (x: array_domain t n) . List.Tot.mem x l) /\
-    List.Tot.length l == size_v n
-  ))
-  (decreases (size_v n))
-= if n = mk_size_t (FStar.UInt32.uint_to_t 0)
-  then []
-  else
-    let n' = size_sub n (mk_size_t (FStar.UInt32.uint_to_t 1)) in
-    n' :: raise_list_array_domain t n' n (included_indices t n')
-
-let array_elements_view_type
-  (t: Type u#0)
-  (n: size_t)
-  (k: array_domain t n)
-: Tot Type0
-= t
-
-let array_elements_view
-  (t: Type u#0)
-  (n: size_t)
-  (k: array_domain t n)
-: Tot (Steel.C.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
-= Steel.C.Opt.opt_view _
-
-let intro_array_view_init
-  (t: Type u#0)
-  (n: size_t)
-  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-  (k: nat { k < size_v n })
-: Tot t
-= x (int_to_size_t k)
-
-let intro_array_view
-  (t: Type u#0)
-  (n: size_t)
-  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-: Tot (array_view_type t n)
-= Seq.init (size_v n) (intro_array_view_init t n x)
-
-let array_to_view
-  (t: Type u#0)
-  (n: size_t)
-  (x: Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
-: Tot (array_view_type t n)
-= intro_array_view t n (S.struct_view_to_view (array_elements_view t n) (included_indices t n) x)
-
-let elim_array_view_f
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-  (k: Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
-: Tot (array_elements_view_type t n k)
-= Seq.index x (size_v k)
-
-let elim_array_view
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-: Tot (restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-= on_dom (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
-
-let array_to_carrier
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-: Tot (Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
-= S.struct_view_to_carrier (array_elements_view t n) (included_indices t n) (elim_array_view t n x)
-
-open Steel.C.PCM
-
-let array_view_to_view_frame
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-  (frame: array_pcm_carrier t n)
-: Lemma
-    (requires (composable (array_pcm t n) (array_to_carrier t n x) frame))
-    (ensures
-      S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)
-        (op (array_pcm t n) (array_to_carrier t n x) frame) /\ 
-      array_to_view t n
-        (op (array_pcm t n) (array_to_carrier t n x) frame) `Seq.equal` x)
-= S.struct_view_to_view_frame (array_elements_view t n) (included_indices t n)
-    (elim_array_view t n x) frame
-
-let array_view' (t: Type u#0) (n: size_t)
-  : Tot (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
-=
-  let open Steel.C.Ref in
-  {
-    to_view_prop = S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n);
-    to_view = array_to_view t n;
-    to_carrier = array_to_carrier t n;
-    to_carrier_not_one = (S.struct_view (array_elements_view t n) (included_indices t n)).to_carrier_not_one;
-    to_view_frame = array_view_to_view_frame t n;
-  }
-
-let array_view t n =
-  assert (size_v n > 0);
-  array_view' t n
-
-noeq
-type array base t = {
-  base_len: Ghost.erased size_t;
-  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
-  from: size_t;
-  to: size_t; // must be Tot because of array_small_to_large below
-  prf: squash (
-    size_v base_len >= 0 /\
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  );
-}
-
-let len a = a.to `size_sub` a.from
-
-let array_large_to_small_f
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: Ghost.erased size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t base_len)
-: Tot (array_pcm_carrier t (to `size_sub` from))
-= on_dom (array_domain t (to `size_sub` from)) (fun k -> x (from `size_add` k))
-
-let array_large_to_small
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: Ghost.erased size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Tot (Steel.C.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
-= Steel.C.Connection.mkmorphism
-    (array_large_to_small_f t base_len from to sq)
-    (assert (array_large_to_small_f t base_len from to sq (one (array_pcm t base_len)) `feq` one (array_pcm t (to `size_sub` from))))
-    (fun x1 x2 ->
-      assert (array_large_to_small_f t base_len from to sq (op (array_pcm t base_len) x1 x2) `feq` op (array_pcm t (to `size_sub` from)) (array_large_to_small_f t base_len from to sq x1)  (array_large_to_small_f t base_len from to sq x2))
-    )
-
-let array_small_to_large_f
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t) // Tot, argh
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t (to `size_sub` from))
-: Tot (array_pcm_carrier t base_len)
-= on_dom (array_domain t base_len) (fun k -> if size_le from k && not (size_le to k) then x (k `size_sub` from)
-  else one (Steel.C.Opt.opt_pcm #t))
-
-let array_small_to_large
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Tot (Steel.C.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
-= Steel.C.Connection.mkmorphism
-    (array_small_to_large_f t base_len from to sq)
-    (assert (array_small_to_large_f t base_len from to sq (one (array_pcm t (to `size_sub` from))) `feq` one (array_pcm t (base_len))))
-    (fun x1 x2 ->
-      assert (array_small_to_large_f t base_len from to sq (op (array_pcm t (to `size_sub` from)) x1 x2) `feq` op (array_pcm t (base_len)) (array_small_to_large_f t base_len from to sq x1)  (array_small_to_large_f t base_len from to sq x2))
-    )
-
-let array_small_to_large_to_small
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Lemma
-  (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
-= assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
-
-#push-options "--z3rlimit 32 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
-#restart-solver
-
-assume
-val size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
-  (requires True)
-  (ensures (fun z -> size_v z == size_v x - size_v y))
-
-#restart-solver
-
-let array_conn_fpu_f
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
-  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
-  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
-: Tot (array_pcm_carrier t base_len)
-= let sq0 : squash (size_v to >= size_v from) = () in
-  let z : size_t = size_sub' to from sq0 in
-  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-  // let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
-  // let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
-  // S.prod_pcm_composable_intro
-  //   (array_elements_pcm t z)
-  //   x
-  //   frame_small
-  //   (fun h -> assume False);
-  // assert (composable (array_pcm t (z)) x frame_small);
-  // op_comm (array_pcm t (z)) x frame_small;
-  // assert (op (array_pcm t (z)) frame_small x `feq` v_small);
-  // compatible_intro (array_pcm t (z)) x v_small frame_small;
-  assume (compatible (array_pcm t (z)) x v_small);
-  assume (p_refine (array_pcm t (z)) v_small); // TODO: remove p_refine from Steel.C.PCM
-  let v_small' : array_pcm_carrier t z = f v_small in
-  let v' : array_pcm_carrier t base_len =
-    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
-      if from `size_le` k && not (to `size_le` k)
-      then begin
-        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
-        v_small' (size_sub' k from sq2) <: option t
-      end
-      else v k
-    )
-  in
-  v'
-
-let array_conn_fpu
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
-  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
-: Tot (frame_preserving_upd (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y))
-= frame_preserving_upd_intro
-    (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y)
-    (array_conn_fpu_f t base_len from to sq x y f)
-    (fun _ -> assume False)
-    (fun _ _ -> assume False)
-    (fun _ _ -> assume False)
-
-#pop-options
-
-let array_conn
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Steel.C.Connection.connection
-    (array_pcm t base_len)
-    (array_pcm t (to `size_sub` from))
-=
-  Steel.C.Connection.mkconnection
-    (array_small_to_large t base_len from to sq)
-    (array_large_to_small t base_len from to sq)
-    (array_small_to_large_to_small t base_len from to sq)
-    (array_conn_fpu t base_len from to sq)
-
-#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
-#restart-solver
-
-let array_conn_id
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-: Lemma
-  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id _)
-=
-  let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
-  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
-  assume (forall (x: Ghost.erased (array_pcm_carrier t (base_len `size_sub` z)) { ~ (Ghost.reveal x == one (array_pcm t (base_len `size_sub` z))) }) y (f: frame_preserving_upd (array_pcm t (base_len `size_sub` z)) x y) v . array_conn_fpu_f t base_len z base_len () x y f v `feq` f v);
-  assert (forall x y f . array_conn_fpu_f t base_len z base_len () x y f `feq` f);
-  assume ((array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len ()).Steel.C.Connection.conn_lift_frame_preserving_upd === (Steel.C.Connection.connection_id (array_pcm t base_len)).Steel.C.Connection.conn_lift_frame_preserving_upd);
-  array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () `Steel.C.Connection.connection_eq` Steel.C.Connection.connection_id _
-
-let to_view_array_conn
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t base_len)
-: Lemma
-  (requires (
-    S.struct_view_to_view_prop (array_elements_view t base_len) (included_indices t base_len) x 
-  ))
-  (ensures (
-    let x' = array_large_to_small_f t base_len from to sq x in
-    S.struct_view_to_view_prop (array_elements_view t (to `size_sub` from)) (included_indices t (to `size_sub` from)) x' /\
-    array_to_view t (to `size_sub` from) x' `Seq.equal` Seq.slice (array_to_view t base_len x) (size_v from) (size_v to)
-  ))
-= ()
-
-#pop-options
-
-
-
-(*
-let array_as_ref
-  (#base: Type)
-  (#t: Type)
-  (a: array base t)
-: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
-
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fst b/examples/steel/arraystructs/Steel.C.Fields.fst
index 4277c96292d..aff451e9553 100644
--- a/examples/steel/arraystructs/Steel.C.Fields.fst
+++ b/examples/steel/arraystructs/Steel.C.Fields.fst
@@ -1,7 +1,7 @@
 module Steel.C.Fields
 
-let struct_fields_t_nil: Type0 = unit
-let struct_fields_t_cons
+let c_fields_t_nil: Type0 = unit
+let c_fields_t_cons
   (field: Type0) (t: Type0) (fields: Type0)
 : Type0
 = unit
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
index 347a1235b7f..e155d975af3 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fst
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -152,13 +152,14 @@ let elim_pts_to_or_null_nullptr #a #b #_ #pb #v p =
     (vpure (Ghost.reveal v == None #b <==> p == None #(ref' a b)) `star` vpure True);
   elim_vpure True; elim_vpure _
 
-let elim_pts_to_or_null_nonnull_witness #opened
+assume val elim_pts_to_or_null_nonnull_witness (#opened:inames)
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
 : SteelGhost (Ghost.erased 'b) opened
     (pts_to_or_null p pb v)
-    (fun w -> pts_to_or_null p pb (Some w))
+    (fun w -> pts_to_or_null p pb (Some (Ghost.reveal w)))
     (requires fun _ -> p =!= nullptr)
-    (ensures fun _ w _ -> v == Some w)
+    (ensures fun _ w _ -> Ghost.reveal v == Some (Ghost.reveal w))
+    (*
 = match Ghost.reveal v with
   | None -> 
     let prf = gget (pts_to_or_null p pb v) in
@@ -170,10 +171,14 @@ let elim_pts_to_or_null_nonnull_witness #opened
     let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
     assert (p =!= nullptr);
     change_equal_slprop (pts_to_or_null p pb v) (pts_to_or_null p pb (Some w));
+    sladmit();
     w
+    *)
 
 #set-options "--ide_id_info_off"
 
+let elim_pts_to_or_null = admit()
+(*
 let elim_pts_to_or_null #a #b #_ #pb #v p =
   let w = elim_pts_to_or_null_nonnull_witness p in
   unfold_pts_to_or_null pb p (Some w);
@@ -181,6 +186,7 @@ let elim_pts_to_or_null #a #b #_ #pb #v p =
     (vpure (Ghost.reveal (Some w) == None <==> p == None) `star` pts_to' p pb w);
   elim_vpure (Ghost.reveal (Some w) == None <==> p == None);
   w
+  *)
   
 let is_null #a #b #pb #v p = return (None? p)
 
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 707e3d3e854..506e0f1d923 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -193,6 +193,7 @@ let struct'_without_field
 : struct' tag fields (insert field excluded)
 = on_dom (struct_dom fields (insert field excluded)) v
 
+#push-options "--z3rlimit 30"
 let struct_without_field_to_carrier
   (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_of fields)
   (s: struct_pcm_carrier tag fields)
@@ -207,6 +208,7 @@ let struct_without_field_to_carrier
     struct_without_field (struct_pcms fields) field s
     `feq` (struct_view tag fields (insert field excluded)).to_carrier
          (struct'_without_field tag fields excluded field v))
+#pop-options
 
 let extract_field
   (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
@@ -230,6 +232,17 @@ let extract_field_unextracted
   (v: struct' tag fields excluded)
 = ()
 
+let extract_field_unextracted'
+  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
+  (field: field_of fields)
+  (v: struct' tag fields excluded)
+= let aux (field': field_of fields)
+  : Lemma ( (not (excluded field) /\ not (excluded field') /\ (field =!= field')) ==>
+    (fst (extract_field tag fields excluded field v) `struct_get` field' == v `struct_get` field'))
+  = Classical.move_requires (extract_field_unextracted tag fields excluded field field') v
+  in
+  Classical.forall_intro aux
+
 val addr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -318,6 +331,7 @@ let extract_field_with_field
     (struct'_with_field tag fields excluded field w v)
     `feq` v)
 
+#push-options "--z3rlimit 50"
 let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
@@ -344,6 +358,14 @@ let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
     (struct'_with_field tag fields excluded field w v);
   extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
   return ()
+#pop-options
+
+#restart-solver
+
+#push-options "--admit_smt_queries true"
+
+let dummy_def = ()
 
 let unaddr_of_struct_field_ref #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
+#pop-options
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
index 2f7762b9389..01ca761d098 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fsti
@@ -1,5 +1,7 @@
 module Steel.C.StructLiteral
 
+#set-options "--z3rlimit 50"
+
 open Steel.Memory
 open Steel.Effect
 open Steel.Effect.Common
@@ -19,130 +21,6 @@ open FStar.FSet
 
 module TS = Steel.C.Typestring
 
-(**** MOVE TO ChurchList *)
-
-let rec list_elim (xs: list 'a)
-  (b:(list 'a -> Type))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: b xs
-= match xs with
-  | [] -> base
-  | x :: xs -> ind x xs (list_elim xs b base ind)
-
-let elim_t (#a: Type u#a) (xs: list a): Tot (Type u#(max a (1 + b))) =
-  b:(list a -> Type u#b) ->
-  base:b [] ->
-  ind:(x:a -> xs:list a -> b xs -> b (x :: xs)) ->
-  b xs
-
-//[@@__reduce__]
-noeq type clist (a:Type u#a): Type = {
-  raw: list a;
-  elim0: elim_t u#_ u#0 raw;
-  elim1: elim_t u#_ u#1 raw;
-  elim2: elim_t u#_ u#2 raw;
-  elim3: elim_t u#_ u#3 raw;
-}
-
-//[@@__reduce__]
-let clist_elim0
-  (c: clist 'a)
-  (b:(list 'a -> Type0))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: Pure (b c.raw)
-  (requires True)
-  (ensures (fun y -> y == list_elim c.raw b base ind))
-= let b' (l2: list 'a) : Type =
-    (x: b l2 { x == list_elim l2 b base ind })
-  in
-  c.elim0
-    b'
-    base
-    (fun x xs x' -> ind x xs x')
-
-//[@@__reduce__]
-let clist_elim1
-  (c: clist 'a)
-  (b:(list 'a -> Type u#1))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: Pure (b c.raw)
-  (requires True)
-  (ensures (fun y -> y == list_elim c.raw b base ind))
-= let b' (l2: list 'a) : Type =
-    (x: b l2 { x == list_elim l2 b base ind })
-  in
-  c.elim1
-    b'
-    base
-    (fun x xs x' -> ind x xs x')
-
-//[@@__reduce__]
-let clist_elim2
-  (c: clist 'a)
-  (b:(list 'a -> Type u#2))
-  (base:b [])
-  (ind:(x:'a -> xs:list 'a -> b xs -> b (x :: xs)))
-: Pure (b c.raw)
-  (requires True)
-  (ensures (fun y -> y == list_elim c.raw b base ind))
-= let b' (l2: list 'a) : Type =
-    (x: b l2 { x == list_elim l2 b base ind })
-  in
-  c.elim2
-    b'
-    base
-    (fun x xs x' -> ind x xs x')
-
-#push-options "--print_universes --print_implicits"
-
-#push-options "--fuel 0"
-let mk_clist (xs: list 'a) = {
-  raw = xs;
-  elim0 = list_elim xs;
-  elim1 = list_elim xs;
-  elim2 = list_elim xs;
-  elim3 = list_elim xs;
-}
-let _ =
-  let xs = normalize_term (mk_clist [1; 2; 3; 4]) in
-  assert (clist_elim0 xs (fun _ -> int) 0 (fun x xs sum_xs -> x + sum_xs) == 10)
-#pop-options
-
-//[@@__reduce__]
-let nil (#a: Type u#a): clist u#a a = {
-  raw = [];
-  elim0 = (fun _ base _ -> base);
-  elim1 = (fun _ base _ -> base);
-  elim2 = (fun _ base _ -> base);
-  elim3 = (fun _ base _ -> base);
-}
-
-//[@@__reduce__]
-let cons (#a: Type u#a) (x: a) (xs: clist u#a a): clist u#a a = {
-  raw = x :: xs.raw;
-  elim0 = (fun b base ind -> ind x xs.raw (xs.elim0 b base ind));
-  elim1 = (fun b base ind -> ind x xs.raw (xs.elim1 b base ind));
-  elim2 = (fun b base ind -> ind x xs.raw (xs.elim2 b base ind));
-  elim3 = (fun b base ind -> ind x xs.raw (xs.elim3 b base ind));
-}
-
-//[@@__reduce__]
-let cmem (#a:eqtype) (#b: Type u#b) (x: a) (xs: clist u#0 a): bool
-= clist_elim0 xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur)
-
-//[@@__reduce__]
-let cmem_ok (#a:eqtype) (x: a) (xs: clist u#0 a)
-: Lemma (cmem x xs == mem x xs.raw)
-= let rec aux (xs: list a)
-  : Lemma (list_elim xs (fun _ -> bool) false (fun x' xs recur -> x = x' || recur) == mem x xs)
-  = match xs with [] -> () | x :: xs -> aux xs
-  in aux xs.raw
-
-(**** END MOVE TO ChurchList *)
-
 val mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0
 
 let mk_c_struct (tag: Type0) (fields: c_fields) =
@@ -354,6 +232,7 @@ val extract_field_unextracted
 : Lemma
     (requires not (excluded field) /\ not (excluded field') /\ (field =!= field'))
     (ensures 
+      not (excluded field) /\ not (excluded field') /\ (field =!= field') /\
       fst (extract_field tag fields excluded field v) `struct_get` field'
       == v `struct_get` field')
 //    [SMTPat (extract_field tag fields excluded field v);
@@ -418,7 +297,10 @@ val unaddr_of_struct_field_ref'
        ==
          h (q `pts_to_view` (fields.get_field field).view))
 
-#push-options "--z3rlimit 30"
+#restart-solver
+
+val dummy_def : unit
+
 val unaddr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -448,7 +330,6 @@ val unaddr_of_struct_field_ref
         (extract_field tag fields (remove field excluded) field
           (h' (p `pts_to_view` struct_view tag fields (remove field excluded))))
       == h (q `pts_to_view` (fields.get_field field).view))
-#pop-options
 
 open Steel.C.Reference
 
@@ -523,7 +404,6 @@ let addr_of_struct_field
     (normalize (fields.get_field field).carrier)
     tag fields excluded field p
 
-#push-options "--z3rlimit 30"
 let unaddr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -557,4 +437,3 @@ let unaddr_of_struct_field
 =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
-#pop-options
diff --git a/examples/steel/arraystructs/Steel.C.Typestring.fst b/examples/steel/arraystructs/Steel.C.Typestring.fst
index 44143adbcba..3a5c9343730 100644
--- a/examples/steel/arraystructs/Steel.C.Typestring.fst
+++ b/examples/steel/arraystructs/Steel.C.Typestring.fst
@@ -43,7 +43,7 @@ let cN: Type0 = unit
 let cO: Type0 = unit
 let cP: Type0 = unit
 let cQ: Type0 = unit
-let cr: Type0 = unit
+let cR: Type0 = unit
 let cS: Type0 = unit
 let cT: Type0 = unit
 let cU: Type0 = unit

From 3ec3ccb38b25e903b51a0bd6fea215ab4619d237 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 16:33:22 -0700
Subject: [PATCH 221/513] Reset FStar_Extraction_Kremlin.ml to state on master

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 5e9bca78e68..f9059f8b928 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -80,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -427,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =

From f42415f4bdb295bd0f6bce4ddd5a43050d216e5b Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 13 Aug 2021 16:48:42 -0700
Subject: [PATCH 222/513] Fix build for Steel.C.Frac.fst

---
 examples/steel/arraystructs/Steel.C.Frac.fst |   4 +-
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 740 ++++++++++++++++++-
 2 files changed, 730 insertions(+), 14 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Frac.fst b/examples/steel/arraystructs/Steel.C.Frac.fst
index 347ffcb15fc..15348d3faa7 100644
--- a/examples/steel/arraystructs/Steel.C.Frac.fst
+++ b/examples/steel/arraystructs/Steel.C.Frac.fst
@@ -3,11 +3,13 @@ module Steel.C.Frac
 open Steel.C.PCM
 open Steel.C.Ref
 open Steel.Effect
+open Steel.Effect.Atomic
   
 open Steel.FractionalPermission
 
 let frac_pcm_write r x y
-= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y)
+= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y);
+  change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let frac_pcm_read r x
 = let y' = ref_read r in
diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index f9059f8b928..63549b77614 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type program = decl Prims.list
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -865,6 +981,61 @@ and (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some
+              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
+               ((FStar_Extraction_ML_Syntax.MLTY_Named
+                ([], view_type_name))::[], p));
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
+            FStar_Extraction_ML_Syntax.mllb_def = fields;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
+            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
+            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
+            ((let uu___6 =
+                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
+              FStar_Compiler_Util.print1
+                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
+             (let rec parse_fields fields1 =
+                match fields1 with
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_Name p1;
+                    FStar_Extraction_ML_Syntax.mlty = uu___6;
+                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
+                    let uu___8 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
+                    FStar_Compiler_Util.print_endline "End of fields"
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_App
+                      ({
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Name p1;
+                         FStar_Extraction_ML_Syntax.mlty = uu___6;
+                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
+                       {
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Const
+                           (FStar_Extraction_ML_Syntax.MLC_String name1);
+                         FStar_Extraction_ML_Syntax.mlty = uu___8;
+                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
+                    FStar_Extraction_ML_Syntax.mlty = uu___10;
+                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
+                    let uu___12 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
+                    ((let uu___13 =
+                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
+                          typedef in
+                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
+                        uu___13);
+                     parse_fields fields2)
+                | uu___6 ->
+                    failwith "Couldn't parse fields from struct_fields" in
+              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);
@@ -1070,7 +1241,126 @@ and (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -1180,7 +1470,8 @@ and (translate_type_decl :
                  (FStar_Errors.Warning_DefinitionNotTranslated, uu___8) in
                FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
               FStar_Pervasives_Native.None))
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+and (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -1190,8 +1481,9 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1209,6 +1501,47 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ref" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.array" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1221,7 +1554,8 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1258,16 +1592,18 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type env1 arg in TConstBuf uu___
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (((((((((((((((let uu___ =
                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1323,13 +1659,14 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.Array.array")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1339,19 +1676,36 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
@@ -2606,6 +2960,366 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___8;
+                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.ref_of_array" -> translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.mk_array_of_ref" -> translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.intro_varray" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.split_left" -> translate_expr env1 a
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.split_right" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::al::ar::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.joinc" -> translate_expr env1 al
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           i::[])
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.StdInt.mk_size_t" -> translate_expr env1 i
       | FStar_Extraction_ML_Syntax.MLE_App (head, args) ->
           let uu___ =
             let uu___1 = translate_expr env1 head in

From fd90fb5a0f13bf9b63c47d70c935ece2bf532be6 Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Mon, 23 Aug 2021 08:00:37 -0700
Subject: [PATCH 223/513] Get all files to verify

---
 examples/steel/arraystructs/Steel.C.Opt.fst   |  9 ++++-
 examples/steel/arraystructs/Steel.C.Ptr.fst   | 40 +++++++++----------
 .../steel/arraystructs/Steel.C.Struct.fst     |  2 +
 .../arraystructs/Steel.C.StructLiteral.fst    |  2 +
 examples/steel/arraystructs/Steel.C.Union.fst |  4 +-
 .../arraystructs/Steel.C.UnionLiteral.fst     |  1 +
 6 files changed, 34 insertions(+), 24 deletions(-)

diff --git a/examples/steel/arraystructs/Steel.C.Opt.fst b/examples/steel/arraystructs/Steel.C.Opt.fst
index 42a570a8d34..4b230e58ae0 100644
--- a/examples/steel/arraystructs/Steel.C.Opt.fst
+++ b/examples/steel/arraystructs/Steel.C.Opt.fst
@@ -4,10 +4,12 @@ open Steel.C.PCM
 module A = Steel.Effect.Atomic
 
 let opt_read r =
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   let Some x = ref_read r in
   x
 
 let opt_write #a #b #x r y =
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
@@ -17,7 +19,9 @@ let opt_pcm_write
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
   (requires (fun _ -> Some? x))
   (ensures (fun _ _ _ -> True))
-= ref_upd r x (Some y) (opt_pcm_fpu x y)
+= A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  ref_upd r x (Some y) (opt_pcm_fpu x y);
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let opt_pcm_read
   (#a:Type) (#b: Type)
@@ -25,6 +29,7 @@ let opt_pcm_read
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-= let y' = ref_read r in
+= A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  let y' = ref_read r in
   assert (Ghost.reveal x == y');
   Some?.v y'
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/examples/steel/arraystructs/Steel.C.Ptr.fst
index e155d975af3..22fb302edd9 100644
--- a/examples/steel/arraystructs/Steel.C.Ptr.fst
+++ b/examples/steel/arraystructs/Steel.C.Ptr.fst
@@ -152,41 +152,36 @@ let elim_pts_to_or_null_nullptr #a #b #_ #pb #v p =
     (vpure (Ghost.reveal v == None #b <==> p == None #(ref' a b)) `star` vpure True);
   elim_vpure True; elim_vpure _
 
-assume val elim_pts_to_or_null_nonnull_witness (#opened:inames)
+let elim_pts_to_or_null_nonnull_witness (#opened:inames)
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
 : SteelGhost (Ghost.erased 'b) opened
     (pts_to_or_null p pb v)
     (fun w -> pts_to_or_null p pb (Some (Ghost.reveal w)))
     (requires fun _ -> p =!= nullptr)
     (ensures fun _ w _ -> Ghost.reveal v == Some (Ghost.reveal w))
-    (*
 = match Ghost.reveal v with
   | None -> 
     let prf = gget (pts_to_or_null p pb v) in
     let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
     assert (p == nullptr);
-    unreachable (fun w -> v == Some w)
+    unreachable (fun w -> Ghost.reveal v == Some (Ghost.reveal w))
   | Some w ->
     let prf = gget (pts_to_or_null p pb v) in
     let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
     assert (p =!= nullptr);
     change_equal_slprop (pts_to_or_null p pb v) (pts_to_or_null p pb (Some w));
-    sladmit();
     w
-    *)
 
 #set-options "--ide_id_info_off"
 
-let elim_pts_to_or_null = admit()
-(*
 let elim_pts_to_or_null #a #b #_ #pb #v p =
-  let w = elim_pts_to_or_null_nonnull_witness p in
-  unfold_pts_to_or_null pb p (Some w);
-  change_equal_slprop (pts_to_or_null p pb (Some w))
-    (vpure (Ghost.reveal (Some w) == None <==> p == None) `star` pts_to' p pb w);
-  elim_vpure (Ghost.reveal (Some w) == None <==> p == None);
+  let w: Ghost.erased _ = elim_pts_to_or_null_nonnull_witness p in
+  unfold_pts_to_or_null pb p (Some (Ghost.reveal w));
+  change_equal_slprop (pts_to_or_null p pb (Some (Ghost.reveal w)))
+    (vpure (Ghost.reveal (Ghost.hide (Some (Ghost.reveal w))) == None <==> p == None) `star`
+     pts_to' p pb (Ghost.reveal w));
+  elim_vpure (Ghost.reveal (Ghost.hide (Some (Ghost.reveal w))) == None <==> p == None);
   w
-  *)
   
 let is_null #a #b #pb #v p = return (None? p)
 
@@ -246,13 +241,16 @@ let unfocus #a #b #c #opened #p #q r r' l x =
   let r'' = intro_pts_to_ghost ref_r' in
   change_equal_slprop (pts_to r'' p _) (pts_to r' p _)
 
-let ptr_opt_write
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (p: ptr a (option b)) (y: b)
-: SteelT unit
-    (pts_to p opt_pcm (some x))
-    (fun _ -> pts_to p opt_pcm (some (Ghost.hide y)))
-= let r = elim_pts_to p in
+let ptr_opt_write #a #b #x p y =
+  change_equal_slprop (pts_to p opt_pcm (Some #b (Ghost.reveal x)))
+    (pts_to p opt_pcm (Ghost.reveal (Ghost.hide (Some #b (Ghost.reveal x)))));
+  let r = elim_pts_to #a #_ #opt_pcm p in
+  change_equal_slprop
+    (r `R.pts_to` Ghost.reveal (Ghost.hide (Some #b (Ghost.reveal x))))
+    (r `R.pts_to` Some (Ghost.reveal x));
   r `opt_write` y;
+  change_equal_slprop (Steel.C.Ref.pts_to r _)
+    (Steel.C.Ref.pts_to r (Ghost.reveal (Ghost.hide (Some y))));
   let p' = intro_pts_to r in
-  change_equal_slprop (pts_to p' opt_pcm _) (pts_to p opt_pcm _)
+  change_equal_slprop (pts_to p' opt_pcm _) (pts_to p opt_pcm _);
+  return ()
diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/examples/steel/arraystructs/Steel.C.Struct.fst
index 4a5bd937c10..e6797d61299 100644
--- a/examples/steel/arraystructs/Steel.C.Struct.fst
+++ b/examples/steel/arraystructs/Steel.C.Struct.fst
@@ -311,7 +311,9 @@ let addr_of_struct_field
     (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
 = struct_peel p k xs;
   split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   A.return r
 
 (*
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
index 506e0f1d923..7a2fde071a2 100644
--- a/examples/steel/arraystructs/Steel.C.StructLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.StructLiteral.fst
@@ -275,6 +275,8 @@ let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
     pts_to_view_elim p (struct_view tag fields excluded)
   in
   let q = addr_of_struct_field p field s in
+  change_equal_slprop (p `pts_to` _) (p `pts_to` _);
+  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   struct_without_field_to_carrier tag fields excluded field s v;
   pts_to_view_intro p (struct_without_field (struct_pcms fields) field s)
     (struct_view tag fields (insert field excluded))
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/examples/steel/arraystructs/Steel.C.Union.fst
index 2a608661fa4..abc78c31881 100644
--- a/examples/steel/arraystructs/Steel.C.Union.fst
+++ b/examples/steel/arraystructs/Steel.C.Union.fst
@@ -466,7 +466,9 @@ let addr_of_union_field
     (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
 = union_peel p k xs;
   A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
-  focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
+  let s = focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  A.change_equal_slprop (s `pts_to` _) (s `pts_to` _);
+  A.return s
 
 module M = Steel.Memory 
 let unaddr_of_union_field
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
index 50309d5610e..554b18fe58f 100644
--- a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
+++ b/examples/steel/arraystructs/Steel.C.UnionLiteral.fst
@@ -161,6 +161,7 @@ let addr_of_union_field'
   in
   assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
   let q = Steel.C.Union.addr_of_union_field #'a #_ #_ #(union_pcms fields) p field s in
+  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   pts_to_view_intro q (Ghost.reveal s field)
     (fields.get_field field).view
     (dsnd (Ghost.reveal v));

From c9db2a8da8a5e1f4f3d1a9e6f206f0b7e980277a Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 26 Aug 2021 12:56:18 -0700
Subject: [PATCH 224/513] Move arraystructs files into ulib/experimental; move
 FStar.FSet into ulib

---
 {examples/steel/arraystructs => ulib}/FStar.FSet.fst              | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Array.fsti   | 0
 .../arraystructs => ulib/experimental}/Steel.C.Connection.fst     | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Fields.fst   | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Fields.fsti  | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Frac.fst     | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Frac.fsti    | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Opt.fst      | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Opt.fsti     | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.PCM.fst      | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.PCM.fsti     | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Ptr.fst      | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Ptr.fsti     | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Ref.fst      | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Ref.fsti     | 0
 .../arraystructs => ulib/experimental}/Steel.C.Reference.fst      | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.StdInt.fst   | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.StdInt.fsti  | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Struct.fst   | 0
 .../arraystructs => ulib/experimental}/Steel.C.StructLiteral.fst  | 0
 .../arraystructs => ulib/experimental}/Steel.C.StructLiteral.fsti | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Typedef.fst  | 0
 .../arraystructs => ulib/experimental}/Steel.C.TypedefNorm.fst    | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Typenat.fst  | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Typenat.fsti | 0
 .../arraystructs => ulib/experimental}/Steel.C.Typestring.fst     | 0
 .../arraystructs => ulib/experimental}/Steel.C.Typestring.fsti    | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Uninit.fsti  | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Union.fst    | 0
 .../arraystructs => ulib/experimental}/Steel.C.UnionLiteral.fst   | 0
 .../arraystructs => ulib/experimental}/Steel.C.UnionLiteral.fsti  | 0
 .../steel/arraystructs => ulib/experimental}/Steel.C.Universe.fst | 0
 32 files changed, 0 insertions(+), 0 deletions(-)
 rename {examples/steel/arraystructs => ulib}/FStar.FSet.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Array.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Connection.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Fields.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Fields.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Frac.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Frac.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Opt.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Opt.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.PCM.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.PCM.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Ptr.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Ptr.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Ref.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Ref.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Reference.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.StdInt.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.StdInt.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Struct.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.StructLiteral.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.StructLiteral.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Typedef.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.TypedefNorm.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Typenat.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Typenat.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Typestring.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Typestring.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Uninit.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Union.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.UnionLiteral.fst (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.UnionLiteral.fsti (100%)
 rename {examples/steel/arraystructs => ulib/experimental}/Steel.C.Universe.fst (100%)

diff --git a/examples/steel/arraystructs/FStar.FSet.fst b/ulib/FStar.FSet.fst
similarity index 100%
rename from examples/steel/arraystructs/FStar.FSet.fst
rename to ulib/FStar.FSet.fst
diff --git a/examples/steel/arraystructs/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Array.fsti
rename to ulib/experimental/Steel.C.Array.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Connection.fst
rename to ulib/experimental/Steel.C.Connection.fst
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fst b/ulib/experimental/Steel.C.Fields.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Fields.fst
rename to ulib/experimental/Steel.C.Fields.fst
diff --git a/examples/steel/arraystructs/Steel.C.Fields.fsti b/ulib/experimental/Steel.C.Fields.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Fields.fsti
rename to ulib/experimental/Steel.C.Fields.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fst b/ulib/experimental/Steel.C.Frac.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Frac.fst
rename to ulib/experimental/Steel.C.Frac.fst
diff --git a/examples/steel/arraystructs/Steel.C.Frac.fsti b/ulib/experimental/Steel.C.Frac.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Frac.fsti
rename to ulib/experimental/Steel.C.Frac.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fst b/ulib/experimental/Steel.C.Opt.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Opt.fst
rename to ulib/experimental/Steel.C.Opt.fst
diff --git a/examples/steel/arraystructs/Steel.C.Opt.fsti b/ulib/experimental/Steel.C.Opt.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Opt.fsti
rename to ulib/experimental/Steel.C.Opt.fsti
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fst b/ulib/experimental/Steel.C.PCM.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.PCM.fst
rename to ulib/experimental/Steel.C.PCM.fst
diff --git a/examples/steel/arraystructs/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.PCM.fsti
rename to ulib/experimental/Steel.C.PCM.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fst b/ulib/experimental/Steel.C.Ptr.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Ptr.fst
rename to ulib/experimental/Steel.C.Ptr.fst
diff --git a/examples/steel/arraystructs/Steel.C.Ptr.fsti b/ulib/experimental/Steel.C.Ptr.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Ptr.fsti
rename to ulib/experimental/Steel.C.Ptr.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Ref.fst
rename to ulib/experimental/Steel.C.Ref.fst
diff --git a/examples/steel/arraystructs/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Ref.fsti
rename to ulib/experimental/Steel.C.Ref.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Reference.fst
rename to ulib/experimental/Steel.C.Reference.fst
diff --git a/examples/steel/arraystructs/Steel.C.StdInt.fst b/ulib/experimental/Steel.C.StdInt.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.StdInt.fst
rename to ulib/experimental/Steel.C.StdInt.fst
diff --git a/examples/steel/arraystructs/Steel.C.StdInt.fsti b/ulib/experimental/Steel.C.StdInt.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.StdInt.fsti
rename to ulib/experimental/Steel.C.StdInt.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Struct.fst b/ulib/experimental/Steel.C.Struct.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Struct.fst
rename to ulib/experimental/Steel.C.Struct.fst
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.StructLiteral.fst
rename to ulib/experimental/Steel.C.StructLiteral.fst
diff --git a/examples/steel/arraystructs/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.StructLiteral.fsti
rename to ulib/experimental/Steel.C.StructLiteral.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Typedef.fst b/ulib/experimental/Steel.C.Typedef.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Typedef.fst
rename to ulib/experimental/Steel.C.Typedef.fst
diff --git a/examples/steel/arraystructs/Steel.C.TypedefNorm.fst b/ulib/experimental/Steel.C.TypedefNorm.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.TypedefNorm.fst
rename to ulib/experimental/Steel.C.TypedefNorm.fst
diff --git a/examples/steel/arraystructs/Steel.C.Typenat.fst b/ulib/experimental/Steel.C.Typenat.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Typenat.fst
rename to ulib/experimental/Steel.C.Typenat.fst
diff --git a/examples/steel/arraystructs/Steel.C.Typenat.fsti b/ulib/experimental/Steel.C.Typenat.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Typenat.fsti
rename to ulib/experimental/Steel.C.Typenat.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Typestring.fst b/ulib/experimental/Steel.C.Typestring.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Typestring.fst
rename to ulib/experimental/Steel.C.Typestring.fst
diff --git a/examples/steel/arraystructs/Steel.C.Typestring.fsti b/ulib/experimental/Steel.C.Typestring.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Typestring.fsti
rename to ulib/experimental/Steel.C.Typestring.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Uninit.fsti b/ulib/experimental/Steel.C.Uninit.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Uninit.fsti
rename to ulib/experimental/Steel.C.Uninit.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Union.fst b/ulib/experimental/Steel.C.Union.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Union.fst
rename to ulib/experimental/Steel.C.Union.fst
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.UnionLiteral.fst
rename to ulib/experimental/Steel.C.UnionLiteral.fst
diff --git a/examples/steel/arraystructs/Steel.C.UnionLiteral.fsti b/ulib/experimental/Steel.C.UnionLiteral.fsti
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.UnionLiteral.fsti
rename to ulib/experimental/Steel.C.UnionLiteral.fsti
diff --git a/examples/steel/arraystructs/Steel.C.Universe.fst b/ulib/experimental/Steel.C.Universe.fst
similarity index 100%
rename from examples/steel/arraystructs/Steel.C.Universe.fst
rename to ulib/experimental/Steel.C.Universe.fst

From a4447701bc81308a66f1ea2504d03c24d88263da Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Thu, 26 Aug 2021 14:49:50 -0700
Subject: [PATCH 225/513] Document Steel.C.*.fsti

---
 ulib/experimental/Steel.C.Connection.fst     | 13 ++++++++
 ulib/experimental/Steel.C.Fields.fsti        | 34 ++++++++++++++++++++
 ulib/experimental/Steel.C.Ptr.fsti           | 16 ++++++++-
 ulib/experimental/Steel.C.Ref.fsti           | 34 ++++++++++++++++++++
 ulib/experimental/Steel.C.StructLiteral.fsti | 31 ++++++++++++++++++
 ulib/experimental/Steel.C.Typedef.fst        |  6 +++-
 ulib/experimental/Steel.C.Typenat.fsti       |  5 +++
 ulib/experimental/Steel.C.Typestring.fsti    |  5 +++
 ulib/experimental/Steel.C.UnionLiteral.fsti  | 20 +++++++++++-
 9 files changed, 161 insertions(+), 3 deletions(-)

diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index 1e716ea36fc..1fa939a4d4c 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -3,6 +3,8 @@ module Steel.C.Connection
 open Steel.C.PCM
 open FStar.FunctionalExtensionality
 
+(** PCM morphisms *)
+
 let morph_compose2 (pa: pcm 'a) (pb: pcm 'b) (morph: 'a -> 'b)
   (x1: 'a) (x2: 'a{composable pa x1 x2})
 = squash (
@@ -17,8 +19,10 @@ type morphism (#a #b: Type) (pa: pcm a) (pb: pcm b) = {
   morph: (a ^-> b);
   morph_unit: squash (morph (one pa) == one pb);
   morph_compose: restricted_t a (morph_compose1 pa pb morph);
+  (** Extensionality is needed to show that composition of morphism is associative *)
 }
 
+(** A smart constructor for extensional morphisms *)
 let mkmorphism (#pa: pcm 'a) (#pb: pcm 'b) (morph: 'a -> 'b)
   (morph_unit: squash (morph (one pa) == one pb))
   (morph_compose: (x1:'a -> x2:'a{composable pa x1 x2} -> morph_compose2 pa pb (on_dom 'a morph) x1 x2))
@@ -170,6 +174,15 @@ let fpu_lift_elim (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_s
 : Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y))
 = lift (| x, y, restricted_frame_preserving_upd_intro f |)
 
+(** A connection from a "large" PCM p_large to a "small" PCM p_small
+    is composed of an injective morphism small->large + the left inverse
+    that witnesses its injectivity, along with a way of lifting
+    frame-preserving updates on p_small to frame-preserving updates on
+    p_large.
+    
+    Like morphisms, we require connections be extensional in order to
+    prove the associativity of connection composition. *)
+
 noeq
 type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t_small) = {
   conn_small_to_large: morphism p_small p_large;
diff --git a/ulib/experimental/Steel.C.Fields.fsti b/ulib/experimental/Steel.C.Fields.fsti
index 437248ea0c1..5381f684473 100644
--- a/ulib/experimental/Steel.C.Fields.fsti
+++ b/ulib/experimental/Steel.C.Fields.fsti
@@ -8,6 +8,7 @@ open Steel.C.Opt
 
 module TS = Steel.C.Typestring
 
+(** Used to control normalization *)
 irreducible let c_struct = ()
 irreducible let c_union = ()
 irreducible let c_typedef = ()
@@ -21,6 +22,19 @@ let trivial_typedef: typedef = {
   is_unit = (fun o -> None? o);
 }
 
+(** While possible to encode struct fields as a list of (field name,
+    typedef) pairs, such a representation does not play well with F*'s
+    normalizer due to the fact that many kinds of queries we would like to
+    perform on such lists of struct fields require recursion over that
+    list. This interacts poorly with Steel's normalization tactic, and
+    requires the user to increase fuel, which can be costly. To sidestep
+    this, we essentially encode a list of fields by all of the various
+    types at which we would like to eliminate that list, and build up each
+    elimination at "list"-construction time by exposing combinators
+    {c_fields_nil, c_fields_cons} which, rather than constructing a
+    list, just precompute all of the facts that we could ever need to
+    know in the future about it. All such facts are represented in
+    the following c_fields struct. *)
 //[@@__reduce__]
 noeq type c_fields = {
   //cfields: clist string;
@@ -39,6 +53,11 @@ noeq type c_fields = {
 
 (* Begin for extraction *)
 
+(** The following combinators encode c_fields as a F* type, which
+    allows struct field information to stick around after erasure for
+    Kremlin. For more details about why we need this, see
+    Steel.C.Typestring.fsti and Steel.C.Typenat.fsti *)
+
 val c_fields_t_nil: Type0
 val c_fields_t_cons
   (field: Type0) (t: Type0) (fields: Type0)
@@ -83,6 +102,21 @@ let fields_cons (field: field_t) (td: typedef) (fields: c_fields): c_fields = {
 
 let field_of (fields: c_fields) = field:string{fields.has_field field == true /\ field =!= ""}
 
+(** We divide normalization into two stages:
+      1) First, all typedefs (which ought to have been defined with attribute c_typedef) are unfolded.
+      2) Then, struct/union fields (which ought to have been defined
+         with attributes c_struct and c_union respectively) are unfolded
+         along with a number of helper definitions.
+    This two-step normalization process is used by
+    addr_of_struct_field and addr_of_union_field, and was developed to
+    ensure that, in the case where a struct has structs inside of it,
+    only the outermost typedef representing the outermost struct is
+    unfolded.
+    
+    In retrospect, it's unclear whether this is needed, or even
+    whether [norm] actually carries out such a 2-stage process.
+    TODO see if this can be simplified *)
+
 unfold let unfold_typedefs = [delta_attr [`%c_typedef]]
 
 unfold let simplify_typedefs =
diff --git a/ulib/experimental/Steel.C.Ptr.fsti b/ulib/experimental/Steel.C.Ptr.fsti
index 61a932492e9..d6a60fe07ac 100644
--- a/ulib/experimental/Steel.C.Ptr.fsti
+++ b/ulib/experimental/Steel.C.Ptr.fsti
@@ -11,14 +11,19 @@ open Steel.C.Ref
 open Steel.C.Connection
 open Steel.Effect
 
+(** The type of nullable pointers to values of type b inside "base objects" of type a. *)
 val ptr (a: Type u#0) (b: Type u#b) : Type u#b
 
+(** [pts_to p pb v] if p is non-null, has PCM pb, and points to v *)
 val pts_to (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: 'b): vprop
 
+(** [pts_to_or_null p pb v] if p is null or points to v *)
 val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: option 'b): vprop
 
+(** The null pointer. *)
 val nullptr (#a:Type) (#b:Type) : ptr a b
 
+(** A non-null pointer that corresponds to underlying reference r. *)
 val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
 
 val nullptr_vptr_disjoint (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb)
@@ -27,6 +32,7 @@ val nullptr_vptr_disjoint (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb)
 val vptr_injective (#a:Type) (#b:Type) (#pb: pcm b) (r r': ref a pb)
 : Lemma (requires vptr r == vptr r') (ensures r == r') [SMTPat (vptr r); SMTPat (vptr r')]
 
+(** If [pts_to p pb v] then p is non-null. *)
 val pts_to_nonnull (#opened:inames) (#a:Type) (#b:Type) (#pb: pcm b)
   (#v: Ghost.erased b)
   (p: ptr a b)
@@ -36,6 +42,8 @@ val pts_to_nonnull (#opened:inames) (#a:Type) (#b:Type) (#pb: pcm b)
     (requires fun _ -> True)
     (ensures fun _ _ _ -> p =!= nullptr)
 
+(** Introduction and elimination rules for pts_to *)
+
 val intro_pts_to
   (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
 : Steel (ptr 'a 'b)
@@ -52,6 +60,8 @@ val elim_pts_to
     (requires fun _ -> True)
     (ensures fun _ r _ -> p == vptr r)
 
+(** Introduction and elimination rules for pts_to_or_null *)
+
 val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
   (pb: pcm b)
 : SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb None)
@@ -78,6 +88,7 @@ val elim_pts_to_or_null (#opened:inames)
     (requires fun _ -> p =!= nullptr)
     (ensures fun _ w _ -> Ghost.reveal v == Some #'b w)
 
+(** Test whether a pointer is null. *)
 val is_null
   (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
 : Steel bool
@@ -86,6 +97,8 @@ val is_null
     (requires fun _ -> Some? v ==> Some?.v v =!= one pb)
     (ensures fun _ b _ -> b <==> p == nullptr)
 
+(** Focus/unfocus on pointers *)
+
 val ptr_focused
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r': ptr a c) (r: ptr a b) (#q: pcm c) (l: connection p q)
@@ -109,7 +122,8 @@ val unfocus (#a #b #c:Type) (#opened:Steel.Memory.inames)
     (fun _ -> pts_to r' p (l.conn_small_to_large.morph x))
     (requires fun _ -> ptr_focused r r' l)
     (ensures fun _ _ _ -> True)
-    
+
+(** Write for pointers using the all-or-none PCM *)
 val ptr_opt_write
   (#a:Type) (#b:Type) (#x: Ghost.erased b)
   (p: ptr a (option b)) (y: b)
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index d1719d86f06..0be569dfe64 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -5,20 +5,27 @@ open Steel.C.Connection
 
 #push-options "--print_universes"
 
+(** A [ref' a b] is a reference to some value of type b inside of a "base object" of type a. *)
 val ref' (a: Type u#0) (b: Type u#b) : Type u#b
 
+(** The PCM that governs the values pointed to by a ref' *)
 val pcm_of_ref' (#a: _) (#b: Type u#b) (r: ref' a b) : GTot (pcm b)
 
+(** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
 let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
   (r: ref' a b { pcm_of_ref' r == q })
 
 open Steel.Effect
 
+(** r points to PCM carrier value v *)
 val pts_to
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p) ([@@@smt_fallback] v: b)
 : vprop
 
+(** Given a reference to an element of PCM p and a connection l from p to q,
+    [ref_focus r l] is a reference to an element of q. The intuition is that
+    q represents a "part of" p (e.g. a struct field, union case, or array slice). *)
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
@@ -39,6 +46,7 @@ val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
 
 module A = Steel.Effect.Atomic
 
+(** Allocate a reference containing value x. *)
 val ref_alloc
   (#a:Type0) (p: pcm a) (x: a)
 : Steel (ref a p)
@@ -47,6 +55,7 @@ val ref_alloc
     (requires fun _ -> p_refine p x)
     (ensures fun _ _ _ -> True)
 
+(** Take a pointer to a "substructure" of a reference. *)
 val focus (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
@@ -58,6 +67,7 @@ val focus (#p: pcm 'b) (r: ref 'a p)
 
 module M = Steel.Memory
 
+(** Inverse of focus. *)
 val unfocus (#opened:M.inames)
   (#p: pcm 'b)
   (#q: pcm 'c)
@@ -69,6 +79,7 @@ val unfocus (#opened:M.inames)
     (requires fun _ -> r == ref_focus r' l)
     (ensures fun _ _ _ -> True)
 
+(** Split the permissions on a reference into two halves. *)
 val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 : Steel unit
     (r `pts_to` xy)
@@ -76,11 +87,13 @@ val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
     (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
     (fun _ _ _ -> True)
 
+(** Inverse of split. *)
 val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
 : SteelT (_:unit{composable p x y})
     ((r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> r `pts_to` op p x y)
 
+(** Read a PCM carrier value. *)
 val ref_read
   (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
 : Steel b
@@ -89,11 +102,13 @@ val ref_read
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible p x x')
 
+(** Write a PCM carrier value. *)
 val ref_upd
   (#a:Type) (#b:Type) (#p: pcm b)
   (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 
+(** Construct a write from a frame-preserving update. *)
 val base_fpu
   (#a: Type)
   (p: pcm a)
@@ -106,6 +121,10 @@ val base_fpu
 let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
   (x: a { p x })
 
+(** PCM carrier values are cumbersome to work with directly. To
+    abstract over them, we define "view"s, which are essentially
+    lossless partial functions from PCM carrier values to "view
+    types".  *)
 noeq
 type sel_view
   (#carrier: Type u#a)
@@ -113,11 +132,24 @@ type sel_view
   (view: Type u#b)
   (can_view_unit:bool)
 = {
+  (** When is a PCM carrier value viewable? *)
   to_view_prop: (carrier -> Tot prop);
   to_view: (refine carrier to_view_prop -> Tot view);
+  (** Construct a PCM carrier value from a view (used for writes) *)
   to_carrier: (view -> Tot (refine carrier to_view_prop));
+  (** If can_view_unit is false, then the unit of the PCM must be unviewable.
+      If can_view_unit is true, all bets are off.
+      This was originally used to allow viewing empty structs (which
+      would have can_view_unit := true).  Empty structs aren't useful
+      in C programming, but they can temporarily arise in our model
+      after one has taken pointers to every field of a nonempty
+      struct.
+      We eventually found a different way of coping with this
+      situation (see Steel.C.StructLiteral for details), so we in fact use (can_view_unit := false) everywhere
+      and we could get rid of can_view_unit entirely. *)
   to_carrier_not_one:
     squash (~ can_view_unit ==> ~ (exists x. to_carrier x == one p) /\ ~ (to_view_prop (one p)));
+  (** The PCM carrier value corresponding to a view must be stable under composition with surrounding frames. *)
   to_view_frame:
     (x: view) ->
     (frame: carrier) ->
@@ -126,6 +158,8 @@ type sel_view
     (ensures (to_view_prop (op p (to_carrier x) frame) /\ to_view (op p (to_carrier x) frame) == x));
 }
 
+(** Every sel_view gives rise to a selector, which we can use to hide even the view-type values. *)
+
 let weaken_view (#p: pcm 'a) (v: sel_view p 'b false): sel_view p 'b true = {
   to_view_prop = v.to_view_prop;
   to_view = v.to_view;
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index 01ca761d098..dff1786d5ae 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -23,16 +23,29 @@ module TS = Steel.C.Typestring
 
 val mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0
 
+(** To declare a struct definition, one needs to write
+      let _ = norm norm_c_typedef (mk_c_struct <struct_tag> <struct_fields>).
+    This normalizes to a type (mk_struct_def t fs), where
+      t is an embedding of the struct tag name as a Type0 (see Steel.C.Typestring), and
+      fs is an embedding of the struct fields as a Type0
+    Kremlin then parses this embedding and emits a C struct definition. *)
 let mk_c_struct (tag: Type0) (fields: c_fields) =
   mk_struct_def tag (c_fields_t fields)
 
+(** When we take a pointer &p->foo, p loses access to field foo.
+    To record this fact, we explcitly track the set of excluded fields. *)
 let excluded_fields = s:set string{s "" == false}
 
+(** A [struct' tag fields excluded] is a view type for C structs with
+    tag [tag], fields [fields], and excluded fields [excluded]. *)
 val struct' (tag: Type0) (fields: c_fields) (excluded: excluded_fields): Type0
 
+(** A [struct tag fields] is a view type for C structs with tag [tag] and fields [fields]. *)
 inline_for_extraction
 let struct (tag: Type0) (fields: c_fields) = struct' tag fields emptyset
 
+(** Combinators for constructing struct literals *)
+
 val mk_nil (tag: Type0): struct tag fields_nil
 
 val mk_cons (tag: Type0) (fields: c_fields)
@@ -41,8 +54,11 @@ val mk_cons (tag: Type0) (fields: c_fields)
     (requires fields.has_field field == false)
     (ensures fun _ -> True)
 
+(** [struct_pcm_carrier tag fields] is the carrier of the PCM which
+    models structs with tag [tag] and fields [fields]. *)
 val struct_pcm_carrier (tag: Type0) (fields: c_fields): Type0
 
+(** [struct_pcm] is the PCM that models structs with tag [tag] and fields [fields]. *)
 val struct_pcm (tag: Type0) (fields: c_fields): pcm (struct_pcm_carrier tag fields)
 
 /// Reading a struct field
@@ -203,10 +219,12 @@ let typedef_struct (tag: Type0) (fields: c_fields): typedef = {
   is_unit = struct_is_unit tag fields;
 }
 
+(** A connection from a struct to any of its fields *)
 val struct_field
   (tag: Type0) (fields: c_fields) (field: field_of fields)
 : connection (struct_pcm tag fields) (fields.get_field field).pcm
 
+(** extract_field tag fields excluded field v = (v without field field, v.field) *)
 val extract_field
   (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
   (field: field_of fields)
@@ -368,6 +386,18 @@ let addr_of_struct_field''
          h' (q `pts_to_view` (fields.get_field field).view))
 = addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
+(** Take the address of a field of a struct.
+    The above definitions are set up so that calls to addr_of_struct_field are erased to calls to addr_of_struct_field'' with
+      (fields.get_field field).view_type
+    and
+      (fields.get_field field).carrier
+    fully normalized. This allows the extracted OCaml code to be
+    ML-typable, avoiding Obj.magic and the insertion of spurious casts
+    in the extracted C.
+
+    Calls to [norm] are used to compute the type of values pointed to
+    by the returned reference, and to ensure that the Steel tactic
+    will be able to unify vprops properly. *)
 inline_for_extraction noextract
 let addr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
@@ -404,6 +434,7 @@ let addr_of_struct_field
     (normalize (fields.get_field field).carrier)
     tag fields excluded field p
 
+(** Inverse of unaddr_of_struct_field. *)
 let unaddr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
diff --git a/ulib/experimental/Steel.C.Typedef.fst b/ulib/experimental/Steel.C.Typedef.fst
index 2948da6c44f..7c4666f170b 100644
--- a/ulib/experimental/Steel.C.Typedef.fst
+++ b/ulib/experimental/Steel.C.Typedef.fst
@@ -8,11 +8,15 @@ open Steel.Effect
 
 irreducible let iter_unfold = 0
 
+(** A typedef bundles together the various pieces of information needed to model a C data type in Steel. *)
 [@@__reduce__]
 noeq type typedef = { 
-  carrier: Type0; 
+  (** The PCM used to model values of the corresponding C type. *)
+  carrier: Type0;
   pcm: pcm carrier; 
+  (** A way to view PCM carrier values as F* values that model the corresponding C values. *)
   view_type: Type0; 
   view: sel_view pcm view_type false;
+  (** A way to decide whether a given element of the PCM is unit (needed to determine the case of a union) *)
   is_unit: x:carrier -> b:bool{b <==> x == one pcm};
 } 
diff --git a/ulib/experimental/Steel.C.Typenat.fsti b/ulib/experimental/Steel.C.Typenat.fsti
index 59b908d020b..5a10dc54f98 100644
--- a/ulib/experimental/Steel.C.Typenat.fsti
+++ b/ulib/experimental/Steel.C.Typenat.fsti
@@ -1,5 +1,10 @@
 module Steel.C.Typenat
 
+(** Suppose [array (n : nat) (t : Type)] represents the type of array values.
+    Then, when extracting values of type [ref (array n t)], the length n is lost.
+    To make sure this information sticks around, this module provides
+    an encoding of natural numbers as types. *)
+
 val z: Type0
 val s: Type0 -> Type0
 
diff --git a/ulib/experimental/Steel.C.Typestring.fsti b/ulib/experimental/Steel.C.Typestring.fsti
index 218ad05ada6..ffdf1e5ee3b 100644
--- a/ulib/experimental/Steel.C.Typestring.fsti
+++ b/ulib/experimental/Steel.C.Typestring.fsti
@@ -1,5 +1,10 @@
 module Steel.C.Typestring
 
+(** Suppose [struct (t : string) (fields : struct_fields)] represents the type of struct values.
+    Then, when extracting values of type [ref (struct t fields)], the tag t is lost.
+    To make sure this information sticks around, this module provides
+    an encoding of strings like t as types. *)
+
 val ca: Type0
 val cb: Type0
 val cc: Type0
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fsti b/ulib/experimental/Steel.C.UnionLiteral.fsti
index e414f501ede..7d45f194042 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fsti
+++ b/ulib/experimental/Steel.C.UnionLiteral.fsti
@@ -21,22 +21,29 @@ module TS = Steel.C.Typestring
 
 val mk_union_def (tag: Type0) (field_descriptions: Type0): Type0
 
+(** To declare a struct definition, one needs to write
+      let _ = norm norm_c_typedef (mk_c_struct <struct_tag> <struct_fields>).
+    See Steel.C.StructLiteral.mk_c_struct for more details. *)
 let mk_c_union (tag: Type0) (fields: c_fields) =
   mk_union_def tag (c_fields_t fields)
 
 let union_views (fields: c_fields) (field: field_of fields): Type0 =
   (fields.get_field field).view_type
 
+(** A [union tag fields] is a view type for C union with tag [tag] and fields [fields]. *)
 val union (tag: Type0) (fields: c_fields): Type0
 
+(** [mk_union tag fields field x] represents the union literal (union tag) {.field = x} *)
 val mk_union (tag: Type0) (fields: c_fields)
   (field: field_of fields) (x: (fields.get_field field).view_type)
 : Pure (union tag fields)
     (requires fields.has_field field == true)
     (ensures fun _ -> True)
 
+(** The carrier of the PCM representing unions with tag [tag] and fields [fields]. *)
 val union_pcm_carrier (tag: Type0) (fields: c_fields): Type0
 
+(** The PCM representing unions with tag [tag] and fields [fields]. *)
 val union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields)
 
 let nonempty_c_fields = fields:c_fields{Some? fields.nonempty_witness}
@@ -44,6 +51,11 @@ let nonempty_c_fields = fields:c_fields{Some? fields.nonempty_witness}
 val union_view (tag: Type0) (fields: nonempty_c_fields)
 : sel_view (union_pcm tag fields) (union tag fields) false
 
+(** For now we expose an isomorphism between values of type [union tag fields] and dependent tuples.
+    This allows a particularly dedicated Steel programmer to bypass the nominality of C unions, because
+    it reveals the fact that the tag name is completely unused. In the future we should essentially expose
+    (dfst . dtuple2_of_union) and (dsnd . dtuple2_of_union) and the right laws, but not the whole isomorphism. *)
+
 val dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
 : dtuple2 (field_of fields) (union_views fields)
 
@@ -61,6 +73,7 @@ val union_of_dtuple2_of_union
   (x: union tag fields)
 : Lemma (union_of_dtuple2 (dtuple2_of_union #tag #fields x) == x)
 
+(** A connection from a union to any of its fields *)
 val union_field
   (tag: Type0) (fields: c_fields) (field: field_of fields)
 : connection (union_pcm tag fields) (fields.get_field field).pcm
@@ -105,6 +118,9 @@ val addr_of_union_field''
       dtuple2_of_union #tag #fields (h (p `pts_to_view` union_view tag fields))
         == (|field, h' (q `pts_to_view` (fields.get_field field).view)|))
 
+(** Take the address of a field of a union.
+    The definitions and normalization strategies are identical to
+    those described in Steel.C.StructLiteral.addr_of_struct_field. *)
 inline_for_extraction noextract
 let addr_of_union_field
   (#tag: Type0) (#fields: c_fields)
@@ -135,6 +151,7 @@ let addr_of_union_field
     (normalize (fields.get_field field).carrier)
     tag fields field p
 
+(** Inverse of addr_of_union_field. *)
 val unaddr_of_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
@@ -174,12 +191,13 @@ val switch_union_field'
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
         == (|field, new_value|))
 
+(** Switch the case of a union to field [field] by writing [new_value] to it. *)
 noextract inline_for_extraction
 let switch_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
   (p: ref 'a (union tag fields) (union_pcm tag fields))
-  // TODO match order of c to get p->field = new_value
+  // TODO it would be nice permute the arguments so that their order matches the C code p->field = new_value
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)

From f08b5e477dc77e7404d835742db5543d7c23f4ea Mon Sep 17 00:00:00 2001
From: John Li <johnli0135@gmail.com>
Date: Fri, 27 Aug 2021 06:20:30 -0700
Subject: [PATCH 226/513] Document examples

---
 examples/steel/arraystructs/HaclExample.fst |  27 ++-
 examples/steel/arraystructs/PointStruct.fst | 237 +++++---------------
 examples/steel/arraystructs/ScalarUnion.fst | 177 ++-------------
 3 files changed, 93 insertions(+), 348 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index fe45269d080..4006b9a5cb0 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -21,6 +21,15 @@ open Steel.C.Typestring
 
 module U64 = FStar.UInt64
 
+(** In this file we demonstrate how Steel could be used to manipulate the following data type used in Hacl*:
+      https://github.com/project-everest/hacl-star/blob/master/code/poly1305/Hacl.Impl.Poly1305.fsti#L18
+    This Low* definition amounts to the struct definition
+      struct poly1305_ctx { uint64_t limbs[5]; uint64_t precomp[20]; };
+    and, with our new model of structs and arrays and pointer-to-field, can be expresesd directly in Steel.
+
+    See PointStruct.fst for more detailed explanations of the various definitions needed below.
+*)
+
 [@@c_typedef]
 noextract inline_for_extraction
 let u64: typedef = {
@@ -47,14 +56,18 @@ noextract inline_for_extraction let twenty' = normalize (nat_t_of_nat 20)
 noextract inline_for_extraction let twenty: size_t_of twenty' = mk_size_t (U32.uint_to_t 20)
 #pop-options
 
+(** uint64_t[5] *)
 [@@c_struct]
 noextract inline_for_extraction
 let five_u64s: typedef = array_typedef_sized U64.t five' five
 
+(** uint64_t[20] *)
 [@@c_struct]
 noextract inline_for_extraction
 let twenty_u64s: typedef = array_typedef_sized U64.t twenty' twenty
 
+(** struct comp { uint64_t limbs[5]; uint64_t precomp[20]; }; *)
+
 [@@c_struct]//;c_typedef]
 noextract inline_for_extraction
 let comp_fields: c_fields =
@@ -75,9 +88,13 @@ let comp_pcm = struct_pcm comp_tag comp_fields
 noextract inline_for_extraction
 let c_comp: typedef = typedef_struct comp_tag comp_fields
 
-//let x : unit -> norm norm_list (mk_c_struct comp_tag comp_fields) = fun _ -> admit(); magic()
 let _ = norm norm_c_typedef (mk_c_struct comp_tag comp_fields)
 
+(** To demonstrate how our model could be used, we write a simple
+    function that takes pointers to the limbs and precomp fields and
+    passes them to helper functions (which in this case simply set on
+    element of the corresponding array to zero) *)
+
 let do_something_with_limbs
   (a: array 'a U64.t)
 : Steel unit
@@ -85,13 +102,7 @@ let do_something_with_limbs
     (fun _ -> varray a)
     (requires fun _ -> length a == 5)
     (ensures fun _ _ _ -> True)
-= // let alar = split a (mk_size_t (U32.uint_to_t 1)) in
-  // let q = split_left a (mk_size_t (U32.uint_to_t 1)) in
-  // let p = ref_of_array q in
-  // p `opt_write_sel` (U64.uint_to_t 0);
-  // array_of_ref q p;
-  // join' (GPair?.fst alar) (GPair?.snd alar);
-  upd a (mk_size_t (U32.uint_to_t 2)) (U64.uint_to_t 0);
+= upd a (mk_size_t (U32.uint_to_t 2)) (U64.uint_to_t 0);
   return ()
 
 let do_something_with_precomp
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index e55ffe77977..019fd0c5dde 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -20,6 +20,10 @@ module U32 = FStar.UInt32
 
 unfold let int' = FStar.UInt32.t
 
+(** A struct is encoded by what amounts to a list of (field name, typedef) pairs.
+    In this example, we define a struct named point with two u32 fields; to do so
+    we need a typedef for u32s. *)
+
 [@@c_typedef]
 noextract inline_for_extraction
 let c_int': typedef = {
@@ -32,11 +36,27 @@ let c_int': typedef = {
 
 module T = FStar.Tactics
 
+(** To enforce nominality, structs are labelled by struct tags, which
+    are represented by strings encoded as F* types. This encoding allows
+    struct tags to stick around after erasure to OCaml.
+    
+    TODO the normalization is only needed for extraction, and so it
+    should be possible to use postprocess_for_extraction_with instead
+    of normalize. However, at present it seems that
+    postprocess_for_extraction_with does not run on definitions of
+    type Type. *)
+
 noextract inline_for_extraction
 //[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
 //     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
 let point_tag = normalize (mk_string_t "PointStruct.point")
 
+(** point_fields is a representation of the list of (field name,
+    typedef) pairs of the point struct we are defining.  For a more
+    detailed explanation for why this list is constructed using
+    fields_cons and fields_nil rather than as a normal F* list, see
+    Steel.C.Fields.fsti *)
+
 [@@c_struct]
 noextract inline_for_extraction
 let point_fields: c_fields =
@@ -44,21 +64,41 @@ let point_fields: c_fields =
   fields_cons "y" c_int' (
   fields_nil))
 
+(** The type of (struct point) values *)
 noextract inline_for_extraction
 let point = struct point_tag point_fields
 
+(** A way of viewing (struct point) PCM carrier values as (struct point) values *)
 noextract inline_for_extraction
 let point_view = struct_view point_tag point_fields
 
+(** The PCM used to model the point struct *)
 noextract inline_for_extraction
 let point_pcm = struct_pcm point_tag point_fields
 
+(** A typedef for the point struct (useful if this struct needs to be nested inside another struct definition) *)
 [@@c_typedef]
 noextract inline_for_extraction
 let c_point: typedef = typedef_struct point_tag point_fields
 
+(** Define the point struct. Kremlin detects this definition and
+    emits a corresponding C typedef at extraction time.  See
+    Steel.C.StructLiteral.mk_c_struct for more information. *)
 let _ = norm norm_c_typedef (mk_c_struct point_tag point_fields)
 
+(** There is some flexibility in how these definitions can be constructed.
+    Below, we define
+      struct line { struct point first; struct point second; };
+    but split the list of (field name, typedef) pairs across two
+    definitions: .second is declared in the definition below, while
+    .first is declared "inline" in the call to mk_c_struct parsed by
+    Kremlin.
+
+    This code is just to illustrate that extraction is fairly
+    flexible: all Kremlin cares about is that the call to mk_c_struct
+    normalizes (under rules norm_c_typedef) to a valid struct
+    definition. In practice, it isn't recommended to split the list of
+    fields like this. *)
 noextract inline_for_extraction
 let line_fields_second_half: c_fields =
   fields_cons "second" c_point fields_nil
@@ -70,16 +110,12 @@ let _ = norm norm_c_typedef (mk_c_struct line_tag (fields_cons "first" c_point l
 
 #push-options "--fuel 0"
 
-(*
-let x_conn
-: connection point_pcm (opt_pcm #int)
-= struct_field point_tag point_fields "x"
-*)
-
 #push-options "--print_universes --print_implicits --z3rlimit 100 --query_stats"
 
 open Steel.C.Reference
 
+(** To illustrate pointer-to-field in action, we write a function swap
+    that swaps x and y coordinates of a point struct. *)
 val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
@@ -90,21 +126,29 @@ val swap (p: ref 'a point point_pcm)
       == h (p `pts_to_view` point_view emptyset) `struct_get` "y" /\
       h' (p `pts_to_view` point_view emptyset) `struct_get` "y"
       == h (p `pts_to_view` point_view emptyset) `struct_get` "x")
-      //True)
 
 let swap p =
   let initial_point = gget (p `pts_to_view` point_view emptyset) in
+  (** Take pointers to the "x" and "y" fields *)
   let q = addr_of_struct_field "x" p in
   let r = addr_of_struct_field "y" p in
   let x = opt_read_sel q in
   let y = opt_read_sel r in
   q `opt_write_sel` y;
   r `opt_write_sel` x;
+  (** Give ownership of x and y fields back to p *)
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
+  (** The view for structs is parameterized by a set of fields that have been loaned out.
+      When these loans are returned to p, the corresponding field names are removed from the set of loaned fields.
+      However, this new set is not definitionally equal to emptyset, the following equality needs to be proved by SMT: *)
   change_equal_slprop
     (p `pts_to_view` point_view (remove "x" (remove "y" (insert "y" (insert "x" emptyset)))))
     (p `pts_to_view` point_view emptyset);
+    (** TOOD in the future, may want to make struct_view smt_fallback in its first argument and mark point_view as unfold *)
+  (** For some reason these assertions is necessary to get the program
+      to verify. It's unclear why, since such assertions are normally
+      easily provable by SMT *)
   let final_point = gget (p `pts_to_view` point_view emptyset) in
   assert (struct_get #point_tag #point_fields #emptyset final_point "x" ==
     struct_get #point_tag #point_fields #emptyset initial_point "y");
@@ -112,27 +156,11 @@ let swap p =
     struct_get #point_tag #point_fields #emptyset initial_point "x");
   return ()
 
-(*
-assume val addr_of_struct_field_ref'
-  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
-  (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (fields.get_field field).pcm)
-    (p `pts_to_view` struct_view tag fields excluded)
-    (fun q ->
-      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
-      (q `pts_to_view` (fields.get_field field).view))
-    (requires fun _ -> not (excluded field))
-    (ensures fun h q h' -> 
-      not (excluded field) /\
-      q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
-      extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded))
-       ==
-        (h' (p `pts_to_view` struct_view tag fields (insert field excluded)),
-         h' (q `pts_to_view` (fields.get_field field).view)))
-*)
-
+(** We can also define swap by calling a helper function that swaps
+    any two pointers.  This demonstrates that one can manipulate
+    pointers in a generic way: the helper function does not need to
+    know that its inputs are pointers to fields of a struct in order
+    to work. *)
 let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
 : Steel unit
   ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
@@ -171,156 +199,3 @@ let swap' p =
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
   return ()
-
-(*
-ref 'a (struct tag fields)
-ref 'a (fields.get_field field).view_type
-ref 'a view_t ...
-
-struct: s:string -> x:Type{x == y:string{y == s}} -> c_fields -> Type
-point = s:string{s == point_tag}
-
-[@@c_typedef]
-s = struct ..
-
-[@@c_struct]
-point_fields = fields_cons "a" s
-
-[@@c_typedef]
-point = struct point_tag point_fields
-
-mark get_field, view_type, ... c_struct
-
-norm [unfold c_typedef] point
-
-p: ref 'a point  ...
----> (PointStruct.point, unit) struct
-
-p: ref 'a int ...
-*)
-
-(*
-TO PROVE:
-extract_field v field = (w, x) 
-get v field = x
-get v field' = get w field' for all field' =!= field
-*)
-
-(* struct tag { point_fields ... } *)
-
-(*
-
-struct tag *p ;
-
-int *q = &p->x;
-
-q: ref (struct tag) #int (int_pcm)
-
-EAddrOf (
-  EField (
-    TQualified "Example.t",
-    (EBufRead (<<p>>, 0)),
-    "x"))
-
-
-Read:
-    EBufRead (<<p>>, 0)
-
-Write:
-    EBufWrite (<<e>>, 0, <<e'>>)
-or
-    EAssign (EBufRead (<<e>>, 0), <<e'>>)
-
-addr_of_struct_field "x" (p: ref 'a #(struct_pcm_carrier tag point_fields) (struct_pcm tag point_fields))
-(* &(((struct tag)(*p)).x)
-
-*)
-
-
-
-
-*)
-
-/// make pts_to_view stuff smt_fallback?
-let addr_of_x' #a p excluded =
-  let q = addr_of_struct_field #_ #point_tag #point_fields #excluded "x" p in
-  //change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
-  //change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` point_view (insert "x" excluded));
-  //slassert ((p `pts_to_view` point_view (insert "x" excluded)) `star`
-  //     (q `pts_to_view` opt_view int));
-  change_equal_slprop (q `pts_to_view` _)
-    (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int));
-  change_equal_slprop (p `pts_to_view` _)
-    (pts_to_view #a #point #point_pcm p
-          #(struct' point_tag point_fields (insert #string "x" excluded)) #false 
-         (point_view (insert "x" excluded)));
-  //slassert ((pts_to_view #a #point #point_pcm p
-  //        #(struct' point_tag point_fields (insert #string "x" excluded)) #false 
-  //       (point_view (insert "x" excluded))) `star`
-  //     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int)));
-  //sladmit();
-  return q
-
-let point_fields k = match k with
-  | X -> option int
-  | Y -> option int
-let point = restricted_t point_field point_fields
-
-let point_fields_pcm k : pcm (point_fields k) = match k with
-  | X -> opt_pcm #int
-  | Y -> opt_pcm #int
-let point_pcm = prod_pcm point_fields_pcm
-
-let mk_point_f (x y: option int) (k: point_field): point_fields k = match k with
-  | X -> x
-  | Y -> y
-  
-let mk_point (x y: option int): point =
-  on_domain point_field (mk_point_f x y)
-
-let _x = struct_field point_fields_pcm X
-let _y = struct_field point_fields_pcm Y
-
-/// Taking pointers to the x and y fields of a point
-
-let point_without_x x y
-: Lemma (struct_without_field point_fields_pcm X (mk_point x y) `feq` Ghost.reveal (mk_point none y))
-  [SMTPat (mk_point x y)]
-= ()
-
-let point_with_x x y
-: Lemma (struct_with_field point_fields_pcm X x (mk_point None y) `feq`
-         mk_point x y)
-  [SMTPat (mk_point x y)]
-= ()
-
-let point_without_y x y
-: Lemma (struct_without_field point_fields_pcm Y (mk_point x y) `feq` mk_point x None)
-  [SMTPat (mk_point x y)]
-= ()
-
-let point_with_y x y
-: Lemma (struct_with_field point_fields_pcm Y y (mk_point x None) `feq`
-         mk_point x y)
-  [SMTPat (mk_point x y)]
-= ()
-
-let addr_of_x #a #x #y p =
-  let q = addr_of_struct_field p X (mk_point x y) in
-  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point None y);
-  change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  return q
-  
-let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm X q p (mk_point None y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
-  change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_y #a #x #y p =
-  let q = addr_of_struct_field p Y (mk_point x y) in
-  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_point x None);
-  change_equal_slprop (q `pts_to` _) (q `pts_to` y);
-  return q
-
-let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #point_fields_pcm Y q p (mk_point x None) y; // same here
-  change_equal_slprop (p `pts_to` _) (p `pts_to` _)
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index 56722c3dbee..cf7263fc746 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -21,6 +21,11 @@ open Steel.C.Typenat
 module U32 = FStar.UInt32
 module U16 = FStar.UInt16
 
+(** A union is encoded by what amounts to a list of (field name,
+    typedef) pairs.  In this example, we define a union named
+    u32_or_u16 with one u32 field and one u16 field; to do so we need
+    typedefs for u32s and u16s. *)
+
 [@@c_typedef]
 noextract inline_for_extraction
 let u32: typedef = {
@@ -43,11 +48,15 @@ let u16: typedef = {
 
 module T = FStar.Tactics
 
+(** Like structs, unions are labelled by tags to enforce nominality.
+    For a more detailed explanation see PointStruct.fst *)
+
 noextract inline_for_extraction
 //[@@FStar.Tactics.Effect.postprocess_for_extraction_with(fun () ->
 //     T.norm [delta; iota; zeta_full; primops]; T.trefl ())]
 let u32_or_u16_tag = normalize (mk_string_t "ScalarUnion.u32_or_u16")
 
+(** The fields of a u32_or_u16. *)
 [@@c_struct]
 noextract inline_for_extraction
 let u32_or_u16_fields: c_fields =
@@ -55,32 +64,33 @@ let u32_or_u16_fields: c_fields =
   fields_cons "as_u16" u16 (
   fields_nil))
 
+(** The type of (union u32_or_u16) values. *)
 noextract inline_for_extraction
 let u32_or_u16 = union u32_or_u16_tag u32_or_u16_fields
 
+(** A way to view PCM carrier values as (union u32_or_u16) values. *)
 noextract inline_for_extraction
 let u32_or_u16_view = union_view u32_or_u16_tag u32_or_u16_fields
 
+(** The PCM that models (union u32_or_u16) values. *)
 noextract inline_for_extraction
 let u32_or_u16_pcm = union_pcm u32_or_u16_tag u32_or_u16_fields
 
+(** A typedef for u32_or_u16, useful in case it is needed as a field of a struct or union *)
 [@@c_typedef]
 noextract inline_for_extraction
 let c_u32_or_u16: typedef = typedef_union u32_or_u16_tag u32_or_u16_fields
 
+(** Define the union. Like with mk_c_struct, Kremlin detects this
+    definition at extraction type and emits the corresponding typedef. *)
 let _ = norm norm_c_typedef (mk_c_union u32_or_u16_tag u32_or_u16_fields)
 
 #push-options "--fuel 0"
 
-(*
-let x_conn
-: connection u32_or_u16_pcm (opt_pcm #int)
-= struct_field u32_or_u16_tag u32_or_u16_fields "x"
-*)
-
 #push-options "--print_universes --print_implicits"
 // --z3rlimit 30"
 
+(** Switch a case of the union to the u16 case, by writing x to it. *)
 val switch_to_u16
   (p: ref unit u32_or_u16 u32_or_u16_pcm)
   (x: U16.t)
@@ -97,6 +107,7 @@ let switch_to_u16 p x =
   switch_union_field "as_u16" x p;
   return ()
 
+(** Helper function that zeros the memory location pointed to by p. *)
 let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
 : Steel unit
   (p `pts_to_view` opt_view _)
@@ -105,6 +116,7 @@ let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
   (ensures fun _ _ _ -> True)
 = opt_write_sel p 0ul
 
+(** Given a union in the u32 case, set the u32 to zero. *)
 val zero_u32_of_union (p: ref unit u32_or_u16 u32_or_u16_pcm)
 : Steel unit
     (p `pts_to_view` u32_or_u16_view)
@@ -117,156 +129,3 @@ let zero_u32_of_union p =
   zero_u32_ref q;
   unaddr_of_union_field "as_u32" p q;
   return ()
-
-(*
-ref 'a (struct tag fields)
-ref 'a (fields.get_field field).view_type
-ref 'a view_t ...
-
-struct: s:string -> x:Type{x == y:string{y == s}} -> c_fields -> Type
-u32_or_u16 = s:string{s == u32_or_u16_tag}
-
-[@@c_typedef]
-s = struct ..
-
-[@@c_struct]
-u32_or_u16_fields = fields_cons "a" s
-
-[@@c_typedef]
-u32_or_u16 = struct u32_or_u16_tag u32_or_u16_fields
-
-mark get_field, view_type, ... c_struct
-
-norm [unfold c_typedef] u32_or_u16
-
-p: ref 'a u32_or_u16  ...
----> (U32_Or_U16Struct.u32_or_u16, unit) struct
-
-p: ref 'a int ...
-*)
-
-(*
-TO PROVE:
-extract_field v field = (w, x) 
-get v field = x
-get v field' = get w field' for all field' =!= field
-*)
-
-(* struct tag { u32_or_u16_fields ... } *)
-
-(*
-
-struct tag *p ;
-
-int *q = &p->x;
-
-q: ref (struct tag) #int (int_pcm)
-
-EAddrOf (
-  EField (
-    TQualified "Example.t",
-    (EBufRead (<<p>>, 0)),
-    "x"))
-
-
-Read:
-    EBufRead (<<p>>, 0)
-
-Write:
-    EBufWrite (<<e>>, 0, <<e'>>)
-or
-    EAssign (EBufRead (<<e>>, 0), <<e'>>)
-
-addr_of_struct_field "x" (p: ref 'a #(struct_pcm_carrier tag u32_or_u16_fields) (struct_pcm tag u32_or_u16_fields))
-(* &(((struct tag)(*p)).x)
-
-*)
-
-
-
-
-*)
-
-/// make pts_to_view stuff smt_fallback?
-let addr_of_x' #a p excluded =
-  let q = addr_of_struct_field #_ #u32_or_u16_tag #u32_or_u16_fields #excluded "x" p in
-  //change_equal_slprop (q `pts_to_view` _) (q `pts_to_view` opt_view int);
-  //change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` u32_or_u16_view (insert "x" excluded));
-  //slassert ((p `pts_to_view` u32_or_u16_view (insert "x" excluded)) `star`
-  //     (q `pts_to_view` opt_view int));
-  change_equal_slprop (q `pts_to_view` _)
-    (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int));
-  change_equal_slprop (p `pts_to_view` _)
-    (pts_to_view #a #u32_or_u16 #u32_or_u16_pcm p
-          #(struct' u32_or_u16_tag u32_or_u16_fields (insert #string "x" excluded)) #false 
-         (u32_or_u16_view (insert "x" excluded)));
-  //slassert ((pts_to_view #a #u32_or_u16 #u32_or_u16_pcm p
-  //        #(struct' u32_or_u16_tag u32_or_u16_fields (insert #string "x" excluded)) #false 
-  //       (u32_or_u16_view (insert "x" excluded))) `star`
-  //     (pts_to_view #a #(option int) #(opt_pcm #int) q #int #false (opt_view int)));
-  //sladmit();
-  return q
-
-let u32_or_u16_fields k = match k with
-  | X -> option int
-  | Y -> option int
-let u32_or_u16 = restricted_t u32_or_u16_field u32_or_u16_fields
-
-let u32_or_u16_fields_pcm k : pcm (u32_or_u16_fields k) = match k with
-  | X -> opt_pcm #int
-  | Y -> opt_pcm #int
-let u32_or_u16_pcm = prod_pcm u32_or_u16_fields_pcm
-
-let mk_u32_or_u16_f (x y: option int) (k: u32_or_u16_field): u32_or_u16_fields k = match k with
-  | X -> x
-  | Y -> y
-  
-let mk_u32_or_u16 (x y: option int): u32_or_u16 =
-  on_domain u32_or_u16_field (mk_u32_or_u16_f x y)
-
-let _x = struct_field u32_or_u16_fields_pcm X
-let _y = struct_field u32_or_u16_fields_pcm Y
-
-/// Taking u32_or_u16ers to the x and y fields of a u32_or_u16
-
-let u32_or_u16_without_x x y
-: Lemma (struct_without_field u32_or_u16_fields_pcm X (mk_u32_or_u16 x y) `feq` Ghost.reveal (mk_u32_or_u16 none y))
-  [SMTPat (mk_u32_or_u16 x y)]
-= ()
-
-let u32_or_u16_with_x x y
-: Lemma (struct_with_field u32_or_u16_fields_pcm X x (mk_u32_or_u16 None y) `feq`
-         mk_u32_or_u16 x y)
-  [SMTPat (mk_u32_or_u16 x y)]
-= ()
-
-let u32_or_u16_without_y x y
-: Lemma (struct_without_field u32_or_u16_fields_pcm Y (mk_u32_or_u16 x y) `feq` mk_u32_or_u16 x None)
-  [SMTPat (mk_u32_or_u16 x y)]
-= ()
-
-let u32_or_u16_with_y x y
-: Lemma (struct_with_field u32_or_u16_fields_pcm Y y (mk_u32_or_u16 x None) `feq`
-         mk_u32_or_u16 x y)
-  [SMTPat (mk_u32_or_u16 x y)]
-= ()
-
-let addr_of_x #a #x #y p =
-  let q = addr_of_struct_field p X (mk_u32_or_u16 x y) in
-  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_u32_or_u16 None y);
-  change_equal_slprop (q `pts_to` _) (q `pts_to` x);
-  return q
-  
-let unaddr_of_x #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #u32_or_u16_fields_pcm X q p (mk_u32_or_u16 None y) x; // FIXME: WHY WHY WHY does F* infer the constant function (due to the type of q) instead?
-  change_equal_slprop (p `pts_to` _) (p `pts_to` _)
-
-let addr_of_y #a #x #y p =
-  let q = addr_of_struct_field p Y (mk_u32_or_u16 x y) in
-  change_equal_slprop (p `pts_to` _) (p `pts_to` mk_u32_or_u16 x None);
-  change_equal_slprop (q `pts_to` _) (q `pts_to` y);
-  return q
-
-let unaddr_of_y #a #x #y p q =
-  unaddr_of_struct_field #_ #_ #_ #u32_or_u16_fields_pcm Y q p (mk_u32_or_u16 x None) y; // same here
-  change_equal_slprop (p `pts_to` _) (p `pts_to` _)

From 7c84be04eb64ccbf7032645c057616d978659095 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Sep 2021 10:21:44 -0700
Subject: [PATCH 227/513] reset src/ocaml-output/FStar_Extraction_Kremlin.ml to
 origin/master

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 734 +------------------
 1 file changed, 17 insertions(+), 717 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 63549b77614..6361e5129a4 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type program = decl Prims.list
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -805,20 +689,18 @@ let (empty : Prims.string Prims.list -> env) =
 let (extend : env -> Prims.string -> env) =
   fun env1 ->
     fun x ->
-      let uu___ = env1 in
       {
         names = ({ pretty = x } :: (env1.names));
-        names_t = (uu___.names_t);
-        module_name = (uu___.module_name)
+        names_t = (env1.names_t);
+        module_name = (env1.module_name)
       }
 let (extend_t : env -> Prims.string -> env) =
   fun env1 ->
     fun x ->
-      let uu___ = env1 in
       {
-        names = (uu___.names);
+        names = (env1.names);
         names_t = (x :: (env1.names_t));
-        module_name = (uu___.module_name)
+        module_name = (env1.module_name)
       }
 let (find_name : env -> Prims.string -> name) =
   fun env1 ->
@@ -981,61 +863,6 @@ and (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some
-              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
-               ((FStar_Extraction_ML_Syntax.MLTY_Named
-                ([], view_type_name))::[], p));
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-            FStar_Extraction_ML_Syntax.mllb_def = fields;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
-            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
-            ((let uu___6 =
-                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
-              FStar_Compiler_Util.print1
-                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
-             (let rec parse_fields fields1 =
-                match fields1 with
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_Name p1;
-                    FStar_Extraction_ML_Syntax.mlty = uu___6;
-                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
-                    let uu___8 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
-                    FStar_Compiler_Util.print_endline "End of fields"
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_App
-                      ({
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Name p1;
-                         FStar_Extraction_ML_Syntax.mlty = uu___6;
-                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                       {
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Const
-                           (FStar_Extraction_ML_Syntax.MLC_String name1);
-                         FStar_Extraction_ML_Syntax.mlty = uu___8;
-                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
-                    FStar_Extraction_ML_Syntax.mlty = uu___10;
-                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
-                    let uu___12 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
-                    ((let uu___13 =
-                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
-                          typedef in
-                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
-                        uu___13);
-                     parse_fields fields2)
-                | uu___6 ->
-                    failwith "Couldn't parse fields from struct_fields" in
-              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);
@@ -1241,126 +1068,7 @@ and (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -1470,8 +1178,7 @@ and (translate_type_decl :
                  (FStar_Errors.Warning_DefinitionNotTranslated, uu___8) in
                FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
               FStar_Pervasives_Native.None))
-and (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -1481,9 +1188,8 @@ and (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1501,47 +1207,6 @@ and (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ref" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.array" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1554,8 +1219,7 @@ and (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1592,18 +1256,16 @@ and (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (((((((((((((((let uu___ =
                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1659,14 +1321,13 @@ and (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.Array.array")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1676,36 +1337,19 @@ and (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
@@ -2976,350 +2620,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___8;
-                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.ref_of_array" -> translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.mk_array_of_ref" -> translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.intro_varray" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.split_left" -> translate_expr env1 a
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.split_right" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::al::ar::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.joinc" -> translate_expr env1 al
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           i::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.StdInt.mk_size_t" -> translate_expr env1 i
       | FStar_Extraction_ML_Syntax.MLE_App (head, args) ->
           let uu___ =
             let uu___1 = translate_expr env1 head in

From 974bfaecb6f0b83126b6030d8252158b04752a9c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Sep 2021 10:32:25 -0700
Subject: [PATCH 228/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 740 ++++++++++++++++++-
 1 file changed, 727 insertions(+), 13 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 6361e5129a4..5c2c2a9f290 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type program = decl Prims.list
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -863,6 +979,61 @@ and (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some
+              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
+               ((FStar_Extraction_ML_Syntax.MLTY_Named
+                ([], view_type_name))::[], p));
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
+            FStar_Extraction_ML_Syntax.mllb_def = fields;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
+            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
+            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
+            ((let uu___6 =
+                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
+              FStar_Compiler_Util.print1
+                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
+             (let rec parse_fields fields1 =
+                match fields1 with
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_Name p1;
+                    FStar_Extraction_ML_Syntax.mlty = uu___6;
+                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
+                    let uu___8 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
+                    FStar_Compiler_Util.print_endline "End of fields"
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_App
+                      ({
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Name p1;
+                         FStar_Extraction_ML_Syntax.mlty = uu___6;
+                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
+                       {
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Const
+                           (FStar_Extraction_ML_Syntax.MLC_String name1);
+                         FStar_Extraction_ML_Syntax.mlty = uu___8;
+                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
+                    FStar_Extraction_ML_Syntax.mlty = uu___10;
+                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
+                    let uu___12 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
+                    ((let uu___13 =
+                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
+                          typedef in
+                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
+                        uu___13);
+                     parse_fields fields2)
+                | uu___6 ->
+                    failwith "Couldn't parse fields from struct_fields" in
+              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);
@@ -1068,7 +1239,126 @@ and (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -1178,7 +1468,8 @@ and (translate_type_decl :
                  (FStar_Errors.Warning_DefinitionNotTranslated, uu___8) in
                FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
               FStar_Pervasives_Native.None))
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+and (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -1188,8 +1479,9 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1207,6 +1499,47 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ref" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.array" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1219,7 +1552,8 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1256,16 +1590,18 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type env1 arg in TConstBuf uu___
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (((((((((((((((let uu___ =
                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1321,13 +1657,14 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.Array.array")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1337,19 +1674,36 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
@@ -2620,6 +2974,366 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___8;
+                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.ref_of_array" -> translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.mk_array_of_ref" -> translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.intro_varray" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.split_left" -> translate_expr env1 a
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.split_right" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::al::ar::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.joinc" -> translate_expr env1 al
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           i::[])
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.StdInt.mk_size_t" -> translate_expr env1 i
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App (head, args) ->
           let uu___ =
             let uu___1 = translate_expr env1 head in

From 3a59c03b821cc6b619f1216bd255a6f59fbc1c01 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Sep 2021 11:24:42 -0700
Subject: [PATCH 229/513] move pts_to_witinv to .fst

---
 ulib/experimental/Steel.C.Ref.fst  | 221 +++++++++++++++++++++++++++++
 ulib/experimental/Steel.C.Ref.fsti | 178 ++---------------------
 2 files changed, 229 insertions(+), 170 deletions(-)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index eff2e3cf733..5df2099ee68 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -174,6 +174,16 @@ let base_fpu p x y =
   compatible_refl p y;
   y
 
+let pts_to_view_explicit
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (v: Ghost.erased c)
+: Tot M.slprop
+= hp_of (pts_to r (vw.to_carrier v))
+
 let pts_to_view_explicit_witinv
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
@@ -207,3 +217,214 @@ let pts_to_view_explicit_witinv
     ()
   in
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
+
+let pts_to_view_sl
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot M.slprop
+= M.h_exists (pts_to_view_explicit r vw)
+
+
+let pts_to_view_sel'
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot (selector' c (pts_to_view_sl r vw))
+= fun h ->
+  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
+  Ghost.reveal (Ghost.reveal x)
+
+let pts_to_view_depends_only_on
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
+
+let pts_to_view_depends_only_on_core
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (m0:M.hmem (pts_to_view_sl r vw))
+: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
+= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
+  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
+  pts_to_view_explicit_witinv r vw;
+  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
+
+let pts_to_view_sel
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot (selector c (pts_to_view_sl r vw))
+= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
+  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
+  pts_to_view_sel' r vw
+
+let pts_to_view_intro_lemma
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
+  (ensures (
+    M.interp (pts_to_view_sl r vw) m /\
+    pts_to_view_sel r vw m == Ghost.reveal y
+  )) 
+=
+  M.intro_h_exists y (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+let pts_to_view_intro
+  (#invs: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+: A.SteelGhost unit invs
+    (pts_to r x)
+    (fun _ -> pts_to_view r vw)
+    (fun _ -> vw.to_carrier y == Ghost.reveal x)
+    (fun _ _ h' ->
+      h' (pts_to_view r vw) == Ghost.reveal y
+    )
+= A.change_slprop_2
+    (pts_to r x)
+    (pts_to_view r vw)
+    y
+    (fun m ->
+      pts_to_view_intro_lemma r x vw y m
+    )
+
+
+let pts_to_view_elim_lemma
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (m: M.mem)
+: Lemma
+  (requires (M.interp (pts_to_view_sl r vw) m))
+  (ensures (
+    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
+  ))
+=
+  M.elim_h_exists (pts_to_view_explicit r vw) m;
+  pts_to_view_explicit_witinv r vw
+
+/// Introducing a dependent star for [v] and [q]
+let intro_vdep2 (#opened:_)
+  (v: vprop)
+  (q: vprop)
+  (p: (t_of v -> Tot vprop))
+  (x: t_of v)
+: A.SteelGhost unit opened
+    (v `star` q)
+    (fun _ -> vdep v p)
+    (requires (fun h -> h v == x /\ q == p x))
+    (ensures (fun h _ h' ->
+      let x2 = h' (vdep v p) in
+      q == p (h v) /\
+      dfst x2 == (h v) /\
+      dsnd x2 == (h q)
+    ))
+=
+  A.intro_vdep v q p
+
+let pts_to_view_elim
+  (#invs: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost (Ghost.erased b) invs
+    (pts_to_view r vw)
+    (fun res -> pts_to r res)
+    (fun _ -> True)
+    (fun h res _ ->
+      Ghost.reveal res == vw.to_carrier (h (pts_to_view r vw)) /\
+      vw.to_view_prop res /\
+      True //~ (Ghost.reveal res == one p)
+    )
+=
+  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
+  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
+  // vw.to_carrier_not_one g;
+  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
+  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
+  intro_vdep2
+    (pts_to_view r vw)
+    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
+    f
+    (Ghost.reveal g);
+  A.rewrite_slprop
+    (vdep (pts_to_view r vw) f)
+    (pts_to r res)
+    (fun m ->
+      interp_vdep_hp (pts_to_view r vw) f m;
+      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
+      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
+      pts_to_view_elim_lemma r vw m
+    );
+  res
+
+
+let compatible_elim'
+  (#a: Type u#a)
+  (pcm: pcm0 a)
+  (x y: a)
+  (sq: squash (compatible pcm x y))
+: GTot (frame: a {
+    composable pcm x frame /\
+    op pcm frame x == y
+  })
+= compatible_elim pcm x y
+
+let ref_read_sel
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Steel c
+  (pts_to_view r vw)
+  (fun _ -> pts_to_view r vw)
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (pts_to_view r vw) /\
+    res == h' (pts_to_view r vw)
+  ))
+=
+  let _v = pts_to_view_elim r vw in
+  let v = ref_read r in
+  let sq : squash (compatible p _v v) = () in
+  let frame = Ghost.hide (compatible_elim' p _v v sq) in
+  vw.to_view_frame (vw.to_view _v) frame ;
+  let res = vw.to_view v in
+  pts_to_view_intro r _v vw res;
+  A.return res
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 0be569dfe64..5a78f2f5efe 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -32,7 +32,7 @@ val ref_focus
 : ref a q
 
 val ref_focus_id
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (#a:Type) (#b:Type) (#p: pcm b)
   (r: ref a p)
 : Lemma
   (ref_focus r (connection_id _) == r)
@@ -190,81 +190,21 @@ let sel_view_inv
   in
   ()
 
-let pts_to_view_explicit
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-  (v: Ghost.erased c)
-: Tot M.slprop
-= hp_of (pts_to r (vw.to_carrier v))
-
-val pts_to_view_explicit_witinv
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-: Lemma
-  (M.is_witness_invariant (pts_to_view_explicit r vw))
-
-let pts_to_view_sl
+val pts_to_view_sl
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
-: Tot M.slprop
-= M.h_exists (pts_to_view_explicit r vw)
+: Tot (M.slprop u#1)
 
-let pts_to_view_sel'
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-: Tot (selector' c (pts_to_view_sl r vw))
-= fun h ->
-  let x = M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) h in
-  Ghost.reveal (Ghost.reveal x)
-
-let pts_to_view_depends_only_on
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-  (m0:M.hmem (pts_to_view_sl r vw)) (m1:M.mem{M.disjoint m0 m1})
-: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.join m0 m1))
-= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
-  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.join m0 m1)) in
-  pts_to_view_explicit_witinv r vw;
-  M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
-
-let pts_to_view_depends_only_on_core
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-  (m0:M.hmem (pts_to_view_sl r vw))
-: Lemma (pts_to_view_sel' r vw m0 == pts_to_view_sel' r vw (M.core_mem m0))
-= let x = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) m0) in
-  let y = Ghost.reveal (M.id_elim_exists #(Ghost.erased c) (pts_to_view_explicit r vw) (M.core_mem m0)) in
-  pts_to_view_explicit_witinv r vw;
-  M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
-
-let pts_to_view_sel
+val pts_to_view_sel
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : Tot (selector c (pts_to_view_sl r vw))
-= Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
-  Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
-  pts_to_view_sel' r vw
 
 [@@__steel_reduce__]
 let pts_to_view'
@@ -295,26 +235,7 @@ let pts_to_view
 : Tot vprop
 = VUnit (pts_to_view' r vw)
 
-let pts_to_view_intro_lemma
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
-  (m: M.mem)
-: Lemma
-  (requires (M.interp (hp_of (pts_to r x)) m) /\ vw.to_carrier y == Ghost.reveal x)
-  (ensures (
-    M.interp (pts_to_view_sl r vw) m /\
-    pts_to_view_sel r vw m == Ghost.reveal y
-  )) 
-=
-  M.intro_h_exists y (pts_to_view_explicit r vw) m;
-  pts_to_view_explicit_witinv r vw
-
-let pts_to_view_intro
+val pts_to_view_intro
   (#invs: _)
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
@@ -330,50 +251,8 @@ let pts_to_view_intro
     (fun _ _ h' ->
       h' (pts_to_view r vw) == Ghost.reveal y
     )
-= A.change_slprop_2
-    (pts_to r x)
-    (pts_to_view r vw)
-    y
-    (fun m ->
-      pts_to_view_intro_lemma r x vw y m
-    )
 
-let pts_to_view_elim_lemma
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-  (m: M.mem)
-: Lemma
-  (requires (M.interp (pts_to_view_sl r vw) m))
-  (ensures (
-    M.interp (hp_of (pts_to r (vw.to_carrier (pts_to_view_sel r vw m)))) m
-  ))
-=
-  M.elim_h_exists (pts_to_view_explicit r vw) m;
-  pts_to_view_explicit_witinv r vw
-
-/// Introducing a dependent star for [v] and [q]
-let intro_vdep2 (#opened:_)
-  (v: vprop)
-  (q: vprop)
-  (p: (t_of v -> Tot vprop))
-  (x: t_of v)
-: A.SteelGhost unit opened
-    (v `star` q)
-    (fun _ -> vdep v p)
-    (requires (fun h -> h v == x /\ q == p x))
-    (ensures (fun h _ h' ->
-      let x2 = h' (vdep v p) in
-      q == p (h v) /\
-      dfst x2 == (h v) /\
-      dsnd x2 == (h q)
-    ))
-=
-  A.intro_vdep v q p
-
-let pts_to_view_elim
+val pts_to_view_elim
   (#invs: _)
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
@@ -389,40 +268,8 @@ let pts_to_view_elim
       vw.to_view_prop res /\
       True //~ (Ghost.reveal res == one p)
     )
-=
-  let g : Ghost.erased c = A.gget (pts_to_view r vw) in
-  let res : Ghost.erased b = Ghost.hide (vw.to_carrier g) in
-  // vw.to_carrier_not_one g;
-  A.intro_pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res);
-  let f (x: t_of (pts_to_view r vw)) : Tot vprop = pure (vw.to_carrier x == Ghost.reveal res) in
-  intro_vdep2
-    (pts_to_view r vw)
-    (pure (vw.to_carrier (Ghost.reveal g) == Ghost.reveal res))
-    f
-    (Ghost.reveal g);
-  A.rewrite_slprop
-    (vdep (pts_to_view r vw) f)
-    (pts_to r res)
-    (fun m ->
-      interp_vdep_hp (pts_to_view r vw) f m;
-      M.interp_star (hp_of (pts_to_view r vw)) (hp_of (f (sel_of (pts_to_view r vw) m))) m;
-      M.pure_interp (vw.to_carrier (sel_of (pts_to_view r vw) m) == Ghost.reveal res) m;
-      pts_to_view_elim_lemma r vw m
-    );
-  res
-
-let compatible_elim'
-  (#a: Type u#a)
-  (pcm: pcm0 a)
-  (x y: a)
-  (sq: squash (compatible pcm x y))
-: GTot (frame: a {
-    composable pcm x frame /\
-    op pcm frame x == y
-  })
-= compatible_elim pcm x y
-
-let ref_read_sel
+
+val ref_read_sel
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
   (#c: Type0)
@@ -436,14 +283,5 @@ let ref_read_sel
     res == h (pts_to_view r vw) /\
     res == h' (pts_to_view r vw)
   ))
-=
-  let _v = pts_to_view_elim r vw in
-  let v = ref_read r in
-  let sq : squash (compatible p _v v) = () in
-  let frame = Ghost.hide (compatible_elim' p _v v sq) in
-  vw.to_view_frame (vw.to_view _v) frame ;
-  let res = vw.to_view v in
-  pts_to_view_intro r _v vw res;
-  A.return res
 
 (* write cannot be defined generically because of p_refine *)

From 904f8dc7b571cdddd164d13714d242ed31dd23c9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Sep 2021 11:24:56 -0700
Subject: [PATCH 230/513] make array selector ghost

---
 ulib/experimental/Steel.C.Array.fsti | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 41243c529eb..b172c98eec5 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -85,11 +85,12 @@ let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}):
 // let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop
 // = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
 
-val varray_hp (#base: Type) (#t: Type) (x: array base t) : Tot (slprop u#1)
-val varray_sel (#base: Type) (#t: Type) (x: array base t) : Tot (selector (array_view_type t (len x)) (varray_hp x))
+val varray_hp (#base: Type0) (#t: Type0) (x: array base t) : Tot (slprop u#1)
+
+val varray_sel (#base: Type0) (#t: Type0) (x: array base t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
 
 [@@ __steel_reduce__ ]
-let varray' (#base: Type) (#t: Type) (x: array base t) : Tot vprop' = {
+let varray' (#base: Type) (#t: Type) (x: array base t) : GTot vprop' = {
   hp = varray_hp x;
   t = array_view_type t (len x);
   sel = varray_sel x;
@@ -125,7 +126,6 @@ val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: S
     h (varray a) == h' (Steel.C.Ref.pts_to_view r (array_view t n))
   ))
 
-
 /// Splitting an array into subarrays
 
 val adjacent

From d9448ba72e7a8b3c66bd67dea127783303fd346e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Sep 2021 12:05:10 -0700
Subject: [PATCH 231/513] WIP arrays

---
 ulib/experimental/Steel.C.Array.fst | 669 ++++++++++++++++++++++++++++
 1 file changed, 669 insertions(+)
 create mode 100644 ulib/experimental/Steel.C.Array.fst

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
new file mode 100644
index 00000000000..401f036bb9d
--- /dev/null
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -0,0 +1,669 @@
+module Steel.C.Array
+
+module S = Steel.C.Struct
+
+let array_domain
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+: Tot Type0
+= (x: size_t { size_v x < size_v n })
+
+let array_range
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain t n)
+: Tot Type0
+= option t
+
+open FStar.FunctionalExtensionality
+
+let array_pcm_carrier t n = restricted_t (array_domain t n) (array_range t n)
+
+let array_elements_pcm
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain t n)
+: Tot (Steel.C.PCM.pcm (array_range t n x))
+= Steel.C.Opt.opt_pcm #t
+
+let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
+
+[@"opaque_to_smt"]
+let rec raise_list_array_domain
+  (t: Type u#0)
+  (n n': size_t)
+  (l: list (array_domain t n))
+: Pure (list (array_domain t n'))
+  (requires (size_v n' >= size_v n))
+  (ensures (fun l' ->
+    (forall (x': array_domain t n') . List.Tot.mem x' l' <==> (size_v x' < size_v n /\ List.Tot.mem x' l)) /\
+    List.Tot.length l' == List.Tot.length l
+  ))
+= match l with
+  | [] -> []
+  | x :: l_ -> x :: raise_list_array_domain t n n' l_
+
+[@"opaque_to_smt"]
+let rec included_indices
+  (t: Type u#0)
+  (n: size_t)
+: Pure (list (array_domain t n))
+  (requires True)
+  (ensures (fun l ->
+    (forall (x: array_domain t n) . List.Tot.mem x l) /\
+    List.Tot.length l == size_v n
+  ))
+  (decreases (size_v n))
+= if n = mk_size_t (FStar.UInt32.uint_to_t 0)
+  then []
+  else
+    let n' = size_sub n (mk_size_t (FStar.UInt32.uint_to_t 1)) in
+    n' :: raise_list_array_domain t n' n (included_indices t n')
+
+let array_elements_view_type
+  (t: Type u#0)
+  (n: size_t)
+  (k: array_domain t n)
+: Tot Type0
+= t
+
+let array_elements_view
+  (t: Type u#0)
+  (n: size_t)
+  (k: array_domain t n)
+: Tot (Steel.C.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
+= Steel.C.Opt.opt_view _
+
+let intro_array_view_init
+  (t: Type u#0)
+  (n: size_t)
+  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+  (k: nat { k < size_v n })
+: Tot t
+= x (int_to_size_t k)
+
+let intro_array_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+: Tot (array_view_type t n)
+= Seq.init (size_v n) (intro_array_view_init t n x)
+
+let array_to_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+: Tot (array_view_type t n)
+= intro_array_view t n (S.struct_view_to_view (array_elements_view t n) (included_indices t n) x)
+
+let elim_array_view_f
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+  (k: Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
+: Tot (array_elements_view_type t n k)
+= Seq.index x (size_v k)
+
+let elim_array_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+: Tot (restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+= on_dom (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
+
+let array_to_carrier
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+: Tot (Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+= S.struct_view_to_carrier (array_elements_view t n) (included_indices t n) (elim_array_view t n x)
+
+open Steel.C.PCM
+
+let array_view_to_view_frame
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+  (frame: array_pcm_carrier t n)
+: Lemma
+    (requires (composable (array_pcm t n) (array_to_carrier t n x) frame))
+    (ensures
+      S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)
+        (op (array_pcm t n) (array_to_carrier t n x) frame) /\ 
+      array_to_view t n
+        (op (array_pcm t n) (array_to_carrier t n x) frame) `Seq.equal` x)
+= S.struct_view_to_view_frame (array_elements_view t n) (included_indices t n)
+    (elim_array_view t n x) frame
+
+let array_view' (t: Type u#0) (n: size_t)
+  : Tot (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
+=
+  let open Steel.C.Ref in
+  {
+    to_view_prop = S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n);
+    to_view = array_to_view t n;
+    to_carrier = array_to_carrier t n;
+    to_carrier_not_one = (S.struct_view (array_elements_view t n) (included_indices t n)).to_carrier_not_one;
+    to_view_frame = array_view_to_view_frame t n;
+  }
+
+let array_view t n =
+  assert (size_v n > 0);
+  array_view' t n
+
+noeq
+type array base t = {
+  base_len: Ghost.erased size_t;
+  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
+  from: size_t;
+  to: size_t; // must be Tot because of array_small_to_large below
+  prf: squash (
+    size_v base_len >= 0 /\
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  );
+}
+
+let len a = a.to `size_sub` a.from
+
+let rec array_is_unit_aux
+  (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
+  (i: size_t)
+  (f:
+    (j: size_t) ->
+    Lemma
+    (requires (size_v j < size_v n - size_v i))
+    (ensures (size_v j < size_v n - size_v i /\ a j == one (array_elements_pcm t n j)))
+  )
+: Pure bool
+  (requires True)
+  (ensures (fun y -> y == true <==> (forall j . size_v j < size_v n ==> a j == one (array_elements_pcm t n j))))
+  (decreases (size_v i))
+= Classical.forall_intro (Classical.move_requires f);
+  if size_le i zero_size
+  then true
+  else
+    let i' = size_sub i one_size in
+    if not (size_le i n)
+    then array_is_unit_aux t n a i' (fun _ -> ())
+    else if None? (a (size_sub n i))
+    then array_is_unit_aux t n a i' (fun j -> if j = size_sub n i then () else f j)
+    else false
+
+let array_is_unit_lemma
+  (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
+: Lemma
+  (requires (forall (j: array_domain  t n) . a j == one (array_elements_pcm t n j)))
+  (ensures (a == one (array_pcm t n)))
+= S.ext a (one (array_pcm t n)) (fun _ -> ())
+
+let array_is_unit t n a =
+  Classical.move_requires (array_is_unit_lemma t n) a;
+  array_is_unit_aux t n a n (fun _ -> ())
+
+let array_large_to_small_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+: Tot (array_pcm_carrier t (to `size_sub` from))
+= on_dom (array_domain t (to `size_sub` from)) (fun k -> x (from `size_add` k))
+
+let array_large_to_small
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Tot (Steel.C.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
+= Steel.C.Connection.mkmorphism
+    (array_large_to_small_f t base_len from to sq)
+    (assert (array_large_to_small_f t base_len from to sq (one (array_pcm t base_len)) `feq` one (array_pcm t (to `size_sub` from))))
+    (fun x1 x2 ->
+      assert (array_large_to_small_f t base_len from to sq (op (array_pcm t base_len) x1 x2) `feq` op (array_pcm t (to `size_sub` from)) (array_large_to_small_f t base_len from to sq x1)  (array_large_to_small_f t base_len from to sq x2))
+    )
+
+let array_small_to_large_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t) // Tot, argh
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t (to `size_sub` from))
+: Tot (array_pcm_carrier t base_len)
+= on_dom (array_domain t base_len) (fun k -> if size_le from k && not (size_le to k) then x (k `size_sub` from)
+  else one (Steel.C.Opt.opt_pcm #t))
+
+let array_small_to_large
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Tot (Steel.C.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
+= Steel.C.Connection.mkmorphism
+    (array_small_to_large_f t base_len from to sq)
+    (assert (array_small_to_large_f t base_len from to sq (one (array_pcm t (to `size_sub` from))) `feq` one (array_pcm t (base_len))))
+    (fun x1 x2 ->
+      assert (array_small_to_large_f t base_len from to sq (op (array_pcm t (to `size_sub` from)) x1 x2) `feq` op (array_pcm t (base_len)) (array_small_to_large_f t base_len from to sq x1)  (array_small_to_large_f t base_len from to sq x2))
+    )
+
+let array_small_to_large_to_small
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Lemma
+  (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
+= assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
+
+#push-options "--z3rlimit 32 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+assume
+val size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
+  (requires True)
+  (ensures (fun z -> size_v z == size_v x - size_v y))
+
+#restart-solver
+
+let array_conn_fpu_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Tot (array_pcm_carrier t base_len)
+= let sq0 : squash (size_v to >= size_v from) = () in
+  let z : size_t = size_sub' to from sq0 in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  // let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
+  // let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
+  // S.prod_pcm_composable_intro
+  //   (array_elements_pcm t z)
+  //   x
+  //   frame_small
+  //   (fun h -> assume False);
+  // assert (composable (array_pcm t (z)) x frame_small);
+  // op_comm (array_pcm t (z)) x frame_small;
+  // assert (op (array_pcm t (z)) frame_small x `feq` v_small);
+  // compatible_intro (array_pcm t (z)) x v_small frame_small;
+  assume (compatible (array_pcm t (z)) x v_small);
+  assume (p_refine (array_pcm t (z)) v_small); // TODO: remove p_refine from Steel.C.PCM
+  let v_small' : array_pcm_carrier t z = f v_small in
+  let v' : array_pcm_carrier t base_len =
+    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
+      if from `size_le` k && not (to `size_le` k)
+      then begin
+        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
+        v_small' (size_sub' k from sq2) <: option t
+      end
+      else v k
+    )
+  in
+  v'
+
+let array_conn_fpu
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+: Tot (frame_preserving_upd (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y))
+= frame_preserving_upd_intro
+    (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y)
+    (array_conn_fpu_f t base_len from to sq x y f)
+    (fun _ -> assume False)
+    (fun _ _ -> assume False)
+    (fun _ _ -> assume False)
+
+#pop-options
+
+let array_conn
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Steel.C.Connection.connection
+    (array_pcm t base_len)
+    (array_pcm t (to `size_sub` from))
+=
+  Steel.C.Connection.mkconnection
+    (array_small_to_large t base_len from to sq)
+    (array_large_to_small t base_len from to sq)
+    (array_small_to_large_to_small t base_len from to sq)
+    (array_conn_fpu t base_len from to sq)
+
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+let array_conn_id
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+: Lemma
+  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id _)
+=
+  let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
+  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
+  assume (forall (x: Ghost.erased (array_pcm_carrier t (base_len `size_sub` z)) { ~ (Ghost.reveal x == one (array_pcm t (base_len `size_sub` z))) }) y (f: frame_preserving_upd (array_pcm t (base_len `size_sub` z)) x y) v . array_conn_fpu_f t base_len z base_len () x y f v `feq` f v);
+  assert (forall x y f . array_conn_fpu_f t base_len z base_len () x y f `feq` f);
+  assume ((array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len ()).Steel.C.Connection.conn_lift_frame_preserving_upd === (Steel.C.Connection.connection_id (array_pcm t base_len)).Steel.C.Connection.conn_lift_frame_preserving_upd);
+  array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () `Steel.C.Connection.connection_eq` Steel.C.Connection.connection_id _
+
+#restart-solver
+
+let array_conn_compose
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+: Lemma
+  (requires (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+  (ensures (
+    array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t (to1 `size_sub` from1) from2 to2 () ==
+    array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) ()
+  ))
+=
+  let z = to1 `size_sub` from1 in
+  assert (forall x . array_small_to_large_f t base_len from1 to1 () (array_small_to_large_f t z from2 to2 ()  x) `feq` array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
+  assert (forall x . array_large_to_small_f t z from2 to2 () (array_large_to_small_f t base_len from1 to1 () x) `feq` array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
+  let cc = array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t z from2 to2 () in
+  let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
+  assume (
+    cc.Steel.C.Connection.conn_lift_frame_preserving_upd ===
+    c.Steel.C.Connection.conn_lift_frame_preserving_upd
+  );
+  cc `Steel.C.Connection.connection_eq` c
+
+let to_view_array_conn
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+: Lemma
+  (requires (
+    S.struct_view_to_view_prop (array_elements_view t base_len) (included_indices t base_len) x 
+  ))
+  (ensures (
+    let x' = array_large_to_small_f t base_len from to sq x in
+    S.struct_view_to_view_prop (array_elements_view t (to `size_sub` from)) (included_indices t (to `size_sub` from)) x' /\
+    array_to_view t (to `size_sub` from) x' `Seq.equal` Seq.slice (array_to_view t base_len x) (size_v from) (size_v to)
+  ))
+= ()
+
+#pop-options
+
+let array_as_ref
+  (#base: Type)
+  (#t: Type)
+  (a: array base t)
+: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+= Steel.C.Ref.ref_focus a.base_ref (array_conn t a.base_len a.from a.to a.prf)
+
+[@@__steel_reduce__]
+let varray0
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: Tot vprop
+= Steel.C.Ref.pts_to_view
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+
+let varray_hp #base #t x = hp_of (varray0 #base #t x)
+
+#push-options "--debug Steel.C.Array --debug_level Extreme"
+
+let varray_sel #base #t x = sel_of (varray0 #base #t x)
+
+#pop-options
+
+let intro_varray1
+  (#inames: _)
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: SteelGhost unit inames
+    (varray0 x)
+    (fun _ -> varray x)
+    (fun _ -> True)
+    (fun h _ h' -> h' (varray x) == h (varray0 x))
+= change_slprop_rel
+    (varray0 x)
+    (varray x)
+    (fun u v -> u == v)
+    (fun m -> ())
+
+let elim_varray1
+  (#inames: _)
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: SteelGhost unit inames
+    (varray x)
+    (fun _ -> varray0 x)
+    (fun _ -> True)
+    (fun h _ h' -> h' (varray0 x) == h (varray x))
+= change_slprop_rel
+    (varray x)
+    (varray0 x)
+    (fun u v -> u == v)
+    (fun m -> ())
+
+val mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+: Pure (array base t)
+  (requires (size_v n > 0))
+  (ensures (fun a -> len a == Ghost.reveal n))
+
+let mk_array #base #t #n r =
+  {
+    base_len = n;
+    base_ref = r;
+    from = mk_size_t 0ul;
+    to = n;
+    prf = ();
+  }
+
+let g_mk_array r = mk_array r
+
+#push-options "--z3rlimit 32"
+
+let intro_varray
+  #base #t #n r sq
+=
+  let res = mk_array r in
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  array_conn_id t n;
+  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
+  Steel.C.Ref.ref_focus_id r;
+  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
+  assert (array_as_ref res == r);
+  change_equal_slprop
+    (r `Steel.C.Ref.pts_to_view` _)
+    (varray0 res);
+  intro_varray1 res;
+  return res
+
+let elim_varray
+  #_ #base #t #n r res sq
+=
+  assert (res == g_mk_array r);
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  array_conn_id t n;
+  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
+  Steel.C.Ref.ref_focus_id r;
+  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
+  assert (array_as_ref res == r);
+  elim_varray1 res;
+  change_equal_slprop
+    (varray0 res)
+    (r `Steel.C.Ref.pts_to_view` _)
+
+#pop-options
+
+let adjacent r1 r2 =
+  r1.base_len == r2.base_len /\
+  r1.base_ref == r2.base_ref /\
+  r1.to == r2.from
+
+val t_merge
+  (#base: Type)
+  (#t: Type)
+  (r1 r2: array base t)
+: Pure (array base t)
+  (requires (adjacent r1 r2))
+  (ensures (fun r -> length r == length r1 + length r2))
+
+let t_merge r1 r2 =
+  {
+    base_len = r1.base_len;
+    base_ref = r1.base_ref;
+    from = r1.from;
+    to = r2.to;
+    prf = ();
+  }
+
+let merge r1 r2 = t_merge r1 r2
+
+let merge_assoc r1 r2 r3 = ()
+
+val tsplit
+  (#base: Type)
+  (#t: Type)
+  (r: array base t)
+  (i: size_t)
+: Pure (array base t & array base t)
+  (requires (size_v i <= length r))
+  (ensures (fun (rl, rr) ->
+    merge_into rl rr r /\
+    length rl == size_v i
+  ))
+
+let tsplit r i =
+  ({
+    base_len = r.base_len;
+    base_ref = r.base_ref;
+    from = r.from;
+    to = r.from `size_add` i;
+    prf = ()
+  }, {
+    base_len = r.base_len;
+    base_ref = r.base_ref;
+    from = r.from `size_add` i;
+    to = r.to;
+    prf = ()
+  })
+
+let gsplit r i = tsplit r i
+
+assume
+val pts_to_split
+  (t: Type)
+  (n: size_t)
+  (x: array_pcm_carrier t n)
+  (i: size_t)
+: Lemma
+  (requires (size_v i <= size_v n))
+  (ensures (
+    let z = mk_size_t 0ul in
+    let xl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () x) in
+    let xr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () x) in
+    composable (array_pcm t n) xl xr /\
+    op (array_pcm t n) xl xr == x
+  ))
+
+(*TODO: split focus into gfocus + tfocus *)
+
+let split
+  #j #base #t x i
+=
+  elim_varray1 x;
+  let v = Steel.C.Ref.pts_to_view_elim
+    #j
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+  in
+  let n = len x in
+  pts_to_split t n v i;
+  let z = mk_size_t 0ul in
+  let vl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () v) in
+  let vr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () v) in
+  
+  sladmit ();
+  magic ()
+  
+  
+
+(*
+
+noeq
+type array base t = {
+  base_len: Ghost.erased size_t;
+  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
+  from: size_t;
+  to: size_t; // must be Tot because of array_small_to_large below
+  prf: squash (
+    size_v base_len >= 0 /\
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  );
+}

From f4c525ec7516bad27f34517a99334ced729f6579 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Sep 2021 10:52:35 -0700
Subject: [PATCH 232/513] make Steel.C.Ref.split, gather SteelGhost

---
 ulib/experimental/Steel.C.Ref.fst  | 6 +++---
 ulib/experimental/Steel.C.Ref.fsti | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 5df2099ee68..7be1c5c34bb 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -108,14 +108,14 @@ let split r xy x y =
     (r `pts_to` y)
 
 let mgather
-  (#a:Type) (#p:P.pcm a)
+  (#inames: _) (#a:Type) (#p:P.pcm a)
   (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: SteelT (_:unit{P.composable p v0 v1})
+: A.SteelGhostT (_:unit{P.composable p v0 v1}) inames
     (mpts_to r v0 `star` mpts_to r v1)
     (fun _ -> mpts_to r (P.op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
-let gather #a #b #p r x y =
+let gather #inames #a #b #p r x y =
   let c = raise_pl r in
   let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
   let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 5a78f2f5efe..4c87638de5d 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -80,16 +80,16 @@ val unfocus (#opened:M.inames)
     (ensures fun _ _ _ -> True)
 
 (** Split the permissions on a reference into two halves. *)
-val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
-: Steel unit
+val split (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+: A.SteelGhost unit inames
     (r `pts_to` xy)
     (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
     (fun _ _ _ -> True)
 
 (** Inverse of split. *)
-val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
-: SteelT (_:unit{composable p x y})
+val gather (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+: A.SteelGhostT (_:unit{composable p x y}) inames
     ((r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> r `pts_to` op p x y)
 

From 908a34ac296f5f2e5e6dbd3b960cac1be83b7341 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Sep 2021 11:51:21 -0700
Subject: [PATCH 233/513] make Steel.C.Ref.ref_focus GTot, split off gfocus

---
 ulib/experimental/Steel.C.Ref.fst  | 18 +++++++++++++++---
 ulib/experimental/Steel.C.Ref.fsti | 11 ++++++++++-
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 7be1c5c34bb..354eb5ce4d9 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -40,7 +40,13 @@ let raise_pl
 let pts_to r v =
   r.r `mpts_to` (raise_pl r).conn_small_to_large.morph v
 
-let ref_focus r #q l = {p = r.p; pl = connection_compose r.pl l; r = r.r; q = q}
+let t_ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: Tot (ref a q)
+= {p = r.p; pl = connection_compose r.pl l; r = r.r; q = q}
+
+let ref_focus r l = t_ref_focus r l
 
 let ref_focus_id r = connection_compose_id_right r.pl
 
@@ -73,11 +79,17 @@ let ref_alloc #a p x =
 
 #pop-options
 
-let focus r l s x =
-  let r' = ref_focus r l in
+let gfocus r l s x =
   connection_compose_assoc (lower_conn r) r.pl l;
   A.change_equal_slprop
     (r `pts_to` s)
+    (ref_focus r l `pts_to` x)
+
+let focus r l s x =
+  let r' = t_ref_focus r l in
+  gfocus r l s x;
+  A.change_equal_slprop
+    (ref_focus r l `pts_to` x)
     (r' `pts_to` x);
   A.return r'
 
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 4c87638de5d..1cf519f2eca 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -29,7 +29,7 @@ val pts_to
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
-: ref a q
+: GTot (ref a q)
 
 val ref_focus_id
   (#a:Type) (#b:Type) (#p: pcm b)
@@ -56,6 +56,15 @@ val ref_alloc
     (ensures fun _ _ _ -> True)
 
 (** Take a pointer to a "substructure" of a reference. *)
+val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
+  (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: A.SteelGhost unit inames
+    (r `pts_to` s)
+    (fun _ -> ref_focus r l `pts_to` x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ _ _ -> True)
+
 val focus (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)

From 2f3489fb1e5ffcfb0de54c0a7fd6f74859787009 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Sep 2021 19:16:30 -0700
Subject: [PATCH 234/513] Steel.C.Array.split

---
 ulib/experimental/Steel.C.Array.fst  | 213 +++++++++++++++++++++++++--
 ulib/experimental/Steel.C.Array.fsti |  19 ++-
 2 files changed, 207 insertions(+), 25 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 401f036bb9d..0feef33a139 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -278,10 +278,10 @@ let array_small_to_large_to_small
 #push-options "--z3rlimit 32 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
 #restart-solver
 
-assume
-val size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
+let size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
   (requires True)
   (ensures (fun z -> size_v z == size_v x - size_v y))
+= size_sub x y
 
 #restart-solver
 
@@ -440,12 +440,19 @@ let to_view_array_conn
 
 #pop-options
 
+let array_as_ref_conn
+  (#base: Type)
+  (#t: Type)
+  (a: array base t)
+: GTot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len a)))
+= array_conn t a.base_len a.from a.to a.prf
+
 let array_as_ref
   (#base: Type)
   (#t: Type)
   (a: array base t)
 : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
-= Steel.C.Ref.ref_focus a.base_ref (array_conn t a.base_len a.from a.to a.prf)
+= Steel.C.Ref.ref_focus a.base_ref (array_as_ref_conn a)
 
 [@@__steel_reduce__]
 let varray0
@@ -608,9 +615,10 @@ let tsplit r i =
     prf = ()
   })
 
-let gsplit r i = tsplit r i
+let gsplit r i = 
+  let (rl, rr) = tsplit r i in
+  GPair rl rr
 
-assume
 val pts_to_split
   (t: Type)
   (n: size_t)
@@ -626,11 +634,87 @@ val pts_to_split
     op (array_pcm t n) xl xr == x
   ))
 
-(*TODO: split focus into gfocus + tfocus *)
+let pts_to_split t n x i =
+  let z = mk_size_t 0ul in
+  let xl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () x) in
+  let xr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () x) in
+  assert (composable (array_pcm t n) xl xr);
+  assert (op (array_pcm t n) xl xr `feq` x)
 
-let split
+val to_carrier_split
+  (t: Type)
+  (n: size_t)
+  (x: array_pcm_carrier t n)
+  (v: array_view_type t n)
+  (i: size_t)
+: Lemma
+  (requires (
+    size_v i <= size_v n /\
+    (array_view' t n).Steel.C.Ref.to_carrier v == x
+  ))
+  (ensures (
+    let z = mk_size_t 0ul in
+    let xl = (array_large_to_small_f t n z i () x) in
+    let xr = (array_large_to_small_f t n i n () x) in
+    (array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) == xl /\
+    (array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) == xr
+  ))
+
+#push-options "--z3rlimit 32"
+#restart-solver
+
+let to_carrier_split t n x v i =
+    let z = mk_size_t 0ul in
+    let xl = (array_large_to_small_f t n z i () x) in
+    let xr = (array_large_to_small_f t n i n () x) in
+    assert ((array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) `feq` xl);
+    assert ((array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
+
+let array_as_ref_split_left
+  (base: Type)
+  (t: Type)
+  (x: array base t)
+  (i: size_t)
+: Lemma
+  (requires (size_v i <= length x))
+  (ensures (
+    array_as_ref (fst (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
+  ))
+= array_conn_compose t x.base_len x.from x.to zero_size i;
+  Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
+
+let array_as_ref_split_right
+  (base: Type)
+  (t: Type)
+  (x: array base t)
+  (i: size_t)
+: Lemma
+  (requires (size_v i <= length x))
+  (ensures (
+    array_as_ref (snd (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
+  ))
+= array_conn_compose t x.base_len x.from x.to i (len x);
+  Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
+
+val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+  : SteelGhost (array base t `gpair` array base t) opened
+          (varray a)
+          (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            let s = h (varray a) in
+            let sl = h' (varray (GPair?.fst res)) in
+            let sr = h' (varray (GPair?.snd res)) in
+            size_v i <= length a /\
+            res == gsplit a i /\
+            sl == Seq.slice s 0 (size_v i) /\
+            sr == Seq.slice s (size_v i) (length a)
+          )
+
+let split'
   #j #base #t x i
 =
+  let gv = gget (varray x) in
   elim_varray1 x;
   let v = Steel.C.Ref.pts_to_view_elim
     #j
@@ -642,19 +726,118 @@ let split
     #(size_v (len x) = 0)
     (array_view' t (len x))
   in
+  pts_to_split t (len x) v i;
+  let (xl, xr) = tsplit x i in
   let n = len x in
-  pts_to_split t n v i;
   let z = mk_size_t 0ul in
-  let vl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () v) in
-  let vr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () v) in
-  
-  sladmit ();
-  magic ()
-  
-  
+  let vl' : array_pcm_carrier t (len xl) = array_large_to_small_f t n z i () v in
+  let vl : array_pcm_carrier t (len x) = array_small_to_large_f t n z i () vl' in
+  let vr' : array_pcm_carrier t (len xr) = array_large_to_small_f t n i n () v in
+  let vr : array_pcm_carrier t (len x) = array_small_to_large_f t n i n () vr' in
+  Steel.C.Ref.split
+    (array_as_ref #base #t x)
+    v
+    vl
+    vr;
+  let cl : (cl: Steel.C.Connection.connection
+    (array_pcm t (len x))
+    (array_pcm t (len xl)) {
+      cl === array_conn t n z i ()
+    })
+  = magic () // array_conn t n z i ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
+  in
+  Steel.C.Ref.gfocus
+    (array_as_ref #base #t x)
+    cl
+    vl
+    vl';
+  array_as_ref_split_left _ t x i;
+  assert (array_as_ref xl == Steel.C.Ref.ref_focus (array_as_ref x) cl);
+  change_equal_slprop
+    (_ `Steel.C.Ref.pts_to` vl')
+    (array_as_ref xl `Steel.C.Ref.pts_to` vl');
+  to_carrier_split t n v gv i;
+  let gvl : array_view_type t (len xl) = Seq.slice gv 0 (size_v i) in
+  Steel.C.Ref.pts_to_view_intro
+    #j
+    #base
+    #(array_pcm_carrier t (len xl))
+    #(array_pcm t (len xl))
+    (array_as_ref xl)
+    vl'
+    #(array_view_type t (len xl))
+    #(size_v (len xl) = 0)
+    (array_view' t (len xl))
+    gvl;
+  change_equal_slprop // necessary, otherwise F* goes off rails
+    (array_as_ref xl `Steel.C.Ref.pts_to_view` _)
+    (varray0 xl);
+  intro_varray1 xl;
+  let cr : (cr: Steel.C.Connection.connection
+    (array_pcm t (len x))
+    (array_pcm t (len xr)) {
+      cr === array_conn t n i n ()
+    })
+  = magic () // array_conn t n i n ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
+  in
+  Steel.C.Ref.gfocus
+    (array_as_ref #base #t x)
+    cr
+    vr
+    vr';
+  array_as_ref_split_right _ t x i;
+  assert (array_as_ref xr == Steel.C.Ref.ref_focus (array_as_ref x) cr);
+  change_equal_slprop
+    (_ `Steel.C.Ref.pts_to` vr')
+    (array_as_ref xr `Steel.C.Ref.pts_to` vr');
+  let gvr : array_view_type t (len xr) = Seq.slice gv (size_v i) (size_v n) in
+//  let _ : squash ((Ghost.reveal gv <: Seq.seq t) == gvl `Seq.append` gvr) =
+//    Seq.lemma_split gv (size_v i)
+//  in
+  Steel.C.Ref.pts_to_view_intro
+    #j
+    #base
+    #(array_pcm_carrier t (len xr))
+    #(array_pcm t (len xr))
+    (array_as_ref xr)
+    vr'
+    #(array_view_type t (len xr))
+    #(size_v (len xr) = 0)
+    (array_view' t (len xr))
+    gvr;
+  change_equal_slprop // necessary, otherwise F* goes off rails
+    (array_as_ref xr `Steel.C.Ref.pts_to_view` _)
+    (varray0 xr);
+  intro_varray1 xr;
+  let res = GPair xl xr in
+  change_equal_slprop
+    (varray xl)
+    (varray (GPair?.fst res));
+  change_equal_slprop
+    (varray xr)
+    (varray (GPair?.snd res));
+  res
+
+let split
+  #_ #_ #t a i
+=
+  let g = gget (varray a) in
+  Seq.lemma_split #t (Ghost.reveal g) (size_v i);
+  split' a i
+
 
 (*
 
+    #j
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+
+
 noeq
 type array base t = {
   base_len: Ghost.erased size_t;
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index b172c98eec5..1bba94800ff 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -167,22 +167,22 @@ val merge_assoc
   ))
   [SMTPat (merge (merge r1 r2) r3)]
 
+[@erasable]
+noeq
+type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
+
 val gsplit
   (#base: Type)
   (#t: Type)
   (r: array base t)
   (i: size_t)
-: Ghost (array base t & array base t)
+: Ghost (array base t `gpair` array base t)
   (requires (size_v i <= length r))
-  (ensures (fun (rl, rr) ->
+  (ensures (fun (GPair rl rr) ->
     merge_into rl rr r /\
     length rl == size_v i
   ))
 
-[@erasable]
-noeq
-type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
-
 val split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
   : SteelGhost (array base t `gpair` array base t) opened
           (varray a)
@@ -193,8 +193,7 @@ val split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
             let sl = h' (varray (GPair?.fst res)) in
             let sr = h' (varray (GPair?.snd res)) in
             size_v i <= length a /\
-            GPair?.fst res == fst (gsplit a i) /\
-            GPair?.snd res == snd (gsplit a i) /\
+            res == gsplit a i /\
             sl == Seq.slice s 0 (size_v i) /\
             sr == Seq.slice s (size_v i) (length a) /\
             s == sl `Seq.append` sr
@@ -208,7 +207,7 @@ val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
           (fun h res h' ->
             h' (varray a) == h (varray a) /\
             size_v i <= length a /\
-            res == fst (gsplit a i)
+            res == GPair?.fst (gsplit a i)
           )
 
 val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
@@ -219,7 +218,7 @@ val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
           (fun h res h' ->
             h' (varray a) == h (varray a) /\
             size_v i <= length a /\
-            res == snd (gsplit a i)
+            res == GPair?.snd (gsplit a i)
           )
 
 val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)

From e7154b48bba324704700cb63a66f420f52b4a53b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Sep 2021 10:55:49 -0700
Subject: [PATCH 235/513] improve fpu extensionality

---
 ulib/experimental/Steel.C.Connection.fst | 140 +++++++++++++++++++----
 ulib/experimental/Steel.C.PCM.fsti       |  13 ++-
 ulib/experimental/Steel.C.Ref.fst        |   2 +-
 ulib/experimental/Steel.C.Union.fst      |   6 +-
 4 files changed, 133 insertions(+), 28 deletions(-)

diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index 1fa939a4d4c..4854c8fefeb 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -147,6 +147,20 @@ let restricted_frame_preserving_upd_elim
 : Tot (frame_preserving_upd p x y)
 = f
 
+noeq
+type fpu_t
+  (#a:Type u#a) (p:pcm a) (x y: Ghost.erased a)
+= {
+  fpu_f: (frame_preserving_upd_dom p x ^-> a);
+  fpu_prf: squash (forall (v: frame_preserving_upd_dom p x) . frame_preserving_upd_post p x y v (fpu_f v));
+}
+
+let mk_restricted_frame_preserving_upd
+  (#a:Type u#a) (#p:pcm a) (#x #y: Ghost.erased a)
+  (phi: fpu_t p x y)
+: Tot (restricted_frame_preserving_upd p x y)
+= restricted_frame_preserving_upd_intro #_ #p #x #y (fun v -> phi.fpu_f v)
+
 let fpu_lift_dom (#t_small: Type) (p_small: pcm t_small)
 = (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) &
    y:Ghost.erased t_small &
@@ -156,7 +170,7 @@ let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_sm
   (conn_small_to_large: morphism p_small p_large)
 : fpu_lift_dom p_small -> Type
 = fun (|x, y, f|) ->
-  restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
+  fpu_t p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
 
 let fpu_lift (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
@@ -172,7 +186,8 @@ let fpu_lift_elim (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_s
   (y: Ghost.erased t_small)
   (f: frame_preserving_upd p_small x y)
 : Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y))
-= lift (| x, y, restricted_frame_preserving_upd_intro f |)
+= let phi = lift (| x, y, restricted_frame_preserving_upd_intro f |) in
+  (fun v -> phi.fpu_f v)
 
 (** A connection from a "large" PCM p_large to a "small" PCM p_small
     is composed of an injective morphism small->large + the left inverse
@@ -191,26 +206,47 @@ type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t
   conn_lift_frame_preserving_upd: fpu_lift conn_small_to_large;
 }
 
-let mkconnection0 (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+let on_dom_nondep
+  (a #b: Type)
+  (f: a -> b)
+: Tot (a ^-> b)
+= on_dom a f
+
+let mkconnection1
+ (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
   (conn_large_to_small: morphism p_large p_small)
   (conn_small_to_large_inv:
     squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
-  (conn_lift_frame_preserving_upd:
+  (conn_lift_frame_preserving_upd_f:
     (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
      y:Ghost.erased t_small ->
      restricted_frame_preserving_upd p_small x y ->
-     restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+     v:frame_preserving_upd_dom p_large (conn_small_to_large.morph x) ->
+     t_large
+  ))
+  (conn_lift_frame_preserving_upd_prf:
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
+     y:Ghost.erased t_small ->
+     f: restricted_frame_preserving_upd p_small x y ->
+     v:frame_preserving_upd_dom p_large (conn_small_to_large.morph x) ->
+     Lemma
+     (frame_preserving_upd_post p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y) v (conn_lift_frame_preserving_upd_f x y f v))
+  ))
 : connection p_large p_small = {
   conn_small_to_large = conn_small_to_large;
   conn_large_to_small = conn_large_to_small;
   conn_small_to_large_inv = conn_small_to_large_inv;
   conn_lift_frame_preserving_upd =
-    on_domain
+    on_dom
       (fpu_lift_dom p_small)
       (fun (z: fpu_lift_dom p_small) ->
-        let (|x, y, f|) = z in
-	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
+        (let (|x, y, f|) = z in {
+        fpu_f = on_dom_nondep
+          (frame_preserving_upd_dom p_large (Ghost.reveal (Ghost.hide (conn_small_to_large.morph x))))
+          (conn_lift_frame_preserving_upd_f x y f);
+        fpu_prf = Classical.forall_intro (conn_lift_frame_preserving_upd_prf x y f)
+      } <: fpu_t p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)) <: fpu_lift_cod conn_small_to_large z);
 }
 
 let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
@@ -221,17 +257,17 @@ let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pc
   (conn_lift_frame_preserving_upd:
     (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
      y:Ghost.erased t_small ->
-     frame_preserving_upd p_small x y ->
+     restricted_frame_preserving_upd p_small x y ->
      frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
 : connection p_large p_small =
-  mkconnection0
+  mkconnection1
     conn_small_to_large
     conn_large_to_small
     conn_small_to_large_inv
-    (fun x y f ->
-      restricted_frame_preserving_upd_intro (conn_lift_frame_preserving_upd x y f))
+    conn_lift_frame_preserving_upd
+    (fun x y f v -> ())
 
-let connection_eq #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
+let connection_eq' #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
 : Lemma
     (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
               l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
@@ -239,8 +275,54 @@ let connection_eq #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
     (ensures l == m)
 = ()
 
+let extensionality (a: Type) (b: (a -> Type)) (f g: restricted_t a b)
+    : Lemma (ensures (feq #a #b f g <==> f == g))
+= FStar.FunctionalExtensionality.extensionality a b f g
+
+let extensionality_nondep (a0 a1 a2: Type) (b: Type)
+  (f: a1 ^-> b)
+  (g: a2 ^-> b)
+: Lemma
+  (requires (a0 == a1 /\ a0 == a2))
+  (ensures (feq f g <==> f == g))
+= extensionality _ _ f g
+
+let connection_eq_gen
+  #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
+  (sq: squash (
+    l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
+    l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph
+  ))
+  (phi:
+    (x: Ghost.erased b { ~ (Ghost.reveal x == one q) }) ->
+    (y: Ghost.erased b) ->
+    (f: restricted_frame_preserving_upd q x y) ->
+    (v: frame_preserving_upd_dom p (l.conn_small_to_large.morph x)) ->
+    Lemma
+    ((l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f v == (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f v)
+  )
+: Lemma
+  (l == m)
+= let psi
+    (x: Ghost.erased b { ~ (Ghost.reveal x == one q) })
+    (y: Ghost.erased b)
+    (f: restricted_frame_preserving_upd q x y)
+  : Lemma
+    ((l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f == (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f)
+  = Classical.forall_intro (phi x y f);
+    extensionality_nondep
+      (frame_preserving_upd_dom p (l.conn_small_to_large.morph x))
+      (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (l.conn_small_to_large.morph x))))
+      (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (m.conn_small_to_large.morph x))))
+      a
+      (l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f 
+      (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f
+  in
+  Classical.forall_intro_3 psi;
+  connection_eq' l m
+
 let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
-  mkconnection0
+  mkconnection
     (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
     (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
     ()
@@ -248,13 +330,13 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
     let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
     let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
     let fb = fbc.conn_lift_frame_preserving_upd (| xc, yc, f |) in
-    fab.conn_lift_frame_preserving_upd (| xb, yb, fb |) )
+    mk_restricted_frame_preserving_upd (fab.conn_lift_frame_preserving_upd (| xb, yb, mk_restricted_frame_preserving_upd fb |) ))
 
 let connection_id
   (#a: Type)
   (p: pcm a)
 : Tot (connection p p)
-= mkconnection0
+= mkconnection
     (morphism_id p)
     (morphism_id p)
     ()
@@ -265,16 +347,22 @@ let connection_compose_id_left
   (c: connection p_large p_small)
 : Lemma
   (connection_id p_large `connection_compose` c == c)
-= connection_eq (connection_id p_large `connection_compose` c) c
+= connection_eq_gen
+    (connection_id p_large `connection_compose` c) c
+    ()
+    (fun x y f v -> ())
 
 let connection_compose_id_right
   (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (c: connection p_large p_small)
 : Lemma
   (c `connection_compose` connection_id p_small == c)
-= connection_eq (c `connection_compose` connection_id p_small) c
+= connection_eq_gen
+    (c `connection_compose` connection_id p_small) c
+    ()
+    (fun x y f v -> ())
 
-#push-options "--z3rlimit 32"
+#push-options "--z3rlimit 16"
 
 let connection_compose_assoc
   (#t1 #t2 #t3 #t4: Type)
@@ -288,7 +376,11 @@ let connection_compose_assoc
 : Lemma
   ((c12 `connection_compose` c23) `connection_compose` c34 == c12 `connection_compose` (c23 `connection_compose` c34))
 =
-  ((c12 `connection_compose` c23) `connection_compose` c34) `connection_eq` (c12 `connection_compose` (c23 `connection_compose` c34))
+  connection_eq_gen
+    ((c12 `connection_compose` c23) `connection_compose` c34)
+    (c12 `connection_compose` (c23 `connection_compose` c34))
+    ()
+    (fun x y f v -> ())
 
 #pop-options
 
@@ -490,7 +582,7 @@ let connection_of_isomorphism
   (#p2: pcm t2)
   (i: isomorphism p1 p2)
 : Tot (connection p1 p2)
-= mkconnection0
+= mkconnection
     i.iso_2_1
     i.iso_1_2
     i.iso_1_2_inv_2_1
@@ -504,7 +596,11 @@ let connection_of_isomorphism_inverse_left
 : Lemma
   (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i == connection_id _)
 = Classical.forall_intro_3 (connection_of_isomorphism_fpu_inverse i);
-  (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i) `connection_eq` connection_id _
+  connection_eq_gen
+    (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i)
+    (connection_id _)
+    ()
+    (fun x y f v -> ())
 
 let connection_of_isomorphism_inverse_right
   (#t1 #t2: Type)
diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
index 637c0595207..3e2fb92a54a 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.PCM.fsti
@@ -198,16 +198,23 @@ let frame_preserving_upd_dom
     compatible p x v
   }
 
-let frame_preserving_upd_codom
+let frame_preserving_upd_post
   (#a:Type u#a) (p:pcm0 a) (x y:a)
   (v: frame_preserving_upd_dom p x)
+  (v_new: a)
+: Tot prop
 =
-  v_new:a{
     p_refine p v_new /\
     compatible p y v_new /\
     (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
        composable p y frame /\
-       (op p x frame == v ==> op p y frame == v_new))}
+       (op p x frame == v ==> op p y frame == v_new))
+
+let frame_preserving_upd_codom
+  (#a:Type u#a) (p:pcm0 a) (x y:a)
+  (v: frame_preserving_upd_dom p x)
+=
+  v_new:a{frame_preserving_upd_post p x y v v_new}
 
 type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
   v: frame_preserving_upd_dom p x ->
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 354eb5ce4d9..e1b77213a2c 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -168,7 +168,7 @@ let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p
 = let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (c.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|) ))
+  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|) )))
 
 let as_action (#p:vprop)
               (#q:vprop)
diff --git a/ulib/experimental/Steel.C.Union.fst b/ulib/experimental/Steel.C.Union.fst
index abc78c31881..c0060f8a353 100644
--- a/ulib/experimental/Steel.C.Union.fst
+++ b/ulib/experimental/Steel.C.Union.fst
@@ -293,9 +293,8 @@ let union_field_lift_fpu0_prf1
 
 #restart-solver
 
-#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 16"
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 64"
 
-#push-options "--z3rlimit 30"
 let union_field_lift_fpu0_prf2
   (#a: eqtype)
   (#b: a -> Type)
@@ -325,8 +324,11 @@ let union_field_lift_fpu0_prf2
       assert (composable (p k) x (frame k));
       assert (composable (p k) y (frame k))
   )
+
 #pop-options
 
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 128"
+
 #restart-solver
 
 let union_field_lift_fpu0_prf3

From cbd004fc829dce1dac9696dd592f2f58bc7088f1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Sep 2021 19:06:40 -0700
Subject: [PATCH 236/513] some extensionality massage on
 Steel.C.Array.array_conn

---
 ulib/experimental/Steel.C.Array.fst | 103 +++++++++++++++++++---------
 1 file changed, 72 insertions(+), 31 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 0feef33a139..3dc9c091043 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -328,26 +328,6 @@ let array_conn_fpu_f
   in
   v'
 
-let array_conn_fpu
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
-  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
-: Tot (frame_preserving_upd (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y))
-= frame_preserving_upd_intro
-    (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) (array_small_to_large_f t base_len from to sq y)
-    (array_conn_fpu_f t base_len from to sq x y f)
-    (fun _ -> assume False)
-    (fun _ _ -> assume False)
-    (fun _ _ -> assume False)
-
 #pop-options
 
 let array_conn
@@ -363,11 +343,12 @@ let array_conn
     (array_pcm t base_len)
     (array_pcm t (to `size_sub` from))
 =
-  Steel.C.Connection.mkconnection
+  Steel.C.Connection.mkconnection1
     (array_small_to_large t base_len from to sq)
     (array_large_to_small t base_len from to sq)
     (array_small_to_large_to_small t base_len from to sq)
-    (array_conn_fpu t base_len from to sq)
+    (array_conn_fpu_f t base_len from to sq)
+    (fun x y f v -> assume False)
 
 #push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
 #restart-solver
@@ -380,13 +361,58 @@ let array_conn_id
 =
   let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
   assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
-  assume (forall (x: Ghost.erased (array_pcm_carrier t (base_len `size_sub` z)) { ~ (Ghost.reveal x == one (array_pcm t (base_len `size_sub` z))) }) y (f: frame_preserving_upd (array_pcm t (base_len `size_sub` z)) x y) v . array_conn_fpu_f t base_len z base_len () x y f v `feq` f v);
-  assert (forall x y f . array_conn_fpu_f t base_len z base_len () x y f `feq` f);
-  assume ((array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len ()).Steel.C.Connection.conn_lift_frame_preserving_upd === (Steel.C.Connection.connection_id (array_pcm t base_len)).Steel.C.Connection.conn_lift_frame_preserving_upd);
-  array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () `Steel.C.Connection.connection_eq` Steel.C.Connection.connection_id _
+  assert (forall x . array_small_to_large_f t base_len z base_len () x == x);
+  assert (forall x . array_large_to_small_f t base_len z base_len () x `feq` x);
+  assert (forall x . array_large_to_small_f t base_len z base_len () x == x);
+  let c = array_conn t base_len z base_len () in
+  Steel.C.Connection.connection_eq_gen
+    c
+    (Steel.C.Connection.connection_id _)
+    ()
+    (fun x y f v ->
+      assume (array_conn_fpu_f t base_len z base_len () x y f v `feq` f v);
+      assert (array_conn_fpu_f t base_len z base_len () x y f v == f v);
+      assert ((c.Steel.C.Connection.conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v == array_conn_fpu_f t base_len z base_len () x y f v);
+      assert (((Steel.C.Connection.connection_id _).conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v == f v);
+      ()
+    )
 
 #restart-solver
 
+let connection_eq_gen
+  #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Connection.connection` q1)
+  #b2 (#q2: pcm b2) (c2: p `Steel.C.Connection.connection` q2)
+  (sq: squash (
+    b1 == b2 /\
+    q1 == q2 /\
+    c1.conn_small_to_large.morph `feq` c2.conn_small_to_large.morph /\
+    c1.conn_large_to_small.morph `feq` c2.conn_large_to_small.morph
+  ))
+  (phi:
+    (x1: Ghost.erased b1 { ~ (Ghost.reveal x1 == one q1) }) ->
+    (y1: Ghost.erased b1) ->
+    (f1: Steel.C.Connection.restricted_frame_preserving_upd q1 x1 y1) ->
+    (v1: frame_preserving_upd_dom p (c1.conn_small_to_large.morph x1)) ->
+    (x2: Ghost.erased b2 { ~ (Ghost.reveal x2 == one q2) }) ->
+    (y2: Ghost.erased b2) ->
+    (f2: Steel.C.Connection.restricted_frame_preserving_upd q2 x2 y2) ->
+    (v2: frame_preserving_upd_dom p (c2.conn_small_to_large.morph x2)) ->
+    (sq': squash (
+      x1 == x2 /\
+      y1 == y2 /\
+      f1 == f2 /\
+      v1 == v2
+    )) ->
+    Tot
+    (squash ((c1.conn_lift_frame_preserving_upd (| x1, y1, f1 |)).fpu_f v1 == (c2.conn_lift_frame_preserving_upd (| x2, y2, f2 |)).fpu_f v2))
+  )
+: Lemma
+  (c1 == c2)
+= Steel.C.Connection.connection_eq_gen c1 c2 () (fun x y f v -> phi x y f v x y f v ())
+
+#set-options "--print_implicits"
+#restart-solver
+
 let array_conn_compose
   (t: Type0)
   (base_len: Ghost.erased size_t)
@@ -407,15 +433,30 @@ let array_conn_compose
   ))
 =
   let z = to1 `size_sub` from1 in
+  let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
+  let _ : squash (sz == size_sub to2 from2) = () in
   assert (forall x . array_small_to_large_f t base_len from1 to1 () (array_small_to_large_f t z from2 to2 ()  x) `feq` array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
   assert (forall x . array_large_to_small_f t z from2 to2 () (array_large_to_small_f t base_len from1 to1 () x) `feq` array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
   let cc = array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t z from2 to2 () in
   let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
-  assume (
-    cc.Steel.C.Connection.conn_lift_frame_preserving_upd ===
-    c.Steel.C.Connection.conn_lift_frame_preserving_upd
-  );
-  cc `Steel.C.Connection.connection_eq` c
+  let sq : squash (
+      cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
+      cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
+  ) = () in
+  let prf
+    (x: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)) { ~ (Ghost.reveal x == one (array_pcm t (to2 `size_sub` from2))) })
+    (y: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)))
+    (f: Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t (to2 `size_sub` from2)) x y)
+    (v: frame_preserving_upd_dom (array_pcm t base_len) (cc.Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x))
+  : Tot (squash (
+//    let x' : (x': Ghost.erased (array_pcm_carrier t sz) { ~ (Ghost.reveal x' == one (array_pcm t sz)) }) = x in
+//    let y' : Ghost.erased (array_pcm_carrier t sz) = y in
+//    let f' : Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t sz) x' y' = f in
+//    let v' : frame_preserving_upd_dom (array_pcm t base_len) (c.Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x') = v in
+    ((cc.Steel.C.Connection.conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v == (c.Steel.C.Connection.conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v)))
+  = assume False
+  in
+  connection_eq_gen cc c sq (fun x1 y1 f1 v1 x2 y2 f2 v2 sq' -> prf x1 y1 f1 v1)
 
 let to_view_array_conn
   (t: Type0)

From bd98ca30b9162c8b4de506c685ff7ecf20ddac9f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Sep 2021 10:52:35 -0700
Subject: [PATCH 237/513] make Steel.C.Ref.split, gather SteelGhost

---
 ulib/experimental/Steel.C.Ref.fst  | 6 +++---
 ulib/experimental/Steel.C.Ref.fsti | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index eff2e3cf733..c37099a7629 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -108,14 +108,14 @@ let split r xy x y =
     (r `pts_to` y)
 
 let mgather
-  (#a:Type) (#p:P.pcm a)
+  (#inames: _) (#a:Type) (#p:P.pcm a)
   (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: SteelT (_:unit{P.composable p v0 v1})
+: A.SteelGhostT (_:unit{P.composable p v0 v1}) inames
     (mpts_to r v0 `star` mpts_to r v1)
     (fun _ -> mpts_to r (P.op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
-let gather #a #b #p r x y =
+let gather #inames #a #b #p r x y =
   let c = raise_pl r in
   let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
   let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 0be569dfe64..c4dcea377cd 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -80,16 +80,16 @@ val unfocus (#opened:M.inames)
     (ensures fun _ _ _ -> True)
 
 (** Split the permissions on a reference into two halves. *)
-val split (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
-: Steel unit
+val split (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+: A.SteelGhost unit inames
     (r `pts_to` xy)
     (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
     (fun _ _ _ -> True)
 
 (** Inverse of split. *)
-val gather (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
-: SteelT (_:unit{composable p x y})
+val gather (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+: A.SteelGhostT (_:unit{composable p x y}) inames
     ((r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> r `pts_to` op p x y)
 

From 0629c821d6fa97c24ce4389e7d47052e2e376971 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Sep 2021 11:51:21 -0700
Subject: [PATCH 238/513] make Steel.C.Ref.ref_focus GTot, split off gfocus

---
 ulib/experimental/Steel.C.Ref.fst  | 18 +++++++++++++++---
 ulib/experimental/Steel.C.Ref.fsti | 11 ++++++++++-
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index c37099a7629..995cbf2c286 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -40,7 +40,13 @@ let raise_pl
 let pts_to r v =
   r.r `mpts_to` (raise_pl r).conn_small_to_large.morph v
 
-let ref_focus r #q l = {p = r.p; pl = connection_compose r.pl l; r = r.r; q = q}
+let t_ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: Tot (ref a q)
+= {p = r.p; pl = connection_compose r.pl l; r = r.r; q = q}
+
+let ref_focus r l = t_ref_focus r l
 
 let ref_focus_id r = connection_compose_id_right r.pl
 
@@ -73,11 +79,17 @@ let ref_alloc #a p x =
 
 #pop-options
 
-let focus r l s x =
-  let r' = ref_focus r l in
+let gfocus r l s x =
   connection_compose_assoc (lower_conn r) r.pl l;
   A.change_equal_slprop
     (r `pts_to` s)
+    (ref_focus r l `pts_to` x)
+
+let focus r l s x =
+  let r' = t_ref_focus r l in
+  gfocus r l s x;
+  A.change_equal_slprop
+    (ref_focus r l `pts_to` x)
     (r' `pts_to` x);
   A.return r'
 
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index c4dcea377cd..4ad7cb405dc 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -29,7 +29,7 @@ val pts_to
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
-: ref a q
+: GTot (ref a q)
 
 val ref_focus_id
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
@@ -56,6 +56,15 @@ val ref_alloc
     (ensures fun _ _ _ -> True)
 
 (** Take a pointer to a "substructure" of a reference. *)
+val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
+  (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: A.SteelGhost unit inames
+    (r `pts_to` s)
+    (fun _ -> ref_focus r l `pts_to` x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ _ _ -> True)
+
 val focus (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)

From f50289163be6dce7643d973511c97b2f4c65fcbd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Sep 2021 10:55:49 -0700
Subject: [PATCH 239/513] improve fpu extensionality

---
 ulib/experimental/Steel.C.Connection.fst | 140 +++++++++++++++++++----
 ulib/experimental/Steel.C.PCM.fsti       |  13 ++-
 ulib/experimental/Steel.C.Ref.fst        |   2 +-
 ulib/experimental/Steel.C.Union.fst      |   6 +-
 4 files changed, 133 insertions(+), 28 deletions(-)

diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index 1fa939a4d4c..4854c8fefeb 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -147,6 +147,20 @@ let restricted_frame_preserving_upd_elim
 : Tot (frame_preserving_upd p x y)
 = f
 
+noeq
+type fpu_t
+  (#a:Type u#a) (p:pcm a) (x y: Ghost.erased a)
+= {
+  fpu_f: (frame_preserving_upd_dom p x ^-> a);
+  fpu_prf: squash (forall (v: frame_preserving_upd_dom p x) . frame_preserving_upd_post p x y v (fpu_f v));
+}
+
+let mk_restricted_frame_preserving_upd
+  (#a:Type u#a) (#p:pcm a) (#x #y: Ghost.erased a)
+  (phi: fpu_t p x y)
+: Tot (restricted_frame_preserving_upd p x y)
+= restricted_frame_preserving_upd_intro #_ #p #x #y (fun v -> phi.fpu_f v)
+
 let fpu_lift_dom (#t_small: Type) (p_small: pcm t_small)
 = (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) &
    y:Ghost.erased t_small &
@@ -156,7 +170,7 @@ let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_sm
   (conn_small_to_large: morphism p_small p_large)
 : fpu_lift_dom p_small -> Type
 = fun (|x, y, f|) ->
-  restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
+  fpu_t p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
 
 let fpu_lift (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
@@ -172,7 +186,8 @@ let fpu_lift_elim (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_s
   (y: Ghost.erased t_small)
   (f: frame_preserving_upd p_small x y)
 : Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y))
-= lift (| x, y, restricted_frame_preserving_upd_intro f |)
+= let phi = lift (| x, y, restricted_frame_preserving_upd_intro f |) in
+  (fun v -> phi.fpu_f v)
 
 (** A connection from a "large" PCM p_large to a "small" PCM p_small
     is composed of an injective morphism small->large + the left inverse
@@ -191,26 +206,47 @@ type connection (#t_large #t_small: Type) (p_large: pcm t_large) (p_small: pcm t
   conn_lift_frame_preserving_upd: fpu_lift conn_small_to_large;
 }
 
-let mkconnection0 (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
+let on_dom_nondep
+  (a #b: Type)
+  (f: a -> b)
+: Tot (a ^-> b)
+= on_dom a f
+
+let mkconnection1
+ (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
   (conn_large_to_small: morphism p_large p_small)
   (conn_small_to_large_inv:
     squash (conn_large_to_small.morph `is_inverse_of` conn_small_to_large.morph))
-  (conn_lift_frame_preserving_upd:
+  (conn_lift_frame_preserving_upd_f:
     (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
      y:Ghost.erased t_small ->
      restricted_frame_preserving_upd p_small x y ->
-     restricted_frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
+     v:frame_preserving_upd_dom p_large (conn_small_to_large.morph x) ->
+     t_large
+  ))
+  (conn_lift_frame_preserving_upd_prf:
+    (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
+     y:Ghost.erased t_small ->
+     f: restricted_frame_preserving_upd p_small x y ->
+     v:frame_preserving_upd_dom p_large (conn_small_to_large.morph x) ->
+     Lemma
+     (frame_preserving_upd_post p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y) v (conn_lift_frame_preserving_upd_f x y f v))
+  ))
 : connection p_large p_small = {
   conn_small_to_large = conn_small_to_large;
   conn_large_to_small = conn_large_to_small;
   conn_small_to_large_inv = conn_small_to_large_inv;
   conn_lift_frame_preserving_upd =
-    on_domain
+    on_dom
       (fpu_lift_dom p_small)
       (fun (z: fpu_lift_dom p_small) ->
-        let (|x, y, f|) = z in
-	conn_lift_frame_preserving_upd x y f <: fpu_lift_cod conn_small_to_large z)
+        (let (|x, y, f|) = z in {
+        fpu_f = on_dom_nondep
+          (frame_preserving_upd_dom p_large (Ghost.reveal (Ghost.hide (conn_small_to_large.morph x))))
+          (conn_lift_frame_preserving_upd_f x y f);
+        fpu_prf = Classical.forall_intro (conn_lift_frame_preserving_upd_prf x y f)
+      } <: fpu_t p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)) <: fpu_lift_cod conn_small_to_large z);
 }
 
 let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
@@ -221,17 +257,17 @@ let mkconnection (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pc
   (conn_lift_frame_preserving_upd:
     (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) ->
      y:Ghost.erased t_small ->
-     frame_preserving_upd p_small x y ->
+     restricted_frame_preserving_upd p_small x y ->
      frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)))
 : connection p_large p_small =
-  mkconnection0
+  mkconnection1
     conn_small_to_large
     conn_large_to_small
     conn_small_to_large_inv
-    (fun x y f ->
-      restricted_frame_preserving_upd_intro (conn_lift_frame_preserving_upd x y f))
+    conn_lift_frame_preserving_upd
+    (fun x y f v -> ())
 
-let connection_eq #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
+let connection_eq' #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
 : Lemma
     (requires l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
               l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph /\
@@ -239,8 +275,54 @@ let connection_eq #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
     (ensures l == m)
 = ()
 
+let extensionality (a: Type) (b: (a -> Type)) (f g: restricted_t a b)
+    : Lemma (ensures (feq #a #b f g <==> f == g))
+= FStar.FunctionalExtensionality.extensionality a b f g
+
+let extensionality_nondep (a0 a1 a2: Type) (b: Type)
+  (f: a1 ^-> b)
+  (g: a2 ^-> b)
+: Lemma
+  (requires (a0 == a1 /\ a0 == a2))
+  (ensures (feq f g <==> f == g))
+= extensionality _ _ f g
+
+let connection_eq_gen
+  #a (#p: pcm a) #b (#q: pcm b) (l m: p `connection` q)
+  (sq: squash (
+    l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph /\
+    l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph
+  ))
+  (phi:
+    (x: Ghost.erased b { ~ (Ghost.reveal x == one q) }) ->
+    (y: Ghost.erased b) ->
+    (f: restricted_frame_preserving_upd q x y) ->
+    (v: frame_preserving_upd_dom p (l.conn_small_to_large.morph x)) ->
+    Lemma
+    ((l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f v == (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f v)
+  )
+: Lemma
+  (l == m)
+= let psi
+    (x: Ghost.erased b { ~ (Ghost.reveal x == one q) })
+    (y: Ghost.erased b)
+    (f: restricted_frame_preserving_upd q x y)
+  : Lemma
+    ((l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f == (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f)
+  = Classical.forall_intro (phi x y f);
+    extensionality_nondep
+      (frame_preserving_upd_dom p (l.conn_small_to_large.morph x))
+      (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (l.conn_small_to_large.morph x))))
+      (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (m.conn_small_to_large.morph x))))
+      a
+      (l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f 
+      (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f
+  in
+  Classical.forall_intro_3 psi;
+  connection_eq' l m
+
 let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc) : Tot (connection pa pc) =
-  mkconnection0
+  mkconnection
     (fbc.conn_small_to_large `morphism_compose` fab.conn_small_to_large)
     (fab.conn_large_to_small `morphism_compose` fbc.conn_large_to_small)
     ()
@@ -248,13 +330,13 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
     let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
     let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
     let fb = fbc.conn_lift_frame_preserving_upd (| xc, yc, f |) in
-    fab.conn_lift_frame_preserving_upd (| xb, yb, fb |) )
+    mk_restricted_frame_preserving_upd (fab.conn_lift_frame_preserving_upd (| xb, yb, mk_restricted_frame_preserving_upd fb |) ))
 
 let connection_id
   (#a: Type)
   (p: pcm a)
 : Tot (connection p p)
-= mkconnection0
+= mkconnection
     (morphism_id p)
     (morphism_id p)
     ()
@@ -265,16 +347,22 @@ let connection_compose_id_left
   (c: connection p_large p_small)
 : Lemma
   (connection_id p_large `connection_compose` c == c)
-= connection_eq (connection_id p_large `connection_compose` c) c
+= connection_eq_gen
+    (connection_id p_large `connection_compose` c) c
+    ()
+    (fun x y f v -> ())
 
 let connection_compose_id_right
   (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (c: connection p_large p_small)
 : Lemma
   (c `connection_compose` connection_id p_small == c)
-= connection_eq (c `connection_compose` connection_id p_small) c
+= connection_eq_gen
+    (c `connection_compose` connection_id p_small) c
+    ()
+    (fun x y f v -> ())
 
-#push-options "--z3rlimit 32"
+#push-options "--z3rlimit 16"
 
 let connection_compose_assoc
   (#t1 #t2 #t3 #t4: Type)
@@ -288,7 +376,11 @@ let connection_compose_assoc
 : Lemma
   ((c12 `connection_compose` c23) `connection_compose` c34 == c12 `connection_compose` (c23 `connection_compose` c34))
 =
-  ((c12 `connection_compose` c23) `connection_compose` c34) `connection_eq` (c12 `connection_compose` (c23 `connection_compose` c34))
+  connection_eq_gen
+    ((c12 `connection_compose` c23) `connection_compose` c34)
+    (c12 `connection_compose` (c23 `connection_compose` c34))
+    ()
+    (fun x y f v -> ())
 
 #pop-options
 
@@ -490,7 +582,7 @@ let connection_of_isomorphism
   (#p2: pcm t2)
   (i: isomorphism p1 p2)
 : Tot (connection p1 p2)
-= mkconnection0
+= mkconnection
     i.iso_2_1
     i.iso_1_2
     i.iso_1_2_inv_2_1
@@ -504,7 +596,11 @@ let connection_of_isomorphism_inverse_left
 : Lemma
   (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i == connection_id _)
 = Classical.forall_intro_3 (connection_of_isomorphism_fpu_inverse i);
-  (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i) `connection_eq` connection_id _
+  connection_eq_gen
+    (connection_of_isomorphism (isomorphism_inverse i) `connection_compose` connection_of_isomorphism i)
+    (connection_id _)
+    ()
+    (fun x y f v -> ())
 
 let connection_of_isomorphism_inverse_right
   (#t1 #t2: Type)
diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
index 637c0595207..3e2fb92a54a 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.PCM.fsti
@@ -198,16 +198,23 @@ let frame_preserving_upd_dom
     compatible p x v
   }
 
-let frame_preserving_upd_codom
+let frame_preserving_upd_post
   (#a:Type u#a) (p:pcm0 a) (x y:a)
   (v: frame_preserving_upd_dom p x)
+  (v_new: a)
+: Tot prop
 =
-  v_new:a{
     p_refine p v_new /\
     compatible p y v_new /\
     (forall (frame:a{composable p x frame}).{:pattern composable p x frame}
        composable p y frame /\
-       (op p x frame == v ==> op p y frame == v_new))}
+       (op p x frame == v ==> op p y frame == v_new))
+
+let frame_preserving_upd_codom
+  (#a:Type u#a) (p:pcm0 a) (x y:a)
+  (v: frame_preserving_upd_dom p x)
+=
+  v_new:a{frame_preserving_upd_post p x y v v_new}
 
 type frame_preserving_upd (#a:Type u#a) (p:pcm0 a) (x y:a) =
   v: frame_preserving_upd_dom p x ->
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 995cbf2c286..ef14d4b4f0e 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -168,7 +168,7 @@ let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p
 = let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (c.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|) ))
+  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|) )))
 
 let as_action (#p:vprop)
               (#q:vprop)
diff --git a/ulib/experimental/Steel.C.Union.fst b/ulib/experimental/Steel.C.Union.fst
index abc78c31881..c0060f8a353 100644
--- a/ulib/experimental/Steel.C.Union.fst
+++ b/ulib/experimental/Steel.C.Union.fst
@@ -293,9 +293,8 @@ let union_field_lift_fpu0_prf1
 
 #restart-solver
 
-#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 16"
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 64"
 
-#push-options "--z3rlimit 30"
 let union_field_lift_fpu0_prf2
   (#a: eqtype)
   (#b: a -> Type)
@@ -325,8 +324,11 @@ let union_field_lift_fpu0_prf2
       assert (composable (p k) x (frame k));
       assert (composable (p k) y (frame k))
   )
+
 #pop-options
 
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 128"
+
 #restart-solver
 
 let union_field_lift_fpu0_prf3

From 7ed4a3f9b6f71a17002b6dfb1cf3a818cfe75e2e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 22 Sep 2021 18:07:43 -0700
Subject: [PATCH 240/513] Steel.C.Array.index, upd

---
 ulib/experimental/Steel.C.Array.fst  | 147 +++++++++++++++++++++++----
 ulib/experimental/Steel.C.Array.fsti |  12 +++
 2 files changed, 137 insertions(+), 22 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 3dc9c091043..9d0ae7ae72e 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -485,7 +485,7 @@ let array_as_ref_conn
   (#base: Type)
   (#t: Type)
   (a: array base t)
-: GTot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len a)))
+: Tot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len a)))
 = array_conn t a.base_len a.from a.to a.prf
 
 let array_as_ref
@@ -866,28 +866,131 @@ let split
   Seq.lemma_split #t (Ghost.reveal g) (size_v i);
   split' a i
 
+let split_left
+  a i
+=
+  return (fst (tsplit a i))
 
-(*
+let split_right
+  a i
+=
+  return (snd (tsplit a i))
 
-    #j
-    #base
-    #(array_pcm_carrier t (len x))
-    #(array_pcm t (len x))
-    (array_as_ref #base #t x)
-    #(array_view_type t (len x))
-    #(size_v (len x) = 0)
-    (array_view' t (len x))
+let join' = admit ()
 
+let joinc
+  al ar
+=
+  return (t_merge al ar)
 
-noeq
-type array base t = {
-  base_len: Ghost.erased size_t;
-  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
-  from: size_t;
-  to: size_t; // must be Tot because of array_small_to_large below
-  prf: squash (
-    size_v base_len >= 0 /\
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  );
-}
+let array_as_one_ref_conn
+  (#base: Type)
+  (#t: Type)
+  (a: array base t)
+: Pure (Steel.C.Connection.connection (array_pcm t a.base_len) (Steel.C.Opt.opt_pcm #t))
+  (requires (length a == 1))
+  (ensures (fun _ -> True))
+=
+  Steel.C.Struct.struct_field
+    (array_elements_pcm t a.base_len)
+    a.from
+
+let g_ref_of_array
+  r
+=
+  r.base_ref `Steel.C.Ref.ref_focus` array_as_one_ref_conn r
+
+let ref_of_array_ghost = admit ()
+
+let ref_of_array = admit ()
+
+let array_of_ref = admit ()
+
+let mk_array_of_ref = admit ()
+
+let seq_equal_1
+  (t: Type)
+  (s1 s2: Seq.seq t)
+: Lemma
+  (requires (
+    Seq.length s1 == 1 /\
+    Seq.length s2 == 1 /\
+    Seq.index s1 0 == Seq.index s2 0
+  ))
+  (ensures (s1 == s2))
+= assert (s1 `Seq.equal` s2)
+
+#push-options "--z3rlimit 128 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+let index
+  #_ #t r i
+=
+  let rr = split_right r i in
+  let rs = split r i in
+  change_equal_slprop
+    (varray (GPair?.snd rs))
+    (varray rr);
+  let rrl = split_left rr one_size in
+  let rrs = split rr one_size in
+  change_equal_slprop
+    (varray (GPair?.fst rrs))
+    (varray rrl);
+  let grl = gget (varray rrl) in
+  let r0 = ref_of_array rrl in
+  let res = Steel.C.Opt.ref_opt_read r0 in
+  array_of_ref rrl r0;
+  let grl' = gget (varray rrl) in
+  seq_equal_1 t (Ghost.reveal grl) (Ghost.reveal grl');
+  let rr' = join' rrl (GPair?.snd rrs) in
+  let r' = join' (GPair?.fst rs) rr' in
+  change_equal_slprop
+    (varray r')
+    (varray r);
+  return res
+
+let seq_append_append_upd
+  (t: Type)
+  (i: nat)
+  (x: t)
+  (s1 s2 s2' s3: Seq.seq t)
+: Lemma
+  (requires (
+    Seq.length s1 == i /\
+    Seq.length s2 == 1 /\
+    Seq.length s2' == 1 /\
+    Seq.index s2' 0 == x
+  ))
+  (ensures (
+    s1 `Seq.append` (s2' `Seq.append` s3) == Seq.upd (s1 `Seq.append` (s2 `Seq.append` s3)) i x
+  ))
+= assert (
+    (s1 `Seq.append` (s2' `Seq.append` s3)) `Seq.equal` (Seq.upd (s1 `Seq.append` (s2 `Seq.append` s3)) i x)
+  )
+
+let upd
+  #_ #t r i x
+=
+  let rr = split_right r i in
+  let rs = split r i in
+  let s1 = gget (varray (GPair?.fst rs)) in
+  change_equal_slprop
+    (varray (GPair?.snd rs))
+    (varray rr);
+  let rrl = split_left rr one_size in
+  let rrs = split rr one_size in
+  let s3 = gget (varray (GPair?.snd rrs)) in
+  change_equal_slprop
+    (varray (GPair?.fst rrs))
+    (varray rrl);
+  let s2 = gget (varray rrl) in
+  let r0 = ref_of_array rrl in
+  Steel.C.Opt.ref_opt_write r0 x;
+  array_of_ref rrl r0;
+  let s2' = gget (varray rrl) in
+  seq_append_append_upd t (size_v i) x s1 s2 s2' s3;
+  let rr' = join' rrl (GPair?.snd rrs) in
+  let r' = join' (GPair?.fst rs) rr' in
+  change_equal_slprop
+    (varray r')
+    (varray r)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 1bba94800ff..ea4c7b704eb 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -271,6 +271,18 @@ val g_ref_of_array
   (requires (length r == 1))
   (ensures (fun _ -> True))
 
+val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
+  : SteelGhost unit inames
+             (varray r)
+             (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t))
+             (requires fun _ -> True)
+             (ensures fun h0 _ h1 ->
+               let r' = g_ref_of_array r in
+               let s = h0 (varray r) in
+               Seq.length s == 1 /\
+               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
 val ref_of_array (#base: Type) (#t:Type0) (r:array base t)
   : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
              (varray r)

From d66134df7dea4309277e689203021e14252213c0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Sep 2021 12:24:13 -0700
Subject: [PATCH 241/513] remove useless use of comm in Steel.C.PCM.compatible

---
 ulib/experimental/Steel.C.PCM.fsti | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
index 3e2fb92a54a..6e8c5ab483c 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.PCM.fsti
@@ -116,7 +116,7 @@ let exclusive (#a:Type u#a) (p:pcm0 a) (x:a) =
 
 let compatible (#a: Type u#a) (pcm:pcm0 a) (x y:a) =
   (exists (frame:a).
-    composable pcm x frame /\ op pcm frame x == y
+    composable pcm x frame /\ op pcm x frame == y
   )
 
 val is_unit (#a: Type u#a) (p:pcm0 a)
@@ -137,7 +137,7 @@ val compatible_intro
   (x y: a)
   (frame: a)
 : Lemma
-  (requires (composable pcm x frame /\ op pcm frame x == y))
+  (requires (composable pcm x frame /\ op pcm x frame == y))
   (ensures (compatible pcm x y))
 
 val compatible_elim
@@ -148,7 +148,7 @@ val compatible_elim
   (requires (compatible pcm x y))
   (ensures (fun frame ->
     composable pcm x frame /\
-    op pcm frame x == y
+    op pcm x frame == y
   ))
 
 val compatible_refl

From 8993c732540a177cb6a7d48c42d1275e653f62a1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Sep 2021 13:57:01 -0700
Subject: [PATCH 242/513] solve `assume`s in array_conn_fpu_f

---
 ulib/experimental/Steel.C.Array.fst | 91 ++++++++++++++++++++++++-----
 1 file changed, 77 insertions(+), 14 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 9d0ae7ae72e..b06a5f68641 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -19,6 +19,20 @@ open FStar.FunctionalExtensionality
 
 let array_pcm_carrier t n = restricted_t (array_domain t n) (array_range t n)
 
+let array_pcm_carrier_ext
+  (t: Type)
+  (n: size_t)
+  (x1 x2: array_pcm_carrier t n)
+  (f: (
+    (i: array_domain t n) ->
+    Lemma
+    (x1 i == x2 i)
+  ))
+: Lemma
+  (ensures (x1 == x2))
+= Classical.forall_intro f;
+  assert (x1 `feq` x2)
+
 let array_elements_pcm
   (t: Type u#0)
   (n: Ghost.erased size_t)
@@ -275,7 +289,7 @@ let array_small_to_large_to_small
   (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
 = assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
 
-#push-options "--z3rlimit 32 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
 #restart-solver
 
 let size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
@@ -285,6 +299,66 @@ let size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
 
 #restart-solver
 
+let array_conn_fpu_compatible
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Lemma
+  (
+    let z = size_sub to from in
+    let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+    compatible (array_pcm t z) x v_small
+  )
+=
+  let z = size_sub to from in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
+  let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
+  S.prod_pcm_composable_intro
+    (array_elements_pcm t z)
+    x
+    frame_small
+    (fun h ->
+      assert (composable (Steel.C.Opt.opt_pcm #t) (array_small_to_large_f t base_len from to sq x (from `size_add` h)) (Ghost.reveal frame (from `size_add` h))
+      )
+    );
+  assert (composable (array_pcm t (z)) x frame_small);
+  array_pcm_carrier_ext t z (op (array_pcm t (z)) x frame_small) v_small (fun i ->
+    assert (op (Steel.C.Opt.opt_pcm #t) (array_small_to_large_f t base_len from to sq x (from `size_add` i)) (Ghost.reveal frame (from `size_add` i)) == v (from `size_add` i))
+  );
+  compatible_intro (array_pcm t (z)) x v_small frame_small
+
+let array_conn_fpu_refine
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Lemma
+  (
+    let z = size_sub to from in
+    let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+    p_refine (array_pcm t (z)) v_small
+  )
+=
+  let z = size_sub to from in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (x: array_domain t z) . True)
+  then ()
+  else assert (Ghost.reveal x `feq` one (array_pcm t z))
+
 let array_conn_fpu_f
   (t: Type0)
   (base_len: Ghost.erased size_t)
@@ -302,19 +376,8 @@ let array_conn_fpu_f
 = let sq0 : squash (size_v to >= size_v from) = () in
   let z : size_t = size_sub' to from sq0 in
   let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-  // let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
-  // let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
-  // S.prod_pcm_composable_intro
-  //   (array_elements_pcm t z)
-  //   x
-  //   frame_small
-  //   (fun h -> assume False);
-  // assert (composable (array_pcm t (z)) x frame_small);
-  // op_comm (array_pcm t (z)) x frame_small;
-  // assert (op (array_pcm t (z)) frame_small x `feq` v_small);
-  // compatible_intro (array_pcm t (z)) x v_small frame_small;
-  assume (compatible (array_pcm t (z)) x v_small);
-  assume (p_refine (array_pcm t (z)) v_small); // TODO: remove p_refine from Steel.C.PCM
+  array_conn_fpu_compatible t base_len from to sq x v;
+  array_conn_fpu_refine t base_len from to sq x v;
   let v_small' : array_pcm_carrier t z = f v_small in
   let v' : array_pcm_carrier t base_len =
     on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->

From ac68bfb7848a271022f758e09ecd7507c5112908 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Sep 2021 17:34:47 -0700
Subject: [PATCH 243/513] Steel.C.Connection.fpu_lift_dom: replace dtuples with
 custom record

---
 ulib/experimental/Steel.C.Connection.fst | 27 ++++++++++++------------
 ulib/experimental/Steel.C.Ref.fst        |  2 +-
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index 4854c8fefeb..b0746087edf 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -161,15 +161,16 @@ let mk_restricted_frame_preserving_upd
 : Tot (restricted_frame_preserving_upd p x y)
 = restricted_frame_preserving_upd_intro #_ #p #x #y (fun v -> phi.fpu_f v)
 
-let fpu_lift_dom (#t_small: Type) (p_small: pcm t_small)
-= (x:(x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))}) &
-   y:Ghost.erased t_small &
-   restricted_frame_preserving_upd p_small x y)
+noeq type fpu_lift_dom (#t_small: Type) (p_small: pcm t_small) = {
+  fpu_lift_dom_x: (x:Ghost.erased t_small{~ (Ghost.reveal x == (one p_small))});
+  fpu_lift_dom_y: Ghost.erased t_small;
+  fpu_lift_dom_f: restricted_frame_preserving_upd p_small fpu_lift_dom_x fpu_lift_dom_y;
+}
 
 let fpu_lift_cod (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (conn_small_to_large: morphism p_small p_large)
 : fpu_lift_dom p_small -> Type
-= fun (|x, y, f|) ->
+= fun { fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f} ->
   fpu_t p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y)
 
 let fpu_lift (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
@@ -186,7 +187,7 @@ let fpu_lift_elim (#t_large:Type) (#t_small: Type) (#p_large: pcm t_large) (#p_s
   (y: Ghost.erased t_small)
   (f: frame_preserving_upd p_small x y)
 : Tot (frame_preserving_upd p_large (conn_small_to_large.morph x) (conn_small_to_large.morph y))
-= let phi = lift (| x, y, restricted_frame_preserving_upd_intro f |) in
+= let phi = lift ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) in
   (fun v -> phi.fpu_f v)
 
 (** A connection from a "large" PCM p_large to a "small" PCM p_small
@@ -241,7 +242,7 @@ let mkconnection1
     on_dom
       (fpu_lift_dom p_small)
       (fun (z: fpu_lift_dom p_small) ->
-        (let (|x, y, f|) = z in {
+        (let {fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; } = z in {
         fpu_f = on_dom_nondep
           (frame_preserving_upd_dom p_large (Ghost.reveal (Ghost.hide (conn_small_to_large.morph x))))
           (conn_lift_frame_preserving_upd_f x y f);
@@ -299,7 +300,7 @@ let connection_eq_gen
     (f: restricted_frame_preserving_upd q x y) ->
     (v: frame_preserving_upd_dom p (l.conn_small_to_large.morph x)) ->
     Lemma
-    ((l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f v == (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f v)
+    ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
   )
 : Lemma
   (l == m)
@@ -308,15 +309,15 @@ let connection_eq_gen
     (y: Ghost.erased b)
     (f: restricted_frame_preserving_upd q x y)
   : Lemma
-    ((l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f == (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f)
+    ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f)
   = Classical.forall_intro (phi x y f);
     extensionality_nondep
       (frame_preserving_upd_dom p (l.conn_small_to_large.morph x))
       (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (l.conn_small_to_large.morph x))))
       (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (m.conn_small_to_large.morph x))))
       a
-      (l.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f 
-      (m.conn_lift_frame_preserving_upd (| x, y, f |)).fpu_f
+      (l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f 
+      (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f
   in
   Classical.forall_intro_3 psi;
   connection_eq' l m
@@ -329,8 +330,8 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
     (fun xc yc f ->
     let xb = Ghost.hide (fbc.conn_small_to_large.morph xc) in
     let yb = Ghost.hide (fbc.conn_small_to_large.morph yc) in
-    let fb = fbc.conn_lift_frame_preserving_upd (| xc, yc, f |) in
-    mk_restricted_frame_preserving_upd (fab.conn_lift_frame_preserving_upd (| xb, yb, mk_restricted_frame_preserving_upd fb |) ))
+    let fb = fbc.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xc; fpu_lift_dom_y = yc; fpu_lift_dom_f = f }) in
+    mk_restricted_frame_preserving_upd (fab.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xb; fpu_lift_dom_y = yb; fpu_lift_dom_f = mk_restricted_frame_preserving_upd fb }) ))
 
 let connection_id
   (#a: Type)
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index e1b77213a2c..ac936171547 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -168,7 +168,7 @@ let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p
 = let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd (|x, y, restricted_frame_preserving_upd_intro f|) )))
+  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
 
 let as_action (#p:vprop)
               (#q:vprop)

From ef0c6675dec55e590a54ed90917ad480ffbe658f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 24 Sep 2021 10:28:47 -0700
Subject: [PATCH 244/513] solve `assume`s in array_conn_id

---
 ulib/experimental/Steel.C.Array.fst      | 131 ++++++++++++++++-------
 ulib/experimental/Steel.C.Connection.fst |  11 ++
 2 files changed, 103 insertions(+), 39 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index b06a5f68641..baebc9c49bb 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -359,6 +359,60 @@ let array_conn_fpu_refine
   then ()
   else assert (Ghost.reveal x `feq` one (array_pcm t z))
 
+let overwrite_array_slice
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+: Tot (array_pcm_carrier t base_len)
+=
+    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
+      if from `size_le` k && not (to `size_le` k)
+      then begin
+        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
+        v_small' (size_sub' k from sq2) <: option t
+      end
+      else v k
+    )
+
+let overwrite_array_slice_index
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+  (k: array_domain t base_len)
+: Lemma (
+    overwrite_array_slice t base_len from to sq v v_small' k == (
+    if size_v from <= size_v k && size_v k < size_v to
+    then v_small' (k `size_sub` from)
+    else v k
+  ))
+= ()
+
+let overwrite_array_slice_id
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t base_len)
+: Lemma
+  (overwrite_array_slice t base_len zero_size base_len () v v_small' == v_small')
+= array_pcm_carrier_ext t base_len
+    (overwrite_array_slice t base_len zero_size base_len () v v_small')
+    v_small'
+    (fun i -> ())
+
 let array_conn_fpu_f
   (t: Type0)
   (base_len: Ghost.erased size_t)
@@ -379,17 +433,7 @@ let array_conn_fpu_f
   array_conn_fpu_compatible t base_len from to sq x v;
   array_conn_fpu_refine t base_len from to sq x v;
   let v_small' : array_pcm_carrier t z = f v_small in
-  let v' : array_pcm_carrier t base_len =
-    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
-      if from `size_le` k && not (to `size_le` k)
-      then begin
-        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
-        v_small' (size_sub' k from sq2) <: option t
-      end
-      else v k
-    )
-  in
-  v'
+  overwrite_array_slice t base_len from to sq v v_small'
 
 #pop-options
 
@@ -416,32 +460,6 @@ let array_conn
 #push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
 #restart-solver
 
-let array_conn_id
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-: Lemma
-  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id _)
-=
-  let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
-  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
-  assert (forall x . array_small_to_large_f t base_len z base_len () x == x);
-  assert (forall x . array_large_to_small_f t base_len z base_len () x `feq` x);
-  assert (forall x . array_large_to_small_f t base_len z base_len () x == x);
-  let c = array_conn t base_len z base_len () in
-  Steel.C.Connection.connection_eq_gen
-    c
-    (Steel.C.Connection.connection_id _)
-    ()
-    (fun x y f v ->
-      assume (array_conn_fpu_f t base_len z base_len () x y f v `feq` f v);
-      assert (array_conn_fpu_f t base_len z base_len () x y f v == f v);
-      assert ((c.Steel.C.Connection.conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v == array_conn_fpu_f t base_len z base_len () x y f v);
-      assert (((Steel.C.Connection.connection_id _).conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v == f v);
-      ()
-    )
-
-#restart-solver
-
 let connection_eq_gen
   #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Connection.connection` q1)
   #b2 (#q2: pcm b2) (c2: p `Steel.C.Connection.connection` q2)
@@ -467,12 +485,47 @@ let connection_eq_gen
       v1 == v2
     )) ->
     Tot
-    (squash ((c1.conn_lift_frame_preserving_upd (| x1, y1, f1 |)).fpu_f v1 == (c2.conn_lift_frame_preserving_upd (| x2, y2, f2 |)).fpu_f v2))
+    (squash ((c1.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1 })).fpu_f v1 == (c2.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2 })).fpu_f v2))
   )
 : Lemma
   (c1 == c2)
 = Steel.C.Connection.connection_eq_gen c1 c2 () (fun x y f v -> phi x y f v x y f v ())
 
+#restart-solver
+let array_conn_id
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+: Lemma
+  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id (array_pcm t base_len))
+= let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
+  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
+  assert (forall x . array_small_to_large_f t base_len z base_len () x == x);
+  assert (forall x . array_large_to_small_f t base_len z base_len () x `feq` x);
+  assert (forall x . array_large_to_small_f t base_len z base_len () x == x);
+  let c = array_conn t base_len z base_len () in
+  connection_eq_gen
+    c
+    (Steel.C.Connection.connection_id (array_pcm t base_len))
+    ()
+    (fun x1 y1 f1 v1 x2 y2 f2 v2 sq12 ->
+      let v_small : array_pcm_carrier t base_len = array_large_to_small_f t base_len z base_len () v1 in
+      assert (v_small == v1);
+      array_conn_fpu_compatible t base_len z base_len () x1 v1;
+      array_conn_fpu_refine t base_len z base_len () x1 v1;
+      let v_small' : array_pcm_carrier t base_len = f1 v1 in
+      overwrite_array_slice_id t base_len v1 v_small';
+      let s' : array_pcm_carrier t base_len = overwrite_array_slice t base_len z base_len () v1 v_small' in
+      assert (array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1 == s');
+      assert (s' == f1 v1);
+      assert ((c.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1; })).Steel.C.Connection.fpu_f v1 == array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1);
+      Steel.C.Connection.connection_id_fpu (array_pcm t base_len) x2 y2 f2 v2;
+      assert (((Steel.C.Connection.connection_id (array_pcm t base_len)).conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2; })).Steel.C.Connection.fpu_f v2 == f2 v2);
+      ()
+    )
+
+#restart-solver
+
+
 #set-options "--print_implicits"
 #restart-solver
 
@@ -516,7 +569,7 @@ let array_conn_compose
 //    let y' : Ghost.erased (array_pcm_carrier t sz) = y in
 //    let f' : Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t sz) x' y' = f in
 //    let v' : frame_preserving_upd_dom (array_pcm t base_len) (c.Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x') = v in
-    ((cc.Steel.C.Connection.conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v == (c.Steel.C.Connection.conn_lift_frame_preserving_upd (| x, y, f |)).Steel.C.Connection.fpu_f v)))
+    ((cc.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).Steel.C.Connection.fpu_f v == (c.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).Steel.C.Connection.fpu_f v)))
   = assume False
   in
   connection_eq_gen cc c sq (fun x1 y1 f1 v1 x2 y2 f2 v2 sq' -> prf x1 y1 f1 v1)
diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index b0746087edf..b3a8557535d 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -343,6 +343,17 @@ let connection_id
     ()
     (fun _ _ f -> f)
 
+let connection_id_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a { ~ (Ghost.reveal x == one p) })
+  (y: Ghost.erased a)
+  (f: restricted_frame_preserving_upd p x y)
+  (v: frame_preserving_upd_dom p x)
+: Lemma
+  (((connection_id p).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f })).fpu_f v == f v)
+= ()
+
 let connection_compose_id_left
   (#t_large #t_small: Type) (#p_large: pcm t_large) (#p_small: pcm t_small)
   (c: connection p_large p_small)

From 9d12532d83ded21a283daf002cb1e1457ab4d1f7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Sep 2021 15:26:14 -0700
Subject: [PATCH 245/513] connection_compose_fpu

---
 ulib/experimental/Steel.C.Connection.fst | 28 +++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index b3a8557535d..ff5a5a4a9bb 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -280,11 +280,11 @@ let extensionality (a: Type) (b: (a -> Type)) (f g: restricted_t a b)
     : Lemma (ensures (feq #a #b f g <==> f == g))
 = FStar.FunctionalExtensionality.extensionality a b f g
 
-let extensionality_nondep (a0 a1 a2: Type) (b: Type)
+let extensionality_nondep (a1 a2: Type) (b: Type)
   (f: a1 ^-> b)
   (g: a2 ^-> b)
 : Lemma
-  (requires (a0 == a1 /\ a0 == a2))
+  (requires (a1 == a2))
   (ensures (feq f g <==> f == g))
 = extensionality _ _ f g
 
@@ -312,7 +312,6 @@ let connection_eq_gen
     ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f)
   = Classical.forall_intro (phi x y f);
     extensionality_nondep
-      (frame_preserving_upd_dom p (l.conn_small_to_large.morph x))
       (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (l.conn_small_to_large.morph x))))
       (frame_preserving_upd_dom p (Ghost.reveal (Ghost.hide (m.conn_small_to_large.morph x))))
       a
@@ -333,6 +332,29 @@ let connection_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (
     let fb = fbc.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xc; fpu_lift_dom_y = yc; fpu_lift_dom_f = f }) in
     mk_restricted_frame_preserving_upd (fab.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xb; fpu_lift_dom_y = yb; fpu_lift_dom_f = mk_restricted_frame_preserving_upd fb }) ))
 
+let connection_compose_fpu (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: connection pa pb) (fbc: connection pb pc)
+  (xc: Ghost.erased c { ~ (Ghost.reveal xc == one pc) })
+  (yc: Ghost.erased c)
+  (fc: restricted_frame_preserving_upd pc xc yc)
+  (fb: restricted_frame_preserving_upd pb (Ghost.hide (fbc.conn_small_to_large.morph xc)) (Ghost.hide (fbc.conn_small_to_large.morph yc)))
+: Lemma
+  (requires (
+    fb `feq` mk_restricted_frame_preserving_upd (fbc.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xc; fpu_lift_dom_y = yc; fpu_lift_dom_f = fc; }))
+  ))
+  (ensures (
+    (connection_compose fab fbc).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xc; fpu_lift_dom_y = yc; fpu_lift_dom_f = fc; }) ==
+    fab.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = Ghost.hide (fbc.conn_small_to_large.morph xc); fpu_lift_dom_y = Ghost.hide (fbc.conn_small_to_large.morph yc); fpu_lift_dom_f = fb; }))
+  )
+= let c = connection_compose fab fbc in
+  let f1 = c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = xc; fpu_lift_dom_y = yc; fpu_lift_dom_f = fc; }) in
+  let f2 = fab.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = Ghost.hide (fbc.conn_small_to_large.morph xc); fpu_lift_dom_y = Ghost.hide (fbc.conn_small_to_large.morph yc); fpu_lift_dom_f = fb; }) in
+  extensionality_nondep 
+    (frame_preserving_upd_dom pa (Ghost.hide (c.conn_small_to_large.morph xc)))
+    (frame_preserving_upd_dom pa (Ghost.hide (fab.conn_small_to_large.morph (Ghost.hide (fbc.conn_small_to_large.morph xc)))))
+    a
+    f1.fpu_f
+    f2.fpu_f
+
 let connection_id
   (#a: Type)
   (p: pcm a)

From c7904a76cac3aad6e4d48ae407f077e16f02a77f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Sep 2021 23:14:32 -0700
Subject: [PATCH 246/513] solve `assume`s in array_conn_compose

---
 ulib/experimental/Steel.C.Array.fst | 330 ++++++++++++++++++++++++++--
 1 file changed, 312 insertions(+), 18 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index baebc9c49bb..2eabcc2e596 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -228,6 +228,42 @@ let array_large_to_small_f
 : Tot (array_pcm_carrier t (to `size_sub` from))
 = on_dom (array_domain t (to `size_sub` from)) (fun k -> x (from `size_add` k))
 
+let array_large_to_small_f_eq
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+  (k: array_domain t (to `size_sub` from))
+: Lemma
+  (array_large_to_small_f t base_len from to sq x k == x (from `size_add` k))
+= ()
+
+let array_large_to_small_f_eq'
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+  (k' : array_domain t base_len)
+: Lemma
+  (requires (
+    size_v from <= size_v k' /\
+    size_v k' < size_v to
+  ))
+  (ensures (
+    array_large_to_small_f t base_len from to sq x (k' `size_sub` from) == x k'
+  ))
+= ()
+
 let array_large_to_small
   (t: Type0)
   (base_len: Ghost.erased size_t)
@@ -401,6 +437,48 @@ let overwrite_array_slice_index
   ))
 = ()
 
+let overwrite_array_slice_index_in
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+  (k: array_domain t base_len)
+: Lemma
+  (requires (
+    size_v from <= size_v k /\ size_v k < size_v to
+  ))
+  (ensures (
+    overwrite_array_slice t base_len from to sq v v_small' k == v_small' (k `size_sub` from)
+  ))
+= ()
+
+let overwrite_array_slice_index_out
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+  (k: array_domain t base_len)
+: Lemma
+  (requires (
+    ~ (size_v from <= size_v k /\ size_v k < size_v to)
+  ))
+  (ensures (
+    overwrite_array_slice t base_len from to sq v v_small' k == v k
+  ))
+= ()
+
 let overwrite_array_slice_id
   (t: Type0)
   (base_len: Ghost.erased size_t)
@@ -460,6 +538,26 @@ let array_conn
 #push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
 #restart-solver
 
+let array_conn_fpu_eq
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))  
+: Lemma
+  (let open Steel.C.Connection in
+  ((array_conn t base_len from to sq).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == array_conn_fpu_f t base_len from to sq x y f v)
+= ()
+
+#restart-solver
+
 let connection_eq_gen
   #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Connection.connection` q1)
   #b2 (#q2: pcm b2) (c2: p `Steel.C.Connection.connection` q2)
@@ -523,12 +621,191 @@ let array_conn_id
       ()
     )
 
+let ifthenelse_prf
+  (p: prop)
+  (cond: bool)
+  (iftrue: squash (cond == true) -> Lemma p)
+  (iffalse: squash (cond == false) -> Lemma p)
+: Lemma p
+= if cond
+  then iftrue ()
+  else iffalse ()
+
 #restart-solver
+let array_conn_compose_morphisms
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (h: squash (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+: Tot (squash (
+      let z = to1 `size_sub` from1 in
+      let c1 = array_conn t base_len from1 to1 () in
+      let c2 = array_conn t z from2 to2 () in
+      let cc = c1 `Steel.C.Connection.connection_compose` c2 in
+      let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
+      cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
+      cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
+  ))
+=
+  let z = to1 `size_sub` from1 in
+  let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
+  let _ : squash (sz == size_sub to2 from2) = () in
+  assert (forall x . array_small_to_large_f t base_len from1 to1 () (array_small_to_large_f t z from2 to2 ()  x) `feq` array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
+  assert (forall x . array_large_to_small_f t z from2 to2 () (array_large_to_small_f t base_len from1 to1 () x) `feq` array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x)
 
+#push-options "--print_implicits --z3rlimit 256"
+
+let size_sub_size_add_l
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+: Lemma
+  ((from1 `size_add` to2) `size_sub` (from1 `size_add` from2) == to2 `size_sub` from2)
+= ()
+
+let size_sub_size_sub
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (i: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v from1 + size_v to2 <= size_v to1 /\
+    size_v from1 + size_v from2 <= size_v i /\
+    size_v i <= size_v from1 + size_v to2
+  ))
+: Lemma
+  ((i `size_sub` from1) `size_sub` from2 == i `size_sub` (from1 `size_add` from2))
+= ()
+
+let array_large_to_small_f_compose
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+  (a: array_pcm_carrier t base_len)
+: Lemma
+  (array_large_to_small_f t (to1 `size_sub` from1) from2 to2 () (array_large_to_small_f t base_len from1 to1 () a) ==
+    array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () a)
+= assert (
+  (array_large_to_small_f t (to1 `size_sub` from1) from2 to2 () (array_large_to_small_f t base_len from1 to1 () a) `feq`
+    array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () a)
+  )
 
-#set-options "--print_implicits"
 #restart-solver
+let array_conn_compose_fpu
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)) {~ (Ghost.reveal x == one (array_pcm t (to2 `size_sub` from2)))})
+  (y: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)))
+  (f: frame_preserving_upd (array_pcm t (to2 `size_sub` from2)) x y)
+  (x2: Ghost.erased (array_pcm_carrier t (to1 `size_sub` from1)))
+  (sqx2: squash (
+    Ghost.reveal x2 == array_small_to_large_f t (to1 `size_sub` from1) from2 to2 () x /\
+    (~ (Ghost.reveal x2 == one (array_pcm t (to1 `size_sub` from1))))
+  ))
+  (y2: Ghost.erased (array_pcm_carrier t (to1 `size_sub` from1)))
+  (sqy2: squash (
+    Ghost.reveal y2 == array_small_to_large_f t (to1 `size_sub` from1) from2 to2 () y
+  ))
+  (f2: frame_preserving_upd (array_pcm t (to1 `size_sub` from1)) x2 y2)
+  (sqf2: (
+    (v: frame_preserving_upd_dom (array_pcm t (to1 `size_sub` from1)) x2) ->
+    Lemma
+    (f2 v == array_conn_fpu_f t (to1 `size_sub` from1) from2 to2 () x y f v)
+  ))
+  (x0: Ghost.erased (array_pcm_carrier t base_len))
+  (sqx0: squash (
+    Ghost.reveal x0 == array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x /\
+    Ghost.reveal x0 == array_small_to_large_f t base_len from1 to1 () x2 /\
+    (~ (Ghost.reveal x0 == one (array_pcm t base_len)))
+  ))
+  (v: frame_preserving_upd_dom (array_pcm t base_len) x0)
+: Lemma
+  (ensures (
+    array_conn_fpu_f t base_len from1 to1 () x2 y2 f2 v == array_conn_fpu_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x y f v
+  ))
+= let al : array_pcm_carrier t base_len = array_conn_fpu_f t base_len from1 to1 () x2 y2 f2 v in
+  array_conn_fpu_compatible t base_len from1 to1 () x2 v;
+  array_conn_fpu_refine t base_len from1 to1 () x2 v;
+  let sz1 = to1 `size_sub` from1 in
+  let v_l_out_small : array_pcm_carrier t sz1 = array_large_to_small_f t base_len from1 to1 () v in
+  sqf2 v_l_out_small;
+  array_conn_fpu_compatible t sz1 from2 to2 () x v_l_out_small;
+  array_conn_fpu_refine t sz1 from2 to2 () x v_l_out_small;
+  let sz2 = to2 `size_sub` from2 in
+  let v_l_in_small : array_pcm_carrier t sz2 = array_large_to_small_f t sz1 from2 to2 () v_l_out_small in
+  let v_l_in_small' : array_pcm_carrier t sz2 = f v_l_in_small in
+  let v_l_in' : array_pcm_carrier t sz1 = overwrite_array_slice t sz1 from2 to2 () v_l_out_small v_l_in_small' in
+  let v_l' : array_pcm_carrier t base_len = overwrite_array_slice t base_len from1 to1 () v v_l_in' in
+  assert (v_l' == al);
+  let from = from1 `size_add` from2 in
+  let to = from1 `size_add` to2 in
+  let _ : squash (sz2 == to `size_sub` from) = size_sub_size_add_l from1 to1 from2 to2 () in
+  let ar : array_pcm_carrier t base_len = array_conn_fpu_f t base_len from to () x y f v in
+  array_conn_fpu_compatible t base_len from to () x v;
+  array_conn_fpu_refine t base_len from to () x v;
+  let v_r_small : array_pcm_carrier t sz2 = array_large_to_small_f t base_len from to () v in
+  let _ : squash (v_r_small == v_l_in_small) = array_large_to_small_f_compose t base_len from1 to1 from2 to2 () v in
+  let v_r_small' : array_pcm_carrier t sz2 = f v_r_small in
+  assert (v_r_small' == v_l_in_small');
+  let v_r' : array_pcm_carrier t base_len = overwrite_array_slice t base_len from to () v v_r_small' in
+  assert (v_r' == ar);
+  array_pcm_carrier_ext t base_len v_l' v_r' (fun i ->
+    overwrite_array_slice_index t base_len from1 to1 () v v_l_in' i;
+    overwrite_array_slice_index t base_len from to () v v_r_small' i;
+    if size_v from1 <= size_v i && size_v i < size_v to1
+    then begin
+      let i' : array_domain t sz1 = i `size_sub` from1 in
+      let b = (size_v from2 <= size_v i' && size_v i' < size_v to2) in
+      assert ((size_v (from1 `size_add` from2) <= size_v i && size_v i < size_v (from1 `size_add` to2)) == b);
+      overwrite_array_slice_index t sz1 from2 to2 () v_l_out_small v_l_in_small' i';
+      if size_v from2 <= size_v i' && size_v i' < size_v to2
+      then begin
+        size_sub_size_sub from1 to1 from2 to2 i ()
+      end else begin
+        assert (f2 v_l_out_small i' == v_l_out_small i');
+        array_large_to_small_f_eq' t base_len from1 to1 () v i
+      end
+    end else begin
+      assert ((size_v (from1 `size_add` from2) <= size_v i && size_v i < size_v (from1 `size_add` to2)) == false)
+    end
+  )
 
+#restart-solver
 let array_conn_compose
   (t: Type0)
   (base_len: Ghost.erased size_t)
@@ -551,28 +828,45 @@ let array_conn_compose
   let z = to1 `size_sub` from1 in
   let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
   let _ : squash (sz == size_sub to2 from2) = () in
-  assert (forall x . array_small_to_large_f t base_len from1 to1 () (array_small_to_large_f t z from2 to2 ()  x) `feq` array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
-  assert (forall x . array_large_to_small_f t z from2 to2 () (array_large_to_small_f t base_len from1 to1 () x) `feq` array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
-  let cc = array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t z from2 to2 () in
+  let c1 = array_conn t base_len from1 to1 () in
+  let c2 = array_conn t z from2 to2 () in
+  let cc = c1 `Steel.C.Connection.connection_compose` c2 in
   let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
   let sq : squash (
       cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
       cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
-  ) = () in
-  let prf
-    (x: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)) { ~ (Ghost.reveal x == one (array_pcm t (to2 `size_sub` from2))) })
-    (y: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)))
-    (f: Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t (to2 `size_sub` from2)) x y)
-    (v: frame_preserving_upd_dom (array_pcm t base_len) (cc.Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x))
-  : Tot (squash (
-//    let x' : (x': Ghost.erased (array_pcm_carrier t sz) { ~ (Ghost.reveal x' == one (array_pcm t sz)) }) = x in
-//    let y' : Ghost.erased (array_pcm_carrier t sz) = y in
-//    let f' : Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t sz) x' y' = f in
-//    let v' : frame_preserving_upd_dom (array_pcm t base_len) (c.Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x') = v in
-    ((cc.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).Steel.C.Connection.fpu_f v == (c.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).Steel.C.Connection.fpu_f v)))
-  = assume False
+  ) =
+    array_conn_compose_morphisms t base_len from1 to1 from2 to2 ()
   in
-  connection_eq_gen cc c sq (fun x1 y1 f1 v1 x2 y2 f2 v2 sq' -> prf x1 y1 f1 v1)
+  Steel.C.Connection.connection_eq_gen cc c sq (fun x y f v ->
+    let open Steel.C.Connection in
+    let x' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph x in
+    let y' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph y in
+    let phi = mk_restricted_frame_preserving_upd (c2.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })) in
+    connection_compose_fpu
+      c1
+      c2
+      x y f
+      phi;
+    array_conn_fpu_eq t base_len from1 to1 () x' y' phi v;
+    array_conn_fpu_eq t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x y f v;
+    array_conn_compose_fpu
+      t base_len from1 to1 from2 to2 ()
+      x y f
+      x' () y' ()
+      phi
+      (fun v' ->
+        array_conn_fpu_eq t z from2 to2 () x y f v'
+      )
+      (cc.conn_small_to_large.morph x)
+      ()
+      v
+  )
+
+
+#pop-options
+
+#restart-solver
 
 let to_view_array_conn
   (t: Type0)

From 9e4cf34817a20af239c4fdddc1791f8c78523332 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 29 Sep 2021 18:37:12 -0700
Subject: [PATCH 247/513] ref_of_array

---
 ulib/experimental/Steel.C.Array.fst      | 161 +++++++++++++++++++++--
 ulib/experimental/Steel.C.Connection.fst |  21 +++
 2 files changed, 169 insertions(+), 13 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 2eabcc2e596..ae5528a6382 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1293,31 +1293,166 @@ let joinc
 =
   return (t_merge al ar)
 
+let array_as_one_ref_iso
+  (base: Type)
+  (t: Type)
+: Tot (Steel.C.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
+= let c1 = (Steel.C.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
+  let c2 = (Steel.C.Struct.field_to_struct (array_elements_pcm t one_size) zero_size) in
+  Steel.C.Connection.mkisomorphism
+    c1
+    c2
+    ()
+    (Steel.C.Connection.is_inverse_of_intro
+      c2.Steel.C.Connection.morph
+      c1.Steel.C.Connection.morph
+      (fun x ->
+        array_pcm_carrier_ext t one_size (c2.Steel.C.Connection.morph (c1.Steel.C.Connection.morph x)) x (fun i ->
+          ()
+        )
+      )
+    )
+    (fun x -> ())
+    (fun x -> ())
+
 let array_as_one_ref_conn
-  (#base: Type)
-  (#t: Type)
-  (a: array base t)
-: Pure (Steel.C.Connection.connection (array_pcm t a.base_len) (Steel.C.Opt.opt_pcm #t))
-  (requires (length a == 1))
+  (base: Type)
+  (t: Type)
+: Tot (Steel.C.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
+= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso base t)
+
+let g_ref_of_array
+  #base #t r
+=
+  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
+
+let array_as_one_ref_conn'
+  (#base: Type) (#t:Type0) (r:array base t)
+: Pure (Steel.C.Connection.connection (array_pcm t r.base_len) (Steel.C.Opt.opt_pcm #t))
+  (requires (length r == 1))
   (ensures (fun _ -> True))
 =
-  Steel.C.Struct.struct_field
-    (array_elements_pcm t a.base_len)
-    a.from
+  array_conn t r.base_len r.from r.to () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
 
-let g_ref_of_array
-  r
+let array_as_one_ref_conn'_small_to_large
+  (#base: Type) (#t:Type0) (r:array base t)
+  (x: option t)
+  (i: array_domain t r.base_len)
+: Lemma
+  (requires (length r == 1))
+  (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = r.from then x else None)))
+= ()
+
+let g_ref_of_array'
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (requires (length r == 1))
+  (ensures (fun _ -> True))
+= r.base_ref `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
+
+let g_ref_of_array'_correct
+  (#base: Type) (#t:Type0) (r:array base t)
+: Lemma
+  (requires (length r == 1))
+  (ensures (g_ref_of_array r == g_ref_of_array' r))
 =
-  r.base_ref `Steel.C.Ref.ref_focus` array_as_one_ref_conn r
+  Steel.C.Ref.ref_focus_comp r.base_ref (array_conn t r.base_len r.from r.to ()) (array_as_one_ref_conn base t)
+
+let get_pts_to
+  (#inames: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
+  (r: Steel.C.Ref.ref a p) (v: Ghost.erased b)
+: SteelGhost (Ghost.erased b) inames
+    (Steel.C.Ref.pts_to r v)
+    (fun _ -> Steel.C.Ref.pts_to r v)
+    (fun _ -> True)
+    (fun _ v' _ -> v' == v)
+= noop(); v
 
-let ref_of_array_ghost = admit ()
+(*
+assume
+val abstract_id
+  (#t: Type)
+  (x: t)
+: Pure t
+  (requires True)
+  (ensures (fun y -> x == y))
+*)
 
-let ref_of_array = admit ()
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false --print_implicits"
+
+#restart-solver
+let ref_of_array_ghost #inames #base #t x sq =
+  let gv = gget (varray x) in
+  elim_varray1 x;
+  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
+    #inames
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+  in
+  assert (len x == one_size);
+  let z : array_domain t one_size = zero_size in
+  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
+  Steel.C.Ref.gfocus
+    #base
+    #(array_pcm_carrier t (len x))
+    #(option t)
+    #_
+    #(array_pcm t (len x))
+    (array_as_ref x)
+    #(Steel.C.Opt.opt_pcm #t)
+    (array_as_one_ref_conn base t)
+    _
+    (Ghost.reveal v z);
+  Steel.C.Ref.pts_to_view_intro
+    _
+    _
+    (Steel.C.Opt.opt_view t)
+    (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
+  change_equal_slprop
+    (Steel.C.Ref.pts_to_view _ _)
+    (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
+
+#restart-solver
+let ref_of_array #base #t x =
+  let gv = gget (varray x) in
+  elim_varray1 x;
+  let v = Steel.C.Ref.pts_to_view_elim
+    #_
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+  in
+  Steel.C.Ref.unfocus _ x.base_ref (array_conn t x.base_len x.from x.to ()) _;
+  let s = get_pts_to x.base_ref _ in
+  let ar : Ghost.erased (array_pcm_carrier t x.base_len) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
+  array_pcm_carrier_ext t x.base_len (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
+    array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
+  );
+  g_ref_of_array'_correct x;
+  let r = Steel.C.Ref.focus x.base_ref (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
+  Steel.C.Ref.pts_to_view_intro
+    _
+    _
+    (Steel.C.Opt.opt_view t)
+    (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
+  return r
 
 let array_of_ref = admit ()
 
 let mk_array_of_ref = admit ()
 
+#pop-options
+
 let seq_equal_1
   (t: Type)
   (s1 s2: Seq.seq t)
diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index ff5a5a4a9bb..166feb819c5 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -122,6 +122,14 @@ let is_inverse_of_injective (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
   [SMTPat (g `is_inverse_of` f); SMTPat (f x1); SMTPat (f x2)]
 = assert (g (f x1) == g (f x2))
 
+let is_inverse_of_intro (#a #b: Type) (g: (b -> Tot a)) (f: (a -> Tot b))
+  (phi: (x: a) -> Lemma
+    (g (f x) == x)
+  )
+: Lemma
+  (g `is_inverse_of` f)
+= Classical.forall_intro phi
+
 #push-options "--print_universes"
 
 let restricted_frame_preserving_upd
@@ -622,6 +630,19 @@ let connection_of_isomorphism
     i.iso_1_2_inv_2_1
     (connection_of_isomorphism_fpu i)
 
+let connection_of_isomorphism_fpu_eq
+  (#t1 #t2: Type)
+  (#p1: pcm t1)
+  (#p2: pcm t2)
+  (i: isomorphism p1 p2)
+  (x: Ghost.erased t2 { ~ (Ghost.reveal x == one p2) })
+  (y: Ghost.erased t2)
+  (f: restricted_frame_preserving_upd p2 x y)
+  (v: frame_preserving_upd_dom p1 (i.iso_2_1.morph x))
+: Lemma
+  (((connection_of_isomorphism i).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == connection_of_isomorphism_fpu' i x y f v)
+= ()
+
 let connection_of_isomorphism_inverse_left
   (#t1 #t2: Type)
   (#p1: pcm t1)

From 55fe9ce06d799f21f0729bda6db2021ffb7dd6a7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 29 Sep 2021 19:25:37 -0700
Subject: [PATCH 248/513] array_of_ref

---
 ulib/experimental/Steel.C.Array.fst | 33 ++++++++++++++++++++++++++++-
 1 file changed, 32 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index ae5528a6382..02f9fc9d725 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1447,7 +1447,38 @@ let ref_of_array #base #t x =
     (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
   return r
 
-let array_of_ref = admit ()
+#restart-solver
+let array_of_ref
+  #_ #base #t r' r
+=
+  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
+  let v = Steel.C.Ref.pts_to_view_elim
+    r
+    (Steel.C.Opt.opt_view t)
+  in
+  Steel.C.Ref.unfocus
+    r
+    (array_as_ref r')
+    (array_as_one_ref_conn base t)
+    v;
+  let g' : Ghost.erased (array_view_type t (len r')) =
+    (Ghost.hide (Seq.create 1 (Ghost.reveal g)))
+  in
+  let v' : Ghost.erased (array_pcm_carrier t (len r')) =
+    get_pts_to (array_as_ref r') _
+  in
+  array_pcm_carrier_ext t (len r') ((array_view t (len r')).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
+    assert (i == zero_size)
+  );
+  Steel.C.Ref.pts_to_view_intro
+    _
+    _
+    (array_view t (len r'))
+    g';
+  change_equal_slprop
+    (Steel.C.Ref.pts_to_view (array_as_ref r') (array_view t (len r')))
+    (varray0 r');
+  intro_varray1 r'
 
 let mk_array_of_ref = admit ()
 

From 052db24e4a4f2b2d7366ded7ef7fb1108518c0b3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 29 Sep 2021 21:10:59 -0700
Subject: [PATCH 249/513] mk_array_of_ref

---
 ulib/experimental/Steel.C.Array.fst | 101 +++++++++++++++++++++++++++-
 1 file changed, 100 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 02f9fc9d725..a1128000784 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1480,7 +1480,106 @@ let array_of_ref
     (varray0 r');
   intro_varray1 r'
 
-let mk_array_of_ref = admit ()
+#restart-solver
+let one_ref_as_array_conn
+  (base: Type) (t:Type0)
+: Tot (Steel.C.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
+=
+  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
+
+let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) : GTot (array base t) =
+  {
+    base_len = one_size;
+    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
+    from = zero_size;
+    to = one_size;
+    prf = ();
+  }
+
+let mk_array_of_ref'_correct
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+: Lemma
+  (g_ref_of_array (mk_array_of_ref' r) == r)
+= array_conn_id t one_size;
+  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
+  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
+  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
+  Steel.C.Ref.ref_focus_id r
+
+let array_as_ref_mk_array_of_ref'
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+: Lemma
+  (ensures (
+    let x = mk_array_of_ref' r in
+    array_as_ref x == x.base_ref
+  ))
+= 
+  let x = mk_array_of_ref' r in
+  array_conn_id t one_size;
+  Steel.C.Ref.ref_focus_id x.base_ref
+
+let array_domain_one_size
+  (t: Type)
+  (i: array_domain t one_size)
+: Lemma
+  (i == zero_size)
+= ()
+
+#restart-solver
+let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
+  (g: Ghost.erased t)
+  (v: Ghost.erased (option t))
+  (v' : Ghost.erased (array_pcm_carrier t one_size))
+  (g' : Ghost.erased (array_view_type t one_size))
+: Lemma
+  (requires (
+    Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Ref.to_carrier (Ghost.reveal g) /\
+    Ghost.reveal v' == (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
+    Ghost.reveal g' == Seq.create 1 (Ghost.reveal g)
+  ))
+  (ensures (
+    (array_view t one_size).Steel.C.Ref.to_carrier g' == (Ghost.reveal v')
+  ))
+= array_pcm_carrier_ext t one_size ((array_view t one_size).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
+    ()
+  )
+
+#restart-solver
+let mk_array_of_ref
+  #base #t r
+=
+  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
+  let v : Ghost.erased (option t) = Steel.C.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
+  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
+  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
+    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
+  in
+  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
+  let res = {
+    base_len = one_size;
+    base_ref = r';
+    from = zero_size;
+    to = one_size;
+    prf = ()
+  }
+  in
+  assert (res == mk_array_of_ref' r);
+  mk_array_of_ref'_correct r;
+  let g' : Ghost.erased (array_view_type t one_size) =
+    Ghost.hide (Seq.create 1 (Ghost.reveal g))
+  in
+  mk_array_of_ref_view_intro base g v v' g' ;
+  Steel.C.Ref.pts_to_view_intro
+    _
+    _
+    (array_view t one_size)
+    g';
+  array_as_ref_mk_array_of_ref' r;
+  change_equal_slprop
+    (Steel.C.Ref.pts_to_view r' (array_view t one_size))
+    (varray0 res);
+  intro_varray1 res;
+  return res
 
 #pop-options
 

From aea2377b1d4516d79f0657f897a92e97a5134835 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 30 Sep 2021 10:42:09 -0700
Subject: [PATCH 250/513] frame_preserving_upd_post_intro

---
 ulib/experimental/Steel.C.PCM.fst  | 12 ++++++++----
 ulib/experimental/Steel.C.PCM.fsti | 29 +++++++++++++++++++++++++++++
 2 files changed, 37 insertions(+), 4 deletions(-)

diff --git a/ulib/experimental/Steel.C.PCM.fst b/ulib/experimental/Steel.C.PCM.fst
index a58041d0dad..a6e30da022a 100644
--- a/ulib/experimental/Steel.C.PCM.fst
+++ b/ulib/experimental/Steel.C.PCM.fst
@@ -301,14 +301,18 @@ let compatible_pcm_of_fstar_pcm p x y = ()
 let exclusive_fstar_pcm_of_pcm p x = ()
 let exclusive_pcm_of_fstar_pcm p x = ()
 
-let frame_preserving_upd_intro
+let frame_preserving_upd_post_intro
   p x y f prf1 prf2 prf3
 = fun v ->
-  let v_new = f v in
   prf1 v;
   Classical.forall_intro (Classical.move_requires (prf2 v));
-  Classical.forall_intro (Classical.move_requires (prf3 v));
-  v_new
+  Classical.forall_intro (Classical.move_requires (prf3 v))
+
+let frame_preserving_upd_intro
+  p x y f prf1 prf2 prf3
+= fun v ->
+  frame_preserving_upd_post_intro p x y f prf1 prf2 prf3 v;
+  f v
 
 let fstar_fpu_of_fpu
   (#a: Type u#a)
diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
index 6e8c5ab483c..b7116020892 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.PCM.fsti
@@ -288,6 +288,35 @@ let frame_preserving_upd_goal3_post
 = frame_preserving_upd_goal3_pre p x y f v frame /\
   op p y frame == f v
 
+val frame_preserving_upd_post_intro
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (prf1:
+    (v: frame_preserving_upd_dom p x) ->
+    Lemma
+    (frame_preserving_upd_goal1 p x y f v)
+  )
+  (prf2:
+    (v: frame_preserving_upd_dom p x) ->
+    (frame: a) ->
+    Lemma
+    (requires (frame_preserving_upd_goal2_pre p x y f v frame))
+    (ensures (frame_preserving_upd_goal2_post p x y f v frame))
+  )
+  (prf3:
+    (v: frame_preserving_upd_dom p x) ->
+    (frame: a) ->
+    Lemma
+    (requires (frame_preserving_upd_goal3_pre p x y f v frame))
+    (ensures (frame_preserving_upd_goal3_post p x y f v frame))
+  )
+  (v: frame_preserving_upd_dom p x)
+: Lemma
+  (frame_preserving_upd_post p x y v (f v))
+
 val frame_preserving_upd_intro
   (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
   (f:

From 9acfc6a15b94551be58d929587e5da9e500f02f5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 30 Sep 2021 16:43:53 -0700
Subject: [PATCH 251/513] frame_preserving_upd_intro'

---
 ulib/experimental/Steel.C.PCM.fst  | 16 ++++++++++++++++
 ulib/experimental/Steel.C.PCM.fsti | 29 +++++++++++++++++++++++++++++
 2 files changed, 45 insertions(+)

diff --git a/ulib/experimental/Steel.C.PCM.fst b/ulib/experimental/Steel.C.PCM.fst
index a6e30da022a..c7530ae4dc6 100644
--- a/ulib/experimental/Steel.C.PCM.fst
+++ b/ulib/experimental/Steel.C.PCM.fst
@@ -308,6 +308,22 @@ let frame_preserving_upd_post_intro
   Classical.forall_intro (Classical.move_requires (prf2 v));
   Classical.forall_intro (Classical.move_requires (prf3 v))
 
+let frame_preserving_upd_post_intro'
+  #a p x y f prf1 prf2 prf3 v
+=
+  frame_preserving_upd_post_intro
+    p x y f
+    (fun v ->
+      prf1 v;
+      let frame = compatible_elim p x v in
+      prf2 v frame;
+      prf3 v frame;
+      compatible_intro p y (f v) frame 
+    )
+    (fun v frame -> prf2 v frame)
+    (fun v frame -> prf3 v frame)
+    v
+
 let frame_preserving_upd_intro
   p x y f prf1 prf2 prf3
 = fun v ->
diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
index b7116020892..5947a924358 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.PCM.fsti
@@ -317,6 +317,35 @@ val frame_preserving_upd_post_intro
 : Lemma
   (frame_preserving_upd_post p x y v (f v))
 
+val frame_preserving_upd_post_intro'
+  (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
+  (f:
+    (v: frame_preserving_upd_dom p x) ->
+    Tot a
+  )
+  (prf1:
+    (v: frame_preserving_upd_dom p x) ->
+    Lemma
+    (p_refine p (f v))
+  )
+  (prf2:
+    (v: frame_preserving_upd_dom p x) ->
+    (frame: a) ->
+    Lemma
+    (requires (composable p x frame))
+    (ensures (composable p y frame))
+  )
+  (prf3:
+    (v: frame_preserving_upd_dom p x) ->
+    (frame: a) ->
+    Lemma
+    (requires (composable p x frame /\ composable p y frame /\ op p x frame == v))
+    (ensures (op p y frame == f v))
+  )
+  (v: frame_preserving_upd_dom p x)
+: Lemma
+  (frame_preserving_upd_post p x y v (f v))
+
 val frame_preserving_upd_intro
   (#a:Type u#a) (p:pcm0 a) (x y: Ghost.erased a)
   (f:

From fd0495b1a42555fb9656fc16c12953790bd7a750 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 30 Sep 2021 16:48:51 -0700
Subject: [PATCH 252/513] allow specialized proofs for
 frame_preserving_upd_post_intro*

---
 ulib/experimental/Steel.C.PCM.fst  | 28 +++++++++++++---------------
 ulib/experimental/Steel.C.PCM.fsti | 12 ++++--------
 2 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/ulib/experimental/Steel.C.PCM.fst b/ulib/experimental/Steel.C.PCM.fst
index c7530ae4dc6..7e790de0c69 100644
--- a/ulib/experimental/Steel.C.PCM.fst
+++ b/ulib/experimental/Steel.C.PCM.fst
@@ -302,32 +302,30 @@ let exclusive_fstar_pcm_of_pcm p x = ()
 let exclusive_pcm_of_fstar_pcm p x = ()
 
 let frame_preserving_upd_post_intro
-  p x y f prf1 prf2 prf3
-= fun v ->
-  prf1 v;
-  Classical.forall_intro (Classical.move_requires (prf2 v));
-  Classical.forall_intro (Classical.move_requires (prf3 v))
+  p x y f v prf1 prf2 prf3
+= prf1 ();
+  Classical.forall_intro (Classical.move_requires (prf2));
+  Classical.forall_intro (Classical.move_requires (prf3))
 
 let frame_preserving_upd_post_intro'
-  #a p x y f prf1 prf2 prf3 v
+  #a p x y f v prf1 prf2 prf3
 =
   frame_preserving_upd_post_intro
-    p x y f
-    (fun v ->
-      prf1 v;
+    p x y f v
+    (fun () ->
+      prf1 ();
       let frame = compatible_elim p x v in
-      prf2 v frame;
-      prf3 v frame;
+      prf2 frame;
+      prf3 frame;
       compatible_intro p y (f v) frame 
     )
-    (fun v frame -> prf2 v frame)
-    (fun v frame -> prf3 v frame)
-    v
+    (fun frame -> prf2 frame)
+    (fun frame -> prf3 frame)
 
 let frame_preserving_upd_intro
   p x y f prf1 prf2 prf3
 = fun v ->
-  frame_preserving_upd_post_intro p x y f prf1 prf2 prf3 v;
+  frame_preserving_upd_post_intro p x y f v (fun _ -> prf1 v) (prf2 v) (prf3 v);
   f v
 
 let fstar_fpu_of_fpu
diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.PCM.fsti
index 5947a924358..fdf8f0aa517 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.PCM.fsti
@@ -294,26 +294,24 @@ val frame_preserving_upd_post_intro
     (v: frame_preserving_upd_dom p x) ->
     Tot a
   )
+  (v: frame_preserving_upd_dom p x)
   (prf1:
-    (v: frame_preserving_upd_dom p x) ->
+    unit ->
     Lemma
     (frame_preserving_upd_goal1 p x y f v)
   )
   (prf2:
-    (v: frame_preserving_upd_dom p x) ->
     (frame: a) ->
     Lemma
     (requires (frame_preserving_upd_goal2_pre p x y f v frame))
     (ensures (frame_preserving_upd_goal2_post p x y f v frame))
   )
   (prf3:
-    (v: frame_preserving_upd_dom p x) ->
     (frame: a) ->
     Lemma
     (requires (frame_preserving_upd_goal3_pre p x y f v frame))
     (ensures (frame_preserving_upd_goal3_post p x y f v frame))
   )
-  (v: frame_preserving_upd_dom p x)
 : Lemma
   (frame_preserving_upd_post p x y v (f v))
 
@@ -323,26 +321,24 @@ val frame_preserving_upd_post_intro'
     (v: frame_preserving_upd_dom p x) ->
     Tot a
   )
+  (v: frame_preserving_upd_dom p x)
   (prf1:
-    (v: frame_preserving_upd_dom p x) ->
+    unit ->
     Lemma
     (p_refine p (f v))
   )
   (prf2:
-    (v: frame_preserving_upd_dom p x) ->
     (frame: a) ->
     Lemma
     (requires (composable p x frame))
     (ensures (composable p y frame))
   )
   (prf3:
-    (v: frame_preserving_upd_dom p x) ->
     (frame: a) ->
     Lemma
     (requires (composable p x frame /\ composable p y frame /\ op p x frame == v))
     (ensures (op p y frame == f v))
   )
-  (v: frame_preserving_upd_dom p x)
 : Lemma
   (frame_preserving_upd_post p x y v (f v))
 

From b599a45a68b93eb46b57cec559dfcc0a2e2417a4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 4 Oct 2021 15:08:45 -0700
Subject: [PATCH 253/513] Steel.C.Array.malloc

---
 ulib/experimental/Steel.C.Array.fst  | 21 +++++++++++++++++++++
 ulib/experimental/Steel.C.Array.fsti | 13 +++++++++++++
 2 files changed, 34 insertions(+)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index a1128000784..c71931a9ade 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1669,3 +1669,24 @@ let upd
   change_equal_slprop
     (varray r')
     (varray r)
+
+#restart-solver
+let array_to_carrier_refine
+  (#t: Type0)
+  (n: size_t)
+  (v: array_view_type t n)
+: Lemma
+  (requires (size_v n > 0))
+  (ensures (p_refine (array_pcm t n) (array_to_carrier t n v)))
+= FStar.Classical.exists_intro (fun (k: array_domain t n) -> True) zero_size
+
+#restart-solver
+let malloc
+  #t x n
+=
+  let v = Seq.create (size_v n) x in
+  let c = array_to_carrier t n v in
+  array_to_carrier_refine n v;
+  let r0 = Steel.C.Ref.ref_alloc (array_pcm t n) c in
+  Steel.C.Ref.pts_to_view_intro r0 c (array_view t n) v;
+  intro_varray r0 ()
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index ea4c7b704eb..7df1a566c1b 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -346,3 +346,16 @@ val upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
              (ensures fun h0 _ h1 ->
                size_v i < length r /\
                h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
+
+/// Allocates an array of size [n] where all cells have initial value [x]
+val malloc
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+: Steel (array (array_pcm_carrier t n) t)
+    emp
+    (fun r -> varray r)
+    (requires fun _ -> size_v n > 0)
+    (ensures fun _ r h' ->
+      h' (varray r) == Seq.create (size_v n) x
+    )

From 6cbcfd491c620f73662a395b968a29bcbbe7d725 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 4 Oct 2021 15:16:14 -0700
Subject: [PATCH 254/513] extract Steel.C.Array.malloc

---
 src/extraction/FStar.Extraction.Kremlin.fs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 6d9b282c8a4..fd15b1bca2d 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1022,6 +1022,7 @@ and translate_expr env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _e0; e1; e2 ])
     when (string_of_mlpath p = "FStar.Buffer.rcreate_mm" ||
+          string_of_mlpath p = "Steel.C.Array.malloc" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.mmalloc" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.mmalloc" ||
           string_of_mlpath p = "LowStar.ImmutableBuffer.imalloc") ->

From 9cc679f7d9b61c81c93e4d51dc80f66c1accd767 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 4 Oct 2021 15:16:53 -0700
Subject: [PATCH 255/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 5c2c2a9f290..0168a53d88d 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -2220,8 +2220,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            _e0::e1::e2::[])
           when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.rcreate_mm") ||
+          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "FStar.Buffer.rcreate_mm") ||
+               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___5 = "Steel.C.Array.malloc"))
+              ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
                uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
              ||

From 699cf537dd94d80430190839164478a89d6d10b5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 4 Oct 2021 19:00:34 -0700
Subject: [PATCH 256/513] Steel.C.Array: support for null pointer

---
 ulib/experimental/Steel.C.Array.fst  | 148 +++++++++++++++++++--------
 ulib/experimental/Steel.C.Array.fsti |  22 ++--
 2 files changed, 123 insertions(+), 47 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index c71931a9ade..ded52e68667 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -166,7 +166,7 @@ let array_view t n =
   array_view' t n
 
 noeq
-type array base t = {
+type array' base t = {
   base_len: Ghost.erased size_t;
   base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
   from: size_t;
@@ -178,7 +178,18 @@ type array base t = {
   );
 }
 
-let len a = a.to `size_sub` a.from
+let len' (#base: _) (#t: _) (a: array' base t) : Tot size_t =
+  a.to `size_sub` a.from
+
+let array_or_null base t = option (array' base t)
+
+let len a = match a with
+| None -> zero_size
+| Some a -> len' a
+
+let null _ _ = None
+
+let g_is_null a = None? a
 
 let rec array_is_unit_aux
   (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
@@ -894,16 +905,23 @@ let to_view_array_conn
 let array_as_ref_conn
   (#base: Type)
   (#t: Type)
-  (a: array base t)
-: Tot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len a)))
+  (a: array' base t)
+: Tot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len' a)))
 = array_conn t a.base_len a.from a.to a.prf
 
+let array_as_ref'
+  (#base: Type)
+  (#t: Type)
+  (a: array' base t)
+: GTot (Steel.C.Reference.ref base (array_view_type t (len' a)) (array_pcm t (len' a)))
+= Steel.C.Ref.ref_focus a.base_ref (array_as_ref_conn a)
+
 let array_as_ref
   (#base: Type)
   (#t: Type)
   (a: array base t)
 : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
-= Steel.C.Ref.ref_focus a.base_ref (array_as_ref_conn a)
+= array_as_ref' (Some?.v a)
 
 [@@__steel_reduce__]
 let varray0
@@ -966,13 +984,13 @@ val mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference
   (ensures (fun a -> len a == Ghost.reveal n))
 
 let mk_array #base #t #n r =
-  {
+  Some ({
     base_len = n;
     base_ref = r;
     from = mk_size_t 0ul;
     to = n;
     prf = ();
-  }
+  })
 
 let g_mk_array r = mk_array r
 
@@ -1014,6 +1032,8 @@ let elim_varray
 #pop-options
 
 let adjacent r1 r2 =
+  let Some r1 = r1 in
+  let Some r2 = r2 in
   r1.base_len == r2.base_len /\
   r1.base_ref == r2.base_ref /\
   r1.to == r2.from
@@ -1027,13 +1047,15 @@ val t_merge
   (ensures (fun r -> length r == length r1 + length r2))
 
 let t_merge r1 r2 =
-  {
+  let Some r1 = r1 in
+  let Some r2 = r2 in
+  Some ({
     base_len = r1.base_len;
     base_ref = r1.base_ref;
     from = r1.from;
     to = r2.to;
     prf = ();
-  }
+  })
 
 let merge r1 r2 = t_merge r1 r2
 
@@ -1052,19 +1074,20 @@ val tsplit
   ))
 
 let tsplit r i =
-  ({
+  let Some r = r in
+  (Some ({
     base_len = r.base_len;
     base_ref = r.base_ref;
     from = r.from;
     to = r.from `size_add` i;
     prf = ()
-  }, {
+  }), Some ({
     base_len = r.base_len;
     base_ref = r.base_ref;
     from = r.from `size_add` i;
     to = r.to;
     prf = ()
-  })
+  }))
 
 let gsplit r i = 
   let (rl, rr) = tsplit r i in
@@ -1131,8 +1154,9 @@ let array_as_ref_split_left
   (ensures (
     array_as_ref (fst (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
   ))
-= array_conn_compose t x.base_len x.from x.to zero_size i;
-  Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
+= let Some x = x in
+  array_conn_compose t x.base_len x.from x.to zero_size i;
+  Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len' x) zero_size i ())
 
 let array_as_ref_split_right
   (base: Type)
@@ -1144,8 +1168,9 @@ let array_as_ref_split_right
   (ensures (
     array_as_ref (snd (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
   ))
-= array_conn_compose t x.base_len x.from x.to i (len x);
-  Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
+= let Some x' = x in
+  array_conn_compose t x'.base_len x'.from x'.to i (len x);
+  Steel.C.Ref.ref_focus_comp x'.base_ref (array_as_ref_conn x') (array_conn t (len x) i (len x) ())
 
 val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
   : SteelGhost (array base t `gpair` array base t) opened
@@ -1162,6 +1187,10 @@ val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
             sr == Seq.slice s (size_v i) (length a)
           )
 
+#pop-options
+#push-options "--z3rlimit 64"
+
+#restart-solver
 let split'
   #j #base #t x i
 =
@@ -1327,26 +1356,26 @@ let g_ref_of_array
   array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
 
 let array_as_one_ref_conn'
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#base: Type) (#t:Type0) (r:array' base t)
 : Pure (Steel.C.Connection.connection (array_pcm t r.base_len) (Steel.C.Opt.opt_pcm #t))
-  (requires (length r == 1))
+  (requires (size_v (len' r) == 1))
   (ensures (fun _ -> True))
 =
   array_conn t r.base_len r.from r.to () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
 
 let array_as_one_ref_conn'_small_to_large
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#base: Type) (#t:Type0) (r:array' base t)
   (x: option t)
   (i: array_domain t r.base_len)
 : Lemma
-  (requires (length r == 1))
+  (requires (size_v (len' r) == 1))
   (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = r.from then x else None)))
 = ()
 
 let g_ref_of_array'
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#base: Type) (#t:Type0) (r:array' base t)
 : Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (requires (length r == 1))
+  (requires (size_v (len' r) == 1))
   (ensures (fun _ -> True))
 = r.base_ref `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
 
@@ -1354,8 +1383,9 @@ let g_ref_of_array'_correct
   (#base: Type) (#t:Type0) (r:array base t)
 : Lemma
   (requires (length r == 1))
-  (ensures (g_ref_of_array r == g_ref_of_array' r))
+  (ensures (g_ref_of_array r == g_ref_of_array' (Some?.v r)))
 =
+  let Some r = r in
   Steel.C.Ref.ref_focus_comp r.base_ref (array_conn t r.base_len r.from r.to ()) (array_as_one_ref_conn base t)
 
 let get_pts_to
@@ -1364,7 +1394,7 @@ let get_pts_to
   (r: Steel.C.Ref.ref a p) (v: Ghost.erased b)
 : SteelGhost (Ghost.erased b) inames
     (Steel.C.Ref.pts_to r v)
-    (fun _ -> Steel.C.Ref.pts_to r v)
+    (fun v' -> Steel.C.Ref.pts_to r v)
     (fun _ -> True)
     (fun _ v' _ -> v' == v)
 = noop(); v
@@ -1419,10 +1449,19 @@ let ref_of_array_ghost #inames #base #t x sq =
     (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
 
 #restart-solver
-let ref_of_array #base #t x =
-  let gv = gget (varray x) in
+val ref_of_array0 (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
+  : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+             (varray r)
+             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r'))
+             (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
+             (ensures fun h0 r' h1 -> True)
+
+#restart-solver
+let ref_of_array0 #base #t x sq v0 =
+  let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
+  assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
   elim_varray1 x;
-  let v = Steel.C.Ref.pts_to_view_elim
+  let v1 : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
     #_
     #base
     #(array_pcm_carrier t (len x))
@@ -1432,19 +1471,39 @@ let ref_of_array #base #t x =
     #(size_v (len x) = 0)
     (array_view' t (len x))
   in
-  Steel.C.Ref.unfocus _ x.base_ref (array_conn t x.base_len x.from x.to ()) _;
-  let s = get_pts_to x.base_ref _ in
-  let ar : Ghost.erased (array_pcm_carrier t x.base_len) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
-  array_pcm_carrier_ext t x.base_len (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
-    array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
+  let x' : array' base t = Some?.v x in
+  let v : Ghost.erased (array_pcm_carrier t (len' x')) = v1 in
+  change_equal_slprop
+    (Steel.C.Ref.pts_to (array_as_ref #base #t x) v1)
+    (Steel.C.Ref.pts_to (array_as_ref' #base #t x') v);
+  Steel.C.Ref.unfocus _ x'.base_ref (array_as_ref_conn x') _;
+  let s = get_pts_to x'.base_ref _ in
+  let ar : Ghost.erased (array_pcm_carrier t x'.base_len) = Ghost.hide ((array_as_one_ref_conn' x').Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
+  array_pcm_carrier_ext t x'.base_len (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
+    array_as_one_ref_conn'_small_to_large x' (Ghost.reveal v zero_size) i
   );
   g_ref_of_array'_correct x;
-  let r = Steel.C.Ref.focus x.base_ref (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
+  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus x'.base_ref (array_as_one_ref_conn' x') s (Ghost.reveal v zero_size) in
   Steel.C.Ref.pts_to_view_intro
     _
     _
     (Steel.C.Opt.opt_view t)
     (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
+  intro_vrefine
+    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+    (fun v' -> v' == Ghost.reveal v0);
+  intro_pure (g_ref_of_array #base #t x == r);
+  return r
+
+#restart-solver
+let ref_of_array #base #t x =
+  let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
+  let v0 = Ghost.hide (Seq.index (Ghost.reveal gv) 0) in
+  let r = ref_of_array0 x () v0 in
+  elim_pure (g_ref_of_array x == r);
+  elim_vrefine
+    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+    (fun v' -> v' == Ghost.reveal v0);
   return r
 
 #restart-solver
@@ -1488,19 +1547,22 @@ let one_ref_as_array_conn
   Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
 
 let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) : GTot (array base t) =
-  {
+  Some ({
     base_len = one_size;
     base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
     from = zero_size;
     to = one_size;
     prf = ();
-  }
+  })
 
+#restart-solver
 let mk_array_of_ref'_correct
   (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
 : Lemma
   (g_ref_of_array (mk_array_of_ref' r) == r)
-= array_conn_id t one_size;
+=
+  g_ref_of_array'_correct (mk_array_of_ref' r);
+  array_conn_id t one_size;
   Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
   Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
   Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
@@ -1511,12 +1573,12 @@ let array_as_ref_mk_array_of_ref'
 : Lemma
   (ensures (
     let x = mk_array_of_ref' r in
-    array_as_ref x == x.base_ref
+    array_as_ref x == (Some?.v x).base_ref
   ))
 = 
   let x = mk_array_of_ref' r in
   array_conn_id t one_size;
-  Steel.C.Ref.ref_focus_id x.base_ref
+  Steel.C.Ref.ref_focus_id (Some?.v x).base_ref
 
 let array_domain_one_size
   (t: Type)
@@ -1555,13 +1617,13 @@ let mk_array_of_ref
     Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
   in
   let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
-  let res = {
+  let res = Some ({
     base_len = one_size;
     base_ref = r';
     from = zero_size;
     to = one_size;
     prf = ()
-  }
+  })
   in
   assert (res == mk_array_of_ref' r);
   mk_array_of_ref'_correct r;
@@ -1689,4 +1751,8 @@ let malloc
   array_to_carrier_refine n v;
   let r0 = Steel.C.Ref.ref_alloc (array_pcm t n) c in
   Steel.C.Ref.pts_to_view_intro r0 c (array_view t n) v;
-  intro_varray r0 ()
+  let r = intro_varray r0 () in
+  change_equal_slprop
+    (varray r)
+    (varray_or_null r);
+  return r
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 7df1a566c1b..b3498d82568 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -55,12 +55,18 @@ val array_view (t: Type u#0) (n: size_t)
 
 /// Abstract datatype for a Steel array of type [t]
 /// Should extract to t*
-val array (base: Type u#0) (t:Type u#0) : Type u#0
+val array_or_null (base: Type u#0) (t: Type u#0) : Type u#0
 
 /// Returns the length of the array. Usable for specification and proof purposes,
 /// as modeled by the GTot effect
-val len (#base: Type) (#t: Type) (a: array base t) : GTot size_t
-let length (#base: Type) (#t: Type) (a: array base t) : GTot nat = size_v (len a)
+val len (#base: Type) (#t: Type) (a: array_or_null base t) : GTot size_t
+let length (#base: Type) (#t: Type) (a: array_or_null base t) : GTot nat = size_v (len a)
+
+val null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
+val g_is_null (#base: Type) (#t: Type) (a: array_or_null base t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null base t))
+inline_for_extraction
+noextract
+let array (base: Type u#0) (t:Type u#0) : Type u#0 = (a: array_or_null base t { g_is_null a == false })
 
 // TODO 
 val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
@@ -347,15 +353,19 @@ val upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
                size_v i < length r /\
                h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
 
+
+let varray_or_null (#base: Type0) (#t: Type0) (x: array_or_null base t) : Tot vprop =
+  if g_is_null x then emp else varray x
+
 /// Allocates an array of size [n] where all cells have initial value [x]
 val malloc
   (#t: Type0)
   (x: t)
   (n: size_t)
-: Steel (array (array_pcm_carrier t n) t)
+: Steel (array_or_null (array_pcm_carrier t n) t)
     emp
-    (fun r -> varray r)
+    (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
     (ensures fun _ r h' ->
-      h' (varray r) == Seq.create (size_v n) x
+      g_is_null r == false ==> h' (varray r) == Seq.create (size_v n) x
     )

From 86de8d7fde0a6955f5fec29555d1178f0c8922de Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 4 Oct 2021 19:40:08 -0700
Subject: [PATCH 257/513] extract Steel.C.Array.array_or_null

---
 src/extraction/FStar.Extraction.Kremlin.fs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index fd15b1bca2d..00808cedfda 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -772,7 +772,7 @@ and translate_type_without_decay env t: typ =
         (UInt32, string_of_int (must (int_of_typenat n))))
   
   | MLTY_Named ([_; arg], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Array.array"
+    Syntax.string_of_mlpath p = "Steel.C.Array.array_or_null"
     ->
       TBuf (translate_type_without_decay env arg)
   

From 824da1f605a720deeb5d114f029880bc3f40c16b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 4 Oct 2021 19:41:54 -0700
Subject: [PATCH 258/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 0168a53d88d..06b0073e548 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -1538,7 +1538,7 @@ and (translate_type_without_decay :
           TArray uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.array" ->
+          uu___1 = "Steel.C.Array.array_or_null" ->
           let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when

From ca3fa8b353a00ecbff7e4f25533b97486b703da6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 5 Oct 2021 11:44:08 -0700
Subject: [PATCH 259/513] (TEMPORARY, PLEASE REVERT) use FStarLang/kremlin#213

---
 .docker/build/config.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.docker/build/config.json b/.docker/build/config.json
index fa0c9e999be..b49d5da4f8a 100644
--- a/.docker/build/config.json
+++ b/.docker/build/config.json
@@ -31,7 +31,7 @@
 
     "RepoVersions" : {
         "hacl_version" : "origin/master",
-        "kremlin_version" : "origin/master",
+        "kremlin_version" : "origin/protz_eaddrof",
         "qd_version" : "origin/master",
         "mitls_version" : "origin/master"
     }

From 0972777cb39aeef6a46062140625c7a59ed07de9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 5 Oct 2021 12:28:15 -0700
Subject: [PATCH 260/513] enable Steel.C verification and extraction tests

---
 examples/steel/Makefile                |  7 +++--
 examples/steel/arraystructs/.gitignore |  4 +++
 examples/steel/arraystructs/Makefile   | 42 +++++++++++++++++++++++---
 3 files changed, 47 insertions(+), 6 deletions(-)
 create mode 100644 examples/steel/arraystructs/.gitignore

diff --git a/examples/steel/Makefile b/examples/steel/Makefile
index ed6463be4a2..d0e6a9eea73 100644
--- a/examples/steel/Makefile
+++ b/examples/steel/Makefile
@@ -2,7 +2,10 @@ EXCLUDED_FSTAR_FILES=ParDivWP.fst Semantics.WP.fst $(wildcard DList*)
 OTHERFLAGS+=--already_cached 'Prims FStar LowStar Steel NMST MST NMSTTotal MSTTotal'
 FSTAR_FILES = DList1.fst $(filter-out $(EXCLUDED_FSTAR_FILES), $(wildcard *.fst))
 
-all: verify-all counter
+all: verify-all counter arraystructs
+
+arraystructs:
+	+$(MAKE) -C $@
 
 $(CACHE_DIR):
 	mkdir -p $@
@@ -25,4 +28,4 @@ counter:
 
 endif
 
-.PHONY: all verify-all counter
+.PHONY: all verify-all counter arraystructs
diff --git a/examples/steel/arraystructs/.gitignore b/examples/steel/arraystructs/.gitignore
new file mode 100644
index 00000000000..52875a24175
--- /dev/null
+++ b/examples/steel/arraystructs/.gitignore
@@ -0,0 +1,4 @@
+*.h
+*.c
+*.krml
+extract
diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 563b147708e..fcdaed73194 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -3,12 +3,17 @@ all: world
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
 FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
 
-INCLUDE_PATH = $(FSTAR_HOME)/ulib/experimental
+INCLUDE_PATH = $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental
 
-world: verify
+ifdef KREMLIN_HOME
+KRML_EXE = $(KREMLIN_HOME)/krml
+endif
+
+world: verify test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \
+	        --already_cached 'Prims,FStar,Steel' \
 		$(addprefix --include ,$(INCLUDE_PATH)) \
 		$(OTHERFLAGS)
 
@@ -39,12 +44,41 @@ verify: $(ALL_CHECKED_FILES)
 	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen OCaml \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
+clean:
+	-rm -rf *.checked *.krml .depend kremlin.rsp .depend.tmp *.c *.h *.o compile_flags.txt extract
+
+ifdef KREMLIN_HOME
+
 .PRECIOUS: %.krml
 %.krml:
 	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen Kremlin \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
-clean:
-	-rm -rf *.checked *.krml .depend kremlin.rsp *.tmp *.o compile_flags.txt
+ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
+FILTERED_KRML_FILES=$(filter-out FStar_NMST.krml Steel_%.krml,$(ALL_KRML_FILES))
+
+extract: $(FILTERED_KRML_FILES)
+	$(KRML_EXE) -skip-compilation -skip-makefiles -bundle 'FStar.\*,Steel.\*' $^
+	touch $@
+
+ALL_C_FILES=$(addsuffix .c,$(ALL_MODULE_NAMES))
+
+$(ALL_C_FILES): %.c: extract
+	test -f $@
+	touch $@
+
+ALL_O_FILES=$(subst .c,.o,$(ALL_C_FILES))
+
+$(ALL_O_FILES): %.o: %.c
+	$(CC) $(CFLAGS) -DKRML_VERIFIED_UINT128 -I $(KREMLIN_HOME)/include -I $(KREMLIN_HOME)/kremlib/dist/minimal -o $@ -c $<
+
+test: $(ALL_O_FILES)
+
+else # no KREMLIN_HOME
+
+test:
+	echo KReMLin is not installed, skipping test
+
+endif # KREMLIN_HOME
 
 .PHONY: all world verify clean depend test

From c361fe9b81760b0da8356d82bcfb00faade404b6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 5 Oct 2021 14:24:53 -0700
Subject: [PATCH 261/513] Revert "(TEMPORARY, PLEASE REVERT) use
 FStarLang/kremlin#213"

CI works well with that PR, and @msprotz greenlit me,
so I just merged it.

This reverts commit ca3fa8b353a00ecbff7e4f25533b97486b703da6.
---
 .docker/build/config.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.docker/build/config.json b/.docker/build/config.json
index b49d5da4f8a..fa0c9e999be 100644
--- a/.docker/build/config.json
+++ b/.docker/build/config.json
@@ -31,7 +31,7 @@
 
     "RepoVersions" : {
         "hacl_version" : "origin/master",
-        "kremlin_version" : "origin/protz_eaddrof",
+        "kremlin_version" : "origin/master",
         "qd_version" : "origin/master",
         "mitls_version" : "origin/master"
     }

From 40d7f84bd5948c99a0699ebfa8749ff733b0e3d5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 5 Oct 2021 19:07:36 -0700
Subject: [PATCH 262/513] ref_free, Steel.C.Array.free

---
 ulib/experimental/Steel.C.Array.fst  | 32 ++++++++++++++++++++++++++++
 ulib/experimental/Steel.C.Array.fsti | 19 ++++++++++++++++-
 ulib/experimental/Steel.C.Ref.fst    | 11 ++++++++++
 ulib/experimental/Steel.C.Ref.fsti   | 14 ++++++++++++
 4 files changed, 75 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index ded52e68667..75a1392c335 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1732,6 +1732,16 @@ let upd
     (varray r')
     (varray r)
 
+#restart-solver
+let freeable
+  #base #t a
+=
+  let Some a' = a in
+  Steel.C.Ref.freeable a'.base_ref /\
+  size_v a'.base_len > 0 /\
+  a'.from == zero_size /\
+  a'.to == Ghost.reveal a'.base_len
+
 #restart-solver
 let array_to_carrier_refine
   (#t: Type0)
@@ -1756,3 +1766,25 @@ let malloc
     (varray r)
     (varray_or_null r);
   return r
+
+#restart-solver
+#push-options "--print_implicits"
+let free
+  #base #t a
+=
+  let r = (Some?.v a).base_ref in
+  elim_varray r a ();
+  let v = Steel.C.Ref.pts_to_view_elim
+    #_
+    #_
+    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
+    #(array_pcm t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
+    r
+    (array_view t (Some?.v a).base_len)
+  in
+  Steel.C.Ref.ref_free
+    #_
+    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
+    #(array_pcm t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
+    #v
+    r
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index b3498d82568..8ec539afa04 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -358,6 +358,13 @@ let varray_or_null (#base: Type0) (#t: Type0) (x: array_or_null base t) : Tot vp
   if g_is_null x then emp else varray x
 
 /// Allocates an array of size [n] where all cells have initial value [x]
+
+val freeable
+  (#base: Type0)
+  (#t: Type0)
+  (a: array base t)
+: Tot prop
+
 val malloc
   (#t: Type0)
   (x: t)
@@ -367,5 +374,15 @@ val malloc
     (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
     (ensures fun _ r h' ->
-      g_is_null r == false ==> h' (varray r) == Seq.create (size_v n) x
+      g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x)
     )
+
+val free
+  (#base: Type0)
+  (#t: Type0)
+  (a: array base t)
+: Steel unit
+    (varray a)
+    (fun _ -> emp)
+    (requires (fun _ -> freeable a))
+    (ensures (fun _ _ _ -> True))
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index ac936171547..76c5b71004b 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -64,6 +64,13 @@ let mk_id_ref
   let r : ref' a a = { p = p; q = p; pl = connection_id p; r = r0 } in
   r
 
+(* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
+
+let freeable #a #b #p r =
+  a == b /\
+  r.p == p /\
+  r.pl == connection_id p
+
 #push-options "--z3rlimit 16"
 
 let ref_alloc #a p x =
@@ -77,6 +84,10 @@ let ref_alloc #a p x =
   A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
   A.return r
 
+let ref_free #a #b #p #x r =
+  // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.PCM
+  Steel.Effect.Atomic.drop (r.r `mpts_to` _)
+
 #pop-options
 
 let gfocus r l s x =
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 1cf519f2eca..dae9cb7a381 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -46,6 +46,10 @@ val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
 
 module A = Steel.Effect.Atomic
 
+val freeable
+  (#a #b:Type0) (#p: pcm b) (r: ref a p)
+: Tot prop
+
 (** Allocate a reference containing value x. *)
 val ref_alloc
   (#a:Type0) (p: pcm a) (x: a)
@@ -53,8 +57,18 @@ val ref_alloc
     emp
     (fun r -> r `pts_to` x)
     (requires fun _ -> p_refine p x)
+    (ensures fun _ r _ -> freeable r)
+
+(** Free a "base" (freeable) reference containing a "whole" (p_refine) value x. *)
+val ref_free
+  (#a #b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+: Steel unit
+    (r `pts_to` x)
+    (fun _ -> emp)
+    (requires fun _ -> p_refine p x /\ freeable r)
     (ensures fun _ _ _ -> True)
 
+
 (** Take a pointer to a "substructure" of a reference. *)
 val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)

From 26df403f508b399f0ae609cab8a7df27267bfaab Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 5 Oct 2021 19:09:31 -0700
Subject: [PATCH 263/513] extract Steel.C.Array.free

---
 src/extraction/FStar.Extraction.Kremlin.fs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 00808cedfda..ab361a0dc6c 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1045,6 +1045,7 @@ and translate_expr env e: expr =
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ])
     when (string_of_mlpath p = "FStar.Buffer.rfree" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.free" ||
+          string_of_mlpath p = "Steel.C.Array.free" ||
           string_of_mlpath p = "Steel.Array.free") ->
       EBufFree (translate_expr env e2)
 

From d037d58cf472a71dd781aa2f3938a8b618bf0819 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 5 Oct 2021 19:10:21 -0700
Subject: [PATCH 264/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 06b0073e548..1c60bc454f0 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -2313,10 +2313,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.Buffer.rfree") ||
+              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___5 = "LowStar.Monotonic.Buffer.free"))
+             ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.free"))
+              uu___5 = "Steel.C.Array.free"))
             ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "Steel.Array.free")

From 0609e338c073a3fa5cd62966633d41088db84cbe Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 15:08:12 -0700
Subject: [PATCH 265/513] remove spurious dependence on Steel.C.Ptr

---
 ulib/experimental/Steel.C.Array.fst        | 2 +-
 ulib/experimental/Steel.C.Struct.fst       | 2 +-
 ulib/experimental/Steel.C.UnionLiteral.fst | 3 ++-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 75a1392c335..a6cb02177a1 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1188,7 +1188,7 @@ val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
           )
 
 #pop-options
-#push-options "--z3rlimit 64"
+#push-options "--z3rlimit 128"
 
 #restart-solver
 let split'
diff --git a/ulib/experimental/Steel.C.Struct.fst b/ulib/experimental/Steel.C.Struct.fst
index e6797d61299..ff47a9bcfd1 100644
--- a/ulib/experimental/Steel.C.Struct.fst
+++ b/ulib/experimental/Steel.C.Struct.fst
@@ -4,7 +4,7 @@ module P = FStar.PCM
 open Steel.C.PCM
 open Steel.C.Connection
 open Steel.C.Ref
-module Ptr = Steel.C.Ptr
+// module Ptr = Steel.C.Ptr
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
index 554b18fe58f..ff768227ce9 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fst
+++ b/ulib/experimental/Steel.C.UnionLiteral.fst
@@ -208,7 +208,7 @@ let unaddr_of_union_field #a #tag #fields field p q =
   unaddr_of_union_field' #a #tag #fields field p q
 
 #restart-solver
-
+#push-options "--z3rlimit 64"
 let exclusive_refine_union_field
   (tag: Type0) (fields: c_fields)
   (old_field new_field: field_of fields)
@@ -236,6 +236,7 @@ let exclusive_refine_union_field
     assert (frame `feq` one (union_pcm tag fields))
   in
   FStar.Classical.(forall_intro (move_requires aux))
+#pop-options
 
 let switch_union_field''
   (#tag: Type0) (#fields: c_fields)

From 040440618d006d95774effa815760a2a173eca49 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 15:48:59 -0700
Subject: [PATCH 266/513] instead of a separate Steel.C.Ptr.ptr, make Ref.ref a
 refinement of Ref.ptr

---
 ulib/experimental/Steel.C.Ptr.fst  | 256 -----------------------------
 ulib/experimental/Steel.C.Ptr.fsti | 132 ---------------
 ulib/experimental/Steel.C.Ref.fst  |  62 ++++---
 ulib/experimental/Steel.C.Ref.fsti |  11 +-
 4 files changed, 44 insertions(+), 417 deletions(-)
 delete mode 100644 ulib/experimental/Steel.C.Ptr.fst
 delete mode 100644 ulib/experimental/Steel.C.Ptr.fsti

diff --git a/ulib/experimental/Steel.C.Ptr.fst b/ulib/experimental/Steel.C.Ptr.fst
deleted file mode 100644
index 22fb302edd9..00000000000
--- a/ulib/experimental/Steel.C.Ptr.fst
+++ /dev/null
@@ -1,256 +0,0 @@
-module Steel.C.Ptr
-
-module P = FStar.PCM
-module R = Steel.C.Ref
-open Steel.Memory
-open Steel.Effect.Atomic
-open Steel.Effect
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Ref
-open Steel.Effect
-
-let vpure_sel'
-  (p: prop)
-: Tot (selector' (squash p) (Steel.Memory.pure p))
-= fun (m: Steel.Memory.hmem (Steel.Memory.pure p)) -> pure_interp p m
-
-let vpure_sel
-  (p: prop)
-: Tot (selector (squash p) (Steel.Memory.pure p))
-= vpure_sel' p
-
-[@@ __steel_reduce__]
-let vpure'
-  (p: prop)
-: GTot vprop'
-= {
-  hp = Steel.Memory.pure p;
-  t = squash p;
-  sel = vpure_sel p;
-}
-
-[@@ __steel_reduce__]
-let vpure (p: prop) : Tot vprop = VUnit (vpure' p)
-
-let intro_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    emp
-    (fun _ -> vpure p)
-    (fun _ -> p)
-    (fun _ _ h' -> p)
-=
-  change_slprop_rel
-    emp
-    (vpure p)
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m)
-
-let elim_vpure
-  (#opened: _)
-  (p: prop)
-: SteelGhost unit opened
-    (vpure p)
-    (fun _ -> emp)
-    (fun _ -> True)
-    (fun _ _ _ -> p)
-=
-  change_slprop_rel
-    (vpure p)
-    emp
-    (fun _ _ -> p)
-    (fun m -> pure_interp p m; reveal_emp (); intro_emp m)
-
-// ----------------------------------------
-
-let ptr a b = option (ref' a b)
-
-let nonnull (p: ptr 'a 'b) (pb: pcm 'b): prop = Some? p /\ pcm_of_ref' (Some?.v p) == pb
-
-let pts_to_dep (p: ptr 'a 'b) (pb: pcm 'b) (v: 'b) (prf: squash (nonnull p pb))
-= let r: ref 'a pb = Some?.v p in r `pts_to` v
-
-let pts_to' (p: ptr 'a 'b) (pb: pcm 'b) (v: 'b): vprop = vpure (nonnull p pb) `vdep` pts_to_dep p pb v
-let pts_to p pb v = pts_to' p pb v
-
-let pts_to_or_null' (p: ptr 'a 'b) (pb: pcm 'b) (v: option 'b): vprop =
-  vpure (v == None <==> p == None) `star`
-  (match v with
-   | None -> vpure True
-   | Some v -> pts_to' p pb v)
-
-let pts_to_or_null p pb v = pts_to_or_null' p pb v
-
-let nullptr #a #b = None
-
-let vptr r = Some r
-
-let nullptr_vptr_disjoint r = ()
-
-let vptr_injective r r' = ()
-
-let pts_to_nonnull #opened #a #b #pb #v p =
-  let _ = gget (pts_to p pb v) in ()
-
-let intro_pts_to #a #b #pb #v r =
-  let p = Some r in
-  intro_vpure (nonnull p pb);
-  intro_vdep (vpure (nonnull p pb)) (r `R.pts_to` v) (pts_to_dep p pb v);
-  change_equal_slprop (_ `vdep` _) (pts_to p pb v);
-  return p
-
-let elim_pts_to #a #b #pb #v p =
-  change_equal_slprop (pts_to p pb v) (vpure (nonnull p pb) `vdep` pts_to_dep p pb v);
-  let prf = elim_vdep _ _ in
-  elim_vpure _;
-  change_equal_slprop (pts_to_dep p pb v prf) _;
-  return (Some?.v p)
-
-#push-options "--print_implicits"
-
-let unfold_pts_to_or_null #a #b (pb: pcm b) (p: ptr a b) (v: option b)
-: Lemma
-    (pts_to_or_null #a #b p pb v  ==
-     (vpure (v == None <==> p == None) `star`
-     (match v with
-      | None -> vpure True
-      | Some v -> pts_to p pb v)))
-= ()
-
-let intro_pts_to_or_null_nullptr #a #b pb =
-  intro_vpure (None #b == None <==> nullptr #a #b == None);
-  intro_vpure True;
-  unfold_pts_to_or_null #a #b pb (nullptr #a #b) None; 
-  change_equal_slprop _ (pts_to_or_null (nullptr #a #b) pb (None #b))
-
-let intro_pts_to_or_null #a #b #_ #pb #v p =
-  let prf_p_nonnull = gget (pts_to p pb (Ghost.reveal v)) in
-  intro_vpure (Some (Ghost.reveal v) == None <==> p == None);
-  unfold_pts_to_or_null pb p (Some (Ghost.reveal v));
-  change_equal_slprop
-    (vpure (Some (Ghost.reveal v) == None <==> p == None) `star` pts_to' p pb (Ghost.reveal v))
-    (pts_to_or_null p pb (Some (Ghost.reveal v)))
-  
-val unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
-: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
-
-let unreachable (#opened:inames) (#p:vprop) (#q:'a -> vprop) (r:'a -> prop)
-: SteelGhostF 'a opened p q (requires fun _ -> False) (ensures fun _ x _ -> r x)
-= let x: 'a = FStar.IndefiniteDescription.indefinite_description_tot 'a (fun _ -> True) in
-  change_slprop_rel p (q x) (fun _ _ -> r x) (fun _ -> ());
-  x
-
-let elim_pts_to_or_null_nullptr #a #b #_ #pb #v p =
-  let prf: Ghost.erased (
-    squash (Ghost.reveal v == None <==> p == None) *
-    squash True) = gget (pts_to_or_null p pb v) in
-  assert (Ghost.reveal v == None);
-  unfold_pts_to_or_null pb p (Ghost.reveal v);
-  change_equal_slprop (pts_to_or_null p pb v) 
-    (vpure (Ghost.reveal v == None #b <==> p == None #(ref' a b)) `star` vpure True);
-  elim_vpure True; elim_vpure _
-
-let elim_pts_to_or_null_nonnull_witness (#opened:inames)
-  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
-: SteelGhost (Ghost.erased 'b) opened
-    (pts_to_or_null p pb v)
-    (fun w -> pts_to_or_null p pb (Some (Ghost.reveal w)))
-    (requires fun _ -> p =!= nullptr)
-    (ensures fun _ w _ -> Ghost.reveal v == Some (Ghost.reveal w))
-= match Ghost.reveal v with
-  | None -> 
-    let prf = gget (pts_to_or_null p pb v) in
-    let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
-    assert (p == nullptr);
-    unreachable (fun w -> Ghost.reveal v == Some (Ghost.reveal w))
-  | Some w ->
-    let prf = gget (pts_to_or_null p pb v) in
-    let _: squash (Ghost.reveal v == None <==> p == None) = fst prf in
-    assert (p =!= nullptr);
-    change_equal_slprop (pts_to_or_null p pb v) (pts_to_or_null p pb (Some w));
-    w
-
-#set-options "--ide_id_info_off"
-
-let elim_pts_to_or_null #a #b #_ #pb #v p =
-  let w: Ghost.erased _ = elim_pts_to_or_null_nonnull_witness p in
-  unfold_pts_to_or_null pb p (Some (Ghost.reveal w));
-  change_equal_slprop (pts_to_or_null p pb (Some (Ghost.reveal w)))
-    (vpure (Ghost.reveal (Ghost.hide (Some (Ghost.reveal w))) == None <==> p == None) `star`
-     pts_to' p pb (Ghost.reveal w));
-  elim_vpure (Ghost.reveal (Ghost.hide (Some (Ghost.reveal w))) == None <==> p == None);
-  w
-  
-let is_null #a #b #pb #v p = return (None? p)
-
-open Steel.C.Connection
-
-let ptr_focused
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r': ptr a c) (r: ptr a b) (#q: pcm c) (l: connection p q)
-: prop
-= exists (ref_r:ref a p). r == vptr ref_r /\ r' == vptr (ref_focus ref_r l)
-
-let focus #a #b #p r #q l s x =
-  let ref_r = elim_pts_to r in
-  assert (r == vptr ref_r);
-  let ref_r_focused = Steel.C.Ref.focus ref_r l s x in
-  let r' = intro_pts_to ref_r_focused in
-  assert (r' == vptr (ref_focus ref_r l));
-  return r'
-  
-val elim_pts_to_ghost (#opened:inames)
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: SteelGhost (ref 'a pb) opened
-    (pts_to p pb v)
-    (fun r -> r `R.pts_to` v)
-    (requires fun _ -> True)
-    (ensures fun _ r _ -> p == vptr r)
-let elim_pts_to_ghost #a #b #_ #pb #v p =
-  change_equal_slprop (pts_to p pb v) (vpure (nonnull p pb) `vdep` pts_to_dep p pb v);
-  let prf = elim_vdep _ _ in
-  elim_vpure _;
-  let r: ref a pb = Some?.v p in
-  change_equal_slprop (pts_to_dep p pb v prf) _;
-  r
-  
-val intro_pts_to_ghost (#opened:inames)
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
-: SteelGhost (ptr 'a 'b) opened
-    (r `R.pts_to` v)
-    (fun p -> pts_to p pb v)
-    (requires fun _ -> True)
-    (ensures fun _ p _ -> p == vptr r)
-let intro_pts_to_ghost #a #b #opened #pb #v r =
-  let p = Some r in
-  intro_vpure (nonnull p pb);
-  intro_vdep (vpure (nonnull p pb)) (r `R.pts_to` v) (pts_to_dep p pb v);
-  change_equal_slprop (_ `vdep` _) (pts_to p pb v);
-  p
-    
-let unfocus #a #b #c #opened #p #q r r' l x =
-  let ref_r' =
-    FStar.IndefiniteDescription.indefinite_description_ghost
-      (ref a p)
-      (fun ref_r -> r' == vptr ref_r /\ r == vptr (ref_focus ref_r l))
-  in
-  let ref_r = elim_pts_to_ghost r in
-  unfocus ref_r ref_r' l x;
-  let r'' = intro_pts_to_ghost ref_r' in
-  change_equal_slprop (pts_to r'' p _) (pts_to r' p _)
-
-let ptr_opt_write #a #b #x p y =
-  change_equal_slprop (pts_to p opt_pcm (Some #b (Ghost.reveal x)))
-    (pts_to p opt_pcm (Ghost.reveal (Ghost.hide (Some #b (Ghost.reveal x)))));
-  let r = elim_pts_to #a #_ #opt_pcm p in
-  change_equal_slprop
-    (r `R.pts_to` Ghost.reveal (Ghost.hide (Some #b (Ghost.reveal x))))
-    (r `R.pts_to` Some (Ghost.reveal x));
-  r `opt_write` y;
-  change_equal_slprop (Steel.C.Ref.pts_to r _)
-    (Steel.C.Ref.pts_to r (Ghost.reveal (Ghost.hide (Some y))));
-  let p' = intro_pts_to r in
-  change_equal_slprop (pts_to p' opt_pcm _) (pts_to p opt_pcm _);
-  return ()
diff --git a/ulib/experimental/Steel.C.Ptr.fsti b/ulib/experimental/Steel.C.Ptr.fsti
deleted file mode 100644
index d6a60fe07ac..00000000000
--- a/ulib/experimental/Steel.C.Ptr.fsti
+++ /dev/null
@@ -1,132 +0,0 @@
-module Steel.C.Ptr
-
-module P = FStar.PCM
-module R = Steel.C.Ref
-open Steel.Memory
-open Steel.Effect.Atomic
-open Steel.Effect
-open Steel.C.PCM
-open Steel.C.Opt
-open Steel.C.Ref
-open Steel.C.Connection
-open Steel.Effect
-
-(** The type of nullable pointers to values of type b inside "base objects" of type a. *)
-val ptr (a: Type u#0) (b: Type u#b) : Type u#b
-
-(** [pts_to p pb v] if p is non-null, has PCM pb, and points to v *)
-val pts_to (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: 'b): vprop
-
-(** [pts_to_or_null p pb v] if p is null or points to v *)
-val pts_to_or_null (p: ptr 'a 'b) (pb: pcm 'b) ([@@@smt_fallback] v: option 'b): vprop
-
-(** The null pointer. *)
-val nullptr (#a:Type) (#b:Type) : ptr a b
-
-(** A non-null pointer that corresponds to underlying reference r. *)
-val vptr (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb) : ptr a b
-
-val nullptr_vptr_disjoint (#a:Type) (#b:Type) (#pb: pcm b) (r: ref a pb)
-: Lemma (nullptr =!= vptr r) [SMTPat (vptr r)]
-
-val vptr_injective (#a:Type) (#b:Type) (#pb: pcm b) (r r': ref a pb)
-: Lemma (requires vptr r == vptr r') (ensures r == r') [SMTPat (vptr r); SMTPat (vptr r')]
-
-(** If [pts_to p pb v] then p is non-null. *)
-val pts_to_nonnull (#opened:inames) (#a:Type) (#b:Type) (#pb: pcm b)
-  (#v: Ghost.erased b)
-  (p: ptr a b)
-: SteelGhost unit opened
-    (pts_to p pb v)
-    (fun _ -> pts_to p pb v)
-    (requires fun _ -> True)
-    (ensures fun _ _ _ -> p =!= nullptr)
-
-(** Introduction and elimination rules for pts_to *)
-
-val intro_pts_to
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (r: ref 'a pb)
-: Steel (ptr 'a 'b)
-    (r `R.pts_to` v)
-    (fun p -> pts_to p pb v)
-    (requires fun _ -> True)
-    (ensures fun _ p _ -> p == vptr r)
-
-val elim_pts_to
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: Steel (ref 'a pb)
-    (pts_to p pb v)
-    (fun r -> r `R.pts_to` v)
-    (requires fun _ -> True)
-    (ensures fun _ r _ -> p == vptr r)
-
-(** Introduction and elimination rules for pts_to_or_null *)
-
-val intro_pts_to_or_null_nullptr (#a:Type) (#b:Type) (#opened:inames)
-  (pb: pcm b)
-: SteelGhostT unit opened emp (fun _ -> pts_to_or_null (nullptr #a) pb None)
-
-val intro_pts_to_or_null (#opened:inames)
-  (#pb: pcm 'b) (#v: Ghost.erased 'b) (p: ptr 'a 'b)
-: SteelGhostT unit opened
-    (pts_to p pb v)
-    (fun _ -> pts_to_or_null p pb (Some #'b v))
-
-val elim_pts_to_or_null_nullptr (#opened:inames)
-  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
-: SteelGhost unit opened
-    (pts_to_or_null p pb v)
-    (fun _ -> emp)
-    (requires fun _ -> p == nullptr)
-    (ensures fun _ _ _ -> Ghost.reveal v == None)
-
-val elim_pts_to_or_null (#opened:inames)
-  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
-: SteelGhost (Ghost.erased 'b) opened
-    (pts_to_or_null p pb v)
-    (fun w -> pts_to p pb w)
-    (requires fun _ -> p =!= nullptr)
-    (ensures fun _ w _ -> Ghost.reveal v == Some #'b w)
-
-(** Test whether a pointer is null. *)
-val is_null
-  (#pb: pcm 'b) (#v: Ghost.erased (option 'b)) (p: ptr 'a 'b)
-: Steel bool
-    (pts_to_or_null p pb v)
-    (fun _ -> pts_to_or_null p pb v)
-    (requires fun _ -> Some? v ==> Some?.v v =!= one pb)
-    (ensures fun _ b _ -> b <==> p == nullptr)
-
-(** Focus/unfocus on pointers *)
-
-val ptr_focused
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r': ptr a c) (r: ptr a b) (#q: pcm c) (l: connection p q)
-: prop
-
-val focus (#p: pcm 'b) (r: ptr 'a 'b) (#q: pcm 'c)
-  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ptr 'a 'c)
-    (pts_to r p s)
-    (fun r' -> pts_to r' q x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
-    (fun _ r' _ -> ptr_focused r' r l)
-
-val unfocus (#a #b #c:Type) (#opened:Steel.Memory.inames)
-  (#p: pcm b)
-  (#q: pcm c)
-  (r: ptr a c) (r': ptr a b)
-  (l: connection p q) (x: Ghost.erased c)
-: SteelGhost unit opened
-    (pts_to r q x)
-    (fun _ -> pts_to r' p (l.conn_small_to_large.morph x))
-    (requires fun _ -> ptr_focused r r' l)
-    (ensures fun _ _ _ -> True)
-
-(** Write for pointers using the all-or-none PCM *)
-val ptr_opt_write
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (p: ptr a (option b)) (y: b)
-: SteelT unit
-    (pts_to p opt_pcm (Some #b x))
-    (fun _ -> pts_to p opt_pcm (Some #b y))
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 76c5b71004b..13b63f308b9 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -5,14 +5,20 @@ open FStar.FunctionalExtensionality
 
 #push-options "--print_universes"
 
-noeq type ref' (a: Type u#0) (b: Type u#b) : Type u#b = {
+noeq type ref0 (a: Type u#0) (b: Type u#b) : Type u#b = {
   p: pcm a;
   q: pcm b;
   pl: connection p q;
   r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
 }
 
-let pcm_of_ref' r = r.q
+let ptr a b = option (ref0 a b)
+
+let null a b = None
+
+let ptr_is_null p = None? p
+
+let pcm_of_ref' r = (Some?.v r).q
 
 let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
 
@@ -21,37 +27,38 @@ let raise_p
   (#b: Type u#b)
   (r: ref' a b)
 : Tot (pcm (U.raise_t u#0 u#1 a))
-= U.raise_pcm r.p
+= U.raise_pcm (Some?.v r).p
 
 let lower_conn
   (#a: Type u#0)
   (#b: Type u#b)
   (r: ref' a b)
-: Tot (connection (raise_p r) r.p)
-= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 r.p))
+: Tot (connection (raise_p r) (Some?.v r).p)
+= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (Some?.v r).p))
 
 let raise_pl
   (#a: Type u#0)
   (#b: Type u#b)
   (r: ref' a b)
-: Tot (connection (raise_p r) r.q)
-= lower_conn r `connection_compose` r.pl
+: Tot (connection (raise_p r) (Some?.v r).q)
+= lower_conn r `connection_compose` (Some?.v r).pl
 
 let pts_to r v =
-  r.r `mpts_to` (raise_pl r).conn_small_to_large.morph v
+  (Some?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
 
 let t_ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
 : Tot (ref a q)
-= {p = r.p; pl = connection_compose r.pl l; r = r.r; q = q}
+= let Some r = r in
+  Some ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
 
 let ref_focus r l = t_ref_focus r l
 
-let ref_focus_id r = connection_compose_id_right r.pl
+let ref_focus_id r = connection_compose_id_right (Some?.v r).pl
 
 let ref_focus_comp r l m
-= connection_compose_assoc r.pl l m
+= connection_compose_assoc (Some?.v r).pl l m
 
 let mk_id_ref
   (#a: Type0)
@@ -61,12 +68,13 @@ let mk_id_ref
 =
   let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
   let fp = fstar_pcm_of_pcm p' in
-  let r : ref' a a = { p = p; q = p; pl = connection_id p; r = r0 } in
+  let r : ref' a a = Some ({ p = p; q = p; pl = connection_id p; r = r0 }) in
   r
 
 (* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
 
 let freeable #a #b #p r =
+  let Some r = r in
   a == b /\
   r.p == p /\
   r.pl == connection_id p
@@ -86,12 +94,12 @@ let ref_alloc #a p x =
 
 let ref_free #a #b #p #x r =
   // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.PCM
-  Steel.Effect.Atomic.drop (r.r `mpts_to` _)
+  Steel.Effect.Atomic.drop ((Some?.v r).r `mpts_to` _)
 
 #pop-options
 
 let gfocus r l s x =
-  connection_compose_assoc (lower_conn r) r.pl l;
+  connection_compose_assoc (lower_conn r) (Some?.v r).pl l;
   A.change_equal_slprop
     (r `pts_to` s)
     (ref_focus r l `pts_to` x)
@@ -105,7 +113,7 @@ let focus r l s x =
   A.return r'
 
 let unfocus r r' l x =
-  connection_compose_assoc (lower_conn r') r'.pl l;
+  connection_compose_assoc (lower_conn r') (Some?.v r').pl l;
   A.change_equal_slprop
     (r `pts_to` x)
     (r' `pts_to` l.conn_small_to_large.morph x)
@@ -118,16 +126,16 @@ let split r xy x y =
   assert (composable (raise_p r) x2 y2);
   A.change_equal_slprop
     (r `pts_to` xy)
-    (r.r `mpts_to` xy2);
-  Steel.PCMReference.split r.r
+    ((Some?.v r).r `mpts_to` xy2);
+  Steel.PCMReference.split (Some?.v r).r
     xy2
     x2
     y2;
   A.change_equal_slprop
-    (r.r `mpts_to` x2)
+    ((Some?.v r).r `mpts_to` x2)
     (r `pts_to` x);
   A.change_equal_slprop
-    (r.r `mpts_to` y2)
+    ((Some?.v r).r `mpts_to` y2)
     (r `pts_to` y)
 
 let mgather
@@ -144,11 +152,11 @@ let gather #inames #a #b #p r x y =
   let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
   A.change_equal_slprop
     (r `pts_to` x)
-    (r.r `mpts_to` x2);
+    ((Some?.v r).r `mpts_to` x2);
   A.change_equal_slprop
     (r `pts_to` y)
-    (r.r `mpts_to` y2);
-  mgather r.r
+    ((Some?.v r).r `mpts_to` y2);
+  mgather (Some?.v r).r
     x2
     y2;
   assert (composable (raise_p r) x2 y2);
@@ -167,9 +175,9 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible p x x')
 = let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
-  A.change_equal_slprop (r `pts_to` x) (r.r `mpts_to` w);
-  let w' = Steel.PCMReference.read r.r w in
-  A.change_equal_slprop (r.r `mpts_to` w) (r `pts_to` x);
+  A.change_equal_slprop (r `pts_to` x) ((Some?.v r).r `mpts_to` w);
+  let w' = Steel.PCMReference.read (Some?.v r).r w in
+  A.change_equal_slprop ((Some?.v r).r `mpts_to` w) (r `pts_to` x);
   let x' = (raise_pl r).conn_large_to_small.morph w' in
   compatible_morphism (raise_pl r).conn_large_to_small w w';
   A.return x'
@@ -179,7 +187,7 @@ let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p
 = let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty r.r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
+  M.upd_gen Set.empty (Some?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
 
 let as_action (#p:vprop)
               (#q:vprop)
@@ -225,7 +233,7 @@ let pts_to_view_explicit_witinv
     let y_ = vw.to_carrier y in
     let x' = c.conn_small_to_large.morph x_ in
     let y' = c.conn_small_to_large.morph y_ in
-    M.pts_to_join r.r x' y' m;
+    M.pts_to_join (Some?.v r).r x' y' m;
     let z' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun z' -> compatible (raise_p r) x' z' /\ compatible (raise_p r) y' z') in
     let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_x' -> composable (raise_p r) x' frame_x' /\ op (raise_p r) frame_x' x' == z') in
     let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_y' -> composable (raise_p r) y' frame_y' /\ op (raise_p r) frame_y' y' == z') in
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index dae9cb7a381..b7eed117f33 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -5,8 +5,15 @@ open Steel.C.Connection
 
 #push-options "--print_universes"
 
-(** A [ref' a b] is a reference to some value of type b inside of a "base object" of type a. *)
-val ref' (a: Type u#0) (b: Type u#b) : Type u#b
+(** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
+val ptr (a: Type u#0) (b: Type u#b) : Type u#b
+
+val null (a: Type) (b: Type) : Tot (ptr a b)
+
+val ptr_is_null (#a: Type) (#b: Type) (p: ptr a b) : Ghost bool (requires True) (ensures (fun r -> r == true <==> p == null a b))
+
+(** A [ref' a b] is a (non-null) reference to some value of type b inside of a "base object" of type a. *)
+let ref' (a: Type u#0) (b: Type u#b) : Type u#b = (p: ptr a b { ptr_is_null p == false })
 
 (** The PCM that governs the values pointed to by a ref' *)
 val pcm_of_ref' (#a: _) (#b: Type u#b) (r: ref' a b) : GTot (pcm b)

From a9eeb12caef86120cb700bb511d35f5c5a1ec355 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 17:12:56 -0700
Subject: [PATCH 267/513] support for the null pointer

---
 ulib/experimental/Steel.C.Ref.fst  | 242 +++++++++++++++++++++++++----
 ulib/experimental/Steel.C.Ref.fsti | 120 +++++++++++++-
 2 files changed, 325 insertions(+), 37 deletions(-)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 13b63f308b9..e020b13e7b6 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -12,13 +12,15 @@ noeq type ref0 (a: Type u#0) (b: Type u#b) : Type u#b = {
   r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
 }
 
-let ptr a b = option (ref0 a b)
+noeq type ptr' (a: Type u#0) (b: Type u#b) : Type u#b =
+  | NonNull: (v: ref0 a b) -> ptr' a b
+  | Null: (v: pcm b) -> ptr' a b
 
-let null a b = None
+let pcm_of_ref' r = if Null? r then Null?.v r else (NonNull?.v r).q
 
-let ptr_is_null p = None? p
+let null a p = Null p
 
-let pcm_of_ref' r = (Some?.v r).q
+let ptr_is_null p = Null? p
 
 let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
 
@@ -27,38 +29,38 @@ let raise_p
   (#b: Type u#b)
   (r: ref' a b)
 : Tot (pcm (U.raise_t u#0 u#1 a))
-= U.raise_pcm (Some?.v r).p
+= U.raise_pcm (NonNull?.v r).p
 
 let lower_conn
   (#a: Type u#0)
   (#b: Type u#b)
   (r: ref' a b)
-: Tot (connection (raise_p r) (Some?.v r).p)
-= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (Some?.v r).p))
+: Tot (connection (raise_p r) (NonNull?.v r).p)
+= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (NonNull?.v r).p))
 
 let raise_pl
   (#a: Type u#0)
   (#b: Type u#b)
   (r: ref' a b)
-: Tot (connection (raise_p r) (Some?.v r).q)
-= lower_conn r `connection_compose` (Some?.v r).pl
+: Tot (connection (raise_p r) (NonNull?.v r).q)
+= lower_conn r `connection_compose` (NonNull?.v r).pl
 
 let pts_to r v =
-  (Some?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
+  (NonNull?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
 
 let t_ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
 : Tot (ref a q)
-= let Some r = r in
-  Some ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
+= let NonNull r = r in
+  NonNull ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
 
 let ref_focus r l = t_ref_focus r l
 
-let ref_focus_id r = connection_compose_id_right (Some?.v r).pl
+let ref_focus_id r = connection_compose_id_right (NonNull?.v r).pl
 
 let ref_focus_comp r l m
-= connection_compose_assoc (Some?.v r).pl l m
+= connection_compose_assoc (NonNull?.v r).pl l m
 
 let mk_id_ref
   (#a: Type0)
@@ -68,13 +70,13 @@ let mk_id_ref
 =
   let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
   let fp = fstar_pcm_of_pcm p' in
-  let r : ref' a a = Some ({ p = p; q = p; pl = connection_id p; r = r0 }) in
+  let r : ref' a a = NonNull ({ p = p; q = p; pl = connection_id p; r = r0 }) in
   r
 
 (* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
 
 let freeable #a #b #p r =
-  let Some r = r in
+  let NonNull r = r in
   a == b /\
   r.p == p /\
   r.pl == connection_id p
@@ -94,12 +96,12 @@ let ref_alloc #a p x =
 
 let ref_free #a #b #p #x r =
   // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.PCM
-  Steel.Effect.Atomic.drop ((Some?.v r).r `mpts_to` _)
+  Steel.Effect.Atomic.drop ((NonNull?.v r).r `mpts_to` _)
 
 #pop-options
 
 let gfocus r l s x =
-  connection_compose_assoc (lower_conn r) (Some?.v r).pl l;
+  connection_compose_assoc (lower_conn r) (NonNull?.v r).pl l;
   A.change_equal_slprop
     (r `pts_to` s)
     (ref_focus r l `pts_to` x)
@@ -113,7 +115,7 @@ let focus r l s x =
   A.return r'
 
 let unfocus r r' l x =
-  connection_compose_assoc (lower_conn r') (Some?.v r').pl l;
+  connection_compose_assoc (lower_conn r') (NonNull?.v r').pl l;
   A.change_equal_slprop
     (r `pts_to` x)
     (r' `pts_to` l.conn_small_to_large.morph x)
@@ -126,16 +128,16 @@ let split r xy x y =
   assert (composable (raise_p r) x2 y2);
   A.change_equal_slprop
     (r `pts_to` xy)
-    ((Some?.v r).r `mpts_to` xy2);
-  Steel.PCMReference.split (Some?.v r).r
+    ((NonNull?.v r).r `mpts_to` xy2);
+  Steel.PCMReference.split (NonNull?.v r).r
     xy2
     x2
     y2;
   A.change_equal_slprop
-    ((Some?.v r).r `mpts_to` x2)
+    ((NonNull?.v r).r `mpts_to` x2)
     (r `pts_to` x);
   A.change_equal_slprop
-    ((Some?.v r).r `mpts_to` y2)
+    ((NonNull?.v r).r `mpts_to` y2)
     (r `pts_to` y)
 
 let mgather
@@ -152,11 +154,11 @@ let gather #inames #a #b #p r x y =
   let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
   A.change_equal_slprop
     (r `pts_to` x)
-    ((Some?.v r).r `mpts_to` x2);
+    ((NonNull?.v r).r `mpts_to` x2);
   A.change_equal_slprop
     (r `pts_to` y)
-    ((Some?.v r).r `mpts_to` y2);
-  mgather (Some?.v r).r
+    ((NonNull?.v r).r `mpts_to` y2);
+  mgather (NonNull?.v r).r
     x2
     y2;
   assert (composable (raise_p r) x2 y2);
@@ -175,9 +177,9 @@ let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
     (requires fun _ -> True)
     (ensures fun _ x' _ -> compatible p x x')
 = let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
-  A.change_equal_slprop (r `pts_to` x) ((Some?.v r).r `mpts_to` w);
-  let w' = Steel.PCMReference.read (Some?.v r).r w in
-  A.change_equal_slprop ((Some?.v r).r `mpts_to` w) (r `pts_to` x);
+  A.change_equal_slprop (r `pts_to` x) ((NonNull?.v r).r `mpts_to` w);
+  let w' = Steel.PCMReference.read (NonNull?.v r).r w in
+  A.change_equal_slprop ((NonNull?.v r).r `mpts_to` w) (r `pts_to` x);
   let x' = (raise_pl r).conn_large_to_small.morph w' in
   compatible_morphism (raise_pl r).conn_large_to_small w w';
   A.return x'
@@ -187,7 +189,7 @@ let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p
 = let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty (Some?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
+  M.upd_gen Set.empty (NonNull?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
 
 let as_action (#p:vprop)
               (#q:vprop)
@@ -233,7 +235,7 @@ let pts_to_view_explicit_witinv
     let y_ = vw.to_carrier y in
     let x' = c.conn_small_to_large.morph x_ in
     let y' = c.conn_small_to_large.morph y_ in
-    M.pts_to_join (Some?.v r).r x' y' m;
+    M.pts_to_join (NonNull?.v r).r x' y' m;
     let z' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun z' -> compatible (raise_p r) x' z' /\ compatible (raise_p r) y' z') in
     let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_x' -> composable (raise_p r) x' frame_x' /\ op (raise_p r) frame_x' x' == z') in
     let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_y' -> composable (raise_p r) y' frame_y' /\ op (raise_p r) frame_y' y' == z') in
@@ -459,3 +461,181 @@ let ref_read_sel
   let res = vw.to_view v in
   pts_to_view_intro r _v vw res;
   A.return res
+
+
+// [@@__steel_reduce__; __reduce__]
+let pts_to_view_or_null0
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot vprop
+= if ptr_is_null r
+  then (emp `vrewrite` (fun _ -> None <: option c))
+  else (pts_to_view r vw `vrewrite` (fun x -> Some x))
+
+let pts_to_view_or_null_sl
+  r vw
+=
+  hp_of (pts_to_view_or_null0 r vw)
+
+let pts_to_view_or_null_sel
+  r vw
+=
+  sel_of (pts_to_view_or_null0 r vw)
+
+let pts_to_view_or_null_prop_null
+  (#inames: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost unit inames
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires fun _ -> Null? r)
+    (ensures fun h _ h' ->
+      let s = h (pts_to_view_or_null r vw) in
+      h' (pts_to_view_or_null r vw) == s /\
+      None? s == Null? r
+    )
+=
+  A.change_slprop_rel
+    (pts_to_view_or_null r vw)
+    (pts_to_view_or_null0 r vw)
+    (fun x y -> x == y)
+    (fun _ -> ());
+  A.change_equal_slprop
+    (pts_to_view_or_null0 r vw)
+    (emp `vrewrite` (fun _ -> None <: option c));
+  A.elim_vrewrite emp (fun _ -> None <: option c);
+  A.intro_vrewrite emp (fun _ -> None <: option c);
+  A.change_equal_slprop
+    (emp `vrewrite` (fun _ -> None <: option c))
+    (pts_to_view_or_null0 r vw);  
+  A.change_slprop_rel
+    (pts_to_view_or_null0 r vw)
+    (pts_to_view_or_null r vw)
+    (fun x y -> x == y)
+    (fun _ -> ())
+
+let pts_to_view_or_null_prop_not_null
+  (#inames: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost unit inames
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires fun _ -> NonNull? r)
+    (ensures fun h _ h' ->
+      let s = h (pts_to_view_or_null r vw) in
+      h' (pts_to_view_or_null r vw) == s /\
+      None? s == Null? r
+    )
+=
+  A.change_slprop_rel
+    (pts_to_view_or_null r vw)
+    (pts_to_view_or_null0 r vw)
+    (fun x y -> x == y)
+    (fun _ -> ());
+  A.change_equal_slprop
+    (pts_to_view_or_null0 r vw)
+    (pts_to_view r vw `vrewrite` (fun x -> Some x));
+  A.elim_vrewrite (pts_to_view r vw) (fun x -> Some x);
+  A.intro_vrewrite (pts_to_view r vw) (fun x -> Some x);
+  A.change_equal_slprop
+    (pts_to_view r vw `vrewrite` (fun x -> Some x))
+    (pts_to_view_or_null0 r vw);  
+  A.change_slprop_rel
+    (pts_to_view_or_null0 r vw)
+    (pts_to_view_or_null r vw)
+    (fun x y -> x == y)
+    (fun _ -> ())
+
+let pts_to_view_or_null_prop
+  (#inames: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost unit inames
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires fun _ -> True)
+    (ensures fun h _ h' ->
+      let s = h (pts_to_view_or_null r vw) in
+      h' (pts_to_view_or_null r vw) == s /\
+      None? s == Null? r
+    )
+=
+  if Null? r
+  then pts_to_view_or_null_prop_null r vw
+  else pts_to_view_or_null_prop_not_null r vw
+
+let is_null
+  r vw
+=
+  pts_to_view_or_null_prop r vw;
+  A.return (Null? r)
+
+let intro_pts_to_view_or_null_null
+  a #b #p #c vw
+=
+  A.intro_vrewrite emp (fun _ -> None <: option c);
+  A.change_equal_slprop
+    (emp `vrewrite` (fun _ -> None <: option c))
+    (pts_to_view_or_null0 (null a p) vw);
+  A.change_slprop_rel
+    (pts_to_view_or_null0 (null a p) vw)
+    (pts_to_view_or_null (null a p) vw)
+    (fun x y -> x == y)
+    (fun _ -> ())
+
+let elim_pts_to_view_or_null_null
+  a #b #p #c vw
+=
+  A.change_slprop_rel
+    (pts_to_view_or_null (null a p) vw)
+    (pts_to_view_or_null0 (null a p) vw)
+    (fun x y -> x == y)
+    (fun _ -> ());
+  A.change_equal_slprop
+    (pts_to_view_or_null0 (null a p) vw)
+    (emp `vrewrite` (fun _ -> None <: option c));
+  A.elim_vrewrite emp (fun _ -> None <: option c)
+
+let intro_pts_to_view_or_null_not_null
+  r vw
+=
+  A.intro_vrewrite
+    (pts_to_view r vw)
+    (fun x -> Some x);
+  A.change_equal_slprop
+    (pts_to_view r vw `vrewrite` (fun x -> Some x))
+    (pts_to_view_or_null0 r vw);
+  A.change_slprop_rel
+    (pts_to_view_or_null0 r vw)
+    (pts_to_view_or_null r vw)
+    (fun x y -> x == y)
+    (fun _ -> ())
+
+let elim_pts_to_view_or_null_not_null
+  r vw
+=
+  A.change_slprop_rel
+    (pts_to_view_or_null r vw)
+    (pts_to_view_or_null0 r vw)
+    (fun x y -> x == y)
+    (fun _ -> ());
+  A.change_equal_slprop
+    (pts_to_view_or_null0 r vw)
+    (pts_to_view r vw `vrewrite` (fun x -> Some x));
+  A.elim_vrewrite
+    (pts_to_view r vw)
+    (fun x -> Some x)
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index b7eed117f33..7dbd9a2d58e 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -6,17 +6,18 @@ open Steel.C.Connection
 #push-options "--print_universes"
 
 (** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
-val ptr (a: Type u#0) (b: Type u#b) : Type u#b
+val ptr' (a: Type u#0) (b: Type u#b) : Type u#b
+(** The PCM that governs the values pointed to by a ref' *)
+val pcm_of_ref' (#a: _) (#b: Type u#b) (r: ptr' a b) : GTot (pcm b)
+let ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) = (r: ptr' a b { pcm_of_ref' r == p })
 
-val null (a: Type) (b: Type) : Tot (ptr a b)
+val null (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a p)
 
-val ptr_is_null (#a: Type) (#b: Type) (p: ptr a b) : Ghost bool (requires True) (ensures (fun r -> r == true <==> p == null a b))
+val ptr_is_null (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null a p))
 
 (** A [ref' a b] is a (non-null) reference to some value of type b inside of a "base object" of type a. *)
-let ref' (a: Type u#0) (b: Type u#b) : Type u#b = (p: ptr a b { ptr_is_null p == false })
+let ref' (a: Type u#0) (b: Type u#b) : Type u#b = (p: ptr' a b { ptr_is_null (p <: ptr a (pcm_of_ref' p)) == false })
 
-(** The PCM that governs the values pointed to by a ref' *)
-val pcm_of_ref' (#a: _) (#b: Type u#b) (r: ref' a b) : GTot (pcm b)
 
 (** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
 let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
@@ -315,3 +316,110 @@ val ref_read_sel
   ))
 
 (* write cannot be defined generically because of p_refine *)
+
+/// Pointers (and the null pointer)
+
+val pts_to_view_or_null_sl
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type u#0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot (M.slprop u#1)
+
+val pts_to_view_or_null_sel
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: GTot (selector (option c) (pts_to_view_or_null_sl r vw))
+
+[@@__steel_reduce__]
+let pts_to_view_or_null'
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: GTot vprop'
+= {
+  hp = pts_to_view_or_null_sl r vw;
+  t = option c;
+  sel = pts_to_view_or_null_sel r vw;
+}
+
+[@@__steel_reduce__]
+let pts_to_view_or_null
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot vprop
+= VUnit (pts_to_view_or_null' r vw)
+
+val is_null
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Steel bool
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires (fun _ -> True))
+    (ensures (fun h res h' ->
+      let s = h (pts_to_view_or_null r vw) in
+      h' (pts_to_view_or_null r vw) == s /\
+      res == ptr_is_null r /\
+      res == (None? s)
+    ))
+
+val intro_pts_to_view_or_null_null
+  (#inames: _)
+  (a: Type) (#b: Type) (#p: pcm b)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost unit inames
+    emp
+    (fun _ -> pts_to_view_or_null (null a p) vw)
+    (requires (fun _ -> True))
+    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null a p) vw) == None))
+
+val elim_pts_to_view_or_null_null
+  (#inames: _)
+  (a: Type) (#b: Type) (#p: pcm b)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhostT unit inames
+    (pts_to_view_or_null (null a p) vw)
+    (fun _ -> emp)
+
+val intro_pts_to_view_or_null_not_null
+  (#inames: _)
+  (#a: Type) (#b: Type) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost unit inames
+    (pts_to_view r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires (fun _ -> True))
+    (ensures (fun h _ h' -> h' (pts_to_view_or_null r vw) == Some (h (pts_to_view r vw))))
+
+val elim_pts_to_view_or_null_not_null
+  (#inames: _)
+  (#a: Type) (#b: Type) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: A.SteelGhost unit inames
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view r vw)
+    (requires (fun _ -> True))
+    (ensures (fun h _ h' -> h (pts_to_view_or_null r vw) == Some (h' (pts_to_view r vw))))

From 5a5327d21ff70c1a4daff752df928900cb40f6b1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 20:31:42 -0700
Subject: [PATCH 268/513] support for null pointer

---
 ulib/experimental/Steel.C.Array.fst     |   2 +-
 ulib/experimental/Steel.C.Opt.fst       |  20 ++++
 ulib/experimental/Steel.C.Opt.fsti      |  21 +++++
 ulib/experimental/Steel.C.Ref.fst       |  20 ++--
 ulib/experimental/Steel.C.Ref.fsti      |  20 ++--
 ulib/experimental/Steel.C.Reference.fst | 120 ++++++++++++++++++++----
 6 files changed, 166 insertions(+), 37 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index a6cb02177a1..115b2d31501 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1000,7 +1000,7 @@ let intro_varray
   #base #t #n r sq
 =
   let res = mk_array r in
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
   assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
   assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
diff --git a/ulib/experimental/Steel.C.Opt.fst b/ulib/experimental/Steel.C.Opt.fst
index 4b230e58ae0..deb15a5eb0f 100644
--- a/ulib/experimental/Steel.C.Opt.fst
+++ b/ulib/experimental/Steel.C.Opt.fst
@@ -33,3 +33,23 @@ let opt_pcm_read
   let y' = ref_read r in
   assert (Ghost.reveal x == y');
   Some?.v y'
+
+let malloc
+  #c x
+=
+  let xc = ((opt_view c).to_carrier x) in
+  let r = Steel.C.Ref.ref_alloc _ xc in
+  pts_to_view_intro r xc (opt_view c) x;
+  let r' : ref (option c) c (opt_pcm #c) = r in
+  A.change_equal_slprop
+    (Steel.C.Ref.pts_to_view r (opt_view c))
+    (pts_to_view r' (opt_view c));
+  intro_pts_to_view_or_null_not_null r' (opt_view c);
+  A.return r'
+
+let free
+  #c r
+=
+  let r' : Steel.C.Ref.ref (option c) (opt_pcm #c) = r in 
+  let _ = pts_to_view_elim r (opt_view c) in
+  Steel.C.Ref.ref_free r
diff --git a/ulib/experimental/Steel.C.Opt.fsti b/ulib/experimental/Steel.C.Opt.fsti
index 0817c2c9795..c9e9e6ece9a 100644
--- a/ulib/experimental/Steel.C.Opt.fsti
+++ b/ulib/experimental/Steel.C.Opt.fsti
@@ -163,3 +163,24 @@ let ref_opt_write
     w == h' (pts_to_view r (opt_view b))
   ))
 = opt_write_sel r w
+
+val malloc
+  (#c:Type0) (x: c)
+: Steel (ptr (option c) c (opt_pcm #c))
+    emp
+    (fun r -> pts_to_view_or_null r (opt_view c))
+    (requires fun _ -> True)
+    (ensures fun _ r h' ->
+      let s = h' (pts_to_view_or_null r (opt_view c)) in
+      ptr_is_null r == None? s /\
+      (Some? s ==> (Some?.v s == x /\ freeable r))
+    )
+
+val free
+  (#c: Type0)
+  (r: ref (option c) c (opt_pcm #c))
+: Steel unit
+    (pts_to_view r (opt_view c))
+    (fun _ -> emp)
+    (requires fun _ -> freeable r)
+    (ensures fun _ _ _ -> True)
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index e020b13e7b6..088aff07ec8 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -16,7 +16,14 @@ noeq type ptr' (a: Type u#0) (b: Type u#b) : Type u#b =
   | NonNull: (v: ref0 a b) -> ptr' a b
   | Null: (v: pcm b) -> ptr' a b
 
-let pcm_of_ref' r = if Null? r then Null?.v r else (NonNull?.v r).q
+let pcm_of_ptr'
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ptr' a b)
+: Tot (pcm b)
+= if Null? r then Null?.v r else (NonNull?.v r).q
+
+let ptr a #b p = (r: ptr' a b { pcm_of_ptr' r == p })
 
 let null a p = Null p
 
@@ -27,21 +34,21 @@ let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fall
 let raise_p
   (#a: Type u#0)
   (#b: Type u#b)
-  (r: ref' a b)
+  (r: ptr' a b { NonNull? r})
 : Tot (pcm (U.raise_t u#0 u#1 a))
 = U.raise_pcm (NonNull?.v r).p
 
 let lower_conn
   (#a: Type u#0)
   (#b: Type u#b)
-  (r: ref' a b)
+  (r: ptr' a b { NonNull? r})
 : Tot (connection (raise_p r) (NonNull?.v r).p)
 = connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (NonNull?.v r).p))
 
 let raise_pl
   (#a: Type u#0)
   (#b: Type u#b)
-  (r: ref' a b)
+  (r: ptr' a b {NonNull? r})
 : Tot (connection (raise_p r) (NonNull?.v r).q)
 = lower_conn r `connection_compose` (NonNull?.v r).pl
 
@@ -70,8 +77,7 @@ let mk_id_ref
 =
   let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
   let fp = fstar_pcm_of_pcm p' in
-  let r : ref' a a = NonNull ({ p = p; q = p; pl = connection_id p; r = r0 }) in
-  r
+  NonNull ({ p = p; q = p; pl = connection_id p; r = r0 })
 
 (* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
 
@@ -89,7 +95,7 @@ let ref_alloc #a p x =
 //  let fp : P.pcm u#1 _ = fstar_pcm_of_pcm p' in // FIXME: I can define this local definition, but WHY WHY WHY can't I USE it?
   compatible_refl p' x';
   let r0 : Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) = Steel.PCMReference.alloc #_ #(fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) x' in
-  let r : ref' a a = mk_id_ref p r0 in
+  let r : ref a p = mk_id_ref p r0 in
   connection_compose_id_right (lower_conn r);
   A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
   A.return r
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 7dbd9a2d58e..4a3863c991e 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -6,22 +6,23 @@ open Steel.C.Connection
 #push-options "--print_universes"
 
 (** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
-val ptr' (a: Type u#0) (b: Type u#b) : Type u#b
-(** The PCM that governs the values pointed to by a ref' *)
-val pcm_of_ref' (#a: _) (#b: Type u#b) (r: ptr' a b) : GTot (pcm b)
-let ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) = (r: ptr' a b { pcm_of_ref' r == p })
+val ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
 
 val null (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a p)
 
 val ptr_is_null (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null a p))
 
-(** A [ref' a b] is a (non-null) reference to some value of type b inside of a "base object" of type a. *)
-let ref' (a: Type u#0) (b: Type u#b) : Type u#b = (p: ptr' a b { ptr_is_null (p <: ptr a (pcm_of_ref' p)) == false })
+let refine (a: Type) (p: (a -> prop)) : Tot Type =
+  (x: a { p x })
 
+let not_null
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p)
+: Tot prop
+= ptr_is_null r == false
 
 (** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
 let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
-  (r: ref' a b { pcm_of_ref' r == q })
+  refine (ptr a q) (not_null #a #b #q)
 
 open Steel.Effect
 
@@ -55,7 +56,7 @@ val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
 module A = Steel.Effect.Atomic
 
 val freeable
-  (#a #b:Type0) (#p: pcm b) (r: ref a p)
+  (#a: Type0) (#b:Type0) (#p: pcm b) (r: ref a p)
 : Tot prop
 
 (** Allocate a reference containing value x. *)
@@ -149,9 +150,6 @@ val base_fpu
   (requires (exclusive p x /\ p_refine p y))
   (ensures (fun _ -> True))
 
-let refine (a: Type) (p: (a -> Tot prop)) : Tot Type =
-  (x: a { p x })
-
 (** PCM carrier values are cumbersome to work with directly. To
     abstract over them, we define "view"s, which are essentially
     lossless partial functions from PCM carrier values to "view
diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index 4c339b74ce2..a63fcbbfa13 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -1,20 +1,31 @@
 module Steel.C.Reference
-open FStar.FunctionalExtensionality
 open Steel.C.PCM
-open Steel.C.Connection
 open Steel.C.Ref
 open Steel.Effect
 open Steel.Effect.Atomic
 
-open FStar.FSet
-
 #push-options "--print_universes"
 
-let ref (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+// [@@__reduce__]
+let ptr (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
 : Type u#b
-= ref a q
+= ptr a q
+
+// [@@__reduce__]
+inline_for_extraction
+let ref (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+: Tot (Type u#b)
+=
+  (x: ptr a view_t q { not_null x })
+
+unfold
+let ref_of_ref
+  (#a: Type u#0) (#view_t: Type u#0) (#b: Type u#b) (#q: pcm b)
+  (r: ref a view_t q)
+: Tot (Steel.C.Ref.ref a q)
+= r
 
-[@@__steel_reduce__]
+[@@__steel_reduce__] // ; __reduce__]
 let pts_to_view
   (#a: Type u#0) 
   (#view_t: Type u#0)
@@ -24,19 +35,10 @@ let pts_to_view
 : vprop
 = r `pts_to_view` view
 
-(*
-val ref_alloc
-  (#a:Type0) (p: pcm a) (x: a)
-: Steel (ref a p)
-    emp
-    (fun r -> r `pts_to` x)
-    (requires fun _ -> p_refine p x)
-    (ensures fun _ _ _ -> True)
-*)
-
 let ref_read
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b)
   (#view_t: Type u#0)
+  (#p: pcm b)
   (#vw: sel_view p view_t false)
   (r: ref a view_t p)
 : Steel view_t
@@ -48,3 +50,85 @@ let ref_read
     res == h' (r `pts_to_view` vw)
   ))
 = ref_read_sel r vw
+
+let null (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a view_t p) = null a p
+
+[@@__steel_reduce__] // ; __reduce__]
+let pts_to_view_or_null
+  (#a: Type u#0) 
+  (#view_t: Type u#0)
+  (#view_t': Type u#0)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr a view_t p) (view: sel_view p view_t' false)
+: vprop
+= r `pts_to_view_or_null` view
+
+let is_null
+  (#a: Type u#0) (#b: Type u#b) (#c: Type0) (#p: pcm b)
+  (r: ptr a c p)
+  (vw: sel_view p c false)
+: Steel bool
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires (fun _ -> True))
+    (ensures (fun h res h' ->
+      let s = h (pts_to_view_or_null r vw) in
+      h' (pts_to_view_or_null r vw) == s /\
+      res == ptr_is_null r /\
+      res == (None? s)
+    ))
+= is_null r vw
+
+let intro_pts_to_view_or_null_null
+  (#inames: _)
+  (a: Type) (#b: Type) (#p: pcm b)
+  (#c: Type0)
+  (vw: sel_view p c false)
+: SteelGhost unit inames
+    emp
+    (fun _ -> pts_to_view_or_null (null a c p) vw)
+    (requires (fun _ -> True))
+    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null a c p) vw) == None))
+= intro_pts_to_view_or_null_null a vw
+
+let elim_pts_to_view_or_null_null
+  (#inames: _)
+  (a: Type) (#b: Type) (#p: pcm b)
+  (#c: Type0)
+  (vw: sel_view p c false)
+: SteelGhostT unit inames
+    (pts_to_view_or_null (null a c p) vw)
+    (fun _ -> emp)
+= elim_pts_to_view_or_null_null a vw
+
+let intro_pts_to_view_or_null_not_null
+  (#inames: _)
+  (#a: Type) (#b: Type) (#p: pcm b)
+  (#c: Type0)
+  (r: ref a c p)
+  (vw: sel_view p c false)
+: SteelGhost unit inames
+    (pts_to_view r vw)
+    (fun _ -> pts_to_view_or_null r vw)
+    (requires (fun _ -> True))
+    (ensures (fun h _ h' -> h' (pts_to_view_or_null r vw) == Some (h (pts_to_view r vw))))
+= intro_pts_to_view_or_null_not_null r vw
+
+let elim_pts_to_view_or_null_not_null
+  (#inames: _)
+  (#a: Type) (#b: Type) (#p: pcm b)
+  (#c: Type0)
+  (r: ref a c p)
+  (vw: sel_view p c false)
+: SteelGhost unit inames
+    (pts_to_view_or_null r vw)
+    (fun _ -> pts_to_view r vw)
+    (requires (fun _ -> True))
+    (ensures (fun h _ h' -> h (pts_to_view_or_null r vw) == Some (h' (pts_to_view r vw))))
+= elim_pts_to_view_or_null_not_null r vw
+
+let freeable
+  (#a: Type u#0) (#view_t: Type u#0) (#b: Type u#0) (#q: pcm b)
+  (r: ref a view_t q)
+: Tot prop
+= freeable (r <: Steel.C.Ref.ref a q)

From 363e593590444edcbca5e9f1b5d9181ba6f79d0c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 20:53:29 -0700
Subject: [PATCH 269/513] Steel.C.Array.is_null

---
 ulib/experimental/Steel.C.Array.fst  |  3 +++
 ulib/experimental/Steel.C.Array.fsti | 13 +++++++++++++
 2 files changed, 16 insertions(+)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 115b2d31501..0a80c20bd08 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1788,3 +1788,6 @@ let free
     #(array_pcm t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
     #v
     r
+
+let is_null a =
+  return (None? a)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 8ec539afa04..37ac86f26a9 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -386,3 +386,16 @@ val free
     (fun _ -> emp)
     (requires (fun _ -> freeable a))
     (ensures (fun _ _ _ -> True))
+
+val is_null
+  (#base: Type0)
+  (#t: Type0)
+  (a: array_or_null base t)
+: Steel bool
+    (varray_or_null a)
+    (fun _ -> varray_or_null a)
+    (requires fun _ -> True)
+    (ensures fun h res h' ->
+      res == g_is_null a /\
+      h' (varray_or_null a) == h (varray_or_null a)
+    )

From 88a32cc59372086b2313d75969c2471db6939dae Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 22:50:33 -0700
Subject: [PATCH 270/513] generalize signature of
 Steel.C.Reference.elim_pts_to_view_or_null_null

---
 ulib/experimental/Steel.C.Reference.fst | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index a63fcbbfa13..cb73971cf3a 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -95,11 +95,17 @@ let elim_pts_to_view_or_null_null
   (#inames: _)
   (a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
+  (r: ptr a c p)
   (vw: sel_view p c false)
-: SteelGhostT unit inames
-    (pts_to_view_or_null (null a c p) vw)
+: SteelGhost unit inames
+    (pts_to_view_or_null r vw)
     (fun _ -> emp)
-= elim_pts_to_view_or_null_null a vw
+    (requires (fun _ -> ptr_is_null r == true))
+    (ensures (fun _ _ _ -> True))
+= change_equal_slprop
+    (pts_to_view_or_null r vw)
+    (pts_to_view_or_null (null a c p) vw);
+  elim_pts_to_view_or_null_null a vw
 
 let intro_pts_to_view_or_null_not_null
   (#inames: _)

From 2349f8cd02e41a5b511f7deb5f6fca5da06dcd8b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 22:51:49 -0700
Subject: [PATCH 271/513] extract malloc, free, null, is_null

NOTE: for null, we piggyback extraction to the Low* library,
because KReMLin AST does not have anything about null
---
 src/extraction/FStar.Extraction.Kremlin.fs | 42 ++++++++++++++++++++--
 1 file changed, 40 insertions(+), 2 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index ab361a0dc6c..68aa73e0fb1 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -760,7 +760,7 @@ and translate_type_without_decay env t: typ =
       TQualified (must (lident_of_typestring tag))
   
   | MLTY_Named ([_; arg; _; _], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Reference.ref"
+    Syntax.string_of_mlpath p = "Steel.C.Reference.ptr"
     ->
       TBuf (translate_type_without_decay env arg)
       
@@ -1022,12 +1022,23 @@ and translate_expr env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _e0; e1; e2 ])
     when (string_of_mlpath p = "FStar.Buffer.rcreate_mm" ||
-          string_of_mlpath p = "Steel.C.Array.malloc" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.mmalloc" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.mmalloc" ||
           string_of_mlpath p = "LowStar.ImmutableBuffer.imalloc") ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
+    when (
+          string_of_mlpath p = "Steel.C.Array.malloc" ||
+          false) ->
+      EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e ])
+    when (
+          string_of_mlpath p = "Steel.C.Opt.malloc" ||
+          false) ->
+      EBufCreate (ManuallyManaged, translate_expr env e, EConstant (UInt32, "1"))
+
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e0; e1 ])
     when string_of_mlpath p = "Steel.Array.malloc" ->
       EBufCreate (ManuallyManaged, translate_expr env e0, translate_expr env e1)
@@ -1046,6 +1057,7 @@ and translate_expr env e: expr =
     when (string_of_mlpath p = "FStar.Buffer.rfree" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.free" ||
           string_of_mlpath p = "Steel.C.Array.free" ||
+          string_of_mlpath p = "Steel.C.Opt.free" ||
           string_of_mlpath p = "Steel.Array.free") ->
       EBufFree (translate_expr env e2)
 
@@ -1224,6 +1236,32 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
     translate_expr env e
 
+(* BEGIN support for the Steel null pointer. Here, we "piggyback" to
+the current Low* operators for the null pointer, which KReMLin will
+extract to C later.
+
+TODO: these should be removed and those operators should be directly
+supported by KReMLin (in src/Builtin.ml) Or alternatively Null and
+IsNull nodes should be added to the KReMLin AST *)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [e])
+    when string_of_mlpath p = "Steel.C.Array.is_null"
+    -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *); e; _ (* view *)])
+    when string_of_mlpath p = "Steel.C.Reference.is_null"
+    -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
+
+  | MLE_TApp ({expr=MLE_Name p}, _)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.null"
+    -> EQualified (["LowStar"; "Buffer"], "null")
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *)])
+    when string_of_mlpath p = "Steel.C.Reference.null"
+    -> EApp (EQualified (["LowStar"; "Buffer"], "null"), [EUnit])
+
+(* END support for the Steel null pointer *)
+
   (* Operations on Steel.C.Reference.ref *)
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
     when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->

From c8504be8febf911e36d4a401822aca24aeae3d78 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 22:53:16 -0700
Subject: [PATCH 272/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 133 +++++++++++++++++--
 1 file changed, 123 insertions(+), 10 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 1c60bc454f0..bf66983b42b 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -1520,7 +1520,7 @@ and (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named
           (uu___::arg::uu___1::uu___2::[], p) when
           let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ref" ->
+          uu___3 = "Steel.C.Reference.ptr" ->
           let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
       | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -2220,11 +2220,8 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            _e0::e1::e2::[])
           when
-          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "FStar.Buffer.rcreate_mm") ||
-               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "Steel.C.Array.malloc"))
-              ||
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.Buffer.rcreate_mm") ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
                uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
              ||
@@ -2239,6 +2236,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Array.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___6, uu___7) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2313,13 +2353,16 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.rfree") ||
+          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "FStar.Buffer.rfree") ||
+               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___5 = "LowStar.Monotonic.Buffer.free"))
+              ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.free"))
+               uu___5 = "Steel.C.Array.free"))
              ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Array.free"))
+              uu___5 = "Steel.C.Opt.free"))
             ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "Steel.Array.free")
@@ -2980,6 +3023,76 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.is_null" ->
+          let uu___5 =
+            let uu___6 = let uu___7 = translate_expr env1 e1 in [uu___7] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___6) in
+          EApp uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Reference.is_null" ->
+          let uu___7 =
+            let uu___8 = let uu___9 = translate_expr env1 e1 in [uu___9] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___8) in
+          EApp uu___7
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.null" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Reference.null" ->
+          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =

From a8971c911afe0e0dbff28308556de475d2b348ed Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 8 Oct 2021 22:54:22 -0700
Subject: [PATCH 273/513] test extraction of malloc, free, null, is_null

---
 examples/steel/arraystructs/HaclExample.fst | 24 +++++++++++++++++++--
 examples/steel/arraystructs/Makefile        |  9 ++++++--
 examples/steel/arraystructs/PointStruct.fst | 15 ++++++++++++-
 3 files changed, 43 insertions(+), 5 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index 4006b9a5cb0..4771487074f 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -107,12 +107,32 @@ let do_something_with_limbs
 
 let do_something_with_precomp
   (a: array 'a U64.t)
-: Steel unit
+: Steel (array_or_null 'a U64.t)
     (varray a)
     (fun _ -> varray a)
     (requires fun _ -> length a == 20)
     (ensures fun _ _ _ -> True)
 = upd a (mk_size_t (U32.uint_to_t 19)) (U64.uint_to_t 0);
+  return (null _ _)
+
+let test_alloc_free
+  ()
+: SteelT unit
+    emp
+    (fun _ -> emp)
+=
+  let a = malloc true (mk_size_t 42ul) in
+  if Steel.C.Array.is_null a
+  then begin
+    change_equal_slprop
+      (varray_or_null a)
+      emp
+  end else begin
+    change_equal_slprop
+      (varray_or_null a)
+      (varray a);
+    free a
+  end;
   return ()
 
 #push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 30"
@@ -127,7 +147,7 @@ let test
   let r = addr_of_struct_field "precomp" p in
   let b = intro_varray r () in
   do_something_with_limbs a;
-  do_something_with_precomp b;
+  let _ = do_something_with_precomp b in
   elim_varray q a ();
   elim_varray r b ();
   unaddr_of_struct_field "precomp" p r;
diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index fcdaed73194..eaf28dc9324 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -13,7 +13,7 @@ world: verify test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \
-	        --already_cached 'Prims,FStar,Steel' \
+	        --already_cached 'Prims,FStar,LowStar,Steel' \
 		$(addprefix --include ,$(INCLUDE_PATH)) \
 		$(OTHERFLAGS)
 
@@ -21,8 +21,13 @@ FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 
 ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
 
+# We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
+# since the KReMLin AST does not have a node for null
+# TODO: This should be removed, and support for Steel.C null should be directly added to KReMLin instead
+SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst
+
 .depend: $(ALL_SOURCE_FILES) Makefile
-	$(FSTAR) --dep full $(ALL_SOURCE_FILES) > $@.tmp
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) > $@.tmp
 	mv $@.tmp $@
 
 depend: .depend
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 019fd0c5dde..ac111085db4 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -180,7 +180,7 @@ let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
   return ()
 
 val swap' (p: ref 'a point point_pcm)
-: Steel unit
+: Steel (ptr 'a point point_pcm)
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
     (requires fun _ -> True)
@@ -198,4 +198,17 @@ let swap' p =
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
+  return (null _ _ _)
+
+let test_malloc_free () : SteelT unit emp (fun _ -> emp) =
+  let c = malloc 42ul in
+  if is_null c _
+  then begin
+    elim_pts_to_view_or_null_null _ c (opt_view _);
+    return ()
+  end else begin
+    elim_pts_to_view_or_null_not_null c (opt_view _);
+    free c
+  end;
   return ()
+

From cf7c282c5cec02aa79e3545f54d7f935e38bb4a2 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 11 Oct 2021 21:18:18 -0700
Subject: [PATCH 274/513] refine_view, rewrite_view

---
 ulib/experimental/Steel.C.Reference.fst | 248 ++++++++++++++++++++++++
 1 file changed, 248 insertions(+)

diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index cb73971cf3a..d2a94c0df49 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -138,3 +138,251 @@ let freeable
   (r: ref a view_t q)
 : Tot prop
 = freeable (r <: Steel.C.Ref.ref a q)
+
+(* Operations on views *)
+
+let refine_view
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type u#b)
+  (#can_view_unit:bool)
+  (vw: sel_view p view can_view_unit)
+  (pr: (view -> Tot prop))
+: Tot (sel_view p (refine view pr) can_view_unit)
+= {
+  to_view_prop = (fun (c: carrier) -> vw.to_view_prop c /\ pr (vw.to_view c));
+  to_view = (fun c -> vw.to_view c <: refine view pr);
+  to_carrier = (fun (v: refine view pr) -> vw.to_carrier v <: carrier);
+  to_carrier_not_one = vw.to_carrier_not_one;
+  to_view_frame = (fun x frame -> vw.to_view_frame x frame);
+}
+
+let intro_refine_view'
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (pr: (view -> Tot prop))
+  (#base: Type)
+  (r: ref base view p)
+: SteelGhost unit opened
+    (pts_to_view r vw)
+    (fun _ -> pts_to_view r (refine_view vw pr))
+    (fun h -> pr (h (pts_to_view r vw)))
+    (fun h _ h' ->
+      let x = h (pts_to_view r vw) in
+      pr x /\
+      x == h' (pts_to_view r (refine_view vw pr))
+    )
+= let g = gget (pts_to_view r vw) in
+  let v = pts_to_view_elim r vw in
+  pts_to_view_intro r v (refine_view vw pr) (Ghost.hide (Ghost.reveal g))
+
+inline_for_extraction
+noextract
+let intro_refine_view
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (pr: (view -> Tot prop))
+  (#base: Type)
+  (r: ref base view p)
+: SteelAtomicBase (ref base (refine view pr) p) false opened Unobservable
+    (pts_to_view r vw)
+    (fun r' -> pts_to_view r' (refine_view vw pr))
+    (fun h -> pr (h (pts_to_view r vw)))
+    (fun h r' h' ->
+      let x = h (pts_to_view r vw) in
+      pr x /\
+      r == r' /\
+      x == h' (pts_to_view r' (refine_view vw pr))
+    )
+= intro_refine_view' vw pr r;
+  let r' : ref base (refine view pr) p = r in
+  change_equal_slprop
+    (pts_to_view r (refine_view vw pr))
+    (pts_to_view r' (refine_view vw pr));
+  return r'
+
+let elim_refine_view'
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (pr: (view -> Tot prop))
+  (#base: Type)
+  (r: ref base (refine view pr) p)
+: SteelGhost unit opened
+    (pts_to_view r (refine_view vw pr))
+    (fun _ -> pts_to_view r vw)
+    (fun h -> True)
+    (fun h _ h' ->
+      let x = h' (pts_to_view r vw) in
+      pr x /\
+      x == h (pts_to_view r (refine_view vw pr))
+    )
+= let g = gget (pts_to_view r (refine_view vw pr)) in
+  let v = pts_to_view_elim r (refine_view vw pr) in
+  pts_to_view_intro r v vw (Ghost.hide (Ghost.reveal g))
+
+inline_for_extraction
+noextract
+let elim_refine_view
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (pr: (view -> Tot prop))
+  (#base: Type)
+  (r: ref base (refine view pr) p)
+: SteelAtomicBase (ref base view p) false opened Unobservable
+    (pts_to_view r (refine_view vw pr))
+    (fun r' -> pts_to_view r' vw)
+    (fun h -> True)
+    (fun h r' h' ->
+      let x = h' (pts_to_view r' vw) in
+      pr x /\
+      r' == r /\
+      x == h (pts_to_view r (refine_view vw pr))
+    )
+= elim_refine_view' vw pr r;
+  let r' : ref base view p = r in
+  change_equal_slprop
+    (pts_to_view r vw)
+    (pts_to_view r' vw);
+  return r'
+
+let rewrite_view
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type u#b)
+  (#can_view_unit:bool)
+  (vw: sel_view p view can_view_unit)
+  (#view' : Type u#c)
+  (f: view -> view')
+  (g: view' -> view)
+  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+: Tot (sel_view p view' can_view_unit)
+= {
+  to_view_prop = vw.to_view_prop;
+  to_view = (fun c -> f (vw.to_view c));
+  to_carrier = (fun v -> vw.to_carrier (g v));
+  to_carrier_not_one = vw.to_carrier_not_one;
+  to_view_frame = (fun x frame -> vw.to_view_frame (g x) frame);
+}
+
+let intro_rewrite_view'
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (#view' : Type)
+  (f: view -> view')
+  (g: view' -> view)
+  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (#base: _)
+  (r: ref base view p)
+  (x' : Ghost.erased view')
+: SteelGhost unit opened
+    (pts_to_view r vw)
+    (fun _ -> pts_to_view r (rewrite_view vw f g prf))
+    (fun h -> h (pts_to_view r vw) == g x')
+    (fun h _ h' ->
+      f (h (pts_to_view r vw)) == Ghost.reveal x' /\
+      h' (pts_to_view r (rewrite_view vw f g prf)) == Ghost.reveal x'
+    )
+= let v = pts_to_view_elim r vw in
+  pts_to_view_intro r v (rewrite_view vw f g prf) x'
+
+inline_for_extraction
+noextract
+let intro_rewrite_view
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (#view' : Type)
+  (f: view -> view')
+  (g: view' -> view)
+  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (#base: _)
+  (r: ref base view p)
+  (x' : Ghost.erased view')
+: SteelAtomicBase (ref base view' p) false opened Unobservable
+    (pts_to_view r vw)
+    (fun r' -> pts_to_view r' (rewrite_view vw f g prf))
+    (fun h -> h (pts_to_view r vw) == g x')
+    (fun h r' h' ->
+      f (h (pts_to_view r vw)) == Ghost.reveal x' /\
+      h' (pts_to_view r' (rewrite_view vw f g prf)) == Ghost.reveal x'
+    )
+= intro_rewrite_view' vw f g prf r x';
+  let r' : ref base view' p = r in
+  change_equal_slprop
+    (pts_to_view r (rewrite_view vw f g prf))
+    (pts_to_view r' (rewrite_view vw f g prf));
+  return r'
+
+let elim_rewrite_view'
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (#view' : Type)
+  (f: view -> view')
+  (g: view' -> view)
+  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (#base: _)
+  (r: ref base view' p)
+: SteelGhost unit opened
+    (pts_to_view r (rewrite_view vw f g prf))
+    (fun _ -> pts_to_view r vw)
+    (fun _ -> True)
+    (fun h _ h' ->
+      let x = h (pts_to_view r (rewrite_view vw f g prf)) in
+      let x' = h' (pts_to_view r vw) in
+      Ghost.reveal x' == g (Ghost.reveal x) /\
+      f (Ghost.reveal x') == Ghost.reveal x
+    )
+= let gv = gget (pts_to_view r (rewrite_view vw f g prf)) in
+  let v = pts_to_view_elim r (rewrite_view vw f g prf) in
+  pts_to_view_intro r v vw (g gv)
+
+inline_for_extraction
+noextract
+let elim_rewrite_view
+  (#opened: _)
+  (#carrier: Type u#a)
+  (#p: pcm carrier)
+  (#view: Type)
+  (vw: sel_view p view false)
+  (#view' : Type)
+  (f: view -> view')
+  (g: view' -> view)
+  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (#base: _)
+  (r: ref base view' p)
+: SteelAtomicBase (ref base view p) false opened Unobservable
+    (pts_to_view r (rewrite_view vw f g prf))
+    (fun r' -> pts_to_view r' vw)
+    (fun _ -> True)
+    (fun h r' h' ->
+      let x = h (pts_to_view r (rewrite_view vw f g prf)) in
+      let x' = h' (pts_to_view r' vw) in
+      Ghost.reveal x' == g (Ghost.reveal x) /\
+      f (Ghost.reveal x') == Ghost.reveal x
+    )
+= elim_rewrite_view' vw f g prf r;
+  let r' : ref base view p = r in
+  change_equal_slprop
+    (pts_to_view r vw)
+    (pts_to_view r' vw);
+  return r'

From 53f665602eac34471ebbce0f6d7bd2b8121d320b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 10:38:04 -0700
Subject: [PATCH 275/513] Steel.C.StdInt -> Steel.C.StdInt.Base

---
 ulib/experimental/Steel.C.Array.fsti                            | 2 +-
 .../{Steel.C.StdInt.fst => Steel.C.StdInt.Base.fst}             | 2 +-
 .../{Steel.C.StdInt.fsti => Steel.C.StdInt.Base.fsti}           | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename ulib/experimental/{Steel.C.StdInt.fst => Steel.C.StdInt.Base.fst} (97%)
 rename ulib/experimental/{Steel.C.StdInt.fsti => Steel.C.StdInt.Base.fsti} (98%)

diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 37ac86f26a9..01720edfd3b 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -15,7 +15,7 @@
 *)
 
 module Steel.C.Array
-include Steel.C.StdInt
+include Steel.C.StdInt.Base
 open Steel.Memory
 open Steel.FractionalPermission
 open Steel.Effect
diff --git a/ulib/experimental/Steel.C.StdInt.fst b/ulib/experimental/Steel.C.StdInt.Base.fst
similarity index 97%
rename from ulib/experimental/Steel.C.StdInt.fst
rename to ulib/experimental/Steel.C.StdInt.Base.fst
index 5ba825859b1..9f95f9ae19b 100644
--- a/ulib/experimental/Steel.C.StdInt.fst
+++ b/ulib/experimental/Steel.C.StdInt.Base.fst
@@ -1,4 +1,4 @@
-module Steel.C.StdInt
+module Steel.C.StdInt.Base
 
 module U64 = FStar.UInt64
 module I64 = FStar.Int64
diff --git a/ulib/experimental/Steel.C.StdInt.fsti b/ulib/experimental/Steel.C.StdInt.Base.fsti
similarity index 98%
rename from ulib/experimental/Steel.C.StdInt.fsti
rename to ulib/experimental/Steel.C.StdInt.Base.fsti
index ec0625925bb..30d8d94cd0a 100644
--- a/ulib/experimental/Steel.C.StdInt.fsti
+++ b/ulib/experimental/Steel.C.StdInt.Base.fsti
@@ -1,4 +1,4 @@
-module Steel.C.StdInt
+module Steel.C.StdInt.Base
 
 open FStar.Mul
 

From 70ad434d72f0fb5c22ed6a8cf9327750f3be9fe8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 11:02:56 -0700
Subject: [PATCH 276/513] mk_size_t is not primitive

---
 src/extraction/FStar.Extraction.Kremlin.fs | 5 -----
 ulib/experimental/Steel.C.StdInt.Base.fsti | 1 +
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 68aa73e0fb1..7bccb18039c 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1339,11 +1339,6 @@ IsNull nodes should be added to the KReMLin AST *)
     when string_of_mlpath p = "Steel.C.Array.joinc" ->
       translate_expr env al
 
-  (* Operations on Steel.C.StdInt *)
-  | MLE_App ({expr=MLE_Name p}, [i])
-    when string_of_mlpath p = "Steel.C.StdInt.mk_size_t" ->
-      translate_expr env i
-
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
     when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
     translate_expr env e
diff --git a/ulib/experimental/Steel.C.StdInt.Base.fsti b/ulib/experimental/Steel.C.StdInt.Base.fsti
index 30d8d94cd0a..b98d9d08541 100644
--- a/ulib/experimental/Steel.C.StdInt.Base.fsti
+++ b/ulib/experimental/Steel.C.StdInt.Base.fsti
@@ -19,6 +19,7 @@ val size_v_inj (x1 x2: size_t) : Lemma
   (size_v x1 == size_v x2 ==> x1 == x2)
   [SMTPat (size_v x1); SMTPat (size_v x2)]
 
+inline_for_extraction noextract
 val mk_size_t (x: U32.t) : Pure size_t
   (requires True)
   (ensures (fun y -> size_v y == U32.v x))

From 883f2b210b0b62ea3f605ac83c0b2dfeb4a9d314 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 11:47:15 -0700
Subject: [PATCH 277/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index bf66983b42b..c75becef688 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -3427,16 +3427,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___7 = "Steel.C.Array.joinc" -> translate_expr env1 al
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           i::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.StdInt.mk_size_t" -> translate_expr env1 i
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =

From 2d2be2679804c46a8e57eef3fec27717a2884705 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 11:50:30 -0700
Subject: [PATCH 278/513] extract size_t as U32.t, as required by KReMLin

---
 ulib/experimental/Steel.C.StdInt.Base.fst | 26 +++++++++++++----------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/ulib/experimental/Steel.C.StdInt.Base.fst b/ulib/experimental/Steel.C.StdInt.Base.fst
index 9f95f9ae19b..457aa6ac144 100644
--- a/ulib/experimental/Steel.C.StdInt.Base.fst
+++ b/ulib/experimental/Steel.C.StdInt.Base.fst
@@ -1,16 +1,20 @@
 module Steel.C.StdInt.Base
 
-module U64 = FStar.UInt64
 module I64 = FStar.Int64
 module Cast = FStar.Int.Cast
 
-let size_t = U64.t
+(* FIXME: this could be defined as U64.t, but KReMLin currently demands U32.t.
+   NS: A long-term proposal would be to make KReMLin platform-aware and introduce
+   a platform switch in this library here.
+*)
+
+let size_t = U32.t
 
 let size_precond x =
-  FStar.UInt.fits x U64.n == true
+  FStar.UInt.fits x U32.n == true
 
 let size_v x =
-  U64.v x
+  U32.v x
 
 let size_v_inj (x1 x2: size_t) : Lemma
   (size_v x1 == size_v x2 ==> x1 == x2)
@@ -20,22 +24,22 @@ let size_v_inj (x1 x2: size_t) : Lemma
 let mk_size_t (x: U32.t) : Pure size_t
   (requires True)
   (ensures (fun y -> size_v y == U32.v x))
-= Cast.uint32_to_uint64 x
+= x
 
 let int_to_size_t x =
-  U64.uint_to_t x
+  U32.uint_to_t x
 
 let size_precond_le x y = ()
 
-let size_add x y = x `U64.add` y
+let size_add x y = x `U32.add` y
 
-let size_sub x y = x `U64.sub` y
+let size_sub x y = x `U32.sub` y
 
-let size_mul x y = x `U64.mul` y
+let size_mul x y = x `U32.mul` y
 
-let size_div x y = x `U64.div` y
+let size_div x y = x `U32.div` y
 
-let size_le x y = x `U64.lte` y
+let size_le x y = x `U32.lte` y
 
 let ptrdiff_t = I64.t
 

From b763cf52ea94e96e741faee3271eee038b746406 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 11:53:12 -0700
Subject: [PATCH 279/513] move integer typedefs to Steel.C.StdInt

---
 examples/steel/arraystructs/HaclExample.fst | 11 +----
 examples/steel/arraystructs/PointStruct.fst | 19 ++------
 examples/steel/arraystructs/ScalarUnion.fst | 27 ++---------
 ulib/experimental/Steel.C.StdInt.fst        | 52 +++++++++++++++++++++
 4 files changed, 61 insertions(+), 48 deletions(-)
 create mode 100644 ulib/experimental/Steel.C.StdInt.fst

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index 4771487074f..ab5d26a5d14 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -20,6 +20,7 @@ open Steel.C.Typenat
 open Steel.C.Typestring
 
 module U64 = FStar.UInt64
+module I = Steel.C.StdInt
 
 (** In this file we demonstrate how Steel could be used to manipulate the following data type used in Hacl*:
       https://github.com/project-everest/hacl-star/blob/master/code/poly1305/Hacl.Impl.Poly1305.fsti#L18
@@ -30,16 +31,6 @@ module U64 = FStar.UInt64
     See PointStruct.fst for more detailed explanations of the various definitions needed below.
 *)
 
-[@@c_typedef]
-noextract inline_for_extraction
-let u64: typedef = {
-  carrier = option U64.t;
-  pcm = opt_pcm #U64.t;
-  view_type = U64.t;
-  view = opt_view U64.t;
-  is_unit = (fun x -> None? x);
-}
-
 module T = FStar.Tactics
 
 noextract inline_for_extraction
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index ac111085db4..e18d92dd491 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -18,21 +18,10 @@ open Steel.C.Typestring
 
 module U32 = FStar.UInt32
 
-unfold let int' = FStar.UInt32.t
-
 (** A struct is encoded by what amounts to a list of (field name, typedef) pairs.
     In this example, we define a struct named point with two u32 fields; to do so
-    we need a typedef for u32s. *)
-
-[@@c_typedef]
-noextract inline_for_extraction
-let c_int': typedef = {
-  carrier = option int';
-  pcm = opt_pcm #int';
-  view_type = int';
-  view = opt_view int';
-  is_unit = (fun x -> None? x);
-}
+    we need a typedef for u32s, which can be found in Steel.C.StdInt. *)
+module I = Steel.C.StdInt
 
 module T = FStar.Tactics
 
@@ -60,8 +49,8 @@ let point_tag = normalize (mk_string_t "PointStruct.point")
 [@@c_struct]
 noextract inline_for_extraction
 let point_fields: c_fields =
-  fields_cons "x" c_int' (
-  fields_cons "y" c_int' (
+  fields_cons "x" I.uint32 (
+  fields_cons "y" I.uint32 (
   fields_nil))
 
 (** The type of (struct point) values *)
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index cf7263fc746..a83f7f4f8fb 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -24,27 +24,8 @@ module U16 = FStar.UInt16
 (** A union is encoded by what amounts to a list of (field name,
     typedef) pairs.  In this example, we define a union named
     u32_or_u16 with one u32 field and one u16 field; to do so we need
-    typedefs for u32s and u16s. *)
-
-[@@c_typedef]
-noextract inline_for_extraction
-let u32: typedef = {
-  carrier = option U32.t;
-  pcm = opt_pcm #U32.t;
-  view_type = U32.t;
-  view = opt_view U32.t;
-  is_unit = (fun x -> None? x);
-}
-
-[@@c_typedef]
-noextract inline_for_extraction
-let u16: typedef = {
-  carrier = option U16.t;
-  pcm = opt_pcm #U16.t;
-  view_type = U16.t;
-  view = opt_view U16.t;
-  is_unit = (fun x -> None? x);
-}
+    typedefs for u32s and u16s, which can be found in Steel.C.StdInt. *)
+module I = Steel.C.StdInt
 
 module T = FStar.Tactics
 
@@ -60,8 +41,8 @@ let u32_or_u16_tag = normalize (mk_string_t "ScalarUnion.u32_or_u16")
 [@@c_struct]
 noextract inline_for_extraction
 let u32_or_u16_fields: c_fields =
-  fields_cons "as_u32" u32 (
-  fields_cons "as_u16" u16 (
+  fields_cons "as_u32" I.uint32 (
+  fields_cons "as_u16" I.uint16 (
   fields_nil))
 
 (** The type of (union u32_or_u16) values. *)
diff --git a/ulib/experimental/Steel.C.StdInt.fst b/ulib/experimental/Steel.C.StdInt.fst
new file mode 100644
index 00000000000..49f2dbaac5d
--- /dev/null
+++ b/ulib/experimental/Steel.C.StdInt.fst
@@ -0,0 +1,52 @@
+module Steel.C.StdInt
+include Steel.C.StdInt.Base
+
+open Steel.C.Fields
+open Steel.C.Typedef
+open Steel.C.Opt
+
+module U16 = FStar.UInt16
+module U32 = FStar.UInt32
+module U64 = FStar.UInt64
+
+[@@c_typedef]
+noextract inline_for_extraction
+let size: typedef = {
+  carrier = option size_t;
+  pcm = opt_pcm #size_t;
+  view_type = size_t;
+  view = opt_view size_t;
+  is_unit = (fun x -> None? x);
+}
+
+[@@c_typedef]
+noextract inline_for_extraction
+let uint16: typedef = {
+  carrier = option U16.t;
+  pcm = opt_pcm #U16.t;
+  view_type = U16.t;
+  view = opt_view U16.t;
+  is_unit = (fun x -> None? x);
+}
+
+
+[@@c_typedef]
+noextract inline_for_extraction
+let uint32: typedef = {
+  carrier = option U32.t;
+  pcm = opt_pcm #U32.t;
+  view_type = U32.t;
+  view = opt_view U32.t;
+  is_unit = (fun x -> None? x);
+}
+
+[@@c_typedef]
+noextract inline_for_extraction
+let uint64: typedef = {
+  carrier = option U64.t;
+  pcm = opt_pcm #U64.t;
+  view_type = U64.t;
+  view = opt_view U64.t;
+  is_unit = (fun x -> None? x);
+}
+

From daac1d6e43cdf5943557980358d3ae2939ad9ef6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 12:16:47 -0700
Subject: [PATCH 280/513] refine_typedef, rewrite_typedef

---
 ulib/experimental/Steel.C.Fields.fsti | 35 +++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/ulib/experimental/Steel.C.Fields.fsti b/ulib/experimental/Steel.C.Fields.fsti
index 5381f684473..8797a220d9f 100644
--- a/ulib/experimental/Steel.C.Fields.fsti
+++ b/ulib/experimental/Steel.C.Fields.fsti
@@ -130,3 +130,38 @@ unfold let simplify_typedefs =
      `%Mktypedef?.view_type;
      `%Mktypedef?.view];
    iota; zeta; primops]
+
+(* Operations on views *)
+
+open Steel.C.Reference
+
+[@@c_typedef]
+inline_for_extraction noextract
+let refine_typedef
+  (t: typedef)
+  (p: (t.view_type -> Tot prop))
+: Tot typedef
+= {
+  carrier = t.carrier;
+  pcm = t.pcm;
+  view_type = Steel.C.Ref.refine t.view_type p;
+  view = refine_view t.view p;
+  is_unit = t.is_unit;
+}
+
+[@@c_typedef]
+inline_for_extraction noextract
+let rewrite_typedef
+  (t: typedef)
+  (#view': Type)
+  (f: t.view_type -> Tot view')
+  (g: view' -> Tot t.view_type)
+  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+: Tot typedef
+= {
+  carrier = t.carrier;
+  pcm = t.pcm;
+  view_type = view';
+  view = rewrite_view t.view f g prf;
+  is_unit = t.is_unit;
+}

From 39495afbffaac7e2ad7c291404e46314fd98ca8b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 14:41:31 -0700
Subject: [PATCH 281/513] define opt_typedef and use it as a shortcut for
 integer typedefs

---
 ulib/experimental/Steel.C.Fields.fsti | 10 ++++++++
 ulib/experimental/Steel.C.StdInt.fst  | 34 ++++-----------------------
 2 files changed, 14 insertions(+), 30 deletions(-)

diff --git a/ulib/experimental/Steel.C.Fields.fsti b/ulib/experimental/Steel.C.Fields.fsti
index 8797a220d9f..1f5b06235f6 100644
--- a/ulib/experimental/Steel.C.Fields.fsti
+++ b/ulib/experimental/Steel.C.Fields.fsti
@@ -133,6 +133,16 @@ unfold let simplify_typedefs =
 
 (* Operations on views *)
 
+[@@c_typedef]
+noextract inline_for_extraction
+let opt_typedef (t: Type0): typedef = {
+  carrier = option t;
+  pcm = opt_pcm #t;
+  view_type = t;
+  view = opt_view t;
+  is_unit = (fun x -> None? x);
+}
+
 open Steel.C.Reference
 
 [@@c_typedef]
diff --git a/ulib/experimental/Steel.C.StdInt.fst b/ulib/experimental/Steel.C.StdInt.fst
index 49f2dbaac5d..f54a56d8888 100644
--- a/ulib/experimental/Steel.C.StdInt.fst
+++ b/ulib/experimental/Steel.C.StdInt.fst
@@ -11,42 +11,16 @@ module U64 = FStar.UInt64
 
 [@@c_typedef]
 noextract inline_for_extraction
-let size: typedef = {
-  carrier = option size_t;
-  pcm = opt_pcm #size_t;
-  view_type = size_t;
-  view = opt_view size_t;
-  is_unit = (fun x -> None? x);
-}
+let size: typedef = opt_typedef size_t
 
 [@@c_typedef]
 noextract inline_for_extraction
-let uint16: typedef = {
-  carrier = option U16.t;
-  pcm = opt_pcm #U16.t;
-  view_type = U16.t;
-  view = opt_view U16.t;
-  is_unit = (fun x -> None? x);
-}
-
+let uint16: typedef = opt_typedef U16.t
 
 [@@c_typedef]
 noextract inline_for_extraction
-let uint32: typedef = {
-  carrier = option U32.t;
-  pcm = opt_pcm #U32.t;
-  view_type = U32.t;
-  view = opt_view U32.t;
-  is_unit = (fun x -> None? x);
-}
+let uint32: typedef = opt_typedef U32.t
 
 [@@c_typedef]
 noextract inline_for_extraction
-let uint64: typedef = {
-  carrier = option U64.t;
-  pcm = opt_pcm #U64.t;
-  view_type = U64.t;
-  view = opt_view U64.t;
-  is_unit = (fun x -> None? x);
-}
-
+let uint64: typedef = opt_typedef U64.t

From 6696a6b367cbe760cb7d9f89e2ff63f52b66b1b2 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 12 Oct 2021 16:31:38 -0700
Subject: [PATCH 282/513] view_type_of_typedef

---
 ulib/experimental/Steel.C.Typedef.fst | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/ulib/experimental/Steel.C.Typedef.fst b/ulib/experimental/Steel.C.Typedef.fst
index 7c4666f170b..351b717375f 100644
--- a/ulib/experimental/Steel.C.Typedef.fst
+++ b/ulib/experimental/Steel.C.Typedef.fst
@@ -20,3 +20,10 @@ noeq type typedef = {
   (** A way to decide whether a given element of the PCM is unit (needed to determine the case of a union) *)
   is_unit: x:carrier -> b:bool{b <==> x == one pcm};
 } 
+
+inline_for_extraction noextract
+let view_type_of_typedef
+  (t: typedef)
+: Tot Type0
+= match t with
+  | { view_type = t';  } -> t'

From 6677e2fefd6c702a38e08ac5d4b17ffaa02576b5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 13 Oct 2021 18:44:52 -0700
Subject: [PATCH 283/513] make array `to` Ghost

---
 ulib/experimental/Steel.C.Array.fst  | 75 +++++++++++++++-------------
 ulib/experimental/Steel.C.Array.fsti | 44 +++++++++++++---
 2 files changed, 76 insertions(+), 43 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 0a80c20bd08..69308a6ba98 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -170,7 +170,7 @@ type array' base t = {
   base_len: Ghost.erased size_t;
   base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
   from: size_t;
-  to: size_t; // must be Tot because of array_small_to_large below
+  to: Ghost.erased size_t;
   prf: squash (
     size_v base_len >= 0 /\
     size_v from <= size_v to /\
@@ -178,7 +178,7 @@ type array' base t = {
   );
 }
 
-let len' (#base: _) (#t: _) (a: array' base t) : Tot size_t =
+let len' (#base: _) (#t: _) (a: array' base t) : GTot size_t =
   a.to `size_sub` a.from
 
 let array_or_null base t = option (array' base t)
@@ -906,7 +906,7 @@ let array_as_ref_conn
   (#base: Type)
   (#t: Type)
   (a: array' base t)
-: Tot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len' a)))
+: GTot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len' a)))
 = array_conn t a.base_len a.from a.to a.prf
 
 let array_as_ref'
@@ -1036,7 +1036,7 @@ let adjacent r1 r2 =
   let Some r2 = r2 in
   r1.base_len == r2.base_len /\
   r1.base_ref == r2.base_ref /\
-  r1.to == r2.from
+  Ghost.reveal r1.to == r2.from
 
 val t_merge
   (#base: Type)
@@ -1158,6 +1158,7 @@ let array_as_ref_split_left
   array_conn_compose t x.base_len x.from x.to zero_size i;
   Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len' x) zero_size i ())
 
+#restart-solver
 let array_as_ref_split_right
   (base: Type)
   (t: Type)
@@ -1172,7 +1173,7 @@ let array_as_ref_split_right
   array_conn_compose t x'.base_len x'.from x'.to i (len x);
   Steel.C.Ref.ref_focus_comp x'.base_ref (array_as_ref_conn x') (array_conn t (len x) i (len x) ())
 
-val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
   : SteelGhost (array base t `gpair` array base t) opened
           (varray a)
           (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
@@ -1191,7 +1192,7 @@ val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
 #push-options "--z3rlimit 128"
 
 #restart-solver
-let split'
+let split_
   #j #base #t x i
 =
   let gv = gget (varray x) in
@@ -1298,17 +1299,27 @@ let split'
     (varray (GPair?.snd res));
   res
 
-let split
+let split'
   #_ #_ #t a i
 =
   let g = gget (varray a) in
   Seq.lemma_split #t (Ghost.reveal g) (size_v i);
-  split' a i
+  split_ a i
 
 let split_left
-  a i
+  a al _
 =
-  return (fst (tsplit a i))
+  let res = Some ({
+    base_len = (Some?.v a).base_len;
+    base_ref = (Some?.v a).base_ref;
+    from = (Some?.v a).from;
+    to = (Some?.v al).to;
+    prf = ();
+  }) in
+  change_equal_slprop
+    (varray al)
+    (varray res);
+  return res
 
 let split_right
   a i
@@ -1361,7 +1372,7 @@ let array_as_one_ref_conn'
   (requires (size_v (len' r) == 1))
   (ensures (fun _ -> True))
 =
-  array_conn t r.base_len r.from r.to () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
+  array_conn t r.base_len r.from (r.from `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
 
 let array_as_one_ref_conn'_small_to_large
   (#base: Type) (#t:Type0) (r:array' base t)
@@ -1663,24 +1674,20 @@ let seq_equal_1
 let index
   #_ #t r i
 =
-  let rr = split_right r i in
-  let rs = split r i in
+  let rr = split r i () in
+  let rrr = split rr one_size () in
   change_equal_slprop
-    (varray (GPair?.snd rs))
-    (varray rr);
-  let rrl = split_left rr one_size in
-  let rrs = split rr one_size in
-  change_equal_slprop
-    (varray (GPair?.fst rrs))
-    (varray rrl);
+    (varray rrr)
+    (varray (Ghost.reveal (Ghost.hide rrr)));
+  let rrl = split_left rr (GPair?.fst (gsplit rr one_size)) rrr in
   let grl = gget (varray rrl) in
   let r0 = ref_of_array rrl in
   let res = Steel.C.Opt.ref_opt_read r0 in
   array_of_ref rrl r0;
   let grl' = gget (varray rrl) in
   seq_equal_1 t (Ghost.reveal grl) (Ghost.reveal grl');
-  let rr' = join' rrl (GPair?.snd rrs) in
-  let r' = join' (GPair?.fst rs) rr' in
+  let rr' = join' rrl (Ghost.reveal (Ghost.hide rrr)) in
+  let r' = join' (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit r i)))) rr' in
   change_equal_slprop
     (varray r')
     (varray r);
@@ -1708,26 +1715,22 @@ let seq_append_append_upd
 let upd
   #_ #t r i x
 =
-  let rr = split_right r i in
-  let rs = split r i in
-  let s1 = gget (varray (GPair?.fst rs)) in
-  change_equal_slprop
-    (varray (GPair?.snd rs))
-    (varray rr);
-  let rrl = split_left rr one_size in
-  let rrs = split rr one_size in
-  let s3 = gget (varray (GPair?.snd rrs)) in
+  let rr = split r i () in
+  let rrr = split rr one_size () in
+  let s3 = gget (varray rrr) in
   change_equal_slprop
-    (varray (GPair?.fst rrs))
-    (varray rrl);
+    (varray rrr)
+    (varray (Ghost.reveal (Ghost.hide rrr)));
+  let rrl = split_left rr (GPair?.fst (gsplit rr one_size)) rrr in
+  let s1 = gget (varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit r i))))) in
   let s2 = gget (varray rrl) in
   let r0 = ref_of_array rrl in
   Steel.C.Opt.ref_opt_write r0 x;
   array_of_ref rrl r0;
   let s2' = gget (varray rrl) in
   seq_append_append_upd t (size_v i) x s1 s2 s2' s3;
-  let rr' = join' rrl (GPair?.snd rrs) in
-  let r' = join' (GPair?.fst rs) rr' in
+  let rr' = join' rrl (Ghost.reveal (Ghost.hide rrr)) in
+  let r' = join' (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit r i)))) rr' in
   change_equal_slprop
     (varray r')
     (varray r)
@@ -1740,7 +1743,7 @@ let freeable
   Steel.C.Ref.freeable a'.base_ref /\
   size_v a'.base_len > 0 /\
   a'.from == zero_size /\
-  a'.to == Ghost.reveal a'.base_len
+  a'.to == a'.base_len
 
 #restart-solver
 let array_to_carrier_refine
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 01720edfd3b..7a64446df58 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -189,7 +189,7 @@ val gsplit
     length rl == size_v i
   ))
 
-val split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
   : SteelGhost (array base t `gpair` array base t) opened
           (varray a)
           (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
@@ -205,7 +205,20 @@ val split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
             s == sl `Seq.append` sr
           )
 
-val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
+  (al ar: Ghost.erased (array base t))
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray al)
+          (fun res -> varray res)
+          (fun _ ->
+            merge_into al ar a
+          )
+          (fun h res h' ->
+            res == Ghost.reveal al /\
+            h' (varray res) == h (varray al)
+          )
+
+val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
@@ -213,19 +226,36 @@ val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
           (fun h res h' ->
             h' (varray a) == h (varray a) /\
             size_v i <= length a /\
-            res == GPair?.fst (gsplit a i)
+            res == GPair?.snd (gsplit a i)
           )
 
-val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+inline_for_extraction
+let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a))
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
-          (fun _ -> varray a)
+          (fun res -> varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i))))
+          `star` varray res)
           (fun _ -> size_v i <= length a)
           (fun h res h' ->
-            h' (varray a) == h (varray a) /\
+            let s = h (varray a) in
+            let sl = h' (varray (GPair?.fst (gsplit a i))) in
+            let sr = h' (varray res) in
             size_v i <= length a /\
-            res == GPair?.snd (gsplit a i)
+            res == GPair?.snd (gsplit a i) /\
+            sl == Seq.slice s 0 (size_v i) /\
+            sr == Seq.slice s (size_v i) (length a) /\
+            s == sl `Seq.append` sr
           )
+=
+  let sr = split_right a i in
+  let g = split' a i in
+  change_equal_slprop
+    (varray (GPair?.fst g))
+    (varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i)))));
+  change_equal_slprop
+    (varray (GPair?.snd g))
+    (varray sr);
+  return sr
 
 val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
   : SteelGhost (Ghost.erased (array base t)) opened

From 26790645e90e3f3c9a0233fd2a750b19cf5a78f4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 14 Oct 2021 16:45:23 -0700
Subject: [PATCH 284/513] post-merge

---
 ulib/experimental/Steel.C.Array.fst | 20 ++++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 69308a6ba98..377da9cc526 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1451,8 +1451,14 @@ let ref_of_array_ghost #inames #base #t x sq =
     _
     (Ghost.reveal v z);
   Steel.C.Ref.pts_to_view_intro
-    _
-    _
+    #inames
+    #base
+    #(option t)
+    #(Steel.C.Opt.opt_pcm #t)
+    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn base t))
+    (Ghost.reveal v z)
+    #t
+    #false
     (Steel.C.Opt.opt_view t)
     (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
   change_equal_slprop
@@ -1496,8 +1502,14 @@ let ref_of_array0 #base #t x sq v0 =
   g_ref_of_array'_correct x;
   let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus x'.base_ref (array_as_one_ref_conn' x') s (Ghost.reveal v zero_size) in
   Steel.C.Ref.pts_to_view_intro
-    _
-    _
+    #_
+    #base
+    #(option t)
+    #(Steel.C.Opt.opt_pcm #t)
+    r
+    (Ghost.reveal v zero_size)
+    #t
+    #false
     (Steel.C.Opt.opt_view t)
     (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
   intro_vrefine

From c5d819541a50aee1d6ae54bfe13b5b582fe9e288 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 14 Oct 2021 19:02:34 -0700
Subject: [PATCH 285/513] implement array splitting with a hidden permission
 (to handle zero-sized arrays)

---
 ulib/experimental/Steel.C.Array.fst  | 141 +++++++++++++++++++--------
 ulib/experimental/Steel.C.Array.fsti |  42 +++++---
 2 files changed, 128 insertions(+), 55 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 377da9cc526..2e83ee58dd3 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -171,6 +171,8 @@ type array' base t = {
   base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
   from: size_t;
   to: Ghost.erased size_t;
+  perm_ref: Steel.Reference.ghost_ref unit;
+  perm_val: Steel.FractionalPermission.perm;
   prf: squash (
     size_v base_len >= 0 /\
     size_v from <= size_v to /\
@@ -938,11 +940,19 @@ let varray0
     #(size_v (len x) = 0)
     (array_view' t (len x))
 
-let varray_hp #base #t x = hp_of (varray0 #base #t x)
+[@@__steel_reduce__]
+let varray9
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: Tot vprop
+= (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref  (Some?.v x).perm_val) `vrewrite` fst
+
+let varray_hp #base #t x = hp_of (varray9 #base #t x)
 
 #push-options "--debug Steel.C.Array --debug_level Extreme"
 
-let varray_sel #base #t x = sel_of (varray0 #base #t x)
+let varray_sel #base #t x = sel_of (varray9 #base #t x)
 
 #pop-options
 
@@ -952,12 +962,15 @@ let intro_varray1
   (#t: Type)
   (x: array base t)
 : SteelGhost unit inames
-    (varray0 x)
+    (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
     (fun _ -> varray x)
     (fun _ -> True)
     (fun h _ h' -> h' (varray x) == h (varray0 x))
-= change_slprop_rel
-    (varray0 x)
+= intro_vrewrite
+    (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
+    fst;
+  change_slprop_rel
+    ((varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val) `vrewrite` fst)
     (varray x)
     (fun u v -> u == v)
     (fun m -> ())
@@ -969,37 +982,48 @@ let elim_varray1
   (x: array base t)
 : SteelGhost unit inames
     (varray x)
-    (fun _ -> varray0 x)
+    (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
     (fun _ -> True)
     (fun h _ h' -> h' (varray0 x) == h (varray x))
 = change_slprop_rel
     (varray x)
-    (varray0 x)
+    ((varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val) `vrewrite` fst)
     (fun u v -> u == v)
-    (fun m -> ())
+    (fun m -> ());
+  elim_vrewrite
+    (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
+    fst
 
-val mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-: Pure (array base t)
-  (requires (size_v n > 0))
-  (ensures (fun a -> len a == Ghost.reveal n))
-
-let mk_array #base #t #n r =
-  Some ({
-    base_len = n;
-    base_ref = r;
-    from = mk_size_t 0ul;
-    to = n;
-    prf = ();
-  })
+let g_mk_array #base #t #n r a = 
+  let Some a' = a in
+  size_v n > 0 /\
+  Ghost.reveal a'.base_len == n /\
+  a'.base_ref == r /\
+  a'.from == mk_size_t 0ul /\
+  Ghost.reveal a'.to == n /\
+  a'.perm_val == Steel.FractionalPermission.full_perm
 
-let g_mk_array r = mk_array r
+let g_mk_array_weak r a = ()
 
 #push-options "--z3rlimit 32"
 
 let intro_varray
   #base #t #n r sq
 =
-  let res = mk_array r in
+  let perm_ref = Steel.Reference.ghost_alloc #unit () in
+  let res = Some ({
+    base_len = n;
+    base_ref = r;
+    from = mk_size_t 0ul;
+    to = n;
+    perm_ref = perm_ref;
+    perm_val = Steel.FractionalPermission.full_perm;
+    prf = ();
+  })
+  in
+  change_equal_slprop
+    (Steel.Reference.ghost_vptr perm_ref)
+    (Steel.Reference.ghost_vptrp ((Some?.v res).perm_ref) ((Some?.v res).perm_val));
   assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
   assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
@@ -1016,7 +1040,7 @@ let intro_varray
 let elim_varray
   #_ #base #t #n r res sq
 =
-  assert (res == g_mk_array r);
+  assert (g_mk_array r res);
   assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
   assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
@@ -1027,7 +1051,12 @@ let elim_varray
   elim_varray1 res;
   change_equal_slprop
     (varray0 res)
-    (r `Steel.C.Ref.pts_to_view` _)
+    (r `Steel.C.Ref.pts_to_view` _);
+  let perm_ref = (Some?.v res).perm_ref in
+  change_equal_slprop
+    (Steel.Reference.ghost_vptrp ((Some?.v res).perm_ref) ((Some?.v res).perm_val))
+    (Steel.Reference.ghost_vptr perm_ref);
+  Steel.Reference.ghost_free perm_ref
 
 #pop-options
 
@@ -1036,6 +1065,7 @@ let adjacent r1 r2 =
   let Some r2 = r2 in
   r1.base_len == r2.base_len /\
   r1.base_ref == r2.base_ref /\
+  r1.perm_ref == r2.perm_ref /\
   Ghost.reveal r1.to == r2.from
 
 val t_merge
@@ -1054,6 +1084,8 @@ let t_merge r1 r2 =
     base_ref = r1.base_ref;
     from = r1.from;
     to = r2.to;
+    perm_ref = r1.perm_ref;
+    perm_val = r1.perm_val `Steel.FractionalPermission.sum_perm` r2.perm_val;
     prf = ();
   })
 
@@ -1080,12 +1112,16 @@ let tsplit r i =
     base_ref = r.base_ref;
     from = r.from;
     to = r.from `size_add` i;
+    perm_ref = r.perm_ref;
+    perm_val = Steel.FractionalPermission.half_perm r.perm_val;
     prf = ()
   }), Some ({
     base_len = r.base_len;
     base_ref = r.base_ref;
     from = r.from `size_add` i;
     to = r.to;
+    perm_ref = r.perm_ref;
+    perm_val = Steel.FractionalPermission.half_perm r.perm_val;
     prf = ()
   }))
 
@@ -1253,6 +1289,10 @@ let split_
   change_equal_slprop // necessary, otherwise F* goes off rails
     (array_as_ref xl `Steel.C.Ref.pts_to_view` _)
     (varray0 xl);
+  Steel.Reference.ghost_share (Some?.v x).perm_ref;
+  change_equal_slprop
+    (Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Steel.FractionalPermission.half_perm (Some?.v x).perm_val))
+    (Steel.Reference.ghost_vptrp (Some?.v xl).perm_ref (Some?.v xl).perm_val);
   intro_varray1 xl;
   let cr : (cr: Steel.C.Connection.connection
     (array_pcm t (len x))
@@ -1289,6 +1329,9 @@ let split_
   change_equal_slprop // necessary, otherwise F* goes off rails
     (array_as_ref xr `Steel.C.Ref.pts_to_view` _)
     (varray0 xr);
+  change_equal_slprop
+    (Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Steel.FractionalPermission.half_perm (Some?.v x).perm_val))
+    (Steel.Reference.ghost_vptrp (Some?.v xr).perm_ref (Some?.v xr).perm_val);
   intro_varray1 xr;
   let res = GPair xl xr in
   change_equal_slprop
@@ -1314,6 +1357,8 @@ let split_left
     base_ref = (Some?.v a).base_ref;
     from = (Some?.v a).from;
     to = (Some?.v al).to;
+    perm_ref = (Some?.v a).perm_ref;
+    perm_val = (Some?.v al).perm_val;
     prf = ();
   }) in
   change_equal_slprop
@@ -1410,6 +1455,9 @@ let get_pts_to
     (fun _ v' _ -> v' == v)
 = noop(); v
 
+let v_ref_of_array r =
+  Steel.Reference.ghost_vptrp (Some?.v r).perm_ref (Some?.v r).perm_val
+
 (*
 assume
 val abstract_id
@@ -1469,7 +1517,7 @@ let ref_of_array_ghost #inames #base #t x sq =
 val ref_of_array0 (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
   : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
              (varray r)
-             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r'))
+             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r') `star` v_ref_of_array r)
              (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
              (ensures fun h0 r' h1 -> True)
 
@@ -1519,7 +1567,7 @@ let ref_of_array0 #base #t x sq v0 =
   return r
 
 #restart-solver
-let ref_of_array #base #t x =
+let ref_of_array #base #t x sq =
   let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
   let v0 = Ghost.hide (Seq.index (Ghost.reveal gv) 0) in
   let r = ref_of_array0 x () v0 in
@@ -1531,7 +1579,7 @@ let ref_of_array #base #t x =
 
 #restart-solver
 let array_of_ref
-  #_ #base #t r' r
+  #_ #base #t r' r sq
 =
   let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
   let v = Steel.C.Ref.pts_to_view_elim
@@ -1569,22 +1617,24 @@ let one_ref_as_array_conn
 =
   Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
 
-let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) : GTot (array base t) =
+let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array base t) =
   Some ({
     base_len = one_size;
     base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
     from = zero_size;
     to = one_size;
+    perm_ref = perm_ref;
+    perm_val = Steel.FractionalPermission.full_perm;
     prf = ();
   })
 
 #restart-solver
 let mk_array_of_ref'_correct
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
-  (g_ref_of_array (mk_array_of_ref' r) == r)
+  (g_ref_of_array (mk_array_of_ref' r perm_ref) == r)
 =
-  g_ref_of_array'_correct (mk_array_of_ref' r);
+  g_ref_of_array'_correct (mk_array_of_ref' r perm_ref);
   array_conn_id t one_size;
   Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
   Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
@@ -1592,14 +1642,14 @@ let mk_array_of_ref'_correct
   Steel.C.Ref.ref_focus_id r
 
 let array_as_ref_mk_array_of_ref'
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
   (ensures (
-    let x = mk_array_of_ref' r in
+    let x = mk_array_of_ref' r perm_ref in
     array_as_ref x == (Some?.v x).base_ref
   ))
 = 
-  let x = mk_array_of_ref' r in
+  let x = mk_array_of_ref' r perm_ref in
   array_conn_id t one_size;
   Steel.C.Ref.ref_focus_id (Some?.v x).base_ref
 
@@ -1640,16 +1690,19 @@ let mk_array_of_ref
     Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
   in
   let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
+  let perm_ref = Steel.Reference.ghost_alloc #unit () in
   let res = Some ({
     base_len = one_size;
     base_ref = r';
     from = zero_size;
     to = one_size;
+    perm_ref = perm_ref;
+    perm_val = Steel.FractionalPermission.full_perm;
     prf = ()
   })
   in
-  assert (res == mk_array_of_ref' r);
-  mk_array_of_ref'_correct r;
+  assert (res == mk_array_of_ref' r perm_ref);
+  mk_array_of_ref'_correct r perm_ref;
   let g' : Ghost.erased (array_view_type t one_size) =
     Ghost.hide (Seq.create 1 (Ghost.reveal g))
   in
@@ -1659,10 +1712,13 @@ let mk_array_of_ref
     _
     (array_view t one_size)
     g';
-  array_as_ref_mk_array_of_ref' r;
+  array_as_ref_mk_array_of_ref' r perm_ref;
   change_equal_slprop
     (Steel.C.Ref.pts_to_view r' (array_view t one_size))
     (varray0 res);
+  change_equal_slprop
+    (Steel.Reference.ghost_vptr perm_ref)
+    (Steel.Reference.ghost_vptrp (Some?.v res).perm_ref (Some?.v res).perm_val);
   intro_varray1 res;
   return res
 
@@ -1693,9 +1749,9 @@ let index
     (varray (Ghost.reveal (Ghost.hide rrr)));
   let rrl = split_left rr (GPair?.fst (gsplit rr one_size)) rrr in
   let grl = gget (varray rrl) in
-  let r0 = ref_of_array rrl in
+  let r0 = ref_of_array rrl () in
   let res = Steel.C.Opt.ref_opt_read r0 in
-  array_of_ref rrl r0;
+  array_of_ref rrl r0 ();
   let grl' = gget (varray rrl) in
   seq_equal_1 t (Ghost.reveal grl) (Ghost.reveal grl');
   let rr' = join' rrl (Ghost.reveal (Ghost.hide rrr)) in
@@ -1736,9 +1792,9 @@ let upd
   let rrl = split_left rr (GPair?.fst (gsplit rr one_size)) rrr in
   let s1 = gget (varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit r i))))) in
   let s2 = gget (varray rrl) in
-  let r0 = ref_of_array rrl in
+  let r0 = ref_of_array rrl () in
   Steel.C.Opt.ref_opt_write r0 x;
-  array_of_ref rrl r0;
+  array_of_ref rrl r0 ();
   let s2' = gget (varray rrl) in
   seq_append_append_upd t (size_v i) x s1 s2 s2' s3;
   let rr' = join' rrl (Ghost.reveal (Ghost.hide rrr)) in
@@ -1754,6 +1810,7 @@ let freeable
   let Some a' = a in
   Steel.C.Ref.freeable a'.base_ref /\
   size_v a'.base_len > 0 /\
+  a'.perm_val == Steel.FractionalPermission.full_perm /\
   a'.from == zero_size /\
   a'.to == a'.base_len
 
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 7a64446df58..06210b5bd2e 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -107,9 +107,19 @@ let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop =
   VUnit (varray' x)
 
 val g_mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-: Ghost (array base t)
-  (requires (size_v n > 0))
-  (ensures (fun a -> len a == Ghost.reveal n))
+  (a: array base t)
+: Tot prop
+
+val g_mk_array_weak
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array base t)
+: Lemma
+  (requires (g_mk_array r a))
+  (ensures (
+    size_v n > 0 /\
+    len a == Ghost.reveal n
+  ))
+  [SMTPat (g_mk_array r a)]
 
 val intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
@@ -118,7 +128,7 @@ val intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Refer
     (fun a -> varray a)
     (requires fun _ -> True)
   (ensures (fun h a h' ->
-    a == g_mk_array r /\
+    g_mk_array r a /\
     h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
   ))
 
@@ -126,9 +136,9 @@ val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: S
 : SteelGhost unit inames
   (varray a)
   (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
-  (requires fun _ -> a == g_mk_array r)
+  (requires fun _ -> g_mk_array r a)
   (ensures (fun h _ h' ->
-    a == g_mk_array r /\
+    g_mk_array r a /\
     h (varray a) == h' (Steel.C.Ref.pts_to_view r (array_view t n))
   ))
 
@@ -307,10 +317,16 @@ val g_ref_of_array
   (requires (length r == 1))
   (ensures (fun _ -> True))
 
+val v_ref_of_array
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost vprop
+  (requires (length r == 1))
+  (ensures (fun _ -> True))
+
 val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
   : SteelGhost unit inames
              (varray r)
-             (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t))
+             (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
              (requires fun _ -> True)
              (ensures fun h0 _ h1 ->
                let r' = g_ref_of_array r in
@@ -319,11 +335,11 @@ val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (s
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
-val ref_of_array (#base: Type) (#t:Type0) (r:array base t)
+val ref_of_array (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
   : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
              (varray r)
-             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t))
-             (requires fun _ -> length r == 1)
+             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
+             (requires fun _ -> True)
              (ensures fun h0 r' h1 ->
                let s = h0 (varray r) in
                Seq.length s == 1 /\
@@ -331,11 +347,11 @@ val ref_of_array (#base: Type) (#t:Type0) (r:array base t)
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
-val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
   : SteelGhost unit inames
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
              (fun _ -> varray r')
-             (requires fun _ -> length r' == 1 /\ g_ref_of_array r' == r)
+             (requires fun _ -> g_ref_of_array r' == r)
              (ensures fun h0 _ h1 ->
                let s = h1 (varray r') in
                Seq.length s == 1 /\

From 13d6f95b5134cc10f842bbcbad442d01e3219e61 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 15 Oct 2021 15:07:03 -0700
Subject: [PATCH 286/513] refine Steel.C.Array.merge_assoc; add merge_inj eqs

---
 ulib/experimental/Steel.C.Array.fst  |  4 ++++
 ulib/experimental/Steel.C.Array.fsti | 21 ++++++++++++++++++++-
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 2e83ee58dd3..efdd68ce2f2 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1093,6 +1093,10 @@ let merge r1 r2 = t_merge r1 r2
 
 let merge_assoc r1 r2 r3 = ()
 
+let merge_inj_right a b1 b2 = ()
+
+let merge_inj_left a1 a2 b = ()
+
 val tsplit
   (#base: Type)
   (#t: Type)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 06210b5bd2e..79bad849f4b 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -171,7 +171,10 @@ val merge_assoc
   (#t: Type)
   (r1 r2 r3: array base t)
 : Lemma
-  (requires (adjacent r1 r2 /\ adjacent r2 r3))
+  (requires (
+    (adjacent r1 r2 /\ (adjacent r2 r3 \/ adjacent (merge r1 r2) r3)) \/
+    (adjacent r2 r3 /\ adjacent r1 (merge r2 r3))
+  ))
   (ensures (
     adjacent r1 r2 /\ adjacent r2 r3 /\
     begin
@@ -183,6 +186,22 @@ val merge_assoc
   ))
   [SMTPat (merge (merge r1 r2) r3)]
 
+val merge_inj_right
+  (#base: Type)
+  (#t: Type)
+  (a b1 b2: array base t)
+: Lemma
+  (requires (adjacent a b1 /\ adjacent a b2 /\ merge a b1 == merge a b2))
+  (ensures (b1 == b2))
+
+val merge_inj_left
+  (#base: Type)
+  (#t: Type)
+  (a1 a2 b: array base t)
+: Lemma
+  (requires (adjacent a1 b /\ adjacent a2 b /\ merge a1 b == merge a2 b))
+  (ensures (a1 == a2))
+
 [@erasable]
 noeq
 type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b

From 580268671d7e7c8e13c997a967b5d69e549c1d7a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sat, 16 Oct 2021 13:58:41 -0700
Subject: [PATCH 287/513] no_self_merge

---
 ulib/experimental/Steel.C.Array.fst  | 26 ++++++++++++++++++++++++++
 ulib/experimental/Steel.C.Array.fsti |  6 ++++++
 2 files changed, 32 insertions(+)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index efdd68ce2f2..b40c8b5993b 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1097,6 +1097,32 @@ let merge_inj_right a b1 b2 = ()
 
 let merge_inj_left a1 a2 b = ()
 
+let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b a))
+= let aux () : Lemma
+    (requires (merge_into a b a))
+    (ensures False)
+  = assert (
+      let open Steel.FractionalPermission in
+      let open FStar.Real in
+      (Some?.v a).perm_val.v +. (Some?.v b).perm_val.v >. (Some?.v a).perm_val.v
+    )
+  in
+  Classical.move_requires aux ()
+
+let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b b))
+= let aux () : Lemma
+    (requires (merge_into a b a))
+    (ensures False)
+  = assert (
+      let open Steel.FractionalPermission in
+      let open FStar.Real in
+      (Some?.v a).perm_val.v +. (Some?.v b).perm_val.v >. (Some?.v b).perm_val.v
+    )
+  in
+  Classical.move_requires aux ()
+
 val tsplit
   (#base: Type)
   (#t: Type)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 79bad849f4b..1f830ae9bdd 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -202,6 +202,12 @@ val merge_inj_left
   (requires (adjacent a1 b /\ adjacent a2 b /\ merge a1 b == merge a2 b))
   (ensures (a1 == a2))
 
+val no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b a))
+
+val no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b b))
+
 [@erasable]
 noeq
 type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b

From f479c8eb16ea6ea2db5df22b1e13f36fd9de84ac Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 18 Oct 2021 15:23:10 -0700
Subject: [PATCH 288/513] specify and extract array_or_null_from

---
 src/extraction/FStar.Extraction.Kremlin.fs |  43 ++-
 ulib/experimental/Steel.C.Array.fsti       | 311 +++++++++++++++++++--
 2 files changed, 313 insertions(+), 41 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 7bccb18039c..72876ee4a6c 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -772,7 +772,7 @@ and translate_type_without_decay env t: typ =
         (UInt32, string_of_int (must (int_of_typenat n))))
   
   | MLTY_Named ([_; arg], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Array.array_or_null"
+    Syntax.string_of_mlpath p = "Steel.C.Array.array_or_null_from"
     ->
       TBuf (translate_type_without_decay env arg)
   
@@ -1027,9 +1027,9 @@ and translate_expr env e: expr =
           string_of_mlpath p = "LowStar.ImmutableBuffer.imalloc") ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _ (* sq *) ])
     when (
-          string_of_mlpath p = "Steel.C.Array.malloc" ||
+          string_of_mlpath p = "Steel.C.Array.malloc_from" ||
           false) ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
@@ -1056,11 +1056,16 @@ and translate_expr env e: expr =
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ])
     when (string_of_mlpath p = "FStar.Buffer.rfree" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.free" ||
-          string_of_mlpath p = "Steel.C.Array.free" ||
           string_of_mlpath p = "Steel.C.Opt.free" ||
           string_of_mlpath p = "Steel.Array.free") ->
       EBufFree (translate_expr env e2)
 
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2; _ (* a' *); _ (* sq *) ])
+    when (
+          string_of_mlpath p = "Steel.C.Array.free_from" ||
+          false) ->
+      EBufFree (translate_expr env e2)
+
   (* Generic buffer operations. *)
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _e3 ]) when (string_of_mlpath p = "FStar.Buffer.sub") ->
       EBufSub (translate_expr env e1, translate_expr env e2)
@@ -1244,8 +1249,8 @@ TODO: these should be removed and those operators should be directly
 supported by KReMLin (in src/Builtin.ml) Or alternatively Null and
 IsNull nodes should be added to the KReMLin AST *)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [e])
-    when string_of_mlpath p = "Steel.C.Array.is_null"
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [e; _ (* a' *); _ (* sq *) ])
+    when string_of_mlpath p = "Steel.C.Array.is_null_from"
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *); e; _ (* view *)])
@@ -1253,7 +1258,7 @@ IsNull nodes should be added to the KReMLin AST *)
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
   | MLE_TApp ({expr=MLE_Name p}, _)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.null"
+    when Syntax.string_of_mlpath p = "Steel.C.Array.null_from"
     -> EQualified (["LowStar"; "Buffer"], "null")
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *)])
@@ -1308,37 +1313,29 @@ IsNull nodes should be added to the KReMLin AST *)
         translate_expr env x)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
-    when string_of_mlpath p = "Steel.C.Array.ref_of_array" ->
+    when string_of_mlpath p = "Steel.C.Array.ref_of_array_from" ->
       translate_expr env r
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
-    when string_of_mlpath p = "Steel.C.Array.mk_array_of_ref" ->
+    when string_of_mlpath p = "Steel.C.Array.mk_array_of_ref_from" ->
       translate_expr env r
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; r; _])
-    when string_of_mlpath p = "Steel.C.Array.intro_varray" ->
+    when string_of_mlpath p = "Steel.C.Array.intro_varray_from" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; i])
-    when string_of_mlpath p = "Steel.C.Array.index" ->
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i])
+    when string_of_mlpath p = "Steel.C.Array.index_from" ->
       EBufRead (translate_expr env r, translate_expr env i)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; i; x])
-    when string_of_mlpath p = "Steel.C.Array.upd" ->
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i; x])
+    when string_of_mlpath p = "Steel.C.Array.upd_from" ->
       EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
-    when string_of_mlpath p = "Steel.C.Array.split_left" ->
-      translate_expr env a
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
-    when string_of_mlpath p = "Steel.C.Array.split_right" ->
+    when string_of_mlpath p = "Steel.C.Array.split_right_from" ->
       EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; al; ar])
-    when string_of_mlpath p = "Steel.C.Array.joinc" ->
-      translate_expr env al
-
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
     when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
     translate_expr env e
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 1f830ae9bdd..541bb4ee1b1 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -54,21 +54,36 @@ val array_view (t: Type u#0) (n: size_t)
     (ensures (fun _ -> True))
 
 /// Abstract datatype for a Steel array of type [t]
-/// Should extract to t*
-val array_or_null (base: Type u#0) (t: Type u#0) : Type u#0
+/// We model it as three parts:
+/// - a pure part, which represents the beginning of the array, and should extract to t*
+/// - a ghost part, which represents the end of the array, and should be erased at extraction
+/// - a refinement, because KReMLin does not support inlining of dependent pair types where one part is ghost.
+val array_or_null_from (base: Type0) (t: Type0) : Tot Type0
+[@@erasable]
+val array_or_null_to (base: Type0) (t: Type0) : Tot Type0
+val array_or_null_spec (#base: Type0) (#t: Type0) (x: (array_or_null_from base t & array_or_null_to base t)) : Tot prop
+inline_for_extraction
+let array_or_null (base: Type u#0) (t: Type u#0) : Type u#0 = (x: (array_or_null_from base t & array_or_null_to base t) { array_or_null_spec x })
 
 /// Returns the length of the array. Usable for specification and proof purposes,
 /// as modeled by the GTot effect
 val len (#base: Type) (#t: Type) (a: array_or_null base t) : GTot size_t
 let length (#base: Type) (#t: Type) (a: array_or_null base t) : GTot nat = size_v (len a)
 
-val null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
+
+val null_from (base: Type u#0) (t: Type u#0) : Tot (array_or_null_from base t) 
+val null_to (base: Type u#0) (t: Type u#0) : Pure (array_or_null_to base t) (requires True) (ensures (fun r0 ->
+  array_or_null_spec (null_from base t, r0) /\
+  len (null_from base t, r0) == zero_size))
+
+inline_for_extraction
+let null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
+= (null_from base t, null_to base t)
 val g_is_null (#base: Type) (#t: Type) (a: array_or_null base t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null base t))
 inline_for_extraction
 noextract
 let array (base: Type u#0) (t:Type u#0) : Type u#0 = (a: array_or_null base t { g_is_null a == false })
 
-// TODO 
 val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
 : b:bool{b <==> a == one (array_pcm t n)}
 
@@ -121,7 +136,37 @@ val g_mk_array_weak
   ))
   [SMTPat (g_mk_array r a)]
 
-val intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+val g_mk_array_from
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Tot prop
+
+val g_mk_array_to
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Pure (array_or_null_to base t)
+  (requires (g_mk_array_from r a))
+  (ensures (fun a' ->
+    let a0 = (a, a') in
+    array_or_null_spec a0 /\
+    g_is_null a0 == false /\
+    g_mk_array r a0
+  ))
+
+val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (_: squash (size_v n > 0))
+: Steel (al: array_or_null_from base t { g_mk_array_from r al })
+    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (fun al -> varray (al, g_mk_array_to r al))
+    (requires fun _ -> True)
+  (ensures (fun h al h' ->
+    let a = (al, g_mk_array_to r al) in
+    g_mk_array r a /\
+    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+inline_for_extraction
+let intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
 : Steel (array base t)
     (Steel.C.Ref.pts_to_view r (array_view t n))
@@ -131,6 +176,13 @@ val intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Refer
     g_mk_array r a /\
     h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
   ))
+=
+  let al = intro_varray_from r () in
+  let a = (al, g_mk_array_to r al) in
+  change_equal_slprop
+    (varray (al, g_mk_array_to r al))
+    (varray a);
+  return a
 
 val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n)) (a: array base t) (_: squash (size_v n > 0))
 : SteelGhost unit inames
@@ -156,7 +208,10 @@ val merge
   (r1 r2: array base t)
 : Ghost (array base t)
   (requires (adjacent r1 r2))
-  (ensures (fun r -> length r == length r1 + length r2))
+  (ensures (fun r ->
+    length r == length r1 + length r2 /\
+    fst r == fst r1 // this property justifies array_or_null_from _ t being extracted to t*
+  ))
 
 let merge_into
   (#base: Type)
@@ -240,7 +295,8 @@ val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
             s == sl `Seq.append` sr
           )
 
-val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
+inline_for_extraction
+let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
   (al ar: Ghost.erased (array base t))
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray al)
@@ -252,8 +308,40 @@ val split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
             res == Ghost.reveal al /\
             h' (varray res) == h (varray al)
           )
+= match a with
+  | (a_, _) ->
+    let res = (a_, snd al) in
+    change_equal_slprop
+      (varray al)
+      (varray res);
+    return res
+
+val split_right_from_prop (#base: _) (#t:Type) (a:array base t) (i:size_t) (from: array_or_null_from base t)
+: Tot prop
+
+val split_right_to (#base: _) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a)) (from: array_or_null_from base t)
+: Pure (array_or_null_to base t)
+  (requires (split_right_from_prop a i from))
+  (ensures (fun y ->
+    let res = (from, y) in
+    array_or_null_spec res /\
+    g_is_null res == false /\
+    res == GPair?.snd (gsplit a i)
+  ))
+
+val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array_or_null_from base t) false opened Unobservable
+          (varray a)
+          (fun _ -> varray a)
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            h' (varray a) == h (varray a) /\
+            size_v i <= length a /\
+            split_right_from_prop a i res
+          )
 
-val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+inline_for_extraction
+let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
@@ -263,6 +351,9 @@ val split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
             size_v i <= length a /\
             res == GPair?.snd (gsplit a i)
           )
+= let from = split_right_from a i in
+  let res = (from, split_right_to a i () from) in
+  return res
 
 inline_for_extraction
 let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a))
@@ -303,7 +394,8 @@ val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
             merge_into al ar a
           )
 
-val joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
+inline_for_extraction
+let joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
   : SteelAtomicBase (array base t) false opened Unobservable
           (varray al `star` varray ar)
           (fun a -> varray al `star` varray ar)
@@ -313,6 +405,10 @@ val joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
             h' (varray ar) == h (varray ar) /\
             merge_into al ar a
           )
+= match al with
+  | (a, _) ->
+    let res = (a, snd (merge al ar)) in
+    return res
 
 inline_for_extraction
 let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
@@ -360,7 +456,21 @@ val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (s
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
-val ref_of_array (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
+val ref_of_array_from (#base: Type) (#t:Type0) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
+  : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+             (varray (r_from, r_to))
+             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let r = (r_from, r_to) in
+               let s = h0 (varray r) in
+               Seq.length s == 1 /\
+               g_ref_of_array r == r' /\
+               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+inline_for_extraction
+let ref_of_array (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
   : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
              (varray r)
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
@@ -371,6 +481,16 @@ val ref_of_array (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r
                g_ref_of_array r == r' /\
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
+= match r with
+  | (r_from, r_to) ->
+    change_equal_slprop
+      (varray r)
+      (varray (r_from, r_to));
+    let res = ref_of_array_from r_from r_to () in
+    change_equal_slprop
+      (v_ref_of_array (r_from, r_to))
+      (v_ref_of_array r);
+    return res
 
 val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
   : SteelGhost unit inames
@@ -386,7 +506,37 @@ val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: St
 
 // this function should be used only to pass a pointer as an argument to a function that expects an array
 
-val mk_array_of_ref (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+val mk_array_of_ref_from_spec
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from base t)
+: Tot prop
+
+val mk_array_of_ref_to
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from base t)
+: Pure (array_or_null_to base t)
+  (requires (mk_array_of_ref_from_spec r from))
+  (ensures (fun to ->
+    let r' = (from, to) in
+    array_or_null_spec r' /\
+    g_is_null r' == false
+  ))
+
+val mk_array_of_ref_from (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : Steel (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
+             (requires fun _ -> True)
+             (ensures fun h0 r0 h1 ->
+               let r' = (r0, mk_array_of_ref_to r r0) in
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+inline_for_extraction
+let mk_array_of_ref (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
   : Steel (array base t)
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
@@ -397,12 +547,29 @@ val mk_array_of_ref (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (S
                g_ref_of_array r' == r /\
                h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
-
+= let from = mk_array_of_ref_from r in
+  let r' = (from, mk_array_of_ref_to r from) in
+  change_equal_slprop
+    (varray (from, mk_array_of_ref_to r from))
+    (varray r');
+  return r'
 
 /// Accesses index [i] in array [r], as long as [i] is in bounds and the array
 /// is currently valid in memory
 
-val index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
+val index_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_or_null_to base t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t)
+  : Steel t
+             (varray (r, r'))
+             (fun _ -> varray (r, r'))
+             (requires fun _ -> size_v i < length (r, r'))
+             (ensures fun h0 x h1 ->
+               let s = h1 (varray (r, r')) in
+               size_v i < length (r, r') /\
+               h0 (varray (r, r')) == s /\
+               x == Seq.index s (size_v i))
+
+inline_for_extraction
+let index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
   : Steel t
              (varray r)
              (fun _ -> varray r)
@@ -412,10 +579,33 @@ val index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
                size_v i < length r /\
                h0 (varray r) == s /\
                x == Seq.index s (size_v i))
+= match r with
+  | (r0, r') ->
+    change_equal_slprop
+      (varray r)
+      (varray (r0, r'));
+    let res = index_from r0 r' i in
+    change_equal_slprop
+      (varray (r0, r'))
+      (varray r);
+    return res
+  
 
 /// Updates index [i] in array [r] with value [x], as long as [i]
 /// is in bounds and the array is currently valid in memory
-val upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
+
+
+val upd_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_or_null_to base t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t) (x:t)
+  : Steel unit
+             (varray (r, r'))
+             (fun _ -> varray (r, r'))
+             (requires fun h -> size_v i < length (r, r'))
+             (ensures fun h0 _ h1 ->
+               size_v i < length (r, r') /\
+               h1 (varray (r, r')) == Seq.upd (h0 (varray (r, r'))) (size_v i) x)
+
+inline_for_extraction
+let upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
   : Steel unit
              (varray r)
              (fun _ -> varray r)
@@ -423,7 +613,15 @@ val upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
              (ensures fun h0 _ h1 ->
                size_v i < length r /\
                h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
-
+= match r with
+  | (r0, r') ->
+    change_equal_slprop
+      (varray r)
+      (varray (r0, r'));
+    upd_from r0 r' i x;
+    change_equal_slprop
+      (varray (r0, r'))
+      (varray r)
 
 let varray_or_null (#base: Type0) (#t: Type0) (x: array_or_null base t) : Tot vprop =
   if g_is_null x then emp else varray x
@@ -436,7 +634,33 @@ val freeable
   (a: array base t)
 : Tot prop
 
-val malloc
+val malloc_to
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Pure (array_or_null_to (array_pcm_carrier t n) t)
+    (requires (size_v n > 0))
+    (ensures (fun to -> array_or_null_spec (from, to)))
+
+val malloc_from
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (sq: squash (size_v n > 0))
+: Steel (array_or_null_from (array_pcm_carrier t n) t)
+    emp
+    (fun r -> varray_or_null (r, malloc_to x n r))
+    (requires fun _ -> True)
+    (ensures fun _ r0 h' ->
+      size_v n > 0 /\
+      begin let r : array_or_null (array_pcm_carrier t n) t = (r0, malloc_to x n r0) in
+      g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x)
+      end
+    )
+
+inline_for_extraction
+let malloc
   (#t: Type0)
   (x: t)
   (n: size_t)
@@ -447,8 +671,27 @@ val malloc
     (ensures fun _ r h' ->
       g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x)
     )
+= let r0 = malloc_from x n () in
+  let r = (r0, malloc_to x n r0) in
+  change_equal_slprop
+    (varray_or_null (r0, malloc_to x n r0))
+    (varray_or_null r);
+  return r
 
-val free
+val free_from
+  (#base: Type0)
+  (#t: Type0)
+  (a: array_or_null_from base t)
+  (a' : array_or_null_to base t)
+  (sq: squash (array_or_null_spec (a, a') /\ g_is_null (a, a') == false))
+: Steel unit
+    (varray (a, a'))
+    (fun _ -> emp)
+    (requires (fun _ -> freeable (a,a')))
+    (ensures (fun _ _ _ -> True))
+
+inline_for_extraction
+let free
   (#base: Type0)
   (#t: Type0)
   (a: array base t)
@@ -457,8 +700,30 @@ val free
     (fun _ -> emp)
     (requires (fun _ -> freeable a))
     (ensures (fun _ _ _ -> True))
+= match a with
+  | (af, a') ->
+    change_equal_slprop
+      (varray a)
+      (varray (af, a'));
+    free_from af a' ()
+
+val is_null_from
+  (#base: Type0)
+  (#t: Type0)
+  (a: array_or_null_from base t)
+  (a' : array_or_null_to base t)
+  (sq: squash (array_or_null_spec (a, a')))
+: Steel bool
+    (varray_or_null (a, a'))
+    (fun _ -> varray_or_null (a, a'))
+    (requires fun _ -> True)
+    (ensures fun h res h' ->
+      res == g_is_null (a, a') /\
+      h' (varray_or_null (a, a')) == h (varray_or_null (a, a'))
+    )
 
-val is_null
+inline_for_extraction
+let is_null
   (#base: Type0)
   (#t: Type0)
   (a: array_or_null base t)
@@ -470,3 +735,13 @@ val is_null
       res == g_is_null a /\
       h' (varray_or_null a) == h (varray_or_null a)
     )
+= match a with
+  | (af, a') ->
+    change_equal_slprop
+      (varray_or_null a)
+      (varray_or_null (af, a'));
+    let res = is_null_from af a' () in
+    change_equal_slprop
+      (varray_or_null (af, a'))
+      (varray_or_null a);
+    return res

From 17be222927b17870aae8923d8e12023ad32c04a8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 18 Oct 2021 15:23:26 -0700
Subject: [PATCH 289/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 129 ++++++++-----------
 1 file changed, 56 insertions(+), 73 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index c75becef688..03737af9744 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -1538,7 +1538,7 @@ and (translate_type_without_decay :
           TArray uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.array_or_null" ->
+          uu___1 = "Steel.C.Array.array_or_null_from" ->
           let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
@@ -2248,16 +2248,16 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
+           e1::e2::uu___5::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Array.malloc") || false
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.malloc_from") || false
           ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___6, uu___7) in
-          EBufCreate uu___5
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2353,13 +2353,10 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "FStar.Buffer.rfree") ||
-               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "LowStar.Monotonic.Buffer.free"))
-              ||
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.Buffer.rfree") ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "Steel.C.Array.free"))
+               uu___5 = "LowStar.Monotonic.Buffer.free"))
              ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
               uu___5 = "Steel.C.Opt.free"))
@@ -2367,6 +2364,23 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "Steel.Array.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3035,15 +3049,15 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
+           e1::uu___5::uu___6::[])
           when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.is_null" ->
-          let uu___5 =
-            let uu___6 = let uu___7 = translate_expr env1 e1 in [uu___7] in
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.is_null_from" ->
+          let uu___7 =
+            let uu___8 = let uu___9 = translate_expr env1 e1 in [uu___9] in
             ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___6) in
-          EApp uu___5
+              uu___8) in
+          EApp uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3074,7 +3088,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___2)
           when
           let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.null" ->
+          uu___3 = "Steel.C.Array.null_from" ->
           EQualified (["LowStar"; "Buffer"], "null")
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -3295,7 +3309,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            r::[])
           when
           let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.ref_of_array" -> translate_expr env1 r
+          uu___6 = "Steel.C.Array.ref_of_array_from" -> translate_expr env1 r
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3311,7 +3325,8 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            r::[])
           when
           let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.mk_array_of_ref" -> translate_expr env1 r
+          uu___6 = "Steel.C.Array.mk_array_of_ref_from" ->
+          translate_expr env1 r
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3327,7 +3342,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___6::r::uu___7::[])
           when
           let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.intro_varray" ->
+          uu___8 = "Steel.C.Array.intro_varray_from" ->
           let uu___8 =
             let uu___9 = translate_expr env1 r in
             (uu___9, (EConstant (UInt32, "0"))) in
@@ -3344,35 +3359,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2::uu___3::[]);
              FStar_Extraction_ML_Syntax.mlty = uu___4;
              FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::i::x::[])
+           r::uu___6::i::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3385,10 +3379,15 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2::uu___3::[]);
              FStar_Extraction_ML_Syntax.mlty = uu___4;
              FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
+           r::uu___6::i::x::[])
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.split_left" -> translate_expr env1 a
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3404,29 +3403,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___6::a::i::[])
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.split_right" ->
+          uu___7 = "Steel.C.Array.split_right_from" ->
           let uu___7 =
             let uu___8 =
               let uu___9 = translate_expr env1 a in
               let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
             EBufRead uu___8 in
           EAddrOf uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::al::ar::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.joinc" -> translate_expr env1 al
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =

From 7cb91cd7e5ee3107b8d34a70d96d15514965d1c6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 18 Oct 2021 20:54:17 -0700
Subject: [PATCH 290/513] implement array_or_null_from/to

---
 ulib/experimental/Steel.C.Array.fst      | 603 ++++++++++++++++-------
 ulib/experimental/Steel.C.Array.fsti     |  28 +-
 ulib/experimental/Steel.C.Connection.fst |   7 +
 3 files changed, 438 insertions(+), 200 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index b40c8b5993b..b11a6e002f0 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -2,6 +2,22 @@ module Steel.C.Array
 
 module S = Steel.C.Struct
 
+#push-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
+let half_perm
+  (p: Steel.FractionalPermission.perm)
+: Pure Steel.FractionalPermission.perm
+  (requires True)
+  (ensures (fun y ->
+    y `Steel.FractionalPermission.sum_perm` y == p /\
+    y == Steel.FractionalPermission.half_perm p
+  ))
+= 
+  let open Steel.FractionalPermission in
+  let open FStar.Real in
+  assert ((p.v /. 2.0R) +. (p.v /. 2.0R) == p.v);
+  MkPerm (p.v /. 2.0R)
+#pop-options
+
 let array_domain
   (t: Type u#0)
   (n: Ghost.erased size_t)
@@ -166,32 +182,47 @@ let array_view t n =
   array_view' t n
 
 noeq
-type array' base t = {
+type array_from0 base t = {
   base_len: Ghost.erased size_t;
   base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
   from: size_t;
-  to: Ghost.erased size_t;
   perm_ref: Steel.Reference.ghost_ref unit;
+}
+
+[@@erasable]
+noeq
+type array_to0 = {
+  to: size_t;
   perm_val: Steel.FractionalPermission.perm;
-  prf: squash (
-    size_v base_len >= 0 /\
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  );
 }
 
-let len' (#base: _) (#t: _) (a: array' base t) : GTot size_t =
-  a.to `size_sub` a.from
+let array0_spec
+  (#base: _)
+  (#t: _)
+  (from: array_from0 base t)
+  (to: array_to0)
+: Tot prop
+=
+    size_v from.base_len >= 0 /\
+    size_v from.from <= size_v to.to /\
+    size_v to.to <= size_v from.base_len
 
-let array_or_null base t = option (array' base t)
+let array_or_null_from base t = option (array_from0 base t)
+let array_or_null_to base t = Ghost.erased (option array_to0)
+let array_or_null_spec (from, to) =
+  None? from == None? to /\
+  ((Some? from \/ Some? to) ==> array0_spec (Some?.v from) (Some?.v to))
 
-let len a = match a with
-| None -> zero_size
-| Some a -> len' a
+let len (from, to) =
+  match from with
+  | Some from ->
+    let Some to = Ghost.reveal to in to.to `size_sub` from.from
+  | _ -> zero_size
 
-let null _ _ = None
+let null_from _ _ = None
+let null_to _ _ = None
 
-let g_is_null a = None? a
+let g_is_null a = None? (fst a)
 
 let rec array_is_unit_aux
   (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
@@ -904,26 +935,55 @@ let to_view_array_conn
 
 #pop-options
 
-let array_as_ref_conn
-  (#base: Type)
-  (#t: Type)
-  (a: array' base t)
-: GTot (Steel.C.Connection.connection (array_pcm t a.base_len) (array_pcm t (len' a)))
-= array_conn t a.base_len a.from a.to a.prf
+let array__base_len
+  (#base #t: _)
+  (a: array base t)
+: GTot size_t
+= (Some?.v (fst a)).base_len
+
+let array__base_ref
+  (#base #t: _)
+  (a: array base t)
+: Tot (Steel.C.Reference.ref base (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
+= (Some?.v (fst a)).base_ref
 
-let array_as_ref'
+let array__from
+  (#base #t: _)
+  (a: array base t)
+: Tot size_t
+= (Some?.v (fst a)).from
+
+let array__to
+  (#base #t: _)
+  (a: array base t)
+: GTot size_t
+= (Some?.v (snd a)).to
+
+let array__perm_ref
+  (#base #t: _)
+  (a: array base t)
+: Tot (Steel.Reference.ghost_ref unit)
+= (Some?.v (fst a)).perm_ref
+
+let array__perm_val
+  (#base #t: _)
+  (a: array base t)
+: Tot Steel.FractionalPermission.perm
+= (Some?.v (snd a)).perm_val
+
+let array_as_ref_conn
   (#base: Type)
   (#t: Type)
-  (a: array' base t)
-: GTot (Steel.C.Reference.ref base (array_view_type t (len' a)) (array_pcm t (len' a)))
-= Steel.C.Ref.ref_focus a.base_ref (array_as_ref_conn a)
+  (a: array base t)
+: GTot (Steel.C.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
+= array_conn t (array__base_len a) (array__from a) (array__to a) ()
 
 let array_as_ref
   (#base: Type)
   (#t: Type)
   (a: array base t)
 : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
-= array_as_ref' (Some?.v a)
+= Steel.C.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
 
 [@@__steel_reduce__]
 let varray0
@@ -946,7 +1006,7 @@ let varray9
   (#t: Type)
   (x: array base t)
 : Tot vprop
-= (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref  (Some?.v x).perm_val) `vrewrite` fst
+= (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x)  (array__perm_val x)) `vrewrite` fst
 
 let varray_hp #base #t x = hp_of (varray9 #base #t x)
 
@@ -962,15 +1022,15 @@ let intro_varray1
   (#t: Type)
   (x: array base t)
 : SteelGhost unit inames
-    (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
+    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
     (fun _ -> varray x)
     (fun _ -> True)
     (fun h _ h' -> h' (varray x) == h (varray0 x))
 = intro_vrewrite
-    (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
+    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
     fst;
   change_slprop_rel
-    ((varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val) `vrewrite` fst)
+    ((varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x)) `vrewrite` fst)
     (varray x)
     (fun u v -> u == v)
     (fun m -> ())
@@ -982,48 +1042,75 @@ let elim_varray1
   (x: array base t)
 : SteelGhost unit inames
     (varray x)
-    (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
+    (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
     (fun _ -> True)
     (fun h _ h' -> h' (varray0 x) == h (varray x))
 = change_slprop_rel
     (varray x)
-    ((varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val) `vrewrite` fst)
+    ((varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x)) `vrewrite` fst)
     (fun u v -> u == v)
     (fun m -> ());
   elim_vrewrite
-    (varray0 x `star` Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Some?.v x).perm_val)
+    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
     fst
 
-let g_mk_array #base #t #n r a = 
-  let Some a' = a in
+let g_mk_array_from'
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Tot prop
+= 
+  Some? a /\
   size_v n > 0 /\
-  Ghost.reveal a'.base_len == n /\
-  a'.base_ref == r /\
-  a'.from == mk_size_t 0ul /\
-  Ghost.reveal a'.to == n /\
-  a'.perm_val == Steel.FractionalPermission.full_perm
+  begin let a = Some?.v a in
+  Ghost.reveal a.base_len == n /\
+  a.base_ref == r /\
+  a.from == mk_size_t 0ul
+  end
+
+let g_mk_array #base #t #n r a =
+  g_mk_array_from' r (fst a) /\
+  (array__to a) == n /\
+  (array__perm_val a) == Steel.FractionalPermission.full_perm
 
 let g_mk_array_weak r a = ()
 
+let g_mk_array_from r a = g_mk_array_from' r a
+
+let g_mk_array_to #base #t #n r a
+=
+  Some ({
+    to = n;
+    perm_val = Steel.FractionalPermission.full_perm
+  })
+
 #push-options "--z3rlimit 32"
 
-let intro_varray
+val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (_: squash (size_v n > 0))
+: Steel (array base t)
+    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (fun a -> varray a)
+    (requires fun _ -> True)
+  (ensures (fun h a h' ->
+    g_mk_array r a /\
+    snd a == g_mk_array_to r (fst a) /\
+    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+let intro_varray0
   #base #t #n r sq
 =
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
-  let res = Some ({
+  let from = Some ({
     base_len = n;
     base_ref = r;
     from = mk_size_t 0ul;
-    to = n;
     perm_ref = perm_ref;
-    perm_val = Steel.FractionalPermission.full_perm;
-    prf = ();
-  })
-  in
+  }) in
+  let res = (from, g_mk_array_to r from) in
   change_equal_slprop
     (Steel.Reference.ghost_vptr perm_ref)
-    (Steel.Reference.ghost_vptrp ((Some?.v res).perm_ref) ((Some?.v res).perm_val));
+    (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
   assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
   assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
@@ -1037,6 +1124,14 @@ let intro_varray
   intro_varray1 res;
   return res
 
+let intro_varray_from r _ =
+  let a = intro_varray0 r () in
+  let res = fst a in
+  change_equal_slprop
+    (varray a)
+    (varray (res, g_mk_array_to r res));
+  return res
+
 let elim_varray
   #_ #base #t #n r res sq
 =
@@ -1052,21 +1147,19 @@ let elim_varray
   change_equal_slprop
     (varray0 res)
     (r `Steel.C.Ref.pts_to_view` _);
-  let perm_ref = (Some?.v res).perm_ref in
+  let perm_ref = (array__perm_ref res) in
   change_equal_slprop
-    (Steel.Reference.ghost_vptrp ((Some?.v res).perm_ref) ((Some?.v res).perm_val))
+    (Steel.Reference.ghost_vptrp ((array__perm_ref res)) ((array__perm_val res)))
     (Steel.Reference.ghost_vptr perm_ref);
   Steel.Reference.ghost_free perm_ref
 
 #pop-options
 
 let adjacent r1 r2 =
-  let Some r1 = r1 in
-  let Some r2 = r2 in
-  r1.base_len == r2.base_len /\
-  r1.base_ref == r2.base_ref /\
-  r1.perm_ref == r2.perm_ref /\
-  Ghost.reveal r1.to == r2.from
+  (array__base_len r1) == (array__base_len r2) /\
+  (array__base_ref r1) == (array__base_ref r2) /\
+  (array__perm_ref r1) == (array__perm_ref r2) /\
+  (array__to r1) == (array__from r2)
 
 val t_merge
   (#base: Type)
@@ -1077,17 +1170,10 @@ val t_merge
   (ensures (fun r -> length r == length r1 + length r2))
 
 let t_merge r1 r2 =
-  let Some r1 = r1 in
-  let Some r2 = r2 in
-  Some ({
-    base_len = r1.base_len;
-    base_ref = r1.base_ref;
-    from = r1.from;
-    to = r2.to;
-    perm_ref = r1.perm_ref;
-    perm_val = r1.perm_val `Steel.FractionalPermission.sum_perm` r2.perm_val;
-    prf = ();
-  })
+  (fst r1, Ghost.hide (Some ({
+    to = (array__to r2);
+    perm_val = (array__perm_val r1) `Steel.FractionalPermission.sum_perm` (array__perm_val r2);
+  })))
 
 let merge r1 r2 = t_merge r1 r2
 
@@ -1105,7 +1191,7 @@ let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
   = assert (
       let open Steel.FractionalPermission in
       let open FStar.Real in
-      (Some?.v a).perm_val.v +. (Some?.v b).perm_val.v >. (Some?.v a).perm_val.v
+      (array__perm_val a).v +. (array__perm_val b).v >. (array__perm_val a).v
     )
   in
   Classical.move_requires aux ()
@@ -1118,7 +1204,7 @@ let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
   = assert (
       let open Steel.FractionalPermission in
       let open FStar.Real in
-      (Some?.v a).perm_val.v +. (Some?.v b).perm_val.v >. (Some?.v b).perm_val.v
+      (array__perm_val a).v +. (array__perm_val b).v >. (array__perm_val b).v
     )
   in
   Classical.move_requires aux ()
@@ -1135,25 +1221,25 @@ val tsplit
     length rl == size_v i
   ))
 
-let tsplit r i =
-  let Some r = r in
-  (Some ({
-    base_len = r.base_len;
-    base_ref = r.base_ref;
-    from = r.from;
-    to = r.from `size_add` i;
-    perm_ref = r.perm_ref;
-    perm_val = Steel.FractionalPermission.half_perm r.perm_val;
-    prf = ()
-  }), Some ({
-    base_len = r.base_len;
-    base_ref = r.base_ref;
-    from = r.from `size_add` i;
-    to = r.to;
-    perm_ref = r.perm_ref;
-    perm_val = Steel.FractionalPermission.half_perm r.perm_val;
-    prf = ()
-  }))
+let tsplit #base #t r i =
+  let h = half_perm (array__perm_val r) in
+  let r1 : array base t =
+    (fst r, Ghost.hide (Some ({
+      to = (array__from r) `size_add` i;
+      perm_val = h;
+    })))
+  in
+  let r2 : array base t = (Some ({
+    base_len = (array__base_len r);
+    base_ref = (array__base_ref r);
+    from = (array__from r) `size_add` i;
+    perm_ref = (array__perm_ref r);
+  }), Ghost.hide (Some ({
+    to = (array__to r);
+    perm_val = h;
+  })))
+  in
+  (r1, r2)
 
 let gsplit r i = 
   let (rl, rr) = tsplit r i in
@@ -1220,9 +1306,9 @@ let array_as_ref_split_left
   (ensures (
     array_as_ref (fst (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
   ))
-= let Some x = x in
-  array_conn_compose t x.base_len x.from x.to zero_size i;
-  Steel.C.Ref.ref_focus_comp x.base_ref (array_as_ref_conn x) (array_conn t (len' x) zero_size i ())
+=
+  array_conn_compose t (array__base_len x) (array__from x) (array__to x) zero_size i;
+  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
 
 #restart-solver
 let array_as_ref_split_right
@@ -1235,9 +1321,9 @@ let array_as_ref_split_right
   (ensures (
     array_as_ref (snd (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
   ))
-= let Some x' = x in
-  array_conn_compose t x'.base_len x'.from x'.to i (len x);
-  Steel.C.Ref.ref_focus_comp x'.base_ref (array_as_ref_conn x') (array_conn t (len x) i (len x) ())
+=
+  array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
+  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
 
 val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
   : SteelGhost (array base t `gpair` array base t) opened
@@ -1319,10 +1405,10 @@ let split_
   change_equal_slprop // necessary, otherwise F* goes off rails
     (array_as_ref xl `Steel.C.Ref.pts_to_view` _)
     (varray0 xl);
-  Steel.Reference.ghost_share (Some?.v x).perm_ref;
+  Steel.Reference.ghost_share (array__perm_ref x);
   change_equal_slprop
-    (Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Steel.FractionalPermission.half_perm (Some?.v x).perm_val))
-    (Steel.Reference.ghost_vptrp (Some?.v xl).perm_ref (Some?.v xl).perm_val);
+    (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
+    (Steel.Reference.ghost_vptrp (array__perm_ref xl) (array__perm_val xl));
   intro_varray1 xl;
   let cr : (cr: Steel.C.Connection.connection
     (array_pcm t (len x))
@@ -1360,8 +1446,8 @@ let split_
     (array_as_ref xr `Steel.C.Ref.pts_to_view` _)
     (varray0 xr);
   change_equal_slprop
-    (Steel.Reference.ghost_vptrp (Some?.v x).perm_ref (Steel.FractionalPermission.half_perm (Some?.v x).perm_val))
-    (Steel.Reference.ghost_vptrp (Some?.v xr).perm_ref (Some?.v xr).perm_val);
+    (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
+    (Steel.Reference.ghost_vptrp (array__perm_ref xr) (array__perm_val xr));
   intro_varray1 xr;
   let res = GPair xl xr in
   change_equal_slprop
@@ -1379,35 +1465,13 @@ let split'
   Seq.lemma_split #t (Ghost.reveal g) (size_v i);
   split_ a i
 
-let split_left
-  a al _
-=
-  let res = Some ({
-    base_len = (Some?.v a).base_len;
-    base_ref = (Some?.v a).base_ref;
-    from = (Some?.v a).from;
-    to = (Some?.v al).to;
-    perm_ref = (Some?.v a).perm_ref;
-    perm_val = (Some?.v al).perm_val;
-    prf = ();
-  }) in
-  change_equal_slprop
-    (varray al)
-    (varray res);
-  return res
-
-let split_right
+let split_right_from
   a i
 =
-  return (snd (tsplit a i))
+  return (fst (snd (tsplit a i)))
 
 let join' = admit ()
 
-let joinc
-  al ar
-=
-  return (t_merge al ar)
-
 let array_as_one_ref_iso
   (base: Type)
   (t: Type)
@@ -1442,37 +1506,40 @@ let g_ref_of_array
   array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
 
 let array_as_one_ref_conn'
-  (#base: Type) (#t:Type0) (r:array' base t)
-: Pure (Steel.C.Connection.connection (array_pcm t r.base_len) (Steel.C.Opt.opt_pcm #t))
-  (requires (size_v (len' r) == 1))
+  (#base: Type) (#t:Type0) (r:array base t)
+: Pure (Steel.C.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
+  (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
 =
-  array_conn t r.base_len r.from (r.from `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
+  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
 
+#restart-solver
 let array_as_one_ref_conn'_small_to_large
-  (#base: Type) (#t:Type0) (r:array' base t)
+  (#base: Type) (#t:Type0) (r:array base t)
   (x: option t)
-  (i: array_domain t r.base_len)
+  (i: array_domain t (array__base_len r))
 : Lemma
-  (requires (size_v (len' r) == 1))
-  (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = r.from then x else None)))
-= ()
+  (requires (size_v (len r) == 1))
+  (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = (array__from r) then x else None)))
+= Steel.C.Connection.morphism_compose_morph
+    (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large
+    (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Connection.conn_small_to_large
+    x
 
 let g_ref_of_array'
-  (#base: Type) (#t:Type0) (r:array' base t)
+  (#base: Type) (#t:Type0) (r:array base t)
 : Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (requires (size_v (len' r) == 1))
+  (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
-= r.base_ref `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
+= (array__base_ref r) `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
 
 let g_ref_of_array'_correct
   (#base: Type) (#t:Type0) (r:array base t)
 : Lemma
   (requires (length r == 1))
-  (ensures (g_ref_of_array r == g_ref_of_array' (Some?.v r)))
+  (ensures (g_ref_of_array r == g_ref_of_array' r))
 =
-  let Some r = r in
-  Steel.C.Ref.ref_focus_comp r.base_ref (array_conn t r.base_len r.from r.to ()) (array_as_one_ref_conn base t)
+  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn base t)
 
 let get_pts_to
   (#inames: _)
@@ -1486,7 +1553,7 @@ let get_pts_to
 = noop(); v
 
 let v_ref_of_array r =
-  Steel.Reference.ghost_vptrp (Some?.v r).perm_ref (Some?.v r).perm_val
+  Steel.Reference.ghost_vptrp (array__perm_ref r) (array__perm_val r)
 
 (*
 assume
@@ -1556,7 +1623,7 @@ let ref_of_array0 #base #t x sq v0 =
   let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
   assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
   elim_varray1 x;
-  let v1 : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
+  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
     #_
     #base
     #(array_pcm_carrier t (len x))
@@ -1566,19 +1633,14 @@ let ref_of_array0 #base #t x sq v0 =
     #(size_v (len x) = 0)
     (array_view' t (len x))
   in
-  let x' : array' base t = Some?.v x in
-  let v : Ghost.erased (array_pcm_carrier t (len' x')) = v1 in
-  change_equal_slprop
-    (Steel.C.Ref.pts_to (array_as_ref #base #t x) v1)
-    (Steel.C.Ref.pts_to (array_as_ref' #base #t x') v);
-  Steel.C.Ref.unfocus _ x'.base_ref (array_as_ref_conn x') _;
-  let s = get_pts_to x'.base_ref _ in
-  let ar : Ghost.erased (array_pcm_carrier t x'.base_len) = Ghost.hide ((array_as_one_ref_conn' x').Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
-  array_pcm_carrier_ext t x'.base_len (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
-    array_as_one_ref_conn'_small_to_large x' (Ghost.reveal v zero_size) i
+  Steel.C.Ref.unfocus _ (array__base_ref x) (array_as_ref_conn x) _;
+  let s = get_pts_to (array__base_ref x) _ in
+  let ar : Ghost.erased (array_pcm_carrier t (array__base_len x)) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
+  array_pcm_carrier_ext t (array__base_len x) (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
+    array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
   );
   g_ref_of_array'_correct x;
-  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus x'.base_ref (array_as_one_ref_conn' x') s (Ghost.reveal v zero_size) in
+  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
   Steel.C.Ref.pts_to_view_intro
     #_
     #base
@@ -1597,7 +1659,11 @@ let ref_of_array0 #base #t x sq v0 =
   return r
 
 #restart-solver
-let ref_of_array #base #t x sq =
+let ref_of_array_from #base #t r_from r_to sq =
+  let x : array base t = (r_from, r_to) in
+  change_equal_slprop
+    (varray (r_from, r_to))
+    (varray x);
   let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
   let v0 = Ghost.hide (Seq.index (Ghost.reveal gv) 0) in
   let r = ref_of_array0 x () v0 in
@@ -1605,6 +1671,9 @@ let ref_of_array #base #t x sq =
   elim_vrefine
     (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
     (fun v' -> v' == Ghost.reveal v0);
+  change_equal_slprop
+    (v_ref_of_array x)
+    (v_ref_of_array (r_from, r_to));
   return r
 
 #restart-solver
@@ -1648,15 +1717,15 @@ let one_ref_as_array_conn
   Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
 
 let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array base t) =
-  Some ({
+  (Some ({
     base_len = one_size;
     base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
     from = zero_size;
-    to = one_size;
     perm_ref = perm_ref;
+  }), Ghost.hide (Some ({
+    to = one_size;
     perm_val = Steel.FractionalPermission.full_perm;
-    prf = ();
-  })
+  })))
 
 #restart-solver
 let mk_array_of_ref'_correct
@@ -1671,17 +1740,33 @@ let mk_array_of_ref'_correct
   Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
   Steel.C.Ref.ref_focus_id r
 
+#restart-solver
+let array_as_ref_eq_base_ref
+  (#base: Type) (#t:Type0) (a: array base t)
+: Lemma
+  (requires (
+    array__base_len a == one_size /\
+    array__from a == zero_size /\
+    array__to a == one_size
+  ))
+  (ensures (
+    array_as_ref a == (array__base_ref a)
+  ))
+=
+  array_conn_id t one_size;
+  Steel.C.Ref.ref_focus_id (array__base_ref a)
+
+#restart-solver
 let array_as_ref_mk_array_of_ref'
   (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
   (ensures (
     let x = mk_array_of_ref' r perm_ref in
-    array_as_ref x == (Some?.v x).base_ref
+    array_as_ref x == (array__base_ref x)
   ))
-= 
+=
   let x = mk_array_of_ref' r perm_ref in
-  array_conn_id t one_size;
-  Steel.C.Ref.ref_focus_id (Some?.v x).base_ref
+  array_as_ref_eq_base_ref x
 
 let array_domain_one_size
   (t: Type)
@@ -1709,8 +1794,41 @@ let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
     ()
   )
 
+let mk_array_of_ref_to'
+  (base: Type) (t:Type0)
+: Tot (array_or_null_to base t)
+= Some ({
+    to = one_size;
+    perm_val = Steel.FractionalPermission.full_perm;
+  })
+
+let mk_array_of_ref_from_spec
+  #base #t r from
+=
+  let a = (from, mk_array_of_ref_to' base t) in
+  array_or_null_spec a /\
+  g_is_null a == false /\
+  array__base_len a == one_size /\
+  array__from a == zero_size /\
+  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t
+
+let mk_array_of_ref_to #base #t r from = mk_array_of_ref_to' base t
+
+val mk_array_of_ref0 (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : Steel (array base t)
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun r' -> varray r')
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               r' == mk_array_of_ref' r (array__perm_ref r') /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
 #restart-solver
-let mk_array_of_ref
+let mk_array_of_ref0
   #base #t r
 =
   let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
@@ -1721,15 +1839,15 @@ let mk_array_of_ref
   in
   let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
-  let res = Some ({
+  let res : array base t = (Some ({
     base_len = one_size;
     base_ref = r';
     from = zero_size;
-    to = one_size;
     perm_ref = perm_ref;
+  }), Ghost.hide (Some ({
+    to = one_size;
     perm_val = Steel.FractionalPermission.full_perm;
-    prf = ()
-  })
+  })))
   in
   assert (res == mk_array_of_ref' r perm_ref);
   mk_array_of_ref'_correct r perm_ref;
@@ -1748,10 +1866,20 @@ let mk_array_of_ref
     (varray0 res);
   change_equal_slprop
     (Steel.Reference.ghost_vptr perm_ref)
-    (Steel.Reference.ghost_vptrp (Some?.v res).perm_ref (Some?.v res).perm_val);
+    (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
   intro_varray1 res;
   return res
 
+let mk_array_of_ref_from
+  #base #t r
+=
+  let a = mk_array_of_ref0 r in
+  let res = fst a in
+  change_equal_slprop
+    (varray a)
+    (varray (res, mk_array_of_ref_to r res));
+  return res
+
 #pop-options
 
 let seq_equal_1
@@ -1766,10 +1894,21 @@ let seq_equal_1
   (ensures (s1 == s2))
 = assert (s1 `Seq.equal` s2)
 
+val index0 (#base: Type) (#t:Type) (r:array base t) (i:size_t)
+  : Steel t
+             (varray r)
+             (fun _ -> varray r)
+             (requires fun _ -> size_v i < length r)
+             (ensures fun h0 x h1 ->
+               let s = h1 (varray r) in
+               size_v i < length r /\
+               h0 (varray r) == s /\
+               x == Seq.index s (size_v i))
+
 #push-options "--z3rlimit 128 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
 #restart-solver
 
-let index
+let index0
   #_ #t r i
 =
   let rr = split r i () in
@@ -1791,6 +1930,19 @@ let index
     (varray r);
   return res
 
+let index_from
+  #base #t r r' i
+=
+  let r0 : array base t = (r, r') in
+  change_equal_slprop
+    (varray (r, r'))
+    (varray r0);
+  let res = index0 r0 i in
+  change_equal_slprop
+    (varray r0)
+    (varray (r, r'));
+  return res
+
 let seq_append_append_upd
   (t: Type)
   (i: nat)
@@ -1810,7 +1962,16 @@ let seq_append_append_upd
     (s1 `Seq.append` (s2' `Seq.append` s3)) `Seq.equal` (Seq.upd (s1 `Seq.append` (s2 `Seq.append` s3)) i x)
   )
 
-let upd
+val upd0 (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
+  : Steel unit
+             (varray r)
+             (fun _ -> varray r)
+             (requires fun h -> size_v i < length r)
+             (ensures fun h0 _ h1 ->
+               size_v i < length r /\
+               h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
+
+let upd0
   #_ #t r i x
 =
   let rr = split r i () in
@@ -1833,16 +1994,27 @@ let upd
     (varray r')
     (varray r)
 
+let upd_from
+  #base #t r r' i x
+=
+  let r0 : array base t = (r, r') in
+  change_equal_slprop
+    (varray (r, r'))
+    (varray r0);
+  upd0 r0 i x;
+  change_equal_slprop
+    (varray r0)
+    (varray (r, r'))
+
 #restart-solver
 let freeable
   #base #t a
 =
-  let Some a' = a in
-  Steel.C.Ref.freeable a'.base_ref /\
-  size_v a'.base_len > 0 /\
-  a'.perm_val == Steel.FractionalPermission.full_perm /\
-  a'.from == zero_size /\
-  a'.to == a'.base_len
+  Steel.C.Ref.freeable (array__base_ref a) /\
+  size_v (array__base_len a) > 0 /\
+  (array__perm_val a) == Steel.FractionalPermission.full_perm /\
+  (array__from a) == zero_size /\
+  (array__to a) == (array__base_len a)
 
 #restart-solver
 let array_to_carrier_refine
@@ -1854,8 +2026,45 @@ let array_to_carrier_refine
   (ensures (p_refine (array_pcm t n) (array_to_carrier t n v)))
 = FStar.Classical.exists_intro (fun (k: array_domain t n) -> True) zero_size
 
+let malloc_to'
+ (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Tot (array_or_null_to (array_pcm_carrier t n) t)
+= if None? from
+  then None
+  else Some ({
+    to = n;
+    perm_val = Steel.FractionalPermission.full_perm;
+  })
+
+let malloc_from_spec
+  #t x n from
+=
+  let a = (from, malloc_to' x n from) in
+  array_or_null_spec a /\
+  (g_is_null a == false ==> freeable a)
+
+let malloc_to x n from = malloc_to' x n from
+
+val malloc0
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+: Steel (array_or_null (array_pcm_carrier t n) t)
+    emp
+    (fun r -> varray_or_null r)
+    (requires fun _ -> size_v n > 0)
+    (ensures fun _ r h' ->
+      size_v n > 0 /\
+      malloc_from_spec x n (fst r) /\
+      snd r == malloc_to x n (fst r) /\
+      (g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x))
+    )
+
 #restart-solver
-let malloc
+let malloc0
   #t x n
 =
   let v = Seq.create (size_v n) x in
@@ -1869,27 +2078,55 @@ let malloc
     (varray_or_null r);
   return r
 
+let malloc_from
+  #t x n sq
+= let a = malloc0 x n in
+  let res = fst a in
+  change_equal_slprop
+    (varray_or_null a)
+    (varray_or_null (res, malloc_to x n res));
+  return res
+ 
+val free0
+  (#base: Type0)
+  (#t: Type0)
+  (a: array base t)
+: Steel unit
+    (varray a)
+    (fun _ -> emp)
+    (requires (fun _ -> freeable a))
+    (ensures (fun _ _ _ -> True))
+
 #restart-solver
 #push-options "--print_implicits"
-let free
+let free0
   #base #t a
 =
-  let r = (Some?.v a).base_ref in
+  let r = (array__base_ref a) in
   elim_varray r a ();
   let v = Steel.C.Ref.pts_to_view_elim
     #_
     #_
-    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
-    #(array_pcm t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
+    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
+    #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
     r
-    (array_view t (Some?.v a).base_len)
+    (array_view t (array__base_len a))
   in
   Steel.C.Ref.ref_free
     #_
-    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
-    #(array_pcm t (Ghost.hide (Ghost.reveal (Some?.v a).base_len)))
+    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
+    #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #v
     r
 
-let is_null a =
+let free_from
+  #base #t a a' sq
+=
+  let a0 : array base t = (a, a') in
+  change_equal_slprop
+    (varray (a, a'))
+    (varray a0);
+  free0 a0
+
+let is_null_from a a' sq =
   return (None? a)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 541bb4ee1b1..cbb204f0e93 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -316,19 +316,6 @@ let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
       (varray res);
     return res
 
-val split_right_from_prop (#base: _) (#t:Type) (a:array base t) (i:size_t) (from: array_or_null_from base t)
-: Tot prop
-
-val split_right_to (#base: _) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a)) (from: array_or_null_from base t)
-: Pure (array_or_null_to base t)
-  (requires (split_right_from_prop a i from))
-  (ensures (fun y ->
-    let res = (from, y) in
-    array_or_null_spec res /\
-    g_is_null res == false /\
-    res == GPair?.snd (gsplit a i)
-  ))
-
 val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
   : SteelAtomicBase (array_or_null_from base t) false opened Unobservable
           (varray a)
@@ -337,7 +324,7 @@ val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_
           (fun h res h' ->
             h' (varray a) == h (varray a) /\
             size_v i <= length a /\
-            split_right_from_prop a i res
+            res == fst (GPair?.snd (gsplit a i))
           )
 
 inline_for_extraction
@@ -352,7 +339,7 @@ let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
             res == GPair?.snd (gsplit a i)
           )
 = let from = split_right_from a i in
-  let res = (from, split_right_to a i () from) in
+  let res = (from, snd (GPair?.snd (gsplit a i))) in
   return res
 
 inline_for_extraction
@@ -634,13 +621,20 @@ val freeable
   (a: array base t)
 : Tot prop
 
+val malloc_from_spec
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Tot prop
+
 val malloc_to
   (#t: Type0)
   (x: t)
   (n: size_t)
   (from: array_or_null_from (array_pcm_carrier t n) t)
 : Pure (array_or_null_to (array_pcm_carrier t n) t)
-    (requires (size_v n > 0))
+    (requires (size_v n > 0 /\ malloc_from_spec x n from))
     (ensures (fun to -> array_or_null_spec (from, to)))
 
 val malloc_from
@@ -648,7 +642,7 @@ val malloc_from
   (x: t)
   (n: size_t)
   (sq: squash (size_v n > 0))
-: Steel (array_or_null_from (array_pcm_carrier t n) t)
+: Steel (from: array_or_null_from (array_pcm_carrier t n) t { malloc_from_spec x n from })
     emp
     (fun r -> varray_or_null (r, malloc_to x n r))
     (requires fun _ -> True)
diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Connection.fst
index 166feb819c5..e2542f0d0dc 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Connection.fst
@@ -74,6 +74,13 @@ let morphism_compose (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fa
       fab.morph_compose x1 x2;
       fbc.morph_compose (fab.morph x1) (fab.morph x2))
 
+let morphism_compose_morph
+  (#a #b #c: Type) (#pa: pcm a) (#pb: pcm b) (#pc: pcm c) (fab: morphism pa pb) (fbc: morphism pb pc)
+  (x: a)
+: Lemma
+  ((morphism_compose fab fbc).morph x == fbc.morph (fab.morph x))
+= ()
+
 let morphism_id
   (#a: Type)
   (p: pcm a)

From 0e7230a23e3df94e87d8573cc758672dd3cac60a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 19 Oct 2021 19:03:50 -0700
Subject: [PATCH 291/513] Steel.C.Array.null_to_unique

---
 ulib/experimental/Steel.C.Array.fst  |  1 +
 ulib/experimental/Steel.C.Array.fsti | 11 +++++++++++
 2 files changed, 12 insertions(+)

diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index b11a6e002f0..90a87b94fce 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -221,6 +221,7 @@ let len (from, to) =
 
 let null_from _ _ = None
 let null_to _ _ = None
+let null_to_unique _ = ()
 
 let g_is_null a = None? (fst a)
 
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index cbb204f0e93..d987e4ee971 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -76,6 +76,17 @@ val null_to (base: Type u#0) (t: Type u#0) : Pure (array_or_null_to base t) (req
   array_or_null_spec (null_from base t, r0) /\
   len (null_from base t, r0) == zero_size))
 
+val null_to_unique
+  (#base #t: Type)
+  (to: array_or_null_to base t)
+: Lemma
+  (requires (
+    array_or_null_spec (null_from base t, to)
+  ))
+  (ensures (
+    to == null_to base t
+  ))
+
 inline_for_extraction
 let null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
 = (null_from base t, null_to base t)

From 88c8c15abe14f2f3a101bb13a25554727a5c72c0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 21 Oct 2021 15:23:44 -0700
Subject: [PATCH 292/513] strengthen effects for some Steel.C.Array primitives

---
 src/extraction/FStar.Extraction.Kremlin.fs |  6 ++---
 ulib/experimental/Steel.C.Array.fst        | 17 +++++++-----
 ulib/experimental/Steel.C.Array.fsti       | 30 +++++++++++++---------
 ulib/experimental/Steel.C.Ref.fsti         |  5 ++--
 4 files changed, 34 insertions(+), 24 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 72876ee4a6c..c0dce8c1482 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1312,15 +1312,15 @@ IsNull nodes should be added to the KReMLin AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.ref_of_array_from" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r])
     when string_of_mlpath p = "Steel.C.Array.mk_array_of_ref_from" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; r; _])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
     when string_of_mlpath p = "Steel.C.Array.intro_varray_from" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 90a87b94fce..187611aa2e1 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1086,9 +1086,10 @@ let g_mk_array_to #base #t #n r a
 
 #push-options "--z3rlimit 32"
 
-val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: Steel (array base t)
+: SteelAtomicBase (array base t)
+    false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
     (requires fun _ -> True)
@@ -1099,7 +1100,7 @@ val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Refe
   ))
 
 let intro_varray0
-  #base #t #n r sq
+  #base #t #_ #n r sq
 =
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
   let from = Some ({
@@ -1612,8 +1613,9 @@ let ref_of_array_ghost #inames #base #t x sq =
     (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
 
 #restart-solver
-val ref_of_array0 (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
-  : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+val ref_of_array0 (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+             false opened Unobservable
              (varray r)
              (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r') `star` v_ref_of_array r)
              (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
@@ -1815,8 +1817,9 @@ let mk_array_of_ref_from_spec
 
 let mk_array_of_ref_to #base #t r from = mk_array_of_ref_to' base t
 
-val mk_array_of_ref0 (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : Steel (array base t)
+val mk_array_of_ref0 (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array base t)
+             false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
              (requires fun _ -> True)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index d987e4ee971..af51e0ae56b 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -164,9 +164,10 @@ val g_mk_array_to
     g_mk_array r a0
   ))
 
-val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: Steel (al: array_or_null_from base t { g_mk_array_from r al })
+: SteelAtomicBase (al: array_or_null_from base t { g_mk_array_from r al })
+    false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun al -> varray (al, g_mk_array_to r al))
     (requires fun _ -> True)
@@ -177,9 +178,10 @@ val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.
   ))
 
 inline_for_extraction
-let intro_varray (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+let intro_varray (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: Steel (array base t)
+: SteelAtomicBase (array base t)
+  false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
     (requires fun _ -> True)
@@ -454,8 +456,9 @@ val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (s
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
-val ref_of_array_from (#base: Type) (#t:Type0) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
-  : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+val ref_of_array_from (#base: Type) (#t:Type0) (#opened: _) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+    false opened Unobservable
              (varray (r_from, r_to))
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
              (requires fun _ -> True)
@@ -468,8 +471,9 @@ val ref_of_array_from (#base: Type) (#t:Type0) (r_from:array_or_null_from base t
              )
 
 inline_for_extraction
-let ref_of_array (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
-  : Steel (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+let ref_of_array (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+    false opened Unobservable
              (varray r)
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
              (requires fun _ -> True)
@@ -520,8 +524,9 @@ val mk_array_of_ref_to
     g_is_null r' == false
   ))
 
-val mk_array_of_ref_from (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : Steel (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
+val mk_array_of_ref_from (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
+    false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
              (requires fun _ -> True)
@@ -534,8 +539,9 @@ val mk_array_of_ref_from (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base
              )
 
 inline_for_extraction
-let mk_array_of_ref (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : Steel (array base t)
+let mk_array_of_ref (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array base t)
+    false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
              (requires fun _ -> True)
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 4a3863c991e..68821330f46 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -88,10 +88,11 @@ val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
     (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
     (fun _ _ _ -> True)
 
-val focus (#p: pcm 'b) (r: ref 'a p)
+val focus (#opened: _) (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: Steel (ref 'a q)
+: A.SteelAtomicBase (ref 'a q)
+    false opened A.Unobservable
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
     (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)

From ba0ebaff5ab71ce34187e806a25864c3d9e571c4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 21 Oct 2021 15:24:09 -0700
Subject: [PATCH 293/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 28 ++++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 03737af9744..de6faf52f28 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -3306,10 +3306,10 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2::uu___3::[]);
              FStar_Extraction_ML_Syntax.mlty = uu___4;
              FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
+           uu___6::r::uu___7::uu___8::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.ref_of_array_from" -> translate_expr env1 r
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.ref_of_array_from" -> translate_expr env1 r
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3322,10 +3322,10 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2::uu___3::[]);
              FStar_Extraction_ML_Syntax.mlty = uu___4;
              FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
+           uu___6::r::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.mk_array_of_ref_from" ->
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.mk_array_of_ref_from" ->
           translate_expr env1 r
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -3339,14 +3339,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2::uu___3::[]);
              FStar_Extraction_ML_Syntax.mlty = uu___4;
              FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =

From f167586f2bc1a9eab5c8b96595c57ecd614c35c6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 21 Oct 2021 16:08:48 -0700
Subject: [PATCH 294/513] strengthen effect for Steel.C.Ref/Array.is_null

---
 src/extraction/FStar.Extraction.Kremlin.fs | 4 ++--
 ulib/experimental/Steel.C.Array.fsti       | 6 ++++--
 ulib/experimental/Steel.C.Ref.fsti         | 3 ++-
 ulib/experimental/Steel.C.Reference.fst    | 4 ++--
 4 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index c0dce8c1482..52f932bdd8f 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -1249,11 +1249,11 @@ TODO: these should be removed and those operators should be directly
 supported by KReMLin (in src/Builtin.ml) Or alternatively Null and
 IsNull nodes should be added to the KReMLin AST *)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [e; _ (* a' *); _ (* sq *) ])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.is_null_from"
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *); e; _ (* view *)])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); _ (* pcm *); e; _ (* view *)])
     when string_of_mlpath p = "Steel.C.Reference.is_null"
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index af51e0ae56b..1d24543e732 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -721,10 +721,11 @@ let free
 val is_null_from
   (#base: Type0)
   (#t: Type0)
+  (#opened: _)
   (a: array_or_null_from base t)
   (a' : array_or_null_to base t)
   (sq: squash (array_or_null_spec (a, a')))
-: Steel bool
+: SteelAtomicBase bool false opened Unobservable
     (varray_or_null (a, a'))
     (fun _ -> varray_or_null (a, a'))
     (requires fun _ -> True)
@@ -737,8 +738,9 @@ inline_for_extraction
 let is_null
   (#base: Type0)
   (#t: Type0)
+  (#opened: _)
   (a: array_or_null base t)
-: Steel bool
+: SteelAtomicBase bool false opened Unobservable
     (varray_or_null a)
     (fun _ -> varray_or_null a)
     (requires fun _ -> True)
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 68821330f46..4f8e564e703 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -360,11 +360,12 @@ let pts_to_view_or_null
 
 val is_null
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (#opened: _)
   (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
-: Steel bool
+: A.SteelAtomicBase bool false opened A.Unobservable
     (pts_to_view_or_null r vw)
     (fun _ -> pts_to_view_or_null r vw)
     (requires (fun _ -> True))
diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index d2a94c0df49..51c42e544a4 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -64,10 +64,10 @@ let pts_to_view_or_null
 = r `pts_to_view_or_null` view
 
 let is_null
-  (#a: Type u#0) (#b: Type u#b) (#c: Type0) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#c: Type0) (#opened: _) (#p: pcm b)
   (r: ptr a c p)
   (vw: sel_view p c false)
-: Steel bool
+: SteelAtomicBase bool false opened Unobservable
     (pts_to_view_or_null r vw)
     (fun _ -> pts_to_view_or_null r vw)
     (requires (fun _ -> True))

From 33f36c1b02d56466c3ae58a0589965abf14ac489 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 21 Oct 2021 16:10:30 -0700
Subject: [PATCH 295/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 28 ++++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index de6faf52f28..e20ba2676cb 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -3049,15 +3049,15 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::uu___5::uu___6::[])
+           uu___5::e1::uu___6::uu___7::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.is_null_from" ->
-          let uu___7 =
-            let uu___8 = let uu___9 = translate_expr env1 e1 in [uu___9] in
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
             ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___8) in
-          EApp uu___7
+              uu___9) in
+          EApp uu___8
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3070,15 +3070,15 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::[])
+           uu___5::uu___6::e1::uu___7::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Reference.is_null" ->
-          let uu___7 =
-            let uu___8 = let uu___9 = translate_expr env1 e1 in [uu___9] in
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
             ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___8) in
-          EApp uu___7
+              uu___9) in
+          EApp uu___8
       | FStar_Extraction_ML_Syntax.MLE_TApp
           ({
              FStar_Extraction_ML_Syntax.expr =

From b11a6345996618f0b154733446ecfc64d09fa378 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 22 Oct 2021 13:38:09 -0700
Subject: [PATCH 296/513] make varray_or_null VUnit

---
 examples/steel/arraystructs/HaclExample.fst |  8 +-
 ulib/experimental/Steel.C.Array.fst         | 93 ++++++++++++++++++++-
 ulib/experimental/Steel.C.Array.fsti        | 67 ++++++++++++++-
 3 files changed, 154 insertions(+), 14 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index ab5d26a5d14..84df355e89d 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -115,13 +115,9 @@ let test_alloc_free
   let a = malloc true (mk_size_t 42ul) in
   if Steel.C.Array.is_null a
   then begin
-    change_equal_slprop
-      (varray_or_null a)
-      emp
+    Steel.C.Array.elim_varray_or_null_none a
   end else begin
-    change_equal_slprop
-      (varray_or_null a)
-      (varray a);
+    Steel.C.Array.elim_varray_or_null_some a;
     free a
   end;
   return ()
diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 187611aa2e1..4d8a4fe1fd4 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -2010,6 +2010,93 @@ let upd_from
     (varray r0)
     (varray (r, r'))
 
+let varray_or_null0_rewrite
+  (#base #a: Type0)
+  (r: array_or_null base a)
+  (_: t_of emp)
+: Tot (option (array_view_type a (len r)))
+= None
+
+[@@__steel_reduce__]
+let varray_or_null0
+  (#base #a: Type0)
+  (r: array_or_null base a)
+: Tot vprop
+= if g_is_null r
+  then emp `vrewrite` varray_or_null0_rewrite r
+  else varray r `vrewrite` Some
+
+let is_array_or_null r = hp_of (varray_or_null0 r)
+let array_or_null_sel r = sel_of (varray_or_null0 r)
+
+let intro_varray_or_null_none x =
+  intro_vrewrite emp (varray_or_null0_rewrite x);
+  change_equal_slprop
+    (emp `vrewrite` varray_or_null0_rewrite x)
+    (varray_or_null0 x);
+  change_slprop_rel
+    (varray_or_null0 x)
+    (varray_or_null x)
+    (fun u v -> u == v)
+    (fun _ -> ())
+
+let intro_varray_or_null_some x =
+  intro_vrewrite (varray x) Some;
+  change_equal_slprop
+    (varray x `vrewrite` Some)
+    (varray_or_null0 x);
+  change_slprop_rel
+    (varray_or_null0 x)
+    (varray_or_null x)
+    (fun u v -> u == v)
+    (fun _ -> ())
+
+let elim_varray_or_null_some x =
+  change_slprop_rel
+    (varray_or_null x)
+    (varray_or_null0 x)
+    (fun u v -> u == v)
+    (fun _ -> ());
+  if g_is_null x
+  then begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (emp `vrewrite` varray_or_null0_rewrite x);
+    elim_vrewrite emp (varray_or_null0_rewrite x);
+    assert False;
+    change_equal_slprop
+      emp
+      (varray x)
+  end else begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (varray x `vrewrite` Some);
+    elim_vrewrite (varray x) Some
+  end
+
+let elim_varray_or_null_none x =
+  change_slprop_rel
+    (varray_or_null x)
+    (varray_or_null0 x)
+    (fun u v -> u == v)
+    (fun _ -> ());
+  if g_is_null x
+  then begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (emp `vrewrite` varray_or_null0_rewrite x);
+    elim_vrewrite emp (varray_or_null0_rewrite x)
+  end else begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (varray x `vrewrite` Some);
+    elim_vrewrite (varray x) Some;
+    assert False;
+    change_equal_slprop
+      (varray x)
+      emp
+  end
+
 #restart-solver
 let freeable
   #base #t a
@@ -2064,7 +2151,7 @@ val malloc0
       size_v n > 0 /\
       malloc_from_spec x n (fst r) /\
       snd r == malloc_to x n (fst r) /\
-      (g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x))
+      (g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x)))
     )
 
 #restart-solver
@@ -2077,9 +2164,7 @@ let malloc0
   let r0 = Steel.C.Ref.ref_alloc (array_pcm t n) c in
   Steel.C.Ref.pts_to_view_intro r0 c (array_view t n) v;
   let r = intro_varray r0 () in
-  change_equal_slprop
-    (varray r)
-    (varray_or_null r);
+  intro_varray_or_null_some r;
   return r
 
 let malloc_from
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 1d24543e732..d379e465497 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -627,8 +627,67 @@ let upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
       (varray (r0, r'))
       (varray r)
 
-let varray_or_null (#base: Type0) (#t: Type0) (x: array_or_null base t) : Tot vprop =
-  if g_is_null x then emp else varray x
+
+val is_array_or_null (#base #a:Type0) (r:array_or_null base a) : slprop u#1
+val array_or_null_sel (#base #a:Type0) (r:array_or_null base a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
+
+[@@ __steel_reduce__]
+let varray_or_null' #base #a (r: array_or_null base a) : GTot vprop' =
+  {hp = is_array_or_null r;
+   t = option (array_view_type a (len r));
+   sel = array_or_null_sel r}
+
+[@@ __steel_reduce__]
+let varray_or_null r = VUnit (varray_or_null' r)
+
+val intro_varray_or_null_none
+  (#opened: _)
+  (#base #a: Type)
+  (x: array_or_null base a)
+: SteelGhost unit opened
+    emp
+    (fun _ -> varray_or_null x)
+    (fun _ -> g_is_null x == true)
+    (fun _ _ h' -> h' (varray_or_null x) == None)
+
+val intro_varray_or_null_some
+  (#opened: _)
+  (#base #a: Type)
+  (x: array base a)
+: SteelGhost unit opened
+    (varray x)
+    (fun _ -> varray_or_null x)
+    (fun _ -> True)
+    (fun h _ h' ->
+      g_is_null x == false /\
+      h' (varray_or_null x) == Some (h (varray x)
+    ))
+
+val elim_varray_or_null_some
+  (#opened: _)
+  (#base #a: Type)
+  (x: array_or_null base a)
+: SteelGhost (squash (g_is_null x == false)) opened
+    (varray_or_null x)
+    (fun _ -> varray x)
+    (fun h -> g_is_null x == false \/ Some? (h (varray_or_null x)))
+    (fun h _ h' ->
+      g_is_null x == false /\
+      h (varray_or_null x) == Some (h' (varray x))
+    )
+
+val elim_varray_or_null_none
+  (#opened: _)
+  (#base #a: Type)
+  (x: array_or_null base a)
+: SteelGhost unit opened
+    (varray_or_null x)
+    (fun _ -> emp)
+    (fun h -> g_is_null x == true \/ None? (h (varray_or_null x)))
+    (fun h _ _ ->
+      g_is_null x == true /\
+      h (varray_or_null x) == None
+    )
 
 /// Allocates an array of size [n] where all cells have initial value [x]
 
@@ -666,7 +725,7 @@ val malloc_from
     (ensures fun _ r0 h' ->
       size_v n > 0 /\
       begin let r : array_or_null (array_pcm_carrier t n) t = (r0, malloc_to x n r0) in
-      g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x)
+      g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
       end
     )
 
@@ -680,7 +739,7 @@ let malloc
     (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
     (ensures fun _ r h' ->
-      g_is_null r == false ==> (freeable r /\ h' (varray r) == Seq.create (size_v n) x)
+      g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
     )
 = let r0 = malloc_from x n () in
   let r = (r0, malloc_to x n r0) in

From 49dac2f447e8b635515fb75fc45366333521a58c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sat, 23 Oct 2021 14:29:08 -0700
Subject: [PATCH 297/513] Steel.C.Array -> Steel.C.Array.Base, except index and
 upd

index and upd can be implemented against the rest of the array
library without the need for leaking abstraction. By hiding the
definition of arrays from the implementation of index and upd,
we gain something like 20 minutes of verification time.
---
 src/extraction/FStar.Extraction.Kremlin.fs |   24 +-
 ulib/experimental/Steel.C.Array.Base.fst   | 2097 ++++++++++++++++++++
 ulib/experimental/Steel.C.Array.Base.fsti  |  749 +++++++
 ulib/experimental/Steel.C.Array.fst        | 2089 -------------------
 ulib/experimental/Steel.C.Array.fsti       |  722 +------
 5 files changed, 2859 insertions(+), 2822 deletions(-)
 create mode 100644 ulib/experimental/Steel.C.Array.Base.fst
 create mode 100644 ulib/experimental/Steel.C.Array.Base.fsti

diff --git a/src/extraction/FStar.Extraction.Kremlin.fs b/src/extraction/FStar.Extraction.Kremlin.fs
index 52f932bdd8f..0a5ee73071d 100644
--- a/src/extraction/FStar.Extraction.Kremlin.fs
+++ b/src/extraction/FStar.Extraction.Kremlin.fs
@@ -765,14 +765,14 @@ and translate_type_without_decay env t: typ =
       TBuf (translate_type_without_decay env arg)
       
   | MLTY_Named ([t; n; s], p)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
     ->
       TArray (
         translate_type_without_decay env t,
         (UInt32, string_of_int (must (int_of_typenat n))))
   
   | MLTY_Named ([_; arg], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Array.array_or_null_from"
+    Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_or_null_from"
     ->
       TBuf (translate_type_without_decay env arg)
   
@@ -854,12 +854,12 @@ and translate_type env t: typ =
   // The outermost array type constructor decays to pointer
   match t with
   | MLTY_Named ([t; _; _], p)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type_sized"
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
     ->
       TBuf (translate_type_without_decay env t)
       
   | MLTY_Named ([t; _], p)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.array_view_type"
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type"
     ->
       TBuf (translate_type_without_decay env t)
       
@@ -1029,7 +1029,7 @@ and translate_expr env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _ (* sq *) ])
     when (
-          string_of_mlpath p = "Steel.C.Array.malloc_from" ||
+          string_of_mlpath p = "Steel.C.Array.Base.malloc_from" ||
           false) ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
@@ -1062,7 +1062,7 @@ and translate_expr env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2; _ (* a' *); _ (* sq *) ])
     when (
-          string_of_mlpath p = "Steel.C.Array.free_from" ||
+          string_of_mlpath p = "Steel.C.Array.Base.free_from" ||
           false) ->
       EBufFree (translate_expr env e2)
 
@@ -1250,7 +1250,7 @@ supported by KReMLin (in src/Builtin.ml) Or alternatively Null and
 IsNull nodes should be added to the KReMLin AST *)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
-    when string_of_mlpath p = "Steel.C.Array.is_null_from"
+    when string_of_mlpath p = "Steel.C.Array.Base.is_null_from"
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); _ (* pcm *); e; _ (* view *)])
@@ -1258,7 +1258,7 @@ IsNull nodes should be added to the KReMLin AST *)
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
   | MLE_TApp ({expr=MLE_Name p}, _)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.null_from"
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.null_from"
     -> EQualified (["LowStar"; "Buffer"], "null")
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *)])
@@ -1313,15 +1313,15 @@ IsNull nodes should be added to the KReMLin AST *)
         translate_expr env x)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
-    when string_of_mlpath p = "Steel.C.Array.ref_of_array_from" ->
+    when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
       translate_expr env r
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r])
-    when string_of_mlpath p = "Steel.C.Array.mk_array_of_ref_from" ->
+    when string_of_mlpath p = "Steel.C.Array.Base.mk_array_of_ref_from" ->
       translate_expr env r
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
-    when string_of_mlpath p = "Steel.C.Array.intro_varray_from" ->
+    when string_of_mlpath p = "Steel.C.Array.Base.intro_varray_from" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i])
@@ -1333,7 +1333,7 @@ IsNull nodes should be added to the KReMLin AST *)
       EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
-    when string_of_mlpath p = "Steel.C.Array.split_right_from" ->
+    when string_of_mlpath p = "Steel.C.Array.Base.split_right_from" ->
       EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
diff --git a/ulib/experimental/Steel.C.Array.Base.fst b/ulib/experimental/Steel.C.Array.Base.fst
new file mode 100644
index 00000000000..7bed43a9046
--- /dev/null
+++ b/ulib/experimental/Steel.C.Array.Base.fst
@@ -0,0 +1,2097 @@
+module Steel.C.Array.Base
+
+module S = Steel.C.Struct
+
+#push-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
+let half_perm
+  (p: Steel.FractionalPermission.perm)
+: Pure Steel.FractionalPermission.perm
+  (requires True)
+  (ensures (fun y ->
+    y `Steel.FractionalPermission.sum_perm` y == p /\
+    y == Steel.FractionalPermission.half_perm p
+  ))
+= 
+  let open Steel.FractionalPermission in
+  let open FStar.Real in
+  assert ((p.v /. 2.0R) +. (p.v /. 2.0R) == p.v);
+  MkPerm (p.v /. 2.0R)
+#pop-options
+
+let array_domain
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+: Tot Type0
+= (x: size_t { size_v x < size_v n })
+
+let array_range
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain t n)
+: Tot Type0
+= option t
+
+open FStar.FunctionalExtensionality
+
+let array_pcm_carrier t n = restricted_t (array_domain t n) (array_range t n)
+
+let array_pcm_carrier_ext
+  (t: Type)
+  (n: size_t)
+  (x1 x2: array_pcm_carrier t n)
+  (f: (
+    (i: array_domain t n) ->
+    Lemma
+    (x1 i == x2 i)
+  ))
+: Lemma
+  (ensures (x1 == x2))
+= Classical.forall_intro f;
+  assert (x1 `feq` x2)
+
+let array_elements_pcm
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain t n)
+: Tot (Steel.C.PCM.pcm (array_range t n x))
+= Steel.C.Opt.opt_pcm #t
+
+let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
+
+[@"opaque_to_smt"]
+let rec raise_list_array_domain
+  (t: Type u#0)
+  (n n': size_t)
+  (l: list (array_domain t n))
+: Pure (list (array_domain t n'))
+  (requires (size_v n' >= size_v n))
+  (ensures (fun l' ->
+    (forall (x': array_domain t n') . List.Tot.mem x' l' <==> (size_v x' < size_v n /\ List.Tot.mem x' l)) /\
+    List.Tot.length l' == List.Tot.length l
+  ))
+= match l with
+  | [] -> []
+  | x :: l_ -> x :: raise_list_array_domain t n n' l_
+
+[@"opaque_to_smt"]
+let rec included_indices
+  (t: Type u#0)
+  (n: size_t)
+: Pure (list (array_domain t n))
+  (requires True)
+  (ensures (fun l ->
+    (forall (x: array_domain t n) . List.Tot.mem x l) /\
+    List.Tot.length l == size_v n
+  ))
+  (decreases (size_v n))
+= if n = mk_size_t (FStar.UInt32.uint_to_t 0)
+  then []
+  else
+    let n' = size_sub n (mk_size_t (FStar.UInt32.uint_to_t 1)) in
+    n' :: raise_list_array_domain t n' n (included_indices t n')
+
+let array_elements_view_type
+  (t: Type u#0)
+  (n: size_t)
+  (k: array_domain t n)
+: Tot Type0
+= t
+
+let array_elements_view
+  (t: Type u#0)
+  (n: size_t)
+  (k: array_domain t n)
+: Tot (Steel.C.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
+= Steel.C.Opt.opt_view _
+
+let intro_array_view_init
+  (t: Type u#0)
+  (n: size_t)
+  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+  (k: nat { k < size_v n })
+: Tot t
+= x (int_to_size_t k)
+
+let intro_array_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+: Tot (array_view_type t n)
+= Seq.init (size_v n) (intro_array_view_init t n x)
+
+let array_to_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+: Tot (array_view_type t n)
+= intro_array_view t n (S.struct_view_to_view (array_elements_view t n) (included_indices t n) x)
+
+let elim_array_view_f
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+  (k: Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
+: Tot (array_elements_view_type t n k)
+= Seq.index x (size_v k)
+
+let elim_array_view
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+: Tot (restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+= on_dom (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
+
+let array_to_carrier
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+: Tot (Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+= S.struct_view_to_carrier (array_elements_view t n) (included_indices t n) (elim_array_view t n x)
+
+open Steel.C.PCM
+
+let array_view_to_view_frame
+  (t: Type u#0)
+  (n: size_t)
+  (x: array_view_type t n)
+  (frame: array_pcm_carrier t n)
+: Lemma
+    (requires (composable (array_pcm t n) (array_to_carrier t n x) frame))
+    (ensures
+      S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)
+        (op (array_pcm t n) (array_to_carrier t n x) frame) /\ 
+      array_to_view t n
+        (op (array_pcm t n) (array_to_carrier t n x) frame) `Seq.equal` x)
+= S.struct_view_to_view_frame (array_elements_view t n) (included_indices t n)
+    (elim_array_view t n x) frame
+
+let array_view' (t: Type u#0) (n: size_t)
+  : Tot (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
+=
+  let open Steel.C.Ref in
+  {
+    to_view_prop = S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n);
+    to_view = array_to_view t n;
+    to_carrier = array_to_carrier t n;
+    to_carrier_not_one = (S.struct_view (array_elements_view t n) (included_indices t n)).to_carrier_not_one;
+    to_view_frame = array_view_to_view_frame t n;
+  }
+
+let array_view t n =
+  assert (size_v n > 0);
+  array_view' t n
+
+noeq
+type array_from0 base t = {
+  base_len: Ghost.erased size_t;
+  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
+  from: size_t;
+  perm_ref: Steel.Reference.ghost_ref unit;
+}
+
+[@@erasable]
+noeq
+type array_to0 = {
+  to: size_t;
+  perm_val: Steel.FractionalPermission.perm;
+}
+
+let array0_spec
+  (#base: _)
+  (#t: _)
+  (from: array_from0 base t)
+  (to: array_to0)
+: Tot prop
+=
+    size_v from.base_len >= 0 /\
+    size_v from.from <= size_v to.to /\
+    size_v to.to <= size_v from.base_len
+
+let array_or_null_from base t = option (array_from0 base t)
+let array_or_null_to base t = Ghost.erased (option array_to0)
+let array_or_null_spec (from, to) =
+  None? from == None? to /\
+  ((Some? from \/ Some? to) ==> array0_spec (Some?.v from) (Some?.v to))
+
+let len (from, to) =
+  match from with
+  | Some from ->
+    let Some to = Ghost.reveal to in to.to `size_sub` from.from
+  | _ -> zero_size
+
+let null_from _ _ = None
+let null_to _ _ = None
+let null_to_unique _ = ()
+
+let g_is_null a = None? (fst a)
+
+let rec array_is_unit_aux
+  (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
+  (i: size_t)
+  (f:
+    (j: size_t) ->
+    Lemma
+    (requires (size_v j < size_v n - size_v i))
+    (ensures (size_v j < size_v n - size_v i /\ a j == one (array_elements_pcm t n j)))
+  )
+: Pure bool
+  (requires True)
+  (ensures (fun y -> y == true <==> (forall j . size_v j < size_v n ==> a j == one (array_elements_pcm t n j))))
+  (decreases (size_v i))
+= Classical.forall_intro (Classical.move_requires f);
+  if size_le i zero_size
+  then true
+  else
+    let i' = size_sub i one_size in
+    if not (size_le i n)
+    then array_is_unit_aux t n a i' (fun _ -> ())
+    else if None? (a (size_sub n i))
+    then array_is_unit_aux t n a i' (fun j -> if j = size_sub n i then () else f j)
+    else false
+
+let array_is_unit_lemma
+  (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
+: Lemma
+  (requires (forall (j: array_domain  t n) . a j == one (array_elements_pcm t n j)))
+  (ensures (a == one (array_pcm t n)))
+= S.ext a (one (array_pcm t n)) (fun _ -> ())
+
+let array_is_unit t n a =
+  Classical.move_requires (array_is_unit_lemma t n) a;
+  array_is_unit_aux t n a n (fun _ -> ())
+
+let array_large_to_small_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+: Tot (array_pcm_carrier t (to `size_sub` from))
+= on_dom (array_domain t (to `size_sub` from)) (fun k -> x (from `size_add` k))
+
+let array_large_to_small_f_eq
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+  (k: array_domain t (to `size_sub` from))
+: Lemma
+  (array_large_to_small_f t base_len from to sq x k == x (from `size_add` k))
+= ()
+
+let array_large_to_small_f_eq'
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+  (k' : array_domain t base_len)
+: Lemma
+  (requires (
+    size_v from <= size_v k' /\
+    size_v k' < size_v to
+  ))
+  (ensures (
+    array_large_to_small_f t base_len from to sq x (k' `size_sub` from) == x k'
+  ))
+= ()
+
+let array_large_to_small
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: Ghost.erased size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Tot (Steel.C.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
+= Steel.C.Connection.mkmorphism
+    (array_large_to_small_f t base_len from to sq)
+    (assert (array_large_to_small_f t base_len from to sq (one (array_pcm t base_len)) `feq` one (array_pcm t (to `size_sub` from))))
+    (fun x1 x2 ->
+      assert (array_large_to_small_f t base_len from to sq (op (array_pcm t base_len) x1 x2) `feq` op (array_pcm t (to `size_sub` from)) (array_large_to_small_f t base_len from to sq x1)  (array_large_to_small_f t base_len from to sq x2))
+    )
+
+let array_small_to_large_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t) // Tot, argh
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t (to `size_sub` from))
+: Tot (array_pcm_carrier t base_len)
+= on_dom (array_domain t base_len) (fun k -> if size_le from k && not (size_le to k) then x (k `size_sub` from)
+  else one (Steel.C.Opt.opt_pcm #t))
+
+let array_small_to_large
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Tot (Steel.C.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
+= Steel.C.Connection.mkmorphism
+    (array_small_to_large_f t base_len from to sq)
+    (assert (array_small_to_large_f t base_len from to sq (one (array_pcm t (to `size_sub` from))) `feq` one (array_pcm t (base_len))))
+    (fun x1 x2 ->
+      assert (array_small_to_large_f t base_len from to sq (op (array_pcm t (to `size_sub` from)) x1 x2) `feq` op (array_pcm t (base_len)) (array_small_to_large_f t base_len from to sq x1)  (array_small_to_large_f t base_len from to sq x2))
+    )
+
+let array_small_to_large_to_small
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Lemma
+  (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
+= assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
+
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+let size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
+  (requires True)
+  (ensures (fun z -> size_v z == size_v x - size_v y))
+= size_sub x y
+
+#restart-solver
+
+let array_conn_fpu_compatible
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Lemma
+  (
+    let z = size_sub to from in
+    let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+    compatible (array_pcm t z) x v_small
+  )
+=
+  let z = size_sub to from in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
+  let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
+  S.prod_pcm_composable_intro
+    (array_elements_pcm t z)
+    x
+    frame_small
+    (fun h ->
+      assert (composable (Steel.C.Opt.opt_pcm #t) (array_small_to_large_f t base_len from to sq x (from `size_add` h)) (Ghost.reveal frame (from `size_add` h))
+      )
+    );
+  assert (composable (array_pcm t (z)) x frame_small);
+  array_pcm_carrier_ext t z (op (array_pcm t (z)) x frame_small) v_small (fun i ->
+    assert (op (Steel.C.Opt.opt_pcm #t) (array_small_to_large_f t base_len from to sq x (from `size_add` i)) (Ghost.reveal frame (from `size_add` i)) == v (from `size_add` i))
+  );
+  compatible_intro (array_pcm t (z)) x v_small frame_small
+
+let array_conn_fpu_refine
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Lemma
+  (
+    let z = size_sub to from in
+    let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+    p_refine (array_pcm t (z)) v_small
+  )
+=
+  let z = size_sub to from in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (x: array_domain t z) . True)
+  then ()
+  else assert (Ghost.reveal x `feq` one (array_pcm t z))
+
+let overwrite_array_slice
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+: Tot (array_pcm_carrier t base_len)
+=
+    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
+      if from `size_le` k && not (to `size_le` k)
+      then begin
+        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
+        v_small' (size_sub' k from sq2) <: option t
+      end
+      else v k
+    )
+
+let overwrite_array_slice_index
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+  (k: array_domain t base_len)
+: Lemma (
+    overwrite_array_slice t base_len from to sq v v_small' k == (
+    if size_v from <= size_v k && size_v k < size_v to
+    then v_small' (k `size_sub` from)
+    else v k
+  ))
+= ()
+
+let overwrite_array_slice_index_in
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+  (k: array_domain t base_len)
+: Lemma
+  (requires (
+    size_v from <= size_v k /\ size_v k < size_v to
+  ))
+  (ensures (
+    overwrite_array_slice t base_len from to sq v v_small' k == v_small' (k `size_sub` from)
+  ))
+= ()
+
+let overwrite_array_slice_index_out
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t (to `size_sub` from))
+  (k: array_domain t base_len)
+: Lemma
+  (requires (
+    ~ (size_v from <= size_v k /\ size_v k < size_v to)
+  ))
+  (ensures (
+    overwrite_array_slice t base_len from to sq v v_small' k == v k
+  ))
+= ()
+
+let overwrite_array_slice_id
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (v: array_pcm_carrier t base_len)
+  (v_small' : array_pcm_carrier t base_len)
+: Lemma
+  (overwrite_array_slice t base_len zero_size base_len () v v_small' == v_small')
+= array_pcm_carrier_ext t base_len
+    (overwrite_array_slice t base_len zero_size base_len () v v_small')
+    v_small'
+    (fun i -> ())
+
+let array_conn_fpu_f
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
+: Tot (array_pcm_carrier t base_len)
+= let sq0 : squash (size_v to >= size_v from) = () in
+  let z : size_t = size_sub' to from sq0 in
+  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
+  array_conn_fpu_compatible t base_len from to sq x v;
+  array_conn_fpu_refine t base_len from to sq x v;
+  let v_small' : array_pcm_carrier t z = f v_small in
+  overwrite_array_slice t base_len from to sq v v_small'
+
+#pop-options
+
+let array_conn
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+: Steel.C.Connection.connection
+    (array_pcm t base_len)
+    (array_pcm t (to `size_sub` from))
+=
+  Steel.C.Connection.mkconnection1
+    (array_small_to_large t base_len from to sq)
+    (array_large_to_small t base_len from to sq)
+    (array_small_to_large_to_small t base_len from to sq)
+    (array_conn_fpu_f t base_len from to sq)
+    (fun x y f v -> assume False)
+
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
+#restart-solver
+
+let array_conn_fpu_eq
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
+  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
+  (f: Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))  
+: Lemma
+  (let open Steel.C.Connection in
+  ((array_conn t base_len from to sq).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == array_conn_fpu_f t base_len from to sq x y f v)
+= ()
+
+#restart-solver
+
+let connection_eq_gen
+  #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Connection.connection` q1)
+  #b2 (#q2: pcm b2) (c2: p `Steel.C.Connection.connection` q2)
+  (sq: squash (
+    b1 == b2 /\
+    q1 == q2 /\
+    c1.conn_small_to_large.morph `feq` c2.conn_small_to_large.morph /\
+    c1.conn_large_to_small.morph `feq` c2.conn_large_to_small.morph
+  ))
+  (phi:
+    (x1: Ghost.erased b1 { ~ (Ghost.reveal x1 == one q1) }) ->
+    (y1: Ghost.erased b1) ->
+    (f1: Steel.C.Connection.restricted_frame_preserving_upd q1 x1 y1) ->
+    (v1: frame_preserving_upd_dom p (c1.conn_small_to_large.morph x1)) ->
+    (x2: Ghost.erased b2 { ~ (Ghost.reveal x2 == one q2) }) ->
+    (y2: Ghost.erased b2) ->
+    (f2: Steel.C.Connection.restricted_frame_preserving_upd q2 x2 y2) ->
+    (v2: frame_preserving_upd_dom p (c2.conn_small_to_large.morph x2)) ->
+    (sq': squash (
+      x1 == x2 /\
+      y1 == y2 /\
+      f1 == f2 /\
+      v1 == v2
+    )) ->
+    Tot
+    (squash ((c1.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1 })).fpu_f v1 == (c2.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2 })).fpu_f v2))
+  )
+: Lemma
+  (c1 == c2)
+= Steel.C.Connection.connection_eq_gen c1 c2 () (fun x y f v -> phi x y f v x y f v ())
+
+#restart-solver
+let array_conn_id
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+: Lemma
+  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id (array_pcm t base_len))
+= let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
+  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
+  assert (forall x . array_small_to_large_f t base_len z base_len () x == x);
+  assert (forall x . array_large_to_small_f t base_len z base_len () x `feq` x);
+  assert (forall x . array_large_to_small_f t base_len z base_len () x == x);
+  let c = array_conn t base_len z base_len () in
+  connection_eq_gen
+    c
+    (Steel.C.Connection.connection_id (array_pcm t base_len))
+    ()
+    (fun x1 y1 f1 v1 x2 y2 f2 v2 sq12 ->
+      let v_small : array_pcm_carrier t base_len = array_large_to_small_f t base_len z base_len () v1 in
+      assert (v_small == v1);
+      array_conn_fpu_compatible t base_len z base_len () x1 v1;
+      array_conn_fpu_refine t base_len z base_len () x1 v1;
+      let v_small' : array_pcm_carrier t base_len = f1 v1 in
+      overwrite_array_slice_id t base_len v1 v_small';
+      let s' : array_pcm_carrier t base_len = overwrite_array_slice t base_len z base_len () v1 v_small' in
+      assert (array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1 == s');
+      assert (s' == f1 v1);
+      assert ((c.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1; })).Steel.C.Connection.fpu_f v1 == array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1);
+      Steel.C.Connection.connection_id_fpu (array_pcm t base_len) x2 y2 f2 v2;
+      assert (((Steel.C.Connection.connection_id (array_pcm t base_len)).conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2; })).Steel.C.Connection.fpu_f v2 == f2 v2);
+      ()
+    )
+
+let ifthenelse_prf
+  (p: prop)
+  (cond: bool)
+  (iftrue: squash (cond == true) -> Lemma p)
+  (iffalse: squash (cond == false) -> Lemma p)
+: Lemma p
+= if cond
+  then iftrue ()
+  else iffalse ()
+
+#restart-solver
+let array_conn_compose_morphisms
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (h: squash (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+: Tot (squash (
+      let z = to1 `size_sub` from1 in
+      let c1 = array_conn t base_len from1 to1 () in
+      let c2 = array_conn t z from2 to2 () in
+      let cc = c1 `Steel.C.Connection.connection_compose` c2 in
+      let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
+      cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
+      cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
+  ))
+=
+  let z = to1 `size_sub` from1 in
+  let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
+  let _ : squash (sz == size_sub to2 from2) = () in
+  assert (forall x . array_small_to_large_f t base_len from1 to1 () (array_small_to_large_f t z from2 to2 ()  x) `feq` array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
+  assert (forall x . array_large_to_small_f t z from2 to2 () (array_large_to_small_f t base_len from1 to1 () x) `feq` array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x)
+
+#push-options "--print_implicits --z3rlimit 256"
+
+let size_sub_size_add_l
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+: Lemma
+  ((from1 `size_add` to2) `size_sub` (from1 `size_add` from2) == to2 `size_sub` from2)
+= ()
+
+let size_sub_size_sub
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (i: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v from1 + size_v to2 <= size_v to1 /\
+    size_v from1 + size_v from2 <= size_v i /\
+    size_v i <= size_v from1 + size_v to2
+  ))
+: Lemma
+  ((i `size_sub` from1) `size_sub` from2 == i `size_sub` (from1 `size_add` from2))
+= ()
+
+let array_large_to_small_f_compose
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+  (a: array_pcm_carrier t base_len)
+: Lemma
+  (array_large_to_small_f t (to1 `size_sub` from1) from2 to2 () (array_large_to_small_f t base_len from1 to1 () a) ==
+    array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () a)
+= assert (
+  (array_large_to_small_f t (to1 `size_sub` from1) from2 to2 () (array_large_to_small_f t base_len from1 to1 () a) `feq`
+    array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () a)
+  )
+
+#restart-solver
+let array_conn_compose_fpu
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+  (sq: squash (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+  (x: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)) {~ (Ghost.reveal x == one (array_pcm t (to2 `size_sub` from2)))})
+  (y: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)))
+  (f: frame_preserving_upd (array_pcm t (to2 `size_sub` from2)) x y)
+  (x2: Ghost.erased (array_pcm_carrier t (to1 `size_sub` from1)))
+  (sqx2: squash (
+    Ghost.reveal x2 == array_small_to_large_f t (to1 `size_sub` from1) from2 to2 () x /\
+    (~ (Ghost.reveal x2 == one (array_pcm t (to1 `size_sub` from1))))
+  ))
+  (y2: Ghost.erased (array_pcm_carrier t (to1 `size_sub` from1)))
+  (sqy2: squash (
+    Ghost.reveal y2 == array_small_to_large_f t (to1 `size_sub` from1) from2 to2 () y
+  ))
+  (f2: frame_preserving_upd (array_pcm t (to1 `size_sub` from1)) x2 y2)
+  (sqf2: (
+    (v: frame_preserving_upd_dom (array_pcm t (to1 `size_sub` from1)) x2) ->
+    Lemma
+    (f2 v == array_conn_fpu_f t (to1 `size_sub` from1) from2 to2 () x y f v)
+  ))
+  (x0: Ghost.erased (array_pcm_carrier t base_len))
+  (sqx0: squash (
+    Ghost.reveal x0 == array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x /\
+    Ghost.reveal x0 == array_small_to_large_f t base_len from1 to1 () x2 /\
+    (~ (Ghost.reveal x0 == one (array_pcm t base_len)))
+  ))
+  (v: frame_preserving_upd_dom (array_pcm t base_len) x0)
+: Lemma
+  (ensures (
+    array_conn_fpu_f t base_len from1 to1 () x2 y2 f2 v == array_conn_fpu_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x y f v
+  ))
+= let al : array_pcm_carrier t base_len = array_conn_fpu_f t base_len from1 to1 () x2 y2 f2 v in
+  array_conn_fpu_compatible t base_len from1 to1 () x2 v;
+  array_conn_fpu_refine t base_len from1 to1 () x2 v;
+  let sz1 = to1 `size_sub` from1 in
+  let v_l_out_small : array_pcm_carrier t sz1 = array_large_to_small_f t base_len from1 to1 () v in
+  sqf2 v_l_out_small;
+  array_conn_fpu_compatible t sz1 from2 to2 () x v_l_out_small;
+  array_conn_fpu_refine t sz1 from2 to2 () x v_l_out_small;
+  let sz2 = to2 `size_sub` from2 in
+  let v_l_in_small : array_pcm_carrier t sz2 = array_large_to_small_f t sz1 from2 to2 () v_l_out_small in
+  let v_l_in_small' : array_pcm_carrier t sz2 = f v_l_in_small in
+  let v_l_in' : array_pcm_carrier t sz1 = overwrite_array_slice t sz1 from2 to2 () v_l_out_small v_l_in_small' in
+  let v_l' : array_pcm_carrier t base_len = overwrite_array_slice t base_len from1 to1 () v v_l_in' in
+  assert (v_l' == al);
+  let from = from1 `size_add` from2 in
+  let to = from1 `size_add` to2 in
+  let _ : squash (sz2 == to `size_sub` from) = size_sub_size_add_l from1 to1 from2 to2 () in
+  let ar : array_pcm_carrier t base_len = array_conn_fpu_f t base_len from to () x y f v in
+  array_conn_fpu_compatible t base_len from to () x v;
+  array_conn_fpu_refine t base_len from to () x v;
+  let v_r_small : array_pcm_carrier t sz2 = array_large_to_small_f t base_len from to () v in
+  let _ : squash (v_r_small == v_l_in_small) = array_large_to_small_f_compose t base_len from1 to1 from2 to2 () v in
+  let v_r_small' : array_pcm_carrier t sz2 = f v_r_small in
+  assert (v_r_small' == v_l_in_small');
+  let v_r' : array_pcm_carrier t base_len = overwrite_array_slice t base_len from to () v v_r_small' in
+  assert (v_r' == ar);
+  array_pcm_carrier_ext t base_len v_l' v_r' (fun i ->
+    overwrite_array_slice_index t base_len from1 to1 () v v_l_in' i;
+    overwrite_array_slice_index t base_len from to () v v_r_small' i;
+    if size_v from1 <= size_v i && size_v i < size_v to1
+    then begin
+      let i' : array_domain t sz1 = i `size_sub` from1 in
+      let b = (size_v from2 <= size_v i' && size_v i' < size_v to2) in
+      assert ((size_v (from1 `size_add` from2) <= size_v i && size_v i < size_v (from1 `size_add` to2)) == b);
+      overwrite_array_slice_index t sz1 from2 to2 () v_l_out_small v_l_in_small' i';
+      if size_v from2 <= size_v i' && size_v i' < size_v to2
+      then begin
+        size_sub_size_sub from1 to1 from2 to2 i ()
+      end else begin
+        assert (f2 v_l_out_small i' == v_l_out_small i');
+        array_large_to_small_f_eq' t base_len from1 to1 () v i
+      end
+    end else begin
+      assert ((size_v (from1 `size_add` from2) <= size_v i && size_v i < size_v (from1 `size_add` to2)) == false)
+    end
+  )
+
+#restart-solver
+let array_conn_compose
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from1: size_t)
+  (to1: size_t)
+  (from2: size_t)
+  (to2: size_t)
+: Lemma
+  (requires (
+    size_v from1 <= size_v to1 /\
+    size_v to1 <= size_v base_len /\
+    size_v from2 <= size_v to2 /\
+    size_v from1 + size_v to2 <= size_v to1
+  ))
+  (ensures (
+    array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t (to1 `size_sub` from1) from2 to2 () ==
+    array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) ()
+  ))
+=
+  let z = to1 `size_sub` from1 in
+  let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
+  let _ : squash (sz == size_sub to2 from2) = () in
+  let c1 = array_conn t base_len from1 to1 () in
+  let c2 = array_conn t z from2 to2 () in
+  let cc = c1 `Steel.C.Connection.connection_compose` c2 in
+  let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
+  let sq : squash (
+      cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
+      cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
+  ) =
+    array_conn_compose_morphisms t base_len from1 to1 from2 to2 ()
+  in
+  Steel.C.Connection.connection_eq_gen cc c sq (fun x y f v ->
+    let open Steel.C.Connection in
+    let x' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph x in
+    let y' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph y in
+    let phi = mk_restricted_frame_preserving_upd (c2.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })) in
+    connection_compose_fpu
+      c1
+      c2
+      x y f
+      phi;
+    array_conn_fpu_eq t base_len from1 to1 () x' y' phi v;
+    array_conn_fpu_eq t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x y f v;
+    array_conn_compose_fpu
+      t base_len from1 to1 from2 to2 ()
+      x y f
+      x' () y' ()
+      phi
+      (fun v' ->
+        array_conn_fpu_eq t z from2 to2 () x y f v'
+      )
+      (cc.conn_small_to_large.morph x)
+      ()
+      v
+  )
+
+
+#pop-options
+
+#restart-solver
+
+let to_view_array_conn
+  (t: Type0)
+  (base_len: Ghost.erased size_t)
+  (from: size_t)
+  (to: size_t)
+  (sq: squash (
+    size_v from <= size_v to /\
+    size_v to <= size_v base_len
+  ))
+  (x: array_pcm_carrier t base_len)
+: Lemma
+  (requires (
+    S.struct_view_to_view_prop (array_elements_view t base_len) (included_indices t base_len) x 
+  ))
+  (ensures (
+    let x' = array_large_to_small_f t base_len from to sq x in
+    S.struct_view_to_view_prop (array_elements_view t (to `size_sub` from)) (included_indices t (to `size_sub` from)) x' /\
+    array_to_view t (to `size_sub` from) x' `Seq.equal` Seq.slice (array_to_view t base_len x) (size_v from) (size_v to)
+  ))
+= ()
+
+#pop-options
+
+let array__base_len
+  (#base #t: _)
+  (a: array base t)
+: GTot size_t
+= (Some?.v (fst a)).base_len
+
+let array__base_ref
+  (#base #t: _)
+  (a: array base t)
+: Tot (Steel.C.Reference.ref base (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
+= (Some?.v (fst a)).base_ref
+
+let array__from
+  (#base #t: _)
+  (a: array base t)
+: Tot size_t
+= (Some?.v (fst a)).from
+
+let array__to
+  (#base #t: _)
+  (a: array base t)
+: GTot size_t
+= (Some?.v (snd a)).to
+
+let array__perm_ref
+  (#base #t: _)
+  (a: array base t)
+: Tot (Steel.Reference.ghost_ref unit)
+= (Some?.v (fst a)).perm_ref
+
+let array__perm_val
+  (#base #t: _)
+  (a: array base t)
+: Tot Steel.FractionalPermission.perm
+= (Some?.v (snd a)).perm_val
+
+let array_as_ref_conn
+  (#base: Type)
+  (#t: Type)
+  (a: array base t)
+: GTot (Steel.C.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
+= array_conn t (array__base_len a) (array__from a) (array__to a) ()
+
+let array_as_ref
+  (#base: Type)
+  (#t: Type)
+  (a: array base t)
+: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+= Steel.C.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
+
+[@@__steel_reduce__]
+let varray0
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: Tot vprop
+= Steel.C.Ref.pts_to_view
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+
+[@@__steel_reduce__]
+let varray9
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: Tot vprop
+= (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x)  (array__perm_val x)) `vrewrite` fst
+
+let varray_hp #base #t x = hp_of (varray9 #base #t x)
+
+#push-options "--debug Steel.C.Array --debug_level Extreme"
+
+let varray_sel #base #t x = sel_of (varray9 #base #t x)
+
+#pop-options
+
+let intro_varray1
+  (#inames: _)
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: SteelGhost unit inames
+    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
+    (fun _ -> varray x)
+    (fun _ -> True)
+    (fun h _ h' -> h' (varray x) == h (varray0 x))
+= intro_vrewrite
+    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
+    fst;
+  change_slprop_rel
+    ((varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x)) `vrewrite` fst)
+    (varray x)
+    (fun u v -> u == v)
+    (fun m -> ())
+
+let elim_varray1
+  (#inames: _)
+  (#base: Type)
+  (#t: Type)
+  (x: array base t)
+: SteelGhost unit inames
+    (varray x)
+    (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
+    (fun _ -> True)
+    (fun h _ h' -> h' (varray0 x) == h (varray x))
+= change_slprop_rel
+    (varray x)
+    ((varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x)) `vrewrite` fst)
+    (fun u v -> u == v)
+    (fun m -> ());
+  elim_vrewrite
+    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
+    fst
+
+let g_mk_array_from'
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Tot prop
+= 
+  Some? a /\
+  size_v n > 0 /\
+  begin let a = Some?.v a in
+  Ghost.reveal a.base_len == n /\
+  a.base_ref == r /\
+  a.from == mk_size_t 0ul
+  end
+
+let g_mk_array #base #t #n r a =
+  g_mk_array_from' r (fst a) /\
+  (array__to a) == n /\
+  (array__perm_val a) == Steel.FractionalPermission.full_perm
+
+let g_mk_array_weak r a = ()
+
+let g_mk_array_from r a = g_mk_array_from' r a
+
+let g_mk_array_to #base #t #n r a
+=
+  Some ({
+    to = n;
+    perm_val = Steel.FractionalPermission.full_perm
+  })
+
+#push-options "--z3rlimit 32"
+
+val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (_: squash (size_v n > 0))
+: SteelAtomicBase (array base t)
+    false opened Unobservable
+    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (fun a -> varray a)
+    (requires fun _ -> True)
+  (ensures (fun h a h' ->
+    g_mk_array r a /\
+    snd a == g_mk_array_to r (fst a) /\
+    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+let intro_varray0
+  #base #t #_ #n r sq
+=
+  let perm_ref = Steel.Reference.ghost_alloc #unit () in
+  let from = Some ({
+    base_len = n;
+    base_ref = r;
+    from = mk_size_t 0ul;
+    perm_ref = perm_ref;
+  }) in
+  let res = (from, g_mk_array_to r from) in
+  change_equal_slprop
+    (Steel.Reference.ghost_vptr perm_ref)
+    (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
+  assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  array_conn_id t n;
+  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
+  Steel.C.Ref.ref_focus_id r;
+  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
+  assert (array_as_ref res == r);
+  change_equal_slprop
+    (r `Steel.C.Ref.pts_to_view` _)
+    (varray0 res);
+  intro_varray1 res;
+  return res
+
+let intro_varray_from r _ =
+  let a = intro_varray0 r () in
+  let res = fst a in
+  change_equal_slprop
+    (varray a)
+    (varray (res, g_mk_array_to r res));
+  return res
+
+let elim_varray
+  #_ #base #t #n r res sq
+=
+  assert (g_mk_array r res);
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  array_conn_id t n;
+  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
+  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
+  Steel.C.Ref.ref_focus_id r;
+  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
+  assert (array_as_ref res == r);
+  elim_varray1 res;
+  change_equal_slprop
+    (varray0 res)
+    (r `Steel.C.Ref.pts_to_view` _);
+  let perm_ref = (array__perm_ref res) in
+  change_equal_slprop
+    (Steel.Reference.ghost_vptrp ((array__perm_ref res)) ((array__perm_val res)))
+    (Steel.Reference.ghost_vptr perm_ref);
+  Steel.Reference.ghost_free perm_ref
+
+#pop-options
+
+let adjacent r1 r2 =
+  (array__base_len r1) == (array__base_len r2) /\
+  (array__base_ref r1) == (array__base_ref r2) /\
+  (array__perm_ref r1) == (array__perm_ref r2) /\
+  (array__to r1) == (array__from r2)
+
+val t_merge
+  (#base: Type)
+  (#t: Type)
+  (r1 r2: array base t)
+: Pure (array base t)
+  (requires (adjacent r1 r2))
+  (ensures (fun r -> length r == length r1 + length r2))
+
+let t_merge r1 r2 =
+  (fst r1, Ghost.hide (Some ({
+    to = (array__to r2);
+    perm_val = (array__perm_val r1) `Steel.FractionalPermission.sum_perm` (array__perm_val r2);
+  })))
+
+let merge r1 r2 = t_merge r1 r2
+
+let merge_assoc r1 r2 r3 = ()
+
+let merge_inj_right a b1 b2 = ()
+
+let merge_inj_left a1 a2 b = ()
+
+let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b a))
+= let aux () : Lemma
+    (requires (merge_into a b a))
+    (ensures False)
+  = assert (
+      let open Steel.FractionalPermission in
+      let open FStar.Real in
+      (array__perm_val a).v +. (array__perm_val b).v >. (array__perm_val a).v
+    )
+  in
+  Classical.move_requires aux ()
+
+let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b b))
+= let aux () : Lemma
+    (requires (merge_into a b a))
+    (ensures False)
+  = assert (
+      let open Steel.FractionalPermission in
+      let open FStar.Real in
+      (array__perm_val a).v +. (array__perm_val b).v >. (array__perm_val b).v
+    )
+  in
+  Classical.move_requires aux ()
+
+val tsplit
+  (#base: Type)
+  (#t: Type)
+  (r: array base t)
+  (i: size_t)
+: Pure (array base t & array base t)
+  (requires (size_v i <= length r))
+  (ensures (fun (rl, rr) ->
+    merge_into rl rr r /\
+    length rl == size_v i
+  ))
+
+let tsplit #base #t r i =
+  let h = half_perm (array__perm_val r) in
+  let r1 : array base t =
+    (fst r, Ghost.hide (Some ({
+      to = (array__from r) `size_add` i;
+      perm_val = h;
+    })))
+  in
+  let r2 : array base t = (Some ({
+    base_len = (array__base_len r);
+    base_ref = (array__base_ref r);
+    from = (array__from r) `size_add` i;
+    perm_ref = (array__perm_ref r);
+  }), Ghost.hide (Some ({
+    to = (array__to r);
+    perm_val = h;
+  })))
+  in
+  (r1, r2)
+
+let gsplit r i = 
+  let (rl, rr) = tsplit r i in
+  GPair rl rr
+
+val pts_to_split
+  (t: Type)
+  (n: size_t)
+  (x: array_pcm_carrier t n)
+  (i: size_t)
+: Lemma
+  (requires (size_v i <= size_v n))
+  (ensures (
+    let z = mk_size_t 0ul in
+    let xl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () x) in
+    let xr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () x) in
+    composable (array_pcm t n) xl xr /\
+    op (array_pcm t n) xl xr == x
+  ))
+
+let pts_to_split t n x i =
+  let z = mk_size_t 0ul in
+  let xl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () x) in
+  let xr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () x) in
+  assert (composable (array_pcm t n) xl xr);
+  assert (op (array_pcm t n) xl xr `feq` x)
+
+val to_carrier_split
+  (t: Type)
+  (n: size_t)
+  (x: array_pcm_carrier t n)
+  (v: array_view_type t n)
+  (i: size_t)
+: Lemma
+  (requires (
+    size_v i <= size_v n /\
+    (array_view' t n).Steel.C.Ref.to_carrier v == x
+  ))
+  (ensures (
+    let z = mk_size_t 0ul in
+    let xl = (array_large_to_small_f t n z i () x) in
+    let xr = (array_large_to_small_f t n i n () x) in
+    (array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) == xl /\
+    (array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) == xr
+  ))
+
+#push-options "--z3rlimit 32"
+#restart-solver
+
+let to_carrier_split t n x v i =
+    let z = mk_size_t 0ul in
+    let xl = (array_large_to_small_f t n z i () x) in
+    let xr = (array_large_to_small_f t n i n () x) in
+    assert ((array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) `feq` xl);
+    assert ((array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
+
+let array_as_ref_split_left
+  (base: Type)
+  (t: Type)
+  (x: array base t)
+  (i: size_t)
+: Lemma
+  (requires (size_v i <= length x))
+  (ensures (
+    array_as_ref (fst (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
+  ))
+=
+  array_conn_compose t (array__base_len x) (array__from x) (array__to x) zero_size i;
+  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
+
+#restart-solver
+let array_as_ref_split_right
+  (base: Type)
+  (t: Type)
+  (x: array base t)
+  (i: size_t)
+: Lemma
+  (requires (size_v i <= length x))
+  (ensures (
+    array_as_ref (snd (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
+  ))
+=
+  array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
+  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
+
+val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+  : SteelGhost (array base t `gpair` array base t) opened
+          (varray a)
+          (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            let s = h (varray a) in
+            let sl = h' (varray (GPair?.fst res)) in
+            let sr = h' (varray (GPair?.snd res)) in
+            size_v i <= length a /\
+            res == gsplit a i /\
+            sl == Seq.slice s 0 (size_v i) /\
+            sr == Seq.slice s (size_v i) (length a)
+          )
+
+#pop-options
+#push-options "--z3rlimit 128"
+
+#restart-solver
+let split_
+  #j #base #t x i
+=
+  let gv = gget (varray x) in
+  elim_varray1 x;
+  let v = Steel.C.Ref.pts_to_view_elim
+    #j
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+  in
+  pts_to_split t (len x) v i;
+  let (xl, xr) = tsplit x i in
+  let n = len x in
+  let z = mk_size_t 0ul in
+  let vl' : array_pcm_carrier t (len xl) = array_large_to_small_f t n z i () v in
+  let vl : array_pcm_carrier t (len x) = array_small_to_large_f t n z i () vl' in
+  let vr' : array_pcm_carrier t (len xr) = array_large_to_small_f t n i n () v in
+  let vr : array_pcm_carrier t (len x) = array_small_to_large_f t n i n () vr' in
+  Steel.C.Ref.split
+    (array_as_ref #base #t x)
+    v
+    vl
+    vr;
+  let cl : (cl: Steel.C.Connection.connection
+    (array_pcm t (len x))
+    (array_pcm t (len xl)) {
+      cl === array_conn t n z i ()
+    })
+  = magic () // array_conn t n z i ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
+  in
+  Steel.C.Ref.gfocus
+    (array_as_ref #base #t x)
+    cl
+    vl
+    vl';
+  array_as_ref_split_left _ t x i;
+  assert (array_as_ref xl == Steel.C.Ref.ref_focus (array_as_ref x) cl);
+  change_equal_slprop
+    (_ `Steel.C.Ref.pts_to` vl')
+    (array_as_ref xl `Steel.C.Ref.pts_to` vl');
+  to_carrier_split t n v gv i;
+  let gvl : array_view_type t (len xl) = Seq.slice gv 0 (size_v i) in
+  Steel.C.Ref.pts_to_view_intro
+    #j
+    #base
+    #(array_pcm_carrier t (len xl))
+    #(array_pcm t (len xl))
+    (array_as_ref xl)
+    vl'
+    #(array_view_type t (len xl))
+    #(size_v (len xl) = 0)
+    (array_view' t (len xl))
+    gvl;
+  change_equal_slprop // necessary, otherwise F* goes off rails
+    (array_as_ref xl `Steel.C.Ref.pts_to_view` _)
+    (varray0 xl);
+  Steel.Reference.ghost_share (array__perm_ref x);
+  change_equal_slprop
+    (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
+    (Steel.Reference.ghost_vptrp (array__perm_ref xl) (array__perm_val xl));
+  intro_varray1 xl;
+  let cr : (cr: Steel.C.Connection.connection
+    (array_pcm t (len x))
+    (array_pcm t (len xr)) {
+      cr === array_conn t n i n ()
+    })
+  = magic () // array_conn t n i n ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
+  in
+  Steel.C.Ref.gfocus
+    (array_as_ref #base #t x)
+    cr
+    vr
+    vr';
+  array_as_ref_split_right _ t x i;
+  assert (array_as_ref xr == Steel.C.Ref.ref_focus (array_as_ref x) cr);
+  change_equal_slprop
+    (_ `Steel.C.Ref.pts_to` vr')
+    (array_as_ref xr `Steel.C.Ref.pts_to` vr');
+  let gvr : array_view_type t (len xr) = Seq.slice gv (size_v i) (size_v n) in
+//  let _ : squash ((Ghost.reveal gv <: Seq.seq t) == gvl `Seq.append` gvr) =
+//    Seq.lemma_split gv (size_v i)
+//  in
+  Steel.C.Ref.pts_to_view_intro
+    #j
+    #base
+    #(array_pcm_carrier t (len xr))
+    #(array_pcm t (len xr))
+    (array_as_ref xr)
+    vr'
+    #(array_view_type t (len xr))
+    #(size_v (len xr) = 0)
+    (array_view' t (len xr))
+    gvr;
+  change_equal_slprop // necessary, otherwise F* goes off rails
+    (array_as_ref xr `Steel.C.Ref.pts_to_view` _)
+    (varray0 xr);
+  change_equal_slprop
+    (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
+    (Steel.Reference.ghost_vptrp (array__perm_ref xr) (array__perm_val xr));
+  intro_varray1 xr;
+  let res = GPair xl xr in
+  change_equal_slprop
+    (varray xl)
+    (varray (GPair?.fst res));
+  change_equal_slprop
+    (varray xr)
+    (varray (GPair?.snd res));
+  res
+
+let split'
+  #_ #_ #t a i
+=
+  let g = gget (varray a) in
+  Seq.lemma_split #t (Ghost.reveal g) (size_v i);
+  split_ a i
+
+let split_right_from
+  a i
+=
+  return (fst (snd (tsplit a i)))
+
+let join' = admit ()
+
+let array_as_one_ref_iso
+  (base: Type)
+  (t: Type)
+: Tot (Steel.C.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
+= let c1 = (Steel.C.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
+  let c2 = (Steel.C.Struct.field_to_struct (array_elements_pcm t one_size) zero_size) in
+  Steel.C.Connection.mkisomorphism
+    c1
+    c2
+    ()
+    (Steel.C.Connection.is_inverse_of_intro
+      c2.Steel.C.Connection.morph
+      c1.Steel.C.Connection.morph
+      (fun x ->
+        array_pcm_carrier_ext t one_size (c2.Steel.C.Connection.morph (c1.Steel.C.Connection.morph x)) x (fun i ->
+          ()
+        )
+      )
+    )
+    (fun x -> ())
+    (fun x -> ())
+
+let array_as_one_ref_conn
+  (base: Type)
+  (t: Type)
+: Tot (Steel.C.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
+= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso base t)
+
+let g_ref_of_array
+  #base #t r
+=
+  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
+
+let array_as_one_ref_conn'
+  (#base: Type) (#t:Type0) (r:array base t)
+: Pure (Steel.C.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
+  (requires (size_v (len r) == 1))
+  (ensures (fun _ -> True))
+=
+  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
+
+#restart-solver
+let array_as_one_ref_conn'_small_to_large
+  (#base: Type) (#t:Type0) (r:array base t)
+  (x: option t)
+  (i: array_domain t (array__base_len r))
+: Lemma
+  (requires (size_v (len r) == 1))
+  (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = (array__from r) then x else None)))
+= Steel.C.Connection.morphism_compose_morph
+    (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large
+    (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Connection.conn_small_to_large
+    x
+
+let g_ref_of_array'
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (requires (size_v (len r) == 1))
+  (ensures (fun _ -> True))
+= (array__base_ref r) `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
+
+let g_ref_of_array'_correct
+  (#base: Type) (#t:Type0) (r:array base t)
+: Lemma
+  (requires (length r == 1))
+  (ensures (g_ref_of_array r == g_ref_of_array' r))
+=
+  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn base t)
+
+let get_pts_to
+  (#inames: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
+  (r: Steel.C.Ref.ref a p) (v: Ghost.erased b)
+: SteelGhost (Ghost.erased b) inames
+    (Steel.C.Ref.pts_to r v)
+    (fun v' -> Steel.C.Ref.pts_to r v)
+    (fun _ -> True)
+    (fun _ v' _ -> v' == v)
+= noop(); v
+
+let v_ref_of_array r =
+  Steel.Reference.ghost_vptrp (array__perm_ref r) (array__perm_val r)
+
+(*
+assume
+val abstract_id
+  (#t: Type)
+  (x: t)
+: Pure t
+  (requires True)
+  (ensures (fun y -> x == y))
+*)
+
+#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false --print_implicits"
+
+#restart-solver
+let ref_of_array_ghost #inames #base #t x sq =
+  let gv = gget (varray x) in
+  elim_varray1 x;
+  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
+    #inames
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+  in
+  assert (len x == one_size);
+  let z : array_domain t one_size = zero_size in
+  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
+  Steel.C.Ref.gfocus
+    #base
+    #(array_pcm_carrier t (len x))
+    #(option t)
+    #_
+    #(array_pcm t (len x))
+    (array_as_ref x)
+    #(Steel.C.Opt.opt_pcm #t)
+    (array_as_one_ref_conn base t)
+    _
+    (Ghost.reveal v z);
+  Steel.C.Ref.pts_to_view_intro
+    #inames
+    #base
+    #(option t)
+    #(Steel.C.Opt.opt_pcm #t)
+    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn base t))
+    (Ghost.reveal v z)
+    #t
+    #false
+    (Steel.C.Opt.opt_view t)
+    (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
+  change_equal_slprop
+    (Steel.C.Ref.pts_to_view _ _)
+    (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
+
+#restart-solver
+val ref_of_array0 (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+             false opened Unobservable
+             (varray r)
+             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r') `star` v_ref_of_array r)
+             (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
+             (ensures fun h0 r' h1 -> True)
+
+#restart-solver
+let ref_of_array0 #base #t x sq v0 =
+  let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
+  assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
+  elim_varray1 x;
+  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
+    #_
+    #base
+    #(array_pcm_carrier t (len x))
+    #(array_pcm t (len x))
+    (array_as_ref #base #t x)
+    #(array_view_type t (len x))
+    #(size_v (len x) = 0)
+    (array_view' t (len x))
+  in
+  Steel.C.Ref.unfocus _ (array__base_ref x) (array_as_ref_conn x) _;
+  let s = get_pts_to (array__base_ref x) _ in
+  let ar : Ghost.erased (array_pcm_carrier t (array__base_len x)) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
+  array_pcm_carrier_ext t (array__base_len x) (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
+    array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
+  );
+  g_ref_of_array'_correct x;
+  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
+  Steel.C.Ref.pts_to_view_intro
+    #_
+    #base
+    #(option t)
+    #(Steel.C.Opt.opt_pcm #t)
+    r
+    (Ghost.reveal v zero_size)
+    #t
+    #false
+    (Steel.C.Opt.opt_view t)
+    (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
+  intro_vrefine
+    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+    (fun v' -> v' == Ghost.reveal v0);
+  intro_pure (g_ref_of_array #base #t x == r);
+  return r
+
+#restart-solver
+let ref_of_array_from #base #t r_from r_to sq =
+  let x : array base t = (r_from, r_to) in
+  change_equal_slprop
+    (varray (r_from, r_to))
+    (varray x);
+  let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
+  let v0 = Ghost.hide (Seq.index (Ghost.reveal gv) 0) in
+  let r = ref_of_array0 x () v0 in
+  elim_pure (g_ref_of_array x == r);
+  elim_vrefine
+    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+    (fun v' -> v' == Ghost.reveal v0);
+  change_equal_slprop
+    (v_ref_of_array x)
+    (v_ref_of_array (r_from, r_to));
+  return r
+
+#restart-solver
+let array_of_ref
+  #_ #base #t r' r sq
+=
+  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
+  let v = Steel.C.Ref.pts_to_view_elim
+    r
+    (Steel.C.Opt.opt_view t)
+  in
+  Steel.C.Ref.unfocus
+    r
+    (array_as_ref r')
+    (array_as_one_ref_conn base t)
+    v;
+  let g' : Ghost.erased (array_view_type t (len r')) =
+    (Ghost.hide (Seq.create 1 (Ghost.reveal g)))
+  in
+  let v' : Ghost.erased (array_pcm_carrier t (len r')) =
+    get_pts_to (array_as_ref r') _
+  in
+  array_pcm_carrier_ext t (len r') ((array_view t (len r')).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
+    assert (i == zero_size)
+  );
+  Steel.C.Ref.pts_to_view_intro
+    _
+    _
+    (array_view t (len r'))
+    g';
+  change_equal_slprop
+    (Steel.C.Ref.pts_to_view (array_as_ref r') (array_view t (len r')))
+    (varray0 r');
+  intro_varray1 r'
+
+#restart-solver
+let one_ref_as_array_conn
+  (base: Type) (t:Type0)
+: Tot (Steel.C.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
+=
+  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
+
+let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array base t) =
+  (Some ({
+    base_len = one_size;
+    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
+    from = zero_size;
+    perm_ref = perm_ref;
+  }), Ghost.hide (Some ({
+    to = one_size;
+    perm_val = Steel.FractionalPermission.full_perm;
+  })))
+
+#restart-solver
+let mk_array_of_ref'_correct
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
+: Lemma
+  (g_ref_of_array (mk_array_of_ref' r perm_ref) == r)
+=
+  g_ref_of_array'_correct (mk_array_of_ref' r perm_ref);
+  array_conn_id t one_size;
+  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
+  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
+  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
+  Steel.C.Ref.ref_focus_id r
+
+#restart-solver
+let array_as_ref_eq_base_ref
+  (#base: Type) (#t:Type0) (a: array base t)
+: Lemma
+  (requires (
+    array__base_len a == one_size /\
+    array__from a == zero_size /\
+    array__to a == one_size
+  ))
+  (ensures (
+    array_as_ref a == (array__base_ref a)
+  ))
+=
+  array_conn_id t one_size;
+  Steel.C.Ref.ref_focus_id (array__base_ref a)
+
+#restart-solver
+let array_as_ref_mk_array_of_ref'
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
+: Lemma
+  (ensures (
+    let x = mk_array_of_ref' r perm_ref in
+    array_as_ref x == (array__base_ref x)
+  ))
+=
+  let x = mk_array_of_ref' r perm_ref in
+  array_as_ref_eq_base_ref x
+
+let array_domain_one_size
+  (t: Type)
+  (i: array_domain t one_size)
+: Lemma
+  (i == zero_size)
+= ()
+
+#restart-solver
+let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
+  (g: Ghost.erased t)
+  (v: Ghost.erased (option t))
+  (v' : Ghost.erased (array_pcm_carrier t one_size))
+  (g' : Ghost.erased (array_view_type t one_size))
+: Lemma
+  (requires (
+    Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Ref.to_carrier (Ghost.reveal g) /\
+    Ghost.reveal v' == (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
+    Ghost.reveal g' == Seq.create 1 (Ghost.reveal g)
+  ))
+  (ensures (
+    (array_view t one_size).Steel.C.Ref.to_carrier g' == (Ghost.reveal v')
+  ))
+= array_pcm_carrier_ext t one_size ((array_view t one_size).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
+    ()
+  )
+
+let mk_array_of_ref_to'
+  (base: Type) (t:Type0)
+: Tot (array_or_null_to base t)
+= Some ({
+    to = one_size;
+    perm_val = Steel.FractionalPermission.full_perm;
+  })
+
+let mk_array_of_ref_from_spec
+  #base #t r from
+=
+  let a = (from, mk_array_of_ref_to' base t) in
+  array_or_null_spec a /\
+  g_is_null a == false /\
+  array__base_len a == one_size /\
+  array__from a == zero_size /\
+  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t
+
+let mk_array_of_ref_to #base #t r from = mk_array_of_ref_to' base t
+
+val mk_array_of_ref0 (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array base t)
+             false opened Unobservable
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun r' -> varray r')
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               r' == mk_array_of_ref' r (array__perm_ref r') /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+#restart-solver
+let mk_array_of_ref0
+  #base #t r
+=
+  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
+  let v : Ghost.erased (option t) = Steel.C.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
+  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
+  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
+    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
+  in
+  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
+  let perm_ref = Steel.Reference.ghost_alloc #unit () in
+  let res : array base t = (Some ({
+    base_len = one_size;
+    base_ref = r';
+    from = zero_size;
+    perm_ref = perm_ref;
+  }), Ghost.hide (Some ({
+    to = one_size;
+    perm_val = Steel.FractionalPermission.full_perm;
+  })))
+  in
+  assert (res == mk_array_of_ref' r perm_ref);
+  mk_array_of_ref'_correct r perm_ref;
+  let g' : Ghost.erased (array_view_type t one_size) =
+    Ghost.hide (Seq.create 1 (Ghost.reveal g))
+  in
+  mk_array_of_ref_view_intro base g v v' g' ;
+  Steel.C.Ref.pts_to_view_intro
+    _
+    _
+    (array_view t one_size)
+    g';
+  array_as_ref_mk_array_of_ref' r perm_ref;
+  change_equal_slprop
+    (Steel.C.Ref.pts_to_view r' (array_view t one_size))
+    (varray0 res);
+  change_equal_slprop
+    (Steel.Reference.ghost_vptr perm_ref)
+    (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
+  intro_varray1 res;
+  return res
+
+let mk_array_of_ref_from
+  #base #t r
+=
+  let a = mk_array_of_ref0 r in
+  let res = fst a in
+  change_equal_slprop
+    (varray a)
+    (varray (res, mk_array_of_ref_to r res));
+  return res
+
+#pop-options
+
+let varray_or_null0_rewrite
+  (#base #a: Type0)
+  (r: array_or_null base a)
+  (_: t_of emp)
+: Tot (option (array_view_type a (len r)))
+= None
+
+[@@__steel_reduce__]
+let varray_or_null0
+  (#base #a: Type0)
+  (r: array_or_null base a)
+: Tot vprop
+= if g_is_null r
+  then emp `vrewrite` varray_or_null0_rewrite r
+  else varray r `vrewrite` Some
+
+let is_array_or_null r = hp_of (varray_or_null0 r)
+let array_or_null_sel r = sel_of (varray_or_null0 r)
+
+let intro_varray_or_null_none x =
+  intro_vrewrite emp (varray_or_null0_rewrite x);
+  change_equal_slprop
+    (emp `vrewrite` varray_or_null0_rewrite x)
+    (varray_or_null0 x);
+  change_slprop_rel
+    (varray_or_null0 x)
+    (varray_or_null x)
+    (fun u v -> u == v)
+    (fun _ -> ())
+
+let intro_varray_or_null_some x =
+  intro_vrewrite (varray x) Some;
+  change_equal_slprop
+    (varray x `vrewrite` Some)
+    (varray_or_null0 x);
+  change_slprop_rel
+    (varray_or_null0 x)
+    (varray_or_null x)
+    (fun u v -> u == v)
+    (fun _ -> ())
+
+let elim_varray_or_null_some x =
+  change_slprop_rel
+    (varray_or_null x)
+    (varray_or_null0 x)
+    (fun u v -> u == v)
+    (fun _ -> ());
+  if g_is_null x
+  then begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (emp `vrewrite` varray_or_null0_rewrite x);
+    elim_vrewrite emp (varray_or_null0_rewrite x);
+    assert False;
+    change_equal_slprop
+      emp
+      (varray x)
+  end else begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (varray x `vrewrite` Some);
+    elim_vrewrite (varray x) Some
+  end
+
+let elim_varray_or_null_none x =
+  change_slprop_rel
+    (varray_or_null x)
+    (varray_or_null0 x)
+    (fun u v -> u == v)
+    (fun _ -> ());
+  if g_is_null x
+  then begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (emp `vrewrite` varray_or_null0_rewrite x);
+    elim_vrewrite emp (varray_or_null0_rewrite x)
+  end else begin
+    change_equal_slprop
+      (varray_or_null0 x)
+      (varray x `vrewrite` Some);
+    elim_vrewrite (varray x) Some;
+    assert False;
+    change_equal_slprop
+      (varray x)
+      emp
+  end
+
+#restart-solver
+let freeable
+  #base #t a
+=
+  Steel.C.Ref.freeable (array__base_ref a) /\
+  size_v (array__base_len a) > 0 /\
+  (array__perm_val a) == Steel.FractionalPermission.full_perm /\
+  (array__from a) == zero_size /\
+  (array__to a) == (array__base_len a)
+
+#restart-solver
+let array_to_carrier_refine
+  (#t: Type0)
+  (n: size_t)
+  (v: array_view_type t n)
+: Lemma
+  (requires (size_v n > 0))
+  (ensures (p_refine (array_pcm t n) (array_to_carrier t n v)))
+= FStar.Classical.exists_intro (fun (k: array_domain t n) -> True) zero_size
+
+let malloc_to'
+ (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Tot (array_or_null_to (array_pcm_carrier t n) t)
+= if None? from
+  then None
+  else Some ({
+    to = n;
+    perm_val = Steel.FractionalPermission.full_perm;
+  })
+
+let malloc_from_spec
+  #t x n from
+=
+  let a = (from, malloc_to' x n from) in
+  array_or_null_spec a /\
+  (g_is_null a == false ==> freeable a)
+
+let malloc_to x n from = malloc_to' x n from
+
+val malloc0
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+: Steel (array_or_null (array_pcm_carrier t n) t)
+    emp
+    (fun r -> varray_or_null r)
+    (requires fun _ -> size_v n > 0)
+    (ensures fun _ r h' ->
+      size_v n > 0 /\
+      malloc_from_spec x n (fst r) /\
+      snd r == malloc_to x n (fst r) /\
+      (g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x)))
+    )
+
+#restart-solver
+let malloc0
+  #t x n
+=
+  let v = Seq.create (size_v n) x in
+  let c = array_to_carrier t n v in
+  array_to_carrier_refine n v;
+  let r0 = Steel.C.Ref.ref_alloc (array_pcm t n) c in
+  Steel.C.Ref.pts_to_view_intro r0 c (array_view t n) v;
+  let r = intro_varray r0 () in
+  intro_varray_or_null_some r;
+  return r
+
+let malloc_from
+  #t x n sq
+= let a = malloc0 x n in
+  let res = fst a in
+  change_equal_slprop
+    (varray_or_null a)
+    (varray_or_null (res, malloc_to x n res));
+  return res
+ 
+val free0
+  (#base: Type0)
+  (#t: Type0)
+  (a: array base t)
+: Steel unit
+    (varray a)
+    (fun _ -> emp)
+    (requires (fun _ -> freeable a))
+    (ensures (fun _ _ _ -> True))
+
+#restart-solver
+#push-options "--print_implicits"
+let free0
+  #base #t a
+=
+  let r = (array__base_ref a) in
+  elim_varray r a ();
+  let v = Steel.C.Ref.pts_to_view_elim
+    #_
+    #_
+    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
+    #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
+    r
+    (array_view t (array__base_len a))
+  in
+  Steel.C.Ref.ref_free
+    #_
+    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
+    #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
+    #v
+    r
+
+let free_from
+  #base #t a a' sq
+=
+  let a0 : array base t = (a, a') in
+  change_equal_slprop
+    (varray (a, a'))
+    (varray a0);
+  free0 a0
+
+let is_null_from a a' sq =
+  return (None? a)
diff --git a/ulib/experimental/Steel.C.Array.Base.fsti b/ulib/experimental/Steel.C.Array.Base.fsti
new file mode 100644
index 00000000000..68a6aad9075
--- /dev/null
+++ b/ulib/experimental/Steel.C.Array.Base.fsti
@@ -0,0 +1,749 @@
+(*
+   Copyright 2021 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.C.Array.Base
+include Steel.C.StdInt.Base
+open Steel.Memory
+open Steel.FractionalPermission
+open Steel.Effect
+open FStar.Ghost
+open Steel.Effect.Atomic
+
+open Steel.C.Typedef
+open Steel.C.PCM
+open Steel.C.Fields
+open Steel.C.Typenat
+
+#set-options "--ide_id_info_off"
+
+/// A library for arrays in Steel
+/// TODO: add back support for fractional permissions, or even any element view
+
+val array_pcm_carrier (t: Type u#0) (n: Ghost.erased size_t) : Type u#0
+
+val array_pcm (t: Type u#0) (n: Ghost.erased size_t) : Tot (Steel.C.PCM.pcm (array_pcm_carrier t n))
+
+// FIXME: how to produce array type t[n] as the type of some struct field?
+let array_view_type (t: Type u#0) (n: size_t)
+: Type u#0 =
+  Seq.lseq t (size_v n)
+
+/// A variant of array_view_type, which records the length of the
+/// array in Type as a Steel.C.Typenat, for extraction
+let size_t_of (n': Type u#0) = n:size_t{n' == nat_t_of_nat (size_v n)}
+let array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
+: Type u#0
+= array_view_type t n
+
+val array_view (t: Type u#0) (n: size_t)
+  : Pure (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
+    (requires (size_v n > 0))
+    (ensures (fun _ -> True))
+
+/// Abstract datatype for a Steel array of type [t]
+/// We model it as three parts:
+/// - a pure part, which represents the beginning of the array, and should extract to t*
+/// - a ghost part, which represents the end of the array, and should be erased at extraction
+/// - a refinement, because KReMLin does not support inlining of dependent pair types where one part is ghost.
+val array_or_null_from (base: Type0) (t: Type0) : Tot Type0
+[@@erasable]
+val array_or_null_to (base: Type0) (t: Type0) : Tot Type0
+val array_or_null_spec (#base: Type0) (#t: Type0) (x: (array_or_null_from base t & array_or_null_to base t)) : Tot prop
+inline_for_extraction
+let array_or_null (base: Type u#0) (t: Type u#0) : Type u#0 = (x: (array_or_null_from base t & array_or_null_to base t) { array_or_null_spec x })
+
+/// Returns the length of the array. Usable for specification and proof purposes,
+/// as modeled by the GTot effect
+val len (#base: Type) (#t: Type) (a: array_or_null base t) : GTot size_t
+let length (#base: Type) (#t: Type) (a: array_or_null base t) : GTot nat = size_v (len a)
+
+
+val null_from (base: Type u#0) (t: Type u#0) : Tot (array_or_null_from base t) 
+val null_to (base: Type u#0) (t: Type u#0) : Pure (array_or_null_to base t) (requires True) (ensures (fun r0 ->
+  array_or_null_spec (null_from base t, r0) /\
+  len (null_from base t, r0) == zero_size))
+
+val null_to_unique
+  (#base #t: Type)
+  (to: array_or_null_to base t)
+: Lemma
+  (requires (
+    array_or_null_spec (null_from base t, to)
+  ))
+  (ensures (
+    to == null_to base t
+  ))
+
+inline_for_extraction
+let null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
+= (null_from base t, null_to base t)
+val g_is_null (#base: Type) (#t: Type) (a: array_or_null base t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null base t))
+inline_for_extraction
+noextract
+let array (base: Type u#0) (t:Type u#0) : Type u#0 = (a: array_or_null base t { g_is_null a == false })
+
+val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
+: b:bool{b <==> a == one (array_pcm t n)}
+
+[@@c_struct]
+let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}): typedef = {
+  carrier = array_pcm_carrier t n;
+  pcm = array_pcm t n;
+  view_type = array_view_type_sized t n' n;
+  view = array_view t n;
+  is_unit = array_is_unit t n;
+}
+
+/// Combining the elements above to create an array vprop
+/// TODO: generalize to any view
+
+// val g_array_as_ref (#base: Type u#0) (#t: Type u#0) (a: array base t)
+//   : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+
+// [@@ __steel_reduce__]
+// let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop
+// = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
+
+val varray_hp (#base: Type0) (#t: Type0) (x: array base t) : Tot (slprop u#1)
+
+val varray_sel (#base: Type0) (#t: Type0) (x: array base t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
+
+[@@ __steel_reduce__ ]
+let varray' (#base: Type) (#t: Type) (x: array base t) : GTot vprop' = {
+  hp = varray_hp x;
+  t = array_view_type t (len x);
+  sel = varray_sel x;
+}
+
+[@@ __steel_reduce__ ]
+let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop =
+  VUnit (varray' x)
+
+val g_mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array base t)
+: Tot prop
+
+val g_mk_array_weak
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array base t)
+: Lemma
+  (requires (g_mk_array r a))
+  (ensures (
+    size_v n > 0 /\
+    len a == Ghost.reveal n
+  ))
+  [SMTPat (g_mk_array r a)]
+
+val g_mk_array_from
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Tot prop
+
+val g_mk_array_to
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Pure (array_or_null_to base t)
+  (requires (g_mk_array_from r a))
+  (ensures (fun a' ->
+    let a0 = (a, a') in
+    array_or_null_spec a0 /\
+    g_is_null a0 == false /\
+    g_mk_array r a0
+  ))
+
+val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (_: squash (size_v n > 0))
+: SteelAtomicBase (al: array_or_null_from base t { g_mk_array_from r al })
+    false opened Unobservable
+    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (fun al -> varray (al, g_mk_array_to r al))
+    (requires fun _ -> True)
+  (ensures (fun h al h' ->
+    let a = (al, g_mk_array_to r al) in
+    g_mk_array r a /\
+    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+inline_for_extraction
+let intro_varray (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (_: squash (size_v n > 0))
+: SteelAtomicBase (array base t)
+  false opened Unobservable
+    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (fun a -> varray a)
+    (requires fun _ -> True)
+  (ensures (fun h a h' ->
+    g_mk_array r a /\
+    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+=
+  let al = intro_varray_from r () in
+  let a = (al, g_mk_array_to r al) in
+  change_equal_slprop
+    (varray (al, g_mk_array_to r al))
+    (varray a);
+  return a
+
+val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n)) (a: array base t) (_: squash (size_v n > 0))
+: SteelGhost unit inames
+  (varray a)
+  (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
+  (requires fun _ -> g_mk_array r a)
+  (ensures (fun h _ h' ->
+    g_mk_array r a /\
+    h (varray a) == h' (Steel.C.Ref.pts_to_view r (array_view t n))
+  ))
+
+/// Splitting an array into subarrays
+
+val adjacent
+  (#base: Type)
+  (#t: Type)
+  (r1 r2: array base t)
+: Tot prop
+
+val merge
+  (#base: Type)
+  (#t: Type)
+  (r1 r2: array base t)
+: Ghost (array base t)
+  (requires (adjacent r1 r2))
+  (ensures (fun r ->
+    length r == length r1 + length r2 /\
+    fst r == fst r1 // this property justifies array_or_null_from _ t being extracted to t*
+  ))
+
+let merge_into
+  (#base: Type)
+  (#t: Type)
+  (r1 r2 r3: array base t)
+: Tot prop
+= adjacent r1 r2 /\
+  merge r1 r2 == r3
+
+val merge_assoc
+  (#base: Type)
+  (#t: Type)
+  (r1 r2 r3: array base t)
+: Lemma
+  (requires (
+    (adjacent r1 r2 /\ (adjacent r2 r3 \/ adjacent (merge r1 r2) r3)) \/
+    (adjacent r2 r3 /\ adjacent r1 (merge r2 r3))
+  ))
+  (ensures (
+    adjacent r1 r2 /\ adjacent r2 r3 /\
+    begin
+      let r12 = merge r1 r2 in
+      let r23 = merge r2 r3 in
+      adjacent r1 r23 /\ adjacent r12 r3 /\
+      merge r1 r23 == merge r12 r3
+    end
+  ))
+  [SMTPat (merge (merge r1 r2) r3)]
+
+val merge_inj_right
+  (#base: Type)
+  (#t: Type)
+  (a b1 b2: array base t)
+: Lemma
+  (requires (adjacent a b1 /\ adjacent a b2 /\ merge a b1 == merge a b2))
+  (ensures (b1 == b2))
+
+val merge_inj_left
+  (#base: Type)
+  (#t: Type)
+  (a1 a2 b: array base t)
+: Lemma
+  (requires (adjacent a1 b /\ adjacent a2 b /\ merge a1 b == merge a2 b))
+  (ensures (a1 == a2))
+
+val no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b a))
+
+val no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
+  (~ (merge_into a b b))
+
+[@erasable]
+noeq
+type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
+
+val gsplit
+  (#base: Type)
+  (#t: Type)
+  (r: array base t)
+  (i: size_t)
+: Ghost (array base t `gpair` array base t)
+  (requires (size_v i <= length r))
+  (ensures (fun (GPair rl rr) ->
+    merge_into rl rr r /\
+    length rl == size_v i
+  ))
+
+val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+  : SteelGhost (array base t `gpair` array base t) opened
+          (varray a)
+          (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            let s = h (varray a) in
+            let sl = h' (varray (GPair?.fst res)) in
+            let sr = h' (varray (GPair?.snd res)) in
+            size_v i <= length a /\
+            res == gsplit a i /\
+            sl == Seq.slice s 0 (size_v i) /\
+            sr == Seq.slice s (size_v i) (length a) /\
+            s == sl `Seq.append` sr
+          )
+
+inline_for_extraction
+let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
+  (al ar: Ghost.erased (array base t))
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray al)
+          (fun res -> varray res)
+          (fun _ ->
+            merge_into al ar a
+          )
+          (fun h res h' ->
+            res == Ghost.reveal al /\
+            h' (varray res) == h (varray al)
+          )
+= match a with
+  | (a_, _) ->
+    let res = (a_, snd al) in
+    change_equal_slprop
+      (varray al)
+      (varray res);
+    return res
+
+val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array_or_null_from base t) false opened Unobservable
+          (varray a)
+          (fun _ -> varray a)
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            h' (varray a) == h (varray a) /\
+            size_v i <= length a /\
+            res == fst (GPair?.snd (gsplit a i))
+          )
+
+inline_for_extraction
+let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray a)
+          (fun _ -> varray a)
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            h' (varray a) == h (varray a) /\
+            size_v i <= length a /\
+            res == GPair?.snd (gsplit a i)
+          )
+= let from = split_right_from a i in
+  let res = (from, snd (GPair?.snd (gsplit a i))) in
+  return res
+
+inline_for_extraction
+let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a))
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray a)
+          (fun res -> varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i))))
+          `star` varray res)
+          (fun _ -> size_v i <= length a)
+          (fun h res h' ->
+            let s = h (varray a) in
+            let sl = h' (varray (GPair?.fst (gsplit a i))) in
+            let sr = h' (varray res) in
+            size_v i <= length a /\
+            res == GPair?.snd (gsplit a i) /\
+            sl == Seq.slice s 0 (size_v i) /\
+            sr == Seq.slice s (size_v i) (length a) /\
+            s == sl `Seq.append` sr
+          )
+=
+  let sr = split_right a i in
+  let g = split' a i in
+  change_equal_slprop
+    (varray (GPair?.fst g))
+    (varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i)))));
+  change_equal_slprop
+    (varray (GPair?.snd g))
+    (varray sr);
+  return sr
+
+val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelGhost (Ghost.erased (array base t)) opened
+          (varray al `star` varray ar)
+          (fun a -> varray a)
+          (fun _ -> adjacent al ar)
+          (fun h a h' ->
+            let s = h' (varray a) in
+            s == (h (varray al) `Seq.append` h (varray ar)) /\
+            merge_into al ar a
+          )
+
+inline_for_extraction
+let joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray al `star` varray ar)
+          (fun a -> varray al `star` varray ar)
+          (fun _ -> adjacent al ar)
+          (fun h a h' ->
+            h' (varray al) == h (varray al) /\
+            h' (varray ar) == h (varray ar) /\
+            merge_into al ar a
+          )
+= match al with
+  | (a, _) ->
+    let res = (a, snd (merge al ar)) in
+    return res
+
+inline_for_extraction
+let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelAtomicBase (array base t) false opened Unobservable
+          (varray al `star` varray ar)
+          (fun a -> varray a)
+          (fun _ -> adjacent al ar)
+          (fun h a h' ->
+            let s = h' (varray a) in
+            s == (h (varray al) `Seq.append` h (varray ar)) /\
+            merge_into al ar a
+          )
+=
+  let a = joinc al ar in
+  let ga = join' al ar in
+  change_equal_slprop
+    (varray ga)
+    (varray a);
+  return a
+
+/// Converting an array into a pointer, after it has been split to an array of size 1
+/// Those two functions should extract to identity functions
+
+val g_ref_of_array
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (requires (length r == 1))
+  (ensures (fun _ -> True))
+
+val v_ref_of_array
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost vprop
+  (requires (length r == 1))
+  (ensures (fun _ -> True))
+
+val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
+  : SteelGhost unit inames
+             (varray r)
+             (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
+             (requires fun _ -> True)
+             (ensures fun h0 _ h1 ->
+               let r' = g_ref_of_array r in
+               let s = h0 (varray r) in
+               Seq.length s == 1 /\
+               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+val ref_of_array_from (#base: Type) (#t:Type0) (#opened: _) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+    false opened Unobservable
+             (varray (r_from, r_to))
+             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let r = (r_from, r_to) in
+               let s = h0 (varray r) in
+               Seq.length s == 1 /\
+               g_ref_of_array r == r' /\
+               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+inline_for_extraction
+let ref_of_array (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+    false opened Unobservable
+             (varray r)
+             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let s = h0 (varray r) in
+               Seq.length s == 1 /\
+               g_ref_of_array r == r' /\
+               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+= match r with
+  | (r_from, r_to) ->
+    change_equal_slprop
+      (varray r)
+      (varray (r_from, r_to));
+    let res = ref_of_array_from r_from r_to () in
+    change_equal_slprop
+      (v_ref_of_array (r_from, r_to))
+      (v_ref_of_array r);
+    return res
+
+val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
+  : SteelGhost unit inames
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
+             (fun _ -> varray r')
+             (requires fun _ -> g_ref_of_array r' == r)
+             (ensures fun h0 _ h1 ->
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+// this function should be used only to pass a pointer as an argument to a function that expects an array
+
+val mk_array_of_ref_from_spec
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from base t)
+: Tot prop
+
+val mk_array_of_ref_to
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from base t)
+: Pure (array_or_null_to base t)
+  (requires (mk_array_of_ref_from_spec r from))
+  (ensures (fun to ->
+    let r' = (from, to) in
+    array_or_null_spec r' /\
+    g_is_null r' == false
+  ))
+
+val mk_array_of_ref_from (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
+    false opened Unobservable
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
+             (requires fun _ -> True)
+             (ensures fun h0 r0 h1 ->
+               let r' = (r0, mk_array_of_ref_to r r0) in
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+
+inline_for_extraction
+let mk_array_of_ref (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array base t)
+    false opened Unobservable
+             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (fun r' -> varray r')
+             (requires fun _ -> True)
+             (ensures fun h0 r' h1 ->
+               let s = h1 (varray r') in
+               Seq.length s == 1 /\
+               g_ref_of_array r' == r /\
+               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+             )
+= let from = mk_array_of_ref_from r in
+  let r' = (from, mk_array_of_ref_to r from) in
+  change_equal_slprop
+    (varray (from, mk_array_of_ref_to r from))
+    (varray r');
+  return r'
+
+val is_array_or_null (#base #a:Type0) (r:array_or_null base a) : slprop u#1
+val array_or_null_sel (#base #a:Type0) (r:array_or_null base a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
+
+[@@ __steel_reduce__]
+let varray_or_null' #base #a (r: array_or_null base a) : GTot vprop' =
+  {hp = is_array_or_null r;
+   t = option (array_view_type a (len r));
+   sel = array_or_null_sel r}
+
+[@@ __steel_reduce__]
+let varray_or_null r = VUnit (varray_or_null' r)
+
+val intro_varray_or_null_none
+  (#opened: _)
+  (#base #a: Type)
+  (x: array_or_null base a)
+: SteelGhost unit opened
+    emp
+    (fun _ -> varray_or_null x)
+    (fun _ -> g_is_null x == true)
+    (fun _ _ h' -> h' (varray_or_null x) == None)
+
+val intro_varray_or_null_some
+  (#opened: _)
+  (#base #a: Type)
+  (x: array base a)
+: SteelGhost unit opened
+    (varray x)
+    (fun _ -> varray_or_null x)
+    (fun _ -> True)
+    (fun h _ h' ->
+      g_is_null x == false /\
+      h' (varray_or_null x) == Some (h (varray x)
+    ))
+
+val elim_varray_or_null_some
+  (#opened: _)
+  (#base #a: Type)
+  (x: array_or_null base a)
+: SteelGhost (squash (g_is_null x == false)) opened
+    (varray_or_null x)
+    (fun _ -> varray x)
+    (fun h -> g_is_null x == false \/ Some? (h (varray_or_null x)))
+    (fun h _ h' ->
+      g_is_null x == false /\
+      h (varray_or_null x) == Some (h' (varray x))
+    )
+
+val elim_varray_or_null_none
+  (#opened: _)
+  (#base #a: Type)
+  (x: array_or_null base a)
+: SteelGhost unit opened
+    (varray_or_null x)
+    (fun _ -> emp)
+    (fun h -> g_is_null x == true \/ None? (h (varray_or_null x)))
+    (fun h _ _ ->
+      g_is_null x == true /\
+      h (varray_or_null x) == None
+    )
+
+/// Allocates an array of size [n] where all cells have initial value [x]
+
+val freeable
+  (#base: Type0)
+  (#t: Type0)
+  (a: array base t)
+: Tot prop
+
+val malloc_from_spec
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Tot prop
+
+val malloc_to
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Pure (array_or_null_to (array_pcm_carrier t n) t)
+    (requires (size_v n > 0 /\ malloc_from_spec x n from))
+    (ensures (fun to -> array_or_null_spec (from, to)))
+
+val malloc_from
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+  (sq: squash (size_v n > 0))
+: Steel (from: array_or_null_from (array_pcm_carrier t n) t { malloc_from_spec x n from })
+    emp
+    (fun r -> varray_or_null (r, malloc_to x n r))
+    (requires fun _ -> True)
+    (ensures fun _ r0 h' ->
+      size_v n > 0 /\
+      begin let r : array_or_null (array_pcm_carrier t n) t = (r0, malloc_to x n r0) in
+      g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
+      end
+    )
+
+inline_for_extraction
+let malloc
+  (#t: Type0)
+  (x: t)
+  (n: size_t)
+: Steel (array_or_null (array_pcm_carrier t n) t)
+    emp
+    (fun r -> varray_or_null r)
+    (requires fun _ -> size_v n > 0)
+    (ensures fun _ r h' ->
+      g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
+    )
+= let r0 = malloc_from x n () in
+  let r = (r0, malloc_to x n r0) in
+  change_equal_slprop
+    (varray_or_null (r0, malloc_to x n r0))
+    (varray_or_null r);
+  return r
+
+val free_from
+  (#base: Type0)
+  (#t: Type0)
+  (a: array_or_null_from base t)
+  (a' : array_or_null_to base t)
+  (sq: squash (array_or_null_spec (a, a') /\ g_is_null (a, a') == false))
+: Steel unit
+    (varray (a, a'))
+    (fun _ -> emp)
+    (requires (fun _ -> freeable (a,a')))
+    (ensures (fun _ _ _ -> True))
+
+inline_for_extraction
+let free
+  (#base: Type0)
+  (#t: Type0)
+  (a: array base t)
+: Steel unit
+    (varray a)
+    (fun _ -> emp)
+    (requires (fun _ -> freeable a))
+    (ensures (fun _ _ _ -> True))
+= match a with
+  | (af, a') ->
+    change_equal_slprop
+      (varray a)
+      (varray (af, a'));
+    free_from af a' ()
+
+val is_null_from
+  (#base: Type0)
+  (#t: Type0)
+  (#opened: _)
+  (a: array_or_null_from base t)
+  (a' : array_or_null_to base t)
+  (sq: squash (array_or_null_spec (a, a')))
+: SteelAtomicBase bool false opened Unobservable
+    (varray_or_null (a, a'))
+    (fun _ -> varray_or_null (a, a'))
+    (requires fun _ -> True)
+    (ensures fun h res h' ->
+      res == g_is_null (a, a') /\
+      h' (varray_or_null (a, a')) == h (varray_or_null (a, a'))
+    )
+
+inline_for_extraction
+let is_null
+  (#base: Type0)
+  (#t: Type0)
+  (#opened: _)
+  (a: array_or_null base t)
+: SteelAtomicBase bool false opened Unobservable
+    (varray_or_null a)
+    (fun _ -> varray_or_null a)
+    (requires fun _ -> True)
+    (ensures fun h res h' ->
+      res == g_is_null a /\
+      h' (varray_or_null a) == h (varray_or_null a)
+    )
+= match a with
+  | (af, a') ->
+    change_equal_slprop
+      (varray_or_null a)
+      (varray_or_null (af, a'));
+    let res = is_null_from af a' () in
+    change_equal_slprop
+      (varray_or_null (af, a'))
+      (varray_or_null a);
+    return res
diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 4d8a4fe1fd4..1f122de960d 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -1,1891 +1,5 @@
 module Steel.C.Array
 
-module S = Steel.C.Struct
-
-#push-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
-let half_perm
-  (p: Steel.FractionalPermission.perm)
-: Pure Steel.FractionalPermission.perm
-  (requires True)
-  (ensures (fun y ->
-    y `Steel.FractionalPermission.sum_perm` y == p /\
-    y == Steel.FractionalPermission.half_perm p
-  ))
-= 
-  let open Steel.FractionalPermission in
-  let open FStar.Real in
-  assert ((p.v /. 2.0R) +. (p.v /. 2.0R) == p.v);
-  MkPerm (p.v /. 2.0R)
-#pop-options
-
-let array_domain
-  (t: Type u#0)
-  (n: Ghost.erased size_t)
-: Tot Type0
-= (x: size_t { size_v x < size_v n })
-
-let array_range
-  (t: Type u#0)
-  (n: Ghost.erased size_t)
-  (x: array_domain t n)
-: Tot Type0
-= option t
-
-open FStar.FunctionalExtensionality
-
-let array_pcm_carrier t n = restricted_t (array_domain t n) (array_range t n)
-
-let array_pcm_carrier_ext
-  (t: Type)
-  (n: size_t)
-  (x1 x2: array_pcm_carrier t n)
-  (f: (
-    (i: array_domain t n) ->
-    Lemma
-    (x1 i == x2 i)
-  ))
-: Lemma
-  (ensures (x1 == x2))
-= Classical.forall_intro f;
-  assert (x1 `feq` x2)
-
-let array_elements_pcm
-  (t: Type u#0)
-  (n: Ghost.erased size_t)
-  (x: array_domain t n)
-: Tot (Steel.C.PCM.pcm (array_range t n x))
-= Steel.C.Opt.opt_pcm #t
-
-let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
-
-[@"opaque_to_smt"]
-let rec raise_list_array_domain
-  (t: Type u#0)
-  (n n': size_t)
-  (l: list (array_domain t n))
-: Pure (list (array_domain t n'))
-  (requires (size_v n' >= size_v n))
-  (ensures (fun l' ->
-    (forall (x': array_domain t n') . List.Tot.mem x' l' <==> (size_v x' < size_v n /\ List.Tot.mem x' l)) /\
-    List.Tot.length l' == List.Tot.length l
-  ))
-= match l with
-  | [] -> []
-  | x :: l_ -> x :: raise_list_array_domain t n n' l_
-
-[@"opaque_to_smt"]
-let rec included_indices
-  (t: Type u#0)
-  (n: size_t)
-: Pure (list (array_domain t n))
-  (requires True)
-  (ensures (fun l ->
-    (forall (x: array_domain t n) . List.Tot.mem x l) /\
-    List.Tot.length l == size_v n
-  ))
-  (decreases (size_v n))
-= if n = mk_size_t (FStar.UInt32.uint_to_t 0)
-  then []
-  else
-    let n' = size_sub n (mk_size_t (FStar.UInt32.uint_to_t 1)) in
-    n' :: raise_list_array_domain t n' n (included_indices t n')
-
-let array_elements_view_type
-  (t: Type u#0)
-  (n: size_t)
-  (k: array_domain t n)
-: Tot Type0
-= t
-
-let array_elements_view
-  (t: Type u#0)
-  (n: size_t)
-  (k: array_domain t n)
-: Tot (Steel.C.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
-= Steel.C.Opt.opt_view _
-
-let intro_array_view_init
-  (t: Type u#0)
-  (n: size_t)
-  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-  (k: nat { k < size_v n })
-: Tot t
-= x (int_to_size_t k)
-
-let intro_array_view
-  (t: Type u#0)
-  (n: size_t)
-  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-: Tot (array_view_type t n)
-= Seq.init (size_v n) (intro_array_view_init t n x)
-
-let array_to_view
-  (t: Type u#0)
-  (n: size_t)
-  (x: Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
-: Tot (array_view_type t n)
-= intro_array_view t n (S.struct_view_to_view (array_elements_view t n) (included_indices t n) x)
-
-let elim_array_view_f
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-  (k: Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
-: Tot (array_elements_view_type t n k)
-= Seq.index x (size_v k)
-
-let elim_array_view
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-: Tot (restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-= on_dom (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
-
-let array_to_carrier
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-: Tot (Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
-= S.struct_view_to_carrier (array_elements_view t n) (included_indices t n) (elim_array_view t n x)
-
-open Steel.C.PCM
-
-let array_view_to_view_frame
-  (t: Type u#0)
-  (n: size_t)
-  (x: array_view_type t n)
-  (frame: array_pcm_carrier t n)
-: Lemma
-    (requires (composable (array_pcm t n) (array_to_carrier t n x) frame))
-    (ensures
-      S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)
-        (op (array_pcm t n) (array_to_carrier t n x) frame) /\ 
-      array_to_view t n
-        (op (array_pcm t n) (array_to_carrier t n x) frame) `Seq.equal` x)
-= S.struct_view_to_view_frame (array_elements_view t n) (included_indices t n)
-    (elim_array_view t n x) frame
-
-let array_view' (t: Type u#0) (n: size_t)
-  : Tot (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
-=
-  let open Steel.C.Ref in
-  {
-    to_view_prop = S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n);
-    to_view = array_to_view t n;
-    to_carrier = array_to_carrier t n;
-    to_carrier_not_one = (S.struct_view (array_elements_view t n) (included_indices t n)).to_carrier_not_one;
-    to_view_frame = array_view_to_view_frame t n;
-  }
-
-let array_view t n =
-  assert (size_v n > 0);
-  array_view' t n
-
-noeq
-type array_from0 base t = {
-  base_len: Ghost.erased size_t;
-  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
-  from: size_t;
-  perm_ref: Steel.Reference.ghost_ref unit;
-}
-
-[@@erasable]
-noeq
-type array_to0 = {
-  to: size_t;
-  perm_val: Steel.FractionalPermission.perm;
-}
-
-let array0_spec
-  (#base: _)
-  (#t: _)
-  (from: array_from0 base t)
-  (to: array_to0)
-: Tot prop
-=
-    size_v from.base_len >= 0 /\
-    size_v from.from <= size_v to.to /\
-    size_v to.to <= size_v from.base_len
-
-let array_or_null_from base t = option (array_from0 base t)
-let array_or_null_to base t = Ghost.erased (option array_to0)
-let array_or_null_spec (from, to) =
-  None? from == None? to /\
-  ((Some? from \/ Some? to) ==> array0_spec (Some?.v from) (Some?.v to))
-
-let len (from, to) =
-  match from with
-  | Some from ->
-    let Some to = Ghost.reveal to in to.to `size_sub` from.from
-  | _ -> zero_size
-
-let null_from _ _ = None
-let null_to _ _ = None
-let null_to_unique _ = ()
-
-let g_is_null a = None? (fst a)
-
-let rec array_is_unit_aux
-  (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
-  (i: size_t)
-  (f:
-    (j: size_t) ->
-    Lemma
-    (requires (size_v j < size_v n - size_v i))
-    (ensures (size_v j < size_v n - size_v i /\ a j == one (array_elements_pcm t n j)))
-  )
-: Pure bool
-  (requires True)
-  (ensures (fun y -> y == true <==> (forall j . size_v j < size_v n ==> a j == one (array_elements_pcm t n j))))
-  (decreases (size_v i))
-= Classical.forall_intro (Classical.move_requires f);
-  if size_le i zero_size
-  then true
-  else
-    let i' = size_sub i one_size in
-    if not (size_le i n)
-    then array_is_unit_aux t n a i' (fun _ -> ())
-    else if None? (a (size_sub n i))
-    then array_is_unit_aux t n a i' (fun j -> if j = size_sub n i then () else f j)
-    else false
-
-let array_is_unit_lemma
-  (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
-: Lemma
-  (requires (forall (j: array_domain  t n) . a j == one (array_elements_pcm t n j)))
-  (ensures (a == one (array_pcm t n)))
-= S.ext a (one (array_pcm t n)) (fun _ -> ())
-
-let array_is_unit t n a =
-  Classical.move_requires (array_is_unit_lemma t n) a;
-  array_is_unit_aux t n a n (fun _ -> ())
-
-let array_large_to_small_f
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: Ghost.erased size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t base_len)
-: Tot (array_pcm_carrier t (to `size_sub` from))
-= on_dom (array_domain t (to `size_sub` from)) (fun k -> x (from `size_add` k))
-
-let array_large_to_small_f_eq
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: Ghost.erased size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t base_len)
-  (k: array_domain t (to `size_sub` from))
-: Lemma
-  (array_large_to_small_f t base_len from to sq x k == x (from `size_add` k))
-= ()
-
-let array_large_to_small_f_eq'
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: Ghost.erased size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t base_len)
-  (k' : array_domain t base_len)
-: Lemma
-  (requires (
-    size_v from <= size_v k' /\
-    size_v k' < size_v to
-  ))
-  (ensures (
-    array_large_to_small_f t base_len from to sq x (k' `size_sub` from) == x k'
-  ))
-= ()
-
-let array_large_to_small
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: Ghost.erased size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Tot (Steel.C.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
-= Steel.C.Connection.mkmorphism
-    (array_large_to_small_f t base_len from to sq)
-    (assert (array_large_to_small_f t base_len from to sq (one (array_pcm t base_len)) `feq` one (array_pcm t (to `size_sub` from))))
-    (fun x1 x2 ->
-      assert (array_large_to_small_f t base_len from to sq (op (array_pcm t base_len) x1 x2) `feq` op (array_pcm t (to `size_sub` from)) (array_large_to_small_f t base_len from to sq x1)  (array_large_to_small_f t base_len from to sq x2))
-    )
-
-let array_small_to_large_f
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t) // Tot, argh
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t (to `size_sub` from))
-: Tot (array_pcm_carrier t base_len)
-= on_dom (array_domain t base_len) (fun k -> if size_le from k && not (size_le to k) then x (k `size_sub` from)
-  else one (Steel.C.Opt.opt_pcm #t))
-
-let array_small_to_large
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Tot (Steel.C.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
-= Steel.C.Connection.mkmorphism
-    (array_small_to_large_f t base_len from to sq)
-    (assert (array_small_to_large_f t base_len from to sq (one (array_pcm t (to `size_sub` from))) `feq` one (array_pcm t (base_len))))
-    (fun x1 x2 ->
-      assert (array_small_to_large_f t base_len from to sq (op (array_pcm t (to `size_sub` from)) x1 x2) `feq` op (array_pcm t (base_len)) (array_small_to_large_f t base_len from to sq x1)  (array_small_to_large_f t base_len from to sq x2))
-    )
-
-let array_small_to_large_to_small
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Lemma
-  (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
-= assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
-
-#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
-#restart-solver
-
-let size_sub' (x y: size_t) (sq: squash (size_v x >= size_v y)) : Pure size_t
-  (requires True)
-  (ensures (fun z -> size_v z == size_v x - size_v y))
-= size_sub x y
-
-#restart-solver
-
-let array_conn_fpu_compatible
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
-: Lemma
-  (
-    let z = size_sub to from in
-    let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-    compatible (array_pcm t z) x v_small
-  )
-=
-  let z = size_sub to from in
-  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-  let frame : Ghost.erased (array_pcm_carrier t base_len) = Ghost.hide (compatible_elim (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x) v) in
-  let frame_small : Ghost.erased (array_pcm_carrier t (z)) = Ghost.hide (array_large_to_small_f t base_len from to sq (Ghost.reveal frame)) in
-  S.prod_pcm_composable_intro
-    (array_elements_pcm t z)
-    x
-    frame_small
-    (fun h ->
-      assert (composable (Steel.C.Opt.opt_pcm #t) (array_small_to_large_f t base_len from to sq x (from `size_add` h)) (Ghost.reveal frame (from `size_add` h))
-      )
-    );
-  assert (composable (array_pcm t (z)) x frame_small);
-  array_pcm_carrier_ext t z (op (array_pcm t (z)) x frame_small) v_small (fun i ->
-    assert (op (Steel.C.Opt.opt_pcm #t) (array_small_to_large_f t base_len from to sq x (from `size_add` i)) (Ghost.reveal frame (from `size_add` i)) == v (from `size_add` i))
-  );
-  compatible_intro (array_pcm t (z)) x v_small frame_small
-
-let array_conn_fpu_refine
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
-: Lemma
-  (
-    let z = size_sub to from in
-    let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-    p_refine (array_pcm t (z)) v_small
-  )
-=
-  let z = size_sub to from in
-  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-  if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (x: array_domain t z) . True)
-  then ()
-  else assert (Ghost.reveal x `feq` one (array_pcm t z))
-
-let overwrite_array_slice
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (v: array_pcm_carrier t base_len)
-  (v_small' : array_pcm_carrier t (to `size_sub` from))
-: Tot (array_pcm_carrier t base_len)
-=
-    on_dom (array_domain t base_len) (fun (k: array_domain t base_len) ->
-      if from `size_le` k && not (to `size_le` k)
-      then begin
-        let sq2 : squash (size_v k >= size_v from) = assert (size_v k >= size_v from) in
-        v_small' (size_sub' k from sq2) <: option t
-      end
-      else v k
-    )
-
-let overwrite_array_slice_index
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (v: array_pcm_carrier t base_len)
-  (v_small' : array_pcm_carrier t (to `size_sub` from))
-  (k: array_domain t base_len)
-: Lemma (
-    overwrite_array_slice t base_len from to sq v v_small' k == (
-    if size_v from <= size_v k && size_v k < size_v to
-    then v_small' (k `size_sub` from)
-    else v k
-  ))
-= ()
-
-let overwrite_array_slice_index_in
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (v: array_pcm_carrier t base_len)
-  (v_small' : array_pcm_carrier t (to `size_sub` from))
-  (k: array_domain t base_len)
-: Lemma
-  (requires (
-    size_v from <= size_v k /\ size_v k < size_v to
-  ))
-  (ensures (
-    overwrite_array_slice t base_len from to sq v v_small' k == v_small' (k `size_sub` from)
-  ))
-= ()
-
-let overwrite_array_slice_index_out
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (v: array_pcm_carrier t base_len)
-  (v_small' : array_pcm_carrier t (to `size_sub` from))
-  (k: array_domain t base_len)
-: Lemma
-  (requires (
-    ~ (size_v from <= size_v k /\ size_v k < size_v to)
-  ))
-  (ensures (
-    overwrite_array_slice t base_len from to sq v v_small' k == v k
-  ))
-= ()
-
-let overwrite_array_slice_id
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (v: array_pcm_carrier t base_len)
-  (v_small' : array_pcm_carrier t base_len)
-: Lemma
-  (overwrite_array_slice t base_len zero_size base_len () v v_small' == v_small')
-= array_pcm_carrier_ext t base_len
-    (overwrite_array_slice t base_len zero_size base_len () v v_small')
-    v_small'
-    (fun i -> ())
-
-let array_conn_fpu_f
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
-  (f: frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
-  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))
-: Tot (array_pcm_carrier t base_len)
-= let sq0 : squash (size_v to >= size_v from) = () in
-  let z : size_t = size_sub' to from sq0 in
-  let v_small : array_pcm_carrier t z = array_large_to_small_f t base_len from to sq v in
-  array_conn_fpu_compatible t base_len from to sq x v;
-  array_conn_fpu_refine t base_len from to sq x v;
-  let v_small' : array_pcm_carrier t z = f v_small in
-  overwrite_array_slice t base_len from to sq v v_small'
-
-#pop-options
-
-let array_conn
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-: Steel.C.Connection.connection
-    (array_pcm t base_len)
-    (array_pcm t (to `size_sub` from))
-=
-  Steel.C.Connection.mkconnection1
-    (array_small_to_large t base_len from to sq)
-    (array_large_to_small t base_len from to sq)
-    (array_small_to_large_to_small t base_len from to sq)
-    (array_conn_fpu_f t base_len from to sq)
-    (fun x y f v -> assume False)
-
-#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
-#restart-solver
-
-let array_conn_fpu_eq
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
-  (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
-  (f: Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
-  (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))  
-: Lemma
-  (let open Steel.C.Connection in
-  ((array_conn t base_len from to sq).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == array_conn_fpu_f t base_len from to sq x y f v)
-= ()
-
-#restart-solver
-
-let connection_eq_gen
-  #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Connection.connection` q1)
-  #b2 (#q2: pcm b2) (c2: p `Steel.C.Connection.connection` q2)
-  (sq: squash (
-    b1 == b2 /\
-    q1 == q2 /\
-    c1.conn_small_to_large.morph `feq` c2.conn_small_to_large.morph /\
-    c1.conn_large_to_small.morph `feq` c2.conn_large_to_small.morph
-  ))
-  (phi:
-    (x1: Ghost.erased b1 { ~ (Ghost.reveal x1 == one q1) }) ->
-    (y1: Ghost.erased b1) ->
-    (f1: Steel.C.Connection.restricted_frame_preserving_upd q1 x1 y1) ->
-    (v1: frame_preserving_upd_dom p (c1.conn_small_to_large.morph x1)) ->
-    (x2: Ghost.erased b2 { ~ (Ghost.reveal x2 == one q2) }) ->
-    (y2: Ghost.erased b2) ->
-    (f2: Steel.C.Connection.restricted_frame_preserving_upd q2 x2 y2) ->
-    (v2: frame_preserving_upd_dom p (c2.conn_small_to_large.morph x2)) ->
-    (sq': squash (
-      x1 == x2 /\
-      y1 == y2 /\
-      f1 == f2 /\
-      v1 == v2
-    )) ->
-    Tot
-    (squash ((c1.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1 })).fpu_f v1 == (c2.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2 })).fpu_f v2))
-  )
-: Lemma
-  (c1 == c2)
-= Steel.C.Connection.connection_eq_gen c1 c2 () (fun x y f v -> phi x y f v x y f v ())
-
-#restart-solver
-let array_conn_id
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-: Lemma
-  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id (array_pcm t base_len))
-= let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
-  assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
-  assert (forall x . array_small_to_large_f t base_len z base_len () x == x);
-  assert (forall x . array_large_to_small_f t base_len z base_len () x `feq` x);
-  assert (forall x . array_large_to_small_f t base_len z base_len () x == x);
-  let c = array_conn t base_len z base_len () in
-  connection_eq_gen
-    c
-    (Steel.C.Connection.connection_id (array_pcm t base_len))
-    ()
-    (fun x1 y1 f1 v1 x2 y2 f2 v2 sq12 ->
-      let v_small : array_pcm_carrier t base_len = array_large_to_small_f t base_len z base_len () v1 in
-      assert (v_small == v1);
-      array_conn_fpu_compatible t base_len z base_len () x1 v1;
-      array_conn_fpu_refine t base_len z base_len () x1 v1;
-      let v_small' : array_pcm_carrier t base_len = f1 v1 in
-      overwrite_array_slice_id t base_len v1 v_small';
-      let s' : array_pcm_carrier t base_len = overwrite_array_slice t base_len z base_len () v1 v_small' in
-      assert (array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1 == s');
-      assert (s' == f1 v1);
-      assert ((c.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1; })).Steel.C.Connection.fpu_f v1 == array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1);
-      Steel.C.Connection.connection_id_fpu (array_pcm t base_len) x2 y2 f2 v2;
-      assert (((Steel.C.Connection.connection_id (array_pcm t base_len)).conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2; })).Steel.C.Connection.fpu_f v2 == f2 v2);
-      ()
-    )
-
-let ifthenelse_prf
-  (p: prop)
-  (cond: bool)
-  (iftrue: squash (cond == true) -> Lemma p)
-  (iffalse: squash (cond == false) -> Lemma p)
-: Lemma p
-= if cond
-  then iftrue ()
-  else iffalse ()
-
-#restart-solver
-let array_conn_compose_morphisms
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from1: size_t)
-  (to1: size_t)
-  (from2: size_t)
-  (to2: size_t)
-  (h: squash (
-    size_v from1 <= size_v to1 /\
-    size_v to1 <= size_v base_len /\
-    size_v from2 <= size_v to2 /\
-    size_v from1 + size_v to2 <= size_v to1
-  ))
-: Tot (squash (
-      let z = to1 `size_sub` from1 in
-      let c1 = array_conn t base_len from1 to1 () in
-      let c2 = array_conn t z from2 to2 () in
-      let cc = c1 `Steel.C.Connection.connection_compose` c2 in
-      let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
-      cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
-      cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
-  ))
-=
-  let z = to1 `size_sub` from1 in
-  let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
-  let _ : squash (sz == size_sub to2 from2) = () in
-  assert (forall x . array_small_to_large_f t base_len from1 to1 () (array_small_to_large_f t z from2 to2 ()  x) `feq` array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x);
-  assert (forall x . array_large_to_small_f t z from2 to2 () (array_large_to_small_f t base_len from1 to1 () x) `feq` array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x)
-
-#push-options "--print_implicits --z3rlimit 256"
-
-let size_sub_size_add_l
-  (from1: size_t)
-  (to1: size_t)
-  (from2: size_t)
-  (to2: size_t)
-  (sq: squash (
-    size_v from1 <= size_v to1 /\
-    size_v from2 <= size_v to2 /\
-    size_v from1 + size_v to2 <= size_v to1
-  ))
-: Lemma
-  ((from1 `size_add` to2) `size_sub` (from1 `size_add` from2) == to2 `size_sub` from2)
-= ()
-
-let size_sub_size_sub
-  (from1: size_t)
-  (to1: size_t)
-  (from2: size_t)
-  (to2: size_t)
-  (i: size_t)
-  (sq: squash (
-    size_v from1 <= size_v to1 /\
-    size_v from1 + size_v to2 <= size_v to1 /\
-    size_v from1 + size_v from2 <= size_v i /\
-    size_v i <= size_v from1 + size_v to2
-  ))
-: Lemma
-  ((i `size_sub` from1) `size_sub` from2 == i `size_sub` (from1 `size_add` from2))
-= ()
-
-let array_large_to_small_f_compose
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from1: size_t)
-  (to1: size_t)
-  (from2: size_t)
-  (to2: size_t)
-  (sq: squash (
-    size_v from1 <= size_v to1 /\
-    size_v to1 <= size_v base_len /\
-    size_v from2 <= size_v to2 /\
-    size_v from1 + size_v to2 <= size_v to1
-  ))
-  (a: array_pcm_carrier t base_len)
-: Lemma
-  (array_large_to_small_f t (to1 `size_sub` from1) from2 to2 () (array_large_to_small_f t base_len from1 to1 () a) ==
-    array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () a)
-= assert (
-  (array_large_to_small_f t (to1 `size_sub` from1) from2 to2 () (array_large_to_small_f t base_len from1 to1 () a) `feq`
-    array_large_to_small_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () a)
-  )
-
-#restart-solver
-let array_conn_compose_fpu
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from1: size_t)
-  (to1: size_t)
-  (from2: size_t)
-  (to2: size_t)
-  (sq: squash (
-    size_v from1 <= size_v to1 /\
-    size_v to1 <= size_v base_len /\
-    size_v from2 <= size_v to2 /\
-    size_v from1 + size_v to2 <= size_v to1
-  ))
-  (x: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)) {~ (Ghost.reveal x == one (array_pcm t (to2 `size_sub` from2)))})
-  (y: Ghost.erased (array_pcm_carrier t (to2 `size_sub` from2)))
-  (f: frame_preserving_upd (array_pcm t (to2 `size_sub` from2)) x y)
-  (x2: Ghost.erased (array_pcm_carrier t (to1 `size_sub` from1)))
-  (sqx2: squash (
-    Ghost.reveal x2 == array_small_to_large_f t (to1 `size_sub` from1) from2 to2 () x /\
-    (~ (Ghost.reveal x2 == one (array_pcm t (to1 `size_sub` from1))))
-  ))
-  (y2: Ghost.erased (array_pcm_carrier t (to1 `size_sub` from1)))
-  (sqy2: squash (
-    Ghost.reveal y2 == array_small_to_large_f t (to1 `size_sub` from1) from2 to2 () y
-  ))
-  (f2: frame_preserving_upd (array_pcm t (to1 `size_sub` from1)) x2 y2)
-  (sqf2: (
-    (v: frame_preserving_upd_dom (array_pcm t (to1 `size_sub` from1)) x2) ->
-    Lemma
-    (f2 v == array_conn_fpu_f t (to1 `size_sub` from1) from2 to2 () x y f v)
-  ))
-  (x0: Ghost.erased (array_pcm_carrier t base_len))
-  (sqx0: squash (
-    Ghost.reveal x0 == array_small_to_large_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x /\
-    Ghost.reveal x0 == array_small_to_large_f t base_len from1 to1 () x2 /\
-    (~ (Ghost.reveal x0 == one (array_pcm t base_len)))
-  ))
-  (v: frame_preserving_upd_dom (array_pcm t base_len) x0)
-: Lemma
-  (ensures (
-    array_conn_fpu_f t base_len from1 to1 () x2 y2 f2 v == array_conn_fpu_f t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x y f v
-  ))
-= let al : array_pcm_carrier t base_len = array_conn_fpu_f t base_len from1 to1 () x2 y2 f2 v in
-  array_conn_fpu_compatible t base_len from1 to1 () x2 v;
-  array_conn_fpu_refine t base_len from1 to1 () x2 v;
-  let sz1 = to1 `size_sub` from1 in
-  let v_l_out_small : array_pcm_carrier t sz1 = array_large_to_small_f t base_len from1 to1 () v in
-  sqf2 v_l_out_small;
-  array_conn_fpu_compatible t sz1 from2 to2 () x v_l_out_small;
-  array_conn_fpu_refine t sz1 from2 to2 () x v_l_out_small;
-  let sz2 = to2 `size_sub` from2 in
-  let v_l_in_small : array_pcm_carrier t sz2 = array_large_to_small_f t sz1 from2 to2 () v_l_out_small in
-  let v_l_in_small' : array_pcm_carrier t sz2 = f v_l_in_small in
-  let v_l_in' : array_pcm_carrier t sz1 = overwrite_array_slice t sz1 from2 to2 () v_l_out_small v_l_in_small' in
-  let v_l' : array_pcm_carrier t base_len = overwrite_array_slice t base_len from1 to1 () v v_l_in' in
-  assert (v_l' == al);
-  let from = from1 `size_add` from2 in
-  let to = from1 `size_add` to2 in
-  let _ : squash (sz2 == to `size_sub` from) = size_sub_size_add_l from1 to1 from2 to2 () in
-  let ar : array_pcm_carrier t base_len = array_conn_fpu_f t base_len from to () x y f v in
-  array_conn_fpu_compatible t base_len from to () x v;
-  array_conn_fpu_refine t base_len from to () x v;
-  let v_r_small : array_pcm_carrier t sz2 = array_large_to_small_f t base_len from to () v in
-  let _ : squash (v_r_small == v_l_in_small) = array_large_to_small_f_compose t base_len from1 to1 from2 to2 () v in
-  let v_r_small' : array_pcm_carrier t sz2 = f v_r_small in
-  assert (v_r_small' == v_l_in_small');
-  let v_r' : array_pcm_carrier t base_len = overwrite_array_slice t base_len from to () v v_r_small' in
-  assert (v_r' == ar);
-  array_pcm_carrier_ext t base_len v_l' v_r' (fun i ->
-    overwrite_array_slice_index t base_len from1 to1 () v v_l_in' i;
-    overwrite_array_slice_index t base_len from to () v v_r_small' i;
-    if size_v from1 <= size_v i && size_v i < size_v to1
-    then begin
-      let i' : array_domain t sz1 = i `size_sub` from1 in
-      let b = (size_v from2 <= size_v i' && size_v i' < size_v to2) in
-      assert ((size_v (from1 `size_add` from2) <= size_v i && size_v i < size_v (from1 `size_add` to2)) == b);
-      overwrite_array_slice_index t sz1 from2 to2 () v_l_out_small v_l_in_small' i';
-      if size_v from2 <= size_v i' && size_v i' < size_v to2
-      then begin
-        size_sub_size_sub from1 to1 from2 to2 i ()
-      end else begin
-        assert (f2 v_l_out_small i' == v_l_out_small i');
-        array_large_to_small_f_eq' t base_len from1 to1 () v i
-      end
-    end else begin
-      assert ((size_v (from1 `size_add` from2) <= size_v i && size_v i < size_v (from1 `size_add` to2)) == false)
-    end
-  )
-
-#restart-solver
-let array_conn_compose
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from1: size_t)
-  (to1: size_t)
-  (from2: size_t)
-  (to2: size_t)
-: Lemma
-  (requires (
-    size_v from1 <= size_v to1 /\
-    size_v to1 <= size_v base_len /\
-    size_v from2 <= size_v to2 /\
-    size_v from1 + size_v to2 <= size_v to1
-  ))
-  (ensures (
-    array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t (to1 `size_sub` from1) from2 to2 () ==
-    array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) ()
-  ))
-=
-  let z = to1 `size_sub` from1 in
-  let sz = size_sub (size_add from1 to2) (size_add from1 from2) in
-  let _ : squash (sz == size_sub to2 from2) = () in
-  let c1 = array_conn t base_len from1 to1 () in
-  let c2 = array_conn t z from2 to2 () in
-  let cc = c1 `Steel.C.Connection.connection_compose` c2 in
-  let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
-  let sq : squash (
-      cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
-      cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
-  ) =
-    array_conn_compose_morphisms t base_len from1 to1 from2 to2 ()
-  in
-  Steel.C.Connection.connection_eq_gen cc c sq (fun x y f v ->
-    let open Steel.C.Connection in
-    let x' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph x in
-    let y' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph y in
-    let phi = mk_restricted_frame_preserving_upd (c2.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })) in
-    connection_compose_fpu
-      c1
-      c2
-      x y f
-      phi;
-    array_conn_fpu_eq t base_len from1 to1 () x' y' phi v;
-    array_conn_fpu_eq t base_len (from1 `size_add` from2) (from1 `size_add` to2) () x y f v;
-    array_conn_compose_fpu
-      t base_len from1 to1 from2 to2 ()
-      x y f
-      x' () y' ()
-      phi
-      (fun v' ->
-        array_conn_fpu_eq t z from2 to2 () x y f v'
-      )
-      (cc.conn_small_to_large.morph x)
-      ()
-      v
-  )
-
-
-#pop-options
-
-#restart-solver
-
-let to_view_array_conn
-  (t: Type0)
-  (base_len: Ghost.erased size_t)
-  (from: size_t)
-  (to: size_t)
-  (sq: squash (
-    size_v from <= size_v to /\
-    size_v to <= size_v base_len
-  ))
-  (x: array_pcm_carrier t base_len)
-: Lemma
-  (requires (
-    S.struct_view_to_view_prop (array_elements_view t base_len) (included_indices t base_len) x 
-  ))
-  (ensures (
-    let x' = array_large_to_small_f t base_len from to sq x in
-    S.struct_view_to_view_prop (array_elements_view t (to `size_sub` from)) (included_indices t (to `size_sub` from)) x' /\
-    array_to_view t (to `size_sub` from) x' `Seq.equal` Seq.slice (array_to_view t base_len x) (size_v from) (size_v to)
-  ))
-= ()
-
-#pop-options
-
-let array__base_len
-  (#base #t: _)
-  (a: array base t)
-: GTot size_t
-= (Some?.v (fst a)).base_len
-
-let array__base_ref
-  (#base #t: _)
-  (a: array base t)
-: Tot (Steel.C.Reference.ref base (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
-= (Some?.v (fst a)).base_ref
-
-let array__from
-  (#base #t: _)
-  (a: array base t)
-: Tot size_t
-= (Some?.v (fst a)).from
-
-let array__to
-  (#base #t: _)
-  (a: array base t)
-: GTot size_t
-= (Some?.v (snd a)).to
-
-let array__perm_ref
-  (#base #t: _)
-  (a: array base t)
-: Tot (Steel.Reference.ghost_ref unit)
-= (Some?.v (fst a)).perm_ref
-
-let array__perm_val
-  (#base #t: _)
-  (a: array base t)
-: Tot Steel.FractionalPermission.perm
-= (Some?.v (snd a)).perm_val
-
-let array_as_ref_conn
-  (#base: Type)
-  (#t: Type)
-  (a: array base t)
-: GTot (Steel.C.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
-= array_conn t (array__base_len a) (array__from a) (array__to a) ()
-
-let array_as_ref
-  (#base: Type)
-  (#t: Type)
-  (a: array base t)
-: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
-= Steel.C.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
-
-[@@__steel_reduce__]
-let varray0
-  (#base: Type)
-  (#t: Type)
-  (x: array base t)
-: Tot vprop
-= Steel.C.Ref.pts_to_view
-    #base
-    #(array_pcm_carrier t (len x))
-    #(array_pcm t (len x))
-    (array_as_ref #base #t x)
-    #(array_view_type t (len x))
-    #(size_v (len x) = 0)
-    (array_view' t (len x))
-
-[@@__steel_reduce__]
-let varray9
-  (#base: Type)
-  (#t: Type)
-  (x: array base t)
-: Tot vprop
-= (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x)  (array__perm_val x)) `vrewrite` fst
-
-let varray_hp #base #t x = hp_of (varray9 #base #t x)
-
-#push-options "--debug Steel.C.Array --debug_level Extreme"
-
-let varray_sel #base #t x = sel_of (varray9 #base #t x)
-
-#pop-options
-
-let intro_varray1
-  (#inames: _)
-  (#base: Type)
-  (#t: Type)
-  (x: array base t)
-: SteelGhost unit inames
-    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
-    (fun _ -> varray x)
-    (fun _ -> True)
-    (fun h _ h' -> h' (varray x) == h (varray0 x))
-= intro_vrewrite
-    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
-    fst;
-  change_slprop_rel
-    ((varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x)) `vrewrite` fst)
-    (varray x)
-    (fun u v -> u == v)
-    (fun m -> ())
-
-let elim_varray1
-  (#inames: _)
-  (#base: Type)
-  (#t: Type)
-  (x: array base t)
-: SteelGhost unit inames
-    (varray x)
-    (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
-    (fun _ -> True)
-    (fun h _ h' -> h' (varray0 x) == h (varray x))
-= change_slprop_rel
-    (varray x)
-    ((varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x)) `vrewrite` fst)
-    (fun u v -> u == v)
-    (fun m -> ());
-  elim_vrewrite
-    (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
-    fst
-
-let g_mk_array_from'
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from base t)
-: Tot prop
-= 
-  Some? a /\
-  size_v n > 0 /\
-  begin let a = Some?.v a in
-  Ghost.reveal a.base_len == n /\
-  a.base_ref == r /\
-  a.from == mk_size_t 0ul
-  end
-
-let g_mk_array #base #t #n r a =
-  g_mk_array_from' r (fst a) /\
-  (array__to a) == n /\
-  (array__perm_val a) == Steel.FractionalPermission.full_perm
-
-let g_mk_array_weak r a = ()
-
-let g_mk_array_from r a = g_mk_array_from' r a
-
-let g_mk_array_to #base #t #n r a
-=
-  Some ({
-    to = n;
-    perm_val = Steel.FractionalPermission.full_perm
-  })
-
-#push-options "--z3rlimit 32"
-
-val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (_: squash (size_v n > 0))
-: SteelAtomicBase (array base t)
-    false opened Unobservable
-    (Steel.C.Ref.pts_to_view r (array_view t n))
-    (fun a -> varray a)
-    (requires fun _ -> True)
-  (ensures (fun h a h' ->
-    g_mk_array r a /\
-    snd a == g_mk_array_to r (fst a) /\
-    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
-  ))
-
-let intro_varray0
-  #base #t #_ #n r sq
-=
-  let perm_ref = Steel.Reference.ghost_alloc #unit () in
-  let from = Some ({
-    base_len = n;
-    base_ref = r;
-    from = mk_size_t 0ul;
-    perm_ref = perm_ref;
-  }) in
-  let res = (from, g_mk_array_to r from) in
-  change_equal_slprop
-    (Steel.Reference.ghost_vptr perm_ref)
-    (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
-  assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
-  array_conn_id t n;
-  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
-  Steel.C.Ref.ref_focus_id r;
-  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
-  assert (array_as_ref res == r);
-  change_equal_slprop
-    (r `Steel.C.Ref.pts_to_view` _)
-    (varray0 res);
-  intro_varray1 res;
-  return res
-
-let intro_varray_from r _ =
-  let a = intro_varray0 r () in
-  let res = fst a in
-  change_equal_slprop
-    (varray a)
-    (varray (res, g_mk_array_to r res));
-  return res
-
-let elim_varray
-  #_ #base #t #n r res sq
-=
-  assert (g_mk_array r res);
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
-  array_conn_id t n;
-  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
-  Steel.C.Ref.ref_focus_id r;
-  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
-  assert (array_as_ref res == r);
-  elim_varray1 res;
-  change_equal_slprop
-    (varray0 res)
-    (r `Steel.C.Ref.pts_to_view` _);
-  let perm_ref = (array__perm_ref res) in
-  change_equal_slprop
-    (Steel.Reference.ghost_vptrp ((array__perm_ref res)) ((array__perm_val res)))
-    (Steel.Reference.ghost_vptr perm_ref);
-  Steel.Reference.ghost_free perm_ref
-
-#pop-options
-
-let adjacent r1 r2 =
-  (array__base_len r1) == (array__base_len r2) /\
-  (array__base_ref r1) == (array__base_ref r2) /\
-  (array__perm_ref r1) == (array__perm_ref r2) /\
-  (array__to r1) == (array__from r2)
-
-val t_merge
-  (#base: Type)
-  (#t: Type)
-  (r1 r2: array base t)
-: Pure (array base t)
-  (requires (adjacent r1 r2))
-  (ensures (fun r -> length r == length r1 + length r2))
-
-let t_merge r1 r2 =
-  (fst r1, Ghost.hide (Some ({
-    to = (array__to r2);
-    perm_val = (array__perm_val r1) `Steel.FractionalPermission.sum_perm` (array__perm_val r2);
-  })))
-
-let merge r1 r2 = t_merge r1 r2
-
-let merge_assoc r1 r2 r3 = ()
-
-let merge_inj_right a b1 b2 = ()
-
-let merge_inj_left a1 a2 b = ()
-
-let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
-  (~ (merge_into a b a))
-= let aux () : Lemma
-    (requires (merge_into a b a))
-    (ensures False)
-  = assert (
-      let open Steel.FractionalPermission in
-      let open FStar.Real in
-      (array__perm_val a).v +. (array__perm_val b).v >. (array__perm_val a).v
-    )
-  in
-  Classical.move_requires aux ()
-
-let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
-  (~ (merge_into a b b))
-= let aux () : Lemma
-    (requires (merge_into a b a))
-    (ensures False)
-  = assert (
-      let open Steel.FractionalPermission in
-      let open FStar.Real in
-      (array__perm_val a).v +. (array__perm_val b).v >. (array__perm_val b).v
-    )
-  in
-  Classical.move_requires aux ()
-
-val tsplit
-  (#base: Type)
-  (#t: Type)
-  (r: array base t)
-  (i: size_t)
-: Pure (array base t & array base t)
-  (requires (size_v i <= length r))
-  (ensures (fun (rl, rr) ->
-    merge_into rl rr r /\
-    length rl == size_v i
-  ))
-
-let tsplit #base #t r i =
-  let h = half_perm (array__perm_val r) in
-  let r1 : array base t =
-    (fst r, Ghost.hide (Some ({
-      to = (array__from r) `size_add` i;
-      perm_val = h;
-    })))
-  in
-  let r2 : array base t = (Some ({
-    base_len = (array__base_len r);
-    base_ref = (array__base_ref r);
-    from = (array__from r) `size_add` i;
-    perm_ref = (array__perm_ref r);
-  }), Ghost.hide (Some ({
-    to = (array__to r);
-    perm_val = h;
-  })))
-  in
-  (r1, r2)
-
-let gsplit r i = 
-  let (rl, rr) = tsplit r i in
-  GPair rl rr
-
-val pts_to_split
-  (t: Type)
-  (n: size_t)
-  (x: array_pcm_carrier t n)
-  (i: size_t)
-: Lemma
-  (requires (size_v i <= size_v n))
-  (ensures (
-    let z = mk_size_t 0ul in
-    let xl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () x) in
-    let xr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () x) in
-    composable (array_pcm t n) xl xr /\
-    op (array_pcm t n) xl xr == x
-  ))
-
-let pts_to_split t n x i =
-  let z = mk_size_t 0ul in
-  let xl = array_small_to_large_f t n z i () (array_large_to_small_f t n z i () x) in
-  let xr = array_small_to_large_f t n i n () (array_large_to_small_f t n i n () x) in
-  assert (composable (array_pcm t n) xl xr);
-  assert (op (array_pcm t n) xl xr `feq` x)
-
-val to_carrier_split
-  (t: Type)
-  (n: size_t)
-  (x: array_pcm_carrier t n)
-  (v: array_view_type t n)
-  (i: size_t)
-: Lemma
-  (requires (
-    size_v i <= size_v n /\
-    (array_view' t n).Steel.C.Ref.to_carrier v == x
-  ))
-  (ensures (
-    let z = mk_size_t 0ul in
-    let xl = (array_large_to_small_f t n z i () x) in
-    let xr = (array_large_to_small_f t n i n () x) in
-    (array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) == xl /\
-    (array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) == xr
-  ))
-
-#push-options "--z3rlimit 32"
-#restart-solver
-
-let to_carrier_split t n x v i =
-    let z = mk_size_t 0ul in
-    let xl = (array_large_to_small_f t n z i () x) in
-    let xr = (array_large_to_small_f t n i n () x) in
-    assert ((array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) `feq` xl);
-    assert ((array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
-
-let array_as_ref_split_left
-  (base: Type)
-  (t: Type)
-  (x: array base t)
-  (i: size_t)
-: Lemma
-  (requires (size_v i <= length x))
-  (ensures (
-    array_as_ref (fst (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
-  ))
-=
-  array_conn_compose t (array__base_len x) (array__from x) (array__to x) zero_size i;
-  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
-
-#restart-solver
-let array_as_ref_split_right
-  (base: Type)
-  (t: Type)
-  (x: array base t)
-  (i: size_t)
-: Lemma
-  (requires (size_v i <= length x))
-  (ensures (
-    array_as_ref (snd (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
-  ))
-=
-  array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
-  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
-
-val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
-  : SteelGhost (array base t `gpair` array base t) opened
-          (varray a)
-          (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
-          (fun _ -> size_v i <= length a)
-          (fun h res h' ->
-            let s = h (varray a) in
-            let sl = h' (varray (GPair?.fst res)) in
-            let sr = h' (varray (GPair?.snd res)) in
-            size_v i <= length a /\
-            res == gsplit a i /\
-            sl == Seq.slice s 0 (size_v i) /\
-            sr == Seq.slice s (size_v i) (length a)
-          )
-
-#pop-options
-#push-options "--z3rlimit 128"
-
-#restart-solver
-let split_
-  #j #base #t x i
-=
-  let gv = gget (varray x) in
-  elim_varray1 x;
-  let v = Steel.C.Ref.pts_to_view_elim
-    #j
-    #base
-    #(array_pcm_carrier t (len x))
-    #(array_pcm t (len x))
-    (array_as_ref #base #t x)
-    #(array_view_type t (len x))
-    #(size_v (len x) = 0)
-    (array_view' t (len x))
-  in
-  pts_to_split t (len x) v i;
-  let (xl, xr) = tsplit x i in
-  let n = len x in
-  let z = mk_size_t 0ul in
-  let vl' : array_pcm_carrier t (len xl) = array_large_to_small_f t n z i () v in
-  let vl : array_pcm_carrier t (len x) = array_small_to_large_f t n z i () vl' in
-  let vr' : array_pcm_carrier t (len xr) = array_large_to_small_f t n i n () v in
-  let vr : array_pcm_carrier t (len x) = array_small_to_large_f t n i n () vr' in
-  Steel.C.Ref.split
-    (array_as_ref #base #t x)
-    v
-    vl
-    vr;
-  let cl : (cl: Steel.C.Connection.connection
-    (array_pcm t (len x))
-    (array_pcm t (len xl)) {
-      cl === array_conn t n z i ()
-    })
-  = magic () // array_conn t n z i ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
-  in
-  Steel.C.Ref.gfocus
-    (array_as_ref #base #t x)
-    cl
-    vl
-    vl';
-  array_as_ref_split_left _ t x i;
-  assert (array_as_ref xl == Steel.C.Ref.ref_focus (array_as_ref x) cl);
-  change_equal_slprop
-    (_ `Steel.C.Ref.pts_to` vl')
-    (array_as_ref xl `Steel.C.Ref.pts_to` vl');
-  to_carrier_split t n v gv i;
-  let gvl : array_view_type t (len xl) = Seq.slice gv 0 (size_v i) in
-  Steel.C.Ref.pts_to_view_intro
-    #j
-    #base
-    #(array_pcm_carrier t (len xl))
-    #(array_pcm t (len xl))
-    (array_as_ref xl)
-    vl'
-    #(array_view_type t (len xl))
-    #(size_v (len xl) = 0)
-    (array_view' t (len xl))
-    gvl;
-  change_equal_slprop // necessary, otherwise F* goes off rails
-    (array_as_ref xl `Steel.C.Ref.pts_to_view` _)
-    (varray0 xl);
-  Steel.Reference.ghost_share (array__perm_ref x);
-  change_equal_slprop
-    (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
-    (Steel.Reference.ghost_vptrp (array__perm_ref xl) (array__perm_val xl));
-  intro_varray1 xl;
-  let cr : (cr: Steel.C.Connection.connection
-    (array_pcm t (len x))
-    (array_pcm t (len xr)) {
-      cr === array_conn t n i n ()
-    })
-  = magic () // array_conn t n i n ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
-  in
-  Steel.C.Ref.gfocus
-    (array_as_ref #base #t x)
-    cr
-    vr
-    vr';
-  array_as_ref_split_right _ t x i;
-  assert (array_as_ref xr == Steel.C.Ref.ref_focus (array_as_ref x) cr);
-  change_equal_slprop
-    (_ `Steel.C.Ref.pts_to` vr')
-    (array_as_ref xr `Steel.C.Ref.pts_to` vr');
-  let gvr : array_view_type t (len xr) = Seq.slice gv (size_v i) (size_v n) in
-//  let _ : squash ((Ghost.reveal gv <: Seq.seq t) == gvl `Seq.append` gvr) =
-//    Seq.lemma_split gv (size_v i)
-//  in
-  Steel.C.Ref.pts_to_view_intro
-    #j
-    #base
-    #(array_pcm_carrier t (len xr))
-    #(array_pcm t (len xr))
-    (array_as_ref xr)
-    vr'
-    #(array_view_type t (len xr))
-    #(size_v (len xr) = 0)
-    (array_view' t (len xr))
-    gvr;
-  change_equal_slprop // necessary, otherwise F* goes off rails
-    (array_as_ref xr `Steel.C.Ref.pts_to_view` _)
-    (varray0 xr);
-  change_equal_slprop
-    (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
-    (Steel.Reference.ghost_vptrp (array__perm_ref xr) (array__perm_val xr));
-  intro_varray1 xr;
-  let res = GPair xl xr in
-  change_equal_slprop
-    (varray xl)
-    (varray (GPair?.fst res));
-  change_equal_slprop
-    (varray xr)
-    (varray (GPair?.snd res));
-  res
-
-let split'
-  #_ #_ #t a i
-=
-  let g = gget (varray a) in
-  Seq.lemma_split #t (Ghost.reveal g) (size_v i);
-  split_ a i
-
-let split_right_from
-  a i
-=
-  return (fst (snd (tsplit a i)))
-
-let join' = admit ()
-
-let array_as_one_ref_iso
-  (base: Type)
-  (t: Type)
-: Tot (Steel.C.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
-= let c1 = (Steel.C.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
-  let c2 = (Steel.C.Struct.field_to_struct (array_elements_pcm t one_size) zero_size) in
-  Steel.C.Connection.mkisomorphism
-    c1
-    c2
-    ()
-    (Steel.C.Connection.is_inverse_of_intro
-      c2.Steel.C.Connection.morph
-      c1.Steel.C.Connection.morph
-      (fun x ->
-        array_pcm_carrier_ext t one_size (c2.Steel.C.Connection.morph (c1.Steel.C.Connection.morph x)) x (fun i ->
-          ()
-        )
-      )
-    )
-    (fun x -> ())
-    (fun x -> ())
-
-let array_as_one_ref_conn
-  (base: Type)
-  (t: Type)
-: Tot (Steel.C.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
-= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso base t)
-
-let g_ref_of_array
-  #base #t r
-=
-  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
-
-let array_as_one_ref_conn'
-  (#base: Type) (#t:Type0) (r:array base t)
-: Pure (Steel.C.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
-  (requires (size_v (len r) == 1))
-  (ensures (fun _ -> True))
-=
-  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
-
-#restart-solver
-let array_as_one_ref_conn'_small_to_large
-  (#base: Type) (#t:Type0) (r:array base t)
-  (x: option t)
-  (i: array_domain t (array__base_len r))
-: Lemma
-  (requires (size_v (len r) == 1))
-  (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = (array__from r) then x else None)))
-= Steel.C.Connection.morphism_compose_morph
-    (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large
-    (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Connection.conn_small_to_large
-    x
-
-let g_ref_of_array'
-  (#base: Type) (#t:Type0) (r:array base t)
-: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (requires (size_v (len r) == 1))
-  (ensures (fun _ -> True))
-= (array__base_ref r) `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
-
-let g_ref_of_array'_correct
-  (#base: Type) (#t:Type0) (r:array base t)
-: Lemma
-  (requires (length r == 1))
-  (ensures (g_ref_of_array r == g_ref_of_array' r))
-=
-  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn base t)
-
-let get_pts_to
-  (#inames: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
-  (r: Steel.C.Ref.ref a p) (v: Ghost.erased b)
-: SteelGhost (Ghost.erased b) inames
-    (Steel.C.Ref.pts_to r v)
-    (fun v' -> Steel.C.Ref.pts_to r v)
-    (fun _ -> True)
-    (fun _ v' _ -> v' == v)
-= noop(); v
-
-let v_ref_of_array r =
-  Steel.Reference.ghost_vptrp (array__perm_ref r) (array__perm_val r)
-
-(*
-assume
-val abstract_id
-  (#t: Type)
-  (x: t)
-: Pure t
-  (requires True)
-  (ensures (fun y -> x == y))
-*)
-
-#push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false --print_implicits"
-
-#restart-solver
-let ref_of_array_ghost #inames #base #t x sq =
-  let gv = gget (varray x) in
-  elim_varray1 x;
-  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
-    #inames
-    #base
-    #(array_pcm_carrier t (len x))
-    #(array_pcm t (len x))
-    (array_as_ref #base #t x)
-    #(array_view_type t (len x))
-    #(size_v (len x) = 0)
-    (array_view' t (len x))
-  in
-  assert (len x == one_size);
-  let z : array_domain t one_size = zero_size in
-  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
-  Steel.C.Ref.gfocus
-    #base
-    #(array_pcm_carrier t (len x))
-    #(option t)
-    #_
-    #(array_pcm t (len x))
-    (array_as_ref x)
-    #(Steel.C.Opt.opt_pcm #t)
-    (array_as_one_ref_conn base t)
-    _
-    (Ghost.reveal v z);
-  Steel.C.Ref.pts_to_view_intro
-    #inames
-    #base
-    #(option t)
-    #(Steel.C.Opt.opt_pcm #t)
-    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn base t))
-    (Ghost.reveal v z)
-    #t
-    #false
-    (Steel.C.Opt.opt_view t)
-    (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
-  change_equal_slprop
-    (Steel.C.Ref.pts_to_view _ _)
-    (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
-
-#restart-solver
-val ref_of_array0 (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
-  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-             false opened Unobservable
-             (varray r)
-             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r') `star` v_ref_of_array r)
-             (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
-             (ensures fun h0 r' h1 -> True)
-
-#restart-solver
-let ref_of_array0 #base #t x sq v0 =
-  let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
-  assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
-  elim_varray1 x;
-  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
-    #_
-    #base
-    #(array_pcm_carrier t (len x))
-    #(array_pcm t (len x))
-    (array_as_ref #base #t x)
-    #(array_view_type t (len x))
-    #(size_v (len x) = 0)
-    (array_view' t (len x))
-  in
-  Steel.C.Ref.unfocus _ (array__base_ref x) (array_as_ref_conn x) _;
-  let s = get_pts_to (array__base_ref x) _ in
-  let ar : Ghost.erased (array_pcm_carrier t (array__base_len x)) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
-  array_pcm_carrier_ext t (array__base_len x) (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
-    array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
-  );
-  g_ref_of_array'_correct x;
-  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
-  Steel.C.Ref.pts_to_view_intro
-    #_
-    #base
-    #(option t)
-    #(Steel.C.Opt.opt_pcm #t)
-    r
-    (Ghost.reveal v zero_size)
-    #t
-    #false
-    (Steel.C.Opt.opt_view t)
-    (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
-  intro_vrefine
-    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
-    (fun v' -> v' == Ghost.reveal v0);
-  intro_pure (g_ref_of_array #base #t x == r);
-  return r
-
-#restart-solver
-let ref_of_array_from #base #t r_from r_to sq =
-  let x : array base t = (r_from, r_to) in
-  change_equal_slprop
-    (varray (r_from, r_to))
-    (varray x);
-  let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
-  let v0 = Ghost.hide (Seq.index (Ghost.reveal gv) 0) in
-  let r = ref_of_array0 x () v0 in
-  elim_pure (g_ref_of_array x == r);
-  elim_vrefine
-    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
-    (fun v' -> v' == Ghost.reveal v0);
-  change_equal_slprop
-    (v_ref_of_array x)
-    (v_ref_of_array (r_from, r_to));
-  return r
-
-#restart-solver
-let array_of_ref
-  #_ #base #t r' r sq
-=
-  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
-  let v = Steel.C.Ref.pts_to_view_elim
-    r
-    (Steel.C.Opt.opt_view t)
-  in
-  Steel.C.Ref.unfocus
-    r
-    (array_as_ref r')
-    (array_as_one_ref_conn base t)
-    v;
-  let g' : Ghost.erased (array_view_type t (len r')) =
-    (Ghost.hide (Seq.create 1 (Ghost.reveal g)))
-  in
-  let v' : Ghost.erased (array_pcm_carrier t (len r')) =
-    get_pts_to (array_as_ref r') _
-  in
-  array_pcm_carrier_ext t (len r') ((array_view t (len r')).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
-    assert (i == zero_size)
-  );
-  Steel.C.Ref.pts_to_view_intro
-    _
-    _
-    (array_view t (len r'))
-    g';
-  change_equal_slprop
-    (Steel.C.Ref.pts_to_view (array_as_ref r') (array_view t (len r')))
-    (varray0 r');
-  intro_varray1 r'
-
-#restart-solver
-let one_ref_as_array_conn
-  (base: Type) (t:Type0)
-: Tot (Steel.C.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
-=
-  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
-
-let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array base t) =
-  (Some ({
-    base_len = one_size;
-    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
-    from = zero_size;
-    perm_ref = perm_ref;
-  }), Ghost.hide (Some ({
-    to = one_size;
-    perm_val = Steel.FractionalPermission.full_perm;
-  })))
-
-#restart-solver
-let mk_array_of_ref'_correct
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
-: Lemma
-  (g_ref_of_array (mk_array_of_ref' r perm_ref) == r)
-=
-  g_ref_of_array'_correct (mk_array_of_ref' r perm_ref);
-  array_conn_id t one_size;
-  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
-  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
-  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
-  Steel.C.Ref.ref_focus_id r
-
-#restart-solver
-let array_as_ref_eq_base_ref
-  (#base: Type) (#t:Type0) (a: array base t)
-: Lemma
-  (requires (
-    array__base_len a == one_size /\
-    array__from a == zero_size /\
-    array__to a == one_size
-  ))
-  (ensures (
-    array_as_ref a == (array__base_ref a)
-  ))
-=
-  array_conn_id t one_size;
-  Steel.C.Ref.ref_focus_id (array__base_ref a)
-
-#restart-solver
-let array_as_ref_mk_array_of_ref'
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
-: Lemma
-  (ensures (
-    let x = mk_array_of_ref' r perm_ref in
-    array_as_ref x == (array__base_ref x)
-  ))
-=
-  let x = mk_array_of_ref' r perm_ref in
-  array_as_ref_eq_base_ref x
-
-let array_domain_one_size
-  (t: Type)
-  (i: array_domain t one_size)
-: Lemma
-  (i == zero_size)
-= ()
-
-#restart-solver
-let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
-  (g: Ghost.erased t)
-  (v: Ghost.erased (option t))
-  (v' : Ghost.erased (array_pcm_carrier t one_size))
-  (g' : Ghost.erased (array_view_type t one_size))
-: Lemma
-  (requires (
-    Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Ref.to_carrier (Ghost.reveal g) /\
-    Ghost.reveal v' == (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
-    Ghost.reveal g' == Seq.create 1 (Ghost.reveal g)
-  ))
-  (ensures (
-    (array_view t one_size).Steel.C.Ref.to_carrier g' == (Ghost.reveal v')
-  ))
-= array_pcm_carrier_ext t one_size ((array_view t one_size).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
-    ()
-  )
-
-let mk_array_of_ref_to'
-  (base: Type) (t:Type0)
-: Tot (array_or_null_to base t)
-= Some ({
-    to = one_size;
-    perm_val = Steel.FractionalPermission.full_perm;
-  })
-
-let mk_array_of_ref_from_spec
-  #base #t r from
-=
-  let a = (from, mk_array_of_ref_to' base t) in
-  array_or_null_spec a /\
-  g_is_null a == false /\
-  array__base_len a == one_size /\
-  array__from a == zero_size /\
-  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t
-
-let mk_array_of_ref_to #base #t r from = mk_array_of_ref_to' base t
-
-val mk_array_of_ref0 (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (array base t)
-             false opened Unobservable
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
-             (fun r' -> varray r')
-             (requires fun _ -> True)
-             (ensures fun h0 r' h1 ->
-               let s = h1 (varray r') in
-               Seq.length s == 1 /\
-               g_ref_of_array r' == r /\
-               r' == mk_array_of_ref' r (array__perm_ref r') /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-
-#restart-solver
-let mk_array_of_ref0
-  #base #t r
-=
-  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
-  let v : Ghost.erased (option t) = Steel.C.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
-  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
-  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
-    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
-  in
-  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
-  let perm_ref = Steel.Reference.ghost_alloc #unit () in
-  let res : array base t = (Some ({
-    base_len = one_size;
-    base_ref = r';
-    from = zero_size;
-    perm_ref = perm_ref;
-  }), Ghost.hide (Some ({
-    to = one_size;
-    perm_val = Steel.FractionalPermission.full_perm;
-  })))
-  in
-  assert (res == mk_array_of_ref' r perm_ref);
-  mk_array_of_ref'_correct r perm_ref;
-  let g' : Ghost.erased (array_view_type t one_size) =
-    Ghost.hide (Seq.create 1 (Ghost.reveal g))
-  in
-  mk_array_of_ref_view_intro base g v v' g' ;
-  Steel.C.Ref.pts_to_view_intro
-    _
-    _
-    (array_view t one_size)
-    g';
-  array_as_ref_mk_array_of_ref' r perm_ref;
-  change_equal_slprop
-    (Steel.C.Ref.pts_to_view r' (array_view t one_size))
-    (varray0 res);
-  change_equal_slprop
-    (Steel.Reference.ghost_vptr perm_ref)
-    (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
-  intro_varray1 res;
-  return res
-
-let mk_array_of_ref_from
-  #base #t r
-=
-  let a = mk_array_of_ref0 r in
-  let res = fst a in
-  change_equal_slprop
-    (varray a)
-    (varray (res, mk_array_of_ref_to r res));
-  return res
-
-#pop-options
-
 let seq_equal_1
   (t: Type)
   (s1 s2: Seq.seq t)
@@ -2016,206 +130,3 @@ let varray_or_null0_rewrite
   (_: t_of emp)
 : Tot (option (array_view_type a (len r)))
 = None
-
-[@@__steel_reduce__]
-let varray_or_null0
-  (#base #a: Type0)
-  (r: array_or_null base a)
-: Tot vprop
-= if g_is_null r
-  then emp `vrewrite` varray_or_null0_rewrite r
-  else varray r `vrewrite` Some
-
-let is_array_or_null r = hp_of (varray_or_null0 r)
-let array_or_null_sel r = sel_of (varray_or_null0 r)
-
-let intro_varray_or_null_none x =
-  intro_vrewrite emp (varray_or_null0_rewrite x);
-  change_equal_slprop
-    (emp `vrewrite` varray_or_null0_rewrite x)
-    (varray_or_null0 x);
-  change_slprop_rel
-    (varray_or_null0 x)
-    (varray_or_null x)
-    (fun u v -> u == v)
-    (fun _ -> ())
-
-let intro_varray_or_null_some x =
-  intro_vrewrite (varray x) Some;
-  change_equal_slprop
-    (varray x `vrewrite` Some)
-    (varray_or_null0 x);
-  change_slprop_rel
-    (varray_or_null0 x)
-    (varray_or_null x)
-    (fun u v -> u == v)
-    (fun _ -> ())
-
-let elim_varray_or_null_some x =
-  change_slprop_rel
-    (varray_or_null x)
-    (varray_or_null0 x)
-    (fun u v -> u == v)
-    (fun _ -> ());
-  if g_is_null x
-  then begin
-    change_equal_slprop
-      (varray_or_null0 x)
-      (emp `vrewrite` varray_or_null0_rewrite x);
-    elim_vrewrite emp (varray_or_null0_rewrite x);
-    assert False;
-    change_equal_slprop
-      emp
-      (varray x)
-  end else begin
-    change_equal_slprop
-      (varray_or_null0 x)
-      (varray x `vrewrite` Some);
-    elim_vrewrite (varray x) Some
-  end
-
-let elim_varray_or_null_none x =
-  change_slprop_rel
-    (varray_or_null x)
-    (varray_or_null0 x)
-    (fun u v -> u == v)
-    (fun _ -> ());
-  if g_is_null x
-  then begin
-    change_equal_slprop
-      (varray_or_null0 x)
-      (emp `vrewrite` varray_or_null0_rewrite x);
-    elim_vrewrite emp (varray_or_null0_rewrite x)
-  end else begin
-    change_equal_slprop
-      (varray_or_null0 x)
-      (varray x `vrewrite` Some);
-    elim_vrewrite (varray x) Some;
-    assert False;
-    change_equal_slprop
-      (varray x)
-      emp
-  end
-
-#restart-solver
-let freeable
-  #base #t a
-=
-  Steel.C.Ref.freeable (array__base_ref a) /\
-  size_v (array__base_len a) > 0 /\
-  (array__perm_val a) == Steel.FractionalPermission.full_perm /\
-  (array__from a) == zero_size /\
-  (array__to a) == (array__base_len a)
-
-#restart-solver
-let array_to_carrier_refine
-  (#t: Type0)
-  (n: size_t)
-  (v: array_view_type t n)
-: Lemma
-  (requires (size_v n > 0))
-  (ensures (p_refine (array_pcm t n) (array_to_carrier t n v)))
-= FStar.Classical.exists_intro (fun (k: array_domain t n) -> True) zero_size
-
-let malloc_to'
- (#t: Type0)
-  (x: t)
-  (n: size_t)
-  (from: array_or_null_from (array_pcm_carrier t n) t)
-: Tot (array_or_null_to (array_pcm_carrier t n) t)
-= if None? from
-  then None
-  else Some ({
-    to = n;
-    perm_val = Steel.FractionalPermission.full_perm;
-  })
-
-let malloc_from_spec
-  #t x n from
-=
-  let a = (from, malloc_to' x n from) in
-  array_or_null_spec a /\
-  (g_is_null a == false ==> freeable a)
-
-let malloc_to x n from = malloc_to' x n from
-
-val malloc0
-  (#t: Type0)
-  (x: t)
-  (n: size_t)
-: Steel (array_or_null (array_pcm_carrier t n) t)
-    emp
-    (fun r -> varray_or_null r)
-    (requires fun _ -> size_v n > 0)
-    (ensures fun _ r h' ->
-      size_v n > 0 /\
-      malloc_from_spec x n (fst r) /\
-      snd r == malloc_to x n (fst r) /\
-      (g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x)))
-    )
-
-#restart-solver
-let malloc0
-  #t x n
-=
-  let v = Seq.create (size_v n) x in
-  let c = array_to_carrier t n v in
-  array_to_carrier_refine n v;
-  let r0 = Steel.C.Ref.ref_alloc (array_pcm t n) c in
-  Steel.C.Ref.pts_to_view_intro r0 c (array_view t n) v;
-  let r = intro_varray r0 () in
-  intro_varray_or_null_some r;
-  return r
-
-let malloc_from
-  #t x n sq
-= let a = malloc0 x n in
-  let res = fst a in
-  change_equal_slprop
-    (varray_or_null a)
-    (varray_or_null (res, malloc_to x n res));
-  return res
- 
-val free0
-  (#base: Type0)
-  (#t: Type0)
-  (a: array base t)
-: Steel unit
-    (varray a)
-    (fun _ -> emp)
-    (requires (fun _ -> freeable a))
-    (ensures (fun _ _ _ -> True))
-
-#restart-solver
-#push-options "--print_implicits"
-let free0
-  #base #t a
-=
-  let r = (array__base_ref a) in
-  elim_varray r a ();
-  let v = Steel.C.Ref.pts_to_view_elim
-    #_
-    #_
-    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
-    #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
-    r
-    (array_view t (array__base_len a))
-  in
-  Steel.C.Ref.ref_free
-    #_
-    #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
-    #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
-    #v
-    r
-
-let free_from
-  #base #t a a' sq
-=
-  let a0 : array base t = (a, a') in
-  change_equal_slprop
-    (varray (a, a'))
-    (varray a0);
-  free0 a0
-
-let is_null_from a a' sq =
-  return (None? a)
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index d379e465497..1d2227358c8 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -15,7 +15,7 @@
 *)
 
 module Steel.C.Array
-include Steel.C.StdInt.Base
+include Steel.C.Array.Base
 open Steel.Memory
 open Steel.FractionalPermission
 open Steel.Effect
@@ -29,535 +29,6 @@ open Steel.C.Typenat
 
 #set-options "--ide_id_info_off"
 
-/// A library for arrays in Steel
-/// TODO: add back support for fractional permissions, or even any element view
-
-val array_pcm_carrier (t: Type u#0) (n: Ghost.erased size_t) : Type u#0
-
-val array_pcm (t: Type u#0) (n: Ghost.erased size_t) : Tot (Steel.C.PCM.pcm (array_pcm_carrier t n))
-
-// FIXME: how to produce array type t[n] as the type of some struct field?
-let array_view_type (t: Type u#0) (n: size_t)
-: Type u#0 =
-  Seq.lseq t (size_v n)
-
-/// A variant of array_view_type, which records the length of the
-/// array in Type as a Steel.C.Typenat, for extraction
-let size_t_of (n': Type u#0) = n:size_t{n' == nat_t_of_nat (size_v n)}
-let array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
-: Type u#0
-= array_view_type t n
-
-val array_view (t: Type u#0) (n: size_t)
-  : Pure (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
-    (requires (size_v n > 0))
-    (ensures (fun _ -> True))
-
-/// Abstract datatype for a Steel array of type [t]
-/// We model it as three parts:
-/// - a pure part, which represents the beginning of the array, and should extract to t*
-/// - a ghost part, which represents the end of the array, and should be erased at extraction
-/// - a refinement, because KReMLin does not support inlining of dependent pair types where one part is ghost.
-val array_or_null_from (base: Type0) (t: Type0) : Tot Type0
-[@@erasable]
-val array_or_null_to (base: Type0) (t: Type0) : Tot Type0
-val array_or_null_spec (#base: Type0) (#t: Type0) (x: (array_or_null_from base t & array_or_null_to base t)) : Tot prop
-inline_for_extraction
-let array_or_null (base: Type u#0) (t: Type u#0) : Type u#0 = (x: (array_or_null_from base t & array_or_null_to base t) { array_or_null_spec x })
-
-/// Returns the length of the array. Usable for specification and proof purposes,
-/// as modeled by the GTot effect
-val len (#base: Type) (#t: Type) (a: array_or_null base t) : GTot size_t
-let length (#base: Type) (#t: Type) (a: array_or_null base t) : GTot nat = size_v (len a)
-
-
-val null_from (base: Type u#0) (t: Type u#0) : Tot (array_or_null_from base t) 
-val null_to (base: Type u#0) (t: Type u#0) : Pure (array_or_null_to base t) (requires True) (ensures (fun r0 ->
-  array_or_null_spec (null_from base t, r0) /\
-  len (null_from base t, r0) == zero_size))
-
-val null_to_unique
-  (#base #t: Type)
-  (to: array_or_null_to base t)
-: Lemma
-  (requires (
-    array_or_null_spec (null_from base t, to)
-  ))
-  (ensures (
-    to == null_to base t
-  ))
-
-inline_for_extraction
-let null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
-= (null_from base t, null_to base t)
-val g_is_null (#base: Type) (#t: Type) (a: array_or_null base t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null base t))
-inline_for_extraction
-noextract
-let array (base: Type u#0) (t:Type u#0) : Type u#0 = (a: array_or_null base t { g_is_null a == false })
-
-val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
-: b:bool{b <==> a == one (array_pcm t n)}
-
-[@@c_struct]
-let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}): typedef = {
-  carrier = array_pcm_carrier t n;
-  pcm = array_pcm t n;
-  view_type = array_view_type_sized t n' n;
-  view = array_view t n;
-  is_unit = array_is_unit t n;
-}
-
-/// Combining the elements above to create an array vprop
-/// TODO: generalize to any view
-
-// val g_array_as_ref (#base: Type u#0) (#t: Type u#0) (a: array base t)
-//   : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
-
-// [@@ __steel_reduce__]
-// let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop
-// = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
-
-val varray_hp (#base: Type0) (#t: Type0) (x: array base t) : Tot (slprop u#1)
-
-val varray_sel (#base: Type0) (#t: Type0) (x: array base t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
-
-[@@ __steel_reduce__ ]
-let varray' (#base: Type) (#t: Type) (x: array base t) : GTot vprop' = {
-  hp = varray_hp x;
-  t = array_view_type t (len x);
-  sel = varray_sel x;
-}
-
-[@@ __steel_reduce__ ]
-let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop =
-  VUnit (varray' x)
-
-val g_mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array base t)
-: Tot prop
-
-val g_mk_array_weak
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array base t)
-: Lemma
-  (requires (g_mk_array r a))
-  (ensures (
-    size_v n > 0 /\
-    len a == Ghost.reveal n
-  ))
-  [SMTPat (g_mk_array r a)]
-
-val g_mk_array_from
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from base t)
-: Tot prop
-
-val g_mk_array_to
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from base t)
-: Pure (array_or_null_to base t)
-  (requires (g_mk_array_from r a))
-  (ensures (fun a' ->
-    let a0 = (a, a') in
-    array_or_null_spec a0 /\
-    g_is_null a0 == false /\
-    g_mk_array r a0
-  ))
-
-val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (_: squash (size_v n > 0))
-: SteelAtomicBase (al: array_or_null_from base t { g_mk_array_from r al })
-    false opened Unobservable
-    (Steel.C.Ref.pts_to_view r (array_view t n))
-    (fun al -> varray (al, g_mk_array_to r al))
-    (requires fun _ -> True)
-  (ensures (fun h al h' ->
-    let a = (al, g_mk_array_to r al) in
-    g_mk_array r a /\
-    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
-  ))
-
-inline_for_extraction
-let intro_varray (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (_: squash (size_v n > 0))
-: SteelAtomicBase (array base t)
-  false opened Unobservable
-    (Steel.C.Ref.pts_to_view r (array_view t n))
-    (fun a -> varray a)
-    (requires fun _ -> True)
-  (ensures (fun h a h' ->
-    g_mk_array r a /\
-    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
-  ))
-=
-  let al = intro_varray_from r () in
-  let a = (al, g_mk_array_to r al) in
-  change_equal_slprop
-    (varray (al, g_mk_array_to r al))
-    (varray a);
-  return a
-
-val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n)) (a: array base t) (_: squash (size_v n > 0))
-: SteelGhost unit inames
-  (varray a)
-  (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
-  (requires fun _ -> g_mk_array r a)
-  (ensures (fun h _ h' ->
-    g_mk_array r a /\
-    h (varray a) == h' (Steel.C.Ref.pts_to_view r (array_view t n))
-  ))
-
-/// Splitting an array into subarrays
-
-val adjacent
-  (#base: Type)
-  (#t: Type)
-  (r1 r2: array base t)
-: Tot prop
-
-val merge
-  (#base: Type)
-  (#t: Type)
-  (r1 r2: array base t)
-: Ghost (array base t)
-  (requires (adjacent r1 r2))
-  (ensures (fun r ->
-    length r == length r1 + length r2 /\
-    fst r == fst r1 // this property justifies array_or_null_from _ t being extracted to t*
-  ))
-
-let merge_into
-  (#base: Type)
-  (#t: Type)
-  (r1 r2 r3: array base t)
-: Tot prop
-= adjacent r1 r2 /\
-  merge r1 r2 == r3
-
-val merge_assoc
-  (#base: Type)
-  (#t: Type)
-  (r1 r2 r3: array base t)
-: Lemma
-  (requires (
-    (adjacent r1 r2 /\ (adjacent r2 r3 \/ adjacent (merge r1 r2) r3)) \/
-    (adjacent r2 r3 /\ adjacent r1 (merge r2 r3))
-  ))
-  (ensures (
-    adjacent r1 r2 /\ adjacent r2 r3 /\
-    begin
-      let r12 = merge r1 r2 in
-      let r23 = merge r2 r3 in
-      adjacent r1 r23 /\ adjacent r12 r3 /\
-      merge r1 r23 == merge r12 r3
-    end
-  ))
-  [SMTPat (merge (merge r1 r2) r3)]
-
-val merge_inj_right
-  (#base: Type)
-  (#t: Type)
-  (a b1 b2: array base t)
-: Lemma
-  (requires (adjacent a b1 /\ adjacent a b2 /\ merge a b1 == merge a b2))
-  (ensures (b1 == b2))
-
-val merge_inj_left
-  (#base: Type)
-  (#t: Type)
-  (a1 a2 b: array base t)
-: Lemma
-  (requires (adjacent a1 b /\ adjacent a2 b /\ merge a1 b == merge a2 b))
-  (ensures (a1 == a2))
-
-val no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
-  (~ (merge_into a b a))
-
-val no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
-  (~ (merge_into a b b))
-
-[@erasable]
-noeq
-type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
-
-val gsplit
-  (#base: Type)
-  (#t: Type)
-  (r: array base t)
-  (i: size_t)
-: Ghost (array base t `gpair` array base t)
-  (requires (size_v i <= length r))
-  (ensures (fun (GPair rl rr) ->
-    merge_into rl rr r /\
-    length rl == size_v i
-  ))
-
-val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
-  : SteelGhost (array base t `gpair` array base t) opened
-          (varray a)
-          (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
-          (fun _ -> size_v i <= length a)
-          (fun h res h' ->
-            let s = h (varray a) in
-            let sl = h' (varray (GPair?.fst res)) in
-            let sr = h' (varray (GPair?.snd res)) in
-            size_v i <= length a /\
-            res == gsplit a i /\
-            sl == Seq.slice s 0 (size_v i) /\
-            sr == Seq.slice s (size_v i) (length a) /\
-            s == sl `Seq.append` sr
-          )
-
-inline_for_extraction
-let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
-  (al ar: Ghost.erased (array base t))
-  : SteelAtomicBase (array base t) false opened Unobservable
-          (varray al)
-          (fun res -> varray res)
-          (fun _ ->
-            merge_into al ar a
-          )
-          (fun h res h' ->
-            res == Ghost.reveal al /\
-            h' (varray res) == h (varray al)
-          )
-= match a with
-  | (a_, _) ->
-    let res = (a_, snd al) in
-    change_equal_slprop
-      (varray al)
-      (varray res);
-    return res
-
-val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
-  : SteelAtomicBase (array_or_null_from base t) false opened Unobservable
-          (varray a)
-          (fun _ -> varray a)
-          (fun _ -> size_v i <= length a)
-          (fun h res h' ->
-            h' (varray a) == h (varray a) /\
-            size_v i <= length a /\
-            res == fst (GPair?.snd (gsplit a i))
-          )
-
-inline_for_extraction
-let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
-  : SteelAtomicBase (array base t) false opened Unobservable
-          (varray a)
-          (fun _ -> varray a)
-          (fun _ -> size_v i <= length a)
-          (fun h res h' ->
-            h' (varray a) == h (varray a) /\
-            size_v i <= length a /\
-            res == GPair?.snd (gsplit a i)
-          )
-= let from = split_right_from a i in
-  let res = (from, snd (GPair?.snd (gsplit a i))) in
-  return res
-
-inline_for_extraction
-let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a))
-  : SteelAtomicBase (array base t) false opened Unobservable
-          (varray a)
-          (fun res -> varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i))))
-          `star` varray res)
-          (fun _ -> size_v i <= length a)
-          (fun h res h' ->
-            let s = h (varray a) in
-            let sl = h' (varray (GPair?.fst (gsplit a i))) in
-            let sr = h' (varray res) in
-            size_v i <= length a /\
-            res == GPair?.snd (gsplit a i) /\
-            sl == Seq.slice s 0 (size_v i) /\
-            sr == Seq.slice s (size_v i) (length a) /\
-            s == sl `Seq.append` sr
-          )
-=
-  let sr = split_right a i in
-  let g = split' a i in
-  change_equal_slprop
-    (varray (GPair?.fst g))
-    (varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i)))));
-  change_equal_slprop
-    (varray (GPair?.snd g))
-    (varray sr);
-  return sr
-
-val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
-  : SteelGhost (Ghost.erased (array base t)) opened
-          (varray al `star` varray ar)
-          (fun a -> varray a)
-          (fun _ -> adjacent al ar)
-          (fun h a h' ->
-            let s = h' (varray a) in
-            s == (h (varray al) `Seq.append` h (varray ar)) /\
-            merge_into al ar a
-          )
-
-inline_for_extraction
-let joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
-  : SteelAtomicBase (array base t) false opened Unobservable
-          (varray al `star` varray ar)
-          (fun a -> varray al `star` varray ar)
-          (fun _ -> adjacent al ar)
-          (fun h a h' ->
-            h' (varray al) == h (varray al) /\
-            h' (varray ar) == h (varray ar) /\
-            merge_into al ar a
-          )
-= match al with
-  | (a, _) ->
-    let res = (a, snd (merge al ar)) in
-    return res
-
-inline_for_extraction
-let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
-  : SteelAtomicBase (array base t) false opened Unobservable
-          (varray al `star` varray ar)
-          (fun a -> varray a)
-          (fun _ -> adjacent al ar)
-          (fun h a h' ->
-            let s = h' (varray a) in
-            s == (h (varray al) `Seq.append` h (varray ar)) /\
-            merge_into al ar a
-          )
-=
-  let a = joinc al ar in
-  let ga = join' al ar in
-  change_equal_slprop
-    (varray ga)
-    (varray a);
-  return a
-
-/// Converting an array into a pointer, after it has been split to an array of size 1
-/// Those two functions should extract to identity functions
-
-val g_ref_of_array
-  (#base: Type) (#t:Type0) (r:array base t)
-: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (requires (length r == 1))
-  (ensures (fun _ -> True))
-
-val v_ref_of_array
-  (#base: Type) (#t:Type0) (r:array base t)
-: Ghost vprop
-  (requires (length r == 1))
-  (ensures (fun _ -> True))
-
-val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
-  : SteelGhost unit inames
-             (varray r)
-             (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
-             (requires fun _ -> True)
-             (ensures fun h0 _ h1 ->
-               let r' = g_ref_of_array r in
-               let s = h0 (varray r) in
-               Seq.length s == 1 /\
-               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-
-val ref_of_array_from (#base: Type) (#t:Type0) (#opened: _) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
-  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-    false opened Unobservable
-             (varray (r_from, r_to))
-             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
-             (requires fun _ -> True)
-             (ensures fun h0 r' h1 ->
-               let r = (r_from, r_to) in
-               let s = h0 (varray r) in
-               Seq.length s == 1 /\
-               g_ref_of_array r == r' /\
-               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-
-inline_for_extraction
-let ref_of_array (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1))
-  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-    false opened Unobservable
-             (varray r)
-             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
-             (requires fun _ -> True)
-             (ensures fun h0 r' h1 ->
-               let s = h0 (varray r) in
-               Seq.length s == 1 /\
-               g_ref_of_array r == r' /\
-               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-= match r with
-  | (r_from, r_to) ->
-    change_equal_slprop
-      (varray r)
-      (varray (r_from, r_to));
-    let res = ref_of_array_from r_from r_to () in
-    change_equal_slprop
-      (v_ref_of_array (r_from, r_to))
-      (v_ref_of_array r);
-    return res
-
-val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
-  : SteelGhost unit inames
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
-             (fun _ -> varray r')
-             (requires fun _ -> g_ref_of_array r' == r)
-             (ensures fun h0 _ h1 ->
-               let s = h1 (varray r') in
-               Seq.length s == 1 /\
-               g_ref_of_array r' == r /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-
-// this function should be used only to pass a pointer as an argument to a function that expects an array
-
-val mk_array_of_ref_from_spec
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (from: array_or_null_from base t)
-: Tot prop
-
-val mk_array_of_ref_to
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (from: array_or_null_from base t)
-: Pure (array_or_null_to base t)
-  (requires (mk_array_of_ref_from_spec r from))
-  (ensures (fun to ->
-    let r' = (from, to) in
-    array_or_null_spec r' /\
-    g_is_null r' == false
-  ))
-
-val mk_array_of_ref_from (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
-    false opened Unobservable
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
-             (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
-             (requires fun _ -> True)
-             (ensures fun h0 r0 h1 ->
-               let r' = (r0, mk_array_of_ref_to r r0) in
-               let s = h1 (varray r') in
-               Seq.length s == 1 /\
-               g_ref_of_array r' == r /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-
-inline_for_extraction
-let mk_array_of_ref (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (array base t)
-    false opened Unobservable
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
-             (fun r' -> varray r')
-             (requires fun _ -> True)
-             (ensures fun h0 r' h1 ->
-               let s = h1 (varray r') in
-               Seq.length s == 1 /\
-               g_ref_of_array r' == r /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
-             )
-= let from = mk_array_of_ref_from r in
-  let r' = (from, mk_array_of_ref_to r from) in
-  change_equal_slprop
-    (varray (from, mk_array_of_ref_to r from))
-    (varray r');
-  return r'
-
 /// Accesses index [i] in array [r], as long as [i] is in bounds and the array
 /// is currently valid in memory
 
@@ -626,194 +97,3 @@ let upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
     change_equal_slprop
       (varray (r0, r'))
       (varray r)
-
-
-val is_array_or_null (#base #a:Type0) (r:array_or_null base a) : slprop u#1
-val array_or_null_sel (#base #a:Type0) (r:array_or_null base a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
-
-[@@ __steel_reduce__]
-let varray_or_null' #base #a (r: array_or_null base a) : GTot vprop' =
-  {hp = is_array_or_null r;
-   t = option (array_view_type a (len r));
-   sel = array_or_null_sel r}
-
-[@@ __steel_reduce__]
-let varray_or_null r = VUnit (varray_or_null' r)
-
-val intro_varray_or_null_none
-  (#opened: _)
-  (#base #a: Type)
-  (x: array_or_null base a)
-: SteelGhost unit opened
-    emp
-    (fun _ -> varray_or_null x)
-    (fun _ -> g_is_null x == true)
-    (fun _ _ h' -> h' (varray_or_null x) == None)
-
-val intro_varray_or_null_some
-  (#opened: _)
-  (#base #a: Type)
-  (x: array base a)
-: SteelGhost unit opened
-    (varray x)
-    (fun _ -> varray_or_null x)
-    (fun _ -> True)
-    (fun h _ h' ->
-      g_is_null x == false /\
-      h' (varray_or_null x) == Some (h (varray x)
-    ))
-
-val elim_varray_or_null_some
-  (#opened: _)
-  (#base #a: Type)
-  (x: array_or_null base a)
-: SteelGhost (squash (g_is_null x == false)) opened
-    (varray_or_null x)
-    (fun _ -> varray x)
-    (fun h -> g_is_null x == false \/ Some? (h (varray_or_null x)))
-    (fun h _ h' ->
-      g_is_null x == false /\
-      h (varray_or_null x) == Some (h' (varray x))
-    )
-
-val elim_varray_or_null_none
-  (#opened: _)
-  (#base #a: Type)
-  (x: array_or_null base a)
-: SteelGhost unit opened
-    (varray_or_null x)
-    (fun _ -> emp)
-    (fun h -> g_is_null x == true \/ None? (h (varray_or_null x)))
-    (fun h _ _ ->
-      g_is_null x == true /\
-      h (varray_or_null x) == None
-    )
-
-/// Allocates an array of size [n] where all cells have initial value [x]
-
-val freeable
-  (#base: Type0)
-  (#t: Type0)
-  (a: array base t)
-: Tot prop
-
-val malloc_from_spec
-  (#t: Type0)
-  (x: t)
-  (n: size_t)
-  (from: array_or_null_from (array_pcm_carrier t n) t)
-: Tot prop
-
-val malloc_to
-  (#t: Type0)
-  (x: t)
-  (n: size_t)
-  (from: array_or_null_from (array_pcm_carrier t n) t)
-: Pure (array_or_null_to (array_pcm_carrier t n) t)
-    (requires (size_v n > 0 /\ malloc_from_spec x n from))
-    (ensures (fun to -> array_or_null_spec (from, to)))
-
-val malloc_from
-  (#t: Type0)
-  (x: t)
-  (n: size_t)
-  (sq: squash (size_v n > 0))
-: Steel (from: array_or_null_from (array_pcm_carrier t n) t { malloc_from_spec x n from })
-    emp
-    (fun r -> varray_or_null (r, malloc_to x n r))
-    (requires fun _ -> True)
-    (ensures fun _ r0 h' ->
-      size_v n > 0 /\
-      begin let r : array_or_null (array_pcm_carrier t n) t = (r0, malloc_to x n r0) in
-      g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
-      end
-    )
-
-inline_for_extraction
-let malloc
-  (#t: Type0)
-  (x: t)
-  (n: size_t)
-: Steel (array_or_null (array_pcm_carrier t n) t)
-    emp
-    (fun r -> varray_or_null r)
-    (requires fun _ -> size_v n > 0)
-    (ensures fun _ r h' ->
-      g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
-    )
-= let r0 = malloc_from x n () in
-  let r = (r0, malloc_to x n r0) in
-  change_equal_slprop
-    (varray_or_null (r0, malloc_to x n r0))
-    (varray_or_null r);
-  return r
-
-val free_from
-  (#base: Type0)
-  (#t: Type0)
-  (a: array_or_null_from base t)
-  (a' : array_or_null_to base t)
-  (sq: squash (array_or_null_spec (a, a') /\ g_is_null (a, a') == false))
-: Steel unit
-    (varray (a, a'))
-    (fun _ -> emp)
-    (requires (fun _ -> freeable (a,a')))
-    (ensures (fun _ _ _ -> True))
-
-inline_for_extraction
-let free
-  (#base: Type0)
-  (#t: Type0)
-  (a: array base t)
-: Steel unit
-    (varray a)
-    (fun _ -> emp)
-    (requires (fun _ -> freeable a))
-    (ensures (fun _ _ _ -> True))
-= match a with
-  | (af, a') ->
-    change_equal_slprop
-      (varray a)
-      (varray (af, a'));
-    free_from af a' ()
-
-val is_null_from
-  (#base: Type0)
-  (#t: Type0)
-  (#opened: _)
-  (a: array_or_null_from base t)
-  (a' : array_or_null_to base t)
-  (sq: squash (array_or_null_spec (a, a')))
-: SteelAtomicBase bool false opened Unobservable
-    (varray_or_null (a, a'))
-    (fun _ -> varray_or_null (a, a'))
-    (requires fun _ -> True)
-    (ensures fun h res h' ->
-      res == g_is_null (a, a') /\
-      h' (varray_or_null (a, a')) == h (varray_or_null (a, a'))
-    )
-
-inline_for_extraction
-let is_null
-  (#base: Type0)
-  (#t: Type0)
-  (#opened: _)
-  (a: array_or_null base t)
-: SteelAtomicBase bool false opened Unobservable
-    (varray_or_null a)
-    (fun _ -> varray_or_null a)
-    (requires fun _ -> True)
-    (ensures fun h res h' ->
-      res == g_is_null a /\
-      h' (varray_or_null a) == h (varray_or_null a)
-    )
-= match a with
-  | (af, a') ->
-    change_equal_slprop
-      (varray_or_null a)
-      (varray_or_null (af, a'));
-    let res = is_null_from af a' () in
-    change_equal_slprop
-      (varray_or_null (af, a'))
-      (varray_or_null a);
-    return res

From 49b166a96bdf2f0d4a6242c8f590ee876054acd5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sat, 23 Oct 2021 14:30:20 -0700
Subject: [PATCH 298/513] snap

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 25 ++++++++++----------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index e20ba2676cb..06e268d5c38 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -1524,7 +1524,7 @@ and (translate_type_without_decay :
           let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
       | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.array_view_type_sized" ->
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
           let uu___ =
             let uu___1 = translate_type_without_decay env1 t1 in
             let uu___2 =
@@ -1538,7 +1538,7 @@ and (translate_type_without_decay :
           TArray uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.array_or_null_from" ->
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
           let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
@@ -1697,11 +1697,11 @@ and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       match t with
       | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.array_view_type_sized" ->
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
           let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.array_view_type" ->
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
           let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
       | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
@@ -2251,7 +2251,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            e1::e2::uu___5::[])
           when
           (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.malloc_from") || false
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
           ->
           let uu___6 =
             let uu___7 = translate_expr env1 e1 in
@@ -2379,7 +2379,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            e2::uu___5::uu___6::[])
           when
           (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.free_from") || false
+           uu___7 = "Steel.C.Array.Base.free_from") || false
           -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -3052,7 +3052,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___5::e1::uu___6::uu___7::[])
           when
           let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.is_null_from" ->
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
           let uu___8 =
             let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
             ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
@@ -3088,7 +3088,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___2)
           when
           let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.null_from" ->
+          uu___3 = "Steel.C.Array.Base.null_from" ->
           EQualified (["LowStar"; "Buffer"], "null")
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -3309,7 +3309,8 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___6::r::uu___7::uu___8::[])
           when
           let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.ref_of_array_from" -> translate_expr env1 r
+          uu___9 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3325,7 +3326,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___6::r::[])
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.mk_array_of_ref_from" ->
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
           translate_expr env1 r
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -3342,7 +3343,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___6::uu___7::r::uu___8::[])
           when
           let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.intro_varray_from" ->
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
           let uu___9 =
             let uu___10 = translate_expr env1 r in
             (uu___10, (EConstant (UInt32, "0"))) in
@@ -3403,7 +3404,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___6::a::i::[])
           when
           let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.split_right_from" ->
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
           let uu___7 =
             let uu___8 =
               let uu___9 = translate_expr env1 a in

From d546af988f98d38284197913b987b08abefa2cea Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 7 Dec 2021 08:16:16 -0800
Subject: [PATCH 299/513] post-merge

---
 ulib/experimental/Steel.C.Ref.fst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 088aff07ec8..1a6d19446e8 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -527,6 +527,8 @@ let pts_to_view_or_null_prop_null
     (fun x y -> x == y)
     (fun _ -> ())
 
+#push-options "--z3rlimit 16"
+#restart-solver
 let pts_to_view_or_null_prop_not_null
   (#inames: _)
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
@@ -562,6 +564,7 @@ let pts_to_view_or_null_prop_not_null
     (pts_to_view_or_null r vw)
     (fun x y -> x == y)
     (fun _ -> ())
+#pop-options
 
 let pts_to_view_or_null_prop
   (#inames: _)

From 4e93f48d55ee857ae3312cf6e538e34efc2a67e5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 14 Jan 2022 12:16:23 -0800
Subject: [PATCH 300/513] "s vrefine (equals x)" as a "generic pts_to" pattern

---
 ulib/experimental/Steel.ST.Combinators.fst  | 279 ++++++++++++++++++++
 ulib/experimental/Steel.ST.Combinators.fsti | 136 ++++++++++
 2 files changed, 415 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.Combinators.fst
 create mode 100644 ulib/experimental/Steel.ST.Combinators.fsti

diff --git a/ulib/experimental/Steel.ST.Combinators.fst b/ulib/experimental/Steel.ST.Combinators.fst
new file mode 100644
index 00000000000..5f6899d6b3f
--- /dev/null
+++ b/ulib/experimental/Steel.ST.Combinators.fst
@@ -0,0 +1,279 @@
+module Steel.ST.Combinators
+include Steel.ST.Util
+module C = Steel.ST.Coercions
+module Ghost = FStar.Ghost
+module SA = Steel.Effect.Atomic
+
+#set-options "--ide_id_info_off"
+
+let vrefine_elim'
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+: SA.SteelGhostT unit inames
+    (s `vrefine` p)
+    (fun _ -> s)
+= SA.elim_vrefine s p
+
+let vrefine_elim
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+: STGhostT unit inames
+    (s `vrefine` p)
+    (fun _ -> s)
+= C.coerce_ghost (fun _ -> vrefine_elim' s p)
+
+let vrefine_equals_intro'
+  (#inames: _)
+  (s: vprop)
+: SA.SteelGhostT (Ghost.erased (t_of s)) inames
+    s
+    (fun res -> s `vrefine` equals (Ghost.reveal res))
+=
+  let res = SA.gget s in
+  SA.intro_vrefine s (equals (Ghost.reveal res));
+  res
+
+let vrefine_equals_intro
+  (#inames: _)
+  (s: vprop)
+: STGhostT (Ghost.erased (t_of s)) inames
+    s
+    (fun res -> s `vrefine` equals (Ghost.reveal res))
+=
+  C.coerce_ghost (fun _ -> vrefine_equals_intro' s)
+
+let vrefine_vrefine_equals_elim'
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+  (x: t_of s)
+: SA.SteelGhost unit
+    inames
+    (s `vrefine` p `vrefine` equals x)
+    (fun _ -> s `vrefine` equals x)
+    (fun _ -> True)
+    (fun _ _ _ -> p x)
+=
+  SA.elim_vrefine (s `vrefine` p) (equals x);
+  SA.elim_vrefine s p;
+  SA.intro_vrefine s (equals x)
+
+let vrefine_vrefine_equals_elim
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+  (x: t_of s)
+: STGhost unit
+    inames
+    (s `vrefine` p `vrefine` equals x)
+    (fun _ -> s `vrefine` equals x)
+    True
+    (fun _ -> p x)
+= C.coerce_ghost (fun _ -> vrefine_vrefine_equals_elim' s p x)
+
+let vrefine_vrefine_equals_intro'
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+  (x: t_of s)
+: SA.SteelGhost unit
+    inames
+    (s `vrefine` equals x)
+    (fun _ -> s `vrefine` p `vrefine` equals x)
+    (fun _ -> p x)
+    (fun _ _ _ -> True)
+=
+  SA.elim_vrefine s (equals x);
+  SA.intro_vrefine s p;
+  SA.intro_vrefine (s `vrefine` p) (equals x)
+
+let vrefine_vrefine_equals_intro
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+  (x: t_of s)
+: STGhost unit
+    inames
+    (s `vrefine` equals x)
+    (fun _ -> s `vrefine` p `vrefine` equals x)
+    (p x)
+    (fun _ -> True)
+= C.coerce_ghost (fun _ -> vrefine_vrefine_equals_intro' s p x)
+
+let vrefine_equals_star_intro'
+  (#inames: _)
+  (s1 s2: vprop)
+  (x1: t_of s1)
+  (x2: t_of s2)
+: SA.SteelGhostT unit
+    inames
+    ((s1 `vrefine` equals x1) `star` (s2 `vrefine` equals x2))
+    (fun _ -> (s1 `star` s2) `vrefine` equals (x1, x2))
+= SA.elim_vrefine s1 (equals x1);
+  SA.elim_vrefine s2 (equals x2);
+  SA.intro_vrefine (s1 `star` s2) (equals (x1, x2))
+
+let vrefine_equals_star_intro
+  (#inames: _)
+  (s1 s2: vprop)
+  (x1: t_of s1)
+  (x2: t_of s2)
+: STGhostT unit
+    inames
+    ((s1 `vrefine` equals x1) `star` (s2 `vrefine` equals x2))
+    (fun _ -> (s1 `star` s2) `vrefine` equals (x1, x2))
+= C.coerce_ghost (fun _ -> vrefine_equals_star_intro' s1 s2 x1 x2)
+
+let vrefine_equals_star_elim'
+  (#inames: _)
+  (s1 s2: vprop)
+  (x: t_of (s1 `star` s2))
+: SA.SteelGhostT unit
+    inames
+    ((s1 `star` s2) `vrefine` equals x)
+    (fun _ -> (s1 `vrefine` equals (fst x)) `star` (s2 `vrefine` equals (snd x)))
+=
+  SA.elim_vrefine (s1 `star` s2) (equals x);
+  SA.intro_vrefine s1 (equals (fst x));
+  SA.intro_vrefine s2 (equals (snd x))
+
+let vrefine_equals_star_elim
+  (#inames: _)
+  (s1 s2: vprop)
+  (x: t_of (s1 `star` s2))
+: STGhostT unit
+    inames
+    ((s1 `star` s2) `vrefine` equals x)
+    (fun _ -> (s1 `vrefine` equals (fst x)) `star` (s2 `vrefine` equals (snd x)))
+= C.coerce_ghost (fun _ -> vrefine_equals_star_elim' s1 s2 x)
+
+let vrewrite_vrefine_equals_intro'
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t_of s)
+: SA.SteelGhost (Ghost.erased t) inames
+    (s `vrefine` equals x)
+    (fun res -> s `vrewrite` f `vrefine` equals (Ghost.reveal res))
+    (fun _ -> True)
+    (fun _ res _ -> Ghost.reveal res == f x)
+=
+  SA.elim_vrefine s (equals x);
+  SA.intro_vrewrite s f;
+  let res : Ghost.erased t = Ghost.hide (f x) in
+  SA.intro_vrefine (s `vrewrite` f) (equals (Ghost.reveal res));
+  res
+
+let vrewrite_vrefine_equals_intro0
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t_of s)
+: STGhost (Ghost.erased t) inames
+    (s `vrefine` equals x)
+    (fun res -> s `vrewrite` f `vrefine` equals (Ghost.reveal res))
+    True
+    (fun res -> Ghost.reveal res == f x)
+= C.coerce_ghost (fun _ -> vrewrite_vrefine_equals_intro' s f x)
+
+let vrewrite_vrefine_equals_elim'
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t)
+: SA.SteelGhost (Ghost.erased (t_of s)) inames
+    (s `vrewrite` f `vrefine` equals x)
+    (fun res -> s `vrefine` equals (Ghost.reveal res))
+    (fun _ -> True)
+    (fun _ res _ -> f (Ghost.reveal res) == x)
+=
+  SA.elim_vrefine (s `vrewrite` f) (equals x);
+  SA.elim_vrewrite s f;
+  let res : Ghost.erased (t_of s) = SA.gget s in
+  SA.intro_vrefine s (equals (Ghost.reveal res));
+  res
+
+let vrewrite_vrefine_equals_elim
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t)
+: STGhost (Ghost.erased (t_of s)) inames
+    (s `vrewrite` f `vrefine` equals x)
+    (fun res -> s `vrefine` equals (Ghost.reveal res))
+    True
+    (fun res -> f (Ghost.reveal res) == x)
+= C.coerce_ghost (fun _ -> vrewrite_vrefine_equals_elim' s f x)
+
+let vdep_intro'
+  (#inames: _)
+  (vtag: vprop)
+  (vpl: (t_of vtag -> Tot vprop))
+  (tag: t_of vtag)
+  (vpl0: vprop)
+  (pl: t_of vpl0)
+: SA.SteelGhost (Ghost.erased (normal (t_of (vtag `vdep` vpl)))) inames
+    ((vtag `vrefine` equals tag) `star` (vpl0 `vrefine` equals pl))
+    (fun res -> (vtag `vdep` vpl) `vrefine` equals (Ghost.reveal res))
+    (fun _ -> vpl0 == vpl tag)
+    (fun _ res _ ->
+      vpl0 == vpl tag /\
+      dfst (Ghost.reveal res) == tag /\
+      dsnd (Ghost.reveal res) == pl
+    )
+= SA.elim_vrefine vtag (equals tag);
+  SA.elim_vrefine vpl0 (equals pl);
+  SA.intro_vdep vtag vpl0 vpl;
+  let res : Ghost.erased (normal (t_of (vtag `vdep` vpl))) = (| tag, pl |) in
+  SA.intro_vrefine (vtag `vdep` vpl) (equals (Ghost.reveal res));
+  res
+
+let vdep_intro
+  (#inames: _)
+  (vtag: vprop)
+  (vpl: (t_of vtag -> Tot vprop))
+  (tag: t_of vtag)
+  (vpl0: vprop)
+  (pl: t_of vpl0)
+: STGhost (Ghost.erased (normal (t_of (vtag `vdep` vpl)))) inames
+    ((vtag `vrefine` equals tag) `star` (vpl0 `vrefine` equals pl))
+    (fun res -> (vtag `vdep` vpl) `vrefine` equals (Ghost.reveal res))
+    (vpl0 == vpl tag)
+    (fun res ->
+      vpl0 == vpl tag /\
+      dfst (Ghost.reveal res) == tag /\
+      dsnd (Ghost.reveal res) == pl
+    )
+= C.coerce_ghost (fun _ -> vdep_intro' vtag vpl tag vpl0 pl)
+
+let vdep_elim'
+  (#inames: _)
+  (vtag: vprop)
+  (vpl: (t_of vtag -> Tot vprop))
+  (x: normal (t_of (vtag `vdep` vpl)))
+: SA.SteelGhostT unit inames
+    ((vtag `vdep` vpl) `vrefine` equals x)
+    (fun _ -> (vtag `vrefine` equals (dfst x)) `star` (vpl (dfst x) `vrefine` equals (dsnd x)))
+= SA.elim_vrefine (vtag `vdep` vpl) (equals x);
+  let tag = SA.elim_vdep vtag vpl in
+  SA.intro_vrefine vtag (equals (dfst x));
+  SA.change_equal_slprop
+    (vpl tag)
+    (vpl (dfst x));
+  SA.intro_vrefine (vpl (dfst x)) (equals (dsnd x))
+
+let vdep_elim
+  (#inames: _)
+  (vtag: vprop)
+  (vpl: (t_of vtag -> Tot vprop))
+  (x: normal (t_of (vtag `vdep` vpl)))
+: STGhostT unit inames
+    ((vtag `vdep` vpl) `vrefine` equals x)
+    (fun _ -> (vtag `vrefine` equals (dfst x)) `star` (vpl (dfst x) `vrefine` equals (dsnd x)))
+= C.coerce_ghost (fun _ -> vdep_elim' vtag vpl x)
diff --git a/ulib/experimental/Steel.ST.Combinators.fsti b/ulib/experimental/Steel.ST.Combinators.fsti
new file mode 100644
index 00000000000..c108ea2b196
--- /dev/null
+++ b/ulib/experimental/Steel.ST.Combinators.fsti
@@ -0,0 +1,136 @@
+module Steel.ST.Combinators
+include Steel.ST.Util
+module Ghost = FStar.Ghost
+
+#set-options "--ide_id_info_off"
+
+(* This module is basically saying that, for any vprop s, there is a
+   generic way to derive its "explicit pts_to" version, namely "s
+   `vrefine` equals x".  Thus, we offer vprop combinators and
+   corresponding rules based on that pattern, all of which we claim
+   can eliminate the need for selector predicates in practice.  *)
+
+let equals (#a: Type) (x: a) (y: a) : Tot prop =
+  x == y
+
+val vrefine_elim
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+: STGhostT unit inames
+    (s `vrefine` p)
+    (fun _ -> s)
+
+val vrefine_equals_intro
+  (#inames: _)
+  (s: vprop)
+: STGhostT (Ghost.erased (t_of s)) inames
+    s
+    (fun res -> s `vrefine` equals (Ghost.reveal res))
+
+val vrefine_vrefine_equals_elim
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+  (x: t_of s)
+: STGhost unit
+    inames
+    (s `vrefine` p `vrefine` equals x)
+    (fun _ -> s `vrefine` equals x)
+    True
+    (fun _ -> p x)
+
+val vrefine_vrefine_equals_intro
+  (#inames: _)
+  (s: vprop)
+  (p: t_of s -> Tot prop)
+  (x: t_of s)
+: STGhost unit
+    inames
+    (s `vrefine` equals x)
+    (fun _ -> s `vrefine` p `vrefine` equals x)
+    (p x)
+    (fun _ -> True)
+
+val vrefine_equals_star_intro
+  (#inames: _)
+  (s1 s2: vprop)
+  (x1: t_of s1)
+  (x2: t_of s2)
+: STGhostT unit
+    inames
+    ((s1 `vrefine` equals x1) `star` (s2 `vrefine` equals x2))
+    (fun _ -> (s1 `star` s2) `vrefine` equals (x1, x2))
+
+val vrefine_equals_star_elim
+  (#inames: _)
+  (s1 s2: vprop)
+  (x: t_of (s1 `star` s2))
+: STGhostT unit
+    inames
+    ((s1 `star` s2) `vrefine` equals x)
+    (fun _ -> (s1 `vrefine` equals (fst x)) `star` (s2 `vrefine` equals (snd x)))
+
+val vrewrite_vrefine_equals_intro0
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t_of s)
+: STGhost (Ghost.erased t) inames
+    (s `vrefine` equals x)
+    (fun res -> s `vrewrite` f `vrefine` equals (Ghost.reveal res))
+    True
+    (fun res -> Ghost.reveal res == f x)
+
+let vrewrite_vrefine_equals_intro
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t_of s)
+: STGhostT unit inames
+    (s `vrefine` equals x)
+    (fun res -> s `vrewrite` f `vrefine` equals (f x))
+= let res = vrewrite_vrefine_equals_intro0 s f x in
+  rewrite
+    (s `vrewrite` f `vrefine` equals (Ghost.reveal res))
+    (s `vrewrite` f `vrefine` equals (f x))
+
+val vrewrite_vrefine_equals_elim
+  (#inames: _)
+  (#t: Type)
+  (s: vprop)
+  (f: t_of s -> GTot t)
+  (x: t)
+: STGhost (Ghost.erased (t_of s)) inames
+    (s `vrewrite` f `vrefine` equals x)
+    (fun res -> s `vrefine` equals (Ghost.reveal res))
+    True
+    (fun res -> f (Ghost.reveal res) == x)
+
+val vdep_intro
+  (#inames: _)
+  (vtag: vprop)
+  (vpl: (t_of vtag -> Tot vprop))
+  (tag: t_of vtag)
+  (vpl0: vprop)
+  (pl: t_of vpl0)
+: STGhost (Ghost.erased (normal (t_of (vtag `vdep` vpl)))) inames
+    ((vtag `vrefine` equals tag) `star` (vpl0 `vrefine` equals pl))
+    (fun res -> (vtag `vdep` vpl) `vrefine` equals (Ghost.reveal res))
+    (vpl0 == vpl tag)
+    (fun res ->
+      vpl0 == vpl tag /\
+      dfst (Ghost.reveal res) == tag /\
+      dsnd (Ghost.reveal res) == pl
+    )
+
+val vdep_elim
+  (#inames: _)
+  (vtag: vprop)
+  (vpl: (t_of vtag -> Tot vprop))
+  (x: normal (t_of (vtag `vdep` vpl)))
+: STGhostT unit inames
+    ((vtag `vdep` vpl) `vrefine` equals x)
+    (fun _ -> (vtag `vrefine` equals (dfst x)) `star` (vpl (dfst x) `vrefine` equals (dsnd x)))

From b59399acfd4ab14a4f6203942f06d21089a5d562 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 14 Jan 2022 16:46:34 -0800
Subject: [PATCH 301/513] pts_to ~ vptr `vrefine` equals

---
 ulib/experimental/Steel.ST.Reference.fst  | 48 +++++++++++++++++++++++
 ulib/experimental/Steel.ST.Reference.fsti | 31 +++++++++++++++
 2 files changed, 79 insertions(+)

diff --git a/ulib/experimental/Steel.ST.Reference.fst b/ulib/experimental/Steel.ST.Reference.fst
index affb5836110..b5fd3ab7eff 100644
--- a/ulib/experimental/Steel.ST.Reference.fst
+++ b/ulib/experimental/Steel.ST.Reference.fst
@@ -130,3 +130,51 @@ let cas (#t:eqtype)
       (pts_to r full_perm v)
       (fun b -> if b then pts_to r full_perm v_new else pts_to r full_perm v)
   = coerce_atomic (fun _ -> R.cas_pt #t #uses r v v_old v_new)
+
+let ptrp r p = R.ptrp r p
+let ptrp_sel r p = R.ptrp_sel r p
+
+module SA = Steel.Effect.Atomic
+
+let vptrp_intro'
+  (#inames: _)
+  (#a: Type) (r: ref a) (p: perm) (v: a)
+: SA.SteelGhostT unit inames
+    (pts_to r p v)
+    (fun _ -> vptrp r p `vrefine` C.equals v)
+=
+  R.intro_vptr r p v;
+  SA.change_slprop
+    (R.vptrp r p)
+    (vptrp r p)
+    v
+    v
+    (fun _ -> ());
+  SA.intro_vrefine (vptrp r p) (C.equals v)
+
+let vptrp_intro r p v =
+  coerce_ghost (fun _ -> vptrp_intro' r p v)
+
+let vptrp_elim'
+  (#inames: _)
+  (#a: Type) (r: ref a) (p: perm) (v: a)
+: SA.SteelGhostT unit inames
+    (vptrp r p `vrefine` C.equals v)
+    (fun _ -> pts_to r p v)
+=
+  SA.elim_vrefine (vptrp r p) (C.equals v);
+  SA.change_slprop
+    (vptrp r p)
+    (R.vptrp r p)
+    v
+    v
+    (fun _ -> ());
+  let v' = R.elim_vptr r p in
+  SA.change_slprop_rel
+    (R.pts_to r p v')
+    (R.pts_to r p v)
+    (fun _ _ -> True)
+    (fun _ -> ())
+
+let vptrp_elim r p v =
+  coerce_ghost (fun _ -> vptrp_elim' r p v)
diff --git a/ulib/experimental/Steel.ST.Reference.fsti b/ulib/experimental/Steel.ST.Reference.fsti
index 8dc08b2b6a5..e739c48f073 100644
--- a/ulib/experimental/Steel.ST.Reference.fsti
+++ b/ulib/experimental/Steel.ST.Reference.fsti
@@ -155,3 +155,34 @@ val cas (#t:eqtype)
       uses
       (pts_to r full_perm v)
       (fun b -> if b then pts_to r full_perm v_new else pts_to r full_perm v)
+
+// A reinterpretation of pts_to with selectors
+
+module C = Steel.ST.Combinators
+
+val ptrp (#a:Type0) (r:ref a) ([@@@smt_fallback] p: perm) : slprop u#1
+val ptrp_sel (#a:Type0) (r:ref a) (p: perm) : selector a (ptrp r p)
+
+[@@ __steel_reduce__]
+let vptr' #a r p : vprop' =
+  {hp = ptrp r p;
+   t = a;
+   sel = ptrp_sel r p}
+
+[@@ __steel_reduce__]
+unfold
+let vptrp (#a: Type) (r: ref a) ([@@@smt_fallback] p: perm) = VUnit (vptr' r p)
+
+val vptrp_intro
+  (#inames: _)
+  (#a: Type) (r: ref a) (p: perm) (v: a)
+: STGhostT unit inames
+    (pts_to r p v)
+    (fun _ -> vptrp r p `vrefine` C.equals v)
+
+val vptrp_elim
+  (#inames: _)
+  (#a: Type) (r: ref a) (p: perm) (v: a)
+: STGhostT unit inames
+    (vptrp r p `vrefine` C.equals v)
+    (fun _ -> pts_to r p v)

From 24e4b987f5e8252c89ea1cb54d72e00630e96fcd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 16 Jan 2022 10:36:01 -0800
Subject: [PATCH 302/513] vrefine_equals_injective

---
 ulib/experimental/Steel.ST.Combinators.fst  | 13 +++++++++++++
 ulib/experimental/Steel.ST.Combinators.fsti | 11 +++++++++++
 2 files changed, 24 insertions(+)

diff --git a/ulib/experimental/Steel.ST.Combinators.fst b/ulib/experimental/Steel.ST.Combinators.fst
index 5f6899d6b3f..bcc79da4ee5 100644
--- a/ulib/experimental/Steel.ST.Combinators.fst
+++ b/ulib/experimental/Steel.ST.Combinators.fst
@@ -277,3 +277,16 @@ let vdep_elim
     ((vtag `vdep` vpl) `vrefine` equals x)
     (fun _ -> (vtag `vrefine` equals (dfst x)) `star` (vpl (dfst x) `vrefine` equals (dsnd x)))
 = C.coerce_ghost (fun _ -> vdep_elim' vtag vpl x)
+
+let vrefine_equals_injective
+  (v: vprop)
+  (x1 x2: t_of v)
+  (m: mem)
+: Lemma
+  (requires (
+    interp (hp_of (v `vrefine` equals x1)) m /\
+    interp (hp_of (v `vrefine` equals x2)) m
+  ))
+  (ensures (x1 == x2))
+= interp_vrefine_hp v (equals x1) m;
+  interp_vrefine_hp v (equals x2) m
diff --git a/ulib/experimental/Steel.ST.Combinators.fsti b/ulib/experimental/Steel.ST.Combinators.fsti
index c108ea2b196..693fbb6e955 100644
--- a/ulib/experimental/Steel.ST.Combinators.fsti
+++ b/ulib/experimental/Steel.ST.Combinators.fsti
@@ -134,3 +134,14 @@ val vdep_elim
 : STGhostT unit inames
     ((vtag `vdep` vpl) `vrefine` equals x)
     (fun _ -> (vtag `vrefine` equals (dfst x)) `star` (vpl (dfst x) `vrefine` equals (dsnd x)))
+
+val vrefine_equals_injective
+  (v: vprop)
+  (x1 x2: t_of v)
+  (m: mem)
+: Lemma
+  (requires (
+    interp (hp_of (v `vrefine` equals x1)) m /\
+    interp (hp_of (v `vrefine` equals x2)) m
+  ))
+  (ensures (x1 == x2))

From 0f806f54ad485d337c33e9c29acdfcd2b6d6fded Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 29 Mar 2022 10:03:50 -0700
Subject: [PATCH 303/513] reset src/ocaml-output/FStar_Extraction_Kremlin.ml

---
 src/ocaml-output/FStar_Extraction_Kremlin.ml | 3607 +++++++-----------
 1 file changed, 1484 insertions(+), 2123 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Kremlin.ml b/src/ocaml-output/FStar_Extraction_Kremlin.ml
index 06e268d5c38..401caff0d1b 100644
--- a/src/ocaml-output/FStar_Extraction_Kremlin.ml
+++ b/src/ocaml-output/FStar_Extraction_Kremlin.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type program = decl Prims.list
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -881,27 +765,7 @@ let (list_elements :
       | uu___ ->
           failwith "Argument of FStar.Buffer.createL is not a list literal!" in
     list_elements1 [] e2
-let rec (translate_module :
-  (FStar_Extraction_ML_Syntax.mlpath * (FStar_Extraction_ML_Syntax.mlsig *
-    FStar_Extraction_ML_Syntax.mlmodule) FStar_Pervasives_Native.option *
-    FStar_Extraction_ML_Syntax.mllib) -> file)
-  =
-  fun m ->
-    let uu___ = m in
-    match uu___ with
-    | (module_name, modul, uu___1) ->
-        let module_name1 =
-          FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst module_name)
-            [FStar_Pervasives_Native.snd module_name] in
-        let program1 =
-          match modul with
-          | FStar_Pervasives_Native.Some (_signature, decls) ->
-              FStar_Compiler_List.collect
-                (translate_decl (empty module_name1)) decls
-          | uu___2 ->
-              failwith "Unexpected standalone interface or nested modules" in
-        ((FStar_String.concat "_" module_name1), program1)
-and (translate_flags :
+let (translate_flags :
   FStar_Extraction_ML_Syntax.meta Prims.list -> flag Prims.list) =
   fun flags ->
     FStar_Compiler_List.choose
@@ -936,7 +800,7 @@ and (translate_flags :
          | FStar_Extraction_ML_Syntax.Deprecated s ->
              FStar_Pervasives_Native.Some (Deprecated s)
          | uu___1 -> FStar_Pervasives_Native.None) flags
-and (translate_cc :
+let (translate_cc :
   FStar_Extraction_ML_Syntax.meta Prims.list ->
     cc FStar_Pervasives_Native.option)
   =
@@ -953,769 +817,195 @@ and (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-and (translate_decl :
-  env -> FStar_Extraction_ML_Syntax.mlmodule1 -> decl Prims.list) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
-    fun d ->
-      match d with
-      | FStar_Extraction_ML_Syntax.MLM_Let (flavor, lbs) ->
-          FStar_Compiler_List.choose (translate_let env1 flavor) lbs
-      | FStar_Extraction_ML_Syntax.MLM_Loc uu___ -> []
-      | FStar_Extraction_ML_Syntax.MLM_Ty tys ->
-          FStar_Compiler_List.choose (translate_type_decl env1) tys
-      | FStar_Extraction_ML_Syntax.MLM_Top uu___ ->
-          failwith "todo: translate_decl [MLM_Top]"
-      | FStar_Extraction_ML_Syntax.MLM_Exn (m, uu___) ->
-          (FStar_Compiler_Util.print1_warning
-             "Not extracting exception %s to KreMLin (exceptions unsupported)\n"
-             m;
-           [])
-and (translate_let :
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Tuple [] -> TAny
+      | FStar_Extraction_ML_Syntax.MLTY_Top -> TAny
+      | FStar_Extraction_ML_Syntax.MLTY_Var name1 ->
+          let uu___ = find_t env1 name1 in TBound uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
+          let uu___1 =
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+          TArrow uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Prims.unit" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Prims.bool" -> TBool
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], ("FStar"::m::[], "t"))
+          when is_machine_int m ->
+          let uu___ = FStar_Compiler_Util.must (mk_width m) in TInt uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], ("FStar"::m::[], "t'"))
+          when is_machine_int m ->
+          let uu___ = FStar_Compiler_Util.must (mk_width m) in TInt uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
+          when
+          (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___2 = "FStar.Monotonic.HyperStack.s_mref") ||
+              (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___2 = "FStar.Monotonic.HyperHeap.mrref"))
+             ||
+             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___2 = "FStar.HyperStack.ST.m_rref"))
+            ||
+            (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___2 = "FStar.HyperStack.ST.s_mref")
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          ((((((((((let uu___1 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                    uu___1 = "FStar.Monotonic.HyperStack.mreference") ||
+                     (let uu___1 =
+                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                      uu___1 = "FStar.Monotonic.HyperStack.mstackref"))
+                    ||
+                    (let uu___1 =
+                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                     uu___1 = "FStar.Monotonic.HyperStack.mref"))
+                   ||
+                   (let uu___1 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                    uu___1 = "FStar.Monotonic.HyperStack.mmmstackref"))
+                  ||
+                  (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                   uu___1 = "FStar.Monotonic.HyperStack.mmmref"))
+                 ||
+                 (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                  uu___1 = "FStar.Monotonic.Heap.mref"))
+                ||
+                (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "FStar.HyperStack.ST.mreference"))
+               ||
+               (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___1 = "FStar.HyperStack.ST.mstackref"))
+              ||
+              (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___1 = "FStar.HyperStack.ST.mref"))
+             ||
+             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___1 = "FStar.HyperStack.ST.mmmstackref"))
+            ||
+            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___1 = "FStar.HyperStack.ST.mmmref")
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
+          let uu___2 = translate_type env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "LowStar.ConstBuffer.const_buffer" ->
+          let uu___ = translate_type env1 arg in TConstBuf uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          (((((((((((((((((let uu___ =
+                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                           uu___ = "FStar.Buffer.buffer") ||
+                            (let uu___ =
+                               FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                             uu___ = "LowStar.Buffer.buffer"))
+                           ||
+                           (let uu___ =
+                              FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                            uu___ = "LowStar.ImmutableBuffer.ibuffer"))
+                          ||
+                          (let uu___ =
+                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                           uu___ = "LowStar.UninitializedBuffer.ubuffer"))
+                         ||
+                         (let uu___ =
+                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                          uu___ = "FStar.HyperStack.reference"))
+                        ||
+                        (let uu___ =
+                           FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                         uu___ = "FStar.HyperStack.stackref"))
+                       ||
+                       (let uu___ =
+                          FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                        uu___ = "FStar.HyperStack.ref"))
+                      ||
+                      (let uu___ =
+                         FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                       uu___ = "FStar.HyperStack.mmstackref"))
+                     ||
+                     (let uu___ =
+                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                      uu___ = "FStar.HyperStack.mmref"))
+                    ||
+                    (let uu___ =
+                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                     uu___ = "FStar.HyperStack.ST.reference"))
+                   ||
+                   (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                    uu___ = "FStar.HyperStack.ST.stackref"))
+                  ||
+                  (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                   uu___ = "FStar.HyperStack.ST.ref"))
+                 ||
+                 (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                  uu___ = "FStar.HyperStack.ST.mmstackref"))
+                ||
+                (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___ = "FStar.HyperStack.ST.mmref"))
+               ||
+               (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___ = "Steel.Reference.ref"))
+              ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.Array.array"))
+             ||
+             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___ = "Steel.ST.Reference.ref"))
+            ||
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.ST.Array.array")
+          -> let uu___ = translate_type env1 arg in TBuf uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___1 = "FStar.HyperStack.s_ref") ||
+            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___1 = "FStar.HyperStack.ST.s_ref")
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "FStar.Ghost.erased" -> TAny
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], (path, type_name)) ->
+          TQualified (path, type_name)
+      | FStar_Extraction_ML_Syntax.MLTY_Named (args, (ns, t1)) when
+          ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
+            (FStar_Compiler_Util.starts_with t1 "tuple")
+          ->
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          TTuple uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
+          if (FStar_Compiler_List.length args) > Prims.int_zero
+          then
+            let uu___ =
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              (lid, uu___1) in
+            TApp uu___
+          else TQualified lid
+      | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          TTuple uu___
+and (translate_binders :
   env ->
-    FStar_Extraction_ML_Syntax.mlletflavor ->
-      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun flavor ->
-      fun lb ->
-        match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some
-              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
-               ((FStar_Extraction_ML_Syntax.MLTY_Named
-                ([], view_type_name))::[], p));
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-            FStar_Extraction_ML_Syntax.mllb_def = fields;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
-            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
-            ((let uu___6 =
-                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
-              FStar_Compiler_Util.print1
-                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
-             (let rec parse_fields fields1 =
-                match fields1 with
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_Name p1;
-                    FStar_Extraction_ML_Syntax.mlty = uu___6;
-                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
-                    let uu___8 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
-                    FStar_Compiler_Util.print_endline "End of fields"
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_App
-                      ({
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Name p1;
-                         FStar_Extraction_ML_Syntax.mlty = uu___6;
-                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                       {
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Const
-                           (FStar_Extraction_ML_Syntax.MLC_String name1);
-                         FStar_Extraction_ML_Syntax.mlty = uu___8;
-                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
-                    FStar_Extraction_ML_Syntax.mlty = uu___10;
-                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
-                    let uu___12 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
-                    ((let uu___13 =
-                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
-                          typedef in
-                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
-                        uu___13);
-                     parse_fields fields2)
-                | uu___6 ->
-                    failwith "Couldn't parse fields from struct_fields" in
-              parse_fields fields; FStar_Pervasives_Native.None))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t0);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def = e;
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___1;_} when
-            FStar_Compiler_Util.for_some
-              (fun uu___2 ->
-                 match uu___2 with
-                 | FStar_Extraction_ML_Syntax.Assumed -> true
-                 | uu___3 -> false) meta
-            ->
-            let name2 = ((env1.module_name), name1) in
-            let arg_names =
-              match e.FStar_Extraction_ML_Syntax.expr with
-              | FStar_Extraction_ML_Syntax.MLE_Fun (args, uu___2) ->
-                  FStar_Compiler_List.map FStar_Pervasives_Native.fst args
-              | uu___2 -> [] in
-            if (FStar_Compiler_List.length tvars) = Prims.int_zero
-            then
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = translate_cc meta in
-                  let uu___5 = translate_flags meta in
-                  let uu___6 = translate_type env1 t0 in
-                  (uu___4, uu___5, name2, uu___6, arg_names) in
-                DExternal uu___3 in
-              FStar_Pervasives_Native.Some uu___2
-            else
-              ((let uu___4 =
-                  FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                FStar_Compiler_Util.print1_warning
-                  "Not extracting %s to KreMLin (polymorphic assumes are not supported)\n"
-                  uu___4);
-               FStar_Pervasives_Native.None)
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t0);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def =
-              {
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Fun (args, body);
-                FStar_Extraction_ML_Syntax.mlty = uu___1;
-                FStar_Extraction_ML_Syntax.loc = uu___2;_};
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___3;_} ->
-            if
-              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-                meta
-            then FStar_Pervasives_Native.None
-            else
-              (let env2 =
-                 if flavor = FStar_Extraction_ML_Syntax.Rec
-                 then extend env1 name1
-                 else env1 in
-               let env3 =
-                 FStar_Compiler_List.fold_left
-                   (fun env4 -> fun name2 -> extend_t env4 name2) env2 tvars in
-               let rec find_return_type eff i uu___5 =
-                 match uu___5 with
-                 | FStar_Extraction_ML_Syntax.MLTY_Fun (uu___6, eff1, t) when
-                     i > Prims.int_zero ->
-                     find_return_type eff1 (i - Prims.int_one) t
-                 | t -> (i, eff, t) in
-               let name2 = ((env3.module_name), name1) in
-               let uu___5 =
-                 find_return_type FStar_Extraction_ML_Syntax.E_PURE
-                   (FStar_Compiler_List.length args) t0 in
-               match uu___5 with
-               | (i, eff, t) ->
-                   (if i > Prims.int_zero
-                    then
-                      (let msg =
-                         "function type annotation has less arrows than the number of arguments; please mark the return type abbreviation as inline_for_extraction" in
-                       let uu___7 =
-                         FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                       FStar_Compiler_Util.print2_warning
-                         "Not extracting %s to KreMLin (%s)\n" uu___7 msg)
-                    else ();
-                    (let t1 = translate_type env3 t in
-                     let binders = translate_binders env3 args in
-                     let env4 = add_binders env3 args in
-                     let cc1 = translate_cc meta in
-                     let meta1 =
-                       match (eff, t1) with
-                       | (FStar_Extraction_ML_Syntax.E_ERASABLE, uu___7) ->
-                           let uu___8 = translate_flags meta in MustDisappear
-                             :: uu___8
-                       | (FStar_Extraction_ML_Syntax.E_PURE, TUnit) ->
-                           let uu___7 = translate_flags meta in MustDisappear
-                             :: uu___7
-                       | uu___7 -> translate_flags meta in
-                     try
-                       (fun uu___7 ->
-                          match () with
-                          | () ->
-                              let body1 = translate_expr env4 body in
-                              FStar_Pervasives_Native.Some
-                                (DFunction
-                                   (cc1, meta1,
-                                     (FStar_Compiler_List.length tvars), t1,
-                                     name2, binders, body1))) ()
-                     with
-                     | e ->
-                         let msg = FStar_Compiler_Util.print_exn e in
-                         ((let uu___9 =
-                             let uu___10 =
-                               let uu___11 =
-                                 FStar_Extraction_ML_Syntax.string_of_mlpath
-                                   name2 in
-                               FStar_Compiler_Util.format2
-                                 "Error while extracting %s to KreMLin (%s)\n"
-                                 uu___11 msg in
-                             (FStar_Errors.Warning_FunctionNotExtacted,
-                               uu___10) in
-                           FStar_Errors.log_issue
-                             FStar_Compiler_Range.dummyRange uu___9);
-                          (let msg1 =
-                             Prims.op_Hat
-                               "This function was not extracted:\n" msg in
-                           FStar_Pervasives_Native.Some
-                             (DFunction
-                                (cc1, meta1,
-                                  (FStar_Compiler_List.length tvars), t1,
-                                  name2, binders, (EAbortS msg1))))))))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def = expr1;
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___1;_} ->
-            if
-              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-                meta
-            then FStar_Pervasives_Native.None
-            else
-              (let meta1 = translate_flags meta in
-               let env2 =
-                 FStar_Compiler_List.fold_left
-                   (fun env3 -> fun name2 -> extend_t env3 name2) env1 tvars in
-               let t1 = translate_type env2 t in
-               let name2 = ((env2.module_name), name1) in
-               try
-                 (fun uu___3 ->
-                    match () with
-                    | () ->
-                        let expr2 = translate_expr env2 expr1 in
-                        FStar_Pervasives_Native.Some
-                          (DGlobal
-                             (meta1, name2,
-                               (FStar_Compiler_List.length tvars), t1, expr2)))
-                   ()
-               with
-               | e ->
-                   ((let uu___5 =
-                       let uu___6 =
-                         let uu___7 =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                         let uu___8 = FStar_Compiler_Util.print_exn e in
-                         FStar_Compiler_Util.format2
-                           "Error extracting %s to KreMLin (%s)\n" uu___7
-                           uu___8 in
-                       (FStar_Errors.Warning_DefinitionNotTranslated, uu___6) in
-                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                       uu___5);
-                    FStar_Pervasives_Native.Some
-                      (DGlobal
-                         (meta1, name2, (FStar_Compiler_List.length tvars),
-                           t1, EAny))))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc = ts;
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def = uu___1;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___2;
-            FStar_Extraction_ML_Syntax.print_typ = uu___3;_} ->
-            ((let uu___5 =
-                let uu___6 =
-                  FStar_Compiler_Util.format1
-                    "Not extracting %s to KreMLin\n" name1 in
-                (FStar_Errors.Warning_DefinitionNotTranslated, uu___6) in
-              FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___5);
-             (match ts with
-              | FStar_Pervasives_Native.Some (idents, t) ->
-                  let uu___6 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") t in
-                  FStar_Compiler_Util.print2
-                    "Type scheme is: forall %s. %s\n"
-                    (FStar_String.concat ", " idents) uu___6
-              | FStar_Pervasives_Native.None -> ());
-             FStar_Pervasives_Native.None)
-and (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KreMLin (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KreMLin\n" name1 in
-                 (FStar_Errors.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
-and (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple [] -> TAny
-      | FStar_Extraction_ML_Syntax.MLTY_Top -> TAny
-      | FStar_Extraction_ML_Syntax.MLTY_Var name1 ->
-          let uu___ = find_t env1 name1 in TBound uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
-          let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
-          TArrow uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Prims.unit" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Prims.bool" -> TBool
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], ("FStar"::m::[], "t"))
-          when is_machine_int m ->
-          let uu___ = FStar_Compiler_Util.must (mk_width m) in TInt uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], ("FStar"::m::[], "t'"))
-          when is_machine_int m ->
-          let uu___ = FStar_Compiler_Util.must (mk_width m) in TInt uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
-          when
-          (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___2 = "FStar.Monotonic.HyperStack.s_mref") ||
-              (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___2 = "FStar.Monotonic.HyperHeap.mrref"))
-             ||
-             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___2 = "FStar.HyperStack.ST.m_rref"))
-            ||
-            (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          ((((((((((let uu___1 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___1 = "FStar.Monotonic.HyperStack.mreference") ||
-                     (let uu___1 =
-                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                      uu___1 = "FStar.Monotonic.HyperStack.mstackref"))
-                    ||
-                    (let uu___1 =
-                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                     uu___1 = "FStar.Monotonic.HyperStack.mref"))
-                   ||
-                   (let uu___1 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___1 = "FStar.Monotonic.HyperStack.mmmstackref"))
-                  ||
-                  (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                   uu___1 = "FStar.Monotonic.HyperStack.mmmref"))
-                 ||
-                 (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                  uu___1 = "FStar.Monotonic.Heap.mref"))
-                ||
-                (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "FStar.HyperStack.ST.mreference"))
-               ||
-               (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___1 = "FStar.HyperStack.ST.mstackref"))
-              ||
-              (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___1 = "FStar.HyperStack.ST.mref"))
-             ||
-             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___1 = "FStar.HyperStack.ST.mmmstackref"))
-            ||
-            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          (((((((((((((((let uu___ =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                         uu___ = "FStar.Buffer.buffer") ||
-                          (let uu___ =
-                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                           uu___ = "LowStar.Buffer.buffer"))
-                         ||
-                         (let uu___ =
-                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                          uu___ = "LowStar.ImmutableBuffer.ibuffer"))
-                        ||
-                        (let uu___ =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                         uu___ = "LowStar.UninitializedBuffer.ubuffer"))
-                       ||
-                       (let uu___ =
-                          FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                        uu___ = "FStar.HyperStack.reference"))
-                      ||
-                      (let uu___ =
-                         FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                       uu___ = "FStar.HyperStack.stackref"))
-                     ||
-                     (let uu___ =
-                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                      uu___ = "FStar.HyperStack.ref"))
-                    ||
-                    (let uu___ =
-                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                     uu___ = "FStar.HyperStack.mmstackref"))
-                   ||
-                   (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___ = "FStar.HyperStack.mmref"))
-                  ||
-                  (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                   uu___ = "FStar.HyperStack.ST.reference"))
-                 ||
-                 (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                  uu___ = "FStar.HyperStack.ST.stackref"))
-                ||
-                (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___ = "FStar.HyperStack.ST.ref"))
-               ||
-               (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___ = "FStar.HyperStack.ST.mmstackref"))
-              ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "FStar.HyperStack.ST.mmref"))
-             ||
-             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___ = "Steel.Reference.ref"))
-            ||
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.Array.array")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___1 = "FStar.HyperStack.s_ref") ||
-            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "FStar.Ghost.erased" -> TAny
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], (path, type_name)) ->
-          TQualified (path, type_name)
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, (ns, t1)) when
-          ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
-            (FStar_Compiler_Util.starts_with t1 "tuple")
-          ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
-          TTuple uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
-          if (FStar_Compiler_List.length args) > Prims.int_zero
-          then
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
-              (lid, uu___1) in
-            TApp uu___
-          else TQualified lid
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
-          TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
-and (translate_binders :
-  env ->
-    (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
-      Prims.list -> binder Prims.list)
+    (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
+      binder Prims.list)
   =
   fun env1 ->
     fun args -> FStar_Compiler_List.map (translate_binder env1) args
 and (translate_binder :
-  env ->
-    (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty) ->
-      binder)
-  =
+  env -> (Prims.string * FStar_Extraction_ML_Syntax.mlty) -> binder) =
   fun env1 ->
     fun uu___ ->
       match uu___ with
@@ -1767,248 +1057,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___1 = translate_expr env1 expr1 in
             let uu___2 = translate_branches env1 branches1 in
             (uu___1, uu___2) in
-          EMatch uu___
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           arg::[])
-          when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "FStar.Dyn.undyn" ->
-          let uu___4 =
-            let uu___5 = translate_expr env1 arg in
-            let uu___6 = translate_type env1 t in (uu___5, uu___6) in
-          ECast uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Prims.admit" -> EAbort
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_}::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "LowStar.Failure.failwith" ->
-          let uu___6 = let uu___7 = translate_type env1 t in (s, uu___7) in
-          EAbortT uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           arg::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.HyperStack.All.failwith") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "FStar.Error.unexpected"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Error.unreachable")
-          ->
-          (match arg with
-           | {
-               FStar_Extraction_ML_Syntax.expr =
-                 FStar_Extraction_ML_Syntax.MLE_Const
-                 (FStar_Extraction_ML_Syntax.MLC_String msg);
-               FStar_Extraction_ML_Syntax.mlty = uu___5;
-               FStar_Extraction_ML_Syntax.loc = uu___6;_} -> EAbortS msg
-           | uu___5 ->
-               let print_nm = (["FStar"; "HyperStack"; "IO"], "print_string") in
-               let print =
-                 FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top
-                   (FStar_Extraction_ML_Syntax.MLE_Name print_nm) in
-               let print1 =
-                 FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top
-                   (FStar_Extraction_ML_Syntax.MLE_App (print, [arg])) in
-               let t = translate_expr env1 print1 in ESequence [t; EAbort])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.ToFStarBuffer.new_to_old_st") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ToFStarBuffer.old_to_new_st")
-          -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          (((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "FStar.Buffer.index") ||
-                (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___5 = "FStar.Buffer.op_Array_Access"))
-               ||
-               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "LowStar.Monotonic.Buffer.index"))
-              ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.UninitializedBuffer.uindex"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.ConstBuffer.index"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Array.index")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.op_Bang") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.read")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.create") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.malloca"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.ialloca")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (Stack, uu___6, uu___7) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           elen::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.UninitializedBuffer.ualloca" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 elen in (Stack, uu___6) in
-          EBufCreateNoInit uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           init::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.HyperStack.ST.salloc" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (Stack, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
+          EMatch uu___
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2018,25 +1067,17 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::[])
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           arg::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.createL") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.malloca_of_list"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.ialloca_of_list")
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = list_elements e2 in
-              FStar_Compiler_List.map (translate_expr env1) uu___7 in
-            (Stack, uu___6) in
-          EBufCreateL uu___5
+          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___4 = "FStar.Dyn.undyn" ->
+          let uu___4 =
+            let uu___5 = translate_expr env1 arg in
+            let uu___6 = translate_type env1 t in (uu___5, uu___6) in
+          ECast uu___4
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2049,19 +1090,10 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _erid::e2::[])
+           uu___5)
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.Monotonic.Buffer.mgcmalloc_of_list") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.igcmalloc_of_list")
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = list_elements e2 in
-              FStar_Compiler_List.map (translate_expr env1) uu___7 in
-            (Eternal, uu___6) in
-          EBufCreateL uu___5
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Prims.admit" -> EAbort
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2071,20 +1103,20 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _rid::init::[])
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String s);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_}::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.ralloc") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.HyperStack.ST.ralloc_drgn")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (Eternal, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "LowStar.Failure.failwith" ->
+          let uu___6 = let uu___7 = translate_type env1 t in (s, uu___7) in
+          EAbortT uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2097,72 +1129,34 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _e0::e1::e2::[])
+           arg::[])
           when
           ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rcreate") ||
+            uu___5 = "FStar.HyperStack.All.failwith") ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.mgcmalloc"))
+              uu___5 = "FStar.Error.unexpected"))
             ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.igcmalloc")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (Eternal, uu___6, uu___7) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          (((((let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___6 = "LowStar.Monotonic.Buffer.mgcmalloc_and_blit") ||
-                (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___6 = "LowStar.Monotonic.Buffer.mmalloc_and_blit"))
-               ||
-               (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___6 = "LowStar.Monotonic.Buffer.malloca_and_blit"))
-              ||
-              (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___6 = "LowStar.ImmutableBuffer.igcmalloc_and_blit"))
-             ||
-             (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___6 = "LowStar.ImmutableBuffer.imalloc_and_blit"))
-            ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "LowStar.ImmutableBuffer.ialloca_and_blit")
+             uu___5 = "FStar.Error.unreachable")
           ->
-          EAbortS
-            "alloc_and_blit family of functions are not yet supported downstream"
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _erid::elen::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.UninitializedBuffer.ugcmalloc" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 elen in (Eternal, uu___6) in
-          EBufCreateNoInit uu___5
+          (match arg with
+           | {
+               FStar_Extraction_ML_Syntax.expr =
+                 FStar_Extraction_ML_Syntax.MLE_Const
+                 (FStar_Extraction_ML_Syntax.MLC_String msg);
+               FStar_Extraction_ML_Syntax.mlty = uu___5;
+               FStar_Extraction_ML_Syntax.loc = uu___6;_} -> EAbortS msg
+           | uu___5 ->
+               let print_nm = (["FStar"; "HyperStack"; "IO"], "print_string") in
+               let print =
+                 FStar_Extraction_ML_Syntax.with_ty
+                   FStar_Extraction_ML_Syntax.MLTY_Top
+                   (FStar_Extraction_ML_Syntax.MLE_Name print_nm) in
+               let print1 =
+                 FStar_Extraction_ML_Syntax.with_ty
+                   FStar_Extraction_ML_Syntax.MLTY_Top
+                   (FStar_Extraction_ML_Syntax.MLE_App (print, [arg])) in
+               let t = translate_expr env1 print1 in ESequence [t; EAbort])
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2175,37 +1169,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _rid::init::[])
+           e1::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.ralloc_mm") ||
+           uu___5 = "LowStar.ToFStarBuffer.new_to_old_st") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.HyperStack.ST.ralloc_drgn_mm")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           init::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.Reference.malloc" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
+             uu___5 = "LowStar.ToFStarBuffer.old_to_new_st")
+          -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2218,24 +1188,29 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _e0::e1::e2::[])
+           e1::e2::[])
           when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.rcreate_mm") ||
+          (((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___5 = "FStar.Buffer.index") ||
+                (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___5 = "FStar.Buffer.op_Array_Access"))
+               ||
+               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___5 = "LowStar.Monotonic.Buffer.index"))
+              ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
+               uu___5 = "LowStar.UninitializedBuffer.uindex"))
              ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
+              uu___5 = "LowStar.ConstBuffer.index"))
             ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.imalloc")
+             uu___5 = "Steel.Array.index")
           ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___6, uu___7) in
-          EBufCreate uu___5
+            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
+          EBufRead uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2248,16 +1223,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
+           _perm::e1::_seq::e2::[])
           when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Array.read" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
+          EBufRead uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2273,33 +1246,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            e1::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
+           uu___5 = "FStar.HyperStack.ST.op_Bang") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.Reference.read")
           ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e0::e1::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.Array.malloc" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e0 in
-            let uu___7 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, uu___7) in
-          EBufCreate uu___5
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2312,14 +1266,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _erid::elen::[])
+           _perm::_v::e1::[])
           when
           let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.UninitializedBuffer.umalloc" ->
+          uu___5 = "Steel.ST.Reference.read" ->
           let uu___5 =
-            let uu___6 = translate_expr env1 elen in
-            (ManuallyManaged, uu___6) in
-          EBufCreateNoInit uu___5
+            let uu___6 = translate_expr env1 e1 in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2332,13 +1286,20 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::[])
+           e1::e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.create") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.Monotonic.Buffer.malloca"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.free")
-          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+             uu___5 = "LowStar.ImmutableBuffer.ialloca")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in (Stack, uu___6, uu___7) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2351,19 +1312,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::[])
+           elen::[])
           when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.rfree") ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.free"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Array.free")
-          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "LowStar.UninitializedBuffer.ualloca" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 elen in (Stack, uu___6) in
+          EBufCreateNoInit uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2376,11 +1331,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
+           init::[])
           when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "FStar.HyperStack.ST.salloc" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 init in
+            (Stack, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2393,14 +1351,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::_e3::[])
+           e2::[])
           when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Buffer.sub" ->
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.createL") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.Monotonic.Buffer.malloca_of_list"))
+            ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.ImmutableBuffer.ialloca_of_list")
+          ->
           let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
+            let uu___6 =
+              let uu___7 = list_elements e2 in
+              FStar_Compiler_List.map (translate_expr env1) uu___7 in
+            (Stack, uu___6) in
+          EBufCreateL uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2413,17 +1379,19 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::_e3::[])
+           _erid::e2::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.Monotonic.Buffer.msub") ||
+           uu___5 = "LowStar.Monotonic.Buffer.mgcmalloc_of_list") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ConstBuffer.sub")
+             uu___5 = "LowStar.ImmutableBuffer.igcmalloc_of_list")
           ->
           let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
+            let uu___6 =
+              let uu___7 = list_elements e2 in
+              FStar_Compiler_List.map (translate_expr env1) uu___7 in
+            (Eternal, uu___6) in
+          EBufCreateL uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2436,10 +1404,17 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
+           _rid::init::[])
           when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Buffer.join" -> translate_expr env1 e1
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.HyperStack.ST.ralloc") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.HyperStack.ST.ralloc_drgn")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 init in
+            (Eternal, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2452,14 +1427,20 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
+           _e0::e1::e2::[])
           when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Buffer.offset" ->
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rcreate") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.Monotonic.Buffer.mgcmalloc"))
+            ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.ImmutableBuffer.igcmalloc")
+          ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
+            let uu___7 = translate_expr env1 e2 in (Eternal, uu___6, uu___7) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2472,14 +1453,27 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
+           uu___5)
           when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.Monotonic.Buffer.moffset" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
+          (((((let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___6 = "LowStar.Monotonic.Buffer.mgcmalloc_and_blit") ||
+                (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___6 = "LowStar.Monotonic.Buffer.mmalloc_and_blit"))
+               ||
+               (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___6 = "LowStar.Monotonic.Buffer.malloca_and_blit"))
+              ||
+              (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___6 = "LowStar.ImmutableBuffer.igcmalloc_and_blit"))
+             ||
+             (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___6 = "LowStar.ImmutableBuffer.imalloc_and_blit"))
+            ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "LowStar.ImmutableBuffer.ialloca_and_blit")
+          ->
+          EAbortS
+            "alloc_and_blit family of functions are not yet supported downstream"
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2492,27 +1486,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::e3::[])
+           _erid::elen::[])
           when
-          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "FStar.Buffer.upd") ||
-               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "FStar.Buffer.op_Array_Assignment"))
-              ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.upd'"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.UninitializedBuffer.uupd"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Array.upd")
-          ->
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "LowStar.UninitializedBuffer.ugcmalloc" ->
           let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
-          EBufWrite uu___5
+            let uu___6 = translate_expr env1 elen in (Eternal, uu___6) in
+          EBufCreateNoInit uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2525,38 +1505,17 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
+           _rid::init::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.op_Colon_Equals") ||
+           uu___5 = "FStar.HyperStack.ST.ralloc_mm") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.write")
+             uu___5 = "FStar.HyperStack.ST.ralloc_drgn_mm")
           ->
           let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (uu___6, (EConstant (UInt32, "0")), uu___7) in
-          EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2::[])
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "FStar.HyperStack.ST.push_frame" -> EPushFrame
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2::[])
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "FStar.HyperStack.ST.pop_frame" -> EPopFrame
+            let uu___6 = translate_expr env1 init in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2569,24 +1528,17 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::e3::e4::e5::[])
+           init::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.blit") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.blit"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.Reference.malloc") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.UninitializedBuffer.ublit")
+             uu___5 = "Steel.ST.Reference.alloc")
           ->
           let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in
-            let uu___9 = translate_expr env1 e4 in
-            let uu___10 = translate_expr env1 e5 in
-            (uu___6, uu___7, uu___8, uu___9, uu___10) in
-          EBufBlit uu___5
+            let uu___6 = translate_expr env1 init in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2599,26 +1551,24 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::e3::[])
+           _e0::e1::e2::[])
           when
-          let s = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          (s = "FStar.Buffer.fill") || (s = "LowStar.Monotonic.Buffer.fill")
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.Buffer.rcreate_mm") ||
+              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
+             ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
+            ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.ImmutableBuffer.imalloc")
           ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
             let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
-          EBufFill uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2::[])
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "FStar.HyperStack.ST.get" -> EUnit
+            (ManuallyManaged, uu___6, uu___7) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2631,13 +1581,18 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _rid::[])
+           e0::e1::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.free_drgn") ||
+           uu___5 = "Steel.Array.malloc") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.HyperStack.ST.new_drgn")
-          -> EUnit
+             uu___5 = "Steel.ST.Array.alloc")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e0 in
+            let uu___7 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, uu___7) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2650,19 +1605,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _ebuf::_eseq::[])
+           _erid::elen::[])
           when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.Monotonic.Buffer.witness_p") ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.recall_p"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.ImmutableBuffer.witness_contents"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.recall_contents")
-          -> EUnit
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "LowStar.UninitializedBuffer.umalloc" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 elen in
+            (ManuallyManaged, uu___6) in
+          EBufCreateNoInit uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2675,13 +1625,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
+           e2::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.ConstBuffer.of_buffer") ||
+           uu___5 = "FStar.HyperStack.ST.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ConstBuffer.of_ibuffer")
-          -> translate_expr env1 e1
+             uu___5 = "Steel.Reference.free")
+          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2691,19 +1641,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           _eqal::e1::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _v::e2::[])
           when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "LowStar.ConstBuffer.of_qbuf" ->
-          let uu___4 =
-            let uu___5 = translate_expr env1 e1 in
-            let uu___6 =
-              let uu___7 = translate_type env1 t in TConstBuf uu___7 in
-            (uu___5, uu___6) in
-          ECast uu___4
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Reference.free" ->
+          let uu___5 = translate_expr env1 e2 in EBufFree uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2713,144 +1658,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           e1::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::[])
           when
-          ((let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___4 = "LowStar.ConstBuffer.cast") ||
-             (let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___4 = "LowStar.ConstBuffer.to_buffer"))
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.Buffer.rfree") ||
+              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___5 = "LowStar.Monotonic.Buffer.free"))
+             ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.Array.free"))
             ||
-            (let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___4 = "LowStar.ConstBuffer.to_ibuffer")
-          ->
-          let uu___4 =
-            let uu___5 = translate_expr env1 e1 in
-            let uu___6 = let uu___7 = translate_type env1 t in TBuf uu___7 in
-            (uu___5, uu___6) in
-          ECast uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           e1::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Obj.repr" ->
-          let uu___2 = let uu___3 = translate_expr env1 e1 in (uu___3, TAny) in
-          ECast uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name ("FStar"::m::[], op1);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           args)
-          when (is_machine_int m) && (is_op op1) ->
-          let uu___2 = FStar_Compiler_Util.must (mk_width m) in
-          let uu___3 = FStar_Compiler_Util.must (mk_op op1) in
-          mk_op_app env1 uu___2 uu___3 args
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name ("Prims"::[], op1);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           args)
-          when is_bool_op op1 ->
-          let uu___2 = FStar_Compiler_Util.must (mk_bool_op op1) in
-          mk_op_app env1 Bool uu___2 args
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("FStar"::m::[], "int_to_t");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_Int
-               (c, FStar_Pervasives_Native.None));
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          when is_machine_int m ->
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Util.must (mk_width m) in (uu___5, c) in
-          EConstant uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("FStar"::m::[], "uint_to_t");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_Int
-               (c, FStar_Pervasives_Native.None));
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          when is_machine_int m ->
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Util.must (mk_width m) in (uu___5, c) in
-          EConstant uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("C"::[], "string_of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
-           | uu___4 ->
-               failwith
-                 "Cannot extract string_of_literal applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("C"::"Compat"::"String"::[], "of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
-           | uu___4 ->
-               failwith
-                 "Cannot extract string_of_literal applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("C"::"String"::[], "of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
-           | uu___4 ->
-               failwith
-                 "Cannot extract string_of_literal applied to a non-literal")
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.ST.Array.free")
+          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2863,164 +1686,53 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           { FStar_Extraction_ML_Syntax.expr = ebefore;
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_}::e1::{
-                                                               FStar_Extraction_ML_Syntax.expr
-                                                                 = eafter;
-                                                               FStar_Extraction_ML_Syntax.mlty
-                                                                 = uu___7;
-                                                               FStar_Extraction_ML_Syntax.loc
-                                                                 = uu___8;_}::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "LowStar.Comment.comment_gen" ->
-          (match (ebefore, eafter) with
-           | (FStar_Extraction_ML_Syntax.MLE_Const
-              (FStar_Extraction_ML_Syntax.MLC_String sbefore),
-              FStar_Extraction_ML_Syntax.MLE_Const
-              (FStar_Extraction_ML_Syntax.MLC_String safter)) ->
-               (if FStar_Compiler_Util.contains sbefore "*/"
-                then failwith "Before Comment contains end-of-comment marker"
-                else ();
-                if FStar_Compiler_Util.contains safter "*/"
-                then failwith "After Comment contains end-of-comment marker"
-                else ();
-                (let uu___11 =
-                   let uu___12 = translate_expr env1 e1 in
-                   (sbefore, uu___12, safter) in
-                 EComment uu___11))
-           | uu___9 ->
-               failwith "Cannot extract comment applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+           e1::e2::_e3::[])
           when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "LowStar.Comment.comment" ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) ->
-               (if FStar_Compiler_Util.contains s "*/"
-                then
-                  failwith
-                    "Standalone Comment contains end-of-comment marker"
-                else ();
-                EStandaloneComment s)
-           | uu___4 ->
-               failwith "Cannot extract comment applied to a non-literal")
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "FStar.Buffer.sub" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
+          EBufSub uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("LowStar"::"Literal"::[], "buffer_of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) ->
-               ECast ((EString s), (TBuf (TInt UInt8)))
-           | uu___4 ->
-               failwith
-                 "Cannot extract buffer_of_literal applied to a non-literal")
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::_e3::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "LowStar.Monotonic.Buffer.msub") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.ConstBuffer.sub")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
+          EBufSub uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("FStar"::"Int"::"Cast"::[], c);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           arg::[])
-          ->
-          let is_known_type =
-            (((((((FStar_Compiler_Util.starts_with c "uint8") ||
-                    (FStar_Compiler_Util.starts_with c "uint16"))
-                   || (FStar_Compiler_Util.starts_with c "uint32"))
-                  || (FStar_Compiler_Util.starts_with c "uint64"))
-                 || (FStar_Compiler_Util.starts_with c "int8"))
-                || (FStar_Compiler_Util.starts_with c "int16"))
-               || (FStar_Compiler_Util.starts_with c "int32"))
-              || (FStar_Compiler_Util.starts_with c "int64") in
-          if (FStar_Compiler_Util.ends_with c "uint64") && is_known_type
-          then
-            let uu___2 =
-              let uu___3 = translate_expr env1 arg in (uu___3, (TInt UInt64)) in
-            ECast uu___2
-          else
-            if (FStar_Compiler_Util.ends_with c "uint32") && is_known_type
-            then
-              (let uu___3 =
-                 let uu___4 = translate_expr env1 arg in
-                 (uu___4, (TInt UInt32)) in
-               ECast uu___3)
-            else
-              if (FStar_Compiler_Util.ends_with c "uint16") && is_known_type
-              then
-                (let uu___4 =
-                   let uu___5 = translate_expr env1 arg in
-                   (uu___5, (TInt UInt16)) in
-                 ECast uu___4)
-              else
-                if (FStar_Compiler_Util.ends_with c "uint8") && is_known_type
-                then
-                  (let uu___5 =
-                     let uu___6 = translate_expr env1 arg in
-                     (uu___6, (TInt UInt8)) in
-                   ECast uu___5)
-                else
-                  if
-                    (FStar_Compiler_Util.ends_with c "int64") &&
-                      is_known_type
-                  then
-                    (let uu___6 =
-                       let uu___7 = translate_expr env1 arg in
-                       (uu___7, (TInt Int64)) in
-                     ECast uu___6)
-                  else
-                    if
-                      (FStar_Compiler_Util.ends_with c "int32") &&
-                        is_known_type
-                    then
-                      (let uu___7 =
-                         let uu___8 = translate_expr env1 arg in
-                         (uu___8, (TInt Int32)) in
-                       ECast uu___7)
-                    else
-                      if
-                        (FStar_Compiler_Util.ends_with c "int16") &&
-                          is_known_type
-                      then
-                        (let uu___8 =
-                           let uu___9 = translate_expr env1 arg in
-                           (uu___9, (TInt Int16)) in
-                         ECast uu___8)
-                      else
-                        if
-                          (FStar_Compiler_Util.ends_with c "int8") &&
-                            is_known_type
-                        then
-                          (let uu___9 =
-                             let uu___10 = translate_expr env1 arg in
-                             (uu___10, (TInt Int8)) in
-                           ECast uu___9)
-                        else
-                          (let uu___10 =
-                             let uu___11 =
-                               let uu___12 = translate_expr env1 arg in
-                               [uu___12] in
-                             ((EQualified (["FStar"; "Int"; "Cast"], c)),
-                               uu___11) in
-                           EApp uu___10)
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "FStar.Buffer.join" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3033,10 +1745,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
+           e1::e2::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "FStar.Buffer.offset" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
+          EBufSub uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3049,15 +1765,14 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
+           e1::e2::[])
           when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "LowStar.Monotonic.Buffer.moffset" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
+          EBufSub uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3070,26 +1785,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
+           e1::e2::e3::[])
           when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "FStar.Buffer.upd") ||
+               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___5 = "FStar.Buffer.op_Array_Assignment"))
+              ||
+              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___5 = "LowStar.Monotonic.Buffer.upd'"))
+             ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.UninitializedBuffer.uupd"))
+            ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.Array.upd")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
+          EBufWrite uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::_s::e2::e3::[])
           when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Array.write" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
+          EBufWrite uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3102,11 +1839,18 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
+           e1::e2::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Reference.null" ->
-          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.HyperStack.ST.op_Colon_Equals") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.Reference.write")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            (uu___6, (EConstant (UInt32, "0")), uu___7) in
+          EBufWrite uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3119,10 +1863,35 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
+           _v::e1::e2::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Reference.write" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            (uu___6, (EConstant (UInt32, "0")), uu___7) in
+          EBufWrite uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2::[])
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "FStar.HyperStack.ST.push_frame" -> EPushFrame
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2::[])
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "FStar.HyperStack.ST.pop_frame" -> EPopFrame
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3135,10 +1904,24 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
+           e1::e2::e3::e4::e5::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.blit") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.Monotonic.Buffer.blit"))
+            ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.UninitializedBuffer.ublit")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            let uu___8 = translate_expr env1 e3 in
+            let uu___9 = translate_expr env1 e4 in
+            let uu___10 = translate_expr env1 e5 in
+            (uu___6, uu___7, uu___8, uu___9, uu___10) in
+          EBufBlit uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3148,34 +1931,29 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::e3::[])
+          when
+          let s = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          (s = "FStar.Buffer.fill") || (s = "LowStar.Monotonic.Buffer.fill")
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            let uu___7 = translate_expr env1 e2 in
+            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
+          EBufFill uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2::[])
           when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "FStar.HyperStack.ST.get" -> EUnit
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3185,33 +1963,16 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___8;
-                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _rid::[])
           when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.HyperStack.ST.free_drgn") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.HyperStack.ST.new_drgn")
+          -> EUnit
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3221,35 +1982,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _ebuf::_eseq::[])
           when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.Monotonic.Buffer.witness_p") ||
+              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___5 = "LowStar.Monotonic.Buffer.recall_p"))
+             ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "LowStar.ImmutableBuffer.witness_contents"))
+            ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.ImmutableBuffer.recall_contents")
+          -> EUnit
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3259,17 +2007,16 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "LowStar.ConstBuffer.of_buffer") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "LowStar.ConstBuffer.of_ibuffer")
+          -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3279,21 +2026,19 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           _eqal::e1::[])
           when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
+          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___4 = "LowStar.ConstBuffer.of_qbuf" ->
+          let uu___4 =
+            let uu___5 = translate_expr env1 e1 in
+            let uu___6 =
+              let uu___7 = translate_type env1 t in TConstBuf uu___7 in
+            (uu___5, uu___6) in
+          ECast uu___4
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3303,31 +2048,144 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::uu___7::uu___8::[])
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           e1::[])
           when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
+          ((let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___4 = "LowStar.ConstBuffer.cast") ||
+             (let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___4 = "LowStar.ConstBuffer.to_buffer"))
+            ||
+            (let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___4 = "LowStar.ConstBuffer.to_ibuffer")
+          ->
+          let uu___4 =
+            let uu___5 = translate_expr env1 e1 in
+            let uu___6 = let uu___7 = translate_type env1 t in TBuf uu___7 in
+            (uu___5, uu___6) in
+          ECast uu___4
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           e1::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Obj.repr" ->
+          let uu___2 = let uu___3 = translate_expr env1 e1 in (uu___3, TAny) in
+          ECast uu___2
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name ("FStar"::m::[], op1);
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           args)
+          when (is_machine_int m) && (is_op op1) ->
+          let uu___2 = FStar_Compiler_Util.must (mk_width m) in
+          let uu___3 = FStar_Compiler_Util.must (mk_op op1) in
+          mk_op_app env1 uu___2 uu___3 args
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name ("Prims"::[], op1);
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           args)
+          when is_bool_op op1 ->
+          let uu___2 = FStar_Compiler_Util.must (mk_bool_op op1) in
+          mk_op_app env1 Bool uu___2 args
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("FStar"::m::[], "int_to_t");
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_Int
+               (c, FStar_Pervasives_Native.None));
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+          when is_machine_int m ->
+          let uu___4 =
+            let uu___5 = FStar_Compiler_Util.must (mk_width m) in (uu___5, c) in
+          EConstant uu___4
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("FStar"::m::[], "uint_to_t");
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_Int
+               (c, FStar_Pervasives_Native.None));
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+          when is_machine_int m ->
+          let uu___4 =
+            let uu___5 = FStar_Compiler_Util.must (mk_width m) in (uu___5, c) in
+          EConstant uu___4
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("C"::[], "string_of_literal");
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           { FStar_Extraction_ML_Syntax.expr = e1;
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+          ->
+          (match e1 with
+           | FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
+           | uu___4 ->
+               failwith
+                 "Cannot extract string_of_literal applied to a non-literal")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("C"::"Compat"::"String"::[], "of_literal");
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           { FStar_Extraction_ML_Syntax.expr = e1;
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+          ->
+          (match e1 with
+           | FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
+           | uu___4 ->
+               failwith
+                 "Cannot extract string_of_literal applied to a non-literal")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("C"::"String"::[], "of_literal");
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           { FStar_Extraction_ML_Syntax.expr = e1;
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+          ->
+          (match e1 with
+           | FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
+           | uu___4 ->
+               failwith
+                 "Cannot extract string_of_literal applied to a non-literal")
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3337,37 +2195,167 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           { FStar_Extraction_ML_Syntax.expr = ebefore;
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_}::e1::{
+                                                               FStar_Extraction_ML_Syntax.expr
+                                                                 = eafter;
+                                                               FStar_Extraction_ML_Syntax.mlty
+                                                                 = uu___7;
+                                                               FStar_Extraction_ML_Syntax.loc
+                                                                 = uu___8;_}::[])
           when
           let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
+          uu___9 = "LowStar.Comment.comment_gen" ->
+          (match (ebefore, eafter) with
+           | (FStar_Extraction_ML_Syntax.MLE_Const
+              (FStar_Extraction_ML_Syntax.MLC_String sbefore),
+              FStar_Extraction_ML_Syntax.MLE_Const
+              (FStar_Extraction_ML_Syntax.MLC_String safter)) ->
+               (if FStar_Compiler_Util.contains sbefore "*/"
+                then failwith "Before Comment contains end-of-comment marker"
+                else ();
+                if FStar_Compiler_Util.contains safter "*/"
+                then failwith "After Comment contains end-of-comment marker"
+                else ();
+                (let uu___11 =
+                   let uu___12 = translate_expr env1 e1 in
+                   (sbefore, uu___12, safter) in
+                 EComment uu___11))
+           | uu___9 ->
+               failwith "Cannot extract comment applied to a non-literal")
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           { FStar_Extraction_ML_Syntax.expr = e1;
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
+          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___4 = "LowStar.Comment.comment" ->
+          (match e1 with
+           | FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String s) ->
+               (if FStar_Compiler_Util.contains s "*/"
+                then
+                  failwith
+                    "Standalone Comment contains end-of-comment marker"
+                else ();
+                EStandaloneComment s)
+           | uu___4 ->
+               failwith "Cannot extract comment applied to a non-literal")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("LowStar"::"Literal"::[], "buffer_of_literal");
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           { FStar_Extraction_ML_Syntax.expr = e1;
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
+          ->
+          (match e1 with
+           | FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String s) ->
+               ECast ((EString s), (TBuf (TInt UInt8)))
+           | uu___4 ->
+               failwith
+                 "Cannot extract buffer_of_literal applied to a non-literal")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("FStar"::"Int"::"Cast"::[], c);
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           arg::[])
+          ->
+          let is_known_type =
+            (((((((FStar_Compiler_Util.starts_with c "uint8") ||
+                    (FStar_Compiler_Util.starts_with c "uint16"))
+                   || (FStar_Compiler_Util.starts_with c "uint32"))
+                  || (FStar_Compiler_Util.starts_with c "uint64"))
+                 || (FStar_Compiler_Util.starts_with c "int8"))
+                || (FStar_Compiler_Util.starts_with c "int16"))
+               || (FStar_Compiler_Util.starts_with c "int32"))
+              || (FStar_Compiler_Util.starts_with c "int64") in
+          if (FStar_Compiler_Util.ends_with c "uint64") && is_known_type
+          then
+            let uu___2 =
+              let uu___3 = translate_expr env1 arg in (uu___3, (TInt UInt64)) in
+            ECast uu___2
+          else
+            if (FStar_Compiler_Util.ends_with c "uint32") && is_known_type
+            then
+              (let uu___3 =
+                 let uu___4 = translate_expr env1 arg in
+                 (uu___4, (TInt UInt32)) in
+               ECast uu___3)
+            else
+              if (FStar_Compiler_Util.ends_with c "uint16") && is_known_type
+              then
+                (let uu___4 =
+                   let uu___5 = translate_expr env1 arg in
+                   (uu___5, (TInt UInt16)) in
+                 ECast uu___4)
+              else
+                if (FStar_Compiler_Util.ends_with c "uint8") && is_known_type
+                then
+                  (let uu___5 =
+                     let uu___6 = translate_expr env1 arg in
+                     (uu___6, (TInt UInt8)) in
+                   ECast uu___5)
+                else
+                  if
+                    (FStar_Compiler_Util.ends_with c "int64") &&
+                      is_known_type
+                  then
+                    (let uu___6 =
+                       let uu___7 = translate_expr env1 arg in
+                       (uu___7, (TInt Int64)) in
+                     ECast uu___6)
+                  else
+                    if
+                      (FStar_Compiler_Util.ends_with c "int32") &&
+                        is_known_type
+                    then
+                      (let uu___7 =
+                         let uu___8 = translate_expr env1 arg in
+                         (uu___8, (TInt Int32)) in
+                       ECast uu___7)
+                    else
+                      if
+                        (FStar_Compiler_Util.ends_with c "int16") &&
+                          is_known_type
+                      then
+                        (let uu___8 =
+                           let uu___9 = translate_expr env1 arg in
+                           (uu___9, (TInt Int16)) in
+                         ECast uu___8)
+                      else
+                        if
+                          (FStar_Compiler_Util.ends_with c "int8") &&
+                            is_known_type
+                        then
+                          (let uu___9 =
+                             let uu___10 = translate_expr env1 arg in
+                             (uu___10, (TInt Int8)) in
+                           ECast uu___9)
+                        else
+                          (let uu___10 =
+                             let uu___11 =
+                               let uu___12 = translate_expr env1 arg in
+                               [uu___12] in
+                             ((EQualified (["FStar"; "Int"; "Cast"], c)),
+                               uu___11) in
+                           EApp uu___10)
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3377,18 +2365,16 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.Effect.Atomic.return") ||
+            (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___7 = "Steel.ST.Util.return")
+          -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3398,19 +2384,20 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                     FStar_Extraction_ML_Syntax.MLE_Name p;
                   FStar_Extraction_ML_Syntax.mlty = uu___;
                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _fp::_fp'::_opened::_p::_i::{
+                                         FStar_Extraction_ML_Syntax.expr =
+                                           FStar_Extraction_ML_Syntax.MLE_Fun
+                                           (uu___5, body);
+                                         FStar_Extraction_ML_Syntax.mlty =
+                                           uu___6;
+                                         FStar_Extraction_ML_Syntax.loc =
+                                           uu___7;_}::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.ST.Util.with_invariant" -> translate_expr env1 body
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3423,10 +2410,23 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                 uu___2);
              FStar_Extraction_ML_Syntax.mlty = uu___3;
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
+           _fp::_fp'::_opened::_p::_i::e1::[])
           when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Util.with_invariant" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.string_of_int
+                  (FStar_Pervasives_Native.fst
+                     e1.FStar_Extraction_ML_Syntax.loc) in
+              FStar_Compiler_Util.format2
+                "Extraction of with_invariant requires its argument to be a function literal at extraction time, try marking its argument inline_for_extraction (%s, %s)"
+                uu___7
+                (FStar_Pervasives_Native.snd
+                   e1.FStar_Extraction_ML_Syntax.loc) in
+            (FStar_Errors.Fatal_ExtractionUnsupported, uu___6) in
+          FStar_Errors.raise_error uu___5 FStar_Compiler_Range.dummyRange
       | FStar_Extraction_ML_Syntax.MLE_App (head, args) ->
           let uu___ =
             let uu___1 = translate_expr env1 head in
@@ -3533,166 +2533,527 @@ and (assert_lid : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           failwith uu___1
 and (translate_branches :
   env ->
-    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
-      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr)
-      Prims.list -> (pattern * expr) Prims.list)
+    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
+      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr)
+      Prims.list -> (pattern * expr) Prims.list)
+  =
+  fun env1 ->
+    fun branches1 ->
+      FStar_Compiler_List.map (translate_branch env1) branches1
+and (translate_branch :
+  env ->
+    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
+      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr) ->
+      (pattern * expr))
+  =
+  fun env1 ->
+    fun uu___ ->
+      match uu___ with
+      | (pat, guard, expr1) ->
+          if guard = FStar_Pervasives_Native.None
+          then
+            let uu___1 = translate_pat env1 pat in
+            (match uu___1 with
+             | (env2, pat1) ->
+                 let uu___2 = translate_expr env2 expr1 in (pat1, uu___2))
+          else failwith "todo: translate_branch"
+and (translate_width :
+  (FStar_Const.signedness * FStar_Const.width) FStar_Pervasives_Native.option
+    -> width)
+  =
+  fun uu___ ->
+    match uu___ with
+    | FStar_Pervasives_Native.None -> CInt
+    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int8) ->
+        Int8
+    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int16) ->
+        Int16
+    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int32) ->
+        Int32
+    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int64) ->
+        Int64
+    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int8)
+        -> UInt8
+    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int16)
+        -> UInt16
+    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int32)
+        -> UInt32
+    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int64)
+        -> UInt64
+and (translate_pat :
+  env -> FStar_Extraction_ML_Syntax.mlpattern -> (env * pattern)) =
+  fun env1 ->
+    fun p ->
+      match p with
+      | FStar_Extraction_ML_Syntax.MLP_Const
+          (FStar_Extraction_ML_Syntax.MLC_Unit) -> (env1, PUnit)
+      | FStar_Extraction_ML_Syntax.MLP_Const
+          (FStar_Extraction_ML_Syntax.MLC_Bool b) -> (env1, (PBool b))
+      | FStar_Extraction_ML_Syntax.MLP_Const
+          (FStar_Extraction_ML_Syntax.MLC_Int (s, sw)) ->
+          let uu___ =
+            let uu___1 = let uu___2 = translate_width sw in (uu___2, s) in
+            PConstant uu___1 in
+          (env1, uu___)
+      | FStar_Extraction_ML_Syntax.MLP_Var name1 ->
+          let env2 = extend env1 name1 in
+          (env2, (PVar { name = name1; typ = TAny; mut = false }))
+      | FStar_Extraction_ML_Syntax.MLP_Wild ->
+          let env2 = extend env1 "_" in
+          (env2, (PVar { name = "_"; typ = TAny; mut = false }))
+      | FStar_Extraction_ML_Syntax.MLP_CTor ((uu___, cons), ps) ->
+          let uu___1 =
+            FStar_Compiler_List.fold_left
+              (fun uu___2 ->
+                 fun p1 ->
+                   match uu___2 with
+                   | (env2, acc) ->
+                       let uu___3 = translate_pat env2 p1 in
+                       (match uu___3 with | (env3, p2) -> (env3, (p2 :: acc))))
+              (env1, []) ps in
+          (match uu___1 with
+           | (env2, ps1) ->
+               (env2, (PCons (cons, (FStar_Compiler_List.rev ps1)))))
+      | FStar_Extraction_ML_Syntax.MLP_Record (uu___, ps) ->
+          let uu___1 =
+            FStar_Compiler_List.fold_left
+              (fun uu___2 ->
+                 fun uu___3 ->
+                   match (uu___2, uu___3) with
+                   | ((env2, acc), (field, p1)) ->
+                       let uu___4 = translate_pat env2 p1 in
+                       (match uu___4 with
+                        | (env3, p2) -> (env3, ((field, p2) :: acc))))
+              (env1, []) ps in
+          (match uu___1 with
+           | (env2, ps1) -> (env2, (PRecord (FStar_Compiler_List.rev ps1))))
+      | FStar_Extraction_ML_Syntax.MLP_Tuple ps ->
+          let uu___ =
+            FStar_Compiler_List.fold_left
+              (fun uu___1 ->
+                 fun p1 ->
+                   match uu___1 with
+                   | (env2, acc) ->
+                       let uu___2 = translate_pat env2 p1 in
+                       (match uu___2 with | (env3, p2) -> (env3, (p2 :: acc))))
+              (env1, []) ps in
+          (match uu___ with
+           | (env2, ps1) -> (env2, (PTuple (FStar_Compiler_List.rev ps1))))
+      | FStar_Extraction_ML_Syntax.MLP_Const uu___ ->
+          failwith "todo: translate_pat [MLP_Const]"
+      | FStar_Extraction_ML_Syntax.MLP_Branch uu___ ->
+          failwith "todo: translate_pat [MLP_Branch]"
+and (translate_constant : FStar_Extraction_ML_Syntax.mlconstant -> expr) =
+  fun c ->
+    match c with
+    | FStar_Extraction_ML_Syntax.MLC_Unit -> EUnit
+    | FStar_Extraction_ML_Syntax.MLC_Bool b -> EBool b
+    | FStar_Extraction_ML_Syntax.MLC_String s ->
+        ((let uu___1 =
+            let uu___2 = FStar_String.list_of_string s in
+            FStar_Compiler_Effect.op_Bar_Greater uu___2
+              (FStar_Compiler_Util.for_some
+                 (fun c1 -> c1 = (FStar_Char.char_of_int Prims.int_zero))) in
+          if uu___1
+          then
+            let uu___2 =
+              FStar_Compiler_Util.format1
+                "Refusing to translate a string literal that contains a null character: %s"
+                s in
+            failwith uu___2
+          else ());
+         EString s)
+    | FStar_Extraction_ML_Syntax.MLC_Char c1 ->
+        let i = FStar_Compiler_Util.int_of_char c1 in
+        let s = FStar_Compiler_Util.string_of_int i in
+        let c2 = EConstant (UInt32, s) in
+        let char_of_int = EQualified (["FStar"; "Char"], "char_of_int") in
+        EApp (char_of_int, [c2])
+    | FStar_Extraction_ML_Syntax.MLC_Int
+        (s, FStar_Pervasives_Native.Some (sg, wd)) ->
+        let uu___ =
+          let uu___1 =
+            translate_width (FStar_Pervasives_Native.Some (sg, wd)) in
+          (uu___1, s) in
+        EConstant uu___
+    | FStar_Extraction_ML_Syntax.MLC_Float uu___ ->
+        failwith "todo: translate_expr [MLC_Float]"
+    | FStar_Extraction_ML_Syntax.MLC_Bytes uu___ ->
+        failwith "todo: translate_expr [MLC_Bytes]"
+    | FStar_Extraction_ML_Syntax.MLC_Int (s, FStar_Pervasives_Native.None) ->
+        EConstant (CInt, s)
+and (mk_op_app :
+  env -> width -> op -> FStar_Extraction_ML_Syntax.mlexpr Prims.list -> expr)
+  =
+  fun env1 ->
+    fun w ->
+      fun op1 ->
+        fun args ->
+          let uu___ =
+            let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
+            ((EOp (op1, w)), uu___1) in
+          EApp uu___
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
-    fun branches1 ->
-      FStar_Compiler_List.map (translate_branch env1) branches1
-and (translate_branch :
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KreMLin (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KreMLin\n" name1 in
+                 (FStar_Errors.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
+let (translate_let :
   env ->
-    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
-      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr) ->
-      (pattern * expr))
+    FStar_Extraction_ML_Syntax.mlletflavor ->
+      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
-    fun uu___ ->
-      match uu___ with
-      | (pat, guard, expr1) ->
-          if guard = FStar_Pervasives_Native.None
-          then
-            let uu___1 = translate_pat env1 pat in
-            (match uu___1 with
-             | (env2, pat1) ->
-                 let uu___2 = translate_expr env2 expr1 in (pat1, uu___2))
-          else failwith "todo: translate_branch"
-and (translate_width :
-  (FStar_Const.signedness * FStar_Const.width) FStar_Pervasives_Native.option
-    -> width)
+    fun flavor ->
+      fun lb ->
+        match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some (tvars, t0);
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
+            FStar_Extraction_ML_Syntax.mllb_def = e;
+            FStar_Extraction_ML_Syntax.mllb_meta = meta;
+            FStar_Extraction_ML_Syntax.print_typ = uu___1;_} when
+            FStar_Compiler_Util.for_some
+              (fun uu___2 ->
+                 match uu___2 with
+                 | FStar_Extraction_ML_Syntax.Assumed -> true
+                 | uu___3 -> false) meta
+            ->
+            let name2 = ((env1.module_name), name1) in
+            let arg_names =
+              match e.FStar_Extraction_ML_Syntax.expr with
+              | FStar_Extraction_ML_Syntax.MLE_Fun (args, uu___2) ->
+                  FStar_Compiler_List.map FStar_Pervasives_Native.fst args
+              | uu___2 -> [] in
+            if (FStar_Compiler_List.length tvars) = Prims.int_zero
+            then
+              let uu___2 =
+                let uu___3 =
+                  let uu___4 = translate_cc meta in
+                  let uu___5 = translate_flags meta in
+                  let uu___6 = translate_type env1 t0 in
+                  (uu___4, uu___5, name2, uu___6, arg_names) in
+                DExternal uu___3 in
+              FStar_Pervasives_Native.Some uu___2
+            else
+              ((let uu___4 =
+                  FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                FStar_Compiler_Util.print1_warning
+                  "Not extracting %s to KreMLin (polymorphic assumes are not supported)\n"
+                  uu___4);
+               FStar_Pervasives_Native.None)
+        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some (tvars, t0);
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
+            FStar_Extraction_ML_Syntax.mllb_def =
+              {
+                FStar_Extraction_ML_Syntax.expr =
+                  FStar_Extraction_ML_Syntax.MLE_Fun (args, body);
+                FStar_Extraction_ML_Syntax.mlty = uu___1;
+                FStar_Extraction_ML_Syntax.loc = uu___2;_};
+            FStar_Extraction_ML_Syntax.mllb_meta = meta;
+            FStar_Extraction_ML_Syntax.print_typ = uu___3;_} ->
+            if
+              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+                meta
+            then FStar_Pervasives_Native.None
+            else
+              (let env2 =
+                 if flavor = FStar_Extraction_ML_Syntax.Rec
+                 then extend env1 name1
+                 else env1 in
+               let env3 =
+                 FStar_Compiler_List.fold_left
+                   (fun env4 -> fun name2 -> extend_t env4 name2) env2 tvars in
+               let rec find_return_type eff i uu___5 =
+                 match uu___5 with
+                 | FStar_Extraction_ML_Syntax.MLTY_Fun (uu___6, eff1, t) when
+                     i > Prims.int_zero ->
+                     find_return_type eff1 (i - Prims.int_one) t
+                 | t -> (i, eff, t) in
+               let name2 = ((env3.module_name), name1) in
+               let uu___5 =
+                 find_return_type FStar_Extraction_ML_Syntax.E_PURE
+                   (FStar_Compiler_List.length args) t0 in
+               match uu___5 with
+               | (i, eff, t) ->
+                   (if i > Prims.int_zero
+                    then
+                      (let msg =
+                         "function type annotation has less arrows than the number of arguments; please mark the return type abbreviation as inline_for_extraction" in
+                       let uu___7 =
+                         FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                       FStar_Compiler_Util.print2_warning
+                         "Not extracting %s to KreMLin (%s)\n" uu___7 msg)
+                    else ();
+                    (let t1 = translate_type env3 t in
+                     let binders = translate_binders env3 args in
+                     let env4 = add_binders env3 args in
+                     let cc1 = translate_cc meta in
+                     let meta1 =
+                       match (eff, t1) with
+                       | (FStar_Extraction_ML_Syntax.E_ERASABLE, uu___7) ->
+                           let uu___8 = translate_flags meta in MustDisappear
+                             :: uu___8
+                       | (FStar_Extraction_ML_Syntax.E_PURE, TUnit) ->
+                           let uu___7 = translate_flags meta in MustDisappear
+                             :: uu___7
+                       | uu___7 -> translate_flags meta in
+                     try
+                       (fun uu___7 ->
+                          match () with
+                          | () ->
+                              let body1 = translate_expr env4 body in
+                              FStar_Pervasives_Native.Some
+                                (DFunction
+                                   (cc1, meta1,
+                                     (FStar_Compiler_List.length tvars), t1,
+                                     name2, binders, body1))) ()
+                     with
+                     | e ->
+                         let msg = FStar_Compiler_Util.print_exn e in
+                         ((let uu___9 =
+                             let uu___10 =
+                               let uu___11 =
+                                 FStar_Extraction_ML_Syntax.string_of_mlpath
+                                   name2 in
+                               FStar_Compiler_Util.format2
+                                 "Error while extracting %s to KreMLin (%s)\n"
+                                 uu___11 msg in
+                             (FStar_Errors.Warning_FunctionNotExtacted,
+                               uu___10) in
+                           FStar_Errors.log_issue
+                             FStar_Compiler_Range.dummyRange uu___9);
+                          (let msg1 =
+                             Prims.op_Hat
+                               "This function was not extracted:\n" msg in
+                           FStar_Pervasives_Native.Some
+                             (DFunction
+                                (cc1, meta1,
+                                  (FStar_Compiler_List.length tvars), t1,
+                                  name2, binders, (EAbortS msg1))))))))
+        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some (tvars, t);
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
+            FStar_Extraction_ML_Syntax.mllb_def = expr1;
+            FStar_Extraction_ML_Syntax.mllb_meta = meta;
+            FStar_Extraction_ML_Syntax.print_typ = uu___1;_} ->
+            if
+              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+                meta
+            then FStar_Pervasives_Native.None
+            else
+              (let meta1 = translate_flags meta in
+               let env2 =
+                 FStar_Compiler_List.fold_left
+                   (fun env3 -> fun name2 -> extend_t env3 name2) env1 tvars in
+               let t1 = translate_type env2 t in
+               let name2 = ((env2.module_name), name1) in
+               try
+                 (fun uu___3 ->
+                    match () with
+                    | () ->
+                        let expr2 = translate_expr env2 expr1 in
+                        FStar_Pervasives_Native.Some
+                          (DGlobal
+                             (meta1, name2,
+                               (FStar_Compiler_List.length tvars), t1, expr2)))
+                   ()
+               with
+               | uu___3 ->
+                   ((let uu___5 =
+                       let uu___6 =
+                         let uu___7 =
+                           FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                         let uu___8 = FStar_Compiler_Util.print_exn uu___3 in
+                         FStar_Compiler_Util.format2
+                           "Error extracting %s to KreMLin (%s)\n" uu___7
+                           uu___8 in
+                       (FStar_Errors.Warning_DefinitionNotTranslated, uu___6) in
+                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
+                       uu___5);
+                    FStar_Pervasives_Native.Some
+                      (DGlobal
+                         (meta1, name2, (FStar_Compiler_List.length tvars),
+                           t1, EAny))))
+        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
+            FStar_Extraction_ML_Syntax.mllb_tysc = ts;
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
+            FStar_Extraction_ML_Syntax.mllb_def = uu___1;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___2;
+            FStar_Extraction_ML_Syntax.print_typ = uu___3;_} ->
+            ((let uu___5 =
+                let uu___6 =
+                  FStar_Compiler_Util.format1
+                    "Not extracting %s to KreMLin\n" name1 in
+                (FStar_Errors.Warning_DefinitionNotTranslated, uu___6) in
+              FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___5);
+             (match ts with
+              | FStar_Pervasives_Native.Some (idents, t) ->
+                  let uu___6 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") t in
+                  FStar_Compiler_Util.print2
+                    "Type scheme is: forall %s. %s\n"
+                    (FStar_String.concat ", " idents) uu___6
+              | FStar_Pervasives_Native.None -> ());
+             FStar_Pervasives_Native.None)
+let (translate_decl :
+  env -> FStar_Extraction_ML_Syntax.mlmodule1 -> decl Prims.list) =
+  fun env1 ->
+    fun d ->
+      match d with
+      | FStar_Extraction_ML_Syntax.MLM_Let (flavor, lbs) ->
+          FStar_Compiler_List.choose (translate_let env1 flavor) lbs
+      | FStar_Extraction_ML_Syntax.MLM_Loc uu___ -> []
+      | FStar_Extraction_ML_Syntax.MLM_Ty tys ->
+          FStar_Compiler_List.choose (translate_type_decl env1) tys
+      | FStar_Extraction_ML_Syntax.MLM_Top uu___ ->
+          failwith "todo: translate_decl [MLM_Top]"
+      | FStar_Extraction_ML_Syntax.MLM_Exn (m, uu___) ->
+          (FStar_Compiler_Util.print1_warning
+             "Not extracting exception %s to KreMLin (exceptions unsupported)\n"
+             m;
+           [])
+let (translate_module :
+  (FStar_Extraction_ML_Syntax.mlpath * (FStar_Extraction_ML_Syntax.mlsig *
+    FStar_Extraction_ML_Syntax.mlmodule) FStar_Pervasives_Native.option *
+    FStar_Extraction_ML_Syntax.mllib) -> file)
   =
-  fun uu___ ->
+  fun m ->
+    let uu___ = m in
     match uu___ with
-    | FStar_Pervasives_Native.None -> CInt
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int8) ->
-        Int8
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int16) ->
-        Int16
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int32) ->
-        Int32
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int64) ->
-        Int64
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int8)
-        -> UInt8
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int16)
-        -> UInt16
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int32)
-        -> UInt32
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int64)
-        -> UInt64
-and (translate_pat :
-  env -> FStar_Extraction_ML_Syntax.mlpattern -> (env * pattern)) =
-  fun env1 ->
-    fun p ->
-      match p with
-      | FStar_Extraction_ML_Syntax.MLP_Const
-          (FStar_Extraction_ML_Syntax.MLC_Unit) -> (env1, PUnit)
-      | FStar_Extraction_ML_Syntax.MLP_Const
-          (FStar_Extraction_ML_Syntax.MLC_Bool b) -> (env1, (PBool b))
-      | FStar_Extraction_ML_Syntax.MLP_Const
-          (FStar_Extraction_ML_Syntax.MLC_Int (s, sw)) ->
-          let uu___ =
-            let uu___1 = let uu___2 = translate_width sw in (uu___2, s) in
-            PConstant uu___1 in
-          (env1, uu___)
-      | FStar_Extraction_ML_Syntax.MLP_Var name1 ->
-          let env2 = extend env1 name1 in
-          (env2, (PVar { name = name1; typ = TAny; mut = false }))
-      | FStar_Extraction_ML_Syntax.MLP_Wild ->
-          let env2 = extend env1 "_" in
-          (env2, (PVar { name = "_"; typ = TAny; mut = false }))
-      | FStar_Extraction_ML_Syntax.MLP_CTor ((uu___, cons), ps) ->
-          let uu___1 =
-            FStar_Compiler_List.fold_left
-              (fun uu___2 ->
-                 fun p1 ->
-                   match uu___2 with
-                   | (env2, acc) ->
-                       let uu___3 = translate_pat env2 p1 in
-                       (match uu___3 with | (env3, p2) -> (env3, (p2 :: acc))))
-              (env1, []) ps in
-          (match uu___1 with
-           | (env2, ps1) ->
-               (env2, (PCons (cons, (FStar_Compiler_List.rev ps1)))))
-      | FStar_Extraction_ML_Syntax.MLP_Record (uu___, ps) ->
-          let uu___1 =
-            FStar_Compiler_List.fold_left
-              (fun uu___2 ->
-                 fun uu___3 ->
-                   match (uu___2, uu___3) with
-                   | ((env2, acc), (field, p1)) ->
-                       let uu___4 = translate_pat env2 p1 in
-                       (match uu___4 with
-                        | (env3, p2) -> (env3, ((field, p2) :: acc))))
-              (env1, []) ps in
-          (match uu___1 with
-           | (env2, ps1) -> (env2, (PRecord (FStar_Compiler_List.rev ps1))))
-      | FStar_Extraction_ML_Syntax.MLP_Tuple ps ->
-          let uu___ =
-            FStar_Compiler_List.fold_left
-              (fun uu___1 ->
-                 fun p1 ->
-                   match uu___1 with
-                   | (env2, acc) ->
-                       let uu___2 = translate_pat env2 p1 in
-                       (match uu___2 with | (env3, p2) -> (env3, (p2 :: acc))))
-              (env1, []) ps in
-          (match uu___ with
-           | (env2, ps1) -> (env2, (PTuple (FStar_Compiler_List.rev ps1))))
-      | FStar_Extraction_ML_Syntax.MLP_Const uu___ ->
-          failwith "todo: translate_pat [MLP_Const]"
-      | FStar_Extraction_ML_Syntax.MLP_Branch uu___ ->
-          failwith "todo: translate_pat [MLP_Branch]"
-and (translate_constant : FStar_Extraction_ML_Syntax.mlconstant -> expr) =
-  fun c ->
-    match c with
-    | FStar_Extraction_ML_Syntax.MLC_Unit -> EUnit
-    | FStar_Extraction_ML_Syntax.MLC_Bool b -> EBool b
-    | FStar_Extraction_ML_Syntax.MLC_String s ->
-        ((let uu___1 =
-            let uu___2 = FStar_String.list_of_string s in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (FStar_Compiler_Util.for_some
-                 (fun c1 -> c1 = (FStar_Char.char_of_int Prims.int_zero))) in
-          if uu___1
-          then
-            let uu___2 =
-              FStar_Compiler_Util.format1
-                "Refusing to translate a string literal that contains a null character: %s"
-                s in
-            failwith uu___2
-          else ());
-         EString s)
-    | FStar_Extraction_ML_Syntax.MLC_Char c1 ->
-        let i = FStar_Compiler_Util.int_of_char c1 in
-        let s = FStar_Compiler_Util.string_of_int i in
-        let c2 = EConstant (UInt32, s) in
-        let char_of_int = EQualified (["FStar"; "Char"], "char_of_int") in
-        EApp (char_of_int, [c2])
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (s, FStar_Pervasives_Native.Some (sg, wd)) ->
-        let uu___ =
-          let uu___1 =
-            translate_width (FStar_Pervasives_Native.Some (sg, wd)) in
-          (uu___1, s) in
-        EConstant uu___
-    | FStar_Extraction_ML_Syntax.MLC_Float uu___ ->
-        failwith "todo: translate_expr [MLC_Float]"
-    | FStar_Extraction_ML_Syntax.MLC_Bytes uu___ ->
-        failwith "todo: translate_expr [MLC_Bytes]"
-    | FStar_Extraction_ML_Syntax.MLC_Int (s, FStar_Pervasives_Native.None) ->
-        EConstant (CInt, s)
-and (mk_op_app :
-  env -> width -> op -> FStar_Extraction_ML_Syntax.mlexpr Prims.list -> expr)
-  =
-  fun env1 ->
-    fun w ->
-      fun op1 ->
-        fun args ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
-            ((EOp (op1, w)), uu___1) in
-          EApp uu___
+    | (module_name, modul, uu___1) ->
+        let module_name1 =
+          FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst module_name)
+            [FStar_Pervasives_Native.snd module_name] in
+        let program1 =
+          match modul with
+          | FStar_Pervasives_Native.Some (_signature, decls) ->
+              FStar_Compiler_List.collect
+                (translate_decl (empty module_name1)) decls
+          | uu___2 ->
+              failwith "Unexpected standalone interface or nested modules" in
+        ((FStar_String.concat "_" module_name1), program1)
 let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
   fun uu___ ->
     match uu___ with

From fc9f232be4f39312578b1155f8d9ce8040d4506c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 29 Mar 2022 10:19:55 -0700
Subject: [PATCH 304/513] krml rename

---
 examples/steel/arraystructs/Makefile         | 22 ++++++++++----------
 examples/steel/arraystructs/PointStruct.fst  |  6 +++---
 examples/steel/arraystructs/ScalarUnion.fst  |  2 +-
 src/extraction/FStar.Extraction.Krml.fs      |  6 +++---
 ulib/experimental/Steel.C.Array.Base.fsti    |  2 +-
 ulib/experimental/Steel.C.Fields.fsti        |  2 +-
 ulib/experimental/Steel.C.StdInt.Base.fst    |  4 ++--
 ulib/experimental/Steel.C.StructLiteral.fsti |  2 +-
 8 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index eaf28dc9324..47a93490a77 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -5,8 +5,8 @@ FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
 
 INCLUDE_PATH = $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental
 
-ifdef KREMLIN_HOME
-KRML_EXE = $(KREMLIN_HOME)/krml
+ifdef KRML_HOME
+KRML_EXE = $(KRML_HOME)/krml
 endif
 
 world: verify test
@@ -22,8 +22,8 @@ FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
 
 # We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
-# since the KReMLin AST does not have a node for null
-# TODO: This should be removed, and support for Steel.C null should be directly added to KReMLin instead
+# since the KaRaMeL AST does not have a node for null
+# TODO: This should be removed, and support for Steel.C null should be directly added to KaRaMeL instead
 SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst
 
 .depend: $(ALL_SOURCE_FILES) Makefile
@@ -50,13 +50,13 @@ verify: $(ALL_CHECKED_FILES)
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
 clean:
-	-rm -rf *.checked *.krml .depend kremlin.rsp .depend.tmp *.c *.h *.o compile_flags.txt extract
+	-rm -rf *.checked *.krml .depend .depend.tmp *.c *.h *.o compile_flags.txt extract
 
-ifdef KREMLIN_HOME
+ifdef KRML_HOME
 
 .PRECIOUS: %.krml
 %.krml:
-	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen Kremlin \
+	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen krml \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
 ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
@@ -75,15 +75,15 @@ $(ALL_C_FILES): %.c: extract
 ALL_O_FILES=$(subst .c,.o,$(ALL_C_FILES))
 
 $(ALL_O_FILES): %.o: %.c
-	$(CC) $(CFLAGS) -DKRML_VERIFIED_UINT128 -I $(KREMLIN_HOME)/include -I $(KREMLIN_HOME)/kremlib/dist/minimal -o $@ -c $<
+	$(CC) $(CFLAGS) -DKRML_VERIFIED_UINT128 -I $(KRML_HOME)/include -I $(KRML_HOME)/krmllib/dist/minimal -o $@ -c $<
 
 test: $(ALL_O_FILES)
 
-else # no KREMLIN_HOME
+else # no KRML_HOME
 
 test:
-	echo KReMLin is not installed, skipping test
+	echo KaRaMeL is not installed, skipping test
 
-endif # KREMLIN_HOME
+endif # KRML_HOME
 
 .PHONY: all world verify clean depend test
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index e18d92dd491..bd29afe064c 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -70,7 +70,7 @@ let point_pcm = struct_pcm point_tag point_fields
 noextract inline_for_extraction
 let c_point: typedef = typedef_struct point_tag point_fields
 
-(** Define the point struct. Kremlin detects this definition and
+(** Define the point struct. Karamel detects this definition and
     emits a corresponding C typedef at extraction time.  See
     Steel.C.StructLiteral.mk_c_struct for more information. *)
 let _ = norm norm_c_typedef (mk_c_struct point_tag point_fields)
@@ -81,10 +81,10 @@ let _ = norm norm_c_typedef (mk_c_struct point_tag point_fields)
     but split the list of (field name, typedef) pairs across two
     definitions: .second is declared in the definition below, while
     .first is declared "inline" in the call to mk_c_struct parsed by
-    Kremlin.
+    Karamel.
 
     This code is just to illustrate that extraction is fairly
-    flexible: all Kremlin cares about is that the call to mk_c_struct
+    flexible: all Karamel cares about is that the call to mk_c_struct
     normalizes (under rules norm_c_typedef) to a valid struct
     definition. In practice, it isn't recommended to split the list of
     fields like this. *)
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index a83f7f4f8fb..74fe25f8552 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -62,7 +62,7 @@ let u32_or_u16_pcm = union_pcm u32_or_u16_tag u32_or_u16_fields
 noextract inline_for_extraction
 let c_u32_or_u16: typedef = typedef_union u32_or_u16_tag u32_or_u16_fields
 
-(** Define the union. Like with mk_c_struct, Kremlin detects this
+(** Define the union. Like with mk_c_struct, Karamel detects this
     definition at extraction type and emits the corresponding typedef. *)
 let _ = norm norm_c_typedef (mk_c_union u32_or_u16_tag u32_or_u16_fields)
 
diff --git a/src/extraction/FStar.Extraction.Krml.fs b/src/extraction/FStar.Extraction.Krml.fs
index c557f013c3a..5b065c90685 100644
--- a/src/extraction/FStar.Extraction.Krml.fs
+++ b/src/extraction/FStar.Extraction.Krml.fs
@@ -982,12 +982,12 @@ and translate_expr env e: expr =
     translate_expr env e
 
 (* BEGIN support for the Steel null pointer. Here, we "piggyback" to
-the current Low* operators for the null pointer, which KReMLin will
+the current Low* operators for the null pointer, which KaRaMeL will
 extract to C later.
 
 TODO: these should be removed and those operators should be directly
-supported by KReMLin (in src/Builtin.ml) Or alternatively Null and
-IsNull nodes should be added to the KReMLin AST *)
+supported by KaRaMeL (in src/Builtin.ml) Or alternatively Null and
+IsNull nodes should be added to the KaRaMeL AST *)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.is_null_from"
diff --git a/ulib/experimental/Steel.C.Array.Base.fsti b/ulib/experimental/Steel.C.Array.Base.fsti
index 68a6aad9075..0ee4a517278 100644
--- a/ulib/experimental/Steel.C.Array.Base.fsti
+++ b/ulib/experimental/Steel.C.Array.Base.fsti
@@ -57,7 +57,7 @@ val array_view (t: Type u#0) (n: size_t)
 /// We model it as three parts:
 /// - a pure part, which represents the beginning of the array, and should extract to t*
 /// - a ghost part, which represents the end of the array, and should be erased at extraction
-/// - a refinement, because KReMLin does not support inlining of dependent pair types where one part is ghost.
+/// - a refinement, because KaRaMeL does not support inlining of dependent pair types where one part is ghost.
 val array_or_null_from (base: Type0) (t: Type0) : Tot Type0
 [@@erasable]
 val array_or_null_to (base: Type0) (t: Type0) : Tot Type0
diff --git a/ulib/experimental/Steel.C.Fields.fsti b/ulib/experimental/Steel.C.Fields.fsti
index 1f5b06235f6..8c2cfe0fa58 100644
--- a/ulib/experimental/Steel.C.Fields.fsti
+++ b/ulib/experimental/Steel.C.Fields.fsti
@@ -55,7 +55,7 @@ noeq type c_fields = {
 
 (** The following combinators encode c_fields as a F* type, which
     allows struct field information to stick around after erasure for
-    Kremlin. For more details about why we need this, see
+    Karamel. For more details about why we need this, see
     Steel.C.Typestring.fsti and Steel.C.Typenat.fsti *)
 
 val c_fields_t_nil: Type0
diff --git a/ulib/experimental/Steel.C.StdInt.Base.fst b/ulib/experimental/Steel.C.StdInt.Base.fst
index 457aa6ac144..af310ce16c7 100644
--- a/ulib/experimental/Steel.C.StdInt.Base.fst
+++ b/ulib/experimental/Steel.C.StdInt.Base.fst
@@ -3,8 +3,8 @@ module Steel.C.StdInt.Base
 module I64 = FStar.Int64
 module Cast = FStar.Int.Cast
 
-(* FIXME: this could be defined as U64.t, but KReMLin currently demands U32.t.
-   NS: A long-term proposal would be to make KReMLin platform-aware and introduce
+(* FIXME: this could be defined as U64.t, but KaRaMeL currently demands U32.t.
+   NS: A long-term proposal would be to make KaRaMeL platform-aware and introduce
    a platform switch in this library here.
 *)
 
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index dff1786d5ae..40ac19a4f70 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -28,7 +28,7 @@ val mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0
     This normalizes to a type (mk_struct_def t fs), where
       t is an embedding of the struct tag name as a Type0 (see Steel.C.Typestring), and
       fs is an embedding of the struct fields as a Type0
-    Kremlin then parses this embedding and emits a C struct definition. *)
+    Karamel then parses this embedding and emits a C struct definition. *)
 let mk_c_struct (tag: Type0) (fields: c_fields) =
   mk_struct_def tag (c_fields_t fields)
 

From a10cd37d905d6c12686a2147b82bcd53b041447d Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 29 Mar 2022 10:51:24 -0700
Subject: [PATCH 305/513] post-merge

---
 src/extraction/FStar.Extraction.Krml.fs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fs b/src/extraction/FStar.Extraction.Krml.fs
index 5b065c90685..4d38791f964 100644
--- a/src/extraction/FStar.Extraction.Krml.fs
+++ b/src/extraction/FStar.Extraction.Krml.fs
@@ -439,7 +439,7 @@ let translate_cc flags =
   | [ "cdecl" ] -> Some CDecl
   | _ -> None
 
-let translate_type_without_decay env t: typ =
+let rec translate_type_without_decay env t: typ =
   match t with
   | MLTY_Tuple []
   | MLTY_Top ->

From 57d57f9828b339ab1a371c350a9011c0a8ec9868 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 29 Mar 2022 10:51:32 -0700
Subject: [PATCH 306/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 839 +++++++++++++++++++++-
 1 file changed, 823 insertions(+), 16 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index e9d0404e3ac..8f1971ad2c3 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type program = decl Prims.list
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,47 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1017,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,16 +1055,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type env1 arg in TConstBuf uu___
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (((((((((((((((((let uu___ =
                              FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -968,13 +1130,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.Array.array")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -984,19 +1147,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1569,6 +1749,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1663,10 +1886,13 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.rfree") ||
+          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "FStar.Buffer.rfree") ||
+               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                uu___5 = "LowStar.Monotonic.Buffer.free"))
+              ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.free"))
+               uu___5 = "Steel.C.Opt.free"))
              ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
               uu___5 = "Steel.Array.free"))
@@ -1674,6 +1900,23 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "Steel.ST.Array.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2356,6 +2599,396 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Reference.null" ->
+          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___8;
+                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::uu___7::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2705,7 +3338,126 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -2824,6 +3576,61 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some
+              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
+               ((FStar_Extraction_ML_Syntax.MLTY_Named
+                ([], view_type_name))::[], p));
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
+            FStar_Extraction_ML_Syntax.mllb_def = fields;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
+            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
+            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
+            ((let uu___6 =
+                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
+              FStar_Compiler_Util.print1
+                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
+             (let rec parse_fields fields1 =
+                match fields1 with
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_Name p1;
+                    FStar_Extraction_ML_Syntax.mlty = uu___6;
+                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
+                    let uu___8 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
+                    FStar_Compiler_Util.print_endline "End of fields"
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_App
+                      ({
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Name p1;
+                         FStar_Extraction_ML_Syntax.mlty = uu___6;
+                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
+                       {
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Const
+                           (FStar_Extraction_ML_Syntax.MLC_String name1);
+                         FStar_Extraction_ML_Syntax.mlty = uu___8;
+                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
+                    FStar_Extraction_ML_Syntax.mlty = uu___10;
+                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
+                    let uu___12 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
+                    ((let uu___13 =
+                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
+                          typedef in
+                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
+                        uu___13);
+                     parse_fields fields2)
+                | uu___6 ->
+                    failwith "Couldn't parse fields from struct_fields" in
+              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From 817d255b758552ce9a3ef4968d2006585e62395e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 29 Mar 2022 12:00:37 -0700
Subject: [PATCH 307/513] rlimit

---
 ulib/experimental/Steel.C.StructLiteral.fst | 2 ++
 ulib/experimental/Steel.C.UnionLiteral.fst  | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
index 7a2fde071a2..b8b5b93569f 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ b/ulib/experimental/Steel.C.StructLiteral.fst
@@ -300,6 +300,7 @@ let struct'_with_field
 = on_dom (struct_dom fields (remove field excluded))
     (fun field' -> if field = field' then w else v field')
 
+#push-options "--z3rlimit 30"
 let struct_with_field_to_carrier'
   (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_of fields)
   (s: struct_pcm_carrier tag fields)
@@ -317,6 +318,7 @@ let struct_with_field_to_carrier'
     (struct_with_field (struct_pcms fields) field t s
       `feq` (struct_view tag fields (remove field excluded)).to_carrier
            (struct'_with_field tag fields excluded field w v))
+#pop-options
 
 let extract_field_with_field
   (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
index ff768227ce9..20b8eee0812 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fst
+++ b/ulib/experimental/Steel.C.UnionLiteral.fst
@@ -129,7 +129,8 @@ let union_is_unit tag fields v
 
 open Steel.C.Reference
 
-#push-options "--z3rlimit 30"
+#push-options "--z3rlimit 64"
+#restart-solver
 let addr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
@@ -159,7 +160,7 @@ let addr_of_union_field'
   let s: Ghost.erased (union_pcm_carrier tag fields) =
     pts_to_view_elim p (union_view tag fields)
   in
-  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
+//  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
   let q = Steel.C.Union.addr_of_union_field #'a #_ #_ #(union_pcms fields) p field s in
   change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   pts_to_view_intro q (Ghost.reveal s field)

From b3e7e612891f3b4fb5f20f0cd3faad2f115020c5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 10:21:33 -0700
Subject: [PATCH 308/513] Revert "snap"

This reverts commit 57d57f9828b339ab1a371c350a9011c0a8ec9868.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 839 +---------------------
 1 file changed, 16 insertions(+), 823 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 8f1971ad2c3..e9d0404e3ac 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type program = decl Prims.list
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,47 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1017,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1055,18 +895,16 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (((((((((((((((((let uu___ =
                              FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1130,14 +968,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.Array.array")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1147,36 +984,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1749,49 +1569,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1886,13 +1663,10 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "FStar.Buffer.rfree") ||
-               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "LowStar.Monotonic.Buffer.free"))
-              ||
+          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "FStar.Buffer.rfree") ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "Steel.C.Opt.free"))
+               uu___5 = "LowStar.Monotonic.Buffer.free"))
              ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
               uu___5 = "Steel.Array.free"))
@@ -1900,23 +1674,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "Steel.ST.Array.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2599,396 +2356,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Reference.null" ->
-          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___8;
-                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::uu___7::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3338,126 +2705,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -3576,61 +2824,6 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some
-              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
-               ((FStar_Extraction_ML_Syntax.MLTY_Named
-                ([], view_type_name))::[], p));
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-            FStar_Extraction_ML_Syntax.mllb_def = fields;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
-            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
-            ((let uu___6 =
-                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
-              FStar_Compiler_Util.print1
-                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
-             (let rec parse_fields fields1 =
-                match fields1 with
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_Name p1;
-                    FStar_Extraction_ML_Syntax.mlty = uu___6;
-                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
-                    let uu___8 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
-                    FStar_Compiler_Util.print_endline "End of fields"
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_App
-                      ({
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Name p1;
-                         FStar_Extraction_ML_Syntax.mlty = uu___6;
-                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                       {
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Const
-                           (FStar_Extraction_ML_Syntax.MLC_String name1);
-                         FStar_Extraction_ML_Syntax.mlty = uu___8;
-                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
-                    FStar_Extraction_ML_Syntax.mlty = uu___10;
-                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
-                    let uu___12 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
-                    ((let uu___13 =
-                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
-                          typedef in
-                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
-                        uu___13);
-                     parse_fields fields2)
-                | uu___6 ->
-                    failwith "Couldn't parse fields from struct_fields" in
-              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From 3df5e6638767ce038ab6ac6563af588a35d99f83 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 10:58:48 -0700
Subject: [PATCH 309/513] post-merge

---
 src/extraction/FStar.Extraction.Krml.fst    | 18 +++++++++---------
 ulib/experimental/Steel.C.UnionLiteral.fst  |  6 +++---
 ulib/experimental/Steel.HigherReference.fst |  2 +-
 3 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 4692f2b5400..c4874ea62fc 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -51,7 +51,7 @@ type decl =
   | DTypeVariant of lident * list flag * int * branches_t
   | DTypeAbstractStruct of lident
   | DExternal of option cc * list flag * lident * typ * list ident
-  | DUntaggedUnion of lident * list<flag> * int * list<(ident * typ)>
+  | DUntaggedUnion of lident * list flag * int * list (ident * typ)
 
 and cc =
   | StdCall
@@ -276,10 +276,10 @@ let is_machine_int m =
   mk_width m <> None
 
 (* JL: TODO: in stdlib somewhere? *)
-let opt_bind (m: option<'a>) (k: 'a -> option<'b>): option<'b> =
+let opt_bind (m: option 'a) (k: 'a -> option 'b): option 'b =
   match m with Some x -> k x | None -> None
 
-let char_of_typechar (t: mlty): option<char> =
+let char_of_typechar (t: mlty): option char =
   match t with
   | MLTY_Named ([], p) ->
     let p = Syntax.string_of_mlpath p in
@@ -292,8 +292,8 @@ let char_of_typechar (t: mlty): option<char> =
 
   | _ -> None
 
-let string_of_typestring (t: mlty): option<string> =
-  let rec go t: option<list<string>> =
+let string_of_typestring (t: mlty): option string =
+  let rec go t: option (list string) =
     match t with
     | MLTY_Named ([], p)
       when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_nil"
@@ -311,7 +311,7 @@ let string_of_typestring (t: mlty): option<string> =
   in
   opt_bind (go t) (fun ss -> Some (FStar.String.concat "" ss))
 
-let lident_of_string (s: string): option<lident> =
+let lident_of_string (s: string): option lident =
   let path = FStar.String.split ['.'] s in
   let rec go p =
     match p with
@@ -322,10 +322,10 @@ let lident_of_string (s: string): option<lident> =
       Some (s :: names, name))
   in go path
 
-let lident_of_typestring (t: mlty): option<lident> =
+let lident_of_typestring (t: mlty): option lident =
   opt_bind (string_of_typestring t) lident_of_string
 
-let int_of_typenat (t: mlty): option<int> =
+let int_of_typenat (t: mlty): option int =
   let rec go t =
     match t with
     | MLTY_Named ([], p)
@@ -1269,7 +1269,7 @@ let translate_type_decl env ty: option decl =
     None
   else
     // JL: TODO: hoist?
-    let parse_fields (fields: mlty): option<list<_>> =
+    let parse_fields (fields: mlty): option (list _) =
       let rec go fields =
         match fields with
         | MLTY_Named ([], p)
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
index 20b8eee0812..2b8844b8bd1 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fst
+++ b/ulib/experimental/Steel.C.UnionLiteral.fst
@@ -160,13 +160,13 @@ let addr_of_union_field'
   let s: Ghost.erased (union_pcm_carrier tag fields) =
     pts_to_view_elim p (union_view tag fields)
   in
-//  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
+  //  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
   let q = Steel.C.Union.addr_of_union_field #'a #_ #_ #(union_pcms fields) p field s in
-  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
+//  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   pts_to_view_intro q (Ghost.reveal s field)
     (fields.get_field field).view
     (dsnd (Ghost.reveal v));
-  assert (Ghost.reveal v == (|field, dsnd (Ghost.reveal v)|));
+//  assert (Ghost.reveal v == (|field, dsnd (Ghost.reveal v)|));
   return q
 #pop-options
 
diff --git a/ulib/experimental/Steel.HigherReference.fst b/ulib/experimental/Steel.HigherReference.fst
index 8cc7d8c0e69..cbd747822b3 100644
--- a/ulib/experimental/Steel.HigherReference.fst
+++ b/ulib/experimental/Steel.HigherReference.fst
@@ -20,8 +20,8 @@ open Steel.Memory
 open Steel.Effect.Atomic
 open Steel.Effect
 open FStar.PCM
-open FStar.Real
 open Steel.PCMFrac
+open FStar.Real
 module RP = Steel.PCMReference
 
 #set-options "--ide_id_info_off"

From e003df9aaf16e5659c9da2263a8dde6c8a1c072a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 10:58:55 -0700
Subject: [PATCH 310/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 837 +++++++++++++++++++++-
 1 file changed, 822 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index a1e1c1dc8d7..27ebec0ec48 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,47 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1017,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,16 +1055,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type env1 arg in TConstBuf uu___
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -964,13 +1126,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -983,19 +1146,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1600,6 +1780,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1693,11 +1916,31 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2399,6 +2642,396 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Reference.null" ->
+          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___8;
+                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::uu___7::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2781,7 +3414,126 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -2900,6 +3652,61 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some
+              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
+               ((FStar_Extraction_ML_Syntax.MLTY_Named
+                ([], view_type_name))::[], p));
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
+            FStar_Extraction_ML_Syntax.mllb_def = fields;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
+            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
+            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
+            ((let uu___6 =
+                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
+              FStar_Compiler_Util.print1
+                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
+             (let rec parse_fields fields1 =
+                match fields1 with
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_Name p1;
+                    FStar_Extraction_ML_Syntax.mlty = uu___6;
+                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
+                    let uu___8 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
+                    FStar_Compiler_Util.print_endline "End of fields"
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_App
+                      ({
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Name p1;
+                         FStar_Extraction_ML_Syntax.mlty = uu___6;
+                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
+                       {
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Const
+                           (FStar_Extraction_ML_Syntax.MLC_String name1);
+                         FStar_Extraction_ML_Syntax.mlty = uu___8;
+                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
+                    FStar_Extraction_ML_Syntax.mlty = uu___10;
+                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
+                    let uu___12 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
+                    ((let uu___13 =
+                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
+                          typedef in
+                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
+                        uu___13);
+                     parse_fields fields2)
+                | uu___6 ->
+                    failwith "Couldn't parse fields from struct_fields" in
+              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From f6cde91288f8a1bf01cd62e95f77f092d32b07c7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 12:00:16 -0700
Subject: [PATCH 311/513] do not extract \*MST\* effect definitions

---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 47a93490a77..f3c5b7f84f1 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -27,7 +27,7 @@ ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
 SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst
 
 .depend: $(ALL_SOURCE_FILES) Makefile
-	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) > $@.tmp
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:*,-Prims,-FStar.MSTTotal,-FStar.NMSTTotal,-FStar.MST,-FStar.NMST' > $@.tmp
 	mv $@.tmp $@
 
 depend: .depend

From d5c2ceabbf8d35bbcfae611171cbe38a9cdad4d7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 18:58:16 -0700
Subject: [PATCH 312/513] Revert "snap"

This reverts commit e003df9aaf16e5659c9da2263a8dde6c8a1c072a.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 837 +---------------------
 1 file changed, 15 insertions(+), 822 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 27ebec0ec48..a1e1c1dc8d7 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,47 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1017,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1055,18 +895,16 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1126,14 +964,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1146,36 +983,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1780,49 +1600,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1916,31 +1693,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2642,396 +2399,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Reference.null" ->
-          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___8;
-                     FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::uu___7::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3414,126 +2781,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -3652,61 +2900,6 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some
-              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
-               ((FStar_Extraction_ML_Syntax.MLTY_Named
-                ([], view_type_name))::[], p));
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-            FStar_Extraction_ML_Syntax.mllb_def = fields;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
-            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
-            ((let uu___6 =
-                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
-              FStar_Compiler_Util.print1
-                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
-             (let rec parse_fields fields1 =
-                match fields1 with
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_Name p1;
-                    FStar_Extraction_ML_Syntax.mlty = uu___6;
-                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
-                    let uu___8 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
-                    FStar_Compiler_Util.print_endline "End of fields"
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_App
-                      ({
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Name p1;
-                         FStar_Extraction_ML_Syntax.mlty = uu___6;
-                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                       {
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Const
-                           (FStar_Extraction_ML_Syntax.MLC_String name1);
-                         FStar_Extraction_ML_Syntax.mlty = uu___8;
-                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
-                    FStar_Extraction_ML_Syntax.mlty = uu___10;
-                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
-                    let uu___12 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
-                    ((let uu___13 =
-                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
-                          typedef in
-                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
-                        uu___13);
-                     parse_fields fields2)
-                | uu___6 ->
-                    failwith "Couldn't parse fields from struct_fields" in
-              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From 1363725c226e318fb69f4164880fcc0279ae948b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 19:31:41 -0700
Subject: [PATCH 313/513] remove base type, thanks to an invariant and
 indefinite description

---
 examples/steel/arraystructs/HaclExample.fst  |  10 +-
 examples/steel/arraystructs/PointStruct.fst  |  12 +-
 examples/steel/arraystructs/ScalarUnion.fst  |   8 +-
 src/extraction/FStar.Extraction.Krml.fst     |  26 +-
 ulib/experimental/Steel.C.Array.Base.fst     | 283 ++++++-------
 ulib/experimental/Steel.C.Array.Base.fsti    | 230 +++++------
 ulib/experimental/Steel.C.Array.fst          |  20 +-
 ulib/experimental/Steel.C.Array.fsti         |   8 +-
 ulib/experimental/Steel.C.Frac.fsti          |  16 +-
 ulib/experimental/Steel.C.Opt.fst            |  14 +-
 ulib/experimental/Steel.C.Opt.fsti           |  36 +-
 ulib/experimental/Steel.C.Ref.fst            | 399 +++++++++++--------
 ulib/experimental/Steel.C.Ref.fsti           | 140 +++----
 ulib/experimental/Steel.C.Reference.fst      | 100 +++--
 ulib/experimental/Steel.C.Struct.fst         |  10 +-
 ulib/experimental/Steel.C.StructLiteral.fst  |  14 +-
 ulib/experimental/Steel.C.StructLiteral.fsti |  31 +-
 ulib/experimental/Steel.C.Union.fst          |  10 +-
 ulib/experimental/Steel.C.UnionLiteral.fst   |  28 +-
 ulib/experimental/Steel.C.UnionLiteral.fsti  |  19 +-
 ulib/experimental/Steel.Effect.Common.fsti   |   2 +-
 ulib/experimental/Steel.PCMReadOnly.fst      |  34 ++
 22 files changed, 747 insertions(+), 703 deletions(-)
 create mode 100644 ulib/experimental/Steel.PCMReadOnly.fst

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index 84df355e89d..17b65fcfe89 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -87,7 +87,7 @@ let _ = norm norm_c_typedef (mk_c_struct comp_tag comp_fields)
     element of the corresponding array to zero) *)
 
 let do_something_with_limbs
-  (a: array 'a U64.t)
+  (a: array U64.t)
 : Steel unit
     (varray a)
     (fun _ -> varray a)
@@ -97,14 +97,14 @@ let do_something_with_limbs
   return ()
 
 let do_something_with_precomp
-  (a: array 'a U64.t)
-: Steel (array_or_null 'a U64.t)
+  (a: array U64.t)
+: Steel (array_or_null U64.t)
     (varray a)
     (fun _ -> varray a)
     (requires fun _ -> length a == 20)
     (ensures fun _ _ _ -> True)
 = upd a (mk_size_t (U32.uint_to_t 19)) (U64.uint_to_t 0);
-  return (null _ _)
+  return (null _)
 
 let test_alloc_free
   ()
@@ -125,7 +125,7 @@ let test_alloc_free
 #push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 30"
 
 let test
-  (p: ref 'a comp comp_pcm)
+  (p: ref comp comp_pcm)
 : SteelT unit
     (p `pts_to_view` comp_view emptyset)
     (fun _ -> p `pts_to_view` comp_view emptyset)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index bd29afe064c..020250e2f3e 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -105,7 +105,7 @@ open Steel.C.Reference
 
 (** To illustrate pointer-to-field in action, we write a function swap
     that swaps x and y coordinates of a point struct. *)
-val swap (p: ref 'a point point_pcm)
+val swap (p: ref point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
@@ -150,7 +150,7 @@ let swap p =
     pointers in a generic way: the helper function does not need to
     know that its inputs are pointers to fields of a struct in order
     to work. *)
-let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
+let generic_swap_sel (p:ref 'c (opt_pcm #'c)) (q:ref 'c (opt_pcm #'c))
 : Steel unit
   ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
   (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
@@ -168,8 +168,8 @@ let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
   opt_write_sel q tmp;
   return ()
 
-val swap' (p: ref 'a point point_pcm)
-: Steel (ptr 'a point point_pcm)
+val swap' (p: ref point point_pcm)
+: Steel (ptr point point_pcm)
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
     (requires fun _ -> True)
@@ -187,13 +187,13 @@ let swap' p =
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
-  return (null _ _ _)
+  return (null _ _)
 
 let test_malloc_free () : SteelT unit emp (fun _ -> emp) =
   let c = malloc 42ul in
   if is_null c _
   then begin
-    elim_pts_to_view_or_null_null _ c (opt_view _);
+    elim_pts_to_view_or_null_null c (opt_view _);
     return ()
   end else begin
     elim_pts_to_view_or_null_not_null c (opt_view _);
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index 74fe25f8552..c33e4f08170 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -73,7 +73,7 @@ let _ = norm norm_c_typedef (mk_c_union u32_or_u16_tag u32_or_u16_fields)
 
 (** Switch a case of the union to the u16 case, by writing x to it. *)
 val switch_to_u16
-  (p: ref unit u32_or_u16 u32_or_u16_pcm)
+  (p: ref u32_or_u16 u32_or_u16_pcm)
   (x: U16.t)
 : Steel unit
     (p `pts_to_view` u32_or_u16_view)
@@ -89,7 +89,7 @@ let switch_to_u16 p x =
   return ()
 
 (** Helper function that zeros the memory location pointed to by p. *)
-let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
+let zero_u32_ref (p:ref U32.t (opt_pcm #U32.t))
 : Steel unit
   (p `pts_to_view` opt_view _)
   (fun _ -> p `pts_to_view` opt_view _)
@@ -98,7 +98,7 @@ let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
 = opt_write_sel p 0ul
 
 (** Given a union in the u32 case, set the u32 to zero. *)
-val zero_u32_of_union (p: ref unit u32_or_u16 u32_or_u16_pcm)
+val zero_u32_of_union (p: ref u32_or_u16 u32_or_u16_pcm)
 : Steel unit
     (p `pts_to_view` u32_or_u16_view)
     (fun _ -> p `pts_to_view` u32_or_u16_view)
@@ -106,7 +106,7 @@ val zero_u32_of_union (p: ref unit u32_or_u16 u32_or_u16_pcm)
     (ensures fun h q h' -> True)
 
 let zero_u32_of_union p =
-  let q: ref _ U32.t _ = addr_of_union_field "as_u32" p in
+  let q: ref U32.t _ = addr_of_union_field "as_u32" p in
   zero_u32_ref q;
   unaddr_of_union_field "as_u32" p q;
   return ()
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index c4874ea62fc..a2353990727 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -461,7 +461,7 @@ let rec translate_type_without_decay env t: typ =
     ->
       TQualified (must (lident_of_typestring tag))
   
-  | MLTY_Named ([_; arg; _; _], p) when
+  | MLTY_Named ([arg; _; _], p) when
     Syntax.string_of_mlpath p = "Steel.C.Reference.ptr"
     ->
       TBuf (translate_type_without_decay env arg)
@@ -473,7 +473,7 @@ let rec translate_type_without_decay env t: typ =
         translate_type_without_decay env t,
         (UInt32, string_of_int (must (int_of_typenat n))))
   
-  | MLTY_Named ([_; arg], p) when
+  | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_or_null_from"
     ->
       TBuf (translate_type_without_decay env arg)
@@ -1027,7 +1027,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
     when string_of_mlpath p = "Steel.C.UnionLiteral.unaddr_of_union_field" ->
       EUnit
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; struct_name])},
              [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field''" ->
       EAddrOf (EField (
@@ -1035,7 +1035,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; union_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
       EAddrOf (EField (
@@ -1043,7 +1043,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; new_value; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.switch_union_field'" ->
       EAssign (
@@ -1053,37 +1053,37 @@ IsNull nodes should be added to the KaRaMeL AST *)
           field_name),
         translate_expr env new_value)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r])
     when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; x])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r; x])
     when string_of_mlpath p = "Steel.C.Opt.opt_write_sel" ->
       EAssign (
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r])
     when string_of_mlpath p = "Steel.C.Array.Base.mk_array_of_ref_from" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
     when string_of_mlpath p = "Steel.C.Array.Base.intro_varray_from" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r; _ (* r' *); i])
     when string_of_mlpath p = "Steel.C.Array.index_from" ->
       EBufRead (translate_expr env r, translate_expr env i)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i; x])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r; _ (* r' *); i; x])
     when string_of_mlpath p = "Steel.C.Array.upd_from" ->
       EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; a; i])
     when string_of_mlpath p = "Steel.C.Array.Base.split_right_from" ->
       EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
 
diff --git a/ulib/experimental/Steel.C.Array.Base.fst b/ulib/experimental/Steel.C.Array.Base.fst
index 7bed43a9046..fd27cd20ee6 100644
--- a/ulib/experimental/Steel.C.Array.Base.fst
+++ b/ulib/experimental/Steel.C.Array.Base.fst
@@ -182,9 +182,9 @@ let array_view t n =
   array_view' t n
 
 noeq
-type array_from0 base t = {
+type array_from0 t = {
   base_len: Ghost.erased size_t;
-  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
+  base_ref: Steel.C.Reference.ref (array_view_type t base_len) (array_pcm t base_len);
   from: size_t;
   perm_ref: Steel.Reference.ghost_ref unit;
 }
@@ -197,9 +197,8 @@ type array_to0 = {
 }
 
 let array0_spec
-  (#base: _)
   (#t: _)
-  (from: array_from0 base t)
+  (from: array_from0 t)
   (to: array_to0)
 : Tot prop
 =
@@ -207,8 +206,8 @@ let array0_spec
     size_v from.from <= size_v to.to /\
     size_v to.to <= size_v from.base_len
 
-let array_or_null_from base t = option (array_from0 base t)
-let array_or_null_to base t = Ghost.erased (option array_to0)
+let array_or_null_from t = option (array_from0 t)
+let array_or_null_to t = Ghost.erased (option array_to0)
 let array_or_null_spec (from, to) =
   None? from == None? to /\
   ((Some? from \/ Some? to) ==> array0_spec (Some?.v from) (Some?.v to))
@@ -219,8 +218,8 @@ let len (from, to) =
     let Some to = Ghost.reveal to in to.to `size_sub` from.from
   | _ -> zero_size
 
-let null_from _ _ = None
-let null_to _ _ = None
+let null_from _ = None
+let null_to _ = None
 let null_to_unique _ = ()
 
 let g_is_null a = None? (fst a)
@@ -937,91 +936,85 @@ let to_view_array_conn
 #pop-options
 
 let array__base_len
-  (#base #t: _)
-  (a: array base t)
+  (#t: _)
+  (a: array t)
 : GTot size_t
 = (Some?.v (fst a)).base_len
 
 let array__base_ref
-  (#base #t: _)
-  (a: array base t)
-: Tot (Steel.C.Reference.ref base (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
+  (#t: _)
+  (a: array t)
+: Tot (Steel.C.Reference.ref (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
 = (Some?.v (fst a)).base_ref
 
 let array__from
-  (#base #t: _)
-  (a: array base t)
+  (#t: _)
+  (a: array t)
 : Tot size_t
 = (Some?.v (fst a)).from
 
 let array__to
-  (#base #t: _)
-  (a: array base t)
+  (#t: _)
+  (a: array t)
 : GTot size_t
 = (Some?.v (snd a)).to
 
 let array__perm_ref
-  (#base #t: _)
-  (a: array base t)
+  (#t: _)
+  (a: array t)
 : Tot (Steel.Reference.ghost_ref unit)
 = (Some?.v (fst a)).perm_ref
 
 let array__perm_val
-  (#base #t: _)
-  (a: array base t)
+  (#t: _)
+  (a: array t)
 : Tot Steel.FractionalPermission.perm
 = (Some?.v (snd a)).perm_val
 
 let array_as_ref_conn
-  (#base: Type)
   (#t: Type)
-  (a: array base t)
+  (a: array t)
 : GTot (Steel.C.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
 = array_conn t (array__base_len a) (array__from a) (array__to a) ()
 
 let array_as_ref
-  (#base: Type)
   (#t: Type)
-  (a: array base t)
-: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+  (a: array t)
+: GTot (Steel.C.Reference.ref (array_view_type t (len a)) (array_pcm t (len a)))
 = Steel.C.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
 
 [@@__steel_reduce__]
 let varray0
-  (#base: Type)
   (#t: Type)
-  (x: array base t)
+  (x: array t)
 : Tot vprop
 = Steel.C.Ref.pts_to_view
-    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
 
 [@@__steel_reduce__]
 let varray9
-  (#base: Type)
   (#t: Type)
-  (x: array base t)
+  (x: array t)
 : Tot vprop
 = (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x)  (array__perm_val x)) `vrewrite` fst
 
-let varray_hp #base #t x = hp_of (varray9 #base #t x)
+let varray_hp #t x = hp_of (varray9 #t x)
 
 #push-options "--debug Steel.C.Array --debug_level Extreme"
 
-let varray_sel #base #t x = sel_of (varray9 #base #t x)
+let varray_sel #t x = sel_of (varray9 #t x)
 
 #pop-options
 
 let intro_varray1
   (#inames: _)
-  (#base: Type)
   (#t: Type)
-  (x: array base t)
+  (x: array t)
 : SteelGhost unit inames
     (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
     (fun _ -> varray x)
@@ -1038,9 +1031,8 @@ let intro_varray1
 
 let elim_varray1
   (#inames: _)
-  (#base: Type)
   (#t: Type)
-  (x: array base t)
+  (x: array t)
 : SteelGhost unit inames
     (varray x)
     (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
@@ -1056,8 +1048,8 @@ let elim_varray1
     fst
 
 let g_mk_array_from'
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from base t)
+  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from t)
 : Tot prop
 = 
   Some? a /\
@@ -1068,7 +1060,7 @@ let g_mk_array_from'
   a.from == mk_size_t 0ul
   end
 
-let g_mk_array #base #t #n r a =
+let g_mk_array #t #n r a =
   g_mk_array_from' r (fst a) /\
   (array__to a) == n /\
   (array__perm_val a) == Steel.FractionalPermission.full_perm
@@ -1077,7 +1069,7 @@ let g_mk_array_weak r a = ()
 
 let g_mk_array_from r a = g_mk_array_from' r a
 
-let g_mk_array_to #base #t #n r a
+let g_mk_array_to #t #n r a
 =
   Some ({
     to = n;
@@ -1086,9 +1078,9 @@ let g_mk_array_to #base #t #n r a
 
 #push-options "--z3rlimit 32"
 
-val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+val intro_varray0 (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: SteelAtomicBase (array base t)
+: SteelAtomicBase (array t)
     false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
@@ -1100,7 +1092,7 @@ val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r:
   ))
 
 let intro_varray0
-  #base #t #_ #n r sq
+  #t #_ #n r sq
 =
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
   let from = Some ({
@@ -1113,7 +1105,7 @@ let intro_varray0
   change_equal_slprop
     (Steel.Reference.ghost_vptr perm_ref)
     (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
-  assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  assert ((array_as_ref res <: Steel.C.Ref.ref (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
   assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
   assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
@@ -1135,7 +1127,7 @@ let intro_varray_from r _ =
   return res
 
 let elim_varray
-  #_ #base #t #n r res sq
+  #_ #t #n r res sq
 =
   assert (g_mk_array r res);
   assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
@@ -1164,10 +1156,9 @@ let adjacent r1 r2 =
   (array__to r1) == (array__from r2)
 
 val t_merge
-  (#base: Type)
   (#t: Type)
-  (r1 r2: array base t)
-: Pure (array base t)
+  (r1 r2: array t)
+: Pure (array t)
   (requires (adjacent r1 r2))
   (ensures (fun r -> length r == length r1 + length r2))
 
@@ -1185,7 +1176,7 @@ let merge_inj_right a b1 b2 = ()
 
 let merge_inj_left a1 a2 b = ()
 
-let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
+let no_self_merge_1 (#t: Type) (a b: array t) : Lemma
   (~ (merge_into a b a))
 = let aux () : Lemma
     (requires (merge_into a b a))
@@ -1198,7 +1189,7 @@ let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
   in
   Classical.move_requires aux ()
 
-let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
+let no_self_merge_2 (#t: Type) (a b: array t) : Lemma
   (~ (merge_into a b b))
 = let aux () : Lemma
     (requires (merge_into a b a))
@@ -1212,26 +1203,25 @@ let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
   Classical.move_requires aux ()
 
 val tsplit
-  (#base: Type)
   (#t: Type)
-  (r: array base t)
+  (r: array t)
   (i: size_t)
-: Pure (array base t & array base t)
+: Pure (array t & array t)
   (requires (size_v i <= length r))
   (ensures (fun (rl, rr) ->
     merge_into rl rr r /\
     length rl == size_v i
   ))
 
-let tsplit #base #t r i =
+let tsplit #t r i =
   let h = half_perm (array__perm_val r) in
-  let r1 : array base t =
+  let r1 : array t =
     (fst r, Ghost.hide (Some ({
       to = (array__from r) `size_add` i;
       perm_val = h;
     })))
   in
-  let r2 : array base t = (Some ({
+  let r2 : array t = (Some ({
     base_len = (array__base_len r);
     base_ref = (array__base_ref r);
     from = (array__from r) `size_add` i;
@@ -1299,9 +1289,8 @@ let to_carrier_split t n x v i =
     assert ((array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
 
 let array_as_ref_split_left
-  (base: Type)
   (t: Type)
-  (x: array base t)
+  (x: array t)
   (i: size_t)
 : Lemma
   (requires (size_v i <= length x))
@@ -1314,9 +1303,8 @@ let array_as_ref_split_left
 
 #restart-solver
 let array_as_ref_split_right
-  (base: Type)
   (t: Type)
-  (x: array base t)
+  (x: array t)
   (i: size_t)
 : Lemma
   (requires (size_v i <= length x))
@@ -1327,8 +1315,8 @@ let array_as_ref_split_right
   array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
   Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
 
-val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
-  : SteelGhost (array base t `gpair` array base t) opened
+val split_ (#opened: _) (#t:Type) (a:array t) (i:size_t)
+  : SteelGhost (array t `gpair` array t) opened
           (varray a)
           (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
           (fun _ -> size_v i <= length a)
@@ -1347,16 +1335,15 @@ val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
 
 #restart-solver
 let split_
-  #j #base #t x i
+  #j #t x i
 =
   let gv = gget (varray x) in
   elim_varray1 x;
   let v = Steel.C.Ref.pts_to_view_elim
     #j
-    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
@@ -1370,7 +1357,7 @@ let split_
   let vr' : array_pcm_carrier t (len xr) = array_large_to_small_f t n i n () v in
   let vr : array_pcm_carrier t (len x) = array_small_to_large_f t n i n () vr' in
   Steel.C.Ref.split
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     v
     vl
     vr;
@@ -1382,11 +1369,11 @@ let split_
   = magic () // array_conn t n z i ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
   in
   Steel.C.Ref.gfocus
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     cl
     vl
     vl';
-  array_as_ref_split_left _ t x i;
+  array_as_ref_split_left t x i;
   assert (array_as_ref xl == Steel.C.Ref.ref_focus (array_as_ref x) cl);
   change_equal_slprop
     (_ `Steel.C.Ref.pts_to` vl')
@@ -1395,7 +1382,6 @@ let split_
   let gvl : array_view_type t (len xl) = Seq.slice gv 0 (size_v i) in
   Steel.C.Ref.pts_to_view_intro
     #j
-    #base
     #(array_pcm_carrier t (len xl))
     #(array_pcm t (len xl))
     (array_as_ref xl)
@@ -1420,11 +1406,11 @@ let split_
   = magic () // array_conn t n i n ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
   in
   Steel.C.Ref.gfocus
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     cr
     vr
     vr';
-  array_as_ref_split_right _ t x i;
+  array_as_ref_split_right t x i;
   assert (array_as_ref xr == Steel.C.Ref.ref_focus (array_as_ref x) cr);
   change_equal_slprop
     (_ `Steel.C.Ref.pts_to` vr')
@@ -1435,7 +1421,6 @@ let split_
 //  in
   Steel.C.Ref.pts_to_view_intro
     #j
-    #base
     #(array_pcm_carrier t (len xr))
     #(array_pcm t (len xr))
     (array_as_ref xr)
@@ -1461,7 +1446,7 @@ let split_
   res
 
 let split'
-  #_ #_ #t a i
+  #_ #t a i
 =
   let g = gget (varray a) in
   Seq.lemma_split #t (Ghost.reveal g) (size_v i);
@@ -1475,7 +1460,6 @@ let split_right_from
 let join' = admit ()
 
 let array_as_one_ref_iso
-  (base: Type)
   (t: Type)
 : Tot (Steel.C.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
 = let c1 = (Steel.C.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
@@ -1497,56 +1481,55 @@ let array_as_one_ref_iso
     (fun x -> ())
 
 let array_as_one_ref_conn
-  (base: Type)
   (t: Type)
 : Tot (Steel.C.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
-= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso base t)
+= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso t)
 
 let g_ref_of_array
-  #base #t r
+  #t r
 =
-  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
+  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn t
 
 let array_as_one_ref_conn'
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#t:Type0) (r:array t)
 : Pure (Steel.C.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
   (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
 =
-  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
+  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn t
 
 #restart-solver
 let array_as_one_ref_conn'_small_to_large
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#t:Type0) (r:array t)
   (x: option t)
   (i: array_domain t (array__base_len r))
 : Lemma
   (requires (size_v (len r) == 1))
   (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = (array__from r) then x else None)))
 = Steel.C.Connection.morphism_compose_morph
-    (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large
+    (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large
     (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Connection.conn_small_to_large
     x
 
 let g_ref_of_array'
-  (#base: Type) (#t:Type0) (r:array base t)
-: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (#t:Type0) (r:array t)
+: Ghost (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
   (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
 = (array__base_ref r) `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
 
 let g_ref_of_array'_correct
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#t:Type0) (r:array t)
 : Lemma
   (requires (length r == 1))
   (ensures (g_ref_of_array r == g_ref_of_array' r))
 =
-  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn base t)
+  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn t)
 
 let get_pts_to
   (#inames: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
-  (r: Steel.C.Ref.ref a p) (v: Ghost.erased b)
+  (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
+  (r: Steel.C.Ref.ref p) (v: Ghost.erased b)
 : SteelGhost (Ghost.erased b) inames
     (Steel.C.Ref.pts_to r v)
     (fun v' -> Steel.C.Ref.pts_to r v)
@@ -1570,39 +1553,36 @@ val abstract_id
 #push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false --print_implicits"
 
 #restart-solver
-let ref_of_array_ghost #inames #base #t x sq =
+let ref_of_array_ghost #inames #t x sq =
   let gv = gget (varray x) in
   elim_varray1 x;
   let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
     #inames
-    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
   in
   assert (len x == one_size);
   let z : array_domain t one_size = zero_size in
-  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
+  assert (Ghost.reveal v `feq` (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
   Steel.C.Ref.gfocus
-    #base
     #(array_pcm_carrier t (len x))
     #(option t)
     #_
     #(array_pcm t (len x))
     (array_as_ref x)
     #(Steel.C.Opt.opt_pcm #t)
-    (array_as_one_ref_conn base t)
+    (array_as_one_ref_conn t)
     _
     (Ghost.reveal v z);
   Steel.C.Ref.pts_to_view_intro
     #inames
-    #base
     #(option t)
     #(Steel.C.Opt.opt_pcm #t)
-    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn base t))
+    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn t))
     (Ghost.reveal v z)
     #t
     #false
@@ -1613,25 +1593,24 @@ let ref_of_array_ghost #inames #base #t x sq =
     (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
 
 #restart-solver
-val ref_of_array0 (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
-  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+val ref_of_array0 (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
+  : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
              false opened Unobservable
              (varray r)
-             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r') `star` v_ref_of_array r)
+             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #t r == r') `star` v_ref_of_array r)
              (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
              (ensures fun h0 r' h1 -> True)
 
 #restart-solver
-let ref_of_array0 #base #t x sq v0 =
+let ref_of_array0 #t x sq v0 =
   let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
   assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
   elim_varray1 x;
   let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
     #_
-    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #base #t x)
+    (array_as_ref #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
@@ -1643,10 +1622,9 @@ let ref_of_array0 #base #t x sq v0 =
     array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
   );
   g_ref_of_array'_correct x;
-  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
+  let r : Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
   Steel.C.Ref.pts_to_view_intro
     #_
-    #base
     #(option t)
     #(Steel.C.Opt.opt_pcm #t)
     r
@@ -1658,12 +1636,12 @@ let ref_of_array0 #base #t x sq v0 =
   intro_vrefine
     (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
     (fun v' -> v' == Ghost.reveal v0);
-  intro_pure (g_ref_of_array #base #t x == r);
+  intro_pure (g_ref_of_array #t x == r);
   return r
 
 #restart-solver
-let ref_of_array_from #base #t r_from r_to sq =
-  let x : array base t = (r_from, r_to) in
+let ref_of_array_from #t r_from r_to sq =
+  let x : array t = (r_from, r_to) in
   change_equal_slprop
     (varray (r_from, r_to))
     (varray x);
@@ -1681,7 +1659,7 @@ let ref_of_array_from #base #t r_from r_to sq =
 
 #restart-solver
 let array_of_ref
-  #_ #base #t r' r sq
+  #_ #t r' r sq
 =
   let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
   let v = Steel.C.Ref.pts_to_view_elim
@@ -1691,7 +1669,7 @@ let array_of_ref
   Steel.C.Ref.unfocus
     r
     (array_as_ref r')
-    (array_as_one_ref_conn base t)
+    (array_as_one_ref_conn t)
     v;
   let g' : Ghost.erased (array_view_type t (len r')) =
     (Ghost.hide (Seq.create 1 (Ghost.reveal g)))
@@ -1714,15 +1692,15 @@ let array_of_ref
 
 #restart-solver
 let one_ref_as_array_conn
-  (base: Type) (t:Type0)
+  (t:Type0)
 : Tot (Steel.C.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
 =
-  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
+  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso t)))
 
-let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array base t) =
+let mk_array_of_ref' (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array t) =
   (Some ({
     base_len = one_size;
-    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
+    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn t;
     from = zero_size;
     perm_ref = perm_ref;
   }), Ghost.hide (Some ({
@@ -1732,20 +1710,20 @@ let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (
 
 #restart-solver
 let mk_array_of_ref'_correct
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
+  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
   (g_ref_of_array (mk_array_of_ref' r perm_ref) == r)
 =
   g_ref_of_array'_correct (mk_array_of_ref' r perm_ref);
   array_conn_id t one_size;
-  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
-  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
-  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
+  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn t);
+  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn t) (array_as_one_ref_conn t);
+  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t);
   Steel.C.Ref.ref_focus_id r
 
 #restart-solver
 let array_as_ref_eq_base_ref
-  (#base: Type) (#t:Type0) (a: array base t)
+  (#t:Type0) (a: array t)
 : Lemma
   (requires (
     array__base_len a == one_size /\
@@ -1761,7 +1739,7 @@ let array_as_ref_eq_base_ref
 
 #restart-solver
 let array_as_ref_mk_array_of_ref'
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
+  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
   (ensures (
     let x = mk_array_of_ref' r perm_ref in
@@ -1779,7 +1757,7 @@ let array_domain_one_size
 = ()
 
 #restart-solver
-let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
+let mk_array_of_ref_view_intro (#t:Type0)
   (g: Ghost.erased t)
   (v: Ghost.erased (option t))
   (v' : Ghost.erased (array_pcm_carrier t one_size))
@@ -1787,7 +1765,7 @@ let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
 : Lemma
   (requires (
     Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Ref.to_carrier (Ghost.reveal g) /\
-    Ghost.reveal v' == (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
+    Ghost.reveal v' == (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
     Ghost.reveal g' == Seq.create 1 (Ghost.reveal g)
   ))
   (ensures (
@@ -1798,27 +1776,27 @@ let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
   )
 
 let mk_array_of_ref_to'
-  (base: Type) (t:Type0)
-: Tot (array_or_null_to base t)
+  (t:Type0)
+: Tot (array_or_null_to t)
 = Some ({
     to = one_size;
     perm_val = Steel.FractionalPermission.full_perm;
   })
 
 let mk_array_of_ref_from_spec
-  #base #t r from
+  #t r from
 =
-  let a = (from, mk_array_of_ref_to' base t) in
+  let a = (from, mk_array_of_ref_to' t) in
   array_or_null_spec a /\
   g_is_null a == false /\
   array__base_len a == one_size /\
   array__from a == zero_size /\
-  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t
+  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn t
 
-let mk_array_of_ref_to #base #t r from = mk_array_of_ref_to' base t
+let mk_array_of_ref_to #t r from = mk_array_of_ref_to' t
 
-val mk_array_of_ref0 (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (array base t)
+val mk_array_of_ref0 (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array t)
              false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
@@ -1833,17 +1811,17 @@ val mk_array_of_ref0 (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference
 
 #restart-solver
 let mk_array_of_ref0
-  #base #t r
+  #t r
 =
   let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
   let v : Ghost.erased (option t) = Steel.C.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
-  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
-  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
-    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
+  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
+  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
+    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t)
   in
-  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
+  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn t) v v' in
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
-  let res : array base t = (Some ({
+  let res : array t = (Some ({
     base_len = one_size;
     base_ref = r';
     from = zero_size;
@@ -1858,7 +1836,7 @@ let mk_array_of_ref0
   let g' : Ghost.erased (array_view_type t one_size) =
     Ghost.hide (Seq.create 1 (Ghost.reveal g))
   in
-  mk_array_of_ref_view_intro base g v v' g' ;
+  mk_array_of_ref_view_intro g v v' g' ;
   Steel.C.Ref.pts_to_view_intro
     _
     _
@@ -1875,7 +1853,7 @@ let mk_array_of_ref0
   return res
 
 let mk_array_of_ref_from
-  #base #t r
+  #t r
 =
   let a = mk_array_of_ref0 r in
   let res = fst a in
@@ -1887,16 +1865,16 @@ let mk_array_of_ref_from
 #pop-options
 
 let varray_or_null0_rewrite
-  (#base #a: Type0)
-  (r: array_or_null base a)
+  (#a: Type0)
+  (r: array_or_null a)
   (_: t_of emp)
 : Tot (option (array_view_type a (len r)))
 = None
 
 [@@__steel_reduce__]
 let varray_or_null0
-  (#base #a: Type0)
-  (r: array_or_null base a)
+  (#a: Type0)
+  (r: array_or_null a)
 : Tot vprop
 = if g_is_null r
   then emp `vrewrite` varray_or_null0_rewrite r
@@ -1975,7 +1953,7 @@ let elim_varray_or_null_none x =
 
 #restart-solver
 let freeable
-  #base #t a
+  #t a
 =
   Steel.C.Ref.freeable (array__base_ref a) /\
   size_v (array__base_len a) > 0 /\
@@ -1997,8 +1975,8 @@ let malloc_to'
  (#t: Type0)
   (x: t)
   (n: size_t)
-  (from: array_or_null_from (array_pcm_carrier t n) t)
-: Tot (array_or_null_to (array_pcm_carrier t n) t)
+  (from: array_or_null_from t)
+: Tot (array_or_null_to t)
 = if None? from
   then None
   else Some ({
@@ -2019,7 +1997,7 @@ val malloc0
   (#t: Type0)
   (x: t)
   (n: size_t)
-: Steel (array_or_null (array_pcm_carrier t n) t)
+: Steel (array_or_null t)
     emp
     (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
@@ -2053,9 +2031,8 @@ let malloc_from
   return res
  
 val free0
-  (#base: Type0)
   (#t: Type0)
-  (a: array base t)
+  (a: array t)
 : Steel unit
     (varray a)
     (fun _ -> emp)
@@ -2065,12 +2042,11 @@ val free0
 #restart-solver
 #push-options "--print_implicits"
 let free0
-  #base #t a
+  #t a
 =
   let r = (array__base_ref a) in
   elim_varray r a ();
   let v = Steel.C.Ref.pts_to_view_elim
-    #_
     #_
     #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
@@ -2078,16 +2054,15 @@ let free0
     (array_view t (array__base_len a))
   in
   Steel.C.Ref.ref_free
-    #_
     #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #v
     r
 
 let free_from
-  #base #t a a' sq
+  #t a a' sq
 =
-  let a0 : array base t = (a, a') in
+  let a0 : array t = (a, a') in
   change_equal_slprop
     (varray (a, a'))
     (varray a0);
diff --git a/ulib/experimental/Steel.C.Array.Base.fsti b/ulib/experimental/Steel.C.Array.Base.fsti
index 0ee4a517278..5b04af13198 100644
--- a/ulib/experimental/Steel.C.Array.Base.fsti
+++ b/ulib/experimental/Steel.C.Array.Base.fsti
@@ -58,42 +58,42 @@ val array_view (t: Type u#0) (n: size_t)
 /// - a pure part, which represents the beginning of the array, and should extract to t*
 /// - a ghost part, which represents the end of the array, and should be erased at extraction
 /// - a refinement, because KaRaMeL does not support inlining of dependent pair types where one part is ghost.
-val array_or_null_from (base: Type0) (t: Type0) : Tot Type0
+val array_or_null_from (t: Type0) : Tot Type0
 [@@erasable]
-val array_or_null_to (base: Type0) (t: Type0) : Tot Type0
-val array_or_null_spec (#base: Type0) (#t: Type0) (x: (array_or_null_from base t & array_or_null_to base t)) : Tot prop
+val array_or_null_to (t: Type0) : Tot Type0
+val array_or_null_spec (#t: Type0) (x: (array_or_null_from t & array_or_null_to t)) : Tot prop
 inline_for_extraction
-let array_or_null (base: Type u#0) (t: Type u#0) : Type u#0 = (x: (array_or_null_from base t & array_or_null_to base t) { array_or_null_spec x })
+let array_or_null (t: Type u#0) : Type u#0 = (x: (array_or_null_from t & array_or_null_to t) { array_or_null_spec x })
 
 /// Returns the length of the array. Usable for specification and proof purposes,
 /// as modeled by the GTot effect
-val len (#base: Type) (#t: Type) (a: array_or_null base t) : GTot size_t
-let length (#base: Type) (#t: Type) (a: array_or_null base t) : GTot nat = size_v (len a)
+val len (#t: Type) (a: array_or_null t) : GTot size_t
+let length (#t: Type) (a: array_or_null t) : GTot nat = size_v (len a)
 
 
-val null_from (base: Type u#0) (t: Type u#0) : Tot (array_or_null_from base t) 
-val null_to (base: Type u#0) (t: Type u#0) : Pure (array_or_null_to base t) (requires True) (ensures (fun r0 ->
-  array_or_null_spec (null_from base t, r0) /\
-  len (null_from base t, r0) == zero_size))
+val null_from (t: Type u#0) : Tot (array_or_null_from t) 
+val null_to (t: Type u#0) : Pure (array_or_null_to t) (requires True) (ensures (fun r0 ->
+  array_or_null_spec (null_from t, r0) /\
+  len (null_from t, r0) == zero_size))
 
 val null_to_unique
-  (#base #t: Type)
-  (to: array_or_null_to base t)
+  (#t: Type)
+  (to: array_or_null_to t)
 : Lemma
   (requires (
-    array_or_null_spec (null_from base t, to)
+    array_or_null_spec (null_from t, to)
   ))
   (ensures (
-    to == null_to base t
+    to == null_to t
   ))
 
 inline_for_extraction
-let null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
-= (null_from base t, null_to base t)
-val g_is_null (#base: Type) (#t: Type) (a: array_or_null base t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null base t))
+let null (t: Type u#0) : Pure (array_or_null t) (requires True) (ensures (fun r -> len r == zero_size))
+= (null_from t, null_to t)
+val g_is_null (#t: Type) (a: array_or_null t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null t))
 inline_for_extraction
 noextract
-let array (base: Type u#0) (t:Type u#0) : Type u#0 = (a: array_or_null base t { g_is_null a == false })
+let array (t:Type u#0) : Type u#0 = (a: array_or_null t { g_is_null a == false })
 
 val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
 : b:bool{b <==> a == one (array_pcm t n)}
@@ -110,35 +110,35 @@ let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}):
 /// Combining the elements above to create an array vprop
 /// TODO: generalize to any view
 
-// val g_array_as_ref (#base: Type u#0) (#t: Type u#0) (a: array base t)
-//   : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
+// val g_array_as_ref (#t: Type u#0) (a: array t)
+//   : GTot (Steel.C.Reference.ref (array_view_type t (len a)) (array_pcm t (len a)))
 
 // [@@ __steel_reduce__]
-// let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop
+// let varray (#t: Type) (x: array t) : Tot vprop
 // = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
 
-val varray_hp (#base: Type0) (#t: Type0) (x: array base t) : Tot (slprop u#1)
+val varray_hp (#t: Type0) (x: array t) : Tot (slprop u#1)
 
-val varray_sel (#base: Type0) (#t: Type0) (x: array base t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
+val varray_sel (#t: Type0) (x: array t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
 
 [@@ __steel_reduce__ ]
-let varray' (#base: Type) (#t: Type) (x: array base t) : GTot vprop' = {
+let varray' (#t: Type) (x: array t) : GTot vprop' = {
   hp = varray_hp x;
   t = array_view_type t (len x);
   sel = varray_sel x;
 }
 
 [@@ __steel_reduce__ ]
-let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop =
+let varray (#t: Type) (x: array t) : Tot vprop =
   VUnit (varray' x)
 
-val g_mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array base t)
+val g_mk_array (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+  (a: array t)
 : Tot prop
 
 val g_mk_array_weak
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array base t)
+  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+  (a: array t)
 : Lemma
   (requires (g_mk_array r a))
   (ensures (
@@ -148,14 +148,14 @@ val g_mk_array_weak
   [SMTPat (g_mk_array r a)]
 
 val g_mk_array_from
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from base t)
+  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from t)
 : Tot prop
 
 val g_mk_array_to
-  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from base t)
-: Pure (array_or_null_to base t)
+  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from t)
+: Pure (array_or_null_to t)
   (requires (g_mk_array_from r a))
   (ensures (fun a' ->
     let a0 = (a, a') in
@@ -164,9 +164,9 @@ val g_mk_array_to
     g_mk_array r a0
   ))
 
-val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+val intro_varray_from (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: SteelAtomicBase (al: array_or_null_from base t { g_mk_array_from r al })
+: SteelAtomicBase (al: array_or_null_from t { g_mk_array_from r al })
     false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun al -> varray (al, g_mk_array_to r al))
@@ -178,9 +178,9 @@ val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t)
   ))
 
 inline_for_extraction
-let intro_varray (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+let intro_varray (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: SteelAtomicBase (array base t)
+: SteelAtomicBase (array t)
   false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
@@ -197,7 +197,7 @@ let intro_varray (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r:
     (varray a);
   return a
 
-val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n)) (a: array base t) (_: squash (size_v n > 0))
+val elim_varray (#inames: _) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n)) (a: array t) (_: squash (size_v n > 0))
 : SteelGhost unit inames
   (varray a)
   (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
@@ -210,16 +210,14 @@ val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: S
 /// Splitting an array into subarrays
 
 val adjacent
-  (#base: Type)
   (#t: Type)
-  (r1 r2: array base t)
+  (r1 r2: array t)
 : Tot prop
 
 val merge
-  (#base: Type)
   (#t: Type)
-  (r1 r2: array base t)
-: Ghost (array base t)
+  (r1 r2: array t)
+: Ghost (array t)
   (requires (adjacent r1 r2))
   (ensures (fun r ->
     length r == length r1 + length r2 /\
@@ -227,17 +225,15 @@ val merge
   ))
 
 let merge_into
-  (#base: Type)
   (#t: Type)
-  (r1 r2 r3: array base t)
+  (r1 r2 r3: array t)
 : Tot prop
 = adjacent r1 r2 /\
   merge r1 r2 == r3
 
 val merge_assoc
-  (#base: Type)
   (#t: Type)
-  (r1 r2 r3: array base t)
+  (r1 r2 r3: array t)
 : Lemma
   (requires (
     (adjacent r1 r2 /\ (adjacent r2 r3 \/ adjacent (merge r1 r2) r3)) \/
@@ -255,25 +251,23 @@ val merge_assoc
   [SMTPat (merge (merge r1 r2) r3)]
 
 val merge_inj_right
-  (#base: Type)
   (#t: Type)
-  (a b1 b2: array base t)
+  (a b1 b2: array t)
 : Lemma
   (requires (adjacent a b1 /\ adjacent a b2 /\ merge a b1 == merge a b2))
   (ensures (b1 == b2))
 
 val merge_inj_left
-  (#base: Type)
   (#t: Type)
-  (a1 a2 b: array base t)
+  (a1 a2 b: array t)
 : Lemma
   (requires (adjacent a1 b /\ adjacent a2 b /\ merge a1 b == merge a2 b))
   (ensures (a1 == a2))
 
-val no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
+val no_self_merge_1 (#t: Type) (a b: array t) : Lemma
   (~ (merge_into a b a))
 
-val no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
+val no_self_merge_2 (#t: Type) (a b: array t) : Lemma
   (~ (merge_into a b b))
 
 [@erasable]
@@ -281,19 +275,18 @@ noeq
 type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
 
 val gsplit
-  (#base: Type)
   (#t: Type)
-  (r: array base t)
+  (r: array t)
   (i: size_t)
-: Ghost (array base t `gpair` array base t)
+: Ghost (array t `gpair` array t)
   (requires (size_v i <= length r))
   (ensures (fun (GPair rl rr) ->
     merge_into rl rr r /\
     length rl == size_v i
   ))
 
-val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
-  : SteelGhost (array base t `gpair` array base t) opened
+val split' (#opened: _) (#t:Type) (a:array t) (i:size_t)
+  : SteelGhost (array t `gpair` array t) opened
           (varray a)
           (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
           (fun _ -> size_v i <= length a)
@@ -309,9 +302,9 @@ val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
           )
 
 inline_for_extraction
-let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
-  (al ar: Ghost.erased (array base t))
-  : SteelAtomicBase (array base t) false opened Unobservable
+let split_left (#t:Type) (#opened: _) (a:array t)
+  (al ar: Ghost.erased (array t))
+  : SteelAtomicBase (array t) false opened Unobservable
           (varray al)
           (fun res -> varray res)
           (fun _ ->
@@ -329,8 +322,8 @@ let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
       (varray res);
     return res
 
-val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
-  : SteelAtomicBase (array_or_null_from base t) false opened Unobservable
+val split_right_from (#t:Type) (#opened: _) (a:array t) (i:size_t)
+  : SteelAtomicBase (array_or_null_from t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
           (fun _ -> size_v i <= length a)
@@ -341,8 +334,8 @@ val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_
           )
 
 inline_for_extraction
-let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
-  : SteelAtomicBase (array base t) false opened Unobservable
+let split_right (#t:Type) (#opened: _) (a:array t) (i:size_t)
+  : SteelAtomicBase (array t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
           (fun _ -> size_v i <= length a)
@@ -356,8 +349,8 @@ let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
   return res
 
 inline_for_extraction
-let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a))
-  : SteelAtomicBase (array base t) false opened Unobservable
+let split (#opened: _) (#t:Type) (a:array t) (i:size_t) (sq: squash (size_v i <= length a))
+  : SteelAtomicBase (array t) false opened Unobservable
           (varray a)
           (fun res -> varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i))))
           `star` varray res)
@@ -383,8 +376,8 @@ let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq:
     (varray sr);
   return sr
 
-val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
-  : SteelGhost (Ghost.erased (array base t)) opened
+val join' (#opened: _) (#t:Type) (al ar:array t)
+  : SteelGhost (Ghost.erased (array t)) opened
           (varray al `star` varray ar)
           (fun a -> varray a)
           (fun _ -> adjacent al ar)
@@ -395,8 +388,8 @@ val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
           )
 
 inline_for_extraction
-let joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
-  : SteelAtomicBase (array base t) false opened Unobservable
+let joinc (#t:Type) (#opened: _) (al ar:array t)
+  : SteelAtomicBase (array t) false opened Unobservable
           (varray al `star` varray ar)
           (fun a -> varray al `star` varray ar)
           (fun _ -> adjacent al ar)
@@ -411,8 +404,8 @@ let joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
     return res
 
 inline_for_extraction
-let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
-  : SteelAtomicBase (array base t) false opened Unobservable
+let join (#opened: _) (#t:Type) (al ar:array t)
+  : SteelAtomicBase (array t) false opened Unobservable
           (varray al `star` varray ar)
           (fun a -> varray a)
           (fun _ -> adjacent al ar)
@@ -433,18 +426,18 @@ let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
 /// Those two functions should extract to identity functions
 
 val g_ref_of_array
-  (#base: Type) (#t:Type0) (r:array base t)
-: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (#t:Type0) (r:array t)
+: Ghost (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
   (requires (length r == 1))
   (ensures (fun _ -> True))
 
 val v_ref_of_array
-  (#base: Type) (#t:Type0) (r:array base t)
+  (#t:Type0) (r:array t)
 : Ghost vprop
   (requires (length r == 1))
   (ensures (fun _ -> True))
 
-val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
+val ref_of_array_ghost (#inames: _) (#t:Type0) (r:array t) (sq: squash (length r == 1))
   : SteelGhost unit inames
              (varray r)
              (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
@@ -456,8 +449,8 @@ val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (s
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
-val ref_of_array_from (#base: Type) (#t:Type0) (#opened: _) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
-  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+val ref_of_array_from (#t:Type0) (#opened: _) (r_from:array_or_null_from t) (r_to: array_or_null_to t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
     false opened Unobservable
              (varray (r_from, r_to))
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
@@ -471,8 +464,8 @@ val ref_of_array_from (#base: Type) (#t:Type0) (#opened: _) (r_from:array_or_nul
              )
 
 inline_for_extraction
-let ref_of_array (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1))
-  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+let ref_of_array (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
     false opened Unobservable
              (varray r)
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
@@ -494,7 +487,7 @@ let ref_of_array (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squ
       (v_ref_of_array r);
     return res
 
-val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
+val array_of_ref (#inames: _) (#t:Type0) (r': array t) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
   : SteelGhost unit inames
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
              (fun _ -> varray r')
@@ -509,14 +502,14 @@ val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: St
 // this function should be used only to pass a pointer as an argument to a function that expects an array
 
 val mk_array_of_ref_from_spec
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (from: array_or_null_from base t)
+  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from t)
 : Tot prop
 
 val mk_array_of_ref_to
-  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  (from: array_or_null_from base t)
-: Pure (array_or_null_to base t)
+  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from t)
+: Pure (array_or_null_to t)
   (requires (mk_array_of_ref_from_spec r from))
   (ensures (fun to ->
     let r' = (from, to) in
@@ -524,8 +517,8 @@ val mk_array_of_ref_to
     g_is_null r' == false
   ))
 
-val mk_array_of_ref_from (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
+val mk_array_of_ref_from (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (r0: array_or_null_from t { mk_array_of_ref_from_spec r r0 })
     false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
@@ -539,8 +532,8 @@ val mk_array_of_ref_from (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Refer
              )
 
 inline_for_extraction
-let mk_array_of_ref (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (array base t)
+let mk_array_of_ref (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array t)
     false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
@@ -558,11 +551,11 @@ let mk_array_of_ref (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.
     (varray r');
   return r'
 
-val is_array_or_null (#base #a:Type0) (r:array_or_null base a) : slprop u#1
-val array_or_null_sel (#base #a:Type0) (r:array_or_null base a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
+val is_array_or_null (#a:Type0) (r:array_or_null a) : slprop u#1
+val array_or_null_sel (#a:Type0) (r:array_or_null a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
 
 [@@ __steel_reduce__]
-let varray_or_null' #base #a (r: array_or_null base a) : GTot vprop' =
+let varray_or_null' #a (r: array_or_null a) : GTot vprop' =
   {hp = is_array_or_null r;
    t = option (array_view_type a (len r));
    sel = array_or_null_sel r}
@@ -572,8 +565,8 @@ let varray_or_null r = VUnit (varray_or_null' r)
 
 val intro_varray_or_null_none
   (#opened: _)
-  (#base #a: Type)
-  (x: array_or_null base a)
+  (#a: Type)
+  (x: array_or_null a)
 : SteelGhost unit opened
     emp
     (fun _ -> varray_or_null x)
@@ -582,8 +575,8 @@ val intro_varray_or_null_none
 
 val intro_varray_or_null_some
   (#opened: _)
-  (#base #a: Type)
-  (x: array base a)
+  (#a: Type)
+  (x: array a)
 : SteelGhost unit opened
     (varray x)
     (fun _ -> varray_or_null x)
@@ -595,8 +588,8 @@ val intro_varray_or_null_some
 
 val elim_varray_or_null_some
   (#opened: _)
-  (#base #a: Type)
-  (x: array_or_null base a)
+  (#a: Type)
+  (x: array_or_null a)
 : SteelGhost (squash (g_is_null x == false)) opened
     (varray_or_null x)
     (fun _ -> varray x)
@@ -608,8 +601,8 @@ val elim_varray_or_null_some
 
 val elim_varray_or_null_none
   (#opened: _)
-  (#base #a: Type)
-  (x: array_or_null base a)
+  (#a: Type)
+  (x: array_or_null a)
 : SteelGhost unit opened
     (varray_or_null x)
     (fun _ -> emp)
@@ -622,24 +615,23 @@ val elim_varray_or_null_none
 /// Allocates an array of size [n] where all cells have initial value [x]
 
 val freeable
-  (#base: Type0)
   (#t: Type0)
-  (a: array base t)
+  (a: array t)
 : Tot prop
 
 val malloc_from_spec
   (#t: Type0)
   (x: t)
   (n: size_t)
-  (from: array_or_null_from (array_pcm_carrier t n) t)
+  (from: array_or_null_from t)
 : Tot prop
 
 val malloc_to
   (#t: Type0)
   (x: t)
   (n: size_t)
-  (from: array_or_null_from (array_pcm_carrier t n) t)
-: Pure (array_or_null_to (array_pcm_carrier t n) t)
+  (from: array_or_null_from t)
+: Pure (array_or_null_to t)
     (requires (size_v n > 0 /\ malloc_from_spec x n from))
     (ensures (fun to -> array_or_null_spec (from, to)))
 
@@ -648,13 +640,13 @@ val malloc_from
   (x: t)
   (n: size_t)
   (sq: squash (size_v n > 0))
-: Steel (from: array_or_null_from (array_pcm_carrier t n) t { malloc_from_spec x n from })
+: Steel (from: array_or_null_from t { malloc_from_spec x n from })
     emp
     (fun r -> varray_or_null (r, malloc_to x n r))
     (requires fun _ -> True)
     (ensures fun _ r0 h' ->
       size_v n > 0 /\
-      begin let r : array_or_null (array_pcm_carrier t n) t = (r0, malloc_to x n r0) in
+      begin let r : array_or_null t = (r0, malloc_to x n r0) in
       g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
       end
     )
@@ -664,7 +656,7 @@ let malloc
   (#t: Type0)
   (x: t)
   (n: size_t)
-: Steel (array_or_null (array_pcm_carrier t n) t)
+: Steel (array_or_null t)
     emp
     (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
@@ -679,10 +671,9 @@ let malloc
   return r
 
 val free_from
-  (#base: Type0)
   (#t: Type0)
-  (a: array_or_null_from base t)
-  (a' : array_or_null_to base t)
+  (a: array_or_null_from t)
+  (a' : array_or_null_to t)
   (sq: squash (array_or_null_spec (a, a') /\ g_is_null (a, a') == false))
 : Steel unit
     (varray (a, a'))
@@ -692,9 +683,8 @@ val free_from
 
 inline_for_extraction
 let free
-  (#base: Type0)
   (#t: Type0)
-  (a: array base t)
+  (a: array t)
 : Steel unit
     (varray a)
     (fun _ -> emp)
@@ -708,11 +698,10 @@ let free
     free_from af a' ()
 
 val is_null_from
-  (#base: Type0)
   (#t: Type0)
   (#opened: _)
-  (a: array_or_null_from base t)
-  (a' : array_or_null_to base t)
+  (a: array_or_null_from t)
+  (a' : array_or_null_to t)
   (sq: squash (array_or_null_spec (a, a')))
 : SteelAtomicBase bool false opened Unobservable
     (varray_or_null (a, a'))
@@ -725,10 +714,9 @@ val is_null_from
 
 inline_for_extraction
 let is_null
-  (#base: Type0)
   (#t: Type0)
   (#opened: _)
-  (a: array_or_null base t)
+  (a: array_or_null t)
 : SteelAtomicBase bool false opened Unobservable
     (varray_or_null a)
     (fun _ -> varray_or_null a)
diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 1f122de960d..61ad058a37f 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -12,7 +12,7 @@ let seq_equal_1
   (ensures (s1 == s2))
 = assert (s1 `Seq.equal` s2)
 
-val index0 (#base: Type) (#t:Type) (r:array base t) (i:size_t)
+val index0 (#t:Type) (r:array t) (i:size_t)
   : Steel t
              (varray r)
              (fun _ -> varray r)
@@ -27,7 +27,7 @@ val index0 (#base: Type) (#t:Type) (r:array base t) (i:size_t)
 #restart-solver
 
 let index0
-  #_ #t r i
+  #t r i
 =
   let rr = split r i () in
   let rrr = split rr one_size () in
@@ -49,9 +49,9 @@ let index0
   return res
 
 let index_from
-  #base #t r r' i
+  #t r r' i
 =
-  let r0 : array base t = (r, r') in
+  let r0 : array t = (r, r') in
   change_equal_slprop
     (varray (r, r'))
     (varray r0);
@@ -80,7 +80,7 @@ let seq_append_append_upd
     (s1 `Seq.append` (s2' `Seq.append` s3)) `Seq.equal` (Seq.upd (s1 `Seq.append` (s2 `Seq.append` s3)) i x)
   )
 
-val upd0 (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
+val upd0 (#t:Type) (r:array t) (i:size_t) (x:t)
   : Steel unit
              (varray r)
              (fun _ -> varray r)
@@ -90,7 +90,7 @@ val upd0 (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
                h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
 
 let upd0
-  #_ #t r i x
+  #t r i x
 =
   let rr = split r i () in
   let rrr = split rr one_size () in
@@ -113,9 +113,9 @@ let upd0
     (varray r)
 
 let upd_from
-  #base #t r r' i x
+  #t r r' i x
 =
-  let r0 : array base t = (r, r') in
+  let r0 : array t = (r, r') in
   change_equal_slprop
     (varray (r, r'))
     (varray r0);
@@ -125,8 +125,8 @@ let upd_from
     (varray (r, r'))
 
 let varray_or_null0_rewrite
-  (#base #a: Type0)
-  (r: array_or_null base a)
+  (#a: Type0)
+  (r: array_or_null a)
   (_: t_of emp)
 : Tot (option (array_view_type a (len r)))
 = None
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index 1d2227358c8..edcc94a302a 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -32,7 +32,7 @@ open Steel.C.Typenat
 /// Accesses index [i] in array [r], as long as [i] is in bounds and the array
 /// is currently valid in memory
 
-val index_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_or_null_to base t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t)
+val index_from (#t:Type) (r:array_or_null_from t) (r' : array_or_null_to t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t)
   : Steel t
              (varray (r, r'))
              (fun _ -> varray (r, r'))
@@ -44,7 +44,7 @@ val index_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array
                x == Seq.index s (size_v i))
 
 inline_for_extraction
-let index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
+let index (#t:Type) (r:array t) (i:size_t)
   : Steel t
              (varray r)
              (fun _ -> varray r)
@@ -70,7 +70,7 @@ let index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
 /// is in bounds and the array is currently valid in memory
 
 
-val upd_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_or_null_to base t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t) (x:t)
+val upd_from (#t:Type) (r:array_or_null_from t) (r' : array_or_null_to t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t) (x:t)
   : Steel unit
              (varray (r, r'))
              (fun _ -> varray (r, r'))
@@ -80,7 +80,7 @@ val upd_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_o
                h1 (varray (r, r')) == Seq.upd (h0 (varray (r, r'))) (size_v i) x)
 
 inline_for_extraction
-let upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
+let upd (#t:Type) (r:array t) (i:size_t) (x:t)
   : Steel unit
              (varray r)
              (fun _ -> varray r)
diff --git a/ulib/experimental/Steel.C.Frac.fsti b/ulib/experimental/Steel.C.Frac.fsti
index 356ef323ede..8e985451cd9 100644
--- a/ulib/experimental/Steel.C.Frac.fsti
+++ b/ulib/experimental/Steel.C.Frac.fsti
@@ -46,15 +46,15 @@ let frac_pcm_fpu
 = base_fpu pcm_frac x (Some (y, full_perm))
 
 val frac_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
+  (#b: Type)
+  (r: ref (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
   (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
   (ensures (fun _ _ _ -> True))
 
 val frac_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
+  (#b: Type)
+  (r: ref (pcm_frac #b)) (x: Ghost.erased (fractional b))
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
@@ -78,9 +78,9 @@ let frac_view
 }
 
 let frac_read_sel
-  (#a: Type u#0) (#b: Type u#0)
+  (#b: Type u#0)
   (#p: perm)
-  (r: ref a (pcm_frac #b))
+  (r: ref (pcm_frac #b))
 : Steel b
   (pts_to_view r (frac_view _ p))
   (fun _ -> pts_to_view r (frac_view _ p))
@@ -92,9 +92,9 @@ let frac_read_sel
 = ref_read_sel r (frac_view _ p)
 
 let frac_write_sel
-  (#a: Type u#0) (#b: Type u#0)
+  (#b: Type u#0)
   (#p: perm)
-  (r: ref a (pcm_frac #b))
+  (r: ref (pcm_frac #b))
   (w: b)
 : Steel unit
   (pts_to_view r (frac_view _ p))
diff --git a/ulib/experimental/Steel.C.Opt.fst b/ulib/experimental/Steel.C.Opt.fst
index deb15a5eb0f..cbedf3afcd1 100644
--- a/ulib/experimental/Steel.C.Opt.fst
+++ b/ulib/experimental/Steel.C.Opt.fst
@@ -8,14 +8,14 @@ let opt_read r =
   let Some x = ref_read r in
   x
 
-let opt_write #a #b #x r y =
+let opt_write #b #x r y =
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+  (#b: Type)
+  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
   (requires (fun _ -> Some? x))
   (ensures (fun _ _ _ -> True))
@@ -24,8 +24,8 @@ let opt_pcm_write
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+  (#b: Type)
+  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b))
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Ghost.reveal x == Some y))
@@ -40,7 +40,7 @@ let malloc
   let xc = ((opt_view c).to_carrier x) in
   let r = Steel.C.Ref.ref_alloc _ xc in
   pts_to_view_intro r xc (opt_view c) x;
-  let r' : ref (option c) c (opt_pcm #c) = r in
+  let r' : ref c (opt_pcm #c) = r in
   A.change_equal_slprop
     (Steel.C.Ref.pts_to_view r (opt_view c))
     (pts_to_view r' (opt_view c));
@@ -50,6 +50,6 @@ let malloc
 let free
   #c r
 =
-  let r' : Steel.C.Ref.ref (option c) (opt_pcm #c) = r in 
+  let r' : Steel.C.Ref.ref (opt_pcm #c) = r in 
   let _ = pts_to_view_elim r (opt_view c) in
   Steel.C.Ref.ref_free r
diff --git a/ulib/experimental/Steel.C.Opt.fsti b/ulib/experimental/Steel.C.Opt.fsti
index c9e9e6ece9a..f483f96e318 100644
--- a/ulib/experimental/Steel.C.Opt.fsti
+++ b/ulib/experimental/Steel.C.Opt.fsti
@@ -35,8 +35,8 @@ let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
 let some_v (x: Ghost.erased (option 'a){Some? x}): Ghost.erased 'a = Some?.v x
 
 val opt_read
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (r: ref a (opt_pcm #b))
+  (#b:Type) (#x: Ghost.erased b)
+  (r: ref (opt_pcm #b))
 : Steel b
     (r `pts_to` Some #b x)
     (fun _ -> r `pts_to` Some #b x)
@@ -44,8 +44,8 @@ val opt_read
     (ensures fun _ x' _ -> Ghost.reveal x == x')
 
 val opt_write
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (r: ref a (opt_pcm #b)) (y: b)
+  (#b:Type) (#x: Ghost.erased b)
+  (r: ref (opt_pcm #b)) (y: b)
 : SteelT unit
     (r `pts_to` Some #b x)
     (fun _ -> r `pts_to` Some y)
@@ -94,22 +94,22 @@ let opt_pcm_fpu
 = base_fpu opt_pcm x (Some y)
 
 val opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+  (#b: Type)
+  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
   (requires (fun _ -> Some? x))
   (ensures (fun _ _ _ -> True))
 
 val opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+  (#b: Type)
+  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b))
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Ghost.reveal x == Some y))
 
 let opt_read_sel
-  (#a: Type u#0) (#b: Type u#0)
-  (r: ref a (opt_pcm #b))
+  (#b: Type u#0)
+  (r: ref (opt_pcm #b))
 : Steel b
   (pts_to_view r (opt_view b))
   (fun _ -> pts_to_view r (opt_view b))
@@ -121,8 +121,8 @@ let opt_read_sel
 = ref_read_sel r (opt_view b)
 
 let opt_write_sel
-  (#a: Type u#0) (#b: Type u#0)
-  (r: ref a (opt_pcm #b))
+  (#b: Type u#0)
+  (r: ref (opt_pcm #b))
   (w: b)
 : Steel unit
   (pts_to_view r (opt_view b))
@@ -139,8 +139,8 @@ let opt_write_sel
 open Steel.C.Reference
 
 let ref_opt_read
-  (#a: Type u#0) (#b: Type u#0)
-  (r: ref a b (opt_pcm #b))
+  (#b: Type u#0)
+  (r: ref b (opt_pcm #b))
 : Steel b
   (pts_to_view r (opt_view b))
   (fun _ -> pts_to_view r (opt_view b))
@@ -152,8 +152,8 @@ let ref_opt_read
 = ref_read_sel r (opt_view b)
 
 let ref_opt_write
-  (#a: Type u#0) (#b: Type u#0)
-  (r: ref a b (opt_pcm #b))
+  (#b: Type u#0)
+  (r: ref b (opt_pcm #b))
   (w: b)
 : Steel unit
   (pts_to_view r (opt_view b))
@@ -166,7 +166,7 @@ let ref_opt_write
 
 val malloc
   (#c:Type0) (x: c)
-: Steel (ptr (option c) c (opt_pcm #c))
+: Steel (ptr c (opt_pcm #c))
     emp
     (fun r -> pts_to_view_or_null r (opt_view c))
     (requires fun _ -> True)
@@ -178,7 +178,7 @@ val malloc
 
 val free
   (#c: Type0)
-  (r: ref (option c) c (opt_pcm #c))
+  (r: ref c (opt_pcm #c))
 : Steel unit
     (pts_to_view r (opt_view c))
     (fun _ -> emp)
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 1a6d19446e8..8e9972f3cfe 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -3,64 +3,149 @@ module P = FStar.PCM
 module U = Steel.C.Universe
 open FStar.FunctionalExtensionality
 
+module M = Steel.Memory
+module R = Steel.PCMReference
+module GHR = Steel.GhostPCMReference
+module RO = Steel.PCMReadOnly
+
 #push-options "--print_universes"
 
-noeq type ref0 (a: Type u#0) (b: Type u#b) : Type u#b = {
-  p: pcm a;
+let is_base_type
+  (r: GHR.ref _ (RO.pcm_readonly #Type0))
+  (i: M.iname)
+  (t0: Type)
+: Tot prop
+= (let open Steel.Effect.Atomic in ( >--> ))
+    i
+    (GHR.pts_to r (Some t0))
+
+let has_base_type
+  (r: GHR.ref _ (RO.pcm_readonly #Type0))
+  (i: M.iname)
+: Tot prop
+= exists (t0: Type) . is_base_type r i t0
+
+let has_base_type_intro
+  (r: GHR.ref _ (RO.pcm_readonly #Type0))
+  (i: M.iname)
+  (t0: Type)
+: Lemma
+  (requires ((let open Steel.Effect.Atomic in ( >--> )) i (GHR.pts_to r (Some t0))))
+  (ensures (has_base_type r i))
+= ()
+
+let get_base_type
+  (r: GHR.ref _ (RO.pcm_readonly #Type0))
+  (i: M.iname)
+: Pure Type
+    (requires (has_base_type r i))
+    (ensures (fun t0 -> is_base_type r i t0))
+= FStar.IndefiniteDescription.indefinite_description_ghost Type (fun t0 -> is_base_type r i t0)
+
+let with_invariant_g_f (#a:Type)
+                     (#fp:A.vprop)
+                     (#fp':a -> A.vprop)
+                     (#opened_invariants:M.inames)
+                     (#p:A.vprop)
+                     (i:A.inv p{not (A.mem_inv opened_invariants i)})
+                     (f:unit -> A.SteelGhostT a (A.add_inv opened_invariants i)
+                                         (p `A.star` fp)
+                                         (fun x -> p `A.star` fp' x))
+  : A.SteelGhostF a opened_invariants fp fp' (fun _ -> True) (fun _ _ _ -> True)
+= A.with_invariant_g i f
+
+let has_base_type_idem
+  (#opened: M.inames)
+  (r: GHR.ref _ (RO.pcm_readonly #Type0))
+  (i: M.iname)
+  (v: Type0)
+  (sq: squash (
+    not (A.mem_inv opened i) /\
+    has_base_type r i
+  ))
+: A.SteelGhostT (squash (v == get_base_type r i)) opened
+    (GHR.pts_to r (Some v))
+    (fun _ -> GHR.pts_to r (Some v))
+= with_invariant_g_f
+    #(squash (v == get_base_type r i))
+    #(GHR.pts_to r (Some v))
+    #(fun _ -> GHR.pts_to r (Some v))
+    #_
+    #(GHR.pts_to r (Some (get_base_type r i)))
+    i
+    (fun _ ->
+      GHR.gather r (Some v) _;
+      GHR.share r _ (Some v) (Some (get_base_type r i))
+    )
+
+noeq type ref0 (b: Type u#b) : Type u#b = {
+  base_type: GHR.ref _ (RO.pcm_readonly #Type0);
+  base_inv: Ghost.erased M.iname;
+  base_has_type: squash (has_base_type base_type base_inv);
+  p: pcm (get_base_type base_type base_inv);
   q: pcm b;
   pl: connection p q;
-  r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
+  r: M.ref (U.raise_t (get_base_type base_type base_inv)) (fstar_pcm_of_pcm (U.raise_pcm p));
 }
 
-noeq type ptr' (a: Type u#0) (b: Type u#b) : Type u#b =
-  | NonNull: (v: ref0 a b) -> ptr' a b
-  | Null: (v: pcm b) -> ptr' a b
+noeq type ptr' (b: Type u#b) : Type u#b =
+  | NonNull: (v: ref0 b) -> ptr' b
+  | Null: (v: pcm b) -> ptr' b
 
 let pcm_of_ptr'
-  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' a b)
+  (r: ptr' b)
 : Tot (pcm b)
 = if Null? r then Null?.v r else (NonNull?.v r).q
 
-let ptr a #b p = (r: ptr' a b { pcm_of_ptr' r == p })
+let ptr #b p = (r: ptr' b { pcm_of_ptr' r == p })
 
-let null a p = Null p
+let null p = Null p
 
 let ptr_is_null p = Null? p
 
-let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
-
 let raise_p
-  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' a b { NonNull? r})
-: Tot (pcm (U.raise_t u#0 u#1 a))
+  (r: ptr' b { NonNull? r})
+: Tot (pcm (U.raise_t u#0 u#1 (get_base_type (NonNull?.v r).base_type (NonNull?.v r).base_inv)))
 = U.raise_pcm (NonNull?.v r).p
 
+let base_of
+  (#b: Type u#b)
+  (r: ptr' b { NonNull? r })
+: Tot (M.ref _ (fstar_pcm_of_pcm (raise_p r)))
+= (NonNull?.v r).r
+
 let lower_conn
-  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' a b { NonNull? r})
+  (r: ptr' b { NonNull? r})
 : Tot (connection (raise_p r) (NonNull?.v r).p)
 = connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (NonNull?.v r).p))
 
 let raise_pl
-  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' a b {NonNull? r})
+  (r: ptr' b {NonNull? r})
 : Tot (connection (raise_p r) (NonNull?.v r).q)
 = lower_conn r `connection_compose` (NonNull?.v r).pl
 
-let pts_to r v =
-  (NonNull?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
+let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
+
+[@@__reduce__]
+let pts_to0
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p) (v: b)
+: Tot vprop
+= mpts_to (base_of r) ((raise_pl r).conn_small_to_large.morph v) `star`
+  GHR.pts_to (NonNull?.v r).base_type (Some (get_base_type (NonNull?.v r).base_type (NonNull?.v r).base_inv))
+
+let pts_to r v = pts_to0 r v
 
 let t_ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref a p) (#q: pcm c) (l: connection p q)
-: Tot (ref a q)
+  (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref p) (#q: pcm c) (l: connection p q)
+: Tot (ref q)
 = let NonNull r = r in
-  NonNull ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
+  NonNull ({r with p = r.p; pl = connection_compose r.pl l; q = q})
 
 let ref_focus r l = t_ref_focus r l
 
@@ -69,40 +154,48 @@ let ref_focus_id r = connection_compose_id_right (NonNull?.v r).pl
 let ref_focus_comp r l m
 = connection_compose_assoc (NonNull?.v r).pl l m
 
-let mk_id_ref
-  (#a: Type0)
-  (p: pcm a)
-  (r0: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)))
-: Tot (ref a p)
-=
-  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
-  let fp = fstar_pcm_of_pcm p' in
-  NonNull ({ p = p; q = p; pl = connection_id p; r = r0 })
-
 (* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
 
-let freeable #a #b #p r =
+let freeable #b #p r =
   let NonNull r = r in
-  a == b /\
-  r.p == p /\
-  r.pl == connection_id p
+  get_base_type r.base_type r.base_inv == b /\
+  r.q == r.p /\
+  r.pl == connection_id _
 
-#push-options "--z3rlimit 16"
+#push-options "--z3rlimit 32"
+#restart-solver
+
+let ref_alloc #a pcm v =
+  let r : Steel.Memory.ref (U.raise_t a) (fstar_pcm_of_pcm (U.raise_pcm pcm)) = R.alloc (U.raise_val v) in
+  let g: GHR.ref _ (RO.pcm_readonly #Type0) = GHR.alloc (Some a) in
+  GHR.share g (Some a) (Some a) (Some a);
+  let i = A.new_invariant (GHR.pts_to g (Some a)) in
+  has_base_type_intro g i a;
+  has_base_type_idem g i _ ();
+  let p : ref pcm = NonNull ({
+    base_type = g;
+    base_inv = i;
+    base_has_type = ();
+    p = pcm;
+    q = pcm;
+    pl = connection_id _;
+    r = r;
+  })
+  in
+  A.change_equal_slprop
+    (mpts_to r (U.raise_val v))
+    (mpts_to (base_of p) ((raise_pl p).conn_small_to_large.morph v));
+  A.change_equal_slprop
+    (GHR.pts_to g _)
+    (GHR.pts_to (NonNull?.v p).base_type (Some (get_base_type (NonNull?.v p).base_type (NonNull?.v p).base_inv)));
+  A.change_equal_slprop
+    (pts_to0 p v)
+    (pts_to p v);
+  A.return p
 
-let ref_alloc #a p x =
-  let x' : U.raise_t u#0 u#1 a = U.raise_val u#0 u#1 x in
-  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
-//  let fp : P.pcm u#1 _ = fstar_pcm_of_pcm p' in // FIXME: I can define this local definition, but WHY WHY WHY can't I USE it?
-  compatible_refl p' x';
-  let r0 : Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) = Steel.PCMReference.alloc #_ #(fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) x' in
-  let r : ref a p = mk_id_ref p r0 in
-  connection_compose_id_right (lower_conn r);
-  A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
-  A.return r
-
-let ref_free #a #b #p #x r =
+let ref_free #b #p #x r =
   // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.PCM
-  Steel.Effect.Atomic.drop ((NonNull?.v r).r `mpts_to` _)
+  A.drop (pts_to _ _)
 
 #pop-options
 
@@ -126,24 +219,39 @@ let unfocus r r' l x =
     (r `pts_to` x)
     (r' `pts_to` l.conn_small_to_large.morph x)
 
+let read_only_share
+  (#a: Type)
+  (#opened: _)
+  (#v: a)
+  (r: GHR.ref _ (RO.pcm_readonly #a))
+: A.SteelGhostT unit opened
+    (GHR.pts_to r (Some v))
+    (fun _ -> GHR.pts_to r (Some v) `star` GHR.pts_to r (Some v))
+= GHR.share r _ (Some v) (Some v)
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
 let split r xy x y =
   let c = raise_pl r in
-  let xy2 = Ghost.hide (c.conn_small_to_large.morph xy) in
-  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
-  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
-  assert (composable (raise_p r) x2 y2);
+  let xy2 = (c.conn_small_to_large.morph xy) in
+  let x2 = (c.conn_small_to_large.morph x) in
+  let y2 = (c.conn_small_to_large.morph y) in
+  assert (P.composable (fstar_pcm_of_pcm (raise_p r)) x2 y2);
+  A.change_equal_slprop (r `pts_to` xy) (r `pts_to0` xy);
   A.change_equal_slprop
-    (r `pts_to` xy)
-    ((NonNull?.v r).r `mpts_to` xy2);
-  Steel.PCMReference.split (NonNull?.v r).r
+    (_ `mpts_to` _)
+    (base_of r `mpts_to` xy2);
+  R.split (base_of r)
     xy2
     x2
     y2;
+  read_only_share (NonNull?.v r).base_type;
   A.change_equal_slprop
-    ((NonNull?.v r).r `mpts_to` x2)
+    (mpts_to (base_of r) x2 `star` GHR.pts_to _ _)
     (r `pts_to` x);
   A.change_equal_slprop
-    ((NonNull?.v r).r `mpts_to` y2)
+    (mpts_to (base_of r) y2 `star` GHR.pts_to _ _)
     (r `pts_to` y)
 
 let mgather
@@ -154,59 +262,46 @@ let mgather
     (fun _ -> mpts_to r (P.op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
-let gather #inames #a #b #p r x y =
+let gather #inames #b #p r x y =
   let c = raise_pl r in
-  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
-  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
-  A.change_equal_slprop
-    (r `pts_to` x)
-    ((NonNull?.v r).r `mpts_to` x2);
-  A.change_equal_slprop
-    (r `pts_to` y)
-    ((NonNull?.v r).r `mpts_to` y2);
-  mgather (NonNull?.v r).r
-    x2
-    y2;
+  let x2 = (c.conn_small_to_large.morph x) in
+  let y2 = (c.conn_small_to_large.morph y) in
+  A.change_equal_slprop (r `pts_to` x) (r `pts_to0` x);
+  A.change_equal_slprop (mpts_to (base_of r) _) (mpts_to (base_of r) x2);
+  A.change_equal_slprop (r `pts_to` y) (r `pts_to0` y);
+  mgather (base_of r) x2 _;
+  GHR.gather (NonNull?.v r).base_type _ _;
   assert (composable (raise_p r) x2 y2);
   assert (
     let x' = c.conn_large_to_small.morph x2 in
     let y' = c.conn_large_to_small.morph y2 in
     composable p x' y' /\
-    Ghost.reveal x == x' /\ Ghost.reveal y == y'
+    x == x' /\ y == y'
   );
-  A.change_equal_slprop _ (r `pts_to` op p x y)
+  A.change_equal_slprop
+    (mpts_to _ _ `star` GHR.pts_to _ _)
+    (r `pts_to` op p x y)
 
-let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
-: Steel 'b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible p x x')
+let ref_read
+  #_ #p #x r
 = let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
-  A.change_equal_slprop (r `pts_to` x) ((NonNull?.v r).r `mpts_to` w);
-  let w' = Steel.PCMReference.read (NonNull?.v r).r w in
-  A.change_equal_slprop ((NonNull?.v r).r `mpts_to` w) (r `pts_to` x);
+  A.change_equal_slprop (r `pts_to` x) (r `pts_to0` x);
+  A.change_equal_slprop (mpts_to _ _) (mpts_to (base_of r) (Ghost.reveal w));
+  let w' = R.read (base_of r) w in
+  A.change_equal_slprop (mpts_to _ _ `star` GHR.pts_to _ _) (r `pts_to` x);
   let x' = (raise_pl r).conn_large_to_small.morph w' in
   compatible_morphism (raise_pl r).conn_large_to_small w w';
+  assert (compatible p x x');
   A.return x'
 
-let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
-: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= let c = raise_pl r in
+let ref_upd #b #p r x y f =
+  let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty (NonNull?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
-
-let as_action (#p:vprop)
-              (#q:vprop)
-              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
-: SteelT unit p (fun x -> q)
-= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
-  let x = Steel.Effect.as_action f in
-  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
-  A.return x
-
-let ref_upd r x y f = as_action (ref_upd_act r x y f)
+  A.change_equal_slprop (r `pts_to` x) (r `pts_to0` x);
+  A.change_equal_slprop (mpts_to _ _) (mpts_to (base_of r) (Ghost.reveal x'));
+  R.upd_gen (base_of r) x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )));
+  A.change_equal_slprop (mpts_to _ _ `star` GHR.pts_to _ _) (r `pts_to` y)
 
 let base_fpu p x y =
   fun _ ->
@@ -214,8 +309,8 @@ let base_fpu p x y =
   y
 
 let pts_to_view_explicit
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -224,8 +319,8 @@ let pts_to_view_explicit
 = hp_of (pts_to r (vw.to_carrier v))
 
 let pts_to_view_explicit_witinv
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -241,7 +336,7 @@ let pts_to_view_explicit_witinv
     let y_ = vw.to_carrier y in
     let x' = c.conn_small_to_large.morph x_ in
     let y' = c.conn_small_to_large.morph y_ in
-    M.pts_to_join (NonNull?.v r).r x' y' m;
+    M.pts_to_join (base_of r) x' y' m;
     let z' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun z' -> compatible (raise_p r) x' z' /\ compatible (raise_p r) y' z') in
     let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_x' -> composable (raise_p r) x' frame_x' /\ op (raise_p r) frame_x' x' == z') in
     let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_y' -> composable (raise_p r) y' frame_y' /\ op (raise_p r) frame_y' y' == z') in
@@ -258,18 +353,12 @@ let pts_to_view_explicit_witinv
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
 
 let pts_to_view_sl
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type u#c)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-: Tot M.slprop
+  r vw
 = M.h_exists (pts_to_view_explicit r vw)
 
-
 let pts_to_view_sel'
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -279,8 +368,8 @@ let pts_to_view_sel'
   Ghost.reveal (Ghost.reveal x)
 
 let pts_to_view_depends_only_on
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -292,8 +381,8 @@ let pts_to_view_depends_only_on
   M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
 
 let pts_to_view_depends_only_on_core
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -305,19 +394,14 @@ let pts_to_view_depends_only_on_core
   M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
 
 let pts_to_view_sel
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-: Tot (selector c (pts_to_view_sl r vw))
+  r vw
 = Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
   Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
   pts_to_view_sel' r vw
 
 let pts_to_view_intro_lemma
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (x: Ghost.erased b)
   (#c: Type0)
   (#can_view_unit: bool)
@@ -335,21 +419,7 @@ let pts_to_view_intro_lemma
   pts_to_view_explicit_witinv r vw
 
 let pts_to_view_intro
-  (#invs: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
-  (#c: Type0)
-  (#can_view_unit: bool)
-  (vw: sel_view p c can_view_unit)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
-: A.SteelGhost unit invs
-    (pts_to r x)
-    (fun _ -> pts_to_view r vw)
-    (fun _ -> vw.to_carrier y == Ghost.reveal x)
-    (fun _ _ h' ->
-      h' (pts_to_view r vw) == Ghost.reveal y
-    )
+  r x vw y
 = A.change_slprop_2
     (pts_to r x)
     (pts_to_view r vw)
@@ -358,10 +428,9 @@ let pts_to_view_intro
       pts_to_view_intro_lemma r x vw y m
     )
 
-
 let pts_to_view_elim_lemma
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -396,8 +465,8 @@ let intro_vdep2 (#opened:_)
 
 let pts_to_view_elim
   (#invs: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -432,7 +501,6 @@ let pts_to_view_elim
     );
   res
 
-
 let compatible_elim'
   (#a: Type u#a)
   (pcm: pcm0 a)
@@ -445,8 +513,8 @@ let compatible_elim'
 = compatible_elim pcm x y
 
 let ref_read_sel
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -468,11 +536,10 @@ let ref_read_sel
   pts_to_view_intro r _v vw res;
   A.return res
 
-
 // [@@__steel_reduce__; __reduce__]
 let pts_to_view_or_null0
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -493,8 +560,8 @@ let pts_to_view_or_null_sel
 
 let pts_to_view_or_null_prop_null
   (#inames: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -531,8 +598,8 @@ let pts_to_view_or_null_prop_null
 #restart-solver
 let pts_to_view_or_null_prop_not_null
   (#inames: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -568,8 +635,8 @@ let pts_to_view_or_null_prop_not_null
 
 let pts_to_view_or_null_prop
   (#inames: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -594,28 +661,28 @@ let is_null
   A.return (Null? r)
 
 let intro_pts_to_view_or_null_null
-  a #b #p #c vw
+  #_ #b #p #c vw
 =
   A.intro_vrewrite emp (fun _ -> None <: option c);
   A.change_equal_slprop
     (emp `vrewrite` (fun _ -> None <: option c))
-    (pts_to_view_or_null0 (null a p) vw);
+    (pts_to_view_or_null0 (null p) vw);
   A.change_slprop_rel
-    (pts_to_view_or_null0 (null a p) vw)
-    (pts_to_view_or_null (null a p) vw)
+    (pts_to_view_or_null0 (null p) vw)
+    (pts_to_view_or_null (null p) vw)
     (fun x y -> x == y)
     (fun _ -> ())
 
 let elim_pts_to_view_or_null_null
-  a #b #p #c vw
+  #_ #b #p #c vw
 =
   A.change_slprop_rel
-    (pts_to_view_or_null (null a p) vw)
-    (pts_to_view_or_null0 (null a p) vw)
+    (pts_to_view_or_null (null p) vw)
+    (pts_to_view_or_null0 (null p) vw)
     (fun x y -> x == y)
     (fun _ -> ());
   A.change_equal_slprop
-    (pts_to_view_or_null0 (null a p) vw)
+    (pts_to_view_or_null0 (null p) vw)
     (emp `vrewrite` (fun _ -> None <: option c));
   A.elim_vrewrite emp (fun _ -> None <: option c)
 
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index 4f8e564e703..d7ba85bfcef 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -3,66 +3,66 @@ open FStar.FunctionalExtensionality
 open Steel.C.PCM
 open Steel.C.Connection
 
+module A = Steel.Effect.Atomic
+
 #push-options "--print_universes"
 
-(** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
-val ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
+(** A [ptr b] is a (maybe null) pointer to some value of type b. *)
+val ptr (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
 
-val null (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a p)
+val null (#b: Type u#b) (p: pcm b) : Tot (ptr p)
 
-val ptr_is_null (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null a p))
+val ptr_is_null (#b: Type u#b) (#p: pcm b) (r: ptr p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null p))
 
 let refine (a: Type) (p: (a -> prop)) : Tot Type =
   (x: a { p x })
 
 let not_null
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b) (r: ptr p)
 : Tot prop
 = ptr_is_null r == false
 
 (** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
-let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
-  refine (ptr a q) (not_null #a #b #q)
+let ref (#b: Type u#b) (q: pcm b) : Type u#b =
+  refine (ptr q) (not_null #b #q)
 
 open Steel.Effect
 
 (** r points to PCM carrier value v *)
 val pts_to
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p) ([@@@smt_fallback] v: b)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p) ([@@@smt_fallback] v: b)
 : vprop
 
 (** Given a reference to an element of PCM p and a connection l from p to q,
     [ref_focus r l] is a reference to an element of q. The intuition is that
     q represents a "part of" p (e.g. a struct field, union case, or array slice). *)
 val ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref a p) (#q: pcm c) (l: connection p q)
-: GTot (ref a q)
+  (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref p) (#q: pcm c) (l: connection p q)
+: GTot (ref q)
 
 val ref_focus_id
-  (#a:Type) (#b:Type) (#p: pcm b)
-  (r: ref a p)
+  (#b:Type) (#p: pcm b)
+  (r: ref p)
 : Lemma
   (ref_focus r (connection_id _) == r)
 
-val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
+val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref p)
   (l: connection p q) (m: connection q s)
 : Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
   [SMTPatOr [
     [SMTPat (ref_focus (ref_focus r l) m)]; 
     [SMTPat (ref_focus r (l `connection_compose` m))]]]
 
-module A = Steel.Effect.Atomic
-
 val freeable
-  (#a: Type0) (#b:Type0) (#p: pcm b) (r: ref a p)
+  (#b:Type0) (#p: pcm b) (r: ref p)
 : Tot prop
 
 (** Allocate a reference containing value x. *)
 val ref_alloc
   (#a:Type0) (p: pcm a) (x: a)
-: Steel (ref a p)
+: Steel (ref p)
     emp
     (fun r -> r `pts_to` x)
     (requires fun _ -> p_refine p x)
@@ -70,7 +70,7 @@ val ref_alloc
 
 (** Free a "base" (freeable) reference containing a "whole" (p_refine) value x. *)
 val ref_free
-  (#a #b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+  (#b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref p)
 : Steel unit
     (r `pts_to` x)
     (fun _ -> emp)
@@ -79,19 +79,19 @@ val ref_free
 
 
 (** Take a pointer to a "substructure" of a reference. *)
-val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
+val gfocus (#inames: _) (#p: pcm 'b) (r: ref p)
   (#q: pcm 'c)
-  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+  (l: connection p q) (s: 'b) (x: 'c)
 : A.SteelGhost unit inames
     (r `pts_to` s)
     (fun _ -> ref_focus r l `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ -> s == l.conn_small_to_large.morph x)
     (fun _ _ _ -> True)
 
-val focus (#opened: _) (#p: pcm 'b) (r: ref 'a p)
+val focus (#opened: _) (#p: pcm 'b) (r: ref p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: A.SteelAtomicBase (ref 'a q)
+: A.SteelAtomicBase (ref q)
     false opened A.Unobservable
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
@@ -104,8 +104,8 @@ module M = Steel.Memory
 val unfocus (#opened:M.inames)
   (#p: pcm 'b)
   (#q: pcm 'c)
-  (r: ref 'a q) (r': ref 'a p)
-  (l: connection p q) (x: Ghost.erased 'c)
+  (r: ref q) (r': ref p)
+  (l: connection p q) (x: 'c)
 : A.SteelGhost unit opened
     (r `pts_to` x)
     (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
@@ -113,22 +113,22 @@ val unfocus (#opened:M.inames)
     (ensures fun _ _ _ -> True)
 
 (** Split the permissions on a reference into two halves. *)
-val split (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+val split (#inames: _) (#b:Type) (#p: pcm b) (r: ref p) (xy x y: b)
 : A.SteelGhost unit inames
     (r `pts_to` xy)
     (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
+    (fun _ -> composable p x y /\ xy == (op p x y))
     (fun _ _ _ -> True)
 
 (** Inverse of split. *)
-val gather (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+val gather (#inames: _) (#b:Type) (#p: pcm b) (r: ref p) (x y: b)
 : A.SteelGhostT (_:unit{composable p x y}) inames
     ((r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> r `pts_to` op p x y)
 
 (** Read a PCM carrier value. *)
 val ref_read
-  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+  (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref p)
 : Steel b
     (r `pts_to` x)
     (fun _ -> r `pts_to` x)
@@ -137,8 +137,8 @@ val ref_read
 
 (** Write a PCM carrier value. *)
 val ref_upd
-  (#a:Type) (#b:Type) (#p: pcm b)
-  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
+  (#b:Type) (#p: pcm b)
+  (r: ref p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 
 (** Construct a write from a frame-preserving update. *)
@@ -221,16 +221,16 @@ let sel_view_inv
   ()
 
 val pts_to_view_sl
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : Tot (M.slprop u#1)
 
 val pts_to_view_sel
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -238,8 +238,8 @@ val pts_to_view_sel
 
 [@@__steel_reduce__]
 let pts_to_view'
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -252,8 +252,8 @@ let pts_to_view'
 
 [@@__steel_reduce__]
 let pts_to_view 
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -267,25 +267,25 @@ let pts_to_view
 
 val pts_to_view_intro
   (#invs: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
-  (x: Ghost.erased b)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
+  (x: b)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
-  (y: Ghost.erased c) // necessary because to_view may erase information from x
+  (y: c) // necessary because to_view may erase information from x
 : A.SteelGhost unit invs
     (pts_to r x)
     (fun _ -> pts_to_view r vw)
-    (fun _ -> vw.to_carrier y == Ghost.reveal x)
+    (fun _ -> vw.to_carrier y == x)
     (fun _ _ h' ->
-      h' (pts_to_view r vw) == Ghost.reveal y
+      h' (pts_to_view r vw) == y
     )
 
 val pts_to_view_elim
   (#invs: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -300,8 +300,8 @@ val pts_to_view_elim
     )
 
 val ref_read_sel
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -319,16 +319,16 @@ val ref_read_sel
 /// Pointers (and the null pointer)
 
 val pts_to_view_or_null_sl
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type u#0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : Tot (M.slprop u#1)
 
 val pts_to_view_or_null_sel
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -336,8 +336,8 @@ val pts_to_view_or_null_sel
 
 [@@__steel_reduce__]
 let pts_to_view_or_null'
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -350,8 +350,8 @@ let pts_to_view_or_null'
 
 [@@__steel_reduce__]
 let pts_to_view_or_null
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ptr a p)
+  (#b: Type u#b) (#p: pcm b)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -359,9 +359,9 @@ let pts_to_view_or_null
 = VUnit (pts_to_view_or_null' r vw)
 
 val is_null
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (#b: Type u#b) (#p: pcm b)
   (#opened: _)
-  (r: ptr a p)
+  (r: ptr p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -378,30 +378,30 @@ val is_null
 
 val intro_pts_to_view_or_null_null
   (#inames: _)
-  (a: Type) (#b: Type) (#p: pcm b)
+  (#b: Type) (#p: pcm b)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : A.SteelGhost unit inames
     emp
-    (fun _ -> pts_to_view_or_null (null a p) vw)
+    (fun _ -> pts_to_view_or_null (null p) vw)
     (requires (fun _ -> True))
-    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null a p) vw) == None))
+    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null p) vw) == None))
 
 val elim_pts_to_view_or_null_null
   (#inames: _)
-  (a: Type) (#b: Type) (#p: pcm b)
+  (#b: Type) (#p: pcm b)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : A.SteelGhostT unit inames
-    (pts_to_view_or_null (null a p) vw)
+    (pts_to_view_or_null (null p) vw)
     (fun _ -> emp)
 
 val intro_pts_to_view_or_null_not_null
   (#inames: _)
-  (#a: Type) (#b: Type) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -413,8 +413,8 @@ val intro_pts_to_view_or_null_not_null
 
 val elim_pts_to_view_or_null_not_null
   (#inames: _)
-  (#a: Type) (#b: Type) (#p: pcm b)
-  (r: ref a p)
+  (#b: Type) (#p: pcm b)
+  (r: ref p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index 51c42e544a4..ce77264fbce 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -7,40 +7,39 @@ open Steel.Effect.Atomic
 #push-options "--print_universes"
 
 // [@@__reduce__]
-let ptr (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+let ptr (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
 : Type u#b
-= ptr a q
+= ptr q
 
 // [@@__reduce__]
 inline_for_extraction
-let ref (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+let ref (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
 : Tot (Type u#b)
 =
-  (x: ptr a view_t q { not_null x })
+  (x: ptr view_t q { not_null x })
 
 unfold
 let ref_of_ref
-  (#a: Type u#0) (#view_t: Type u#0) (#b: Type u#b) (#q: pcm b)
-  (r: ref a view_t q)
-: Tot (Steel.C.Ref.ref a q)
+  (#view_t: Type u#0) (#b: Type u#b) (#q: pcm b)
+  (r: ref view_t q)
+: Tot (Steel.C.Ref.ref q)
 = r
 
 [@@__steel_reduce__] // ; __reduce__]
 let pts_to_view
-  (#a: Type u#0) 
   (#view_t: Type u#0)
   (#view_t': Type u#0)
   (#b: Type u#b) (#p: pcm b)
-  (r: ref a view_t p) (view: sel_view p view_t' false)
+  (r: ref view_t p) (view: sel_view p view_t' false)
 : vprop
 = r `pts_to_view` view
 
 let ref_read
-  (#a: Type u#0) (#b: Type u#b)
+  (#b: Type u#b)
   (#view_t: Type u#0)
   (#p: pcm b)
   (#vw: sel_view p view_t false)
-  (r: ref a view_t p)
+  (r: ref view_t p)
 : Steel view_t
   (r `pts_to_view` vw)
   (fun _ -> r `pts_to_view` vw)
@@ -51,21 +50,20 @@ let ref_read
   ))
 = ref_read_sel r vw
 
-let null (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a view_t p) = null a p
+let null (view_t: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr view_t p) = null p
 
 [@@__steel_reduce__] // ; __reduce__]
 let pts_to_view_or_null
-  (#a: Type u#0) 
   (#view_t: Type u#0)
   (#view_t': Type u#0)
   (#b: Type u#b) (#p: pcm b)
-  (r: ptr a view_t p) (view: sel_view p view_t' false)
+  (r: ptr view_t p) (view: sel_view p view_t' false)
 : vprop
 = r `pts_to_view_or_null` view
 
 let is_null
-  (#a: Type u#0) (#b: Type u#b) (#c: Type0) (#opened: _) (#p: pcm b)
-  (r: ptr a c p)
+  (#b: Type u#b) (#c: Type0) (#opened: _) (#p: pcm b)
+  (r: ptr c p)
   (vw: sel_view p c false)
 : SteelAtomicBase bool false opened Unobservable
     (pts_to_view_or_null r vw)
@@ -81,21 +79,21 @@ let is_null
 
 let intro_pts_to_view_or_null_null
   (#inames: _)
-  (a: Type) (#b: Type) (#p: pcm b)
+  (#b: Type) (#p: pcm b)
   (#c: Type0)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     emp
-    (fun _ -> pts_to_view_or_null (null a c p) vw)
+    (fun _ -> pts_to_view_or_null (null c p) vw)
     (requires (fun _ -> True))
-    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null a c p) vw) == None))
-= intro_pts_to_view_or_null_null a vw
+    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null c p) vw) == None))
+= intro_pts_to_view_or_null_null vw
 
 let elim_pts_to_view_or_null_null
   (#inames: _)
-  (a: Type) (#b: Type) (#p: pcm b)
+  (#b: Type) (#p: pcm b)
   (#c: Type0)
-  (r: ptr a c p)
+  (r: ptr c p)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     (pts_to_view_or_null r vw)
@@ -104,14 +102,14 @@ let elim_pts_to_view_or_null_null
     (ensures (fun _ _ _ -> True))
 = change_equal_slprop
     (pts_to_view_or_null r vw)
-    (pts_to_view_or_null (null a c p) vw);
-  elim_pts_to_view_or_null_null a vw
+    (pts_to_view_or_null (null c p) vw);
+  elim_pts_to_view_or_null_null vw
 
 let intro_pts_to_view_or_null_not_null
   (#inames: _)
-  (#a: Type) (#b: Type) (#p: pcm b)
+  (#b: Type) (#p: pcm b)
   (#c: Type0)
-  (r: ref a c p)
+  (r: ref c p)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     (pts_to_view r vw)
@@ -122,9 +120,9 @@ let intro_pts_to_view_or_null_not_null
 
 let elim_pts_to_view_or_null_not_null
   (#inames: _)
-  (#a: Type) (#b: Type) (#p: pcm b)
+  (#b: Type) (#p: pcm b)
   (#c: Type0)
-  (r: ref a c p)
+  (r: ref c p)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     (pts_to_view_or_null r vw)
@@ -134,10 +132,10 @@ let elim_pts_to_view_or_null_not_null
 = elim_pts_to_view_or_null_not_null r vw
 
 let freeable
-  (#a: Type u#0) (#view_t: Type u#0) (#b: Type u#0) (#q: pcm b)
-  (r: ref a view_t q)
+  (#view_t: Type u#0) (#b: Type u#0) (#q: pcm b)
+  (r: ref view_t q)
 : Tot prop
-= freeable (r <: Steel.C.Ref.ref a q)
+= freeable (r <: Steel.C.Ref.ref q)
 
 (* Operations on views *)
 
@@ -164,8 +162,7 @@ let intro_refine_view'
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (#base: Type)
-  (r: ref base view p)
+  (r: ref view p)
 : SteelGhost unit opened
     (pts_to_view r vw)
     (fun _ -> pts_to_view r (refine_view vw pr))
@@ -188,9 +185,8 @@ let intro_refine_view
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (#base: Type)
-  (r: ref base view p)
-: SteelAtomicBase (ref base (refine view pr) p) false opened Unobservable
+  (r: ref view p)
+: SteelAtomicBase (ref (refine view pr) p) false opened Unobservable
     (pts_to_view r vw)
     (fun r' -> pts_to_view r' (refine_view vw pr))
     (fun h -> pr (h (pts_to_view r vw)))
@@ -201,7 +197,7 @@ let intro_refine_view
       x == h' (pts_to_view r' (refine_view vw pr))
     )
 = intro_refine_view' vw pr r;
-  let r' : ref base (refine view pr) p = r in
+  let r' : ref (refine view pr) p = r in
   change_equal_slprop
     (pts_to_view r (refine_view vw pr))
     (pts_to_view r' (refine_view vw pr));
@@ -214,8 +210,7 @@ let elim_refine_view'
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (#base: Type)
-  (r: ref base (refine view pr) p)
+  (r: ref (refine view pr) p)
 : SteelGhost unit opened
     (pts_to_view r (refine_view vw pr))
     (fun _ -> pts_to_view r vw)
@@ -238,9 +233,8 @@ let elim_refine_view
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (#base: Type)
-  (r: ref base (refine view pr) p)
-: SteelAtomicBase (ref base view p) false opened Unobservable
+  (r: ref (refine view pr) p)
+: SteelAtomicBase (ref view p) false opened Unobservable
     (pts_to_view r (refine_view vw pr))
     (fun r' -> pts_to_view r' vw)
     (fun h -> True)
@@ -251,7 +245,7 @@ let elim_refine_view
       x == h (pts_to_view r (refine_view vw pr))
     )
 = elim_refine_view' vw pr r;
-  let r' : ref base view p = r in
+  let r' : ref view p = r in
   change_equal_slprop
     (pts_to_view r vw)
     (pts_to_view r' vw);
@@ -286,8 +280,7 @@ let intro_rewrite_view'
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (#base: _)
-  (r: ref base view p)
+  (r: ref view p)
   (x' : Ghost.erased view')
 : SteelGhost unit opened
     (pts_to_view r vw)
@@ -312,10 +305,9 @@ let intro_rewrite_view
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (#base: _)
-  (r: ref base view p)
+  (r: ref view p)
   (x' : Ghost.erased view')
-: SteelAtomicBase (ref base view' p) false opened Unobservable
+: SteelAtomicBase (ref view' p) false opened Unobservable
     (pts_to_view r vw)
     (fun r' -> pts_to_view r' (rewrite_view vw f g prf))
     (fun h -> h (pts_to_view r vw) == g x')
@@ -324,7 +316,7 @@ let intro_rewrite_view
       h' (pts_to_view r' (rewrite_view vw f g prf)) == Ghost.reveal x'
     )
 = intro_rewrite_view' vw f g prf r x';
-  let r' : ref base view' p = r in
+  let r' : ref view' p = r in
   change_equal_slprop
     (pts_to_view r (rewrite_view vw f g prf))
     (pts_to_view r' (rewrite_view vw f g prf));
@@ -340,8 +332,7 @@ let elim_rewrite_view'
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (#base: _)
-  (r: ref base view' p)
+  (r: ref view' p)
 : SteelGhost unit opened
     (pts_to_view r (rewrite_view vw f g prf))
     (fun _ -> pts_to_view r vw)
@@ -368,9 +359,8 @@ let elim_rewrite_view
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (#base: _)
-  (r: ref base view' p)
-: SteelAtomicBase (ref base view p) false opened Unobservable
+  (r: ref view' p)
+: SteelAtomicBase (ref view p) false opened Unobservable
     (pts_to_view r (rewrite_view vw f g prf))
     (fun r' -> pts_to_view r' vw)
     (fun _ -> True)
@@ -381,7 +371,7 @@ let elim_rewrite_view
       f (Ghost.reveal x') == Ghost.reveal x
     )
 = elim_rewrite_view' vw f g prf r;
-  let r' : ref base view p = r in
+  let r' : ref view p = r in
   change_equal_slprop
     (pts_to_view r vw)
     (pts_to_view r' vw);
diff --git a/ulib/experimental/Steel.C.Struct.fst b/ulib/experimental/Steel.C.Struct.fst
index ff47a9bcfd1..67f002cb427 100644
--- a/ulib/experimental/Steel.C.Struct.fst
+++ b/ulib/experimental/Steel.C.Struct.fst
@@ -299,10 +299,10 @@ let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
 
 let addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
+  (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref (prod_pcm p)) (k:a)
   (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
+: Steel (ref (p k))
     (r `pts_to` xs)
     (fun s ->
       (r `pts_to` struct_without_field p k xs) `star` 
@@ -350,8 +350,8 @@ let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
 let unaddr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (prod_pcm p))
+  (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref (p k)) (r: ref (prod_pcm p))
   (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
 : Steel unit
     ((r `pts_to` xs) `star` (r' `pts_to` x))
diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
index b8b5b93569f..cbed69903d2 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ b/ulib/experimental/Steel.C.StructLiteral.fst
@@ -246,8 +246,8 @@ let extract_field_unextracted'
 val addr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (fields.get_field field).pcm)
+  (p: ref (struct_pcm tag fields))
+: Steel (ref (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
@@ -267,7 +267,7 @@ val addr_of_struct_field_ref'
         h' (q `pts_to_view` (fields.get_field field).view))
 
 #push-options "--z3rlimit 30"
-let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
+let addr_of_struct_field_ref' #tag #fields #excluded field p =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -287,7 +287,7 @@ let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
   return q
 #pop-options
 
-let addr_of_struct_field_ref #a #tag #fields #excluded field p =
+let addr_of_struct_field_ref #tag #fields #excluded field p =
   addr_of_struct_field_ref' field p
 
 let struct'_with_field
@@ -336,7 +336,7 @@ let extract_field_with_field
     `feq` v)
 
 #push-options "--z3rlimit 50"
-let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
+let unaddr_of_struct_field_ref' #tag #fields #excluded field p q =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -349,7 +349,7 @@ let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
   let t: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  unaddr_of_struct_field #_ #_ #_ #(struct_pcms fields) field q p s t;
+  unaddr_of_struct_field #_ #_ #(struct_pcms fields) field q p s t;
   let h1: squash (excluded field == true) = () in
   let h2: squash (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v) = () in
   let h3: squash (Ghost.reveal t == (fields.get_field field).view.to_carrier w) = () in
@@ -370,6 +370,6 @@ let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
 
 let dummy_def = ()
 
-let unaddr_of_struct_field_ref #a #tag #fields #excluded field p q =
+let unaddr_of_struct_field_ref #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
 #pop-options
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index 40ac19a4f70..83db77647c6 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -268,13 +268,12 @@ val extract_field_unextracted'
 val addr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (fields.get_field field).pcm)
+  (p: ref (struct_pcm tag fields))
+: Steel (ref (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
                   q
@@ -295,8 +294,8 @@ val addr_of_struct_field_ref
 val unaddr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (q: ref 'a (fields.get_field field).pcm)
+  (p: ref (struct_pcm tag fields))
+  (q: ref (fields.get_field field).pcm)
 : Steel unit
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (q `pts_to_view` (fields.get_field field).view))
@@ -322,12 +321,11 @@ val dummy_def : unit
 val unaddr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-  (q: ref 'a (fields.get_field field).pcm)
+  (p: ref (struct_pcm tag fields))
+  (q: ref (fields.get_field field).pcm)
 : Steel unit
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
                   q
@@ -359,13 +357,12 @@ let addr_of_struct_field''
   (field: field_of fields{
     return_view_type == (fields.get_field field).view_type /\
     return_carrier == (fields.get_field field).carrier})
-  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
-: Steel (ref 'a return_view_type #return_carrier (fields.get_field field).pcm)
+  (p: ref (struct tag fields) (struct_pcm tag fields))
+: Steel (ref return_view_type #return_carrier (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -384,7 +381,7 @@ let addr_of_struct_field''
         snd (extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded))) ==
          h' (q `pts_to_view` (fields.get_field field).view))
-= addr_of_struct_field_ref #'a #tag #fields #excluded field p
+= addr_of_struct_field_ref #tag #fields #excluded field p
 
 (** Take the address of a field of a struct.
     The above definitions are set up so that calls to addr_of_struct_field are erased to calls to addr_of_struct_field'' with
@@ -402,8 +399,8 @@ inline_for_extraction noextract
 let addr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
-: Steel (ref 'a
+  (p: ref (struct tag fields) (struct_pcm tag fields))
+: Steel (ref
           (norm simplify_typedefs (fields.get_field field).view_type)
           #(norm simplify_typedefs (fields.get_field field).carrier)
           (fields.get_field field).pcm)
@@ -411,7 +408,6 @@ let addr_of_struct_field
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -438,14 +434,13 @@ let addr_of_struct_field
 let unaddr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
-  (q: ref 'a
+  (p: ref (struct tag fields) (struct_pcm tag fields))
+  (q: ref
     (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
     (fields.get_field field).pcm)
 : Steel unit
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
diff --git a/ulib/experimental/Steel.C.Union.fst b/ulib/experimental/Steel.C.Union.fst
index c0060f8a353..b4e9d9fc933 100644
--- a/ulib/experimental/Steel.C.Union.fst
+++ b/ulib/experimental/Steel.C.Union.fst
@@ -458,10 +458,10 @@ let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 = assert (xs `feq` field_to_union_f p k (xs k))
 
 let addr_of_union_field
-  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
-  (r: ref base (union_pcm p)) (k:a)
+  (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref (union_pcm p)) (k:a)
   (xs: Ghost.erased (union p))
-: Steel (ref base (p k))
+: Steel (ref (p k))
     (r `pts_to` xs)
     (fun r' -> r' `pts_to` Ghost.reveal xs k)
     (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
@@ -474,8 +474,8 @@ let addr_of_union_field
 
 module M = Steel.Memory 
 let unaddr_of_union_field
-  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (union_pcm p))
+  (#opened:M.inames) (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref (p k)) (r: ref (union_pcm p))
   (x: Ghost.erased (b k))
 : A.SteelGhost unit opened
     (r' `pts_to` x)
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
index 2b8844b8bd1..83251e22943 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fst
+++ b/ulib/experimental/Steel.C.UnionLiteral.fst
@@ -134,14 +134,13 @@ open Steel.C.Reference
 let addr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
-: Steel (ref 'a
+  (p: ref (union tag fields) (union_pcm tag fields))
+: Steel (ref
           (fields.get_field field).view_type
           (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
-                  #'a
                   #(fields.get_field field).view_type
                   #(fields.get_field field).view_type
                   #(fields.get_field field).carrier
@@ -161,7 +160,7 @@ let addr_of_union_field'
     pts_to_view_elim p (union_view tag fields)
   in
   //  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
-  let q = Steel.C.Union.addr_of_union_field #'a #_ #_ #(union_pcms fields) p field s in
+  let q = Steel.C.Union.addr_of_union_field #_ #_ #(union_pcms fields) p field s in
 //  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   pts_to_view_intro q (Ghost.reveal s field)
     (fields.get_field field).view
@@ -170,17 +169,16 @@ let addr_of_union_field'
   return q
 #pop-options
 
-let addr_of_union_field'' #a return_view_type return_carrier tag fields field p =
-  addr_of_union_field' #a #tag #fields field p
+let addr_of_union_field'' return_view_type return_carrier tag fields field p =
+  addr_of_union_field' #tag #fields field p
 
 let unaddr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
-  (q: ref 'a (fields.get_field field).view_type (fields.get_field field).pcm)
+  (p: ref (union tag fields) (union_pcm tag fields))
+  (q: ref (fields.get_field field).view_type (fields.get_field field).pcm)
 : Steel unit
     (pts_to_view u#0
-                 #'a
                  #(fields.get_field field).view_type
                  #(fields.get_field field).view_type
                  #(fields.get_field field).carrier
@@ -198,15 +196,15 @@ let unaddr_of_union_field'
   let s: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  Steel.C.Union.unaddr_of_union_field #_ #_ #_ #_ #(union_pcms fields) field q p s;
+  Steel.C.Union.unaddr_of_union_field #_ #_ #_ #(union_pcms fields) field q p s;
   pts_to_view_intro p
     (field_to_union_f (union_pcms fields) field s)
     (union_view tag fields)
     (|field, Ghost.reveal v|);
   return ()
 
-let unaddr_of_union_field #a #tag #fields field p q =
-  unaddr_of_union_field' #a #tag #fields field p q
+let unaddr_of_union_field #tag #fields field p q =
+  unaddr_of_union_field' #tag #fields field p q
 
 #restart-solver
 #push-options "--z3rlimit 64"
@@ -242,7 +240,7 @@ let exclusive_refine_union_field
 let switch_union_field''
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (p: ref (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
@@ -291,7 +289,7 @@ let switch_union_field'
   (new_value_ty: Type0) (tag: Type0) (fields: c_fields)
   (field: field_of fields{new_value_ty == (fields.get_field field).view_type})
   (new_value: new_value_ty)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (p: ref (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
@@ -305,4 +303,4 @@ let switch_union_field'
     (ensures fun _ _ h' ->
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
         == (|field, new_value|))
-= switch_union_field'' #'a #tag #fields field new_value p
+= switch_union_field'' #tag #fields field new_value p
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fsti b/ulib/experimental/Steel.C.UnionLiteral.fsti
index 7d45f194042..2daa20cba0e 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fsti
+++ b/ulib/experimental/Steel.C.UnionLiteral.fsti
@@ -99,12 +99,11 @@ val addr_of_union_field''
   (field: field_of fields{
     return_view_type == (fields.get_field field).view_type /\
     return_carrier == (fields.get_field field).carrier})
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
-: Steel (ref 'a return_view_type #return_carrier (fields.get_field field).pcm)
+  (p: ref (union tag fields) (union_pcm tag fields))
+: Steel (ref return_view_type #return_carrier (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -125,15 +124,14 @@ inline_for_extraction noextract
 let addr_of_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
-: Steel (ref 'a
+  (p: ref (union tag fields) (union_pcm tag fields))
+: Steel (ref
           (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
           #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
           (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
-                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -155,11 +153,10 @@ let addr_of_union_field
 val unaddr_of_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
-  (q: ref 'a (fields.get_field field).view_type (fields.get_field field).pcm)
+  (p: ref (union tag fields) (union_pcm tag fields))
+  (q: ref (fields.get_field field).view_type (fields.get_field field).pcm)
 : Steel unit
     (pts_to_view u#0
-                 #'a
                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -176,7 +173,7 @@ val switch_union_field'
   (new_value_ty: Type0) (tag: Type0) (fields: c_fields)
   (field: field_of fields{new_value_ty == (fields.get_field field).view_type})
   (new_value: new_value_ty)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (p: ref (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
@@ -196,7 +193,7 @@ noextract inline_for_extraction
 let switch_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
-  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (p: ref (union tag fields) (union_pcm tag fields))
   // TODO it would be nice permute the arguments so that their order matches the C code p->field = new_value
 : Steel unit
     (p `pts_to_view` union_view tag fields)
diff --git a/ulib/experimental/Steel.Effect.Common.fsti b/ulib/experimental/Steel.Effect.Common.fsti
index 4a1fef34e3e..8be125fd71a 100644
--- a/ulib/experimental/Steel.Effect.Common.fsti
+++ b/ulib/experimental/Steel.Effect.Common.fsti
@@ -3190,7 +3190,7 @@ let ( >--> ) (i:iname) (p:vprop) : prop = i >--> (hp_of p)
 let inv (p:vprop) = i:Ghost.erased iname{reveal i >--> p}
 
 /// Ghost check to determing whether invariant [i] belongs to the set of opened invariants [e]
-let mem_inv (#p:vprop) (e:inames) (i:inv p) : erased bool = elift2 (fun e i -> Set.mem i e) e i
+let mem_inv (e:inames) (i:iname) : erased bool = elift2 (fun e i -> Set.mem i e) e i
 
 /// Adding invariant [i] to the set of opened invariants [e]
 noextract
diff --git a/ulib/experimental/Steel.PCMReadOnly.fst b/ulib/experimental/Steel.PCMReadOnly.fst
new file mode 100644
index 00000000000..2b1bfbb36a7
--- /dev/null
+++ b/ulib/experimental/Steel.PCMReadOnly.fst
@@ -0,0 +1,34 @@
+module Steel.PCMReadOnly
+include FStar.PCM
+
+let readonly (a:Type u#a) = option a
+let composable #a : symrel (readonly a) =
+  fun (f0 f1:readonly a) ->
+    match f0, f1 with
+    | None, _
+    | _, None -> True
+    | Some x0, Some x1 -> x0==x1
+let compose #a (f0:readonly a) (f1:readonly a{composable f0 f1}) : readonly a =
+  match f0, f1 with
+  | None, f
+  | f, None -> f
+  | Some x0, Some _ -> Some x0
+
+let pcm_readonly #a : pcm (readonly a) = {
+  p = {
+         composable = composable;
+         op = compose;
+         one = None
+      };
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun _ -> True)
+}
+
+let mk_frame_preserving_upd
+  (#a: Type)
+  (v0: a)
+: Tot (frame_preserving_upd pcm_readonly (Some v0) (Some v0))
+= fun _ -> Some v0

From b0e03e2a89e673c3fb43974028d203fb4643e3d7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 2 Sep 2022 19:32:25 -0700
Subject: [PATCH 314/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 837 +++++++++++++++++++++-
 1 file changed, 822 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index a1e1c1dc8d7..5023c40c903 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,47 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1017,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,16 +1055,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type env1 arg in TConstBuf uu___
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -964,13 +1126,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -983,19 +1146,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1600,6 +1780,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1693,11 +1916,31 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2399,6 +2642,396 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Reference.null" ->
+          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2781,7 +3414,126 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -2900,6 +3652,61 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some
+              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
+               ((FStar_Extraction_ML_Syntax.MLTY_Named
+                ([], view_type_name))::[], p));
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
+            FStar_Extraction_ML_Syntax.mllb_def = fields;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
+            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
+            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
+            ((let uu___6 =
+                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
+              FStar_Compiler_Util.print1
+                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
+             (let rec parse_fields fields1 =
+                match fields1 with
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_Name p1;
+                    FStar_Extraction_ML_Syntax.mlty = uu___6;
+                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
+                    let uu___8 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
+                    FStar_Compiler_Util.print_endline "End of fields"
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_App
+                      ({
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Name p1;
+                         FStar_Extraction_ML_Syntax.mlty = uu___6;
+                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
+                       {
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Const
+                           (FStar_Extraction_ML_Syntax.MLC_String name1);
+                         FStar_Extraction_ML_Syntax.mlty = uu___8;
+                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
+                    FStar_Extraction_ML_Syntax.mlty = uu___10;
+                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
+                    let uu___12 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
+                    ((let uu___13 =
+                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
+                          typedef in
+                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
+                        uu___13);
+                     parse_fields fields2)
+                | uu___6 ->
+                    failwith "Couldn't parse fields from struct_fields" in
+              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From af0751765d67bbaa2011b6e2bb49add514209538 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 18 Oct 2022 11:22:06 -0700
Subject: [PATCH 315/513] Revert "snap"

This reverts commit b0e03e2a89e673c3fb43974028d203fb4643e3d7.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 837 +---------------------
 1 file changed, 15 insertions(+), 822 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 5023c40c903..a1e1c1dc8d7 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,47 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1017,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1055,18 +895,16 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "LowStar.ConstBuffer.const_buffer" ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1126,14 +964,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1146,36 +983,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1780,49 +1600,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1916,31 +1693,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2642,396 +2399,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Reference.null" ->
-          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3414,126 +2781,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -3652,61 +2900,6 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some
-              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
-               ((FStar_Extraction_ML_Syntax.MLTY_Named
-                ([], view_type_name))::[], p));
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-            FStar_Extraction_ML_Syntax.mllb_def = fields;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
-            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
-            ((let uu___6 =
-                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
-              FStar_Compiler_Util.print1
-                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
-             (let rec parse_fields fields1 =
-                match fields1 with
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_Name p1;
-                    FStar_Extraction_ML_Syntax.mlty = uu___6;
-                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
-                    let uu___8 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
-                    FStar_Compiler_Util.print_endline "End of fields"
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_App
-                      ({
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Name p1;
-                         FStar_Extraction_ML_Syntax.mlty = uu___6;
-                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                       {
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Const
-                           (FStar_Extraction_ML_Syntax.MLC_String name1);
-                         FStar_Extraction_ML_Syntax.mlty = uu___8;
-                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
-                    FStar_Extraction_ML_Syntax.mlty = uu___10;
-                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
-                    let uu___12 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
-                    ((let uu___13 =
-                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
-                          typedef in
-                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
-                        uu___13);
-                     parse_fields fields2)
-                | uu___6 ->
-                    failwith "Couldn't parse fields from struct_fields" in
-              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From d141e88fef98978116eb73b00cd0728f156d6382 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 18 Oct 2022 12:08:00 -0700
Subject: [PATCH 316/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 838 +++++++++++++++++++++-
 1 file changed, 823 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 196817624df..6ae9a687184 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,47 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1017,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,18 +1055,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -966,13 +1129,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -985,19 +1149,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1605,6 +1786,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1698,11 +1922,31 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2428,6 +2672,396 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Reference.null" ->
+          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2810,7 +3444,126 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -2929,6 +3682,61 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some
+              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
+               ((FStar_Extraction_ML_Syntax.MLTY_Named
+                ([], view_type_name))::[], p));
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
+            FStar_Extraction_ML_Syntax.mllb_def = fields;
+            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
+            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
+            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
+            ((let uu___6 =
+                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
+              FStar_Compiler_Util.print1
+                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
+             (let rec parse_fields fields1 =
+                match fields1 with
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_Name p1;
+                    FStar_Extraction_ML_Syntax.mlty = uu___6;
+                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
+                    let uu___8 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
+                    FStar_Compiler_Util.print_endline "End of fields"
+                | {
+                    FStar_Extraction_ML_Syntax.expr =
+                      FStar_Extraction_ML_Syntax.MLE_App
+                      ({
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Name p1;
+                         FStar_Extraction_ML_Syntax.mlty = uu___6;
+                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
+                       {
+                         FStar_Extraction_ML_Syntax.expr =
+                           FStar_Extraction_ML_Syntax.MLE_Const
+                           (FStar_Extraction_ML_Syntax.MLC_String name1);
+                         FStar_Extraction_ML_Syntax.mlty = uu___8;
+                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
+                    FStar_Extraction_ML_Syntax.mlty = uu___10;
+                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
+                    let uu___12 =
+                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
+                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
+                    ((let uu___13 =
+                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
+                          typedef in
+                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
+                        uu___13);
+                     parse_fields fields2)
+                | uu___6 ->
+                    failwith "Couldn't parse fields from struct_fields" in
+              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From 2d55a6272b359677cf69f0fe0076b369ac7c16c0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 18 Oct 2022 15:05:46 -0700
Subject: [PATCH 317/513] separate model modules

---
 ulib/experimental/Steel.C.Array.Base.fst      | 304 +++++++++---------
 ulib/experimental/Steel.C.Array.Base.fsti     |  44 +--
 ulib/experimental/Steel.C.Array.fsti          |   2 +-
 ulib/experimental/Steel.C.Fields.fsti         |   4 +-
 ...ction.fst => Steel.C.Model.Connection.fst} |   4 +-
 ...teel.C.Frac.fst => Steel.C.Model.Frac.fst} |   6 +-
 ...el.C.Frac.fsti => Steel.C.Model.Frac.fsti} |   6 +-
 ...{Steel.C.PCM.fst => Steel.C.Model.PCM.fst} |   2 +-
 ...teel.C.PCM.fsti => Steel.C.Model.PCM.fsti} |   2 +-
 ...{Steel.C.Ref.fst => Steel.C.Model.Ref.fst} |   6 +-
 ...teel.C.Ref.fsti => Steel.C.Model.Ref.fsti} |   6 +-
 ....C.Struct.fst => Steel.C.Model.Struct.fst} |  10 +-
 ....Uninit.fsti => Steel.C.Model.Uninit.fsti} |  10 +-
 ...el.C.Union.fst => Steel.C.Model.Union.fst} |  10 +-
 ...niverse.fst => Steel.C.Model.Universe.fst} |   6 +-
 ulib/experimental/Steel.C.Opt.fst             |  10 +-
 ulib/experimental/Steel.C.Opt.fsti            |   4 +-
 ulib/experimental/Steel.C.Reference.fst       |  18 +-
 ulib/experimental/Steel.C.StructLiteral.fst   |   8 +-
 ulib/experimental/Steel.C.StructLiteral.fsti  |  12 +-
 ulib/experimental/Steel.C.Typedef.fst         |   4 +-
 ulib/experimental/Steel.C.UnionLiteral.fst    |  24 +-
 ulib/experimental/Steel.C.UnionLiteral.fsti   |   8 +-
 23 files changed, 255 insertions(+), 255 deletions(-)
 rename ulib/experimental/{Steel.C.Connection.fst => Steel.C.Model.Connection.fst} (99%)
 rename ulib/experimental/{Steel.C.Frac.fst => Steel.C.Model.Frac.fst} (95%)
 rename ulib/experimental/{Steel.C.Frac.fsti => Steel.C.Model.Frac.fsti} (97%)
 rename ulib/experimental/{Steel.C.PCM.fst => Steel.C.Model.PCM.fst} (99%)
 rename ulib/experimental/{Steel.C.PCM.fsti => Steel.C.Model.PCM.fsti} (99%)
 rename ulib/experimental/{Steel.C.Ref.fst => Steel.C.Model.Ref.fst} (99%)
 rename ulib/experimental/{Steel.C.Ref.fsti => Steel.C.Model.Ref.fsti} (99%)
 rename ulib/experimental/{Steel.C.Struct.fst => Steel.C.Model.Struct.fst} (99%)
 rename ulib/experimental/{Steel.C.Uninit.fsti => Steel.C.Model.Uninit.fsti} (97%)
 rename ulib/experimental/{Steel.C.Union.fst => Steel.C.Model.Union.fst} (99%)
 rename ulib/experimental/{Steel.C.Universe.fst => Steel.C.Model.Universe.fst} (97%)

diff --git a/ulib/experimental/Steel.C.Array.Base.fst b/ulib/experimental/Steel.C.Array.Base.fst
index fd27cd20ee6..ef6252ce0f7 100644
--- a/ulib/experimental/Steel.C.Array.Base.fst
+++ b/ulib/experimental/Steel.C.Array.Base.fst
@@ -1,6 +1,6 @@
 module Steel.C.Array.Base
 
-module S = Steel.C.Struct
+module S = Steel.C.Model.Struct
 
 #push-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
 let half_perm
@@ -53,7 +53,7 @@ let array_elements_pcm
   (t: Type u#0)
   (n: Ghost.erased size_t)
   (x: array_domain t n)
-: Tot (Steel.C.PCM.pcm (array_range t n x))
+: Tot (Steel.C.Model.PCM.pcm (array_range t n x))
 = Steel.C.Opt.opt_pcm #t
 
 let array_pcm t n = S.prod_pcm (array_elements_pcm t n)
@@ -101,13 +101,13 @@ let array_elements_view
   (t: Type u#0)
   (n: size_t)
   (k: array_domain t n)
-: Tot (Steel.C.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
+: Tot (Steel.C.Model.Ref.sel_view (array_elements_pcm t n k) (array_elements_view_type t n k) false)
 = Steel.C.Opt.opt_view _
 
 let intro_array_view_init
   (t: Type u#0)
   (n: size_t)
-  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+  (x: restricted_t (Steel.C.Model.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
   (k: nat { k < size_v n })
 : Tot t
 = x (int_to_size_t k)
@@ -115,14 +115,14 @@ let intro_array_view_init
 let intro_array_view
   (t: Type u#0)
   (n: size_t)
-  (x: restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+  (x: restricted_t (Steel.C.Model.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
 : Tot (array_view_type t n)
 = Seq.init (size_v n) (intro_array_view_init t n x)
 
 let array_to_view
   (t: Type u#0)
   (n: size_t)
-  (x: Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+  (x: Steel.C.Model.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
 : Tot (array_view_type t n)
 = intro_array_view t n (S.struct_view_to_view (array_elements_view t n) (included_indices t n) x)
 
@@ -130,7 +130,7 @@ let elim_array_view_f
   (t: Type u#0)
   (n: size_t)
   (x: array_view_type t n)
-  (k: Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
+  (k: Steel.C.Model.Ref.refine (array_domain t n) (S.mem (included_indices t n)))
 : Tot (array_elements_view_type t n k)
 = Seq.index x (size_v k)
 
@@ -138,17 +138,17 @@ let elim_array_view
   (t: Type u#0)
   (n: size_t)
   (x: array_view_type t n)
-: Tot (restricted_t (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
-= on_dom (Steel.C.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
+: Tot (restricted_t (Steel.C.Model.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (array_elements_view_type t n))
+= on_dom (Steel.C.Model.Ref.refine (array_domain t n) (S.mem (included_indices t n))) (elim_array_view_f t n x)
 
 let array_to_carrier
   (t: Type u#0)
   (n: size_t)
   (x: array_view_type t n)
-: Tot (Steel.C.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
+: Tot (Steel.C.Model.Ref.refine (array_pcm_carrier t n) (S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n)))
 = S.struct_view_to_carrier (array_elements_view t n) (included_indices t n) (elim_array_view t n x)
 
-open Steel.C.PCM
+open Steel.C.Model.PCM
 
 let array_view_to_view_frame
   (t: Type u#0)
@@ -166,9 +166,9 @@ let array_view_to_view_frame
     (elim_array_view t n x) frame
 
 let array_view' (t: Type u#0) (n: size_t)
-  : Tot (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
+  : Tot (Steel.C.Model.Ref.sel_view (array_pcm t n) (array_view_type t n) (size_v n = 0))
 =
-  let open Steel.C.Ref in
+  let open Steel.C.Model.Ref in
   {
     to_view_prop = S.struct_view_to_view_prop (array_elements_view t n) (included_indices t n);
     to_view = array_to_view t n;
@@ -317,8 +317,8 @@ let array_large_to_small
     size_v from <= size_v to /\
     size_v to <= size_v base_len
   ))
-: Tot (Steel.C.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
-= Steel.C.Connection.mkmorphism
+: Tot (Steel.C.Model.Connection.morphism #(array_pcm_carrier t base_len) #(array_pcm_carrier t (to `size_sub` from))  (array_pcm t base_len) (array_pcm t (to `size_sub` from)))
+= Steel.C.Model.Connection.mkmorphism
     (array_large_to_small_f t base_len from to sq)
     (assert (array_large_to_small_f t base_len from to sq (one (array_pcm t base_len)) `feq` one (array_pcm t (to `size_sub` from))))
     (fun x1 x2 ->
@@ -348,8 +348,8 @@ let array_small_to_large
     size_v from <= size_v to /\
     size_v to <= size_v base_len
   ))
-: Tot (Steel.C.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
-= Steel.C.Connection.mkmorphism
+: Tot (Steel.C.Model.Connection.morphism (array_pcm t (to `size_sub` from))  (array_pcm t base_len))
+= Steel.C.Model.Connection.mkmorphism
     (array_small_to_large_f t base_len from to sq)
     (assert (array_small_to_large_f t base_len from to sq (one (array_pcm t (to `size_sub` from))) `feq` one (array_pcm t (base_len))))
     (fun x1 x2 ->
@@ -366,7 +366,7 @@ let array_small_to_large_to_small
     size_v to <= size_v base_len
   ))
 : Lemma
-  (array_large_to_small_f t base_len from to sq `Steel.C.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
+  (array_large_to_small_f t base_len from to sq `Steel.C.Model.Connection.is_inverse_of` array_small_to_large_f t base_len from to sq)
 = assert (forall x . array_large_to_small_f t base_len from to sq (array_small_to_large_f t base_len from to sq x) `feq` x)
 
 #push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false"
@@ -568,11 +568,11 @@ let array_conn
     size_v from <= size_v to /\
     size_v to <= size_v base_len
   ))
-: Steel.C.Connection.connection
+: Steel.C.Model.Connection.connection
     (array_pcm t base_len)
     (array_pcm t (to `size_sub` from))
 =
-  Steel.C.Connection.mkconnection1
+  Steel.C.Model.Connection.mkconnection1
     (array_small_to_large t base_len from to sq)
     (array_large_to_small t base_len from to sq)
     (array_small_to_large_to_small t base_len from to sq)
@@ -593,18 +593,18 @@ let array_conn_fpu_eq
   ))
   (x: Ghost.erased (array_pcm_carrier t (to `size_sub` from)) { ~ (Ghost.reveal x == one (array_pcm t (to `size_sub` from))) })
   (y: Ghost.erased (array_pcm_carrier t (to `size_sub` from)))
-  (f: Steel.C.Connection.restricted_frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
+  (f: Steel.C.Model.Connection.restricted_frame_preserving_upd (array_pcm t (to `size_sub` from)) x y)
   (v: frame_preserving_upd_dom (array_pcm t base_len) (array_small_to_large_f t base_len from to sq x))  
 : Lemma
-  (let open Steel.C.Connection in
+  (let open Steel.C.Model.Connection in
   ((array_conn t base_len from to sq).conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == array_conn_fpu_f t base_len from to sq x y f v)
 = ()
 
 #restart-solver
 
 let connection_eq_gen
-  #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Connection.connection` q1)
-  #b2 (#q2: pcm b2) (c2: p `Steel.C.Connection.connection` q2)
+  #a (#p: pcm a) #b1 (#q1: pcm b1) (c1: p `Steel.C.Model.Connection.connection` q1)
+  #b2 (#q2: pcm b2) (c2: p `Steel.C.Model.Connection.connection` q2)
   (sq: squash (
     b1 == b2 /\
     q1 == q2 /\
@@ -614,11 +614,11 @@ let connection_eq_gen
   (phi:
     (x1: Ghost.erased b1 { ~ (Ghost.reveal x1 == one q1) }) ->
     (y1: Ghost.erased b1) ->
-    (f1: Steel.C.Connection.restricted_frame_preserving_upd q1 x1 y1) ->
+    (f1: Steel.C.Model.Connection.restricted_frame_preserving_upd q1 x1 y1) ->
     (v1: frame_preserving_upd_dom p (c1.conn_small_to_large.morph x1)) ->
     (x2: Ghost.erased b2 { ~ (Ghost.reveal x2 == one q2) }) ->
     (y2: Ghost.erased b2) ->
-    (f2: Steel.C.Connection.restricted_frame_preserving_upd q2 x2 y2) ->
+    (f2: Steel.C.Model.Connection.restricted_frame_preserving_upd q2 x2 y2) ->
     (v2: frame_preserving_upd_dom p (c2.conn_small_to_large.morph x2)) ->
     (sq': squash (
       x1 == x2 /\
@@ -627,18 +627,18 @@ let connection_eq_gen
       v1 == v2
     )) ->
     Tot
-    (squash ((c1.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1 })).fpu_f v1 == (c2.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2 })).fpu_f v2))
+    (squash ((c1.conn_lift_frame_preserving_upd Steel.C.Model.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1 })).fpu_f v1 == (c2.conn_lift_frame_preserving_upd Steel.C.Model.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2 })).fpu_f v2))
   )
 : Lemma
   (c1 == c2)
-= Steel.C.Connection.connection_eq_gen c1 c2 () (fun x y f v -> phi x y f v x y f v ())
+= Steel.C.Model.Connection.connection_eq_gen c1 c2 () (fun x y f v -> phi x y f v x y f v ())
 
 #restart-solver
 let array_conn_id
   (t: Type0)
   (base_len: Ghost.erased size_t)
 : Lemma
-  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Connection.connection_id (array_pcm t base_len))
+  (array_conn t base_len (mk_size_t (FStar.UInt32.uint_to_t 0)) base_len () == Steel.C.Model.Connection.connection_id (array_pcm t base_len))
 = let z = mk_size_t (FStar.UInt32.uint_to_t 0) in
   assert (forall x . array_small_to_large_f t base_len z base_len () x `feq` x);
   assert (forall x . array_small_to_large_f t base_len z base_len () x == x);
@@ -647,7 +647,7 @@ let array_conn_id
   let c = array_conn t base_len z base_len () in
   connection_eq_gen
     c
-    (Steel.C.Connection.connection_id (array_pcm t base_len))
+    (Steel.C.Model.Connection.connection_id (array_pcm t base_len))
     ()
     (fun x1 y1 f1 v1 x2 y2 f2 v2 sq12 ->
       let v_small : array_pcm_carrier t base_len = array_large_to_small_f t base_len z base_len () v1 in
@@ -659,9 +659,9 @@ let array_conn_id
       let s' : array_pcm_carrier t base_len = overwrite_array_slice t base_len z base_len () v1 v_small' in
       assert (array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1 == s');
       assert (s' == f1 v1);
-      assert ((c.Steel.C.Connection.conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1; })).Steel.C.Connection.fpu_f v1 == array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1);
-      Steel.C.Connection.connection_id_fpu (array_pcm t base_len) x2 y2 f2 v2;
-      assert (((Steel.C.Connection.connection_id (array_pcm t base_len)).conn_lift_frame_preserving_upd Steel.C.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2; })).Steel.C.Connection.fpu_f v2 == f2 v2);
+      assert ((c.Steel.C.Model.Connection.conn_lift_frame_preserving_upd Steel.C.Model.Connection.({ fpu_lift_dom_x = x1; fpu_lift_dom_y = y1; fpu_lift_dom_f = f1; })).Steel.C.Model.Connection.fpu_f v1 == array_conn_fpu_f t base_len z base_len () x1 y1 f1 v1);
+      Steel.C.Model.Connection.connection_id_fpu (array_pcm t base_len) x2 y2 f2 v2;
+      assert (((Steel.C.Model.Connection.connection_id (array_pcm t base_len)).conn_lift_frame_preserving_upd Steel.C.Model.Connection.({ fpu_lift_dom_x = x2; fpu_lift_dom_y = y2; fpu_lift_dom_f = f2; })).Steel.C.Model.Connection.fpu_f v2 == f2 v2);
       ()
     )
 
@@ -693,7 +693,7 @@ let array_conn_compose_morphisms
       let z = to1 `size_sub` from1 in
       let c1 = array_conn t base_len from1 to1 () in
       let c2 = array_conn t z from2 to2 () in
-      let cc = c1 `Steel.C.Connection.connection_compose` c2 in
+      let cc = c1 `Steel.C.Model.Connection.connection_compose` c2 in
       let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
       cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
       cc.conn_large_to_small.morph `feq` c.conn_large_to_small.morph
@@ -865,7 +865,7 @@ let array_conn_compose
     size_v from1 + size_v to2 <= size_v to1
   ))
   (ensures (
-    array_conn t base_len from1 to1 () `Steel.C.Connection.connection_compose` array_conn t (to1 `size_sub` from1) from2 to2 () ==
+    array_conn t base_len from1 to1 () `Steel.C.Model.Connection.connection_compose` array_conn t (to1 `size_sub` from1) from2 to2 () ==
     array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) ()
   ))
 =
@@ -874,7 +874,7 @@ let array_conn_compose
   let _ : squash (sz == size_sub to2 from2) = () in
   let c1 = array_conn t base_len from1 to1 () in
   let c2 = array_conn t z from2 to2 () in
-  let cc = c1 `Steel.C.Connection.connection_compose` c2 in
+  let cc = c1 `Steel.C.Model.Connection.connection_compose` c2 in
   let c = array_conn t base_len (from1 `size_add` from2) (from1 `size_add` to2) () in
   let sq : squash (
       cc.conn_small_to_large.morph `feq` c.conn_small_to_large.morph /\
@@ -882,8 +882,8 @@ let array_conn_compose
   ) =
     array_conn_compose_morphisms t base_len from1 to1 from2 to2 ()
   in
-  Steel.C.Connection.connection_eq_gen cc c sq (fun x y f v ->
-    let open Steel.C.Connection in
+  Steel.C.Model.Connection.connection_eq_gen cc c sq (fun x y f v ->
+    let open Steel.C.Model.Connection in
     let x' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph x in
     let y' : Ghost.erased (array_pcm_carrier t z) = c2.conn_small_to_large.morph y in
     let phi = mk_restricted_frame_preserving_upd (c2.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })) in
@@ -974,21 +974,21 @@ let array__perm_val
 let array_as_ref_conn
   (#t: Type)
   (a: array t)
-: GTot (Steel.C.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
+: GTot (Steel.C.Model.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
 = array_conn t (array__base_len a) (array__from a) (array__to a) ()
 
 let array_as_ref
   (#t: Type)
   (a: array t)
 : GTot (Steel.C.Reference.ref (array_view_type t (len a)) (array_pcm t (len a)))
-= Steel.C.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
+= Steel.C.Model.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
 
 [@@__steel_reduce__]
 let varray0
   (#t: Type)
   (x: array t)
 : Tot vprop
-= Steel.C.Ref.pts_to_view
+= Steel.C.Model.Ref.pts_to_view
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
     (array_as_ref #t x)
@@ -1082,13 +1082,13 @@ val intro_varray0 (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference
   (_: squash (size_v n > 0))
 : SteelAtomicBase (array t)
     false opened Unobservable
-    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (Steel.C.Model.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
     (requires fun _ -> True)
   (ensures (fun h a h' ->
     g_mk_array r a /\
     snd a == g_mk_array_to r (fst a) /\
-    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+    h' (varray a) == h (Steel.C.Model.Ref.pts_to_view r (array_view t n))
   ))
 
 let intro_varray0
@@ -1105,15 +1105,15 @@ let intro_varray0
   change_equal_slprop
     (Steel.Reference.ghost_vptr perm_ref)
     (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
-  assert ((array_as_ref res <: Steel.C.Ref.ref (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  assert ((array_as_ref res <: Steel.C.Model.Ref.ref (array_pcm t n)) == Steel.C.Model.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
-  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
-  Steel.C.Ref.ref_focus_id r;
-  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
+  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Model.Connection.connection_id (array_pcm t n));
+  assert (array_as_ref res == Steel.C.Model.Ref.ref_focus r (Steel.C.Model.Connection.connection_id (array_pcm t n)));
+  Steel.C.Model.Ref.ref_focus_id r;
+  assert (Steel.C.Model.Ref.ref_focus r (Steel.C.Model.Connection.connection_id (array_pcm t n)) == r);
   assert (array_as_ref res == r);
   change_equal_slprop
-    (r `Steel.C.Ref.pts_to_view` _)
+    (r `Steel.C.Model.Ref.pts_to_view` _)
     (varray0 res);
   intro_varray1 res;
   return res
@@ -1130,17 +1130,17 @@ let elim_varray
   #_ #t #n r res sq
 =
   assert (g_mk_array r res);
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  assert (array_as_ref res == Steel.C.Model.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
-  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
-  assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
-  Steel.C.Ref.ref_focus_id r;
-  assert (Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)) == r);
+  assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Model.Connection.connection_id (array_pcm t n));
+  assert (array_as_ref res == Steel.C.Model.Ref.ref_focus r (Steel.C.Model.Connection.connection_id (array_pcm t n)));
+  Steel.C.Model.Ref.ref_focus_id r;
+  assert (Steel.C.Model.Ref.ref_focus r (Steel.C.Model.Connection.connection_id (array_pcm t n)) == r);
   assert (array_as_ref res == r);
   elim_varray1 res;
   change_equal_slprop
     (varray0 res)
-    (r `Steel.C.Ref.pts_to_view` _);
+    (r `Steel.C.Model.Ref.pts_to_view` _);
   let perm_ref = (array__perm_ref res) in
   change_equal_slprop
     (Steel.Reference.ghost_vptrp ((array__perm_ref res)) ((array__perm_val res)))
@@ -1268,14 +1268,14 @@ val to_carrier_split
 : Lemma
   (requires (
     size_v i <= size_v n /\
-    (array_view' t n).Steel.C.Ref.to_carrier v == x
+    (array_view' t n).Steel.C.Model.Ref.to_carrier v == x
   ))
   (ensures (
     let z = mk_size_t 0ul in
     let xl = (array_large_to_small_f t n z i () x) in
     let xr = (array_large_to_small_f t n i n () x) in
-    (array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) == xl /\
-    (array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) == xr
+    (array_view' t i).Steel.C.Model.Ref.to_carrier (Seq.slice v 0 (size_v i)) == xl /\
+    (array_view' t (n `size_sub` i)).Steel.C.Model.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) == xr
   ))
 
 #push-options "--z3rlimit 32"
@@ -1285,8 +1285,8 @@ let to_carrier_split t n x v i =
     let z = mk_size_t 0ul in
     let xl = (array_large_to_small_f t n z i () x) in
     let xr = (array_large_to_small_f t n i n () x) in
-    assert ((array_view' t i).Steel.C.Ref.to_carrier (Seq.slice v 0 (size_v i)) `feq` xl);
-    assert ((array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
+    assert ((array_view' t i).Steel.C.Model.Ref.to_carrier (Seq.slice v 0 (size_v i)) `feq` xl);
+    assert ((array_view' t (n `size_sub` i)).Steel.C.Model.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
 
 let array_as_ref_split_left
   (t: Type)
@@ -1295,11 +1295,11 @@ let array_as_ref_split_left
 : Lemma
   (requires (size_v i <= length x))
   (ensures (
-    array_as_ref (fst (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
+    array_as_ref (fst (tsplit x i)) == Steel.C.Model.Ref.ref_focus (array_as_ref x) (array_conn t (len x) zero_size i ())
   ))
 =
   array_conn_compose t (array__base_len x) (array__from x) (array__to x) zero_size i;
-  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
+  Steel.C.Model.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) zero_size i ())
 
 #restart-solver
 let array_as_ref_split_right
@@ -1309,11 +1309,11 @@ let array_as_ref_split_right
 : Lemma
   (requires (size_v i <= length x))
   (ensures (
-    array_as_ref (snd (tsplit x i)) == Steel.C.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
+    array_as_ref (snd (tsplit x i)) == Steel.C.Model.Ref.ref_focus (array_as_ref x) (array_conn t (len x) i (len x) ())
   ))
 =
   array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
-  Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
+  Steel.C.Model.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
 
 val split_ (#opened: _) (#t:Type) (a:array t) (i:size_t)
   : SteelGhost (array t `gpair` array t) opened
@@ -1339,7 +1339,7 @@ let split_
 =
   let gv = gget (varray x) in
   elim_varray1 x;
-  let v = Steel.C.Ref.pts_to_view_elim
+  let v = Steel.C.Model.Ref.pts_to_view_elim
     #j
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
@@ -1356,31 +1356,31 @@ let split_
   let vl : array_pcm_carrier t (len x) = array_small_to_large_f t n z i () vl' in
   let vr' : array_pcm_carrier t (len xr) = array_large_to_small_f t n i n () v in
   let vr : array_pcm_carrier t (len x) = array_small_to_large_f t n i n () vr' in
-  Steel.C.Ref.split
+  Steel.C.Model.Ref.split
     (array_as_ref #t x)
     v
     vl
     vr;
-  let cl : (cl: Steel.C.Connection.connection
+  let cl : (cl: Steel.C.Model.Connection.connection
     (array_pcm t (len x))
     (array_pcm t (len xl)) {
       cl === array_conn t n z i ()
     })
   = magic () // array_conn t n z i ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
   in
-  Steel.C.Ref.gfocus
+  Steel.C.Model.Ref.gfocus
     (array_as_ref #t x)
     cl
     vl
     vl';
   array_as_ref_split_left t x i;
-  assert (array_as_ref xl == Steel.C.Ref.ref_focus (array_as_ref x) cl);
+  assert (array_as_ref xl == Steel.C.Model.Ref.ref_focus (array_as_ref x) cl);
   change_equal_slprop
-    (_ `Steel.C.Ref.pts_to` vl')
-    (array_as_ref xl `Steel.C.Ref.pts_to` vl');
+    (_ `Steel.C.Model.Ref.pts_to` vl')
+    (array_as_ref xl `Steel.C.Model.Ref.pts_to` vl');
   to_carrier_split t n v gv i;
   let gvl : array_view_type t (len xl) = Seq.slice gv 0 (size_v i) in
-  Steel.C.Ref.pts_to_view_intro
+  Steel.C.Model.Ref.pts_to_view_intro
     #j
     #(array_pcm_carrier t (len xl))
     #(array_pcm t (len xl))
@@ -1391,35 +1391,35 @@ let split_
     (array_view' t (len xl))
     gvl;
   change_equal_slprop // necessary, otherwise F* goes off rails
-    (array_as_ref xl `Steel.C.Ref.pts_to_view` _)
+    (array_as_ref xl `Steel.C.Model.Ref.pts_to_view` _)
     (varray0 xl);
   Steel.Reference.ghost_share (array__perm_ref x);
   change_equal_slprop
     (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
     (Steel.Reference.ghost_vptrp (array__perm_ref xl) (array__perm_val xl));
   intro_varray1 xl;
-  let cr : (cr: Steel.C.Connection.connection
+  let cr : (cr: Steel.C.Model.Connection.connection
     (array_pcm t (len x))
     (array_pcm t (len xr)) {
       cr === array_conn t n i n ()
     })
   = magic () // array_conn t n i n ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
   in
-  Steel.C.Ref.gfocus
+  Steel.C.Model.Ref.gfocus
     (array_as_ref #t x)
     cr
     vr
     vr';
   array_as_ref_split_right t x i;
-  assert (array_as_ref xr == Steel.C.Ref.ref_focus (array_as_ref x) cr);
+  assert (array_as_ref xr == Steel.C.Model.Ref.ref_focus (array_as_ref x) cr);
   change_equal_slprop
-    (_ `Steel.C.Ref.pts_to` vr')
-    (array_as_ref xr `Steel.C.Ref.pts_to` vr');
+    (_ `Steel.C.Model.Ref.pts_to` vr')
+    (array_as_ref xr `Steel.C.Model.Ref.pts_to` vr');
   let gvr : array_view_type t (len xr) = Seq.slice gv (size_v i) (size_v n) in
 //  let _ : squash ((Ghost.reveal gv <: Seq.seq t) == gvl `Seq.append` gvr) =
 //    Seq.lemma_split gv (size_v i)
 //  in
-  Steel.C.Ref.pts_to_view_intro
+  Steel.C.Model.Ref.pts_to_view_intro
     #j
     #(array_pcm_carrier t (len xr))
     #(array_pcm t (len xr))
@@ -1430,7 +1430,7 @@ let split_
     (array_view' t (len xr))
     gvr;
   change_equal_slprop // necessary, otherwise F* goes off rails
-    (array_as_ref xr `Steel.C.Ref.pts_to_view` _)
+    (array_as_ref xr `Steel.C.Model.Ref.pts_to_view` _)
     (varray0 xr);
   change_equal_slprop
     (Steel.Reference.ghost_vptrp (array__perm_ref x) (Steel.FractionalPermission.half_perm (array__perm_val x)))
@@ -1461,18 +1461,18 @@ let join' = admit ()
 
 let array_as_one_ref_iso
   (t: Type)
-: Tot (Steel.C.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
-= let c1 = (Steel.C.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
-  let c2 = (Steel.C.Struct.field_to_struct (array_elements_pcm t one_size) zero_size) in
-  Steel.C.Connection.mkisomorphism
+: Tot (Steel.C.Model.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
+= let c1 = (Steel.C.Model.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
+  let c2 = (Steel.C.Model.Struct.field_to_struct (array_elements_pcm t one_size) zero_size) in
+  Steel.C.Model.Connection.mkisomorphism
     c1
     c2
     ()
-    (Steel.C.Connection.is_inverse_of_intro
-      c2.Steel.C.Connection.morph
-      c1.Steel.C.Connection.morph
+    (Steel.C.Model.Connection.is_inverse_of_intro
+      c2.Steel.C.Model.Connection.morph
+      c1.Steel.C.Model.Connection.morph
       (fun x ->
-        array_pcm_carrier_ext t one_size (c2.Steel.C.Connection.morph (c1.Steel.C.Connection.morph x)) x (fun i ->
+        array_pcm_carrier_ext t one_size (c2.Steel.C.Model.Connection.morph (c1.Steel.C.Model.Connection.morph x)) x (fun i ->
           ()
         )
       )
@@ -1482,21 +1482,21 @@ let array_as_one_ref_iso
 
 let array_as_one_ref_conn
   (t: Type)
-: Tot (Steel.C.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
-= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso t)
+: Tot (Steel.C.Model.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
+= Steel.C.Model.Connection.connection_of_isomorphism (array_as_one_ref_iso t)
 
 let g_ref_of_array
   #t r
 =
-  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn t
+  array_as_ref r `Steel.C.Model.Ref.ref_focus` array_as_one_ref_conn t
 
 let array_as_one_ref_conn'
   (#t:Type0) (r:array t)
-: Pure (Steel.C.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
+: Pure (Steel.C.Model.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
   (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
 =
-  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn t
+  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Model.Connection.connection_compose` array_as_one_ref_conn t
 
 #restart-solver
 let array_as_one_ref_conn'_small_to_large
@@ -1505,10 +1505,10 @@ let array_as_one_ref_conn'_small_to_large
   (i: array_domain t (array__base_len r))
 : Lemma
   (requires (size_v (len r) == 1))
-  (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = (array__from r) then x else None)))
-= Steel.C.Connection.morphism_compose_morph
-    (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large
-    (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Connection.conn_small_to_large
+  (ensures ((array_as_one_ref_conn' r).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph x i == (if i = (array__from r) then x else None)))
+= Steel.C.Model.Connection.morphism_compose_morph
+    (array_as_one_ref_conn t).Steel.C.Model.Connection.conn_small_to_large
+    (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Model.Connection.conn_small_to_large
     x
 
 let g_ref_of_array'
@@ -1516,7 +1516,7 @@ let g_ref_of_array'
 : Ghost (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
   (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
-= (array__base_ref r) `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
+= (array__base_ref r) `Steel.C.Model.Ref.ref_focus` array_as_one_ref_conn' r
 
 let g_ref_of_array'_correct
   (#t:Type0) (r:array t)
@@ -1524,15 +1524,15 @@ let g_ref_of_array'_correct
   (requires (length r == 1))
   (ensures (g_ref_of_array r == g_ref_of_array' r))
 =
-  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn t)
+  Steel.C.Model.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn t)
 
 let get_pts_to
   (#inames: _)
-  (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
-  (r: Steel.C.Ref.ref p) (v: Ghost.erased b)
+  (#b: Type u#b) (#p: Steel.C.Model.PCM.pcm b)
+  (r: Steel.C.Model.Ref.ref p) (v: Ghost.erased b)
 : SteelGhost (Ghost.erased b) inames
-    (Steel.C.Ref.pts_to r v)
-    (fun v' -> Steel.C.Ref.pts_to r v)
+    (Steel.C.Model.Ref.pts_to r v)
+    (fun v' -> Steel.C.Model.Ref.pts_to r v)
     (fun _ -> True)
     (fun _ v' _ -> v' == v)
 = noop(); v
@@ -1556,7 +1556,7 @@ val abstract_id
 let ref_of_array_ghost #inames #t x sq =
   let gv = gget (varray x) in
   elim_varray1 x;
-  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
+  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Model.Ref.pts_to_view_elim
     #inames
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
@@ -1567,8 +1567,8 @@ let ref_of_array_ghost #inames #t x sq =
   in
   assert (len x == one_size);
   let z : array_domain t one_size = zero_size in
-  assert (Ghost.reveal v `feq` (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
-  Steel.C.Ref.gfocus
+  assert (Ghost.reveal v `feq` (array_as_one_ref_conn t).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph (Ghost.reveal v z));
+  Steel.C.Model.Ref.gfocus
     #(array_pcm_carrier t (len x))
     #(option t)
     #_
@@ -1578,26 +1578,26 @@ let ref_of_array_ghost #inames #t x sq =
     (array_as_one_ref_conn t)
     _
     (Ghost.reveal v z);
-  Steel.C.Ref.pts_to_view_intro
+  Steel.C.Model.Ref.pts_to_view_intro
     #inames
     #(option t)
     #(Steel.C.Opt.opt_pcm #t)
-    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn t))
+    (Steel.C.Model.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn t))
     (Ghost.reveal v z)
     #t
     #false
     (Steel.C.Opt.opt_view t)
     (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
   change_equal_slprop
-    (Steel.C.Ref.pts_to_view _ _)
-    (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
+    (Steel.C.Model.Ref.pts_to_view _ _)
+    (Steel.C.Model.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
 
 #restart-solver
 val ref_of_array0 (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
   : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
              false opened Unobservable
              (varray r)
-             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #t r == r') `star` v_ref_of_array r)
+             (fun r' -> (Steel.C.Model.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #t r == r') `star` v_ref_of_array r)
              (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
              (ensures fun h0 r' h1 -> True)
 
@@ -1606,7 +1606,7 @@ let ref_of_array0 #t x sq v0 =
   let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
   assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
   elim_varray1 x;
-  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
+  let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Model.Ref.pts_to_view_elim
     #_
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
@@ -1615,15 +1615,15 @@ let ref_of_array0 #t x sq v0 =
     #(size_v (len x) = 0)
     (array_view' t (len x))
   in
-  Steel.C.Ref.unfocus _ (array__base_ref x) (array_as_ref_conn x) _;
+  Steel.C.Model.Ref.unfocus _ (array__base_ref x) (array_as_ref_conn x) _;
   let s = get_pts_to (array__base_ref x) _ in
-  let ar : Ghost.erased (array_pcm_carrier t (array__base_len x)) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v zero_size)) in
+  let ar : Ghost.erased (array_pcm_carrier t (array__base_len x)) = Ghost.hide ((array_as_one_ref_conn' x).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph (Ghost.reveal v zero_size)) in
   array_pcm_carrier_ext t (array__base_len x) (Ghost.reveal s) (Ghost.reveal ar) (fun i ->
     array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
   );
   g_ref_of_array'_correct x;
-  let r : Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
-  Steel.C.Ref.pts_to_view_intro
+  let r : Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t) = Steel.C.Model.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
+  Steel.C.Model.Ref.pts_to_view_intro
     #_
     #(option t)
     #(Steel.C.Opt.opt_pcm #t)
@@ -1634,7 +1634,7 @@ let ref_of_array0 #t x sq v0 =
     (Steel.C.Opt.opt_view t)
     (Ghost.hide (Seq.index (Ghost.reveal gv <: Seq.seq t) 0));
   intro_vrefine
-    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+    (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
     (fun v' -> v' == Ghost.reveal v0);
   intro_pure (g_ref_of_array #t x == r);
   return r
@@ -1650,7 +1650,7 @@ let ref_of_array_from #t r_from r_to sq =
   let r = ref_of_array0 x () v0 in
   elim_pure (g_ref_of_array x == r);
   elim_vrefine
-    (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+    (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
     (fun v' -> v' == Ghost.reveal v0);
   change_equal_slprop
     (v_ref_of_array x)
@@ -1661,12 +1661,12 @@ let ref_of_array_from #t r_from r_to sq =
 let array_of_ref
   #_ #t r' r sq
 =
-  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
-  let v = Steel.C.Ref.pts_to_view_elim
+  let g : Ghost.erased t = gget (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
+  let v = Steel.C.Model.Ref.pts_to_view_elim
     r
     (Steel.C.Opt.opt_view t)
   in
-  Steel.C.Ref.unfocus
+  Steel.C.Model.Ref.unfocus
     r
     (array_as_ref r')
     (array_as_one_ref_conn t)
@@ -1677,30 +1677,30 @@ let array_of_ref
   let v' : Ghost.erased (array_pcm_carrier t (len r')) =
     get_pts_to (array_as_ref r') _
   in
-  array_pcm_carrier_ext t (len r') ((array_view t (len r')).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
+  array_pcm_carrier_ext t (len r') ((array_view t (len r')).Steel.C.Model.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
     assert (i == zero_size)
   );
-  Steel.C.Ref.pts_to_view_intro
+  Steel.C.Model.Ref.pts_to_view_intro
     _
     _
     (array_view t (len r'))
     g';
   change_equal_slprop
-    (Steel.C.Ref.pts_to_view (array_as_ref r') (array_view t (len r')))
+    (Steel.C.Model.Ref.pts_to_view (array_as_ref r') (array_view t (len r')))
     (varray0 r');
   intro_varray1 r'
 
 #restart-solver
 let one_ref_as_array_conn
   (t:Type0)
-: Tot (Steel.C.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
+: Tot (Steel.C.Model.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
 =
-  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso t)))
+  Steel.C.Model.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso t)))
 
 let mk_array_of_ref' (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array t) =
   (Some ({
     base_len = one_size;
-    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn t;
+    base_ref = r `Steel.C.Model.Ref.ref_focus` one_ref_as_array_conn t;
     from = zero_size;
     perm_ref = perm_ref;
   }), Ghost.hide (Some ({
@@ -1716,10 +1716,10 @@ let mk_array_of_ref'_correct
 =
   g_ref_of_array'_correct (mk_array_of_ref' r perm_ref);
   array_conn_id t one_size;
-  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn t);
-  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn t) (array_as_one_ref_conn t);
-  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t);
-  Steel.C.Ref.ref_focus_id r
+  Steel.C.Model.Connection.connection_compose_id_left (array_as_one_ref_conn t);
+  Steel.C.Model.Ref.ref_focus_comp r (one_ref_as_array_conn t) (array_as_one_ref_conn t);
+  Steel.C.Model.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t);
+  Steel.C.Model.Ref.ref_focus_id r
 
 #restart-solver
 let array_as_ref_eq_base_ref
@@ -1735,7 +1735,7 @@ let array_as_ref_eq_base_ref
   ))
 =
   array_conn_id t one_size;
-  Steel.C.Ref.ref_focus_id (array__base_ref a)
+  Steel.C.Model.Ref.ref_focus_id (array__base_ref a)
 
 #restart-solver
 let array_as_ref_mk_array_of_ref'
@@ -1764,14 +1764,14 @@ let mk_array_of_ref_view_intro (#t:Type0)
   (g' : Ghost.erased (array_view_type t one_size))
 : Lemma
   (requires (
-    Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Ref.to_carrier (Ghost.reveal g) /\
-    Ghost.reveal v' == (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
+    Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Model.Ref.to_carrier (Ghost.reveal g) /\
+    Ghost.reveal v' == (array_as_one_ref_conn t).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph (Ghost.reveal v) /\
     Ghost.reveal g' == Seq.create 1 (Ghost.reveal g)
   ))
   (ensures (
-    (array_view t one_size).Steel.C.Ref.to_carrier g' == (Ghost.reveal v')
+    (array_view t one_size).Steel.C.Model.Ref.to_carrier g' == (Ghost.reveal v')
   ))
-= array_pcm_carrier_ext t one_size ((array_view t one_size).Steel.C.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
+= array_pcm_carrier_ext t one_size ((array_view t one_size).Steel.C.Model.Ref.to_carrier g') (Ghost.reveal v') (fun i ->
     ()
   )
 
@@ -1791,14 +1791,14 @@ let mk_array_of_ref_from_spec
   g_is_null a == false /\
   array__base_len a == one_size /\
   array__from a == zero_size /\
-  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn t
+  array__base_ref a == r `Steel.C.Model.Ref.ref_focus` one_ref_as_array_conn t
 
 let mk_array_of_ref_to #t r from = mk_array_of_ref_to' t
 
 val mk_array_of_ref0 (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
   : SteelAtomicBase (array t)
              false opened Unobservable
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
              (requires fun _ -> True)
              (ensures fun h0 r' h1 ->
@@ -1806,20 +1806,20 @@ val mk_array_of_ref0 (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.
                Seq.length s == 1 /\
                g_ref_of_array r' == r /\
                r' == mk_array_of_ref' r (array__perm_ref r') /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h0 (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
 #restart-solver
 let mk_array_of_ref0
   #t r
 =
-  let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
-  let v : Ghost.erased (option t) = Steel.C.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
-  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
-  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
-    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t)
+  let g : Ghost.erased t = gget (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
+  let v : Ghost.erased (option t) = Steel.C.Model.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
+  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn t).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph (Ghost.reveal v)) in
+  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn t).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph (Ghost.reveal v')) =
+    Steel.C.Model.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t)
   in
-  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn t) v v' in
+  let r' = Steel.C.Model.Ref.focus r (one_ref_as_array_conn t) v v' in
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
   let res : array t = (Some ({
     base_len = one_size;
@@ -1837,14 +1837,14 @@ let mk_array_of_ref0
     Ghost.hide (Seq.create 1 (Ghost.reveal g))
   in
   mk_array_of_ref_view_intro g v v' g' ;
-  Steel.C.Ref.pts_to_view_intro
+  Steel.C.Model.Ref.pts_to_view_intro
     _
     _
     (array_view t one_size)
     g';
   array_as_ref_mk_array_of_ref' r perm_ref;
   change_equal_slprop
-    (Steel.C.Ref.pts_to_view r' (array_view t one_size))
+    (Steel.C.Model.Ref.pts_to_view r' (array_view t one_size))
     (varray0 res);
   change_equal_slprop
     (Steel.Reference.ghost_vptr perm_ref)
@@ -1955,7 +1955,7 @@ let elim_varray_or_null_none x =
 let freeable
   #t a
 =
-  Steel.C.Ref.freeable (array__base_ref a) /\
+  Steel.C.Model.Ref.freeable (array__base_ref a) /\
   size_v (array__base_len a) > 0 /\
   (array__perm_val a) == Steel.FractionalPermission.full_perm /\
   (array__from a) == zero_size /\
@@ -2015,8 +2015,8 @@ let malloc0
   let v = Seq.create (size_v n) x in
   let c = array_to_carrier t n v in
   array_to_carrier_refine n v;
-  let r0 = Steel.C.Ref.ref_alloc (array_pcm t n) c in
-  Steel.C.Ref.pts_to_view_intro r0 c (array_view t n) v;
+  let r0 = Steel.C.Model.Ref.ref_alloc (array_pcm t n) c in
+  Steel.C.Model.Ref.pts_to_view_intro r0 c (array_view t n) v;
   let r = intro_varray r0 () in
   intro_varray_or_null_some r;
   return r
@@ -2046,14 +2046,14 @@ let free0
 =
   let r = (array__base_ref a) in
   elim_varray r a ();
-  let v = Steel.C.Ref.pts_to_view_elim
+  let v = Steel.C.Model.Ref.pts_to_view_elim
     #_
     #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
     r
     (array_view t (array__base_len a))
   in
-  Steel.C.Ref.ref_free
+  Steel.C.Model.Ref.ref_free
     #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #v
diff --git a/ulib/experimental/Steel.C.Array.Base.fsti b/ulib/experimental/Steel.C.Array.Base.fsti
index 5b04af13198..884c4317a92 100644
--- a/ulib/experimental/Steel.C.Array.Base.fsti
+++ b/ulib/experimental/Steel.C.Array.Base.fsti
@@ -23,7 +23,7 @@ open FStar.Ghost
 open Steel.Effect.Atomic
 
 open Steel.C.Typedef
-open Steel.C.PCM
+open Steel.C.Model.PCM
 open Steel.C.Fields
 open Steel.C.Typenat
 
@@ -34,7 +34,7 @@ open Steel.C.Typenat
 
 val array_pcm_carrier (t: Type u#0) (n: Ghost.erased size_t) : Type u#0
 
-val array_pcm (t: Type u#0) (n: Ghost.erased size_t) : Tot (Steel.C.PCM.pcm (array_pcm_carrier t n))
+val array_pcm (t: Type u#0) (n: Ghost.erased size_t) : Tot (Steel.C.Model.PCM.pcm (array_pcm_carrier t n))
 
 // FIXME: how to produce array type t[n] as the type of some struct field?
 let array_view_type (t: Type u#0) (n: size_t)
@@ -49,7 +49,7 @@ let array_view_type_sized (t: Type u#0) (n': Type u#0) (n: size_t_of n')
 = array_view_type t n
 
 val array_view (t: Type u#0) (n: size_t)
-  : Pure (Steel.C.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
+  : Pure (Steel.C.Model.Ref.sel_view (array_pcm t n) (array_view_type t n) false)
     (requires (size_v n > 0))
     (ensures (fun _ -> True))
 
@@ -115,7 +115,7 @@ let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}):
 
 // [@@ __steel_reduce__]
 // let varray (#t: Type) (x: array t) : Tot vprop
-// = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
+// = Steel.C.Model.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
 
 val varray_hp (#t: Type0) (x: array t) : Tot (slprop u#1)
 
@@ -168,13 +168,13 @@ val intro_varray_from (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Refer
   (_: squash (size_v n > 0))
 : SteelAtomicBase (al: array_or_null_from t { g_mk_array_from r al })
     false opened Unobservable
-    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (Steel.C.Model.Ref.pts_to_view r (array_view t n))
     (fun al -> varray (al, g_mk_array_to r al))
     (requires fun _ -> True)
   (ensures (fun h al h' ->
     let a = (al, g_mk_array_to r al) in
     g_mk_array r a /\
-    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+    h' (varray a) == h (Steel.C.Model.Ref.pts_to_view r (array_view t n))
   ))
 
 inline_for_extraction
@@ -182,12 +182,12 @@ let intro_varray (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.
   (_: squash (size_v n > 0))
 : SteelAtomicBase (array t)
   false opened Unobservable
-    (Steel.C.Ref.pts_to_view r (array_view t n))
+    (Steel.C.Model.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
     (requires fun _ -> True)
   (ensures (fun h a h' ->
     g_mk_array r a /\
-    h' (varray a) == h (Steel.C.Ref.pts_to_view r (array_view t n))
+    h' (varray a) == h (Steel.C.Model.Ref.pts_to_view r (array_view t n))
   ))
 =
   let al = intro_varray_from r () in
@@ -200,11 +200,11 @@ let intro_varray (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.
 val elim_varray (#inames: _) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n)) (a: array t) (_: squash (size_v n > 0))
 : SteelGhost unit inames
   (varray a)
-  (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
+  (fun _ -> Steel.C.Model.Ref.pts_to_view r (array_view t n))
   (requires fun _ -> g_mk_array r a)
   (ensures (fun h _ h' ->
     g_mk_array r a /\
-    h (varray a) == h' (Steel.C.Ref.pts_to_view r (array_view t n))
+    h (varray a) == h' (Steel.C.Model.Ref.pts_to_view r (array_view t n))
   ))
 
 /// Splitting an array into subarrays
@@ -440,27 +440,27 @@ val v_ref_of_array
 val ref_of_array_ghost (#inames: _) (#t:Type0) (r:array t) (sq: squash (length r == 1))
   : SteelGhost unit inames
              (varray r)
-             (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
+             (fun _ -> Steel.C.Model.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
              (requires fun _ -> True)
              (ensures fun h0 _ h1 ->
                let r' = g_ref_of_array r in
                let s = h0 (varray r) in
                Seq.length s == 1 /\
-               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h1 (Steel.C.Model.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
 val ref_of_array_from (#t:Type0) (#opened: _) (r_from:array_or_null_from t) (r_to: array_or_null_to t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
   : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
     false opened Unobservable
              (varray (r_from, r_to))
-             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
+             (fun r' -> Steel.C.Model.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
              (requires fun _ -> True)
              (ensures fun h0 r' h1 ->
                let r = (r_from, r_to) in
                let s = h0 (varray r) in
                Seq.length s == 1 /\
                g_ref_of_array r == r' /\
-               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h1 (Steel.C.Model.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
 inline_for_extraction
@@ -468,13 +468,13 @@ let ref_of_array (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1)
   : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
     false opened Unobservable
              (varray r)
-             (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
+             (fun r' -> Steel.C.Model.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
              (requires fun _ -> True)
              (ensures fun h0 r' h1 ->
                let s = h0 (varray r) in
                Seq.length s == 1 /\
                g_ref_of_array r == r' /\
-               h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h1 (Steel.C.Model.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 = match r with
   | (r_from, r_to) ->
@@ -489,14 +489,14 @@ let ref_of_array (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1)
 
 val array_of_ref (#inames: _) (#t:Type0) (r': array t) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
   : SteelGhost unit inames
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
+             (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
              (fun _ -> varray r')
              (requires fun _ -> g_ref_of_array r' == r)
              (ensures fun h0 _ h1 ->
                let s = h1 (varray r') in
                Seq.length s == 1 /\
                g_ref_of_array r' == r /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h0 (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
 // this function should be used only to pass a pointer as an argument to a function that expects an array
@@ -520,7 +520,7 @@ val mk_array_of_ref_to
 val mk_array_of_ref_from (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
   : SteelAtomicBase (r0: array_or_null_from t { mk_array_of_ref_from_spec r r0 })
     false opened Unobservable
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
              (requires fun _ -> True)
              (ensures fun h0 r0 h1 ->
@@ -528,21 +528,21 @@ val mk_array_of_ref_from (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (St
                let s = h1 (varray r') in
                Seq.length s == 1 /\
                g_ref_of_array r' == r /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h0 (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
 inline_for_extraction
 let mk_array_of_ref (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
   : SteelAtomicBase (array t)
     false opened Unobservable
-             (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
+             (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
              (requires fun _ -> True)
              (ensures fun h0 r' h1 ->
                let s = h1 (varray r') in
                Seq.length s == 1 /\
                g_ref_of_array r' == r /\
-               h0 (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
+               h0 (Steel.C.Model.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 = let from = mk_array_of_ref_from r in
   let r' = (from, mk_array_of_ref_to r from) in
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index edcc94a302a..1bc18bab0ec 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -23,7 +23,7 @@ open FStar.Ghost
 open Steel.Effect.Atomic
 
 open Steel.C.Typedef
-open Steel.C.PCM
+open Steel.C.Model.PCM
 open Steel.C.Fields
 open Steel.C.Typenat
 
diff --git a/ulib/experimental/Steel.C.Fields.fsti b/ulib/experimental/Steel.C.Fields.fsti
index 8c2cfe0fa58..8bd6c7598b8 100644
--- a/ulib/experimental/Steel.C.Fields.fsti
+++ b/ulib/experimental/Steel.C.Fields.fsti
@@ -154,7 +154,7 @@ let refine_typedef
 = {
   carrier = t.carrier;
   pcm = t.pcm;
-  view_type = Steel.C.Ref.refine t.view_type p;
+  view_type = Steel.C.Model.Ref.refine t.view_type p;
   view = refine_view t.view p;
   is_unit = t.is_unit;
 }
@@ -166,7 +166,7 @@ let rewrite_typedef
   (#view': Type)
   (f: t.view_type -> Tot view')
   (g: view' -> Tot t.view_type)
-  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (prf: squash (f `Steel.C.Model.Connection.is_inverse_of` g))
 : Tot typedef
 = {
   carrier = t.carrier;
diff --git a/ulib/experimental/Steel.C.Connection.fst b/ulib/experimental/Steel.C.Model.Connection.fst
similarity index 99%
rename from ulib/experimental/Steel.C.Connection.fst
rename to ulib/experimental/Steel.C.Model.Connection.fst
index e2542f0d0dc..af9849fe597 100644
--- a/ulib/experimental/Steel.C.Connection.fst
+++ b/ulib/experimental/Steel.C.Model.Connection.fst
@@ -1,6 +1,6 @@
-module Steel.C.Connection
+module Steel.C.Model.Connection
 
-open Steel.C.PCM
+open Steel.C.Model.PCM
 open FStar.FunctionalExtensionality
 
 (** PCM morphisms *)
diff --git a/ulib/experimental/Steel.C.Frac.fst b/ulib/experimental/Steel.C.Model.Frac.fst
similarity index 95%
rename from ulib/experimental/Steel.C.Frac.fst
rename to ulib/experimental/Steel.C.Model.Frac.fst
index 15348d3faa7..0ed30fd7334 100644
--- a/ulib/experimental/Steel.C.Frac.fst
+++ b/ulib/experimental/Steel.C.Model.Frac.fst
@@ -1,7 +1,7 @@
-module Steel.C.Frac
+module Steel.C.Model.Frac
 
-open Steel.C.PCM
-open Steel.C.Ref
+open Steel.C.Model.PCM
+open Steel.C.Model.Ref
 open Steel.Effect
 open Steel.Effect.Atomic
   
diff --git a/ulib/experimental/Steel.C.Frac.fsti b/ulib/experimental/Steel.C.Model.Frac.fsti
similarity index 97%
rename from ulib/experimental/Steel.C.Frac.fsti
rename to ulib/experimental/Steel.C.Model.Frac.fsti
index 8e985451cd9..f1629ebe2e3 100644
--- a/ulib/experimental/Steel.C.Frac.fsti
+++ b/ulib/experimental/Steel.C.Model.Frac.fsti
@@ -1,8 +1,8 @@
-module Steel.C.Frac
+module Steel.C.Model.Frac
 
 module P = FStar.PCM
-open Steel.C.PCM
-open Steel.C.Ref
+open Steel.C.Model.PCM
+open Steel.C.Model.Ref
 open Steel.Effect
 
 /// Fractional permissions: from Steel.HigherReference
diff --git a/ulib/experimental/Steel.C.PCM.fst b/ulib/experimental/Steel.C.Model.PCM.fst
similarity index 99%
rename from ulib/experimental/Steel.C.PCM.fst
rename to ulib/experimental/Steel.C.Model.PCM.fst
index 7e790de0c69..0e46540b2a7 100644
--- a/ulib/experimental/Steel.C.PCM.fst
+++ b/ulib/experimental/Steel.C.Model.PCM.fst
@@ -1,4 +1,4 @@
-module Steel.C.PCM
+module Steel.C.Model.PCM
 module P = FStar.PCM
 open FStar.FunctionalExtensionality
 open FStar.IndefiniteDescription
diff --git a/ulib/experimental/Steel.C.PCM.fsti b/ulib/experimental/Steel.C.Model.PCM.fsti
similarity index 99%
rename from ulib/experimental/Steel.C.PCM.fsti
rename to ulib/experimental/Steel.C.Model.PCM.fsti
index fdf8f0aa517..a6e22b29514 100644
--- a/ulib/experimental/Steel.C.PCM.fsti
+++ b/ulib/experimental/Steel.C.Model.PCM.fsti
@@ -1,4 +1,4 @@
-module Steel.C.PCM
+module Steel.C.Model.PCM
 module P = FStar.PCM
 open FStar.FunctionalExtensionality
 open FStar.IndefiniteDescription
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Model.Ref.fst
similarity index 99%
rename from ulib/experimental/Steel.C.Ref.fst
rename to ulib/experimental/Steel.C.Model.Ref.fst
index 8e9972f3cfe..d2762ed7ac2 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Model.Ref.fst
@@ -1,6 +1,6 @@
-module Steel.C.Ref
+module Steel.C.Model.Ref
 module P = FStar.PCM
-module U = Steel.C.Universe
+module U = Steel.C.Model.Universe
 open FStar.FunctionalExtensionality
 
 module M = Steel.Memory
@@ -194,7 +194,7 @@ let ref_alloc #a pcm v =
   A.return p
 
 let ref_free #b #p #x r =
-  // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.PCM
+  // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.Model.PCM
   A.drop (pts_to _ _)
 
 #pop-options
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Model.Ref.fsti
similarity index 99%
rename from ulib/experimental/Steel.C.Ref.fsti
rename to ulib/experimental/Steel.C.Model.Ref.fsti
index d7ba85bfcef..56a9ce7ae64 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Model.Ref.fsti
@@ -1,7 +1,7 @@
-module Steel.C.Ref
+module Steel.C.Model.Ref
 open FStar.FunctionalExtensionality
-open Steel.C.PCM
-open Steel.C.Connection
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
 
 module A = Steel.Effect.Atomic
 
diff --git a/ulib/experimental/Steel.C.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
similarity index 99%
rename from ulib/experimental/Steel.C.Struct.fst
rename to ulib/experimental/Steel.C.Model.Struct.fst
index 67f002cb427..4f655c0a710 100644
--- a/ulib/experimental/Steel.C.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -1,10 +1,10 @@
-module Steel.C.Struct
+module Steel.C.Model.Struct
 
 module P = FStar.PCM
-open Steel.C.PCM
-open Steel.C.Connection
-open Steel.C.Ref
-// module Ptr = Steel.C.Ptr
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+open Steel.C.Model.Ref
+// module Ptr = Steel.C.Model.Ptr
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
diff --git a/ulib/experimental/Steel.C.Uninit.fsti b/ulib/experimental/Steel.C.Model.Uninit.fsti
similarity index 97%
rename from ulib/experimental/Steel.C.Uninit.fsti
rename to ulib/experimental/Steel.C.Model.Uninit.fsti
index a065d47d04b..54e520ccba6 100644
--- a/ulib/experimental/Steel.C.Uninit.fsti
+++ b/ulib/experimental/Steel.C.Model.Uninit.fsti
@@ -1,9 +1,9 @@
-module Steel.C.Uninit
+module Steel.C.Model.Uninit
 
 module P = FStar.PCM
-open Steel.C.PCM
-open Steel.C.Ref
-open Steel.C.Connection
+open Steel.C.Model.PCM
+open Steel.C.Model.Ref
+open Steel.C.Model.Connection
 open Steel.Effect
 
 /// Uninitialized
@@ -52,7 +52,7 @@ let fstar_pcm_uninit #a (p: pcm a) : Tot (P.pcm (uninit_t a)) = let open P in {
   p = {
          composable = uninit_composable p;
          op = uninit_compose p;
-         one = InitOrUnit (Steel.C.PCM.one p);
+         one = InitOrUnit (Steel.C.Model.PCM.one p);
       };
   comm = (fun _ _ -> ());
   assoc = (fun x1 x2 x3 -> ());
diff --git a/ulib/experimental/Steel.C.Union.fst b/ulib/experimental/Steel.C.Model.Union.fst
similarity index 99%
rename from ulib/experimental/Steel.C.Union.fst
rename to ulib/experimental/Steel.C.Model.Union.fst
index b4e9d9fc933..26fa32d28be 100644
--- a/ulib/experimental/Steel.C.Union.fst
+++ b/ulib/experimental/Steel.C.Model.Union.fst
@@ -1,10 +1,10 @@
-module Steel.C.Union
+module Steel.C.Model.Union
 
 module P = FStar.PCM
-open Steel.C.PCM
-open Steel.C.Connection
-open Steel.C.Ref
-open Steel.C.Struct
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+open Steel.C.Model.Ref
+open Steel.C.Model.Struct
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
diff --git a/ulib/experimental/Steel.C.Universe.fst b/ulib/experimental/Steel.C.Model.Universe.fst
similarity index 97%
rename from ulib/experimental/Steel.C.Universe.fst
rename to ulib/experimental/Steel.C.Model.Universe.fst
index 532409ff0f1..ca2ea574173 100644
--- a/ulib/experimental/Steel.C.Universe.fst
+++ b/ulib/experimental/Steel.C.Model.Universe.fst
@@ -1,5 +1,5 @@
-module Steel.C.Universe
-open Steel.C.PCM
+module Steel.C.Model.Universe
+open Steel.C.Model.PCM
 include FStar.Universe
 module P = FStar.PCM
 
@@ -96,7 +96,7 @@ let raise_pcm
   in
   res
 
-open Steel.C.Connection
+open Steel.C.Model.Connection
 
 let raise_pcm_morphism
   (#a: Type u#a)
diff --git a/ulib/experimental/Steel.C.Opt.fst b/ulib/experimental/Steel.C.Opt.fst
index cbedf3afcd1..0a7e241dbd2 100644
--- a/ulib/experimental/Steel.C.Opt.fst
+++ b/ulib/experimental/Steel.C.Opt.fst
@@ -1,6 +1,6 @@
 module Steel.C.Opt
 
-open Steel.C.PCM
+open Steel.C.Model.PCM
 module A = Steel.Effect.Atomic
 
 let opt_read r =
@@ -38,11 +38,11 @@ let malloc
   #c x
 =
   let xc = ((opt_view c).to_carrier x) in
-  let r = Steel.C.Ref.ref_alloc _ xc in
+  let r = Steel.C.Model.Ref.ref_alloc _ xc in
   pts_to_view_intro r xc (opt_view c) x;
   let r' : ref c (opt_pcm #c) = r in
   A.change_equal_slprop
-    (Steel.C.Ref.pts_to_view r (opt_view c))
+    (Steel.C.Model.Ref.pts_to_view r (opt_view c))
     (pts_to_view r' (opt_view c));
   intro_pts_to_view_or_null_not_null r' (opt_view c);
   A.return r'
@@ -50,6 +50,6 @@ let malloc
 let free
   #c r
 =
-  let r' : Steel.C.Ref.ref (opt_pcm #c) = r in 
+  let r' : Steel.C.Model.Ref.ref (opt_pcm #c) = r in 
   let _ = pts_to_view_elim r (opt_view c) in
-  Steel.C.Ref.ref_free r
+  Steel.C.Model.Ref.ref_free r
diff --git a/ulib/experimental/Steel.C.Opt.fsti b/ulib/experimental/Steel.C.Opt.fsti
index f483f96e318..b294647908c 100644
--- a/ulib/experimental/Steel.C.Opt.fsti
+++ b/ulib/experimental/Steel.C.Opt.fsti
@@ -1,8 +1,8 @@
 module Steel.C.Opt
 
 module P = FStar.PCM
-open Steel.C.PCM
-open Steel.C.Ref
+open Steel.C.Model.PCM
+open Steel.C.Model.Ref
 open Steel.Effect
 
 /// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index ce77264fbce..c6dfe117b37 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -1,6 +1,6 @@
 module Steel.C.Reference
-open Steel.C.PCM
-open Steel.C.Ref
+open Steel.C.Model.PCM
+open Steel.C.Model.Ref
 open Steel.Effect
 open Steel.Effect.Atomic
 
@@ -22,7 +22,7 @@ unfold
 let ref_of_ref
   (#view_t: Type u#0) (#b: Type u#b) (#q: pcm b)
   (r: ref view_t q)
-: Tot (Steel.C.Ref.ref q)
+: Tot (Steel.C.Model.Ref.ref q)
 = r
 
 [@@__steel_reduce__] // ; __reduce__]
@@ -135,7 +135,7 @@ let freeable
   (#view_t: Type u#0) (#b: Type u#0) (#q: pcm b)
   (r: ref view_t q)
 : Tot prop
-= freeable (r <: Steel.C.Ref.ref q)
+= freeable (r <: Steel.C.Model.Ref.ref q)
 
 (* Operations on views *)
 
@@ -260,7 +260,7 @@ let rewrite_view
   (#view' : Type u#c)
   (f: view -> view')
   (g: view' -> view)
-  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (prf: squash (f `Steel.C.Model.Connection.is_inverse_of` g))
 : Tot (sel_view p view' can_view_unit)
 = {
   to_view_prop = vw.to_view_prop;
@@ -279,7 +279,7 @@ let intro_rewrite_view'
   (#view' : Type)
   (f: view -> view')
   (g: view' -> view)
-  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (prf: squash (f `Steel.C.Model.Connection.is_inverse_of` g))
   (r: ref view p)
   (x' : Ghost.erased view')
 : SteelGhost unit opened
@@ -304,7 +304,7 @@ let intro_rewrite_view
   (#view' : Type)
   (f: view -> view')
   (g: view' -> view)
-  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (prf: squash (f `Steel.C.Model.Connection.is_inverse_of` g))
   (r: ref view p)
   (x' : Ghost.erased view')
 : SteelAtomicBase (ref view' p) false opened Unobservable
@@ -331,7 +331,7 @@ let elim_rewrite_view'
   (#view' : Type)
   (f: view -> view')
   (g: view' -> view)
-  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (prf: squash (f `Steel.C.Model.Connection.is_inverse_of` g))
   (r: ref view' p)
 : SteelGhost unit opened
     (pts_to_view r (rewrite_view vw f g prf))
@@ -358,7 +358,7 @@ let elim_rewrite_view
   (#view' : Type)
   (f: view -> view')
   (g: view' -> view)
-  (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
+  (prf: squash (f `Steel.C.Model.Connection.is_inverse_of` g))
   (r: ref view' p)
 : SteelAtomicBase (ref view p) false opened Unobservable
     (pts_to_view r (rewrite_view vw f g prf))
diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
index cbed69903d2..3dc49bb5a61 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ b/ulib/experimental/Steel.C.StructLiteral.fst
@@ -5,11 +5,11 @@ open Steel.Effect
 open Steel.Effect.Common
 open Steel.Effect.Atomic
 
-open Steel.C.PCM
-open Steel.C.Struct
+open Steel.C.Model.PCM
+open Steel.C.Model.Struct
 open Steel.C.Typedef
-open Steel.C.Ref
-open Steel.C.Connection
+open Steel.C.Model.Ref
+open Steel.C.Model.Connection
 open Steel.C.Opt
 open Steel.C.Fields
 
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index 83db77647c6..d56e947dfbe 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -7,11 +7,11 @@ open Steel.Effect
 open Steel.Effect.Common
 open Steel.Effect.Atomic
 
-open Steel.C.PCM
-open Steel.C.Struct
+open Steel.C.Model.PCM
+open Steel.C.Model.Struct
 open Steel.C.Typedef
-open Steel.C.Ref
-open Steel.C.Connection
+open Steel.C.Model.Ref
+open Steel.C.Model.Connection
 open Steel.C.Opt
 open Steel.C.Fields
 
@@ -372,7 +372,7 @@ let addr_of_struct_field''
     (requires fun _ -> not (excluded field))
     (ensures fun h q h' -> 
       not (excluded field) /\
-      q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
+      q == Steel.C.Model.Ref.ref_focus p (struct_field tag fields field) /\
       fst (extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded)))
        ==
@@ -417,7 +417,7 @@ let addr_of_struct_field
     (requires fun _ -> not (excluded field))
     (ensures fun h q h' -> 
       not (excluded field) /\
-      q == Steel.C.Ref.ref_focus p (struct_field tag fields field) /\
+      q == Steel.C.Model.Ref.ref_focus p (struct_field tag fields field) /\
       fst (extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded)))
        == h' (p `pts_to_view` struct_view tag fields (insert field excluded))
diff --git a/ulib/experimental/Steel.C.Typedef.fst b/ulib/experimental/Steel.C.Typedef.fst
index 351b717375f..330a96941ee 100644
--- a/ulib/experimental/Steel.C.Typedef.fst
+++ b/ulib/experimental/Steel.C.Typedef.fst
@@ -1,8 +1,8 @@
 module Steel.C.Typedef
 
 open FStar.List.Tot
-open Steel.C.PCM
-open Steel.C.Ref
+open Steel.C.Model.PCM
+open Steel.C.Model.Ref
 open FStar.FunctionalExtensionality
 open Steel.Effect
 
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
index 83251e22943..082ed36860f 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fst
+++ b/ulib/experimental/Steel.C.UnionLiteral.fst
@@ -5,11 +5,11 @@ open Steel.Effect
 open Steel.Effect.Common
 open Steel.Effect.Atomic
 
-open Steel.C.PCM
-open Steel.C.Union
+open Steel.C.Model.PCM
+open Steel.C.Model.Union
 open Steel.C.Typedef
-open Steel.C.Ref
-open Steel.C.Connection
+open Steel.C.Model.Ref
+open Steel.C.Model.Connection
 open Steel.C.Opt
 open Steel.C.Fields
 
@@ -38,7 +38,7 @@ let union_pcms (fields: c_fields) (field: field_of fields): pcm (union_carriers
   (fields.get_field field).pcm
 
 let union_pcm_carrier (tag: Type0) (fields: c_fields): Type0 =
-  Steel.C.Union.union (union_pcms fields)
+  Steel.C.Model.Union.union (union_pcms fields)
 
 let union_pcm (tag: Type0) (fields: c_fields): pcm (union_pcm_carrier tag fields) =
   union_pcm (union_pcms fields)
@@ -50,7 +50,7 @@ let is_units (fields: c_fields) (field: field_of fields)
 
 let rec case_of_union_aux (fields: c_fields)
   (fields_list: list string)
-  (u: Steel.C.Union.union (union_pcms fields))
+  (u: Steel.C.Model.Union.union (union_pcms fields))
 : Pure (option (field_of fields))
     (requires forall (field:string). field `mem` fields_list ==> fields.has_field field == true)
     (ensures fun field ->
@@ -67,7 +67,7 @@ let rec case_of_union_aux (fields: c_fields)
       if (fields.get_field field).is_unit (u field) then None else Some field
 
 let case_of_union (fields: nonempty_c_fields)
-  (u: Steel.C.Union.union (union_pcms fields))
+  (u: Steel.C.Model.Union.union (union_pcms fields))
 : field:field_of fields{case_refinement_f (union_pcms fields) field u}
 = match case_of_union_aux fields fields.cfields u with
   | None -> Some?.v fields.nonempty_witness
@@ -79,7 +79,7 @@ let union_views' (fields: c_fields) (field: field_of fields)
 
 let union_view (tag: Type0) (fields: nonempty_c_fields)
 : sel_view (union_pcm tag fields) (union tag fields) false
-= Steel.C.Union.union_view (union_views' fields) (case_of_union fields)
+= Steel.C.Model.Union.union_view (union_views' fields) (case_of_union fields)
 
 let dtuple2_of_union (#tag: Type0) (#fields: c_fields) (x: union tag fields)
 : dtuple2 (field_of fields) (union_views fields)
@@ -160,7 +160,7 @@ let addr_of_union_field'
     pts_to_view_elim p (union_view tag fields)
   in
   //  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
-  let q = Steel.C.Union.addr_of_union_field #_ #_ #(union_pcms fields) p field s in
+  let q = Steel.C.Model.Union.addr_of_union_field #_ #_ #(union_pcms fields) p field s in
 //  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   pts_to_view_intro q (Ghost.reveal s field)
     (fields.get_field field).view
@@ -196,7 +196,7 @@ let unaddr_of_union_field'
   let s: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  Steel.C.Union.unaddr_of_union_field #_ #_ #_ #(union_pcms fields) field q p s;
+  Steel.C.Model.Union.unaddr_of_union_field #_ #_ #_ #(union_pcms fields) field q p s;
   pts_to_view_intro p
     (field_to_union_f (union_pcms fields) field s)
     (union_view tag fields)
@@ -226,7 +226,7 @@ let exclusive_refine_union_field
   let aux frame
   : Lemma
     (requires 
-     Steel.C.PCM.composable
+     Steel.C.Model.PCM.composable
       (union_pcm tag fields)
       ((union_view tag fields).to_carrier (|old_field, old_value|))
       frame)
@@ -279,7 +279,7 @@ let switch_union_field''
   let upd: frame_preserving_upd (union_pcm tag fields) s new_s =
     base_fpu (union_pcm tag fields) s new_s
   in
-  Steel.C.Ref.ref_upd p s new_s upd;
+  Steel.C.Model.Ref.ref_upd p s new_s upd;
   pts_to_view_intro p new_s
     (union_view tag fields)
     (|field, new_value|);
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fsti b/ulib/experimental/Steel.C.UnionLiteral.fsti
index 2daa20cba0e..98efe7791a2 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fsti
+++ b/ulib/experimental/Steel.C.UnionLiteral.fsti
@@ -5,11 +5,11 @@ open Steel.Effect
 open Steel.Effect.Common
 open Steel.Effect.Atomic
 
-open Steel.C.PCM
-open Steel.C.Union
+open Steel.C.Model.PCM
+open Steel.C.Model.Union
 open Steel.C.Typedef
-open Steel.C.Ref
-open Steel.C.Connection
+open Steel.C.Model.Ref
+open Steel.C.Model.Connection
 open Steel.C.Opt
 open Steel.C.Fields
 

From b76d680c5bf046699ab1c68020980a6d32165566 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 18 Oct 2022 15:08:50 -0700
Subject: [PATCH 318/513] fix examples

---
 examples/steel/arraystructs/HaclExample.fst | 6 +++---
 examples/steel/arraystructs/PointStruct.fst | 6 +++---
 examples/steel/arraystructs/ScalarUnion.fst | 6 +++---
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index 17b65fcfe89..a112cf825a0 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -1,8 +1,8 @@
 module HaclExample
 
-open Steel.C.PCM
+open Steel.C.Model.PCM
 open Steel.C.Opt
-open Steel.C.Connection
+open Steel.C.Model.Connection
 open Steel.C.StructLiteral
 open Steel.C.Typedef
 open FStar.FunctionalExtensionality
@@ -10,7 +10,7 @@ open Steel.Effect
 open Steel.Effect.Atomic
 open Steel.C.Fields
 open Steel.C.Opt
-open Steel.C.Ref
+open Steel.C.Model.Ref
 open Steel.C.Reference
 open Steel.C.TypedefNorm
 open Steel.C.Array
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 020250e2f3e..5b262c5fa68 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -1,9 +1,9 @@
 module PointStruct
 
-open Steel.C.PCM
+open Steel.C.Model.PCM
 open Steel.C.Opt
-open Steel.C.Connection
-open Steel.C.Struct
+open Steel.C.Model.Connection
+open Steel.C.Model.Struct
 open Steel.C.StructLiteral
 open Steel.C.Typedef
 open FStar.FunctionalExtensionality
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index c33e4f08170..8c33defc526 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -1,8 +1,8 @@
 module ScalarUnion
 
-open Steel.C.PCM
+open Steel.C.Model.PCM
 open Steel.C.Opt
-open Steel.C.Connection
+open Steel.C.Model.Connection
 open Steel.C.StructLiteral
 open Steel.C.UnionLiteral
 open Steel.C.Typedef
@@ -10,7 +10,7 @@ open FStar.FunctionalExtensionality
 open Steel.Effect
 open Steel.Effect.Atomic
 open Steel.C.Fields
-open Steel.C.Ref
+open Steel.C.Model.Ref
 open Steel.C.Reference
 open Steel.C.TypedefNorm
 

From 989ea2476c4defa9788815a7371ec909e24e1149 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 19 Oct 2022 14:34:53 -0700
Subject: [PATCH 319/513] rename struct fields

---
 ulib/experimental/Steel.C.Model.Struct.fst | 219 +++++++++++++++++++++
 1 file changed, 219 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index 4f655c0a710..12248ebfc21 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -238,6 +238,225 @@ let struct_field
     ()
     (struct_field_lift_fpu p k)
 
+let is_substruct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+: Tot prop
+= (forall (k: a') . b' k == b (inj k) /\ p' k == p (inj k)) /\
+  (forall (k: a') . surj (inj k) == Some k) /\
+  (forall (k: a) . (match surj k with None -> True | Some k' -> inj k' == k))
+
+let substruct_to_struct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x: restricted_t a' b')
+: Pure (restricted_t a b)
+  (requires True)
+  (ensures (fun y -> forall k . y k == (match surj k with Some k' -> (x k' <: b k) | _ -> one (p k))))
+= on_dom a (fun k -> match surj k with Some k' -> (x k' <: b k) | _ -> one (p k))
+
+let substruct_to_struct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+: Tot (morphism (prod_pcm p') (prod_pcm p))
+= mkmorphism
+    (substruct_to_struct_f p p' inj surj sq)
+    (assert (substruct_to_struct_f p p' inj surj sq (one (prod_pcm p')) `feq` one (prod_pcm p)))
+    (fun x1 x2 ->
+      assert (prod_op p (substruct_to_struct_f p p' inj surj sq x1) (substruct_to_struct_f p p' inj surj sq x2) `feq` substruct_to_struct_f p p' inj surj sq (prod_op p' x1 x2))
+    )
+
+let struct_to_substruct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x: restricted_t a b)
+: Pure (restricted_t a' b')
+  (requires True)
+  (ensures (fun y -> forall k . y k == x (inj k)))
+= on_dom a' (fun k -> x (inj k) <: b' k)
+
+let struct_to_substruct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+: Tot (morphism (prod_pcm p) (prod_pcm p'))
+= mkmorphism
+    (struct_to_substruct_f p p' inj surj sq)
+    (assert (struct_to_substruct_f p p' inj surj sq (one (prod_pcm p)) `feq` one (prod_pcm p')))
+    (fun x1 x2 ->
+      assert (prod_op p' (struct_to_substruct_f p p' inj surj sq x1) (struct_to_substruct_f p p' inj surj sq x2) `feq` struct_to_substruct_f p p' inj surj sq (prod_op p x1 x2))
+    )
+
+let substruct_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
+  (y': Ghost.erased (restricted_t a' b'))
+  (f': frame_preserving_upd (prod_pcm p') x' y')
+  (v: restricted_t a b {
+    p_refine (prod_pcm p) v /\
+    compatible (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') v
+  })
+: Tot (restricted_t a b)
+= 
+    on_dom a (fun k ->
+      let v' = ((struct_to_substruct p p' inj surj sq).morph v) in
+      let x = Ghost.hide ((substruct_to_struct p p' inj surj sq).morph x') in
+      assert (forall frame . (composable (prod_pcm p) x frame /\ op (prod_pcm p) x frame == v) ==> (
+        let frame' = (struct_to_substruct p p' inj surj sq).morph frame in
+        composable (prod_pcm p') x' frame' /\ op (prod_pcm p') x' frame' `feq` v'
+      ));
+      assert ((~ (exists (k' : a') . True)) ==> Ghost.reveal x' `feq` one (prod_pcm p'));
+      match surj k with
+      | Some k' -> f' v' k' <: b k
+      | _ -> v k
+    )
+
+#push-options "--query_stats --z3rlimit 64 --split_queries"
+
+#restart-solver
+let substruct_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
+  (y': Ghost.erased (restricted_t a' b'))
+  (f': frame_preserving_upd (prod_pcm p') x' y')
+  (v: restricted_t a b {
+    p_refine (prod_pcm p) v /\
+    compatible (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') v
+  })
+: Lemma
+  (let v_new = substruct_lift_fpu' p p' inj surj sq x' y' f' v in
+    frame_preserving_upd_post (prod_pcm p)
+    ((substruct_to_struct p p' inj surj sq).morph x')
+    ((substruct_to_struct p p' inj surj sq).morph y')
+    v
+    (substruct_lift_fpu' p p' inj surj sq x' y' f' v)
+  )
+=
+  let y = (substruct_to_struct p p' inj surj sq).morph y' in
+  let v_new = substruct_lift_fpu' p p' inj surj sq x' y' f' v in
+  let v' = ((struct_to_substruct p p' inj surj sq).morph v) in
+  let x = Ghost.hide ((substruct_to_struct p p' inj surj sq).morph x') in
+  assert (forall frame . (composable (prod_pcm p) x frame /\ op (prod_pcm p) x frame == v) ==> (
+    let frame' = (struct_to_substruct p p' inj surj sq).morph frame in
+    composable (prod_pcm p') x' frame' /\ op (prod_pcm p') x' frame' `feq` v'
+  ));
+  assert ((~ (exists (k' : a') . True)) ==> Ghost.reveal x' `feq` one (prod_pcm p'));
+  assert (compatible (prod_pcm p') y' (f' v'));
+  assert (forall (frame': restricted_t a' b') .
+    (composable (prod_pcm p') y' frame' /\ op (prod_pcm p') frame' y' == f' v') ==> (
+    let frame : restricted_t a b = on_dom a (fun k -> match surj k with None -> v_new k | Some k' -> frame' k' <: b k) in
+    composable (prod_pcm p) y frame /\
+    op (prod_pcm p) frame y `feq` v_new
+  ));
+  assert (compatible (prod_pcm p) y v_new);
+  assert (p_refine (prod_pcm p) v_new);
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  let prf (frame: restricted_t a b) : Lemma
+    (requires (
+      composable (prod_pcm p) x frame
+    ))
+    (ensures (
+      composable (prod_pcm p) x frame /\
+      composable (prod_pcm p) y frame /\
+      (op (prod_pcm p) x frame == v ==> op (prod_pcm p) y frame `feq` v_new)
+    ))
+  =
+    let frame' = struct_to_substruct_f p p' inj surj sq frame in
+    assert (composable (prod_pcm p') x' frame');
+    assert (composable (prod_pcm p') y' frame');
+    assert (op (prod_pcm p) x frame == v ==> op (prod_pcm p') x' frame' `feq` v');
+    ()
+  in
+  Classical.forall_intro (Classical.move_requires prf)
+
+#pop-options
+
+let substruct_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
+  (y': Ghost.erased (restricted_t a' b'))
+  (f': frame_preserving_upd (prod_pcm p') x' y')
+: Tot (frame_preserving_upd (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') ((substruct_to_struct p p' inj surj sq).morph y'))
+= fun v ->
+    substruct_lift_fpu_prf p p' inj surj sq x' y' f' v;
+    substruct_lift_fpu' p p' inj surj sq x' y' f' v
+
+let substruct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+: Tot (connection (prod_pcm p) (prod_pcm p'))
+= mkconnection
+    (substruct_to_struct p p' inj surj sq)
+    (struct_to_substruct p p' inj surj sq)
+    (assert (forall x .
+      struct_to_substruct_f p p' inj surj sq (substruct_to_struct_f p p' inj surj sq x) `feq` x
+    ))
+    (substruct_lift_fpu p p' inj surj sq)
+
 let exclusive_struct_intro
   (#a: Type)
   (#b: a -> Type)

From cfbd27ffdc04e422656cf86434f718009834cc91 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 19 Oct 2022 16:16:03 -0700
Subject: [PATCH 320/513] renaming vs. id, compose

---
 ulib/experimental/Steel.C.Model.Struct.fst | 86 ++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index 12248ebfc21..eb0cabff256 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -457,6 +457,92 @@ let substruct
     ))
     (substruct_lift_fpu p p' inj surj sq)
 
+#push-options "--query_stats --z3rlimit 64"
+
+#restart-solver
+let substruct_id
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (inj: (a -> a))
+  (surj: (a -> option a))
+  (sq: squash (
+    (forall x . inj x == x) /\
+    (forall x . surj x == Some x)
+  ))
+: Lemma
+  (substruct p p inj surj () == connection_id (prod_pcm p))
+= let l = substruct p p inj surj () in
+  let m = connection_id (prod_pcm p) in
+  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
+    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
+  in
+  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) = () in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
+#push-options "--query_stats --z3rlimit 256"
+
+#restart-solver
+let substruct_compose
+  (#a1: eqtype)
+  (#b1: a1 -> Type)
+  (p1:(k: a1 -> pcm (b1 k)))
+  (#a2: eqtype)
+  (#b2: (a2 -> Type))
+  (p2: (k: a2 -> pcm (b2 k)))
+  (inj21: (a2 -> a1))
+  (surj12: (a1 -> option a2))
+  (sq12: squash (is_substruct p1 p2 inj21 surj12))
+  (#a3: eqtype)
+  (#b3: (a3 -> Type))
+  (p3: (k: a3 -> pcm (b3 k)))
+  (inj32: (a3 -> a2))
+  (surj23: (a2 -> option a3))
+  (sq23: squash (is_substruct p2 p3 inj32 surj23))
+  (inj31: (a3 -> a1))
+  (surj13: (a1 -> option a3))
+  (sq13: squash (is_substruct p1 p3 inj31 surj13))
+: Lemma
+  (requires (
+    (forall x3 . inj31 x3 == inj21 (inj32 x3)) /\
+    (forall x1 . surj13 x1 == (match surj12 x1 with
+    | None -> None
+    | Some x2 -> surj23 x2
+  ))))
+  (ensures (
+    substruct p1 p3 inj31 surj13 sq13 ==
+      substruct p1 p2 inj21 surj12 sq12 `connection_compose`
+      substruct p2 p3 inj32 surj23 sq23
+  ))
+=
+  let c12 = substruct p1 p2 inj21 surj12 sq12 in
+  let c23 = substruct p2 p3 inj32 surj23 sq23 in
+  let l = substruct p1 p3 inj31 surj13 sq13 in
+  let m = connection_compose c12 c23 in
+  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
+    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
+  in
+  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) =
+    assert (forall x . l.conn_large_to_small.morph x `feq` m.conn_large_to_small.morph x)
+  in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
 let exclusive_struct_intro
   (#a: Type)
   (#b: a -> Type)

From a00e4e6ede4e7783eab9f6eb0fd0ca5858c54dc5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 20 Oct 2022 16:07:29 -0700
Subject: [PATCH 321/513] substruct_field

---
 ulib/experimental/Steel.C.Model.Struct.fst | 35 ++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index eb0cabff256..d6749e64b4b 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -543,6 +543,41 @@ let substruct_compose
 
 #pop-options
 
+#push-options "--query_stats --z3rlimit 64"
+
+#restart-solver
+let substruct_field
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (field': a')
+: Lemma
+  (substruct p p' inj surj sq `connection_compose` struct_field p' field' ==
+    struct_field p (inj field')
+  )
+=
+  let l = substruct p p' inj surj sq `connection_compose` struct_field p' field' in
+  let m = struct_field p (inj field') in
+  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
+    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
+  in
+  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) = () in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
 let exclusive_struct_intro
   (#a: Type)
   (#b: a -> Type)

From 8cf82c06c135ef8cb04ec53ac4becf1f03a6b2c8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 21 Oct 2022 11:09:05 -0700
Subject: [PATCH 322/513] substruct_pts_to

---
 ulib/experimental/Steel.C.Model.Struct.fst | 112 +++++++++++++++++++++
 1 file changed, 112 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index d6749e64b4b..64632c358d6 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -578,6 +578,118 @@ let substruct_field
 
 #pop-options
 
+let substruct_erase_fields
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (surj: (a -> option a'))
+  (f: restricted_t a b)
+: Tot (restricted_t a b)
+= on_dom a (fun x -> if Some? (surj x) then one (p x) else f x)
+
+let substruct_erase_fields_op
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (f: restricted_t a b)
+: Lemma
+  (
+    let f_sub = substruct_to_struct_f p p' inj surj sq (struct_to_substruct_f p p' inj surj sq f) in
+    let f_rem = substruct_erase_fields p surj f in
+    composable (prod_pcm p) f_sub f_rem /\
+    op (prod_pcm p) f_sub f_rem `feq` f
+  )
+= Classical.forall_intro_2 (fun k -> is_unit (p k))
+
+let substruct_composable
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (f: restricted_t a b)
+  (g': restricted_t a' b')
+: Lemma
+  (requires (
+    forall x' . f (inj x') == one (p' x')
+  ))
+  (ensures (
+    let g = substruct_to_struct_f p p' inj surj sq g' in
+    composable (prod_pcm p) f g /\
+    (forall x . op (prod_pcm p) f g x == (match surj x with None -> f x | Some x' -> g' x' <: b x))
+  ))
+= Classical.forall_intro_2 (fun k -> is_unit (p k))
+
+let substruct_pts_to_intro
+  (#opened: _)
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (r: ref (prod_pcm p))
+  (f: restricted_t a b)
+: A.SteelGhostT unit opened
+    (pts_to r f)
+    (fun _ ->
+      pts_to r (substruct_erase_fields p surj f) `star`
+      pts_to (r `ref_focus` substruct p p' inj surj sq) (struct_to_substruct_f p p' inj surj sq f)
+    )
+= substruct_erase_fields_op p p' inj surj sq f;
+  split r _ (substruct_erase_fields p surj f) (substruct_to_struct_f p p' inj surj sq (struct_to_substruct_f p p' inj surj sq f));
+  gfocus r (substruct p p' inj surj sq) (substruct_to_struct_f _ _ _ _ _ _) _
+
+let substruct_pts_to_elim
+  (#opened: _)
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (r: ref (prod_pcm p))
+  (f: restricted_t a b)
+  (g': restricted_t a' b')
+: A.SteelGhost (Ghost.erased (restricted_t a b)) opened
+    (pts_to r f `star` pts_to (r `ref_focus` substruct p p' inj surj sq) g')
+    (fun res -> pts_to r res)
+    (fun _ ->
+      forall x' . f (inj x') == one (p' x')
+    )
+    (fun _ res _ ->
+      let g = substruct_to_struct_f p p' inj surj sq g' in
+      composable (prod_pcm p) f g /\
+      Ghost.reveal res == op (prod_pcm p) f g /\
+      (forall x . Ghost.reveal res x == (match surj x with None -> f x | Some x' -> g' x' <: b x))
+    )
+= substruct_composable p p' inj surj sq f g';
+  let g = substruct_to_struct_f p p' inj surj sq g' in
+  let res = Ghost.hide (op (prod_pcm p) f g) in
+  unfocus (r `ref_focus` _) r (substruct p p' inj surj sq) _;
+  gather r f _;
+  A.change_equal_slprop
+    (pts_to r _)
+    (pts_to r res);
+  res
+
 let exclusive_struct_intro
   (#a: Type)
   (#b: a -> Type)

From e2faca50df516caae9fe9346ce80817c0e062e48 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 21 Oct 2022 12:00:42 -0700
Subject: [PATCH 323/513] g_addr_of_struct_field, ghost unaddr_of_struct_field

---
 ulib/experimental/Steel.C.Model.Struct.fst  | 25 ++++++++++++++++-----
 ulib/experimental/Steel.C.StructLiteral.fst |  2 +-
 2 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index 64632c358d6..f37080b6fd8 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -750,6 +750,21 @@ let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
 = Classical.forall_intro_2 (fun k -> is_unit (p k));
   assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
 
+let g_addr_of_struct_field
+  (#opened: _)
+  (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: A.SteelGhostT unit opened
+    (r `pts_to` xs)
+    (fun _ ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (ref_focus r (struct_field p k) `pts_to` Ghost.reveal xs k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
+  gfocus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
+
 let addr_of_struct_field
   (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
   (r: ref (prod_pcm p)) (k:a)
@@ -802,19 +817,19 @@ let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
 let unaddr_of_struct_field
+  (#opened: _)
   (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
   (r': ref (p k)) (r: ref (prod_pcm p))
-  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
-: Steel unit
+  (xs: restricted_t a b) (x: b k)
+: A.SteelGhost unit opened
     ((r `pts_to` xs) `star` (r' `pts_to` x))
     (fun s -> r `pts_to` struct_with_field p k x xs)
-    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
+    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ xs k == one (p k))
     (ensures fun _ _ _ -> True)
 = unfocus r' r (struct_field p k) x;
   gather r xs (field_to_struct_f p k x);
   struct_unpeel p k x xs;
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  A.return ()
+  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 (*
 let struct_view_to_view_prop
diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
index 3dc49bb5a61..27b18569578 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ b/ulib/experimental/Steel.C.StructLiteral.fst
@@ -349,7 +349,7 @@ let unaddr_of_struct_field_ref' #tag #fields #excluded field p q =
   let t: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  unaddr_of_struct_field #_ #_ #(struct_pcms fields) field q p s t;
+  unaddr_of_struct_field #_ #_ #_ #(struct_pcms fields) field q p s t;
   let h1: squash (excluded field == true) = () in
   let h2: squash (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v) = () in
   let h3: squash (Ghost.reveal t == (fields.get_field field).view.to_carrier w) = () in

From 25338a320f9adba9470221267ce405a4173fc64a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 21 Oct 2022 21:47:09 -0700
Subject: [PATCH 324/513] arrays reloaded, generic on element pcm. join missing

---
 ulib/experimental/Steel.C.Model.Array.fst  | 696 +++++++++++++++++++++
 ulib/experimental/Steel.C.StdInt.Base.fst  |   2 +
 ulib/experimental/Steel.C.StdInt.Base.fsti |   4 +
 3 files changed, 702 insertions(+)
 create mode 100644 ulib/experimental/Steel.C.Model.Array.fst

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
new file mode 100644
index 00000000000..ad945eb238b
--- /dev/null
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -0,0 +1,696 @@
+module Steel.C.Model.Array
+
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+open Steel.C.Model.Ref
+open Steel.C.Model.Struct
+open Steel.C.StdInt
+open Steel.Effect
+module R = Steel.C.Model.Ref
+module A = Steel.Effect.Atomic
+
+(* Base array type *)
+
+let array_domain
+  (n: Ghost.erased size_t)
+: Tot Type0
+= (x: size_t { size_v x < size_v n })
+
+let array_range
+  (t: Type u#0)
+  (n: Ghost.erased size_t)
+  (x: array_domain n)
+: Tot Type0
+= t
+
+open FStar.FunctionalExtensionality
+
+let array_pcm_carrier
+  (t: Type)
+  (n: Ghost.erased size_t)
+: Tot Type
+= restricted_t (array_domain n) (array_range t n)
+
+let array_pcm_carrier_ext
+  (t: Type)
+  (n: size_t)
+  (x1 x2: array_pcm_carrier t n)
+  (f: (
+    (i: array_domain n) ->
+    Lemma
+    (x1 i == x2 i)
+  ))
+: Lemma
+  (ensures (x1 == x2))
+= Classical.forall_intro f;
+  assert (x1 `feq` x2)
+
+let array_elements_pcm
+  (#t: Type u#0)
+  (p: pcm t)
+  (n: Ghost.erased size_t)
+  (x: array_domain n)
+: Tot (Steel.C.Model.PCM.pcm (array_range t n x))
+= p
+
+let array_pcm
+  (#t: Type u#0)
+  (p: pcm t)
+  (n: Ghost.erased size_t)
+: Tot (pcm (array_pcm_carrier t n))
+= prod_pcm (array_elements_pcm p n)
+
+noeq
+type array
+  (#t: Type)
+  (p: pcm t)
+= {
+    base_len: Ghost.erased size_t;
+    base: R.ref (array_pcm p base_len);
+    offset: size_t;
+    len: Ghost.erased size_t;
+    prf: squash (size_v offset + size_v len <= size_v base_len);
+  }
+
+let length
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+: GTot nat
+= size_v a.len
+
+let adjacent
+  (#t: Type)
+  (#p: pcm t)
+  (a1 a2: array p)
+: Tot prop
+= a1.base_len == a2.base_len /\
+  a1.base == a2.base /\
+  size_v a1.offset + size_v a1.len == size_v a2.offset
+
+let merge
+  (#t: Type)
+  (#p: pcm t)
+  (a1 a2: array p)
+: Pure (array p)
+    (requires (adjacent a1 a2))
+    (ensures (fun y -> length y == length a1 + length a2))
+= {
+    base_len = a1.base_len;
+    base = a1.base;
+    offset = a1.offset;
+    len = size_add a1.len a2.len;
+    prf = ();
+  }
+
+let large_to_small_index
+  (large_len: size_t)
+  (offset: size_t)
+  (small_len: size_t)
+  (sq: squash (size_v offset + size_v small_len <= size_v large_len))
+  (x: array_domain large_len)
+: Tot (option (array_domain small_len))
+= if if offset `size_le` x then x `size_lt` (offset `size_add` small_len) else false
+  then Some (x `size_sub` offset)
+  else None
+
+let small_to_large_index
+  (large_len: size_t)
+  (offset: size_t)
+  (small_len: size_t)
+  (sq: squash (size_v offset + size_v small_len <= size_v large_len))
+  (x: array_domain small_len)
+: Tot (array_domain large_len)
+= offset `size_add` x
+
+let ref_of_array_conn
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+: GTot (connection (array_pcm p r.base_len) (array_pcm p r.len))
+= substruct (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) ()
+
+let ref_of_array
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+: GTot (R.ref (array_pcm p r.len))
+= R.ref_focus r.base (ref_of_array_conn r)
+
+let ref_of_array_id
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+: Lemma
+  (requires (
+    size_v r.offset == 0 /\
+    r.len == r.base_len
+  ))
+  (ensures (
+    ref_of_array r == r.base
+  ))
+= substruct_id (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) ();
+  R.ref_focus_id r.base
+
+let array_pcm_carrier_of_seq
+  (#t: Type)
+  (n: Ghost.erased size_t)
+  (s: Seq.lseq t (size_v n))
+: Tot (array_pcm_carrier t n)
+= on_dom (array_domain n) (fun i -> Seq.index s (size_v i) <: array_range t n i)
+
+let seq_of_array_pcm_carrier
+  (#t: Type)
+  (#n: Ghost.erased size_t)
+  (x: array_pcm_carrier t n)
+: GTot (Seq.lseq t (size_v n))
+= Seq.init (size_v n) (fun i -> x (int_to_size_t i) <: t)
+
+let array_pcm_carrier_of_seq_of_array_pcm_carrier
+  (#t: Type)
+  (#n: size_t)
+  (x: array_pcm_carrier t n)
+: Lemma
+  (array_pcm_carrier_of_seq n (seq_of_array_pcm_carrier x) `feq` x)
+= ()
+
+let seq_of_array_pcm_carrier_of_seq
+  (#t: Type)
+  (n: Ghost.erased size_t)
+  (s: Seq.lseq t (size_v n))
+: Lemma
+  (seq_of_array_pcm_carrier (array_pcm_carrier_of_seq n s) `Seq.equal` s)
+= ()
+
+let pts_to0
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (x: Seq.seq t)
+: Tot vprop
+= if Seq.length x = size_v r.len
+  then R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x)
+  else pure False
+
+let trivial_selector
+  (hp: Steel.Memory.slprop u#1)
+: Tot (selector unit hp)
+= fun _ -> ()
+
+[@@__steel_reduce__]
+let pts_to
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (x: Seq.seq t)
+: Tot vprop
+= VUnit ({
+    hp = hp_of (pts_to0 r x);
+    t = unit;
+    sel = trivial_selector _;
+  })
+
+let intro_pts_to'
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (x: Seq.lseq t (size_v r.len))
+: A.SteelGhostT unit opened
+   (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
+   (fun _ -> pts_to r x)
+= A.rewrite_slprop
+    (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
+    (pts_to r x)
+    (fun _ -> ())
+
+let intro_pts_to
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s: array_pcm_carrier t r.len)
+: A.SteelGhostT unit opened
+   (R.pts_to (ref_of_array r) s)
+   (fun _ -> pts_to r (seq_of_array_pcm_carrier s))
+= array_pcm_carrier_of_seq_of_array_pcm_carrier s;
+  A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _);
+  intro_pts_to' r (seq_of_array_pcm_carrier s)
+
+let intro_pts_to0
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s: array_pcm_carrier t r.len)
+  (s': Seq.seq t)
+: A.SteelGhost unit opened
+   (R.pts_to (ref_of_array r) s)
+   (fun _ -> pts_to r s')
+   (fun _ -> seq_of_array_pcm_carrier s `Seq.equal` s')
+   (fun _ _ _ -> True)
+= intro_pts_to r s;
+  A.change_equal_slprop (pts_to r (seq_of_array_pcm_carrier s)) (pts_to r s')
+
+let intro_pts_to1
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (r0: R.ref (array_pcm p r.len))
+  (s: array_pcm_carrier t r.len)
+  (s': Seq.seq t)
+: A.SteelGhost unit opened
+   (R.pts_to r0 s)
+   (fun _ -> pts_to r s')
+   (fun _ ->
+     r0 == ref_of_array r /\
+     seq_of_array_pcm_carrier s `Seq.equal` s'
+   )
+   (fun _ _ _ -> True)
+= A.change_equal_slprop (R.pts_to r0 s) (R.pts_to (ref_of_array r) s);
+  intro_pts_to0 r s s'
+
+let intro_pts_to2
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (#t0: Type)
+  (#p0: pcm t0)
+  (r0: R.ref p0)
+  (s: t0)
+  (s': Seq.seq t)
+: A.SteelGhost unit opened
+   (R.pts_to r0 s)
+   (fun _ -> pts_to r s')
+   (fun _ ->
+     t0 == array_pcm_carrier t r.len /\
+     p0 == array_pcm p r.len /\
+     r0 == ref_of_array r /\
+     seq_of_array_pcm_carrier (s <: array_pcm_carrier t r.len) `Seq.equal` s'
+   )
+   (fun _ _ _ -> True)
+= A.change_equal_slprop
+    (R.pts_to r0 s)
+    (R.pts_to (r0 <: R.ref (array_pcm p r.len)) s);
+  intro_pts_to1 r r0 s s'
+
+let elim_pts_to
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (x: Seq.seq t)
+: A.SteelGhostT (squash (Seq.length x == size_v r.len)) opened
+   (pts_to r x)
+   (fun _ -> R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
+= if Seq.length x = size_v r.len
+  then begin
+    A.rewrite_slprop
+      (pts_to r x)
+      (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
+      (fun _ -> ())
+  end else begin
+    A.change_slprop_rel
+      (pts_to r x)
+      (pure False)
+      (fun _ _ -> False)
+      (fun m -> 
+        assert (Steel.Memory.interp (hp_of (pure False)) m);
+        Steel.Memory.pure_interp False m 
+      );
+    A.rewrite_slprop
+      (pure False)
+      (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
+      (fun _ -> ())
+  end
+
+let pts_to_length
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (x: Seq.seq t)
+: A.SteelGhostT (squash (Seq.length x == size_v r.len)) opened
+    (pts_to r x)
+    (fun _ -> pts_to r x)
+=
+  elim_pts_to r _;
+  intro_pts_to0 r _ x
+
+let cell
+  (#t: Type)
+  (p: pcm t) 
+  (len: Ghost.erased size_t)
+  (i: size_t)
+: Pure (connection (array_pcm p len) p)
+    (requires (size_v i < size_v len))
+    (ensures (fun _ -> True))
+= struct_field (array_elements_pcm p len) i
+
+let g_focus_cell
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s: Seq.seq t)
+  (i: size_t)
+  (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
+: A.SteelGhostT (squash (size_v i < size_v r.len /\ size_v r.len == Seq.length s)) opened
+    (pts_to r s)
+    (fun _ -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to (ref_focus (ref_of_array r) (cell p r.len i)) (Seq.index s (size_v i)))
+= elim_pts_to r _;
+  g_addr_of_struct_field (ref_of_array r) i _;
+  intro_pts_to0 r _ (Seq.upd s (size_v i) (one p));
+  A.change_equal_slprop (R.pts_to (ref_focus _ _) _) (R.pts_to (ref_focus _ _) _)
+
+#push-options "--z3rlimit 16"
+
+let pts_to_elim_to_base
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (x: Seq.seq t)
+: A.SteelGhost (Ghost.erased (array_pcm_carrier t r.base_len)) opened
+    (pts_to r x)
+    (fun y -> R.pts_to r.base y)
+    (fun _ -> True)
+    (fun _ y _ ->
+      Seq.length x == size_v r.len /\
+      Ghost.reveal y == (ref_of_array_conn r).conn_small_to_large.morph (array_pcm_carrier_of_seq r.len x) /\
+      Ghost.reveal y == substruct_to_struct_f (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () (array_pcm_carrier_of_seq r.len x)
+    )
+= elim_pts_to r _;
+  unfocus (ref_of_array r) r.base (ref_of_array_conn r) _;
+  let y = Ghost.hide ((ref_of_array_conn r).conn_small_to_large.morph (array_pcm_carrier_of_seq r.len x)) in
+  A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _);
+  y
+
+#pop-options
+
+let pts_to_intro_from_base
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (y: array_pcm_carrier t r.base_len)
+  (x: Seq.seq t)
+: A.SteelGhost unit opened
+    (R.pts_to r.base y)
+    (fun _ -> pts_to r x)
+    (fun _ ->
+      Seq.length x == size_v r.len /\
+      y `feq` substruct_to_struct_f (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () (array_pcm_carrier_of_seq r.len x)
+    )
+    (fun _ _ _ -> True)
+= gfocus r.base (ref_of_array_conn r) _ (array_pcm_carrier_of_seq r.len x);
+  A.change_equal_slprop (R.pts_to _ _) (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x));
+  intro_pts_to0 r _ x
+
+#push-options "--z3rlimit 16 --split_queries"
+
+#restart-solver
+let focus_cell
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s: Ghost.erased (Seq.seq t))
+  (i: size_t)
+  (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
+: Steel (_: ref p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) })
+    (pts_to r s)
+    (fun r' -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to r' (Seq.index s (size_v i)))
+    (fun _ -> True)
+    (fun _ r' _ ->
+      r' == ref_focus (ref_of_array r) (cell p r.len i)
+    )
+= let y = pts_to_elim_to_base r _ in
+  ref_focus_comp r.base (ref_of_array_conn r) (cell p r.len i);
+  substruct_field (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () i;
+  let r' = addr_of_struct_field r.base (r.offset `size_add` i) _ in
+  pts_to_intro_from_base r _ _;
+  A.change_equal_slprop (R.pts_to r' _) (R.pts_to r' _);
+  A.return r'
+
+#pop-options
+
+let unfocus_cell
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s: Seq.seq t)
+  (i: size_t)
+  (r': R.ref p)
+  (v: t)
+  (sq: squash (size_v i < size_v r.len /\ size_v i < Seq.length s))
+: A.SteelGhost unit opened
+    (pts_to r s `star` R.pts_to r' v)
+    (fun _ -> pts_to r (Seq.upd s (size_v i) v))
+    (fun _ -> 
+      r' == ref_focus (ref_of_array r) (cell p r.len i) /\
+      Seq.index s (size_v i) == one p
+    )
+    (fun _ _ _ -> True)
+= elim_pts_to r _;
+  unaddr_of_struct_field #_ #_ #_ #(array_elements_pcm p r.len) i r' (ref_of_array r) _ _;
+  intro_pts_to0 r _ (Seq.upd s (size_v i) v)
+
+let share
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s s1 s2: Seq.seq t)
+: A.SteelGhost unit opened
+    (pts_to r s)
+    (fun _ -> pts_to r s1 `star` pts_to r s2)
+    (fun _ ->
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s /\
+      (forall (i: nat) .
+        i < Seq.length s ==> (
+        composable p (Seq.index s1 i) (Seq.index s2 i) /\
+        op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+      ))
+    )
+    (fun _ _ _ -> True)
+= elim_pts_to r _;
+  let a1 = array_pcm_carrier_of_seq r.len s1 in
+  let a2 = array_pcm_carrier_of_seq r.len s2 in
+  assert (
+    composable (array_pcm p r.len) a1 a2 /\
+    op (array_pcm p r.len) a1 a2 `feq` array_pcm_carrier_of_seq r.len s
+  );
+  R.split _ _ a1 a2;
+  intro_pts_to0 r a1 s1;
+  intro_pts_to0 r a2 s2
+
+let gather
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array p)
+  (s s1 s2: Seq.seq t)
+: A.SteelGhost unit opened
+    (pts_to r s1 `star` pts_to r s2)
+    (fun _ -> pts_to r s)
+    (fun _ ->
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s /\
+      (forall (i: nat) .
+        i < Seq.length s ==> (
+        composable p (Seq.index s1 i) (Seq.index s2 i) /\
+        op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+      ))
+    )
+    (fun _ _ _ -> True)
+= elim_pts_to r s1;
+  elim_pts_to r s2;
+  let a1 = array_pcm_carrier_of_seq r.len s1 in
+  let a2 = array_pcm_carrier_of_seq r.len s2 in
+  assert (
+    composable (array_pcm p r.len) a1 a2 /\
+    op (array_pcm p r.len) a1 a2 `feq` array_pcm_carrier_of_seq r.len s
+  );
+  R.gather _ (array_pcm_carrier_of_seq r.len s1) _;
+  intro_pts_to0 r _ s
+
+let split_l
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (i: size_t)
+: Pure (array p)
+    (requires (size_v i <= size_v a.len))
+    (ensures (fun _ -> True))
+= {
+    a with
+    len = i;
+  }
+
+let split_r
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (i: size_t)
+: Pure (array p)
+    (requires (size_v i <= size_v a.len))
+    (ensures (fun _ -> True))
+= {
+    a with
+    offset = a.offset `size_add` i;
+    len = a.len `size_sub` i;
+  }
+
+#push-options "--z3rlimit 64"
+
+#restart-solver
+let g_split_lhs
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (s: Seq.seq t)
+  (i: size_t)
+  (sq: squash (size_v i <= size_v a.len /\ Seq.length s == size_v a.len))
+  (sl: Seq.lseq t (size_v a.len))
+: A.SteelGhost unit opened
+    (pts_to a sl)
+    (fun _ -> pts_to (split_l a i) (Seq.slice s 0 (size_v i)))
+    (fun _ ->
+      let sl0 = Seq.slice s 0 (size_v i) in
+      sl == sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p)
+    )
+    (fun _ _ _ -> True)
+=
+  let sl0 = Seq.slice s 0 (size_v i) in
+  let al = split_l a i in
+  substruct_compose
+    (array_elements_pcm p a.base_len)
+    (array_elements_pcm p a.len)
+    (small_to_large_index a.base_len a.offset a.len ())
+    (large_to_small_index a.base_len a.offset a.len ())
+    ()
+    (array_elements_pcm p al.len)
+    (small_to_large_index a.len zero_size al.len ())
+    (large_to_small_index a.len zero_size al.len ())
+    ()
+    (small_to_large_index al.base_len al.offset al.len ())
+    (large_to_small_index al.base_len al.offset al.len ())
+    ();
+  let cl = 
+    substruct
+      (array_elements_pcm p a.len)
+      (array_elements_pcm p al.len)
+      (small_to_large_index a.len zero_size al.len ())
+      (large_to_small_index a.len zero_size al.len ())
+      ()
+  in
+  let xl = array_pcm_carrier_of_seq a.len sl in
+  elim_pts_to a sl;
+  ref_focus_comp
+    a.base
+    (ref_of_array_conn a)
+    cl;
+  let xl0 = array_pcm_carrier_of_seq al.len sl0 in
+  assert (
+    xl `feq` 
+      substruct_to_struct_f
+        (array_elements_pcm p a.len)
+        (array_elements_pcm p al.len)
+        (small_to_large_index a.len zero_size al.len ())
+        (large_to_small_index a.len zero_size al.len ())
+        ()
+        xl0
+  );
+  gfocus (ref_of_array a) cl _ xl0;
+  intro_pts_to2 (split_l a i) (ref_focus (ref_of_array a) cl) _ (Seq.slice s 0 (size_v i))
+
+#restart-solver
+let g_split_rhs
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (s: Seq.seq t)
+  (i: size_t)
+  (sq: squash (size_v i <= size_v a.len /\ Seq.length s == size_v a.len))
+  (sr: Seq.lseq t (size_v a.len))
+: A.SteelGhost unit opened
+    (pts_to a sr)
+    (fun _ -> pts_to (split_r a i) (Seq.slice s (size_v i) (size_v a.len)))
+    (fun _ ->
+      let sr0 = Seq.slice s (size_v i) (size_v a.len) in
+      sr == Seq.create (size_v i) (one p) `Seq.append` sr0
+    )
+    (fun _ _ _ -> True)
+=
+  let sr0 = Seq.slice s (size_v i) (size_v a.len) in
+  let ar = split_r a i in
+  substruct_compose
+    (array_elements_pcm p a.base_len)
+    (array_elements_pcm p a.len)
+    (small_to_large_index a.base_len a.offset a.len ())
+    (large_to_small_index a.base_len a.offset a.len ())
+    ()
+    (array_elements_pcm p ar.len)
+    (small_to_large_index a.len i ar.len ())
+    (large_to_small_index a.len i ar.len ())
+    ()
+    (small_to_large_index ar.base_len ar.offset ar.len ())
+    (large_to_small_index ar.base_len ar.offset ar.len ())
+    ();
+  let cr = 
+    substruct
+      (array_elements_pcm p a.len)
+      (array_elements_pcm p ar.len)
+      (small_to_large_index a.len i ar.len ())
+      (large_to_small_index a.len i ar.len ())
+      ()
+  in
+  let xr = array_pcm_carrier_of_seq a.len sr in
+  elim_pts_to a sr;
+  ref_focus_comp
+    a.base
+    (ref_of_array_conn a)
+    cr;
+  let xr0 = array_pcm_carrier_of_seq ar.len sr0 in
+  assert (
+    xr `feq` 
+      substruct_to_struct_f
+        (array_elements_pcm p a.len)
+        (array_elements_pcm p ar.len)
+        (small_to_large_index a.len i ar.len ())
+        (large_to_small_index a.len i ar.len ())
+        ()
+        xr0
+  );
+  gfocus (ref_of_array a) cr _ xr0;
+  intro_pts_to2 (split_r a i) (ref_focus (ref_of_array a) cr) _ (Seq.slice s (size_v i) (size_v a.len))
+
+#pop-options
+
+#restart-solver
+let g_split
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (s: Seq.seq t)
+  (i: size_t)
+  (sq: squash (size_v i <= size_v a.len))
+: A.SteelGhostT (squash (Seq.length s == size_v a.len)) opened
+    (pts_to a s)
+    (fun _ -> pts_to (split_l a i) (Seq.slice s 0 (size_v i)) `star` pts_to (split_r a i) (Seq.slice s (size_v i) (size_v a.len)))
+= pts_to_length a _;
+  Classical.forall_intro (is_unit p);
+  let sl0 = Seq.slice s 0 (size_v i) in
+  let sl : Seq.lseq t (size_v a.len) = sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p) in
+  let sr0 = Seq.slice s (size_v i) (size_v a.len) in
+  let sr : Seq.lseq t (size_v a.len) = Seq.create (size_v i) (one p) `Seq.append` sr0 in
+  share a s sl sr;
+  g_split_lhs a s i sq sl;
+  g_split_rhs a s i sq sr
diff --git a/ulib/experimental/Steel.C.StdInt.Base.fst b/ulib/experimental/Steel.C.StdInt.Base.fst
index af310ce16c7..2c7bc3a1c48 100644
--- a/ulib/experimental/Steel.C.StdInt.Base.fst
+++ b/ulib/experimental/Steel.C.StdInt.Base.fst
@@ -41,6 +41,8 @@ let size_div x y = x `U32.div` y
 
 let size_le x y = x `U32.lte` y
 
+let size_lt x y = x `U32.lt` y
+
 let ptrdiff_t = I64.t
 
 let ptrdiff_v x =
diff --git a/ulib/experimental/Steel.C.StdInt.Base.fsti b/ulib/experimental/Steel.C.StdInt.Base.fsti
index b98d9d08541..27f40e8e4f0 100644
--- a/ulib/experimental/Steel.C.StdInt.Base.fsti
+++ b/ulib/experimental/Steel.C.StdInt.Base.fsti
@@ -54,6 +54,10 @@ val size_le (x y: size_t) : Pure bool
   (requires True)
   (ensures (fun z -> z == (size_v x <= size_v y)))
 
+val size_lt (x y: size_t) : Pure bool
+  (requires True)
+  (ensures (fun z -> z == (size_v x < size_v y)))
+
 let zero_size : (zero_size: size_t { size_v zero_size == 0 }) = mk_size_t 0ul
 
 let one_size : (zero_size: size_t { size_v zero_size == 1 }) = mk_size_t 1ul

From e28d98444f6865bdfda85d44f42d4bfffef2c409 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sat, 22 Oct 2022 10:20:35 -0700
Subject: [PATCH 325/513] simplify g_split

---
 ulib/experimental/Steel.C.Model.Array.fst | 128 +++++++---------------
 1 file changed, 40 insertions(+), 88 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index ad945eb238b..d3e75fbcdad 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -518,19 +518,31 @@ let gather
   R.gather _ (array_pcm_carrier_of_seq r.len s1) _;
   intro_pts_to0 r _ s
 
-let split_l
+let sub
   (#t: Type)
   (#p: pcm t)
   (a: array p)
-  (i: size_t)
+  (offset: size_t)
+  (len: Ghost.erased size_t)
 : Pure (array p)
-    (requires (size_v i <= size_v a.len))
+    (requires (size_v offset + size_v len <= size_v a.len))
     (ensures (fun _ -> True))
 = {
     a with
-    len = i;
+    offset = a.offset `size_add` offset;
+    len = len;
   }
 
+let split_l
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (i: Ghost.erased size_t)
+: Pure (array p)
+    (requires (size_v i <= size_v a.len))
+    (ensures (fun _ -> True))
+= sub a zero_size i
+
 let split_r
   (#t: Type)
   (#p: pcm t)
@@ -539,35 +551,33 @@ let split_r
 : Pure (array p)
     (requires (size_v i <= size_v a.len))
     (ensures (fun _ -> True))
-= {
-    a with
-    offset = a.offset `size_add` i;
-    len = a.len `size_sub` i;
-  }
+= sub a i (a.len `size_sub` i)
 
 #push-options "--z3rlimit 64"
 
 #restart-solver
-let g_split_lhs
+let g_focus_sub
   (#opened: _)
   (#t: Type)
   (#p: pcm t)
   (a: array p)
   (s: Seq.seq t)
-  (i: size_t)
-  (sq: squash (size_v i <= size_v a.len /\ Seq.length s == size_v a.len))
+  (offset: size_t)
+  (len: size_t)
+  (sq: squash (size_v offset + size_v len <= size_v a.len /\ Seq.length s == size_v a.len))
   (sl: Seq.lseq t (size_v a.len))
+  (al: array p)
+  (sl0: Seq.lseq t (size_v len))
 : A.SteelGhost unit opened
     (pts_to a sl)
-    (fun _ -> pts_to (split_l a i) (Seq.slice s 0 (size_v i)))
+    (fun _ -> pts_to al sl0)
     (fun _ ->
-      let sl0 = Seq.slice s 0 (size_v i) in
-      sl == sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p)
+      al == sub a offset len /\
+      sl0 `Seq.equal` Seq.slice s (size_v offset) (size_v offset + size_v len) /\
+      sl `Seq.equal` (Seq.create (size_v offset) (one p) `Seq.append` sl0 `Seq.append` Seq.create (size_v a.len - size_v len - size_v offset) (one p))
     )
     (fun _ _ _ -> True)
 =
-  let sl0 = Seq.slice s 0 (size_v i) in
-  let al = split_l a i in
   substruct_compose
     (array_elements_pcm p a.base_len)
     (array_elements_pcm p a.len)
@@ -575,8 +585,8 @@ let g_split_lhs
     (large_to_small_index a.base_len a.offset a.len ())
     ()
     (array_elements_pcm p al.len)
-    (small_to_large_index a.len zero_size al.len ())
-    (large_to_small_index a.len zero_size al.len ())
+    (small_to_large_index a.len offset al.len ())
+    (large_to_small_index a.len offset al.len ())
     ()
     (small_to_large_index al.base_len al.offset al.len ())
     (large_to_small_index al.base_len al.offset al.len ())
@@ -585,8 +595,8 @@ let g_split_lhs
     substruct
       (array_elements_pcm p a.len)
       (array_elements_pcm p al.len)
-      (small_to_large_index a.len zero_size al.len ())
-      (large_to_small_index a.len zero_size al.len ())
+      (small_to_large_index a.len offset al.len ())
+      (large_to_small_index a.len offset al.len ())
       ()
   in
   let xl = array_pcm_carrier_of_seq a.len sl in
@@ -601,78 +611,18 @@ let g_split_lhs
       substruct_to_struct_f
         (array_elements_pcm p a.len)
         (array_elements_pcm p al.len)
-        (small_to_large_index a.len zero_size al.len ())
-        (large_to_small_index a.len zero_size al.len ())
+        (small_to_large_index a.len offset al.len ())
+        (large_to_small_index a.len offset al.len ())
         ()
         xl0
   );
   gfocus (ref_of_array a) cl _ xl0;
-  intro_pts_to2 (split_l a i) (ref_focus (ref_of_array a) cl) _ (Seq.slice s 0 (size_v i))
-
-#restart-solver
-let g_split_rhs
-  (#opened: _)
-  (#t: Type)
-  (#p: pcm t)
-  (a: array p)
-  (s: Seq.seq t)
-  (i: size_t)
-  (sq: squash (size_v i <= size_v a.len /\ Seq.length s == size_v a.len))
-  (sr: Seq.lseq t (size_v a.len))
-: A.SteelGhost unit opened
-    (pts_to a sr)
-    (fun _ -> pts_to (split_r a i) (Seq.slice s (size_v i) (size_v a.len)))
-    (fun _ ->
-      let sr0 = Seq.slice s (size_v i) (size_v a.len) in
-      sr == Seq.create (size_v i) (one p) `Seq.append` sr0
-    )
-    (fun _ _ _ -> True)
-=
-  let sr0 = Seq.slice s (size_v i) (size_v a.len) in
-  let ar = split_r a i in
-  substruct_compose
-    (array_elements_pcm p a.base_len)
-    (array_elements_pcm p a.len)
-    (small_to_large_index a.base_len a.offset a.len ())
-    (large_to_small_index a.base_len a.offset a.len ())
-    ()
-    (array_elements_pcm p ar.len)
-    (small_to_large_index a.len i ar.len ())
-    (large_to_small_index a.len i ar.len ())
-    ()
-    (small_to_large_index ar.base_len ar.offset ar.len ())
-    (large_to_small_index ar.base_len ar.offset ar.len ())
-    ();
-  let cr = 
-    substruct
-      (array_elements_pcm p a.len)
-      (array_elements_pcm p ar.len)
-      (small_to_large_index a.len i ar.len ())
-      (large_to_small_index a.len i ar.len ())
-      ()
-  in
-  let xr = array_pcm_carrier_of_seq a.len sr in
-  elim_pts_to a sr;
-  ref_focus_comp
-    a.base
-    (ref_of_array_conn a)
-    cr;
-  let xr0 = array_pcm_carrier_of_seq ar.len sr0 in
-  assert (
-    xr `feq` 
-      substruct_to_struct_f
-        (array_elements_pcm p a.len)
-        (array_elements_pcm p ar.len)
-        (small_to_large_index a.len i ar.len ())
-        (large_to_small_index a.len i ar.len ())
-        ()
-        xr0
-  );
-  gfocus (ref_of_array a) cr _ xr0;
-  intro_pts_to2 (split_r a i) (ref_focus (ref_of_array a) cr) _ (Seq.slice s (size_v i) (size_v a.len))
+  intro_pts_to2 al (ref_focus (ref_of_array a) cl) _ sl0
 
 #pop-options
 
+#push-options "--z3rlimit 16"
+
 #restart-solver
 let g_split
   (#opened: _)
@@ -692,5 +642,7 @@ let g_split
   let sr0 = Seq.slice s (size_v i) (size_v a.len) in
   let sr : Seq.lseq t (size_v a.len) = Seq.create (size_v i) (one p) `Seq.append` sr0 in
   share a s sl sr;
-  g_split_lhs a s i sq sl;
-  g_split_rhs a s i sq sr
+  g_focus_sub a s zero_size i () sl (split_l a i) (Seq.slice s 0 (size_v i));
+  g_focus_sub a s i (a.len `size_sub` i) () sr (split_r a i) (Seq.slice s (size_v i) (size_v a.len))
+
+#pop-options

From d1393ee3c9db862806bf72be1073ad1caa948cc3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sat, 22 Oct 2022 11:36:17 -0700
Subject: [PATCH 326/513] join

---
 ulib/experimental/Steel.C.Model.Array.fst | 104 ++++++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index d3e75fbcdad..a72bb6e960c 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -646,3 +646,107 @@ let g_split
   g_focus_sub a s i (a.len `size_sub` i) () sr (split_r a i) (Seq.slice s (size_v i) (size_v a.len))
 
 #pop-options
+
+#push-options "--z3rlimit 64"
+
+#restart-solver
+let unfocus_sub
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (s: Seq.seq t)
+  (offset: size_t)
+  (len: size_t)
+  (sq: squash (size_v offset + size_v len <= size_v a.len /\ Seq.length s == size_v a.len))
+  (sl: Seq.lseq t (size_v a.len))
+  (al: array p)
+  (sl0: Seq.lseq t (size_v len))
+: A.SteelGhost unit opened
+    (pts_to al sl0)
+    (fun _ -> pts_to a sl)
+    (fun _ ->
+      al == sub a offset len /\
+      sl0 `Seq.equal` Seq.slice s (size_v offset) (size_v offset + size_v len) /\
+      sl `Seq.equal` (Seq.create (size_v offset) (one p) `Seq.append` sl0 `Seq.append` Seq.create (size_v a.len - size_v len - size_v offset) (one p))
+    )
+    (fun _ _ _ -> True)
+=
+  substruct_compose
+    (array_elements_pcm p a.base_len)
+    (array_elements_pcm p a.len)
+    (small_to_large_index a.base_len a.offset a.len ())
+    (large_to_small_index a.base_len a.offset a.len ())
+    ()
+    (array_elements_pcm p al.len)
+    (small_to_large_index a.len offset al.len ())
+    (large_to_small_index a.len offset al.len ())
+    ()
+    (small_to_large_index al.base_len al.offset al.len ())
+    (large_to_small_index al.base_len al.offset al.len ())
+    ();
+  let cl = 
+    substruct
+      (array_elements_pcm p a.len)
+      (array_elements_pcm p al.len)
+      (small_to_large_index a.len offset al.len ())
+      (large_to_small_index a.len offset al.len ())
+      ()
+  in
+  let xl = array_pcm_carrier_of_seq a.len sl in
+  elim_pts_to al sl0;
+  ref_focus_comp
+    a.base
+    (ref_of_array_conn a)
+    cl;
+  let xl0 = array_pcm_carrier_of_seq al.len sl0 in
+  assert (
+    xl `feq` 
+      substruct_to_struct_f
+        (array_elements_pcm p a.len)
+        (array_elements_pcm p al.len)
+        (small_to_large_index a.len offset al.len ())
+        (large_to_small_index a.len offset al.len ())
+        ()
+        xl0
+  );
+  unfocus (ref_of_array al) (ref_of_array a) cl _;
+  intro_pts_to2 a (ref_of_array a) _ sl
+
+#pop-options
+
+#push-options "--z3rlimit 64 --fuel 0 --ifuel 1 --z3cliopt smt.arith.nl=false"
+
+#restart-solver
+let join
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (a: array p)
+  (i: size_t)
+  (al ar: array p)
+  (sl0 sr0: Seq.seq t)
+: A.SteelGhost unit opened
+    (pts_to al sl0 `star` pts_to ar sr0)
+    (fun _ -> pts_to a (sl0 `Seq.append` sr0))
+    (fun _ ->
+      size_v i <= size_v a.len /\
+      al == split_l a i /\
+      ar == split_r a i
+    )
+    (fun _ _ _ -> True)
+=
+  pts_to_length al _;
+  pts_to_length ar _;
+  Classical.forall_intro (is_unit p);
+  let sl : Seq.lseq t (size_v a.len) = sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p) in
+  let sr : Seq.lseq t (size_v a.len) = Seq.create (size_v i) (one p) `Seq.append` sr0 in
+  let s : Seq.lseq t (size_v a.len) = Seq.append sl0 sr0 in
+  assert (i == Ghost.reveal al.len);
+  assert (size_v zero_size == 0);
+  unfocus_sub a s zero_size i () sl al sl0;
+  unfocus_sub a s i (a.len `size_sub` i) () sr ar sr0;
+  gather a s sl sr;
+  A.change_equal_slprop (pts_to a _) (pts_to a _)
+
+#pop-options

From d26506ba7025232b4f8c58989aa3b40501083fa8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 23 Oct 2022 17:44:02 -0700
Subject: [PATCH 327/513] rlimit

---
 ulib/experimental/Steel.C.Model.Array.fst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index a72bb6e960c..66cd0f255c5 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -715,7 +715,7 @@ let unfocus_sub
 
 #pop-options
 
-#push-options "--z3rlimit 64 --fuel 0 --ifuel 1 --z3cliopt smt.arith.nl=false"
+#push-options "--z3rlimit 128 --fuel 0 --ifuel 1 --z3cliopt smt.arith.nl=false"
 
 #restart-solver
 let join

From b9e69da8af93e15a3e90aa4c3d4ce00f9ae1ae5b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 24 Oct 2022 09:34:55 -0700
Subject: [PATCH 328/513] Revert "snap"

This reverts commit d141e88fef98978116eb73b00cd0728f156d6382.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 838 +---------------------
 1 file changed, 15 insertions(+), 823 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 6ae9a687184..196817624df 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,47 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1017,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1055,21 +895,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1129,14 +966,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1149,36 +985,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1786,49 +1605,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1922,31 +1698,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2672,396 +2428,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Reference.null" ->
-          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3444,126 +2810,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
@@ -3682,61 +2929,6 @@ let (translate_let :
     fun flavor ->
       fun lb ->
         match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = uu___;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some
-              (uu___1, FStar_Extraction_ML_Syntax.MLTY_Named
-               ((FStar_Extraction_ML_Syntax.MLTY_Named
-                ([], view_type_name))::[], p));
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-            FStar_Extraction_ML_Syntax.mllb_def = fields;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-            FStar_Extraction_ML_Syntax.print_typ = uu___4;_} when
-            let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "Steel.C.StructLiteral.register_fields_of" ->
-            ((let uu___6 =
-                FStar_Extraction_ML_Syntax.string_of_mlpath view_type_name in
-              FStar_Compiler_Util.print1
-                "Found _ : register_fields_of %s. Fields are:\n" uu___6);
-             (let rec parse_fields fields1 =
-                match fields1 with
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_Name p1;
-                    FStar_Extraction_ML_Syntax.mlty = uu___6;
-                    FStar_Extraction_ML_Syntax.loc = uu___7;_} when
-                    let uu___8 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___8 = "Steel.C.StructLiteral.fields_nil" ->
-                    FStar_Compiler_Util.print_endline "End of fields"
-                | {
-                    FStar_Extraction_ML_Syntax.expr =
-                      FStar_Extraction_ML_Syntax.MLE_App
-                      ({
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Name p1;
-                         FStar_Extraction_ML_Syntax.mlty = uu___6;
-                         FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                       {
-                         FStar_Extraction_ML_Syntax.expr =
-                           FStar_Extraction_ML_Syntax.MLE_Const
-                           (FStar_Extraction_ML_Syntax.MLC_String name1);
-                         FStar_Extraction_ML_Syntax.mlty = uu___8;
-                         FStar_Extraction_ML_Syntax.loc = uu___9;_}::typedef::fields2::[]);
-                    FStar_Extraction_ML_Syntax.mlty = uu___10;
-                    FStar_Extraction_ML_Syntax.loc = uu___11;_} when
-                    let uu___12 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p1 in
-                    uu___12 = "Steel.C.StructLiteral.fields_cons" ->
-                    ((let uu___13 =
-                        FStar_Extraction_ML_Code.string_of_mlexpr ([], "")
-                          typedef in
-                      FStar_Compiler_Util.print2 "  Field %s : %s\n" name1
-                        uu___13);
-                     parse_fields fields2)
-                | uu___6 ->
-                    failwith "Couldn't parse fields from struct_fields" in
-              parse_fields fields; FStar_Pervasives_Native.None))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t0);

From 2658a6518670d5628b96ee391eee37a937de2275 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 24 Oct 2022 09:36:32 -0700
Subject: [PATCH 329/513] remove old unused case (pre struct literal
 refactoring)

---
 src/extraction/FStar.Extraction.Krml.fst | 27 ------------------------
 1 file changed, 27 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 0404c9a08dd..6e979e6b912 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -1396,33 +1396,6 @@ let translate_type_decl env ty: option decl =
 
 let translate_let env flavor lb: option decl =
   match lb with
-  | {
-      mllb_tysc = Some (_, MLTY_Named ([MLTY_Named ([], view_type_name)], p));
-      mllb_def = fields;
-    } when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.register_fields_of" ->
-      begin
-        BU.print1 "Found _ : register_fields_of %s. Fields are:\n"
-          (Syntax.string_of_mlpath view_type_name);
-        let rec parse_fields fields =
-          match fields with
-          | {expr=MLE_Name p}
-            when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.fields_nil"
-            ->
-            print_endline "End of fields"
-          | {expr=MLE_App ({expr=MLE_Name p},
-                           [{expr=MLE_Const (MLC_String name)}; typedef; fields])}
-            when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.fields_cons"
-            ->
-            BU.print2 "  Field %s : %s\n"
-              name
-              (FStar.Extraction.ML.Code.string_of_mlexpr ([], "") typedef);
-            parse_fields fields
-          | _ -> failwith "Couldn't parse fields from struct_fields"
-        in
-        parse_fields fields;
-        None
-      end
-
   | {
       mllb_name = name;
       mllb_tysc = Some (tvars, t0);

From 096261c9947007bd058089c4175eb507785ddf7e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 24 Oct 2022 09:36:54 -0700
Subject: [PATCH 330/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 783 +++++++++++++++++++++-
 1 file changed, 768 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 196817624df..7c341cbd75a 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,47 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1017,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,18 +1055,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -966,13 +1129,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -985,19 +1149,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1605,6 +1786,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1698,11 +1922,31 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2428,6 +2672,396 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Reference.null" ->
+          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2810,7 +3444,126 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 706999ab00d8a9ff6964597ef1a6b7c037a3f7ea Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 26 Oct 2022 18:35:24 -0700
Subject: [PATCH 331/513] spec and impl for an integrated C type hierarchy:
 scalars and structs

---
 examples/steel/arraystructs/Makefile         |   3 +-
 examples/steel/arraystructs/PointStruct2.fst |  39 ++
 ulib/experimental/Steel.C.Typenat.fsti       |  13 +
 ulib/experimental/Steel.C.Types.fst          | 524 +++++++++++++++++++
 ulib/experimental/Steel.C.Types.fsti         | 436 +++++++++++++++
 ulib/experimental/Steel.C.Typestring.fsti    |  15 +
 6 files changed, 1029 insertions(+), 1 deletion(-)
 create mode 100644 examples/steel/arraystructs/PointStruct2.fst
 create mode 100644 ulib/experimental/Steel.C.Types.fst
 create mode 100644 ulib/experimental/Steel.C.Types.fsti

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index f3c5b7f84f1..ea09c721ec6 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -59,7 +59,8 @@ ifdef KRML_HOME
 	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen krml \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
-ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
+# FIXME: add extraction rules for Steel.C.Types to support PointStruct2
+ALL_MODULE_NAMES=$(filter-out PointStruct2,$(basename $(ALL_SOURCE_FILES)))
 FILTERED_KRML_FILES=$(filter-out FStar_NMST.krml Steel_%.krml,$(ALL_KRML_FILES))
 
 extract: $(FILTERED_KRML_FILES)
diff --git a/examples/steel/arraystructs/PointStruct2.fst b/examples/steel/arraystructs/PointStruct2.fst
new file mode 100644
index 00000000000..7b208162a7e
--- /dev/null
+++ b/examples/steel/arraystructs/PointStruct2.fst
@@ -0,0 +1,39 @@
+module PointStruct2
+open Steel.C.Types
+
+module U32 = FStar.UInt32
+
+noextract
+inline_for_extraction
+let point_fields =
+  field_description_cons "x" (scalar U32.t) (
+  field_description_cons "y" (scalar U32.t) (
+  field_description_nil))
+
+let _ = define_struct "PointStruct.point" point_fields
+
+inline_for_extraction noextract
+let point = struct "PointStruct.point" point_fields
+
+#push-options "--query_stats --fuel 0"
+
+let swap_struct (p: ref point) (v: Ghost.erased (typeof point))
+: Steel (Ghost.erased (typeof point))
+    (p `pts_to` v)
+    (fun v' -> p `pts_to` v')
+    (requires fun _ ->
+      exists (vx vy: U32.t) . struct_get_field v "x" == mk_scalar vx /\ struct_get_field v "y" == mk_scalar vy
+    )
+    (ensures fun _ v' _ ->
+      struct_get_field v' "x" == struct_get_field v "y" /\
+      struct_get_field v' "y" == struct_get_field v "x"
+    )
+= let px = struct_field p "x" in
+  let py = struct_field p "y" in
+  let x = read px in
+  let y = read py in
+  write px y;
+  write py x;
+  unstruct_field p "x" px;
+  unstruct_field p "y" py;
+  return _
diff --git a/ulib/experimental/Steel.C.Typenat.fsti b/ulib/experimental/Steel.C.Typenat.fsti
index 5a10dc54f98..17f28a1e0bb 100644
--- a/ulib/experimental/Steel.C.Typenat.fsti
+++ b/ulib/experimental/Steel.C.Typenat.fsti
@@ -12,3 +12,16 @@ let rec nat_t_of_nat (n: nat): Type0 =
   match n with
   | 0 -> z
   | n -> s (nat_t_of_nat (n - 1))
+
+unfold
+let norm_typenat =
+  [
+    delta_only [
+      `%nat_t_of_nat;
+    ];
+    iota; zeta; primops;
+  ]
+
+let solve_nat_t_of_nat () =
+  FStar.Tactics.norm norm_typenat;
+  FStar.Tactics.trefl ()
diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
new file mode 100644
index 00000000000..c7d3f38b17f
--- /dev/null
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -0,0 +1,524 @@
+module Steel.C.Types
+open Steel.C.Model.PCM
+
+#set-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
+
+let prod_perm
+  p1 p2
+= let w = let open FStar.Real in P.MkPerm?.v p1 *. P.MkPerm?.v p2 in
+  assert (let open FStar.Real in (p2 `P.lesser_equal_perm` P.full_perm ==> w <=. P.MkPerm?.v p1 *. 1.0R));
+  P.MkPerm w
+
+noeq
+type typedef (t: Type0) : Type u#1 = {
+  pcm: pcm t;
+  fractionable: (t -> Tot prop);
+  mk_fraction: (
+    (x: t) ->
+    (p: P.perm) ->
+    Pure t
+    (requires (fractionable x))
+    (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> fractionable y))
+  );
+  mk_fraction_full: (
+    (x: t) ->
+    Lemma
+    (requires (fractionable x))
+    (ensures (fractionable x /\ mk_fraction x P.full_perm == x))
+  );
+  mk_fraction_compose: (
+    (x: t) ->
+    (p1: P.perm) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (fractionable x /\ p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm))
+    (ensures (mk_fraction (mk_fraction x p1) p2 == mk_fraction x (p1 `prod_perm` p2)))
+  );
+  fractionable_one: squash (fractionable (one pcm));
+  mk_fraction_one: (
+    (p: P.perm) ->
+    Lemma
+    (mk_fraction (one pcm) p == one pcm)
+  );
+  uninitialized: (y: t { exclusive pcm y });
+  mk_fraction_split: (
+    (v: t) ->
+    (p1: P.perm) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (fractionable v /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm))
+    (ensures (
+      composable pcm (mk_fraction v p1) (mk_fraction v p2)
+    ))
+  );
+  mk_fraction_join: (
+    (v: t) ->
+    (p1: P.perm) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (
+      fractionable v /\
+      composable pcm (mk_fraction v p1) (mk_fraction v p2)
+    ))
+    (ensures (
+      op pcm (mk_fraction v p1) (mk_fraction v p2) == mk_fraction v (p1 `P.sum_perm` p2)
+    ))
+  );
+}
+
+let fractionable td x = td.fractionable x
+let mk_fraction td x p = td.mk_fraction x p
+let mk_fraction_full td x = td.mk_fraction_full x
+let mk_fraction_compose td x p1 p2 = td.mk_fraction_compose x p1 p2
+
+let full td v = exclusive td.pcm v
+
+let uninitialized td = td.uninitialized
+
+let unknown td = one td.pcm
+
+let mk_fraction_unknown td p = td.mk_fraction_one p
+
+module R = Steel.C.Model.Ref
+
+let ptr td = R.ptr td.pcm
+let null _ = R.null _
+
+let _pts_to r v = hp_of (R.pts_to r v)
+
+#restart-solver
+let mk_fraction_split_gen
+  #_ #_ #td r v p p1 p2
+=
+  td.mk_fraction_split v p1 p2;
+  td.mk_fraction_join v p1 p2;
+  rewrite_slprop
+    (pts_to _ _)
+    (R.pts_to r (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)))
+    (fun _ -> ());
+  R.split r _ (td.mk_fraction v p1) (td.mk_fraction v p2);
+  rewrite_slprop
+    (R.pts_to r (td.mk_fraction v p1))
+    (pts_to r (mk_fraction td v p1))
+    (fun _ -> ());
+  rewrite_slprop
+    (R.pts_to r (td.mk_fraction v p2))
+    (pts_to r (mk_fraction td v p2))
+    (fun _ -> ())
+
+let mk_fraction_join
+  #_ #_ #td r v p1 p2
+=
+  rewrite_slprop
+    (pts_to r (mk_fraction td v p1))
+    (R.pts_to r (td.mk_fraction v p1))
+    (fun _ -> ());
+  rewrite_slprop
+    (pts_to r (mk_fraction td v p2))
+    (R.pts_to r (td.mk_fraction v p2))
+    (fun _ -> ());
+  R.gather r (td.mk_fraction v p1) (td.mk_fraction v p2);
+  td.mk_fraction_join v p1 p2;
+  rewrite_slprop
+    (R.pts_to _ _)
+    (pts_to _ _)
+    (fun _ -> ())
+
+module F = Steel.C.Model.Frac
+module U = Steel.C.Model.Uninit
+
+let scalar_t t = U.uninit_t (F.fractional t)
+
+let scalar_fractionable
+  (#t: Type)
+  (s: scalar_t t)
+: GTot prop
+= match s with
+  | U.InitOrUnit (Some (_, p)) -> (p `P.lesser_equal_perm` P.full_perm) == true
+  | U.InitOrUnit None -> True
+  | _ -> False
+
+[@@noextract_to "krml"] // proof-only
+let scalar_mk_fraction
+  (#t: Type)
+  (x: scalar_t t)
+  (p: P.perm)
+: Pure (scalar_t t)
+    (requires (scalar_fractionable x))
+    (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> scalar_fractionable y))
+= match x with
+  | U.InitOrUnit (Some (v, p')) ->
+    U.InitOrUnit (Some (v, p `prod_perm` p'))
+  | _ -> x
+
+#restart-solver
+let scalar t = {
+  pcm = U.pcm_uninit F.pcm_frac;
+  fractionable = scalar_fractionable #t;
+  mk_fraction = scalar_mk_fraction #t;
+  mk_fraction_full = (fun x ->
+    match x with
+    | U.InitOrUnit (Some (v, p)) ->
+      assert_norm ((P.full_perm `prod_perm` p).v == (let open FStar.Real in 1.0R *. p.v));
+      assert (P.full_perm `prod_perm` p == p)
+    | _ -> ()
+  );
+  mk_fraction_compose = (fun w p1 p2 ->
+    match w with
+    | U.InitOrUnit (Some (v, p)) ->
+      assert_norm (let open FStar.Real in ((p1 `prod_perm` p2) `prod_perm` p).v == (p1.v *. p2.v) *. p.v);
+      assert_norm (let open FStar.Real in (p2 `prod_perm` (p1 `prod_perm` p)).v == p2.v *. (p1.v *. p.v));
+      assert ((p1 `prod_perm` p2) `prod_perm` p == p2 `prod_perm` (p1 `prod_perm` p))
+    | _ -> ()
+  );
+  fractionable_one = ();
+  mk_fraction_one = (fun _ -> ());
+  uninitialized = U.Uninitialized;
+  mk_fraction_split = (fun w p1 p2 ->
+    match w with
+    | U.InitOrUnit (Some (v, p)) ->
+      assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
+      assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
+      assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p));
+      assert (composable (U.pcm_uninit F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2));
+()   //   assert (op (U.pcm_uninit F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2) == scalar_mk_fraction w (p1 `P.sum_perm` p2))
+    | _ -> ()
+  );
+  mk_fraction_join = (fun w p1 p2 ->
+    match w with
+    | U.InitOrUnit (Some (v, p)) ->
+      assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
+      assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
+      assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p))
+    | _ -> ()
+  );
+}
+
+let mk_scalar v = U.InitOrUnit (Some (v, P.full_perm))
+
+let mk_scalar_fractionable v p = ()
+
+let mk_scalar_inj v1 v2 p1 p2 = ()
+
+let scalar_unique
+  v1 v2 p1 p2 r
+=
+  rewrite_slprop
+    (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1))
+    (R.pts_to r (U.InitOrUnit (Some (v1, p1))))
+    (fun _ -> ());
+  rewrite_slprop
+    (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
+    (R.pts_to r (U.InitOrUnit (Some (v2, p2))))
+    (fun _ -> ());
+  R.gather r (U.InitOrUnit (Some (v1, p1))) (U.InitOrUnit (Some (v2, p2)));
+  R.split r _ (U.InitOrUnit (Some (v1, p1))) (U.InitOrUnit (Some (v2, p2)));
+  rewrite_slprop
+    (R.pts_to r (U.InitOrUnit (Some (v1, p1))))
+    (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1))
+    (fun _ -> ());
+  rewrite_slprop
+    (R.pts_to r (U.InitOrUnit (Some (v2, p2))))
+    (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
+    (fun _ -> ())
+
+let read0
+  #t #v #p r
+=
+  rewrite_slprop
+    (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+    (R.pts_to r (U.InitOrUnit (Some (Ghost.reveal v, p))))
+    (fun _ -> ());
+  let v' = R.ref_read r in
+  rewrite_slprop
+    (R.pts_to r (U.InitOrUnit (Some (Ghost.reveal v, p))))
+    (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+    (fun _ -> ());
+  let U.InitOrUnit (Some (v0, _)) = v' in
+  return v0
+
+let write
+  #t #v r v'
+=
+  rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  R.ref_upd r _ _ (R.base_fpu _ _ (U.InitOrUnit (Some (v', P.full_perm))));
+  rewrite_slprop
+    (R.pts_to r _)
+    (pts_to _ _)
+    (fun _ -> ())
+
+let field_t_nil = unit
+let field_t_cons _ _ _ = unit
+
+let define_struct0 _ _ _ = unit
+
+module S = Steel.C.Model.Struct
+
+[@@noextract_to "krml"] // proof-only
+let struct_field_pcm
+  (#tf: Type0)
+  (fields: field_description_t tf)
+  (f: field_t fields)
+: Tot (pcm (fields.fd_type f))
+= (fields.fd_typedef f).pcm
+
+module FX = FStar.FunctionalExtensionality
+
+let struct_t0 _ n fields =
+  FX.restricted_t (field_t fields) fields.fd_type
+
+[@@noextract_to "krml"] // proof-only
+let struct_pcm
+  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+: Tot (pcm (struct_t0 tn n fields))
+= S.prod_pcm (struct_field_pcm fields)
+
+[@@noextract_to "krml"] // proof-only
+let t_struct_set_field
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields)
+: Tot (struct_t0 tn n fields)
+= FX.on_dom (field_t fields) (fun f' -> if f = f' then v else s f')
+
+let struct_set_field = t_struct_set_field
+
+let struct_get_field
+  s field
+= s field
+
+let struct_eq
+  s1 s2
+= s1 `FX.feq` s2
+
+let struct_eq_intro
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s1 s2: struct_t0 tn n fields)
+  (prf: (
+    (f: field_t fields) ->
+    Lemma
+    (s1 f == s2 f)
+  ))
+: Lemma
+  (s1 == s2)
+= Classical.forall_intro prf;
+  assert (s1 `FX.feq` s2)
+
+let struct_get_field_same
+  s field v
+= ()
+
+let struct_get_field_other
+  s field v field'
+= ()
+
+let struct_fractionable
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+: GTot prop
+= forall (f: field_t fields) . (fields.fd_typedef f).fractionable (s f)
+
+[@@noextract_to "krml"] // proof-only
+let struct_mk_fraction
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (p: P.perm)
+: Pure (struct_t0 tn n fields)
+  (requires (struct_fractionable s))
+  (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> struct_fractionable s'))
+= FX.on_dom (field_t fields) (fun f -> (fields.fd_typedef f).mk_fraction (s f) p)
+
+[@@noextract_to "krml"] // proof-only
+let struct_uninitialized
+  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+: Tot (struct_t0 tn n fields)
+= FX.on_dom (field_t fields) (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f)
+
+let struct0
+  tn n fields
+= {
+  pcm = struct_pcm tn n fields;
+  fractionable = struct_fractionable;
+  mk_fraction = struct_mk_fraction;
+  mk_fraction_full = (fun x ->
+    struct_eq_intro (struct_mk_fraction x P.full_perm) x (fun f ->
+      (fields.fd_typedef f).mk_fraction_full (x f)
+    )
+  );
+  mk_fraction_compose = (fun x p1 p2 ->
+    struct_eq_intro (struct_mk_fraction (struct_mk_fraction x p1) p2) (struct_mk_fraction x (p1 `prod_perm` p2)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_compose (x f) p1 p2
+    )
+  );
+  fractionable_one = ();
+  mk_fraction_one = (fun p ->
+    struct_eq_intro (struct_mk_fraction (one (struct_pcm tn n fields)) p) (one (struct_pcm tn n fields)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_one p
+    )
+  );
+  uninitialized = struct_uninitialized _ _ _;
+  mk_fraction_split = (fun v p1 p2 ->
+    let prf
+      (f: field_t fields)
+    : Lemma
+      (composable (fields.fd_typedef f).pcm (mk_fraction (fields.fd_typedef f) (v f) p1) (mk_fraction (fields.fd_typedef f) (v f) p2))
+    = (fields.fd_typedef f).mk_fraction_split (v f) p1 p2
+    in
+    Classical.forall_intro prf
+  );
+  mk_fraction_join = (fun v p1 p2 ->
+    struct_eq_intro (op (struct_pcm tn n fields) (struct_mk_fraction v p1) (struct_mk_fraction v p2)) (struct_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_join (v f) p1 p2
+    )
+  );
+}
+
+let struct_get_field_unknown
+  tn n fields field
+= ()
+
+let struct_get_field_uninitialized
+  tn n fields field
+= ()
+
+let g_struct_field
+  #_ #_ #_ #fields r field
+= R.ref_focus r (S.struct_field (struct_field_pcm fields) field)
+
+#push-options "--z3rlimit 16"
+
+let ghost_struct_field
+  #_ #tn #_ #n #fields #v r field
+= rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  let prf
+    (f': field_t fields)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 prf;
+  let v' = struct_set_field field (unknown (fields.fd_typedef field)) v in
+  let vf = S.field_to_struct_f (struct_field_pcm fields) field (struct_get_field v field) in
+  assert (composable (struct_pcm tn n fields) v' vf);
+  assert (op (struct_pcm tn n fields) v' vf `FX.feq` v);
+  R.split r _ v' vf;
+  R.gfocus r (S.struct_field (struct_field_pcm fields) field) vf (struct_get_field v field);
+  rewrite_slprop
+    (R.pts_to r _)
+    (pts_to r _)
+    (fun _ -> ());
+  rewrite_slprop
+    (R.pts_to _ _)
+    (pts_to (g_struct_field r field) _)
+    (fun _ -> ())
+
+let struct_field
+  #_ #tn #_ #n #fields #v r field
+= rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  let prf
+    (f': field_t fields)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 prf;
+  let v' = Ghost.hide (struct_set_field field (unknown (fields.fd_typedef field)) v) in
+  let vf = Ghost.hide (S.field_to_struct_f (struct_field_pcm fields) field (struct_get_field v field)) in
+  assert (composable (struct_pcm tn n fields) v' vf);
+  assert (op (struct_pcm tn n fields) v' vf `FX.feq` v);
+  R.split r _ v' vf;
+  let r' = R.focus r (S.struct_field (struct_field_pcm fields) field) vf (struct_get_field v field) in
+  rewrite_slprop
+    (R.pts_to r _)
+    (pts_to r _)
+    (fun _ -> ());
+  rewrite_slprop
+    (R.pts_to _ _)
+    (pts_to r' _)
+    (fun _ -> ());
+  return r'
+
+let unstruct_field
+  #_ #tn #_ #n #fields #v r field #v' r'
+= rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  rewrite_slprop
+    (pts_to r' v')
+    (R.pts_to r' v')
+    (fun _ -> ());
+  let prf
+    (f': field_t fields)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 prf;
+  let vf = S.field_to_struct_f (struct_field_pcm fields) field v' in
+  assert (composable (struct_pcm tn n fields) v vf);
+  assert (op (struct_pcm tn n fields) v vf `FX.feq` struct_set_field field v' v);
+  R.unfocus r' r (S.struct_field (struct_field_pcm fields) field) _;
+  R.gather r v _;
+  rewrite_slprop
+    (R.pts_to r _)
+    (pts_to r _)
+    (fun _ -> ())
+
+#pop-options
+
+let fractionable_struct _ = ()
+let mk_fraction_struct _ _ _ = ()
+
+let full_struct
+  #tn #_ #n #fields s
+=
+  let is_unit'
+    (f': field_t fields)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 is_unit';
+  let prf
+    (field: field_t fields)
+  : Lemma
+    (requires (full (struct0 tn n fields) s))
+    (ensures (full (fields.fd_typedef field) (struct_get_field s field)))
+  = let prf'
+      (x: fields.fd_type field)
+    : Lemma
+      (requires (composable (fields.fd_typedef field).pcm (struct_get_field s field) x))
+      (ensures (x == one (fields.fd_typedef field).pcm))
+    = let s' = struct_set_field field x (one (struct_pcm tn n fields)) in
+      assert (composable (struct_pcm tn n fields) s s')
+    in
+    Classical.forall_intro (Classical.move_requires prf')
+  in
+  Classical.forall_intro (Classical.move_requires prf)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
new file mode 100644
index 00000000000..3b978915e2f
--- /dev/null
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -0,0 +1,436 @@
+module Steel.C.Types
+open Steel.C.Typenat
+open Steel.C.Typestring
+// open Steel.C.StdInt // for size_t
+include Steel.Effect.Common
+include Steel.Effect
+include Steel.Effect.Atomic
+
+module P = Steel.FractionalPermission
+
+/// Helper to compose two permissions into one
+val prod_perm (p1 p2: P.perm) : Pure P.perm
+  (requires True)
+  (ensures (fun p ->
+    ((p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm) ==>
+    p `P.lesser_equal_perm` P.full_perm) /\
+    p.v == (let open FStar.Real in p1.v *. p2.v)
+  ))
+
+[@@noextract_to "krml"] // proof-only
+val typedef (t: Type0) : Type u#1
+
+inline_for_extraction [@@noextract_to "krml"]
+let typeof (#t: Type0) (td: typedef t) : Tot Type0 = t
+
+val fractionable (#t: Type0) (td: typedef t) (x: t) : GTot prop
+
+val mk_fraction (#t: Type0) (td: typedef t) (x: t) (p: P.perm) : Ghost t
+  (requires (fractionable td x))
+  (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> fractionable td y))
+
+val mk_fraction_full (#t: Type0) (td: typedef t) (x: t) : Lemma
+  (requires (fractionable td x))
+  (ensures (mk_fraction td x P.full_perm == x))
+  [SMTPat (mk_fraction td x P.full_perm)]
+
+val mk_fraction_compose (#t: Type0) (td: typedef t) (x: t) (p1 p2: P.perm) : Lemma
+  (requires (fractionable td x /\ p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm))
+  (ensures (mk_fraction td (mk_fraction td x p1) p2 == mk_fraction td x (p1 `prod_perm` p2)))
+
+val full (#t: Type0) (td: typedef t) (v: t) : GTot prop
+
+val uninitialized (#t: Type0) (td: typedef t) : Ghost t
+  (requires True)
+  (ensures (fun y -> full td y))
+
+val unknown (#t: Type0) (td: typedef t) : Ghost t
+  (requires True)
+  (ensures (fun y -> fractionable td y))
+
+val mk_fraction_unknown (#t: Type0) (td: typedef t) (p: P.perm) : Lemma
+  (ensures (mk_fraction td (unknown td) p == unknown td))
+
+// To be extracted as: *t
+[@@noextract_to "krml"] // primitive
+val ptr (#t: Type) (td: typedef t) : Tot Type0
+[@@noextract_to "krml"] // primitive
+val null (#t: Type) (td: typedef t) : Tot (ptr td)
+inline_for_extraction [@@noextract_to "krml"]
+let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
+
+val _pts_to (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t) : Steel.Memory.slprop u#1
+let trivial_selector (hp: Steel.Memory.slprop u#1) : selector unit hp = fun _ -> ()
+[@@__steel_reduce__]
+let pts_to (#t: Type) (#td: typedef t) (r: ref td) ([@@@ smt_fallback ] v: Ghost.erased t) : vprop = VUnit ({
+  hp = _pts_to r v;
+  t = _;
+  sel = trivial_selector _;
+})
+
+val mk_fraction_split_gen
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p p1 p2: P.perm) : SteelGhost unit opened
+  (pts_to r (mk_fraction td v p))
+  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (fun _ -> p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ _ _ -> True)
+
+let mk_fraction_split
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p1 p2: P.perm) : SteelGhost unit opened
+  (pts_to r v)
+  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (fun _ -> P.full_perm == p1 `P.sum_perm` p2)
+  (fun _ _ _ -> True)
+= mk_fraction_full td v;
+  change_equal_slprop (pts_to _ _) (pts_to _ _);
+  mk_fraction_split_gen r v P.full_perm p1 p2
+
+val mk_fraction_join
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p1 p2: P.perm)
+: SteelGhostT unit opened
+  (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
+
+// To be extracted as: t
+[@@noextract_to "krml"] // primitive
+val scalar_t (t: Type0) : Type0
+[@@noextract_to "krml"] // proof-only
+val scalar (t: Type) : typedef (scalar_t t)
+val mk_scalar (#t: Type) (v: t) : Ghost (scalar_t t)
+  (requires True)
+  (ensures (fun y ->
+    fractionable (scalar t) y /\
+    full (scalar t) y
+  ))
+
+val mk_scalar_fractionable
+  (#t: Type)
+  (v: t)
+  (p: P.perm)
+: Lemma
+  (requires (fractionable (scalar t) (mk_fraction (scalar t) (mk_scalar v) p)))
+  (ensures (p `P.lesser_equal_perm` P.full_perm))
+
+val mk_scalar_inj
+  (#t: Type)
+  (v1 v2: t)
+  (p1 p2: P.perm)
+: Lemma
+  (requires (mk_fraction (scalar t) (mk_scalar v1) p1 == mk_fraction (scalar t) (mk_scalar v2) p2))
+  (ensures (v1 == v2 /\ p1 == p2))
+  [SMTPat [mk_fraction (scalar t) (mk_scalar v1) p1; mk_fraction (scalar t) (mk_scalar v2) p2]]
+
+val scalar_unique
+  (#opened: _)
+  (#t: Type)
+  (v1 v2: t)
+  (p1 p2: P.perm)
+  (r: ref (scalar t))
+: SteelGhost unit opened
+    (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
+    (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
+    (fun _ -> True)
+    (fun _ _ _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+
+[@@noextract_to "krml"] // primitive
+val read0 (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : Steel t
+  (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+  (fun _ -> True)
+  (fun _ v' _ -> v' == Ghost.reveal v)
+
+let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
+  (mk_scalar v == mk_fraction (scalar t) (mk_scalar v) P.full_perm)
+  [SMTPat (mk_scalar v)]
+= ()
+
+inline_for_extraction [@@noextract_to "krml"]
+let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : Steel t
+  (pts_to r v)
+  (fun _ -> pts_to r v)
+  (fun _ -> exists v0 p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p)
+  (fun _ v1 _ -> forall v0 p . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p ==> v0 == v1)
+= let v0 = FStar.IndefiniteDescription.indefinite_description_tot _ (fun v0 -> exists p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p) in
+  let p = FStar.IndefiniteDescription.indefinite_description_tot _ (fun p -> Ghost.reveal v == mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p) in
+  let prf v0' p' : Lemma
+    (requires (Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0') p'))
+    (ensures (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
+  = mk_scalar_inj (Ghost.reveal v0) v0' p p'
+  in
+  let prf' v0' p' : Lemma
+    (Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0') p' ==> (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
+  = Classical.move_requires (prf v0') p'
+  in
+  Classical.forall_intro_2 prf';
+  change_equal_slprop (pts_to _ _) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p));
+  let v1 = read0 r in
+  change_equal_slprop (pts_to _ _) (pts_to r v);
+  return v1
+
+[@@noextract_to "krml"] // primitive
+val write (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : Steel unit
+  (pts_to r v)
+  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
+  (fun _ -> Ghost.reveal v == uninitialized (scalar t) \/ (exists (v0: t) . Ghost.reveal v == mk_scalar v0))
+  (fun _ _ _ -> True)
+
+// To be extracted as: struct t { fields ... }
+[@@noextract_to "krml"] // primitive
+val field_t_nil: Type0
+[@@noextract_to "krml"] // primitive
+val field_t_cons (fn: Type0) (ft: Type0) (fc: Type0): Type0
+
+inline_for_extraction [@@noextract_to "krml"]
+noeq
+type field_description_t (t: Type0) : Type u#1 = {
+  fd_def: (string -> GTot bool);
+  fd_type: (string -> Type0);
+  fd_typedef: ((s: string) -> Pure (typedef (fd_type s)) (requires (fd_def s)) (ensures (fun _ -> True)));
+}
+
+[@@noextract_to "krml"] // proof-only
+let field_t (#t: Type0) (fd: field_description_t t) = (s: string { fd.fd_def s })
+
+inline_for_extraction [@@noextract_to "krml"]
+let field_description_nil : field_description_t field_t_nil = {
+  fd_def = (fun _ -> false);
+  fd_type = (fun _ -> unit);
+  fd_typedef = (fun _ -> false_elim ());
+}
+
+inline_for_extraction [@@noextract_to "krml"]
+let field_description_cons0
+  (fn: Type0) (#ft: Type0) (#fc: Type0) (n: string) (t: typedef ft) (fd: field_description_t fc)
+: Tot (field_description_t (field_t_cons fn ft fc))
+= {
+    fd_def = (fun n' -> n = n' || fd.fd_def n');
+    fd_type = (fun n' -> if n = n' then ft else fd.fd_type n');
+    fd_typedef = (fun n' -> if n = n' then t else fd.fd_typedef n');
+  }
+
+inline_for_extraction [@@noextract_to "krml"]
+let field_description_cons (#ft: Type0) (#fc: Type0) (n: string) (#fn: Type0) (# [ solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == fn))) (t: typedef ft) (fd: field_description_t fc) : Tot (field_description_t (field_t_cons fn ft fc)) =
+  field_description_cons0 fn #ft #fc n t fd
+
+[@@noextract_to "krml"] // primitive
+val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let define_struct (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+= define_struct0 tn #tf n fields
+
+// To be extracted as: struct t
+[@@noextract_to "krml"] // primitive
+val struct_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let struct_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+= struct_t0 tn #tf n fields
+
+val struct_set_field (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields) : GTot (struct_t0 tn n fields)
+
+val struct_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+: GTot (fields.fd_type field)
+
+val struct_eq
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s1 s2: struct_t0 tn n fields)
+: Ghost prop
+  (requires True)
+  (ensures (fun y ->
+    (y <==> (s1 == s2)) /\
+    (y <==> (forall field . struct_get_field s1 field == struct_get_field s2 field))
+  ))
+
+val struct_get_field_same
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+: Lemma
+  (struct_get_field (struct_set_field field v s) field == v)
+  [SMTPat (struct_get_field (struct_set_field field v s) field)]
+
+val struct_get_field_other
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+  (field': field_t fields)
+: Lemma
+  (requires (field' <> field))
+  (ensures (struct_get_field (struct_set_field field v s) field' == struct_get_field s field'))
+  [SMTPat (struct_get_field (struct_set_field field v s) field')]
+
+[@@noextract_to "krml"] // proof-only
+val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
+
+[@@noextract_to "krml"] // proof-only
+let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
+= struct0 tn #tf n fields
+
+val struct_get_field_unknown
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+: Lemma
+  (struct_get_field (unknown (struct0 tn n fields)) field == unknown (fields.fd_typedef field))
+  [SMTPat (struct_get_field (unknown (struct0 tn n fields)) field)]
+
+val struct_get_field_uninitialized
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+: Lemma
+  (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))
+  [SMTPat (struct_get_field (uninitialized (struct0 tn n fields)) field)]
+
+val g_struct_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: GTot (ref (fields.fd_typedef field))
+
+val ghost_struct_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: SteelGhostT unit opened
+    (pts_to r v)
+    (fun _ -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to (g_struct_field r field) (struct_get_field v field))
+
+[@@noextract_to "krml"] // primitive
+val struct_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
+    (pts_to r v)
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == g_struct_field r field)
+
+val unstruct_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    (pts_to r v `star` pts_to r' v')
+    (fun _ -> pts_to r (struct_set_field field v' v))
+    (fun _ ->
+      r' == g_struct_field r field /\
+      struct_get_field v field == unknown (fields.fd_typedef field)
+    )
+    (fun _ _ _ -> True)
+
+val fractionable_struct
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+: Lemma
+  (fractionable (struct0 tn n fields) s <==> (forall field . fractionable (fields.fd_typedef field) (struct_get_field s field)))
+  [SMTPat (fractionable (struct0 tn n fields) s)]
+
+val mk_fraction_struct
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (p: P.perm)
+  (field: field_t fields)
+: Lemma
+  (requires (fractionable (struct0 tn n fields) s))
+  (ensures (struct_get_field (mk_fraction (struct0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (struct_get_field s field) p))
+  [SMTPat (struct_get_field (mk_fraction (struct0 tn n fields) s p) field)]
+
+(*
+val mk_fraction_struct_recip
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (p: P.perm)
+: Ghost (struct_t0 tn n fields)
+  (requires (
+    (forall field . exists v . fractionable (fields.fd_typedef field) v /\ struct_get_field s field == mk_fraction (fields.fd_typedef field) v p)
+  ))
+  (ensures (fun s' ->
+    fractionable (struct0 tn n fields) s' /\
+    s == mk_fraction (struct0 tn n fields) s' p
+  ))
+*)
+
+val full_struct
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: struct_t0 tn n fields)
+: Lemma
+  (full (struct0 tn n fields) s <==> (forall field . full (fields.fd_typedef field) (struct_get_field s field)))
+  [SMTPat (full (struct0 tn n fields) s)]
+
+(*
+// To be extracted as: t[tn]
+val base_array_t (t: Type0) (tn: Type0 (* using Typenat *)) (n: size_t) : Type0
+noextract
+val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: size_t) : Tot (typedef (base_array_t t tn n))
+let base_array (#t: Type0) (td: typedef t) (n: size_t) (#tn: Type0) (# [ solve_nat_t_of_nat () ] prf: squash (norm norm_typenat (nat_t_of_nat (size_v n) == tn))) : Tot (typedef (base_array_t t tn n)) =
+  base_array0 #t tn td n
+val mk_base_array (#t: Type) (tn: Type0) (n: size_t) (v: Seq.seq t) : Ghost (base_array_t t tn n)
+  (requires (
+    Seq.length v == size_v n
+  ))
+  (ensures (fun y -> True))
+val mk_base_array_fractionable (#t: Type) (tn: Type0) (td: typedef t) (n: size_t) (v: Seq.seq t) : Lemma
+  (requires (Seq.length v == size_v n))
+  (ensures (
+    Seq.length v == size_v n /\  
+    fractionable (base_array0 tn td n) (mk_base_array tn n v) <==> (forall (i: nat) . i < Seq.length v ==> fractionable td (Seq.index v i))
+  ))
+// and that's all. users are not supposed to manipulate an array directly from its base reference. they should use an array instead.
+*)
diff --git a/ulib/experimental/Steel.C.Typestring.fsti b/ulib/experimental/Steel.C.Typestring.fsti
index ffdf1e5ee3b..9eae146ae25 100644
--- a/ulib/experimental/Steel.C.Typestring.fsti
+++ b/ulib/experimental/Steel.C.Typestring.fsti
@@ -149,3 +149,18 @@ let rec string_t_of_chars (s: list char): Type0 =
   | c :: s -> string_cons (char_t_of_char c) (string_t_of_chars s)
 
 let mk_string_t s: Type0 = string_t_of_chars (String.list_of_string s)
+
+unfold
+let norm_typestring =
+  [
+    delta_only [
+      `%char_t_of_char;
+      `%string_t_of_chars;
+      `%mk_string_t;
+    ];
+    iota; zeta; primops;
+  ]
+
+let solve_mk_string_t () =
+  FStar.Tactics.norm norm_typestring;
+  FStar.Tactics.trefl ()

From a3836b7af0b1010ed42198255e42c6853459a495 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 27 Oct 2022 15:58:25 -0700
Subject: [PATCH 332/513] re-enable extraction of PointStruct2 (CI failed
 anyway)

---
 examples/steel/arraystructs/Makefile | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index ea09c721ec6..f3c5b7f84f1 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -59,8 +59,7 @@ ifdef KRML_HOME
 	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen krml \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
-# FIXME: add extraction rules for Steel.C.Types to support PointStruct2
-ALL_MODULE_NAMES=$(filter-out PointStruct2,$(basename $(ALL_SOURCE_FILES)))
+ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
 FILTERED_KRML_FILES=$(filter-out FStar_NMST.krml Steel_%.krml,$(ALL_KRML_FILES))
 
 extract: $(FILTERED_KRML_FILES)

From b7e176284f91e9b5b9faaa500052a8f921fa0522 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 27 Oct 2022 16:09:39 -0700
Subject: [PATCH 333/513] Revert "snap"

This reverts commit 096261c9947007bd058089c4175eb507785ddf7e.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 783 +---------------------
 1 file changed, 15 insertions(+), 768 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 7c341cbd75a..196817624df 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,47 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1017,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1055,21 +895,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1129,14 +966,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1149,36 +985,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1786,49 +1605,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1922,31 +1698,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2672,396 +2428,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Reference.null" ->
-          EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3444,126 +2810,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From c658407d6c3606b2c8ec3bfc5524e31d2a14002a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 27 Oct 2022 16:23:03 -0700
Subject: [PATCH 334/513] extract scalars and pointers

---
 src/extraction/FStar.Extraction.Krml.fst | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 6e979e6b912..661b04e445e 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -465,7 +465,17 @@ let rec translate_type_without_decay env t: typ =
     Syntax.string_of_mlpath p = "Steel.C.Reference.ptr"
     ->
       TBuf (translate_type_without_decay env arg)
-      
+
+  | MLTY_Named ([arg; _], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Types.ptr"
+    ->
+      TBuf (translate_type_without_decay env arg)
+
+  | MLTY_Named ([arg], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Types.scalar_t"
+    ->
+      translate_type_without_decay env arg
+
   | MLTY_Named ([t; n; s], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
     ->
@@ -1020,6 +1030,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *)])
     when string_of_mlpath p = "Steel.C.Reference.null"
+    || string_of_mlpath p = "Steel.C.Types.null"
     -> EApp (EQualified (["LowStar"; "Buffer"], "null"), [EUnit])
 
 (* END support for the Steel null pointer *)
@@ -1069,6 +1080,16 @@ IsNull nodes should be added to the KaRaMeL AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *) ; _ (* perm *) ; r])
+    when string_of_mlpath p = "Steel.C.Types.read0" ->
+      EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *); r; x])
+    when string_of_mlpath p = "Steel.C.Types.write" ->
+      EAssign (
+        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
+        translate_expr env x)
+
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
       translate_expr env r

From 33ae7f2398d3385bb00fd13ad1820586378098a0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 27 Oct 2022 16:23:24 -0700
Subject: [PATCH 335/513] test scalars and pointers

---
 examples/steel/arraystructs/Makefile         |  2 +-
 examples/steel/arraystructs/PointStruct2.fst | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index f3c5b7f84f1..5f7468c282f 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -3,7 +3,7 @@ all: world
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
 FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
 
-INCLUDE_PATH = $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental
+INCLUDE_PATH = $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj
 
 ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
diff --git a/examples/steel/arraystructs/PointStruct2.fst b/examples/steel/arraystructs/PointStruct2.fst
index 7b208162a7e..64c2e217d91 100644
--- a/examples/steel/arraystructs/PointStruct2.fst
+++ b/examples/steel/arraystructs/PointStruct2.fst
@@ -2,7 +2,18 @@ module PointStruct2
 open Steel.C.Types
 
 module U32 = FStar.UInt32
+module C = C // for _zero_for_deref
 
+let swap (#v1 #v2: Ghost.erased U32.t) (r1 r2: ref (scalar U32.t)) : SteelT unit
+  ((r1 `pts_to` mk_scalar (Ghost.reveal v1)) `star` (r2 `pts_to` mk_scalar (Ghost.reveal v2)))
+  (fun _ -> (r1 `pts_to` mk_scalar (Ghost.reveal v2)) `star` (r2 `pts_to` mk_scalar (Ghost.reveal v1)))
+= let x1 = read r1 in
+  let x2 = read r2 in
+  write r1 x2;
+  write r2 x1;
+  return () // necessary to enable smt_fallback
+
+(*
 noextract
 inline_for_extraction
 let point_fields =
@@ -37,3 +48,4 @@ let swap_struct (p: ref point) (v: Ghost.erased (typeof point))
   unstruct_field p "x" px;
   unstruct_field p "y" py;
   return _
+*)

From e556ec7b202eb0659980addf50f2532c033cacc2 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 27 Oct 2022 16:23:48 -0700
Subject: [PATCH 336/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 837 +++++++++++++++++++++-
 1 file changed, 822 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 196817624df..4b7cf4d168d 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,55 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1025,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,18 +1063,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -966,13 +1137,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -985,19 +1157,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1605,6 +1794,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1698,11 +1930,31 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2428,6 +2680,442 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2810,7 +3498,126 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let parse_fields fields =
+           let rec go fields1 =
+             match fields1 with
+             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
+                 FStar_Pervasives_Native.Some []
+             | FStar_Extraction_ML_Syntax.MLTY_Named
+                 (field::t::fields2::[], p) when
+                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
+                 let uu___1 = string_of_typestring field in
+                 opt_bind uu___1
+                   (fun field1 ->
+                      if field1 = ""
+                      then go fields2
+                      else
+                        (let uu___3 = go fields2 in
+                         opt_bind uu___3
+                           (fun fields3 ->
+                              FStar_Pervasives_Native.Some ((field1, t) ::
+                                fields3))))
+             | uu___1 -> FStar_Pervasives_Native.None in
+           let uu___1 = go fields in
+           match uu___1 with
+           | FStar_Pervasives_Native.None ->
+               ((let uu___3 =
+                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+                 FStar_Compiler_Util.print1
+                   "Failed to parse fields from %s.\n" uu___3);
+                FStar_Pervasives_Native.None)
+           | FStar_Pervasives_Native.Some fields1 ->
+               (FStar_Compiler_Util.print_endline "Got fields:";
+                FStar_Compiler_List.fold_left
+                  (fun uu___4 ->
+                     fun uu___5 ->
+                       match uu___5 with
+                       | (field, ty1) ->
+                           let uu___6 =
+                             FStar_Extraction_ML_Code.string_of_mlty 
+                               ([], "") ty1 in
+                           FStar_Compiler_Util.print2 "  %s : %s\n" field
+                             uu___6) () fields1;
+                (let uu___4 =
+                   FStar_Compiler_List.map
+                     (fun uu___5 ->
+                        match uu___5 with
+                        | (field, ty1) ->
+                            ((let uu___7 =
+                                FStar_Extraction_ML_Code.string_of_mlty
+                                  ([], "") ty1 in
+                              FStar_Compiler_Util.print1 "Translating %s.\n"
+                                uu___7);
+                             (let uu___7 =
+                                translate_type_without_decay env1 ty1 in
+                              (field, uu___7)))) fields1 in
+                 FStar_Pervasives_Native.Some uu___4)) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   let uu___8 =
+                     let uu___9 =
+                       let uu___10 =
+                         FStar_Compiler_List.map
+                           (fun uu___11 ->
+                              match uu___11 with
+                              | (field, ty1) -> (field, (ty1, true))) fields1 in
+                       (p1, [], Prims.int_zero, uu___10) in
+                     DTypeFlat uu___9 in
+                   FStar_Pervasives_Native.Some uu___8))
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_fields fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From cd603869f91e87d7985a8e908416b9ea6fc55b32 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 10:39:03 -0700
Subject: [PATCH 337/513] fix bundle

---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 5f7468c282f..fe5cd5b1287 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -63,7 +63,7 @@ ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
 FILTERED_KRML_FILES=$(filter-out FStar_NMST.krml Steel_%.krml,$(ALL_KRML_FILES))
 
 extract: $(FILTERED_KRML_FILES)
-	$(KRML_EXE) -skip-compilation -skip-makefiles -bundle 'FStar.\*,Steel.\*' $^
+	$(KRML_EXE) -skip-compilation -skip-makefiles -bundle 'FStar.\*,Steel.\*,C' $^
 	touch $@
 
 ALL_C_FILES=$(addsuffix .c,$(ALL_MODULE_NAMES))

From 744182f36b7816cb66bfe3713733f6770951615f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 11:21:53 -0700
Subject: [PATCH 338/513] Revert "snap"

This reverts commit e556ec7b202eb0659980addf50f2532c033cacc2.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 837 +---------------------
 1 file changed, 15 insertions(+), 822 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 4b7cf4d168d..196817624df 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,55 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1025,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1063,21 +895,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1137,14 +966,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1157,36 +985,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1794,49 +1605,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1930,31 +1698,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2680,442 +2428,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3498,126 +2810,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let parse_fields fields =
-           let rec go fields1 =
-             match fields1 with
-             | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_nil" ->
-                 FStar_Pervasives_Native.Some []
-             | FStar_Extraction_ML_Syntax.MLTY_Named
-                 (field::t::fields2::[], p) when
-                 let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "Steel.C.Fields.c_fields_t_cons" ->
-                 let uu___1 = string_of_typestring field in
-                 opt_bind uu___1
-                   (fun field1 ->
-                      if field1 = ""
-                      then go fields2
-                      else
-                        (let uu___3 = go fields2 in
-                         opt_bind uu___3
-                           (fun fields3 ->
-                              FStar_Pervasives_Native.Some ((field1, t) ::
-                                fields3))))
-             | uu___1 -> FStar_Pervasives_Native.None in
-           let uu___1 = go fields in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               ((let uu___3 =
-                   FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-                 FStar_Compiler_Util.print1
-                   "Failed to parse fields from %s.\n" uu___3);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some fields1 ->
-               (FStar_Compiler_Util.print_endline "Got fields:";
-                FStar_Compiler_List.fold_left
-                  (fun uu___4 ->
-                     fun uu___5 ->
-                       match uu___5 with
-                       | (field, ty1) ->
-                           let uu___6 =
-                             FStar_Extraction_ML_Code.string_of_mlty 
-                               ([], "") ty1 in
-                           FStar_Compiler_Util.print2 "  %s : %s\n" field
-                             uu___6) () fields1;
-                (let uu___4 =
-                   FStar_Compiler_List.map
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (field, ty1) ->
-                            ((let uu___7 =
-                                FStar_Extraction_ML_Code.string_of_mlty
-                                  ([], "") ty1 in
-                              FStar_Compiler_Util.print1 "Translating %s.\n"
-                                uu___7);
-                             (let uu___7 =
-                                translate_type_without_decay env1 ty1 in
-                              (field, uu___7)))) fields1 in
-                 FStar_Pervasives_Native.Some uu___4)) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing struct definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         FStar_Compiler_List.map
-                           (fun uu___11 ->
-                              match uu___11 with
-                              | (field, ty1) -> (field, (ty1, true))) fields1 in
-                       (p1, [], Prims.int_zero, uu___10) in
-                     DTypeFlat uu___9 in
-                   FStar_Pervasives_Native.Some uu___8))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_fields fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 83540762c0b25b472b97da41b053b032abfe9efd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 12:17:56 -0700
Subject: [PATCH 339/513] extract structs

---
 examples/steel/arraystructs/PointStruct2.fst |  8 +--
 src/extraction/FStar.Extraction.Krml.fst     | 65 ++++++++++++++------
 ulib/experimental/Steel.C.Types.fsti         |  2 +-
 3 files changed, 52 insertions(+), 23 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct2.fst b/examples/steel/arraystructs/PointStruct2.fst
index 64c2e217d91..e35535d0bc8 100644
--- a/examples/steel/arraystructs/PointStruct2.fst
+++ b/examples/steel/arraystructs/PointStruct2.fst
@@ -13,7 +13,6 @@ let swap (#v1 #v2: Ghost.erased U32.t) (r1 r2: ref (scalar U32.t)) : SteelT unit
   write r2 x1;
   return () // necessary to enable smt_fallback
 
-(*
 noextract
 inline_for_extraction
 let point_fields =
@@ -21,10 +20,10 @@ let point_fields =
   field_description_cons "y" (scalar U32.t) (
   field_description_nil))
 
-let _ = define_struct "PointStruct.point" point_fields
+let _ = define_struct "PointStruct2.point" point_fields
 
 inline_for_extraction noextract
-let point = struct "PointStruct.point" point_fields
+let point = struct "PointStruct2.point" point_fields
 
 #push-options "--query_stats --fuel 0"
 
@@ -48,4 +47,5 @@ let swap_struct (p: ref point) (v: Ghost.erased (typeof point))
   unstruct_field p "x" px;
   unstruct_field p "y" py;
   return _
-*)
+
+#pop-options
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 661b04e445e..67f31af8694 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -455,7 +455,12 @@ let rec translate_type_without_decay env t: typ =
     BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
     ->
       TQualified (must (lident_of_typestring tag))
-  
+
+  | MLTY_Named ([tag; _; _; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.Types.struct_t0"
+    ->
+      TQualified (must (lident_of_typestring tag))
+
   | MLTY_Named ([tag; _], p) when
     BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
     ->
@@ -1052,6 +1057,20 @@ IsNull nodes should be added to the KaRaMeL AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)},
+             [_ (* opened *)
+               ; ({expr=MLE_Const (MLC_String struct_name)})
+               ; _ (* fields *)
+               ; _ (* v *)
+               ; r
+               ; ({expr=MLE_Const (MLC_String field_name)})
+             ])
+    when string_of_mlpath p = "Steel.C.Types.struct_field" ->
+      EAddrOf (EField (
+        TQualified (must (lident_of_string struct_name)),
+        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
+        field_name))
+
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
@@ -1291,27 +1310,25 @@ and translate_constant c: expr =
 and mk_op_app env w op args =
   EApp (EOp (op, w), List.map (translate_expr env) args)
 
-let translate_type_decl env ty: option decl =
-  if List.mem Syntax.NoExtract ty.tydecl_meta then
-    None
-  else
-    // JL: TODO: hoist?
-    let parse_fields (fields: mlty): option (list _) =
+let parse_steel_c_fields env (fields: mlty): option (list _) =
       let rec go fields =
         match fields with
         | MLTY_Named ([], p)
           when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
+          || Syntax.string_of_mlpath p = "Steel.C.Types.field_t_nil"
           -> Some []
           
         | MLTY_Named ([field; t; fields], p)
           when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
+          || Syntax.string_of_mlpath p = "Steel.C.Types.field_t_cons"
           ->
           opt_bind (string_of_typestring field) (fun field ->
           if field = "" then go fields else
           opt_bind (go fields) (fun fields ->
           Some ((field, t) :: fields)))
-  
-        | _ -> None
+
+        | _ ->
+          None
       in
       match go fields with
       | None ->
@@ -1335,12 +1352,14 @@ let translate_type_decl env ty: option decl =
                    (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
                  (field, translate_type_without_decay env ty))
               fields)
-    in
-    match ty with
-    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
-      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
-      ->
-      begin
+
+let translate_type_decl env ty: option decl =
+  if List.mem Syntax.NoExtract ty.tydecl_meta then
+    None
+  else
+    let define_struct
+      tag fields
+    =
         (* JL: TODO remove/improve these print commands *)
         print_endline "Parsing struct definition.";
         begin match lident_of_typestring tag with
@@ -1349,11 +1368,21 @@ let translate_type_decl env ty: option decl =
             (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
           None
         | Some p ->
-          let fields = must (parse_fields fields) in
+          let fields = must (parse_steel_c_fields env fields) in
           Some (DTypeFlat (p, [], 0,
             List.map (fun (field, ty) -> (field, (ty, true))) fields))
         end
-      end
+    in
+    match ty with
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
+      ->
+      define_struct tag fields
+
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.Types.define_struct0"
+      ->
+      define_struct tag fields
 
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
       when Syntax.string_of_mlpath p = "Steel.C.UnionLiteral.mk_union_def"
@@ -1367,7 +1396,7 @@ let translate_type_decl env ty: option decl =
             (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
           None
         | Some p ->
-          let fields = must (parse_fields fields) in
+          let fields = must (parse_steel_c_fields env fields) in
           Some (DUntaggedUnion (p, [], 0, fields))
         end
       end
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 3b978915e2f..11088ed77f9 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -329,9 +329,9 @@ val ghost_struct_field
 
 [@@noextract_to "krml"] // primitive
 val struct_field
-  (#opened: _)
   (#tn: Type0)
   (#tf: Type0)
+  (#opened: _)
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))

From 3f93f7aa88bcc306728ec5fd82f41a8cc479a198 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 15:19:32 -0700
Subject: [PATCH 340/513] remove field pointer cast at extraction

---
 examples/steel/arraystructs/PointStruct2.fst |  1 +
 src/extraction/FStar.Extraction.Krml.fst     |  3 +-
 ulib/experimental/Steel.C.Types.fst          | 27 +++++++++++-
 ulib/experimental/Steel.C.Types.fsti         | 44 +++++++++++++++++---
 4 files changed, 67 insertions(+), 8 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct2.fst b/examples/steel/arraystructs/PointStruct2.fst
index e35535d0bc8..307e3e80f6b 100644
--- a/examples/steel/arraystructs/PointStruct2.fst
+++ b/examples/steel/arraystructs/PointStruct2.fst
@@ -15,6 +15,7 @@ let swap (#v1 #v2: Ghost.erased U32.t) (r1 r2: ref (scalar U32.t)) : SteelT unit
 
 noextract
 inline_for_extraction
+[@@ norm_field_attr]
 let point_fields =
   field_description_cons "x" (scalar U32.t) (
   field_description_cons "y" (scalar U32.t) (
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 67f31af8694..4b312fc811f 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -1064,8 +1064,9 @@ IsNull nodes should be added to the KaRaMeL AST *)
                ; _ (* v *)
                ; r
                ; ({expr=MLE_Const (MLC_String field_name)})
+               ; _ (* td' *)
              ])
-    when string_of_mlpath p = "Steel.C.Types.struct_field" ->
+    when string_of_mlpath p = "Steel.C.Types.struct_field0" ->
       EAddrOf (EField (
         TQualified (must (lident_of_string struct_name)),
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index c7d3f38b17f..5f826a5596c 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -253,6 +253,8 @@ let write
 let field_t_nil = unit
 let field_t_cons _ _ _ = unit
 
+irreducible let norm_field_attr = ()
+
 let define_struct0 _ _ _ = unit
 
 module S = Steel.C.Model.Struct
@@ -423,8 +425,21 @@ let ghost_struct_field
     (pts_to (g_struct_field r field) _)
     (fun _ -> ())
 
-let struct_field
-  #_ #tn #_ #n #fields #v r field
+[@@noextract_to "krml"] // primitive
+let struct_field'
+  (#tn: Type0)
+  (#tf: Type0)
+  (#opened: _)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
+    (pts_to r v)
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == g_struct_field r field)
 = rewrite_slprop
     (pts_to r v)
     (R.pts_to r v)
@@ -456,6 +471,14 @@ let struct_field
     (fun _ -> ());
   return r'
 
+let struct_field0
+  t' r field td'
+=
+  let r' = struct_field' r field in
+  let res : ref td' = r' in
+  change_equal_slprop (pts_to r' _) (pts_to res _);
+  return res
+
 let unstruct_field
   #_ #tn #_ #n #fields #v r field #v' r'
 = rewrite_slprop
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 11088ed77f9..93e4b22dafc 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -183,7 +183,15 @@ val field_t_nil: Type0
 [@@noextract_to "krml"] // primitive
 val field_t_cons (fn: Type0) (ft: Type0) (fc: Type0): Type0
 
-inline_for_extraction [@@noextract_to "krml"]
+val norm_field_attr : unit
+
+noextract
+let norm_field_steps = [
+  delta_attr [`%norm_field_attr];
+  iota; zeta; primops;
+]
+
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
 noeq
 type field_description_t (t: Type0) : Type u#1 = {
   fd_def: (string -> GTot bool);
@@ -201,7 +209,7 @@ let field_description_nil : field_description_t field_t_nil = {
   fd_typedef = (fun _ -> false_elim ());
 }
 
-inline_for_extraction [@@noextract_to "krml"]
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
 let field_description_cons0
   (fn: Type0) (#ft: Type0) (#fc: Type0) (n: string) (t: typedef ft) (fd: field_description_t fc)
 : Tot (field_description_t (field_t_cons fn ft fc))
@@ -211,7 +219,7 @@ let field_description_cons0
     fd_typedef = (fun n' -> if n = n' then t else fd.fd_typedef n');
   }
 
-inline_for_extraction [@@noextract_to "krml"]
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
 let field_description_cons (#ft: Type0) (#fc: Type0) (n: string) (#fn: Type0) (# [ solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == fn))) (t: typedef ft) (fd: field_description_t fc) : Tot (field_description_t (field_t_cons fn ft fc)) =
   field_description_cons0 fn #ft #fc n t fd
 
@@ -328,21 +336,47 @@ val ghost_struct_field
     (fun _ -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to (g_struct_field r field) (struct_get_field v field))
 
 [@@noextract_to "krml"] // primitive
-val struct_field
+val struct_field0
   (#tn: Type0)
   (#tf: Type0)
+  (t': Type0)
   (#opened: _)
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
+  (td': typedef t' {
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  })
+: SteelAtomicBase (ref td') false opened Unobservable
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
     (fun _ -> True)
     (fun _ r' _ -> r' == g_struct_field r field)
 
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let struct_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#opened: _)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
+    (pts_to r v)
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == g_struct_field r field)
+= struct_field0
+    (norm norm_field_steps (fields.fd_type field))
+    r
+    field
+    (fields.fd_typedef field)
+
 val unstruct_field
   (#opened: _)
   (#tn: Type0)

From c579dfa6d26b64a0e59312a11b12efce4884afa3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 15:19:53 -0700
Subject: [PATCH 341/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 912 +++++++++++++++++++++-
 1 file changed, 897 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 196817624df..d55dd96cb78 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1033,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,18 +1071,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -966,13 +1145,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -985,19 +1165,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1605,6 +1802,49 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1698,11 +1938,31 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2428,6 +2688,484 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2798,6 +3536,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2810,7 +3614,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 53e58747e595a6e37627b21f9fbd50913250f6d4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 15:49:55 -0700
Subject: [PATCH 342/513] make uninitialized fractionable

---
 ulib/experimental/Steel.C.Types.fst  | 50 +++++++++++++---------------
 ulib/experimental/Steel.C.Types.fsti |  2 +-
 2 files changed, 25 insertions(+), 27 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 5f826a5596c..079a8f9ed74 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -40,7 +40,7 @@ type typedef (t: Type0) : Type u#1 = {
     Lemma
     (mk_fraction (one pcm) p == one pcm)
   );
-  uninitialized: (y: t { exclusive pcm y });
+  uninitialized: (y: t { exclusive pcm y /\ fractionable y });
   mk_fraction_split: (
     (v: t) ->
     (p1: P.perm) ->
@@ -125,18 +125,16 @@ let mk_fraction_join
     (fun _ -> ())
 
 module F = Steel.C.Model.Frac
-module U = Steel.C.Model.Uninit
 
-let scalar_t t = U.uninit_t (F.fractional t)
+let scalar_t t = F.fractional (option t)
 
 let scalar_fractionable
   (#t: Type)
   (s: scalar_t t)
 : GTot prop
 = match s with
-  | U.InitOrUnit (Some (_, p)) -> (p `P.lesser_equal_perm` P.full_perm) == true
-  | U.InitOrUnit None -> True
-  | _ -> False
+  | Some (_, p) -> (p `P.lesser_equal_perm` P.full_perm) == true
+  | _ -> True
 
 [@@noextract_to "krml"] // proof-only
 let scalar_mk_fraction
@@ -147,25 +145,25 @@ let scalar_mk_fraction
     (requires (scalar_fractionable x))
     (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> scalar_fractionable y))
 = match x with
-  | U.InitOrUnit (Some (v, p')) ->
-    U.InitOrUnit (Some (v, p `prod_perm` p'))
+  | (Some (v, p')) ->
+    (Some (v, p `prod_perm` p'))
   | _ -> x
 
 #restart-solver
 let scalar t = {
-  pcm = U.pcm_uninit F.pcm_frac;
+  pcm = F.pcm_frac;
   fractionable = scalar_fractionable #t;
   mk_fraction = scalar_mk_fraction #t;
   mk_fraction_full = (fun x ->
     match x with
-    | U.InitOrUnit (Some (v, p)) ->
+    | (Some (v, p)) ->
       assert_norm ((P.full_perm `prod_perm` p).v == (let open FStar.Real in 1.0R *. p.v));
       assert (P.full_perm `prod_perm` p == p)
     | _ -> ()
   );
   mk_fraction_compose = (fun w p1 p2 ->
     match w with
-    | U.InitOrUnit (Some (v, p)) ->
+    | (Some (v, p)) ->
       assert_norm (let open FStar.Real in ((p1 `prod_perm` p2) `prod_perm` p).v == (p1.v *. p2.v) *. p.v);
       assert_norm (let open FStar.Real in (p2 `prod_perm` (p1 `prod_perm` p)).v == p2.v *. (p1.v *. p.v));
       assert ((p1 `prod_perm` p2) `prod_perm` p == p2 `prod_perm` (p1 `prod_perm` p))
@@ -173,20 +171,20 @@ let scalar t = {
   );
   fractionable_one = ();
   mk_fraction_one = (fun _ -> ());
-  uninitialized = U.Uninitialized;
+  uninitialized = Some (None, P.full_perm);
   mk_fraction_split = (fun w p1 p2 ->
     match w with
-    | U.InitOrUnit (Some (v, p)) ->
+    | (Some (v, p)) ->
       assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
       assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
       assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p));
-      assert (composable (U.pcm_uninit F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2));
+      assert (composable (F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2));
 ()   //   assert (op (U.pcm_uninit F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2) == scalar_mk_fraction w (p1 `P.sum_perm` p2))
     | _ -> ()
   );
   mk_fraction_join = (fun w p1 p2 ->
     match w with
-    | U.InitOrUnit (Some (v, p)) ->
+    | (Some (v, p)) ->
       assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
       assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
       assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p))
@@ -194,7 +192,7 @@ let scalar t = {
   );
 }
 
-let mk_scalar v = U.InitOrUnit (Some (v, P.full_perm))
+let mk_scalar v = (Some (Some v, P.full_perm))
 
 let mk_scalar_fractionable v p = ()
 
@@ -205,20 +203,20 @@ let scalar_unique
 =
   rewrite_slprop
     (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1))
-    (R.pts_to r (U.InitOrUnit (Some (v1, p1))))
+    (R.pts_to r (Some (Some v1, p1)))
     (fun _ -> ());
   rewrite_slprop
     (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
-    (R.pts_to r (U.InitOrUnit (Some (v2, p2))))
+    (R.pts_to r (Some (Some v2, p2)))
     (fun _ -> ());
-  R.gather r (U.InitOrUnit (Some (v1, p1))) (U.InitOrUnit (Some (v2, p2)));
-  R.split r _ (U.InitOrUnit (Some (v1, p1))) (U.InitOrUnit (Some (v2, p2)));
+  R.gather r (Some (Some v1, p1)) (Some (Some v2, p2));
+  R.split r _ (Some (Some v1, p1)) (Some (Some v2, p2));
   rewrite_slprop
-    (R.pts_to r (U.InitOrUnit (Some (v1, p1))))
+    (R.pts_to r (Some (Some v1, p1)))
     (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1))
     (fun _ -> ());
   rewrite_slprop
-    (R.pts_to r (U.InitOrUnit (Some (v2, p2))))
+    (R.pts_to r (Some (Some v2, p2)))
     (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
     (fun _ -> ())
 
@@ -227,14 +225,14 @@ let read0
 =
   rewrite_slprop
     (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-    (R.pts_to r (U.InitOrUnit (Some (Ghost.reveal v, p))))
+    (R.pts_to r (Some (Some (Ghost.reveal v), p)))
     (fun _ -> ());
   let v' = R.ref_read r in
   rewrite_slprop
-    (R.pts_to r (U.InitOrUnit (Some (Ghost.reveal v, p))))
+    (R.pts_to r (Some (Some (Ghost.reveal v), p)))
     (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
     (fun _ -> ());
-  let U.InitOrUnit (Some (v0, _)) = v' in
+  let Some (Some v0, _) = v' in
   return v0
 
 let write
@@ -244,7 +242,7 @@ let write
     (pts_to r v)
     (R.pts_to r v)
     (fun _ -> ());
-  R.ref_upd r _ _ (R.base_fpu _ _ (U.InitOrUnit (Some (v', P.full_perm))));
+  R.ref_upd r _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
   rewrite_slprop
     (R.pts_to r _)
     (pts_to _ _)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 93e4b22dafc..8faf406026f 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -42,7 +42,7 @@ val full (#t: Type0) (td: typedef t) (v: t) : GTot prop
 
 val uninitialized (#t: Type0) (td: typedef t) : Ghost t
   (requires True)
-  (ensures (fun y -> full td y))
+  (ensures (fun y -> full td y /\ fractionable td y))
 
 val unknown (#t: Type0) (td: typedef t) : Ghost t
   (requires True)

From dc9002f014e96091e11852bf84dc08ce91fb473b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 22:02:15 -0700
Subject: [PATCH 343/513] unions

---
 ulib/experimental/Steel.C.Types.fst  | 374 ++++++++++++++++++++++++++-
 ulib/experimental/Steel.C.Types.fsti | 332 +++++++++++++++++++++++-
 2 files changed, 689 insertions(+), 17 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 079a8f9ed74..0068981e770 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -40,7 +40,11 @@ type typedef (t: Type0) : Type u#1 = {
     Lemma
     (mk_fraction (one pcm) p == one pcm)
   );
-  uninitialized: (y: t { exclusive pcm y /\ fractionable y });
+  uninitialized: (y: t {
+    exclusive pcm y /\
+    fractionable y /\
+    p_refine pcm y
+  });
   mk_fraction_split: (
     (v: t) ->
     (p1: P.perm) ->
@@ -64,6 +68,13 @@ type typedef (t: Type0) : Type u#1 = {
       op pcm (mk_fraction v p1) (mk_fraction v p2) == mk_fraction v (p1 `P.sum_perm` p2)
     ))
   );
+  mk_fraction_eq_one: (
+    (v: t) ->
+    (p: P.perm) ->
+    Lemma
+    (requires (fractionable v /\ mk_fraction v p == one pcm))
+    (ensures (v == one pcm))
+  );
 }
 
 let fractionable td x = td.fractionable x
@@ -78,6 +89,7 @@ let uninitialized td = td.uninitialized
 let unknown td = one td.pcm
 
 let mk_fraction_unknown td p = td.mk_fraction_one p
+let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
 
 module R = Steel.C.Model.Ref
 
@@ -190,6 +202,7 @@ let scalar t = {
       assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p))
     | _ -> ()
   );
+  mk_fraction_eq_one = (fun v p -> ());
 }
 
 let mk_scalar v = (Some (Some v, P.full_perm))
@@ -334,9 +347,13 @@ let struct_mk_fraction
 
 [@@noextract_to "krml"] // proof-only
 let struct_uninitialized
-  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
-: Tot (struct_t0 tn n fields)
-= FX.on_dom (field_t fields) (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f)
+  (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf)
+: Pure (struct_t0 tn n fields)
+    (requires True)
+    (ensures (fun y -> p_refine (struct_pcm tn n fields) y))
+= let y = FX.on_dom (field_t fields) (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f) in
+  assert (exists (fd:field_t fields) . fields.fd_def fd == true /\ True);
+  y
 
 let struct0
   tn n fields
@@ -375,6 +392,11 @@ let struct0
       (fields.fd_typedef f).mk_fraction_join (v f) p1 p2
     )
   );
+  mk_fraction_eq_one = (fun v p ->
+    struct_eq_intro v (one (struct_pcm tn n fields)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_eq_one (v f) p
+    )
+  );
 }
 
 let struct_get_field_unknown
@@ -389,8 +411,9 @@ let g_struct_field
   #_ #_ #_ #fields r field
 = R.ref_focus r (S.struct_field (struct_field_pcm fields) field)
 
-#push-options "--z3rlimit 16"
+#push-options "--z3rlimit 32"
 
+#restart-solver
 let ghost_struct_field
   #_ #tn #_ #n #fields #v r field
 = rewrite_slprop
@@ -429,7 +452,7 @@ let struct_field'
   (#tf: Type0)
   (#opened: _)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
@@ -543,3 +566,342 @@ let full_struct
     Classical.forall_intro (Classical.move_requires prf')
   in
   Classical.forall_intro (Classical.move_requires prf)
+
+module U = Steel.C.Model.Union
+
+let define_union0 _ _ _ = unit
+
+[@@noextract_to "krml"] // proof-only
+let union_field_t
+  (#t: Type)
+  (fd: field_description_t t)
+: Tot Type0
+= option (field_t fd)
+
+[@@noextract_to "krml"] // proof-only
+let union_field_type
+  (#t: Type)
+  (fd: field_description_t t)
+  (field: union_field_t fd)
+: Tot Type0
+= match field with
+  | None -> scalar_t unit
+  | Some f -> fd.fd_type f
+
+[@@noextract_to "krml"] // proof-only
+let union_field_typedef
+  (#t: Type)
+  (fd: field_description_t t)
+  (field: union_field_t fd)
+: Tot (typedef (union_field_type fd field))
+= match field with
+  | None -> scalar unit
+  | Some f -> fd.fd_typedef f
+
+[@@noextract_to "krml"] // proof-only
+let union_field_pcm
+  (#t: Type)
+  (fd: field_description_t t)
+  (field: union_field_t fd)
+: Tot (pcm (union_field_type fd field))
+= (union_field_typedef fd field).pcm
+
+let union_t0
+  tn n fields
+= U.union (union_field_pcm fields)
+
+let union_set_field
+  tn n fields f v
+= U.field_to_union_f (union_field_pcm fields) (Some f) v
+
+let union_get_case
+  u
+= match U.case_of_union _ u with
+  | None -> None
+  | Some s -> s
+
+let union_get_field
+  u field
+= U.union_to_field_f _ (Some field) u
+
+let union_get_field_same
+  tn n fields field v
+= ()
+
+let union_set_field_same
+  #tn #_ #n #fields  s field
+= assert (union_set_field tn n fields field (union_get_field s field) `FX.feq` s)
+
+let union_fractionable
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+: GTot prop
+= match U.case_of_union (union_field_pcm fields) s with
+  | Some f -> fractionable (union_field_typedef fields f) (s f)
+  | _ -> True
+
+let union_fractionable_fields
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (f: union_field_t fields)
+: Lemma
+  (requires (union_fractionable s))
+  (ensures (fractionable (union_field_typedef fields f) (s f)))
+= ()
+
+[@@noextract_to "krml"] // proof-only
+let union_mk_fraction
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (p: P.perm)
+: Pure (union_t0 tn n fields)
+  (requires (union_fractionable s))
+  (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> union_fractionable s'))
+= let prf
+    (f: union_field_t fields)
+  : Lemma
+    (let u = one (union_field_typedef fields f).pcm in
+      (union_field_typedef fields f).mk_fraction u p == u
+    )
+  = (union_field_typedef fields f).mk_fraction_one p
+  in
+  Classical.forall_intro prf;
+  FX.on_dom (union_field_t fields) (fun f ->
+    (union_field_typedef fields f).mk_fraction (s f) p
+  )
+
+[@@noextract_to "krml"] // proof-only
+let union_pcm
+  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+: Tot (pcm (union_t0 tn n fields))
+= U.union_pcm (union_field_pcm fields)
+
+let union_eq_intro
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s1 s2: union_t0 tn n fields)
+  (prf: (
+    (f: union_field_t fields) ->
+    Lemma
+    (s1 f == s2 f)
+  ))
+: Lemma
+  (s1 == s2)
+= Classical.forall_intro prf;
+  assert (s1 `FX.feq` s2)
+
+[@@noextract_to "krml"] // proof-only
+let union_uninitialized
+  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+: Pure (union_t0 tn n fields)
+  (requires True)
+  (ensures (fun y -> exclusive (union_pcm tn n fields) y /\ p_refine (union_pcm tn n fields) y))
+= let y : union_t0 tn n fields =
+    U.field_to_union_f (union_field_pcm fields) None (scalar unit).uninitialized
+  in
+  U.exclusive_union_intro (union_field_pcm fields) y None;
+  y
+
+#push-options "--z3rlimit 16"
+
+#restart-solver
+let union0
+  tn n fields
+= {
+  pcm = union_pcm tn n fields;
+  fractionable = union_fractionable;
+  mk_fraction = union_mk_fraction;
+  mk_fraction_full = (fun x ->
+    union_eq_intro (union_mk_fraction x P.full_perm) x (fun f ->
+      (union_field_typedef fields f).mk_fraction_full (x f)
+    )
+  );
+  mk_fraction_compose = (fun x p1 p2 ->
+    union_eq_intro (union_mk_fraction (union_mk_fraction x p1) p2) (union_mk_fraction x (p1 `prod_perm` p2)) (fun f ->
+      union_fractionable_fields x f;
+      (union_field_typedef fields f).mk_fraction_compose (x f) p1 p2
+    )
+  );
+  fractionable_one = ();
+  mk_fraction_one = (fun p ->
+    union_eq_intro (union_mk_fraction (one (union_pcm tn n fields)) p) (one (union_pcm tn n fields)) (fun f ->
+      (union_field_typedef fields f).mk_fraction_one p
+    )
+  );
+  uninitialized = union_uninitialized _ _ _;
+  mk_fraction_split = (fun v p1 p2 ->
+    U.union_comp_intro (union_field_pcm fields) (union_mk_fraction v p1) (union_mk_fraction v p2) (fun j k ->
+      (union_field_typedef fields j).mk_fraction_one p1;
+      (union_field_typedef fields k).mk_fraction_one p2;
+      assert (j == k);
+      (union_field_typedef fields j).mk_fraction_split (v j) p1 p2
+    )
+  );
+  mk_fraction_join = (fun v p1 p2 ->
+    union_eq_intro (op (union_pcm tn n fields) (union_mk_fraction v p1) (union_mk_fraction v p2)) (union_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
+      (union_field_typedef fields f).mk_fraction_join (v f) p1 p2
+    )
+  );
+  mk_fraction_eq_one = (fun v p ->
+    union_eq_intro v (one (union_pcm tn n fields)) (fun f ->
+      (union_field_typedef fields f).mk_fraction_eq_one (v f) p
+    )
+  );
+}
+
+#pop-options
+
+let union_get_case_unknown
+  tn n fields
+= ()
+
+let union_set_field_unknown
+  tn n fields field
+= ()
+
+let union_get_case_uninitialized
+  tn n fields
+= ()
+
+let mk_fraction_union_get_case
+  #tn #_ #n #fields s p
+= match U.case_of_union (union_field_pcm fields) s with
+  | None -> (union0 tn n fields).mk_fraction_one p
+  | Some f ->
+    Classical.move_requires ((union_field_typedef fields f).mk_fraction_eq_one (s f)) p
+
+let fractionable_union_get_field
+  s field
+= ()
+
+let mk_fraction_union_get_field
+  s p field
+= ()
+
+let mk_fraction_union_set_field
+  tn n fields field v p
+= 
+  assert (fractionable (union0 tn n fields) (union_set_field tn n fields field v));
+  let prf
+    (f: union_field_t fields)
+  : Lemma
+    (let u = one (union_field_typedef fields f).pcm in
+      (union_field_typedef fields f).mk_fraction u p == u
+    )
+  = (union_field_typedef fields f).mk_fraction_one p
+  in
+  Classical.forall_intro prf;
+  assert (mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p `FX.feq` union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p))
+
+let full_union
+  #_ #_ #_ #fields s field
+= Classical.move_requires (U.exclusive_union_intro (union_field_pcm fields) s) (Some field);
+  Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
+
+let g_union_field
+  #_ #_ #_ #fields r field
+= R.ref_focus r (U.union_field (union_field_pcm fields) (Some field))
+
+#push-options "--z3rlimit 16"
+
+#restart-solver
+let ghost_union_field
+  #_ #tn #_ #n #fields #v r field
+= rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
+  assert (v' `FX.feq` v);
+  R.gfocus r (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
+  rewrite_slprop
+    (R.pts_to _ _)
+    (pts_to (g_union_field r field) _)
+    (fun _ -> ())
+
+[@@noextract_to "krml"] // primitive
+let union_field'
+  (#tn: Type0)
+  (#tf: Type0)
+  (#opened: _)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+: SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
+    (pts_to r v)
+    (fun r' -> pts_to r' (union_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == g_union_field r field)
+= rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  let v' = Ghost.hide (U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field)) in
+  assert (v' `FX.feq` v);
+  let r' = R.focus r (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field) in
+  rewrite_slprop
+    (R.pts_to _ _)
+    (pts_to r' _)
+    (fun _ -> ());
+  return r'
+
+let union_field0
+  t' r field td'
+=
+  let r' = union_field' r field in
+  let res : ref td' = r' in
+  change_equal_slprop (pts_to r' _) (pts_to res _);
+  return res
+
+let ununion_field
+  #_ #tn #_ #n #fields r field #v' r'
+= rewrite_slprop
+    (pts_to r' v')
+    (R.pts_to r' v')
+    (fun _ -> ());
+  R.unfocus r' r (U.union_field (union_field_pcm fields) (Some field)) _;
+  rewrite_slprop
+    (R.pts_to r _)
+    (pts_to r _)
+    (fun _ -> ())
+
+[@@noextract_to "krml"] // primitive
+let union_switch_field'
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+: Steel (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
+    (fun _ -> full (union0 tn n fields) v)
+    (fun _ r' _ -> r' == g_union_field r field)
+= rewrite_slprop
+    (pts_to r v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
+  R.ref_upd r _ _ (R.base_fpu (union_pcm tn n fields) _ v');
+  rewrite_slprop
+    (R.pts_to _ _)
+    (pts_to r v')
+    (fun _ -> ());
+  let r' = union_field' r field in
+  return r'
+
+let union_switch_field0
+  t' r field td'
+=
+  let r' = union_switch_field' r field in
+  let res : ref td' = r' in
+  change_equal_slprop (pts_to r' _) (pts_to res _);
+  return res
+
+#pop-options
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 8faf406026f..b0cb4668c98 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -51,6 +51,11 @@ val unknown (#t: Type0) (td: typedef t) : Ghost t
 val mk_fraction_unknown (#t: Type0) (td: typedef t) (p: P.perm) : Lemma
   (ensures (mk_fraction td (unknown td) p == unknown td))
 
+val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemma
+  (requires (fractionable td v /\ mk_fraction td v p == unknown td))
+  (ensures (v == unknown td))
+
+
 // To be extracted as: *t
 [@@noextract_to "krml"] // primitive
 val ptr (#t: Type) (td: typedef t) : Tot Type0
@@ -195,16 +200,22 @@ inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
 noeq
 type field_description_t (t: Type0) : Type u#1 = {
   fd_def: (string -> GTot bool);
+  fd_empty: (fd_empty: bool { fd_empty == true <==> (forall s . fd_def s == false) });
   fd_type: (string -> Type0);
   fd_typedef: ((s: string) -> Pure (typedef (fd_type s)) (requires (fd_def s)) (ensures (fun _ -> True)));
 }
 
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
+let nonempty_field_description_t (t: Type0) =
+  (fd: field_description_t t { fd.fd_empty == false })
+
 [@@noextract_to "krml"] // proof-only
 let field_t (#t: Type0) (fd: field_description_t t) = (s: string { fd.fd_def s })
 
 inline_for_extraction [@@noextract_to "krml"]
 let field_description_nil : field_description_t field_t_nil = {
   fd_def = (fun _ -> false);
+  fd_empty = true;
   fd_type = (fun _ -> unit);
   fd_typedef = (fun _ -> false_elim ());
 }
@@ -215,6 +226,7 @@ let field_description_cons0
 : Tot (field_description_t (field_t_cons fn ft fc))
 = {
     fd_def = (fun n' -> n = n' || fd.fd_def n');
+    fd_empty = false;
     fd_type = (fun n' -> if n = n' then ft else fd.fd_type n');
     fd_typedef = (fun n' -> if n = n' then t else fd.fd_typedef n');
   }
@@ -287,10 +299,12 @@ val struct_get_field_other
   [SMTPat (struct_get_field (struct_set_field field v s) field')]
 
 [@@noextract_to "krml"] // proof-only
-val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
+val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
 
 [@@noextract_to "krml"] // proof-only
-let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
+let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Pure (typedef (struct_t0 tn n fields))
+  (requires (fields.fd_empty == false))
+  (ensures (fun _ -> True))
 = struct0 tn #tf n fields
 
 val struct_get_field_unknown
@@ -317,7 +331,7 @@ val g_struct_field
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
 : GTot (ref (fields.fd_typedef field))
@@ -327,7 +341,7 @@ val ghost_struct_field
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
@@ -342,7 +356,7 @@ val struct_field0
   (t': Type0)
   (#opened: _)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
@@ -362,7 +376,7 @@ let struct_field
   (#tf: Type0)
   (#opened: _)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
@@ -382,7 +396,7 @@ val unstruct_field
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
@@ -401,7 +415,7 @@ val fractionable_struct
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
 : Lemma
   (fractionable (struct0 tn n fields) s <==> (forall field . fractionable (fields.fd_typedef field) (struct_get_field s field)))
@@ -411,7 +425,7 @@ val mk_fraction_struct
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
   (p: P.perm)
   (field: field_t fields)
@@ -425,7 +439,7 @@ val mk_fraction_struct_recip
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
   (p: P.perm)
 : Ghost (struct_t0 tn n fields)
@@ -442,12 +456,308 @@ val full_struct
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
 : Lemma
   (full (struct0 tn n fields) s <==> (forall field . full (fields.fd_typedef field) (struct_get_field s field)))
   [SMTPat (full (struct0 tn n fields) s)]
 
+[@@noextract_to "krml"] // primitive
+val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+= define_union0 tn #tf n fields
+
+// To be extracted as: union t
+[@@noextract_to "krml"] // primitive
+val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+= union_t0 tn #tf n fields
+
+val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
+
+val union_get_case
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (u: union_t0 tn n fields)
+: GTot (option (field_t fields))
+
+val union_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (u: union_t0 tn n fields)
+  (field: field_t fields)
+: Ghost (fields.fd_type field)
+    (requires (union_get_case u == Some field))
+    (ensures (fun _ -> True))
+
+val union_get_field_same
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+: Lemma
+  (requires (~ (v == unknown (fields.fd_typedef field))))
+  (ensures (
+    let u = union_set_field tn n fields field v in
+    union_get_case u == Some field /\
+    union_get_field u field == v
+  ))
+  [SMTPatOr [
+    [SMTPat (union_get_case (union_set_field tn n fields field v))];
+    [SMTPat (union_get_field (union_set_field tn n fields field v) field)];
+  ]]
+
+val union_set_field_same
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (field: field_t fields)
+: Lemma
+  (requires (union_get_case s == Some field))
+  (ensures (
+    union_set_field tn n fields field (union_get_field s field) == s
+  ))
+  [SMTPat (union_set_field tn n fields (union_get_field s field))]
+
+[@@noextract_to "krml"] // proof-only
+val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
+
+[@@noextract_to "krml"] // proof-only
+let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
+= union0 tn #tf n fields
+
+val union_get_case_unknown
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+: Lemma
+  (union_get_case (unknown (union0 tn n fields)) == None)
+  [SMTPat (unknown (union0 tn n fields))]
+
+val union_set_field_unknown
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+: Lemma
+  (union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
+  [SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
+
+val union_get_case_uninitialized
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+: Lemma
+  (union_get_case (uninitialized (union0 tn n fields)) == None)
+  [SMTPat (uninitialized (union0 tn n fields))]
+
+val mk_fraction_union_get_case
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (p: P.perm)
+: Lemma
+  (requires (fractionable (union0 tn n fields) s))
+  (ensures (
+    union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
+  ))
+  [SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
+
+val fractionable_union_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (field: field_t fields)
+: Lemma
+  (requires (union_get_case s == Some field))
+  (ensures (
+    fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
+  ))
+  [SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
+
+val mk_fraction_union_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (p: P.perm)
+  (field: field_t fields)
+: Lemma
+  (requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
+  (ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
+  [SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
+
+val mk_fraction_union_set_field
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+  (p: P.perm)
+: Lemma
+  (requires (fractionable (fields.fd_typedef field) v))
+  (ensures (
+    fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
+    mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
+  ))
+
+val full_union
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (field: field_t fields)
+: Lemma
+  (requires (union_get_case s == Some field))
+  (ensures (
+    full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
+  ))
+  [SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
+
+val g_union_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+: GTot (ref (fields.fd_typedef field))
+
+val ghost_union_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+: SteelGhostT unit opened
+    (pts_to r v)
+    (fun _ -> pts_to (g_union_field r field) (union_get_field v field))
+
+[@@noextract_to "krml"] // primitive
+val union_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#opened: _)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+  (td': typedef t' {
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  })
+: SteelAtomicBase (ref td') false opened Unobservable
+    (pts_to r v)
+    (fun r' -> pts_to r' (union_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == g_union_field r field)
+
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let union_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#opened: _)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+: SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
+    (pts_to r v)
+    (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> r' == g_union_field r field)
+= union_field0
+    (norm norm_field_steps (fields.fd_type field))
+    r
+    field
+    (fields.fd_typedef field)
+
+val ununion_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    (pts_to r' v')
+    (fun _ -> pts_to r (union_set_field tn n fields field v'))
+    (fun _ ->
+      r' == g_union_field r field
+    )
+    (fun _ _ _ -> True)
+
+// NOTE: we DO NOT support preservation of struct prefixes
+
+[@@noextract_to "krml"] // primitive
+val union_switch_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (td': typedef t' {
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  })
+: Steel (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+    (pts_to r v)
+    (fun r' -> pts_to r' (uninitialized (fields.fd_typedef field)))
+    (fun _ -> full (union0 tn n fields) v)
+    (fun _ r' _ -> r' == g_union_field r field)
+
+inline_for_extraction [@@noextract_to "krml"]
+let union_switch_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+: Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+    (pts_to r v)
+    (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
+    (fun _ -> full (union0 tn n fields) v)
+    (fun _ r' _ -> r' == g_union_field r field)
+= union_switch_field0
+    (norm norm_field_steps (fields.fd_type field))
+    r
+    field
+    (fields.fd_typedef field)
+
 (*
 // To be extracted as: t[tn]
 val base_array_t (t: Type0) (tn: Type0 (* using Typenat *)) (n: size_t) : Type0

From 5f4762d0b1b8e2a9ef5d1695b302539df35fc6d7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 28 Oct 2022 22:07:42 -0700
Subject: [PATCH 344/513] weaken precond for scalar write

---
 ulib/experimental/Steel.C.Types.fsti | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index b0cb4668c98..55cc3a94130 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -179,7 +179,7 @@ let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : Steel
 val write (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : Steel unit
   (pts_to r v)
   (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
-  (fun _ -> Ghost.reveal v == uninitialized (scalar t) \/ (exists (v0: t) . Ghost.reveal v == mk_scalar v0))
+  (fun _ -> full (scalar t) v)
   (fun _ _ _ -> True)
 
 // To be extracted as: struct t { fields ... }

From a56d7b274fd797f36206a01aeff8e21db3d2cbb9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 31 Oct 2022 11:21:02 -0700
Subject: [PATCH 345/513] lower universe for typedef

---
 ulib/experimental/Steel.C.Types.fst  | 22 +++++++++++-----------
 ulib/experimental/Steel.C.Types.fsti |  2 +-
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 0068981e770..6f0525f9f77 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -10,9 +10,9 @@ let prod_perm
   P.MkPerm w
 
 noeq
-type typedef (t: Type0) : Type u#1 = {
+type typedef (t: Type0) : Type0 = {
   pcm: pcm t;
-  fractionable: (t -> Tot prop);
+  fractionable: (t -> GTot bool);
   mk_fraction: (
     (x: t) ->
     (p: P.perm) ->
@@ -77,7 +77,7 @@ type typedef (t: Type0) : Type u#1 = {
   );
 }
 
-let fractionable td x = td.fractionable x
+let fractionable td x = td.fractionable x == true
 let mk_fraction td x p = td.mk_fraction x p
 let mk_fraction_full td x = td.mk_fraction_full x
 let mk_fraction_compose td x p1 p2 = td.mk_fraction_compose x p1 p2
@@ -143,10 +143,10 @@ let scalar_t t = F.fractional (option t)
 let scalar_fractionable
   (#t: Type)
   (s: scalar_t t)
-: GTot prop
+: GTot bool
 = match s with
-  | Some (_, p) -> (p `P.lesser_equal_perm` P.full_perm) == true
-  | _ -> True
+  | Some (_, p) -> p `P.lesser_equal_perm` P.full_perm
+  | _ -> true
 
 [@@noextract_to "krml"] // proof-only
 let scalar_mk_fraction
@@ -332,8 +332,8 @@ let struct_get_field_other
 let struct_fractionable
   (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
   (s: struct_t0 tn n fields)
-: GTot prop
-= forall (f: field_t fields) . (fields.fd_typedef f).fractionable (s f)
+: GTot bool
+= FStar.StrongExcludedMiddle.strong_excluded_middle (forall (f: field_t fields) . (fields.fd_typedef f).fractionable (s f))
 
 [@@noextract_to "krml"] // proof-only
 let struct_mk_fraction
@@ -635,10 +635,10 @@ let union_set_field_same
 let union_fractionable
   (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
   (s: union_t0 tn n fields)
-: GTot prop
+: GTot bool
 = match U.case_of_union (union_field_pcm fields) s with
-  | Some f -> fractionable (union_field_typedef fields f) (s f)
-  | _ -> True
+  | Some f -> (union_field_typedef fields f).fractionable (s f)
+  | _ -> true
 
 let union_fractionable_fields
   (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 55cc3a94130..bded71a66d1 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -18,7 +18,7 @@ val prod_perm (p1 p2: P.perm) : Pure P.perm
   ))
 
 [@@noextract_to "krml"] // proof-only
-val typedef (t: Type0) : Type u#1
+val typedef (t: Type0) : Type0
 
 inline_for_extraction [@@noextract_to "krml"]
 let typeof (#t: Type0) (td: typedef t) : Tot Type0 = t

From cd3f716abce949aaddbbd704356a108d73686b1a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 31 Oct 2022 14:05:43 -0700
Subject: [PATCH 346/513] post-merge: rlimit

---
 ulib/experimental/Steel.C.Model.Array.fst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index 66cd0f255c5..942c81840f3 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -553,7 +553,7 @@ let split_r
     (ensures (fun _ -> True))
 = sub a i (a.len `size_sub` i)
 
-#push-options "--z3rlimit 64"
+#push-options "--z3rlimit 128"
 
 #restart-solver
 let g_focus_sub
@@ -621,7 +621,7 @@ let g_focus_sub
 
 #pop-options
 
-#push-options "--z3rlimit 16"
+#push-options "--z3rlimit 32"
 
 #restart-solver
 let g_split

From a8163f018c675f1e58acd53a57f271365285a2c9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 31 Oct 2022 17:02:37 -0700
Subject: [PATCH 347/513] type dictionary

---
 ulib/experimental/Steel.TypeDictionary.fst | 174 +++++++++++++++++++++
 1 file changed, 174 insertions(+)
 create mode 100644 ulib/experimental/Steel.TypeDictionary.fst

diff --git a/ulib/experimental/Steel.TypeDictionary.fst b/ulib/experimental/Steel.TypeDictionary.fst
new file mode 100644
index 00000000000..c47519644db
--- /dev/null
+++ b/ulib/experimental/Steel.TypeDictionary.fst
@@ -0,0 +1,174 @@
+module Steel.TypeDictionary
+
+module FP = FStar.Preorder
+module R = Steel.GhostMonotonicHigherReference
+
+let n_up_to (size: nat) : Type0 = (n: nat { n < size })
+
+[@@erasable]
+noeq
+type dictionary = {
+  size: nat;
+  type_of_nat: (n_up_to size -> Type0);
+  type_of_nat_inj: squash (forall n1 n2 . type_of_nat n1 == type_of_nat n2 ==> n1 == n2);
+}
+
+let nat_of_type
+  (d: dictionary)
+  (t: Type0)
+: Ghost nat
+  (requires (exists n . d.type_of_nat n == t))
+  (ensures (fun _ -> True))
+= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun (n: n_up_to d.size) -> d.type_of_nat n == t)
+
+let nat_of_type_of_nat
+  (d: dictionary)
+  (n: n_up_to d.size)
+: Lemma
+  (nat_of_type d (d.type_of_nat n) == n)
+= ()
+
+let type_of_nat_of_type
+  (d: dictionary)
+  (t: Type0)
+: Lemma
+  (requires (exists n . d.type_of_nat n == t))
+  (ensures (d.type_of_nat (nat_of_type d t) == t))
+= ()
+
+let preorder : FP.preorder dictionary =
+  (fun d1 d2 ->
+    d1.size <= d2.size /\
+    (forall (n: n_up_to d1.size) . d1.type_of_nat n == d2.type_of_nat n)
+  )
+
+open Steel.Effect.Common
+open Steel.Effect
+open Steel.Effect.Atomic
+open Steel.FractionalPermission
+
+module S = Steel.Effect.Common
+
+let dict_and_inv_f (opened: _) : SteelGhostT
+  (Ghost.erased (dict: R.ref dictionary preorder & S.inv (h_exists (R.pts_to dict full_perm))))
+  opened emp (fun _ -> emp)
+=
+  let d = ({ size = 0; type_of_nat = (fun _ -> unit); type_of_nat_inj = () }) in
+  let dict = R.alloc preorder d in
+  intro_exists _ (R.pts_to dict full_perm);
+  let i = new_invariant (h_exists (R.pts_to dict full_perm)) in
+  Ghost.hide (| dict, i |)
+
+// let dict_and_inv = dict_and_inv_f _
+assume val dict_and_inv : Ghost.erased (dict: R.ref dictionary preorder & S.inv (h_exists (R.pts_to dict full_perm)))
+
+let dict : R.ref dictionary preorder = dfst dict_and_inv
+let inv : S.inv (h_exists (R.pts_to dict full_perm)) = dsnd dict_and_inv
+
+let token_has_type_in (n: nat) (t: Type0) (d: dictionary) : GTot prop =
+  n < d.size /\
+  d.type_of_nat n == t
+
+let token_has_type (n: nat) (t: Type0) : GTot prop =
+  R.witnessed dict (token_has_type_in n t)
+
+let token_has_some_type (n: nat) : GTot prop =
+  exists (t: Type0) . token_has_type n t
+
+let token : Type0 = (n: Ghost.erased nat { token_has_some_type n })
+
+let type_of_token
+  (n: token)
+: Tot Type0
+= FStar.IndefiniteDescription.indefinite_description_ghost Type0 (fun t -> token_has_type n t)
+
+let token_has_type_inj_type_with (#opened: _) (n: nat) (t1 t2: Type0) : SteelGhostT unit opened
+  (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n t1 /\ token_has_type n t2))
+  (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (t1 == t2))
+= elim_pure _;
+  let ggd : Ghost.erased (Ghost.erased dictionary) = witness_exists () in
+  let d : dictionary = Ghost.reveal (Ghost.reveal ggd) in
+  rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
+  R.recall (token_has_type_in n t1) dict d;
+  R.recall (token_has_type_in n t2) dict d;
+  intro_exists (Ghost.hide d) (R.pts_to dict full_perm);
+  intro_pure _
+
+let token_has_type_inj_token_with (#opened: _) (n1 n2: nat) (t: Type0) : SteelGhostT unit opened
+  (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n1 t /\ token_has_type n2 t))
+  (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (n1 == n2))
+= elim_pure _;
+  let ggd : Ghost.erased (Ghost.erased dictionary) = witness_exists () in
+  let d : dictionary = Ghost.reveal (Ghost.reveal ggd) in
+  rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
+  R.recall (token_has_type_in n1 t) dict d;
+  R.recall (token_has_type_in n2 t) dict d;
+  intro_exists (Ghost.hide d) (R.pts_to dict full_perm);
+  intro_pure _
+
+#push-options "--split_queries"
+
+#restart-solver
+let get_token_from_true
+  (#opened: _)
+  (d: dictionary)
+  (t: Type0)
+: SteelGhost token opened
+    (R.pts_to dict full_perm d)
+    (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
+    (fun _ -> exists (n: n_up_to d.size) . d.type_of_nat n == t)
+    (fun _ _ _ -> True)
+= let n = FStar.IndefiniteDescription.indefinite_description_ghost (n_up_to d.size) (fun n -> d.type_of_nat n == t) in
+  R.witness dict (token_has_type_in n t) d ();
+  intro_exists (Ghost.hide d) (R.pts_to dict full_perm);
+  intro_pure _;
+  token_has_type_inj_type_with n t (type_of_token n);
+  elim_pure _;
+  let n' : token = n in
+  intro_pure (type_of_token n' == t);
+  n'
+
+let get_token_from_false
+  (#opened: _)
+  (d: dictionary)
+  (t: Type0)
+: SteelGhost token opened
+    (R.pts_to dict full_perm d)
+    (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
+    (fun _ -> ~ (exists (n: n_up_to d.size) . d.type_of_nat n == t))
+    (fun _ _ _ -> True)
+= let n = d.size in
+  let d' = {size = n+1; type_of_nat = (fun n' -> if n = n'  then t else d.type_of_nat n'); type_of_nat_inj = () } in
+  R.write dict d';
+  let n' : n_up_to d'.size = n in
+  assert (d'.type_of_nat n' == t);
+  get_token_from_true d' t
+
+#pop-options
+
+let get_token_from
+  (#opened: _)
+  (t: Type0)
+  ()
+: SteelGhostT token opened
+    (h_exists (R.pts_to dict full_perm) `star` emp)
+    (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
+= let ggd : Ghost.erased (Ghost.erased dictionary) = witness_exists () in
+  let d : dictionary = Ghost.reveal (Ghost.reveal ggd) in
+  rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
+  if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (n: n_up_to d.size) . d.type_of_nat n == t)
+  then
+    get_token_from_true d t
+  else
+    get_token_from_false d t
+
+let get_token
+  (#opened: _)
+  (t: Type0)
+: SteelGhost token opened emp (fun _ -> emp) (fun _ -> Ghost.reveal (mem_inv opened inv) == false) (fun _ n _ -> type_of_token n == t)
+= let n = with_invariant_g
+    inv
+    (get_token_from t)
+  in
+  elim_pure (type_of_token n == t);
+  n

From 241bdd74010f6df09273bffddf5c8bd6730f51e8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 31 Oct 2022 18:38:43 -0700
Subject: [PATCH 348/513] remove useless Ghost.erased

---
 ulib/experimental/Steel.TypeDictionary.fst | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/ulib/experimental/Steel.TypeDictionary.fst b/ulib/experimental/Steel.TypeDictionary.fst
index c47519644db..43e9726ec99 100644
--- a/ulib/experimental/Steel.TypeDictionary.fst
+++ b/ulib/experimental/Steel.TypeDictionary.fst
@@ -86,24 +86,24 @@ let token_has_type_inj_type_with (#opened: _) (n: nat) (t1 t2: Type0) : SteelGho
   (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n t1 /\ token_has_type n t2))
   (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (t1 == t2))
 = elim_pure _;
-  let ggd : Ghost.erased (Ghost.erased dictionary) = witness_exists () in
-  let d : dictionary = Ghost.reveal (Ghost.reveal ggd) in
+  let gd : Ghost.erased dictionary = witness_exists () in
+  let d : dictionary = Ghost.reveal gd in
   rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
   R.recall (token_has_type_in n t1) dict d;
   R.recall (token_has_type_in n t2) dict d;
-  intro_exists (Ghost.hide d) (R.pts_to dict full_perm);
+  intro_exists d (R.pts_to dict full_perm);
   intro_pure _
 
 let token_has_type_inj_token_with (#opened: _) (n1 n2: nat) (t: Type0) : SteelGhostT unit opened
   (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n1 t /\ token_has_type n2 t))
   (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (n1 == n2))
 = elim_pure _;
-  let ggd : Ghost.erased (Ghost.erased dictionary) = witness_exists () in
-  let d : dictionary = Ghost.reveal (Ghost.reveal ggd) in
+  let gd : Ghost.erased dictionary = witness_exists () in
+  let d : dictionary = Ghost.reveal gd in
   rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
   R.recall (token_has_type_in n1 t) dict d;
   R.recall (token_has_type_in n2 t) dict d;
-  intro_exists (Ghost.hide d) (R.pts_to dict full_perm);
+  intro_exists d (R.pts_to dict full_perm);
   intro_pure _
 
 #push-options "--split_queries"
@@ -120,7 +120,7 @@ let get_token_from_true
     (fun _ _ _ -> True)
 = let n = FStar.IndefiniteDescription.indefinite_description_ghost (n_up_to d.size) (fun n -> d.type_of_nat n == t) in
   R.witness dict (token_has_type_in n t) d ();
-  intro_exists (Ghost.hide d) (R.pts_to dict full_perm);
+  intro_exists d (R.pts_to dict full_perm);
   intro_pure _;
   token_has_type_inj_type_with n t (type_of_token n);
   elim_pure _;
@@ -153,8 +153,8 @@ let get_token_from
 : SteelGhostT token opened
     (h_exists (R.pts_to dict full_perm) `star` emp)
     (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
-= let ggd : Ghost.erased (Ghost.erased dictionary) = witness_exists () in
-  let d : dictionary = Ghost.reveal (Ghost.reveal ggd) in
+= let gd : Ghost.erased dictionary = witness_exists () in
+  let d : dictionary = Ghost.reveal gd in
   rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
   if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (n: n_up_to d.size) . d.type_of_nat n == t)
   then

From 30c45aed44ada723e276251ab00028c1e4d19352 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 31 Oct 2022 19:17:39 -0700
Subject: [PATCH 349/513] TypeDictionary fsti

---
 ulib/experimental/Steel.TypeDictionary.fst  | 78 +++++++++++++++++++--
 ulib/experimental/Steel.TypeDictionary.fsti | 35 +++++++++
 2 files changed, 106 insertions(+), 7 deletions(-)
 create mode 100644 ulib/experimental/Steel.TypeDictionary.fsti

diff --git a/ulib/experimental/Steel.TypeDictionary.fst b/ulib/experimental/Steel.TypeDictionary.fst
index 43e9726ec99..fe1417bf25f 100644
--- a/ulib/experimental/Steel.TypeDictionary.fst
+++ b/ulib/experimental/Steel.TypeDictionary.fst
@@ -36,6 +36,7 @@ let type_of_nat_of_type
   (ensures (d.type_of_nat (nat_of_type d t) == t))
 = ()
 
+[@@noextract_to "krml"]
 let preorder : FP.preorder dictionary =
   (fun d1 d2 ->
     d1.size <= d2.size /\
@@ -49,8 +50,14 @@ open Steel.FractionalPermission
 
 module S = Steel.Effect.Common
 
+[@@__steel_reduce__]
+let dict_inv_vprop
+  (dict: R.ref dictionary preorder)
+: Tot vprop
+= h_exists (R.pts_to dict full_perm)
+
 let dict_and_inv_f (opened: _) : SteelGhostT
-  (Ghost.erased (dict: R.ref dictionary preorder & S.inv (h_exists (R.pts_to dict full_perm))))
+  (Ghost.erased (dict: R.ref dictionary preorder & S.inv (dict_inv_vprop dict)))
   opened emp (fun _ -> emp)
 =
   let d = ({ size = 0; type_of_nat = (fun _ -> unit); type_of_nat_inj = () }) in
@@ -60,10 +67,24 @@ let dict_and_inv_f (opened: _) : SteelGhostT
   Ghost.hide (| dict, i |)
 
 // let dict_and_inv = dict_and_inv_f _
-assume val dict_and_inv : Ghost.erased (dict: R.ref dictionary preorder & S.inv (h_exists (R.pts_to dict full_perm)))
+assume val dict_and_inv : Ghost.erased (dict: R.ref dictionary preorder & S.inv (dict_inv_vprop dict))
 
 let dict : R.ref dictionary preorder = dfst dict_and_inv
-let inv : S.inv (h_exists (R.pts_to dict full_perm)) = dsnd dict_and_inv
+let inv : Ghost.erased Steel.Memory.iname = dsnd dict_and_inv
+
+let inv_holds : squash (inv >--> dict_inv_vprop dict) = ()
+
+let p_eq_q_p_FIXME_why_do_I_need_to_do_that
+  (p q: prop)
+  (sq: squash p)
+: Lemma
+  (requires (p == q))
+  (ensures q)
+= ()
+
+let inv_holds_unfold_WHY_WHY_WHY () : Lemma (inv >--> h_exists (R.pts_to dict full_perm)) =
+  assert_norm ((inv >--> dict_inv_vprop dict) == (inv >--> h_exists (R.pts_to dict full_perm)));
+  p_eq_q_p_FIXME_why_do_I_need_to_do_that (inv >--> dict_inv_vprop dict) (inv >--> h_exists (R.pts_to dict full_perm)) inv_holds
 
 let token_has_type_in (n: nat) (t: Type0) (d: dictionary) : GTot prop =
   n < d.size /\
@@ -82,7 +103,7 @@ let type_of_token
 : Tot Type0
 = FStar.IndefiniteDescription.indefinite_description_ghost Type0 (fun t -> token_has_type n t)
 
-let token_has_type_inj_type_with (#opened: _) (n: nat) (t1 t2: Type0) : SteelGhostT unit opened
+let token_has_type_inj_type_with (#opened: _) (n: nat) (t1 t2: Type0) () : SteelGhostT unit opened
   (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n t1 /\ token_has_type n t2))
   (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (t1 == t2))
 = elim_pure _;
@@ -94,7 +115,23 @@ let token_has_type_inj_type_with (#opened: _) (n: nat) (t1 t2: Type0) : SteelGho
   intro_exists d (R.pts_to dict full_perm);
   intro_pure _
 
-let token_has_type_inj_token_with (#opened: _) (n1 n2: nat) (t: Type0) : SteelGhostT unit opened
+let token_has_type_inj_type (#opened: _) (n: nat) (t1 t2: Type0) : SteelGhost unit opened
+  emp
+  (fun _ -> emp)
+  (fun _ ->
+    token_has_type n t1 /\
+    token_has_type n t2 /\
+    Ghost.reveal (mem_inv opened inv) == false
+  )
+  (fun _ _ _ -> t1 == t2)
+= inv_holds_unfold_WHY_WHY_WHY ();
+  intro_pure _;
+  with_invariant_g
+    inv
+    (token_has_type_inj_type_with n t1 t2);
+  elim_pure _
+
+let token_has_type_inj_token_with (#opened: _) (n1 n2: nat) (t: Type0) () : SteelGhostT unit opened
   (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n1 t /\ token_has_type n2 t))
   (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (n1 == n2))
 = elim_pure _;
@@ -106,6 +143,32 @@ let token_has_type_inj_token_with (#opened: _) (n1 n2: nat) (t: Type0) : SteelGh
   intro_exists d (R.pts_to dict full_perm);
   intro_pure _
 
+let token_has_type_inj_token (#opened: _) (n1 n2: nat) (t: Type0) : SteelGhost unit opened
+  emp
+  (fun _ -> emp)
+  (fun _ ->
+    token_has_type n1 t /\
+    token_has_type n2 t /\
+    Ghost.reveal (mem_inv opened inv) == false
+  )
+  (fun _ _ _ -> n1 == n2)
+= inv_holds_unfold_WHY_WHY_WHY ();
+  intro_pure _;
+  with_invariant_g
+    inv
+    (token_has_type_inj_token_with n1 n2 t);
+  elim_pure _
+
+let type_of_token_inj (#opened: _) (n1 n2: token) : SteelGhost unit opened
+  emp
+  (fun _ -> emp)
+  (fun _ ->
+    type_of_token n1 == type_of_token n2 /\
+    Ghost.reveal (mem_inv opened inv) == false
+  )
+  (fun _ _ _ -> n1 == n2)
+= token_has_type_inj_token n1 n2 (type_of_token n1)
+
 #push-options "--split_queries"
 
 #restart-solver
@@ -122,7 +185,7 @@ let get_token_from_true
   R.witness dict (token_has_type_in n t) d ();
   intro_exists d (R.pts_to dict full_perm);
   intro_pure _;
-  token_has_type_inj_type_with n t (type_of_token n);
+  token_has_type_inj_type_with n t (type_of_token n) ();
   elim_pure _;
   let n' : token = n in
   intro_pure (type_of_token n' == t);
@@ -166,7 +229,8 @@ let get_token
   (#opened: _)
   (t: Type0)
 : SteelGhost token opened emp (fun _ -> emp) (fun _ -> Ghost.reveal (mem_inv opened inv) == false) (fun _ n _ -> type_of_token n == t)
-= let n = with_invariant_g
+= inv_holds_unfold_WHY_WHY_WHY ();
+  let n = with_invariant_g
     inv
     (get_token_from t)
   in
diff --git a/ulib/experimental/Steel.TypeDictionary.fsti b/ulib/experimental/Steel.TypeDictionary.fsti
new file mode 100644
index 00000000000..495dcea4e6a
--- /dev/null
+++ b/ulib/experimental/Steel.TypeDictionary.fsti
@@ -0,0 +1,35 @@
+module Steel.TypeDictionary
+
+open Steel.Effect.Common
+open Steel.Effect
+open Steel.Effect.Atomic
+
+val inv : Ghost.erased Steel.Memory.iname
+
+[@@erasable; must_erase_for_extraction]
+val token : Type0
+
+[@@noextract_to "krml"]
+val type_of_token
+  (n: token)
+: Tot Type0
+
+val type_of_token_inj
+  (#opened: _) (n1 n2: token)
+: SteelGhost unit opened
+  emp
+  (fun _ -> emp)
+  (fun _ ->
+    type_of_token n1 == type_of_token n2 /\
+    Ghost.reveal (mem_inv opened inv) == false
+  )
+  (fun _ _ _ -> n1 == n2)
+
+val get_token
+  (#opened: _)
+  (t: Type0)
+: SteelGhost token opened
+  emp
+  (fun _ -> emp)
+  (fun _ -> Ghost.reveal (mem_inv opened inv) == false)
+  (fun _ n _ -> type_of_token n == t)

From 93a6890c6db4fb7e1bb7237a579d7cb686e27564 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 09:57:18 -0700
Subject: [PATCH 350/513] top-level definition for the dictionary

---
 ulib/experimental/Steel.TypeDictionary.fst | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/ulib/experimental/Steel.TypeDictionary.fst b/ulib/experimental/Steel.TypeDictionary.fst
index fe1417bf25f..490a1ae2efa 100644
--- a/ulib/experimental/Steel.TypeDictionary.fst
+++ b/ulib/experimental/Steel.TypeDictionary.fst
@@ -56,9 +56,10 @@ let dict_inv_vprop
 : Tot vprop
 = h_exists (R.pts_to dict full_perm)
 
-let dict_and_inv_f (opened: _) : SteelGhostT
-  (Ghost.erased (dict: R.ref dictionary preorder & S.inv (dict_inv_vprop dict)))
-  opened emp (fun _ -> emp)
+[@@noextract_to "krml"]
+let dict_and_inv_t = Ghost.erased (dict: R.ref dictionary preorder & S.inv (dict_inv_vprop dict))
+
+let dict_and_inv_f (opened: _) : SteelGhostT dict_and_inv_t opened emp (fun _ -> emp)
 =
   let d = ({ size = 0; type_of_nat = (fun _ -> unit); type_of_nat_inj = () }) in
   let dict = R.alloc preorder d in
@@ -66,8 +67,10 @@ let dict_and_inv_f (opened: _) : SteelGhostT
   let i = new_invariant (h_exists (R.pts_to dict full_perm)) in
   Ghost.hide (| dict, i |)
 
-// let dict_and_inv = dict_and_inv_f _
-assume val dict_and_inv : Ghost.erased (dict: R.ref dictionary preorder & S.inv (dict_inv_vprop dict))
+#push-options "--warn_error -272" // disable top-level effect warning
+[@@noextract_to "krml"]
+let dict_and_inv = dict_and_inv_f _ <: SteelTop dict_and_inv_t false (fun _ -> emp) (fun _ _ _ -> True)
+#pop-options
 
 let dict : R.ref dictionary preorder = dfst dict_and_inv
 let inv : Ghost.erased Steel.Memory.iname = dsnd dict_and_inv

From b0366695d15138d74f53989d6a4f842fbde4f469 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 13:15:54 -0700
Subject: [PATCH 351/513] model void*

---
 ulib/experimental/Steel.C.Types.fst  | 216 ++++++++++++++++++---------
 ulib/experimental/Steel.C.Types.fsti | 138 ++++++++++++++---
 2 files changed, 261 insertions(+), 93 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 6f0525f9f77..e0e2aebd0a8 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -92,16 +92,27 @@ let mk_fraction_unknown td p = td.mk_fraction_one p
 let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
 
 module R = Steel.C.Model.Ref
+module TD = Steel.TypeDictionary
 
-let ptr td = R.ptr td.pcm
-let null _ = R.null _
+noeq
+type ref0 : Type0 = {
+  dest: TD.token;
+  typedef: typedef (TD.type_of_token dest);
+  ref: R.ref typedef.pcm;
+}
+
+let void_ptr = option ref0
+let void_null = None
+let type_of_ptr p = TD.type_of_token (Some?.v p).dest
+let typedef_of_ptr p = (Some?.v p).typedef
 
-let _pts_to r v = hp_of (R.pts_to r v)
+let _pts_to r v = hp_of (R.pts_to (Some?.v r).ref v)
 
 #restart-solver
 let mk_fraction_split_gen
-  #_ #_ #td r v p p1 p2
+  #_ #_ #td r0 v p p1 p2
 =
+  let r = (Some?.v r0).ref in
   td.mk_fraction_split v p1 p2;
   td.mk_fraction_join v p1 p2;
   rewrite_slprop
@@ -111,22 +122,22 @@ let mk_fraction_split_gen
   R.split r _ (td.mk_fraction v p1) (td.mk_fraction v p2);
   rewrite_slprop
     (R.pts_to r (td.mk_fraction v p1))
-    (pts_to r (mk_fraction td v p1))
+    (pts_to r0 (mk_fraction td v p1))
     (fun _ -> ());
   rewrite_slprop
     (R.pts_to r (td.mk_fraction v p2))
-    (pts_to r (mk_fraction td v p2))
+    (pts_to r0 (mk_fraction td v p2))
     (fun _ -> ())
 
 let mk_fraction_join
-  #_ #_ #td r v p1 p2
-=
+  #_ #_ #td r0 v p1 p2
+= let r = (Some?.v r0).ref in
   rewrite_slprop
-    (pts_to r (mk_fraction td v p1))
+    (pts_to r0 (mk_fraction td v p1))
     (R.pts_to r (td.mk_fraction v p1))
     (fun _ -> ());
   rewrite_slprop
-    (pts_to r (mk_fraction td v p2))
+    (pts_to r0 (mk_fraction td v p2))
     (R.pts_to r (td.mk_fraction v p2))
     (fun _ -> ());
   R.gather r (td.mk_fraction v p1) (td.mk_fraction v p2);
@@ -212,47 +223,50 @@ let mk_scalar_fractionable v p = ()
 let mk_scalar_inj v1 v2 p1 p2 = ()
 
 let scalar_unique
-  v1 v2 p1 p2 r
+  #_ #t v1 v2 p1 p2 r0
 =
+  let r : R.ref (scalar t).pcm = (Some?.v r0).ref in
   rewrite_slprop
-    (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1))
+    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v1) p1))
     (R.pts_to r (Some (Some v1, p1)))
     (fun _ -> ());
   rewrite_slprop
-    (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
+    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v2) p2))
     (R.pts_to r (Some (Some v2, p2)))
     (fun _ -> ());
   R.gather r (Some (Some v1, p1)) (Some (Some v2, p2));
   R.split r _ (Some (Some v1, p1)) (Some (Some v2, p2));
   rewrite_slprop
     (R.pts_to r (Some (Some v1, p1)))
-    (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1))
+    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v1) p1))
     (fun _ -> ());
   rewrite_slprop
     (R.pts_to r (Some (Some v2, p2)))
-    (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
+    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v2) p2))
     (fun _ -> ())
 
 let read0
-  #t #v #p r
+  #t #v #p r0
 =
+  let r : R.ref (scalar t).pcm = (Some?.v r0).ref in
   rewrite_slprop
-    (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+    (pts_to r0 (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
     (R.pts_to r (Some (Some (Ghost.reveal v), p)))
     (fun _ -> ());
   let v' = R.ref_read r in
   rewrite_slprop
     (R.pts_to r (Some (Some (Ghost.reveal v), p)))
-    (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+    (pts_to r0 (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
     (fun _ -> ());
   let Some (Some v0, _) = v' in
   return v0
 
 let write
-  #t #v r v'
+  #t #v r0 v'
 =
+  let r : R.ref (scalar t).pcm = (Some?.v r0).ref in
   rewrite_slprop
-    (pts_to r v)
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
   R.ref_upd r _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
@@ -407,17 +421,25 @@ let struct_get_field_uninitialized
   tn n fields field
 = ()
 
-let g_struct_field
-  #_ #_ #_ #fields r field
-= R.ref_focus r (S.struct_field (struct_field_pcm fields) field)
+let _inv = TD.inv
+
+let has_struct_field
+  #_ #_ #_ #fields r field r'
+= (Some?.v r').ref == R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm fields) field)
+
+let has_struct_field_inj
+  r field r1 r2
+= TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
 
 #push-options "--z3rlimit 32"
 
 #restart-solver
-let ghost_struct_field
-  #_ #tn #_ #n #fields #v r field
-= rewrite_slprop
-    (pts_to r v)
+
+let ghost_struct_field_focus
+  #_ #tn #_ #n #fields #v r0 field r'0
+= let r : R.ref (struct_pcm tn n fields) = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
   let prf
@@ -439,13 +461,26 @@ let ghost_struct_field
   R.gfocus r (S.struct_field (struct_field_pcm fields) field) vf (struct_get_field v field);
   rewrite_slprop
     (R.pts_to r _)
-    (pts_to r _)
+    (pts_to r0 _)
     (fun _ -> ());
   rewrite_slprop
     (R.pts_to _ _)
-    (pts_to (g_struct_field r field) _)
+    (pts_to r'0 _)
     (fun _ -> ())
 
+let ghost_struct_field
+  #_ #tn #_ #n #fields #v r field
+= let tok' = TD.get_token (fields.fd_type field) in
+  let r' : ref (fields.fd_typedef field) = Some ({
+    dest = tok';
+    typedef = fields.fd_typedef field;
+    ref = R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm fields) field);
+  })
+  in
+  let gr' = Ghost.hide r' in
+  ghost_struct_field_focus r field gr';
+  gr'
+
 [@@noextract_to "krml"] // primitive
 let struct_field'
   (#tn: Type0)
@@ -454,15 +489,16 @@ let struct_field'
   (#n: string)
   (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
+  (r0: ref (struct0 tn n fields))
   (field: field_t fields)
 : SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
-    (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> r' == g_struct_field r field)
-= rewrite_slprop
-    (pts_to r v)
+    (pts_to r0 v)
+    (fun r' -> pts_to r0 (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ -> has_struct_field r0 field r')
+= let r : R.ref (struct_pcm tn n fields) = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
   let prf
@@ -482,15 +518,22 @@ let struct_field'
   assert (op (struct_pcm tn n fields) v' vf `FX.feq` v);
   R.split r _ v' vf;
   let r' = R.focus r (S.struct_field (struct_field_pcm fields) field) vf (struct_get_field v field) in
+  let tok' = TD.get_token (fields.fd_type field) in
+  let res : ref (fields.fd_typedef field) = Some ({
+    dest = tok';
+    typedef = fields.fd_typedef field;
+    ref = r';
+  })
+  in
   rewrite_slprop
     (R.pts_to r _)
-    (pts_to r _)
+    (pts_to r0 _)
     (fun _ -> ());
   rewrite_slprop
     (R.pts_to _ _)
-    (pts_to r' _)
+    (pts_to res _)
     (fun _ -> ());
-  return r'
+  return res
 
 let struct_field0
   t' r field td'
@@ -501,13 +544,15 @@ let struct_field0
   return res
 
 let unstruct_field
-  #_ #tn #_ #n #fields #v r field #v' r'
-= rewrite_slprop
-    (pts_to r v)
+  #_ #tn #_ #n #fields #v r0 field #v' r'0
+= let r : R.ref (struct_pcm tn n fields) = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
+  let r' : R.ref (fields.fd_typedef field).pcm = (Some?.v r'0).ref in
   rewrite_slprop
-    (pts_to r' v')
+    (pts_to r'0 v')
     (R.pts_to r' v')
     (fun _ -> ());
   let prf
@@ -528,7 +573,7 @@ let unstruct_field
   R.gather r v _;
   rewrite_slprop
     (R.pts_to r _)
-    (pts_to r _)
+    (pts_to r0 _)
     (fun _ -> ())
 
 #pop-options
@@ -800,17 +845,22 @@ let full_union
 = Classical.move_requires (U.exclusive_union_intro (union_field_pcm fields) s) (Some field);
   Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
 
-let g_union_field
-  #_ #_ #_ #fields r field
-= R.ref_focus r (U.union_field (union_field_pcm fields) (Some field))
+let has_union_field
+  #_ #_ #_ #fields r field r'
+= (Some?.v r').ref == R.ref_focus (Some?.v r).ref (U.union_field (union_field_pcm fields) (Some field))
+
+let has_union_field_inj
+  #_ #_ #_ #fields r field r1 r2
+= TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
 
 #push-options "--z3rlimit 16"
 
 #restart-solver
-let ghost_union_field
-  #_ #tn #_ #n #fields #v r field
-= rewrite_slprop
-    (pts_to r v)
+let ghost_union_field_focus
+  #_ #tn #_ #n #fields #v r0 field r'0
+= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
   let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
@@ -818,9 +868,22 @@ let ghost_union_field
   R.gfocus r (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
   rewrite_slprop
     (R.pts_to _ _)
-    (pts_to (g_union_field r field) _)
+    (pts_to r'0 _)
     (fun _ -> ())
 
+let ghost_union_field
+  #_ #tn #_ #n #fields #v r field
+= let tok' = TD.get_token (fields.fd_type field) in
+  let r' : ref (fields.fd_typedef field) = Some ({
+    dest = tok';
+    typedef = fields.fd_typedef field;
+    ref = R.ref_focus (Some?.v r).ref (U.union_field (union_field_pcm fields) (Some field));
+  })
+  in
+  let gr' = Ghost.hide r' in
+  ghost_union_field_focus r field gr';
+  gr'
+
 [@@noextract_to "krml"] // primitive
 let union_field'
   (#tn: Type0)
@@ -829,25 +892,33 @@ let union_field'
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
+  (r0: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
 : SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
-    (pts_to r v)
+    (pts_to r0 v)
     (fun r' -> pts_to r' (union_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> r' == g_union_field r field)
-= rewrite_slprop
-    (pts_to r v)
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ -> has_union_field r0 field r')
+= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
   let v' = Ghost.hide (U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field)) in
   assert (v' `FX.feq` v);
   let r' = R.focus r (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field) in
+  let tok' = TD.get_token (fields.fd_type field) in
+  let res : ref (fields.fd_typedef field) = Some ({
+    dest = tok';
+    typedef = fields.fd_typedef field;
+    ref = r';
+  })
+  in
   rewrite_slprop
     (R.pts_to _ _)
-    (pts_to r' _)
+    (pts_to res _)
     (fun _ -> ());
-  return r'
+  return res
 
 let union_field0
   t' r field td'
@@ -858,15 +929,17 @@ let union_field0
   return res
 
 let ununion_field
-  #_ #tn #_ #n #fields r field #v' r'
-= rewrite_slprop
-    (pts_to r' v')
+  #_ #tn #_ #n #fields r0 field #v' r'0
+= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
+  let r' : R.ref (fields.fd_typedef field).pcm = (Some?.v r'0).ref in
+  rewrite_slprop
+    (pts_to r'0 v')
     (R.pts_to r' v')
     (fun _ -> ());
   R.unfocus r' r (U.union_field (union_field_pcm fields) (Some field)) _;
   rewrite_slprop
     (R.pts_to r _)
-    (pts_to r _)
+    (pts_to r0 _)
     (fun _ -> ())
 
 [@@noextract_to "krml"] // primitive
@@ -876,24 +949,25 @@ let union_switch_field'
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
+  (r0: ref (union0 tn n fields))
   (field: field_t fields)
 : Steel (ref (fields.fd_typedef field))
-    (pts_to r v)
+    (pts_to r0 v)
     (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
     (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> r' == g_union_field r field)
-= rewrite_slprop
-    (pts_to r v)
+    (fun _ r' _ -> has_union_field r0 field r')
+= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
     (R.pts_to r v)
     (fun _ -> ());
   let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
   R.ref_upd r _ _ (R.base_fpu (union_pcm tn n fields) _ v');
   rewrite_slprop
     (R.pts_to _ _)
-    (pts_to r v')
+    (pts_to r0 v')
     (fun _ -> ());
-  let r' = union_field' r field in
+  let r' = union_field' r0 field in
   return r'
 
 let union_switch_field0
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index bded71a66d1..7a7c33b230d 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -56,11 +56,23 @@ val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemm
   (ensures (v == unknown td))
 
 
+// To be extracted as: void*
+[@@noextract_to "krml"] // primitive
+val void_ptr : Type0
+ 
+// To be extracted as: NULL
+[@@noextract_to "krml"] // primitive
+val void_null: void_ptr
+
+[@@noextract_to "krml"] // proof-only
+val type_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot Type0
+val typedef_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot (typedef (type_of_ptr p))
+
 // To be extracted as: *t
 [@@noextract_to "krml"] // primitive
-val ptr (#t: Type) (td: typedef t) : Tot Type0
+let ptr (#t: Type) (td: typedef t) : Tot Type0 = (p: void_ptr { (~ (p == void_null)) ==> (type_of_ptr p == t /\ typedef_of_ptr p == td) })
 [@@noextract_to "krml"] // primitive
-val null (#t: Type) (td: typedef t) : Tot (ptr td)
+let null (#t: Type) (td: typedef t) : Tot (ptr td) = void_null
 inline_for_extraction [@@noextract_to "krml"]
 let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
 
@@ -327,14 +339,52 @@ val struct_get_field_uninitialized
   (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))
   [SMTPat (struct_get_field (uninitialized (struct0 tn n fields)) field)]
 
-val g_struct_field
+val _inv: Ghost.erased Steel.Memory.iname
+
+val has_struct_field
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
   (#fields: nonempty_field_description_t tf)
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: GTot (ref (fields.fd_typedef field))
+  (r': ref (fields.fd_typedef field))
+: GTot prop
+
+val has_struct_field_inj
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r1 r2: ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    emp
+    (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_struct_field r field r1 /\
+      has_struct_field r field r2
+    )
+    (fun _ _ _ -> r1 == r2)
+
+val ghost_struct_field_focus
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    (pts_to r v)
+    (fun _ -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
+    (fun _ -> has_struct_field r field r')
+    (fun _ _ _ -> True)
 
 val ghost_struct_field
   (#opened: _)
@@ -345,9 +395,11 @@ val ghost_struct_field
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: SteelGhostT unit opened
+: SteelGhost (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
-    (fun _ -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to (g_struct_field r field) (struct_get_field v field))
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ -> has_struct_field r field r')
 
 [@@noextract_to "krml"] // primitive
 val struct_field0
@@ -367,8 +419,10 @@ val struct_field0
 : SteelAtomicBase (ref td') false opened Unobservable
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> r' == g_struct_field r field)
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ ->
+      has_struct_field r field r'
+    )
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let struct_field
@@ -383,8 +437,10 @@ let struct_field
 : SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> r' == g_struct_field r field)
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ ->
+      has_struct_field r field r'
+    )
 = struct_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -406,7 +462,7 @@ val unstruct_field
     (pts_to r v `star` pts_to r' v')
     (fun _ -> pts_to r (struct_set_field field v' v))
     (fun _ ->
-      r' == g_struct_field r field /\
+      has_struct_field r field r' /\
       struct_get_field v field == unknown (fields.fd_typedef field)
     )
     (fun _ _ _ -> True)
@@ -634,14 +690,50 @@ val full_union
   ))
   [SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
 
-val g_union_field
+val has_union_field
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
   (#fields: field_description_t tf)
   (r: ref (union0 tn n fields))
   (field: field_t fields)
-: GTot (ref (fields.fd_typedef field))
+  (r': ref (fields.fd_typedef field))
+: GTot prop
+
+val has_union_field_inj
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r1 r2: ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    emp
+    (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_union_field r field r1 /\
+      has_union_field r field r2
+    )
+    (fun _ _ _ -> r1 == r2)
+
+val ghost_union_field_focus
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+  (r': ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    (pts_to r v)
+    (fun _ -> pts_to r' (union_get_field v field))
+    (fun _ -> has_union_field r field r')
+    (fun _ _ _ -> True)
 
 val ghost_union_field
   (#opened: _)
@@ -652,9 +744,11 @@ val ghost_union_field
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: SteelGhostT unit opened
+: SteelGhost (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
-    (fun _ -> pts_to (g_union_field r field) (union_get_field v field))
+    (fun r' -> pts_to r' (union_get_field v field))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ -> has_union_field r field r')
 
 [@@noextract_to "krml"] // primitive
 val union_field0
@@ -674,8 +768,8 @@ val union_field0
 : SteelAtomicBase (ref td') false opened Unobservable
     (pts_to r v)
     (fun r' -> pts_to r' (union_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> r' == g_union_field r field)
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ -> has_union_field r field r')
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let union_field
@@ -690,8 +784,8 @@ let union_field
 : SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
     (pts_to r v)
     (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> r' == g_union_field r field)
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ r' _ -> has_union_field r field r')
 = union_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -712,7 +806,7 @@ val ununion_field
     (pts_to r' v')
     (fun _ -> pts_to r (union_set_field tn n fields field v'))
     (fun _ ->
-      r' == g_union_field r field
+      has_union_field r field r'
     )
     (fun _ _ _ -> True)
 
@@ -736,7 +830,7 @@ val union_switch_field0
     (pts_to r v)
     (fun r' -> pts_to r' (uninitialized (fields.fd_typedef field)))
     (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> r' == g_union_field r field)
+    (fun _ r' _ -> has_union_field r field r')
 
 inline_for_extraction [@@noextract_to "krml"]
 let union_switch_field
@@ -751,7 +845,7 @@ let union_switch_field
     (pts_to r v)
     (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
     (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> r' == g_union_field r field)
+    (fun _ r' _ -> has_union_field r field r')
 = union_switch_field0
     (norm norm_field_steps (fields.fd_type field))
     r

From 210bc10ce155783a0327de3d98dcdd740134e16f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 14:06:03 -0700
Subject: [PATCH 352/513] model is_null, alloc, free

---
 ulib/experimental/Steel.C.Types.fst  | 40 ++++++++++++++++++-
 ulib/experimental/Steel.C.Types.fsti | 57 ++++++++++++++++++++++++++++
 2 files changed, 96 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index e0e2aebd0a8..1446add8295 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -82,7 +82,7 @@ let mk_fraction td x p = td.mk_fraction x p
 let mk_fraction_full td x = td.mk_fraction_full x
 let mk_fraction_compose td x p1 p2 = td.mk_fraction_compose x p1 p2
 
-let full td v = exclusive td.pcm v
+let full td v = exclusive td.pcm v /\ p_refine td.pcm v
 
 let uninitialized td = td.uninitialized
 
@@ -108,6 +108,39 @@ let typedef_of_ptr p = (Some?.v p).typedef
 
 let _pts_to r v = hp_of (R.pts_to (Some?.v r).ref v)
 
+let is_null
+  p
+= return (None? p)
+
+let freeable
+  r
+= R.freeable (Some?.v r).ref
+
+let alloc
+  #t td
+= let r = R.ref_alloc td.pcm td.uninitialized in
+  let tok = TD.get_token t in
+  let res : ref td = Some ({
+    dest = tok;
+    typedef = td;
+    ref = r;
+  })
+  in
+  rewrite_slprop
+    (R.pts_to r _)
+    (pts_to_or_null res _)
+    (fun _ -> ());
+  return res
+
+let free
+  #t #td #v r0
+= let r : R.ref td.pcm = (Some?.v r0).ref in
+  rewrite_slprop
+    (pts_to r0 v)
+    (R.pts_to r v)
+    (fun _ -> ());
+  R.ref_free r
+
 #restart-solver
 let mk_fraction_split_gen
   #_ #_ #td r0 v p p1 p2
@@ -222,6 +255,9 @@ let mk_scalar_fractionable v p = ()
 
 let mk_scalar_inj v1 v2 p1 p2 = ()
 
+#push-options "--z3rlimit 16"
+
+#restart-solver
 let scalar_unique
   #_ #t v1 v2 p1 p2 r0
 =
@@ -245,6 +281,8 @@ let scalar_unique
     (pts_to r0 (mk_fraction (scalar _) (mk_scalar v2) p2))
     (fun _ -> ())
 
+#pop-options
+
 let read0
   #t #v #p r0
 =
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 7a7c33b230d..bbcef8882af 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -85,6 +85,63 @@ let pts_to (#t: Type) (#td: typedef t) (r: ref td) ([@@@ smt_fallback ] v: Ghost
   sel = trivial_selector _;
 })
 
+let pts_to_or_null' 
+  (#t: Type) (#td: typedef t) (p: ptr td) (v: Ghost.erased t) : vprop
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (p == null _)
+  then emp
+  else pts_to p v
+
+[@@__steel_reduce__]
+let pts_to_or_null (#t: Type) (#td: typedef t) (p: ptr td) ([@@@ smt_fallback ] v: Ghost.erased t) : vprop = VUnit ({
+  hp = hp_of (pts_to_or_null' p v);
+  t = _;
+  sel = trivial_selector _;
+})
+
+[@@noextract_to "krml"] // primitive
+val is_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (p: ptr td)
+: SteelAtomicBase bool false opened Unobservable
+    (pts_to_or_null p v)
+    (fun _ -> pts_to_or_null p v)
+    (fun _ -> True)
+    (fun _ res _ -> res == true <==> p == null _)
+
+val freeable
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: GTot prop
+
+[@@noextract_to "krml"] // primitive
+val alloc
+  (#t: Type)
+  (td: typedef t)
+: Steel (ptr td)
+    emp
+    (fun p -> pts_to_or_null p (uninitialized td))
+    (fun _ -> True)
+    (fun _ p _ -> (~ (p == null _)) ==> freeable p)
+
+[@@noextract_to "krml"] // primitive
+val free
+  (#t: Type)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: Steel unit
+    (pts_to r v)
+    (fun _ -> emp)
+    (fun _ ->
+      freeable r /\
+      full td v
+    )
+    (fun _ _ _ -> True)
+
 val mk_fraction_split_gen
   (#opened: _)
   (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p p1 p2: P.perm) : SteelGhost unit opened

From 7a88cf76831f3ca57efef41c85f47d26c16dff62 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 14:08:21 -0700
Subject: [PATCH 353/513] Revert "snap"

This reverts commit c579dfa6d26b64a0e59312a11b12efce4884afa3.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 912 +---------------------
 1 file changed, 15 insertions(+), 897 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index d55dd96cb78..196817624df 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,63 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1033,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1071,21 +895,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1145,14 +966,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1165,36 +985,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1802,49 +1605,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1938,31 +1698,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2688,484 +2428,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3536,72 +2798,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3614,85 +2810,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 6056e05bcb0162f36d546d06d7e65d804aeddc6c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 14:18:57 -0700
Subject: [PATCH 354/513] extract alloc, free, is_null

---
 src/extraction/FStar.Extraction.Krml.fst | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 4b312fc811f..895d68ec42f 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -785,6 +785,12 @@ and translate_expr env e: expr =
           false) ->
       EBufCreate (ManuallyManaged, translate_expr env e, EConstant (UInt32, "1"))
 
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
+    when (
+          string_of_mlpath p = "Steel.C.Types.alloc" ||
+          false) ->
+      EBufCreateNoInit (ManuallyManaged, EConstant (UInt32, "1"))
+
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e0; e1 ])
     when string_of_mlpath p = "Steel.ST.HigherArray.malloc_ptr" ->
       EBufCreate (ManuallyManaged, translate_expr env e0, translate_expr env e1)
@@ -817,6 +823,10 @@ and translate_expr env e: expr =
           false) ->
       EBufFree (translate_expr env e2)
 
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *); _ (* v *); e ]) when
+       string_of_mlpath p = "Steel.C.Types.free" ->
+      EBufFree (translate_expr env e)
+
   (* Generic buffer operations. *)
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _e3 ]) when (string_of_mlpath p = "FStar.Buffer.sub") ->
       EBufSub (translate_expr env e1, translate_expr env e2)
@@ -1029,6 +1039,10 @@ IsNull nodes should be added to the KaRaMeL AST *)
     when string_of_mlpath p = "Steel.C.Reference.is_null"
     -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); _ (* td *); _ (* v *); e])
+    when string_of_mlpath p = "Steel.C.Types.is_null"
+    -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
+  
   | MLE_TApp ({expr=MLE_Name p}, _)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.null_from"
     -> EQualified (["LowStar"; "Buffer"], "null")

From 858078bc6e25fc0b481c0d66add956e6d5c0d99c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 17:01:11 -0700
Subject: [PATCH 355/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 967 +++++++++++++++++++++-
 1 file changed, 952 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 196817624df..54543f937d9 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -141,6 +144,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -207,6 +211,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -426,6 +438,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -573,6 +589,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -666,6 +686,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -817,7 +933,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -827,8 +944,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -846,6 +964,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -858,7 +1033,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -895,18 +1071,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -966,13 +1145,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -985,19 +1165,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1605,6 +1802,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1698,11 +1955,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2428,6 +2722,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::uu___7::e1::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Types.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2798,6 +3591,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2810,7 +3669,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From f3d6a930f6d78d0d81f3928890c958e83410ffc0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 16:20:42 -0700
Subject: [PATCH 356/513] linked lists with void*

---
 examples/steel/arraystructs/LList.fst | 211 ++++++++++++++++++++++++++
 ulib/experimental/Steel.C.Types.fsti  |  26 ++++
 2 files changed, 237 insertions(+)
 create mode 100644 examples/steel/arraystructs/LList.fst

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
new file mode 100644
index 00000000000..bd49fab978f
--- /dev/null
+++ b/examples/steel/arraystructs/LList.fst
@@ -0,0 +1,211 @@
+module LList
+open Steel.C.Types
+
+module U32 = FStar.UInt32
+
+noextract
+inline_for_extraction
+[@@ norm_field_attr]
+let cell_fields =
+  field_description_cons "hd" (scalar U32.t) (
+  field_description_cons "tl" (scalar void_ptr) (
+  field_description_nil))
+
+let _ = define_struct "LList.cell" cell_fields
+
+inline_for_extraction noextract
+let cell = struct "LList.cell" cell_fields
+
+let rec llist' (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop (decreases (Ghost.reveal l)) =
+  match Ghost.reveal l with
+  | [] -> pure (p == null _)
+  | a :: q ->
+    h_exists (fun (_: squash (~ (p == null _) /\ freeable p)) ->
+      h_exists (fun (p' : ptr cell) ->
+      pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
+      llist' p' q
+    ))
+
+[@@__steel_reduce__]
+let llist (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop = VUnit ({
+  hp = hp_of (llist' p l);
+  t = _;
+  sel = trivial_selector _;
+})
+
+let change_slprop_by_norm
+  (#opened: _) (p q: vprop)
+: SteelGhost unit opened p (fun _ -> q) (fun _ -> normalize (hp_of p == hp_of q)) (fun _ _ _ -> True)
+= rewrite_slprop p q (fun _ -> ())
+
+let llist_intro_nil (#opened: _) (p: ptr cell) : SteelGhost unit opened
+  emp
+  (fun _ -> llist p [])
+  (fun _ -> p == null _)
+  (fun _ _ _ -> True)
+= intro_pure (p == null _);
+  change_slprop_by_norm
+    (pure (p == null _))
+    (llist p [])
+
+let llist_intro_cons (#opened: _) (p: ref cell) (s: Ghost.erased (struct_t "LList.cell" cell_fields)) (a: U32.t) (p' : ptr cell) (q: Ghost.erased (list U32.t)) : SteelGhost unit opened
+  (pts_to p s `star` llist p' q)
+  (fun _ -> llist p (a :: q))
+  (fun _ ->
+    freeable p /\
+    s `struct_eq` struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))
+  )
+  (fun _ _ _ -> True)
+= change_equal_slprop (pts_to p s) (pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))));
+  intro_exists p' (fun (p' : ptr cell) -> pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
+      llist p' q
+  );
+  intro_exists () (fun (_: squash (~ (p == null _) /\ freeable p)) ->
+    h_exists (fun (p' : ptr cell) -> pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
+      llist p' q
+  ));
+  change_slprop_by_norm
+    (h_exists _)
+    (llist p (a :: q))
+
+let llist_elim_nil (#opened: _) (p: ptr cell) (l: Ghost.erased (list U32.t)) : SteelGhost unit opened
+  (llist p l)
+  (fun _ -> emp)
+  (fun _ -> Nil? l)
+  (fun _ _ _ -> p == null _)
+= change_equal_slprop (llist p l) (llist p []);
+  change_slprop_by_norm
+    (llist p [])
+    (pure (p == null _));
+  elim_pure _
+
+let llist_elim_cons (#opened: _) (p: ptr cell) (l: Ghost.erased (list U32.t)) (sq: squash (Cons? l))
+: SteelGhostT (p': Ghost.erased (ptr cell) { ~ (p == null _) /\ freeable p }) opened
+  (llist p l)
+  (fun p' ->
+    pts_to p (struct_set_field "hd" (mk_scalar (List.Tot.hd l)) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
+    llist p' (List.Tot.tl l)
+  )
+= let a :: q = Ghost.reveal l in
+  change_equal_slprop (llist p l) (llist p (a :: q));
+  change_slprop_by_norm
+    (llist p (a :: q))
+    (h_exists (fun (_: squash (~ (p == null _) /\ freeable p)) ->
+      h_exists (fun (p' : ptr cell) ->
+      pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
+      llist p' q
+    )));
+  let prf : Ghost.erased (squash (~ (p == null _) /\ freeable p)) = witness_exists () in
+  let _ = Ghost.reveal prf in
+  let p1 = witness_exists () in
+  let p' : (p': Ghost.erased (ptr cell) { ~ (p == null _) /\ freeable p }) = p1 in
+  change_equal_slprop
+    (pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p1 <: void_ptr)) (unknown cell))))
+    (pts_to p (struct_set_field "hd" (mk_scalar (List.Tot.hd l)) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))));
+  change_equal_slprop
+    (llist _ q)
+    (llist p' (List.Tot.tl l));
+  p'
+
+[@@__steel_reduce__]
+let pllist
+  (p: ref (scalar (ptr cell)))
+  (l: Ghost.erased (list U32.t))
+: Tot vprop
+= h_exists (fun (pc: ptr cell) ->
+    pts_to p (mk_scalar pc) `star`
+    llist pc l
+  )
+
+let pllist_get
+  (#l: Ghost.erased (list U32.t))
+  (p: ref (scalar (ptr cell)))
+: SteelT (ptr cell)
+    (pllist p l)
+    (fun pc -> pts_to p (mk_scalar (Ghost.reveal pc)) `star` llist pc l)
+= let _ = witness_exists () in
+  let pc = read p in
+  change_equal_slprop (pts_to p _) (pts_to p (mk_scalar (Ghost.reveal pc)));
+  change_equal_slprop (llist _ _) (llist pc l);
+  return pc
+
+let pllist_put
+  (#v: Ghost.erased (scalar_t (ptr cell)))
+  (#l: Ghost.erased (list U32.t))
+  (p: ref (scalar (ptr cell)))
+  (pc: ptr cell)
+: Steel unit
+    (pts_to p v `star` llist pc l)
+    (fun _ -> pllist p l)
+    (fun _ -> full (scalar (ptr cell)) v)
+    (fun _ _ _ -> True)
+= write p pc;
+  intro_exists pc (fun (pc: ptr cell) ->
+    pts_to p (mk_scalar pc) `star`
+    llist pc l
+  );
+  change_slprop_by_norm
+    (h_exists (fun (pc: ptr cell) ->
+      pts_to p (mk_scalar pc) `star`
+      llist pc l
+    ))
+    (pllist p l)
+
+let push
+  (#l: Ghost.erased (list U32.t))
+  (a: U32.t)
+  (p: ref (scalar (ptr cell)))
+: SteelT bool
+    (pllist p l)
+    (fun b -> pllist p (if b then a :: l else l))
+= let c = alloc cell in
+  if is_null c
+  then begin
+    assert_null c;
+    return false
+  end else begin
+    assert_not_null c;
+    let p_tl = pllist_get p in
+    let c_hd = struct_field c "hd" in
+    let c_tl = struct_field c "tl" in
+    write c_hd a;
+    write c_tl p_tl;
+    unstruct_field c "tl" c_tl;
+    unstruct_field c "hd" c_hd;
+    llist_intro_cons c _ a p_tl _;
+    pllist_put p c;
+    return true
+  end
+
+let pop
+  (#l: Ghost.erased (list U32.t))
+  (p: ref (scalar (ptr cell)))
+  (sq: squash (Cons? l))
+: Steel U32.t
+    (pllist p l)
+    (fun _ -> pllist p (List.Tot.tl l))
+    (fun _ -> True)
+    (fun _ res _ -> res == List.Tot.hd l)
+= let c = pllist_get p in
+  let _ = llist_elim_cons c _ () in
+  let c_hd = struct_field c "hd" in
+  let c_tl = struct_field c "tl" in
+  let res = read c_hd in
+  let p_tl = read c_tl in
+  unstruct_field c "tl" c_tl;
+  unstruct_field c "hd" c_hd;
+  free c;
+  change_equal_slprop (llist _ _) (llist p_tl (List.Tot.tl l));
+  pllist_put p p_tl;
+  return res
+
+let init
+  (#v: Ghost.erased (scalar_t (ptr cell)))
+  (r: ref (scalar (ptr cell)))
+: Steel unit
+    (pts_to r v)
+    (fun _ -> pllist r [])
+    (fun _ -> full (scalar (ptr cell)) v)
+    (fun _ _ _ -> True)
+= llist_intro_nil (null _);
+  pllist_put r (null _)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index bbcef8882af..1ff9eb6f873 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -111,6 +111,32 @@ val is_null
     (fun _ -> True)
     (fun _ res _ -> res == true <==> p == null _)
 
+let assert_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (p: ptr td)
+: SteelGhost unit opened
+    (pts_to_or_null p v)
+    (fun _ -> emp)
+    (fun _ -> p == null _)
+    (fun _ _ _ -> True)
+= rewrite_slprop (pts_to_or_null p v) emp (fun _ -> ())
+
+let assert_not_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (p: ptr td)
+: SteelGhost (squash (~ (p == null _))) opened
+    (pts_to_or_null p v)
+    (fun _ -> pts_to p v)
+    (fun _ -> ~ (p == null _))
+    (fun _ _ _ -> True)
+= change_equal_slprop (pts_to_or_null p v) (pts_to p v)
+
 val freeable
   (#t: Type)
   (#td: typedef t)

From 546a6a701700cd3ddad5c0c8e5596316f74bb9de Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 1 Nov 2022 16:48:00 -0700
Subject: [PATCH 357/513] stopgap measure to extract void* without krml
 support/branch

---
 examples/steel/arraystructs/Makefile       |  4 ++--
 examples/steel/arraystructs/lib/.gitignore |  1 +
 examples/steel/arraystructs/lib/steel_c.h  | 10 ++++++++++
 ulib/experimental/Steel.C.Types.fsti       |  6 ++++++
 4 files changed, 19 insertions(+), 2 deletions(-)
 create mode 100644 examples/steel/arraystructs/lib/.gitignore
 create mode 100644 examples/steel/arraystructs/lib/steel_c.h

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index fe5cd5b1287..2d678d7a298 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -63,7 +63,7 @@ ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
 FILTERED_KRML_FILES=$(filter-out FStar_NMST.krml Steel_%.krml,$(ALL_KRML_FILES))
 
 extract: $(FILTERED_KRML_FILES)
-	$(KRML_EXE) -skip-compilation -skip-makefiles -bundle 'FStar.\*,Steel.\*,C' $^
+	$(KRML_EXE) -skip-compilation -skip-makefiles -bundle 'FStar.\*,Steel.\*,C' -add-include '"steel_c.h"' $^
 	touch $@
 
 ALL_C_FILES=$(addsuffix .c,$(ALL_MODULE_NAMES))
@@ -75,7 +75,7 @@ $(ALL_C_FILES): %.c: extract
 ALL_O_FILES=$(subst .c,.o,$(ALL_C_FILES))
 
 $(ALL_O_FILES): %.o: %.c
-	$(CC) $(CFLAGS) -DKRML_VERIFIED_UINT128 -I $(KRML_HOME)/include -I $(KRML_HOME)/krmllib/dist/minimal -o $@ -c $<
+	$(CC) $(CFLAGS) -DKRML_VERIFIED_UINT128 -I $(KRML_HOME)/include -I $(KRML_HOME)/krmllib/dist/minimal -I lib -o $@ -c $<
 
 test: $(ALL_O_FILES)
 
diff --git a/examples/steel/arraystructs/lib/.gitignore b/examples/steel/arraystructs/lib/.gitignore
new file mode 100644
index 00000000000..96e79c167db
--- /dev/null
+++ b/examples/steel/arraystructs/lib/.gitignore
@@ -0,0 +1 @@
+!*.h
diff --git a/examples/steel/arraystructs/lib/steel_c.h b/examples/steel/arraystructs/lib/steel_c.h
new file mode 100644
index 00000000000..9059f8b1b5b
--- /dev/null
+++ b/examples/steel/arraystructs/lib/steel_c.h
@@ -0,0 +1,10 @@
+#ifndef __STEEL_C
+#define __STEEL_C
+
+// This file is a stopgap measure to avoid creating a Karamel branch.
+// Ideally, it should be empty, and its contents should be added to
+// krmllib.h
+
+typedef void* Steel_C_Types_void_ptr;
+
+#endif // ndef __STEEL_C
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 1ff9eb6f873..84dda6d942e 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -57,6 +57,12 @@ val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemm
 
 
 // To be extracted as: void*
+
+// FIXME: Currently, Karamel does not directly support
+// void*. examples/steel/arraystructs currently has a stopgap in
+// lib/steel_c.h, whose contents should be moved to krmllib.h, unless
+// direct support for void* is added to Karamel.
+
 [@@noextract_to "krml"] // primitive
 val void_ptr : Type0
  

From 39200aaa67b978d3721f89db60bc18fc2649e941 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 2 Nov 2022 10:07:27 -0700
Subject: [PATCH 358/513] precompute struct typename (halves F* verification
 memory consumption)

---
 examples/steel/arraystructs/LList.fst | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index bd49fab978f..7d892c536df 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -11,10 +11,13 @@ let cell_fields =
   field_description_cons "tl" (scalar void_ptr) (
   field_description_nil))
 
-let _ = define_struct "LList.cell" cell_fields
+inline_for_extraction noextract
+let cell_n : Type0 = norm Steel.C.Typestring.norm_typestring (Steel.C.Typestring.mk_string_t "LList.cell")
+
+let _ = define_struct0 cell_n "LList.cell" cell_fields
 
 inline_for_extraction noextract
-let cell = struct "LList.cell" cell_fields
+let cell = struct0 cell_n "LList.cell" cell_fields
 
 let rec llist' (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop (decreases (Ghost.reveal l)) =
   match Ghost.reveal l with
@@ -48,7 +51,7 @@ let llist_intro_nil (#opened: _) (p: ptr cell) : SteelGhost unit opened
     (pure (p == null _))
     (llist p [])
 
-let llist_intro_cons (#opened: _) (p: ref cell) (s: Ghost.erased (struct_t "LList.cell" cell_fields)) (a: U32.t) (p' : ptr cell) (q: Ghost.erased (list U32.t)) : SteelGhost unit opened
+let llist_intro_cons (#opened: _) (p: ref cell) (s: Ghost.erased (typeof cell)) (a: U32.t) (p' : ptr cell) (q: Ghost.erased (list U32.t)) : SteelGhost unit opened
   (pts_to p s `star` llist p' q)
   (fun _ -> llist p (a :: q))
   (fun _ ->

From 002b84fa27ce751e0ddd75d0d7aaa24a1d399dc1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 2 Nov 2022 11:13:21 -0700
Subject: [PATCH 359/513] Revert "snap"

This reverts commit 858078bc6e25fc0b481c0d66add956e6d5c0d99c.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 967 +---------------------
 1 file changed, 15 insertions(+), 952 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 54543f937d9..196817624df 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -144,7 +141,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,14 +207,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -438,10 +426,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -589,10 +573,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -686,102 +666,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -933,8 +817,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -944,9 +827,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -964,63 +846,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1033,8 +858,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1071,21 +895,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1145,14 +966,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1165,36 +985,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1802,66 +1605,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1955,48 +1698,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2722,505 +2428,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::uu___7::e1::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Types.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3591,72 +2798,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3669,85 +2810,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 8e242baaeb9fdc88528018e946d2e400e0d16900 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 2 Nov 2022 11:20:44 -0700
Subject: [PATCH 360/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 967 +++++++++++++++++++++-
 1 file changed, 952 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index c98d5cc93fd..c8a2bf1dc9a 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -143,6 +146,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -209,6 +213,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -428,6 +440,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -579,6 +595,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -674,6 +694,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -825,7 +941,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -835,8 +952,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -854,6 +972,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -866,7 +1041,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -903,18 +1079,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -974,13 +1153,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -993,19 +1173,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1613,6 +1810,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1706,11 +1963,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2436,6 +2730,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::uu___7::e1::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Types.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2808,6 +3601,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2820,7 +3679,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From f97cfd21e973eac448d192125db97cb6332731b2 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 2 Nov 2022 12:00:34 -0700
Subject: [PATCH 361/513] move new array model to size_t

---
 ulib/experimental/Steel.C.Model.Array.fst | 24 ++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index 942c81840f3..28a7d51fad3 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -4,13 +4,16 @@ open Steel.C.Model.PCM
 open Steel.C.Model.Connection
 open Steel.C.Model.Ref
 open Steel.C.Model.Struct
-open Steel.C.StdInt
 open Steel.Effect
 module R = Steel.C.Model.Ref
 module A = Steel.Effect.Atomic
+module SZ = FStar.SizeT
 
 (* Base array type *)
 
+let size_t = SZ.t
+let size_v = SZ.v
+
 let array_domain
   (n: Ghost.erased size_t)
 : Tot Type0
@@ -88,6 +91,8 @@ let adjacent
   a1.base == a2.base /\
   size_v a1.offset + size_v a1.len == size_v a2.offset
 
+let size_add = SZ.add
+
 let merge
   (#t: Type)
   (#p: pcm t)
@@ -103,6 +108,10 @@ let merge
     prf = ();
   }
 
+let size_le = SZ.lte
+let size_lt = SZ.lt
+let size_sub = SZ.sub
+
 let large_to_small_index
   (large_len: size_t)
   (offset: size_t)
@@ -159,6 +168,8 @@ let array_pcm_carrier_of_seq
 : Tot (array_pcm_carrier t n)
 = on_dom (array_domain n) (fun i -> Seq.index s (size_v i) <: array_range t n i)
 
+let int_to_size_t = SZ.uint_to_t
+
 let seq_of_array_pcm_carrier
   (#t: Type)
   (#n: Ghost.erased size_t)
@@ -541,7 +552,7 @@ let split_l
 : Pure (array p)
     (requires (size_v i <= size_v a.len))
     (ensures (fun _ -> True))
-= sub a zero_size i
+= sub a 0sz i
 
 let split_r
   (#t: Type)
@@ -642,12 +653,12 @@ let g_split
   let sr0 = Seq.slice s (size_v i) (size_v a.len) in
   let sr : Seq.lseq t (size_v a.len) = Seq.create (size_v i) (one p) `Seq.append` sr0 in
   share a s sl sr;
-  g_focus_sub a s zero_size i () sl (split_l a i) (Seq.slice s 0 (size_v i));
+  g_focus_sub a s 0sz i () sl (split_l a i) (Seq.slice s 0 (size_v i));
   g_focus_sub a s i (a.len `size_sub` i) () sr (split_r a i) (Seq.slice s (size_v i) (size_v a.len))
 
 #pop-options
 
-#push-options "--z3rlimit 64"
+#push-options "--z3rlimit 128"
 
 #restart-solver
 let unfocus_sub
@@ -715,7 +726,7 @@ let unfocus_sub
 
 #pop-options
 
-#push-options "--z3rlimit 128 --fuel 0 --ifuel 1 --z3cliopt smt.arith.nl=false"
+#push-options "--z3rlimit 256 --fuel 0 --ifuel 1 --z3cliopt smt.arith.nl=false"
 
 #restart-solver
 let join
@@ -743,8 +754,7 @@ let join
   let sr : Seq.lseq t (size_v a.len) = Seq.create (size_v i) (one p) `Seq.append` sr0 in
   let s : Seq.lseq t (size_v a.len) = Seq.append sl0 sr0 in
   assert (i == Ghost.reveal al.len);
-  assert (size_v zero_size == 0);
-  unfocus_sub a s zero_size i () sl al sl0;
+  unfocus_sub a s 0sz i () sl al sl0;
   unfocus_sub a s i (a.len `size_sub` i) () sr ar sr0;
   gather a s sl sr;
   A.change_equal_slprop (pts_to a _) (pts_to a _)

From bf5979eb6497b1bb8d15eb422fdf0590bd5e1d5c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 2 Nov 2022 16:11:24 -0700
Subject: [PATCH 362/513] ref as array

---
 ulib/experimental/Steel.C.Model.Array.fst | 147 ++++++++++++++++++++++
 1 file changed, 147 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index 28a7d51fad3..9e58d1c70d6 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -760,3 +760,150 @@ let join
   A.change_equal_slprop (pts_to a _) (pts_to a _)
 
 #pop-options
+
+#restart-solver
+let array_as_one_ref_iso
+  (#t: Type)
+  (p: pcm t)
+: Tot (isomorphism (array_pcm p 1sz) p)
+= assert_norm (size_v 1sz == 1);
+  let c = cell p 1sz 0sz in
+  let c1 = c.conn_large_to_small in
+  let c2 = c.conn_small_to_large in
+  Steel.C.Model.Connection.mkisomorphism
+    c1
+    c2
+    ()
+    (Steel.C.Model.Connection.is_inverse_of_intro
+      c2.Steel.C.Model.Connection.morph
+      c1.Steel.C.Model.Connection.morph
+      (fun x ->
+        array_pcm_carrier_ext t 1sz (c2.Steel.C.Model.Connection.morph (c1.Steel.C.Model.Connection.morph x)) x (fun i ->
+          ()
+        )
+      )
+    )
+    (fun x -> ())
+    (fun x -> ())
+
+#restart-solver
+let array_as_one_ref_iso_eq
+  (#t: Type)
+  (p: pcm t)
+: Lemma
+  (
+    let _ = assert_norm (size_v 0sz == 0) in
+    let _ = assert_norm (size_v 1sz == 1) in
+    let _ : squash (size_v 0sz < size_v 1sz) = () in
+    connection_of_isomorphism (array_as_one_ref_iso p) == cell p 1sz 0sz
+  )
+= assert_norm (size_v 0sz == 0);
+  assert_norm (size_v 1sz == 1);
+  let l = (connection_of_isomorphism (array_as_one_ref_iso p)) in
+  let m = (cell p 1sz 0sz) in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      connection_of_isomorphism_fpu_eq (array_as_one_ref_iso p) x y f v;
+      assert_norm ((m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == struct_field_lift_fpu' (array_elements_pcm p 1sz) 0sz x y f v);
+      assert (connection_of_isomorphism_fpu' (array_as_one_ref_iso p) x y f v `feq` struct_field_lift_fpu' (array_elements_pcm p 1sz) 0sz x y f v);
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+let array_of_ref_conn
+  (#t: Type)
+  (p: pcm t) 
+: Tot (connection p (array_pcm p 1sz))
+= connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso p))
+
+let g_array_of_ref
+  (#t: Type)
+  (#p: pcm t)
+  (r: ref p)
+: Ghost (array p)
+    (requires True)
+    (ensures (fun a ->
+      size_v a.base_len == 1 /\
+      size_v a.len == 1
+    ))
+= assert_norm (size_v 1sz == 1);
+  {
+    base_len = _;
+    base = ref_focus r (array_of_ref_conn p);
+    offset = 0sz;
+    len = 1sz;
+    prf = ();
+  }
+
+let ref_of_array_of_ref_base
+  (#t: Type)
+  (#p: pcm t)
+  (r: ref p)
+: Lemma
+  (ref_of_array (g_array_of_ref r) == ref_focus r (array_of_ref_conn p))
+= ref_of_array_id (g_array_of_ref r)
+
+#push-options "--split_queries"
+
+#restart-solver
+let ref_of_array_of_ref
+  (#t: Type)
+  (#p: pcm t)
+  (r: ref p)
+: Lemma
+  (ref_focus (ref_of_array (g_array_of_ref r)) (cell p 1sz 0sz) == r)
+= ref_of_array_of_ref_base r;
+  ref_focus_comp r (array_of_ref_conn p) (cell p 1sz 0sz); 
+  array_as_one_ref_iso_eq p;
+  connection_of_isomorphism_inverse_left (array_as_one_ref_iso p);
+  ref_focus_id r
+
+#pop-options
+
+#restart-solver
+let ghost_array_of_ref
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (#v: t)
+  (r: ref p)
+: A.SteelGhostT unit opened
+    (R.pts_to r v)
+    (fun _ -> pts_to (g_array_of_ref r) (Seq.create 1 v))
+= assert_norm (size_v 0sz == 0);
+  assert_norm (size_v 1sz == 1);
+  let v' : array_pcm_carrier t 1sz = field_to_struct_f (array_elements_pcm p 1sz) 0sz v in
+  assert (seq_of_array_pcm_carrier v' `Seq.equal` Seq.create 1 v);
+  R.gfocus r (array_of_ref_conn p) _ v';
+  ref_of_array_of_ref_base r; 
+  intro_pts_to1 _ _ _ _
+
+#restart-solver
+let array_of_ref
+  (#t: Type)
+  (#p: pcm t)
+  (#v: Ghost.erased t)
+  (r: ref p)
+: Steel (array p)
+    (R.pts_to r v)
+    (fun a -> pts_to a (Seq.create 1 (Ghost.reveal v)))
+    (fun _ -> True)
+    (fun _ a _ -> a == g_array_of_ref r)
+= assert_norm (size_v 0sz == 0);
+  assert_norm (size_v 1sz == 1);
+  let v' : Ghost.erased (array_pcm_carrier t 1sz) = Ghost.hide (field_to_struct_f (array_elements_pcm p 1sz) 0sz v) in
+  assert (seq_of_array_pcm_carrier v' `Seq.equal` Seq.create 1 (Ghost.reveal v));
+  let r' = R.focus r (array_of_ref_conn p) _ v' in
+  let a : array p = {
+    base_len = 1sz;
+    base = r';
+    offset = 0sz;
+    len = 1sz;
+    prf = ();    
+  }
+  in
+  ref_of_array_of_ref_base r;
+  intro_pts_to1 a _ _ _;
+  A.return a

From 76a1856892cf18162d3e61543d8625ed755c690c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 2 Nov 2022 17:13:51 -0700
Subject: [PATCH 363/513] make array operations atomic

---
 ulib/experimental/Steel.C.Model.Array.fst  | 6 ++++--
 ulib/experimental/Steel.C.Model.Struct.fst | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index 9e58d1c70d6..19721fe878d 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -425,12 +425,13 @@ let pts_to_intro_from_base
 #restart-solver
 let focus_cell
   (#t: Type)
+  (#opened: _)
   (#p: pcm t)
   (r: array p)
   (s: Ghost.erased (Seq.seq t))
   (i: size_t)
   (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
-: Steel (_: ref p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) })
+: A.SteelAtomicBase (_: ref p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) }) false opened Unobservable
     (pts_to r s)
     (fun r' -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to r' (Seq.index s (size_v i)))
     (fun _ -> True)
@@ -883,10 +884,11 @@ let ghost_array_of_ref
 #restart-solver
 let array_of_ref
   (#t: Type)
+  (#opened: _)
   (#p: pcm t)
   (#v: Ghost.erased t)
   (r: ref p)
-: Steel (array p)
+: A.SteelAtomicBase (array p) false opened Unobservable
     (R.pts_to r v)
     (fun a -> pts_to a (Seq.create 1 (Ghost.reveal v)))
     (fun _ -> True)
diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index f37080b6fd8..ffabc695c5f 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -766,10 +766,11 @@ let g_addr_of_struct_field
   gfocus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
 
 let addr_of_struct_field
+  (#opened: _)
   (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
   (r: ref (prod_pcm p)) (k:a)
   (xs: Ghost.erased (restricted_t a b))
-: Steel (ref (p k))
+: A.SteelAtomicBase (ref (p k)) false opened Unobservable
     (r `pts_to` xs)
     (fun s ->
       (r `pts_to` struct_without_field p k xs) `star` 

From 49b9ed0a146b3430b0dd65a8bb607293802d8a5f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 3 Nov 2022 10:31:23 -0700
Subject: [PATCH 364/513] all structs must have at least one field

---
 ulib/experimental/Steel.C.Types.fst  | 10 +++++-----
 ulib/experimental/Steel.C.Types.fsti | 30 +++++++++++++---------------
 2 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 1446add8295..4ce0a0d572a 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -337,13 +337,13 @@ let struct_t0 _ n fields =
 
 [@@noextract_to "krml"] // proof-only
 let struct_pcm
-  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+  (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf)
 : Tot (pcm (struct_t0 tn n fields))
 = S.prod_pcm (struct_field_pcm fields)
 
 [@@noextract_to "krml"] // proof-only
 let t_struct_set_field
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields)
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields)
 : Tot (struct_t0 tn n fields)
 = FX.on_dom (field_t fields) (fun f' -> if f = f' then v else s f')
 
@@ -361,7 +361,7 @@ let struct_eq_intro
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s1 s2: struct_t0 tn n fields)
   (prf: (
     (f: field_t fields) ->
@@ -382,14 +382,14 @@ let struct_get_field_other
 = ()
 
 let struct_fractionable
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
 : GTot bool
 = FStar.StrongExcludedMiddle.strong_excluded_middle (forall (f: field_t fields) . (fields.fd_typedef f).fractionable (s f))
 
 [@@noextract_to "krml"] // proof-only
 let struct_mk_fraction
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
   (p: P.perm)
 : Pure (struct_t0 tn n fields)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 84dda6d942e..b4dd5b329dc 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -324,7 +324,7 @@ let field_description_nil : field_description_t field_t_nil = {
 inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
 let field_description_cons0
   (fn: Type0) (#ft: Type0) (#fc: Type0) (n: string) (t: typedef ft) (fd: field_description_t fc)
-: Tot (field_description_t (field_t_cons fn ft fc))
+: Tot (nonempty_field_description_t (field_t_cons fn ft fc))
 = {
     fd_def = (fun n' -> n = n' || fd.fd_def n');
     fd_empty = false;
@@ -333,29 +333,29 @@ let field_description_cons0
   }
 
 inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
-let field_description_cons (#ft: Type0) (#fc: Type0) (n: string) (#fn: Type0) (# [ solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == fn))) (t: typedef ft) (fd: field_description_t fc) : Tot (field_description_t (field_t_cons fn ft fc)) =
+let field_description_cons (#ft: Type0) (#fc: Type0) (n: string) (#fn: Type0) (# [ solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == fn))) (t: typedef ft) (fd: field_description_t fc) : Tot (nonempty_field_description_t (field_t_cons fn ft fc)) =
   field_description_cons0 fn #ft #fc n t fd
 
 [@@noextract_to "krml"] // primitive
-val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
 inline_for_extraction [@@noextract_to "krml"]
-let define_struct (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+let define_struct (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
 = define_struct0 tn #tf n fields
 
 // To be extracted as: struct t
 [@@noextract_to "krml"] // primitive
-val struct_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+val struct_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
 inline_for_extraction [@@noextract_to "krml"]
-let struct_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+let struct_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
 = struct_t0 tn #tf n fields
 
-val struct_set_field (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields) : GTot (struct_t0 tn n fields)
+val struct_set_field (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields) : GTot (struct_t0 tn n fields)
 
 val struct_get_field
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
   (field: field_t fields)
 : GTot (fields.fd_type field)
@@ -364,7 +364,7 @@ val struct_eq
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s1 s2: struct_t0 tn n fields)
 : Ghost prop
   (requires True)
@@ -377,7 +377,7 @@ val struct_get_field_same
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
   (field: field_t fields)
   (v: fields.fd_type field)
@@ -389,7 +389,7 @@ val struct_get_field_other
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
-  (#fields: field_description_t tf)
+  (#fields: nonempty_field_description_t tf)
   (s: struct_t0 tn n fields)
   (field: field_t fields)
   (v: fields.fd_type field)
@@ -403,16 +403,14 @@ val struct_get_field_other
 val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
 
 [@@noextract_to "krml"] // proof-only
-let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Pure (typedef (struct_t0 tn n fields))
-  (requires (fields.fd_empty == false))
-  (ensures (fun _ -> True))
+let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
 = struct0 tn #tf n fields
 
 val struct_get_field_unknown
   (tn: Type0)
   (#tf: Type0)
   (n: string)
-  (fields: field_description_t tf)
+  (fields: nonempty_field_description_t tf)
   (field: field_t fields)
 : Lemma
   (struct_get_field (unknown (struct0 tn n fields)) field == unknown (fields.fd_typedef field))
@@ -422,7 +420,7 @@ val struct_get_field_uninitialized
   (tn: Type0)
   (#tf: Type0)
   (n: string)
-  (fields: field_description_t tf)
+  (fields: nonempty_field_description_t tf)
   (field: field_t fields)
 : Lemma
   (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))

From 1bf0a8b9316d3a6573868e0b6f44eb040ba19c55 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 3 Nov 2022 12:47:21 -0700
Subject: [PATCH 365/513] generalize struct typedef

---
 ulib/experimental/Steel.C.Types.fst | 203 +++++++++++++++++++---------
 1 file changed, 138 insertions(+), 65 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 4ce0a0d572a..8932c2a3529 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -320,34 +320,75 @@ irreducible let norm_field_attr = ()
 
 let define_struct0 _ _ _ = unit
 
+[@@noextract_to "krml"]
+noeq
+type field_description_gen_t (field_t: eqtype) : Type u#1 = {
+  fd_nonempty: squash (exists (f: field_t) . True);
+  fd_type: (field_t -> Type0);
+  fd_typedef: ((s: field_t) -> Tot (typedef (fd_type s)));
+}
+
+let nonempty_field_description_nonempty
+  (#tf: Type)
+  (fd: nonempty_field_description_t tf)
+: Lemma
+  (exists (f: field_t fd) . True)
+= if StrongExcludedMiddle.strong_excluded_middle (exists (f: field_t fd) . True)
+  then ()
+  else begin
+    let prf
+      (f: string)
+    : Lemma
+      (fd.fd_def f == false)
+    = if fd.fd_def f
+      then Classical.exists_intro (fun (f: field_t fd) -> True) f
+      else ()
+    in
+    Classical.forall_intro prf
+  end
+
+[@@noextract_to "krml"]
+let fd_gen_of_nonempty_fd (#tf: Type0) (fd: nonempty_field_description_t tf) : Tot (field_description_gen_t (field_t fd)) = {
+  fd_nonempty = nonempty_field_description_nonempty fd;
+  fd_type = fd.fd_type;
+  fd_typedef = (fun (s: field_t fd) -> fd.fd_typedef s);
+}
+
 module S = Steel.C.Model.Struct
 
 [@@noextract_to "krml"] // proof-only
 let struct_field_pcm
-  (#tf: Type0)
-  (fields: field_description_t tf)
-  (f: field_t fields)
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+  (f: field_t)
 : Tot (pcm (fields.fd_type f))
 = (fields.fd_typedef f).pcm
 
 module FX = FStar.FunctionalExtensionality
 
+[@@noextract_to "krml"] // primitive
+let struct_t1 (#field_t: eqtype) (fields: field_description_gen_t field_t) : Tot Type0 =
+  FX.restricted_t field_t fields.fd_type
+
 let struct_t0 _ n fields =
-  FX.restricted_t (field_t fields) fields.fd_type
+  struct_t1 (fd_gen_of_nonempty_fd fields)
 
 [@@noextract_to "krml"] // proof-only
 let struct_pcm
-  (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf)
-: Tot (pcm (struct_t0 tn n fields))
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+: Tot (pcm (struct_t1 fields))
 = S.prod_pcm (struct_field_pcm fields)
 
 [@@noextract_to "krml"] // proof-only
 let t_struct_set_field
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields)
-: Tot (struct_t0 tn n fields)
-= FX.on_dom (field_t fields) (fun f' -> if f = f' then v else s f')
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t) (f: field_t) (v: fields.fd_type f) (s: struct_t1 fields)
+: Tot (struct_t1 fields)
+= FX.on_dom (field_t) (fun f' -> if f = f' then v else s f')
 
-let struct_set_field = t_struct_set_field
+let struct_set_field
+  f v s
+= t_struct_set_field f v s
 
 let struct_get_field
   s field
@@ -358,13 +399,11 @@ let struct_eq
 = s1 `FX.feq` s2
 
 let struct_eq_intro
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s1 s2: struct_t0 tn n fields)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (s1 s2: struct_t1 fields)
   (prf: (
-    (f: field_t fields) ->
+    (f: field_t) ->
     Lemma
     (s1 f == s2 f)
   ))
@@ -382,35 +421,34 @@ let struct_get_field_other
 = ()
 
 let struct_fractionable
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t)
+  (s: struct_t1 fields)
 : GTot bool
-= FStar.StrongExcludedMiddle.strong_excluded_middle (forall (f: field_t fields) . (fields.fd_typedef f).fractionable (s f))
+= FStar.StrongExcludedMiddle.strong_excluded_middle (forall (f: field_t) . (fields.fd_typedef f).fractionable (s f))
 
 [@@noextract_to "krml"] // proof-only
 let struct_mk_fraction
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t)
+  (s: struct_t1 fields)
   (p: P.perm)
-: Pure (struct_t0 tn n fields)
+: Pure (struct_t1 fields)
   (requires (struct_fractionable s))
   (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> struct_fractionable s'))
-= FX.on_dom (field_t fields) (fun f -> (fields.fd_typedef f).mk_fraction (s f) p)
+= FX.on_dom field_t (fun f -> (fields.fd_typedef f).mk_fraction (s f) p)
 
 [@@noextract_to "krml"] // proof-only
 let struct_uninitialized
-  (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf)
-: Pure (struct_t0 tn n fields)
+  (#field_t: eqtype) (fields: field_description_gen_t field_t)
+: Pure (struct_t1 fields)
     (requires True)
-    (ensures (fun y -> p_refine (struct_pcm tn n fields) y))
-= let y = FX.on_dom (field_t fields) (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f) in
-  assert (exists (fd:field_t fields) . fields.fd_def fd == true /\ True);
-  y
+    (ensures (fun y -> p_refine (struct_pcm fields) y))
+= FX.on_dom field_t (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f)
 
-let struct0
-  tn n fields
+let struct1
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
 = {
-  pcm = struct_pcm tn n fields;
+  pcm = struct_pcm fields;
   fractionable = struct_fractionable;
   mk_fraction = struct_mk_fraction;
   mk_fraction_full = (fun x ->
@@ -425,14 +463,14 @@ let struct0
   );
   fractionable_one = ();
   mk_fraction_one = (fun p ->
-    struct_eq_intro (struct_mk_fraction (one (struct_pcm tn n fields)) p) (one (struct_pcm tn n fields)) (fun f ->
+    struct_eq_intro (struct_mk_fraction (one (struct_pcm fields)) p) (one (struct_pcm fields)) (fun f ->
       (fields.fd_typedef f).mk_fraction_one p
     )
   );
-  uninitialized = struct_uninitialized _ _ _;
+  uninitialized = struct_uninitialized _;
   mk_fraction_split = (fun v p1 p2 ->
     let prf
-      (f: field_t fields)
+      (f: field_t)
     : Lemma
       (composable (fields.fd_typedef f).pcm (mk_fraction (fields.fd_typedef f) (v f) p1) (mk_fraction (fields.fd_typedef f) (v f) p2))
     = (fields.fd_typedef f).mk_fraction_split (v f) p1 p2
@@ -440,17 +478,19 @@ let struct0
     Classical.forall_intro prf
   );
   mk_fraction_join = (fun v p1 p2 ->
-    struct_eq_intro (op (struct_pcm tn n fields) (struct_mk_fraction v p1) (struct_mk_fraction v p2)) (struct_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
+    struct_eq_intro (op (struct_pcm fields) (struct_mk_fraction v p1) (struct_mk_fraction v p2)) (struct_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
       (fields.fd_typedef f).mk_fraction_join (v f) p1 p2
     )
   );
   mk_fraction_eq_one = (fun v p ->
-    struct_eq_intro v (one (struct_pcm tn n fields)) (fun f ->
+    struct_eq_intro v (one (struct_pcm fields)) (fun f ->
       (fields.fd_typedef f).mk_fraction_eq_one (v f) p
     )
   );
 }
 
+let struct0 _ _ _ = struct1 _
+
 let struct_get_field_unknown
   tn n fields field
 = ()
@@ -461,13 +501,40 @@ let struct_get_field_uninitialized
 
 let _inv = TD.inv
 
-let has_struct_field
-  #_ #_ #_ #fields r field r'
+let has_struct_field_gen
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: GTot prop
 = (Some?.v r').ref == R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm fields) field)
 
+let has_struct_field
+  r field r'
+= has_struct_field_gen r field r'
+
+let has_struct_field_gen_inj
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r1 r2: ref (fields.fd_typedef field))
+: SteelGhost unit opened
+    emp
+    (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_struct_field_gen r field r1 /\
+      has_struct_field_gen r field r2
+    )
+    (fun _ _ _ -> r1 == r2)
+= TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
+
 let has_struct_field_inj
   r field r1 r2
-= TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
+= has_struct_field_gen_inj r field r1 r2
 
 #push-options "--z3rlimit 32"
 
@@ -475,7 +542,7 @@ let has_struct_field_inj
 
 let ghost_struct_field_focus
   #_ #tn #_ #n #fields #v r0 field r'0
-= let r : R.ref (struct_pcm tn n fields) = (Some?.v r0).ref in
+= let r : R.ref (struct_pcm _) = (Some?.v r0).ref in
   rewrite_slprop
     (pts_to r0 v)
     (R.pts_to r v)
@@ -492,11 +559,11 @@ let ghost_struct_field_focus
   in
   Classical.forall_intro_2 prf;
   let v' = struct_set_field field (unknown (fields.fd_typedef field)) v in
-  let vf = S.field_to_struct_f (struct_field_pcm fields) field (struct_get_field v field) in
-  assert (composable (struct_pcm tn n fields) v' vf);
-  assert (op (struct_pcm tn n fields) v' vf `FX.feq` v);
+  let vf = S.field_to_struct_f (struct_field_pcm _) field (struct_get_field v field) in
+  assert (composable (struct_pcm _) v' vf);
+  assert (op (struct_pcm _) v' vf `FX.feq` v);
   R.split r _ v' vf;
-  R.gfocus r (S.struct_field (struct_field_pcm fields) field) vf (struct_get_field v field);
+  R.gfocus r (S.struct_field (struct_field_pcm _) field) vf (struct_get_field v field);
   rewrite_slprop
     (R.pts_to r _)
     (pts_to r0 _)
@@ -512,7 +579,7 @@ let ghost_struct_field
   let r' : ref (fields.fd_typedef field) = Some ({
     dest = tok';
     typedef = fields.fd_typedef field;
-    ref = R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm fields) field);
+    ref = R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm (fd_gen_of_nonempty_fd fields)) field);
   })
   in
   let gr' = Ghost.hide r' in
@@ -534,7 +601,7 @@ let struct_field'
     (fun r' -> pts_to r0 (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
     (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
     (fun _ r' _ -> has_struct_field r0 field r')
-= let r : R.ref (struct_pcm tn n fields) = (Some?.v r0).ref in
+= let r : R.ref (struct_pcm _) = (Some?.v r0).ref in
   rewrite_slprop
     (pts_to r0 v)
     (R.pts_to r v)
@@ -551,11 +618,11 @@ let struct_field'
   in
   Classical.forall_intro_2 prf;
   let v' = Ghost.hide (struct_set_field field (unknown (fields.fd_typedef field)) v) in
-  let vf = Ghost.hide (S.field_to_struct_f (struct_field_pcm fields) field (struct_get_field v field)) in
-  assert (composable (struct_pcm tn n fields) v' vf);
-  assert (op (struct_pcm tn n fields) v' vf `FX.feq` v);
+  let vf = Ghost.hide (S.field_to_struct_f (struct_field_pcm _) field (struct_get_field v field)) in
+  assert (composable (struct_pcm _) v' vf);
+  assert (op (struct_pcm _) v' vf `FX.feq` v);
   R.split r _ v' vf;
-  let r' = R.focus r (S.struct_field (struct_field_pcm fields) field) vf (struct_get_field v field) in
+  let r' = R.focus r (S.struct_field (struct_field_pcm _) field) vf (struct_get_field v field) in
   let tok' = TD.get_token (fields.fd_type field) in
   let res : ref (fields.fd_typedef field) = Some ({
     dest = tok';
@@ -583,7 +650,7 @@ let struct_field0
 
 let unstruct_field
   #_ #tn #_ #n #fields #v r0 field #v' r'0
-= let r : R.ref (struct_pcm tn n fields) = (Some?.v r0).ref in
+= let r : R.ref (struct_pcm _) = (Some?.v r0).ref in
   rewrite_slprop
     (pts_to r0 v)
     (R.pts_to r v)
@@ -604,10 +671,10 @@ let unstruct_field
   = is_unit (fields.fd_typedef f').pcm x
   in
   Classical.forall_intro_2 prf;
-  let vf = S.field_to_struct_f (struct_field_pcm fields) field v' in
-  assert (composable (struct_pcm tn n fields) v vf);
-  assert (op (struct_pcm tn n fields) v vf `FX.feq` struct_set_field field v' v);
-  R.unfocus r' r (S.struct_field (struct_field_pcm fields) field) _;
+  let vf = S.field_to_struct_f (struct_field_pcm _) field v' in
+  assert (composable (struct_pcm _) v vf);
+  assert (op (struct_pcm _) v vf `FX.feq` struct_set_field field v' v);
+  R.unfocus r' r (S.struct_field (struct_field_pcm _) field) _;
   R.gather r v _;
   rewrite_slprop
     (R.pts_to r _)
@@ -619,11 +686,15 @@ let unstruct_field
 let fractionable_struct _ = ()
 let mk_fraction_struct _ _ _ = ()
 
-let full_struct
-  #tn #_ #n #fields s
+let full_struct_gen
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (s: struct_t1 fields)
+: Lemma
+  (full (struct1 fields) s <==> (forall field . full (fields.fd_typedef field) (s field)))
 =
   let is_unit'
-    (f': field_t fields)
+    (f': field_t)
     (x: (fields.fd_type f'))
   : Lemma
     (let p = (fields.fd_typedef f').pcm in
@@ -634,22 +705,24 @@ let full_struct
   in
   Classical.forall_intro_2 is_unit';
   let prf
-    (field: field_t fields)
+    (field: field_t)
   : Lemma
-    (requires (full (struct0 tn n fields) s))
-    (ensures (full (fields.fd_typedef field) (struct_get_field s field)))
+    (requires (full (struct1 fields) s))
+    (ensures (full (fields.fd_typedef field) (s field)))
   = let prf'
       (x: fields.fd_type field)
     : Lemma
-      (requires (composable (fields.fd_typedef field).pcm (struct_get_field s field) x))
+      (requires (composable (fields.fd_typedef field).pcm (s field) x))
       (ensures (x == one (fields.fd_typedef field).pcm))
-    = let s' = struct_set_field field x (one (struct_pcm tn n fields)) in
-      assert (composable (struct_pcm tn n fields) s s')
+    = let s' = t_struct_set_field field x (one (struct_pcm fields)) in
+      assert (composable (struct_pcm fields) s s')
     in
     Classical.forall_intro (Classical.move_requires prf')
   in
   Classical.forall_intro (Classical.move_requires prf)
 
+let full_struct s = full_struct_gen s
+
 module U = Steel.C.Model.Union
 
 let define_union0 _ _ _ = unit

From c28b7b24c49273f2459674161333d0e6a55d04ec Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 3 Nov 2022 15:56:57 -0700
Subject: [PATCH 366/513] pcm extensionality

---
 ulib/experimental/Steel.C.Model.PCM.fst  | 22 +++++++++++++++++++++
 ulib/experimental/Steel.C.Model.PCM.fsti | 25 ++++++++++++++++++++++++
 2 files changed, 47 insertions(+)

diff --git a/ulib/experimental/Steel.C.Model.PCM.fst b/ulib/experimental/Steel.C.Model.PCM.fst
index 0e46540b2a7..3fda1089cd5 100644
--- a/ulib/experimental/Steel.C.Model.PCM.fst
+++ b/ulib/experimental/Steel.C.Model.PCM.fst
@@ -186,6 +186,28 @@ let op_assoc_r
 let p_refine (#a: Type) (p: pcm0 a) (x: a) : Tot prop =
   p.refine x == true
 
+let pcm0_ext #a p1 p2 composable_eq op_eq p_refine_eq one_eq =
+  let composable_eq'
+    (xy: (a & a))
+  : Lemma
+    (p1.p.composable xy == p2.p.composable xy)
+  = let (x, y) = xy in
+    composable_eq x y
+  in
+  Classical.forall_intro composable_eq';
+  assert (p1.p.composable `feq_g` p2.p.composable);
+  assert (op_dom p1.p.composable == op_dom p2.p.composable);
+  let op_eq'
+    (xy: op_dom p1.p.composable)
+  : Lemma
+    (p1.p.op xy == p2.p.op xy)
+  = let (x, y) = xy in
+    op_eq x y
+  in
+  Classical.forall_intro op_eq';
+  Classical.forall_intro p_refine_eq;
+  pcm_eq p1 p2
+
 let pcm_of_fstar_pcm
   (#a: Type)
   (p: P.pcm a)
diff --git a/ulib/experimental/Steel.C.Model.PCM.fsti b/ulib/experimental/Steel.C.Model.PCM.fsti
index a6e22b29514..c01ec0063dc 100644
--- a/ulib/experimental/Steel.C.Model.PCM.fsti
+++ b/ulib/experimental/Steel.C.Model.PCM.fsti
@@ -46,6 +46,31 @@ val op_assoc_r
 
 val p_refine (#a: Type) (p: pcm0 a) (x: a) : Tot prop
 
+val pcm0_ext (#a: Type u#a) (p1 p2: pcm0 a)
+  (composable_eq: (
+    (x: a) ->
+    (y: a) ->
+    Lemma
+    (composable p1 x y <==> composable p2 x y)
+  ))
+  (op_eq: (
+    (x: a) ->
+    (y: a) ->
+    Lemma
+    (requires (composable p1 x y /\ composable p2 x y))
+    (ensures (
+      op p1 x y == op p2 x y
+    ))
+  ))
+  (p_refine_eq: (
+    (x: a) ->
+    Lemma
+    (p_refine p1 x <==> p_refine p2 x)
+  ))
+  (one_eq: squash (one p1 == one p2))
+: Lemma
+  (p1 == p2)
+
 val pcm_of_fstar_pcm
   (#a: Type)
   (p: P.pcm a)

From 90fa95195ee81263d558e9e8adcc0c958592016f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 8 Nov 2022 16:05:16 -0800
Subject: [PATCH 367/513] WIP arrays

---
 ulib/experimental/Steel.C.Model.Array.fst  |  38 ++
 ulib/experimental/Steel.C.Model.Struct.fst |  56 ++
 ulib/experimental/Steel.C.Types.fst        | 309 +++++++++-
 ulib/experimental/Steel.C.Types.fsti       | 677 ++++++++++++++++++++-
 4 files changed, 1057 insertions(+), 23 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index 19721fe878d..aa8e390c6ca 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -168,6 +168,16 @@ let array_pcm_carrier_of_seq
 : Tot (array_pcm_carrier t n)
 = on_dom (array_domain n) (fun i -> Seq.index s (size_v i) <: array_range t n i)
 
+let array_pcm_carrier_of_seq_eq
+  (#t: Type)
+  (n: Ghost.erased size_t)
+  (s: Seq.lseq t (size_v n))
+  (i: array_domain n)
+: Lemma
+  (array_pcm_carrier_of_seq n s i == Seq.index s (SZ.v i))
+  [SMTPat (array_pcm_carrier_of_seq n s i)]
+= ()
+
 let int_to_size_t = SZ.uint_to_t
 
 let seq_of_array_pcm_carrier
@@ -909,3 +919,31 @@ let array_of_ref
   ref_of_array_of_ref_base r;
   intro_pts_to1 a _ _ _;
   A.return a
+
+#push-options "--split_queries --z3rlimit 32 --query_stats"
+
+#restart-solver
+let unarray_of_ref
+  (#opened: _)
+  (#t: Type)
+  (#p: pcm t)
+  (#v: Seq.seq t)
+  (r: ref p)
+  (a: array p)
+: A.SteelGhost (squash (Seq.length v == 1)) opened
+    (pts_to a v)
+    (fun _ -> R.pts_to r (Seq.index v 0))
+    (fun _ -> a == g_array_of_ref r)
+    (fun _ _ _ -> True)
+= assert_norm (size_v 0sz == 0);
+  assert_norm (size_v 1sz == 1);
+  elim_pts_to _ _;
+  ref_of_array_of_ref_base r;
+  R.unfocus (ref_of_array a) r (array_of_ref_conn p) _;
+  let x = (array_pcm_carrier_of_seq a.len v) in
+  assert_norm ((array_of_ref_conn p).conn_small_to_large.morph x == x 0sz);
+  array_pcm_carrier_of_seq_eq a.len v 0sz;
+  assert (x 0sz == Seq.index v 0);
+  A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _)
+
+#pop-options
diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index ffabc695c5f..2255e0d1253 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -95,6 +95,24 @@ let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
   assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
   prod_pcm' p
 
+let prod_pcm_ext
+  (#a: Type)
+  (#b: (a -> Type))
+  (p1 p2: ((k: a) -> pcm (b k)))
+  (p_eq: (
+    (k: a) ->
+    Lemma
+    (p1 k == p2 k)
+  ))
+: Lemma
+  (prod_pcm p1 == prod_pcm p2)
+= Classical.forall_intro p_eq;
+  pcm0_ext (prod_pcm p1) (prod_pcm p2)
+    (fun x y -> ())
+    (fun x y -> assert (op (prod_pcm p1) x y `feq` op (prod_pcm p2) x y))
+    (fun _ -> ())
+    (assert (one (prod_pcm p1) `feq` one (prod_pcm p2)))
+
 let prod_pcm_composable_intro0
   (p:(k:'a -> pcm ('b k)))
   (x y: restricted_t 'a 'b)
@@ -238,6 +256,44 @@ let struct_field
     ()
     (struct_field_lift_fpu p k)
 
+#push-options "--split_queries"
+
+#restart-solver
+let struct_field_ext
+  (#a: eqtype)
+  (#b: a -> Type u#b)
+  (p1 p2:(k: a -> pcm (b k)))
+  (p_eq: (
+    (k: a) ->
+    Lemma
+    (p1 k == p2 k)
+  ))
+  (k: a)
+: Lemma
+  (prod_pcm p1 == prod_pcm p2 /\
+    p1 k == p2 k /\
+    struct_field p1 k === struct_field p2 k
+  )
+= prod_pcm_ext p1 p2 p_eq;
+  p_eq k;
+  Classical.forall_intro p_eq;
+  let l = struct_field p1 k in
+  let m : connection (prod_pcm p1) (p1 k) = coerce_eq () (struct_field p2 k) in
+  assert (forall x . field_to_struct_f p1 k x `feq` field_to_struct_f p2 k x);
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      struct_field_lift_fpu_prf p1 k x y f v;
+      struct_field_lift_fpu_prf p2 k x y f v;
+      assert (forall k' . struct_field_lift_fpu' p1 k x y f v k' == struct_field_lift_fpu' p2 k x y f v k');
+      assert (struct_field_lift_fpu' p1 k x y f v == struct_field_lift_fpu' p2 k x y f v);
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
 let is_substruct
   (#a: eqtype)
   (#b: a -> Type)
diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 8932c2a3529..5bb9279cde3 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -503,7 +503,7 @@ let _inv = TD.inv
 
 let has_struct_field_gen
   (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
+  (fields: field_description_gen_t field_t)
   (r: ref (struct1 fields))
   (field: field_t)
   (r': ref (fields.fd_typedef field))
@@ -512,12 +512,12 @@ let has_struct_field_gen
 
 let has_struct_field
   r field r'
-= has_struct_field_gen r field r'
+= has_struct_field_gen _ r field r'
 
 let has_struct_field_gen_inj
   (#opened: _)
   (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
+  (fields: field_description_gen_t field_t)
   (r: ref (struct1 fields))
   (field: field_t)
   (r1 r2: ref (fields.fd_typedef field))
@@ -526,15 +526,15 @@ let has_struct_field_gen_inj
     (fun _ -> emp)
     (fun _ ->
       Ghost.reveal (mem_inv opened _inv) == false /\
-      has_struct_field_gen r field r1 /\
-      has_struct_field_gen r field r2
+      has_struct_field_gen fields r field r1 /\
+      has_struct_field_gen fields r field r2
     )
     (fun _ _ _ -> r1 == r2)
 = TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
 
 let has_struct_field_inj
   r field r1 r2
-= has_struct_field_gen_inj r field r1 r2
+= has_struct_field_gen_inj _ r field r1 r2
 
 #push-options "--z3rlimit 32"
 
@@ -1090,3 +1090,300 @@ let union_switch_field0
   return res
 
 #pop-options
+
+/// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
+
+module A = Steel.C.Model.Array
+
+let base_array_t t _ n = A.array_pcm_carrier t n
+
+[@@noextract_to "krml"] // proof-only
+let base_array_fd
+  (#t: Type)
+  (td: typedef t)
+  (n: array_size_t)
+: Tot (field_description_gen_t (base_array_index_t n))
+= {
+    fd_nonempty = (let _ : base_array_index_t n = 0sz in ());
+    fd_type = A.array_range t n;
+    fd_typedef = (fun _ -> td);
+  }
+
+let base_array0 tn td n = struct1 (base_array_fd td n)
+
+let base_array_index a i = a i
+
+let base_array_eq #_ #_ #n a1 a2 =
+  assert (a1 `FX.feq` a2 <==> (forall (i: base_array_index_t n) . a1 i == a2 i));
+  a1 `FX.feq` a2
+
+let mk_base_array _ n v = A.array_pcm_carrier_of_seq n v
+
+let mk_base_array_index _ _ _ _ = ()
+
+let base_array_fractionable a td = ()
+
+let base_array_mk_fraction a td p i = ()
+
+let base_array_index_unknown tn n td i = ()
+
+let base_array_index_uninitialized tn n td i = ()
+
+let base_array_index_full td x = ()
+
+let has_base_array_cell #_ #_ #n #td r i r' =
+  SZ.v i < SZ.v n /\
+  has_struct_field_gen (base_array_fd td n) r i r'
+
+let has_base_array_cell_inj
+  #_ #_ #_ #n #td r i r1 r2
+= has_struct_field_gen_inj (base_array_fd td n) r i r1 r2
+
+/// Array pointers (with decay)
+
+noeq
+type array_ref #t td = {
+  ar_base_size_token: TD.token;
+  ar_base_size: Ghost.erased array_size_t;
+  ar_base: ref (base_array0 #t (TD.type_of_token ar_base_size_token) td ar_base_size);
+  ar_offset: base_array_index_t ar_base_size;
+}
+let array_ref_base_size_type ar = TD.type_of_token ar.ar_base_size_token
+let array_ref_base_size ar = ar.ar_base_size
+let array_ref_base ar = ar.ar_base
+let array_ref_offset ar = ar.ar_offset
+let array_ref_base_offset_inj a1 a2 =
+  TD.type_of_token_inj a1.ar_base_size_token a2.ar_base_size_token
+
+#push-options "--z3rlimit 16"
+
+#restart-solver
+let base_array_pcm_eq
+  (#t: Type)
+  (td: typedef t)
+  (n: array_size_t)
+  (tn: Type0)
+: Lemma
+  (A.array_pcm td.pcm n == (base_array0 tn td n).pcm)
+  [SMTPat (base_array0 tn td n).pcm]
+= pcm0_ext (A.array_pcm td.pcm n) (base_array0 tn td n).pcm
+    (fun _ _ -> ())
+    (fun x1 x2 ->
+      assert (op (A.array_pcm td.pcm n) x1 x2 `FX.feq` op (base_array0 tn td n).pcm x1 x2)
+    )
+    (fun _ -> ())
+    ()
+
+#pop-options
+
+[@@noextract_to "krml"] // proof-only
+let coerce (#t1 t2: Type) (x1: t1) : Pure t2
+  (requires (t1 == t2))
+  (ensures (fun x2 ->
+    t1 == t2 /\
+    x1 == x2
+  ))
+= x1
+
+[@@noextract_to "krml"] // proof-only
+let model_array_of_array
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+: Tot (A.array td.pcm)
+= let (| al, len |) = a in
+  {
+    base_len = Ghost.hide (Ghost.reveal al.ar_base_size);
+    base = coerce _ ((Some?.v al.ar_base).ref);
+    offset = al.ar_offset;
+    len = len;
+    prf = ();
+  }
+
+let array_pts_to' r v =
+  A.pts_to (model_array_of_array r) v
+
+let array_pts_to_length r v =
+  rewrite_slprop
+    (array_pts_to _ _)
+    (A.pts_to (model_array_of_array r) v)
+    (fun _ -> ());
+  A.pts_to_length _ _;
+  rewrite_slprop
+    (A.pts_to _ _)
+    (array_pts_to _ _)
+    (fun _ -> ())
+
+#push-options "--z3rlimit 16"
+
+let ghost_array_of_base_focus
+  #_ #tn #_ #n #td #v r a
+= let mr : R.ref (A.array_pcm td.pcm n) = coerce _ (Some?.v r).ref in
+  let m : A.array td.pcm = {
+    base_len = Ghost.hide n;
+    base = mr;
+    offset = 0sz;
+    len = n;
+    prf = ();
+  }
+  in
+  rewrite_slprop (pts_to r v) (R.pts_to m.base v) (fun _ -> ());
+  assert (seq_of_base_array v `Seq.equal` A.seq_of_array_pcm_carrier v);
+  A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
+  A.pts_to_intro_from_base m v (seq_of_base_array v);
+  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ())
+
+#pop-options
+
+let ghost_array_of_base
+  #_ #tn #_ #n #td #v r
+= let tok = TD.get_token tn in
+  let ar : array_ref td = {
+    ar_base_size_token = tok;
+    ar_base_size = Ghost.hide (n <: SZ.t);
+    ar_base = r;
+    ar_offset = 0sz;
+  }
+  in
+  let res : (a: Ghost.erased (array td)  { has_array_of_base r a }) = Ghost.hide (| ar, Ghost.hide n |) in
+  ghost_array_of_base_focus r res;
+  res
+
+let array_ref_of_base
+  #_ #tn #_ #n #td #v r
+= let tok = TD.get_token tn in
+  let ar : array_ref td = {
+    ar_base_size_token = tok;
+    ar_base_size = Ghost.hide (n <: SZ.t);
+    ar_base = r;
+    ar_offset = 0sz;
+  }
+  in
+  ghost_array_of_base_focus r (| ar, Ghost.hide n |);
+  return ar
+
+#push-options "--z3rlimit 16 --split_queries"
+
+#restart-solver
+let unarray_of_base
+  #t #tn #_ #n #td #v r a
+=
+  let m = model_array_of_array a in
+  rewrite_slprop (array_pts_to _ _) (A.pts_to m v) (fun _ -> ());
+  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = A.pts_to_elim_to_base m v in
+  let y' : Ghost.erased (base_array_t t tn n) = Ghost.hide (Ghost.reveal y) in
+  rewrite_slprop (R.pts_to m.base y) (pts_to r y') (fun _ -> ());
+  y'
+
+#pop-options
+
+let has_array_of_ref
+  r a
+= TD.type_of_token (dfst a).ar_base_size_token == unit /\
+  model_array_of_array a == A.g_array_of_ref (coerce _ (Some?.v r).ref)
+
+let has_array_of_ref_inj
+  r a1 a2
+= TD.type_of_token_inj (dfst a1).ar_base_size_token (dfst a2).ar_base_size_token;
+  TD.type_of_token_inj (Some?.v (dfst a1).ar_base).dest (Some?.v (dfst a2).ar_base).dest
+
+let ghost_array_of_ref_focus
+  #t #_ #td #v r a
+= let mr : R.ref td.pcm = (Some?.v r).ref in
+  rewrite_slprop (pts_to _ _) (R.pts_to mr v) (fun _ -> ());
+  let ma = A.ghost_array_of_ref mr in
+  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ())
+
+let ghost_array_of_ref
+  #t #_ #td #v r
+= let mr : R.ref td.pcm = (Some?.v r).ref in
+  let ma = A.g_array_of_ref mr in
+  let tok_unit = TD.get_token unit in
+  let tok_array = TD.get_token (A.array_pcm_carrier t 1sz) in
+  let ar = {
+    ar_base_size_token = tok_unit;
+    ar_base_size = 1sz;
+    ar_base = Some ({
+      dest = tok_array;
+      typedef = base_array0 unit td 1sz;
+      ref = coerce _ ma.base;
+    });
+    ar_offset = 0sz;
+  }
+  in
+  let res: (a: Ghost.erased (array td) { has_array_of_ref r a }) = Ghost.hide (| ar, Ghost.hide 1sz |) in
+  ghost_array_of_ref_focus r res;
+  res
+
+let array_ref_of_ref
+  #t #_ #td #v r
+= let mr : R.ref td.pcm = (Some?.v r).ref in
+  rewrite_slprop (pts_to _ _) (R.pts_to mr v) (fun _ -> ());
+  let ma = A.array_of_ref mr in
+  let tok_unit = TD.get_token unit in
+  let tok_array = TD.get_token (A.array_pcm_carrier t 1sz) in
+  let res = {
+    ar_base_size_token = tok_unit;
+    ar_base_size = 1sz;
+    ar_base = Some ({
+      dest = tok_array;
+      typedef = base_array0 unit td 1sz;
+      ref = coerce _ ma.base;
+    });
+    ar_offset = 0sz;
+  }
+  in
+  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ());
+  return res
+
+
+
+unfold
+let has_base_array_cell0
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: Ghost prop
+    (requires True)
+    (fun p -> p ==> has_base_array_cell r i r')
+= SZ.v i < SZ.v n /\
+  has_struct_field_gen (base_array_fd td n) r i r'
+
+#restart-solver
+let struct_field_eq_cell
+  (#t: Type)
+  (td: typedef t)
+  (n: array_size_t)
+  (k: base_array_index_t n)
+: Lemma
+  (Steel.C.Model.Struct.struct_field (struct_field_pcm (base_array_fd td n)) k == A.cell td.pcm n k)
+= assert_norm (A.array_domain n == base_array_index_t n);
+  Steel.C.Model.Struct.struct_field_ext #(A.array_domain n) #(A.array_range t n) (struct_field_pcm (base_array_fd td n)) (A.array_elements_pcm td.pcm n) (fun _ -> ()) k
+
+#push-options "--split_queries --z3rlimit 16"
+
+#restart-solver
+let has_array_cell_array_of_ref
+  #_ #td r a
+= assert_norm (SZ.v 0sz == 0);
+  assert_norm (SZ.v 1sz == 1);
+  A.ref_of_array_of_ref (Some?.v r).ref;
+  A.ref_of_array_of_ref_base (Some?.v r).ref;
+  assert (Ghost.reveal (dsnd a) == 1sz);
+  assert ((dfst a).ar_offset == 0sz);
+  struct_field_eq_cell td 1sz 0sz;
+  assert (has_base_array_cell0 (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` 0sz) r)
+
+#pop-options
+
+(*
+let ghost_array_cell
+  #_ #_ #_ #s a i
+= let ma = model_array_of_array a in
+*)
+
+let mk_fraction_seq_join = magic ()
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index b4dd5b329dc..c312c0e11bc 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -1,7 +1,6 @@
 module Steel.C.Types
 open Steel.C.Typenat
 open Steel.C.Typestring
-// open Steel.C.StdInt // for size_t
 include Steel.Effect.Common
 include Steel.Effect
 include Steel.Effect.Atomic
@@ -176,7 +175,7 @@ val free
 
 val mk_fraction_split_gen
   (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p p1 p2: P.perm) : SteelGhost unit opened
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm) : SteelGhost unit opened
   (pts_to r (mk_fraction td v p))
   (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
   (fun _ -> p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
@@ -311,7 +310,7 @@ let nonempty_field_description_t (t: Type0) =
   (fd: field_description_t t { fd.fd_empty == false })
 
 [@@noextract_to "krml"] // proof-only
-let field_t (#t: Type0) (fd: field_description_t t) = (s: string { fd.fd_def s })
+let field_t (#t: Type0) (fd: field_description_t t) : Tot eqtype = (s: string { fd.fd_def s })
 
 inline_for_extraction [@@noextract_to "krml"]
 let field_description_nil : field_description_t field_t_nil = {
@@ -939,23 +938,667 @@ let union_switch_field
     field
     (fields.fd_typedef field)
 
-(*
+module SZ = FStar.SizeT
+
 // To be extracted as: t[tn]
-val base_array_t (t: Type0) (tn: Type0 (* using Typenat *)) (n: size_t) : Type0
-noextract
-val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: size_t) : Tot (typedef (base_array_t t tn n))
-let base_array (#t: Type0) (td: typedef t) (n: size_t) (#tn: Type0) (# [ solve_nat_t_of_nat () ] prf: squash (norm norm_typenat (nat_t_of_nat (size_v n) == tn))) : Tot (typedef (base_array_t t tn n)) =
-  base_array0 #t tn td n
-val mk_base_array (#t: Type) (tn: Type0) (n: size_t) (v: Seq.seq t) : Ghost (base_array_t t tn n)
+// Per the C standard, base array types must be of nonzero size
+inline_for_extraction [@@noextract_to "krml"]
+let array_size_t = (n: SZ.t { SZ.v n > 0 })
+val base_array_t (t: Type0) (tn: Type0 (* using Typenat (or Typestring for `#define`d constants) *)) (n: array_size_t) : Type0
+inline_for_extraction [@@noextract_to "krml"]
+let base_array_index_t (n: array_size_t) : Tot eqtype = (i: SZ.t { SZ.v i < SZ.v n })
+[@@noextract_to "krml"]
+val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: array_size_t) : Tot (typedef (base_array_t t tn n))
+val base_array_index (#t: Type0) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (i: base_array_index_t n) : GTot t
+val base_array_eq (#t: Type0) (#tn: Type0) (#n: array_size_t) (a1 a2: base_array_t t tn n) : Ghost prop
+  (requires True)
+  (ensures (fun y ->
+    (y <==> (a1 == a2)) /\
+    (y <==> (forall (i: base_array_index_t n) . base_array_index a1 i == base_array_index a2 i))
+  ))
+val mk_base_array (#t: Type) (tn: Type0) (n: array_size_t) (v: Seq.seq t) : Ghost (base_array_t t tn n)
   (requires (
-    Seq.length v == size_v n
+    Seq.length v == SZ.v n
   ))
   (ensures (fun y -> True))
-val mk_base_array_fractionable (#t: Type) (tn: Type0) (td: typedef t) (n: size_t) (v: Seq.seq t) : Lemma
-  (requires (Seq.length v == size_v n))
+val mk_base_array_index (#t: Type) (tn: Type) (n: array_size_t) (v: Seq.seq t) (i: base_array_index_t n) : Lemma
+  (requires (Seq.length v == SZ.v n))
   (ensures (
-    Seq.length v == size_v n /\  
-    fractionable (base_array0 tn td n) (mk_base_array tn n v) <==> (forall (i: nat) . i < Seq.length v ==> fractionable td (Seq.index v i))
+    Seq.length v == SZ.v n /\
+    base_array_index (mk_base_array tn n v) i == Seq.index v (SZ.v i)
   ))
-// and that's all. users are not supposed to manipulate an array directly from its base reference. they should use an array instead.
-*)
+  [SMTPat (base_array_index (mk_base_array tn n v) i)]
+
+let mk_base_array_inj  (#t: Type) (tn: Type0) (n: array_size_t) (v1 v2: Seq.seq t) : Lemma
+  (requires (
+    Seq.length v1 == SZ.v n /\
+    Seq.length v2 == SZ.v n /\
+    mk_base_array tn n v1 == mk_base_array tn n v2
+  ))
+  (ensures (v1 == v2))
+  [SMTPat (mk_base_array tn n v1); SMTPat (mk_base_array tn n v2)]
+= assert (forall (i: nat) . i < SZ.v n ==> base_array_index (mk_base_array tn n v1) (SZ.uint_to_t i) == base_array_index (mk_base_array tn n v2) (SZ.uint_to_t i));
+  assert (v1 `Seq.equal` v2)
+val base_array_fractionable (#t: Type) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (td: typedef t) : Lemma
+  (
+    fractionable (base_array0 tn td n) a <==>
+      (forall (i: base_array_index_t n) . fractionable td (base_array_index a i))
+  )
+  [SMTPat (fractionable (base_array0 tn td n) a)]
+val base_array_mk_fraction   (#t: Type) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (td: typedef t) (p: P.perm) (i: base_array_index_t n) : Lemma
+  (requires (
+    fractionable (base_array0 tn td n) a
+  ))
+  (ensures (
+    fractionable (base_array0 tn td n) a /\
+    base_array_index (mk_fraction (base_array0 tn td n) a p) i == mk_fraction td (base_array_index a i) p
+  ))
+  [SMTPat (base_array_index (mk_fraction (base_array0 tn td n) a p) i)]
+
+val base_array_index_unknown (#t: Type) (tn: Type0) (n: array_size_t) (td: typedef t) (i: base_array_index_t n) : Lemma
+  (base_array_index (unknown (base_array0 tn td n)) i == unknown td)
+  [SMTPat (base_array_index (unknown (base_array0 tn td n)) i)]
+
+val base_array_index_uninitialized (#t: Type) (tn: Type0) (n: array_size_t) (td: typedef t) (i: base_array_index_t n) : Lemma
+  (base_array_index (uninitialized (base_array0 tn td n)) i == uninitialized td)
+  [SMTPat (base_array_index (uninitialized (base_array0 tn td n)) i)]
+
+val base_array_index_full (#t: Type) (#tn: Type0) (#n: array_size_t) (td: typedef t) (x: base_array_t t tn n) : Lemma
+  (full (base_array0 tn td n) x <==> (forall (i: base_array_index_t n) . full td (base_array_index x i)))
+  [SMTPat (full (base_array0 tn td n) x)]
+
+val has_base_array_cell
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: GTot prop
+
+val has_base_array_cell_inj
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: SteelGhost unit opened
+    emp
+    (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_base_array_cell r i r1 /\
+      has_base_array_cell r i r2
+    )
+    (fun _ _ _ -> r1 == r2)
+
+// contrary to array fields, one is not supposed to take an array cell directly from a base array. one should use arrays instead
+
+// To be extracted to: t*  (array type decays to pointer type)
+
+// We still want to prove that cutting off some cell range on the
+// right-hand end of an array won't change the C pointer to which an
+// array extracts to. This is why we separately introduce `array_ref`
+// to represent the "base+offset" pointer, and `array` which holds the
+// ghost length of an array.
+
+[@@noextract_to "krml"] // primitive
+val array_ref (#t: Type) (td: typedef t) : Tot Type0
+val array_ref_base_size_type (#t: Type) (#td: typedef t) (a: array_ref td) : GTot Type0
+val array_ref_base_size (#t: Type) (#td: typedef t) (a: array_ref td) : GTot array_size_t
+val array_ref_base (#t: Type) (#td: typedef t) (a: array_ref td) : GTot (ref (base_array0 (array_ref_base_size_type a) td (array_ref_base_size a)))
+val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ref td) : Ghost SZ.t
+  (requires True)
+  (ensures (fun y -> SZ.v y < SZ.v (array_ref_base_size a)))
+val array_ref_base_offset_inj (#opened: _) (#t: Type) (#td: typedef t) (a1 a2: array_ref td) : SteelGhost unit opened
+  emp (fun _ -> emp)
+  (requires (fun _ ->
+    Ghost.reveal (mem_inv opened _inv) == false /\
+    array_ref_base_size_type a1 == array_ref_base_size_type a2 /\
+    array_ref_base_size a1 == array_ref_base_size a2 /\
+    array_ref_base a1 == array_ref_base a2 /\
+    array_ref_offset a1 == array_ref_offset a2
+  ))
+  (ensures (fun _ _ _ -> a1 == a2))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
+  (len: Ghost.erased SZ.t { SZ.v (array_ref_offset r) + SZ.v len <= SZ.v (array_ref_base_size r) })
+
+inline_for_extraction [@@noextract_to "krml"]
+let array (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ref td & array_len_t r)
+
+val array_pts_to'
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: Tot vprop
+
+[@@__steel_reduce__]
+let array_pts_to
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: Tot vprop
+= VUnit ({
+    hp = hp_of (array_pts_to' r v);
+    t = _;
+    sel = trivial_selector _;
+  })
+
+val array_pts_to_length
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: SteelGhost unit opened
+    (array_pts_to r v)
+    (fun _ -> array_pts_to r v)
+    (fun _ -> True)
+    (fun _ _ _ -> Seq.length v == SZ.v (dsnd r))
+
+let has_array_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (a: array td)
+: GTot prop
+= let (| al, len |) = a in
+  array_ref_base_size_type al == tn /\
+  array_ref_base_size al == n /\
+  array_ref_base al == r /\
+  array_ref_offset al == 0sz /\
+  Ghost.reveal len == n
+
+let has_array_of_base_inj
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (a1 a2: array td)
+: SteelGhost unit opened
+    emp (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_array_of_base r a1 /\
+      has_array_of_base r a2
+    )
+    (fun _ _ _ -> a1 == a2)
+= array_ref_base_offset_inj (dfst a1) (dfst a2)
+
+let seq_of_base_array
+  (#t: Type)
+  (#tn: Type)
+  (#n: array_size_t)
+  (v: base_array_t t tn n)
+: GTot (Seq.lseq t (SZ.v n))
+= Seq.init_ghost (SZ.v n) (fun i -> base_array_index v (SZ.uint_to_t i))
+
+val ghost_array_of_base_focus
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+  (a: array td)
+: SteelGhost unit opened
+    (pts_to r v)
+    (fun _ -> array_pts_to a (seq_of_base_array v))
+    (fun _ -> has_array_of_base r a)
+    (fun _ _ _ -> True)
+
+val ghost_array_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: SteelGhost (a: Ghost.erased (array td) { has_array_of_base r a }) opened
+    (pts_to r v)
+    (fun a -> array_pts_to a (seq_of_base_array v))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ _ _ -> True)
+
+// to be extracted to just r
+[@@noextract_to "krml"] // primitive
+val array_ref_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: SteelAtomicBase (a: array_ref td { array_ref_base_size a == n /\ array_ref_offset a == 0sz /\ has_array_of_base r (| a, Ghost.hide n |) }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to (| a, Ghost.hide (n <: SZ.t) |) (seq_of_base_array v))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ _ _ -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: SteelAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to a (seq_of_base_array v))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ _ _ -> True)
+= let al = array_ref_of_base r in
+  let a = (| al, Ghost.hide (n <: SZ.t) |) in
+  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  return a
+
+val unarray_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (Seq.seq t))
+  (r: ref (base_array0 tn td n))
+  (a: array td)
+: SteelGhost (Ghost.erased (base_array_t t tn n)) opened
+    (array_pts_to a v)
+    (fun v' -> pts_to r v')
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_array_of_base r a
+    )
+    (fun _ v' _ -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
+
+val has_array_of_ref
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a: array td)
+: Ghost prop
+  (requires True)
+  (ensures (fun p ->
+    let (| al, len |) = a in
+    p ==> (
+      array_ref_base_size al == 1sz /\
+      array_ref_offset al == 0sz /\
+      Ghost.reveal len == 1sz
+  )))
+
+val has_array_of_ref_inj
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a1 a2: array td)
+: SteelGhost unit opened
+    emp (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_array_of_ref r a1 /\
+      has_array_of_ref r a2
+    )
+    (fun _ _ _ -> a1 == a2)
+
+val ghost_array_of_ref_focus
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+  (a: array td)
+: SteelGhost unit opened
+    (pts_to r v)
+    (fun _ -> array_pts_to a (Seq.create 1 (Ghost.reveal v)))
+    (fun _ ->
+      has_array_of_ref r a
+    )
+    (fun _ _ _ -> True)
+
+val ghost_array_of_ref
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: SteelGhost (a: Ghost.erased (array td) { has_array_of_ref r a }) opened
+    (pts_to r v)
+    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ _ _ -> True)
+
+// to be extracted to just r
+[@@noextract_to "krml"] // primitive
+val array_ref_of_ref
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: SteelAtomicBase (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz /\ has_array_of_ref r (| a, Ghost.hide 1sz |) }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ _ _ -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_of_ref
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: SteelAtomicBase (a: array td { has_array_of_ref r a }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)))
+    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ _ _ -> True)
+= let al = array_ref_of_ref r in
+  let a = (| al, Ghost.hide 1sz |) in
+  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  return a
+
+val unarray_of_ref
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (r: ref td)
+  (a: array td)
+: SteelGhost (squash (Seq.length s == 1)) opened
+    (array_pts_to a s)
+    (fun _ -> pts_to r (Seq.index s 0))
+    (fun _ ->
+      has_array_of_ref r a
+    )
+    (fun _ _ _ -> True)
+
+let has_array_cell
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: GTot prop
+= SZ.v i < SZ.v (dsnd a) /\
+  has_base_array_cell (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r
+
+let has_array_cell_inj
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r1 r2: ref td)
+: SteelGhost unit opened
+    emp
+    (fun _ -> emp)
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      has_array_cell a i r1 /\
+      has_array_cell a i r2
+    )
+    (fun _ _ _ -> r1 == r2)
+= has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
+
+val has_array_cell_array_of_ref
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a: array td)
+: Lemma
+    (requires has_array_of_ref r a)
+    (ensures has_array_cell a 0sz r)
+
+val ghost_array_cell_focus
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: SteelGhost (squash (has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s)
+    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun _ ->
+      has_array_cell a i r
+    )
+    (fun _ _ _ -> True)
+
+val ghost_array_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: SteelGhost (r: Ghost.erased (ref td) { has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a) }) opened
+    (array_pts_to a s)
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
+    )
+    (fun _ _ _ -> True)
+
+[@@noextract_to "krml"] // primitive
+val array_ref_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array_ref td)
+  (len: array_len_t a)
+  (i: SZ.t)
+: SteelAtomicBase (r: ref td { has_array_cell (| a, len |) i r /\ Seq.length s == SZ.v len }) false opened Unobservable
+    (array_pts_to (| a, len |) s)
+    (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v len)
+    )
+    (fun _ _ _ -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: SteelAtomicBase (r: ref td { has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a) }) false opened Unobservable
+    (array_pts_to a s)
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun _ ->
+      Ghost.reveal (mem_inv opened _inv) == false /\
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
+    )
+    (fun _ _ _ -> True)
+= let (| al, len |) = a in
+  change_equal_slprop (array_pts_to _ _) (array_pts_to _ s);
+  let r = array_ref_cell al len i in
+  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  return r
+
+val unarray_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (#v: Ghost.erased t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: SteelGhost (squash (has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s `star` pts_to r v)
+    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) v))
+    (fun _ ->
+      has_array_cell a i r /\
+      (SZ.v i < Seq.length s ==> Seq.index s (SZ.v i) == unknown td)
+    )
+    (fun _ _ _ -> True)
+
+val array_ref_shift
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_ref td)
+  (i: SZ.t)
+: Ghost (array_ref td)
+    (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
+    (ensures (fun y -> 
+      array_ref_base_size_type y == array_ref_base_size_type a /\
+      array_ref_base_size y == array_ref_base_size a /\
+      array_ref_base y == array_ref_base a /\
+      array_ref_offset y == array_ref_offset a `SZ.add` i
+    ))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_split_l
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+: Pure (array td)
+   (requires (SZ.v i <= SZ.v (dsnd a)))
+   (ensures (fun _ -> True))
+= let (| al, _ |) = a in
+  (| al, Ghost.hide i |)
+
+let array_split_r
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+: Ghost (array td)
+   (requires (SZ.v i <= SZ.v (dsnd a)))
+   (ensures (fun _ -> True))
+= let (| al, len |) = a in
+  (| array_ref_shift al i, Ghost.hide (len `SZ.sub` i) |)
+
+val ghost_array_split
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: SteelGhost (squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s)
+    (fun _ -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
+      array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)))
+    (fun _ -> SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
+    (fun _ _ _ -> True)
+
+[@@noextract_to "krml"] // primitive
+val array_ref_split
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (al: array_ref td)
+  (len: array_len_t al)
+  (i: SZ.t)
+: SteelAtomicBase (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len}) false opened Unobservable
+    (array_pts_to (| al, len |) s)
+    (fun _ -> array_pts_to (array_split_l (| al, len |) i) (Seq.slice s 0 (SZ.v i)) `star`
+      array_pts_to (array_split_r (| al, len |) i) (Seq.slice s (SZ.v i) (Seq.length s)))
+    (fun _ -> SZ.v i <= SZ.v len \/ SZ.v i <= Seq.length s)
+    (fun _ ar _ -> ar == dfst (array_split_r (| al, len |) i))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_split
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: SteelAtomicBase (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)}) false opened Unobservable
+    (array_pts_to a s)
+    (fun a' -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
+      array_pts_to a' (Seq.slice s (SZ.v i) (Seq.length s)))
+    (fun _ -> SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
+    (fun _ a' _ -> a' == array_split_r a i)
+= let (| al, len |) = a in
+  change_equal_slprop (array_pts_to _ _) (array_pts_to _ s);
+  let ar = array_ref_split al len i in
+  let a' = (| ar, Ghost.hide (len `SZ.sub` i) |) in
+  change_equal_slprop (array_pts_to (array_split_l _ _) _) (array_pts_to (array_split_l a _) _);
+  change_equal_slprop (array_pts_to (array_split_r _ _) _) (array_pts_to a' _);
+  return a'
+
+val array_join
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#sl #sr: Ghost.erased (Seq.seq t))
+  (a al ar: array td)
+  (i: SZ.t)
+: SteelGhost unit opened
+    (array_pts_to al sl `star` array_pts_to ar sr)
+    (fun _ -> array_pts_to a (sl `Seq.append` sr))
+    (fun _ ->
+      SZ.v i <= SZ.v (dsnd a) /\
+      al == array_split_l a i /\
+      ar == array_split_r a i
+    )
+    (fun _ _ _ -> True)
+
+let fractionable_seq (#t: Type) (td: typedef t) (s: Seq.seq t) : GTot prop =
+  forall (i: nat). i < Seq.length s ==> fractionable td (Seq.index s i)
+
+let mk_fraction_seq (#t: Type) (td: typedef t) (s: Seq.seq t) (p: P.perm) : Ghost (Seq.seq t)
+  (requires (fractionable_seq td s))
+  (ensures (fun _ -> True))
+= Seq.init_ghost (Seq.length s) (fun i -> mk_fraction td (Seq.index s i) p)
+
+let mk_fraction_seq_full (#t: Type0) (td: typedef t) (x: Seq.seq t) : Lemma
+  (requires (fractionable_seq td x))
+  (ensures (mk_fraction_seq td x P.full_perm == x))
+  [SMTPat (mk_fraction_seq td x P.full_perm)]
+= assert (mk_fraction_seq td x P.full_perm `Seq.equal` x)
+
+val mk_fraction_seq_split_gen
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p p1 p2: P.perm) : SteelGhost unit opened
+  (array_pts_to r (mk_fraction_seq td v p))
+  (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
+  (fun _ -> p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ _ _ -> True)
+
+let mk_fraction_seq_split
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: array td) (v: Ghost.erased (Seq.seq t) { fractionable_seq td v }) (p1 p2: P.perm) : SteelGhost unit opened
+  (array_pts_to r v)
+  (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
+  (fun _ -> P.full_perm == p1 `P.sum_perm` p2)
+  (fun _ _ _ -> True)
+= mk_fraction_seq_full td v;
+  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  mk_fraction_seq_split_gen r v P.full_perm p1 p2
+
+val mk_fraction_seq_join
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p1 p2: P.perm)
+: SteelGhostT unit opened
+  (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
+  (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))

From f3726ec3482c355fb13bfb23929aeef82ec7bc86 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 10 Nov 2022 15:57:45 -0800
Subject: [PATCH 368/513] Revert "snap"

This reverts commit 8e242baaeb9fdc88528018e946d2e400e0d16900.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 967 +---------------------
 1 file changed, 15 insertions(+), 952 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index c8a2bf1dc9a..c98d5cc93fd 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -146,7 +143,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -213,14 +209,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -440,10 +428,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -595,10 +579,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -694,102 +674,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -941,8 +825,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -952,9 +835,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -972,63 +854,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1041,8 +866,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1079,21 +903,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1153,14 +974,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1173,36 +993,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1810,66 +1613,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1963,48 +1706,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2730,505 +2436,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::uu___7::e1::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Types.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3601,72 +2808,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3679,85 +2820,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From a38ae8e5a7e73973eb6404d6ec6789691990b3ee Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 11 Nov 2022 12:37:55 -0800
Subject: [PATCH 369/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 967 +++++++++++++++++++++-
 1 file changed, 952 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 15ec36e93a5..b598744a6da 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -80,6 +82,7 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
+  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -143,6 +146,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -209,6 +213,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -428,6 +440,10 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
+let (uu___is_EAddrOf : expr -> Prims.bool) =
+  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
+let (__proj__EAddrOf__item___0 : expr -> expr) =
+  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -579,6 +595,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -674,6 +694,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -825,7 +941,8 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -835,8 +952,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -854,6 +972,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -866,7 +1041,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -903,18 +1079,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -974,13 +1153,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -993,19 +1173,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1613,6 +1810,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1706,11 +1963,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2436,6 +2730,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::e1::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::uu___7::e1::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Types.is_null" ->
+          let uu___8 =
+            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
+            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
+              uu___9) in
+          EApp uu___8
+      | FStar_Extraction_ML_Syntax.MLE_TApp
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2)
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Array.Base.null_from" ->
+          EQualified (["LowStar"; "Buffer"], "null")
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2814,6 +3607,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2826,7 +3685,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 0614b08f240bf8d4750b33150564ed8a044a4b99 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 11 Jan 2023 14:12:07 -0800
Subject: [PATCH 370/513] Revert "snap"

This reverts commit a38ae8e5a7e73973eb6404d6ec6789691990b3ee.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 967 +---------------------
 1 file changed, 15 insertions(+), 952 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index b598744a6da..15ec36e93a5 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -82,7 +80,6 @@ and expr =
   | EAbortT of (Prims.string * typ) 
   | EComment of (Prims.string * expr * Prims.string) 
   | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
 and op =
   | Add 
   | AddW 
@@ -146,7 +143,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -213,14 +209,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -440,10 +428,6 @@ let (uu___is_EStandaloneComment : expr -> Prims.bool) =
     match projectee with | EStandaloneComment _0 -> true | uu___ -> false
 let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
   fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
 let (uu___is_Add : op -> Prims.bool) =
   fun projectee -> match projectee with | Add -> true | uu___ -> false
 let (uu___is_AddW : op -> Prims.bool) =
@@ -595,10 +579,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -694,102 +674,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -941,8 +825,7 @@ let (translate_cc :
     | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
     | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
     | uu___1 -> FStar_Pervasives_Native.None
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -952,9 +835,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -972,63 +854,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1041,8 +866,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1079,21 +903,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1153,14 +974,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1173,36 +993,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1810,66 +1613,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1963,48 +1706,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2730,505 +2436,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::e1::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::uu___7::e1::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Types.is_null" ->
-          let uu___8 =
-            let uu___9 = let uu___10 = translate_expr env1 e1 in [uu___10] in
-            ((EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null")),
-              uu___9) in
-          EApp uu___8
-      | FStar_Extraction_ML_Syntax.MLE_TApp
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2)
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Array.Base.null_from" ->
-          EQualified (["LowStar"; "Buffer"], "null")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> EApp ((EQualified (["LowStar"; "Buffer"], "null")), [EUnit])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3607,72 +2814,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3685,85 +2826,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 99909a6acef8f648a99775a6a891341e66ec46ae Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 11 Jan 2023 14:42:40 -0800
Subject: [PATCH 371/513] move definition of vrefine_vrewrite_equals_intro into
 .fst

---
 ulib/experimental/Steel.ST.Combinators.fst  | 7 +++++++
 ulib/experimental/Steel.ST.Combinators.fsti | 6 +-----
 2 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/ulib/experimental/Steel.ST.Combinators.fst b/ulib/experimental/Steel.ST.Combinators.fst
index bcc79da4ee5..a8e39724642 100644
--- a/ulib/experimental/Steel.ST.Combinators.fst
+++ b/ulib/experimental/Steel.ST.Combinators.fst
@@ -180,6 +180,13 @@ let vrewrite_vrefine_equals_intro0
     (fun res -> Ghost.reveal res == f x)
 = C.coerce_ghost (fun _ -> vrewrite_vrefine_equals_intro' s f x)
 
+let vrewrite_vrefine_equals_intro
+  s f x
+= let res = vrewrite_vrefine_equals_intro0 s f x in
+  rewrite
+    (s `vrewrite` f `vrefine` equals (Ghost.reveal res))
+    (s `vrewrite` f `vrefine` equals (f x))
+
 let vrewrite_vrefine_equals_elim'
   (#inames: _)
   (#t: Type)
diff --git a/ulib/experimental/Steel.ST.Combinators.fsti b/ulib/experimental/Steel.ST.Combinators.fsti
index 693fbb6e955..de3561fb1da 100644
--- a/ulib/experimental/Steel.ST.Combinators.fsti
+++ b/ulib/experimental/Steel.ST.Combinators.fsti
@@ -83,7 +83,7 @@ val vrewrite_vrefine_equals_intro0
     True
     (fun res -> Ghost.reveal res == f x)
 
-let vrewrite_vrefine_equals_intro
+val vrewrite_vrefine_equals_intro
   (#inames: _)
   (#t: Type)
   (s: vprop)
@@ -92,10 +92,6 @@ let vrewrite_vrefine_equals_intro
 : STGhostT unit inames
     (s `vrefine` equals x)
     (fun res -> s `vrewrite` f `vrefine` equals (f x))
-= let res = vrewrite_vrefine_equals_intro0 s f x in
-  rewrite
-    (s `vrewrite` f `vrefine` equals (Ghost.reveal res))
-    (s `vrewrite` f `vrefine` equals (f x))
 
 val vrewrite_vrefine_equals_elim
   (#inames: _)

From 816904148f0aefcbccf8cdc5266a3168fe4cf632 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 12 Jan 2023 10:48:17 -0800
Subject: [PATCH 372/513] use EBufNull to extract null (from
 FStarLang/karamel#318)

---
 src/extraction/FStar.Extraction.Krml.fst | 28 ++++++++++--------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 4d6d8434ce5..293c308c084 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -1044,34 +1044,28 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
     translate_expr env e
 
-(* BEGIN support for the Steel null pointer. Here, we "piggyback" to
-the current Low* operators for the null pointer, which KaRaMeL will
-extract to C later.
+(* BEGIN support for the Steel null pointer. *)
 
-TODO: these should be removed and those operators should be directly
-supported by KaRaMeL (in src/Builtin.ml) Or alternatively Null and
-IsNull nodes should be added to the KaRaMeL AST *)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.is_null_from"
-    -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
+    -> generate_is_null (translate_type env t) (translate_expr env e)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); _ (* pcm *); e; _ (* view *)])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; t])}, [_ (* opened *); _ (* pcm *); e; _ (* view *)])
     when string_of_mlpath p = "Steel.C.Reference.is_null"
-    -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
+    -> generate_is_null (translate_type env t) (translate_expr env e)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); _ (* td *); _ (* v *); e])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); _ (* td *); _ (* v *); e])
     when string_of_mlpath p = "Steel.C.Types.is_null"
-    -> EApp (EQualified (["LowStar"; "Monotonic"; "Buffer"], "is_null"), [ translate_expr env e ])
+    -> generate_is_null (translate_type env t) (translate_expr env e)
   
-  | MLE_TApp ({expr=MLE_Name p}, _)
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, _)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.null_from"
-    -> EQualified (["LowStar"; "Buffer"], "null")
+    -> EBufNull (translate_type env t)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* pcm *)])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
     when string_of_mlpath p = "Steel.C.Reference.null"
     || string_of_mlpath p = "Steel.C.Types.null"
-    -> EApp (EQualified (["LowStar"; "Buffer"], "null"), [EUnit])
+    -> EBufNull (translate_type env t)
 
 (* END support for the Steel null pointer *)
 

From 4c2d9793bf8a3838dc4d6dea46921d8d7e5efb1e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 12 Jan 2023 10:49:37 -0800
Subject: [PATCH 373/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 962 +++++++++++++++++++++-
 1 file changed, 947 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index d684b8e8ea4..24d9e966adc 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -145,6 +147,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -211,6 +214,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -590,6 +601,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -685,6 +700,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -841,7 +952,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -851,8 +963,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -870,6 +983,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -882,7 +1052,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -919,18 +1090,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -990,13 +1164,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1009,19 +1184,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1665,6 +1857,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1758,11 +2010,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2488,6 +2777,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2885,6 +3673,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2897,7 +3751,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From bce72d3c84b055ece64af5a2f0d780c3a2ba5e35 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 12 Jan 2023 10:50:03 -0800
Subject: [PATCH 374/513] arraystructs examples still need
 `--compat_pre_typed_indexed_effects`

---
 examples/steel/arraystructs/Makefile | 1 +
 1 file changed, 1 insertion(+)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 2d678d7a298..2caf053cbf0 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -13,6 +13,7 @@ world: verify test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \
+		--compat_pre_typed_indexed_effects \
 	        --already_cached 'Prims,FStar,LowStar,Steel' \
 		$(addprefix --include ,$(INCLUDE_PATH)) \
 		$(OTHERFLAGS)

From dc6da53aaadf44763d6618536e18092c7226775b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 12 Jan 2023 12:48:51 -0800
Subject: [PATCH 375/513] bore holes

---
 ulib/experimental/Steel.C.Types.fst | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 5bb9279cde3..20d85f55474 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -1336,7 +1336,7 @@ let array_ref_of_ref
   rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ());
   return res
 
-
+let unarray_of_ref = magic ()
 
 unfold
 let has_base_array_cell0
@@ -1380,10 +1380,26 @@ let has_array_cell_array_of_ref
 
 #pop-options
 
+let ghost_array_cell_focus = magic ()
+
+let ghost_array_cell = magic ()
 (*
-let ghost_array_cell
   #_ #_ #_ #s a i
 = let ma = model_array_of_array a in
 *)
 
+let array_ref_cell = magic ()
+
+let unarray_cell = magic ()
+
+let array_ref_shift = magic ()
+
+let ghost_array_split = magic ()
+
+let array_ref_split = magic ()
+
+let array_join = magic ()
+
+let mk_fraction_seq_split_gen = magic ()
+
 let mk_fraction_seq_join = magic ()

From 91af9fb8ea77785af19ec569114e4501760f2a40 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 7 Feb 2023 10:21:20 -0800
Subject: [PATCH 376/513] Revert "snap"

This reverts commit 4c2d9793bf8a3838dc4d6dea46921d8d7e5efb1e.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 962 +---------------------
 1 file changed, 15 insertions(+), 947 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index 24d9e966adc..d684b8e8ea4 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -147,7 +145,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -214,14 +211,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -601,10 +590,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -700,102 +685,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -952,8 +841,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -963,9 +851,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -983,63 +870,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1052,8 +882,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1090,21 +919,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1164,14 +990,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1184,36 +1009,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1857,66 +1665,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2010,48 +1758,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2777,505 +2488,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3673,72 +2885,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3751,85 +2897,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From b3bd8aea1cf5be1704399e9daed6fac9d8a68603 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 7 Feb 2023 10:37:53 -0800
Subject: [PATCH 377/513] snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 962 +++++++++++++++++++++-
 1 file changed, 947 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index c4f540b06c3..fddc1f9ef61 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Reference.ptr" ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1058,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1096,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1170,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1190,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1883,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2036,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2803,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___8;
+                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___10 =
+            let uu___11 =
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___14 in
+                TQualified uu___13 in
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = translate_expr env1 r in
+                  (uu___15, (EConstant (UInt32, "0"))) in
+                EBufRead uu___14 in
+              (uu___12, uu___13, field_name) in
+            EField uu___11 in
+          EAddrOf uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___8 =
+            let uu___9 =
+              let uu___10 =
+                let uu___11 =
+                  let uu___12 =
+                    let uu___13 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___13 in
+                  TQualified uu___12 in
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = translate_expr env1 r in
+                    (uu___14, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___13 in
+                (uu___11, uu___12, field_name) in
+              EField uu___10 in
+            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
+          EAssign uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 r in
+            (uu___6, (EConstant (UInt32, "0"))) in
+          EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::x::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                let uu___8 = translate_expr env1 r in
+                (uu___8, (EConstant (UInt32, "0"))) in
+              EBufRead uu___7 in
+            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
+          EAssign uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 r in
+            (uu___9, (EConstant (UInt32, "0"))) in
+          EBufRead uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.index_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           r::uu___5::i::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.upd_from" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            let uu___8 = translate_expr env1 i in
+            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
+          EBufWrite uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::a::i::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 = translate_expr env1 a in
+              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+            EBufRead uu___7 in
+          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3715,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3793,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 7d5144bc0743080118b9d00cfde4937796bd8b2d Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Feb 2023 13:03:53 -0800
Subject: [PATCH 378/513] Revert "remove base type, thanks to an invariant and
 indefinite description"

This reverts commit 1363725c226e318fb69f4164880fcc0279ae948b.
---
 examples/steel/arraystructs/HaclExample.fst  |  10 +-
 examples/steel/arraystructs/PointStruct.fst  |  12 +-
 examples/steel/arraystructs/ScalarUnion.fst  |   8 +-
 src/extraction/FStar.Extraction.Krml.fst     |  26 +-
 ulib/experimental/Steel.C.Array.Base.fst     | 283 +++++++------
 ulib/experimental/Steel.C.Array.Base.fsti    | 230 ++++++-----
 ulib/experimental/Steel.C.Array.fst          |  20 +-
 ulib/experimental/Steel.C.Array.fsti         |   8 +-
 ulib/experimental/Steel.C.Frac.fsti          |  16 +-
 ulib/experimental/Steel.C.Opt.fst            |  14 +-
 ulib/experimental/Steel.C.Opt.fsti           |  36 +-
 ulib/experimental/Steel.C.Ref.fst            | 399 ++++++++-----------
 ulib/experimental/Steel.C.Ref.fsti           | 140 +++----
 ulib/experimental/Steel.C.Reference.fst      | 100 ++---
 ulib/experimental/Steel.C.Struct.fst         |  10 +-
 ulib/experimental/Steel.C.StructLiteral.fst  |  14 +-
 ulib/experimental/Steel.C.StructLiteral.fsti |  31 +-
 ulib/experimental/Steel.C.Union.fst          |  10 +-
 ulib/experimental/Steel.C.UnionLiteral.fst   |  28 +-
 ulib/experimental/Steel.C.UnionLiteral.fsti  |  19 +-
 ulib/experimental/Steel.Effect.Common.fsti   |   2 +-
 ulib/experimental/Steel.PCMReadOnly.fst      |  34 --
 22 files changed, 703 insertions(+), 747 deletions(-)
 delete mode 100644 ulib/experimental/Steel.PCMReadOnly.fst

diff --git a/examples/steel/arraystructs/HaclExample.fst b/examples/steel/arraystructs/HaclExample.fst
index 17b65fcfe89..84df355e89d 100644
--- a/examples/steel/arraystructs/HaclExample.fst
+++ b/examples/steel/arraystructs/HaclExample.fst
@@ -87,7 +87,7 @@ let _ = norm norm_c_typedef (mk_c_struct comp_tag comp_fields)
     element of the corresponding array to zero) *)
 
 let do_something_with_limbs
-  (a: array U64.t)
+  (a: array 'a U64.t)
 : Steel unit
     (varray a)
     (fun _ -> varray a)
@@ -97,14 +97,14 @@ let do_something_with_limbs
   return ()
 
 let do_something_with_precomp
-  (a: array U64.t)
-: Steel (array_or_null U64.t)
+  (a: array 'a U64.t)
+: Steel (array_or_null 'a U64.t)
     (varray a)
     (fun _ -> varray a)
     (requires fun _ -> length a == 20)
     (ensures fun _ _ _ -> True)
 = upd a (mk_size_t (U32.uint_to_t 19)) (U64.uint_to_t 0);
-  return (null _)
+  return (null _ _)
 
 let test_alloc_free
   ()
@@ -125,7 +125,7 @@ let test_alloc_free
 #push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 30"
 
 let test
-  (p: ref comp comp_pcm)
+  (p: ref 'a comp comp_pcm)
 : SteelT unit
     (p `pts_to_view` comp_view emptyset)
     (fun _ -> p `pts_to_view` comp_view emptyset)
diff --git a/examples/steel/arraystructs/PointStruct.fst b/examples/steel/arraystructs/PointStruct.fst
index 020250e2f3e..bd29afe064c 100644
--- a/examples/steel/arraystructs/PointStruct.fst
+++ b/examples/steel/arraystructs/PointStruct.fst
@@ -105,7 +105,7 @@ open Steel.C.Reference
 
 (** To illustrate pointer-to-field in action, we write a function swap
     that swaps x and y coordinates of a point struct. *)
-val swap (p: ref point point_pcm)
+val swap (p: ref 'a point point_pcm)
 : Steel unit
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
@@ -150,7 +150,7 @@ let swap p =
     pointers in a generic way: the helper function does not need to
     know that its inputs are pointers to fields of a struct in order
     to work. *)
-let generic_swap_sel (p:ref 'c (opt_pcm #'c)) (q:ref 'c (opt_pcm #'c))
+let generic_swap_sel (p:ref 'a 'c (opt_pcm #'c)) (q:ref 'b 'c (opt_pcm #'c))
 : Steel unit
   ((p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
   (fun _ -> (p `pts_to_view` opt_view _) `star` (q `pts_to_view` opt_view _))
@@ -168,8 +168,8 @@ let generic_swap_sel (p:ref 'c (opt_pcm #'c)) (q:ref 'c (opt_pcm #'c))
   opt_write_sel q tmp;
   return ()
 
-val swap' (p: ref point point_pcm)
-: Steel (ptr point point_pcm)
+val swap' (p: ref 'a point point_pcm)
+: Steel (ptr 'a point point_pcm)
     (p `pts_to_view` point_view emptyset)
     (fun _ -> p `pts_to_view` point_view emptyset)
     (requires fun _ -> True)
@@ -187,13 +187,13 @@ let swap' p =
   unaddr_of_struct_field "y" p r;
   unaddr_of_struct_field "x" p q;
   change_equal_slprop (p `pts_to_view` _) (p `pts_to_view` _);
-  return (null _ _)
+  return (null _ _ _)
 
 let test_malloc_free () : SteelT unit emp (fun _ -> emp) =
   let c = malloc 42ul in
   if is_null c _
   then begin
-    elim_pts_to_view_or_null_null c (opt_view _);
+    elim_pts_to_view_or_null_null _ c (opt_view _);
     return ()
   end else begin
     elim_pts_to_view_or_null_not_null c (opt_view _);
diff --git a/examples/steel/arraystructs/ScalarUnion.fst b/examples/steel/arraystructs/ScalarUnion.fst
index c33e4f08170..74fe25f8552 100644
--- a/examples/steel/arraystructs/ScalarUnion.fst
+++ b/examples/steel/arraystructs/ScalarUnion.fst
@@ -73,7 +73,7 @@ let _ = norm norm_c_typedef (mk_c_union u32_or_u16_tag u32_or_u16_fields)
 
 (** Switch a case of the union to the u16 case, by writing x to it. *)
 val switch_to_u16
-  (p: ref u32_or_u16 u32_or_u16_pcm)
+  (p: ref unit u32_or_u16 u32_or_u16_pcm)
   (x: U16.t)
 : Steel unit
     (p `pts_to_view` u32_or_u16_view)
@@ -89,7 +89,7 @@ let switch_to_u16 p x =
   return ()
 
 (** Helper function that zeros the memory location pointed to by p. *)
-let zero_u32_ref (p:ref U32.t (opt_pcm #U32.t))
+let zero_u32_ref (p:ref 'a U32.t (opt_pcm #U32.t))
 : Steel unit
   (p `pts_to_view` opt_view _)
   (fun _ -> p `pts_to_view` opt_view _)
@@ -98,7 +98,7 @@ let zero_u32_ref (p:ref U32.t (opt_pcm #U32.t))
 = opt_write_sel p 0ul
 
 (** Given a union in the u32 case, set the u32 to zero. *)
-val zero_u32_of_union (p: ref u32_or_u16 u32_or_u16_pcm)
+val zero_u32_of_union (p: ref unit u32_or_u16 u32_or_u16_pcm)
 : Steel unit
     (p `pts_to_view` u32_or_u16_view)
     (fun _ -> p `pts_to_view` u32_or_u16_view)
@@ -106,7 +106,7 @@ val zero_u32_of_union (p: ref u32_or_u16 u32_or_u16_pcm)
     (ensures fun h q h' -> True)
 
 let zero_u32_of_union p =
-  let q: ref U32.t _ = addr_of_union_field "as_u32" p in
+  let q: ref _ U32.t _ = addr_of_union_field "as_u32" p in
   zero_u32_ref q;
   unaddr_of_union_field "as_u32" p q;
   return ()
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index a2353990727..c4874ea62fc 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -461,7 +461,7 @@ let rec translate_type_without_decay env t: typ =
     ->
       TQualified (must (lident_of_typestring tag))
   
-  | MLTY_Named ([arg; _; _], p) when
+  | MLTY_Named ([_; arg; _; _], p) when
     Syntax.string_of_mlpath p = "Steel.C.Reference.ptr"
     ->
       TBuf (translate_type_without_decay env arg)
@@ -473,7 +473,7 @@ let rec translate_type_without_decay env t: typ =
         translate_type_without_decay env t,
         (UInt32, string_of_int (must (int_of_typenat n))))
   
-  | MLTY_Named ([arg], p) when
+  | MLTY_Named ([_; arg], p) when
     Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_or_null_from"
     ->
       TBuf (translate_type_without_decay env arg)
@@ -1027,7 +1027,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
     when string_of_mlpath p = "Steel.C.UnionLiteral.unaddr_of_union_field" ->
       EUnit
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; struct_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
              [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field''" ->
       EAddrOf (EField (
@@ -1035,7 +1035,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
       EAddrOf (EField (
@@ -1043,7 +1043,7 @@ IsNull nodes should be added to the KaRaMeL AST *)
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         field_name))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; union_name])},
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; new_value; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.switch_union_field'" ->
       EAssign (
@@ -1053,37 +1053,37 @@ IsNull nodes should be added to the KaRaMeL AST *)
           field_name),
         translate_expr env new_value)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
     when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r; x])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; x])
     when string_of_mlpath p = "Steel.C.Opt.opt_write_sel" ->
       EAssign (
         EBufRead (translate_expr env r, EConstant (UInt32, "0")),
         translate_expr env x)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r])
     when string_of_mlpath p = "Steel.C.Array.Base.mk_array_of_ref_from" ->
       translate_expr env r
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
     when string_of_mlpath p = "Steel.C.Array.Base.intro_varray_from" ->
       EBufRead (translate_expr env r, EConstant (UInt32, "0"))
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r; _ (* r' *); i])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i])
     when string_of_mlpath p = "Steel.C.Array.index_from" ->
       EBufRead (translate_expr env r, translate_expr env i)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [r; _ (* r' *); i; x])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i; x])
     when string_of_mlpath p = "Steel.C.Array.upd_from" ->
       EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
 
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; a; i])
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
     when string_of_mlpath p = "Steel.C.Array.Base.split_right_from" ->
       EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
 
diff --git a/ulib/experimental/Steel.C.Array.Base.fst b/ulib/experimental/Steel.C.Array.Base.fst
index fd27cd20ee6..7bed43a9046 100644
--- a/ulib/experimental/Steel.C.Array.Base.fst
+++ b/ulib/experimental/Steel.C.Array.Base.fst
@@ -182,9 +182,9 @@ let array_view t n =
   array_view' t n
 
 noeq
-type array_from0 t = {
+type array_from0 base t = {
   base_len: Ghost.erased size_t;
-  base_ref: Steel.C.Reference.ref (array_view_type t base_len) (array_pcm t base_len);
+  base_ref: Steel.C.Reference.ref base (array_view_type t base_len) (array_pcm t base_len);
   from: size_t;
   perm_ref: Steel.Reference.ghost_ref unit;
 }
@@ -197,8 +197,9 @@ type array_to0 = {
 }
 
 let array0_spec
+  (#base: _)
   (#t: _)
-  (from: array_from0 t)
+  (from: array_from0 base t)
   (to: array_to0)
 : Tot prop
 =
@@ -206,8 +207,8 @@ let array0_spec
     size_v from.from <= size_v to.to /\
     size_v to.to <= size_v from.base_len
 
-let array_or_null_from t = option (array_from0 t)
-let array_or_null_to t = Ghost.erased (option array_to0)
+let array_or_null_from base t = option (array_from0 base t)
+let array_or_null_to base t = Ghost.erased (option array_to0)
 let array_or_null_spec (from, to) =
   None? from == None? to /\
   ((Some? from \/ Some? to) ==> array0_spec (Some?.v from) (Some?.v to))
@@ -218,8 +219,8 @@ let len (from, to) =
     let Some to = Ghost.reveal to in to.to `size_sub` from.from
   | _ -> zero_size
 
-let null_from _ = None
-let null_to _ = None
+let null_from _ _ = None
+let null_to _ _ = None
 let null_to_unique _ = ()
 
 let g_is_null a = None? (fst a)
@@ -936,85 +937,91 @@ let to_view_array_conn
 #pop-options
 
 let array__base_len
-  (#t: _)
-  (a: array t)
+  (#base #t: _)
+  (a: array base t)
 : GTot size_t
 = (Some?.v (fst a)).base_len
 
 let array__base_ref
-  (#t: _)
-  (a: array t)
-: Tot (Steel.C.Reference.ref (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
+  (#base #t: _)
+  (a: array base t)
+: Tot (Steel.C.Reference.ref base (array_view_type t (array__base_len a)) (array_pcm t (array__base_len a)))
 = (Some?.v (fst a)).base_ref
 
 let array__from
-  (#t: _)
-  (a: array t)
+  (#base #t: _)
+  (a: array base t)
 : Tot size_t
 = (Some?.v (fst a)).from
 
 let array__to
-  (#t: _)
-  (a: array t)
+  (#base #t: _)
+  (a: array base t)
 : GTot size_t
 = (Some?.v (snd a)).to
 
 let array__perm_ref
-  (#t: _)
-  (a: array t)
+  (#base #t: _)
+  (a: array base t)
 : Tot (Steel.Reference.ghost_ref unit)
 = (Some?.v (fst a)).perm_ref
 
 let array__perm_val
-  (#t: _)
-  (a: array t)
+  (#base #t: _)
+  (a: array base t)
 : Tot Steel.FractionalPermission.perm
 = (Some?.v (snd a)).perm_val
 
 let array_as_ref_conn
+  (#base: Type)
   (#t: Type)
-  (a: array t)
+  (a: array base t)
 : GTot (Steel.C.Connection.connection (array_pcm t (array__base_len a)) (array_pcm t (len a)))
 = array_conn t (array__base_len a) (array__from a) (array__to a) ()
 
 let array_as_ref
+  (#base: Type)
   (#t: Type)
-  (a: array t)
-: GTot (Steel.C.Reference.ref (array_view_type t (len a)) (array_pcm t (len a)))
+  (a: array base t)
+: GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
 = Steel.C.Ref.ref_focus (array__base_ref a) (array_as_ref_conn a)
 
 [@@__steel_reduce__]
 let varray0
+  (#base: Type)
   (#t: Type)
-  (x: array t)
+  (x: array base t)
 : Tot vprop
 = Steel.C.Ref.pts_to_view
+    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
 
 [@@__steel_reduce__]
 let varray9
+  (#base: Type)
   (#t: Type)
-  (x: array t)
+  (x: array base t)
 : Tot vprop
 = (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x)  (array__perm_val x)) `vrewrite` fst
 
-let varray_hp #t x = hp_of (varray9 #t x)
+let varray_hp #base #t x = hp_of (varray9 #base #t x)
 
 #push-options "--debug Steel.C.Array --debug_level Extreme"
 
-let varray_sel #t x = sel_of (varray9 #t x)
+let varray_sel #base #t x = sel_of (varray9 #base #t x)
 
 #pop-options
 
 let intro_varray1
   (#inames: _)
+  (#base: Type)
   (#t: Type)
-  (x: array t)
+  (x: array base t)
 : SteelGhost unit inames
     (varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
     (fun _ -> varray x)
@@ -1031,8 +1038,9 @@ let intro_varray1
 
 let elim_varray1
   (#inames: _)
+  (#base: Type)
   (#t: Type)
-  (x: array t)
+  (x: array base t)
 : SteelGhost unit inames
     (varray x)
     (fun _ -> varray0 x `star` Steel.Reference.ghost_vptrp (array__perm_ref x) (array__perm_val x))
@@ -1048,8 +1056,8 @@ let elim_varray1
     fst
 
 let g_mk_array_from'
-  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from t)
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
 : Tot prop
 = 
   Some? a /\
@@ -1060,7 +1068,7 @@ let g_mk_array_from'
   a.from == mk_size_t 0ul
   end
 
-let g_mk_array #t #n r a =
+let g_mk_array #base #t #n r a =
   g_mk_array_from' r (fst a) /\
   (array__to a) == n /\
   (array__perm_val a) == Steel.FractionalPermission.full_perm
@@ -1069,7 +1077,7 @@ let g_mk_array_weak r a = ()
 
 let g_mk_array_from r a = g_mk_array_from' r a
 
-let g_mk_array_to #t #n r a
+let g_mk_array_to #base #t #n r a
 =
   Some ({
     to = n;
@@ -1078,9 +1086,9 @@ let g_mk_array_to #t #n r a
 
 #push-options "--z3rlimit 32"
 
-val intro_varray0 (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+val intro_varray0 (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: SteelAtomicBase (array t)
+: SteelAtomicBase (array base t)
     false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
@@ -1092,7 +1100,7 @@ val intro_varray0 (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference
   ))
 
 let intro_varray0
-  #t #_ #n r sq
+  #base #t #_ #n r sq
 =
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
   let from = Some ({
@@ -1105,7 +1113,7 @@ let intro_varray0
   change_equal_slprop
     (Steel.Reference.ghost_vptr perm_ref)
     (Steel.Reference.ghost_vptrp (array__perm_ref res) (array__perm_val res));
-  assert ((array_as_ref res <: Steel.C.Ref.ref (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
+  assert ((array_as_ref res <: Steel.C.Ref.ref base (array_pcm t n)) == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
   array_conn_id t n;
   assert (array_conn t n (mk_size_t 0ul) n () == Steel.C.Connection.connection_id (array_pcm t n));
   assert (array_as_ref res == Steel.C.Ref.ref_focus r (Steel.C.Connection.connection_id (array_pcm t n)));
@@ -1127,7 +1135,7 @@ let intro_varray_from r _ =
   return res
 
 let elim_varray
-  #_ #t #n r res sq
+  #_ #base #t #n r res sq
 =
   assert (g_mk_array r res);
   assert (array_as_ref res == Steel.C.Ref.ref_focus r (array_conn t n (mk_size_t 0ul) n ()));
@@ -1156,9 +1164,10 @@ let adjacent r1 r2 =
   (array__to r1) == (array__from r2)
 
 val t_merge
+  (#base: Type)
   (#t: Type)
-  (r1 r2: array t)
-: Pure (array t)
+  (r1 r2: array base t)
+: Pure (array base t)
   (requires (adjacent r1 r2))
   (ensures (fun r -> length r == length r1 + length r2))
 
@@ -1176,7 +1185,7 @@ let merge_inj_right a b1 b2 = ()
 
 let merge_inj_left a1 a2 b = ()
 
-let no_self_merge_1 (#t: Type) (a b: array t) : Lemma
+let no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
   (~ (merge_into a b a))
 = let aux () : Lemma
     (requires (merge_into a b a))
@@ -1189,7 +1198,7 @@ let no_self_merge_1 (#t: Type) (a b: array t) : Lemma
   in
   Classical.move_requires aux ()
 
-let no_self_merge_2 (#t: Type) (a b: array t) : Lemma
+let no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
   (~ (merge_into a b b))
 = let aux () : Lemma
     (requires (merge_into a b a))
@@ -1203,25 +1212,26 @@ let no_self_merge_2 (#t: Type) (a b: array t) : Lemma
   Classical.move_requires aux ()
 
 val tsplit
+  (#base: Type)
   (#t: Type)
-  (r: array t)
+  (r: array base t)
   (i: size_t)
-: Pure (array t & array t)
+: Pure (array base t & array base t)
   (requires (size_v i <= length r))
   (ensures (fun (rl, rr) ->
     merge_into rl rr r /\
     length rl == size_v i
   ))
 
-let tsplit #t r i =
+let tsplit #base #t r i =
   let h = half_perm (array__perm_val r) in
-  let r1 : array t =
+  let r1 : array base t =
     (fst r, Ghost.hide (Some ({
       to = (array__from r) `size_add` i;
       perm_val = h;
     })))
   in
-  let r2 : array t = (Some ({
+  let r2 : array base t = (Some ({
     base_len = (array__base_len r);
     base_ref = (array__base_ref r);
     from = (array__from r) `size_add` i;
@@ -1289,8 +1299,9 @@ let to_carrier_split t n x v i =
     assert ((array_view' t (n `size_sub` i)).Steel.C.Ref.to_carrier (Seq.slice v (size_v i) (size_v n)) `feq` xr)
 
 let array_as_ref_split_left
+  (base: Type)
   (t: Type)
-  (x: array t)
+  (x: array base t)
   (i: size_t)
 : Lemma
   (requires (size_v i <= length x))
@@ -1303,8 +1314,9 @@ let array_as_ref_split_left
 
 #restart-solver
 let array_as_ref_split_right
+  (base: Type)
   (t: Type)
-  (x: array t)
+  (x: array base t)
   (i: size_t)
 : Lemma
   (requires (size_v i <= length x))
@@ -1315,8 +1327,8 @@ let array_as_ref_split_right
   array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
   Steel.C.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
 
-val split_ (#opened: _) (#t:Type) (a:array t) (i:size_t)
-  : SteelGhost (array t `gpair` array t) opened
+val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+  : SteelGhost (array base t `gpair` array base t) opened
           (varray a)
           (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
           (fun _ -> size_v i <= length a)
@@ -1335,15 +1347,16 @@ val split_ (#opened: _) (#t:Type) (a:array t) (i:size_t)
 
 #restart-solver
 let split_
-  #j #t x i
+  #j #base #t x i
 =
   let gv = gget (varray x) in
   elim_varray1 x;
   let v = Steel.C.Ref.pts_to_view_elim
     #j
+    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
@@ -1357,7 +1370,7 @@ let split_
   let vr' : array_pcm_carrier t (len xr) = array_large_to_small_f t n i n () v in
   let vr : array_pcm_carrier t (len x) = array_small_to_large_f t n i n () vr' in
   Steel.C.Ref.split
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     v
     vl
     vr;
@@ -1369,11 +1382,11 @@ let split_
   = magic () // array_conn t n z i ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
   in
   Steel.C.Ref.gfocus
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     cl
     vl
     vl';
-  array_as_ref_split_left t x i;
+  array_as_ref_split_left _ t x i;
   assert (array_as_ref xl == Steel.C.Ref.ref_focus (array_as_ref x) cl);
   change_equal_slprop
     (_ `Steel.C.Ref.pts_to` vl')
@@ -1382,6 +1395,7 @@ let split_
   let gvl : array_view_type t (len xl) = Seq.slice gv 0 (size_v i) in
   Steel.C.Ref.pts_to_view_intro
     #j
+    #base
     #(array_pcm_carrier t (len xl))
     #(array_pcm t (len xl))
     (array_as_ref xl)
@@ -1406,11 +1420,11 @@ let split_
   = magic () // array_conn t n i n ()  // FIXME: WHY WHY WHY does this send F* off rails (> 35 GB RAM consumption and going)
   in
   Steel.C.Ref.gfocus
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     cr
     vr
     vr';
-  array_as_ref_split_right t x i;
+  array_as_ref_split_right _ t x i;
   assert (array_as_ref xr == Steel.C.Ref.ref_focus (array_as_ref x) cr);
   change_equal_slprop
     (_ `Steel.C.Ref.pts_to` vr')
@@ -1421,6 +1435,7 @@ let split_
 //  in
   Steel.C.Ref.pts_to_view_intro
     #j
+    #base
     #(array_pcm_carrier t (len xr))
     #(array_pcm t (len xr))
     (array_as_ref xr)
@@ -1446,7 +1461,7 @@ let split_
   res
 
 let split'
-  #_ #t a i
+  #_ #_ #t a i
 =
   let g = gget (varray a) in
   Seq.lemma_split #t (Ghost.reveal g) (size_v i);
@@ -1460,6 +1475,7 @@ let split_right_from
 let join' = admit ()
 
 let array_as_one_ref_iso
+  (base: Type)
   (t: Type)
 : Tot (Steel.C.Connection.isomorphism (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
 = let c1 = (Steel.C.Struct.struct_to_field (array_elements_pcm t one_size) zero_size) in
@@ -1481,55 +1497,56 @@ let array_as_one_ref_iso
     (fun x -> ())
 
 let array_as_one_ref_conn
+  (base: Type)
   (t: Type)
 : Tot (Steel.C.Connection.connection (array_pcm t one_size) (Steel.C.Opt.opt_pcm #t))
-= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso t)
+= Steel.C.Connection.connection_of_isomorphism (array_as_one_ref_iso base t)
 
 let g_ref_of_array
-  #t r
+  #base #t r
 =
-  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn t
+  array_as_ref r `Steel.C.Ref.ref_focus` array_as_one_ref_conn base t
 
 let array_as_one_ref_conn'
-  (#t:Type0) (r:array t)
+  (#base: Type) (#t:Type0) (r:array base t)
 : Pure (Steel.C.Connection.connection (array_pcm t (array__base_len r)) (Steel.C.Opt.opt_pcm #t))
   (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
 =
-  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn t
+  array_conn t (array__base_len r) (array__from r) ((array__from r) `size_add` one_size) () `Steel.C.Connection.connection_compose` array_as_one_ref_conn base t
 
 #restart-solver
 let array_as_one_ref_conn'_small_to_large
-  (#t:Type0) (r:array t)
+  (#base: Type) (#t:Type0) (r:array base t)
   (x: option t)
   (i: array_domain t (array__base_len r))
 : Lemma
   (requires (size_v (len r) == 1))
   (ensures ((array_as_one_ref_conn' r).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph x i == (if i = (array__from r) then x else None)))
 = Steel.C.Connection.morphism_compose_morph
-    (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large
+    (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large
     (array_conn t (array__base_len r) (array__from r) (array__from r `size_add` one_size) ()).Steel.C.Connection.conn_small_to_large
     x
 
 let g_ref_of_array'
-  (#t:Type0) (r:array t)
-: Ghost (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
   (requires (size_v (len r) == 1))
   (ensures (fun _ -> True))
 = (array__base_ref r) `Steel.C.Ref.ref_focus` array_as_one_ref_conn' r
 
 let g_ref_of_array'_correct
-  (#t:Type0) (r:array t)
+  (#base: Type) (#t:Type0) (r:array base t)
 : Lemma
   (requires (length r == 1))
   (ensures (g_ref_of_array r == g_ref_of_array' r))
 =
-  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn t)
+  Steel.C.Ref.ref_focus_comp (array__base_ref r) (array_conn t (array__base_len r) (array__from r) (array__to r) ()) (array_as_one_ref_conn base t)
 
 let get_pts_to
   (#inames: _)
-  (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
-  (r: Steel.C.Ref.ref p) (v: Ghost.erased b)
+  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
+  (r: Steel.C.Ref.ref a p) (v: Ghost.erased b)
 : SteelGhost (Ghost.erased b) inames
     (Steel.C.Ref.pts_to r v)
     (fun v' -> Steel.C.Ref.pts_to r v)
@@ -1553,36 +1570,39 @@ val abstract_id
 #push-options "--z3rlimit 64 --fuel 1 --ifuel 2 --query_stats --z3cliopt smt.arith.nl=false --print_implicits"
 
 #restart-solver
-let ref_of_array_ghost #inames #t x sq =
+let ref_of_array_ghost #inames #base #t x sq =
   let gv = gget (varray x) in
   elim_varray1 x;
   let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
     #inames
+    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
   in
   assert (len x == one_size);
   let z : array_domain t one_size = zero_size in
-  assert (Ghost.reveal v `feq` (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
+  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
   Steel.C.Ref.gfocus
+    #base
     #(array_pcm_carrier t (len x))
     #(option t)
     #_
     #(array_pcm t (len x))
     (array_as_ref x)
     #(Steel.C.Opt.opt_pcm #t)
-    (array_as_one_ref_conn t)
+    (array_as_one_ref_conn base t)
     _
     (Ghost.reveal v z);
   Steel.C.Ref.pts_to_view_intro
     #inames
+    #base
     #(option t)
     #(Steel.C.Opt.opt_pcm #t)
-    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn t))
+    (Steel.C.Ref.ref_focus (array_as_ref x) (array_as_one_ref_conn base t))
     (Ghost.reveal v z)
     #t
     #false
@@ -1593,24 +1613,25 @@ let ref_of_array_ghost #inames #t x sq =
     (Steel.C.Ref.pts_to_view (g_ref_of_array x) (Steel.C.Opt.opt_view t))
 
 #restart-solver
-val ref_of_array0 (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
-  : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+val ref_of_array0 (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1)) (v0: Ghost.erased t)
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
              false opened Unobservable
              (varray r)
-             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #t r == r') `star` v_ref_of_array r)
+             (fun r' -> (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `vrefine` (fun v' -> v' == Ghost.reveal v0)) `star` pure (g_ref_of_array #base #t r == r') `star` v_ref_of_array r)
              (requires fun h0 -> Seq.index (h0 (varray r)) 0 == Ghost.reveal v0)
              (ensures fun h0 r' h1 -> True)
 
 #restart-solver
-let ref_of_array0 #t x sq v0 =
+let ref_of_array0 #base #t x sq v0 =
   let gv : Ghost.erased (array_view_type t (len x)) = gget (varray x) in
   assert (Seq.index (Ghost.reveal gv) 0 == Ghost.reveal v0);
   elim_varray1 x;
   let v : Ghost.erased (array_pcm_carrier t (len x)) = Steel.C.Ref.pts_to_view_elim
     #_
+    #base
     #(array_pcm_carrier t (len x))
     #(array_pcm t (len x))
-    (array_as_ref #t x)
+    (array_as_ref #base #t x)
     #(array_view_type t (len x))
     #(size_v (len x) = 0)
     (array_view' t (len x))
@@ -1622,9 +1643,10 @@ let ref_of_array0 #t x sq v0 =
     array_as_one_ref_conn'_small_to_large x (Ghost.reveal v zero_size) i
   );
   g_ref_of_array'_correct x;
-  let r : Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
+  let r : Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t) = Steel.C.Ref.focus (array__base_ref x) (array_as_one_ref_conn' x) s (Ghost.reveal v zero_size) in
   Steel.C.Ref.pts_to_view_intro
     #_
+    #base
     #(option t)
     #(Steel.C.Opt.opt_pcm #t)
     r
@@ -1636,12 +1658,12 @@ let ref_of_array0 #t x sq v0 =
   intro_vrefine
     (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
     (fun v' -> v' == Ghost.reveal v0);
-  intro_pure (g_ref_of_array #t x == r);
+  intro_pure (g_ref_of_array #base #t x == r);
   return r
 
 #restart-solver
-let ref_of_array_from #t r_from r_to sq =
-  let x : array t = (r_from, r_to) in
+let ref_of_array_from #base #t r_from r_to sq =
+  let x : array base t = (r_from, r_to) in
   change_equal_slprop
     (varray (r_from, r_to))
     (varray x);
@@ -1659,7 +1681,7 @@ let ref_of_array_from #t r_from r_to sq =
 
 #restart-solver
 let array_of_ref
-  #_ #t r' r sq
+  #_ #base #t r' r sq
 =
   let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
   let v = Steel.C.Ref.pts_to_view_elim
@@ -1669,7 +1691,7 @@ let array_of_ref
   Steel.C.Ref.unfocus
     r
     (array_as_ref r')
-    (array_as_one_ref_conn t)
+    (array_as_one_ref_conn base t)
     v;
   let g' : Ghost.erased (array_view_type t (len r')) =
     (Ghost.hide (Seq.create 1 (Ghost.reveal g)))
@@ -1692,15 +1714,15 @@ let array_of_ref
 
 #restart-solver
 let one_ref_as_array_conn
-  (t:Type0)
+  (base: Type) (t:Type0)
 : Tot (Steel.C.Connection.connection (Steel.C.Opt.opt_pcm #t) (array_pcm t one_size))
 =
-  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso t)))
+  Steel.C.Connection.(connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso base t)))
 
-let mk_array_of_ref' (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array t) =
+let mk_array_of_ref' (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit) : GTot (array base t) =
   (Some ({
     base_len = one_size;
-    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn t;
+    base_ref = r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t;
     from = zero_size;
     perm_ref = perm_ref;
   }), Ghost.hide (Some ({
@@ -1710,20 +1732,20 @@ let mk_array_of_ref' (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm
 
 #restart-solver
 let mk_array_of_ref'_correct
-  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
   (g_ref_of_array (mk_array_of_ref' r perm_ref) == r)
 =
   g_ref_of_array'_correct (mk_array_of_ref' r perm_ref);
   array_conn_id t one_size;
-  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn t);
-  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn t) (array_as_one_ref_conn t);
-  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t);
+  Steel.C.Connection.connection_compose_id_left (array_as_one_ref_conn base t);
+  Steel.C.Ref.ref_focus_comp r (one_ref_as_array_conn base t) (array_as_one_ref_conn base t);
+  Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t);
   Steel.C.Ref.ref_focus_id r
 
 #restart-solver
 let array_as_ref_eq_base_ref
-  (#t:Type0) (a: array t)
+  (#base: Type) (#t:Type0) (a: array base t)
 : Lemma
   (requires (
     array__base_len a == one_size /\
@@ -1739,7 +1761,7 @@ let array_as_ref_eq_base_ref
 
 #restart-solver
 let array_as_ref_mk_array_of_ref'
-  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (perm_ref: Steel.Reference.ghost_ref unit)
 : Lemma
   (ensures (
     let x = mk_array_of_ref' r perm_ref in
@@ -1757,7 +1779,7 @@ let array_domain_one_size
 = ()
 
 #restart-solver
-let mk_array_of_ref_view_intro (#t:Type0)
+let mk_array_of_ref_view_intro (base: Type) (#t:Type0)
   (g: Ghost.erased t)
   (v: Ghost.erased (option t))
   (v' : Ghost.erased (array_pcm_carrier t one_size))
@@ -1765,7 +1787,7 @@ let mk_array_of_ref_view_intro (#t:Type0)
 : Lemma
   (requires (
     Ghost.reveal v == (Steel.C.Opt.opt_view t).Steel.C.Ref.to_carrier (Ghost.reveal g) /\
-    Ghost.reveal v' == (array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
+    Ghost.reveal v' == (array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v) /\
     Ghost.reveal g' == Seq.create 1 (Ghost.reveal g)
   ))
   (ensures (
@@ -1776,27 +1798,27 @@ let mk_array_of_ref_view_intro (#t:Type0)
   )
 
 let mk_array_of_ref_to'
-  (t:Type0)
-: Tot (array_or_null_to t)
+  (base: Type) (t:Type0)
+: Tot (array_or_null_to base t)
 = Some ({
     to = one_size;
     perm_val = Steel.FractionalPermission.full_perm;
   })
 
 let mk_array_of_ref_from_spec
-  #t r from
+  #base #t r from
 =
-  let a = (from, mk_array_of_ref_to' t) in
+  let a = (from, mk_array_of_ref_to' base t) in
   array_or_null_spec a /\
   g_is_null a == false /\
   array__base_len a == one_size /\
   array__from a == zero_size /\
-  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn t
+  array__base_ref a == r `Steel.C.Ref.ref_focus` one_ref_as_array_conn base t
 
-let mk_array_of_ref_to #t r from = mk_array_of_ref_to' t
+let mk_array_of_ref_to #base #t r from = mk_array_of_ref_to' base t
 
-val mk_array_of_ref0 (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (array t)
+val mk_array_of_ref0 (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array base t)
              false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
@@ -1811,17 +1833,17 @@ val mk_array_of_ref0 (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.
 
 #restart-solver
 let mk_array_of_ref0
-  #t r
+  #base #t r
 =
   let g : Ghost.erased t = gget (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t)) in
   let v : Ghost.erased (option t) = Steel.C.Ref.pts_to_view_elim r (Steel.C.Opt.opt_view t) in
-  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
-  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
-    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso t)
+  let v' : Ghost.erased (array_pcm_carrier t one_size) = Ghost.hide ((array_as_one_ref_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v)) in
+  let _ : squash (Ghost.reveal v == (one_ref_as_array_conn base t).Steel.C.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v')) =
+    Steel.C.Connection.connection_of_isomorphism_inverse_left (array_as_one_ref_iso base t)
   in
-  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn t) v v' in
+  let r' = Steel.C.Ref.focus r (one_ref_as_array_conn base t) v v' in
   let perm_ref = Steel.Reference.ghost_alloc #unit () in
-  let res : array t = (Some ({
+  let res : array base t = (Some ({
     base_len = one_size;
     base_ref = r';
     from = zero_size;
@@ -1836,7 +1858,7 @@ let mk_array_of_ref0
   let g' : Ghost.erased (array_view_type t one_size) =
     Ghost.hide (Seq.create 1 (Ghost.reveal g))
   in
-  mk_array_of_ref_view_intro g v v' g' ;
+  mk_array_of_ref_view_intro base g v v' g' ;
   Steel.C.Ref.pts_to_view_intro
     _
     _
@@ -1853,7 +1875,7 @@ let mk_array_of_ref0
   return res
 
 let mk_array_of_ref_from
-  #t r
+  #base #t r
 =
   let a = mk_array_of_ref0 r in
   let res = fst a in
@@ -1865,16 +1887,16 @@ let mk_array_of_ref_from
 #pop-options
 
 let varray_or_null0_rewrite
-  (#a: Type0)
-  (r: array_or_null a)
+  (#base #a: Type0)
+  (r: array_or_null base a)
   (_: t_of emp)
 : Tot (option (array_view_type a (len r)))
 = None
 
 [@@__steel_reduce__]
 let varray_or_null0
-  (#a: Type0)
-  (r: array_or_null a)
+  (#base #a: Type0)
+  (r: array_or_null base a)
 : Tot vprop
 = if g_is_null r
   then emp `vrewrite` varray_or_null0_rewrite r
@@ -1953,7 +1975,7 @@ let elim_varray_or_null_none x =
 
 #restart-solver
 let freeable
-  #t a
+  #base #t a
 =
   Steel.C.Ref.freeable (array__base_ref a) /\
   size_v (array__base_len a) > 0 /\
@@ -1975,8 +1997,8 @@ let malloc_to'
  (#t: Type0)
   (x: t)
   (n: size_t)
-  (from: array_or_null_from t)
-: Tot (array_or_null_to t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Tot (array_or_null_to (array_pcm_carrier t n) t)
 = if None? from
   then None
   else Some ({
@@ -1997,7 +2019,7 @@ val malloc0
   (#t: Type0)
   (x: t)
   (n: size_t)
-: Steel (array_or_null t)
+: Steel (array_or_null (array_pcm_carrier t n) t)
     emp
     (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
@@ -2031,8 +2053,9 @@ let malloc_from
   return res
  
 val free0
+  (#base: Type0)
   (#t: Type0)
-  (a: array t)
+  (a: array base t)
 : Steel unit
     (varray a)
     (fun _ -> emp)
@@ -2042,11 +2065,12 @@ val free0
 #restart-solver
 #push-options "--print_implicits"
 let free0
-  #t a
+  #base #t a
 =
   let r = (array__base_ref a) in
   elim_varray r a ();
   let v = Steel.C.Ref.pts_to_view_elim
+    #_
     #_
     #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
@@ -2054,15 +2078,16 @@ let free0
     (array_view t (array__base_len a))
   in
   Steel.C.Ref.ref_free
+    #_
     #(array_pcm_carrier t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #(array_pcm t (Ghost.hide (Ghost.reveal (array__base_len a))))
     #v
     r
 
 let free_from
-  #t a a' sq
+  #base #t a a' sq
 =
-  let a0 : array t = (a, a') in
+  let a0 : array base t = (a, a') in
   change_equal_slprop
     (varray (a, a'))
     (varray a0);
diff --git a/ulib/experimental/Steel.C.Array.Base.fsti b/ulib/experimental/Steel.C.Array.Base.fsti
index 5b04af13198..0ee4a517278 100644
--- a/ulib/experimental/Steel.C.Array.Base.fsti
+++ b/ulib/experimental/Steel.C.Array.Base.fsti
@@ -58,42 +58,42 @@ val array_view (t: Type u#0) (n: size_t)
 /// - a pure part, which represents the beginning of the array, and should extract to t*
 /// - a ghost part, which represents the end of the array, and should be erased at extraction
 /// - a refinement, because KaRaMeL does not support inlining of dependent pair types where one part is ghost.
-val array_or_null_from (t: Type0) : Tot Type0
+val array_or_null_from (base: Type0) (t: Type0) : Tot Type0
 [@@erasable]
-val array_or_null_to (t: Type0) : Tot Type0
-val array_or_null_spec (#t: Type0) (x: (array_or_null_from t & array_or_null_to t)) : Tot prop
+val array_or_null_to (base: Type0) (t: Type0) : Tot Type0
+val array_or_null_spec (#base: Type0) (#t: Type0) (x: (array_or_null_from base t & array_or_null_to base t)) : Tot prop
 inline_for_extraction
-let array_or_null (t: Type u#0) : Type u#0 = (x: (array_or_null_from t & array_or_null_to t) { array_or_null_spec x })
+let array_or_null (base: Type u#0) (t: Type u#0) : Type u#0 = (x: (array_or_null_from base t & array_or_null_to base t) { array_or_null_spec x })
 
 /// Returns the length of the array. Usable for specification and proof purposes,
 /// as modeled by the GTot effect
-val len (#t: Type) (a: array_or_null t) : GTot size_t
-let length (#t: Type) (a: array_or_null t) : GTot nat = size_v (len a)
+val len (#base: Type) (#t: Type) (a: array_or_null base t) : GTot size_t
+let length (#base: Type) (#t: Type) (a: array_or_null base t) : GTot nat = size_v (len a)
 
 
-val null_from (t: Type u#0) : Tot (array_or_null_from t) 
-val null_to (t: Type u#0) : Pure (array_or_null_to t) (requires True) (ensures (fun r0 ->
-  array_or_null_spec (null_from t, r0) /\
-  len (null_from t, r0) == zero_size))
+val null_from (base: Type u#0) (t: Type u#0) : Tot (array_or_null_from base t) 
+val null_to (base: Type u#0) (t: Type u#0) : Pure (array_or_null_to base t) (requires True) (ensures (fun r0 ->
+  array_or_null_spec (null_from base t, r0) /\
+  len (null_from base t, r0) == zero_size))
 
 val null_to_unique
-  (#t: Type)
-  (to: array_or_null_to t)
+  (#base #t: Type)
+  (to: array_or_null_to base t)
 : Lemma
   (requires (
-    array_or_null_spec (null_from t, to)
+    array_or_null_spec (null_from base t, to)
   ))
   (ensures (
-    to == null_to t
+    to == null_to base t
   ))
 
 inline_for_extraction
-let null (t: Type u#0) : Pure (array_or_null t) (requires True) (ensures (fun r -> len r == zero_size))
-= (null_from t, null_to t)
-val g_is_null (#t: Type) (a: array_or_null t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null t))
+let null (base: Type u#0) (t: Type u#0) : Pure (array_or_null base t) (requires True) (ensures (fun r -> len r == zero_size))
+= (null_from base t, null_to base t)
+val g_is_null (#base: Type) (#t: Type) (a: array_or_null base t) : Ghost bool (requires True) (ensures (fun res -> res == true <==> a == null base t))
 inline_for_extraction
 noextract
-let array (t:Type u#0) : Type u#0 = (a: array_or_null t { g_is_null a == false })
+let array (base: Type u#0) (t:Type u#0) : Type u#0 = (a: array_or_null base t { g_is_null a == false })
 
 val array_is_unit (t: Type0) (n: size_t) (a: array_pcm_carrier t n)
 : b:bool{b <==> a == one (array_pcm t n)}
@@ -110,35 +110,35 @@ let array_typedef_sized (t: Type0) (n': Type0) (n: size_t_of n'{size_v n > 0}):
 /// Combining the elements above to create an array vprop
 /// TODO: generalize to any view
 
-// val g_array_as_ref (#t: Type u#0) (a: array t)
-//   : GTot (Steel.C.Reference.ref (array_view_type t (len a)) (array_pcm t (len a)))
+// val g_array_as_ref (#base: Type u#0) (#t: Type u#0) (a: array base t)
+//   : GTot (Steel.C.Reference.ref base (array_view_type t (len a)) (array_pcm t (len a)))
 
 // [@@ __steel_reduce__]
-// let varray (#t: Type) (x: array t) : Tot vprop
+// let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop
 // = Steel.C.Ref.pts_to_view (g_array_as_ref x) (array_view t (len x))
 
-val varray_hp (#t: Type0) (x: array t) : Tot (slprop u#1)
+val varray_hp (#base: Type0) (#t: Type0) (x: array base t) : Tot (slprop u#1)
 
-val varray_sel (#t: Type0) (x: array t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
+val varray_sel (#base: Type0) (#t: Type0) (x: array base t) : GTot (selector (array_view_type t (len x)) (varray_hp x))
 
 [@@ __steel_reduce__ ]
-let varray' (#t: Type) (x: array t) : GTot vprop' = {
+let varray' (#base: Type) (#t: Type) (x: array base t) : GTot vprop' = {
   hp = varray_hp x;
   t = array_view_type t (len x);
   sel = varray_sel x;
 }
 
 [@@ __steel_reduce__ ]
-let varray (#t: Type) (x: array t) : Tot vprop =
+let varray (#base: Type) (#t: Type) (x: array base t) : Tot vprop =
   VUnit (varray' x)
 
-val g_mk_array (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
-  (a: array t)
+val g_mk_array (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array base t)
 : Tot prop
 
 val g_mk_array_weak
-  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
-  (a: array t)
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array base t)
 : Lemma
   (requires (g_mk_array r a))
   (ensures (
@@ -148,14 +148,14 @@ val g_mk_array_weak
   [SMTPat (g_mk_array r a)]
 
 val g_mk_array_from
-  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from t)
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
 : Tot prop
 
 val g_mk_array_to
-  (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
-  (a: array_or_null_from t)
-: Pure (array_or_null_to t)
+  (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
+  (a: array_or_null_from base t)
+: Pure (array_or_null_to base t)
   (requires (g_mk_array_from r a))
   (ensures (fun a' ->
     let a0 = (a, a') in
@@ -164,9 +164,9 @@ val g_mk_array_to
     g_mk_array r a0
   ))
 
-val intro_varray_from (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+val intro_varray_from (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: SteelAtomicBase (al: array_or_null_from t { g_mk_array_from r al })
+: SteelAtomicBase (al: array_or_null_from base t { g_mk_array_from r al })
     false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun al -> varray (al, g_mk_array_to r al))
@@ -178,9 +178,9 @@ val intro_varray_from (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Refer
   ))
 
 inline_for_extraction
-let intro_varray (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n))
+let intro_varray (#base: Type u#0) (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n))
   (_: squash (size_v n > 0))
-: SteelAtomicBase (array t)
+: SteelAtomicBase (array base t)
   false opened Unobservable
     (Steel.C.Ref.pts_to_view r (array_view t n))
     (fun a -> varray a)
@@ -197,7 +197,7 @@ let intro_varray (#t: Type u#0) (#opened: _) (#n: size_t) (r: Steel.C.Reference.
     (varray a);
   return a
 
-val elim_varray (#inames: _) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref (array_view_type t n) (array_pcm t n)) (a: array t) (_: squash (size_v n > 0))
+val elim_varray (#inames: _) (#base: Type u#0) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.ref base (array_view_type t n) (array_pcm t n)) (a: array base t) (_: squash (size_v n > 0))
 : SteelGhost unit inames
   (varray a)
   (fun _ -> Steel.C.Ref.pts_to_view r (array_view t n))
@@ -210,14 +210,16 @@ val elim_varray (#inames: _) (#t: Type u#0) (#n: size_t) (r: Steel.C.Reference.r
 /// Splitting an array into subarrays
 
 val adjacent
+  (#base: Type)
   (#t: Type)
-  (r1 r2: array t)
+  (r1 r2: array base t)
 : Tot prop
 
 val merge
+  (#base: Type)
   (#t: Type)
-  (r1 r2: array t)
-: Ghost (array t)
+  (r1 r2: array base t)
+: Ghost (array base t)
   (requires (adjacent r1 r2))
   (ensures (fun r ->
     length r == length r1 + length r2 /\
@@ -225,15 +227,17 @@ val merge
   ))
 
 let merge_into
+  (#base: Type)
   (#t: Type)
-  (r1 r2 r3: array t)
+  (r1 r2 r3: array base t)
 : Tot prop
 = adjacent r1 r2 /\
   merge r1 r2 == r3
 
 val merge_assoc
+  (#base: Type)
   (#t: Type)
-  (r1 r2 r3: array t)
+  (r1 r2 r3: array base t)
 : Lemma
   (requires (
     (adjacent r1 r2 /\ (adjacent r2 r3 \/ adjacent (merge r1 r2) r3)) \/
@@ -251,23 +255,25 @@ val merge_assoc
   [SMTPat (merge (merge r1 r2) r3)]
 
 val merge_inj_right
+  (#base: Type)
   (#t: Type)
-  (a b1 b2: array t)
+  (a b1 b2: array base t)
 : Lemma
   (requires (adjacent a b1 /\ adjacent a b2 /\ merge a b1 == merge a b2))
   (ensures (b1 == b2))
 
 val merge_inj_left
+  (#base: Type)
   (#t: Type)
-  (a1 a2 b: array t)
+  (a1 a2 b: array base t)
 : Lemma
   (requires (adjacent a1 b /\ adjacent a2 b /\ merge a1 b == merge a2 b))
   (ensures (a1 == a2))
 
-val no_self_merge_1 (#t: Type) (a b: array t) : Lemma
+val no_self_merge_1 (#base #t: Type) (a b: array base t) : Lemma
   (~ (merge_into a b a))
 
-val no_self_merge_2 (#t: Type) (a b: array t) : Lemma
+val no_self_merge_2 (#base #t: Type) (a b: array base t) : Lemma
   (~ (merge_into a b b))
 
 [@erasable]
@@ -275,18 +281,19 @@ noeq
 type gpair (a b: Type) = | GPair: (fst: a) -> (snd: b) -> gpair a b
 
 val gsplit
+  (#base: Type)
   (#t: Type)
-  (r: array t)
+  (r: array base t)
   (i: size_t)
-: Ghost (array t `gpair` array t)
+: Ghost (array base t `gpair` array base t)
   (requires (size_v i <= length r))
   (ensures (fun (GPair rl rr) ->
     merge_into rl rr r /\
     length rl == size_v i
   ))
 
-val split' (#opened: _) (#t:Type) (a:array t) (i:size_t)
-  : SteelGhost (array t `gpair` array t) opened
+val split' (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
+  : SteelGhost (array base t `gpair` array base t) opened
           (varray a)
           (fun res -> varray (GPair?.fst res) `star` varray (GPair?.snd res))
           (fun _ -> size_v i <= length a)
@@ -302,9 +309,9 @@ val split' (#opened: _) (#t:Type) (a:array t) (i:size_t)
           )
 
 inline_for_extraction
-let split_left (#t:Type) (#opened: _) (a:array t)
-  (al ar: Ghost.erased (array t))
-  : SteelAtomicBase (array t) false opened Unobservable
+let split_left (#base: _) (#t:Type) (#opened: _) (a:array base t)
+  (al ar: Ghost.erased (array base t))
+  : SteelAtomicBase (array base t) false opened Unobservable
           (varray al)
           (fun res -> varray res)
           (fun _ ->
@@ -322,8 +329,8 @@ let split_left (#t:Type) (#opened: _) (a:array t)
       (varray res);
     return res
 
-val split_right_from (#t:Type) (#opened: _) (a:array t) (i:size_t)
-  : SteelAtomicBase (array_or_null_from t) false opened Unobservable
+val split_right_from (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array_or_null_from base t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
           (fun _ -> size_v i <= length a)
@@ -334,8 +341,8 @@ val split_right_from (#t:Type) (#opened: _) (a:array t) (i:size_t)
           )
 
 inline_for_extraction
-let split_right (#t:Type) (#opened: _) (a:array t) (i:size_t)
-  : SteelAtomicBase (array t) false opened Unobservable
+let split_right (#base: _) (#t:Type) (#opened: _) (a:array base t) (i:size_t)
+  : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
           (fun _ -> varray a)
           (fun _ -> size_v i <= length a)
@@ -349,8 +356,8 @@ let split_right (#t:Type) (#opened: _) (a:array t) (i:size_t)
   return res
 
 inline_for_extraction
-let split (#opened: _) (#t:Type) (a:array t) (i:size_t) (sq: squash (size_v i <= length a))
-  : SteelAtomicBase (array t) false opened Unobservable
+let split (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t) (sq: squash (size_v i <= length a))
+  : SteelAtomicBase (array base t) false opened Unobservable
           (varray a)
           (fun res -> varray (Ghost.reveal (Ghost.hide (GPair?.fst (gsplit a i))))
           `star` varray res)
@@ -376,8 +383,8 @@ let split (#opened: _) (#t:Type) (a:array t) (i:size_t) (sq: squash (size_v i <=
     (varray sr);
   return sr
 
-val join' (#opened: _) (#t:Type) (al ar:array t)
-  : SteelGhost (Ghost.erased (array t)) opened
+val join' (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelGhost (Ghost.erased (array base t)) opened
           (varray al `star` varray ar)
           (fun a -> varray a)
           (fun _ -> adjacent al ar)
@@ -388,8 +395,8 @@ val join' (#opened: _) (#t:Type) (al ar:array t)
           )
 
 inline_for_extraction
-let joinc (#t:Type) (#opened: _) (al ar:array t)
-  : SteelAtomicBase (array t) false opened Unobservable
+let joinc (#base: _) (#t:Type) (#opened: _) (al ar:array base t)
+  : SteelAtomicBase (array base t) false opened Unobservable
           (varray al `star` varray ar)
           (fun a -> varray al `star` varray ar)
           (fun _ -> adjacent al ar)
@@ -404,8 +411,8 @@ let joinc (#t:Type) (#opened: _) (al ar:array t)
     return res
 
 inline_for_extraction
-let join (#opened: _) (#t:Type) (al ar:array t)
-  : SteelAtomicBase (array t) false opened Unobservable
+let join (#opened: _) (#base: _) (#t:Type) (al ar:array base t)
+  : SteelAtomicBase (array base t) false opened Unobservable
           (varray al `star` varray ar)
           (fun a -> varray a)
           (fun _ -> adjacent al ar)
@@ -426,18 +433,18 @@ let join (#opened: _) (#t:Type) (al ar:array t)
 /// Those two functions should extract to identity functions
 
 val g_ref_of_array
-  (#t:Type0) (r:array t)
-: Ghost (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+  (#base: Type) (#t:Type0) (r:array base t)
+: Ghost (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
   (requires (length r == 1))
   (ensures (fun _ -> True))
 
 val v_ref_of_array
-  (#t:Type0) (r:array t)
+  (#base: Type) (#t:Type0) (r:array base t)
 : Ghost vprop
   (requires (length r == 1))
   (ensures (fun _ -> True))
 
-val ref_of_array_ghost (#inames: _) (#t:Type0) (r:array t) (sq: squash (length r == 1))
+val ref_of_array_ghost (#inames: _) (#base: Type) (#t:Type0) (r:array base t) (sq: squash (length r == 1))
   : SteelGhost unit inames
              (varray r)
              (fun _ -> Steel.C.Ref.pts_to_view (g_ref_of_array r) (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
@@ -449,8 +456,8 @@ val ref_of_array_ghost (#inames: _) (#t:Type0) (r:array t) (sq: squash (length r
                h1 (Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t)) == Seq.index s 0
              )
 
-val ref_of_array_from (#t:Type0) (#opened: _) (r_from:array_or_null_from t) (r_to: array_or_null_to t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
-  : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+val ref_of_array_from (#base: Type) (#t:Type0) (#opened: _) (r_from:array_or_null_from base t) (r_to: array_or_null_to base t) (sq: squash (let r = (r_from, r_to) in array_or_null_spec r /\ length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
     false opened Unobservable
              (varray (r_from, r_to))
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array (r_from, r_to))
@@ -464,8 +471,8 @@ val ref_of_array_from (#t:Type0) (#opened: _) (r_from:array_or_null_from t) (r_t
              )
 
 inline_for_extraction
-let ref_of_array (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1))
-  : SteelAtomicBase (Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
+let ref_of_array (#base: Type) (#t:Type0) (#opened: _) (r:array base t) (sq: squash (length r == 1))
+  : SteelAtomicBase (Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
     false opened Unobservable
              (varray r)
              (fun r' -> Steel.C.Ref.pts_to_view r' (Steel.C.Opt.opt_view t) `star` v_ref_of_array r)
@@ -487,7 +494,7 @@ let ref_of_array (#t:Type0) (#opened: _) (r:array t) (sq: squash (length r == 1)
       (v_ref_of_array r);
     return res
 
-val array_of_ref (#inames: _) (#t:Type0) (r': array t) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
+val array_of_ref (#inames: _) (#base: Type) (#t:Type0) (r': array base t) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t)) (sq: squash (length r' == 1))
   : SteelGhost unit inames
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t) `star` v_ref_of_array r')
              (fun _ -> varray r')
@@ -502,14 +509,14 @@ val array_of_ref (#inames: _) (#t:Type0) (r': array t) (r: Steel.C.Reference.ref
 // this function should be used only to pass a pointer as an argument to a function that expects an array
 
 val mk_array_of_ref_from_spec
-  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
-  (from: array_or_null_from t)
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from base t)
 : Tot prop
 
 val mk_array_of_ref_to
-  (#t:Type0) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
-  (from: array_or_null_from t)
-: Pure (array_or_null_to t)
+  (#base: Type) (#t:Type0) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  (from: array_or_null_from base t)
+: Pure (array_or_null_to base t)
   (requires (mk_array_of_ref_from_spec r from))
   (ensures (fun to ->
     let r' = (from, to) in
@@ -517,8 +524,8 @@ val mk_array_of_ref_to
     g_is_null r' == false
   ))
 
-val mk_array_of_ref_from (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (r0: array_or_null_from t { mk_array_of_ref_from_spec r r0 })
+val mk_array_of_ref_from (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (r0: array_or_null_from base t { mk_array_of_ref_from_spec r r0 })
     false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r0 -> varray (r0, mk_array_of_ref_to r r0))
@@ -532,8 +539,8 @@ val mk_array_of_ref_from (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (St
              )
 
 inline_for_extraction
-let mk_array_of_ref (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C.Opt.opt_pcm #t))
-  : SteelAtomicBase (array t)
+let mk_array_of_ref (#base: Type) (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref base t (Steel.C.Opt.opt_pcm #t))
+  : SteelAtomicBase (array base t)
     false opened Unobservable
              (Steel.C.Ref.pts_to_view r (Steel.C.Opt.opt_view t))
              (fun r' -> varray r')
@@ -551,11 +558,11 @@ let mk_array_of_ref (#t:Type0) (#opened: _) (r: Steel.C.Reference.ref t (Steel.C
     (varray r');
   return r'
 
-val is_array_or_null (#a:Type0) (r:array_or_null a) : slprop u#1
-val array_or_null_sel (#a:Type0) (r:array_or_null a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
+val is_array_or_null (#base #a:Type0) (r:array_or_null base a) : slprop u#1
+val array_or_null_sel (#base #a:Type0) (r:array_or_null base a) : GTot (selector (option (array_view_type a (len r))) (is_array_or_null r))
 
 [@@ __steel_reduce__]
-let varray_or_null' #a (r: array_or_null a) : GTot vprop' =
+let varray_or_null' #base #a (r: array_or_null base a) : GTot vprop' =
   {hp = is_array_or_null r;
    t = option (array_view_type a (len r));
    sel = array_or_null_sel r}
@@ -565,8 +572,8 @@ let varray_or_null r = VUnit (varray_or_null' r)
 
 val intro_varray_or_null_none
   (#opened: _)
-  (#a: Type)
-  (x: array_or_null a)
+  (#base #a: Type)
+  (x: array_or_null base a)
 : SteelGhost unit opened
     emp
     (fun _ -> varray_or_null x)
@@ -575,8 +582,8 @@ val intro_varray_or_null_none
 
 val intro_varray_or_null_some
   (#opened: _)
-  (#a: Type)
-  (x: array a)
+  (#base #a: Type)
+  (x: array base a)
 : SteelGhost unit opened
     (varray x)
     (fun _ -> varray_or_null x)
@@ -588,8 +595,8 @@ val intro_varray_or_null_some
 
 val elim_varray_or_null_some
   (#opened: _)
-  (#a: Type)
-  (x: array_or_null a)
+  (#base #a: Type)
+  (x: array_or_null base a)
 : SteelGhost (squash (g_is_null x == false)) opened
     (varray_or_null x)
     (fun _ -> varray x)
@@ -601,8 +608,8 @@ val elim_varray_or_null_some
 
 val elim_varray_or_null_none
   (#opened: _)
-  (#a: Type)
-  (x: array_or_null a)
+  (#base #a: Type)
+  (x: array_or_null base a)
 : SteelGhost unit opened
     (varray_or_null x)
     (fun _ -> emp)
@@ -615,23 +622,24 @@ val elim_varray_or_null_none
 /// Allocates an array of size [n] where all cells have initial value [x]
 
 val freeable
+  (#base: Type0)
   (#t: Type0)
-  (a: array t)
+  (a: array base t)
 : Tot prop
 
 val malloc_from_spec
   (#t: Type0)
   (x: t)
   (n: size_t)
-  (from: array_or_null_from t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
 : Tot prop
 
 val malloc_to
   (#t: Type0)
   (x: t)
   (n: size_t)
-  (from: array_or_null_from t)
-: Pure (array_or_null_to t)
+  (from: array_or_null_from (array_pcm_carrier t n) t)
+: Pure (array_or_null_to (array_pcm_carrier t n) t)
     (requires (size_v n > 0 /\ malloc_from_spec x n from))
     (ensures (fun to -> array_or_null_spec (from, to)))
 
@@ -640,13 +648,13 @@ val malloc_from
   (x: t)
   (n: size_t)
   (sq: squash (size_v n > 0))
-: Steel (from: array_or_null_from t { malloc_from_spec x n from })
+: Steel (from: array_or_null_from (array_pcm_carrier t n) t { malloc_from_spec x n from })
     emp
     (fun r -> varray_or_null (r, malloc_to x n r))
     (requires fun _ -> True)
     (ensures fun _ r0 h' ->
       size_v n > 0 /\
-      begin let r : array_or_null t = (r0, malloc_to x n r0) in
+      begin let r : array_or_null (array_pcm_carrier t n) t = (r0, malloc_to x n r0) in
       g_is_null r == false ==> (freeable r /\ len r == n /\ h' (varray_or_null r) == Some (Seq.create (size_v n) x))
       end
     )
@@ -656,7 +664,7 @@ let malloc
   (#t: Type0)
   (x: t)
   (n: size_t)
-: Steel (array_or_null t)
+: Steel (array_or_null (array_pcm_carrier t n) t)
     emp
     (fun r -> varray_or_null r)
     (requires fun _ -> size_v n > 0)
@@ -671,9 +679,10 @@ let malloc
   return r
 
 val free_from
+  (#base: Type0)
   (#t: Type0)
-  (a: array_or_null_from t)
-  (a' : array_or_null_to t)
+  (a: array_or_null_from base t)
+  (a' : array_or_null_to base t)
   (sq: squash (array_or_null_spec (a, a') /\ g_is_null (a, a') == false))
 : Steel unit
     (varray (a, a'))
@@ -683,8 +692,9 @@ val free_from
 
 inline_for_extraction
 let free
+  (#base: Type0)
   (#t: Type0)
-  (a: array t)
+  (a: array base t)
 : Steel unit
     (varray a)
     (fun _ -> emp)
@@ -698,10 +708,11 @@ let free
     free_from af a' ()
 
 val is_null_from
+  (#base: Type0)
   (#t: Type0)
   (#opened: _)
-  (a: array_or_null_from t)
-  (a' : array_or_null_to t)
+  (a: array_or_null_from base t)
+  (a' : array_or_null_to base t)
   (sq: squash (array_or_null_spec (a, a')))
 : SteelAtomicBase bool false opened Unobservable
     (varray_or_null (a, a'))
@@ -714,9 +725,10 @@ val is_null_from
 
 inline_for_extraction
 let is_null
+  (#base: Type0)
   (#t: Type0)
   (#opened: _)
-  (a: array_or_null t)
+  (a: array_or_null base t)
 : SteelAtomicBase bool false opened Unobservable
     (varray_or_null a)
     (fun _ -> varray_or_null a)
diff --git a/ulib/experimental/Steel.C.Array.fst b/ulib/experimental/Steel.C.Array.fst
index 61ad058a37f..1f122de960d 100644
--- a/ulib/experimental/Steel.C.Array.fst
+++ b/ulib/experimental/Steel.C.Array.fst
@@ -12,7 +12,7 @@ let seq_equal_1
   (ensures (s1 == s2))
 = assert (s1 `Seq.equal` s2)
 
-val index0 (#t:Type) (r:array t) (i:size_t)
+val index0 (#base: Type) (#t:Type) (r:array base t) (i:size_t)
   : Steel t
              (varray r)
              (fun _ -> varray r)
@@ -27,7 +27,7 @@ val index0 (#t:Type) (r:array t) (i:size_t)
 #restart-solver
 
 let index0
-  #t r i
+  #_ #t r i
 =
   let rr = split r i () in
   let rrr = split rr one_size () in
@@ -49,9 +49,9 @@ let index0
   return res
 
 let index_from
-  #t r r' i
+  #base #t r r' i
 =
-  let r0 : array t = (r, r') in
+  let r0 : array base t = (r, r') in
   change_equal_slprop
     (varray (r, r'))
     (varray r0);
@@ -80,7 +80,7 @@ let seq_append_append_upd
     (s1 `Seq.append` (s2' `Seq.append` s3)) `Seq.equal` (Seq.upd (s1 `Seq.append` (s2 `Seq.append` s3)) i x)
   )
 
-val upd0 (#t:Type) (r:array t) (i:size_t) (x:t)
+val upd0 (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
   : Steel unit
              (varray r)
              (fun _ -> varray r)
@@ -90,7 +90,7 @@ val upd0 (#t:Type) (r:array t) (i:size_t) (x:t)
                h1 (varray r) == Seq.upd (h0 (varray r)) (size_v i) x)
 
 let upd0
-  #t r i x
+  #_ #t r i x
 =
   let rr = split r i () in
   let rrr = split rr one_size () in
@@ -113,9 +113,9 @@ let upd0
     (varray r)
 
 let upd_from
-  #t r r' i x
+  #base #t r r' i x
 =
-  let r0 : array t = (r, r') in
+  let r0 : array base t = (r, r') in
   change_equal_slprop
     (varray (r, r'))
     (varray r0);
@@ -125,8 +125,8 @@ let upd_from
     (varray (r, r'))
 
 let varray_or_null0_rewrite
-  (#a: Type0)
-  (r: array_or_null a)
+  (#base #a: Type0)
+  (r: array_or_null base a)
   (_: t_of emp)
 : Tot (option (array_view_type a (len r)))
 = None
diff --git a/ulib/experimental/Steel.C.Array.fsti b/ulib/experimental/Steel.C.Array.fsti
index edcc94a302a..1d2227358c8 100644
--- a/ulib/experimental/Steel.C.Array.fsti
+++ b/ulib/experimental/Steel.C.Array.fsti
@@ -32,7 +32,7 @@ open Steel.C.Typenat
 /// Accesses index [i] in array [r], as long as [i] is in bounds and the array
 /// is currently valid in memory
 
-val index_from (#t:Type) (r:array_or_null_from t) (r' : array_or_null_to t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t)
+val index_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_or_null_to base t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t)
   : Steel t
              (varray (r, r'))
              (fun _ -> varray (r, r'))
@@ -44,7 +44,7 @@ val index_from (#t:Type) (r:array_or_null_from t) (r' : array_or_null_to t { arr
                x == Seq.index s (size_v i))
 
 inline_for_extraction
-let index (#t:Type) (r:array t) (i:size_t)
+let index (#base: Type) (#t:Type) (r:array base t) (i:size_t)
   : Steel t
              (varray r)
              (fun _ -> varray r)
@@ -70,7 +70,7 @@ let index (#t:Type) (r:array t) (i:size_t)
 /// is in bounds and the array is currently valid in memory
 
 
-val upd_from (#t:Type) (r:array_or_null_from t) (r' : array_or_null_to t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t) (x:t)
+val upd_from (#base: Type) (#t:Type) (r:array_or_null_from base t) (r' : array_or_null_to base t { array_or_null_spec (r, r') /\ g_is_null (r, r') == false }) (i:size_t) (x:t)
   : Steel unit
              (varray (r, r'))
              (fun _ -> varray (r, r'))
@@ -80,7 +80,7 @@ val upd_from (#t:Type) (r:array_or_null_from t) (r' : array_or_null_to t { array
                h1 (varray (r, r')) == Seq.upd (h0 (varray (r, r'))) (size_v i) x)
 
 inline_for_extraction
-let upd (#t:Type) (r:array t) (i:size_t) (x:t)
+let upd (#base: Type) (#t:Type) (r:array base t) (i:size_t) (x:t)
   : Steel unit
              (varray r)
              (fun _ -> varray r)
diff --git a/ulib/experimental/Steel.C.Frac.fsti b/ulib/experimental/Steel.C.Frac.fsti
index 8e985451cd9..356ef323ede 100644
--- a/ulib/experimental/Steel.C.Frac.fsti
+++ b/ulib/experimental/Steel.C.Frac.fsti
@@ -46,15 +46,15 @@ let frac_pcm_fpu
 = base_fpu pcm_frac x (Some (y, full_perm))
 
 val frac_pcm_write
-  (#b: Type)
-  (r: ref (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
   (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
   (ensures (fun _ _ _ -> True))
 
 val frac_pcm_read
-  (#b: Type)
-  (r: ref (pcm_frac #b)) (x: Ghost.erased (fractional b))
+  (#a:Type) (#b: Type)
+  (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
@@ -78,9 +78,9 @@ let frac_view
 }
 
 let frac_read_sel
-  (#b: Type u#0)
+  (#a: Type u#0) (#b: Type u#0)
   (#p: perm)
-  (r: ref (pcm_frac #b))
+  (r: ref a (pcm_frac #b))
 : Steel b
   (pts_to_view r (frac_view _ p))
   (fun _ -> pts_to_view r (frac_view _ p))
@@ -92,9 +92,9 @@ let frac_read_sel
 = ref_read_sel r (frac_view _ p)
 
 let frac_write_sel
-  (#b: Type u#0)
+  (#a: Type u#0) (#b: Type u#0)
   (#p: perm)
-  (r: ref (pcm_frac #b))
+  (r: ref a (pcm_frac #b))
   (w: b)
 : Steel unit
   (pts_to_view r (frac_view _ p))
diff --git a/ulib/experimental/Steel.C.Opt.fst b/ulib/experimental/Steel.C.Opt.fst
index cbedf3afcd1..deb15a5eb0f 100644
--- a/ulib/experimental/Steel.C.Opt.fst
+++ b/ulib/experimental/Steel.C.Opt.fst
@@ -8,14 +8,14 @@ let opt_read r =
   let Some x = ref_read r in
   x
 
-let opt_write #b #x r y =
+let opt_write #a #b #x r y =
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
   ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let opt_pcm_write
-  (#b: Type)
-  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
   (requires (fun _ -> Some? x))
   (ensures (fun _ _ _ -> True))
@@ -24,8 +24,8 @@ let opt_pcm_write
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 let opt_pcm_read
-  (#b: Type)
-  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b))
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Ghost.reveal x == Some y))
@@ -40,7 +40,7 @@ let malloc
   let xc = ((opt_view c).to_carrier x) in
   let r = Steel.C.Ref.ref_alloc _ xc in
   pts_to_view_intro r xc (opt_view c) x;
-  let r' : ref c (opt_pcm #c) = r in
+  let r' : ref (option c) c (opt_pcm #c) = r in
   A.change_equal_slprop
     (Steel.C.Ref.pts_to_view r (opt_view c))
     (pts_to_view r' (opt_view c));
@@ -50,6 +50,6 @@ let malloc
 let free
   #c r
 =
-  let r' : Steel.C.Ref.ref (opt_pcm #c) = r in 
+  let r' : Steel.C.Ref.ref (option c) (opt_pcm #c) = r in 
   let _ = pts_to_view_elim r (opt_view c) in
   Steel.C.Ref.ref_free r
diff --git a/ulib/experimental/Steel.C.Opt.fsti b/ulib/experimental/Steel.C.Opt.fsti
index f483f96e318..c9e9e6ece9a 100644
--- a/ulib/experimental/Steel.C.Opt.fsti
+++ b/ulib/experimental/Steel.C.Opt.fsti
@@ -35,8 +35,8 @@ let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
 let some_v (x: Ghost.erased (option 'a){Some? x}): Ghost.erased 'a = Some?.v x
 
 val opt_read
-  (#b:Type) (#x: Ghost.erased b)
-  (r: ref (opt_pcm #b))
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (opt_pcm #b))
 : Steel b
     (r `pts_to` Some #b x)
     (fun _ -> r `pts_to` Some #b x)
@@ -44,8 +44,8 @@ val opt_read
     (ensures fun _ x' _ -> Ghost.reveal x == x')
 
 val opt_write
-  (#b:Type) (#x: Ghost.erased b)
-  (r: ref (opt_pcm #b)) (y: b)
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (opt_pcm #b)) (y: b)
 : SteelT unit
     (r `pts_to` Some #b x)
     (fun _ -> r `pts_to` Some y)
@@ -94,22 +94,22 @@ let opt_pcm_fpu
 = base_fpu opt_pcm x (Some y)
 
 val opt_pcm_write
-  (#b: Type)
-  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
 : Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
   (requires (fun _ -> Some? x))
   (ensures (fun _ _ _ -> True))
 
 val opt_pcm_read
-  (#b: Type)
-  (r: ref (opt_pcm #b)) (x: Ghost.erased (option b))
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
 : Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
   (requires (fun _ -> Some? x))
   (ensures (fun _ y _ -> Ghost.reveal x == Some y))
 
 let opt_read_sel
-  (#b: Type u#0)
-  (r: ref (opt_pcm #b))
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a (opt_pcm #b))
 : Steel b
   (pts_to_view r (opt_view b))
   (fun _ -> pts_to_view r (opt_view b))
@@ -121,8 +121,8 @@ let opt_read_sel
 = ref_read_sel r (opt_view b)
 
 let opt_write_sel
-  (#b: Type u#0)
-  (r: ref (opt_pcm #b))
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a (opt_pcm #b))
   (w: b)
 : Steel unit
   (pts_to_view r (opt_view b))
@@ -139,8 +139,8 @@ let opt_write_sel
 open Steel.C.Reference
 
 let ref_opt_read
-  (#b: Type u#0)
-  (r: ref b (opt_pcm #b))
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a b (opt_pcm #b))
 : Steel b
   (pts_to_view r (opt_view b))
   (fun _ -> pts_to_view r (opt_view b))
@@ -152,8 +152,8 @@ let ref_opt_read
 = ref_read_sel r (opt_view b)
 
 let ref_opt_write
-  (#b: Type u#0)
-  (r: ref b (opt_pcm #b))
+  (#a: Type u#0) (#b: Type u#0)
+  (r: ref a b (opt_pcm #b))
   (w: b)
 : Steel unit
   (pts_to_view r (opt_view b))
@@ -166,7 +166,7 @@ let ref_opt_write
 
 val malloc
   (#c:Type0) (x: c)
-: Steel (ptr c (opt_pcm #c))
+: Steel (ptr (option c) c (opt_pcm #c))
     emp
     (fun r -> pts_to_view_or_null r (opt_view c))
     (requires fun _ -> True)
@@ -178,7 +178,7 @@ val malloc
 
 val free
   (#c: Type0)
-  (r: ref c (opt_pcm #c))
+  (r: ref (option c) c (opt_pcm #c))
 : Steel unit
     (pts_to_view r (opt_view c))
     (fun _ -> emp)
diff --git a/ulib/experimental/Steel.C.Ref.fst b/ulib/experimental/Steel.C.Ref.fst
index 8e9972f3cfe..1a6d19446e8 100644
--- a/ulib/experimental/Steel.C.Ref.fst
+++ b/ulib/experimental/Steel.C.Ref.fst
@@ -3,149 +3,64 @@ module P = FStar.PCM
 module U = Steel.C.Universe
 open FStar.FunctionalExtensionality
 
-module M = Steel.Memory
-module R = Steel.PCMReference
-module GHR = Steel.GhostPCMReference
-module RO = Steel.PCMReadOnly
-
 #push-options "--print_universes"
 
-let is_base_type
-  (r: GHR.ref _ (RO.pcm_readonly #Type0))
-  (i: M.iname)
-  (t0: Type)
-: Tot prop
-= (let open Steel.Effect.Atomic in ( >--> ))
-    i
-    (GHR.pts_to r (Some t0))
-
-let has_base_type
-  (r: GHR.ref _ (RO.pcm_readonly #Type0))
-  (i: M.iname)
-: Tot prop
-= exists (t0: Type) . is_base_type r i t0
-
-let has_base_type_intro
-  (r: GHR.ref _ (RO.pcm_readonly #Type0))
-  (i: M.iname)
-  (t0: Type)
-: Lemma
-  (requires ((let open Steel.Effect.Atomic in ( >--> )) i (GHR.pts_to r (Some t0))))
-  (ensures (has_base_type r i))
-= ()
-
-let get_base_type
-  (r: GHR.ref _ (RO.pcm_readonly #Type0))
-  (i: M.iname)
-: Pure Type
-    (requires (has_base_type r i))
-    (ensures (fun t0 -> is_base_type r i t0))
-= FStar.IndefiniteDescription.indefinite_description_ghost Type (fun t0 -> is_base_type r i t0)
-
-let with_invariant_g_f (#a:Type)
-                     (#fp:A.vprop)
-                     (#fp':a -> A.vprop)
-                     (#opened_invariants:M.inames)
-                     (#p:A.vprop)
-                     (i:A.inv p{not (A.mem_inv opened_invariants i)})
-                     (f:unit -> A.SteelGhostT a (A.add_inv opened_invariants i)
-                                         (p `A.star` fp)
-                                         (fun x -> p `A.star` fp' x))
-  : A.SteelGhostF a opened_invariants fp fp' (fun _ -> True) (fun _ _ _ -> True)
-= A.with_invariant_g i f
-
-let has_base_type_idem
-  (#opened: M.inames)
-  (r: GHR.ref _ (RO.pcm_readonly #Type0))
-  (i: M.iname)
-  (v: Type0)
-  (sq: squash (
-    not (A.mem_inv opened i) /\
-    has_base_type r i
-  ))
-: A.SteelGhostT (squash (v == get_base_type r i)) opened
-    (GHR.pts_to r (Some v))
-    (fun _ -> GHR.pts_to r (Some v))
-= with_invariant_g_f
-    #(squash (v == get_base_type r i))
-    #(GHR.pts_to r (Some v))
-    #(fun _ -> GHR.pts_to r (Some v))
-    #_
-    #(GHR.pts_to r (Some (get_base_type r i)))
-    i
-    (fun _ ->
-      GHR.gather r (Some v) _;
-      GHR.share r _ (Some v) (Some (get_base_type r i))
-    )
-
-noeq type ref0 (b: Type u#b) : Type u#b = {
-  base_type: GHR.ref _ (RO.pcm_readonly #Type0);
-  base_inv: Ghost.erased M.iname;
-  base_has_type: squash (has_base_type base_type base_inv);
-  p: pcm (get_base_type base_type base_inv);
+noeq type ref0 (a: Type u#0) (b: Type u#b) : Type u#b = {
+  p: pcm a;
   q: pcm b;
   pl: connection p q;
-  r: M.ref (U.raise_t (get_base_type base_type base_inv)) (fstar_pcm_of_pcm (U.raise_pcm p));
+  r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
 }
 
-noeq type ptr' (b: Type u#b) : Type u#b =
-  | NonNull: (v: ref0 b) -> ptr' b
-  | Null: (v: pcm b) -> ptr' b
+noeq type ptr' (a: Type u#0) (b: Type u#b) : Type u#b =
+  | NonNull: (v: ref0 a b) -> ptr' a b
+  | Null: (v: pcm b) -> ptr' a b
 
 let pcm_of_ptr'
+  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' b)
+  (r: ptr' a b)
 : Tot (pcm b)
 = if Null? r then Null?.v r else (NonNull?.v r).q
 
-let ptr #b p = (r: ptr' b { pcm_of_ptr' r == p })
+let ptr a #b p = (r: ptr' a b { pcm_of_ptr' r == p })
 
-let null p = Null p
+let null a p = Null p
 
 let ptr_is_null p = Null? p
 
+let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
+
 let raise_p
+  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' b { NonNull? r})
-: Tot (pcm (U.raise_t u#0 u#1 (get_base_type (NonNull?.v r).base_type (NonNull?.v r).base_inv)))
+  (r: ptr' a b { NonNull? r})
+: Tot (pcm (U.raise_t u#0 u#1 a))
 = U.raise_pcm (NonNull?.v r).p
 
-let base_of
-  (#b: Type u#b)
-  (r: ptr' b { NonNull? r })
-: Tot (M.ref _ (fstar_pcm_of_pcm (raise_p r)))
-= (NonNull?.v r).r
-
 let lower_conn
+  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' b { NonNull? r})
+  (r: ptr' a b { NonNull? r})
 : Tot (connection (raise_p r) (NonNull?.v r).p)
 = connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (NonNull?.v r).p))
 
 let raise_pl
+  (#a: Type u#0)
   (#b: Type u#b)
-  (r: ptr' b {NonNull? r})
+  (r: ptr' a b {NonNull? r})
 : Tot (connection (raise_p r) (NonNull?.v r).q)
 = lower_conn r `connection_compose` (NonNull?.v r).pl
 
-let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
-
-[@@__reduce__]
-let pts_to0
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p) (v: b)
-: Tot vprop
-= mpts_to (base_of r) ((raise_pl r).conn_small_to_large.morph v) `star`
-  GHR.pts_to (NonNull?.v r).base_type (Some (get_base_type (NonNull?.v r).base_type (NonNull?.v r).base_inv))
-
-let pts_to r v = pts_to0 r v
+let pts_to r v =
+  (NonNull?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
 
 let t_ref_focus
-  (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref p) (#q: pcm c) (l: connection p q)
-: Tot (ref q)
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: Tot (ref a q)
 = let NonNull r = r in
-  NonNull ({r with p = r.p; pl = connection_compose r.pl l; q = q})
+  NonNull ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
 
 let ref_focus r l = t_ref_focus r l
 
@@ -154,48 +69,40 @@ let ref_focus_id r = connection_compose_id_right (NonNull?.v r).pl
 let ref_focus_comp r l m
 = connection_compose_assoc (NonNull?.v r).pl l m
 
+let mk_id_ref
+  (#a: Type0)
+  (p: pcm a)
+  (r0: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)))
+: Tot (ref a p)
+=
+  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
+  let fp = fstar_pcm_of_pcm p' in
+  NonNull ({ p = p; q = p; pl = connection_id p; r = r0 })
+
 (* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
 
-let freeable #b #p r =
+let freeable #a #b #p r =
   let NonNull r = r in
-  get_base_type r.base_type r.base_inv == b /\
-  r.q == r.p /\
-  r.pl == connection_id _
+  a == b /\
+  r.p == p /\
+  r.pl == connection_id p
 
-#push-options "--z3rlimit 32"
-#restart-solver
-
-let ref_alloc #a pcm v =
-  let r : Steel.Memory.ref (U.raise_t a) (fstar_pcm_of_pcm (U.raise_pcm pcm)) = R.alloc (U.raise_val v) in
-  let g: GHR.ref _ (RO.pcm_readonly #Type0) = GHR.alloc (Some a) in
-  GHR.share g (Some a) (Some a) (Some a);
-  let i = A.new_invariant (GHR.pts_to g (Some a)) in
-  has_base_type_intro g i a;
-  has_base_type_idem g i _ ();
-  let p : ref pcm = NonNull ({
-    base_type = g;
-    base_inv = i;
-    base_has_type = ();
-    p = pcm;
-    q = pcm;
-    pl = connection_id _;
-    r = r;
-  })
-  in
-  A.change_equal_slprop
-    (mpts_to r (U.raise_val v))
-    (mpts_to (base_of p) ((raise_pl p).conn_small_to_large.morph v));
-  A.change_equal_slprop
-    (GHR.pts_to g _)
-    (GHR.pts_to (NonNull?.v p).base_type (Some (get_base_type (NonNull?.v p).base_type (NonNull?.v p).base_inv)));
-  A.change_equal_slprop
-    (pts_to0 p v)
-    (pts_to p v);
-  A.return p
+#push-options "--z3rlimit 16"
 
-let ref_free #b #p #x r =
+let ref_alloc #a p x =
+  let x' : U.raise_t u#0 u#1 a = U.raise_val u#0 u#1 x in
+  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
+//  let fp : P.pcm u#1 _ = fstar_pcm_of_pcm p' in // FIXME: I can define this local definition, but WHY WHY WHY can't I USE it?
+  compatible_refl p' x';
+  let r0 : Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) = Steel.PCMReference.alloc #_ #(fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) x' in
+  let r : ref a p = mk_id_ref p r0 in
+  connection_compose_id_right (lower_conn r);
+  A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
+  A.return r
+
+let ref_free #a #b #p #x r =
   // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.PCM
-  A.drop (pts_to _ _)
+  Steel.Effect.Atomic.drop ((NonNull?.v r).r `mpts_to` _)
 
 #pop-options
 
@@ -219,39 +126,24 @@ let unfocus r r' l x =
     (r `pts_to` x)
     (r' `pts_to` l.conn_small_to_large.morph x)
 
-let read_only_share
-  (#a: Type)
-  (#opened: _)
-  (#v: a)
-  (r: GHR.ref _ (RO.pcm_readonly #a))
-: A.SteelGhostT unit opened
-    (GHR.pts_to r (Some v))
-    (fun _ -> GHR.pts_to r (Some v) `star` GHR.pts_to r (Some v))
-= GHR.share r _ (Some v) (Some v)
-
-#push-options "--z3rlimit 16"
-#restart-solver
-
 let split r xy x y =
   let c = raise_pl r in
-  let xy2 = (c.conn_small_to_large.morph xy) in
-  let x2 = (c.conn_small_to_large.morph x) in
-  let y2 = (c.conn_small_to_large.morph y) in
-  assert (P.composable (fstar_pcm_of_pcm (raise_p r)) x2 y2);
-  A.change_equal_slprop (r `pts_to` xy) (r `pts_to0` xy);
+  let xy2 = Ghost.hide (c.conn_small_to_large.morph xy) in
+  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
+  assert (composable (raise_p r) x2 y2);
   A.change_equal_slprop
-    (_ `mpts_to` _)
-    (base_of r `mpts_to` xy2);
-  R.split (base_of r)
+    (r `pts_to` xy)
+    ((NonNull?.v r).r `mpts_to` xy2);
+  Steel.PCMReference.split (NonNull?.v r).r
     xy2
     x2
     y2;
-  read_only_share (NonNull?.v r).base_type;
   A.change_equal_slprop
-    (mpts_to (base_of r) x2 `star` GHR.pts_to _ _)
+    ((NonNull?.v r).r `mpts_to` x2)
     (r `pts_to` x);
   A.change_equal_slprop
-    (mpts_to (base_of r) y2 `star` GHR.pts_to _ _)
+    ((NonNull?.v r).r `mpts_to` y2)
     (r `pts_to` y)
 
 let mgather
@@ -262,46 +154,59 @@ let mgather
     (fun _ -> mpts_to r (P.op p v0 v1))
 = Steel.PCMReference.gather r v0 v1
 
-let gather #inames #b #p r x y =
+let gather #inames #a #b #p r x y =
   let c = raise_pl r in
-  let x2 = (c.conn_small_to_large.morph x) in
-  let y2 = (c.conn_small_to_large.morph y) in
-  A.change_equal_slprop (r `pts_to` x) (r `pts_to0` x);
-  A.change_equal_slprop (mpts_to (base_of r) _) (mpts_to (base_of r) x2);
-  A.change_equal_slprop (r `pts_to` y) (r `pts_to0` y);
-  mgather (base_of r) x2 _;
-  GHR.gather (NonNull?.v r).base_type _ _;
+  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
+  A.change_equal_slprop
+    (r `pts_to` x)
+    ((NonNull?.v r).r `mpts_to` x2);
+  A.change_equal_slprop
+    (r `pts_to` y)
+    ((NonNull?.v r).r `mpts_to` y2);
+  mgather (NonNull?.v r).r
+    x2
+    y2;
   assert (composable (raise_p r) x2 y2);
   assert (
     let x' = c.conn_large_to_small.morph x2 in
     let y' = c.conn_large_to_small.morph y2 in
     composable p x' y' /\
-    x == x' /\ y == y'
+    Ghost.reveal x == x' /\ Ghost.reveal y == y'
   );
-  A.change_equal_slprop
-    (mpts_to _ _ `star` GHR.pts_to _ _)
-    (r `pts_to` op p x y)
+  A.change_equal_slprop _ (r `pts_to` op p x y)
 
-let ref_read
-  #_ #p #x r
+let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
+: Steel 'b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires fun _ -> True)
+    (ensures fun _ x' _ -> compatible p x x')
 = let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
-  A.change_equal_slprop (r `pts_to` x) (r `pts_to0` x);
-  A.change_equal_slprop (mpts_to _ _) (mpts_to (base_of r) (Ghost.reveal w));
-  let w' = R.read (base_of r) w in
-  A.change_equal_slprop (mpts_to _ _ `star` GHR.pts_to _ _) (r `pts_to` x);
+  A.change_equal_slprop (r `pts_to` x) ((NonNull?.v r).r `mpts_to` w);
+  let w' = Steel.PCMReference.read (NonNull?.v r).r w in
+  A.change_equal_slprop ((NonNull?.v r).r `mpts_to` w) (r `pts_to` x);
   let x' = (raise_pl r).conn_large_to_small.morph w' in
   compatible_morphism (raise_pl r).conn_large_to_small w w';
-  assert (compatible p x x');
   A.return x'
 
-let ref_upd #b #p r x y f =
-  let c = raise_pl r in
+let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
+: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
+= let c = raise_pl r in
   let x' = Ghost.hide (c.conn_small_to_large.morph x) in
   let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  A.change_equal_slprop (r `pts_to` x) (r `pts_to0` x);
-  A.change_equal_slprop (mpts_to _ _) (mpts_to (base_of r) (Ghost.reveal x'));
-  R.upd_gen (base_of r) x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )));
-  A.change_equal_slprop (mpts_to _ _ `star` GHR.pts_to _ _) (r `pts_to` y)
+  M.upd_gen Set.empty (NonNull?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
+
+let as_action (#p:vprop)
+              (#q:vprop)
+              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
+: SteelT unit p (fun x -> q)
+= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
+  let x = Steel.Effect.as_action f in
+  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
+  A.return x
+
+let ref_upd r x y f = as_action (ref_upd_act r x y f)
 
 let base_fpu p x y =
   fun _ ->
@@ -309,8 +214,8 @@ let base_fpu p x y =
   y
 
 let pts_to_view_explicit
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -319,8 +224,8 @@ let pts_to_view_explicit
 = hp_of (pts_to r (vw.to_carrier v))
 
 let pts_to_view_explicit_witinv
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -336,7 +241,7 @@ let pts_to_view_explicit_witinv
     let y_ = vw.to_carrier y in
     let x' = c.conn_small_to_large.morph x_ in
     let y' = c.conn_small_to_large.morph y_ in
-    M.pts_to_join (base_of r) x' y' m;
+    M.pts_to_join (NonNull?.v r).r x' y' m;
     let z' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun z' -> compatible (raise_p r) x' z' /\ compatible (raise_p r) y' z') in
     let frame_x' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_x' -> composable (raise_p r) x' frame_x' /\ op (raise_p r) frame_x' x' == z') in
     let frame_y' = FStar.IndefiniteDescription.indefinite_description_ghost _ (fun frame_y' -> composable (raise_p r) y' frame_y' /\ op (raise_p r) frame_y' y' == z') in
@@ -353,12 +258,18 @@ let pts_to_view_explicit_witinv
   Classical.forall_intro_3 (fun x y -> Classical.move_requires (aux x y))
 
 let pts_to_view_sl
-  r vw
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type u#c)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot M.slprop
 = M.h_exists (pts_to_view_explicit r vw)
 
+
 let pts_to_view_sel'
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -368,8 +279,8 @@ let pts_to_view_sel'
   Ghost.reveal (Ghost.reveal x)
 
 let pts_to_view_depends_only_on
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -381,8 +292,8 @@ let pts_to_view_depends_only_on
   M.elim_wi (pts_to_view_explicit r vw) x y (M.join m0 m1)
 
 let pts_to_view_depends_only_on_core
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -394,14 +305,19 @@ let pts_to_view_depends_only_on_core
   M.elim_wi (pts_to_view_explicit r vw) x y (M.core_mem m0)
 
 let pts_to_view_sel
-  r vw
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+: Tot (selector c (pts_to_view_sl r vw))
 = Classical.forall_intro_2 (pts_to_view_depends_only_on r vw);
   Classical.forall_intro (pts_to_view_depends_only_on_core r vw);
   pts_to_view_sel' r vw
 
 let pts_to_view_intro_lemma
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (x: Ghost.erased b)
   (#c: Type0)
   (#can_view_unit: bool)
@@ -419,7 +335,21 @@ let pts_to_view_intro_lemma
   pts_to_view_explicit_witinv r vw
 
 let pts_to_view_intro
-  r x vw y
+  (#invs: _)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
+  (#c: Type0)
+  (#can_view_unit: bool)
+  (vw: sel_view p c can_view_unit)
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
+: A.SteelGhost unit invs
+    (pts_to r x)
+    (fun _ -> pts_to_view r vw)
+    (fun _ -> vw.to_carrier y == Ghost.reveal x)
+    (fun _ _ h' ->
+      h' (pts_to_view r vw) == Ghost.reveal y
+    )
 = A.change_slprop_2
     (pts_to r x)
     (pts_to_view r vw)
@@ -428,9 +358,10 @@ let pts_to_view_intro
       pts_to_view_intro_lemma r x vw y m
     )
 
+
 let pts_to_view_elim_lemma
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -465,8 +396,8 @@ let intro_vdep2 (#opened:_)
 
 let pts_to_view_elim
   (#invs: _)
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -501,6 +432,7 @@ let pts_to_view_elim
     );
   res
 
+
 let compatible_elim'
   (#a: Type u#a)
   (pcm: pcm0 a)
@@ -513,8 +445,8 @@ let compatible_elim'
 = compatible_elim pcm x y
 
 let ref_read_sel
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -536,10 +468,11 @@ let ref_read_sel
   pts_to_view_intro r _v vw res;
   A.return res
 
+
 // [@@__steel_reduce__; __reduce__]
 let pts_to_view_or_null0
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -560,8 +493,8 @@ let pts_to_view_or_null_sel
 
 let pts_to_view_or_null_prop_null
   (#inames: _)
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -598,8 +531,8 @@ let pts_to_view_or_null_prop_null
 #restart-solver
 let pts_to_view_or_null_prop_not_null
   (#inames: _)
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -635,8 +568,8 @@ let pts_to_view_or_null_prop_not_null
 
 let pts_to_view_or_null_prop
   (#inames: _)
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -661,28 +594,28 @@ let is_null
   A.return (Null? r)
 
 let intro_pts_to_view_or_null_null
-  #_ #b #p #c vw
+  a #b #p #c vw
 =
   A.intro_vrewrite emp (fun _ -> None <: option c);
   A.change_equal_slprop
     (emp `vrewrite` (fun _ -> None <: option c))
-    (pts_to_view_or_null0 (null p) vw);
+    (pts_to_view_or_null0 (null a p) vw);
   A.change_slprop_rel
-    (pts_to_view_or_null0 (null p) vw)
-    (pts_to_view_or_null (null p) vw)
+    (pts_to_view_or_null0 (null a p) vw)
+    (pts_to_view_or_null (null a p) vw)
     (fun x y -> x == y)
     (fun _ -> ())
 
 let elim_pts_to_view_or_null_null
-  #_ #b #p #c vw
+  a #b #p #c vw
 =
   A.change_slprop_rel
-    (pts_to_view_or_null (null p) vw)
-    (pts_to_view_or_null0 (null p) vw)
+    (pts_to_view_or_null (null a p) vw)
+    (pts_to_view_or_null0 (null a p) vw)
     (fun x y -> x == y)
     (fun _ -> ());
   A.change_equal_slprop
-    (pts_to_view_or_null0 (null p) vw)
+    (pts_to_view_or_null0 (null a p) vw)
     (emp `vrewrite` (fun _ -> None <: option c));
   A.elim_vrewrite emp (fun _ -> None <: option c)
 
diff --git a/ulib/experimental/Steel.C.Ref.fsti b/ulib/experimental/Steel.C.Ref.fsti
index d7ba85bfcef..4f8e564e703 100644
--- a/ulib/experimental/Steel.C.Ref.fsti
+++ b/ulib/experimental/Steel.C.Ref.fsti
@@ -3,66 +3,66 @@ open FStar.FunctionalExtensionality
 open Steel.C.PCM
 open Steel.C.Connection
 
-module A = Steel.Effect.Atomic
-
 #push-options "--print_universes"
 
-(** A [ptr b] is a (maybe null) pointer to some value of type b. *)
-val ptr (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
+(** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
+val ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
 
-val null (#b: Type u#b) (p: pcm b) : Tot (ptr p)
+val null (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a p)
 
-val ptr_is_null (#b: Type u#b) (#p: pcm b) (r: ptr p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null p))
+val ptr_is_null (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null a p))
 
 let refine (a: Type) (p: (a -> prop)) : Tot Type =
   (x: a { p x })
 
 let not_null
-  (#b: Type u#b) (#p: pcm b) (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p)
 : Tot prop
 = ptr_is_null r == false
 
 (** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
-let ref (#b: Type u#b) (q: pcm b) : Type u#b =
-  refine (ptr q) (not_null #b #q)
+let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
+  refine (ptr a q) (not_null #a #b #q)
 
 open Steel.Effect
 
 (** r points to PCM carrier value v *)
 val pts_to
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p) ([@@@smt_fallback] v: b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p) ([@@@smt_fallback] v: b)
 : vprop
 
 (** Given a reference to an element of PCM p and a connection l from p to q,
     [ref_focus r l] is a reference to an element of q. The intuition is that
     q represents a "part of" p (e.g. a struct field, union case, or array slice). *)
 val ref_focus
-  (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref p) (#q: pcm c) (l: connection p q)
-: GTot (ref q)
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: GTot (ref a q)
 
 val ref_focus_id
-  (#b:Type) (#p: pcm b)
-  (r: ref p)
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p)
 : Lemma
   (ref_focus r (connection_id _) == r)
 
-val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref p)
+val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
   (l: connection p q) (m: connection q s)
 : Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
   [SMTPatOr [
     [SMTPat (ref_focus (ref_focus r l) m)]; 
     [SMTPat (ref_focus r (l `connection_compose` m))]]]
 
+module A = Steel.Effect.Atomic
+
 val freeable
-  (#b:Type0) (#p: pcm b) (r: ref p)
+  (#a: Type0) (#b:Type0) (#p: pcm b) (r: ref a p)
 : Tot prop
 
 (** Allocate a reference containing value x. *)
 val ref_alloc
   (#a:Type0) (p: pcm a) (x: a)
-: Steel (ref p)
+: Steel (ref a p)
     emp
     (fun r -> r `pts_to` x)
     (requires fun _ -> p_refine p x)
@@ -70,7 +70,7 @@ val ref_alloc
 
 (** Free a "base" (freeable) reference containing a "whole" (p_refine) value x. *)
 val ref_free
-  (#b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref p)
+  (#a #b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
 : Steel unit
     (r `pts_to` x)
     (fun _ -> emp)
@@ -79,19 +79,19 @@ val ref_free
 
 
 (** Take a pointer to a "substructure" of a reference. *)
-val gfocus (#inames: _) (#p: pcm 'b) (r: ref p)
+val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
-  (l: connection p q) (s: 'b) (x: 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
 : A.SteelGhost unit inames
     (r `pts_to` s)
     (fun _ -> ref_focus r l `pts_to` x)
-    (fun _ -> s == l.conn_small_to_large.morph x)
+    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
     (fun _ _ _ -> True)
 
-val focus (#opened: _) (#p: pcm 'b) (r: ref p)
+val focus (#opened: _) (#p: pcm 'b) (r: ref 'a p)
   (#q: pcm 'c)
   (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: A.SteelAtomicBase (ref q)
+: A.SteelAtomicBase (ref 'a q)
     false opened A.Unobservable
     (r `pts_to` s)
     (fun r' -> r' `pts_to` x)
@@ -104,8 +104,8 @@ module M = Steel.Memory
 val unfocus (#opened:M.inames)
   (#p: pcm 'b)
   (#q: pcm 'c)
-  (r: ref q) (r': ref p)
-  (l: connection p q) (x: 'c)
+  (r: ref 'a q) (r': ref 'a p)
+  (l: connection p q) (x: Ghost.erased 'c)
 : A.SteelGhost unit opened
     (r `pts_to` x)
     (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
@@ -113,22 +113,22 @@ val unfocus (#opened:M.inames)
     (ensures fun _ _ _ -> True)
 
 (** Split the permissions on a reference into two halves. *)
-val split (#inames: _) (#b:Type) (#p: pcm b) (r: ref p) (xy x y: b)
+val split (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
 : A.SteelGhost unit inames
     (r `pts_to` xy)
     (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable p x y /\ xy == (op p x y))
+    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
     (fun _ _ _ -> True)
 
 (** Inverse of split. *)
-val gather (#inames: _) (#b:Type) (#p: pcm b) (r: ref p) (x y: b)
+val gather (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
 : A.SteelGhostT (_:unit{composable p x y}) inames
     ((r `pts_to` x) `star` (r `pts_to` y))
     (fun _ -> r `pts_to` op p x y)
 
 (** Read a PCM carrier value. *)
 val ref_read
-  (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref p)
+  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
 : Steel b
     (r `pts_to` x)
     (fun _ -> r `pts_to` x)
@@ -137,8 +137,8 @@ val ref_read
 
 (** Write a PCM carrier value. *)
 val ref_upd
-  (#b:Type) (#p: pcm b)
-  (r: ref p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 
 (** Construct a write from a frame-preserving update. *)
@@ -221,16 +221,16 @@ let sel_view_inv
   ()
 
 val pts_to_view_sl
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type u#c)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : Tot (M.slprop u#1)
 
 val pts_to_view_sel
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -238,8 +238,8 @@ val pts_to_view_sel
 
 [@@__steel_reduce__]
 let pts_to_view'
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -252,8 +252,8 @@ let pts_to_view'
 
 [@@__steel_reduce__]
 let pts_to_view 
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -267,25 +267,25 @@ let pts_to_view
 
 val pts_to_view_intro
   (#invs: _)
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
-  (x: b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
+  (x: Ghost.erased b)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
-  (y: c) // necessary because to_view may erase information from x
+  (y: Ghost.erased c) // necessary because to_view may erase information from x
 : A.SteelGhost unit invs
     (pts_to r x)
     (fun _ -> pts_to_view r vw)
-    (fun _ -> vw.to_carrier y == x)
+    (fun _ -> vw.to_carrier y == Ghost.reveal x)
     (fun _ _ h' ->
-      h' (pts_to_view r vw) == y
+      h' (pts_to_view r vw) == Ghost.reveal y
     )
 
 val pts_to_view_elim
   (#invs: _)
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -300,8 +300,8 @@ val pts_to_view_elim
     )
 
 val ref_read_sel
-  (#b: Type u#b) (#p: pcm b)
-  (r: ref p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -319,16 +319,16 @@ val ref_read_sel
 /// Pointers (and the null pointer)
 
 val pts_to_view_or_null_sl
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type u#0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : Tot (M.slprop u#1)
 
 val pts_to_view_or_null_sel
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -336,8 +336,8 @@ val pts_to_view_or_null_sel
 
 [@@__steel_reduce__]
 let pts_to_view_or_null'
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -350,8 +350,8 @@ let pts_to_view_or_null'
 
 [@@__steel_reduce__]
 let pts_to_view_or_null
-  (#b: Type u#b) (#p: pcm b)
-  (r: ptr p)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -359,9 +359,9 @@ let pts_to_view_or_null
 = VUnit (pts_to_view_or_null' r vw)
 
 val is_null
-  (#b: Type u#b) (#p: pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (#opened: _)
-  (r: ptr p)
+  (r: ptr a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -378,30 +378,30 @@ val is_null
 
 val intro_pts_to_view_or_null_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
+  (a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : A.SteelGhost unit inames
     emp
-    (fun _ -> pts_to_view_or_null (null p) vw)
+    (fun _ -> pts_to_view_or_null (null a p) vw)
     (requires (fun _ -> True))
-    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null p) vw) == None))
+    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null a p) vw) == None))
 
 val elim_pts_to_view_or_null_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
+  (a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
 : A.SteelGhostT unit inames
-    (pts_to_view_or_null (null p) vw)
+    (pts_to_view_or_null (null a p) vw)
     (fun _ -> emp)
 
 val intro_pts_to_view_or_null_not_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
-  (r: ref p)
+  (#a: Type) (#b: Type) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
@@ -413,8 +413,8 @@ val intro_pts_to_view_or_null_not_null
 
 val elim_pts_to_view_or_null_not_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
-  (r: ref p)
+  (#a: Type) (#b: Type) (#p: pcm b)
+  (r: ref a p)
   (#c: Type0)
   (#can_view_unit: bool)
   (vw: sel_view p c can_view_unit)
diff --git a/ulib/experimental/Steel.C.Reference.fst b/ulib/experimental/Steel.C.Reference.fst
index ce77264fbce..51c42e544a4 100644
--- a/ulib/experimental/Steel.C.Reference.fst
+++ b/ulib/experimental/Steel.C.Reference.fst
@@ -7,39 +7,40 @@ open Steel.Effect.Atomic
 #push-options "--print_universes"
 
 // [@@__reduce__]
-let ptr (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+let ptr (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
 : Type u#b
-= ptr q
+= ptr a q
 
 // [@@__reduce__]
 inline_for_extraction
-let ref (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
+let ref (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (q: pcm b)
 : Tot (Type u#b)
 =
-  (x: ptr view_t q { not_null x })
+  (x: ptr a view_t q { not_null x })
 
 unfold
 let ref_of_ref
-  (#view_t: Type u#0) (#b: Type u#b) (#q: pcm b)
-  (r: ref view_t q)
-: Tot (Steel.C.Ref.ref q)
+  (#a: Type u#0) (#view_t: Type u#0) (#b: Type u#b) (#q: pcm b)
+  (r: ref a view_t q)
+: Tot (Steel.C.Ref.ref a q)
 = r
 
 [@@__steel_reduce__] // ; __reduce__]
 let pts_to_view
+  (#a: Type u#0) 
   (#view_t: Type u#0)
   (#view_t': Type u#0)
   (#b: Type u#b) (#p: pcm b)
-  (r: ref view_t p) (view: sel_view p view_t' false)
+  (r: ref a view_t p) (view: sel_view p view_t' false)
 : vprop
 = r `pts_to_view` view
 
 let ref_read
-  (#b: Type u#b)
+  (#a: Type u#0) (#b: Type u#b)
   (#view_t: Type u#0)
   (#p: pcm b)
   (#vw: sel_view p view_t false)
-  (r: ref view_t p)
+  (r: ref a view_t p)
 : Steel view_t
   (r `pts_to_view` vw)
   (fun _ -> r `pts_to_view` vw)
@@ -50,20 +51,21 @@ let ref_read
   ))
 = ref_read_sel r vw
 
-let null (view_t: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr view_t p) = null p
+let null (a: Type u#0) (view_t: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a view_t p) = null a p
 
 [@@__steel_reduce__] // ; __reduce__]
 let pts_to_view_or_null
+  (#a: Type u#0) 
   (#view_t: Type u#0)
   (#view_t': Type u#0)
   (#b: Type u#b) (#p: pcm b)
-  (r: ptr view_t p) (view: sel_view p view_t' false)
+  (r: ptr a view_t p) (view: sel_view p view_t' false)
 : vprop
 = r `pts_to_view_or_null` view
 
 let is_null
-  (#b: Type u#b) (#c: Type0) (#opened: _) (#p: pcm b)
-  (r: ptr c p)
+  (#a: Type u#0) (#b: Type u#b) (#c: Type0) (#opened: _) (#p: pcm b)
+  (r: ptr a c p)
   (vw: sel_view p c false)
 : SteelAtomicBase bool false opened Unobservable
     (pts_to_view_or_null r vw)
@@ -79,21 +81,21 @@ let is_null
 
 let intro_pts_to_view_or_null_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
+  (a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     emp
-    (fun _ -> pts_to_view_or_null (null c p) vw)
+    (fun _ -> pts_to_view_or_null (null a c p) vw)
     (requires (fun _ -> True))
-    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null c p) vw) == None))
-= intro_pts_to_view_or_null_null vw
+    (ensures (fun _ _ h' -> h' (pts_to_view_or_null (null a c p) vw) == None))
+= intro_pts_to_view_or_null_null a vw
 
 let elim_pts_to_view_or_null_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
+  (a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
-  (r: ptr c p)
+  (r: ptr a c p)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     (pts_to_view_or_null r vw)
@@ -102,14 +104,14 @@ let elim_pts_to_view_or_null_null
     (ensures (fun _ _ _ -> True))
 = change_equal_slprop
     (pts_to_view_or_null r vw)
-    (pts_to_view_or_null (null c p) vw);
-  elim_pts_to_view_or_null_null vw
+    (pts_to_view_or_null (null a c p) vw);
+  elim_pts_to_view_or_null_null a vw
 
 let intro_pts_to_view_or_null_not_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
+  (#a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
-  (r: ref c p)
+  (r: ref a c p)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     (pts_to_view r vw)
@@ -120,9 +122,9 @@ let intro_pts_to_view_or_null_not_null
 
 let elim_pts_to_view_or_null_not_null
   (#inames: _)
-  (#b: Type) (#p: pcm b)
+  (#a: Type) (#b: Type) (#p: pcm b)
   (#c: Type0)
-  (r: ref c p)
+  (r: ref a c p)
   (vw: sel_view p c false)
 : SteelGhost unit inames
     (pts_to_view_or_null r vw)
@@ -132,10 +134,10 @@ let elim_pts_to_view_or_null_not_null
 = elim_pts_to_view_or_null_not_null r vw
 
 let freeable
-  (#view_t: Type u#0) (#b: Type u#0) (#q: pcm b)
-  (r: ref view_t q)
+  (#a: Type u#0) (#view_t: Type u#0) (#b: Type u#0) (#q: pcm b)
+  (r: ref a view_t q)
 : Tot prop
-= freeable (r <: Steel.C.Ref.ref q)
+= freeable (r <: Steel.C.Ref.ref a q)
 
 (* Operations on views *)
 
@@ -162,7 +164,8 @@ let intro_refine_view'
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (r: ref view p)
+  (#base: Type)
+  (r: ref base view p)
 : SteelGhost unit opened
     (pts_to_view r vw)
     (fun _ -> pts_to_view r (refine_view vw pr))
@@ -185,8 +188,9 @@ let intro_refine_view
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (r: ref view p)
-: SteelAtomicBase (ref (refine view pr) p) false opened Unobservable
+  (#base: Type)
+  (r: ref base view p)
+: SteelAtomicBase (ref base (refine view pr) p) false opened Unobservable
     (pts_to_view r vw)
     (fun r' -> pts_to_view r' (refine_view vw pr))
     (fun h -> pr (h (pts_to_view r vw)))
@@ -197,7 +201,7 @@ let intro_refine_view
       x == h' (pts_to_view r' (refine_view vw pr))
     )
 = intro_refine_view' vw pr r;
-  let r' : ref (refine view pr) p = r in
+  let r' : ref base (refine view pr) p = r in
   change_equal_slprop
     (pts_to_view r (refine_view vw pr))
     (pts_to_view r' (refine_view vw pr));
@@ -210,7 +214,8 @@ let elim_refine_view'
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (r: ref (refine view pr) p)
+  (#base: Type)
+  (r: ref base (refine view pr) p)
 : SteelGhost unit opened
     (pts_to_view r (refine_view vw pr))
     (fun _ -> pts_to_view r vw)
@@ -233,8 +238,9 @@ let elim_refine_view
   (#view: Type)
   (vw: sel_view p view false)
   (pr: (view -> Tot prop))
-  (r: ref (refine view pr) p)
-: SteelAtomicBase (ref view p) false opened Unobservable
+  (#base: Type)
+  (r: ref base (refine view pr) p)
+: SteelAtomicBase (ref base view p) false opened Unobservable
     (pts_to_view r (refine_view vw pr))
     (fun r' -> pts_to_view r' vw)
     (fun h -> True)
@@ -245,7 +251,7 @@ let elim_refine_view
       x == h (pts_to_view r (refine_view vw pr))
     )
 = elim_refine_view' vw pr r;
-  let r' : ref view p = r in
+  let r' : ref base view p = r in
   change_equal_slprop
     (pts_to_view r vw)
     (pts_to_view r' vw);
@@ -280,7 +286,8 @@ let intro_rewrite_view'
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (r: ref view p)
+  (#base: _)
+  (r: ref base view p)
   (x' : Ghost.erased view')
 : SteelGhost unit opened
     (pts_to_view r vw)
@@ -305,9 +312,10 @@ let intro_rewrite_view
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (r: ref view p)
+  (#base: _)
+  (r: ref base view p)
   (x' : Ghost.erased view')
-: SteelAtomicBase (ref view' p) false opened Unobservable
+: SteelAtomicBase (ref base view' p) false opened Unobservable
     (pts_to_view r vw)
     (fun r' -> pts_to_view r' (rewrite_view vw f g prf))
     (fun h -> h (pts_to_view r vw) == g x')
@@ -316,7 +324,7 @@ let intro_rewrite_view
       h' (pts_to_view r' (rewrite_view vw f g prf)) == Ghost.reveal x'
     )
 = intro_rewrite_view' vw f g prf r x';
-  let r' : ref view' p = r in
+  let r' : ref base view' p = r in
   change_equal_slprop
     (pts_to_view r (rewrite_view vw f g prf))
     (pts_to_view r' (rewrite_view vw f g prf));
@@ -332,7 +340,8 @@ let elim_rewrite_view'
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (r: ref view' p)
+  (#base: _)
+  (r: ref base view' p)
 : SteelGhost unit opened
     (pts_to_view r (rewrite_view vw f g prf))
     (fun _ -> pts_to_view r vw)
@@ -359,8 +368,9 @@ let elim_rewrite_view
   (f: view -> view')
   (g: view' -> view)
   (prf: squash (f `Steel.C.Connection.is_inverse_of` g))
-  (r: ref view' p)
-: SteelAtomicBase (ref view p) false opened Unobservable
+  (#base: _)
+  (r: ref base view' p)
+: SteelAtomicBase (ref base view p) false opened Unobservable
     (pts_to_view r (rewrite_view vw f g prf))
     (fun r' -> pts_to_view r' vw)
     (fun _ -> True)
@@ -371,7 +381,7 @@ let elim_rewrite_view
       f (Ghost.reveal x') == Ghost.reveal x
     )
 = elim_rewrite_view' vw f g prf r;
-  let r' : ref view p = r in
+  let r' : ref base view p = r in
   change_equal_slprop
     (pts_to_view r vw)
     (pts_to_view r' vw);
diff --git a/ulib/experimental/Steel.C.Struct.fst b/ulib/experimental/Steel.C.Struct.fst
index 67f002cb427..ff47a9bcfd1 100644
--- a/ulib/experimental/Steel.C.Struct.fst
+++ b/ulib/experimental/Steel.C.Struct.fst
@@ -299,10 +299,10 @@ let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
 
 let addr_of_struct_field
-  (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref (prod_pcm p)) (k:a)
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
   (xs: Ghost.erased (restricted_t a b))
-: Steel (ref (p k))
+: Steel (ref base (p k))
     (r `pts_to` xs)
     (fun s ->
       (r `pts_to` struct_without_field p k xs) `star` 
@@ -350,8 +350,8 @@ let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
   assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
 let unaddr_of_struct_field
-  (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref (p k)) (r: ref (prod_pcm p))
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (prod_pcm p))
   (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
 : Steel unit
     ((r `pts_to` xs) `star` (r' `pts_to` x))
diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
index cbed69903d2..b8b5b93569f 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ b/ulib/experimental/Steel.C.StructLiteral.fst
@@ -246,8 +246,8 @@ let extract_field_unextracted'
 val addr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref (struct_pcm tag fields))
-: Steel (ref (fields.get_field field).pcm)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
@@ -267,7 +267,7 @@ val addr_of_struct_field_ref'
         h' (q `pts_to_view` (fields.get_field field).view))
 
 #push-options "--z3rlimit 30"
-let addr_of_struct_field_ref' #tag #fields #excluded field p =
+let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -287,7 +287,7 @@ let addr_of_struct_field_ref' #tag #fields #excluded field p =
   return q
 #pop-options
 
-let addr_of_struct_field_ref #tag #fields #excluded field p =
+let addr_of_struct_field_ref #a #tag #fields #excluded field p =
   addr_of_struct_field_ref' field p
 
 let struct'_with_field
@@ -336,7 +336,7 @@ let extract_field_with_field
     `feq` v)
 
 #push-options "--z3rlimit 50"
-let unaddr_of_struct_field_ref' #tag #fields #excluded field p q =
+let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
   let v: Ghost.erased (struct' tag fields excluded) =
     gget (p `pts_to_view` struct_view tag fields excluded)
   in
@@ -349,7 +349,7 @@ let unaddr_of_struct_field_ref' #tag #fields #excluded field p q =
   let t: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  unaddr_of_struct_field #_ #_ #(struct_pcms fields) field q p s t;
+  unaddr_of_struct_field #_ #_ #_ #(struct_pcms fields) field q p s t;
   let h1: squash (excluded field == true) = () in
   let h2: squash (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v) = () in
   let h3: squash (Ghost.reveal t == (fields.get_field field).view.to_carrier w) = () in
@@ -370,6 +370,6 @@ let unaddr_of_struct_field_ref' #tag #fields #excluded field p q =
 
 let dummy_def = ()
 
-let unaddr_of_struct_field_ref #tag #fields #excluded field p q =
+let unaddr_of_struct_field_ref #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
 #pop-options
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index 83db77647c6..40ac19a4f70 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -268,12 +268,13 @@ val extract_field_unextracted'
 val addr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref (struct_pcm tag fields))
-: Steel (ref (fields.get_field field).pcm)
+  (p: ref 'a (struct_pcm tag fields))
+: Steel (ref 'a (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
                   q
@@ -294,8 +295,8 @@ val addr_of_struct_field_ref
 val unaddr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref (struct_pcm tag fields))
-  (q: ref (fields.get_field field).pcm)
+  (p: ref 'a (struct_pcm tag fields))
+  (q: ref 'a (fields.get_field field).pcm)
 : Steel unit
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (q `pts_to_view` (fields.get_field field).view))
@@ -321,11 +322,12 @@ val dummy_def : unit
 val unaddr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref (struct_pcm tag fields))
-  (q: ref (fields.get_field field).pcm)
+  (p: ref 'a (struct_pcm tag fields))
+  (q: ref 'a (fields.get_field field).pcm)
 : Steel unit
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).pcm))
                   q
@@ -357,12 +359,13 @@ let addr_of_struct_field''
   (field: field_of fields{
     return_view_type == (fields.get_field field).view_type /\
     return_carrier == (fields.get_field field).carrier})
-  (p: ref (struct tag fields) (struct_pcm tag fields))
-: Steel (ref return_view_type #return_carrier (fields.get_field field).pcm)
+  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
+: Steel (ref 'a return_view_type #return_carrier (fields.get_field field).pcm)
     (p `pts_to_view` struct_view tag fields excluded)
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -381,7 +384,7 @@ let addr_of_struct_field''
         snd (extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded))) ==
          h' (q `pts_to_view` (fields.get_field field).view))
-= addr_of_struct_field_ref #tag #fields #excluded field p
+= addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 (** Take the address of a field of a struct.
     The above definitions are set up so that calls to addr_of_struct_field are erased to calls to addr_of_struct_field'' with
@@ -399,8 +402,8 @@ inline_for_extraction noextract
 let addr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref (struct tag fields) (struct_pcm tag fields))
-: Steel (ref
+  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
+: Steel (ref 'a
           (norm simplify_typedefs (fields.get_field field).view_type)
           #(norm simplify_typedefs (fields.get_field field).carrier)
           (fields.get_field field).pcm)
@@ -408,6 +411,7 @@ let addr_of_struct_field
     (fun q ->
       (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
       (pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -434,13 +438,14 @@ let addr_of_struct_field
 let unaddr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
-  (p: ref (struct tag fields) (struct_pcm tag fields))
-  (q: ref
+  (p: ref 'a (struct tag fields) (struct_pcm tag fields))
+  (q: ref 'a
     (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
     (fields.get_field field).pcm)
 : Steel unit
     ((p `pts_to_view` struct_view tag fields excluded) `star`
      (pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
diff --git a/ulib/experimental/Steel.C.Union.fst b/ulib/experimental/Steel.C.Union.fst
index b4e9d9fc933..c0060f8a353 100644
--- a/ulib/experimental/Steel.C.Union.fst
+++ b/ulib/experimental/Steel.C.Union.fst
@@ -458,10 +458,10 @@ let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
 = assert (xs `feq` field_to_union_f p k (xs k))
 
 let addr_of_union_field
-  (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
-  (r: ref (union_pcm p)) (k:a)
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref base (union_pcm p)) (k:a)
   (xs: Ghost.erased (union p))
-: Steel (ref (p k))
+: Steel (ref base (p k))
     (r `pts_to` xs)
     (fun r' -> r' `pts_to` Ghost.reveal xs k)
     (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
@@ -474,8 +474,8 @@ let addr_of_union_field
 
 module M = Steel.Memory 
 let unaddr_of_union_field
-  (#opened:M.inames) (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref (p k)) (r: ref (union_pcm p))
+  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (union_pcm p))
   (x: Ghost.erased (b k))
 : A.SteelGhost unit opened
     (r' `pts_to` x)
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fst b/ulib/experimental/Steel.C.UnionLiteral.fst
index 83251e22943..2b8844b8bd1 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fst
+++ b/ulib/experimental/Steel.C.UnionLiteral.fst
@@ -134,13 +134,14 @@ open Steel.C.Reference
 let addr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref (union tag fields) (union_pcm tag fields))
-: Steel (ref
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel (ref 'a
           (fields.get_field field).view_type
           (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
+                  #'a
                   #(fields.get_field field).view_type
                   #(fields.get_field field).view_type
                   #(fields.get_field field).carrier
@@ -160,7 +161,7 @@ let addr_of_union_field'
     pts_to_view_elim p (union_view tag fields)
   in
   //  assert (Ghost.reveal s == (union_view tag fields).to_carrier v);
-  let q = Steel.C.Union.addr_of_union_field #_ #_ #(union_pcms fields) p field s in
+  let q = Steel.C.Union.addr_of_union_field #'a #_ #_ #(union_pcms fields) p field s in
 //  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
   pts_to_view_intro q (Ghost.reveal s field)
     (fields.get_field field).view
@@ -169,16 +170,17 @@ let addr_of_union_field'
   return q
 #pop-options
 
-let addr_of_union_field'' return_view_type return_carrier tag fields field p =
-  addr_of_union_field' #tag #fields field p
+let addr_of_union_field'' #a return_view_type return_carrier tag fields field p =
+  addr_of_union_field' #a #tag #fields field p
 
 let unaddr_of_union_field'
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref (union tag fields) (union_pcm tag fields))
-  (q: ref (fields.get_field field).view_type (fields.get_field field).pcm)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (q: ref 'a (fields.get_field field).view_type (fields.get_field field).pcm)
 : Steel unit
     (pts_to_view u#0
+                 #'a
                  #(fields.get_field field).view_type
                  #(fields.get_field field).view_type
                  #(fields.get_field field).carrier
@@ -196,15 +198,15 @@ let unaddr_of_union_field'
   let s: Ghost.erased (fields.get_field field).carrier =
     pts_to_view_elim q (fields.get_field field).view
   in
-  Steel.C.Union.unaddr_of_union_field #_ #_ #_ #(union_pcms fields) field q p s;
+  Steel.C.Union.unaddr_of_union_field #_ #_ #_ #_ #(union_pcms fields) field q p s;
   pts_to_view_intro p
     (field_to_union_f (union_pcms fields) field s)
     (union_view tag fields)
     (|field, Ghost.reveal v|);
   return ()
 
-let unaddr_of_union_field #tag #fields field p q =
-  unaddr_of_union_field' #tag #fields field p q
+let unaddr_of_union_field #a #tag #fields field p q =
+  unaddr_of_union_field' #a #tag #fields field p q
 
 #restart-solver
 #push-options "--z3rlimit 64"
@@ -240,7 +242,7 @@ let exclusive_refine_union_field
 let switch_union_field''
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
-  (p: ref (union tag fields) (union_pcm tag fields))
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
@@ -289,7 +291,7 @@ let switch_union_field'
   (new_value_ty: Type0) (tag: Type0) (fields: c_fields)
   (field: field_of fields{new_value_ty == (fields.get_field field).view_type})
   (new_value: new_value_ty)
-  (p: ref (union tag fields) (union_pcm tag fields))
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
@@ -303,4 +305,4 @@ let switch_union_field'
     (ensures fun _ _ h' ->
       dtuple2_of_union #tag #fields (h' (p `pts_to_view` union_view tag fields))
         == (|field, new_value|))
-= switch_union_field'' #tag #fields field new_value p
+= switch_union_field'' #'a #tag #fields field new_value p
diff --git a/ulib/experimental/Steel.C.UnionLiteral.fsti b/ulib/experimental/Steel.C.UnionLiteral.fsti
index 2daa20cba0e..7d45f194042 100644
--- a/ulib/experimental/Steel.C.UnionLiteral.fsti
+++ b/ulib/experimental/Steel.C.UnionLiteral.fsti
@@ -99,11 +99,12 @@ val addr_of_union_field''
   (field: field_of fields{
     return_view_type == (fields.get_field field).view_type /\
     return_carrier == (fields.get_field field).carrier})
-  (p: ref (union tag fields) (union_pcm tag fields))
-: Steel (ref return_view_type #return_carrier (fields.get_field field).pcm)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel (ref 'a return_view_type #return_carrier (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -124,14 +125,15 @@ inline_for_extraction noextract
 let addr_of_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref (union tag fields) (union_pcm tag fields))
-: Steel (ref
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+: Steel (ref 'a
           (norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
           #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
           (fields.get_field field).pcm)
     (p `pts_to_view` union_view tag fields)
     (fun q ->
       pts_to_view u#0
+                  #'a
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                   #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -153,10 +155,11 @@ let addr_of_union_field
 val unaddr_of_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields)
-  (p: ref (union tag fields) (union_pcm tag fields))
-  (q: ref (fields.get_field field).view_type (fields.get_field field).pcm)
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
+  (q: ref 'a (fields.get_field field).view_type (fields.get_field field).pcm)
 : Steel unit
     (pts_to_view u#0
+                 #'a
                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).view_type))
                  #(norm simplify_typedefs (norm unfold_typedefs (fields.get_field field).carrier))
@@ -173,7 +176,7 @@ val switch_union_field'
   (new_value_ty: Type0) (tag: Type0) (fields: c_fields)
   (field: field_of fields{new_value_ty == (fields.get_field field).view_type})
   (new_value: new_value_ty)
-  (p: ref (union tag fields) (union_pcm tag fields))
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
 : Steel unit
     (p `pts_to_view` union_view tag fields)
     (fun _ -> p `pts_to_view` union_view tag fields)
@@ -193,7 +196,7 @@ noextract inline_for_extraction
 let switch_union_field
   (#tag: Type0) (#fields: c_fields)
   (field: field_of fields) (new_value: (fields.get_field field).view_type)
-  (p: ref (union tag fields) (union_pcm tag fields))
+  (p: ref 'a (union tag fields) (union_pcm tag fields))
   // TODO it would be nice permute the arguments so that their order matches the C code p->field = new_value
 : Steel unit
     (p `pts_to_view` union_view tag fields)
diff --git a/ulib/experimental/Steel.Effect.Common.fsti b/ulib/experimental/Steel.Effect.Common.fsti
index 8be125fd71a..4a1fef34e3e 100644
--- a/ulib/experimental/Steel.Effect.Common.fsti
+++ b/ulib/experimental/Steel.Effect.Common.fsti
@@ -3190,7 +3190,7 @@ let ( >--> ) (i:iname) (p:vprop) : prop = i >--> (hp_of p)
 let inv (p:vprop) = i:Ghost.erased iname{reveal i >--> p}
 
 /// Ghost check to determing whether invariant [i] belongs to the set of opened invariants [e]
-let mem_inv (e:inames) (i:iname) : erased bool = elift2 (fun e i -> Set.mem i e) e i
+let mem_inv (#p:vprop) (e:inames) (i:inv p) : erased bool = elift2 (fun e i -> Set.mem i e) e i
 
 /// Adding invariant [i] to the set of opened invariants [e]
 noextract
diff --git a/ulib/experimental/Steel.PCMReadOnly.fst b/ulib/experimental/Steel.PCMReadOnly.fst
deleted file mode 100644
index 2b1bfbb36a7..00000000000
--- a/ulib/experimental/Steel.PCMReadOnly.fst
+++ /dev/null
@@ -1,34 +0,0 @@
-module Steel.PCMReadOnly
-include FStar.PCM
-
-let readonly (a:Type u#a) = option a
-let composable #a : symrel (readonly a) =
-  fun (f0 f1:readonly a) ->
-    match f0, f1 with
-    | None, _
-    | _, None -> True
-    | Some x0, Some x1 -> x0==x1
-let compose #a (f0:readonly a) (f1:readonly a{composable f0 f1}) : readonly a =
-  match f0, f1 with
-  | None, f
-  | f, None -> f
-  | Some x0, Some _ -> Some x0
-
-let pcm_readonly #a : pcm (readonly a) = {
-  p = {
-         composable = composable;
-         op = compose;
-         one = None
-      };
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun _ -> True)
-}
-
-let mk_frame_preserving_upd
-  (#a: Type)
-  (v0: a)
-: Tot (frame_preserving_upd pcm_readonly (Some v0) (Some v0))
-= fun _ -> Some v0

From 3b82def21992b51c9cf1767bd30996803ed00cda Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Feb 2023 10:01:55 -0800
Subject: [PATCH 379/513] post-merge

---
 ulib/experimental/Steel.C.Array.Base.fst     |  9 +++++++--
 ulib/experimental/Steel.C.Model.Struct.fst   | 16 +++++++++-------
 ulib/experimental/Steel.C.StructLiteral.fst  |  1 +
 ulib/experimental/Steel.C.StructLiteral.fsti |  4 +++-
 ulib/experimental/Steel.C.Types.fsti         |  3 ++-
 5 files changed, 22 insertions(+), 11 deletions(-)

diff --git a/ulib/experimental/Steel.C.Array.Base.fst b/ulib/experimental/Steel.C.Array.Base.fst
index 9ceac01c7f5..db3964f4709 100644
--- a/ulib/experimental/Steel.C.Array.Base.fst
+++ b/ulib/experimental/Steel.C.Array.Base.fst
@@ -1327,6 +1327,8 @@ let array_as_ref_split_right
   array_conn_compose t (array__base_len x) (array__from x) (array__to x) i (len x);
   Steel.C.Model.Ref.ref_focus_comp (array__base_ref x) (array_as_ref_conn x) (array_conn t (len x) i (len x) ())
 
+#restart-solver
+assume
 val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
   : SteelGhost (array base t `gpair` array base t) opened
           (varray a)
@@ -1343,8 +1345,10 @@ val split_ (#opened: _) (#base: Type) (#t:Type) (a:array base t) (i:size_t)
           )
 
 #pop-options
+
 #push-options "--z3rlimit 128"
 
+(*
 #restart-solver
 let split_
   #j #base #t x i
@@ -1459,6 +1463,7 @@ let split_
     (varray xr)
     (varray (GPair?.snd res));
   res
+*)
 
 let split'
   #_ #_ #t a i
@@ -1545,7 +1550,7 @@ let g_ref_of_array'_correct
 
 let get_pts_to
   (#inames: _)
-  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.PCM.pcm b)
+  (#a: Type u#0) (#b: Type u#b) (#p: Steel.C.Model.PCM.pcm b)
   (r: Steel.C.Model.Ref.ref a p) (v: Ghost.erased b)
 : SteelGhost (Ghost.erased b) inames
     (Steel.C.Model.Ref.pts_to r v)
@@ -1585,7 +1590,7 @@ let ref_of_array_ghost #inames #base #t x sq =
   in
   assert (len x == one_size);
   let z : array_domain t one_size = zero_size in
-  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Connection.morph (Ghost.reveal v z));
+  assert (Ghost.reveal v `feq` (array_as_one_ref_conn base t).Steel.C.Model.Connection.conn_small_to_large.Steel.C.Model.Connection.morph (Ghost.reveal v z));
   Steel.C.Model.Ref.gfocus
     #base
     #(array_pcm_carrier t (len x))
diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index 3d1fe9e85ad..e70b10f4093 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -689,6 +689,7 @@ let substruct_composable
 
 let substruct_pts_to_intro
   (#opened: _)
+  (#base: Type)
   (#a: eqtype)
   (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
@@ -698,7 +699,7 @@ let substruct_pts_to_intro
   (inj: (a' -> a))
   (surj: (a -> option a'))
   (sq: squash (is_substruct p p' inj surj))
-  (r: ref (prod_pcm p))
+  (r: ref base (prod_pcm p))
   (f: restricted_t a b)
 : A.SteelGhostT unit opened
     (pts_to r f)
@@ -712,6 +713,7 @@ let substruct_pts_to_intro
 
 let substruct_pts_to_elim
   (#opened: _)
+  (#base: Type)
   (#a: eqtype)
   (#b: a -> Type)
   (p:(k: a -> pcm (b k)))
@@ -721,7 +723,7 @@ let substruct_pts_to_elim
   (inj: (a' -> a))
   (surj: (a -> option a'))
   (sq: squash (is_substruct p p' inj surj))
-  (r: ref (prod_pcm p))
+  (r: ref base (prod_pcm p))
   (f: restricted_t a b)
   (g': restricted_t a' b')
 : A.SteelGhost (Ghost.erased (restricted_t a b)) opened
@@ -740,7 +742,7 @@ let substruct_pts_to_elim
   let g = substruct_to_struct_f p p' inj surj sq g' in
   let res = Ghost.hide (op (prod_pcm p) f g) in
   unfocus (r `ref_focus` _) r (substruct p p' inj surj sq) _;
-  gather r f _;
+  let _ = gather r f _ in
   A.change_equal_slprop
     (pts_to r _)
     (pts_to r res);
@@ -809,7 +811,7 @@ let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
 let g_addr_of_struct_field
   (#opened: _)
   (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref (prod_pcm p)) (k:a)
+  (r: ref base (prod_pcm p)) (k:a)
   (xs: Ghost.erased (restricted_t a b))
 : A.SteelGhostT unit opened
     (r `pts_to` xs)
@@ -877,13 +879,13 @@ let unaddr_of_struct_field
   (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
   (r': ref base (p k)) (r: ref base (prod_pcm p))
   (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
-: Steel unit
+: A.SteelGhost unit opened
     ((r `pts_to` xs) `star` (r' `pts_to` x))
     (fun s -> r `pts_to` struct_with_field p k x xs)
-    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ xs k == one (p k))
+    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
     (ensures fun _ _ _ -> True)
 = unfocus r' r (struct_field p k) x;
-  gather r xs (field_to_struct_f p k x);
+  let _ = gather r xs (field_to_struct_f p k x) in
   struct_unpeel p k x xs;
   A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
index e7a702e6af6..48a3c91d794 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ b/ulib/experimental/Steel.C.StructLiteral.fst
@@ -243,6 +243,7 @@ let extract_field_unextracted'
   in
   Classical.forall_intro aux
 
+(*
 val addr_of_struct_field_ref'
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index be5cc17dca1..7facb07d3d4 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -1,6 +1,6 @@
 module Steel.C.StructLiteral
 
-#set-options "--z3rlimit 50"
+#set-options "--z3rlimit 50 --ide_id_info_off"
 
 open Steel.Memory
 open Steel.Effect
@@ -265,6 +265,7 @@ val extract_field_unextracted'
     (fst (extract_field tag fields excluded field v) `struct_get` field' == v `struct_get` field'))
     [SMTPat (extract_field tag fields excluded field v)]
 
+(*
 val addr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -468,3 +469,4 @@ let unaddr_of_struct_field
 =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
   unaddr_of_struct_field_ref' field p q
+
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index c312c0e11bc..40a042b1d3f 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -425,7 +425,8 @@ val struct_get_field_uninitialized
   (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))
   [SMTPat (struct_get_field (uninitialized (struct0 tn n fields)) field)]
 
-val _inv: Ghost.erased Steel.Memory.iname
+val _inv_vprop: vprop
+val _inv: inv _inv_vprop
 
 val has_struct_field
   (#tn: Type0)

From b6e1decc8a0f226e992a9d3ed373cea82c291a82 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Feb 2023 10:50:49 -0800
Subject: [PATCH 380/513] add base type to arrays

---
 ulib/experimental/Steel.C.Model.Array.fst  | 202 +++++++++++++--------
 ulib/experimental/Steel.C.Model.Struct.fst |   3 +-
 2 files changed, 130 insertions(+), 75 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index aa8e390c6ca..a78debb1e80 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -65,27 +65,30 @@ let array_pcm
 
 noeq
 type array
+  (base_t: Type)
   (#t: Type)
   (p: pcm t)
 = {
     base_len: Ghost.erased size_t;
-    base: R.ref (array_pcm p base_len);
+    base: R.ref base_t (array_pcm p base_len);
     offset: size_t;
     len: Ghost.erased size_t;
     prf: squash (size_v offset + size_v len <= size_v base_len);
   }
 
 let length
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
 : GTot nat
 = size_v a.len
 
 let adjacent
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a1 a2: array p)
+  (a1 a2: array base_t p)
 : Tot prop
 = a1.base_len == a2.base_len /\
   a1.base == a2.base /\
@@ -94,10 +97,11 @@ let adjacent
 let size_add = SZ.add
 
 let merge
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a1 a2: array p)
-: Pure (array p)
+  (a1 a2: array base_t p)
+: Pure (array base_t p)
     (requires (adjacent a1 a2))
     (ensures (fun y -> length y == length a1 + length a2))
 = {
@@ -133,23 +137,26 @@ let small_to_large_index
 = offset `size_add` x
 
 let ref_of_array_conn
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
 : GTot (connection (array_pcm p r.base_len) (array_pcm p r.len))
 = substruct (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) ()
 
 let ref_of_array
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
-: GTot (R.ref (array_pcm p r.len))
+  (r: array base_t p)
+: GTot (R.ref base_t (array_pcm p r.len))
 = R.ref_focus r.base (ref_of_array_conn r)
 
 let ref_of_array_id
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
 : Lemma
   (requires (
     size_v r.offset == 0 /\
@@ -204,9 +211,10 @@ let seq_of_array_pcm_carrier_of_seq
 = ()
 
 let pts_to0
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (x: Seq.seq t)
 : Tot vprop
 = if Seq.length x = size_v r.len
@@ -220,9 +228,10 @@ let trivial_selector
 
 [@@__steel_reduce__]
 let pts_to
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (x: Seq.seq t)
 : Tot vprop
 = VUnit ({
@@ -233,9 +242,10 @@ let pts_to
 
 let intro_pts_to'
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (x: Seq.lseq t (size_v r.len))
 : A.SteelGhostT unit opened
    (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
@@ -247,9 +257,10 @@ let intro_pts_to'
 
 let intro_pts_to
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s: array_pcm_carrier t r.len)
 : A.SteelGhostT unit opened
    (R.pts_to (ref_of_array r) s)
@@ -260,9 +271,10 @@ let intro_pts_to
 
 let intro_pts_to0
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s: array_pcm_carrier t r.len)
   (s': Seq.seq t)
 : A.SteelGhost unit opened
@@ -275,10 +287,11 @@ let intro_pts_to0
 
 let intro_pts_to1
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
-  (r0: R.ref (array_pcm p r.len))
+  (r: array base_t p)
+  (r0: R.ref base_t (array_pcm p r.len))
   (s: array_pcm_carrier t r.len)
   (s': Seq.seq t)
 : A.SteelGhost unit opened
@@ -294,18 +307,21 @@ let intro_pts_to1
 
 let intro_pts_to2
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
+  (#base_t0: Type)
   (#t0: Type)
   (#p0: pcm t0)
-  (r0: R.ref p0)
+  (r0: R.ref base_t0 p0)
   (s: t0)
   (s': Seq.seq t)
 : A.SteelGhost unit opened
    (R.pts_to r0 s)
    (fun _ -> pts_to r s')
    (fun _ ->
+     base_t0 == base_t /\
      t0 == array_pcm_carrier t r.len /\
      p0 == array_pcm p r.len /\
      r0 == ref_of_array r /\
@@ -314,24 +330,29 @@ let intro_pts_to2
    (fun _ _ _ -> True)
 = A.change_equal_slprop
     (R.pts_to r0 s)
-    (R.pts_to (r0 <: R.ref (array_pcm p r.len)) s);
+    (R.pts_to (r0 <: R.ref base_t (array_pcm p r.len)) s);
   intro_pts_to1 r r0 s s'
 
 let elim_pts_to
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (x: Seq.seq t)
 : A.SteelGhostT (squash (Seq.length x == size_v r.len)) opened
    (pts_to r x)
-   (fun _ -> R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
+   (fun _ -> R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len (x <: Seq.lseq t (size_v r.len))))
 = if Seq.length x = size_v r.len
   then begin
+    let sq : squash (Seq.length x == size_v r.len) = () in
     A.rewrite_slprop
       (pts_to r x)
-      (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
-      (fun _ -> ())
+      (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len (x <: Seq.lseq t (size_v r.len))))
+      (fun _ -> ());
+    let sq : squash (Seq.length x == size_v r.len) = () in
+    A.noop ();
+    sq
   end else begin
     A.change_slprop_rel
       (pts_to r x)
@@ -341,23 +362,28 @@ let elim_pts_to
         assert (Steel.Memory.interp (hp_of (pure False)) m);
         Steel.Memory.pure_interp False m 
       );
+    assert False;
     A.rewrite_slprop
       (pure False)
       (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
-      (fun _ -> ())
+      (fun _ -> ());
+    let sq : squash (Seq.length x == size_v r.len) = () in
+    A.noop ();
+    sq
   end
 
 let pts_to_length
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (x: Seq.seq t)
 : A.SteelGhostT (squash (Seq.length x == size_v r.len)) opened
     (pts_to r x)
     (fun _ -> pts_to r x)
 =
-  elim_pts_to r _;
+  let _ = elim_pts_to r _ in
   intro_pts_to0 r _ x
 
 let cell
@@ -372,16 +398,17 @@ let cell
 
 let g_focus_cell
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s: Seq.seq t)
   (i: size_t)
   (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
 : A.SteelGhostT (squash (size_v i < size_v r.len /\ size_v r.len == Seq.length s)) opened
     (pts_to r s)
     (fun _ -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to (ref_focus (ref_of_array r) (cell p r.len i)) (Seq.index s (size_v i)))
-= elim_pts_to r _;
+= let _ = elim_pts_to r _ in
   g_addr_of_struct_field (ref_of_array r) i _;
   intro_pts_to0 r _ (Seq.upd s (size_v i) (one p));
   A.change_equal_slprop (R.pts_to (ref_focus _ _) _) (R.pts_to (ref_focus _ _) _)
@@ -390,9 +417,10 @@ let g_focus_cell
 
 let pts_to_elim_to_base
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (x: Seq.seq t)
 : A.SteelGhost (Ghost.erased (array_pcm_carrier t r.base_len)) opened
     (pts_to r x)
@@ -403,7 +431,7 @@ let pts_to_elim_to_base
       Ghost.reveal y == (ref_of_array_conn r).conn_small_to_large.morph (array_pcm_carrier_of_seq r.len x) /\
       Ghost.reveal y == substruct_to_struct_f (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () (array_pcm_carrier_of_seq r.len x)
     )
-= elim_pts_to r _;
+= let _ = elim_pts_to r _ in
   unfocus (ref_of_array r) r.base (ref_of_array_conn r) _;
   let y = Ghost.hide ((ref_of_array_conn r).conn_small_to_large.morph (array_pcm_carrier_of_seq r.len x)) in
   A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _);
@@ -413,9 +441,10 @@ let pts_to_elim_to_base
 
 let pts_to_intro_from_base
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (y: array_pcm_carrier t r.base_len)
   (x: Seq.seq t)
 : A.SteelGhost unit opened
@@ -434,14 +463,15 @@ let pts_to_intro_from_base
 
 #restart-solver
 let focus_cell
+  (#base_t: Type)
   (#t: Type)
   (#opened: _)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s: Ghost.erased (Seq.seq t))
   (i: size_t)
   (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
-: A.SteelAtomicBase (_: ref p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) }) false opened Unobservable
+: A.SteelAtomicBase (_: ref base_t p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) }) false opened Unobservable
     (pts_to r s)
     (fun r' -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to r' (Seq.index s (size_v i)))
     (fun _ -> True)
@@ -460,12 +490,13 @@ let focus_cell
 
 let unfocus_cell
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s: Seq.seq t)
   (i: size_t)
-  (r': R.ref p)
+  (r': R.ref base_t p)
   (v: t)
   (sq: squash (size_v i < size_v r.len /\ size_v i < Seq.length s))
 : A.SteelGhost unit opened
@@ -476,15 +507,16 @@ let unfocus_cell
       Seq.index s (size_v i) == one p
     )
     (fun _ _ _ -> True)
-= elim_pts_to r _;
-  unaddr_of_struct_field #_ #_ #_ #(array_elements_pcm p r.len) i r' (ref_of_array r) _ _;
+= let _ = elim_pts_to r _ in
+  unaddr_of_struct_field #_ #_ #_ #_ #(array_elements_pcm p r.len) i r' (ref_of_array r) _ _;
   intro_pts_to0 r _ (Seq.upd s (size_v i) v)
 
 let share
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s s1 s2: Seq.seq t)
 : A.SteelGhost unit opened
     (pts_to r s)
@@ -499,7 +531,7 @@ let share
       ))
     )
     (fun _ _ _ -> True)
-= elim_pts_to r _;
+= let _ = elim_pts_to r _ in
   let a1 = array_pcm_carrier_of_seq r.len s1 in
   let a2 = array_pcm_carrier_of_seq r.len s2 in
   assert (
@@ -512,9 +544,10 @@ let share
 
 let gather
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: array p)
+  (r: array base_t p)
   (s s1 s2: Seq.seq t)
 : A.SteelGhost unit opened
     (pts_to r s1 `star` pts_to r s2)
@@ -529,24 +562,25 @@ let gather
       ))
     )
     (fun _ _ _ -> True)
-= elim_pts_to r s1;
-  elim_pts_to r s2;
+= let _ = elim_pts_to r s1 in
+  let _ = elim_pts_to r s2 in
   let a1 = array_pcm_carrier_of_seq r.len s1 in
   let a2 = array_pcm_carrier_of_seq r.len s2 in
   assert (
     composable (array_pcm p r.len) a1 a2 /\
     op (array_pcm p r.len) a1 a2 `feq` array_pcm_carrier_of_seq r.len s
   );
-  R.gather _ (array_pcm_carrier_of_seq r.len s1) _;
+  let _ = R.gather _ (array_pcm_carrier_of_seq r.len s1) _ in
   intro_pts_to0 r _ s
 
 let sub
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (offset: size_t)
   (len: Ghost.erased size_t)
-: Pure (array p)
+: Pure (array base_t p)
     (requires (size_v offset + size_v len <= size_v a.len))
     (ensures (fun _ -> True))
 = {
@@ -556,21 +590,23 @@ let sub
   }
 
 let split_l
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (i: Ghost.erased size_t)
-: Pure (array p)
+: Pure (array base_t p)
     (requires (size_v i <= size_v a.len))
     (ensures (fun _ -> True))
 = sub a 0sz i
 
 let split_r
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (i: size_t)
-: Pure (array p)
+: Pure (array base_t p)
     (requires (size_v i <= size_v a.len))
     (ensures (fun _ -> True))
 = sub a i (a.len `size_sub` i)
@@ -580,15 +616,16 @@ let split_r
 #restart-solver
 let g_focus_sub
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (s: Seq.seq t)
   (offset: size_t)
   (len: size_t)
   (sq: squash (size_v offset + size_v len <= size_v a.len /\ Seq.length s == size_v a.len))
   (sl: Seq.lseq t (size_v a.len))
-  (al: array p)
+  (al: array base_t p)
   (sl0: Seq.lseq t (size_v len))
 : A.SteelGhost unit opened
     (pts_to a sl)
@@ -648,16 +685,17 @@ let g_focus_sub
 #restart-solver
 let g_split
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (s: Seq.seq t)
   (i: size_t)
   (sq: squash (size_v i <= size_v a.len))
 : A.SteelGhostT (squash (Seq.length s == size_v a.len)) opened
     (pts_to a s)
     (fun _ -> pts_to (split_l a i) (Seq.slice s 0 (size_v i)) `star` pts_to (split_r a i) (Seq.slice s (size_v i) (size_v a.len)))
-= pts_to_length a _;
+= let _ = pts_to_length a _ in
   Classical.forall_intro (is_unit p);
   let sl0 = Seq.slice s 0 (size_v i) in
   let sl : Seq.lseq t (size_v a.len) = sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p) in
@@ -674,15 +712,16 @@ let g_split
 #restart-solver
 let unfocus_sub
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (s: Seq.seq t)
   (offset: size_t)
   (len: size_t)
   (sq: squash (size_v offset + size_v len <= size_v a.len /\ Seq.length s == size_v a.len))
   (sl: Seq.lseq t (size_v a.len))
-  (al: array p)
+  (al: array base_t p)
   (sl0: Seq.lseq t (size_v len))
 : A.SteelGhost unit opened
     (pts_to al sl0)
@@ -716,7 +755,7 @@ let unfocus_sub
       ()
   in
   let xl = array_pcm_carrier_of_seq a.len sl in
-  elim_pts_to al sl0;
+  let _ = elim_pts_to al sl0 in
   ref_focus_comp
     a.base
     (ref_of_array_conn a)
@@ -737,16 +776,25 @@ let unfocus_sub
 
 #pop-options
 
+let mk_lseq
+  (#t: Type)
+  (s: Seq.seq t)
+  (l: nat)
+  (sq: squash (Seq.length s == l))
+: Tot (Seq.lseq t l)
+= s
+
 #push-options "--z3rlimit 256 --fuel 0 --ifuel 1 --z3cliopt smt.arith.nl=false"
 
 #restart-solver
 let join
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (a: array p)
+  (a: array base_t p)
   (i: size_t)
-  (al ar: array p)
+  (al ar: array base_t p)
   (sl0 sr0: Seq.seq t)
 : A.SteelGhost unit opened
     (pts_to al sl0 `star` pts_to ar sr0)
@@ -758,12 +806,12 @@ let join
     )
     (fun _ _ _ -> True)
 =
-  pts_to_length al _;
-  pts_to_length ar _;
+  let _ = pts_to_length al _ in
+  let _ = pts_to_length ar _ in
   Classical.forall_intro (is_unit p);
-  let sl : Seq.lseq t (size_v a.len) = sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p) in
-  let sr : Seq.lseq t (size_v a.len) = Seq.create (size_v i) (one p) `Seq.append` sr0 in
-  let s : Seq.lseq t (size_v a.len) = Seq.append sl0 sr0 in
+  let sl : Seq.lseq t (size_v a.len) = mk_lseq (sl0 `Seq.append` Seq.create (size_v a.len - size_v i) (one p)) (size_v a.len) () in
+  let sr : Seq.lseq t (size_v a.len) = mk_lseq (Seq.create (size_v i) (one p) `Seq.append` sr0) (size_v a.len) () in
+  let s : Seq.lseq t (size_v a.len) = mk_lseq (Seq.append sl0 sr0) (size_v a.len) () in
   assert (i == Ghost.reveal al.len);
   unfocus_sub a s 0sz i () sl al sl0;
   unfocus_sub a s i (a.len `size_sub` i) () sr ar sr0;
@@ -830,10 +878,11 @@ let array_of_ref_conn
 = connection_of_isomorphism (isomorphism_inverse (array_as_one_ref_iso p))
 
 let g_array_of_ref
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: ref p)
-: Ghost (array p)
+  (r: ref base_t p)
+: Ghost (array base_t p)
     (requires True)
     (ensures (fun a ->
       size_v a.base_len == 1 /\
@@ -849,9 +898,10 @@ let g_array_of_ref
   }
 
 let ref_of_array_of_ref_base
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: ref p)
+  (r: ref base_t p)
 : Lemma
   (ref_of_array (g_array_of_ref r) == ref_focus r (array_of_ref_conn p))
 = ref_of_array_id (g_array_of_ref r)
@@ -860,9 +910,10 @@ let ref_of_array_of_ref_base
 
 #restart-solver
 let ref_of_array_of_ref
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
-  (r: ref p)
+  (r: ref base_t p)
 : Lemma
   (ref_focus (ref_of_array (g_array_of_ref r)) (cell p 1sz 0sz) == r)
 = ref_of_array_of_ref_base r;
@@ -876,10 +927,11 @@ let ref_of_array_of_ref
 #restart-solver
 let ghost_array_of_ref
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
   (#v: t)
-  (r: ref p)
+  (r: ref base_t p)
 : A.SteelGhostT unit opened
     (R.pts_to r v)
     (fun _ -> pts_to (g_array_of_ref r) (Seq.create 1 v))
@@ -893,12 +945,13 @@ let ghost_array_of_ref
 
 #restart-solver
 let array_of_ref
+  (#base_t: Type)
   (#t: Type)
   (#opened: _)
   (#p: pcm t)
   (#v: Ghost.erased t)
-  (r: ref p)
-: A.SteelAtomicBase (array p) false opened Unobservable
+  (r: ref base_t p)
+: A.SteelAtomicBase (array base_t p) false opened Unobservable
     (R.pts_to r v)
     (fun a -> pts_to a (Seq.create 1 (Ghost.reveal v)))
     (fun _ -> True)
@@ -908,7 +961,7 @@ let array_of_ref
   let v' : Ghost.erased (array_pcm_carrier t 1sz) = Ghost.hide (field_to_struct_f (array_elements_pcm p 1sz) 0sz v) in
   assert (seq_of_array_pcm_carrier v' `Seq.equal` Seq.create 1 (Ghost.reveal v));
   let r' = R.focus r (array_of_ref_conn p) _ v' in
-  let a : array p = {
+  let a : array base_t p = {
     base_len = 1sz;
     base = r';
     offset = 0sz;
@@ -925,11 +978,12 @@ let array_of_ref
 #restart-solver
 let unarray_of_ref
   (#opened: _)
+  (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
   (#v: Seq.seq t)
-  (r: ref p)
-  (a: array p)
+  (r: ref base_t p)
+  (a: array base_t p)
 : A.SteelGhost (squash (Seq.length v == 1)) opened
     (pts_to a v)
     (fun _ -> R.pts_to r (Seq.index v 0))
@@ -937,7 +991,7 @@ let unarray_of_ref
     (fun _ _ _ -> True)
 = assert_norm (size_v 0sz == 0);
   assert_norm (size_v 1sz == 1);
-  elim_pts_to _ _;
+  let _ = elim_pts_to _ _ in
   ref_of_array_of_ref_base r;
   R.unfocus (ref_of_array a) r (array_of_ref_conn p) _;
   let x = (array_pcm_carrier_of_seq a.len v) in
diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index e70b10f4093..474a4c52039 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -824,10 +824,11 @@ let g_addr_of_struct_field
   gfocus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
 
 let addr_of_struct_field
+  (#opened: _)
   (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
   (r: ref base (prod_pcm p)) (k:a)
   (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
+: A.SteelAtomicBase (ref base (p k)) false opened A.Unobservable
     (r `pts_to` xs)
     (fun s ->
       (r `pts_to` struct_without_field p k xs) `star` 

From d7ec819c7155f019ca9789b0e5442ed706c2ac62 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Feb 2023 16:20:41 -0800
Subject: [PATCH 381/513] move types and pure funs on Steel.C.Model.Ref to new
 Base module

---
 ulib/experimental/Steel.C.Model.Ref.Base.fst  | 83 +++++++++++++++++++
 ulib/experimental/Steel.C.Model.Ref.Base.fsti | 65 +++++++++++++++
 ulib/experimental/Steel.C.Model.Ref.fst       | 79 +-----------------
 ulib/experimental/Steel.C.Model.Ref.fsti      | 61 +-------------
 4 files changed, 150 insertions(+), 138 deletions(-)
 create mode 100644 ulib/experimental/Steel.C.Model.Ref.Base.fst
 create mode 100644 ulib/experimental/Steel.C.Model.Ref.Base.fsti

diff --git a/ulib/experimental/Steel.C.Model.Ref.Base.fst b/ulib/experimental/Steel.C.Model.Ref.Base.fst
new file mode 100644
index 00000000000..d77d6fd71da
--- /dev/null
+++ b/ulib/experimental/Steel.C.Model.Ref.Base.fst
@@ -0,0 +1,83 @@
+module Steel.C.Model.Ref.Base
+module P = FStar.PCM
+module U = Steel.C.Model.Universe
+open FStar.FunctionalExtensionality
+
+#push-options "--print_universes"
+
+noeq type ref0 (a: Type u#0) (b: Type u#b) : Type u#b = {
+  p: pcm a;
+  q: pcm b;
+  pl: connection p q;
+  r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
+}
+
+noeq type ptr' (a: Type u#0) (b: Type u#b) : Type u#b =
+  | NonNull: (v: ref0 a b) -> ptr' a b
+  | Null: (v: pcm b) -> ptr' a b
+
+let pcm_of_ptr'
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ptr' a b)
+: Tot (pcm b)
+= if Null? r then Null?.v r else (NonNull?.v r).q
+
+let ptr a #b p = (r: ptr' a b { pcm_of_ptr' r == p })
+
+let null a p = Null p
+
+let ptr_is_null p = Null? p
+
+let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
+
+let raise_p
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ptr' a b { NonNull? r})
+: Tot (pcm (U.raise_t u#0 u#1 a))
+= U.raise_pcm (NonNull?.v r).p
+
+let lower_conn
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ptr' a b { NonNull? r})
+: Tot (connection (raise_p r) (NonNull?.v r).p)
+= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (NonNull?.v r).p))
+
+let raise_pl
+  (#a: Type u#0)
+  (#b: Type u#b)
+  (r: ptr' a b {NonNull? r})
+: Tot (connection (raise_p r) (NonNull?.v r).q)
+= lower_conn r `connection_compose` (NonNull?.v r).pl
+
+let t_ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: Tot (ref a q)
+= let NonNull r = r in
+  NonNull ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
+
+let ref_focus r l = t_ref_focus r l
+
+let ref_focus_id r = connection_compose_id_right (NonNull?.v r).pl
+
+let ref_focus_comp r l m
+= connection_compose_assoc (NonNull?.v r).pl l m
+
+(* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
+
+let freeable #a #b #p r =
+  let NonNull r = r in
+  a == b /\
+  r.p == p /\
+  r.pl == connection_id p
+
+let pts_to r v =
+  (NonNull?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
+
+let base_fpu p x y =
+  fun _ ->
+  compatible_refl p y;
+  y
diff --git a/ulib/experimental/Steel.C.Model.Ref.Base.fsti b/ulib/experimental/Steel.C.Model.Ref.Base.fsti
new file mode 100644
index 00000000000..164b5d525ee
--- /dev/null
+++ b/ulib/experimental/Steel.C.Model.Ref.Base.fsti
@@ -0,0 +1,65 @@
+module Steel.C.Model.Ref.Base
+open FStar.FunctionalExtensionality
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+open Steel.Effect.Common
+
+(** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
+val ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
+
+val null (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a p)
+
+val ptr_is_null (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null a p))
+
+let refine (a: Type) (p: (a -> prop)) : Tot Type =
+  (x: a { p x })
+
+let not_null
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p)
+: Tot prop
+= ptr_is_null r == false
+
+(** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
+let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
+  refine (ptr a q) (not_null #a #b #q)
+
+(** Given a reference to an element of PCM p and a connection l from p to q,
+    [ref_focus r l] is a reference to an element of q. The intuition is that
+    q represents a "part of" p (e.g. a struct field, union case, or array slice). *)
+val ref_focus
+  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
+  (r: ref a p) (#q: pcm c) (l: connection p q)
+: GTot (ref a q)
+
+val ref_focus_id
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p)
+: Lemma
+  (ref_focus r (connection_id _) == r)
+
+val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
+  (l: connection p q) (m: connection q s)
+: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
+  [SMTPatOr [
+    [SMTPat (ref_focus (ref_focus r l) m)]; 
+    [SMTPat (ref_focus r (l `connection_compose` m))]]]
+
+val freeable
+  (#a: Type0) (#b:Type0) (#p: pcm b) (r: ref a p)
+: Tot prop
+
+(** r points to PCM carrier value v *)
+val pts_to
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: ref a p) ([@@@smt_fallback] v: b)
+: vprop
+
+(** Construct a write from a frame-preserving update. *)
+val base_fpu
+  (#a: Type)
+  (p: pcm a)
+  (x: Ghost.erased a)
+  (y: a)
+: Pure (frame_preserving_upd p x y)
+  (requires (exclusive p x /\ p_refine p y))
+  (ensures (fun _ -> True))
diff --git a/ulib/experimental/Steel.C.Model.Ref.fst b/ulib/experimental/Steel.C.Model.Ref.fst
index 076a013a788..f884352c66f 100644
--- a/ulib/experimental/Steel.C.Model.Ref.fst
+++ b/ulib/experimental/Steel.C.Model.Ref.fst
@@ -3,71 +3,7 @@ module P = FStar.PCM
 module U = Steel.C.Model.Universe
 open FStar.FunctionalExtensionality
 
-#push-options "--print_universes"
-
-noeq type ref0 (a: Type u#0) (b: Type u#b) : Type u#b = {
-  p: pcm a;
-  q: pcm b;
-  pl: connection p q;
-  r: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm p));
-}
-
-noeq type ptr' (a: Type u#0) (b: Type u#b) : Type u#b =
-  | NonNull: (v: ref0 a b) -> ptr' a b
-  | Null: (v: pcm b) -> ptr' a b
-
-let pcm_of_ptr'
-  (#a: Type u#0)
-  (#b: Type u#b)
-  (r: ptr' a b)
-: Tot (pcm b)
-= if Null? r then Null?.v r else (NonNull?.v r).q
-
-let ptr a #b p = (r: ptr' a b { pcm_of_ptr' r == p })
-
-let null a p = Null p
-
-let ptr_is_null p = Null? p
-
-let mpts_to (#a: Type u#1) (#p: P.pcm a) (r: Steel.Memory.ref a p) ([@@@smt_fallback] v: a) = Steel.PCMReference.pts_to r v
-
-let raise_p
-  (#a: Type u#0)
-  (#b: Type u#b)
-  (r: ptr' a b { NonNull? r})
-: Tot (pcm (U.raise_t u#0 u#1 a))
-= U.raise_pcm (NonNull?.v r).p
-
-let lower_conn
-  (#a: Type u#0)
-  (#b: Type u#b)
-  (r: ptr' a b { NonNull? r})
-: Tot (connection (raise_p r) (NonNull?.v r).p)
-= connection_of_isomorphism (isomorphism_inverse (U.raise_pcm_isomorphism u#0 u#1 (NonNull?.v r).p))
-
-let raise_pl
-  (#a: Type u#0)
-  (#b: Type u#b)
-  (r: ptr' a b {NonNull? r})
-: Tot (connection (raise_p r) (NonNull?.v r).q)
-= lower_conn r `connection_compose` (NonNull?.v r).pl
-
-let pts_to r v =
-  (NonNull?.v r).r `mpts_to` (raise_pl r).conn_small_to_large.morph v
-
-let t_ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref a p) (#q: pcm c) (l: connection p q)
-: Tot (ref a q)
-= let NonNull r = r in
-  NonNull ({p = r.p; pl = connection_compose r.pl l; r = r.r; q = q})
-
-let ref_focus r l = t_ref_focus r l
-
-let ref_focus_id r = connection_compose_id_right (NonNull?.v r).pl
-
-let ref_focus_comp r l m
-= connection_compose_assoc (NonNull?.v r).pl l m
+friend Steel.C.Model.Ref.Base
 
 let mk_id_ref
   (#a: Type0)
@@ -79,14 +15,6 @@ let mk_id_ref
   let fp = fstar_pcm_of_pcm p' in
   NonNull ({ p = p; q = p; pl = connection_id p; r = r0 })
 
-(* freeable r if and only if r is a "base" reference, i.e. its connection path is empty *)
-
-let freeable #a #b #p r =
-  let NonNull r = r in
-  a == b /\
-  r.p == p /\
-  r.pl == connection_id p
-
 #push-options "--z3rlimit 16"
 
 let ref_alloc #a p x =
@@ -208,11 +136,6 @@ let as_action (#p:vprop)
 
 let ref_upd r x y f = as_action (ref_upd_act r x y f)
 
-let base_fpu p x y =
-  fun _ ->
-  compatible_refl p y;
-  y
-
 let pts_to_view_explicit
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
diff --git a/ulib/experimental/Steel.C.Model.Ref.fsti b/ulib/experimental/Steel.C.Model.Ref.fsti
index 1d2ebe69229..d3b172f7825 100644
--- a/ulib/experimental/Steel.C.Model.Ref.fsti
+++ b/ulib/experimental/Steel.C.Model.Ref.fsti
@@ -2,63 +2,14 @@ module Steel.C.Model.Ref
 open FStar.FunctionalExtensionality
 open Steel.C.Model.PCM
 open Steel.C.Model.Connection
+include Steel.C.Model.Ref.Base
 
 #push-options "--print_universes"
 
-(** A [ptr a b] is a (maybe null) pointer to some value of type b inside of a "base object" of type a. *)
-val ptr (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (Type u#b)
-
-val null (a: Type u#0) (#b: Type u#b) (p: pcm b) : Tot (ptr a p)
-
-val ptr_is_null (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p) : Ghost bool (requires True) (ensures (fun res -> res == true <==> r == null a p))
-
-let refine (a: Type) (p: (a -> prop)) : Tot Type =
-  (x: a { p x })
-
-let not_null
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b) (r: ptr a p)
-: Tot prop
-= ptr_is_null r == false
-
-(** A [ref a #b q] is a [ref' a b] where the PCM inside the ref' is forced to be q *)
-let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
-  refine (ptr a q) (not_null #a #b #q)
-
 open Steel.Effect
 
-(** r points to PCM carrier value v *)
-val pts_to
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: ref a p) ([@@@smt_fallback] v: b)
-: vprop
-
-(** Given a reference to an element of PCM p and a connection l from p to q,
-    [ref_focus r l] is a reference to an element of q. The intuition is that
-    q represents a "part of" p (e.g. a struct field, union case, or array slice). *)
-val ref_focus
-  (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
-  (r: ref a p) (#q: pcm c) (l: connection p q)
-: GTot (ref a q)
-
-val ref_focus_id
-  (#a:Type) (#b:Type) (#p: pcm b)
-  (r: ref a p)
-: Lemma
-  (ref_focus r (connection_id _) == r)
-
-val ref_focus_comp (#p: pcm 'a) (#q: pcm 'b) (#s: pcm 'c) (r: ref 'd p)
-  (l: connection p q) (m: connection q s)
-: Lemma (ref_focus (ref_focus r l) m == ref_focus r (l `connection_compose` m))
-  [SMTPatOr [
-    [SMTPat (ref_focus (ref_focus r l) m)]; 
-    [SMTPat (ref_focus r (l `connection_compose` m))]]]
-
 module A = Steel.Effect.Atomic
 
-val freeable
-  (#a: Type0) (#b:Type0) (#p: pcm b) (r: ref a p)
-: Tot prop
-
 (** Allocate a reference containing value x. *)
 val ref_alloc
   (#a:Type0) (p: pcm a) (x: a)
@@ -141,16 +92,6 @@ val ref_upd
   (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
 : SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
 
-(** Construct a write from a frame-preserving update. *)
-val base_fpu
-  (#a: Type)
-  (p: pcm a)
-  (x: Ghost.erased a)
-  (y: a)
-: Pure (frame_preserving_upd p x y)
-  (requires (exclusive p x /\ p_refine p y))
-  (ensures (fun _ -> True))
-
 (** PCM carrier values are cumbersome to work with directly. To
     abstract over them, we define "view"s, which are essentially
     lossless partial functions from PCM carrier values to "view

From 02583cb311a3964990ed1c7de18237090e329fab Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Feb 2023 16:34:59 -0800
Subject: [PATCH 382/513] Steel.ST.C.Model.Ref

---
 ulib/experimental/Steel.ST.C.Model.Ref.fst  | 42 ++++++++++
 ulib/experimental/Steel.ST.C.Model.Ref.fsti | 90 +++++++++++++++++++++
 2 files changed, 132 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Ref.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Ref.fsti

diff --git a/ulib/experimental/Steel.ST.C.Model.Ref.fst b/ulib/experimental/Steel.ST.C.Model.Ref.fst
new file mode 100644
index 00000000000..fa148f706a0
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Ref.fst
@@ -0,0 +1,42 @@
+module Steel.ST.C.Model.Ref
+
+// FIXME: in fact, to avoid those explicit coercions below, we should
+// swap Steel.ST.C.Model.Ref.fst and Steel.C.Model.Ref.fst for the
+// non-view operations, thus benefitting from the automatic effect
+// liftings
+
+module STC = Steel.ST.Coercions
+module SR = Steel.C.Model.Ref
+
+let ref_alloc
+  p x
+= STC.coerce_steel (fun _ -> SR.ref_alloc p x)
+
+let ref_free
+  r
+= STC.coerce_steel (fun _ -> SR.ref_free r)
+
+let gfocus
+  r l s x
+= STC.coerce_ghost (fun _ -> SR.gfocus r l s x)
+
+let focus
+  r l s x
+= STC.coerce_atomic (fun _ -> SR.focus r l s x)
+
+let unfocus
+  r r' l x
+= STC.coerce_ghost (fun _ -> SR.unfocus r r' l x)
+
+let split r xy x y
+= STC.coerce_ghost (fun _ -> SR.split r xy x y)
+
+let gather r x y
+= STC.coerce_ghost (fun _ -> SR.gather r x y)
+
+let ref_read r
+= STC.coerce_steel (fun _ -> SR.ref_read r)
+
+let ref_upd
+  r x y f
+= STC.coerce_steel (fun _ -> SR.ref_upd r x y f)
diff --git a/ulib/experimental/Steel.ST.C.Model.Ref.fsti b/ulib/experimental/Steel.ST.C.Model.Ref.fsti
new file mode 100644
index 00000000000..36fa6e143b2
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Ref.fsti
@@ -0,0 +1,90 @@
+module Steel.ST.C.Model.Ref
+open Steel.ST.Util
+
+include Steel.C.Model.Ref.Base
+
+open FStar.FunctionalExtensionality
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+
+(** Allocate a reference containing value x. *)
+val ref_alloc
+  (#a:Type0) (p: pcm a) (x: a)
+: ST (ref a p)
+    emp
+    (fun r -> r `pts_to` x)
+    (requires p_refine p x)
+    (ensures fun r -> freeable r)
+
+(** Free a "base" (freeable) reference containing a "whole" (p_refine) value x. *)
+val ref_free
+  (#a #b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+: ST unit
+    (r `pts_to` x)
+    (fun _ -> emp)
+    (requires p_refine p x /\ freeable r)
+    (ensures fun _ -> True)
+
+
+(** Take a pointer to a "substructure" of a reference. *)
+val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
+  (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: STGhost unit inames
+    (r `pts_to` s)
+    (fun _ -> ref_focus r l `pts_to` x)
+    (Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun _ -> True)
+
+val focus (#opened: _) (#p: pcm 'b) (r: ref 'a p)
+  (#q: pcm 'c)
+  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
+: STAtomicBase (ref 'a q)
+    false opened Unobservable
+    (r `pts_to` s)
+    (fun r' -> r' `pts_to` x)
+    (Ghost.reveal s == l.conn_small_to_large.morph x)
+    (fun r' -> r' == ref_focus r l)
+
+module M = Steel.Memory
+
+(** Inverse of focus. *)
+val unfocus (#opened:M.inames)
+  (#p: pcm 'b)
+  (#q: pcm 'c)
+  (r: ref 'a q) (r': ref 'a p)
+  (l: connection p q) (x: Ghost.erased 'c)
+: STGhost unit opened
+    (r `pts_to` x)
+    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
+    (requires r == ref_focus r' l)
+    (ensures fun _ -> True)
+
+(** Split the permissions on a reference into two halves. *)
+val split (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
+: STGhost unit inames
+    (r `pts_to` xy)
+    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
+    (composable p x y /\ xy == Ghost.hide (op p x y))
+    (fun _ -> True)
+
+(** Inverse of split. *)
+val gather (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
+: STGhostT (_:unit{composable p x y}) inames
+    ((r `pts_to` x) `star` (r `pts_to` y))
+    (fun _ -> r `pts_to` op p x y)
+
+(** Read a PCM carrier value. *)
+val ref_read
+  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
+: ST b
+    (r `pts_to` x)
+    (fun _ -> r `pts_to` x)
+    (requires True)
+    (ensures fun x' -> compatible p x x')
+
+(** Write a PCM carrier value. *)
+val ref_upd
+  (#a:Type) (#b:Type) (#p: pcm b)
+  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
+: STT unit (r `pts_to` x) (fun _ -> r `pts_to` y)

From 79c9feb23567c16bd8f27bbdcb11f5fc20789955 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Feb 2023 18:49:33 -0800
Subject: [PATCH 383/513] Steel.ST.HigherReference

---
 .../experimental/Steel.ST.HigherReference.fst | 188 ++++++++++++++++
 .../Steel.ST.HigherReference.fsti             | 205 ++++++++++++++++++
 2 files changed, 393 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.HigherReference.fst
 create mode 100644 ulib/experimental/Steel.ST.HigherReference.fsti

diff --git a/ulib/experimental/Steel.ST.HigherReference.fst b/ulib/experimental/Steel.ST.HigherReference.fst
new file mode 100644
index 00000000000..313822f34fe
--- /dev/null
+++ b/ulib/experimental/Steel.ST.HigherReference.fst
@@ -0,0 +1,188 @@
+(*
+   Copyright 2020 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.ST.HigherReference
+open FStar.Ghost
+open Steel.ST.Util
+open Steel.ST.Coercions
+module R = Steel.HigherReference
+
+let ref (a:Type u#1)
+  : Type0
+  = R.ref a
+
+let null (#a:Type)
+  : ref a
+  = R.null #a
+
+let is_null (#a:Type) (r:ref a)
+  : b:bool{b <==> r == null}
+  = R.is_null r
+
+let pts_to (#a:Type)
+           (r:ref a)
+           ([@@@smt_fallback] p:perm)
+           ([@@@smt_fallback] v:a)
+  : vprop
+  = R.pts_to r p v
+
+let pts_to_injective_eq
+      (#a: Type)
+      (#opened:inames)
+      (#p0 #p1:perm)
+      (#v0 #v1:a)
+      (r: ref a)
+  : STGhost unit opened
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+  = coerce_ghost
+    (fun _ -> R.higher_ref_pts_to_injective_eq #a #opened #p0 #p1 #(hide v0) #(hide v1) r)
+
+let pts_to_not_null #a #opened #p #v r
+  = extract_fact #opened (pts_to r p v) (r =!= null) (R.pts_to_not_null r p v);
+    ()
+
+let alloc (#a:Type) (x:a)
+  : ST (ref a)
+      emp
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> not (is_null r))
+  = let r = coerce_steel (fun _ -> R.alloc x) in
+    r
+
+let read (#a:Type)
+         (#p:perm)
+         (#v:erased a)
+         (r:ref a)
+  : ST a
+      (pts_to r p v)
+      (fun _ -> pts_to r p v)
+      (requires True)
+      (ensures fun x -> x == Ghost.reveal v)
+  = let u = coerce_steel (fun _ -> R.read r) in
+    return u
+
+let write (#a:Type)
+          (#v:erased a)
+          (r:ref a)
+          (x:a)
+  : STT unit
+      (pts_to r full_perm v)
+      (fun _ -> pts_to r full_perm x)
+  = coerce_steel (fun _ -> R.write r x);
+    return ()
+
+let free (#a:Type)
+         (#v:erased a)
+         (r:ref a)
+  : STT unit
+        (pts_to r full_perm v)
+        (fun _ -> emp)
+  = coerce_steel(fun _ -> R.free r);
+    return ()
+
+/// Local primitive, to be extracted to Low* EPushFrame.  To remember
+/// that we need to call some pop_frame later, we insert some dummy
+/// vprop into the context.
+let _stack_frame : vprop = pure True
+let _push_frame () : STT unit emp (fun _ -> _stack_frame) =
+  rewrite (pure True) _stack_frame
+
+/// Local primitive, to be extracted to Low* EBufCreate
+let _alloca (#a:Type) (x:a)
+  : ST (ref a)
+      emp
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> not (is_null r))
+= alloc x
+
+/// Local primitive, to be extracted to Low* EPopFrame
+let _free_and_pop_frame
+  (#a:Type)
+  (#v:erased a)
+  (r:ref a)
+: STT unit
+    (pts_to r full_perm v `star` _stack_frame)
+    (fun _ -> emp)
+= free r;
+  rewrite _stack_frame (pure True);
+  elim_pure _
+
+let with_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+= _push_frame ();
+  let r = _alloca init in
+  let v = body r in
+  let _ = elim_exists () in
+  _free_and_pop_frame r;
+  return v
+
+let with_named_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (name: string)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+= _push_frame ();
+  [@(rename_let name)]
+  let r = _alloca init in
+  let v = body r in
+  let _ = elim_exists () in
+  _free_and_pop_frame r;
+  return v
+
+let share (#a:Type)
+          (#uses:_)
+          (#p:perm)
+          (#v:erased a)
+          (r:ref a)
+  : STGhostT unit uses
+      (pts_to r p v)
+      (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
+  = coerce_ghost (fun _ -> R.share r)
+
+let gather (#a:Type)
+           (#uses:_)
+           (#p0 p1:perm)
+           (#v0 #v1:erased a)
+           (r:ref a)
+  : STGhost unit uses
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r (sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+  = coerce_ghost (fun _ -> R.gather #a #uses #p0 #p1 #v0 #v1 r)
diff --git a/ulib/experimental/Steel.ST.HigherReference.fsti b/ulib/experimental/Steel.ST.HigherReference.fsti
new file mode 100644
index 00000000000..1a2f568fd87
--- /dev/null
+++ b/ulib/experimental/Steel.ST.HigherReference.fsti
@@ -0,0 +1,205 @@
+(*
+   Copyright 2021 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.ST.HigherReference
+open FStar.Ghost
+open Steel.ST.Util
+
+module U32 = FStar.UInt32
+
+(** This module provides a reference whose ownership is controlled
+    using fractional permissions.
+    
+    It provides a distinguished null reference too, which is
+    extractable to C as a null pointer. *)
+
+/// The main ref type.
+///
+/// It's in universe zero, so refs can be stored in the heap, you can
+/// have [ref (ref a)] etc.
+val ref ([@@@ strictly_positive] a:Type u#1)
+  : Type0
+
+/// The null reference
+val null (#a:Type) 
+  : ref a
+
+/// Nullness is decidable with a pure function
+val is_null (#a:Type) (r:ref a)
+  : b:bool{b <==> r == null}
+
+/// The main representation predicate
+///
+/// Both the permissions [p] and the value [v] are marked with the
+/// [smt_fallback] attribute. This allows the Steel unifier to produce
+/// equality goals discharged by SMT to relate instances of the
+/// [pts_to] predicate that differ on the [p] and [v] arguments.
+///
+/// For instance, [pts_to r (sum_perm (half_perm p) (half_perm p)) (v + 1)]
+/// is unifiable with [pts_to r p (1 + v)]
+val pts_to (#a:Type)
+           (r:ref a)
+           ([@@@smt_fallback] p:perm)
+           ([@@@smt_fallback] v:a)
+  : vprop
+
+/// A reference can point to at most one value
+val pts_to_injective_eq (#a: Type)
+                        (#opened:inames)
+                        (#p0 #p1:perm)
+                        (#v0 #v1: a)
+                        (r: ref a)
+  : STGhost unit opened
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+
+/// Null references can't point to anything
+val pts_to_not_null (#a:Type)
+                    (#opened:inames)
+                    (#p:perm)
+                    (#v:a)
+                    (r:ref a)
+  : STGhost unit opened
+      (pts_to r p v)
+      (fun _ -> pts_to r p v)
+      (requires True)
+      (ensures fun _ -> r =!= null)
+                    
+/// Allocating a reference returns full-permission to a non-null
+/// reference pointing to the initializer [x].
+///
+/// We do not model memory exhaustion
+val alloc (#a:Type) (x:a)
+  : ST (ref a)
+      emp 
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> not (is_null r))
+
+/// Reads the value in reference [r]. The postcondition ensures that
+/// the returned value is equal to the index [v].
+val read (#a:Type)
+         (#p:perm)
+         (#v:erased a)
+         (r:ref a)
+  : ST a
+      (pts_to r p v)
+      (fun x -> pts_to r p v)
+      (requires True)
+      (ensures fun x -> x == Ghost.reveal v)
+
+/// Writes value `x` in the reference `r`, as long as we have full
+/// ownership of `r`
+val write (#a:Type)
+          (#v:erased a)
+          (r:ref a)
+          (x:a)
+  : STT unit
+      (pts_to r full_perm v)
+      (fun _ -> pts_to r full_perm x)
+
+/// Frees reference [r], as long as we have full ownership of [r]
+val free (#a:Type)
+         (#v:erased a)
+         (r:ref a)
+  : STT unit
+    (pts_to r full_perm v) (fun _ -> emp)
+
+/// Executes a code block with a local variable temporarily allocated
+/// on the stack. This function is declared in the `STF` effect so
+/// that the pre- and post-resources can be properly inferred by the
+/// Steel tactic from the caller's context.
+///
+/// From the extraction point of view, `with_local init body` is to behave
+/// similarly as the following Low* code:
+///
+/// <<<
+/// push_frame ();
+/// let r = alloca 1ul init in
+/// let res = body r in
+/// pop_frame ();
+/// r
+/// >>>
+///
+/// and thus, is to be extracted to C as:
+/// <<<
+/// ret_t res;
+/// {
+///   t r = init;
+///   res = <body r>;
+/// }
+/// >>>
+///
+/// To this end, we mimic the Low* behavior by defining local
+/// primitives with primitive extraction in the `.fst`, and have them
+/// called by `with_local`. This is why we mark `with_local` as
+/// `inline_for_extraction`.
+inline_for_extraction
+val with_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+
+/// Same as with_local, with an additional string argument to set the
+/// name of the local variable in the extracted C code.
+inline_for_extraction
+val with_named_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (name: string)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+
+/// Splits the permission on reference [r] into two. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val share (#a:Type)
+          (#uses:_)
+          (#p:perm)
+          (#v:erased a)
+          (r:ref a)
+  : STGhostT unit uses
+      (pts_to r p v)
+      (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
+
+/// Combines permissions on reference [r]. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val gather (#a:Type)
+           (#uses:_) 
+           (#p0 p1:perm)
+           (#v0 #v1:erased a)
+           (r:ref a)
+  : STGhost unit uses
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r (sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)

From b161d4d1e9d72fc51d5457f9124268c5c391c686 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Feb 2023 14:06:27 -0800
Subject: [PATCH 384/513] upgrade GenElim to universe 1

---
 ulib/experimental/Steel.ST.GenElim.Base.fst  |   2 +-
 ulib/experimental/Steel.ST.GenElim.Base.fsti | 190 ++++++++-----
 ulib/experimental/Steel.ST.GenElim.fst       | 285 ++++++++++++-------
 ulib/experimental/Steel.ST.GenElim.fsti      |   6 +-
 4 files changed, 315 insertions(+), 168 deletions(-)

diff --git a/ulib/experimental/Steel.ST.GenElim.Base.fst b/ulib/experimental/Steel.ST.GenElim.Base.fst
index 7c8b7334eee..183ea41cb9f 100644
--- a/ulib/experimental/Steel.ST.GenElim.Base.fst
+++ b/ulib/experimental/Steel.ST.GenElim.Base.fst
@@ -6,7 +6,7 @@ irreducible let gen_elim_reduce = ()
 let gen_elim_pred
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
   (ij: (gen_elim_i & gen_elim_nondep_t))
diff --git a/ulib/experimental/Steel.ST.GenElim.Base.fsti b/ulib/experimental/Steel.ST.GenElim.Base.fsti
index 2420c7bde31..bc5d80a8296 100644
--- a/ulib/experimental/Steel.ST.GenElim.Base.fsti
+++ b/ulib/experimental/Steel.ST.GenElim.Base.fsti
@@ -22,9 +22,12 @@ type gen_elim_i =
   | GEStarL: (left: gen_elim_i) -> (right: gen_unit_elim_i) -> gen_elim_i
   | GEStarR: (left: gen_unit_elim_i) -> (right: gen_elim_i) -> gen_elim_i
   | GEStar: (left: gen_elim_i) -> (right: gen_elim_i) -> gen_elim_i
-  | GEExistsNoAbs: (#a: Type0) -> (body: (a -> vprop)) -> gen_elim_i // FIXME: generalize the universe
-  | GEExistsUnit: (#a: Type0) -> (body: (a -> gen_unit_elim_i)) -> gen_elim_i
-  | GEExists: (#a: Type0) -> (body: (a -> gen_elim_i)) -> gen_elim_i
+  | GEExistsNoAbs0: (#a: Type0) -> (body: (a -> vprop)) -> gen_elim_i // FIXME: generalize the universe
+  | GEExistsUnit0: (#a: Type0) -> (body: (a -> gen_unit_elim_i)) -> gen_elim_i
+  | GEExists0: (#a: Type0) -> (body: (a -> gen_elim_i)) -> gen_elim_i
+  | GEExistsNoAbs1: (#a: Type u#1) -> (body: (a -> vprop)) -> gen_elim_i // FIXME: generalize the universe
+  | GEExistsUnit1: (#a: Type u#1) -> (body: (a -> gen_unit_elim_i)) -> gen_elim_i
+  | GEExists1: (#a: Type u#1) -> (body: (a -> gen_elim_i)) -> gen_elim_i
 
 val gen_elim_reduce: unit
 
@@ -64,24 +67,32 @@ let rec compute_gen_elim_p
   | GEStarL left right -> compute_gen_elim_p left `star` compute_gen_unit_elim_p right
   | GEStarR left right -> compute_gen_unit_elim_p left `star` compute_gen_elim_p right
   | GEStar left right -> compute_gen_elim_p left `star` compute_gen_elim_p right
-  | GEExistsNoAbs #a p -> exists_ p
-  | GEExistsUnit #a p -> exists_ (fun x -> compute_gen_unit_elim_p (p x))
-  | GEExists #a body -> exists_ (fun x -> compute_gen_elim_p (body x))
+  | GEExistsNoAbs0 #a p -> exists_ p
+  | GEExistsUnit0 #a p -> exists_ (fun x -> compute_gen_unit_elim_p (p x))
+  | GEExists0 #a body -> exists_ (fun x -> compute_gen_elim_p (body x))
+  | GEExistsNoAbs1 #a p -> exists_ p
+  | GEExistsUnit1 #a p -> exists_ (fun x -> compute_gen_unit_elim_p (p x))
+  | GEExists1 #a body -> exists_ (fun x -> compute_gen_elim_p (body x))
 
 let compute_gen_elim_p' = compute_gen_elim_p
 
+module U = FStar.Universe
+
 [@@ gen_elim_reduce; __steel_reduce__; noextract_to "Plugin"]
 let rec compute_gen_elim_a
   (x: gen_elim_i)
-: Tot Type0
+: Tot (Type u#1)
 = match x with
-  | GEUnit _ -> unit
+  | GEUnit _ -> U.raise_t unit
   | GEStarL left _ -> compute_gen_elim_a left
   | GEStarR _ right -> compute_gen_elim_a right
   | GEStar left right -> (compute_gen_elim_a left & compute_gen_elim_a right)
-  | GEExistsNoAbs #a _
-  | GEExistsUnit #a _ -> a
-  | GEExists #a body -> dtuple2 a (fun x -> compute_gen_elim_a (body x))
+  | GEExistsNoAbs0 #a _
+  | GEExistsUnit0 #a _ -> U.raise_t a
+  | GEExists0 #a body -> dtuple2 a (fun x -> compute_gen_elim_a (body x))
+  | GEExistsNoAbs1 #a _
+  | GEExistsUnit1 #a _ -> a
+  | GEExists1 #a body -> dtuple2 a (fun x -> compute_gen_elim_a (body x))
 
 [@@noextract_to "Plugin"]
 let dfstp #a #b t = dfst #a #b t
@@ -110,9 +121,18 @@ let rec compute_gen_elim_q
     fun v ->
       let v' : (tleft & tright) = coerce_with_trefl v in
       compute_gen_elim_q left (fstp #tleft #tright v') `star` compute_gen_elim_q right (sndp #tleft #tright v')
-  | GEExistsNoAbs #a p -> p
-  | GEExistsUnit #a p -> fun v -> compute_gen_unit_elim_q (p v)
-  | GEExists #a body ->
+  | GEExistsNoAbs0 #a p -> fun v -> p (U.downgrade_val v)
+  | GEExistsUnit0 #a p -> fun v -> compute_gen_unit_elim_q (p (U.downgrade_val v))
+  | GEExists0 #a body ->
+    let dept = (fun x -> compute_gen_elim_a (body x)) in
+    fun v ->
+    let v' : dtuple2 a dept = coerce_with_trefl v in
+    compute_gen_elim_q
+      (body (dfstp #a #dept v'))
+      (dsndp #a #dept v')
+  | GEExistsNoAbs1 #a p -> p
+  | GEExistsUnit1 #a p -> fun v -> compute_gen_unit_elim_q (p v)
+  | GEExists1 #a body ->
     let dept = (fun x -> compute_gen_elim_a (body x)) in
     fun v ->
     let v' : dtuple2 a dept = coerce_with_trefl v in
@@ -135,9 +155,18 @@ let rec compute_gen_elim_post
     fun v ->
       let v' : (tleft & tright) = coerce_with_trefl v in
       compute_gen_elim_post left (fstp #tleft #tright v') /\ compute_gen_elim_post right (sndp #tleft #tright v')
-  | GEExistsNoAbs #a p -> fun _ -> True
-  | GEExistsUnit #a p -> fun v -> compute_gen_unit_elim_post (p v)
-  | GEExists #a body ->
+  | GEExistsNoAbs0 #a p -> fun _ -> True
+  | GEExistsUnit0 #a p -> fun v -> compute_gen_unit_elim_post (p (U.downgrade_val v))
+  | GEExists0 #a body ->
+    let dept = (fun x -> compute_gen_elim_a (body x)) in
+    fun v ->
+    let v' : dtuple2 a dept = coerce_with_trefl v in
+    compute_gen_elim_post
+      (body (dfstp #a #dept v'))
+      (dsndp #a #dept v')
+  | GEExistsNoAbs1 #a p -> fun _ -> True
+  | GEExistsUnit1 #a p -> fun v -> compute_gen_unit_elim_post (p v)
+  | GEExists1 #a body ->
     let dept = (fun x -> compute_gen_elim_a (body x)) in
     fun v ->
     let v' : dtuple2 a dept = coerce_with_trefl v in
@@ -147,9 +176,9 @@ let rec compute_gen_elim_post
 
 [@@erasable]
 noeq
-type gen_elim_tele =
+type gen_elim_tele : Type u#(max 2 (a + 1)) =
   | TRet: vprop -> prop -> gen_elim_tele
-  | TExists: (ty: Type u#0) -> (ty -> gen_elim_tele) -> gen_elim_tele
+  | TExists: (ty: Type u#a) -> (ty -> gen_elim_tele) -> gen_elim_tele
 
 [@@gen_elim_reduce]
 let rec tele_star_vprop (i: gen_elim_tele) (v: vprop) (p: prop) : Tot gen_elim_tele (decreases i) =
@@ -165,15 +194,18 @@ let rec tele_star (i1 i2: gen_elim_tele) : Tot gen_elim_tele =
   | TExists ty1 f1, TExists ty2 f2 -> TExists ty1 (fun x1 -> TExists ty2 (fun x2 -> tele_star (f1 x1) (f2 x2)))
 
 [@@gen_elim_reduce]
-let rec compute_gen_elim_tele (x: gen_elim_i) : Tot gen_elim_tele =
+let rec compute_gen_elim_tele (x: gen_elim_i) : Tot (gen_elim_tele u#1) =
   match x with
   | GEUnit v -> TRet (compute_gen_unit_elim_q v) (compute_gen_unit_elim_post v)
   | GEStarL l ru -> tele_star_vprop (compute_gen_elim_tele l) (compute_gen_unit_elim_q ru) (compute_gen_unit_elim_post ru)
   | GEStarR lu r -> tele_star_vprop (compute_gen_elim_tele r) (compute_gen_unit_elim_q lu) (compute_gen_unit_elim_post lu)
   | GEStar l r -> tele_star (compute_gen_elim_tele l) (compute_gen_elim_tele r)
-  | GEExistsNoAbs #ty body -> TExists ty (fun x -> TRet (body x) True)
-  | GEExistsUnit #ty body -> TExists ty (fun x -> TRet (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_post (body x)))
-  | GEExists #ty f -> TExists ty (fun x -> compute_gen_elim_tele (f x))
+  | GEExistsNoAbs0 #ty body -> TExists (U.raise_t ty) (fun x -> TRet (body (U.downgrade_val x)) True)
+  | GEExistsUnit0 #ty body -> TExists (U.raise_t ty) (fun x -> TRet (compute_gen_unit_elim_q (body (U.downgrade_val x))) (compute_gen_unit_elim_post (body (U.downgrade_val x))))
+  | GEExists0 #ty f -> TExists (U.raise_t ty) (fun x -> compute_gen_elim_tele (f (U.downgrade_val x)))
+  | GEExistsNoAbs1 #ty body -> TExists ty (fun x -> TRet (body x) True)
+  | GEExistsUnit1 #ty body -> TExists ty (fun x -> TRet (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_post (body x)))
+  | GEExists1 #ty f -> TExists ty (fun x -> compute_gen_elim_tele (f x))
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
 let rec curried_function_type (x: list (Type u#a)) (ret_t: Type u#(max a b)) : Tot (Type u#(max a b)) =
@@ -183,56 +215,56 @@ let rec curried_function_type (x: list (Type u#a)) (ret_t: Type u#(max a b)) : T
 
 [@@erasable]
 noeq
-type gen_elim_nondep_t =
-| GENonDep: (ty: list Type0) -> curried_function_type ty vprop -> curried_function_type ty prop -> gen_elim_nondep_t
+type gen_elim_nondep_t : Type u#(max 2 (a + 1)) =
+| GENonDep: (ty: list (Type u#a)) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> gen_elim_nondep_t
 | GEDep
 
 [@@gen_elim_reduce]
 let mk_gen_elim_nondep
-  (ty: list Type0)
+  (ty: list (Type u#a))
   (tvprop: Type)
   (q: tvprop)
   (tprop: Type)
   (post: tprop)
-: Pure gen_elim_nondep_t
+: Pure (gen_elim_nondep_t u#a)
   (requires (
-    tvprop == curried_function_type ty vprop /\
-    tprop == curried_function_type ty prop
+    tvprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) /\
+    tprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop)
   ))
   (ensures (fun _ -> True))
 = GENonDep ty q post
 
 [@@gen_elim_reduce]
 let mk_gen_elim_nondep_by_tac
-  (ty: list Type0)
+  (ty: list (Type u#a))
   (tvprop: Type)
   (q: tvprop)
   (tprop: Type)
   (post: tprop)
-: Pure gen_elim_nondep_t
+: Pure (gen_elim_nondep_t u#a)
   (requires (
-    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tvprop == curried_function_type ty vprop) /\
-    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tprop == curried_function_type ty prop)
+    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tvprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop)) /\
+    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop))
   ))
   (ensures (fun _ -> True))
 = GENonDep ty q post
 
 [@@gen_elim_reduce]
-let rec gen_elim_nondep_sem (ty: list Type0) : Tot (curried_function_type ty vprop -> curried_function_type ty prop -> Tot gen_elim_tele) =
-  match ty as ty' returns curried_function_type ty' vprop -> curried_function_type ty' prop -> Tot gen_elim_tele with
-  | [] -> fun q post -> TRet q post
+let rec gen_elim_nondep_sem (ty: list (Type u#a)) : Tot (curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot (gen_elim_tele u#a)) =
+  match ty as ty' returns curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot gen_elim_tele with
+  | [] -> fun q post -> TRet (q (U.raise_val ())) (post (U.raise_val ()))
   | t :: tq -> fun q post -> TExists t (fun x -> gen_elim_nondep_sem tq (q x) (post x))
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let check_gen_elim_nondep_sem (i: gen_elim_i) (nd: gen_elim_nondep_t) : Tot prop =
+let check_gen_elim_nondep_sem (i: gen_elim_i) (nd: gen_elim_nondep_t u#1) : Tot prop =
   match nd with
   | GENonDep ty q post -> compute_gen_elim_tele i == gen_elim_nondep_sem ty q post
   | GEDep -> True
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let compute_gen_elim_nondep_a' (ty: list Type0) : Tot Type0 =
+let compute_gen_elim_nondep_a' (ty: list (Type u#a)) : Tot (Type u#a) =
     match ty with
-    | [] -> unit
+    | [] -> U.raise_t unit
     | [t1] -> t1
     | [t1; t2] -> tuple2 t1 t2
     | [t1; t2; t3] -> tuple3 t1 t2 t3
@@ -247,16 +279,16 @@ let compute_gen_elim_nondep_a' (ty: list Type0) : Tot Type0 =
     | [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12] -> tuple12 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12
     | [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13] -> tuple13 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13
     | [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13; t14] -> tuple14 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14
-    | _ -> unit // unsupported
+    | _ -> U.raise_t unit // unsupported
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let compute_gen_elim_nondep_a (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot Type0 =
+let compute_gen_elim_nondep_a (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot Type =
   match i with
   | GENonDep ty q post -> compute_gen_elim_nondep_a' ty
   | GEDep -> compute_gen_elim_a i0
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let compute_uncurry (ret_type: Type u#a) (def: ret_type) (ty: list Type0) : curried_function_type ty ret_type -> compute_gen_elim_nondep_a' ty -> ret_type =
+let compute_uncurry (ret_type: Type u#(max a b)) (def: ret_type) (ty: list (Type u#a)) : curried_function_type ty ret_type -> compute_gen_elim_nondep_a' ty -> ret_type =
     match ty as ty' returns (curried_function_type ty' ret_type -> compute_gen_elim_nondep_a' ty' -> ret_type) with
     | [] -> fun q _ -> q
     | [t1] -> fun q -> q
@@ -278,7 +310,7 @@ let compute_uncurry (ret_type: Type u#a) (def: ret_type) (ty: list Type0) : curr
 [@@gen_elim_reduce]
 let compute_gen_elim_nondep_q0 (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot (compute_gen_elim_nondep_a i0 i -> vprop) =
   match i with
-  | GENonDep ty q post -> compute_uncurry vprop (compute_gen_elim_p' i0) ty q
+  | GENonDep ty q post -> fun x -> compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) ty q x (U.raise_val ())
       // that default value does not reduce, on purpose, to make the tactic fail if the type list is too long
   | GEDep -> compute_gen_elim_q i0
 
@@ -289,7 +321,7 @@ let compute_gen_elim_nondep_q (i0: gen_elim_i) (i: gen_elim_nondep_t) (x: Ghost.
 [@@gen_elim_reduce; noextract_to "Plugin"]
 let compute_gen_elim_nondep_post0 (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot (compute_gen_elim_nondep_a i0 i -> prop) =
   match i with
-  | GENonDep ty q post -> compute_uncurry prop True ty post
+  | GENonDep ty q post -> fun x -> compute_uncurry _ (fun _ -> True) ty post x (U.raise_val ())
   | GEDep -> compute_gen_elim_post i0
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
@@ -346,6 +378,14 @@ let abstr_has_exists
   | T.Tv_Abs _ body -> term_has_head body (`exists_)
   | _ -> false
 
+let rec get_universe
+  (u: T.universe)
+: T.Tac nat
+= match T.inspect_universe u with
+  | T.Uv_Zero -> 0
+  | T.Uv_Succ u -> 1 + get_universe u
+  | _ -> T.fail "get_universe: not an universe instantiation"
+
 let rec solve_gen_elim
   (tl': T.term)
 : T.Tac T.term
@@ -358,6 +398,10 @@ let rec solve_gen_elim
         let (hd, lbody) = T.collect_app tl' in
         if hd `is_fvar` (`%exists_)
         then
+          let universe = match T.inspect_ln_unascribe hd with
+          | T.Tv_UInst _ (u :: _) -> get_universe u
+          | _ -> T.fail "ill-formed exists_: no universe found"
+          in
           let (ty, body) =
             match lbody with
             | [(ty, T.Q_Implicit); (body, T.Q_Explicit)] -> ([(ty, T.Q_Implicit)], body)
@@ -369,12 +413,27 @@ let rec solve_gen_elim
               if not (term_has_head abody (`exists_))
               then
                 let body' = solve_gen_unit_elim abody in
-                T.mk_app (`GEExistsUnit) (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
+                T.mk_app 
+                  begin match universe with
+                  | 0 -> (`GEExistsUnit0)
+                  | _ -> (`GEExistsUnit1)
+                  end
+                  (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
               else
                 let body' = solve_gen_elim abody in
-                T.mk_app (`GEExists) (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
+                T.mk_app
+                  begin match universe with
+                  | 0 -> (`GEExists0)
+                  | _ -> (`GEExists1)
+                  end
+                  (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
             | _ ->
-              T.mk_app (`GEExistsNoAbs) lbody
+              T.mk_app
+                begin match universe with
+                | 0 -> (`GEExistsNoAbs0)
+                | _ -> (`GEExistsNoAbs1)
+                end
+                lbody
           end
         else if is_star_or_vstar hd
         then
@@ -402,7 +461,7 @@ let rec solve_gen_elim
 val gen_elim_prop
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Tot prop
@@ -412,7 +471,7 @@ val gen_elim_prop_intro'
   (j: gen_elim_nondep_t)
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
   (sq_p: squash (p == compute_gen_elim_p i))
@@ -425,18 +484,18 @@ val gen_elim_prop_intro'
 
 let gen_elim_prop_intro
   (i: gen_elim_i)
-  (ty: list Type0)
+  (ty: list (Type u#1))
   (tvprop: Type)
   (q0: tvprop)
   (tprop: Type)
   (post0: tprop)
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
-  (sq_tvprop: squash (tvprop == curried_function_type ty vprop))
-  (sq_tprop: squash (tprop == curried_function_type ty prop))
+  (sq_tvprop: squash (tvprop == curried_function_type u#1 u#2 ty (U.raise_t unit -> vprop)))
+  (sq_tprop: squash (tprop == curried_function_type u#1 u#2 ty (U.raise_t u#_ u#2 unit -> prop)))
   (sq_p: squash (p == compute_gen_elim_p i))
   (sq_j: squash (check_gen_elim_nondep_sem i (mk_gen_elim_nondep ty tvprop q0 tprop post0)))
   (sq_a: squash (a == compute_gen_elim_nondep_a i (mk_gen_elim_nondep ty tvprop q0 tprop post0)))
@@ -449,7 +508,7 @@ let gen_elim_prop_intro
 val gen_elim_prop_elim
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Ghost (gen_elim_i & gen_elim_nondep_t)
@@ -466,7 +525,7 @@ val gen_elim_prop_elim
 let gen_elim_prop_placeholder
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Tot prop
@@ -475,7 +534,7 @@ let gen_elim_prop_placeholder
 let gen_elim_prop_placeholder_intro
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Lemma (gen_elim_prop_placeholder enable_nondep_opt p a q post)
@@ -492,27 +551,28 @@ let rec solve_gen_elim_nondep' (fuel: nat) (rev_types_and_binders: list (T.term
       let cons_type (accu: (unit -> T.Tac T.term)) (tb: (T.term & T.binder)) () : T.Tac T.term =
         let (ty, _) = tb in
         let tl = accu () in
-        T.mk_app (`Cons) [(`Type0), T.Q_Implicit; ty, T.Q_Explicit; tl, T.Q_Explicit]
+        T.mk_app (`Cons) [(`Type u#1), T.Q_Implicit; ty, T.Q_Explicit; tl, T.Q_Explicit]
       in
-      let nil_type () : T.Tac T.term = T.mk_app (`Nil) [(`Type0), T.Q_Implicit] in
+      let nil_type () : T.Tac T.term = T.mk_app (`Nil) [(`(Type u#1)), T.Q_Implicit] in
       let type_list = List.Tot.fold_left cons_type nil_type rev_types_and_binders () in
       let type_list_typechecks =
         let open T in
         try
           let env = cur_env () in
           let ty = tc env type_list in
-          ty `term_eq_old` (`(list Type0))
+          ty `term_eq_old` (`(list (Type u#1)))
         with _ -> false
       in
       if not type_list_typechecks
       then None
       else
-        let binders = List.Tot.map snd (List.Tot.rev rev_types_and_binders) in
+        let dummy_raised_unit_binder = T.fresh_binder (`(U.raise_t u#_ u#2 unit)) in
+        let binders = List.Tot.map snd (List.Tot.rev rev_types_and_binders) `List.Tot.append` [dummy_raised_unit_binder] in
         let norm_term = T.norm_term [delta_attr [(`%gen_elim_reduce)]; zeta; iota] in
         let v' = T.mk_abs binders v in
-        let tv' = norm_term (T.mk_app (`curried_function_type) [type_list, T.Q_Explicit; (`vprop), T.Q_Explicit]) in
+        let tv' = norm_term (T.mk_app (`(curried_function_type u#1 u#2)) [type_list, T.Q_Explicit; (`(U.raise_t u#_ u#2 unit -> vprop)), T.Q_Explicit]) in
         let p' = T.mk_abs binders p in
-        let tp' = norm_term (T.mk_app (`curried_function_type) [type_list, T.Q_Explicit; (`prop), T.Q_Explicit]) in
+        let tp' = norm_term (T.mk_app (`(curried_function_type u#1 u#2)) [type_list, T.Q_Explicit; (`(U.raise_t u#_ u#2 unit -> prop)), T.Q_Explicit]) in
         Some (Mktuple5
           type_list
           tv'
@@ -551,7 +611,7 @@ let solve_gen_elim_nondep (enable_nondep_opt: bool) (t: T.term) : T.Tac T.term =
           v'
           tp'
           p'
-        ) -> T.mk_app (`mk_gen_elim_nondep_by_tac) [
+        ) -> T.mk_app (`(mk_gen_elim_nondep_by_tac u#1)) [
           type_list, T.Q_Explicit;
           tv', T.Q_Explicit;
           v', T.Q_Explicit;
@@ -628,7 +688,9 @@ let solve_gen_elim_prop_placeholder
       let i' = solve_gen_elim p in
       let j' = solve_gen_elim_nondep enable_nondep_opt i' in
       let norm_term = T.norm_term [delta_attr [(`%gen_elim_reduce)]; zeta; iota] in
-      let a' = norm_term (T.mk_app (`compute_gen_elim_nondep_a) [i', T.Q_Explicit; j', T.Q_Explicit]) in
+      let a' = T.mk_app (`compute_gen_elim_nondep_a) [i', T.Q_Explicit; j', T.Q_Explicit] in
+      let a'_ts = T.term_to_string a' in
+      let a' = norm_term a' in
       let q' = norm_term (T.mk_app (`compute_gen_elim_nondep_q) [i', T.Q_Explicit; j', T.Q_Explicit]) in
       let post' = norm_term (T.mk_app (`compute_gen_elim_nondep_post) [i', T.Q_Explicit; j', T.Q_Explicit]) in
       T.unshelve a;
diff --git a/ulib/experimental/Steel.ST.GenElim.fst b/ulib/experimental/Steel.ST.GenElim.fst
index 49c274413a0..6f1cceba1e1 100644
--- a/ulib/experimental/Steel.ST.GenElim.fst
+++ b/ulib/experimental/Steel.ST.GenElim.fst
@@ -2,26 +2,29 @@ module Steel.ST.GenElim
 
 let gen_elim_f
   (p: vprop)
-  (a: Type0) // FIXME: generalize this universe
+  (a: Type)
   (q: (a -> vprop))
   (post: (a -> prop))
 : Tot Type
 = ((opened: inames) -> STGhost a opened p q True post)
 
+module U = FStar.Universe
+
 let gen_unit_elim_t (i: gen_unit_elim_i) : Tot Type =
-  gen_elim_f (compute_gen_unit_elim_p i) unit (fun _ -> compute_gen_unit_elim_q i) (fun _ -> compute_gen_unit_elim_post i)
+  gen_elim_f (compute_gen_unit_elim_p i) (U.raise_t u#_ u#1 unit) (fun _ -> compute_gen_unit_elim_q i) (fun _ -> compute_gen_unit_elim_post i)
 
 let compute_gen_unit_elim_f_id
   (v: vprop)
 : Tot (gen_unit_elim_t (GUEId v))
-= fun _ -> noop ()
+= fun _ -> noop (); U.raise_val ()
 
 let compute_gen_unit_elim_f_pure
   (p: prop)
 : Tot (gen_unit_elim_t (GUEPure p))
 = fun _ ->
   rewrite (compute_gen_unit_elim_p (GUEPure p)) (pure p);
-  elim_pure p
+  elim_pure p;
+  U.raise_val ()
 
 let compute_gen_unit_elim_f_star
   (i1 i2: gen_unit_elim_i)
@@ -30,8 +33,10 @@ let compute_gen_unit_elim_f_star
 : Tot (gen_unit_elim_t (GUEStar i1 i2))
 = fun _ ->
   rewrite (compute_gen_unit_elim_p (GUEStar i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_unit_elim_p i2);
-  f1 _; f2 _;
-  rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_unit_elim_q i2) (compute_gen_unit_elim_q (GUEStar i1 i2))
+  let _ = f1 _ in
+  let _ = f2 _ in
+  rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_unit_elim_q i2) (compute_gen_unit_elim_q (GUEStar i1 i2));
+  U.raise_val ()
 
 let rec compute_gen_unit_elim_f
   (i: gen_unit_elim_i)
@@ -58,7 +63,7 @@ let compute_gen_elim_f_star_l
   fun _ ->
   rewrite (compute_gen_elim_p (GEStarL i1 i2)) (compute_gen_elim_p i1 `star` compute_gen_unit_elim_p i2);
   let res = f1 _ in
-  f2 _;
+  let _ = f2 _ in
   let res' : compute_gen_elim_a (GEStarL i1 i2) = coerce_with_trefl res in
   rewrite (compute_gen_elim_q i1 res `star` compute_gen_unit_elim_q i2) (compute_gen_elim_q (GEStarL i1 i2) res');
   res'
@@ -71,7 +76,7 @@ let compute_gen_elim_f_star_r
 = let f1 = compute_gen_unit_elim_f i1 in
   fun _ ->
   rewrite (compute_gen_elim_p (GEStarR i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_elim_p i2);
-  f1 _;
+  let _ = f1 _ in
   let res = f2 _ in
   let res' : compute_gen_elim_a (GEStarR i1 i2) = coerce_with_trefl res in
   rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_elim_q i2 res) (compute_gen_elim_q (GEStarR i1 i2) res');
@@ -91,15 +96,15 @@ let compute_gen_elim_f_star
   rewrite (compute_gen_elim_q i1 res1 `star` compute_gen_elim_q i2 res2) (compute_gen_elim_q (GEStar i1 i2) res);
   res
 
-let compute_gen_elim_f_exists_no_abs
+let compute_gen_elim_f_exists_no_abs0
   (a: Type0)
   (body: (a -> vprop))
-: GTot (gen_elim_t (GEExistsNoAbs body))
+: GTot (gen_elim_t (GEExistsNoAbs0 body))
 = fun _ ->
-  rewrite (compute_gen_elim_p (GEExistsNoAbs body)) (exists_ body);
+  rewrite (compute_gen_elim_p (GEExistsNoAbs0 body)) (exists_ body);
   let gres = elim_exists () in
-  let res : compute_gen_elim_a (GEExistsNoAbs body) = coerce_with_trefl (Ghost.reveal gres) in
-  rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs body) res);
+  let res : compute_gen_elim_a (GEExistsNoAbs0 body) = U.raise_val (Ghost.reveal gres) in //  coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs0 body) res);
   res
 
 let rewrite_with_trefl (#opened:_) (p q:vprop)
@@ -110,29 +115,65 @@ let rewrite_with_trefl (#opened:_) (p q:vprop)
       (ensures fun _ -> True)
 = rewrite p q
 
-let compute_gen_elim_f_exists_unit
+let compute_gen_elim_f_exists_unit0
   (a: Type0)
   (body: a -> gen_unit_elim_i)
-: Tot (gen_elim_t (GEExistsUnit body))
+: Tot (gen_elim_t (GEExistsUnit0 body))
 = fun _ ->
-  rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
+  rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit0 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
   let gres = elim_exists () in
-  compute_gen_unit_elim_f (body gres) _;
-  let res : compute_gen_elim_a (GEExistsUnit body) = coerce_with_trefl (Ghost.reveal gres) in
-  rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit body) res);
+  let _ = compute_gen_unit_elim_f (body gres) _ in
+  let res : compute_gen_elim_a (GEExistsUnit0 body) = U.raise_val (Ghost.reveal gres) in // coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit0 body) res);
   res
 
-let compute_gen_elim_f_exists
+let compute_gen_elim_f_exists0
   (a: Type0)
   (body: a -> gen_elim_i)
   (f: (x: a) -> GTot (gen_elim_t (body x)))
-: Tot (gen_elim_t (GEExists body))
+: Tot (gen_elim_t (GEExists0 body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p (GEExists0 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
+  let gres1 = elim_exists () in
+  let gres2 = f gres1 _ in
+  let res : compute_gen_elim_a (GEExists0 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
+  rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists0 body) res);
+  res
+
+let compute_gen_elim_f_exists_no_abs1
+  (a: Type)
+  (body: (a -> vprop))
+: GTot (gen_elim_t (GEExistsNoAbs1 body))
+= fun _ ->
+  rewrite (compute_gen_elim_p (GEExistsNoAbs1 body)) (exists_ body);
+  let gres = elim_exists () in
+  let res : compute_gen_elim_a (GEExistsNoAbs1 body) = coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs1 body) res);
+  res
+
+let compute_gen_elim_f_exists_unit1
+  (a: Type)
+  (body: a -> gen_unit_elim_i)
+: Tot (gen_elim_t (GEExistsUnit1 body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit1 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
+  let gres = elim_exists () in
+  let _ = compute_gen_unit_elim_f (body gres) _ in
+  let res : compute_gen_elim_a (GEExistsUnit1 body) = coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit1 body) res);
+  res
+
+let compute_gen_elim_f_exists1
+  (a: Type)
+  (body: a -> gen_elim_i)
+  (f: (x: a) -> GTot (gen_elim_t (body x)))
+: Tot (gen_elim_t (GEExists1 body))
 = fun _ ->
-  rewrite_with_trefl (compute_gen_elim_p (GEExists body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
+  rewrite_with_trefl (compute_gen_elim_p (GEExists1 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
   let gres1 = elim_exists () in
   let gres2 = f gres1 _ in
-  let res : compute_gen_elim_a (GEExists body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
-  rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists body) res);
+  let res : compute_gen_elim_a (GEExists1 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
+  rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists1 body) res);
   res
 
 let rec compute_gen_elim_f
@@ -143,9 +184,12 @@ let rec compute_gen_elim_f
   | GEStarL i1 i2 -> compute_gen_elim_f_star_l i1 (compute_gen_elim_f i1) i2
   | GEStarR i1 i2 -> compute_gen_elim_f_star_r i1 i2 (compute_gen_elim_f i2)
   | GEStar i1 i2 -> compute_gen_elim_f_star i1 (compute_gen_elim_f i1) i2 (compute_gen_elim_f i2)
-  | GEExistsNoAbs body -> compute_gen_elim_f_exists_no_abs _ body
-  | GEExistsUnit body -> compute_gen_elim_f_exists_unit _ body
-  | GEExists body -> compute_gen_elim_f_exists _ body (fun x -> compute_gen_elim_f (body x))
+  | GEExistsNoAbs0 body -> compute_gen_elim_f_exists_no_abs0 _ body
+  | GEExistsUnit0 body -> compute_gen_elim_f_exists_unit0 _ body
+  | GEExists0 body -> compute_gen_elim_f_exists0 _ body (fun x -> compute_gen_elim_f (body x))
+  | GEExistsNoAbs1 body -> compute_gen_elim_f_exists_no_abs1 _ body
+  | GEExistsUnit1 body -> compute_gen_elim_f_exists_unit1 _ body
+  | GEExists1 body -> compute_gen_elim_f_exists1 _ body (fun x -> compute_gen_elim_f (body x))
 
 let rec tele_p (x: gen_elim_tele) : Tot vprop =
   match x with
@@ -252,7 +296,7 @@ let compute_gen_elim_tele_correct_unit
 : Tot (ge_to_tele_t (GEUnit v))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p v);
-  compute_gen_unit_elim_f v _;
+  let _ = compute_gen_unit_elim_f v _ in
   intro_pure (compute_gen_unit_elim_post v);
   rewrite_with_trefl (compute_gen_unit_elim_q v `star` pure _) (tele_p _)
 
@@ -264,7 +308,7 @@ let compute_gen_elim_tele_correct_star_l
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_elim_p l `star` compute_gen_unit_elim_p ru);
   ihl _;
-  compute_gen_unit_elim_f ru _;
+  let _ = compute_gen_unit_elim_f ru _ in
   intro_pure (compute_gen_unit_elim_post ru);
   tele_star_vprop_correct _ _ _ _;
   rewrite_with_trefl (tele_p _) (tele_p _)
@@ -277,7 +321,7 @@ let compute_gen_elim_tele_correct_star_r
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p lu `star` compute_gen_elim_p r);
   ihr _;
-  compute_gen_unit_elim_f lu _;
+  let _ = compute_gen_unit_elim_f lu _ in
   intro_pure (compute_gen_unit_elim_post lu);
   tele_star_vprop_correct _ _ _ _;
   rewrite_with_trefl (tele_p _) (tele_p _)
@@ -295,10 +339,48 @@ let compute_gen_elim_tele_correct_star
   tele_star_correct (compute_gen_elim_tele l) (compute_gen_elim_tele r) _;
   rewrite_with_trefl (tele_p _) (tele_p _)
 
-let compute_gen_elim_tele_correct_exists_no_abs
+let compute_gen_elim_tele_correct_exists_no_abs0
   (ty: _)
   (body: ty -> vprop)
-: Tot (ge_to_tele_t (GEExistsNoAbs #ty body))
+: Tot (ge_to_tele_t (GEExistsNoAbs0 #ty body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
+  let x = elim_exists' () in
+  intro_pure True;
+  rewrite (body x) (body (U.downgrade_val (U.raise_val x)));
+  intro_exists (U.raise_val u#0 u#1 x) (fun x -> body (U.downgrade_val x) `star` pure True);
+  rewrite_with_trefl (exists_ _) (tele_p _)
+
+let compute_gen_elim_tele_correct_exists_unit0
+  (ty: _)
+  (body: ty -> gen_unit_elim_i)
+: Tot (ge_to_tele_t (GEExistsUnit0 #ty body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
+  let x = elim_exists' () in
+  let _ = compute_gen_unit_elim_f (body x) _ in
+  intro_pure (compute_gen_unit_elim_post (body (U.downgrade_val (U.raise_val u#0 u#1 x))));
+  rewrite (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_q (body (U.downgrade_val (U.raise_val x))));
+  intro_exists (U.raise_val u#0 u#1 x) (fun x -> compute_gen_unit_elim_q (body (U.downgrade_val x)) `star` pure (compute_gen_unit_elim_post (body (U.downgrade_val x))));
+  rewrite_with_trefl (exists_ _) (tele_p _)
+
+let compute_gen_elim_tele_correct_exists0
+  (ty: _)
+  (body: ty -> gen_elim_i)
+  (ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
+: Tot (ge_to_tele_t (GEExists0 #ty body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
+  let x = elim_exists' () in
+  ih x _;
+  rewrite (tele_p (compute_gen_elim_tele (body x))) (tele_p (compute_gen_elim_tele (body (U.downgrade_val (U.raise_val u#0 u#1 x)))));
+  intro_exists (U.raise_val u#0 u#1 x) (fun x -> tele_p (compute_gen_elim_tele (body (U.downgrade_val u#0 u#1 x))));
+  rewrite_with_trefl (exists_ _) (tele_p _)
+
+let compute_gen_elim_tele_correct_exists_no_abs1
+  (ty: _)
+  (body: ty -> vprop)
+: Tot (ge_to_tele_t (GEExistsNoAbs1 #ty body))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
   let x = elim_exists' () in
@@ -306,23 +388,23 @@ let compute_gen_elim_tele_correct_exists_no_abs
   intro_exists x (fun x -> body x `star` pure True);
   rewrite_with_trefl (exists_ _) (tele_p _)
 
-let compute_gen_elim_tele_correct_exists_unit
+let compute_gen_elim_tele_correct_exists_unit1
   (ty: _)
   (body: ty -> gen_unit_elim_i)
-: Tot (ge_to_tele_t (GEExistsUnit #ty body))
+: Tot (ge_to_tele_t (GEExistsUnit1 #ty body))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
   let x = elim_exists' () in
-  compute_gen_unit_elim_f (body x) _;
+  let _ = compute_gen_unit_elim_f (body x) _ in
   intro_pure (compute_gen_unit_elim_post (body x));
   intro_exists x (fun x -> compute_gen_unit_elim_q (body x) `star` pure (compute_gen_unit_elim_post (body x)));
   rewrite_with_trefl (exists_ _) (tele_p _)
 
-let compute_gen_elim_tele_correct_exists
+let compute_gen_elim_tele_correct_exists1
   (ty: _)
   (body: ty -> gen_elim_i)
   (ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
-: Tot (ge_to_tele_t (GEExists #ty body))
+: Tot (ge_to_tele_t (GEExists1 #ty body))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
   let x = elim_exists' () in
@@ -338,25 +420,28 @@ let rec compute_gen_elim_tele_correct
   | GEStarL l ru -> compute_gen_elim_tele_correct_star_l l (compute_gen_elim_tele_correct l) ru
   | GEStarR lu r -> compute_gen_elim_tele_correct_star_r lu r (compute_gen_elim_tele_correct r)
   | GEStar l r -> compute_gen_elim_tele_correct_star l (compute_gen_elim_tele_correct l) r (compute_gen_elim_tele_correct r)
-  | GEExistsNoAbs #ty body -> compute_gen_elim_tele_correct_exists_no_abs ty body
-  | GEExistsUnit #ty body -> compute_gen_elim_tele_correct_exists_unit ty body
-  | GEExists #ty body -> compute_gen_elim_tele_correct_exists ty body (fun x -> compute_gen_elim_tele_correct (body x))
-
-let rec gen_elim_nondep_p (ty: list Type0) : Tot (curried_function_type ty vprop -> curried_function_type ty prop -> Tot vprop) =
-  match ty as ty' returns curried_function_type ty' vprop -> curried_function_type ty' prop -> Tot vprop with
-  | [] -> fun q post -> q `star` pure post
+  | GEExistsNoAbs0 #ty body -> compute_gen_elim_tele_correct_exists_no_abs0 ty body
+  | GEExistsUnit0 #ty body -> compute_gen_elim_tele_correct_exists_unit0 ty body
+  | GEExists0 #ty body -> compute_gen_elim_tele_correct_exists0 ty body (fun x -> compute_gen_elim_tele_correct (body x))
+  | GEExistsNoAbs1 #ty body -> compute_gen_elim_tele_correct_exists_no_abs1 ty body
+  | GEExistsUnit1 #ty body -> compute_gen_elim_tele_correct_exists_unit1 ty body
+  | GEExists1 #ty body -> compute_gen_elim_tele_correct_exists1 ty body (fun x -> compute_gen_elim_tele_correct (body x))
+
+let rec gen_elim_nondep_p (ty: list (Type u#a)) : Tot (curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop) =
+  match ty as ty' returns curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop with
+  | [] -> fun q post -> q (U.raise_val ()) `star` pure (post (U.raise_val ()))
   | t :: tq -> fun q post -> exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x))
 
 let rec gen_elim_nondep_sem_correct
-  (ty: list Type0)
-: Tot ((q: curried_function_type ty vprop) -> (post: curried_function_type ty prop) -> Lemma
+  (ty: list (Type u#a))
+: Tot ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
     (tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
   )
-= match ty returns ((q: curried_function_type ty vprop) -> (post: curried_function_type ty prop) -> Lemma
+= match ty returns ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
     (tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
   )
   with
-  | [] -> fun q post -> equiv_refl (q `star` pure post)
+  | [] -> fun q post -> equiv_refl (q (U.raise_val ()) `star` pure (post (U.raise_val ())))
   | ta :: tq -> fun q post ->
     let phi
       (x: ta)
@@ -376,7 +461,7 @@ let rec gen_elim_nondep_sem_correct
 
 let compute_gen_elim_nondep_correct_t
   (i0: gen_elim_i)
-  (ty: list Type0)
+  (ty: list (Type u#1))
 : Tot Type
 = (q: _) ->
   (post: _) ->
@@ -384,8 +469,8 @@ let compute_gen_elim_nondep_correct_t
   GTot (gen_elim_f
     (compute_gen_elim_p i0)
     (compute_gen_elim_nondep_a' ty)
-    (compute_uncurry vprop (compute_gen_elim_p' i0) ty q)
-    (compute_uncurry prop True ty post)
+    (fun x -> compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) ty q x (U.raise_val ()))
+    (fun x -> compute_uncurry _ (fun _ -> True) ty post x (U.raise_val ()))
   )
 
 let compute_gen_elim_nondep_correct0
@@ -393,76 +478,76 @@ let compute_gen_elim_nondep_correct0
 : Tot (compute_gen_elim_nondep_correct_t i0 [])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (_ `star` pure post);
-    let res = () in
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (q (U.raise_val ()) `star` pure (post (U.raise_val ())));
+    let res = U.raise_val () in
     elim_pure _;
-    rewrite_with_trefl q (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct1
   (i0: gen_elim_i)
-  (t1: Type0)
+  (t1: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> q x1 `star` pure (post x1)));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> q x1 (U.raise_val ()) `star` pure (post x1 (U.raise_val ()))));
     let res = elim_exists' () in
     elim_pure _;
-    rewrite_with_trefl (q _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct2
   (i0: gen_elim_i)
-  (t1 t2: Type0)
+  (t1 t2: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> q x1 x2 `star` pure (post x1 x2))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> q x1 x2 (U.raise_val ()) `star` pure (post x1 x2 (U.raise_val ())))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let res = Mktuple2 x1 x2 in
     elim_pure _;
-    rewrite_with_trefl (q _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct3
   (i0: gen_elim_i)
-  (t1 t2 t3: Type0)
+  (t1 t2 t3: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> q x1 x2 x3 `star` pure (post x1 x2 x3)))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> q x1 x2 x3 (U.raise_val ()) `star` pure (post x1 x2 x3 (U.raise_val ()))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
     let res = Mktuple3 x1 x2 x3 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct4
   (i0: gen_elim_i)
-  (t1 t2 t3 t4: Type0)
+  (t1 t2 t3 t4: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> q x1 x2 x3 x4 `star` pure (post x1 x2 x3 x4))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> q x1 x2 x3 x4 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 (U.raise_val ())))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
     let x4 = elim_exists' () in
     let res = Mktuple4 x1 x2 x3 x4 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct5
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5: Type0)
+  (t1 t2 t3 t4 t5: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> q x1 x2 x3 x4 x5 `star` pure (post x1 x2 x3 x4 x5)))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> q x1 x2 x3 x4 x5 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 (U.raise_val ()))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -470,16 +555,16 @@ let compute_gen_elim_nondep_correct5
     let x5 = elim_exists' () in
     let res = Mktuple5 x1 x2 x3 x4 x5 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct6
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6: Type0)
+  (t1 t2 t3 t4 t5 t6: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> q x1 x2 x3 x4 x5 x6 `star` pure (post x1 x2 x3 x4 x5 x6))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> q x1 x2 x3 x4 x5 x6 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 (U.raise_val ())))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -488,16 +573,16 @@ let compute_gen_elim_nondep_correct6
     let x6 = elim_exists' () in
     let res = Mktuple6 x1 x2 x3 x4 x5 x6 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct7
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7: Type0)
+  (t1 t2 t3 t4 t5 t6 t7: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> q x1 x2 x3 x4 x5 x6 x7 `star` pure (post x1 x2 x3 x4 x5 x6 x7)))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> q x1 x2 x3 x4 x5 x6 x7 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 (U.raise_val ()))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -507,16 +592,16 @@ let compute_gen_elim_nondep_correct7
     let x7 = elim_exists' () in
     let res = Mktuple7 x1 x2 x3 x4 x5 x6 x7 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct8
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> q x1 x2 x3 x4 x5 x6 x7 x8 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> q x1 x2 x3 x4 x5 x6 x7 x8 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 (U.raise_val ())))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -527,16 +612,16 @@ let compute_gen_elim_nondep_correct8
     let x8 = elim_exists' () in
     let res = Mktuple8 x1 x2 x3 x4 x5 x6 x7 x8 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct9
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9)))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 (U.raise_val ()))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -548,16 +633,16 @@ let compute_gen_elim_nondep_correct9
     let x9 = elim_exists' () in
     let res = Mktuple9 x1 x2 x3 x4 x5 x6 x7 x8 x9 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct10
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 (U.raise_val ())))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -570,16 +655,16 @@ let compute_gen_elim_nondep_correct10
     let x10 = elim_exists' () in
     let res = Mktuple10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct11
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11)))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 (U.raise_val ()))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -593,16 +678,16 @@ let compute_gen_elim_nondep_correct11
     let x11 = elim_exists' () in
     let res = Mktuple11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct12
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12))))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 (U.raise_val ())))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -617,16 +702,16 @@ let compute_gen_elim_nondep_correct12
     let x12 = elim_exists' () in
     let res = Mktuple12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct13
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13)))))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 (U.raise_val ()))))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -642,16 +727,16 @@ let compute_gen_elim_nondep_correct13
     let x13 = elim_exists' () in
     let res = Mktuple13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct14
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13; t14])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> exists_ (fun x14 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14))))))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> exists_ (fun x14 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 (U.raise_val ())))))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -668,22 +753,22 @@ let compute_gen_elim_nondep_correct14
     let x14 = elim_exists' () in
     let res = Mktuple14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct_default
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15: Type0) (tq: list Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15: Type) (tq: list Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 (t1 :: t2 :: t3 :: t4 :: t5 :: t6 :: t7 :: t8 :: t9 :: t10 :: t11 :: t12 :: t13 :: t14 :: t15 :: tq))
 = fun q post intro _ ->
     // default case: no exists is opened
-    let res : compute_gen_elim_nondep_a' (t1 :: t2 :: t3 :: t4 :: t5 :: t6 :: t7 :: t8 :: t9 :: t10 :: t11 :: t12 :: t13 :: t14 :: t15 :: tq) = coerce_with_trefl () in
-    rewrite_with_trefl (compute_gen_elim_p i0) (compute_uncurry vprop _ _ _ res);
+    let res : compute_gen_elim_nondep_a' (t1 :: t2 :: t3 :: t4 :: t5 :: t6 :: t7 :: t8 :: t9 :: t10 :: t11 :: t12 :: t13 :: t14 :: t15 :: tq) = (U.raise_val ()) in
+    rewrite_with_trefl (compute_gen_elim_p i0) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct'
   (i0: gen_elim_i)
-  (ty: list Type0)
+  (ty: list Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 ty)
 = match ty returns compute_gen_elim_nondep_correct_t i0 ty with
   | [] -> compute_gen_elim_nondep_correct0 i0
diff --git a/ulib/experimental/Steel.ST.GenElim.fsti b/ulib/experimental/Steel.ST.GenElim.fsti
index ac620e765ab..7a94b5aeca4 100644
--- a/ulib/experimental/Steel.ST.GenElim.fsti
+++ b/ulib/experimental/Steel.ST.GenElim.fsti
@@ -7,7 +7,7 @@ val gen_elim'
   (#opened: _)
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
   (sq: squash (gen_elim_prop_placeholder enable_nondep_opt p a q post))
@@ -17,7 +17,7 @@ val gen_elim'
 val gen_elim
   (#opened: _)
   (#[@@@ framing_implicit] p: vprop)
-  (#[@@@ framing_implicit] a: Type0)
+  (#[@@@ framing_implicit] a: Type)
   (#[@@@ framing_implicit] q: Ghost.erased a -> Tot vprop)
   (#[@@@ framing_implicit] post: Ghost.erased a -> Tot prop)
   (#[@@@ framing_implicit] sq: squash (gen_elim_prop_placeholder true p a q post))
@@ -27,7 +27,7 @@ val gen_elim
 val gen_elim_dep
   (#opened: _)
   (#[@@@ framing_implicit] p: vprop)
-  (#[@@@ framing_implicit] a: Type0)
+  (#[@@@ framing_implicit] a: Type)
   (#[@@@ framing_implicit] q: Ghost.erased a -> Tot vprop)
   (#[@@@ framing_implicit] post: Ghost.erased a -> Tot prop)
   (#[@@@ framing_implicit] sq: squash (gen_elim_prop_placeholder false p a q post))

From a78ff9df276173cfb01795c79d848a39fadd37cd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Feb 2023 17:11:11 -0800
Subject: [PATCH 385/513] type dictionary no longer works

---
 ulib/experimental/Steel.TypeDictionary.fst  | 241 --------------------
 ulib/experimental/Steel.TypeDictionary.fsti |  35 ---
 2 files changed, 276 deletions(-)
 delete mode 100644 ulib/experimental/Steel.TypeDictionary.fst
 delete mode 100644 ulib/experimental/Steel.TypeDictionary.fsti

diff --git a/ulib/experimental/Steel.TypeDictionary.fst b/ulib/experimental/Steel.TypeDictionary.fst
deleted file mode 100644
index 490a1ae2efa..00000000000
--- a/ulib/experimental/Steel.TypeDictionary.fst
+++ /dev/null
@@ -1,241 +0,0 @@
-module Steel.TypeDictionary
-
-module FP = FStar.Preorder
-module R = Steel.GhostMonotonicHigherReference
-
-let n_up_to (size: nat) : Type0 = (n: nat { n < size })
-
-[@@erasable]
-noeq
-type dictionary = {
-  size: nat;
-  type_of_nat: (n_up_to size -> Type0);
-  type_of_nat_inj: squash (forall n1 n2 . type_of_nat n1 == type_of_nat n2 ==> n1 == n2);
-}
-
-let nat_of_type
-  (d: dictionary)
-  (t: Type0)
-: Ghost nat
-  (requires (exists n . d.type_of_nat n == t))
-  (ensures (fun _ -> True))
-= FStar.IndefiniteDescription.indefinite_description_ghost _ (fun (n: n_up_to d.size) -> d.type_of_nat n == t)
-
-let nat_of_type_of_nat
-  (d: dictionary)
-  (n: n_up_to d.size)
-: Lemma
-  (nat_of_type d (d.type_of_nat n) == n)
-= ()
-
-let type_of_nat_of_type
-  (d: dictionary)
-  (t: Type0)
-: Lemma
-  (requires (exists n . d.type_of_nat n == t))
-  (ensures (d.type_of_nat (nat_of_type d t) == t))
-= ()
-
-[@@noextract_to "krml"]
-let preorder : FP.preorder dictionary =
-  (fun d1 d2 ->
-    d1.size <= d2.size /\
-    (forall (n: n_up_to d1.size) . d1.type_of_nat n == d2.type_of_nat n)
-  )
-
-open Steel.Effect.Common
-open Steel.Effect
-open Steel.Effect.Atomic
-open Steel.FractionalPermission
-
-module S = Steel.Effect.Common
-
-[@@__steel_reduce__]
-let dict_inv_vprop
-  (dict: R.ref dictionary preorder)
-: Tot vprop
-= h_exists (R.pts_to dict full_perm)
-
-[@@noextract_to "krml"]
-let dict_and_inv_t = Ghost.erased (dict: R.ref dictionary preorder & S.inv (dict_inv_vprop dict))
-
-let dict_and_inv_f (opened: _) : SteelGhostT dict_and_inv_t opened emp (fun _ -> emp)
-=
-  let d = ({ size = 0; type_of_nat = (fun _ -> unit); type_of_nat_inj = () }) in
-  let dict = R.alloc preorder d in
-  intro_exists _ (R.pts_to dict full_perm);
-  let i = new_invariant (h_exists (R.pts_to dict full_perm)) in
-  Ghost.hide (| dict, i |)
-
-#push-options "--warn_error -272" // disable top-level effect warning
-[@@noextract_to "krml"]
-let dict_and_inv = dict_and_inv_f _ <: SteelTop dict_and_inv_t false (fun _ -> emp) (fun _ _ _ -> True)
-#pop-options
-
-let dict : R.ref dictionary preorder = dfst dict_and_inv
-let inv : Ghost.erased Steel.Memory.iname = dsnd dict_and_inv
-
-let inv_holds : squash (inv >--> dict_inv_vprop dict) = ()
-
-let p_eq_q_p_FIXME_why_do_I_need_to_do_that
-  (p q: prop)
-  (sq: squash p)
-: Lemma
-  (requires (p == q))
-  (ensures q)
-= ()
-
-let inv_holds_unfold_WHY_WHY_WHY () : Lemma (inv >--> h_exists (R.pts_to dict full_perm)) =
-  assert_norm ((inv >--> dict_inv_vprop dict) == (inv >--> h_exists (R.pts_to dict full_perm)));
-  p_eq_q_p_FIXME_why_do_I_need_to_do_that (inv >--> dict_inv_vprop dict) (inv >--> h_exists (R.pts_to dict full_perm)) inv_holds
-
-let token_has_type_in (n: nat) (t: Type0) (d: dictionary) : GTot prop =
-  n < d.size /\
-  d.type_of_nat n == t
-
-let token_has_type (n: nat) (t: Type0) : GTot prop =
-  R.witnessed dict (token_has_type_in n t)
-
-let token_has_some_type (n: nat) : GTot prop =
-  exists (t: Type0) . token_has_type n t
-
-let token : Type0 = (n: Ghost.erased nat { token_has_some_type n })
-
-let type_of_token
-  (n: token)
-: Tot Type0
-= FStar.IndefiniteDescription.indefinite_description_ghost Type0 (fun t -> token_has_type n t)
-
-let token_has_type_inj_type_with (#opened: _) (n: nat) (t1 t2: Type0) () : SteelGhostT unit opened
-  (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n t1 /\ token_has_type n t2))
-  (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (t1 == t2))
-= elim_pure _;
-  let gd : Ghost.erased dictionary = witness_exists () in
-  let d : dictionary = Ghost.reveal gd in
-  rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
-  R.recall (token_has_type_in n t1) dict d;
-  R.recall (token_has_type_in n t2) dict d;
-  intro_exists d (R.pts_to dict full_perm);
-  intro_pure _
-
-let token_has_type_inj_type (#opened: _) (n: nat) (t1 t2: Type0) : SteelGhost unit opened
-  emp
-  (fun _ -> emp)
-  (fun _ ->
-    token_has_type n t1 /\
-    token_has_type n t2 /\
-    Ghost.reveal (mem_inv opened inv) == false
-  )
-  (fun _ _ _ -> t1 == t2)
-= inv_holds_unfold_WHY_WHY_WHY ();
-  intro_pure _;
-  with_invariant_g
-    inv
-    (token_has_type_inj_type_with n t1 t2);
-  elim_pure _
-
-let token_has_type_inj_token_with (#opened: _) (n1 n2: nat) (t: Type0) () : SteelGhostT unit opened
-  (h_exists (R.pts_to dict full_perm) `star` pure (token_has_type n1 t /\ token_has_type n2 t))
-  (fun _ -> h_exists (R.pts_to dict full_perm) `star` pure (n1 == n2))
-= elim_pure _;
-  let gd : Ghost.erased dictionary = witness_exists () in
-  let d : dictionary = Ghost.reveal gd in
-  rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
-  R.recall (token_has_type_in n1 t) dict d;
-  R.recall (token_has_type_in n2 t) dict d;
-  intro_exists d (R.pts_to dict full_perm);
-  intro_pure _
-
-let token_has_type_inj_token (#opened: _) (n1 n2: nat) (t: Type0) : SteelGhost unit opened
-  emp
-  (fun _ -> emp)
-  (fun _ ->
-    token_has_type n1 t /\
-    token_has_type n2 t /\
-    Ghost.reveal (mem_inv opened inv) == false
-  )
-  (fun _ _ _ -> n1 == n2)
-= inv_holds_unfold_WHY_WHY_WHY ();
-  intro_pure _;
-  with_invariant_g
-    inv
-    (token_has_type_inj_token_with n1 n2 t);
-  elim_pure _
-
-let type_of_token_inj (#opened: _) (n1 n2: token) : SteelGhost unit opened
-  emp
-  (fun _ -> emp)
-  (fun _ ->
-    type_of_token n1 == type_of_token n2 /\
-    Ghost.reveal (mem_inv opened inv) == false
-  )
-  (fun _ _ _ -> n1 == n2)
-= token_has_type_inj_token n1 n2 (type_of_token n1)
-
-#push-options "--split_queries"
-
-#restart-solver
-let get_token_from_true
-  (#opened: _)
-  (d: dictionary)
-  (t: Type0)
-: SteelGhost token opened
-    (R.pts_to dict full_perm d)
-    (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
-    (fun _ -> exists (n: n_up_to d.size) . d.type_of_nat n == t)
-    (fun _ _ _ -> True)
-= let n = FStar.IndefiniteDescription.indefinite_description_ghost (n_up_to d.size) (fun n -> d.type_of_nat n == t) in
-  R.witness dict (token_has_type_in n t) d ();
-  intro_exists d (R.pts_to dict full_perm);
-  intro_pure _;
-  token_has_type_inj_type_with n t (type_of_token n) ();
-  elim_pure _;
-  let n' : token = n in
-  intro_pure (type_of_token n' == t);
-  n'
-
-let get_token_from_false
-  (#opened: _)
-  (d: dictionary)
-  (t: Type0)
-: SteelGhost token opened
-    (R.pts_to dict full_perm d)
-    (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
-    (fun _ -> ~ (exists (n: n_up_to d.size) . d.type_of_nat n == t))
-    (fun _ _ _ -> True)
-= let n = d.size in
-  let d' = {size = n+1; type_of_nat = (fun n' -> if n = n'  then t else d.type_of_nat n'); type_of_nat_inj = () } in
-  R.write dict d';
-  let n' : n_up_to d'.size = n in
-  assert (d'.type_of_nat n' == t);
-  get_token_from_true d' t
-
-#pop-options
-
-let get_token_from
-  (#opened: _)
-  (t: Type0)
-  ()
-: SteelGhostT token opened
-    (h_exists (R.pts_to dict full_perm) `star` emp)
-    (fun n -> h_exists (R.pts_to dict full_perm) `star` pure (type_of_token n == t))
-= let gd : Ghost.erased dictionary = witness_exists () in
-  let d : dictionary = Ghost.reveal gd in
-  rewrite_slprop (R.pts_to dict full_perm _) (R.pts_to dict full_perm d) (fun _ -> ());
-  if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (n: n_up_to d.size) . d.type_of_nat n == t)
-  then
-    get_token_from_true d t
-  else
-    get_token_from_false d t
-
-let get_token
-  (#opened: _)
-  (t: Type0)
-: SteelGhost token opened emp (fun _ -> emp) (fun _ -> Ghost.reveal (mem_inv opened inv) == false) (fun _ n _ -> type_of_token n == t)
-= inv_holds_unfold_WHY_WHY_WHY ();
-  let n = with_invariant_g
-    inv
-    (get_token_from t)
-  in
-  elim_pure (type_of_token n == t);
-  n
diff --git a/ulib/experimental/Steel.TypeDictionary.fsti b/ulib/experimental/Steel.TypeDictionary.fsti
deleted file mode 100644
index 495dcea4e6a..00000000000
--- a/ulib/experimental/Steel.TypeDictionary.fsti
+++ /dev/null
@@ -1,35 +0,0 @@
-module Steel.TypeDictionary
-
-open Steel.Effect.Common
-open Steel.Effect
-open Steel.Effect.Atomic
-
-val inv : Ghost.erased Steel.Memory.iname
-
-[@@erasable; must_erase_for_extraction]
-val token : Type0
-
-[@@noextract_to "krml"]
-val type_of_token
-  (n: token)
-: Tot Type0
-
-val type_of_token_inj
-  (#opened: _) (n1 n2: token)
-: SteelGhost unit opened
-  emp
-  (fun _ -> emp)
-  (fun _ ->
-    type_of_token n1 == type_of_token n2 /\
-    Ghost.reveal (mem_inv opened inv) == false
-  )
-  (fun _ _ _ -> n1 == n2)
-
-val get_token
-  (#opened: _)
-  (t: Type0)
-: SteelGhost token opened
-  emp
-  (fun _ -> emp)
-  (fun _ -> Ghost.reveal (mem_inv opened inv) == false)
-  (fun _ n _ -> type_of_token n == t)

From 30c43d214e86265c3d8d2ca598e0756408db4511 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Feb 2023 17:11:48 -0800
Subject: [PATCH 386/513] WIP

---
 ulib/experimental/Steel.C.Types.fst  | 555 +++++++++++++++++++++------
 ulib/experimental/Steel.C.Types.fsti | 552 +++++++++++++++++---------
 2 files changed, 807 insertions(+), 300 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 20d85f55474..419694c30ee 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -92,8 +92,21 @@ let mk_fraction_unknown td p = td.mk_fraction_one p
 let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
 
 module R = Steel.C.Model.Ref
-module TD = Steel.TypeDictionary
+module RST = Steel.ST.C.Model.Ref
+module ST = Steel.ST.GenElim
 
+noeq
+type ref0_v (#t: Type) (td: typedef t) : Type u#1 = {
+  base: Type0;
+  ref: R.ref base td.pcm;
+}
+
+module HR = Steel.ST.HigherReference
+
+let ptr #t td = HR.ref (ref0_v td)
+let null td = HR.null
+
+(*
 noeq
 type ref0 : Type0 = {
   dest: TD.token;
@@ -105,80 +118,339 @@ let void_ptr = option ref0
 let void_null = None
 let type_of_ptr p = TD.type_of_token (Some?.v p).dest
 let typedef_of_ptr p = (Some?.v p).typedef
+*)
 
-let _pts_to r v = hp_of (R.pts_to (Some?.v r).ref v)
+let r_pts_to
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: R.ref a p) (v: b)
+: vprop
+= R.pts_to r v
+
+[@@__reduce__]
+let pts_to0
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+  (v: t)
+: Tot vprop
+= ST.exists_ (fun p -> ST.exists_ (fun w ->
+    HR.pts_to r p w `star`
+    r_pts_to w.ref v
+  ))
+
+let _pts_to r v = hp_of (pts_to0 r v)
+
+let pts_to_intro
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (p: P.perm)
+  (w1 w2: ref0_v td)
+  (v: t)
+: ST.STGhost unit opened
+    (HR.pts_to r p w1 `star` R.pts_to w2.ref v)
+    (fun _ -> pts_to r v)
+    (w1 == w2)
+    (fun _ -> True)
+= ST.vpattern_rewrite (HR.pts_to r p) w2;
+  ST.weaken (pts_to0 r v) (pts_to r v) (fun _ -> ())
 
 let is_null
   p
-= return (None? p)
+= let res = HR.is_null p in
+  return res
+
+[@@__reduce__]
+let ref_equiv0
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: Tot vprop
+= ST.exists_ (fun p1 -> ST.exists_ (fun p2 -> ST.exists_ (fun w ->
+    HR.pts_to r1 p1 w `star`
+    HR.pts_to r2 p2 w
+  )))
+
+let ref_equiv
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: Tot vprop
+= ref_equiv0 r1 r2
+
+let ref_equiv_dup'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: ST.STGhostT unit opened
+    (ref_equiv r1 r2)
+    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r1 r2)
+= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  HR.share r1;
+  HR.share r2;
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
+  ST.noop ();
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let ref_equiv_sym'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: ST.STGhostT unit opened
+    (ref_equiv r1 r2)
+    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r1)
+= ref_equiv_dup' r1 r2;
+  ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  ST.noop ();
+  ST.rewrite (ref_equiv0 r2 r1) (ref_equiv r2 r1)
+
+let hr_share (#a:Type)
+          (#uses:_)
+          (#p:P.perm)
+          (#v:a)
+          (r:HR.ref a)
+  : ST.STGhostT unit uses
+      (HR.pts_to r p v)
+      (fun _ -> HR.pts_to r (P.half_perm p) v `star` HR.pts_to r (P.half_perm p) v)
+= HR.share #_ #_ #_ #v r
+
+let hr_gather
+  (#a:Type)
+  (#uses:_) 
+  (#p0 #p1:P.perm)
+  (v0 #v1:a)
+  (r:HR.ref a)
+: ST.STGhost unit uses
+      (HR.pts_to r p0 v0 `star` HR.pts_to r p1 v1)
+      (fun _ -> HR.pts_to r (P.sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+= HR.gather p1 r
+
+let ref_equiv_trans'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2 r3: ref td)
+: ST.STGhostT unit opened
+    (ref_equiv r1 r2 `star` ref_equiv r2 r3)
+    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r3 `star` ref_equiv r1 r3)
+= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  let p2 = ST.vpattern_replace (fun p -> HR.pts_to r2 p _) in
+  ST.rewrite (ref_equiv r2 r3) (ref_equiv0 r2 r3);
+  let _ = ST.gen_elim () in
+  HR.pts_to_injective_eq #_ #_ #_ #_ #w #_ r2;
+  ST.vpattern_rewrite (HR.pts_to r3 _) w;
+  hr_share r1;
+  hr_share r3;
+  HR.gather p2 r2;
+  hr_share r2;
+  ST.noop ();
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
+  ST.rewrite (ref_equiv0 r2 r3) (ref_equiv r2 r3);
+  ST.rewrite (ref_equiv0 r1 r3) (ref_equiv r1 r3)
+
+let hr_share_imbalance (#a:Type)
+          (#uses:_)
+          (#p:P.perm)
+          (#v:a)
+          (r:HR.ref a)
+  : ST.STGhostT P.perm uses
+      (HR.pts_to r p v)
+      (fun p1 -> HR.pts_to r p1 v `star` ST.exists_ (fun p2 -> HR.pts_to r p2 v))
+= HR.share #_ #_ #_ #v r;
+  _
+
+#set-options "--ide_id_info_off"
+
+let pts_to_equiv'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+  (v: t)
+: ST.STGhostT unit opened
+    (ref_equiv r1 r2 `star` pts_to r1 v)
+    (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
+= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  ST.weaken (pts_to r1 v) (pts_to0 r1 v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  ST.weaken (pts_to0 r2 v) (pts_to r2 v) (fun _ -> ());
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let pts_to_equiv
+  r1 r2 v
+= pts_to_equiv' r1 r2 v
+
+[@@__steel_reduce__; __reduce__]
+let freeable0
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: Tot vprop
+= ST.exists_ (fun p -> ST.exists_ (fun w ->
+    HR.pts_to r p w `star`
+    ST.pure (R.freeable w.ref)
+  ))
 
 let freeable
   r
-= R.freeable (Some?.v r).ref
+= freeable0 r
 
-let alloc
-  #t td
-= let r = R.ref_alloc td.pcm td.uninitialized in
-  let tok = TD.get_token t in
-  let res : ref td = Some ({
-    dest = tok;
-    typedef = td;
+let freeable_dup'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: ST.STGhostT unit opened
+    (freeable r)
+    (fun _ -> freeable r `star` freeable r)
+= ST.rewrite (freeable r) (freeable0 r);
+  let _ = ST.gen_elim () in
+  HR.share r;
+  ST.noop ();
+  ST.rewrite (freeable0 r) (freeable r);
+  ST.noop ();
+  ST.rewrite (freeable0 r) (freeable r)
+
+module STC = Steel.ST.Coercions
+
+let freeable_dup
+  r
+= let _ = freeable_dup' r in
+  noop ()
+
+let freeable_equiv'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: ST.STGhostT unit opened
+    (ref_equiv r1 r2 `star` freeable r1)
+    (fun _ -> ref_equiv r1 r2 `star` freeable r2)
+= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  ST.rewrite (freeable r1) (freeable0 r1);
+  let _ = ST.gen_elim () in
+  hr_gather w r1;
+  HR.share r2;
+  ST.rewrite (freeable0 r2) (freeable r2);
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let freeable_equiv
+  r1 r2
+= freeable_equiv' r1 r2
+
+let alloc'
+  (#t: Type)
+  (td: typedef t)
+: ST.STT (ptr td)
+    emp
+    (fun p -> pts_to_or_null p (uninitialized td) `star` freeable_or_null p)
+= let r = RST.ref_alloc td.pcm td.uninitialized in
+  let w = {
+    base = _;
     ref = r;
-  })
+  }
   in
-  rewrite_slprop
-    (R.pts_to r _)
-    (pts_to_or_null res _)
-    (fun _ -> ());
-  return res
+  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (uninitialized td));
+  let res = HR.alloc w in
+  HR.share res;
+  HR.pts_to_not_null res;
+  ST.weaken (pts_to0 res (uninitialized td)) (pts_to_or_null res (uninitialized td)) (fun _ -> ());
+  ST.weaken (freeable0 res) (freeable_or_null res) (fun _ -> ());
+  ST.return res
+
+let alloc
+  td
+= alloc' td
+
+let free'
+  (#t: Type)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: ST.ST unit
+    (pts_to r v `star` freeable r)
+    (fun _ -> emp)
+    (
+      full td v
+    )
+    (fun _ -> True)
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = HR.read r in
+  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  ST.rewrite (freeable r) (freeable0 r);
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  RST.ref_free w.ref;
+  ST.drop (HR.pts_to _ _ _);
+  ST.return ()
 
 let free
-  #t #td #v r0
-= let r : R.ref td.pcm = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
-  R.ref_free r
+  r
+= free' r
 
-#restart-solver
-let mk_fraction_split_gen
-  #_ #_ #td r0 v p p1 p2
-=
-  let r = (Some?.v r0).ref in
+let mk_fraction_split_gen'
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm)
+: ST.STGhost unit opened
+  (pts_to r (mk_fraction td v p))
+  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ -> True)
+= ST.weaken (pts_to _ _) (pts_to0 r (mk_fraction td v p)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
   td.mk_fraction_split v p1 p2;
   td.mk_fraction_join v p1 p2;
-  rewrite_slprop
-    (pts_to _ _)
-    (R.pts_to r (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)))
-    (fun _ -> ());
-  R.split r _ (td.mk_fraction v p1) (td.mk_fraction v p2);
-  rewrite_slprop
-    (R.pts_to r (td.mk_fraction v p1))
-    (pts_to r0 (mk_fraction td v p1))
-    (fun _ -> ());
-  rewrite_slprop
-    (R.pts_to r (td.mk_fraction v p2))
-    (pts_to r0 (mk_fraction td v p2))
-    (fun _ -> ())
+  ST.rewrite
+    (R.pts_to _ _)
+    (R.pts_to w.ref (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)));
+  RST.split _ _ (td.mk_fraction v p1) (td.mk_fraction v p2);
+  HR.share r;
+  ST.weaken (pts_to0 r (td.mk_fraction v p1)) (pts_to r (mk_fraction td v p1)) (fun _ -> ());
+  ST.weaken (pts_to0 r (td.mk_fraction v p2)) (pts_to r (mk_fraction td v p2)) (fun _ -> ())
 
-let mk_fraction_join
-  #_ #_ #td r0 v p1 p2
-= let r = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 (mk_fraction td v p1))
-    (R.pts_to r (td.mk_fraction v p1))
-    (fun _ -> ());
-  rewrite_slprop
-    (pts_to r0 (mk_fraction td v p2))
-    (R.pts_to r (td.mk_fraction v p2))
-    (fun _ -> ());
-  R.gather r (td.mk_fraction v p1) (td.mk_fraction v p2);
+let mk_fraction_split_gen
+  r v p p1 p2
+= mk_fraction_split_gen' r v p p1 p2
+
+let mk_fraction_join'
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p1 p2: P.perm)
+: ST.STGhostT unit opened
+  (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
+= ST.weaken (pts_to r (mk_fraction td v p1)) (pts_to0 r (mk_fraction td v p1)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (td.mk_fraction v p1));
+  ST.weaken (pts_to r (mk_fraction td v p2)) (pts_to0 r (mk_fraction td v p2)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  ST.rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to w.ref (td.mk_fraction v p2));
+  let _ = RST.gather w.ref (td.mk_fraction v p1) _ in
   td.mk_fraction_join v p1 p2;
-  rewrite_slprop
-    (R.pts_to _ _)
-    (pts_to _ _)
-    (fun _ -> ())
+  ST.weaken (pts_to0 r _) (pts_to r _) (fun _ -> ())
+
+let mk_fraction_join
+  r v p1 p2
+= mk_fraction_join' r v p1 p2
 
 module F = Steel.C.Model.Frac
 
@@ -258,60 +530,76 @@ let mk_scalar_inj v1 v2 p1 p2 = ()
 #push-options "--z3rlimit 16"
 
 #restart-solver
+
+let scalar_unique'
+  (#opened: _)
+  (#t: Type)
+  (v1 v2: t)
+  (p1 p2: P.perm)
+  (r: ref (scalar t))
+: ST.STGhost unit opened
+    (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
+    (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
+    True
+    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+= ST.weaken (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1))) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  ST.rewrite (r_pts_to _ (Some (Some v1, p1))) (R.pts_to w.ref (Some (Some v1, p1)));
+  ST.weaken (pts_to r _) (pts_to0 r (Some (Some v2, p2))) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  ST.rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to w.ref (Some (Some v2, p2)));
+  let _ = RST.gather w.ref (Some (Some v1, p1)) (Some (Some v2, p2)) in
+  RST.split w.ref _ (Some (Some v1, p1)) (Some (Some v2, p2));
+  HR.share r;
+  ST.noop (); // FIXME: WHY WHY WHY?
+  ST.weaken (pts_to0 r (Some (Some v1, p1))) (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1)) (fun _ -> ());
+  ST.weaken (pts_to0 r (Some (Some v2, p2))) (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2)) (fun _ -> ())
+
 let scalar_unique
-  #_ #t v1 v2 p1 p2 r0
-=
-  let r : R.ref (scalar t).pcm = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v1) p1))
-    (R.pts_to r (Some (Some v1, p1)))
-    (fun _ -> ());
-  rewrite_slprop
-    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v2) p2))
-    (R.pts_to r (Some (Some v2, p2)))
-    (fun _ -> ());
-  R.gather r (Some (Some v1, p1)) (Some (Some v2, p2));
-  R.split r _ (Some (Some v1, p1)) (Some (Some v2, p2));
-  rewrite_slprop
-    (R.pts_to r (Some (Some v1, p1)))
-    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v1) p1))
-    (fun _ -> ());
-  rewrite_slprop
-    (R.pts_to r (Some (Some v2, p2)))
-    (pts_to r0 (mk_fraction (scalar _) (mk_scalar v2) p2))
-    (fun _ -> ())
+  v1 v2 p1 p2 r0
+= scalar_unique' v1 v2 p1 p2 r0
 
 #pop-options
 
-let read0
-  #t #v #p r0
-=
-  let r : R.ref (scalar t).pcm = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-    (R.pts_to r (Some (Some (Ghost.reveal v), p)))
-    (fun _ -> ());
-  let v' = R.ref_read r in
-  rewrite_slprop
-    (R.pts_to r (Some (Some (Ghost.reveal v), p)))
-    (pts_to r0 (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-    (fun _ -> ());
+let read0' (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : ST.ST t
+  (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+  (True)
+  (fun v' -> v' == Ghost.reveal v)
+= ST.weaken (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p))) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = HR.read r in
+  ST.vpattern_rewrite (HR.pts_to r _) w;
+  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Some (Some (Ghost.reveal v), p)));
+  let v' = RST.ref_read w.ref in
   let Some (Some v0, _) = v' in
-  return v0
+  ST.rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v), p)));
+  ST.weaken (pts_to0 r (Some (Some (Ghost.reveal v), p))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p)) (fun _ -> ());
+  ST.return v0
+
+let read0
+  r0
+= read0' r0
+
+let write' (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : ST.ST unit
+  (pts_to r v)
+  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
+  (full (scalar t) v)
+  (fun _ -> True)
+= ST.weaken (pts_to r _) (pts_to0 r (Ghost.reveal v)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = HR.read r in
+  ST.vpattern_rewrite (HR.pts_to r _) w;
+  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  RST.ref_upd w.ref _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
+  ST.rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v'), P.full_perm)));
+  ST.weaken (pts_to0 r (Some (Some (Ghost.reveal v'), P.full_perm))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v')) P.full_perm)) (fun _ -> ())
 
 let write
-  #t #v r0 v'
-=
-  let r : R.ref (scalar t).pcm = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
-  R.ref_upd r _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
-  rewrite_slprop
-    (R.pts_to r _)
-    (pts_to _ _)
-    (fun _ -> ())
+  r0 v'
+= write' r0 v'
 
 let field_t_nil = unit
 let field_t_cons _ _ _ = unit
@@ -499,20 +787,67 @@ let struct_get_field_uninitialized
   tn n fields field
 = ()
 
-let _inv = TD.inv
-
 let has_struct_field_gen
   (#field_t: eqtype)
   (fields: field_description_gen_t field_t)
+  (r: ref0_v (struct1 fields))
+  (field: field_t)
+  (r': ref0_v (fields.fd_typedef field))
+: GTot prop
+= r'.base == r.base /\
+  r'.ref == R.ref_focus r.ref (S.struct_field (struct_field_pcm fields) field)
+
+[@@__reduce__]
+let has_struct_field0
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
   (r: ref (struct1 fields))
   (field: field_t)
   (r': ref (fields.fd_typedef field))
-: GTot prop
-= (Some?.v r').ref == R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm fields) field)
+: Tot vprop
+= ST.exists_ (fun p -> ST.exists_ (fun w -> ST.exists_ (fun p' -> ST.exists_ (fun w' ->
+    HR.pts_to r p w `star`
+    HR.pts_to r' p' w' `star`
+    ST.pure (has_struct_field_gen fields w field w')
+  ))))
+
+let has_struct_field1
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= has_struct_field0 r field r'
 
 let has_struct_field
   r field r'
-= has_struct_field_gen _ r field r'
+= has_struct_field1 r field r'
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let has_struct_field_dup'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: ST.STGhostT unit opened
+    (has_struct_field1 r field r')
+    (fun _ -> has_struct_field1 r field r' `star` has_struct_field1 r field r')
+=
+  ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = ST.gen_elim_dep () in
+  HR.share r;
+  HR.share r';
+  ST.noop ();
+  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  ST.noop ();
+  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
+
+#pop-options
 
 let has_struct_field_gen_inj
   (#opened: _)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 40a042b1d3f..3b8e7c9e668 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -55,6 +55,7 @@ val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemm
   (ensures (v == unknown td))
 
 
+(*
 // To be extracted as: void*
 
 // FIXME: Currently, Karamel does not directly support
@@ -78,6 +79,11 @@ val typedef_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot (typedef (type_of
 let ptr (#t: Type) (td: typedef t) : Tot Type0 = (p: void_ptr { (~ (p == void_null)) ==> (type_of_ptr p == t /\ typedef_of_ptr p == td) })
 [@@noextract_to "krml"] // primitive
 let null (#t: Type) (td: typedef t) : Tot (ptr td) = void_null
+*)
+
+val ptr (#t: Type) (td: typedef t) : Tot Type0
+val null (#t: Type) (td: typedef t) : Tot (ptr td)
+
 inline_for_extraction [@@noextract_to "krml"]
 let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
 
@@ -142,21 +148,83 @@ let assert_not_null
     (fun _ _ _ -> True)
 = change_equal_slprop (pts_to_or_null p v) (pts_to p v)
 
+val ref_equiv
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: Tot vprop
+
+val pts_to_equiv
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+  (v: t)
+: SteelGhostT unit opened
+    (ref_equiv r1 r2 `star` pts_to r1 v)
+    (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
+
 val freeable
   (#t: Type)
   (#td: typedef t)
   (r: ref td)
-: GTot prop
+: Tot vprop
+
+val freeable_dup
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: SteelGhostT unit opened
+    (freeable r)
+    (fun _ -> freeable r `star` freeable r)
+
+val freeable_equiv
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: SteelGhostT unit opened
+    (ref_equiv r1 r2 `star` freeable r1)
+    (fun _ -> ref_equiv r1 r2 `star` freeable r2)
+
+let freeable_or_null'
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+: Tot vprop
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (r == null _)
+  then emp
+  else freeable r
+
+[@@__steel_reduce__]
+let freeable_or_null (#t: Type) (#td: typedef t) (p: ptr td) : vprop = VUnit ({
+  hp = hp_of (freeable_or_null' p);
+  t = _;
+  sel = trivial_selector _;
+})
+
+(*
+let freeable_or_null_dup
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+: SteelGhostT vprop opened
+    (freeable_or_null r)
+    (fun _ -> freeable_or_null r `star` freeable_or_null r)
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (r == null _)
+  then ()
+  else freeable r
+*)
 
 [@@noextract_to "krml"] // primitive
 val alloc
   (#t: Type)
   (td: typedef t)
-: Steel (ptr td)
+: SteelT (ptr td)
     emp
-    (fun p -> pts_to_or_null p (uninitialized td))
-    (fun _ -> True)
-    (fun _ p _ -> (~ (p == null _)) ==> freeable p)
+    (fun p -> pts_to_or_null p (uninitialized td) `star` freeable_or_null p)
 
 [@@noextract_to "krml"] // primitive
 val free
@@ -165,10 +233,9 @@ val free
   (#v: Ghost.erased t)
   (r: ref td)
 : Steel unit
-    (pts_to r v)
+    (pts_to r v `star` freeable r)
     (fun _ -> emp)
     (fun _ ->
-      freeable r /\
       full td v
     )
     (fun _ _ _ -> True)
@@ -425,9 +492,6 @@ val struct_get_field_uninitialized
   (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))
   [SMTPat (struct_get_field (uninitialized (struct0 tn n fields)) field)]
 
-val _inv_vprop: vprop
-val _inv: inv _inv_vprop
-
 val has_struct_field
   (#tn: Type0)
   (#tf: Type0)
@@ -436,7 +500,20 @@ val has_struct_field
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: GTot prop
+: Tot vprop
+
+val has_struct_field_dup
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: SteelGhostT unit opened
+    (has_struct_field r field r')
+    (fun _ -> has_struct_field r field r' `star` has_struct_field r field r')
 
 val has_struct_field_inj
   (#opened: _)
@@ -447,15 +524,37 @@ val has_struct_field_inj
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
   (r1 r2: ref (fields.fd_typedef field))
-: SteelGhost unit opened
-    emp
-    (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
-      has_struct_field r field r1 /\
-      has_struct_field r field r2
-    )
-    (fun _ _ _ -> r1 == r2)
+: SteelGhostT unit opened
+    (has_struct_field r field r1 `star` has_struct_field r field r2)
+    (fun _ -> has_struct_field r field r1 `star` has_struct_field r field r2 `star` ref_equiv r1 r2)
+
+val has_struct_field_equiv_from
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r1: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+  (r2: ref (struct0 tn n fields))
+: SteelGhostT unit opened
+    (ref_equiv r1 r2 `star` has_struct_field r1 field r')
+    (fun _ -> ref_equiv r1 r2 `star` has_struct_field r2 field r')
+
+val has_struct_field_equiv_to
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r1': ref (fields.fd_typedef field))
+  (r2': ref (fields.fd_typedef field))
+: SteelGhostT unit opened
+    (ref_equiv r1' r2' `star` has_struct_field r field r1')
+    (fun _ -> ref_equiv r1' r2' `star` has_struct_field r field r2')
 
 val ghost_struct_field_focus
   (#opened: _)
@@ -467,11 +566,9 @@ val ghost_struct_field_focus
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: SteelGhost unit opened
-    (pts_to r v)
-    (fun _ -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-    (fun _ -> has_struct_field r field r')
-    (fun _ _ _ -> True)
+: SteelGhostT unit opened
+    (has_struct_field r field r' `star` pts_to r v)
+    (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
 
 val ghost_struct_field
   (#opened: _)
@@ -482,11 +579,9 @@ val ghost_struct_field
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: SteelGhost (Ghost.erased (ref (fields.fd_typedef field))) opened
+: SteelGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ -> has_struct_field r field r')
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
 
 [@@noextract_to "krml"] // primitive
 val struct_field0
@@ -505,11 +600,9 @@ val struct_field0
   })
 : SteelAtomicBase (ref td') false opened Unobservable
     (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ ->
-      has_struct_field r field r'
-    )
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
+    (fun _ -> True)
+    (fun _ _ _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let struct_field
@@ -523,11 +616,9 @@ let struct_field
   (field: field_t fields)
 : SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
     (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ ->
-      has_struct_field r field r'
-    )
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field) `star` has_struct_field r field r')
+    (fun _ -> True)
+    (fun _ _ _ -> True)
 = struct_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -546,10 +637,9 @@ val unstruct_field
   (#v': Ghost.erased (fields.fd_type field))
   (r': ref (fields.fd_typedef field))
 : SteelGhost unit opened
-    (pts_to r v `star` pts_to r' v')
-    (fun _ -> pts_to r (struct_set_field field v' v))
+    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field v' v))
     (fun _ ->
-      has_struct_field r field r' /\
       struct_get_field v field == unknown (fields.fd_typedef field)
     )
     (fun _ _ _ -> True)
@@ -785,7 +875,20 @@ val has_union_field
   (r: ref (union0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: GTot prop
+: Tot vprop
+
+val has_union_field_dup
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: SteelGhostT unit opened
+    (has_union_field r field r')
+    (fun _ -> has_union_field r field r' `star` has_union_field r field r')
 
 val has_union_field_inj
   (#opened: _)
@@ -796,15 +899,35 @@ val has_union_field_inj
   (r: ref (union0 tn n fields))
   (field: field_t fields)
   (r1 r2: ref (fields.fd_typedef field))
-: SteelGhost unit opened
-    emp
-    (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
-      has_union_field r field r1 /\
-      has_union_field r field r2
-    )
-    (fun _ _ _ -> r1 == r2)
+: SteelGhostT unit opened
+    (has_union_field r field r1 `star` has_union_field r field r2)
+    (fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 r2)
+
+val has_union_field_equiv_from
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r1 r2: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: SteelGhostT unit opened
+    (has_union_field r1 field r' `star` ref_equiv r1 r2)
+    (fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
+
+val has_union_field_equiv_to
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r1 r2: ref (fields.fd_typedef field))
+: SteelGhostT unit opened
+    (has_union_field r field r1 `star` ref_equiv r1 r2)
+    (fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
 
 val ghost_union_field_focus
   (#opened: _)
@@ -816,11 +939,9 @@ val ghost_union_field_focus
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
   (r': ref (fields.fd_typedef field))
-: SteelGhost unit opened
-    (pts_to r v)
-    (fun _ -> pts_to r' (union_get_field v field))
-    (fun _ -> has_union_field r field r')
-    (fun _ _ _ -> True)
+: SteelGhostT unit opened
+    (has_union_field r field r' `star` pts_to r v)
+    (fun _ -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
 
 val ghost_union_field
   (#opened: _)
@@ -831,11 +952,9 @@ val ghost_union_field
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: SteelGhost (Ghost.erased (ref (fields.fd_typedef field))) opened
+: SteelGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
-    (fun r' -> pts_to r' (union_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ -> has_union_field r field r')
+    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
 
 [@@noextract_to "krml"] // primitive
 val union_field0
@@ -854,9 +973,9 @@ val union_field0
   })
 : SteelAtomicBase (ref td') false opened Unobservable
     (pts_to r v)
-    (fun r' -> pts_to r' (union_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ -> has_union_field r field r')
+    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let union_field
@@ -870,9 +989,9 @@ let union_field
   (field: field_t fields {union_get_case v == Some field})
 : SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
     (pts_to r v)
-    (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ -> has_union_field r field r')
+    (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
+    (fun _ -> True)
+    (fun _ r' _ -> True) 
 = union_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -889,13 +1008,9 @@ val ununion_field
   (field: field_t fields)
   (#v': Ghost.erased (fields.fd_type field))
   (r': ref (fields.fd_typedef field))
-: SteelGhost unit opened
-    (pts_to r' v')
-    (fun _ -> pts_to r (union_set_field tn n fields field v'))
-    (fun _ ->
-      has_union_field r field r'
-    )
-    (fun _ _ _ -> True)
+: SteelGhostT unit opened
+    (has_union_field r field r' `star` pts_to r' v')
+    (fun _ -> has_union_field r field r' `star` pts_to r (union_set_field tn n fields field v'))
 
 // NOTE: we DO NOT support preservation of struct prefixes
 
@@ -915,9 +1030,9 @@ val union_switch_field0
   })
 : Steel (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
     (pts_to r v)
-    (fun r' -> pts_to r' (uninitialized (fields.fd_typedef field)))
+    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
     (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> has_union_field r field r')
+    (fun _ r' _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
 let union_switch_field
@@ -930,9 +1045,9 @@ let union_switch_field
   (field: field_t fields)
 : Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) // need to write the pcm carrier value, so this cannot be Ghost or Atomic
     (pts_to r v)
-    (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
+    (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
     (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> has_union_field r field r')
+    (fun _ r' _ -> True)
 = union_switch_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -1016,7 +1131,20 @@ val has_base_array_cell
   (r: ref (base_array0 tn td n))
   (i: SZ.t)
   (r': ref td)
-: GTot prop
+: Tot vprop
+
+val has_base_array_cell_dup
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: SteelGhostT unit opened
+    (has_base_array_cell r i r')
+    (fun _ -> has_base_array_cell r i r' `star` has_base_array_cell r i r')
 
 val has_base_array_cell_inj
   (#opened: _)
@@ -1027,15 +1155,35 @@ val has_base_array_cell_inj
   (r: ref (base_array0 tn td n))
   (i: SZ.t)
   (r1 r2: ref td)
-: SteelGhost unit opened
-    emp
-    (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
-      has_base_array_cell r i r1 /\
-      has_base_array_cell r i r2
-    )
-    (fun _ _ _ -> r1 == r2)
+: SteelGhostT unit opened
+    (has_base_array_cell r i r1 `star` has_base_array_cell r i r2)
+    (fun _ -> has_base_array_cell r i r1 `star` has_base_array_cell r i r2 `star` ref_equiv r1 r2)
+
+val has_base_array_cell_equiv_from
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r1 r2: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: SteelGhostT unit opened
+    (has_base_array_cell r1 i r' `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell r2 i r' `star` ref_equiv r1 r2)
+
+val has_base_array_cell_equiv_to
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: SteelGhostT unit opened
+    (has_base_array_cell r i r1 `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell r i r2 `star` ref_equiv r1 r2)
 
 // contrary to array fields, one is not supposed to take an array cell directly from a base array. one should use arrays instead
 
@@ -1049,22 +1197,26 @@ val has_base_array_cell_inj
 
 [@@noextract_to "krml"] // primitive
 val array_ref (#t: Type) (td: typedef t) : Tot Type0
+(*
 val array_ref_base_size_type (#t: Type) (#td: typedef t) (a: array_ref td) : GTot Type0
+*)
 val array_ref_base_size (#t: Type) (#td: typedef t) (a: array_ref td) : GTot array_size_t
-val array_ref_base (#t: Type) (#td: typedef t) (a: array_ref td) : GTot (ref (base_array0 (array_ref_base_size_type a) td (array_ref_base_size a)))
+val has_array_ref_base (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r: ref (base_array0 ty td (array_ref_base_size a))) : GTot prop
+val has_array_ref_base_inj (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r1 r2: ref (base_array0 ty td (array_ref_base_size a))) : Lemma
+  (requires (has_array_ref_base a r1 /\ has_array_ref_base a r2))
+  (ensures (r1 == r2))
 val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ref td) : Ghost SZ.t
   (requires True)
   (ensures (fun y -> SZ.v y < SZ.v (array_ref_base_size a)))
-val array_ref_base_offset_inj (#opened: _) (#t: Type) (#td: typedef t) (a1 a2: array_ref td) : SteelGhost unit opened
-  emp (fun _ -> emp)
-  (requires (fun _ ->
-    Ghost.reveal (mem_inv opened _inv) == false /\
-    array_ref_base_size_type a1 == array_ref_base_size_type a2 /\
+val array_ref_base_offset_inj (#t: Type) (#td: typedef t) (#ty: Type) (a1: array_ref td) (r1: ref (base_array0 ty td (array_ref_base_size a1))) (a2: array_ref td) (r2: ref (base_array0 ty td (array_ref_base_size a2))) : Lemma
+  (requires (
     array_ref_base_size a1 == array_ref_base_size a2 /\
-    array_ref_base a1 == array_ref_base a2 /\
+    has_array_ref_base a1 r1 /\
+    has_array_ref_base a2 r2 /\
+    r1 == coerce_eq () r2 /\
     array_ref_offset a1 == array_ref_offset a2
   ))
-  (ensures (fun _ _ _ -> a1 == a2))
+  (ensures (a1 == a2))
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
@@ -1113,30 +1265,28 @@ let has_array_of_base
   (r: ref (base_array0 tn td n))
   (a: array td)
 : GTot prop
-= let (| al, len |) = a in
-  array_ref_base_size_type al == tn /\
-  array_ref_base_size al == n /\
-  array_ref_base al == r /\
-  array_ref_offset al == 0sz /\
-  Ghost.reveal len == n
+=   let (| al, len |) = a in
+    array_ref_base_size al == n /\
+    has_array_ref_base al r /\
+    array_ref_offset al == 0sz /\
+    Ghost.reveal len == n
 
 let has_array_of_base_inj
-  (#opened: _)
   (#t: Type)
   (#tn: Type0)
   (#n: array_size_t)
   (#td: typedef t)
   (r: ref (base_array0 tn td n))
   (a1 a2: array td)
-: SteelGhost unit opened
-    emp (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
+: Lemma
+  (requires (
       has_array_of_base r a1 /\
       has_array_of_base r a2
-    )
-    (fun _ _ _ -> a1 == a2)
-= array_ref_base_offset_inj (dfst a1) (dfst a2)
+  ))
+  (ensures (a1 == a2))
+= let (| ar1, _ |) = a1 in
+  let (| ar2, _ |) = a2 in
+  array_ref_base_offset_inj ar1 r ar2 r
 
 let seq_of_base_array
   (#t: Type)
@@ -1169,11 +1319,9 @@ val ghost_array_of_base
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
-: SteelGhost (a: Ghost.erased (array td) { has_array_of_base r a }) opened
+: SteelGhostT (a: Ghost.erased (array td) { has_array_of_base r a }) opened
     (pts_to r v)
     (fun a -> array_pts_to a (seq_of_base_array v))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ _ _ -> True)
 
 // to be extracted to just r
 [@@noextract_to "krml"] // primitive
@@ -1188,7 +1336,7 @@ val array_ref_of_base
 : SteelAtomicBase (a: array_ref td { array_ref_base_size a == n /\ array_ref_offset a == 0sz /\ has_array_of_base r (| a, Ghost.hide n |) }) false opened Unobservable
     (pts_to r v)
     (fun a -> array_pts_to (| a, Ghost.hide (n <: SZ.t) |) (seq_of_base_array v))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ -> True)
     (fun _ _ _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
@@ -1203,7 +1351,7 @@ let array_of_base
 : SteelAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
     (pts_to r v)
     (fun a -> array_pts_to a (seq_of_base_array v))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun _ -> True)
     (fun _ _ _ -> True)
 = let al = array_ref_of_base r in
   let a = (| al, Ghost.hide (n <: SZ.t) |) in
@@ -1223,7 +1371,6 @@ val unarray_of_base
     (array_pts_to a v)
     (fun v' -> pts_to r v')
     (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
       has_array_of_base r a
     )
     (fun _ v' _ -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
@@ -1233,30 +1380,38 @@ val has_array_of_ref
   (#td: typedef t)
   (r: ref td)
   (a: array td)
-: Ghost prop
-  (requires True)
-  (ensures (fun p ->
-    let (| al, len |) = a in
-    p ==> (
+: Tot vprop
+
+val has_array_of_ref_post
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a: array td)
+: SteelGhost unit opened
+    (has_array_of_ref r a)
+    (fun _ -> has_array_of_ref r a)
+    (fun _ -> True)
+    (fun _ _ _ ->
+      let (| al, len |) = a in
       array_ref_base_size al == 1sz /\
       array_ref_offset al == 0sz /\
       Ghost.reveal len == 1sz
-  )))
+    )
 
+(*
 val has_array_of_ref_inj
-  (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (r: ref td)
   (a1 a2: array td)
-: SteelGhost unit opened
-    emp (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
+: Lemma
+    (requires (
       has_array_of_ref r a1 /\
       has_array_of_ref r a2
-    )
-    (fun _ _ _ -> a1 == a2)
+    ))
+    (ensures a1 == a2)
+*)
 
 val ghost_array_of_ref_focus
   (#t: Type)
@@ -1265,13 +1420,9 @@ val ghost_array_of_ref_focus
   (#v: Ghost.erased t)
   (r: ref td)
   (a: array td)
-: SteelGhost unit opened
-    (pts_to r v)
-    (fun _ -> array_pts_to a (Seq.create 1 (Ghost.reveal v)))
-    (fun _ ->
-      has_array_of_ref r a
-    )
-    (fun _ _ _ -> True)
+: SteelGhostT unit opened
+    (pts_to r v `star` has_array_of_ref r a)
+    (fun _ -> has_array_of_ref r a `star` array_pts_to a (Seq.create 1 (Ghost.reveal v)))
 
 val ghost_array_of_ref
   (#t: Type)
@@ -1279,11 +1430,9 @@ val ghost_array_of_ref
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: SteelGhost (a: Ghost.erased (array td) { has_array_of_ref r a }) opened
+: SteelGhostT (Ghost.erased (array td)) opened
     (pts_to r v)
-    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ _ _ -> True)
+    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
 
 // to be extracted to just r
 [@@noextract_to "krml"] // primitive
@@ -1293,10 +1442,10 @@ val array_ref_of_ref
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: SteelAtomicBase (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz /\ has_array_of_ref r (| a, Ghost.hide 1sz |) }) false opened Unobservable
+: SteelAtomicBase (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz }) false opened Unobservable
     (pts_to r v)
-    (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r (| a, Ghost.hide 1sz |))
+    (fun _ -> True)
     (fun _ _ _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
@@ -1306,14 +1455,15 @@ let array_of_ref
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: SteelAtomicBase (a: array td { has_array_of_ref r a }) false opened Unobservable
+: SteelAtomicBase (array td) false opened Unobservable
     (pts_to r v)
-    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
+    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
+    (fun _ -> True)
     (fun _ _ _ -> True)
 = let al = array_ref_of_ref r in
-  let a = (| al, Ghost.hide 1sz |) in
+  let a : array td = (| al, Ghost.hide 1sz |) in
   change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  change_equal_slprop (has_array_of_ref _ _) (has_array_of_ref r a);
   return a
 
 val unarray_of_ref
@@ -1323,50 +1473,80 @@ val unarray_of_ref
   (#s: Ghost.erased (Seq.seq t))
   (r: ref td)
   (a: array td)
-: SteelGhost (squash (Seq.length s == 1)) opened
-    (array_pts_to a s)
-    (fun _ -> pts_to r (Seq.index s 0))
-    (fun _ ->
-      has_array_of_ref r a
-    )
-    (fun _ _ _ -> True)
+: SteelGhostT (squash (Seq.length s == 1)) opened
+    (array_pts_to a s `star` has_array_of_ref r a)
+    (fun _ -> pts_to r (Seq.index s 0) `star` has_array_of_ref r a)
 
-let has_array_cell
+val has_array_cell
   (#t: Type)
   (#td: typedef t)
   (a: array td)
   (i: SZ.t)
   (r: ref td)
-: GTot prop
+: Tot vprop
+(*
 = SZ.v i < SZ.v (dsnd a) /\
   has_base_array_cell (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r
+*)
 
-let has_array_cell_inj
+val has_array_cell_has_base_array_cell
   (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (a: array td)
   (i: SZ.t)
-  (r1 r2: ref td)
+  (r: ref td)
+  (#ty: Type)
+  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
 : SteelGhost unit opened
-    emp
-    (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
-      has_array_cell a i r1 /\
+    (has_array_cell a i r)
+    (fun _ -> has_base_array_cell br i r)
+    (fun _ -> has_array_ref_base (dfst a) br)
+    (fun _ _ _ -> True)
+
+val has_base_array_cell_has_array_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+  (#ty: Type)
+  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
+: SteelGhost unit opened
+    (has_base_array_cell br i r)
+    (fun _ -> has_array_cell a i r)
+    (fun _ -> has_array_ref_base (dfst a) br)
+    (fun _ _ _ -> True)
+
+val has_array_cell_inj
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r1 r2: ref td)
+: SteelGhostT unit opened
+    (
+      has_array_cell a i r1 `star`
       has_array_cell a i r2
     )
-    (fun _ _ _ -> r1 == r2)
-= has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
+    (fun _ ->
+      has_array_cell a i r1 `star`
+      has_array_cell a i r2 `star`
+      ref_equiv r1 r2
+    )
+// = has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
 
 val has_array_cell_array_of_ref
+  (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (r: ref td)
   (a: array td)
-: Lemma
-    (requires has_array_of_ref r a)
-    (ensures has_array_cell a 0sz r)
+: SteelGhostT unit opened
+    (has_array_of_ref r a)
+    (fun _ -> has_array_of_ref r a `star` has_array_cell a 0sz r)
 
 val ghost_array_cell_focus
   (#opened: _)
@@ -1376,13 +1556,9 @@ val ghost_array_cell_focus
   (a: array td)
   (i: SZ.t)
   (r: ref td)
-: SteelGhost (squash (has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a))) opened
-    (array_pts_to a s)
-    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
-    (fun _ ->
-      has_array_cell a i r
-    )
-    (fun _ _ _ -> True)
+: SteelGhostT (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s `star` has_array_cell a i r)
+    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
 
 val ghost_array_cell
   (#opened: _)
@@ -1391,11 +1567,10 @@ val ghost_array_cell
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: SteelGhost (r: Ghost.erased (ref td) { has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a) }) opened
+: SteelGhost (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) opened
     (array_pts_to a s)
-    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
     (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
     )
     (fun _ _ _ -> True)
@@ -1409,11 +1584,10 @@ val array_ref_cell
   (a: array_ref td)
   (len: array_len_t a)
   (i: SZ.t)
-: SteelAtomicBase (r: ref td { has_array_cell (| a, len |) i r /\ Seq.length s == SZ.v len }) false opened Unobservable
+: SteelAtomicBase (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len }) false opened Unobservable
     (array_pts_to (| a, len |) s)
-    (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell (| a, len |) i r)
     (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v len)
     )
     (fun _ _ _ -> True)
@@ -1426,11 +1600,10 @@ let array_cell
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: SteelAtomicBase (r: ref td { has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a) }) false opened Unobservable
+: SteelAtomicBase (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) false opened Unobservable
     (array_pts_to a s)
-    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)))
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
     (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
     )
     (fun _ _ _ -> True)
@@ -1438,6 +1611,7 @@ let array_cell
   change_equal_slprop (array_pts_to _ _) (array_pts_to _ s);
   let r = array_ref_cell al len i in
   change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  change_equal_slprop (has_array_cell _ _ _) (has_array_cell a i r);
   return r
 
 val unarray_cell
@@ -1449,11 +1623,10 @@ val unarray_cell
   (a: array td)
   (i: SZ.t)
   (r: ref td)
-: SteelGhost (squash (has_array_cell a i r /\ Seq.length s == SZ.v (dsnd a))) opened
-    (array_pts_to a s `star` pts_to r v)
-    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) v))
+: SteelGhost (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s `star` pts_to r v `star` has_array_cell a i r)
+    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) v) `star` has_array_cell a i r)
     (fun _ ->
-      has_array_cell a i r /\
       (SZ.v i < Seq.length s ==> Seq.index s (SZ.v i) == unknown td)
     )
     (fun _ _ _ -> True)
@@ -1466,9 +1639,8 @@ val array_ref_shift
 : Ghost (array_ref td)
     (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
     (ensures (fun y -> 
-      array_ref_base_size_type y == array_ref_base_size_type a /\
       array_ref_base_size y == array_ref_base_size a /\
-      array_ref_base y == array_ref_base a /\
+      (forall ty r . has_array_ref_base a #ty r ==> has_array_ref_base y #ty (coerce_eq () r)) /\
       array_ref_offset y == array_ref_offset a `SZ.add` i
     ))
 

From 92a7f7ea1c95a62d5df0dcdd632faa3d25318649 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Feb 2023 14:06:27 -0800
Subject: [PATCH 387/513] upgrade GenElim to universe 1

---
 ulib/experimental/Steel.ST.GenElim.Base.fst  |   2 +-
 ulib/experimental/Steel.ST.GenElim.Base.fsti | 190 ++++++++-----
 ulib/experimental/Steel.ST.GenElim.fst       | 285 ++++++++++++-------
 ulib/experimental/Steel.ST.GenElim.fsti      |   6 +-
 4 files changed, 315 insertions(+), 168 deletions(-)

diff --git a/ulib/experimental/Steel.ST.GenElim.Base.fst b/ulib/experimental/Steel.ST.GenElim.Base.fst
index 7c8b7334eee..183ea41cb9f 100644
--- a/ulib/experimental/Steel.ST.GenElim.Base.fst
+++ b/ulib/experimental/Steel.ST.GenElim.Base.fst
@@ -6,7 +6,7 @@ irreducible let gen_elim_reduce = ()
 let gen_elim_pred
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
   (ij: (gen_elim_i & gen_elim_nondep_t))
diff --git a/ulib/experimental/Steel.ST.GenElim.Base.fsti b/ulib/experimental/Steel.ST.GenElim.Base.fsti
index 2420c7bde31..bc5d80a8296 100644
--- a/ulib/experimental/Steel.ST.GenElim.Base.fsti
+++ b/ulib/experimental/Steel.ST.GenElim.Base.fsti
@@ -22,9 +22,12 @@ type gen_elim_i =
   | GEStarL: (left: gen_elim_i) -> (right: gen_unit_elim_i) -> gen_elim_i
   | GEStarR: (left: gen_unit_elim_i) -> (right: gen_elim_i) -> gen_elim_i
   | GEStar: (left: gen_elim_i) -> (right: gen_elim_i) -> gen_elim_i
-  | GEExistsNoAbs: (#a: Type0) -> (body: (a -> vprop)) -> gen_elim_i // FIXME: generalize the universe
-  | GEExistsUnit: (#a: Type0) -> (body: (a -> gen_unit_elim_i)) -> gen_elim_i
-  | GEExists: (#a: Type0) -> (body: (a -> gen_elim_i)) -> gen_elim_i
+  | GEExistsNoAbs0: (#a: Type0) -> (body: (a -> vprop)) -> gen_elim_i // FIXME: generalize the universe
+  | GEExistsUnit0: (#a: Type0) -> (body: (a -> gen_unit_elim_i)) -> gen_elim_i
+  | GEExists0: (#a: Type0) -> (body: (a -> gen_elim_i)) -> gen_elim_i
+  | GEExistsNoAbs1: (#a: Type u#1) -> (body: (a -> vprop)) -> gen_elim_i // FIXME: generalize the universe
+  | GEExistsUnit1: (#a: Type u#1) -> (body: (a -> gen_unit_elim_i)) -> gen_elim_i
+  | GEExists1: (#a: Type u#1) -> (body: (a -> gen_elim_i)) -> gen_elim_i
 
 val gen_elim_reduce: unit
 
@@ -64,24 +67,32 @@ let rec compute_gen_elim_p
   | GEStarL left right -> compute_gen_elim_p left `star` compute_gen_unit_elim_p right
   | GEStarR left right -> compute_gen_unit_elim_p left `star` compute_gen_elim_p right
   | GEStar left right -> compute_gen_elim_p left `star` compute_gen_elim_p right
-  | GEExistsNoAbs #a p -> exists_ p
-  | GEExistsUnit #a p -> exists_ (fun x -> compute_gen_unit_elim_p (p x))
-  | GEExists #a body -> exists_ (fun x -> compute_gen_elim_p (body x))
+  | GEExistsNoAbs0 #a p -> exists_ p
+  | GEExistsUnit0 #a p -> exists_ (fun x -> compute_gen_unit_elim_p (p x))
+  | GEExists0 #a body -> exists_ (fun x -> compute_gen_elim_p (body x))
+  | GEExistsNoAbs1 #a p -> exists_ p
+  | GEExistsUnit1 #a p -> exists_ (fun x -> compute_gen_unit_elim_p (p x))
+  | GEExists1 #a body -> exists_ (fun x -> compute_gen_elim_p (body x))
 
 let compute_gen_elim_p' = compute_gen_elim_p
 
+module U = FStar.Universe
+
 [@@ gen_elim_reduce; __steel_reduce__; noextract_to "Plugin"]
 let rec compute_gen_elim_a
   (x: gen_elim_i)
-: Tot Type0
+: Tot (Type u#1)
 = match x with
-  | GEUnit _ -> unit
+  | GEUnit _ -> U.raise_t unit
   | GEStarL left _ -> compute_gen_elim_a left
   | GEStarR _ right -> compute_gen_elim_a right
   | GEStar left right -> (compute_gen_elim_a left & compute_gen_elim_a right)
-  | GEExistsNoAbs #a _
-  | GEExistsUnit #a _ -> a
-  | GEExists #a body -> dtuple2 a (fun x -> compute_gen_elim_a (body x))
+  | GEExistsNoAbs0 #a _
+  | GEExistsUnit0 #a _ -> U.raise_t a
+  | GEExists0 #a body -> dtuple2 a (fun x -> compute_gen_elim_a (body x))
+  | GEExistsNoAbs1 #a _
+  | GEExistsUnit1 #a _ -> a
+  | GEExists1 #a body -> dtuple2 a (fun x -> compute_gen_elim_a (body x))
 
 [@@noextract_to "Plugin"]
 let dfstp #a #b t = dfst #a #b t
@@ -110,9 +121,18 @@ let rec compute_gen_elim_q
     fun v ->
       let v' : (tleft & tright) = coerce_with_trefl v in
       compute_gen_elim_q left (fstp #tleft #tright v') `star` compute_gen_elim_q right (sndp #tleft #tright v')
-  | GEExistsNoAbs #a p -> p
-  | GEExistsUnit #a p -> fun v -> compute_gen_unit_elim_q (p v)
-  | GEExists #a body ->
+  | GEExistsNoAbs0 #a p -> fun v -> p (U.downgrade_val v)
+  | GEExistsUnit0 #a p -> fun v -> compute_gen_unit_elim_q (p (U.downgrade_val v))
+  | GEExists0 #a body ->
+    let dept = (fun x -> compute_gen_elim_a (body x)) in
+    fun v ->
+    let v' : dtuple2 a dept = coerce_with_trefl v in
+    compute_gen_elim_q
+      (body (dfstp #a #dept v'))
+      (dsndp #a #dept v')
+  | GEExistsNoAbs1 #a p -> p
+  | GEExistsUnit1 #a p -> fun v -> compute_gen_unit_elim_q (p v)
+  | GEExists1 #a body ->
     let dept = (fun x -> compute_gen_elim_a (body x)) in
     fun v ->
     let v' : dtuple2 a dept = coerce_with_trefl v in
@@ -135,9 +155,18 @@ let rec compute_gen_elim_post
     fun v ->
       let v' : (tleft & tright) = coerce_with_trefl v in
       compute_gen_elim_post left (fstp #tleft #tright v') /\ compute_gen_elim_post right (sndp #tleft #tright v')
-  | GEExistsNoAbs #a p -> fun _ -> True
-  | GEExistsUnit #a p -> fun v -> compute_gen_unit_elim_post (p v)
-  | GEExists #a body ->
+  | GEExistsNoAbs0 #a p -> fun _ -> True
+  | GEExistsUnit0 #a p -> fun v -> compute_gen_unit_elim_post (p (U.downgrade_val v))
+  | GEExists0 #a body ->
+    let dept = (fun x -> compute_gen_elim_a (body x)) in
+    fun v ->
+    let v' : dtuple2 a dept = coerce_with_trefl v in
+    compute_gen_elim_post
+      (body (dfstp #a #dept v'))
+      (dsndp #a #dept v')
+  | GEExistsNoAbs1 #a p -> fun _ -> True
+  | GEExistsUnit1 #a p -> fun v -> compute_gen_unit_elim_post (p v)
+  | GEExists1 #a body ->
     let dept = (fun x -> compute_gen_elim_a (body x)) in
     fun v ->
     let v' : dtuple2 a dept = coerce_with_trefl v in
@@ -147,9 +176,9 @@ let rec compute_gen_elim_post
 
 [@@erasable]
 noeq
-type gen_elim_tele =
+type gen_elim_tele : Type u#(max 2 (a + 1)) =
   | TRet: vprop -> prop -> gen_elim_tele
-  | TExists: (ty: Type u#0) -> (ty -> gen_elim_tele) -> gen_elim_tele
+  | TExists: (ty: Type u#a) -> (ty -> gen_elim_tele) -> gen_elim_tele
 
 [@@gen_elim_reduce]
 let rec tele_star_vprop (i: gen_elim_tele) (v: vprop) (p: prop) : Tot gen_elim_tele (decreases i) =
@@ -165,15 +194,18 @@ let rec tele_star (i1 i2: gen_elim_tele) : Tot gen_elim_tele =
   | TExists ty1 f1, TExists ty2 f2 -> TExists ty1 (fun x1 -> TExists ty2 (fun x2 -> tele_star (f1 x1) (f2 x2)))
 
 [@@gen_elim_reduce]
-let rec compute_gen_elim_tele (x: gen_elim_i) : Tot gen_elim_tele =
+let rec compute_gen_elim_tele (x: gen_elim_i) : Tot (gen_elim_tele u#1) =
   match x with
   | GEUnit v -> TRet (compute_gen_unit_elim_q v) (compute_gen_unit_elim_post v)
   | GEStarL l ru -> tele_star_vprop (compute_gen_elim_tele l) (compute_gen_unit_elim_q ru) (compute_gen_unit_elim_post ru)
   | GEStarR lu r -> tele_star_vprop (compute_gen_elim_tele r) (compute_gen_unit_elim_q lu) (compute_gen_unit_elim_post lu)
   | GEStar l r -> tele_star (compute_gen_elim_tele l) (compute_gen_elim_tele r)
-  | GEExistsNoAbs #ty body -> TExists ty (fun x -> TRet (body x) True)
-  | GEExistsUnit #ty body -> TExists ty (fun x -> TRet (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_post (body x)))
-  | GEExists #ty f -> TExists ty (fun x -> compute_gen_elim_tele (f x))
+  | GEExistsNoAbs0 #ty body -> TExists (U.raise_t ty) (fun x -> TRet (body (U.downgrade_val x)) True)
+  | GEExistsUnit0 #ty body -> TExists (U.raise_t ty) (fun x -> TRet (compute_gen_unit_elim_q (body (U.downgrade_val x))) (compute_gen_unit_elim_post (body (U.downgrade_val x))))
+  | GEExists0 #ty f -> TExists (U.raise_t ty) (fun x -> compute_gen_elim_tele (f (U.downgrade_val x)))
+  | GEExistsNoAbs1 #ty body -> TExists ty (fun x -> TRet (body x) True)
+  | GEExistsUnit1 #ty body -> TExists ty (fun x -> TRet (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_post (body x)))
+  | GEExists1 #ty f -> TExists ty (fun x -> compute_gen_elim_tele (f x))
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
 let rec curried_function_type (x: list (Type u#a)) (ret_t: Type u#(max a b)) : Tot (Type u#(max a b)) =
@@ -183,56 +215,56 @@ let rec curried_function_type (x: list (Type u#a)) (ret_t: Type u#(max a b)) : T
 
 [@@erasable]
 noeq
-type gen_elim_nondep_t =
-| GENonDep: (ty: list Type0) -> curried_function_type ty vprop -> curried_function_type ty prop -> gen_elim_nondep_t
+type gen_elim_nondep_t : Type u#(max 2 (a + 1)) =
+| GENonDep: (ty: list (Type u#a)) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> gen_elim_nondep_t
 | GEDep
 
 [@@gen_elim_reduce]
 let mk_gen_elim_nondep
-  (ty: list Type0)
+  (ty: list (Type u#a))
   (tvprop: Type)
   (q: tvprop)
   (tprop: Type)
   (post: tprop)
-: Pure gen_elim_nondep_t
+: Pure (gen_elim_nondep_t u#a)
   (requires (
-    tvprop == curried_function_type ty vprop /\
-    tprop == curried_function_type ty prop
+    tvprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) /\
+    tprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop)
   ))
   (ensures (fun _ -> True))
 = GENonDep ty q post
 
 [@@gen_elim_reduce]
 let mk_gen_elim_nondep_by_tac
-  (ty: list Type0)
+  (ty: list (Type u#a))
   (tvprop: Type)
   (q: tvprop)
   (tprop: Type)
   (post: tprop)
-: Pure gen_elim_nondep_t
+: Pure (gen_elim_nondep_t u#a)
   (requires (
-    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tvprop == curried_function_type ty vprop) /\
-    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tprop == curried_function_type ty prop)
+    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tvprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop)) /\
+    T.with_tactic (fun _ -> T.norm [delta_attr [(`%gen_elim_reduce)]; iota; zeta]) (tprop == curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop))
   ))
   (ensures (fun _ -> True))
 = GENonDep ty q post
 
 [@@gen_elim_reduce]
-let rec gen_elim_nondep_sem (ty: list Type0) : Tot (curried_function_type ty vprop -> curried_function_type ty prop -> Tot gen_elim_tele) =
-  match ty as ty' returns curried_function_type ty' vprop -> curried_function_type ty' prop -> Tot gen_elim_tele with
-  | [] -> fun q post -> TRet q post
+let rec gen_elim_nondep_sem (ty: list (Type u#a)) : Tot (curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot (gen_elim_tele u#a)) =
+  match ty as ty' returns curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot gen_elim_tele with
+  | [] -> fun q post -> TRet (q (U.raise_val ())) (post (U.raise_val ()))
   | t :: tq -> fun q post -> TExists t (fun x -> gen_elim_nondep_sem tq (q x) (post x))
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let check_gen_elim_nondep_sem (i: gen_elim_i) (nd: gen_elim_nondep_t) : Tot prop =
+let check_gen_elim_nondep_sem (i: gen_elim_i) (nd: gen_elim_nondep_t u#1) : Tot prop =
   match nd with
   | GENonDep ty q post -> compute_gen_elim_tele i == gen_elim_nondep_sem ty q post
   | GEDep -> True
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let compute_gen_elim_nondep_a' (ty: list Type0) : Tot Type0 =
+let compute_gen_elim_nondep_a' (ty: list (Type u#a)) : Tot (Type u#a) =
     match ty with
-    | [] -> unit
+    | [] -> U.raise_t unit
     | [t1] -> t1
     | [t1; t2] -> tuple2 t1 t2
     | [t1; t2; t3] -> tuple3 t1 t2 t3
@@ -247,16 +279,16 @@ let compute_gen_elim_nondep_a' (ty: list Type0) : Tot Type0 =
     | [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12] -> tuple12 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12
     | [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13] -> tuple13 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13
     | [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13; t14] -> tuple14 t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14
-    | _ -> unit // unsupported
+    | _ -> U.raise_t unit // unsupported
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let compute_gen_elim_nondep_a (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot Type0 =
+let compute_gen_elim_nondep_a (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot Type =
   match i with
   | GENonDep ty q post -> compute_gen_elim_nondep_a' ty
   | GEDep -> compute_gen_elim_a i0
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
-let compute_uncurry (ret_type: Type u#a) (def: ret_type) (ty: list Type0) : curried_function_type ty ret_type -> compute_gen_elim_nondep_a' ty -> ret_type =
+let compute_uncurry (ret_type: Type u#(max a b)) (def: ret_type) (ty: list (Type u#a)) : curried_function_type ty ret_type -> compute_gen_elim_nondep_a' ty -> ret_type =
     match ty as ty' returns (curried_function_type ty' ret_type -> compute_gen_elim_nondep_a' ty' -> ret_type) with
     | [] -> fun q _ -> q
     | [t1] -> fun q -> q
@@ -278,7 +310,7 @@ let compute_uncurry (ret_type: Type u#a) (def: ret_type) (ty: list Type0) : curr
 [@@gen_elim_reduce]
 let compute_gen_elim_nondep_q0 (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot (compute_gen_elim_nondep_a i0 i -> vprop) =
   match i with
-  | GENonDep ty q post -> compute_uncurry vprop (compute_gen_elim_p' i0) ty q
+  | GENonDep ty q post -> fun x -> compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) ty q x (U.raise_val ())
       // that default value does not reduce, on purpose, to make the tactic fail if the type list is too long
   | GEDep -> compute_gen_elim_q i0
 
@@ -289,7 +321,7 @@ let compute_gen_elim_nondep_q (i0: gen_elim_i) (i: gen_elim_nondep_t) (x: Ghost.
 [@@gen_elim_reduce; noextract_to "Plugin"]
 let compute_gen_elim_nondep_post0 (i0: gen_elim_i) (i: gen_elim_nondep_t) : Tot (compute_gen_elim_nondep_a i0 i -> prop) =
   match i with
-  | GENonDep ty q post -> compute_uncurry prop True ty post
+  | GENonDep ty q post -> fun x -> compute_uncurry _ (fun _ -> True) ty post x (U.raise_val ())
   | GEDep -> compute_gen_elim_post i0
 
 [@@gen_elim_reduce; noextract_to "Plugin"]
@@ -346,6 +378,14 @@ let abstr_has_exists
   | T.Tv_Abs _ body -> term_has_head body (`exists_)
   | _ -> false
 
+let rec get_universe
+  (u: T.universe)
+: T.Tac nat
+= match T.inspect_universe u with
+  | T.Uv_Zero -> 0
+  | T.Uv_Succ u -> 1 + get_universe u
+  | _ -> T.fail "get_universe: not an universe instantiation"
+
 let rec solve_gen_elim
   (tl': T.term)
 : T.Tac T.term
@@ -358,6 +398,10 @@ let rec solve_gen_elim
         let (hd, lbody) = T.collect_app tl' in
         if hd `is_fvar` (`%exists_)
         then
+          let universe = match T.inspect_ln_unascribe hd with
+          | T.Tv_UInst _ (u :: _) -> get_universe u
+          | _ -> T.fail "ill-formed exists_: no universe found"
+          in
           let (ty, body) =
             match lbody with
             | [(ty, T.Q_Implicit); (body, T.Q_Explicit)] -> ([(ty, T.Q_Implicit)], body)
@@ -369,12 +413,27 @@ let rec solve_gen_elim
               if not (term_has_head abody (`exists_))
               then
                 let body' = solve_gen_unit_elim abody in
-                T.mk_app (`GEExistsUnit) (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
+                T.mk_app 
+                  begin match universe with
+                  | 0 -> (`GEExistsUnit0)
+                  | _ -> (`GEExistsUnit1)
+                  end
+                  (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
               else
                 let body' = solve_gen_elim abody in
-                T.mk_app (`GEExists) (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
+                T.mk_app
+                  begin match universe with
+                  | 0 -> (`GEExists0)
+                  | _ -> (`GEExists1)
+                  end
+                  (ty `List.Tot.append` [T.mk_abs [b] body', T.Q_Explicit])
             | _ ->
-              T.mk_app (`GEExistsNoAbs) lbody
+              T.mk_app
+                begin match universe with
+                | 0 -> (`GEExistsNoAbs0)
+                | _ -> (`GEExistsNoAbs1)
+                end
+                lbody
           end
         else if is_star_or_vstar hd
         then
@@ -402,7 +461,7 @@ let rec solve_gen_elim
 val gen_elim_prop
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Tot prop
@@ -412,7 +471,7 @@ val gen_elim_prop_intro'
   (j: gen_elim_nondep_t)
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
   (sq_p: squash (p == compute_gen_elim_p i))
@@ -425,18 +484,18 @@ val gen_elim_prop_intro'
 
 let gen_elim_prop_intro
   (i: gen_elim_i)
-  (ty: list Type0)
+  (ty: list (Type u#1))
   (tvprop: Type)
   (q0: tvprop)
   (tprop: Type)
   (post0: tprop)
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
-  (sq_tvprop: squash (tvprop == curried_function_type ty vprop))
-  (sq_tprop: squash (tprop == curried_function_type ty prop))
+  (sq_tvprop: squash (tvprop == curried_function_type u#1 u#2 ty (U.raise_t unit -> vprop)))
+  (sq_tprop: squash (tprop == curried_function_type u#1 u#2 ty (U.raise_t u#_ u#2 unit -> prop)))
   (sq_p: squash (p == compute_gen_elim_p i))
   (sq_j: squash (check_gen_elim_nondep_sem i (mk_gen_elim_nondep ty tvprop q0 tprop post0)))
   (sq_a: squash (a == compute_gen_elim_nondep_a i (mk_gen_elim_nondep ty tvprop q0 tprop post0)))
@@ -449,7 +508,7 @@ let gen_elim_prop_intro
 val gen_elim_prop_elim
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Ghost (gen_elim_i & gen_elim_nondep_t)
@@ -466,7 +525,7 @@ val gen_elim_prop_elim
 let gen_elim_prop_placeholder
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Tot prop
@@ -475,7 +534,7 @@ let gen_elim_prop_placeholder
 let gen_elim_prop_placeholder_intro
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type u#1)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
 : Lemma (gen_elim_prop_placeholder enable_nondep_opt p a q post)
@@ -492,27 +551,28 @@ let rec solve_gen_elim_nondep' (fuel: nat) (rev_types_and_binders: list (T.term
       let cons_type (accu: (unit -> T.Tac T.term)) (tb: (T.term & T.binder)) () : T.Tac T.term =
         let (ty, _) = tb in
         let tl = accu () in
-        T.mk_app (`Cons) [(`Type0), T.Q_Implicit; ty, T.Q_Explicit; tl, T.Q_Explicit]
+        T.mk_app (`Cons) [(`Type u#1), T.Q_Implicit; ty, T.Q_Explicit; tl, T.Q_Explicit]
       in
-      let nil_type () : T.Tac T.term = T.mk_app (`Nil) [(`Type0), T.Q_Implicit] in
+      let nil_type () : T.Tac T.term = T.mk_app (`Nil) [(`(Type u#1)), T.Q_Implicit] in
       let type_list = List.Tot.fold_left cons_type nil_type rev_types_and_binders () in
       let type_list_typechecks =
         let open T in
         try
           let env = cur_env () in
           let ty = tc env type_list in
-          ty `term_eq_old` (`(list Type0))
+          ty `term_eq_old` (`(list (Type u#1)))
         with _ -> false
       in
       if not type_list_typechecks
       then None
       else
-        let binders = List.Tot.map snd (List.Tot.rev rev_types_and_binders) in
+        let dummy_raised_unit_binder = T.fresh_binder (`(U.raise_t u#_ u#2 unit)) in
+        let binders = List.Tot.map snd (List.Tot.rev rev_types_and_binders) `List.Tot.append` [dummy_raised_unit_binder] in
         let norm_term = T.norm_term [delta_attr [(`%gen_elim_reduce)]; zeta; iota] in
         let v' = T.mk_abs binders v in
-        let tv' = norm_term (T.mk_app (`curried_function_type) [type_list, T.Q_Explicit; (`vprop), T.Q_Explicit]) in
+        let tv' = norm_term (T.mk_app (`(curried_function_type u#1 u#2)) [type_list, T.Q_Explicit; (`(U.raise_t u#_ u#2 unit -> vprop)), T.Q_Explicit]) in
         let p' = T.mk_abs binders p in
-        let tp' = norm_term (T.mk_app (`curried_function_type) [type_list, T.Q_Explicit; (`prop), T.Q_Explicit]) in
+        let tp' = norm_term (T.mk_app (`(curried_function_type u#1 u#2)) [type_list, T.Q_Explicit; (`(U.raise_t u#_ u#2 unit -> prop)), T.Q_Explicit]) in
         Some (Mktuple5
           type_list
           tv'
@@ -551,7 +611,7 @@ let solve_gen_elim_nondep (enable_nondep_opt: bool) (t: T.term) : T.Tac T.term =
           v'
           tp'
           p'
-        ) -> T.mk_app (`mk_gen_elim_nondep_by_tac) [
+        ) -> T.mk_app (`(mk_gen_elim_nondep_by_tac u#1)) [
           type_list, T.Q_Explicit;
           tv', T.Q_Explicit;
           v', T.Q_Explicit;
@@ -628,7 +688,9 @@ let solve_gen_elim_prop_placeholder
       let i' = solve_gen_elim p in
       let j' = solve_gen_elim_nondep enable_nondep_opt i' in
       let norm_term = T.norm_term [delta_attr [(`%gen_elim_reduce)]; zeta; iota] in
-      let a' = norm_term (T.mk_app (`compute_gen_elim_nondep_a) [i', T.Q_Explicit; j', T.Q_Explicit]) in
+      let a' = T.mk_app (`compute_gen_elim_nondep_a) [i', T.Q_Explicit; j', T.Q_Explicit] in
+      let a'_ts = T.term_to_string a' in
+      let a' = norm_term a' in
       let q' = norm_term (T.mk_app (`compute_gen_elim_nondep_q) [i', T.Q_Explicit; j', T.Q_Explicit]) in
       let post' = norm_term (T.mk_app (`compute_gen_elim_nondep_post) [i', T.Q_Explicit; j', T.Q_Explicit]) in
       T.unshelve a;
diff --git a/ulib/experimental/Steel.ST.GenElim.fst b/ulib/experimental/Steel.ST.GenElim.fst
index 49c274413a0..6f1cceba1e1 100644
--- a/ulib/experimental/Steel.ST.GenElim.fst
+++ b/ulib/experimental/Steel.ST.GenElim.fst
@@ -2,26 +2,29 @@ module Steel.ST.GenElim
 
 let gen_elim_f
   (p: vprop)
-  (a: Type0) // FIXME: generalize this universe
+  (a: Type)
   (q: (a -> vprop))
   (post: (a -> prop))
 : Tot Type
 = ((opened: inames) -> STGhost a opened p q True post)
 
+module U = FStar.Universe
+
 let gen_unit_elim_t (i: gen_unit_elim_i) : Tot Type =
-  gen_elim_f (compute_gen_unit_elim_p i) unit (fun _ -> compute_gen_unit_elim_q i) (fun _ -> compute_gen_unit_elim_post i)
+  gen_elim_f (compute_gen_unit_elim_p i) (U.raise_t u#_ u#1 unit) (fun _ -> compute_gen_unit_elim_q i) (fun _ -> compute_gen_unit_elim_post i)
 
 let compute_gen_unit_elim_f_id
   (v: vprop)
 : Tot (gen_unit_elim_t (GUEId v))
-= fun _ -> noop ()
+= fun _ -> noop (); U.raise_val ()
 
 let compute_gen_unit_elim_f_pure
   (p: prop)
 : Tot (gen_unit_elim_t (GUEPure p))
 = fun _ ->
   rewrite (compute_gen_unit_elim_p (GUEPure p)) (pure p);
-  elim_pure p
+  elim_pure p;
+  U.raise_val ()
 
 let compute_gen_unit_elim_f_star
   (i1 i2: gen_unit_elim_i)
@@ -30,8 +33,10 @@ let compute_gen_unit_elim_f_star
 : Tot (gen_unit_elim_t (GUEStar i1 i2))
 = fun _ ->
   rewrite (compute_gen_unit_elim_p (GUEStar i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_unit_elim_p i2);
-  f1 _; f2 _;
-  rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_unit_elim_q i2) (compute_gen_unit_elim_q (GUEStar i1 i2))
+  let _ = f1 _ in
+  let _ = f2 _ in
+  rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_unit_elim_q i2) (compute_gen_unit_elim_q (GUEStar i1 i2));
+  U.raise_val ()
 
 let rec compute_gen_unit_elim_f
   (i: gen_unit_elim_i)
@@ -58,7 +63,7 @@ let compute_gen_elim_f_star_l
   fun _ ->
   rewrite (compute_gen_elim_p (GEStarL i1 i2)) (compute_gen_elim_p i1 `star` compute_gen_unit_elim_p i2);
   let res = f1 _ in
-  f2 _;
+  let _ = f2 _ in
   let res' : compute_gen_elim_a (GEStarL i1 i2) = coerce_with_trefl res in
   rewrite (compute_gen_elim_q i1 res `star` compute_gen_unit_elim_q i2) (compute_gen_elim_q (GEStarL i1 i2) res');
   res'
@@ -71,7 +76,7 @@ let compute_gen_elim_f_star_r
 = let f1 = compute_gen_unit_elim_f i1 in
   fun _ ->
   rewrite (compute_gen_elim_p (GEStarR i1 i2)) (compute_gen_unit_elim_p i1 `star` compute_gen_elim_p i2);
-  f1 _;
+  let _ = f1 _ in
   let res = f2 _ in
   let res' : compute_gen_elim_a (GEStarR i1 i2) = coerce_with_trefl res in
   rewrite (compute_gen_unit_elim_q i1 `star` compute_gen_elim_q i2 res) (compute_gen_elim_q (GEStarR i1 i2) res');
@@ -91,15 +96,15 @@ let compute_gen_elim_f_star
   rewrite (compute_gen_elim_q i1 res1 `star` compute_gen_elim_q i2 res2) (compute_gen_elim_q (GEStar i1 i2) res);
   res
 
-let compute_gen_elim_f_exists_no_abs
+let compute_gen_elim_f_exists_no_abs0
   (a: Type0)
   (body: (a -> vprop))
-: GTot (gen_elim_t (GEExistsNoAbs body))
+: GTot (gen_elim_t (GEExistsNoAbs0 body))
 = fun _ ->
-  rewrite (compute_gen_elim_p (GEExistsNoAbs body)) (exists_ body);
+  rewrite (compute_gen_elim_p (GEExistsNoAbs0 body)) (exists_ body);
   let gres = elim_exists () in
-  let res : compute_gen_elim_a (GEExistsNoAbs body) = coerce_with_trefl (Ghost.reveal gres) in
-  rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs body) res);
+  let res : compute_gen_elim_a (GEExistsNoAbs0 body) = U.raise_val (Ghost.reveal gres) in //  coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs0 body) res);
   res
 
 let rewrite_with_trefl (#opened:_) (p q:vprop)
@@ -110,29 +115,65 @@ let rewrite_with_trefl (#opened:_) (p q:vprop)
       (ensures fun _ -> True)
 = rewrite p q
 
-let compute_gen_elim_f_exists_unit
+let compute_gen_elim_f_exists_unit0
   (a: Type0)
   (body: a -> gen_unit_elim_i)
-: Tot (gen_elim_t (GEExistsUnit body))
+: Tot (gen_elim_t (GEExistsUnit0 body))
 = fun _ ->
-  rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
+  rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit0 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
   let gres = elim_exists () in
-  compute_gen_unit_elim_f (body gres) _;
-  let res : compute_gen_elim_a (GEExistsUnit body) = coerce_with_trefl (Ghost.reveal gres) in
-  rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit body) res);
+  let _ = compute_gen_unit_elim_f (body gres) _ in
+  let res : compute_gen_elim_a (GEExistsUnit0 body) = U.raise_val (Ghost.reveal gres) in // coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit0 body) res);
   res
 
-let compute_gen_elim_f_exists
+let compute_gen_elim_f_exists0
   (a: Type0)
   (body: a -> gen_elim_i)
   (f: (x: a) -> GTot (gen_elim_t (body x)))
-: Tot (gen_elim_t (GEExists body))
+: Tot (gen_elim_t (GEExists0 body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p (GEExists0 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
+  let gres1 = elim_exists () in
+  let gres2 = f gres1 _ in
+  let res : compute_gen_elim_a (GEExists0 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
+  rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists0 body) res);
+  res
+
+let compute_gen_elim_f_exists_no_abs1
+  (a: Type)
+  (body: (a -> vprop))
+: GTot (gen_elim_t (GEExistsNoAbs1 body))
+= fun _ ->
+  rewrite (compute_gen_elim_p (GEExistsNoAbs1 body)) (exists_ body);
+  let gres = elim_exists () in
+  let res : compute_gen_elim_a (GEExistsNoAbs1 body) = coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (body gres) (compute_gen_elim_q (GEExistsNoAbs1 body) res);
+  res
+
+let compute_gen_elim_f_exists_unit1
+  (a: Type)
+  (body: a -> gen_unit_elim_i)
+: Tot (gen_elim_t (GEExistsUnit1 body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p (GEExistsUnit1 body)) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
+  let gres = elim_exists () in
+  let _ = compute_gen_unit_elim_f (body gres) _ in
+  let res : compute_gen_elim_a (GEExistsUnit1 body) = coerce_with_trefl (Ghost.reveal gres) in
+  rewrite (compute_gen_unit_elim_q (body gres)) (compute_gen_elim_q (GEExistsUnit1 body) res);
+  res
+
+let compute_gen_elim_f_exists1
+  (a: Type)
+  (body: a -> gen_elim_i)
+  (f: (x: a) -> GTot (gen_elim_t (body x)))
+: Tot (gen_elim_t (GEExists1 body))
 = fun _ ->
-  rewrite_with_trefl (compute_gen_elim_p (GEExists body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
+  rewrite_with_trefl (compute_gen_elim_p (GEExists1 body)) (exists_ (fun x -> compute_gen_elim_p (body x)));
   let gres1 = elim_exists () in
   let gres2 = f gres1 _ in
-  let res : compute_gen_elim_a (GEExists body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
-  rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists body) res);
+  let res : compute_gen_elim_a (GEExists1 body) = coerce_with_trefl (Mkdtuple2 #a #(fun x -> compute_gen_elim_a (body x)) (Ghost.reveal gres1) (Ghost.reveal gres2)) in
+  rewrite (compute_gen_elim_q (body gres1) gres2) (compute_gen_elim_q (GEExists1 body) res);
   res
 
 let rec compute_gen_elim_f
@@ -143,9 +184,12 @@ let rec compute_gen_elim_f
   | GEStarL i1 i2 -> compute_gen_elim_f_star_l i1 (compute_gen_elim_f i1) i2
   | GEStarR i1 i2 -> compute_gen_elim_f_star_r i1 i2 (compute_gen_elim_f i2)
   | GEStar i1 i2 -> compute_gen_elim_f_star i1 (compute_gen_elim_f i1) i2 (compute_gen_elim_f i2)
-  | GEExistsNoAbs body -> compute_gen_elim_f_exists_no_abs _ body
-  | GEExistsUnit body -> compute_gen_elim_f_exists_unit _ body
-  | GEExists body -> compute_gen_elim_f_exists _ body (fun x -> compute_gen_elim_f (body x))
+  | GEExistsNoAbs0 body -> compute_gen_elim_f_exists_no_abs0 _ body
+  | GEExistsUnit0 body -> compute_gen_elim_f_exists_unit0 _ body
+  | GEExists0 body -> compute_gen_elim_f_exists0 _ body (fun x -> compute_gen_elim_f (body x))
+  | GEExistsNoAbs1 body -> compute_gen_elim_f_exists_no_abs1 _ body
+  | GEExistsUnit1 body -> compute_gen_elim_f_exists_unit1 _ body
+  | GEExists1 body -> compute_gen_elim_f_exists1 _ body (fun x -> compute_gen_elim_f (body x))
 
 let rec tele_p (x: gen_elim_tele) : Tot vprop =
   match x with
@@ -252,7 +296,7 @@ let compute_gen_elim_tele_correct_unit
 : Tot (ge_to_tele_t (GEUnit v))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p v);
-  compute_gen_unit_elim_f v _;
+  let _ = compute_gen_unit_elim_f v _ in
   intro_pure (compute_gen_unit_elim_post v);
   rewrite_with_trefl (compute_gen_unit_elim_q v `star` pure _) (tele_p _)
 
@@ -264,7 +308,7 @@ let compute_gen_elim_tele_correct_star_l
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_elim_p l `star` compute_gen_unit_elim_p ru);
   ihl _;
-  compute_gen_unit_elim_f ru _;
+  let _ = compute_gen_unit_elim_f ru _ in
   intro_pure (compute_gen_unit_elim_post ru);
   tele_star_vprop_correct _ _ _ _;
   rewrite_with_trefl (tele_p _) (tele_p _)
@@ -277,7 +321,7 @@ let compute_gen_elim_tele_correct_star_r
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (compute_gen_unit_elim_p lu `star` compute_gen_elim_p r);
   ihr _;
-  compute_gen_unit_elim_f lu _;
+  let _ = compute_gen_unit_elim_f lu _ in
   intro_pure (compute_gen_unit_elim_post lu);
   tele_star_vprop_correct _ _ _ _;
   rewrite_with_trefl (tele_p _) (tele_p _)
@@ -295,10 +339,48 @@ let compute_gen_elim_tele_correct_star
   tele_star_correct (compute_gen_elim_tele l) (compute_gen_elim_tele r) _;
   rewrite_with_trefl (tele_p _) (tele_p _)
 
-let compute_gen_elim_tele_correct_exists_no_abs
+let compute_gen_elim_tele_correct_exists_no_abs0
   (ty: _)
   (body: ty -> vprop)
-: Tot (ge_to_tele_t (GEExistsNoAbs #ty body))
+: Tot (ge_to_tele_t (GEExistsNoAbs0 #ty body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
+  let x = elim_exists' () in
+  intro_pure True;
+  rewrite (body x) (body (U.downgrade_val (U.raise_val x)));
+  intro_exists (U.raise_val u#0 u#1 x) (fun x -> body (U.downgrade_val x) `star` pure True);
+  rewrite_with_trefl (exists_ _) (tele_p _)
+
+let compute_gen_elim_tele_correct_exists_unit0
+  (ty: _)
+  (body: ty -> gen_unit_elim_i)
+: Tot (ge_to_tele_t (GEExistsUnit0 #ty body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
+  let x = elim_exists' () in
+  let _ = compute_gen_unit_elim_f (body x) _ in
+  intro_pure (compute_gen_unit_elim_post (body (U.downgrade_val (U.raise_val u#0 u#1 x))));
+  rewrite (compute_gen_unit_elim_q (body x)) (compute_gen_unit_elim_q (body (U.downgrade_val (U.raise_val x))));
+  intro_exists (U.raise_val u#0 u#1 x) (fun x -> compute_gen_unit_elim_q (body (U.downgrade_val x)) `star` pure (compute_gen_unit_elim_post (body (U.downgrade_val x))));
+  rewrite_with_trefl (exists_ _) (tele_p _)
+
+let compute_gen_elim_tele_correct_exists0
+  (ty: _)
+  (body: ty -> gen_elim_i)
+  (ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
+: Tot (ge_to_tele_t (GEExists0 #ty body))
+= fun _ ->
+  rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
+  let x = elim_exists' () in
+  ih x _;
+  rewrite (tele_p (compute_gen_elim_tele (body x))) (tele_p (compute_gen_elim_tele (body (U.downgrade_val (U.raise_val u#0 u#1 x)))));
+  intro_exists (U.raise_val u#0 u#1 x) (fun x -> tele_p (compute_gen_elim_tele (body (U.downgrade_val u#0 u#1 x))));
+  rewrite_with_trefl (exists_ _) (tele_p _)
+
+let compute_gen_elim_tele_correct_exists_no_abs1
+  (ty: _)
+  (body: ty -> vprop)
+: Tot (ge_to_tele_t (GEExistsNoAbs1 #ty body))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (exists_ body);
   let x = elim_exists' () in
@@ -306,23 +388,23 @@ let compute_gen_elim_tele_correct_exists_no_abs
   intro_exists x (fun x -> body x `star` pure True);
   rewrite_with_trefl (exists_ _) (tele_p _)
 
-let compute_gen_elim_tele_correct_exists_unit
+let compute_gen_elim_tele_correct_exists_unit1
   (ty: _)
   (body: ty -> gen_unit_elim_i)
-: Tot (ge_to_tele_t (GEExistsUnit #ty body))
+: Tot (ge_to_tele_t (GEExistsUnit1 #ty body))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_unit_elim_p (body x)));
   let x = elim_exists' () in
-  compute_gen_unit_elim_f (body x) _;
+  let _ = compute_gen_unit_elim_f (body x) _ in
   intro_pure (compute_gen_unit_elim_post (body x));
   intro_exists x (fun x -> compute_gen_unit_elim_q (body x) `star` pure (compute_gen_unit_elim_post (body x)));
   rewrite_with_trefl (exists_ _) (tele_p _)
 
-let compute_gen_elim_tele_correct_exists
+let compute_gen_elim_tele_correct_exists1
   (ty: _)
   (body: ty -> gen_elim_i)
   (ih: (x: ty) -> GTot (ge_to_tele_t (body x)))
-: Tot (ge_to_tele_t (GEExists #ty body))
+: Tot (ge_to_tele_t (GEExists1 #ty body))
 = fun _ ->
   rewrite_with_trefl (compute_gen_elim_p _) (exists_ (fun x -> compute_gen_elim_p (body x)));
   let x = elim_exists' () in
@@ -338,25 +420,28 @@ let rec compute_gen_elim_tele_correct
   | GEStarL l ru -> compute_gen_elim_tele_correct_star_l l (compute_gen_elim_tele_correct l) ru
   | GEStarR lu r -> compute_gen_elim_tele_correct_star_r lu r (compute_gen_elim_tele_correct r)
   | GEStar l r -> compute_gen_elim_tele_correct_star l (compute_gen_elim_tele_correct l) r (compute_gen_elim_tele_correct r)
-  | GEExistsNoAbs #ty body -> compute_gen_elim_tele_correct_exists_no_abs ty body
-  | GEExistsUnit #ty body -> compute_gen_elim_tele_correct_exists_unit ty body
-  | GEExists #ty body -> compute_gen_elim_tele_correct_exists ty body (fun x -> compute_gen_elim_tele_correct (body x))
-
-let rec gen_elim_nondep_p (ty: list Type0) : Tot (curried_function_type ty vprop -> curried_function_type ty prop -> Tot vprop) =
-  match ty as ty' returns curried_function_type ty' vprop -> curried_function_type ty' prop -> Tot vprop with
-  | [] -> fun q post -> q `star` pure post
+  | GEExistsNoAbs0 #ty body -> compute_gen_elim_tele_correct_exists_no_abs0 ty body
+  | GEExistsUnit0 #ty body -> compute_gen_elim_tele_correct_exists_unit0 ty body
+  | GEExists0 #ty body -> compute_gen_elim_tele_correct_exists0 ty body (fun x -> compute_gen_elim_tele_correct (body x))
+  | GEExistsNoAbs1 #ty body -> compute_gen_elim_tele_correct_exists_no_abs1 ty body
+  | GEExistsUnit1 #ty body -> compute_gen_elim_tele_correct_exists_unit1 ty body
+  | GEExists1 #ty body -> compute_gen_elim_tele_correct_exists1 ty body (fun x -> compute_gen_elim_tele_correct (body x))
+
+let rec gen_elim_nondep_p (ty: list (Type u#a)) : Tot (curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop) =
+  match ty as ty' returns curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> vprop) -> curried_function_type ty' (U.raise_t u#_ u#(max 2 a) unit -> prop) -> Tot vprop with
+  | [] -> fun q post -> q (U.raise_val ()) `star` pure (post (U.raise_val ()))
   | t :: tq -> fun q post -> exists_ (fun x -> gen_elim_nondep_p tq (q x) (post x))
 
 let rec gen_elim_nondep_sem_correct
-  (ty: list Type0)
-: Tot ((q: curried_function_type ty vprop) -> (post: curried_function_type ty prop) -> Lemma
+  (ty: list (Type u#a))
+: Tot ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
     (tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
   )
-= match ty returns ((q: curried_function_type ty vprop) -> (post: curried_function_type ty prop) -> Lemma
+= match ty returns ((q: curried_function_type ty _) -> (post: curried_function_type ty _) -> Lemma
     (tele_p (gen_elim_nondep_sem ty q post) `equiv` gen_elim_nondep_p ty q post)
   )
   with
-  | [] -> fun q post -> equiv_refl (q `star` pure post)
+  | [] -> fun q post -> equiv_refl (q (U.raise_val ()) `star` pure (post (U.raise_val ())))
   | ta :: tq -> fun q post ->
     let phi
       (x: ta)
@@ -376,7 +461,7 @@ let rec gen_elim_nondep_sem_correct
 
 let compute_gen_elim_nondep_correct_t
   (i0: gen_elim_i)
-  (ty: list Type0)
+  (ty: list (Type u#1))
 : Tot Type
 = (q: _) ->
   (post: _) ->
@@ -384,8 +469,8 @@ let compute_gen_elim_nondep_correct_t
   GTot (gen_elim_f
     (compute_gen_elim_p i0)
     (compute_gen_elim_nondep_a' ty)
-    (compute_uncurry vprop (compute_gen_elim_p' i0) ty q)
-    (compute_uncurry prop True ty post)
+    (fun x -> compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) ty q x (U.raise_val ()))
+    (fun x -> compute_uncurry _ (fun _ -> True) ty post x (U.raise_val ()))
   )
 
 let compute_gen_elim_nondep_correct0
@@ -393,76 +478,76 @@ let compute_gen_elim_nondep_correct0
 : Tot (compute_gen_elim_nondep_correct_t i0 [])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (_ `star` pure post);
-    let res = () in
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (q (U.raise_val ()) `star` pure (post (U.raise_val ())));
+    let res = U.raise_val () in
     elim_pure _;
-    rewrite_with_trefl q (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct1
   (i0: gen_elim_i)
-  (t1: Type0)
+  (t1: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> q x1 `star` pure (post x1)));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> q x1 (U.raise_val ()) `star` pure (post x1 (U.raise_val ()))));
     let res = elim_exists' () in
     elim_pure _;
-    rewrite_with_trefl (q _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct2
   (i0: gen_elim_i)
-  (t1 t2: Type0)
+  (t1 t2: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> q x1 x2 `star` pure (post x1 x2))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> q x1 x2 (U.raise_val ()) `star` pure (post x1 x2 (U.raise_val ())))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let res = Mktuple2 x1 x2 in
     elim_pure _;
-    rewrite_with_trefl (q _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct3
   (i0: gen_elim_i)
-  (t1 t2 t3: Type0)
+  (t1 t2 t3: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> q x1 x2 x3 `star` pure (post x1 x2 x3)))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> q x1 x2 x3 (U.raise_val ()) `star` pure (post x1 x2 x3 (U.raise_val ()))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
     let res = Mktuple3 x1 x2 x3 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct4
   (i0: gen_elim_i)
-  (t1 t2 t3 t4: Type0)
+  (t1 t2 t3 t4: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> q x1 x2 x3 x4 `star` pure (post x1 x2 x3 x4))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> q x1 x2 x3 x4 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 (U.raise_val ())))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
     let x4 = elim_exists' () in
     let res = Mktuple4 x1 x2 x3 x4 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct5
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5: Type0)
+  (t1 t2 t3 t4 t5: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> q x1 x2 x3 x4 x5 `star` pure (post x1 x2 x3 x4 x5)))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> q x1 x2 x3 x4 x5 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 (U.raise_val ()))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -470,16 +555,16 @@ let compute_gen_elim_nondep_correct5
     let x5 = elim_exists' () in
     let res = Mktuple5 x1 x2 x3 x4 x5 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct6
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6: Type0)
+  (t1 t2 t3 t4 t5 t6: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> q x1 x2 x3 x4 x5 x6 `star` pure (post x1 x2 x3 x4 x5 x6))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> q x1 x2 x3 x4 x5 x6 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 (U.raise_val ())))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -488,16 +573,16 @@ let compute_gen_elim_nondep_correct6
     let x6 = elim_exists' () in
     let res = Mktuple6 x1 x2 x3 x4 x5 x6 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct7
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7: Type0)
+  (t1 t2 t3 t4 t5 t6 t7: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> q x1 x2 x3 x4 x5 x6 x7 `star` pure (post x1 x2 x3 x4 x5 x6 x7)))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> q x1 x2 x3 x4 x5 x6 x7 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 (U.raise_val ()))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -507,16 +592,16 @@ let compute_gen_elim_nondep_correct7
     let x7 = elim_exists' () in
     let res = Mktuple7 x1 x2 x3 x4 x5 x6 x7 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct8
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> q x1 x2 x3 x4 x5 x6 x7 x8 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> q x1 x2 x3 x4 x5 x6 x7 x8 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 (U.raise_val ())))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -527,16 +612,16 @@ let compute_gen_elim_nondep_correct8
     let x8 = elim_exists' () in
     let res = Mktuple8 x1 x2 x3 x4 x5 x6 x7 x8 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct9
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9)))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 (U.raise_val ()))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -548,16 +633,16 @@ let compute_gen_elim_nondep_correct9
     let x9 = elim_exists' () in
     let res = Mktuple9 x1 x2 x3 x4 x5 x6 x7 x8 x9 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct10
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 (U.raise_val ())))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -570,16 +655,16 @@ let compute_gen_elim_nondep_correct10
     let x10 = elim_exists' () in
     let res = Mktuple10 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct11
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11)))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 (U.raise_val ()))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -593,16 +678,16 @@ let compute_gen_elim_nondep_correct11
     let x11 = elim_exists' () in
     let res = Mktuple11 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct12
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12))))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 (U.raise_val ())))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -617,16 +702,16 @@ let compute_gen_elim_nondep_correct12
     let x12 = elim_exists' () in
     let res = Mktuple12 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct13
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13)))))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 (U.raise_val ()))))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -642,16 +727,16 @@ let compute_gen_elim_nondep_correct13
     let x13 = elim_exists' () in
     let res = Mktuple13 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct14
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14: Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14: Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 [t1; t2; t3; t4; t5; t6; t7; t8; t9; t10; t11; t12; t13; t14])
 = fun q post intro _ ->
     intro _;
-    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> exists_ (fun x14 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14))))))))))))))));
+    rewrite_with_trefl (gen_elim_nondep_p _ _ _) (exists_ (fun x1 -> exists_ (fun x2 -> exists_ (fun x3 -> exists_ (fun x4 -> exists_ (fun x5 -> exists_ (fun x6 -> exists_ (fun x7 -> exists_ (fun x8 -> exists_ (fun x9 -> exists_ (fun x10 -> exists_ (fun x11 -> exists_ (fun x12 -> exists_ (fun x13 -> exists_ (fun x14 -> q x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 (U.raise_val ()) `star` pure (post x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 (U.raise_val ())))))))))))))))));
     let x1 = elim_exists' () in
     let x2 = elim_exists' () in
     let x3 = elim_exists' () in
@@ -668,22 +753,22 @@ let compute_gen_elim_nondep_correct14
     let x14 = elim_exists' () in
     let res = Mktuple14 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 in
     elim_pure _;
-    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _ _) (compute_uncurry vprop _ _ _ res);
+    rewrite_with_trefl (q _ _ _ _ _ _ _ _ _ _ _ _ _ _ (U.raise_val ())) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct_default
   (i0: gen_elim_i)
-  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15: Type0) (tq: list Type0)
+  (t1 t2 t3 t4 t5 t6 t7 t8 t9 t10 t11 t12 t13 t14 t15: Type) (tq: list Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 (t1 :: t2 :: t3 :: t4 :: t5 :: t6 :: t7 :: t8 :: t9 :: t10 :: t11 :: t12 :: t13 :: t14 :: t15 :: tq))
 = fun q post intro _ ->
     // default case: no exists is opened
-    let res : compute_gen_elim_nondep_a' (t1 :: t2 :: t3 :: t4 :: t5 :: t6 :: t7 :: t8 :: t9 :: t10 :: t11 :: t12 :: t13 :: t14 :: t15 :: tq) = coerce_with_trefl () in
-    rewrite_with_trefl (compute_gen_elim_p i0) (compute_uncurry vprop _ _ _ res);
+    let res : compute_gen_elim_nondep_a' (t1 :: t2 :: t3 :: t4 :: t5 :: t6 :: t7 :: t8 :: t9 :: t10 :: t11 :: t12 :: t13 :: t14 :: t15 :: tq) = (U.raise_val ()) in
+    rewrite_with_trefl (compute_gen_elim_p i0) (compute_uncurry _ (fun _ -> compute_gen_elim_p' i0) _ _ res (U.raise_val ()));
     res
 
 let compute_gen_elim_nondep_correct'
   (i0: gen_elim_i)
-  (ty: list Type0)
+  (ty: list Type)
 : Tot (compute_gen_elim_nondep_correct_t i0 ty)
 = match ty returns compute_gen_elim_nondep_correct_t i0 ty with
   | [] -> compute_gen_elim_nondep_correct0 i0
diff --git a/ulib/experimental/Steel.ST.GenElim.fsti b/ulib/experimental/Steel.ST.GenElim.fsti
index ac620e765ab..7a94b5aeca4 100644
--- a/ulib/experimental/Steel.ST.GenElim.fsti
+++ b/ulib/experimental/Steel.ST.GenElim.fsti
@@ -7,7 +7,7 @@ val gen_elim'
   (#opened: _)
   (enable_nondep_opt: bool)
   (p: vprop)
-  (a: Type0)
+  (a: Type)
   (q: Ghost.erased a -> Tot vprop)
   (post: Ghost.erased a -> Tot prop)
   (sq: squash (gen_elim_prop_placeholder enable_nondep_opt p a q post))
@@ -17,7 +17,7 @@ val gen_elim'
 val gen_elim
   (#opened: _)
   (#[@@@ framing_implicit] p: vprop)
-  (#[@@@ framing_implicit] a: Type0)
+  (#[@@@ framing_implicit] a: Type)
   (#[@@@ framing_implicit] q: Ghost.erased a -> Tot vprop)
   (#[@@@ framing_implicit] post: Ghost.erased a -> Tot prop)
   (#[@@@ framing_implicit] sq: squash (gen_elim_prop_placeholder true p a q post))
@@ -27,7 +27,7 @@ val gen_elim
 val gen_elim_dep
   (#opened: _)
   (#[@@@ framing_implicit] p: vprop)
-  (#[@@@ framing_implicit] a: Type0)
+  (#[@@@ framing_implicit] a: Type)
   (#[@@@ framing_implicit] q: Ghost.erased a -> Tot vprop)
   (#[@@@ framing_implicit] post: Ghost.erased a -> Tot prop)
   (#[@@@ framing_implicit] sq: squash (gen_elim_prop_placeholder false p a q post))

From 32d012938d2220869035c1b41bfb7527edc153e7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Feb 2023 17:26:57 -0800
Subject: [PATCH 388/513] snap

---
 .../generated/Steel_ST_GenElim_Base.ml        | 1484 ++++++++++-------
 1 file changed, 905 insertions(+), 579 deletions(-)

diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index ad134920e48..f50533bf38f 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (5))
-                          (Prims.of_int (310)) (Prims.of_int (28)))
+                          (Prims.of_int (342)) (Prims.of_int (5))
+                          (Prims.of_int (342)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (2))
-                          (Prims.of_int (320)) (Prims.of_int (12)))
+                          (Prims.of_int (342)) (Prims.of_int (2))
+                          (Prims.of_int (352)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (320))
+                                          (Prims.of_int (352))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (318))
+                                                                 (Prims.of_int (350))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (23))
-                         (Prims.of_int (329)) (Prims.of_int (40)))
+                         (Prims.of_int (361)) (Prims.of_int (23))
+                         (Prims.of_int (361)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (8))
-                         (Prims.of_int (340)) (Prims.of_int (47)))
+                         (Prims.of_int (361)) (Prims.of_int (8))
+                         (Prims.of_int (372)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (340))
+                                             (Prims.of_int (372))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -243,15 +243,15 @@ let rec (solve_gen_unit_elim :
                                                             FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (335))
+                                                                 (Prims.of_int (367))
                                                                  (Prims.of_int (20))
-                                                                 (Prims.of_int (335))
+                                                                 (Prims.of_int (367))
                                                                  (Prims.of_int (42)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (336))
+                                                                 (Prims.of_int (368))
                                                                  (Prims.of_int (10))
-                                                                 (Prims.of_int (337))
+                                                                 (Prims.of_int (369))
                                                                  (Prims.of_int (68)))
                                                               (Obj.magic
                                                                  (solve_gen_unit_elim
@@ -262,15 +262,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -321,10 +321,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -342,22 +342,53 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
+let rec (get_universe :
+  FStar_Reflection_Types.universe ->
+    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
+  =
+  fun uu___ ->
+    (fun u ->
+       match FStar_Reflection_Builtins.inspect_universe u with
+       | FStar_Reflection_Data.Uv_Zero ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.lift_div_tac
+                   (fun uu___ -> Prims.int_zero)))
+       | FStar_Reflection_Data.Uv_Succ u1 ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.tac_bind
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (23))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (19))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Obj.magic (get_universe u1))
+                   (fun uu___ ->
+                      FStar_Tactics_Effect.lift_div_tac
+                        (fun uu___1 -> Prims.int_one + uu___))))
+       | uu___ ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Derived.fail
+                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -374,11 +405,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (355)) (Prims.of_int (17))
-                      (Prims.of_int (355)) (Prims.of_int (40)))
+                      (Prims.of_int (395)) (Prims.of_int (17))
+                      (Prims.of_int (395)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (356)) (Prims.of_int (8))
-                      (Prims.of_int (356)) (Prims.of_int (45)))
+                      (Prims.of_int (396)) (Prims.of_int (8))
+                      (Prims.of_int (396)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -397,11 +428,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (26))
-                      (Prims.of_int (358)) (Prims.of_int (43)))
+                      (Prims.of_int (398)) (Prims.of_int (26))
+                      (Prims.of_int (398)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (8))
-                      (Prims.of_int (399)) (Prims.of_int (68)))
+                      (Prims.of_int (398)) (Prims.of_int (8))
+                      (Prims.of_int (458)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -414,94 +445,126 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (362))
-                                       (Prims.of_int (12))
-                                       (Prims.of_int (365))
-                                       (Prims.of_int (46)))
+                                       (Prims.of_int (401))
+                                       (Prims.of_int (25))
+                                       (Prims.of_int (403))
+                                       (Prims.of_int (63)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (361))
+                                       (Prims.of_int (405))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (378))
+                                       (Prims.of_int (437))
                                        (Prims.of_int (13)))
-                                    (match lbody with
-                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
-                                         (body,
-                                          FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Effect.lift_div_tac
-                                                 (fun uu___3 ->
-                                                    ([(ty,
-                                                        FStar_Reflection_Data.Q_Implicit)],
-                                                      body))))
-                                     | (body,
-                                        FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Effect.lift_div_tac
-                                                 (fun uu___3 -> ([], body))))
+                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
+                                             hd
+                                     with
+                                     | FStar_Reflection_Data.Tv_UInst
+                                         (uu___3, u::uu___4) ->
+                                         Obj.magic (get_universe u)
                                      | uu___3 ->
                                          Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Derived.fail
-                                                 "ill-formed exists_")))
+                                           (FStar_Tactics_Derived.fail
+                                              "ill-formed exists_: no universe found"))
                                     (fun uu___3 ->
-                                       (fun uu___3 ->
-                                          match uu___3 with
-                                          | (ty, body) ->
-                                              Obj.magic
-                                                (FStar_Tactics_Effect.tac_bind
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (22))
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (36)))
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (16))
-                                                      (Prims.of_int (377))
-                                                      (Prims.of_int (45)))
-                                                   (Obj.magic
-                                                      (FStar_Tactics_Builtins.inspect
-                                                         body))
-                                                   (fun uu___4 ->
-                                                      (fun uu___4 ->
-                                                         match uu___4 with
-                                                         | FStar_Reflection_Data.Tv_Abs
-                                                             (b, abody) ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.tac_bind
+                                       (fun universe ->
+                                          Obj.magic
+                                            (FStar_Tactics_Effect.tac_bind
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (406))
+                                                  (Prims.of_int (12))
+                                                  (Prims.of_int (409))
+                                                  (Prims.of_int (46)))
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (405))
+                                                  (Prims.of_int (10))
+                                                  (Prims.of_int (437))
+                                                  (Prims.of_int (13)))
+                                               (match lbody with
+                                                | (ty,
+                                                   FStar_Reflection_Data.Q_Implicit)::
+                                                    (body,
+                                                     FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    Obj.magic
+                                                      (Obj.repr
+                                                         (FStar_Tactics_Effect.lift_div_tac
+                                                            (fun uu___3 ->
+                                                               ([(ty,
+                                                                   FStar_Reflection_Data.Q_Implicit)],
+                                                                 body))))
+                                                | (body,
+                                                   FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    Obj.magic
+                                                      (Obj.repr
+                                                         (FStar_Tactics_Effect.lift_div_tac
+                                                            (fun uu___3 ->
+                                                               ([], body))))
+                                                | uu___3 ->
+                                                    Obj.magic
+                                                      (Obj.repr
+                                                         (FStar_Tactics_Derived.fail
+                                                            "ill-formed exists_")))
+                                               (fun uu___3 ->
+                                                  (fun uu___3 ->
+                                                     match uu___3 with
+                                                     | (ty, body) ->
+                                                         Obj.magic
+                                                           (FStar_Tactics_Effect.tac_bind
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (22))
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (36)))
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (16))
+                                                                 (Prims.of_int (436))
+                                                                 (Prims.of_int (21)))
+                                                              (Obj.magic
+                                                                 (FStar_Tactics_Builtins.inspect
+                                                                    body))
+                                                              (fun uu___4 ->
+                                                                 (fun uu___4
+                                                                    ->
+                                                                    match uu___4
+                                                                    with
+                                                                    | 
+                                                                    FStar_Reflection_Data.Tv_Abs
+                                                                    (b,
+                                                                    abody) ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -530,16 +593,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -551,58 +614,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (82)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -632,14 +695,32 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___8
+                                                                    when
+                                                                    uu___8 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit"])))
+                                                                    "GEExistsUnit0"]))
+                                                                    | 
+                                                                    uu___8 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsUnit1"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -647,16 +728,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -668,58 +749,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (78)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -749,48 +830,86 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___9
+                                                                    when
+                                                                    uu___9 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists"])))
+                                                                    "GEExists0"]))
+                                                                    | 
+                                                                    uu___9 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExists1"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                         | uu___5 ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.lift_div_tac
+                                                                    | 
+                                                                    uu___5 ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___7
+                                                                    when
+                                                                    uu___7 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsNoAbs0"]))
+                                                                    | 
+                                                                    uu___7 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs"])))
+                                                                    "GEExistsNoAbs1"])))
                                                                     lbody))))
-                                                        uu___4))) uu___3))
+                                                                   uu___4)))
+                                                    uu___3))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (399))
+                                       (Prims.of_int (458))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -808,15 +927,15 @@ let rec (solve_gen_elim :
                                                       FStar_Tactics_Effect.tac_bind
                                                         (Prims.mk_range
                                                            "Steel.ST.GenElim.Base.fsti"
-                                                           (Prims.of_int (383))
+                                                           (Prims.of_int (442))
                                                            (Prims.of_int (15))
-                                                           (Prims.of_int (383))
+                                                           (Prims.of_int (442))
                                                            (Prims.of_int (42)))
                                                         (Prims.mk_range
                                                            "Steel.ST.GenElim.Base.fsti"
-                                                           (Prims.of_int (383))
+                                                           (Prims.of_int (442))
                                                            (Prims.of_int (12))
-                                                           (Prims.of_int (396))
+                                                           (Prims.of_int (455))
                                                            (Prims.of_int (72)))
                                                         (Obj.magic
                                                            (term_has_head tl
@@ -836,15 +955,15 @@ let rec (solve_gen_elim :
                                                                   (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -857,15 +976,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -887,15 +1006,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -924,15 +1043,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -963,15 +1082,15 @@ let rec (solve_gen_elim :
                                                                   (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -984,15 +1103,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1075,11 +1194,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (19))
-                            (Prims.of_int (488)) (Prims.of_int (34)))
+                            (Prims.of_int (547)) (Prims.of_int (19))
+                            (Prims.of_int (547)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (4))
-                            (Prims.of_int (532)) (Prims.of_int (13)))
+                            (Prims.of_int (547)) (Prims.of_int (4))
+                            (Prims.of_int (592)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1099,15 +1218,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (493))
+                                                     (Prims.of_int (552))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (495))
-                                                     (Prims.of_int (85)))
+                                                     (Prims.of_int (554))
+                                                     (Prims.of_int (88)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (497))
+                                                     (Prims.of_int (556))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (522))
+                                                     (Prims.of_int (582))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1117,16 +1236,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (495))
-                                                                   (Prims.of_int (85)))
+                                                                   (Prims.of_int (554))
+                                                                   (Prims.of_int (88)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1145,16 +1264,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (554))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (495))
-                                                                    (Prims.of_int (85)))
+                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (88)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1172,7 +1291,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1185,15 +1306,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (556))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (497))
-                                                                (Prims.of_int (79)))
+                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (84)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (498))
+                                                                (Prims.of_int (557))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (522))
+                                                                (Prims.of_int (582))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1218,7 +1339,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1229,15 +1352,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (499))
+                                                                    (Prims.of_int (558))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1254,15 +1377,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (501))
+                                                                    (Prims.of_int (560))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (505))
+                                                                    (Prims.of_int (564))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (507))
+                                                                    (Prims.of_int (566))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1275,16 +1398,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1296,16 +1419,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (563))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1327,7 +1450,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1362,23 +1487,69 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (39))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (81)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (8))
+                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (9)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.fresh_binder
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))))
+                                                                    (fun
+                                                                    uu___3 ->
+                                                                    (fun
+                                                                    dummy_raised_unit_binder
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (510))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (120)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.append
+                                                                    (FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders)))
+                                                                    rev_types_and_binders))
+                                                                    [dummy_raised_unit_binder]))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1388,15 +1559,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1416,15 +1587,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1437,37 +1608,88 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (513))
-                                                                    (Prims.of_int (113)))
+                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (151)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    = "_";
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (964));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    })
+                                                                    FStar_Reflection_Data.Q_Explicit
+                                                                    []),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"]))),
+                                                                    "vprop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1477,15 +1699,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1498,35 +1720,86 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (515))
-                                                                    (Prims.of_int (112)))
+                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (150)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (516))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    = "_";
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (967));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    })
+                                                                    FStar_Reflection_Data.Q_Explicit
+                                                                    []),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"]))),
+                                                                    "prop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1541,6 +1814,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
+                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1567,15 +1841,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (529))
+                                                         (Prims.of_int (589))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1636,11 +1910,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (539)) (Prims.of_int (17))
-                                 (Prims.of_int (539)) (Prims.of_int (64)))
+                                 (Prims.of_int (599)) (Prims.of_int (17))
+                                 (Prims.of_int (599)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (540)) (Prims.of_int (6))
-                                 (Prims.of_int (541)) (Prims.of_int (37)))
+                                 (Prims.of_int (600)) (Prims.of_int (6))
+                                 (Prims.of_int (601)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1659,15 +1933,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1701,10 +1975,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1719,13 +1993,17 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_FVar
-                            (FStar_Reflection_Builtins.pack_fv
-                               ["Steel";
-                               "ST";
-                               "GenElim";
-                               "Base";
-                               "mk_gen_elim_nondep_by_tac"])))
+                         (FStar_Reflection_Data.Tv_UInst
+                            ((FStar_Reflection_Builtins.pack_fv
+                                ["Steel";
+                                "ST";
+                                "GenElim";
+                                "Base";
+                                "mk_gen_elim_nondep_by_tac"]),
+                              [FStar_Reflection_Builtins.pack_universe
+                                 (FStar_Reflection_Data.Uv_Succ
+                                    (FStar_Reflection_Builtins.pack_universe
+                                       FStar_Reflection_Data.Uv_Zero))])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
@@ -1735,16 +2013,16 @@ let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+         (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+         (Prims.of_int (2)) (Prims.of_int (664)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+               (Prims.of_int (31)) (Prims.of_int (626)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+               (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -1756,27 +2034,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (567)) (Prims.of_int (2))
-                        (Prims.of_int (568)) (Prims.of_int (33)))
+                        (Prims.of_int (627)) (Prims.of_int (2))
+                        (Prims.of_int (628)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (569)) (Prims.of_int (2))
-                        (Prims.of_int (604)) (Prims.of_int (35)))
+                        (Prims.of_int (629)) (Prims.of_int (2))
+                        (Prims.of_int (664)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (5))
-                              (Prims.of_int (567)) (Prims.of_int (23)))
+                              (Prims.of_int (627)) (Prims.of_int (5))
+                              (Prims.of_int (627)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (2))
-                              (Prims.of_int (568)) (Prims.of_int (33)))
+                              (Prims.of_int (627)) (Prims.of_int (2))
+                              (Prims.of_int (628)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (9))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (627)) (Prims.of_int (9))
+                                    (Prims.of_int (627)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (5))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (627)) (Prims.of_int (5))
+                                    (Prims.of_int (627)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -1802,15 +2080,15 @@ let (solve_gen_elim_prop :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (571))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (571))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (571))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (603))
+                                       (Prims.of_int (663))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -1824,15 +2102,15 @@ let (solve_gen_elim_prop :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (572))
+                                                      (Prims.of_int (632))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (573))
+                                                      (Prims.of_int (633))
                                                       (Prims.of_int (42)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (574))
+                                                      (Prims.of_int (634))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (602))
+                                                      (Prims.of_int (662))
                                                       (Prims.of_int (44)))
                                                    (if
                                                       Prims.op_Negation
@@ -1873,15 +2151,15 @@ let (solve_gen_elim_prop :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (74)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -1899,15 +2177,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1921,15 +2199,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1953,29 +2231,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2026,15 +2304,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (586))
+                                                                    (Prims.of_int (646))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (593))
+                                                                    (Prims.of_int (653))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2070,15 +2348,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2088,15 +2366,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2124,15 +2402,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2159,15 +2437,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2177,15 +2455,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2209,15 +2487,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2227,15 +2505,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2249,15 +2527,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (45)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (47))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.trivial
@@ -2283,15 +2561,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2301,15 +2579,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2333,15 +2611,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2351,15 +2629,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2387,15 +2665,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2430,16 +2708,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+         (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+         (Prims.of_int (2)) (Prims.of_int (706)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+               (Prims.of_int (31)) (Prims.of_int (670)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+               (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2451,27 +2729,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (611)) (Prims.of_int (2))
-                        (Prims.of_int (612)) (Prims.of_int (33)))
+                        (Prims.of_int (671)) (Prims.of_int (2))
+                        (Prims.of_int (672)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (613)) (Prims.of_int (2))
-                        (Prims.of_int (644)) (Prims.of_int (35)))
+                        (Prims.of_int (673)) (Prims.of_int (2))
+                        (Prims.of_int (706)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (5))
-                              (Prims.of_int (611)) (Prims.of_int (23)))
+                              (Prims.of_int (671)) (Prims.of_int (5))
+                              (Prims.of_int (671)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (2))
-                              (Prims.of_int (612)) (Prims.of_int (33)))
+                              (Prims.of_int (671)) (Prims.of_int (2))
+                              (Prims.of_int (672)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (9))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (671)) (Prims.of_int (9))
+                                    (Prims.of_int (671)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (5))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (671)) (Prims.of_int (5))
+                                    (Prims.of_int (671)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2497,15 +2775,15 @@ let (solve_gen_elim_prop_placeholder :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (615))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (615))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (615))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (643))
+                                       (Prims.of_int (705))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2519,15 +2797,15 @@ let (solve_gen_elim_prop_placeholder :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (616))
+                                                      (Prims.of_int (676))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (617))
+                                                      (Prims.of_int (677))
                                                       (Prims.of_int (54)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (618))
+                                                      (Prims.of_int (678))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (642))
+                                                      (Prims.of_int (704))
                                                       (Prims.of_int (56)))
                                                    (if
                                                       Prims.op_Negation
@@ -2568,43 +2846,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (681))
                                                                     (Prims.of_int (47)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (681))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2650,29 +2928,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2696,29 +2974,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2742,29 +3020,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (685))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2788,15 +3066,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (685))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (626))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -2827,15 +3105,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2853,15 +3131,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2875,15 +3153,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -2898,15 +3176,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2928,19 +3206,21 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (631))
-                                                                    (Prims.of_int (101)))
+                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    (FStar_Reflection_Derived.mk_app
+                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -2953,7 +3233,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)])))
+                                                                    FStar_Reflection_Data.Q_Explicit)]))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -2963,15 +3243,59 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (37)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Builtins.term_to_string
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun
+                                                                    a'_ts ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (27)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun a'1
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (15))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -2998,15 +3322,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3033,15 +3357,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3056,19 +3380,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'))
+                                                                    a'1))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3079,15 +3403,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3102,15 +3426,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3125,15 +3449,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3148,15 +3472,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3171,15 +3495,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3211,6 +3535,8 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
+                                                                    uu___12)))
+                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From 017599cddd8ba4243e09202bd4e0b9983d36b8bd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Feb 2023 23:35:35 -0800
Subject: [PATCH 389/513] Revert "snap"

This reverts commit b3bd8aea1cf5be1704399e9daed6fac9d8a68603.
---
 src/ocaml-output/FStar_Extraction_Krml.ml | 962 +---------------------
 1 file changed, 15 insertions(+), 947 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index fddc1f9ef61..c4f540b06c3 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -706,102 +691,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -958,8 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -969,9 +857,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -989,63 +876,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Reference.ptr" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1058,8 +888,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1096,21 +925,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1170,14 +996,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1190,36 +1015,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1883,66 +1691,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2036,48 +1784,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2803,505 +2514,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___8;
-                             FStar_Extraction_ML_Syntax.loc = uu___9;_}::r::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___10 =
-            let uu___11 =
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___14 in
-                TQualified uu___13 in
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = translate_expr env1 r in
-                  (uu___15, (EConstant (UInt32, "0"))) in
-                EBufRead uu___14 in
-              (uu___12, uu___13, field_name) in
-            EField uu___11 in
-          EAddrOf uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::new_value::r::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___8 =
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    let uu___13 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___13 in
-                  TQualified uu___12 in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = translate_expr env1 r in
-                    (uu___14, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___13 in
-                (uu___11, uu___12, field_name) in
-              EField uu___10 in
-            let uu___10 = translate_expr env1 new_value in (uu___9, uu___10) in
-          EAssign uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 r in
-            (uu___6, (EConstant (UInt32, "0"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::x::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = translate_expr env1 r in
-                (uu___8, (EConstant (UInt32, "0"))) in
-              EBufRead uu___7 in
-            let uu___7 = translate_expr env1 x in (uu___6, uu___7) in
-          EAssign uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 r in
-            (uu___9, (EConstant (UInt32, "0"))) in
-          EBufRead uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.index_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in (uu___7, uu___8) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           r::uu___5::i::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.upd_from" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            let uu___8 = translate_expr env1 i in
-            let uu___9 = translate_expr env1 x in (uu___7, uu___8, uu___9) in
-          EBufWrite uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::a::i::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = translate_expr env1 a in
-              let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-            EBufRead uu___7 in
-          EAddrOf uu___6
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3715,72 +2927,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3793,85 +2939,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 2cde4e83f375326472b3fcdc3c84d28d35fcb29a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 23 Feb 2023 23:46:22 -0800
Subject: [PATCH 390/513] ocamlbuild snap

---
 src/ocaml-output/FStar_Extraction_Krml.ml | 962 +++++++++++++++++++++-
 1 file changed, 947 insertions(+), 15 deletions(-)

diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
index c4f540b06c3..9ba78c814d9 100644
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ b/src/ocaml-output/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1058,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1096,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1170,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1190,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1883,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2036,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2803,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3715,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3793,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From d4cbe6503b1e0c28198708fd7ec22dc3acfa4ed8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 24 Feb 2023 00:18:38 -0800
Subject: [PATCH 391/513] dune snap

---
 .../generated/FStar_Extraction_Krml.ml        |  962 ++++++++++-
 ocaml/fstar-lib/generated/FStar_FSet.ml       |   38 +
 ocaml/fstar-lib/generated/FStar_PCM.ml        |    1 +
 .../generated/Steel_ST_GenElim_Base.ml        | 1484 ++++++++++-------
 4 files changed, 1891 insertions(+), 594 deletions(-)
 create mode 100644 ocaml/fstar-lib/generated/FStar_FSet.ml

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index c4f540b06c3..9ba78c814d9 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1058,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1096,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1170,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1190,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1883,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2036,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2803,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3715,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3793,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
diff --git a/ocaml/fstar-lib/generated/FStar_FSet.ml b/ocaml/fstar-lib/generated/FStar_FSet.ml
new file mode 100644
index 00000000000..95583a6ea9e
--- /dev/null
+++ b/ocaml/fstar-lib/generated/FStar_FSet.ml
@@ -0,0 +1,38 @@
+open Prims
+type ('a, 'f, 'xs) has_elements = unit
+type 'a set = ('a, Prims.bool) FStar_FunctionalExtensionality.restricted_t
+let intro_set :
+  'a .
+    ('a, Prims.bool) FStar_FunctionalExtensionality.restricted_t ->
+      unit -> 'a set
+  = fun f -> fun xs -> f
+let emptyset : 'a . unit -> 'a set =
+  fun uu___ ->
+    intro_set
+      (FStar_FunctionalExtensionality.on_domain (fun uu___1 -> false)) ()
+let insert : 'a . 'a -> 'a set -> 'a set =
+  fun x ->
+    fun s ->
+      intro_set
+        (FStar_FunctionalExtensionality.on_domain
+           (fun x' -> (x = x') || (s x'))) ()
+let set_remove :
+  'a .
+    'a ->
+      ('a, Prims.bool) FStar_FunctionalExtensionality.restricted_t ->
+        ('a, Prims.bool) FStar_FunctionalExtensionality.restricted_t
+  =
+  fun x ->
+    fun s ->
+      FStar_FunctionalExtensionality.on_domain
+        (fun x' -> (Prims.op_Negation (x = x')) && (s x'))
+let rec list_remove : 'a . 'a -> 'a Prims.list -> 'a Prims.list =
+  fun x ->
+    fun xs ->
+      match xs with
+      | [] -> []
+      | x'::xs1 ->
+          if x = x' then list_remove x xs1 else x' :: (list_remove x xs1)
+let remove : 'a . 'a -> 'a set -> 'a set =
+  fun x -> fun s -> intro_set (set_remove x s) ()
+type ('a, 's, 'x) notin = unit
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_PCM.ml b/ocaml/fstar-lib/generated/FStar_PCM.ml
index 737e6694a0c..01b99979ba0 100644
--- a/ocaml/fstar-lib/generated/FStar_PCM.ml
+++ b/ocaml/fstar-lib/generated/FStar_PCM.ml
@@ -28,6 +28,7 @@ let __proj__Mkpcm__item__p : 'a . 'a pcm -> 'a pcm' =
 
 
 type ('a, 'p, 'x, 'y) composable = Obj.t
+let one : 'a . 'a pcm -> 'a = fun p -> (p.p).one
 let op : 'a . 'a pcm -> 'a -> 'a -> 'a =
   fun p -> fun x -> fun y -> (p.p).op x y
 type ('a, 'pcm1, 'x, 'y) compatible = unit
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index ad134920e48..f50533bf38f 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (5))
-                          (Prims.of_int (310)) (Prims.of_int (28)))
+                          (Prims.of_int (342)) (Prims.of_int (5))
+                          (Prims.of_int (342)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (2))
-                          (Prims.of_int (320)) (Prims.of_int (12)))
+                          (Prims.of_int (342)) (Prims.of_int (2))
+                          (Prims.of_int (352)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (320))
+                                          (Prims.of_int (352))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (318))
+                                                                 (Prims.of_int (350))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (23))
-                         (Prims.of_int (329)) (Prims.of_int (40)))
+                         (Prims.of_int (361)) (Prims.of_int (23))
+                         (Prims.of_int (361)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (8))
-                         (Prims.of_int (340)) (Prims.of_int (47)))
+                         (Prims.of_int (361)) (Prims.of_int (8))
+                         (Prims.of_int (372)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (340))
+                                             (Prims.of_int (372))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -243,15 +243,15 @@ let rec (solve_gen_unit_elim :
                                                             FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (335))
+                                                                 (Prims.of_int (367))
                                                                  (Prims.of_int (20))
-                                                                 (Prims.of_int (335))
+                                                                 (Prims.of_int (367))
                                                                  (Prims.of_int (42)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (336))
+                                                                 (Prims.of_int (368))
                                                                  (Prims.of_int (10))
-                                                                 (Prims.of_int (337))
+                                                                 (Prims.of_int (369))
                                                                  (Prims.of_int (68)))
                                                               (Obj.magic
                                                                  (solve_gen_unit_elim
@@ -262,15 +262,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -321,10 +321,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -342,22 +342,53 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
+let rec (get_universe :
+  FStar_Reflection_Types.universe ->
+    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
+  =
+  fun uu___ ->
+    (fun u ->
+       match FStar_Reflection_Builtins.inspect_universe u with
+       | FStar_Reflection_Data.Uv_Zero ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.lift_div_tac
+                   (fun uu___ -> Prims.int_zero)))
+       | FStar_Reflection_Data.Uv_Succ u1 ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.tac_bind
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (23))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (19))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Obj.magic (get_universe u1))
+                   (fun uu___ ->
+                      FStar_Tactics_Effect.lift_div_tac
+                        (fun uu___1 -> Prims.int_one + uu___))))
+       | uu___ ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Derived.fail
+                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -374,11 +405,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (355)) (Prims.of_int (17))
-                      (Prims.of_int (355)) (Prims.of_int (40)))
+                      (Prims.of_int (395)) (Prims.of_int (17))
+                      (Prims.of_int (395)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (356)) (Prims.of_int (8))
-                      (Prims.of_int (356)) (Prims.of_int (45)))
+                      (Prims.of_int (396)) (Prims.of_int (8))
+                      (Prims.of_int (396)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -397,11 +428,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (26))
-                      (Prims.of_int (358)) (Prims.of_int (43)))
+                      (Prims.of_int (398)) (Prims.of_int (26))
+                      (Prims.of_int (398)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (8))
-                      (Prims.of_int (399)) (Prims.of_int (68)))
+                      (Prims.of_int (398)) (Prims.of_int (8))
+                      (Prims.of_int (458)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -414,94 +445,126 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (362))
-                                       (Prims.of_int (12))
-                                       (Prims.of_int (365))
-                                       (Prims.of_int (46)))
+                                       (Prims.of_int (401))
+                                       (Prims.of_int (25))
+                                       (Prims.of_int (403))
+                                       (Prims.of_int (63)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (361))
+                                       (Prims.of_int (405))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (378))
+                                       (Prims.of_int (437))
                                        (Prims.of_int (13)))
-                                    (match lbody with
-                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
-                                         (body,
-                                          FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Effect.lift_div_tac
-                                                 (fun uu___3 ->
-                                                    ([(ty,
-                                                        FStar_Reflection_Data.Q_Implicit)],
-                                                      body))))
-                                     | (body,
-                                        FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Effect.lift_div_tac
-                                                 (fun uu___3 -> ([], body))))
+                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
+                                             hd
+                                     with
+                                     | FStar_Reflection_Data.Tv_UInst
+                                         (uu___3, u::uu___4) ->
+                                         Obj.magic (get_universe u)
                                      | uu___3 ->
                                          Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Derived.fail
-                                                 "ill-formed exists_")))
+                                           (FStar_Tactics_Derived.fail
+                                              "ill-formed exists_: no universe found"))
                                     (fun uu___3 ->
-                                       (fun uu___3 ->
-                                          match uu___3 with
-                                          | (ty, body) ->
-                                              Obj.magic
-                                                (FStar_Tactics_Effect.tac_bind
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (22))
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (36)))
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (16))
-                                                      (Prims.of_int (377))
-                                                      (Prims.of_int (45)))
-                                                   (Obj.magic
-                                                      (FStar_Tactics_Builtins.inspect
-                                                         body))
-                                                   (fun uu___4 ->
-                                                      (fun uu___4 ->
-                                                         match uu___4 with
-                                                         | FStar_Reflection_Data.Tv_Abs
-                                                             (b, abody) ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.tac_bind
+                                       (fun universe ->
+                                          Obj.magic
+                                            (FStar_Tactics_Effect.tac_bind
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (406))
+                                                  (Prims.of_int (12))
+                                                  (Prims.of_int (409))
+                                                  (Prims.of_int (46)))
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (405))
+                                                  (Prims.of_int (10))
+                                                  (Prims.of_int (437))
+                                                  (Prims.of_int (13)))
+                                               (match lbody with
+                                                | (ty,
+                                                   FStar_Reflection_Data.Q_Implicit)::
+                                                    (body,
+                                                     FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    Obj.magic
+                                                      (Obj.repr
+                                                         (FStar_Tactics_Effect.lift_div_tac
+                                                            (fun uu___3 ->
+                                                               ([(ty,
+                                                                   FStar_Reflection_Data.Q_Implicit)],
+                                                                 body))))
+                                                | (body,
+                                                   FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    Obj.magic
+                                                      (Obj.repr
+                                                         (FStar_Tactics_Effect.lift_div_tac
+                                                            (fun uu___3 ->
+                                                               ([], body))))
+                                                | uu___3 ->
+                                                    Obj.magic
+                                                      (Obj.repr
+                                                         (FStar_Tactics_Derived.fail
+                                                            "ill-formed exists_")))
+                                               (fun uu___3 ->
+                                                  (fun uu___3 ->
+                                                     match uu___3 with
+                                                     | (ty, body) ->
+                                                         Obj.magic
+                                                           (FStar_Tactics_Effect.tac_bind
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (22))
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (36)))
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (16))
+                                                                 (Prims.of_int (436))
+                                                                 (Prims.of_int (21)))
+                                                              (Obj.magic
+                                                                 (FStar_Tactics_Builtins.inspect
+                                                                    body))
+                                                              (fun uu___4 ->
+                                                                 (fun uu___4
+                                                                    ->
+                                                                    match uu___4
+                                                                    with
+                                                                    | 
+                                                                    FStar_Reflection_Data.Tv_Abs
+                                                                    (b,
+                                                                    abody) ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -530,16 +593,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -551,58 +614,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (82)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -632,14 +695,32 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___8
+                                                                    when
+                                                                    uu___8 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit"])))
+                                                                    "GEExistsUnit0"]))
+                                                                    | 
+                                                                    uu___8 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsUnit1"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -647,16 +728,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -668,58 +749,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (78)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -749,48 +830,86 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___9
+                                                                    when
+                                                                    uu___9 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists"])))
+                                                                    "GEExists0"]))
+                                                                    | 
+                                                                    uu___9 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExists1"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                         | uu___5 ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.lift_div_tac
+                                                                    | 
+                                                                    uu___5 ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___7
+                                                                    when
+                                                                    uu___7 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsNoAbs0"]))
+                                                                    | 
+                                                                    uu___7 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs"])))
+                                                                    "GEExistsNoAbs1"])))
                                                                     lbody))))
-                                                        uu___4))) uu___3))
+                                                                   uu___4)))
+                                                    uu___3))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (399))
+                                       (Prims.of_int (458))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -808,15 +927,15 @@ let rec (solve_gen_elim :
                                                       FStar_Tactics_Effect.tac_bind
                                                         (Prims.mk_range
                                                            "Steel.ST.GenElim.Base.fsti"
-                                                           (Prims.of_int (383))
+                                                           (Prims.of_int (442))
                                                            (Prims.of_int (15))
-                                                           (Prims.of_int (383))
+                                                           (Prims.of_int (442))
                                                            (Prims.of_int (42)))
                                                         (Prims.mk_range
                                                            "Steel.ST.GenElim.Base.fsti"
-                                                           (Prims.of_int (383))
+                                                           (Prims.of_int (442))
                                                            (Prims.of_int (12))
-                                                           (Prims.of_int (396))
+                                                           (Prims.of_int (455))
                                                            (Prims.of_int (72)))
                                                         (Obj.magic
                                                            (term_has_head tl
@@ -836,15 +955,15 @@ let rec (solve_gen_elim :
                                                                   (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -857,15 +976,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -887,15 +1006,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -924,15 +1043,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -963,15 +1082,15 @@ let rec (solve_gen_elim :
                                                                   (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -984,15 +1103,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1075,11 +1194,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (19))
-                            (Prims.of_int (488)) (Prims.of_int (34)))
+                            (Prims.of_int (547)) (Prims.of_int (19))
+                            (Prims.of_int (547)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (4))
-                            (Prims.of_int (532)) (Prims.of_int (13)))
+                            (Prims.of_int (547)) (Prims.of_int (4))
+                            (Prims.of_int (592)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1099,15 +1218,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (493))
+                                                     (Prims.of_int (552))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (495))
-                                                     (Prims.of_int (85)))
+                                                     (Prims.of_int (554))
+                                                     (Prims.of_int (88)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (497))
+                                                     (Prims.of_int (556))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (522))
+                                                     (Prims.of_int (582))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1117,16 +1236,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (495))
-                                                                   (Prims.of_int (85)))
+                                                                   (Prims.of_int (554))
+                                                                   (Prims.of_int (88)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1145,16 +1264,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (554))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (495))
-                                                                    (Prims.of_int (85)))
+                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (88)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1172,7 +1291,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1185,15 +1306,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (556))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (497))
-                                                                (Prims.of_int (79)))
+                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (84)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (498))
+                                                                (Prims.of_int (557))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (522))
+                                                                (Prims.of_int (582))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1218,7 +1339,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1229,15 +1352,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (499))
+                                                                    (Prims.of_int (558))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1254,15 +1377,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (501))
+                                                                    (Prims.of_int (560))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (505))
+                                                                    (Prims.of_int (564))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (507))
+                                                                    (Prims.of_int (566))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1275,16 +1398,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1296,16 +1419,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (563))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1327,7 +1450,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1362,23 +1487,69 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (39))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (81)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (8))
+                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (9)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.fresh_binder
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))))
+                                                                    (fun
+                                                                    uu___3 ->
+                                                                    (fun
+                                                                    dummy_raised_unit_binder
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (510))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (120)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.append
+                                                                    (FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders)))
+                                                                    rev_types_and_binders))
+                                                                    [dummy_raised_unit_binder]))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1388,15 +1559,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1416,15 +1587,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1437,37 +1608,88 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (513))
-                                                                    (Prims.of_int (113)))
+                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (151)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    = "_";
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (964));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    })
+                                                                    FStar_Reflection_Data.Q_Explicit
+                                                                    []),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"]))),
+                                                                    "vprop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1477,15 +1699,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1498,35 +1720,86 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (515))
-                                                                    (Prims.of_int (112)))
+                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (150)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (516))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    = "_";
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (967));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    })
+                                                                    FStar_Reflection_Data.Q_Explicit
+                                                                    []),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"]))),
+                                                                    "prop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1541,6 +1814,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
+                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1567,15 +1841,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (529))
+                                                         (Prims.of_int (589))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1636,11 +1910,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (539)) (Prims.of_int (17))
-                                 (Prims.of_int (539)) (Prims.of_int (64)))
+                                 (Prims.of_int (599)) (Prims.of_int (17))
+                                 (Prims.of_int (599)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (540)) (Prims.of_int (6))
-                                 (Prims.of_int (541)) (Prims.of_int (37)))
+                                 (Prims.of_int (600)) (Prims.of_int (6))
+                                 (Prims.of_int (601)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1659,15 +1933,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1701,10 +1975,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1719,13 +1993,17 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_FVar
-                            (FStar_Reflection_Builtins.pack_fv
-                               ["Steel";
-                               "ST";
-                               "GenElim";
-                               "Base";
-                               "mk_gen_elim_nondep_by_tac"])))
+                         (FStar_Reflection_Data.Tv_UInst
+                            ((FStar_Reflection_Builtins.pack_fv
+                                ["Steel";
+                                "ST";
+                                "GenElim";
+                                "Base";
+                                "mk_gen_elim_nondep_by_tac"]),
+                              [FStar_Reflection_Builtins.pack_universe
+                                 (FStar_Reflection_Data.Uv_Succ
+                                    (FStar_Reflection_Builtins.pack_universe
+                                       FStar_Reflection_Data.Uv_Zero))])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
@@ -1735,16 +2013,16 @@ let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+         (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+         (Prims.of_int (2)) (Prims.of_int (664)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+               (Prims.of_int (31)) (Prims.of_int (626)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+               (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -1756,27 +2034,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (567)) (Prims.of_int (2))
-                        (Prims.of_int (568)) (Prims.of_int (33)))
+                        (Prims.of_int (627)) (Prims.of_int (2))
+                        (Prims.of_int (628)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (569)) (Prims.of_int (2))
-                        (Prims.of_int (604)) (Prims.of_int (35)))
+                        (Prims.of_int (629)) (Prims.of_int (2))
+                        (Prims.of_int (664)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (5))
-                              (Prims.of_int (567)) (Prims.of_int (23)))
+                              (Prims.of_int (627)) (Prims.of_int (5))
+                              (Prims.of_int (627)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (2))
-                              (Prims.of_int (568)) (Prims.of_int (33)))
+                              (Prims.of_int (627)) (Prims.of_int (2))
+                              (Prims.of_int (628)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (9))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (627)) (Prims.of_int (9))
+                                    (Prims.of_int (627)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (5))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (627)) (Prims.of_int (5))
+                                    (Prims.of_int (627)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -1802,15 +2080,15 @@ let (solve_gen_elim_prop :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (571))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (571))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (571))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (603))
+                                       (Prims.of_int (663))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -1824,15 +2102,15 @@ let (solve_gen_elim_prop :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (572))
+                                                      (Prims.of_int (632))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (573))
+                                                      (Prims.of_int (633))
                                                       (Prims.of_int (42)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (574))
+                                                      (Prims.of_int (634))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (602))
+                                                      (Prims.of_int (662))
                                                       (Prims.of_int (44)))
                                                    (if
                                                       Prims.op_Negation
@@ -1873,15 +2151,15 @@ let (solve_gen_elim_prop :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (74)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -1899,15 +2177,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1921,15 +2199,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1953,29 +2231,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2026,15 +2304,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (586))
+                                                                    (Prims.of_int (646))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (593))
+                                                                    (Prims.of_int (653))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2070,15 +2348,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2088,15 +2366,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2124,15 +2402,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2159,15 +2437,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2177,15 +2455,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2209,15 +2487,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2227,15 +2505,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2249,15 +2527,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (45)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (47))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.trivial
@@ -2283,15 +2561,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2301,15 +2579,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2333,15 +2611,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2351,15 +2629,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2387,15 +2665,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2430,16 +2708,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+         (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+         (Prims.of_int (2)) (Prims.of_int (706)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+               (Prims.of_int (31)) (Prims.of_int (670)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+               (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2451,27 +2729,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (611)) (Prims.of_int (2))
-                        (Prims.of_int (612)) (Prims.of_int (33)))
+                        (Prims.of_int (671)) (Prims.of_int (2))
+                        (Prims.of_int (672)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (613)) (Prims.of_int (2))
-                        (Prims.of_int (644)) (Prims.of_int (35)))
+                        (Prims.of_int (673)) (Prims.of_int (2))
+                        (Prims.of_int (706)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (5))
-                              (Prims.of_int (611)) (Prims.of_int (23)))
+                              (Prims.of_int (671)) (Prims.of_int (5))
+                              (Prims.of_int (671)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (2))
-                              (Prims.of_int (612)) (Prims.of_int (33)))
+                              (Prims.of_int (671)) (Prims.of_int (2))
+                              (Prims.of_int (672)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (9))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (671)) (Prims.of_int (9))
+                                    (Prims.of_int (671)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (5))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (671)) (Prims.of_int (5))
+                                    (Prims.of_int (671)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2497,15 +2775,15 @@ let (solve_gen_elim_prop_placeholder :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (615))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (615))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (615))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (643))
+                                       (Prims.of_int (705))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2519,15 +2797,15 @@ let (solve_gen_elim_prop_placeholder :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (616))
+                                                      (Prims.of_int (676))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (617))
+                                                      (Prims.of_int (677))
                                                       (Prims.of_int (54)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (618))
+                                                      (Prims.of_int (678))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (642))
+                                                      (Prims.of_int (704))
                                                       (Prims.of_int (56)))
                                                    (if
                                                       Prims.op_Negation
@@ -2568,43 +2846,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (681))
                                                                     (Prims.of_int (47)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (681))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2650,29 +2928,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2696,29 +2974,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2742,29 +3020,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (685))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2788,15 +3066,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (685))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (626))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -2827,15 +3105,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2853,15 +3131,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2875,15 +3153,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -2898,15 +3176,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2928,19 +3206,21 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (631))
-                                                                    (Prims.of_int (101)))
+                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    (FStar_Reflection_Derived.mk_app
+                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -2953,7 +3233,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)])))
+                                                                    FStar_Reflection_Data.Q_Explicit)]))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -2963,15 +3243,59 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (37)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Builtins.term_to_string
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun
+                                                                    a'_ts ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (27)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun a'1
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (15))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -2998,15 +3322,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3033,15 +3357,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3056,19 +3380,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'))
+                                                                    a'1))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3079,15 +3403,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3102,15 +3426,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3125,15 +3449,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3148,15 +3472,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3171,15 +3495,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3211,6 +3535,8 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
+                                                                    uu___12)))
+                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From b52e145f957d61848903b54a7c284f8703388475 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 24 Feb 2023 00:19:08 -0800
Subject: [PATCH 392/513] remove ocamlbuild snapshot

---
 src/ocaml-output/FStar_CheckedFiles.ml        |   571 -
 src/ocaml-output/FStar_Common.ml              |   177 -
 src/ocaml-output/FStar_Compiler_Option.ml     |    37 -
 src/ocaml-output/FStar_Compiler_Range.ml      |   249 -
 src/ocaml-output/FStar_Const.ml               |   144 -
 src/ocaml-output/FStar_Dependencies.ml        |    19 -
 src/ocaml-output/FStar_Errors.ml              |  3032 ---
 src/ocaml-output/FStar_Extraction_Krml.ml     |  4322 ----
 src/ocaml-output/FStar_Extraction_ML_Code.ml  |  1412 --
 src/ocaml-output/FStar_Extraction_ML_Modul.ml |  2827 ---
 ...ar_Extraction_ML_RemoveUnusedParameters.ml |   611 -
 .../FStar_Extraction_ML_Syntax.ml             |   733 -
 src/ocaml-output/FStar_Extraction_ML_Term.ml  |  4279 ----
 src/ocaml-output/FStar_Extraction_ML_UEnv.ml  |  1130 -
 src/ocaml-output/FStar_Extraction_ML_Util.ml  |  1598 --
 src/ocaml-output/FStar_Ident.ml               |   156 -
 .../FStar_Interactive_CompletionTable.ml      |   890 -
 src/ocaml-output/FStar_Interactive_Ide.ml     |  2688 ---
 .../FStar_Interactive_JsonHelper.ml           |   906 -
 src/ocaml-output/FStar_Interactive_Legacy.ml  |   961 -
 src/ocaml-output/FStar_Interactive_Lsp.ml     |   530 -
 .../FStar_Interactive_PushHelper.ml           |   892 -
 .../FStar_Interactive_QueryHelper.ml          |   289 -
 src/ocaml-output/FStar_Main.ml                |   345 -
 src/ocaml-output/FStar_Options.ml             |  2543 ---
 src/ocaml-output/FStar_Order.ml               |    58 -
 src/ocaml-output/FStar_Parser_AST.ml          |  2423 ---
 src/ocaml-output/FStar_Parser_Const.ml        |   601 -
 src/ocaml-output/FStar_Parser_Dep.ml          |  2741 ---
 src/ocaml-output/FStar_Parser_Driver.ml       |    54 -
 src/ocaml-output/FStar_Parser_ToDocument.ml   |  4917 -----
 src/ocaml-output/FStar_Pervasives.ml          |   277 -
 src/ocaml-output/FStar_Prettyprint.ml         |    90 -
 src/ocaml-output/FStar_Profiling.ml           |   111 -
 src/ocaml-output/FStar_Reflection_Basic.ml    |  1293 --
 .../FStar_Reflection_Constants.ml             |   408 -
 src/ocaml-output/FStar_Reflection_Data.ml     |   446 -
 .../FStar_Reflection_Embeddings.ml            |  2612 ---
 .../FStar_Reflection_Interpreter.ml           |   721 -
 .../FStar_Reflection_NBEEmbeddings.ml         |  2450 ---
 src/ocaml-output/FStar_SMTEncoding_Encode.ml  |  7783 -------
 .../FStar_SMTEncoding_EncodeTerm.ml           |  3958 ----
 src/ocaml-output/FStar_SMTEncoding_Env.ml     |  1118 -
 .../FStar_SMTEncoding_ErrorReporting.ml       |   852 -
 src/ocaml-output/FStar_SMTEncoding_Solver.ml  |  1912 --
 src/ocaml-output/FStar_SMTEncoding_Term.ml    |  2221 --
 src/ocaml-output/FStar_SMTEncoding_Util.ml    |   259 -
 src/ocaml-output/FStar_SMTEncoding_Z3.ml      |  1047 -
 src/ocaml-output/FStar_Syntax_DsEnv.ml        |  3364 ---
 src/ocaml-output/FStar_Syntax_Embeddings.ml   |  2695 ---
 src/ocaml-output/FStar_Syntax_Free.ml         |   582 -
 src/ocaml-output/FStar_Syntax_Hash.ml         |  1174 --
 src/ocaml-output/FStar_Syntax_InstFV.ml       |   332 -
 src/ocaml-output/FStar_Syntax_MutRecTy.ml     |   376 -
 src/ocaml-output/FStar_Syntax_Print.ml        |  1759 --
 src/ocaml-output/FStar_Syntax_Print_Pretty.ml |    91 -
 src/ocaml-output/FStar_Syntax_Resugar.ml      |  2926 ---
 src/ocaml-output/FStar_Syntax_Subst.ml        |  2185 --
 src/ocaml-output/FStar_Syntax_Syntax.ml       |  2202 --
 src/ocaml-output/FStar_Syntax_Unionfind.ml    |   379 -
 src/ocaml-output/FStar_Syntax_Util.ml         |  4879 -----
 src/ocaml-output/FStar_Tactics_Basic.ml       |  7317 -------
 src/ocaml-output/FStar_Tactics_Common.ml      |    16 -
 src/ocaml-output/FStar_Tactics_CtrlRewrite.ml |   843 -
 src/ocaml-output/FStar_Tactics_Embedding.ml   |   826 -
 src/ocaml-output/FStar_Tactics_Hooks.ml       |  1870 --
 src/ocaml-output/FStar_Tactics_InterpFuns.ml  | 16951 ----------------
 src/ocaml-output/FStar_Tactics_Interpreter.ml |  2140 --
 src/ocaml-output/FStar_Tactics_Monad.ml       |   936 -
 src/ocaml-output/FStar_Tactics_Printing.ml    |   357 -
 src/ocaml-output/FStar_Tactics_Result.ml      |    14 -
 src/ocaml-output/FStar_Tactics_Types.ml       |   466 -
 src/ocaml-output/FStar_Tests_Norm.ml          |  1461 --
 src/ocaml-output/FStar_Tests_Pars.ml          |   624 -
 src/ocaml-output/FStar_Tests_Test.ml          |    34 -
 src/ocaml-output/FStar_Tests_Unif.ml          |   578 -
 src/ocaml-output/FStar_Tests_Util.ml          |   262 -
 src/ocaml-output/FStar_Thunk.ml               |    19 -
 src/ocaml-output/FStar_ToSyntax_Interleave.ml |   601 -
 src/ocaml-output/FStar_ToSyntax_ToSyntax.ml   |  9373 ---------
 src/ocaml-output/FStar_TypeChecker_Cfg.ml     |  4244 ----
 src/ocaml-output/FStar_TypeChecker_Common.ml  |  1769 --
 src/ocaml-output/FStar_TypeChecker_Core.ml    |  4351 ----
 src/ocaml-output/FStar_TypeChecker_DMFF.ml    |  4740 -----
 .../FStar_TypeChecker_DeferredImplicits.ml    |   847 -
 src/ocaml-output/FStar_TypeChecker_Env.ml     |  6834 -------
 src/ocaml-output/FStar_TypeChecker_Err.ml     |   603 -
 .../FStar_TypeChecker_Generalize.ml           |   689 -
 src/ocaml-output/FStar_TypeChecker_NBE.ml     |  3365 ---
 src/ocaml-output/FStar_TypeChecker_NBETerm.ml |  2159 --
 .../FStar_TypeChecker_Normalize.ml            |  9313 ---------
 .../FStar_TypeChecker_PatternUtils.ml         |   478 -
 .../FStar_TypeChecker_Positivity.ml           |  1422 --
 src/ocaml-output/FStar_TypeChecker_Rel.ml     | 14921 --------------
 src/ocaml-output/FStar_TypeChecker_Tc.ml      |  5050 -----
 .../FStar_TypeChecker_TcEffect.ml             |  9639 ---------
 .../FStar_TypeChecker_TcInductive.ml          |  2949 ---
 src/ocaml-output/FStar_TypeChecker_TcTerm.ml  | 13030 ------------
 src/ocaml-output/FStar_TypeChecker_Util.ml    |  8596 --------
 src/ocaml-output/FStar_Universal.ml           |  1343 --
 src/ocaml-output/FStar_VConfig.ml             |   348 -
 101 files changed, 234015 deletions(-)
 delete mode 100644 src/ocaml-output/FStar_CheckedFiles.ml
 delete mode 100644 src/ocaml-output/FStar_Common.ml
 delete mode 100644 src/ocaml-output/FStar_Compiler_Option.ml
 delete mode 100644 src/ocaml-output/FStar_Compiler_Range.ml
 delete mode 100644 src/ocaml-output/FStar_Const.ml
 delete mode 100644 src/ocaml-output/FStar_Dependencies.ml
 delete mode 100644 src/ocaml-output/FStar_Errors.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_Krml.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_Code.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_Modul.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_RemoveUnusedParameters.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_Syntax.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_Term.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_UEnv.ml
 delete mode 100644 src/ocaml-output/FStar_Extraction_ML_Util.ml
 delete mode 100644 src/ocaml-output/FStar_Ident.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_CompletionTable.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_Ide.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_JsonHelper.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_Legacy.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_Lsp.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_PushHelper.ml
 delete mode 100644 src/ocaml-output/FStar_Interactive_QueryHelper.ml
 delete mode 100644 src/ocaml-output/FStar_Main.ml
 delete mode 100644 src/ocaml-output/FStar_Options.ml
 delete mode 100644 src/ocaml-output/FStar_Order.ml
 delete mode 100644 src/ocaml-output/FStar_Parser_AST.ml
 delete mode 100644 src/ocaml-output/FStar_Parser_Const.ml
 delete mode 100644 src/ocaml-output/FStar_Parser_Dep.ml
 delete mode 100644 src/ocaml-output/FStar_Parser_Driver.ml
 delete mode 100644 src/ocaml-output/FStar_Parser_ToDocument.ml
 delete mode 100644 src/ocaml-output/FStar_Pervasives.ml
 delete mode 100644 src/ocaml-output/FStar_Prettyprint.ml
 delete mode 100644 src/ocaml-output/FStar_Profiling.ml
 delete mode 100644 src/ocaml-output/FStar_Reflection_Basic.ml
 delete mode 100644 src/ocaml-output/FStar_Reflection_Constants.ml
 delete mode 100644 src/ocaml-output/FStar_Reflection_Data.ml
 delete mode 100644 src/ocaml-output/FStar_Reflection_Embeddings.ml
 delete mode 100644 src/ocaml-output/FStar_Reflection_Interpreter.ml
 delete mode 100644 src/ocaml-output/FStar_Reflection_NBEEmbeddings.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_Encode.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_EncodeTerm.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_Env.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_ErrorReporting.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_Solver.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_Term.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_Util.ml
 delete mode 100644 src/ocaml-output/FStar_SMTEncoding_Z3.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_DsEnv.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Embeddings.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Free.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Hash.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_InstFV.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_MutRecTy.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Print.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Print_Pretty.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Resugar.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Subst.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Syntax.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Unionfind.ml
 delete mode 100644 src/ocaml-output/FStar_Syntax_Util.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Basic.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Common.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_CtrlRewrite.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Embedding.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Hooks.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_InterpFuns.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Interpreter.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Monad.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Printing.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Result.ml
 delete mode 100644 src/ocaml-output/FStar_Tactics_Types.ml
 delete mode 100644 src/ocaml-output/FStar_Tests_Norm.ml
 delete mode 100644 src/ocaml-output/FStar_Tests_Pars.ml
 delete mode 100644 src/ocaml-output/FStar_Tests_Test.ml
 delete mode 100644 src/ocaml-output/FStar_Tests_Unif.ml
 delete mode 100644 src/ocaml-output/FStar_Tests_Util.ml
 delete mode 100644 src/ocaml-output/FStar_Thunk.ml
 delete mode 100644 src/ocaml-output/FStar_ToSyntax_Interleave.ml
 delete mode 100644 src/ocaml-output/FStar_ToSyntax_ToSyntax.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Cfg.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Common.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Core.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_DMFF.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_DeferredImplicits.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Env.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Err.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Generalize.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_NBE.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_NBETerm.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Normalize.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_PatternUtils.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Positivity.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Rel.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Tc.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_TcEffect.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_TcInductive.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_TcTerm.ml
 delete mode 100644 src/ocaml-output/FStar_TypeChecker_Util.ml
 delete mode 100644 src/ocaml-output/FStar_Universal.ml
 delete mode 100644 src/ocaml-output/FStar_VConfig.ml

diff --git a/src/ocaml-output/FStar_CheckedFiles.ml b/src/ocaml-output/FStar_CheckedFiles.ml
deleted file mode 100644
index 97d8ee5af75..00000000000
--- a/src/ocaml-output/FStar_CheckedFiles.ml
+++ /dev/null
@@ -1,571 +0,0 @@
-open Prims
-let (cache_version_number : Prims.int) = (Prims.of_int (48))
-type tc_result =
-  {
-  checked_module: FStar_Syntax_Syntax.modul ;
-  mii: FStar_Syntax_DsEnv.module_inclusion_info ;
-  smt_decls:
-    (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.fvar_binding
-      Prims.list)
-    ;
-  tc_time: Prims.int ;
-  extraction_time: Prims.int }
-let (__proj__Mktc_result__item__checked_module :
-  tc_result -> FStar_Syntax_Syntax.modul) =
-  fun projectee ->
-    match projectee with
-    | { checked_module; mii; smt_decls; tc_time; extraction_time;_} ->
-        checked_module
-let (__proj__Mktc_result__item__mii :
-  tc_result -> FStar_Syntax_DsEnv.module_inclusion_info) =
-  fun projectee ->
-    match projectee with
-    | { checked_module; mii; smt_decls; tc_time; extraction_time;_} -> mii
-let (__proj__Mktc_result__item__smt_decls :
-  tc_result ->
-    (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.fvar_binding
-      Prims.list))
-  =
-  fun projectee ->
-    match projectee with
-    | { checked_module; mii; smt_decls; tc_time; extraction_time;_} ->
-        smt_decls
-let (__proj__Mktc_result__item__tc_time : tc_result -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { checked_module; mii; smt_decls; tc_time; extraction_time;_} ->
-        tc_time
-let (__proj__Mktc_result__item__extraction_time : tc_result -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { checked_module; mii; smt_decls; tc_time; extraction_time;_} ->
-        extraction_time
-type checked_file_entry_stage1 =
-  {
-  version: Prims.int ;
-  digest: Prims.string ;
-  parsing_data: FStar_Parser_Dep.parsing_data }
-let (__proj__Mkchecked_file_entry_stage1__item__version :
-  checked_file_entry_stage1 -> Prims.int) =
-  fun projectee ->
-    match projectee with | { version; digest; parsing_data;_} -> version
-let (__proj__Mkchecked_file_entry_stage1__item__digest :
-  checked_file_entry_stage1 -> Prims.string) =
-  fun projectee ->
-    match projectee with | { version; digest; parsing_data;_} -> digest
-let (__proj__Mkchecked_file_entry_stage1__item__parsing_data :
-  checked_file_entry_stage1 -> FStar_Parser_Dep.parsing_data) =
-  fun projectee ->
-    match projectee with | { version; digest; parsing_data;_} -> parsing_data
-type checked_file_entry_stage2 =
-  {
-  deps_dig: (Prims.string * Prims.string) Prims.list ;
-  tc_res: tc_result }
-let (__proj__Mkchecked_file_entry_stage2__item__deps_dig :
-  checked_file_entry_stage2 -> (Prims.string * Prims.string) Prims.list) =
-  fun projectee -> match projectee with | { deps_dig; tc_res;_} -> deps_dig
-let (__proj__Mkchecked_file_entry_stage2__item__tc_res :
-  checked_file_entry_stage2 -> tc_result) =
-  fun projectee -> match projectee with | { deps_dig; tc_res;_} -> tc_res
-type tc_result_t =
-  | Unknown 
-  | Invalid of Prims.string 
-  | Valid of Prims.string 
-let (uu___is_Unknown : tc_result_t -> Prims.bool) =
-  fun projectee -> match projectee with | Unknown -> true | uu___ -> false
-let (uu___is_Invalid : tc_result_t -> Prims.bool) =
-  fun projectee -> match projectee with | Invalid _0 -> true | uu___ -> false
-let (__proj__Invalid__item___0 : tc_result_t -> Prims.string) =
-  fun projectee -> match projectee with | Invalid _0 -> _0
-let (uu___is_Valid : tc_result_t -> Prims.bool) =
-  fun projectee -> match projectee with | Valid _0 -> true | uu___ -> false
-let (__proj__Valid__item___0 : tc_result_t -> Prims.string) =
-  fun projectee -> match projectee with | Valid _0 -> _0
-type cache_t =
-  (tc_result_t * (Prims.string, FStar_Parser_Dep.parsing_data)
-    FStar_Pervasives.either)
-let (mcache : cache_t FStar_Compiler_Util.smap) =
-  FStar_Compiler_Util.smap_create (Prims.of_int (50))
-let (hash_dependences :
-  FStar_Parser_Dep.deps ->
-    Prims.string ->
-      (Prims.string, (Prims.string * Prims.string) Prims.list)
-        FStar_Pervasives.either)
-  =
-  fun deps ->
-    fun fn ->
-      let fn1 =
-        let uu___ = FStar_Options.find_file fn in
-        match uu___ with
-        | FStar_Pervasives_Native.Some fn2 -> fn2
-        | uu___1 -> fn in
-      let module_name = FStar_Parser_Dep.lowercase_module_name fn1 in
-      let source_hash = FStar_Compiler_Util.digest_of_file fn1 in
-      let has_interface =
-        let uu___ = FStar_Parser_Dep.interface_of deps module_name in
-        FStar_Compiler_Option.isSome uu___ in
-      let interface_checked_file_name =
-        let uu___ = (FStar_Parser_Dep.is_implementation fn1) && has_interface in
-        if uu___
-        then
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater module_name
-                  (FStar_Parser_Dep.interface_of deps) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                FStar_Compiler_Util.must in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              FStar_Parser_Dep.cache_file_name in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        else FStar_Pervasives_Native.None in
-      let binary_deps =
-        let uu___ = FStar_Parser_Dep.deps_of deps fn1 in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (FStar_Compiler_List.filter
-             (fun fn2 ->
-                let uu___1 =
-                  (FStar_Parser_Dep.is_interface fn2) &&
-                    (let uu___2 = FStar_Parser_Dep.lowercase_module_name fn2 in
-                     uu___2 = module_name) in
-                Prims.op_Negation uu___1)) in
-      let binary_deps1 =
-        FStar_Compiler_List.sortWith
-          (fun fn11 ->
-             fun fn2 ->
-               let uu___ = FStar_Parser_Dep.lowercase_module_name fn11 in
-               let uu___1 = FStar_Parser_Dep.lowercase_module_name fn2 in
-               FStar_String.compare uu___ uu___1) binary_deps in
-      let maybe_add_iface_hash out =
-        match interface_checked_file_name with
-        | FStar_Pervasives_Native.None ->
-            FStar_Pervasives.Inr (("source", source_hash) :: out)
-        | FStar_Pervasives_Native.Some iface ->
-            let uu___ = FStar_Compiler_Util.smap_try_find mcache iface in
-            (match uu___ with
-             | FStar_Pervasives_Native.None ->
-                 let msg =
-                   FStar_Compiler_Util.format1
-                     "hash_dependences::the interface checked file %s does not exist\n"
-                     iface in
-                 ((let uu___2 =
-                     FStar_Options.debug_at_level_no_module
-                       (FStar_Options.Other "CheckedFiles") in
-                   if uu___2
-                   then FStar_Compiler_Util.print1 "%s\n" msg
-                   else ());
-                  FStar_Pervasives.Inl msg)
-             | FStar_Pervasives_Native.Some (Invalid msg, uu___1) ->
-                 FStar_Pervasives.Inl msg
-             | FStar_Pervasives_Native.Some (Valid h, uu___1) ->
-                 FStar_Pervasives.Inr (("source", source_hash) ::
-                   ("interface", h) :: out)
-             | FStar_Pervasives_Native.Some (Unknown, uu___1) ->
-                 let uu___2 =
-                   FStar_Compiler_Util.format1
-                     "Impossible: unknown entry in the mcache for interface %s\n"
-                     iface in
-                 failwith uu___2) in
-      let rec hash_deps out uu___ =
-        match uu___ with
-        | [] -> maybe_add_iface_hash out
-        | fn2::deps1 ->
-            let cache_fn = FStar_Parser_Dep.cache_file_name fn2 in
-            let digest =
-              let uu___1 = FStar_Compiler_Util.smap_try_find mcache cache_fn in
-              match uu___1 with
-              | FStar_Pervasives_Native.None ->
-                  let msg =
-                    FStar_Compiler_Util.format2
-                      "For dependency %s, cache file %s is not loaded" fn2
-                      cache_fn in
-                  ((let uu___3 =
-                      FStar_Options.debug_at_level_no_module
-                        (FStar_Options.Other "CheckedFiles") in
-                    if uu___3
-                    then FStar_Compiler_Util.print1 "%s\n" msg
-                    else ());
-                   FStar_Pervasives.Inl msg)
-              | FStar_Pervasives_Native.Some (Invalid msg, uu___2) ->
-                  FStar_Pervasives.Inl msg
-              | FStar_Pervasives_Native.Some (Valid dig, uu___2) ->
-                  FStar_Pervasives.Inr dig
-              | FStar_Pervasives_Native.Some (Unknown, uu___2) ->
-                  let uu___3 =
-                    FStar_Compiler_Util.format2
-                      "Impossible: unknown entry in the cache for dependence %s of module %s"
-                      fn2 module_name in
-                  failwith uu___3 in
-            (match digest with
-             | FStar_Pervasives.Inl msg -> FStar_Pervasives.Inl msg
-             | FStar_Pervasives.Inr dig ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Parser_Dep.lowercase_module_name fn2 in
-                     (uu___3, dig) in
-                   uu___2 :: out in
-                 hash_deps uu___1 deps1) in
-      hash_deps [] binary_deps1
-let (load_checked_file : Prims.string -> Prims.string -> cache_t) =
-  fun fn ->
-    fun checked_fn ->
-      let elt =
-        FStar_Compiler_Effect.op_Bar_Greater checked_fn
-          (FStar_Compiler_Util.smap_try_find mcache) in
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater elt FStar_Compiler_Util.is_some in
-      if uu___
-      then FStar_Compiler_Effect.op_Bar_Greater elt FStar_Compiler_Util.must
-      else
-        (let add_and_return elt1 =
-           FStar_Compiler_Util.smap_add mcache checked_fn elt1; elt1 in
-         if Prims.op_Negation (FStar_Compiler_Util.file_exists checked_fn)
-         then
-           let msg =
-             FStar_Compiler_Util.format1 "checked file %s does not exist"
-               checked_fn in
-           add_and_return ((Invalid msg), (FStar_Pervasives.Inl msg))
-         else
-           (let entry = FStar_Compiler_Util.load_value_from_file checked_fn in
-            match entry with
-            | FStar_Pervasives_Native.None ->
-                let msg =
-                  FStar_Compiler_Util.format1 "checked file %s is corrupt"
-                    checked_fn in
-                add_and_return ((Invalid msg), (FStar_Pervasives.Inl msg))
-            | FStar_Pervasives_Native.Some x ->
-                if x.version <> cache_version_number
-                then
-                  let msg =
-                    FStar_Compiler_Util.format1
-                      "checked file %s has incorrect version" checked_fn in
-                  add_and_return ((Invalid msg), (FStar_Pervasives.Inl msg))
-                else
-                  (let current_digest = FStar_Compiler_Util.digest_of_file fn in
-                   if x.digest <> current_digest
-                   then
-                     ((let uu___5 =
-                         FStar_Options.debug_at_level_no_module
-                           (FStar_Options.Other "CheckedFiles") in
-                       if uu___5
-                       then
-                         FStar_Compiler_Util.print4
-                           "Checked file %s is stale since incorrect digest of %s, expected: %s, found: %s\n"
-                           checked_fn fn current_digest x.digest
-                       else ());
-                      (let msg =
-                         FStar_Compiler_Util.format2
-                           "checked file %s is stale (digest mismatch for %s)"
-                           checked_fn fn in
-                       add_and_return
-                         ((Invalid msg), (FStar_Pervasives.Inl msg))))
-                   else
-                     add_and_return
-                       (Unknown, (FStar_Pervasives.Inr (x.parsing_data))))))
-let (load_checked_file_with_tc_result :
-  FStar_Parser_Dep.deps ->
-    Prims.string ->
-      Prims.string -> (Prims.string, tc_result) FStar_Pervasives.either)
-  =
-  fun deps ->
-    fun fn ->
-      fun checked_fn ->
-        let load_tc_result fn1 =
-          let entry = FStar_Compiler_Util.load_2values_from_file checked_fn in
-          match entry with
-          | FStar_Pervasives_Native.Some (uu___, s2) ->
-              ((s2.deps_dig), (s2.tc_res))
-          | uu___ ->
-              failwith
-                "Impossible! if first phase of loading was unknown, it should have succeeded" in
-        let elt = load_checked_file fn checked_fn in
-        match elt with
-        | (Invalid msg, uu___) -> FStar_Pervasives.Inl msg
-        | (Valid uu___, uu___1) ->
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater checked_fn
-                  load_tc_result in
-              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                FStar_Pervasives_Native.snd in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (fun uu___3 -> FStar_Pervasives.Inr uu___3)
-        | (Unknown, parsing_data) ->
-            let uu___ = hash_dependences deps fn in
-            (match uu___ with
-             | FStar_Pervasives.Inl msg ->
-                 let elt1 = ((Invalid msg), parsing_data) in
-                 (FStar_Compiler_Util.smap_add mcache checked_fn elt1;
-                  FStar_Pervasives.Inl msg)
-             | FStar_Pervasives.Inr deps_dig' ->
-                 let uu___1 =
-                   FStar_Compiler_Effect.op_Bar_Greater checked_fn
-                     load_tc_result in
-                 (match uu___1 with
-                  | (deps_dig, tc_result1) ->
-                      if deps_dig = deps_dig'
-                      then
-                        let elt1 =
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_Compiler_Util.digest_of_file checked_fn in
-                            Valid uu___3 in
-                          (uu___2, parsing_data) in
-                        (FStar_Compiler_Util.smap_add mcache checked_fn elt1;
-                         (let validate_iface_cache uu___3 =
-                            let iface =
-                              let uu___4 =
-                                FStar_Compiler_Effect.op_Bar_Greater fn
-                                  FStar_Parser_Dep.lowercase_module_name in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___4
-                                (FStar_Parser_Dep.interface_of deps) in
-                            match iface with
-                            | FStar_Pervasives_Native.None -> ()
-                            | FStar_Pervasives_Native.Some iface1 ->
-                                (try
-                                   (fun uu___4 ->
-                                      match () with
-                                      | () ->
-                                          let iface_checked_fn =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              iface1
-                                              FStar_Parser_Dep.cache_file_name in
-                                          let uu___5 =
-                                            FStar_Compiler_Util.smap_try_find
-                                              mcache iface_checked_fn in
-                                          (match uu___5 with
-                                           | FStar_Pervasives_Native.Some
-                                               (Unknown, parsing_data1) ->
-                                               let uu___6 =
-                                                 let uu___7 =
-                                                   let uu___8 =
-                                                     FStar_Compiler_Util.digest_of_file
-                                                       iface_checked_fn in
-                                                   Valid uu___8 in
-                                                 (uu___7, parsing_data1) in
-                                               FStar_Compiler_Util.smap_add
-                                                 mcache iface_checked_fn
-                                                 uu___6
-                                           | uu___6 -> ())) ()
-                                 with | uu___4 -> ()) in
-                          validate_iface_cache ();
-                          FStar_Pervasives.Inr tc_result1))
-                      else
-                        ((let uu___4 =
-                            FStar_Options.debug_at_level_no_module
-                              (FStar_Options.Other "CheckedFiles") in
-                          if uu___4
-                          then
-                            ((let uu___6 =
-                                FStar_Compiler_Util.string_of_int
-                                  (FStar_Compiler_List.length deps_dig') in
-                              let uu___7 =
-                                FStar_Parser_Dep.print_digest deps_dig' in
-                              let uu___8 =
-                                FStar_Compiler_Util.string_of_int
-                                  (FStar_Compiler_List.length deps_dig) in
-                              let uu___9 =
-                                FStar_Parser_Dep.print_digest deps_dig in
-                              FStar_Compiler_Util.print4
-                                "Expected (%s) hashes:\n%s\n\nGot (%s) hashes:\n\t%s\n"
-                                uu___6 uu___7 uu___8 uu___9);
-                             if
-                               (FStar_Compiler_List.length deps_dig) =
-                                 (FStar_Compiler_List.length deps_dig')
-                             then
-                               FStar_Compiler_List.iter2
-                                 (fun uu___6 ->
-                                    fun uu___7 ->
-                                      match (uu___6, uu___7) with
-                                      | ((x, y), (x', y')) ->
-                                          if (x <> x') || (y <> y')
-                                          then
-                                            let uu___8 =
-                                              FStar_Parser_Dep.print_digest
-                                                [(x, y)] in
-                                            let uu___9 =
-                                              FStar_Parser_Dep.print_digest
-                                                [(x', y')] in
-                                            FStar_Compiler_Util.print2
-                                              "Differ at: Expected %s\n Got %s\n"
-                                              uu___8 uu___9
-                                          else ()) deps_dig deps_dig'
-                             else ())
-                          else ());
-                         (let msg =
-                            FStar_Compiler_Util.format1
-                              "checked file %s is stale (dependence hash mismatch, use --debug yes for more details)"
-                              checked_fn in
-                          let elt1 =
-                            ((Invalid msg), (FStar_Pervasives.Inl msg)) in
-                          FStar_Compiler_Util.smap_add mcache checked_fn elt1;
-                          FStar_Pervasives.Inl msg))))
-let (load_parsing_data_from_cache :
-  Prims.string ->
-    FStar_Parser_Dep.parsing_data FStar_Pervasives_Native.option)
-  =
-  fun file_name ->
-    FStar_Errors.with_ctx
-      (Prims.op_Hat "While loading parsing data from " file_name)
-      (fun uu___ ->
-         let cache_file =
-           try
-             (fun uu___1 ->
-                match () with
-                | () ->
-                    let uu___2 = FStar_Parser_Dep.cache_file_name file_name in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___2
-                      (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)) ()
-           with | uu___1 -> FStar_Pervasives_Native.None in
-         match cache_file with
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-         | FStar_Pervasives_Native.Some cache_file1 ->
-             let uu___1 = load_checked_file file_name cache_file1 in
-             (match uu___1 with
-              | (uu___2, FStar_Pervasives.Inl msg) ->
-                  FStar_Pervasives_Native.None
-              | (uu___2, FStar_Pervasives.Inr data) ->
-                  FStar_Pervasives_Native.Some data))
-let (load_module_from_cache :
-  FStar_Extraction_ML_UEnv.uenv ->
-    Prims.string -> tc_result FStar_Pervasives_Native.option)
-  =
-  let already_failed = FStar_Compiler_Util.mk_ref false in
-  fun env ->
-    fun fn ->
-      FStar_Errors.with_ctx
-        (Prims.op_Hat "While loading module from file " fn)
-        (fun uu___ ->
-           let load_it fn1 uu___1 =
-             let cache_file = FStar_Parser_Dep.cache_file_name fn1 in
-             let fail msg cache_file1 =
-               let suppress_warning =
-                 (FStar_Options.should_verify_file fn1) ||
-                   (FStar_Compiler_Effect.op_Bang already_failed) in
-               if Prims.op_Negation suppress_warning
-               then
-                 (FStar_Compiler_Effect.op_Colon_Equals already_failed true;
-                  (let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_Range.mk_pos Prims.int_zero
-                         Prims.int_zero in
-                     let uu___5 =
-                       FStar_Compiler_Range.mk_pos Prims.int_zero
-                         Prims.int_zero in
-                     FStar_Compiler_Range.mk_range fn1 uu___4 uu___5 in
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Compiler_Util.format3
-                         "Unable to load %s since %s; will recheck %s (suppressing this warning for further modules)"
-                         cache_file1 msg fn1 in
-                     (FStar_Errors.Warning_CachedFile, uu___5) in
-                   FStar_Errors.log_issue uu___3 uu___4))
-               else () in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-                 FStar_TypeChecker_Env.dep_graph uu___4 in
-               load_checked_file_with_tc_result uu___3 fn1 cache_file in
-             match uu___2 with
-             | FStar_Pervasives.Inl msg ->
-                 (fail msg cache_file; FStar_Pervasives_Native.None)
-             | FStar_Pervasives.Inr tc_result1 ->
-                 ((let uu___4 =
-                     FStar_Options.debug_at_level_no_module
-                       (FStar_Options.Other "CheckedFiles") in
-                   if uu___4
-                   then
-                     FStar_Compiler_Util.print1
-                       "Successfully loaded module from checked file %s\n"
-                       cache_file
-                   else ());
-                  FStar_Pervasives_Native.Some tc_result1) in
-           let load_with_profiling fn1 =
-             FStar_Profiling.profile (load_it fn1)
-               FStar_Pervasives_Native.None "FStar.CheckedFiles" in
-           let i_fn_opt =
-             let uu___1 =
-               let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-               FStar_TypeChecker_Env.dep_graph uu___2 in
-             let uu___2 = FStar_Parser_Dep.lowercase_module_name fn in
-             FStar_Parser_Dep.interface_of uu___1 uu___2 in
-           let uu___1 =
-             (FStar_Parser_Dep.is_implementation fn) &&
-               (FStar_Compiler_Effect.op_Bar_Greater i_fn_opt
-                  FStar_Compiler_Util.is_some) in
-           if uu___1
-           then
-             let i_fn =
-               FStar_Compiler_Effect.op_Bar_Greater i_fn_opt
-                 FStar_Compiler_Util.must in
-             let i_tc = load_with_profiling i_fn in
-             match i_tc with
-             | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-             | FStar_Pervasives_Native.Some uu___2 -> load_with_profiling fn
-           else load_with_profiling fn)
-let (store_values_to_cache :
-  Prims.string ->
-    checked_file_entry_stage1 -> checked_file_entry_stage2 -> unit)
-  =
-  fun cache_file ->
-    fun stage1 ->
-      fun stage2 ->
-        FStar_Errors.with_ctx
-          (Prims.op_Hat "While writing checked file " cache_file)
-          (fun uu___ ->
-             FStar_Compiler_Util.save_2values_to_file cache_file stage1
-               stage2)
-let (store_module_to_cache :
-  FStar_Extraction_ML_UEnv.uenv ->
-    Prims.string -> FStar_Parser_Dep.parsing_data -> tc_result -> unit)
-  =
-  fun env ->
-    fun fn ->
-      fun parsing_data ->
-        fun tc_result1 ->
-          let uu___ =
-            (FStar_Options.cache_checked_modules ()) &&
-              (let uu___1 = FStar_Options.cache_off () in
-               Prims.op_Negation uu___1) in
-          if uu___
-          then
-            let cache_file = FStar_Parser_Dep.cache_file_name fn in
-            let digest =
-              let uu___1 =
-                let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-                FStar_TypeChecker_Env.dep_graph uu___2 in
-              hash_dependences uu___1 fn in
-            match digest with
-            | FStar_Pervasives.Inr hashes ->
-                let tc_result2 =
-                  {
-                    checked_module = (tc_result1.checked_module);
-                    mii = (tc_result1.mii);
-                    smt_decls = (tc_result1.smt_decls);
-                    tc_time = Prims.int_zero;
-                    extraction_time = Prims.int_zero
-                  } in
-                let stage1 =
-                  let uu___1 = FStar_Compiler_Util.digest_of_file fn in
-                  {
-                    version = cache_version_number;
-                    digest = uu___1;
-                    parsing_data
-                  } in
-                let stage2 = { deps_dig = hashes; tc_res = tc_result2 } in
-                store_values_to_cache cache_file stage1 stage2
-            | FStar_Pervasives.Inl msg ->
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Compiler_Range.mk_pos Prims.int_zero Prims.int_zero in
-                  let uu___3 =
-                    FStar_Compiler_Range.mk_pos Prims.int_zero Prims.int_zero in
-                  FStar_Compiler_Range.mk_range fn uu___2 uu___3 in
-                let uu___2 =
-                  let uu___3 =
-                    FStar_Compiler_Util.format2 "%s was not written since %s"
-                      cache_file msg in
-                  (FStar_Errors.Warning_FileNotWritten, uu___3) in
-                FStar_Errors.log_issue uu___1 uu___2
-          else ()
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Common.ml b/src/ocaml-output/FStar_Common.ml
deleted file mode 100644
index 3732323554f..00000000000
--- a/src/ocaml-output/FStar_Common.ml
+++ /dev/null
@@ -1,177 +0,0 @@
-open Prims
-let (has_cygpath : Prims.bool) =
-  try
-    (fun uu___ ->
-       match () with
-       | () ->
-           let t_out =
-             FStar_Compiler_Util.run_process "has_cygpath" "which"
-               ["cygpath"] FStar_Pervasives_Native.None in
-           (FStar_Compiler_Util.trim_string t_out) = "/usr/bin/cygpath") ()
-  with | uu___ -> false
-let (try_convert_file_name_to_mixed : Prims.string -> Prims.string) =
-  let cache = FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-  fun s ->
-    if has_cygpath && (FStar_Compiler_Util.starts_with s "/")
-    then
-      let uu___ = FStar_Compiler_Util.smap_try_find cache s in
-      match uu___ with
-      | FStar_Pervasives_Native.Some s1 -> s1
-      | FStar_Pervasives_Native.None ->
-          let label = "try_convert_file_name_to_mixed" in
-          let out =
-            let uu___1 =
-              FStar_Compiler_Util.run_process label "cygpath" ["-m"; s]
-                FStar_Pervasives_Native.None in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              FStar_Compiler_Util.trim_string in
-          (FStar_Compiler_Util.smap_add cache s out; out)
-    else s
-let snapshot :
-  'a 'b 'c .
-    ('a -> 'b) ->
-      'c Prims.list FStar_Compiler_Effect.ref -> 'a -> (Prims.int * 'b)
-  =
-  fun push ->
-    fun stackref ->
-      fun arg ->
-        FStar_Compiler_Util.atomically
-          (fun uu___ ->
-             let len =
-               let uu___1 = FStar_Compiler_Effect.op_Bang stackref in
-               FStar_Compiler_List.length uu___1 in
-             let arg' = push arg in (len, arg'))
-let rollback :
-  'a 'c .
-    (unit -> 'a) ->
-      'c Prims.list FStar_Compiler_Effect.ref ->
-        Prims.int FStar_Pervasives_Native.option -> 'a
-  =
-  fun pop ->
-    fun stackref ->
-      fun depth ->
-        let rec aux n =
-          if n <= Prims.int_zero
-          then failwith "Too many pops"
-          else
-            if n = Prims.int_one
-            then pop ()
-            else ((let uu___3 = pop () in ()); aux (n - Prims.int_one)) in
-        let curdepth =
-          let uu___ = FStar_Compiler_Effect.op_Bang stackref in
-          FStar_Compiler_List.length uu___ in
-        let n =
-          match depth with
-          | FStar_Pervasives_Native.Some d -> curdepth - d
-          | FStar_Pervasives_Native.None -> Prims.int_one in
-        FStar_Compiler_Util.atomically (fun uu___ -> aux n)
-let raise_failed_assertion : 'uuuuu . Prims.string -> 'uuuuu =
-  fun msg ->
-    let uu___ = FStar_Compiler_Util.format1 "Assertion failed: %s" msg in
-    failwith uu___
-let (runtime_assert : Prims.bool -> Prims.string -> unit) =
-  fun b ->
-    fun msg -> if Prims.op_Negation b then raise_failed_assertion msg else ()
-let __string_of_list :
-  'a . Prims.string -> ('a -> Prims.string) -> 'a Prims.list -> Prims.string
-  =
-  fun delim ->
-    fun f ->
-      fun l ->
-        match l with
-        | [] -> "[]"
-        | x::xs ->
-            let strb = FStar_Compiler_Util.new_string_builder () in
-            (FStar_Compiler_Util.string_builder_append strb "[";
-             (let uu___2 = f x in
-              FStar_Compiler_Util.string_builder_append strb uu___2);
-             FStar_Compiler_List.iter
-               (fun x1 ->
-                  FStar_Compiler_Util.string_builder_append strb delim;
-                  (let uu___4 = f x1 in
-                   FStar_Compiler_Util.string_builder_append strb uu___4)) xs;
-             FStar_Compiler_Util.string_builder_append strb "]";
-             FStar_Compiler_Util.string_of_string_builder strb)
-let string_of_list :
-  'uuuuu .
-    unit -> ('uuuuu -> Prims.string) -> 'uuuuu Prims.list -> Prims.string
-  = fun uu___ -> __string_of_list ", "
-let string_of_list' :
-  'uuuuu .
-    unit -> ('uuuuu -> Prims.string) -> 'uuuuu Prims.list -> Prims.string
-  = fun uu___ -> __string_of_list "; "
-let string_of_set :
-  'a . ('a -> Prims.string) -> 'a FStar_Compiler_Util.set -> Prims.string =
-  fun f ->
-    fun l ->
-      let uu___ = FStar_Compiler_Util.set_elements l in
-      match uu___ with
-      | [] -> "{}"
-      | x::xs ->
-          let strb = FStar_Compiler_Util.new_string_builder () in
-          (FStar_Compiler_Util.string_builder_append strb "{";
-           (let uu___3 = f x in
-            FStar_Compiler_Util.string_builder_append strb uu___3);
-           FStar_Compiler_List.iter
-             (fun x1 ->
-                FStar_Compiler_Util.string_builder_append strb ", ";
-                (let uu___5 = f x1 in
-                 FStar_Compiler_Util.string_builder_append strb uu___5)) xs;
-           FStar_Compiler_Util.string_builder_append strb "}";
-           FStar_Compiler_Util.string_of_string_builder strb)
-let list_of_option : 'a . 'a FStar_Pervasives_Native.option -> 'a Prims.list
-  =
-  fun o ->
-    match o with
-    | FStar_Pervasives_Native.None -> []
-    | FStar_Pervasives_Native.Some x -> [x]
-let string_of_option :
-  'uuuuu .
-    ('uuuuu -> Prims.string) ->
-      'uuuuu FStar_Pervasives_Native.option -> Prims.string
-  =
-  fun f ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.None -> "None"
-      | FStar_Pervasives_Native.Some x ->
-          let uu___1 = f x in Prims.op_Hat "Some " uu___1
-let tabulate : 'a . Prims.int -> (Prims.int -> 'a) -> 'a Prims.list =
-  fun n ->
-    fun f ->
-      let rec aux i =
-        if i < n
-        then
-          let uu___ = f i in
-          let uu___1 = aux (i + Prims.int_one) in uu___ :: uu___1
-        else [] in
-      aux Prims.int_zero
-let rec max_prefix :
-  'a . ('a -> Prims.bool) -> 'a Prims.list -> ('a Prims.list * 'a Prims.list)
-  =
-  fun f ->
-    fun xs ->
-      match xs with
-      | [] -> ([], [])
-      | x::xs1 when f x ->
-          let uu___ = max_prefix f xs1 in
-          (match uu___ with | (l, r) -> ((x :: l), r))
-      | x::xs1 -> ([], (x :: xs1))
-let max_suffix :
-  'a . ('a -> Prims.bool) -> 'a Prims.list -> ('a Prims.list * 'a Prims.list)
-  =
-  fun f ->
-    fun xs ->
-      let rec aux acc xs1 =
-        match xs1 with
-        | [] -> (acc, [])
-        | x::xs2 when f x -> aux (x :: acc) xs2
-        | x::xs2 -> (acc, (x :: xs2)) in
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater xs FStar_Compiler_List.rev in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1 (aux []) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (fun uu___1 ->
-           match uu___1 with
-           | (xs1, ys) -> ((FStar_Compiler_List.rev ys), xs1))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Compiler_Option.ml b/src/ocaml-output/FStar_Compiler_Option.ml
deleted file mode 100644
index aeb9eeabbe8..00000000000
--- a/src/ocaml-output/FStar_Compiler_Option.ml
+++ /dev/null
@@ -1,37 +0,0 @@
-open Prims
-let isNone : 'a . 'a FStar_Pervasives_Native.option -> Prims.bool =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> true
-    | FStar_Pervasives_Native.Some uu___1 -> false
-let isSome : 'a . 'a FStar_Pervasives_Native.option -> Prims.bool =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some uu___1 -> true
-    | FStar_Pervasives_Native.None -> false
-let map :
-  'a 'b .
-    ('a -> 'b) ->
-      'a FStar_Pervasives_Native.option -> 'b FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some x ->
-          let uu___1 = f x in FStar_Pervasives_Native.Some uu___1
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let mapTot :
-  'a 'b .
-    ('a -> 'b) ->
-      'a FStar_Pervasives_Native.option -> 'b FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some x -> FStar_Pervasives_Native.Some (f x)
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let get : 'a . 'a FStar_Pervasives_Native.option -> 'a =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some x -> x
-    | FStar_Pervasives_Native.None -> failwith "empty option"
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Compiler_Range.ml b/src/ocaml-output/FStar_Compiler_Range.ml
deleted file mode 100644
index 9910cb4096c..00000000000
--- a/src/ocaml-output/FStar_Compiler_Range.ml
+++ /dev/null
@@ -1,249 +0,0 @@
-open Prims
-type file_name = Prims.string[@@deriving yojson,show]
-type pos = {
-  line: Prims.int ;
-  col: Prims.int }[@@deriving yojson,show,yojson,show]
-let (__proj__Mkpos__item__line : pos -> Prims.int) =
-  fun projectee -> match projectee with | { line; col;_} -> line
-let (__proj__Mkpos__item__col : pos -> Prims.int) =
-  fun projectee -> match projectee with | { line; col;_} -> col
-let (max : Prims.int -> Prims.int -> Prims.int) =
-  fun i -> fun j -> if i < j then j else i
-let (pos_geq : pos -> pos -> Prims.bool) =
-  fun p1 ->
-    fun p2 ->
-      (p1.line > p2.line) || ((p1.line = p2.line) && (p1.col >= p2.col))
-type rng = {
-  file_name: file_name ;
-  start_pos: pos ;
-  end_pos: pos }[@@deriving yojson,show,yojson,show]
-let (__proj__Mkrng__item__file_name : rng -> file_name) =
-  fun projectee ->
-    match projectee with
-    | { file_name = file_name1; start_pos; end_pos;_} -> file_name1
-let (__proj__Mkrng__item__start_pos : rng -> pos) =
-  fun projectee ->
-    match projectee with
-    | { file_name = file_name1; start_pos; end_pos;_} -> start_pos
-let (__proj__Mkrng__item__end_pos : rng -> pos) =
-  fun projectee ->
-    match projectee with
-    | { file_name = file_name1; start_pos; end_pos;_} -> end_pos
-type range = {
-  def_range: rng ;
-  use_range: rng }[@@deriving yojson,show,yojson,show]
-let (__proj__Mkrange__item__def_range : range -> rng) =
-  fun projectee ->
-    match projectee with | { def_range; use_range;_} -> def_range
-let (__proj__Mkrange__item__use_range : range -> rng) =
-  fun projectee ->
-    match projectee with | { def_range; use_range;_} -> use_range
-let (dummy_pos : pos) = { line = Prims.int_zero; col = Prims.int_zero }
-let (dummy_rng : rng) =
-  { file_name = " dummy"; start_pos = dummy_pos; end_pos = dummy_pos }
-let (dummyRange : range) = { def_range = dummy_rng; use_range = dummy_rng }
-let (use_range : range -> rng) = fun r -> r.use_range
-let (def_range : range -> rng) = fun r -> r.def_range
-let (range_of_rng : rng -> rng -> range) =
-  fun d -> fun u -> { def_range = d; use_range = u }
-let (set_use_range : range -> rng -> range) =
-  fun r2 ->
-    fun use_rng ->
-      if use_rng <> dummy_rng
-      then { def_range = (r2.def_range); use_range = use_rng }
-      else r2
-let (set_def_range : range -> rng -> range) =
-  fun r2 ->
-    fun def_rng ->
-      if def_rng <> dummy_rng
-      then { def_range = def_rng; use_range = (r2.use_range) }
-      else r2
-let (mk_pos : Prims.int -> Prims.int -> pos) =
-  fun l ->
-    fun c -> { line = (max Prims.int_zero l); col = (max Prims.int_zero c) }
-let (mk_rng : file_name -> pos -> pos -> rng) =
-  fun file_name1 ->
-    fun start_pos ->
-      fun end_pos -> { file_name = file_name1; start_pos; end_pos }
-let (mk_range : Prims.string -> pos -> pos -> range) =
-  fun f -> fun b -> fun e -> let r = mk_rng f b e in range_of_rng r r
-let (union_rng : rng -> rng -> rng) =
-  fun r1 ->
-    fun r2 ->
-      if r1.file_name <> r2.file_name
-      then r2
-      else
-        (let start_pos =
-           if pos_geq r1.start_pos r2.start_pos
-           then r2.start_pos
-           else r1.start_pos in
-         let end_pos =
-           if pos_geq r1.end_pos r2.end_pos then r1.end_pos else r2.end_pos in
-         mk_rng r1.file_name start_pos end_pos)
-let (union_ranges : range -> range -> range) =
-  fun r1 ->
-    fun r2 ->
-      let uu___ = union_rng r1.def_range r2.def_range in
-      let uu___1 = union_rng r1.use_range r2.use_range in
-      { def_range = uu___; use_range = uu___1 }
-let (rng_included : rng -> rng -> Prims.bool) =
-  fun r1 ->
-    fun r2 ->
-      if r1.file_name <> r2.file_name
-      then false
-      else
-        (pos_geq r1.start_pos r2.start_pos) &&
-          (pos_geq r2.end_pos r1.end_pos)
-let (string_of_pos : pos -> Prims.string) =
-  fun pos1 ->
-    let uu___ = FStar_Compiler_Util.string_of_int pos1.line in
-    let uu___1 = FStar_Compiler_Util.string_of_int pos1.col in
-    FStar_Compiler_Util.format2 "%s,%s" uu___ uu___1
-let (string_of_file_name : Prims.string -> Prims.string) =
-  fun f ->
-    let uu___ = FStar_Options.ide () in
-    if uu___
-    then
-      try
-        (fun uu___1 ->
-           match () with
-           | () ->
-               let uu___2 =
-                 let uu___3 = FStar_Compiler_Util.basename f in
-                 FStar_Options.find_file uu___3 in
-               (match uu___2 with
-                | FStar_Pervasives_Native.None -> f
-                | FStar_Pervasives_Native.Some absolute_path -> absolute_path))
-          ()
-      with | uu___1 -> f
-    else f
-let (file_of_range : range -> Prims.string) =
-  fun r -> let f = (r.def_range).file_name in string_of_file_name f
-let (set_file_of_range : range -> Prims.string -> range) =
-  fun r ->
-    fun f ->
-      {
-        def_range =
-          (let uu___ = r.def_range in
-           {
-             file_name = f;
-             start_pos = (uu___.start_pos);
-             end_pos = (uu___.end_pos)
-           });
-        use_range = (r.use_range)
-      }
-let (string_of_rng : rng -> Prims.string) =
-  fun r ->
-    let uu___ = string_of_file_name r.file_name in
-    let uu___1 = string_of_pos r.start_pos in
-    let uu___2 = string_of_pos r.end_pos in
-    FStar_Compiler_Util.format3 "%s(%s-%s)" uu___ uu___1 uu___2
-let (string_of_def_range : range -> Prims.string) =
-  fun r -> string_of_rng r.def_range
-let (string_of_use_range : range -> Prims.string) =
-  fun r -> string_of_rng r.use_range
-let (string_of_range : range -> Prims.string) =
-  fun r -> string_of_def_range r
-let (start_of_range : range -> pos) = fun r -> (r.def_range).start_pos
-let (end_of_range : range -> pos) = fun r -> (r.def_range).end_pos
-let (file_of_use_range : range -> Prims.string) =
-  fun r -> (r.use_range).file_name
-let (start_of_use_range : range -> pos) = fun r -> (r.use_range).start_pos
-let (end_of_use_range : range -> pos) = fun r -> (r.use_range).end_pos
-let (line_of_pos : pos -> Prims.int) = fun p -> p.line
-let (col_of_pos : pos -> Prims.int) = fun p -> p.col
-let (end_range : range -> range) =
-  fun r ->
-    mk_range (r.def_range).file_name (r.def_range).end_pos
-      (r.def_range).end_pos
-let (compare_rng : rng -> rng -> Prims.int) =
-  fun r1 ->
-    fun r2 ->
-      let fcomp = FStar_String.compare r1.file_name r2.file_name in
-      if fcomp = Prims.int_zero
-      then
-        let start1 = r1.start_pos in
-        let start2 = r2.start_pos in
-        let lcomp = start1.line - start2.line in
-        (if lcomp = Prims.int_zero then start1.col - start2.col else lcomp)
-      else fcomp
-let (compare : range -> range -> Prims.int) =
-  fun r1 -> fun r2 -> compare_rng r1.def_range r2.def_range
-let (compare_use_range : range -> range -> Prims.int) =
-  fun r1 -> fun r2 -> compare_rng r1.use_range r2.use_range
-let (range_before_pos : range -> pos -> Prims.bool) =
-  fun m1 -> fun p -> let uu___ = end_of_range m1 in pos_geq p uu___
-let (end_of_line : pos -> pos) =
-  fun p -> { line = (p.line); col = FStar_Compiler_Util.max_int }
-let (extend_to_end_of_line : range -> range) =
-  fun r ->
-    let uu___ = file_of_range r in
-    let uu___1 = start_of_range r in
-    let uu___2 = let uu___3 = end_of_range r in end_of_line uu___3 in
-    mk_range uu___ uu___1 uu___2
-let (prims_to_fstar_range :
-  ((Prims.string * (Prims.int * Prims.int) * (Prims.int * Prims.int)) *
-    (Prims.string * (Prims.int * Prims.int) * (Prims.int * Prims.int))) ->
-    range)
-  =
-  fun r ->
-    let uu___ = r in
-    match uu___ with
-    | (r1, r2) ->
-        let uu___1 = r1 in
-        (match uu___1 with
-         | (f1, s1, e1) ->
-             let uu___2 = r2 in
-             (match uu___2 with
-              | (f2, s2, e2) ->
-                  let s11 =
-                    mk_pos (FStar_Pervasives_Native.fst s1)
-                      (FStar_Pervasives_Native.snd s1) in
-                  let e11 =
-                    mk_pos (FStar_Pervasives_Native.fst e1)
-                      (FStar_Pervasives_Native.snd e1) in
-                  let s21 =
-                    mk_pos (FStar_Pervasives_Native.fst s2)
-                      (FStar_Pervasives_Native.snd s2) in
-                  let e21 =
-                    mk_pos (FStar_Pervasives_Native.fst e2)
-                      (FStar_Pervasives_Native.snd e2) in
-                  let r11 = mk_rng f1 s11 e11 in
-                  let r21 = mk_rng f2 s21 e21 in
-                  { def_range = r11; use_range = r21 }))
-let (json_of_pos : pos -> FStar_Compiler_Util.json) =
-  fun pos1 ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = line_of_pos pos1 in FStar_Compiler_Util.JsonInt uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 = col_of_pos pos1 in FStar_Compiler_Util.JsonInt uu___4 in
-        [uu___3] in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.JsonList uu___
-let (json_of_range_fields :
-  Prims.string -> pos -> pos -> FStar_Compiler_Util.json) =
-  fun file ->
-    fun b ->
-      fun e ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = let uu___3 = json_of_pos b in ("beg", uu___3) in
-            let uu___3 =
-              let uu___4 = let uu___5 = json_of_pos e in ("end", uu___5) in
-              [uu___4] in
-            uu___2 :: uu___3 in
-          ("fname", (FStar_Compiler_Util.JsonStr file)) :: uu___1 in
-        FStar_Compiler_Util.JsonAssoc uu___
-let (json_of_use_range : range -> FStar_Compiler_Util.json) =
-  fun r ->
-    let uu___ = file_of_use_range r in
-    let uu___1 = start_of_use_range r in
-    let uu___2 = end_of_use_range r in
-    json_of_range_fields uu___ uu___1 uu___2
-let (json_of_def_range : range -> FStar_Compiler_Util.json) =
-  fun r ->
-    let uu___ = file_of_range r in
-    let uu___1 = start_of_range r in
-    let uu___2 = end_of_range r in json_of_range_fields uu___ uu___1 uu___2
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Const.ml b/src/ocaml-output/FStar_Const.ml
deleted file mode 100644
index 11179b4b695..00000000000
--- a/src/ocaml-output/FStar_Const.ml
+++ /dev/null
@@ -1,144 +0,0 @@
-open Prims
-type signedness =
-  | Unsigned 
-  | Signed [@@deriving yojson,show]
-let (uu___is_Unsigned : signedness -> Prims.bool) =
-  fun projectee -> match projectee with | Unsigned -> true | uu___ -> false
-let (uu___is_Signed : signedness -> Prims.bool) =
-  fun projectee -> match projectee with | Signed -> true | uu___ -> false
-type width =
-  | Int8 
-  | Int16 
-  | Int32 
-  | Int64 
-  | Sizet [@@deriving yojson,show]
-let (uu___is_Int8 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int8 -> true | uu___ -> false
-let (uu___is_Int16 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int16 -> true | uu___ -> false
-let (uu___is_Int32 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int32 -> true | uu___ -> false
-let (uu___is_Int64 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int64 -> true | uu___ -> false
-let (uu___is_Sizet : width -> Prims.bool) =
-  fun projectee -> match projectee with | Sizet -> true | uu___ -> false
-type sconst =
-  | Const_effect 
-  | Const_unit 
-  | Const_bool of Prims.bool 
-  | Const_int of (Prims.string * (signedness * width)
-  FStar_Pervasives_Native.option) 
-  | Const_char of FStar_BaseTypes.char 
-  | Const_real of Prims.string 
-  | Const_string of (Prims.string * FStar_Compiler_Range.range) 
-  | Const_range_of 
-  | Const_set_range_of 
-  | Const_range of FStar_Compiler_Range.range 
-  | Const_reify 
-  | Const_reflect of FStar_Ident.lid [@@deriving yojson,show]
-let (uu___is_Const_effect : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_effect -> true | uu___ -> false
-let (uu___is_Const_unit : sconst -> Prims.bool) =
-  fun projectee -> match projectee with | Const_unit -> true | uu___ -> false
-let (uu___is_Const_bool : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_bool _0 -> true | uu___ -> false
-let (__proj__Const_bool__item___0 : sconst -> Prims.bool) =
-  fun projectee -> match projectee with | Const_bool _0 -> _0
-let (uu___is_Const_int : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_int _0 -> true | uu___ -> false
-let (__proj__Const_int__item___0 :
-  sconst ->
-    (Prims.string * (signedness * width) FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Const_int _0 -> _0
-let (uu___is_Const_char : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_char _0 -> true | uu___ -> false
-let (__proj__Const_char__item___0 : sconst -> FStar_BaseTypes.char) =
-  fun projectee -> match projectee with | Const_char _0 -> _0
-let (uu___is_Const_real : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_real _0 -> true | uu___ -> false
-let (__proj__Const_real__item___0 : sconst -> Prims.string) =
-  fun projectee -> match projectee with | Const_real _0 -> _0
-let (uu___is_Const_string : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_string _0 -> true | uu___ -> false
-let (__proj__Const_string__item___0 :
-  sconst -> (Prims.string * FStar_Compiler_Range.range)) =
-  fun projectee -> match projectee with | Const_string _0 -> _0
-let (uu___is_Const_range_of : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_range_of -> true | uu___ -> false
-let (uu___is_Const_set_range_of : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_set_range_of -> true | uu___ -> false
-let (uu___is_Const_range : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_range _0 -> true | uu___ -> false
-let (__proj__Const_range__item___0 : sconst -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | Const_range _0 -> _0
-let (uu___is_Const_reify : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_reify -> true | uu___ -> false
-let (uu___is_Const_reflect : sconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Const_reflect _0 -> true | uu___ -> false
-let (__proj__Const_reflect__item___0 : sconst -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Const_reflect _0 -> _0
-let (eq_const : sconst -> sconst -> Prims.bool) =
-  fun c1 ->
-    fun c2 ->
-      match (c1, c2) with
-      | (Const_int (s1, o1), Const_int (s2, o2)) ->
-          (let uu___ = FStar_Compiler_Util.ensure_decimal s1 in
-           let uu___1 = FStar_Compiler_Util.ensure_decimal s2 in
-           uu___ = uu___1) && (o1 = o2)
-      | (Const_string (a, uu___), Const_string (b, uu___1)) -> a = b
-      | (Const_reflect l1, Const_reflect l2) -> FStar_Ident.lid_equals l1 l2
-      | uu___ -> c1 = c2
-let rec (pow2 : FStar_BigInt.bigint -> FStar_BigInt.bigint) =
-  fun x ->
-    let uu___ = FStar_BigInt.eq_big_int x FStar_BigInt.zero in
-    if uu___
-    then FStar_BigInt.one
-    else
-      (let uu___2 = let uu___3 = FStar_BigInt.pred_big_int x in pow2 uu___3 in
-       FStar_BigInt.mult_big_int FStar_BigInt.two uu___2)
-let (bounds :
-  signedness -> width -> (FStar_BigInt.bigint * FStar_BigInt.bigint)) =
-  fun signedness1 ->
-    fun width1 ->
-      let n =
-        match width1 with
-        | Int8 -> FStar_BigInt.big_int_of_string "8"
-        | Int16 -> FStar_BigInt.big_int_of_string "16"
-        | Int32 -> FStar_BigInt.big_int_of_string "32"
-        | Int64 -> FStar_BigInt.big_int_of_string "64"
-        | Sizet -> FStar_BigInt.big_int_of_string "16" in
-      let uu___ =
-        match signedness1 with
-        | Unsigned ->
-            let uu___1 =
-              let uu___2 = pow2 n in FStar_BigInt.pred_big_int uu___2 in
-            (FStar_BigInt.zero, uu___1)
-        | Signed ->
-            let upper =
-              let uu___1 = FStar_BigInt.pred_big_int n in pow2 uu___1 in
-            let uu___1 = FStar_BigInt.minus_big_int upper in
-            let uu___2 = FStar_BigInt.pred_big_int upper in (uu___1, uu___2) in
-      match uu___ with | (lower, upper) -> (lower, upper)
-let (within_bounds : Prims.string -> signedness -> width -> Prims.bool) =
-  fun repr ->
-    fun signedness1 ->
-      fun width1 ->
-        let uu___ = bounds signedness1 width1 in
-        match uu___ with
-        | (lower, upper) ->
-            let value =
-              let uu___1 = FStar_Compiler_Util.ensure_decimal repr in
-              FStar_BigInt.big_int_of_string uu___1 in
-            (FStar_BigInt.le_big_int lower value) &&
-              (FStar_BigInt.le_big_int value upper)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Dependencies.ml b/src/ocaml-output/FStar_Dependencies.ml
deleted file mode 100644
index 67656ba584d..00000000000
--- a/src/ocaml-output/FStar_Dependencies.ml
+++ /dev/null
@@ -1,19 +0,0 @@
-open Prims
-let (find_deps_if_needed :
-  Prims.string Prims.list ->
-    (Prims.string ->
-       FStar_Parser_Dep.parsing_data FStar_Pervasives_Native.option)
-      -> (Prims.string Prims.list * FStar_Parser_Dep.deps))
-  =
-  fun files ->
-    fun get_parsing_data_from_cache ->
-      let uu___ = FStar_Parser_Dep.collect files get_parsing_data_from_cache in
-      match uu___ with
-      | (all_files, deps) ->
-          (match all_files with
-           | [] ->
-               (FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                  (FStar_Errors.Error_DependencyAnalysisFailed,
-                    "Dependency analysis failed; reverting to using only the files provided\n");
-                (files, deps))
-           | uu___1 -> ((FStar_Compiler_List.rev all_files), deps))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Errors.ml b/src/ocaml-output/FStar_Errors.ml
deleted file mode 100644
index 0e4eca86669..00000000000
--- a/src/ocaml-output/FStar_Errors.ml
+++ /dev/null
@@ -1,3032 +0,0 @@
-open Prims
-exception Invalid_warn_error_setting of Prims.string 
-let (uu___is_Invalid_warn_error_setting : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Invalid_warn_error_setting uu___ -> true
-    | uu___ -> false
-let (__proj__Invalid_warn_error_setting__item__uu___ :
-  Prims.exn -> Prims.string) =
-  fun projectee ->
-    match projectee with | Invalid_warn_error_setting uu___ -> uu___
-type error_flag =
-  | CFatal 
-  | CAlwaysError 
-  | CError 
-  | CWarning 
-  | CSilent 
-let (uu___is_CFatal : error_flag -> Prims.bool) =
-  fun projectee -> match projectee with | CFatal -> true | uu___ -> false
-let (uu___is_CAlwaysError : error_flag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CAlwaysError -> true | uu___ -> false
-let (uu___is_CError : error_flag -> Prims.bool) =
-  fun projectee -> match projectee with | CError -> true | uu___ -> false
-let (uu___is_CWarning : error_flag -> Prims.bool) =
-  fun projectee -> match projectee with | CWarning -> true | uu___ -> false
-let (uu___is_CSilent : error_flag -> Prims.bool) =
-  fun projectee -> match projectee with | CSilent -> true | uu___ -> false
-type raw_error =
-  | Error_DependencyAnalysisFailed 
-  | Error_IDETooManyPops 
-  | Error_IDEUnrecognized 
-  | Error_InductiveTypeNotSatisfyPositivityCondition 
-  | Error_InvalidUniverseVar 
-  | Error_MissingFileName 
-  | Error_ModuleFileNameMismatch 
-  | Error_OpPlusInUniverse 
-  | Error_OutOfRange 
-  | Error_ProofObligationFailed 
-  | Error_TooManyFiles 
-  | Error_TypeCheckerFailToProve 
-  | Error_TypeError 
-  | Error_UncontrainedUnificationVar 
-  | Error_UnexpectedGTotComputation 
-  | Error_UnexpectedInstance 
-  | Error_UnknownFatal_AssertionFailure 
-  | Error_Z3InvocationError 
-  | Error_IDEAssertionFailure 
-  | Error_Z3SolverError 
-  | Fatal_AbstractTypeDeclarationInInterface 
-  | Fatal_ActionMustHaveFunctionType 
-  | Fatal_AlreadyDefinedTopLevelDeclaration 
-  | Fatal_ArgumentLengthMismatch 
-  | Fatal_AssertionFailure 
-  | Fatal_AssignToImmutableValues 
-  | Fatal_AssumeValInInterface 
-  | Fatal_BadlyInstantiatedSynthByTactic 
-  | Fatal_BadSignatureShape 
-  | Fatal_BinderAndArgsLengthMismatch 
-  | Fatal_BothValAndLetInInterface 
-  | Fatal_CardinalityConstraintViolated 
-  | Fatal_ComputationNotTotal 
-  | Fatal_ComputationTypeNotAllowed 
-  | Fatal_ComputedTypeNotMatchAnnotation 
-  | Fatal_ConstructorArgLengthMismatch 
-  | Fatal_ConstructorFailedCheck 
-  | Fatal_ConstructorNotFound 
-  | Fatal_ConstsructorBuildWrongType 
-  | Fatal_CycleInRecTypeAbbreviation 
-  | Fatal_DataContructorNotFound 
-  | Fatal_DefaultQualifierNotAllowedOnEffects 
-  | Fatal_DefinitionNotFound 
-  | Fatal_DisjuctivePatternVarsMismatch 
-  | Fatal_DivergentComputationCannotBeIncludedInTotal 
-  | Fatal_DuplicateInImplementation 
-  | Fatal_DuplicateModuleOrInterface 
-  | Fatal_DuplicateTopLevelNames 
-  | Fatal_DuplicateTypeAnnotationAndValDecl 
-  | Fatal_EffectCannotBeReified 
-  | Fatal_EffectConstructorNotFullyApplied 
-  | Fatal_EffectfulAndPureComputationMismatch 
-  | Fatal_EffectNotFound 
-  | Fatal_EffectsCannotBeComposed 
-  | Fatal_ErrorInSolveDeferredConstraints 
-  | Fatal_ErrorsReported 
-  | Fatal_EscapedBoundVar 
-  | Fatal_ExpectedArrowAnnotatedType 
-  | Fatal_ExpectedGhostExpression 
-  | Fatal_ExpectedPureExpression 
-  | Fatal_ExpectNormalizedEffect 
-  | Fatal_ExpectTermGotFunction 
-  | Fatal_ExpectTrivialPreCondition 
-  | Fatal_FailToCompileNativeTactic 
-  | Fatal_FailToExtractNativeTactic 
-  | Fatal_FailToProcessPragma 
-  | Fatal_FailToResolveImplicitArgument 
-  | Fatal_FailToSolveUniverseInEquality 
-  | Fatal_FieldsNotBelongToSameRecordType 
-  | Fatal_ForbiddenReferenceToCurrentModule 
-  | Fatal_FreeVariables 
-  | Fatal_FunctionTypeExpected 
-  | Fatal_IdentifierNotFound 
-  | Fatal_IllAppliedConstant 
-  | Fatal_IllegalCharInByteArray 
-  | Fatal_IllegalCharInOperatorName 
-  | Fatal_IllTyped 
-  | Fatal_ImpossibleAbbrevLidBundle 
-  | Fatal_ImpossibleAbbrevRenameBundle 
-  | Fatal_ImpossibleInductiveWithAbbrev 
-  | Fatal_ImpossiblePrePostAbs 
-  | Fatal_ImpossiblePrePostArrow 
-  | Fatal_ImpossibleToGenerateDMEffect 
-  | Fatal_ImpossibleTypeAbbrevBundle 
-  | Fatal_ImpossibleTypeAbbrevSigeltBundle 
-  | Fatal_IncludeModuleNotPrepared 
-  | Fatal_IncoherentInlineUniverse 
-  | Fatal_IncompatibleKinds 
-  | Fatal_IncompatibleNumberOfTypes 
-  | Fatal_IncompatibleSetOfUniverse 
-  | Fatal_IncompatibleUniverse 
-  | Fatal_InconsistentImplicitArgumentAnnotation 
-  | Fatal_InconsistentImplicitQualifier 
-  | Fatal_InconsistentQualifierAnnotation 
-  | Fatal_InferredTypeCauseVarEscape 
-  | Fatal_InlineRenamedAsUnfold 
-  | Fatal_InsufficientPatternArguments 
-  | Fatal_InterfaceAlreadyProcessed 
-  | Fatal_InterfaceNotImplementedByModule 
-  | Fatal_InterfaceWithTypeImplementation 
-  | Fatal_InvalidFloatingPointNumber 
-  | Fatal_InvalidFSDocKeyword 
-  | Fatal_InvalidIdentifier 
-  | Fatal_InvalidLemmaArgument 
-  | Fatal_InvalidNumericLiteral 
-  | Fatal_InvalidRedefinitionOfLexT 
-  | Fatal_InvalidUnicodeInStringLiteral 
-  | Fatal_InvalidUTF8Encoding 
-  | Fatal_InvalidWarnErrorSetting 
-  | Fatal_LetBoundMonadicMismatch 
-  | Fatal_LetMutableForVariablesOnly 
-  | Fatal_LetOpenModuleOnly 
-  | Fatal_LetRecArgumentMismatch 
-  | Fatal_MalformedActionDeclaration 
-  | Fatal_MismatchedPatternType 
-  | Fatal_MismatchUniversePolymorphic 
-  | Fatal_MissingDataConstructor 
-  | Fatal_MissingExposeInterfacesOption 
-  | Fatal_MissingFieldInRecord 
-  | Fatal_MissingImplementation 
-  | Fatal_MissingImplicitArguments 
-  | Fatal_MissingInterface 
-  | Fatal_MissingNameInBinder 
-  | Fatal_MissingPrimsModule 
-  | Fatal_MissingQuantifierBinder 
-  | Fatal_ModuleExpected 
-  | Fatal_ModuleFileNotFound 
-  | Fatal_ModuleFirstStatement 
-  | Fatal_ModuleNotFound 
-  | Fatal_ModuleOrFileNotFound 
-  | Fatal_MonadAlreadyDefined 
-  | Fatal_MoreThanOneDeclaration 
-  | Fatal_MultipleLetBinding 
-  | Fatal_NameNotFound 
-  | Fatal_NameSpaceNotFound 
-  | Fatal_NegativeUniverseConstFatal_NotSupported 
-  | Fatal_NoFileProvided 
-  | Fatal_NonInductiveInMutuallyDefinedType 
-  | Fatal_NonLinearPatternNotPermitted 
-  | Fatal_NonLinearPatternVars 
-  | Fatal_NonSingletonTopLevel 
-  | Fatal_NonSingletonTopLevelModule 
-  | Error_NonTopRecFunctionNotFullyEncoded 
-  | Fatal_NonTrivialPreConditionInPrims 
-  | Fatal_NonVariableInductiveTypeParameter 
-  | Fatal_NotApplicationOrFv 
-  | Fatal_NotEnoughArgsToEffect 
-  | Fatal_NotEnoughArgumentsForEffect 
-  | Fatal_NotFunctionType 
-  | Fatal_NotSupported 
-  | Fatal_NotTopLevelModule 
-  | Fatal_NotValidFStarFile 
-  | Fatal_NotValidIncludeDirectory 
-  | Fatal_OneModulePerFile 
-  | Fatal_OpenGoalsInSynthesis 
-  | Fatal_OptionsNotCompatible 
-  | Fatal_OutOfOrder 
-  | Fatal_ParseErrors 
-  | Fatal_ParseItError 
-  | Fatal_PolyTypeExpected 
-  | Fatal_PossibleInfiniteTyp 
-  | Fatal_PreModuleMismatch 
-  | Fatal_QulifierListNotPermitted 
-  | Fatal_RecursiveFunctionLiteral 
-  | Fatal_ReflectOnlySupportedOnEffects 
-  | Fatal_ReservedPrefix 
-  | Fatal_SMTOutputParseError 
-  | Fatal_SMTSolverError 
-  | Fatal_SyntaxError 
-  | Fatal_SynthByTacticError 
-  | Fatal_TacticGotStuck 
-  | Fatal_TcOneFragmentFailed 
-  | Fatal_TermOutsideOfDefLanguage 
-  | Fatal_ToManyArgumentToFunction 
-  | Fatal_TooManyOrTooFewFileMatch 
-  | Fatal_TooManyPatternArguments 
-  | Fatal_TooManyUniverse 
-  | Fatal_TypeMismatch 
-  | Fatal_TypeWithinPatternsAllowedOnVariablesOnly 
-  | Fatal_UnableToReadFile 
-  | Fatal_UnepxectedOrUnboundOperator 
-  | Fatal_UnexpectedBinder 
-  | Fatal_UnexpectedBindShape 
-  | Fatal_UnexpectedChar 
-  | Fatal_UnexpectedComputationTypeForLetRec 
-  | Fatal_UnexpectedConstructorType 
-  | Fatal_UnexpectedDataConstructor 
-  | Fatal_UnexpectedEffect 
-  | Fatal_UnexpectedEmptyRecord 
-  | Fatal_UnexpectedExpressionType 
-  | Fatal_UnexpectedFunctionParameterType 
-  | Fatal_UnexpectedGeneralizedUniverse 
-  | Fatal_UnexpectedGTotForLetRec 
-  | Fatal_UnexpectedGuard 
-  | Fatal_UnexpectedIdentifier 
-  | Fatal_UnexpectedImplicitArgument 
-  | Fatal_UnexpectedImplictArgument 
-  | Fatal_UnexpectedInductivetype 
-  | Fatal_UnexpectedLetBinding 
-  | Fatal_UnexpectedModuleDeclaration 
-  | Fatal_UnexpectedNumberOfUniverse 
-  | Fatal_UnexpectedNumericLiteral 
-  | Fatal_UnexpectedPattern 
-  | Fatal_UnexpectedPosition 
-  | Fatal_UnExpectedPreCondition 
-  | Fatal_UnexpectedReturnShape 
-  | Fatal_UnexpectedSignatureForMonad 
-  | Fatal_UnexpectedTerm 
-  | Fatal_UnexpectedTermInUniverse 
-  | Fatal_UnexpectedTermType 
-  | Fatal_UnexpectedTermVQuote 
-  | Fatal_UnexpectedUniversePolymorphicReturn 
-  | Fatal_UnexpectedUniverseVariable 
-  | Fatal_UnfoldableDeprecated 
-  | Fatal_UnificationNotWellFormed 
-  | Fatal_Uninstantiated 
-  | Error_UninstantiatedUnificationVarInTactic 
-  | Fatal_UninstantiatedVarInTactic 
-  | Fatal_UniverseMightContainSumOfTwoUnivVars 
-  | Fatal_UniversePolymorphicInnerLetBound 
-  | Fatal_UnknownAttribute 
-  | Fatal_UnknownToolForDep 
-  | Fatal_UnrecognizedExtension 
-  | Fatal_UnresolvedPatternVar 
-  | Fatal_UnsupportedConstant 
-  | Fatal_UnsupportedDisjuctivePatterns 
-  | Fatal_UnsupportedQualifier 
-  | Fatal_UserTacticFailure 
-  | Fatal_ValueRestriction 
-  | Fatal_VariableNotFound 
-  | Fatal_WrongBodyTypeForReturnWP 
-  | Fatal_WrongDataAppHeadFormat 
-  | Fatal_WrongDefinitionOrder 
-  | Fatal_WrongResultTypeAfterConstrutor 
-  | Fatal_WrongTerm 
-  | Fatal_WhenClauseNotSupported 
-  | Unused01 
-  | Warning_AddImplicitAssumeNewQualifier 
-  | Warning_AdmitWithoutDefinition 
-  | Warning_CachedFile 
-  | Warning_DefinitionNotTranslated 
-  | Warning_DependencyFound 
-  | Warning_DeprecatedEqualityOnBinder 
-  | Warning_DeprecatedOpaqueQualifier 
-  | Warning_DocOverwrite 
-  | Warning_FileNotWritten 
-  | Warning_Filtered 
-  | Warning_FunctionLiteralPrecisionLoss 
-  | Warning_FunctionNotExtacted 
-  | Warning_HintFailedToReplayProof 
-  | Warning_HitReplayFailed 
-  | Warning_IDEIgnoreCodeGen 
-  | Warning_IllFormedGoal 
-  | Warning_InaccessibleArgument 
-  | Warning_IncoherentImplicitQualifier 
-  | Warning_IrrelevantQualifierOnArgumentToReflect 
-  | Warning_IrrelevantQualifierOnArgumentToReify 
-  | Warning_MalformedWarnErrorList 
-  | Warning_MetaAlienNotATmUnknown 
-  | Warning_MultipleAscriptions 
-  | Warning_NondependentUserDefinedDataType 
-  | Warning_NonListLiteralSMTPattern 
-  | Warning_NormalizationFailure 
-  | Warning_NotDependentArrow 
-  | Warning_NotEmbedded 
-  | Warning_PatternMissingBoundVar 
-  | Warning_RecursiveDependency 
-  | Warning_RedundantExplicitCurrying 
-  | Warning_SMTPatTDeprecated 
-  | Warning_SMTPatternIllFormed 
-  | Warning_TopLevelEffect 
-  | Warning_UnboundModuleReference 
-  | Warning_UnexpectedFile 
-  | Warning_UnexpectedFsTypApp 
-  | Warning_UnexpectedZ3Output 
-  | Warning_UnprotectedTerm 
-  | Warning_UnrecognizedAttribute 
-  | Warning_UpperBoundCandidateAlreadyVisited 
-  | Warning_UseDefaultEffect 
-  | Warning_WrongErrorLocation 
-  | Warning_Z3InvocationWarning 
-  | Warning_PluginNotImplemented 
-  | Warning_MissingInterfaceOrImplementation 
-  | Warning_ConstructorBuildsUnexpectedType 
-  | Warning_ModuleOrFileNotFoundWarning 
-  | Error_NoLetMutable 
-  | Error_BadImplicit 
-  | Warning_DeprecatedDefinition 
-  | Fatal_SMTEncodingArityMismatch 
-  | Warning_Defensive 
-  | Warning_CantInspect 
-  | Warning_NilGivenExplicitArgs 
-  | Warning_ConsAppliedExplicitArgs 
-  | Warning_UnembedBinderKnot 
-  | Fatal_TacticProofRelevantGoal 
-  | Warning_TacAdmit 
-  | Fatal_IncoherentPatterns 
-  | Error_NoSMTButNeeded 
-  | Fatal_UnexpectedAntiquotation 
-  | Fatal_SplicedUndef 
-  | Fatal_SpliceUnembedFail 
-  | Warning_ExtractionUnexpectedEffect 
-  | Error_DidNotFail 
-  | Warning_UnappliedFail 
-  | Warning_QuantifierWithoutPattern 
-  | Error_EmptyFailErrs 
-  | Warning_logicqualifier 
-  | Fatal_CyclicDependence 
-  | Error_InductiveAnnotNotAType 
-  | Fatal_FriendInterface 
-  | Error_CannotRedefineConst 
-  | Error_BadClassDecl 
-  | Error_BadInductiveParam 
-  | Error_FieldShadow 
-  | Error_UnexpectedDM4FType 
-  | Fatal_EffectAbbreviationResultTypeMismatch 
-  | Error_AlreadyCachedAssertionFailure 
-  | Error_MustEraseMissing 
-  | Warning_EffectfulArgumentToErasedFunction 
-  | Fatal_EmptySurfaceLet 
-  | Warning_UnexpectedCheckedFile 
-  | Fatal_ExtractionUnsupported 
-  | Warning_SMTErrorReason 
-  | Warning_CoercionNotFound 
-  | Error_QuakeFailed 
-  | Error_IllSMTPat 
-  | Error_IllScopedTerm 
-  | Warning_UnusedLetRec 
-  | Fatal_Effects_Ordering_Coherence 
-  | Warning_BleedingEdge_Feature 
-  | Warning_IgnoredBinding 
-  | Warning_CouldNotReadHints 
-  | Fatal_BadUvar 
-  | Warning_WarnOnUse 
-  | Warning_DeprecatedAttributeSyntax 
-  | Warning_DeprecatedGeneric 
-  | Error_BadSplice 
-  | Error_UnexpectedUnresolvedUvar 
-  | Warning_UnfoldPlugin 
-  | Error_LayeredMissingAnnot 
-  | Error_CallToErased 
-  | Error_ErasedCtor 
-  | Error_RemoveUnusedTypeParameter 
-  | Warning_NoMagicInFSharp 
-  | Error_BadLetOpenRecord 
-  | Error_UnexpectedTypeclassInstance 
-  | Warning_AmbiguousResolveImplicitsHook 
-  | Warning_SplitAndRetryQueries 
-  | Warning_DeprecatedLightDoNotation 
-  | Warning_FailedToCheckInitialTacticGoal 
-  | Warning_Adhoc_IndexedEffect_Combinator 
-let (uu___is_Error_DependencyAnalysisFailed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_DependencyAnalysisFailed -> true
-    | uu___ -> false
-let (uu___is_Error_IDETooManyPops : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_IDETooManyPops -> true | uu___ -> false
-let (uu___is_Error_IDEUnrecognized : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_IDEUnrecognized -> true | uu___ -> false
-let (uu___is_Error_InductiveTypeNotSatisfyPositivityCondition :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_InductiveTypeNotSatisfyPositivityCondition -> true
-    | uu___ -> false
-let (uu___is_Error_InvalidUniverseVar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_InvalidUniverseVar -> true | uu___ -> false
-let (uu___is_Error_MissingFileName : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_MissingFileName -> true | uu___ -> false
-let (uu___is_Error_ModuleFileNameMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_ModuleFileNameMismatch -> true
-    | uu___ -> false
-let (uu___is_Error_OpPlusInUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_OpPlusInUniverse -> true | uu___ -> false
-let (uu___is_Error_OutOfRange : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_OutOfRange -> true | uu___ -> false
-let (uu___is_Error_ProofObligationFailed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_ProofObligationFailed -> true
-    | uu___ -> false
-let (uu___is_Error_TooManyFiles : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_TooManyFiles -> true | uu___ -> false
-let (uu___is_Error_TypeCheckerFailToProve : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_TypeCheckerFailToProve -> true
-    | uu___ -> false
-let (uu___is_Error_TypeError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_TypeError -> true | uu___ -> false
-let (uu___is_Error_UncontrainedUnificationVar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_UncontrainedUnificationVar -> true
-    | uu___ -> false
-let (uu___is_Error_UnexpectedGTotComputation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_UnexpectedGTotComputation -> true
-    | uu___ -> false
-let (uu___is_Error_UnexpectedInstance : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_UnexpectedInstance -> true | uu___ -> false
-let (uu___is_Error_UnknownFatal_AssertionFailure : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_UnknownFatal_AssertionFailure -> true
-    | uu___ -> false
-let (uu___is_Error_Z3InvocationError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_Z3InvocationError -> true | uu___ -> false
-let (uu___is_Error_IDEAssertionFailure : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_IDEAssertionFailure -> true | uu___ -> false
-let (uu___is_Error_Z3SolverError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_Z3SolverError -> true | uu___ -> false
-let (uu___is_Fatal_AbstractTypeDeclarationInInterface :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_AbstractTypeDeclarationInInterface -> true
-    | uu___ -> false
-let (uu___is_Fatal_ActionMustHaveFunctionType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ActionMustHaveFunctionType -> true
-    | uu___ -> false
-let (uu___is_Fatal_AlreadyDefinedTopLevelDeclaration :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_AlreadyDefinedTopLevelDeclaration -> true
-    | uu___ -> false
-let (uu___is_Fatal_ArgumentLengthMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ArgumentLengthMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_AssertionFailure : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_AssertionFailure -> true | uu___ -> false
-let (uu___is_Fatal_AssignToImmutableValues : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_AssignToImmutableValues -> true
-    | uu___ -> false
-let (uu___is_Fatal_AssumeValInInterface : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_AssumeValInInterface -> true
-    | uu___ -> false
-let (uu___is_Fatal_BadlyInstantiatedSynthByTactic : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_BadlyInstantiatedSynthByTactic -> true
-    | uu___ -> false
-let (uu___is_Fatal_BadSignatureShape : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_BadSignatureShape -> true | uu___ -> false
-let (uu___is_Fatal_BinderAndArgsLengthMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_BinderAndArgsLengthMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_BothValAndLetInInterface : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_BothValAndLetInInterface -> true
-    | uu___ -> false
-let (uu___is_Fatal_CardinalityConstraintViolated : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_CardinalityConstraintViolated -> true
-    | uu___ -> false
-let (uu___is_Fatal_ComputationNotTotal : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ComputationNotTotal -> true | uu___ -> false
-let (uu___is_Fatal_ComputationTypeNotAllowed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ComputationTypeNotAllowed -> true
-    | uu___ -> false
-let (uu___is_Fatal_ComputedTypeNotMatchAnnotation : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_ComputedTypeNotMatchAnnotation -> true
-    | uu___ -> false
-let (uu___is_Fatal_ConstructorArgLengthMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ConstructorArgLengthMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_ConstructorFailedCheck : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ConstructorFailedCheck -> true
-    | uu___ -> false
-let (uu___is_Fatal_ConstructorNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ConstructorNotFound -> true | uu___ -> false
-let (uu___is_Fatal_ConstsructorBuildWrongType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ConstsructorBuildWrongType -> true
-    | uu___ -> false
-let (uu___is_Fatal_CycleInRecTypeAbbreviation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_CycleInRecTypeAbbreviation -> true
-    | uu___ -> false
-let (uu___is_Fatal_DataContructorNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DataContructorNotFound -> true
-    | uu___ -> false
-let (uu___is_Fatal_DefaultQualifierNotAllowedOnEffects :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DefaultQualifierNotAllowedOnEffects -> true
-    | uu___ -> false
-let (uu___is_Fatal_DefinitionNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_DefinitionNotFound -> true | uu___ -> false
-let (uu___is_Fatal_DisjuctivePatternVarsMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DisjuctivePatternVarsMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_DivergentComputationCannotBeIncludedInTotal :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DivergentComputationCannotBeIncludedInTotal -> true
-    | uu___ -> false
-let (uu___is_Fatal_DuplicateInImplementation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DuplicateInImplementation -> true
-    | uu___ -> false
-let (uu___is_Fatal_DuplicateModuleOrInterface : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DuplicateModuleOrInterface -> true
-    | uu___ -> false
-let (uu___is_Fatal_DuplicateTopLevelNames : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DuplicateTopLevelNames -> true
-    | uu___ -> false
-let (uu___is_Fatal_DuplicateTypeAnnotationAndValDecl :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_DuplicateTypeAnnotationAndValDecl -> true
-    | uu___ -> false
-let (uu___is_Fatal_EffectCannotBeReified : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_EffectCannotBeReified -> true
-    | uu___ -> false
-let (uu___is_Fatal_EffectConstructorNotFullyApplied :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_EffectConstructorNotFullyApplied -> true
-    | uu___ -> false
-let (uu___is_Fatal_EffectfulAndPureComputationMismatch :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_EffectfulAndPureComputationMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_EffectNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_EffectNotFound -> true | uu___ -> false
-let (uu___is_Fatal_EffectsCannotBeComposed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_EffectsCannotBeComposed -> true
-    | uu___ -> false
-let (uu___is_Fatal_ErrorInSolveDeferredConstraints : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_ErrorInSolveDeferredConstraints -> true
-    | uu___ -> false
-let (uu___is_Fatal_ErrorsReported : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ErrorsReported -> true | uu___ -> false
-let (uu___is_Fatal_EscapedBoundVar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_EscapedBoundVar -> true | uu___ -> false
-let (uu___is_Fatal_ExpectedArrowAnnotatedType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExpectedArrowAnnotatedType -> true
-    | uu___ -> false
-let (uu___is_Fatal_ExpectedGhostExpression : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExpectedGhostExpression -> true
-    | uu___ -> false
-let (uu___is_Fatal_ExpectedPureExpression : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExpectedPureExpression -> true
-    | uu___ -> false
-let (uu___is_Fatal_ExpectNormalizedEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExpectNormalizedEffect -> true
-    | uu___ -> false
-let (uu___is_Fatal_ExpectTermGotFunction : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExpectTermGotFunction -> true
-    | uu___ -> false
-let (uu___is_Fatal_ExpectTrivialPreCondition : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExpectTrivialPreCondition -> true
-    | uu___ -> false
-let (uu___is_Fatal_FailToCompileNativeTactic : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_FailToCompileNativeTactic -> true
-    | uu___ -> false
-let (uu___is_Fatal_FailToExtractNativeTactic : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_FailToExtractNativeTactic -> true
-    | uu___ -> false
-let (uu___is_Fatal_FailToProcessPragma : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_FailToProcessPragma -> true | uu___ -> false
-let (uu___is_Fatal_FailToResolveImplicitArgument : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_FailToResolveImplicitArgument -> true
-    | uu___ -> false
-let (uu___is_Fatal_FailToSolveUniverseInEquality : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_FailToSolveUniverseInEquality -> true
-    | uu___ -> false
-let (uu___is_Fatal_FieldsNotBelongToSameRecordType : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_FieldsNotBelongToSameRecordType -> true
-    | uu___ -> false
-let (uu___is_Fatal_ForbiddenReferenceToCurrentModule :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ForbiddenReferenceToCurrentModule -> true
-    | uu___ -> false
-let (uu___is_Fatal_FreeVariables : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_FreeVariables -> true | uu___ -> false
-let (uu___is_Fatal_FunctionTypeExpected : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_FunctionTypeExpected -> true
-    | uu___ -> false
-let (uu___is_Fatal_IdentifierNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_IdentifierNotFound -> true | uu___ -> false
-let (uu___is_Fatal_IllAppliedConstant : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_IllAppliedConstant -> true | uu___ -> false
-let (uu___is_Fatal_IllegalCharInByteArray : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IllegalCharInByteArray -> true
-    | uu___ -> false
-let (uu___is_Fatal_IllegalCharInOperatorName : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IllegalCharInOperatorName -> true
-    | uu___ -> false
-let (uu___is_Fatal_IllTyped : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_IllTyped -> true | uu___ -> false
-let (uu___is_Fatal_ImpossibleAbbrevLidBundle : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossibleAbbrevLidBundle -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossibleAbbrevRenameBundle : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossibleAbbrevRenameBundle -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossibleInductiveWithAbbrev : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossibleInductiveWithAbbrev -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossiblePrePostAbs : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossiblePrePostAbs -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossiblePrePostArrow : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossiblePrePostArrow -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossibleToGenerateDMEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossibleToGenerateDMEffect -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossibleTypeAbbrevBundle : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossibleTypeAbbrevBundle -> true
-    | uu___ -> false
-let (uu___is_Fatal_ImpossibleTypeAbbrevSigeltBundle :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ImpossibleTypeAbbrevSigeltBundle -> true
-    | uu___ -> false
-let (uu___is_Fatal_IncludeModuleNotPrepared : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IncludeModuleNotPrepared -> true
-    | uu___ -> false
-let (uu___is_Fatal_IncoherentInlineUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IncoherentInlineUniverse -> true
-    | uu___ -> false
-let (uu___is_Fatal_IncompatibleKinds : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_IncompatibleKinds -> true | uu___ -> false
-let (uu___is_Fatal_IncompatibleNumberOfTypes : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IncompatibleNumberOfTypes -> true
-    | uu___ -> false
-let (uu___is_Fatal_IncompatibleSetOfUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IncompatibleSetOfUniverse -> true
-    | uu___ -> false
-let (uu___is_Fatal_IncompatibleUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_IncompatibleUniverse -> true
-    | uu___ -> false
-let (uu___is_Fatal_InconsistentImplicitArgumentAnnotation :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InconsistentImplicitArgumentAnnotation -> true
-    | uu___ -> false
-let (uu___is_Fatal_InconsistentImplicitQualifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InconsistentImplicitQualifier -> true
-    | uu___ -> false
-let (uu___is_Fatal_InconsistentQualifierAnnotation : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_InconsistentQualifierAnnotation -> true
-    | uu___ -> false
-let (uu___is_Fatal_InferredTypeCauseVarEscape : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InferredTypeCauseVarEscape -> true
-    | uu___ -> false
-let (uu___is_Fatal_InlineRenamedAsUnfold : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InlineRenamedAsUnfold -> true
-    | uu___ -> false
-let (uu___is_Fatal_InsufficientPatternArguments : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InsufficientPatternArguments -> true
-    | uu___ -> false
-let (uu___is_Fatal_InterfaceAlreadyProcessed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InterfaceAlreadyProcessed -> true
-    | uu___ -> false
-let (uu___is_Fatal_InterfaceNotImplementedByModule : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_InterfaceNotImplementedByModule -> true
-    | uu___ -> false
-let (uu___is_Fatal_InterfaceWithTypeImplementation : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_InterfaceWithTypeImplementation -> true
-    | uu___ -> false
-let (uu___is_Fatal_InvalidFloatingPointNumber : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InvalidFloatingPointNumber -> true
-    | uu___ -> false
-let (uu___is_Fatal_InvalidFSDocKeyword : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_InvalidFSDocKeyword -> true | uu___ -> false
-let (uu___is_Fatal_InvalidIdentifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_InvalidIdentifier -> true | uu___ -> false
-let (uu___is_Fatal_InvalidLemmaArgument : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InvalidLemmaArgument -> true
-    | uu___ -> false
-let (uu___is_Fatal_InvalidNumericLiteral : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InvalidNumericLiteral -> true
-    | uu___ -> false
-let (uu___is_Fatal_InvalidRedefinitionOfLexT : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InvalidRedefinitionOfLexT -> true
-    | uu___ -> false
-let (uu___is_Fatal_InvalidUnicodeInStringLiteral : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InvalidUnicodeInStringLiteral -> true
-    | uu___ -> false
-let (uu___is_Fatal_InvalidUTF8Encoding : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_InvalidUTF8Encoding -> true | uu___ -> false
-let (uu___is_Fatal_InvalidWarnErrorSetting : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_InvalidWarnErrorSetting -> true
-    | uu___ -> false
-let (uu___is_Fatal_LetBoundMonadicMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_LetBoundMonadicMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_LetMutableForVariablesOnly : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_LetMutableForVariablesOnly -> true
-    | uu___ -> false
-let (uu___is_Fatal_LetOpenModuleOnly : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_LetOpenModuleOnly -> true | uu___ -> false
-let (uu___is_Fatal_LetRecArgumentMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_LetRecArgumentMismatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_MalformedActionDeclaration : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MalformedActionDeclaration -> true
-    | uu___ -> false
-let (uu___is_Fatal_MismatchedPatternType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MismatchedPatternType -> true
-    | uu___ -> false
-let (uu___is_Fatal_MismatchUniversePolymorphic : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MismatchUniversePolymorphic -> true
-    | uu___ -> false
-let (uu___is_Fatal_MissingDataConstructor : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MissingDataConstructor -> true
-    | uu___ -> false
-let (uu___is_Fatal_MissingExposeInterfacesOption : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MissingExposeInterfacesOption -> true
-    | uu___ -> false
-let (uu___is_Fatal_MissingFieldInRecord : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MissingFieldInRecord -> true
-    | uu___ -> false
-let (uu___is_Fatal_MissingImplementation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MissingImplementation -> true
-    | uu___ -> false
-let (uu___is_Fatal_MissingImplicitArguments : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MissingImplicitArguments -> true
-    | uu___ -> false
-let (uu___is_Fatal_MissingInterface : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_MissingInterface -> true | uu___ -> false
-let (uu___is_Fatal_MissingNameInBinder : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_MissingNameInBinder -> true | uu___ -> false
-let (uu___is_Fatal_MissingPrimsModule : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_MissingPrimsModule -> true | uu___ -> false
-let (uu___is_Fatal_MissingQuantifierBinder : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MissingQuantifierBinder -> true
-    | uu___ -> false
-let (uu___is_Fatal_ModuleExpected : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ModuleExpected -> true | uu___ -> false
-let (uu___is_Fatal_ModuleFileNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ModuleFileNotFound -> true | uu___ -> false
-let (uu___is_Fatal_ModuleFirstStatement : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ModuleFirstStatement -> true
-    | uu___ -> false
-let (uu___is_Fatal_ModuleNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ModuleNotFound -> true | uu___ -> false
-let (uu___is_Fatal_ModuleOrFileNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ModuleOrFileNotFound -> true
-    | uu___ -> false
-let (uu___is_Fatal_MonadAlreadyDefined : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_MonadAlreadyDefined -> true | uu___ -> false
-let (uu___is_Fatal_MoreThanOneDeclaration : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_MoreThanOneDeclaration -> true
-    | uu___ -> false
-let (uu___is_Fatal_MultipleLetBinding : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_MultipleLetBinding -> true | uu___ -> false
-let (uu___is_Fatal_NameNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NameNotFound -> true | uu___ -> false
-let (uu___is_Fatal_NameSpaceNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NameSpaceNotFound -> true | uu___ -> false
-let (uu___is_Fatal_NegativeUniverseConstFatal_NotSupported :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NegativeUniverseConstFatal_NotSupported -> true
-    | uu___ -> false
-let (uu___is_Fatal_NoFileProvided : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NoFileProvided -> true | uu___ -> false
-let (uu___is_Fatal_NonInductiveInMutuallyDefinedType :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonInductiveInMutuallyDefinedType -> true
-    | uu___ -> false
-let (uu___is_Fatal_NonLinearPatternNotPermitted : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonLinearPatternNotPermitted -> true
-    | uu___ -> false
-let (uu___is_Fatal_NonLinearPatternVars : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonLinearPatternVars -> true
-    | uu___ -> false
-let (uu___is_Fatal_NonSingletonTopLevel : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonSingletonTopLevel -> true
-    | uu___ -> false
-let (uu___is_Fatal_NonSingletonTopLevelModule : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonSingletonTopLevelModule -> true
-    | uu___ -> false
-let (uu___is_Error_NonTopRecFunctionNotFullyEncoded :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_NonTopRecFunctionNotFullyEncoded -> true
-    | uu___ -> false
-let (uu___is_Fatal_NonTrivialPreConditionInPrims : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonTrivialPreConditionInPrims -> true
-    | uu___ -> false
-let (uu___is_Fatal_NonVariableInductiveTypeParameter :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NonVariableInductiveTypeParameter -> true
-    | uu___ -> false
-let (uu___is_Fatal_NotApplicationOrFv : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NotApplicationOrFv -> true | uu___ -> false
-let (uu___is_Fatal_NotEnoughArgsToEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NotEnoughArgsToEffect -> true
-    | uu___ -> false
-let (uu___is_Fatal_NotEnoughArgumentsForEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NotEnoughArgumentsForEffect -> true
-    | uu___ -> false
-let (uu___is_Fatal_NotFunctionType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NotFunctionType -> true | uu___ -> false
-let (uu___is_Fatal_NotSupported : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NotSupported -> true | uu___ -> false
-let (uu___is_Fatal_NotTopLevelModule : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NotTopLevelModule -> true | uu___ -> false
-let (uu___is_Fatal_NotValidFStarFile : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_NotValidFStarFile -> true | uu___ -> false
-let (uu___is_Fatal_NotValidIncludeDirectory : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_NotValidIncludeDirectory -> true
-    | uu___ -> false
-let (uu___is_Fatal_OneModulePerFile : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_OneModulePerFile -> true | uu___ -> false
-let (uu___is_Fatal_OpenGoalsInSynthesis : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_OpenGoalsInSynthesis -> true
-    | uu___ -> false
-let (uu___is_Fatal_OptionsNotCompatible : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_OptionsNotCompatible -> true
-    | uu___ -> false
-let (uu___is_Fatal_OutOfOrder : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_OutOfOrder -> true | uu___ -> false
-let (uu___is_Fatal_ParseErrors : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ParseErrors -> true | uu___ -> false
-let (uu___is_Fatal_ParseItError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ParseItError -> true | uu___ -> false
-let (uu___is_Fatal_PolyTypeExpected : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_PolyTypeExpected -> true | uu___ -> false
-let (uu___is_Fatal_PossibleInfiniteTyp : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_PossibleInfiniteTyp -> true | uu___ -> false
-let (uu___is_Fatal_PreModuleMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_PreModuleMismatch -> true | uu___ -> false
-let (uu___is_Fatal_QulifierListNotPermitted : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_QulifierListNotPermitted -> true
-    | uu___ -> false
-let (uu___is_Fatal_RecursiveFunctionLiteral : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_RecursiveFunctionLiteral -> true
-    | uu___ -> false
-let (uu___is_Fatal_ReflectOnlySupportedOnEffects : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ReflectOnlySupportedOnEffects -> true
-    | uu___ -> false
-let (uu___is_Fatal_ReservedPrefix : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ReservedPrefix -> true | uu___ -> false
-let (uu___is_Fatal_SMTOutputParseError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_SMTOutputParseError -> true | uu___ -> false
-let (uu___is_Fatal_SMTSolverError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_SMTSolverError -> true | uu___ -> false
-let (uu___is_Fatal_SyntaxError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_SyntaxError -> true | uu___ -> false
-let (uu___is_Fatal_SynthByTacticError : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_SynthByTacticError -> true | uu___ -> false
-let (uu___is_Fatal_TacticGotStuck : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_TacticGotStuck -> true | uu___ -> false
-let (uu___is_Fatal_TcOneFragmentFailed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_TcOneFragmentFailed -> true | uu___ -> false
-let (uu___is_Fatal_TermOutsideOfDefLanguage : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_TermOutsideOfDefLanguage -> true
-    | uu___ -> false
-let (uu___is_Fatal_ToManyArgumentToFunction : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ToManyArgumentToFunction -> true
-    | uu___ -> false
-let (uu___is_Fatal_TooManyOrTooFewFileMatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_TooManyOrTooFewFileMatch -> true
-    | uu___ -> false
-let (uu___is_Fatal_TooManyPatternArguments : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_TooManyPatternArguments -> true
-    | uu___ -> false
-let (uu___is_Fatal_TooManyUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_TooManyUniverse -> true | uu___ -> false
-let (uu___is_Fatal_TypeMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_TypeMismatch -> true | uu___ -> false
-let (uu___is_Fatal_TypeWithinPatternsAllowedOnVariablesOnly :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_TypeWithinPatternsAllowedOnVariablesOnly -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnableToReadFile : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnableToReadFile -> true | uu___ -> false
-let (uu___is_Fatal_UnepxectedOrUnboundOperator : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnepxectedOrUnboundOperator -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedBinder : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedBinder -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedBindShape : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedBindShape -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedChar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedChar -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedComputationTypeForLetRec :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedComputationTypeForLetRec -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedConstructorType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedConstructorType -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedDataConstructor : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedDataConstructor -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedEffect -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedEmptyRecord : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedEmptyRecord -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedExpressionType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedExpressionType -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedFunctionParameterType : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedFunctionParameterType -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedGeneralizedUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedGeneralizedUniverse -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedGTotForLetRec : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedGTotForLetRec -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedGuard : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedGuard -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedIdentifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedIdentifier -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedImplicitArgument : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedImplicitArgument -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedImplictArgument : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedImplictArgument -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedInductivetype : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedInductivetype -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedLetBinding : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedLetBinding -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedModuleDeclaration : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedModuleDeclaration -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedNumberOfUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedNumberOfUniverse -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedNumericLiteral : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedNumericLiteral -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedPattern : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedPattern -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedPosition : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedPosition -> true | uu___ -> false
-let (uu___is_Fatal_UnExpectedPreCondition : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnExpectedPreCondition -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedReturnShape : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedReturnShape -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedSignatureForMonad : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedSignatureForMonad -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedTerm : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedTerm -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedTermInUniverse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedTermInUniverse -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedTermType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnexpectedTermType -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedTermVQuote : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedTermVQuote -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedUniversePolymorphicReturn :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedUniversePolymorphicReturn -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnexpectedUniverseVariable : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedUniverseVariable -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnfoldableDeprecated : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnfoldableDeprecated -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnificationNotWellFormed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnificationNotWellFormed -> true
-    | uu___ -> false
-let (uu___is_Fatal_Uninstantiated : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_Uninstantiated -> true | uu___ -> false
-let (uu___is_Error_UninstantiatedUnificationVarInTactic :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_UninstantiatedUnificationVarInTactic -> true
-    | uu___ -> false
-let (uu___is_Fatal_UninstantiatedVarInTactic : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UninstantiatedVarInTactic -> true
-    | uu___ -> false
-let (uu___is_Fatal_UniverseMightContainSumOfTwoUnivVars :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UniverseMightContainSumOfTwoUnivVars -> true
-    | uu___ -> false
-let (uu___is_Fatal_UniversePolymorphicInnerLetBound :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UniversePolymorphicInnerLetBound -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnknownAttribute : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnknownAttribute -> true | uu___ -> false
-let (uu___is_Fatal_UnknownToolForDep : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnknownToolForDep -> true | uu___ -> false
-let (uu___is_Fatal_UnrecognizedExtension : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnrecognizedExtension -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnresolvedPatternVar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnresolvedPatternVar -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnsupportedConstant : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UnsupportedConstant -> true | uu___ -> false
-let (uu___is_Fatal_UnsupportedDisjuctivePatterns : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnsupportedDisjuctivePatterns -> true
-    | uu___ -> false
-let (uu___is_Fatal_UnsupportedQualifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnsupportedQualifier -> true
-    | uu___ -> false
-let (uu___is_Fatal_UserTacticFailure : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_UserTacticFailure -> true | uu___ -> false
-let (uu___is_Fatal_ValueRestriction : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_ValueRestriction -> true | uu___ -> false
-let (uu___is_Fatal_VariableNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_VariableNotFound -> true | uu___ -> false
-let (uu___is_Fatal_WrongBodyTypeForReturnWP : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_WrongBodyTypeForReturnWP -> true
-    | uu___ -> false
-let (uu___is_Fatal_WrongDataAppHeadFormat : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_WrongDataAppHeadFormat -> true
-    | uu___ -> false
-let (uu___is_Fatal_WrongDefinitionOrder : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_WrongDefinitionOrder -> true
-    | uu___ -> false
-let (uu___is_Fatal_WrongResultTypeAfterConstrutor : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Fatal_WrongResultTypeAfterConstrutor -> true
-    | uu___ -> false
-let (uu___is_Fatal_WrongTerm : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_WrongTerm -> true | uu___ -> false
-let (uu___is_Fatal_WhenClauseNotSupported : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_WhenClauseNotSupported -> true
-    | uu___ -> false
-let (uu___is_Unused01 : raw_error -> Prims.bool) =
-  fun projectee -> match projectee with | Unused01 -> true | uu___ -> false
-let (uu___is_Warning_AddImplicitAssumeNewQualifier : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Warning_AddImplicitAssumeNewQualifier -> true
-    | uu___ -> false
-let (uu___is_Warning_AdmitWithoutDefinition : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_AdmitWithoutDefinition -> true
-    | uu___ -> false
-let (uu___is_Warning_CachedFile : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_CachedFile -> true | uu___ -> false
-let (uu___is_Warning_DefinitionNotTranslated : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_DefinitionNotTranslated -> true
-    | uu___ -> false
-let (uu___is_Warning_DependencyFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_DependencyFound -> true | uu___ -> false
-let (uu___is_Warning_DeprecatedEqualityOnBinder : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_DeprecatedEqualityOnBinder -> true
-    | uu___ -> false
-let (uu___is_Warning_DeprecatedOpaqueQualifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_DeprecatedOpaqueQualifier -> true
-    | uu___ -> false
-let (uu___is_Warning_DocOverwrite : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_DocOverwrite -> true | uu___ -> false
-let (uu___is_Warning_FileNotWritten : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_FileNotWritten -> true | uu___ -> false
-let (uu___is_Warning_Filtered : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_Filtered -> true | uu___ -> false
-let (uu___is_Warning_FunctionLiteralPrecisionLoss : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Warning_FunctionLiteralPrecisionLoss -> true
-    | uu___ -> false
-let (uu___is_Warning_FunctionNotExtacted : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_FunctionNotExtacted -> true
-    | uu___ -> false
-let (uu___is_Warning_HintFailedToReplayProof : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_HintFailedToReplayProof -> true
-    | uu___ -> false
-let (uu___is_Warning_HitReplayFailed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_HitReplayFailed -> true | uu___ -> false
-let (uu___is_Warning_IDEIgnoreCodeGen : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_IDEIgnoreCodeGen -> true | uu___ -> false
-let (uu___is_Warning_IllFormedGoal : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_IllFormedGoal -> true | uu___ -> false
-let (uu___is_Warning_InaccessibleArgument : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_InaccessibleArgument -> true
-    | uu___ -> false
-let (uu___is_Warning_IncoherentImplicitQualifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_IncoherentImplicitQualifier -> true
-    | uu___ -> false
-let (uu___is_Warning_IrrelevantQualifierOnArgumentToReflect :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_IrrelevantQualifierOnArgumentToReflect -> true
-    | uu___ -> false
-let (uu___is_Warning_IrrelevantQualifierOnArgumentToReify :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_IrrelevantQualifierOnArgumentToReify -> true
-    | uu___ -> false
-let (uu___is_Warning_MalformedWarnErrorList : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_MalformedWarnErrorList -> true
-    | uu___ -> false
-let (uu___is_Warning_MetaAlienNotATmUnknown : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_MetaAlienNotATmUnknown -> true
-    | uu___ -> false
-let (uu___is_Warning_MultipleAscriptions : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_MultipleAscriptions -> true
-    | uu___ -> false
-let (uu___is_Warning_NondependentUserDefinedDataType :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_NondependentUserDefinedDataType -> true
-    | uu___ -> false
-let (uu___is_Warning_NonListLiteralSMTPattern : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_NonListLiteralSMTPattern -> true
-    | uu___ -> false
-let (uu___is_Warning_NormalizationFailure : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_NormalizationFailure -> true
-    | uu___ -> false
-let (uu___is_Warning_NotDependentArrow : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_NotDependentArrow -> true | uu___ -> false
-let (uu___is_Warning_NotEmbedded : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_NotEmbedded -> true | uu___ -> false
-let (uu___is_Warning_PatternMissingBoundVar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_PatternMissingBoundVar -> true
-    | uu___ -> false
-let (uu___is_Warning_RecursiveDependency : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_RecursiveDependency -> true
-    | uu___ -> false
-let (uu___is_Warning_RedundantExplicitCurrying : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_RedundantExplicitCurrying -> true
-    | uu___ -> false
-let (uu___is_Warning_SMTPatTDeprecated : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_SMTPatTDeprecated -> true | uu___ -> false
-let (uu___is_Warning_SMTPatternIllFormed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_SMTPatternIllFormed -> true
-    | uu___ -> false
-let (uu___is_Warning_TopLevelEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_TopLevelEffect -> true | uu___ -> false
-let (uu___is_Warning_UnboundModuleReference : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_UnboundModuleReference -> true
-    | uu___ -> false
-let (uu___is_Warning_UnexpectedFile : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UnexpectedFile -> true | uu___ -> false
-let (uu___is_Warning_UnexpectedFsTypApp : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_UnexpectedFsTypApp -> true
-    | uu___ -> false
-let (uu___is_Warning_UnexpectedZ3Output : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_UnexpectedZ3Output -> true
-    | uu___ -> false
-let (uu___is_Warning_UnprotectedTerm : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UnprotectedTerm -> true | uu___ -> false
-let (uu___is_Warning_UnrecognizedAttribute : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_UnrecognizedAttribute -> true
-    | uu___ -> false
-let (uu___is_Warning_UpperBoundCandidateAlreadyVisited :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_UpperBoundCandidateAlreadyVisited -> true
-    | uu___ -> false
-let (uu___is_Warning_UseDefaultEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UseDefaultEffect -> true | uu___ -> false
-let (uu___is_Warning_WrongErrorLocation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_WrongErrorLocation -> true
-    | uu___ -> false
-let (uu___is_Warning_Z3InvocationWarning : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_Z3InvocationWarning -> true
-    | uu___ -> false
-let (uu___is_Warning_PluginNotImplemented : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_PluginNotImplemented -> true
-    | uu___ -> false
-let (uu___is_Warning_MissingInterfaceOrImplementation :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_MissingInterfaceOrImplementation -> true
-    | uu___ -> false
-let (uu___is_Warning_ConstructorBuildsUnexpectedType :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_ConstructorBuildsUnexpectedType -> true
-    | uu___ -> false
-let (uu___is_Warning_ModuleOrFileNotFoundWarning : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_ModuleOrFileNotFoundWarning -> true
-    | uu___ -> false
-let (uu___is_Error_NoLetMutable : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_NoLetMutable -> true | uu___ -> false
-let (uu___is_Error_BadImplicit : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_BadImplicit -> true | uu___ -> false
-let (uu___is_Warning_DeprecatedDefinition : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_DeprecatedDefinition -> true
-    | uu___ -> false
-let (uu___is_Fatal_SMTEncodingArityMismatch : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_SMTEncodingArityMismatch -> true
-    | uu___ -> false
-let (uu___is_Warning_Defensive : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_Defensive -> true | uu___ -> false
-let (uu___is_Warning_CantInspect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_CantInspect -> true | uu___ -> false
-let (uu___is_Warning_NilGivenExplicitArgs : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_NilGivenExplicitArgs -> true
-    | uu___ -> false
-let (uu___is_Warning_ConsAppliedExplicitArgs : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_ConsAppliedExplicitArgs -> true
-    | uu___ -> false
-let (uu___is_Warning_UnembedBinderKnot : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UnembedBinderKnot -> true | uu___ -> false
-let (uu___is_Fatal_TacticProofRelevantGoal : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_TacticProofRelevantGoal -> true
-    | uu___ -> false
-let (uu___is_Warning_TacAdmit : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_TacAdmit -> true | uu___ -> false
-let (uu___is_Fatal_IncoherentPatterns : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_IncoherentPatterns -> true | uu___ -> false
-let (uu___is_Error_NoSMTButNeeded : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_NoSMTButNeeded -> true | uu___ -> false
-let (uu___is_Fatal_UnexpectedAntiquotation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_UnexpectedAntiquotation -> true
-    | uu___ -> false
-let (uu___is_Fatal_SplicedUndef : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_SplicedUndef -> true | uu___ -> false
-let (uu___is_Fatal_SpliceUnembedFail : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_SpliceUnembedFail -> true | uu___ -> false
-let (uu___is_Warning_ExtractionUnexpectedEffect : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_ExtractionUnexpectedEffect -> true
-    | uu___ -> false
-let (uu___is_Error_DidNotFail : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_DidNotFail -> true | uu___ -> false
-let (uu___is_Warning_UnappliedFail : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UnappliedFail -> true | uu___ -> false
-let (uu___is_Warning_QuantifierWithoutPattern : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_QuantifierWithoutPattern -> true
-    | uu___ -> false
-let (uu___is_Error_EmptyFailErrs : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_EmptyFailErrs -> true | uu___ -> false
-let (uu___is_Warning_logicqualifier : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_logicqualifier -> true | uu___ -> false
-let (uu___is_Fatal_CyclicDependence : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_CyclicDependence -> true | uu___ -> false
-let (uu___is_Error_InductiveAnnotNotAType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_InductiveAnnotNotAType -> true
-    | uu___ -> false
-let (uu___is_Fatal_FriendInterface : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_FriendInterface -> true | uu___ -> false
-let (uu___is_Error_CannotRedefineConst : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_CannotRedefineConst -> true | uu___ -> false
-let (uu___is_Error_BadClassDecl : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_BadClassDecl -> true | uu___ -> false
-let (uu___is_Error_BadInductiveParam : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_BadInductiveParam -> true | uu___ -> false
-let (uu___is_Error_FieldShadow : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_FieldShadow -> true | uu___ -> false
-let (uu___is_Error_UnexpectedDM4FType : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_UnexpectedDM4FType -> true | uu___ -> false
-let (uu___is_Fatal_EffectAbbreviationResultTypeMismatch :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_EffectAbbreviationResultTypeMismatch -> true
-    | uu___ -> false
-let (uu___is_Error_AlreadyCachedAssertionFailure : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_AlreadyCachedAssertionFailure -> true
-    | uu___ -> false
-let (uu___is_Error_MustEraseMissing : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_MustEraseMissing -> true | uu___ -> false
-let (uu___is_Warning_EffectfulArgumentToErasedFunction :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_EffectfulArgumentToErasedFunction -> true
-    | uu___ -> false
-let (uu___is_Fatal_EmptySurfaceLet : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_EmptySurfaceLet -> true | uu___ -> false
-let (uu___is_Warning_UnexpectedCheckedFile : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_UnexpectedCheckedFile -> true
-    | uu___ -> false
-let (uu___is_Fatal_ExtractionUnsupported : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_ExtractionUnsupported -> true
-    | uu___ -> false
-let (uu___is_Warning_SMTErrorReason : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_SMTErrorReason -> true | uu___ -> false
-let (uu___is_Warning_CoercionNotFound : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_CoercionNotFound -> true | uu___ -> false
-let (uu___is_Error_QuakeFailed : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_QuakeFailed -> true | uu___ -> false
-let (uu___is_Error_IllSMTPat : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_IllSMTPat -> true | uu___ -> false
-let (uu___is_Error_IllScopedTerm : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_IllScopedTerm -> true | uu___ -> false
-let (uu___is_Warning_UnusedLetRec : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UnusedLetRec -> true | uu___ -> false
-let (uu___is_Fatal_Effects_Ordering_Coherence : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Fatal_Effects_Ordering_Coherence -> true
-    | uu___ -> false
-let (uu___is_Warning_BleedingEdge_Feature : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_BleedingEdge_Feature -> true
-    | uu___ -> false
-let (uu___is_Warning_IgnoredBinding : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_IgnoredBinding -> true | uu___ -> false
-let (uu___is_Warning_CouldNotReadHints : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_CouldNotReadHints -> true | uu___ -> false
-let (uu___is_Fatal_BadUvar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Fatal_BadUvar -> true | uu___ -> false
-let (uu___is_Warning_WarnOnUse : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_WarnOnUse -> true | uu___ -> false
-let (uu___is_Warning_DeprecatedAttributeSyntax : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_DeprecatedAttributeSyntax -> true
-    | uu___ -> false
-let (uu___is_Warning_DeprecatedGeneric : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_DeprecatedGeneric -> true | uu___ -> false
-let (uu___is_Error_BadSplice : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_BadSplice -> true | uu___ -> false
-let (uu___is_Error_UnexpectedUnresolvedUvar : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_UnexpectedUnresolvedUvar -> true
-    | uu___ -> false
-let (uu___is_Warning_UnfoldPlugin : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_UnfoldPlugin -> true | uu___ -> false
-let (uu___is_Error_LayeredMissingAnnot : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_LayeredMissingAnnot -> true | uu___ -> false
-let (uu___is_Error_CallToErased : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_CallToErased -> true | uu___ -> false
-let (uu___is_Error_ErasedCtor : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_ErasedCtor -> true | uu___ -> false
-let (uu___is_Error_RemoveUnusedTypeParameter : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_RemoveUnusedTypeParameter -> true
-    | uu___ -> false
-let (uu___is_Warning_NoMagicInFSharp : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning_NoMagicInFSharp -> true | uu___ -> false
-let (uu___is_Error_BadLetOpenRecord : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error_BadLetOpenRecord -> true | uu___ -> false
-let (uu___is_Error_UnexpectedTypeclassInstance : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Error_UnexpectedTypeclassInstance -> true
-    | uu___ -> false
-let (uu___is_Warning_AmbiguousResolveImplicitsHook : raw_error -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Warning_AmbiguousResolveImplicitsHook -> true
-    | uu___ -> false
-let (uu___is_Warning_SplitAndRetryQueries : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_SplitAndRetryQueries -> true
-    | uu___ -> false
-let (uu___is_Warning_DeprecatedLightDoNotation : raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_DeprecatedLightDoNotation -> true
-    | uu___ -> false
-let (uu___is_Warning_FailedToCheckInitialTacticGoal :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_FailedToCheckInitialTacticGoal -> true
-    | uu___ -> false
-let (uu___is_Warning_Adhoc_IndexedEffect_Combinator :
-  raw_error -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Warning_Adhoc_IndexedEffect_Combinator -> true
-    | uu___ -> false
-type flag = error_flag
-type error_setting = (raw_error * error_flag * Prims.int)
-let (default_settings : error_setting Prims.list) =
-  [(Error_DependencyAnalysisFailed, CAlwaysError, Prims.int_zero);
-  (Error_IDETooManyPops, CAlwaysError, Prims.int_one);
-  (Error_IDEUnrecognized, CAlwaysError, (Prims.of_int (2)));
-  (Error_InductiveTypeNotSatisfyPositivityCondition, CAlwaysError,
-    (Prims.of_int (3)));
-  (Error_InvalidUniverseVar, CAlwaysError, (Prims.of_int (4)));
-  (Error_MissingFileName, CAlwaysError, (Prims.of_int (5)));
-  (Error_ModuleFileNameMismatch, CAlwaysError, (Prims.of_int (6)));
-  (Error_OpPlusInUniverse, CAlwaysError, (Prims.of_int (7)));
-  (Error_OutOfRange, CAlwaysError, (Prims.of_int (8)));
-  (Error_ProofObligationFailed, CError, (Prims.of_int (9)));
-  (Error_TooManyFiles, CAlwaysError, (Prims.of_int (10)));
-  (Error_TypeCheckerFailToProve, CAlwaysError, (Prims.of_int (11)));
-  (Error_TypeError, CAlwaysError, (Prims.of_int (12)));
-  (Error_UncontrainedUnificationVar, CAlwaysError, (Prims.of_int (13)));
-  (Error_UnexpectedGTotComputation, CAlwaysError, (Prims.of_int (14)));
-  (Error_UnexpectedInstance, CAlwaysError, (Prims.of_int (15)));
-  (Error_UnknownFatal_AssertionFailure, CError, (Prims.of_int (16)));
-  (Error_Z3InvocationError, CAlwaysError, (Prims.of_int (17)));
-  (Error_IDEAssertionFailure, CAlwaysError, (Prims.of_int (18)));
-  (Error_Z3SolverError, CError, (Prims.of_int (19)));
-  (Fatal_AbstractTypeDeclarationInInterface, CFatal, (Prims.of_int (20)));
-  (Fatal_ActionMustHaveFunctionType, CFatal, (Prims.of_int (21)));
-  (Fatal_AlreadyDefinedTopLevelDeclaration, CFatal, (Prims.of_int (22)));
-  (Fatal_ArgumentLengthMismatch, CFatal, (Prims.of_int (23)));
-  (Fatal_AssertionFailure, CFatal, (Prims.of_int (24)));
-  (Fatal_AssignToImmutableValues, CFatal, (Prims.of_int (25)));
-  (Fatal_AssumeValInInterface, CFatal, (Prims.of_int (26)));
-  (Fatal_BadlyInstantiatedSynthByTactic, CFatal, (Prims.of_int (27)));
-  (Fatal_BadSignatureShape, CFatal, (Prims.of_int (28)));
-  (Fatal_BinderAndArgsLengthMismatch, CFatal, (Prims.of_int (29)));
-  (Fatal_BothValAndLetInInterface, CFatal, (Prims.of_int (30)));
-  (Fatal_CardinalityConstraintViolated, CFatal, (Prims.of_int (31)));
-  (Fatal_ComputationNotTotal, CFatal, (Prims.of_int (32)));
-  (Fatal_ComputationTypeNotAllowed, CFatal, (Prims.of_int (33)));
-  (Fatal_ComputedTypeNotMatchAnnotation, CFatal, (Prims.of_int (34)));
-  (Fatal_ConstructorArgLengthMismatch, CFatal, (Prims.of_int (35)));
-  (Fatal_ConstructorFailedCheck, CFatal, (Prims.of_int (36)));
-  (Fatal_ConstructorNotFound, CFatal, (Prims.of_int (37)));
-  (Fatal_ConstsructorBuildWrongType, CFatal, (Prims.of_int (38)));
-  (Fatal_CycleInRecTypeAbbreviation, CFatal, (Prims.of_int (39)));
-  (Fatal_DataContructorNotFound, CFatal, (Prims.of_int (40)));
-  (Fatal_DefaultQualifierNotAllowedOnEffects, CFatal, (Prims.of_int (41)));
-  (Fatal_DefinitionNotFound, CFatal, (Prims.of_int (42)));
-  (Fatal_DisjuctivePatternVarsMismatch, CFatal, (Prims.of_int (43)));
-  (Fatal_DivergentComputationCannotBeIncludedInTotal, CFatal,
-    (Prims.of_int (44)));
-  (Fatal_DuplicateInImplementation, CFatal, (Prims.of_int (45)));
-  (Fatal_DuplicateModuleOrInterface, CFatal, (Prims.of_int (46)));
-  (Fatal_DuplicateTopLevelNames, CFatal, (Prims.of_int (47)));
-  (Fatal_DuplicateTypeAnnotationAndValDecl, CFatal, (Prims.of_int (48)));
-  (Fatal_EffectCannotBeReified, CFatal, (Prims.of_int (49)));
-  (Fatal_EffectConstructorNotFullyApplied, CFatal, (Prims.of_int (50)));
-  (Fatal_EffectfulAndPureComputationMismatch, CFatal, (Prims.of_int (51)));
-  (Fatal_EffectNotFound, CFatal, (Prims.of_int (52)));
-  (Fatal_EffectsCannotBeComposed, CFatal, (Prims.of_int (53)));
-  (Fatal_ErrorInSolveDeferredConstraints, CFatal, (Prims.of_int (54)));
-  (Fatal_ErrorsReported, CFatal, (Prims.of_int (55)));
-  (Fatal_EscapedBoundVar, CFatal, (Prims.of_int (56)));
-  (Fatal_ExpectedArrowAnnotatedType, CFatal, (Prims.of_int (57)));
-  (Fatal_ExpectedGhostExpression, CFatal, (Prims.of_int (58)));
-  (Fatal_ExpectedPureExpression, CFatal, (Prims.of_int (59)));
-  (Fatal_ExpectNormalizedEffect, CFatal, (Prims.of_int (60)));
-  (Fatal_ExpectTermGotFunction, CFatal, (Prims.of_int (61)));
-  (Fatal_ExpectTrivialPreCondition, CFatal, (Prims.of_int (62)));
-  (Fatal_FailToExtractNativeTactic, CFatal, (Prims.of_int (63)));
-  (Fatal_FailToCompileNativeTactic, CFatal, (Prims.of_int (64)));
-  (Fatal_FailToProcessPragma, CFatal, (Prims.of_int (65)));
-  (Fatal_FailToResolveImplicitArgument, CFatal, (Prims.of_int (66)));
-  (Fatal_FailToSolveUniverseInEquality, CFatal, (Prims.of_int (67)));
-  (Fatal_FieldsNotBelongToSameRecordType, CFatal, (Prims.of_int (68)));
-  (Fatal_ForbiddenReferenceToCurrentModule, CFatal, (Prims.of_int (69)));
-  (Fatal_FreeVariables, CFatal, (Prims.of_int (70)));
-  (Fatal_FunctionTypeExpected, CFatal, (Prims.of_int (71)));
-  (Fatal_IdentifierNotFound, CFatal, (Prims.of_int (72)));
-  (Fatal_IllAppliedConstant, CFatal, (Prims.of_int (73)));
-  (Fatal_IllegalCharInByteArray, CFatal, (Prims.of_int (74)));
-  (Fatal_IllegalCharInOperatorName, CFatal, (Prims.of_int (75)));
-  (Fatal_IllTyped, CFatal, (Prims.of_int (76)));
-  (Fatal_ImpossibleAbbrevLidBundle, CFatal, (Prims.of_int (77)));
-  (Fatal_ImpossibleAbbrevRenameBundle, CFatal, (Prims.of_int (78)));
-  (Fatal_ImpossibleInductiveWithAbbrev, CFatal, (Prims.of_int (79)));
-  (Fatal_ImpossiblePrePostAbs, CFatal, (Prims.of_int (80)));
-  (Fatal_ImpossiblePrePostArrow, CFatal, (Prims.of_int (81)));
-  (Fatal_ImpossibleToGenerateDMEffect, CFatal, (Prims.of_int (82)));
-  (Fatal_ImpossibleTypeAbbrevBundle, CFatal, (Prims.of_int (83)));
-  (Fatal_ImpossibleTypeAbbrevSigeltBundle, CFatal, (Prims.of_int (84)));
-  (Fatal_IncludeModuleNotPrepared, CFatal, (Prims.of_int (85)));
-  (Fatal_IncoherentInlineUniverse, CFatal, (Prims.of_int (86)));
-  (Fatal_IncompatibleKinds, CFatal, (Prims.of_int (87)));
-  (Fatal_IncompatibleNumberOfTypes, CFatal, (Prims.of_int (88)));
-  (Fatal_IncompatibleSetOfUniverse, CFatal, (Prims.of_int (89)));
-  (Fatal_IncompatibleUniverse, CFatal, (Prims.of_int (90)));
-  (Fatal_InconsistentImplicitArgumentAnnotation, CFatal, (Prims.of_int (91)));
-  (Fatal_InconsistentImplicitQualifier, CFatal, (Prims.of_int (92)));
-  (Fatal_InconsistentQualifierAnnotation, CFatal, (Prims.of_int (93)));
-  (Fatal_InferredTypeCauseVarEscape, CFatal, (Prims.of_int (94)));
-  (Fatal_InlineRenamedAsUnfold, CFatal, (Prims.of_int (95)));
-  (Fatal_InsufficientPatternArguments, CFatal, (Prims.of_int (96)));
-  (Fatal_InterfaceAlreadyProcessed, CFatal, (Prims.of_int (97)));
-  (Fatal_InterfaceNotImplementedByModule, CFatal, (Prims.of_int (98)));
-  (Fatal_InterfaceWithTypeImplementation, CFatal, (Prims.of_int (99)));
-  (Fatal_InvalidFloatingPointNumber, CFatal, (Prims.of_int (100)));
-  (Fatal_InvalidFSDocKeyword, CFatal, (Prims.of_int (101)));
-  (Fatal_InvalidIdentifier, CFatal, (Prims.of_int (102)));
-  (Fatal_InvalidLemmaArgument, CFatal, (Prims.of_int (103)));
-  (Fatal_InvalidNumericLiteral, CFatal, (Prims.of_int (104)));
-  (Fatal_InvalidRedefinitionOfLexT, CFatal, (Prims.of_int (105)));
-  (Fatal_InvalidUnicodeInStringLiteral, CFatal, (Prims.of_int (106)));
-  (Fatal_InvalidUTF8Encoding, CFatal, (Prims.of_int (107)));
-  (Fatal_InvalidWarnErrorSetting, CFatal, (Prims.of_int (108)));
-  (Fatal_LetBoundMonadicMismatch, CFatal, (Prims.of_int (109)));
-  (Fatal_LetMutableForVariablesOnly, CFatal, (Prims.of_int (110)));
-  (Fatal_LetOpenModuleOnly, CFatal, (Prims.of_int (111)));
-  (Fatal_LetRecArgumentMismatch, CFatal, (Prims.of_int (112)));
-  (Fatal_MalformedActionDeclaration, CFatal, (Prims.of_int (113)));
-  (Fatal_MismatchedPatternType, CFatal, (Prims.of_int (114)));
-  (Fatal_MismatchUniversePolymorphic, CFatal, (Prims.of_int (115)));
-  (Fatal_MissingDataConstructor, CFatal, (Prims.of_int (116)));
-  (Fatal_MissingExposeInterfacesOption, CFatal, (Prims.of_int (117)));
-  (Fatal_MissingFieldInRecord, CFatal, (Prims.of_int (118)));
-  (Fatal_MissingImplementation, CFatal, (Prims.of_int (119)));
-  (Fatal_MissingImplicitArguments, CFatal, (Prims.of_int (120)));
-  (Fatal_MissingInterface, CFatal, (Prims.of_int (121)));
-  (Fatal_MissingNameInBinder, CFatal, (Prims.of_int (122)));
-  (Fatal_MissingPrimsModule, CFatal, (Prims.of_int (123)));
-  (Fatal_MissingQuantifierBinder, CFatal, (Prims.of_int (124)));
-  (Fatal_ModuleExpected, CFatal, (Prims.of_int (125)));
-  (Fatal_ModuleFileNotFound, CFatal, (Prims.of_int (126)));
-  (Fatal_ModuleFirstStatement, CFatal, (Prims.of_int (127)));
-  (Fatal_ModuleNotFound, CFatal, (Prims.of_int (128)));
-  (Fatal_ModuleOrFileNotFound, CFatal, (Prims.of_int (129)));
-  (Fatal_MonadAlreadyDefined, CFatal, (Prims.of_int (130)));
-  (Fatal_MoreThanOneDeclaration, CFatal, (Prims.of_int (131)));
-  (Fatal_MultipleLetBinding, CFatal, (Prims.of_int (132)));
-  (Fatal_NameNotFound, CFatal, (Prims.of_int (133)));
-  (Fatal_NameSpaceNotFound, CFatal, (Prims.of_int (134)));
-  (Fatal_NegativeUniverseConstFatal_NotSupported, CFatal,
-    (Prims.of_int (135)));
-  (Fatal_NoFileProvided, CFatal, (Prims.of_int (136)));
-  (Fatal_NonInductiveInMutuallyDefinedType, CFatal, (Prims.of_int (137)));
-  (Fatal_NonLinearPatternNotPermitted, CFatal, (Prims.of_int (138)));
-  (Fatal_NonLinearPatternVars, CFatal, (Prims.of_int (139)));
-  (Fatal_NonSingletonTopLevel, CFatal, (Prims.of_int (140)));
-  (Fatal_NonSingletonTopLevelModule, CFatal, (Prims.of_int (141)));
-  (Error_NonTopRecFunctionNotFullyEncoded, CError, (Prims.of_int (142)));
-  (Fatal_NonTrivialPreConditionInPrims, CFatal, (Prims.of_int (143)));
-  (Fatal_NonVariableInductiveTypeParameter, CFatal, (Prims.of_int (144)));
-  (Fatal_NotApplicationOrFv, CFatal, (Prims.of_int (145)));
-  (Fatal_NotEnoughArgsToEffect, CFatal, (Prims.of_int (146)));
-  (Fatal_NotEnoughArgumentsForEffect, CFatal, (Prims.of_int (147)));
-  (Fatal_NotFunctionType, CFatal, (Prims.of_int (148)));
-  (Fatal_NotSupported, CFatal, (Prims.of_int (149)));
-  (Fatal_NotTopLevelModule, CFatal, (Prims.of_int (150)));
-  (Fatal_NotValidFStarFile, CFatal, (Prims.of_int (151)));
-  (Fatal_NotValidIncludeDirectory, CFatal, (Prims.of_int (152)));
-  (Fatal_OneModulePerFile, CFatal, (Prims.of_int (153)));
-  (Fatal_OpenGoalsInSynthesis, CFatal, (Prims.of_int (154)));
-  (Fatal_OptionsNotCompatible, CFatal, (Prims.of_int (155)));
-  (Fatal_OutOfOrder, CFatal, (Prims.of_int (156)));
-  (Fatal_ParseErrors, CFatal, (Prims.of_int (157)));
-  (Fatal_ParseItError, CFatal, (Prims.of_int (158)));
-  (Fatal_PolyTypeExpected, CFatal, (Prims.of_int (159)));
-  (Fatal_PossibleInfiniteTyp, CFatal, (Prims.of_int (160)));
-  (Fatal_PreModuleMismatch, CFatal, (Prims.of_int (161)));
-  (Fatal_QulifierListNotPermitted, CFatal, (Prims.of_int (162)));
-  (Fatal_RecursiveFunctionLiteral, CFatal, (Prims.of_int (163)));
-  (Fatal_ReflectOnlySupportedOnEffects, CFatal, (Prims.of_int (164)));
-  (Fatal_ReservedPrefix, CFatal, (Prims.of_int (165)));
-  (Fatal_SMTOutputParseError, CFatal, (Prims.of_int (166)));
-  (Fatal_SMTSolverError, CFatal, (Prims.of_int (167)));
-  (Fatal_SyntaxError, CFatal, (Prims.of_int (168)));
-  (Fatal_SynthByTacticError, CFatal, (Prims.of_int (169)));
-  (Fatal_TacticGotStuck, CFatal, (Prims.of_int (170)));
-  (Fatal_TcOneFragmentFailed, CFatal, (Prims.of_int (171)));
-  (Fatal_TermOutsideOfDefLanguage, CFatal, (Prims.of_int (172)));
-  (Fatal_ToManyArgumentToFunction, CFatal, (Prims.of_int (173)));
-  (Fatal_TooManyOrTooFewFileMatch, CFatal, (Prims.of_int (174)));
-  (Fatal_TooManyPatternArguments, CFatal, (Prims.of_int (175)));
-  (Fatal_TooManyUniverse, CFatal, (Prims.of_int (176)));
-  (Fatal_TypeMismatch, CFatal, (Prims.of_int (177)));
-  (Fatal_TypeWithinPatternsAllowedOnVariablesOnly, CFatal,
-    (Prims.of_int (178)));
-  (Fatal_UnableToReadFile, CFatal, (Prims.of_int (179)));
-  (Fatal_UnepxectedOrUnboundOperator, CFatal, (Prims.of_int (180)));
-  (Fatal_UnexpectedBinder, CFatal, (Prims.of_int (181)));
-  (Fatal_UnexpectedBindShape, CFatal, (Prims.of_int (182)));
-  (Fatal_UnexpectedChar, CFatal, (Prims.of_int (183)));
-  (Fatal_UnexpectedComputationTypeForLetRec, CFatal, (Prims.of_int (184)));
-  (Fatal_UnexpectedConstructorType, CFatal, (Prims.of_int (185)));
-  (Fatal_UnexpectedDataConstructor, CFatal, (Prims.of_int (186)));
-  (Fatal_UnexpectedEffect, CFatal, (Prims.of_int (187)));
-  (Fatal_UnexpectedEmptyRecord, CFatal, (Prims.of_int (188)));
-  (Fatal_UnexpectedExpressionType, CFatal, (Prims.of_int (189)));
-  (Fatal_UnexpectedFunctionParameterType, CFatal, (Prims.of_int (190)));
-  (Fatal_UnexpectedGeneralizedUniverse, CFatal, (Prims.of_int (191)));
-  (Fatal_UnexpectedGTotForLetRec, CFatal, (Prims.of_int (192)));
-  (Fatal_UnexpectedGuard, CFatal, (Prims.of_int (193)));
-  (Fatal_UnexpectedIdentifier, CFatal, (Prims.of_int (194)));
-  (Fatal_UnexpectedImplicitArgument, CFatal, (Prims.of_int (195)));
-  (Fatal_UnexpectedImplictArgument, CFatal, (Prims.of_int (196)));
-  (Fatal_UnexpectedInductivetype, CFatal, (Prims.of_int (197)));
-  (Fatal_UnexpectedLetBinding, CFatal, (Prims.of_int (198)));
-  (Fatal_UnexpectedModuleDeclaration, CFatal, (Prims.of_int (199)));
-  (Fatal_UnexpectedNumberOfUniverse, CFatal, (Prims.of_int (200)));
-  (Fatal_UnexpectedNumericLiteral, CFatal, (Prims.of_int (201)));
-  (Fatal_UnexpectedPattern, CFatal, (Prims.of_int (203)));
-  (Fatal_UnexpectedPosition, CFatal, (Prims.of_int (204)));
-  (Fatal_UnExpectedPreCondition, CFatal, (Prims.of_int (205)));
-  (Fatal_UnexpectedReturnShape, CFatal, (Prims.of_int (206)));
-  (Fatal_UnexpectedSignatureForMonad, CFatal, (Prims.of_int (207)));
-  (Fatal_UnexpectedTerm, CFatal, (Prims.of_int (208)));
-  (Fatal_UnexpectedTermInUniverse, CFatal, (Prims.of_int (209)));
-  (Fatal_UnexpectedTermType, CFatal, (Prims.of_int (210)));
-  (Fatal_UnexpectedTermVQuote, CFatal, (Prims.of_int (211)));
-  (Fatal_UnexpectedUniversePolymorphicReturn, CFatal, (Prims.of_int (212)));
-  (Fatal_UnexpectedUniverseVariable, CFatal, (Prims.of_int (213)));
-  (Fatal_UnfoldableDeprecated, CFatal, (Prims.of_int (214)));
-  (Fatal_UnificationNotWellFormed, CFatal, (Prims.of_int (215)));
-  (Fatal_Uninstantiated, CFatal, (Prims.of_int (216)));
-  (Error_UninstantiatedUnificationVarInTactic, CError, (Prims.of_int (217)));
-  (Fatal_UninstantiatedVarInTactic, CFatal, (Prims.of_int (218)));
-  (Fatal_UniverseMightContainSumOfTwoUnivVars, CFatal, (Prims.of_int (219)));
-  (Fatal_UniversePolymorphicInnerLetBound, CFatal, (Prims.of_int (220)));
-  (Fatal_UnknownAttribute, CFatal, (Prims.of_int (221)));
-  (Fatal_UnknownToolForDep, CFatal, (Prims.of_int (222)));
-  (Fatal_UnrecognizedExtension, CFatal, (Prims.of_int (223)));
-  (Fatal_UnresolvedPatternVar, CFatal, (Prims.of_int (224)));
-  (Fatal_UnsupportedConstant, CFatal, (Prims.of_int (225)));
-  (Fatal_UnsupportedDisjuctivePatterns, CFatal, (Prims.of_int (226)));
-  (Fatal_UnsupportedQualifier, CFatal, (Prims.of_int (227)));
-  (Fatal_UserTacticFailure, CFatal, (Prims.of_int (228)));
-  (Fatal_ValueRestriction, CFatal, (Prims.of_int (229)));
-  (Fatal_VariableNotFound, CFatal, (Prims.of_int (230)));
-  (Fatal_WrongBodyTypeForReturnWP, CFatal, (Prims.of_int (231)));
-  (Fatal_WrongDataAppHeadFormat, CFatal, (Prims.of_int (232)));
-  (Fatal_WrongDefinitionOrder, CFatal, (Prims.of_int (233)));
-  (Fatal_WrongResultTypeAfterConstrutor, CFatal, (Prims.of_int (234)));
-  (Fatal_WrongTerm, CFatal, (Prims.of_int (235)));
-  (Fatal_WhenClauseNotSupported, CFatal, (Prims.of_int (236)));
-  (Unused01, CFatal, (Prims.of_int (237)));
-  (Warning_PluginNotImplemented, CError, (Prims.of_int (238)));
-  (Warning_AddImplicitAssumeNewQualifier, CWarning, (Prims.of_int (239)));
-  (Warning_AdmitWithoutDefinition, CWarning, (Prims.of_int (240)));
-  (Warning_CachedFile, CWarning, (Prims.of_int (241)));
-  (Warning_DefinitionNotTranslated, CWarning, (Prims.of_int (242)));
-  (Warning_DependencyFound, CWarning, (Prims.of_int (243)));
-  (Warning_DeprecatedEqualityOnBinder, CWarning, (Prims.of_int (244)));
-  (Warning_DeprecatedOpaqueQualifier, CWarning, (Prims.of_int (245)));
-  (Warning_DocOverwrite, CWarning, (Prims.of_int (246)));
-  (Warning_FileNotWritten, CWarning, (Prims.of_int (247)));
-  (Warning_Filtered, CWarning, (Prims.of_int (248)));
-  (Warning_FunctionLiteralPrecisionLoss, CWarning, (Prims.of_int (249)));
-  (Warning_FunctionNotExtacted, CWarning, (Prims.of_int (250)));
-  (Warning_HintFailedToReplayProof, CWarning, (Prims.of_int (251)));
-  (Warning_HitReplayFailed, CWarning, (Prims.of_int (252)));
-  (Warning_IDEIgnoreCodeGen, CWarning, (Prims.of_int (253)));
-  (Warning_IllFormedGoal, CWarning, (Prims.of_int (254)));
-  (Warning_InaccessibleArgument, CWarning, (Prims.of_int (255)));
-  (Warning_IncoherentImplicitQualifier, CWarning, (Prims.of_int (256)));
-  (Warning_IrrelevantQualifierOnArgumentToReflect, CWarning,
-    (Prims.of_int (257)));
-  (Warning_IrrelevantQualifierOnArgumentToReify, CWarning,
-    (Prims.of_int (258)));
-  (Warning_MalformedWarnErrorList, CWarning, (Prims.of_int (259)));
-  (Warning_MetaAlienNotATmUnknown, CWarning, (Prims.of_int (260)));
-  (Warning_MultipleAscriptions, CWarning, (Prims.of_int (261)));
-  (Warning_NondependentUserDefinedDataType, CWarning, (Prims.of_int (262)));
-  (Warning_NonListLiteralSMTPattern, CWarning, (Prims.of_int (263)));
-  (Warning_NormalizationFailure, CWarning, (Prims.of_int (264)));
-  (Warning_NotDependentArrow, CWarning, (Prims.of_int (265)));
-  (Warning_NotEmbedded, CWarning, (Prims.of_int (266)));
-  (Warning_PatternMissingBoundVar, CWarning, (Prims.of_int (267)));
-  (Warning_RecursiveDependency, CWarning, (Prims.of_int (268)));
-  (Warning_RedundantExplicitCurrying, CWarning, (Prims.of_int (269)));
-  (Warning_SMTPatTDeprecated, CWarning, (Prims.of_int (270)));
-  (Warning_SMTPatternIllFormed, CWarning, (Prims.of_int (271)));
-  (Warning_TopLevelEffect, CWarning, (Prims.of_int (272)));
-  (Warning_UnboundModuleReference, CWarning, (Prims.of_int (273)));
-  (Warning_UnexpectedFile, CWarning, (Prims.of_int (274)));
-  (Warning_UnexpectedFsTypApp, CWarning, (Prims.of_int (275)));
-  (Warning_UnexpectedZ3Output, CError, (Prims.of_int (276)));
-  (Warning_UnprotectedTerm, CWarning, (Prims.of_int (277)));
-  (Warning_UnrecognizedAttribute, CWarning, (Prims.of_int (278)));
-  (Warning_UpperBoundCandidateAlreadyVisited, CWarning, (Prims.of_int (279)));
-  (Warning_UseDefaultEffect, CWarning, (Prims.of_int (280)));
-  (Warning_WrongErrorLocation, CWarning, (Prims.of_int (281)));
-  (Warning_Z3InvocationWarning, CWarning, (Prims.of_int (282)));
-  (Warning_MissingInterfaceOrImplementation, CWarning, (Prims.of_int (283)));
-  (Warning_ConstructorBuildsUnexpectedType, CWarning, (Prims.of_int (284)));
-  (Warning_ModuleOrFileNotFoundWarning, CWarning, (Prims.of_int (285)));
-  (Error_NoLetMutable, CAlwaysError, (Prims.of_int (286)));
-  (Error_BadImplicit, CAlwaysError, (Prims.of_int (287)));
-  (Warning_DeprecatedDefinition, CWarning, (Prims.of_int (288)));
-  (Fatal_SMTEncodingArityMismatch, CFatal, (Prims.of_int (289)));
-  (Warning_Defensive, CWarning, (Prims.of_int (290)));
-  (Warning_CantInspect, CWarning, (Prims.of_int (291)));
-  (Warning_NilGivenExplicitArgs, CWarning, (Prims.of_int (292)));
-  (Warning_ConsAppliedExplicitArgs, CWarning, (Prims.of_int (293)));
-  (Warning_UnembedBinderKnot, CWarning, (Prims.of_int (294)));
-  (Fatal_TacticProofRelevantGoal, CFatal, (Prims.of_int (295)));
-  (Warning_TacAdmit, CWarning, (Prims.of_int (296)));
-  (Fatal_IncoherentPatterns, CFatal, (Prims.of_int (297)));
-  (Error_NoSMTButNeeded, CAlwaysError, (Prims.of_int (298)));
-  (Fatal_UnexpectedAntiquotation, CFatal, (Prims.of_int (299)));
-  (Fatal_SplicedUndef, CFatal, (Prims.of_int (300)));
-  (Fatal_SpliceUnembedFail, CFatal, (Prims.of_int (301)));
-  (Warning_ExtractionUnexpectedEffect, CWarning, (Prims.of_int (302)));
-  (Error_DidNotFail, CError, (Prims.of_int (303)));
-  (Warning_UnappliedFail, CWarning, (Prims.of_int (304)));
-  (Warning_QuantifierWithoutPattern, CSilent, (Prims.of_int (305)));
-  (Error_EmptyFailErrs, CAlwaysError, (Prims.of_int (306)));
-  (Warning_logicqualifier, CWarning, (Prims.of_int (307)));
-  (Fatal_CyclicDependence, CFatal, (Prims.of_int (308)));
-  (Error_InductiveAnnotNotAType, CError, (Prims.of_int (309)));
-  (Fatal_FriendInterface, CFatal, (Prims.of_int (310)));
-  (Error_CannotRedefineConst, CError, (Prims.of_int (311)));
-  (Error_BadClassDecl, CError, (Prims.of_int (312)));
-  (Error_BadInductiveParam, CFatal, (Prims.of_int (313)));
-  (Error_FieldShadow, CFatal, (Prims.of_int (314)));
-  (Error_UnexpectedDM4FType, CFatal, (Prims.of_int (315)));
-  (Fatal_EffectAbbreviationResultTypeMismatch, CFatal, (Prims.of_int (316)));
-  (Error_AlreadyCachedAssertionFailure, CFatal, (Prims.of_int (317)));
-  (Error_MustEraseMissing, CWarning, (Prims.of_int (318)));
-  (Warning_EffectfulArgumentToErasedFunction, CWarning, (Prims.of_int (319)));
-  (Fatal_EmptySurfaceLet, CFatal, (Prims.of_int (320)));
-  (Warning_UnexpectedCheckedFile, CWarning, (Prims.of_int (321)));
-  (Fatal_ExtractionUnsupported, CFatal, (Prims.of_int (322)));
-  (Warning_SMTErrorReason, CWarning, (Prims.of_int (323)));
-  (Warning_CoercionNotFound, CWarning, (Prims.of_int (324)));
-  (Error_QuakeFailed, CError, (Prims.of_int (325)));
-  (Error_IllSMTPat, CError, (Prims.of_int (326)));
-  (Error_IllScopedTerm, CError, (Prims.of_int (327)));
-  (Warning_UnusedLetRec, CWarning, (Prims.of_int (328)));
-  (Fatal_Effects_Ordering_Coherence, CError, (Prims.of_int (329)));
-  (Warning_BleedingEdge_Feature, CWarning, (Prims.of_int (330)));
-  (Warning_IgnoredBinding, CWarning, (Prims.of_int (331)));
-  (Warning_CouldNotReadHints, CWarning, (Prims.of_int (333)));
-  (Fatal_BadUvar, CFatal, (Prims.of_int (334)));
-  (Warning_WarnOnUse, CSilent, (Prims.of_int (335)));
-  (Warning_DeprecatedAttributeSyntax, CSilent, (Prims.of_int (336)));
-  (Warning_DeprecatedGeneric, CWarning, (Prims.of_int (337)));
-  (Error_BadSplice, CError, (Prims.of_int (338)));
-  (Error_UnexpectedUnresolvedUvar, CAlwaysError, (Prims.of_int (339)));
-  (Warning_UnfoldPlugin, CWarning, (Prims.of_int (340)));
-  (Error_LayeredMissingAnnot, CAlwaysError, (Prims.of_int (341)));
-  (Error_CallToErased, CError, (Prims.of_int (342)));
-  (Error_ErasedCtor, CError, (Prims.of_int (343)));
-  (Error_RemoveUnusedTypeParameter, CWarning, (Prims.of_int (344)));
-  (Warning_NoMagicInFSharp, CWarning, (Prims.of_int (345)));
-  (Error_BadLetOpenRecord, CAlwaysError, (Prims.of_int (346)));
-  (Error_UnexpectedTypeclassInstance, CAlwaysError, (Prims.of_int (347)));
-  (Warning_AmbiguousResolveImplicitsHook, CWarning, (Prims.of_int (348)));
-  (Warning_SplitAndRetryQueries, CWarning, (Prims.of_int (349)));
-  (Warning_DeprecatedLightDoNotation, CWarning, (Prims.of_int (350)));
-  (Warning_FailedToCheckInitialTacticGoal, CSilent, (Prims.of_int (351)));
-  (Warning_Adhoc_IndexedEffect_Combinator, CWarning, (Prims.of_int (352)))]
-let lookup_error :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    ('uuuuu * 'uuuuu1 * 'uuuuu2) Prims.list ->
-      'uuuuu -> ('uuuuu * 'uuuuu1 * 'uuuuu2)
-  =
-  fun settings ->
-    fun e ->
-      let uu___ =
-        FStar_Compiler_Util.try_find
-          (fun uu___1 -> match uu___1 with | (v, uu___2, i) -> e = v)
-          settings in
-      match uu___ with
-      | FStar_Pervasives_Native.Some i -> i
-      | FStar_Pervasives_Native.None ->
-          failwith "Impossible: unrecognized error"
-let lookup_error_range :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu * 'uuuuu1 * Prims.int) Prims.list ->
-      (Prims.int * Prims.int) -> ('uuuuu * 'uuuuu1 * Prims.int) Prims.list
-  =
-  fun settings ->
-    fun uu___ ->
-      match uu___ with
-      | (l, h) ->
-          let uu___1 =
-            FStar_Compiler_List.partition
-              (fun uu___2 ->
-                 match uu___2 with
-                 | (uu___3, uu___4, i) -> (l <= i) && (i <= h)) settings in
-          (match uu___1 with | (matches, uu___2) -> matches)
-let error_number :
-  'uuuuu 'uuuuu1 'uuuuu2 . ('uuuuu * 'uuuuu1 * 'uuuuu2) -> 'uuuuu2 =
-  fun uu___ -> match uu___ with | (uu___1, uu___2, i) -> i
-let (warn_on_use_errno : Prims.int) =
-  let uu___ = lookup_error default_settings Warning_WarnOnUse in
-  error_number uu___
-let (defensive_errno : Prims.int) =
-  let uu___ = lookup_error default_settings Warning_Defensive in
-  error_number uu___
-let (call_to_erased_errno : Prims.int) =
-  let uu___ = lookup_error default_settings Error_CallToErased in
-  error_number uu___
-let (update_flags :
-  (error_flag * Prims.string) Prims.list -> error_setting Prims.list) =
-  fun l ->
-    let set_one_flag i flag1 default_flag =
-      match (flag1, default_flag) with
-      | (CWarning, CAlwaysError) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Compiler_Util.string_of_int i in
-              FStar_Compiler_Util.format1 "cannot turn error %s into warning"
-                uu___2 in
-            Invalid_warn_error_setting uu___1 in
-          FStar_Compiler_Effect.raise uu___
-      | (CError, CAlwaysError) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Compiler_Util.string_of_int i in
-              FStar_Compiler_Util.format1 "cannot turn error %s into warning"
-                uu___2 in
-            Invalid_warn_error_setting uu___1 in
-          FStar_Compiler_Effect.raise uu___
-      | (CSilent, CAlwaysError) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Compiler_Util.string_of_int i in
-              FStar_Compiler_Util.format1 "cannot silence error %s" uu___2 in
-            Invalid_warn_error_setting uu___1 in
-          FStar_Compiler_Effect.raise uu___
-      | (uu___, CFatal) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Compiler_Util.string_of_int i in
-              FStar_Compiler_Util.format1
-                "cannot change the error level of fatal error %s" uu___3 in
-            Invalid_warn_error_setting uu___2 in
-          FStar_Compiler_Effect.raise uu___1
-      | uu___ -> flag1 in
-    let set_flag_for_range uu___ =
-      match uu___ with
-      | (flag1, range) ->
-          let errs = lookup_error_range default_settings range in
-          FStar_Compiler_List.map
-            (fun uu___1 ->
-               match uu___1 with
-               | (v, default_flag, i) ->
-                   let uu___2 = set_one_flag i flag1 default_flag in
-                   (v, uu___2, i)) errs in
-    let compute_range uu___ =
-      match uu___ with
-      | (flag1, s) ->
-          let r = FStar_Compiler_Util.split s ".." in
-          let uu___1 =
-            match r with
-            | r1::r2::[] ->
-                let uu___2 = FStar_Compiler_Util.int_of_string r1 in
-                let uu___3 = FStar_Compiler_Util.int_of_string r2 in
-                (uu___2, uu___3)
-            | uu___2 ->
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Compiler_Util.format1
-                      "Malformed warn-error range %s" s in
-                  Invalid_warn_error_setting uu___4 in
-                FStar_Compiler_Effect.raise uu___3 in
-          (match uu___1 with | (l1, h) -> (flag1, (l1, h))) in
-    let error_range_settings = FStar_Compiler_List.map compute_range l in
-    let uu___ =
-      FStar_Compiler_List.collect set_flag_for_range error_range_settings in
-    FStar_Compiler_List.op_At uu___ default_settings
-type error =
-  (raw_error * Prims.string * FStar_Compiler_Range.range * Prims.string
-    Prims.list)
-exception Err of (raw_error * Prims.string * Prims.string Prims.list) 
-let (uu___is_Err : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | Err uu___ -> true | uu___ -> false
-let (__proj__Err__item__uu___ :
-  Prims.exn -> (raw_error * Prims.string * Prims.string Prims.list)) =
-  fun projectee -> match projectee with | Err uu___ -> uu___
-exception Error of error 
-let (uu___is_Error : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Error uu___ -> true | uu___ -> false
-let (__proj__Error__item__uu___ : Prims.exn -> error) =
-  fun projectee -> match projectee with | Error uu___ -> uu___
-exception Warning of error 
-let (uu___is_Warning : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Warning uu___ -> true | uu___ -> false
-let (__proj__Warning__item__uu___ : Prims.exn -> error) =
-  fun projectee -> match projectee with | Warning uu___ -> uu___
-exception Stop 
-let (uu___is_Stop : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | Stop -> true | uu___ -> false
-exception Empty_frag 
-let (uu___is_Empty_frag : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | Empty_frag -> true | uu___ -> false
-type issue_level =
-  | ENotImplemented 
-  | EInfo 
-  | EWarning 
-  | EError 
-let (uu___is_ENotImplemented : issue_level -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ENotImplemented -> true | uu___ -> false
-let (uu___is_EInfo : issue_level -> Prims.bool) =
-  fun projectee -> match projectee with | EInfo -> true | uu___ -> false
-let (uu___is_EWarning : issue_level -> Prims.bool) =
-  fun projectee -> match projectee with | EWarning -> true | uu___ -> false
-let (uu___is_EError : issue_level -> Prims.bool) =
-  fun projectee -> match projectee with | EError -> true | uu___ -> false
-type issue =
-  {
-  issue_msg: Prims.string ;
-  issue_level: issue_level ;
-  issue_range: FStar_Compiler_Range.range FStar_Pervasives_Native.option ;
-  issue_number: Prims.int FStar_Pervasives_Native.option ;
-  issue_ctx: Prims.string Prims.list }
-let (__proj__Mkissue__item__issue_msg : issue -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { issue_msg; issue_level = issue_level1; issue_range; issue_number;
-        issue_ctx;_} -> issue_msg
-let (__proj__Mkissue__item__issue_level : issue -> issue_level) =
-  fun projectee ->
-    match projectee with
-    | { issue_msg; issue_level = issue_level1; issue_range; issue_number;
-        issue_ctx;_} -> issue_level1
-let (__proj__Mkissue__item__issue_range :
-  issue -> FStar_Compiler_Range.range FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { issue_msg; issue_level = issue_level1; issue_range; issue_number;
-        issue_ctx;_} -> issue_range
-let (__proj__Mkissue__item__issue_number :
-  issue -> Prims.int FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { issue_msg; issue_level = issue_level1; issue_range; issue_number;
-        issue_ctx;_} -> issue_number
-let (__proj__Mkissue__item__issue_ctx : issue -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { issue_msg; issue_level = issue_level1; issue_range; issue_number;
-        issue_ctx;_} -> issue_ctx
-type error_handler =
-  {
-  eh_add_one: issue -> unit ;
-  eh_count_errors: unit -> Prims.int ;
-  eh_report: unit -> issue Prims.list ;
-  eh_clear: unit -> unit }
-let (__proj__Mkerror_handler__item__eh_add_one :
-  error_handler -> issue -> unit) =
-  fun projectee ->
-    match projectee with
-    | { eh_add_one; eh_count_errors; eh_report; eh_clear;_} -> eh_add_one
-let (__proj__Mkerror_handler__item__eh_count_errors :
-  error_handler -> unit -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { eh_add_one; eh_count_errors; eh_report; eh_clear;_} ->
-        eh_count_errors
-let (__proj__Mkerror_handler__item__eh_report :
-  error_handler -> unit -> issue Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { eh_add_one; eh_count_errors; eh_report; eh_clear;_} -> eh_report
-let (__proj__Mkerror_handler__item__eh_clear : error_handler -> unit -> unit)
-  =
-  fun projectee ->
-    match projectee with
-    | { eh_add_one; eh_count_errors; eh_report; eh_clear;_} -> eh_clear
-let (ctx_string : Prims.string Prims.list -> Prims.string) =
-  fun ctx ->
-    let uu___ = FStar_Options.error_contexts () in
-    if uu___
-    then
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater ctx
-          (FStar_Compiler_List.map (fun s -> FStar_String.op_Hat "\n> " s)) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 (FStar_String.concat "")
-    else ""
-let (issue_message : issue -> Prims.string) =
-  fun i ->
-    let uu___ = ctx_string i.issue_ctx in
-    FStar_String.op_Hat i.issue_msg uu___
-let (format_issue : issue -> Prims.string) =
-  fun issue1 ->
-    let level_header =
-      match issue1.issue_level with
-      | EInfo -> "Info"
-      | EWarning -> "Warning"
-      | EError -> "Error"
-      | ENotImplemented -> "Feature not yet implemented: " in
-    let uu___ =
-      match issue1.issue_range with
-      | FStar_Pervasives_Native.None -> ("", "")
-      | FStar_Pervasives_Native.Some r when
-          r = FStar_Compiler_Range.dummyRange ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Compiler_Range.def_range r in
-              let uu___4 =
-                FStar_Compiler_Range.def_range
-                  FStar_Compiler_Range.dummyRange in
-              uu___3 = uu___4 in
-            if uu___2
-            then ""
-            else
-              (let uu___4 = FStar_Compiler_Range.string_of_range r in
-               FStar_Compiler_Util.format1 " (see also %s)" uu___4) in
-          ("", uu___1)
-      | FStar_Pervasives_Native.Some r ->
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Range.string_of_use_range r in
-            FStar_Compiler_Util.format1 "%s: " uu___2 in
-          let uu___2 =
-            let uu___3 =
-              (let uu___4 = FStar_Compiler_Range.use_range r in
-               let uu___5 = FStar_Compiler_Range.def_range r in
-               uu___4 = uu___5) ||
-                (let uu___4 = FStar_Compiler_Range.def_range r in
-                 let uu___5 =
-                   FStar_Compiler_Range.def_range
-                     FStar_Compiler_Range.dummyRange in
-                 uu___4 = uu___5) in
-            if uu___3
-            then ""
-            else
-              (let uu___5 = FStar_Compiler_Range.string_of_range r in
-               FStar_Compiler_Util.format1 " (see also %s)" uu___5) in
-          (uu___1, uu___2) in
-    match uu___ with
-    | (range_str, see_also_str) ->
-        let issue_number =
-          match issue1.issue_number with
-          | FStar_Pervasives_Native.None -> ""
-          | FStar_Pervasives_Native.Some n ->
-              let uu___1 = FStar_Compiler_Util.string_of_int n in
-              FStar_Compiler_Util.format1 " %s" uu___1 in
-        let uu___1 = issue_message issue1 in
-        FStar_Compiler_Util.format5 "%s(%s%s) %s%s" range_str level_header
-          issue_number uu___1 see_also_str
-let (print_issue : issue -> unit) =
-  fun issue1 ->
-    let printer =
-      match issue1.issue_level with
-      | EInfo -> FStar_Compiler_Util.print_string
-      | EWarning -> FStar_Compiler_Util.print_warning
-      | EError -> FStar_Compiler_Util.print_error
-      | ENotImplemented -> FStar_Compiler_Util.print_error in
-    let uu___ =
-      let uu___1 = format_issue issue1 in FStar_String.op_Hat uu___1 "\n" in
-    printer uu___
-let (compare_issues : issue -> issue -> Prims.int) =
-  fun i1 ->
-    fun i2 ->
-      match ((i1.issue_range), (i2.issue_range)) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-          Prims.int_zero
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some uu___) ->
-          ~- Prims.int_one
-      | (FStar_Pervasives_Native.Some uu___, FStar_Pervasives_Native.None) ->
-          Prims.int_one
-      | (FStar_Pervasives_Native.Some r1, FStar_Pervasives_Native.Some r2) ->
-          FStar_Compiler_Range.compare_use_range r1 r2
-let (mk_default_handler : Prims.bool -> error_handler) =
-  fun print ->
-    let issues = FStar_Compiler_Util.mk_ref [] in
-    let add_one e =
-      (match e.issue_level with
-       | EInfo -> print_issue e
-       | uu___1 ->
-           let uu___2 =
-             let uu___3 = FStar_Compiler_Effect.op_Bang issues in e :: uu___3 in
-           FStar_Compiler_Effect.op_Colon_Equals issues uu___2);
-      (let uu___2 =
-         (FStar_Options.defensive_abort ()) &&
-           (e.issue_number = (FStar_Pervasives_Native.Some defensive_errno)) in
-       if uu___2 then failwith "Aborting due to --defensive abort" else ()) in
-    let count_errors uu___ =
-      let uu___1 = FStar_Compiler_Effect.op_Bang issues in
-      FStar_Compiler_List.fold_left
-        (fun n ->
-           fun i ->
-             match i.issue_level with
-             | EError -> n + Prims.int_one
-             | uu___2 -> n) Prims.int_zero uu___1 in
-    let report uu___ =
-      let unique_issues =
-        let uu___1 = FStar_Compiler_Effect.op_Bang issues in
-        FStar_Compiler_Util.remove_dups (fun i0 -> fun i1 -> i0 = i1) uu___1 in
-      let sorted_unique_issues =
-        FStar_Compiler_List.sortWith compare_issues unique_issues in
-      if print
-      then FStar_Compiler_List.iter print_issue sorted_unique_issues
-      else ();
-      sorted_unique_issues in
-    let clear uu___ = FStar_Compiler_Effect.op_Colon_Equals issues [] in
-    {
-      eh_add_one = add_one;
-      eh_count_errors = count_errors;
-      eh_report = report;
-      eh_clear = clear
-    }
-let (default_handler : error_handler) = mk_default_handler true
-let (current_handler : error_handler FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref default_handler
-let (mk_issue :
-  issue_level ->
-    FStar_Compiler_Range.range FStar_Pervasives_Native.option ->
-      Prims.string ->
-        Prims.int FStar_Pervasives_Native.option ->
-          Prims.string Prims.list -> issue)
-  =
-  fun level ->
-    fun range ->
-      fun msg ->
-        fun n ->
-          fun ctx ->
-            {
-              issue_msg = msg;
-              issue_level = level;
-              issue_range = range;
-              issue_number = n;
-              issue_ctx = ctx
-            }
-let (get_err_count : unit -> Prims.int) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang current_handler in
-    uu___1.eh_count_errors ()
-let (wrapped_eh_add_one : error_handler -> issue -> unit) =
-  fun h ->
-    fun issue1 ->
-      h.eh_add_one issue1;
-      if issue1.issue_level <> EInfo
-      then
-        ((let uu___2 =
-            let uu___3 =
-              FStar_Compiler_Effect.op_Bang FStar_Options.abort_counter in
-            uu___3 - Prims.int_one in
-          FStar_Compiler_Effect.op_Colon_Equals FStar_Options.abort_counter
-            uu___2);
-         (let uu___2 =
-            let uu___3 =
-              FStar_Compiler_Effect.op_Bang FStar_Options.abort_counter in
-            uu___3 = Prims.int_zero in
-          if uu___2 then failwith "Aborting due to --abort_on" else ()))
-      else ()
-let (add_one : issue -> unit) =
-  fun issue1 ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         let uu___1 = FStar_Compiler_Effect.op_Bang current_handler in
-         wrapped_eh_add_one uu___1 issue1)
-let (add_many : issue Prims.list -> unit) =
-  fun issues ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         let uu___1 =
-           let uu___2 = FStar_Compiler_Effect.op_Bang current_handler in
-           wrapped_eh_add_one uu___2 in
-         FStar_Compiler_List.iter uu___1 issues)
-let (report_all : unit -> issue Prims.list) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang current_handler in
-    uu___1.eh_report ()
-let (clear : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang current_handler in
-    uu___1.eh_clear ()
-let (set_handler : error_handler -> unit) =
-  fun handler ->
-    let issues = report_all () in
-    clear ();
-    FStar_Compiler_Effect.op_Colon_Equals current_handler handler;
-    add_many issues
-type error_context_t =
-  {
-  push: Prims.string -> unit ;
-  pop: unit -> Prims.string ;
-  clear: unit -> unit ;
-  get: unit -> Prims.string Prims.list }
-let (__proj__Mkerror_context_t__item__push :
-  error_context_t -> Prims.string -> unit) =
-  fun projectee ->
-    match projectee with | { push; pop; clear = clear1; get;_} -> push
-let (__proj__Mkerror_context_t__item__pop :
-  error_context_t -> unit -> Prims.string) =
-  fun projectee ->
-    match projectee with | { push; pop; clear = clear1; get;_} -> pop
-let (__proj__Mkerror_context_t__item__clear :
-  error_context_t -> unit -> unit) =
-  fun projectee ->
-    match projectee with | { push; pop; clear = clear1; get;_} -> clear1
-let (__proj__Mkerror_context_t__item__get :
-  error_context_t -> unit -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with | { push; pop; clear = clear1; get;_} -> get
-let (error_context : error_context_t) =
-  let ctxs = FStar_Compiler_Util.mk_ref [] in
-  let push s =
-    let uu___ =
-      let uu___1 = FStar_Compiler_Effect.op_Bang ctxs in s :: uu___1 in
-    FStar_Compiler_Effect.op_Colon_Equals ctxs uu___ in
-  let pop s =
-    let uu___ = FStar_Compiler_Effect.op_Bang ctxs in
-    match uu___ with
-    | h::t -> (FStar_Compiler_Effect.op_Colon_Equals ctxs t; h)
-    | uu___1 -> failwith "cannot pop error prefix..." in
-  let clear1 uu___ = FStar_Compiler_Effect.op_Colon_Equals ctxs [] in
-  let get uu___ = FStar_Compiler_Effect.op_Bang ctxs in
-  { push; pop; clear = clear1; get }
-let (get_ctx : unit -> Prims.string Prims.list) =
-  fun uu___ -> error_context.get ()
-let (diag : FStar_Compiler_Range.range -> Prims.string -> unit) =
-  fun r ->
-    fun msg ->
-      let uu___ = FStar_Options.debug_any () in
-      if uu___
-      then
-        add_one
-          (mk_issue EInfo (FStar_Pervasives_Native.Some r) msg
-             FStar_Pervasives_Native.None [])
-      else ()
-let (warn_unsafe_options :
-  FStar_Compiler_Range.range FStar_Pervasives_Native.option ->
-    Prims.string -> unit)
-  =
-  fun rng_opt ->
-    fun msg ->
-      let uu___ = FStar_Options.report_assumes () in
-      match uu___ with
-      | FStar_Pervasives_Native.Some "warn" ->
-          let uu___1 =
-            let uu___2 =
-              FStar_String.op_Hat
-                "Every use of this option triggers a warning: " msg in
-            mk_issue EWarning rng_opt uu___2
-              (FStar_Pervasives_Native.Some warn_on_use_errno) [] in
-          add_one uu___1
-      | FStar_Pervasives_Native.Some "error" ->
-          let uu___1 =
-            let uu___2 =
-              FStar_String.op_Hat
-                "Every use of this option triggers an error: " msg in
-            mk_issue EError rng_opt uu___2
-              (FStar_Pervasives_Native.Some warn_on_use_errno) [] in
-          add_one uu___1
-      | uu___1 -> ()
-let (set_option_warning_callback_range :
-  FStar_Compiler_Range.range FStar_Pervasives_Native.option -> unit) =
-  fun ropt ->
-    FStar_Options.set_option_warning_callback (warn_unsafe_options ropt)
-let (uu___254 :
-  (((Prims.string -> error_setting Prims.list) -> unit) *
-    (unit -> error_setting Prims.list)))
-  =
-  let parser_callback =
-    FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let error_flags = FStar_Compiler_Util.smap_create (Prims.of_int (10)) in
-  let set_error_flags uu___ =
-    let parse s =
-      let uu___1 = FStar_Compiler_Effect.op_Bang parser_callback in
-      match uu___1 with
-      | FStar_Pervasives_Native.None ->
-          failwith "Callback for parsing warn_error strings is not set"
-      | FStar_Pervasives_Native.Some f -> f s in
-    let we = FStar_Options.warn_error () in
-    try
-      (fun uu___1 ->
-         match () with
-         | () ->
-             let r = parse we in
-             (FStar_Compiler_Util.smap_add error_flags we
-                (FStar_Pervasives_Native.Some r);
-              FStar_Getopt.Success)) ()
-    with
-    | Invalid_warn_error_setting msg ->
-        (FStar_Compiler_Util.smap_add error_flags we
-           FStar_Pervasives_Native.None;
-         (let uu___3 =
-            FStar_String.op_Hat "Invalid --warn_error setting: " msg in
-          FStar_Getopt.Error uu___3)) in
-  let get_error_flags uu___ =
-    let we = FStar_Options.warn_error () in
-    let uu___1 = FStar_Compiler_Util.smap_try_find error_flags we in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some (FStar_Pervasives_Native.Some w) -> w
-    | uu___2 -> default_settings in
-  let set_callbacks f =
-    FStar_Compiler_Effect.op_Colon_Equals parser_callback
-      (FStar_Pervasives_Native.Some f);
-    FStar_Options.set_error_flags_callback set_error_flags;
-    FStar_Options.set_option_warning_callback
-      (warn_unsafe_options FStar_Pervasives_Native.None) in
-  (set_callbacks, get_error_flags)
-let (set_parse_warn_error :
-  (Prims.string -> error_setting Prims.list) -> unit) =
-  match uu___254 with
-  | (set_parse_warn_error1, error_flags) -> set_parse_warn_error1
-let (error_flags : unit -> error_setting Prims.list) =
-  match uu___254 with | (set_parse_warn_error1, error_flags1) -> error_flags1
-let (lookup : raw_error -> (raw_error * error_flag * Prims.int)) =
-  fun err ->
-    let flags = error_flags () in
-    let uu___ = lookup_error flags err in
-    match uu___ with
-    | (v, level, i) ->
-        let with_level level1 = (v, level1, i) in
-        (match v with
-         | Warning_Defensive when
-             (FStar_Options.defensive_error ()) ||
-               (FStar_Options.defensive_abort ())
-             -> with_level CAlwaysError
-         | Warning_WarnOnUse ->
-             let level' =
-               let uu___1 = FStar_Options.report_assumes () in
-               match uu___1 with
-               | FStar_Pervasives_Native.None -> level
-               | FStar_Pervasives_Native.Some "warn" ->
-                   (match level with | CSilent -> CWarning | uu___2 -> level)
-               | FStar_Pervasives_Native.Some "error" ->
-                   (match level with
-                    | CWarning -> CError
-                    | CSilent -> CError
-                    | uu___2 -> level)
-               | FStar_Pervasives_Native.Some uu___2 -> level in
-             with_level level'
-         | uu___1 -> with_level level)
-let (log_issue_ctx :
-  FStar_Compiler_Range.range ->
-    (raw_error * Prims.string) -> Prims.string Prims.list -> unit)
-  =
-  fun r ->
-    fun uu___ ->
-      fun ctx ->
-        match uu___ with
-        | (e, msg) ->
-            let uu___1 = lookup e in
-            (match uu___1 with
-             | (uu___2, CAlwaysError, errno) ->
-                 add_one
-                   (mk_issue EError (FStar_Pervasives_Native.Some r) msg
-                      (FStar_Pervasives_Native.Some errno) ctx)
-             | (uu___2, CError, errno) ->
-                 add_one
-                   (mk_issue EError (FStar_Pervasives_Native.Some r) msg
-                      (FStar_Pervasives_Native.Some errno) ctx)
-             | (uu___2, CWarning, errno) ->
-                 add_one
-                   (mk_issue EWarning (FStar_Pervasives_Native.Some r) msg
-                      (FStar_Pervasives_Native.Some errno) ctx)
-             | (uu___2, CSilent, uu___3) -> ()
-             | (uu___2, CFatal, errno) ->
-                 let i =
-                   mk_issue EError (FStar_Pervasives_Native.Some r) msg
-                     (FStar_Pervasives_Native.Some errno) ctx in
-                 let uu___3 = FStar_Options.ide () in
-                 if uu___3
-                 then add_one i
-                 else
-                   (let uu___5 =
-                      let uu___6 = format_issue i in
-                      FStar_String.op_Hat
-                        "don't use log_issue to report fatal error, should use raise_error: "
-                        uu___6 in
-                    failwith uu___5))
-let (log_issue :
-  FStar_Compiler_Range.range -> (raw_error * Prims.string) -> unit) =
-  fun r ->
-    fun uu___ ->
-      match uu___ with
-      | (e, msg) ->
-          let ctx = error_context.get () in log_issue_ctx r (e, msg) ctx
-let (add_errors : error Prims.list -> unit) =
-  fun errs ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         FStar_Compiler_List.iter
-           (fun uu___1 ->
-              match uu___1 with
-              | (e, msg, r, ctx) -> log_issue_ctx r (e, msg) ctx) errs)
-let (issue_of_exn : Prims.exn -> issue FStar_Pervasives_Native.option) =
-  fun e ->
-    match e with
-    | Error (e1, msg, r, ctx) ->
-        let errno = let uu___ = lookup e1 in error_number uu___ in
-        FStar_Pervasives_Native.Some
-          (mk_issue EError (FStar_Pervasives_Native.Some r) msg
-             (FStar_Pervasives_Native.Some errno) ctx)
-    | Err (e1, msg, ctx) ->
-        let errno = let uu___ = lookup e1 in error_number uu___ in
-        FStar_Pervasives_Native.Some
-          (mk_issue EError FStar_Pervasives_Native.None msg
-             (FStar_Pervasives_Native.Some errno) ctx)
-    | uu___ -> FStar_Pervasives_Native.None
-let (err_exn : Prims.exn -> unit) =
-  fun exn ->
-    if exn = Stop
-    then ()
-    else
-      (let uu___1 = issue_of_exn exn in
-       match uu___1 with
-       | FStar_Pervasives_Native.Some issue1 -> add_one issue1
-       | FStar_Pervasives_Native.None -> FStar_Compiler_Effect.raise exn)
-let (handleable : Prims.exn -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | Error uu___1 -> true
-    | Stop -> true
-    | Err uu___1 -> true
-    | uu___1 -> false
-let (stop_if_err : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = let uu___2 = get_err_count () in uu___2 > Prims.int_zero in
-    if uu___1 then FStar_Compiler_Effect.raise Stop else ()
-let raise_error :
-  'uuuuu . (raw_error * Prims.string) -> FStar_Compiler_Range.range -> 'uuuuu
-  =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (e, msg) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = error_context.get () in (e, msg, r, uu___3) in
-            Error uu___2 in
-          FStar_Compiler_Effect.raise uu___1
-let raise_err : 'uuuuu . (raw_error * Prims.string) -> 'uuuuu =
-  fun uu___ ->
-    match uu___ with
-    | (e, msg) ->
-        let uu___1 =
-          let uu___2 = let uu___3 = error_context.get () in (e, msg, uu___3) in
-          Err uu___2 in
-        FStar_Compiler_Effect.raise uu___1
-let with_ctx : 'a . Prims.string -> (unit -> 'a) -> 'a =
-  fun s ->
-    fun f ->
-      error_context.push s;
-      (let r =
-         let uu___1 = FStar_Options.trace_error () in
-         if uu___1
-         then let uu___2 = f () in FStar_Pervasives.Inr uu___2
-         else
-           (try
-              (fun uu___3 ->
-                 match () with
-                 | () -> let uu___4 = f () in FStar_Pervasives.Inr uu___4) ()
-            with
-            | FStar_Compiler_Effect.Failure msg ->
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = error_context.get () in ctx_string uu___7 in
-                    FStar_String.op_Hat msg uu___6 in
-                  FStar_Compiler_Effect.Failure uu___5 in
-                FStar_Pervasives.Inl uu___4
-            | ex -> FStar_Pervasives.Inl ex) in
-       (let uu___2 = error_context.pop () in ());
-       (match r with
-        | FStar_Pervasives.Inr r1 -> r1
-        | FStar_Pervasives.Inl e -> FStar_Compiler_Effect.raise e))
-let with_ctx_if : 'a . Prims.bool -> Prims.string -> (unit -> 'a) -> 'a =
-  fun b -> fun s -> fun f -> if b then with_ctx s f else f ()
-let catch_errors :
-  'a . (unit -> 'a) -> (issue Prims.list * 'a FStar_Pervasives_Native.option)
-  =
-  fun f ->
-    let newh = mk_default_handler false in
-    let old = FStar_Compiler_Effect.op_Bang current_handler in
-    FStar_Compiler_Effect.op_Colon_Equals current_handler newh;
-    (let r =
-       try
-         (fun uu___1 ->
-            match () with
-            | () -> let uu___2 = f () in FStar_Pervasives_Native.Some uu___2)
-           ()
-       with | uu___1 -> (err_exn uu___1; FStar_Pervasives_Native.None) in
-     let all_issues = newh.eh_report () in
-     FStar_Compiler_Effect.op_Colon_Equals current_handler old;
-     (let uu___2 =
-        FStar_Compiler_List.partition (fun i -> i.issue_level = EError)
-          all_issues in
-      match uu___2 with
-      | (errs, rest) ->
-          (FStar_Compiler_List.iter old.eh_add_one rest; (errs, r))))
-let (find_multiset_discrepancy :
-  Prims.int Prims.list ->
-    Prims.int Prims.list ->
-      (Prims.int * Prims.int * Prims.int) FStar_Pervasives_Native.option)
-  =
-  fun l1 ->
-    fun l2 ->
-      let sort = FStar_Compiler_List.sortWith (fun x -> fun y -> x - y) in
-      let rec collect l =
-        match l with
-        | [] -> []
-        | hd::tl ->
-            let uu___ = collect tl in
-            (match uu___ with
-             | [] -> [(hd, Prims.int_one)]
-             | (h, n)::t ->
-                 if h = hd
-                 then (h, (n + Prims.int_one)) :: t
-                 else (hd, Prims.int_one) :: (h, n) :: t) in
-      let summ l = collect l in
-      let l11 = let uu___ = sort l1 in summ uu___ in
-      let l21 = let uu___ = sort l2 in summ uu___ in
-      let rec aux l12 l22 =
-        match (l12, l22) with
-        | ([], []) -> FStar_Pervasives_Native.None
-        | ((e, n)::uu___, []) ->
-            FStar_Pervasives_Native.Some (e, n, Prims.int_zero)
-        | ([], (e, n)::uu___) ->
-            FStar_Pervasives_Native.Some (e, Prims.int_zero, n)
-        | ((hd1, n1)::tl1, (hd2, n2)::tl2) ->
-            if hd1 < hd2
-            then FStar_Pervasives_Native.Some (hd1, n1, Prims.int_zero)
-            else
-              if hd1 > hd2
-              then FStar_Pervasives_Native.Some (hd2, Prims.int_zero, n2)
-              else
-                if n1 <> n2
-                then FStar_Pervasives_Native.Some (hd1, n1, n2)
-                else aux tl1 tl2 in
-      aux l11 l21
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_Krml.ml b/src/ocaml-output/FStar_Extraction_Krml.ml
deleted file mode 100644
index 9ba78c814d9..00000000000
--- a/src/ocaml-output/FStar_Extraction_Krml.ml
+++ /dev/null
@@ -1,4322 +0,0 @@
-open Prims
-type decl =
-  | DGlobal of (flag Prims.list * (Prims.string Prims.list * Prims.string) *
-  Prims.int * typ * expr) 
-  | DFunction of (cc FStar_Pervasives_Native.option * flag Prims.list *
-  Prims.int * typ * (Prims.string Prims.list * Prims.string) * binder
-  Prims.list * expr) 
-  | DTypeAlias of ((Prims.string Prims.list * Prims.string) * flag Prims.list
-  * Prims.int * typ) 
-  | DTypeFlat of ((Prims.string Prims.list * Prims.string) * flag Prims.list
-  * Prims.int * (Prims.string * (typ * Prims.bool)) Prims.list) 
-  | DUnusedRetainedForBackwardsCompat of (cc FStar_Pervasives_Native.option *
-  flag Prims.list * (Prims.string Prims.list * Prims.string) * typ) 
-  | DTypeVariant of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * (Prims.string * (typ *
-  Prims.bool)) Prims.list) Prims.list) 
-  | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
-  | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
-  (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
-and cc =
-  | StdCall 
-  | CDecl 
-  | FastCall 
-and flag =
-  | Private 
-  | WipeBody 
-  | CInline 
-  | Substitute 
-  | GCType 
-  | Comment of Prims.string 
-  | MustDisappear 
-  | Const of Prims.string 
-  | Prologue of Prims.string 
-  | Epilogue of Prims.string 
-  | Abstract 
-  | IfDef 
-  | Macro 
-  | Deprecated of Prims.string 
-and lifetime =
-  | Eternal 
-  | Stack 
-  | ManuallyManaged 
-and expr =
-  | EBound of Prims.int 
-  | EQualified of (Prims.string Prims.list * Prims.string) 
-  | EConstant of (width * Prims.string) 
-  | EUnit 
-  | EApp of (expr * expr Prims.list) 
-  | ETypApp of (expr * typ Prims.list) 
-  | ELet of (binder * expr * expr) 
-  | EIfThenElse of (expr * expr * expr) 
-  | ESequence of expr Prims.list 
-  | EAssign of (expr * expr) 
-  | EBufCreate of (lifetime * expr * expr) 
-  | EBufRead of (expr * expr) 
-  | EBufWrite of (expr * expr * expr) 
-  | EBufSub of (expr * expr) 
-  | EBufBlit of (expr * expr * expr * expr * expr) 
-  | EMatch of (expr * (pattern * expr) Prims.list) 
-  | EOp of (op * width) 
-  | ECast of (expr * typ) 
-  | EPushFrame 
-  | EPopFrame 
-  | EBool of Prims.bool 
-  | EAny 
-  | EAbort 
-  | EReturn of expr 
-  | EFlat of (typ * (Prims.string * expr) Prims.list) 
-  | EField of (typ * expr * Prims.string) 
-  | EWhile of (expr * expr) 
-  | EBufCreateL of (lifetime * expr Prims.list) 
-  | ETuple of expr Prims.list 
-  | ECons of (typ * Prims.string * expr Prims.list) 
-  | EBufFill of (expr * expr * expr) 
-  | EString of Prims.string 
-  | EFun of (binder Prims.list * expr * typ) 
-  | EAbortS of Prims.string 
-  | EBufFree of expr 
-  | EBufCreateNoInit of (lifetime * expr) 
-  | EAbortT of (Prims.string * typ) 
-  | EComment of (Prims.string * expr * Prims.string) 
-  | EStandaloneComment of Prims.string 
-  | EAddrOf of expr 
-  | EBufNull of typ 
-  | EBufDiff of (expr * expr) 
-and op =
-  | Add 
-  | AddW 
-  | Sub 
-  | SubW 
-  | Div 
-  | DivW 
-  | Mult 
-  | MultW 
-  | Mod 
-  | BOr 
-  | BAnd 
-  | BXor 
-  | BShiftL 
-  | BShiftR 
-  | BNot 
-  | Eq 
-  | Neq 
-  | Lt 
-  | Lte 
-  | Gt 
-  | Gte 
-  | And 
-  | Or 
-  | Xor 
-  | Not 
-and pattern =
-  | PUnit 
-  | PBool of Prims.bool 
-  | PVar of binder 
-  | PCons of (Prims.string * pattern Prims.list) 
-  | PTuple of pattern Prims.list 
-  | PRecord of (Prims.string * pattern) Prims.list 
-  | PConstant of (width * Prims.string) 
-and width =
-  | UInt8 
-  | UInt16 
-  | UInt32 
-  | UInt64 
-  | Int8 
-  | Int16 
-  | Int32 
-  | Int64 
-  | Bool 
-  | CInt 
-  | SizeT 
-  | PtrdiffT 
-and binder = {
-  name: Prims.string ;
-  typ: typ ;
-  mut: Prims.bool }
-and typ =
-  | TInt of width 
-  | TBuf of typ 
-  | TUnit 
-  | TQualified of (Prims.string Prims.list * Prims.string) 
-  | TBool 
-  | TAny 
-  | TArrow of (typ * typ) 
-  | TBound of Prims.int 
-  | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
-  | TTuple of typ Prims.list 
-  | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
-let (uu___is_DGlobal : decl -> Prims.bool) =
-  fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
-let (__proj__DGlobal__item___0 :
-  decl ->
-    (flag Prims.list * (Prims.string Prims.list * Prims.string) * Prims.int *
-      typ * expr))
-  = fun projectee -> match projectee with | DGlobal _0 -> _0
-let (uu___is_DFunction : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DFunction _0 -> true | uu___ -> false
-let (__proj__DFunction__item___0 :
-  decl ->
-    (cc FStar_Pervasives_Native.option * flag Prims.list * Prims.int * typ *
-      (Prims.string Prims.list * Prims.string) * binder Prims.list * expr))
-  = fun projectee -> match projectee with | DFunction _0 -> _0
-let (uu___is_DTypeAlias : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DTypeAlias _0 -> true | uu___ -> false
-let (__proj__DTypeAlias__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      typ))
-  = fun projectee -> match projectee with | DTypeAlias _0 -> _0
-let (uu___is_DTypeFlat : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DTypeFlat _0 -> true | uu___ -> false
-let (__proj__DTypeFlat__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * (typ * Prims.bool)) Prims.list))
-  = fun projectee -> match projectee with | DTypeFlat _0 -> _0
-let (uu___is_DUnusedRetainedForBackwardsCompat : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | DUnusedRetainedForBackwardsCompat _0 -> true
-    | uu___ -> false
-let (__proj__DUnusedRetainedForBackwardsCompat__item___0 :
-  decl ->
-    (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
-      Prims.list * Prims.string) * typ))
-  =
-  fun projectee ->
-    match projectee with | DUnusedRetainedForBackwardsCompat _0 -> _0
-let (uu___is_DTypeVariant : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DTypeVariant _0 -> true | uu___ -> false
-let (__proj__DTypeVariant__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * (Prims.string * (typ * Prims.bool)) Prims.list)
-      Prims.list))
-  = fun projectee -> match projectee with | DTypeVariant _0 -> _0
-let (uu___is_DTypeAbstractStruct : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DTypeAbstractStruct _0 -> true | uu___ -> false
-let (__proj__DTypeAbstractStruct__item___0 :
-  decl -> (Prims.string Prims.list * Prims.string)) =
-  fun projectee -> match projectee with | DTypeAbstractStruct _0 -> _0
-let (uu___is_DExternal : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DExternal _0 -> true | uu___ -> false
-let (__proj__DExternal__item___0 :
-  decl ->
-    (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
-      Prims.list * Prims.string) * typ * Prims.string Prims.list))
-  = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
-let (uu___is_StdCall : cc -> Prims.bool) =
-  fun projectee -> match projectee with | StdCall -> true | uu___ -> false
-let (uu___is_CDecl : cc -> Prims.bool) =
-  fun projectee -> match projectee with | CDecl -> true | uu___ -> false
-let (uu___is_FastCall : cc -> Prims.bool) =
-  fun projectee -> match projectee with | FastCall -> true | uu___ -> false
-let (uu___is_Private : flag -> Prims.bool) =
-  fun projectee -> match projectee with | Private -> true | uu___ -> false
-let (uu___is_WipeBody : flag -> Prims.bool) =
-  fun projectee -> match projectee with | WipeBody -> true | uu___ -> false
-let (uu___is_CInline : flag -> Prims.bool) =
-  fun projectee -> match projectee with | CInline -> true | uu___ -> false
-let (uu___is_Substitute : flag -> Prims.bool) =
-  fun projectee -> match projectee with | Substitute -> true | uu___ -> false
-let (uu___is_GCType : flag -> Prims.bool) =
-  fun projectee -> match projectee with | GCType -> true | uu___ -> false
-let (uu___is_Comment : flag -> Prims.bool) =
-  fun projectee -> match projectee with | Comment _0 -> true | uu___ -> false
-let (__proj__Comment__item___0 : flag -> Prims.string) =
-  fun projectee -> match projectee with | Comment _0 -> _0
-let (uu___is_MustDisappear : flag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MustDisappear -> true | uu___ -> false
-let (uu___is_Const : flag -> Prims.bool) =
-  fun projectee -> match projectee with | Const _0 -> true | uu___ -> false
-let (__proj__Const__item___0 : flag -> Prims.string) =
-  fun projectee -> match projectee with | Const _0 -> _0
-let (uu___is_Prologue : flag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Prologue _0 -> true | uu___ -> false
-let (__proj__Prologue__item___0 : flag -> Prims.string) =
-  fun projectee -> match projectee with | Prologue _0 -> _0
-let (uu___is_Epilogue : flag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Epilogue _0 -> true | uu___ -> false
-let (__proj__Epilogue__item___0 : flag -> Prims.string) =
-  fun projectee -> match projectee with | Epilogue _0 -> _0
-let (uu___is_Abstract : flag -> Prims.bool) =
-  fun projectee -> match projectee with | Abstract -> true | uu___ -> false
-let (uu___is_IfDef : flag -> Prims.bool) =
-  fun projectee -> match projectee with | IfDef -> true | uu___ -> false
-let (uu___is_Macro : flag -> Prims.bool) =
-  fun projectee -> match projectee with | Macro -> true | uu___ -> false
-let (uu___is_Deprecated : flag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Deprecated _0 -> true | uu___ -> false
-let (__proj__Deprecated__item___0 : flag -> Prims.string) =
-  fun projectee -> match projectee with | Deprecated _0 -> _0
-let (uu___is_Eternal : lifetime -> Prims.bool) =
-  fun projectee -> match projectee with | Eternal -> true | uu___ -> false
-let (uu___is_Stack : lifetime -> Prims.bool) =
-  fun projectee -> match projectee with | Stack -> true | uu___ -> false
-let (uu___is_ManuallyManaged : lifetime -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ManuallyManaged -> true | uu___ -> false
-let (uu___is_EBound : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EBound _0 -> true | uu___ -> false
-let (__proj__EBound__item___0 : expr -> Prims.int) =
-  fun projectee -> match projectee with | EBound _0 -> _0
-let (uu___is_EQualified : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EQualified _0 -> true | uu___ -> false
-let (__proj__EQualified__item___0 :
-  expr -> (Prims.string Prims.list * Prims.string)) =
-  fun projectee -> match projectee with | EQualified _0 -> _0
-let (uu___is_EConstant : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EConstant _0 -> true | uu___ -> false
-let (__proj__EConstant__item___0 : expr -> (width * Prims.string)) =
-  fun projectee -> match projectee with | EConstant _0 -> _0
-let (uu___is_EUnit : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EUnit -> true | uu___ -> false
-let (uu___is_EApp : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EApp _0 -> true | uu___ -> false
-let (__proj__EApp__item___0 : expr -> (expr * expr Prims.list)) =
-  fun projectee -> match projectee with | EApp _0 -> _0
-let (uu___is_ETypApp : expr -> Prims.bool) =
-  fun projectee -> match projectee with | ETypApp _0 -> true | uu___ -> false
-let (__proj__ETypApp__item___0 : expr -> (expr * typ Prims.list)) =
-  fun projectee -> match projectee with | ETypApp _0 -> _0
-let (uu___is_ELet : expr -> Prims.bool) =
-  fun projectee -> match projectee with | ELet _0 -> true | uu___ -> false
-let (__proj__ELet__item___0 : expr -> (binder * expr * expr)) =
-  fun projectee -> match projectee with | ELet _0 -> _0
-let (uu___is_EIfThenElse : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EIfThenElse _0 -> true | uu___ -> false
-let (__proj__EIfThenElse__item___0 : expr -> (expr * expr * expr)) =
-  fun projectee -> match projectee with | EIfThenElse _0 -> _0
-let (uu___is_ESequence : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ESequence _0 -> true | uu___ -> false
-let (__proj__ESequence__item___0 : expr -> expr Prims.list) =
-  fun projectee -> match projectee with | ESequence _0 -> _0
-let (uu___is_EAssign : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAssign _0 -> true | uu___ -> false
-let (__proj__EAssign__item___0 : expr -> (expr * expr)) =
-  fun projectee -> match projectee with | EAssign _0 -> _0
-let (uu___is_EBufCreate : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufCreate _0 -> true | uu___ -> false
-let (__proj__EBufCreate__item___0 : expr -> (lifetime * expr * expr)) =
-  fun projectee -> match projectee with | EBufCreate _0 -> _0
-let (uu___is_EBufRead : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufRead _0 -> true | uu___ -> false
-let (__proj__EBufRead__item___0 : expr -> (expr * expr)) =
-  fun projectee -> match projectee with | EBufRead _0 -> _0
-let (uu___is_EBufWrite : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufWrite _0 -> true | uu___ -> false
-let (__proj__EBufWrite__item___0 : expr -> (expr * expr * expr)) =
-  fun projectee -> match projectee with | EBufWrite _0 -> _0
-let (uu___is_EBufSub : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EBufSub _0 -> true | uu___ -> false
-let (__proj__EBufSub__item___0 : expr -> (expr * expr)) =
-  fun projectee -> match projectee with | EBufSub _0 -> _0
-let (uu___is_EBufBlit : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufBlit _0 -> true | uu___ -> false
-let (__proj__EBufBlit__item___0 : expr -> (expr * expr * expr * expr * expr))
-  = fun projectee -> match projectee with | EBufBlit _0 -> _0
-let (uu___is_EMatch : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EMatch _0 -> true | uu___ -> false
-let (__proj__EMatch__item___0 : expr -> (expr * (pattern * expr) Prims.list))
-  = fun projectee -> match projectee with | EMatch _0 -> _0
-let (uu___is_EOp : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EOp _0 -> true | uu___ -> false
-let (__proj__EOp__item___0 : expr -> (op * width)) =
-  fun projectee -> match projectee with | EOp _0 -> _0
-let (uu___is_ECast : expr -> Prims.bool) =
-  fun projectee -> match projectee with | ECast _0 -> true | uu___ -> false
-let (__proj__ECast__item___0 : expr -> (expr * typ)) =
-  fun projectee -> match projectee with | ECast _0 -> _0
-let (uu___is_EPushFrame : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EPushFrame -> true | uu___ -> false
-let (uu___is_EPopFrame : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EPopFrame -> true | uu___ -> false
-let (uu___is_EBool : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EBool _0 -> true | uu___ -> false
-let (__proj__EBool__item___0 : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EBool _0 -> _0
-let (uu___is_EAny : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAny -> true | uu___ -> false
-let (uu___is_EAbort : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAbort -> true | uu___ -> false
-let (uu___is_EReturn : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EReturn _0 -> true | uu___ -> false
-let (__proj__EReturn__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EReturn _0 -> _0
-let (uu___is_EFlat : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EFlat _0 -> true | uu___ -> false
-let (__proj__EFlat__item___0 :
-  expr -> (typ * (Prims.string * expr) Prims.list)) =
-  fun projectee -> match projectee with | EFlat _0 -> _0
-let (uu___is_EField : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EField _0 -> true | uu___ -> false
-let (__proj__EField__item___0 : expr -> (typ * expr * Prims.string)) =
-  fun projectee -> match projectee with | EField _0 -> _0
-let (uu___is_EWhile : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EWhile _0 -> true | uu___ -> false
-let (__proj__EWhile__item___0 : expr -> (expr * expr)) =
-  fun projectee -> match projectee with | EWhile _0 -> _0
-let (uu___is_EBufCreateL : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufCreateL _0 -> true | uu___ -> false
-let (__proj__EBufCreateL__item___0 : expr -> (lifetime * expr Prims.list)) =
-  fun projectee -> match projectee with | EBufCreateL _0 -> _0
-let (uu___is_ETuple : expr -> Prims.bool) =
-  fun projectee -> match projectee with | ETuple _0 -> true | uu___ -> false
-let (__proj__ETuple__item___0 : expr -> expr Prims.list) =
-  fun projectee -> match projectee with | ETuple _0 -> _0
-let (uu___is_ECons : expr -> Prims.bool) =
-  fun projectee -> match projectee with | ECons _0 -> true | uu___ -> false
-let (__proj__ECons__item___0 :
-  expr -> (typ * Prims.string * expr Prims.list)) =
-  fun projectee -> match projectee with | ECons _0 -> _0
-let (uu___is_EBufFill : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufFill _0 -> true | uu___ -> false
-let (__proj__EBufFill__item___0 : expr -> (expr * expr * expr)) =
-  fun projectee -> match projectee with | EBufFill _0 -> _0
-let (uu___is_EString : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EString _0 -> true | uu___ -> false
-let (__proj__EString__item___0 : expr -> Prims.string) =
-  fun projectee -> match projectee with | EString _0 -> _0
-let (uu___is_EFun : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EFun _0 -> true | uu___ -> false
-let (__proj__EFun__item___0 : expr -> (binder Prims.list * expr * typ)) =
-  fun projectee -> match projectee with | EFun _0 -> _0
-let (uu___is_EAbortS : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAbortS _0 -> true | uu___ -> false
-let (__proj__EAbortS__item___0 : expr -> Prims.string) =
-  fun projectee -> match projectee with | EAbortS _0 -> _0
-let (uu___is_EBufFree : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufFree _0 -> true | uu___ -> false
-let (__proj__EBufFree__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EBufFree _0 -> _0
-let (uu___is_EBufCreateNoInit : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufCreateNoInit _0 -> true | uu___ -> false
-let (__proj__EBufCreateNoInit__item___0 : expr -> (lifetime * expr)) =
-  fun projectee -> match projectee with | EBufCreateNoInit _0 -> _0
-let (uu___is_EAbortT : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAbortT _0 -> true | uu___ -> false
-let (__proj__EAbortT__item___0 : expr -> (Prims.string * typ)) =
-  fun projectee -> match projectee with | EAbortT _0 -> _0
-let (uu___is_EComment : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EComment _0 -> true | uu___ -> false
-let (__proj__EComment__item___0 :
-  expr -> (Prims.string * expr * Prims.string)) =
-  fun projectee -> match projectee with | EComment _0 -> _0
-let (uu___is_EStandaloneComment : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EStandaloneComment _0 -> true | uu___ -> false
-let (__proj__EStandaloneComment__item___0 : expr -> Prims.string) =
-  fun projectee -> match projectee with | EStandaloneComment _0 -> _0
-let (uu___is_EAddrOf : expr -> Prims.bool) =
-  fun projectee -> match projectee with | EAddrOf _0 -> true | uu___ -> false
-let (__proj__EAddrOf__item___0 : expr -> expr) =
-  fun projectee -> match projectee with | EAddrOf _0 -> _0
-let (uu___is_EBufNull : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufNull _0 -> true | uu___ -> false
-let (__proj__EBufNull__item___0 : expr -> typ) =
-  fun projectee -> match projectee with | EBufNull _0 -> _0
-let (uu___is_EBufDiff : expr -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EBufDiff _0 -> true | uu___ -> false
-let (__proj__EBufDiff__item___0 : expr -> (expr * expr)) =
-  fun projectee -> match projectee with | EBufDiff _0 -> _0
-let (uu___is_Add : op -> Prims.bool) =
-  fun projectee -> match projectee with | Add -> true | uu___ -> false
-let (uu___is_AddW : op -> Prims.bool) =
-  fun projectee -> match projectee with | AddW -> true | uu___ -> false
-let (uu___is_Sub : op -> Prims.bool) =
-  fun projectee -> match projectee with | Sub -> true | uu___ -> false
-let (uu___is_SubW : op -> Prims.bool) =
-  fun projectee -> match projectee with | SubW -> true | uu___ -> false
-let (uu___is_Div : op -> Prims.bool) =
-  fun projectee -> match projectee with | Div -> true | uu___ -> false
-let (uu___is_DivW : op -> Prims.bool) =
-  fun projectee -> match projectee with | DivW -> true | uu___ -> false
-let (uu___is_Mult : op -> Prims.bool) =
-  fun projectee -> match projectee with | Mult -> true | uu___ -> false
-let (uu___is_MultW : op -> Prims.bool) =
-  fun projectee -> match projectee with | MultW -> true | uu___ -> false
-let (uu___is_Mod : op -> Prims.bool) =
-  fun projectee -> match projectee with | Mod -> true | uu___ -> false
-let (uu___is_BOr : op -> Prims.bool) =
-  fun projectee -> match projectee with | BOr -> true | uu___ -> false
-let (uu___is_BAnd : op -> Prims.bool) =
-  fun projectee -> match projectee with | BAnd -> true | uu___ -> false
-let (uu___is_BXor : op -> Prims.bool) =
-  fun projectee -> match projectee with | BXor -> true | uu___ -> false
-let (uu___is_BShiftL : op -> Prims.bool) =
-  fun projectee -> match projectee with | BShiftL -> true | uu___ -> false
-let (uu___is_BShiftR : op -> Prims.bool) =
-  fun projectee -> match projectee with | BShiftR -> true | uu___ -> false
-let (uu___is_BNot : op -> Prims.bool) =
-  fun projectee -> match projectee with | BNot -> true | uu___ -> false
-let (uu___is_Eq : op -> Prims.bool) =
-  fun projectee -> match projectee with | Eq -> true | uu___ -> false
-let (uu___is_Neq : op -> Prims.bool) =
-  fun projectee -> match projectee with | Neq -> true | uu___ -> false
-let (uu___is_Lt : op -> Prims.bool) =
-  fun projectee -> match projectee with | Lt -> true | uu___ -> false
-let (uu___is_Lte : op -> Prims.bool) =
-  fun projectee -> match projectee with | Lte -> true | uu___ -> false
-let (uu___is_Gt : op -> Prims.bool) =
-  fun projectee -> match projectee with | Gt -> true | uu___ -> false
-let (uu___is_Gte : op -> Prims.bool) =
-  fun projectee -> match projectee with | Gte -> true | uu___ -> false
-let (uu___is_And : op -> Prims.bool) =
-  fun projectee -> match projectee with | And -> true | uu___ -> false
-let (uu___is_Or : op -> Prims.bool) =
-  fun projectee -> match projectee with | Or -> true | uu___ -> false
-let (uu___is_Xor : op -> Prims.bool) =
-  fun projectee -> match projectee with | Xor -> true | uu___ -> false
-let (uu___is_Not : op -> Prims.bool) =
-  fun projectee -> match projectee with | Not -> true | uu___ -> false
-let (uu___is_PUnit : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PUnit -> true | uu___ -> false
-let (uu___is_PBool : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PBool _0 -> true | uu___ -> false
-let (__proj__PBool__item___0 : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PBool _0 -> _0
-let (uu___is_PVar : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PVar _0 -> true | uu___ -> false
-let (__proj__PVar__item___0 : pattern -> binder) =
-  fun projectee -> match projectee with | PVar _0 -> _0
-let (uu___is_PCons : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PCons _0 -> true | uu___ -> false
-let (__proj__PCons__item___0 :
-  pattern -> (Prims.string * pattern Prims.list)) =
-  fun projectee -> match projectee with | PCons _0 -> _0
-let (uu___is_PTuple : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PTuple _0 -> true | uu___ -> false
-let (__proj__PTuple__item___0 : pattern -> pattern Prims.list) =
-  fun projectee -> match projectee with | PTuple _0 -> _0
-let (uu___is_PRecord : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | PRecord _0 -> true | uu___ -> false
-let (__proj__PRecord__item___0 :
-  pattern -> (Prims.string * pattern) Prims.list) =
-  fun projectee -> match projectee with | PRecord _0 -> _0
-let (uu___is_PConstant : pattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PConstant _0 -> true | uu___ -> false
-let (__proj__PConstant__item___0 : pattern -> (width * Prims.string)) =
-  fun projectee -> match projectee with | PConstant _0 -> _0
-let (uu___is_UInt8 : width -> Prims.bool) =
-  fun projectee -> match projectee with | UInt8 -> true | uu___ -> false
-let (uu___is_UInt16 : width -> Prims.bool) =
-  fun projectee -> match projectee with | UInt16 -> true | uu___ -> false
-let (uu___is_UInt32 : width -> Prims.bool) =
-  fun projectee -> match projectee with | UInt32 -> true | uu___ -> false
-let (uu___is_UInt64 : width -> Prims.bool) =
-  fun projectee -> match projectee with | UInt64 -> true | uu___ -> false
-let (uu___is_Int8 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int8 -> true | uu___ -> false
-let (uu___is_Int16 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int16 -> true | uu___ -> false
-let (uu___is_Int32 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int32 -> true | uu___ -> false
-let (uu___is_Int64 : width -> Prims.bool) =
-  fun projectee -> match projectee with | Int64 -> true | uu___ -> false
-let (uu___is_Bool : width -> Prims.bool) =
-  fun projectee -> match projectee with | Bool -> true | uu___ -> false
-let (uu___is_CInt : width -> Prims.bool) =
-  fun projectee -> match projectee with | CInt -> true | uu___ -> false
-let (uu___is_SizeT : width -> Prims.bool) =
-  fun projectee -> match projectee with | SizeT -> true | uu___ -> false
-let (uu___is_PtrdiffT : width -> Prims.bool) =
-  fun projectee -> match projectee with | PtrdiffT -> true | uu___ -> false
-let (__proj__Mkbinder__item__name : binder -> Prims.string) =
-  fun projectee -> match projectee with | { name; typ = typ1; mut;_} -> name
-let (__proj__Mkbinder__item__typ : binder -> typ) =
-  fun projectee -> match projectee with | { name; typ = typ1; mut;_} -> typ1
-let (__proj__Mkbinder__item__mut : binder -> Prims.bool) =
-  fun projectee -> match projectee with | { name; typ = typ1; mut;_} -> mut
-let (uu___is_TInt : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TInt _0 -> true | uu___ -> false
-let (__proj__TInt__item___0 : typ -> width) =
-  fun projectee -> match projectee with | TInt _0 -> _0
-let (uu___is_TBuf : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TBuf _0 -> true | uu___ -> false
-let (__proj__TBuf__item___0 : typ -> typ) =
-  fun projectee -> match projectee with | TBuf _0 -> _0
-let (uu___is_TUnit : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TUnit -> true | uu___ -> false
-let (uu___is_TQualified : typ -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TQualified _0 -> true | uu___ -> false
-let (__proj__TQualified__item___0 :
-  typ -> (Prims.string Prims.list * Prims.string)) =
-  fun projectee -> match projectee with | TQualified _0 -> _0
-let (uu___is_TBool : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TBool -> true | uu___ -> false
-let (uu___is_TAny : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TAny -> true | uu___ -> false
-let (uu___is_TArrow : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArrow _0 -> true | uu___ -> false
-let (__proj__TArrow__item___0 : typ -> (typ * typ)) =
-  fun projectee -> match projectee with | TArrow _0 -> _0
-let (uu___is_TBound : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TBound _0 -> true | uu___ -> false
-let (__proj__TBound__item___0 : typ -> Prims.int) =
-  fun projectee -> match projectee with | TBound _0 -> _0
-let (uu___is_TApp : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TApp _0 -> true | uu___ -> false
-let (__proj__TApp__item___0 :
-  typ -> ((Prims.string Prims.list * Prims.string) * typ Prims.list)) =
-  fun projectee -> match projectee with | TApp _0 -> _0
-let (uu___is_TTuple : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TTuple _0 -> true | uu___ -> false
-let (__proj__TTuple__item___0 : typ -> typ Prims.list) =
-  fun projectee -> match projectee with | TTuple _0 -> _0
-let (uu___is_TConstBuf : typ -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TConstBuf _0 -> true | uu___ -> false
-let (__proj__TConstBuf__item___0 : typ -> typ) =
-  fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
-type ident = Prims.string
-type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
-type branches_t =
-  (Prims.string * (Prims.string * (typ * Prims.bool)) Prims.list) Prims.list
-type fsdoc = Prims.string
-type branch = (pattern * expr)
-type branches = (pattern * expr) Prims.list
-type constant = (width * Prims.string)
-type var = Prims.int
-type lident = (Prims.string Prims.list * Prims.string)
-type program = decl Prims.list
-type file = (Prims.string * program)
-type version = Prims.int
-type binary_format = (version * file Prims.list)
-let (current_version : version) = (Prims.of_int (28))
-let fst3 : 'uuuuu 'uuuuu1 'uuuuu2 . ('uuuuu * 'uuuuu1 * 'uuuuu2) -> 'uuuuu =
-  fun uu___ -> match uu___ with | (x, uu___1, uu___2) -> x
-let snd3 : 'uuuuu 'uuuuu1 'uuuuu2 . ('uuuuu * 'uuuuu1 * 'uuuuu2) -> 'uuuuu1 =
-  fun uu___ -> match uu___ with | (uu___1, x, uu___2) -> x
-let thd3 : 'uuuuu 'uuuuu1 'uuuuu2 . ('uuuuu * 'uuuuu1 * 'uuuuu2) -> 'uuuuu2 =
-  fun uu___ -> match uu___ with | (uu___1, uu___2, x) -> x
-let (mk_width : Prims.string -> width FStar_Pervasives_Native.option) =
-  fun uu___ ->
-    match uu___ with
-    | "UInt8" -> FStar_Pervasives_Native.Some UInt8
-    | "UInt16" -> FStar_Pervasives_Native.Some UInt16
-    | "UInt32" -> FStar_Pervasives_Native.Some UInt32
-    | "UInt64" -> FStar_Pervasives_Native.Some UInt64
-    | "Int8" -> FStar_Pervasives_Native.Some Int8
-    | "Int16" -> FStar_Pervasives_Native.Some Int16
-    | "Int32" -> FStar_Pervasives_Native.Some Int32
-    | "Int64" -> FStar_Pervasives_Native.Some Int64
-    | "SizeT" -> FStar_Pervasives_Native.Some SizeT
-    | "PtrdiffT" -> FStar_Pervasives_Native.Some PtrdiffT
-    | uu___1 -> FStar_Pervasives_Native.None
-let (mk_bool_op : Prims.string -> op FStar_Pervasives_Native.option) =
-  fun uu___ ->
-    match uu___ with
-    | "op_Negation" -> FStar_Pervasives_Native.Some Not
-    | "op_AmpAmp" -> FStar_Pervasives_Native.Some And
-    | "op_BarBar" -> FStar_Pervasives_Native.Some Or
-    | "op_Equality" -> FStar_Pervasives_Native.Some Eq
-    | "op_disEquality" -> FStar_Pervasives_Native.Some Neq
-    | uu___1 -> FStar_Pervasives_Native.None
-let (is_bool_op : Prims.string -> Prims.bool) =
-  fun op1 -> (mk_bool_op op1) <> FStar_Pervasives_Native.None
-let (mk_op : Prims.string -> op FStar_Pervasives_Native.option) =
-  fun uu___ ->
-    match uu___ with
-    | "add" -> FStar_Pervasives_Native.Some Add
-    | "op_Plus_Hat" -> FStar_Pervasives_Native.Some Add
-    | "add_underspec" -> FStar_Pervasives_Native.Some Add
-    | "add_mod" -> FStar_Pervasives_Native.Some AddW
-    | "op_Plus_Percent_Hat" -> FStar_Pervasives_Native.Some AddW
-    | "sub" -> FStar_Pervasives_Native.Some Sub
-    | "op_Subtraction_Hat" -> FStar_Pervasives_Native.Some Sub
-    | "sub_underspec" -> FStar_Pervasives_Native.Some Sub
-    | "sub_mod" -> FStar_Pervasives_Native.Some SubW
-    | "op_Subtraction_Percent_Hat" -> FStar_Pervasives_Native.Some SubW
-    | "mul" -> FStar_Pervasives_Native.Some Mult
-    | "op_Star_Hat" -> FStar_Pervasives_Native.Some Mult
-    | "mul_mod" -> FStar_Pervasives_Native.Some MultW
-    | "op_Star_Percent_Hat" -> FStar_Pervasives_Native.Some MultW
-    | "div" -> FStar_Pervasives_Native.Some Div
-    | "op_Slash_Hat" -> FStar_Pervasives_Native.Some Div
-    | "div_mod" -> FStar_Pervasives_Native.Some DivW
-    | "op_Slash_Percent_Hat" -> FStar_Pervasives_Native.Some DivW
-    | "rem" -> FStar_Pervasives_Native.Some Mod
-    | "op_Percent_Hat" -> FStar_Pervasives_Native.Some Mod
-    | "logor" -> FStar_Pervasives_Native.Some BOr
-    | "op_Bar_Hat" -> FStar_Pervasives_Native.Some BOr
-    | "logxor" -> FStar_Pervasives_Native.Some BXor
-    | "op_Hat_Hat" -> FStar_Pervasives_Native.Some BXor
-    | "logand" -> FStar_Pervasives_Native.Some BAnd
-    | "op_Amp_Hat" -> FStar_Pervasives_Native.Some BAnd
-    | "lognot" -> FStar_Pervasives_Native.Some BNot
-    | "shift_right" -> FStar_Pervasives_Native.Some BShiftR
-    | "op_Greater_Greater_Hat" -> FStar_Pervasives_Native.Some BShiftR
-    | "shift_left" -> FStar_Pervasives_Native.Some BShiftL
-    | "op_Less_Less_Hat" -> FStar_Pervasives_Native.Some BShiftL
-    | "eq" -> FStar_Pervasives_Native.Some Eq
-    | "op_Equals_Hat" -> FStar_Pervasives_Native.Some Eq
-    | "op_Greater_Hat" -> FStar_Pervasives_Native.Some Gt
-    | "gt" -> FStar_Pervasives_Native.Some Gt
-    | "op_Greater_Equals_Hat" -> FStar_Pervasives_Native.Some Gte
-    | "gte" -> FStar_Pervasives_Native.Some Gte
-    | "op_Less_Hat" -> FStar_Pervasives_Native.Some Lt
-    | "lt" -> FStar_Pervasives_Native.Some Lt
-    | "op_Less_Equals_Hat" -> FStar_Pervasives_Native.Some Lte
-    | "lte" -> FStar_Pervasives_Native.Some Lte
-    | uu___1 -> FStar_Pervasives_Native.None
-let (is_op : Prims.string -> Prims.bool) =
-  fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
-let (is_machine_int : Prims.string -> Prims.bool) =
-  fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
-type env =
-  {
-  names: name Prims.list ;
-  names_t: Prims.string Prims.list ;
-  module_name: Prims.string Prims.list }
-and name = {
-  pretty: Prims.string }
-let (__proj__Mkenv__item__names : env -> name Prims.list) =
-  fun projectee ->
-    match projectee with | { names; names_t; module_name;_} -> names
-let (__proj__Mkenv__item__names_t : env -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with | { names; names_t; module_name;_} -> names_t
-let (__proj__Mkenv__item__module_name : env -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with | { names; names_t; module_name;_} -> module_name
-let (__proj__Mkname__item__pretty : name -> Prims.string) =
-  fun projectee -> match projectee with | { pretty;_} -> pretty
-let (empty : Prims.string Prims.list -> env) =
-  fun module_name -> { names = []; names_t = []; module_name }
-let (extend : env -> Prims.string -> env) =
-  fun env1 ->
-    fun x ->
-      {
-        names = ({ pretty = x } :: (env1.names));
-        names_t = (env1.names_t);
-        module_name = (env1.module_name)
-      }
-let (extend_t : env -> Prims.string -> env) =
-  fun env1 ->
-    fun x ->
-      {
-        names = (env1.names);
-        names_t = (x :: (env1.names_t));
-        module_name = (env1.module_name)
-      }
-let (find_name : env -> Prims.string -> name) =
-  fun env1 ->
-    fun x ->
-      let uu___ =
-        FStar_Compiler_List.tryFind (fun name1 -> name1.pretty = x)
-          env1.names in
-      match uu___ with
-      | FStar_Pervasives_Native.Some name1 -> name1
-      | FStar_Pervasives_Native.None ->
-          failwith "internal error: name not found"
-let (find : env -> Prims.string -> Prims.int) =
-  fun env1 ->
-    fun x ->
-      try
-        (fun uu___ ->
-           match () with
-           | () ->
-               FStar_Compiler_List.index (fun name1 -> name1.pretty = x)
-                 env1.names) ()
-      with
-      | uu___ ->
-          let uu___1 =
-            FStar_Compiler_Util.format1 "Internal error: name not found %s\n"
-              x in
-          failwith uu___1
-let (find_t : env -> Prims.string -> Prims.int) =
-  fun env1 ->
-    fun x ->
-      try
-        (fun uu___ ->
-           match () with
-           | () ->
-               FStar_Compiler_List.index (fun name1 -> name1 = x)
-                 env1.names_t) ()
-      with
-      | uu___ ->
-          let uu___1 =
-            FStar_Compiler_Util.format1 "Internal error: name not found %s\n"
-              x in
-          failwith uu___1
-let add_binders : 'uuuuu . env -> (Prims.string * 'uuuuu) Prims.list -> env =
-  fun env1 ->
-    fun binders ->
-      FStar_Compiler_List.fold_left
-        (fun env2 ->
-           fun uu___ ->
-             match uu___ with | (name1, uu___1) -> extend env2 name1) env1
-        binders
-let (list_elements :
-  FStar_Extraction_ML_Syntax.mlexpr ->
-    FStar_Extraction_ML_Syntax.mlexpr Prims.list)
-  =
-  fun e2 ->
-    let rec list_elements1 acc e21 =
-      match e21.FStar_Extraction_ML_Syntax.expr with
-      | FStar_Extraction_ML_Syntax.MLE_CTor
-          (("Prims"::[], "Cons"), hd::tl::[]) ->
-          list_elements1 (hd :: acc) tl
-      | FStar_Extraction_ML_Syntax.MLE_CTor (("Prims"::[], "Nil"), []) ->
-          FStar_Compiler_List.rev acc
-      | uu___ ->
-          failwith "Argument of FStar.Buffer.createL is not a list literal!" in
-    list_elements1 [] e2
-let (translate_flags :
-  FStar_Extraction_ML_Syntax.meta Prims.list -> flag Prims.list) =
-  fun flags ->
-    FStar_Compiler_List.choose
-      (fun uu___ ->
-         match uu___ with
-         | FStar_Extraction_ML_Syntax.Private ->
-             FStar_Pervasives_Native.Some Private
-         | FStar_Extraction_ML_Syntax.NoExtract ->
-             FStar_Pervasives_Native.Some WipeBody
-         | FStar_Extraction_ML_Syntax.CInline ->
-             FStar_Pervasives_Native.Some CInline
-         | FStar_Extraction_ML_Syntax.Substitute ->
-             FStar_Pervasives_Native.Some Substitute
-         | FStar_Extraction_ML_Syntax.GCType ->
-             FStar_Pervasives_Native.Some GCType
-         | FStar_Extraction_ML_Syntax.Comment s ->
-             FStar_Pervasives_Native.Some (Comment s)
-         | FStar_Extraction_ML_Syntax.StackInline ->
-             FStar_Pervasives_Native.Some MustDisappear
-         | FStar_Extraction_ML_Syntax.CConst s ->
-             FStar_Pervasives_Native.Some (Const s)
-         | FStar_Extraction_ML_Syntax.CPrologue s ->
-             FStar_Pervasives_Native.Some (Prologue s)
-         | FStar_Extraction_ML_Syntax.CEpilogue s ->
-             FStar_Pervasives_Native.Some (Epilogue s)
-         | FStar_Extraction_ML_Syntax.CAbstract ->
-             FStar_Pervasives_Native.Some Abstract
-         | FStar_Extraction_ML_Syntax.CIfDef ->
-             FStar_Pervasives_Native.Some IfDef
-         | FStar_Extraction_ML_Syntax.CMacro ->
-             FStar_Pervasives_Native.Some Macro
-         | FStar_Extraction_ML_Syntax.Deprecated s ->
-             FStar_Pervasives_Native.Some (Deprecated s)
-         | uu___1 -> FStar_Pervasives_Native.None) flags
-let (translate_cc :
-  FStar_Extraction_ML_Syntax.meta Prims.list ->
-    cc FStar_Pervasives_Native.option)
-  =
-  fun flags ->
-    let uu___ =
-      FStar_Compiler_List.choose
-        (fun uu___1 ->
-           match uu___1 with
-           | FStar_Extraction_ML_Syntax.CCConv s ->
-               FStar_Pervasives_Native.Some s
-           | uu___2 -> FStar_Pervasives_Native.None) flags in
-    match uu___ with
-    | "stdcall"::[] -> FStar_Pervasives_Native.Some StdCall
-    | "fastcall"::[] -> FStar_Pervasives_Native.Some FastCall
-    | "cdecl"::[] -> FStar_Pervasives_Native.Some CDecl
-    | uu___1 -> FStar_Pervasives_Native.None
-let (generate_is_null : typ -> expr -> expr) =
-  fun t ->
-    fun x ->
-      let dummy = UInt64 in
-      EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple [] -> TAny
-      | FStar_Extraction_ML_Syntax.MLTY_Top -> TAny
-      | FStar_Extraction_ML_Syntax.MLTY_Var name1 ->
-          let uu___ = find_t env1 name1 in TBound uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
-          let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
-          TArrow uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Prims.unit" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Prims.bool" -> TBool
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], ("FStar"::m::[], "t"))
-          when is_machine_int m ->
-          let uu___ = FStar_Compiler_Util.must (mk_width m) in TInt uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], ("FStar"::m::[], "t'"))
-          when is_machine_int m ->
-          let uu___ = FStar_Compiler_Util.must (mk_width m) in TInt uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
-          when
-          (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___2 = "FStar.Monotonic.HyperStack.s_mref") ||
-              (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___2 = "FStar.Monotonic.HyperHeap.mrref"))
-             ||
-             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___2 = "FStar.HyperStack.ST.m_rref"))
-            ||
-            (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          ((((((((((let uu___1 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___1 = "FStar.Monotonic.HyperStack.mreference") ||
-                     (let uu___1 =
-                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                      uu___1 = "FStar.Monotonic.HyperStack.mstackref"))
-                    ||
-                    (let uu___1 =
-                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                     uu___1 = "FStar.Monotonic.HyperStack.mref"))
-                   ||
-                   (let uu___1 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___1 = "FStar.Monotonic.HyperStack.mmmstackref"))
-                  ||
-                  (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                   uu___1 = "FStar.Monotonic.HyperStack.mmmref"))
-                 ||
-                 (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                  uu___1 = "FStar.Monotonic.Heap.mref"))
-                ||
-                (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___1 = "FStar.HyperStack.ST.mreference"))
-               ||
-               (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___1 = "FStar.HyperStack.ST.mstackref"))
-              ||
-              (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___1 = "FStar.HyperStack.ST.mref"))
-             ||
-             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___1 = "FStar.HyperStack.ST.mmmstackref"))
-            ||
-            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___ = "LowStar.ConstBuffer.const_buffer") ||
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          ((((((((((((((((let uu___ =
-                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                          uu___ = "FStar.Buffer.buffer") ||
-                           (let uu___ =
-                              FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                            uu___ = "LowStar.Buffer.buffer"))
-                          ||
-                          (let uu___ =
-                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                           uu___ = "LowStar.ImmutableBuffer.ibuffer"))
-                         ||
-                         (let uu___ =
-                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                          uu___ = "LowStar.UninitializedBuffer.ubuffer"))
-                        ||
-                        (let uu___ =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                         uu___ = "FStar.HyperStack.reference"))
-                       ||
-                       (let uu___ =
-                          FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                        uu___ = "FStar.HyperStack.stackref"))
-                      ||
-                      (let uu___ =
-                         FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                       uu___ = "FStar.HyperStack.ref"))
-                     ||
-                     (let uu___ =
-                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                      uu___ = "FStar.HyperStack.mmstackref"))
-                    ||
-                    (let uu___ =
-                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                     uu___ = "FStar.HyperStack.mmref"))
-                   ||
-                   (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___ = "FStar.HyperStack.ST.reference"))
-                  ||
-                  (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                   uu___ = "FStar.HyperStack.ST.stackref"))
-                 ||
-                 (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                  uu___ = "FStar.HyperStack.ST.ref"))
-                ||
-                (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___ = "FStar.HyperStack.ST.mmstackref"))
-               ||
-               (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___ = "FStar.HyperStack.ST.mmref"))
-              ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.Reference.ref"))
-             ||
-             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___ = "Steel.ST.Reference.ref"))
-            ||
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___1 = "FStar.HyperStack.s_ref") ||
-            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "FStar.Ghost.erased" -> TAny
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], (path, type_name)) ->
-          TQualified (path, type_name)
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, (ns, t1)) when
-          ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
-            (FStar_Compiler_Util.starts_with t1 "tuple")
-          ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
-          TTuple uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
-          if (FStar_Compiler_List.length args) > Prims.int_zero
-          then
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
-              (lid, uu___1) in
-            TApp uu___
-          else TQualified lid
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
-          TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
-and (translate_binders :
-  env ->
-    (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
-      binder Prims.list)
-  =
-  fun env1 ->
-    fun args -> FStar_Compiler_List.map (translate_binder env1) args
-and (translate_binder :
-  env -> (Prims.string * FStar_Extraction_ML_Syntax.mlty) -> binder) =
-  fun env1 ->
-    fun uu___ ->
-      match uu___ with
-      | (name1, typ1) ->
-          let uu___1 = translate_type env1 typ1 in
-          { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      match e.FStar_Extraction_ML_Syntax.expr with
-      | FStar_Extraction_ML_Syntax.MLE_Tuple [] -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_Const c -> translate_constant c
-      | FStar_Extraction_ML_Syntax.MLE_Var name1 ->
-          let uu___ = find env1 name1 in EBound uu___
-      | FStar_Extraction_ML_Syntax.MLE_Name ("FStar"::m::[], op1) when
-          (is_machine_int m) && (is_op op1) ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_Util.must (mk_op op1) in
-            let uu___2 = FStar_Compiler_Util.must (mk_width m) in
-            (uu___1, uu___2) in
-          EOp uu___
-      | FStar_Extraction_ML_Syntax.MLE_Name ("Prims"::[], op1) when
-          is_bool_op op1 ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_Util.must (mk_bool_op op1) in
-            (uu___1, Bool) in
-          EOp uu___
-      | FStar_Extraction_ML_Syntax.MLE_Name n -> EQualified n
-      | FStar_Extraction_ML_Syntax.MLE_Let
-          ((flavor,
-            { FStar_Extraction_ML_Syntax.mllb_name = name1;
-              FStar_Extraction_ML_Syntax.mllb_tysc =
-                FStar_Pervasives_Native.Some ([], typ1);
-              FStar_Extraction_ML_Syntax.mllb_add_unit = add_unit;
-              FStar_Extraction_ML_Syntax.mllb_def = body;
-              FStar_Extraction_ML_Syntax.mllb_meta = flags;
-              FStar_Extraction_ML_Syntax.print_typ = print;_}::[]),
-           continuation)
-          ->
-          let binder1 =
-            let uu___ = translate_type env1 typ1 in
-            { name = name1; typ = uu___; mut = false } in
-          let body1 = translate_expr env1 body in
-          let env2 = extend env1 name1 in
-          let continuation1 = translate_expr env2 continuation in
-          ELet (binder1, body1, continuation1)
-      | FStar_Extraction_ML_Syntax.MLE_Match (expr1, branches1) ->
-          let uu___ =
-            let uu___1 = translate_expr env1 expr1 in
-            let uu___2 = translate_branches env1 branches1 in
-            (uu___1, uu___2) in
-          EMatch uu___
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.null_ptr" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           arg::[])
-          when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "Steel.ST.HigherArray.is_null_ptr" ->
-          let uu___4 = translate_type env1 t in
-          let uu___5 = translate_expr env1 arg in
-          generate_is_null uu___4 uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           arg::[])
-          when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "FStar.Dyn.undyn" ->
-          let uu___4 =
-            let uu___5 = translate_expr env1 arg in
-            let uu___6 = translate_type env1 t in (uu___5, uu___6) in
-          ECast uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Prims.admit" -> EAbort
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_}::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "LowStar.Failure.failwith" ->
-          let uu___6 = let uu___7 = translate_type env1 t in (s, uu___7) in
-          EAbortT uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           arg::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.HyperStack.All.failwith") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "FStar.Error.unexpected"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Error.unreachable")
-          ->
-          (match arg with
-           | {
-               FStar_Extraction_ML_Syntax.expr =
-                 FStar_Extraction_ML_Syntax.MLE_Const
-                 (FStar_Extraction_ML_Syntax.MLC_String msg);
-               FStar_Extraction_ML_Syntax.mlty = uu___5;
-               FStar_Extraction_ML_Syntax.loc = uu___6;_} -> EAbortS msg
-           | uu___5 ->
-               let print_nm = (["FStar"; "HyperStack"; "IO"], "print_string") in
-               let print =
-                 FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top
-                   (FStar_Extraction_ML_Syntax.MLE_Name print_nm) in
-               let print1 =
-                 FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top
-                   (FStar_Extraction_ML_Syntax.MLE_App (print, [arg])) in
-               let t = translate_expr env1 print1 in ESequence [t; EAbort])
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.ToFStarBuffer.new_to_old_st") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ToFStarBuffer.old_to_new_st")
-          -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _perm0::_perm1::_seq0::_seq1::e0::_len0::e1::_len1::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.ptrdiff_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e0 in
-            let uu___7 = translate_expr env1 e1 in (uu___6, uu___7) in
-          EBufDiff uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          (((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "FStar.Buffer.index") ||
-                (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___5 = "FStar.Buffer.op_Array_Access"))
-               ||
-               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "LowStar.Monotonic.Buffer.index"))
-              ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.UninitializedBuffer.uindex"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.ConstBuffer.index"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.TLArray.get")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _perm::e1::_len::_seq::e2::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.index_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.op_Bang") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.read")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (uu___6, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _perm::_v::e1::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.Reference.read" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (uu___6, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           arg::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Universe.raise_val" -> translate_expr env1 arg
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           arg::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Universe.downgrade_val" -> translate_expr env1 arg
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.create") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.malloca"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.ialloca")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (Stack, uu___6, uu___7) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           elen::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.UninitializedBuffer.ualloca" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 elen in (Stack, uu___6) in
-          EBufCreateNoInit uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           init::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.salloc") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.Reference._alloca")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (Stack, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.createL") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.malloca_of_list"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.ialloca_of_list")
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = list_elements e2 in
-              FStar_Compiler_List.map (translate_expr env1) uu___7 in
-            (Stack, uu___6) in
-          EBufCreateL uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _erid::e2::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.Monotonic.Buffer.mgcmalloc_of_list") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.igcmalloc_of_list")
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = list_elements e2 in
-              FStar_Compiler_List.map (translate_expr env1) uu___7 in
-            (Eternal, uu___6) in
-          EBufCreateL uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _rid::init::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.ralloc") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.HyperStack.ST.ralloc_drgn")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (Eternal, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _e0::e1::e2::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rcreate") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.mgcmalloc"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.igcmalloc")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (Eternal, uu___6, uu___7) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          (((((let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___6 = "LowStar.Monotonic.Buffer.mgcmalloc_and_blit") ||
-                (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___6 = "LowStar.Monotonic.Buffer.mmalloc_and_blit"))
-               ||
-               (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___6 = "LowStar.Monotonic.Buffer.malloca_and_blit"))
-              ||
-              (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___6 = "LowStar.ImmutableBuffer.igcmalloc_and_blit"))
-             ||
-             (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___6 = "LowStar.ImmutableBuffer.imalloc_and_blit"))
-            ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "LowStar.ImmutableBuffer.ialloca_and_blit")
-          ->
-          EAbortS
-            "alloc_and_blit family of functions are not yet supported downstream"
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _erid::elen::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.UninitializedBuffer.ugcmalloc" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 elen in (Eternal, uu___6) in
-          EBufCreateNoInit uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _rid::init::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.ralloc_mm") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.HyperStack.ST.ralloc_drgn_mm")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           init::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.Reference.malloc") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.Reference.alloc")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _e0::e1::e2::[])
-          when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.rcreate_mm") ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.mmalloc"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.imalloc")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___6, uu___7) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e0::e1::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.malloc_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e0 in
-            let uu___7 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, uu___7) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _erid::elen::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.UninitializedBuffer.umalloc" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 elen in
-            (ManuallyManaged, uu___6) in
-          EBufCreateNoInit uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.rfree") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.free")
-          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _v::e2::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.ST.HigherArray.free_ptr") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.Reference.free")
-          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.Monotonic.Buffer.free")
-          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::_e3::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Buffer.sub" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::_e3::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.Monotonic.Buffer.msub") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ConstBuffer.sub")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "FStar.Buffer.join" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.offset") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.HigherArray.ptr_shift")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "LowStar.Monotonic.Buffer.moffset" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufSub uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::e3::[])
-          when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.Buffer.upd") ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "FStar.Buffer.op_Array_Assignment"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.upd'"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.UninitializedBuffer.uupd")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
-          EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::_len::_s::e2::e3::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.upd_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
-          EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.op_Colon_Equals") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.write")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (uu___6, (EQualified (["C"], "_zero_for_deref")), uu___7) in
-          EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _v::e1::e2::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.Reference.write" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (uu___6, (EQualified (["C"], "_zero_for_deref")), uu___7) in
-          EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2::[])
-          when
-          (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___3 = "FStar.HyperStack.ST.push_frame") ||
-            (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___3 = "Steel.ST.Reference._push_frame")
-          -> EPushFrame
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2::[])
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "FStar.HyperStack.ST.pop_frame" -> EPopFrame
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.Reference._free_and_pop_frame" -> EPopFrame
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::e3::e4::e5::[])
-          when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.blit") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.Monotonic.Buffer.blit"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.UninitializedBuffer.ublit")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in
-            let uu___9 = translate_expr env1 e4 in
-            let uu___10 = translate_expr env1 e5 in
-            (uu___6, uu___7, uu___8, uu___9, uu___10) in
-          EBufBlit uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::uu___7::e1::uu___8::e2::e3::uu___9::e4::e5::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.ST.HigherArray.blit_ptr" ->
-          let uu___10 =
-            let uu___11 = translate_expr env1 e1 in
-            let uu___12 = translate_expr env1 e2 in
-            let uu___13 = translate_expr env1 e3 in
-            let uu___14 = translate_expr env1 e4 in
-            let uu___15 = translate_expr env1 e5 in
-            (uu___11, uu___12, uu___13, uu___14, uu___15) in
-          EBufBlit uu___10
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::e3::[])
-          when
-          let s = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          (s = "FStar.Buffer.fill") || (s = "LowStar.Monotonic.Buffer.fill")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
-          EBufFill uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           uu___2::[])
-          when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "FStar.HyperStack.ST.get" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _rid::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.free_drgn") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "FStar.HyperStack.ST.new_drgn")
-          -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _ebuf::_eseq::[])
-          when
-          (((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.Monotonic.Buffer.witness_p") ||
-              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.Monotonic.Buffer.recall_p"))
-             ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.ImmutableBuffer.witness_contents"))
-            ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ImmutableBuffer.recall_contents")
-          -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "LowStar.ConstBuffer.of_buffer") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "LowStar.ConstBuffer.of_ibuffer")
-          -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           _eqal::e1::[])
-          when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "LowStar.ConstBuffer.of_qbuf" ->
-          let uu___4 =
-            let uu___5 = translate_expr env1 e1 in
-            let uu___6 =
-              let uu___7 = translate_type env1 t in TConstBuf uu___7 in
-            (uu___5, uu___6) in
-          ECast uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           e1::[])
-          when
-          ((let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___4 = "LowStar.ConstBuffer.cast") ||
-             (let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___4 = "LowStar.ConstBuffer.to_buffer"))
-            ||
-            (let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___4 = "LowStar.ConstBuffer.to_ibuffer")
-          ->
-          let uu___4 =
-            let uu___5 = translate_expr env1 e1 in
-            let uu___6 = let uu___7 = translate_type env1 t in TBuf uu___7 in
-            (uu___5, uu___6) in
-          ECast uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           e1::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Obj.repr" ->
-          let uu___2 = let uu___3 = translate_expr env1 e1 in (uu___3, TAny) in
-          ECast uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name ("FStar"::m::[], op1);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           args)
-          when (is_machine_int m) && (is_op op1) ->
-          let uu___2 = FStar_Compiler_Util.must (mk_width m) in
-          let uu___3 = FStar_Compiler_Util.must (mk_op op1) in
-          mk_op_app env1 uu___2 uu___3 args
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name ("Prims"::[], op1);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           args)
-          when is_bool_op op1 ->
-          let uu___2 = FStar_Compiler_Util.must (mk_bool_op op1) in
-          mk_op_app env1 Bool uu___2 args
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("FStar"::m::[], "int_to_t");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_Int
-               (c, FStar_Pervasives_Native.None));
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          when is_machine_int m ->
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Util.must (mk_width m) in (uu___5, c) in
-          EConstant uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("FStar"::m::[], "uint_to_t");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_Int
-               (c, FStar_Pervasives_Native.None));
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          when is_machine_int m ->
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Util.must (mk_width m) in (uu___5, c) in
-          EConstant uu___4
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("C"::[], "string_of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
-           | uu___4 ->
-               failwith
-                 "Cannot extract string_of_literal applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("C"::"Compat"::"String"::[], "of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
-           | uu___4 ->
-               failwith
-                 "Cannot extract string_of_literal applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("C"::"String"::[], "of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) -> EString s
-           | uu___4 ->
-               failwith
-                 "Cannot extract string_of_literal applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           { FStar_Extraction_ML_Syntax.expr = ebefore;
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_}::e1::{
-                                                               FStar_Extraction_ML_Syntax.expr
-                                                                 = eafter;
-                                                               FStar_Extraction_ML_Syntax.mlty
-                                                                 = uu___7;
-                                                               FStar_Extraction_ML_Syntax.loc
-                                                                 = uu___8;_}::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "LowStar.Comment.comment_gen" ->
-          (match (ebefore, eafter) with
-           | (FStar_Extraction_ML_Syntax.MLE_Const
-              (FStar_Extraction_ML_Syntax.MLC_String sbefore),
-              FStar_Extraction_ML_Syntax.MLE_Const
-              (FStar_Extraction_ML_Syntax.MLC_String safter)) ->
-               (if FStar_Compiler_Util.contains sbefore "*/"
-                then failwith "Before Comment contains end-of-comment marker"
-                else ();
-                if FStar_Compiler_Util.contains safter "*/"
-                then failwith "After Comment contains end-of-comment marker"
-                else ();
-                (let uu___11 =
-                   let uu___12 = translate_expr env1 e1 in
-                   (sbefore, uu___12, safter) in
-                 EComment uu___11))
-           | uu___9 ->
-               failwith "Cannot extract comment applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "LowStar.Comment.comment" ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) ->
-               (if FStar_Compiler_Util.contains s "*/"
-                then
-                  failwith
-                    "Standalone Comment contains end-of-comment marker"
-                else ();
-                EStandaloneComment s)
-           | uu___4 ->
-               failwith "Cannot extract comment applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("LowStar"::"Literal"::[], "buffer_of_literal");
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           { FStar_Extraction_ML_Syntax.expr = e1;
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_}::[])
-          ->
-          (match e1 with
-           | FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String s) ->
-               ECast ((EString s), (TBuf (TInt UInt8)))
-           | uu___4 ->
-               failwith
-                 "Cannot extract buffer_of_literal applied to a non-literal")
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("FStar"::"Int"::"Cast"::[], c);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           arg::[])
-          ->
-          let is_known_type =
-            (((((((FStar_Compiler_Util.starts_with c "uint8") ||
-                    (FStar_Compiler_Util.starts_with c "uint16"))
-                   || (FStar_Compiler_Util.starts_with c "uint32"))
-                  || (FStar_Compiler_Util.starts_with c "uint64"))
-                 || (FStar_Compiler_Util.starts_with c "int8"))
-                || (FStar_Compiler_Util.starts_with c "int16"))
-               || (FStar_Compiler_Util.starts_with c "int32"))
-              || (FStar_Compiler_Util.starts_with c "int64") in
-          if (FStar_Compiler_Util.ends_with c "uint64") && is_known_type
-          then
-            let uu___2 =
-              let uu___3 = translate_expr env1 arg in (uu___3, (TInt UInt64)) in
-            ECast uu___2
-          else
-            if (FStar_Compiler_Util.ends_with c "uint32") && is_known_type
-            then
-              (let uu___3 =
-                 let uu___4 = translate_expr env1 arg in
-                 (uu___4, (TInt UInt32)) in
-               ECast uu___3)
-            else
-              if (FStar_Compiler_Util.ends_with c "uint16") && is_known_type
-              then
-                (let uu___4 =
-                   let uu___5 = translate_expr env1 arg in
-                   (uu___5, (TInt UInt16)) in
-                 ECast uu___4)
-              else
-                if (FStar_Compiler_Util.ends_with c "uint8") && is_known_type
-                then
-                  (let uu___5 =
-                     let uu___6 = translate_expr env1 arg in
-                     (uu___6, (TInt UInt8)) in
-                   ECast uu___5)
-                else
-                  if
-                    (FStar_Compiler_Util.ends_with c "int64") &&
-                      is_known_type
-                  then
-                    (let uu___6 =
-                       let uu___7 = translate_expr env1 arg in
-                       (uu___7, (TInt Int64)) in
-                     ECast uu___6)
-                  else
-                    if
-                      (FStar_Compiler_Util.ends_with c "int32") &&
-                        is_known_type
-                    then
-                      (let uu___7 =
-                         let uu___8 = translate_expr env1 arg in
-                         (uu___8, (TInt Int32)) in
-                       ECast uu___7)
-                    else
-                      if
-                        (FStar_Compiler_Util.ends_with c "int16") &&
-                          is_known_type
-                      then
-                        (let uu___8 =
-                           let uu___9 = translate_expr env1 arg in
-                           (uu___9, (TInt Int16)) in
-                         ECast uu___8)
-                      else
-                        if
-                          (FStar_Compiler_Util.ends_with c "int8") &&
-                            is_known_type
-                        then
-                          (let uu___9 =
-                             let uu___10 = translate_expr env1 arg in
-                             (uu___10, (TInt Int8)) in
-                           ECast uu___9)
-                        else
-                          (let uu___10 =
-                             let uu___11 =
-                               let uu___12 = translate_expr env1 arg in
-                               [uu___12] in
-                             ((EQualified (["FStar"; "Int"; "Cast"], c)),
-                               uu___11) in
-                           EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           arg::[])
-          when
-          (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___2 = "FStar.SizeT.uint16_to_sizet") ||
-              (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___2 = "FStar.SizeT.uint32_to_sizet"))
-             ||
-             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___2 = "FStar.SizeT.uint64_to_sizet"))
-            ||
-            (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___2 = "FStar.PtrdiffT.ptrdifft_to_sizet")
-          ->
-          let uu___2 =
-            let uu___3 = translate_expr env1 arg in (uu___3, (TInt SizeT)) in
-          ECast uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           arg::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "FStar.SizeT.sizet_to_uint32" ->
-          let uu___2 =
-            let uu___3 = translate_expr env1 arg in (uu___3, (TInt UInt32)) in
-          ECast uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           _inv::test::body::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.ST.Loops.while_loop" ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = translate_expr env1 test in
-                let uu___6 =
-                  let uu___7 = translate_expr env1 body in [uu___7] in
-                uu___5 :: uu___6 in
-              EUnit :: uu___4 in
-            ((EQualified (["Steel"; "Loops"], "while_loop")), uu___3) in
-          EApp uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("Steel"::"ST"::"Printf"::[], fn);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           args)
-          ->
-          let uu___2 =
-            let uu___3 = FStar_Compiler_List.map (translate_expr env1) args in
-            ((EQualified (["LowStar"; "Printf"], fn)), uu___3) in
-          EApp uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.Effect.Atomic.return") ||
-            (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___7 = "Steel.ST.Util.return")
-          -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _fp::_fp'::_opened::_p::_i::{
-                                         FStar_Extraction_ML_Syntax.expr =
-                                           FStar_Extraction_ML_Syntax.MLE_Fun
-                                           (uu___5, body);
-                                         FStar_Extraction_ML_Syntax.mlty =
-                                           uu___6;
-                                         FStar_Extraction_ML_Syntax.loc =
-                                           uu___7;_}::[])
-          when
-          (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___8 = "Steel.ST.Util.with_invariant") ||
-            (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.Effect.Atomic.with_invariant")
-          -> translate_expr env1 body
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _fp::_fp'::_opened::_p::_i::e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.ST.Util.with_invariant") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Effect.Atomic.with_invariant")
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.string_of_int
-                  (FStar_Pervasives_Native.fst
-                     e1.FStar_Extraction_ML_Syntax.loc) in
-              FStar_Compiler_Util.format2
-                "Extraction of with_invariant requires its argument to be a function literal at extraction time, try marking its argument inline_for_extraction (%s, %s)"
-                uu___7
-                (FStar_Pervasives_Native.snd
-                   e1.FStar_Extraction_ML_Syntax.loc) in
-            (FStar_Errors.Fatal_ExtractionUnsupported, uu___6) in
-          FStar_Errors.raise_error uu___5 FStar_Compiler_Range.dummyRange
-      | FStar_Extraction_ML_Syntax.MLE_App (head, args) ->
-          let uu___ =
-            let uu___1 = translate_expr env1 head in
-            let uu___2 = FStar_Compiler_List.map (translate_expr env1) args in
-            (uu___1, uu___2) in
-          EApp uu___
-      | FStar_Extraction_ML_Syntax.MLE_TApp (head, ty_args) ->
-          let uu___ =
-            let uu___1 = translate_expr env1 head in
-            let uu___2 =
-              FStar_Compiler_List.map (translate_type env1) ty_args in
-            (uu___1, uu___2) in
-          ETypApp uu___
-      | FStar_Extraction_ML_Syntax.MLE_Coerce (e1, t_from, t_to) ->
-          let uu___ =
-            let uu___1 = translate_expr env1 e1 in
-            let uu___2 = translate_type env1 t_to in (uu___1, uu___2) in
-          ECast uu___
-      | FStar_Extraction_ML_Syntax.MLE_Record (uu___, fields) ->
-          let uu___1 =
-            let uu___2 = assert_lid env1 e.FStar_Extraction_ML_Syntax.mlty in
-            let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, expr1) ->
-                       let uu___5 = translate_expr env1 expr1 in
-                       (field, uu___5)) fields in
-            (uu___2, uu___3) in
-          EFlat uu___1
-      | FStar_Extraction_ML_Syntax.MLE_Proj (e1, path) ->
-          let uu___ =
-            let uu___1 = assert_lid env1 e1.FStar_Extraction_ML_Syntax.mlty in
-            let uu___2 = translate_expr env1 e1 in
-            (uu___1, uu___2, (FStar_Pervasives_Native.snd path)) in
-          EField uu___
-      | FStar_Extraction_ML_Syntax.MLE_Let uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Extraction_ML_Code.string_of_mlexpr ([], "") e in
-            FStar_Compiler_Util.format1
-              "todo: translate_expr [MLE_Let] (expr is: %s)" uu___2 in
-          failwith uu___1
-      | FStar_Extraction_ML_Syntax.MLE_App (head, uu___) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlexpr ([], "") head in
-            FStar_Compiler_Util.format1
-              "todo: translate_expr [MLE_App] (head is: %s)" uu___2 in
-          failwith uu___1
-      | FStar_Extraction_ML_Syntax.MLE_Seq seqs ->
-          let uu___ = FStar_Compiler_List.map (translate_expr env1) seqs in
-          ESequence uu___
-      | FStar_Extraction_ML_Syntax.MLE_Tuple es ->
-          let uu___ = FStar_Compiler_List.map (translate_expr env1) es in
-          ETuple uu___
-      | FStar_Extraction_ML_Syntax.MLE_CTor ((uu___, cons), es) ->
-          let uu___1 =
-            let uu___2 = assert_lid env1 e.FStar_Extraction_ML_Syntax.mlty in
-            let uu___3 = FStar_Compiler_List.map (translate_expr env1) es in
-            (uu___2, cons, uu___3) in
-          ECons uu___1
-      | FStar_Extraction_ML_Syntax.MLE_Fun (args, body) ->
-          let binders = translate_binders env1 args in
-          let env2 = add_binders env1 args in
-          let uu___ =
-            let uu___1 = translate_expr env2 body in
-            let uu___2 =
-              translate_type env2 body.FStar_Extraction_ML_Syntax.mlty in
-            (binders, uu___1, uu___2) in
-          EFun uu___
-      | FStar_Extraction_ML_Syntax.MLE_If (e1, e2, e3) ->
-          let uu___ =
-            let uu___1 = translate_expr env1 e1 in
-            let uu___2 = translate_expr env1 e2 in
-            let uu___3 =
-              match e3 with
-              | FStar_Pervasives_Native.None -> EUnit
-              | FStar_Pervasives_Native.Some e31 -> translate_expr env1 e31 in
-            (uu___1, uu___2, uu___3) in
-          EIfThenElse uu___
-      | FStar_Extraction_ML_Syntax.MLE_Raise uu___ ->
-          failwith "todo: translate_expr [MLE_Raise]"
-      | FStar_Extraction_ML_Syntax.MLE_Try uu___ ->
-          failwith "todo: translate_expr [MLE_Try]"
-      | FStar_Extraction_ML_Syntax.MLE_Coerce uu___ ->
-          failwith "todo: translate_expr [MLE_Coerce]"
-and (assert_lid : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (ts, lid) ->
-          if (FStar_Compiler_List.length ts) > Prims.int_zero
-          then
-            let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) ts in
-              (lid, uu___1) in
-            TApp uu___
-          else TQualified lid
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Extraction_ML_Code.string_of_mlty ([], "") t in
-            FStar_Compiler_Util.format1
-              "invalid argument: expected MLTY_Named, got %s" uu___2 in
-          failwith uu___1
-and (translate_branches :
-  env ->
-    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
-      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr)
-      Prims.list -> (pattern * expr) Prims.list)
-  =
-  fun env1 ->
-    fun branches1 ->
-      FStar_Compiler_List.map (translate_branch env1) branches1
-and (translate_branch :
-  env ->
-    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
-      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr) ->
-      (pattern * expr))
-  =
-  fun env1 ->
-    fun uu___ ->
-      match uu___ with
-      | (pat, guard, expr1) ->
-          if guard = FStar_Pervasives_Native.None
-          then
-            let uu___1 = translate_pat env1 pat in
-            (match uu___1 with
-             | (env2, pat1) ->
-                 let uu___2 = translate_expr env2 expr1 in (pat1, uu___2))
-          else failwith "todo: translate_branch"
-and (translate_width :
-  (FStar_Const.signedness * FStar_Const.width) FStar_Pervasives_Native.option
-    -> width)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> CInt
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int8) ->
-        Int8
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int16) ->
-        Int16
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int32) ->
-        Int32
-    | FStar_Pervasives_Native.Some (FStar_Const.Signed, FStar_Const.Int64) ->
-        Int64
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int8)
-        -> UInt8
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int16)
-        -> UInt16
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int32)
-        -> UInt32
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Int64)
-        -> UInt64
-    | FStar_Pervasives_Native.Some (FStar_Const.Unsigned, FStar_Const.Sizet)
-        -> SizeT
-and (translate_pat :
-  env -> FStar_Extraction_ML_Syntax.mlpattern -> (env * pattern)) =
-  fun env1 ->
-    fun p ->
-      match p with
-      | FStar_Extraction_ML_Syntax.MLP_Const
-          (FStar_Extraction_ML_Syntax.MLC_Unit) -> (env1, PUnit)
-      | FStar_Extraction_ML_Syntax.MLP_Const
-          (FStar_Extraction_ML_Syntax.MLC_Bool b) -> (env1, (PBool b))
-      | FStar_Extraction_ML_Syntax.MLP_Const
-          (FStar_Extraction_ML_Syntax.MLC_Int (s, sw)) ->
-          let uu___ =
-            let uu___1 = let uu___2 = translate_width sw in (uu___2, s) in
-            PConstant uu___1 in
-          (env1, uu___)
-      | FStar_Extraction_ML_Syntax.MLP_Var name1 ->
-          let env2 = extend env1 name1 in
-          (env2, (PVar { name = name1; typ = TAny; mut = false }))
-      | FStar_Extraction_ML_Syntax.MLP_Wild ->
-          let env2 = extend env1 "_" in
-          (env2, (PVar { name = "_"; typ = TAny; mut = false }))
-      | FStar_Extraction_ML_Syntax.MLP_CTor ((uu___, cons), ps) ->
-          let uu___1 =
-            FStar_Compiler_List.fold_left
-              (fun uu___2 ->
-                 fun p1 ->
-                   match uu___2 with
-                   | (env2, acc) ->
-                       let uu___3 = translate_pat env2 p1 in
-                       (match uu___3 with | (env3, p2) -> (env3, (p2 :: acc))))
-              (env1, []) ps in
-          (match uu___1 with
-           | (env2, ps1) ->
-               (env2, (PCons (cons, (FStar_Compiler_List.rev ps1)))))
-      | FStar_Extraction_ML_Syntax.MLP_Record (uu___, ps) ->
-          let uu___1 =
-            FStar_Compiler_List.fold_left
-              (fun uu___2 ->
-                 fun uu___3 ->
-                   match (uu___2, uu___3) with
-                   | ((env2, acc), (field, p1)) ->
-                       let uu___4 = translate_pat env2 p1 in
-                       (match uu___4 with
-                        | (env3, p2) -> (env3, ((field, p2) :: acc))))
-              (env1, []) ps in
-          (match uu___1 with
-           | (env2, ps1) -> (env2, (PRecord (FStar_Compiler_List.rev ps1))))
-      | FStar_Extraction_ML_Syntax.MLP_Tuple ps ->
-          let uu___ =
-            FStar_Compiler_List.fold_left
-              (fun uu___1 ->
-                 fun p1 ->
-                   match uu___1 with
-                   | (env2, acc) ->
-                       let uu___2 = translate_pat env2 p1 in
-                       (match uu___2 with | (env3, p2) -> (env3, (p2 :: acc))))
-              (env1, []) ps in
-          (match uu___ with
-           | (env2, ps1) -> (env2, (PTuple (FStar_Compiler_List.rev ps1))))
-      | FStar_Extraction_ML_Syntax.MLP_Const uu___ ->
-          failwith "todo: translate_pat [MLP_Const]"
-      | FStar_Extraction_ML_Syntax.MLP_Branch uu___ ->
-          failwith "todo: translate_pat [MLP_Branch]"
-and (translate_constant : FStar_Extraction_ML_Syntax.mlconstant -> expr) =
-  fun c ->
-    match c with
-    | FStar_Extraction_ML_Syntax.MLC_Unit -> EUnit
-    | FStar_Extraction_ML_Syntax.MLC_Bool b -> EBool b
-    | FStar_Extraction_ML_Syntax.MLC_String s ->
-        ((let uu___1 =
-            let uu___2 = FStar_String.list_of_string s in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (FStar_Compiler_Util.for_some
-                 (fun c1 -> c1 = (FStar_Char.char_of_int Prims.int_zero))) in
-          if uu___1
-          then
-            let uu___2 =
-              FStar_Compiler_Util.format1
-                "Refusing to translate a string literal that contains a null character: %s"
-                s in
-            failwith uu___2
-          else ());
-         EString s)
-    | FStar_Extraction_ML_Syntax.MLC_Char c1 ->
-        let i = FStar_Compiler_Util.int_of_char c1 in
-        let s = FStar_Compiler_Util.string_of_int i in
-        let c2 = EConstant (UInt32, s) in
-        let char_of_int = EQualified (["FStar"; "Char"], "char_of_int") in
-        EApp (char_of_int, [c2])
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (s, FStar_Pervasives_Native.Some (sg, wd)) ->
-        let uu___ =
-          let uu___1 =
-            translate_width (FStar_Pervasives_Native.Some (sg, wd)) in
-          (uu___1, s) in
-        EConstant uu___
-    | FStar_Extraction_ML_Syntax.MLC_Float uu___ ->
-        failwith "todo: translate_expr [MLC_Float]"
-    | FStar_Extraction_ML_Syntax.MLC_Bytes uu___ ->
-        failwith "todo: translate_expr [MLC_Bytes]"
-    | FStar_Extraction_ML_Syntax.MLC_Int (s, FStar_Pervasives_Native.None) ->
-        EConstant (CInt, s)
-and (mk_op_app :
-  env -> width -> op -> FStar_Extraction_ML_Syntax.mlexpr Prims.list -> expr)
-  =
-  fun env1 ->
-    fun w ->
-      fun op1 ->
-        fun args ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
-            ((EOp (op1, w)), uu___1) in
-          EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
-let (translate_let :
-  env ->
-    FStar_Extraction_ML_Syntax.mlletflavor ->
-      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun flavor ->
-      fun lb ->
-        match lb with
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t0);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def = e;
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___1;_} when
-            FStar_Compiler_Util.for_some
-              (fun uu___2 ->
-                 match uu___2 with
-                 | FStar_Extraction_ML_Syntax.Assumed -> true
-                 | uu___3 -> false) meta
-            ->
-            let name2 = ((env1.module_name), name1) in
-            let arg_names =
-              match e.FStar_Extraction_ML_Syntax.expr with
-              | FStar_Extraction_ML_Syntax.MLE_Fun (args, uu___2) ->
-                  FStar_Compiler_List.map FStar_Pervasives_Native.fst args
-              | uu___2 -> [] in
-            if (FStar_Compiler_List.length tvars) = Prims.int_zero
-            then
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = translate_cc meta in
-                  let uu___5 = translate_flags meta in
-                  let uu___6 = translate_type env1 t0 in
-                  (uu___4, uu___5, name2, uu___6, arg_names) in
-                DExternal uu___3 in
-              FStar_Pervasives_Native.Some uu___2
-            else
-              ((let uu___4 =
-                  FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                FStar_Compiler_Util.print1_warning
-                  "Not extracting %s to KaRaMeL (polymorphic assumes are not supported)\n"
-                  uu___4);
-               FStar_Pervasives_Native.None)
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t0);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def =
-              {
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Fun (args, body);
-                FStar_Extraction_ML_Syntax.mlty = uu___1;
-                FStar_Extraction_ML_Syntax.loc = uu___2;_};
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___3;_} ->
-            if
-              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-                meta
-            then FStar_Pervasives_Native.None
-            else
-              (let env2 =
-                 if flavor = FStar_Extraction_ML_Syntax.Rec
-                 then extend env1 name1
-                 else env1 in
-               let env3 =
-                 FStar_Compiler_List.fold_left
-                   (fun env4 -> fun name2 -> extend_t env4 name2) env2 tvars in
-               let rec find_return_type eff i uu___5 =
-                 match uu___5 with
-                 | FStar_Extraction_ML_Syntax.MLTY_Fun (uu___6, eff1, t) when
-                     i > Prims.int_zero ->
-                     find_return_type eff1 (i - Prims.int_one) t
-                 | t -> (i, eff, t) in
-               let name2 = ((env3.module_name), name1) in
-               let uu___5 =
-                 find_return_type FStar_Extraction_ML_Syntax.E_PURE
-                   (FStar_Compiler_List.length args) t0 in
-               match uu___5 with
-               | (i, eff, t) ->
-                   (if i > Prims.int_zero
-                    then
-                      (let msg =
-                         "function type annotation has less arrows than the number of arguments; please mark the return type abbreviation as inline_for_extraction" in
-                       let uu___7 =
-                         FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                       FStar_Compiler_Util.print2_warning
-                         "Not extracting %s to KaRaMeL (%s)\n" uu___7 msg)
-                    else ();
-                    (let t1 = translate_type env3 t in
-                     let binders = translate_binders env3 args in
-                     let env4 = add_binders env3 args in
-                     let cc1 = translate_cc meta in
-                     let meta1 =
-                       match (eff, t1) with
-                       | (FStar_Extraction_ML_Syntax.E_ERASABLE, uu___7) ->
-                           let uu___8 = translate_flags meta in MustDisappear
-                             :: uu___8
-                       | (FStar_Extraction_ML_Syntax.E_PURE, TUnit) ->
-                           let uu___7 = translate_flags meta in MustDisappear
-                             :: uu___7
-                       | uu___7 -> translate_flags meta in
-                     try
-                       (fun uu___7 ->
-                          match () with
-                          | () ->
-                              let body1 = translate_expr env4 body in
-                              FStar_Pervasives_Native.Some
-                                (DFunction
-                                   (cc1, meta1,
-                                     (FStar_Compiler_List.length tvars), t1,
-                                     name2, binders, body1))) ()
-                     with
-                     | e ->
-                         let msg = FStar_Compiler_Util.print_exn e in
-                         ((let uu___9 =
-                             let uu___10 =
-                               let uu___11 =
-                                 FStar_Extraction_ML_Syntax.string_of_mlpath
-                                   name2 in
-                               FStar_Compiler_Util.format2
-                                 "Error while extracting %s to KaRaMeL (%s)\n"
-                                 uu___11 msg in
-                             (FStar_Errors.Warning_FunctionNotExtacted,
-                               uu___10) in
-                           FStar_Errors.log_issue
-                             FStar_Compiler_Range.dummyRange uu___9);
-                          (let msg1 =
-                             Prims.op_Hat
-                               "This function was not extracted:\n" msg in
-                           FStar_Pervasives_Native.Some
-                             (DFunction
-                                (cc1, meta1,
-                                  (FStar_Compiler_List.length tvars), t1,
-                                  name2, binders, (EAbortS msg1))))))))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def =
-              {
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_App
-                  ({
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_TApp
-                       ({
-                          FStar_Extraction_ML_Syntax.expr =
-                            FStar_Extraction_ML_Syntax.MLE_Name p;
-                          FStar_Extraction_ML_Syntax.mlty = uu___1;
-                          FStar_Extraction_ML_Syntax.loc = uu___2;_},
-                        uu___3);
-                     FStar_Extraction_ML_Syntax.mlty = uu___4;
-                     FStar_Extraction_ML_Syntax.loc = uu___5;_},
-                   l::[]);
-                FStar_Extraction_ML_Syntax.mlty = uu___6;
-                FStar_Extraction_ML_Syntax.loc = uu___7;_};
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___8;_} when
-            let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___9 = "Steel.TLArray.create" ->
-            if
-              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-                meta
-            then FStar_Pervasives_Native.None
-            else
-              (let meta1 = translate_flags meta in
-               let env2 =
-                 FStar_Compiler_List.fold_left
-                   (fun env3 -> fun name2 -> extend_t env3 name2) env1 tvars in
-               let t1 = translate_type env2 t in
-               let name2 = ((env2.module_name), name1) in
-               try
-                 (fun uu___10 ->
-                    match () with
-                    | () ->
-                        let expr1 =
-                          let uu___11 = list_elements l in
-                          FStar_Compiler_List.map (translate_expr env2)
-                            uu___11 in
-                        FStar_Pervasives_Native.Some
-                          (DGlobal
-                             (meta1, name2,
-                               (FStar_Compiler_List.length tvars), t1,
-                               (EBufCreateL (Eternal, expr1))))) ()
-               with
-               | uu___10 ->
-                   ((let uu___12 =
-                       let uu___13 =
-                         let uu___14 =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                         let uu___15 = FStar_Compiler_Util.print_exn uu___10 in
-                         FStar_Compiler_Util.format2
-                           "Error extracting %s to KaRaMeL (%s)\n" uu___14
-                           uu___15 in
-                       (FStar_Errors.Warning_DefinitionNotTranslated,
-                         uu___13) in
-                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                       uu___12);
-                    FStar_Pervasives_Native.Some
-                      (DGlobal
-                         (meta1, name2, (FStar_Compiler_List.length tvars),
-                           t1, EAny))))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def = expr1;
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___1;_} ->
-            if
-              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-                meta
-            then FStar_Pervasives_Native.None
-            else
-              (let meta1 = translate_flags meta in
-               let env2 =
-                 FStar_Compiler_List.fold_left
-                   (fun env3 -> fun name2 -> extend_t env3 name2) env1 tvars in
-               let t1 = translate_type env2 t in
-               let name2 = ((env2.module_name), name1) in
-               try
-                 (fun uu___3 ->
-                    match () with
-                    | () ->
-                        let expr2 = translate_expr env2 expr1 in
-                        FStar_Pervasives_Native.Some
-                          (DGlobal
-                             (meta1, name2,
-                               (FStar_Compiler_List.length tvars), t1, expr2)))
-                   ()
-               with
-               | uu___3 ->
-                   ((let uu___5 =
-                       let uu___6 =
-                         let uu___7 =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                         let uu___8 = FStar_Compiler_Util.print_exn uu___3 in
-                         FStar_Compiler_Util.format2
-                           "Error extracting %s to KaRaMeL (%s)\n" uu___7
-                           uu___8 in
-                       (FStar_Errors.Warning_DefinitionNotTranslated, uu___6) in
-                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                       uu___5);
-                    FStar_Pervasives_Native.Some
-                      (DGlobal
-                         (meta1, name2, (FStar_Compiler_List.length tvars),
-                           t1, EAny))))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc = ts;
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def = uu___1;
-            FStar_Extraction_ML_Syntax.mllb_meta = uu___2;
-            FStar_Extraction_ML_Syntax.print_typ = uu___3;_} ->
-            ((let uu___5 =
-                let uu___6 =
-                  FStar_Compiler_Util.format1
-                    "Not extracting %s to KaRaMeL\n" name1 in
-                (FStar_Errors.Warning_DefinitionNotTranslated, uu___6) in
-              FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___5);
-             (match ts with
-              | FStar_Pervasives_Native.Some (idents, t) ->
-                  let uu___6 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") t in
-                  FStar_Compiler_Util.print2
-                    "Type scheme is: forall %s. %s\n"
-                    (FStar_String.concat ", " idents) uu___6
-              | FStar_Pervasives_Native.None -> ());
-             FStar_Pervasives_Native.None)
-let (translate_decl :
-  env -> FStar_Extraction_ML_Syntax.mlmodule1 -> decl Prims.list) =
-  fun env1 ->
-    fun d ->
-      match d with
-      | FStar_Extraction_ML_Syntax.MLM_Let (flavor, lbs) ->
-          FStar_Compiler_List.choose (translate_let env1 flavor) lbs
-      | FStar_Extraction_ML_Syntax.MLM_Loc uu___ -> []
-      | FStar_Extraction_ML_Syntax.MLM_Ty tys ->
-          FStar_Compiler_List.choose (translate_type_decl env1) tys
-      | FStar_Extraction_ML_Syntax.MLM_Top uu___ ->
-          failwith "todo: translate_decl [MLM_Top]"
-      | FStar_Extraction_ML_Syntax.MLM_Exn (m, uu___) ->
-          (FStar_Compiler_Util.print1_warning
-             "Not extracting exception %s to KaRaMeL (exceptions unsupported)\n"
-             m;
-           [])
-let (translate_module :
-  (FStar_Extraction_ML_Syntax.mlpath * (FStar_Extraction_ML_Syntax.mlsig *
-    FStar_Extraction_ML_Syntax.mlmodule) FStar_Pervasives_Native.option *
-    FStar_Extraction_ML_Syntax.mllib) -> file)
-  =
-  fun m ->
-    let uu___ = m in
-    match uu___ with
-    | (module_name, modul, uu___1) ->
-        let module_name1 =
-          FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst module_name)
-            [FStar_Pervasives_Native.snd module_name] in
-        let program1 =
-          match modul with
-          | FStar_Pervasives_Native.Some (_signature, decls) ->
-              FStar_Compiler_List.collect
-                (translate_decl (empty module_name1)) decls
-          | uu___2 ->
-              failwith "Unexpected standalone interface or nested modules" in
-        ((FStar_String.concat "_" module_name1), program1)
-let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Extraction_ML_Syntax.MLLib modules ->
-        FStar_Compiler_List.filter_map
-          (fun m ->
-             let m_name =
-               let uu___1 = m in
-               match uu___1 with
-               | (path, uu___2, uu___3) ->
-                   FStar_Extraction_ML_Syntax.string_of_mlpath path in
-             try
-               (fun uu___1 ->
-                  match () with
-                  | () ->
-                      ((let uu___3 =
-                          let uu___4 = FStar_Options.silent () in
-                          Prims.op_Negation uu___4 in
-                        if uu___3
-                        then
-                          FStar_Compiler_Util.print1
-                            "Attempting to translate module %s\n" m_name
-                        else ());
-                       (let uu___3 = translate_module m in
-                        FStar_Pervasives_Native.Some uu___3))) ()
-             with
-             | uu___1 ->
-                 ((let uu___3 = FStar_Compiler_Util.print_exn uu___1 in
-                   FStar_Compiler_Util.print2
-                     "Unable to translate module: %s because:\n  %s\n" m_name
-                     uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_Code.ml b/src/ocaml-output/FStar_Extraction_ML_Code.ml
deleted file mode 100644
index 95d3251b624..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_Code.ml
+++ /dev/null
@@ -1,1412 +0,0 @@
-open Prims
-type doc =
-  | Doc of Prims.string 
-let (uu___is_Doc : doc -> Prims.bool) = fun projectee -> true
-let (__proj__Doc__item___0 : doc -> Prims.string) =
-  fun projectee -> match projectee with | Doc _0 -> _0
-type assoc =
-  | ILeft 
-  | IRight 
-  | Left 
-  | Right 
-  | NonAssoc 
-let (uu___is_ILeft : assoc -> Prims.bool) =
-  fun projectee -> match projectee with | ILeft -> true | uu___ -> false
-let (uu___is_IRight : assoc -> Prims.bool) =
-  fun projectee -> match projectee with | IRight -> true | uu___ -> false
-let (uu___is_Left : assoc -> Prims.bool) =
-  fun projectee -> match projectee with | Left -> true | uu___ -> false
-let (uu___is_Right : assoc -> Prims.bool) =
-  fun projectee -> match projectee with | Right -> true | uu___ -> false
-let (uu___is_NonAssoc : assoc -> Prims.bool) =
-  fun projectee -> match projectee with | NonAssoc -> true | uu___ -> false
-type fixity =
-  | Prefix 
-  | Postfix 
-  | Infix of assoc 
-let (uu___is_Prefix : fixity -> Prims.bool) =
-  fun projectee -> match projectee with | Prefix -> true | uu___ -> false
-let (uu___is_Postfix : fixity -> Prims.bool) =
-  fun projectee -> match projectee with | Postfix -> true | uu___ -> false
-let (uu___is_Infix : fixity -> Prims.bool) =
-  fun projectee -> match projectee with | Infix _0 -> true | uu___ -> false
-let (__proj__Infix__item___0 : fixity -> assoc) =
-  fun projectee -> match projectee with | Infix _0 -> _0
-type opprec = (Prims.int * fixity)
-type level = (opprec * assoc)
-let (t_prio_fun : (Prims.int * fixity)) =
-  ((Prims.of_int (10)), (Infix Right))
-let (t_prio_tpl : (Prims.int * fixity)) =
-  ((Prims.of_int (20)), (Infix NonAssoc))
-let (t_prio_name : (Prims.int * fixity)) = ((Prims.of_int (30)), Postfix)
-let (e_bin_prio_lambda : (Prims.int * fixity)) = ((Prims.of_int (5)), Prefix)
-let (e_bin_prio_if : (Prims.int * fixity)) = ((Prims.of_int (15)), Prefix)
-let (e_bin_prio_letin : (Prims.int * fixity)) = ((Prims.of_int (19)), Prefix)
-let (e_bin_prio_or : (Prims.int * fixity)) =
-  ((Prims.of_int (20)), (Infix Left))
-let (e_bin_prio_and : (Prims.int * fixity)) =
-  ((Prims.of_int (25)), (Infix Left))
-let (e_bin_prio_eq : (Prims.int * fixity)) =
-  ((Prims.of_int (27)), (Infix NonAssoc))
-let (e_bin_prio_order : (Prims.int * fixity)) =
-  ((Prims.of_int (29)), (Infix NonAssoc))
-let (e_bin_prio_op1 : (Prims.int * fixity)) =
-  ((Prims.of_int (30)), (Infix Left))
-let (e_bin_prio_op2 : (Prims.int * fixity)) =
-  ((Prims.of_int (40)), (Infix Left))
-let (e_bin_prio_op3 : (Prims.int * fixity)) =
-  ((Prims.of_int (50)), (Infix Left))
-let (e_bin_prio_op4 : (Prims.int * fixity)) =
-  ((Prims.of_int (60)), (Infix Left))
-let (e_bin_prio_comb : (Prims.int * fixity)) =
-  ((Prims.of_int (70)), (Infix Left))
-let (e_bin_prio_seq : (Prims.int * fixity)) =
-  ((Prims.of_int (100)), (Infix Left))
-let (e_app_prio : (Prims.int * fixity)) =
-  ((Prims.of_int (10000)), (Infix Left))
-let (min_op_prec : (Prims.int * fixity)) =
-  ((~- Prims.int_one), (Infix NonAssoc))
-let (max_op_prec : (Prims.int * fixity)) =
-  (FStar_Compiler_Util.max_int, (Infix NonAssoc))
-let (empty : doc) = Doc ""
-let (hardline : doc) = Doc "\n"
-let (text : Prims.string -> doc) = fun s -> Doc s
-let (num : Prims.int -> doc) =
-  fun i -> let uu___ = FStar_Compiler_Util.string_of_int i in Doc uu___
-let (break1 : doc) = text " "
-let (enclose : doc -> doc -> doc -> doc) =
-  fun uu___ ->
-    fun uu___1 ->
-      fun uu___2 ->
-        match (uu___, uu___1, uu___2) with
-        | (Doc l, Doc r, Doc x) -> Doc (Prims.op_Hat l (Prims.op_Hat x r))
-let (cbrackets : doc -> doc) =
-  fun uu___ ->
-    match uu___ with | Doc d -> enclose (text "{") (text "}") (Doc d)
-let (parens : doc -> doc) =
-  fun uu___ ->
-    match uu___ with | Doc d -> enclose (text "(") (text ")") (Doc d)
-let (cat : doc -> doc -> doc) =
-  fun uu___ ->
-    fun uu___1 ->
-      match (uu___, uu___1) with
-      | (Doc d1, Doc d2) -> Doc (Prims.op_Hat d1 d2)
-let (reduce : doc Prims.list -> doc) =
-  fun docs -> FStar_Compiler_List.fold_left cat empty docs
-let (combine : doc -> doc Prims.list -> doc) =
-  fun uu___ ->
-    fun docs ->
-      match uu___ with
-      | Doc sep ->
-          let select uu___1 =
-            match uu___1 with
-            | Doc d ->
-                if d = ""
-                then FStar_Pervasives_Native.None
-                else FStar_Pervasives_Native.Some d in
-          let docs1 = FStar_Compiler_List.choose select docs in
-          Doc (FStar_String.concat sep docs1)
-let (reduce1 : doc Prims.list -> doc) = fun docs -> combine break1 docs
-let (hbox : doc -> doc) = fun d -> d
-let rec in_ns : 'a . ('a Prims.list * 'a Prims.list) -> Prims.bool =
-  fun x ->
-    match x with
-    | ([], uu___) -> true
-    | (x1::t1, x2::t2) when x1 = x2 -> in_ns (t1, t2)
-    | (uu___, uu___1) -> false
-let (path_of_ns :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    Prims.string Prims.list -> Prims.string Prims.list)
-  =
-  fun currentModule ->
-    fun ns ->
-      let ns' = FStar_Extraction_ML_Util.flatten_ns ns in
-      if ns' = currentModule
-      then []
-      else
-        (let cg_libs = FStar_Options.codegen_libs () in
-         let ns_len = FStar_Compiler_List.length ns in
-         let found =
-           FStar_Compiler_Util.find_map cg_libs
-             (fun cg_path ->
-                let cg_len = FStar_Compiler_List.length cg_path in
-                if (FStar_Compiler_List.length cg_path) < ns_len
-                then
-                  let uu___1 = FStar_Compiler_Util.first_N cg_len ns in
-                  match uu___1 with
-                  | (pfx, sfx) ->
-                      (if pfx = cg_path
-                       then
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Extraction_ML_Util.flatten_ns sfx in
-                             [uu___4] in
-                           FStar_Compiler_List.op_At pfx uu___3 in
-                         FStar_Pervasives_Native.Some uu___2
-                       else FStar_Pervasives_Native.None)
-                else FStar_Pervasives_Native.None) in
-         match found with
-         | FStar_Pervasives_Native.None -> [ns']
-         | FStar_Pervasives_Native.Some x -> x)
-let (mlpath_of_mlpath :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlpath -> FStar_Extraction_ML_Syntax.mlpath)
-  =
-  fun currentModule ->
-    fun x ->
-      let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath x in
-      match uu___ with
-      | "Prims.Some" -> ([], "Some")
-      | "Prims.None" -> ([], "None")
-      | uu___1 ->
-          let uu___2 = x in
-          (match uu___2 with
-           | (ns, x1) ->
-               let uu___3 = path_of_ns currentModule ns in (uu___3, x1))
-let (ptsym_of_symbol :
-  FStar_Extraction_ML_Syntax.mlsymbol -> FStar_Extraction_ML_Syntax.mlsymbol)
-  =
-  fun s ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_String.get s Prims.int_zero in
-        FStar_Char.lowercase uu___2 in
-      let uu___2 = FStar_String.get s Prims.int_zero in uu___1 <> uu___2 in
-    if uu___ then Prims.op_Hat "l__" s else s
-let (ptsym :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlpath -> FStar_Extraction_ML_Syntax.mlsymbol)
-  =
-  fun currentModule ->
-    fun mlp ->
-      if FStar_Compiler_List.isEmpty (FStar_Pervasives_Native.fst mlp)
-      then ptsym_of_symbol (FStar_Pervasives_Native.snd mlp)
-      else
-        (let uu___1 = mlpath_of_mlpath currentModule mlp in
-         match uu___1 with
-         | (p, s) ->
-             let uu___2 =
-               let uu___3 = let uu___4 = ptsym_of_symbol s in [uu___4] in
-               FStar_Compiler_List.op_At p uu___3 in
-             FStar_String.concat "." uu___2)
-let (ptctor :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlpath -> FStar_Extraction_ML_Syntax.mlsymbol)
-  =
-  fun currentModule ->
-    fun mlp ->
-      let uu___ = mlpath_of_mlpath currentModule mlp in
-      match uu___ with
-      | (p, s) ->
-          let s1 =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_String.get s Prims.int_zero in
-                FStar_Char.uppercase uu___3 in
-              let uu___3 = FStar_String.get s Prims.int_zero in
-              uu___2 <> uu___3 in
-            if uu___1 then Prims.op_Hat "U__" s else s in
-          FStar_String.concat "." (FStar_Compiler_List.op_At p [s1])
-let (infix_prim_ops :
-  (Prims.string * (Prims.int * fixity) * Prims.string) Prims.list) =
-  [("op_Addition", e_bin_prio_op1, "+");
-  ("op_Subtraction", e_bin_prio_op1, "-");
-  ("op_Multiply", e_bin_prio_op1, "*");
-  ("op_Division", e_bin_prio_op1, "/");
-  ("op_Equality", e_bin_prio_eq, "=");
-  ("op_Colon_Equals", e_bin_prio_eq, ":=");
-  ("op_disEquality", e_bin_prio_eq, "<>");
-  ("op_AmpAmp", e_bin_prio_and, "&&");
-  ("op_BarBar", e_bin_prio_or, "||");
-  ("op_LessThanOrEqual", e_bin_prio_order, "<=");
-  ("op_GreaterThanOrEqual", e_bin_prio_order, ">=");
-  ("op_LessThan", e_bin_prio_order, "<");
-  ("op_GreaterThan", e_bin_prio_order, ">");
-  ("op_Modulus", e_bin_prio_order, "mod")]
-let (prim_uni_ops : unit -> (Prims.string * Prims.string) Prims.list) =
-  fun uu___ ->
-    let op_minus =
-      let uu___1 = FStar_Extraction_ML_Util.codegen_fsharp () in
-      if uu___1 then "-" else "~-" in
-    [("op_Negation", "not");
-    ("op_Minus", op_minus);
-    ("op_Bang", "Support.ST.read")]
-let prim_types : 'uuuuu . unit -> 'uuuuu Prims.list = fun uu___ -> []
-let (prim_constructors : (Prims.string * Prims.string) Prims.list) =
-  [("Some", "Some"); ("None", "None"); ("Nil", "[]"); ("Cons", "::")]
-let (is_prims_ns :
-  FStar_Extraction_ML_Syntax.mlsymbol Prims.list -> Prims.bool) =
-  fun ns -> ns = ["Prims"]
-let (as_bin_op :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    (FStar_Extraction_ML_Syntax.mlsymbol * (Prims.int * fixity) *
-      Prims.string) FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (ns, x) ->
-        if is_prims_ns ns
-        then
-          FStar_Compiler_List.tryFind
-            (fun uu___1 -> match uu___1 with | (y, uu___2, uu___3) -> x = y)
-            infix_prim_ops
-        else FStar_Pervasives_Native.None
-let (is_bin_op : FStar_Extraction_ML_Syntax.mlpath -> Prims.bool) =
-  fun p -> let uu___ = as_bin_op p in uu___ <> FStar_Pervasives_Native.None
-let (as_uni_op :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    (FStar_Extraction_ML_Syntax.mlsymbol * Prims.string)
-      FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (ns, x) ->
-        if is_prims_ns ns
-        then
-          let uu___1 = prim_uni_ops () in
-          FStar_Compiler_List.tryFind
-            (fun uu___2 -> match uu___2 with | (y, uu___3) -> x = y) uu___1
-        else FStar_Pervasives_Native.None
-let (is_uni_op : FStar_Extraction_ML_Syntax.mlpath -> Prims.bool) =
-  fun p -> let uu___ = as_uni_op p in uu___ <> FStar_Pervasives_Native.None
-let (is_standard_type : FStar_Extraction_ML_Syntax.mlpath -> Prims.bool) =
-  fun p -> false
-let (as_standard_constructor :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    (FStar_Extraction_ML_Syntax.mlsymbol * Prims.string)
-      FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (ns, x) ->
-        if is_prims_ns ns
-        then
-          FStar_Compiler_List.tryFind
-            (fun uu___1 -> match uu___1 with | (y, uu___2) -> x = y)
-            prim_constructors
-        else FStar_Pervasives_Native.None
-let (is_standard_constructor :
-  FStar_Extraction_ML_Syntax.mlpath -> Prims.bool) =
-  fun p ->
-    let uu___ = as_standard_constructor p in
-    uu___ <> FStar_Pervasives_Native.None
-let (maybe_paren :
-  ((Prims.int * fixity) * assoc) -> (Prims.int * fixity) -> doc -> doc) =
-  fun uu___ ->
-    fun inner ->
-      fun doc1 ->
-        match uu___ with
-        | (outer, side) ->
-            let noparens _inner _outer side1 =
-              let uu___1 = _inner in
-              match uu___1 with
-              | (pi, fi) ->
-                  let uu___2 = _outer in
-                  (match uu___2 with
-                   | (po, fo) ->
-                       (pi > po) ||
-                         ((match (fi, side1) with
-                           | (Postfix, Left) -> true
-                           | (Prefix, Right) -> true
-                           | (Infix (Left), Left) ->
-                               (pi = po) && (fo = (Infix Left))
-                           | (Infix (Right), Right) ->
-                               (pi = po) && (fo = (Infix Right))
-                           | (Infix (Left), ILeft) ->
-                               (pi = po) && (fo = (Infix Left))
-                           | (Infix (Right), IRight) ->
-                               (pi = po) && (fo = (Infix Right))
-                           | (uu___3, NonAssoc) -> (pi = po) && (fi = fo)
-                           | (uu___3, uu___4) -> false))) in
-            if noparens inner outer side then doc1 else parens doc1
-let (escape_byte_hex : FStar_BaseTypes.byte -> Prims.string) =
-  fun x -> Prims.op_Hat "\\x" (FStar_Compiler_Util.hex_string_of_byte x)
-let (escape_char_hex : FStar_BaseTypes.char -> Prims.string) =
-  fun x -> escape_byte_hex (FStar_Compiler_Util.byte_of_char x)
-let (escape_or :
-  (FStar_BaseTypes.char -> Prims.string) ->
-    FStar_BaseTypes.char -> Prims.string)
-  =
-  fun fallback ->
-    fun uu___ ->
-      if uu___ = 92
-      then "\\\\"
-      else
-        if uu___ = 32
-        then " "
-        else
-          if uu___ = 8
-          then "\\b"
-          else
-            if uu___ = 9
-            then "\\t"
-            else
-              if uu___ = 13
-              then "\\r"
-              else
-                if uu___ = 10
-                then "\\n"
-                else
-                  if uu___ = 39
-                  then "\\'"
-                  else
-                    if uu___ = 34
-                    then "\\\""
-                    else
-                      if FStar_Compiler_Util.is_letter_or_digit uu___
-                      then FStar_Compiler_Util.string_of_char uu___
-                      else
-                        if FStar_Compiler_Util.is_punctuation uu___
-                        then FStar_Compiler_Util.string_of_char uu___
-                        else
-                          if FStar_Compiler_Util.is_symbol uu___
-                          then FStar_Compiler_Util.string_of_char uu___
-                          else fallback uu___
-let (string_of_mlconstant :
-  FStar_Extraction_ML_Syntax.mlconstant -> Prims.string) =
-  fun sctt ->
-    match sctt with
-    | FStar_Extraction_ML_Syntax.MLC_Unit -> "()"
-    | FStar_Extraction_ML_Syntax.MLC_Bool (true) -> "true"
-    | FStar_Extraction_ML_Syntax.MLC_Bool (false) -> "false"
-    | FStar_Extraction_ML_Syntax.MLC_Char c ->
-        let uu___ = FStar_Extraction_ML_Util.codegen_fsharp () in
-        if uu___
-        then
-          Prims.op_Hat "'"
-            (Prims.op_Hat (FStar_Compiler_Util.string_of_char c) "'")
-        else
-          (let nc = FStar_Char.int_of_char c in
-           let uu___2 = FStar_Compiler_Util.string_of_int nc in
-           Prims.op_Hat uu___2
-             (if
-                ((nc >= (Prims.of_int (32))) && (nc = (Prims.of_int (127))))
-                  && (nc < (Prims.of_int (34)))
-              then
-                Prims.op_Hat " (*"
-                  (Prims.op_Hat (FStar_Compiler_Util.string_of_char c) "*)")
-              else ""))
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (s, FStar_Pervasives_Native.Some
-         (FStar_Const.Signed, FStar_Const.Int32))
-        -> Prims.op_Hat s "l"
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (s, FStar_Pervasives_Native.Some
-         (FStar_Const.Signed, FStar_Const.Int64))
-        -> Prims.op_Hat s "L"
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (s, FStar_Pervasives_Native.Some (uu___, FStar_Const.Int8)) -> s
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (s, FStar_Pervasives_Native.Some (uu___, FStar_Const.Int16)) -> s
-    | FStar_Extraction_ML_Syntax.MLC_Int
-        (v, FStar_Pervasives_Native.Some (s, w)) ->
-        let sign =
-          match s with
-          | FStar_Const.Signed -> "Int"
-          | FStar_Const.Unsigned -> "UInt" in
-        let ws =
-          match w with
-          | FStar_Const.Int8 -> "8"
-          | FStar_Const.Int16 -> "16"
-          | FStar_Const.Int32 -> "32"
-          | FStar_Const.Int64 -> "64" in
-        let z = Prims.op_Hat "(Prims.parse_int \"" (Prims.op_Hat v "\")") in
-        let u =
-          match s with
-          | FStar_Const.Signed -> ""
-          | FStar_Const.Unsigned -> "u" in
-        Prims.op_Hat "(FStar_"
-          (Prims.op_Hat sign
-             (Prims.op_Hat ws
-                (Prims.op_Hat "."
-                   (Prims.op_Hat u
-                      (Prims.op_Hat "int_to_t (" (Prims.op_Hat z "))"))))))
-    | FStar_Extraction_ML_Syntax.MLC_Int (s, FStar_Pervasives_Native.None) ->
-        Prims.op_Hat "(Prims.parse_int \"" (Prims.op_Hat s "\")")
-    | FStar_Extraction_ML_Syntax.MLC_Float d ->
-        FStar_Compiler_Util.string_of_float d
-    | FStar_Extraction_ML_Syntax.MLC_Bytes bytes ->
-        let uu___ =
-          let uu___1 = FStar_Compiler_Bytes.f_encode escape_byte_hex bytes in
-          Prims.op_Hat uu___1 "\"" in
-        Prims.op_Hat "\"" uu___
-    | FStar_Extraction_ML_Syntax.MLC_String chars ->
-        let uu___ =
-          let uu___1 =
-            FStar_String.collect
-              (escape_or FStar_Compiler_Util.string_of_char) chars in
-          Prims.op_Hat uu___1 "\"" in
-        Prims.op_Hat "\"" uu___
-    | uu___ -> failwith "TODO: extract integer constants properly into OCaml"
-let rec (doc_of_mltype' :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    level -> FStar_Extraction_ML_Syntax.mlty -> doc)
-  =
-  fun currentModule ->
-    fun outer ->
-      fun ty ->
-        match ty with
-        | FStar_Extraction_ML_Syntax.MLTY_Var x ->
-            let escape_tyvar s =
-              if FStar_Compiler_Util.starts_with s "'_"
-              then FStar_Compiler_Util.replace_char s 95 117
-              else s in
-            text (escape_tyvar x)
-        | FStar_Extraction_ML_Syntax.MLTY_Tuple tys ->
-            let doc1 =
-              FStar_Compiler_List.map
-                (doc_of_mltype currentModule (t_prio_tpl, Left)) tys in
-            let doc2 =
-              let uu___ =
-                let uu___1 = combine (text " * ") doc1 in hbox uu___1 in
-              parens uu___ in
-            doc2
-        | FStar_Extraction_ML_Syntax.MLTY_Named (args, name) ->
-            let args1 =
-              match args with
-              | [] -> empty
-              | arg::[] ->
-                  doc_of_mltype currentModule (t_prio_name, Left) arg
-              | uu___ ->
-                  let args2 =
-                    FStar_Compiler_List.map
-                      (doc_of_mltype currentModule (min_op_prec, NonAssoc))
-                      args in
-                  let uu___1 =
-                    let uu___2 = combine (text ", ") args2 in hbox uu___2 in
-                  parens uu___1 in
-            let name1 = ptsym currentModule name in
-            let uu___ = reduce1 [args1; text name1] in hbox uu___
-        | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
-            let d1 = doc_of_mltype currentModule (t_prio_fun, Left) t1 in
-            let d2 = doc_of_mltype currentModule (t_prio_fun, Right) t2 in
-            let uu___1 =
-              let uu___2 = reduce1 [d1; text " -> "; d2] in hbox uu___2 in
-            maybe_paren outer t_prio_fun uu___1
-        | FStar_Extraction_ML_Syntax.MLTY_Top ->
-            let uu___ = FStar_Extraction_ML_Util.codegen_fsharp () in
-            if uu___ then text "obj" else text "Obj.t"
-        | FStar_Extraction_ML_Syntax.MLTY_Erased -> text "unit"
-and (doc_of_mltype :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    level -> FStar_Extraction_ML_Syntax.mlty -> doc)
-  =
-  fun currentModule ->
-    fun outer ->
-      fun ty ->
-        let uu___ = FStar_Extraction_ML_Util.resugar_mlty ty in
-        doc_of_mltype' currentModule outer uu___
-let rec (doc_of_expr :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    level -> FStar_Extraction_ML_Syntax.mlexpr -> doc)
-  =
-  fun currentModule ->
-    fun outer ->
-      fun e ->
-        match e.FStar_Extraction_ML_Syntax.expr with
-        | FStar_Extraction_ML_Syntax.MLE_Coerce (e1, t, t') ->
-            let doc1 = doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-            let uu___ = FStar_Extraction_ML_Util.codegen_fsharp () in
-            if uu___
-            then
-              let uu___1 = reduce [text "Prims.unsafe_coerce "; doc1] in
-              parens uu___1
-            else
-              (let uu___2 = reduce [text "Obj.magic "; parens doc1] in
-               parens uu___2)
-        | FStar_Extraction_ML_Syntax.MLE_Seq es ->
-            let docs =
-              FStar_Compiler_List.map
-                (doc_of_expr currentModule (min_op_prec, NonAssoc)) es in
-            let docs1 =
-              FStar_Compiler_List.map
-                (fun d -> reduce [d; text ";"; hardline]) docs in
-            let uu___ = reduce docs1 in parens uu___
-        | FStar_Extraction_ML_Syntax.MLE_Const c ->
-            let uu___ = string_of_mlconstant c in text uu___
-        | FStar_Extraction_ML_Syntax.MLE_Var x -> text x
-        | FStar_Extraction_ML_Syntax.MLE_Name path ->
-            let uu___ = ptsym currentModule path in text uu___
-        | FStar_Extraction_ML_Syntax.MLE_Record (path, fields) ->
-            let for1 uu___ =
-              match uu___ with
-              | (name, e1) ->
-                  let doc1 =
-                    doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 = ptsym currentModule (path, name) in
-                      text uu___3 in
-                    [uu___2; text "="; doc1] in
-                  reduce1 uu___1 in
-            let uu___ =
-              let uu___1 = FStar_Compiler_List.map for1 fields in
-              combine (text "; ") uu___1 in
-            cbrackets uu___
-        | FStar_Extraction_ML_Syntax.MLE_CTor (ctor, []) ->
-            let name =
-              let uu___ = is_standard_constructor ctor in
-              if uu___
-              then
-                let uu___1 =
-                  let uu___2 = as_standard_constructor ctor in
-                  FStar_Compiler_Option.get uu___2 in
-                FStar_Pervasives_Native.snd uu___1
-              else ptctor currentModule ctor in
-            text name
-        | FStar_Extraction_ML_Syntax.MLE_CTor (ctor, args) ->
-            let name =
-              let uu___ = is_standard_constructor ctor in
-              if uu___
-              then
-                let uu___1 =
-                  let uu___2 = as_standard_constructor ctor in
-                  FStar_Compiler_Option.get uu___2 in
-                FStar_Pervasives_Native.snd uu___1
-              else ptctor currentModule ctor in
-            let args1 =
-              FStar_Compiler_List.map
-                (doc_of_expr currentModule (min_op_prec, NonAssoc)) args in
-            let doc1 =
-              match (name, args1) with
-              | ("::", x::xs::[]) -> reduce [parens x; text "::"; xs]
-              | (uu___, uu___1) ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 = combine (text ", ") args1 in
-                        parens uu___5 in
-                      [uu___4] in
-                    (text name) :: uu___3 in
-                  reduce1 uu___2 in
-            maybe_paren outer e_app_prio doc1
-        | FStar_Extraction_ML_Syntax.MLE_Tuple es ->
-            let docs =
-              FStar_Compiler_List.map
-                (fun x ->
-                   let uu___ =
-                     doc_of_expr currentModule (min_op_prec, NonAssoc) x in
-                   parens uu___) es in
-            let docs1 = let uu___ = combine (text ", ") docs in parens uu___ in
-            docs1
-        | FStar_Extraction_ML_Syntax.MLE_Let ((rec_, lets), body) ->
-            let pre =
-              if
-                e.FStar_Extraction_ML_Syntax.loc <>
-                  FStar_Extraction_ML_Syntax.dummy_loc
-              then
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 = doc_of_loc e.FStar_Extraction_ML_Syntax.loc in
-                    [uu___2] in
-                  hardline :: uu___1 in
-                reduce uu___
-              else empty in
-            let doc1 = doc_of_lets currentModule (rec_, false, lets) in
-            let body1 =
-              doc_of_expr currentModule (min_op_prec, NonAssoc) body in
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = reduce1 [text "in"; body1] in [uu___4] in
-                  doc1 :: uu___3 in
-                pre :: uu___2 in
-              combine hardline uu___1 in
-            parens uu___
-        | FStar_Extraction_ML_Syntax.MLE_App (e1, args) ->
-            (match ((e1.FStar_Extraction_ML_Syntax.expr), args) with
-             | (FStar_Extraction_ML_Syntax.MLE_Name p,
-                {
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Fun (uu___::[], scrutinee);
-                  FStar_Extraction_ML_Syntax.mlty = uu___1;
-                  FStar_Extraction_ML_Syntax.loc = uu___2;_}::{
-                                                                FStar_Extraction_ML_Syntax.expr
-                                                                  =
-                                                                  FStar_Extraction_ML_Syntax.MLE_Fun
-                                                                  ((arg,
-                                                                    uu___3)::[],
-                                                                   possible_match);
-                                                                FStar_Extraction_ML_Syntax.mlty
-                                                                  = uu___4;
-                                                                FStar_Extraction_ML_Syntax.loc
-                                                                  = uu___5;_}::[])
-                 when
-                 (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                  uu___6 = "FStar.Compiler.Effect.try_with") ||
-                   (let uu___6 =
-                      FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___6 = "FStar.All.try_with")
-                 ->
-                 let branches =
-                   match possible_match with
-                   | {
-                       FStar_Extraction_ML_Syntax.expr =
-                         FStar_Extraction_ML_Syntax.MLE_Match
-                         ({
-                            FStar_Extraction_ML_Syntax.expr =
-                              FStar_Extraction_ML_Syntax.MLE_Var arg';
-                            FStar_Extraction_ML_Syntax.mlty = uu___6;
-                            FStar_Extraction_ML_Syntax.loc = uu___7;_},
-                          branches1);
-                       FStar_Extraction_ML_Syntax.mlty = uu___8;
-                       FStar_Extraction_ML_Syntax.loc = uu___9;_} when
-                       arg = arg' -> branches1
-                   | e2 ->
-                       [(FStar_Extraction_ML_Syntax.MLP_Wild,
-                          FStar_Pervasives_Native.None, e2)] in
-                 doc_of_expr currentModule outer
-                   {
-                     FStar_Extraction_ML_Syntax.expr =
-                       (FStar_Extraction_ML_Syntax.MLE_Try
-                          (scrutinee, branches));
-                     FStar_Extraction_ML_Syntax.mlty =
-                       (possible_match.FStar_Extraction_ML_Syntax.mlty);
-                     FStar_Extraction_ML_Syntax.loc =
-                       (possible_match.FStar_Extraction_ML_Syntax.loc)
-                   }
-             | (FStar_Extraction_ML_Syntax.MLE_Name p, e11::e2::[]) when
-                 is_bin_op p -> doc_of_binop currentModule p e11 e2
-             | (FStar_Extraction_ML_Syntax.MLE_App
-                ({
-                   FStar_Extraction_ML_Syntax.expr =
-                     FStar_Extraction_ML_Syntax.MLE_Name p;
-                   FStar_Extraction_ML_Syntax.mlty = uu___;
-                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                 unitVal::[]),
-                e11::e2::[]) when
-                 (is_bin_op p) &&
-                   (unitVal = FStar_Extraction_ML_Syntax.ml_unit)
-                 -> doc_of_binop currentModule p e11 e2
-             | (FStar_Extraction_ML_Syntax.MLE_Name p, e11::[]) when
-                 is_uni_op p -> doc_of_uniop currentModule p e11
-             | (FStar_Extraction_ML_Syntax.MLE_App
-                ({
-                   FStar_Extraction_ML_Syntax.expr =
-                     FStar_Extraction_ML_Syntax.MLE_Name p;
-                   FStar_Extraction_ML_Syntax.mlty = uu___;
-                   FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                 unitVal::[]),
-                e11::[]) when
-                 (is_uni_op p) &&
-                   (unitVal = FStar_Extraction_ML_Syntax.ml_unit)
-                 -> doc_of_uniop currentModule p e11
-             | uu___ ->
-                 let e2 = doc_of_expr currentModule (e_app_prio, ILeft) e1 in
-                 let args1 =
-                   FStar_Compiler_List.map
-                     (doc_of_expr currentModule (e_app_prio, IRight)) args in
-                 let uu___1 = reduce1 (e2 :: args1) in parens uu___1)
-        | FStar_Extraction_ML_Syntax.MLE_Proj (e1, f) ->
-            let e2 = doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-            let doc1 =
-              let uu___ = FStar_Extraction_ML_Util.codegen_fsharp () in
-              if uu___
-              then
-                reduce [e2; text "."; text (FStar_Pervasives_Native.snd f)]
-              else
-                (let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 = ptsym currentModule f in text uu___6 in
-                       [uu___5] in
-                     (text ".") :: uu___4 in
-                   e2 :: uu___3 in
-                 reduce uu___2) in
-            doc1
-        | FStar_Extraction_ML_Syntax.MLE_Fun (ids, body) ->
-            let bvar_annot x xt =
-              let uu___ = FStar_Extraction_ML_Util.codegen_fsharp () in
-              if uu___
-              then
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        match xt with
-                        | FStar_Pervasives_Native.Some xxt ->
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  doc_of_mltype currentModule outer xxt in
-                                [uu___7] in
-                              (text " : ") :: uu___6 in
-                            reduce1 uu___5
-                        | uu___5 -> text "" in
-                      [uu___4; text ")"] in
-                    (text x) :: uu___3 in
-                  (text "(") :: uu___2 in
-                reduce1 uu___1
-              else text x in
-            let ids1 =
-              FStar_Compiler_List.map
-                (fun uu___ ->
-                   match uu___ with
-                   | (x, xt) ->
-                       bvar_annot x (FStar_Pervasives_Native.Some xt)) ids in
-            let body1 =
-              doc_of_expr currentModule (min_op_prec, NonAssoc) body in
-            let doc1 =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = reduce1 ids1 in [uu___2; text "->"; body1] in
-                (text "fun") :: uu___1 in
-              reduce1 uu___ in
-            parens doc1
-        | FStar_Extraction_ML_Syntax.MLE_If
-            (cond, e1, FStar_Pervasives_Native.None) ->
-            let cond1 =
-              doc_of_expr currentModule (min_op_prec, NonAssoc) cond in
-            let doc1 =
-              let uu___ =
-                let uu___1 =
-                  reduce1 [text "if"; cond1; text "then"; text "begin"] in
-                let uu___2 =
-                  let uu___3 =
-                    doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-                  [uu___3; text "end"] in
-                uu___1 :: uu___2 in
-              combine hardline uu___ in
-            maybe_paren outer e_bin_prio_if doc1
-        | FStar_Extraction_ML_Syntax.MLE_If
-            (cond, e1, FStar_Pervasives_Native.Some e2) ->
-            let cond1 =
-              doc_of_expr currentModule (min_op_prec, NonAssoc) cond in
-            let doc1 =
-              let uu___ =
-                let uu___1 =
-                  reduce1 [text "if"; cond1; text "then"; text "begin"] in
-                let uu___2 =
-                  let uu___3 =
-                    doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-                  let uu___4 =
-                    let uu___5 =
-                      reduce1 [text "end"; text "else"; text "begin"] in
-                    let uu___6 =
-                      let uu___7 =
-                        doc_of_expr currentModule (min_op_prec, NonAssoc) e2 in
-                      [uu___7; text "end"] in
-                    uu___5 :: uu___6 in
-                  uu___3 :: uu___4 in
-                uu___1 :: uu___2 in
-              combine hardline uu___ in
-            maybe_paren outer e_bin_prio_if doc1
-        | FStar_Extraction_ML_Syntax.MLE_Match (cond, pats) ->
-            let cond1 =
-              doc_of_expr currentModule (min_op_prec, NonAssoc) cond in
-            let pats1 =
-              FStar_Compiler_List.map (doc_of_branch currentModule) pats in
-            let doc1 =
-              let uu___ = reduce1 [text "match"; parens cond1; text "with"] in
-              uu___ :: pats1 in
-            let doc2 = combine hardline doc1 in parens doc2
-        | FStar_Extraction_ML_Syntax.MLE_Raise (exn, []) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = ptctor currentModule exn in text uu___3 in
-                [uu___2] in
-              (text "raise") :: uu___1 in
-            reduce1 uu___
-        | FStar_Extraction_ML_Syntax.MLE_Raise (exn, args) ->
-            let args1 =
-              FStar_Compiler_List.map
-                (doc_of_expr currentModule (min_op_prec, NonAssoc)) args in
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = ptctor currentModule exn in text uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = combine (text ", ") args1 in parens uu___5 in
-                  [uu___4] in
-                uu___2 :: uu___3 in
-              (text "raise") :: uu___1 in
-            reduce1 uu___
-        | FStar_Extraction_ML_Syntax.MLE_Try (e1, pats) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        FStar_Compiler_List.map (doc_of_branch currentModule)
-                          pats in
-                      combine hardline uu___6 in
-                    [uu___5] in
-                  (text "with") :: uu___4 in
-                uu___2 :: uu___3 in
-              (text "try") :: uu___1 in
-            combine hardline uu___
-        | FStar_Extraction_ML_Syntax.MLE_TApp (head, ty_args) ->
-            doc_of_expr currentModule outer head
-and (doc_of_binop :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlpath ->
-      FStar_Extraction_ML_Syntax.mlexpr ->
-        FStar_Extraction_ML_Syntax.mlexpr -> doc)
-  =
-  fun currentModule ->
-    fun p ->
-      fun e1 ->
-        fun e2 ->
-          let uu___ =
-            let uu___1 = as_bin_op p in FStar_Compiler_Option.get uu___1 in
-          match uu___ with
-          | (uu___1, prio, txt) ->
-              let e11 = doc_of_expr currentModule (prio, Left) e1 in
-              let e21 = doc_of_expr currentModule (prio, Right) e2 in
-              let doc1 = reduce1 [e11; text txt; e21] in parens doc1
-and (doc_of_uniop :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlpath ->
-      FStar_Extraction_ML_Syntax.mlexpr -> doc)
-  =
-  fun currentModule ->
-    fun p ->
-      fun e1 ->
-        let uu___ =
-          let uu___1 = as_uni_op p in FStar_Compiler_Option.get uu___1 in
-        match uu___ with
-        | (uu___1, txt) ->
-            let e11 = doc_of_expr currentModule (min_op_prec, NonAssoc) e1 in
-            let doc1 = reduce1 [text txt; parens e11] in parens doc1
-and (doc_of_pattern :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlpattern -> doc)
-  =
-  fun currentModule ->
-    fun pattern ->
-      match pattern with
-      | FStar_Extraction_ML_Syntax.MLP_Wild -> text "_"
-      | FStar_Extraction_ML_Syntax.MLP_Const c ->
-          let uu___ = string_of_mlconstant c in text uu___
-      | FStar_Extraction_ML_Syntax.MLP_Var x -> text x
-      | FStar_Extraction_ML_Syntax.MLP_Record (path, fields) ->
-          let for1 uu___ =
-            match uu___ with
-            | (name, p) ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = ptsym currentModule (path, name) in
-                    text uu___3 in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = doc_of_pattern currentModule p in [uu___5] in
-                    (text "=") :: uu___4 in
-                  uu___2 :: uu___3 in
-                reduce1 uu___1 in
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map for1 fields in
-            combine (text "; ") uu___1 in
-          cbrackets uu___
-      | FStar_Extraction_ML_Syntax.MLP_CTor (ctor, []) ->
-          let name =
-            let uu___ = is_standard_constructor ctor in
-            if uu___
-            then
-              let uu___1 =
-                let uu___2 = as_standard_constructor ctor in
-                FStar_Compiler_Option.get uu___2 in
-              FStar_Pervasives_Native.snd uu___1
-            else ptctor currentModule ctor in
-          text name
-      | FStar_Extraction_ML_Syntax.MLP_CTor (ctor, pats) ->
-          let name =
-            let uu___ = is_standard_constructor ctor in
-            if uu___
-            then
-              let uu___1 =
-                let uu___2 = as_standard_constructor ctor in
-                FStar_Compiler_Option.get uu___2 in
-              FStar_Pervasives_Native.snd uu___1
-            else ptctor currentModule ctor in
-          let doc1 =
-            match (name, pats) with
-            | ("::", x::xs::[]) ->
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 = doc_of_pattern currentModule x in
-                    parens uu___2 in
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = doc_of_pattern currentModule xs in
-                      [uu___4] in
-                    (text "::") :: uu___3 in
-                  uu___1 :: uu___2 in
-                reduce uu___
-            | (uu___, (FStar_Extraction_ML_Syntax.MLP_Tuple uu___1)::[]) ->
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = FStar_Compiler_List.hd pats in
-                      doc_of_pattern currentModule uu___5 in
-                    [uu___4] in
-                  (text name) :: uu___3 in
-                reduce1 uu___2
-            | uu___ ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_Compiler_List.map
-                            (doc_of_pattern currentModule) pats in
-                        combine (text ", ") uu___5 in
-                      parens uu___4 in
-                    [uu___3] in
-                  (text name) :: uu___2 in
-                reduce1 uu___1 in
-          maybe_paren (min_op_prec, NonAssoc) e_app_prio doc1
-      | FStar_Extraction_ML_Syntax.MLP_Tuple ps ->
-          let ps1 = FStar_Compiler_List.map (doc_of_pattern currentModule) ps in
-          let uu___ = combine (text ", ") ps1 in parens uu___
-      | FStar_Extraction_ML_Syntax.MLP_Branch ps ->
-          let ps1 = FStar_Compiler_List.map (doc_of_pattern currentModule) ps in
-          let ps2 = FStar_Compiler_List.map parens ps1 in
-          combine (text " | ") ps2
-and (doc_of_branch :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlbranch -> doc)
-  =
-  fun currentModule ->
-    fun uu___ ->
-      match uu___ with
-      | (p, cond, e) ->
-          let case =
-            match cond with
-            | FStar_Pervasives_Native.None ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = doc_of_pattern currentModule p in [uu___3] in
-                  (text "|") :: uu___2 in
-                reduce1 uu___1
-            | FStar_Pervasives_Native.Some c ->
-                let c1 = doc_of_expr currentModule (min_op_prec, NonAssoc) c in
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = doc_of_pattern currentModule p in
-                    [uu___3; text "when"; c1] in
-                  (text "|") :: uu___2 in
-                reduce1 uu___1 in
-          let uu___1 =
-            let uu___2 = reduce1 [case; text "->"; text "begin"] in
-            let uu___3 =
-              let uu___4 =
-                doc_of_expr currentModule (min_op_prec, NonAssoc) e in
-              [uu___4; text "end"] in
-            uu___2 :: uu___3 in
-          combine hardline uu___1
-and (doc_of_lets :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    (FStar_Extraction_ML_Syntax.mlletflavor * Prims.bool *
-      FStar_Extraction_ML_Syntax.mllb Prims.list) -> doc)
-  =
-  fun currentModule ->
-    fun uu___ ->
-      match uu___ with
-      | (rec_, top_level, lets) ->
-          let for1 uu___1 =
-            match uu___1 with
-            | { FStar_Extraction_ML_Syntax.mllb_name = name;
-                FStar_Extraction_ML_Syntax.mllb_tysc = tys;
-                FStar_Extraction_ML_Syntax.mllb_add_unit = uu___2;
-                FStar_Extraction_ML_Syntax.mllb_def = e;
-                FStar_Extraction_ML_Syntax.mllb_meta = uu___3;
-                FStar_Extraction_ML_Syntax.print_typ = pt;_} ->
-                let e1 = doc_of_expr currentModule (min_op_prec, NonAssoc) e in
-                let ids = [] in
-                let ty_annot =
-                  if Prims.op_Negation pt
-                  then text ""
-                  else
-                    (let uu___5 =
-                       (FStar_Extraction_ML_Util.codegen_fsharp ()) &&
-                         ((rec_ = FStar_Extraction_ML_Syntax.Rec) ||
-                            top_level) in
-                     if uu___5
-                     then
-                       match tys with
-                       | FStar_Pervasives_Native.Some
-                           (uu___6::uu___7, uu___8) -> text ""
-                       | FStar_Pervasives_Native.None -> text ""
-                       | FStar_Pervasives_Native.Some ([], ty) ->
-                           let ty1 =
-                             doc_of_mltype currentModule
-                               (min_op_prec, NonAssoc) ty in
-                           reduce1 [text ":"; ty1]
-                     else
-                       if top_level
-                       then
-                         (match tys with
-                          | FStar_Pervasives_Native.None -> text ""
-                          | FStar_Pervasives_Native.Some ([], ty) ->
-                              let ty1 =
-                                doc_of_mltype currentModule
-                                  (min_op_prec, NonAssoc) ty in
-                              reduce1 [text ":"; ty1]
-                          | FStar_Pervasives_Native.Some (vs, ty) ->
-                              let ty1 =
-                                doc_of_mltype currentModule
-                                  (min_op_prec, NonAssoc) ty in
-                              let vars =
-                                let uu___7 =
-                                  FStar_Compiler_Effect.op_Bar_Greater vs
-                                    (FStar_Compiler_List.map
-                                       (fun x ->
-                                          doc_of_mltype currentModule
-                                            (min_op_prec, NonAssoc)
-                                            (FStar_Extraction_ML_Syntax.MLTY_Var
-                                               x))) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                  reduce1 in
-                              reduce1 [text ":"; vars; text "."; ty1])
-                       else text "") in
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 = reduce1 ids in
-                    [uu___6; ty_annot; text "="; e1] in
-                  (text name) :: uu___5 in
-                reduce1 uu___4 in
-          let letdoc =
-            if rec_ = FStar_Extraction_ML_Syntax.Rec
-            then reduce1 [text "let"; text "rec"]
-            else text "let" in
-          let lets1 = FStar_Compiler_List.map for1 lets in
-          let lets2 =
-            FStar_Compiler_List.mapi
-              (fun i ->
-                 fun doc1 ->
-                   reduce1
-                     [if i = Prims.int_zero then letdoc else text "and";
-                     doc1]) lets1 in
-          combine hardline lets2
-and (doc_of_loc : FStar_Extraction_ML_Syntax.mlloc -> doc) =
-  fun uu___ ->
-    match uu___ with
-    | (lineno, file) ->
-        let uu___1 =
-          ((FStar_Options.no_location_info ()) ||
-             (FStar_Extraction_ML_Util.codegen_fsharp ()))
-            || (file = " dummy") in
-        if uu___1
-        then empty
-        else
-          (let file1 = FStar_Compiler_Util.basename file in
-           let uu___3 =
-             let uu___4 =
-               let uu___5 = num lineno in
-               [uu___5; text (Prims.op_Hat "\"" (Prims.op_Hat file1 "\""))] in
-             (text "#") :: uu___4 in
-           reduce1 uu___3)
-let (doc_of_mltydecl :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mltydecl -> doc)
-  =
-  fun currentModule ->
-    fun decls ->
-      let for1 uu___ =
-        match uu___ with
-        | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-            FStar_Extraction_ML_Syntax.tydecl_name = x;
-            FStar_Extraction_ML_Syntax.tydecl_ignored = mangle_opt;
-            FStar_Extraction_ML_Syntax.tydecl_parameters = tparams;
-            FStar_Extraction_ML_Syntax.tydecl_meta = uu___2;
-            FStar_Extraction_ML_Syntax.tydecl_defn = body;_} ->
-            let x1 =
-              match mangle_opt with
-              | FStar_Pervasives_Native.None -> x
-              | FStar_Pervasives_Native.Some y -> y in
-            let tparams1 =
-              match tparams with
-              | [] -> empty
-              | x2::[] -> text x2
-              | uu___3 ->
-                  let doc1 =
-                    FStar_Compiler_List.map (fun x2 -> text x2) tparams in
-                  let uu___4 = combine (text ", ") doc1 in parens uu___4 in
-            let forbody body1 =
-              match body1 with
-              | FStar_Extraction_ML_Syntax.MLTD_Abbrev ty ->
-                  doc_of_mltype currentModule (min_op_prec, NonAssoc) ty
-              | FStar_Extraction_ML_Syntax.MLTD_Record fields ->
-                  let forfield uu___3 =
-                    match uu___3 with
-                    | (name, ty) ->
-                        let name1 = text name in
-                        let ty1 =
-                          doc_of_mltype currentModule (min_op_prec, NonAssoc)
-                            ty in
-                        reduce1 [name1; text ":"; ty1] in
-                  let uu___3 =
-                    let uu___4 = FStar_Compiler_List.map forfield fields in
-                    combine (text "; ") uu___4 in
-                  cbrackets uu___3
-              | FStar_Extraction_ML_Syntax.MLTD_DType ctors ->
-                  let forctor uu___3 =
-                    match uu___3 with
-                    | (name, tys) ->
-                        let uu___4 = FStar_Compiler_List.split tys in
-                        (match uu___4 with
-                         | (_names, tys1) ->
-                             (match tys1 with
-                              | [] -> text name
-                              | uu___5 ->
-                                  let tys2 =
-                                    FStar_Compiler_List.map
-                                      (doc_of_mltype currentModule
-                                         (t_prio_tpl, Left)) tys1 in
-                                  let tys3 = combine (text " * ") tys2 in
-                                  reduce1 [text name; text "of"; tys3])) in
-                  let ctors1 = FStar_Compiler_List.map forctor ctors in
-                  let ctors2 =
-                    FStar_Compiler_List.map (fun d -> reduce1 [text "|"; d])
-                      ctors1 in
-                  combine hardline ctors2 in
-            let doc1 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 = ptsym currentModule ([], x1) in text uu___6 in
-                  [uu___5] in
-                tparams1 :: uu___4 in
-              reduce1 uu___3 in
-            (match body with
-             | FStar_Pervasives_Native.None -> doc1
-             | FStar_Pervasives_Native.Some body1 ->
-                 let body2 = forbody body1 in
-                 let uu___3 =
-                   let uu___4 = reduce1 [doc1; text "="] in [uu___4; body2] in
-                 combine hardline uu___3) in
-      let doc1 = FStar_Compiler_List.map for1 decls in
-      let doc2 =
-        if (FStar_Compiler_List.length doc1) > Prims.int_zero
-        then
-          let uu___ =
-            let uu___1 =
-              let uu___2 = combine (text " \n and ") doc1 in [uu___2] in
-            (text "type") :: uu___1 in
-          reduce1 uu___
-        else text "" in
-      doc2
-let rec (doc_of_sig1 :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlsig1 -> doc)
-  =
-  fun currentModule ->
-    fun s ->
-      match s with
-      | FStar_Extraction_ML_Syntax.MLS_Mod (x, subsig) ->
-          let uu___ =
-            let uu___1 = reduce1 [text "module"; text x; text "="] in
-            let uu___2 =
-              let uu___3 = doc_of_sig currentModule subsig in
-              let uu___4 = let uu___5 = reduce1 [text "end"] in [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          combine hardline uu___
-      | FStar_Extraction_ML_Syntax.MLS_Exn (x, []) ->
-          reduce1 [text "exception"; text x]
-      | FStar_Extraction_ML_Syntax.MLS_Exn (x, args) ->
-          let args1 =
-            FStar_Compiler_List.map
-              (doc_of_mltype currentModule (min_op_prec, NonAssoc)) args in
-          let args2 = let uu___ = combine (text " * ") args1 in parens uu___ in
-          reduce1 [text "exception"; text x; text "of"; args2]
-      | FStar_Extraction_ML_Syntax.MLS_Val (x, (uu___, ty)) ->
-          let ty1 = doc_of_mltype currentModule (min_op_prec, NonAssoc) ty in
-          reduce1 [text "val"; text x; text ": "; ty1]
-      | FStar_Extraction_ML_Syntax.MLS_Ty decls ->
-          doc_of_mltydecl currentModule decls
-and (doc_of_sig :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlsig -> doc)
-  =
-  fun currentModule ->
-    fun s ->
-      let docs = FStar_Compiler_List.map (doc_of_sig1 currentModule) s in
-      let docs1 =
-        FStar_Compiler_List.map (fun x -> reduce [x; hardline; hardline])
-          docs in
-      reduce docs1
-let (doc_of_mod1 :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlmodule1 -> doc)
-  =
-  fun currentModule ->
-    fun m ->
-      match m with
-      | FStar_Extraction_ML_Syntax.MLM_Exn (x, []) ->
-          reduce1 [text "exception"; text x]
-      | FStar_Extraction_ML_Syntax.MLM_Exn (x, args) ->
-          let args1 =
-            FStar_Compiler_List.map FStar_Pervasives_Native.snd args in
-          let args2 =
-            FStar_Compiler_List.map
-              (doc_of_mltype currentModule (min_op_prec, NonAssoc)) args1 in
-          let args3 = let uu___ = combine (text " * ") args2 in parens uu___ in
-          reduce1 [text "exception"; text x; text "of"; args3]
-      | FStar_Extraction_ML_Syntax.MLM_Ty decls ->
-          doc_of_mltydecl currentModule decls
-      | FStar_Extraction_ML_Syntax.MLM_Let (rec_, lets) ->
-          doc_of_lets currentModule (rec_, true, lets)
-      | FStar_Extraction_ML_Syntax.MLM_Top e ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    doc_of_expr currentModule (min_op_prec, NonAssoc) e in
-                  [uu___4] in
-                (text "=") :: uu___3 in
-              (text "_") :: uu___2 in
-            (text "let") :: uu___1 in
-          reduce1 uu___
-      | FStar_Extraction_ML_Syntax.MLM_Loc loc -> doc_of_loc loc
-let (doc_of_mod :
-  FStar_Extraction_ML_Syntax.mlsymbol ->
-    FStar_Extraction_ML_Syntax.mlmodule -> doc)
-  =
-  fun currentModule ->
-    fun m ->
-      let docs =
-        FStar_Compiler_List.map
-          (fun x ->
-             let doc1 = doc_of_mod1 currentModule x in
-             [doc1;
-             (match x with
-              | FStar_Extraction_ML_Syntax.MLM_Loc uu___ -> empty
-              | uu___ -> hardline);
-             hardline]) m in
-      reduce (FStar_Compiler_List.flatten docs)
-let (doc_of_mllib_r :
-  FStar_Extraction_ML_Syntax.mllib -> (Prims.string * doc) Prims.list) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Extraction_ML_Syntax.MLLib mllib ->
-        let rec for1_sig uu___1 =
-          match uu___1 with
-          | (x, sigmod, FStar_Extraction_ML_Syntax.MLLib sub) ->
-              let x1 = FStar_Extraction_ML_Util.flatten_mlpath x in
-              let head =
-                reduce1 [text "module"; text x1; text ":"; text "sig"] in
-              let tail = reduce1 [text "end"] in
-              let doc1 =
-                FStar_Compiler_Option.map
-                  (fun uu___2 ->
-                     match uu___2 with | (s, uu___3) -> doc_of_sig x1 s)
-                  sigmod in
-              let sub1 = FStar_Compiler_List.map for1_sig sub in
-              let sub2 =
-                FStar_Compiler_List.map
-                  (fun x2 -> reduce [x2; hardline; hardline]) sub1 in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = reduce sub2 in [uu___5; cat tail hardline] in
-                  (match doc1 with
-                   | FStar_Pervasives_Native.None -> empty
-                   | FStar_Pervasives_Native.Some s -> cat s hardline) ::
-                    uu___4 in
-                (cat head hardline) :: uu___3 in
-              reduce uu___2
-        and for1_mod istop uu___1 =
-          match uu___1 with
-          | (mod_name, sigmod, FStar_Extraction_ML_Syntax.MLLib sub) ->
-              let target_mod_name =
-                FStar_Extraction_ML_Util.flatten_mlpath mod_name in
-              let maybe_open_pervasives =
-                match mod_name with
-                | ("FStar"::[], "Pervasives") -> []
-                | uu___2 ->
-                    let pervasives =
-                      FStar_Extraction_ML_Util.flatten_mlpath
-                        (["FStar"], "Pervasives") in
-                    [hardline; text (Prims.op_Hat "open " pervasives)] in
-              let head =
-                let uu___2 =
-                  let uu___3 = FStar_Extraction_ML_Util.codegen_fsharp () in
-                  if uu___3
-                  then [text "module"; text target_mod_name]
-                  else
-                    if Prims.op_Negation istop
-                    then
-                      [text "module";
-                      text target_mod_name;
-                      text "=";
-                      text "struct"]
-                    else [] in
-                reduce1 uu___2 in
-              let tail =
-                if Prims.op_Negation istop
-                then reduce1 [text "end"]
-                else reduce1 [] in
-              let doc1 =
-                FStar_Compiler_Option.map
-                  (fun uu___2 ->
-                     match uu___2 with
-                     | (uu___3, m) -> doc_of_mod target_mod_name m) sigmod in
-              let sub1 = FStar_Compiler_List.map (for1_mod false) sub in
-              let sub2 =
-                FStar_Compiler_List.map
-                  (fun x -> reduce [x; hardline; hardline]) sub1 in
-              let prefix =
-                let uu___2 = FStar_Extraction_ML_Util.codegen_fsharp () in
-                if uu___2 then [cat (text "#light \"off\"") hardline] else [] in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 = reduce sub2 in
-                          [uu___8; cat tail hardline] in
-                        (match doc1 with
-                         | FStar_Pervasives_Native.None -> empty
-                         | FStar_Pervasives_Native.Some s -> cat s hardline)
-                          :: uu___7 in
-                      hardline :: uu___6 in
-                    FStar_Compiler_List.op_At maybe_open_pervasives uu___5 in
-                  FStar_Compiler_List.op_At
-                    [head; hardline; text "open Prims"] uu___4 in
-                FStar_Compiler_List.op_At prefix uu___3 in
-              FStar_Compiler_Effect.op_Less_Bar reduce uu___2 in
-        let docs =
-          FStar_Compiler_List.map
-            (fun uu___1 ->
-               match uu___1 with
-               | (x, s, m) ->
-                   let uu___2 = FStar_Extraction_ML_Util.flatten_mlpath x in
-                   let uu___3 = for1_mod true (x, s, m) in (uu___2, uu___3))
-            mllib in
-        docs
-let (pretty : Prims.int -> doc -> Prims.string) =
-  fun sz -> fun uu___ -> match uu___ with | Doc doc1 -> doc1
-let (doc_of_mllib :
-  FStar_Extraction_ML_Syntax.mllib -> (Prims.string * doc) Prims.list) =
-  fun mllib -> doc_of_mllib_r mllib
-let (string_of_mlexpr :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    FStar_Extraction_ML_Syntax.mlexpr -> Prims.string)
-  =
-  fun cmod ->
-    fun e ->
-      let doc1 =
-        let uu___ = FStar_Extraction_ML_Util.flatten_mlpath cmod in
-        doc_of_expr uu___ (min_op_prec, NonAssoc) e in
-      pretty Prims.int_zero doc1
-let (string_of_mlty :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    FStar_Extraction_ML_Syntax.mlty -> Prims.string)
-  =
-  fun cmod ->
-    fun e ->
-      let doc1 =
-        let uu___ = FStar_Extraction_ML_Util.flatten_mlpath cmod in
-        doc_of_mltype uu___ (min_op_prec, NonAssoc) e in
-      pretty Prims.int_zero doc1
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_Modul.ml b/src/ocaml-output/FStar_Extraction_ML_Modul.ml
deleted file mode 100644
index d41e3a4fe1d..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_Modul.ml
+++ /dev/null
@@ -1,2827 +0,0 @@
-open Prims
-type env_t = FStar_Extraction_ML_UEnv.uenv
-let (fail_exp :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun lid ->
-    fun t ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Parser_Const.failwith_lid () in
-            FStar_Syntax_Syntax.fvar uu___3
-              FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-          let uu___3 =
-            let uu___4 = FStar_Syntax_Syntax.iarg t in
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    let uu___9 =
-                      let uu___10 =
-                        let uu___11 =
-                          let uu___12 = FStar_Syntax_Print.lid_to_string lid in
-                          Prims.op_Hat "Not yet implemented:" uu___12 in
-                        (uu___11, FStar_Compiler_Range.dummyRange) in
-                      FStar_Const.Const_string uu___10 in
-                    FStar_Syntax_Syntax.Tm_constant uu___9 in
-                  FStar_Syntax_Syntax.mk uu___8
-                    FStar_Compiler_Range.dummyRange in
-                FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.as_arg
-                  uu___7 in
-              [uu___6] in
-            uu___4 :: uu___5 in
-          (uu___2, uu___3) in
-        FStar_Syntax_Syntax.Tm_app uu___1 in
-      FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (always_fail :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.letbinding)
-  =
-  fun lid ->
-    fun t ->
-      let imp =
-        let uu___ = FStar_Syntax_Util.arrow_formals t in
-        match uu___ with
-        | ([], t1) ->
-            let b =
-              let uu___1 =
-                FStar_Syntax_Syntax.gen_bv "_" FStar_Pervasives_Native.None
-                  t1 in
-              FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_binder
-                uu___1 in
-            let uu___1 = fail_exp lid t1 in
-            FStar_Syntax_Util.abs [b] uu___1 FStar_Pervasives_Native.None
-        | (bs, t1) ->
-            let uu___1 = fail_exp lid t1 in
-            FStar_Syntax_Util.abs bs uu___1 FStar_Pervasives_Native.None in
-      let lb =
-        let uu___ =
-          let uu___1 =
-            FStar_Syntax_Syntax.lid_as_fv lid
-              FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-          FStar_Pervasives.Inr uu___1 in
-        let uu___1 = FStar_Parser_Const.effect_ML_lid () in
-        {
-          FStar_Syntax_Syntax.lbname = uu___;
-          FStar_Syntax_Syntax.lbunivs = [];
-          FStar_Syntax_Syntax.lbtyp = t;
-          FStar_Syntax_Syntax.lbeff = uu___1;
-          FStar_Syntax_Syntax.lbdef = imp;
-          FStar_Syntax_Syntax.lbattrs = [];
-          FStar_Syntax_Syntax.lbpos = (imp.FStar_Syntax_Syntax.pos)
-        } in
-      lb
-let as_pair : 'uuuuu . 'uuuuu Prims.list -> ('uuuuu * 'uuuuu) =
-  fun uu___ ->
-    match uu___ with
-    | a::b::[] -> (a, b)
-    | uu___1 -> failwith "Expected a list with 2 elements"
-let (flag_of_qual :
-  FStar_Syntax_Syntax.qualifier ->
-    FStar_Extraction_ML_Syntax.meta FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Assumption ->
-        FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.Assumed
-    | FStar_Syntax_Syntax.Private ->
-        FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.Private
-    | FStar_Syntax_Syntax.NoExtract ->
-        FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.NoExtract
-    | uu___1 -> FStar_Pervasives_Native.None
-let rec (extract_meta :
-  FStar_Syntax_Syntax.term ->
-    FStar_Extraction_ML_Syntax.meta FStar_Pervasives_Native.option)
-  =
-  fun x ->
-    let uu___ = FStar_Syntax_Subst.compress x in
-    match uu___ with
-    | { FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-        FStar_Syntax_Syntax.pos = uu___1; FStar_Syntax_Syntax.vars = uu___2;
-        FStar_Syntax_Syntax.hash_code = uu___3;_} ->
-        let uu___4 =
-          let uu___5 = FStar_Syntax_Syntax.lid_of_fv fv in
-          FStar_Ident.string_of_lid uu___5 in
-        (match uu___4 with
-         | "FStar.Pervasives.PpxDerivingShow" ->
-             FStar_Pervasives_Native.Some
-               FStar_Extraction_ML_Syntax.PpxDerivingShow
-         | "FStar.Pervasives.PpxDerivingYoJson" ->
-             FStar_Pervasives_Native.Some
-               FStar_Extraction_ML_Syntax.PpxDerivingYoJson
-         | "FStar.Pervasives.CInline" ->
-             FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.CInline
-         | "FStar.Pervasives.Substitute" ->
-             FStar_Pervasives_Native.Some
-               FStar_Extraction_ML_Syntax.Substitute
-         | "FStar.Pervasives.Gc" ->
-             FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.GCType
-         | "FStar.Pervasives.CAbstractStruct" ->
-             FStar_Pervasives_Native.Some
-               FStar_Extraction_ML_Syntax.CAbstract
-         | "FStar.Pervasives.CIfDef" ->
-             FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.CIfDef
-         | "FStar.Pervasives.CMacro" ->
-             FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.CMacro
-         | "Prims.deprecated" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.Deprecated "")
-         | uu___5 -> FStar_Pervasives_Native.None)
-    | {
-        FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_app
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           ({
-              FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_string (s, uu___4));
-              FStar_Syntax_Syntax.pos = uu___5;
-              FStar_Syntax_Syntax.vars = uu___6;
-              FStar_Syntax_Syntax.hash_code = uu___7;_},
-            uu___8)::[]);
-        FStar_Syntax_Syntax.pos = uu___9; FStar_Syntax_Syntax.vars = uu___10;
-        FStar_Syntax_Syntax.hash_code = uu___11;_} ->
-        let uu___12 =
-          let uu___13 = FStar_Syntax_Syntax.lid_of_fv fv in
-          FStar_Ident.string_of_lid uu___13 in
-        (match uu___12 with
-         | "FStar.Pervasives.PpxDerivingShowConstant" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.PpxDerivingShowConstant s)
-         | "FStar.Pervasives.Comment" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.Comment s)
-         | "FStar.Pervasives.CPrologue" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.CPrologue s)
-         | "FStar.Pervasives.CEpilogue" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.CEpilogue s)
-         | "FStar.Pervasives.CConst" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.CConst s)
-         | "FStar.Pervasives.CCConv" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.CCConv s)
-         | "Prims.deprecated" ->
-             FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.Deprecated s)
-         | uu___13 -> FStar_Pervasives_Native.None)
-    | {
-        FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-          (FStar_Const.Const_string ("KrmlPrivate", uu___1));
-        FStar_Syntax_Syntax.pos = uu___2; FStar_Syntax_Syntax.vars = uu___3;
-        FStar_Syntax_Syntax.hash_code = uu___4;_} ->
-        FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.Private
-    | {
-        FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-          (FStar_Const.Const_string ("c_inline", uu___1));
-        FStar_Syntax_Syntax.pos = uu___2; FStar_Syntax_Syntax.vars = uu___3;
-        FStar_Syntax_Syntax.hash_code = uu___4;_} ->
-        FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.CInline
-    | {
-        FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-          (FStar_Const.Const_string ("substitute", uu___1));
-        FStar_Syntax_Syntax.pos = uu___2; FStar_Syntax_Syntax.vars = uu___3;
-        FStar_Syntax_Syntax.hash_code = uu___4;_} ->
-        FStar_Pervasives_Native.Some FStar_Extraction_ML_Syntax.Substitute
-    | { FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_meta (x1, uu___1);
-        FStar_Syntax_Syntax.pos = uu___2; FStar_Syntax_Syntax.vars = uu___3;
-        FStar_Syntax_Syntax.hash_code = uu___4;_} -> extract_meta x1
-    | uu___1 ->
-        let uu___2 = FStar_Syntax_Util.head_and_args x in
-        (match uu___2 with
-         | (head, args) ->
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = FStar_Syntax_Subst.compress head in
-                 uu___5.FStar_Syntax_Syntax.n in
-               (uu___4, args) in
-             (match uu___3 with
-              | (FStar_Syntax_Syntax.Tm_fvar fv, uu___4::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.remove_unused_type_parameters_lid
-                  ->
-                  let uu___5 =
-                    let uu___6 =
-                      FStar_ToSyntax_ToSyntax.parse_attr_with_list false x
-                        FStar_Parser_Const.remove_unused_type_parameters_lid in
-                    FStar_Pervasives_Native.fst uu___6 in
-                  (match uu___5 with
-                   | FStar_Pervasives_Native.None ->
-                       FStar_Pervasives_Native.None
-                   | FStar_Pervasives_Native.Some l ->
-                       let uu___6 =
-                         let uu___7 =
-                           let uu___8 = FStar_Syntax_Syntax.range_of_fv fv in
-                           (l, uu___8) in
-                         FStar_Extraction_ML_Syntax.RemoveUnusedTypeParameters
-                           uu___7 in
-                       FStar_Pervasives_Native.Some uu___6)
-              | uu___4 -> FStar_Pervasives_Native.None))
-let (extract_metadata :
-  FStar_Syntax_Syntax.term Prims.list ->
-    FStar_Extraction_ML_Syntax.meta Prims.list)
-  = fun metas -> FStar_Compiler_List.choose extract_meta metas
-let (binders_as_mlty_binders :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      (FStar_Extraction_ML_UEnv.uenv * FStar_Extraction_ML_Syntax.mlident
-        Prims.list))
-  =
-  fun env ->
-    fun bs ->
-      FStar_Compiler_Util.fold_map
-        (fun env1 ->
-           fun uu___ ->
-             match uu___ with
-             | { FStar_Syntax_Syntax.binder_bv = bv;
-                 FStar_Syntax_Syntax.binder_qual = uu___1;
-                 FStar_Syntax_Syntax.binder_attrs = uu___2;_} ->
-                 let env2 = FStar_Extraction_ML_UEnv.extend_ty env1 bv false in
-                 let name =
-                   let uu___3 = FStar_Extraction_ML_UEnv.lookup_bv env2 bv in
-                   match uu___3 with
-                   | FStar_Pervasives.Inl ty ->
-                       ty.FStar_Extraction_ML_UEnv.ty_b_name
-                   | uu___4 -> failwith "Impossible" in
-                 (env2, name)) env bs
-type data_constructor =
-  {
-  dname: FStar_Ident.lident ;
-  dtyp: FStar_Syntax_Syntax.typ }
-let (__proj__Mkdata_constructor__item__dname :
-  data_constructor -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | { dname; dtyp;_} -> dname
-let (__proj__Mkdata_constructor__item__dtyp :
-  data_constructor -> FStar_Syntax_Syntax.typ) =
-  fun projectee -> match projectee with | { dname; dtyp;_} -> dtyp
-type inductive_family =
-  {
-  ifv: FStar_Syntax_Syntax.fv ;
-  iname: FStar_Ident.lident ;
-  iparams: FStar_Syntax_Syntax.binders ;
-  ityp: FStar_Syntax_Syntax.term ;
-  idatas: data_constructor Prims.list ;
-  iquals: FStar_Syntax_Syntax.qualifier Prims.list ;
-  imetadata: FStar_Extraction_ML_Syntax.metadata }
-let (__proj__Mkinductive_family__item__ifv :
-  inductive_family -> FStar_Syntax_Syntax.fv) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> ifv
-let (__proj__Mkinductive_family__item__iname :
-  inductive_family -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> iname
-let (__proj__Mkinductive_family__item__iparams :
-  inductive_family -> FStar_Syntax_Syntax.binders) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> iparams
-let (__proj__Mkinductive_family__item__ityp :
-  inductive_family -> FStar_Syntax_Syntax.term) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> ityp
-let (__proj__Mkinductive_family__item__idatas :
-  inductive_family -> data_constructor Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> idatas
-let (__proj__Mkinductive_family__item__iquals :
-  inductive_family -> FStar_Syntax_Syntax.qualifier Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> iquals
-let (__proj__Mkinductive_family__item__imetadata :
-  inductive_family -> FStar_Extraction_ML_Syntax.metadata) =
-  fun projectee ->
-    match projectee with
-    | { ifv; iname; iparams; ityp; idatas; iquals; imetadata;_} -> imetadata
-let (print_ifamily : inductive_family -> unit) =
-  fun i ->
-    let uu___ = FStar_Syntax_Print.lid_to_string i.iname in
-    let uu___1 = FStar_Syntax_Print.binders_to_string " " i.iparams in
-    let uu___2 = FStar_Syntax_Print.term_to_string i.ityp in
-    let uu___3 =
-      let uu___4 =
-        FStar_Compiler_Effect.op_Bar_Greater i.idatas
-          (FStar_Compiler_List.map
-             (fun d ->
-                let uu___5 = FStar_Syntax_Print.lid_to_string d.dname in
-                let uu___6 =
-                  let uu___7 = FStar_Syntax_Print.term_to_string d.dtyp in
-                  Prims.op_Hat " : " uu___7 in
-                Prims.op_Hat uu___5 uu___6)) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___4
-        (FStar_String.concat "\n\t\t") in
-    FStar_Compiler_Util.print4 "\n\t%s %s : %s { %s }\n" uu___ uu___1 uu___2
-      uu___3
-let (bundle_as_inductive_families :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        (FStar_Extraction_ML_UEnv.uenv * inductive_family Prims.list))
-  =
-  fun env ->
-    fun ses ->
-      fun quals ->
-        let uu___ =
-          FStar_Compiler_Util.fold_map
-            (fun env1 ->
-               fun se ->
-                 match se.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_inductive_typ
-                     (l, us, bs, _num_uniform, t, _mut_i, datas) ->
-                     let uu___1 = FStar_Syntax_Subst.open_univ_vars us t in
-                     (match uu___1 with
-                      | (_us, t1) ->
-                          let uu___2 = FStar_Syntax_Subst.open_term bs t1 in
-                          (match uu___2 with
-                           | (bs1, t2) ->
-                               let datas1 =
-                                 FStar_Compiler_Effect.op_Bar_Greater ses
-                                   (FStar_Compiler_List.collect
-                                      (fun se1 ->
-                                         match se1.FStar_Syntax_Syntax.sigel
-                                         with
-                                         | FStar_Syntax_Syntax.Sig_datacon
-                                             (d, us1, t3, l', nparams,
-                                              uu___3)
-                                             when FStar_Ident.lid_equals l l'
-                                             ->
-                                             let uu___4 =
-                                               FStar_Syntax_Subst.open_univ_vars
-                                                 us1 t3 in
-                                             (match uu___4 with
-                                              | (_us1, t4) ->
-                                                  let uu___5 =
-                                                    FStar_Syntax_Util.arrow_formals
-                                                      t4 in
-                                                  (match uu___5 with
-                                                   | (bs', body) ->
-                                                       let uu___6 =
-                                                         FStar_Compiler_Util.first_N
-                                                           (FStar_Compiler_List.length
-                                                              bs1) bs' in
-                                                       (match uu___6 with
-                                                        | (bs_params, rest)
-                                                            ->
-                                                            let subst =
-                                                              FStar_Compiler_List.map2
-                                                                (fun uu___7
-                                                                   ->
-                                                                   fun uu___8
-                                                                    ->
-                                                                    match 
-                                                                    (uu___7,
-                                                                    uu___8)
-                                                                    with
-                                                                    | 
-                                                                    ({
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b';
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___9;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___10;_},
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___11;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___12;_})
-                                                                    ->
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    b in
-                                                                    (b',
-                                                                    uu___14) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___13)
-                                                                bs_params bs1 in
-                                                            let t5 =
-                                                              let uu___7 =
-                                                                let uu___8 =
-                                                                  FStar_Syntax_Syntax.mk_Total
-                                                                    body in
-                                                                FStar_Syntax_Util.arrow
-                                                                  rest uu___8 in
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                uu___7
-                                                                (FStar_Syntax_Subst.subst
-                                                                   subst) in
-                                                            [{
-                                                               dname = d;
-                                                               dtyp = t5
-                                                             }])))
-                                         | uu___3 -> [])) in
-                               let metadata =
-                                 let uu___3 =
-                                   extract_metadata
-                                     se.FStar_Syntax_Syntax.sigattrs in
-                                 let uu___4 =
-                                   FStar_Compiler_List.choose flag_of_qual
-                                     quals in
-                                 FStar_Compiler_List.op_At uu___3 uu___4 in
-                               let fv =
-                                 FStar_Syntax_Syntax.lid_as_fv l
-                                   FStar_Syntax_Syntax.delta_constant
-                                   FStar_Pervasives_Native.None in
-                               let uu___3 =
-                                 FStar_Extraction_ML_UEnv.extend_type_name
-                                   env1 fv in
-                               (match uu___3 with
-                                | (uu___4, env2) ->
-                                    (env2,
-                                      [{
-                                         ifv = fv;
-                                         iname = l;
-                                         iparams = bs1;
-                                         ityp = t2;
-                                         idatas = datas1;
-                                         iquals =
-                                           (se.FStar_Syntax_Syntax.sigquals);
-                                         imetadata = metadata
-                                       }]))))
-                 | uu___1 -> (env1, [])) env ses in
-        match uu___ with
-        | (env1, ifams) -> (env1, (FStar_Compiler_List.flatten ifams))
-type tydef_declaration =
-  (FStar_Extraction_ML_Syntax.mlsymbol * FStar_Extraction_ML_Syntax.metadata
-    * Prims.int)
-type iface =
-  {
-  iface_module_name: FStar_Extraction_ML_Syntax.mlpath ;
-  iface_bindings:
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_UEnv.exp_binding)
-      Prims.list
-    ;
-  iface_tydefs:
-    (FStar_Extraction_ML_UEnv.tydef, tydef_declaration)
-      FStar_Pervasives.either Prims.list
-    ;
-  iface_type_names:
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_Syntax.mlpath) Prims.list }
-let (__proj__Mkiface__item__iface_module_name :
-  iface -> FStar_Extraction_ML_Syntax.mlpath) =
-  fun projectee ->
-    match projectee with
-    | { iface_module_name; iface_bindings; iface_tydefs; iface_type_names;_}
-        -> iface_module_name
-let (__proj__Mkiface__item__iface_bindings :
-  iface ->
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_UEnv.exp_binding)
-      Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { iface_module_name; iface_bindings; iface_tydefs; iface_type_names;_}
-        -> iface_bindings
-let (__proj__Mkiface__item__iface_tydefs :
-  iface ->
-    (FStar_Extraction_ML_UEnv.tydef, tydef_declaration)
-      FStar_Pervasives.either Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { iface_module_name; iface_bindings; iface_tydefs; iface_type_names;_}
-        -> iface_tydefs
-let (__proj__Mkiface__item__iface_type_names :
-  iface ->
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_Syntax.mlpath) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { iface_module_name; iface_bindings; iface_tydefs; iface_type_names;_}
-        -> iface_type_names
-let (empty_iface : iface) =
-  {
-    iface_module_name = ([], "");
-    iface_bindings = [];
-    iface_tydefs = [];
-    iface_type_names = []
-  }
-let (iface_of_bindings :
-  (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_UEnv.exp_binding) Prims.list
-    -> iface)
-  =
-  fun fvs ->
-    {
-      iface_module_name = (empty_iface.iface_module_name);
-      iface_bindings = fvs;
-      iface_tydefs = (empty_iface.iface_tydefs);
-      iface_type_names = (empty_iface.iface_type_names)
-    }
-let (iface_of_tydefs : FStar_Extraction_ML_UEnv.tydef Prims.list -> iface) =
-  fun tds ->
-    let uu___ =
-      FStar_Compiler_List.map (fun uu___1 -> FStar_Pervasives.Inl uu___1) tds in
-    let uu___1 =
-      FStar_Compiler_List.map
-        (fun td ->
-           let uu___2 = FStar_Extraction_ML_UEnv.tydef_fv td in
-           let uu___3 = FStar_Extraction_ML_UEnv.tydef_mlpath td in
-           (uu___2, uu___3)) tds in
-    {
-      iface_module_name = (empty_iface.iface_module_name);
-      iface_bindings = (empty_iface.iface_bindings);
-      iface_tydefs = uu___;
-      iface_type_names = uu___1
-    }
-let (iface_of_type_names :
-  (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_Syntax.mlpath) Prims.list ->
-    iface)
-  =
-  fun fvs ->
-    {
-      iface_module_name = (empty_iface.iface_module_name);
-      iface_bindings = (empty_iface.iface_bindings);
-      iface_tydefs = (empty_iface.iface_tydefs);
-      iface_type_names = fvs
-    }
-let (iface_union : iface -> iface -> iface) =
-  fun if1 ->
-    fun if2 ->
-      let uu___ =
-        if if1.iface_module_name <> if1.iface_module_name
-        then failwith "Union not defined"
-        else if1.iface_module_name in
-      {
-        iface_module_name = uu___;
-        iface_bindings =
-          (FStar_Compiler_List.op_At if1.iface_bindings if2.iface_bindings);
-        iface_tydefs =
-          (FStar_Compiler_List.op_At if1.iface_tydefs if2.iface_tydefs);
-        iface_type_names =
-          (FStar_Compiler_List.op_At if1.iface_type_names
-             if2.iface_type_names)
-      }
-let (iface_union_l : iface Prims.list -> iface) =
-  fun ifs -> FStar_Compiler_List.fold_right iface_union ifs empty_iface
-let (mlpath_to_string : FStar_Extraction_ML_Syntax.mlpath -> Prims.string) =
-  fun p ->
-    FStar_String.concat ". "
-      (FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst p)
-         [FStar_Pervasives_Native.snd p])
-let tscheme_to_string :
-  'uuuuu .
-    FStar_Extraction_ML_Syntax.mlpath ->
-      ('uuuuu * FStar_Extraction_ML_Syntax.mlty) -> Prims.string
-  =
-  fun cm ->
-    fun ts ->
-      FStar_Extraction_ML_Code.string_of_mlty cm
-        (FStar_Pervasives_Native.snd ts)
-let (print_exp_binding :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    FStar_Extraction_ML_UEnv.exp_binding -> Prims.string)
-  =
-  fun cm ->
-    fun e ->
-      let uu___ =
-        FStar_Extraction_ML_Code.string_of_mlexpr cm
-          e.FStar_Extraction_ML_UEnv.exp_b_expr in
-      let uu___1 =
-        tscheme_to_string cm e.FStar_Extraction_ML_UEnv.exp_b_tscheme in
-      FStar_Compiler_Util.format3
-        "{\n\texp_b_name = %s\n\texp_b_expr = %s\n\texp_b_tscheme = %s }"
-        e.FStar_Extraction_ML_UEnv.exp_b_name uu___ uu___1
-let (print_binding :
-  FStar_Extraction_ML_Syntax.mlpath ->
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_UEnv.exp_binding) ->
-      Prims.string)
-  =
-  fun cm ->
-    fun uu___ ->
-      match uu___ with
-      | (fv, exp_binding) ->
-          let uu___1 = FStar_Syntax_Print.fv_to_string fv in
-          let uu___2 = print_exp_binding cm exp_binding in
-          FStar_Compiler_Util.format2 "(%s, %s)" uu___1 uu___2
-let print_tydef :
-  'uuuuu 'uuuuu1 .
-    FStar_Extraction_ML_Syntax.mlpath ->
-      (FStar_Extraction_ML_UEnv.tydef, (Prims.string * 'uuuuu * 'uuuuu1))
-        FStar_Pervasives.either -> Prims.string
-  =
-  fun cm ->
-    fun tydef ->
-      let uu___ =
-        match tydef with
-        | FStar_Pervasives.Inl tydef1 ->
-            let uu___1 =
-              let uu___2 = FStar_Extraction_ML_UEnv.tydef_fv tydef1 in
-              FStar_Syntax_Print.fv_to_string uu___2 in
-            let uu___2 =
-              let uu___3 = FStar_Extraction_ML_UEnv.tydef_def tydef1 in
-              tscheme_to_string cm uu___3 in
-            (uu___1, uu___2)
-        | FStar_Pervasives.Inr (p, uu___1, uu___2) -> (p, "None") in
-      match uu___ with
-      | (name, defn) -> FStar_Compiler_Util.format2 "(%s, %s)" name defn
-let (iface_to_string : iface -> Prims.string) =
-  fun iface1 ->
-    let cm = iface1.iface_module_name in
-    let print_type_name uu___ =
-      match uu___ with | (tn, uu___1) -> FStar_Syntax_Print.fv_to_string tn in
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_List.map (print_binding cm) iface1.iface_bindings in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 (FStar_String.concat "\n") in
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_List.map (print_tydef cm) iface1.iface_tydefs in
-      FStar_Compiler_Effect.op_Bar_Greater uu___2 (FStar_String.concat "\n") in
-    let uu___2 =
-      let uu___3 =
-        FStar_Compiler_List.map print_type_name iface1.iface_type_names in
-      FStar_Compiler_Effect.op_Bar_Greater uu___3 (FStar_String.concat "\n") in
-    FStar_Compiler_Util.format4
-      "Interface %s = {\niface_bindings=\n%s;\n\niface_tydefs=\n%s;\n\niface_type_names=%s;\n}"
-      (mlpath_to_string iface1.iface_module_name) uu___ uu___1 uu___2
-let (gamma_to_string : FStar_Extraction_ML_UEnv.uenv -> Prims.string) =
-  fun env ->
-    let cm = FStar_Extraction_ML_UEnv.current_module_of_uenv env in
-    let gamma =
-      let uu___ = FStar_Extraction_ML_UEnv.bindings_of_uenv env in
-      FStar_Compiler_List.collect
-        (fun uu___1 ->
-           match uu___1 with
-           | FStar_Extraction_ML_UEnv.Fv (b, e) -> [(b, e)]
-           | uu___2 -> []) uu___ in
-    let uu___ =
-      let uu___1 = FStar_Compiler_List.map (print_binding cm) gamma in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 (FStar_String.concat "\n") in
-    FStar_Compiler_Util.format1 "Gamma = {\n %s }" uu___
-let (extract_typ_abbrev :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Syntax_Syntax.term Prims.list ->
-        FStar_Syntax_Syntax.letbinding ->
-          (env_t * iface * FStar_Extraction_ML_Syntax.mlmodule1 Prims.list))
-  =
-  fun env ->
-    fun quals ->
-      fun attrs ->
-        fun lb ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-              FStar_TypeChecker_Env.open_universes_in uu___2
-                lb.FStar_Syntax_Syntax.lbunivs
-                [lb.FStar_Syntax_Syntax.lbdef; lb.FStar_Syntax_Syntax.lbtyp] in
-            match uu___1 with
-            | (tcenv, uu___2, def_typ) ->
-                let uu___3 = as_pair def_typ in (tcenv, uu___3) in
-          match uu___ with
-          | (tcenv, (lbdef, lbtyp)) ->
-              let lbtyp1 =
-                FStar_TypeChecker_Normalize.normalize
-                  [FStar_TypeChecker_Env.Beta;
-                  FStar_TypeChecker_Env.UnfoldUntil
-                    FStar_Syntax_Syntax.delta_constant;
-                  FStar_TypeChecker_Env.ForExtraction] tcenv lbtyp in
-              let lbdef1 =
-                FStar_TypeChecker_Normalize.eta_expand_with_type tcenv lbdef
-                  lbtyp1 in
-              let fv =
-                FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-              let lid =
-                (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-              let def =
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Subst.compress lbdef1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___2
-                    FStar_Syntax_Util.unmeta in
-                FStar_Compiler_Effect.op_Bar_Greater uu___1
-                  FStar_Syntax_Util.un_uinst in
-              let def1 =
-                match def.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_abs uu___1 ->
-                    FStar_Extraction_ML_Term.normalize_abs def
-                | uu___1 -> def in
-              let uu___1 =
-                match def1.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_abs (bs, body, uu___2) ->
-                    FStar_Syntax_Subst.open_term bs body
-                | uu___2 -> ([], def1) in
-              (match uu___1 with
-               | (bs, body) ->
-                   let assumed =
-                     FStar_Compiler_Util.for_some
-                       (fun uu___2 ->
-                          match uu___2 with
-                          | FStar_Syntax_Syntax.Assumption -> true
-                          | uu___3 -> false) quals in
-                   let uu___2 = binders_as_mlty_binders env bs in
-                   (match uu___2 with
-                    | (env1, ml_bs) ->
-                        let body1 =
-                          let uu___3 =
-                            FStar_Extraction_ML_Term.term_as_mlty env1 body in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___3
-                            (FStar_Extraction_ML_Util.eraseTypeDeep
-                               (FStar_Extraction_ML_Util.udelta_unfold env1)) in
-                        let metadata =
-                          let has_val_decl =
-                            FStar_Extraction_ML_UEnv.has_tydef_declaration
-                              env lid in
-                          let meta =
-                            let uu___3 = extract_metadata attrs in
-                            let uu___4 =
-                              FStar_Compiler_List.choose flag_of_qual quals in
-                            FStar_Compiler_List.op_At uu___3 uu___4 in
-                          if has_val_decl
-                          then
-                            let uu___3 =
-                              let uu___4 = FStar_Ident.range_of_lid lid in
-                              FStar_Extraction_ML_Syntax.HasValDecl uu___4 in
-                            uu___3 :: meta
-                          else meta in
-                        let tyscheme = (ml_bs, body1) in
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Compiler_Effect.op_Bar_Greater quals
-                              (FStar_Compiler_Util.for_some
-                                 (fun uu___5 ->
-                                    match uu___5 with
-                                    | FStar_Syntax_Syntax.Assumption -> true
-                                    | FStar_Syntax_Syntax.New -> true
-                                    | uu___6 -> false)) in
-                          if uu___4
-                          then
-                            let uu___5 =
-                              FStar_Extraction_ML_UEnv.extend_type_name env
-                                fv in
-                            match uu___5 with
-                            | (mlp, env2) ->
-                                (mlp, (iface_of_type_names [(fv, mlp)]),
-                                  env2)
-                          else
-                            (let uu___6 =
-                               FStar_Extraction_ML_UEnv.extend_tydef env fv
-                                 tyscheme metadata in
-                             match uu___6 with
-                             | (td, mlp, env2) ->
-                                 let uu___7 = iface_of_tydefs [td] in
-                                 (mlp, uu___7, env2)) in
-                        (match uu___3 with
-                         | (mlpath, iface1, env2) ->
-                             let td =
-                               {
-                                 FStar_Extraction_ML_Syntax.tydecl_assumed =
-                                   assumed;
-                                 FStar_Extraction_ML_Syntax.tydecl_name =
-                                   (FStar_Pervasives_Native.snd mlpath);
-                                 FStar_Extraction_ML_Syntax.tydecl_ignored =
-                                   FStar_Pervasives_Native.None;
-                                 FStar_Extraction_ML_Syntax.tydecl_parameters
-                                   = ml_bs;
-                                 FStar_Extraction_ML_Syntax.tydecl_meta =
-                                   metadata;
-                                 FStar_Extraction_ML_Syntax.tydecl_defn =
-                                   (FStar_Pervasives_Native.Some
-                                      (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-                                         body1))
-                               } in
-                             let def2 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   let uu___6 = FStar_Ident.range_of_lid lid in
-                                   FStar_Extraction_ML_Util.mlloc_of_range
-                                     uu___6 in
-                                 FStar_Extraction_ML_Syntax.MLM_Loc uu___5 in
-                               [uu___4;
-                               FStar_Extraction_ML_Syntax.MLM_Ty [td]] in
-                             (env2, iface1, def2))))
-let (extract_let_rec_type :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Syntax_Syntax.term Prims.list ->
-        FStar_Syntax_Syntax.letbinding ->
-          (env_t * iface * FStar_Extraction_ML_Syntax.mlmodule1 Prims.list))
-  =
-  fun env ->
-    fun quals ->
-      fun attrs ->
-        fun lb ->
-          let lbtyp =
-            let uu___ = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-            FStar_TypeChecker_Normalize.normalize
-              [FStar_TypeChecker_Env.Beta;
-              FStar_TypeChecker_Env.AllowUnboundUniverses;
-              FStar_TypeChecker_Env.EraseUniverses;
-              FStar_TypeChecker_Env.UnfoldUntil
-                FStar_Syntax_Syntax.delta_constant;
-              FStar_TypeChecker_Env.ForExtraction] uu___
-              lb.FStar_Syntax_Syntax.lbtyp in
-          let uu___ = FStar_Syntax_Util.arrow_formals lbtyp in
-          match uu___ with
-          | (bs, uu___1) ->
-              let uu___2 = binders_as_mlty_binders env bs in
-              (match uu___2 with
-               | (env1, ml_bs) ->
-                   let fv =
-                     FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-                   let lid =
-                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                   let body = FStar_Extraction_ML_Syntax.MLTY_Top in
-                   let metadata =
-                     let uu___3 = extract_metadata attrs in
-                     let uu___4 =
-                       FStar_Compiler_List.choose flag_of_qual quals in
-                     FStar_Compiler_List.op_At uu___3 uu___4 in
-                   let assumed = false in
-                   let tscheme = (ml_bs, body) in
-                   let uu___3 =
-                     FStar_Extraction_ML_UEnv.extend_tydef env fv tscheme
-                       metadata in
-                   (match uu___3 with
-                    | (tydef, mlp, env2) ->
-                        let td =
-                          {
-                            FStar_Extraction_ML_Syntax.tydecl_assumed =
-                              assumed;
-                            FStar_Extraction_ML_Syntax.tydecl_name =
-                              (FStar_Pervasives_Native.snd mlp);
-                            FStar_Extraction_ML_Syntax.tydecl_ignored =
-                              FStar_Pervasives_Native.None;
-                            FStar_Extraction_ML_Syntax.tydecl_parameters =
-                              ml_bs;
-                            FStar_Extraction_ML_Syntax.tydecl_meta = metadata;
-                            FStar_Extraction_ML_Syntax.tydecl_defn =
-                              (FStar_Pervasives_Native.Some
-                                 (FStar_Extraction_ML_Syntax.MLTD_Abbrev body))
-                          } in
-                        let def =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = FStar_Ident.range_of_lid lid in
-                              FStar_Extraction_ML_Util.mlloc_of_range uu___6 in
-                            FStar_Extraction_ML_Syntax.MLM_Loc uu___5 in
-                          [uu___4; FStar_Extraction_ML_Syntax.MLM_Ty [td]] in
-                        let iface1 = iface_of_tydefs [tydef] in
-                        (env2, iface1, def)))
-let (extract_bundle_iface :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.sigelt -> (env_t * iface))
-  =
-  fun env ->
-    fun se ->
-      let extract_ctor env_iparams ml_tyvars env1 ctor =
-        let mlt =
-          let uu___ =
-            FStar_Extraction_ML_Term.term_as_mlty env_iparams ctor.dtyp in
-          FStar_Extraction_ML_Util.eraseTypeDeep
-            (FStar_Extraction_ML_Util.udelta_unfold env_iparams) uu___ in
-        let tys = (ml_tyvars, mlt) in
-        let fvv =
-          FStar_Syntax_Syntax.lid_as_fv ctor.dname
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___ = FStar_Extraction_ML_UEnv.extend_fv env1 fvv tys false in
-        match uu___ with | (env2, uu___1, b) -> (env2, (fvv, b)) in
-      let extract_one_family env1 ind =
-        let uu___ = binders_as_mlty_binders env1 ind.iparams in
-        match uu___ with
-        | (env_iparams, vars) ->
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater ind.idatas
-                (FStar_Compiler_Util.fold_map (extract_ctor env_iparams vars)
-                   env1) in
-            (match uu___1 with
-             | (env2, ctors) ->
-                 let env3 =
-                   let uu___2 =
-                     FStar_Compiler_Util.find_opt
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | FStar_Syntax_Syntax.RecordType uu___4 -> true
-                          | uu___4 -> false) ind.iquals in
-                   match uu___2 with
-                   | FStar_Pervasives_Native.Some
-                       (FStar_Syntax_Syntax.RecordType (ns, ids)) ->
-                       let g =
-                         FStar_Compiler_List.fold_right
-                           (fun id ->
-                              fun g1 ->
-                                let uu___3 =
-                                  FStar_Extraction_ML_UEnv.extend_record_field_name
-                                    g1 ((ind.iname), id) in
-                                match uu___3 with | (uu___4, g2) -> g2) ids
-                           env2 in
-                       g
-                   | uu___3 -> env2 in
-                 (env3, ctors)) in
-      match ((se.FStar_Syntax_Syntax.sigel),
-              (se.FStar_Syntax_Syntax.sigquals))
-      with
-      | (FStar_Syntax_Syntax.Sig_bundle
-         ({
-            FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-              (l, uu___, t, uu___1, uu___2, uu___3);
-            FStar_Syntax_Syntax.sigrng = uu___4;
-            FStar_Syntax_Syntax.sigquals = uu___5;
-            FStar_Syntax_Syntax.sigmeta = uu___6;
-            FStar_Syntax_Syntax.sigattrs = uu___7;
-            FStar_Syntax_Syntax.sigopts = uu___8;_}::[],
-          uu___9),
-         (FStar_Syntax_Syntax.ExceptionConstructor)::[]) ->
-          let uu___10 = extract_ctor env [] env { dname = l; dtyp = t } in
-          (match uu___10 with
-           | (env1, ctor) -> (env1, (iface_of_bindings [ctor])))
-      | (FStar_Syntax_Syntax.Sig_bundle (ses, uu___), quals) ->
-          let uu___1 =
-            FStar_Syntax_Util.has_attribute se.FStar_Syntax_Syntax.sigattrs
-              FStar_Parser_Const.erasable_attr in
-          if uu___1
-          then (env, empty_iface)
-          else
-            (let uu___3 = bundle_as_inductive_families env ses quals in
-             match uu___3 with
-             | (env1, ifams) ->
-                 let uu___4 =
-                   FStar_Compiler_Util.fold_map extract_one_family env1 ifams in
-                 (match uu___4 with
-                  | (env2, td) ->
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            FStar_Compiler_List.map
-                              (fun x ->
-                                 let uu___8 =
-                                   FStar_Extraction_ML_UEnv.mlpath_of_lident
-                                     env2 x.iname in
-                                 ((x.ifv), uu___8)) ifams in
-                          iface_of_type_names uu___7 in
-                        iface_union uu___6
-                          (iface_of_bindings (FStar_Compiler_List.flatten td)) in
-                      (env2, uu___5)))
-      | uu___ -> failwith "Unexpected signature element"
-let (extract_type_declaration :
-  FStar_Extraction_ML_UEnv.uenv ->
-    Prims.bool ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.qualifier Prims.list ->
-          FStar_Syntax_Syntax.term Prims.list ->
-            FStar_Syntax_Syntax.univ_name Prims.list ->
-              FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-                (env_t * iface * FStar_Extraction_ML_Syntax.mlmodule1
-                  Prims.list))
-  =
-  fun g ->
-    fun is_interface_val ->
-      fun lid ->
-        fun quals ->
-          fun attrs ->
-            fun univs ->
-              fun t ->
-                let uu___ =
-                  let uu___1 =
-                    FStar_Compiler_Effect.op_Bar_Greater quals
-                      (FStar_Compiler_Util.for_some
-                         (fun uu___2 ->
-                            match uu___2 with
-                            | FStar_Syntax_Syntax.Assumption -> true
-                            | uu___3 -> false)) in
-                  Prims.op_Negation uu___1 in
-                if uu___
-                then
-                  let g1 =
-                    FStar_Extraction_ML_UEnv.extend_with_tydef_declaration g
-                      lid in
-                  (g1, empty_iface, [])
-                else
-                  (let uu___2 = FStar_Syntax_Util.arrow_formals t in
-                   match uu___2 with
-                   | (bs, uu___3) ->
-                       let fv =
-                         FStar_Syntax_Syntax.lid_as_fv lid
-                           FStar_Syntax_Syntax.delta_constant
-                           FStar_Pervasives_Native.None in
-                       let lb =
-                         let uu___4 =
-                           FStar_Syntax_Util.abs bs
-                             FStar_Syntax_Syntax.t_unit
-                             FStar_Pervasives_Native.None in
-                         {
-                           FStar_Syntax_Syntax.lbname =
-                             (FStar_Pervasives.Inr fv);
-                           FStar_Syntax_Syntax.lbunivs = univs;
-                           FStar_Syntax_Syntax.lbtyp = t;
-                           FStar_Syntax_Syntax.lbeff =
-                             FStar_Parser_Const.effect_Tot_lid;
-                           FStar_Syntax_Syntax.lbdef = uu___4;
-                           FStar_Syntax_Syntax.lbattrs = attrs;
-                           FStar_Syntax_Syntax.lbpos =
-                             (t.FStar_Syntax_Syntax.pos)
-                         } in
-                       let uu___4 = extract_typ_abbrev g quals attrs lb in
-                       (match uu___4 with
-                        | (g1, iface1, mods) ->
-                            let iface2 =
-                              if is_interface_val
-                              then
-                                let mlp =
-                                  FStar_Extraction_ML_UEnv.mlpath_of_lident
-                                    g1 lid in
-                                let meta = extract_metadata attrs in
-                                {
-                                  iface_module_name =
-                                    (empty_iface.iface_module_name);
-                                  iface_bindings =
-                                    (empty_iface.iface_bindings);
-                                  iface_tydefs =
-                                    [FStar_Pervasives.Inr
-                                       ((FStar_Pervasives_Native.snd mlp),
-                                         meta,
-                                         (FStar_Compiler_List.length bs))];
-                                  iface_type_names =
-                                    (empty_iface.iface_type_names)
-                                }
-                              else iface1 in
-                            (g1, iface2, mods)))
-let (extract_reifiable_effect :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.eff_decl ->
-      (FStar_Extraction_ML_UEnv.uenv * iface *
-        FStar_Extraction_ML_Syntax.mlmodule1 Prims.list))
-  =
-  fun g ->
-    fun ed ->
-      let extend_iface lid mlp exp exp_binding =
-        let fv =
-          FStar_Syntax_Syntax.lid_as_fv lid
-            FStar_Syntax_Syntax.delta_equational FStar_Pervasives_Native.None in
-        let lb =
-          {
-            FStar_Extraction_ML_Syntax.mllb_name =
-              (FStar_Pervasives_Native.snd mlp);
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.None;
-            FStar_Extraction_ML_Syntax.mllb_add_unit = false;
-            FStar_Extraction_ML_Syntax.mllb_def = exp;
-            FStar_Extraction_ML_Syntax.mllb_meta = [];
-            FStar_Extraction_ML_Syntax.print_typ = false
-          } in
-        ((iface_of_bindings [(fv, exp_binding)]),
-          (FStar_Extraction_ML_Syntax.MLM_Let
-             (FStar_Extraction_ML_Syntax.NonRec, [lb]))) in
-      let rec extract_fv tm =
-        (let uu___1 =
-           let uu___2 =
-             let uu___3 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-             FStar_TypeChecker_Env.debug uu___3 in
-           FStar_Compiler_Effect.op_Less_Bar uu___2
-             (FStar_Options.Other "ExtractionReify") in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.term_to_string tm in
-           FStar_Compiler_Util.print1 "extract_fv term: %s\n" uu___2
-         else ());
-        (let uu___1 =
-           let uu___2 = FStar_Syntax_Subst.compress tm in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_uinst (tm1, uu___2) -> extract_fv tm1
-         | FStar_Syntax_Syntax.Tm_fvar fv ->
-             let mlp =
-               FStar_Extraction_ML_UEnv.mlpath_of_lident g
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-             let uu___2 =
-               FStar_Extraction_ML_UEnv.lookup_fv tm.FStar_Syntax_Syntax.pos
-                 g fv in
-             (match uu___2 with
-              | { FStar_Extraction_ML_UEnv.exp_b_name = uu___3;
-                  FStar_Extraction_ML_UEnv.exp_b_expr = uu___4;
-                  FStar_Extraction_ML_UEnv.exp_b_tscheme = tysc;_} ->
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_Extraction_ML_Syntax.with_ty
-                         FStar_Extraction_ML_Syntax.MLTY_Top)
-                      (FStar_Extraction_ML_Syntax.MLE_Name mlp) in
-                  (uu___5, tysc))
-         | uu___2 ->
-             let uu___3 =
-               let uu___4 =
-                 FStar_Compiler_Range.string_of_range
-                   tm.FStar_Syntax_Syntax.pos in
-               let uu___5 = FStar_Syntax_Print.term_to_string tm in
-               FStar_Compiler_Util.format2 "(%s) Not an fv: %s" uu___4 uu___5 in
-             failwith uu___3) in
-      let extract_action g1 a =
-        (let uu___2 =
-           let uu___3 =
-             let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g1 in
-             FStar_TypeChecker_Env.debug uu___4 in
-           FStar_Compiler_Effect.op_Less_Bar uu___3
-             (FStar_Options.Other "ExtractionReify") in
-         if uu___2
-         then
-           let uu___3 =
-             FStar_Syntax_Print.term_to_string
-               a.FStar_Syntax_Syntax.action_typ in
-           let uu___4 =
-             FStar_Syntax_Print.term_to_string
-               a.FStar_Syntax_Syntax.action_defn in
-           FStar_Compiler_Util.print2 "Action type %s and term %s\n" uu___3
-             uu___4
-         else ());
-        (let lbname =
-           let uu___2 =
-             FStar_Syntax_Syntax.new_bv
-               (FStar_Pervasives_Native.Some
-                  ((a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos))
-               FStar_Syntax_Syntax.tun in
-           FStar_Pervasives.Inl uu___2 in
-         let lb =
-           FStar_Syntax_Syntax.mk_lb
-             (lbname, (a.FStar_Syntax_Syntax.action_univs),
-               FStar_Parser_Const.effect_Tot_lid,
-               (a.FStar_Syntax_Syntax.action_typ),
-               (a.FStar_Syntax_Syntax.action_defn), [],
-               ((a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos)) in
-         let lbs = (false, [lb]) in
-         let action_lb =
-           FStar_Syntax_Syntax.mk
-             (FStar_Syntax_Syntax.Tm_let
-                (lbs, FStar_Syntax_Util.exp_false_bool))
-             (a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-         let uu___2 = FStar_Extraction_ML_Term.term_as_mlexpr g1 action_lb in
-         match uu___2 with
-         | (a_let, uu___3, ty) ->
-             let uu___4 =
-               match a_let.FStar_Extraction_ML_Syntax.expr with
-               | FStar_Extraction_ML_Syntax.MLE_Let
-                   ((uu___5, mllb::[]), uu___6) ->
-                   (match mllb.FStar_Extraction_ML_Syntax.mllb_tysc with
-                    | FStar_Pervasives_Native.Some tysc ->
-                        ((mllb.FStar_Extraction_ML_Syntax.mllb_def), tysc)
-                    | FStar_Pervasives_Native.None ->
-                        failwith "No type scheme")
-               | uu___5 -> failwith "Impossible" in
-             (match uu___4 with
-              | (exp, tysc) ->
-                  let uu___5 =
-                    FStar_Extraction_ML_UEnv.extend_with_action_name g1 ed a
-                      tysc in
-                  (match uu___5 with
-                   | (a_nm, a_lid, exp_b, g2) ->
-                       ((let uu___7 =
-                           let uu___8 =
-                             let uu___9 =
-                               FStar_Extraction_ML_UEnv.tcenv_of_uenv g2 in
-                             FStar_TypeChecker_Env.debug uu___9 in
-                           FStar_Compiler_Effect.op_Less_Bar uu___8
-                             (FStar_Options.Other "ExtractionReify") in
-                         if uu___7
-                         then
-                           let uu___8 =
-                             FStar_Extraction_ML_Code.string_of_mlexpr a_nm
-                               a_let in
-                           FStar_Compiler_Util.print1
-                             "Extracted action term: %s\n" uu___8
-                         else ());
-                        (let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               FStar_Extraction_ML_UEnv.tcenv_of_uenv g2 in
-                             FStar_TypeChecker_Env.debug uu___10 in
-                           FStar_Compiler_Effect.op_Less_Bar uu___9
-                             (FStar_Options.Other "ExtractionReify") in
-                         if uu___8
-                         then
-                           ((let uu___10 =
-                               FStar_Extraction_ML_Code.string_of_mlty a_nm
-                                 (FStar_Pervasives_Native.snd tysc) in
-                             FStar_Compiler_Util.print1
-                               "Extracted action type: %s\n" uu___10);
-                            FStar_Compiler_List.iter
-                              (fun x ->
-                                 FStar_Compiler_Util.print1
-                                   "and binders: %s\n" x)
-                              (FStar_Pervasives_Native.fst tysc))
-                         else ());
-                        (let uu___8 = extend_iface a_lid a_nm exp exp_b in
-                         match uu___8 with
-                         | (iface1, impl) -> (g2, (iface1, impl))))))) in
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_Effect.op_Bar_Greater ed
-                  FStar_Syntax_Util.get_return_repr in
-              FStar_Compiler_Effect.op_Bar_Greater uu___4
-                FStar_Compiler_Util.must in
-            FStar_Compiler_Effect.op_Bar_Greater uu___3
-              FStar_Pervasives_Native.snd in
-          extract_fv uu___2 in
-        match uu___1 with
-        | (return_tm, ty_sc) ->
-            let uu___2 =
-              FStar_Extraction_ML_UEnv.extend_with_monad_op_name g ed
-                "return" ty_sc in
-            (match uu___2 with
-             | (return_nm, return_lid, return_b, g1) ->
-                 let uu___3 =
-                   extend_iface return_lid return_nm return_tm return_b in
-                 (match uu___3 with | (iface1, impl) -> (g1, iface1, impl))) in
-      match uu___ with
-      | (g1, return_iface, return_decl) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Bar_Greater ed
-                      FStar_Syntax_Util.get_bind_repr in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___5
-                    FStar_Compiler_Util.must in
-                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                  FStar_Pervasives_Native.snd in
-              extract_fv uu___3 in
-            match uu___2 with
-            | (bind_tm, ty_sc) ->
-                let uu___3 =
-                  FStar_Extraction_ML_UEnv.extend_with_monad_op_name g1 ed
-                    "bind" ty_sc in
-                (match uu___3 with
-                 | (bind_nm, bind_lid, bind_b, g2) ->
-                     let uu___4 =
-                       extend_iface bind_lid bind_nm bind_tm bind_b in
-                     (match uu___4 with
-                      | (iface1, impl) -> (g2, iface1, impl))) in
-          (match uu___1 with
-           | (g2, bind_iface, bind_decl) ->
-               let uu___2 =
-                 FStar_Compiler_Util.fold_map extract_action g2
-                   ed.FStar_Syntax_Syntax.actions in
-               (match uu___2 with
-                | (g3, actions) ->
-                    let uu___3 = FStar_Compiler_List.unzip actions in
-                    (match uu___3 with
-                     | (actions_iface, actions1) ->
-                         let uu___4 =
-                           iface_union_l (return_iface :: bind_iface ::
-                             actions_iface) in
-                         (g3, uu___4, (return_decl :: bind_decl :: actions1)))))
-let (should_split_let_rec_types_and_terms :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.letbinding Prims.list -> Prims.bool)
-  =
-  fun env ->
-    fun lbs ->
-      let rec is_homogeneous out lbs1 =
-        match lbs1 with
-        | [] -> true
-        | lb::lbs_tail ->
-            let is_type =
-              FStar_Extraction_ML_Term.is_arity env
-                lb.FStar_Syntax_Syntax.lbtyp in
-            (match out with
-             | FStar_Pervasives_Native.None ->
-                 is_homogeneous (FStar_Pervasives_Native.Some is_type)
-                   lbs_tail
-             | FStar_Pervasives_Native.Some b when b = is_type ->
-                 is_homogeneous (FStar_Pervasives_Native.Some is_type)
-                   lbs_tail
-             | uu___ -> false) in
-      let uu___ = is_homogeneous FStar_Pervasives_Native.None lbs in
-      Prims.op_Negation uu___
-let (split_let_rec_types_and_terms :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Syntax_Syntax.letbinding Prims.list ->
-        FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun se ->
-    fun env ->
-      fun lbs ->
-        let rec aux out mutuals lbs1 =
-          match lbs1 with
-          | [] -> (out, mutuals)
-          | lb::lbs_tail ->
-              let uu___ = aux out mutuals lbs_tail in
-              (match uu___ with
-               | (out1, mutuals1) ->
-                   let uu___1 =
-                     let uu___2 =
-                       FStar_Extraction_ML_Term.is_arity env
-                         lb.FStar_Syntax_Syntax.lbtyp in
-                     Prims.op_Negation uu___2 in
-                   if uu___1
-                   then (out1, (lb :: mutuals1))
-                   else
-                     (let uu___3 =
-                        FStar_Syntax_Util.abs_formals_maybe_unascribe_body
-                          true lb.FStar_Syntax_Syntax.lbdef in
-                      match uu___3 with
-                      | (formals, body, rc_opt) ->
-                          let body1 =
-                            FStar_Syntax_Syntax.tconst
-                              FStar_Parser_Const.c_true_lid in
-                          let lbdef =
-                            FStar_Syntax_Util.abs formals body1
-                              FStar_Pervasives_Native.None in
-                          let lb1 =
-                            {
-                              FStar_Syntax_Syntax.lbname =
-                                (lb.FStar_Syntax_Syntax.lbname);
-                              FStar_Syntax_Syntax.lbunivs =
-                                (lb.FStar_Syntax_Syntax.lbunivs);
-                              FStar_Syntax_Syntax.lbtyp =
-                                (lb.FStar_Syntax_Syntax.lbtyp);
-                              FStar_Syntax_Syntax.lbeff =
-                                (lb.FStar_Syntax_Syntax.lbeff);
-                              FStar_Syntax_Syntax.lbdef = lbdef;
-                              FStar_Syntax_Syntax.lbattrs =
-                                (lb.FStar_Syntax_Syntax.lbattrs);
-                              FStar_Syntax_Syntax.lbpos =
-                                (lb.FStar_Syntax_Syntax.lbpos)
-                            } in
-                          let se1 =
-                            {
-                              FStar_Syntax_Syntax.sigel =
-                                (FStar_Syntax_Syntax.Sig_let
-                                   ((false, [lb1]), []));
-                              FStar_Syntax_Syntax.sigrng =
-                                (se.FStar_Syntax_Syntax.sigrng);
-                              FStar_Syntax_Syntax.sigquals =
-                                (se.FStar_Syntax_Syntax.sigquals);
-                              FStar_Syntax_Syntax.sigmeta =
-                                (se.FStar_Syntax_Syntax.sigmeta);
-                              FStar_Syntax_Syntax.sigattrs =
-                                (se.FStar_Syntax_Syntax.sigattrs);
-                              FStar_Syntax_Syntax.sigopts =
-                                (se.FStar_Syntax_Syntax.sigopts)
-                            } in
-                          ((se1 :: out1), mutuals1))) in
-        let uu___ = aux [] [] lbs in
-        match uu___ with
-        | (sigs, lbs1) ->
-            let lb =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    Obj.magic
-                      (FStar_Compiler_List.map
-                         (fun lb1 -> lb1.FStar_Syntax_Syntax.lbname) lbs1) in
-                  ((true, lbs1), uu___3) in
-                FStar_Syntax_Syntax.Sig_let uu___2 in
-              {
-                FStar_Syntax_Syntax.sigel = uu___1;
-                FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-                FStar_Syntax_Syntax.sigquals =
-                  (se.FStar_Syntax_Syntax.sigquals);
-                FStar_Syntax_Syntax.sigmeta =
-                  (se.FStar_Syntax_Syntax.sigmeta);
-                FStar_Syntax_Syntax.sigattrs =
-                  (se.FStar_Syntax_Syntax.sigattrs);
-                FStar_Syntax_Syntax.sigopts =
-                  (se.FStar_Syntax_Syntax.sigopts)
-              } in
-            let sigs1 = FStar_Compiler_List.op_At sigs [lb] in sigs1
-let (extract_let_rec_types :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Syntax_Syntax.letbinding Prims.list ->
-        (FStar_Extraction_ML_UEnv.uenv * iface *
-          FStar_Extraction_ML_Syntax.mlmodule1 Prims.list))
-  =
-  fun se ->
-    fun env ->
-      fun lbs ->
-        let uu___ =
-          FStar_Compiler_Util.for_some
-            (fun lb ->
-               let uu___1 =
-                 FStar_Extraction_ML_Term.is_arity env
-                   lb.FStar_Syntax_Syntax.lbtyp in
-               Prims.op_Negation uu___1) lbs in
-        if uu___
-        then failwith "Impossible: mixed mutual types and terms"
-        else
-          (let uu___2 =
-             FStar_Compiler_List.fold_left
-               (fun uu___3 ->
-                  fun lb ->
-                    match uu___3 with
-                    | (env1, iface_opt, impls) ->
-                        let uu___4 =
-                          extract_let_rec_type env1
-                            se.FStar_Syntax_Syntax.sigquals
-                            se.FStar_Syntax_Syntax.sigattrs lb in
-                        (match uu___4 with
-                         | (env2, iface1, impl) ->
-                             let iface_opt1 =
-                               match iface_opt with
-                               | FStar_Pervasives_Native.None ->
-                                   FStar_Pervasives_Native.Some iface1
-                               | FStar_Pervasives_Native.Some iface' ->
-                                   let uu___5 = iface_union iface' iface1 in
-                                   FStar_Pervasives_Native.Some uu___5 in
-                             (env2, iface_opt1, (impl :: impls))))
-               (env, FStar_Pervasives_Native.None, []) lbs in
-           match uu___2 with
-           | (env1, iface_opt, impls) ->
-               let uu___3 = FStar_Compiler_Option.get iface_opt in
-               let uu___4 =
-                 FStar_Compiler_Effect.op_Bar_Greater
-                   (FStar_Compiler_List.rev impls)
-                   FStar_Compiler_List.flatten in
-               (env1, uu___3, uu___4))
-let (get_noextract_to :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Options.codegen_t FStar_Pervasives_Native.option -> Prims.bool)
-  =
-  fun se ->
-    fun backend ->
-      FStar_Compiler_Util.for_some
-        (fun uu___ ->
-           let uu___1 = FStar_Syntax_Util.head_and_args uu___ in
-           match uu___1 with
-           | (hd, args) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Subst.compress hd in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 (uu___3, args) in
-               (match uu___2 with
-                | (FStar_Syntax_Syntax.Tm_fvar fv, (a, uu___3)::[]) when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.noextract_to_attr
-                    ->
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_Syntax_Embeddings.unembed
-                          FStar_Syntax_Embeddings.e_string a in
-                      uu___5 false FStar_Syntax_Embeddings.id_norm_cb in
-                    (match uu___4 with
-                     | FStar_Pervasives_Native.Some s ->
-                         (FStar_Compiler_Option.isSome backend) &&
-                           (let uu___5 = FStar_Options.parse_codegen s in
-                            uu___5 = backend)
-                     | FStar_Pervasives_Native.None -> false)
-                | uu___3 -> false)) se.FStar_Syntax_Syntax.sigattrs
-let (sigelt_has_noextract : FStar_Syntax_Syntax.sigelt -> Prims.bool) =
-  fun se ->
-    let has_noextract_qualifier =
-      FStar_Compiler_List.contains FStar_Syntax_Syntax.NoExtract
-        se.FStar_Syntax_Syntax.sigquals in
-    let has_noextract_attribute =
-      let uu___ = FStar_Options.codegen () in get_noextract_to se uu___ in
-    let uu___ = FStar_Options.codegen () in
-    match uu___ with
-    | FStar_Pervasives_Native.Some (FStar_Options.Krml) ->
-        has_noextract_qualifier && has_noextract_attribute
-    | uu___1 -> has_noextract_qualifier || has_noextract_attribute
-let (karamel_fixup_qual :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt) =
-  fun se ->
-    let uu___ =
-      ((let uu___1 = FStar_Options.codegen () in
-        uu___1 = (FStar_Pervasives_Native.Some FStar_Options.Krml)) &&
-         (get_noextract_to se
-            (FStar_Pervasives_Native.Some FStar_Options.Krml)))
-        &&
-        (Prims.op_Negation
-           (FStar_Compiler_List.contains FStar_Syntax_Syntax.NoExtract
-              se.FStar_Syntax_Syntax.sigquals)) in
-    if uu___
-    then
-      {
-        FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-        FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-        FStar_Syntax_Syntax.sigquals = (FStar_Syntax_Syntax.NoExtract ::
-          (se.FStar_Syntax_Syntax.sigquals));
-        FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-        FStar_Syntax_Syntax.sigattrs = (se.FStar_Syntax_Syntax.sigattrs);
-        FStar_Syntax_Syntax.sigopts = (se.FStar_Syntax_Syntax.sigopts)
-      }
-    else se
-let (mark_sigelt_erased :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Extraction_ML_UEnv.uenv -> FStar_Extraction_ML_UEnv.uenv)
-  =
-  fun se ->
-    fun g ->
-      FStar_Extraction_ML_UEnv.debug g
-        (fun u ->
-           let uu___1 = FStar_Syntax_Print.sigelt_to_string_short se in
-           FStar_Compiler_Util.print1 ">>>> NOT extracting %s \n" uu___1);
-      FStar_Compiler_List.fold_right
-        (fun lid ->
-           fun g1 ->
-             let uu___1 =
-               FStar_Syntax_Syntax.lid_as_fv lid
-                 FStar_Syntax_Syntax.delta_constant
-                 FStar_Pervasives_Native.None in
-             FStar_Extraction_ML_UEnv.extend_erased_fv g1 uu___1)
-        (FStar_Syntax_Util.lids_of_sigelt se) g
-let rec (extract_sigelt_iface :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.sigelt -> (FStar_Extraction_ML_UEnv.uenv * iface))
-  =
-  fun g ->
-    fun se ->
-      let uu___ = sigelt_has_noextract se in
-      if uu___
-      then let g1 = mark_sigelt_erased se g in (g1, empty_iface)
-      else
-        (let se1 = karamel_fixup_qual se in
-         match se1.FStar_Syntax_Syntax.sigel with
-         | FStar_Syntax_Syntax.Sig_bundle uu___2 ->
-             extract_bundle_iface g se1
-         | FStar_Syntax_Syntax.Sig_inductive_typ uu___2 ->
-             extract_bundle_iface g se1
-         | FStar_Syntax_Syntax.Sig_datacon uu___2 ->
-             extract_bundle_iface g se1
-         | FStar_Syntax_Syntax.Sig_declare_typ (lid, univs, t) when
-             FStar_Extraction_ML_Term.is_arity g t ->
-             let uu___2 =
-               extract_type_declaration g true lid
-                 se1.FStar_Syntax_Syntax.sigquals
-                 se1.FStar_Syntax_Syntax.sigattrs univs t in
-             (match uu___2 with | (env, iface1, uu___3) -> (env, iface1))
-         | FStar_Syntax_Syntax.Sig_let ((false, lb::[]), uu___2) when
-             FStar_Extraction_ML_Term.is_arity g lb.FStar_Syntax_Syntax.lbtyp
-             ->
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater
-                 se1.FStar_Syntax_Syntax.sigquals
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | FStar_Syntax_Syntax.Projector uu___5 -> true
-                       | uu___5 -> false)) in
-             if uu___3
-             then (g, empty_iface)
-             else
-               (let uu___5 =
-                  extract_typ_abbrev g se1.FStar_Syntax_Syntax.sigquals
-                    se1.FStar_Syntax_Syntax.sigattrs lb in
-                match uu___5 with | (env, iface1, uu___6) -> (env, iface1))
-         | FStar_Syntax_Syntax.Sig_let ((true, lbs), uu___2) when
-             should_split_let_rec_types_and_terms g lbs ->
-             let ses = split_let_rec_types_and_terms se1 g lbs in
-             let iface1 =
-               let uu___3 = FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-               {
-                 iface_module_name = uu___3;
-                 iface_bindings = (empty_iface.iface_bindings);
-                 iface_tydefs = (empty_iface.iface_tydefs);
-                 iface_type_names = (empty_iface.iface_type_names)
-               } in
-             FStar_Compiler_List.fold_left
-               (fun uu___3 ->
-                  fun se2 ->
-                    match uu___3 with
-                    | (g1, out) ->
-                        let uu___4 = extract_sigelt_iface g1 se2 in
-                        (match uu___4 with
-                         | (g2, mls) ->
-                             let uu___5 = iface_union out mls in (g2, uu___5)))
-               (g, iface1) ses
-         | FStar_Syntax_Syntax.Sig_let ((true, lbs), uu___2) when
-             FStar_Compiler_Util.for_some
-               (fun lb ->
-                  FStar_Extraction_ML_Term.is_arity g
-                    lb.FStar_Syntax_Syntax.lbtyp) lbs
-             ->
-             let uu___3 = extract_let_rec_types se1 g lbs in
-             (match uu___3 with | (env, iface1, uu___4) -> (env, iface1))
-         | FStar_Syntax_Syntax.Sig_declare_typ (lid, _univs, t) ->
-             let quals = se1.FStar_Syntax_Syntax.sigquals in
-             let uu___2 =
-               (FStar_Compiler_Effect.op_Bar_Greater quals
-                  (FStar_Compiler_List.contains
-                     FStar_Syntax_Syntax.Assumption))
-                 &&
-                 (let uu___3 =
-                    let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                    FStar_TypeChecker_Util.must_erase_for_extraction uu___4 t in
-                  Prims.op_Negation uu___3) in
-             if uu___2
-             then
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = let uu___6 = always_fail lid t in [uu___6] in
-                   (false, uu___5) in
-                 FStar_Extraction_ML_Term.extract_lb_iface g uu___4 in
-               (match uu___3 with
-                | (g1, bindings) -> (g1, (iface_of_bindings bindings)))
-             else (g, empty_iface)
-         | FStar_Syntax_Syntax.Sig_let (lbs, uu___2) ->
-             let uu___3 = FStar_Extraction_ML_Term.extract_lb_iface g lbs in
-             (match uu___3 with
-              | (g1, bindings) -> (g1, (iface_of_bindings bindings)))
-         | FStar_Syntax_Syntax.Sig_assume uu___2 -> (g, empty_iface)
-         | FStar_Syntax_Syntax.Sig_sub_effect uu___2 -> (g, empty_iface)
-         | FStar_Syntax_Syntax.Sig_effect_abbrev uu___2 -> (g, empty_iface)
-         | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___2 ->
-             (g, empty_iface)
-         | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___2 ->
-             (g, empty_iface)
-         | FStar_Syntax_Syntax.Sig_pragma p ->
-             (FStar_Syntax_Util.process_pragma p
-                se1.FStar_Syntax_Syntax.sigrng;
-              (g, empty_iface))
-         | FStar_Syntax_Syntax.Sig_splice uu___2 ->
-             failwith "impossible: trying to extract splice"
-         | FStar_Syntax_Syntax.Sig_fail uu___2 ->
-             failwith "impossible: trying to extract Sig_fail"
-         | FStar_Syntax_Syntax.Sig_new_effect ed ->
-             let uu___2 =
-               (let uu___3 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                FStar_TypeChecker_Env.is_reifiable_effect uu___3
-                  ed.FStar_Syntax_Syntax.mname)
-                 &&
-                 (FStar_Compiler_List.isEmpty ed.FStar_Syntax_Syntax.binders) in
-             if uu___2
-             then
-               let uu___3 = extract_reifiable_effect g ed in
-               (match uu___3 with | (env, iface1, uu___4) -> (env, iface1))
-             else (g, empty_iface))
-let (extract_iface' :
-  env_t ->
-    FStar_Syntax_Syntax.modul -> (FStar_Extraction_ML_UEnv.uenv * iface))
-  =
-  fun g ->
-    fun modul ->
-      let uu___ = FStar_Options.interactive () in
-      if uu___
-      then (g, empty_iface)
-      else
-        (let uu___2 = FStar_Options.restore_cmd_line_options true in
-         let decls = modul.FStar_Syntax_Syntax.declarations in
-         let iface1 =
-           let uu___3 = FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-           {
-             iface_module_name = uu___3;
-             iface_bindings = (empty_iface.iface_bindings);
-             iface_tydefs = (empty_iface.iface_tydefs);
-             iface_type_names = (empty_iface.iface_type_names)
-           } in
-         let res =
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun se ->
-                  match uu___3 with
-                  | (g1, iface2) ->
-                      let uu___4 = extract_sigelt_iface g1 se in
-                      (match uu___4 with
-                       | (g2, iface') ->
-                           let uu___5 = iface_union iface2 iface' in
-                           (g2, uu___5))) (g, iface1) decls in
-         (let uu___4 = FStar_Options.restore_cmd_line_options true in
-          FStar_Compiler_Effect.op_Less_Bar (fun uu___5 -> ()) uu___4);
-         res)
-let (extract_iface :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.modul -> (FStar_Extraction_ML_UEnv.uenv * iface))
-  =
-  fun g ->
-    fun modul ->
-      let uu___ =
-        FStar_Syntax_Unionfind.with_uf_enabled
-          (fun uu___1 ->
-             let uu___2 = FStar_Options.debug_any () in
-             if uu___2
-             then
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-                 FStar_Compiler_Util.format1 "Extracted interface of %s"
-                   uu___4 in
-               FStar_Compiler_Util.measure_execution_time uu___3
-                 (fun uu___4 -> extract_iface' g modul)
-             else extract_iface' g modul) in
-      match uu___ with
-      | (g1, iface1) ->
-          let uu___1 =
-            FStar_Extraction_ML_UEnv.with_typars_env g1
-              (fun e ->
-                 let iface_tydefs =
-                   FStar_Compiler_List.map
-                     (fun uu___2 ->
-                        match uu___2 with
-                        | FStar_Pervasives.Inl td ->
-                            let uu___3 =
-                              let uu___4 =
-                                FStar_Extraction_ML_UEnv.tydef_mlpath td in
-                              FStar_Pervasives_Native.snd uu___4 in
-                            let uu___4 =
-                              FStar_Extraction_ML_UEnv.tydef_meta td in
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Extraction_ML_UEnv.tydef_def td in
-                              FStar_Pervasives.Inl uu___6 in
-                            (uu___3, uu___4, uu___5)
-                        | FStar_Pervasives.Inr (p, m, n) ->
-                            (p, m, (FStar_Pervasives.Inr n)))
-                     iface1.iface_tydefs in
-                 let uu___2 =
-                   FStar_Extraction_ML_UEnv.extend_with_module_name g1
-                     modul.FStar_Syntax_Syntax.name in
-                 match uu___2 with
-                 | (module_name, uu___3) ->
-                     let e1 =
-                       FStar_Extraction_ML_RemoveUnusedParameters.set_current_module
-                         e module_name in
-                     FStar_Extraction_ML_RemoveUnusedParameters.elim_tydefs
-                       e1 iface_tydefs) in
-          (match uu___1 with
-           | (g2, uu___2) ->
-               let uu___3 = FStar_Extraction_ML_UEnv.exit_module g2 in
-               (uu___3, iface1))
-let (extract_bundle :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_Extraction_ML_UEnv.uenv * FStar_Extraction_ML_Syntax.mlmodule1
-        Prims.list))
-  =
-  fun env ->
-    fun se ->
-      let extract_ctor env_iparams ml_tyvars env1 ctor =
-        let mlt =
-          let uu___ =
-            FStar_Extraction_ML_Term.term_as_mlty env_iparams ctor.dtyp in
-          FStar_Extraction_ML_Util.eraseTypeDeep
-            (FStar_Extraction_ML_Util.udelta_unfold env_iparams) uu___ in
-        let steps =
-          [FStar_TypeChecker_Env.Inlining;
-          FStar_TypeChecker_Env.UnfoldUntil
-            FStar_Syntax_Syntax.delta_constant;
-          FStar_TypeChecker_Env.EraseUniverses;
-          FStar_TypeChecker_Env.AllowUnboundUniverses;
-          FStar_TypeChecker_Env.ForExtraction] in
-        let names =
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  FStar_Extraction_ML_UEnv.tcenv_of_uenv env_iparams in
-                FStar_TypeChecker_Normalize.normalize steps uu___3 ctor.dtyp in
-              FStar_Syntax_Subst.compress uu___2 in
-            uu___1.FStar_Syntax_Syntax.n in
-          match uu___ with
-          | FStar_Syntax_Syntax.Tm_arrow (bs, uu___1) ->
-              FStar_Compiler_List.map
-                (fun uu___2 ->
-                   match uu___2 with
-                   | {
-                       FStar_Syntax_Syntax.binder_bv =
-                         { FStar_Syntax_Syntax.ppname = ppname;
-                           FStar_Syntax_Syntax.index = uu___3;
-                           FStar_Syntax_Syntax.sort = uu___4;_};
-                       FStar_Syntax_Syntax.binder_qual = uu___5;
-                       FStar_Syntax_Syntax.binder_attrs = uu___6;_} ->
-                       FStar_Ident.string_of_id ppname) bs
-          | uu___1 -> [] in
-        let tys = (ml_tyvars, mlt) in
-        let fvv =
-          FStar_Syntax_Syntax.lid_as_fv ctor.dname
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___ = FStar_Extraction_ML_UEnv.extend_fv env1 fvv tys false in
-        match uu___ with
-        | (env2, mls, uu___1) ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Extraction_ML_Util.argTypes mlt in
-                FStar_Compiler_List.zip names uu___4 in
-              (mls, uu___3) in
-            (env2, uu___2) in
-      let extract_one_family env1 ind =
-        let uu___ = binders_as_mlty_binders env1 ind.iparams in
-        match uu___ with
-        | (env_iparams, vars) ->
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater ind.idatas
-                (FStar_Compiler_Util.fold_map (extract_ctor env_iparams vars)
-                   env1) in
-            (match uu___1 with
-             | (env2, ctors) ->
-                 let uu___2 = FStar_Syntax_Util.arrow_formals ind.ityp in
-                 (match uu___2 with
-                  | (indices, uu___3) ->
-                      let ml_params =
-                        let uu___4 =
-                          FStar_Compiler_Effect.op_Bar_Greater indices
-                            (FStar_Compiler_List.mapi
-                               (fun i ->
-                                  fun uu___5 ->
-                                    let uu___6 =
-                                      FStar_Compiler_Util.string_of_int i in
-                                    Prims.op_Hat "'dummyV" uu___6)) in
-                        FStar_Compiler_List.append vars uu___4 in
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_Compiler_Util.find_opt
-                            (fun uu___6 ->
-                               match uu___6 with
-                               | FStar_Syntax_Syntax.RecordType uu___7 ->
-                                   true
-                               | uu___7 -> false) ind.iquals in
-                        match uu___5 with
-                        | FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.RecordType (ns, ids)) ->
-                            let uu___6 = FStar_Compiler_List.hd ctors in
-                            (match uu___6 with
-                             | (uu___7, c_ty) ->
-                                 let uu___9 =
-                                   FStar_Compiler_List.fold_right2
-                                     (fun id ->
-                                        fun uu___10 ->
-                                          fun uu___11 ->
-                                            match (uu___10, uu___11) with
-                                            | ((uu___12, ty), (fields, g)) ->
-                                                let uu___13 =
-                                                  FStar_Extraction_ML_UEnv.extend_record_field_name
-                                                    g ((ind.iname), id) in
-                                                (match uu___13 with
-                                                 | (mlid, g1) ->
-                                                     (((mlid, ty) :: fields),
-                                                       g1))) ids c_ty
-                                     ([], env2) in
-                                 (match uu___9 with
-                                  | (fields, g) ->
-                                      ((FStar_Pervasives_Native.Some
-                                          (FStar_Extraction_ML_Syntax.MLTD_Record
-                                             fields)), g)))
-                        | uu___6 when
-                            (FStar_Compiler_List.length ctors) =
-                              Prims.int_zero
-                            -> (FStar_Pervasives_Native.None, env2)
-                        | uu___6 ->
-                            ((FStar_Pervasives_Native.Some
-                                (FStar_Extraction_ML_Syntax.MLTD_DType ctors)),
-                              env2) in
-                      (match uu___4 with
-                       | (tbody, env3) ->
-                           let td =
-                             let uu___5 =
-                               let uu___6 =
-                                 FStar_Extraction_ML_UEnv.mlpath_of_lident
-                                   env3 ind.iname in
-                               FStar_Pervasives_Native.snd uu___6 in
-                             {
-                               FStar_Extraction_ML_Syntax.tydecl_assumed =
-                                 false;
-                               FStar_Extraction_ML_Syntax.tydecl_name =
-                                 uu___5;
-                               FStar_Extraction_ML_Syntax.tydecl_ignored =
-                                 FStar_Pervasives_Native.None;
-                               FStar_Extraction_ML_Syntax.tydecl_parameters =
-                                 ml_params;
-                               FStar_Extraction_ML_Syntax.tydecl_meta =
-                                 (ind.imetadata);
-                               FStar_Extraction_ML_Syntax.tydecl_defn = tbody
-                             } in
-                           (env3, td)))) in
-      match ((se.FStar_Syntax_Syntax.sigel),
-              (se.FStar_Syntax_Syntax.sigquals))
-      with
-      | (FStar_Syntax_Syntax.Sig_bundle
-         ({
-            FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-              (l, uu___, t, uu___1, uu___2, uu___3);
-            FStar_Syntax_Syntax.sigrng = uu___4;
-            FStar_Syntax_Syntax.sigquals = uu___5;
-            FStar_Syntax_Syntax.sigmeta = uu___6;
-            FStar_Syntax_Syntax.sigattrs = uu___7;
-            FStar_Syntax_Syntax.sigopts = uu___8;_}::[],
-          uu___9),
-         (FStar_Syntax_Syntax.ExceptionConstructor)::[]) ->
-          let uu___10 = extract_ctor env [] env { dname = l; dtyp = t } in
-          (match uu___10 with
-           | (env1, ctor) ->
-               (env1, [FStar_Extraction_ML_Syntax.MLM_Exn ctor]))
-      | (FStar_Syntax_Syntax.Sig_bundle (ses, uu___), quals) ->
-          let uu___1 =
-            FStar_Syntax_Util.has_attribute se.FStar_Syntax_Syntax.sigattrs
-              FStar_Parser_Const.erasable_attr in
-          if uu___1
-          then (env, [])
-          else
-            (let uu___3 = bundle_as_inductive_families env ses quals in
-             match uu___3 with
-             | (env1, ifams) ->
-                 let uu___4 =
-                   FStar_Compiler_Util.fold_map extract_one_family env1 ifams in
-                 (match uu___4 with
-                  | (env2, td) ->
-                      (env2, [FStar_Extraction_ML_Syntax.MLM_Ty td])))
-      | uu___ -> failwith "Unexpected signature element"
-let (maybe_register_plugin :
-  env_t ->
-    FStar_Syntax_Syntax.sigelt ->
-      FStar_Extraction_ML_Syntax.mlmodule1 Prims.list)
-  =
-  fun g ->
-    fun se ->
-      let w =
-        FStar_Extraction_ML_Syntax.with_ty
-          FStar_Extraction_ML_Syntax.MLTY_Top in
-      let plugin_with_arity attrs =
-        FStar_Compiler_Util.find_map attrs
-          (fun t ->
-             let uu___ = FStar_Syntax_Util.head_and_args t in
-             match uu___ with
-             | (head, args) ->
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Syntax_Util.is_fvar FStar_Parser_Const.plugin_attr
-                       head in
-                   Prims.op_Negation uu___2 in
-                 if uu___1
-                 then FStar_Pervasives_Native.None
-                 else
-                   (match args with
-                    | ({
-                         FStar_Syntax_Syntax.n =
-                           FStar_Syntax_Syntax.Tm_constant
-                           (FStar_Const.Const_int (s, uu___3));
-                         FStar_Syntax_Syntax.pos = uu___4;
-                         FStar_Syntax_Syntax.vars = uu___5;
-                         FStar_Syntax_Syntax.hash_code = uu___6;_},
-                       uu___7)::[] ->
-                        let uu___8 =
-                          let uu___9 = FStar_Compiler_Util.int_of_string s in
-                          FStar_Pervasives_Native.Some uu___9 in
-                        FStar_Pervasives_Native.Some uu___8
-                    | uu___3 ->
-                        FStar_Pervasives_Native.Some
-                          FStar_Pervasives_Native.None)) in
-      let uu___ =
-        let uu___1 = FStar_Options.codegen () in
-        uu___1 <> (FStar_Pervasives_Native.Some FStar_Options.Plugin) in
-      if uu___
-      then []
-      else
-        (let uu___2 = plugin_with_arity se.FStar_Syntax_Syntax.sigattrs in
-         match uu___2 with
-         | FStar_Pervasives_Native.None -> []
-         | FStar_Pervasives_Native.Some arity_opt ->
-             (match se.FStar_Syntax_Syntax.sigel with
-              | FStar_Syntax_Syntax.Sig_let (lbs, lids) ->
-                  let mk_registration lb =
-                    let fv =
-                      FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-                    let fv_lid =
-                      (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                    let fv_t = lb.FStar_Syntax_Syntax.lbtyp in
-                    let ml_name_str =
-                      let uu___3 =
-                        let uu___4 = FStar_Ident.string_of_lid fv_lid in
-                        FStar_Extraction_ML_Syntax.MLC_String uu___4 in
-                      FStar_Extraction_ML_Syntax.MLE_Const uu___3 in
-                    let uu___3 =
-                      FStar_Extraction_ML_Util.interpret_plugin_as_term_fun g
-                        fv fv_t arity_opt ml_name_str in
-                    match uu___3 with
-                    | FStar_Pervasives_Native.Some
-                        (interp, nbe_interp, arity, plugin) ->
-                        let uu___4 =
-                          if plugin
-                          then
-                            ((["FStar_Tactics_Native"], "register_plugin"),
-                              [interp; nbe_interp])
-                          else
-                            ((["FStar_Tactics_Native"], "register_tactic"),
-                              [interp]) in
-                        (match uu___4 with
-                         | (register, args) ->
-                             let h =
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_Extraction_ML_Syntax.with_ty
-                                    FStar_Extraction_ML_Syntax.MLTY_Top)
-                                 (FStar_Extraction_ML_Syntax.MLE_Name
-                                    register) in
-                             let arity1 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Compiler_Util.string_of_int arity in
-                                   (uu___7, FStar_Pervasives_Native.None) in
-                                 FStar_Extraction_ML_Syntax.MLC_Int uu___6 in
-                               FStar_Extraction_ML_Syntax.MLE_Const uu___5 in
-                             let app =
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_Extraction_ML_Syntax.with_ty
-                                    FStar_Extraction_ML_Syntax.MLTY_Top)
-                                 (FStar_Extraction_ML_Syntax.MLE_App
-                                    (h,
-                                      (FStar_Compiler_List.op_At
-                                         [w ml_name_str; w arity1] args))) in
-                             [FStar_Extraction_ML_Syntax.MLM_Top app])
-                    | FStar_Pervasives_Native.None -> [] in
-                  FStar_Compiler_List.collect mk_registration
-                    (FStar_Pervasives_Native.snd lbs)
-              | uu___3 -> []))
-let (lb_irrelevant : env_t -> FStar_Syntax_Syntax.letbinding -> Prims.bool) =
-  fun g ->
-    fun lb ->
-      ((let uu___ = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-        FStar_TypeChecker_Env.non_informative uu___
-          lb.FStar_Syntax_Syntax.lbtyp)
-         &&
-         (let uu___ =
-            FStar_Extraction_ML_Term.is_arity g lb.FStar_Syntax_Syntax.lbtyp in
-          Prims.op_Negation uu___))
-        &&
-        (FStar_Syntax_Util.is_pure_or_ghost_effect
-           lb.FStar_Syntax_Syntax.lbeff)
-let rec (extract_sig :
-  env_t ->
-    FStar_Syntax_Syntax.sigelt ->
-      (env_t * FStar_Extraction_ML_Syntax.mlmodule1 Prims.list))
-  =
-  fun g ->
-    fun se ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Print.sigelt_to_string_short se in
-        FStar_Compiler_Util.format1
-          "While extracting top-level definition `%s`" uu___1 in
-      FStar_Errors.with_ctx uu___
-        (fun uu___1 ->
-           FStar_Extraction_ML_UEnv.debug g
-             (fun u ->
-                let uu___3 = FStar_Syntax_Print.sigelt_to_string_short se in
-                FStar_Compiler_Util.print1 ">>>> extract_sig %s \n" uu___3);
-           (let uu___3 = sigelt_has_noextract se in
-            if uu___3
-            then let g1 = mark_sigelt_erased se g in (g1, [])
-            else
-              (let se1 = karamel_fixup_qual se in
-               match se1.FStar_Syntax_Syntax.sigel with
-               | FStar_Syntax_Syntax.Sig_bundle uu___5 ->
-                   extract_bundle g se1
-               | FStar_Syntax_Syntax.Sig_inductive_typ uu___5 ->
-                   extract_bundle g se1
-               | FStar_Syntax_Syntax.Sig_datacon uu___5 ->
-                   extract_bundle g se1
-               | FStar_Syntax_Syntax.Sig_new_effect ed when
-                   let uu___5 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                   FStar_TypeChecker_Env.is_reifiable_effect uu___5
-                     ed.FStar_Syntax_Syntax.mname
-                   ->
-                   let uu___5 = extract_reifiable_effect g ed in
-                   (match uu___5 with | (env, _iface, impl) -> (env, impl))
-               | FStar_Syntax_Syntax.Sig_splice uu___5 ->
-                   failwith "impossible: trying to extract splice"
-               | FStar_Syntax_Syntax.Sig_fail uu___5 ->
-                   failwith "impossible: trying to extract Sig_fail"
-               | FStar_Syntax_Syntax.Sig_new_effect uu___5 -> (g, [])
-               | FStar_Syntax_Syntax.Sig_let ((uu___5, lbs), uu___6) when
-                   FStar_Compiler_List.for_all (lb_irrelevant g) lbs ->
-                   (g, [])
-               | FStar_Syntax_Syntax.Sig_declare_typ (lid, univs, t) when
-                   FStar_Extraction_ML_Term.is_arity g t ->
-                   let uu___5 =
-                     extract_type_declaration g false lid
-                       se1.FStar_Syntax_Syntax.sigquals
-                       se1.FStar_Syntax_Syntax.sigattrs univs t in
-                   (match uu___5 with | (env, uu___6, impl) -> (env, impl))
-               | FStar_Syntax_Syntax.Sig_let ((false, lb::[]), uu___5) when
-                   FStar_Extraction_ML_Term.is_arity g
-                     lb.FStar_Syntax_Syntax.lbtyp
-                   ->
-                   let uu___6 =
-                     FStar_Compiler_Effect.op_Bar_Greater
-                       se1.FStar_Syntax_Syntax.sigquals
-                       (FStar_Compiler_Util.for_some
-                          (fun uu___7 ->
-                             match uu___7 with
-                             | FStar_Syntax_Syntax.Projector uu___8 -> true
-                             | uu___8 -> false)) in
-                   if uu___6
-                   then (g, [])
-                   else
-                     (let uu___8 =
-                        extract_typ_abbrev g se1.FStar_Syntax_Syntax.sigquals
-                          se1.FStar_Syntax_Syntax.sigattrs lb in
-                      match uu___8 with | (env, uu___9, impl) -> (env, impl))
-               | FStar_Syntax_Syntax.Sig_let ((true, lbs), uu___5) when
-                   should_split_let_rec_types_and_terms g lbs ->
-                   let ses = split_let_rec_types_and_terms se1 g lbs in
-                   FStar_Compiler_List.fold_left
-                     (fun uu___6 ->
-                        fun se2 ->
-                          match uu___6 with
-                          | (g1, out) ->
-                              let uu___7 = extract_sig g1 se2 in
-                              (match uu___7 with
-                               | (g2, mls) ->
-                                   (g2, (FStar_Compiler_List.op_At out mls))))
-                     (g, []) ses
-               | FStar_Syntax_Syntax.Sig_let ((true, lbs), uu___5) when
-                   FStar_Compiler_Util.for_some
-                     (fun lb ->
-                        FStar_Extraction_ML_Term.is_arity g
-                          lb.FStar_Syntax_Syntax.lbtyp) lbs
-                   ->
-                   let uu___6 = extract_let_rec_types se1 g lbs in
-                   (match uu___6 with | (env, uu___7, impl) -> (env, impl))
-               | FStar_Syntax_Syntax.Sig_let (lbs, uu___5) ->
-                   let attrs = se1.FStar_Syntax_Syntax.sigattrs in
-                   let quals = se1.FStar_Syntax_Syntax.sigquals in
-                   let maybe_postprocess_lbs lbs1 =
-                     let post_tau =
-                       let uu___6 =
-                         FStar_Syntax_Util.extract_attr'
-                           FStar_Parser_Const.postprocess_extr_with attrs in
-                       match uu___6 with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.None
-                       | FStar_Pervasives_Native.Some
-                           (uu___7,
-                            (tau, FStar_Pervasives_Native.None)::uu___8)
-                           -> FStar_Pervasives_Native.Some tau
-                       | FStar_Pervasives_Native.Some uu___7 ->
-                           (FStar_Errors.log_issue
-                              se1.FStar_Syntax_Syntax.sigrng
-                              (FStar_Errors.Warning_UnrecognizedAttribute,
-                                "Ill-formed application of 'postprocess_for_extraction_with'");
-                            FStar_Pervasives_Native.None) in
-                     let postprocess_lb tau lb =
-                       let env = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                       let lbdef =
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_TypeChecker_Env.current_module env in
-                             FStar_Ident.string_of_lid uu___8 in
-                           FStar_Pervasives_Native.Some uu___7 in
-                         FStar_Profiling.profile
-                           (fun uu___7 ->
-                              FStar_TypeChecker_Env.postprocess env tau
-                                lb.FStar_Syntax_Syntax.lbtyp
-                                lb.FStar_Syntax_Syntax.lbdef) uu___6
-                           "FStar.Extraction.ML.Module.post_process_for_extraction" in
-                       {
-                         FStar_Syntax_Syntax.lbname =
-                           (lb.FStar_Syntax_Syntax.lbname);
-                         FStar_Syntax_Syntax.lbunivs =
-                           (lb.FStar_Syntax_Syntax.lbunivs);
-                         FStar_Syntax_Syntax.lbtyp =
-                           (lb.FStar_Syntax_Syntax.lbtyp);
-                         FStar_Syntax_Syntax.lbeff =
-                           (lb.FStar_Syntax_Syntax.lbeff);
-                         FStar_Syntax_Syntax.lbdef = lbdef;
-                         FStar_Syntax_Syntax.lbattrs =
-                           (lb.FStar_Syntax_Syntax.lbattrs);
-                         FStar_Syntax_Syntax.lbpos =
-                           (lb.FStar_Syntax_Syntax.lbpos)
-                       } in
-                     match post_tau with
-                     | FStar_Pervasives_Native.None -> lbs1
-                     | FStar_Pervasives_Native.Some tau ->
-                         let uu___6 =
-                           FStar_Compiler_List.map (postprocess_lb tau)
-                             (FStar_Pervasives_Native.snd lbs1) in
-                         ((FStar_Pervasives_Native.fst lbs1), uu___6) in
-                   let maybe_normalize_for_extraction lbs1 =
-                     let norm_steps =
-                       let uu___6 =
-                         FStar_Syntax_Util.extract_attr'
-                           FStar_Parser_Const.normalize_for_extraction_lid
-                           attrs in
-                       match uu___6 with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.None
-                       | FStar_Pervasives_Native.Some
-                           (uu___7,
-                            (steps, FStar_Pervasives_Native.None)::uu___8)
-                           ->
-                           let steps1 =
-                             let uu___9 =
-                               FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                             FStar_TypeChecker_Normalize.normalize
-                               [FStar_TypeChecker_Env.UnfoldUntil
-                                  FStar_Syntax_Syntax.delta_constant;
-                               FStar_TypeChecker_Env.Zeta;
-                               FStar_TypeChecker_Env.Iota;
-                               FStar_TypeChecker_Env.Primops] uu___9 steps in
-                           let uu___9 =
-                             let uu___10 =
-                               FStar_Syntax_Embeddings.e_list
-                                 FStar_Syntax_Embeddings.e_norm_step in
-                             FStar_TypeChecker_Cfg.try_unembed_simple uu___10
-                               steps1 in
-                           (match uu___9 with
-                            | FStar_Pervasives_Native.Some steps2 ->
-                                let uu___10 =
-                                  FStar_TypeChecker_Cfg.translate_norm_steps
-                                    steps2 in
-                                FStar_Pervasives_Native.Some uu___10
-                            | uu___10 ->
-                                ((let uu___12 =
-                                    let uu___13 =
-                                      let uu___14 =
-                                        FStar_Syntax_Print.term_to_string
-                                          steps1 in
-                                      FStar_Compiler_Util.format1
-                                        "Ill-formed application of 'normalize_for_extraction': normalization steps '%s' could not be interpreted"
-                                        uu___14 in
-                                    (FStar_Errors.Warning_UnrecognizedAttribute,
-                                      uu___13) in
-                                  FStar_Errors.log_issue
-                                    se1.FStar_Syntax_Syntax.sigrng uu___12);
-                                 FStar_Pervasives_Native.None))
-                       | FStar_Pervasives_Native.Some uu___7 ->
-                           (FStar_Errors.log_issue
-                              se1.FStar_Syntax_Syntax.sigrng
-                              (FStar_Errors.Warning_UnrecognizedAttribute,
-                                "Ill-formed application of 'normalize_for_extraction'");
-                            FStar_Pervasives_Native.None) in
-                     let norm_one_lb steps lb =
-                       let env = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                       let env1 =
-                         {
-                           FStar_TypeChecker_Env.solver =
-                             (env.FStar_TypeChecker_Env.solver);
-                           FStar_TypeChecker_Env.range =
-                             (env.FStar_TypeChecker_Env.range);
-                           FStar_TypeChecker_Env.curmodule =
-                             (env.FStar_TypeChecker_Env.curmodule);
-                           FStar_TypeChecker_Env.gamma =
-                             (env.FStar_TypeChecker_Env.gamma);
-                           FStar_TypeChecker_Env.gamma_sig =
-                             (env.FStar_TypeChecker_Env.gamma_sig);
-                           FStar_TypeChecker_Env.gamma_cache =
-                             (env.FStar_TypeChecker_Env.gamma_cache);
-                           FStar_TypeChecker_Env.modules =
-                             (env.FStar_TypeChecker_Env.modules);
-                           FStar_TypeChecker_Env.expected_typ =
-                             (env.FStar_TypeChecker_Env.expected_typ);
-                           FStar_TypeChecker_Env.sigtab =
-                             (env.FStar_TypeChecker_Env.sigtab);
-                           FStar_TypeChecker_Env.attrtab =
-                             (env.FStar_TypeChecker_Env.attrtab);
-                           FStar_TypeChecker_Env.instantiate_imp =
-                             (env.FStar_TypeChecker_Env.instantiate_imp);
-                           FStar_TypeChecker_Env.effects =
-                             (env.FStar_TypeChecker_Env.effects);
-                           FStar_TypeChecker_Env.generalize =
-                             (env.FStar_TypeChecker_Env.generalize);
-                           FStar_TypeChecker_Env.letrecs =
-                             (env.FStar_TypeChecker_Env.letrecs);
-                           FStar_TypeChecker_Env.top_level =
-                             (env.FStar_TypeChecker_Env.top_level);
-                           FStar_TypeChecker_Env.check_uvars =
-                             (env.FStar_TypeChecker_Env.check_uvars);
-                           FStar_TypeChecker_Env.use_eq_strict =
-                             (env.FStar_TypeChecker_Env.use_eq_strict);
-                           FStar_TypeChecker_Env.is_iface =
-                             (env.FStar_TypeChecker_Env.is_iface);
-                           FStar_TypeChecker_Env.admit =
-                             (env.FStar_TypeChecker_Env.admit);
-                           FStar_TypeChecker_Env.lax =
-                             (env.FStar_TypeChecker_Env.lax);
-                           FStar_TypeChecker_Env.lax_universes =
-                             (env.FStar_TypeChecker_Env.lax_universes);
-                           FStar_TypeChecker_Env.phase1 =
-                             (env.FStar_TypeChecker_Env.phase1);
-                           FStar_TypeChecker_Env.failhard =
-                             (env.FStar_TypeChecker_Env.failhard);
-                           FStar_TypeChecker_Env.nosynth =
-                             (env.FStar_TypeChecker_Env.nosynth);
-                           FStar_TypeChecker_Env.uvar_subtyping =
-                             (env.FStar_TypeChecker_Env.uvar_subtyping);
-                           FStar_TypeChecker_Env.tc_term =
-                             (env.FStar_TypeChecker_Env.tc_term);
-                           FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                             (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                           FStar_TypeChecker_Env.universe_of =
-                             (env.FStar_TypeChecker_Env.universe_of);
-                           FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                             =
-                             (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                           FStar_TypeChecker_Env.teq_nosmt_force =
-                             (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                           FStar_TypeChecker_Env.subtype_nosmt_force =
-                             (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                           FStar_TypeChecker_Env.qtbl_name_and_index =
-                             (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                           FStar_TypeChecker_Env.normalized_eff_names =
-                             (env.FStar_TypeChecker_Env.normalized_eff_names);
-                           FStar_TypeChecker_Env.fv_delta_depths =
-                             (env.FStar_TypeChecker_Env.fv_delta_depths);
-                           FStar_TypeChecker_Env.proof_ns =
-                             (env.FStar_TypeChecker_Env.proof_ns);
-                           FStar_TypeChecker_Env.synth_hook =
-                             (env.FStar_TypeChecker_Env.synth_hook);
-                           FStar_TypeChecker_Env.try_solve_implicits_hook =
-                             (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                           FStar_TypeChecker_Env.splice =
-                             (env.FStar_TypeChecker_Env.splice);
-                           FStar_TypeChecker_Env.mpreprocess =
-                             (env.FStar_TypeChecker_Env.mpreprocess);
-                           FStar_TypeChecker_Env.postprocess =
-                             (env.FStar_TypeChecker_Env.postprocess);
-                           FStar_TypeChecker_Env.identifier_info =
-                             (env.FStar_TypeChecker_Env.identifier_info);
-                           FStar_TypeChecker_Env.tc_hooks =
-                             (env.FStar_TypeChecker_Env.tc_hooks);
-                           FStar_TypeChecker_Env.dsenv =
-                             (env.FStar_TypeChecker_Env.dsenv);
-                           FStar_TypeChecker_Env.nbe =
-                             (env.FStar_TypeChecker_Env.nbe);
-                           FStar_TypeChecker_Env.strict_args_tab =
-                             (env.FStar_TypeChecker_Env.strict_args_tab);
-                           FStar_TypeChecker_Env.erasable_types_tab =
-                             (env.FStar_TypeChecker_Env.erasable_types_tab);
-                           FStar_TypeChecker_Env.enable_defer_to_tac =
-                             (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                           FStar_TypeChecker_Env.unif_allow_ref_guards =
-                             (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                           FStar_TypeChecker_Env.erase_erasable_args = true;
-                           FStar_TypeChecker_Env.core_check =
-                             (env.FStar_TypeChecker_Env.core_check)
-                         } in
-                       let lbd =
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_TypeChecker_Env.current_module env1 in
-                             FStar_Ident.string_of_lid uu___8 in
-                           FStar_Pervasives_Native.Some uu___7 in
-                         FStar_Profiling.profile
-                           (fun uu___7 ->
-                              FStar_TypeChecker_Normalize.normalize steps
-                                env1 lb.FStar_Syntax_Syntax.lbdef) uu___6
-                           "FStar.Extraction.ML.Module.normalize_for_extraction" in
-                       {
-                         FStar_Syntax_Syntax.lbname =
-                           (lb.FStar_Syntax_Syntax.lbname);
-                         FStar_Syntax_Syntax.lbunivs =
-                           (lb.FStar_Syntax_Syntax.lbunivs);
-                         FStar_Syntax_Syntax.lbtyp =
-                           (lb.FStar_Syntax_Syntax.lbtyp);
-                         FStar_Syntax_Syntax.lbeff =
-                           (lb.FStar_Syntax_Syntax.lbeff);
-                         FStar_Syntax_Syntax.lbdef = lbd;
-                         FStar_Syntax_Syntax.lbattrs =
-                           (lb.FStar_Syntax_Syntax.lbattrs);
-                         FStar_Syntax_Syntax.lbpos =
-                           (lb.FStar_Syntax_Syntax.lbpos)
-                       } in
-                     match norm_steps with
-                     | FStar_Pervasives_Native.None -> lbs1
-                     | FStar_Pervasives_Native.Some steps ->
-                         let uu___6 =
-                           FStar_Compiler_List.map (norm_one_lb steps)
-                             (FStar_Pervasives_Native.snd lbs1) in
-                         ((FStar_Pervasives_Native.fst lbs1), uu___6) in
-                   let uu___6 =
-                     let lbs1 =
-                       let uu___7 = maybe_postprocess_lbs lbs in
-                       maybe_normalize_for_extraction uu___7 in
-                     let uu___7 =
-                       FStar_Syntax_Syntax.mk
-                         (FStar_Syntax_Syntax.Tm_let
-                            (lbs1, FStar_Syntax_Util.exp_false_bool))
-                         se1.FStar_Syntax_Syntax.sigrng in
-                     FStar_Extraction_ML_Term.term_as_mlexpr g uu___7 in
-                   (match uu___6 with
-                    | (ml_let, uu___7, uu___8) ->
-                        (match ml_let.FStar_Extraction_ML_Syntax.expr with
-                         | FStar_Extraction_ML_Syntax.MLE_Let
-                             ((flavor, bindings), uu___9) ->
-                             let flags =
-                               FStar_Compiler_List.choose flag_of_qual quals in
-                             let flags' = extract_metadata attrs in
-                             let uu___10 =
-                               FStar_Compiler_List.fold_left2
-                                 (fun uu___11 ->
-                                    fun ml_lb ->
-                                      fun uu___12 ->
-                                        match (uu___11, uu___12) with
-                                        | ((env, ml_lbs),
-                                           {
-                                             FStar_Syntax_Syntax.lbname =
-                                               lbname;
-                                             FStar_Syntax_Syntax.lbunivs =
-                                               uu___13;
-                                             FStar_Syntax_Syntax.lbtyp = t;
-                                             FStar_Syntax_Syntax.lbeff =
-                                               uu___14;
-                                             FStar_Syntax_Syntax.lbdef =
-                                               uu___15;
-                                             FStar_Syntax_Syntax.lbattrs =
-                                               uu___16;
-                                             FStar_Syntax_Syntax.lbpos =
-                                               uu___17;_})
-                                            ->
-                                            let uu___18 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                ml_lb.FStar_Extraction_ML_Syntax.mllb_meta
-                                                (FStar_Compiler_List.contains
-                                                   FStar_Extraction_ML_Syntax.Erased) in
-                                            if uu___18
-                                            then (env, ml_lbs)
-                                            else
-                                              (let lb_lid =
-                                                 let uu___20 =
-                                                   let uu___21 =
-                                                     FStar_Compiler_Util.right
-                                                       lbname in
-                                                   uu___21.FStar_Syntax_Syntax.fv_name in
-                                                 uu___20.FStar_Syntax_Syntax.v in
-                                               let flags'' =
-                                                 let uu___20 =
-                                                   let uu___21 =
-                                                     FStar_Syntax_Subst.compress
-                                                       t in
-                                                   uu___21.FStar_Syntax_Syntax.n in
-                                                 match uu___20 with
-                                                 | FStar_Syntax_Syntax.Tm_arrow
-                                                     (uu___21,
-                                                      {
-                                                        FStar_Syntax_Syntax.n
-                                                          =
-                                                          FStar_Syntax_Syntax.Comp
-                                                          {
-                                                            FStar_Syntax_Syntax.comp_univs
-                                                              = uu___22;
-                                                            FStar_Syntax_Syntax.effect_name
-                                                              = e;
-                                                            FStar_Syntax_Syntax.result_typ
-                                                              = uu___23;
-                                                            FStar_Syntax_Syntax.effect_args
-                                                              = uu___24;
-                                                            FStar_Syntax_Syntax.flags
-                                                              = uu___25;_};
-                                                        FStar_Syntax_Syntax.pos
-                                                          = uu___26;
-                                                        FStar_Syntax_Syntax.vars
-                                                          = uu___27;
-                                                        FStar_Syntax_Syntax.hash_code
-                                                          = uu___28;_})
-                                                     when
-                                                     let uu___29 =
-                                                       FStar_Ident.string_of_lid
-                                                         e in
-                                                     uu___29 =
-                                                       "FStar.HyperStack.ST.StackInline"
-                                                     ->
-                                                     [FStar_Extraction_ML_Syntax.StackInline]
-                                                 | uu___21 -> [] in
-                                               let meta =
-                                                 FStar_Compiler_List.op_At
-                                                   flags
-                                                   (FStar_Compiler_List.op_At
-                                                      flags' flags'') in
-                                               let ml_lb1 =
-                                                 {
-                                                   FStar_Extraction_ML_Syntax.mllb_name
-                                                     =
-                                                     (ml_lb.FStar_Extraction_ML_Syntax.mllb_name);
-                                                   FStar_Extraction_ML_Syntax.mllb_tysc
-                                                     =
-                                                     (ml_lb.FStar_Extraction_ML_Syntax.mllb_tysc);
-                                                   FStar_Extraction_ML_Syntax.mllb_add_unit
-                                                     =
-                                                     (ml_lb.FStar_Extraction_ML_Syntax.mllb_add_unit);
-                                                   FStar_Extraction_ML_Syntax.mllb_def
-                                                     =
-                                                     (ml_lb.FStar_Extraction_ML_Syntax.mllb_def);
-                                                   FStar_Extraction_ML_Syntax.mllb_meta
-                                                     = meta;
-                                                   FStar_Extraction_ML_Syntax.print_typ
-                                                     =
-                                                     (ml_lb.FStar_Extraction_ML_Syntax.print_typ)
-                                                 } in
-                                               let uu___20 =
-                                                 let uu___21 =
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     quals
-                                                     (FStar_Compiler_Util.for_some
-                                                        (fun uu___22 ->
-                                                           match uu___22 with
-                                                           | FStar_Syntax_Syntax.Projector
-                                                               uu___23 ->
-                                                               true
-                                                           | uu___23 -> false)) in
-                                                 if uu___21
-                                                 then
-                                                   let uu___22 =
-                                                     let uu___23 =
-                                                       FStar_Compiler_Util.right
-                                                         lbname in
-                                                     let uu___24 =
-                                                       FStar_Compiler_Util.must
-                                                         ml_lb1.FStar_Extraction_ML_Syntax.mllb_tysc in
-                                                     FStar_Extraction_ML_UEnv.extend_fv
-                                                       env uu___23 uu___24
-                                                       ml_lb1.FStar_Extraction_ML_Syntax.mllb_add_unit in
-                                                   match uu___22 with
-                                                   | (env1, mls, uu___23) ->
-                                                       (env1,
-                                                         {
-                                                           FStar_Extraction_ML_Syntax.mllb_name
-                                                             = mls;
-                                                           FStar_Extraction_ML_Syntax.mllb_tysc
-                                                             =
-                                                             (ml_lb1.FStar_Extraction_ML_Syntax.mllb_tysc);
-                                                           FStar_Extraction_ML_Syntax.mllb_add_unit
-                                                             =
-                                                             (ml_lb1.FStar_Extraction_ML_Syntax.mllb_add_unit);
-                                                           FStar_Extraction_ML_Syntax.mllb_def
-                                                             =
-                                                             (ml_lb1.FStar_Extraction_ML_Syntax.mllb_def);
-                                                           FStar_Extraction_ML_Syntax.mllb_meta
-                                                             =
-                                                             (ml_lb1.FStar_Extraction_ML_Syntax.mllb_meta);
-                                                           FStar_Extraction_ML_Syntax.print_typ
-                                                             =
-                                                             (ml_lb1.FStar_Extraction_ML_Syntax.print_typ)
-                                                         })
-                                                 else
-                                                   (let uu___23 =
-                                                      let uu___24 =
-                                                        FStar_Compiler_Util.must
-                                                          ml_lb1.FStar_Extraction_ML_Syntax.mllb_tysc in
-                                                      FStar_Extraction_ML_UEnv.extend_lb
-                                                        env lbname t uu___24
-                                                        ml_lb1.FStar_Extraction_ML_Syntax.mllb_add_unit in
-                                                    match uu___23 with
-                                                    | (env1, uu___24,
-                                                       uu___25) ->
-                                                        (env1, ml_lb1)) in
-                                               match uu___20 with
-                                               | (g1, ml_lb2) ->
-                                                   (g1, (ml_lb2 :: ml_lbs))))
-                                 (g, []) bindings
-                                 (FStar_Pervasives_Native.snd lbs) in
-                             (match uu___10 with
-                              | (g1, ml_lbs') ->
-                                  let uu___11 =
-                                    let uu___12 =
-                                      let uu___13 =
-                                        let uu___14 =
-                                          FStar_Extraction_ML_Util.mlloc_of_range
-                                            se1.FStar_Syntax_Syntax.sigrng in
-                                        FStar_Extraction_ML_Syntax.MLM_Loc
-                                          uu___14 in
-                                      [uu___13;
-                                      FStar_Extraction_ML_Syntax.MLM_Let
-                                        (flavor,
-                                          (FStar_Compiler_List.rev ml_lbs'))] in
-                                    let uu___13 =
-                                      maybe_register_plugin g1 se1 in
-                                    FStar_Compiler_List.op_At uu___12 uu___13 in
-                                  (g1, uu___11))
-                         | uu___9 ->
-                             let uu___10 =
-                               let uu___11 =
-                                 let uu___12 =
-                                   FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                     g in
-                                 FStar_Extraction_ML_Code.string_of_mlexpr
-                                   uu___12 ml_let in
-                               FStar_Compiler_Util.format1
-                                 "Impossible: Translated a let to a non-let: %s"
-                                 uu___11 in
-                             failwith uu___10))
-               | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___5, t) ->
-                   let quals = se1.FStar_Syntax_Syntax.sigquals in
-                   let uu___6 =
-                     (FStar_Compiler_Effect.op_Bar_Greater quals
-                        (FStar_Compiler_List.contains
-                           FStar_Syntax_Syntax.Assumption))
-                       &&
-                       (let uu___7 =
-                          let uu___8 =
-                            FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                          FStar_TypeChecker_Util.must_erase_for_extraction
-                            uu___8 t in
-                        Prims.op_Negation uu___7) in
-                   if uu___6
-                   then
-                     let always_fail1 =
-                       let uu___7 =
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               let uu___11 = always_fail lid t in [uu___11] in
-                             (false, uu___10) in
-                           (uu___9, []) in
-                         FStar_Syntax_Syntax.Sig_let uu___8 in
-                       {
-                         FStar_Syntax_Syntax.sigel = uu___7;
-                         FStar_Syntax_Syntax.sigrng =
-                           (se1.FStar_Syntax_Syntax.sigrng);
-                         FStar_Syntax_Syntax.sigquals =
-                           (se1.FStar_Syntax_Syntax.sigquals);
-                         FStar_Syntax_Syntax.sigmeta =
-                           (se1.FStar_Syntax_Syntax.sigmeta);
-                         FStar_Syntax_Syntax.sigattrs =
-                           (se1.FStar_Syntax_Syntax.sigattrs);
-                         FStar_Syntax_Syntax.sigopts =
-                           (se1.FStar_Syntax_Syntax.sigopts)
-                       } in
-                     let uu___7 = extract_sig g always_fail1 in
-                     (match uu___7 with
-                      | (g1, mlm) ->
-                          let uu___8 =
-                            FStar_Compiler_Util.find_map quals
-                              (fun uu___9 ->
-                                 match uu___9 with
-                                 | FStar_Syntax_Syntax.Discriminator l ->
-                                     FStar_Pervasives_Native.Some l
-                                 | uu___10 -> FStar_Pervasives_Native.None) in
-                          (match uu___8 with
-                           | FStar_Pervasives_Native.Some l ->
-                               let uu___9 =
-                                 let uu___10 =
-                                   let uu___11 =
-                                     FStar_Extraction_ML_Util.mlloc_of_range
-                                       se1.FStar_Syntax_Syntax.sigrng in
-                                   FStar_Extraction_ML_Syntax.MLM_Loc uu___11 in
-                                 let uu___11 =
-                                   let uu___12 =
-                                     FStar_Extraction_ML_Term.ind_discriminator_body
-                                       g1 lid l in
-                                   [uu___12] in
-                                 uu___10 :: uu___11 in
-                               (g1, uu___9)
-                           | uu___9 ->
-                               let uu___10 =
-                                 FStar_Compiler_Util.find_map quals
-                                   (fun uu___11 ->
-                                      match uu___11 with
-                                      | FStar_Syntax_Syntax.Projector
-                                          (l, uu___12) ->
-                                          FStar_Pervasives_Native.Some l
-                                      | uu___12 ->
-                                          FStar_Pervasives_Native.None) in
-                               (match uu___10 with
-                                | FStar_Pervasives_Native.Some uu___11 ->
-                                    (g1, [])
-                                | uu___11 -> (g1, mlm))))
-                   else (g, [])
-               | FStar_Syntax_Syntax.Sig_assume uu___5 -> (g, [])
-               | FStar_Syntax_Syntax.Sig_sub_effect uu___5 -> (g, [])
-               | FStar_Syntax_Syntax.Sig_effect_abbrev uu___5 -> (g, [])
-               | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___5 -> (g, [])
-               | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___5 ->
-                   (g, [])
-               | FStar_Syntax_Syntax.Sig_pragma p ->
-                   (FStar_Syntax_Util.process_pragma p
-                      se1.FStar_Syntax_Syntax.sigrng;
-                    (g, [])))))
-let (extract' :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.modul ->
-      (FStar_Extraction_ML_UEnv.uenv * FStar_Extraction_ML_Syntax.mllib
-        FStar_Pervasives_Native.option))
-  =
-  fun g ->
-    fun m ->
-      let uu___ = FStar_Options.restore_cmd_line_options true in
-      let uu___1 =
-        FStar_Extraction_ML_UEnv.extend_with_module_name g
-          m.FStar_Syntax_Syntax.name in
-      match uu___1 with
-      | (name, g1) ->
-          let g2 =
-            let uu___2 =
-              let uu___3 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g1 in
-              FStar_TypeChecker_Env.set_current_module uu___3
-                m.FStar_Syntax_Syntax.name in
-            FStar_Extraction_ML_UEnv.set_tcenv g1 uu___2 in
-          let g3 = FStar_Extraction_ML_UEnv.set_current_module g2 name in
-          let uu___2 =
-            FStar_Compiler_Util.fold_map
-              (fun g4 ->
-                 fun se ->
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-                     FStar_Options.debug_module uu___4 in
-                   if uu___3
-                   then
-                     let nm =
-                       let uu___4 =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           (FStar_Syntax_Util.lids_of_sigelt se)
-                           (FStar_Compiler_List.map FStar_Ident.string_of_lid) in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         (FStar_String.concat ", ") in
-                     (FStar_Compiler_Util.print1 "+++About to extract {%s}\n"
-                        nm;
-                      (let uu___5 =
-                         FStar_Compiler_Util.format1 "---Extracted {%s}" nm in
-                       FStar_Compiler_Util.measure_execution_time uu___5
-                         (fun uu___6 -> extract_sig g4 se)))
-                   else extract_sig g4 se) g3
-              m.FStar_Syntax_Syntax.declarations in
-          (match uu___2 with
-           | (g4, sigs) ->
-               let mlm = FStar_Compiler_List.flatten sigs in
-               let is_karamel =
-                 let uu___3 = FStar_Options.codegen () in
-                 uu___3 = (FStar_Pervasives_Native.Some FStar_Options.Krml) in
-               let uu___3 =
-                 (let uu___4 =
-                    FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-                  uu___4 <> "Prims") &&
-                   (is_karamel ||
-                      (Prims.op_Negation m.FStar_Syntax_Syntax.is_interface)) in
-               if uu___3
-               then
-                 ((let uu___5 =
-                     let uu___6 = FStar_Options.silent () in
-                     Prims.op_Negation uu___6 in
-                   if uu___5
-                   then
-                     let uu___6 =
-                       FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-                     FStar_Compiler_Util.print1 "Extracted module %s\n"
-                       uu___6
-                   else ());
-                  (g4,
-                    (FStar_Pervasives_Native.Some
-                       (FStar_Extraction_ML_Syntax.MLLib
-                          [(name, (FStar_Pervasives_Native.Some ([], mlm)),
-                             (FStar_Extraction_ML_Syntax.MLLib []))]))))
-               else (g4, FStar_Pervasives_Native.None))
-let (extract :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.modul ->
-      (FStar_Extraction_ML_UEnv.uenv * FStar_Extraction_ML_Syntax.mllib
-        FStar_Pervasives_Native.option))
-  =
-  fun g ->
-    fun m ->
-      (let uu___1 = FStar_Options.restore_cmd_line_options true in
-       FStar_Compiler_Effect.op_Less_Bar (fun uu___2 -> ()) uu___1);
-      (let tgt =
-         let uu___1 = FStar_Options.codegen () in
-         match uu___1 with
-         | FStar_Pervasives_Native.None ->
-             failwith "Impossible: We're in extract, codegen must be set!"
-         | FStar_Pervasives_Native.Some t -> t in
-       (let uu___2 =
-          let uu___3 =
-            let uu___4 = FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-            FStar_Options.should_extract uu___4 tgt in
-          Prims.op_Negation uu___3 in
-        if uu___2
-        then
-          let uu___3 =
-            let uu___4 = FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-            FStar_Compiler_Util.format1
-              "Extract called on a module %s that should not be extracted"
-              uu___4 in
-          failwith uu___3
-        else ());
-       (let uu___2 = FStar_Options.interactive () in
-        if uu___2
-        then (g, FStar_Pervasives_Native.None)
-        else
-          (let nm = FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-           let uu___4 =
-             FStar_Syntax_Unionfind.with_uf_enabled
-               (fun uu___5 ->
-                  FStar_Errors.with_ctx
-                    (Prims.op_Hat "While extracting module " nm)
-                    (fun uu___6 ->
-                       FStar_Profiling.profile (fun uu___7 -> extract' g m)
-                         (FStar_Pervasives_Native.Some nm)
-                         "FStar.Extraction.ML.Modul.extract")) in
-           match uu___4 with
-           | (g1, mllib) ->
-               let uu___5 =
-                 match mllib with
-                 | FStar_Pervasives_Native.None -> (g1, mllib)
-                 | FStar_Pervasives_Native.Some mllib1 ->
-                     let uu___6 =
-                       FStar_Extraction_ML_UEnv.with_typars_env g1
-                         (fun e ->
-                            FStar_Extraction_ML_RemoveUnusedParameters.elim_mllib
-                              e mllib1) in
-                     (match uu___6 with
-                      | (g2, mllib2) ->
-                          (g2, (FStar_Pervasives_Native.Some mllib2))) in
-               (match uu___5 with
-                | (g2, mllib1) ->
-                    ((let uu___7 =
-                        FStar_Options.restore_cmd_line_options true in
-                      FStar_Compiler_Effect.op_Less_Bar (fun uu___8 -> ())
-                        uu___7);
-                     (let uu___7 = FStar_Extraction_ML_UEnv.exit_module g2 in
-                      (uu___7, mllib1)))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_RemoveUnusedParameters.ml b/src/ocaml-output/FStar_Extraction_ML_RemoveUnusedParameters.ml
deleted file mode 100644
index 7221427bd4e..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_RemoveUnusedParameters.ml
+++ /dev/null
@@ -1,611 +0,0 @@
-open Prims
-type argument_tag =
-  | Retain 
-  | Omit 
-let (uu___is_Retain : argument_tag -> Prims.bool) =
-  fun projectee -> match projectee with | Retain -> true | uu___ -> false
-let (uu___is_Omit : argument_tag -> Prims.bool) =
-  fun projectee -> match projectee with | Omit -> true | uu___ -> false
-type entry = argument_tag Prims.list
-type env_t =
-  {
-  current_module: FStar_Extraction_ML_Syntax.mlsymbol Prims.list ;
-  tydef_map: entry FStar_Compiler_Util.psmap }
-let (__proj__Mkenv_t__item__current_module :
-  env_t -> FStar_Extraction_ML_Syntax.mlsymbol Prims.list) =
-  fun projectee ->
-    match projectee with | { current_module; tydef_map;_} -> current_module
-let (__proj__Mkenv_t__item__tydef_map :
-  env_t -> entry FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with | { current_module; tydef_map;_} -> tydef_map
-let (initial_env : env_t) =
-  let uu___ = FStar_Compiler_Util.psmap_empty () in
-  { current_module = []; tydef_map = uu___ }
-type tydef =
-  (FStar_Extraction_ML_Syntax.mlsymbol * FStar_Extraction_ML_Syntax.metadata
-    * (FStar_Extraction_ML_Syntax.mltyscheme, Prims.int)
-    FStar_Pervasives.either)
-let (extend_env :
-  env_t -> FStar_Extraction_ML_Syntax.mlsymbol -> entry -> env_t) =
-  fun env ->
-    fun i ->
-      fun e ->
-        let uu___ =
-          let uu___1 =
-            FStar_Extraction_ML_Syntax.string_of_mlpath
-              ((env.current_module), i) in
-          FStar_Compiler_Util.psmap_add env.tydef_map uu___1 e in
-        { current_module = (env.current_module); tydef_map = uu___ }
-let (lookup_tyname :
-  env_t ->
-    FStar_Extraction_ML_Syntax.mlpath -> entry FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun name ->
-      let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath name in
-      FStar_Compiler_Util.psmap_try_find env.tydef_map uu___
-type var_set = FStar_Extraction_ML_Syntax.mlident FStar_Compiler_Util.set
-let (empty_var_set : Prims.string FStar_Compiler_Util.set) =
-  FStar_Compiler_Util.new_set (fun x -> fun y -> FStar_String.compare x y)
-let rec (freevars_of_mlty' :
-  var_set -> FStar_Extraction_ML_Syntax.mlty -> var_set) =
-  fun vars ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Var i ->
-          FStar_Compiler_Util.set_add i vars
-      | FStar_Extraction_ML_Syntax.MLTY_Fun (t0, uu___, t1) ->
-          let uu___1 = freevars_of_mlty' vars t0 in
-          freevars_of_mlty' uu___1 t1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tys, uu___) ->
-          FStar_Compiler_List.fold_left freevars_of_mlty' vars tys
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple tys ->
-          FStar_Compiler_List.fold_left freevars_of_mlty' vars tys
-      | uu___ -> vars
-let (freevars_of_mlty : FStar_Extraction_ML_Syntax.mlty -> var_set) =
-  freevars_of_mlty' empty_var_set
-let rec (elim_mlty :
-  env_t -> FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun env ->
-    fun mlty ->
-      match mlty with
-      | FStar_Extraction_ML_Syntax.MLTY_Var uu___ -> mlty
-      | FStar_Extraction_ML_Syntax.MLTY_Fun (t0, e, t1) ->
-          let uu___ =
-            let uu___1 = elim_mlty env t0 in
-            let uu___2 = elim_mlty env t1 in (uu___1, e, uu___2) in
-          FStar_Extraction_ML_Syntax.MLTY_Fun uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, name) ->
-          let args1 = FStar_Compiler_List.map (elim_mlty env) args in
-          let uu___ = lookup_tyname env name in
-          (match uu___ with
-           | FStar_Pervasives_Native.None ->
-               FStar_Extraction_ML_Syntax.MLTY_Named (args1, name)
-           | FStar_Pervasives_Native.Some entry1 ->
-               (if
-                  (FStar_Compiler_List.length entry1) <>
-                    (FStar_Compiler_List.length args1)
-                then
-                  failwith
-                    "Impossible: arity mismatch between definition and use"
-                else ();
-                (let args2 =
-                   FStar_Compiler_List.fold_right2
-                     (fun arg ->
-                        fun tag ->
-                          fun out ->
-                            match tag with
-                            | Retain -> arg :: out
-                            | uu___2 -> out) args1 entry1 [] in
-                 FStar_Extraction_ML_Syntax.MLTY_Named (args2, name))))
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple tys ->
-          let uu___ = FStar_Compiler_List.map (elim_mlty env) tys in
-          FStar_Extraction_ML_Syntax.MLTY_Tuple uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Top -> mlty
-      | FStar_Extraction_ML_Syntax.MLTY_Erased -> mlty
-let rec (elim_mlexpr' :
-  env_t ->
-    FStar_Extraction_ML_Syntax.mlexpr' -> FStar_Extraction_ML_Syntax.mlexpr')
-  =
-  fun env ->
-    fun e ->
-      match e with
-      | FStar_Extraction_ML_Syntax.MLE_Const uu___ -> e
-      | FStar_Extraction_ML_Syntax.MLE_Var uu___ -> e
-      | FStar_Extraction_ML_Syntax.MLE_Name uu___ -> e
-      | FStar_Extraction_ML_Syntax.MLE_Let (lb, e1) ->
-          let uu___ =
-            let uu___1 = elim_letbinding env lb in
-            let uu___2 = elim_mlexpr env e1 in (uu___1, uu___2) in
-          FStar_Extraction_ML_Syntax.MLE_Let uu___
-      | FStar_Extraction_ML_Syntax.MLE_App (e1, es) ->
-          let uu___ =
-            let uu___1 = elim_mlexpr env e1 in
-            let uu___2 = FStar_Compiler_List.map (elim_mlexpr env) es in
-            (uu___1, uu___2) in
-          FStar_Extraction_ML_Syntax.MLE_App uu___
-      | FStar_Extraction_ML_Syntax.MLE_TApp (e1, tys) ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map (elim_mlty env) tys in
-            (e1, uu___1) in
-          FStar_Extraction_ML_Syntax.MLE_TApp uu___
-      | FStar_Extraction_ML_Syntax.MLE_Fun (bvs, e1) ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map
-                (fun uu___2 ->
-                   match uu___2 with
-                   | (x, t) -> let uu___3 = elim_mlty env t in (x, uu___3))
-                bvs in
-            let uu___2 = elim_mlexpr env e1 in (uu___1, uu___2) in
-          FStar_Extraction_ML_Syntax.MLE_Fun uu___
-      | FStar_Extraction_ML_Syntax.MLE_Match (e1, branches) ->
-          let uu___ =
-            let uu___1 = elim_mlexpr env e1 in
-            let uu___2 = FStar_Compiler_List.map (elim_branch env) branches in
-            (uu___1, uu___2) in
-          FStar_Extraction_ML_Syntax.MLE_Match uu___
-      | FStar_Extraction_ML_Syntax.MLE_Coerce (e1, t0, t1) ->
-          let uu___ =
-            let uu___1 = elim_mlexpr env e1 in
-            let uu___2 = elim_mlty env t0 in
-            let uu___3 = elim_mlty env t1 in (uu___1, uu___2, uu___3) in
-          FStar_Extraction_ML_Syntax.MLE_Coerce uu___
-      | FStar_Extraction_ML_Syntax.MLE_CTor (l, es) ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map (elim_mlexpr env) es in
-            (l, uu___1) in
-          FStar_Extraction_ML_Syntax.MLE_CTor uu___
-      | FStar_Extraction_ML_Syntax.MLE_Seq es ->
-          let uu___ = FStar_Compiler_List.map (elim_mlexpr env) es in
-          FStar_Extraction_ML_Syntax.MLE_Seq uu___
-      | FStar_Extraction_ML_Syntax.MLE_Tuple es ->
-          let uu___ = FStar_Compiler_List.map (elim_mlexpr env) es in
-          FStar_Extraction_ML_Syntax.MLE_Tuple uu___
-      | FStar_Extraction_ML_Syntax.MLE_Record (syms, fields) ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map
-                (fun uu___2 ->
-                   match uu___2 with
-                   | (s, e1) ->
-                       let uu___3 = elim_mlexpr env e1 in (s, uu___3)) fields in
-            (syms, uu___1) in
-          FStar_Extraction_ML_Syntax.MLE_Record uu___
-      | FStar_Extraction_ML_Syntax.MLE_Proj (e1, p) ->
-          let uu___ = let uu___1 = elim_mlexpr env e1 in (uu___1, p) in
-          FStar_Extraction_ML_Syntax.MLE_Proj uu___
-      | FStar_Extraction_ML_Syntax.MLE_If (e1, e11, e2_opt) ->
-          let uu___ =
-            let uu___1 = elim_mlexpr env e1 in
-            let uu___2 = elim_mlexpr env e11 in
-            let uu___3 = FStar_Compiler_Util.map_opt e2_opt (elim_mlexpr env) in
-            (uu___1, uu___2, uu___3) in
-          FStar_Extraction_ML_Syntax.MLE_If uu___
-      | FStar_Extraction_ML_Syntax.MLE_Raise (p, es) ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map (elim_mlexpr env) es in
-            (p, uu___1) in
-          FStar_Extraction_ML_Syntax.MLE_Raise uu___
-      | FStar_Extraction_ML_Syntax.MLE_Try (e1, branches) ->
-          let uu___ =
-            let uu___1 = elim_mlexpr env e1 in
-            let uu___2 = FStar_Compiler_List.map (elim_branch env) branches in
-            (uu___1, uu___2) in
-          FStar_Extraction_ML_Syntax.MLE_Try uu___
-and (elim_letbinding :
-  env_t ->
-    (FStar_Extraction_ML_Syntax.mlletflavor * FStar_Extraction_ML_Syntax.mllb
-      Prims.list) ->
-      (FStar_Extraction_ML_Syntax.mlletflavor *
-        FStar_Extraction_ML_Syntax.mllb Prims.list))
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | (flavor, lbs) ->
-          let elim_one_lb lb =
-            let ts =
-              FStar_Compiler_Util.map_opt
-                lb.FStar_Extraction_ML_Syntax.mllb_tysc
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (vars, t) ->
-                       let uu___2 = elim_mlty env t in (vars, uu___2)) in
-            let expr = elim_mlexpr env lb.FStar_Extraction_ML_Syntax.mllb_def in
-            {
-              FStar_Extraction_ML_Syntax.mllb_name =
-                (lb.FStar_Extraction_ML_Syntax.mllb_name);
-              FStar_Extraction_ML_Syntax.mllb_tysc = ts;
-              FStar_Extraction_ML_Syntax.mllb_add_unit =
-                (lb.FStar_Extraction_ML_Syntax.mllb_add_unit);
-              FStar_Extraction_ML_Syntax.mllb_def = expr;
-              FStar_Extraction_ML_Syntax.mllb_meta =
-                (lb.FStar_Extraction_ML_Syntax.mllb_meta);
-              FStar_Extraction_ML_Syntax.print_typ =
-                (lb.FStar_Extraction_ML_Syntax.print_typ)
-            } in
-          let uu___1 = FStar_Compiler_List.map elim_one_lb lbs in
-          (flavor, uu___1)
-and (elim_branch :
-  env_t ->
-    (FStar_Extraction_ML_Syntax.mlpattern * FStar_Extraction_ML_Syntax.mlexpr
-      FStar_Pervasives_Native.option * FStar_Extraction_ML_Syntax.mlexpr) ->
-      (FStar_Extraction_ML_Syntax.mlpattern *
-        FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option *
-        FStar_Extraction_ML_Syntax.mlexpr))
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | (pat, wopt, e) ->
-          let uu___1 = FStar_Compiler_Util.map_opt wopt (elim_mlexpr env) in
-          let uu___2 = elim_mlexpr env e in (pat, uu___1, uu___2)
-and (elim_mlexpr :
-  env_t ->
-    FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun env ->
-    fun e ->
-      let uu___ = elim_mlexpr' env e.FStar_Extraction_ML_Syntax.expr in
-      let uu___1 = elim_mlty env e.FStar_Extraction_ML_Syntax.mlty in
-      {
-        FStar_Extraction_ML_Syntax.expr = uu___;
-        FStar_Extraction_ML_Syntax.mlty = uu___1;
-        FStar_Extraction_ML_Syntax.loc = (e.FStar_Extraction_ML_Syntax.loc)
-      }
-exception Drop_tydef 
-let (uu___is_Drop_tydef : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | Drop_tydef -> true | uu___ -> false
-let (elim_tydef :
-  env_t ->
-    Prims.string ->
-      FStar_Extraction_ML_Syntax.meta Prims.list ->
-        Prims.string Prims.list ->
-          FStar_Extraction_ML_Syntax.mlty ->
-            (env_t * (Prims.string * FStar_Extraction_ML_Syntax.meta
-              Prims.list * Prims.string Prims.list *
-              FStar_Extraction_ML_Syntax.mlty)))
-  =
-  fun env ->
-    fun name ->
-      fun metadata ->
-        fun parameters ->
-          fun mlty ->
-            let val_decl_range =
-              FStar_Compiler_Util.find_map metadata
-                (fun uu___ ->
-                   match uu___ with
-                   | FStar_Extraction_ML_Syntax.HasValDecl r ->
-                       FStar_Pervasives_Native.Some r
-                   | uu___1 -> FStar_Pervasives_Native.None) in
-            let remove_typars_list =
-              FStar_Compiler_Util.try_find
-                (fun uu___ ->
-                   match uu___ with
-                   | FStar_Extraction_ML_Syntax.RemoveUnusedTypeParameters
-                       uu___1 -> true
-                   | uu___1 -> false) metadata in
-            let range_of_tydef =
-              match remove_typars_list with
-              | FStar_Pervasives_Native.None ->
-                  FStar_Compiler_Range.dummyRange
-              | FStar_Pervasives_Native.Some
-                  (FStar_Extraction_ML_Syntax.RemoveUnusedTypeParameters
-                  (uu___, r)) -> r in
-            let must_eliminate i =
-              match remove_typars_list with
-              | FStar_Pervasives_Native.Some
-                  (FStar_Extraction_ML_Syntax.RemoveUnusedTypeParameters
-                  (l, r)) -> FStar_Compiler_List.contains i l
-              | uu___ -> false in
-            let can_eliminate i =
-              match (val_decl_range, remove_typars_list) with
-              | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None)
-                  -> true
-              | uu___ -> false in
-            let mlty1 = elim_mlty env mlty in
-            let freevars = freevars_of_mlty mlty1 in
-            let uu___ =
-              FStar_Compiler_List.fold_left
-                (fun uu___1 ->
-                   fun p ->
-                     match uu___1 with
-                     | (i, params, entry1) ->
-                         let uu___2 = FStar_Compiler_Util.set_mem p freevars in
-                         if uu___2
-                         then
-                           (if must_eliminate i
-                            then
-                              (let uu___4 =
-                                 let uu___5 =
-                                   FStar_Compiler_Util.format2
-                                     "Expected parameter %s of %s to be unused in its definition and eliminated"
-                                     p name in
-                                 (FStar_Errors.Error_RemoveUnusedTypeParameter,
-                                   uu___5) in
-                               FStar_Errors.log_issue range_of_tydef uu___4)
-                            else ();
-                            ((i + Prims.int_one), (p :: params), (Retain ::
-                              entry1)))
-                         else
-                           if (can_eliminate i) || (must_eliminate i)
-                           then
-                             ((i + Prims.int_one), params, (Omit :: entry1))
-                           else
-                             (let uu___5 =
-                                let uu___6 = FStar_Options.codegen () in
-                                uu___6 =
-                                  (FStar_Pervasives_Native.Some
-                                     FStar_Options.FSharp) in
-                              if uu___5
-                              then
-                                let range =
-                                  match val_decl_range with
-                                  | FStar_Pervasives_Native.Some r -> r
-                                  | uu___6 -> range_of_tydef in
-                                ((let uu___7 =
-                                    let uu___8 =
-                                      let uu___9 =
-                                        FStar_Compiler_Util.string_of_int i in
-                                      let uu___10 =
-                                        FStar_Compiler_Util.string_of_int i in
-                                      FStar_Compiler_Util.format3
-                                        "Parameter %s of %s is unused and must be eliminated for F#; add `[@@ remove_unused_type_parameters [%s; ...]]` to the interface signature; \nThis type definition is being dropped"
-                                        uu___9 name uu___10 in
-                                    (FStar_Errors.Error_RemoveUnusedTypeParameter,
-                                      uu___8) in
-                                  FStar_Errors.log_issue range uu___7);
-                                 FStar_Compiler_Effect.raise Drop_tydef)
-                              else
-                                ((i + Prims.int_one), (p :: params), (Retain
-                                  :: entry1)))) (Prims.int_zero, [], [])
-                parameters in
-            match uu___ with
-            | (uu___1, parameters1, entry1) ->
-                let uu___2 =
-                  extend_env env name (FStar_Compiler_List.rev entry1) in
-                (uu___2,
-                  (name, metadata, (FStar_Compiler_List.rev parameters1),
-                    mlty1))
-let (elim_tydef_or_decl : env_t -> tydef -> (env_t * tydef)) =
-  fun env ->
-    fun td ->
-      match td with
-      | (name, metadata, FStar_Pervasives.Inr arity) ->
-          let remove_typars_list =
-            FStar_Compiler_Util.try_find
-              (fun uu___ ->
-                 match uu___ with
-                 | FStar_Extraction_ML_Syntax.RemoveUnusedTypeParameters
-                     uu___1 -> true
-                 | uu___1 -> false) metadata in
-          (match remove_typars_list with
-           | FStar_Pervasives_Native.None -> (env, td)
-           | FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.RemoveUnusedTypeParameters 
-               (l, r)) ->
-               let must_eliminate i = FStar_Compiler_List.contains i l in
-               let rec aux i =
-                 if i = arity
-                 then []
-                 else
-                   if must_eliminate i
-                   then
-                     (let uu___1 = aux (i + Prims.int_one) in Omit :: uu___1)
-                   else
-                     (let uu___2 = aux (i + Prims.int_one) in Retain ::
-                        uu___2) in
-               let entries = aux Prims.int_zero in
-               let uu___ = extend_env env name entries in (uu___, td))
-      | (name, metadata, FStar_Pervasives.Inl (parameters, mlty)) ->
-          let uu___ = elim_tydef env name metadata parameters mlty in
-          (match uu___ with
-           | (env1, (name1, meta, params, mlty1)) ->
-               (env1, (name1, meta, (FStar_Pervasives.Inl (params, mlty1)))))
-let (elim_tydefs : env_t -> tydef Prims.list -> (env_t * tydef Prims.list)) =
-  fun env ->
-    fun tds ->
-      let uu___ =
-        let uu___1 = FStar_Options.codegen () in
-        uu___1 <> (FStar_Pervasives_Native.Some FStar_Options.FSharp) in
-      if uu___
-      then (env, tds)
-      else
-        (let uu___2 =
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun td ->
-                  match uu___3 with
-                  | (env1, out) ->
-                      (try
-                         (fun uu___4 ->
-                            match () with
-                            | () ->
-                                let uu___5 = elim_tydef_or_decl env1 td in
-                                (match uu___5 with
-                                 | (env2, td1) -> (env2, (td1 :: out)))) ()
-                       with | Drop_tydef -> (env1, out))) (env, []) tds in
-         match uu___2 with
-         | (env1, tds1) -> (env1, (FStar_Compiler_List.rev tds1)))
-let (elim_one_mltydecl :
-  env_t ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      (env_t * FStar_Extraction_ML_Syntax.one_mltydecl))
-  =
-  fun env ->
-    fun td ->
-      let uu___ = td in
-      match uu___ with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_name = name;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = parameters;
-          FStar_Extraction_ML_Syntax.tydecl_meta = meta;
-          FStar_Extraction_ML_Syntax.tydecl_defn = body;_} ->
-          let elim_td td1 =
-            match td1 with
-            | FStar_Extraction_ML_Syntax.MLTD_Abbrev mlty ->
-                let uu___3 = elim_tydef env name meta parameters mlty in
-                (match uu___3 with
-                 | (env1, (name1, uu___4, parameters1, mlty1)) ->
-                     (env1, parameters1,
-                       (FStar_Extraction_ML_Syntax.MLTD_Abbrev mlty1)))
-            | FStar_Extraction_ML_Syntax.MLTD_Record fields ->
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Compiler_List.map
-                      (fun uu___5 ->
-                         match uu___5 with
-                         | (name1, ty) ->
-                             let uu___6 = elim_mlty env ty in (name1, uu___6))
-                      fields in
-                  FStar_Extraction_ML_Syntax.MLTD_Record uu___4 in
-                (env, parameters, uu___3)
-            | FStar_Extraction_ML_Syntax.MLTD_DType inductive ->
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Compiler_List.map
-                      (fun uu___5 ->
-                         match uu___5 with
-                         | (i, constrs) ->
-                             let uu___6 =
-                               FStar_Compiler_List.map
-                                 (fun uu___7 ->
-                                    match uu___7 with
-                                    | (constr, ty) ->
-                                        let uu___8 = elim_mlty env ty in
-                                        (constr, uu___8)) constrs in
-                             (i, uu___6)) inductive in
-                  FStar_Extraction_ML_Syntax.MLTD_DType uu___4 in
-                (env, parameters, uu___3) in
-          let uu___3 =
-            match body with
-            | FStar_Pervasives_Native.None -> (env, parameters, body)
-            | FStar_Pervasives_Native.Some td1 ->
-                let uu___4 = elim_td td1 in
-                (match uu___4 with
-                 | (env1, parameters1, td2) ->
-                     (env1, parameters1, (FStar_Pervasives_Native.Some td2))) in
-          (match uu___3 with
-           | (env1, parameters1, body1) ->
-               (env1,
-                 {
-                   FStar_Extraction_ML_Syntax.tydecl_assumed =
-                     (td.FStar_Extraction_ML_Syntax.tydecl_assumed);
-                   FStar_Extraction_ML_Syntax.tydecl_name =
-                     (td.FStar_Extraction_ML_Syntax.tydecl_name);
-                   FStar_Extraction_ML_Syntax.tydecl_ignored =
-                     (td.FStar_Extraction_ML_Syntax.tydecl_ignored);
-                   FStar_Extraction_ML_Syntax.tydecl_parameters = parameters1;
-                   FStar_Extraction_ML_Syntax.tydecl_meta =
-                     (td.FStar_Extraction_ML_Syntax.tydecl_meta);
-                   FStar_Extraction_ML_Syntax.tydecl_defn = body1
-                 }))
-let (elim_module :
-  env_t ->
-    FStar_Extraction_ML_Syntax.mlmodule1 Prims.list ->
-      (env_t * FStar_Extraction_ML_Syntax.mlmodule1 Prims.list))
-  =
-  fun env ->
-    fun m ->
-      let elim_module1 env1 m1 =
-        match m1 with
-        | FStar_Extraction_ML_Syntax.MLM_Ty td ->
-            let uu___ =
-              FStar_Compiler_Util.fold_map elim_one_mltydecl env1 td in
-            (match uu___ with
-             | (env2, td1) -> (env2, (FStar_Extraction_ML_Syntax.MLM_Ty td1)))
-        | FStar_Extraction_ML_Syntax.MLM_Let lb ->
-            let uu___ =
-              let uu___1 = elim_letbinding env1 lb in
-              FStar_Extraction_ML_Syntax.MLM_Let uu___1 in
-            (env1, uu___)
-        | FStar_Extraction_ML_Syntax.MLM_Exn (name, sym_tys) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_List.map
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | (s, t) ->
-                           let uu___4 = elim_mlty env1 t in (s, uu___4))
-                    sym_tys in
-                (name, uu___2) in
-              FStar_Extraction_ML_Syntax.MLM_Exn uu___1 in
-            (env1, uu___)
-        | FStar_Extraction_ML_Syntax.MLM_Top e ->
-            let uu___ =
-              let uu___1 = elim_mlexpr env1 e in
-              FStar_Extraction_ML_Syntax.MLM_Top uu___1 in
-            (env1, uu___)
-        | uu___ -> (env1, m1) in
-      let uu___ =
-        FStar_Compiler_List.fold_left
-          (fun uu___1 ->
-             fun m1 ->
-               match uu___1 with
-               | (env1, out) ->
-                   (try
-                      (fun uu___2 ->
-                         match () with
-                         | () ->
-                             let uu___3 = elim_module1 env1 m1 in
-                             (match uu___3 with
-                              | (env2, m2) -> (env2, (m2 :: out)))) ()
-                    with | Drop_tydef -> (env1, out))) (env, []) m in
-      match uu___ with | (env1, m1) -> (env1, (FStar_Compiler_List.rev m1))
-let (set_current_module :
-  env_t -> FStar_Extraction_ML_Syntax.mlpath -> env_t) =
-  fun e ->
-    fun n ->
-      let curmod =
-        FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst n)
-          [FStar_Pervasives_Native.snd n] in
-      { current_module = curmod; tydef_map = (e.tydef_map) }
-let (elim_mllib :
-  env_t ->
-    FStar_Extraction_ML_Syntax.mllib ->
-      (env_t * FStar_Extraction_ML_Syntax.mllib))
-  =
-  fun env ->
-    fun m ->
-      let uu___ =
-        let uu___1 = FStar_Options.codegen () in
-        uu___1 <> (FStar_Pervasives_Native.Some FStar_Options.FSharp) in
-      if uu___
-      then (env, m)
-      else
-        (let uu___2 = m in
-         match uu___2 with
-         | FStar_Extraction_ML_Syntax.MLLib libs ->
-             let elim_one_lib env1 lib =
-               let uu___3 = lib in
-               match uu___3 with
-               | (name, sig_mod, _libs) ->
-                   let env2 = set_current_module env1 name in
-                   let uu___4 =
-                     match sig_mod with
-                     | FStar_Pervasives_Native.Some (sig_, mod_) ->
-                         let uu___5 = elim_module env2 mod_ in
-                         (match uu___5 with
-                          | (env3, mod_1) ->
-                              ((FStar_Pervasives_Native.Some (sig_, mod_1)),
-                                env3))
-                     | FStar_Pervasives_Native.None ->
-                         (FStar_Pervasives_Native.None, env2) in
-                   (match uu___4 with
-                    | (sig_mod1, env3) -> (env3, (name, sig_mod1, _libs))) in
-             let uu___3 = FStar_Compiler_Util.fold_map elim_one_lib env libs in
-             (match uu___3 with
-              | (env1, libs1) ->
-                  (env1, (FStar_Extraction_ML_Syntax.MLLib libs1))))
-let (elim_mllibs :
-  FStar_Extraction_ML_Syntax.mllib Prims.list ->
-    FStar_Extraction_ML_Syntax.mllib Prims.list)
-  =
-  fun l ->
-    let uu___ = FStar_Compiler_Util.fold_map elim_mllib initial_env l in
-    FStar_Pervasives_Native.snd uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_Syntax.ml b/src/ocaml-output/FStar_Extraction_ML_Syntax.ml
deleted file mode 100644
index 5c0f5fd2ef3..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_Syntax.ml
+++ /dev/null
@@ -1,733 +0,0 @@
-open Prims
-type mlsymbol = Prims.string
-type mlident = mlsymbol
-type mlpath = (mlsymbol Prims.list * mlsymbol)
-let krml_keywords : 'uuuuu . unit -> 'uuuuu Prims.list = fun uu___ -> []
-let (ocamlkeywords : Prims.string Prims.list) =
-  ["and";
-  "as";
-  "assert";
-  "asr";
-  "begin";
-  "class";
-  "constraint";
-  "do";
-  "done";
-  "downto";
-  "else";
-  "end";
-  "exception";
-  "external";
-  "false";
-  "for";
-  "fun";
-  "function";
-  "functor";
-  "if";
-  "in";
-  "include";
-  "inherit";
-  "initializer";
-  "land";
-  "lazy";
-  "let";
-  "lor";
-  "lsl";
-  "lsr";
-  "lxor";
-  "match";
-  "method";
-  "mod";
-  "module";
-  "mutable";
-  "new";
-  "object";
-  "of";
-  "open";
-  "or";
-  "private";
-  "rec";
-  "sig";
-  "struct";
-  "then";
-  "to";
-  "true";
-  "try";
-  "type";
-  "val";
-  "virtual";
-  "when";
-  "while";
-  "with";
-  "nonrec"]
-let (fsharpkeywords : Prims.string Prims.list) =
-  ["abstract";
-  "and";
-  "as";
-  "assert";
-  "base";
-  "begin";
-  "class";
-  "default";
-  "delegate";
-  "do";
-  "done";
-  "downcast";
-  "downto";
-  "elif";
-  "else";
-  "end";
-  "exception";
-  "extern";
-  "false";
-  "finally";
-  "fixed";
-  "for";
-  "fun";
-  "function";
-  "global";
-  "if";
-  "in";
-  "inherit";
-  "inline";
-  "interface";
-  "internal";
-  "lazy";
-  "let";
-  "let!";
-  "match";
-  "member";
-  "module";
-  "mutable";
-  "namespace";
-  "new";
-  "not";
-  "null";
-  "of";
-  "open";
-  "or";
-  "override";
-  "private";
-  "public";
-  "rec";
-  "return";
-  "return!";
-  "select";
-  "static";
-  "struct";
-  "then";
-  "to";
-  "true";
-  "try";
-  "type";
-  "upcast";
-  "use";
-  "use!";
-  "val";
-  "void";
-  "when";
-  "while";
-  "with";
-  "yield";
-  "yield!";
-  "asr";
-  "land";
-  "lor";
-  "lsl";
-  "lsr";
-  "lxor";
-  "mod";
-  "sig";
-  "atomic";
-  "break";
-  "checked";
-  "component";
-  "const";
-  "constraint";
-  "constructor";
-  "continue";
-  "eager";
-  "event";
-  "external";
-  "fixed";
-  "functor";
-  "include";
-  "method";
-  "mixin";
-  "object";
-  "parallel";
-  "process";
-  "protected";
-  "pure";
-  "sealed";
-  "tailcall";
-  "trait";
-  "virtual";
-  "volatile"]
-let (string_of_mlpath : mlpath -> mlsymbol) =
-  fun uu___ ->
-    match uu___ with
-    | (p, s) -> FStar_String.concat "." (FStar_Compiler_List.op_At p [s])
-type mlidents = mlident Prims.list
-type mlsymbols = mlsymbol Prims.list
-type e_tag =
-  | E_PURE 
-  | E_ERASABLE 
-  | E_IMPURE 
-let (uu___is_E_PURE : e_tag -> Prims.bool) =
-  fun projectee -> match projectee with | E_PURE -> true | uu___ -> false
-let (uu___is_E_ERASABLE : e_tag -> Prims.bool) =
-  fun projectee -> match projectee with | E_ERASABLE -> true | uu___ -> false
-let (uu___is_E_IMPURE : e_tag -> Prims.bool) =
-  fun projectee -> match projectee with | E_IMPURE -> true | uu___ -> false
-type mlloc = (Prims.int * Prims.string)
-let (dummy_loc : mlloc) = (Prims.int_zero, "")
-type mlty =
-  | MLTY_Var of mlident 
-  | MLTY_Fun of (mlty * e_tag * mlty) 
-  | MLTY_Named of (mlty Prims.list * mlpath) 
-  | MLTY_Tuple of mlty Prims.list 
-  | MLTY_Top 
-  | MLTY_Erased 
-let (uu___is_MLTY_Var : mlty -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTY_Var _0 -> true | uu___ -> false
-let (__proj__MLTY_Var__item___0 : mlty -> mlident) =
-  fun projectee -> match projectee with | MLTY_Var _0 -> _0
-let (uu___is_MLTY_Fun : mlty -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTY_Fun _0 -> true | uu___ -> false
-let (__proj__MLTY_Fun__item___0 : mlty -> (mlty * e_tag * mlty)) =
-  fun projectee -> match projectee with | MLTY_Fun _0 -> _0
-let (uu___is_MLTY_Named : mlty -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTY_Named _0 -> true | uu___ -> false
-let (__proj__MLTY_Named__item___0 : mlty -> (mlty Prims.list * mlpath)) =
-  fun projectee -> match projectee with | MLTY_Named _0 -> _0
-let (uu___is_MLTY_Tuple : mlty -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTY_Tuple _0 -> true | uu___ -> false
-let (__proj__MLTY_Tuple__item___0 : mlty -> mlty Prims.list) =
-  fun projectee -> match projectee with | MLTY_Tuple _0 -> _0
-let (uu___is_MLTY_Top : mlty -> Prims.bool) =
-  fun projectee -> match projectee with | MLTY_Top -> true | uu___ -> false
-let (uu___is_MLTY_Erased : mlty -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTY_Erased -> true | uu___ -> false
-type mltyscheme = (mlidents * mlty)
-type mlconstant =
-  | MLC_Unit 
-  | MLC_Bool of Prims.bool 
-  | MLC_Int of (Prims.string * (FStar_Const.signedness * FStar_Const.width)
-  FStar_Pervasives_Native.option) 
-  | MLC_Float of FStar_BaseTypes.float 
-  | MLC_Char of FStar_BaseTypes.char 
-  | MLC_String of Prims.string 
-  | MLC_Bytes of FStar_BaseTypes.byte Prims.array 
-let (uu___is_MLC_Unit : mlconstant -> Prims.bool) =
-  fun projectee -> match projectee with | MLC_Unit -> true | uu___ -> false
-let (uu___is_MLC_Bool : mlconstant -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLC_Bool _0 -> true | uu___ -> false
-let (__proj__MLC_Bool__item___0 : mlconstant -> Prims.bool) =
-  fun projectee -> match projectee with | MLC_Bool _0 -> _0
-let (uu___is_MLC_Int : mlconstant -> Prims.bool) =
-  fun projectee -> match projectee with | MLC_Int _0 -> true | uu___ -> false
-let (__proj__MLC_Int__item___0 :
-  mlconstant ->
-    (Prims.string * (FStar_Const.signedness * FStar_Const.width)
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | MLC_Int _0 -> _0
-let (uu___is_MLC_Float : mlconstant -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLC_Float _0 -> true | uu___ -> false
-let (__proj__MLC_Float__item___0 : mlconstant -> FStar_BaseTypes.float) =
-  fun projectee -> match projectee with | MLC_Float _0 -> _0
-let (uu___is_MLC_Char : mlconstant -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLC_Char _0 -> true | uu___ -> false
-let (__proj__MLC_Char__item___0 : mlconstant -> FStar_BaseTypes.char) =
-  fun projectee -> match projectee with | MLC_Char _0 -> _0
-let (uu___is_MLC_String : mlconstant -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLC_String _0 -> true | uu___ -> false
-let (__proj__MLC_String__item___0 : mlconstant -> Prims.string) =
-  fun projectee -> match projectee with | MLC_String _0 -> _0
-let (uu___is_MLC_Bytes : mlconstant -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLC_Bytes _0 -> true | uu___ -> false
-let (__proj__MLC_Bytes__item___0 :
-  mlconstant -> FStar_BaseTypes.byte Prims.array) =
-  fun projectee -> match projectee with | MLC_Bytes _0 -> _0
-type mlpattern =
-  | MLP_Wild 
-  | MLP_Const of mlconstant 
-  | MLP_Var of mlident 
-  | MLP_CTor of (mlpath * mlpattern Prims.list) 
-  | MLP_Branch of mlpattern Prims.list 
-  | MLP_Record of (mlsymbol Prims.list * (mlsymbol * mlpattern) Prims.list) 
-  | MLP_Tuple of mlpattern Prims.list 
-let (uu___is_MLP_Wild : mlpattern -> Prims.bool) =
-  fun projectee -> match projectee with | MLP_Wild -> true | uu___ -> false
-let (uu___is_MLP_Const : mlpattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLP_Const _0 -> true | uu___ -> false
-let (__proj__MLP_Const__item___0 : mlpattern -> mlconstant) =
-  fun projectee -> match projectee with | MLP_Const _0 -> _0
-let (uu___is_MLP_Var : mlpattern -> Prims.bool) =
-  fun projectee -> match projectee with | MLP_Var _0 -> true | uu___ -> false
-let (__proj__MLP_Var__item___0 : mlpattern -> mlident) =
-  fun projectee -> match projectee with | MLP_Var _0 -> _0
-let (uu___is_MLP_CTor : mlpattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLP_CTor _0 -> true | uu___ -> false
-let (__proj__MLP_CTor__item___0 :
-  mlpattern -> (mlpath * mlpattern Prims.list)) =
-  fun projectee -> match projectee with | MLP_CTor _0 -> _0
-let (uu___is_MLP_Branch : mlpattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLP_Branch _0 -> true | uu___ -> false
-let (__proj__MLP_Branch__item___0 : mlpattern -> mlpattern Prims.list) =
-  fun projectee -> match projectee with | MLP_Branch _0 -> _0
-let (uu___is_MLP_Record : mlpattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLP_Record _0 -> true | uu___ -> false
-let (__proj__MLP_Record__item___0 :
-  mlpattern -> (mlsymbol Prims.list * (mlsymbol * mlpattern) Prims.list)) =
-  fun projectee -> match projectee with | MLP_Record _0 -> _0
-let (uu___is_MLP_Tuple : mlpattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLP_Tuple _0 -> true | uu___ -> false
-let (__proj__MLP_Tuple__item___0 : mlpattern -> mlpattern Prims.list) =
-  fun projectee -> match projectee with | MLP_Tuple _0 -> _0
-type meta =
-  | Mutable 
-  | Assumed 
-  | Private 
-  | NoExtract 
-  | CInline 
-  | Substitute 
-  | GCType 
-  | PpxDerivingShow 
-  | PpxDerivingShowConstant of Prims.string 
-  | PpxDerivingYoJson 
-  | Comment of Prims.string 
-  | StackInline 
-  | CPrologue of Prims.string 
-  | CEpilogue of Prims.string 
-  | CConst of Prims.string 
-  | CCConv of Prims.string 
-  | Erased 
-  | CAbstract 
-  | CIfDef 
-  | CMacro 
-  | Deprecated of Prims.string 
-  | RemoveUnusedTypeParameters of (Prims.int Prims.list *
-  FStar_Compiler_Range.range) 
-  | HasValDecl of FStar_Compiler_Range.range 
-let (uu___is_Mutable : meta -> Prims.bool) =
-  fun projectee -> match projectee with | Mutable -> true | uu___ -> false
-let (uu___is_Assumed : meta -> Prims.bool) =
-  fun projectee -> match projectee with | Assumed -> true | uu___ -> false
-let (uu___is_Private : meta -> Prims.bool) =
-  fun projectee -> match projectee with | Private -> true | uu___ -> false
-let (uu___is_NoExtract : meta -> Prims.bool) =
-  fun projectee -> match projectee with | NoExtract -> true | uu___ -> false
-let (uu___is_CInline : meta -> Prims.bool) =
-  fun projectee -> match projectee with | CInline -> true | uu___ -> false
-let (uu___is_Substitute : meta -> Prims.bool) =
-  fun projectee -> match projectee with | Substitute -> true | uu___ -> false
-let (uu___is_GCType : meta -> Prims.bool) =
-  fun projectee -> match projectee with | GCType -> true | uu___ -> false
-let (uu___is_PpxDerivingShow : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PpxDerivingShow -> true | uu___ -> false
-let (uu___is_PpxDerivingShowConstant : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | PpxDerivingShowConstant _0 -> true
-    | uu___ -> false
-let (__proj__PpxDerivingShowConstant__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | PpxDerivingShowConstant _0 -> _0
-let (uu___is_PpxDerivingYoJson : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PpxDerivingYoJson -> true | uu___ -> false
-let (uu___is_Comment : meta -> Prims.bool) =
-  fun projectee -> match projectee with | Comment _0 -> true | uu___ -> false
-let (__proj__Comment__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | Comment _0 -> _0
-let (uu___is_StackInline : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | StackInline -> true | uu___ -> false
-let (uu___is_CPrologue : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CPrologue _0 -> true | uu___ -> false
-let (__proj__CPrologue__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | CPrologue _0 -> _0
-let (uu___is_CEpilogue : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CEpilogue _0 -> true | uu___ -> false
-let (__proj__CEpilogue__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | CEpilogue _0 -> _0
-let (uu___is_CConst : meta -> Prims.bool) =
-  fun projectee -> match projectee with | CConst _0 -> true | uu___ -> false
-let (__proj__CConst__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | CConst _0 -> _0
-let (uu___is_CCConv : meta -> Prims.bool) =
-  fun projectee -> match projectee with | CCConv _0 -> true | uu___ -> false
-let (__proj__CCConv__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | CCConv _0 -> _0
-let (uu___is_Erased : meta -> Prims.bool) =
-  fun projectee -> match projectee with | Erased -> true | uu___ -> false
-let (uu___is_CAbstract : meta -> Prims.bool) =
-  fun projectee -> match projectee with | CAbstract -> true | uu___ -> false
-let (uu___is_CIfDef : meta -> Prims.bool) =
-  fun projectee -> match projectee with | CIfDef -> true | uu___ -> false
-let (uu___is_CMacro : meta -> Prims.bool) =
-  fun projectee -> match projectee with | CMacro -> true | uu___ -> false
-let (uu___is_Deprecated : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Deprecated _0 -> true | uu___ -> false
-let (__proj__Deprecated__item___0 : meta -> Prims.string) =
-  fun projectee -> match projectee with | Deprecated _0 -> _0
-let (uu___is_RemoveUnusedTypeParameters : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | RemoveUnusedTypeParameters _0 -> true
-    | uu___ -> false
-let (__proj__RemoveUnusedTypeParameters__item___0 :
-  meta -> (Prims.int Prims.list * FStar_Compiler_Range.range)) =
-  fun projectee -> match projectee with | RemoveUnusedTypeParameters _0 -> _0
-let (uu___is_HasValDecl : meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | HasValDecl _0 -> true | uu___ -> false
-let (__proj__HasValDecl__item___0 : meta -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | HasValDecl _0 -> _0
-type metadata = meta Prims.list
-type mlletflavor =
-  | Rec 
-  | NonRec 
-let (uu___is_Rec : mlletflavor -> Prims.bool) =
-  fun projectee -> match projectee with | Rec -> true | uu___ -> false
-let (uu___is_NonRec : mlletflavor -> Prims.bool) =
-  fun projectee -> match projectee with | NonRec -> true | uu___ -> false
-type mlexpr' =
-  | MLE_Const of mlconstant 
-  | MLE_Var of mlident 
-  | MLE_Name of mlpath 
-  | MLE_Let of ((mlletflavor * mllb Prims.list) * mlexpr) 
-  | MLE_App of (mlexpr * mlexpr Prims.list) 
-  | MLE_TApp of (mlexpr * mlty Prims.list) 
-  | MLE_Fun of ((mlident * mlty) Prims.list * mlexpr) 
-  | MLE_Match of (mlexpr * (mlpattern * mlexpr FStar_Pervasives_Native.option
-  * mlexpr) Prims.list) 
-  | MLE_Coerce of (mlexpr * mlty * mlty) 
-  | MLE_CTor of (mlpath * mlexpr Prims.list) 
-  | MLE_Seq of mlexpr Prims.list 
-  | MLE_Tuple of mlexpr Prims.list 
-  | MLE_Record of (mlsymbol Prims.list * (mlsymbol * mlexpr) Prims.list) 
-  | MLE_Proj of (mlexpr * mlpath) 
-  | MLE_If of (mlexpr * mlexpr * mlexpr FStar_Pervasives_Native.option) 
-  | MLE_Raise of (mlpath * mlexpr Prims.list) 
-  | MLE_Try of (mlexpr * (mlpattern * mlexpr FStar_Pervasives_Native.option *
-  mlexpr) Prims.list) 
-and mlexpr = {
-  expr: mlexpr' ;
-  mlty: mlty ;
-  loc: mlloc }
-and mllb =
-  {
-  mllb_name: mlident ;
-  mllb_tysc: mltyscheme FStar_Pervasives_Native.option ;
-  mllb_add_unit: Prims.bool ;
-  mllb_def: mlexpr ;
-  mllb_meta: metadata ;
-  print_typ: Prims.bool }
-let (uu___is_MLE_Const : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Const _0 -> true | uu___ -> false
-let (__proj__MLE_Const__item___0 : mlexpr' -> mlconstant) =
-  fun projectee -> match projectee with | MLE_Const _0 -> _0
-let (uu___is_MLE_Var : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_Var _0 -> true | uu___ -> false
-let (__proj__MLE_Var__item___0 : mlexpr' -> mlident) =
-  fun projectee -> match projectee with | MLE_Var _0 -> _0
-let (uu___is_MLE_Name : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Name _0 -> true | uu___ -> false
-let (__proj__MLE_Name__item___0 : mlexpr' -> mlpath) =
-  fun projectee -> match projectee with | MLE_Name _0 -> _0
-let (uu___is_MLE_Let : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_Let _0 -> true | uu___ -> false
-let (__proj__MLE_Let__item___0 :
-  mlexpr' -> ((mlletflavor * mllb Prims.list) * mlexpr)) =
-  fun projectee -> match projectee with | MLE_Let _0 -> _0
-let (uu___is_MLE_App : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_App _0 -> true | uu___ -> false
-let (__proj__MLE_App__item___0 : mlexpr' -> (mlexpr * mlexpr Prims.list)) =
-  fun projectee -> match projectee with | MLE_App _0 -> _0
-let (uu___is_MLE_TApp : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_TApp _0 -> true | uu___ -> false
-let (__proj__MLE_TApp__item___0 : mlexpr' -> (mlexpr * mlty Prims.list)) =
-  fun projectee -> match projectee with | MLE_TApp _0 -> _0
-let (uu___is_MLE_Fun : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_Fun _0 -> true | uu___ -> false
-let (__proj__MLE_Fun__item___0 :
-  mlexpr' -> ((mlident * mlty) Prims.list * mlexpr)) =
-  fun projectee -> match projectee with | MLE_Fun _0 -> _0
-let (uu___is_MLE_Match : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Match _0 -> true | uu___ -> false
-let (__proj__MLE_Match__item___0 :
-  mlexpr' ->
-    (mlexpr * (mlpattern * mlexpr FStar_Pervasives_Native.option * mlexpr)
-      Prims.list))
-  = fun projectee -> match projectee with | MLE_Match _0 -> _0
-let (uu___is_MLE_Coerce : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Coerce _0 -> true | uu___ -> false
-let (__proj__MLE_Coerce__item___0 : mlexpr' -> (mlexpr * mlty * mlty)) =
-  fun projectee -> match projectee with | MLE_Coerce _0 -> _0
-let (uu___is_MLE_CTor : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_CTor _0 -> true | uu___ -> false
-let (__proj__MLE_CTor__item___0 : mlexpr' -> (mlpath * mlexpr Prims.list)) =
-  fun projectee -> match projectee with | MLE_CTor _0 -> _0
-let (uu___is_MLE_Seq : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_Seq _0 -> true | uu___ -> false
-let (__proj__MLE_Seq__item___0 : mlexpr' -> mlexpr Prims.list) =
-  fun projectee -> match projectee with | MLE_Seq _0 -> _0
-let (uu___is_MLE_Tuple : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Tuple _0 -> true | uu___ -> false
-let (__proj__MLE_Tuple__item___0 : mlexpr' -> mlexpr Prims.list) =
-  fun projectee -> match projectee with | MLE_Tuple _0 -> _0
-let (uu___is_MLE_Record : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Record _0 -> true | uu___ -> false
-let (__proj__MLE_Record__item___0 :
-  mlexpr' -> (mlsymbol Prims.list * (mlsymbol * mlexpr) Prims.list)) =
-  fun projectee -> match projectee with | MLE_Record _0 -> _0
-let (uu___is_MLE_Proj : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Proj _0 -> true | uu___ -> false
-let (__proj__MLE_Proj__item___0 : mlexpr' -> (mlexpr * mlpath)) =
-  fun projectee -> match projectee with | MLE_Proj _0 -> _0
-let (uu___is_MLE_If : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_If _0 -> true | uu___ -> false
-let (__proj__MLE_If__item___0 :
-  mlexpr' -> (mlexpr * mlexpr * mlexpr FStar_Pervasives_Native.option)) =
-  fun projectee -> match projectee with | MLE_If _0 -> _0
-let (uu___is_MLE_Raise : mlexpr' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLE_Raise _0 -> true | uu___ -> false
-let (__proj__MLE_Raise__item___0 : mlexpr' -> (mlpath * mlexpr Prims.list)) =
-  fun projectee -> match projectee with | MLE_Raise _0 -> _0
-let (uu___is_MLE_Try : mlexpr' -> Prims.bool) =
-  fun projectee -> match projectee with | MLE_Try _0 -> true | uu___ -> false
-let (__proj__MLE_Try__item___0 :
-  mlexpr' ->
-    (mlexpr * (mlpattern * mlexpr FStar_Pervasives_Native.option * mlexpr)
-      Prims.list))
-  = fun projectee -> match projectee with | MLE_Try _0 -> _0
-let (__proj__Mkmlexpr__item__expr : mlexpr -> mlexpr') =
-  fun projectee ->
-    match projectee with | { expr; mlty = mlty1; loc;_} -> expr
-let (__proj__Mkmlexpr__item__mlty : mlexpr -> mlty) =
-  fun projectee ->
-    match projectee with | { expr; mlty = mlty1; loc;_} -> mlty1
-let (__proj__Mkmlexpr__item__loc : mlexpr -> mlloc) =
-  fun projectee -> match projectee with | { expr; mlty = mlty1; loc;_} -> loc
-let (__proj__Mkmllb__item__mllb_name : mllb -> mlident) =
-  fun projectee ->
-    match projectee with
-    | { mllb_name; mllb_tysc; mllb_add_unit; mllb_def; mllb_meta;
-        print_typ;_} -> mllb_name
-let (__proj__Mkmllb__item__mllb_tysc :
-  mllb -> mltyscheme FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { mllb_name; mllb_tysc; mllb_add_unit; mllb_def; mllb_meta;
-        print_typ;_} -> mllb_tysc
-let (__proj__Mkmllb__item__mllb_add_unit : mllb -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { mllb_name; mllb_tysc; mllb_add_unit; mllb_def; mllb_meta;
-        print_typ;_} -> mllb_add_unit
-let (__proj__Mkmllb__item__mllb_def : mllb -> mlexpr) =
-  fun projectee ->
-    match projectee with
-    | { mllb_name; mllb_tysc; mllb_add_unit; mllb_def; mllb_meta;
-        print_typ;_} -> mllb_def
-let (__proj__Mkmllb__item__mllb_meta : mllb -> metadata) =
-  fun projectee ->
-    match projectee with
-    | { mllb_name; mllb_tysc; mllb_add_unit; mllb_def; mllb_meta;
-        print_typ;_} -> mllb_meta
-let (__proj__Mkmllb__item__print_typ : mllb -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { mllb_name; mllb_tysc; mllb_add_unit; mllb_def; mllb_meta;
-        print_typ;_} -> print_typ
-type mlbranch = (mlpattern * mlexpr FStar_Pervasives_Native.option * mlexpr)
-type mlletbinding = (mlletflavor * mllb Prims.list)
-type mltybody =
-  | MLTD_Abbrev of mlty 
-  | MLTD_Record of (mlsymbol * mlty) Prims.list 
-  | MLTD_DType of (mlsymbol * (mlsymbol * mlty) Prims.list) Prims.list 
-let (uu___is_MLTD_Abbrev : mltybody -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTD_Abbrev _0 -> true | uu___ -> false
-let (__proj__MLTD_Abbrev__item___0 : mltybody -> mlty) =
-  fun projectee -> match projectee with | MLTD_Abbrev _0 -> _0
-let (uu___is_MLTD_Record : mltybody -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTD_Record _0 -> true | uu___ -> false
-let (__proj__MLTD_Record__item___0 :
-  mltybody -> (mlsymbol * mlty) Prims.list) =
-  fun projectee -> match projectee with | MLTD_Record _0 -> _0
-let (uu___is_MLTD_DType : mltybody -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MLTD_DType _0 -> true | uu___ -> false
-let (__proj__MLTD_DType__item___0 :
-  mltybody -> (mlsymbol * (mlsymbol * mlty) Prims.list) Prims.list) =
-  fun projectee -> match projectee with | MLTD_DType _0 -> _0
-type one_mltydecl =
-  {
-  tydecl_assumed: Prims.bool ;
-  tydecl_name: mlsymbol ;
-  tydecl_ignored: mlsymbol FStar_Pervasives_Native.option ;
-  tydecl_parameters: mlidents ;
-  tydecl_meta: metadata ;
-  tydecl_defn: mltybody FStar_Pervasives_Native.option }
-let (__proj__Mkone_mltydecl__item__tydecl_assumed :
-  one_mltydecl -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { tydecl_assumed; tydecl_name; tydecl_ignored; tydecl_parameters;
-        tydecl_meta; tydecl_defn;_} -> tydecl_assumed
-let (__proj__Mkone_mltydecl__item__tydecl_name : one_mltydecl -> mlsymbol) =
-  fun projectee ->
-    match projectee with
-    | { tydecl_assumed; tydecl_name; tydecl_ignored; tydecl_parameters;
-        tydecl_meta; tydecl_defn;_} -> tydecl_name
-let (__proj__Mkone_mltydecl__item__tydecl_ignored :
-  one_mltydecl -> mlsymbol FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { tydecl_assumed; tydecl_name; tydecl_ignored; tydecl_parameters;
-        tydecl_meta; tydecl_defn;_} -> tydecl_ignored
-let (__proj__Mkone_mltydecl__item__tydecl_parameters :
-  one_mltydecl -> mlidents) =
-  fun projectee ->
-    match projectee with
-    | { tydecl_assumed; tydecl_name; tydecl_ignored; tydecl_parameters;
-        tydecl_meta; tydecl_defn;_} -> tydecl_parameters
-let (__proj__Mkone_mltydecl__item__tydecl_meta : one_mltydecl -> metadata) =
-  fun projectee ->
-    match projectee with
-    | { tydecl_assumed; tydecl_name; tydecl_ignored; tydecl_parameters;
-        tydecl_meta; tydecl_defn;_} -> tydecl_meta
-let (__proj__Mkone_mltydecl__item__tydecl_defn :
-  one_mltydecl -> mltybody FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { tydecl_assumed; tydecl_name; tydecl_ignored; tydecl_parameters;
-        tydecl_meta; tydecl_defn;_} -> tydecl_defn
-type mltydecl = one_mltydecl Prims.list
-type mlmodule1 =
-  | MLM_Ty of mltydecl 
-  | MLM_Let of mlletbinding 
-  | MLM_Exn of (mlsymbol * (mlsymbol * mlty) Prims.list) 
-  | MLM_Top of mlexpr 
-  | MLM_Loc of mlloc 
-let (uu___is_MLM_Ty : mlmodule1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLM_Ty _0 -> true | uu___ -> false
-let (__proj__MLM_Ty__item___0 : mlmodule1 -> mltydecl) =
-  fun projectee -> match projectee with | MLM_Ty _0 -> _0
-let (uu___is_MLM_Let : mlmodule1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLM_Let _0 -> true | uu___ -> false
-let (__proj__MLM_Let__item___0 : mlmodule1 -> mlletbinding) =
-  fun projectee -> match projectee with | MLM_Let _0 -> _0
-let (uu___is_MLM_Exn : mlmodule1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLM_Exn _0 -> true | uu___ -> false
-let (__proj__MLM_Exn__item___0 :
-  mlmodule1 -> (mlsymbol * (mlsymbol * mlty) Prims.list)) =
-  fun projectee -> match projectee with | MLM_Exn _0 -> _0
-let (uu___is_MLM_Top : mlmodule1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLM_Top _0 -> true | uu___ -> false
-let (__proj__MLM_Top__item___0 : mlmodule1 -> mlexpr) =
-  fun projectee -> match projectee with | MLM_Top _0 -> _0
-let (uu___is_MLM_Loc : mlmodule1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLM_Loc _0 -> true | uu___ -> false
-let (__proj__MLM_Loc__item___0 : mlmodule1 -> mlloc) =
-  fun projectee -> match projectee with | MLM_Loc _0 -> _0
-type mlmodule = mlmodule1 Prims.list
-type mlsig1 =
-  | MLS_Mod of (mlsymbol * mlsig1 Prims.list) 
-  | MLS_Ty of mltydecl 
-  | MLS_Val of (mlsymbol * mltyscheme) 
-  | MLS_Exn of (mlsymbol * mlty Prims.list) 
-let (uu___is_MLS_Mod : mlsig1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLS_Mod _0 -> true | uu___ -> false
-let (__proj__MLS_Mod__item___0 : mlsig1 -> (mlsymbol * mlsig1 Prims.list)) =
-  fun projectee -> match projectee with | MLS_Mod _0 -> _0
-let (uu___is_MLS_Ty : mlsig1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLS_Ty _0 -> true | uu___ -> false
-let (__proj__MLS_Ty__item___0 : mlsig1 -> mltydecl) =
-  fun projectee -> match projectee with | MLS_Ty _0 -> _0
-let (uu___is_MLS_Val : mlsig1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLS_Val _0 -> true | uu___ -> false
-let (__proj__MLS_Val__item___0 : mlsig1 -> (mlsymbol * mltyscheme)) =
-  fun projectee -> match projectee with | MLS_Val _0 -> _0
-let (uu___is_MLS_Exn : mlsig1 -> Prims.bool) =
-  fun projectee -> match projectee with | MLS_Exn _0 -> true | uu___ -> false
-let (__proj__MLS_Exn__item___0 : mlsig1 -> (mlsymbol * mlty Prims.list)) =
-  fun projectee -> match projectee with | MLS_Exn _0 -> _0
-type mlsig = mlsig1 Prims.list
-let (with_ty_loc : mlty -> mlexpr' -> mlloc -> mlexpr) =
-  fun t -> fun e -> fun l -> { expr = e; mlty = t; loc = l }
-let (with_ty : mlty -> mlexpr' -> mlexpr) =
-  fun t -> fun e -> with_ty_loc t e dummy_loc
-type mllib =
-  | MLLib of (mlpath * (mlsig * mlmodule) FStar_Pervasives_Native.option *
-  mllib) Prims.list 
-let (uu___is_MLLib : mllib -> Prims.bool) = fun projectee -> true
-let (__proj__MLLib__item___0 :
-  mllib ->
-    (mlpath * (mlsig * mlmodule) FStar_Pervasives_Native.option * mllib)
-      Prims.list)
-  = fun projectee -> match projectee with | MLLib _0 -> _0
-let (ml_unit_ty : mlty) = MLTY_Erased
-let (ml_bool_ty : mlty) = MLTY_Named ([], (["Prims"], "bool"))
-let (ml_int_ty : mlty) = MLTY_Named ([], (["Prims"], "int"))
-let (ml_string_ty : mlty) = MLTY_Named ([], (["Prims"], "string"))
-let (ml_unit : mlexpr) = with_ty ml_unit_ty (MLE_Const MLC_Unit)
-let (mlp_lalloc : (Prims.string Prims.list * Prims.string)) =
-  (["SST"], "lalloc")
-let (apply_obj_repr : mlexpr -> mlty -> mlexpr) =
-  fun x ->
-    fun t ->
-      let repr_name =
-        let uu___ =
-          let uu___1 = FStar_Options.codegen () in
-          uu___1 = (FStar_Pervasives_Native.Some FStar_Options.FSharp) in
-        if uu___ then MLE_Name ([], "box") else MLE_Name (["Obj"], "repr") in
-      let obj_repr = with_ty (MLTY_Fun (t, E_PURE, MLTY_Top)) repr_name in
-      with_ty_loc MLTY_Top (MLE_App (obj_repr, [x])) x.loc
-let (push_unit : mltyscheme -> mltyscheme) =
-  fun ts ->
-    let uu___ = ts in
-    match uu___ with | (vs, ty) -> (vs, (MLTY_Fun (ml_unit_ty, E_PURE, ty)))
-let (pop_unit : mltyscheme -> mltyscheme) =
-  fun ts ->
-    let uu___ = ts in
-    match uu___ with
-    | (vs, ty) ->
-        (match ty with
-         | MLTY_Fun (l, E_PURE, t) ->
-             if l = ml_unit_ty
-             then (vs, t)
-             else failwith "unexpected: pop_unit: domain was not unit"
-         | uu___1 -> failwith "unexpected: pop_unit: not a function type")
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_Term.ml b/src/ocaml-output/FStar_Extraction_ML_Term.ml
deleted file mode 100644
index a606557ea59..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_Term.ml
+++ /dev/null
@@ -1,4279 +0,0 @@
-open Prims
-exception Un_extractable 
-let (uu___is_Un_extractable : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Un_extractable -> true | uu___ -> false
-let (type_leq :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      FStar_Extraction_ML_Syntax.mlty -> Prims.bool)
-  =
-  fun g ->
-    fun t1 ->
-      fun t2 ->
-        FStar_Extraction_ML_Util.type_leq
-          (FStar_Extraction_ML_Util.udelta_unfold g) t1 t2
-let (type_leq_c :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option ->
-      FStar_Extraction_ML_Syntax.mlty ->
-        FStar_Extraction_ML_Syntax.mlty ->
-          (Prims.bool * FStar_Extraction_ML_Syntax.mlexpr
-            FStar_Pervasives_Native.option))
-  =
-  fun g ->
-    fun t1 ->
-      fun t2 ->
-        FStar_Extraction_ML_Util.type_leq_c
-          (FStar_Extraction_ML_Util.udelta_unfold g) t1 t2
-let (eraseTypeDeep :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun g ->
-    fun t ->
-      FStar_Extraction_ML_Util.eraseTypeDeep
-        (FStar_Extraction_ML_Util.udelta_unfold g) t
-let fail :
-  'uuuuu .
-    FStar_Compiler_Range.range ->
-      (FStar_Errors.raw_error * Prims.string) -> 'uuuuu
-  = fun r -> fun err -> FStar_Errors.raise_error err r
-let err_ill_typed_application :
-  'uuuuu 'uuuuu1 .
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Extraction_ML_Syntax.mlexpr ->
-          (FStar_Syntax_Syntax.term * 'uuuuu) Prims.list ->
-            FStar_Extraction_ML_Syntax.mlty -> 'uuuuu1
-  =
-  fun env ->
-    fun t ->
-      fun mlhead ->
-        fun args ->
-          fun ty ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string t in
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Extraction_ML_UEnv.current_module_of_uenv env in
-                  FStar_Extraction_ML_Code.string_of_mlexpr uu___4 mlhead in
-                let uu___4 =
-                  let uu___5 =
-                    FStar_Extraction_ML_UEnv.current_module_of_uenv env in
-                  FStar_Extraction_ML_Code.string_of_mlty uu___5 ty in
-                let uu___5 =
-                  let uu___6 =
-                    FStar_Compiler_Effect.op_Bar_Greater args
-                      (FStar_Compiler_List.map
-                         (fun uu___7 ->
-                            match uu___7 with
-                            | (x, uu___8) ->
-                                FStar_Syntax_Print.term_to_string x)) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___6
-                    (FStar_String.concat " ") in
-                FStar_Compiler_Util.format4
-                  "Ill-typed application: source application is %s \n translated prefix to %s at type %s\n remaining args are %s\n"
-                  uu___2 uu___3 uu___4 uu___5 in
-              (FStar_Errors.Fatal_IllTyped, uu___1) in
-            fail t.FStar_Syntax_Syntax.pos uu___
-let err_ill_typed_erasure :
-  'uuuuu .
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Compiler_Range.range -> FStar_Extraction_ML_Syntax.mlty -> 'uuuuu
-  =
-  fun env ->
-    fun pos ->
-      fun ty ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Extraction_ML_UEnv.current_module_of_uenv env in
-              FStar_Extraction_ML_Code.string_of_mlty uu___3 ty in
-            FStar_Compiler_Util.format1
-              "Erased value found where a value of type %s was expected"
-              uu___2 in
-          (FStar_Errors.Fatal_IllTyped, uu___1) in
-        fail pos uu___
-let err_value_restriction :
-  'uuuuu . FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> 'uuuuu =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_Syntax_Print.tag_of_term t in
-        let uu___3 = FStar_Syntax_Print.term_to_string t in
-        FStar_Compiler_Util.format2
-          "Refusing to generalize because of the value restriction: (%s) %s"
-          uu___2 uu___3 in
-      (FStar_Errors.Fatal_ValueRestriction, uu___1) in
-    fail t.FStar_Syntax_Syntax.pos uu___
-let (err_unexpected_eff :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Extraction_ML_Syntax.mlty ->
-        FStar_Extraction_ML_Syntax.e_tag ->
-          FStar_Extraction_ML_Syntax.e_tag -> unit)
-  =
-  fun env ->
-    fun t ->
-      fun ty ->
-        fun f0 ->
-          fun f1 ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string t in
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Extraction_ML_UEnv.current_module_of_uenv env in
-                  FStar_Extraction_ML_Code.string_of_mlty uu___4 ty in
-                let uu___4 = FStar_Extraction_ML_Util.eff_to_string f0 in
-                let uu___5 = FStar_Extraction_ML_Util.eff_to_string f1 in
-                FStar_Compiler_Util.format4
-                  "for expression %s of type %s, Expected effect %s; got effect %s"
-                  uu___2 uu___3 uu___4 uu___5 in
-              (FStar_Errors.Warning_ExtractionUnexpectedEffect, uu___1) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___
-let (effect_as_etag :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Ident.lident -> FStar_Extraction_ML_Syntax.e_tag)
-  =
-  let cache = FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-  let rec delta_norm_eff g l =
-    let uu___ =
-      let uu___1 = FStar_Ident.string_of_lid l in
-      FStar_Compiler_Util.smap_try_find cache uu___1 in
-    match uu___ with
-    | FStar_Pervasives_Native.Some l1 -> l1
-    | FStar_Pervasives_Native.None ->
-        let res =
-          let uu___1 =
-            let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-            FStar_TypeChecker_Env.lookup_effect_abbrev uu___2
-              [FStar_Syntax_Syntax.U_zero] l in
-          match uu___1 with
-          | FStar_Pervasives_Native.None -> l
-          | FStar_Pervasives_Native.Some (uu___2, c) ->
-              delta_norm_eff g (FStar_Syntax_Util.comp_effect_name c) in
-        ((let uu___2 = FStar_Ident.string_of_lid l in
-          FStar_Compiler_Util.smap_add cache uu___2 res);
-         res) in
-  fun g ->
-    fun l ->
-      let l1 = delta_norm_eff g l in
-      let uu___ =
-        FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_PURE_lid in
-      if uu___
-      then FStar_Extraction_ML_Syntax.E_PURE
-      else
-        (let uu___2 =
-           let uu___3 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-           FStar_TypeChecker_Env.is_erasable_effect uu___3 l1 in
-         if uu___2
-         then FStar_Extraction_ML_Syntax.E_ERASABLE
-         else
-           (let ed_opt =
-              let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-              FStar_TypeChecker_Env.effect_decl_opt uu___4 l1 in
-            match ed_opt with
-            | FStar_Pervasives_Native.Some (ed, qualifiers) ->
-                let uu___4 =
-                  let uu___5 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                  FStar_TypeChecker_Env.is_reifiable_effect uu___5
-                    ed.FStar_Syntax_Syntax.mname in
-                if uu___4
-                then FStar_Extraction_ML_Syntax.E_PURE
-                else FStar_Extraction_ML_Syntax.E_IMPURE
-            | FStar_Pervasives_Native.None ->
-                FStar_Extraction_ML_Syntax.E_IMPURE))
-let rec (is_arity :
-  FStar_Extraction_ML_UEnv.uenv -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      let t1 = FStar_Syntax_Util.unmeta t in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t1 in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_unknown -> failwith "Impossible"
-      | FStar_Syntax_Syntax.Tm_delayed uu___1 -> failwith "Impossible"
-      | FStar_Syntax_Syntax.Tm_ascribed uu___1 -> failwith "Impossible"
-      | FStar_Syntax_Syntax.Tm_meta uu___1 -> failwith "Impossible"
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___1 = FStar_Syntax_Util.unfold_lazy i in is_arity env uu___1
-      | FStar_Syntax_Syntax.Tm_uvar uu___1 -> false
-      | FStar_Syntax_Syntax.Tm_constant uu___1 -> false
-      | FStar_Syntax_Syntax.Tm_name uu___1 -> false
-      | FStar_Syntax_Syntax.Tm_quoted uu___1 -> false
-      | FStar_Syntax_Syntax.Tm_bvar uu___1 -> false
-      | FStar_Syntax_Syntax.Tm_type uu___1 -> true
-      | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-          is_arity env (FStar_Syntax_Util.comp_result c)
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let topt =
-            let uu___1 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-            FStar_TypeChecker_Env.lookup_definition
-              [FStar_TypeChecker_Env.Unfold
-                 FStar_Syntax_Syntax.delta_constant] uu___1
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match topt with
-           | FStar_Pervasives_Native.None -> false
-           | FStar_Pervasives_Native.Some (uu___1, t2) -> is_arity env t2)
-      | FStar_Syntax_Syntax.Tm_app uu___1 ->
-          let uu___2 = FStar_Syntax_Util.head_and_args t1 in
-          (match uu___2 with | (head, uu___3) -> is_arity env head)
-      | FStar_Syntax_Syntax.Tm_uinst (head, uu___1) -> is_arity env head
-      | FStar_Syntax_Syntax.Tm_refine (x, uu___1) ->
-          is_arity env x.FStar_Syntax_Syntax.sort
-      | FStar_Syntax_Syntax.Tm_abs (uu___1, body, uu___2) ->
-          is_arity env body
-      | FStar_Syntax_Syntax.Tm_let (uu___1, body) -> is_arity env body
-      | FStar_Syntax_Syntax.Tm_match (uu___1, uu___2, branches, uu___3) ->
-          (match branches with
-           | (uu___4, uu___5, e)::uu___6 -> is_arity env e
-           | uu___4 -> false)
-let rec (is_type_aux :
-  FStar_Extraction_ML_UEnv.uenv -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      let t1 = FStar_Syntax_Subst.compress t in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.tag_of_term t1 in
-            FStar_Compiler_Util.format1 "Impossible: %s" uu___2 in
-          failwith uu___1
-      | FStar_Syntax_Syntax.Tm_unknown ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Print.tag_of_term t1 in
-            FStar_Compiler_Util.format1 "Impossible: %s" uu___1 in
-          failwith uu___
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___ = FStar_Syntax_Util.unfold_lazy i in
-          is_type_aux env uu___
-      | FStar_Syntax_Syntax.Tm_constant uu___ -> false
-      | FStar_Syntax_Syntax.Tm_type uu___ -> true
-      | FStar_Syntax_Syntax.Tm_refine uu___ -> true
-      | FStar_Syntax_Syntax.Tm_arrow uu___ -> true
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          let uu___ = FStar_Parser_Const.failwith_lid () in
-          FStar_Syntax_Syntax.fv_eq_lid fv uu___ -> false
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          FStar_Extraction_ML_UEnv.is_type_name env fv
-      | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-          let t2 = FStar_Syntax_Util.ctx_uvar_typ u in
-          let uu___ = FStar_Syntax_Subst.subst' s t2 in is_arity env uu___
-      | FStar_Syntax_Syntax.Tm_bvar
-          { FStar_Syntax_Syntax.ppname = uu___;
-            FStar_Syntax_Syntax.index = uu___1;
-            FStar_Syntax_Syntax.sort = t2;_}
-          -> is_arity env t2
-      | FStar_Syntax_Syntax.Tm_name
-          { FStar_Syntax_Syntax.ppname = uu___;
-            FStar_Syntax_Syntax.index = uu___1;
-            FStar_Syntax_Syntax.sort = t2;_}
-          -> is_arity env t2
-      | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___, uu___1) ->
-          is_type_aux env t2
-      | FStar_Syntax_Syntax.Tm_uinst (t2, uu___) -> is_type_aux env t2
-      | FStar_Syntax_Syntax.Tm_abs (bs, body, uu___) ->
-          let uu___1 = FStar_Syntax_Subst.open_term bs body in
-          (match uu___1 with | (uu___2, body1) -> is_type_aux env body1)
-      | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-          let x = FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Syntax.mk_binder x in [uu___2] in
-            FStar_Syntax_Subst.open_term uu___1 body in
-          (match uu___ with | (uu___1, body1) -> is_type_aux env body1)
-      | FStar_Syntax_Syntax.Tm_let ((uu___, lbs), body) ->
-          let uu___1 = FStar_Syntax_Subst.open_let_rec lbs body in
-          (match uu___1 with | (uu___2, body1) -> is_type_aux env body1)
-      | FStar_Syntax_Syntax.Tm_match (uu___, uu___1, branches, uu___2) ->
-          (match branches with
-           | b::uu___3 ->
-               let uu___4 = FStar_Syntax_Subst.open_branch b in
-               (match uu___4 with | (uu___5, uu___6, e) -> is_type_aux env e)
-           | uu___3 -> false)
-      | FStar_Syntax_Syntax.Tm_quoted uu___ -> false
-      | FStar_Syntax_Syntax.Tm_meta (t2, uu___) -> is_type_aux env t2
-      | FStar_Syntax_Syntax.Tm_app (head, uu___) -> is_type_aux env head
-let (is_type :
-  FStar_Extraction_ML_UEnv.uenv -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      FStar_Extraction_ML_UEnv.debug env
-        (fun uu___1 ->
-           let uu___2 = FStar_Syntax_Print.tag_of_term t in
-           let uu___3 = FStar_Syntax_Print.term_to_string t in
-           FStar_Compiler_Util.print2 "checking is_type (%s) %s\n" uu___2
-             uu___3);
-      (let b = is_type_aux env t in
-       FStar_Extraction_ML_UEnv.debug env
-         (fun uu___2 ->
-            if b
-            then
-              let uu___3 = FStar_Syntax_Print.term_to_string t in
-              let uu___4 = FStar_Syntax_Print.tag_of_term t in
-              FStar_Compiler_Util.print2 "yes, is_type %s (%s)\n" uu___3
-                uu___4
-            else
-              (let uu___4 = FStar_Syntax_Print.term_to_string t in
-               let uu___5 = FStar_Syntax_Print.tag_of_term t in
-               FStar_Compiler_Util.print2 "not a type %s (%s)\n" uu___4
-                 uu___5));
-       b)
-let (is_steel_with_invariant_g : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst head in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            _a::_fp::_fp'::_o::_p::_i::_body::[]) ->
-             (FStar_Syntax_Syntax.fv_eq_lid fv
-                FStar_Parser_Const.steel_with_invariant_g_lid)
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.steel_st_with_invariant_g_lid)
-         | uu___2 -> false)
-let (is_steel_with_invariant :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst head in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            _a::_fp::_fp'::_o::_obs::_p::_i::body::[]) when
-             (FStar_Syntax_Syntax.fv_eq_lid fv
-                FStar_Parser_Const.steel_with_invariant_lid)
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.steel_st_with_invariant_lid)
-             ->
-             FStar_Pervasives_Native.Some (FStar_Pervasives_Native.fst body)
-         | uu___2 -> FStar_Pervasives_Native.None)
-let (is_steel_new_invariant : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst head in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, _o::_p::[]) ->
-             (FStar_Syntax_Syntax.fv_eq_lid fv
-                FStar_Parser_Const.steel_new_invariant_lid)
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.steel_st_new_invariant_lid)
-         | uu___2 -> false)
-let (is_type_binder :
-  FStar_Extraction_ML_UEnv.uenv -> FStar_Syntax_Syntax.binder -> Prims.bool)
-  =
-  fun env ->
-    fun x ->
-      is_arity env (x.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-let (is_constructor : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar
-        { FStar_Syntax_Syntax.fv_name = uu___1;
-          FStar_Syntax_Syntax.fv_delta = uu___2;
-          FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-            (FStar_Syntax_Syntax.Data_ctor);_}
-        -> true
-    | FStar_Syntax_Syntax.Tm_fvar
-        { FStar_Syntax_Syntax.fv_name = uu___1;
-          FStar_Syntax_Syntax.fv_delta = uu___2;
-          FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-            (FStar_Syntax_Syntax.Record_ctor uu___3);_}
-        -> true
-    | uu___1 -> false
-let rec (is_fstar_value : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_constant uu___1 -> true
-    | FStar_Syntax_Syntax.Tm_bvar uu___1 -> true
-    | FStar_Syntax_Syntax.Tm_fvar uu___1 -> true
-    | FStar_Syntax_Syntax.Tm_abs uu___1 -> true
-    | FStar_Syntax_Syntax.Tm_app (head, args) ->
-        let uu___1 = is_constructor head in
-        if uu___1
-        then
-          FStar_Compiler_Effect.op_Bar_Greater args
-            (FStar_Compiler_List.for_all
-               (fun uu___2 ->
-                  match uu___2 with | (te, uu___3) -> is_fstar_value te))
-        else false
-    | FStar_Syntax_Syntax.Tm_meta (t1, uu___1) -> is_fstar_value t1
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, uu___1, uu___2) ->
-        is_fstar_value t1
-    | uu___1 -> false
-let rec (is_ml_value : FStar_Extraction_ML_Syntax.mlexpr -> Prims.bool) =
-  fun e ->
-    match e.FStar_Extraction_ML_Syntax.expr with
-    | FStar_Extraction_ML_Syntax.MLE_Const uu___ -> true
-    | FStar_Extraction_ML_Syntax.MLE_Var uu___ -> true
-    | FStar_Extraction_ML_Syntax.MLE_Name uu___ -> true
-    | FStar_Extraction_ML_Syntax.MLE_Fun uu___ -> true
-    | FStar_Extraction_ML_Syntax.MLE_CTor (uu___, exps) ->
-        FStar_Compiler_Util.for_all is_ml_value exps
-    | FStar_Extraction_ML_Syntax.MLE_Tuple exps ->
-        FStar_Compiler_Util.for_all is_ml_value exps
-    | FStar_Extraction_ML_Syntax.MLE_Record (uu___, fields) ->
-        FStar_Compiler_Util.for_all
-          (fun uu___1 -> match uu___1 with | (uu___2, e1) -> is_ml_value e1)
-          fields
-    | FStar_Extraction_ML_Syntax.MLE_TApp (h, uu___) -> is_ml_value h
-    | uu___ -> false
-let (normalize_abs : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t0 ->
-    let rec aux bs t copt =
-      let t1 = FStar_Syntax_Subst.compress t in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_abs (bs', body, copt1) ->
-          aux (FStar_Compiler_List.op_At bs bs') body copt1
-      | uu___ ->
-          let e' = FStar_Syntax_Util.unascribe t1 in
-          let uu___1 = FStar_Syntax_Util.is_fun e' in
-          if uu___1 then aux bs e' copt else FStar_Syntax_Util.abs bs e' copt in
-    aux [] t0 FStar_Pervasives_Native.None
-let (unit_binder : unit -> FStar_Syntax_Syntax.binder) =
-  fun uu___ ->
-    let uu___1 =
-      FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-        FStar_Syntax_Syntax.t_unit in
-    FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_binder uu___1
-let (check_pats_for_ite :
-  (FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.term
-    FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term) Prims.list ->
-    (Prims.bool * FStar_Syntax_Syntax.term FStar_Pervasives_Native.option *
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option))
-  =
-  fun l ->
-    let def =
-      (false, FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) in
-    if (FStar_Compiler_List.length l) <> (Prims.of_int (2))
-    then def
-    else
-      (let uu___1 = FStar_Compiler_List.hd l in
-       match uu___1 with
-       | (p1, w1, e1) ->
-           let uu___2 =
-             let uu___3 = FStar_Compiler_List.tl l in
-             FStar_Compiler_List.hd uu___3 in
-           (match uu___2 with
-            | (p2, w2, e2) ->
-                (match (w1, w2, (p1.FStar_Syntax_Syntax.v),
-                         (p2.FStar_Syntax_Syntax.v))
-                 with
-                 | (FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.None,
-                    FStar_Syntax_Syntax.Pat_constant (FStar_Const.Const_bool
-                    (true)), FStar_Syntax_Syntax.Pat_constant
-                    (FStar_Const.Const_bool (false))) ->
-                     (true, (FStar_Pervasives_Native.Some e1),
-                       (FStar_Pervasives_Native.Some e2))
-                 | (FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.None,
-                    FStar_Syntax_Syntax.Pat_constant (FStar_Const.Const_bool
-                    (false)), FStar_Syntax_Syntax.Pat_constant
-                    (FStar_Const.Const_bool (true))) ->
-                     (true, (FStar_Pervasives_Native.Some e2),
-                       (FStar_Pervasives_Native.Some e1))
-                 | uu___3 -> def)))
-let (instantiate_tyscheme :
-  FStar_Extraction_ML_Syntax.mltyscheme ->
-    FStar_Extraction_ML_Syntax.mlty Prims.list ->
-      FStar_Extraction_ML_Syntax.mlty)
-  = fun s -> fun args -> FStar_Extraction_ML_Util.subst s args
-let (fresh_mlidents :
-  FStar_Extraction_ML_Syntax.mlty Prims.list ->
-    FStar_Extraction_ML_UEnv.uenv ->
-      ((FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
-        Prims.list * FStar_Extraction_ML_UEnv.uenv))
-  =
-  fun ts ->
-    fun g ->
-      let uu___ =
-        FStar_Compiler_List.fold_right
-          (fun t ->
-             fun uu___1 ->
-               match uu___1 with
-               | (uenv, vs) ->
-                   let uu___2 = FStar_Extraction_ML_UEnv.new_mlident uenv in
-                   (match uu___2 with | (uenv1, v) -> (uenv1, ((v, t) :: vs))))
-          ts (g, []) in
-      match uu___ with | (g1, vs_ts) -> (vs_ts, g1)
-let (instantiate_maybe_partial :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlexpr ->
-      FStar_Extraction_ML_Syntax.mltyscheme ->
-        FStar_Extraction_ML_Syntax.mlty Prims.list ->
-          (FStar_Extraction_ML_Syntax.mlexpr *
-            FStar_Extraction_ML_Syntax.e_tag *
-            FStar_Extraction_ML_Syntax.mlty))
-  =
-  fun g ->
-    fun e ->
-      fun s ->
-        fun tyargs ->
-          let uu___ = s in
-          match uu___ with
-          | (vars, t) ->
-              let n_vars = FStar_Compiler_List.length vars in
-              let n_args = FStar_Compiler_List.length tyargs in
-              if n_args = n_vars
-              then
-                (if n_args = Prims.int_zero
-                 then (e, FStar_Extraction_ML_Syntax.E_PURE, t)
-                 else
-                   (let ts = instantiate_tyscheme (vars, t) tyargs in
-                    let tapp =
-                      {
-                        FStar_Extraction_ML_Syntax.expr =
-                          (FStar_Extraction_ML_Syntax.MLE_TApp (e, tyargs));
-                        FStar_Extraction_ML_Syntax.mlty = ts;
-                        FStar_Extraction_ML_Syntax.loc =
-                          (e.FStar_Extraction_ML_Syntax.loc)
-                      } in
-                    (tapp, FStar_Extraction_ML_Syntax.E_PURE, ts)))
-              else
-                if n_args < n_vars
-                then
-                  (let extra_tyargs =
-                     let uu___2 = FStar_Compiler_Util.first_N n_args vars in
-                     match uu___2 with
-                     | (uu___3, rest_vars) ->
-                         FStar_Compiler_Effect.op_Bar_Greater rest_vars
-                           (FStar_Compiler_List.map
-                              (fun uu___4 ->
-                                 FStar_Extraction_ML_Syntax.MLTY_Erased)) in
-                   let tyargs1 =
-                     FStar_Compiler_List.op_At tyargs extra_tyargs in
-                   let ts = instantiate_tyscheme (vars, t) tyargs1 in
-                   let tapp =
-                     {
-                       FStar_Extraction_ML_Syntax.expr =
-                         (FStar_Extraction_ML_Syntax.MLE_TApp (e, tyargs1));
-                       FStar_Extraction_ML_Syntax.mlty = ts;
-                       FStar_Extraction_ML_Syntax.loc =
-                         (e.FStar_Extraction_ML_Syntax.loc)
-                     } in
-                   let t1 =
-                     FStar_Compiler_List.fold_left
-                       (fun out ->
-                          fun t2 ->
-                            FStar_Extraction_ML_Syntax.MLTY_Fun
-                              (t2, FStar_Extraction_ML_Syntax.E_PURE, out))
-                       ts extra_tyargs in
-                   let uu___2 = fresh_mlidents extra_tyargs g in
-                   match uu___2 with
-                   | (vs_ts, g1) ->
-                       let f =
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (FStar_Extraction_ML_Syntax.with_ty t1)
-                           (FStar_Extraction_ML_Syntax.MLE_Fun (vs_ts, tapp)) in
-                       (f, FStar_Extraction_ML_Syntax.E_PURE, t1))
-                else
-                  failwith
-                    "Impossible: instantiate_maybe_partial called with too many arguments"
-let (eta_expand :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun g ->
-    fun t ->
-      fun e ->
-        let uu___ = FStar_Extraction_ML_Util.doms_and_cod t in
-        match uu___ with
-        | (ts, r) ->
-            if ts = []
-            then e
-            else
-              (let uu___2 = fresh_mlidents ts g in
-               match uu___2 with
-               | (vs_ts, g1) ->
-                   let vs_es =
-                     FStar_Compiler_List.map
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | (v, t1) ->
-                              FStar_Extraction_ML_Syntax.with_ty t1
-                                (FStar_Extraction_ML_Syntax.MLE_Var v)) vs_ts in
-                   let body =
-                     FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_Extraction_ML_Syntax.with_ty r)
-                       (FStar_Extraction_ML_Syntax.MLE_App (e, vs_es)) in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Extraction_ML_Syntax.with_ty t)
-                     (FStar_Extraction_ML_Syntax.MLE_Fun (vs_ts, body)))
-let (default_value_for_ty :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun g ->
-    fun t ->
-      let uu___ = FStar_Extraction_ML_Util.doms_and_cod t in
-      match uu___ with
-      | (ts, r) ->
-          let body r1 =
-            let r2 =
-              let uu___1 = FStar_Extraction_ML_Util.udelta_unfold g r1 in
-              match uu___1 with
-              | FStar_Pervasives_Native.None -> r1
-              | FStar_Pervasives_Native.Some r3 -> r3 in
-            match r2 with
-            | FStar_Extraction_ML_Syntax.MLTY_Erased ->
-                FStar_Extraction_ML_Syntax.ml_unit
-            | FStar_Extraction_ML_Syntax.MLTY_Top ->
-                FStar_Extraction_ML_Syntax.apply_obj_repr
-                  FStar_Extraction_ML_Syntax.ml_unit
-                  FStar_Extraction_ML_Syntax.MLTY_Erased
-            | uu___1 ->
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty r2)
-                  (FStar_Extraction_ML_Syntax.MLE_Coerce
-                     (FStar_Extraction_ML_Syntax.ml_unit,
-                       FStar_Extraction_ML_Syntax.MLTY_Erased, r2)) in
-          if ts = []
-          then body r
-          else
-            (let uu___2 = fresh_mlidents ts g in
-             match uu___2 with
-             | (vs_ts, g1) ->
-                 let uu___3 =
-                   let uu___4 = let uu___5 = body r in (vs_ts, uu___5) in
-                   FStar_Extraction_ML_Syntax.MLE_Fun uu___4 in
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (FStar_Extraction_ML_Syntax.with_ty t) uu___3)
-let (maybe_eta_expand_coercion :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun g ->
-    fun expect ->
-      fun e ->
-        let uu___ =
-          let uu___1 = FStar_Options.codegen () in
-          uu___1 = (FStar_Pervasives_Native.Some FStar_Options.Krml) in
-        if uu___ then e else eta_expand g expect e
-let (apply_coercion :
-  FStar_Compiler_Range.range ->
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Extraction_ML_Syntax.mlexpr ->
-        FStar_Extraction_ML_Syntax.mlty ->
-          FStar_Extraction_ML_Syntax.mlty ->
-            FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun pos ->
-    fun g ->
-      fun e ->
-        fun ty ->
-          fun expect ->
-            (let uu___1 = FStar_Extraction_ML_Util.codegen_fsharp () in
-             if uu___1
-             then
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-                     FStar_Extraction_ML_Code.string_of_mlty uu___5 ty in
-                   let uu___5 =
-                     let uu___6 =
-                       FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-                     FStar_Extraction_ML_Code.string_of_mlty uu___6 expect in
-                   FStar_Compiler_Util.format2
-                     "Inserted an unsafe type coercion in generated code from %s to %s; this may be unsound in F#"
-                     uu___4 uu___5 in
-                 (FStar_Errors.Warning_NoMagicInFSharp, uu___3) in
-               FStar_Errors.log_issue pos uu___2
-             else ());
-            (let mk_fun binder body =
-               match body.FStar_Extraction_ML_Syntax.expr with
-               | FStar_Extraction_ML_Syntax.MLE_Fun (binders, body1) ->
-                   FStar_Extraction_ML_Syntax.MLE_Fun
-                     ((binder :: binders), body1)
-               | uu___1 ->
-                   FStar_Extraction_ML_Syntax.MLE_Fun ([binder], body) in
-             let rec aux e1 ty1 expect1 =
-               let coerce_branch uu___1 =
-                 match uu___1 with
-                 | (pat, w, b) ->
-                     let uu___2 = aux b ty1 expect1 in (pat, w, uu___2) in
-               match ((e1.FStar_Extraction_ML_Syntax.expr), ty1, expect1)
-               with
-               | (FStar_Extraction_ML_Syntax.MLE_Fun (arg::rest, body),
-                  FStar_Extraction_ML_Syntax.MLTY_Fun (t0, uu___1, t1),
-                  FStar_Extraction_ML_Syntax.MLTY_Fun (s0, uu___2, s1)) ->
-                   let body1 =
-                     match rest with
-                     | [] -> body
-                     | uu___3 ->
-                         FStar_Extraction_ML_Syntax.with_ty t1
-                           (FStar_Extraction_ML_Syntax.MLE_Fun (rest, body)) in
-                   let body2 = aux body1 t1 s1 in
-                   let uu___3 = type_leq g s0 t0 in
-                   if uu___3
-                   then
-                     FStar_Extraction_ML_Syntax.with_ty expect1
-                       (mk_fun arg body2)
-                   else
-                     (let lb =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_Extraction_ML_Syntax.with_ty s0)
-                                  (FStar_Extraction_ML_Syntax.MLE_Var
-                                     (FStar_Pervasives_Native.fst arg)) in
-                              (uu___8, s0, t0) in
-                            FStar_Extraction_ML_Syntax.MLE_Coerce uu___7 in
-                          FStar_Extraction_ML_Syntax.with_ty t0 uu___6 in
-                        {
-                          FStar_Extraction_ML_Syntax.mllb_name =
-                            (FStar_Pervasives_Native.fst arg);
-                          FStar_Extraction_ML_Syntax.mllb_tysc =
-                            (FStar_Pervasives_Native.Some ([], t0));
-                          FStar_Extraction_ML_Syntax.mllb_add_unit = false;
-                          FStar_Extraction_ML_Syntax.mllb_def = uu___5;
-                          FStar_Extraction_ML_Syntax.mllb_meta = [];
-                          FStar_Extraction_ML_Syntax.print_typ = false
-                        } in
-                      let body3 =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty s1)
-                          (FStar_Extraction_ML_Syntax.MLE_Let
-                             ((FStar_Extraction_ML_Syntax.NonRec, [lb]),
-                               body2)) in
-                      FStar_Extraction_ML_Syntax.with_ty expect1
-                        (mk_fun ((FStar_Pervasives_Native.fst arg), s0) body3))
-               | (FStar_Extraction_ML_Syntax.MLE_Let (lbs, body), uu___1,
-                  uu___2) ->
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = aux body ty1 expect1 in (lbs, uu___5) in
-                     FStar_Extraction_ML_Syntax.MLE_Let uu___4 in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Extraction_ML_Syntax.with_ty expect1) uu___3
-               | (FStar_Extraction_ML_Syntax.MLE_Match (s, branches), uu___1,
-                  uu___2) ->
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Compiler_List.map coerce_branch branches in
-                       (s, uu___5) in
-                     FStar_Extraction_ML_Syntax.MLE_Match uu___4 in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Extraction_ML_Syntax.with_ty expect1) uu___3
-               | (FStar_Extraction_ML_Syntax.MLE_If (s, b1, b2_opt), uu___1,
-                  uu___2) ->
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = aux b1 ty1 expect1 in
-                       let uu___6 =
-                         FStar_Compiler_Util.map_opt b2_opt
-                           (fun b2 -> aux b2 ty1 expect1) in
-                       (s, uu___5, uu___6) in
-                     FStar_Extraction_ML_Syntax.MLE_If uu___4 in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Extraction_ML_Syntax.with_ty expect1) uu___3
-               | (FStar_Extraction_ML_Syntax.MLE_Seq es, uu___1, uu___2) ->
-                   let uu___3 = FStar_Compiler_Util.prefix es in
-                   (match uu___3 with
-                    | (prefix, last) ->
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 = aux last ty1 expect1 in [uu___7] in
-                            FStar_Compiler_List.op_At prefix uu___6 in
-                          FStar_Extraction_ML_Syntax.MLE_Seq uu___5 in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty expect1) uu___4)
-               | (FStar_Extraction_ML_Syntax.MLE_Try (s, branches), uu___1,
-                  uu___2) ->
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Compiler_List.map coerce_branch branches in
-                       (s, uu___5) in
-                     FStar_Extraction_ML_Syntax.MLE_Try uu___4 in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Extraction_ML_Syntax.with_ty expect1) uu___3
-               | uu___1 ->
-                   FStar_Extraction_ML_Syntax.with_ty expect1
-                     (FStar_Extraction_ML_Syntax.MLE_Coerce
-                        (e1, ty1, expect1)) in
-             aux e ty expect)
-let (maybe_coerce :
-  FStar_Compiler_Range.range ->
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Extraction_ML_Syntax.mlexpr ->
-        FStar_Extraction_ML_Syntax.mlty ->
-          FStar_Extraction_ML_Syntax.mlty ->
-            FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun pos ->
-    fun g ->
-      fun e ->
-        fun ty ->
-          fun expect ->
-            let ty1 = eraseTypeDeep g ty in
-            let uu___ =
-              type_leq_c g (FStar_Pervasives_Native.Some e) ty1 expect in
-            match uu___ with
-            | (true, FStar_Pervasives_Native.Some e') -> e'
-            | uu___1 ->
-                (match ty1 with
-                 | FStar_Extraction_ML_Syntax.MLTY_Erased ->
-                     default_value_for_ty g expect
-                 | uu___2 ->
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Extraction_ML_Util.erase_effect_annotations
-                           ty1 in
-                       let uu___5 =
-                         FStar_Extraction_ML_Util.erase_effect_annotations
-                           expect in
-                       type_leq g uu___4 uu___5 in
-                     if uu___3
-                     then
-                       (FStar_Extraction_ML_UEnv.debug g
-                          (fun uu___5 ->
-                             let uu___6 =
-                               let uu___7 =
-                                 FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                   g in
-                               FStar_Extraction_ML_Code.string_of_mlexpr
-                                 uu___7 e in
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                   g in
-                               FStar_Extraction_ML_Code.string_of_mlty uu___8
-                                 ty1 in
-                             FStar_Compiler_Util.print2
-                               "\n Effect mismatch on type of %s : %s\n"
-                               uu___6 uu___7);
-                        e)
-                     else
-                       (FStar_Extraction_ML_UEnv.debug g
-                          (fun uu___6 ->
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                   g in
-                               FStar_Extraction_ML_Code.string_of_mlexpr
-                                 uu___8 e in
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                   g in
-                               FStar_Extraction_ML_Code.string_of_mlty uu___9
-                                 ty1 in
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                   g in
-                               FStar_Extraction_ML_Code.string_of_mlty
-                                 uu___10 expect in
-                             FStar_Compiler_Util.print3
-                               "\n (*needed to coerce expression \n %s \n of type \n %s \n to type \n %s *) \n"
-                               uu___7 uu___8 uu___9);
-                        (let uu___6 = apply_coercion pos g e ty1 expect in
-                         maybe_eta_expand_coercion g expect uu___6)))
-let (bv_as_mlty :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.bv -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun g ->
-    fun bv ->
-      let uu___ = FStar_Extraction_ML_UEnv.lookup_bv g bv in
-      match uu___ with
-      | FStar_Pervasives.Inl ty_b -> ty_b.FStar_Extraction_ML_UEnv.ty_b_ty
-      | uu___1 -> FStar_Extraction_ML_Syntax.MLTY_Top
-let (extraction_norm_steps : FStar_TypeChecker_Env.step Prims.list) =
-  let extraction_norm_steps_core =
-    [FStar_TypeChecker_Env.AllowUnboundUniverses;
-    FStar_TypeChecker_Env.EraseUniverses;
-    FStar_TypeChecker_Env.Inlining;
-    FStar_TypeChecker_Env.Eager_unfolding;
-    FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-    FStar_TypeChecker_Env.Primops;
-    FStar_TypeChecker_Env.Unascribe;
-    FStar_TypeChecker_Env.ForExtraction] in
-  let extraction_norm_steps_nbe = FStar_TypeChecker_Env.NBE ::
-    extraction_norm_steps_core in
-  let uu___ = FStar_Options.use_nbe_for_extraction () in
-  if uu___ then extraction_norm_steps_nbe else extraction_norm_steps_core
-let (comp_no_args :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total uu___ -> c
-    | FStar_Syntax_Syntax.GTotal uu___ -> c
-    | FStar_Syntax_Syntax.Comp ct ->
-        let effect_args =
-          FStar_Compiler_List.map
-            (fun uu___ ->
-               match uu___ with
-               | (uu___1, aq) -> (FStar_Syntax_Syntax.t_unit, aq))
-            ct.FStar_Syntax_Syntax.effect_args in
-        let ct1 =
-          {
-            FStar_Syntax_Syntax.comp_univs =
-              (ct.FStar_Syntax_Syntax.comp_univs);
-            FStar_Syntax_Syntax.effect_name =
-              (ct.FStar_Syntax_Syntax.effect_name);
-            FStar_Syntax_Syntax.result_typ =
-              (ct.FStar_Syntax_Syntax.result_typ);
-            FStar_Syntax_Syntax.effect_args = effect_args;
-            FStar_Syntax_Syntax.flags = (ct.FStar_Syntax_Syntax.flags)
-          } in
-        let c1 =
-          {
-            FStar_Syntax_Syntax.n = (FStar_Syntax_Syntax.Comp ct1);
-            FStar_Syntax_Syntax.pos = (c.FStar_Syntax_Syntax.pos);
-            FStar_Syntax_Syntax.vars = (c.FStar_Syntax_Syntax.vars);
-            FStar_Syntax_Syntax.hash_code = (c.FStar_Syntax_Syntax.hash_code)
-          } in
-        c1
-let maybe_reify_comp :
-  'uuuuu .
-    'uuuuu ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.term
-  =
-  fun g ->
-    fun env ->
-      fun c ->
-        let c1 = comp_no_args c in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater c1
-                FStar_Syntax_Util.comp_effect_name in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (FStar_TypeChecker_Env.norm_eff_name env) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_TypeChecker_Env.is_reifiable_effect env) in
-        if uu___
-        then
-          let uu___1 =
-            FStar_TypeChecker_Env.reify_comp env c1
-              FStar_Syntax_Syntax.U_unknown in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_TypeChecker_Normalize.normalize extraction_norm_steps env)
-        else FStar_Syntax_Util.comp_result c1
-let rec (translate_term_to_mlty :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.term -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun g ->
-    fun t0 ->
-      let arg_as_mlty g1 uu___ =
-        match uu___ with
-        | (a, uu___1) ->
-            let uu___2 = is_type g1 a in
-            if uu___2
-            then translate_term_to_mlty g1 a
-            else FStar_Extraction_ML_Syntax.MLTY_Erased in
-      let fv_app_as_mlty g1 fv args =
-        let uu___ =
-          let uu___1 = FStar_Extraction_ML_UEnv.is_fv_type g1 fv in
-          Prims.op_Negation uu___1 in
-        if uu___
-        then FStar_Extraction_ML_Syntax.MLTY_Top
-        else
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g1 in
-               FStar_TypeChecker_Env.lookup_lid uu___4
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-             match uu___3 with
-             | ((uu___4, fvty), uu___5) ->
-                 let fvty1 =
-                   let uu___6 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g1 in
-                   FStar_TypeChecker_Normalize.normalize
-                     [FStar_TypeChecker_Env.UnfoldUntil
-                        FStar_Syntax_Syntax.delta_constant;
-                     FStar_TypeChecker_Env.ForExtraction] uu___6 fvty in
-                 FStar_Syntax_Util.arrow_formals fvty1 in
-           match uu___2 with
-           | (formals, uu___3) ->
-               let mlargs = FStar_Compiler_List.map (arg_as_mlty g1) args in
-               let mlargs1 =
-                 let n_args = FStar_Compiler_List.length args in
-                 if (FStar_Compiler_List.length formals) > n_args
-                 then
-                   let uu___4 = FStar_Compiler_Util.first_N n_args formals in
-                   match uu___4 with
-                   | (uu___5, rest) ->
-                       let uu___6 =
-                         FStar_Compiler_List.map
-                           (fun uu___7 ->
-                              FStar_Extraction_ML_Syntax.MLTY_Erased) rest in
-                       FStar_Compiler_List.op_At mlargs uu___6
-                 else mlargs in
-               let nm =
-                 FStar_Extraction_ML_UEnv.mlpath_of_lident g1
-                   (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-               FStar_Extraction_ML_Syntax.MLTY_Named (mlargs1, nm)) in
-      let aux env t =
-        let t1 = FStar_Syntax_Subst.compress t in
-        match t1.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_type uu___ ->
-            FStar_Extraction_ML_Syntax.MLTY_Erased
-        | FStar_Syntax_Syntax.Tm_bvar uu___ ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1 "Impossible: Unexpected term %s"
-                uu___2 in
-            failwith uu___1
-        | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1 "Impossible: Unexpected term %s"
-                uu___2 in
-            failwith uu___1
-        | FStar_Syntax_Syntax.Tm_unknown ->
-            let uu___ =
-              let uu___1 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1 "Impossible: Unexpected term %s"
-                uu___1 in
-            failwith uu___
-        | FStar_Syntax_Syntax.Tm_lazy i ->
-            let uu___ = FStar_Syntax_Util.unfold_lazy i in
-            translate_term_to_mlty env uu___
-        | FStar_Syntax_Syntax.Tm_constant uu___ ->
-            FStar_Extraction_ML_Syntax.MLTY_Top
-        | FStar_Syntax_Syntax.Tm_quoted uu___ ->
-            FStar_Extraction_ML_Syntax.MLTY_Top
-        | FStar_Syntax_Syntax.Tm_uvar uu___ ->
-            FStar_Extraction_ML_Syntax.MLTY_Top
-        | FStar_Syntax_Syntax.Tm_meta (t2, uu___) ->
-            translate_term_to_mlty env t2
-        | FStar_Syntax_Syntax.Tm_refine
-            ({ FStar_Syntax_Syntax.ppname = uu___;
-               FStar_Syntax_Syntax.index = uu___1;
-               FStar_Syntax_Syntax.sort = t2;_},
-             uu___2)
-            -> translate_term_to_mlty env t2
-        | FStar_Syntax_Syntax.Tm_uinst (t2, uu___) ->
-            translate_term_to_mlty env t2
-        | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___, uu___1) ->
-            translate_term_to_mlty env t2
-        | FStar_Syntax_Syntax.Tm_name bv -> bv_as_mlty env bv
-        | FStar_Syntax_Syntax.Tm_fvar fv -> fv_app_as_mlty env fv []
-        | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-            let uu___ = FStar_Syntax_Subst.open_comp bs c in
-            (match uu___ with
-             | (bs1, c1) ->
-                 let uu___1 = binders_as_ml_binders env bs1 in
-                 (match uu___1 with
-                  | (mlbs, env1) ->
-                      let t_ret =
-                        let uu___2 =
-                          let uu___3 =
-                            FStar_Extraction_ML_UEnv.tcenv_of_uenv env1 in
-                          maybe_reify_comp env1 uu___3 c1 in
-                        translate_term_to_mlty env1 uu___2 in
-                      let erase =
-                        effect_as_etag env1
-                          (FStar_Syntax_Util.comp_effect_name c1) in
-                      let uu___2 =
-                        FStar_Compiler_List.fold_right
-                          (fun uu___3 ->
-                             fun uu___4 ->
-                               match (uu___3, uu___4) with
-                               | ((uu___5, t2), (tag, t')) ->
-                                   (FStar_Extraction_ML_Syntax.E_PURE,
-                                     (FStar_Extraction_ML_Syntax.MLTY_Fun
-                                        (t2, tag, t')))) mlbs (erase, t_ret) in
-                      (match uu___2 with | (uu___3, t2) -> t2)))
-        | FStar_Syntax_Syntax.Tm_app (head, args) ->
-            let res =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Util.un_uinst head in
-                  uu___2.FStar_Syntax_Syntax.n in
-                (uu___1, args) in
-              match uu___ with
-              | (FStar_Syntax_Syntax.Tm_name bv, uu___1) -> bv_as_mlty env bv
-              | (FStar_Syntax_Syntax.Tm_fvar fv, uu___1::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steel_memory_inv_lid
-                  -> translate_term_to_mlty env FStar_Syntax_Syntax.t_unit
-              | (FStar_Syntax_Syntax.Tm_fvar fv, uu___1) ->
-                  fv_app_as_mlty env fv args
-              | (FStar_Syntax_Syntax.Tm_app (head1, args'), uu___1) ->
-                  let uu___2 =
-                    FStar_Syntax_Syntax.mk
-                      (FStar_Syntax_Syntax.Tm_app
-                         (head1, (FStar_Compiler_List.op_At args' args)))
-                      t1.FStar_Syntax_Syntax.pos in
-                  translate_term_to_mlty env uu___2
-              | uu___1 -> FStar_Extraction_ML_Syntax.MLTY_Top in
-            res
-        | FStar_Syntax_Syntax.Tm_abs (bs, ty, uu___) ->
-            let uu___1 = FStar_Syntax_Subst.open_term bs ty in
-            (match uu___1 with
-             | (bs1, ty1) ->
-                 let uu___2 = binders_as_ml_binders env bs1 in
-                 (match uu___2 with
-                  | (bts, env1) -> translate_term_to_mlty env1 ty1))
-        | FStar_Syntax_Syntax.Tm_let uu___ ->
-            FStar_Extraction_ML_Syntax.MLTY_Top
-        | FStar_Syntax_Syntax.Tm_match uu___ ->
-            FStar_Extraction_ML_Syntax.MLTY_Top in
-      let rec is_top_ty t =
-        match t with
-        | FStar_Extraction_ML_Syntax.MLTY_Top -> true
-        | FStar_Extraction_ML_Syntax.MLTY_Named uu___ ->
-            let uu___1 = FStar_Extraction_ML_Util.udelta_unfold g t in
-            (match uu___1 with
-             | FStar_Pervasives_Native.None -> false
-             | FStar_Pervasives_Native.Some t1 -> is_top_ty t1)
-        | uu___ -> false in
-      let uu___ =
-        let uu___1 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-        FStar_TypeChecker_Util.must_erase_for_extraction uu___1 t0 in
-      if uu___
-      then FStar_Extraction_ML_Syntax.MLTY_Erased
-      else
-        (let mlt = aux g t0 in
-         let uu___2 = is_top_ty mlt in
-         if uu___2 then FStar_Extraction_ML_Syntax.MLTY_Top else mlt)
-and (binders_as_ml_binders :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.binders ->
-      ((FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
-        Prims.list * FStar_Extraction_ML_UEnv.uenv))
-  =
-  fun g ->
-    fun bs ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater bs
-          (FStar_Compiler_List.fold_left
-             (fun uu___1 ->
-                fun b ->
-                  match uu___1 with
-                  | (ml_bs, env) ->
-                      let uu___2 = is_type_binder g b in
-                      if uu___2
-                      then
-                        let b1 = b.FStar_Syntax_Syntax.binder_bv in
-                        let env1 =
-                          FStar_Extraction_ML_UEnv.extend_ty env b1 true in
-                        let ml_b =
-                          let uu___3 =
-                            FStar_Extraction_ML_UEnv.lookup_ty env1 b1 in
-                          uu___3.FStar_Extraction_ML_UEnv.ty_b_name in
-                        let ml_b1 =
-                          (ml_b, FStar_Extraction_ML_Syntax.ml_unit_ty) in
-                        ((ml_b1 :: ml_bs), env1)
-                      else
-                        (let b1 = b.FStar_Syntax_Syntax.binder_bv in
-                         let t =
-                           translate_term_to_mlty env
-                             b1.FStar_Syntax_Syntax.sort in
-                         let uu___4 =
-                           FStar_Extraction_ML_UEnv.extend_bv env b1 
-                             ([], t) false false in
-                         match uu___4 with
-                         | (env1, b2, uu___5) ->
-                             let ml_b = (b2, t) in ((ml_b :: ml_bs), env1)))
-             ([], g)) in
-      match uu___ with
-      | (ml_bs, env) -> ((FStar_Compiler_List.rev ml_bs), env)
-let (term_as_mlty :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.term -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun g ->
-    fun t0 ->
-      let t =
-        let uu___ = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-        FStar_TypeChecker_Normalize.normalize extraction_norm_steps uu___ t0 in
-      translate_term_to_mlty g t
-let (mk_MLE_Seq :
-  FStar_Extraction_ML_Syntax.mlexpr ->
-    FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr')
-  =
-  fun e1 ->
-    fun e2 ->
-      match ((e1.FStar_Extraction_ML_Syntax.expr),
-              (e2.FStar_Extraction_ML_Syntax.expr))
-      with
-      | (FStar_Extraction_ML_Syntax.MLE_Seq es1,
-         FStar_Extraction_ML_Syntax.MLE_Seq es2) ->
-          FStar_Extraction_ML_Syntax.MLE_Seq
-            (FStar_Compiler_List.op_At es1 es2)
-      | (FStar_Extraction_ML_Syntax.MLE_Seq es1, uu___) ->
-          FStar_Extraction_ML_Syntax.MLE_Seq
-            (FStar_Compiler_List.op_At es1 [e2])
-      | (uu___, FStar_Extraction_ML_Syntax.MLE_Seq es2) ->
-          FStar_Extraction_ML_Syntax.MLE_Seq (e1 :: es2)
-      | uu___ -> FStar_Extraction_ML_Syntax.MLE_Seq [e1; e2]
-let (mk_MLE_Let :
-  Prims.bool ->
-    FStar_Extraction_ML_Syntax.mlletbinding ->
-      FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr')
-  =
-  fun top_level ->
-    fun lbs ->
-      fun body ->
-        match lbs with
-        | (FStar_Extraction_ML_Syntax.NonRec, lb::[]) when
-            Prims.op_Negation top_level ->
-            (match lb.FStar_Extraction_ML_Syntax.mllb_tysc with
-             | FStar_Pervasives_Native.Some ([], t) when
-                 t = FStar_Extraction_ML_Syntax.ml_unit_ty ->
-                 if
-                   body.FStar_Extraction_ML_Syntax.expr =
-                     FStar_Extraction_ML_Syntax.ml_unit.FStar_Extraction_ML_Syntax.expr
-                 then
-                   (lb.FStar_Extraction_ML_Syntax.mllb_def).FStar_Extraction_ML_Syntax.expr
-                 else
-                   (match body.FStar_Extraction_ML_Syntax.expr with
-                    | FStar_Extraction_ML_Syntax.MLE_Var x when
-                        x = lb.FStar_Extraction_ML_Syntax.mllb_name ->
-                        (lb.FStar_Extraction_ML_Syntax.mllb_def).FStar_Extraction_ML_Syntax.expr
-                    | uu___1 when
-                        (lb.FStar_Extraction_ML_Syntax.mllb_def).FStar_Extraction_ML_Syntax.expr
-                          =
-                          FStar_Extraction_ML_Syntax.ml_unit.FStar_Extraction_ML_Syntax.expr
-                        -> body.FStar_Extraction_ML_Syntax.expr
-                    | uu___1 ->
-                        mk_MLE_Seq lb.FStar_Extraction_ML_Syntax.mllb_def
-                          body)
-             | uu___ -> FStar_Extraction_ML_Syntax.MLE_Let (lbs, body))
-        | uu___ -> FStar_Extraction_ML_Syntax.MLE_Let (lbs, body)
-let record_fields :
-  'a .
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Ident.lident ->
-        FStar_Ident.ident Prims.list ->
-          'a Prims.list ->
-            (FStar_Extraction_ML_Syntax.mlsymbol * 'a) Prims.list
-  =
-  fun g ->
-    fun ty ->
-      fun fns ->
-        fun xs ->
-          let fns1 =
-            FStar_Compiler_List.map
-              (fun x ->
-                 FStar_Extraction_ML_UEnv.lookup_record_field_name g (ty, x))
-              fns in
-          FStar_Compiler_List.map2
-            (fun uu___ -> fun x -> match uu___ with | (p, s) -> (s, x)) fns1
-            xs
-let (resugar_pat :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.fv_qual FStar_Pervasives_Native.option ->
-      FStar_Extraction_ML_Syntax.mlpattern ->
-        FStar_Extraction_ML_Syntax.mlpattern)
-  =
-  fun g ->
-    fun q ->
-      fun p ->
-        match p with
-        | FStar_Extraction_ML_Syntax.MLP_CTor (d, pats) ->
-            let uu___ = FStar_Extraction_ML_Util.is_xtuple d in
-            (match uu___ with
-             | FStar_Pervasives_Native.Some n ->
-                 FStar_Extraction_ML_Syntax.MLP_Tuple pats
-             | uu___1 ->
-                 (match q with
-                  | FStar_Pervasives_Native.Some
-                      (FStar_Syntax_Syntax.Record_ctor (ty, fns)) ->
-                      let path =
-                        let uu___2 = FStar_Ident.ns_of_lid ty in
-                        FStar_Compiler_List.map FStar_Ident.string_of_id
-                          uu___2 in
-                      let fs = record_fields g ty fns pats in
-                      FStar_Extraction_ML_Syntax.MLP_Record (path, fs)
-                  | uu___2 -> p))
-        | uu___ -> p
-let rec (extract_one_pat :
-  Prims.bool ->
-    FStar_Extraction_ML_UEnv.uenv ->
-      FStar_Syntax_Syntax.pat ->
-        FStar_Extraction_ML_Syntax.mlty ->
-          (FStar_Extraction_ML_UEnv.uenv ->
-             FStar_Syntax_Syntax.term ->
-               (FStar_Extraction_ML_Syntax.mlexpr *
-                 FStar_Extraction_ML_Syntax.e_tag *
-                 FStar_Extraction_ML_Syntax.mlty))
-            ->
-            (FStar_Extraction_ML_UEnv.uenv *
-              (FStar_Extraction_ML_Syntax.mlpattern *
-              FStar_Extraction_ML_Syntax.mlexpr Prims.list)
-              FStar_Pervasives_Native.option * Prims.bool))
-  =
-  fun imp ->
-    fun g ->
-      fun p ->
-        fun expected_ty ->
-          fun term_as_mlexpr ->
-            let ok t =
-              match expected_ty with
-              | FStar_Extraction_ML_Syntax.MLTY_Top -> false
-              | uu___ ->
-                  let ok1 = type_leq g t expected_ty in
-                  (if Prims.op_Negation ok1
-                   then
-                     FStar_Extraction_ML_UEnv.debug g
-                       (fun uu___2 ->
-                          let uu___3 =
-                            let uu___4 =
-                              FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                g in
-                            FStar_Extraction_ML_Code.string_of_mlty uu___4
-                              expected_ty in
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                g in
-                            FStar_Extraction_ML_Code.string_of_mlty uu___5 t in
-                          FStar_Compiler_Util.print2
-                            "Expected pattern type %s; got pattern type %s\n"
-                            uu___3 uu___4)
-                   else ();
-                   ok1) in
-            match p.FStar_Syntax_Syntax.v with
-            | FStar_Syntax_Syntax.Pat_constant (FStar_Const.Const_int
-                (c, swopt)) when
-                let uu___ = FStar_Options.codegen () in
-                uu___ <> (FStar_Pervasives_Native.Some FStar_Options.Krml) ->
-                let uu___ =
-                  match swopt with
-                  | FStar_Pervasives_Native.None ->
-                      let uu___1 =
-                        let uu___2 =
-                          let uu___3 =
-                            FStar_Extraction_ML_Util.mlconst_of_const
-                              p.FStar_Syntax_Syntax.p
-                              (FStar_Const.Const_int
-                                 (c, FStar_Pervasives_Native.None)) in
-                          FStar_Extraction_ML_Syntax.MLE_Const uu___3 in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty
-                             FStar_Extraction_ML_Syntax.ml_int_ty) uu___2 in
-                      (uu___1, FStar_Extraction_ML_Syntax.ml_int_ty)
-                  | FStar_Pervasives_Native.Some sw ->
-                      let source_term =
-                        let uu___1 =
-                          let uu___2 =
-                            FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                          uu___2.FStar_TypeChecker_Env.dsenv in
-                        FStar_ToSyntax_ToSyntax.desugar_machine_integer
-                          uu___1 c sw FStar_Compiler_Range.dummyRange in
-                      let uu___1 = term_as_mlexpr g source_term in
-                      (match uu___1 with
-                       | (mlterm, uu___2, mlty) -> (mlterm, mlty)) in
-                (match uu___ with
-                 | (mlc, ml_ty) ->
-                     let uu___1 = FStar_Extraction_ML_UEnv.new_mlident g in
-                     (match uu___1 with
-                      | (g1, x) ->
-                          let x_exp =
-                            let x_exp1 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_Extraction_ML_Syntax.with_ty
-                                   expected_ty)
-                                (FStar_Extraction_ML_Syntax.MLE_Var x) in
-                            let coerce x1 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_Extraction_ML_Syntax.with_ty ml_ty)
-                                (FStar_Extraction_ML_Syntax.MLE_Coerce
-                                   (x1, ml_ty, expected_ty)) in
-                            match expected_ty with
-                            | FStar_Extraction_ML_Syntax.MLTY_Top ->
-                                coerce x_exp1
-                            | uu___2 ->
-                                let uu___3 = ok ml_ty in
-                                if uu___3 then x_exp1 else coerce x_exp1 in
-                          let when_clause =
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_Extraction_ML_Syntax.with_ty
-                                 FStar_Extraction_ML_Syntax.ml_bool_ty)
-                              (FStar_Extraction_ML_Syntax.MLE_App
-                                 (FStar_Extraction_ML_Util.prims_op_equality,
-                                   [x_exp; mlc])) in
-                          let uu___2 = ok ml_ty in
-                          (g1,
-                            (FStar_Pervasives_Native.Some
-                               ((FStar_Extraction_ML_Syntax.MLP_Var x),
-                                 [when_clause])), uu___2)))
-            | FStar_Syntax_Syntax.Pat_constant s ->
-                let t =
-                  let uu___ = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                  FStar_TypeChecker_TcTerm.tc_constant uu___
-                    FStar_Compiler_Range.dummyRange s in
-                let mlty = term_as_mlty g t in
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        FStar_Extraction_ML_Util.mlconst_of_const
-                          p.FStar_Syntax_Syntax.p s in
-                      FStar_Extraction_ML_Syntax.MLP_Const uu___3 in
-                    (uu___2, []) in
-                  FStar_Pervasives_Native.Some uu___1 in
-                let uu___1 = ok mlty in (g, uu___, uu___1)
-            | FStar_Syntax_Syntax.Pat_var x ->
-                let uu___ =
-                  FStar_Extraction_ML_UEnv.extend_bv g x ([], expected_ty)
-                    false imp in
-                (match uu___ with
-                 | (g1, x1, uu___1) ->
-                     (g1,
-                       (if imp
-                        then FStar_Pervasives_Native.None
-                        else
-                          FStar_Pervasives_Native.Some
-                            ((FStar_Extraction_ML_Syntax.MLP_Var x1), [])),
-                       true))
-            | FStar_Syntax_Syntax.Pat_wild x ->
-                let uu___ =
-                  FStar_Extraction_ML_UEnv.extend_bv g x ([], expected_ty)
-                    false imp in
-                (match uu___ with
-                 | (g1, x1, uu___1) ->
-                     (g1,
-                       (if imp
-                        then FStar_Pervasives_Native.None
-                        else
-                          FStar_Pervasives_Native.Some
-                            ((FStar_Extraction_ML_Syntax.MLP_Var x1), [])),
-                       true))
-            | FStar_Syntax_Syntax.Pat_dot_term uu___ ->
-                (g, FStar_Pervasives_Native.None, true)
-            | FStar_Syntax_Syntax.Pat_cons (f, uu___, pats) ->
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Extraction_ML_UEnv.try_lookup_fv
-                      p.FStar_Syntax_Syntax.p g f in
-                  match uu___2 with
-                  | FStar_Pervasives_Native.Some
-                      { FStar_Extraction_ML_UEnv.exp_b_name = uu___3;
-                        FStar_Extraction_ML_UEnv.exp_b_expr =
-                          {
-                            FStar_Extraction_ML_Syntax.expr =
-                              FStar_Extraction_ML_Syntax.MLE_Name n;
-                            FStar_Extraction_ML_Syntax.mlty = uu___4;
-                            FStar_Extraction_ML_Syntax.loc = uu___5;_};
-                        FStar_Extraction_ML_UEnv.exp_b_tscheme = ttys;_}
-                      -> (n, ttys)
-                  | FStar_Pervasives_Native.Some uu___3 ->
-                      failwith "Expected a constructor"
-                  | FStar_Pervasives_Native.None ->
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Print.fv_to_string f in
-                          FStar_Compiler_Util.format1
-                            "Cannot extract this pattern, the %s constructor was erased"
-                            uu___5 in
-                        (FStar_Errors.Error_ErasedCtor, uu___4) in
-                      FStar_Errors.raise_error uu___3
-                        (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.p in
-                (match uu___1 with
-                 | (d, tys) ->
-                     let nTyVars =
-                       FStar_Compiler_List.length
-                         (FStar_Pervasives_Native.fst tys) in
-                     let uu___2 = FStar_Compiler_Util.first_N nTyVars pats in
-                     (match uu___2 with
-                      | (tysVarPats, restPats) ->
-                          let f_ty =
-                            let mlty_args =
-                              FStar_Compiler_Effect.op_Bar_Greater tysVarPats
-                                (FStar_Compiler_List.map
-                                   (fun uu___3 ->
-                                      match uu___3 with
-                                      | (p1, uu___4) ->
-                                          (match expected_ty with
-                                           | FStar_Extraction_ML_Syntax.MLTY_Top
-                                               ->
-                                               FStar_Extraction_ML_Syntax.MLTY_Top
-                                           | uu___5 ->
-                                               (match p1.FStar_Syntax_Syntax.v
-                                                with
-                                                | FStar_Syntax_Syntax.Pat_dot_term
-                                                    (FStar_Pervasives_Native.Some
-                                                    t) -> term_as_mlty g t
-                                                | uu___6 ->
-                                                    FStar_Extraction_ML_Syntax.MLTY_Top)))) in
-                            let f_ty1 =
-                              FStar_Extraction_ML_Util.subst tys mlty_args in
-                            FStar_Extraction_ML_Util.uncurry_mlty_fun f_ty1 in
-                          (FStar_Extraction_ML_UEnv.debug g
-                             (fun uu___4 ->
-                                let uu___5 =
-                                  FStar_Syntax_Print.fv_to_string f in
-                                let uu___6 =
-                                  let uu___7 = f_ty in
-                                  match uu___7 with
-                                  | (args, t) ->
-                                      let args1 =
-                                        let uu___8 =
-                                          let uu___9 =
-                                            let uu___10 =
-                                              FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                                g in
-                                            FStar_Extraction_ML_Code.string_of_mlty
-                                              uu___10 in
-                                          FStar_Compiler_List.map uu___9 args in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___8 (FStar_String.concat " -> ") in
-                                      let res =
-                                        let uu___8 =
-                                          FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                            g in
-                                        FStar_Extraction_ML_Code.string_of_mlty
-                                          uu___8 t in
-                                      FStar_Compiler_Util.format2 "%s -> %s"
-                                        args1 res in
-                                FStar_Compiler_Util.print2
-                                  "@@@Expected type of pattern with head = %s is %s\n"
-                                  uu___5 uu___6);
-                           (let uu___4 =
-                              FStar_Compiler_Util.fold_map
-                                (fun g1 ->
-                                   fun uu___5 ->
-                                     match uu___5 with
-                                     | (p1, imp1) ->
-                                         let uu___6 =
-                                           extract_one_pat true g1 p1
-                                             FStar_Extraction_ML_Syntax.MLTY_Top
-                                             term_as_mlexpr in
-                                         (match uu___6 with
-                                          | (g2, p2, uu___7) -> (g2, p2))) g
-                                tysVarPats in
-                            match uu___4 with
-                            | (g1, tyMLPats) ->
-                                let uu___5 =
-                                  FStar_Compiler_Util.fold_map
-                                    (fun uu___6 ->
-                                       fun uu___7 ->
-                                         match (uu___6, uu___7) with
-                                         | ((g2, f_ty1, ok1), (p1, imp1)) ->
-                                             let uu___8 =
-                                               match f_ty1 with
-                                               | (hd::rest, res) ->
-                                                   ((rest, res), hd)
-                                               | uu___9 ->
-                                                   (([],
-                                                      FStar_Extraction_ML_Syntax.MLTY_Top),
-                                                     FStar_Extraction_ML_Syntax.MLTY_Top) in
-                                             (match uu___8 with
-                                              | (f_ty2, expected_arg_ty) ->
-                                                  let uu___9 =
-                                                    extract_one_pat false g2
-                                                      p1 expected_arg_ty
-                                                      term_as_mlexpr in
-                                                  (match uu___9 with
-                                                   | (g3, p2, ok') ->
-                                                       ((g3, f_ty2,
-                                                          (ok1 && ok')), p2))))
-                                    (g1, f_ty, true) restPats in
-                                (match uu___5 with
-                                 | ((g2, f_ty1, sub_pats_ok), restMLPats) ->
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           (FStar_Compiler_List.append
-                                              tyMLPats restMLPats)
-                                           (FStar_Compiler_List.collect
-                                              (fun uu___8 ->
-                                                 match uu___8 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     x -> [x]
-                                                 | uu___9 -> [])) in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___7 FStar_Compiler_List.split in
-                                     (match uu___6 with
-                                      | (mlPats, when_clauses) ->
-                                          let pat_ty_compat =
-                                            match f_ty1 with
-                                            | ([], t) -> ok t
-                                            | uu___7 -> false in
-                                          let uu___7 =
-                                            let uu___8 =
-                                              let uu___9 =
-                                                resugar_pat g2
-                                                  f.FStar_Syntax_Syntax.fv_qual
-                                                  (FStar_Extraction_ML_Syntax.MLP_CTor
-                                                     (d, mlPats)) in
-                                              let uu___10 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  when_clauses
-                                                  FStar_Compiler_List.flatten in
-                                              (uu___9, uu___10) in
-                                            FStar_Pervasives_Native.Some
-                                              uu___8 in
-                                          (g2, uu___7,
-                                            (sub_pats_ok && pat_ty_compat))))))))
-let (extract_pat :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.pat ->
-      FStar_Extraction_ML_Syntax.mlty ->
-        (FStar_Extraction_ML_UEnv.uenv ->
-           FStar_Syntax_Syntax.term ->
-             (FStar_Extraction_ML_Syntax.mlexpr *
-               FStar_Extraction_ML_Syntax.e_tag *
-               FStar_Extraction_ML_Syntax.mlty))
-          ->
-          (FStar_Extraction_ML_UEnv.uenv *
-            (FStar_Extraction_ML_Syntax.mlpattern *
-            FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option)
-            Prims.list * Prims.bool))
-  =
-  fun g ->
-    fun p ->
-      fun expected_t ->
-        fun term_as_mlexpr ->
-          let extract_one_pat1 g1 p1 expected_t1 =
-            let uu___ =
-              extract_one_pat false g1 p1 expected_t1 term_as_mlexpr in
-            match uu___ with
-            | (g2, FStar_Pervasives_Native.Some (x, v), b) -> (g2, (x, v), b)
-            | uu___1 -> failwith "Impossible: Unable to translate pattern" in
-          let mk_when_clause whens =
-            match whens with
-            | [] -> FStar_Pervasives_Native.None
-            | hd::tl ->
-                let uu___ =
-                  FStar_Compiler_List.fold_left
-                    FStar_Extraction_ML_Util.conjoin hd tl in
-                FStar_Pervasives_Native.Some uu___ in
-          let uu___ = extract_one_pat1 g p expected_t in
-          match uu___ with
-          | (g1, (p1, whens), b) ->
-              let when_clause = mk_when_clause whens in
-              (g1, [(p1, when_clause)], b)
-let (maybe_eta_data_and_project_record :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.fv_qual FStar_Pervasives_Native.option ->
-      FStar_Extraction_ML_Syntax.mlty ->
-        FStar_Extraction_ML_Syntax.mlexpr ->
-          FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun g ->
-    fun qual ->
-      fun residualType ->
-        fun mlAppExpr ->
-          let rec eta_args g1 more_args t =
-            match t with
-            | FStar_Extraction_ML_Syntax.MLTY_Fun (t0, uu___, t1) ->
-                let uu___1 = FStar_Extraction_ML_UEnv.new_mlident g1 in
-                (match uu___1 with
-                 | (g2, x) ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_Compiler_Effect.op_Less_Bar
-                             (FStar_Extraction_ML_Syntax.with_ty t0)
-                             (FStar_Extraction_ML_Syntax.MLE_Var x) in
-                         ((x, t0), uu___4) in
-                       uu___3 :: more_args in
-                     eta_args g2 uu___2 t1)
-            | FStar_Extraction_ML_Syntax.MLTY_Named (uu___, uu___1) ->
-                ((FStar_Compiler_List.rev more_args), t)
-            | uu___ ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Extraction_ML_UEnv.current_module_of_uenv g1 in
-                    FStar_Extraction_ML_Code.string_of_mlexpr uu___3
-                      mlAppExpr in
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Extraction_ML_UEnv.current_module_of_uenv g1 in
-                    FStar_Extraction_ML_Code.string_of_mlty uu___4 t in
-                  FStar_Compiler_Util.format2
-                    "Impossible: Head type is not an arrow: (%s : %s)" uu___2
-                    uu___3 in
-                failwith uu___1 in
-          let as_record qual1 e =
-            match ((e.FStar_Extraction_ML_Syntax.expr), qual1) with
-            | (FStar_Extraction_ML_Syntax.MLE_CTor (uu___, args),
-               FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-               (tyname, fields))) ->
-                let path =
-                  let uu___1 = FStar_Ident.ns_of_lid tyname in
-                  FStar_Compiler_List.map FStar_Ident.string_of_id uu___1 in
-                let fields1 = record_fields g tyname fields args in
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     e.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_Record (path, fields1))
-            | uu___ -> e in
-          let resugar_and_maybe_eta qual1 e =
-            let uu___ = eta_args g [] residualType in
-            match uu___ with
-            | (eargs, tres) ->
-                (match eargs with
-                 | [] ->
-                     let uu___1 = as_record qual1 e in
-                     FStar_Extraction_ML_Util.resugar_exp uu___1
-                 | uu___1 ->
-                     let uu___2 = FStar_Compiler_List.unzip eargs in
-                     (match uu___2 with
-                      | (binders, eargs1) ->
-                          (match e.FStar_Extraction_ML_Syntax.expr with
-                           | FStar_Extraction_ML_Syntax.MLE_CTor (head, args)
-                               ->
-                               let body =
-                                 let uu___3 =
-                                   let uu___4 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (FStar_Extraction_ML_Syntax.with_ty
-                                          tres)
-                                       (FStar_Extraction_ML_Syntax.MLE_CTor
-                                          (head,
-                                            (FStar_Compiler_List.op_At args
-                                               eargs1))) in
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (as_record qual1) uu___4 in
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   FStar_Extraction_ML_Util.resugar_exp
-                                   uu___3 in
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_Extraction_ML_Syntax.with_ty
-                                    e.FStar_Extraction_ML_Syntax.mlty)
-                                 (FStar_Extraction_ML_Syntax.MLE_Fun
-                                    (binders, body))
-                           | uu___3 ->
-                               failwith "Impossible: Not a constructor"))) in
-          match ((mlAppExpr.FStar_Extraction_ML_Syntax.expr), qual) with
-          | (uu___, FStar_Pervasives_Native.None) -> mlAppExpr
-          | (FStar_Extraction_ML_Syntax.MLE_App
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                FStar_Extraction_ML_Syntax.mlty = uu___;
-                FStar_Extraction_ML_Syntax.loc = uu___1;_},
-              mle::args),
-             FStar_Pervasives_Native.Some
-             (FStar_Syntax_Syntax.Record_projector (constrname, f))) ->
-              let fn =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                    FStar_TypeChecker_Env.typ_of_datacon uu___4 constrname in
-                  (uu___3, f) in
-                FStar_Extraction_ML_UEnv.lookup_record_field_name g uu___2 in
-              let proj = FStar_Extraction_ML_Syntax.MLE_Proj (mle, fn) in
-              let e =
-                match args with
-                | [] -> proj
-                | uu___2 ->
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty
-                             FStar_Extraction_ML_Syntax.MLTY_Top) proj in
-                      (uu___4, args) in
-                    FStar_Extraction_ML_Syntax.MLE_App uu___3 in
-              FStar_Extraction_ML_Syntax.with_ty
-                mlAppExpr.FStar_Extraction_ML_Syntax.mlty e
-          | (FStar_Extraction_ML_Syntax.MLE_App
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_TApp
-                  ({
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                     FStar_Extraction_ML_Syntax.mlty = uu___;
-                     FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                   uu___2);
-                FStar_Extraction_ML_Syntax.mlty = uu___3;
-                FStar_Extraction_ML_Syntax.loc = uu___4;_},
-              mle::args),
-             FStar_Pervasives_Native.Some
-             (FStar_Syntax_Syntax.Record_projector (constrname, f))) ->
-              let fn =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                    FStar_TypeChecker_Env.typ_of_datacon uu___7 constrname in
-                  (uu___6, f) in
-                FStar_Extraction_ML_UEnv.lookup_record_field_name g uu___5 in
-              let proj = FStar_Extraction_ML_Syntax.MLE_Proj (mle, fn) in
-              let e =
-                match args with
-                | [] -> proj
-                | uu___5 ->
-                    let uu___6 =
-                      let uu___7 =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty
-                             FStar_Extraction_ML_Syntax.MLTY_Top) proj in
-                      (uu___7, args) in
-                    FStar_Extraction_ML_Syntax.MLE_App uu___6 in
-              FStar_Extraction_ML_Syntax.with_ty
-                mlAppExpr.FStar_Extraction_ML_Syntax.mlty e
-          | (FStar_Extraction_ML_Syntax.MLE_App
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                FStar_Extraction_ML_Syntax.mlty = uu___;
-                FStar_Extraction_ML_Syntax.loc = uu___1;_},
-              mlargs),
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Data_ctor)) ->
-              let uu___2 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, mlargs)) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___2
-          | (FStar_Extraction_ML_Syntax.MLE_App
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                FStar_Extraction_ML_Syntax.mlty = uu___;
-                FStar_Extraction_ML_Syntax.loc = uu___1;_},
-              mlargs),
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-             uu___2)) ->
-              let uu___3 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, mlargs)) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___3
-          | (FStar_Extraction_ML_Syntax.MLE_App
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_TApp
-                  ({
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                     FStar_Extraction_ML_Syntax.mlty = uu___;
-                     FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                   uu___2);
-                FStar_Extraction_ML_Syntax.mlty = uu___3;
-                FStar_Extraction_ML_Syntax.loc = uu___4;_},
-              mlargs),
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Data_ctor)) ->
-              let uu___5 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, mlargs)) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___5
-          | (FStar_Extraction_ML_Syntax.MLE_App
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_TApp
-                  ({
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                     FStar_Extraction_ML_Syntax.mlty = uu___;
-                     FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                   uu___2);
-                FStar_Extraction_ML_Syntax.mlty = uu___3;
-                FStar_Extraction_ML_Syntax.loc = uu___4;_},
-              mlargs),
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-             uu___5)) ->
-              let uu___6 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, mlargs)) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___6
-          | (FStar_Extraction_ML_Syntax.MLE_Name mlp,
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Data_ctor)) ->
-              let uu___ =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, [])) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___
-          | (FStar_Extraction_ML_Syntax.MLE_Name mlp,
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-             uu___)) ->
-              let uu___1 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, [])) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___1
-          | (FStar_Extraction_ML_Syntax.MLE_TApp
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                FStar_Extraction_ML_Syntax.mlty = uu___;
-                FStar_Extraction_ML_Syntax.loc = uu___1;_},
-              uu___2),
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Data_ctor)) ->
-              let uu___3 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, [])) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___3
-          | (FStar_Extraction_ML_Syntax.MLE_TApp
-             ({
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_Name mlp;
-                FStar_Extraction_ML_Syntax.mlty = uu___;
-                FStar_Extraction_ML_Syntax.loc = uu___1;_},
-              uu___2),
-             FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-             uu___3)) ->
-              let uu___4 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     mlAppExpr.FStar_Extraction_ML_Syntax.mlty)
-                  (FStar_Extraction_ML_Syntax.MLE_CTor (mlp, [])) in
-              FStar_Compiler_Effect.op_Less_Bar (resugar_and_maybe_eta qual)
-                uu___4
-          | uu___ -> mlAppExpr
-let (maybe_promote_effect :
-  FStar_Extraction_ML_Syntax.mlexpr ->
-    FStar_Extraction_ML_Syntax.e_tag ->
-      FStar_Extraction_ML_Syntax.mlty ->
-        (FStar_Extraction_ML_Syntax.mlexpr *
-          FStar_Extraction_ML_Syntax.e_tag))
-  =
-  fun ml_e ->
-    fun tag ->
-      fun t ->
-        match (tag, t) with
-        | (FStar_Extraction_ML_Syntax.E_ERASABLE,
-           FStar_Extraction_ML_Syntax.MLTY_Erased) ->
-            (FStar_Extraction_ML_Syntax.ml_unit,
-              FStar_Extraction_ML_Syntax.E_PURE)
-        | (FStar_Extraction_ML_Syntax.E_PURE,
-           FStar_Extraction_ML_Syntax.MLTY_Erased) ->
-            (FStar_Extraction_ML_Syntax.ml_unit,
-              FStar_Extraction_ML_Syntax.E_PURE)
-        | uu___ -> (ml_e, tag)
-let (extract_lb_sig :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.letbindings ->
-      (FStar_Syntax_Syntax.lbname * FStar_Extraction_ML_Syntax.e_tag *
-        (FStar_Syntax_Syntax.typ * (FStar_Syntax_Syntax.binders *
-        FStar_Extraction_ML_Syntax.mltyscheme)) * Prims.bool *
-        FStar_Syntax_Syntax.term) Prims.list)
-  =
-  fun g ->
-    fun lbs ->
-      let maybe_generalize uu___ =
-        match uu___ with
-        | { FStar_Syntax_Syntax.lbname = lbname_;
-            FStar_Syntax_Syntax.lbunivs = uu___1;
-            FStar_Syntax_Syntax.lbtyp = lbtyp;
-            FStar_Syntax_Syntax.lbeff = lbeff;
-            FStar_Syntax_Syntax.lbdef = lbdef;
-            FStar_Syntax_Syntax.lbattrs = lbattrs;
-            FStar_Syntax_Syntax.lbpos = uu___2;_} ->
-            let f_e = effect_as_etag g lbeff in
-            let lbtyp1 = FStar_Syntax_Subst.compress lbtyp in
-            let no_gen uu___3 =
-              let expected_t = term_as_mlty g lbtyp1 in
-              (lbname_, f_e, (lbtyp1, ([], ([], expected_t))), false, lbdef) in
-            let uu___3 =
-              let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-              FStar_TypeChecker_Util.must_erase_for_extraction uu___4 lbtyp1 in
-            if uu___3
-            then
-              (lbname_, f_e,
-                (lbtyp1, ([], ([], FStar_Extraction_ML_Syntax.MLTY_Erased))),
-                false, lbdef)
-            else
-              (match lbtyp1.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_arrow (bs, c) when
-                   let uu___5 = FStar_Compiler_List.hd bs in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___5
-                     (is_type_binder g)
-                   ->
-                   let uu___5 = FStar_Syntax_Subst.open_comp bs c in
-                   (match uu___5 with
-                    | (bs1, c1) ->
-                        let uu___6 =
-                          let uu___7 =
-                            FStar_Compiler_Util.prefix_until
-                              (fun x ->
-                                 let uu___8 = is_type_binder g x in
-                                 Prims.op_Negation uu___8) bs1 in
-                          match uu___7 with
-                          | FStar_Pervasives_Native.None ->
-                              (bs1, (FStar_Syntax_Util.comp_result c1))
-                          | FStar_Pervasives_Native.Some (bs2, b, rest) ->
-                              let uu___8 =
-                                FStar_Syntax_Util.arrow (b :: rest) c1 in
-                              (bs2, uu___8) in
-                        (match uu___6 with
-                         | (tbinders, tbody) ->
-                             let n_tbinders =
-                               FStar_Compiler_List.length tbinders in
-                             let lbdef1 =
-                               let uu___7 = normalize_abs lbdef in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                 FStar_Syntax_Util.unmeta in
-                             (match lbdef1.FStar_Syntax_Syntax.n with
-                              | FStar_Syntax_Syntax.Tm_abs (bs2, body, copt)
-                                  ->
-                                  let uu___7 =
-                                    FStar_Syntax_Subst.open_term bs2 body in
-                                  (match uu___7 with
-                                   | (bs3, body1) ->
-                                       if
-                                         n_tbinders <=
-                                           (FStar_Compiler_List.length bs3)
-                                       then
-                                         let uu___8 =
-                                           FStar_Compiler_Util.first_N
-                                             n_tbinders bs3 in
-                                         (match uu___8 with
-                                          | (targs, rest_args) ->
-                                              let expected_source_ty =
-                                                let s =
-                                                  FStar_Compiler_List.map2
-                                                    (fun uu___9 ->
-                                                       fun uu___10 ->
-                                                         match (uu___9,
-                                                                 uu___10)
-                                                         with
-                                                         | ({
-                                                              FStar_Syntax_Syntax.binder_bv
-                                                                = x;
-                                                              FStar_Syntax_Syntax.binder_qual
-                                                                = uu___11;
-                                                              FStar_Syntax_Syntax.binder_attrs
-                                                                = uu___12;_},
-                                                            {
-                                                              FStar_Syntax_Syntax.binder_bv
-                                                                = y;
-                                                              FStar_Syntax_Syntax.binder_qual
-                                                                = uu___13;
-                                                              FStar_Syntax_Syntax.binder_attrs
-                                                                = uu___14;_})
-                                                             ->
-                                                             let uu___15 =
-                                                               let uu___16 =
-                                                                 FStar_Syntax_Syntax.bv_to_name
-                                                                   y in
-                                                               (x, uu___16) in
-                                                             FStar_Syntax_Syntax.NT
-                                                               uu___15)
-                                                    tbinders targs in
-                                                FStar_Syntax_Subst.subst s
-                                                  tbody in
-                                              let env =
-                                                FStar_Compiler_List.fold_left
-                                                  (fun env1 ->
-                                                     fun uu___9 ->
-                                                       match uu___9 with
-                                                       | {
-                                                           FStar_Syntax_Syntax.binder_bv
-                                                             = a;
-                                                           FStar_Syntax_Syntax.binder_qual
-                                                             = uu___10;
-                                                           FStar_Syntax_Syntax.binder_attrs
-                                                             = uu___11;_}
-                                                           ->
-                                                           FStar_Extraction_ML_UEnv.extend_ty
-                                                             env1 a false) g
-                                                  targs in
-                                              let expected_t =
-                                                term_as_mlty env
-                                                  expected_source_ty in
-                                              let polytype =
-                                                let uu___9 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    targs
-                                                    (FStar_Compiler_List.map
-                                                       (fun uu___10 ->
-                                                          match uu___10 with
-                                                          | {
-                                                              FStar_Syntax_Syntax.binder_bv
-                                                                = x;
-                                                              FStar_Syntax_Syntax.binder_qual
-                                                                = uu___11;
-                                                              FStar_Syntax_Syntax.binder_attrs
-                                                                = uu___12;_}
-                                                              ->
-                                                              let uu___13 =
-                                                                FStar_Extraction_ML_UEnv.lookup_ty
-                                                                  env x in
-                                                              uu___13.FStar_Extraction_ML_UEnv.ty_b_name)) in
-                                                (uu___9, expected_t) in
-                                              let add_unit =
-                                                match rest_args with
-                                                | [] ->
-                                                    (let uu___9 =
-                                                       is_fstar_value body1 in
-                                                     Prims.op_Negation uu___9)
-                                                      ||
-                                                      (let uu___9 =
-                                                         FStar_Syntax_Util.is_pure_comp
-                                                           c1 in
-                                                       Prims.op_Negation
-                                                         uu___9)
-                                                | uu___9 -> false in
-                                              let rest_args1 =
-                                                if add_unit
-                                                then
-                                                  let uu___9 = unit_binder () in
-                                                  uu___9 :: rest_args
-                                                else rest_args in
-                                              let polytype1 =
-                                                if add_unit
-                                                then
-                                                  FStar_Extraction_ML_Syntax.push_unit
-                                                    polytype
-                                                else polytype in
-                                              let body2 =
-                                                FStar_Syntax_Util.abs
-                                                  rest_args1 body1 copt in
-                                              (lbname_, f_e,
-                                                (lbtyp1, (targs, polytype1)),
-                                                add_unit, body2))
-                                       else
-                                         failwith "Not enough type binders")
-                              | FStar_Syntax_Syntax.Tm_uinst uu___7 ->
-                                  let env =
-                                    FStar_Compiler_List.fold_left
-                                      (fun env1 ->
-                                         fun uu___8 ->
-                                           match uu___8 with
-                                           | {
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 = a;
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 = uu___9;
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 = uu___10;_}
-                                               ->
-                                               FStar_Extraction_ML_UEnv.extend_ty
-                                                 env1 a false) g tbinders in
-                                  let expected_t = term_as_mlty env tbody in
-                                  let polytype =
-                                    let uu___8 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        tbinders
-                                        (FStar_Compiler_List.map
-                                           (fun uu___9 ->
-                                              match uu___9 with
-                                              | {
-                                                  FStar_Syntax_Syntax.binder_bv
-                                                    = x;
-                                                  FStar_Syntax_Syntax.binder_qual
-                                                    = uu___10;
-                                                  FStar_Syntax_Syntax.binder_attrs
-                                                    = uu___11;_}
-                                                  ->
-                                                  let uu___12 =
-                                                    FStar_Extraction_ML_UEnv.lookup_ty
-                                                      env x in
-                                                  uu___12.FStar_Extraction_ML_UEnv.ty_b_name)) in
-                                    (uu___8, expected_t) in
-                                  let args =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      tbinders
-                                      (FStar_Compiler_List.map
-                                         (fun uu___8 ->
-                                            match uu___8 with
-                                            | {
-                                                FStar_Syntax_Syntax.binder_bv
-                                                  = bv;
-                                                FStar_Syntax_Syntax.binder_qual
-                                                  = uu___9;
-                                                FStar_Syntax_Syntax.binder_attrs
-                                                  = uu___10;_}
-                                                ->
-                                                let uu___11 =
-                                                  FStar_Syntax_Syntax.bv_to_name
-                                                    bv in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___11
-                                                  FStar_Syntax_Syntax.as_arg)) in
-                                  let e =
-                                    FStar_Syntax_Syntax.mk
-                                      (FStar_Syntax_Syntax.Tm_app
-                                         (lbdef1, args))
-                                      lbdef1.FStar_Syntax_Syntax.pos in
-                                  (lbname_, f_e,
-                                    (lbtyp1, (tbinders, polytype)), false, e)
-                              | FStar_Syntax_Syntax.Tm_fvar uu___7 ->
-                                  let env =
-                                    FStar_Compiler_List.fold_left
-                                      (fun env1 ->
-                                         fun uu___8 ->
-                                           match uu___8 with
-                                           | {
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 = a;
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 = uu___9;
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 = uu___10;_}
-                                               ->
-                                               FStar_Extraction_ML_UEnv.extend_ty
-                                                 env1 a false) g tbinders in
-                                  let expected_t = term_as_mlty env tbody in
-                                  let polytype =
-                                    let uu___8 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        tbinders
-                                        (FStar_Compiler_List.map
-                                           (fun uu___9 ->
-                                              match uu___9 with
-                                              | {
-                                                  FStar_Syntax_Syntax.binder_bv
-                                                    = x;
-                                                  FStar_Syntax_Syntax.binder_qual
-                                                    = uu___10;
-                                                  FStar_Syntax_Syntax.binder_attrs
-                                                    = uu___11;_}
-                                                  ->
-                                                  let uu___12 =
-                                                    FStar_Extraction_ML_UEnv.lookup_ty
-                                                      env x in
-                                                  uu___12.FStar_Extraction_ML_UEnv.ty_b_name)) in
-                                    (uu___8, expected_t) in
-                                  let args =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      tbinders
-                                      (FStar_Compiler_List.map
-                                         (fun uu___8 ->
-                                            match uu___8 with
-                                            | {
-                                                FStar_Syntax_Syntax.binder_bv
-                                                  = bv;
-                                                FStar_Syntax_Syntax.binder_qual
-                                                  = uu___9;
-                                                FStar_Syntax_Syntax.binder_attrs
-                                                  = uu___10;_}
-                                                ->
-                                                let uu___11 =
-                                                  FStar_Syntax_Syntax.bv_to_name
-                                                    bv in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___11
-                                                  FStar_Syntax_Syntax.as_arg)) in
-                                  let e =
-                                    FStar_Syntax_Syntax.mk
-                                      (FStar_Syntax_Syntax.Tm_app
-                                         (lbdef1, args))
-                                      lbdef1.FStar_Syntax_Syntax.pos in
-                                  (lbname_, f_e,
-                                    (lbtyp1, (tbinders, polytype)), false, e)
-                              | FStar_Syntax_Syntax.Tm_name uu___7 ->
-                                  let env =
-                                    FStar_Compiler_List.fold_left
-                                      (fun env1 ->
-                                         fun uu___8 ->
-                                           match uu___8 with
-                                           | {
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 = a;
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 = uu___9;
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 = uu___10;_}
-                                               ->
-                                               FStar_Extraction_ML_UEnv.extend_ty
-                                                 env1 a false) g tbinders in
-                                  let expected_t = term_as_mlty env tbody in
-                                  let polytype =
-                                    let uu___8 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        tbinders
-                                        (FStar_Compiler_List.map
-                                           (fun uu___9 ->
-                                              match uu___9 with
-                                              | {
-                                                  FStar_Syntax_Syntax.binder_bv
-                                                    = x;
-                                                  FStar_Syntax_Syntax.binder_qual
-                                                    = uu___10;
-                                                  FStar_Syntax_Syntax.binder_attrs
-                                                    = uu___11;_}
-                                                  ->
-                                                  let uu___12 =
-                                                    FStar_Extraction_ML_UEnv.lookup_ty
-                                                      env x in
-                                                  uu___12.FStar_Extraction_ML_UEnv.ty_b_name)) in
-                                    (uu___8, expected_t) in
-                                  let args =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      tbinders
-                                      (FStar_Compiler_List.map
-                                         (fun uu___8 ->
-                                            match uu___8 with
-                                            | {
-                                                FStar_Syntax_Syntax.binder_bv
-                                                  = bv;
-                                                FStar_Syntax_Syntax.binder_qual
-                                                  = uu___9;
-                                                FStar_Syntax_Syntax.binder_attrs
-                                                  = uu___10;_}
-                                                ->
-                                                let uu___11 =
-                                                  FStar_Syntax_Syntax.bv_to_name
-                                                    bv in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___11
-                                                  FStar_Syntax_Syntax.as_arg)) in
-                                  let e =
-                                    FStar_Syntax_Syntax.mk
-                                      (FStar_Syntax_Syntax.Tm_app
-                                         (lbdef1, args))
-                                      lbdef1.FStar_Syntax_Syntax.pos in
-                                  (lbname_, f_e,
-                                    (lbtyp1, (tbinders, polytype)), false, e)
-                              | uu___7 -> err_value_restriction lbdef1)))
-               | uu___5 -> no_gen ()) in
-      FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.snd lbs)
-        (FStar_Compiler_List.map maybe_generalize)
-let (extract_lb_iface :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.letbindings ->
-      (FStar_Extraction_ML_UEnv.uenv * (FStar_Syntax_Syntax.fv *
-        FStar_Extraction_ML_UEnv.exp_binding) Prims.list))
-  =
-  fun g ->
-    fun lbs ->
-      let is_top =
-        FStar_Syntax_Syntax.is_top_level (FStar_Pervasives_Native.snd lbs) in
-      let is_rec =
-        (Prims.op_Negation is_top) && (FStar_Pervasives_Native.fst lbs) in
-      let lbs1 = extract_lb_sig g lbs in
-      FStar_Compiler_Util.fold_map
-        (fun env ->
-           fun uu___ ->
-             match uu___ with
-             | (lbname, e_tag, (typ, (binders, mltyscheme)), add_unit, _body)
-                 ->
-                 let uu___1 =
-                   FStar_Extraction_ML_UEnv.extend_lb env lbname typ
-                     mltyscheme add_unit in
-                 (match uu___1 with
-                  | (env1, uu___2, exp_binding) ->
-                      let uu___3 =
-                        let uu___4 = FStar_Compiler_Util.right lbname in
-                        (uu___4, exp_binding) in
-                      (env1, uu___3))) g lbs1
-let rec (check_term_as_mlexpr :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Extraction_ML_Syntax.e_tag ->
-        FStar_Extraction_ML_Syntax.mlty ->
-          (FStar_Extraction_ML_Syntax.mlexpr *
-            FStar_Extraction_ML_Syntax.mlty))
-  =
-  fun g ->
-    fun e ->
-      fun f ->
-        fun ty ->
-          FStar_Extraction_ML_UEnv.debug g
-            (fun uu___1 ->
-               let uu___2 = FStar_Syntax_Print.term_to_string e in
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-                 FStar_Extraction_ML_Code.string_of_mlty uu___4 ty in
-               let uu___4 = FStar_Extraction_ML_Util.eff_to_string f in
-               FStar_Compiler_Util.print3
-                 "Checking %s at type %s and eff %s\n" uu___2 uu___3 uu___4);
-          (match (f, ty) with
-           | (FStar_Extraction_ML_Syntax.E_ERASABLE, uu___1) ->
-               (FStar_Extraction_ML_Syntax.ml_unit,
-                 FStar_Extraction_ML_Syntax.MLTY_Erased)
-           | (FStar_Extraction_ML_Syntax.E_PURE,
-              FStar_Extraction_ML_Syntax.MLTY_Erased) ->
-               (FStar_Extraction_ML_Syntax.ml_unit,
-                 FStar_Extraction_ML_Syntax.MLTY_Erased)
-           | uu___1 ->
-               let uu___2 = term_as_mlexpr g e in
-               (match uu___2 with
-                | (ml_e, tag, t) ->
-                    let uu___3 = FStar_Extraction_ML_Util.eff_leq tag f in
-                    if uu___3
-                    then
-                      let uu___4 =
-                        maybe_coerce e.FStar_Syntax_Syntax.pos g ml_e t ty in
-                      (uu___4, ty)
-                    else
-                      (match (tag, f, ty) with
-                       | (FStar_Extraction_ML_Syntax.E_ERASABLE,
-                          FStar_Extraction_ML_Syntax.E_PURE,
-                          FStar_Extraction_ML_Syntax.MLTY_Erased) ->
-                           let uu___5 =
-                             maybe_coerce e.FStar_Syntax_Syntax.pos g ml_e t
-                               ty in
-                           (uu___5, ty)
-                       | uu___5 ->
-                           (err_unexpected_eff g e ty f tag;
-                            (let uu___7 =
-                               maybe_coerce e.FStar_Syntax_Syntax.pos g ml_e
-                                 t ty in
-                             (uu___7, ty))))))
-and (term_as_mlexpr :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Extraction_ML_Syntax.mlexpr * FStar_Extraction_ML_Syntax.e_tag *
-        FStar_Extraction_ML_Syntax.mlty))
-  =
-  fun g ->
-    fun e ->
-      let uu___ = term_as_mlexpr' g e in
-      match uu___ with
-      | (e1, f, t) ->
-          let uu___1 = maybe_promote_effect e1 f t in
-          (match uu___1 with | (e2, f1) -> (e2, f1, t))
-and (term_as_mlexpr' :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Extraction_ML_Syntax.mlexpr * FStar_Extraction_ML_Syntax.e_tag *
-        FStar_Extraction_ML_Syntax.mlty))
-  =
-  fun g ->
-    fun top ->
-      let top1 = FStar_Syntax_Subst.compress top in
-      FStar_Extraction_ML_UEnv.debug g
-        (fun u ->
-           let uu___1 =
-             let uu___2 =
-               FStar_Compiler_Range.string_of_range
-                 top1.FStar_Syntax_Syntax.pos in
-             let uu___3 = FStar_Syntax_Print.tag_of_term top1 in
-             let uu___4 = FStar_Syntax_Print.term_to_string top1 in
-             FStar_Compiler_Util.format3 "%s: term_as_mlexpr' (%s) :  %s \n"
-               uu___2 uu___3 uu___4 in
-           FStar_Compiler_Util.print_string uu___1);
-      (let is_match t =
-         let uu___1 =
-           let uu___2 =
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater t
-                 FStar_Syntax_Subst.compress in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               FStar_Syntax_Util.unascribe in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_match uu___2 -> true
-         | uu___2 -> false in
-       let should_apply_to_match_branches =
-         FStar_Compiler_List.for_all
-           (fun uu___1 ->
-              match uu___1 with
-              | (t, uu___2) ->
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_Effect.op_Bar_Greater t
-                        FStar_Syntax_Subst.compress in
-                    uu___4.FStar_Syntax_Syntax.n in
-                  (match uu___3 with
-                   | FStar_Syntax_Syntax.Tm_name uu___4 -> true
-                   | FStar_Syntax_Syntax.Tm_fvar uu___4 -> true
-                   | FStar_Syntax_Syntax.Tm_constant uu___4 -> true
-                   | uu___4 -> false)) in
-       let apply_to_match_branches head args =
-         let uu___1 =
-           let uu___2 =
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater head
-                 FStar_Syntax_Subst.compress in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               FStar_Syntax_Util.unascribe in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_match (scrutinee, uu___2, branches, uu___3)
-             ->
-             let branches1 =
-               FStar_Compiler_Effect.op_Bar_Greater branches
-                 (FStar_Compiler_List.map
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | (pat, when_opt, body) ->
-                           (pat, when_opt,
-                             {
-                               FStar_Syntax_Syntax.n =
-                                 (FStar_Syntax_Syntax.Tm_app (body, args));
-                               FStar_Syntax_Syntax.pos =
-                                 (body.FStar_Syntax_Syntax.pos);
-                               FStar_Syntax_Syntax.vars =
-                                 (body.FStar_Syntax_Syntax.vars);
-                               FStar_Syntax_Syntax.hash_code =
-                                 (body.FStar_Syntax_Syntax.hash_code)
-                             }))) in
-             {
-               FStar_Syntax_Syntax.n =
-                 (FStar_Syntax_Syntax.Tm_match
-                    (scrutinee, FStar_Pervasives_Native.None, branches1,
-                      FStar_Pervasives_Native.None));
-               FStar_Syntax_Syntax.pos = (head.FStar_Syntax_Syntax.pos);
-               FStar_Syntax_Syntax.vars = (head.FStar_Syntax_Syntax.vars);
-               FStar_Syntax_Syntax.hash_code =
-                 (head.FStar_Syntax_Syntax.hash_code)
-             }
-         | uu___2 ->
-             failwith
-               "Impossible! cannot apply args to match branches if head is not a match" in
-       let t = FStar_Syntax_Subst.compress top1 in
-       match t.FStar_Syntax_Syntax.n with
-       | FStar_Syntax_Syntax.Tm_unknown ->
-           let uu___1 =
-             let uu___2 = FStar_Syntax_Print.tag_of_term t in
-             FStar_Compiler_Util.format1 "Impossible: Unexpected term: %s"
-               uu___2 in
-           failwith uu___1
-       | FStar_Syntax_Syntax.Tm_delayed uu___1 ->
-           let uu___2 =
-             let uu___3 = FStar_Syntax_Print.tag_of_term t in
-             FStar_Compiler_Util.format1 "Impossible: Unexpected term: %s"
-               uu___3 in
-           failwith uu___2
-       | FStar_Syntax_Syntax.Tm_uvar uu___1 ->
-           let uu___2 =
-             let uu___3 = FStar_Syntax_Print.tag_of_term t in
-             FStar_Compiler_Util.format1 "Impossible: Unexpected term: %s"
-               uu___3 in
-           failwith uu___2
-       | FStar_Syntax_Syntax.Tm_bvar uu___1 ->
-           let uu___2 =
-             let uu___3 = FStar_Syntax_Print.tag_of_term t in
-             FStar_Compiler_Util.format1 "Impossible: Unexpected term: %s"
-               uu___3 in
-           failwith uu___2
-       | FStar_Syntax_Syntax.Tm_lazy i ->
-           let uu___1 = FStar_Syntax_Util.unfold_lazy i in
-           term_as_mlexpr g uu___1
-       | FStar_Syntax_Syntax.Tm_type uu___1 ->
-           (FStar_Extraction_ML_Syntax.ml_unit,
-             FStar_Extraction_ML_Syntax.E_PURE,
-             FStar_Extraction_ML_Syntax.ml_unit_ty)
-       | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-           (FStar_Extraction_ML_Syntax.ml_unit,
-             FStar_Extraction_ML_Syntax.E_PURE,
-             FStar_Extraction_ML_Syntax.ml_unit_ty)
-       | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-           (FStar_Extraction_ML_Syntax.ml_unit,
-             FStar_Extraction_ML_Syntax.E_PURE,
-             FStar_Extraction_ML_Syntax.ml_unit_ty)
-       | FStar_Syntax_Syntax.Tm_quoted
-           (qt,
-            { FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_dynamic;
-              FStar_Syntax_Syntax.antiquotes = uu___1;_})
-           ->
-           let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Parser_Const.failwith_lid () in
-               FStar_Syntax_Syntax.lid_as_fv uu___4
-                 FStar_Syntax_Syntax.delta_constant
-                 FStar_Pervasives_Native.None in
-             FStar_Extraction_ML_UEnv.lookup_fv t.FStar_Syntax_Syntax.pos g
-               uu___3 in
-           (match uu___2 with
-            | { FStar_Extraction_ML_UEnv.exp_b_name = uu___3;
-                FStar_Extraction_ML_UEnv.exp_b_expr = fw;
-                FStar_Extraction_ML_UEnv.exp_b_tscheme = uu___4;_} ->
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 =
-                        let uu___9 =
-                          FStar_Compiler_Effect.op_Less_Bar
-                            (FStar_Extraction_ML_Syntax.with_ty
-                               FStar_Extraction_ML_Syntax.ml_string_ty)
-                            (FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                                  "Cannot evaluate open quotation at runtime")) in
-                        [uu___9] in
-                      (fw, uu___8) in
-                    FStar_Extraction_ML_Syntax.MLE_App uu___7 in
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_Extraction_ML_Syntax.with_ty
-                       FStar_Extraction_ML_Syntax.ml_int_ty) uu___6 in
-                (uu___5, FStar_Extraction_ML_Syntax.E_PURE,
-                  FStar_Extraction_ML_Syntax.ml_int_ty))
-       | FStar_Syntax_Syntax.Tm_quoted
-           (qt,
-            { FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_static;
-              FStar_Syntax_Syntax.antiquotes = aqs;_})
-           ->
-           let uu___1 = FStar_Reflection_Basic.inspect_ln qt in
-           (match uu___1 with
-            | FStar_Reflection_Data.Tv_Var bv ->
-                let uu___2 = FStar_Syntax_Syntax.lookup_aq bv aqs in
-                (match uu___2 with
-                 | FStar_Pervasives_Native.Some tm -> term_as_mlexpr g tm
-                 | FStar_Pervasives_Native.None ->
-                     let tv =
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_Reflection_Embeddings.e_term_view_aq aqs in
-                         FStar_Syntax_Embeddings.embed uu___4
-                           (FStar_Reflection_Data.Tv_Var bv) in
-                       uu___3 t.FStar_Syntax_Syntax.pos
-                         FStar_Pervasives_Native.None
-                         FStar_Syntax_Embeddings.id_norm_cb in
-                     let t1 =
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Syntax.as_arg tv in
-                         [uu___4] in
-                       FStar_Syntax_Util.mk_app
-                         (FStar_Reflection_Constants.refl_constant_term
-                            FStar_Reflection_Constants.fstar_refl_pack_ln)
-                         uu___3 in
-                     term_as_mlexpr g t1)
-            | tv ->
-                let tv1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Reflection_Embeddings.e_term_view_aq aqs in
-                    FStar_Syntax_Embeddings.embed uu___3 tv in
-                  uu___2 t.FStar_Syntax_Syntax.pos
-                    FStar_Pervasives_Native.None
-                    FStar_Syntax_Embeddings.id_norm_cb in
-                let t1 =
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Syntax.as_arg tv1 in [uu___3] in
-                  FStar_Syntax_Util.mk_app
-                    (FStar_Reflection_Constants.refl_constant_term
-                       FStar_Reflection_Constants.fstar_refl_pack_ln) uu___2 in
-                term_as_mlexpr g t1)
-       | FStar_Syntax_Syntax.Tm_meta
-           (t1, FStar_Syntax_Syntax.Meta_monadic (m, uu___1)) ->
-           let t2 = FStar_Syntax_Subst.compress t1 in
-           (match t2.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) when
-                FStar_Compiler_Util.is_left lb.FStar_Syntax_Syntax.lbname ->
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                    FStar_TypeChecker_Env.effect_decl_opt uu___4 m in
-                  FStar_Compiler_Util.must uu___3 in
-                (match uu___2 with
-                 | (ed, qualifiers) ->
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                         FStar_TypeChecker_Env.is_reifiable_effect uu___5
-                           ed.FStar_Syntax_Syntax.mname in
-                       Prims.op_Negation uu___4 in
-                     if uu___3
-                     then term_as_mlexpr g t2
-                     else
-                       failwith
-                         "This should not happen (should have been handled at Tm_abs level)")
-            | uu___2 -> term_as_mlexpr g t2)
-       | FStar_Syntax_Syntax.Tm_meta
-           (t1, FStar_Syntax_Syntax.Meta_monadic_lift (m1, _m2, _ty)) when
-           let uu___1 = effect_as_etag g m1 in
-           uu___1 = FStar_Extraction_ML_Syntax.E_ERASABLE ->
-           (FStar_Extraction_ML_Syntax.ml_unit,
-             FStar_Extraction_ML_Syntax.E_ERASABLE,
-             FStar_Extraction_ML_Syntax.MLTY_Erased)
-       | FStar_Syntax_Syntax.Tm_meta
-           (t1, FStar_Syntax_Syntax.Meta_desugared
-            (FStar_Syntax_Syntax.Machine_integer (signedness, width)))
-           ->
-           let t2 = FStar_Syntax_Subst.compress t1 in
-           let t3 = FStar_Syntax_Util.unascribe t2 in
-           (match t3.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Tm_app (hd, (x, uu___1)::[]) ->
-                let x1 = FStar_Syntax_Subst.compress x in
-                let x2 = FStar_Syntax_Util.unascribe x1 in
-                (match x2.FStar_Syntax_Syntax.n with
-                 | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_int
-                     (repr, uu___2)) ->
-                     let uu___3 =
-                       let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                       FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term
-                         uu___4 t3 true in
-                     (match uu___3 with
-                      | (uu___4, ty, uu___5) ->
-                          let ml_ty = term_as_mlty g ty in
-                          let ml_const =
-                            FStar_Const.Const_int
-                              (repr,
-                                (FStar_Pervasives_Native.Some
-                                   (signedness, width))) in
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Extraction_ML_Util.mlexpr_of_const
-                                t3.FStar_Syntax_Syntax.pos ml_const in
-                            FStar_Extraction_ML_Syntax.with_ty ml_ty uu___7 in
-                          (uu___6, FStar_Extraction_ML_Syntax.E_PURE, ml_ty))
-                 | uu___2 -> term_as_mlexpr g t3)
-            | uu___1 -> term_as_mlexpr g t3)
-       | FStar_Syntax_Syntax.Tm_meta (t1, uu___1) -> term_as_mlexpr g t1
-       | FStar_Syntax_Syntax.Tm_uinst (t1, uu___1) -> term_as_mlexpr g t1
-       | FStar_Syntax_Syntax.Tm_constant c ->
-           let uu___1 =
-             let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-             FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term uu___2 t true in
-           (match uu___1 with
-            | (uu___2, ty, uu___3) ->
-                let ml_ty = term_as_mlty g ty in
-                let uu___4 =
-                  let uu___5 =
-                    FStar_Extraction_ML_Util.mlexpr_of_const
-                      t.FStar_Syntax_Syntax.pos c in
-                  FStar_Extraction_ML_Syntax.with_ty ml_ty uu___5 in
-                (uu___4, FStar_Extraction_ML_Syntax.E_PURE, ml_ty))
-       | FStar_Syntax_Syntax.Tm_name uu___1 ->
-           let uu___2 = is_type g t in
-           if uu___2
-           then
-             (FStar_Extraction_ML_Syntax.ml_unit,
-               FStar_Extraction_ML_Syntax.E_PURE,
-               FStar_Extraction_ML_Syntax.ml_unit_ty)
-           else
-             (let uu___4 = FStar_Extraction_ML_UEnv.lookup_term g t in
-              match uu___4 with
-              | (FStar_Pervasives.Inl uu___5, uu___6) ->
-                  (FStar_Extraction_ML_Syntax.ml_unit,
-                    FStar_Extraction_ML_Syntax.E_PURE,
-                    FStar_Extraction_ML_Syntax.ml_unit_ty)
-              | (FStar_Pervasives.Inr
-                 { FStar_Extraction_ML_UEnv.exp_b_name = uu___5;
-                   FStar_Extraction_ML_UEnv.exp_b_expr = x;
-                   FStar_Extraction_ML_UEnv.exp_b_tscheme = mltys;_},
-                 qual) ->
-                  (match mltys with
-                   | ([], t1) when t1 = FStar_Extraction_ML_Syntax.ml_unit_ty
-                       ->
-                       (FStar_Extraction_ML_Syntax.ml_unit,
-                         FStar_Extraction_ML_Syntax.E_PURE, t1)
-                   | ([], t1) ->
-                       let uu___6 =
-                         maybe_eta_data_and_project_record g qual t1 x in
-                       (uu___6, FStar_Extraction_ML_Syntax.E_PURE, t1)
-                   | uu___6 -> instantiate_maybe_partial g x mltys []))
-       | FStar_Syntax_Syntax.Tm_fvar fv ->
-           let uu___1 = is_type g t in
-           if uu___1
-           then
-             (FStar_Extraction_ML_Syntax.ml_unit,
-               FStar_Extraction_ML_Syntax.E_PURE,
-               FStar_Extraction_ML_Syntax.ml_unit_ty)
-           else
-             (let uu___3 =
-                FStar_Extraction_ML_UEnv.try_lookup_fv
-                  t.FStar_Syntax_Syntax.pos g fv in
-              match uu___3 with
-              | FStar_Pervasives_Native.None ->
-                  (FStar_Extraction_ML_Syntax.ml_unit,
-                    FStar_Extraction_ML_Syntax.E_PURE,
-                    FStar_Extraction_ML_Syntax.MLTY_Erased)
-              | FStar_Pervasives_Native.Some
-                  { FStar_Extraction_ML_UEnv.exp_b_name = uu___4;
-                    FStar_Extraction_ML_UEnv.exp_b_expr = x;
-                    FStar_Extraction_ML_UEnv.exp_b_tscheme = mltys;_}
-                  ->
-                  (FStar_Extraction_ML_UEnv.debug g
-                     (fun uu___6 ->
-                        let uu___7 = FStar_Syntax_Print.fv_to_string fv in
-                        let uu___8 =
-                          let uu___9 =
-                            FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-                          FStar_Extraction_ML_Code.string_of_mlexpr uu___9 x in
-                        let uu___9 =
-                          let uu___10 =
-                            FStar_Extraction_ML_UEnv.current_module_of_uenv g in
-                          FStar_Extraction_ML_Code.string_of_mlty uu___10
-                            (FStar_Pervasives_Native.snd mltys) in
-                        FStar_Compiler_Util.print3
-                          "looked up %s: got %s at %s \n" uu___7 uu___8
-                          uu___9);
-                   (match mltys with
-                    | ([], t1) when
-                        t1 = FStar_Extraction_ML_Syntax.ml_unit_ty ->
-                        (FStar_Extraction_ML_Syntax.ml_unit,
-                          FStar_Extraction_ML_Syntax.E_PURE, t1)
-                    | ([], t1) ->
-                        let uu___6 =
-                          maybe_eta_data_and_project_record g
-                            fv.FStar_Syntax_Syntax.fv_qual t1 x in
-                        (uu___6, FStar_Extraction_ML_Syntax.E_PURE, t1)
-                    | uu___6 -> instantiate_maybe_partial g x mltys [])))
-       | FStar_Syntax_Syntax.Tm_abs (bs, body, rcopt) ->
-           let uu___1 = FStar_Syntax_Subst.open_term bs body in
-           (match uu___1 with
-            | (bs1, body1) ->
-                let uu___2 = binders_as_ml_binders g bs1 in
-                (match uu___2 with
-                 | (ml_bs, env) ->
-                     let body2 =
-                       match rcopt with
-                       | FStar_Pervasives_Native.Some rc ->
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-                             FStar_TypeChecker_Env.is_reifiable_rc uu___4 rc in
-                           if uu___3
-                           then
-                             let uu___4 =
-                               FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-                             FStar_TypeChecker_Util.reify_body uu___4
-                               [FStar_TypeChecker_Env.Inlining;
-                               FStar_TypeChecker_Env.ForExtraction;
-                               FStar_TypeChecker_Env.Unascribe] body1
-                           else body1
-                       | FStar_Pervasives_Native.None ->
-                           (FStar_Extraction_ML_UEnv.debug g
-                              (fun uu___4 ->
-                                 let uu___5 =
-                                   FStar_Syntax_Print.term_to_string body1 in
-                                 FStar_Compiler_Util.print1
-                                   "No computation type for: %s\n" uu___5);
-                            body1) in
-                     let uu___3 = term_as_mlexpr env body2 in
-                     (match uu___3 with
-                      | (ml_body, f, t1) ->
-                          let uu___4 =
-                            FStar_Compiler_List.fold_right
-                              (fun uu___5 ->
-                                 fun uu___6 ->
-                                   match (uu___5, uu___6) with
-                                   | ((uu___7, targ), (f1, t2)) ->
-                                       (FStar_Extraction_ML_Syntax.E_PURE,
-                                         (FStar_Extraction_ML_Syntax.MLTY_Fun
-                                            (targ, f1, t2)))) ml_bs (f, t1) in
-                          (match uu___4 with
-                           | (f1, tfun) ->
-                               let uu___5 =
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (FStar_Extraction_ML_Syntax.with_ty tfun)
-                                   (FStar_Extraction_ML_Syntax.MLE_Fun
-                                      (ml_bs, ml_body)) in
-                               (uu___5, f1, tfun)))))
-       | FStar_Syntax_Syntax.Tm_app
-           ({
-              FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_range_of);
-              FStar_Syntax_Syntax.pos = uu___1;
-              FStar_Syntax_Syntax.vars = uu___2;
-              FStar_Syntax_Syntax.hash_code = uu___3;_},
-            (a1, uu___4)::[])
-           ->
-           let ty =
-             let uu___5 =
-               FStar_Syntax_Syntax.tabbrev FStar_Parser_Const.range_lid in
-             term_as_mlty g uu___5 in
-           let uu___5 =
-             let uu___6 =
-               FStar_Extraction_ML_Util.mlexpr_of_range
-                 a1.FStar_Syntax_Syntax.pos in
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_Extraction_ML_Syntax.with_ty ty) uu___6 in
-           (uu___5, FStar_Extraction_ML_Syntax.E_PURE, ty)
-       | FStar_Syntax_Syntax.Tm_app
-           ({
-              FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_set_range_of);
-              FStar_Syntax_Syntax.pos = uu___1;
-              FStar_Syntax_Syntax.vars = uu___2;
-              FStar_Syntax_Syntax.hash_code = uu___3;_},
-            (t1, uu___4)::(r, uu___5)::[])
-           -> term_as_mlexpr g t1
-       | FStar_Syntax_Syntax.Tm_app
-           ({
-              FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_reflect uu___1);
-              FStar_Syntax_Syntax.pos = uu___2;
-              FStar_Syntax_Syntax.vars = uu___3;
-              FStar_Syntax_Syntax.hash_code = uu___4;_},
-            uu___5)
-           ->
-           let uu___6 =
-             let uu___7 =
-               let uu___8 = FStar_Parser_Const.failwith_lid () in
-               FStar_Syntax_Syntax.lid_as_fv uu___8
-                 FStar_Syntax_Syntax.delta_constant
-                 FStar_Pervasives_Native.None in
-             FStar_Extraction_ML_UEnv.lookup_fv t.FStar_Syntax_Syntax.pos g
-               uu___7 in
-           (match uu___6 with
-            | { FStar_Extraction_ML_UEnv.exp_b_name = uu___7;
-                FStar_Extraction_ML_UEnv.exp_b_expr = fw;
-                FStar_Extraction_ML_UEnv.exp_b_tscheme = uu___8;_} ->
-                let uu___9 =
-                  let uu___10 =
-                    let uu___11 =
-                      let uu___12 =
-                        let uu___13 =
-                          FStar_Compiler_Effect.op_Less_Bar
-                            (FStar_Extraction_ML_Syntax.with_ty
-                               FStar_Extraction_ML_Syntax.ml_string_ty)
-                            (FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                                  "Extraction of reflect is not supported")) in
-                        [uu___13] in
-                      (fw, uu___12) in
-                    FStar_Extraction_ML_Syntax.MLE_App uu___11 in
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_Extraction_ML_Syntax.with_ty
-                       FStar_Extraction_ML_Syntax.ml_int_ty) uu___10 in
-                (uu___9, FStar_Extraction_ML_Syntax.E_PURE,
-                  FStar_Extraction_ML_Syntax.ml_int_ty))
-       | FStar_Syntax_Syntax.Tm_app uu___1 when is_steel_with_invariant_g t
-           ->
-           (FStar_Extraction_ML_Syntax.ml_unit,
-             FStar_Extraction_ML_Syntax.E_PURE,
-             FStar_Extraction_ML_Syntax.MLTY_Erased)
-       | FStar_Syntax_Syntax.Tm_app uu___1 when
-           let uu___2 = is_steel_with_invariant t in
-           FStar_Pervasives_Native.uu___is_Some uu___2 ->
-           let body =
-             let uu___2 = is_steel_with_invariant t in
-             FStar_Pervasives_Native.__proj__Some__item__v uu___2 in
-           let tm =
-             let uu___2 =
-               let uu___3 =
-                 FStar_Syntax_Syntax.as_arg FStar_Syntax_Syntax.unit_const in
-               [uu___3] in
-             FStar_Syntax_Syntax.mk_Tm_app body uu___2
-               body.FStar_Syntax_Syntax.pos in
-           term_as_mlexpr g tm
-       | FStar_Syntax_Syntax.Tm_app uu___1 when is_steel_new_invariant t ->
-           (FStar_Extraction_ML_Syntax.ml_unit,
-             FStar_Extraction_ML_Syntax.E_PURE,
-             FStar_Extraction_ML_Syntax.ml_unit_ty)
-       | FStar_Syntax_Syntax.Tm_app (head, args) when
-           (is_match head) &&
-             (FStar_Compiler_Effect.op_Bar_Greater args
-                should_apply_to_match_branches)
-           ->
-           let uu___1 =
-             FStar_Compiler_Effect.op_Bar_Greater args
-               (apply_to_match_branches head) in
-           FStar_Compiler_Effect.op_Bar_Greater uu___1 (term_as_mlexpr g)
-       | FStar_Syntax_Syntax.Tm_app (head, args) ->
-           let is_total rc =
-             (FStar_Ident.lid_equals rc.FStar_Syntax_Syntax.residual_effect
-                FStar_Parser_Const.effect_Tot_lid)
-               ||
-               (FStar_Compiler_Effect.op_Bar_Greater
-                  rc.FStar_Syntax_Syntax.residual_flags
-                  (FStar_Compiler_List.existsb
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | FStar_Syntax_Syntax.TOTAL -> true
-                        | uu___2 -> false))) in
-           let uu___1 =
-             let uu___2 =
-               let uu___3 =
-                 FStar_Compiler_Effect.op_Bar_Greater head
-                   FStar_Syntax_Subst.compress in
-               FStar_Compiler_Effect.op_Bar_Greater uu___3
-                 FStar_Syntax_Util.unascribe in
-             uu___2.FStar_Syntax_Syntax.n in
-           (match uu___1 with
-            | FStar_Syntax_Syntax.Tm_abs (bs, uu___2, _rc) ->
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                    FStar_TypeChecker_Normalize.normalize
-                      [FStar_TypeChecker_Env.Beta;
-                      FStar_TypeChecker_Env.Iota;
-                      FStar_TypeChecker_Env.Zeta;
-                      FStar_TypeChecker_Env.EraseUniverses;
-                      FStar_TypeChecker_Env.AllowUnboundUniverses;
-                      FStar_TypeChecker_Env.ForExtraction] uu___5 in
-                  FStar_Compiler_Effect.op_Bar_Greater t uu___4 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  (term_as_mlexpr g)
-            | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify) ->
-                let e =
-                  let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                  let uu___3 = FStar_Compiler_List.hd args in
-                  FStar_TypeChecker_Util.reify_body_with_arg uu___2
-                    [FStar_TypeChecker_Env.Inlining;
-                    FStar_TypeChecker_Env.ForExtraction;
-                    FStar_TypeChecker_Env.Unascribe] head uu___3 in
-                let tm =
-                  let uu___2 = FStar_TypeChecker_Util.remove_reify e in
-                  let uu___3 = FStar_Compiler_List.tl args in
-                  FStar_Syntax_Syntax.mk_Tm_app uu___2 uu___3
-                    t.FStar_Syntax_Syntax.pos in
-                term_as_mlexpr g tm
-            | uu___2 ->
-                let rec extract_app is_data uu___3 uu___4 restArgs =
-                  match (uu___3, uu___4) with
-                  | ((mlhead, mlargs_f), (f, t1)) ->
-                      let mk_head uu___5 =
-                        let mlargs =
-                          FStar_Compiler_Effect.op_Bar_Greater
-                            (FStar_Compiler_List.rev mlargs_f)
-                            (FStar_Compiler_List.map
-                               FStar_Pervasives_Native.fst) in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty t1)
-                          (FStar_Extraction_ML_Syntax.MLE_App
-                             (mlhead, mlargs)) in
-                      (FStar_Extraction_ML_UEnv.debug g
-                         (fun uu___6 ->
-                            let uu___7 =
-                              let uu___8 =
-                                FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                  g in
-                              let uu___9 = mk_head () in
-                              FStar_Extraction_ML_Code.string_of_mlexpr
-                                uu___8 uu___9 in
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                  g in
-                              FStar_Extraction_ML_Code.string_of_mlty uu___9
-                                t1 in
-                            let uu___9 =
-                              match restArgs with
-                              | [] -> "none"
-                              | (hd, uu___10)::uu___11 ->
-                                  FStar_Syntax_Print.term_to_string hd in
-                            FStar_Compiler_Util.print3
-                              "extract_app ml_head=%s type of head = %s, next arg = %s\n"
-                              uu___7 uu___8 uu___9);
-                       (match (restArgs, t1) with
-                        | ([], uu___6) ->
-                            let app =
-                              let uu___7 = mk_head () in
-                              maybe_eta_data_and_project_record g is_data t1
-                                uu___7 in
-                            (app, f, t1)
-                        | ((arg, uu___6)::rest,
-                           FStar_Extraction_ML_Syntax.MLTY_Fun
-                           (formal_t, f', t2)) when
-                            (is_type g arg) &&
-                              (type_leq g formal_t
-                                 FStar_Extraction_ML_Syntax.ml_unit_ty)
-                            ->
-                            let uu___7 =
-                              let uu___8 =
-                                FStar_Extraction_ML_Util.join
-                                  arg.FStar_Syntax_Syntax.pos f f' in
-                              (uu___8, t2) in
-                            extract_app is_data
-                              (mlhead,
-                                ((FStar_Extraction_ML_Syntax.ml_unit,
-                                   FStar_Extraction_ML_Syntax.E_PURE) ::
-                                mlargs_f)) uu___7 rest
-                        | ((e0, uu___6)::rest,
-                           FStar_Extraction_ML_Syntax.MLTY_Fun
-                           (tExpected, f', t2)) ->
-                            let r = e0.FStar_Syntax_Syntax.pos in
-                            let expected_effect =
-                              let uu___7 =
-                                (FStar_Options.lax ()) &&
-                                  (FStar_TypeChecker_Util.short_circuit_head
-                                     head) in
-                              if uu___7
-                              then FStar_Extraction_ML_Syntax.E_IMPURE
-                              else FStar_Extraction_ML_Syntax.E_PURE in
-                            let uu___7 =
-                              check_term_as_mlexpr g e0 expected_effect
-                                tExpected in
-                            (match uu___7 with
-                             | (e01, tInferred) ->
-                                 let uu___8 =
-                                   let uu___9 =
-                                     FStar_Extraction_ML_Util.join_l r
-                                       [f; f'] in
-                                   (uu___9, t2) in
-                                 extract_app is_data
-                                   (mlhead, ((e01, expected_effect) ::
-                                     mlargs_f)) uu___8 rest)
-                        | uu___6 ->
-                            let uu___7 =
-                              FStar_Extraction_ML_Util.udelta_unfold g t1 in
-                            (match uu___7 with
-                             | FStar_Pervasives_Native.Some t2 ->
-                                 extract_app is_data (mlhead, mlargs_f)
-                                   (f, t2) restArgs
-                             | FStar_Pervasives_Native.None ->
-                                 (match t1 with
-                                  | FStar_Extraction_ML_Syntax.MLTY_Erased ->
-                                      (FStar_Extraction_ML_Syntax.ml_unit,
-                                        FStar_Extraction_ML_Syntax.E_PURE,
-                                        t1)
-                                  | FStar_Extraction_ML_Syntax.MLTY_Top ->
-                                      let t2 =
-                                        FStar_Compiler_List.fold_right
-                                          (fun t3 ->
-                                             fun out ->
-                                               FStar_Extraction_ML_Syntax.MLTY_Fun
-                                                 (FStar_Extraction_ML_Syntax.MLTY_Top,
-                                                   FStar_Extraction_ML_Syntax.E_PURE,
-                                                   out)) restArgs
-                                          FStar_Extraction_ML_Syntax.MLTY_Top in
-                                      let mlhead1 =
-                                        let mlargs =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            (FStar_Compiler_List.rev mlargs_f)
-                                            (FStar_Compiler_List.map
-                                               FStar_Pervasives_Native.fst) in
-                                        let head1 =
-                                          FStar_Compiler_Effect.op_Less_Bar
-                                            (FStar_Extraction_ML_Syntax.with_ty
-                                               FStar_Extraction_ML_Syntax.MLTY_Top)
-                                            (FStar_Extraction_ML_Syntax.MLE_App
-                                               (mlhead, mlargs)) in
-                                        maybe_coerce
-                                          top1.FStar_Syntax_Syntax.pos g
-                                          head1
-                                          FStar_Extraction_ML_Syntax.MLTY_Top
-                                          t2 in
-                                      extract_app is_data (mlhead1, [])
-                                        (f, t2) restArgs
-                                  | uu___8 ->
-                                      let mlhead1 =
-                                        let mlargs =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            (FStar_Compiler_List.rev mlargs_f)
-                                            (FStar_Compiler_List.map
-                                               FStar_Pervasives_Native.fst) in
-                                        let head1 =
-                                          FStar_Compiler_Effect.op_Less_Bar
-                                            (FStar_Extraction_ML_Syntax.with_ty
-                                               FStar_Extraction_ML_Syntax.MLTY_Top)
-                                            (FStar_Extraction_ML_Syntax.MLE_App
-                                               (mlhead, mlargs)) in
-                                        maybe_coerce
-                                          top1.FStar_Syntax_Syntax.pos g
-                                          head1
-                                          FStar_Extraction_ML_Syntax.MLTY_Top
-                                          t1 in
-                                      err_ill_typed_application g top1
-                                        mlhead1 restArgs t1)))) in
-                let extract_app_maybe_projector is_data mlhead uu___3 args1 =
-                  match uu___3 with
-                  | (f, t1) ->
-                      (match is_data with
-                       | FStar_Pervasives_Native.Some
-                           (FStar_Syntax_Syntax.Record_projector uu___4) ->
-                           let rec remove_implicits args2 f1 t2 =
-                             match (args2, t2) with
-                             | ((a0, FStar_Pervasives_Native.Some
-                                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                                   FStar_Syntax_Syntax.aqual_attributes =
-                                     uu___5;_})::args3,
-                                FStar_Extraction_ML_Syntax.MLTY_Fun
-                                (uu___6, f', t3)) ->
-                                 let uu___7 =
-                                   FStar_Extraction_ML_Util.join
-                                     a0.FStar_Syntax_Syntax.pos f1 f' in
-                                 remove_implicits args3 uu___7 t3
-                             | uu___5 -> (args2, f1, t2) in
-                           let uu___5 = remove_implicits args1 f t1 in
-                           (match uu___5 with
-                            | (args2, f1, t2) ->
-                                extract_app is_data (mlhead, []) (f1, t2)
-                                  args2)
-                       | uu___4 ->
-                           extract_app is_data (mlhead, []) (f, t1) args1) in
-                let extract_app_with_instantiations uu___3 =
-                  let head1 = FStar_Syntax_Util.un_uinst head in
-                  match head1.FStar_Syntax_Syntax.n with
-                  | FStar_Syntax_Syntax.Tm_name uu___4 ->
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Extraction_ML_UEnv.lookup_term g head1 in
-                        match uu___6 with
-                        | (FStar_Pervasives.Inr exp_b, q) ->
-                            (FStar_Extraction_ML_UEnv.debug g
-                               (fun uu___8 ->
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string head1 in
-                                  let uu___10 =
-                                    let uu___11 =
-                                      FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                        g in
-                                    FStar_Extraction_ML_Code.string_of_mlexpr
-                                      uu___11
-                                      exp_b.FStar_Extraction_ML_UEnv.exp_b_expr in
-                                  let uu___11 =
-                                    let uu___12 =
-                                      FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                        g in
-                                    FStar_Extraction_ML_Code.string_of_mlty
-                                      uu___12
-                                      (FStar_Pervasives_Native.snd
-                                         exp_b.FStar_Extraction_ML_UEnv.exp_b_tscheme) in
-                                  FStar_Compiler_Util.print3
-                                    "@@@looked up %s: got %s at %s\n" uu___9
-                                    uu___10 uu___11);
-                             (((exp_b.FStar_Extraction_ML_UEnv.exp_b_expr),
-                                (exp_b.FStar_Extraction_ML_UEnv.exp_b_tscheme)),
-                               q))
-                        | uu___7 -> failwith "FIXME Ty" in
-                      (match uu___5 with
-                       | ((head_ml, (vars, t1)), qual) ->
-                           let has_typ_apps =
-                             match args with
-                             | (a, uu___6)::uu___7 -> is_type g a
-                             | uu___6 -> false in
-                           let uu___6 =
-                             let n = FStar_Compiler_List.length vars in
-                             let uu___7 =
-                               if (FStar_Compiler_List.length args) <= n
-                               then
-                                 let uu___8 =
-                                   FStar_Compiler_List.map
-                                     (fun uu___9 ->
-                                        match uu___9 with
-                                        | (x, uu___10) -> term_as_mlty g x)
-                                     args in
-                                 (uu___8, [])
-                               else
-                                 (let uu___9 =
-                                    FStar_Compiler_Util.first_N n args in
-                                  match uu___9 with
-                                  | (prefix, rest) ->
-                                      let uu___10 =
-                                        FStar_Compiler_List.map
-                                          (fun uu___11 ->
-                                             match uu___11 with
-                                             | (x, uu___12) ->
-                                                 term_as_mlty g x) prefix in
-                                      (uu___10, rest)) in
-                             match uu___7 with
-                             | (provided_type_args, rest) ->
-                                 let uu___8 =
-                                   match head_ml.FStar_Extraction_ML_Syntax.expr
-                                   with
-                                   | FStar_Extraction_ML_Syntax.MLE_Name
-                                       uu___9 ->
-                                       let uu___10 =
-                                         instantiate_maybe_partial g head_ml
-                                           (vars, t1) provided_type_args in
-                                       (match uu___10 with
-                                        | (head2, uu___11, t2) -> (head2, t2))
-                                   | FStar_Extraction_ML_Syntax.MLE_Var
-                                       uu___9 ->
-                                       let uu___10 =
-                                         instantiate_maybe_partial g head_ml
-                                           (vars, t1) provided_type_args in
-                                       (match uu___10 with
-                                        | (head2, uu___11, t2) -> (head2, t2))
-                                   | FStar_Extraction_ML_Syntax.MLE_App
-                                       (head2,
-                                        {
-                                          FStar_Extraction_ML_Syntax.expr =
-                                            FStar_Extraction_ML_Syntax.MLE_Const
-                                            (FStar_Extraction_ML_Syntax.MLC_Unit);
-                                          FStar_Extraction_ML_Syntax.mlty =
-                                            uu___9;
-                                          FStar_Extraction_ML_Syntax.loc =
-                                            uu___10;_}::[])
-                                       ->
-                                       let uu___11 =
-                                         instantiate_maybe_partial g head2
-                                           (vars, t1) provided_type_args in
-                                       (match uu___11 with
-                                        | (head3, uu___12, t2) ->
-                                            let uu___13 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                (FStar_Extraction_ML_Syntax.MLE_App
-                                                   (head3,
-                                                     [FStar_Extraction_ML_Syntax.ml_unit]))
-                                                (FStar_Extraction_ML_Syntax.with_ty
-                                                   t2) in
-                                            (uu___13, t2))
-                                   | uu___9 ->
-                                       failwith
-                                         "Impossible: Unexpected head term" in
-                                 (match uu___8 with
-                                  | (head2, t2) -> (head2, t2, rest)) in
-                           (match uu___6 with
-                            | (head_ml1, head_t, args1) ->
-                                (match args1 with
-                                 | [] ->
-                                     let uu___7 =
-                                       maybe_eta_data_and_project_record g
-                                         qual head_t head_ml1 in
-                                     (uu___7,
-                                       FStar_Extraction_ML_Syntax.E_PURE,
-                                       head_t)
-                                 | uu___7 ->
-                                     extract_app_maybe_projector qual
-                                       head_ml1
-                                       (FStar_Extraction_ML_Syntax.E_PURE,
-                                         head_t) args1)))
-                  | FStar_Syntax_Syntax.Tm_fvar uu___4 ->
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Extraction_ML_UEnv.lookup_term g head1 in
-                        match uu___6 with
-                        | (FStar_Pervasives.Inr exp_b, q) ->
-                            (FStar_Extraction_ML_UEnv.debug g
-                               (fun uu___8 ->
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string head1 in
-                                  let uu___10 =
-                                    let uu___11 =
-                                      FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                        g in
-                                    FStar_Extraction_ML_Code.string_of_mlexpr
-                                      uu___11
-                                      exp_b.FStar_Extraction_ML_UEnv.exp_b_expr in
-                                  let uu___11 =
-                                    let uu___12 =
-                                      FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                        g in
-                                    FStar_Extraction_ML_Code.string_of_mlty
-                                      uu___12
-                                      (FStar_Pervasives_Native.snd
-                                         exp_b.FStar_Extraction_ML_UEnv.exp_b_tscheme) in
-                                  FStar_Compiler_Util.print3
-                                    "@@@looked up %s: got %s at %s\n" uu___9
-                                    uu___10 uu___11);
-                             (((exp_b.FStar_Extraction_ML_UEnv.exp_b_expr),
-                                (exp_b.FStar_Extraction_ML_UEnv.exp_b_tscheme)),
-                               q))
-                        | uu___7 -> failwith "FIXME Ty" in
-                      (match uu___5 with
-                       | ((head_ml, (vars, t1)), qual) ->
-                           let has_typ_apps =
-                             match args with
-                             | (a, uu___6)::uu___7 -> is_type g a
-                             | uu___6 -> false in
-                           let uu___6 =
-                             let n = FStar_Compiler_List.length vars in
-                             let uu___7 =
-                               if (FStar_Compiler_List.length args) <= n
-                               then
-                                 let uu___8 =
-                                   FStar_Compiler_List.map
-                                     (fun uu___9 ->
-                                        match uu___9 with
-                                        | (x, uu___10) -> term_as_mlty g x)
-                                     args in
-                                 (uu___8, [])
-                               else
-                                 (let uu___9 =
-                                    FStar_Compiler_Util.first_N n args in
-                                  match uu___9 with
-                                  | (prefix, rest) ->
-                                      let uu___10 =
-                                        FStar_Compiler_List.map
-                                          (fun uu___11 ->
-                                             match uu___11 with
-                                             | (x, uu___12) ->
-                                                 term_as_mlty g x) prefix in
-                                      (uu___10, rest)) in
-                             match uu___7 with
-                             | (provided_type_args, rest) ->
-                                 let uu___8 =
-                                   match head_ml.FStar_Extraction_ML_Syntax.expr
-                                   with
-                                   | FStar_Extraction_ML_Syntax.MLE_Name
-                                       uu___9 ->
-                                       let uu___10 =
-                                         instantiate_maybe_partial g head_ml
-                                           (vars, t1) provided_type_args in
-                                       (match uu___10 with
-                                        | (head2, uu___11, t2) -> (head2, t2))
-                                   | FStar_Extraction_ML_Syntax.MLE_Var
-                                       uu___9 ->
-                                       let uu___10 =
-                                         instantiate_maybe_partial g head_ml
-                                           (vars, t1) provided_type_args in
-                                       (match uu___10 with
-                                        | (head2, uu___11, t2) -> (head2, t2))
-                                   | FStar_Extraction_ML_Syntax.MLE_App
-                                       (head2,
-                                        {
-                                          FStar_Extraction_ML_Syntax.expr =
-                                            FStar_Extraction_ML_Syntax.MLE_Const
-                                            (FStar_Extraction_ML_Syntax.MLC_Unit);
-                                          FStar_Extraction_ML_Syntax.mlty =
-                                            uu___9;
-                                          FStar_Extraction_ML_Syntax.loc =
-                                            uu___10;_}::[])
-                                       ->
-                                       let uu___11 =
-                                         instantiate_maybe_partial g head2
-                                           (vars, t1) provided_type_args in
-                                       (match uu___11 with
-                                        | (head3, uu___12, t2) ->
-                                            let uu___13 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                (FStar_Extraction_ML_Syntax.MLE_App
-                                                   (head3,
-                                                     [FStar_Extraction_ML_Syntax.ml_unit]))
-                                                (FStar_Extraction_ML_Syntax.with_ty
-                                                   t2) in
-                                            (uu___13, t2))
-                                   | uu___9 ->
-                                       failwith
-                                         "Impossible: Unexpected head term" in
-                                 (match uu___8 with
-                                  | (head2, t2) -> (head2, t2, rest)) in
-                           (match uu___6 with
-                            | (head_ml1, head_t, args1) ->
-                                (match args1 with
-                                 | [] ->
-                                     let uu___7 =
-                                       maybe_eta_data_and_project_record g
-                                         qual head_t head_ml1 in
-                                     (uu___7,
-                                       FStar_Extraction_ML_Syntax.E_PURE,
-                                       head_t)
-                                 | uu___7 ->
-                                     extract_app_maybe_projector qual
-                                       head_ml1
-                                       (FStar_Extraction_ML_Syntax.E_PURE,
-                                         head_t) args1)))
-                  | uu___4 ->
-                      let uu___5 = term_as_mlexpr g head1 in
-                      (match uu___5 with
-                       | (head2, f, t1) ->
-                           extract_app_maybe_projector
-                             FStar_Pervasives_Native.None head2 (f, t1) args) in
-                let uu___3 = is_type g t in
-                if uu___3
-                then
-                  (FStar_Extraction_ML_Syntax.ml_unit,
-                    FStar_Extraction_ML_Syntax.E_PURE,
-                    FStar_Extraction_ML_Syntax.ml_unit_ty)
-                else
-                  (let uu___5 =
-                     let uu___6 = FStar_Syntax_Util.un_uinst head in
-                     uu___6.FStar_Syntax_Syntax.n in
-                   match uu___5 with
-                   | FStar_Syntax_Syntax.Tm_fvar fv ->
-                       let uu___6 =
-                         FStar_Extraction_ML_UEnv.try_lookup_fv
-                           t.FStar_Syntax_Syntax.pos g fv in
-                       (match uu___6 with
-                        | FStar_Pervasives_Native.None ->
-                            (FStar_Extraction_ML_Syntax.ml_unit,
-                              FStar_Extraction_ML_Syntax.E_PURE,
-                              FStar_Extraction_ML_Syntax.MLTY_Erased)
-                        | uu___7 -> extract_app_with_instantiations ())
-                   | uu___6 -> extract_app_with_instantiations ()))
-       | FStar_Syntax_Syntax.Tm_ascribed (e0, (tc, uu___1, uu___2), f) ->
-           let t1 =
-             match tc with
-             | FStar_Pervasives.Inl t2 -> term_as_mlty g t2
-             | FStar_Pervasives.Inr c ->
-                 let uu___3 =
-                   let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                   maybe_reify_comp g uu___4 c in
-                 term_as_mlty g uu___3 in
-           let f1 =
-             match f with
-             | FStar_Pervasives_Native.None ->
-                 failwith "Ascription node with an empty effect label"
-             | FStar_Pervasives_Native.Some l -> effect_as_etag g l in
-           let uu___3 = check_term_as_mlexpr g e0 f1 t1 in
-           (match uu___3 with | (e, t2) -> (e, f1, t2))
-       | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), e') when
-           (let uu___1 = FStar_Syntax_Syntax.is_top_level [lb] in
-            Prims.op_Negation uu___1) &&
-             (let uu___1 =
-                FStar_Syntax_Util.get_attribute
-                  FStar_Parser_Const.rename_let_attr
-                  lb.FStar_Syntax_Syntax.lbattrs in
-              FStar_Compiler_Util.is_some uu___1)
-           ->
-           let b =
-             let uu___1 =
-               FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-             FStar_Syntax_Syntax.mk_binder uu___1 in
-           let uu___1 = FStar_Syntax_Subst.open_term_1 b e' in
-           (match uu___1 with
-            | ({ FStar_Syntax_Syntax.binder_bv = x;
-                 FStar_Syntax_Syntax.binder_qual = uu___2;
-                 FStar_Syntax_Syntax.binder_attrs = uu___3;_},
-               body) ->
-                let suggested_name =
-                  let attr =
-                    FStar_Syntax_Util.get_attribute
-                      FStar_Parser_Const.rename_let_attr
-                      lb.FStar_Syntax_Syntax.lbattrs in
-                  match attr with
-                  | FStar_Pervasives_Native.Some ((str, uu___4)::[]) ->
-                      let uu___5 =
-                        let uu___6 = FStar_Syntax_Subst.compress str in
-                        uu___6.FStar_Syntax_Syntax.n in
-                      (match uu___5 with
-                       | FStar_Syntax_Syntax.Tm_constant
-                           (FStar_Const.Const_string (s, uu___6)) when
-                           s <> "" ->
-                           let id =
-                             let uu___7 =
-                               let uu___8 = FStar_Syntax_Syntax.range_of_bv x in
-                               (s, uu___8) in
-                             FStar_Ident.mk_ident uu___7 in
-                           let bv =
-                             {
-                               FStar_Syntax_Syntax.ppname = id;
-                               FStar_Syntax_Syntax.index = Prims.int_zero;
-                               FStar_Syntax_Syntax.sort =
-                                 (x.FStar_Syntax_Syntax.sort)
-                             } in
-                           let bv1 = FStar_Syntax_Syntax.freshen_bv bv in
-                           FStar_Pervasives_Native.Some bv1
-                       | uu___6 ->
-                           (FStar_Errors.log_issue
-                              top1.FStar_Syntax_Syntax.pos
-                              (FStar_Errors.Warning_UnrecognizedAttribute,
-                                "Ignoring ill-formed application of `rename_let`");
-                            FStar_Pervasives_Native.None))
-                  | FStar_Pervasives_Native.Some uu___4 ->
-                      (FStar_Errors.log_issue top1.FStar_Syntax_Syntax.pos
-                         (FStar_Errors.Warning_UnrecognizedAttribute,
-                           "Ignoring ill-formed application of `rename_let`");
-                       FStar_Pervasives_Native.None)
-                  | FStar_Pervasives_Native.None ->
-                      FStar_Pervasives_Native.None in
-                let remove_attr attrs =
-                  let uu___4 =
-                    FStar_Compiler_List.partition
-                      (fun attr ->
-                         let uu___5 =
-                           FStar_Syntax_Util.get_attribute
-                             FStar_Parser_Const.rename_let_attr [attr] in
-                         FStar_Compiler_Util.is_some uu___5)
-                      lb.FStar_Syntax_Syntax.lbattrs in
-                  match uu___4 with | (uu___5, other_attrs) -> other_attrs in
-                let maybe_rewritten_let =
-                  match suggested_name with
-                  | FStar_Pervasives_Native.None ->
-                      let other_attrs =
-                        remove_attr lb.FStar_Syntax_Syntax.lbattrs in
-                      FStar_Syntax_Syntax.Tm_let
-                        ((false,
-                           [{
-                              FStar_Syntax_Syntax.lbname =
-                                (lb.FStar_Syntax_Syntax.lbname);
-                              FStar_Syntax_Syntax.lbunivs =
-                                (lb.FStar_Syntax_Syntax.lbunivs);
-                              FStar_Syntax_Syntax.lbtyp =
-                                (lb.FStar_Syntax_Syntax.lbtyp);
-                              FStar_Syntax_Syntax.lbeff =
-                                (lb.FStar_Syntax_Syntax.lbeff);
-                              FStar_Syntax_Syntax.lbdef =
-                                (lb.FStar_Syntax_Syntax.lbdef);
-                              FStar_Syntax_Syntax.lbattrs = other_attrs;
-                              FStar_Syntax_Syntax.lbpos =
-                                (lb.FStar_Syntax_Syntax.lbpos)
-                            }]), e')
-                  | FStar_Pervasives_Native.Some y ->
-                      let other_attrs =
-                        remove_attr lb.FStar_Syntax_Syntax.lbattrs in
-                      let rename =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Syntax_Syntax.bv_to_name y in
-                            (x, uu___6) in
-                          FStar_Syntax_Syntax.NT uu___5 in
-                        [uu___4] in
-                      let body1 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.mk_binder y in
-                          [uu___5] in
-                        let uu___5 = FStar_Syntax_Subst.subst rename body in
-                        FStar_Syntax_Subst.close uu___4 uu___5 in
-                      let lb1 =
-                        {
-                          FStar_Syntax_Syntax.lbname =
-                            (FStar_Pervasives.Inl y);
-                          FStar_Syntax_Syntax.lbunivs =
-                            (lb.FStar_Syntax_Syntax.lbunivs);
-                          FStar_Syntax_Syntax.lbtyp =
-                            (lb.FStar_Syntax_Syntax.lbtyp);
-                          FStar_Syntax_Syntax.lbeff =
-                            (lb.FStar_Syntax_Syntax.lbeff);
-                          FStar_Syntax_Syntax.lbdef =
-                            (lb.FStar_Syntax_Syntax.lbdef);
-                          FStar_Syntax_Syntax.lbattrs = other_attrs;
-                          FStar_Syntax_Syntax.lbpos =
-                            (lb.FStar_Syntax_Syntax.lbpos)
-                        } in
-                      FStar_Syntax_Syntax.Tm_let ((false, [lb1]), body1) in
-                let top2 =
-                  {
-                    FStar_Syntax_Syntax.n = maybe_rewritten_let;
-                    FStar_Syntax_Syntax.pos = (top1.FStar_Syntax_Syntax.pos);
-                    FStar_Syntax_Syntax.vars =
-                      (top1.FStar_Syntax_Syntax.vars);
-                    FStar_Syntax_Syntax.hash_code =
-                      (top1.FStar_Syntax_Syntax.hash_code)
-                  } in
-                term_as_mlexpr' g top2)
-       | FStar_Syntax_Syntax.Tm_let ((is_rec, lbs), e') ->
-           let top_level = FStar_Syntax_Syntax.is_top_level lbs in
-           let uu___1 =
-             if is_rec
-             then FStar_Syntax_Subst.open_let_rec lbs e'
-             else
-               (let uu___3 = FStar_Syntax_Syntax.is_top_level lbs in
-                if uu___3
-                then (lbs, e')
-                else
-                  (let lb = FStar_Compiler_List.hd lbs in
-                   let x =
-                     let uu___5 =
-                       FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-                     FStar_Syntax_Syntax.freshen_bv uu___5 in
-                   let lb1 =
-                     {
-                       FStar_Syntax_Syntax.lbname = (FStar_Pervasives.Inl x);
-                       FStar_Syntax_Syntax.lbunivs =
-                         (lb.FStar_Syntax_Syntax.lbunivs);
-                       FStar_Syntax_Syntax.lbtyp =
-                         (lb.FStar_Syntax_Syntax.lbtyp);
-                       FStar_Syntax_Syntax.lbeff =
-                         (lb.FStar_Syntax_Syntax.lbeff);
-                       FStar_Syntax_Syntax.lbdef =
-                         (lb.FStar_Syntax_Syntax.lbdef);
-                       FStar_Syntax_Syntax.lbattrs =
-                         (lb.FStar_Syntax_Syntax.lbattrs);
-                       FStar_Syntax_Syntax.lbpos =
-                         (lb.FStar_Syntax_Syntax.lbpos)
-                     } in
-                   let e'1 =
-                     FStar_Syntax_Subst.subst
-                       [FStar_Syntax_Syntax.DB (Prims.int_zero, x)] e' in
-                   ([lb1], e'1))) in
-           (match uu___1 with
-            | (lbs1, e'1) ->
-                let lbs2 =
-                  if top_level
-                  then
-                    let tcenv =
-                      let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv g in
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                g in
-                            FStar_Pervasives_Native.fst uu___6 in
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 =
-                                FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                  g in
-                              FStar_Pervasives_Native.snd uu___8 in
-                            [uu___7] in
-                          FStar_Compiler_List.op_At uu___5 uu___6 in
-                        FStar_Ident.lid_of_path uu___4
-                          FStar_Compiler_Range.dummyRange in
-                      FStar_TypeChecker_Env.set_current_module uu___2 uu___3 in
-                    FStar_Compiler_Effect.op_Bar_Greater lbs1
-                      (FStar_Compiler_List.map
-                         (fun lb ->
-                            let lbdef =
-                              let uu___2 = FStar_Options.ml_ish () in
-                              if uu___2
-                              then lb.FStar_Syntax_Syntax.lbdef
-                              else
-                                (let norm_call uu___4 =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_TypeChecker_Env.current_module
-                                           tcenv in
-                                       FStar_Ident.string_of_lid uu___7 in
-                                     FStar_Pervasives_Native.Some uu___6 in
-                                   FStar_Profiling.profile
-                                     (fun uu___6 ->
-                                        FStar_TypeChecker_Normalize.normalize
-                                          (FStar_TypeChecker_Env.PureSubtermsWithinComputations
-                                          :: FStar_TypeChecker_Env.Reify ::
-                                          extraction_norm_steps) tcenv
-                                          lb.FStar_Syntax_Syntax.lbdef)
-                                     uu___5
-                                     "FStar.Extraction.ML.Term.normalize_lb_def" in
-                                 let uu___4 =
-                                   (FStar_Compiler_Effect.op_Less_Bar
-                                      (FStar_TypeChecker_Env.debug tcenv)
-                                      (FStar_Options.Other "Extraction"))
-                                     ||
-                                     (FStar_Compiler_Effect.op_Less_Bar
-                                        (FStar_TypeChecker_Env.debug tcenv)
-                                        (FStar_Options.Other "ExtractNorm")) in
-                                 if uu___4
-                                 then
-                                   ((let uu___6 =
-                                       FStar_Syntax_Print.lbname_to_string
-                                         lb.FStar_Syntax_Syntax.lbname in
-                                     let uu___7 =
-                                       FStar_Syntax_Print.term_to_string
-                                         lb.FStar_Syntax_Syntax.lbdef in
-                                     FStar_Compiler_Util.print2
-                                       "Starting to normalize top-level let %s = %s\n"
-                                       uu___6 uu___7);
-                                    (let a = norm_call () in
-                                     (let uu___7 =
-                                        FStar_Syntax_Print.term_to_string a in
-                                      FStar_Compiler_Util.print1
-                                        "Normalized to %s\n" uu___7);
-                                     a))
-                                 else norm_call ()) in
-                            {
-                              FStar_Syntax_Syntax.lbname =
-                                (lb.FStar_Syntax_Syntax.lbname);
-                              FStar_Syntax_Syntax.lbunivs =
-                                (lb.FStar_Syntax_Syntax.lbunivs);
-                              FStar_Syntax_Syntax.lbtyp =
-                                (lb.FStar_Syntax_Syntax.lbtyp);
-                              FStar_Syntax_Syntax.lbeff =
-                                (lb.FStar_Syntax_Syntax.lbeff);
-                              FStar_Syntax_Syntax.lbdef = lbdef;
-                              FStar_Syntax_Syntax.lbattrs =
-                                (lb.FStar_Syntax_Syntax.lbattrs);
-                              FStar_Syntax_Syntax.lbpos =
-                                (lb.FStar_Syntax_Syntax.lbpos)
-                            }))
-                  else lbs1 in
-                let check_lb env uu___2 =
-                  match uu___2 with
-                  | (nm, (_lbname, f, (_t, (targs, polytype)), add_unit, e))
-                      ->
-                      let env1 =
-                        FStar_Compiler_List.fold_left
-                          (fun env2 ->
-                             fun uu___3 ->
-                               match uu___3 with
-                               | { FStar_Syntax_Syntax.binder_bv = a;
-                                   FStar_Syntax_Syntax.binder_qual = uu___4;
-                                   FStar_Syntax_Syntax.binder_attrs = uu___5;_}
-                                   ->
-                                   FStar_Extraction_ML_UEnv.extend_ty env2 a
-                                     false) env targs in
-                      let expected_t = FStar_Pervasives_Native.snd polytype in
-                      let uu___3 = check_term_as_mlexpr env1 e f expected_t in
-                      (match uu___3 with
-                       | (e1, ty) ->
-                           let uu___4 = maybe_promote_effect e1 f expected_t in
-                           (match uu___4 with
-                            | (e2, f1) ->
-                                let meta =
-                                  match (f1, ty) with
-                                  | (FStar_Extraction_ML_Syntax.E_PURE,
-                                     FStar_Extraction_ML_Syntax.MLTY_Erased)
-                                      -> [FStar_Extraction_ML_Syntax.Erased]
-                                  | (FStar_Extraction_ML_Syntax.E_ERASABLE,
-                                     FStar_Extraction_ML_Syntax.MLTY_Erased)
-                                      -> [FStar_Extraction_ML_Syntax.Erased]
-                                  | uu___5 -> [] in
-                                (f1,
-                                  {
-                                    FStar_Extraction_ML_Syntax.mllb_name = nm;
-                                    FStar_Extraction_ML_Syntax.mllb_tysc =
-                                      (FStar_Pervasives_Native.Some polytype);
-                                    FStar_Extraction_ML_Syntax.mllb_add_unit
-                                      = add_unit;
-                                    FStar_Extraction_ML_Syntax.mllb_def = e2;
-                                    FStar_Extraction_ML_Syntax.mllb_meta =
-                                      meta;
-                                    FStar_Extraction_ML_Syntax.print_typ =
-                                      true
-                                  }))) in
-                let lbs3 = extract_lb_sig g (is_rec, lbs2) in
-                let uu___2 =
-                  FStar_Compiler_List.fold_right
-                    (fun lb ->
-                       fun uu___3 ->
-                         match uu___3 with
-                         | (env, lbs4, env_burn) ->
-                             let uu___4 = lb in
-                             (match uu___4 with
-                              | (lbname, uu___5, (t1, (uu___6, polytype)),
-                                 add_unit, uu___7) ->
-                                  let uu___8 =
-                                    FStar_Extraction_ML_UEnv.extend_lb env
-                                      lbname t1 polytype add_unit in
-                                  (match uu___8 with
-                                   | (env1, nm, uu___9) ->
-                                       let env_burn1 =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             FStar_Options.codegen () in
-                                           uu___11 <>
-                                             (FStar_Pervasives_Native.Some
-                                                FStar_Options.Krml) in
-                                         if uu___10
-                                         then
-                                           FStar_Extraction_ML_UEnv.burn_name
-                                             env_burn nm
-                                         else env_burn in
-                                       (env1, ((nm, lb) :: lbs4), env_burn1))))
-                    lbs3 (g, [], g) in
-                (match uu___2 with
-                 | (env_body, lbs4, env_burn) ->
-                     let env_def = if is_rec then env_body else env_burn in
-                     let lbs5 =
-                       FStar_Compiler_Effect.op_Bar_Greater lbs4
-                         (FStar_Compiler_List.map (check_lb env_def)) in
-                     let e'_rng = e'1.FStar_Syntax_Syntax.pos in
-                     let uu___3 = term_as_mlexpr env_body e'1 in
-                     (match uu___3 with
-                      | (e'2, f', t') ->
-                          let f =
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Compiler_List.map
-                                  FStar_Pervasives_Native.fst lbs5 in
-                              f' :: uu___5 in
-                            FStar_Extraction_ML_Util.join_l e'_rng uu___4 in
-                          let is_rec1 =
-                            if is_rec = true
-                            then FStar_Extraction_ML_Syntax.Rec
-                            else FStar_Extraction_ML_Syntax.NonRec in
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Compiler_List.map
-                                    FStar_Pervasives_Native.snd lbs5 in
-                                (is_rec1, uu___7) in
-                              mk_MLE_Let top_level uu___6 e'2 in
-                            let uu___6 =
-                              FStar_Extraction_ML_Util.mlloc_of_range
-                                t.FStar_Syntax_Syntax.pos in
-                            FStar_Extraction_ML_Syntax.with_ty_loc t' uu___5
-                              uu___6 in
-                          (uu___4, f, t'))))
-       | FStar_Syntax_Syntax.Tm_match (scrutinee, uu___1, pats, uu___2) ->
-           let uu___3 = term_as_mlexpr g scrutinee in
-           (match uu___3 with
-            | (e, f_e, t_e) ->
-                let uu___4 = check_pats_for_ite pats in
-                (match uu___4 with
-                 | (b, then_e, else_e) ->
-                     let no_lift x t1 = x in
-                     if b
-                     then
-                       (match (then_e, else_e) with
-                        | (FStar_Pervasives_Native.Some then_e1,
-                           FStar_Pervasives_Native.Some else_e1) ->
-                            let uu___5 = term_as_mlexpr g then_e1 in
-                            (match uu___5 with
-                             | (then_mle, f_then, t_then) ->
-                                 let uu___6 = term_as_mlexpr g else_e1 in
-                                 (match uu___6 with
-                                  | (else_mle, f_else, t_else) ->
-                                      let uu___7 =
-                                        let uu___8 = type_leq g t_then t_else in
-                                        if uu___8
-                                        then (t_else, no_lift)
-                                        else
-                                          (let uu___10 =
-                                             type_leq g t_else t_then in
-                                           if uu___10
-                                           then (t_then, no_lift)
-                                           else
-                                             (FStar_Extraction_ML_Syntax.MLTY_Top,
-                                               FStar_Extraction_ML_Syntax.apply_obj_repr)) in
-                                      (match uu___7 with
-                                       | (t_branch, maybe_lift) ->
-                                           let uu___8 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   maybe_lift then_mle t_then in
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     maybe_lift else_mle
-                                                       t_else in
-                                                   FStar_Pervasives_Native.Some
-                                                     uu___13 in
-                                                 (e, uu___11, uu___12) in
-                                               FStar_Extraction_ML_Syntax.MLE_If
-                                                 uu___10 in
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               (FStar_Extraction_ML_Syntax.with_ty
-                                                  t_branch) uu___9 in
-                                           let uu___9 =
-                                             FStar_Extraction_ML_Util.join
-                                               then_e1.FStar_Syntax_Syntax.pos
-                                               f_then f_else in
-                                           (uu___8, uu___9, t_branch))))
-                        | uu___5 ->
-                            failwith
-                              "ITE pats matched but then and else expressions not found?")
-                     else
-                       (let uu___6 =
-                          FStar_Compiler_Effect.op_Bar_Greater pats
-                            (FStar_Compiler_Util.fold_map
-                               (fun compat ->
-                                  fun br ->
-                                    let uu___7 =
-                                      FStar_Syntax_Subst.open_branch br in
-                                    match uu___7 with
-                                    | (pat, when_opt, branch) ->
-                                        let uu___8 =
-                                          extract_pat g pat t_e
-                                            term_as_mlexpr in
-                                        (match uu___8 with
-                                         | (env, p, pat_t_compat) ->
-                                             let uu___9 =
-                                               match when_opt with
-                                               | FStar_Pervasives_Native.None
-                                                   ->
-                                                   (FStar_Pervasives_Native.None,
-                                                     FStar_Extraction_ML_Syntax.E_PURE)
-                                               | FStar_Pervasives_Native.Some
-                                                   w ->
-                                                   let w_pos =
-                                                     w.FStar_Syntax_Syntax.pos in
-                                                   let uu___10 =
-                                                     term_as_mlexpr env w in
-                                                   (match uu___10 with
-                                                    | (w1, f_w, t_w) ->
-                                                        let w2 =
-                                                          maybe_coerce w_pos
-                                                            env w1 t_w
-                                                            FStar_Extraction_ML_Syntax.ml_bool_ty in
-                                                        ((FStar_Pervasives_Native.Some
-                                                            w2), f_w)) in
-                                             (match uu___9 with
-                                              | (when_opt1, f_when) ->
-                                                  let uu___10 =
-                                                    term_as_mlexpr env branch in
-                                                  (match uu___10 with
-                                                   | (mlbranch, f_branch,
-                                                      t_branch) ->
-                                                       let uu___11 =
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           p
-                                                           (FStar_Compiler_List.map
-                                                              (fun uu___12 ->
-                                                                 match uu___12
-                                                                 with
-                                                                 | (p1, wopt)
-                                                                    ->
-                                                                    let when_clause
-                                                                    =
-                                                                    FStar_Extraction_ML_Util.conjoin_opt
-                                                                    wopt
-                                                                    when_opt1 in
-                                                                    (p1,
-                                                                    (when_clause,
-                                                                    f_when),
-                                                                    (mlbranch,
-                                                                    f_branch,
-                                                                    t_branch)))) in
-                                                       ((compat &&
-                                                           pat_t_compat),
-                                                         uu___11))))) true) in
-                        match uu___6 with
-                        | (pat_t_compat, mlbranches) ->
-                            let mlbranches1 =
-                              FStar_Compiler_List.flatten mlbranches in
-                            let e1 =
-                              if pat_t_compat
-                              then e
-                              else
-                                (FStar_Extraction_ML_UEnv.debug g
-                                   (fun uu___9 ->
-                                      let uu___10 =
-                                        let uu___11 =
-                                          FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                            g in
-                                        FStar_Extraction_ML_Code.string_of_mlexpr
-                                          uu___11 e in
-                                      let uu___11 =
-                                        let uu___12 =
-                                          FStar_Extraction_ML_UEnv.current_module_of_uenv
-                                            g in
-                                        FStar_Extraction_ML_Code.string_of_mlty
-                                          uu___12 t_e in
-                                      FStar_Compiler_Util.print2
-                                        "Coercing scrutinee %s from type %s because pattern type is incompatible\n"
-                                        uu___10 uu___11);
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (FStar_Extraction_ML_Syntax.with_ty t_e)
-                                   (FStar_Extraction_ML_Syntax.MLE_Coerce
-                                      (e, t_e,
-                                        FStar_Extraction_ML_Syntax.MLTY_Top))) in
-                            (match mlbranches1 with
-                             | [] ->
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       FStar_Parser_Const.failwith_lid () in
-                                     FStar_Syntax_Syntax.lid_as_fv uu___9
-                                       FStar_Syntax_Syntax.delta_constant
-                                       FStar_Pervasives_Native.None in
-                                   FStar_Extraction_ML_UEnv.lookup_fv
-                                     t.FStar_Syntax_Syntax.pos g uu___8 in
-                                 (match uu___7 with
-                                  | {
-                                      FStar_Extraction_ML_UEnv.exp_b_name =
-                                        uu___8;
-                                      FStar_Extraction_ML_UEnv.exp_b_expr =
-                                        fw;
-                                      FStar_Extraction_ML_UEnv.exp_b_tscheme
-                                        = uu___9;_}
-                                      ->
-                                      let uu___10 =
-                                        let uu___11 =
-                                          let uu___12 =
-                                            let uu___13 =
-                                              let uu___14 =
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  (FStar_Extraction_ML_Syntax.with_ty
-                                                     FStar_Extraction_ML_Syntax.ml_string_ty)
-                                                  (FStar_Extraction_ML_Syntax.MLE_Const
-                                                     (FStar_Extraction_ML_Syntax.MLC_String
-                                                        "unreachable")) in
-                                              [uu___14] in
-                                            (fw, uu___13) in
-                                          FStar_Extraction_ML_Syntax.MLE_App
-                                            uu___12 in
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (FStar_Extraction_ML_Syntax.with_ty
-                                             FStar_Extraction_ML_Syntax.ml_int_ty)
-                                          uu___11 in
-                                      (uu___10,
-                                        FStar_Extraction_ML_Syntax.E_PURE,
-                                        FStar_Extraction_ML_Syntax.ml_int_ty))
-                             | (uu___7, uu___8, (uu___9, f_first, t_first))::rest
-                                 ->
-                                 let uu___10 =
-                                   FStar_Compiler_List.fold_left
-                                     (fun uu___11 ->
-                                        fun uu___12 ->
-                                          match (uu___11, uu___12) with
-                                          | ((topt, f),
-                                             (uu___13, uu___14,
-                                              (uu___15, f_branch, t_branch)))
-                                              ->
-                                              let f1 =
-                                                FStar_Extraction_ML_Util.join
-                                                  top1.FStar_Syntax_Syntax.pos
-                                                  f f_branch in
-                                              let topt1 =
-                                                match topt with
-                                                | FStar_Pervasives_Native.None
-                                                    ->
-                                                    FStar_Pervasives_Native.None
-                                                | FStar_Pervasives_Native.Some
-                                                    t1 ->
-                                                    let uu___16 =
-                                                      type_leq g t1 t_branch in
-                                                    if uu___16
-                                                    then
-                                                      FStar_Pervasives_Native.Some
-                                                        t_branch
-                                                    else
-                                                      (let uu___18 =
-                                                         type_leq g t_branch
-                                                           t1 in
-                                                       if uu___18
-                                                       then
-                                                         FStar_Pervasives_Native.Some
-                                                           t1
-                                                       else
-                                                         FStar_Pervasives_Native.None) in
-                                              (topt1, f1))
-                                     ((FStar_Pervasives_Native.Some t_first),
-                                       f_first) rest in
-                                 (match uu___10 with
-                                  | (topt, f_match) ->
-                                      let mlbranches2 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          mlbranches1
-                                          (FStar_Compiler_List.map
-                                             (fun uu___11 ->
-                                                match uu___11 with
-                                                | (p, (wopt, uu___12),
-                                                   (b1, uu___13, t1)) ->
-                                                    let b2 =
-                                                      match topt with
-                                                      | FStar_Pervasives_Native.None
-                                                          ->
-                                                          FStar_Extraction_ML_Syntax.apply_obj_repr
-                                                            b1 t1
-                                                      | FStar_Pervasives_Native.Some
-                                                          uu___14 -> b1 in
-                                                    (p, wopt, b2))) in
-                                      let t_match =
-                                        match topt with
-                                        | FStar_Pervasives_Native.None ->
-                                            FStar_Extraction_ML_Syntax.MLTY_Top
-                                        | FStar_Pervasives_Native.Some t1 ->
-                                            t1 in
-                                      let uu___11 =
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (FStar_Extraction_ML_Syntax.with_ty
-                                             t_match)
-                                          (FStar_Extraction_ML_Syntax.MLE_Match
-                                             (e1, mlbranches2)) in
-                                      (uu___11, f_match, t_match)))))))
-let (ind_discriminator_body :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident -> FStar_Extraction_ML_Syntax.mlmodule1)
-  =
-  fun env ->
-    fun discName ->
-      fun constrName ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-            FStar_TypeChecker_Env.lookup_lid uu___2 discName in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.fst
-            uu___1 in
-        match uu___ with
-        | (uu___1, fstar_disc_type) ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Subst.compress fstar_disc_type in
-                uu___4.FStar_Syntax_Syntax.n in
-              match uu___3 with
-              | FStar_Syntax_Syntax.Tm_arrow (binders, uu___4) ->
-                  let binders1 =
-                    FStar_Compiler_Effect.op_Bar_Greater binders
-                      (FStar_Compiler_List.filter
-                         (fun uu___5 ->
-                            match uu___5 with
-                            | { FStar_Syntax_Syntax.binder_bv = uu___6;
-                                FStar_Syntax_Syntax.binder_qual =
-                                  FStar_Pervasives_Native.Some
-                                  (FStar_Syntax_Syntax.Implicit uu___7);
-                                FStar_Syntax_Syntax.binder_attrs = uu___8;_}
-                                -> true
-                            | uu___6 -> false)) in
-                  FStar_Compiler_List.fold_right
-                    (fun uu___5 ->
-                       fun uu___6 ->
-                         match uu___6 with
-                         | (g, vs) ->
-                             let uu___7 =
-                               FStar_Extraction_ML_UEnv.new_mlident g in
-                             (match uu___7 with
-                              | (g1, v) ->
-                                  (g1,
-                                    ((v, FStar_Extraction_ML_Syntax.MLTY_Top)
-                                    :: vs)))) binders1 (env, [])
-              | uu___4 -> failwith "Discriminator must be a function" in
-            (match uu___2 with
-             | (g, wildcards) ->
-                 let uu___3 = FStar_Extraction_ML_UEnv.new_mlident g in
-                 (match uu___3 with
-                  | (g1, mlid) ->
-                      let targ = FStar_Extraction_ML_Syntax.MLTY_Top in
-                      let disc_ty = FStar_Extraction_ML_Syntax.MLTY_Top in
-                      let discrBody =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      (FStar_Extraction_ML_Syntax.with_ty
-                                         targ)
-                                      (FStar_Extraction_ML_Syntax.MLE_Name
-                                         ([], mlid)) in
-                                  let uu___10 =
-                                    let uu___11 =
-                                      let uu___12 =
-                                        let uu___13 =
-                                          let uu___14 =
-                                            FStar_Extraction_ML_UEnv.mlpath_of_lident
-                                              g1 constrName in
-                                          (uu___14,
-                                            [FStar_Extraction_ML_Syntax.MLP_Wild]) in
-                                        FStar_Extraction_ML_Syntax.MLP_CTor
-                                          uu___13 in
-                                      let uu___13 =
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (FStar_Extraction_ML_Syntax.with_ty
-                                             FStar_Extraction_ML_Syntax.ml_bool_ty)
-                                          (FStar_Extraction_ML_Syntax.MLE_Const
-                                             (FStar_Extraction_ML_Syntax.MLC_Bool
-                                                true)) in
-                                      (uu___12, FStar_Pervasives_Native.None,
-                                        uu___13) in
-                                    let uu___12 =
-                                      let uu___13 =
-                                        let uu___14 =
-                                          FStar_Compiler_Effect.op_Less_Bar
-                                            (FStar_Extraction_ML_Syntax.with_ty
-                                               FStar_Extraction_ML_Syntax.ml_bool_ty)
-                                            (FStar_Extraction_ML_Syntax.MLE_Const
-                                               (FStar_Extraction_ML_Syntax.MLC_Bool
-                                                  false)) in
-                                        (FStar_Extraction_ML_Syntax.MLP_Wild,
-                                          FStar_Pervasives_Native.None,
-                                          uu___14) in
-                                      [uu___13] in
-                                    uu___11 :: uu___12 in
-                                  (uu___9, uu___10) in
-                                FStar_Extraction_ML_Syntax.MLE_Match uu___8 in
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_Extraction_ML_Syntax.with_ty
-                                   FStar_Extraction_ML_Syntax.ml_bool_ty)
-                                uu___7 in
-                            ((FStar_Compiler_List.op_At wildcards
-                                [(mlid, targ)]), uu___6) in
-                          FStar_Extraction_ML_Syntax.MLE_Fun uu___5 in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Extraction_ML_Syntax.with_ty disc_ty) uu___4 in
-                      let uu___4 =
-                        FStar_Extraction_ML_UEnv.mlpath_of_lident env
-                          discName in
-                      (match uu___4 with
-                       | (uu___5, name) ->
-                           FStar_Extraction_ML_Syntax.MLM_Let
-                             (FStar_Extraction_ML_Syntax.NonRec,
-                               [{
-                                  FStar_Extraction_ML_Syntax.mllb_name = name;
-                                  FStar_Extraction_ML_Syntax.mllb_tysc =
-                                    FStar_Pervasives_Native.None;
-                                  FStar_Extraction_ML_Syntax.mllb_add_unit =
-                                    false;
-                                  FStar_Extraction_ML_Syntax.mllb_def =
-                                    discrBody;
-                                  FStar_Extraction_ML_Syntax.mllb_meta = [];
-                                  FStar_Extraction_ML_Syntax.print_typ =
-                                    false
-                                }]))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_UEnv.ml b/src/ocaml-output/FStar_Extraction_ML_UEnv.ml
deleted file mode 100644
index 515cc0016c5..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_UEnv.ml
+++ /dev/null
@@ -1,1130 +0,0 @@
-open Prims
-type ty_binding =
-  {
-  ty_b_name: FStar_Extraction_ML_Syntax.mlident ;
-  ty_b_ty: FStar_Extraction_ML_Syntax.mlty }
-let (__proj__Mkty_binding__item__ty_b_name :
-  ty_binding -> FStar_Extraction_ML_Syntax.mlident) =
-  fun projectee ->
-    match projectee with | { ty_b_name; ty_b_ty;_} -> ty_b_name
-let (__proj__Mkty_binding__item__ty_b_ty :
-  ty_binding -> FStar_Extraction_ML_Syntax.mlty) =
-  fun projectee -> match projectee with | { ty_b_name; ty_b_ty;_} -> ty_b_ty
-type exp_binding =
-  {
-  exp_b_name: FStar_Extraction_ML_Syntax.mlident ;
-  exp_b_expr: FStar_Extraction_ML_Syntax.mlexpr ;
-  exp_b_tscheme: FStar_Extraction_ML_Syntax.mltyscheme }
-let (__proj__Mkexp_binding__item__exp_b_name :
-  exp_binding -> FStar_Extraction_ML_Syntax.mlident) =
-  fun projectee ->
-    match projectee with
-    | { exp_b_name; exp_b_expr; exp_b_tscheme;_} -> exp_b_name
-let (__proj__Mkexp_binding__item__exp_b_expr :
-  exp_binding -> FStar_Extraction_ML_Syntax.mlexpr) =
-  fun projectee ->
-    match projectee with
-    | { exp_b_name; exp_b_expr; exp_b_tscheme;_} -> exp_b_expr
-let (__proj__Mkexp_binding__item__exp_b_tscheme :
-  exp_binding -> FStar_Extraction_ML_Syntax.mltyscheme) =
-  fun projectee ->
-    match projectee with
-    | { exp_b_name; exp_b_expr; exp_b_tscheme;_} -> exp_b_tscheme
-type ty_or_exp_b = (ty_binding, exp_binding) FStar_Pervasives.either
-type binding =
-  | Bv of (FStar_Syntax_Syntax.bv * ty_or_exp_b) 
-  | Fv of (FStar_Syntax_Syntax.fv * exp_binding) 
-  | ErasedFv of FStar_Syntax_Syntax.fv 
-let (uu___is_Bv : binding -> Prims.bool) =
-  fun projectee -> match projectee with | Bv _0 -> true | uu___ -> false
-let (__proj__Bv__item___0 :
-  binding -> (FStar_Syntax_Syntax.bv * ty_or_exp_b)) =
-  fun projectee -> match projectee with | Bv _0 -> _0
-let (uu___is_Fv : binding -> Prims.bool) =
-  fun projectee -> match projectee with | Fv _0 -> true | uu___ -> false
-let (__proj__Fv__item___0 :
-  binding -> (FStar_Syntax_Syntax.fv * exp_binding)) =
-  fun projectee -> match projectee with | Fv _0 -> _0
-let (uu___is_ErasedFv : binding -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ErasedFv _0 -> true | uu___ -> false
-let (__proj__ErasedFv__item___0 : binding -> FStar_Syntax_Syntax.fv) =
-  fun projectee -> match projectee with | ErasedFv _0 -> _0
-type tydef =
-  {
-  tydef_fv: FStar_Syntax_Syntax.fv ;
-  tydef_mlmodule_name: FStar_Extraction_ML_Syntax.mlsymbol Prims.list ;
-  tydef_name: FStar_Extraction_ML_Syntax.mlsymbol ;
-  tydef_meta: FStar_Extraction_ML_Syntax.metadata ;
-  tydef_def: FStar_Extraction_ML_Syntax.mltyscheme }
-let (__proj__Mktydef__item__tydef_fv : tydef -> FStar_Syntax_Syntax.fv) =
-  fun projectee ->
-    match projectee with
-    | { tydef_fv; tydef_mlmodule_name; tydef_name; tydef_meta; tydef_def;_}
-        -> tydef_fv
-let (__proj__Mktydef__item__tydef_mlmodule_name :
-  tydef -> FStar_Extraction_ML_Syntax.mlsymbol Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { tydef_fv; tydef_mlmodule_name; tydef_name; tydef_meta; tydef_def;_}
-        -> tydef_mlmodule_name
-let (__proj__Mktydef__item__tydef_name :
-  tydef -> FStar_Extraction_ML_Syntax.mlsymbol) =
-  fun projectee ->
-    match projectee with
-    | { tydef_fv; tydef_mlmodule_name; tydef_name; tydef_meta; tydef_def;_}
-        -> tydef_name
-let (__proj__Mktydef__item__tydef_meta :
-  tydef -> FStar_Extraction_ML_Syntax.metadata) =
-  fun projectee ->
-    match projectee with
-    | { tydef_fv; tydef_mlmodule_name; tydef_name; tydef_meta; tydef_def;_}
-        -> tydef_meta
-let (__proj__Mktydef__item__tydef_def :
-  tydef -> FStar_Extraction_ML_Syntax.mltyscheme) =
-  fun projectee ->
-    match projectee with
-    | { tydef_fv; tydef_mlmodule_name; tydef_name; tydef_meta; tydef_def;_}
-        -> tydef_def
-let (tydef_fv : tydef -> FStar_Syntax_Syntax.fv) = fun td -> td.tydef_fv
-let (tydef_meta : tydef -> FStar_Extraction_ML_Syntax.metadata) =
-  fun td -> td.tydef_meta
-let (tydef_def : tydef -> FStar_Extraction_ML_Syntax.mltyscheme) =
-  fun td -> td.tydef_def
-let (tydef_mlpath : tydef -> FStar_Extraction_ML_Syntax.mlpath) =
-  fun td -> ((td.tydef_mlmodule_name), (td.tydef_name))
-type uenv =
-  {
-  env_tcenv: FStar_TypeChecker_Env.env ;
-  env_bindings: binding Prims.list ;
-  env_mlident_map:
-    FStar_Extraction_ML_Syntax.mlident FStar_Compiler_Util.psmap ;
-  env_remove_typars: FStar_Extraction_ML_RemoveUnusedParameters.env_t ;
-  mlpath_of_lid: FStar_Extraction_ML_Syntax.mlpath FStar_Compiler_Util.psmap ;
-  env_fieldname_map:
-    FStar_Extraction_ML_Syntax.mlident FStar_Compiler_Util.psmap ;
-  mlpath_of_fieldname:
-    FStar_Extraction_ML_Syntax.mlpath FStar_Compiler_Util.psmap ;
-  tydefs: tydef Prims.list ;
-  type_names:
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_Syntax.mlpath) Prims.list ;
-  tydef_declarations: Prims.bool FStar_Compiler_Util.psmap ;
-  currentModule: FStar_Extraction_ML_Syntax.mlpath }
-let (__proj__Mkuenv__item__env_tcenv : uenv -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> env_tcenv
-let (__proj__Mkuenv__item__env_bindings : uenv -> binding Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> env_bindings
-let (__proj__Mkuenv__item__env_mlident_map :
-  uenv -> FStar_Extraction_ML_Syntax.mlident FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> env_mlident_map
-let (__proj__Mkuenv__item__env_remove_typars :
-  uenv -> FStar_Extraction_ML_RemoveUnusedParameters.env_t) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> env_remove_typars
-let (__proj__Mkuenv__item__mlpath_of_lid :
-  uenv -> FStar_Extraction_ML_Syntax.mlpath FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> mlpath_of_lid
-let (__proj__Mkuenv__item__env_fieldname_map :
-  uenv -> FStar_Extraction_ML_Syntax.mlident FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> env_fieldname_map
-let (__proj__Mkuenv__item__mlpath_of_fieldname :
-  uenv -> FStar_Extraction_ML_Syntax.mlpath FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} ->
-        mlpath_of_fieldname
-let (__proj__Mkuenv__item__tydefs : uenv -> tydef Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> tydefs
-let (__proj__Mkuenv__item__type_names :
-  uenv ->
-    (FStar_Syntax_Syntax.fv * FStar_Extraction_ML_Syntax.mlpath) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> type_names
-let (__proj__Mkuenv__item__tydef_declarations :
-  uenv -> Prims.bool FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} ->
-        tydef_declarations
-let (__proj__Mkuenv__item__currentModule :
-  uenv -> FStar_Extraction_ML_Syntax.mlpath) =
-  fun projectee ->
-    match projectee with
-    | { env_tcenv; env_bindings; env_mlident_map; env_remove_typars;
-        mlpath_of_lid; env_fieldname_map; mlpath_of_fieldname; tydefs;
-        type_names; tydef_declarations; currentModule;_} -> currentModule
-let (tcenv_of_uenv : uenv -> FStar_TypeChecker_Env.env) =
-  fun u -> u.env_tcenv
-let (set_tcenv : uenv -> FStar_TypeChecker_Env.env -> uenv) =
-  fun u ->
-    fun t ->
-      {
-        env_tcenv = t;
-        env_bindings = (u.env_bindings);
-        env_mlident_map = (u.env_mlident_map);
-        env_remove_typars = (u.env_remove_typars);
-        mlpath_of_lid = (u.mlpath_of_lid);
-        env_fieldname_map = (u.env_fieldname_map);
-        mlpath_of_fieldname = (u.mlpath_of_fieldname);
-        tydefs = (u.tydefs);
-        type_names = (u.type_names);
-        tydef_declarations = (u.tydef_declarations);
-        currentModule = (u.currentModule)
-      }
-let (current_module_of_uenv : uenv -> FStar_Extraction_ML_Syntax.mlpath) =
-  fun u -> u.currentModule
-let (set_current_module : uenv -> FStar_Extraction_ML_Syntax.mlpath -> uenv)
-  =
-  fun u ->
-    fun m ->
-      {
-        env_tcenv = (u.env_tcenv);
-        env_bindings = (u.env_bindings);
-        env_mlident_map = (u.env_mlident_map);
-        env_remove_typars = (u.env_remove_typars);
-        mlpath_of_lid = (u.mlpath_of_lid);
-        env_fieldname_map = (u.env_fieldname_map);
-        mlpath_of_fieldname = (u.mlpath_of_fieldname);
-        tydefs = (u.tydefs);
-        type_names = (u.type_names);
-        tydef_declarations = (u.tydef_declarations);
-        currentModule = m
-      }
-let with_typars_env :
-  'a .
-    uenv ->
-      (FStar_Extraction_ML_RemoveUnusedParameters.env_t ->
-         (FStar_Extraction_ML_RemoveUnusedParameters.env_t * 'a))
-        -> (uenv * 'a)
-  =
-  fun u ->
-    fun f ->
-      let uu___ = f u.env_remove_typars in
-      match uu___ with
-      | (e, x) ->
-          ({
-             env_tcenv = (u.env_tcenv);
-             env_bindings = (u.env_bindings);
-             env_mlident_map = (u.env_mlident_map);
-             env_remove_typars = e;
-             mlpath_of_lid = (u.mlpath_of_lid);
-             env_fieldname_map = (u.env_fieldname_map);
-             mlpath_of_fieldname = (u.mlpath_of_fieldname);
-             tydefs = (u.tydefs);
-             type_names = (u.type_names);
-             tydef_declarations = (u.tydef_declarations);
-             currentModule = (u.currentModule)
-           }, x)
-let (bindings_of_uenv : uenv -> binding Prims.list) = fun u -> u.env_bindings
-let (debug : uenv -> (unit -> unit) -> unit) =
-  fun g ->
-    fun f ->
-      let c = FStar_Extraction_ML_Syntax.string_of_mlpath g.currentModule in
-      let uu___ =
-        FStar_Options.debug_at_level c (FStar_Options.Other "Extraction") in
-      if uu___ then f () else ()
-let (print_mlpath_map : uenv -> Prims.string) =
-  fun g ->
-    let string_of_mlpath mlp =
-      Prims.op_Hat
-        (FStar_String.concat "." (FStar_Pervasives_Native.fst mlp))
-        (Prims.op_Hat "." (FStar_Pervasives_Native.snd mlp)) in
-    let entries =
-      FStar_Compiler_Util.psmap_fold g.mlpath_of_lid
-        (fun key ->
-           fun value ->
-             fun entries1 ->
-               let uu___ =
-                 FStar_Compiler_Util.format2 "%s -> %s" key
-                   (string_of_mlpath value) in
-               uu___ :: entries1) [] in
-    FStar_String.concat "\n" entries
-let (lookup_fv_generic :
-  uenv ->
-    FStar_Syntax_Syntax.fv ->
-      (Prims.bool, exp_binding) FStar_Pervasives.either)
-  =
-  fun g ->
-    fun fv ->
-      let v =
-        FStar_Compiler_Util.find_map g.env_bindings
-          (fun uu___ ->
-             match uu___ with
-             | Fv (fv', t) when FStar_Syntax_Syntax.fv_eq fv fv' ->
-                 FStar_Pervasives_Native.Some (FStar_Pervasives.Inr t)
-             | ErasedFv fv' when FStar_Syntax_Syntax.fv_eq fv fv' ->
-                 FStar_Pervasives_Native.Some (FStar_Pervasives.Inl true)
-             | uu___1 -> FStar_Pervasives_Native.None) in
-      match v with
-      | FStar_Pervasives_Native.Some r -> r
-      | FStar_Pervasives_Native.None -> FStar_Pervasives.Inl false
-let (try_lookup_fv :
-  FStar_Compiler_Range.range ->
-    uenv ->
-      FStar_Syntax_Syntax.fv -> exp_binding FStar_Pervasives_Native.option)
-  =
-  fun r ->
-    fun g ->
-      fun fv ->
-        let uu___ = lookup_fv_generic g fv in
-        match uu___ with
-        | FStar_Pervasives.Inr r1 -> FStar_Pervasives_Native.Some r1
-        | FStar_Pervasives.Inl (true) ->
-            ((let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Print.fv_to_string fv in
-                  let uu___5 =
-                    FStar_Compiler_Util.string_of_int
-                      FStar_Errors.call_to_erased_errno in
-                  FStar_Compiler_Util.format2
-                    "Will not extract reference to variable `%s` since it is noextract; either remove its qualifier or add it to this definition. This error can be ignored with `--warn_error -%s`."
-                    uu___4 uu___5 in
-                (FStar_Errors.Error_CallToErased, uu___3) in
-              FStar_Errors.log_issue r uu___2);
-             FStar_Pervasives_Native.None)
-        | FStar_Pervasives.Inl (false) -> FStar_Pervasives_Native.None
-let (lookup_fv :
-  FStar_Compiler_Range.range -> uenv -> FStar_Syntax_Syntax.fv -> exp_binding)
-  =
-  fun r ->
-    fun g ->
-      fun fv ->
-        let uu___ = lookup_fv_generic g fv in
-        match uu___ with
-        | FStar_Pervasives.Inr t -> t
-        | FStar_Pervasives.Inl b ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_Range.string_of_range
-                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.p in
-              let uu___3 =
-                FStar_Syntax_Print.lid_to_string
-                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-              let uu___4 = FStar_Compiler_Util.string_of_bool b in
-              FStar_Compiler_Util.format3
-                "Internal error: (%s) free variable %s not found during extraction (erased=%s)\n"
-                uu___2 uu___3 uu___4 in
-            failwith uu___1
-let (lookup_bv : uenv -> FStar_Syntax_Syntax.bv -> ty_or_exp_b) =
-  fun g ->
-    fun bv ->
-      let x =
-        FStar_Compiler_Util.find_map g.env_bindings
-          (fun uu___ ->
-             match uu___ with
-             | Bv (bv', r) when FStar_Syntax_Syntax.bv_eq bv bv' ->
-                 FStar_Pervasives_Native.Some r
-             | uu___1 -> FStar_Pervasives_Native.None) in
-      match x with
-      | FStar_Pervasives_Native.None ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                FStar_Ident.range_of_id bv.FStar_Syntax_Syntax.ppname in
-              FStar_Compiler_Range.string_of_range uu___2 in
-            let uu___2 = FStar_Syntax_Print.bv_to_string bv in
-            FStar_Compiler_Util.format2 "(%s) bound Variable %s not found\n"
-              uu___1 uu___2 in
-          failwith uu___
-      | FStar_Pervasives_Native.Some y -> y
-let (lookup_term :
-  uenv ->
-    FStar_Syntax_Syntax.term ->
-      (ty_or_exp_b * FStar_Syntax_Syntax.fv_qual
-        FStar_Pervasives_Native.option))
-  =
-  fun g ->
-    fun t ->
-      match t.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_name x ->
-          let uu___ = lookup_bv g x in (uu___, FStar_Pervasives_Native.None)
-      | FStar_Syntax_Syntax.Tm_fvar x ->
-          let uu___ =
-            let uu___1 = lookup_fv t.FStar_Syntax_Syntax.pos g x in
-            FStar_Pervasives.Inr uu___1 in
-          (uu___, (x.FStar_Syntax_Syntax.fv_qual))
-      | uu___ -> failwith "Impossible: lookup_term for a non-name"
-let (lookup_ty : uenv -> FStar_Syntax_Syntax.bv -> ty_binding) =
-  fun g ->
-    fun x ->
-      let uu___ = lookup_bv g x in
-      match uu___ with
-      | FStar_Pervasives.Inl ty -> ty
-      | uu___1 -> failwith "Expected a type name"
-let (lookup_tydef :
-  uenv ->
-    FStar_Extraction_ML_Syntax.mlpath ->
-      FStar_Extraction_ML_Syntax.mltyscheme FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | (module_name, ty_name) ->
-          FStar_Compiler_Util.find_map env.tydefs
-            (fun tydef1 ->
-               if
-                 (ty_name = tydef1.tydef_name) &&
-                   (module_name = tydef1.tydef_mlmodule_name)
-               then FStar_Pervasives_Native.Some (tydef1.tydef_def)
-               else FStar_Pervasives_Native.None)
-let (has_tydef_declaration : uenv -> FStar_Ident.lident -> Prims.bool) =
-  fun u ->
-    fun l ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid l in
-        FStar_Compiler_Util.psmap_try_find u.tydef_declarations uu___1 in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some b -> b
-let (mlpath_of_lident :
-  uenv -> FStar_Ident.lident -> FStar_Extraction_ML_Syntax.mlpath) =
-  fun g ->
-    fun x ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid x in
-        FStar_Compiler_Util.psmap_try_find g.mlpath_of_lid uu___1 in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          (debug g
-             (fun uu___2 ->
-                (let uu___4 = FStar_Ident.string_of_lid x in
-                 FStar_Compiler_Util.print1 "Identifier not found: %s" uu___4);
-                (let uu___4 = print_mlpath_map g in
-                 FStar_Compiler_Util.print1 "Env is \n%s\n" uu___4));
-           (let uu___2 =
-              let uu___3 = FStar_Ident.string_of_lid x in
-              Prims.op_Hat "Identifier not found: " uu___3 in
-            failwith uu___2))
-      | FStar_Pervasives_Native.Some mlp -> mlp
-let (is_type_name : uenv -> FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun g ->
-    fun fv ->
-      FStar_Compiler_Effect.op_Bar_Greater g.type_names
-        (FStar_Compiler_Util.for_some
-           (fun uu___ ->
-              match uu___ with
-              | (x, uu___1) -> FStar_Syntax_Syntax.fv_eq fv x))
-let (is_fv_type : uenv -> FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun g ->
-    fun fv ->
-      (is_type_name g fv) ||
-        (FStar_Compiler_Effect.op_Bar_Greater g.tydefs
-           (FStar_Compiler_Util.for_some
-              (fun tydef1 -> FStar_Syntax_Syntax.fv_eq fv tydef1.tydef_fv)))
-let (lookup_record_field_name :
-  uenv ->
-    (FStar_Ident.lident * FStar_Ident.ident) ->
-      FStar_Extraction_ML_Syntax.mlpath)
-  =
-  fun g ->
-    fun uu___ ->
-      match uu___ with
-      | (type_name, fn) ->
-          let key =
-            let uu___1 =
-              let uu___2 = FStar_Ident.ids_of_lid type_name in
-              FStar_Compiler_List.op_At uu___2 [fn] in
-            FStar_Ident.lid_of_ids uu___1 in
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_lid key in
-            FStar_Compiler_Util.psmap_try_find g.mlpath_of_fieldname uu___2 in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               let uu___2 =
-                 let uu___3 = FStar_Ident.string_of_lid key in
-                 Prims.op_Hat "Field name not found: " uu___3 in
-               failwith uu___2
-           | FStar_Pervasives_Native.Some mlp -> mlp)
-let (initial_mlident_map : unit -> Prims.string FStar_Compiler_Util.psmap) =
-  let map = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang map in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some m -> m
-    | FStar_Pervasives_Native.None ->
-        let m =
-          let uu___2 =
-            let uu___3 = FStar_Options.codegen () in
-            match uu___3 with
-            | FStar_Pervasives_Native.Some (FStar_Options.FSharp) ->
-                FStar_Extraction_ML_Syntax.fsharpkeywords
-            | FStar_Pervasives_Native.Some (FStar_Options.OCaml) ->
-                FStar_Extraction_ML_Syntax.ocamlkeywords
-            | FStar_Pervasives_Native.Some (FStar_Options.Plugin) ->
-                FStar_Extraction_ML_Syntax.ocamlkeywords
-            | FStar_Pervasives_Native.Some (FStar_Options.Krml) ->
-                FStar_Extraction_ML_Syntax.krml_keywords ()
-            | FStar_Pervasives_Native.None -> [] in
-          let uu___3 = FStar_Compiler_Util.psmap_empty () in
-          FStar_Compiler_List.fold_right
-            (fun x -> fun m1 -> FStar_Compiler_Util.psmap_add m1 x "") uu___2
-            uu___3 in
-        (FStar_Compiler_Effect.op_Colon_Equals map
-           (FStar_Pervasives_Native.Some m);
-         m)
-let (rename_conventional : Prims.string -> Prims.bool -> Prims.string) =
-  fun s ->
-    fun is_local_type_variable ->
-      let cs = FStar_String.list_of_string s in
-      let sanitize_typ uu___ =
-        let valid_rest c = FStar_Compiler_Util.is_letter_or_digit c in
-        let aux cs1 =
-          FStar_Compiler_List.map
-            (fun x -> let uu___1 = valid_rest x in if uu___1 then x else 117)
-            cs1 in
-        let uu___1 = let uu___2 = FStar_Compiler_List.hd cs in uu___2 = 39 in
-        if uu___1
-        then
-          let uu___2 = FStar_Compiler_List.hd cs in
-          let uu___3 = let uu___4 = FStar_Compiler_List.tail cs in aux uu___4 in
-          uu___2 :: uu___3
-        else (let uu___3 = aux cs in 39 :: uu___3) in
-      let sanitize_term uu___ =
-        let valid c =
-          ((FStar_Compiler_Util.is_letter_or_digit c) || (c = 95)) ||
-            (c = 39) in
-        let cs' =
-          FStar_Compiler_List.fold_right
-            (fun c ->
-               fun cs1 ->
-                 let uu___1 =
-                   let uu___2 = valid c in if uu___2 then [c] else [95; 95] in
-                 FStar_Compiler_List.op_At uu___1 cs1) cs [] in
-        match cs' with
-        | c::cs1 when (FStar_Compiler_Util.is_digit c) || (c = 39) -> 95 :: c
-            :: cs1
-        | uu___1 -> cs in
-      let uu___ =
-        if is_local_type_variable then sanitize_typ () else sanitize_term () in
-      FStar_String.string_of_list uu___
-let (root_name_of_bv :
-  FStar_Syntax_Syntax.bv -> FStar_Extraction_ML_Syntax.mlident) =
-  fun x ->
-    let uu___ =
-      (let uu___1 = FStar_Ident.string_of_id x.FStar_Syntax_Syntax.ppname in
-       FStar_Compiler_Util.starts_with uu___1 FStar_Ident.reserved_prefix) ||
-        (FStar_Syntax_Syntax.is_null_bv x) in
-    if uu___
-    then FStar_Ident.reserved_prefix
-    else FStar_Ident.string_of_id x.FStar_Syntax_Syntax.ppname
-let (find_uniq :
-  Prims.string FStar_Compiler_Util.psmap ->
-    Prims.string ->
-      Prims.bool -> (Prims.string * Prims.string FStar_Compiler_Util.psmap))
-  =
-  fun ml_ident_map ->
-    fun root_name ->
-      fun is_local_type_variable ->
-        let rec aux i root_name1 =
-          let target_mlident =
-            if i = Prims.int_zero
-            then root_name1
-            else
-              (let uu___1 = FStar_Compiler_Util.string_of_int i in
-               Prims.op_Hat root_name1 uu___1) in
-          let uu___ =
-            FStar_Compiler_Util.psmap_try_find ml_ident_map target_mlident in
-          match uu___ with
-          | FStar_Pervasives_Native.Some x ->
-              aux (i + Prims.int_one) root_name1
-          | FStar_Pervasives_Native.None ->
-              let map =
-                FStar_Compiler_Util.psmap_add ml_ident_map target_mlident "" in
-              (target_mlident, map) in
-        let mlident = rename_conventional root_name is_local_type_variable in
-        if is_local_type_variable
-        then
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Util.substring_from mlident Prims.int_one in
-            aux Prims.int_zero uu___1 in
-          match uu___ with | (nm, map) -> ((Prims.op_Hat "'" nm), map)
-        else aux Prims.int_zero mlident
-let (mlns_of_lid : FStar_Ident.lident -> Prims.string Prims.list) =
-  fun x ->
-    let uu___ = FStar_Ident.ns_of_lid x in
-    FStar_Compiler_List.map FStar_Ident.string_of_id uu___
-let (new_mlpath_of_lident :
-  uenv -> FStar_Ident.lident -> (FStar_Extraction_ML_Syntax.mlpath * uenv)) =
-  fun g ->
-    fun x ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Parser_Const.failwith_lid () in
-          FStar_Ident.lid_equals x uu___2 in
-        if uu___1
-        then
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Ident.ident_of_lid x in
-              FStar_Ident.string_of_id uu___4 in
-            ([], uu___3) in
-          (uu___2, g)
-        else
-          (let uu___3 =
-             let uu___4 =
-               let uu___5 = FStar_Ident.ident_of_lid x in
-               FStar_Ident.string_of_id uu___5 in
-             find_uniq g.env_mlident_map uu___4 false in
-           match uu___3 with
-           | (name, map) ->
-               let g1 =
-                 {
-                   env_tcenv = (g.env_tcenv);
-                   env_bindings = (g.env_bindings);
-                   env_mlident_map = map;
-                   env_remove_typars = (g.env_remove_typars);
-                   mlpath_of_lid = (g.mlpath_of_lid);
-                   env_fieldname_map = (g.env_fieldname_map);
-                   mlpath_of_fieldname = (g.mlpath_of_fieldname);
-                   tydefs = (g.tydefs);
-                   type_names = (g.type_names);
-                   tydef_declarations = (g.tydef_declarations);
-                   currentModule = (g.currentModule)
-                 } in
-               let uu___4 = let uu___5 = mlns_of_lid x in (uu___5, name) in
-               (uu___4, g1)) in
-      match uu___ with
-      | (mlp, g1) ->
-          let g2 =
-            let uu___1 =
-              let uu___2 = FStar_Ident.string_of_lid x in
-              FStar_Compiler_Util.psmap_add g1.mlpath_of_lid uu___2 mlp in
-            {
-              env_tcenv = (g1.env_tcenv);
-              env_bindings = (g1.env_bindings);
-              env_mlident_map = (g1.env_mlident_map);
-              env_remove_typars = (g1.env_remove_typars);
-              mlpath_of_lid = uu___1;
-              env_fieldname_map = (g1.env_fieldname_map);
-              mlpath_of_fieldname = (g1.mlpath_of_fieldname);
-              tydefs = (g1.tydefs);
-              type_names = (g1.type_names);
-              tydef_declarations = (g1.tydef_declarations);
-              currentModule = (g1.currentModule)
-            } in
-          (mlp, g2)
-let (extend_ty : uenv -> FStar_Syntax_Syntax.bv -> Prims.bool -> uenv) =
-  fun g ->
-    fun a ->
-      fun map_to_top ->
-        let is_local_type_variable = Prims.op_Negation map_to_top in
-        let uu___ =
-          let uu___1 = root_name_of_bv a in
-          find_uniq g.env_mlident_map uu___1 is_local_type_variable in
-        match uu___ with
-        | (ml_a, mlident_map) ->
-            let mapped_to =
-              if map_to_top
-              then FStar_Extraction_ML_Syntax.MLTY_Top
-              else FStar_Extraction_ML_Syntax.MLTY_Var ml_a in
-            let gamma =
-              (Bv
-                 (a,
-                   (FStar_Pervasives.Inl
-                      { ty_b_name = ml_a; ty_b_ty = mapped_to })))
-              :: (g.env_bindings) in
-            let tcenv = FStar_TypeChecker_Env.push_bv g.env_tcenv a in
-            {
-              env_tcenv = tcenv;
-              env_bindings = gamma;
-              env_mlident_map = mlident_map;
-              env_remove_typars = (g.env_remove_typars);
-              mlpath_of_lid = (g.mlpath_of_lid);
-              env_fieldname_map = (g.env_fieldname_map);
-              mlpath_of_fieldname = (g.mlpath_of_fieldname);
-              tydefs = (g.tydefs);
-              type_names = (g.type_names);
-              tydef_declarations = (g.tydef_declarations);
-              currentModule = (g.currentModule)
-            }
-let (extend_bv :
-  uenv ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Extraction_ML_Syntax.mltyscheme ->
-        Prims.bool ->
-          Prims.bool ->
-            (uenv * FStar_Extraction_ML_Syntax.mlident * exp_binding))
-  =
-  fun g ->
-    fun x ->
-      fun t_x ->
-        fun add_unit ->
-          fun mk_unit ->
-            let ml_ty =
-              match t_x with
-              | ([], t) -> t
-              | uu___ -> FStar_Extraction_ML_Syntax.MLTY_Top in
-            let uu___ =
-              let uu___1 = root_name_of_bv x in
-              find_uniq g.env_mlident_map uu___1 false in
-            match uu___ with
-            | (mlident, mlident_map) ->
-                let mlx = FStar_Extraction_ML_Syntax.MLE_Var mlident in
-                let mlx1 =
-                  if mk_unit
-                  then FStar_Extraction_ML_Syntax.ml_unit
-                  else
-                    if add_unit
-                    then
-                      FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_Extraction_ML_Syntax.with_ty
-                           FStar_Extraction_ML_Syntax.MLTY_Top)
-                        (FStar_Extraction_ML_Syntax.MLE_App
-                           ((FStar_Extraction_ML_Syntax.with_ty
-                               FStar_Extraction_ML_Syntax.MLTY_Top mlx),
-                             [FStar_Extraction_ML_Syntax.ml_unit]))
-                    else FStar_Extraction_ML_Syntax.with_ty ml_ty mlx in
-                let t_x1 =
-                  if add_unit
-                  then FStar_Extraction_ML_Syntax.pop_unit t_x
-                  else t_x in
-                let exp_binding1 =
-                  {
-                    exp_b_name = mlident;
-                    exp_b_expr = mlx1;
-                    exp_b_tscheme = t_x1
-                  } in
-                let gamma = (Bv (x, (FStar_Pervasives.Inr exp_binding1))) ::
-                  (g.env_bindings) in
-                let tcenv =
-                  let uu___1 = FStar_Syntax_Syntax.binders_of_list [x] in
-                  FStar_TypeChecker_Env.push_binders g.env_tcenv uu___1 in
-                ({
-                   env_tcenv = tcenv;
-                   env_bindings = gamma;
-                   env_mlident_map = mlident_map;
-                   env_remove_typars = (g.env_remove_typars);
-                   mlpath_of_lid = (g.mlpath_of_lid);
-                   env_fieldname_map = (g.env_fieldname_map);
-                   mlpath_of_fieldname = (g.mlpath_of_fieldname);
-                   tydefs = (g.tydefs);
-                   type_names = (g.type_names);
-                   tydef_declarations = (g.tydef_declarations);
-                   currentModule = (g.currentModule)
-                 }, mlident, exp_binding1)
-let (burn_name : uenv -> FStar_Extraction_ML_Syntax.mlident -> uenv) =
-  fun g ->
-    fun i ->
-      let uu___ = FStar_Compiler_Util.psmap_add g.env_mlident_map i "" in
-      {
-        env_tcenv = (g.env_tcenv);
-        env_bindings = (g.env_bindings);
-        env_mlident_map = uu___;
-        env_remove_typars = (g.env_remove_typars);
-        mlpath_of_lid = (g.mlpath_of_lid);
-        env_fieldname_map = (g.env_fieldname_map);
-        mlpath_of_fieldname = (g.mlpath_of_fieldname);
-        tydefs = (g.tydefs);
-        type_names = (g.type_names);
-        tydef_declarations = (g.tydef_declarations);
-        currentModule = (g.currentModule)
-      }
-let (new_mlident : uenv -> (uenv * FStar_Extraction_ML_Syntax.mlident)) =
-  fun g ->
-    let ml_ty = FStar_Extraction_ML_Syntax.MLTY_Top in
-    let x =
-      FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-        FStar_Syntax_Syntax.tun in
-    let uu___ =
-      extend_bv g x ([], FStar_Extraction_ML_Syntax.MLTY_Top) false false in
-    match uu___ with | (g1, id, uu___1) -> (g1, id)
-let (extend_fv :
-  uenv ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_Extraction_ML_Syntax.mltyscheme ->
-        Prims.bool ->
-          (uenv * FStar_Extraction_ML_Syntax.mlident * exp_binding))
-  =
-  fun g ->
-    fun x ->
-      fun t_x ->
-        fun add_unit ->
-          let rec mltyFvars t =
-            match t with
-            | FStar_Extraction_ML_Syntax.MLTY_Var x1 -> [x1]
-            | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, f, t2) ->
-                let uu___ = mltyFvars t1 in
-                let uu___1 = mltyFvars t2 in
-                FStar_Compiler_List.append uu___ uu___1
-            | FStar_Extraction_ML_Syntax.MLTY_Named (args, path) ->
-                FStar_Compiler_List.collect mltyFvars args
-            | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-                FStar_Compiler_List.collect mltyFvars ts
-            | FStar_Extraction_ML_Syntax.MLTY_Top -> []
-            | FStar_Extraction_ML_Syntax.MLTY_Erased -> [] in
-          let rec subsetMlidents la lb =
-            match la with
-            | h::tla ->
-                (FStar_Compiler_List.contains h lb) &&
-                  (subsetMlidents tla lb)
-            | [] -> true in
-          let tySchemeIsClosed tys =
-            let uu___ = mltyFvars (FStar_Pervasives_Native.snd tys) in
-            subsetMlidents uu___ (FStar_Pervasives_Native.fst tys) in
-          let uu___ = tySchemeIsClosed t_x in
-          if uu___
-          then
-            let ml_ty =
-              match t_x with
-              | ([], t) -> t
-              | uu___1 -> FStar_Extraction_ML_Syntax.MLTY_Top in
-            let uu___1 =
-              new_mlpath_of_lident g
-                (x.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-            match uu___1 with
-            | (mlpath, g1) ->
-                let mlsymbol = FStar_Pervasives_Native.snd mlpath in
-                let mly = FStar_Extraction_ML_Syntax.MLE_Name mlpath in
-                let mly1 =
-                  if add_unit
-                  then
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_Extraction_ML_Syntax.with_ty
-                         FStar_Extraction_ML_Syntax.MLTY_Top)
-                      (FStar_Extraction_ML_Syntax.MLE_App
-                         ((FStar_Extraction_ML_Syntax.with_ty
-                             FStar_Extraction_ML_Syntax.MLTY_Top mly),
-                           [FStar_Extraction_ML_Syntax.ml_unit]))
-                  else FStar_Extraction_ML_Syntax.with_ty ml_ty mly in
-                let t_x1 =
-                  if add_unit
-                  then FStar_Extraction_ML_Syntax.pop_unit t_x
-                  else t_x in
-                let exp_binding1 =
-                  {
-                    exp_b_name = mlsymbol;
-                    exp_b_expr = mly1;
-                    exp_b_tscheme = t_x1
-                  } in
-                let gamma = (Fv (x, exp_binding1)) :: (g1.env_bindings) in
-                let mlident_map =
-                  FStar_Compiler_Util.psmap_add g1.env_mlident_map mlsymbol
-                    "" in
-                ({
-                   env_tcenv = (g1.env_tcenv);
-                   env_bindings = gamma;
-                   env_mlident_map = mlident_map;
-                   env_remove_typars = (g1.env_remove_typars);
-                   mlpath_of_lid = (g1.mlpath_of_lid);
-                   env_fieldname_map = (g1.env_fieldname_map);
-                   mlpath_of_fieldname = (g1.mlpath_of_fieldname);
-                   tydefs = (g1.tydefs);
-                   type_names = (g1.type_names);
-                   tydef_declarations = (g1.tydef_declarations);
-                   currentModule = (g1.currentModule)
-                 }, mlsymbol, exp_binding1)
-          else failwith "freevars found"
-let (extend_erased_fv : uenv -> FStar_Syntax_Syntax.fv -> uenv) =
-  fun g ->
-    fun f ->
-      {
-        env_tcenv = (g.env_tcenv);
-        env_bindings = ((ErasedFv f) :: (g.env_bindings));
-        env_mlident_map = (g.env_mlident_map);
-        env_remove_typars = (g.env_remove_typars);
-        mlpath_of_lid = (g.mlpath_of_lid);
-        env_fieldname_map = (g.env_fieldname_map);
-        mlpath_of_fieldname = (g.mlpath_of_fieldname);
-        tydefs = (g.tydefs);
-        type_names = (g.type_names);
-        tydef_declarations = (g.tydef_declarations);
-        currentModule = (g.currentModule)
-      }
-let (extend_lb :
-  uenv ->
-    FStar_Syntax_Syntax.lbname ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Extraction_ML_Syntax.mltyscheme ->
-          Prims.bool ->
-            (uenv * FStar_Extraction_ML_Syntax.mlident * exp_binding))
-  =
-  fun g ->
-    fun l ->
-      fun t ->
-        fun t_x ->
-          fun add_unit ->
-            match l with
-            | FStar_Pervasives.Inl x -> extend_bv g x t_x add_unit false
-            | FStar_Pervasives.Inr f -> extend_fv g f t_x add_unit
-let (extend_tydef :
-  uenv ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_Extraction_ML_Syntax.mltyscheme ->
-        FStar_Extraction_ML_Syntax.metadata ->
-          (tydef * FStar_Extraction_ML_Syntax.mlpath * uenv))
-  =
-  fun g ->
-    fun fv ->
-      fun ts ->
-        fun meta ->
-          let uu___ =
-            new_mlpath_of_lident g
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          match uu___ with
-          | (name, g1) ->
-              let tydef1 =
-                {
-                  tydef_fv = fv;
-                  tydef_mlmodule_name = (FStar_Pervasives_Native.fst name);
-                  tydef_name = (FStar_Pervasives_Native.snd name);
-                  tydef_meta = meta;
-                  tydef_def = ts
-                } in
-              (tydef1, name,
-                {
-                  env_tcenv = (g1.env_tcenv);
-                  env_bindings = (g1.env_bindings);
-                  env_mlident_map = (g1.env_mlident_map);
-                  env_remove_typars = (g1.env_remove_typars);
-                  mlpath_of_lid = (g1.mlpath_of_lid);
-                  env_fieldname_map = (g1.env_fieldname_map);
-                  mlpath_of_fieldname = (g1.mlpath_of_fieldname);
-                  tydefs = (tydef1 :: (g1.tydefs));
-                  type_names = ((fv, name) :: (g1.type_names));
-                  tydef_declarations = (g1.tydef_declarations);
-                  currentModule = (g1.currentModule)
-                })
-let (extend_with_tydef_declaration : uenv -> FStar_Ident.lident -> uenv) =
-  fun u ->
-    fun l ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid l in
-        FStar_Compiler_Util.psmap_add u.tydef_declarations uu___1 true in
-      {
-        env_tcenv = (u.env_tcenv);
-        env_bindings = (u.env_bindings);
-        env_mlident_map = (u.env_mlident_map);
-        env_remove_typars = (u.env_remove_typars);
-        mlpath_of_lid = (u.mlpath_of_lid);
-        env_fieldname_map = (u.env_fieldname_map);
-        mlpath_of_fieldname = (u.mlpath_of_fieldname);
-        tydefs = (u.tydefs);
-        type_names = (u.type_names);
-        tydef_declarations = uu___;
-        currentModule = (u.currentModule)
-      }
-let (extend_type_name :
-  uenv ->
-    FStar_Syntax_Syntax.fv -> (FStar_Extraction_ML_Syntax.mlpath * uenv))
-  =
-  fun g ->
-    fun fv ->
-      let uu___ =
-        new_mlpath_of_lident g
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      match uu___ with
-      | (name, g1) ->
-          (name,
-            {
-              env_tcenv = (g1.env_tcenv);
-              env_bindings = (g1.env_bindings);
-              env_mlident_map = (g1.env_mlident_map);
-              env_remove_typars = (g1.env_remove_typars);
-              mlpath_of_lid = (g1.mlpath_of_lid);
-              env_fieldname_map = (g1.env_fieldname_map);
-              mlpath_of_fieldname = (g1.mlpath_of_fieldname);
-              tydefs = (g1.tydefs);
-              type_names = ((fv, name) :: (g1.type_names));
-              tydef_declarations = (g1.tydef_declarations);
-              currentModule = (g1.currentModule)
-            })
-let (extend_with_monad_op_name :
-  uenv ->
-    FStar_Syntax_Syntax.eff_decl ->
-      Prims.string ->
-        FStar_Extraction_ML_Syntax.mltyscheme ->
-          (FStar_Extraction_ML_Syntax.mlpath * FStar_Ident.lident *
-            exp_binding * uenv))
-  =
-  fun g ->
-    fun ed ->
-      fun nm ->
-        fun ts ->
-          let lid =
-            let uu___ = FStar_Ident.id_of_text nm in
-            FStar_Syntax_Util.mk_field_projector_name_from_ident
-              ed.FStar_Syntax_Syntax.mname uu___ in
-          let uu___ =
-            let uu___1 =
-              FStar_Syntax_Syntax.lid_as_fv lid
-                FStar_Syntax_Syntax.delta_constant
-                FStar_Pervasives_Native.None in
-            extend_fv g uu___1 ts false in
-          match uu___ with
-          | (g1, mlid, exp_b) ->
-              let mlp = let uu___1 = mlns_of_lid lid in (uu___1, mlid) in
-              (mlp, lid, exp_b, g1)
-let (extend_with_action_name :
-  uenv ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.action ->
-        FStar_Extraction_ML_Syntax.mltyscheme ->
-          (FStar_Extraction_ML_Syntax.mlpath * FStar_Ident.lident *
-            exp_binding * uenv))
-  =
-  fun g ->
-    fun ed ->
-      fun a ->
-        fun ts ->
-          let nm =
-            let uu___ =
-              FStar_Ident.ident_of_lid a.FStar_Syntax_Syntax.action_name in
-            FStar_Ident.string_of_id uu___ in
-          let module_name =
-            FStar_Ident.ns_of_lid ed.FStar_Syntax_Syntax.mname in
-          let lid =
-            let uu___ =
-              let uu___1 = let uu___2 = FStar_Ident.id_of_text nm in [uu___2] in
-              FStar_Compiler_List.op_At module_name uu___1 in
-            FStar_Ident.lid_of_ids uu___ in
-          let uu___ =
-            let uu___1 =
-              FStar_Syntax_Syntax.lid_as_fv lid
-                FStar_Syntax_Syntax.delta_constant
-                FStar_Pervasives_Native.None in
-            extend_fv g uu___1 ts false in
-          match uu___ with
-          | (g1, mlid, exp_b) ->
-              let mlp = let uu___1 = mlns_of_lid lid in (uu___1, mlid) in
-              (mlp, lid, exp_b, g1)
-let (extend_record_field_name :
-  uenv ->
-    (FStar_Ident.lident * FStar_Ident.ident) ->
-      (FStar_Extraction_ML_Syntax.mlident * uenv))
-  =
-  fun g ->
-    fun uu___ ->
-      match uu___ with
-      | (type_name, fn) ->
-          let key =
-            let uu___1 =
-              let uu___2 = FStar_Ident.ids_of_lid type_name in
-              FStar_Compiler_List.op_At uu___2 [fn] in
-            FStar_Ident.lid_of_ids uu___1 in
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_id fn in
-            find_uniq g.env_fieldname_map uu___2 false in
-          (match uu___1 with
-           | (name, fieldname_map) ->
-               let ns = mlns_of_lid type_name in
-               let mlp = (ns, name) in
-               let g1 =
-                 let uu___2 =
-                   let uu___3 = FStar_Ident.string_of_lid key in
-                   FStar_Compiler_Util.psmap_add g.mlpath_of_fieldname uu___3
-                     mlp in
-                 {
-                   env_tcenv = (g.env_tcenv);
-                   env_bindings = (g.env_bindings);
-                   env_mlident_map = (g.env_mlident_map);
-                   env_remove_typars = (g.env_remove_typars);
-                   mlpath_of_lid = (g.mlpath_of_lid);
-                   env_fieldname_map = fieldname_map;
-                   mlpath_of_fieldname = uu___2;
-                   tydefs = (g.tydefs);
-                   type_names = (g.type_names);
-                   tydef_declarations = (g.tydef_declarations);
-                   currentModule = (g.currentModule)
-                 } in
-               (name, g1))
-let (extend_with_module_name :
-  uenv -> FStar_Ident.lident -> (FStar_Extraction_ML_Syntax.mlpath * uenv)) =
-  fun g ->
-    fun m ->
-      let ns = mlns_of_lid m in
-      let p =
-        let uu___ = FStar_Ident.ident_of_lid m in
-        FStar_Ident.string_of_id uu___ in
-      ((ns, p), g)
-let (exit_module : uenv -> uenv) =
-  fun g ->
-    let uu___ = initial_mlident_map () in
-    let uu___1 = initial_mlident_map () in
-    {
-      env_tcenv = (g.env_tcenv);
-      env_bindings = (g.env_bindings);
-      env_mlident_map = uu___;
-      env_remove_typars = (g.env_remove_typars);
-      mlpath_of_lid = (g.mlpath_of_lid);
-      env_fieldname_map = uu___1;
-      mlpath_of_fieldname = (g.mlpath_of_fieldname);
-      tydefs = (g.tydefs);
-      type_names = (g.type_names);
-      tydef_declarations = (g.tydef_declarations);
-      currentModule = (g.currentModule)
-    }
-let (new_uenv : FStar_TypeChecker_Env.env -> uenv) =
-  fun e ->
-    let env =
-      let uu___ = initial_mlident_map () in
-      let uu___1 = FStar_Compiler_Util.psmap_empty () in
-      let uu___2 = initial_mlident_map () in
-      let uu___3 = FStar_Compiler_Util.psmap_empty () in
-      let uu___4 = FStar_Compiler_Util.psmap_empty () in
-      {
-        env_tcenv = e;
-        env_bindings = [];
-        env_mlident_map = uu___;
-        env_remove_typars =
-          FStar_Extraction_ML_RemoveUnusedParameters.initial_env;
-        mlpath_of_lid = uu___1;
-        env_fieldname_map = uu___2;
-        mlpath_of_fieldname = uu___3;
-        tydefs = [];
-        type_names = [];
-        tydef_declarations = uu___4;
-        currentModule = ([], "")
-      } in
-    let a = "'a" in
-    let failwith_ty =
-      ([a],
-        (FStar_Extraction_ML_Syntax.MLTY_Fun
-           ((FStar_Extraction_ML_Syntax.MLTY_Named
-               ([], (["Prims"], "string"))),
-             FStar_Extraction_ML_Syntax.E_IMPURE,
-             (FStar_Extraction_ML_Syntax.MLTY_Var a)))) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Parser_Const.failwith_lid () in
-          FStar_Syntax_Syntax.lid_as_fv uu___3
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        FStar_Pervasives.Inr uu___2 in
-      extend_lb env uu___1 FStar_Syntax_Syntax.tun failwith_ty false in
-    match uu___ with | (g, uu___1, uu___2) -> g
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Extraction_ML_Util.ml b/src/ocaml-output/FStar_Extraction_ML_Util.ml
deleted file mode 100644
index 5de0db966bf..00000000000
--- a/src/ocaml-output/FStar_Extraction_ML_Util.ml
+++ /dev/null
@@ -1,1598 +0,0 @@
-open Prims
-let (codegen_fsharp : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.codegen () in
-    uu___1 = (FStar_Pervasives_Native.Some FStar_Options.FSharp)
-let pruneNones :
-  'a . 'a FStar_Pervasives_Native.option Prims.list -> 'a Prims.list =
-  fun l ->
-    FStar_Compiler_List.fold_right
-      (fun x ->
-         fun ll ->
-           match x with
-           | FStar_Pervasives_Native.Some xs -> xs :: ll
-           | FStar_Pervasives_Native.None -> ll) l []
-let (mk_range_mle : FStar_Extraction_ML_Syntax.mlexpr) =
-  FStar_Compiler_Effect.op_Less_Bar
-    (FStar_Extraction_ML_Syntax.with_ty FStar_Extraction_ML_Syntax.MLTY_Top)
-    (FStar_Extraction_ML_Syntax.MLE_Name (["Prims"], "mk_range"))
-let (dummy_range_mle : FStar_Extraction_ML_Syntax.mlexpr) =
-  FStar_Compiler_Effect.op_Less_Bar
-    (FStar_Extraction_ML_Syntax.with_ty FStar_Extraction_ML_Syntax.MLTY_Top)
-    (FStar_Extraction_ML_Syntax.MLE_Name (["FStar"; "Range"], "dummyRange"))
-let (fstar_real_of_string : FStar_Extraction_ML_Syntax.mlexpr) =
-  FStar_Compiler_Effect.op_Less_Bar
-    (FStar_Extraction_ML_Syntax.with_ty FStar_Extraction_ML_Syntax.MLTY_Top)
-    (FStar_Extraction_ML_Syntax.MLE_Name (["FStar"; "Real"], "of_string"))
-let (mlconst_of_const' :
-  FStar_Const.sconst -> FStar_Extraction_ML_Syntax.mlconstant) =
-  fun sctt ->
-    match sctt with
-    | FStar_Const.Const_effect -> failwith "Unsupported constant"
-    | FStar_Const.Const_range uu___ -> FStar_Extraction_ML_Syntax.MLC_Unit
-    | FStar_Const.Const_unit -> FStar_Extraction_ML_Syntax.MLC_Unit
-    | FStar_Const.Const_char c -> FStar_Extraction_ML_Syntax.MLC_Char c
-    | FStar_Const.Const_int (s, i) ->
-        FStar_Extraction_ML_Syntax.MLC_Int (s, i)
-    | FStar_Const.Const_bool b -> FStar_Extraction_ML_Syntax.MLC_Bool b
-    | FStar_Const.Const_string (s, uu___) ->
-        FStar_Extraction_ML_Syntax.MLC_String s
-    | FStar_Const.Const_range_of ->
-        failwith "Unhandled constant: range_of/set_range_of"
-    | FStar_Const.Const_set_range_of ->
-        failwith "Unhandled constant: range_of/set_range_of"
-    | FStar_Const.Const_real uu___ ->
-        failwith "Unhandled constant: real/reify/reflect"
-    | FStar_Const.Const_reify ->
-        failwith "Unhandled constant: real/reify/reflect"
-    | FStar_Const.Const_reflect uu___ ->
-        failwith "Unhandled constant: real/reify/reflect"
-let (mlconst_of_const :
-  FStar_Compiler_Range.range ->
-    FStar_Const.sconst -> FStar_Extraction_ML_Syntax.mlconstant)
-  =
-  fun p ->
-    fun c ->
-      try (fun uu___ -> match () with | () -> mlconst_of_const' c) ()
-      with
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Range.string_of_range p in
-            let uu___3 = FStar_Syntax_Print.const_to_string c in
-            FStar_Compiler_Util.format2
-              "(%s) Failed to translate constant %s " uu___2 uu___3 in
-          failwith uu___1
-let (mlexpr_of_range :
-  FStar_Compiler_Range.range -> FStar_Extraction_ML_Syntax.mlexpr') =
-  fun r ->
-    let cint i =
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Util.string_of_int i in
-            (uu___3, FStar_Pervasives_Native.None) in
-          FStar_Extraction_ML_Syntax.MLC_Int uu___2 in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          (fun uu___2 -> FStar_Extraction_ML_Syntax.MLE_Const uu___2) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (FStar_Extraction_ML_Syntax.with_ty
-           FStar_Extraction_ML_Syntax.ml_int_ty) in
-    let cstr s =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Extraction_ML_Syntax.MLC_String s)
-          (fun uu___1 -> FStar_Extraction_ML_Syntax.MLE_Const uu___1) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (FStar_Extraction_ML_Syntax.with_ty
-           FStar_Extraction_ML_Syntax.ml_string_ty) in
-    let drop_path s = FStar_Compiler_List.last (FStar_String.split [47] s) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = FStar_Compiler_Range.file_of_range r in
-            FStar_Compiler_Effect.op_Bar_Greater uu___4 drop_path in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3 cstr in
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 = FStar_Compiler_Range.start_of_range r in
-              FStar_Compiler_Effect.op_Bar_Greater uu___6
-                FStar_Compiler_Range.line_of_pos in
-            FStar_Compiler_Effect.op_Bar_Greater uu___5 cint in
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = FStar_Compiler_Range.start_of_range r in
-                FStar_Compiler_Effect.op_Bar_Greater uu___8
-                  FStar_Compiler_Range.col_of_pos in
-              FStar_Compiler_Effect.op_Bar_Greater uu___7 cint in
-            let uu___7 =
-              let uu___8 =
-                let uu___9 =
-                  let uu___10 = FStar_Compiler_Range.end_of_range r in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___10
-                    FStar_Compiler_Range.line_of_pos in
-                FStar_Compiler_Effect.op_Bar_Greater uu___9 cint in
-              let uu___9 =
-                let uu___10 =
-                  let uu___11 =
-                    let uu___12 = FStar_Compiler_Range.end_of_range r in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___12
-                      FStar_Compiler_Range.col_of_pos in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___11 cint in
-                [uu___10] in
-              uu___8 :: uu___9 in
-            uu___6 :: uu___7 in
-          uu___4 :: uu___5 in
-        uu___2 :: uu___3 in
-      (mk_range_mle, uu___1) in
-    FStar_Extraction_ML_Syntax.MLE_App uu___
-let (mlexpr_of_const :
-  FStar_Compiler_Range.range ->
-    FStar_Const.sconst -> FStar_Extraction_ML_Syntax.mlexpr')
-  =
-  fun p ->
-    fun c ->
-      match c with
-      | FStar_Const.Const_range r -> mlexpr_of_range r
-      | FStar_Const.Const_real s ->
-          let str = mlconst_of_const p (FStar_Const.Const_string (s, p)) in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_Extraction_ML_Syntax.with_ty
-                     FStar_Extraction_ML_Syntax.ml_string_ty)
-                  (FStar_Extraction_ML_Syntax.MLE_Const str) in
-              [uu___2] in
-            (fstar_real_of_string, uu___1) in
-          FStar_Extraction_ML_Syntax.MLE_App uu___
-      | uu___ ->
-          let uu___1 = mlconst_of_const p c in
-          FStar_Extraction_ML_Syntax.MLE_Const uu___1
-let rec (subst_aux :
-  (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
-    Prims.list ->
-    FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun subst ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Var x ->
-          let uu___ =
-            FStar_Compiler_Util.find_opt
-              (fun uu___1 -> match uu___1 with | (y, uu___2) -> y = x) subst in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some ts ->
-               FStar_Pervasives_Native.snd ts
-           | FStar_Pervasives_Native.None -> t)
-      | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, f, t2) ->
-          let uu___ =
-            let uu___1 = subst_aux subst t1 in
-            let uu___2 = subst_aux subst t2 in (uu___1, f, uu___2) in
-          FStar_Extraction_ML_Syntax.MLTY_Fun uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, path) ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_List.map (subst_aux subst) args in
-            (uu___1, path) in
-          FStar_Extraction_ML_Syntax.MLTY_Named uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (subst_aux subst) ts in
-          FStar_Extraction_ML_Syntax.MLTY_Tuple uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Top -> t
-      | FStar_Extraction_ML_Syntax.MLTY_Erased -> t
-let (try_subst :
-  FStar_Extraction_ML_Syntax.mltyscheme ->
-    FStar_Extraction_ML_Syntax.mlty Prims.list ->
-      FStar_Extraction_ML_Syntax.mlty FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    fun args ->
-      match uu___ with
-      | (formals, t) ->
-          if
-            (FStar_Compiler_List.length formals) <>
-              (FStar_Compiler_List.length args)
-          then FStar_Pervasives_Native.None
-          else
-            (let uu___2 =
-               let uu___3 = FStar_Compiler_List.zip formals args in
-               subst_aux uu___3 t in
-             FStar_Pervasives_Native.Some uu___2)
-let (subst :
-  (FStar_Extraction_ML_Syntax.mlidents * FStar_Extraction_ML_Syntax.mlty) ->
-    FStar_Extraction_ML_Syntax.mlty Prims.list ->
-      FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun ts ->
-    fun args ->
-      let uu___ = try_subst ts args in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          failwith
-            "Substitution must be fully applied (see GitHub issue #490)"
-      | FStar_Pervasives_Native.Some t -> t
-let (udelta_unfold :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      FStar_Extraction_ML_Syntax.mlty FStar_Pervasives_Native.option)
-  =
-  fun g ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (args, n) ->
-          let uu___1 = FStar_Extraction_ML_UEnv.lookup_tydef g n in
-          (match uu___1 with
-           | FStar_Pervasives_Native.Some ts ->
-               let uu___2 = try_subst ts args in
-               (match uu___2 with
-                | FStar_Pervasives_Native.None ->
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Extraction_ML_Syntax.string_of_mlpath n in
-                      let uu___5 =
-                        FStar_Compiler_Util.string_of_int
-                          (FStar_Compiler_List.length args) in
-                      let uu___6 =
-                        FStar_Compiler_Util.string_of_int
-                          (FStar_Compiler_List.length
-                             (FStar_Pervasives_Native.fst ts)) in
-                      FStar_Compiler_Util.format3
-                        "Substitution must be fully applied; got an application of %s with %s args whereas %s were expected (see GitHub issue #490)"
-                        uu___4 uu___5 uu___6 in
-                    failwith uu___3
-                | FStar_Pervasives_Native.Some r ->
-                    FStar_Pervasives_Native.Some r)
-           | uu___2 -> FStar_Pervasives_Native.None)
-      | uu___1 -> FStar_Pervasives_Native.None
-let (eff_leq :
-  FStar_Extraction_ML_Syntax.e_tag ->
-    FStar_Extraction_ML_Syntax.e_tag -> Prims.bool)
-  =
-  fun f ->
-    fun f' ->
-      match (f, f') with
-      | (FStar_Extraction_ML_Syntax.E_PURE, uu___) -> true
-      | (FStar_Extraction_ML_Syntax.E_ERASABLE,
-         FStar_Extraction_ML_Syntax.E_ERASABLE) -> true
-      | (FStar_Extraction_ML_Syntax.E_IMPURE,
-         FStar_Extraction_ML_Syntax.E_IMPURE) -> true
-      | uu___ -> false
-let (eff_to_string : FStar_Extraction_ML_Syntax.e_tag -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Extraction_ML_Syntax.E_PURE -> "Pure"
-    | FStar_Extraction_ML_Syntax.E_ERASABLE -> "Erasable"
-    | FStar_Extraction_ML_Syntax.E_IMPURE -> "Impure"
-let (join :
-  FStar_Compiler_Range.range ->
-    FStar_Extraction_ML_Syntax.e_tag ->
-      FStar_Extraction_ML_Syntax.e_tag -> FStar_Extraction_ML_Syntax.e_tag)
-  =
-  fun r ->
-    fun f ->
-      fun f' ->
-        match (f, f') with
-        | (FStar_Extraction_ML_Syntax.E_IMPURE,
-           FStar_Extraction_ML_Syntax.E_PURE) ->
-            FStar_Extraction_ML_Syntax.E_IMPURE
-        | (FStar_Extraction_ML_Syntax.E_PURE,
-           FStar_Extraction_ML_Syntax.E_IMPURE) ->
-            FStar_Extraction_ML_Syntax.E_IMPURE
-        | (FStar_Extraction_ML_Syntax.E_IMPURE,
-           FStar_Extraction_ML_Syntax.E_IMPURE) ->
-            FStar_Extraction_ML_Syntax.E_IMPURE
-        | (FStar_Extraction_ML_Syntax.E_ERASABLE,
-           FStar_Extraction_ML_Syntax.E_ERASABLE) ->
-            FStar_Extraction_ML_Syntax.E_ERASABLE
-        | (FStar_Extraction_ML_Syntax.E_PURE,
-           FStar_Extraction_ML_Syntax.E_ERASABLE) ->
-            FStar_Extraction_ML_Syntax.E_ERASABLE
-        | (FStar_Extraction_ML_Syntax.E_ERASABLE,
-           FStar_Extraction_ML_Syntax.E_PURE) ->
-            FStar_Extraction_ML_Syntax.E_ERASABLE
-        | (FStar_Extraction_ML_Syntax.E_PURE,
-           FStar_Extraction_ML_Syntax.E_PURE) ->
-            FStar_Extraction_ML_Syntax.E_PURE
-        | uu___ ->
-            let uu___1 =
-              let uu___2 = FStar_Compiler_Range.string_of_range r in
-              let uu___3 = eff_to_string f in
-              let uu___4 = eff_to_string f' in
-              FStar_Compiler_Util.format3
-                "Impossible (%s): Inconsistent effects %s and %s" uu___2
-                uu___3 uu___4 in
-            failwith uu___1
-let (join_l :
-  FStar_Compiler_Range.range ->
-    FStar_Extraction_ML_Syntax.e_tag Prims.list ->
-      FStar_Extraction_ML_Syntax.e_tag)
-  =
-  fun r ->
-    fun fs ->
-      FStar_Compiler_List.fold_left (join r)
-        FStar_Extraction_ML_Syntax.E_PURE fs
-let (mk_ty_fun :
-  (FStar_Extraction_ML_Syntax.mlident * FStar_Extraction_ML_Syntax.mlty)
-    Prims.list ->
-    FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  FStar_Compiler_List.fold_right
-    (fun uu___ ->
-       fun t ->
-         match uu___ with
-         | (uu___1, t0) ->
-             FStar_Extraction_ML_Syntax.MLTY_Fun
-               (t0, FStar_Extraction_ML_Syntax.E_PURE, t))
-type unfold_t =
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_Extraction_ML_Syntax.mlty FStar_Pervasives_Native.option
-let rec (type_leq_c :
-  unfold_t ->
-    FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option ->
-      FStar_Extraction_ML_Syntax.mlty ->
-        FStar_Extraction_ML_Syntax.mlty ->
-          (Prims.bool * FStar_Extraction_ML_Syntax.mlexpr
-            FStar_Pervasives_Native.option))
-  =
-  fun unfold_ty ->
-    fun e ->
-      fun t ->
-        fun t' ->
-          match (t, t') with
-          | (FStar_Extraction_ML_Syntax.MLTY_Var x,
-             FStar_Extraction_ML_Syntax.MLTY_Var y) ->
-              if x = y
-              then (true, e)
-              else (false, FStar_Pervasives_Native.None)
-          | (FStar_Extraction_ML_Syntax.MLTY_Fun (t1, f, t2),
-             FStar_Extraction_ML_Syntax.MLTY_Fun (t1', f', t2')) ->
-              let mk_fun xs body =
-                match xs with
-                | [] -> body
-                | uu___ ->
-                    let e1 =
-                      match body.FStar_Extraction_ML_Syntax.expr with
-                      | FStar_Extraction_ML_Syntax.MLE_Fun (ys, body1) ->
-                          FStar_Extraction_ML_Syntax.MLE_Fun
-                            ((FStar_Compiler_List.op_At xs ys), body1)
-                      | uu___1 ->
-                          FStar_Extraction_ML_Syntax.MLE_Fun (xs, body) in
-                    let uu___1 =
-                      mk_ty_fun xs body.FStar_Extraction_ML_Syntax.mlty in
-                    FStar_Extraction_ML_Syntax.with_ty uu___1 e1 in
-              (match e with
-               | FStar_Pervasives_Native.Some
-                   {
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Fun (x::xs, body);
-                     FStar_Extraction_ML_Syntax.mlty = uu___;
-                     FStar_Extraction_ML_Syntax.loc = uu___1;_}
-                   ->
-                   let uu___2 = (type_leq unfold_ty t1' t1) && (eff_leq f f') in
-                   if uu___2
-                   then
-                     (if
-                        (f = FStar_Extraction_ML_Syntax.E_PURE) &&
-                          (f' = FStar_Extraction_ML_Syntax.E_ERASABLE)
-                      then
-                        let uu___3 = type_leq unfold_ty t2 t2' in
-                        (if uu___3
-                         then
-                           let body1 =
-                             let uu___4 =
-                               type_leq unfold_ty t2
-                                 FStar_Extraction_ML_Syntax.ml_unit_ty in
-                             if uu___4
-                             then FStar_Extraction_ML_Syntax.ml_unit
-                             else
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_Extraction_ML_Syntax.with_ty t2')
-                                 (FStar_Extraction_ML_Syntax.MLE_Coerce
-                                    (FStar_Extraction_ML_Syntax.ml_unit,
-                                      FStar_Extraction_ML_Syntax.ml_unit_ty,
-                                      t2')) in
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   mk_ty_fun [x]
-                                     body1.FStar_Extraction_ML_Syntax.mlty in
-                                 FStar_Extraction_ML_Syntax.with_ty uu___7 in
-                               FStar_Compiler_Effect.op_Less_Bar uu___6
-                                 (FStar_Extraction_ML_Syntax.MLE_Fun
-                                    ([x], body1)) in
-                             FStar_Pervasives_Native.Some uu___5 in
-                           (true, uu___4)
-                         else (false, FStar_Pervasives_Native.None))
-                      else
-                        (let uu___4 =
-                           let uu___5 =
-                             let uu___6 = mk_fun xs body in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               (fun uu___7 ->
-                                  FStar_Pervasives_Native.Some uu___7) uu___6 in
-                           type_leq_c unfold_ty uu___5 t2 t2' in
-                         match uu___4 with
-                         | (ok, body1) ->
-                             let res =
-                               match body1 with
-                               | FStar_Pervasives_Native.Some body2 ->
-                                   let uu___5 = mk_fun [x] body2 in
-                                   FStar_Pervasives_Native.Some uu___5
-                               | uu___5 -> FStar_Pervasives_Native.None in
-                             (ok, res)))
-                   else (false, FStar_Pervasives_Native.None)
-               | uu___ ->
-                   let uu___1 =
-                     ((type_leq unfold_ty t1' t1) && (eff_leq f f')) &&
-                       (type_leq unfold_ty t2 t2') in
-                   if uu___1
-                   then (true, e)
-                   else (false, FStar_Pervasives_Native.None))
-          | (FStar_Extraction_ML_Syntax.MLTY_Named (args, path),
-             FStar_Extraction_ML_Syntax.MLTY_Named (args', path')) ->
-              if path = path'
-              then
-                let uu___ =
-                  FStar_Compiler_List.forall2 (type_leq unfold_ty) args args' in
-                (if uu___
-                 then (true, e)
-                 else (false, FStar_Pervasives_Native.None))
-              else
-                (let uu___1 = unfold_ty t in
-                 match uu___1 with
-                 | FStar_Pervasives_Native.Some t1 ->
-                     type_leq_c unfold_ty e t1 t'
-                 | FStar_Pervasives_Native.None ->
-                     let uu___2 = unfold_ty t' in
-                     (match uu___2 with
-                      | FStar_Pervasives_Native.None ->
-                          (false, FStar_Pervasives_Native.None)
-                      | FStar_Pervasives_Native.Some t'1 ->
-                          type_leq_c unfold_ty e t t'1))
-          | (FStar_Extraction_ML_Syntax.MLTY_Tuple ts,
-             FStar_Extraction_ML_Syntax.MLTY_Tuple ts') ->
-              let uu___ =
-                FStar_Compiler_List.forall2 (type_leq unfold_ty) ts ts' in
-              if uu___
-              then (true, e)
-              else (false, FStar_Pervasives_Native.None)
-          | (FStar_Extraction_ML_Syntax.MLTY_Top,
-             FStar_Extraction_ML_Syntax.MLTY_Top) -> (true, e)
-          | (FStar_Extraction_ML_Syntax.MLTY_Named uu___, uu___1) ->
-              let uu___2 = unfold_ty t in
-              (match uu___2 with
-               | FStar_Pervasives_Native.Some t1 ->
-                   type_leq_c unfold_ty e t1 t'
-               | uu___3 -> (false, FStar_Pervasives_Native.None))
-          | (uu___, FStar_Extraction_ML_Syntax.MLTY_Named uu___1) ->
-              let uu___2 = unfold_ty t' in
-              (match uu___2 with
-               | FStar_Pervasives_Native.Some t'1 ->
-                   type_leq_c unfold_ty e t t'1
-               | uu___3 -> (false, FStar_Pervasives_Native.None))
-          | (FStar_Extraction_ML_Syntax.MLTY_Erased,
-             FStar_Extraction_ML_Syntax.MLTY_Erased) -> (true, e)
-          | uu___ -> (false, FStar_Pervasives_Native.None)
-and (type_leq :
-  unfold_t ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      FStar_Extraction_ML_Syntax.mlty -> Prims.bool)
-  =
-  fun g ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ = type_leq_c g FStar_Pervasives_Native.None t1 t2 in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          FStar_Pervasives_Native.fst
-let rec (erase_effect_annotations :
-  FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty) =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, f, t2) ->
-        let uu___ =
-          let uu___1 = erase_effect_annotations t1 in
-          let uu___2 = erase_effect_annotations t2 in
-          (uu___1, FStar_Extraction_ML_Syntax.E_PURE, uu___2) in
-        FStar_Extraction_ML_Syntax.MLTY_Fun uu___
-    | uu___ -> t
-let is_type_abstraction :
-  'a 'b 'c . (('a, 'b) FStar_Pervasives.either * 'c) Prims.list -> Prims.bool
-  =
-  fun uu___ ->
-    match uu___ with
-    | (FStar_Pervasives.Inl uu___1, uu___2)::uu___3 -> true
-    | uu___1 -> false
-let (is_xtuple :
-  (Prims.string Prims.list * Prims.string) ->
-    Prims.int FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (ns, n) ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_Util.concat_l "."
-              (FStar_Compiler_List.op_At ns [n]) in
-          FStar_Parser_Const.is_tuple_datacon_string uu___2 in
-        if uu___1
-        then
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Util.char_at n (Prims.of_int (7)) in
-            FStar_Compiler_Util.int_of_char uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-        else FStar_Pervasives_Native.None
-let (resugar_exp :
-  FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr) =
-  fun e ->
-    match e.FStar_Extraction_ML_Syntax.expr with
-    | FStar_Extraction_ML_Syntax.MLE_CTor (mlp, args) ->
-        let uu___ = is_xtuple mlp in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some n ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_Extraction_ML_Syntax.with_ty
-                  e.FStar_Extraction_ML_Syntax.mlty)
-               (FStar_Extraction_ML_Syntax.MLE_Tuple args)
-         | uu___1 -> e)
-    | uu___ -> e
-let (record_field_path :
-  FStar_Ident.lident Prims.list -> Prims.string Prims.list) =
-  fun uu___ ->
-    match uu___ with
-    | f::uu___1 ->
-        let uu___2 =
-          let uu___3 = FStar_Ident.ns_of_lid f in
-          FStar_Compiler_Util.prefix uu___3 in
-        (match uu___2 with
-         | (ns, uu___3) ->
-             FStar_Compiler_Effect.op_Bar_Greater ns
-               (FStar_Compiler_List.map
-                  (fun id -> FStar_Ident.string_of_id id)))
-    | uu___1 -> failwith "impos"
-let record_fields :
-  'a .
-    FStar_Ident.lident Prims.list ->
-      'a Prims.list -> (Prims.string * 'a) Prims.list
-  =
-  fun fs ->
-    fun vs ->
-      FStar_Compiler_List.map2
-        (fun f ->
-           fun e ->
-             let uu___ =
-               let uu___1 = FStar_Ident.ident_of_lid f in
-               FStar_Ident.string_of_id uu___1 in
-             (uu___, e)) fs vs
-let (is_xtuple_ty :
-  (Prims.string Prims.list * Prims.string) ->
-    Prims.int FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (ns, n) ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_Util.concat_l "."
-              (FStar_Compiler_List.op_At ns [n]) in
-          FStar_Parser_Const.is_tuple_constructor_string uu___2 in
-        if uu___1
-        then
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Util.char_at n (Prims.of_int (5)) in
-            FStar_Compiler_Util.int_of_char uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-        else FStar_Pervasives_Native.None
-let (resugar_mlty :
-  FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty) =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named (args, mlp) ->
-        let uu___ = is_xtuple_ty mlp in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some n ->
-             FStar_Extraction_ML_Syntax.MLTY_Tuple args
-         | uu___1 -> t)
-    | uu___ -> t
-let (flatten_ns : Prims.string Prims.list -> Prims.string) =
-  fun ns -> FStar_String.concat "_" ns
-let (flatten_mlpath :
-  (Prims.string Prims.list * Prims.string) -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | (ns, n) -> FStar_String.concat "_" (FStar_Compiler_List.op_At ns [n])
-let (ml_module_name_of_lid : FStar_Ident.lident -> Prims.string) =
-  fun l ->
-    let mlp =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater l FStar_Ident.ns_of_lid in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          (FStar_Compiler_List.map FStar_Ident.string_of_id) in
-      let uu___1 =
-        let uu___2 = FStar_Ident.ident_of_lid l in
-        FStar_Ident.string_of_id uu___2 in
-      (uu___, uu___1) in
-    flatten_mlpath mlp
-let rec (erasableType :
-  unfold_t -> FStar_Extraction_ML_Syntax.mlty -> Prims.bool) =
-  fun unfold_ty ->
-    fun t ->
-      let erasableTypeNoDelta t1 =
-        if t1 = FStar_Extraction_ML_Syntax.ml_unit_ty
-        then true
-        else
-          (match t1 with
-           | FStar_Extraction_ML_Syntax.MLTY_Named
-               (uu___1, ("FStar"::"Ghost"::[], "erased")) -> true
-           | FStar_Extraction_ML_Syntax.MLTY_Named
-               (uu___1, ("FStar"::"Tactics"::"Effect"::[], "tactic")) ->
-               let uu___2 = FStar_Options.codegen () in
-               uu___2 <> (FStar_Pervasives_Native.Some FStar_Options.Plugin)
-           | uu___1 -> false) in
-      let uu___ = erasableTypeNoDelta t in
-      if uu___
-      then true
-      else
-        (let uu___2 = unfold_ty t in
-         match uu___2 with
-         | FStar_Pervasives_Native.Some t1 -> erasableType unfold_ty t1
-         | FStar_Pervasives_Native.None -> false)
-let rec (eraseTypeDeep :
-  unfold_t ->
-    FStar_Extraction_ML_Syntax.mlty -> FStar_Extraction_ML_Syntax.mlty)
-  =
-  fun unfold_ty ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Fun (tyd, etag, tycd) ->
-          if etag = FStar_Extraction_ML_Syntax.E_PURE
-          then
-            let uu___ =
-              let uu___1 = eraseTypeDeep unfold_ty tyd in
-              let uu___2 = eraseTypeDeep unfold_ty tycd in
-              (uu___1, etag, uu___2) in
-            FStar_Extraction_ML_Syntax.MLTY_Fun uu___
-          else t
-      | FStar_Extraction_ML_Syntax.MLTY_Named (lty, mlp) ->
-          let uu___ = erasableType unfold_ty t in
-          if uu___
-          then FStar_Extraction_ML_Syntax.MLTY_Erased
-          else
-            (let uu___2 =
-               let uu___3 =
-                 FStar_Compiler_List.map (eraseTypeDeep unfold_ty) lty in
-               (uu___3, mlp) in
-             FStar_Extraction_ML_Syntax.MLTY_Named uu___2)
-      | FStar_Extraction_ML_Syntax.MLTY_Tuple lty ->
-          let uu___ = FStar_Compiler_List.map (eraseTypeDeep unfold_ty) lty in
-          FStar_Extraction_ML_Syntax.MLTY_Tuple uu___
-      | uu___ -> t
-let (prims_op_equality : FStar_Extraction_ML_Syntax.mlexpr) =
-  FStar_Compiler_Effect.op_Less_Bar
-    (FStar_Extraction_ML_Syntax.with_ty FStar_Extraction_ML_Syntax.MLTY_Top)
-    (FStar_Extraction_ML_Syntax.MLE_Name (["Prims"], "op_Equality"))
-let (prims_op_amp_amp : FStar_Extraction_ML_Syntax.mlexpr) =
-  let uu___ =
-    let uu___1 =
-      mk_ty_fun
-        [("x", FStar_Extraction_ML_Syntax.ml_bool_ty);
-        ("y", FStar_Extraction_ML_Syntax.ml_bool_ty)]
-        FStar_Extraction_ML_Syntax.ml_bool_ty in
-    FStar_Extraction_ML_Syntax.with_ty uu___1 in
-  FStar_Compiler_Effect.op_Less_Bar uu___
-    (FStar_Extraction_ML_Syntax.MLE_Name (["Prims"], "op_AmpAmp"))
-let (conjoin :
-  FStar_Extraction_ML_Syntax.mlexpr ->
-    FStar_Extraction_ML_Syntax.mlexpr -> FStar_Extraction_ML_Syntax.mlexpr)
-  =
-  fun e1 ->
-    fun e2 ->
-      FStar_Compiler_Effect.op_Less_Bar
-        (FStar_Extraction_ML_Syntax.with_ty
-           FStar_Extraction_ML_Syntax.ml_bool_ty)
-        (FStar_Extraction_ML_Syntax.MLE_App (prims_op_amp_amp, [e1; e2]))
-let (conjoin_opt :
-  FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option ->
-    FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option ->
-      FStar_Extraction_ML_Syntax.mlexpr FStar_Pervasives_Native.option)
-  =
-  fun e1 ->
-    fun e2 ->
-      match (e1, e2) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives_Native.None
-      | (FStar_Pervasives_Native.Some x, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives_Native.Some x
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some x) ->
-          FStar_Pervasives_Native.Some x
-      | (FStar_Pervasives_Native.Some x, FStar_Pervasives_Native.Some y) ->
-          let uu___ = conjoin x y in FStar_Pervasives_Native.Some uu___
-let (mlloc_of_range :
-  FStar_Compiler_Range.range -> (Prims.int * Prims.string)) =
-  fun r ->
-    let pos = FStar_Compiler_Range.start_of_range r in
-    let line = FStar_Compiler_Range.line_of_pos pos in
-    let uu___ = FStar_Compiler_Range.file_of_range r in (line, uu___)
-let rec (doms_and_cod :
-  FStar_Extraction_ML_Syntax.mlty ->
-    (FStar_Extraction_ML_Syntax.mlty Prims.list *
-      FStar_Extraction_ML_Syntax.mlty))
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Fun (a, uu___, b) ->
-        let uu___1 = doms_and_cod b in
-        (match uu___1 with | (ds, c) -> ((a :: ds), c))
-    | uu___ -> ([], t)
-let (argTypes :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_Extraction_ML_Syntax.mlty Prims.list)
-  = fun t -> let uu___ = doms_and_cod t in FStar_Pervasives_Native.fst uu___
-let rec (uncurry_mlty_fun :
-  FStar_Extraction_ML_Syntax.mlty ->
-    (FStar_Extraction_ML_Syntax.mlty Prims.list *
-      FStar_Extraction_ML_Syntax.mlty))
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Fun (a, uu___, b) ->
-        let uu___1 = uncurry_mlty_fun b in
-        (match uu___1 with | (args, res) -> ((a :: args), res))
-    | uu___ -> ([], t)
-exception NoTacticEmbedding of Prims.string 
-let (uu___is_NoTacticEmbedding : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NoTacticEmbedding uu___ -> true | uu___ -> false
-let (__proj__NoTacticEmbedding__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | NoTacticEmbedding uu___ -> uu___
-let (not_implemented_warning :
-  FStar_Compiler_Range.range -> Prims.string -> Prims.string -> unit) =
-  fun r ->
-    fun t ->
-      fun msg ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  FStar_Errors.lookup
-                    FStar_Errors.Warning_PluginNotImplemented in
-                FStar_Errors.error_number uu___4 in
-              FStar_Compiler_Effect.op_Less_Bar
-                FStar_Compiler_Util.string_of_int uu___3 in
-            FStar_Compiler_Util.format3
-              "Plugin %s can not run natively because %s (use --warn_error -%s to carry on)."
-              t msg uu___2 in
-          (FStar_Errors.Warning_PluginNotImplemented, uu___1) in
-        FStar_Errors.log_issue r uu___
-type emb_loc =
-  | Syntax_term 
-  | Refl_emb 
-  | NBE_t 
-  | NBERefl_emb 
-let (uu___is_Syntax_term : emb_loc -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Syntax_term -> true | uu___ -> false
-let (uu___is_Refl_emb : emb_loc -> Prims.bool) =
-  fun projectee -> match projectee with | Refl_emb -> true | uu___ -> false
-let (uu___is_NBE_t : emb_loc -> Prims.bool) =
-  fun projectee -> match projectee with | NBE_t -> true | uu___ -> false
-let (uu___is_NBERefl_emb : emb_loc -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NBERefl_emb -> true | uu___ -> false
-type wrapped_term =
-  (FStar_Extraction_ML_Syntax.mlexpr * FStar_Extraction_ML_Syntax.mlexpr *
-    Prims.int * Prims.bool)
-let (interpret_plugin_as_term_fun :
-  FStar_Extraction_ML_UEnv.uenv ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_Syntax_Syntax.typ ->
-        Prims.int FStar_Pervasives_Native.option ->
-          FStar_Extraction_ML_Syntax.mlexpr' ->
-            (FStar_Extraction_ML_Syntax.mlexpr *
-              FStar_Extraction_ML_Syntax.mlexpr * Prims.int * Prims.bool)
-              FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun fv ->
-      fun t ->
-        fun arity_opt ->
-          fun ml_fv ->
-            let fv_lid =
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-            let tcenv = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-            let t1 =
-              FStar_TypeChecker_Normalize.normalize
-                [FStar_TypeChecker_Env.EraseUniverses;
-                FStar_TypeChecker_Env.AllowUnboundUniverses;
-                FStar_TypeChecker_Env.UnfoldUntil
-                  FStar_Syntax_Syntax.delta_constant;
-                FStar_TypeChecker_Env.ForExtraction] tcenv t in
-            let w =
-              FStar_Extraction_ML_Syntax.with_ty
-                FStar_Extraction_ML_Syntax.MLTY_Top in
-            let as_name mlp =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top)
-                (FStar_Extraction_ML_Syntax.MLE_Name mlp) in
-            let lid_to_name l =
-              let uu___ =
-                let uu___1 = FStar_Extraction_ML_UEnv.mlpath_of_lident env l in
-                FStar_Extraction_ML_Syntax.MLE_Name uu___1 in
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top) uu___ in
-            let str_to_name s = as_name ([], s) in
-            let fstar_tc_nbe_prefix s =
-              as_name (["FStar_TypeChecker_NBETerm"], s) in
-            let fstar_syn_emb_prefix s =
-              as_name (["FStar_Syntax_Embeddings"], s) in
-            let fstar_refl_emb_prefix s =
-              as_name (["FStar_Reflection_Embeddings"], s) in
-            let fstar_refl_nbeemb_prefix s =
-              as_name (["FStar_Reflection_NBEEmbeddings"], s) in
-            let fv_lid_embedded =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = as_name (["FStar_Ident"], "lid_of_str") in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 = FStar_Ident.string_of_lid fv_lid in
-                          FStar_Extraction_ML_Syntax.MLC_String uu___7 in
-                        FStar_Extraction_ML_Syntax.MLE_Const uu___6 in
-                      FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_Extraction_ML_Syntax.with_ty
-                           FStar_Extraction_ML_Syntax.MLTY_Top) uu___5 in
-                    [uu___4] in
-                  (uu___2, uu___3) in
-                FStar_Extraction_ML_Syntax.MLE_App uu___1 in
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_Extraction_ML_Syntax.with_ty
-                   FStar_Extraction_ML_Syntax.MLTY_Top) uu___ in
-            let emb_prefix uu___ =
-              match uu___ with
-              | Syntax_term -> fstar_syn_emb_prefix
-              | Refl_emb -> fstar_refl_emb_prefix
-              | NBE_t -> fstar_tc_nbe_prefix
-              | NBERefl_emb -> fstar_refl_nbeemb_prefix in
-            let mk_tactic_interpretation l arity =
-              if arity > FStar_Tactics_InterpFuns.max_tac_arity
-              then
-                FStar_Compiler_Effect.raise
-                  (NoTacticEmbedding
-                     "tactic plugins can only take up to 20 arguments")
-              else
-                (let idroot =
-                   match l with
-                   | Syntax_term -> "mk_tactic_interpretation_"
-                   | uu___1 -> "mk_nbe_tactic_interpretation_" in
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Compiler_Util.string_of_int arity in
-                     Prims.op_Hat idroot uu___3 in
-                   (["FStar_Tactics_InterpFuns"], uu___2) in
-                 as_name uu___1) in
-            let mk_from_tactic l arity =
-              let idroot =
-                match l with
-                | Syntax_term -> "from_tactic_"
-                | uu___ -> "from_nbe_tactic_" in
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Compiler_Util.string_of_int arity in
-                  Prims.op_Hat idroot uu___2 in
-                (["FStar_Tactics_Native"], uu___1) in
-              as_name uu___ in
-            let mk_basic_embedding l s =
-              if s = "norm_step"
-              then
-                match l with
-                | Syntax_term ->
-                    as_name (["FStar_Tactics_Builtins"], "e_norm_step'")
-                | NBE_t ->
-                    as_name (["FStar_Tactics_Builtins"], "e_norm_step_nbe'")
-                | uu___ ->
-                    failwith "impossible: mk_basic_embedding norm_step"
-              else emb_prefix l (Prims.op_Hat "e_" s) in
-            let mk_arrow_as_prim_step l arity =
-              let uu___ =
-                let uu___1 = FStar_Compiler_Util.string_of_int arity in
-                Prims.op_Hat "arrow_as_prim_step_" uu___1 in
-              emb_prefix l uu___ in
-            let mk_any_embedding l s =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = emb_prefix l "mk_any_emb" in
-                  let uu___3 = let uu___4 = str_to_name s in [uu___4] in
-                  (uu___2, uu___3) in
-                FStar_Extraction_ML_Syntax.MLE_App uu___1 in
-              FStar_Compiler_Effect.op_Less_Bar w uu___ in
-            let mk_lam nm e =
-              FStar_Compiler_Effect.op_Less_Bar w
-                (FStar_Extraction_ML_Syntax.MLE_Fun
-                   ([(nm, FStar_Extraction_ML_Syntax.MLTY_Top)], e)) in
-            let emb_arrow l e1 e2 =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = emb_prefix l "e_arrow" in (uu___2, [e1; e2]) in
-                FStar_Extraction_ML_Syntax.MLE_App uu___1 in
-              FStar_Compiler_Effect.op_Less_Bar w uu___ in
-            let known_type_constructors =
-              let term_cs =
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Parser_Const.mk_tuple_lid
-                                      (Prims.of_int (2))
-                                      FStar_Compiler_Range.dummyRange in
-                                  (uu___9, (Prims.of_int (2)), "tuple2") in
-                                (uu___8, Syntax_term) in
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 =
-                                    let uu___11 =
-                                      FStar_Reflection_Constants.fstar_refl_types_lid
-                                        "term" in
-                                    (uu___11, Prims.int_zero, "term") in
-                                  (uu___10, Refl_emb) in
-                                let uu___10 =
-                                  let uu___11 =
-                                    let uu___12 =
-                                      let uu___13 =
-                                        FStar_Reflection_Constants.fstar_refl_types_lid
-                                          "sigelt" in
-                                      (uu___13, Prims.int_zero, "sigelt") in
-                                    (uu___12, Refl_emb) in
-                                  let uu___12 =
-                                    let uu___13 =
-                                      let uu___14 =
-                                        let uu___15 =
-                                          FStar_Reflection_Constants.fstar_refl_types_lid
-                                            "fv" in
-                                        (uu___15, Prims.int_zero, "fv") in
-                                      (uu___14, Refl_emb) in
-                                    let uu___14 =
-                                      let uu___15 =
-                                        let uu___16 =
-                                          let uu___17 =
-                                            FStar_Reflection_Constants.fstar_refl_types_lid
-                                              "binder" in
-                                          (uu___17, Prims.int_zero, "binder") in
-                                        (uu___16, Refl_emb) in
-                                      let uu___16 =
-                                        let uu___17 =
-                                          let uu___18 =
-                                            let uu___19 =
-                                              FStar_Reflection_Constants.fstar_refl_syntax_lid
-                                                "binders" in
-                                            (uu___19, Prims.int_zero,
-                                              "binders") in
-                                          (uu___18, Refl_emb) in
-                                        let uu___18 =
-                                          let uu___19 =
-                                            let uu___20 =
-                                              let uu___21 =
-                                                FStar_Reflection_Constants.fstar_refl_data_lid
-                                                  "exp" in
-                                              (uu___21, Prims.int_zero,
-                                                "exp") in
-                                            (uu___20, Refl_emb) in
-                                          [uu___19] in
-                                        uu___17 :: uu___18 in
-                                      uu___15 :: uu___16 in
-                                    uu___13 :: uu___14 in
-                                  uu___11 :: uu___12 in
-                                uu___9 :: uu___10 in
-                              uu___7 :: uu___8 in
-                            ((FStar_Parser_Const.option_lid, Prims.int_one,
-                               "option"), Syntax_term)
-                              :: uu___6 in
-                          ((FStar_Parser_Const.list_lid, Prims.int_one,
-                             "list"), Syntax_term)
-                            :: uu___5 in
-                        ((FStar_Parser_Const.norm_step_lid, Prims.int_zero,
-                           "norm_step"), Syntax_term)
-                          :: uu___4 in
-                      ((FStar_Parser_Const.string_lid, Prims.int_zero,
-                         "string"), Syntax_term)
-                        :: uu___3 in
-                    ((FStar_Parser_Const.unit_lid, Prims.int_zero, "unit"),
-                      Syntax_term) :: uu___2 in
-                  ((FStar_Parser_Const.bool_lid, Prims.int_zero, "bool"),
-                    Syntax_term) :: uu___1 in
-                ((FStar_Parser_Const.int_lid, Prims.int_zero, "int"),
-                  Syntax_term) :: uu___ in
-              let nbe_cs =
-                FStar_Compiler_List.map
-                  (fun uu___ ->
-                     match uu___ with
-                     | (x, Syntax_term) -> (x, NBE_t)
-                     | (x, Refl_emb) -> (x, NBERefl_emb)
-                     | uu___1 -> failwith "Impossible") term_cs in
-              fun uu___ ->
-                match uu___ with
-                | Syntax_term -> term_cs
-                | Refl_emb -> term_cs
-                | uu___1 -> nbe_cs in
-            let is_known_type_constructor l fv1 n =
-              FStar_Compiler_Util.for_some
-                (fun uu___ ->
-                   match uu___ with
-                   | ((x, args, uu___1), uu___2) ->
-                       (FStar_Syntax_Syntax.fv_eq_lid fv1 x) && (n = args))
-                (known_type_constructors l) in
-            let find_env_entry bv uu___ =
-              match uu___ with
-              | (bv', uu___1) -> FStar_Syntax_Syntax.bv_eq bv bv' in
-            let rec mk_embedding l env1 t2 =
-              let t3 =
-                FStar_TypeChecker_Normalize.unfold_whnf'
-                  [FStar_TypeChecker_Env.ForExtraction] tcenv t2 in
-              let uu___ =
-                let uu___1 = FStar_Syntax_Subst.compress t3 in
-                uu___1.FStar_Syntax_Syntax.n in
-              match uu___ with
-              | FStar_Syntax_Syntax.Tm_name bv when
-                  FStar_Compiler_Util.for_some (find_env_entry bv) env1 ->
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        FStar_Compiler_Util.find_opt (find_env_entry bv) env1 in
-                      FStar_Compiler_Util.must uu___3 in
-                    FStar_Pervasives_Native.snd uu___2 in
-                  FStar_Compiler_Effect.op_Less_Bar (mk_any_embedding l)
-                    uu___1
-              | FStar_Syntax_Syntax.Tm_refine (x, uu___1) ->
-                  mk_embedding l env1 x.FStar_Syntax_Syntax.sort
-              | FStar_Syntax_Syntax.Tm_ascribed (t4, uu___1, uu___2) ->
-                  mk_embedding l env1 t4
-              | FStar_Syntax_Syntax.Tm_arrow (b::[], c) when
-                  FStar_Syntax_Util.is_pure_comp c ->
-                  let uu___1 = FStar_Syntax_Subst.open_comp [b] c in
-                  (match uu___1 with
-                   | (bs, c1) ->
-                       let t0 =
-                         let uu___2 =
-                           let uu___3 = FStar_Compiler_List.hd bs in
-                           uu___3.FStar_Syntax_Syntax.binder_bv in
-                         uu___2.FStar_Syntax_Syntax.sort in
-                       let t11 = FStar_Syntax_Util.comp_result c1 in
-                       let uu___2 = mk_embedding l env1 t0 in
-                       let uu___3 = mk_embedding l env1 t11 in
-                       emb_arrow l uu___2 uu___3)
-              | FStar_Syntax_Syntax.Tm_arrow (b::more::bs, c) ->
-                  let tail =
-                    FStar_Syntax_Syntax.mk
-                      (FStar_Syntax_Syntax.Tm_arrow ((more :: bs), c))
-                      t3.FStar_Syntax_Syntax.pos in
-                  let t4 =
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Syntax.mk_Total tail in
-                        ([b], uu___3) in
-                      FStar_Syntax_Syntax.Tm_arrow uu___2 in
-                    FStar_Syntax_Syntax.mk uu___1 t3.FStar_Syntax_Syntax.pos in
-                  mk_embedding l env1 t4
-              | FStar_Syntax_Syntax.Tm_fvar uu___1 ->
-                  let uu___2 = FStar_Syntax_Util.head_and_args t3 in
-                  (match uu___2 with
-                   | (head, args) ->
-                       let n_args = FStar_Compiler_List.length args in
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Util.un_uinst head in
-                         uu___4.FStar_Syntax_Syntax.n in
-                       (match uu___3 with
-                        | FStar_Syntax_Syntax.Tm_fvar fv1 when
-                            is_known_type_constructor l fv1 n_args ->
-                            let arg_embeddings =
-                              FStar_Compiler_Effect.op_Bar_Greater args
-                                (FStar_Compiler_List.map
-                                   (fun uu___4 ->
-                                      match uu___4 with
-                                      | (t4, uu___5) ->
-                                          mk_embedding l env1 t4)) in
-                            let nm =
-                              let uu___4 =
-                                FStar_Ident.ident_of_lid
-                                  (fv1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                              FStar_Ident.string_of_id uu___4 in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Compiler_Util.find_opt
-                                  (fun uu___6 ->
-                                     match uu___6 with
-                                     | ((x, uu___7, uu___8), uu___9) ->
-                                         FStar_Syntax_Syntax.fv_eq_lid fv1 x)
-                                  (known_type_constructors l) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                FStar_Compiler_Util.must in
-                            (match uu___4 with
-                             | ((uu___5, t_arity, _trepr_head),
-                                loc_embedding) ->
-                                 let head1 =
-                                   mk_basic_embedding loc_embedding nm in
-                                 (match t_arity with
-                                  | uu___6 when uu___6 = Prims.int_zero ->
-                                      head1
-                                  | n ->
-                                      FStar_Compiler_Effect.op_Less_Bar w
-                                        (FStar_Extraction_ML_Syntax.MLE_App
-                                           (head1, arg_embeddings))))
-                        | uu___4 ->
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Print.term_to_string t3 in
-                                Prims.op_Hat
-                                  "Embedding not defined for type " uu___7 in
-                              NoTacticEmbedding uu___6 in
-                            FStar_Compiler_Effect.raise uu___5))
-              | FStar_Syntax_Syntax.Tm_uinst uu___1 ->
-                  let uu___2 = FStar_Syntax_Util.head_and_args t3 in
-                  (match uu___2 with
-                   | (head, args) ->
-                       let n_args = FStar_Compiler_List.length args in
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Util.un_uinst head in
-                         uu___4.FStar_Syntax_Syntax.n in
-                       (match uu___3 with
-                        | FStar_Syntax_Syntax.Tm_fvar fv1 when
-                            is_known_type_constructor l fv1 n_args ->
-                            let arg_embeddings =
-                              FStar_Compiler_Effect.op_Bar_Greater args
-                                (FStar_Compiler_List.map
-                                   (fun uu___4 ->
-                                      match uu___4 with
-                                      | (t4, uu___5) ->
-                                          mk_embedding l env1 t4)) in
-                            let nm =
-                              let uu___4 =
-                                FStar_Ident.ident_of_lid
-                                  (fv1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                              FStar_Ident.string_of_id uu___4 in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Compiler_Util.find_opt
-                                  (fun uu___6 ->
-                                     match uu___6 with
-                                     | ((x, uu___7, uu___8), uu___9) ->
-                                         FStar_Syntax_Syntax.fv_eq_lid fv1 x)
-                                  (known_type_constructors l) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                FStar_Compiler_Util.must in
-                            (match uu___4 with
-                             | ((uu___5, t_arity, _trepr_head),
-                                loc_embedding) ->
-                                 let head1 =
-                                   mk_basic_embedding loc_embedding nm in
-                                 (match t_arity with
-                                  | uu___6 when uu___6 = Prims.int_zero ->
-                                      head1
-                                  | n ->
-                                      FStar_Compiler_Effect.op_Less_Bar w
-                                        (FStar_Extraction_ML_Syntax.MLE_App
-                                           (head1, arg_embeddings))))
-                        | uu___4 ->
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Print.term_to_string t3 in
-                                Prims.op_Hat
-                                  "Embedding not defined for type " uu___7 in
-                              NoTacticEmbedding uu___6 in
-                            FStar_Compiler_Effect.raise uu___5))
-              | FStar_Syntax_Syntax.Tm_app uu___1 ->
-                  let uu___2 = FStar_Syntax_Util.head_and_args t3 in
-                  (match uu___2 with
-                   | (head, args) ->
-                       let n_args = FStar_Compiler_List.length args in
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Util.un_uinst head in
-                         uu___4.FStar_Syntax_Syntax.n in
-                       (match uu___3 with
-                        | FStar_Syntax_Syntax.Tm_fvar fv1 when
-                            is_known_type_constructor l fv1 n_args ->
-                            let arg_embeddings =
-                              FStar_Compiler_Effect.op_Bar_Greater args
-                                (FStar_Compiler_List.map
-                                   (fun uu___4 ->
-                                      match uu___4 with
-                                      | (t4, uu___5) ->
-                                          mk_embedding l env1 t4)) in
-                            let nm =
-                              let uu___4 =
-                                FStar_Ident.ident_of_lid
-                                  (fv1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                              FStar_Ident.string_of_id uu___4 in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Compiler_Util.find_opt
-                                  (fun uu___6 ->
-                                     match uu___6 with
-                                     | ((x, uu___7, uu___8), uu___9) ->
-                                         FStar_Syntax_Syntax.fv_eq_lid fv1 x)
-                                  (known_type_constructors l) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                FStar_Compiler_Util.must in
-                            (match uu___4 with
-                             | ((uu___5, t_arity, _trepr_head),
-                                loc_embedding) ->
-                                 let head1 =
-                                   mk_basic_embedding loc_embedding nm in
-                                 (match t_arity with
-                                  | uu___6 when uu___6 = Prims.int_zero ->
-                                      head1
-                                  | n ->
-                                      FStar_Compiler_Effect.op_Less_Bar w
-                                        (FStar_Extraction_ML_Syntax.MLE_App
-                                           (head1, arg_embeddings))))
-                        | uu___4 ->
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Print.term_to_string t3 in
-                                Prims.op_Hat
-                                  "Embedding not defined for type " uu___7 in
-                              NoTacticEmbedding uu___6 in
-                            FStar_Compiler_Effect.raise uu___5))
-              | uu___1 ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Print.term_to_string t3 in
-                      Prims.op_Hat "Embedding not defined for type " uu___4 in
-                    NoTacticEmbedding uu___3 in
-                  FStar_Compiler_Effect.raise uu___2 in
-            let abstract_tvars tvar_names body =
-              match tvar_names with
-              | [] ->
-                  let body1 =
-                    let uu___ =
-                      let uu___1 =
-                        let uu___2 =
-                          as_name (["FStar_Syntax_Embeddings"], "debug_wrap") in
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 = FStar_Ident.string_of_lid fv_lid in
-                                FStar_Extraction_ML_Syntax.MLC_String uu___7 in
-                              FStar_Extraction_ML_Syntax.MLE_Const uu___6 in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_Extraction_ML_Syntax.with_ty
-                                 FStar_Extraction_ML_Syntax.MLTY_Top) uu___5 in
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 =
-                                  let uu___9 =
-                                    let uu___10 =
-                                      let uu___11 = str_to_name "args" in
-                                      [uu___11] in
-                                    (body, uu___10) in
-                                  FStar_Extraction_ML_Syntax.MLE_App uu___9 in
-                                FStar_Compiler_Effect.op_Less_Bar w uu___8 in
-                              mk_lam "_" uu___7 in
-                            [uu___6] in
-                          uu___4 :: uu___5 in
-                        (uu___2, uu___3) in
-                      FStar_Extraction_ML_Syntax.MLE_App uu___1 in
-                    FStar_Compiler_Effect.op_Less_Bar w uu___ in
-                  mk_lam "args" body1
-              | uu___ ->
-                  let args_tail =
-                    FStar_Extraction_ML_Syntax.MLP_Var "args_tail" in
-                  let mk_cons hd_pat tail_pat =
-                    FStar_Extraction_ML_Syntax.MLP_CTor
-                      ((["Prims"], "Cons"), [hd_pat; tail_pat]) in
-                  let fst_pat v =
-                    FStar_Extraction_ML_Syntax.MLP_Tuple
-                      [FStar_Extraction_ML_Syntax.MLP_Var v;
-                      FStar_Extraction_ML_Syntax.MLP_Wild] in
-                  let pattern =
-                    FStar_Compiler_List.fold_right
-                      (fun hd_var -> mk_cons (fst_pat hd_var)) tvar_names
-                      args_tail in
-                  let branch =
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 = as_name ([], "args") in [uu___5] in
-                          (body, uu___4) in
-                        FStar_Extraction_ML_Syntax.MLE_App uu___3 in
-                      FStar_Compiler_Effect.op_Less_Bar w uu___2 in
-                    (pattern, FStar_Pervasives_Native.None, uu___1) in
-                  let default_branch =
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 = str_to_name "failwith" in
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                mlexpr_of_const
-                                  FStar_Compiler_Range.dummyRange
-                                  (FStar_Const.Const_string
-                                     ("arity mismatch",
-                                       FStar_Compiler_Range.dummyRange)) in
-                              FStar_Compiler_Effect.op_Less_Bar w uu___7 in
-                            [uu___6] in
-                          (uu___4, uu___5) in
-                        FStar_Extraction_ML_Syntax.MLE_App uu___3 in
-                      FStar_Compiler_Effect.op_Less_Bar w uu___2 in
-                    (FStar_Extraction_ML_Syntax.MLP_Wild,
-                      FStar_Pervasives_Native.None, uu___1) in
-                  let body1 =
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = as_name ([], "args") in
-                        (uu___3, [branch; default_branch]) in
-                      FStar_Extraction_ML_Syntax.MLE_Match uu___2 in
-                    FStar_Compiler_Effect.op_Less_Bar w uu___1 in
-                  let body2 =
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 =
-                          as_name (["FStar_Syntax_Embeddings"], "debug_wrap") in
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 = FStar_Ident.string_of_lid fv_lid in
-                                FStar_Extraction_ML_Syntax.MLC_String uu___8 in
-                              FStar_Extraction_ML_Syntax.MLE_Const uu___7 in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_Extraction_ML_Syntax.with_ty
-                                 FStar_Extraction_ML_Syntax.MLTY_Top) uu___6 in
-                          let uu___6 =
-                            let uu___7 = mk_lam "_" body1 in [uu___7] in
-                          uu___5 :: uu___6 in
-                        (uu___3, uu___4) in
-                      FStar_Extraction_ML_Syntax.MLE_App uu___2 in
-                    FStar_Compiler_Effect.op_Less_Bar w uu___1 in
-                  mk_lam "args" body2 in
-            let uu___ = FStar_Syntax_Util.arrow_formals_comp t1 in
-            match uu___ with
-            | (bs, c) ->
-                let uu___1 =
-                  match arity_opt with
-                  | FStar_Pervasives_Native.None -> (bs, c)
-                  | FStar_Pervasives_Native.Some n ->
-                      let n_bs = FStar_Compiler_List.length bs in
-                      if n = n_bs
-                      then (bs, c)
-                      else
-                        if n < n_bs
-                        then
-                          (let uu___3 = FStar_Compiler_Util.first_N n bs in
-                           match uu___3 with
-                           | (bs1, rest) ->
-                               let c1 =
-                                 let uu___4 = FStar_Syntax_Util.arrow rest c in
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   FStar_Syntax_Syntax.mk_Total uu___4 in
-                               (bs1, c1))
-                        else
-                          (let msg =
-                             let uu___4 = FStar_Ident.string_of_lid fv_lid in
-                             let uu___5 = FStar_Compiler_Util.string_of_int n in
-                             let uu___6 =
-                               FStar_Compiler_Util.string_of_int n_bs in
-                             FStar_Compiler_Util.format3
-                               "Embedding not defined for %s; expected arity at least %s; got %s"
-                               uu___4 uu___5 uu___6 in
-                           FStar_Compiler_Effect.raise
-                             (NoTacticEmbedding msg)) in
-                (match uu___1 with
-                 | (bs1, c1) ->
-                     let result_typ = FStar_Syntax_Util.comp_result c1 in
-                     let arity = FStar_Compiler_List.length bs1 in
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Compiler_Util.prefix_until
-                           (fun uu___4 ->
-                              match uu___4 with
-                              | { FStar_Syntax_Syntax.binder_bv = b;
-                                  FStar_Syntax_Syntax.binder_qual = uu___5;
-                                  FStar_Syntax_Syntax.binder_attrs = uu___6;_}
-                                  ->
-                                  let uu___7 =
-                                    let uu___8 =
-                                      FStar_Syntax_Subst.compress
-                                        b.FStar_Syntax_Syntax.sort in
-                                    uu___8.FStar_Syntax_Syntax.n in
-                                  (match uu___7 with
-                                   | FStar_Syntax_Syntax.Tm_type uu___8 ->
-                                       false
-                                   | uu___8 -> true)) bs1 in
-                       match uu___3 with
-                       | FStar_Pervasives_Native.None -> (bs1, [])
-                       | FStar_Pervasives_Native.Some (tvars, x, rest) ->
-                           (tvars, (x :: rest)) in
-                     (match uu___2 with
-                      | (type_vars, bs2) ->
-                          let tvar_arity =
-                            FStar_Compiler_List.length type_vars in
-                          let non_tvar_arity = FStar_Compiler_List.length bs2 in
-                          let tvar_names =
-                            FStar_Compiler_List.mapi
-                              (fun i ->
-                                 fun tv ->
-                                   let uu___3 =
-                                     FStar_Compiler_Util.string_of_int i in
-                                   Prims.op_Hat "tv_" uu___3) type_vars in
-                          let tvar_context =
-                            FStar_Compiler_List.map2
-                              (fun b ->
-                                 fun nm ->
-                                   ((b.FStar_Syntax_Syntax.binder_bv), nm))
-                              type_vars tvar_names in
-                          let rec aux loc accum_embeddings bs3 =
-                            match bs3 with
-                            | [] ->
-                                let arg_unembeddings =
-                                  FStar_Compiler_List.rev accum_embeddings in
-                                let res_embedding =
-                                  mk_embedding loc tvar_context result_typ in
-                                let fv_lid1 =
-                                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                let uu___3 =
-                                  FStar_Syntax_Util.is_pure_comp c1 in
-                                if uu___3
-                                then
-                                  let cb = str_to_name "cb" in
-                                  let embed_fun_N =
-                                    mk_arrow_as_prim_step loc non_tvar_arity in
-                                  let args =
-                                    let uu___4 =
-                                      let uu___5 =
-                                        let uu___6 = lid_to_name fv_lid1 in
-                                        let uu___7 =
-                                          let uu___8 =
-                                            let uu___9 =
-                                              let uu___10 =
-                                                let uu___11 =
-                                                  let uu___12 =
-                                                    FStar_Compiler_Util.string_of_int
-                                                      tvar_arity in
-                                                  (uu___12,
-                                                    FStar_Pervasives_Native.None) in
-                                                FStar_Extraction_ML_Syntax.MLC_Int
-                                                  uu___11 in
-                                              FStar_Extraction_ML_Syntax.MLE_Const
-                                                uu___10 in
-                                            FStar_Compiler_Effect.op_Less_Bar
-                                              (FStar_Extraction_ML_Syntax.with_ty
-                                                 FStar_Extraction_ML_Syntax.MLTY_Top)
-                                              uu___9 in
-                                          [uu___8; fv_lid_embedded; cb] in
-                                        uu___6 :: uu___7 in
-                                      res_embedding :: uu___5 in
-                                    FStar_Compiler_List.op_At
-                                      arg_unembeddings uu___4 in
-                                  let fun_embedding =
-                                    FStar_Compiler_Effect.op_Less_Bar w
-                                      (FStar_Extraction_ML_Syntax.MLE_App
-                                         (embed_fun_N, args)) in
-                                  let tabs =
-                                    abstract_tvars tvar_names fun_embedding in
-                                  let cb_tabs = mk_lam "cb" tabs in
-                                  let uu___4 =
-                                    if loc = NBE_t
-                                    then cb_tabs
-                                    else mk_lam "_psc" cb_tabs in
-                                  (uu___4, arity, true)
-                                else
-                                  (let uu___5 =
-                                     let uu___6 =
-                                       FStar_TypeChecker_Env.norm_eff_name
-                                         tcenv
-                                         (FStar_Syntax_Util.comp_effect_name
-                                            c1) in
-                                     FStar_Ident.lid_equals uu___6
-                                       FStar_Parser_Const.effect_TAC_lid in
-                                   if uu___5
-                                   then
-                                     let h =
-                                       mk_tactic_interpretation loc
-                                         non_tvar_arity in
-                                     let tac_fun =
-                                       let uu___6 =
-                                         let uu___7 =
-                                           let uu___8 =
-                                             mk_from_tactic loc
-                                               non_tvar_arity in
-                                           let uu___9 =
-                                             let uu___10 =
-                                               lid_to_name fv_lid1 in
-                                             [uu___10] in
-                                           (uu___8, uu___9) in
-                                         FStar_Extraction_ML_Syntax.MLE_App
-                                           uu___7 in
-                                       FStar_Compiler_Effect.op_Less_Bar w
-                                         uu___6 in
-                                     let psc = str_to_name "psc" in
-                                     let ncb = str_to_name "ncb" in
-                                     let all_args = str_to_name "args" in
-                                     let args =
-                                       FStar_Compiler_List.op_At [tac_fun]
-                                         (FStar_Compiler_List.op_At
-                                            arg_unembeddings
-                                            [res_embedding; psc; ncb]) in
-                                     let tabs =
-                                       match tvar_names with
-                                       | [] ->
-                                           let uu___6 =
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               w
-                                               (FStar_Extraction_ML_Syntax.MLE_App
-                                                  (h,
-                                                    (FStar_Compiler_List.op_At
-                                                       args [all_args]))) in
-                                           mk_lam "args" uu___6
-                                       | uu___6 ->
-                                           let uu___7 =
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               w
-                                               (FStar_Extraction_ML_Syntax.MLE_App
-                                                  (h, args)) in
-                                           abstract_tvars tvar_names uu___7 in
-                                     let uu___6 =
-                                       let uu___7 = mk_lam "ncb" tabs in
-                                       mk_lam "psc" uu___7 in
-                                     (uu___6, (arity + Prims.int_one), false)
-                                   else
-                                     (let uu___7 =
-                                        let uu___8 =
-                                          let uu___9 =
-                                            FStar_Syntax_Print.term_to_string
-                                              t1 in
-                                          Prims.op_Hat
-                                            "Plugins not defined for type "
-                                            uu___9 in
-                                        NoTacticEmbedding uu___8 in
-                                      FStar_Compiler_Effect.raise uu___7))
-                            | { FStar_Syntax_Syntax.binder_bv = b;
-                                FStar_Syntax_Syntax.binder_qual = uu___3;
-                                FStar_Syntax_Syntax.binder_attrs = uu___4;_}::bs4
-                                ->
-                                let uu___5 =
-                                  let uu___6 =
-                                    mk_embedding loc tvar_context
-                                      b.FStar_Syntax_Syntax.sort in
-                                  uu___6 :: accum_embeddings in
-                                aux loc uu___5 bs4 in
-                          (try
-                             (fun uu___3 ->
-                                match () with
-                                | () ->
-                                    let uu___4 = aux Syntax_term [] bs2 in
-                                    (match uu___4 with
-                                     | (w1, a, b) ->
-                                         let uu___5 = aux NBE_t [] bs2 in
-                                         (match uu___5 with
-                                          | (w', uu___6, uu___7) ->
-                                              FStar_Pervasives_Native.Some
-                                                (w1, w', a, b)))) ()
-                           with
-                           | NoTacticEmbedding msg ->
-                               ((let uu___5 =
-                                   FStar_Ident.range_of_lid
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                 let uu___6 =
-                                   FStar_Syntax_Print.fv_to_string fv in
-                                 not_implemented_warning uu___5 uu___6 msg);
-                                FStar_Pervasives_Native.None))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Ident.ml b/src/ocaml-output/FStar_Ident.ml
deleted file mode 100644
index 770d3c0e4eb..00000000000
--- a/src/ocaml-output/FStar_Ident.ml
+++ /dev/null
@@ -1,156 +0,0 @@
-open Prims
-type ident = {
-  idText: Prims.string ;
-  idRange: FStar_Compiler_Range.range }[@@deriving yojson,show,yojson,show]
-let (__proj__Mkident__item__idText : ident -> Prims.string) =
-  fun projectee -> match projectee with | { idText; idRange;_} -> idText
-let (__proj__Mkident__item__idRange : ident -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | { idText; idRange;_} -> idRange
-type path = Prims.string Prims.list[@@deriving yojson,show]
-type ipath = ident Prims.list[@@deriving yojson,show]
-type lident =
-  {
-  ns: ipath ;
-  ident: ident ;
-  nsstr: Prims.string ;
-  str: Prims.string }[@@deriving yojson,show,yojson,show]
-let (__proj__Mklident__item__ns : lident -> ipath) =
-  fun projectee ->
-    match projectee with | { ns; ident = ident1; nsstr; str;_} -> ns
-let (__proj__Mklident__item__ident : lident -> ident) =
-  fun projectee ->
-    match projectee with | { ns; ident = ident1; nsstr; str;_} -> ident1
-let (__proj__Mklident__item__nsstr : lident -> Prims.string) =
-  fun projectee ->
-    match projectee with | { ns; ident = ident1; nsstr; str;_} -> nsstr
-let (__proj__Mklident__item__str : lident -> Prims.string) =
-  fun projectee ->
-    match projectee with | { ns; ident = ident1; nsstr; str;_} -> str
-let (mk_ident : (Prims.string * FStar_Compiler_Range.range) -> ident) =
-  fun uu___ ->
-    match uu___ with | (text, range) -> { idText = text; idRange = range }
-let (set_id_range : FStar_Compiler_Range.range -> ident -> ident) =
-  fun r -> fun i -> { idText = (i.idText); idRange = r }
-let (reserved_prefix : Prims.string) = "uu___"
-let (uu___32 :
-  (((unit -> Prims.int) * (unit -> unit)) * Prims.int
-    FStar_Compiler_Effect.ref))
-  =
-  let x = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let next_id uu___ =
-    let v = FStar_Compiler_Effect.op_Bang x in
-    FStar_Compiler_Effect.op_Colon_Equals x (v + Prims.int_one); v in
-  let reset uu___ = FStar_Compiler_Effect.op_Colon_Equals x Prims.int_zero in
-  ((next_id, reset), x)
-let (_gen : ((unit -> Prims.int) * (unit -> unit))) =
-  match uu___32 with | (_gen1, _secret_ref) -> _gen1
-let (_secret_ref : Prims.int FStar_Compiler_Effect.ref) =
-  match uu___32 with | (_gen1, _secret_ref1) -> _secret_ref1
-let (next_id : unit -> Prims.int) =
-  fun uu___ -> FStar_Pervasives_Native.fst _gen ()
-let (reset_gensym : unit -> unit) =
-  fun uu___ -> FStar_Pervasives_Native.snd _gen ()
-let with_frozen_gensym : 'a . (unit -> 'a) -> 'a =
-  fun f ->
-    let v = FStar_Compiler_Effect.op_Bang _secret_ref in
-    let r =
-      try (fun uu___ -> match () with | () -> f ()) ()
-      with
-      | uu___ ->
-          (FStar_Compiler_Effect.op_Colon_Equals _secret_ref v;
-           FStar_Compiler_Effect.raise uu___) in
-    FStar_Compiler_Effect.op_Colon_Equals _secret_ref v; r
-let (gen' : Prims.string -> FStar_Compiler_Range.range -> ident) =
-  fun s ->
-    fun r ->
-      let i = next_id () in
-      mk_ident ((Prims.op_Hat s (Prims.string_of_int i)), r)
-let (gen : FStar_Compiler_Range.range -> ident) =
-  fun r -> gen' reserved_prefix r
-let (ident_of_lid : lident -> ident) = fun l -> l.ident
-let (range_of_id : ident -> FStar_Compiler_Range.range) =
-  fun id -> id.idRange
-let (id_of_text : Prims.string -> ident) =
-  fun str -> mk_ident (str, FStar_Compiler_Range.dummyRange)
-let (string_of_id : ident -> Prims.string) = fun id -> id.idText
-let (text_of_path : path -> Prims.string) =
-  fun path1 -> FStar_Compiler_Util.concat_l "." path1
-let (path_of_text : Prims.string -> path) =
-  fun text -> FStar_String.split [46] text
-let (path_of_ns : ipath -> path) =
-  fun ns -> FStar_Compiler_List.map string_of_id ns
-let (path_of_lid : lident -> path) =
-  fun lid ->
-    FStar_Compiler_List.map string_of_id
-      (FStar_Compiler_List.op_At lid.ns [lid.ident])
-let (ns_of_lid : lident -> ipath) = fun lid -> lid.ns
-let (ids_of_lid : lident -> ipath) =
-  fun lid -> FStar_Compiler_List.op_At lid.ns [lid.ident]
-let (lid_of_ns_and_id : ipath -> ident -> lident) =
-  fun ns ->
-    fun id ->
-      let nsstr =
-        let uu___ = FStar_Compiler_List.map string_of_id ns in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ text_of_path in
-      {
-        ns;
-        ident = id;
-        nsstr;
-        str =
-          (if nsstr = ""
-           then id.idText
-           else Prims.op_Hat nsstr (Prims.op_Hat "." id.idText))
-      }
-let (lid_of_ids : ipath -> lident) =
-  fun ids ->
-    let uu___ = FStar_Compiler_Util.prefix ids in
-    match uu___ with | (ns, id) -> lid_of_ns_and_id ns id
-let (lid_of_str : Prims.string -> lident) =
-  fun str ->
-    let uu___ =
-      FStar_Compiler_List.map id_of_text (FStar_Compiler_Util.split str ".") in
-    lid_of_ids uu___
-let (lid_of_path : path -> FStar_Compiler_Range.range -> lident) =
-  fun path1 ->
-    fun pos ->
-      let ids = FStar_Compiler_List.map (fun s -> mk_ident (s, pos)) path1 in
-      lid_of_ids ids
-let (text_of_lid : lident -> Prims.string) = fun lid -> lid.str
-let (lid_equals : lident -> lident -> Prims.bool) =
-  fun l1 -> fun l2 -> l1.str = l2.str
-let (ident_equals : ident -> ident -> Prims.bool) =
-  fun id1 -> fun id2 -> id1.idText = id2.idText
-type lid = lident[@@deriving yojson,show]
-let (range_of_lid : lident -> FStar_Compiler_Range.range) =
-  fun lid1 -> range_of_id lid1.ident
-let (set_lid_range : lident -> FStar_Compiler_Range.range -> lident) =
-  fun l ->
-    fun r ->
-      {
-        ns = (l.ns);
-        ident =
-          (let uu___ = l.ident in { idText = (uu___.idText); idRange = r });
-        nsstr = (l.nsstr);
-        str = (l.str)
-      }
-let (lid_add_suffix : lident -> Prims.string -> lident) =
-  fun l ->
-    fun s ->
-      let path1 = path_of_lid l in
-      let uu___ = range_of_lid l in
-      lid_of_path (FStar_Compiler_List.op_At path1 [s]) uu___
-let (ml_path_of_lid : lident -> Prims.string) =
-  fun lid1 ->
-    let uu___ =
-      let uu___1 = path_of_ns lid1.ns in
-      let uu___2 = let uu___3 = string_of_id lid1.ident in [uu___3] in
-      FStar_Compiler_List.op_At uu___1 uu___2 in
-    FStar_Compiler_Effect.op_Less_Bar (FStar_String.concat "_") uu___
-let (string_of_lid : lident -> Prims.string) = fun lid1 -> lid1.str
-let (qual_id : lident -> ident -> lident) =
-  fun lid1 ->
-    fun id ->
-      let uu___ =
-        lid_of_ids (FStar_Compiler_List.op_At lid1.ns [lid1.ident; id]) in
-      let uu___1 = range_of_id id in set_lid_range uu___ uu___1
-let (nsstr : lident -> Prims.string) = fun l -> l.nsstr
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_CompletionTable.ml b/src/ocaml-output/FStar_Interactive_CompletionTable.ml
deleted file mode 100644
index 180649c3b71..00000000000
--- a/src/ocaml-output/FStar_Interactive_CompletionTable.ml
+++ /dev/null
@@ -1,890 +0,0 @@
-open Prims
-let (string_compare : Prims.string -> Prims.string -> Prims.int) =
-  fun s1 -> fun s2 -> FStar_String.compare s1 s2
-type 'a heap =
-  | EmptyHeap 
-  | Heap of ('a * 'a heap Prims.list) 
-let uu___is_EmptyHeap : 'a . 'a heap -> Prims.bool =
-  fun projectee -> match projectee with | EmptyHeap -> true | uu___ -> false
-let uu___is_Heap : 'a . 'a heap -> Prims.bool =
-  fun projectee -> match projectee with | Heap _0 -> true | uu___ -> false
-let __proj__Heap__item___0 : 'a . 'a heap -> ('a * 'a heap Prims.list) =
-  fun projectee -> match projectee with | Heap _0 -> _0
-let heap_merge :
-  'uuuuu .
-    ('uuuuu -> 'uuuuu -> Prims.int) ->
-      'uuuuu heap -> 'uuuuu heap -> 'uuuuu heap
-  =
-  fun cmp ->
-    fun h1 ->
-      fun h2 ->
-        match (h1, h2) with
-        | (EmptyHeap, h) -> h
-        | (h, EmptyHeap) -> h
-        | (Heap (v1, hh1), Heap (v2, hh2)) ->
-            let uu___ = let uu___1 = cmp v1 v2 in uu___1 < Prims.int_zero in
-            if uu___ then Heap (v1, (h2 :: hh1)) else Heap (v2, (h1 :: hh2))
-let heap_insert :
-  'uuuuu .
-    ('uuuuu -> 'uuuuu -> Prims.int) -> 'uuuuu heap -> 'uuuuu -> 'uuuuu heap
-  = fun cmp -> fun h -> fun v -> heap_merge cmp (Heap (v, [])) h
-let rec heap_merge_pairs :
-  'uuuuu .
-    ('uuuuu -> 'uuuuu -> Prims.int) -> 'uuuuu heap Prims.list -> 'uuuuu heap
-  =
-  fun cmp ->
-    fun uu___ ->
-      match uu___ with
-      | [] -> EmptyHeap
-      | h::[] -> h
-      | h1::h2::hh ->
-          let uu___1 = heap_merge cmp h1 h2 in
-          let uu___2 = heap_merge_pairs cmp hh in
-          heap_merge cmp uu___1 uu___2
-let heap_peek : 'uuuuu . 'uuuuu heap -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun uu___ ->
-    match uu___ with
-    | EmptyHeap -> FStar_Pervasives_Native.None
-    | Heap (v, uu___1) -> FStar_Pervasives_Native.Some v
-let heap_pop :
-  'uuuuu .
-    ('uuuuu -> 'uuuuu -> Prims.int) ->
-      'uuuuu heap -> ('uuuuu * 'uuuuu heap) FStar_Pervasives_Native.option
-  =
-  fun cmp ->
-    fun uu___ ->
-      match uu___ with
-      | EmptyHeap -> FStar_Pervasives_Native.None
-      | Heap (v, hh) ->
-          let uu___1 = let uu___2 = heap_merge_pairs cmp hh in (v, uu___2) in
-          FStar_Pervasives_Native.Some uu___1
-let heap_from_list :
-  'uuuuu .
-    ('uuuuu -> 'uuuuu -> Prims.int) -> 'uuuuu Prims.list -> 'uuuuu heap
-  =
-  fun cmp ->
-    fun values ->
-      FStar_Compiler_List.fold_left (heap_insert cmp) EmptyHeap values
-let push_nodup :
-  'uuuuu .
-    ('uuuuu -> Prims.string) ->
-      'uuuuu -> 'uuuuu Prims.list -> 'uuuuu Prims.list
-  =
-  fun key_fn ->
-    fun x ->
-      fun uu___ ->
-        match uu___ with
-        | [] -> [x]
-        | h::t ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = key_fn x in
-                let uu___4 = key_fn h in string_compare uu___3 uu___4 in
-              uu___2 = Prims.int_zero in
-            if uu___1 then h :: t else x :: h :: t
-let rec add_priorities :
-  'uuuuu .
-    Prims.int ->
-      (Prims.int * 'uuuuu) Prims.list ->
-        'uuuuu Prims.list -> (Prims.int * 'uuuuu) Prims.list
-  =
-  fun n ->
-    fun acc ->
-      fun uu___ ->
-        match uu___ with
-        | [] -> acc
-        | h::t -> add_priorities (n + Prims.int_one) ((n, h) :: acc) t
-let merge_increasing_lists_rev :
-  'a . ('a -> Prims.string) -> 'a Prims.list Prims.list -> 'a Prims.list =
-  fun key_fn ->
-    fun lists ->
-      let cmp v1 v2 =
-        match (v1, v2) with
-        | ((uu___, []), uu___1) -> failwith "impossible"
-        | (uu___, (uu___1, [])) -> failwith "impossible"
-        | ((pr1, h1::uu___), (pr2, h2::uu___1)) ->
-            let cmp_h =
-              let uu___2 = key_fn h1 in
-              let uu___3 = key_fn h2 in string_compare uu___2 uu___3 in
-            if cmp_h <> Prims.int_zero then cmp_h else pr1 - pr2 in
-      let rec aux lists1 acc =
-        let uu___ = heap_pop cmp lists1 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> acc
-        | FStar_Pervasives_Native.Some ((pr, []), uu___1) ->
-            failwith "impossible"
-        | FStar_Pervasives_Native.Some ((pr, v::[]), lists2) ->
-            let uu___1 = push_nodup key_fn v acc in aux lists2 uu___1
-        | FStar_Pervasives_Native.Some ((pr, v::tl), lists2) ->
-            let uu___1 = heap_insert cmp lists2 (pr, tl) in
-            let uu___2 = push_nodup key_fn v acc in aux uu___1 uu___2 in
-      let lists1 = FStar_Compiler_List.filter (fun x -> x <> []) lists in
-      match lists1 with
-      | [] -> []
-      | l::[] -> FStar_Compiler_List.rev l
-      | uu___ ->
-          let lists2 = add_priorities Prims.int_zero [] lists1 in
-          let uu___1 = heap_from_list cmp lists2 in aux uu___1 []
-type 'a btree =
-  | StrEmpty 
-  | StrBranch of (Prims.string * 'a * 'a btree * 'a btree) 
-let uu___is_StrEmpty : 'a . 'a btree -> Prims.bool =
-  fun projectee -> match projectee with | StrEmpty -> true | uu___ -> false
-let uu___is_StrBranch : 'a . 'a btree -> Prims.bool =
-  fun projectee ->
-    match projectee with | StrBranch _0 -> true | uu___ -> false
-let __proj__StrBranch__item___0 :
-  'a . 'a btree -> (Prims.string * 'a * 'a btree * 'a btree) =
-  fun projectee -> match projectee with | StrBranch _0 -> _0
-let rec btree_to_list_rev :
-  'a .
-    'a btree ->
-      (Prims.string * 'a) Prims.list -> (Prims.string * 'a) Prims.list
-  =
-  fun btree1 ->
-    fun acc ->
-      match btree1 with
-      | StrEmpty -> acc
-      | StrBranch (key, value, lbt, rbt) ->
-          let uu___ =
-            let uu___1 = btree_to_list_rev lbt acc in (key, value) :: uu___1 in
-          btree_to_list_rev rbt uu___
-let rec btree_from_list :
-  'a .
-    (Prims.string * 'a) Prims.list ->
-      Prims.int -> ('a btree * (Prims.string * 'a) Prims.list)
-  =
-  fun nodes ->
-    fun size ->
-      if size = Prims.int_zero
-      then (StrEmpty, nodes)
-      else
-        (let lbt_size = size / (Prims.of_int (2)) in
-         let rbt_size = (size - lbt_size) - Prims.int_one in
-         let uu___1 = btree_from_list nodes lbt_size in
-         match uu___1 with
-         | (lbt, nodes_left) ->
-             (match nodes_left with
-              | [] -> failwith "Invalid size passed to btree_from_list"
-              | (k, v)::nodes_left1 ->
-                  let uu___2 = btree_from_list nodes_left1 rbt_size in
-                  (match uu___2 with
-                   | (rbt, nodes_left2) ->
-                       ((StrBranch (k, v, lbt, rbt)), nodes_left2))))
-let rec btree_insert_replace :
-  'a . 'a btree -> Prims.string -> 'a -> 'a btree =
-  fun bt ->
-    fun k ->
-      fun v ->
-        match bt with
-        | StrEmpty -> StrBranch (k, v, StrEmpty, StrEmpty)
-        | StrBranch (k', v', lbt, rbt) ->
-            let cmp = string_compare k k' in
-            if cmp < Prims.int_zero
-            then
-              let uu___ =
-                let uu___1 = btree_insert_replace lbt k v in
-                (k', v', uu___1, rbt) in
-              StrBranch uu___
-            else
-              if cmp > Prims.int_zero
-              then
-                (let uu___1 =
-                   let uu___2 = btree_insert_replace rbt k v in
-                   (k', v', lbt, uu___2) in
-                 StrBranch uu___1)
-              else StrBranch (k', v, lbt, rbt)
-let rec btree_find_exact :
-  'a . 'a btree -> Prims.string -> 'a FStar_Pervasives_Native.option =
-  fun bt ->
-    fun k ->
-      match bt with
-      | StrEmpty -> FStar_Pervasives_Native.None
-      | StrBranch (k', v, lbt, rbt) ->
-          let cmp = string_compare k k' in
-          if cmp < Prims.int_zero
-          then btree_find_exact lbt k
-          else
-            if cmp > Prims.int_zero
-            then btree_find_exact rbt k
-            else FStar_Pervasives_Native.Some v
-let rec btree_extract_min :
-  'a .
-    'a btree -> (Prims.string * 'a * 'a btree) FStar_Pervasives_Native.option
-  =
-  fun bt ->
-    match bt with
-    | StrEmpty -> FStar_Pervasives_Native.None
-    | StrBranch (k, v, StrEmpty, rbt) ->
-        FStar_Pervasives_Native.Some (k, v, rbt)
-    | StrBranch (uu___, uu___1, lbt, uu___2) -> btree_extract_min lbt
-let rec btree_remove : 'a . 'a btree -> Prims.string -> 'a btree =
-  fun bt ->
-    fun k ->
-      match bt with
-      | StrEmpty -> StrEmpty
-      | StrBranch (k', v, lbt, rbt) ->
-          let cmp = string_compare k k' in
-          if cmp < Prims.int_zero
-          then
-            let uu___ =
-              let uu___1 = btree_remove lbt k in (k', v, uu___1, rbt) in
-            StrBranch uu___
-          else
-            if cmp > Prims.int_zero
-            then
-              (let uu___1 =
-                 let uu___2 = btree_remove rbt k in (k', v, lbt, uu___2) in
-               StrBranch uu___1)
-            else
-              (match lbt with
-               | StrEmpty -> bt
-               | uu___2 ->
-                   let uu___3 = btree_extract_min rbt in
-                   (match uu___3 with
-                    | FStar_Pervasives_Native.None -> lbt
-                    | FStar_Pervasives_Native.Some
-                        (rbt_min_k, rbt_min_v, rbt') ->
-                        StrBranch (rbt_min_k, rbt_min_v, lbt, rbt')))
-type prefix_match =
-  {
-  prefix: Prims.string FStar_Pervasives_Native.option ;
-  completion: Prims.string }
-let (__proj__Mkprefix_match__item__prefix :
-  prefix_match -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | { prefix; completion;_} -> prefix
-let (__proj__Mkprefix_match__item__completion : prefix_match -> Prims.string)
-  =
-  fun projectee ->
-    match projectee with | { prefix; completion;_} -> completion
-type path_elem = {
-  imports: Prims.string Prims.list ;
-  segment: prefix_match }
-let (__proj__Mkpath_elem__item__imports :
-  path_elem -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | { imports; segment;_} -> imports
-let (__proj__Mkpath_elem__item__segment : path_elem -> prefix_match) =
-  fun projectee -> match projectee with | { imports; segment;_} -> segment
-type path = path_elem Prims.list
-let (matched_prefix_of_path_elem :
-  path_elem -> Prims.string FStar_Pervasives_Native.option) =
-  fun elem -> (elem.segment).prefix
-type query = Prims.string Prims.list
-type ns_info = {
-  ns_name: Prims.string ;
-  ns_loaded: Prims.bool }
-let (__proj__Mkns_info__item__ns_name : ns_info -> Prims.string) =
-  fun projectee -> match projectee with | { ns_name; ns_loaded;_} -> ns_name
-let (__proj__Mkns_info__item__ns_loaded : ns_info -> Prims.bool) =
-  fun projectee ->
-    match projectee with | { ns_name; ns_loaded;_} -> ns_loaded
-type mod_info =
-  {
-  mod_name: Prims.string ;
-  mod_path: Prims.string ;
-  mod_loaded: Prims.bool }
-let (__proj__Mkmod_info__item__mod_name : mod_info -> Prims.string) =
-  fun projectee ->
-    match projectee with | { mod_name; mod_path; mod_loaded;_} -> mod_name
-let (__proj__Mkmod_info__item__mod_path : mod_info -> Prims.string) =
-  fun projectee ->
-    match projectee with | { mod_name; mod_path; mod_loaded;_} -> mod_path
-let (__proj__Mkmod_info__item__mod_loaded : mod_info -> Prims.bool) =
-  fun projectee ->
-    match projectee with | { mod_name; mod_path; mod_loaded;_} -> mod_loaded
-let (mk_path_el : Prims.string Prims.list -> prefix_match -> path_elem) =
-  fun imports -> fun segment -> { imports; segment }
-let btree_find_prefix :
-  'a . 'a btree -> Prims.string -> (prefix_match * 'a) Prims.list =
-  fun bt ->
-    fun prefix ->
-      let rec aux bt1 prefix1 acc =
-        match bt1 with
-        | StrEmpty -> acc
-        | StrBranch (k, v, lbt, rbt) ->
-            let cmp = string_compare k prefix1 in
-            let include_middle = FStar_Compiler_Util.starts_with k prefix1 in
-            let explore_right = (cmp <= Prims.int_zero) || include_middle in
-            let explore_left = cmp > Prims.int_zero in
-            let matches = if explore_right then aux rbt prefix1 acc else acc in
-            let matches1 =
-              if include_middle
-              then
-                ({
-                   prefix = (FStar_Pervasives_Native.Some prefix1);
-                   completion = k
-                 }, v)
-                :: matches
-              else matches in
-            let matches2 =
-              if explore_left then aux lbt prefix1 matches1 else matches1 in
-            matches2 in
-      aux bt prefix []
-let rec btree_fold :
-  'a 'b . 'a btree -> (Prims.string -> 'a -> 'b -> 'b) -> 'b -> 'b =
-  fun bt ->
-    fun f ->
-      fun acc ->
-        match bt with
-        | StrEmpty -> acc
-        | StrBranch (k, v, lbt, rbt) ->
-            let uu___ = let uu___1 = btree_fold rbt f acc in f k v uu___1 in
-            btree_fold lbt f uu___
-let (query_to_string : Prims.string Prims.list -> Prims.string) =
-  fun q -> FStar_String.concat "." q
-type 'a name_collection =
-  | Names of 'a btree 
-  | ImportedNames of (Prims.string * 'a name_collection Prims.list) 
-let uu___is_Names : 'a . 'a name_collection -> Prims.bool =
-  fun projectee -> match projectee with | Names _0 -> true | uu___ -> false
-let __proj__Names__item___0 : 'a . 'a name_collection -> 'a btree =
-  fun projectee -> match projectee with | Names _0 -> _0
-let uu___is_ImportedNames : 'a . 'a name_collection -> Prims.bool =
-  fun projectee ->
-    match projectee with | ImportedNames _0 -> true | uu___ -> false
-let __proj__ImportedNames__item___0 :
-  'a . 'a name_collection -> (Prims.string * 'a name_collection Prims.list) =
-  fun projectee -> match projectee with | ImportedNames _0 -> _0
-type 'a names = 'a name_collection Prims.list
-type 'a trie = {
-  bindings: 'a names ;
-  namespaces: 'a trie names }
-let __proj__Mktrie__item__bindings : 'a . 'a trie -> 'a names =
-  fun projectee ->
-    match projectee with | { bindings; namespaces;_} -> bindings
-let __proj__Mktrie__item__namespaces : 'a . 'a trie -> 'a trie names =
-  fun projectee ->
-    match projectee with | { bindings; namespaces;_} -> namespaces
-let trie_empty : 'uuuuu . unit -> 'uuuuu trie =
-  fun uu___ -> { bindings = []; namespaces = [] }
-let rec names_find_exact :
-  'a . 'a names -> Prims.string -> 'a FStar_Pervasives_Native.option =
-  fun names1 ->
-    fun ns ->
-      let uu___ =
-        match names1 with
-        | [] -> (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None)
-        | (Names bt)::names2 ->
-            let uu___1 = btree_find_exact bt ns in
-            (uu___1, (FStar_Pervasives_Native.Some names2))
-        | (ImportedNames (uu___1, names2))::more_names ->
-            let uu___2 = names_find_exact names2 ns in
-            (uu___2, (FStar_Pervasives_Native.Some more_names)) in
-      match uu___ with
-      | (result, names2) ->
-          (match (result, names2) with
-           | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some
-              scopes) -> names_find_exact scopes ns
-           | uu___1 -> result)
-let rec trie_descend_exact :
-  'a . 'a trie -> query -> 'a trie FStar_Pervasives_Native.option =
-  fun tr ->
-    fun query1 ->
-      match query1 with
-      | [] -> FStar_Pervasives_Native.Some tr
-      | ns::query2 ->
-          let uu___ = names_find_exact tr.namespaces ns in
-          FStar_Compiler_Util.bind_opt uu___
-            (fun scope -> trie_descend_exact scope query2)
-let rec trie_find_exact :
-  'a . 'a trie -> query -> 'a FStar_Pervasives_Native.option =
-  fun tr ->
-    fun query1 ->
-      match query1 with
-      | [] -> failwith "Empty query in trie_find_exact"
-      | name::[] -> names_find_exact tr.bindings name
-      | ns::query2 ->
-          let uu___ = names_find_exact tr.namespaces ns in
-          FStar_Compiler_Util.bind_opt uu___
-            (fun scope -> trie_find_exact scope query2)
-let names_insert : 'a . 'a names -> Prims.string -> 'a -> 'a names =
-  fun name_collections ->
-    fun id ->
-      fun v ->
-        let uu___ =
-          match name_collections with
-          | (Names bt)::tl -> (bt, tl)
-          | uu___1 -> (StrEmpty, name_collections) in
-        match uu___ with
-        | (bt, name_collections1) ->
-            let uu___1 =
-              let uu___2 = btree_insert_replace bt id v in Names uu___2 in
-            uu___1 :: name_collections1
-let rec namespaces_mutate :
-  'a .
-    'a trie names ->
-      Prims.string ->
-        query ->
-          query ->
-            ('a trie ->
-               Prims.string -> query -> query -> 'a trie names -> 'a trie)
-              -> ('a trie -> query -> 'a trie) -> 'a trie names
-  =
-  fun namespaces ->
-    fun ns ->
-      fun q ->
-        fun rev_acc ->
-          fun mut_node ->
-            fun mut_leaf ->
-              let trie1 =
-                let uu___ = names_find_exact namespaces ns in
-                FStar_Compiler_Util.dflt (trie_empty ()) uu___ in
-              let uu___ = trie_mutate trie1 q rev_acc mut_node mut_leaf in
-              names_insert namespaces ns uu___
-and trie_mutate :
-  'a .
-    'a trie ->
-      query ->
-        query ->
-          ('a trie ->
-             Prims.string -> query -> query -> 'a trie names -> 'a trie)
-            -> ('a trie -> query -> 'a trie) -> 'a trie
-  =
-  fun tr ->
-    fun q ->
-      fun rev_acc ->
-        fun mut_node ->
-          fun mut_leaf ->
-            match q with
-            | [] -> mut_leaf tr rev_acc
-            | id::q1 ->
-                let ns' =
-                  namespaces_mutate tr.namespaces id q1 (id :: rev_acc)
-                    mut_node mut_leaf in
-                mut_node tr id q1 rev_acc ns'
-let trie_mutate_leaf :
-  'a . 'a trie -> query -> ('a trie -> query -> 'a trie) -> 'a trie =
-  fun tr ->
-    fun query1 ->
-      trie_mutate tr query1 []
-        (fun tr1 ->
-           fun uu___ ->
-             fun uu___1 ->
-               fun uu___2 ->
-                 fun namespaces -> { bindings = (tr1.bindings); namespaces })
-let trie_insert : 'a . 'a trie -> query -> Prims.string -> 'a -> 'a trie =
-  fun tr ->
-    fun ns_query ->
-      fun id ->
-        fun v ->
-          trie_mutate_leaf tr ns_query
-            (fun tr1 ->
-               fun uu___ ->
-                 let uu___1 = names_insert tr1.bindings id v in
-                 { bindings = uu___1; namespaces = (tr1.namespaces) })
-let trie_import :
-  'a .
-    'a trie ->
-      query ->
-        query -> ('a trie -> 'a trie -> Prims.string -> 'a trie) -> 'a trie
-  =
-  fun tr ->
-    fun host_query ->
-      fun included_query ->
-        fun mutator ->
-          let label = query_to_string included_query in
-          let included_trie =
-            let uu___ = trie_descend_exact tr included_query in
-            FStar_Compiler_Util.dflt (trie_empty ()) uu___ in
-          trie_mutate_leaf tr host_query
-            (fun tr1 -> fun uu___ -> mutator tr1 included_trie label)
-let trie_include : 'a . 'a trie -> query -> query -> 'a trie =
-  fun tr ->
-    fun host_query ->
-      fun included_query ->
-        trie_import tr host_query included_query
-          (fun tr1 ->
-             fun inc ->
-               fun label ->
-                 {
-                   bindings = ((ImportedNames (label, (inc.bindings))) ::
-                     (tr1.bindings));
-                   namespaces = (tr1.namespaces)
-                 })
-let trie_open_namespace : 'a . 'a trie -> query -> query -> 'a trie =
-  fun tr ->
-    fun host_query ->
-      fun included_query ->
-        trie_import tr host_query included_query
-          (fun tr1 ->
-             fun inc ->
-               fun label ->
-                 {
-                   bindings = (tr1.bindings);
-                   namespaces = ((ImportedNames (label, (inc.namespaces))) ::
-                     (tr1.namespaces))
-                 })
-let trie_add_alias :
-  'a . 'a trie -> Prims.string -> query -> query -> 'a trie =
-  fun tr ->
-    fun key ->
-      fun host_query ->
-        fun included_query ->
-          trie_import tr host_query included_query
-            (fun tr1 ->
-               fun inc ->
-                 fun label ->
-                   trie_mutate_leaf tr1 [key]
-                     (fun _ignored_overwritten_trie ->
-                        fun uu___ ->
-                          {
-                            bindings =
-                              [ImportedNames (label, (inc.bindings))];
-                            namespaces = []
-                          }))
-let names_revmap :
-  'a 'b .
-    ('a btree -> 'b) -> 'a names -> (Prims.string Prims.list * 'b) Prims.list
-  =
-  fun fn ->
-    fun name_collections ->
-      let rec aux acc imports name_collections1 =
-        FStar_Compiler_List.fold_left
-          (fun acc1 ->
-             fun uu___ ->
-               match uu___ with
-               | Names bt ->
-                   let uu___1 = let uu___2 = fn bt in (imports, uu___2) in
-                   uu___1 :: acc1
-               | ImportedNames (nm, name_collections2) ->
-                   aux acc1 (nm :: imports) name_collections2) acc
-          name_collections1 in
-      aux [] [] name_collections
-let btree_find_all :
-  'a .
-    Prims.string FStar_Pervasives_Native.option ->
-      'a btree -> (prefix_match * 'a) Prims.list
-  =
-  fun prefix ->
-    fun bt ->
-      btree_fold bt
-        (fun k ->
-           fun tr -> fun acc -> ({ prefix; completion = k }, tr) :: acc) []
-type name_search_term =
-  | NSTAll 
-  | NSTNone 
-  | NSTPrefix of Prims.string 
-let (uu___is_NSTAll : name_search_term -> Prims.bool) =
-  fun projectee -> match projectee with | NSTAll -> true | uu___ -> false
-let (uu___is_NSTNone : name_search_term -> Prims.bool) =
-  fun projectee -> match projectee with | NSTNone -> true | uu___ -> false
-let (uu___is_NSTPrefix : name_search_term -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NSTPrefix _0 -> true | uu___ -> false
-let (__proj__NSTPrefix__item___0 : name_search_term -> Prims.string) =
-  fun projectee -> match projectee with | NSTPrefix _0 -> _0
-let names_find_rev :
-  'a . 'a names -> name_search_term -> (path_elem * 'a) Prims.list =
-  fun names1 ->
-    fun id ->
-      let matching_values_per_collection_with_imports =
-        match id with
-        | NSTNone -> []
-        | NSTAll ->
-            names_revmap (btree_find_all FStar_Pervasives_Native.None) names1
-        | NSTPrefix "" ->
-            names_revmap (btree_find_all (FStar_Pervasives_Native.Some ""))
-              names1
-        | NSTPrefix id1 ->
-            names_revmap (fun bt -> btree_find_prefix bt id1) names1 in
-      let matching_values_per_collection =
-        FStar_Compiler_List.map
-          (fun uu___ ->
-             match uu___ with
-             | (imports, matches) ->
-                 FStar_Compiler_List.map
-                   (fun uu___1 ->
-                      match uu___1 with
-                      | (segment, v) -> ((mk_path_el imports segment), v))
-                   matches) matching_values_per_collection_with_imports in
-      merge_increasing_lists_rev
-        (fun uu___ ->
-           match uu___ with
-           | (path_el, uu___1) -> (path_el.segment).completion)
-        matching_values_per_collection
-let rec trie_find_prefix' :
-  'a .
-    'a trie ->
-      path -> query -> (path * 'a) Prims.list -> (path * 'a) Prims.list
-  =
-  fun tr ->
-    fun path_acc ->
-      fun query1 ->
-        fun acc ->
-          let uu___ =
-            match query1 with
-            | [] -> (NSTAll, NSTAll, [])
-            | id::[] -> ((NSTPrefix id), (NSTPrefix id), [])
-            | ns::query2 -> ((NSTPrefix ns), NSTNone, query2) in
-          match uu___ with
-          | (ns_search_term, bindings_search_term, query2) ->
-              let matching_namespaces_rev =
-                names_find_rev tr.namespaces ns_search_term in
-              let acc_with_recursive_bindings =
-                FStar_Compiler_List.fold_left
-                  (fun acc1 ->
-                     fun uu___1 ->
-                       match uu___1 with
-                       | (path_el, trie1) ->
-                           trie_find_prefix' trie1 (path_el :: path_acc)
-                             query2 acc1) acc matching_namespaces_rev in
-              let matching_bindings_rev =
-                names_find_rev tr.bindings bindings_search_term in
-              FStar_Compiler_List.rev_map_onto
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (path_el, v) ->
-                       ((FStar_Compiler_List.rev (path_el :: path_acc)), v))
-                matching_bindings_rev acc_with_recursive_bindings
-let trie_find_prefix : 'a . 'a trie -> query -> (path * 'a) Prims.list =
-  fun tr -> fun query1 -> trie_find_prefix' tr [] query1 []
-let (mod_name : mod_info -> Prims.string) = fun md -> md.mod_name
-type mod_symbol =
-  | Module of mod_info 
-  | Namespace of ns_info 
-let (uu___is_Module : mod_symbol -> Prims.bool) =
-  fun projectee -> match projectee with | Module _0 -> true | uu___ -> false
-let (__proj__Module__item___0 : mod_symbol -> mod_info) =
-  fun projectee -> match projectee with | Module _0 -> _0
-let (uu___is_Namespace : mod_symbol -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Namespace _0 -> true | uu___ -> false
-let (__proj__Namespace__item___0 : mod_symbol -> ns_info) =
-  fun projectee -> match projectee with | Namespace _0 -> _0
-type lid_symbol = FStar_Ident.lid
-type symbol =
-  | ModOrNs of mod_symbol 
-  | Lid of lid_symbol 
-let (uu___is_ModOrNs : symbol -> Prims.bool) =
-  fun projectee -> match projectee with | ModOrNs _0 -> true | uu___ -> false
-let (__proj__ModOrNs__item___0 : symbol -> mod_symbol) =
-  fun projectee -> match projectee with | ModOrNs _0 -> _0
-let (uu___is_Lid : symbol -> Prims.bool) =
-  fun projectee -> match projectee with | Lid _0 -> true | uu___ -> false
-let (__proj__Lid__item___0 : symbol -> lid_symbol) =
-  fun projectee -> match projectee with | Lid _0 -> _0
-type table = {
-  tbl_lids: lid_symbol trie ;
-  tbl_mods: mod_symbol trie }
-let (__proj__Mktable__item__tbl_lids : table -> lid_symbol trie) =
-  fun projectee -> match projectee with | { tbl_lids; tbl_mods;_} -> tbl_lids
-let (__proj__Mktable__item__tbl_mods : table -> mod_symbol trie) =
-  fun projectee -> match projectee with | { tbl_lids; tbl_mods;_} -> tbl_mods
-let (empty : table) =
-  { tbl_lids = (trie_empty ()); tbl_mods = (trie_empty ()) }
-let (insert : table -> query -> Prims.string -> lid_symbol -> table) =
-  fun tbl ->
-    fun host_query ->
-      fun id ->
-        fun c ->
-          let uu___ = trie_insert tbl.tbl_lids host_query id c in
-          { tbl_lids = uu___; tbl_mods = (tbl.tbl_mods) }
-let (register_alias : table -> Prims.string -> query -> query -> table) =
-  fun tbl ->
-    fun key ->
-      fun host_query ->
-        fun included_query ->
-          let uu___ =
-            trie_add_alias tbl.tbl_lids key host_query included_query in
-          { tbl_lids = uu___; tbl_mods = (tbl.tbl_mods) }
-let (register_include : table -> query -> query -> table) =
-  fun tbl ->
-    fun host_query ->
-      fun included_query ->
-        let uu___ = trie_include tbl.tbl_lids host_query included_query in
-        { tbl_lids = uu___; tbl_mods = (tbl.tbl_mods) }
-let (register_open : table -> Prims.bool -> query -> query -> table) =
-  fun tbl ->
-    fun is_module ->
-      fun host_query ->
-        fun included_query ->
-          if is_module
-          then register_include tbl host_query included_query
-          else
-            (let uu___1 =
-               trie_open_namespace tbl.tbl_lids host_query included_query in
-             { tbl_lids = uu___1; tbl_mods = (tbl.tbl_mods) })
-let (register_module_path :
-  table -> Prims.bool -> Prims.string -> query -> table) =
-  fun tbl ->
-    fun loaded ->
-      fun path1 ->
-        fun mod_query ->
-          let ins_ns id bindings full_name loaded1 =
-            let uu___ =
-              let uu___1 = names_find_exact bindings id in (uu___1, loaded1) in
-            match uu___ with
-            | (FStar_Pervasives_Native.None, uu___1) ->
-                names_insert bindings id
-                  (Namespace { ns_name = full_name; ns_loaded = loaded1 })
-            | (FStar_Pervasives_Native.Some (Namespace
-               { ns_name = uu___1; ns_loaded = false;_}), true) ->
-                names_insert bindings id
-                  (Namespace { ns_name = full_name; ns_loaded = loaded1 })
-            | (FStar_Pervasives_Native.Some uu___1, uu___2) -> bindings in
-          let ins_mod id bindings full_name loaded1 =
-            names_insert bindings id
-              (Module
-                 {
-                   mod_name = full_name;
-                   mod_path = path1;
-                   mod_loaded = loaded1
-                 }) in
-          let name_of_revq query1 =
-            FStar_String.concat "." (FStar_Compiler_List.rev query1) in
-          let ins id q revq bindings loaded1 =
-            let name = name_of_revq (id :: revq) in
-            match q with
-            | [] -> ins_mod id bindings name loaded1
-            | uu___ -> ins_ns id bindings name loaded1 in
-          let uu___ =
-            trie_mutate tbl.tbl_mods mod_query []
-              (fun tr ->
-                 fun id ->
-                   fun q ->
-                     fun revq ->
-                       fun namespaces ->
-                         let uu___1 = ins id q revq tr.bindings loaded in
-                         { bindings = uu___1; namespaces })
-              (fun tr -> fun uu___1 -> tr) in
-          { tbl_lids = (tbl.tbl_lids); tbl_mods = uu___ }
-let (string_of_path : path -> Prims.string) =
-  fun path1 ->
-    let uu___ =
-      FStar_Compiler_List.map (fun el -> (el.segment).completion) path1 in
-    FStar_String.concat "." uu___
-let (match_length_of_path : path -> Prims.int) =
-  fun path1 ->
-    let uu___ =
-      FStar_Compiler_List.fold_left
-        (fun acc ->
-           fun elem ->
-             let uu___1 = acc in
-             match uu___1 with
-             | (acc_len, uu___2) ->
-                 (match (elem.segment).prefix with
-                  | FStar_Pervasives_Native.Some prefix ->
-                      let completion_len =
-                        FStar_String.length (elem.segment).completion in
-                      (((acc_len + Prims.int_one) + completion_len),
-                        (prefix, completion_len))
-                  | FStar_Pervasives_Native.None -> acc))
-        (Prims.int_zero, ("", Prims.int_zero)) path1 in
-    match uu___ with
-    | (length, (last_prefix, last_completion_length)) ->
-        ((length - Prims.int_one) - last_completion_length) +
-          (FStar_String.length last_prefix)
-let (first_import_of_path :
-  path -> Prims.string FStar_Pervasives_Native.option) =
-  fun path1 ->
-    match path1 with
-    | [] -> FStar_Pervasives_Native.None
-    | { imports; segment = uu___;_}::uu___1 ->
-        FStar_Compiler_List.last_opt imports
-let (alist_of_ns_info :
-  ns_info -> (Prims.string * FStar_Compiler_Util.json) Prims.list) =
-  fun ns_info1 ->
-    [("name", (FStar_Compiler_Util.JsonStr (ns_info1.ns_name)));
-    ("loaded", (FStar_Compiler_Util.JsonBool (ns_info1.ns_loaded)))]
-let (alist_of_mod_info :
-  mod_info -> (Prims.string * FStar_Compiler_Util.json) Prims.list) =
-  fun mod_info1 ->
-    [("name", (FStar_Compiler_Util.JsonStr (mod_info1.mod_name)));
-    ("path", (FStar_Compiler_Util.JsonStr (mod_info1.mod_path)));
-    ("loaded", (FStar_Compiler_Util.JsonBool (mod_info1.mod_loaded)))]
-type completion_result =
-  {
-  completion_match_length: Prims.int ;
-  completion_candidate: Prims.string ;
-  completion_annotation: Prims.string }
-let (__proj__Mkcompletion_result__item__completion_match_length :
-  completion_result -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { completion_match_length; completion_candidate;
-        completion_annotation;_} -> completion_match_length
-let (__proj__Mkcompletion_result__item__completion_candidate :
-  completion_result -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { completion_match_length; completion_candidate;
-        completion_annotation;_} -> completion_candidate
-let (__proj__Mkcompletion_result__item__completion_annotation :
-  completion_result -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { completion_match_length; completion_candidate;
-        completion_annotation;_} -> completion_annotation
-let (json_of_completion_result :
-  completion_result -> FStar_Compiler_Util.json) =
-  fun result ->
-    FStar_Compiler_Util.JsonList
-      [FStar_Compiler_Util.JsonInt (result.completion_match_length);
-      FStar_Compiler_Util.JsonStr (result.completion_annotation);
-      FStar_Compiler_Util.JsonStr (result.completion_candidate)]
-let completion_result_of_lid : 'uuuuu . (path * 'uuuuu) -> completion_result
-  =
-  fun uu___ ->
-    match uu___ with
-    | (path1, _lid) ->
-        let uu___1 = match_length_of_path path1 in
-        let uu___2 = string_of_path path1 in
-        let uu___3 =
-          let uu___4 = first_import_of_path path1 in
-          FStar_Compiler_Util.dflt "" uu___4 in
-        {
-          completion_match_length = uu___1;
-          completion_candidate = uu___2;
-          completion_annotation = uu___3
-        }
-let (completion_result_of_mod :
-  Prims.string -> Prims.bool -> path -> completion_result) =
-  fun annot ->
-    fun loaded ->
-      fun path1 ->
-        let uu___ = match_length_of_path path1 in
-        let uu___1 = string_of_path path1 in
-        let uu___2 =
-          FStar_Compiler_Util.format1 (if loaded then " %s " else "(%s)")
-            annot in
-        {
-          completion_match_length = uu___;
-          completion_candidate = uu___1;
-          completion_annotation = uu___2
-        }
-let (completion_result_of_ns_or_mod :
-  (path * mod_symbol) -> completion_result) =
-  fun uu___ ->
-    match uu___ with
-    | (path1, symb) ->
-        (match symb with
-         | Module
-             { mod_name = uu___1; mod_path = uu___2; mod_loaded = loaded;_}
-             -> completion_result_of_mod "mod" loaded path1
-         | Namespace { ns_name = uu___1; ns_loaded = loaded;_} ->
-             completion_result_of_mod "ns" loaded path1)
-let (find_module_or_ns :
-  table -> query -> mod_symbol FStar_Pervasives_Native.option) =
-  fun tbl -> fun query1 -> trie_find_exact tbl.tbl_mods query1
-let (autocomplete_lid : table -> query -> completion_result Prims.list) =
-  fun tbl ->
-    fun query1 ->
-      let uu___ = trie_find_prefix tbl.tbl_lids query1 in
-      FStar_Compiler_List.map completion_result_of_lid uu___
-let (autocomplete_mod_or_ns :
-  table ->
-    query ->
-      ((path * mod_symbol) ->
-         (path * mod_symbol) FStar_Pervasives_Native.option)
-        -> completion_result Prims.list)
-  =
-  fun tbl ->
-    fun query1 ->
-      fun filter ->
-        let uu___ =
-          let uu___1 = trie_find_prefix tbl.tbl_mods query1 in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_Compiler_List.filter_map filter) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (FStar_Compiler_List.map completion_result_of_ns_or_mod)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_Ide.ml b/src/ocaml-output/FStar_Interactive_Ide.ml
deleted file mode 100644
index 8ec462707a2..00000000000
--- a/src/ocaml-output/FStar_Interactive_Ide.ml
+++ /dev/null
@@ -1,2688 +0,0 @@
-open Prims
-let with_captured_errors' :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      FStar_Compiler_Util.sigint_handler ->
-        (FStar_TypeChecker_Env.env -> 'uuuuu FStar_Pervasives_Native.option)
-          -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun env ->
-    fun sigint_handler ->
-      fun f ->
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 FStar_Compiler_Util.with_sigint_handler sigint_handler
-                   (fun uu___1 -> f env)) ()
-        with
-        | FStar_Compiler_Effect.Failure msg ->
-            let msg1 =
-              Prims.op_Hat "ASSERTION FAILURE: "
-                (Prims.op_Hat msg
-                   (Prims.op_Hat "\n"
-                      (Prims.op_Hat "F* may be in an inconsistent state.\n"
-                         (Prims.op_Hat
-                            "Please file a bug report, ideally with a "
-                            "minimized version of the program that triggered the error.")))) in
-            ((let uu___2 = FStar_TypeChecker_Env.get_range env in
-              FStar_Errors.log_issue uu___2
-                (FStar_Errors.Error_IDEAssertionFailure, msg1));
-             FStar_Pervasives_Native.None)
-        | FStar_Compiler_Util.SigInt ->
-            (FStar_Compiler_Util.print_string "Interrupted";
-             FStar_Pervasives_Native.None)
-        | FStar_Errors.Error (e, msg, r, ctx) ->
-            (FStar_TypeChecker_Err.add_errors env [(e, msg, r, ctx)];
-             FStar_Pervasives_Native.None)
-        | FStar_Errors.Err (e, msg, ctx) ->
-            ((let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_TypeChecker_Env.get_range env in
-                  (e, msg, uu___4, ctx) in
-                [uu___3] in
-              FStar_TypeChecker_Err.add_errors env uu___2);
-             FStar_Pervasives_Native.None)
-        | FStar_Errors.Stop -> FStar_Pervasives_Native.None
-let with_captured_errors :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      FStar_Compiler_Util.sigint_handler ->
-        (FStar_TypeChecker_Env.env -> 'uuuuu FStar_Pervasives_Native.option)
-          -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun env ->
-    fun sigint_handler ->
-      fun f ->
-        let uu___ = FStar_Options.trace_error () in
-        if uu___ then f env else with_captured_errors' env sigint_handler f
-let (t0 : FStar_Compiler_Util.time) = FStar_Compiler_Util.now ()
-let (dummy_tf_of_fname :
-  Prims.string -> FStar_Interactive_JsonHelper.timed_fname) =
-  fun fname ->
-    {
-      FStar_Interactive_JsonHelper.tf_fname = fname;
-      FStar_Interactive_JsonHelper.tf_modtime = t0
-    }
-let (string_of_timed_fname :
-  FStar_Interactive_JsonHelper.timed_fname -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | { FStar_Interactive_JsonHelper.tf_fname = fname;
-        FStar_Interactive_JsonHelper.tf_modtime = modtime;_} ->
-        if modtime = t0
-        then FStar_Compiler_Util.format1 "{ %s }" fname
-        else
-          (let uu___2 = FStar_Compiler_Util.string_of_time modtime in
-           FStar_Compiler_Util.format2 "{ %s; %s }" fname uu___2)
-type push_query =
-  {
-  push_kind: FStar_Interactive_PushHelper.push_kind ;
-  push_code: Prims.string ;
-  push_line: Prims.int ;
-  push_column: Prims.int ;
-  push_peek_only: Prims.bool }
-let (__proj__Mkpush_query__item__push_kind :
-  push_query -> FStar_Interactive_PushHelper.push_kind) =
-  fun projectee ->
-    match projectee with
-    | { push_kind; push_code; push_line; push_column; push_peek_only;_} ->
-        push_kind
-let (__proj__Mkpush_query__item__push_code : push_query -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { push_kind; push_code; push_line; push_column; push_peek_only;_} ->
-        push_code
-let (__proj__Mkpush_query__item__push_line : push_query -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { push_kind; push_code; push_line; push_column; push_peek_only;_} ->
-        push_line
-let (__proj__Mkpush_query__item__push_column : push_query -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { push_kind; push_code; push_line; push_column; push_peek_only;_} ->
-        push_column
-let (__proj__Mkpush_query__item__push_peek_only : push_query -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { push_kind; push_code; push_line; push_column; push_peek_only;_} ->
-        push_peek_only
-type env_t = FStar_TypeChecker_Env.env
-let (repl_current_qid :
-  Prims.string FStar_Pervasives_Native.option FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (nothing_left_to_pop :
-  FStar_Interactive_JsonHelper.repl_state -> Prims.bool) =
-  fun st ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bang FStar_Interactive_PushHelper.repl_stack in
-      FStar_Compiler_List.length uu___1 in
-    uu___ =
-      (FStar_Compiler_List.length
-         st.FStar_Interactive_JsonHelper.repl_deps_stack)
-let (string_of_repl_task :
-  FStar_Interactive_JsonHelper.repl_task -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Interactive_JsonHelper.LDInterleaved (intf, impl) ->
-        let uu___1 = string_of_timed_fname intf in
-        let uu___2 = string_of_timed_fname impl in
-        FStar_Compiler_Util.format2 "LDInterleaved (%s, %s)" uu___1 uu___2
-    | FStar_Interactive_JsonHelper.LDSingle intf_or_impl ->
-        let uu___1 = string_of_timed_fname intf_or_impl in
-        FStar_Compiler_Util.format1 "LDSingle %s" uu___1
-    | FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile intf ->
-        let uu___1 = string_of_timed_fname intf in
-        FStar_Compiler_Util.format1 "LDInterfaceOfCurrentFile %s" uu___1
-    | FStar_Interactive_JsonHelper.PushFragment frag ->
-        FStar_Compiler_Util.format1 "PushFragment { code = %s }"
-          frag.FStar_Parser_ParseIt.frag_text
-    | FStar_Interactive_JsonHelper.Noop -> "Noop {}"
-let (run_repl_transaction :
-  FStar_Interactive_JsonHelper.repl_state ->
-    FStar_Interactive_PushHelper.push_kind ->
-      Prims.bool ->
-        FStar_Interactive_JsonHelper.repl_task ->
-          (Prims.bool * FStar_Interactive_JsonHelper.repl_state))
-  =
-  fun st ->
-    fun push_kind ->
-      fun must_rollback ->
-        fun task ->
-          let st1 =
-            FStar_Interactive_PushHelper.push_repl "run_repl_transaction"
-              push_kind task st in
-          let uu___ =
-            FStar_Interactive_PushHelper.track_name_changes
-              st1.FStar_Interactive_JsonHelper.repl_env in
-          match uu___ with
-          | (env, finish_name_tracking) ->
-              let check_success uu___1 =
-                (let uu___2 = FStar_Errors.get_err_count () in
-                 uu___2 = Prims.int_zero) &&
-                  (Prims.op_Negation must_rollback) in
-              let uu___1 =
-                let uu___2 =
-                  with_captured_errors env FStar_Compiler_Util.sigint_raise
-                    (fun env1 ->
-                       let uu___3 =
-                         FStar_Interactive_PushHelper.run_repl_task
-                           st1.FStar_Interactive_JsonHelper.repl_curmod env1
-                           task in
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                         uu___3) in
-                match uu___2 with
-                | FStar_Pervasives_Native.Some (curmod, env1) when
-                    check_success () -> (curmod, env1, true)
-                | uu___3 ->
-                    ((st1.FStar_Interactive_JsonHelper.repl_curmod), env,
-                      false) in
-              (match uu___1 with
-               | (curmod, env1, success) ->
-                   let uu___2 = finish_name_tracking env1 in
-                   (match uu___2 with
-                    | (env2, name_events) ->
-                        let st2 =
-                          if success
-                          then
-                            let st3 =
-                              {
-                                FStar_Interactive_JsonHelper.repl_line =
-                                  (st1.FStar_Interactive_JsonHelper.repl_line);
-                                FStar_Interactive_JsonHelper.repl_column =
-                                  (st1.FStar_Interactive_JsonHelper.repl_column);
-                                FStar_Interactive_JsonHelper.repl_fname =
-                                  (st1.FStar_Interactive_JsonHelper.repl_fname);
-                                FStar_Interactive_JsonHelper.repl_deps_stack
-                                  =
-                                  (st1.FStar_Interactive_JsonHelper.repl_deps_stack);
-                                FStar_Interactive_JsonHelper.repl_curmod =
-                                  curmod;
-                                FStar_Interactive_JsonHelper.repl_env = env2;
-                                FStar_Interactive_JsonHelper.repl_stdin =
-                                  (st1.FStar_Interactive_JsonHelper.repl_stdin);
-                                FStar_Interactive_JsonHelper.repl_names =
-                                  (st1.FStar_Interactive_JsonHelper.repl_names)
-                              } in
-                            FStar_Interactive_PushHelper.commit_name_tracking
-                              st3 name_events
-                          else
-                            FStar_Interactive_PushHelper.pop_repl
-                              "run_repl_transaction" st1 in
-                        (success, st2)))
-let (run_repl_ld_transactions :
-  FStar_Interactive_JsonHelper.repl_state ->
-    FStar_Interactive_JsonHelper.repl_task Prims.list ->
-      (FStar_Interactive_JsonHelper.repl_task -> unit) ->
-        (FStar_Interactive_JsonHelper.repl_state,
-          FStar_Interactive_JsonHelper.repl_state) FStar_Pervasives.either)
-  =
-  fun st ->
-    fun tasks ->
-      fun progress_callback ->
-        let debug verb task =
-          let uu___ = FStar_Options.debug_any () in
-          if uu___
-          then
-            let uu___1 = string_of_repl_task task in
-            FStar_Compiler_Util.print2 "%s %s" verb uu___1
-          else () in
-        let rec revert_many st1 uu___ =
-          match uu___ with
-          | [] -> st1
-          | (_id, (task, _st'))::entries ->
-              ((let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          FStar_Compiler_Effect.op_Bang
-                            FStar_Interactive_PushHelper.repl_stack in
-                        FStar_Compiler_List.hd uu___7 in
-                      FStar_Pervasives_Native.snd uu___6 in
-                    FStar_Pervasives_Native.fst uu___5 in
-                  task = uu___4 in
-                ());
-               debug "Reverting" task;
-               (let st' =
-                  FStar_Interactive_PushHelper.pop_repl
-                    "run_repl_ls_transactions" st1 in
-                let dep_graph =
-                  FStar_TypeChecker_Env.dep_graph
-                    st1.FStar_Interactive_JsonHelper.repl_env in
-                let st'1 =
-                  let uu___3 =
-                    FStar_TypeChecker_Env.set_dep_graph
-                      st'.FStar_Interactive_JsonHelper.repl_env dep_graph in
-                  {
-                    FStar_Interactive_JsonHelper.repl_line =
-                      (st'.FStar_Interactive_JsonHelper.repl_line);
-                    FStar_Interactive_JsonHelper.repl_column =
-                      (st'.FStar_Interactive_JsonHelper.repl_column);
-                    FStar_Interactive_JsonHelper.repl_fname =
-                      (st'.FStar_Interactive_JsonHelper.repl_fname);
-                    FStar_Interactive_JsonHelper.repl_deps_stack =
-                      (st'.FStar_Interactive_JsonHelper.repl_deps_stack);
-                    FStar_Interactive_JsonHelper.repl_curmod =
-                      (st'.FStar_Interactive_JsonHelper.repl_curmod);
-                    FStar_Interactive_JsonHelper.repl_env = uu___3;
-                    FStar_Interactive_JsonHelper.repl_stdin =
-                      (st'.FStar_Interactive_JsonHelper.repl_stdin);
-                    FStar_Interactive_JsonHelper.repl_names =
-                      (st'.FStar_Interactive_JsonHelper.repl_names)
-                  } in
-                revert_many st'1 entries)) in
-        let rec aux st1 tasks1 previous =
-          match (tasks1, previous) with
-          | ([], []) -> FStar_Pervasives.Inl st1
-          | (task::tasks2, []) ->
-              (debug "Loading" task;
-               progress_callback task;
-               (let uu___3 = FStar_Options.restore_cmd_line_options false in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  (fun uu___4 -> ()));
-               (let timestamped_task =
-                  FStar_Interactive_PushHelper.update_task_timestamps task in
-                let push_kind =
-                  let uu___3 = FStar_Options.lax () in
-                  if uu___3
-                  then FStar_Interactive_PushHelper.LaxCheck
-                  else FStar_Interactive_PushHelper.FullCheck in
-                let uu___3 =
-                  run_repl_transaction st1 push_kind false timestamped_task in
-                match uu___3 with
-                | (success, st2) ->
-                    if success
-                    then
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_Compiler_Effect.op_Bang
-                            FStar_Interactive_PushHelper.repl_stack in
-                        {
-                          FStar_Interactive_JsonHelper.repl_line =
-                            (st2.FStar_Interactive_JsonHelper.repl_line);
-                          FStar_Interactive_JsonHelper.repl_column =
-                            (st2.FStar_Interactive_JsonHelper.repl_column);
-                          FStar_Interactive_JsonHelper.repl_fname =
-                            (st2.FStar_Interactive_JsonHelper.repl_fname);
-                          FStar_Interactive_JsonHelper.repl_deps_stack =
-                            uu___5;
-                          FStar_Interactive_JsonHelper.repl_curmod =
-                            (st2.FStar_Interactive_JsonHelper.repl_curmod);
-                          FStar_Interactive_JsonHelper.repl_env =
-                            (st2.FStar_Interactive_JsonHelper.repl_env);
-                          FStar_Interactive_JsonHelper.repl_stdin =
-                            (st2.FStar_Interactive_JsonHelper.repl_stdin);
-                          FStar_Interactive_JsonHelper.repl_names =
-                            (st2.FStar_Interactive_JsonHelper.repl_names)
-                        } in
-                      aux uu___4 tasks2 []
-                    else FStar_Pervasives.Inr st2))
-          | (task::tasks2, prev::previous1) when
-              let uu___ =
-                FStar_Interactive_PushHelper.update_task_timestamps task in
-              (FStar_Pervasives_Native.fst (FStar_Pervasives_Native.snd prev))
-                = uu___
-              -> (debug "Skipping" task; aux st1 tasks2 previous1)
-          | (tasks2, previous1) ->
-              let uu___ = revert_many st1 previous1 in aux uu___ tasks2 [] in
-        aux st tasks
-          (FStar_Compiler_List.rev
-             st.FStar_Interactive_JsonHelper.repl_deps_stack)
-let (js_pushkind :
-  FStar_Compiler_Util.json -> FStar_Interactive_PushHelper.push_kind) =
-  fun s ->
-    let uu___ = FStar_Interactive_JsonHelper.js_str s in
-    match uu___ with
-    | "syntax" -> FStar_Interactive_PushHelper.SyntaxCheck
-    | "lax" -> FStar_Interactive_PushHelper.LaxCheck
-    | "full" -> FStar_Interactive_PushHelper.FullCheck
-    | uu___1 -> FStar_Interactive_JsonHelper.js_fail "push_kind" s
-let (js_reductionrule :
-  FStar_Compiler_Util.json -> FStar_TypeChecker_Env.step) =
-  fun s ->
-    let uu___ = FStar_Interactive_JsonHelper.js_str s in
-    match uu___ with
-    | "beta" -> FStar_TypeChecker_Env.Beta
-    | "delta" ->
-        FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant
-    | "iota" -> FStar_TypeChecker_Env.Iota
-    | "zeta" -> FStar_TypeChecker_Env.Zeta
-    | "reify" -> FStar_TypeChecker_Env.Reify
-    | "pure-subterms" -> FStar_TypeChecker_Env.PureSubtermsWithinComputations
-    | uu___1 -> FStar_Interactive_JsonHelper.js_fail "reduction rule" s
-type completion_context =
-  | CKCode 
-  | CKOption of Prims.bool 
-  | CKModuleOrNamespace of (Prims.bool * Prims.bool) 
-let (uu___is_CKCode : completion_context -> Prims.bool) =
-  fun projectee -> match projectee with | CKCode -> true | uu___ -> false
-let (uu___is_CKOption : completion_context -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CKOption _0 -> true | uu___ -> false
-let (__proj__CKOption__item___0 : completion_context -> Prims.bool) =
-  fun projectee -> match projectee with | CKOption _0 -> _0
-let (uu___is_CKModuleOrNamespace : completion_context -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CKModuleOrNamespace _0 -> true | uu___ -> false
-let (__proj__CKModuleOrNamespace__item___0 :
-  completion_context -> (Prims.bool * Prims.bool)) =
-  fun projectee -> match projectee with | CKModuleOrNamespace _0 -> _0
-let (js_optional_completion_context :
-  FStar_Compiler_Util.json FStar_Pervasives_Native.option ->
-    completion_context)
-  =
-  fun k ->
-    match k with
-    | FStar_Pervasives_Native.None -> CKCode
-    | FStar_Pervasives_Native.Some k1 ->
-        let uu___ = FStar_Interactive_JsonHelper.js_str k1 in
-        (match uu___ with
-         | "symbol" -> CKCode
-         | "code" -> CKCode
-         | "set-options" -> CKOption false
-         | "reset-options" -> CKOption true
-         | "open" -> CKModuleOrNamespace (true, true)
-         | "let-open" -> CKModuleOrNamespace (true, true)
-         | "include" -> CKModuleOrNamespace (true, false)
-         | "module-alias" -> CKModuleOrNamespace (true, false)
-         | uu___1 ->
-             FStar_Interactive_JsonHelper.js_fail
-               "completion context (code, set-options, reset-options, open, let-open, include, module-alias)"
-               k1)
-type lookup_context =
-  | LKSymbolOnly 
-  | LKModule 
-  | LKOption 
-  | LKCode 
-let (uu___is_LKSymbolOnly : lookup_context -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LKSymbolOnly -> true | uu___ -> false
-let (uu___is_LKModule : lookup_context -> Prims.bool) =
-  fun projectee -> match projectee with | LKModule -> true | uu___ -> false
-let (uu___is_LKOption : lookup_context -> Prims.bool) =
-  fun projectee -> match projectee with | LKOption -> true | uu___ -> false
-let (uu___is_LKCode : lookup_context -> Prims.bool) =
-  fun projectee -> match projectee with | LKCode -> true | uu___ -> false
-let (js_optional_lookup_context :
-  FStar_Compiler_Util.json FStar_Pervasives_Native.option -> lookup_context)
-  =
-  fun k ->
-    match k with
-    | FStar_Pervasives_Native.None -> LKSymbolOnly
-    | FStar_Pervasives_Native.Some k1 ->
-        let uu___ = FStar_Interactive_JsonHelper.js_str k1 in
-        (match uu___ with
-         | "symbol-only" -> LKSymbolOnly
-         | "code" -> LKCode
-         | "set-options" -> LKOption
-         | "reset-options" -> LKOption
-         | "open" -> LKModule
-         | "let-open" -> LKModule
-         | "include" -> LKModule
-         | "module-alias" -> LKModule
-         | uu___1 ->
-             FStar_Interactive_JsonHelper.js_fail
-               "lookup context (symbol-only, code, set-options, reset-options, open, let-open, include, module-alias)"
-               k1)
-type position = (Prims.string * Prims.int * Prims.int)
-type query' =
-  | Exit 
-  | DescribeProtocol 
-  | DescribeRepl 
-  | Segment of Prims.string 
-  | Pop 
-  | Push of push_query 
-  | VfsAdd of (Prims.string FStar_Pervasives_Native.option * Prims.string) 
-  | AutoComplete of (Prims.string * completion_context) 
-  | Lookup of (Prims.string * lookup_context * position
-  FStar_Pervasives_Native.option * Prims.string Prims.list) 
-  | Compute of (Prims.string * FStar_TypeChecker_Env.step Prims.list
-  FStar_Pervasives_Native.option) 
-  | Search of Prims.string 
-  | GenericError of Prims.string 
-  | ProtocolViolation of Prims.string 
-and query = {
-  qq: query' ;
-  qid: Prims.string }
-let (uu___is_Exit : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Exit -> true | uu___ -> false
-let (uu___is_DescribeProtocol : query' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DescribeProtocol -> true | uu___ -> false
-let (uu___is_DescribeRepl : query' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DescribeRepl -> true | uu___ -> false
-let (uu___is_Segment : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Segment _0 -> true | uu___ -> false
-let (__proj__Segment__item___0 : query' -> Prims.string) =
-  fun projectee -> match projectee with | Segment _0 -> _0
-let (uu___is_Pop : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Pop -> true | uu___ -> false
-let (uu___is_Push : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Push _0 -> true | uu___ -> false
-let (__proj__Push__item___0 : query' -> push_query) =
-  fun projectee -> match projectee with | Push _0 -> _0
-let (uu___is_VfsAdd : query' -> Prims.bool) =
-  fun projectee -> match projectee with | VfsAdd _0 -> true | uu___ -> false
-let (__proj__VfsAdd__item___0 :
-  query' -> (Prims.string FStar_Pervasives_Native.option * Prims.string)) =
-  fun projectee -> match projectee with | VfsAdd _0 -> _0
-let (uu___is_AutoComplete : query' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | AutoComplete _0 -> true | uu___ -> false
-let (__proj__AutoComplete__item___0 :
-  query' -> (Prims.string * completion_context)) =
-  fun projectee -> match projectee with | AutoComplete _0 -> _0
-let (uu___is_Lookup : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Lookup _0 -> true | uu___ -> false
-let (__proj__Lookup__item___0 :
-  query' ->
-    (Prims.string * lookup_context * position FStar_Pervasives_Native.option
-      * Prims.string Prims.list))
-  = fun projectee -> match projectee with | Lookup _0 -> _0
-let (uu___is_Compute : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Compute _0 -> true | uu___ -> false
-let (__proj__Compute__item___0 :
-  query' ->
-    (Prims.string * FStar_TypeChecker_Env.step Prims.list
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Compute _0 -> _0
-let (uu___is_Search : query' -> Prims.bool) =
-  fun projectee -> match projectee with | Search _0 -> true | uu___ -> false
-let (__proj__Search__item___0 : query' -> Prims.string) =
-  fun projectee -> match projectee with | Search _0 -> _0
-let (uu___is_GenericError : query' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | GenericError _0 -> true | uu___ -> false
-let (__proj__GenericError__item___0 : query' -> Prims.string) =
-  fun projectee -> match projectee with | GenericError _0 -> _0
-let (uu___is_ProtocolViolation : query' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ProtocolViolation _0 -> true | uu___ -> false
-let (__proj__ProtocolViolation__item___0 : query' -> Prims.string) =
-  fun projectee -> match projectee with | ProtocolViolation _0 -> _0
-let (__proj__Mkquery__item__qq : query -> query') =
-  fun projectee -> match projectee with | { qq; qid;_} -> qq
-let (__proj__Mkquery__item__qid : query -> Prims.string) =
-  fun projectee -> match projectee with | { qq; qid;_} -> qid
-let (query_needs_current_module : query' -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | Exit -> false
-    | DescribeProtocol -> false
-    | DescribeRepl -> false
-    | Segment uu___1 -> false
-    | Pop -> false
-    | Push
-        { push_kind = uu___1; push_code = uu___2; push_line = uu___3;
-          push_column = uu___4; push_peek_only = false;_}
-        -> false
-    | VfsAdd uu___1 -> false
-    | GenericError uu___1 -> false
-    | ProtocolViolation uu___1 -> false
-    | Push uu___1 -> true
-    | AutoComplete uu___1 -> true
-    | Lookup uu___1 -> true
-    | Compute uu___1 -> true
-    | Search uu___1 -> true
-let (interactive_protocol_vernum : Prims.int) = (Prims.of_int (2))
-let (interactive_protocol_features : Prims.string Prims.list) =
-  ["autocomplete";
-  "autocomplete/context";
-  "compute";
-  "compute/reify";
-  "compute/pure-subterms";
-  "describe-protocol";
-  "describe-repl";
-  "exit";
-  "lookup";
-  "lookup/context";
-  "lookup/documentation";
-  "lookup/definition";
-  "peek";
-  "pop";
-  "push";
-  "search";
-  "segment";
-  "vfs-add";
-  "tactic-ranges";
-  "interrupt";
-  "progress"]
-type query_status =
-  | QueryOK 
-  | QueryNOK 
-  | QueryViolatesProtocol 
-let (uu___is_QueryOK : query_status -> Prims.bool) =
-  fun projectee -> match projectee with | QueryOK -> true | uu___ -> false
-let (uu___is_QueryNOK : query_status -> Prims.bool) =
-  fun projectee -> match projectee with | QueryNOK -> true | uu___ -> false
-let (uu___is_QueryViolatesProtocol : query_status -> Prims.bool) =
-  fun projectee ->
-    match projectee with | QueryViolatesProtocol -> true | uu___ -> false
-let (wrap_js_failure :
-  Prims.string -> Prims.string -> FStar_Compiler_Util.json -> query) =
-  fun qid ->
-    fun expected ->
-      fun got ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Interactive_JsonHelper.json_debug got in
-            FStar_Compiler_Util.format2
-              "JSON decoding failed: expected %s, got %s" expected uu___2 in
-          ProtocolViolation uu___1 in
-        { qq = uu___; qid }
-let (unpack_interactive_query : FStar_Compiler_Util.json -> query) =
-  fun json ->
-    let assoc errloc key a =
-      let uu___ = FStar_Interactive_JsonHelper.try_assoc key a in
-      match uu___ with
-      | FStar_Pervasives_Native.Some v -> v
-      | FStar_Pervasives_Native.None ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Util.format2 "Missing key [%s] in %s." key
-                errloc in
-            FStar_Interactive_JsonHelper.InvalidQuery uu___2 in
-          FStar_Compiler_Effect.raise uu___1 in
-    let request =
-      FStar_Compiler_Effect.op_Bar_Greater json
-        FStar_Interactive_JsonHelper.js_assoc in
-    let qid =
-      let uu___ = assoc "query" "query-id" request in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        FStar_Interactive_JsonHelper.js_str in
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             let query1 =
-               let uu___1 = assoc "query" "query" request in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 FStar_Interactive_JsonHelper.js_str in
-             let args =
-               let uu___1 = assoc "query" "args" request in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 FStar_Interactive_JsonHelper.js_assoc in
-             let arg k = assoc "[args]" k args in
-             let try_arg k =
-               let uu___1 = FStar_Interactive_JsonHelper.try_assoc k args in
-               match uu___1 with
-               | FStar_Pervasives_Native.Some (FStar_Compiler_Util.JsonNull)
-                   -> FStar_Pervasives_Native.None
-               | other -> other in
-             let uu___1 =
-               match query1 with
-               | "exit" -> Exit
-               | "pop" -> Pop
-               | "describe-protocol" -> DescribeProtocol
-               | "describe-repl" -> DescribeRepl
-               | "segment" ->
-                   let uu___2 =
-                     let uu___3 = arg "code" in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_str in
-                   Segment uu___2
-               | "peek" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = arg "kind" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         js_pushkind in
-                     let uu___4 =
-                       let uu___5 = arg "code" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_str in
-                     let uu___5 =
-                       let uu___6 = arg "line" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___6
-                         FStar_Interactive_JsonHelper.js_int in
-                     let uu___6 =
-                       let uu___7 = arg "column" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___7
-                         FStar_Interactive_JsonHelper.js_int in
-                     {
-                       push_kind = uu___3;
-                       push_code = uu___4;
-                       push_line = uu___5;
-                       push_column = uu___6;
-                       push_peek_only = (query1 = "peek")
-                     } in
-                   Push uu___2
-               | "push" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = arg "kind" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         js_pushkind in
-                     let uu___4 =
-                       let uu___5 = arg "code" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_str in
-                     let uu___5 =
-                       let uu___6 = arg "line" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___6
-                         FStar_Interactive_JsonHelper.js_int in
-                     let uu___6 =
-                       let uu___7 = arg "column" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___7
-                         FStar_Interactive_JsonHelper.js_int in
-                     {
-                       push_kind = uu___3;
-                       push_code = uu___4;
-                       push_line = uu___5;
-                       push_column = uu___6;
-                       push_peek_only = (query1 = "peek")
-                     } in
-                   Push uu___2
-               | "autocomplete" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = arg "partial-symbol" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         FStar_Interactive_JsonHelper.js_str in
-                     let uu___4 =
-                       let uu___5 = try_arg "context" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         js_optional_completion_context in
-                     (uu___3, uu___4) in
-                   AutoComplete uu___2
-               | "lookup" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = arg "symbol" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         FStar_Interactive_JsonHelper.js_str in
-                     let uu___4 =
-                       let uu___5 = try_arg "context" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         js_optional_lookup_context in
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 = try_arg "location" in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___7
-                           (FStar_Compiler_Util.map_option
-                              FStar_Interactive_JsonHelper.js_assoc) in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___6
-                         (FStar_Compiler_Util.map_option
-                            (fun loc ->
-                               let uu___7 =
-                                 let uu___8 =
-                                   assoc "[location]" "filename" loc in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___8
-                                   FStar_Interactive_JsonHelper.js_str in
-                               let uu___8 =
-                                 let uu___9 = assoc "[location]" "line" loc in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                   FStar_Interactive_JsonHelper.js_int in
-                               let uu___9 =
-                                 let uu___10 =
-                                   assoc "[location]" "column" loc in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___10
-                                   FStar_Interactive_JsonHelper.js_int in
-                               (uu___7, uu___8, uu___9))) in
-                     let uu___6 =
-                       let uu___7 = arg "requested-info" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___7
-                         (FStar_Interactive_JsonHelper.js_list
-                            FStar_Interactive_JsonHelper.js_str) in
-                     (uu___3, uu___4, uu___5, uu___6) in
-                   Lookup uu___2
-               | "compute" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = arg "term" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         FStar_Interactive_JsonHelper.js_str in
-                     let uu___4 =
-                       let uu___5 = try_arg "rules" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         (FStar_Compiler_Util.map_option
-                            (FStar_Interactive_JsonHelper.js_list
-                               js_reductionrule)) in
-                     (uu___3, uu___4) in
-                   Compute uu___2
-               | "search" ->
-                   let uu___2 =
-                     let uu___3 = arg "terms" in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_str in
-                   Search uu___2
-               | "vfs-add" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = try_arg "filename" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         (FStar_Compiler_Util.map_option
-                            FStar_Interactive_JsonHelper.js_str) in
-                     let uu___4 =
-                       let uu___5 = arg "contents" in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_str in
-                     (uu___3, uu___4) in
-                   VfsAdd uu___2
-               | uu___2 ->
-                   let uu___3 =
-                     FStar_Compiler_Util.format1 "Unknown query '%s'" query1 in
-                   ProtocolViolation uu___3 in
-             { qq = uu___1; qid }) ()
-    with
-    | FStar_Interactive_JsonHelper.InvalidQuery msg ->
-        { qq = (ProtocolViolation msg); qid }
-    | FStar_Interactive_JsonHelper.UnexpectedJsonType (expected, got) ->
-        wrap_js_failure qid expected got
-let (deserialize_interactive_query : FStar_Compiler_Util.json -> query) =
-  fun js_query ->
-    try
-      (fun uu___ -> match () with | () -> unpack_interactive_query js_query)
-        ()
-    with
-    | FStar_Interactive_JsonHelper.InvalidQuery msg ->
-        { qq = (ProtocolViolation msg); qid = "?" }
-    | FStar_Interactive_JsonHelper.UnexpectedJsonType (expected, got) ->
-        wrap_js_failure "?" expected got
-let (parse_interactive_query : Prims.string -> query) =
-  fun query_str ->
-    let uu___ = FStar_Compiler_Util.json_of_string query_str in
-    match uu___ with
-    | FStar_Pervasives_Native.None ->
-        { qq = (ProtocolViolation "Json parsing failed."); qid = "?" }
-    | FStar_Pervasives_Native.Some request ->
-        deserialize_interactive_query request
-let (read_interactive_query : FStar_Compiler_Util.stream_reader -> query) =
-  fun stream ->
-    let uu___ = FStar_Compiler_Util.read_line stream in
-    match uu___ with
-    | FStar_Pervasives_Native.None ->
-        FStar_Compiler_Effect.exit Prims.int_zero
-    | FStar_Pervasives_Native.Some line -> parse_interactive_query line
-let json_of_opt :
-  'uuuuu .
-    ('uuuuu -> FStar_Compiler_Util.json) ->
-      'uuuuu FStar_Pervasives_Native.option -> FStar_Compiler_Util.json
-  =
-  fun json_of_a ->
-    fun opt_a ->
-      let uu___ = FStar_Compiler_Util.map_option json_of_a opt_a in
-      FStar_Compiler_Util.dflt FStar_Compiler_Util.JsonNull uu___
-let (json_of_issue_level :
-  FStar_Errors.issue_level -> FStar_Compiler_Util.json) =
-  fun i ->
-    FStar_Compiler_Util.JsonStr
-      (match i with
-       | FStar_Errors.ENotImplemented -> "not-implemented"
-       | FStar_Errors.EInfo -> "info"
-       | FStar_Errors.EWarning -> "warning"
-       | FStar_Errors.EError -> "error")
-let (json_of_issue : FStar_Errors.issue -> FStar_Compiler_Util.json) =
-  fun issue ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Errors.issue_message issue in
-              FStar_Compiler_Util.JsonStr uu___5 in
-            ("message", uu___4) in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    match issue.FStar_Errors.issue_range with
-                    | FStar_Pervasives_Native.None -> []
-                    | FStar_Pervasives_Native.Some r ->
-                        let uu___9 = FStar_Compiler_Range.json_of_use_range r in
-                        [uu___9] in
-                  let uu___9 =
-                    match issue.FStar_Errors.issue_range with
-                    | FStar_Pervasives_Native.Some r when
-                        let uu___10 = FStar_Compiler_Range.def_range r in
-                        let uu___11 = FStar_Compiler_Range.use_range r in
-                        uu___10 <> uu___11 ->
-                        let uu___10 =
-                          FStar_Compiler_Range.json_of_def_range r in
-                        [uu___10]
-                    | uu___10 -> [] in
-                  FStar_Compiler_List.op_At uu___8 uu___9 in
-                FStar_Compiler_Util.JsonList uu___7 in
-              ("ranges", uu___6) in
-            [uu___5] in
-          uu___3 :: uu___4 in
-        FStar_Compiler_List.op_At
-          (match issue.FStar_Errors.issue_number with
-           | FStar_Pervasives_Native.None -> []
-           | FStar_Pervasives_Native.Some n ->
-               [("number", (FStar_Compiler_Util.JsonInt n))]) uu___2 in
-      FStar_Compiler_List.op_At
-        [("level", (json_of_issue_level issue.FStar_Errors.issue_level))]
-        uu___1 in
-    FStar_Compiler_Effect.op_Less_Bar
-      (fun uu___1 -> FStar_Compiler_Util.JsonAssoc uu___1) uu___
-let (alist_of_symbol_lookup_result :
-  FStar_Interactive_QueryHelper.sl_reponse ->
-    (Prims.string * FStar_Compiler_Util.json) Prims.list)
-  =
-  fun lr ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          json_of_opt FStar_Compiler_Range.json_of_def_range
-            lr.FStar_Interactive_QueryHelper.slr_def_range in
-        ("defined-at", uu___2) in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            json_of_opt (fun uu___5 -> FStar_Compiler_Util.JsonStr uu___5)
-              lr.FStar_Interactive_QueryHelper.slr_typ in
-          ("type", uu___4) in
-        let uu___4 =
-          let uu___5 =
-            let uu___6 =
-              json_of_opt (fun uu___7 -> FStar_Compiler_Util.JsonStr uu___7)
-                lr.FStar_Interactive_QueryHelper.slr_doc in
-            ("documentation", uu___6) in
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                json_of_opt
-                  (fun uu___9 -> FStar_Compiler_Util.JsonStr uu___9)
-                  lr.FStar_Interactive_QueryHelper.slr_def in
-              ("definition", uu___8) in
-            [uu___7] in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    ("name",
-      (FStar_Compiler_Util.JsonStr
-         (lr.FStar_Interactive_QueryHelper.slr_name)))
-      :: uu___
-let (alist_of_protocol_info :
-  (Prims.string * FStar_Compiler_Util.json) Prims.list) =
-  let js_version = FStar_Compiler_Util.JsonInt interactive_protocol_vernum in
-  let js_features =
-    let uu___ =
-      FStar_Compiler_List.map
-        (fun uu___1 -> FStar_Compiler_Util.JsonStr uu___1)
-        interactive_protocol_features in
-    FStar_Compiler_Effect.op_Less_Bar
-      (fun uu___1 -> FStar_Compiler_Util.JsonList uu___1) uu___ in
-  [("version", js_version); ("features", js_features)]
-type fstar_option_permission_level =
-  | OptSet 
-  | OptReadOnly 
-let (uu___is_OptSet : fstar_option_permission_level -> Prims.bool) =
-  fun projectee -> match projectee with | OptSet -> true | uu___ -> false
-let (uu___is_OptReadOnly : fstar_option_permission_level -> Prims.bool) =
-  fun projectee ->
-    match projectee with | OptReadOnly -> true | uu___ -> false
-let (string_of_option_permission_level :
-  fstar_option_permission_level -> Prims.string) =
-  fun uu___ -> match uu___ with | OptSet -> "" | OptReadOnly -> "read-only"
-type fstar_option =
-  {
-  opt_name: Prims.string ;
-  opt_sig: Prims.string ;
-  opt_value: FStar_Options.option_val ;
-  opt_default: FStar_Options.option_val ;
-  opt_type: FStar_Options.opt_type ;
-  opt_snippets: Prims.string Prims.list ;
-  opt_documentation: Prims.string FStar_Pervasives_Native.option ;
-  opt_permission_level: fstar_option_permission_level }
-let (__proj__Mkfstar_option__item__opt_name : fstar_option -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_name
-let (__proj__Mkfstar_option__item__opt_sig : fstar_option -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_sig
-let (__proj__Mkfstar_option__item__opt_value :
-  fstar_option -> FStar_Options.option_val) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_value
-let (__proj__Mkfstar_option__item__opt_default :
-  fstar_option -> FStar_Options.option_val) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_default
-let (__proj__Mkfstar_option__item__opt_type :
-  fstar_option -> FStar_Options.opt_type) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_type
-let (__proj__Mkfstar_option__item__opt_snippets :
-  fstar_option -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_snippets
-let (__proj__Mkfstar_option__item__opt_documentation :
-  fstar_option -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_documentation
-let (__proj__Mkfstar_option__item__opt_permission_level :
-  fstar_option -> fstar_option_permission_level) =
-  fun projectee ->
-    match projectee with
-    | { opt_name; opt_sig; opt_value; opt_default; opt_type; opt_snippets;
-        opt_documentation; opt_permission_level;_} -> opt_permission_level
-let rec (kind_of_fstar_option_type : FStar_Options.opt_type -> Prims.string)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Options.Const uu___1 -> "flag"
-    | FStar_Options.IntStr uu___1 -> "int"
-    | FStar_Options.BoolStr -> "bool"
-    | FStar_Options.PathStr uu___1 -> "path"
-    | FStar_Options.SimpleStr uu___1 -> "string"
-    | FStar_Options.EnumStr uu___1 -> "enum"
-    | FStar_Options.OpenEnumStr uu___1 -> "open enum"
-    | FStar_Options.PostProcessed (uu___1, typ) ->
-        kind_of_fstar_option_type typ
-    | FStar_Options.Accumulated typ -> kind_of_fstar_option_type typ
-    | FStar_Options.ReverseAccumulated typ -> kind_of_fstar_option_type typ
-    | FStar_Options.WithSideEffect (uu___1, typ) ->
-        kind_of_fstar_option_type typ
-let (snippets_of_fstar_option :
-  Prims.string -> FStar_Options.opt_type -> Prims.string Prims.list) =
-  fun name ->
-    fun typ ->
-      let mk_field field_name =
-        Prims.op_Hat "${" (Prims.op_Hat field_name "}") in
-      let mk_snippet name1 argstring =
-        Prims.op_Hat "--"
-          (Prims.op_Hat name1
-             (if argstring <> "" then Prims.op_Hat " " argstring else "")) in
-      let rec arg_snippets_of_type typ1 =
-        match typ1 with
-        | FStar_Options.Const uu___ -> [""]
-        | FStar_Options.BoolStr -> ["true"; "false"]
-        | FStar_Options.IntStr desc -> [mk_field desc]
-        | FStar_Options.PathStr desc -> [mk_field desc]
-        | FStar_Options.SimpleStr desc -> [mk_field desc]
-        | FStar_Options.EnumStr strs -> strs
-        | FStar_Options.OpenEnumStr (strs, desc) ->
-            FStar_Compiler_List.op_At strs [mk_field desc]
-        | FStar_Options.PostProcessed (uu___, elem_spec) ->
-            arg_snippets_of_type elem_spec
-        | FStar_Options.Accumulated elem_spec ->
-            arg_snippets_of_type elem_spec
-        | FStar_Options.ReverseAccumulated elem_spec ->
-            arg_snippets_of_type elem_spec
-        | FStar_Options.WithSideEffect (uu___, elem_spec) ->
-            arg_snippets_of_type elem_spec in
-      let uu___ = arg_snippets_of_type typ in
-      FStar_Compiler_List.map (mk_snippet name) uu___
-let rec (json_of_fstar_option_value :
-  FStar_Options.option_val -> FStar_Compiler_Util.json) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Options.Bool b -> FStar_Compiler_Util.JsonBool b
-    | FStar_Options.String s -> FStar_Compiler_Util.JsonStr s
-    | FStar_Options.Path s -> FStar_Compiler_Util.JsonStr s
-    | FStar_Options.Int n -> FStar_Compiler_Util.JsonInt n
-    | FStar_Options.List vs ->
-        let uu___1 = FStar_Compiler_List.map json_of_fstar_option_value vs in
-        FStar_Compiler_Util.JsonList uu___1
-    | FStar_Options.Unset -> FStar_Compiler_Util.JsonNull
-let (alist_of_fstar_option :
-  fstar_option -> (Prims.string * FStar_Compiler_Util.json) Prims.list) =
-  fun opt ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = json_of_fstar_option_value opt.opt_value in
-          ("value", uu___3) in
-        let uu___3 =
-          let uu___4 =
-            let uu___5 = json_of_fstar_option_value opt.opt_default in
-            ("default", uu___5) in
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                json_of_opt
-                  (fun uu___8 -> FStar_Compiler_Util.JsonStr uu___8)
-                  opt.opt_documentation in
-              ("documentation", uu___7) in
-            let uu___7 =
-              let uu___8 =
-                let uu___9 =
-                  let uu___10 = kind_of_fstar_option_type opt.opt_type in
-                  FStar_Compiler_Util.JsonStr uu___10 in
-                ("type", uu___9) in
-              [uu___8;
-              ("permission-level",
-                (FStar_Compiler_Util.JsonStr
-                   (string_of_option_permission_level
-                      opt.opt_permission_level)))] in
-            uu___6 :: uu___7 in
-          uu___4 :: uu___5 in
-        uu___2 :: uu___3 in
-      ("signature", (FStar_Compiler_Util.JsonStr (opt.opt_sig))) :: uu___1 in
-    ("name", (FStar_Compiler_Util.JsonStr (opt.opt_name))) :: uu___
-let (json_of_fstar_option : fstar_option -> FStar_Compiler_Util.json) =
-  fun opt ->
-    let uu___ = alist_of_fstar_option opt in
-    FStar_Compiler_Util.JsonAssoc uu___
-let (json_of_response :
-  Prims.string ->
-    query_status -> FStar_Compiler_Util.json -> FStar_Compiler_Util.json)
-  =
-  fun qid ->
-    fun status ->
-      fun response ->
-        let qid1 = FStar_Compiler_Util.JsonStr qid in
-        let status1 =
-          match status with
-          | QueryOK -> FStar_Compiler_Util.JsonStr "success"
-          | QueryNOK -> FStar_Compiler_Util.JsonStr "failure"
-          | QueryViolatesProtocol ->
-              FStar_Compiler_Util.JsonStr "protocol-violation" in
-        FStar_Compiler_Util.JsonAssoc
-          [("kind", (FStar_Compiler_Util.JsonStr "response"));
-          ("query-id", qid1);
-          ("status", status1);
-          ("response", response)]
-let (write_response :
-  Prims.string -> query_status -> FStar_Compiler_Util.json -> unit) =
-  fun qid ->
-    fun status ->
-      fun response ->
-        FStar_Interactive_JsonHelper.write_json
-          (json_of_response qid status response)
-let (json_of_message :
-  Prims.string -> FStar_Compiler_Util.json -> FStar_Compiler_Util.json) =
-  fun level ->
-    fun js_contents ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Compiler_Effect.op_Bang repl_current_qid in
-              json_of_opt (fun uu___5 -> FStar_Compiler_Util.JsonStr uu___5)
-                uu___4 in
-            ("query-id", uu___3) in
-          [uu___2;
-          ("level", (FStar_Compiler_Util.JsonStr level));
-          ("contents", js_contents)] in
-        ("kind", (FStar_Compiler_Util.JsonStr "message")) :: uu___1 in
-      FStar_Compiler_Util.JsonAssoc uu___
-let forward_message :
-  'uuuuu .
-    (FStar_Compiler_Util.json -> 'uuuuu) ->
-      Prims.string -> FStar_Compiler_Util.json -> 'uuuuu
-  =
-  fun callback ->
-    fun level ->
-      fun contents ->
-        let uu___ = json_of_message level contents in callback uu___
-let (json_of_hello : FStar_Compiler_Util.json) =
-  let js_version = FStar_Compiler_Util.JsonInt interactive_protocol_vernum in
-  let js_features =
-    let uu___ =
-      FStar_Compiler_List.map
-        (fun uu___1 -> FStar_Compiler_Util.JsonStr uu___1)
-        interactive_protocol_features in
-    FStar_Compiler_Util.JsonList uu___ in
-  FStar_Compiler_Util.JsonAssoc
-    (("kind", (FStar_Compiler_Util.JsonStr "protocol-info")) ::
-    alist_of_protocol_info)
-let (write_hello : unit -> unit) =
-  fun uu___ -> FStar_Interactive_JsonHelper.write_json json_of_hello
-let (sig_of_fstar_option :
-  Prims.string -> FStar_Options.opt_type -> Prims.string) =
-  fun name ->
-    fun typ ->
-      let flag = Prims.op_Hat "--" name in
-      let uu___ = FStar_Options.desc_of_opt_type typ in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> flag
-      | FStar_Pervasives_Native.Some arg_sig ->
-          Prims.op_Hat flag (Prims.op_Hat " " arg_sig)
-let (fstar_options_list_cache : fstar_option Prims.list) =
-  let defaults = FStar_Compiler_Util.smap_of_list FStar_Options.defaults in
-  let uu___ =
-    FStar_Compiler_Effect.op_Bar_Greater FStar_Options.all_specs_with_types
-      (FStar_Compiler_List.filter_map
-         (fun uu___1 ->
-            match uu___1 with
-            | (_shortname, name, typ, doc) ->
-                let uu___2 = FStar_Compiler_Util.smap_try_find defaults name in
-                FStar_Compiler_Effect.op_Bar_Greater uu___2
-                  (FStar_Compiler_Util.map_option
-                     (fun default_value ->
-                        let uu___3 = sig_of_fstar_option name typ in
-                        let uu___4 = snippets_of_fstar_option name typ in
-                        let uu___5 =
-                          let uu___6 = FStar_Options.settable name in
-                          if uu___6 then OptSet else OptReadOnly in
-                        {
-                          opt_name = name;
-                          opt_sig = uu___3;
-                          opt_value = FStar_Options.Unset;
-                          opt_default = default_value;
-                          opt_type = typ;
-                          opt_snippets = uu___4;
-                          opt_documentation =
-                            (if doc = ""
-                             then FStar_Pervasives_Native.None
-                             else FStar_Pervasives_Native.Some doc);
-                          opt_permission_level = uu___5
-                        })))) in
-  FStar_Compiler_Effect.op_Bar_Greater uu___
-    (FStar_Compiler_List.sortWith
-       (fun o1 ->
-          fun o2 ->
-            FStar_String.compare (FStar_String.lowercase o1.opt_name)
-              (FStar_String.lowercase o2.opt_name)))
-let (fstar_options_map_cache : fstar_option FStar_Compiler_Util.smap) =
-  let cache = FStar_Compiler_Util.smap_create (Prims.of_int (50)) in
-  FStar_Compiler_List.iter
-    (fun opt -> FStar_Compiler_Util.smap_add cache opt.opt_name opt)
-    fstar_options_list_cache;
-  cache
-let (update_option : fstar_option -> fstar_option) =
-  fun opt ->
-    let uu___ = FStar_Options.get_option opt.opt_name in
-    {
-      opt_name = (opt.opt_name);
-      opt_sig = (opt.opt_sig);
-      opt_value = uu___;
-      opt_default = (opt.opt_default);
-      opt_type = (opt.opt_type);
-      opt_snippets = (opt.opt_snippets);
-      opt_documentation = (opt.opt_documentation);
-      opt_permission_level = (opt.opt_permission_level)
-    }
-let (current_fstar_options :
-  (fstar_option -> Prims.bool) -> fstar_option Prims.list) =
-  fun filter ->
-    let uu___ = FStar_Compiler_List.filter filter fstar_options_list_cache in
-    FStar_Compiler_List.map update_option uu___
-let (trim_option_name : Prims.string -> (Prims.string * Prims.string)) =
-  fun opt_name ->
-    let opt_prefix = "--" in
-    if FStar_Compiler_Util.starts_with opt_name opt_prefix
-    then
-      let uu___ =
-        FStar_Compiler_Util.substring_from opt_name
-          (FStar_String.length opt_prefix) in
-      (opt_prefix, uu___)
-    else ("", opt_name)
-let (json_of_repl_state :
-  FStar_Interactive_JsonHelper.repl_state -> FStar_Compiler_Util.json) =
-  fun st ->
-    let filenames uu___ =
-      match uu___ with
-      | (uu___1, (task, uu___2)) ->
-          (match task with
-           | FStar_Interactive_JsonHelper.LDInterleaved (intf, impl) ->
-               [intf.FStar_Interactive_JsonHelper.tf_fname;
-               impl.FStar_Interactive_JsonHelper.tf_fname]
-           | FStar_Interactive_JsonHelper.LDSingle intf_or_impl ->
-               [intf_or_impl.FStar_Interactive_JsonHelper.tf_fname]
-           | FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile intf ->
-               [intf.FStar_Interactive_JsonHelper.tf_fname]
-           | uu___3 -> []) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              FStar_Compiler_List.concatMap filenames
-                st.FStar_Interactive_JsonHelper.repl_deps_stack in
-            FStar_Compiler_List.map
-              (fun uu___5 -> FStar_Compiler_Util.JsonStr uu___5) uu___4 in
-          FStar_Compiler_Util.JsonList uu___3 in
-        ("loaded-dependencies", uu___2) in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 = current_fstar_options (fun uu___7 -> true) in
-              FStar_Compiler_List.map json_of_fstar_option uu___6 in
-            FStar_Compiler_Util.JsonList uu___5 in
-          ("options", uu___4) in
-        [uu___3] in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.JsonAssoc uu___
-let run_exit :
-  'uuuuu 'uuuuu1 .
-    'uuuuu ->
-      ((query_status * FStar_Compiler_Util.json) * ('uuuuu1, Prims.int)
-        FStar_Pervasives.either)
-  =
-  fun st ->
-    ((QueryOK, FStar_Compiler_Util.JsonNull),
-      (FStar_Pervasives.Inr Prims.int_zero))
-let run_describe_protocol :
-  'uuuuu 'uuuuu1 .
-    'uuuuu ->
-      ((query_status * FStar_Compiler_Util.json) * ('uuuuu, 'uuuuu1)
-        FStar_Pervasives.either)
-  =
-  fun st ->
-    ((QueryOK, (FStar_Compiler_Util.JsonAssoc alist_of_protocol_info)),
-      (FStar_Pervasives.Inl st))
-let run_describe_repl :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      ((query_status * FStar_Compiler_Util.json) *
-        (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-        FStar_Pervasives.either)
-  =
-  fun st ->
-    let uu___ = let uu___1 = json_of_repl_state st in (QueryOK, uu___1) in
-    (uu___, (FStar_Pervasives.Inl st))
-let run_protocol_violation :
-  'uuuuu 'uuuuu1 .
-    'uuuuu ->
-      Prims.string ->
-        ((query_status * FStar_Compiler_Util.json) * ('uuuuu, 'uuuuu1)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun message ->
-      ((QueryViolatesProtocol, (FStar_Compiler_Util.JsonStr message)),
-        (FStar_Pervasives.Inl st))
-let run_generic_error :
-  'uuuuu 'uuuuu1 .
-    'uuuuu ->
-      Prims.string ->
-        ((query_status * FStar_Compiler_Util.json) * ('uuuuu, 'uuuuu1)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun message ->
-      ((QueryNOK, (FStar_Compiler_Util.JsonStr message)),
-        (FStar_Pervasives.Inl st))
-let (collect_errors : unit -> FStar_Errors.issue Prims.list) =
-  fun uu___ ->
-    let errors = FStar_Errors.report_all () in FStar_Errors.clear (); errors
-let run_segment :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        ((query_status * FStar_Compiler_Util.json) *
-          (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun code ->
-      let frag =
-        {
-          FStar_Parser_ParseIt.frag_fname = "<input>";
-          FStar_Parser_ParseIt.frag_text = code;
-          FStar_Parser_ParseIt.frag_line = Prims.int_one;
-          FStar_Parser_ParseIt.frag_col = Prims.int_zero
-        } in
-      let collect_decls uu___ =
-        let uu___1 = FStar_Parser_Driver.parse_fragment frag in
-        match uu___1 with
-        | FStar_Parser_Driver.Empty -> []
-        | FStar_Parser_Driver.Decls decls -> decls
-        | FStar_Parser_Driver.Modul (FStar_Parser_AST.Module (uu___2, decls))
-            -> decls
-        | FStar_Parser_Driver.Modul (FStar_Parser_AST.Interface
-            (uu___2, decls, uu___3)) -> decls in
-      let uu___ =
-        with_captured_errors st.FStar_Interactive_JsonHelper.repl_env
-          FStar_Compiler_Util.sigint_ignore
-          (fun uu___1 ->
-             let uu___2 = collect_decls () in
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3) uu___2) in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let errors =
-            let uu___1 = collect_errors () in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (FStar_Compiler_List.map json_of_issue) in
-          ((QueryNOK, (FStar_Compiler_Util.JsonList errors)),
-            (FStar_Pervasives.Inl st))
-      | FStar_Pervasives_Native.Some decls ->
-          let json_of_decl decl =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_Range.json_of_def_range
-                    (FStar_Parser_AST.decl_drange decl) in
-                ("def_range", uu___3) in
-              [uu___2] in
-            FStar_Compiler_Util.JsonAssoc uu___1 in
-          let js_decls =
-            let uu___1 = FStar_Compiler_List.map json_of_decl decls in
-            FStar_Compiler_Effect.op_Less_Bar
-              (fun uu___2 -> FStar_Compiler_Util.JsonList uu___2) uu___1 in
-          ((QueryOK, (FStar_Compiler_Util.JsonAssoc [("decls", js_decls)])),
-            (FStar_Pervasives.Inl st))
-let run_vfs_add :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string FStar_Pervasives_Native.option ->
-        Prims.string ->
-          ((query_status * FStar_Compiler_Util.json) *
-            (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun opt_fname ->
-      fun contents ->
-        let fname =
-          FStar_Compiler_Util.dflt st.FStar_Interactive_JsonHelper.repl_fname
-            opt_fname in
-        FStar_Parser_ParseIt.add_vfs_entry fname contents;
-        ((QueryOK, FStar_Compiler_Util.JsonNull), (FStar_Pervasives.Inl st))
-let run_pop :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      ((query_status * FStar_Compiler_Util.json) *
-        (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-        FStar_Pervasives.either)
-  =
-  fun st ->
-    let uu___ = nothing_left_to_pop st in
-    if uu___
-    then
-      ((QueryNOK, (FStar_Compiler_Util.JsonStr "Too many pops")),
-        (FStar_Pervasives.Inl st))
-    else
-      (let st' = FStar_Interactive_PushHelper.pop_repl "pop_query" st in
-       ((QueryOK, FStar_Compiler_Util.JsonNull), (FStar_Pervasives.Inl st')))
-let (write_progress :
-  Prims.string FStar_Pervasives_Native.option ->
-    (Prims.string * FStar_Compiler_Util.json) Prims.list -> unit)
-  =
-  fun stage ->
-    fun contents_alist ->
-      let stage1 =
-        match stage with
-        | FStar_Pervasives_Native.Some s -> FStar_Compiler_Util.JsonStr s
-        | FStar_Pervasives_Native.None -> FStar_Compiler_Util.JsonNull in
-      let js_contents = ("stage", stage1) :: contents_alist in
-      let uu___ =
-        json_of_message "progress"
-          (FStar_Compiler_Util.JsonAssoc js_contents) in
-      FStar_Interactive_JsonHelper.write_json uu___
-let (write_repl_ld_task_progress :
-  FStar_Interactive_JsonHelper.repl_task -> unit) =
-  fun task ->
-    match task with
-    | FStar_Interactive_JsonHelper.LDInterleaved (uu___, tf) ->
-        let modname =
-          FStar_Parser_Dep.module_name_of_file
-            tf.FStar_Interactive_JsonHelper.tf_fname in
-        write_progress (FStar_Pervasives_Native.Some "loading-dependency")
-          [("modname", (FStar_Compiler_Util.JsonStr modname))]
-    | FStar_Interactive_JsonHelper.LDSingle tf ->
-        let modname =
-          FStar_Parser_Dep.module_name_of_file
-            tf.FStar_Interactive_JsonHelper.tf_fname in
-        write_progress (FStar_Pervasives_Native.Some "loading-dependency")
-          [("modname", (FStar_Compiler_Util.JsonStr modname))]
-    | FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile tf ->
-        let modname =
-          FStar_Parser_Dep.module_name_of_file
-            tf.FStar_Interactive_JsonHelper.tf_fname in
-        write_progress (FStar_Pervasives_Native.Some "loading-dependency")
-          [("modname", (FStar_Compiler_Util.JsonStr modname))]
-    | uu___ -> ()
-let (load_deps :
-  FStar_Interactive_JsonHelper.repl_state ->
-    ((FStar_Interactive_JsonHelper.repl_state * Prims.string Prims.list),
-      FStar_Interactive_JsonHelper.repl_state) FStar_Pervasives.either)
-  =
-  fun st ->
-    let uu___ =
-      with_captured_errors st.FStar_Interactive_JsonHelper.repl_env
-        FStar_Compiler_Util.sigint_ignore
-        (fun _env ->
-           let uu___1 =
-             FStar_Interactive_PushHelper.deps_and_repl_ld_tasks_of_our_file
-               st.FStar_Interactive_JsonHelper.repl_fname in
-           FStar_Compiler_Effect.op_Less_Bar
-             (fun uu___2 -> FStar_Pervasives_Native.Some uu___2) uu___1) in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> FStar_Pervasives.Inr st
-    | FStar_Pervasives_Native.Some (deps, tasks, dep_graph) ->
-        let st1 =
-          let uu___1 =
-            FStar_TypeChecker_Env.set_dep_graph
-              st.FStar_Interactive_JsonHelper.repl_env dep_graph in
-          {
-            FStar_Interactive_JsonHelper.repl_line =
-              (st.FStar_Interactive_JsonHelper.repl_line);
-            FStar_Interactive_JsonHelper.repl_column =
-              (st.FStar_Interactive_JsonHelper.repl_column);
-            FStar_Interactive_JsonHelper.repl_fname =
-              (st.FStar_Interactive_JsonHelper.repl_fname);
-            FStar_Interactive_JsonHelper.repl_deps_stack =
-              (st.FStar_Interactive_JsonHelper.repl_deps_stack);
-            FStar_Interactive_JsonHelper.repl_curmod =
-              (st.FStar_Interactive_JsonHelper.repl_curmod);
-            FStar_Interactive_JsonHelper.repl_env = uu___1;
-            FStar_Interactive_JsonHelper.repl_stdin =
-              (st.FStar_Interactive_JsonHelper.repl_stdin);
-            FStar_Interactive_JsonHelper.repl_names =
-              (st.FStar_Interactive_JsonHelper.repl_names)
-          } in
-        let uu___1 =
-          run_repl_ld_transactions st1 tasks write_repl_ld_task_progress in
-        (match uu___1 with
-         | FStar_Pervasives.Inr st2 ->
-             (write_progress FStar_Pervasives_Native.None [];
-              FStar_Pervasives.Inr st2)
-         | FStar_Pervasives.Inl st2 ->
-             (write_progress FStar_Pervasives_Native.None [];
-              FStar_Pervasives.Inl (st2, deps)))
-let (rephrase_dependency_error : FStar_Errors.issue -> FStar_Errors.issue) =
-  fun issue ->
-    let uu___ =
-      FStar_Compiler_Util.format1
-        "Error while computing or loading dependencies:\n%s"
-        issue.FStar_Errors.issue_msg in
-    {
-      FStar_Errors.issue_msg = uu___;
-      FStar_Errors.issue_level = (issue.FStar_Errors.issue_level);
-      FStar_Errors.issue_range = (issue.FStar_Errors.issue_range);
-      FStar_Errors.issue_number = (issue.FStar_Errors.issue_number);
-      FStar_Errors.issue_ctx = (issue.FStar_Errors.issue_ctx)
-    }
-let run_push_without_deps :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      push_query ->
-        ((query_status * FStar_Compiler_Util.json) *
-          (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun query1 ->
-      let set_nosynth_flag st1 flag =
-        {
-          FStar_Interactive_JsonHelper.repl_line =
-            (st1.FStar_Interactive_JsonHelper.repl_line);
-          FStar_Interactive_JsonHelper.repl_column =
-            (st1.FStar_Interactive_JsonHelper.repl_column);
-          FStar_Interactive_JsonHelper.repl_fname =
-            (st1.FStar_Interactive_JsonHelper.repl_fname);
-          FStar_Interactive_JsonHelper.repl_deps_stack =
-            (st1.FStar_Interactive_JsonHelper.repl_deps_stack);
-          FStar_Interactive_JsonHelper.repl_curmod =
-            (st1.FStar_Interactive_JsonHelper.repl_curmod);
-          FStar_Interactive_JsonHelper.repl_env =
-            (let uu___ = st1.FStar_Interactive_JsonHelper.repl_env in
-             {
-               FStar_TypeChecker_Env.solver =
-                 (uu___.FStar_TypeChecker_Env.solver);
-               FStar_TypeChecker_Env.range =
-                 (uu___.FStar_TypeChecker_Env.range);
-               FStar_TypeChecker_Env.curmodule =
-                 (uu___.FStar_TypeChecker_Env.curmodule);
-               FStar_TypeChecker_Env.gamma =
-                 (uu___.FStar_TypeChecker_Env.gamma);
-               FStar_TypeChecker_Env.gamma_sig =
-                 (uu___.FStar_TypeChecker_Env.gamma_sig);
-               FStar_TypeChecker_Env.gamma_cache =
-                 (uu___.FStar_TypeChecker_Env.gamma_cache);
-               FStar_TypeChecker_Env.modules =
-                 (uu___.FStar_TypeChecker_Env.modules);
-               FStar_TypeChecker_Env.expected_typ =
-                 (uu___.FStar_TypeChecker_Env.expected_typ);
-               FStar_TypeChecker_Env.sigtab =
-                 (uu___.FStar_TypeChecker_Env.sigtab);
-               FStar_TypeChecker_Env.attrtab =
-                 (uu___.FStar_TypeChecker_Env.attrtab);
-               FStar_TypeChecker_Env.instantiate_imp =
-                 (uu___.FStar_TypeChecker_Env.instantiate_imp);
-               FStar_TypeChecker_Env.effects =
-                 (uu___.FStar_TypeChecker_Env.effects);
-               FStar_TypeChecker_Env.generalize =
-                 (uu___.FStar_TypeChecker_Env.generalize);
-               FStar_TypeChecker_Env.letrecs =
-                 (uu___.FStar_TypeChecker_Env.letrecs);
-               FStar_TypeChecker_Env.top_level =
-                 (uu___.FStar_TypeChecker_Env.top_level);
-               FStar_TypeChecker_Env.check_uvars =
-                 (uu___.FStar_TypeChecker_Env.check_uvars);
-               FStar_TypeChecker_Env.use_eq_strict =
-                 (uu___.FStar_TypeChecker_Env.use_eq_strict);
-               FStar_TypeChecker_Env.is_iface =
-                 (uu___.FStar_TypeChecker_Env.is_iface);
-               FStar_TypeChecker_Env.admit =
-                 (uu___.FStar_TypeChecker_Env.admit);
-               FStar_TypeChecker_Env.lax = (uu___.FStar_TypeChecker_Env.lax);
-               FStar_TypeChecker_Env.lax_universes =
-                 (uu___.FStar_TypeChecker_Env.lax_universes);
-               FStar_TypeChecker_Env.phase1 =
-                 (uu___.FStar_TypeChecker_Env.phase1);
-               FStar_TypeChecker_Env.failhard =
-                 (uu___.FStar_TypeChecker_Env.failhard);
-               FStar_TypeChecker_Env.nosynth = flag;
-               FStar_TypeChecker_Env.uvar_subtyping =
-                 (uu___.FStar_TypeChecker_Env.uvar_subtyping);
-               FStar_TypeChecker_Env.tc_term =
-                 (uu___.FStar_TypeChecker_Env.tc_term);
-               FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                 (uu___.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-               FStar_TypeChecker_Env.universe_of =
-                 (uu___.FStar_TypeChecker_Env.universe_of);
-               FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                 (uu___.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-               FStar_TypeChecker_Env.teq_nosmt_force =
-                 (uu___.FStar_TypeChecker_Env.teq_nosmt_force);
-               FStar_TypeChecker_Env.subtype_nosmt_force =
-                 (uu___.FStar_TypeChecker_Env.subtype_nosmt_force);
-               FStar_TypeChecker_Env.qtbl_name_and_index =
-                 (uu___.FStar_TypeChecker_Env.qtbl_name_and_index);
-               FStar_TypeChecker_Env.normalized_eff_names =
-                 (uu___.FStar_TypeChecker_Env.normalized_eff_names);
-               FStar_TypeChecker_Env.fv_delta_depths =
-                 (uu___.FStar_TypeChecker_Env.fv_delta_depths);
-               FStar_TypeChecker_Env.proof_ns =
-                 (uu___.FStar_TypeChecker_Env.proof_ns);
-               FStar_TypeChecker_Env.synth_hook =
-                 (uu___.FStar_TypeChecker_Env.synth_hook);
-               FStar_TypeChecker_Env.try_solve_implicits_hook =
-                 (uu___.FStar_TypeChecker_Env.try_solve_implicits_hook);
-               FStar_TypeChecker_Env.splice =
-                 (uu___.FStar_TypeChecker_Env.splice);
-               FStar_TypeChecker_Env.mpreprocess =
-                 (uu___.FStar_TypeChecker_Env.mpreprocess);
-               FStar_TypeChecker_Env.postprocess =
-                 (uu___.FStar_TypeChecker_Env.postprocess);
-               FStar_TypeChecker_Env.identifier_info =
-                 (uu___.FStar_TypeChecker_Env.identifier_info);
-               FStar_TypeChecker_Env.tc_hooks =
-                 (uu___.FStar_TypeChecker_Env.tc_hooks);
-               FStar_TypeChecker_Env.dsenv =
-                 (uu___.FStar_TypeChecker_Env.dsenv);
-               FStar_TypeChecker_Env.nbe = (uu___.FStar_TypeChecker_Env.nbe);
-               FStar_TypeChecker_Env.strict_args_tab =
-                 (uu___.FStar_TypeChecker_Env.strict_args_tab);
-               FStar_TypeChecker_Env.erasable_types_tab =
-                 (uu___.FStar_TypeChecker_Env.erasable_types_tab);
-               FStar_TypeChecker_Env.enable_defer_to_tac =
-                 (uu___.FStar_TypeChecker_Env.enable_defer_to_tac);
-               FStar_TypeChecker_Env.unif_allow_ref_guards =
-                 (uu___.FStar_TypeChecker_Env.unif_allow_ref_guards);
-               FStar_TypeChecker_Env.erase_erasable_args =
-                 (uu___.FStar_TypeChecker_Env.erase_erasable_args);
-               FStar_TypeChecker_Env.core_check =
-                 (uu___.FStar_TypeChecker_Env.core_check)
-             });
-          FStar_Interactive_JsonHelper.repl_stdin =
-            (st1.FStar_Interactive_JsonHelper.repl_stdin);
-          FStar_Interactive_JsonHelper.repl_names =
-            (st1.FStar_Interactive_JsonHelper.repl_names)
-        } in
-      let uu___ = query1 in
-      match uu___ with
-      | { push_kind; push_code = text; push_line = line;
-          push_column = column; push_peek_only = peek_only;_} ->
-          let frag =
-            {
-              FStar_Parser_ParseIt.frag_fname = "<input>";
-              FStar_Parser_ParseIt.frag_text = text;
-              FStar_Parser_ParseIt.frag_line = line;
-              FStar_Parser_ParseIt.frag_col = column
-            } in
-          ((let uu___2 = FStar_Options.ide_id_info_off () in
-            if uu___2
-            then
-              FStar_TypeChecker_Env.toggle_id_info
-                st.FStar_Interactive_JsonHelper.repl_env false
-            else
-              FStar_TypeChecker_Env.toggle_id_info
-                st.FStar_Interactive_JsonHelper.repl_env true);
-           (let st1 = set_nosynth_flag st peek_only in
-            let uu___2 =
-              run_repl_transaction st1 push_kind peek_only
-                (FStar_Interactive_JsonHelper.PushFragment frag) in
-            match uu___2 with
-            | (success, st2) ->
-                let st3 = set_nosynth_flag st2 false in
-                let status =
-                  if success || peek_only then QueryOK else QueryNOK in
-                let json_errors =
-                  let uu___3 =
-                    let uu___4 = collect_errors () in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___4
-                      (FStar_Compiler_List.map json_of_issue) in
-                  FStar_Compiler_Util.JsonList uu___3 in
-                let st4 =
-                  if success
-                  then
-                    {
-                      FStar_Interactive_JsonHelper.repl_line = line;
-                      FStar_Interactive_JsonHelper.repl_column = column;
-                      FStar_Interactive_JsonHelper.repl_fname =
-                        (st3.FStar_Interactive_JsonHelper.repl_fname);
-                      FStar_Interactive_JsonHelper.repl_deps_stack =
-                        (st3.FStar_Interactive_JsonHelper.repl_deps_stack);
-                      FStar_Interactive_JsonHelper.repl_curmod =
-                        (st3.FStar_Interactive_JsonHelper.repl_curmod);
-                      FStar_Interactive_JsonHelper.repl_env =
-                        (st3.FStar_Interactive_JsonHelper.repl_env);
-                      FStar_Interactive_JsonHelper.repl_stdin =
-                        (st3.FStar_Interactive_JsonHelper.repl_stdin);
-                      FStar_Interactive_JsonHelper.repl_names =
-                        (st3.FStar_Interactive_JsonHelper.repl_names)
-                    }
-                  else st3 in
-                ((status, json_errors), (FStar_Pervasives.Inl st4))))
-let run_push_with_deps :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      push_query ->
-        ((query_status * FStar_Compiler_Util.json) *
-          (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun query1 ->
-      (let uu___1 = FStar_Options.debug_any () in
-       if uu___1
-       then FStar_Compiler_Util.print_string "Reloading dependencies"
-       else ());
-      FStar_TypeChecker_Env.toggle_id_info
-        st.FStar_Interactive_JsonHelper.repl_env false;
-      (let uu___2 = load_deps st in
-       match uu___2 with
-       | FStar_Pervasives.Inr st1 ->
-           let errors =
-             let uu___3 = collect_errors () in
-             FStar_Compiler_List.map rephrase_dependency_error uu___3 in
-           let js_errors =
-             FStar_Compiler_Effect.op_Bar_Greater errors
-               (FStar_Compiler_List.map json_of_issue) in
-           ((QueryNOK, (FStar_Compiler_Util.JsonList js_errors)),
-             (FStar_Pervasives.Inl st1))
-       | FStar_Pervasives.Inl (st1, deps) ->
-           ((let uu___4 = FStar_Options.restore_cmd_line_options false in
-             FStar_Compiler_Effect.op_Bar_Greater uu___4 (fun uu___5 -> ()));
-            (let names =
-               FStar_Interactive_PushHelper.add_module_completions
-                 st1.FStar_Interactive_JsonHelper.repl_fname deps
-                 st1.FStar_Interactive_JsonHelper.repl_names in
-             run_push_without_deps
-               {
-                 FStar_Interactive_JsonHelper.repl_line =
-                   (st1.FStar_Interactive_JsonHelper.repl_line);
-                 FStar_Interactive_JsonHelper.repl_column =
-                   (st1.FStar_Interactive_JsonHelper.repl_column);
-                 FStar_Interactive_JsonHelper.repl_fname =
-                   (st1.FStar_Interactive_JsonHelper.repl_fname);
-                 FStar_Interactive_JsonHelper.repl_deps_stack =
-                   (st1.FStar_Interactive_JsonHelper.repl_deps_stack);
-                 FStar_Interactive_JsonHelper.repl_curmod =
-                   (st1.FStar_Interactive_JsonHelper.repl_curmod);
-                 FStar_Interactive_JsonHelper.repl_env =
-                   (st1.FStar_Interactive_JsonHelper.repl_env);
-                 FStar_Interactive_JsonHelper.repl_stdin =
-                   (st1.FStar_Interactive_JsonHelper.repl_stdin);
-                 FStar_Interactive_JsonHelper.repl_names = names
-               } query1)))
-let run_push :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      push_query ->
-        ((query_status * FStar_Compiler_Util.json) *
-          (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun query1 ->
-      let uu___ = nothing_left_to_pop st in
-      if uu___
-      then run_push_with_deps st query1
-      else run_push_without_deps st query1
-let (run_symbol_lookup :
-  FStar_Interactive_JsonHelper.repl_state ->
-    Prims.string ->
-      FStar_Interactive_QueryHelper.position FStar_Pervasives_Native.option
-        ->
-        Prims.string Prims.list ->
-          (Prims.string,
-            (Prims.string * (Prims.string * FStar_Compiler_Util.json)
-              Prims.list))
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun symbol ->
-      fun pos_opt ->
-        fun requested_info ->
-          let uu___ =
-            FStar_Interactive_QueryHelper.symlookup
-              st.FStar_Interactive_JsonHelper.repl_env symbol pos_opt
-              requested_info in
-          match uu___ with
-          | FStar_Pervasives_Native.None ->
-              FStar_Pervasives.Inl "Symbol not found"
-          | FStar_Pervasives_Native.Some result ->
-              let uu___1 =
-                let uu___2 = alist_of_symbol_lookup_result result in
-                ("symbol", uu___2) in
-              FStar_Pervasives.Inr uu___1
-let (run_option_lookup :
-  Prims.string ->
-    (Prims.string,
-      (Prims.string * (Prims.string * FStar_Compiler_Util.json) Prims.list))
-      FStar_Pervasives.either)
-  =
-  fun opt_name ->
-    let uu___ = trim_option_name opt_name in
-    match uu___ with
-    | (uu___1, trimmed_name) ->
-        let uu___2 =
-          FStar_Compiler_Util.smap_try_find fstar_options_map_cache
-            trimmed_name in
-        (match uu___2 with
-         | FStar_Pervasives_Native.None ->
-             FStar_Pervasives.Inl (Prims.op_Hat "Unknown option:" opt_name)
-         | FStar_Pervasives_Native.Some opt ->
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = update_option opt in
-                 alist_of_fstar_option uu___5 in
-               ("option", uu___4) in
-             FStar_Pervasives.Inr uu___3)
-let (run_module_lookup :
-  FStar_Interactive_JsonHelper.repl_state ->
-    Prims.string ->
-      (Prims.string,
-        (Prims.string * (Prims.string * FStar_Compiler_Util.json) Prims.list))
-        FStar_Pervasives.either)
-  =
-  fun st ->
-    fun symbol ->
-      let query1 = FStar_Compiler_Util.split symbol "." in
-      let uu___ =
-        FStar_Interactive_CompletionTable.find_module_or_ns
-          st.FStar_Interactive_JsonHelper.repl_names query1 in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          FStar_Pervasives.Inl "No such module or namespace"
-      | FStar_Pervasives_Native.Some
-          (FStar_Interactive_CompletionTable.Module mod_info) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Interactive_CompletionTable.alist_of_mod_info mod_info in
-            ("module", uu___2) in
-          FStar_Pervasives.Inr uu___1
-      | FStar_Pervasives_Native.Some
-          (FStar_Interactive_CompletionTable.Namespace ns_info) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Interactive_CompletionTable.alist_of_ns_info ns_info in
-            ("namespace", uu___2) in
-          FStar_Pervasives.Inr uu___1
-let (run_code_lookup :
-  FStar_Interactive_JsonHelper.repl_state ->
-    Prims.string ->
-      FStar_Interactive_QueryHelper.position FStar_Pervasives_Native.option
-        ->
-        Prims.string Prims.list ->
-          (Prims.string,
-            (Prims.string * (Prims.string * FStar_Compiler_Util.json)
-              Prims.list))
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun symbol ->
-      fun pos_opt ->
-        fun requested_info ->
-          let uu___ = run_symbol_lookup st symbol pos_opt requested_info in
-          match uu___ with
-          | FStar_Pervasives.Inr alist -> FStar_Pervasives.Inr alist
-          | FStar_Pervasives.Inl uu___1 ->
-              let uu___2 = run_module_lookup st symbol in
-              (match uu___2 with
-               | FStar_Pervasives.Inr alist -> FStar_Pervasives.Inr alist
-               | FStar_Pervasives.Inl err_msg ->
-                   FStar_Pervasives.Inl
-                     "No such symbol, module, or namespace.")
-let (run_lookup' :
-  FStar_Interactive_JsonHelper.repl_state ->
-    Prims.string ->
-      lookup_context ->
-        FStar_Interactive_QueryHelper.position FStar_Pervasives_Native.option
-          ->
-          Prims.string Prims.list ->
-            (Prims.string,
-              (Prims.string * (Prims.string * FStar_Compiler_Util.json)
-                Prims.list))
-              FStar_Pervasives.either)
-  =
-  fun st ->
-    fun symbol ->
-      fun context ->
-        fun pos_opt ->
-          fun requested_info ->
-            match context with
-            | LKSymbolOnly ->
-                run_symbol_lookup st symbol pos_opt requested_info
-            | LKModule -> run_module_lookup st symbol
-            | LKOption -> run_option_lookup symbol
-            | LKCode -> run_code_lookup st symbol pos_opt requested_info
-let run_lookup :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        lookup_context ->
-          FStar_Interactive_QueryHelper.position
-            FStar_Pervasives_Native.option ->
-            Prims.string Prims.list ->
-              ((query_status * FStar_Compiler_Util.json) *
-                (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-                FStar_Pervasives.either)
-  =
-  fun st ->
-    fun symbol ->
-      fun context ->
-        fun pos_opt ->
-          fun requested_info ->
-            let uu___ = run_lookup' st symbol context pos_opt requested_info in
-            match uu___ with
-            | FStar_Pervasives.Inl err_msg ->
-                ((QueryNOK, (FStar_Compiler_Util.JsonStr err_msg)),
-                  (FStar_Pervasives.Inl st))
-            | FStar_Pervasives.Inr (kind, info) ->
-                ((QueryOK,
-                   (FStar_Compiler_Util.JsonAssoc
-                      (("kind", (FStar_Compiler_Util.JsonStr kind)) :: info))),
-                  (FStar_Pervasives.Inl st))
-let run_code_autocomplete :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        ((query_status * FStar_Compiler_Util.json) *
-          (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun search_term ->
-      let result = FStar_Interactive_QueryHelper.ck_completion st search_term in
-      let js =
-        FStar_Compiler_List.map
-          FStar_Interactive_CompletionTable.json_of_completion_result result in
-      ((QueryOK, (FStar_Compiler_Util.JsonList js)),
-        (FStar_Pervasives.Inl st))
-let run_module_autocomplete :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        'uuuuu ->
-          'uuuuu1 ->
-            ((query_status * FStar_Compiler_Util.json) *
-              (FStar_Interactive_JsonHelper.repl_state, 'uuuuu2)
-              FStar_Pervasives.either)
-  =
-  fun st ->
-    fun search_term ->
-      fun modules ->
-        fun namespaces ->
-          let needle = FStar_Compiler_Util.split search_term "." in
-          let mods_and_nss =
-            FStar_Interactive_CompletionTable.autocomplete_mod_or_ns
-              st.FStar_Interactive_JsonHelper.repl_names needle
-              (fun uu___ -> FStar_Pervasives_Native.Some uu___) in
-          let json =
-            FStar_Compiler_List.map
-              FStar_Interactive_CompletionTable.json_of_completion_result
-              mods_and_nss in
-          ((QueryOK, (FStar_Compiler_Util.JsonList json)),
-            (FStar_Pervasives.Inl st))
-let candidates_of_fstar_option :
-  'uuuuu .
-    Prims.int ->
-      'uuuuu ->
-        fstar_option ->
-          FStar_Interactive_CompletionTable.completion_result Prims.list
-  =
-  fun match_len ->
-    fun is_reset ->
-      fun opt ->
-        let uu___ =
-          match opt.opt_permission_level with
-          | OptSet -> (true, "")
-          | OptReadOnly -> (false, "read-only") in
-        match uu___ with
-        | (may_set, explanation) ->
-            let opt_type = kind_of_fstar_option_type opt.opt_type in
-            let annot =
-              if may_set
-              then opt_type
-              else
-                Prims.op_Hat "("
-                  (Prims.op_Hat explanation
-                     (Prims.op_Hat " " (Prims.op_Hat opt_type ")"))) in
-            FStar_Compiler_Effect.op_Bar_Greater opt.opt_snippets
-              (FStar_Compiler_List.map
-                 (fun snippet ->
-                    {
-                      FStar_Interactive_CompletionTable.completion_match_length
-                        = match_len;
-                      FStar_Interactive_CompletionTable.completion_candidate
-                        = snippet;
-                      FStar_Interactive_CompletionTable.completion_annotation
-                        = annot
-                    }))
-let run_option_autocomplete :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    'uuuuu ->
-      Prims.string ->
-        'uuuuu1 ->
-          ((query_status * FStar_Compiler_Util.json) * ('uuuuu, 'uuuuu2)
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun search_term ->
-      fun is_reset ->
-        let uu___ = trim_option_name search_term in
-        match uu___ with
-        | ("--", trimmed_name) ->
-            let matcher opt =
-              FStar_Compiler_Util.starts_with opt.opt_name trimmed_name in
-            let options = current_fstar_options matcher in
-            let match_len = FStar_String.length search_term in
-            let collect_candidates =
-              candidates_of_fstar_option match_len is_reset in
-            let results =
-              FStar_Compiler_List.concatMap collect_candidates options in
-            let json =
-              FStar_Compiler_List.map
-                FStar_Interactive_CompletionTable.json_of_completion_result
-                results in
-            ((QueryOK, (FStar_Compiler_Util.JsonList json)),
-              (FStar_Pervasives.Inl st))
-        | (uu___1, uu___2) ->
-            ((QueryNOK,
-               (FStar_Compiler_Util.JsonStr "Options should start with '--'")),
-              (FStar_Pervasives.Inl st))
-let run_autocomplete :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        completion_context ->
-          ((query_status * FStar_Compiler_Util.json) *
-            (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun search_term ->
-      fun context ->
-        match context with
-        | CKCode -> run_code_autocomplete st search_term
-        | CKOption is_reset ->
-            run_option_autocomplete st search_term is_reset
-        | CKModuleOrNamespace (modules, namespaces) ->
-            run_module_autocomplete st search_term modules namespaces
-let run_and_rewind :
-  'uuuuu 'uuuuu1 .
-    FStar_Interactive_JsonHelper.repl_state ->
-      'uuuuu ->
-        (FStar_Interactive_JsonHelper.repl_state -> 'uuuuu) ->
-          ('uuuuu * (FStar_Interactive_JsonHelper.repl_state, 'uuuuu1)
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun sigint_default ->
-      fun task ->
-        let st1 =
-          FStar_Interactive_PushHelper.push_repl "run_and_rewind"
-            FStar_Interactive_PushHelper.FullCheck
-            FStar_Interactive_JsonHelper.Noop st in
-        let results =
-          try
-            (fun uu___ ->
-               match () with
-               | () ->
-                   FStar_Compiler_Util.with_sigint_handler
-                     FStar_Compiler_Util.sigint_raise
-                     (fun uu___1 ->
-                        let uu___2 = task st1 in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (fun uu___3 -> FStar_Pervasives.Inl uu___3) uu___2))
-              ()
-          with
-          | FStar_Compiler_Util.SigInt -> FStar_Pervasives.Inl sigint_default
-          | e -> FStar_Pervasives.Inr e in
-        let st2 = FStar_Interactive_PushHelper.pop_repl "run_and_rewind" st1 in
-        match results with
-        | FStar_Pervasives.Inl results1 ->
-            (results1, (FStar_Pervasives.Inl st2))
-        | FStar_Pervasives.Inr e -> FStar_Compiler_Effect.raise e
-let run_with_parsed_and_tc_term :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        'uuuuu ->
-          'uuuuu1 ->
-            (FStar_TypeChecker_Env.env ->
-               FStar_Syntax_Syntax.term ->
-                 (query_status * FStar_Compiler_Util.json))
-              ->
-              ((query_status * FStar_Compiler_Util.json) *
-                (FStar_Interactive_JsonHelper.repl_state, 'uuuuu2)
-                FStar_Pervasives.either)
-  =
-  fun st ->
-    fun term ->
-      fun line ->
-        fun column ->
-          fun continuation ->
-            let dummy_let_fragment term1 =
-              let dummy_decl =
-                FStar_Compiler_Util.format1 "let __compute_dummy__ = (%s)"
-                  term1 in
-              {
-                FStar_Parser_ParseIt.frag_fname = " input";
-                FStar_Parser_ParseIt.frag_text = dummy_decl;
-                FStar_Parser_ParseIt.frag_line = Prims.int_zero;
-                FStar_Parser_ParseIt.frag_col = Prims.int_zero
-              } in
-            let find_let_body ses =
-              match ses with
-              | {
-                  FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_let
-                    ((uu___,
-                      { FStar_Syntax_Syntax.lbname = uu___1;
-                        FStar_Syntax_Syntax.lbunivs = univs;
-                        FStar_Syntax_Syntax.lbtyp = uu___2;
-                        FStar_Syntax_Syntax.lbeff = uu___3;
-                        FStar_Syntax_Syntax.lbdef = def;
-                        FStar_Syntax_Syntax.lbattrs = uu___4;
-                        FStar_Syntax_Syntax.lbpos = uu___5;_}::[]),
-                     uu___6);
-                  FStar_Syntax_Syntax.sigrng = uu___7;
-                  FStar_Syntax_Syntax.sigquals = uu___8;
-                  FStar_Syntax_Syntax.sigmeta = uu___9;
-                  FStar_Syntax_Syntax.sigattrs = uu___10;
-                  FStar_Syntax_Syntax.sigopts = uu___11;_}::[] ->
-                  FStar_Pervasives_Native.Some (univs, def)
-              | uu___ -> FStar_Pervasives_Native.None in
-            let parse frag =
-              let uu___ =
-                FStar_Parser_ParseIt.parse
-                  (FStar_Parser_ParseIt.Toplevel frag) in
-              match uu___ with
-              | FStar_Parser_ParseIt.ASTFragment
-                  (FStar_Pervasives.Inr decls, uu___1) ->
-                  FStar_Pervasives_Native.Some decls
-              | uu___1 -> FStar_Pervasives_Native.None in
-            let desugar env decls =
-              let uu___ =
-                let uu___1 = FStar_ToSyntax_ToSyntax.decls_to_sigelts decls in
-                uu___1 env.FStar_TypeChecker_Env.dsenv in
-              FStar_Pervasives_Native.fst uu___ in
-            let typecheck tcenv decls =
-              let uu___ = FStar_TypeChecker_Tc.tc_decls tcenv decls in
-              match uu___ with | (ses, uu___1) -> ses in
-            run_and_rewind st
-              (QueryNOK,
-                (FStar_Compiler_Util.JsonStr "Computation interrupted"))
-              (fun st1 ->
-                 let tcenv = st1.FStar_Interactive_JsonHelper.repl_env in
-                 let frag = dummy_let_fragment term in
-                 let uu___ = parse frag in
-                 match uu___ with
-                 | FStar_Pervasives_Native.None ->
-                     (QueryNOK,
-                       (FStar_Compiler_Util.JsonStr
-                          "Could not parse this term"))
-                 | FStar_Pervasives_Native.Some decls ->
-                     let aux uu___1 =
-                       let decls1 = desugar tcenv decls in
-                       let ses = typecheck tcenv decls1 in
-                       match find_let_body ses with
-                       | FStar_Pervasives_Native.None ->
-                           (QueryNOK,
-                             (FStar_Compiler_Util.JsonStr
-                                "Typechecking yielded an unexpected term"))
-                       | FStar_Pervasives_Native.Some (univs, def) ->
-                           let uu___2 =
-                             FStar_Syntax_Subst.open_univ_vars univs def in
-                           (match uu___2 with
-                            | (univs1, def1) ->
-                                let tcenv1 =
-                                  FStar_TypeChecker_Env.push_univ_vars tcenv
-                                    univs1 in
-                                continuation tcenv1 def1) in
-                     let uu___1 = FStar_Options.trace_error () in
-                     if uu___1
-                     then aux ()
-                     else
-                       (try (fun uu___3 -> match () with | () -> aux ()) ()
-                        with
-                        | uu___3 ->
-                            let uu___4 = FStar_Errors.issue_of_exn uu___3 in
-                            (match uu___4 with
-                             | FStar_Pervasives_Native.Some issue ->
-                                 let uu___5 =
-                                   let uu___6 =
-                                     FStar_Errors.format_issue issue in
-                                   FStar_Compiler_Util.JsonStr uu___6 in
-                                 (QueryNOK, uu___5)
-                             | FStar_Pervasives_Native.None ->
-                                 FStar_Compiler_Effect.raise uu___3)))
-let run_compute :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        FStar_TypeChecker_Env.step Prims.list FStar_Pervasives_Native.option
-          ->
-          ((query_status * FStar_Compiler_Util.json) *
-            (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-            FStar_Pervasives.either)
-  =
-  fun st ->
-    fun term ->
-      fun rules ->
-        let rules1 =
-          FStar_Compiler_List.op_At
-            (match rules with
-             | FStar_Pervasives_Native.Some rules2 -> rules2
-             | FStar_Pervasives_Native.None ->
-                 [FStar_TypeChecker_Env.Beta;
-                 FStar_TypeChecker_Env.Iota;
-                 FStar_TypeChecker_Env.Zeta;
-                 FStar_TypeChecker_Env.UnfoldUntil
-                   FStar_Syntax_Syntax.delta_constant])
-            [FStar_TypeChecker_Env.Inlining;
-            FStar_TypeChecker_Env.Eager_unfolding;
-            FStar_TypeChecker_Env.UnfoldTac;
-            FStar_TypeChecker_Env.Primops] in
-        let normalize_term tcenv rules2 t =
-          FStar_TypeChecker_Normalize.normalize rules2 tcenv t in
-        run_with_parsed_and_tc_term st term Prims.int_zero Prims.int_zero
-          (fun tcenv ->
-             fun def ->
-               let normalized = normalize_term tcenv rules1 def in
-               let uu___ =
-                 let uu___1 =
-                   FStar_Interactive_QueryHelper.term_to_string tcenv
-                     normalized in
-                 FStar_Compiler_Util.JsonStr uu___1 in
-               (QueryOK, uu___))
-type search_term' =
-  | NameContainsStr of Prims.string 
-  | TypeContainsLid of FStar_Ident.lid 
-and search_term = {
-  st_negate: Prims.bool ;
-  st_term: search_term' }
-let (uu___is_NameContainsStr : search_term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NameContainsStr _0 -> true | uu___ -> false
-let (__proj__NameContainsStr__item___0 : search_term' -> Prims.string) =
-  fun projectee -> match projectee with | NameContainsStr _0 -> _0
-let (uu___is_TypeContainsLid : search_term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TypeContainsLid _0 -> true | uu___ -> false
-let (__proj__TypeContainsLid__item___0 : search_term' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | TypeContainsLid _0 -> _0
-let (__proj__Mksearch_term__item__st_negate : search_term -> Prims.bool) =
-  fun projectee ->
-    match projectee with | { st_negate; st_term;_} -> st_negate
-let (__proj__Mksearch_term__item__st_term : search_term -> search_term') =
-  fun projectee -> match projectee with | { st_negate; st_term;_} -> st_term
-let (st_cost : search_term' -> Prims.int) =
-  fun uu___ ->
-    match uu___ with
-    | NameContainsStr str -> - (FStar_String.length str)
-    | TypeContainsLid lid -> Prims.int_one
-type search_candidate =
-  {
-  sc_lid: FStar_Ident.lid ;
-  sc_typ:
-    FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref
-    ;
-  sc_fvars:
-    FStar_Ident.lid FStar_Compiler_Util.set FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref
-    }
-let (__proj__Mksearch_candidate__item__sc_lid :
-  search_candidate -> FStar_Ident.lid) =
-  fun projectee ->
-    match projectee with | { sc_lid; sc_typ; sc_fvars;_} -> sc_lid
-let (__proj__Mksearch_candidate__item__sc_typ :
-  search_candidate ->
-    FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref)
-  =
-  fun projectee ->
-    match projectee with | { sc_lid; sc_typ; sc_fvars;_} -> sc_typ
-let (__proj__Mksearch_candidate__item__sc_fvars :
-  search_candidate ->
-    FStar_Ident.lid FStar_Compiler_Util.set FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref)
-  =
-  fun projectee ->
-    match projectee with | { sc_lid; sc_typ; sc_fvars;_} -> sc_fvars
-let (sc_of_lid : FStar_Ident.lid -> search_candidate) =
-  fun lid ->
-    let uu___ = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-    let uu___1 = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-    { sc_lid = lid; sc_typ = uu___; sc_fvars = uu___1 }
-let (sc_typ :
-  FStar_TypeChecker_Env.env -> search_candidate -> FStar_Syntax_Syntax.typ) =
-  fun tcenv ->
-    fun sc ->
-      let uu___ = FStar_Compiler_Effect.op_Bang sc.sc_typ in
-      match uu___ with
-      | FStar_Pervasives_Native.Some t -> t
-      | FStar_Pervasives_Native.None ->
-          let typ =
-            let uu___1 = FStar_TypeChecker_Env.try_lookup_lid tcenv sc.sc_lid in
-            match uu___1 with
-            | FStar_Pervasives_Native.None ->
-                FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-                  FStar_Compiler_Range.dummyRange
-            | FStar_Pervasives_Native.Some ((uu___2, typ1), uu___3) -> typ1 in
-          (FStar_Compiler_Effect.op_Colon_Equals sc.sc_typ
-             (FStar_Pervasives_Native.Some typ);
-           typ)
-let (sc_fvars :
-  FStar_TypeChecker_Env.env ->
-    search_candidate -> FStar_Ident.lident FStar_Compiler_Util.set)
-  =
-  fun tcenv ->
-    fun sc ->
-      let uu___ = FStar_Compiler_Effect.op_Bang sc.sc_fvars in
-      match uu___ with
-      | FStar_Pervasives_Native.Some fv -> fv
-      | FStar_Pervasives_Native.None ->
-          let fv =
-            let uu___1 = sc_typ tcenv sc in FStar_Syntax_Free.fvars uu___1 in
-          (FStar_Compiler_Effect.op_Colon_Equals sc.sc_fvars
-             (FStar_Pervasives_Native.Some fv);
-           fv)
-let (json_of_search_result :
-  FStar_TypeChecker_Env.env -> search_candidate -> FStar_Compiler_Util.json)
-  =
-  fun tcenv ->
-    fun sc ->
-      let typ_str =
-        let uu___ = sc_typ tcenv sc in
-        FStar_Interactive_QueryHelper.term_to_string tcenv uu___ in
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Syntax_DsEnv.shorten_lid
-                  tcenv.FStar_TypeChecker_Env.dsenv sc.sc_lid in
-              FStar_Ident.string_of_lid uu___4 in
-            FStar_Compiler_Util.JsonStr uu___3 in
-          ("lid", uu___2) in
-        [uu___1; ("type", (FStar_Compiler_Util.JsonStr typ_str))] in
-      FStar_Compiler_Util.JsonAssoc uu___
-exception InvalidSearch of Prims.string 
-let (uu___is_InvalidSearch : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InvalidSearch uu___ -> true | uu___ -> false
-let (__proj__InvalidSearch__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | InvalidSearch uu___ -> uu___
-let run_search :
-  'uuuuu .
-    FStar_Interactive_JsonHelper.repl_state ->
-      Prims.string ->
-        ((query_status * FStar_Compiler_Util.json) *
-          (FStar_Interactive_JsonHelper.repl_state, 'uuuuu)
-          FStar_Pervasives.either)
-  =
-  fun st ->
-    fun search_str ->
-      let tcenv = st.FStar_Interactive_JsonHelper.repl_env in
-      let empty_fv_set = FStar_Syntax_Syntax.new_fv_set () in
-      let st_matches candidate term =
-        let found =
-          match term.st_term with
-          | NameContainsStr str ->
-              let uu___ = FStar_Ident.string_of_lid candidate.sc_lid in
-              FStar_Compiler_Util.contains uu___ str
-          | TypeContainsLid lid ->
-              let uu___ = sc_fvars tcenv candidate in
-              FStar_Compiler_Util.set_mem lid uu___ in
-        found <> term.st_negate in
-      let parse search_str1 =
-        let parse_one term =
-          let negate = FStar_Compiler_Util.starts_with term "-" in
-          let term1 =
-            if negate
-            then FStar_Compiler_Util.substring_from term Prims.int_one
-            else term in
-          let beg_quote = FStar_Compiler_Util.starts_with term1 "\"" in
-          let end_quote = FStar_Compiler_Util.ends_with term1 "\"" in
-          let strip_quotes str =
-            if (FStar_String.length str) < (Prims.of_int (2))
-            then
-              FStar_Compiler_Effect.raise (InvalidSearch "Empty search term")
-            else
-              FStar_Compiler_Util.substring str Prims.int_one
-                ((FStar_String.length term1) - (Prims.of_int (2))) in
-          let parsed =
-            if beg_quote <> end_quote
-            then
-              let uu___ =
-                let uu___1 =
-                  FStar_Compiler_Util.format1
-                    "Improperly quoted search term: %s" term1 in
-                InvalidSearch uu___1 in
-              FStar_Compiler_Effect.raise uu___
-            else
-              if beg_quote
-              then
-                (let uu___1 = strip_quotes term1 in NameContainsStr uu___1)
-              else
-                (let lid = FStar_Ident.lid_of_str term1 in
-                 let uu___2 =
-                   FStar_Syntax_DsEnv.resolve_to_fully_qualified_name
-                     tcenv.FStar_TypeChecker_Env.dsenv lid in
-                 match uu___2 with
-                 | FStar_Pervasives_Native.None ->
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Compiler_Util.format1 "Unknown identifier: %s"
-                           term1 in
-                       InvalidSearch uu___4 in
-                     FStar_Compiler_Effect.raise uu___3
-                 | FStar_Pervasives_Native.Some lid1 -> TypeContainsLid lid1) in
-          { st_negate = negate; st_term = parsed } in
-        let terms =
-          FStar_Compiler_List.map parse_one
-            (FStar_Compiler_Util.split search_str1 " ") in
-        let cmp x y = (st_cost x.st_term) - (st_cost y.st_term) in
-        FStar_Compiler_Util.sort_with cmp terms in
-      let pprint_one term =
-        let uu___ =
-          match term.st_term with
-          | NameContainsStr s -> FStar_Compiler_Util.format1 "\"%s\"" s
-          | TypeContainsLid l ->
-              let uu___1 = FStar_Ident.string_of_lid l in
-              FStar_Compiler_Util.format1 "%s" uu___1 in
-        Prims.op_Hat (if term.st_negate then "-" else "") uu___ in
-      let results =
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 let terms = parse search_str in
-                 let all_lidents = FStar_TypeChecker_Env.lidents tcenv in
-                 let all_candidates =
-                   FStar_Compiler_List.map sc_of_lid all_lidents in
-                 let matches_all candidate =
-                   FStar_Compiler_List.for_all (st_matches candidate) terms in
-                 let cmp r1 r2 =
-                   let uu___1 = FStar_Ident.string_of_lid r1.sc_lid in
-                   let uu___2 = FStar_Ident.string_of_lid r2.sc_lid in
-                   FStar_Compiler_Util.compare uu___1 uu___2 in
-                 let results1 =
-                   FStar_Compiler_List.filter matches_all all_candidates in
-                 let sorted = FStar_Compiler_Util.sort_with cmp results1 in
-                 let js =
-                   FStar_Compiler_List.map (json_of_search_result tcenv)
-                     sorted in
-                 (match results1 with
-                  | [] ->
-                      let kwds =
-                        let uu___1 = FStar_Compiler_List.map pprint_one terms in
-                        FStar_Compiler_Util.concat_l " " uu___1 in
-                      let uu___1 =
-                        let uu___2 =
-                          FStar_Compiler_Util.format1
-                            "No results found for query [%s]" kwds in
-                        InvalidSearch uu___2 in
-                      FStar_Compiler_Effect.raise uu___1
-                  | uu___1 -> (QueryOK, (FStar_Compiler_Util.JsonList js))))
-            ()
-        with | InvalidSearch s -> (QueryNOK, (FStar_Compiler_Util.JsonStr s)) in
-      (results, (FStar_Pervasives.Inl st))
-let (run_query :
-  FStar_Interactive_JsonHelper.repl_state ->
-    query' ->
-      ((query_status * FStar_Compiler_Util.json) *
-        (FStar_Interactive_JsonHelper.repl_state, Prims.int)
-        FStar_Pervasives.either))
-  =
-  fun st ->
-    fun q ->
-      match q with
-      | Exit -> run_exit st
-      | DescribeProtocol -> run_describe_protocol st
-      | DescribeRepl -> run_describe_repl st
-      | GenericError message -> run_generic_error st message
-      | ProtocolViolation query1 -> run_protocol_violation st query1
-      | Segment c -> run_segment st c
-      | VfsAdd (fname, contents) -> run_vfs_add st fname contents
-      | Push pquery -> run_push st pquery
-      | Pop -> run_pop st
-      | AutoComplete (search_term1, context) ->
-          run_autocomplete st search_term1 context
-      | Lookup (symbol, context, pos_opt, rq_info) ->
-          run_lookup st symbol context pos_opt rq_info
-      | Compute (term, rules) -> run_compute st term rules
-      | Search term -> run_search st term
-let (validate_query :
-  FStar_Interactive_JsonHelper.repl_state -> query -> query) =
-  fun st ->
-    fun q ->
-      match q.qq with
-      | Push
-          { push_kind = FStar_Interactive_PushHelper.SyntaxCheck;
-            push_code = uu___; push_line = uu___1; push_column = uu___2;
-            push_peek_only = false;_}
-          ->
-          {
-            qq =
-              (ProtocolViolation
-                 "Cannot use 'kind': 'syntax' with 'query': 'push'");
-            qid = (q.qid)
-          }
-      | uu___ ->
-          (match st.FStar_Interactive_JsonHelper.repl_curmod with
-           | FStar_Pervasives_Native.None when
-               query_needs_current_module q.qq ->
-               { qq = (GenericError "Current module unset"); qid = (q.qid) }
-           | uu___1 -> q)
-let (validate_and_run_query :
-  FStar_Interactive_JsonHelper.repl_state ->
-    query ->
-      ((query_status * FStar_Compiler_Util.json) *
-        (FStar_Interactive_JsonHelper.repl_state, Prims.int)
-        FStar_Pervasives.either))
-  =
-  fun st ->
-    fun query1 ->
-      let query2 = validate_query st query1 in
-      FStar_Compiler_Effect.op_Colon_Equals repl_current_qid
-        (FStar_Pervasives_Native.Some (query2.qid));
-      run_query st query2.qq
-let (js_repl_eval :
-  FStar_Interactive_JsonHelper.repl_state ->
-    query ->
-      (FStar_Compiler_Util.json * (FStar_Interactive_JsonHelper.repl_state,
-        Prims.int) FStar_Pervasives.either))
-  =
-  fun st ->
-    fun query1 ->
-      let uu___ = validate_and_run_query st query1 in
-      match uu___ with
-      | ((status, response), st_opt) ->
-          let js_response = json_of_response query1.qid status response in
-          (js_response, st_opt)
-let (js_repl_eval_js :
-  FStar_Interactive_JsonHelper.repl_state ->
-    FStar_Compiler_Util.json ->
-      (FStar_Compiler_Util.json * (FStar_Interactive_JsonHelper.repl_state,
-        Prims.int) FStar_Pervasives.either))
-  =
-  fun st ->
-    fun query_js ->
-      let uu___ = deserialize_interactive_query query_js in
-      js_repl_eval st uu___
-let (js_repl_eval_str :
-  FStar_Interactive_JsonHelper.repl_state ->
-    Prims.string ->
-      (Prims.string * (FStar_Interactive_JsonHelper.repl_state, Prims.int)
-        FStar_Pervasives.either))
-  =
-  fun st ->
-    fun query_str ->
-      let uu___ =
-        let uu___1 = parse_interactive_query query_str in
-        js_repl_eval st uu___1 in
-      match uu___ with
-      | (js_response, st_opt) ->
-          let uu___1 = FStar_Compiler_Util.string_of_json js_response in
-          (uu___1, st_opt)
-let (js_repl_init_opts : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.parse_cmd_line () in
-    match uu___1 with
-    | (res, fnames) ->
-        (match res with
-         | FStar_Getopt.Error msg ->
-             failwith (Prims.op_Hat "repl_init: " msg)
-         | FStar_Getopt.Help -> failwith "repl_init: --help unexpected"
-         | FStar_Getopt.Success ->
-             (match fnames with
-              | [] ->
-                  failwith
-                    "repl_init: No file name given in --ide invocation"
-              | h::uu___2::uu___3 ->
-                  failwith
-                    "repl_init: Too many file names given in --ide invocation"
-              | uu___2 -> ()))
-let rec (go : FStar_Interactive_JsonHelper.repl_state -> Prims.int) =
-  fun st ->
-    let query1 =
-      read_interactive_query st.FStar_Interactive_JsonHelper.repl_stdin in
-    let uu___ = validate_and_run_query st query1 in
-    match uu___ with
-    | ((status, response), state_opt) ->
-        (write_response query1.qid status response;
-         (match state_opt with
-          | FStar_Pervasives.Inl st' -> go st'
-          | FStar_Pervasives.Inr exitcode -> exitcode))
-let (interactive_error_handler : FStar_Errors.error_handler) =
-  let issues = FStar_Compiler_Util.mk_ref [] in
-  let add_one e =
-    let uu___ =
-      let uu___1 = FStar_Compiler_Effect.op_Bang issues in e :: uu___1 in
-    FStar_Compiler_Effect.op_Colon_Equals issues uu___ in
-  let count_errors uu___ =
-    let issues1 =
-      let uu___1 = FStar_Compiler_Effect.op_Bang issues in
-      FStar_Compiler_Util.remove_dups (fun i0 -> fun i1 -> i0 = i1) uu___1 in
-    let uu___1 =
-      FStar_Compiler_List.filter
-        (fun e -> e.FStar_Errors.issue_level = FStar_Errors.EError) issues1 in
-    FStar_Compiler_List.length uu___1 in
-  let report uu___ =
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang issues in
-      FStar_Compiler_Util.remove_dups (fun i0 -> fun i1 -> i0 = i1) uu___2 in
-    FStar_Compiler_List.sortWith FStar_Errors.compare_issues uu___1 in
-  let clear uu___ = FStar_Compiler_Effect.op_Colon_Equals issues [] in
-  {
-    FStar_Errors.eh_add_one = add_one;
-    FStar_Errors.eh_count_errors = count_errors;
-    FStar_Errors.eh_report = report;
-    FStar_Errors.eh_clear = clear
-  }
-let (interactive_printer :
-  (FStar_Compiler_Util.json -> unit) -> FStar_Compiler_Util.printer) =
-  fun printer ->
-    {
-      FStar_Compiler_Util.printer_prinfo =
-        (fun s ->
-           forward_message printer "info" (FStar_Compiler_Util.JsonStr s));
-      FStar_Compiler_Util.printer_prwarning =
-        (fun s ->
-           forward_message printer "warning" (FStar_Compiler_Util.JsonStr s));
-      FStar_Compiler_Util.printer_prerror =
-        (fun s ->
-           forward_message printer "error" (FStar_Compiler_Util.JsonStr s));
-      FStar_Compiler_Util.printer_prgeneric =
-        (fun label ->
-           fun get_string ->
-             fun get_json ->
-               let uu___ = get_json () in forward_message printer label uu___)
-    }
-let (install_ide_mode_hooks : (FStar_Compiler_Util.json -> unit) -> unit) =
-  fun printer ->
-    FStar_Compiler_Util.set_printer (interactive_printer printer);
-    FStar_Errors.set_handler interactive_error_handler
-let (initial_range : FStar_Compiler_Range.range) =
-  let uu___ = FStar_Compiler_Range.mk_pos Prims.int_one Prims.int_zero in
-  let uu___1 = FStar_Compiler_Range.mk_pos Prims.int_one Prims.int_zero in
-  FStar_Compiler_Range.mk_range "<input>" uu___ uu___1
-let (build_initial_repl_state :
-  Prims.string -> FStar_Interactive_JsonHelper.repl_state) =
-  fun filename ->
-    let env = FStar_Universal.init_env FStar_Parser_Dep.empty_deps in
-    let env1 = FStar_TypeChecker_Env.set_range env initial_range in
-    let uu___ = FStar_Compiler_Util.open_stdin () in
-    {
-      FStar_Interactive_JsonHelper.repl_line = Prims.int_one;
-      FStar_Interactive_JsonHelper.repl_column = Prims.int_zero;
-      FStar_Interactive_JsonHelper.repl_fname = filename;
-      FStar_Interactive_JsonHelper.repl_deps_stack = [];
-      FStar_Interactive_JsonHelper.repl_curmod = FStar_Pervasives_Native.None;
-      FStar_Interactive_JsonHelper.repl_env = env1;
-      FStar_Interactive_JsonHelper.repl_stdin = uu___;
-      FStar_Interactive_JsonHelper.repl_names =
-        FStar_Interactive_CompletionTable.empty
-    }
-let interactive_mode' :
-  'uuuuu . FStar_Interactive_JsonHelper.repl_state -> 'uuuuu =
-  fun init_st ->
-    write_hello ();
-    (let exit_code =
-       let uu___1 =
-         (FStar_Options.record_hints ()) || (FStar_Options.use_hints ()) in
-       if uu___1
-       then
-         let uu___2 =
-           let uu___3 = FStar_Options.file_list () in
-           FStar_Compiler_List.hd uu___3 in
-         FStar_SMTEncoding_Solver.with_hints_db uu___2
-           (fun uu___3 -> go init_st)
-       else go init_st in
-     FStar_Compiler_Effect.exit exit_code)
-let (interactive_mode : Prims.string -> unit) =
-  fun filename ->
-    install_ide_mode_hooks FStar_Interactive_JsonHelper.write_json;
-    FStar_Compiler_Util.set_sigint_handler FStar_Compiler_Util.sigint_ignore;
-    (let uu___3 =
-       let uu___4 = FStar_Options.codegen () in
-       FStar_Compiler_Option.isSome uu___4 in
-     if uu___3
-     then
-       FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-         (FStar_Errors.Warning_IDEIgnoreCodeGen, "--ide: ignoring --codegen")
-     else ());
-    (let init = build_initial_repl_state filename in
-     let uu___3 = FStar_Options.trace_error () in
-     if uu___3
-     then interactive_mode' init
-     else
-       (try (fun uu___5 -> match () with | () -> interactive_mode' init) ()
-        with
-        | uu___5 ->
-            (FStar_Errors.set_handler FStar_Errors.default_handler;
-             FStar_Compiler_Effect.raise uu___5)))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_JsonHelper.ml b/src/ocaml-output/FStar_Interactive_JsonHelper.ml
deleted file mode 100644
index 4a81467f69f..00000000000
--- a/src/ocaml-output/FStar_Interactive_JsonHelper.ml
+++ /dev/null
@@ -1,906 +0,0 @@
-open Prims
-type assoct = (Prims.string * FStar_Compiler_Util.json) Prims.list
-let (try_assoc :
-  Prims.string ->
-    assoct -> FStar_Compiler_Util.json FStar_Pervasives_Native.option)
-  =
-  fun key ->
-    fun d ->
-      let uu___ =
-        FStar_Compiler_Util.try_find
-          (fun uu___1 -> match uu___1 with | (k, uu___2) -> k = key) d in
-      FStar_Compiler_Util.map_option FStar_Pervasives_Native.snd uu___
-exception MissingKey of Prims.string 
-let (uu___is_MissingKey : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MissingKey uu___ -> true | uu___ -> false
-let (__proj__MissingKey__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | MissingKey uu___ -> uu___
-exception InvalidQuery of Prims.string 
-let (uu___is_InvalidQuery : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InvalidQuery uu___ -> true | uu___ -> false
-let (__proj__InvalidQuery__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | InvalidQuery uu___ -> uu___
-exception UnexpectedJsonType of (Prims.string * FStar_Compiler_Util.json) 
-let (uu___is_UnexpectedJsonType : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnexpectedJsonType uu___ -> true | uu___ -> false
-let (__proj__UnexpectedJsonType__item__uu___ :
-  Prims.exn -> (Prims.string * FStar_Compiler_Util.json)) =
-  fun projectee -> match projectee with | UnexpectedJsonType uu___ -> uu___
-exception MalformedHeader 
-let (uu___is_MalformedHeader : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MalformedHeader -> true | uu___ -> false
-exception InputExhausted 
-let (uu___is_InputExhausted : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InputExhausted -> true | uu___ -> false
-let (assoc : Prims.string -> assoct -> FStar_Compiler_Util.json) =
-  fun key ->
-    fun a ->
-      let uu___ = try_assoc key a in
-      match uu___ with
-      | FStar_Pervasives_Native.Some v -> v
-      | FStar_Pervasives_Native.None ->
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Util.format1 "Missing key [%s]" key in
-            MissingKey uu___2 in
-          FStar_Compiler_Effect.raise uu___1
-let (write_json : FStar_Compiler_Util.json -> unit) =
-  fun js ->
-    (let uu___1 = FStar_Compiler_Util.string_of_json js in
-     FStar_Compiler_Util.print_raw uu___1);
-    FStar_Compiler_Util.print_raw "\n"
-let (write_jsonrpc : FStar_Compiler_Util.json -> unit) =
-  fun js ->
-    let js_str = FStar_Compiler_Util.string_of_json js in
-    let len = FStar_Compiler_Util.string_of_int (FStar_String.length js_str) in
-    let uu___ =
-      FStar_Compiler_Util.format2 "Content-Length: %s\r\n\r\n%s" len js_str in
-    FStar_Compiler_Util.print_raw uu___
-let js_fail : 'a . Prims.string -> FStar_Compiler_Util.json -> 'a =
-  fun expected ->
-    fun got ->
-      FStar_Compiler_Effect.raise (UnexpectedJsonType (expected, got))
-let (js_int : FStar_Compiler_Util.json -> Prims.int) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonInt i -> i
-    | other -> js_fail "int" other
-let (js_str : FStar_Compiler_Util.json -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonStr s -> s
-    | other -> js_fail "string" other
-let js_list :
-  'a .
-    (FStar_Compiler_Util.json -> 'a) ->
-      FStar_Compiler_Util.json -> 'a Prims.list
-  =
-  fun k ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Compiler_Util.JsonList l -> FStar_Compiler_List.map k l
-      | other -> js_fail "list" other
-let (js_assoc : FStar_Compiler_Util.json -> assoct) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonAssoc a -> a
-    | other -> js_fail "dictionary" other
-let (js_str_int : FStar_Compiler_Util.json -> Prims.int) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonInt i -> i
-    | FStar_Compiler_Util.JsonStr s -> FStar_Compiler_Util.int_of_string s
-    | other -> js_fail "string or int" other
-let (arg : Prims.string -> assoct -> FStar_Compiler_Util.json) =
-  fun k ->
-    fun r ->
-      let uu___ =
-        let uu___1 = assoc "params" r in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1 js_assoc in
-      assoc k uu___
-let (uri_to_path : Prims.string -> Prims.string) =
-  fun u ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Util.substring u (Prims.of_int (9)) (Prims.of_int (3)) in
-      uu___1 = "%3A" in
-    if uu___
-    then
-      let uu___1 =
-        FStar_Compiler_Util.substring u (Prims.of_int (8)) Prims.int_one in
-      let uu___2 = FStar_Compiler_Util.substring_from u (Prims.of_int (12)) in
-      FStar_Compiler_Util.format2 "%s:%s" uu___1 uu___2
-    else FStar_Compiler_Util.substring_from u (Prims.of_int (7))
-type completion_context =
-  {
-  trigger_kind: Prims.int ;
-  trigger_char: Prims.string FStar_Pervasives_Native.option }
-let (__proj__Mkcompletion_context__item__trigger_kind :
-  completion_context -> Prims.int) =
-  fun projectee ->
-    match projectee with | { trigger_kind; trigger_char;_} -> trigger_kind
-let (__proj__Mkcompletion_context__item__trigger_char :
-  completion_context -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with | { trigger_kind; trigger_char;_} -> trigger_char
-let (path_to_uri : Prims.string -> Prims.string) =
-  fun u ->
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.char_at u Prims.int_one in uu___1 = 58 in
-    if uu___
-    then
-      let rest =
-        let uu___1 = FStar_Compiler_Util.substring_from u (Prims.of_int (2)) in
-        FStar_Compiler_Util.replace_char uu___1 92 47 in
-      let uu___1 =
-        FStar_Compiler_Util.substring u Prims.int_zero Prims.int_one in
-      FStar_Compiler_Util.format2 "file:///%s%3A%s" uu___1 rest
-    else FStar_Compiler_Util.format1 "file://%s" u
-let (js_compl_context : FStar_Compiler_Util.json -> completion_context) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonAssoc a ->
-        let uu___1 =
-          let uu___2 = assoc "triggerKind" a in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2 js_int in
-        let uu___2 =
-          let uu___3 = try_assoc "triggerChar" a in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3
-            (FStar_Compiler_Util.map_option js_str) in
-        { trigger_kind = uu___1; trigger_char = uu___2 }
-    | other -> js_fail "dictionary" other
-type txdoc_item =
-  {
-  fname: Prims.string ;
-  langId: Prims.string ;
-  version: Prims.int ;
-  text: Prims.string }
-let (__proj__Mktxdoc_item__item__fname : txdoc_item -> Prims.string) =
-  fun projectee ->
-    match projectee with | { fname; langId; version; text;_} -> fname
-let (__proj__Mktxdoc_item__item__langId : txdoc_item -> Prims.string) =
-  fun projectee ->
-    match projectee with | { fname; langId; version; text;_} -> langId
-let (__proj__Mktxdoc_item__item__version : txdoc_item -> Prims.int) =
-  fun projectee ->
-    match projectee with | { fname; langId; version; text;_} -> version
-let (__proj__Mktxdoc_item__item__text : txdoc_item -> Prims.string) =
-  fun projectee ->
-    match projectee with | { fname; langId; version; text;_} -> text
-let (js_txdoc_item : FStar_Compiler_Util.json -> txdoc_item) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonAssoc a ->
-        let arg1 k = assoc k a in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = arg1 "uri" in
-            FStar_Compiler_Effect.op_Bar_Greater uu___3 js_str in
-          uri_to_path uu___2 in
-        let uu___2 =
-          let uu___3 = arg1 "languageId" in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3 js_str in
-        let uu___3 =
-          let uu___4 = arg1 "version" in
-          FStar_Compiler_Effect.op_Bar_Greater uu___4 js_int in
-        let uu___4 =
-          let uu___5 = arg1 "text" in
-          FStar_Compiler_Effect.op_Bar_Greater uu___5 js_str in
-        { fname = uu___1; langId = uu___2; version = uu___3; text = uu___4 }
-    | other -> js_fail "dictionary" other
-type txdoc_pos = {
-  path: Prims.string ;
-  line: Prims.int ;
-  col: Prims.int }
-let (__proj__Mktxdoc_pos__item__path : txdoc_pos -> Prims.string) =
-  fun projectee -> match projectee with | { path; line; col;_} -> path
-let (__proj__Mktxdoc_pos__item__line : txdoc_pos -> Prims.int) =
-  fun projectee -> match projectee with | { path; line; col;_} -> line
-let (__proj__Mktxdoc_pos__item__col : txdoc_pos -> Prims.int) =
-  fun projectee -> match projectee with | { path; line; col;_} -> col
-let (js_txdoc_id : assoct -> Prims.string) =
-  fun r ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = arg "textDocument" r in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3 js_assoc in
-        assoc "uri" uu___2 in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 js_str in
-    uri_to_path uu___
-let (js_txdoc_pos : assoct -> txdoc_pos) =
-  fun r ->
-    let pos =
-      let uu___ = arg "position" r in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ js_assoc in
-    let uu___ = js_txdoc_id r in
-    let uu___1 =
-      let uu___2 = assoc "line" pos in
-      FStar_Compiler_Effect.op_Bar_Greater uu___2 js_int in
-    let uu___2 =
-      let uu___3 = assoc "character" pos in
-      FStar_Compiler_Effect.op_Bar_Greater uu___3 js_int in
-    { path = uu___; line = uu___1; col = uu___2 }
-type workspace_folder = {
-  wk_uri: Prims.string ;
-  wk_name: Prims.string }
-let (__proj__Mkworkspace_folder__item__wk_uri :
-  workspace_folder -> Prims.string) =
-  fun projectee -> match projectee with | { wk_uri; wk_name;_} -> wk_uri
-let (__proj__Mkworkspace_folder__item__wk_name :
-  workspace_folder -> Prims.string) =
-  fun projectee -> match projectee with | { wk_uri; wk_name;_} -> wk_name
-type wsch_event = {
-  added: workspace_folder ;
-  removed: workspace_folder }
-let (__proj__Mkwsch_event__item__added : wsch_event -> workspace_folder) =
-  fun projectee -> match projectee with | { added; removed;_} -> added
-let (__proj__Mkwsch_event__item__removed : wsch_event -> workspace_folder) =
-  fun projectee -> match projectee with | { added; removed;_} -> removed
-let (js_wsch_event : FStar_Compiler_Util.json -> wsch_event) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonAssoc a ->
-        let added' =
-          let uu___1 = assoc "added" a in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1 js_assoc in
-        let removed' =
-          let uu___1 = assoc "removed" a in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1 js_assoc in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = assoc "uri" added' in
-            FStar_Compiler_Effect.op_Bar_Greater uu___3 js_str in
-          let uu___3 =
-            let uu___4 = assoc "name" added' in
-            FStar_Compiler_Effect.op_Bar_Greater uu___4 js_str in
-          { wk_uri = uu___2; wk_name = uu___3 } in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = assoc "uri" removed' in
-            FStar_Compiler_Effect.op_Bar_Greater uu___4 js_str in
-          let uu___4 =
-            let uu___5 = assoc "name" removed' in
-            FStar_Compiler_Effect.op_Bar_Greater uu___5 js_str in
-          { wk_uri = uu___3; wk_name = uu___4 } in
-        { added = uu___1; removed = uu___2 }
-    | other -> js_fail "dictionary" other
-let (js_contentch : FStar_Compiler_Util.json -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonList l ->
-        let uu___1 =
-          FStar_Compiler_List.map
-            (fun uu___2 ->
-               match uu___2 with
-               | FStar_Compiler_Util.JsonAssoc a ->
-                   let uu___3 = assoc "text" a in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___3 js_str) l in
-        FStar_Compiler_List.hd uu___1
-    | other -> js_fail "dictionary" other
-type lquery =
-  | Initialize of (Prims.int * Prims.string) 
-  | Initialized 
-  | Shutdown 
-  | Exit 
-  | Cancel of Prims.int 
-  | FolderChange of wsch_event 
-  | ChangeConfig 
-  | ChangeWatch 
-  | Symbol of Prims.string 
-  | ExecCommand of Prims.string 
-  | DidOpen of txdoc_item 
-  | DidChange of (Prims.string * Prims.string) 
-  | WillSave of Prims.string 
-  | WillSaveWait of Prims.string 
-  | DidSave of (Prims.string * Prims.string) 
-  | DidClose of Prims.string 
-  | Completion of (txdoc_pos * completion_context) 
-  | Resolve 
-  | Hover of txdoc_pos 
-  | SignatureHelp of txdoc_pos 
-  | Declaration of txdoc_pos 
-  | Definition of txdoc_pos 
-  | TypeDefinition of txdoc_pos 
-  | Implementation of txdoc_pos 
-  | References 
-  | DocumentHighlight of txdoc_pos 
-  | DocumentSymbol 
-  | CodeAction 
-  | CodeLens 
-  | CodeLensResolve 
-  | DocumentLink 
-  | DocumentLinkResolve 
-  | DocumentColor 
-  | ColorPresentation 
-  | Formatting 
-  | RangeFormatting 
-  | TypeFormatting 
-  | Rename 
-  | PrepareRename of txdoc_pos 
-  | FoldingRange 
-  | BadProtocolMsg of Prims.string 
-let (uu___is_Initialize : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Initialize _0 -> true | uu___ -> false
-let (__proj__Initialize__item___0 : lquery -> (Prims.int * Prims.string)) =
-  fun projectee -> match projectee with | Initialize _0 -> _0
-let (uu___is_Initialized : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Initialized -> true | uu___ -> false
-let (uu___is_Shutdown : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Shutdown -> true | uu___ -> false
-let (uu___is_Exit : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Exit -> true | uu___ -> false
-let (uu___is_Cancel : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Cancel _0 -> true | uu___ -> false
-let (__proj__Cancel__item___0 : lquery -> Prims.int) =
-  fun projectee -> match projectee with | Cancel _0 -> _0
-let (uu___is_FolderChange : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FolderChange _0 -> true | uu___ -> false
-let (__proj__FolderChange__item___0 : lquery -> wsch_event) =
-  fun projectee -> match projectee with | FolderChange _0 -> _0
-let (uu___is_ChangeConfig : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ChangeConfig -> true | uu___ -> false
-let (uu___is_ChangeWatch : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ChangeWatch -> true | uu___ -> false
-let (uu___is_Symbol : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Symbol _0 -> true | uu___ -> false
-let (__proj__Symbol__item___0 : lquery -> Prims.string) =
-  fun projectee -> match projectee with | Symbol _0 -> _0
-let (uu___is_ExecCommand : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ExecCommand _0 -> true | uu___ -> false
-let (__proj__ExecCommand__item___0 : lquery -> Prims.string) =
-  fun projectee -> match projectee with | ExecCommand _0 -> _0
-let (uu___is_DidOpen : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | DidOpen _0 -> true | uu___ -> false
-let (__proj__DidOpen__item___0 : lquery -> txdoc_item) =
-  fun projectee -> match projectee with | DidOpen _0 -> _0
-let (uu___is_DidChange : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DidChange _0 -> true | uu___ -> false
-let (__proj__DidChange__item___0 : lquery -> (Prims.string * Prims.string)) =
-  fun projectee -> match projectee with | DidChange _0 -> _0
-let (uu___is_WillSave : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | WillSave _0 -> true | uu___ -> false
-let (__proj__WillSave__item___0 : lquery -> Prims.string) =
-  fun projectee -> match projectee with | WillSave _0 -> _0
-let (uu___is_WillSaveWait : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | WillSaveWait _0 -> true | uu___ -> false
-let (__proj__WillSaveWait__item___0 : lquery -> Prims.string) =
-  fun projectee -> match projectee with | WillSaveWait _0 -> _0
-let (uu___is_DidSave : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | DidSave _0 -> true | uu___ -> false
-let (__proj__DidSave__item___0 : lquery -> (Prims.string * Prims.string)) =
-  fun projectee -> match projectee with | DidSave _0 -> _0
-let (uu___is_DidClose : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DidClose _0 -> true | uu___ -> false
-let (__proj__DidClose__item___0 : lquery -> Prims.string) =
-  fun projectee -> match projectee with | DidClose _0 -> _0
-let (uu___is_Completion : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Completion _0 -> true | uu___ -> false
-let (__proj__Completion__item___0 :
-  lquery -> (txdoc_pos * completion_context)) =
-  fun projectee -> match projectee with | Completion _0 -> _0
-let (uu___is_Resolve : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Resolve -> true | uu___ -> false
-let (uu___is_Hover : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Hover _0 -> true | uu___ -> false
-let (__proj__Hover__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | Hover _0 -> _0
-let (uu___is_SignatureHelp : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SignatureHelp _0 -> true | uu___ -> false
-let (__proj__SignatureHelp__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | SignatureHelp _0 -> _0
-let (uu___is_Declaration : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Declaration _0 -> true | uu___ -> false
-let (__proj__Declaration__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | Declaration _0 -> _0
-let (uu___is_Definition : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Definition _0 -> true | uu___ -> false
-let (__proj__Definition__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | Definition _0 -> _0
-let (uu___is_TypeDefinition : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TypeDefinition _0 -> true | uu___ -> false
-let (__proj__TypeDefinition__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | TypeDefinition _0 -> _0
-let (uu___is_Implementation : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Implementation _0 -> true | uu___ -> false
-let (__proj__Implementation__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | Implementation _0 -> _0
-let (uu___is_References : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | References -> true | uu___ -> false
-let (uu___is_DocumentHighlight : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DocumentHighlight _0 -> true | uu___ -> false
-let (__proj__DocumentHighlight__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | DocumentHighlight _0 -> _0
-let (uu___is_DocumentSymbol : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DocumentSymbol -> true | uu___ -> false
-let (uu___is_CodeAction : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | CodeAction -> true | uu___ -> false
-let (uu___is_CodeLens : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | CodeLens -> true | uu___ -> false
-let (uu___is_CodeLensResolve : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CodeLensResolve -> true | uu___ -> false
-let (uu___is_DocumentLink : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DocumentLink -> true | uu___ -> false
-let (uu___is_DocumentLinkResolve : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DocumentLinkResolve -> true | uu___ -> false
-let (uu___is_DocumentColor : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DocumentColor -> true | uu___ -> false
-let (uu___is_ColorPresentation : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ColorPresentation -> true | uu___ -> false
-let (uu___is_Formatting : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Formatting -> true | uu___ -> false
-let (uu___is_RangeFormatting : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RangeFormatting -> true | uu___ -> false
-let (uu___is_TypeFormatting : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TypeFormatting -> true | uu___ -> false
-let (uu___is_Rename : lquery -> Prims.bool) =
-  fun projectee -> match projectee with | Rename -> true | uu___ -> false
-let (uu___is_PrepareRename : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PrepareRename _0 -> true | uu___ -> false
-let (__proj__PrepareRename__item___0 : lquery -> txdoc_pos) =
-  fun projectee -> match projectee with | PrepareRename _0 -> _0
-let (uu___is_FoldingRange : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FoldingRange -> true | uu___ -> false
-let (uu___is_BadProtocolMsg : lquery -> Prims.bool) =
-  fun projectee ->
-    match projectee with | BadProtocolMsg _0 -> true | uu___ -> false
-let (__proj__BadProtocolMsg__item___0 : lquery -> Prims.string) =
-  fun projectee -> match projectee with | BadProtocolMsg _0 -> _0
-type lsp_query =
-  {
-  query_id: Prims.int FStar_Pervasives_Native.option ;
-  q: lquery }
-let (__proj__Mklsp_query__item__query_id :
-  lsp_query -> Prims.int FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | { query_id; q;_} -> query_id
-let (__proj__Mklsp_query__item__q : lsp_query -> lquery) =
-  fun projectee -> match projectee with | { query_id; q;_} -> q
-type repl_depth_t = (FStar_TypeChecker_Env.tcenv_depth_t * Prims.int)
-type optmod_t = FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option
-type timed_fname =
-  {
-  tf_fname: Prims.string ;
-  tf_modtime: FStar_Compiler_Util.time }
-let (__proj__Mktimed_fname__item__tf_fname : timed_fname -> Prims.string) =
-  fun projectee ->
-    match projectee with | { tf_fname; tf_modtime;_} -> tf_fname
-let (__proj__Mktimed_fname__item__tf_modtime :
-  timed_fname -> FStar_Compiler_Util.time) =
-  fun projectee ->
-    match projectee with | { tf_fname; tf_modtime;_} -> tf_modtime
-type repl_task =
-  | LDInterleaved of (timed_fname * timed_fname) 
-  | LDSingle of timed_fname 
-  | LDInterfaceOfCurrentFile of timed_fname 
-  | PushFragment of FStar_Parser_ParseIt.input_frag 
-  | Noop 
-let (uu___is_LDInterleaved : repl_task -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LDInterleaved _0 -> true | uu___ -> false
-let (__proj__LDInterleaved__item___0 :
-  repl_task -> (timed_fname * timed_fname)) =
-  fun projectee -> match projectee with | LDInterleaved _0 -> _0
-let (uu___is_LDSingle : repl_task -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LDSingle _0 -> true | uu___ -> false
-let (__proj__LDSingle__item___0 : repl_task -> timed_fname) =
-  fun projectee -> match projectee with | LDSingle _0 -> _0
-let (uu___is_LDInterfaceOfCurrentFile : repl_task -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | LDInterfaceOfCurrentFile _0 -> true
-    | uu___ -> false
-let (__proj__LDInterfaceOfCurrentFile__item___0 : repl_task -> timed_fname) =
-  fun projectee -> match projectee with | LDInterfaceOfCurrentFile _0 -> _0
-let (uu___is_PushFragment : repl_task -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PushFragment _0 -> true | uu___ -> false
-let (__proj__PushFragment__item___0 :
-  repl_task -> FStar_Parser_ParseIt.input_frag) =
-  fun projectee -> match projectee with | PushFragment _0 -> _0
-let (uu___is_Noop : repl_task -> Prims.bool) =
-  fun projectee -> match projectee with | Noop -> true | uu___ -> false
-type repl_state =
-  {
-  repl_line: Prims.int ;
-  repl_column: Prims.int ;
-  repl_fname: Prims.string ;
-  repl_deps_stack: (repl_depth_t * (repl_task * repl_state)) Prims.list ;
-  repl_curmod: optmod_t ;
-  repl_env: FStar_TypeChecker_Env.env ;
-  repl_stdin: FStar_Compiler_Util.stream_reader ;
-  repl_names: FStar_Interactive_CompletionTable.table }
-let (__proj__Mkrepl_state__item__repl_line : repl_state -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_line
-let (__proj__Mkrepl_state__item__repl_column : repl_state -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_column
-let (__proj__Mkrepl_state__item__repl_fname : repl_state -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_fname
-let (__proj__Mkrepl_state__item__repl_deps_stack :
-  repl_state -> (repl_depth_t * (repl_task * repl_state)) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_deps_stack
-let (__proj__Mkrepl_state__item__repl_curmod : repl_state -> optmod_t) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_curmod
-let (__proj__Mkrepl_state__item__repl_env :
-  repl_state -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_env
-let (__proj__Mkrepl_state__item__repl_stdin :
-  repl_state -> FStar_Compiler_Util.stream_reader) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_stdin
-let (__proj__Mkrepl_state__item__repl_names :
-  repl_state -> FStar_Interactive_CompletionTable.table) =
-  fun projectee ->
-    match projectee with
-    | { repl_line; repl_column; repl_fname; repl_deps_stack; repl_curmod;
-        repl_env; repl_stdin; repl_names;_} -> repl_names
-type repl_stack_entry_t = (repl_depth_t * (repl_task * repl_state))
-type repl_stack_t = (repl_depth_t * (repl_task * repl_state)) Prims.list
-type grepl_state =
-  {
-  grepl_repls: repl_state FStar_Compiler_Util.psmap ;
-  grepl_stdin: FStar_Compiler_Util.stream_reader }
-let (__proj__Mkgrepl_state__item__grepl_repls :
-  grepl_state -> repl_state FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with | { grepl_repls; grepl_stdin;_} -> grepl_repls
-let (__proj__Mkgrepl_state__item__grepl_stdin :
-  grepl_state -> FStar_Compiler_Util.stream_reader) =
-  fun projectee ->
-    match projectee with | { grepl_repls; grepl_stdin;_} -> grepl_stdin
-type error_code =
-  | ParseError 
-  | InvalidRequest 
-  | MethodNotFound 
-  | InvalidParams 
-  | InternalError 
-  | ServerErrorStart 
-  | ServerErrorEnd 
-  | ServerNotInitialized 
-  | UnknownErrorCode 
-  | RequestCancelled 
-  | ContentModified 
-let (uu___is_ParseError : error_code -> Prims.bool) =
-  fun projectee -> match projectee with | ParseError -> true | uu___ -> false
-let (uu___is_InvalidRequest : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InvalidRequest -> true | uu___ -> false
-let (uu___is_MethodNotFound : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MethodNotFound -> true | uu___ -> false
-let (uu___is_InvalidParams : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InvalidParams -> true | uu___ -> false
-let (uu___is_InternalError : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InternalError -> true | uu___ -> false
-let (uu___is_ServerErrorStart : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ServerErrorStart -> true | uu___ -> false
-let (uu___is_ServerErrorEnd : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ServerErrorEnd -> true | uu___ -> false
-let (uu___is_ServerNotInitialized : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ServerNotInitialized -> true | uu___ -> false
-let (uu___is_UnknownErrorCode : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnknownErrorCode -> true | uu___ -> false
-let (uu___is_RequestCancelled : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RequestCancelled -> true | uu___ -> false
-let (uu___is_ContentModified : error_code -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ContentModified -> true | uu___ -> false
-type rng =
-  {
-  rng_start: (Prims.int * Prims.int) ;
-  rng_end: (Prims.int * Prims.int) }
-let (__proj__Mkrng__item__rng_start : rng -> (Prims.int * Prims.int)) =
-  fun projectee ->
-    match projectee with | { rng_start; rng_end;_} -> rng_start
-let (__proj__Mkrng__item__rng_end : rng -> (Prims.int * Prims.int)) =
-  fun projectee -> match projectee with | { rng_start; rng_end;_} -> rng_end
-let (js_rng : FStar_Compiler_Util.json -> rng) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonAssoc a ->
-        let st = assoc "start" a in
-        let fin = assoc "end" a in
-        let l = assoc "line" in
-        let c = assoc "character" in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Compiler_Effect.op_Bar_Greater st js_assoc in
-              l uu___4 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___3 js_int in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Compiler_Effect.op_Bar_Greater st js_assoc in
-              c uu___5 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___4 js_int in
-          (uu___2, uu___3) in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Compiler_Effect.op_Bar_Greater fin js_assoc in
-              l uu___5 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___4 js_int in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 = FStar_Compiler_Effect.op_Bar_Greater st js_assoc in
-              c uu___6 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___5 js_int in
-          (uu___3, uu___4) in
-        { rng_start = uu___1; rng_end = uu___2 }
-    | other -> js_fail "dictionary" other
-let (errorcode_to_int : error_code -> Prims.int) =
-  fun uu___ ->
-    match uu___ with
-    | ParseError -> ~- (Prims.of_int (32700))
-    | InvalidRequest -> ~- (Prims.of_int (32600))
-    | MethodNotFound -> ~- (Prims.of_int (32601))
-    | InvalidParams -> ~- (Prims.of_int (32602))
-    | InternalError -> ~- (Prims.of_int (32603))
-    | ServerErrorStart -> ~- (Prims.of_int (32099))
-    | ServerErrorEnd -> ~- (Prims.of_int (32000))
-    | ServerNotInitialized -> ~- (Prims.of_int (32002))
-    | UnknownErrorCode -> ~- (Prims.of_int (32001))
-    | RequestCancelled -> ~- (Prims.of_int (32800))
-    | ContentModified -> ~- (Prims.of_int (32801))
-let (json_debug : FStar_Compiler_Util.json -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Compiler_Util.JsonNull -> "null"
-    | FStar_Compiler_Util.JsonBool b ->
-        FStar_Compiler_Util.format1 "bool (%s)"
-          (if b then "true" else "false")
-    | FStar_Compiler_Util.JsonInt i ->
-        let uu___1 = FStar_Compiler_Util.string_of_int i in
-        FStar_Compiler_Util.format1 "int (%s)" uu___1
-    | FStar_Compiler_Util.JsonStr s ->
-        FStar_Compiler_Util.format1 "string (%s)" s
-    | FStar_Compiler_Util.JsonList uu___1 -> "list (...)"
-    | FStar_Compiler_Util.JsonAssoc uu___1 -> "dictionary (...)"
-let (wrap_jsfail :
-  Prims.int FStar_Pervasives_Native.option ->
-    Prims.string -> FStar_Compiler_Util.json -> lsp_query)
-  =
-  fun qid ->
-    fun expected ->
-      fun got ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = json_debug got in
-            FStar_Compiler_Util.format2
-              "JSON decoding failed: expected %s, got %s" expected uu___2 in
-          BadProtocolMsg uu___1 in
-        { query_id = qid; q = uu___ }
-let (resultResponse :
-  FStar_Compiler_Util.json -> assoct FStar_Pervasives_Native.option) =
-  fun r -> FStar_Pervasives_Native.Some [("result", r)]
-let (errorResponse :
-  FStar_Compiler_Util.json -> assoct FStar_Pervasives_Native.option) =
-  fun r -> FStar_Pervasives_Native.Some [("error", r)]
-let (nullResponse : assoct FStar_Pervasives_Native.option) =
-  resultResponse FStar_Compiler_Util.JsonNull
-let (json_of_response :
-  Prims.int FStar_Pervasives_Native.option ->
-    assoct -> FStar_Compiler_Util.json)
-  =
-  fun qid ->
-    fun response ->
-      match qid with
-      | FStar_Pervasives_Native.Some i ->
-          FStar_Compiler_Util.JsonAssoc
-            (FStar_Compiler_List.op_At
-               [("jsonrpc", (FStar_Compiler_Util.JsonStr "2.0"));
-               ("id", (FStar_Compiler_Util.JsonInt i))] response)
-      | FStar_Pervasives_Native.None ->
-          FStar_Compiler_Util.JsonAssoc
-            (FStar_Compiler_List.op_At
-               [("jsonrpc", (FStar_Compiler_Util.JsonStr "2.0"))] response)
-let (js_resperr : error_code -> Prims.string -> FStar_Compiler_Util.json) =
-  fun err ->
-    fun msg ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = errorcode_to_int err in
-            FStar_Compiler_Util.JsonInt uu___3 in
-          ("code", uu___2) in
-        [uu___1; ("message", (FStar_Compiler_Util.JsonStr msg))] in
-      FStar_Compiler_Util.JsonAssoc uu___
-let (wrap_content_szerr : Prims.string -> lsp_query) =
-  fun m ->
-    { query_id = FStar_Pervasives_Native.None; q = (BadProtocolMsg m) }
-let (js_servcap : FStar_Compiler_Util.json) =
-  FStar_Compiler_Util.JsonAssoc
-    [("capabilities",
-       (FStar_Compiler_Util.JsonAssoc
-          [("textDocumentSync",
-             (FStar_Compiler_Util.JsonAssoc
-                [("openClose", (FStar_Compiler_Util.JsonBool true));
-                ("change", (FStar_Compiler_Util.JsonInt Prims.int_one));
-                ("willSave", (FStar_Compiler_Util.JsonBool false));
-                ("willSaveWaitUntil", (FStar_Compiler_Util.JsonBool false));
-                ("save",
-                  (FStar_Compiler_Util.JsonAssoc
-                     [("includeText", (FStar_Compiler_Util.JsonBool true))]))]));
-          ("hoverProvider", (FStar_Compiler_Util.JsonBool true));
-          ("completionProvider", (FStar_Compiler_Util.JsonAssoc []));
-          ("signatureHelpProvider", (FStar_Compiler_Util.JsonAssoc []));
-          ("definitionProvider", (FStar_Compiler_Util.JsonBool true));
-          ("typeDefinitionProvider", (FStar_Compiler_Util.JsonBool false));
-          ("implementationProvider", (FStar_Compiler_Util.JsonBool false));
-          ("referencesProvider", (FStar_Compiler_Util.JsonBool false));
-          ("documentSymbolProvider", (FStar_Compiler_Util.JsonBool false));
-          ("workspaceSymbolProvider", (FStar_Compiler_Util.JsonBool false));
-          ("codeActionProvider", (FStar_Compiler_Util.JsonBool false))]))]
-let (js_pos : FStar_Compiler_Range.pos -> FStar_Compiler_Util.json) =
-  fun p ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = FStar_Compiler_Range.line_of_pos p in
-            uu___4 - Prims.int_one in
-          FStar_Compiler_Util.JsonInt uu___3 in
-        ("line", uu___2) in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Range.col_of_pos p in
-            FStar_Compiler_Util.JsonInt uu___5 in
-          ("character", uu___4) in
-        [uu___3] in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.JsonAssoc uu___
-let (js_range : FStar_Compiler_Range.range -> FStar_Compiler_Util.json) =
-  fun r ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Compiler_Range.start_of_range r in js_pos uu___3 in
-        ("start", uu___2) in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Range.end_of_range r in js_pos uu___5 in
-          ("end", uu___4) in
-        [uu___3] in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.JsonAssoc uu___
-let (js_dummyrange : FStar_Compiler_Util.json) =
-  FStar_Compiler_Util.JsonAssoc
-    [("start",
-       (FStar_Compiler_Util.JsonAssoc
-          [("line", (FStar_Compiler_Util.JsonInt Prims.int_zero));
-          ("character", (FStar_Compiler_Util.JsonInt Prims.int_zero));
-          ("end",
-            (FStar_Compiler_Util.JsonAssoc
-               [("line", (FStar_Compiler_Util.JsonInt Prims.int_zero));
-               ("character", (FStar_Compiler_Util.JsonInt Prims.int_zero))]))]))]
-let (js_loclink : FStar_Compiler_Range.range -> FStar_Compiler_Util.json) =
-  fun r ->
-    let s = js_range r in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_Compiler_Range.file_of_range r in
-                path_to_uri uu___6 in
-              FStar_Compiler_Util.JsonStr uu___5 in
-            ("targetUri", uu___4) in
-          [uu___3; ("targetRange", s); ("targetSelectionRange", s)] in
-        FStar_Compiler_Util.JsonAssoc uu___2 in
-      [uu___1] in
-    FStar_Compiler_Util.JsonList uu___
-let (pos_munge : txdoc_pos -> (Prims.string * Prims.int * Prims.int)) =
-  fun pos -> ((pos.path), (pos.line + Prims.int_one), (pos.col))
-let (js_diag :
-  Prims.string ->
-    Prims.string ->
-      FStar_Compiler_Range.range FStar_Pervasives_Native.option -> assoct)
-  =
-  fun fname ->
-    fun msg ->
-      fun r ->
-        let r' =
-          match r with
-          | FStar_Pervasives_Native.Some r1 -> js_range r1
-          | FStar_Pervasives_Native.None -> js_dummyrange in
-        let ds =
-          ("diagnostics",
-            (FStar_Compiler_Util.JsonList
-               [FStar_Compiler_Util.JsonAssoc
-                  [("range", r');
-                  ("message", (FStar_Compiler_Util.JsonStr msg))]])) in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 = path_to_uri fname in
-                    FStar_Compiler_Util.JsonStr uu___6 in
-                  ("uri", uu___5) in
-                [uu___4; ds] in
-              FStar_Compiler_Util.JsonAssoc uu___3 in
-            ("params", uu___2) in
-          [uu___1] in
-        ("method",
-          (FStar_Compiler_Util.JsonStr "textDocument/publishDiagnostics")) ::
-          uu___
-let (js_diag_clear : Prims.string -> assoct) =
-  fun fname ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = path_to_uri fname in
-                FStar_Compiler_Util.JsonStr uu___6 in
-              ("uri", uu___5) in
-            [uu___4; ("diagnostics", (FStar_Compiler_Util.JsonList []))] in
-          FStar_Compiler_Util.JsonAssoc uu___3 in
-        ("params", uu___2) in
-      [uu___1] in
-    ("method",
-      (FStar_Compiler_Util.JsonStr "textDocument/publishDiagnostics")) ::
-      uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_Legacy.ml b/src/ocaml-output/FStar_Interactive_Legacy.ml
deleted file mode 100644
index 60466c32c1d..00000000000
--- a/src/ocaml-output/FStar_Interactive_Legacy.ml
+++ /dev/null
@@ -1,961 +0,0 @@
-open Prims
-let (tc_one_file :
-  Prims.string Prims.list ->
-    FStar_TypeChecker_Env.env ->
-      ((Prims.string FStar_Pervasives_Native.option * Prims.string) *
-        FStar_TypeChecker_Env.env_t * Prims.string Prims.list))
-  =
-  fun remaining ->
-    fun env ->
-      let uu___ =
-        match remaining with
-        | intf::impl::remaining1 when
-            FStar_Universal.needs_interleaving intf impl ->
-            let uu___1 =
-              FStar_Universal.tc_one_file_for_ide env
-                (FStar_Pervasives_Native.Some intf) impl
-                FStar_Parser_Dep.empty_parsing_data in
-            (match uu___1 with
-             | (uu___2, env1) ->
-                 (((FStar_Pervasives_Native.Some intf), impl), env1,
-                   remaining1))
-        | intf_or_impl::remaining1 ->
-            let uu___1 =
-              FStar_Universal.tc_one_file_for_ide env
-                FStar_Pervasives_Native.None intf_or_impl
-                FStar_Parser_Dep.empty_parsing_data in
-            (match uu___1 with
-             | (uu___2, env1) ->
-                 ((FStar_Pervasives_Native.None, intf_or_impl), env1,
-                   remaining1))
-        | [] -> failwith "Impossible" in
-      match uu___ with
-      | ((intf, impl), env1, remaining1) -> ((intf, impl), env1, remaining1)
-type env_t = FStar_TypeChecker_Env.env
-type modul_t = FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option
-type stack_t = (env_t * modul_t) Prims.list
-let (pop : FStar_TypeChecker_Env.env -> Prims.string -> unit) =
-  fun env ->
-    fun msg ->
-      (let uu___1 = FStar_TypeChecker_Tc.pop_context env msg in ());
-      FStar_Options.pop ()
-let (push_with_kind :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool -> Prims.bool -> Prims.string -> FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun lax ->
-      fun restore_cmd_line_options ->
-        fun msg ->
-          let env1 =
-            {
-              FStar_TypeChecker_Env.solver =
-                (env.FStar_TypeChecker_Env.solver);
-              FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-              FStar_TypeChecker_Env.curmodule =
-                (env.FStar_TypeChecker_Env.curmodule);
-              FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-              FStar_TypeChecker_Env.gamma_sig =
-                (env.FStar_TypeChecker_Env.gamma_sig);
-              FStar_TypeChecker_Env.gamma_cache =
-                (env.FStar_TypeChecker_Env.gamma_cache);
-              FStar_TypeChecker_Env.modules =
-                (env.FStar_TypeChecker_Env.modules);
-              FStar_TypeChecker_Env.expected_typ =
-                (env.FStar_TypeChecker_Env.expected_typ);
-              FStar_TypeChecker_Env.sigtab =
-                (env.FStar_TypeChecker_Env.sigtab);
-              FStar_TypeChecker_Env.attrtab =
-                (env.FStar_TypeChecker_Env.attrtab);
-              FStar_TypeChecker_Env.instantiate_imp =
-                (env.FStar_TypeChecker_Env.instantiate_imp);
-              FStar_TypeChecker_Env.effects =
-                (env.FStar_TypeChecker_Env.effects);
-              FStar_TypeChecker_Env.generalize =
-                (env.FStar_TypeChecker_Env.generalize);
-              FStar_TypeChecker_Env.letrecs =
-                (env.FStar_TypeChecker_Env.letrecs);
-              FStar_TypeChecker_Env.top_level =
-                (env.FStar_TypeChecker_Env.top_level);
-              FStar_TypeChecker_Env.check_uvars =
-                (env.FStar_TypeChecker_Env.check_uvars);
-              FStar_TypeChecker_Env.use_eq_strict =
-                (env.FStar_TypeChecker_Env.use_eq_strict);
-              FStar_TypeChecker_Env.is_iface =
-                (env.FStar_TypeChecker_Env.is_iface);
-              FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-              FStar_TypeChecker_Env.lax = lax;
-              FStar_TypeChecker_Env.lax_universes =
-                (env.FStar_TypeChecker_Env.lax_universes);
-              FStar_TypeChecker_Env.phase1 =
-                (env.FStar_TypeChecker_Env.phase1);
-              FStar_TypeChecker_Env.failhard =
-                (env.FStar_TypeChecker_Env.failhard);
-              FStar_TypeChecker_Env.nosynth =
-                (env.FStar_TypeChecker_Env.nosynth);
-              FStar_TypeChecker_Env.uvar_subtyping =
-                (env.FStar_TypeChecker_Env.uvar_subtyping);
-              FStar_TypeChecker_Env.tc_term =
-                (env.FStar_TypeChecker_Env.tc_term);
-              FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-              FStar_TypeChecker_Env.universe_of =
-                (env.FStar_TypeChecker_Env.universe_of);
-              FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-              FStar_TypeChecker_Env.teq_nosmt_force =
-                (env.FStar_TypeChecker_Env.teq_nosmt_force);
-              FStar_TypeChecker_Env.subtype_nosmt_force =
-                (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-              FStar_TypeChecker_Env.qtbl_name_and_index =
-                (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-              FStar_TypeChecker_Env.normalized_eff_names =
-                (env.FStar_TypeChecker_Env.normalized_eff_names);
-              FStar_TypeChecker_Env.fv_delta_depths =
-                (env.FStar_TypeChecker_Env.fv_delta_depths);
-              FStar_TypeChecker_Env.proof_ns =
-                (env.FStar_TypeChecker_Env.proof_ns);
-              FStar_TypeChecker_Env.synth_hook =
-                (env.FStar_TypeChecker_Env.synth_hook);
-              FStar_TypeChecker_Env.try_solve_implicits_hook =
-                (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-              FStar_TypeChecker_Env.splice =
-                (env.FStar_TypeChecker_Env.splice);
-              FStar_TypeChecker_Env.mpreprocess =
-                (env.FStar_TypeChecker_Env.mpreprocess);
-              FStar_TypeChecker_Env.postprocess =
-                (env.FStar_TypeChecker_Env.postprocess);
-              FStar_TypeChecker_Env.identifier_info =
-                (env.FStar_TypeChecker_Env.identifier_info);
-              FStar_TypeChecker_Env.tc_hooks =
-                (env.FStar_TypeChecker_Env.tc_hooks);
-              FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-              FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-              FStar_TypeChecker_Env.strict_args_tab =
-                (env.FStar_TypeChecker_Env.strict_args_tab);
-              FStar_TypeChecker_Env.erasable_types_tab =
-                (env.FStar_TypeChecker_Env.erasable_types_tab);
-              FStar_TypeChecker_Env.enable_defer_to_tac =
-                (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-              FStar_TypeChecker_Env.unif_allow_ref_guards =
-                (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-              FStar_TypeChecker_Env.erase_erasable_args =
-                (env.FStar_TypeChecker_Env.erase_erasable_args);
-              FStar_TypeChecker_Env.core_check =
-                (env.FStar_TypeChecker_Env.core_check)
-            } in
-          let res = FStar_TypeChecker_Tc.push_context env1 msg in
-          FStar_Options.push ();
-          if restore_cmd_line_options
-          then
-            (let uu___2 = FStar_Options.restore_cmd_line_options false in
-             FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()))
-          else ();
-          res
-let (check_frag :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option ->
-      FStar_Parser_ParseIt.input_frag ->
-        (FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option *
-          FStar_TypeChecker_Env.env * Prims.int)
-          FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun curmod ->
-      fun frag ->
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 let uu___1 = FStar_Universal.tc_one_fragment curmod env frag in
-                 (match uu___1 with
-                  | (m, env1) ->
-                      let uu___2 =
-                        let uu___3 = FStar_Errors.get_err_count () in
-                        (m, env1, uu___3) in
-                      FStar_Pervasives_Native.Some uu___2)) ()
-        with
-        | FStar_Errors.Error (e, msg, r, ctx) when
-            let uu___1 = FStar_Options.trace_error () in
-            Prims.op_Negation uu___1 ->
-            (FStar_TypeChecker_Err.add_errors env [(e, msg, r, ctx)];
-             FStar_Pervasives_Native.None)
-        | FStar_Errors.Err (e, msg, ctx) when
-            let uu___1 = FStar_Options.trace_error () in
-            Prims.op_Negation uu___1 ->
-            ((let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_TypeChecker_Env.get_range env in
-                  (e, msg, uu___4, ctx) in
-                [uu___3] in
-              FStar_TypeChecker_Err.add_errors env uu___2);
-             FStar_Pervasives_Native.None)
-let (report_fail : unit -> unit) =
-  fun uu___ ->
-    (let uu___2 = FStar_Errors.report_all () in
-     FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()));
-    FStar_Errors.clear ()
-type input_chunks =
-  | Push of (Prims.bool * Prims.int * Prims.int) 
-  | Pop of Prims.string 
-  | Code of (Prims.string * (Prims.string * Prims.string)) 
-  | Info of (Prims.string * Prims.bool * (Prims.string * Prims.int *
-  Prims.int) FStar_Pervasives_Native.option) 
-  | Completions of Prims.string 
-let (uu___is_Push : input_chunks -> Prims.bool) =
-  fun projectee -> match projectee with | Push _0 -> true | uu___ -> false
-let (__proj__Push__item___0 :
-  input_chunks -> (Prims.bool * Prims.int * Prims.int)) =
-  fun projectee -> match projectee with | Push _0 -> _0
-let (uu___is_Pop : input_chunks -> Prims.bool) =
-  fun projectee -> match projectee with | Pop _0 -> true | uu___ -> false
-let (__proj__Pop__item___0 : input_chunks -> Prims.string) =
-  fun projectee -> match projectee with | Pop _0 -> _0
-let (uu___is_Code : input_chunks -> Prims.bool) =
-  fun projectee -> match projectee with | Code _0 -> true | uu___ -> false
-let (__proj__Code__item___0 :
-  input_chunks -> (Prims.string * (Prims.string * Prims.string))) =
-  fun projectee -> match projectee with | Code _0 -> _0
-let (uu___is_Info : input_chunks -> Prims.bool) =
-  fun projectee -> match projectee with | Info _0 -> true | uu___ -> false
-let (__proj__Info__item___0 :
-  input_chunks ->
-    (Prims.string * Prims.bool * (Prims.string * Prims.int * Prims.int)
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Info _0 -> _0
-let (uu___is_Completions : input_chunks -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Completions _0 -> true | uu___ -> false
-let (__proj__Completions__item___0 : input_chunks -> Prims.string) =
-  fun projectee -> match projectee with | Completions _0 -> _0
-type interactive_state =
-  {
-  chunk: FStar_Compiler_Util.string_builder ;
-  stdin:
-    FStar_Compiler_Util.stream_reader FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref
-    ;
-  buffer: input_chunks Prims.list FStar_Compiler_Effect.ref ;
-  log:
-    FStar_Compiler_Util.file_handle FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref
-    }
-let (__proj__Mkinteractive_state__item__chunk :
-  interactive_state -> FStar_Compiler_Util.string_builder) =
-  fun projectee ->
-    match projectee with | { chunk; stdin; buffer; log;_} -> chunk
-let (__proj__Mkinteractive_state__item__stdin :
-  interactive_state ->
-    FStar_Compiler_Util.stream_reader FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref)
-  =
-  fun projectee ->
-    match projectee with | { chunk; stdin; buffer; log;_} -> stdin
-let (__proj__Mkinteractive_state__item__buffer :
-  interactive_state -> input_chunks Prims.list FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with | { chunk; stdin; buffer; log;_} -> buffer
-let (__proj__Mkinteractive_state__item__log :
-  interactive_state ->
-    FStar_Compiler_Util.file_handle FStar_Pervasives_Native.option
-      FStar_Compiler_Effect.ref)
-  =
-  fun projectee ->
-    match projectee with | { chunk; stdin; buffer; log;_} -> log
-let (the_interactive_state : interactive_state) =
-  let uu___ = FStar_Compiler_Util.new_string_builder () in
-  let uu___1 = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let uu___2 = FStar_Compiler_Util.mk_ref [] in
-  let uu___3 = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  { chunk = uu___; stdin = uu___1; buffer = uu___2; log = uu___3 }
-let rec (read_chunk : unit -> input_chunks) =
-  fun uu___ ->
-    let s = the_interactive_state in
-    let log =
-      let uu___1 = FStar_Options.debug_any () in
-      if uu___1
-      then
-        let transcript =
-          let uu___2 = FStar_Compiler_Effect.op_Bang s.log in
-          match uu___2 with
-          | FStar_Pervasives_Native.Some transcript1 -> transcript1
-          | FStar_Pervasives_Native.None ->
-              let transcript1 =
-                FStar_Compiler_Util.open_file_for_writing "transcript" in
-              (FStar_Compiler_Effect.op_Colon_Equals s.log
-                 (FStar_Pervasives_Native.Some transcript1);
-               transcript1) in
-        fun line ->
-          (FStar_Compiler_Util.append_to_file transcript line;
-           FStar_Compiler_Util.flush_file transcript)
-      else (fun uu___3 -> ()) in
-    let stdin =
-      let uu___1 = FStar_Compiler_Effect.op_Bang s.stdin in
-      match uu___1 with
-      | FStar_Pervasives_Native.Some i -> i
-      | FStar_Pervasives_Native.None ->
-          let i = FStar_Compiler_Util.open_stdin () in
-          (FStar_Compiler_Effect.op_Colon_Equals s.stdin
-             (FStar_Pervasives_Native.Some i);
-           i) in
-    let line =
-      let uu___1 = FStar_Compiler_Util.read_line stdin in
-      match uu___1 with
-      | FStar_Pervasives_Native.None ->
-          FStar_Compiler_Effect.exit Prims.int_zero
-      | FStar_Pervasives_Native.Some l -> l in
-    log line;
-    (let l = FStar_Compiler_Util.trim_string line in
-     if FStar_Compiler_Util.starts_with l "#end"
-     then
-       let responses =
-         match FStar_Compiler_Util.split l " " with
-         | uu___2::ok::fail::[] -> (ok, fail)
-         | uu___2 -> ("ok", "fail") in
-       let str = FStar_Compiler_Util.string_of_string_builder s.chunk in
-       (FStar_Compiler_Util.clear_string_builder s.chunk;
-        Code (str, responses))
-     else
-       if FStar_Compiler_Util.starts_with l "#pop"
-       then (FStar_Compiler_Util.clear_string_builder s.chunk; Pop l)
-       else
-         if FStar_Compiler_Util.starts_with l "#push"
-         then
-           (FStar_Compiler_Util.clear_string_builder s.chunk;
-            (let lc_lax =
-               let uu___5 =
-                 FStar_Compiler_Util.substring_from l
-                   (FStar_String.length "#push") in
-               FStar_Compiler_Util.trim_string uu___5 in
-             let lc =
-               match FStar_Compiler_Util.split lc_lax " " with
-               | l1::c::"#lax"::[] ->
-                   let uu___5 = FStar_Compiler_Util.int_of_string l1 in
-                   let uu___6 = FStar_Compiler_Util.int_of_string c in
-                   (true, uu___5, uu___6)
-               | l1::c::[] ->
-                   let uu___5 = FStar_Compiler_Util.int_of_string l1 in
-                   let uu___6 = FStar_Compiler_Util.int_of_string c in
-                   (false, uu___5, uu___6)
-               | uu___5 ->
-                   (FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                      (FStar_Errors.Warning_WrongErrorLocation,
-                        (Prims.op_Hat
-                           "Error locations may be wrong, unrecognized string after #push: "
-                           lc_lax));
-                    (false, Prims.int_one, Prims.int_zero)) in
-             Push lc))
-         else
-           if FStar_Compiler_Util.starts_with l "#info "
-           then
-             (match FStar_Compiler_Util.split l " " with
-              | uu___5::symbol::[] ->
-                  (FStar_Compiler_Util.clear_string_builder s.chunk;
-                   Info (symbol, true, FStar_Pervasives_Native.None))
-              | uu___5::symbol::file::row::col::[] ->
-                  (FStar_Compiler_Util.clear_string_builder s.chunk;
-                   (let uu___7 =
-                      let uu___8 =
-                        let uu___9 =
-                          let uu___10 = FStar_Compiler_Util.int_of_string row in
-                          let uu___11 = FStar_Compiler_Util.int_of_string col in
-                          (file, uu___10, uu___11) in
-                        FStar_Pervasives_Native.Some uu___9 in
-                      (symbol, false, uu___8) in
-                    Info uu___7))
-              | uu___5 ->
-                  (FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                     (FStar_Errors.Error_IDEUnrecognized,
-                       (Prims.op_Hat "Unrecognized \"#info\" request: " l));
-                   FStar_Compiler_Effect.exit Prims.int_one))
-           else
-             if FStar_Compiler_Util.starts_with l "#completions "
-             then
-               (match FStar_Compiler_Util.split l " " with
-                | uu___6::prefix::"#"::[] ->
-                    (FStar_Compiler_Util.clear_string_builder s.chunk;
-                     Completions prefix)
-                | uu___6 ->
-                    (FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                       (FStar_Errors.Error_IDEUnrecognized,
-                         (Prims.op_Hat
-                            "Unrecognized \"#completions\" request: " l));
-                     FStar_Compiler_Effect.exit Prims.int_one))
-             else
-               if l = "#finish"
-               then FStar_Compiler_Effect.exit Prims.int_zero
-               else
-                 (FStar_Compiler_Util.string_builder_append s.chunk line;
-                  FStar_Compiler_Util.string_builder_append s.chunk "\n";
-                  read_chunk ()))
-let (shift_chunk : unit -> input_chunks) =
-  fun uu___ ->
-    let s = the_interactive_state in
-    let uu___1 = FStar_Compiler_Effect.op_Bang s.buffer in
-    match uu___1 with
-    | [] -> read_chunk ()
-    | chunk::chunks ->
-        (FStar_Compiler_Effect.op_Colon_Equals s.buffer chunks; chunk)
-let (fill_buffer : unit -> unit) =
-  fun uu___ ->
-    let s = the_interactive_state in
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang s.buffer in
-      let uu___3 = let uu___4 = read_chunk () in [uu___4] in
-      FStar_Compiler_List.op_At uu___2 uu___3 in
-    FStar_Compiler_Effect.op_Colon_Equals s.buffer uu___1
-let (deps_of_our_file :
-  Prims.string ->
-    (Prims.string Prims.list * Prims.string FStar_Pervasives_Native.option *
-      FStar_Parser_Dep.deps))
-  =
-  fun filename ->
-    let uu___ =
-      FStar_Dependencies.find_deps_if_needed [filename]
-        FStar_CheckedFiles.load_parsing_data_from_cache in
-    match uu___ with
-    | (deps, dep_graph) ->
-        let uu___1 =
-          FStar_Compiler_List.partition
-            (fun x ->
-               let uu___2 = FStar_Parser_Dep.lowercase_module_name x in
-               let uu___3 = FStar_Parser_Dep.lowercase_module_name filename in
-               uu___2 <> uu___3) deps in
-        (match uu___1 with
-         | (deps1, same_name) ->
-             let maybe_intf =
-               match same_name with
-               | intf::impl::[] ->
-                   ((let uu___3 =
-                       (let uu___4 = FStar_Parser_Dep.is_interface intf in
-                        Prims.op_Negation uu___4) ||
-                         (let uu___4 =
-                            FStar_Parser_Dep.is_implementation impl in
-                          Prims.op_Negation uu___4) in
-                     if uu___3
-                     then
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Compiler_Util.format2
-                             "Found %s and %s but not an interface + implementation"
-                             intf impl in
-                         (FStar_Errors.Warning_MissingInterfaceOrImplementation,
-                           uu___5) in
-                       FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                         uu___4
-                     else ());
-                    FStar_Pervasives_Native.Some intf)
-               | impl::[] -> FStar_Pervasives_Native.None
-               | uu___2 ->
-                   ((let uu___4 =
-                       let uu___5 =
-                         FStar_Compiler_Util.format1
-                           "Unexpected: ended up with %s"
-                           (FStar_String.concat " " same_name) in
-                       (FStar_Errors.Warning_UnexpectedFile, uu___5) in
-                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                       uu___4);
-                    FStar_Pervasives_Native.None) in
-             (deps1, maybe_intf, dep_graph))
-type m_timestamps =
-  (Prims.string FStar_Pervasives_Native.option * Prims.string *
-    FStar_Compiler_Util.time FStar_Pervasives_Native.option *
-    FStar_Compiler_Util.time) Prims.list
-let rec (tc_deps :
-  modul_t ->
-    stack_t ->
-      FStar_TypeChecker_Env.env ->
-        Prims.string Prims.list ->
-          m_timestamps ->
-            (stack_t * FStar_TypeChecker_Env.env * m_timestamps))
-  =
-  fun m ->
-    fun stack ->
-      fun env ->
-        fun remaining ->
-          fun ts ->
-            match remaining with
-            | [] -> (stack, env, ts)
-            | uu___ ->
-                let stack1 = (env, m) :: stack in
-                let env1 =
-                  let uu___1 = FStar_Options.lax () in
-                  push_with_kind env uu___1 true "typecheck_modul" in
-                let uu___1 = tc_one_file remaining env1 in
-                (match uu___1 with
-                 | ((intf, impl), env2, remaining1) ->
-                     let uu___2 =
-                       let intf_t =
-                         match intf with
-                         | FStar_Pervasives_Native.Some intf1 ->
-                             let uu___3 =
-                               FStar_Parser_ParseIt.get_file_last_modification_time
-                                 intf1 in
-                             FStar_Pervasives_Native.Some uu___3
-                         | FStar_Pervasives_Native.None ->
-                             FStar_Pervasives_Native.None in
-                       let impl_t =
-                         FStar_Parser_ParseIt.get_file_last_modification_time
-                           impl in
-                       (intf_t, impl_t) in
-                     (match uu___2 with
-                      | (intf_t, impl_t) ->
-                          tc_deps m stack1 env2 remaining1
-                            ((intf, impl, intf_t, impl_t) :: ts)))
-let (update_deps :
-  Prims.string ->
-    modul_t ->
-      stack_t -> env_t -> m_timestamps -> (stack_t * env_t * m_timestamps))
-  =
-  fun filename ->
-    fun m ->
-      fun stk ->
-        fun env ->
-          fun ts ->
-            let is_stale intf impl intf_t impl_t =
-              let impl_mt =
-                FStar_Parser_ParseIt.get_file_last_modification_time impl in
-              (FStar_Compiler_Util.is_before impl_t impl_mt) ||
-                (match (intf, intf_t) with
-                 | (FStar_Pervasives_Native.Some intf1,
-                    FStar_Pervasives_Native.Some intf_t1) ->
-                     let intf_mt =
-                       FStar_Parser_ParseIt.get_file_last_modification_time
-                         intf1 in
-                     FStar_Compiler_Util.is_before intf_t1 intf_mt
-                 | (FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.None) -> false
-                 | (uu___, uu___1) ->
-                     failwith
-                       "Impossible, if the interface is None, the timestamp entry should also be None") in
-            let rec iterate depnames st env' ts1 good_stack good_ts =
-              let match_dep depnames1 intf impl =
-                match intf with
-                | FStar_Pervasives_Native.None ->
-                    (match depnames1 with
-                     | dep::depnames' ->
-                         if dep = impl
-                         then (true, depnames')
-                         else (false, depnames1)
-                     | uu___ -> (false, depnames1))
-                | FStar_Pervasives_Native.Some intf1 ->
-                    (match depnames1 with
-                     | depintf::dep::depnames' ->
-                         if (depintf = intf1) && (dep = impl)
-                         then (true, depnames')
-                         else (false, depnames1)
-                     | uu___ -> (false, depnames1)) in
-              let rec pop_tc_and_stack env1 stack ts2 =
-                match ts2 with
-                | [] -> env1
-                | uu___::ts3 ->
-                    (pop env1 "";
-                     (let uu___2 =
-                        let uu___3 = FStar_Compiler_List.hd stack in
-                        let uu___4 = FStar_Compiler_List.tl stack in
-                        (uu___3, uu___4) in
-                      match uu___2 with
-                      | ((env2, uu___3), stack1) ->
-                          pop_tc_and_stack env2 stack1 ts3)) in
-              match ts1 with
-              | ts_elt::ts' ->
-                  let uu___ = ts_elt in
-                  (match uu___ with
-                   | (intf, impl, intf_t, impl_t) ->
-                       let uu___1 = match_dep depnames intf impl in
-                       (match uu___1 with
-                        | (b, depnames') ->
-                            let uu___2 =
-                              (Prims.op_Negation b) ||
-                                (is_stale intf impl intf_t impl_t) in
-                            if uu___2
-                            then
-                              let env1 =
-                                pop_tc_and_stack env'
-                                  (FStar_Compiler_List.rev_append st []) ts1 in
-                              tc_deps m good_stack env1 depnames good_ts
-                            else
-                              (let uu___4 =
-                                 let uu___5 = FStar_Compiler_List.hd st in
-                                 let uu___6 = FStar_Compiler_List.tl st in
-                                 (uu___5, uu___6) in
-                               match uu___4 with
-                               | (stack_elt, st') ->
-                                   iterate depnames' st' env' ts' (stack_elt
-                                     :: good_stack) (ts_elt :: good_ts))))
-              | [] -> tc_deps m good_stack env' depnames good_ts in
-            let uu___ = deps_of_our_file filename in
-            match uu___ with
-            | (filenames, uu___1, dep_graph) ->
-                iterate filenames (FStar_Compiler_List.rev_append stk []) env
-                  (FStar_Compiler_List.rev_append ts []) [] []
-let (format_info :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Compiler_Range.range ->
-          Prims.string FStar_Pervasives_Native.option -> Prims.string)
-  =
-  fun env ->
-    fun name ->
-      fun typ ->
-        fun range ->
-          fun doc ->
-            let uu___ = FStar_Compiler_Range.string_of_range range in
-            let uu___1 = FStar_TypeChecker_Normalize.term_to_string env typ in
-            let uu___2 =
-              match doc with
-              | FStar_Pervasives_Native.Some docstring ->
-                  FStar_Compiler_Util.format1 "#doc %s" docstring
-              | FStar_Pervasives_Native.None -> "" in
-            FStar_Compiler_Util.format4 "(defined at %s) %s: %s%s" uu___ name
-              uu___1 uu___2
-let rec (go :
-  (Prims.int * Prims.int) ->
-    Prims.string -> stack_t -> modul_t -> env_t -> m_timestamps -> unit)
-  =
-  fun line_col ->
-    fun filename ->
-      fun stack ->
-        fun curmod ->
-          fun env ->
-            fun ts ->
-              let uu___ = shift_chunk () in
-              match uu___ with
-              | Info (symbol, fqn_only, pos_opt) ->
-                  let info_at_pos_opt =
-                    match pos_opt with
-                    | FStar_Pervasives_Native.None ->
-                        FStar_Pervasives_Native.None
-                    | FStar_Pervasives_Native.Some (file, row, col) ->
-                        FStar_TypeChecker_Err.info_at_pos env file row col in
-                  let info_opt =
-                    match info_at_pos_opt with
-                    | FStar_Pervasives_Native.Some uu___1 -> info_at_pos_opt
-                    | FStar_Pervasives_Native.None ->
-                        if symbol = ""
-                        then FStar_Pervasives_Native.None
-                        else
-                          (let lid =
-                             let uu___2 =
-                               FStar_Compiler_List.map FStar_Ident.id_of_text
-                                 (FStar_Compiler_Util.split symbol ".") in
-                             FStar_Ident.lid_of_ids uu___2 in
-                           let lid1 =
-                             if fqn_only
-                             then lid
-                             else
-                               (let uu___3 =
-                                  FStar_Syntax_DsEnv.resolve_to_fully_qualified_name
-                                    env.FStar_TypeChecker_Env.dsenv lid in
-                                match uu___3 with
-                                | FStar_Pervasives_Native.None -> lid
-                                | FStar_Pervasives_Native.Some lid2 -> lid2) in
-                           let uu___2 =
-                             FStar_TypeChecker_Env.try_lookup_lid env lid1 in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___2
-                             (FStar_Compiler_Util.map_option
-                                (fun uu___3 ->
-                                   match uu___3 with
-                                   | ((uu___4, typ), r) ->
-                                       ((FStar_Pervasives.Inr lid1), typ, r)))) in
-                  ((match info_opt with
-                    | FStar_Pervasives_Native.None ->
-                        FStar_Compiler_Util.print_string "\n#done-nok\n"
-                    | FStar_Pervasives_Native.Some (name_or_lid, typ, rng) ->
-                        let uu___2 =
-                          match name_or_lid with
-                          | FStar_Pervasives.Inl name ->
-                              (name, FStar_Pervasives_Native.None)
-                          | FStar_Pervasives.Inr lid ->
-                              let uu___3 = FStar_Ident.string_of_lid lid in
-                              (uu___3, FStar_Pervasives_Native.None) in
-                        (match uu___2 with
-                         | (name, doc) ->
-                             let uu___3 = format_info env name typ rng doc in
-                             FStar_Compiler_Util.print1 "%s\n#done-ok\n"
-                               uu___3));
-                   go line_col filename stack curmod env ts)
-              | Completions search_term ->
-                  let rec measure_anchored_match search_term1 candidate =
-                    match (search_term1, candidate) with
-                    | ([], uu___1) ->
-                        FStar_Pervasives_Native.Some ([], Prims.int_zero)
-                    | (uu___1, []) -> FStar_Pervasives_Native.None
-                    | (hs::ts1, hc::tc) ->
-                        let hc_text = FStar_Ident.string_of_id hc in
-                        if FStar_Compiler_Util.starts_with hc_text hs
-                        then
-                          (match ts1 with
-                           | [] ->
-                               FStar_Pervasives_Native.Some
-                                 (candidate, (FStar_String.length hs))
-                           | uu___1 ->
-                               let uu___2 = measure_anchored_match ts1 tc in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                                 (FStar_Compiler_Util.map_option
-                                    (fun uu___3 ->
-                                       match uu___3 with
-                                       | (matched, len) ->
-                                           ((hc :: matched),
-                                             (((FStar_String.length hc_text)
-                                                 + Prims.int_one)
-                                                + len)))))
-                        else FStar_Pervasives_Native.None in
-                  let rec locate_match needle candidate =
-                    let uu___1 = measure_anchored_match needle candidate in
-                    match uu___1 with
-                    | FStar_Pervasives_Native.Some (matched, n) ->
-                        FStar_Pervasives_Native.Some ([], matched, n)
-                    | FStar_Pervasives_Native.None ->
-                        (match candidate with
-                         | [] -> FStar_Pervasives_Native.None
-                         | hc::tc ->
-                             let uu___2 = locate_match needle tc in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___2
-                               (FStar_Compiler_Util.map_option
-                                  (fun uu___3 ->
-                                     match uu___3 with
-                                     | (prefix, matched, len) ->
-                                         ((hc :: prefix), matched, len)))) in
-                  let str_of_ids ids =
-                    let uu___1 =
-                      FStar_Compiler_List.map FStar_Ident.string_of_id ids in
-                    FStar_Compiler_Util.concat_l "." uu___1 in
-                  let match_lident_against needle lident =
-                    let uu___1 =
-                      let uu___2 = FStar_Ident.ns_of_lid lident in
-                      let uu___3 =
-                        let uu___4 = FStar_Ident.ident_of_lid lident in
-                        [uu___4] in
-                      FStar_Compiler_List.op_At uu___2 uu___3 in
-                    locate_match needle uu___1 in
-                  let shorten_namespace uu___1 =
-                    match uu___1 with
-                    | (prefix, matched, match_len) ->
-                        let naked_match =
-                          match matched with
-                          | uu___2::[] -> true
-                          | uu___2 -> false in
-                        let uu___2 =
-                          FStar_Syntax_DsEnv.shorten_module_path
-                            env.FStar_TypeChecker_Env.dsenv prefix
-                            naked_match in
-                        (match uu___2 with
-                         | (stripped_ns, shortened) ->
-                             let uu___3 = str_of_ids shortened in
-                             let uu___4 = str_of_ids matched in
-                             let uu___5 = str_of_ids stripped_ns in
-                             (uu___3, uu___4, uu___5, match_len)) in
-                  let prepare_candidate uu___1 =
-                    match uu___1 with
-                    | (prefix, matched, stripped_ns, match_len) ->
-                        if prefix = ""
-                        then (matched, stripped_ns, match_len)
-                        else
-                          ((Prims.op_Hat prefix (Prims.op_Hat "." matched)),
-                            stripped_ns,
-                            (((FStar_String.length prefix) + match_len) +
-                               Prims.int_one)) in
-                  let needle = FStar_Compiler_Util.split search_term "." in
-                  let all_lidents_in_env = FStar_TypeChecker_Env.lidents env in
-                  let matches =
-                    let case_a_find_transitive_includes orig_ns m id =
-                      let exported_names =
-                        FStar_Syntax_DsEnv.transitive_exported_ids
-                          env.FStar_TypeChecker_Env.dsenv m in
-                      let matched_length =
-                        FStar_Compiler_List.fold_left
-                          (fun out ->
-                             fun s ->
-                               ((FStar_String.length s) + out) +
-                                 Prims.int_one) (FStar_String.length id)
-                          orig_ns in
-                      FStar_Compiler_Effect.op_Bar_Greater exported_names
-                        (FStar_Compiler_List.filter_map
-                           (fun n ->
-                              if FStar_Compiler_Util.starts_with n id
-                              then
-                                let lid =
-                                  let uu___1 = FStar_Ident.ids_of_lid m in
-                                  let uu___2 = FStar_Ident.id_of_text n in
-                                  FStar_Ident.lid_of_ns_and_id uu___1 uu___2 in
-                                let uu___1 =
-                                  FStar_Syntax_DsEnv.resolve_to_fully_qualified_name
-                                    env.FStar_TypeChecker_Env.dsenv lid in
-                                FStar_Compiler_Option.map
-                                  (fun fqn ->
-                                     let uu___2 =
-                                       let uu___3 =
-                                         FStar_Compiler_List.map
-                                           FStar_Ident.id_of_text orig_ns in
-                                       let uu___4 =
-                                         let uu___5 =
-                                           FStar_Ident.ident_of_lid fqn in
-                                         [uu___5] in
-                                       FStar_Compiler_List.op_At uu___3
-                                         uu___4 in
-                                     ([], uu___2, matched_length)) uu___1
-                              else FStar_Pervasives_Native.None)) in
-                    let case_b_find_matches_in_env uu___1 =
-                      let matches1 =
-                        FStar_Compiler_List.filter_map
-                          (match_lident_against needle) all_lidents_in_env in
-                      FStar_Compiler_Effect.op_Bar_Greater matches1
-                        (FStar_Compiler_List.filter
-                           (fun uu___2 ->
-                              match uu___2 with
-                              | (ns, id, uu___3) ->
-                                  let uu___4 =
-                                    let uu___5 = FStar_Ident.lid_of_ids id in
-                                    FStar_Syntax_DsEnv.resolve_to_fully_qualified_name
-                                      env.FStar_TypeChecker_Env.dsenv uu___5 in
-                                  (match uu___4 with
-                                   | FStar_Pervasives_Native.None -> false
-                                   | FStar_Pervasives_Native.Some l ->
-                                       let uu___5 =
-                                         FStar_Ident.lid_of_ids
-                                           (FStar_Compiler_List.op_At ns id) in
-                                       FStar_Ident.lid_equals l uu___5))) in
-                    let uu___1 = FStar_Compiler_Util.prefix needle in
-                    match uu___1 with
-                    | (ns, id) ->
-                        let matched_ids =
-                          match ns with
-                          | [] -> case_b_find_matches_in_env ()
-                          | uu___2 ->
-                              let l =
-                                FStar_Ident.lid_of_path ns
-                                  FStar_Compiler_Range.dummyRange in
-                              let uu___3 =
-                                FStar_Syntax_DsEnv.resolve_module_name
-                                  env.FStar_TypeChecker_Env.dsenv l true in
-                              (match uu___3 with
-                               | FStar_Pervasives_Native.None ->
-                                   case_b_find_matches_in_env ()
-                               | FStar_Pervasives_Native.Some m ->
-                                   case_a_find_transitive_includes ns m id) in
-                        FStar_Compiler_Effect.op_Bar_Greater matched_ids
-                          (FStar_Compiler_List.map
-                             (fun x ->
-                                let uu___2 = shorten_namespace x in
-                                prepare_candidate uu___2)) in
-                  ((let uu___2 =
-                      FStar_Compiler_Util.sort_with
-                        (fun uu___3 ->
-                           fun uu___4 ->
-                             match (uu___3, uu___4) with
-                             | ((cd1, ns1, uu___5), (cd2, ns2, uu___6)) ->
-                                 (match FStar_String.compare cd1 cd2 with
-                                  | uu___7 when uu___7 = Prims.int_zero ->
-                                      FStar_String.compare ns1 ns2
-                                  | n -> n)) matches in
-                    FStar_Compiler_List.iter
-                      (fun uu___3 ->
-                         match uu___3 with
-                         | (candidate, ns, match_len) ->
-                             let uu___4 =
-                               FStar_Compiler_Util.string_of_int match_len in
-                             FStar_Compiler_Util.print3 "%s %s %s \n" uu___4
-                               ns candidate) uu___2);
-                   FStar_Compiler_Util.print_string "#done-ok\n";
-                   go line_col filename stack curmod env ts)
-              | Pop msg ->
-                  (pop env msg;
-                   (let uu___2 =
-                      match stack with
-                      | [] ->
-                          (FStar_Errors.log_issue
-                             FStar_Compiler_Range.dummyRange
-                             (FStar_Errors.Error_IDETooManyPops,
-                               "too many pops");
-                           FStar_Compiler_Effect.exit Prims.int_one)
-                      | hd::tl -> (hd, tl) in
-                    match uu___2 with
-                    | ((env1, curmod1), stack1) ->
-                        go line_col filename stack1 curmod1 env1 ts))
-              | Push (lax, l, c) ->
-                  let uu___1 =
-                    if
-                      (FStar_Compiler_List.length stack) =
-                        (FStar_Compiler_List.length ts)
-                    then
-                      let uu___2 = update_deps filename curmod stack env ts in
-                      (true, uu___2)
-                    else (false, (stack, env, ts)) in
-                  (match uu___1 with
-                   | (restore_cmd_line_options, (stack1, env1, ts1)) ->
-                       let stack2 = (env1, curmod) :: stack1 in
-                       let env2 =
-                         push_with_kind env1 lax restore_cmd_line_options
-                           "#push" in
-                       go (l, c) filename stack2 curmod env2 ts1)
-              | Code (text, (ok, fail)) ->
-                  let fail1 curmod1 tcenv =
-                    report_fail ();
-                    FStar_Compiler_Util.print1 "%s\n" fail;
-                    go line_col filename stack curmod1 tcenv ts in
-                  let frag =
-                    {
-                      FStar_Parser_ParseIt.frag_fname = " input";
-                      FStar_Parser_ParseIt.frag_text = text;
-                      FStar_Parser_ParseIt.frag_line =
-                        (FStar_Pervasives_Native.fst line_col);
-                      FStar_Parser_ParseIt.frag_col =
-                        (FStar_Pervasives_Native.snd line_col)
-                    } in
-                  let res = check_frag env curmod frag in
-                  (match res with
-                   | FStar_Pervasives_Native.Some (curmod1, env1, n_errs) ->
-                       if n_errs = Prims.int_zero
-                       then
-                         (FStar_Compiler_Util.print1 "\n%s\n" ok;
-                          go line_col filename stack curmod1 env1 ts)
-                       else fail1 curmod1 env1
-                   | uu___1 -> fail1 curmod env)
-let (interactive_mode : Prims.string -> unit) =
-  fun filename ->
-    (let uu___1 =
-       let uu___2 = FStar_Options.codegen () in
-       FStar_Compiler_Option.isSome uu___2 in
-     if uu___1
-     then
-       FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-         (FStar_Errors.Warning_IDEIgnoreCodeGen,
-           "code-generation is not supported in interactive mode, ignoring the codegen flag")
-     else ());
-    (let uu___1 = deps_of_our_file filename in
-     match uu___1 with
-     | (filenames, maybe_intf, dep_graph) ->
-         let env = FStar_Universal.init_env dep_graph in
-         let uu___2 =
-           tc_deps FStar_Pervasives_Native.None [] env filenames [] in
-         (match uu___2 with
-          | (stack, env1, ts) ->
-              let initial_range =
-                let uu___3 =
-                  FStar_Compiler_Range.mk_pos Prims.int_one Prims.int_zero in
-                let uu___4 =
-                  FStar_Compiler_Range.mk_pos Prims.int_one Prims.int_zero in
-                FStar_Compiler_Range.mk_range filename uu___3 uu___4 in
-              let env2 = FStar_TypeChecker_Env.set_range env1 initial_range in
-              let env3 =
-                match maybe_intf with
-                | FStar_Pervasives_Native.Some intf ->
-                    FStar_Universal.load_interface_decls env2 intf
-                | FStar_Pervasives_Native.None -> env2 in
-              let uu___3 =
-                (FStar_Options.record_hints ()) ||
-                  (FStar_Options.use_hints ()) in
-              if uu___3
-              then
-                let uu___4 =
-                  let uu___5 = FStar_Options.file_list () in
-                  FStar_Compiler_List.hd uu___5 in
-                FStar_SMTEncoding_Solver.with_hints_db uu___4
-                  (fun uu___5 ->
-                     go (Prims.int_one, Prims.int_zero) filename stack
-                       FStar_Pervasives_Native.None env3 ts)
-              else
-                go (Prims.int_one, Prims.int_zero) filename stack
-                  FStar_Pervasives_Native.None env3 ts))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_Lsp.ml b/src/ocaml-output/FStar_Interactive_Lsp.ml
deleted file mode 100644
index 96bfa0a808f..00000000000
--- a/src/ocaml-output/FStar_Interactive_Lsp.ml
+++ /dev/null
@@ -1,530 +0,0 @@
-open Prims
-let (unpack_lsp_query :
-  (Prims.string * FStar_Compiler_Util.json) Prims.list ->
-    FStar_Interactive_JsonHelper.lsp_query)
-  =
-  fun r ->
-    let qid =
-      let uu___ = FStar_Interactive_JsonHelper.try_assoc "id" r in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (FStar_Compiler_Util.map_option
-           FStar_Interactive_JsonHelper.js_str_int) in
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             let method1 =
-               let uu___1 = FStar_Interactive_JsonHelper.assoc "method" r in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 FStar_Interactive_JsonHelper.js_str in
-             let uu___1 =
-               match method1 with
-               | "initialize" ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Interactive_JsonHelper.arg "processId" r in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         FStar_Interactive_JsonHelper.js_int in
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Interactive_JsonHelper.arg "rootUri" r in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_str in
-                     (uu___3, uu___4) in
-                   FStar_Interactive_JsonHelper.Initialize uu___2
-               | "initialized" -> FStar_Interactive_JsonHelper.Initialized
-               | "shutdown" -> FStar_Interactive_JsonHelper.Shutdown
-               | "exit" -> FStar_Interactive_JsonHelper.Exit
-               | "$/cancelRequest" ->
-                   let uu___2 =
-                     let uu___3 = FStar_Interactive_JsonHelper.arg "id" r in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_str_int in
-                   FStar_Interactive_JsonHelper.Cancel uu___2
-               | "workspace/didChangeWorkspaceFolders" ->
-                   let uu___2 =
-                     let uu___3 = FStar_Interactive_JsonHelper.arg "event" r in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_wsch_event in
-                   FStar_Interactive_JsonHelper.FolderChange uu___2
-               | "workspace/didChangeConfiguration" ->
-                   FStar_Interactive_JsonHelper.ChangeConfig
-               | "workspace/didChangeWatchedFiles" ->
-                   FStar_Interactive_JsonHelper.ChangeWatch
-               | "workspace/symbol" ->
-                   let uu___2 =
-                     let uu___3 = FStar_Interactive_JsonHelper.arg "query" r in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_str in
-                   FStar_Interactive_JsonHelper.Symbol uu___2
-               | "workspace/executeCommand" ->
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Interactive_JsonHelper.arg "command" r in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_str in
-                   FStar_Interactive_JsonHelper.ExecCommand uu___2
-               | "textDocument/didOpen" ->
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Interactive_JsonHelper.arg "textDocument" r in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Interactive_JsonHelper.js_txdoc_item in
-                   FStar_Interactive_JsonHelper.DidOpen uu___2
-               | "textDocument/didChange" ->
-                   let uu___2 =
-                     let uu___3 = FStar_Interactive_JsonHelper.js_txdoc_id r in
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Interactive_JsonHelper.arg "contentChanges" r in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_contentch in
-                     (uu___3, uu___4) in
-                   FStar_Interactive_JsonHelper.DidChange uu___2
-               | "textDocument/willSave" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_id r in
-                   FStar_Interactive_JsonHelper.WillSave uu___2
-               | "textDocument/willSaveWaitUntil" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_id r in
-                   FStar_Interactive_JsonHelper.WillSaveWait uu___2
-               | "textDocument/didSave" ->
-                   let uu___2 =
-                     let uu___3 = FStar_Interactive_JsonHelper.js_txdoc_id r in
-                     let uu___4 =
-                       let uu___5 = FStar_Interactive_JsonHelper.arg "text" r in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_str in
-                     (uu___3, uu___4) in
-                   FStar_Interactive_JsonHelper.DidSave uu___2
-               | "textDocument/didClose" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_id r in
-                   FStar_Interactive_JsonHelper.DidClose uu___2
-               | "textDocument/completion" ->
-                   let uu___2 =
-                     let uu___3 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Interactive_JsonHelper.arg "context" r in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Interactive_JsonHelper.js_compl_context in
-                     (uu___3, uu___4) in
-                   FStar_Interactive_JsonHelper.Completion uu___2
-               | "completionItem/resolve" ->
-                   FStar_Interactive_JsonHelper.Resolve
-               | "textDocument/hover" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.Hover uu___2
-               | "textDocument/signatureHelp" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.SignatureHelp uu___2
-               | "textDocument/declaration" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.Declaration uu___2
-               | "textDocument/definition" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.Definition uu___2
-               | "textDocument/typeDefinition" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.TypeDefinition uu___2
-               | "textDocument/implementation" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.Implementation uu___2
-               | "textDocument/references" ->
-                   FStar_Interactive_JsonHelper.References
-               | "textDocument/documentHighlight" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.DocumentHighlight uu___2
-               | "textDocument/documentSymbol" ->
-                   FStar_Interactive_JsonHelper.DocumentSymbol
-               | "textDocument/codeAction" ->
-                   FStar_Interactive_JsonHelper.CodeAction
-               | "textDocument/codeLens" ->
-                   FStar_Interactive_JsonHelper.CodeLens
-               | "codeLens/resolve" ->
-                   FStar_Interactive_JsonHelper.CodeLensResolve
-               | "textDocument/documentLink" ->
-                   FStar_Interactive_JsonHelper.DocumentLink
-               | "documentLink/resolve" ->
-                   FStar_Interactive_JsonHelper.DocumentLinkResolve
-               | "textDocument/documentColor" ->
-                   FStar_Interactive_JsonHelper.DocumentColor
-               | "textDocument/colorPresentation" ->
-                   FStar_Interactive_JsonHelper.ColorPresentation
-               | "textDocument/formatting" ->
-                   FStar_Interactive_JsonHelper.Formatting
-               | "textDocument/rangeFormatting" ->
-                   FStar_Interactive_JsonHelper.RangeFormatting
-               | "textDocument/onTypeFormatting" ->
-                   FStar_Interactive_JsonHelper.TypeFormatting
-               | "textDocument/rename" -> FStar_Interactive_JsonHelper.Rename
-               | "textDocument/prepareRename" ->
-                   let uu___2 = FStar_Interactive_JsonHelper.js_txdoc_pos r in
-                   FStar_Interactive_JsonHelper.PrepareRename uu___2
-               | "textDocument/foldingRange" ->
-                   FStar_Interactive_JsonHelper.FoldingRange
-               | m ->
-                   let uu___2 =
-                     FStar_Compiler_Util.format1 "Unknown method '%s'" m in
-                   FStar_Interactive_JsonHelper.BadProtocolMsg uu___2 in
-             {
-               FStar_Interactive_JsonHelper.query_id = qid;
-               FStar_Interactive_JsonHelper.q = uu___1
-             }) ()
-    with
-    | FStar_Interactive_JsonHelper.MissingKey msg ->
-        {
-          FStar_Interactive_JsonHelper.query_id = qid;
-          FStar_Interactive_JsonHelper.q =
-            (FStar_Interactive_JsonHelper.BadProtocolMsg msg)
-        }
-    | FStar_Interactive_JsonHelper.UnexpectedJsonType (expected, got) ->
-        FStar_Interactive_JsonHelper.wrap_jsfail qid expected got
-let (deserialize_lsp_query :
-  FStar_Compiler_Util.json -> FStar_Interactive_JsonHelper.lsp_query) =
-  fun js_query ->
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             let uu___1 =
-               FStar_Compiler_Effect.op_Bar_Greater js_query
-                 FStar_Interactive_JsonHelper.js_assoc in
-             unpack_lsp_query uu___1) ()
-    with
-    | FStar_Interactive_JsonHelper.UnexpectedJsonType (expected, got) ->
-        FStar_Interactive_JsonHelper.wrap_jsfail FStar_Pervasives_Native.None
-          expected got
-let (parse_lsp_query :
-  Prims.string -> FStar_Interactive_JsonHelper.lsp_query) =
-  fun query_str ->
-    let uu___1 = FStar_Compiler_Util.json_of_string query_str in
-    match uu___1 with
-    | FStar_Pervasives_Native.None ->
-        {
-          FStar_Interactive_JsonHelper.query_id =
-            FStar_Pervasives_Native.None;
-          FStar_Interactive_JsonHelper.q =
-            (FStar_Interactive_JsonHelper.BadProtocolMsg
-               "Json parsing failed")
-        }
-    | FStar_Pervasives_Native.Some request -> deserialize_lsp_query request
-let (repl_state_init :
-  Prims.string -> FStar_Interactive_JsonHelper.repl_state) =
-  fun fname ->
-    let intial_range =
-      let uu___ = FStar_Compiler_Range.mk_pos Prims.int_one Prims.int_zero in
-      let uu___1 = FStar_Compiler_Range.mk_pos Prims.int_one Prims.int_zero in
-      FStar_Compiler_Range.mk_range fname uu___ uu___1 in
-    let env = FStar_Universal.init_env FStar_Parser_Dep.empty_deps in
-    let env1 = FStar_TypeChecker_Env.set_range env intial_range in
-    let uu___ = FStar_Compiler_Util.open_stdin () in
-    {
-      FStar_Interactive_JsonHelper.repl_line = Prims.int_one;
-      FStar_Interactive_JsonHelper.repl_column = Prims.int_zero;
-      FStar_Interactive_JsonHelper.repl_fname = fname;
-      FStar_Interactive_JsonHelper.repl_deps_stack = [];
-      FStar_Interactive_JsonHelper.repl_curmod = FStar_Pervasives_Native.None;
-      FStar_Interactive_JsonHelper.repl_env = env1;
-      FStar_Interactive_JsonHelper.repl_stdin = uu___;
-      FStar_Interactive_JsonHelper.repl_names =
-        FStar_Interactive_CompletionTable.empty
-    }
-type optresponse =
-  FStar_Interactive_JsonHelper.assoct FStar_Pervasives_Native.option
-type either_gst_exit =
-  (FStar_Interactive_JsonHelper.grepl_state, Prims.int)
-    FStar_Pervasives.either
-let (invoke_full_lax :
-  FStar_Interactive_JsonHelper.grepl_state ->
-    Prims.string ->
-      Prims.string -> Prims.bool -> (optresponse * either_gst_exit))
-  =
-  fun gst ->
-    fun fname ->
-      fun text ->
-        fun force ->
-          let aux uu___ =
-            FStar_Parser_ParseIt.add_vfs_entry fname text;
-            (let uu___2 =
-               let uu___3 = repl_state_init fname in
-               FStar_Interactive_PushHelper.full_lax text uu___3 in
-             match uu___2 with
-             | (diag, st') ->
-                 let repls =
-                   FStar_Compiler_Util.psmap_add
-                     gst.FStar_Interactive_JsonHelper.grepl_repls fname st' in
-                 let diag1 =
-                   if FStar_Compiler_Util.is_some diag
-                   then diag
-                   else
-                     (let uu___4 =
-                        FStar_Interactive_JsonHelper.js_diag_clear fname in
-                      FStar_Pervasives_Native.Some uu___4) in
-                 (diag1,
-                   (FStar_Pervasives.Inl
-                      {
-                        FStar_Interactive_JsonHelper.grepl_repls = repls;
-                        FStar_Interactive_JsonHelper.grepl_stdin =
-                          (gst.FStar_Interactive_JsonHelper.grepl_stdin)
-                      }))) in
-          let uu___ =
-            FStar_Compiler_Util.psmap_try_find
-              gst.FStar_Interactive_JsonHelper.grepl_repls fname in
-          match uu___ with
-          | FStar_Pervasives_Native.Some uu___1 ->
-              if force
-              then aux ()
-              else (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst))
-          | FStar_Pervasives_Native.None -> aux ()
-let (run_query :
-  FStar_Interactive_JsonHelper.grepl_state ->
-    FStar_Interactive_JsonHelper.lquery -> (optresponse * either_gst_exit))
-  =
-  fun gst ->
-    fun q ->
-      match q with
-      | FStar_Interactive_JsonHelper.Initialize (uu___, uu___1) ->
-          let uu___2 =
-            FStar_Interactive_JsonHelper.resultResponse
-              FStar_Interactive_JsonHelper.js_servcap in
-          (uu___2, (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Initialized ->
-          (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Shutdown ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Exit ->
-          (FStar_Pervasives_Native.None,
-            (FStar_Pervasives.Inr Prims.int_zero))
-      | FStar_Interactive_JsonHelper.Cancel id ->
-          (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.FolderChange evt ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.ChangeConfig ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.ChangeWatch ->
-          (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Symbol sym ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.ExecCommand cmd ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DidOpen
-          { FStar_Interactive_JsonHelper.fname = f;
-            FStar_Interactive_JsonHelper.langId = uu___;
-            FStar_Interactive_JsonHelper.version = uu___1;
-            FStar_Interactive_JsonHelper.text = t;_}
-          -> invoke_full_lax gst f t false
-      | FStar_Interactive_JsonHelper.DidChange (txid, content) ->
-          (FStar_Parser_ParseIt.add_vfs_entry txid content;
-           (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst)))
-      | FStar_Interactive_JsonHelper.WillSave txid ->
-          (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.WillSaveWait txid ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DidSave (f, t) ->
-          invoke_full_lax gst f t true
-      | FStar_Interactive_JsonHelper.DidClose txid ->
-          (FStar_Pervasives_Native.None, (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Completion (txpos, ctx) ->
-          let uu___ =
-            FStar_Compiler_Util.psmap_try_find
-              gst.FStar_Interactive_JsonHelper.grepl_repls
-              txpos.FStar_Interactive_JsonHelper.path in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some st ->
-               let uu___1 = FStar_Interactive_QueryHelper.complookup st txpos in
-               (uu___1, (FStar_Pervasives.Inl gst))
-           | FStar_Pervasives_Native.None ->
-               (FStar_Interactive_JsonHelper.nullResponse,
-                 (FStar_Pervasives.Inl gst)))
-      | FStar_Interactive_JsonHelper.Resolve ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Hover txpos ->
-          let uu___ =
-            FStar_Compiler_Util.psmap_try_find
-              gst.FStar_Interactive_JsonHelper.grepl_repls
-              txpos.FStar_Interactive_JsonHelper.path in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some st ->
-               let uu___1 =
-                 FStar_Interactive_QueryHelper.hoverlookup
-                   st.FStar_Interactive_JsonHelper.repl_env txpos in
-               (uu___1, (FStar_Pervasives.Inl gst))
-           | FStar_Pervasives_Native.None ->
-               (FStar_Interactive_JsonHelper.nullResponse,
-                 (FStar_Pervasives.Inl gst)))
-      | FStar_Interactive_JsonHelper.SignatureHelp txpos ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Declaration txpos ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Definition txpos ->
-          let uu___ =
-            FStar_Compiler_Util.psmap_try_find
-              gst.FStar_Interactive_JsonHelper.grepl_repls
-              txpos.FStar_Interactive_JsonHelper.path in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some st ->
-               let uu___1 =
-                 FStar_Interactive_QueryHelper.deflookup
-                   st.FStar_Interactive_JsonHelper.repl_env txpos in
-               (uu___1, (FStar_Pervasives.Inl gst))
-           | FStar_Pervasives_Native.None ->
-               (FStar_Interactive_JsonHelper.nullResponse,
-                 (FStar_Pervasives.Inl gst)))
-      | FStar_Interactive_JsonHelper.TypeDefinition txpos ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Implementation txpos ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.References ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DocumentHighlight txpos ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DocumentSymbol ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.CodeAction ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.CodeLens ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.CodeLensResolve ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DocumentLink ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DocumentLinkResolve ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.DocumentColor ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.ColorPresentation ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Formatting ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.RangeFormatting ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.TypeFormatting ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.Rename ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.PrepareRename txpos ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.FoldingRange ->
-          (FStar_Interactive_JsonHelper.nullResponse,
-            (FStar_Pervasives.Inl gst))
-      | FStar_Interactive_JsonHelper.BadProtocolMsg msg ->
-          let uu___ =
-            let uu___1 =
-              FStar_Interactive_JsonHelper.js_resperr
-                FStar_Interactive_JsonHelper.MethodNotFound msg in
-            FStar_Interactive_JsonHelper.errorResponse uu___1 in
-          (uu___, (FStar_Pervasives.Inl gst))
-let rec (parse_header_len :
-  FStar_Compiler_Util.stream_reader -> Prims.int -> Prims.int) =
-  fun stream ->
-    fun len ->
-      let uu___ = FStar_Compiler_Util.read_line stream in
-      match uu___ with
-      | FStar_Pervasives_Native.Some s ->
-          if FStar_Compiler_Util.starts_with s "Content-Length: "
-          then
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_Util.substring_from s (Prims.of_int (16)) in
-              FStar_Compiler_Util.safe_int_of_string uu___2 in
-            (match uu___1 with
-             | FStar_Pervasives_Native.Some new_len ->
-                 parse_header_len stream new_len
-             | FStar_Pervasives_Native.None ->
-                 FStar_Compiler_Effect.raise
-                   FStar_Interactive_JsonHelper.MalformedHeader)
-          else
-            if FStar_Compiler_Util.starts_with s "Content-Type: "
-            then parse_header_len stream len
-            else
-              if s = ""
-              then len
-              else
-                FStar_Compiler_Effect.raise
-                  FStar_Interactive_JsonHelper.MalformedHeader
-      | FStar_Pervasives_Native.None ->
-          FStar_Compiler_Effect.raise
-            FStar_Interactive_JsonHelper.InputExhausted
-let rec (read_lsp_query :
-  FStar_Compiler_Util.stream_reader -> FStar_Interactive_JsonHelper.lsp_query)
-  =
-  fun stream ->
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             let n = parse_header_len stream Prims.int_zero in
-             let uu___1 = FStar_Compiler_Util.nread stream n in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some s -> parse_lsp_query s
-              | FStar_Pervasives_Native.None ->
-                  let uu___2 =
-                    let uu___3 = FStar_Compiler_Util.string_of_int n in
-                    FStar_Compiler_Util.format1 "Could not read %s bytes"
-                      uu___3 in
-                  FStar_Interactive_JsonHelper.wrap_content_szerr uu___2)) ()
-    with
-    | FStar_Interactive_JsonHelper.MalformedHeader ->
-        (FStar_Compiler_Util.print_error "[E] Malformed Content Header\n";
-         read_lsp_query stream)
-    | FStar_Interactive_JsonHelper.InputExhausted -> read_lsp_query stream
-let rec (go : FStar_Interactive_JsonHelper.grepl_state -> Prims.int) =
-  fun gst ->
-    let query = read_lsp_query gst.FStar_Interactive_JsonHelper.grepl_stdin in
-    let uu___ = run_query gst query.FStar_Interactive_JsonHelper.q in
-    match uu___ with
-    | (r, state_opt) ->
-        ((match r with
-          | FStar_Pervasives_Native.Some response ->
-              let response' =
-                FStar_Interactive_JsonHelper.json_of_response
-                  query.FStar_Interactive_JsonHelper.query_id response in
-              (if false
-               then
-                 (let uu___3 = FStar_Compiler_Util.string_of_json response' in
-                  FStar_Compiler_Util.print1_error "<<< %s\n" uu___3)
-               else ();
-               FStar_Interactive_JsonHelper.write_jsonrpc response')
-          | FStar_Pervasives_Native.None -> ());
-         (match state_opt with
-          | FStar_Pervasives.Inl gst' -> go gst'
-          | FStar_Pervasives.Inr exitcode -> exitcode))
-let (start_server : unit -> unit) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Util.psmap_empty () in
-        let uu___4 = FStar_Compiler_Util.open_stdin () in
-        {
-          FStar_Interactive_JsonHelper.grepl_repls = uu___3;
-          FStar_Interactive_JsonHelper.grepl_stdin = uu___4
-        } in
-      go uu___2 in
-    FStar_Compiler_Effect.exit uu___1
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_PushHelper.ml b/src/ocaml-output/FStar_Interactive_PushHelper.ml
deleted file mode 100644
index 88dba1c09dc..00000000000
--- a/src/ocaml-output/FStar_Interactive_PushHelper.ml
+++ /dev/null
@@ -1,892 +0,0 @@
-open Prims
-type push_kind =
-  | SyntaxCheck 
-  | LaxCheck 
-  | FullCheck 
-let (uu___is_SyntaxCheck : push_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SyntaxCheck -> true | uu___ -> false
-let (uu___is_LaxCheck : push_kind -> Prims.bool) =
-  fun projectee -> match projectee with | LaxCheck -> true | uu___ -> false
-let (uu___is_FullCheck : push_kind -> Prims.bool) =
-  fun projectee -> match projectee with | FullCheck -> true | uu___ -> false
-type ctx_depth_t =
-  (Prims.int * Prims.int * FStar_TypeChecker_Env.solver_depth_t * Prims.int)
-type deps_t = FStar_Parser_Dep.deps
-type either_replst =
-  (FStar_Interactive_JsonHelper.repl_state,
-    FStar_Interactive_JsonHelper.repl_state) FStar_Pervasives.either
-type name_tracking_event =
-  | NTAlias of (FStar_Ident.lid * FStar_Ident.ident * FStar_Ident.lid) 
-  | NTOpen of (FStar_Ident.lid * FStar_Syntax_DsEnv.open_module_or_namespace)
-  
-  | NTInclude of (FStar_Ident.lid * FStar_Ident.lid) 
-  | NTBinding of (FStar_Syntax_Syntax.binding,
-  FStar_TypeChecker_Env.sig_binding) FStar_Pervasives.either 
-let (uu___is_NTAlias : name_tracking_event -> Prims.bool) =
-  fun projectee -> match projectee with | NTAlias _0 -> true | uu___ -> false
-let (__proj__NTAlias__item___0 :
-  name_tracking_event ->
-    (FStar_Ident.lid * FStar_Ident.ident * FStar_Ident.lid))
-  = fun projectee -> match projectee with | NTAlias _0 -> _0
-let (uu___is_NTOpen : name_tracking_event -> Prims.bool) =
-  fun projectee -> match projectee with | NTOpen _0 -> true | uu___ -> false
-let (__proj__NTOpen__item___0 :
-  name_tracking_event ->
-    (FStar_Ident.lid * FStar_Syntax_DsEnv.open_module_or_namespace))
-  = fun projectee -> match projectee with | NTOpen _0 -> _0
-let (uu___is_NTInclude : name_tracking_event -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NTInclude _0 -> true | uu___ -> false
-let (__proj__NTInclude__item___0 :
-  name_tracking_event -> (FStar_Ident.lid * FStar_Ident.lid)) =
-  fun projectee -> match projectee with | NTInclude _0 -> _0
-let (uu___is_NTBinding : name_tracking_event -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NTBinding _0 -> true | uu___ -> false
-let (__proj__NTBinding__item___0 :
-  name_tracking_event ->
-    (FStar_Syntax_Syntax.binding, FStar_TypeChecker_Env.sig_binding)
-      FStar_Pervasives.either)
-  = fun projectee -> match projectee with | NTBinding _0 -> _0
-let (repl_stack :
-  FStar_Interactive_JsonHelper.repl_stack_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let (set_check_kind :
-  FStar_TypeChecker_Env.env_t -> push_kind -> FStar_TypeChecker_Env.env_t) =
-  fun env ->
-    fun check_kind ->
-      let uu___ = (check_kind = LaxCheck) || (FStar_Options.lax ()) in
-      let uu___1 =
-        FStar_Syntax_DsEnv.set_syntax_only env.FStar_TypeChecker_Env.dsenv
-          (check_kind = SyntaxCheck) in
-      {
-        FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (env.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (env.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (env.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (env.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (env.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (env.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (env.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (env.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (env.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (env.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (env.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (env.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (env.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface = (env.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = uu___;
-        FStar_TypeChecker_Env.lax_universes =
-          (env.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard = (env.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (env.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (env.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (env.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (env.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (env.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (env.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (env.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns = (env.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (env.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (env.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (env.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (env.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks = (env.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = uu___1;
-        FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (env.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (env.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (env.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (env.FStar_TypeChecker_Env.core_check)
-      }
-let (repl_ld_tasks_of_deps :
-  Prims.string Prims.list ->
-    FStar_Interactive_JsonHelper.repl_task Prims.list ->
-      FStar_Interactive_JsonHelper.repl_task Prims.list)
-  =
-  fun deps ->
-    fun final_tasks ->
-      let wrap fname =
-        let uu___ = FStar_Compiler_Util.now () in
-        {
-          FStar_Interactive_JsonHelper.tf_fname = fname;
-          FStar_Interactive_JsonHelper.tf_modtime = uu___
-        } in
-      let rec aux deps1 final_tasks1 =
-        match deps1 with
-        | intf::impl::deps' when FStar_Universal.needs_interleaving intf impl
-            ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 = wrap intf in
-                let uu___3 = wrap impl in (uu___2, uu___3) in
-              FStar_Interactive_JsonHelper.LDInterleaved uu___1 in
-            let uu___1 = aux deps' final_tasks1 in uu___ :: uu___1
-        | intf_or_impl::deps' ->
-            let uu___ =
-              let uu___1 = wrap intf_or_impl in
-              FStar_Interactive_JsonHelper.LDSingle uu___1 in
-            let uu___1 = aux deps' final_tasks1 in uu___ :: uu___1
-        | [] -> final_tasks1 in
-      aux deps final_tasks
-let (deps_and_repl_ld_tasks_of_our_file :
-  Prims.string ->
-    (Prims.string Prims.list * FStar_Interactive_JsonHelper.repl_task
-      Prims.list * deps_t))
-  =
-  fun filename ->
-    let get_mod_name fname = FStar_Parser_Dep.lowercase_module_name fname in
-    let our_mod_name = get_mod_name filename in
-    let has_our_mod_name f =
-      let uu___ = get_mod_name f in uu___ = our_mod_name in
-    let parse_data_cache = FStar_CheckedFiles.load_parsing_data_from_cache in
-    let uu___ =
-      FStar_Dependencies.find_deps_if_needed [filename] parse_data_cache in
-    match uu___ with
-    | (deps, dep_graph) ->
-        let uu___1 = FStar_Compiler_List.partition has_our_mod_name deps in
-        (match uu___1 with
-         | (same_name, real_deps) ->
-             let intf_tasks =
-               match same_name with
-               | intf::impl::[] ->
-                   ((let uu___3 =
-                       let uu___4 = FStar_Parser_Dep.is_interface intf in
-                       Prims.op_Negation uu___4 in
-                     if uu___3
-                     then
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Compiler_Util.format1
-                             "Expecting an interface, got %s" intf in
-                         (FStar_Errors.Fatal_MissingInterface, uu___5) in
-                       FStar_Errors.raise_err uu___4
-                     else ());
-                    (let uu___4 =
-                       let uu___5 = FStar_Parser_Dep.is_implementation impl in
-                       Prims.op_Negation uu___5 in
-                     if uu___4
-                     then
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Compiler_Util.format1
-                             "Expecting an implementation, got %s" impl in
-                         (FStar_Errors.Fatal_MissingImplementation, uu___6) in
-                       FStar_Errors.raise_err uu___5
-                     else ());
-                    (let uu___4 =
-                       let uu___5 =
-                         let uu___6 = FStar_Compiler_Util.now () in
-                         {
-                           FStar_Interactive_JsonHelper.tf_fname = intf;
-                           FStar_Interactive_JsonHelper.tf_modtime = uu___6
-                         } in
-                       FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile
-                         uu___5 in
-                     [uu___4]))
-               | impl::[] -> []
-               | uu___2 ->
-                   let mods_str = FStar_String.concat " " same_name in
-                   let message = "Too many or too few files matching %s: %s" in
-                   ((let uu___4 =
-                       let uu___5 =
-                         FStar_Compiler_Util.format message
-                           [our_mod_name; mods_str] in
-                       (FStar_Errors.Fatal_TooManyOrTooFewFileMatch, uu___5) in
-                     FStar_Errors.raise_err uu___4);
-                    []) in
-             let tasks = repl_ld_tasks_of_deps real_deps intf_tasks in
-             (real_deps, tasks, dep_graph))
-let (snapshot_env :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      (FStar_Interactive_JsonHelper.repl_depth_t *
-        FStar_TypeChecker_Env.env_t))
-  =
-  fun env ->
-    fun msg ->
-      let uu___ = FStar_TypeChecker_Tc.snapshot_context env msg in
-      match uu___ with
-      | (ctx_depth, env1) ->
-          let uu___1 = FStar_Options.snapshot () in
-          (match uu___1 with
-           | (opt_depth, ()) -> ((ctx_depth, opt_depth), env1))
-let (push_repl :
-  Prims.string ->
-    push_kind ->
-      FStar_Interactive_JsonHelper.repl_task ->
-        FStar_Interactive_JsonHelper.repl_state ->
-          FStar_Interactive_JsonHelper.repl_state)
-  =
-  fun msg ->
-    fun push_kind1 ->
-      fun task ->
-        fun st ->
-          let uu___ =
-            snapshot_env st.FStar_Interactive_JsonHelper.repl_env msg in
-          match uu___ with
-          | (depth, env) ->
-              ((let uu___2 =
-                  let uu___3 = FStar_Compiler_Effect.op_Bang repl_stack in
-                  (depth, (task, st)) :: uu___3 in
-                FStar_Compiler_Effect.op_Colon_Equals repl_stack uu___2);
-               (let uu___2 = set_check_kind env push_kind1 in
-                {
-                  FStar_Interactive_JsonHelper.repl_line =
-                    (st.FStar_Interactive_JsonHelper.repl_line);
-                  FStar_Interactive_JsonHelper.repl_column =
-                    (st.FStar_Interactive_JsonHelper.repl_column);
-                  FStar_Interactive_JsonHelper.repl_fname =
-                    (st.FStar_Interactive_JsonHelper.repl_fname);
-                  FStar_Interactive_JsonHelper.repl_deps_stack =
-                    (st.FStar_Interactive_JsonHelper.repl_deps_stack);
-                  FStar_Interactive_JsonHelper.repl_curmod =
-                    (st.FStar_Interactive_JsonHelper.repl_curmod);
-                  FStar_Interactive_JsonHelper.repl_env = uu___2;
-                  FStar_Interactive_JsonHelper.repl_stdin =
-                    (st.FStar_Interactive_JsonHelper.repl_stdin);
-                  FStar_Interactive_JsonHelper.repl_names =
-                    (st.FStar_Interactive_JsonHelper.repl_names)
-                }))
-let (rollback_env :
-  FStar_TypeChecker_Env.solver_t ->
-    Prims.string ->
-      ((Prims.int * Prims.int * FStar_TypeChecker_Env.solver_depth_t *
-        Prims.int) * Prims.int) -> FStar_TypeChecker_Env.env)
-  =
-  fun solver ->
-    fun msg ->
-      fun uu___ ->
-        match uu___ with
-        | (ctx_depth, opt_depth) ->
-            let env =
-              FStar_TypeChecker_Tc.rollback_context solver msg
-                (FStar_Pervasives_Native.Some ctx_depth) in
-            (FStar_Options.rollback (FStar_Pervasives_Native.Some opt_depth);
-             env)
-let (pop_repl :
-  Prims.string ->
-    FStar_Interactive_JsonHelper.repl_state ->
-      FStar_Interactive_JsonHelper.repl_state)
-  =
-  fun msg ->
-    fun st ->
-      let uu___ = FStar_Compiler_Effect.op_Bang repl_stack in
-      match uu___ with
-      | [] -> failwith "Too many pops"
-      | (depth, (uu___1, st'))::stack_tl ->
-          let env =
-            rollback_env
-              (st.FStar_Interactive_JsonHelper.repl_env).FStar_TypeChecker_Env.solver
-              msg depth in
-          (FStar_Compiler_Effect.op_Colon_Equals repl_stack stack_tl;
-           (let uu___4 =
-              FStar_Compiler_Util.physical_equality env
-                st'.FStar_Interactive_JsonHelper.repl_env in
-            FStar_Common.runtime_assert uu___4 "Inconsistent stack state");
-           st')
-let (tc_one :
-  FStar_TypeChecker_Env.env_t ->
-    Prims.string FStar_Pervasives_Native.option ->
-      Prims.string -> FStar_TypeChecker_Env.env_t)
-  =
-  fun env ->
-    fun intf_opt ->
-      fun modf ->
-        let parse_data =
-          let uu___ =
-            let uu___1 = FStar_TypeChecker_Env.dep_graph env in
-            FStar_Parser_Dep.parsing_data_of uu___1 in
-          FStar_Compiler_Effect.op_Bar_Greater modf uu___ in
-        let uu___ =
-          FStar_Universal.tc_one_file_for_ide env intf_opt modf parse_data in
-        match uu___ with | (uu___1, env1) -> env1
-let (run_repl_task :
-  FStar_Interactive_JsonHelper.optmod_t ->
-    FStar_TypeChecker_Env.env_t ->
-      FStar_Interactive_JsonHelper.repl_task ->
-        (FStar_Interactive_JsonHelper.optmod_t * FStar_TypeChecker_Env.env_t))
-  =
-  fun curmod ->
-    fun env ->
-      fun task ->
-        match task with
-        | FStar_Interactive_JsonHelper.LDInterleaved (intf, impl) ->
-            let uu___ =
-              tc_one env
-                (FStar_Pervasives_Native.Some
-                   (intf.FStar_Interactive_JsonHelper.tf_fname))
-                impl.FStar_Interactive_JsonHelper.tf_fname in
-            (curmod, uu___)
-        | FStar_Interactive_JsonHelper.LDSingle intf_or_impl ->
-            let uu___ =
-              tc_one env FStar_Pervasives_Native.None
-                intf_or_impl.FStar_Interactive_JsonHelper.tf_fname in
-            (curmod, uu___)
-        | FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile intf ->
-            let uu___ =
-              FStar_Universal.load_interface_decls env
-                intf.FStar_Interactive_JsonHelper.tf_fname in
-            (curmod, uu___)
-        | FStar_Interactive_JsonHelper.PushFragment frag ->
-            FStar_Universal.tc_one_fragment curmod env frag
-        | FStar_Interactive_JsonHelper.Noop -> (curmod, env)
-let (query_of_ids :
-  FStar_Ident.ident Prims.list -> FStar_Interactive_CompletionTable.query) =
-  fun ids -> FStar_Compiler_List.map FStar_Ident.string_of_id ids
-let (query_of_lid :
-  FStar_Ident.lident -> FStar_Interactive_CompletionTable.query) =
-  fun lid ->
-    let uu___ =
-      let uu___1 = FStar_Ident.ns_of_lid lid in
-      let uu___2 = let uu___3 = FStar_Ident.ident_of_lid lid in [uu___3] in
-      FStar_Compiler_List.op_At uu___1 uu___2 in
-    query_of_ids uu___
-let (update_names_from_event :
-  Prims.string ->
-    FStar_Interactive_CompletionTable.table ->
-      name_tracking_event -> FStar_Interactive_CompletionTable.table)
-  =
-  fun cur_mod_str ->
-    fun table ->
-      fun evt ->
-        let is_cur_mod lid =
-          let uu___ = FStar_Ident.string_of_lid lid in uu___ = cur_mod_str in
-        match evt with
-        | NTAlias (host, id, included) ->
-            let uu___ = is_cur_mod host in
-            if uu___
-            then
-              let uu___1 = FStar_Ident.string_of_id id in
-              let uu___2 = query_of_lid included in
-              FStar_Interactive_CompletionTable.register_alias table uu___1
-                [] uu___2
-            else table
-        | NTOpen (host, (included, kind)) ->
-            let uu___ = is_cur_mod host in
-            if uu___
-            then
-              let uu___1 = query_of_lid included in
-              FStar_Interactive_CompletionTable.register_open table
-                (kind = FStar_Syntax_DsEnv.Open_module) [] uu___1
-            else table
-        | NTInclude (host, included) ->
-            let uu___ =
-              let uu___1 = is_cur_mod host in
-              if uu___1 then [] else query_of_lid host in
-            let uu___1 = query_of_lid included in
-            FStar_Interactive_CompletionTable.register_include table uu___
-              uu___1
-        | NTBinding binding ->
-            let lids =
-              match binding with
-              | FStar_Pervasives.Inl (FStar_Syntax_Syntax.Binding_lid
-                  (lid, uu___)) -> [lid]
-              | FStar_Pervasives.Inr (lids1, uu___) -> lids1
-              | uu___ -> [] in
-            FStar_Compiler_List.fold_left
-              (fun tbl ->
-                 fun lid ->
-                   let ns_query =
-                     let uu___ =
-                       let uu___1 = FStar_Ident.nsstr lid in
-                       uu___1 = cur_mod_str in
-                     if uu___
-                     then []
-                     else
-                       (let uu___2 = FStar_Ident.ns_of_lid lid in
-                        query_of_ids uu___2) in
-                   let uu___ =
-                     let uu___1 = FStar_Ident.ident_of_lid lid in
-                     FStar_Ident.string_of_id uu___1 in
-                   FStar_Interactive_CompletionTable.insert tbl ns_query
-                     uu___ lid) table lids
-let (commit_name_tracking' :
-  FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option ->
-    FStar_Interactive_CompletionTable.table ->
-      name_tracking_event Prims.list ->
-        FStar_Interactive_CompletionTable.table)
-  =
-  fun cur_mod ->
-    fun names ->
-      fun name_events ->
-        let cur_mod_str =
-          match cur_mod with
-          | FStar_Pervasives_Native.None -> ""
-          | FStar_Pervasives_Native.Some md ->
-              let uu___ = FStar_Syntax_Syntax.mod_name md in
-              FStar_Ident.string_of_lid uu___ in
-        let updater = update_names_from_event cur_mod_str in
-        FStar_Compiler_List.fold_left updater names name_events
-let (commit_name_tracking :
-  FStar_Interactive_JsonHelper.repl_state ->
-    name_tracking_event Prims.list -> FStar_Interactive_JsonHelper.repl_state)
-  =
-  fun st ->
-    fun name_events ->
-      let names =
-        commit_name_tracking' st.FStar_Interactive_JsonHelper.repl_curmod
-          st.FStar_Interactive_JsonHelper.repl_names name_events in
-      {
-        FStar_Interactive_JsonHelper.repl_line =
-          (st.FStar_Interactive_JsonHelper.repl_line);
-        FStar_Interactive_JsonHelper.repl_column =
-          (st.FStar_Interactive_JsonHelper.repl_column);
-        FStar_Interactive_JsonHelper.repl_fname =
-          (st.FStar_Interactive_JsonHelper.repl_fname);
-        FStar_Interactive_JsonHelper.repl_deps_stack =
-          (st.FStar_Interactive_JsonHelper.repl_deps_stack);
-        FStar_Interactive_JsonHelper.repl_curmod =
-          (st.FStar_Interactive_JsonHelper.repl_curmod);
-        FStar_Interactive_JsonHelper.repl_env =
-          (st.FStar_Interactive_JsonHelper.repl_env);
-        FStar_Interactive_JsonHelper.repl_stdin =
-          (st.FStar_Interactive_JsonHelper.repl_stdin);
-        FStar_Interactive_JsonHelper.repl_names = names
-      }
-let (fresh_name_tracking_hooks :
-  unit ->
-    (name_tracking_event Prims.list FStar_Compiler_Effect.ref *
-      FStar_Syntax_DsEnv.dsenv_hooks * FStar_TypeChecker_Env.tcenv_hooks))
-  =
-  fun uu___ ->
-    let events = FStar_Compiler_Util.mk_ref [] in
-    let push_event evt =
-      let uu___1 =
-        let uu___2 = FStar_Compiler_Effect.op_Bang events in evt :: uu___2 in
-      FStar_Compiler_Effect.op_Colon_Equals events uu___1 in
-    let uu___1 =
-      FStar_Syntax_DsEnv.mk_dsenv_hooks
-        (fun dsenv ->
-           fun op ->
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_DsEnv.current_module dsenv in
-                 (uu___4, op) in
-               NTOpen uu___3 in
-             push_event uu___2)
-        (fun dsenv ->
-           fun ns ->
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_DsEnv.current_module dsenv in
-                 (uu___4, ns) in
-               NTInclude uu___3 in
-             push_event uu___2)
-        (fun dsenv ->
-           fun x ->
-             fun l ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_DsEnv.current_module dsenv in
-                   (uu___4, x, l) in
-                 NTAlias uu___3 in
-               push_event uu___2) in
-    (events, uu___1,
-      {
-        FStar_TypeChecker_Env.tc_push_in_gamma_hook =
-          (fun uu___2 -> fun s -> push_event (NTBinding s))
-      })
-let (track_name_changes :
-  FStar_TypeChecker_Env.env_t ->
-    (FStar_TypeChecker_Env.env_t *
-      (FStar_TypeChecker_Env.env_t ->
-         (FStar_TypeChecker_Env.env_t * name_tracking_event Prims.list))))
-  =
-  fun env ->
-    let set_hooks dshooks tchooks env1 =
-      let uu___ =
-        FStar_Universal.with_dsenv_of_tcenv env1
-          (fun dsenv ->
-             let uu___1 = FStar_Syntax_DsEnv.set_ds_hooks dsenv dshooks in
-             ((), uu___1)) in
-      match uu___ with
-      | ((), tcenv') -> FStar_TypeChecker_Env.set_tc_hooks tcenv' tchooks in
-    let uu___ =
-      let uu___1 =
-        FStar_Syntax_DsEnv.ds_hooks env.FStar_TypeChecker_Env.dsenv in
-      let uu___2 = FStar_TypeChecker_Env.tc_hooks env in (uu___1, uu___2) in
-    match uu___ with
-    | (old_dshooks, old_tchooks) ->
-        let uu___1 = fresh_name_tracking_hooks () in
-        (match uu___1 with
-         | (events, new_dshooks, new_tchooks) ->
-             let uu___2 = set_hooks new_dshooks new_tchooks env in
-             (uu___2,
-               ((fun env1 ->
-                   let uu___3 = set_hooks old_dshooks old_tchooks env1 in
-                   let uu___4 =
-                     let uu___5 = FStar_Compiler_Effect.op_Bang events in
-                     FStar_Compiler_List.rev uu___5 in
-                   (uu___3, uu___4)))))
-let (repl_tx :
-  FStar_Interactive_JsonHelper.repl_state ->
-    push_kind ->
-      FStar_Interactive_JsonHelper.repl_task ->
-        (FStar_Interactive_JsonHelper.assoct FStar_Pervasives_Native.option *
-          FStar_Interactive_JsonHelper.repl_state))
-  =
-  fun st ->
-    fun push_kind1 ->
-      fun task ->
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 let st1 = push_repl "repl_tx" push_kind1 task st in
-                 let uu___1 =
-                   track_name_changes
-                     st1.FStar_Interactive_JsonHelper.repl_env in
-                 (match uu___1 with
-                  | (env, finish_name_tracking) ->
-                      let uu___2 =
-                        run_repl_task
-                          st1.FStar_Interactive_JsonHelper.repl_curmod env
-                          task in
-                      (match uu___2 with
-                       | (curmod, env1) ->
-                           let st2 =
-                             {
-                               FStar_Interactive_JsonHelper.repl_line =
-                                 (st1.FStar_Interactive_JsonHelper.repl_line);
-                               FStar_Interactive_JsonHelper.repl_column =
-                                 (st1.FStar_Interactive_JsonHelper.repl_column);
-                               FStar_Interactive_JsonHelper.repl_fname =
-                                 (st1.FStar_Interactive_JsonHelper.repl_fname);
-                               FStar_Interactive_JsonHelper.repl_deps_stack =
-                                 (st1.FStar_Interactive_JsonHelper.repl_deps_stack);
-                               FStar_Interactive_JsonHelper.repl_curmod =
-                                 curmod;
-                               FStar_Interactive_JsonHelper.repl_env = env1;
-                               FStar_Interactive_JsonHelper.repl_stdin =
-                                 (st1.FStar_Interactive_JsonHelper.repl_stdin);
-                               FStar_Interactive_JsonHelper.repl_names =
-                                 (st1.FStar_Interactive_JsonHelper.repl_names)
-                             } in
-                           let uu___3 = finish_name_tracking env1 in
-                           (match uu___3 with
-                            | (env2, name_events) ->
-                                let uu___4 =
-                                  commit_name_tracking st2 name_events in
-                                (FStar_Pervasives_Native.None, uu___4))))) ()
-        with
-        | FStar_Compiler_Effect.Failure msg ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Interactive_JsonHelper.js_diag
-                  st.FStar_Interactive_JsonHelper.repl_fname msg
-                  FStar_Pervasives_Native.None in
-              FStar_Pervasives_Native.Some uu___2 in
-            (uu___1, st)
-        | FStar_Compiler_Util.SigInt ->
-            (FStar_Compiler_Util.print_error "[E] Interrupt";
-             (FStar_Pervasives_Native.None, st))
-        | FStar_Errors.Error (e, msg, r, _ctx) ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Interactive_JsonHelper.js_diag
-                  st.FStar_Interactive_JsonHelper.repl_fname msg
-                  (FStar_Pervasives_Native.Some r) in
-              FStar_Pervasives_Native.Some uu___2 in
-            (uu___1, st)
-        | FStar_Errors.Err (e, msg, _ctx) ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Interactive_JsonHelper.js_diag
-                  st.FStar_Interactive_JsonHelper.repl_fname msg
-                  FStar_Pervasives_Native.None in
-              FStar_Pervasives_Native.Some uu___2 in
-            (uu___1, st)
-        | FStar_Errors.Stop ->
-            (FStar_Compiler_Util.print_error "[E] Stop";
-             (FStar_Pervasives_Native.None, st))
-let (tf_of_fname : Prims.string -> FStar_Interactive_JsonHelper.timed_fname)
-  =
-  fun fname ->
-    let uu___ = FStar_Parser_ParseIt.get_file_last_modification_time fname in
-    {
-      FStar_Interactive_JsonHelper.tf_fname = fname;
-      FStar_Interactive_JsonHelper.tf_modtime = uu___
-    }
-let (update_task_timestamps :
-  FStar_Interactive_JsonHelper.repl_task ->
-    FStar_Interactive_JsonHelper.repl_task)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Interactive_JsonHelper.LDInterleaved (intf, impl) ->
-        let uu___1 =
-          let uu___2 = tf_of_fname intf.FStar_Interactive_JsonHelper.tf_fname in
-          let uu___3 = tf_of_fname impl.FStar_Interactive_JsonHelper.tf_fname in
-          (uu___2, uu___3) in
-        FStar_Interactive_JsonHelper.LDInterleaved uu___1
-    | FStar_Interactive_JsonHelper.LDSingle intf_or_impl ->
-        let uu___1 =
-          tf_of_fname intf_or_impl.FStar_Interactive_JsonHelper.tf_fname in
-        FStar_Interactive_JsonHelper.LDSingle uu___1
-    | FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile intf ->
-        let uu___1 = tf_of_fname intf.FStar_Interactive_JsonHelper.tf_fname in
-        FStar_Interactive_JsonHelper.LDInterfaceOfCurrentFile uu___1
-    | other -> other
-let (repl_ldtx :
-  FStar_Interactive_JsonHelper.repl_state ->
-    FStar_Interactive_JsonHelper.repl_task Prims.list -> either_replst)
-  =
-  fun st ->
-    fun tasks ->
-      let rec revert_many st1 uu___ =
-        match uu___ with
-        | [] -> st1
-        | (_id, (task, _st'))::entries ->
-            let st' = pop_repl "repl_ldtx" st1 in
-            let dep_graph =
-              FStar_TypeChecker_Env.dep_graph
-                st1.FStar_Interactive_JsonHelper.repl_env in
-            let st'1 =
-              let uu___1 =
-                FStar_TypeChecker_Env.set_dep_graph
-                  st'.FStar_Interactive_JsonHelper.repl_env dep_graph in
-              {
-                FStar_Interactive_JsonHelper.repl_line =
-                  (st'.FStar_Interactive_JsonHelper.repl_line);
-                FStar_Interactive_JsonHelper.repl_column =
-                  (st'.FStar_Interactive_JsonHelper.repl_column);
-                FStar_Interactive_JsonHelper.repl_fname =
-                  (st'.FStar_Interactive_JsonHelper.repl_fname);
-                FStar_Interactive_JsonHelper.repl_deps_stack =
-                  (st'.FStar_Interactive_JsonHelper.repl_deps_stack);
-                FStar_Interactive_JsonHelper.repl_curmod =
-                  (st'.FStar_Interactive_JsonHelper.repl_curmod);
-                FStar_Interactive_JsonHelper.repl_env = uu___1;
-                FStar_Interactive_JsonHelper.repl_stdin =
-                  (st'.FStar_Interactive_JsonHelper.repl_stdin);
-                FStar_Interactive_JsonHelper.repl_names =
-                  (st'.FStar_Interactive_JsonHelper.repl_names)
-              } in
-            revert_many st'1 entries in
-      let rec aux st1 tasks1 previous =
-        match (tasks1, previous) with
-        | ([], []) -> FStar_Pervasives.Inl st1
-        | (task::tasks2, []) ->
-            let timestamped_task = update_task_timestamps task in
-            let uu___ = repl_tx st1 LaxCheck timestamped_task in
-            (match uu___ with
-             | (diag, st2) ->
-                 if Prims.op_Negation (FStar_Compiler_Util.is_some diag)
-                 then
-                   let uu___1 =
-                     let uu___2 = FStar_Compiler_Effect.op_Bang repl_stack in
-                     {
-                       FStar_Interactive_JsonHelper.repl_line =
-                         (st2.FStar_Interactive_JsonHelper.repl_line);
-                       FStar_Interactive_JsonHelper.repl_column =
-                         (st2.FStar_Interactive_JsonHelper.repl_column);
-                       FStar_Interactive_JsonHelper.repl_fname =
-                         (st2.FStar_Interactive_JsonHelper.repl_fname);
-                       FStar_Interactive_JsonHelper.repl_deps_stack = uu___2;
-                       FStar_Interactive_JsonHelper.repl_curmod =
-                         (st2.FStar_Interactive_JsonHelper.repl_curmod);
-                       FStar_Interactive_JsonHelper.repl_env =
-                         (st2.FStar_Interactive_JsonHelper.repl_env);
-                       FStar_Interactive_JsonHelper.repl_stdin =
-                         (st2.FStar_Interactive_JsonHelper.repl_stdin);
-                       FStar_Interactive_JsonHelper.repl_names =
-                         (st2.FStar_Interactive_JsonHelper.repl_names)
-                     } in
-                   aux uu___1 tasks2 []
-                 else FStar_Pervasives.Inr st2)
-        | (task::tasks2, prev::previous1) when
-            let uu___ = update_task_timestamps task in
-            (FStar_Pervasives_Native.fst (FStar_Pervasives_Native.snd prev))
-              = uu___
-            -> aux st1 tasks2 previous1
-        | (tasks2, previous1) ->
-            let uu___ = revert_many st1 previous1 in aux uu___ tasks2 [] in
-      aux st tasks
-        (FStar_Compiler_List.rev
-           st.FStar_Interactive_JsonHelper.repl_deps_stack)
-let (ld_deps :
-  FStar_Interactive_JsonHelper.repl_state ->
-    ((FStar_Interactive_JsonHelper.repl_state * Prims.string Prims.list),
-      FStar_Interactive_JsonHelper.repl_state) FStar_Pervasives.either)
-  =
-  fun st ->
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             let uu___1 =
-               deps_and_repl_ld_tasks_of_our_file
-                 st.FStar_Interactive_JsonHelper.repl_fname in
-             (match uu___1 with
-              | (deps, tasks, dep_graph) ->
-                  let st1 =
-                    let uu___2 =
-                      FStar_TypeChecker_Env.set_dep_graph
-                        st.FStar_Interactive_JsonHelper.repl_env dep_graph in
-                    {
-                      FStar_Interactive_JsonHelper.repl_line =
-                        (st.FStar_Interactive_JsonHelper.repl_line);
-                      FStar_Interactive_JsonHelper.repl_column =
-                        (st.FStar_Interactive_JsonHelper.repl_column);
-                      FStar_Interactive_JsonHelper.repl_fname =
-                        (st.FStar_Interactive_JsonHelper.repl_fname);
-                      FStar_Interactive_JsonHelper.repl_deps_stack =
-                        (st.FStar_Interactive_JsonHelper.repl_deps_stack);
-                      FStar_Interactive_JsonHelper.repl_curmod =
-                        (st.FStar_Interactive_JsonHelper.repl_curmod);
-                      FStar_Interactive_JsonHelper.repl_env = uu___2;
-                      FStar_Interactive_JsonHelper.repl_stdin =
-                        (st.FStar_Interactive_JsonHelper.repl_stdin);
-                      FStar_Interactive_JsonHelper.repl_names =
-                        (st.FStar_Interactive_JsonHelper.repl_names)
-                    } in
-                  let uu___2 = repl_ldtx st1 tasks in
-                  (match uu___2 with
-                   | FStar_Pervasives.Inr st2 -> FStar_Pervasives.Inr st2
-                   | FStar_Pervasives.Inl st2 ->
-                       FStar_Pervasives.Inl (st2, deps)))) ()
-    with
-    | FStar_Errors.Err (e, msg, ctx) ->
-        (FStar_Compiler_Util.print1_error "[E] Failed to load deps. %s" msg;
-         FStar_Pervasives.Inr st)
-    | exn ->
-        ((let uu___2 = FStar_Compiler_Util.message_of_exn exn in
-          FStar_Compiler_Util.print1_error
-            "[E] Failed to load deps. Message: %s" uu___2);
-         FStar_Pervasives.Inr st)
-let (add_module_completions :
-  Prims.string ->
-    Prims.string Prims.list ->
-      FStar_Interactive_CompletionTable.table ->
-        FStar_Interactive_CompletionTable.table)
-  =
-  fun this_fname ->
-    fun deps ->
-      fun table ->
-        let capitalize str =
-          if str = ""
-          then str
-          else
-            (let first =
-               FStar_String.substring str Prims.int_zero Prims.int_one in
-             let uu___1 =
-               FStar_String.substring str Prims.int_one
-                 ((FStar_String.length str) - Prims.int_one) in
-             Prims.op_Hat (FStar_String.uppercase first) uu___1) in
-        let mods = FStar_Parser_Dep.build_inclusion_candidates_list () in
-        let loaded_mods_set =
-          let uu___ = FStar_Compiler_Util.psmap_empty () in
-          let uu___1 = let uu___2 = FStar_Options.prims () in uu___2 :: deps in
-          FStar_Compiler_List.fold_left
-            (fun acc ->
-               fun dep ->
-                 let uu___2 = FStar_Parser_Dep.lowercase_module_name dep in
-                 FStar_Compiler_Util.psmap_add acc uu___2 true) uu___ uu___1 in
-        let loaded modname =
-          FStar_Compiler_Util.psmap_find_default loaded_mods_set modname
-            false in
-        let this_mod_key = FStar_Parser_Dep.lowercase_module_name this_fname in
-        FStar_Compiler_List.fold_left
-          (fun table1 ->
-             fun uu___ ->
-               match uu___ with
-               | (modname, mod_path) ->
-                   let mod_key = FStar_String.lowercase modname in
-                   if this_mod_key = mod_key
-                   then table1
-                   else
-                     (let ns_query =
-                        let uu___2 = capitalize modname in
-                        FStar_Compiler_Util.split uu___2 "." in
-                      let uu___2 = loaded mod_key in
-                      FStar_Interactive_CompletionTable.register_module_path
-                        table1 uu___2 mod_path ns_query)) table
-          (FStar_Compiler_List.rev mods)
-let (full_lax :
-  Prims.string ->
-    FStar_Interactive_JsonHelper.repl_state ->
-      (FStar_Interactive_JsonHelper.assoct FStar_Pervasives_Native.option *
-        FStar_Interactive_JsonHelper.repl_state))
-  =
-  fun text ->
-    fun st ->
-      FStar_TypeChecker_Env.toggle_id_info
-        st.FStar_Interactive_JsonHelper.repl_env true;
-      (let frag =
-         {
-           FStar_Parser_ParseIt.frag_fname =
-             (st.FStar_Interactive_JsonHelper.repl_fname);
-           FStar_Parser_ParseIt.frag_text = text;
-           FStar_Parser_ParseIt.frag_line = Prims.int_one;
-           FStar_Parser_ParseIt.frag_col = Prims.int_zero
-         } in
-       let uu___1 = ld_deps st in
-       match uu___1 with
-       | FStar_Pervasives.Inl (st1, deps) ->
-           let names =
-             add_module_completions
-               st1.FStar_Interactive_JsonHelper.repl_fname deps
-               st1.FStar_Interactive_JsonHelper.repl_names in
-           repl_tx
-             {
-               FStar_Interactive_JsonHelper.repl_line =
-                 (st1.FStar_Interactive_JsonHelper.repl_line);
-               FStar_Interactive_JsonHelper.repl_column =
-                 (st1.FStar_Interactive_JsonHelper.repl_column);
-               FStar_Interactive_JsonHelper.repl_fname =
-                 (st1.FStar_Interactive_JsonHelper.repl_fname);
-               FStar_Interactive_JsonHelper.repl_deps_stack =
-                 (st1.FStar_Interactive_JsonHelper.repl_deps_stack);
-               FStar_Interactive_JsonHelper.repl_curmod =
-                 (st1.FStar_Interactive_JsonHelper.repl_curmod);
-               FStar_Interactive_JsonHelper.repl_env =
-                 (st1.FStar_Interactive_JsonHelper.repl_env);
-               FStar_Interactive_JsonHelper.repl_stdin =
-                 (st1.FStar_Interactive_JsonHelper.repl_stdin);
-               FStar_Interactive_JsonHelper.repl_names = names
-             } LaxCheck (FStar_Interactive_JsonHelper.PushFragment frag)
-       | FStar_Pervasives.Inr st1 -> (FStar_Pervasives_Native.None, st1))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Interactive_QueryHelper.ml b/src/ocaml-output/FStar_Interactive_QueryHelper.ml
deleted file mode 100644
index f85ba89dd10..00000000000
--- a/src/ocaml-output/FStar_Interactive_QueryHelper.ml
+++ /dev/null
@@ -1,289 +0,0 @@
-open Prims
-type position = (Prims.string * Prims.int * Prims.int)
-type sl_reponse =
-  {
-  slr_name: Prims.string ;
-  slr_def_range: FStar_Compiler_Range.range FStar_Pervasives_Native.option ;
-  slr_typ: Prims.string FStar_Pervasives_Native.option ;
-  slr_doc: Prims.string FStar_Pervasives_Native.option ;
-  slr_def: Prims.string FStar_Pervasives_Native.option }
-let (__proj__Mksl_reponse__item__slr_name : sl_reponse -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { slr_name; slr_def_range; slr_typ; slr_doc; slr_def;_} -> slr_name
-let (__proj__Mksl_reponse__item__slr_def_range :
-  sl_reponse -> FStar_Compiler_Range.range FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { slr_name; slr_def_range; slr_typ; slr_doc; slr_def;_} ->
-        slr_def_range
-let (__proj__Mksl_reponse__item__slr_typ :
-  sl_reponse -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { slr_name; slr_def_range; slr_typ; slr_doc; slr_def;_} -> slr_typ
-let (__proj__Mksl_reponse__item__slr_doc :
-  sl_reponse -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { slr_name; slr_def_range; slr_typ; slr_doc; slr_def;_} -> slr_doc
-let (__proj__Mksl_reponse__item__slr_def :
-  sl_reponse -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { slr_name; slr_def_range; slr_typ; slr_doc; slr_def;_} -> slr_def
-let with_printed_effect_args : 'uuuuu . (unit -> 'uuuuu) -> 'uuuuu =
-  fun k ->
-    FStar_Options.with_saved_options
-      (fun uu___ ->
-         FStar_Options.set_option "print_effect_args"
-           (FStar_Options.Bool true);
-         k ())
-let (term_to_string :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.string) =
-  fun tcenv ->
-    fun t ->
-      with_printed_effect_args
-        (fun uu___ -> FStar_TypeChecker_Normalize.term_to_string tcenv t)
-let (sigelt_to_string : FStar_Syntax_Syntax.sigelt -> Prims.string) =
-  fun se ->
-    with_printed_effect_args
-      (fun uu___ -> FStar_Syntax_Print.sigelt_to_string se)
-let (symlookup :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      position FStar_Pervasives_Native.option ->
-        Prims.string Prims.list -> sl_reponse FStar_Pervasives_Native.option)
-  =
-  fun tcenv ->
-    fun symbol ->
-      fun pos_opt ->
-        fun requested_info ->
-          let info_of_lid_str lid_str =
-            let lid =
-              let uu___ =
-                FStar_Compiler_List.map FStar_Ident.id_of_text
-                  (FStar_Compiler_Util.split lid_str ".") in
-              FStar_Ident.lid_of_ids uu___ in
-            let lid1 =
-              let uu___ =
-                FStar_Syntax_DsEnv.resolve_to_fully_qualified_name
-                  tcenv.FStar_TypeChecker_Env.dsenv lid in
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_Compiler_Util.dflt lid) uu___ in
-            let uu___ = FStar_TypeChecker_Env.try_lookup_lid tcenv lid1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___
-              (FStar_Compiler_Util.map_option
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | ((uu___2, typ), r) ->
-                        ((FStar_Pervasives.Inr lid1), typ, r))) in
-          let docs_of_lid lid = FStar_Pervasives_Native.None in
-          let def_of_lid lid =
-            let uu___ = FStar_TypeChecker_Env.lookup_qname tcenv lid in
-            FStar_Compiler_Util.bind_opt uu___
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (FStar_Pervasives.Inr (se, uu___2), uu___3) ->
-                     let uu___4 = sigelt_to_string se in
-                     FStar_Pervasives_Native.Some uu___4
-                 | uu___2 -> FStar_Pervasives_Native.None) in
-          let info_at_pos_opt =
-            FStar_Compiler_Util.bind_opt pos_opt
-              (fun uu___ ->
-                 match uu___ with
-                 | (file, row, col) ->
-                     FStar_TypeChecker_Err.info_at_pos tcenv file row col) in
-          let info_opt =
-            match info_at_pos_opt with
-            | FStar_Pervasives_Native.Some uu___ -> info_at_pos_opt
-            | FStar_Pervasives_Native.None ->
-                if symbol = ""
-                then FStar_Pervasives_Native.None
-                else info_of_lid_str symbol in
-          match info_opt with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some (name_or_lid, typ, rng) ->
-              let name =
-                match name_or_lid with
-                | FStar_Pervasives.Inl name1 -> name1
-                | FStar_Pervasives.Inr lid -> FStar_Ident.string_of_lid lid in
-              let typ_str =
-                if FStar_Compiler_List.mem "type" requested_info
-                then
-                  let uu___ = term_to_string tcenv typ in
-                  FStar_Pervasives_Native.Some uu___
-                else FStar_Pervasives_Native.None in
-              let doc_str =
-                match name_or_lid with
-                | FStar_Pervasives.Inr lid when
-                    FStar_Compiler_List.mem "documentation" requested_info ->
-                    docs_of_lid lid
-                | uu___ -> FStar_Pervasives_Native.None in
-              let def_str =
-                match name_or_lid with
-                | FStar_Pervasives.Inr lid when
-                    FStar_Compiler_List.mem "definition" requested_info ->
-                    def_of_lid lid
-                | uu___ -> FStar_Pervasives_Native.None in
-              let def_range =
-                if FStar_Compiler_List.mem "defined-at" requested_info
-                then FStar_Pervasives_Native.Some rng
-                else FStar_Pervasives_Native.None in
-              FStar_Pervasives_Native.Some
-                {
-                  slr_name = name;
-                  slr_def_range = def_range;
-                  slr_typ = typ_str;
-                  slr_doc = doc_str;
-                  slr_def = def_str
-                }
-let mod_filter :
-  'uuuuu .
-    ('uuuuu * FStar_Interactive_CompletionTable.mod_symbol) ->
-      ('uuuuu * FStar_Interactive_CompletionTable.mod_symbol)
-        FStar_Pervasives_Native.option
-  =
-  fun uu___ ->
-    match uu___ with
-    | (uu___1, FStar_Interactive_CompletionTable.Namespace uu___2) ->
-        FStar_Pervasives_Native.None
-    | (uu___1, FStar_Interactive_CompletionTable.Module
-       { FStar_Interactive_CompletionTable.mod_name = uu___2;
-         FStar_Interactive_CompletionTable.mod_path = uu___3;
-         FStar_Interactive_CompletionTable.mod_loaded = true;_})
-        -> FStar_Pervasives_Native.None
-    | (pth, FStar_Interactive_CompletionTable.Module md) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Interactive_CompletionTable.mod_name md in
-                Prims.op_Hat uu___5 "." in
-              {
-                FStar_Interactive_CompletionTable.mod_name = uu___4;
-                FStar_Interactive_CompletionTable.mod_path =
-                  (md.FStar_Interactive_CompletionTable.mod_path);
-                FStar_Interactive_CompletionTable.mod_loaded =
-                  (md.FStar_Interactive_CompletionTable.mod_loaded)
-              } in
-            FStar_Interactive_CompletionTable.Module uu___3 in
-          (pth, uu___2) in
-        FStar_Pervasives_Native.Some uu___1
-let (ck_completion :
-  FStar_Interactive_JsonHelper.repl_state ->
-    Prims.string ->
-      FStar_Interactive_CompletionTable.completion_result Prims.list)
-  =
-  fun st ->
-    fun search_term ->
-      let needle = FStar_Compiler_Util.split search_term "." in
-      let mods_and_nss =
-        FStar_Interactive_CompletionTable.autocomplete_mod_or_ns
-          st.FStar_Interactive_JsonHelper.repl_names needle mod_filter in
-      let lids =
-        FStar_Interactive_CompletionTable.autocomplete_lid
-          st.FStar_Interactive_JsonHelper.repl_names needle in
-      FStar_Compiler_List.op_At lids mods_and_nss
-let (deflookup :
-  FStar_TypeChecker_Env.env ->
-    FStar_Interactive_JsonHelper.txdoc_pos ->
-      FStar_Interactive_JsonHelper.assoct FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun pos ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Interactive_JsonHelper.pos_munge pos in
-          FStar_Pervasives_Native.Some uu___2 in
-        symlookup env "" uu___1 ["defined-at"] in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          { slr_name = uu___1;
-            slr_def_range = FStar_Pervasives_Native.Some r; slr_typ = uu___2;
-            slr_doc = uu___3; slr_def = uu___4;_}
-          ->
-          let uu___5 = FStar_Interactive_JsonHelper.js_loclink r in
-          FStar_Interactive_JsonHelper.resultResponse uu___5
-      | uu___1 -> FStar_Interactive_JsonHelper.nullResponse
-let (hoverlookup :
-  FStar_TypeChecker_Env.env ->
-    FStar_Interactive_JsonHelper.txdoc_pos ->
-      FStar_Interactive_JsonHelper.assoct FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun pos ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Interactive_JsonHelper.pos_munge pos in
-          FStar_Pervasives_Native.Some uu___2 in
-        symlookup env "" uu___1 ["type"; "definition"] in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          { slr_name = n; slr_def_range = uu___1;
-            slr_typ = FStar_Pervasives_Native.Some t; slr_doc = uu___2;
-            slr_def = FStar_Pervasives_Native.Some d;_}
-          ->
-          let hovertxt =
-            FStar_Compiler_Util.format2
-              "```fstar\n%s\n````\n---\n```fstar\n%s\n```" t d in
-          FStar_Interactive_JsonHelper.resultResponse
-            (FStar_Compiler_Util.JsonAssoc
-               [("contents",
-                  (FStar_Compiler_Util.JsonAssoc
-                     [("kind", (FStar_Compiler_Util.JsonStr "markdown"));
-                     ("value", (FStar_Compiler_Util.JsonStr hovertxt))]))])
-      | uu___1 -> FStar_Interactive_JsonHelper.nullResponse
-let (complookup :
-  FStar_Interactive_JsonHelper.repl_state ->
-    FStar_Interactive_JsonHelper.txdoc_pos ->
-      FStar_Interactive_JsonHelper.assoct FStar_Pervasives_Native.option)
-  =
-  fun st ->
-    fun pos ->
-      let uu___ = FStar_Interactive_JsonHelper.pos_munge pos in
-      match uu___ with
-      | (file, row, current_col) ->
-          let uu___1 = FStar_Parser_ParseIt.read_vfs_entry file in
-          (match uu___1 with
-           | FStar_Pervasives_Native.Some (uu___2, text) ->
-               let rec find_col l =
-                 match l with
-                 | [] -> Prims.int_zero
-                 | h::t ->
-                     if
-                       (h = 32) &&
-                         ((FStar_Compiler_List.length t) < current_col)
-                     then (FStar_Compiler_List.length t) + Prims.int_one
-                     else find_col t in
-               let str =
-                 FStar_Compiler_List.nth
-                   (FStar_Compiler_Util.splitlines text)
-                   (row - Prims.int_one) in
-               let explode s =
-                 let rec exp i l =
-                   if i < Prims.int_zero
-                   then l
-                   else
-                     (let uu___4 =
-                        let uu___5 = FStar_String.get s i in uu___5 :: l in
-                      exp (i - Prims.int_one) uu___4) in
-                 exp ((FStar_String.length s) - Prims.int_one) [] in
-               let begin_col =
-                 let uu___3 =
-                   let uu___4 = explode str in FStar_Compiler_List.rev uu___4 in
-                 find_col uu___3 in
-               let term =
-                 FStar_Compiler_Util.substring str begin_col
-                   (current_col - begin_col) in
-               let items = ck_completion st term in
-               let l =
-                 FStar_Compiler_List.map
-                   (fun r ->
-                      FStar_Compiler_Util.JsonAssoc
-                        [("label",
-                           (FStar_Compiler_Util.JsonStr
-                              (r.FStar_Interactive_CompletionTable.completion_candidate)))])
-                   items in
-               FStar_Interactive_JsonHelper.resultResponse
-                 (FStar_Compiler_Util.JsonList l))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Main.ml b/src/ocaml-output/FStar_Main.ml
deleted file mode 100644
index 70fa5d09dee..00000000000
--- a/src/ocaml-output/FStar_Main.ml
+++ /dev/null
@@ -1,345 +0,0 @@
-open Prims
-let (uu___0 : unit) = FStar_Version.dummy ()
-let (process_args :
-  unit -> (FStar_Getopt.parse_cmdline_res * Prims.string Prims.list)) =
-  fun uu___ -> FStar_Options.parse_cmd_line ()
-let (cleanup : unit -> unit) = fun uu___ -> FStar_Compiler_Util.kill_all ()
-let (finished_message :
-  (Prims.bool * FStar_Ident.lident) Prims.list -> Prims.int -> unit) =
-  fun fmods ->
-    fun errs ->
-      let print_to =
-        if errs > Prims.int_zero
-        then FStar_Compiler_Util.print_error
-        else FStar_Compiler_Util.print_string in
-      let uu___ =
-        let uu___1 = FStar_Options.silent () in Prims.op_Negation uu___1 in
-      if uu___
-      then
-        (FStar_Compiler_Effect.op_Bar_Greater fmods
-           (FStar_Compiler_List.iter
-              (fun uu___2 ->
-                 match uu___2 with
-                 | (iface, name) ->
-                     let tag =
-                       if iface then "i'face (or impl+i'face)" else "module" in
-                     let uu___3 =
-                       let uu___4 = FStar_Ident.string_of_lid name in
-                       FStar_Options.should_print_message uu___4 in
-                     if uu___3
-                     then
-                       let uu___4 =
-                         let uu___5 = FStar_Ident.string_of_lid name in
-                         FStar_Compiler_Util.format2 "Verified %s: %s\n" tag
-                           uu___5 in
-                       print_to uu___4
-                     else ()));
-         if errs > Prims.int_zero
-         then
-           (if errs = Prims.int_one
-            then
-              FStar_Compiler_Util.print_error
-                "1 error was reported (see above)\n"
-            else
-              (let uu___3 = FStar_Compiler_Util.string_of_int errs in
-               FStar_Compiler_Util.print1_error
-                 "%s errors were reported (see above)\n" uu___3))
-         else
-           (let uu___3 =
-              FStar_Compiler_Util.colorize_bold
-                "All verification conditions discharged successfully" in
-            FStar_Compiler_Util.print1 "%s\n" uu___3))
-      else ()
-let (report_errors : (Prims.bool * FStar_Ident.lident) Prims.list -> unit) =
-  fun fmods ->
-    (let uu___1 = FStar_Errors.report_all () in
-     FStar_Compiler_Effect.op_Bar_Greater uu___1 (fun uu___2 -> ()));
-    (let nerrs = FStar_Errors.get_err_count () in
-     if nerrs > Prims.int_zero
-     then
-       (finished_message fmods nerrs;
-        FStar_Compiler_Effect.exit Prims.int_one)
-     else ())
-let (load_native_tactics : unit -> unit) =
-  fun uu___ ->
-    let modules_to_load =
-      let uu___1 = FStar_Options.load () in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (FStar_Compiler_List.map FStar_Ident.lid_of_str) in
-    let cmxs_to_load =
-      let uu___1 = FStar_Options.load_cmxs () in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (FStar_Compiler_List.map FStar_Ident.lid_of_str) in
-    let ml_module_name m = FStar_Extraction_ML_Util.ml_module_name_of_lid m in
-    let ml_file m =
-      let uu___1 = ml_module_name m in Prims.op_Hat uu___1 ".ml" in
-    let cmxs_file m =
-      let cmxs = let uu___1 = ml_module_name m in Prims.op_Hat uu___1 ".cmxs" in
-      let uu___1 = FStar_Options.find_file cmxs in
-      match uu___1 with
-      | FStar_Pervasives_Native.Some f -> f
-      | FStar_Pervasives_Native.None ->
-          if FStar_Compiler_List.contains m cmxs_to_load
-          then
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Util.format1 "Could not find %s to load" cmxs in
-              (FStar_Errors.Fatal_FailToCompileNativeTactic, uu___3) in
-            FStar_Errors.raise_err uu___2
-          else
-            (let uu___3 =
-               let uu___4 = ml_file m in FStar_Options.find_file uu___4 in
-             match uu___3 with
-             | FStar_Pervasives_Native.None ->
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 = ml_file m in
-                     FStar_Compiler_Util.format1
-                       "Failed to compile native tactic; extracted module %s not found"
-                       uu___6 in
-                   (FStar_Errors.Fatal_FailToCompileNativeTactic, uu___5) in
-                 FStar_Errors.raise_err uu___4
-             | FStar_Pervasives_Native.Some ml ->
-                 let dir = FStar_Compiler_Util.dirname ml in
-                 ((let uu___5 = let uu___6 = ml_module_name m in [uu___6] in
-                   FStar_Tactics_Load.compile_modules dir uu___5);
-                  (let uu___5 = FStar_Options.find_file cmxs in
-                   match uu___5 with
-                   | FStar_Pervasives_Native.None ->
-                       let uu___6 =
-                         let uu___7 =
-                           FStar_Compiler_Util.format1
-                             "Failed to compile native tactic; compiled object %s not found"
-                             cmxs in
-                         (FStar_Errors.Fatal_FailToCompileNativeTactic,
-                           uu___7) in
-                       FStar_Errors.raise_err uu___6
-                   | FStar_Pervasives_Native.Some f -> f))) in
-    let cmxs_files =
-      FStar_Compiler_Effect.op_Bar_Greater
-        (FStar_Compiler_List.op_At modules_to_load cmxs_to_load)
-        (FStar_Compiler_List.map cmxs_file) in
-    (let uu___2 = FStar_Options.debug_any () in
-     if uu___2
-     then
-       FStar_Compiler_Util.print1 "Will try to load cmxs files: %s\n"
-         (FStar_String.concat ", " cmxs_files)
-     else ());
-    (let uu___3 =
-       let uu___4 = FStar_Options.no_load_fstartaclib () in
-       Prims.op_Negation uu___4 in
-     if uu___3 then FStar_Tactics_Load.try_load_lib () else ());
-    FStar_Tactics_Load.load_tactics cmxs_files;
-    (let uu___5 = FStar_Options.use_native_tactics () in
-     FStar_Compiler_Util.iter_opt uu___5 FStar_Tactics_Load.load_tactics_dir)
-let (fstar_files :
-  Prims.string Prims.list FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let go : 'uuuuu . 'uuuuu -> unit =
-  fun uu___ ->
-    let uu___1 = process_args () in
-    match uu___1 with
-    | (res, filenames) ->
-        (match res with
-         | FStar_Getopt.Help ->
-             (FStar_Options.display_usage ();
-              FStar_Compiler_Effect.exit Prims.int_zero)
-         | FStar_Getopt.Error msg ->
-             (FStar_Compiler_Util.print_error msg;
-              FStar_Compiler_Effect.exit Prims.int_one)
-         | uu___2 when FStar_Options.print_cache_version () ->
-             ((let uu___4 =
-                 FStar_Compiler_Util.string_of_int
-                   FStar_CheckedFiles.cache_version_number in
-               FStar_Compiler_Util.print1 "F* cache version number: %s\n"
-                 uu___4);
-              FStar_Compiler_Effect.exit Prims.int_zero)
-         | FStar_Getopt.Success ->
-             (FStar_Compiler_Effect.op_Colon_Equals fstar_files
-                (FStar_Pervasives_Native.Some filenames);
-              FStar_Syntax_Unionfind.set_ro ();
-              (let uu___4 =
-                 let uu___5 = FStar_Options.dep () in
-                 uu___5 <> FStar_Pervasives_Native.None in
-               if uu___4
-               then
-                 let uu___5 =
-                   FStar_Parser_Dep.collect filenames
-                     FStar_CheckedFiles.load_parsing_data_from_cache in
-                 match uu___5 with
-                 | (uu___6, deps) ->
-                     (FStar_Parser_Dep.print deps; report_errors [])
-               else
-                 (let uu___6 =
-                    (FStar_Options.print ()) ||
-                      (FStar_Options.print_in_place ()) in
-                  if uu___6
-                  then
-                    (if FStar_Platform.is_fstar_compiler_using_ocaml
-                     then
-                       let printing_mode =
-                         let uu___7 = FStar_Options.print () in
-                         if uu___7
-                         then FStar_Prettyprint.FromTempToStdout
-                         else FStar_Prettyprint.FromTempToFile in
-                       FStar_Prettyprint.generate printing_mode filenames
-                     else
-                       failwith
-                         "You seem to be using the F#-generated version ofthe compiler ; \\o\n                         reindenting is not known to work yet with this version")
-                  else
-                    (let uu___8 = FStar_Options.lsp_server () in
-                     if uu___8
-                     then FStar_Interactive_Lsp.start_server ()
-                     else
-                       (load_native_tactics ();
-                        (let uu___11 = FStar_Options.interactive () in
-                         if uu___11
-                         then
-                           (FStar_Syntax_Unionfind.set_rw ();
-                            (match filenames with
-                             | [] ->
-                                 (FStar_Errors.log_issue
-                                    FStar_Compiler_Range.dummyRange
-                                    (FStar_Errors.Error_MissingFileName,
-                                      "--ide: Name of current file missing in command line invocation\n");
-                                  FStar_Compiler_Effect.exit Prims.int_one)
-                             | uu___13::uu___14::uu___15 ->
-                                 (FStar_Errors.log_issue
-                                    FStar_Compiler_Range.dummyRange
-                                    (FStar_Errors.Error_TooManyFiles,
-                                      "--ide: Too many files in command line invocation\n");
-                                  FStar_Compiler_Effect.exit Prims.int_one)
-                             | filename::[] ->
-                                 let uu___13 =
-                                   FStar_Options.legacy_interactive () in
-                                 if uu___13
-                                 then
-                                   FStar_Interactive_Legacy.interactive_mode
-                                     filename
-                                 else
-                                   FStar_Interactive_Ide.interactive_mode
-                                     filename))
-                         else
-                           if
-                             (FStar_Compiler_List.length filenames) >=
-                               Prims.int_one
-                           then
-                             (let uu___13 =
-                                FStar_Dependencies.find_deps_if_needed
-                                  filenames
-                                  FStar_CheckedFiles.load_parsing_data_from_cache in
-                              match uu___13 with
-                              | (filenames1, dep_graph) ->
-                                  let uu___14 =
-                                    FStar_Universal.batch_mode_tc filenames1
-                                      dep_graph in
-                                  (match uu___14 with
-                                   | (tcrs, env, cleanup1) ->
-                                       ((let uu___16 = cleanup1 env in ());
-                                        (let module_names =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             tcrs
-                                             (FStar_Compiler_List.map
-                                                (fun tcr ->
-                                                   FStar_Universal.module_or_interface_name
-                                                     tcr.FStar_CheckedFiles.checked_module)) in
-                                         report_errors module_names;
-                                         finished_message module_names
-                                           Prims.int_zero))))
-                           else
-                             FStar_Errors.raise_error
-                               (FStar_Errors.Error_MissingFileName,
-                                 "No file provided")
-                               FStar_Compiler_Range.dummyRange)))))))
-let (lazy_chooser :
-  FStar_Syntax_Syntax.lazy_kind ->
-    FStar_Syntax_Syntax.lazyinfo ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun k ->
-    fun i ->
-      match k with
-      | FStar_Syntax_Syntax.BadLazy -> failwith "lazy chooser: got a BadLazy"
-      | FStar_Syntax_Syntax.Lazy_bv ->
-          FStar_Reflection_Embeddings.unfold_lazy_bv i
-      | FStar_Syntax_Syntax.Lazy_binder ->
-          FStar_Reflection_Embeddings.unfold_lazy_binder i
-      | FStar_Syntax_Syntax.Lazy_letbinding ->
-          FStar_Reflection_Embeddings.unfold_lazy_letbinding i
-      | FStar_Syntax_Syntax.Lazy_optionstate ->
-          FStar_Reflection_Embeddings.unfold_lazy_optionstate i
-      | FStar_Syntax_Syntax.Lazy_fvar ->
-          FStar_Reflection_Embeddings.unfold_lazy_fvar i
-      | FStar_Syntax_Syntax.Lazy_comp ->
-          FStar_Reflection_Embeddings.unfold_lazy_comp i
-      | FStar_Syntax_Syntax.Lazy_env ->
-          FStar_Reflection_Embeddings.unfold_lazy_env i
-      | FStar_Syntax_Syntax.Lazy_sigelt ->
-          FStar_Reflection_Embeddings.unfold_lazy_sigelt i
-      | FStar_Syntax_Syntax.Lazy_proofstate ->
-          FStar_Tactics_Embedding.unfold_lazy_proofstate i
-      | FStar_Syntax_Syntax.Lazy_goal ->
-          FStar_Tactics_Embedding.unfold_lazy_goal i
-      | FStar_Syntax_Syntax.Lazy_uvar ->
-          FStar_Syntax_Util.exp_string "((uvar))"
-      | FStar_Syntax_Syntax.Lazy_embedding (uu___, t) -> FStar_Thunk.force t
-      | FStar_Syntax_Syntax.Lazy_universe ->
-          FStar_Reflection_Embeddings.unfold_lazy_universe i
-      | FStar_Syntax_Syntax.Lazy_universe_uvar ->
-          FStar_Syntax_Util.exp_string "((universe_uvar))"
-let (setup_hooks : unit -> unit) =
-  fun uu___ ->
-    FStar_Errors.set_parse_warn_error FStar_Parser_ParseIt.parse_warn_error;
-    FStar_Compiler_Effect.op_Colon_Equals FStar_Syntax_Syntax.lazy_chooser
-      (FStar_Pervasives_Native.Some lazy_chooser);
-    FStar_Compiler_Effect.op_Colon_Equals FStar_Syntax_Util.tts_f
-      (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
-    FStar_Compiler_Effect.op_Colon_Equals
-      FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
-let (handle_error : Prims.exn -> unit) =
-  fun e ->
-    if FStar_Errors.handleable e then FStar_Errors.err_exn e else ();
-    (let uu___2 = FStar_Options.trace_error () in
-     if uu___2
-     then
-       let uu___3 = FStar_Compiler_Util.message_of_exn e in
-       let uu___4 = FStar_Compiler_Util.trace_of_exn e in
-       FStar_Compiler_Util.print2_error "Unexpected error\n%s\n%s\n" uu___3
-         uu___4
-     else
-       if Prims.op_Negation (FStar_Errors.handleable e)
-       then
-         (let uu___4 = FStar_Compiler_Util.message_of_exn e in
-          FStar_Compiler_Util.print1_error
-            "Unexpected error; please file a bug report, ideally with a minimized version of the source program that triggered the error.\n%s\n"
-            uu___4)
-       else ());
-    cleanup ();
-    report_errors []
-let main : 'uuuuu . unit -> 'uuuuu =
-  fun uu___ ->
-    try
-      (fun uu___1 ->
-         match () with
-         | () ->
-             (setup_hooks ();
-              (let uu___3 = FStar_Compiler_Util.record_time go in
-               match uu___3 with
-               | (uu___4, time) ->
-                   ((let uu___6 = FStar_Options.query_stats () in
-                     if uu___6
-                     then
-                       let uu___7 = FStar_Compiler_Util.string_of_int time in
-                       let uu___8 =
-                         let uu___9 = FStar_Getopt.cmdline () in
-                         FStar_String.concat " " uu___9 in
-                       FStar_Compiler_Util.print2_error
-                         "TOTAL TIME %s ms: %s\n" uu___7 uu___8
-                     else ());
-                    cleanup ();
-                    FStar_Compiler_Effect.exit Prims.int_zero)))) ()
-    with
-    | uu___1 ->
-        (handle_error uu___1; FStar_Compiler_Effect.exit Prims.int_one)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Options.ml b/src/ocaml-output/FStar_Options.ml
deleted file mode 100644
index bf37a6da9d7..00000000000
--- a/src/ocaml-output/FStar_Options.ml
+++ /dev/null
@@ -1,2543 +0,0 @@
-open Prims
-type debug_level_t =
-  | Low 
-  | Medium 
-  | High 
-  | Extreme 
-  | Other of Prims.string 
-let (uu___is_Low : debug_level_t -> Prims.bool) =
-  fun projectee -> match projectee with | Low -> true | uu___ -> false
-let (uu___is_Medium : debug_level_t -> Prims.bool) =
-  fun projectee -> match projectee with | Medium -> true | uu___ -> false
-let (uu___is_High : debug_level_t -> Prims.bool) =
-  fun projectee -> match projectee with | High -> true | uu___ -> false
-let (uu___is_Extreme : debug_level_t -> Prims.bool) =
-  fun projectee -> match projectee with | Extreme -> true | uu___ -> false
-let (uu___is_Other : debug_level_t -> Prims.bool) =
-  fun projectee -> match projectee with | Other _0 -> true | uu___ -> false
-let (__proj__Other__item___0 : debug_level_t -> Prims.string) =
-  fun projectee -> match projectee with | Other _0 -> _0
-type option_val =
-  | Bool of Prims.bool 
-  | String of Prims.string 
-  | Path of Prims.string 
-  | Int of Prims.int 
-  | List of option_val Prims.list 
-  | Unset 
-let (uu___is_Bool : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | Bool _0 -> true | uu___ -> false
-let (__proj__Bool__item___0 : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | Bool _0 -> _0
-let (uu___is_String : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | String _0 -> true | uu___ -> false
-let (__proj__String__item___0 : option_val -> Prims.string) =
-  fun projectee -> match projectee with | String _0 -> _0
-let (uu___is_Path : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | Path _0 -> true | uu___ -> false
-let (__proj__Path__item___0 : option_val -> Prims.string) =
-  fun projectee -> match projectee with | Path _0 -> _0
-let (uu___is_Int : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | Int _0 -> true | uu___ -> false
-let (__proj__Int__item___0 : option_val -> Prims.int) =
-  fun projectee -> match projectee with | Int _0 -> _0
-let (uu___is_List : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | List _0 -> true | uu___ -> false
-let (__proj__List__item___0 : option_val -> option_val Prims.list) =
-  fun projectee -> match projectee with | List _0 -> _0
-let (uu___is_Unset : option_val -> Prims.bool) =
-  fun projectee -> match projectee with | Unset -> true | uu___ -> false
-type optionstate = option_val FStar_Compiler_Util.smap
-type opt_type =
-  | Const of option_val 
-  | IntStr of Prims.string 
-  | BoolStr 
-  | PathStr of Prims.string 
-  | SimpleStr of Prims.string 
-  | EnumStr of Prims.string Prims.list 
-  | OpenEnumStr of (Prims.string Prims.list * Prims.string) 
-  | PostProcessed of ((option_val -> option_val) * opt_type) 
-  | Accumulated of opt_type 
-  | ReverseAccumulated of opt_type 
-  | WithSideEffect of ((unit -> unit) * opt_type) 
-let (uu___is_Const : opt_type -> Prims.bool) =
-  fun projectee -> match projectee with | Const _0 -> true | uu___ -> false
-let (__proj__Const__item___0 : opt_type -> option_val) =
-  fun projectee -> match projectee with | Const _0 -> _0
-let (uu___is_IntStr : opt_type -> Prims.bool) =
-  fun projectee -> match projectee with | IntStr _0 -> true | uu___ -> false
-let (__proj__IntStr__item___0 : opt_type -> Prims.string) =
-  fun projectee -> match projectee with | IntStr _0 -> _0
-let (uu___is_BoolStr : opt_type -> Prims.bool) =
-  fun projectee -> match projectee with | BoolStr -> true | uu___ -> false
-let (uu___is_PathStr : opt_type -> Prims.bool) =
-  fun projectee -> match projectee with | PathStr _0 -> true | uu___ -> false
-let (__proj__PathStr__item___0 : opt_type -> Prims.string) =
-  fun projectee -> match projectee with | PathStr _0 -> _0
-let (uu___is_SimpleStr : opt_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SimpleStr _0 -> true | uu___ -> false
-let (__proj__SimpleStr__item___0 : opt_type -> Prims.string) =
-  fun projectee -> match projectee with | SimpleStr _0 -> _0
-let (uu___is_EnumStr : opt_type -> Prims.bool) =
-  fun projectee -> match projectee with | EnumStr _0 -> true | uu___ -> false
-let (__proj__EnumStr__item___0 : opt_type -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | EnumStr _0 -> _0
-let (uu___is_OpenEnumStr : opt_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | OpenEnumStr _0 -> true | uu___ -> false
-let (__proj__OpenEnumStr__item___0 :
-  opt_type -> (Prims.string Prims.list * Prims.string)) =
-  fun projectee -> match projectee with | OpenEnumStr _0 -> _0
-let (uu___is_PostProcessed : opt_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PostProcessed _0 -> true | uu___ -> false
-let (__proj__PostProcessed__item___0 :
-  opt_type -> ((option_val -> option_val) * opt_type)) =
-  fun projectee -> match projectee with | PostProcessed _0 -> _0
-let (uu___is_Accumulated : opt_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Accumulated _0 -> true | uu___ -> false
-let (__proj__Accumulated__item___0 : opt_type -> opt_type) =
-  fun projectee -> match projectee with | Accumulated _0 -> _0
-let (uu___is_ReverseAccumulated : opt_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ReverseAccumulated _0 -> true | uu___ -> false
-let (__proj__ReverseAccumulated__item___0 : opt_type -> opt_type) =
-  fun projectee -> match projectee with | ReverseAccumulated _0 -> _0
-let (uu___is_WithSideEffect : opt_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | WithSideEffect _0 -> true | uu___ -> false
-let (__proj__WithSideEffect__item___0 :
-  opt_type -> ((unit -> unit) * opt_type)) =
-  fun projectee -> match projectee with | WithSideEffect _0 -> _0
-let (debug_embedding : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref false
-let (eager_embedding : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref false
-let (__unit_tests__ : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref false
-let (__unit_tests : unit -> Prims.bool) =
-  fun uu___ -> FStar_Compiler_Effect.op_Bang __unit_tests__
-let (__set_unit_tests : unit -> unit) =
-  fun uu___ -> FStar_Compiler_Effect.op_Colon_Equals __unit_tests__ true
-let (__clear_unit_tests : unit -> unit) =
-  fun uu___ -> FStar_Compiler_Effect.op_Colon_Equals __unit_tests__ false
-let (as_bool : option_val -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | Bool b -> b
-    | uu___1 -> failwith "Impos: expected Bool"
-let (as_int : option_val -> Prims.int) =
-  fun uu___ ->
-    match uu___ with | Int b -> b | uu___1 -> failwith "Impos: expected Int"
-let (as_string : option_val -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | String b -> b
-    | Path b -> FStar_Common.try_convert_file_name_to_mixed b
-    | uu___1 -> failwith "Impos: expected String"
-let (as_list' : option_val -> option_val Prims.list) =
-  fun uu___ ->
-    match uu___ with
-    | List ts -> ts
-    | uu___1 -> failwith "Impos: expected List"
-let as_list :
-  'uuuuu . (option_val -> 'uuuuu) -> option_val -> 'uuuuu Prims.list =
-  fun as_t ->
-    fun x ->
-      let uu___ = as_list' x in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (FStar_Compiler_List.map as_t)
-let as_option :
-  'uuuuu .
-    (option_val -> 'uuuuu) ->
-      option_val -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun as_t ->
-    fun uu___ ->
-      match uu___ with
-      | Unset -> FStar_Pervasives_Native.None
-      | v -> let uu___1 = as_t v in FStar_Pervasives_Native.Some uu___1
-let (as_comma_string_list : option_val -> Prims.string Prims.list) =
-  fun uu___ ->
-    match uu___ with
-    | List ls ->
-        let uu___1 =
-          FStar_Compiler_List.map
-            (fun l ->
-               let uu___2 = as_string l in
-               FStar_Compiler_Util.split uu___2 ",") ls in
-        FStar_Compiler_Effect.op_Less_Bar FStar_Compiler_List.flatten uu___1
-    | uu___1 -> failwith "Impos: expected String (comma list)"
-let copy_optionstate :
-  'uuuuu . 'uuuuu FStar_Compiler_Util.smap -> 'uuuuu FStar_Compiler_Util.smap
-  = fun m -> FStar_Compiler_Util.smap_copy m
-let (fstar_options :
-  optionstate Prims.list Prims.list FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let (internal_peek : unit -> optionstate) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang fstar_options in
-      FStar_Compiler_List.hd uu___2 in
-    FStar_Compiler_List.hd uu___1
-let (peek : unit -> optionstate) =
-  fun uu___ -> let uu___1 = internal_peek () in copy_optionstate uu___1
-let (pop : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang fstar_options in
-    match uu___1 with
-    | [] -> failwith "TOO MANY POPS!"
-    | uu___2::[] -> failwith "TOO MANY POPS!"
-    | uu___2::tl -> FStar_Compiler_Effect.op_Colon_Equals fstar_options tl
-let (push : unit -> unit) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 = FStar_Compiler_Effect.op_Bang fstar_options in
-          FStar_Compiler_List.hd uu___4 in
-        FStar_Compiler_List.map copy_optionstate uu___3 in
-      let uu___3 = FStar_Compiler_Effect.op_Bang fstar_options in uu___2 ::
-        uu___3 in
-    FStar_Compiler_Effect.op_Colon_Equals fstar_options uu___1
-let (internal_pop : unit -> Prims.bool) =
-  fun uu___ ->
-    let curstack =
-      let uu___1 = FStar_Compiler_Effect.op_Bang fstar_options in
-      FStar_Compiler_List.hd uu___1 in
-    match curstack with
-    | [] -> failwith "impossible: empty current option stack"
-    | uu___1::[] -> false
-    | uu___1::tl ->
-        ((let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Compiler_Effect.op_Bang fstar_options in
-              FStar_Compiler_List.tl uu___5 in
-            tl :: uu___4 in
-          FStar_Compiler_Effect.op_Colon_Equals fstar_options uu___3);
-         true)
-let (internal_push : unit -> unit) =
-  fun uu___ ->
-    let curstack =
-      let uu___1 = FStar_Compiler_Effect.op_Bang fstar_options in
-      FStar_Compiler_List.hd uu___1 in
-    let stack' =
-      let uu___1 =
-        let uu___2 = FStar_Compiler_List.hd curstack in
-        copy_optionstate uu___2 in
-      uu___1 :: curstack in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Effect.op_Bang fstar_options in
-        FStar_Compiler_List.tl uu___3 in
-      stack' :: uu___2 in
-    FStar_Compiler_Effect.op_Colon_Equals fstar_options uu___1
-let (set : optionstate -> unit) =
-  fun o ->
-    let uu___ = FStar_Compiler_Effect.op_Bang fstar_options in
-    match uu___ with
-    | [] -> failwith "set on empty option stack"
-    | []::uu___1 -> failwith "set on empty current option stack"
-    | (uu___1::tl)::os ->
-        FStar_Compiler_Effect.op_Colon_Equals fstar_options ((o :: tl) :: os)
-let (snapshot : unit -> (Prims.int * unit)) =
-  fun uu___ -> FStar_Common.snapshot push fstar_options ()
-let (rollback : Prims.int FStar_Pervasives_Native.option -> unit) =
-  fun depth -> FStar_Common.rollback pop fstar_options depth
-let (set_option : Prims.string -> option_val -> unit) =
-  fun k ->
-    fun v ->
-      let map = internal_peek () in
-      if k = "report_assumes"
-      then
-        let uu___ = FStar_Compiler_Util.smap_try_find map k in
-        match uu___ with
-        | FStar_Pervasives_Native.Some (String "error") -> ()
-        | uu___1 -> FStar_Compiler_Util.smap_add map k v
-      else FStar_Compiler_Util.smap_add map k v
-let (set_option' : (Prims.string * option_val) -> unit) =
-  fun uu___ -> match uu___ with | (k, v) -> set_option k v
-let (set_admit_smt_queries : Prims.bool -> unit) =
-  fun b -> set_option "admit_smt_queries" (Bool b)
-let (defaults : (Prims.string * option_val) Prims.list) =
-  [("__temp_fast_implicits", (Bool false));
-  ("abort_on", (Int Prims.int_zero));
-  ("admit_smt_queries", (Bool false));
-  ("admit_except", Unset);
-  ("disallow_unification_guards", (Bool false));
-  ("already_cached", Unset);
-  ("cache_checked_modules", (Bool false));
-  ("cache_dir", Unset);
-  ("cache_off", (Bool false));
-  ("compat_pre_core", Unset);
-  ("compat_pre_typed_indexed_effects", (Bool false));
-  ("print_cache_version", (Bool false));
-  ("cmi", (Bool false));
-  ("codegen", Unset);
-  ("codegen-lib", (List []));
-  ("debug", (List []));
-  ("debug_level", (List []));
-  ("defensive", (String "no"));
-  ("dep", Unset);
-  ("detail_errors", (Bool false));
-  ("detail_hint_replay", (Bool false));
-  ("dump_module", (List []));
-  ("eager_subtyping", (Bool false));
-  ("error_contexts", (Bool false));
-  ("expose_interfaces", (Bool false));
-  ("extract", Unset);
-  ("extract_all", (Bool false));
-  ("extract_module", (List []));
-  ("extract_namespace", (List []));
-  ("full_context_dependency", (Bool true));
-  ("hide_uvar_nums", (Bool false));
-  ("hint_info", (Bool false));
-  ("hint_dir", Unset);
-  ("hint_file", Unset);
-  ("in", (Bool false));
-  ("ide", (Bool false));
-  ("ide_id_info_off", (Bool false));
-  ("lsp", (Bool false));
-  ("include", (List []));
-  ("print", (Bool false));
-  ("print_in_place", (Bool false));
-  ("force", (Bool false));
-  ("fuel", Unset);
-  ("ifuel", Unset);
-  ("initial_fuel", (Int (Prims.of_int (2))));
-  ("initial_ifuel", (Int Prims.int_one));
-  ("keep_query_captions", (Bool true));
-  ("lax", (Bool false));
-  ("load", (List []));
-  ("load_cmxs", (List []));
-  ("log_queries", (Bool false));
-  ("log_types", (Bool false));
-  ("max_fuel", (Int (Prims.of_int (8))));
-  ("max_ifuel", (Int (Prims.of_int (2))));
-  ("MLish", (Bool false));
-  ("no_default_includes", (Bool false));
-  ("no_extract", (List []));
-  ("no_load_fstartaclib", (Bool false));
-  ("no_location_info", (Bool false));
-  ("no_smt", (Bool false));
-  ("no_plugins", (Bool false));
-  ("no_tactics", (Bool false));
-  ("normalize_pure_terms_for_extraction", (Bool false));
-  ("odir", Unset);
-  ("prims", Unset);
-  ("pretype", (Bool true));
-  ("prims_ref", Unset);
-  ("print_bound_var_types", (Bool false));
-  ("print_effect_args", (Bool false));
-  ("print_expected_failures", (Bool false));
-  ("print_full_names", (Bool false));
-  ("print_implicits", (Bool false));
-  ("print_universes", (Bool false));
-  ("print_z3_statistics", (Bool false));
-  ("prn", (Bool false));
-  ("quake", (Int Prims.int_zero));
-  ("quake_lo", (Int Prims.int_one));
-  ("quake_hi", (Int Prims.int_one));
-  ("quake_keep", (Bool false));
-  ("query_stats", (Bool false));
-  ("record_hints", (Bool false));
-  ("record_options", (Bool false));
-  ("report_assumes", Unset);
-  ("retry", (Bool false));
-  ("reuse_hint_for", Unset);
-  ("silent", (Bool false));
-  ("smt", Unset);
-  ("smtencoding.elim_box", (Bool false));
-  ("smtencoding.nl_arith_repr", (String "boxwrap"));
-  ("smtencoding.l_arith_repr", (String "boxwrap"));
-  ("smtencoding.valid_intro", (Bool true));
-  ("smtencoding.valid_elim", (Bool false));
-  ("split_queries", (Bool false));
-  ("tactics_failhard", (Bool false));
-  ("tactics_info", (Bool false));
-  ("tactic_raw_binders", (Bool false));
-  ("tactic_trace", (Bool false));
-  ("tactic_trace_d", (Int Prims.int_zero));
-  ("tcnorm", (Bool true));
-  ("timing", (Bool false));
-  ("trace_error", (Bool false));
-  ("ugly", (Bool false));
-  ("unthrottle_inductives", (Bool false));
-  ("unsafe_tactic_exec", (Bool false));
-  ("use_native_tactics", Unset);
-  ("use_eq_at_higher_order", (Bool false));
-  ("use_hints", (Bool false));
-  ("use_hint_hashes", (Bool false));
-  ("using_facts_from", Unset);
-  ("vcgen.optimize_bind_as_seq", Unset);
-  ("verify_module", (List []));
-  ("warn_default_effects", (Bool false));
-  ("z3refresh", (Bool false));
-  ("z3rlimit", (Int (Prims.of_int (5))));
-  ("z3rlimit_factor", (Int Prims.int_one));
-  ("z3seed", (Int Prims.int_zero));
-  ("z3cliopt", (List []));
-  ("z3smtopt", (List []));
-  ("__no_positivity", (Bool false));
-  ("__tactics_nbe", (Bool false));
-  ("warn_error", (List []));
-  ("use_nbe", (Bool false));
-  ("use_nbe_for_extraction", (Bool false));
-  ("trivial_pre_for_unannotated_effectful_fns", (Bool true));
-  ("profile_group_by_decl", (Bool false));
-  ("profile_component", Unset);
-  ("profile", Unset)]
-let (init : unit -> unit) =
-  fun uu___ ->
-    let o = internal_peek () in
-    FStar_Compiler_Util.smap_clear o;
-    FStar_Compiler_Effect.op_Bar_Greater defaults
-      (FStar_Compiler_List.iter set_option')
-let (clear : unit -> unit) =
-  fun uu___ ->
-    let o = FStar_Compiler_Util.smap_create (Prims.of_int (50)) in
-    FStar_Compiler_Effect.op_Colon_Equals fstar_options [[o]]; init ()
-let (_run : unit) = clear ()
-let (get_option : Prims.string -> option_val) =
-  fun s ->
-    let uu___ =
-      let uu___1 = internal_peek () in
-      FStar_Compiler_Util.smap_try_find uu___1 s in
-    match uu___ with
-    | FStar_Pervasives_Native.None ->
-        let uu___1 =
-          let uu___2 = FStar_String.op_Hat s " not found" in
-          FStar_String.op_Hat "Impossible: option " uu___2 in
-        failwith uu___1
-    | FStar_Pervasives_Native.Some s1 -> s1
-let (set_verification_options : optionstate -> unit) =
-  fun o ->
-    let verifopts =
-      ["initial_fuel";
-      "max_fuel";
-      "initial_ifuel";
-      "max_ifuel";
-      "detail_errors";
-      "detail_hint_replay";
-      "no_smt";
-      "quake";
-      "retry";
-      "smtencoding.elim_box";
-      "smtencoding.nl_arith_repr";
-      "smtencoding.l_arith_repr";
-      "smtencoding.valid_intro";
-      "smtencoding.valid_elim";
-      "tcnorm";
-      "no_plugins";
-      "no_tactics";
-      "vcgen.optimize_bind_as_seq";
-      "z3cliopt";
-      "z3smtopt";
-      "z3refresh";
-      "z3rlimit";
-      "z3rlimit_factor";
-      "z3seed";
-      "trivial_pre_for_unannotated_effectful_fns"] in
-    FStar_Compiler_List.iter
-      (fun k ->
-         let uu___ =
-           let uu___1 = FStar_Compiler_Util.smap_try_find o k in
-           FStar_Compiler_Effect.op_Bar_Greater uu___1
-             FStar_Compiler_Util.must in
-         set_option k uu___) verifopts
-let lookup_opt : 'uuuuu . Prims.string -> (option_val -> 'uuuuu) -> 'uuuuu =
-  fun s -> fun c -> let uu___ = get_option s in c uu___
-let (get_abort_on : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "abort_on" as_int
-let (get_admit_smt_queries : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "admit_smt_queries" as_bool
-let (get_admit_except : unit -> Prims.string FStar_Pervasives_Native.option)
-  = fun uu___ -> lookup_opt "admit_except" (as_option as_string)
-let (get_compat_pre_core : unit -> Prims.int FStar_Pervasives_Native.option)
-  = fun uu___ -> lookup_opt "compat_pre_core" (as_option as_int)
-let (get_compat_pre_typed_indexed_effects : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "compat_pre_typed_indexed_effects" as_bool
-let (get_disallow_unification_guards : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "disallow_unification_guards" as_bool
-let (get_already_cached :
-  unit -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "already_cached" (as_option (as_list as_string))
-let (get_cache_checked_modules : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "cache_checked_modules" as_bool
-let (get_cache_dir : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "cache_dir" (as_option as_string)
-let (get_cache_off : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "cache_off" as_bool
-let (get_print_cache_version : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_cache_version" as_bool
-let (get_cmi : unit -> Prims.bool) = fun uu___ -> lookup_opt "cmi" as_bool
-let (get_codegen : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "codegen" (as_option as_string)
-let (get_codegen_lib : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "codegen-lib" (as_list as_string)
-let (get_debug : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "debug" as_comma_string_list
-let (get_debug_level : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "debug_level" as_comma_string_list
-let (get_defensive : unit -> Prims.string) =
-  fun uu___ -> lookup_opt "defensive" as_string
-let (get_dep : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "dep" (as_option as_string)
-let (get_detail_errors : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "detail_errors" as_bool
-let (get_detail_hint_replay : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "detail_hint_replay" as_bool
-let (get_dump_module : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "dump_module" (as_list as_string)
-let (get_eager_subtyping : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "eager_subtyping" as_bool
-let (get_error_contexts : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "error_contexts" as_bool
-let (get_expose_interfaces : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "expose_interfaces" as_bool
-let (get_extract :
-  unit -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "extract" (as_option (as_list as_string))
-let (get_extract_module : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "extract_module" (as_list as_string)
-let (get_extract_namespace : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "extract_namespace" (as_list as_string)
-let (get_force : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "force" as_bool
-let (get_hide_uvar_nums : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "hide_uvar_nums" as_bool
-let (get_hint_info : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "hint_info" as_bool
-let (get_hint_dir : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "hint_dir" (as_option as_string)
-let (get_hint_file : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "hint_file" (as_option as_string)
-let (get_in : unit -> Prims.bool) = fun uu___ -> lookup_opt "in" as_bool
-let (get_ide : unit -> Prims.bool) = fun uu___ -> lookup_opt "ide" as_bool
-let (get_ide_id_info_off : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "ide_id_info_off" as_bool
-let (get_lsp : unit -> Prims.bool) = fun uu___ -> lookup_opt "lsp" as_bool
-let (get_include : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "include" (as_list as_string)
-let (get_print : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print" as_bool
-let (get_print_in_place : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_in_place" as_bool
-let (get_initial_fuel : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "initial_fuel" as_int
-let (get_initial_ifuel : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "initial_ifuel" as_int
-let (get_keep_query_captions : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "keep_query_captions" as_bool
-let (get_lax : unit -> Prims.bool) = fun uu___ -> lookup_opt "lax" as_bool
-let (get_load : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "load" (as_list as_string)
-let (get_load_cmxs : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "load_cmxs" (as_list as_string)
-let (get_log_queries : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "log_queries" as_bool
-let (get_log_types : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "log_types" as_bool
-let (get_max_fuel : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "max_fuel" as_int
-let (get_max_ifuel : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "max_ifuel" as_int
-let (get_MLish : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "MLish" as_bool
-let (get_no_default_includes : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "no_default_includes" as_bool
-let (get_no_extract : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "no_extract" (as_list as_string)
-let (get_no_load_fstartaclib : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "no_load_fstartaclib" as_bool
-let (get_no_location_info : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "no_location_info" as_bool
-let (get_no_plugins : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "no_plugins" as_bool
-let (get_no_smt : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "no_smt" as_bool
-let (get_normalize_pure_terms_for_extraction : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "normalize_pure_terms_for_extraction" as_bool
-let (get_odir : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "odir" (as_option as_string)
-let (get_ugly : unit -> Prims.bool) = fun uu___ -> lookup_opt "ugly" as_bool
-let (get_prims : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "prims" (as_option as_string)
-let (get_print_bound_var_types : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_bound_var_types" as_bool
-let (get_print_effect_args : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_effect_args" as_bool
-let (get_print_expected_failures : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_expected_failures" as_bool
-let (get_print_full_names : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_full_names" as_bool
-let (get_print_implicits : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_implicits" as_bool
-let (get_print_universes : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_universes" as_bool
-let (get_print_z3_statistics : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "print_z3_statistics" as_bool
-let (get_prn : unit -> Prims.bool) = fun uu___ -> lookup_opt "prn" as_bool
-let (get_quake_lo : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "quake_lo" as_int
-let (get_quake_hi : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "quake_hi" as_int
-let (get_quake_keep : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "quake_keep" as_bool
-let (get_query_stats : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "query_stats" as_bool
-let (get_record_hints : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "record_hints" as_bool
-let (get_record_options : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "record_options" as_bool
-let (get_retry : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "retry" as_bool
-let (get_reuse_hint_for :
-  unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "reuse_hint_for" (as_option as_string)
-let (get_report_assumes :
-  unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "report_assumes" (as_option as_string)
-let (get_silent : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "silent" as_bool
-let (get_smt : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "smt" (as_option as_string)
-let (get_smtencoding_elim_box : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "smtencoding.elim_box" as_bool
-let (get_smtencoding_nl_arith_repr : unit -> Prims.string) =
-  fun uu___ -> lookup_opt "smtencoding.nl_arith_repr" as_string
-let (get_smtencoding_l_arith_repr : unit -> Prims.string) =
-  fun uu___ -> lookup_opt "smtencoding.l_arith_repr" as_string
-let (get_smtencoding_valid_intro : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "smtencoding.valid_intro" as_bool
-let (get_smtencoding_valid_elim : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "smtencoding.valid_elim" as_bool
-let (get_split_queries : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "split_queries" as_bool
-let (get_tactic_raw_binders : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "tactic_raw_binders" as_bool
-let (get_tactics_failhard : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "tactics_failhard" as_bool
-let (get_tactics_info : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "tactics_info" as_bool
-let (get_tactic_trace : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "tactic_trace" as_bool
-let (get_tactic_trace_d : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "tactic_trace_d" as_int
-let (get_tactics_nbe : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "__tactics_nbe" as_bool
-let (get_tcnorm : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "tcnorm" as_bool
-let (get_timing : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "timing" as_bool
-let (get_trace_error : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "trace_error" as_bool
-let (get_unthrottle_inductives : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "unthrottle_inductives" as_bool
-let (get_unsafe_tactic_exec : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "unsafe_tactic_exec" as_bool
-let (get_use_eq_at_higher_order : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "use_eq_at_higher_order" as_bool
-let (get_use_hints : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "use_hints" as_bool
-let (get_use_hint_hashes : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "use_hint_hashes" as_bool
-let (get_use_native_tactics :
-  unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "use_native_tactics" (as_option as_string)
-let (get_no_tactics : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "no_tactics" as_bool
-let (get_using_facts_from :
-  unit -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "using_facts_from" (as_option (as_list as_string))
-let (get_vcgen_optimize_bind_as_seq :
-  unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "vcgen.optimize_bind_as_seq" (as_option as_string)
-let (get_verify_module : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "verify_module" (as_list as_string)
-let (get_version : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "version" as_bool
-let (get_warn_default_effects : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "warn_default_effects" as_bool
-let (get_z3cliopt : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "z3cliopt" (as_list as_string)
-let (get_z3smtopt : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "z3smtopt" (as_list as_string)
-let (get_z3refresh : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "z3refresh" as_bool
-let (get_z3rlimit : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "z3rlimit" as_int
-let (get_z3rlimit_factor : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "z3rlimit_factor" as_int
-let (get_z3seed : unit -> Prims.int) =
-  fun uu___ -> lookup_opt "z3seed" as_int
-let (get_no_positivity : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "__no_positivity" as_bool
-let (get_warn_error : unit -> Prims.string Prims.list) =
-  fun uu___ -> lookup_opt "warn_error" (as_list as_string)
-let (get_use_nbe : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "use_nbe" as_bool
-let (get_use_nbe_for_extraction : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "use_nbe_for_extraction" as_bool
-let (get_trivial_pre_for_unannotated_effectful_fns : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "trivial_pre_for_unannotated_effectful_fns" as_bool
-let (get_profile :
-  unit -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "profile" (as_option (as_list as_string))
-let (get_profile_group_by_decl : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "profile_group_by_decl" as_bool
-let (get_profile_component :
-  unit -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun uu___ -> lookup_opt "profile_component" (as_option (as_list as_string))
-let (dlevel : Prims.string -> debug_level_t) =
-  fun uu___ ->
-    match uu___ with
-    | "Low" -> Low
-    | "Medium" -> Medium
-    | "High" -> High
-    | "Extreme" -> Extreme
-    | s -> Other s
-let (one_debug_level_geq : debug_level_t -> debug_level_t -> Prims.bool) =
-  fun l1 ->
-    fun l2 ->
-      match l1 with
-      | Other uu___ -> l1 = l2
-      | Low -> l1 = l2
-      | Medium -> (l2 = Low) || (l2 = Medium)
-      | High -> ((l2 = Low) || (l2 = Medium)) || (l2 = High)
-      | Extreme ->
-          (((l2 = Low) || (l2 = Medium)) || (l2 = High)) || (l2 = Extreme)
-let (debug_level_geq : debug_level_t -> Prims.bool) =
-  fun l2 ->
-    let uu___ = get_debug_level () in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (FStar_Compiler_Util.for_some
-         (fun l1 -> one_debug_level_geq (dlevel l1) l2))
-let (universe_include_path_base_dirs : Prims.string Prims.list) =
-  let sub_dirs = ["legacy"; "experimental"; ".cache"] in
-  FStar_Compiler_Effect.op_Bar_Greater ["/ulib"; "/lib/fstar"]
-    (FStar_Compiler_List.collect
-       (fun d ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater sub_dirs
-              (FStar_Compiler_List.map
-                 (fun s ->
-                    let uu___1 = FStar_String.op_Hat "/" s in
-                    FStar_String.op_Hat d uu___1)) in
-          d :: uu___))
-let (_version : Prims.string FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref ""
-let (_platform : Prims.string FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref ""
-let (_compiler : Prims.string FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref ""
-let (_date : Prims.string FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref " not set"
-let (_commit : Prims.string FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref ""
-let (display_version : unit -> unit) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang _version in
-      let uu___3 = FStar_Compiler_Effect.op_Bang _platform in
-      let uu___4 = FStar_Compiler_Effect.op_Bang _compiler in
-      let uu___5 = FStar_Compiler_Effect.op_Bang _date in
-      let uu___6 = FStar_Compiler_Effect.op_Bang _commit in
-      FStar_Compiler_Util.format5
-        "F* %s\nplatform=%s\ncompiler=%s\ndate=%s\ncommit=%s\n" uu___2 uu___3
-        uu___4 uu___5 uu___6 in
-    FStar_Compiler_Util.print_string uu___1
-let display_usage_aux :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu * Prims.string * 'uuuuu1 FStar_Getopt.opt_variant * Prims.string)
-      Prims.list -> unit
-  =
-  fun specs ->
-    FStar_Compiler_Util.print_string
-      "fstar.exe [options] file[s] [@respfile...]\n";
-    (let uu___2 =
-       let uu___3 = FStar_Compiler_Util.colorize_bold "@" in
-       FStar_Compiler_Util.format1
-         "  %srespfile  read options from respfile\n" uu___3 in
-     FStar_Compiler_Util.print_string uu___2);
-    FStar_Compiler_List.iter
-      (fun uu___2 ->
-         match uu___2 with
-         | (uu___3, flag, p, doc) ->
-             (match p with
-              | FStar_Getopt.ZeroArgs ig ->
-                  if doc = ""
-                  then
-                    let uu___4 =
-                      let uu___5 = FStar_Compiler_Util.colorize_bold flag in
-                      FStar_Compiler_Util.format1 "  --%s\n" uu___5 in
-                    FStar_Compiler_Util.print_string uu___4
-                  else
-                    (let uu___5 =
-                       let uu___6 = FStar_Compiler_Util.colorize_bold flag in
-                       FStar_Compiler_Util.format2 "  --%s  %s\n" uu___6 doc in
-                     FStar_Compiler_Util.print_string uu___5)
-              | FStar_Getopt.OneArg (uu___4, argname) ->
-                  if doc = ""
-                  then
-                    let uu___5 =
-                      let uu___6 = FStar_Compiler_Util.colorize_bold flag in
-                      let uu___7 = FStar_Compiler_Util.colorize_bold argname in
-                      FStar_Compiler_Util.format2 "  --%s %s\n" uu___6 uu___7 in
-                    FStar_Compiler_Util.print_string uu___5
-                  else
-                    (let uu___6 =
-                       let uu___7 = FStar_Compiler_Util.colorize_bold flag in
-                       let uu___8 = FStar_Compiler_Util.colorize_bold argname in
-                       FStar_Compiler_Util.format3 "  --%s %s  %s\n" uu___7
-                         uu___8 doc in
-                     FStar_Compiler_Util.print_string uu___6))) specs
-let (mk_spec :
-  (FStar_BaseTypes.char * Prims.string * option_val FStar_Getopt.opt_variant
-    * Prims.string) -> FStar_Getopt.opt)
-  =
-  fun o ->
-    let uu___ = o in
-    match uu___ with
-    | (ns, name, arg, desc) ->
-        let arg1 =
-          match arg with
-          | FStar_Getopt.ZeroArgs f ->
-              let g uu___1 = let uu___2 = f () in set_option name uu___2 in
-              FStar_Getopt.ZeroArgs g
-          | FStar_Getopt.OneArg (f, d) ->
-              let g x = let uu___1 = f x in set_option name uu___1 in
-              FStar_Getopt.OneArg (g, d) in
-        (ns, name, arg1, desc)
-let (accumulated_option : Prims.string -> option_val -> option_val) =
-  fun name ->
-    fun value ->
-      let prev_values =
-        let uu___ = lookup_opt name (as_option as_list') in
-        FStar_Compiler_Util.dflt [] uu___ in
-      List (value :: prev_values)
-let (reverse_accumulated_option : Prims.string -> option_val -> option_val) =
-  fun name ->
-    fun value ->
-      let prev_values =
-        let uu___ = lookup_opt name (as_option as_list') in
-        FStar_Compiler_Util.dflt [] uu___ in
-      List (FStar_Compiler_List.op_At prev_values [value])
-let accumulate_string :
-  'uuuuu . Prims.string -> ('uuuuu -> Prims.string) -> 'uuuuu -> unit =
-  fun name ->
-    fun post_processor ->
-      fun value ->
-        let uu___ =
-          let uu___1 = let uu___2 = post_processor value in String uu___2 in
-          accumulated_option name uu___1 in
-        set_option name uu___
-let (add_extract_module : Prims.string -> unit) =
-  fun s -> accumulate_string "extract_module" FStar_String.lowercase s
-let (add_extract_namespace : Prims.string -> unit) =
-  fun s -> accumulate_string "extract_namespace" FStar_String.lowercase s
-let (add_verify_module : Prims.string -> unit) =
-  fun s -> accumulate_string "verify_module" FStar_String.lowercase s
-exception InvalidArgument of Prims.string 
-let (uu___is_InvalidArgument : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InvalidArgument uu___ -> true | uu___ -> false
-let (__proj__InvalidArgument__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | InvalidArgument uu___ -> uu___
-let rec (parse_opt_val :
-  Prims.string -> opt_type -> Prims.string -> option_val) =
-  fun opt_name ->
-    fun typ ->
-      fun str_val ->
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 (match typ with
-                  | Const c -> c
-                  | IntStr uu___1 ->
-                      let uu___2 =
-                        FStar_Compiler_Util.safe_int_of_string str_val in
-                      (match uu___2 with
-                       | FStar_Pervasives_Native.Some v -> Int v
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Compiler_Effect.raise
-                             (InvalidArgument opt_name))
-                  | BoolStr ->
-                      let uu___1 =
-                        if str_val = "true"
-                        then true
-                        else
-                          if str_val = "false"
-                          then false
-                          else
-                            FStar_Compiler_Effect.raise
-                              (InvalidArgument opt_name) in
-                      Bool uu___1
-                  | PathStr uu___1 -> Path str_val
-                  | SimpleStr uu___1 -> String str_val
-                  | EnumStr strs ->
-                      if FStar_Compiler_List.mem str_val strs
-                      then String str_val
-                      else
-                        FStar_Compiler_Effect.raise
-                          (InvalidArgument opt_name)
-                  | OpenEnumStr uu___1 -> String str_val
-                  | PostProcessed (pp, elem_spec) ->
-                      let uu___1 = parse_opt_val opt_name elem_spec str_val in
-                      pp uu___1
-                  | Accumulated elem_spec ->
-                      let v = parse_opt_val opt_name elem_spec str_val in
-                      accumulated_option opt_name v
-                  | ReverseAccumulated elem_spec ->
-                      let v = parse_opt_val opt_name elem_spec str_val in
-                      reverse_accumulated_option opt_name v
-                  | WithSideEffect (side_effect, elem_spec) ->
-                      (side_effect ();
-                       parse_opt_val opt_name elem_spec str_val))) ()
-        with
-        | InvalidArgument opt_name1 ->
-            let uu___1 =
-              FStar_Compiler_Util.format1 "Invalid argument to --%s"
-                opt_name1 in
-            failwith uu___1
-let rec (desc_of_opt_type :
-  opt_type -> Prims.string FStar_Pervasives_Native.option) =
-  fun typ ->
-    let desc_of_enum cases =
-      let uu___ =
-        let uu___1 = FStar_String.op_Hat (FStar_String.concat "|" cases) "]" in
-        FStar_String.op_Hat "[" uu___1 in
-      FStar_Pervasives_Native.Some uu___ in
-    match typ with
-    | Const c -> FStar_Pervasives_Native.None
-    | IntStr desc -> FStar_Pervasives_Native.Some desc
-    | BoolStr -> desc_of_enum ["true"; "false"]
-    | PathStr desc -> FStar_Pervasives_Native.Some desc
-    | SimpleStr desc -> FStar_Pervasives_Native.Some desc
-    | EnumStr strs -> desc_of_enum strs
-    | OpenEnumStr (strs, desc) ->
-        desc_of_enum (FStar_Compiler_List.op_At strs [desc])
-    | PostProcessed (uu___, elem_spec) -> desc_of_opt_type elem_spec
-    | Accumulated elem_spec -> desc_of_opt_type elem_spec
-    | ReverseAccumulated elem_spec -> desc_of_opt_type elem_spec
-    | WithSideEffect (uu___, elem_spec) -> desc_of_opt_type elem_spec
-let (arg_spec_of_opt_type :
-  Prims.string -> opt_type -> option_val FStar_Getopt.opt_variant) =
-  fun opt_name ->
-    fun typ ->
-      let parser = parse_opt_val opt_name typ in
-      let uu___ = desc_of_opt_type typ in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          FStar_Getopt.ZeroArgs ((fun uu___1 -> parser ""))
-      | FStar_Pervasives_Native.Some desc ->
-          FStar_Getopt.OneArg (parser, desc)
-let (pp_validate_dir : option_val -> option_val) =
-  fun p -> let pp = as_string p in FStar_Compiler_Util.mkdir false pp; p
-let (pp_lowercase : option_val -> option_val) =
-  fun s ->
-    let uu___ = let uu___1 = as_string s in FStar_String.lowercase uu___1 in
-    String uu___
-let (abort_counter : Prims.int FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref Prims.int_zero
-let (interp_quake_arg : Prims.string -> (Prims.int * Prims.int * Prims.bool))
-  =
-  fun s ->
-    let ios = FStar_Compiler_Util.int_of_string in
-    match FStar_Compiler_Util.split s "/" with
-    | f::[] ->
-        let uu___ = ios f in let uu___1 = ios f in (uu___, uu___1, false)
-    | f1::f2::[] ->
-        if f2 = "k"
-        then
-          let uu___ = ios f1 in let uu___1 = ios f1 in (uu___, uu___1, true)
-        else
-          (let uu___1 = ios f1 in
-           let uu___2 = ios f2 in (uu___1, uu___2, false))
-    | f1::f2::k::[] ->
-        if k = "k"
-        then
-          let uu___ = ios f1 in let uu___1 = ios f2 in (uu___, uu___1, true)
-        else failwith "unexpected value for --quake"
-    | uu___ -> failwith "unexpected value for --quake"
-let (uu___449 : (((Prims.string -> unit) -> unit) * (Prims.string -> unit)))
-  =
-  let cb = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let set1 f =
-    FStar_Compiler_Effect.op_Colon_Equals cb (FStar_Pervasives_Native.Some f) in
-  let call msg =
-    let uu___ = FStar_Compiler_Effect.op_Bang cb in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> ()
-    | FStar_Pervasives_Native.Some f -> f msg in
-  (set1, call)
-let (set_option_warning_callback_aux : (Prims.string -> unit) -> unit) =
-  match uu___449 with
-  | (set_option_warning_callback_aux1, option_warning_callback) ->
-      set_option_warning_callback_aux1
-let (option_warning_callback : Prims.string -> unit) =
-  match uu___449 with
-  | (set_option_warning_callback_aux1, option_warning_callback1) ->
-      option_warning_callback1
-let (set_option_warning_callback : (Prims.string -> unit) -> unit) =
-  fun f -> set_option_warning_callback_aux f
-let rec (specs_with_types :
-  Prims.bool ->
-    (FStar_BaseTypes.char * Prims.string * opt_type * Prims.string)
-      Prims.list)
-  =
-  fun warn_unsafe ->
-    [(FStar_Getopt.noshort, "abort_on",
-       (PostProcessed
-          (((fun uu___ ->
-               match uu___ with
-               | Int x ->
-                   (FStar_Compiler_Effect.op_Colon_Equals abort_counter x;
-                    Int x)
-               | x -> failwith "?")), (IntStr "non-negative integer"))),
-       "Abort on the n-th error or warning raised. Useful in combination with --trace_error. Count starts at 1, use 0 to disable. (default 0)");
-    (FStar_Getopt.noshort, "admit_smt_queries",
-      (WithSideEffect
-         (((fun uu___ ->
-              if warn_unsafe
-              then option_warning_callback "admit_smt_queries"
-              else ())), BoolStr)),
-      "Admit SMT queries, unsafe! (default 'false')");
-    (FStar_Getopt.noshort, "admit_except",
-      (WithSideEffect
-         (((fun uu___ ->
-              if warn_unsafe
-              then option_warning_callback "admit_except"
-              else ())), (SimpleStr "[symbol|(symbol, id)]"))),
-      "Admit all queries, except those with label ( symbol,  id)) (e.g. --admit_except '(FStar.Fin.pigeonhole, 1)' or --admit_except FStar.Fin.pigeonhole)");
-    (FStar_Getopt.noshort, "compat_pre_core", (IntStr "0, 1, 2"),
-      "Retain behavior of the tactic engine prior to the introduction of FStar.TypeChecker.Core (0 is most permissive, 2 is least permissive)");
-    (FStar_Getopt.noshort, "compat_pre_typed_indexed_effects",
-      (Const (Bool true)), "Retain untyped indexed effects implicits");
-    (FStar_Getopt.noshort, "disallow_unification_guards", BoolStr,
-      "Fail if the SMT guard are produced when the tactic engine re-checks solutions produced by the unifier (default 'false')");
-    (FStar_Getopt.noshort, "already_cached",
-      (Accumulated
-         (SimpleStr
-            "One or more space-separated occurrences of '[+|-]( * | namespace | module)'")),
-      "\n\t\tExpects all modules whose names or namespaces match the provided options \n\t\t\tto already have valid .checked files in the include path");
-    (FStar_Getopt.noshort, "cache_checked_modules", (Const (Bool true)),
-      "Write a '.checked' file for each module after verification and read from it if present, instead of re-verifying");
-    (FStar_Getopt.noshort, "cache_dir",
-      (PostProcessed (pp_validate_dir, (PathStr "dir"))),
-      "Read and write .checked and .checked.lax in directory  dir");
-    (FStar_Getopt.noshort, "cache_off", (Const (Bool true)),
-      "Do not read or write any .checked files");
-    (FStar_Getopt.noshort, "print_cache_version", (Const (Bool true)),
-      "Print the version for .checked files and exit.");
-    (FStar_Getopt.noshort, "cmi", (Const (Bool true)),
-      "Inline across module interfaces during extraction (aka. cross-module inlining)");
-    (FStar_Getopt.noshort, "codegen",
-      (EnumStr ["OCaml"; "FSharp"; "krml"; "Plugin"]),
-      "Generate code for further compilation to executable code, or build a compiler plugin");
-    (FStar_Getopt.noshort, "codegen-lib",
-      (Accumulated (SimpleStr "namespace")),
-      "External runtime library (i.e. M.N.x extracts to M.N.X instead of M_N.x)");
-    (FStar_Getopt.noshort, "debug", (Accumulated (SimpleStr "module_name")),
-      "Print lots of debugging information while checking module");
-    (FStar_Getopt.noshort, "debug_level",
-      (Accumulated
-         (OpenEnumStr (["Low"; "Medium"; "High"; "Extreme"], "..."))),
-      "Control the verbosity of debugging info");
-    (FStar_Getopt.noshort, "defensive",
-      (EnumStr ["no"; "warn"; "error"; "abort"]),
-      "Enable several internal sanity checks, useful to track bugs and report issues.\n\t\tif 'no', no checks are performed\n\t\tif 'warn', checks are performed and raise a warning when they fail\n\t\tif 'error, like 'warn', but the compiler raises a hard error instead \n\t\tif 'abort, like 'warn', but the compiler immediately aborts on an error\n\t\t(default 'no')");
-    (FStar_Getopt.noshort, "dep", (EnumStr ["make"; "graph"; "full"; "raw"]),
-      "Output the transitive closure of the full dependency graph in three formats:\n\t 'graph': a format suitable the 'dot' tool from 'GraphViz'\n\t 'full': a format suitable for 'make', including dependences for producing .ml and .krml files\n\t 'make': (deprecated) a format suitable for 'make', including only dependences among source files");
-    (FStar_Getopt.noshort, "detail_errors", (Const (Bool true)),
-      "Emit a detailed error report by asking the SMT solver many queries; will take longer");
-    (FStar_Getopt.noshort, "detail_hint_replay", (Const (Bool true)),
-      "Emit a detailed report for proof whose unsat core fails to replay");
-    (FStar_Getopt.noshort, "dump_module",
-      (Accumulated (SimpleStr "module_name")), "");
-    (FStar_Getopt.noshort, "eager_subtyping", (Const (Bool true)),
-      "Try to solve subtyping constraints at each binder (loses precision but may be slightly more efficient)");
-    (FStar_Getopt.noshort, "error_contexts", BoolStr,
-      "Print context information for each error or warning raised (default false)");
-    (FStar_Getopt.noshort, "extract",
-      (Accumulated
-         (SimpleStr
-            "One or more semicolon separated occurrences of '[TargetName:]ModuleSelector'")),
-      "\n\t\tExtract only those modules whose names or namespaces match the provided options.\n\t\t\t'TargetName' ranges over {OCaml, krml, FSharp, Plugin}.\n\t\t\tA 'ModuleSelector' is a space or comma-separated list of '[+|-]( * | namespace | module)'.\n\t\t\tFor example --extract 'OCaml:A -A.B' --extract 'krml:A -A.C' --extract '*' means\n\t\t\t\tfor OCaml, extract everything in the A namespace only except A.B;\n\t\t\t\tfor krml, extract everything in the A namespace only except A.C;\n\t\t\t\tfor everything else, extract everything.\n\t\t\tNote, the '+' is optional: --extract '+A' and --extract 'A' mean the same thing.\n\t\t\tNote also that '--extract A' applies both to a module named 'A' and to any module in the 'A' namespace\n\t\tMultiple uses of this option accumulate, e.g., --extract A --extract B is interpreted as --extract 'A B'.");
-    (FStar_Getopt.noshort, "extract_module",
-      (Accumulated (PostProcessed (pp_lowercase, (SimpleStr "module_name")))),
-      "Deprecated: use --extract instead; Only extract the specified modules (instead of the possibly-partial dependency graph)");
-    (FStar_Getopt.noshort, "extract_namespace",
-      (Accumulated
-         (PostProcessed (pp_lowercase, (SimpleStr "namespace name")))),
-      "Deprecated: use --extract instead; Only extract modules in the specified namespace");
-    (FStar_Getopt.noshort, "expose_interfaces", (Const (Bool true)),
-      "Explicitly break the abstraction imposed by the interface of any implementation file that appears on the command line (use with care!)");
-    (FStar_Getopt.noshort, "hide_uvar_nums", (Const (Bool true)),
-      "Don't print unification variable numbers");
-    (FStar_Getopt.noshort, "hint_dir",
-      (PostProcessed (pp_validate_dir, (PathStr "dir"))),
-      "Read/write hints to  dir/module_name.hints (instead of placing hint-file alongside source file)");
-    (FStar_Getopt.noshort, "hint_file", (PathStr "path"),
-      "Read/write hints to  path (instead of module-specific hints files; overrides hint_dir)");
-    (FStar_Getopt.noshort, "hint_info", (Const (Bool true)),
-      "Print information regarding hints (deprecated; use --query_stats instead)");
-    (FStar_Getopt.noshort, "in", (Const (Bool true)),
-      "Legacy interactive mode; reads input from stdin");
-    (FStar_Getopt.noshort, "ide", (Const (Bool true)),
-      "JSON-based interactive mode for IDEs");
-    (FStar_Getopt.noshort, "ide_id_info_off", (Const (Bool true)),
-      "Disable identifier tables in IDE mode (temporary workaround useful in Steel)");
-    (FStar_Getopt.noshort, "lsp", (Const (Bool true)),
-      "Language Server Protocol-based interactive mode for IDEs");
-    (FStar_Getopt.noshort, "include", (ReverseAccumulated (PathStr "path")),
-      "A directory in which to search for files included on the command line");
-    (FStar_Getopt.noshort, "print", (Const (Bool true)),
-      "Parses and prettyprints the files included on the command line");
-    (FStar_Getopt.noshort, "print_in_place", (Const (Bool true)),
-      "Parses and prettyprints in place the files included on the command line");
-    (102, "force", (Const (Bool true)),
-      "Force checking the files given as arguments even if they have valid checked files");
-    (FStar_Getopt.noshort, "fuel",
-      (PostProcessed
-         (((fun uu___ ->
-              match uu___ with
-              | String s ->
-                  let p f =
-                    let uu___1 = FStar_Compiler_Util.int_of_string f in
-                    Int uu___1 in
-                  let uu___1 =
-                    match FStar_Compiler_Util.split s "," with
-                    | f::[] -> (f, f)
-                    | f1::f2::[] -> (f1, f2)
-                    | uu___2 -> failwith "unexpected value for --fuel" in
-                  (match uu___1 with
-                   | (min, max) ->
-                       ((let uu___3 = p min in
-                         set_option "initial_fuel" uu___3);
-                        (let uu___4 = p max in set_option "max_fuel" uu___4);
-                        String s))
-              | uu___1 -> failwith "impos")),
-           (SimpleStr "non-negative integer or pair of non-negative integers"))),
-      "Set initial_fuel and max_fuel at once");
-    (FStar_Getopt.noshort, "ifuel",
-      (PostProcessed
-         (((fun uu___ ->
-              match uu___ with
-              | String s ->
-                  let p f =
-                    let uu___1 = FStar_Compiler_Util.int_of_string f in
-                    Int uu___1 in
-                  let uu___1 =
-                    match FStar_Compiler_Util.split s "," with
-                    | f::[] -> (f, f)
-                    | f1::f2::[] -> (f1, f2)
-                    | uu___2 -> failwith "unexpected value for --ifuel" in
-                  (match uu___1 with
-                   | (min, max) ->
-                       ((let uu___3 = p min in
-                         set_option "initial_ifuel" uu___3);
-                        (let uu___4 = p max in set_option "max_ifuel" uu___4);
-                        String s))
-              | uu___1 -> failwith "impos")),
-           (SimpleStr "non-negative integer or pair of non-negative integers"))),
-      "Set initial_ifuel and max_ifuel at once");
-    (FStar_Getopt.noshort, "initial_fuel", (IntStr "non-negative integer"),
-      "Number of unrolling of recursive functions to try initially (default 2)");
-    (FStar_Getopt.noshort, "initial_ifuel", (IntStr "non-negative integer"),
-      "Number of unrolling of inductive datatypes to try at first (default 1)");
-    (FStar_Getopt.noshort, "keep_query_captions", BoolStr,
-      "Retain comments in the logged SMT queries (requires --log_queries; default true)");
-    (FStar_Getopt.noshort, "lax",
-      (WithSideEffect
-         (((fun uu___ ->
-              if warn_unsafe then option_warning_callback "lax" else ())),
-           (Const (Bool true)))),
-      "Run the lax-type checker only (admit all verification conditions)");
-    (FStar_Getopt.noshort, "load", (ReverseAccumulated (PathStr "module")),
-      "Load OCaml module, compiling it if necessary");
-    (FStar_Getopt.noshort, "load_cmxs",
-      (ReverseAccumulated (PathStr "module")),
-      "Load compiled module, fails hard if the module is not already compiled");
-    (FStar_Getopt.noshort, "log_types", (Const (Bool true)),
-      "Print types computed for data/val/let-bindings");
-    (FStar_Getopt.noshort, "log_queries", (Const (Bool true)),
-      "Log the Z3 queries in several queries-*.smt2 files, as we go");
-    (FStar_Getopt.noshort, "max_fuel", (IntStr "non-negative integer"),
-      "Number of unrolling of recursive functions to try at most (default 8)");
-    (FStar_Getopt.noshort, "max_ifuel", (IntStr "non-negative integer"),
-      "Number of unrolling of inductive datatypes to try at most (default 2)");
-    (FStar_Getopt.noshort, "MLish", (Const (Bool true)),
-      "Trigger various specializations for compiling the F* compiler itself (not meant for user code)");
-    (FStar_Getopt.noshort, "no_default_includes", (Const (Bool true)),
-      "Ignore the default module search paths");
-    (FStar_Getopt.noshort, "no_extract",
-      (Accumulated (PathStr "module name")),
-      "Deprecated: use --extract instead; Do not extract code from this module");
-    (FStar_Getopt.noshort, "no_load_fstartaclib", (Const (Bool true)),
-      "Do not attempt to load fstartaclib by default");
-    (FStar_Getopt.noshort, "no_location_info", (Const (Bool true)),
-      "Suppress location information in the generated OCaml output (only relevant with --codegen OCaml)");
-    (FStar_Getopt.noshort, "no_smt", (Const (Bool true)),
-      "Do not send any queries to the SMT solver, and fail on them instead");
-    (FStar_Getopt.noshort, "normalize_pure_terms_for_extraction",
-      (Const (Bool true)),
-      "Extract top-level pure terms after normalizing them. This can lead to very large code, but can result in more partial evaluation and compile-time specialization.");
-    (FStar_Getopt.noshort, "odir",
-      (PostProcessed (pp_validate_dir, (PathStr "dir"))),
-      "Place output in directory  dir");
-    (FStar_Getopt.noshort, "prims", (PathStr "file"), "");
-    (FStar_Getopt.noshort, "print_bound_var_types", (Const (Bool true)),
-      "Print the types of bound variables");
-    (FStar_Getopt.noshort, "print_effect_args", (Const (Bool true)),
-      "Print inferred predicate transformers for all computation types");
-    (FStar_Getopt.noshort, "print_expected_failures", (Const (Bool true)),
-      "Print the errors generated by declarations marked with expect_failure, useful for debugging error locations");
-    (FStar_Getopt.noshort, "print_full_names", (Const (Bool true)),
-      "Print full names of variables");
-    (FStar_Getopt.noshort, "print_implicits", (Const (Bool true)),
-      "Print implicit arguments");
-    (FStar_Getopt.noshort, "print_universes", (Const (Bool true)),
-      "Print universes");
-    (FStar_Getopt.noshort, "print_z3_statistics", (Const (Bool true)),
-      "Print Z3 statistics for each SMT query (details such as relevant modules, facts, etc. for each proof)");
-    (FStar_Getopt.noshort, "prn", (Const (Bool true)),
-      "Print full names (deprecated; use --print_full_names instead)");
-    (FStar_Getopt.noshort, "quake",
-      (PostProcessed
-         (((fun uu___ ->
-              match uu___ with
-              | String s ->
-                  let uu___1 = interp_quake_arg s in
-                  (match uu___1 with
-                   | (min, max, k) ->
-                       (set_option "quake_lo" (Int min);
-                        set_option "quake_hi" (Int max);
-                        set_option "quake_keep" (Bool k);
-                        set_option "retry" (Bool false);
-                        String s))
-              | uu___1 -> failwith "impos")),
-           (SimpleStr "positive integer or pair of positive integers"))),
-      "Repeats SMT queries to check for robustness\n\t\t--quake N/M repeats each query checks that it succeeds at least N out of M times, aborting early if possible\n\t\t--quake N/M/k works as above, except it will unconditionally run M times\n\t\t--quake N is an alias for --quake N/N\n\t\t--quake N/k is an alias for --quake N/N/k\n\tUsing --quake disables --retry.");
-    (FStar_Getopt.noshort, "query_stats", (Const (Bool true)),
-      "Print SMT query statistics");
-    (FStar_Getopt.noshort, "record_hints", (Const (Bool true)),
-      "Record a database of hints for efficient proof replay");
-    (FStar_Getopt.noshort, "record_options", (Const (Bool true)),
-      "Record the state of options used to check each sigelt, useful for the `check_with` attribute and metaprogramming");
-    (FStar_Getopt.noshort, "retry",
-      (PostProcessed
-         (((fun uu___ ->
-              match uu___ with
-              | Int i ->
-                  (set_option "quake_lo" (Int Prims.int_one);
-                   set_option "quake_hi" (Int i);
-                   set_option "quake_keep" (Bool false);
-                   set_option "retry" (Bool true);
-                   Bool true)
-              | uu___1 -> failwith "impos")), (IntStr "positive integer"))),
-      "Retry each SMT query N times and succeed on the first try. Using --retry disables --quake.");
-    (FStar_Getopt.noshort, "reuse_hint_for", (SimpleStr "toplevel_name"),
-      "Optimistically, attempt using the recorded hint for  toplevel_name (a top-level name in the current module) when trying to verify some other term 'g'");
-    (FStar_Getopt.noshort, "report_assumes", (EnumStr ["warn"; "error"]),
-      "Report every use of an escape hatch, include assume, admit, etc.");
-    (FStar_Getopt.noshort, "silent", (Const (Bool true)),
-      "Disable all non-critical output");
-    (FStar_Getopt.noshort, "smt", (PathStr "path"),
-      "Path to the Z3 SMT solver (we could eventually support other solvers)");
-    (FStar_Getopt.noshort, "smtencoding.elim_box", BoolStr,
-      "Toggle a peephole optimization that eliminates redundant uses of boxing/unboxing in the SMT encoding (default 'false')");
-    (FStar_Getopt.noshort, "smtencoding.nl_arith_repr",
-      (EnumStr ["native"; "wrapped"; "boxwrap"]),
-      "Control the representation of non-linear arithmetic functions in the SMT encoding:\n\t\ti.e., if 'boxwrap' use 'Prims.op_Multiply, Prims.op_Division, Prims.op_Modulus'; \n\t\tif 'native' use '*, div, mod';\n\t\tif 'wrapped' use '_mul, _div, _mod : Int*Int -> Int'; \n\t\t(default 'boxwrap')");
-    (FStar_Getopt.noshort, "smtencoding.l_arith_repr",
-      (EnumStr ["native"; "boxwrap"]),
-      "Toggle the representation of linear arithmetic functions in the SMT encoding:\n\t\ti.e., if 'boxwrap', use 'Prims.op_Addition, Prims.op_Subtraction, Prims.op_Minus'; \n\t\tif 'native', use '+, -, -'; \n\t\t(default 'boxwrap')");
-    (FStar_Getopt.noshort, "smtencoding.valid_intro", BoolStr,
-      "Include an axiom in the SMT encoding to introduce proof-irrelevance from a constructive proof");
-    (FStar_Getopt.noshort, "smtencoding.valid_elim", BoolStr,
-      "Include an axiom in the SMT encoding to eliminate proof-irrelevance into the existence of a proof witness");
-    (FStar_Getopt.noshort, "split_queries", (Const (Bool true)),
-      "Split SMT verification conditions into several separate queries, one per goal");
-    (FStar_Getopt.noshort, "tactic_raw_binders", (Const (Bool true)),
-      "Do not use the lexical scope of tactics to improve binder names");
-    (FStar_Getopt.noshort, "tactics_failhard", (Const (Bool true)),
-      "Do not recover from metaprogramming errors, and abort if one occurs");
-    (FStar_Getopt.noshort, "tactics_info", (Const (Bool true)),
-      "Print some rough information on tactics, such as the time they take to run");
-    (FStar_Getopt.noshort, "tactic_trace", (Const (Bool true)),
-      "Print a depth-indexed trace of tactic execution (Warning: very verbose)");
-    (FStar_Getopt.noshort, "tactic_trace_d", (IntStr "positive_integer"),
-      "Trace tactics up to a certain binding depth");
-    (FStar_Getopt.noshort, "__tactics_nbe", (Const (Bool true)),
-      "Use NBE to evaluate metaprograms (experimental)");
-    (FStar_Getopt.noshort, "tcnorm", BoolStr,
-      "Attempt to normalize definitions marked as tcnorm (default 'true')");
-    (FStar_Getopt.noshort, "timing", (Const (Bool true)),
-      "Print the time it takes to verify each top-level definition.\n\t\tThis is just an alias for an invocation of the profiler, so it may not work well if combined with --profile.\n\t\tIn particular, it implies --profile_group_by_decls.");
-    (FStar_Getopt.noshort, "trace_error", (Const (Bool true)),
-      "Don't print an error message; show an exception trace instead");
-    (FStar_Getopt.noshort, "ugly", (Const (Bool true)),
-      "Emit output formatted for debugging");
-    (FStar_Getopt.noshort, "unthrottle_inductives", (Const (Bool true)),
-      "Let the SMT solver unfold inductive types to arbitrary depths (may affect verifier performance)");
-    (FStar_Getopt.noshort, "unsafe_tactic_exec", (Const (Bool true)),
-      "Allow tactics to run external processes. WARNING: checking an untrusted F* file while using this option can have disastrous effects.");
-    (FStar_Getopt.noshort, "use_eq_at_higher_order", (Const (Bool true)),
-      "Use equality constraints when comparing higher-order types (Temporary)");
-    (FStar_Getopt.noshort, "use_hints", (Const (Bool true)),
-      "Use a previously recorded hints database for proof replay");
-    (FStar_Getopt.noshort, "use_hint_hashes", (Const (Bool true)),
-      "Admit queries if their hash matches the hash recorded in the hints database");
-    (FStar_Getopt.noshort, "use_native_tactics", (PathStr "path"),
-      "Use compiled tactics from  path");
-    (FStar_Getopt.noshort, "no_plugins", (Const (Bool true)),
-      "Do not run plugins natively and interpret them as usual instead");
-    (FStar_Getopt.noshort, "no_tactics", (Const (Bool true)),
-      "Do not run the tactic engine before discharging a VC");
-    (FStar_Getopt.noshort, "using_facts_from",
-      (ReverseAccumulated
-         (SimpleStr
-            "One or more space-separated occurrences of '[+|-]( * | namespace | fact id)'")),
-      "\n\t\tPrunes the context to include only the facts from the given namespace or fact id. \n\t\t\tFacts can be include or excluded using the [+|-] qualifier. \n\t\t\tFor example --using_facts_from '* -FStar.Reflection +FStar.Compiler.List -FStar.Compiler.List.Tot' will \n\t\t\t\tremove all facts from FStar.Compiler.List.Tot.*, \n\t\t\t\tretain all remaining facts from FStar.Compiler.List.*, \n\t\t\t\tremove all facts from FStar.Reflection.*, \n\t\t\t\tand retain all the rest.\n\t\tNote, the '+' is optional: --using_facts_from 'FStar.Compiler.List' is equivalent to --using_facts_from '+FStar.Compiler.List'. \n\t\tMultiple uses of this option accumulate, e.g., --using_facts_from A --using_facts_from B is interpreted as --using_facts_from A^B.");
-    (FStar_Getopt.noshort, "vcgen.optimize_bind_as_seq",
-      (EnumStr ["off"; "without_type"; "with_type"]),
-      "\n\t\tOptimize the generation of verification conditions, \n\t\t\tspecifically the construction of monadic `bind`,\n\t\t\tgenerating `seq` instead of `bind` when the first computation as a trivial post-condition.\n\t\t\tBy default, this optimization does not apply.\n\t\t\tWhen the `without_type` option is chosen, this imposes a cost on the SMT solver\n\t\t\tto reconstruct type information.\n\t\t\tWhen `with_type` is chosen, type information is provided to the SMT solver,\n\t\t\tbut at the cost of VC bloat, which may often be redundant.");
-    (FStar_Getopt.noshort, "__temp_fast_implicits", (Const (Bool true)),
-      "Don't use this option yet");
-    (118, "version",
-      (WithSideEffect
-         (((fun uu___ ->
-              display_version (); FStar_Compiler_Effect.exit Prims.int_zero)),
-           (Const (Bool true)))), "Display version number");
-    (FStar_Getopt.noshort, "warn_default_effects", (Const (Bool true)),
-      "Warn when (a -> b) is desugared to (a -> Tot b)");
-    (FStar_Getopt.noshort, "z3cliopt",
-      (ReverseAccumulated (SimpleStr "option")), "Z3 command line options");
-    (FStar_Getopt.noshort, "z3smtopt",
-      (ReverseAccumulated (SimpleStr "option")), "Z3 options in smt2 format");
-    (FStar_Getopt.noshort, "z3refresh", (Const (Bool true)),
-      "Restart Z3 after each query; useful for ensuring proof robustness");
-    (FStar_Getopt.noshort, "z3rlimit", (IntStr "positive_integer"),
-      "Set the Z3 per-query resource limit (default 5 units, taking roughtly 5s)");
-    (FStar_Getopt.noshort, "z3rlimit_factor", (IntStr "positive_integer"),
-      "Set the Z3 per-query resource limit multiplier. This is useful when, say, regenerating hints and you want to be more lax. (default 1)");
-    (FStar_Getopt.noshort, "z3seed", (IntStr "positive_integer"),
-      "Set the Z3 random seed (default 0)");
-    (FStar_Getopt.noshort, "__no_positivity",
-      (WithSideEffect
-         (((fun uu___ ->
-              if warn_unsafe
-              then option_warning_callback "__no_positivity"
-              else ())), (Const (Bool true)))),
-      "Don't check positivity of inductive types");
-    (FStar_Getopt.noshort, "warn_error", (Accumulated (SimpleStr "")),
-      "The [-warn_error] option follows the OCaml syntax, namely:\n\t\t- [r] is a range of warnings (either a number [n], or a range [n..n])\n\t\t- [-r] silences range [r]\n\t\t- [+r] enables range [r]\n\t\t- [@r] makes range [r] fatal.");
-    (FStar_Getopt.noshort, "use_nbe", BoolStr,
-      "Use normalization by evaluation as the default normalization strategy (default 'false')");
-    (FStar_Getopt.noshort, "use_nbe_for_extraction", BoolStr,
-      "Use normalization by evaluation for normalizing terms before extraction (default 'false')");
-    (FStar_Getopt.noshort, "trivial_pre_for_unannotated_effectful_fns",
-      BoolStr,
-      "Enforce trivial preconditions for unannotated effectful functions (default 'true')");
-    (FStar_Getopt.noshort, "__debug_embedding",
-      (WithSideEffect
-         (((fun uu___ ->
-              FStar_Compiler_Effect.op_Colon_Equals debug_embedding true)),
-           (Const (Bool true)))),
-      "Debug messages for embeddings/unembeddings of natively compiled terms");
-    (FStar_Getopt.noshort, "eager_embedding",
-      (WithSideEffect
-         (((fun uu___ ->
-              FStar_Compiler_Effect.op_Colon_Equals eager_embedding true)),
-           (Const (Bool true)))),
-      "Eagerly embed and unembed terms to primitive operations and plugins: not recommended except for benchmarking");
-    (FStar_Getopt.noshort, "profile_group_by_decl", (Const (Bool true)),
-      "Emit profiles grouped by declaration rather than by module");
-    (FStar_Getopt.noshort, "profile_component",
-      (Accumulated
-         (SimpleStr
-            "One or more space-separated occurrences of '[+|-]( * | namespace | module | identifier)'")),
-      "\n\tSpecific source locations in the compiler are instrumented with profiling counters.\n\tPass `--profile_component FStar.TypeChecker` to enable all counters in the FStar.TypeChecker namespace.\n\tThis option is a module or namespace selector, like many other options (e.g., `--extract`)");
-    (FStar_Getopt.noshort, "profile",
-      (Accumulated
-         (SimpleStr
-            "One or more space-separated occurrences of '[+|-]( * | namespace | module)'")),
-      "\n\tProfiling can be enabled when the compiler is processing a given set of source modules.\n\tPass `--profile FStar.Pervasives` to enable profiling when the compiler is processing any module in FStar.Pervasives.\n\tThis option is a module or namespace selector, like many other options (e.g., `--extract`)");
-    (104, "help",
-      (WithSideEffect
-         (((fun uu___ ->
-              (let uu___2 = specs warn_unsafe in display_usage_aux uu___2);
-              FStar_Compiler_Effect.exit Prims.int_zero)),
-           (Const (Bool true)))), "Display this information")]
-and (specs : Prims.bool -> FStar_Getopt.opt Prims.list) =
-  fun warn_unsafe ->
-    let uu___ = specs_with_types warn_unsafe in
-    FStar_Compiler_List.map
-      (fun uu___1 ->
-         match uu___1 with
-         | (short, long, typ, doc) ->
-             let uu___2 =
-               let uu___3 = arg_spec_of_opt_type long typ in
-               (short, long, uu___3, doc) in
-             mk_spec uu___2) uu___
-let (settable : Prims.string -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | "abort_on" -> true
-    | "admit_except" -> true
-    | "admit_smt_queries" -> true
-    | "compat_pre_core" -> true
-    | "compat_pre_typed_indexed_effects" -> true
-    | "disallow_unification_guards" -> true
-    | "debug" -> true
-    | "debug_level" -> true
-    | "defensive" -> true
-    | "detail_errors" -> true
-    | "detail_hint_replay" -> true
-    | "eager_subtyping" -> true
-    | "error_contexts" -> true
-    | "hide_uvar_nums" -> true
-    | "hint_dir" -> true
-    | "hint_file" -> true
-    | "hint_info" -> true
-    | "fuel" -> true
-    | "ifuel" -> true
-    | "initial_fuel" -> true
-    | "initial_ifuel" -> true
-    | "ide_id_info_off" -> true
-    | "keep_query_captions" -> true
-    | "lax" -> true
-    | "load" -> true
-    | "load_cmxs" -> true
-    | "log_queries" -> true
-    | "log_types" -> true
-    | "max_fuel" -> true
-    | "max_ifuel" -> true
-    | "no_plugins" -> true
-    | "__no_positivity" -> true
-    | "normalize_pure_terms_for_extraction" -> true
-    | "no_smt" -> true
-    | "no_tactics" -> true
-    | "print_bound_var_types" -> true
-    | "print_effect_args" -> true
-    | "print_expected_failures" -> true
-    | "print_full_names" -> true
-    | "print_implicits" -> true
-    | "print_universes" -> true
-    | "print_z3_statistics" -> true
-    | "prn" -> true
-    | "quake_lo" -> true
-    | "quake_hi" -> true
-    | "quake_keep" -> true
-    | "quake" -> true
-    | "query_stats" -> true
-    | "record_options" -> true
-    | "retry" -> true
-    | "reuse_hint_for" -> true
-    | "report_assumes" -> true
-    | "silent" -> true
-    | "smtencoding.elim_box" -> true
-    | "smtencoding.l_arith_repr" -> true
-    | "smtencoding.nl_arith_repr" -> true
-    | "smtencoding.valid_intro" -> true
-    | "smtencoding.valid_elim" -> true
-    | "split_queries" -> true
-    | "tactic_raw_binders" -> true
-    | "tactics_failhard" -> true
-    | "tactics_info" -> true
-    | "__tactics_nbe" -> true
-    | "tactic_trace" -> true
-    | "tactic_trace_d" -> true
-    | "tcnorm" -> true
-    | "__temp_fast_implicits" -> true
-    | "timing" -> true
-    | "trace_error" -> true
-    | "ugly" -> true
-    | "unthrottle_inductives" -> true
-    | "use_eq_at_higher_order" -> true
-    | "using_facts_from" -> true
-    | "vcgen.optimize_bind_as_seq" -> true
-    | "warn_error" -> true
-    | "z3cliopt" -> true
-    | "z3smtopt" -> true
-    | "z3refresh" -> true
-    | "z3rlimit" -> true
-    | "z3rlimit_factor" -> true
-    | "z3seed" -> true
-    | "trivial_pre_for_unannotated_effectful_fns" -> true
-    | "profile_group_by_decl" -> true
-    | "profile_component" -> true
-    | "profile" -> true
-    | uu___1 -> false
-let (all_specs : FStar_Getopt.opt Prims.list) = specs true
-let (all_specs_with_types :
-  (FStar_BaseTypes.char * Prims.string * opt_type * Prims.string) Prims.list)
-  = specs_with_types true
-let (settable_specs :
-  (FStar_BaseTypes.char * Prims.string * unit FStar_Getopt.opt_variant *
-    Prims.string) Prims.list)
-  =
-  FStar_Compiler_Effect.op_Bar_Greater all_specs
-    (FStar_Compiler_List.filter
-       (fun uu___ ->
-          match uu___ with | (uu___1, x, uu___2, uu___3) -> settable x))
-let (uu___641 :
-  (((unit -> FStar_Getopt.parse_cmdline_res) -> unit) *
-    (unit -> FStar_Getopt.parse_cmdline_res)))
-  =
-  let callback = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let set1 f =
-    FStar_Compiler_Effect.op_Colon_Equals callback
-      (FStar_Pervasives_Native.Some f) in
-  let call uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang callback in
-    match uu___1 with
-    | FStar_Pervasives_Native.None ->
-        failwith "Error flags callback not yet set"
-    | FStar_Pervasives_Native.Some f -> f () in
-  (set1, call)
-let (set_error_flags_callback_aux :
-  (unit -> FStar_Getopt.parse_cmdline_res) -> unit) =
-  match uu___641 with
-  | (set_error_flags_callback_aux1, set_error_flags) ->
-      set_error_flags_callback_aux1
-let (set_error_flags : unit -> FStar_Getopt.parse_cmdline_res) =
-  match uu___641 with
-  | (set_error_flags_callback_aux1, set_error_flags1) -> set_error_flags1
-let (set_error_flags_callback :
-  (unit -> FStar_Getopt.parse_cmdline_res) -> unit) =
-  set_error_flags_callback_aux
-let (display_usage : unit -> unit) = fun uu___ -> display_usage_aux all_specs
-let (fstar_bin_directory : Prims.string) =
-  FStar_Compiler_Util.get_exec_dir ()
-let (file_list_ : Prims.string Prims.list FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let rec (parse_filename_arg :
-  FStar_Getopt.opt Prims.list ->
-    Prims.bool -> Prims.string -> FStar_Getopt.parse_cmdline_res)
-  =
-  fun specs1 ->
-    fun enable_filenames ->
-      fun arg ->
-        if FStar_Compiler_Util.starts_with arg "@"
-        then
-          let filename = FStar_Compiler_Util.substring_from arg Prims.int_one in
-          let lines = FStar_Compiler_Util.file_get_lines filename in
-          FStar_Getopt.parse_list specs1
-            (parse_filename_arg specs1 enable_filenames) lines
-        else
-          (if enable_filenames
-           then
-             (let uu___2 =
-                let uu___3 = FStar_Compiler_Effect.op_Bang file_list_ in
-                FStar_Compiler_List.op_At uu___3 [arg] in
-              FStar_Compiler_Effect.op_Colon_Equals file_list_ uu___2)
-           else ();
-           FStar_Getopt.Success)
-let (parse_cmd_line :
-  unit -> (FStar_Getopt.parse_cmdline_res * Prims.string Prims.list)) =
-  fun uu___ ->
-    let res =
-      FStar_Getopt.parse_cmdline all_specs
-        (parse_filename_arg all_specs true) in
-    let res1 = if res = FStar_Getopt.Success then set_error_flags () else res in
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang file_list_ in
-      FStar_Compiler_List.map FStar_Common.try_convert_file_name_to_mixed
-        uu___2 in
-    (res1, uu___1)
-let (file_list : unit -> Prims.string Prims.list) =
-  fun uu___ -> FStar_Compiler_Effect.op_Bang file_list_
-let (restore_cmd_line_options : Prims.bool -> FStar_Getopt.parse_cmdline_res)
-  =
-  fun should_clear ->
-    let old_verify_module = get_verify_module () in
-    if should_clear then clear () else init ();
-    (let specs1 = specs false in
-     let r =
-       FStar_Getopt.parse_cmdline specs1 (parse_filename_arg specs1 false) in
-     (let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            FStar_Compiler_List.map (fun uu___5 -> String uu___5)
-              old_verify_module in
-          List uu___4 in
-        ("verify_module", uu___3) in
-      set_option' uu___2);
-     r)
-let (module_name_of_file_name : Prims.string -> Prims.string) =
-  fun f ->
-    let f1 = FStar_Compiler_Util.basename f in
-    let f2 =
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Util.get_file_extension f1 in
-            FStar_String.length uu___3 in
-          (FStar_String.length f1) - uu___2 in
-        uu___1 - Prims.int_one in
-      FStar_String.substring f1 Prims.int_zero uu___ in
-    FStar_String.lowercase f2
-let (should_check : Prims.string -> Prims.bool) =
-  fun m ->
-    let l = get_verify_module () in
-    FStar_Compiler_List.contains (FStar_String.lowercase m) l
-let (should_verify : Prims.string -> Prims.bool) =
-  fun m ->
-    (let uu___ = get_lax () in Prims.op_Negation uu___) && (should_check m)
-let (should_check_file : Prims.string -> Prims.bool) =
-  fun fn -> let uu___ = module_name_of_file_name fn in should_check uu___
-let (should_verify_file : Prims.string -> Prims.bool) =
-  fun fn -> let uu___ = module_name_of_file_name fn in should_verify uu___
-let (module_name_eq : Prims.string -> Prims.string -> Prims.bool) =
-  fun m1 ->
-    fun m2 -> (FStar_String.lowercase m1) = (FStar_String.lowercase m2)
-let (should_print_message : Prims.string -> Prims.bool) =
-  fun m ->
-    let uu___ = should_verify m in if uu___ then m <> "Prims" else false
-let (include_path : unit -> Prims.string Prims.list) =
-  fun uu___ ->
-    let cache_dir =
-      let uu___1 = get_cache_dir () in
-      match uu___1 with
-      | FStar_Pervasives_Native.None -> []
-      | FStar_Pervasives_Native.Some c -> [c] in
-    let uu___1 = get_no_default_includes () in
-    if uu___1
-    then
-      let uu___2 = get_include () in
-      FStar_Compiler_List.op_At cache_dir uu___2
-    else
-      (let lib_paths =
-         let uu___3 =
-           FStar_Compiler_Util.expand_environment_variable "FSTAR_LIB" in
-         match uu___3 with
-         | FStar_Pervasives_Native.None ->
-             let fstar_home = FStar_String.op_Hat fstar_bin_directory "/.." in
-             let defs = universe_include_path_base_dirs in
-             let uu___4 =
-               FStar_Compiler_Effect.op_Bar_Greater defs
-                 (FStar_Compiler_List.map
-                    (fun x -> FStar_String.op_Hat fstar_home x)) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___4
-               (FStar_Compiler_List.filter FStar_Compiler_Util.file_exists)
-         | FStar_Pervasives_Native.Some s -> [s] in
-       let uu___3 =
-         let uu___4 =
-           let uu___5 = get_include () in
-           FStar_Compiler_List.op_At uu___5 ["."] in
-         FStar_Compiler_List.op_At lib_paths uu___4 in
-       FStar_Compiler_List.op_At cache_dir uu___3)
-let (find_file : Prims.string -> Prims.string FStar_Pervasives_Native.option)
-  =
-  let file_map = FStar_Compiler_Util.smap_create (Prims.of_int (100)) in
-  fun filename ->
-    let uu___ = FStar_Compiler_Util.smap_try_find file_map filename in
-    match uu___ with
-    | FStar_Pervasives_Native.Some f -> f
-    | FStar_Pervasives_Native.None ->
-        let result =
-          try
-            (fun uu___1 ->
-               match () with
-               | () ->
-                   let uu___2 = FStar_Compiler_Util.is_path_absolute filename in
-                   if uu___2
-                   then
-                     (if FStar_Compiler_Util.file_exists filename
-                      then FStar_Pervasives_Native.Some filename
-                      else FStar_Pervasives_Native.None)
-                   else
-                     (let uu___4 =
-                        let uu___5 = include_path () in
-                        FStar_Compiler_List.rev uu___5 in
-                      FStar_Compiler_Util.find_map uu___4
-                        (fun p ->
-                           let path =
-                             if p = "."
-                             then filename
-                             else FStar_Compiler_Util.join_paths p filename in
-                           if FStar_Compiler_Util.file_exists path
-                           then FStar_Pervasives_Native.Some path
-                           else FStar_Pervasives_Native.None))) ()
-          with | uu___1 -> FStar_Pervasives_Native.None in
-        (if FStar_Compiler_Option.isSome result
-         then FStar_Compiler_Util.smap_add file_map filename result
-         else ();
-         result)
-let (prims : unit -> Prims.string) =
-  fun uu___ ->
-    let uu___1 = get_prims () in
-    match uu___1 with
-    | FStar_Pervasives_Native.None ->
-        let filename = "prims.fst" in
-        let uu___2 = find_file filename in
-        (match uu___2 with
-         | FStar_Pervasives_Native.Some result -> result
-         | FStar_Pervasives_Native.None ->
-             let uu___3 =
-               FStar_Compiler_Util.format1
-                 "unable to find required file \"%s\" in the module search path.\n"
-                 filename in
-             failwith uu___3)
-    | FStar_Pervasives_Native.Some x -> x
-let (prims_basename : unit -> Prims.string) =
-  fun uu___ -> let uu___1 = prims () in FStar_Compiler_Util.basename uu___1
-let (pervasives : unit -> Prims.string) =
-  fun uu___ ->
-    let filename = "FStar.Pervasives.fsti" in
-    let uu___1 = find_file filename in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some result -> result
-    | FStar_Pervasives_Native.None ->
-        let uu___2 =
-          FStar_Compiler_Util.format1
-            "unable to find required file \"%s\" in the module search path.\n"
-            filename in
-        failwith uu___2
-let (pervasives_basename : unit -> Prims.string) =
-  fun uu___ ->
-    let uu___1 = pervasives () in FStar_Compiler_Util.basename uu___1
-let (pervasives_native_basename : unit -> Prims.string) =
-  fun uu___ ->
-    let filename = "FStar.Pervasives.Native.fst" in
-    let uu___1 = find_file filename in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some result ->
-        FStar_Compiler_Util.basename result
-    | FStar_Pervasives_Native.None ->
-        let uu___2 =
-          FStar_Compiler_Util.format1
-            "unable to find required file \"%s\" in the module search path.\n"
-            filename in
-        failwith uu___2
-let (prepend_output_dir : Prims.string -> Prims.string) =
-  fun fname ->
-    let uu___ = get_odir () in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> fname
-    | FStar_Pervasives_Native.Some x ->
-        FStar_Compiler_Util.join_paths x fname
-let (prepend_cache_dir : Prims.string -> Prims.string) =
-  fun fpath ->
-    let uu___ = get_cache_dir () in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> fpath
-    | FStar_Pervasives_Native.Some x ->
-        let uu___1 = FStar_Compiler_Util.basename fpath in
-        FStar_Compiler_Util.join_paths x uu___1
-let (path_of_text : Prims.string -> Prims.string Prims.list) =
-  fun text -> FStar_String.split [46] text
-let (parse_settings :
-  Prims.string Prims.list ->
-    (Prims.string Prims.list * Prims.bool) Prims.list)
-  =
-  fun ns ->
-    let cache = FStar_Compiler_Util.smap_create (Prims.of_int (31)) in
-    let with_cache f s =
-      let uu___ = FStar_Compiler_Util.smap_try_find cache s in
-      match uu___ with
-      | FStar_Pervasives_Native.Some s1 -> s1
-      | FStar_Pervasives_Native.None ->
-          let res = f s in (FStar_Compiler_Util.smap_add cache s res; res) in
-    let parse_one_setting s =
-      if s = "*"
-      then ([], true)
-      else
-        if s = "-*"
-        then ([], false)
-        else
-          if FStar_Compiler_Util.starts_with s "-"
-          then
-            (let path =
-               let uu___2 =
-                 FStar_Compiler_Util.substring_from s Prims.int_one in
-               path_of_text uu___2 in
-             (path, false))
-          else
-            (let s1 =
-               if FStar_Compiler_Util.starts_with s "+"
-               then FStar_Compiler_Util.substring_from s Prims.int_one
-               else s in
-             ((path_of_text s1), true)) in
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater ns
-        (FStar_Compiler_List.collect
-           (fun s ->
-              let s1 = FStar_Compiler_Util.trim_string s in
-              if s1 = ""
-              then []
-              else
-                with_cache
-                  (fun s2 ->
-                     let s3 = FStar_Compiler_Util.replace_char s2 32 44 in
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           (FStar_Compiler_Util.splitlines s3)
-                           (FStar_Compiler_List.concatMap
-                              (fun s4 -> FStar_Compiler_Util.split s4 ",")) in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___3
-                         (FStar_Compiler_List.filter (fun s4 -> s4 <> "")) in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___2
-                       (FStar_Compiler_List.map parse_one_setting)) s1)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Compiler_List.rev
-let (__temp_fast_implicits : unit -> Prims.bool) =
-  fun uu___ -> lookup_opt "__temp_fast_implicits" as_bool
-let (admit_smt_queries : unit -> Prims.bool) =
-  fun uu___ -> get_admit_smt_queries ()
-let (admit_except : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_admit_except ()
-let (compat_pre_core_should_register : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_compat_pre_core () in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some uu___2 when uu___2 = Prims.int_zero ->
-        false
-    | uu___2 -> true
-let (compat_pre_core_should_check : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_compat_pre_core () in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some uu___2 when uu___2 = Prims.int_zero ->
-        false
-    | FStar_Pervasives_Native.Some uu___2 when uu___2 = Prims.int_one ->
-        false
-    | uu___2 -> true
-let (compat_pre_core_set : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_compat_pre_core () in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> false
-    | uu___2 -> true
-let (compat_pre_typed_indexed_effects : unit -> Prims.bool) =
-  fun uu___ -> get_compat_pre_typed_indexed_effects ()
-let (disallow_unification_guards : unit -> Prims.bool) =
-  fun uu___ -> get_disallow_unification_guards ()
-let (cache_checked_modules : unit -> Prims.bool) =
-  fun uu___ -> get_cache_checked_modules ()
-let (cache_off : unit -> Prims.bool) = fun uu___ -> get_cache_off ()
-let (print_cache_version : unit -> Prims.bool) =
-  fun uu___ -> get_print_cache_version ()
-let (cmi : unit -> Prims.bool) = fun uu___ -> get_cmi ()
-type codegen_t =
-  | OCaml 
-  | FSharp 
-  | Krml 
-  | Plugin 
-let (uu___is_OCaml : codegen_t -> Prims.bool) =
-  fun projectee -> match projectee with | OCaml -> true | uu___ -> false
-let (uu___is_FSharp : codegen_t -> Prims.bool) =
-  fun projectee -> match projectee with | FSharp -> true | uu___ -> false
-let (uu___is_Krml : codegen_t -> Prims.bool) =
-  fun projectee -> match projectee with | Krml -> true | uu___ -> false
-let (uu___is_Plugin : codegen_t -> Prims.bool) =
-  fun projectee -> match projectee with | Plugin -> true | uu___ -> false
-let (parse_codegen :
-  Prims.string -> codegen_t FStar_Pervasives_Native.option) =
-  fun uu___ ->
-    match uu___ with
-    | "OCaml" -> FStar_Pervasives_Native.Some OCaml
-    | "FSharp" -> FStar_Pervasives_Native.Some FSharp
-    | "krml" -> FStar_Pervasives_Native.Some Krml
-    | "Plugin" -> FStar_Pervasives_Native.Some Plugin
-    | uu___1 -> FStar_Pervasives_Native.None
-let (print_codegen : codegen_t -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | OCaml -> "OCaml"
-    | FSharp -> "FSharp"
-    | Krml -> "krml"
-    | Plugin -> "Plugin"
-let (codegen : unit -> codegen_t FStar_Pervasives_Native.option) =
-  fun uu___ ->
-    let uu___1 = get_codegen () in
-    FStar_Compiler_Util.map_opt uu___1
-      (fun s ->
-         let uu___2 = parse_codegen s in
-         FStar_Compiler_Effect.op_Bar_Greater uu___2 FStar_Compiler_Util.must)
-let (codegen_libs : unit -> Prims.string Prims.list Prims.list) =
-  fun uu___ ->
-    let uu___1 = get_codegen_lib () in
-    FStar_Compiler_Effect.op_Bar_Greater uu___1
-      (FStar_Compiler_List.map (fun x -> FStar_Compiler_Util.split x "."))
-let (debug_any : unit -> Prims.bool) =
-  fun uu___ -> let uu___1 = get_debug () in uu___1 <> []
-let (debug_module : Prims.string -> Prims.bool) =
-  fun modul ->
-    let uu___ = get_debug () in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (FStar_Compiler_List.existsb (module_name_eq modul))
-let (debug_at_level_no_module : debug_level_t -> Prims.bool) =
-  fun level -> debug_level_geq level
-let (debug_at_level : Prims.string -> debug_level_t -> Prims.bool) =
-  fun modul ->
-    fun level -> (debug_module modul) && (debug_at_level_no_module level)
-let (profile_group_by_decls : unit -> Prims.bool) =
-  fun uu___ -> get_profile_group_by_decl ()
-let (defensive : unit -> Prims.bool) =
-  fun uu___ -> let uu___1 = get_defensive () in uu___1 <> "no"
-let (defensive_error : unit -> Prims.bool) =
-  fun uu___ -> let uu___1 = get_defensive () in uu___1 = "error"
-let (defensive_abort : unit -> Prims.bool) =
-  fun uu___ -> let uu___1 = get_defensive () in uu___1 = "abort"
-let (dep : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_dep ()
-let (detail_errors : unit -> Prims.bool) = fun uu___ -> get_detail_errors ()
-let (detail_hint_replay : unit -> Prims.bool) =
-  fun uu___ -> get_detail_hint_replay ()
-let (dump_module : Prims.string -> Prims.bool) =
-  fun s ->
-    let uu___ = get_dump_module () in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (FStar_Compiler_List.existsb (module_name_eq s))
-let (eager_subtyping : unit -> Prims.bool) =
-  fun uu___ -> get_eager_subtyping ()
-let (error_contexts : unit -> Prims.bool) =
-  fun uu___ -> get_error_contexts ()
-let (expose_interfaces : unit -> Prims.bool) =
-  fun uu___ -> get_expose_interfaces ()
-let (force : unit -> Prims.bool) = fun uu___ -> get_force ()
-let (full_context_dependency : unit -> Prims.bool) = fun uu___ -> true
-let (hide_uvar_nums : unit -> Prims.bool) =
-  fun uu___ -> get_hide_uvar_nums ()
-let (hint_info : unit -> Prims.bool) =
-  fun uu___ -> (get_hint_info ()) || (get_query_stats ())
-let (hint_dir : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_hint_dir ()
-let (hint_file : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_hint_file ()
-let (hint_file_for_src : Prims.string -> Prims.string) =
-  fun src_filename ->
-    let uu___ = hint_file () in
-    match uu___ with
-    | FStar_Pervasives_Native.Some fn -> fn
-    | FStar_Pervasives_Native.None ->
-        let file_name =
-          let uu___1 = hint_dir () in
-          match uu___1 with
-          | FStar_Pervasives_Native.Some dir ->
-              let uu___2 = FStar_Compiler_Util.basename src_filename in
-              FStar_Compiler_Util.concat_dir_filename dir uu___2
-          | uu___2 -> src_filename in
-        FStar_Compiler_Util.format1 "%s.hints" file_name
-let (ide : unit -> Prims.bool) = fun uu___ -> get_ide ()
-let (ide_id_info_off : unit -> Prims.bool) =
-  fun uu___ -> get_ide_id_info_off ()
-let (print : unit -> Prims.bool) = fun uu___ -> get_print ()
-let (print_in_place : unit -> Prims.bool) =
-  fun uu___ -> get_print_in_place ()
-let (initial_fuel : unit -> Prims.int) =
-  fun uu___ ->
-    let uu___1 = get_initial_fuel () in
-    let uu___2 = get_max_fuel () in Prims.min uu___1 uu___2
-let (initial_ifuel : unit -> Prims.int) =
-  fun uu___ ->
-    let uu___1 = get_initial_ifuel () in
-    let uu___2 = get_max_ifuel () in Prims.min uu___1 uu___2
-let (interactive : unit -> Prims.bool) =
-  fun uu___ -> (get_in ()) || (get_ide ())
-let (lax : unit -> Prims.bool) = fun uu___ -> get_lax ()
-let (load : unit -> Prims.string Prims.list) = fun uu___ -> get_load ()
-let (load_cmxs : unit -> Prims.string Prims.list) =
-  fun uu___ -> get_load_cmxs ()
-let (legacy_interactive : unit -> Prims.bool) = fun uu___ -> get_in ()
-let (lsp_server : unit -> Prims.bool) = fun uu___ -> get_lsp ()
-let (log_queries : unit -> Prims.bool) = fun uu___ -> get_log_queries ()
-let (keep_query_captions : unit -> Prims.bool) =
-  fun uu___ -> (log_queries ()) && (get_keep_query_captions ())
-let (log_types : unit -> Prims.bool) = fun uu___ -> get_log_types ()
-let (max_fuel : unit -> Prims.int) = fun uu___ -> get_max_fuel ()
-let (max_ifuel : unit -> Prims.int) = fun uu___ -> get_max_ifuel ()
-let (ml_ish : unit -> Prims.bool) = fun uu___ -> get_MLish ()
-let (set_ml_ish : unit -> unit) = fun uu___ -> set_option "MLish" (Bool true)
-let (no_default_includes : unit -> Prims.bool) =
-  fun uu___ -> get_no_default_includes ()
-let (no_extract : Prims.string -> Prims.bool) =
-  fun s ->
-    let uu___ = get_no_extract () in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (FStar_Compiler_List.existsb (module_name_eq s))
-let (normalize_pure_terms_for_extraction : unit -> Prims.bool) =
-  fun uu___ -> get_normalize_pure_terms_for_extraction ()
-let (no_load_fstartaclib : unit -> Prims.bool) =
-  fun uu___ -> get_no_load_fstartaclib ()
-let (no_location_info : unit -> Prims.bool) =
-  fun uu___ -> get_no_location_info ()
-let (no_plugins : unit -> Prims.bool) = fun uu___ -> get_no_plugins ()
-let (no_smt : unit -> Prims.bool) = fun uu___ -> get_no_smt ()
-let (output_dir : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_odir ()
-let (ugly : unit -> Prims.bool) = fun uu___ -> get_ugly ()
-let (print_bound_var_types : unit -> Prims.bool) =
-  fun uu___ -> get_print_bound_var_types ()
-let (print_effect_args : unit -> Prims.bool) =
-  fun uu___ -> get_print_effect_args ()
-let (print_expected_failures : unit -> Prims.bool) =
-  fun uu___ -> get_print_expected_failures ()
-let (print_implicits : unit -> Prims.bool) =
-  fun uu___ -> get_print_implicits ()
-let (print_real_names : unit -> Prims.bool) =
-  fun uu___ -> (get_prn ()) || (get_print_full_names ())
-let (print_universes : unit -> Prims.bool) =
-  fun uu___ -> get_print_universes ()
-let (print_z3_statistics : unit -> Prims.bool) =
-  fun uu___ -> get_print_z3_statistics ()
-let (quake_lo : unit -> Prims.int) = fun uu___ -> get_quake_lo ()
-let (quake_hi : unit -> Prims.int) = fun uu___ -> get_quake_hi ()
-let (quake_keep : unit -> Prims.bool) = fun uu___ -> get_quake_keep ()
-let (query_stats : unit -> Prims.bool) = fun uu___ -> get_query_stats ()
-let (record_hints : unit -> Prims.bool) = fun uu___ -> get_record_hints ()
-let (record_options : unit -> Prims.bool) =
-  fun uu___ -> get_record_options ()
-let (retry : unit -> Prims.bool) = fun uu___ -> get_retry ()
-let (reuse_hint_for : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_reuse_hint_for ()
-let (report_assumes : unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_report_assumes ()
-let (silent : unit -> Prims.bool) = fun uu___ -> get_silent ()
-let (smtencoding_elim_box : unit -> Prims.bool) =
-  fun uu___ -> get_smtencoding_elim_box ()
-let (smtencoding_nl_arith_native : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_smtencoding_nl_arith_repr () in uu___1 = "native"
-let (smtencoding_nl_arith_wrapped : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_smtencoding_nl_arith_repr () in uu___1 = "wrapped"
-let (smtencoding_nl_arith_default : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_smtencoding_nl_arith_repr () in uu___1 = "boxwrap"
-let (smtencoding_l_arith_native : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_smtencoding_l_arith_repr () in uu___1 = "native"
-let (smtencoding_l_arith_default : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_smtencoding_l_arith_repr () in uu___1 = "boxwrap"
-let (smtencoding_valid_intro : unit -> Prims.bool) =
-  fun uu___ -> get_smtencoding_valid_intro ()
-let (smtencoding_valid_elim : unit -> Prims.bool) =
-  fun uu___ -> get_smtencoding_valid_elim ()
-let (split_queries : unit -> Prims.bool) = fun uu___ -> get_split_queries ()
-let (tactic_raw_binders : unit -> Prims.bool) =
-  fun uu___ -> get_tactic_raw_binders ()
-let (tactics_failhard : unit -> Prims.bool) =
-  fun uu___ -> get_tactics_failhard ()
-let (tactics_info : unit -> Prims.bool) = fun uu___ -> get_tactics_info ()
-let (tactic_trace : unit -> Prims.bool) = fun uu___ -> get_tactic_trace ()
-let (tactic_trace_d : unit -> Prims.int) = fun uu___ -> get_tactic_trace_d ()
-let (tactics_nbe : unit -> Prims.bool) = fun uu___ -> get_tactics_nbe ()
-let (tcnorm : unit -> Prims.bool) = fun uu___ -> get_tcnorm ()
-let (timing : unit -> Prims.bool) = fun uu___ -> get_timing ()
-let (trace_error : unit -> Prims.bool) = fun uu___ -> get_trace_error ()
-let (unthrottle_inductives : unit -> Prims.bool) =
-  fun uu___ -> get_unthrottle_inductives ()
-let (unsafe_tactic_exec : unit -> Prims.bool) =
-  fun uu___ -> get_unsafe_tactic_exec ()
-let (use_eq_at_higher_order : unit -> Prims.bool) =
-  fun uu___ -> get_use_eq_at_higher_order ()
-let (use_hints : unit -> Prims.bool) = fun uu___ -> get_use_hints ()
-let (use_hint_hashes : unit -> Prims.bool) =
-  fun uu___ -> get_use_hint_hashes ()
-let (use_native_tactics :
-  unit -> Prims.string FStar_Pervasives_Native.option) =
-  fun uu___ -> get_use_native_tactics ()
-let (use_tactics : unit -> Prims.bool) =
-  fun uu___ -> let uu___1 = get_no_tactics () in Prims.op_Negation uu___1
-let (using_facts_from :
-  unit -> (Prims.string Prims.list * Prims.bool) Prims.list) =
-  fun uu___ ->
-    let uu___1 = get_using_facts_from () in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> [([], true)]
-    | FStar_Pervasives_Native.Some ns -> parse_settings ns
-let (vcgen_optimize_bind_as_seq : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_vcgen_optimize_bind_as_seq () in
-    FStar_Compiler_Option.isSome uu___1
-let (vcgen_decorate_with_type : unit -> Prims.bool) =
-  fun uu___ ->
-    let uu___1 = get_vcgen_optimize_bind_as_seq () in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some "with_type" -> true
-    | uu___2 -> false
-let (warn_default_effects : unit -> Prims.bool) =
-  fun uu___ -> get_warn_default_effects ()
-let (warn_error : unit -> Prims.string) =
-  fun uu___ ->
-    let uu___1 = get_warn_error () in FStar_String.concat " " uu___1
-let (z3_exe : unit -> Prims.string) =
-  fun uu___ ->
-    let uu___1 = get_smt () in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> FStar_Platform.exe "z3"
-    | FStar_Pervasives_Native.Some s -> s
-let (z3_cliopt : unit -> Prims.string Prims.list) =
-  fun uu___ -> get_z3cliopt ()
-let (z3_smtopt : unit -> Prims.string Prims.list) =
-  fun uu___ -> get_z3smtopt ()
-let (z3_refresh : unit -> Prims.bool) = fun uu___ -> get_z3refresh ()
-let (z3_rlimit : unit -> Prims.int) = fun uu___ -> get_z3rlimit ()
-let (z3_rlimit_factor : unit -> Prims.int) =
-  fun uu___ -> get_z3rlimit_factor ()
-let (z3_seed : unit -> Prims.int) = fun uu___ -> get_z3seed ()
-let (no_positivity : unit -> Prims.bool) = fun uu___ -> get_no_positivity ()
-let (use_nbe : unit -> Prims.bool) = fun uu___ -> get_use_nbe ()
-let (use_nbe_for_extraction : unit -> Prims.bool) =
-  fun uu___ -> get_use_nbe_for_extraction ()
-let (trivial_pre_for_unannotated_effectful_fns : unit -> Prims.bool) =
-  fun uu___ -> get_trivial_pre_for_unannotated_effectful_fns ()
-let with_saved_options : 'a . (unit -> 'a) -> 'a =
-  fun f ->
-    let uu___ = let uu___1 = trace_error () in Prims.op_Negation uu___1 in
-    if uu___
-    then
-      (push ();
-       (let r =
-          try
-            (fun uu___2 ->
-               match () with
-               | () -> let uu___3 = f () in FStar_Pervasives.Inr uu___3) ()
-          with | uu___2 -> FStar_Pervasives.Inl uu___2 in
-        pop ();
-        (match r with
-         | FStar_Pervasives.Inr v -> v
-         | FStar_Pervasives.Inl ex -> FStar_Compiler_Effect.raise ex)))
-    else (push (); (let retv = f () in pop (); retv))
-let (module_matches_namespace_filter :
-  Prims.string -> Prims.string Prims.list -> Prims.bool) =
-  fun m ->
-    fun filter ->
-      let m1 = FStar_String.lowercase m in
-      let setting = parse_settings filter in
-      let m_components = path_of_text m1 in
-      let rec matches_path m_components1 path =
-        match (m_components1, path) with
-        | (uu___, []) -> true
-        | (m2::ms, p::ps) ->
-            (m2 = (FStar_String.lowercase p)) && (matches_path ms ps)
-        | uu___ -> false in
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater setting
-          (FStar_Compiler_Util.try_find
-             (fun uu___1 ->
-                match uu___1 with
-                | (path, uu___2) -> matches_path m_components path)) in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some (uu___1, flag) -> flag
-let (matches_namespace_filter_opt :
-  Prims.string ->
-    Prims.string Prims.list FStar_Pervasives_Native.option -> Prims.bool)
-  =
-  fun m ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some filter ->
-          module_matches_namespace_filter m filter
-type parsed_extract_setting =
-  {
-  target_specific_settings: (codegen_t * Prims.string) Prims.list ;
-  default_settings: Prims.string FStar_Pervasives_Native.option }
-let (__proj__Mkparsed_extract_setting__item__target_specific_settings :
-  parsed_extract_setting -> (codegen_t * Prims.string) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { target_specific_settings; default_settings;_} ->
-        target_specific_settings
-let (__proj__Mkparsed_extract_setting__item__default_settings :
-  parsed_extract_setting -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { target_specific_settings; default_settings;_} -> default_settings
-let (print_pes : parsed_extract_setting -> Prims.string) =
-  fun pes ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_List.map
-          (fun uu___2 ->
-             match uu___2 with
-             | (tgt, s) ->
-                 FStar_Compiler_Util.format2 "(%s, %s)" (print_codegen tgt) s)
-          pes.target_specific_settings in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 (FStar_String.concat "; ") in
-    FStar_Compiler_Util.format2
-      "{ target_specific_settings = %s;\n\t\n               default_settings = %s }"
-      uu___
-      (match pes.default_settings with
-       | FStar_Pervasives_Native.None -> "None"
-       | FStar_Pervasives_Native.Some s -> s)
-let (find_setting_for_target :
-  codegen_t ->
-    (codegen_t * Prims.string) Prims.list ->
-      Prims.string FStar_Pervasives_Native.option)
-  =
-  fun tgt ->
-    fun s ->
-      let uu___ =
-        FStar_Compiler_Util.try_find
-          (fun uu___1 -> match uu___1 with | (x, uu___2) -> x = tgt) s in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (uu___1, s1) ->
-          FStar_Pervasives_Native.Some s1
-      | uu___1 -> FStar_Pervasives_Native.None
-let (extract_settings :
-  unit -> parsed_extract_setting FStar_Pervasives_Native.option) =
-  let memo = FStar_Compiler_Util.mk_ref (FStar_Pervasives_Native.None, false) in
-  let merge_parsed_extract_settings p0 p1 =
-    let merge_setting s0 s1 =
-      match (s0, s1) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives_Native.None
-      | (FStar_Pervasives_Native.Some p, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives_Native.Some p
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some p) ->
-          FStar_Pervasives_Native.Some p
-      | (FStar_Pervasives_Native.Some p01, FStar_Pervasives_Native.Some p11)
-          ->
-          let uu___ =
-            let uu___1 = FStar_String.op_Hat "," p11 in
-            FStar_String.op_Hat p01 uu___1 in
-          FStar_Pervasives_Native.Some uu___ in
-    let merge_target tgt =
-      let uu___ =
-        let uu___1 = find_setting_for_target tgt p0.target_specific_settings in
-        let uu___2 = find_setting_for_target tgt p1.target_specific_settings in
-        merge_setting uu___1 uu___2 in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> []
-      | FStar_Pervasives_Native.Some x -> [(tgt, x)] in
-    let uu___ =
-      FStar_Compiler_List.collect merge_target [OCaml; FSharp; Krml; Plugin] in
-    let uu___1 = merge_setting p0.default_settings p1.default_settings in
-    { target_specific_settings = uu___; default_settings = uu___1 } in
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang memo in
-    match uu___1 with
-    | (result, set1) ->
-        let fail msg =
-          display_usage ();
-          (let uu___3 =
-             FStar_Compiler_Util.format1
-               "Could not parse '%s' passed to the --extract option" msg in
-           failwith uu___3) in
-        if set1
-        then result
-        else
-          (let uu___3 = get_extract () in
-           match uu___3 with
-           | FStar_Pervasives_Native.None ->
-               (FStar_Compiler_Effect.op_Colon_Equals memo
-                  (FStar_Pervasives_Native.None, true);
-                FStar_Pervasives_Native.None)
-           | FStar_Pervasives_Native.Some extract_settings1 ->
-               let parse_one_setting extract_setting =
-                 let tgt_specific_settings =
-                   FStar_Compiler_Util.split extract_setting ";" in
-                 let split_one t_setting =
-                   match FStar_Compiler_Util.split t_setting ":" with
-                   | default_setting::[] ->
-                       FStar_Pervasives.Inr
-                         (FStar_Compiler_Util.trim_string default_setting)
-                   | target::setting::[] ->
-                       let target1 = FStar_Compiler_Util.trim_string target in
-                       let uu___4 = parse_codegen target1 in
-                       (match uu___4 with
-                        | FStar_Pervasives_Native.None -> fail target1
-                        | FStar_Pervasives_Native.Some tgt ->
-                            FStar_Pervasives.Inl
-                              (tgt,
-                                (FStar_Compiler_Util.trim_string setting))
-                        | uu___5 -> fail t_setting) in
-                 let settings =
-                   FStar_Compiler_List.map split_one tgt_specific_settings in
-                 let fail_duplicate msg tgt =
-                   display_usage ();
-                   (let uu___5 =
-                      FStar_Compiler_Util.format2
-                        "Could not parse '%s'; multiple setting for %s target"
-                        msg tgt in
-                    failwith uu___5) in
-                 let pes =
-                   FStar_Compiler_List.fold_right
-                     (fun setting ->
-                        fun out ->
-                          match setting with
-                          | FStar_Pervasives.Inr def ->
-                              (match out.default_settings with
-                               | FStar_Pervasives_Native.None ->
-                                   {
-                                     target_specific_settings =
-                                       (out.target_specific_settings);
-                                     default_settings =
-                                       (FStar_Pervasives_Native.Some def)
-                                   }
-                               | FStar_Pervasives_Native.Some uu___4 ->
-                                   fail_duplicate def "default")
-                          | FStar_Pervasives.Inl (target, setting1) ->
-                              let uu___4 =
-                                FStar_Compiler_Util.try_find
-                                  (fun uu___5 ->
-                                     match uu___5 with
-                                     | (x, uu___6) -> x = target)
-                                  out.target_specific_settings in
-                              (match uu___4 with
-                               | FStar_Pervasives_Native.None ->
-                                   {
-                                     target_specific_settings =
-                                       ((target, setting1) ::
-                                       (out.target_specific_settings));
-                                     default_settings =
-                                       (out.default_settings)
-                                   }
-                               | FStar_Pervasives_Native.Some uu___5 ->
-                                   fail_duplicate setting1
-                                     (print_codegen target))) settings
-                     {
-                       target_specific_settings = [];
-                       default_settings = FStar_Pervasives_Native.None
-                     } in
-                 pes in
-               let empty_pes =
-                 {
-                   target_specific_settings = [];
-                   default_settings = FStar_Pervasives_Native.None
-                 } in
-               let pes =
-                 FStar_Compiler_List.fold_right
-                   (fun setting ->
-                      fun pes1 ->
-                        let uu___4 = parse_one_setting setting in
-                        merge_parsed_extract_settings pes1 uu___4)
-                   extract_settings1 empty_pes in
-               (FStar_Compiler_Effect.op_Colon_Equals memo
-                  ((FStar_Pervasives_Native.Some pes), true);
-                FStar_Pervasives_Native.Some pes))
-let (should_extract : Prims.string -> codegen_t -> Prims.bool) =
-  fun m ->
-    fun tgt ->
-      let m1 = FStar_String.lowercase m in
-      let uu___ = extract_settings () in
-      match uu___ with
-      | FStar_Pervasives_Native.Some pes ->
-          ((let uu___2 =
-              let uu___3 = get_no_extract () in
-              let uu___4 = get_extract_namespace () in
-              let uu___5 = get_extract_module () in (uu___3, uu___4, uu___5) in
-            match uu___2 with
-            | ([], [], []) -> ()
-            | uu___3 ->
-                failwith
-                  "Incompatible options: --extract cannot be used with --no_extract, --extract_namespace or --extract_module");
-           (let tsetting =
-              let uu___2 =
-                find_setting_for_target tgt pes.target_specific_settings in
-              match uu___2 with
-              | FStar_Pervasives_Native.Some s -> s
-              | FStar_Pervasives_Native.None ->
-                  (match pes.default_settings with
-                   | FStar_Pervasives_Native.Some s -> s
-                   | FStar_Pervasives_Native.None -> "*") in
-            module_matches_namespace_filter m1 [tsetting]))
-      | FStar_Pervasives_Native.None ->
-          let should_extract_namespace m2 =
-            let uu___1 = get_extract_namespace () in
-            match uu___1 with
-            | [] -> false
-            | ns ->
-                FStar_Compiler_Effect.op_Bar_Greater ns
-                  (FStar_Compiler_Util.for_some
-                     (fun n ->
-                        FStar_Compiler_Util.starts_with m2
-                          (FStar_String.lowercase n))) in
-          let should_extract_module m2 =
-            let uu___1 = get_extract_module () in
-            match uu___1 with
-            | [] -> false
-            | l ->
-                FStar_Compiler_Effect.op_Bar_Greater l
-                  (FStar_Compiler_Util.for_some
-                     (fun n -> (FStar_String.lowercase n) = m2)) in
-          (let uu___1 = no_extract m1 in Prims.op_Negation uu___1) &&
-            (let uu___1 =
-               let uu___2 = get_extract_namespace () in
-               let uu___3 = get_extract_module () in (uu___2, uu___3) in
-             (match uu___1 with
-              | ([], []) -> true
-              | uu___2 ->
-                  (should_extract_namespace m1) || (should_extract_module m1)))
-let (should_be_already_cached : Prims.string -> Prims.bool) =
-  fun m ->
-    let uu___ = get_already_cached () in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> false
-    | FStar_Pervasives_Native.Some already_cached_setting ->
-        module_matches_namespace_filter m already_cached_setting
-let (profile_enabled :
-  Prims.string FStar_Pervasives_Native.option -> Prims.string -> Prims.bool)
-  =
-  fun modul_opt ->
-    fun phase ->
-      match modul_opt with
-      | FStar_Pervasives_Native.None ->
-          let uu___ = get_profile_component () in
-          matches_namespace_filter_opt phase uu___
-      | FStar_Pervasives_Native.Some modul ->
-          ((let uu___ = get_profile () in
-            matches_namespace_filter_opt modul uu___) &&
-             (let uu___ = get_profile_component () in
-              matches_namespace_filter_opt phase uu___))
-            ||
-            (((timing ()) &&
-                (phase = "FStar.TypeChecker.Tc.process_one_decl"))
-               && (should_check modul))
-exception File_argument of Prims.string 
-let (uu___is_File_argument : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | File_argument uu___ -> true | uu___ -> false
-let (__proj__File_argument__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | File_argument uu___ -> uu___
-let (set_options : Prims.string -> FStar_Getopt.parse_cmdline_res) =
-  fun s ->
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             if s = ""
-             then FStar_Getopt.Success
-             else
-               (let res =
-                  FStar_Getopt.parse_string settable_specs
-                    (fun s1 ->
-                       FStar_Compiler_Effect.raise (File_argument s1);
-                       FStar_Getopt.Error "set_options with file argument") s in
-                if res = FStar_Getopt.Success
-                then set_error_flags ()
-                else res)) ()
-    with
-    | File_argument s1 ->
-        let uu___1 =
-          FStar_Compiler_Util.format1 "File %s is not a valid option" s1 in
-        FStar_Getopt.Error uu___1
-let (get_vconfig : unit -> FStar_VConfig.vconfig) =
-  fun uu___ ->
-    let vcfg =
-      let uu___1 = get_initial_fuel () in
-      let uu___2 = get_max_fuel () in
-      let uu___3 = get_initial_ifuel () in
-      let uu___4 = get_max_ifuel () in
-      let uu___5 = get_detail_errors () in
-      let uu___6 = get_detail_hint_replay () in
-      let uu___7 = get_no_smt () in
-      let uu___8 = get_quake_lo () in
-      let uu___9 = get_quake_hi () in
-      let uu___10 = get_quake_keep () in
-      let uu___11 = get_retry () in
-      let uu___12 = get_smtencoding_elim_box () in
-      let uu___13 = get_smtencoding_nl_arith_repr () in
-      let uu___14 = get_smtencoding_l_arith_repr () in
-      let uu___15 = get_smtencoding_valid_intro () in
-      let uu___16 = get_smtencoding_valid_elim () in
-      let uu___17 = get_tcnorm () in
-      let uu___18 = get_no_plugins () in
-      let uu___19 = get_no_tactics () in
-      let uu___20 = get_vcgen_optimize_bind_as_seq () in
-      let uu___21 = get_z3cliopt () in
-      let uu___22 = get_z3smtopt () in
-      let uu___23 = get_z3refresh () in
-      let uu___24 = get_z3rlimit () in
-      let uu___25 = get_z3rlimit_factor () in
-      let uu___26 = get_z3seed () in
-      let uu___27 = get_trivial_pre_for_unannotated_effectful_fns () in
-      let uu___28 = get_reuse_hint_for () in
-      {
-        FStar_VConfig.initial_fuel = uu___1;
-        FStar_VConfig.max_fuel = uu___2;
-        FStar_VConfig.initial_ifuel = uu___3;
-        FStar_VConfig.max_ifuel = uu___4;
-        FStar_VConfig.detail_errors = uu___5;
-        FStar_VConfig.detail_hint_replay = uu___6;
-        FStar_VConfig.no_smt = uu___7;
-        FStar_VConfig.quake_lo = uu___8;
-        FStar_VConfig.quake_hi = uu___9;
-        FStar_VConfig.quake_keep = uu___10;
-        FStar_VConfig.retry = uu___11;
-        FStar_VConfig.smtencoding_elim_box = uu___12;
-        FStar_VConfig.smtencoding_nl_arith_repr = uu___13;
-        FStar_VConfig.smtencoding_l_arith_repr = uu___14;
-        FStar_VConfig.smtencoding_valid_intro = uu___15;
-        FStar_VConfig.smtencoding_valid_elim = uu___16;
-        FStar_VConfig.tcnorm = uu___17;
-        FStar_VConfig.no_plugins = uu___18;
-        FStar_VConfig.no_tactics = uu___19;
-        FStar_VConfig.vcgen_optimize_bind_as_seq = uu___20;
-        FStar_VConfig.z3cliopt = uu___21;
-        FStar_VConfig.z3smtopt = uu___22;
-        FStar_VConfig.z3refresh = uu___23;
-        FStar_VConfig.z3rlimit = uu___24;
-        FStar_VConfig.z3rlimit_factor = uu___25;
-        FStar_VConfig.z3seed = uu___26;
-        FStar_VConfig.trivial_pre_for_unannotated_effectful_fns = uu___27;
-        FStar_VConfig.reuse_hint_for = uu___28
-      } in
-    vcfg
-let (set_vconfig : FStar_VConfig.vconfig -> unit) =
-  fun vcfg ->
-    let option_as tag o =
-      match o with
-      | FStar_Pervasives_Native.None -> Unset
-      | FStar_Pervasives_Native.Some s -> tag s in
-    set_option "initial_fuel" (Int (vcfg.FStar_VConfig.initial_fuel));
-    set_option "max_fuel" (Int (vcfg.FStar_VConfig.max_fuel));
-    set_option "initial_ifuel" (Int (vcfg.FStar_VConfig.initial_ifuel));
-    set_option "max_ifuel" (Int (vcfg.FStar_VConfig.max_ifuel));
-    set_option "detail_errors" (Bool (vcfg.FStar_VConfig.detail_errors));
-    set_option "detail_hint_replay"
-      (Bool (vcfg.FStar_VConfig.detail_hint_replay));
-    set_option "no_smt" (Bool (vcfg.FStar_VConfig.no_smt));
-    set_option "quake_lo" (Int (vcfg.FStar_VConfig.quake_lo));
-    set_option "quake_hi" (Int (vcfg.FStar_VConfig.quake_hi));
-    set_option "quake_keep" (Bool (vcfg.FStar_VConfig.quake_keep));
-    set_option "retry" (Bool (vcfg.FStar_VConfig.retry));
-    set_option "smtencoding.elim_box"
-      (Bool (vcfg.FStar_VConfig.smtencoding_elim_box));
-    set_option "smtencoding.nl_arith_repr"
-      (String (vcfg.FStar_VConfig.smtencoding_nl_arith_repr));
-    set_option "smtencoding.l_arith_repr"
-      (String (vcfg.FStar_VConfig.smtencoding_l_arith_repr));
-    set_option "smtencoding.valid_intro"
-      (Bool (vcfg.FStar_VConfig.smtencoding_valid_intro));
-    set_option "smtencoding.valid_elim"
-      (Bool (vcfg.FStar_VConfig.smtencoding_valid_elim));
-    set_option "tcnorm" (Bool (vcfg.FStar_VConfig.tcnorm));
-    set_option "no_plugins" (Bool (vcfg.FStar_VConfig.no_plugins));
-    set_option "no_tactics" (Bool (vcfg.FStar_VConfig.no_tactics));
-    (let uu___20 =
-       option_as (fun uu___21 -> String uu___21)
-         vcfg.FStar_VConfig.vcgen_optimize_bind_as_seq in
-     set_option "vcgen.optimize_bind_as_seq" uu___20);
-    (let uu___21 =
-       let uu___22 =
-         FStar_Compiler_List.map (fun uu___23 -> String uu___23)
-           vcfg.FStar_VConfig.z3cliopt in
-       List uu___22 in
-     set_option "z3cliopt" uu___21);
-    (let uu___22 =
-       let uu___23 =
-         FStar_Compiler_List.map (fun uu___24 -> String uu___24)
-           vcfg.FStar_VConfig.z3smtopt in
-       List uu___23 in
-     set_option "z3smtopt" uu___22);
-    set_option "z3refresh" (Bool (vcfg.FStar_VConfig.z3refresh));
-    set_option "z3rlimit" (Int (vcfg.FStar_VConfig.z3rlimit));
-    set_option "z3rlimit_factor" (Int (vcfg.FStar_VConfig.z3rlimit_factor));
-    set_option "z3seed" (Int (vcfg.FStar_VConfig.z3seed));
-    set_option "trivial_pre_for_unannotated_effectful_fns"
-      (Bool (vcfg.FStar_VConfig.trivial_pre_for_unannotated_effectful_fns));
-    (let uu___28 =
-       option_as (fun uu___29 -> String uu___29)
-         vcfg.FStar_VConfig.reuse_hint_for in
-     set_option "reuse_hint_for" uu___28)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Order.ml b/src/ocaml-output/FStar_Order.ml
deleted file mode 100644
index 72491a1f813..00000000000
--- a/src/ocaml-output/FStar_Order.ml
+++ /dev/null
@@ -1,58 +0,0 @@
-open Prims
-type order =
-  | Lt 
-  | Eq 
-  | Gt 
-let (uu___is_Lt : order -> Prims.bool) =
-  fun projectee -> match projectee with | Lt -> true | uu___ -> false
-let (uu___is_Eq : order -> Prims.bool) =
-  fun projectee -> match projectee with | Eq -> true | uu___ -> false
-let (uu___is_Gt : order -> Prims.bool) =
-  fun projectee -> match projectee with | Gt -> true | uu___ -> false
-let (ge : order -> Prims.bool) = fun o -> o <> Lt
-let (le : order -> Prims.bool) = fun o -> o <> Gt
-let (ne : order -> Prims.bool) = fun o -> o <> Eq
-let (gt : order -> Prims.bool) = fun o -> o = Gt
-let (lt : order -> Prims.bool) = fun o -> o = Lt
-let (eq : order -> Prims.bool) = fun o -> o = Eq
-let (lex : order -> (unit -> order) -> order) =
-  fun o1 ->
-    fun o2 ->
-      match (o1, o2) with
-      | (Lt, uu___) -> Lt
-      | (Eq, uu___) -> o2 ()
-      | (Gt, uu___) -> Gt
-let (order_from_int : Prims.int -> order) =
-  fun i ->
-    if i < Prims.int_zero then Lt else if i = Prims.int_zero then Eq else Gt
-let (compare_int : Prims.int -> Prims.int -> order) =
-  fun i -> fun j -> order_from_int (i - j)
-let rec compare_list :
-  'a . 'a Prims.list -> 'a Prims.list -> ('a -> 'a -> order) -> order =
-  fun l1 ->
-    fun l2 ->
-      fun f ->
-        match (l1, l2) with
-        | ([], []) -> Eq
-        | ([], uu___) -> Lt
-        | (uu___, []) -> Gt
-        | (x::xs, y::ys) ->
-            let uu___ = f x y in
-            lex uu___ (fun uu___1 -> compare_list xs ys f)
-let compare_option :
-  'a .
-    ('a -> 'a -> order) ->
-      'a FStar_Pervasives_Native.option ->
-        'a FStar_Pervasives_Native.option -> order
-  =
-  fun f ->
-    fun x ->
-      fun y ->
-        match (x, y) with
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) -> Eq
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some uu___)
-            -> Lt
-        | (FStar_Pervasives_Native.Some uu___, FStar_Pervasives_Native.None)
-            -> Gt
-        | (FStar_Pervasives_Native.Some x1, FStar_Pervasives_Native.Some y1)
-            -> f x1 y1
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Parser_AST.ml b/src/ocaml-output/FStar_Parser_AST.ml
deleted file mode 100644
index b1b69b15d9a..00000000000
--- a/src/ocaml-output/FStar_Parser_AST.ml
+++ /dev/null
@@ -1,2423 +0,0 @@
-open Prims
-type level =
-  | Un 
-  | Expr 
-  | Type_level 
-  | Kind 
-  | Formula 
-let (uu___is_Un : level -> Prims.bool) =
-  fun projectee -> match projectee with | Un -> true | uu___ -> false
-let (uu___is_Expr : level -> Prims.bool) =
-  fun projectee -> match projectee with | Expr -> true | uu___ -> false
-let (uu___is_Type_level : level -> Prims.bool) =
-  fun projectee -> match projectee with | Type_level -> true | uu___ -> false
-let (uu___is_Kind : level -> Prims.bool) =
-  fun projectee -> match projectee with | Kind -> true | uu___ -> false
-let (uu___is_Formula : level -> Prims.bool) =
-  fun projectee -> match projectee with | Formula -> true | uu___ -> false
-type let_qualifier =
-  | NoLetQualifier 
-  | Rec 
-let (uu___is_NoLetQualifier : let_qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NoLetQualifier -> true | uu___ -> false
-let (uu___is_Rec : let_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Rec -> true | uu___ -> false
-type quote_kind =
-  | Static 
-  | Dynamic 
-let (uu___is_Static : quote_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Static -> true | uu___ -> false
-let (uu___is_Dynamic : quote_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Dynamic -> true | uu___ -> false
-type term' =
-  | Wild 
-  | Const of FStar_Const.sconst 
-  | Op of (FStar_Ident.ident * term Prims.list) 
-  | Tvar of FStar_Ident.ident 
-  | Uvar of FStar_Ident.ident 
-  | Var of FStar_Ident.lid 
-  | Name of FStar_Ident.lid 
-  | Projector of (FStar_Ident.lid * FStar_Ident.ident) 
-  | Construct of (FStar_Ident.lid * (term * imp) Prims.list) 
-  | Abs of (pattern Prims.list * term) 
-  | App of (term * term * imp) 
-  | Let of (let_qualifier * (term Prims.list FStar_Pervasives_Native.option *
-  (pattern * term)) Prims.list * term) 
-  | LetOperator of ((FStar_Ident.ident * pattern * term) Prims.list * term) 
-  | LetOpen of (FStar_Ident.lid * term) 
-  | LetOpenRecord of (term * term * term) 
-  | Seq of (term * term) 
-  | Bind of (FStar_Ident.ident * term * term) 
-  | If of (term * FStar_Ident.ident FStar_Pervasives_Native.option *
-  (FStar_Ident.ident FStar_Pervasives_Native.option * term * Prims.bool)
-  FStar_Pervasives_Native.option * term * term) 
-  | Match of (term * FStar_Ident.ident FStar_Pervasives_Native.option *
-  (FStar_Ident.ident FStar_Pervasives_Native.option * term * Prims.bool)
-  FStar_Pervasives_Native.option * (pattern * term
-  FStar_Pervasives_Native.option * term) Prims.list) 
-  | TryWith of (term * (pattern * term FStar_Pervasives_Native.option * term)
-  Prims.list) 
-  | Ascribed of (term * term * term FStar_Pervasives_Native.option *
-  Prims.bool) 
-  | Record of (term FStar_Pervasives_Native.option * (FStar_Ident.lid * term)
-  Prims.list) 
-  | Project of (term * FStar_Ident.lid) 
-  | Product of (binder Prims.list * term) 
-  | Sum of ((binder, term) FStar_Pervasives.either Prims.list * term) 
-  | QForall of (binder Prims.list * (FStar_Ident.ident Prims.list * term
-  Prims.list Prims.list) * term) 
-  | QExists of (binder Prims.list * (FStar_Ident.ident Prims.list * term
-  Prims.list Prims.list) * term) 
-  | Refine of (binder * term) 
-  | NamedTyp of (FStar_Ident.ident * term) 
-  | Paren of term 
-  | Requires of (term * Prims.string FStar_Pervasives_Native.option) 
-  | Ensures of (term * Prims.string FStar_Pervasives_Native.option) 
-  | LexList of term Prims.list 
-  | WFOrder of (term * term) 
-  | Decreases of (term * Prims.string FStar_Pervasives_Native.option) 
-  | Labeled of (term * Prims.string * Prims.bool) 
-  | Discrim of FStar_Ident.lid 
-  | Attributes of term Prims.list 
-  | Antiquote of term 
-  | Quote of (term * quote_kind) 
-  | VQuote of term 
-  | CalcProof of (term * term * calc_step Prims.list) 
-  | IntroForall of (binder Prims.list * term * term) 
-  | IntroExists of (binder Prims.list * term * term Prims.list * term) 
-  | IntroImplies of (term * term * binder * term) 
-  | IntroOr of (Prims.bool * term * term * term) 
-  | IntroAnd of (term * term * term * term) 
-  | ElimForall of (binder Prims.list * term * term Prims.list) 
-  | ElimExists of (binder Prims.list * term * term * binder * term) 
-  | ElimImplies of (term * term * term) 
-  | ElimOr of (term * term * term * binder * term * binder * term) 
-  | ElimAnd of (term * term * term * binder * binder * term) 
-and term = {
-  tm: term' ;
-  range: FStar_Compiler_Range.range ;
-  level: level }
-and calc_step =
-  | CalcStep of (term * term * term) 
-and binder' =
-  | Variable of FStar_Ident.ident 
-  | TVariable of FStar_Ident.ident 
-  | Annotated of (FStar_Ident.ident * term) 
-  | TAnnotated of (FStar_Ident.ident * term) 
-  | NoName of term 
-and binder =
-  {
-  b: binder' ;
-  brange: FStar_Compiler_Range.range ;
-  blevel: level ;
-  aqual: arg_qualifier FStar_Pervasives_Native.option ;
-  battributes: term Prims.list }
-and pattern' =
-  | PatWild of (arg_qualifier FStar_Pervasives_Native.option * term
-  Prims.list) 
-  | PatConst of FStar_Const.sconst 
-  | PatApp of (pattern * pattern Prims.list) 
-  | PatVar of (FStar_Ident.ident * arg_qualifier
-  FStar_Pervasives_Native.option * term Prims.list) 
-  | PatName of FStar_Ident.lid 
-  | PatTvar of (FStar_Ident.ident * arg_qualifier
-  FStar_Pervasives_Native.option * term Prims.list) 
-  | PatList of pattern Prims.list 
-  | PatTuple of (pattern Prims.list * Prims.bool) 
-  | PatRecord of (FStar_Ident.lid * pattern) Prims.list 
-  | PatAscribed of (pattern * (term * term FStar_Pervasives_Native.option)) 
-  | PatOr of pattern Prims.list 
-  | PatOp of FStar_Ident.ident 
-  | PatVQuote of term 
-and pattern = {
-  pat: pattern' ;
-  prange: FStar_Compiler_Range.range }
-and arg_qualifier =
-  | Implicit 
-  | Equality 
-  | Meta of term 
-  | TypeClassArg 
-and imp =
-  | FsTypApp 
-  | Hash 
-  | UnivApp 
-  | HashBrace of term 
-  | Infix 
-  | Nothing 
-let (uu___is_Wild : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Wild -> true | uu___ -> false
-let (uu___is_Const : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Const _0 -> true | uu___ -> false
-let (__proj__Const__item___0 : term' -> FStar_Const.sconst) =
-  fun projectee -> match projectee with | Const _0 -> _0
-let (uu___is_Op : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Op _0 -> true | uu___ -> false
-let (__proj__Op__item___0 : term' -> (FStar_Ident.ident * term Prims.list)) =
-  fun projectee -> match projectee with | Op _0 -> _0
-let (uu___is_Tvar : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tvar _0 -> true | uu___ -> false
-let (__proj__Tvar__item___0 : term' -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | Tvar _0 -> _0
-let (uu___is_Uvar : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Uvar _0 -> true | uu___ -> false
-let (__proj__Uvar__item___0 : term' -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | Uvar _0 -> _0
-let (uu___is_Var : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Var _0 -> true | uu___ -> false
-let (__proj__Var__item___0 : term' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Var _0 -> _0
-let (uu___is_Name : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Name _0 -> true | uu___ -> false
-let (__proj__Name__item___0 : term' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Name _0 -> _0
-let (uu___is_Projector : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Projector _0 -> true | uu___ -> false
-let (__proj__Projector__item___0 :
-  term' -> (FStar_Ident.lid * FStar_Ident.ident)) =
-  fun projectee -> match projectee with | Projector _0 -> _0
-let (uu___is_Construct : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Construct _0 -> true | uu___ -> false
-let (__proj__Construct__item___0 :
-  term' -> (FStar_Ident.lid * (term * imp) Prims.list)) =
-  fun projectee -> match projectee with | Construct _0 -> _0
-let (uu___is_Abs : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Abs _0 -> true | uu___ -> false
-let (__proj__Abs__item___0 : term' -> (pattern Prims.list * term)) =
-  fun projectee -> match projectee with | Abs _0 -> _0
-let (uu___is_App : term' -> Prims.bool) =
-  fun projectee -> match projectee with | App _0 -> true | uu___ -> false
-let (__proj__App__item___0 : term' -> (term * term * imp)) =
-  fun projectee -> match projectee with | App _0 -> _0
-let (uu___is_Let : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Let _0 -> true | uu___ -> false
-let (__proj__Let__item___0 :
-  term' ->
-    (let_qualifier * (term Prims.list FStar_Pervasives_Native.option *
-      (pattern * term)) Prims.list * term))
-  = fun projectee -> match projectee with | Let _0 -> _0
-let (uu___is_LetOperator : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LetOperator _0 -> true | uu___ -> false
-let (__proj__LetOperator__item___0 :
-  term' -> ((FStar_Ident.ident * pattern * term) Prims.list * term)) =
-  fun projectee -> match projectee with | LetOperator _0 -> _0
-let (uu___is_LetOpen : term' -> Prims.bool) =
-  fun projectee -> match projectee with | LetOpen _0 -> true | uu___ -> false
-let (__proj__LetOpen__item___0 : term' -> (FStar_Ident.lid * term)) =
-  fun projectee -> match projectee with | LetOpen _0 -> _0
-let (uu___is_LetOpenRecord : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LetOpenRecord _0 -> true | uu___ -> false
-let (__proj__LetOpenRecord__item___0 : term' -> (term * term * term)) =
-  fun projectee -> match projectee with | LetOpenRecord _0 -> _0
-let (uu___is_Seq : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Seq _0 -> true | uu___ -> false
-let (__proj__Seq__item___0 : term' -> (term * term)) =
-  fun projectee -> match projectee with | Seq _0 -> _0
-let (uu___is_Bind : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Bind _0 -> true | uu___ -> false
-let (__proj__Bind__item___0 : term' -> (FStar_Ident.ident * term * term)) =
-  fun projectee -> match projectee with | Bind _0 -> _0
-let (uu___is_If : term' -> Prims.bool) =
-  fun projectee -> match projectee with | If _0 -> true | uu___ -> false
-let (__proj__If__item___0 :
-  term' ->
-    (term * FStar_Ident.ident FStar_Pervasives_Native.option *
-      (FStar_Ident.ident FStar_Pervasives_Native.option * term * Prims.bool)
-      FStar_Pervasives_Native.option * term * term))
-  = fun projectee -> match projectee with | If _0 -> _0
-let (uu___is_Match : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Match _0 -> true | uu___ -> false
-let (__proj__Match__item___0 :
-  term' ->
-    (term * FStar_Ident.ident FStar_Pervasives_Native.option *
-      (FStar_Ident.ident FStar_Pervasives_Native.option * term * Prims.bool)
-      FStar_Pervasives_Native.option * (pattern * term
-      FStar_Pervasives_Native.option * term) Prims.list))
-  = fun projectee -> match projectee with | Match _0 -> _0
-let (uu___is_TryWith : term' -> Prims.bool) =
-  fun projectee -> match projectee with | TryWith _0 -> true | uu___ -> false
-let (__proj__TryWith__item___0 :
-  term' ->
-    (term * (pattern * term FStar_Pervasives_Native.option * term)
-      Prims.list))
-  = fun projectee -> match projectee with | TryWith _0 -> _0
-let (uu___is_Ascribed : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Ascribed _0 -> true | uu___ -> false
-let (__proj__Ascribed__item___0 :
-  term' -> (term * term * term FStar_Pervasives_Native.option * Prims.bool))
-  = fun projectee -> match projectee with | Ascribed _0 -> _0
-let (uu___is_Record : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Record _0 -> true | uu___ -> false
-let (__proj__Record__item___0 :
-  term' ->
-    (term FStar_Pervasives_Native.option * (FStar_Ident.lid * term)
-      Prims.list))
-  = fun projectee -> match projectee with | Record _0 -> _0
-let (uu___is_Project : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Project _0 -> true | uu___ -> false
-let (__proj__Project__item___0 : term' -> (term * FStar_Ident.lid)) =
-  fun projectee -> match projectee with | Project _0 -> _0
-let (uu___is_Product : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Product _0 -> true | uu___ -> false
-let (__proj__Product__item___0 : term' -> (binder Prims.list * term)) =
-  fun projectee -> match projectee with | Product _0 -> _0
-let (uu___is_Sum : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Sum _0 -> true | uu___ -> false
-let (__proj__Sum__item___0 :
-  term' -> ((binder, term) FStar_Pervasives.either Prims.list * term)) =
-  fun projectee -> match projectee with | Sum _0 -> _0
-let (uu___is_QForall : term' -> Prims.bool) =
-  fun projectee -> match projectee with | QForall _0 -> true | uu___ -> false
-let (__proj__QForall__item___0 :
-  term' ->
-    (binder Prims.list * (FStar_Ident.ident Prims.list * term Prims.list
-      Prims.list) * term))
-  = fun projectee -> match projectee with | QForall _0 -> _0
-let (uu___is_QExists : term' -> Prims.bool) =
-  fun projectee -> match projectee with | QExists _0 -> true | uu___ -> false
-let (__proj__QExists__item___0 :
-  term' ->
-    (binder Prims.list * (FStar_Ident.ident Prims.list * term Prims.list
-      Prims.list) * term))
-  = fun projectee -> match projectee with | QExists _0 -> _0
-let (uu___is_Refine : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Refine _0 -> true | uu___ -> false
-let (__proj__Refine__item___0 : term' -> (binder * term)) =
-  fun projectee -> match projectee with | Refine _0 -> _0
-let (uu___is_NamedTyp : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NamedTyp _0 -> true | uu___ -> false
-let (__proj__NamedTyp__item___0 : term' -> (FStar_Ident.ident * term)) =
-  fun projectee -> match projectee with | NamedTyp _0 -> _0
-let (uu___is_Paren : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Paren _0 -> true | uu___ -> false
-let (__proj__Paren__item___0 : term' -> term) =
-  fun projectee -> match projectee with | Paren _0 -> _0
-let (uu___is_Requires : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Requires _0 -> true | uu___ -> false
-let (__proj__Requires__item___0 :
-  term' -> (term * Prims.string FStar_Pervasives_Native.option)) =
-  fun projectee -> match projectee with | Requires _0 -> _0
-let (uu___is_Ensures : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Ensures _0 -> true | uu___ -> false
-let (__proj__Ensures__item___0 :
-  term' -> (term * Prims.string FStar_Pervasives_Native.option)) =
-  fun projectee -> match projectee with | Ensures _0 -> _0
-let (uu___is_LexList : term' -> Prims.bool) =
-  fun projectee -> match projectee with | LexList _0 -> true | uu___ -> false
-let (__proj__LexList__item___0 : term' -> term Prims.list) =
-  fun projectee -> match projectee with | LexList _0 -> _0
-let (uu___is_WFOrder : term' -> Prims.bool) =
-  fun projectee -> match projectee with | WFOrder _0 -> true | uu___ -> false
-let (__proj__WFOrder__item___0 : term' -> (term * term)) =
-  fun projectee -> match projectee with | WFOrder _0 -> _0
-let (uu___is_Decreases : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Decreases _0 -> true | uu___ -> false
-let (__proj__Decreases__item___0 :
-  term' -> (term * Prims.string FStar_Pervasives_Native.option)) =
-  fun projectee -> match projectee with | Decreases _0 -> _0
-let (uu___is_Labeled : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Labeled _0 -> true | uu___ -> false
-let (__proj__Labeled__item___0 : term' -> (term * Prims.string * Prims.bool))
-  = fun projectee -> match projectee with | Labeled _0 -> _0
-let (uu___is_Discrim : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Discrim _0 -> true | uu___ -> false
-let (__proj__Discrim__item___0 : term' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Discrim _0 -> _0
-let (uu___is_Attributes : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Attributes _0 -> true | uu___ -> false
-let (__proj__Attributes__item___0 : term' -> term Prims.list) =
-  fun projectee -> match projectee with | Attributes _0 -> _0
-let (uu___is_Antiquote : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Antiquote _0 -> true | uu___ -> false
-let (__proj__Antiquote__item___0 : term' -> term) =
-  fun projectee -> match projectee with | Antiquote _0 -> _0
-let (uu___is_Quote : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Quote _0 -> true | uu___ -> false
-let (__proj__Quote__item___0 : term' -> (term * quote_kind)) =
-  fun projectee -> match projectee with | Quote _0 -> _0
-let (uu___is_VQuote : term' -> Prims.bool) =
-  fun projectee -> match projectee with | VQuote _0 -> true | uu___ -> false
-let (__proj__VQuote__item___0 : term' -> term) =
-  fun projectee -> match projectee with | VQuote _0 -> _0
-let (uu___is_CalcProof : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CalcProof _0 -> true | uu___ -> false
-let (__proj__CalcProof__item___0 :
-  term' -> (term * term * calc_step Prims.list)) =
-  fun projectee -> match projectee with | CalcProof _0 -> _0
-let (uu___is_IntroForall : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | IntroForall _0 -> true | uu___ -> false
-let (__proj__IntroForall__item___0 :
-  term' -> (binder Prims.list * term * term)) =
-  fun projectee -> match projectee with | IntroForall _0 -> _0
-let (uu___is_IntroExists : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | IntroExists _0 -> true | uu___ -> false
-let (__proj__IntroExists__item___0 :
-  term' -> (binder Prims.list * term * term Prims.list * term)) =
-  fun projectee -> match projectee with | IntroExists _0 -> _0
-let (uu___is_IntroImplies : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | IntroImplies _0 -> true | uu___ -> false
-let (__proj__IntroImplies__item___0 : term' -> (term * term * binder * term))
-  = fun projectee -> match projectee with | IntroImplies _0 -> _0
-let (uu___is_IntroOr : term' -> Prims.bool) =
-  fun projectee -> match projectee with | IntroOr _0 -> true | uu___ -> false
-let (__proj__IntroOr__item___0 : term' -> (Prims.bool * term * term * term))
-  = fun projectee -> match projectee with | IntroOr _0 -> _0
-let (uu___is_IntroAnd : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | IntroAnd _0 -> true | uu___ -> false
-let (__proj__IntroAnd__item___0 : term' -> (term * term * term * term)) =
-  fun projectee -> match projectee with | IntroAnd _0 -> _0
-let (uu___is_ElimForall : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ElimForall _0 -> true | uu___ -> false
-let (__proj__ElimForall__item___0 :
-  term' -> (binder Prims.list * term * term Prims.list)) =
-  fun projectee -> match projectee with | ElimForall _0 -> _0
-let (uu___is_ElimExists : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ElimExists _0 -> true | uu___ -> false
-let (__proj__ElimExists__item___0 :
-  term' -> (binder Prims.list * term * term * binder * term)) =
-  fun projectee -> match projectee with | ElimExists _0 -> _0
-let (uu___is_ElimImplies : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ElimImplies _0 -> true | uu___ -> false
-let (__proj__ElimImplies__item___0 : term' -> (term * term * term)) =
-  fun projectee -> match projectee with | ElimImplies _0 -> _0
-let (uu___is_ElimOr : term' -> Prims.bool) =
-  fun projectee -> match projectee with | ElimOr _0 -> true | uu___ -> false
-let (__proj__ElimOr__item___0 :
-  term' -> (term * term * term * binder * term * binder * term)) =
-  fun projectee -> match projectee with | ElimOr _0 -> _0
-let (uu___is_ElimAnd : term' -> Prims.bool) =
-  fun projectee -> match projectee with | ElimAnd _0 -> true | uu___ -> false
-let (__proj__ElimAnd__item___0 :
-  term' -> (term * term * term * binder * binder * term)) =
-  fun projectee -> match projectee with | ElimAnd _0 -> _0
-let (__proj__Mkterm__item__tm : term -> term') =
-  fun projectee ->
-    match projectee with | { tm; range; level = level1;_} -> tm
-let (__proj__Mkterm__item__range : term -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with | { tm; range; level = level1;_} -> range
-let (__proj__Mkterm__item__level : term -> level) =
-  fun projectee ->
-    match projectee with | { tm; range; level = level1;_} -> level1
-let (uu___is_CalcStep : calc_step -> Prims.bool) = fun projectee -> true
-let (__proj__CalcStep__item___0 : calc_step -> (term * term * term)) =
-  fun projectee -> match projectee with | CalcStep _0 -> _0
-let (uu___is_Variable : binder' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Variable _0 -> true | uu___ -> false
-let (__proj__Variable__item___0 : binder' -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | Variable _0 -> _0
-let (uu___is_TVariable : binder' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TVariable _0 -> true | uu___ -> false
-let (__proj__TVariable__item___0 : binder' -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | TVariable _0 -> _0
-let (uu___is_Annotated : binder' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Annotated _0 -> true | uu___ -> false
-let (__proj__Annotated__item___0 : binder' -> (FStar_Ident.ident * term)) =
-  fun projectee -> match projectee with | Annotated _0 -> _0
-let (uu___is_TAnnotated : binder' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TAnnotated _0 -> true | uu___ -> false
-let (__proj__TAnnotated__item___0 : binder' -> (FStar_Ident.ident * term)) =
-  fun projectee -> match projectee with | TAnnotated _0 -> _0
-let (uu___is_NoName : binder' -> Prims.bool) =
-  fun projectee -> match projectee with | NoName _0 -> true | uu___ -> false
-let (__proj__NoName__item___0 : binder' -> term) =
-  fun projectee -> match projectee with | NoName _0 -> _0
-let (__proj__Mkbinder__item__b : binder -> binder') =
-  fun projectee ->
-    match projectee with | { b; brange; blevel; aqual; battributes;_} -> b
-let (__proj__Mkbinder__item__brange : binder -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { b; brange; blevel; aqual; battributes;_} -> brange
-let (__proj__Mkbinder__item__blevel : binder -> level) =
-  fun projectee ->
-    match projectee with
-    | { b; brange; blevel; aqual; battributes;_} -> blevel
-let (__proj__Mkbinder__item__aqual :
-  binder -> arg_qualifier FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { b; brange; blevel; aqual; battributes;_} -> aqual
-let (__proj__Mkbinder__item__battributes : binder -> term Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { b; brange; blevel; aqual; battributes;_} -> battributes
-let (uu___is_PatWild : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatWild _0 -> true | uu___ -> false
-let (__proj__PatWild__item___0 :
-  pattern' ->
-    (arg_qualifier FStar_Pervasives_Native.option * term Prims.list))
-  = fun projectee -> match projectee with | PatWild _0 -> _0
-let (uu___is_PatConst : pattern' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PatConst _0 -> true | uu___ -> false
-let (__proj__PatConst__item___0 : pattern' -> FStar_Const.sconst) =
-  fun projectee -> match projectee with | PatConst _0 -> _0
-let (uu___is_PatApp : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatApp _0 -> true | uu___ -> false
-let (__proj__PatApp__item___0 : pattern' -> (pattern * pattern Prims.list)) =
-  fun projectee -> match projectee with | PatApp _0 -> _0
-let (uu___is_PatVar : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatVar _0 -> true | uu___ -> false
-let (__proj__PatVar__item___0 :
-  pattern' ->
-    (FStar_Ident.ident * arg_qualifier FStar_Pervasives_Native.option * term
-      Prims.list))
-  = fun projectee -> match projectee with | PatVar _0 -> _0
-let (uu___is_PatName : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatName _0 -> true | uu___ -> false
-let (__proj__PatName__item___0 : pattern' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | PatName _0 -> _0
-let (uu___is_PatTvar : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatTvar _0 -> true | uu___ -> false
-let (__proj__PatTvar__item___0 :
-  pattern' ->
-    (FStar_Ident.ident * arg_qualifier FStar_Pervasives_Native.option * term
-      Prims.list))
-  = fun projectee -> match projectee with | PatTvar _0 -> _0
-let (uu___is_PatList : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatList _0 -> true | uu___ -> false
-let (__proj__PatList__item___0 : pattern' -> pattern Prims.list) =
-  fun projectee -> match projectee with | PatList _0 -> _0
-let (uu___is_PatTuple : pattern' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PatTuple _0 -> true | uu___ -> false
-let (__proj__PatTuple__item___0 :
-  pattern' -> (pattern Prims.list * Prims.bool)) =
-  fun projectee -> match projectee with | PatTuple _0 -> _0
-let (uu___is_PatRecord : pattern' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PatRecord _0 -> true | uu___ -> false
-let (__proj__PatRecord__item___0 :
-  pattern' -> (FStar_Ident.lid * pattern) Prims.list) =
-  fun projectee -> match projectee with | PatRecord _0 -> _0
-let (uu___is_PatAscribed : pattern' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PatAscribed _0 -> true | uu___ -> false
-let (__proj__PatAscribed__item___0 :
-  pattern' -> (pattern * (term * term FStar_Pervasives_Native.option))) =
-  fun projectee -> match projectee with | PatAscribed _0 -> _0
-let (uu___is_PatOr : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatOr _0 -> true | uu___ -> false
-let (__proj__PatOr__item___0 : pattern' -> pattern Prims.list) =
-  fun projectee -> match projectee with | PatOr _0 -> _0
-let (uu___is_PatOp : pattern' -> Prims.bool) =
-  fun projectee -> match projectee with | PatOp _0 -> true | uu___ -> false
-let (__proj__PatOp__item___0 : pattern' -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | PatOp _0 -> _0
-let (uu___is_PatVQuote : pattern' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PatVQuote _0 -> true | uu___ -> false
-let (__proj__PatVQuote__item___0 : pattern' -> term) =
-  fun projectee -> match projectee with | PatVQuote _0 -> _0
-let (__proj__Mkpattern__item__pat : pattern -> pattern') =
-  fun projectee -> match projectee with | { pat; prange;_} -> pat
-let (__proj__Mkpattern__item__prange : pattern -> FStar_Compiler_Range.range)
-  = fun projectee -> match projectee with | { pat; prange;_} -> prange
-let (uu___is_Implicit : arg_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Implicit -> true | uu___ -> false
-let (uu___is_Equality : arg_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Equality -> true | uu___ -> false
-let (uu___is_Meta : arg_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Meta _0 -> true | uu___ -> false
-let (__proj__Meta__item___0 : arg_qualifier -> term) =
-  fun projectee -> match projectee with | Meta _0 -> _0
-let (uu___is_TypeClassArg : arg_qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TypeClassArg -> true | uu___ -> false
-let (uu___is_FsTypApp : imp -> Prims.bool) =
-  fun projectee -> match projectee with | FsTypApp -> true | uu___ -> false
-let (uu___is_Hash : imp -> Prims.bool) =
-  fun projectee -> match projectee with | Hash -> true | uu___ -> false
-let (uu___is_UnivApp : imp -> Prims.bool) =
-  fun projectee -> match projectee with | UnivApp -> true | uu___ -> false
-let (uu___is_HashBrace : imp -> Prims.bool) =
-  fun projectee ->
-    match projectee with | HashBrace _0 -> true | uu___ -> false
-let (__proj__HashBrace__item___0 : imp -> term) =
-  fun projectee -> match projectee with | HashBrace _0 -> _0
-let (uu___is_Infix : imp -> Prims.bool) =
-  fun projectee -> match projectee with | Infix -> true | uu___ -> false
-let (uu___is_Nothing : imp -> Prims.bool) =
-  fun projectee -> match projectee with | Nothing -> true | uu___ -> false
-type match_returns_annotation =
-  (FStar_Ident.ident FStar_Pervasives_Native.option * term * Prims.bool)
-type patterns = (FStar_Ident.ident Prims.list * term Prims.list Prims.list)
-type attributes_ = term Prims.list
-type branch = (pattern * term FStar_Pervasives_Native.option * term)
-type aqual = arg_qualifier FStar_Pervasives_Native.option
-type knd = term
-type typ = term
-type expr = term
-type tycon_record =
-  (FStar_Ident.ident * aqual * attributes_ * term) Prims.list
-type constructor_payload =
-  | VpOfNotation of typ 
-  | VpArbitrary of typ 
-  | VpRecord of (tycon_record * typ FStar_Pervasives_Native.option) 
-let (uu___is_VpOfNotation : constructor_payload -> Prims.bool) =
-  fun projectee ->
-    match projectee with | VpOfNotation _0 -> true | uu___ -> false
-let (__proj__VpOfNotation__item___0 : constructor_payload -> typ) =
-  fun projectee -> match projectee with | VpOfNotation _0 -> _0
-let (uu___is_VpArbitrary : constructor_payload -> Prims.bool) =
-  fun projectee ->
-    match projectee with | VpArbitrary _0 -> true | uu___ -> false
-let (__proj__VpArbitrary__item___0 : constructor_payload -> typ) =
-  fun projectee -> match projectee with | VpArbitrary _0 -> _0
-let (uu___is_VpRecord : constructor_payload -> Prims.bool) =
-  fun projectee ->
-    match projectee with | VpRecord _0 -> true | uu___ -> false
-let (__proj__VpRecord__item___0 :
-  constructor_payload -> (tycon_record * typ FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | VpRecord _0 -> _0
-type tycon =
-  | TyconAbstract of (FStar_Ident.ident * binder Prims.list * knd
-  FStar_Pervasives_Native.option) 
-  | TyconAbbrev of (FStar_Ident.ident * binder Prims.list * knd
-  FStar_Pervasives_Native.option * term) 
-  | TyconRecord of (FStar_Ident.ident * binder Prims.list * knd
-  FStar_Pervasives_Native.option * attributes_ * tycon_record) 
-  | TyconVariant of (FStar_Ident.ident * binder Prims.list * knd
-  FStar_Pervasives_Native.option * (FStar_Ident.ident * constructor_payload
-  FStar_Pervasives_Native.option * attributes_) Prims.list) 
-let (uu___is_TyconAbstract : tycon -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TyconAbstract _0 -> true | uu___ -> false
-let (__proj__TyconAbstract__item___0 :
-  tycon ->
-    (FStar_Ident.ident * binder Prims.list * knd
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | TyconAbstract _0 -> _0
-let (uu___is_TyconAbbrev : tycon -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TyconAbbrev _0 -> true | uu___ -> false
-let (__proj__TyconAbbrev__item___0 :
-  tycon ->
-    (FStar_Ident.ident * binder Prims.list * knd
-      FStar_Pervasives_Native.option * term))
-  = fun projectee -> match projectee with | TyconAbbrev _0 -> _0
-let (uu___is_TyconRecord : tycon -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TyconRecord _0 -> true | uu___ -> false
-let (__proj__TyconRecord__item___0 :
-  tycon ->
-    (FStar_Ident.ident * binder Prims.list * knd
-      FStar_Pervasives_Native.option * attributes_ * tycon_record))
-  = fun projectee -> match projectee with | TyconRecord _0 -> _0
-let (uu___is_TyconVariant : tycon -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TyconVariant _0 -> true | uu___ -> false
-let (__proj__TyconVariant__item___0 :
-  tycon ->
-    (FStar_Ident.ident * binder Prims.list * knd
-      FStar_Pervasives_Native.option * (FStar_Ident.ident *
-      constructor_payload FStar_Pervasives_Native.option * attributes_)
-      Prims.list))
-  = fun projectee -> match projectee with | TyconVariant _0 -> _0
-type qualifier =
-  | Private 
-  | Noeq 
-  | Unopteq 
-  | Assumption 
-  | DefaultEffect 
-  | TotalEffect 
-  | Effect_qual 
-  | New 
-  | Inline 
-  | Visible 
-  | Unfold_for_unification_and_vcgen 
-  | Inline_for_extraction 
-  | Irreducible 
-  | NoExtract 
-  | Reifiable 
-  | Reflectable 
-  | Opaque 
-  | Logic 
-let (uu___is_Private : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Private -> true | uu___ -> false
-let (uu___is_Noeq : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Noeq -> true | uu___ -> false
-let (uu___is_Unopteq : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Unopteq -> true | uu___ -> false
-let (uu___is_Assumption : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Assumption -> true | uu___ -> false
-let (uu___is_DefaultEffect : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DefaultEffect -> true | uu___ -> false
-let (uu___is_TotalEffect : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TotalEffect -> true | uu___ -> false
-let (uu___is_Effect_qual : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Effect_qual -> true | uu___ -> false
-let (uu___is_New : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | New -> true | uu___ -> false
-let (uu___is_Inline : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Inline -> true | uu___ -> false
-let (uu___is_Visible : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Visible -> true | uu___ -> false
-let (uu___is_Unfold_for_unification_and_vcgen : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Unfold_for_unification_and_vcgen -> true
-    | uu___ -> false
-let (uu___is_Inline_for_extraction : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Inline_for_extraction -> true | uu___ -> false
-let (uu___is_Irreducible : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Irreducible -> true | uu___ -> false
-let (uu___is_NoExtract : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | NoExtract -> true | uu___ -> false
-let (uu___is_Reifiable : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Reifiable -> true | uu___ -> false
-let (uu___is_Reflectable : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Reflectable -> true | uu___ -> false
-let (uu___is_Opaque : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Opaque -> true | uu___ -> false
-let (uu___is_Logic : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Logic -> true | uu___ -> false
-type qualifiers = qualifier Prims.list
-type decoration =
-  | Qualifier of qualifier 
-  | DeclAttributes of term Prims.list 
-let (uu___is_Qualifier : decoration -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Qualifier _0 -> true | uu___ -> false
-let (__proj__Qualifier__item___0 : decoration -> qualifier) =
-  fun projectee -> match projectee with | Qualifier _0 -> _0
-let (uu___is_DeclAttributes : decoration -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DeclAttributes _0 -> true | uu___ -> false
-let (__proj__DeclAttributes__item___0 : decoration -> term Prims.list) =
-  fun projectee -> match projectee with | DeclAttributes _0 -> _0
-type lift_op =
-  | NonReifiableLift of term 
-  | ReifiableLift of (term * term) 
-  | LiftForFree of term 
-let (uu___is_NonReifiableLift : lift_op -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NonReifiableLift _0 -> true | uu___ -> false
-let (__proj__NonReifiableLift__item___0 : lift_op -> term) =
-  fun projectee -> match projectee with | NonReifiableLift _0 -> _0
-let (uu___is_ReifiableLift : lift_op -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ReifiableLift _0 -> true | uu___ -> false
-let (__proj__ReifiableLift__item___0 : lift_op -> (term * term)) =
-  fun projectee -> match projectee with | ReifiableLift _0 -> _0
-let (uu___is_LiftForFree : lift_op -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LiftForFree _0 -> true | uu___ -> false
-let (__proj__LiftForFree__item___0 : lift_op -> term) =
-  fun projectee -> match projectee with | LiftForFree _0 -> _0
-type lift =
-  {
-  msource: FStar_Ident.lid ;
-  mdest: FStar_Ident.lid ;
-  lift_op: lift_op }
-let (__proj__Mklift__item__msource : lift -> FStar_Ident.lid) =
-  fun projectee ->
-    match projectee with | { msource; mdest; lift_op = lift_op1;_} -> msource
-let (__proj__Mklift__item__mdest : lift -> FStar_Ident.lid) =
-  fun projectee ->
-    match projectee with | { msource; mdest; lift_op = lift_op1;_} -> mdest
-let (__proj__Mklift__item__lift_op : lift -> lift_op) =
-  fun projectee ->
-    match projectee with
-    | { msource; mdest; lift_op = lift_op1;_} -> lift_op1
-type pragma =
-  | SetOptions of Prims.string 
-  | ResetOptions of Prims.string FStar_Pervasives_Native.option 
-  | PushOptions of Prims.string FStar_Pervasives_Native.option 
-  | PopOptions 
-  | RestartSolver 
-  | PrintEffectsGraph 
-let (uu___is_SetOptions : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SetOptions _0 -> true | uu___ -> false
-let (__proj__SetOptions__item___0 : pragma -> Prims.string) =
-  fun projectee -> match projectee with | SetOptions _0 -> _0
-let (uu___is_ResetOptions : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ResetOptions _0 -> true | uu___ -> false
-let (__proj__ResetOptions__item___0 :
-  pragma -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | ResetOptions _0 -> _0
-let (uu___is_PushOptions : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PushOptions _0 -> true | uu___ -> false
-let (__proj__PushOptions__item___0 :
-  pragma -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | PushOptions _0 -> _0
-let (uu___is_PopOptions : pragma -> Prims.bool) =
-  fun projectee -> match projectee with | PopOptions -> true | uu___ -> false
-let (uu___is_RestartSolver : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RestartSolver -> true | uu___ -> false
-let (uu___is_PrintEffectsGraph : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PrintEffectsGraph -> true | uu___ -> false
-type decl' =
-  | TopLevelModule of FStar_Ident.lid 
-  | Open of FStar_Ident.lid 
-  | Friend of FStar_Ident.lid 
-  | Include of FStar_Ident.lid 
-  | ModuleAbbrev of (FStar_Ident.ident * FStar_Ident.lid) 
-  | TopLevelLet of (let_qualifier * (pattern * term) Prims.list) 
-  | Tycon of (Prims.bool * Prims.bool * tycon Prims.list) 
-  | Val of (FStar_Ident.ident * term) 
-  | Exception of (FStar_Ident.ident * term FStar_Pervasives_Native.option) 
-  | NewEffect of effect_decl 
-  | LayeredEffect of effect_decl 
-  | SubEffect of lift 
-  | Polymonadic_bind of (FStar_Ident.lid * FStar_Ident.lid * FStar_Ident.lid
-  * term) 
-  | Polymonadic_subcomp of (FStar_Ident.lid * FStar_Ident.lid * term) 
-  | Pragma of pragma 
-  | Assume of (FStar_Ident.ident * term) 
-  | Splice of (FStar_Ident.ident Prims.list * term) 
-and decl =
-  {
-  d: decl' ;
-  drange: FStar_Compiler_Range.range ;
-  quals: qualifiers ;
-  attrs: attributes_ }
-and effect_decl =
-  | DefineEffect of (FStar_Ident.ident * binder Prims.list * term * decl
-  Prims.list) 
-  | RedefineEffect of (FStar_Ident.ident * binder Prims.list * term) 
-let (uu___is_TopLevelModule : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TopLevelModule _0 -> true | uu___ -> false
-let (__proj__TopLevelModule__item___0 : decl' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | TopLevelModule _0 -> _0
-let (uu___is_Open : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Open _0 -> true | uu___ -> false
-let (__proj__Open__item___0 : decl' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Open _0 -> _0
-let (uu___is_Friend : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Friend _0 -> true | uu___ -> false
-let (__proj__Friend__item___0 : decl' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Friend _0 -> _0
-let (uu___is_Include : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Include _0 -> true | uu___ -> false
-let (__proj__Include__item___0 : decl' -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Include _0 -> _0
-let (uu___is_ModuleAbbrev : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ModuleAbbrev _0 -> true | uu___ -> false
-let (__proj__ModuleAbbrev__item___0 :
-  decl' -> (FStar_Ident.ident * FStar_Ident.lid)) =
-  fun projectee -> match projectee with | ModuleAbbrev _0 -> _0
-let (uu___is_TopLevelLet : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TopLevelLet _0 -> true | uu___ -> false
-let (__proj__TopLevelLet__item___0 :
-  decl' -> (let_qualifier * (pattern * term) Prims.list)) =
-  fun projectee -> match projectee with | TopLevelLet _0 -> _0
-let (uu___is_Tycon : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Tycon _0 -> true | uu___ -> false
-let (__proj__Tycon__item___0 :
-  decl' -> (Prims.bool * Prims.bool * tycon Prims.list)) =
-  fun projectee -> match projectee with | Tycon _0 -> _0
-let (uu___is_Val : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Val _0 -> true | uu___ -> false
-let (__proj__Val__item___0 : decl' -> (FStar_Ident.ident * term)) =
-  fun projectee -> match projectee with | Val _0 -> _0
-let (uu___is_Exception : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Exception _0 -> true | uu___ -> false
-let (__proj__Exception__item___0 :
-  decl' -> (FStar_Ident.ident * term FStar_Pervasives_Native.option)) =
-  fun projectee -> match projectee with | Exception _0 -> _0
-let (uu___is_NewEffect : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NewEffect _0 -> true | uu___ -> false
-let (__proj__NewEffect__item___0 : decl' -> effect_decl) =
-  fun projectee -> match projectee with | NewEffect _0 -> _0
-let (uu___is_LayeredEffect : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LayeredEffect _0 -> true | uu___ -> false
-let (__proj__LayeredEffect__item___0 : decl' -> effect_decl) =
-  fun projectee -> match projectee with | LayeredEffect _0 -> _0
-let (uu___is_SubEffect : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SubEffect _0 -> true | uu___ -> false
-let (__proj__SubEffect__item___0 : decl' -> lift) =
-  fun projectee -> match projectee with | SubEffect _0 -> _0
-let (uu___is_Polymonadic_bind : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Polymonadic_bind _0 -> true | uu___ -> false
-let (__proj__Polymonadic_bind__item___0 :
-  decl' -> (FStar_Ident.lid * FStar_Ident.lid * FStar_Ident.lid * term)) =
-  fun projectee -> match projectee with | Polymonadic_bind _0 -> _0
-let (uu___is_Polymonadic_subcomp : decl' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Polymonadic_subcomp _0 -> true | uu___ -> false
-let (__proj__Polymonadic_subcomp__item___0 :
-  decl' -> (FStar_Ident.lid * FStar_Ident.lid * term)) =
-  fun projectee -> match projectee with | Polymonadic_subcomp _0 -> _0
-let (uu___is_Pragma : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Pragma _0 -> true | uu___ -> false
-let (__proj__Pragma__item___0 : decl' -> pragma) =
-  fun projectee -> match projectee with | Pragma _0 -> _0
-let (uu___is_Assume : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Assume _0 -> true | uu___ -> false
-let (__proj__Assume__item___0 : decl' -> (FStar_Ident.ident * term)) =
-  fun projectee -> match projectee with | Assume _0 -> _0
-let (uu___is_Splice : decl' -> Prims.bool) =
-  fun projectee -> match projectee with | Splice _0 -> true | uu___ -> false
-let (__proj__Splice__item___0 :
-  decl' -> (FStar_Ident.ident Prims.list * term)) =
-  fun projectee -> match projectee with | Splice _0 -> _0
-let (__proj__Mkdecl__item__d : decl -> decl') =
-  fun projectee -> match projectee with | { d; drange; quals; attrs;_} -> d
-let (__proj__Mkdecl__item__drange : decl -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with | { d; drange; quals; attrs;_} -> drange
-let (__proj__Mkdecl__item__quals : decl -> qualifiers) =
-  fun projectee ->
-    match projectee with | { d; drange; quals; attrs;_} -> quals
-let (__proj__Mkdecl__item__attrs : decl -> attributes_) =
-  fun projectee ->
-    match projectee with | { d; drange; quals; attrs;_} -> attrs
-let (uu___is_DefineEffect : effect_decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DefineEffect _0 -> true | uu___ -> false
-let (__proj__DefineEffect__item___0 :
-  effect_decl ->
-    (FStar_Ident.ident * binder Prims.list * term * decl Prims.list))
-  = fun projectee -> match projectee with | DefineEffect _0 -> _0
-let (uu___is_RedefineEffect : effect_decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RedefineEffect _0 -> true | uu___ -> false
-let (__proj__RedefineEffect__item___0 :
-  effect_decl -> (FStar_Ident.ident * binder Prims.list * term)) =
-  fun projectee -> match projectee with | RedefineEffect _0 -> _0
-type modul =
-  | Module of (FStar_Ident.lid * decl Prims.list) 
-  | Interface of (FStar_Ident.lid * decl Prims.list * Prims.bool) 
-let (uu___is_Module : modul -> Prims.bool) =
-  fun projectee -> match projectee with | Module _0 -> true | uu___ -> false
-let (__proj__Module__item___0 : modul -> (FStar_Ident.lid * decl Prims.list))
-  = fun projectee -> match projectee with | Module _0 -> _0
-let (uu___is_Interface : modul -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Interface _0 -> true | uu___ -> false
-let (__proj__Interface__item___0 :
-  modul -> (FStar_Ident.lid * decl Prims.list * Prims.bool)) =
-  fun projectee -> match projectee with | Interface _0 -> _0
-type file = modul
-type inputFragment = (file, decl Prims.list) FStar_Pervasives.either
-let (decl_drange : decl -> FStar_Compiler_Range.range) =
-  fun decl1 -> decl1.drange
-let (check_id : FStar_Ident.ident -> unit) =
-  fun id ->
-    let first_char =
-      let uu___ = FStar_Ident.string_of_id id in
-      FStar_String.substring uu___ Prims.int_zero Prims.int_one in
-    if (FStar_String.lowercase first_char) = first_char
-    then ()
-    else
-      (let uu___1 =
-         let uu___2 =
-           let uu___3 = FStar_Ident.string_of_id id in
-           FStar_Compiler_Util.format1
-             "Invalid identifer '%s'; expected a symbol that begins with a lower-case character"
-             uu___3 in
-         (FStar_Errors.Fatal_InvalidIdentifier, uu___2) in
-       let uu___2 = FStar_Ident.range_of_id id in
-       FStar_Errors.raise_error uu___1 uu___2)
-let at_most_one :
-  'uuuuu .
-    Prims.string ->
-      FStar_Compiler_Range.range ->
-        'uuuuu Prims.list -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun s ->
-    fun r ->
-      fun l ->
-        match l with
-        | x::[] -> FStar_Pervasives_Native.Some x
-        | [] -> FStar_Pervasives_Native.None
-        | uu___ ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_Util.format1
-                  "At most one %s is allowed on declarations" s in
-              (FStar_Errors.Fatal_MoreThanOneDeclaration, uu___2) in
-            FStar_Errors.raise_error uu___1 r
-let (mk_decl :
-  decl' -> FStar_Compiler_Range.range -> decoration Prims.list -> decl) =
-  fun d ->
-    fun r ->
-      fun decorations ->
-        let attributes_1 =
-          let uu___ =
-            FStar_Compiler_List.choose
-              (fun uu___1 ->
-                 match uu___1 with
-                 | DeclAttributes a -> FStar_Pervasives_Native.Some a
-                 | uu___2 -> FStar_Pervasives_Native.None) decorations in
-          at_most_one "attribute set" r uu___ in
-        let attributes_2 = FStar_Compiler_Util.dflt [] attributes_1 in
-        let qualifiers1 =
-          FStar_Compiler_List.choose
-            (fun uu___ ->
-               match uu___ with
-               | Qualifier q -> FStar_Pervasives_Native.Some q
-               | uu___1 -> FStar_Pervasives_Native.None) decorations in
-        { d; drange = r; quals = qualifiers1; attrs = attributes_2 }
-let (mk_binder_with_attrs :
-  binder' ->
-    FStar_Compiler_Range.range ->
-      level ->
-        arg_qualifier FStar_Pervasives_Native.option ->
-          term Prims.list -> binder)
-  =
-  fun b ->
-    fun r ->
-      fun l ->
-        fun i ->
-          fun attrs ->
-            { b; brange = r; blevel = l; aqual = i; battributes = attrs }
-let (mk_binder :
-  binder' ->
-    FStar_Compiler_Range.range ->
-      level -> arg_qualifier FStar_Pervasives_Native.option -> binder)
-  = fun b -> fun r -> fun l -> fun i -> mk_binder_with_attrs b r l i []
-let (mk_term : term' -> FStar_Compiler_Range.range -> level -> term) =
-  fun t -> fun r -> fun l -> { tm = t; range = r; level = l }
-let (mk_uminus :
-  term ->
-    FStar_Compiler_Range.range -> FStar_Compiler_Range.range -> level -> term)
-  =
-  fun t ->
-    fun rminus ->
-      fun r ->
-        fun l ->
-          let t1 =
-            match t.tm with
-            | Const (FStar_Const.Const_int
-                (s, FStar_Pervasives_Native.Some (FStar_Const.Signed, width)))
-                ->
-                Const
-                  (FStar_Const.Const_int
-                     ((Prims.op_Hat "-" s),
-                       (FStar_Pervasives_Native.Some
-                          (FStar_Const.Signed, width))))
-            | uu___ ->
-                let uu___1 =
-                  let uu___2 = FStar_Ident.mk_ident ("-", rminus) in
-                  (uu___2, [t]) in
-                Op uu___1 in
-          mk_term t1 r l
-let (mk_pattern : pattern' -> FStar_Compiler_Range.range -> pattern) =
-  fun p -> fun r -> { pat = p; prange = r }
-let (un_curry_abs : pattern Prims.list -> term -> term') =
-  fun ps ->
-    fun body ->
-      match body.tm with
-      | Abs (p', body') -> Abs ((FStar_Compiler_List.op_At ps p'), body')
-      | uu___ -> Abs (ps, body)
-let (mk_function :
-  (pattern * term FStar_Pervasives_Native.option * term) Prims.list ->
-    FStar_Compiler_Range.range -> FStar_Compiler_Range.range -> term)
-  =
-  fun branches ->
-    fun r1 ->
-      fun r2 ->
-        let x = FStar_Ident.gen r1 in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = FStar_Ident.lid_of_ids [x] in Var uu___7 in
-                    mk_term uu___6 r1 Expr in
-                  (uu___5, FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.None, branches) in
-                Match uu___4 in
-              mk_term uu___3 r2 Expr in
-            ([mk_pattern (PatVar (x, FStar_Pervasives_Native.None, [])) r1],
-              uu___2) in
-          Abs uu___1 in
-        mk_term uu___ r2 Expr
-let (un_function :
-  pattern -> term -> (pattern * term) FStar_Pervasives_Native.option) =
-  fun p ->
-    fun tm ->
-      match ((p.pat), (tm.tm)) with
-      | (PatVar uu___, Abs (pats, body)) ->
-          FStar_Pervasives_Native.Some
-            ((mk_pattern (PatApp (p, pats)) p.prange), body)
-      | uu___ -> FStar_Pervasives_Native.None
-let (lid_with_range :
-  FStar_Ident.lident -> FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun lid ->
-    fun r ->
-      let uu___ = FStar_Ident.path_of_lid lid in
-      FStar_Ident.lid_of_path uu___ r
-let (consPat : FStar_Compiler_Range.range -> pattern -> pattern -> pattern')
-  =
-  fun r ->
-    fun hd ->
-      fun tl ->
-        PatApp
-          ((mk_pattern (PatName FStar_Parser_Const.cons_lid) r), [hd; tl])
-let (consTerm : FStar_Compiler_Range.range -> term -> term -> term) =
-  fun r ->
-    fun hd ->
-      fun tl ->
-        mk_term
-          (Construct
-             (FStar_Parser_Const.cons_lid, [(hd, Nothing); (tl, Nothing)])) r
-          Expr
-let (mkConsList : FStar_Compiler_Range.range -> term Prims.list -> term) =
-  fun r ->
-    fun elts ->
-      let nil = mk_term (Construct (FStar_Parser_Const.nil_lid, [])) r Expr in
-      FStar_Compiler_List.fold_right (fun e -> fun tl -> consTerm r e tl)
-        elts nil
-let (unit_const : FStar_Compiler_Range.range -> term) =
-  fun r -> mk_term (Const FStar_Const.Const_unit) r Expr
-let (ml_comp : term -> term) =
-  fun t ->
-    let lid = FStar_Parser_Const.effect_ML_lid () in
-    let ml = mk_term (Name lid) t.range Expr in
-    let t1 = mk_term (App (ml, t, Nothing)) t.range Expr in t1
-let (tot_comp : term -> term) =
-  fun t ->
-    let ml = mk_term (Name FStar_Parser_Const.effect_Tot_lid) t.range Expr in
-    let t1 = mk_term (App (ml, t, Nothing)) t.range Expr in t1
-let (mkApp :
-  term -> (term * imp) Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun args ->
-      fun r ->
-        match args with
-        | [] -> t
-        | uu___ ->
-            (match t.tm with
-             | Name s -> mk_term (Construct (s, args)) r Un
-             | uu___1 ->
-                 FStar_Compiler_List.fold_left
-                   (fun t1 ->
-                      fun uu___2 ->
-                        match uu___2 with
-                        | (a, imp1) -> mk_term (App (t1, a, imp1)) r Un) t
-                   args)
-let (mkRefSet : FStar_Compiler_Range.range -> term Prims.list -> term) =
-  fun r ->
-    fun elts ->
-      let uu___ =
-        (FStar_Parser_Const.set_empty, FStar_Parser_Const.set_singleton,
-          FStar_Parser_Const.set_union, FStar_Parser_Const.heap_addr_of_lid) in
-      match uu___ with
-      | (empty_lid, singleton_lid, union_lid, addr_of_lid) ->
-          let empty =
-            let uu___1 =
-              let uu___2 = FStar_Ident.set_lid_range empty_lid r in
-              Var uu___2 in
-            mk_term uu___1 r Expr in
-          let addr_of =
-            let uu___1 =
-              let uu___2 = FStar_Ident.set_lid_range addr_of_lid r in
-              Var uu___2 in
-            mk_term uu___1 r Expr in
-          let singleton =
-            let uu___1 =
-              let uu___2 = FStar_Ident.set_lid_range singleton_lid r in
-              Var uu___2 in
-            mk_term uu___1 r Expr in
-          let union =
-            let uu___1 =
-              let uu___2 = FStar_Ident.set_lid_range union_lid r in
-              Var uu___2 in
-            mk_term uu___1 r Expr in
-          FStar_Compiler_List.fold_right
-            (fun e ->
-               fun tl ->
-                 let e1 = mkApp addr_of [(e, Nothing)] r in
-                 let single_e = mkApp singleton [(e1, Nothing)] r in
-                 mkApp union [(single_e, Nothing); (tl, Nothing)] r) elts
-            empty
-let (mkExplicitApp :
-  term -> term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun args ->
-      fun r ->
-        match args with
-        | [] -> t
-        | uu___ ->
-            (match t.tm with
-             | Name s ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Compiler_List.map (fun a -> (a, Nothing)) args in
-                     (s, uu___3) in
-                   Construct uu___2 in
-                 mk_term uu___1 r Un
-             | uu___1 ->
-                 FStar_Compiler_List.fold_left
-                   (fun t1 -> fun a -> mk_term (App (t1, a, Nothing)) r Un) t
-                   args)
-let (mkAdmitMagic : FStar_Compiler_Range.range -> term) =
-  fun r ->
-    let admit =
-      let admit_name =
-        let uu___ =
-          let uu___1 =
-            FStar_Ident.set_lid_range FStar_Parser_Const.admit_lid r in
-          Var uu___1 in
-        mk_term uu___ r Expr in
-      mkExplicitApp admit_name [unit_const r] r in
-    let magic =
-      let magic_name =
-        let uu___ =
-          let uu___1 =
-            FStar_Ident.set_lid_range FStar_Parser_Const.magic_lid r in
-          Var uu___1 in
-        mk_term uu___ r Expr in
-      mkExplicitApp magic_name [unit_const r] r in
-    let admit_magic = mk_term (Seq (admit, magic)) r Expr in admit_magic
-let mkWildAdmitMagic :
-  'uuuuu .
-    FStar_Compiler_Range.range ->
-      (pattern * 'uuuuu FStar_Pervasives_Native.option * term)
-  =
-  fun r ->
-    let uu___ = mkAdmitMagic r in
-    ((mk_pattern (PatWild (FStar_Pervasives_Native.None, [])) r),
-      FStar_Pervasives_Native.None, uu___)
-let focusBranches :
-  'uuuuu .
-    (Prims.bool * (pattern * 'uuuuu FStar_Pervasives_Native.option * term))
-      Prims.list ->
-      FStar_Compiler_Range.range ->
-        (pattern * 'uuuuu FStar_Pervasives_Native.option * term) Prims.list
-  =
-  fun branches ->
-    fun r ->
-      let should_filter =
-        FStar_Compiler_Util.for_some FStar_Pervasives_Native.fst branches in
-      if should_filter
-      then
-        (FStar_Errors.log_issue r
-           (FStar_Errors.Warning_Filtered, "Focusing on only some cases");
-         (let focussed =
-            let uu___1 =
-              FStar_Compiler_List.filter FStar_Pervasives_Native.fst branches in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (FStar_Compiler_List.map FStar_Pervasives_Native.snd) in
-          let uu___1 = let uu___2 = mkWildAdmitMagic r in [uu___2] in
-          FStar_Compiler_List.op_At focussed uu___1))
-      else
-        FStar_Compiler_Effect.op_Bar_Greater branches
-          (FStar_Compiler_List.map FStar_Pervasives_Native.snd)
-let focusLetBindings :
-  'uuuuu .
-    (Prims.bool * ('uuuuu * term)) Prims.list ->
-      FStar_Compiler_Range.range -> ('uuuuu * term) Prims.list
-  =
-  fun lbs ->
-    fun r ->
-      let should_filter =
-        FStar_Compiler_Util.for_some FStar_Pervasives_Native.fst lbs in
-      if should_filter
-      then
-        (FStar_Errors.log_issue r
-           (FStar_Errors.Warning_Filtered,
-             "Focusing on only some cases in this (mutually) recursive definition");
-         FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with
-              | (f, lb) ->
-                  if f
-                  then lb
-                  else
-                    (let uu___3 = mkAdmitMagic r in
-                     ((FStar_Pervasives_Native.fst lb), uu___3))) lbs)
-      else
-        FStar_Compiler_Effect.op_Bar_Greater lbs
-          (FStar_Compiler_List.map FStar_Pervasives_Native.snd)
-let focusAttrLetBindings :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu * (Prims.bool * ('uuuuu1 * term))) Prims.list ->
-      FStar_Compiler_Range.range -> ('uuuuu * ('uuuuu1 * term)) Prims.list
-  =
-  fun lbs ->
-    fun r ->
-      let should_filter =
-        FStar_Compiler_Util.for_some
-          (fun uu___ -> match uu___ with | (attr, (focus, uu___1)) -> focus)
-          lbs in
-      if should_filter
-      then
-        (FStar_Errors.log_issue r
-           (FStar_Errors.Warning_Filtered,
-             "Focusing on only some cases in this (mutually) recursive definition");
-         FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with
-              | (attr, (f, lb)) ->
-                  if f
-                  then (attr, lb)
-                  else
-                    (let uu___3 =
-                       let uu___4 = mkAdmitMagic r in
-                       ((FStar_Pervasives_Native.fst lb), uu___4) in
-                     (attr, uu___3))) lbs)
-      else
-        FStar_Compiler_Effect.op_Bar_Greater lbs
-          (FStar_Compiler_List.map
-             (fun uu___1 ->
-                match uu___1 with | (attr, (uu___2, lb)) -> (attr, lb)))
-let (mkFsTypApp :
-  term -> term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun args ->
-      fun r ->
-        let uu___ = FStar_Compiler_List.map (fun a -> (a, FsTypApp)) args in
-        mkApp t uu___ r
-let (mkTuple : term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun args ->
-    fun r ->
-      let cons =
-        FStar_Parser_Const.mk_tuple_data_lid
-          (FStar_Compiler_List.length args) r in
-      let uu___ = FStar_Compiler_List.map (fun x -> (x, Nothing)) args in
-      mkApp (mk_term (Name cons) r Expr) uu___ r
-let (mkDTuple : term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun args ->
-    fun r ->
-      let cons =
-        FStar_Parser_Const.mk_dtuple_data_lid
-          (FStar_Compiler_List.length args) r in
-      let uu___ = FStar_Compiler_List.map (fun x -> (x, Nothing)) args in
-      mkApp (mk_term (Name cons) r Expr) uu___ r
-let (mkRefinedBinder :
-  FStar_Ident.ident ->
-    term ->
-      Prims.bool ->
-        term FStar_Pervasives_Native.option ->
-          FStar_Compiler_Range.range ->
-            arg_qualifier FStar_Pervasives_Native.option ->
-              term Prims.list -> binder)
-  =
-  fun id ->
-    fun t ->
-      fun should_bind_var ->
-        fun refopt ->
-          fun m ->
-            fun implicit ->
-              fun attrs ->
-                let b =
-                  mk_binder_with_attrs (Annotated (id, t)) m Type_level
-                    implicit attrs in
-                match refopt with
-                | FStar_Pervasives_Native.None -> b
-                | FStar_Pervasives_Native.Some phi ->
-                    if should_bind_var
-                    then
-                      mk_binder_with_attrs
-                        (Annotated
-                           (id, (mk_term (Refine (b, phi)) m Type_level))) m
-                        Type_level implicit attrs
-                    else
-                      (let x = FStar_Ident.gen t.range in
-                       let b1 =
-                         mk_binder_with_attrs (Annotated (x, t)) m Type_level
-                           implicit attrs in
-                       mk_binder_with_attrs
-                         (Annotated
-                            (id, (mk_term (Refine (b1, phi)) m Type_level)))
-                         m Type_level implicit attrs)
-let (mkRefinedPattern :
-  pattern ->
-    term ->
-      Prims.bool ->
-        term FStar_Pervasives_Native.option ->
-          FStar_Compiler_Range.range -> FStar_Compiler_Range.range -> pattern)
-  =
-  fun pat ->
-    fun t ->
-      fun should_bind_pat ->
-        fun phi_opt ->
-          fun t_range ->
-            fun range ->
-              let t1 =
-                match phi_opt with
-                | FStar_Pervasives_Native.None -> t
-                | FStar_Pervasives_Native.Some phi ->
-                    if should_bind_pat
-                    then
-                      (match pat.pat with
-                       | PatVar (x, uu___, attrs) ->
-                           mk_term
-                             (Refine
-                                ((mk_binder_with_attrs (Annotated (x, t))
-                                    t_range Type_level
-                                    FStar_Pervasives_Native.None attrs), phi))
-                             range Type_level
-                       | uu___ ->
-                           let x = FStar_Ident.gen t_range in
-                           let phi1 =
-                             let x_var =
-                               let uu___1 =
-                                 let uu___2 = FStar_Ident.lid_of_ids [x] in
-                                 Var uu___2 in
-                               mk_term uu___1 phi.range Formula in
-                             let pat_branch =
-                               (pat, FStar_Pervasives_Native.None, phi) in
-                             let otherwise_branch =
-                               let uu___1 =
-                                 let uu___2 =
-                                   let uu___3 =
-                                     FStar_Ident.lid_of_path ["False"]
-                                       phi.range in
-                                   Name uu___3 in
-                                 mk_term uu___2 phi.range Formula in
-                               ((mk_pattern
-                                   (PatWild
-                                      (FStar_Pervasives_Native.None, []))
-                                   phi.range), FStar_Pervasives_Native.None,
-                                 uu___1) in
-                             mk_term
-                               (Match
-                                  (x_var, FStar_Pervasives_Native.None,
-                                    FStar_Pervasives_Native.None,
-                                    [pat_branch; otherwise_branch]))
-                               phi.range Formula in
-                           mk_term
-                             (Refine
-                                ((mk_binder (Annotated (x, t)) t_range
-                                    Type_level FStar_Pervasives_Native.None),
-                                  phi1)) range Type_level)
-                    else
-                      (let x = FStar_Ident.gen t.range in
-                       mk_term
-                         (Refine
-                            ((mk_binder (Annotated (x, t)) t_range Type_level
-                                FStar_Pervasives_Native.None), phi)) range
-                         Type_level) in
-              mk_pattern
-                (PatAscribed (pat, (t1, FStar_Pervasives_Native.None))) range
-let rec (extract_named_refinement :
-  term ->
-    (FStar_Ident.ident * term * term FStar_Pervasives_Native.option)
-      FStar_Pervasives_Native.option)
-  =
-  fun t1 ->
-    match t1.tm with
-    | NamedTyp (x, t) ->
-        FStar_Pervasives_Native.Some (x, t, FStar_Pervasives_Native.None)
-    | Refine
-        ({ b = Annotated (x, t); brange = uu___; blevel = uu___1;
-           aqual = uu___2; battributes = uu___3;_},
-         t')
-        ->
-        FStar_Pervasives_Native.Some
-          (x, t, (FStar_Pervasives_Native.Some t'))
-    | Paren t -> extract_named_refinement t
-    | uu___ -> FStar_Pervasives_Native.None
-let rec (as_mlist :
-  ((FStar_Ident.lid * decl) * decl Prims.list) -> decl Prims.list -> modul) =
-  fun cur ->
-    fun ds ->
-      let uu___ = cur in
-      match uu___ with
-      | ((m_name, m_decl), cur1) ->
-          (match ds with
-           | [] ->
-               Module (m_name, (m_decl :: (FStar_Compiler_List.rev cur1)))
-           | d::ds1 ->
-               (match d.d with
-                | TopLevelModule m' ->
-                    FStar_Errors.raise_error
-                      (FStar_Errors.Fatal_UnexpectedModuleDeclaration,
-                        "Unexpected module declaration") d.drange
-                | uu___1 -> as_mlist ((m_name, m_decl), (d :: cur1)) ds1))
-let (as_frag : decl Prims.list -> inputFragment) =
-  fun ds ->
-    let uu___ =
-      match ds with
-      | d::ds1 -> (d, ds1)
-      | [] -> FStar_Compiler_Effect.raise FStar_Errors.Empty_frag in
-    match uu___ with
-    | (d, ds1) ->
-        (match d.d with
-         | TopLevelModule m ->
-             let m1 = as_mlist ((m, d), []) ds1 in FStar_Pervasives.Inl m1
-         | uu___1 ->
-             let ds2 = d :: ds1 in
-             (FStar_Compiler_List.iter
-                (fun uu___3 ->
-                   match uu___3 with
-                   | { d = TopLevelModule uu___4; drange = r; quals = uu___5;
-                       attrs = uu___6;_} ->
-                       FStar_Errors.raise_error
-                         (FStar_Errors.Fatal_UnexpectedModuleDeclaration,
-                           "Unexpected module declaration") r
-                   | uu___4 -> ()) ds2;
-              FStar_Pervasives.Inr ds2))
-let (strip_prefix :
-  Prims.string -> Prims.string -> Prims.string FStar_Pervasives_Native.option)
-  =
-  fun prefix ->
-    fun s ->
-      if FStar_Compiler_Util.starts_with s prefix
-      then
-        let uu___ =
-          FStar_Compiler_Util.substring_from s (FStar_String.length prefix) in
-        FStar_Pervasives_Native.Some uu___
-      else FStar_Pervasives_Native.None
-let compile_op : 'uuuuu . Prims.int -> Prims.string -> 'uuuuu -> Prims.string
-  =
-  fun arity ->
-    fun s ->
-      fun r ->
-        let name_of_char uu___ =
-          match uu___ with
-          | 38 -> "Amp"
-          | 64 -> "At"
-          | 43 -> "Plus"
-          | 45 when arity = Prims.int_one -> "Minus"
-          | 45 -> "Subtraction"
-          | 126 -> "Tilde"
-          | 47 -> "Slash"
-          | 92 -> "Backslash"
-          | 60 -> "Less"
-          | 61 -> "Equals"
-          | 62 -> "Greater"
-          | 95 -> "Underscore"
-          | 124 -> "Bar"
-          | 33 -> "Bang"
-          | 94 -> "Hat"
-          | 37 -> "Percent"
-          | 42 -> "Star"
-          | 63 -> "Question"
-          | 58 -> "Colon"
-          | 36 -> "Dollar"
-          | 46 -> "Dot"
-          | c ->
-              let uu___1 =
-                FStar_Compiler_Util.string_of_int
-                  (FStar_Compiler_Util.int_of_char c) in
-              Prims.op_Hat "u" uu___1 in
-        match s with
-        | ".[]<-" -> "op_String_Assignment"
-        | ".()<-" -> "op_Array_Assignment"
-        | ".[||]<-" -> "op_Brack_Lens_Assignment"
-        | ".(||)<-" -> "op_Lens_Assignment"
-        | ".[]" -> "op_String_Access"
-        | ".()" -> "op_Array_Access"
-        | ".[||]" -> "op_Brack_Lens_Access"
-        | ".(||)" -> "op_Lens_Access"
-        | uu___ ->
-            let uu___1 =
-              if
-                (FStar_Compiler_Util.starts_with s "let") ||
-                  (FStar_Compiler_Util.starts_with s "and")
-              then
-                let uu___2 =
-                  let uu___3 =
-                    FStar_Compiler_Util.substring s Prims.int_zero
-                      (Prims.of_int (3)) in
-                  Prims.op_Hat uu___3 "_" in
-                let uu___3 =
-                  FStar_Compiler_Util.substring_from s (Prims.of_int (3)) in
-                (uu___2, uu___3)
-              else ("", s) in
-            (match uu___1 with
-             | (prefix, s1) ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_String.list_of_string s1 in
-                       FStar_Compiler_List.map name_of_char uu___5 in
-                     FStar_String.concat "_" uu___4 in
-                   Prims.op_Hat prefix uu___3 in
-                 Prims.op_Hat "op_" uu___2)
-let compile_op' : 'uuuuu . Prims.string -> 'uuuuu -> Prims.string =
-  fun s -> fun r -> compile_op (~- Prims.int_one) s r
-let (string_to_op :
-  Prims.string ->
-    (Prims.string * Prims.int FStar_Pervasives_Native.option)
-      FStar_Pervasives_Native.option)
-  =
-  fun s ->
-    let name_of_op uu___ =
-      match uu___ with
-      | "Amp" ->
-          FStar_Pervasives_Native.Some ("&", FStar_Pervasives_Native.None)
-      | "At" ->
-          FStar_Pervasives_Native.Some ("@", FStar_Pervasives_Native.None)
-      | "Plus" ->
-          FStar_Pervasives_Native.Some ("+", FStar_Pervasives_Native.None)
-      | "Minus" ->
-          FStar_Pervasives_Native.Some ("-", FStar_Pervasives_Native.None)
-      | "Subtraction" ->
-          FStar_Pervasives_Native.Some
-            ("-", (FStar_Pervasives_Native.Some (Prims.of_int (2))))
-      | "Tilde" ->
-          FStar_Pervasives_Native.Some ("~", FStar_Pervasives_Native.None)
-      | "Slash" ->
-          FStar_Pervasives_Native.Some ("/", FStar_Pervasives_Native.None)
-      | "Backslash" ->
-          FStar_Pervasives_Native.Some ("\\", FStar_Pervasives_Native.None)
-      | "Less" ->
-          FStar_Pervasives_Native.Some ("<", FStar_Pervasives_Native.None)
-      | "Equals" ->
-          FStar_Pervasives_Native.Some ("=", FStar_Pervasives_Native.None)
-      | "Greater" ->
-          FStar_Pervasives_Native.Some (">", FStar_Pervasives_Native.None)
-      | "Underscore" ->
-          FStar_Pervasives_Native.Some ("_", FStar_Pervasives_Native.None)
-      | "Bar" ->
-          FStar_Pervasives_Native.Some ("|", FStar_Pervasives_Native.None)
-      | "Bang" ->
-          FStar_Pervasives_Native.Some ("!", FStar_Pervasives_Native.None)
-      | "Hat" ->
-          FStar_Pervasives_Native.Some ("^", FStar_Pervasives_Native.None)
-      | "Percent" ->
-          FStar_Pervasives_Native.Some ("%", FStar_Pervasives_Native.None)
-      | "Star" ->
-          FStar_Pervasives_Native.Some ("*", FStar_Pervasives_Native.None)
-      | "Question" ->
-          FStar_Pervasives_Native.Some ("?", FStar_Pervasives_Native.None)
-      | "Colon" ->
-          FStar_Pervasives_Native.Some (":", FStar_Pervasives_Native.None)
-      | "Dollar" ->
-          FStar_Pervasives_Native.Some ("$", FStar_Pervasives_Native.None)
-      | "Dot" ->
-          FStar_Pervasives_Native.Some (".", FStar_Pervasives_Native.None)
-      | "let" ->
-          FStar_Pervasives_Native.Some (s, FStar_Pervasives_Native.None)
-      | "and" ->
-          FStar_Pervasives_Native.Some (s, FStar_Pervasives_Native.None)
-      | uu___1 -> FStar_Pervasives_Native.None in
-    match s with
-    | "op_String_Assignment" ->
-        FStar_Pervasives_Native.Some (".[]<-", FStar_Pervasives_Native.None)
-    | "op_Array_Assignment" ->
-        FStar_Pervasives_Native.Some (".()<-", FStar_Pervasives_Native.None)
-    | "op_Brack_Lens_Assignment" ->
-        FStar_Pervasives_Native.Some
-          (".[||]<-", FStar_Pervasives_Native.None)
-    | "op_Lens_Assignment" ->
-        FStar_Pervasives_Native.Some
-          (".(||)<-", FStar_Pervasives_Native.None)
-    | "op_String_Access" ->
-        FStar_Pervasives_Native.Some (".[]", FStar_Pervasives_Native.None)
-    | "op_Array_Access" ->
-        FStar_Pervasives_Native.Some (".()", FStar_Pervasives_Native.None)
-    | "op_Brack_Lens_Access" ->
-        FStar_Pervasives_Native.Some (".[||]", FStar_Pervasives_Native.None)
-    | "op_Lens_Access" ->
-        FStar_Pervasives_Native.Some (".(||)", FStar_Pervasives_Native.None)
-    | uu___ ->
-        if FStar_Compiler_Util.starts_with s "op_"
-        then
-          let s1 =
-            let uu___1 =
-              FStar_Compiler_Util.substring_from s
-                (FStar_String.length "op_") in
-            FStar_Compiler_Util.split uu___1 "_" in
-          (match s1 with
-           | op::[] ->
-               if FStar_Compiler_Util.starts_with op "u"
-               then
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Compiler_Util.substring_from op Prims.int_one in
-                   FStar_Compiler_Util.safe_int_of_string uu___2 in
-                 FStar_Compiler_Util.map_opt uu___1
-                   (fun op1 ->
-                      ((FStar_Compiler_Util.string_of_char
-                          (FStar_Compiler_Util.char_of_int op1)),
-                        FStar_Pervasives_Native.None))
-               else name_of_op op
-           | uu___1 ->
-               let maybeop =
-                 let uu___2 = FStar_Compiler_List.map name_of_op s1 in
-                 FStar_Compiler_List.fold_left
-                   (fun acc ->
-                      fun x ->
-                        match acc with
-                        | FStar_Pervasives_Native.None ->
-                            FStar_Pervasives_Native.None
-                        | FStar_Pervasives_Native.Some acc1 ->
-                            (match x with
-                             | FStar_Pervasives_Native.Some (op, uu___3) ->
-                                 FStar_Pervasives_Native.Some
-                                   (Prims.op_Hat acc1 op)
-                             | FStar_Pervasives_Native.None ->
-                                 FStar_Pervasives_Native.None))
-                   (FStar_Pervasives_Native.Some "") uu___2 in
-               FStar_Compiler_Util.map_opt maybeop
-                 (fun o -> (o, FStar_Pervasives_Native.None)))
-        else FStar_Pervasives_Native.None
-let (string_of_fsdoc :
-  (Prims.string * (Prims.string * Prims.string) Prims.list) -> Prims.string)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (comment, keywords) ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_List.map
-              (fun uu___3 ->
-                 match uu___3 with
-                 | (k, v) -> Prims.op_Hat k (Prims.op_Hat "->" v)) keywords in
-          FStar_String.concat "," uu___2 in
-        Prims.op_Hat comment uu___1
-let (string_of_let_qualifier : let_qualifier -> Prims.string) =
-  fun uu___ -> match uu___ with | NoLetQualifier -> "" | Rec -> "rec"
-let to_string_l :
-  'uuuuu .
-    Prims.string ->
-      ('uuuuu -> Prims.string) -> 'uuuuu Prims.list -> Prims.string
-  =
-  fun sep ->
-    fun f ->
-      fun l ->
-        let uu___ = FStar_Compiler_List.map f l in
-        FStar_String.concat sep uu___
-let (imp_to_string : imp -> Prims.string) =
-  fun uu___ -> match uu___ with | Hash -> "#" | uu___1 -> ""
-let rec (term_to_string : term -> Prims.string) =
-  fun x ->
-    match x.tm with
-    | Wild -> "_"
-    | LexList l ->
-        let uu___ =
-          match l with
-          | [] -> " "
-          | hd::tl ->
-              let uu___1 =
-                let uu___2 = term_to_string hd in
-                FStar_Compiler_List.fold_left
-                  (fun s ->
-                     fun t ->
-                       let uu___3 =
-                         let uu___4 = term_to_string t in
-                         Prims.op_Hat "; " uu___4 in
-                       Prims.op_Hat s uu___3) uu___2 in
-              FStar_Compiler_Effect.op_Bar_Greater tl uu___1 in
-        FStar_Compiler_Util.format1 "%[%s]" uu___
-    | Decreases (t, uu___) ->
-        let uu___1 = term_to_string t in
-        FStar_Compiler_Util.format1 "(decreases %s)" uu___1
-    | Requires (t, uu___) ->
-        let uu___1 = term_to_string t in
-        FStar_Compiler_Util.format1 "(requires %s)" uu___1
-    | Ensures (t, uu___) ->
-        let uu___1 = term_to_string t in
-        FStar_Compiler_Util.format1 "(ensures %s)" uu___1
-    | Labeled (t, l, uu___) ->
-        let uu___1 = term_to_string t in
-        FStar_Compiler_Util.format2 "(labeled %s %s)" l uu___1
-    | Const c -> FStar_Parser_Const.const_to_string c
-    | Op (s, xs) ->
-        let uu___ = FStar_Ident.string_of_id s in
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_List.map
-              (fun x1 ->
-                 FStar_Compiler_Effect.op_Bar_Greater x1 term_to_string) xs in
-          FStar_String.concat ", " uu___2 in
-        FStar_Compiler_Util.format2 "%s(%s)" uu___ uu___1
-    | Tvar id -> FStar_Ident.string_of_id id
-    | Uvar id -> FStar_Ident.string_of_id id
-    | Var l -> FStar_Ident.string_of_lid l
-    | Name l -> FStar_Ident.string_of_lid l
-    | Projector (rec_lid, field_id) ->
-        let uu___ = FStar_Ident.string_of_lid rec_lid in
-        let uu___1 = FStar_Ident.string_of_id field_id in
-        FStar_Compiler_Util.format2 "%s?.%s" uu___ uu___1
-    | Construct (l, args) ->
-        let uu___ = FStar_Ident.string_of_lid l in
-        let uu___1 =
-          to_string_l " "
-            (fun uu___2 ->
-               match uu___2 with
-               | (a, imp1) ->
-                   let uu___3 = term_to_string a in
-                   FStar_Compiler_Util.format2 "%s%s" (imp_to_string imp1)
-                     uu___3) args in
-        FStar_Compiler_Util.format2 "(%s %s)" uu___ uu___1
-    | Abs (pats, t) ->
-        let uu___ = to_string_l " " pat_to_string pats in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "(fun %s -> %s)" uu___ uu___1
-    | App (t1, t2, imp1) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater t1 term_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t2 term_to_string in
-        FStar_Compiler_Util.format3 "%s %s%s" uu___ (imp_to_string imp1)
-          uu___1
-    | Let (Rec, (a, (p, b))::lbs, body) ->
-        let uu___ = attrs_opt_to_string a in
-        let uu___1 =
-          let uu___2 = FStar_Compiler_Effect.op_Bar_Greater p pat_to_string in
-          let uu___3 = FStar_Compiler_Effect.op_Bar_Greater b term_to_string in
-          FStar_Compiler_Util.format2 "%s=%s" uu___2 uu___3 in
-        let uu___2 =
-          to_string_l " "
-            (fun uu___3 ->
-               match uu___3 with
-               | (a1, (p1, b1)) ->
-                   let uu___4 = attrs_opt_to_string a1 in
-                   let uu___5 =
-                     FStar_Compiler_Effect.op_Bar_Greater p1 pat_to_string in
-                   let uu___6 =
-                     FStar_Compiler_Effect.op_Bar_Greater b1 term_to_string in
-                   FStar_Compiler_Util.format3 "%sand %s=%s" uu___4 uu___5
-                     uu___6) lbs in
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater body term_to_string in
-        FStar_Compiler_Util.format4 "%slet rec %s%s in %s" uu___ uu___1
-          uu___2 uu___3
-    | Let (q, (attrs, (pat, tm))::[], body) ->
-        let uu___ = attrs_opt_to_string attrs in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater pat pat_to_string in
-        let uu___2 = FStar_Compiler_Effect.op_Bar_Greater tm term_to_string in
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater body term_to_string in
-        FStar_Compiler_Util.format5 "%slet %s %s = %s in %s" uu___
-          (string_of_let_qualifier q) uu___1 uu___2 uu___3
-    | Let (uu___, uu___1, uu___2) ->
-        FStar_Errors.raise_error
-          (FStar_Errors.Fatal_EmptySurfaceLet,
-            "Internal error: found an invalid surface Let") x.range
-    | LetOpen (lid, t) ->
-        let uu___ = FStar_Ident.string_of_lid lid in
-        let uu___1 = term_to_string t in
-        FStar_Compiler_Util.format2 "let open %s in %s" uu___ uu___1
-    | Seq (t1, t2) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater t1 term_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t2 term_to_string in
-        FStar_Compiler_Util.format2 "%s; %s" uu___ uu___1
-    | Bind (id, t1, t2) ->
-        let uu___ = FStar_Ident.string_of_id id in
-        let uu___1 = term_to_string t1 in
-        let uu___2 = term_to_string t2 in
-        FStar_Compiler_Util.format3 "%s <- %s; %s" uu___ uu___1 uu___2
-    | If (t1, op_opt, ret_opt, t2, t3) ->
-        let uu___ =
-          match op_opt with
-          | FStar_Pervasives_Native.Some op -> FStar_Ident.string_of_id op
-          | FStar_Pervasives_Native.None -> "" in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t1 term_to_string in
-        let uu___2 =
-          match ret_opt with
-          | FStar_Pervasives_Native.None -> ""
-          | FStar_Pervasives_Native.Some (as_opt, ret, use_eq) ->
-              let s = if use_eq then "returns$" else "returns" in
-              let uu___3 =
-                match as_opt with
-                | FStar_Pervasives_Native.None -> ""
-                | FStar_Pervasives_Native.Some as_ident ->
-                    let uu___4 = FStar_Ident.string_of_id as_ident in
-                    FStar_Compiler_Util.format1 " as %s " uu___4 in
-              let uu___4 = term_to_string ret in
-              FStar_Compiler_Util.format3 "%s%s %s " uu___3 s uu___4 in
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater t2 term_to_string in
-        let uu___4 = FStar_Compiler_Effect.op_Bar_Greater t3 term_to_string in
-        FStar_Compiler_Util.format5 "if%s %s %sthen %s else %s" uu___ uu___1
-          uu___2 uu___3 uu___4
-    | Match (t, op_opt, ret_opt, branches) ->
-        try_or_match_to_string x t branches op_opt ret_opt
-    | TryWith (t, branches) ->
-        try_or_match_to_string x t branches FStar_Pervasives_Native.None
-          FStar_Pervasives_Native.None
-    | Ascribed (t1, t2, FStar_Pervasives_Native.None, flag) ->
-        let s = if flag then "$:" else "<:" in
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater t1 term_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t2 term_to_string in
-        FStar_Compiler_Util.format3 "(%s %s %s)" uu___ s uu___1
-    | Ascribed (t1, t2, FStar_Pervasives_Native.Some tac, flag) ->
-        let s = if flag then "$:" else "<:" in
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater t1 term_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t2 term_to_string in
-        let uu___2 = FStar_Compiler_Effect.op_Bar_Greater tac term_to_string in
-        FStar_Compiler_Util.format4 "(%s %s %s by %s)" uu___ s uu___1 uu___2
-    | Record (FStar_Pervasives_Native.Some e, fields) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater e term_to_string in
-        let uu___1 =
-          to_string_l " "
-            (fun uu___2 ->
-               match uu___2 with
-               | (l, e1) ->
-                   let uu___3 = FStar_Ident.string_of_lid l in
-                   let uu___4 =
-                     FStar_Compiler_Effect.op_Bar_Greater e1 term_to_string in
-                   FStar_Compiler_Util.format2 "%s=%s" uu___3 uu___4) fields in
-        FStar_Compiler_Util.format2 "{%s with %s}" uu___ uu___1
-    | Record (FStar_Pervasives_Native.None, fields) ->
-        let uu___ =
-          to_string_l " "
-            (fun uu___1 ->
-               match uu___1 with
-               | (l, e) ->
-                   let uu___2 = FStar_Ident.string_of_lid l in
-                   let uu___3 =
-                     FStar_Compiler_Effect.op_Bar_Greater e term_to_string in
-                   FStar_Compiler_Util.format2 "%s=%s" uu___2 uu___3) fields in
-        FStar_Compiler_Util.format1 "{%s}" uu___
-    | Project (e, l) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater e term_to_string in
-        let uu___1 = FStar_Ident.string_of_lid l in
-        FStar_Compiler_Util.format2 "%s.%s" uu___ uu___1
-    | Product ([], t) -> term_to_string t
-    | Product (b::hd::tl, t) ->
-        term_to_string
-          (mk_term
-             (Product
-                ([b], (mk_term (Product ((hd :: tl), t)) x.range x.level)))
-             x.range x.level)
-    | Product (b::[], t) when x.level = Type_level ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater b binder_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "%s -> %s" uu___ uu___1
-    | Product (b::[], t) when x.level = Kind ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater b binder_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "%s => %s" uu___ uu___1
-    | Sum (binders, t) ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater
-            (FStar_Compiler_List.op_At binders [FStar_Pervasives.Inr t])
-            (FStar_Compiler_List.map
-               (fun uu___1 ->
-                  match uu___1 with
-                  | FStar_Pervasives.Inl b -> binder_to_string b
-                  | FStar_Pervasives.Inr t1 -> term_to_string t1)) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (FStar_String.concat " & ")
-    | QForall (bs, (uu___, pats), t) ->
-        let uu___1 = to_string_l " " binder_to_string bs in
-        let uu___2 =
-          to_string_l " \\/ " (to_string_l "; " term_to_string) pats in
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format3 "forall %s.{:pattern %s} %s" uu___1
-          uu___2 uu___3
-    | QExists (bs, (uu___, pats), t) ->
-        let uu___1 = to_string_l " " binder_to_string bs in
-        let uu___2 =
-          to_string_l " \\/ " (to_string_l "; " term_to_string) pats in
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format3 "exists %s.{:pattern %s} %s" uu___1
-          uu___2 uu___3
-    | Refine (b, t) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater b binder_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "%s:{%s}" uu___ uu___1
-    | NamedTyp (x1, t) ->
-        let uu___ = FStar_Ident.string_of_id x1 in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "%s:%s" uu___ uu___1
-    | Paren t ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format1 "(%s)" uu___
-    | Product (bs, t) ->
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater bs
-              (FStar_Compiler_List.map binder_to_string) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_String.concat ",") in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "Unidentified product: [%s] %s" uu___
-          uu___1
-    | Discrim lid ->
-        let uu___ = FStar_Ident.string_of_lid lid in
-        FStar_Compiler_Util.format1 "%s?" uu___
-    | Attributes ts ->
-        let uu___ =
-          let uu___1 = FStar_Compiler_List.map term_to_string ts in
-          FStar_Compiler_Effect.op_Less_Bar (FStar_String.concat " ") uu___1 in
-        FStar_Compiler_Util.format1 "(attributes %s)" uu___
-    | Antiquote t ->
-        let uu___ = term_to_string t in
-        FStar_Compiler_Util.format1 "(`#%s)" uu___
-    | Quote (t, Static) ->
-        let uu___ = term_to_string t in
-        FStar_Compiler_Util.format1 "(`(%s))" uu___
-    | Quote (t, Dynamic) ->
-        let uu___ = term_to_string t in
-        FStar_Compiler_Util.format1 "quote (%s)" uu___
-    | VQuote t ->
-        let uu___ = term_to_string t in
-        FStar_Compiler_Util.format1 "`%%%s" uu___
-    | CalcProof (rel, init, steps) ->
-        let uu___ = term_to_string rel in
-        let uu___1 = term_to_string init in
-        let uu___2 =
-          let uu___3 = FStar_Compiler_List.map calc_step_to_string steps in
-          FStar_Compiler_Effect.op_Less_Bar (FStar_String.concat " ") uu___3 in
-        FStar_Compiler_Util.format3 "calc (%s) { %s %s }" uu___ uu___1 uu___2
-    | ElimForall (bs, t, vs) ->
-        let uu___ = binders_to_string " " bs in
-        let uu___1 = term_to_string t in
-        let uu___2 =
-          let uu___3 = FStar_Compiler_List.map term_to_string vs in
-          FStar_String.concat " " uu___3 in
-        FStar_Compiler_Util.format3 "_elim_ forall %s. %s using %s" uu___
-          uu___1 uu___2
-    | ElimExists (bs, p, q, b, e) ->
-        let uu___ = binders_to_string " " bs in
-        let uu___1 = term_to_string p in
-        let uu___2 = term_to_string q in
-        let uu___3 = binder_to_string b in
-        let uu___4 = term_to_string e in
-        FStar_Compiler_Util.format5
-          "_elim_ exists %s. %s _to_ %s\n\\with %s. %s" uu___ uu___1 uu___2
-          uu___3 uu___4
-    | ElimImplies (p, q, e) ->
-        let uu___ = term_to_string p in
-        let uu___1 = term_to_string q in
-        let uu___2 = term_to_string e in
-        FStar_Compiler_Util.format3 "_elim_ %s ==> %s with %s" uu___ uu___1
-          uu___2
-    | ElimOr (p, q, r, x1, e, y, e') ->
-        let uu___ =
-          let uu___1 = term_to_string p in
-          let uu___2 =
-            let uu___3 = term_to_string q in
-            let uu___4 =
-              let uu___5 = term_to_string r in
-              let uu___6 =
-                let uu___7 = binder_to_string x1 in
-                let uu___8 =
-                  let uu___9 = term_to_string e in
-                  let uu___10 =
-                    let uu___11 = binder_to_string y in
-                    let uu___12 =
-                      let uu___13 = term_to_string e' in [uu___13] in
-                    uu___11 :: uu___12 in
-                  uu___9 :: uu___10 in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        FStar_Compiler_Util.format
-          "_elim_ %s \\/ %s _to_ %s\n\\with %s. %s\n\\and %s.%s" uu___
-    | ElimAnd (p, q, r, x1, y, e) ->
-        let uu___ =
-          let uu___1 = term_to_string p in
-          let uu___2 =
-            let uu___3 = term_to_string q in
-            let uu___4 =
-              let uu___5 = term_to_string r in
-              let uu___6 =
-                let uu___7 = binder_to_string x1 in
-                let uu___8 =
-                  let uu___9 = binder_to_string y in
-                  let uu___10 = let uu___11 = term_to_string e in [uu___11] in
-                  uu___9 :: uu___10 in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        FStar_Compiler_Util.format
-          "_elim_ %s /\\ %s _to_ %s\n\\with %s %s. %s" uu___
-    | IntroForall (xs, p, e) ->
-        let uu___ = binders_to_string " " xs in
-        let uu___1 = term_to_string p in
-        let uu___2 = term_to_string e in
-        FStar_Compiler_Util.format3 "_intro_ forall %s. %s with %s" uu___
-          uu___1 uu___2
-    | IntroExists (xs, t, vs, e) ->
-        let uu___ = binders_to_string " " xs in
-        let uu___1 = term_to_string t in
-        let uu___2 =
-          let uu___3 = FStar_Compiler_List.map term_to_string vs in
-          FStar_String.concat " " uu___3 in
-        let uu___3 = term_to_string e in
-        FStar_Compiler_Util.format4 "_intro_ exists %s. %s using %s with %s"
-          uu___ uu___1 uu___2 uu___3
-    | IntroImplies (p, q, x1, e) ->
-        let uu___ = term_to_string p in
-        let uu___1 = term_to_string q in
-        let uu___2 = binder_to_string x1 in
-        let uu___3 = term_to_string p in
-        FStar_Compiler_Util.format4 "_intro_ %s ==> %s with %s. %s" uu___
-          uu___1 uu___2 uu___3
-    | IntroOr (b, p, q, r) ->
-        let uu___ = term_to_string p in
-        let uu___1 = term_to_string q in
-        let uu___2 = term_to_string r in
-        FStar_Compiler_Util.format4 "_intro_ %s \\/ %s using %s with %s"
-          uu___ uu___1 (if b then "Left" else "Right") uu___2
-    | IntroAnd (p, q, e1, e2) ->
-        let uu___ = term_to_string p in
-        let uu___1 = term_to_string q in
-        let uu___2 = term_to_string e1 in
-        let uu___3 = term_to_string e2 in
-        FStar_Compiler_Util.format4 "_intro_ %s /\\ %s with %s and %s" uu___
-          uu___1 uu___2 uu___3
-and (binders_to_string : Prims.string -> binder Prims.list -> Prims.string) =
-  fun sep ->
-    fun bs ->
-      let uu___ = FStar_Compiler_List.map binder_to_string bs in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat sep)
-and (try_or_match_to_string :
-  term ->
-    term ->
-      (pattern * term FStar_Pervasives_Native.option * term) Prims.list ->
-        FStar_Ident.ident FStar_Pervasives_Native.option ->
-          (FStar_Ident.ident FStar_Pervasives_Native.option * term *
-            Prims.bool) FStar_Pervasives_Native.option -> Prims.string)
-  =
-  fun x ->
-    fun scrutinee ->
-      fun branches ->
-        fun op_opt ->
-          fun ret_opt ->
-            let s =
-              match x.tm with
-              | Match uu___ -> "match"
-              | TryWith uu___ -> "try"
-              | uu___ -> failwith "impossible" in
-            let uu___ =
-              match op_opt with
-              | FStar_Pervasives_Native.Some op ->
-                  FStar_Ident.string_of_id op
-              | FStar_Pervasives_Native.None -> "" in
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater scrutinee term_to_string in
-            let uu___2 =
-              match ret_opt with
-              | FStar_Pervasives_Native.None -> ""
-              | FStar_Pervasives_Native.Some (as_opt, ret, use_eq) ->
-                  let s1 = if use_eq then "returns$" else "returns" in
-                  let uu___3 =
-                    match as_opt with
-                    | FStar_Pervasives_Native.None -> ""
-                    | FStar_Pervasives_Native.Some as_ident ->
-                        let uu___4 = FStar_Ident.string_of_id as_ident in
-                        FStar_Compiler_Util.format1 "as %s " uu___4 in
-                  let uu___4 = term_to_string ret in
-                  FStar_Compiler_Util.format3 "%s%s %s " s1 uu___3 uu___4 in
-            let uu___3 =
-              to_string_l " | "
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (p, w, e) ->
-                       let uu___5 =
-                         FStar_Compiler_Effect.op_Bar_Greater p pat_to_string in
-                       let uu___6 =
-                         match w with
-                         | FStar_Pervasives_Native.None -> ""
-                         | FStar_Pervasives_Native.Some e1 ->
-                             let uu___7 = term_to_string e1 in
-                             FStar_Compiler_Util.format1 "when %s" uu___7 in
-                       let uu___7 =
-                         FStar_Compiler_Effect.op_Bar_Greater e
-                           term_to_string in
-                       FStar_Compiler_Util.format3 "%s %s -> %s" uu___5
-                         uu___6 uu___7) branches in
-            FStar_Compiler_Util.format5 "%s%s %s %swith %s" s uu___ uu___1
-              uu___2 uu___3
-and (calc_step_to_string : calc_step -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | CalcStep (rel, just, next) ->
-        let uu___1 = term_to_string rel in
-        let uu___2 = term_to_string just in
-        let uu___3 = term_to_string next in
-        FStar_Compiler_Util.format3 "%s{ %s } %s" uu___1 uu___2 uu___3
-and (binder_to_string : binder -> Prims.string) =
-  fun x ->
-    let pr x1 =
-      let s =
-        match x1.b with
-        | Variable i -> FStar_Ident.string_of_id i
-        | TVariable i ->
-            let uu___ = FStar_Ident.string_of_id i in
-            FStar_Compiler_Util.format1 "%s:_" uu___
-        | TAnnotated (i, t) ->
-            let uu___ = FStar_Ident.string_of_id i in
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-            FStar_Compiler_Util.format2 "%s:%s" uu___ uu___1
-        | Annotated (i, t) ->
-            let uu___ = FStar_Ident.string_of_id i in
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-            FStar_Compiler_Util.format2 "%s:%s" uu___ uu___1
-        | NoName t -> FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-      let uu___ = aqual_to_string x1.aqual in
-      let uu___1 = attr_list_to_string x1.battributes in
-      FStar_Compiler_Util.format3 "%s%s%s" uu___ uu___1 s in
-    match x.aqual with
-    | FStar_Pervasives_Native.Some (TypeClassArg) ->
-        let uu___ = let uu___1 = pr x in Prims.op_Hat uu___1 " |}" in
-        Prims.op_Hat "{| " uu___
-    | uu___ -> pr x
-and (aqual_to_string :
-  arg_qualifier FStar_Pervasives_Native.option -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some (Equality) -> "$"
-    | FStar_Pervasives_Native.Some (Implicit) -> "#"
-    | FStar_Pervasives_Native.None -> ""
-    | FStar_Pervasives_Native.Some (Meta uu___1) ->
-        failwith "aqual_to_strings: meta arg qualifier?"
-    | FStar_Pervasives_Native.Some (TypeClassArg) ->
-        failwith "aqual_to_strings: meta arg qualifier?"
-and (attr_list_to_string : term Prims.list -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | [] -> ""
-    | l -> attrs_opt_to_string (FStar_Pervasives_Native.Some l)
-and (pat_to_string : pattern -> Prims.string) =
-  fun x ->
-    match x.pat with
-    | PatWild (FStar_Pervasives_Native.None, attrs) ->
-        let uu___ = attr_list_to_string attrs in Prims.op_Hat uu___ "_"
-    | PatWild (uu___, attrs) ->
-        let uu___1 =
-          let uu___2 = attr_list_to_string attrs in Prims.op_Hat uu___2 "_" in
-        Prims.op_Hat "#" uu___1
-    | PatConst c -> FStar_Parser_Const.const_to_string c
-    | PatVQuote t ->
-        let uu___ = term_to_string t in
-        FStar_Compiler_Util.format1 "`%%%s" uu___
-    | PatApp (p, ps) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater p pat_to_string in
-        let uu___1 = to_string_l " " pat_to_string ps in
-        FStar_Compiler_Util.format2 "(%s %s)" uu___ uu___1
-    | PatTvar (i, aq, attrs) ->
-        let uu___ = aqual_to_string aq in
-        let uu___1 = attr_list_to_string attrs in
-        let uu___2 = FStar_Ident.string_of_id i in
-        FStar_Compiler_Util.format3 "%s%s%s" uu___ uu___1 uu___2
-    | PatVar (i, aq, attrs) ->
-        let uu___ = aqual_to_string aq in
-        let uu___1 = attr_list_to_string attrs in
-        let uu___2 = FStar_Ident.string_of_id i in
-        FStar_Compiler_Util.format3 "%s%s%s" uu___ uu___1 uu___2
-    | PatName l -> FStar_Ident.string_of_lid l
-    | PatList l ->
-        let uu___ = to_string_l "; " pat_to_string l in
-        FStar_Compiler_Util.format1 "[%s]" uu___
-    | PatTuple (l, false) ->
-        let uu___ = to_string_l ", " pat_to_string l in
-        FStar_Compiler_Util.format1 "(%s)" uu___
-    | PatTuple (l, true) ->
-        let uu___ = to_string_l ", " pat_to_string l in
-        FStar_Compiler_Util.format1 "(|%s|)" uu___
-    | PatRecord l ->
-        let uu___ =
-          to_string_l "; "
-            (fun uu___1 ->
-               match uu___1 with
-               | (f, e) ->
-                   let uu___2 = FStar_Ident.string_of_lid f in
-                   let uu___3 =
-                     FStar_Compiler_Effect.op_Bar_Greater e pat_to_string in
-                   FStar_Compiler_Util.format2 "%s=%s" uu___2 uu___3) l in
-        FStar_Compiler_Util.format1 "{%s}" uu___
-    | PatOr l -> to_string_l "|\n " pat_to_string l
-    | PatOp op ->
-        let uu___ = FStar_Ident.string_of_id op in
-        FStar_Compiler_Util.format1 "(%s)" uu___
-    | PatAscribed (p, (t, FStar_Pervasives_Native.None)) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater p pat_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        FStar_Compiler_Util.format2 "(%s:%s)" uu___ uu___1
-    | PatAscribed (p, (t, FStar_Pervasives_Native.Some tac)) ->
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater p pat_to_string in
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t term_to_string in
-        let uu___2 = FStar_Compiler_Effect.op_Bar_Greater tac term_to_string in
-        FStar_Compiler_Util.format3 "(%s:%s by %s)" uu___ uu___1 uu___2
-and (attrs_opt_to_string :
-  term Prims.list FStar_Pervasives_Native.option -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> ""
-    | FStar_Pervasives_Native.Some attrs ->
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.map term_to_string attrs in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (FStar_String.concat "; ") in
-        FStar_Compiler_Util.format1 "[@ %s]" uu___1
-let rec (head_id_of_pat : pattern -> FStar_Ident.lident Prims.list) =
-  fun p ->
-    match p.pat with
-    | PatName l -> [l]
-    | PatVar (i, uu___, uu___1) ->
-        let uu___2 = FStar_Ident.lid_of_ids [i] in [uu___2]
-    | PatApp (p1, uu___) -> head_id_of_pat p1
-    | PatAscribed (p1, uu___) -> head_id_of_pat p1
-    | uu___ -> []
-let lids_of_let :
-  'uuuuu . (pattern * 'uuuuu) Prims.list -> FStar_Ident.lident Prims.list =
-  fun defs ->
-    FStar_Compiler_Effect.op_Bar_Greater defs
-      (FStar_Compiler_List.collect
-         (fun uu___ -> match uu___ with | (p, uu___1) -> head_id_of_pat p))
-let (id_of_tycon : tycon -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | TyconAbstract (i, uu___1, uu___2) -> FStar_Ident.string_of_id i
-    | TyconAbbrev (i, uu___1, uu___2, uu___3) -> FStar_Ident.string_of_id i
-    | TyconRecord (i, uu___1, uu___2, uu___3, uu___4) ->
-        FStar_Ident.string_of_id i
-    | TyconVariant (i, uu___1, uu___2, uu___3) -> FStar_Ident.string_of_id i
-let (decl_to_string : decl -> Prims.string) =
-  fun d ->
-    match d.d with
-    | TopLevelModule l ->
-        let uu___ = FStar_Ident.string_of_lid l in
-        Prims.op_Hat "module " uu___
-    | Open l ->
-        let uu___ = FStar_Ident.string_of_lid l in Prims.op_Hat "open " uu___
-    | Friend l ->
-        let uu___ = FStar_Ident.string_of_lid l in
-        Prims.op_Hat "friend " uu___
-    | Include l ->
-        let uu___ = FStar_Ident.string_of_lid l in
-        Prims.op_Hat "include " uu___
-    | ModuleAbbrev (i, l) ->
-        let uu___ = FStar_Ident.string_of_id i in
-        let uu___1 = FStar_Ident.string_of_lid l in
-        FStar_Compiler_Util.format2 "module %s = %s" uu___ uu___1
-    | TopLevelLet (uu___, pats) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = lids_of_let pats in
-            FStar_Compiler_Effect.op_Bar_Greater uu___3
-              (FStar_Compiler_List.map (fun l -> FStar_Ident.string_of_lid l)) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (FStar_String.concat ", ") in
-        Prims.op_Hat "let " uu___1
-    | Assume (i, uu___) ->
-        let uu___1 = FStar_Ident.string_of_id i in
-        Prims.op_Hat "assume " uu___1
-    | Tycon (uu___, uu___1, tys) ->
-        let uu___2 =
-          let uu___3 =
-            FStar_Compiler_Effect.op_Bar_Greater tys
-              (FStar_Compiler_List.map id_of_tycon) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3
-            (FStar_String.concat ", ") in
-        Prims.op_Hat "type " uu___2
-    | Val (i, uu___) ->
-        let uu___1 = FStar_Ident.string_of_id i in Prims.op_Hat "val " uu___1
-    | Exception (i, uu___) ->
-        let uu___1 = FStar_Ident.string_of_id i in
-        Prims.op_Hat "exception " uu___1
-    | NewEffect (DefineEffect (i, uu___, uu___1, uu___2)) ->
-        let uu___3 = FStar_Ident.string_of_id i in
-        Prims.op_Hat "new_effect " uu___3
-    | NewEffect (RedefineEffect (i, uu___, uu___1)) ->
-        let uu___2 = FStar_Ident.string_of_id i in
-        Prims.op_Hat "new_effect " uu___2
-    | LayeredEffect (DefineEffect (i, uu___, uu___1, uu___2)) ->
-        let uu___3 = FStar_Ident.string_of_id i in
-        Prims.op_Hat "layered_effect " uu___3
-    | LayeredEffect (RedefineEffect (i, uu___, uu___1)) ->
-        let uu___2 = FStar_Ident.string_of_id i in
-        Prims.op_Hat "layered_effect " uu___2
-    | Polymonadic_bind (l1, l2, l3, uu___) ->
-        let uu___1 = FStar_Ident.string_of_lid l1 in
-        let uu___2 = FStar_Ident.string_of_lid l2 in
-        let uu___3 = FStar_Ident.string_of_lid l3 in
-        FStar_Compiler_Util.format3 "polymonadic_bind (%s, %s) |> %s" uu___1
-          uu___2 uu___3
-    | Polymonadic_subcomp (l1, l2, uu___) ->
-        let uu___1 = FStar_Ident.string_of_lid l1 in
-        let uu___2 = FStar_Ident.string_of_lid l2 in
-        FStar_Compiler_Util.format2 "polymonadic_subcomp %s <: %s" uu___1
-          uu___2
-    | Splice (ids, t) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_List.map (fun i -> FStar_Ident.string_of_id i)
-                ids in
-            FStar_Compiler_Effect.op_Less_Bar (FStar_String.concat ";")
-              uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = term_to_string t in Prims.op_Hat uu___4 ")" in
-            Prims.op_Hat "] (" uu___3 in
-          Prims.op_Hat uu___1 uu___2 in
-        Prims.op_Hat "splice[" uu___
-    | SubEffect uu___ -> "sub_effect"
-    | Pragma uu___ -> "pragma"
-let (modul_to_string : modul -> Prims.string) =
-  fun m ->
-    match m with
-    | Module (uu___, decls) ->
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater decls
-            (FStar_Compiler_List.map decl_to_string) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          (FStar_String.concat "\n")
-    | Interface (uu___, decls, uu___1) ->
-        let uu___2 =
-          FStar_Compiler_Effect.op_Bar_Greater decls
-            (FStar_Compiler_List.map decl_to_string) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___2
-          (FStar_String.concat "\n")
-let (decl_is_val : FStar_Ident.ident -> decl -> Prims.bool) =
-  fun id ->
-    fun decl1 ->
-      match decl1.d with
-      | Val (id', uu___) -> FStar_Ident.ident_equals id id'
-      | uu___ -> false
-let (thunk : term -> term) =
-  fun ens ->
-    let wildpat =
-      mk_pattern (PatWild (FStar_Pervasives_Native.None, [])) ens.range in
-    mk_term (Abs ([wildpat], ens)) ens.range Expr
-let (ident_of_binder :
-  FStar_Compiler_Range.range -> binder -> FStar_Ident.ident) =
-  fun r ->
-    fun b ->
-      match b.b with
-      | Variable i -> i
-      | TVariable i -> i
-      | Annotated (i, uu___) -> i
-      | TAnnotated (i, uu___) -> i
-      | NoName uu___ ->
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_MissingQuantifierBinder,
-              "Wildcard binders in quantifiers are not allowed") r
-let (idents_of_binders :
-  binder Prims.list ->
-    FStar_Compiler_Range.range -> FStar_Ident.ident Prims.list)
-  =
-  fun bs ->
-    fun r ->
-      FStar_Compiler_Effect.op_Bar_Greater bs
-        (FStar_Compiler_List.map (ident_of_binder r))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Parser_Const.ml b/src/ocaml-output/FStar_Parser_Const.ml
deleted file mode 100644
index 5aa9301aeb7..00000000000
--- a/src/ocaml-output/FStar_Parser_Const.ml
+++ /dev/null
@@ -1,601 +0,0 @@
-open Prims
-let (p2l : FStar_Ident.path -> FStar_Ident.lident) =
-  fun l -> FStar_Ident.lid_of_path l FStar_Compiler_Range.dummyRange
-let (pconst : Prims.string -> FStar_Ident.lident) = fun s -> p2l ["Prims"; s]
-let (psconst : Prims.string -> FStar_Ident.lident) =
-  fun s -> p2l ["FStar"; "Pervasives"; s]
-let (psnconst : Prims.string -> FStar_Ident.lident) =
-  fun s -> p2l ["FStar"; "Pervasives"; "Native"; s]
-let (prims_lid : FStar_Ident.lident) = p2l ["Prims"]
-let (pervasives_native_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "Native"]
-let (pervasives_lid : FStar_Ident.lident) = p2l ["FStar"; "Pervasives"]
-let (fstar_ns_lid : FStar_Ident.lident) = p2l ["FStar"]
-let (bool_lid : FStar_Ident.lident) = pconst "bool"
-let (unit_lid : FStar_Ident.lident) = pconst "unit"
-let (squash_lid : FStar_Ident.lident) = pconst "squash"
-let (auto_squash_lid : FStar_Ident.lident) = pconst "auto_squash"
-let (string_lid : FStar_Ident.lident) = pconst "string"
-let (bytes_lid : FStar_Ident.lident) = pconst "bytes"
-let (int_lid : FStar_Ident.lident) = pconst "int"
-let (exn_lid : FStar_Ident.lident) = pconst "exn"
-let (list_lid : FStar_Ident.lident) = pconst "list"
-let (immutable_array_t_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "ImmutableArray"; "Base"; "t"]
-let (immutable_array_of_list_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "ImmutableArray"; "Base"; "of_list"]
-let (immutable_array_length_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "ImmutableArray"; "Base"; "length"]
-let (immutable_array_index_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "ImmutableArray"; "Base"; "index"]
-let (eqtype_lid : FStar_Ident.lident) = pconst "eqtype"
-let (option_lid : FStar_Ident.lident) = psnconst "option"
-let (either_lid : FStar_Ident.lident) = psconst "either"
-let (pattern_lid : FStar_Ident.lident) = psconst "pattern"
-let (lex_t_lid : FStar_Ident.lident) = pconst "lex_t"
-let (precedes_lid : FStar_Ident.lident) = pconst "precedes"
-let (smtpat_lid : FStar_Ident.lident) = psconst "smt_pat"
-let (smtpatOr_lid : FStar_Ident.lident) = psconst "smt_pat_or"
-let (monadic_lid : FStar_Ident.lident) = pconst "M"
-let (spinoff_lid : FStar_Ident.lident) = psconst "spinoff"
-let (inl_lid : FStar_Ident.lident) = psconst "Inl"
-let (inr_lid : FStar_Ident.lident) = psconst "Inr"
-let (int8_lid : FStar_Ident.lident) = p2l ["FStar"; "Int8"; "t"]
-let (uint8_lid : FStar_Ident.lident) = p2l ["FStar"; "UInt8"; "t"]
-let (int16_lid : FStar_Ident.lident) = p2l ["FStar"; "Int16"; "t"]
-let (uint16_lid : FStar_Ident.lident) = p2l ["FStar"; "UInt16"; "t"]
-let (int32_lid : FStar_Ident.lident) = p2l ["FStar"; "Int32"; "t"]
-let (uint32_lid : FStar_Ident.lident) = p2l ["FStar"; "UInt32"; "t"]
-let (int64_lid : FStar_Ident.lident) = p2l ["FStar"; "Int64"; "t"]
-let (uint64_lid : FStar_Ident.lident) = p2l ["FStar"; "UInt64"; "t"]
-let (salloc_lid : FStar_Ident.lident) = p2l ["FStar"; "ST"; "salloc"]
-let (swrite_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "ST"; "op_Colon_Equals"]
-let (sread_lid : FStar_Ident.lident) = p2l ["FStar"; "ST"; "op_Bang"]
-let (max_lid : FStar_Ident.lident) = p2l ["max"]
-let (real_lid : FStar_Ident.lident) = p2l ["FStar"; "Real"; "real"]
-let (float_lid : FStar_Ident.lident) = p2l ["FStar"; "Float"; "float"]
-let (char_lid : FStar_Ident.lident) = p2l ["FStar"; "Char"; "char"]
-let (heap_lid : FStar_Ident.lident) = p2l ["FStar"; "Heap"; "heap"]
-let (logical_lid : FStar_Ident.lident) = pconst "logical"
-let (smt_theory_symbol_attr_lid : FStar_Ident.lident) =
-  pconst "smt_theory_symbol"
-let (true_lid : FStar_Ident.lident) = pconst "l_True"
-let (false_lid : FStar_Ident.lident) = pconst "l_False"
-let (and_lid : FStar_Ident.lident) = pconst "l_and"
-let (or_lid : FStar_Ident.lident) = pconst "l_or"
-let (not_lid : FStar_Ident.lident) = pconst "l_not"
-let (imp_lid : FStar_Ident.lident) = pconst "l_imp"
-let (iff_lid : FStar_Ident.lident) = pconst "l_iff"
-let (ite_lid : FStar_Ident.lident) = pconst "l_ITE"
-let (exists_lid : FStar_Ident.lident) = pconst "l_Exists"
-let (forall_lid : FStar_Ident.lident) = pconst "l_Forall"
-let (haseq_lid : FStar_Ident.lident) = pconst "hasEq"
-let (b2t_lid : FStar_Ident.lident) = pconst "b2t"
-let (admit_lid : FStar_Ident.lident) = pconst "admit"
-let (magic_lid : FStar_Ident.lident) = pconst "magic"
-let (has_type_lid : FStar_Ident.lident) = pconst "has_type"
-let (c_true_lid : FStar_Ident.lident) = pconst "trivial"
-let (empty_type_lid : FStar_Ident.lident) = pconst "empty"
-let (c_and_lid : FStar_Ident.lident) = pconst "pair"
-let (c_or_lid : FStar_Ident.lident) = pconst "sum"
-let (dtuple2_lid : FStar_Ident.lident) = pconst "dtuple2"
-let (eq2_lid : FStar_Ident.lident) = pconst "eq2"
-let (eq3_lid : FStar_Ident.lident) = pconst "op_Equals_Equals_Equals"
-let (c_eq2_lid : FStar_Ident.lident) = pconst "equals"
-let (cons_lid : FStar_Ident.lident) = pconst "Cons"
-let (nil_lid : FStar_Ident.lident) = pconst "Nil"
-let (some_lid : FStar_Ident.lident) = psnconst "Some"
-let (none_lid : FStar_Ident.lident) = psnconst "None"
-let (assume_lid : FStar_Ident.lident) = pconst "_assume"
-let (assert_lid : FStar_Ident.lident) = pconst "_assert"
-let (pure_wp_lid : FStar_Ident.lident) = pconst "pure_wp"
-let (pure_wp_monotonic_lid : FStar_Ident.lident) = pconst "pure_wp_monotonic"
-let (pure_wp_monotonic0_lid : FStar_Ident.lident) =
-  pconst "pure_wp_monotonic0"
-let (trivial_pure_post_lid : FStar_Ident.lident) =
-  psconst "trivial_pure_post"
-let (pure_assert_wp_lid : FStar_Ident.lident) = pconst "pure_assert_wp0"
-let (pure_assume_wp_lid : FStar_Ident.lident) = pconst "pure_assume_wp0"
-let (assert_norm_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "assert_norm"]
-let (list_append_lid : FStar_Ident.lident) = p2l ["FStar"; "List"; "append"]
-let (list_tot_append_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "List"; "Tot"; "Base"; "append"]
-let (id_lid : FStar_Ident.lident) = psconst "id"
-let (c2l : Prims.string -> FStar_Ident.lident) =
-  fun s -> p2l ["FStar"; "Char"; s]
-let (char_u32_of_char : FStar_Ident.lident) = c2l "u32_of_char"
-let (s2l : Prims.string -> FStar_Ident.lident) =
-  fun n -> p2l ["FStar"; "String"; n]
-let (string_list_of_string_lid : FStar_Ident.lident) = s2l "list_of_string"
-let (string_string_of_list_lid : FStar_Ident.lident) = s2l "string_of_list"
-let (string_make_lid : FStar_Ident.lident) = s2l "make"
-let (string_split_lid : FStar_Ident.lident) = s2l "split"
-let (string_concat_lid : FStar_Ident.lident) = s2l "concat"
-let (string_compare_lid : FStar_Ident.lident) = s2l "compare"
-let (string_lowercase_lid : FStar_Ident.lident) = s2l "lowercase"
-let (string_uppercase_lid : FStar_Ident.lident) = s2l "uppercase"
-let (string_index_lid : FStar_Ident.lident) = s2l "index"
-let (string_index_of_lid : FStar_Ident.lident) = s2l "index_of"
-let (string_sub_lid : FStar_Ident.lident) = s2l "sub"
-let (prims_strcat_lid : FStar_Ident.lident) = pconst "strcat"
-let (prims_op_Hat_lid : FStar_Ident.lident) = pconst "op_Hat"
-let (let_in_typ : FStar_Ident.lident) = p2l ["Prims"; "Let"]
-let (string_of_int_lid : FStar_Ident.lident) = p2l ["Prims"; "string_of_int"]
-let (string_of_bool_lid : FStar_Ident.lident) =
-  p2l ["Prims"; "string_of_bool"]
-let (string_compare : FStar_Ident.lident) =
-  p2l ["FStar"; "String"; "compare"]
-let (order_lid : FStar_Ident.lident) = p2l ["FStar"; "Order"; "order"]
-let (vconfig_lid : FStar_Ident.lident) = p2l ["FStar"; "VConfig"; "vconfig"]
-let (mkvconfig_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "VConfig"; "Mkvconfig"]
-let (op_Eq : FStar_Ident.lident) = pconst "op_Equality"
-let (op_notEq : FStar_Ident.lident) = pconst "op_disEquality"
-let (op_LT : FStar_Ident.lident) = pconst "op_LessThan"
-let (op_LTE : FStar_Ident.lident) = pconst "op_LessThanOrEqual"
-let (op_GT : FStar_Ident.lident) = pconst "op_GreaterThan"
-let (op_GTE : FStar_Ident.lident) = pconst "op_GreaterThanOrEqual"
-let (op_Subtraction : FStar_Ident.lident) = pconst "op_Subtraction"
-let (op_Minus : FStar_Ident.lident) = pconst "op_Minus"
-let (op_Addition : FStar_Ident.lident) = pconst "op_Addition"
-let (op_Multiply : FStar_Ident.lident) = pconst "op_Multiply"
-let (op_Division : FStar_Ident.lident) = pconst "op_Division"
-let (op_Modulus : FStar_Ident.lident) = pconst "op_Modulus"
-let (op_And : FStar_Ident.lident) = pconst "op_AmpAmp"
-let (op_Or : FStar_Ident.lident) = pconst "op_BarBar"
-let (op_Negation : FStar_Ident.lident) = pconst "op_Negation"
-let (real_const : Prims.string -> FStar_Ident.lident) =
-  fun s -> p2l ["FStar"; "Real"; s]
-let (real_op_LT : FStar_Ident.lident) = real_const "op_Less_Dot"
-let (real_op_LTE : FStar_Ident.lident) = real_const "op_Less_Equals_Dot"
-let (real_op_GT : FStar_Ident.lident) = real_const "op_Greater_Dot"
-let (real_op_GTE : FStar_Ident.lident) = real_const "op_Greater_Equals_Dot"
-let (real_op_Subtraction : FStar_Ident.lident) =
-  real_const "op_Subtraction_Dot"
-let (real_op_Addition : FStar_Ident.lident) = real_const "op_Plus_Dot"
-let (real_op_Multiply : FStar_Ident.lident) = real_const "op_Star_Dot"
-let (real_op_Division : FStar_Ident.lident) = real_const "op_Slash_Dot"
-let (real_of_int : FStar_Ident.lident) = real_const "of_int"
-let (bvconst : Prims.string -> FStar_Ident.lident) =
-  fun s -> p2l ["FStar"; "BV"; s]
-let (bv_t_lid : FStar_Ident.lident) = bvconst "bv_t"
-let (nat_to_bv_lid : FStar_Ident.lident) = bvconst "int2bv"
-let (bv_to_nat_lid : FStar_Ident.lident) = bvconst "bv2int"
-let (bv_and_lid : FStar_Ident.lident) = bvconst "bvand"
-let (bv_xor_lid : FStar_Ident.lident) = bvconst "bvxor"
-let (bv_or_lid : FStar_Ident.lident) = bvconst "bvor"
-let (bv_add_lid : FStar_Ident.lident) = bvconst "bvadd"
-let (bv_sub_lid : FStar_Ident.lident) = bvconst "bvsub"
-let (bv_shift_left_lid : FStar_Ident.lident) = bvconst "bvshl"
-let (bv_shift_right_lid : FStar_Ident.lident) = bvconst "bvshr"
-let (bv_udiv_lid : FStar_Ident.lident) = bvconst "bvdiv"
-let (bv_mod_lid : FStar_Ident.lident) = bvconst "bvmod"
-let (bv_mul_lid : FStar_Ident.lident) = bvconst "bvmul"
-let (bv_ult_lid : FStar_Ident.lident) = bvconst "bvult"
-let (bv_uext_lid : FStar_Ident.lident) = bvconst "bv_uext"
-let (array_lid : FStar_Ident.lident) = p2l ["FStar"; "Array"; "array"]
-let (array_of_list_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Array"; "of_list"]
-let (st_lid : FStar_Ident.lident) = p2l ["FStar"; "ST"]
-let (write_lid : FStar_Ident.lident) = p2l ["FStar"; "ST"; "write"]
-let (read_lid : FStar_Ident.lident) = p2l ["FStar"; "ST"; "read"]
-let (alloc_lid : FStar_Ident.lident) = p2l ["FStar"; "ST"; "alloc"]
-let (op_ColonEq : FStar_Ident.lident) =
-  p2l ["FStar"; "ST"; "op_Colon_Equals"]
-let (ref_lid : FStar_Ident.lident) = p2l ["FStar"; "Heap"; "ref"]
-let (heap_addr_of_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Heap"; "addr_of"]
-let (set_empty : FStar_Ident.lident) = p2l ["FStar"; "Set"; "empty"]
-let (set_singleton : FStar_Ident.lident) = p2l ["FStar"; "Set"; "singleton"]
-let (set_union : FStar_Ident.lident) = p2l ["FStar"; "Set"; "union"]
-let (fstar_hyperheap_lid : FStar_Ident.lident) = p2l ["FStar"; "HyperHeap"]
-let (rref_lid : FStar_Ident.lident) = p2l ["FStar"; "HyperHeap"; "rref"]
-let (erased_lid : FStar_Ident.lident) = p2l ["FStar"; "Ghost"; "erased"]
-let (effect_PURE_lid : FStar_Ident.lident) = pconst "PURE"
-let (effect_Pure_lid : FStar_Ident.lident) = pconst "Pure"
-let (effect_Tot_lid : FStar_Ident.lident) = pconst "Tot"
-let (effect_Lemma_lid : FStar_Ident.lident) = psconst "Lemma"
-let (effect_GTot_lid : FStar_Ident.lident) = pconst "GTot"
-let (effect_GHOST_lid : FStar_Ident.lident) = pconst "GHOST"
-let (effect_Ghost_lid : FStar_Ident.lident) = pconst "Ghost"
-let (effect_DIV_lid : FStar_Ident.lident) = psconst "DIV"
-let (effect_Div_lid : FStar_Ident.lident) = psconst "Div"
-let (effect_Dv_lid : FStar_Ident.lident) = psconst "Dv"
-let (compiler_effect_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Compiler"; "Effect"]
-let (compiler_effect_ALL_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Compiler"; "Effect"; "ALL"]
-let (compiler_effect_ML_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Compiler"; "Effect"; "ML"]
-let (compiler_effect_failwith_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Compiler"; "Effect"; "failwith"]
-let (compiler_effect_try_with_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Compiler"; "Effect"; "try_with"]
-let (all_lid : FStar_Ident.lident) = p2l ["FStar"; "All"]
-let (all_ALL_lid : FStar_Ident.lident) = p2l ["FStar"; "All"; "All"]
-let (all_ML_lid : FStar_Ident.lident) = p2l ["FStar"; "All"; "ML"]
-let (all_failwith_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "All"; "failwith"]
-let (all_try_with_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "All"; "try_with"]
-let (effect_ALL_lid : unit -> FStar_Ident.lident) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.ml_ish () in
-    if uu___1 then compiler_effect_ALL_lid else all_lid
-let (effect_ML_lid : unit -> FStar_Ident.lident) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.ml_ish () in
-    if uu___1 then compiler_effect_ML_lid else all_ML_lid
-let (failwith_lid : unit -> FStar_Ident.lident) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.ml_ish () in
-    if uu___1 then compiler_effect_failwith_lid else all_failwith_lid
-let (try_with_lid : unit -> FStar_Ident.lident) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.ml_ish () in
-    if uu___1 then compiler_effect_try_with_lid else all_try_with_lid
-let (as_requires : FStar_Ident.lident) = pconst "as_requires"
-let (as_ensures : FStar_Ident.lident) = pconst "as_ensures"
-let (decreases_lid : FStar_Ident.lident) = pconst "decreases"
-let (inspect : FStar_Ident.lident) =
-  p2l ["FStar"; "Tactics"; "Builtins"; "inspect"]
-let (pack : FStar_Ident.lident) =
-  p2l ["FStar"; "Tactics"; "Builtins"; "pack"]
-let (binder_to_term : FStar_Ident.lident) =
-  p2l ["FStar"; "Tactics"; "Derived"; "binder_to_term"]
-let (reveal : FStar_Ident.lident) = p2l ["FStar"; "Ghost"; "reveal"]
-let (hide : FStar_Ident.lident) = p2l ["FStar"; "Ghost"; "hide"]
-let (term_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Reflection"; "Types"; "term"]
-let (term_view_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Reflection"; "Data"; "term_view"]
-let (decls_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Reflection"; "Data"; "decls"]
-let (ctx_uvar_and_subst_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Reflection"; "Types"; "ctx_uvar_and_subst"]
-let (universe_uvar_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Reflection"; "Types"; "universe_uvar"]
-let (range_lid : FStar_Ident.lident) = pconst "range"
-let (range_of_lid : FStar_Ident.lident) = pconst "range_of"
-let (labeled_lid : FStar_Ident.lident) = pconst "labeled"
-let (range_0 : FStar_Ident.lident) = pconst "range_0"
-let (guard_free : FStar_Ident.lident) = pconst "guard_free"
-let (inversion_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "inversion"]
-let (with_type_lid : FStar_Ident.lident) = psconst "with_type"
-let (normalize : FStar_Ident.lident) = psconst "normalize"
-let (normalize_term : FStar_Ident.lident) = psconst "normalize_term"
-let (norm : FStar_Ident.lident) = psconst "norm"
-let (steps_simpl : FStar_Ident.lident) = psconst "simplify"
-let (steps_weak : FStar_Ident.lident) = psconst "weak"
-let (steps_hnf : FStar_Ident.lident) = psconst "hnf"
-let (steps_primops : FStar_Ident.lident) = psconst "primops"
-let (steps_zeta : FStar_Ident.lident) = psconst "zeta"
-let (steps_zeta_full : FStar_Ident.lident) = psconst "zeta_full"
-let (steps_iota : FStar_Ident.lident) = psconst "iota"
-let (steps_delta : FStar_Ident.lident) = psconst "delta"
-let (steps_reify : FStar_Ident.lident) = psconst "reify_"
-let (steps_unfoldonly : FStar_Ident.lident) = psconst "delta_only"
-let (steps_unfoldfully : FStar_Ident.lident) = psconst "delta_fully"
-let (steps_unfoldattr : FStar_Ident.lident) = psconst "delta_attr"
-let (steps_unfoldqual : FStar_Ident.lident) = psconst "delta_qualifier"
-let (steps_unfoldnamespace : FStar_Ident.lident) = psconst "delta_namespace"
-let (steps_unascribe : FStar_Ident.lident) = psconst "unascribe"
-let (steps_nbe : FStar_Ident.lident) = psconst "nbe"
-let (steps_unmeta : FStar_Ident.lident) = psconst "unmeta"
-let (deprecated_attr : FStar_Ident.lident) = pconst "deprecated"
-let (warn_on_use_attr : FStar_Ident.lident) = pconst "warn_on_use"
-let (inline_let_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "inline_let"]
-let (rename_let_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "rename_let"]
-let (plugin_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "plugin"]
-let (tcnorm_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "tcnorm"]
-let (dm4f_bind_range_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "dm4f_bind_range"]
-let (must_erase_for_extraction_attr : FStar_Ident.lident) =
-  psconst "must_erase_for_extraction"
-let (strict_on_arguments_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "strict_on_arguments"]
-let (resolve_implicits_attr_string : Prims.string) =
-  "FStar.Pervasives.resolve_implicits"
-let (override_resolve_implicits_handler_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "override_resolve_implicits_handler"]
-let (handle_smt_goals_attr : FStar_Ident.lident) = psconst "handle_smt_goals"
-let (handle_smt_goals_attr_string : Prims.string) =
-  "FStar.Pervasives.handle_smt_goals"
-let (erasable_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "erasable"]
-let (comment_attr : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "Comment"]
-let (fail_attr : FStar_Ident.lident) = psconst "expect_failure"
-let (fail_lax_attr : FStar_Ident.lident) = psconst "expect_lax_failure"
-let (tcdecltime_attr : FStar_Ident.lident) = psconst "tcdecltime"
-let (noextract_to_attr : FStar_Ident.lident) = psconst "noextract_to"
-let (unifier_hint_injective_lid : FStar_Ident.lident) =
-  psconst "unifier_hint_injective"
-let (normalize_for_extraction_lid : FStar_Ident.lident) =
-  psconst "normalize_for_extraction"
-let (postprocess_with : FStar_Ident.lident) =
-  p2l ["FStar"; "Tactics"; "Effect"; "postprocess_with"]
-let (preprocess_with : FStar_Ident.lident) =
-  p2l ["FStar"; "Tactics"; "Effect"; "preprocess_with"]
-let (postprocess_extr_with : FStar_Ident.lident) =
-  p2l ["FStar"; "Tactics"; "Effect"; "postprocess_for_extraction_with"]
-let (check_with_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Reflection"; "Builtins"; "check_with"]
-    FStar_Compiler_Range.dummyRange
-let (commute_nested_matches_lid : FStar_Ident.lident) =
-  psconst "commute_nested_matches"
-let (remove_unused_type_parameters_lid : FStar_Ident.lident) =
-  psconst "remove_unused_type_parameters"
-let (ite_soundness_by_attr : FStar_Ident.lident) = psconst "ite_soundness_by"
-let (default_effect_attr : FStar_Ident.lident) = psconst "default_effect"
-let (top_level_effect_attr : FStar_Ident.lident) = psconst "top_level_effect"
-let (effect_parameter_attr : FStar_Ident.lident) = psconst "effect_param"
-let (bind_has_range_args_attr : FStar_Ident.lident) =
-  psconst "bind_has_range_args"
-let (binder_strictly_positive_attr : FStar_Ident.lident) =
-  psconst "strictly_positive"
-let (no_auto_projectors_attr : FStar_Ident.lident) =
-  psconst "no_auto_projectors"
-let (no_subtping_attr_lid : FStar_Ident.lident) = psconst "no_subtyping"
-let (attr_substitute_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "Pervasives"; "Substitute"]
-let (well_founded_relation_lid : FStar_Ident.lident) =
-  p2l ["FStar"; "WellFounded"; "well_founded_relation"]
-let (gen_reset : ((unit -> Prims.int) * (unit -> unit))) =
-  let x = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let gen uu___ = FStar_Compiler_Util.incr x; FStar_Compiler_Util.read x in
-  let reset uu___ = FStar_Compiler_Util.write x Prims.int_zero in
-  (gen, reset)
-let (next_id : unit -> Prims.int) = FStar_Pervasives_Native.fst gen_reset
-let (sli : FStar_Ident.lident -> Prims.string) =
-  fun l ->
-    let uu___ = FStar_Options.print_real_names () in
-    if uu___
-    then FStar_Ident.string_of_lid l
-    else
-      (let uu___2 = FStar_Ident.ident_of_lid l in
-       FStar_Ident.string_of_id uu___2)
-let (const_to_string : FStar_Const.sconst -> Prims.string) =
-  fun x ->
-    match x with
-    | FStar_Const.Const_effect -> "Effect"
-    | FStar_Const.Const_unit -> "()"
-    | FStar_Const.Const_bool b -> if b then "true" else "false"
-    | FStar_Const.Const_real r -> FStar_String.op_Hat r "R"
-    | FStar_Const.Const_string (s, uu___) ->
-        FStar_Compiler_Util.format1 "\"%s\"" s
-    | FStar_Const.Const_int (x1, uu___) -> x1
-    | FStar_Const.Const_char c ->
-        let uu___ =
-          FStar_String.op_Hat (FStar_Compiler_Util.string_of_char c) "'" in
-        FStar_String.op_Hat "'" uu___
-    | FStar_Const.Const_range r -> FStar_Compiler_Range.string_of_range r
-    | FStar_Const.Const_range_of -> "range_of"
-    | FStar_Const.Const_set_range_of -> "set_range_of"
-    | FStar_Const.Const_reify -> "reify"
-    | FStar_Const.Const_reflect l ->
-        let uu___ = sli l in
-        FStar_Compiler_Util.format1 "[[%s.reflect]]" uu___
-let (mk_tuple_lid :
-  Prims.int -> FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun n ->
-    fun r ->
-      let t =
-        let uu___ = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "tuple%s" uu___ in
-      let uu___ = psnconst t in FStar_Ident.set_lid_range uu___ r
-let (lid_tuple2 : FStar_Ident.lident) =
-  mk_tuple_lid (Prims.of_int (2)) FStar_Compiler_Range.dummyRange
-let (lid_tuple3 : FStar_Ident.lident) =
-  mk_tuple_lid (Prims.of_int (3)) FStar_Compiler_Range.dummyRange
-let (is_tuple_constructor_string : Prims.string -> Prims.bool) =
-  fun s -> FStar_Compiler_Util.starts_with s "FStar.Pervasives.Native.tuple"
-let (is_tuple_constructor_id : FStar_Ident.ident -> Prims.bool) =
-  fun id ->
-    let uu___ = FStar_Ident.string_of_id id in
-    is_tuple_constructor_string uu___
-let (is_tuple_constructor_lid : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    let uu___ = FStar_Ident.string_of_lid lid in
-    is_tuple_constructor_string uu___
-let (mk_tuple_data_lid :
-  Prims.int -> FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun n ->
-    fun r ->
-      let t =
-        let uu___ = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "Mktuple%s" uu___ in
-      let uu___ = psnconst t in FStar_Ident.set_lid_range uu___ r
-let (lid_Mktuple2 : FStar_Ident.lident) =
-  mk_tuple_data_lid (Prims.of_int (2)) FStar_Compiler_Range.dummyRange
-let (lid_Mktuple3 : FStar_Ident.lident) =
-  mk_tuple_data_lid (Prims.of_int (3)) FStar_Compiler_Range.dummyRange
-let (is_tuple_datacon_string : Prims.string -> Prims.bool) =
-  fun s ->
-    FStar_Compiler_Util.starts_with s "FStar.Pervasives.Native.Mktuple"
-let (is_tuple_datacon_id : FStar_Ident.ident -> Prims.bool) =
-  fun id ->
-    let uu___ = FStar_Ident.string_of_id id in is_tuple_datacon_string uu___
-let (is_tuple_datacon_lid : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    let uu___ = FStar_Ident.string_of_lid lid in
-    is_tuple_datacon_string uu___
-let (is_tuple_data_lid : FStar_Ident.lident -> Prims.int -> Prims.bool) =
-  fun f ->
-    fun n ->
-      let uu___ = mk_tuple_data_lid n FStar_Compiler_Range.dummyRange in
-      FStar_Ident.lid_equals f uu___
-let (is_tuple_data_lid' : FStar_Ident.lident -> Prims.bool) =
-  fun f ->
-    let uu___ = FStar_Ident.string_of_lid f in is_tuple_datacon_string uu___
-let (mod_prefix_dtuple : Prims.int -> Prims.string -> FStar_Ident.lident) =
-  fun n -> if n = (Prims.of_int (2)) then pconst else psconst
-let (mk_dtuple_lid :
-  Prims.int -> FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun n ->
-    fun r ->
-      let t =
-        let uu___ = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "dtuple%s" uu___ in
-      let uu___ = let uu___1 = mod_prefix_dtuple n in uu___1 t in
-      FStar_Ident.set_lid_range uu___ r
-let (is_dtuple_constructor_string : Prims.string -> Prims.bool) =
-  fun s ->
-    (s = "Prims.dtuple2") ||
-      (FStar_Compiler_Util.starts_with s "FStar.Pervasives.dtuple")
-let (is_dtuple_constructor_lid : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    let uu___ = FStar_Ident.string_of_lid lid in
-    is_dtuple_constructor_string uu___
-let (mk_dtuple_data_lid :
-  Prims.int -> FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun n ->
-    fun r ->
-      let t =
-        let uu___ = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "Mkdtuple%s" uu___ in
-      let uu___ = let uu___1 = mod_prefix_dtuple n in uu___1 t in
-      FStar_Ident.set_lid_range uu___ r
-let (is_dtuple_datacon_string : Prims.string -> Prims.bool) =
-  fun s ->
-    (s = "Prims.Mkdtuple2") ||
-      (FStar_Compiler_Util.starts_with s "FStar.Pervasives.Mkdtuple")
-let (is_dtuple_data_lid : FStar_Ident.lident -> Prims.int -> Prims.bool) =
-  fun f ->
-    fun n ->
-      let uu___ = mk_dtuple_data_lid n FStar_Compiler_Range.dummyRange in
-      FStar_Ident.lid_equals f uu___
-let (is_dtuple_data_lid' : FStar_Ident.lident -> Prims.bool) =
-  fun f ->
-    let uu___ = FStar_Ident.string_of_lid f in is_dtuple_datacon_string uu___
-let (is_name : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    let c =
-      let uu___ =
-        let uu___1 = FStar_Ident.ident_of_lid lid in
-        FStar_Ident.string_of_id uu___1 in
-      FStar_Compiler_Util.char_at uu___ Prims.int_zero in
-    FStar_Compiler_Util.is_upper c
-let (fstar_tactics_lid' : Prims.string Prims.list -> FStar_Ident.lid) =
-  fun s ->
-    FStar_Ident.lid_of_path
-      (FStar_Compiler_List.op_At ["FStar"; "Tactics"] s)
-      FStar_Compiler_Range.dummyRange
-let (fstar_tactics_lid : Prims.string -> FStar_Ident.lid) =
-  fun s -> fstar_tactics_lid' [s]
-let (tac_lid : FStar_Ident.lid) = fstar_tactics_lid' ["Effect"; "tac"]
-let (tactic_lid : FStar_Ident.lid) = fstar_tactics_lid' ["Effect"; "tactic"]
-let (mk_class_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Typeclasses"; "mk_class"]
-let (tcresolve_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Typeclasses"; "tcresolve"]
-let (tcclass_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Typeclasses"; "tcclass"]
-let (tcinstance_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Typeclasses"; "tcinstance"]
-let (no_method_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Typeclasses"; "no_method"]
-let (effect_TAC_lid : FStar_Ident.lid) = fstar_tactics_lid' ["Effect"; "TAC"]
-let (effect_Tac_lid : FStar_Ident.lid) = fstar_tactics_lid' ["Effect"; "Tac"]
-let (by_tactic_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Effect"; "with_tactic"]
-let (rewrite_by_tactic_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Effect"; "rewrite_with_tactic"]
-let (synth_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Effect"; "synth_by_tactic"]
-let (assert_by_tactic_lid : FStar_Ident.lid) =
-  fstar_tactics_lid' ["Effect"; "assert_by_tactic"]
-let (fstar_syntax_syntax_term : FStar_Ident.lident) =
-  FStar_Ident.lid_of_str "FStar.Syntax.Syntax.term"
-let (binder_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Reflection"; "Types"; "binder"]
-    FStar_Compiler_Range.dummyRange
-let (binders_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Reflection"; "Types"; "binders"]
-    FStar_Compiler_Range.dummyRange
-let (bv_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Reflection"; "Types"; "bv"]
-    FStar_Compiler_Range.dummyRange
-let (fv_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Reflection"; "Types"; "fv"]
-    FStar_Compiler_Range.dummyRange
-let (norm_step_lid : FStar_Ident.lident) = psconst "norm_step"
-let (calc_lid : Prims.string -> FStar_Ident.lid) =
-  fun i ->
-    FStar_Ident.lid_of_path ["FStar"; "Calc"; i]
-      FStar_Compiler_Range.dummyRange
-let (calc_init_lid : FStar_Ident.lid) = calc_lid "calc_init"
-let (calc_step_lid : FStar_Ident.lid) = calc_lid "calc_step"
-let (calc_finish_lid : FStar_Ident.lid) = calc_lid "calc_finish"
-let (calc_push_impl_lid : FStar_Ident.lid) = calc_lid "calc_push_impl"
-let (classical_sugar_lid : Prims.string -> FStar_Ident.lid) =
-  fun i ->
-    FStar_Ident.lid_of_path ["FStar"; "Classical"; "Sugar"; i]
-      FStar_Compiler_Range.dummyRange
-let (forall_intro_lid : FStar_Ident.lid) = classical_sugar_lid "forall_intro"
-let (exists_intro_lid : FStar_Ident.lid) = classical_sugar_lid "exists_intro"
-let (implies_intro_lid : FStar_Ident.lid) =
-  classical_sugar_lid "implies_intro"
-let (or_intro_left_lid : FStar_Ident.lid) =
-  classical_sugar_lid "or_intro_left"
-let (or_intro_right_lid : FStar_Ident.lid) =
-  classical_sugar_lid "or_intro_right"
-let (and_intro_lid : FStar_Ident.lid) = classical_sugar_lid "and_intro"
-let (forall_elim_lid : FStar_Ident.lid) = classical_sugar_lid "forall_elim"
-let (exists_elim_lid : FStar_Ident.lid) = classical_sugar_lid "exists_elim"
-let (implies_elim_lid : FStar_Ident.lid) = classical_sugar_lid "implies_elim"
-let (or_elim_lid : FStar_Ident.lid) = classical_sugar_lid "or_elim"
-let (and_elim_lid : FStar_Ident.lid) = classical_sugar_lid "and_elim"
-let (match_returns_def_name : Prims.string) =
-  FStar_String.op_Hat FStar_Ident.reserved_prefix "_ret_"
-let (layered_effect_reify_val_lid :
-  FStar_Ident.lident -> FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun eff_name ->
-    fun r ->
-      let ns = FStar_Ident.ns_of_lid eff_name in
-      let reify_fn_name =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater eff_name
-              FStar_Ident.ident_of_lid in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Ident.string_of_id in
-        FStar_String.op_Hat "reify___" uu___ in
-      let uu___ = FStar_Ident.mk_ident (reify_fn_name, r) in
-      FStar_Ident.lid_of_ns_and_id ns uu___
-let (steel_memory_inv_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "Memory"; "inv"]
-    FStar_Compiler_Range.dummyRange
-let (steel_new_invariant_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "Effect"; "Atomic"; "new_invariant"]
-    FStar_Compiler_Range.dummyRange
-let (steel_st_new_invariant_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "ST"; "Util"; "new_invariant"]
-    FStar_Compiler_Range.dummyRange
-let (steel_with_invariant_g_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "Effect"; "Atomic"; "with_invariant_g"]
-    FStar_Compiler_Range.dummyRange
-let (steel_st_with_invariant_g_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "ST"; "Util"; "with_invariant_g"]
-    FStar_Compiler_Range.dummyRange
-let (steel_with_invariant_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "Effect"; "Atomic"; "with_invariant"]
-    FStar_Compiler_Range.dummyRange
-let (steel_st_with_invariant_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Steel"; "ST"; "Util"; "with_invariant"]
-    FStar_Compiler_Range.dummyRange
-let (fext_lid : Prims.string -> FStar_Ident.lident) =
-  fun s ->
-    FStar_Ident.lid_of_path ["FStar"; "FunctionalExtensionality"; s]
-      FStar_Compiler_Range.dummyRange
-let (fext_on_domain_lid : FStar_Ident.lident) = fext_lid "on_domain"
-let (fext_on_dom_lid : FStar_Ident.lident) = fext_lid "on_dom"
-let (fext_on_domain_g_lid : FStar_Ident.lident) = fext_lid "on_domain_g"
-let (fext_on_dom_g_lid : FStar_Ident.lident) = fext_lid "on_dom_g"
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Parser_Dep.ml b/src/ocaml-output/FStar_Parser_Dep.ml
deleted file mode 100644
index aeb17a7824b..00000000000
--- a/src/ocaml-output/FStar_Parser_Dep.ml
+++ /dev/null
@@ -1,2741 +0,0 @@
-open Prims
-type open_kind =
-  | Open_module 
-  | Open_namespace 
-let (uu___is_Open_module : open_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Open_module -> true | uu___ -> false
-let (uu___is_Open_namespace : open_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Open_namespace -> true | uu___ -> false
-type module_name = Prims.string
-let profile : 'uuuuu . (unit -> 'uuuuu) -> Prims.string -> 'uuuuu =
-  fun f -> fun c -> FStar_Profiling.profile f FStar_Pervasives_Native.None c
-type verify_mode =
-  | VerifyAll 
-  | VerifyUserList 
-  | VerifyFigureItOut 
-let (uu___is_VerifyAll : verify_mode -> Prims.bool) =
-  fun projectee -> match projectee with | VerifyAll -> true | uu___ -> false
-let (uu___is_VerifyUserList : verify_mode -> Prims.bool) =
-  fun projectee ->
-    match projectee with | VerifyUserList -> true | uu___ -> false
-let (uu___is_VerifyFigureItOut : verify_mode -> Prims.bool) =
-  fun projectee ->
-    match projectee with | VerifyFigureItOut -> true | uu___ -> false
-type intf_and_impl =
-  (Prims.string FStar_Pervasives_Native.option * Prims.string
-    FStar_Pervasives_Native.option)
-type files_for_module_name = intf_and_impl FStar_Compiler_Util.smap
-let (intf_and_impl_to_string :
-  (Prims.string FStar_Pervasives_Native.option * Prims.string
-    FStar_Pervasives_Native.option) -> Prims.string)
-  =
-  fun ii ->
-    match ii with
-    | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-        "<None>, <None>"
-    | (FStar_Pervasives_Native.Some intf, FStar_Pervasives_Native.None) ->
-        intf
-    | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some impl) ->
-        impl
-    | (FStar_Pervasives_Native.Some intf, FStar_Pervasives_Native.Some impl)
-        ->
-        let uu___ = FStar_String.op_Hat ", " impl in
-        FStar_String.op_Hat intf uu___
-let (files_for_module_name_to_string : files_for_module_name -> unit) =
-  fun m ->
-    FStar_Compiler_Util.print_string "Printing the file system map {\n";
-    (let str_opt_to_string sopt =
-       match sopt with
-       | FStar_Pervasives_Native.None -> "<None>"
-       | FStar_Pervasives_Native.Some s -> s in
-     FStar_Compiler_Util.smap_iter m
-       (fun k ->
-          fun v ->
-            let uu___2 = intf_and_impl_to_string v in
-            FStar_Compiler_Util.print2 "%s:%s\n" k uu___2);
-     FStar_Compiler_Util.print_string "}\n")
-type color =
-  | White 
-  | Gray 
-  | Black 
-let (uu___is_White : color -> Prims.bool) =
-  fun projectee -> match projectee with | White -> true | uu___ -> false
-let (uu___is_Gray : color -> Prims.bool) =
-  fun projectee -> match projectee with | Gray -> true | uu___ -> false
-let (uu___is_Black : color -> Prims.bool) =
-  fun projectee -> match projectee with | Black -> true | uu___ -> false
-let (check_and_strip_suffix :
-  Prims.string -> Prims.string FStar_Pervasives_Native.option) =
-  fun f ->
-    let suffixes = [".fsti"; ".fst"; ".fsi"; ".fs"] in
-    let matches =
-      FStar_Compiler_List.map
-        (fun ext ->
-           let lext = FStar_String.length ext in
-           let l = FStar_String.length f in
-           let uu___ =
-             (l > lext) &&
-               (let uu___1 = FStar_String.substring f (l - lext) lext in
-                uu___1 = ext) in
-           if uu___
-           then
-             let uu___1 = FStar_String.substring f Prims.int_zero (l - lext) in
-             FStar_Pervasives_Native.Some uu___1
-           else FStar_Pervasives_Native.None) suffixes in
-    let uu___ =
-      FStar_Compiler_List.filter FStar_Compiler_Util.is_some matches in
-    match uu___ with
-    | (FStar_Pervasives_Native.Some m)::uu___1 ->
-        FStar_Pervasives_Native.Some m
-    | uu___1 -> FStar_Pervasives_Native.None
-let (is_interface : Prims.string -> Prims.bool) =
-  fun f ->
-    let uu___ = FStar_String.get f ((FStar_String.length f) - Prims.int_one) in
-    uu___ = 105
-let (is_implementation : Prims.string -> Prims.bool) =
-  fun f -> let uu___ = is_interface f in Prims.op_Negation uu___
-let list_of_option :
-  'uuuuu . 'uuuuu FStar_Pervasives_Native.option -> 'uuuuu Prims.list =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some x -> [x]
-    | FStar_Pervasives_Native.None -> []
-let list_of_pair :
-  'uuuuu .
-    ('uuuuu FStar_Pervasives_Native.option * 'uuuuu
-      FStar_Pervasives_Native.option) -> 'uuuuu Prims.list
-  =
-  fun uu___ ->
-    match uu___ with
-    | (intf, impl) ->
-        FStar_Compiler_List.op_At (list_of_option intf) (list_of_option impl)
-let (module_name_of_file : Prims.string -> Prims.string) =
-  fun f ->
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.basename f in
-      check_and_strip_suffix uu___1 in
-    match uu___ with
-    | FStar_Pervasives_Native.Some longname -> longname
-    | FStar_Pervasives_Native.None ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_Util.format1 "not a valid FStar file: %s" f in
-          (FStar_Errors.Fatal_NotValidFStarFile, uu___2) in
-        FStar_Errors.raise_err uu___1
-let (lowercase_module_name : Prims.string -> Prims.string) =
-  fun f -> let uu___ = module_name_of_file f in FStar_String.lowercase uu___
-let (namespace_of_module :
-  Prims.string -> FStar_Ident.lident FStar_Pervasives_Native.option) =
-  fun f ->
-    let lid =
-      let uu___ = FStar_Ident.path_of_text f in
-      FStar_Ident.lid_of_path uu___ FStar_Compiler_Range.dummyRange in
-    let uu___ = FStar_Ident.ns_of_lid lid in
-    match uu___ with
-    | [] -> FStar_Pervasives_Native.None
-    | ns ->
-        let uu___1 = FStar_Ident.lid_of_ids ns in
-        FStar_Pervasives_Native.Some uu___1
-type file_name = Prims.string
-type dependence =
-  | UseInterface of module_name 
-  | PreferInterface of module_name 
-  | UseImplementation of module_name 
-  | FriendImplementation of module_name 
-let (uu___is_UseInterface : dependence -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UseInterface _0 -> true | uu___ -> false
-let (__proj__UseInterface__item___0 : dependence -> module_name) =
-  fun projectee -> match projectee with | UseInterface _0 -> _0
-let (uu___is_PreferInterface : dependence -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PreferInterface _0 -> true | uu___ -> false
-let (__proj__PreferInterface__item___0 : dependence -> module_name) =
-  fun projectee -> match projectee with | PreferInterface _0 -> _0
-let (uu___is_UseImplementation : dependence -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UseImplementation _0 -> true | uu___ -> false
-let (__proj__UseImplementation__item___0 : dependence -> module_name) =
-  fun projectee -> match projectee with | UseImplementation _0 -> _0
-let (uu___is_FriendImplementation : dependence -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FriendImplementation _0 -> true | uu___ -> false
-let (__proj__FriendImplementation__item___0 : dependence -> module_name) =
-  fun projectee -> match projectee with | FriendImplementation _0 -> _0
-let (dep_to_string : dependence -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | UseInterface f -> FStar_String.op_Hat "UseInterface " f
-    | PreferInterface f -> FStar_String.op_Hat "PreferInterface " f
-    | UseImplementation f -> FStar_String.op_Hat "UseImplementation " f
-    | FriendImplementation f -> FStar_String.op_Hat "FriendImplementation " f
-type dependences = dependence Prims.list
-let empty_dependences : 'uuuuu . unit -> 'uuuuu Prims.list = fun uu___ -> []
-type dep_node = {
-  edges: dependences ;
-  color: color }
-let (__proj__Mkdep_node__item__edges : dep_node -> dependences) =
-  fun projectee -> match projectee with | { edges; color = color1;_} -> edges
-let (__proj__Mkdep_node__item__color : dep_node -> color) =
-  fun projectee ->
-    match projectee with | { edges; color = color1;_} -> color1
-type dependence_graph =
-  | Deps of dep_node FStar_Compiler_Util.smap 
-let (uu___is_Deps : dependence_graph -> Prims.bool) = fun projectee -> true
-let (__proj__Deps__item___0 :
-  dependence_graph -> dep_node FStar_Compiler_Util.smap) =
-  fun projectee -> match projectee with | Deps _0 -> _0
-type parsing_data_elt =
-  | P_begin_module of FStar_Ident.lident 
-  | P_open of (Prims.bool * FStar_Ident.lident) 
-  | P_implicit_open_module_or_namespace of (open_kind * FStar_Ident.lid) 
-  | P_dep of (Prims.bool * FStar_Ident.lident) 
-  | P_alias of (FStar_Ident.ident * FStar_Ident.lident) 
-  | P_lid of FStar_Ident.lident 
-  | P_inline_for_extraction 
-let (uu___is_P_begin_module : parsing_data_elt -> Prims.bool) =
-  fun projectee ->
-    match projectee with | P_begin_module _0 -> true | uu___ -> false
-let (__proj__P_begin_module__item___0 :
-  parsing_data_elt -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | P_begin_module _0 -> _0
-let (uu___is_P_open : parsing_data_elt -> Prims.bool) =
-  fun projectee -> match projectee with | P_open _0 -> true | uu___ -> false
-let (__proj__P_open__item___0 :
-  parsing_data_elt -> (Prims.bool * FStar_Ident.lident)) =
-  fun projectee -> match projectee with | P_open _0 -> _0
-let (uu___is_P_implicit_open_module_or_namespace :
-  parsing_data_elt -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | P_implicit_open_module_or_namespace _0 -> true
-    | uu___ -> false
-let (__proj__P_implicit_open_module_or_namespace__item___0 :
-  parsing_data_elt -> (open_kind * FStar_Ident.lid)) =
-  fun projectee ->
-    match projectee with | P_implicit_open_module_or_namespace _0 -> _0
-let (uu___is_P_dep : parsing_data_elt -> Prims.bool) =
-  fun projectee -> match projectee with | P_dep _0 -> true | uu___ -> false
-let (__proj__P_dep__item___0 :
-  parsing_data_elt -> (Prims.bool * FStar_Ident.lident)) =
-  fun projectee -> match projectee with | P_dep _0 -> _0
-let (uu___is_P_alias : parsing_data_elt -> Prims.bool) =
-  fun projectee -> match projectee with | P_alias _0 -> true | uu___ -> false
-let (__proj__P_alias__item___0 :
-  parsing_data_elt -> (FStar_Ident.ident * FStar_Ident.lident)) =
-  fun projectee -> match projectee with | P_alias _0 -> _0
-let (uu___is_P_lid : parsing_data_elt -> Prims.bool) =
-  fun projectee -> match projectee with | P_lid _0 -> true | uu___ -> false
-let (__proj__P_lid__item___0 : parsing_data_elt -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | P_lid _0 -> _0
-let (uu___is_P_inline_for_extraction : parsing_data_elt -> Prims.bool) =
-  fun projectee ->
-    match projectee with | P_inline_for_extraction -> true | uu___ -> false
-type parsing_data =
-  | Mk_pd of parsing_data_elt Prims.list 
-let (uu___is_Mk_pd : parsing_data -> Prims.bool) = fun projectee -> true
-let (__proj__Mk_pd__item___0 : parsing_data -> parsing_data_elt Prims.list) =
-  fun projectee -> match projectee with | Mk_pd _0 -> _0
-let (str_of_parsing_data_elt : parsing_data_elt -> Prims.string) =
-  fun elt ->
-    let str_of_open_kind uu___ =
-      match uu___ with
-      | Open_module -> "P_open_module"
-      | Open_namespace -> "P_open_namespace" in
-    match elt with
-    | P_begin_module lid ->
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid lid in
-          FStar_String.op_Hat uu___1 ")" in
-        FStar_String.op_Hat "P_begin_module (" uu___
-    | P_open (b, lid) ->
-        let uu___ =
-          let uu___1 = FStar_Compiler_Util.string_of_bool b in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Ident.string_of_lid lid in
-              FStar_String.op_Hat uu___4 ")" in
-            FStar_String.op_Hat ", " uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "P_open (" uu___
-    | P_implicit_open_module_or_namespace (k, lid) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Ident.string_of_lid lid in
-              FStar_String.op_Hat uu___3 ")" in
-            FStar_String.op_Hat ", " uu___2 in
-          FStar_String.op_Hat (str_of_open_kind k) uu___1 in
-        FStar_String.op_Hat "P_implicit_open_module_or_namespace (" uu___
-    | P_dep (b, lid) ->
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid lid in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Compiler_Util.string_of_bool b in
-              FStar_String.op_Hat uu___4 ")" in
-            FStar_String.op_Hat ", " uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "P_dep (" uu___
-    | P_alias (id, lid) ->
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_id id in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Ident.string_of_lid lid in
-              FStar_String.op_Hat uu___4 ")" in
-            FStar_String.op_Hat ", " uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "P_alias (" uu___
-    | P_lid lid ->
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid lid in
-          FStar_String.op_Hat uu___1 ")" in
-        FStar_String.op_Hat "P_lid (" uu___
-    | P_inline_for_extraction -> "P_inline_for_extraction"
-let (str_of_parsing_data : parsing_data -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Mk_pd l ->
-        FStar_Compiler_Effect.op_Bar_Greater l
-          (FStar_Compiler_List.fold_left
-             (fun s ->
-                fun elt ->
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bar_Greater elt
-                        str_of_parsing_data_elt in
-                    FStar_String.op_Hat "; " uu___2 in
-                  FStar_String.op_Hat s uu___1) "")
-let (parsing_data_elt_eq :
-  parsing_data_elt -> parsing_data_elt -> Prims.bool) =
-  fun e1 ->
-    fun e2 ->
-      match (e1, e2) with
-      | (P_begin_module l1, P_begin_module l2) ->
-          FStar_Ident.lid_equals l1 l2
-      | (P_open (b1, l1), P_open (b2, l2)) ->
-          (b1 = b2) && (FStar_Ident.lid_equals l1 l2)
-      | (P_implicit_open_module_or_namespace (k1, l1),
-         P_implicit_open_module_or_namespace (k2, l2)) ->
-          (k1 = k2) && (FStar_Ident.lid_equals l1 l2)
-      | (P_dep (b1, l1), P_dep (b2, l2)) ->
-          (b1 = b2) && (FStar_Ident.lid_equals l1 l2)
-      | (P_alias (i1, l1), P_alias (i2, l2)) ->
-          (let uu___ = FStar_Ident.string_of_id i1 in
-           let uu___1 = FStar_Ident.string_of_id i2 in uu___ = uu___1) &&
-            (FStar_Ident.lid_equals l1 l2)
-      | (P_lid l1, P_lid l2) -> FStar_Ident.lid_equals l1 l2
-      | (P_inline_for_extraction, P_inline_for_extraction) -> true
-      | (uu___, uu___1) -> false
-let (empty_parsing_data : parsing_data) = Mk_pd []
-type deps =
-  {
-  dep_graph: dependence_graph ;
-  file_system_map: files_for_module_name ;
-  cmd_line_files: file_name Prims.list ;
-  all_files: file_name Prims.list ;
-  interfaces_with_inlining: module_name Prims.list ;
-  parse_results: parsing_data FStar_Compiler_Util.smap }
-let (__proj__Mkdeps__item__dep_graph : deps -> dependence_graph) =
-  fun projectee ->
-    match projectee with
-    | { dep_graph; file_system_map; cmd_line_files; all_files;
-        interfaces_with_inlining; parse_results;_} -> dep_graph
-let (__proj__Mkdeps__item__file_system_map : deps -> files_for_module_name) =
-  fun projectee ->
-    match projectee with
-    | { dep_graph; file_system_map; cmd_line_files; all_files;
-        interfaces_with_inlining; parse_results;_} -> file_system_map
-let (__proj__Mkdeps__item__cmd_line_files : deps -> file_name Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { dep_graph; file_system_map; cmd_line_files; all_files;
-        interfaces_with_inlining; parse_results;_} -> cmd_line_files
-let (__proj__Mkdeps__item__all_files : deps -> file_name Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { dep_graph; file_system_map; cmd_line_files; all_files;
-        interfaces_with_inlining; parse_results;_} -> all_files
-let (__proj__Mkdeps__item__interfaces_with_inlining :
-  deps -> module_name Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { dep_graph; file_system_map; cmd_line_files; all_files;
-        interfaces_with_inlining; parse_results;_} ->
-        interfaces_with_inlining
-let (__proj__Mkdeps__item__parse_results :
-  deps -> parsing_data FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { dep_graph; file_system_map; cmd_line_files; all_files;
-        interfaces_with_inlining; parse_results;_} -> parse_results
-let (deps_try_find :
-  dependence_graph -> Prims.string -> dep_node FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    fun k ->
-      match uu___ with | Deps m -> FStar_Compiler_Util.smap_try_find m k
-let (deps_add_dep : dependence_graph -> Prims.string -> dep_node -> unit) =
-  fun uu___ ->
-    fun k ->
-      fun v ->
-        match uu___ with | Deps m -> FStar_Compiler_Util.smap_add m k v
-let (deps_keys : dependence_graph -> Prims.string Prims.list) =
-  fun uu___ -> match uu___ with | Deps m -> FStar_Compiler_Util.smap_keys m
-let (deps_empty : unit -> dependence_graph) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Util.smap_create (Prims.of_int (41)) in
-    Deps uu___1
-let (mk_deps :
-  dependence_graph ->
-    files_for_module_name ->
-      file_name Prims.list ->
-        file_name Prims.list ->
-          module_name Prims.list ->
-            parsing_data FStar_Compiler_Util.smap -> deps)
-  =
-  fun dg ->
-    fun fs ->
-      fun c ->
-        fun a ->
-          fun i ->
-            fun pr ->
-              {
-                dep_graph = dg;
-                file_system_map = fs;
-                cmd_line_files = c;
-                all_files = a;
-                interfaces_with_inlining = i;
-                parse_results = pr
-              }
-let (empty_deps : deps) =
-  let uu___ = deps_empty () in
-  let uu___1 = FStar_Compiler_Util.smap_create Prims.int_zero in
-  let uu___2 = FStar_Compiler_Util.smap_create Prims.int_zero in
-  mk_deps uu___ uu___1 [] [] [] uu___2
-let (module_name_of_dep : dependence -> module_name) =
-  fun uu___ ->
-    match uu___ with
-    | UseInterface m -> m
-    | PreferInterface m -> m
-    | UseImplementation m -> m
-    | FriendImplementation m -> m
-let (resolve_module_name :
-  files_for_module_name ->
-    module_name -> module_name FStar_Pervasives_Native.option)
-  =
-  fun file_system_map ->
-    fun key ->
-      let uu___ = FStar_Compiler_Util.smap_try_find file_system_map key in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives_Native.Some fn, uu___1) ->
-          let uu___2 = lowercase_module_name fn in
-          FStar_Pervasives_Native.Some uu___2
-      | FStar_Pervasives_Native.Some
-          (uu___1, FStar_Pervasives_Native.Some fn) ->
-          let uu___2 = lowercase_module_name fn in
-          FStar_Pervasives_Native.Some uu___2
-      | uu___1 -> FStar_Pervasives_Native.None
-let (interface_of_internal :
-  files_for_module_name ->
-    module_name -> file_name FStar_Pervasives_Native.option)
-  =
-  fun file_system_map ->
-    fun key ->
-      let uu___ = FStar_Compiler_Util.smap_try_find file_system_map key in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives_Native.Some iface, uu___1) ->
-          FStar_Pervasives_Native.Some iface
-      | uu___1 -> FStar_Pervasives_Native.None
-let (implementation_of_internal :
-  files_for_module_name ->
-    module_name -> file_name FStar_Pervasives_Native.option)
-  =
-  fun file_system_map ->
-    fun key ->
-      let uu___ = FStar_Compiler_Util.smap_try_find file_system_map key in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (uu___1, FStar_Pervasives_Native.Some impl) ->
-          FStar_Pervasives_Native.Some impl
-      | uu___1 -> FStar_Pervasives_Native.None
-let (interface_of :
-  deps -> Prims.string -> Prims.string FStar_Pervasives_Native.option) =
-  fun deps1 -> fun key -> interface_of_internal deps1.file_system_map key
-let (implementation_of :
-  deps -> Prims.string -> Prims.string FStar_Pervasives_Native.option) =
-  fun deps1 ->
-    fun key -> implementation_of_internal deps1.file_system_map key
-let (has_interface : files_for_module_name -> module_name -> Prims.bool) =
-  fun file_system_map ->
-    fun key ->
-      let uu___ = interface_of_internal file_system_map key in
-      FStar_Compiler_Option.isSome uu___
-let (has_implementation : files_for_module_name -> module_name -> Prims.bool)
-  =
-  fun file_system_map ->
-    fun key ->
-      let uu___ = implementation_of_internal file_system_map key in
-      FStar_Compiler_Option.isSome uu___
-let (cache_file_name : Prims.string -> Prims.string) =
-  let checked_file_and_exists_flag fn =
-    let lax = FStar_Options.lax () in
-    let cache_fn =
-      if lax
-      then FStar_String.op_Hat fn ".checked.lax"
-      else FStar_String.op_Hat fn ".checked" in
-    let mname = FStar_Compiler_Effect.op_Bar_Greater fn module_name_of_file in
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater cache_fn
-          FStar_Compiler_Util.basename in
-      FStar_Options.find_file uu___1 in
-    match uu___ with
-    | FStar_Pervasives_Native.Some path ->
-        let expected_cache_file = FStar_Options.prepend_cache_dir cache_fn in
-        ((let uu___2 =
-            ((let uu___3 = FStar_Options.dep () in
-              FStar_Compiler_Option.isSome uu___3) &&
-               (let uu___3 = FStar_Options.should_be_already_cached mname in
-                Prims.op_Negation uu___3))
-              &&
-              ((Prims.op_Negation
-                  (FStar_Compiler_Util.file_exists expected_cache_file))
-                 ||
-                 (let uu___3 =
-                    FStar_Compiler_Util.paths_to_same_file path
-                      expected_cache_file in
-                  Prims.op_Negation uu___3)) in
-          if uu___2
-          then
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Options.prepend_cache_dir cache_fn in
-                FStar_Compiler_Util.format3
-                  "Did not expect %s to be already checked, but found it in an unexpected location %s instead of %s"
-                  mname path uu___5 in
-              (FStar_Errors.Warning_UnexpectedCheckedFile, uu___4) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___3
-          else ());
-         (let uu___2 =
-            (FStar_Compiler_Util.file_exists expected_cache_file) &&
-              (FStar_Compiler_Util.paths_to_same_file path
-                 expected_cache_file) in
-          if uu___2 then expected_cache_file else path))
-    | FStar_Pervasives_Native.None ->
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater mname
-            FStar_Options.should_be_already_cached in
-        if uu___1
-        then
-          let uu___2 =
-            let uu___3 =
-              FStar_Compiler_Util.format1
-                "Expected %s to be already checked but could not find it"
-                mname in
-            (FStar_Errors.Error_AlreadyCachedAssertionFailure, uu___3) in
-          FStar_Errors.raise_err uu___2
-        else FStar_Options.prepend_cache_dir cache_fn in
-  let memo = FStar_Compiler_Util.smap_create (Prims.of_int (100)) in
-  let memo1 f x =
-    let uu___ = FStar_Compiler_Util.smap_try_find memo x in
-    match uu___ with
-    | FStar_Pervasives_Native.Some res -> res
-    | FStar_Pervasives_Native.None ->
-        let res = f x in (FStar_Compiler_Util.smap_add memo x res; res) in
-  memo1 checked_file_and_exists_flag
-let (parsing_data_of : deps -> Prims.string -> parsing_data) =
-  fun deps1 ->
-    fun fn ->
-      let uu___ = FStar_Compiler_Util.smap_try_find deps1.parse_results fn in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Compiler_Util.must
-let (file_of_dep_aux :
-  Prims.bool ->
-    files_for_module_name -> file_name Prims.list -> dependence -> file_name)
-  =
-  fun use_checked_file ->
-    fun file_system_map ->
-      fun all_cmd_line_files ->
-        fun d ->
-          let cmd_line_has_impl key =
-            FStar_Compiler_Effect.op_Bar_Greater all_cmd_line_files
-              (FStar_Compiler_Util.for_some
-                 (fun fn ->
-                    (is_implementation fn) &&
-                      (let uu___ = lowercase_module_name fn in key = uu___))) in
-          let maybe_use_cache_of f =
-            if use_checked_file then cache_file_name f else f in
-          match d with
-          | UseInterface key ->
-              let uu___ = interface_of_internal file_system_map key in
-              (match uu___ with
-               | FStar_Pervasives_Native.None ->
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Compiler_Util.format1
-                         "Expected an interface for module %s, but couldn't find one"
-                         key in
-                     (FStar_Errors.Fatal_MissingInterface, uu___3) in
-                   FStar_Errors.raise_err uu___2
-               | FStar_Pervasives_Native.Some f -> f)
-          | PreferInterface key when has_interface file_system_map key ->
-              let uu___ =
-                (cmd_line_has_impl key) &&
-                  (let uu___1 = FStar_Options.dep () in
-                   FStar_Compiler_Option.isNone uu___1) in
-              if uu___
-              then
-                let uu___1 = FStar_Options.expose_interfaces () in
-                (if uu___1
-                 then
-                   let uu___2 =
-                     let uu___3 =
-                       implementation_of_internal file_system_map key in
-                     FStar_Compiler_Option.get uu___3 in
-                   maybe_use_cache_of uu___2
-                 else
-                   (let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            implementation_of_internal file_system_map key in
-                          FStar_Compiler_Option.get uu___6 in
-                        let uu___6 =
-                          let uu___7 =
-                            interface_of_internal file_system_map key in
-                          FStar_Compiler_Option.get uu___7 in
-                        FStar_Compiler_Util.format3
-                          "You may have a cyclic dependence on module %s: use --dep full to confirm. Alternatively, invoking fstar with %s on the command line breaks the abstraction imposed by its interface %s; if you really want this behavior add the option '--expose_interfaces'"
-                          key uu___5 uu___6 in
-                      (FStar_Errors.Fatal_MissingExposeInterfacesOption,
-                        uu___4) in
-                    FStar_Errors.raise_err uu___3))
-              else
-                (let uu___2 =
-                   let uu___3 = interface_of_internal file_system_map key in
-                   FStar_Compiler_Option.get uu___3 in
-                 maybe_use_cache_of uu___2)
-          | PreferInterface key ->
-              let uu___ = implementation_of_internal file_system_map key in
-              (match uu___ with
-               | FStar_Pervasives_Native.None ->
-                   let uu___1 =
-                     let uu___2 =
-                       FStar_Compiler_Util.format1
-                         "Expected an implementation of module %s, but couldn't find one"
-                         key in
-                     (FStar_Errors.Fatal_MissingImplementation, uu___2) in
-                   FStar_Errors.raise_err uu___1
-               | FStar_Pervasives_Native.Some f -> maybe_use_cache_of f)
-          | UseImplementation key ->
-              let uu___ = implementation_of_internal file_system_map key in
-              (match uu___ with
-               | FStar_Pervasives_Native.None ->
-                   let uu___1 =
-                     let uu___2 =
-                       FStar_Compiler_Util.format1
-                         "Expected an implementation of module %s, but couldn't find one"
-                         key in
-                     (FStar_Errors.Fatal_MissingImplementation, uu___2) in
-                   FStar_Errors.raise_err uu___1
-               | FStar_Pervasives_Native.Some f -> maybe_use_cache_of f)
-          | FriendImplementation key ->
-              let uu___ = implementation_of_internal file_system_map key in
-              (match uu___ with
-               | FStar_Pervasives_Native.None ->
-                   let uu___1 =
-                     let uu___2 =
-                       FStar_Compiler_Util.format1
-                         "Expected an implementation of module %s, but couldn't find one"
-                         key in
-                     (FStar_Errors.Fatal_MissingImplementation, uu___2) in
-                   FStar_Errors.raise_err uu___1
-               | FStar_Pervasives_Native.Some f -> maybe_use_cache_of f)
-let (file_of_dep :
-  files_for_module_name -> file_name Prims.list -> dependence -> file_name) =
-  file_of_dep_aux false
-let (dependences_of :
-  files_for_module_name ->
-    dependence_graph ->
-      file_name Prims.list -> file_name -> file_name Prims.list)
-  =
-  fun file_system_map ->
-    fun deps1 ->
-      fun all_cmd_line_files ->
-        fun fn ->
-          let uu___ = deps_try_find deps1 fn in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> empty_dependences ()
-          | FStar_Pervasives_Native.Some { edges = deps2; color = uu___1;_}
-              ->
-              let uu___2 =
-                FStar_Compiler_List.map
-                  (file_of_dep file_system_map all_cmd_line_files) deps2 in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                (FStar_Compiler_List.filter (fun k -> k <> fn))
-let (print_graph : dependence_graph -> unit) =
-  fun graph ->
-    FStar_Compiler_Util.print_endline
-      "A DOT-format graph has been dumped in the current directory as dep.graph";
-    FStar_Compiler_Util.print_endline
-      "With GraphViz installed, try: fdp -Tpng -odep.png dep.graph";
-    FStar_Compiler_Util.print_endline
-      "Hint: cat dep.graph | grep -v _ | grep -v prims";
-    (let uu___3 =
-       let uu___4 =
-         let uu___5 =
-           let uu___6 =
-             let uu___7 =
-               let uu___8 = deps_keys graph in
-               FStar_Compiler_List.unique uu___8 in
-             FStar_Compiler_List.collect
-               (fun k ->
-                  let deps1 =
-                    let uu___8 =
-                      let uu___9 = deps_try_find graph k in
-                      FStar_Compiler_Util.must uu___9 in
-                    uu___8.edges in
-                  let r s = FStar_Compiler_Util.replace_char s 46 95 in
-                  let print dep =
-                    let uu___8 =
-                      let uu___9 = lowercase_module_name k in r uu___9 in
-                    FStar_Compiler_Util.format2 "  \"%s\" -> \"%s\"" uu___8
-                      (r (module_name_of_dep dep)) in
-                  FStar_Compiler_List.map print deps1) uu___7 in
-           FStar_String.concat "\n" uu___6 in
-         FStar_String.op_Hat uu___5 "\n}\n" in
-       FStar_String.op_Hat "digraph {\n" uu___4 in
-     FStar_Compiler_Util.write_file "dep.graph" uu___3)
-let (build_inclusion_candidates_list :
-  unit -> (Prims.string * Prims.string) Prims.list) =
-  fun uu___ ->
-    let include_directories = FStar_Options.include_path () in
-    let include_directories1 =
-      FStar_Compiler_List.map FStar_Compiler_Util.normalize_file_path
-        include_directories in
-    let include_directories2 =
-      FStar_Compiler_List.unique include_directories1 in
-    let cwd =
-      let uu___1 = FStar_Compiler_Util.getcwd () in
-      FStar_Compiler_Util.normalize_file_path uu___1 in
-    FStar_Compiler_List.concatMap
-      (fun d ->
-         if FStar_Compiler_Util.is_directory d
-         then
-           let files = FStar_Compiler_Util.readdir d in
-           FStar_Compiler_List.filter_map
-             (fun f ->
-                let f1 = FStar_Compiler_Util.basename f in
-                let uu___1 = check_and_strip_suffix f1 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___1
-                  (FStar_Compiler_Util.map_option
-                     (fun longname ->
-                        let full_path =
-                          if d = cwd
-                          then f1
-                          else FStar_Compiler_Util.join_paths d f1 in
-                        (longname, full_path)))) files
-         else
-           (let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Util.format1
-                  "not a valid include directory: %s\n" d in
-              (FStar_Errors.Fatal_NotValidIncludeDirectory, uu___3) in
-            FStar_Errors.raise_err uu___2)) include_directories2
-let (build_map : Prims.string Prims.list -> files_for_module_name) =
-  fun filenames ->
-    let map = FStar_Compiler_Util.smap_create (Prims.of_int (41)) in
-    let add_entry key full_path =
-      let uu___ = FStar_Compiler_Util.smap_try_find map key in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (intf, impl) ->
-          let uu___1 = is_interface full_path in
-          if uu___1
-          then
-            FStar_Compiler_Util.smap_add map key
-              ((FStar_Pervasives_Native.Some full_path), impl)
-          else
-            FStar_Compiler_Util.smap_add map key
-              (intf, (FStar_Pervasives_Native.Some full_path))
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = is_interface full_path in
-          if uu___1
-          then
-            FStar_Compiler_Util.smap_add map key
-              ((FStar_Pervasives_Native.Some full_path),
-                FStar_Pervasives_Native.None)
-          else
-            FStar_Compiler_Util.smap_add map key
-              (FStar_Pervasives_Native.None,
-                (FStar_Pervasives_Native.Some full_path)) in
-    (let uu___1 = build_inclusion_candidates_list () in
-     FStar_Compiler_List.iter
-       (fun uu___2 ->
-          match uu___2 with
-          | (longname, full_path) ->
-              add_entry (FStar_String.lowercase longname) full_path) uu___1);
-    FStar_Compiler_List.iter
-      (fun f -> let uu___2 = lowercase_module_name f in add_entry uu___2 f)
-      filenames;
-    map
-let (string_of_lid : FStar_Ident.lident -> Prims.bool -> Prims.string) =
-  fun l ->
-    fun last ->
-      let suffix =
-        if last
-        then
-          let uu___ =
-            let uu___1 = FStar_Ident.ident_of_lid l in
-            FStar_Ident.string_of_id uu___1 in
-          [uu___]
-        else [] in
-      let names =
-        let uu___ =
-          let uu___1 = FStar_Ident.ns_of_lid l in
-          FStar_Compiler_List.map (fun x -> FStar_Ident.string_of_id x)
-            uu___1 in
-        FStar_Compiler_List.op_At uu___ suffix in
-      FStar_String.concat "." names
-let (lowercase_join_longident :
-  FStar_Ident.lident -> Prims.bool -> Prims.string) =
-  fun l ->
-    fun last ->
-      let uu___ = string_of_lid l last in FStar_String.lowercase uu___
-let (namespace_of_lid : FStar_Ident.lident -> Prims.string) =
-  fun l ->
-    let uu___ =
-      let uu___1 = FStar_Ident.ns_of_lid l in
-      FStar_Compiler_List.map FStar_Ident.string_of_id uu___1 in
-    FStar_String.concat "_" uu___
-let (check_module_declaration_against_filename :
-  FStar_Ident.lident -> Prims.string -> unit) =
-  fun lid ->
-    fun filename ->
-      let k' = lowercase_join_longident lid true in
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Compiler_Util.basename filename in
-              check_and_strip_suffix uu___4 in
-            FStar_Compiler_Util.must uu___3 in
-          FStar_String.lowercase uu___2 in
-        uu___1 <> k' in
-      if uu___
-      then
-        let uu___1 = FStar_Ident.range_of_lid lid in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = string_of_lid lid true in
-            FStar_Compiler_Util.format2
-              "The module declaration \"module %s\" found in file %s does not match its filename. Dependencies will be incorrect and the module will not be verified.\n"
-              uu___4 filename in
-          (FStar_Errors.Error_ModuleFileNameMismatch, uu___3) in
-        FStar_Errors.log_issue uu___1 uu___2
-      else ()
-exception Exit 
-let (uu___is_Exit : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | Exit -> true | uu___ -> false
-let (core_modules : Prims.string Prims.list) =
-  let uu___ =
-    let uu___1 = FStar_Options.prims_basename () in
-    let uu___2 =
-      let uu___3 = FStar_Options.pervasives_basename () in
-      let uu___4 =
-        let uu___5 = FStar_Options.pervasives_native_basename () in [uu___5] in
-      uu___3 :: uu___4 in
-    uu___1 :: uu___2 in
-  FStar_Compiler_Effect.op_Bar_Greater uu___
-    (FStar_Compiler_List.map module_name_of_file)
-let (implicit_ns_deps : FStar_Ident.lident Prims.list) =
-  [FStar_Parser_Const.fstar_ns_lid]
-let (implicit_module_deps : FStar_Ident.lident Prims.list) =
-  [FStar_Parser_Const.prims_lid; FStar_Parser_Const.pervasives_lid]
-let (hard_coded_dependencies :
-  Prims.string -> (FStar_Ident.lident * open_kind) Prims.list) =
-  fun full_filename ->
-    let filename = FStar_Compiler_Util.basename full_filename in
-    let implicit_module_deps1 =
-      FStar_Compiler_List.map (fun l -> (l, Open_module))
-        implicit_module_deps in
-    let implicit_ns_deps1 =
-      FStar_Compiler_List.map (fun l -> (l, Open_namespace)) implicit_ns_deps in
-    let uu___ =
-      let uu___1 = module_name_of_file filename in
-      FStar_Compiler_List.mem uu___1 core_modules in
-    if uu___
-    then []
-    else
-      (let uu___2 =
-         let uu___3 = lowercase_module_name full_filename in
-         namespace_of_module uu___3 in
-       match uu___2 with
-       | FStar_Pervasives_Native.None ->
-           FStar_Compiler_List.op_At implicit_ns_deps1 implicit_module_deps1
-       | FStar_Pervasives_Native.Some ns ->
-           FStar_Compiler_List.op_At implicit_ns_deps1
-             (FStar_Compiler_List.op_At implicit_module_deps1
-                [(ns, Open_namespace)]))
-let (dep_subsumed_by : dependence -> dependence -> Prims.bool) =
-  fun d ->
-    fun d' ->
-      match (d, d') with
-      | (PreferInterface l', FriendImplementation l) -> l = l'
-      | uu___ -> d = d'
-let (enter_namespace :
-  files_for_module_name ->
-    files_for_module_name -> Prims.string -> Prims.bool -> Prims.bool)
-  =
-  fun original_map ->
-    fun working_map ->
-      fun prefix ->
-        fun implicit_open ->
-          let found = FStar_Compiler_Util.mk_ref false in
-          let prefix1 = FStar_String.op_Hat prefix "." in
-          let suffix_exists mopt =
-            match mopt with
-            | FStar_Pervasives_Native.None -> false
-            | FStar_Pervasives_Native.Some (intf, impl) ->
-                (FStar_Compiler_Util.is_some intf) ||
-                  (FStar_Compiler_Util.is_some impl) in
-          FStar_Compiler_Util.smap_iter original_map
-            (fun k ->
-               fun uu___1 ->
-                 if FStar_Compiler_Util.starts_with k prefix1
-                 then
-                   let suffix =
-                     FStar_String.substring k (FStar_String.length prefix1)
-                       ((FStar_String.length k) -
-                          (FStar_String.length prefix1)) in
-                   ((let suffix_filename =
-                       FStar_Compiler_Util.smap_try_find original_map suffix in
-                     if implicit_open && (suffix_exists suffix_filename)
-                     then
-                       let str =
-                         let uu___3 =
-                           FStar_Compiler_Effect.op_Bar_Greater
-                             suffix_filename FStar_Compiler_Util.must in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___3
-                           intf_and_impl_to_string in
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_Compiler_Util.format4
-                             "Implicitly opening %s namespace shadows (%s -> %s), rename %s to avoid conflicts"
-                             prefix1 suffix str str in
-                         (FStar_Errors.Warning_UnexpectedFile, uu___4) in
-                       FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                         uu___3
-                     else ());
-                    (let filename =
-                       let uu___3 =
-                         FStar_Compiler_Util.smap_try_find original_map k in
-                       FStar_Compiler_Util.must uu___3 in
-                     FStar_Compiler_Util.smap_add working_map suffix filename;
-                     FStar_Compiler_Effect.op_Colon_Equals found true))
-                 else ());
-          FStar_Compiler_Effect.op_Bang found
-let (collect_one :
-  files_for_module_name ->
-    Prims.string ->
-      (Prims.string -> parsing_data FStar_Pervasives_Native.option) ->
-        (parsing_data * dependence Prims.list * Prims.bool * dependence
-          Prims.list))
-  =
-  fun original_map ->
-    fun filename ->
-      fun get_parsing_data_from_cache ->
-        let from_parsing_data pd original_map1 filename1 =
-          let deps1 = FStar_Compiler_Util.mk_ref [] in
-          let has_inline_for_extraction = FStar_Compiler_Util.mk_ref false in
-          let mo_roots =
-            let mname = lowercase_module_name filename1 in
-            let uu___ =
-              (is_interface filename1) &&
-                (has_implementation original_map1 mname) in
-            if uu___ then [UseImplementation mname] else [] in
-          let auto_open =
-            let uu___ = hard_coded_dependencies filename1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___
-              (FStar_Compiler_List.map
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | (lid, k) ->
-                        P_implicit_open_module_or_namespace (k, lid))) in
-          let working_map = FStar_Compiler_Util.smap_copy original_map1 in
-          let set_interface_inlining uu___ =
-            let uu___1 = is_interface filename1 in
-            if uu___1
-            then
-              FStar_Compiler_Effect.op_Colon_Equals has_inline_for_extraction
-                true
-            else () in
-          let add_dep deps2 d =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Compiler_Effect.op_Bang deps2 in
-                FStar_Compiler_List.existsML (dep_subsumed_by d) uu___2 in
-              Prims.op_Negation uu___1 in
-            if uu___
-            then
-              let uu___1 =
-                let uu___2 = FStar_Compiler_Effect.op_Bang deps2 in d ::
-                  uu___2 in
-              FStar_Compiler_Effect.op_Colon_Equals deps2 uu___1
-            else () in
-          let dep_edge module_name1 is_friend =
-            if is_friend
-            then FriendImplementation module_name1
-            else PreferInterface module_name1 in
-          let add_dependence_edge original_or_working_map lid is_friend =
-            let key = lowercase_join_longident lid true in
-            let uu___ = resolve_module_name original_or_working_map key in
-            match uu___ with
-            | FStar_Pervasives_Native.Some module_name1 ->
-                (add_dep deps1 (dep_edge module_name1 is_friend); true)
-            | uu___1 -> false in
-          let record_open_module let_open lid =
-            let uu___ =
-              (let_open && (add_dependence_edge working_map lid false)) ||
-                ((Prims.op_Negation let_open) &&
-                   (add_dependence_edge original_map1 lid false)) in
-            if uu___
-            then true
-            else
-              (if let_open
-               then
-                 (let uu___3 = FStar_Ident.range_of_lid lid in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = string_of_lid lid true in
-                      FStar_Compiler_Util.format1 "Module not found: %s"
-                        uu___6 in
-                    (FStar_Errors.Warning_ModuleOrFileNotFoundWarning,
-                      uu___5) in
-                  FStar_Errors.log_issue uu___3 uu___4)
-               else ();
-               false) in
-          let record_open_namespace lid implicit_open =
-            let key = lowercase_join_longident lid true in
-            let r =
-              enter_namespace original_map1 working_map key implicit_open in
-            if (Prims.op_Negation r) && (Prims.op_Negation implicit_open)
-            then
-              let uu___ = FStar_Ident.range_of_lid lid in
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = string_of_lid lid true in
-                  FStar_Compiler_Util.format1
-                    "No modules in namespace %s and no file with that name either"
-                    uu___3 in
-                (FStar_Errors.Warning_ModuleOrFileNotFoundWarning, uu___2) in
-              FStar_Errors.log_issue uu___ uu___1
-            else () in
-          let record_open let_open lid =
-            let uu___ = record_open_module let_open lid in
-            if uu___
-            then ()
-            else
-              if Prims.op_Negation let_open
-              then record_open_namespace lid false
-              else () in
-          let record_implicit_open_module_or_namespace uu___ =
-            match uu___ with
-            | (lid, kind) ->
-                (match kind with
-                 | Open_namespace -> record_open_namespace lid true
-                 | Open_module ->
-                     let uu___1 = record_open_module false lid in ()) in
-          let record_module_alias ident lid =
-            let key =
-              let uu___ = FStar_Ident.string_of_id ident in
-              FStar_String.lowercase uu___ in
-            let alias = lowercase_join_longident lid true in
-            let uu___ = FStar_Compiler_Util.smap_try_find original_map1 alias in
-            match uu___ with
-            | FStar_Pervasives_Native.Some deps_of_aliased_module ->
-                (FStar_Compiler_Util.smap_add working_map key
-                   deps_of_aliased_module;
-                 (let uu___3 =
-                    let uu___4 = lowercase_join_longident lid true in
-                    dep_edge uu___4 false in
-                  add_dep deps1 uu___3);
-                 true)
-            | FStar_Pervasives_Native.None ->
-                ((let uu___2 = FStar_Ident.range_of_lid lid in
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_Util.format1
-                        "module not found in search path: %s" alias in
-                    (FStar_Errors.Warning_ModuleOrFileNotFoundWarning,
-                      uu___4) in
-                  FStar_Errors.log_issue uu___2 uu___3);
-                 false) in
-          let add_dep_on_module module_name1 is_friend =
-            let uu___ =
-              add_dependence_edge working_map module_name1 is_friend in
-            if uu___
-            then ()
-            else
-              (let uu___2 =
-                 FStar_Options.debug_at_level_no_module
-                   (FStar_Options.Other "Dep") in
-               if uu___2
-               then
-                 let uu___3 = FStar_Ident.range_of_lid module_name1 in
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Ident.string_of_lid module_name1 in
-                     FStar_Compiler_Util.format1
-                       "Unbound module reference %s" uu___6 in
-                   (FStar_Errors.Warning_UnboundModuleReference, uu___5) in
-                 FStar_Errors.log_issue uu___3 uu___4
-               else ()) in
-          let record_lid lid =
-            let uu___ = FStar_Ident.ns_of_lid lid in
-            match uu___ with
-            | [] -> ()
-            | ns ->
-                let module_name1 = FStar_Ident.lid_of_ids ns in
-                add_dep_on_module module_name1 false in
-          let begin_module lid =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Ident.ns_of_lid lid in
-                FStar_Compiler_List.length uu___2 in
-              uu___1 > Prims.int_zero in
-            if uu___
-            then
-              let uu___1 =
-                let uu___2 = namespace_of_lid lid in
-                enter_namespace original_map1 working_map uu___2 in
-              ()
-            else () in
-          (match pd with
-           | Mk_pd l ->
-               FStar_Compiler_Effect.op_Bar_Greater
-                 (FStar_Compiler_List.op_At auto_open l)
-                 (FStar_Compiler_List.iter
-                    (fun elt ->
-                       match elt with
-                       | P_begin_module lid -> begin_module lid
-                       | P_open (b, lid) -> record_open b lid
-                       | P_implicit_open_module_or_namespace (k, lid) ->
-                           record_implicit_open_module_or_namespace (lid, k)
-                       | P_dep (b, lid) -> add_dep_on_module lid b
-                       | P_alias (id, lid) ->
-                           let uu___1 = record_module_alias id lid in ()
-                       | P_lid lid -> record_lid lid
-                       | P_inline_for_extraction -> set_interface_inlining ())));
-          (let uu___1 = FStar_Compiler_Effect.op_Bang deps1 in
-           let uu___2 =
-             FStar_Compiler_Effect.op_Bang has_inline_for_extraction in
-           (uu___1, uu___2, mo_roots)) in
-        let data_from_cache =
-          FStar_Compiler_Effect.op_Bar_Greater filename
-            get_parsing_data_from_cache in
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater data_from_cache
-            FStar_Compiler_Util.is_some in
-        if uu___
-        then
-          ((let uu___2 =
-              FStar_Options.debug_at_level_no_module
-                (FStar_Options.Other "Dep") in
-            if uu___2
-            then
-              FStar_Compiler_Util.print1
-                "Reading the parsing data for %s from its checked file\n"
-                filename
-            else ());
-           (let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater data_from_cache
-                  FStar_Compiler_Util.must in
-              from_parsing_data uu___3 original_map filename in
-            match uu___2 with
-            | (deps1, has_inline_for_extraction, mo_roots) ->
-                let uu___3 =
-                  FStar_Compiler_Effect.op_Bar_Greater data_from_cache
-                    FStar_Compiler_Util.must in
-                (uu___3, deps1, has_inline_for_extraction, mo_roots)))
-        else
-          (let num_of_toplevelmods =
-             FStar_Compiler_Util.mk_ref Prims.int_zero in
-           let pd = FStar_Compiler_Util.mk_ref [] in
-           let add_to_parsing_data elt =
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Compiler_Effect.op_Bang pd in
-                 FStar_Compiler_List.existsML
-                   (fun e -> parsing_data_elt_eq e elt) uu___4 in
-               Prims.op_Negation uu___3 in
-             if uu___2
-             then
-               let uu___3 =
-                 let uu___4 = FStar_Compiler_Effect.op_Bang pd in elt ::
-                   uu___4 in
-               FStar_Compiler_Effect.op_Colon_Equals pd uu___3
-             else () in
-           let rec collect_module uu___2 =
-             match uu___2 with
-             | FStar_Parser_AST.Module (lid, decls) ->
-                 (check_module_declaration_against_filename lid filename;
-                  add_to_parsing_data (P_begin_module lid);
-                  collect_decls decls)
-             | FStar_Parser_AST.Interface (lid, decls, uu___3) ->
-                 (check_module_declaration_against_filename lid filename;
-                  add_to_parsing_data (P_begin_module lid);
-                  collect_decls decls)
-           and collect_decls decls =
-             FStar_Compiler_List.iter
-               (fun x ->
-                  collect_decl x.FStar_Parser_AST.d;
-                  FStar_Compiler_List.iter collect_term
-                    x.FStar_Parser_AST.attrs;
-                  (match x.FStar_Parser_AST.d with
-                   | FStar_Parser_AST.Val uu___4 when
-                       FStar_Compiler_List.contains
-                         FStar_Parser_AST.Inline_for_extraction
-                         x.FStar_Parser_AST.quals
-                       -> add_to_parsing_data P_inline_for_extraction
-                   | uu___4 -> ())) decls
-           and collect_decl d =
-             match d with
-             | FStar_Parser_AST.Include lid ->
-                 add_to_parsing_data (P_open (false, lid))
-             | FStar_Parser_AST.Open lid ->
-                 add_to_parsing_data (P_open (false, lid))
-             | FStar_Parser_AST.Friend lid ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = lowercase_join_longident lid true in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         FStar_Ident.lid_of_str in
-                     (true, uu___4) in
-                   P_dep uu___3 in
-                 add_to_parsing_data uu___2
-             | FStar_Parser_AST.ModuleAbbrev (ident, lid) ->
-                 add_to_parsing_data (P_alias (ident, lid))
-             | FStar_Parser_AST.TopLevelLet (uu___2, patterms) ->
-                 FStar_Compiler_List.iter
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (pat, t) -> (collect_pattern pat; collect_term t))
-                   patterms
-             | FStar_Parser_AST.Splice (uu___2, t) -> collect_term t
-             | FStar_Parser_AST.Assume (uu___2, t) -> collect_term t
-             | FStar_Parser_AST.SubEffect
-                 { FStar_Parser_AST.msource = uu___2;
-                   FStar_Parser_AST.mdest = uu___3;
-                   FStar_Parser_AST.lift_op =
-                     FStar_Parser_AST.NonReifiableLift t;_}
-                 -> collect_term t
-             | FStar_Parser_AST.SubEffect
-                 { FStar_Parser_AST.msource = uu___2;
-                   FStar_Parser_AST.mdest = uu___3;
-                   FStar_Parser_AST.lift_op = FStar_Parser_AST.LiftForFree t;_}
-                 -> collect_term t
-             | FStar_Parser_AST.Val (uu___2, t) -> collect_term t
-             | FStar_Parser_AST.SubEffect
-                 { FStar_Parser_AST.msource = uu___2;
-                   FStar_Parser_AST.mdest = uu___3;
-                   FStar_Parser_AST.lift_op = FStar_Parser_AST.ReifiableLift
-                     (t0, t1);_}
-                 -> (collect_term t0; collect_term t1)
-             | FStar_Parser_AST.Tycon (uu___2, tc, ts) ->
-                 (if tc
-                  then
-                    add_to_parsing_data
-                      (P_lid FStar_Parser_Const.mk_class_lid)
-                  else ();
-                  FStar_Compiler_List.iter collect_tycon ts)
-             | FStar_Parser_AST.Exception (uu___2, t) ->
-                 FStar_Compiler_Util.iter_opt t collect_term
-             | FStar_Parser_AST.NewEffect ed -> collect_effect_decl ed
-             | FStar_Parser_AST.LayeredEffect ed -> collect_effect_decl ed
-             | FStar_Parser_AST.Polymonadic_bind (uu___2, uu___3, uu___4, t)
-                 -> collect_term t
-             | FStar_Parser_AST.Polymonadic_subcomp (uu___2, uu___3, t) ->
-                 collect_term t
-             | FStar_Parser_AST.Pragma uu___2 -> ()
-             | FStar_Parser_AST.TopLevelModule lid ->
-                 (FStar_Compiler_Util.incr num_of_toplevelmods;
-                  (let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_Effect.op_Bang num_of_toplevelmods in
-                     uu___4 > Prims.int_one in
-                   if uu___3
-                   then
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 = string_of_lid lid true in
-                         FStar_Compiler_Util.format1
-                           "Automatic dependency analysis demands one module per file (module %s not supported)"
-                           uu___6 in
-                       (FStar_Errors.Fatal_OneModulePerFile, uu___5) in
-                     let uu___5 = FStar_Ident.range_of_lid lid in
-                     FStar_Errors.raise_error uu___4 uu___5
-                   else ()))
-           and collect_tycon uu___2 =
-             match uu___2 with
-             | FStar_Parser_AST.TyconAbstract (uu___3, binders, k) ->
-                 (collect_binders binders;
-                  FStar_Compiler_Util.iter_opt k collect_term)
-             | FStar_Parser_AST.TyconAbbrev (uu___3, binders, k, t) ->
-                 (collect_binders binders;
-                  FStar_Compiler_Util.iter_opt k collect_term;
-                  collect_term t)
-             | FStar_Parser_AST.TyconRecord
-                 (uu___3, binders, k, uu___4, identterms) ->
-                 (collect_binders binders;
-                  FStar_Compiler_Util.iter_opt k collect_term;
-                  collect_tycon_record identterms)
-             | FStar_Parser_AST.TyconVariant (uu___3, binders, k, identterms)
-                 ->
-                 (collect_binders binders;
-                  FStar_Compiler_Util.iter_opt k collect_term;
-                  (let uu___6 =
-                     FStar_Compiler_List.filter_map
-                       FStar_Pervasives_Native.__proj__Mktuple3__item___2
-                       identterms in
-                   FStar_Compiler_List.iter
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | FStar_Parser_AST.VpOfNotation t -> collect_term t
-                        | FStar_Parser_AST.VpArbitrary t -> collect_term t
-                        | FStar_Parser_AST.VpRecord (record, t) ->
-                            (collect_tycon_record record;
-                             FStar_Compiler_Util.iter_opt t collect_term))
-                     uu___6))
-           and collect_tycon_record r =
-             FStar_Compiler_List.iter
-               (fun uu___2 ->
-                  match uu___2 with
-                  | (uu___3, aq, attrs, t) ->
-                      (collect_aqual aq;
-                       FStar_Compiler_Effect.op_Bar_Greater attrs
-                         (FStar_Compiler_List.iter collect_term);
-                       collect_term t)) r
-           and collect_effect_decl uu___2 =
-             match uu___2 with
-             | FStar_Parser_AST.DefineEffect (uu___3, binders, t, decls) ->
-                 (collect_binders binders;
-                  collect_term t;
-                  collect_decls decls)
-             | FStar_Parser_AST.RedefineEffect (uu___3, binders, t) ->
-                 (collect_binders binders; collect_term t)
-           and collect_binders binders =
-             FStar_Compiler_List.iter collect_binder binders
-           and collect_binder b =
-             collect_aqual b.FStar_Parser_AST.aqual;
-             FStar_Compiler_Effect.op_Bar_Greater
-               b.FStar_Parser_AST.battributes
-               (FStar_Compiler_List.iter collect_term);
-             (match b with
-              | {
-                  FStar_Parser_AST.b = FStar_Parser_AST.Annotated (uu___4, t);
-                  FStar_Parser_AST.brange = uu___5;
-                  FStar_Parser_AST.blevel = uu___6;
-                  FStar_Parser_AST.aqual = uu___7;
-                  FStar_Parser_AST.battributes = uu___8;_} -> collect_term t
-              | {
-                  FStar_Parser_AST.b = FStar_Parser_AST.TAnnotated
-                    (uu___4, t);
-                  FStar_Parser_AST.brange = uu___5;
-                  FStar_Parser_AST.blevel = uu___6;
-                  FStar_Parser_AST.aqual = uu___7;
-                  FStar_Parser_AST.battributes = uu___8;_} -> collect_term t
-              | { FStar_Parser_AST.b = FStar_Parser_AST.NoName t;
-                  FStar_Parser_AST.brange = uu___4;
-                  FStar_Parser_AST.blevel = uu___5;
-                  FStar_Parser_AST.aqual = uu___6;
-                  FStar_Parser_AST.battributes = uu___7;_} -> collect_term t
-              | uu___4 -> ())
-           and collect_aqual uu___2 =
-             match uu___2 with
-             | FStar_Pervasives_Native.Some (FStar_Parser_AST.Meta t) ->
-                 collect_term t
-             | FStar_Pervasives_Native.Some (FStar_Parser_AST.TypeClassArg)
-                 ->
-                 add_to_parsing_data (P_lid FStar_Parser_Const.tcresolve_lid)
-             | uu___3 -> ()
-           and collect_term t = collect_term' t.FStar_Parser_AST.tm
-           and collect_constant uu___2 =
-             match uu___2 with
-             | FStar_Const.Const_int
-                 (uu___3, FStar_Pervasives_Native.Some
-                  (FStar_Const.Unsigned, FStar_Const.Sizet))
-                 ->
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       FStar_Compiler_Effect.op_Bar_Greater "fstar.sizeT"
-                         FStar_Ident.lid_of_str in
-                     (false, uu___6) in
-                   P_dep uu___5 in
-                 add_to_parsing_data uu___4
-             | FStar_Const.Const_int
-                 (uu___3, FStar_Pervasives_Native.Some (signedness, width))
-                 ->
-                 let u =
-                   match signedness with
-                   | FStar_Const.Unsigned -> "u"
-                   | FStar_Const.Signed -> "" in
-                 let w =
-                   match width with
-                   | FStar_Const.Int8 -> "8"
-                   | FStar_Const.Int16 -> "16"
-                   | FStar_Const.Int32 -> "32"
-                   | FStar_Const.Int64 -> "64" in
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 =
-                         FStar_Compiler_Util.format2 "fstar.%sint%s" u w in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___7
-                         FStar_Ident.lid_of_str in
-                     (false, uu___6) in
-                   P_dep uu___5 in
-                 add_to_parsing_data uu___4
-             | FStar_Const.Const_char uu___3 ->
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       FStar_Compiler_Effect.op_Bar_Greater "fstar.char"
-                         FStar_Ident.lid_of_str in
-                     (false, uu___6) in
-                   P_dep uu___5 in
-                 add_to_parsing_data uu___4
-             | uu___3 -> ()
-           and collect_term' uu___2 =
-             match uu___2 with
-             | FStar_Parser_AST.Wild -> ()
-             | FStar_Parser_AST.Const c -> collect_constant c
-             | FStar_Parser_AST.Op (uu___3, ts) ->
-                 FStar_Compiler_List.iter collect_term ts
-             | FStar_Parser_AST.Tvar uu___3 -> ()
-             | FStar_Parser_AST.Uvar uu___3 -> ()
-             | FStar_Parser_AST.Var lid -> add_to_parsing_data (P_lid lid)
-             | FStar_Parser_AST.Projector (lid, uu___3) ->
-                 add_to_parsing_data (P_lid lid)
-             | FStar_Parser_AST.Discrim lid ->
-                 add_to_parsing_data (P_lid lid)
-             | FStar_Parser_AST.Name lid -> add_to_parsing_data (P_lid lid)
-             | FStar_Parser_AST.Construct (lid, termimps) ->
-                 (add_to_parsing_data (P_lid lid);
-                  FStar_Compiler_List.iter
-                    (fun uu___4 ->
-                       match uu___4 with | (t, uu___5) -> collect_term t)
-                    termimps)
-             | FStar_Parser_AST.Abs (pats, t) ->
-                 (collect_patterns pats; collect_term t)
-             | FStar_Parser_AST.App (t1, t2, uu___3) ->
-                 (collect_term t1; collect_term t2)
-             | FStar_Parser_AST.Let (uu___3, patterms, t) ->
-                 (FStar_Compiler_List.iter
-                    (fun uu___5 ->
-                       match uu___5 with
-                       | (attrs_opt, (pat, t1)) ->
-                           ((let uu___7 =
-                               FStar_Compiler_Util.map_opt attrs_opt
-                                 (FStar_Compiler_List.iter collect_term) in
-                             ());
-                            collect_pattern pat;
-                            collect_term t1)) patterms;
-                  collect_term t)
-             | FStar_Parser_AST.LetOperator (lets, body) ->
-                 (FStar_Compiler_List.iter
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | (ident, pat, def) ->
-                           (collect_pattern pat; collect_term def)) lets;
-                  collect_term body)
-             | FStar_Parser_AST.LetOpen (lid, t) ->
-                 (add_to_parsing_data (P_open (true, lid)); collect_term t)
-             | FStar_Parser_AST.LetOpenRecord (r, rty, e) ->
-                 (collect_term r; collect_term rty; collect_term e)
-             | FStar_Parser_AST.Bind (uu___3, t1, t2) ->
-                 (collect_term t1; collect_term t2)
-             | FStar_Parser_AST.Seq (t1, t2) ->
-                 (collect_term t1; collect_term t2)
-             | FStar_Parser_AST.If (t1, uu___3, ret_opt, t2, t3) ->
-                 (collect_term t1;
-                  (match ret_opt with
-                   | FStar_Pervasives_Native.None -> ()
-                   | FStar_Pervasives_Native.Some (uu___6, ret, uu___7) ->
-                       collect_term ret);
-                  collect_term t2;
-                  collect_term t3)
-             | FStar_Parser_AST.Match (t, uu___3, ret_opt, bs) ->
-                 (collect_term t;
-                  (match ret_opt with
-                   | FStar_Pervasives_Native.None -> ()
-                   | FStar_Pervasives_Native.Some (uu___6, ret, uu___7) ->
-                       collect_term ret);
-                  collect_branches bs)
-             | FStar_Parser_AST.TryWith (t, bs) ->
-                 (collect_term t; collect_branches bs)
-             | FStar_Parser_AST.Ascribed
-                 (t1, t2, FStar_Pervasives_Native.None, uu___3) ->
-                 (collect_term t1; collect_term t2)
-             | FStar_Parser_AST.Ascribed
-                 (t1, t2, FStar_Pervasives_Native.Some tac, uu___3) ->
-                 (collect_term t1; collect_term t2; collect_term tac)
-             | FStar_Parser_AST.Record (t, idterms) ->
-                 (FStar_Compiler_Util.iter_opt t collect_term;
-                  FStar_Compiler_List.iter
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | (fn, t1) -> (collect_fieldname fn; collect_term t1))
-                    idterms)
-             | FStar_Parser_AST.Project (t, f) ->
-                 (collect_term t; collect_fieldname f)
-             | FStar_Parser_AST.Product (binders, t) ->
-                 (collect_binders binders; collect_term t)
-             | FStar_Parser_AST.Sum (binders, t) ->
-                 (FStar_Compiler_List.iter
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | FStar_Pervasives.Inl b -> collect_binder b
-                       | FStar_Pervasives.Inr t1 -> collect_term t1) binders;
-                  collect_term t)
-             | FStar_Parser_AST.QForall (binders, (uu___3, ts), t) ->
-                 (collect_binders binders;
-                  FStar_Compiler_List.iter
-                    (FStar_Compiler_List.iter collect_term) ts;
-                  collect_term t)
-             | FStar_Parser_AST.QExists (binders, (uu___3, ts), t) ->
-                 (collect_binders binders;
-                  FStar_Compiler_List.iter
-                    (FStar_Compiler_List.iter collect_term) ts;
-                  collect_term t)
-             | FStar_Parser_AST.Refine (binder, t) ->
-                 (collect_binder binder; collect_term t)
-             | FStar_Parser_AST.NamedTyp (uu___3, t) -> collect_term t
-             | FStar_Parser_AST.Paren t -> collect_term t
-             | FStar_Parser_AST.Requires (t, uu___3) -> collect_term t
-             | FStar_Parser_AST.Ensures (t, uu___3) -> collect_term t
-             | FStar_Parser_AST.Labeled (t, uu___3, uu___4) -> collect_term t
-             | FStar_Parser_AST.LexList l ->
-                 FStar_Compiler_List.iter collect_term l
-             | FStar_Parser_AST.WFOrder (t1, t2) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.WellFounded" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term t1;
-                  collect_term t2)
-             | FStar_Parser_AST.Decreases (t, uu___3) -> collect_term t
-             | FStar_Parser_AST.Quote (t, uu___3) -> collect_term t
-             | FStar_Parser_AST.Antiquote t -> collect_term t
-             | FStar_Parser_AST.VQuote t -> collect_term t
-             | FStar_Parser_AST.Attributes cattributes ->
-                 FStar_Compiler_List.iter collect_term cattributes
-             | FStar_Parser_AST.CalcProof (rel, init, steps) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Ident.lid_of_str "FStar.Calc" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term rel;
-                  collect_term init;
-                  FStar_Compiler_List.iter
-                    (fun uu___6 ->
-                       match uu___6 with
-                       | FStar_Parser_AST.CalcStep (rel1, just, next) ->
-                           (collect_term rel1;
-                            collect_term just;
-                            collect_term next)) steps)
-             | FStar_Parser_AST.IntroForall (bs, p, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_binders bs;
-                  collect_term p;
-                  collect_term e)
-             | FStar_Parser_AST.IntroExists (bs, t, vs, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_binders bs;
-                  collect_term t;
-                  FStar_Compiler_List.iter collect_term vs;
-                  collect_term e)
-             | FStar_Parser_AST.IntroImplies (p, q, x, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term p;
-                  collect_term q;
-                  collect_binder x;
-                  collect_term e)
-             | FStar_Parser_AST.IntroOr (b, p, q, r) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term p;
-                  collect_term q;
-                  collect_term r)
-             | FStar_Parser_AST.IntroAnd (p, q, r, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term p;
-                  collect_term q;
-                  collect_term r;
-                  collect_term e)
-             | FStar_Parser_AST.ElimForall (bs, p, vs) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_binders bs;
-                  collect_term p;
-                  FStar_Compiler_List.iter collect_term vs)
-             | FStar_Parser_AST.ElimExists (bs, p, q, b, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_binders bs;
-                  collect_term p;
-                  collect_term q;
-                  collect_binder b;
-                  collect_term e)
-             | FStar_Parser_AST.ElimImplies (p, q, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term p;
-                  collect_term q;
-                  collect_term e)
-             | FStar_Parser_AST.ElimAnd (p, q, r, x, y, e) ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term p;
-                  collect_term q;
-                  collect_term r;
-                  collect_binder x;
-                  collect_binder y;
-                  collect_term e)
-             | FStar_Parser_AST.ElimOr (p, q, r, x, e, y, e') ->
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.lid_of_str "FStar.Classical.Sugar" in
-                       (false, uu___6) in
-                     P_dep uu___5 in
-                   add_to_parsing_data uu___4);
-                  collect_term p;
-                  collect_term q;
-                  collect_term r;
-                  collect_binder x;
-                  collect_binder y;
-                  collect_term e;
-                  collect_term e')
-           and collect_patterns ps =
-             FStar_Compiler_List.iter collect_pattern ps
-           and collect_pattern p = collect_pattern' p.FStar_Parser_AST.pat
-           and collect_pattern' uu___2 =
-             match uu___2 with
-             | FStar_Parser_AST.PatVar (uu___3, aqual, attrs) ->
-                 (collect_aqual aqual;
-                  FStar_Compiler_Effect.op_Bar_Greater attrs
-                    (FStar_Compiler_List.iter collect_term))
-             | FStar_Parser_AST.PatTvar (uu___3, aqual, attrs) ->
-                 (collect_aqual aqual;
-                  FStar_Compiler_Effect.op_Bar_Greater attrs
-                    (FStar_Compiler_List.iter collect_term))
-             | FStar_Parser_AST.PatWild (aqual, attrs) ->
-                 (collect_aqual aqual;
-                  FStar_Compiler_Effect.op_Bar_Greater attrs
-                    (FStar_Compiler_List.iter collect_term))
-             | FStar_Parser_AST.PatOp uu___3 -> ()
-             | FStar_Parser_AST.PatConst uu___3 -> ()
-             | FStar_Parser_AST.PatVQuote t -> collect_term t
-             | FStar_Parser_AST.PatApp (p, ps) ->
-                 (collect_pattern p; collect_patterns ps)
-             | FStar_Parser_AST.PatName uu___3 -> ()
-             | FStar_Parser_AST.PatList ps -> collect_patterns ps
-             | FStar_Parser_AST.PatOr ps -> collect_patterns ps
-             | FStar_Parser_AST.PatTuple (ps, uu___3) -> collect_patterns ps
-             | FStar_Parser_AST.PatRecord lidpats ->
-                 FStar_Compiler_List.iter
-                   (fun uu___3 ->
-                      match uu___3 with | (uu___4, p) -> collect_pattern p)
-                   lidpats
-             | FStar_Parser_AST.PatAscribed
-                 (p, (t, FStar_Pervasives_Native.None)) ->
-                 (collect_pattern p; collect_term t)
-             | FStar_Parser_AST.PatAscribed
-                 (p, (t, FStar_Pervasives_Native.Some tac)) ->
-                 (collect_pattern p; collect_term t; collect_term tac)
-           and collect_branches bs =
-             FStar_Compiler_List.iter collect_branch bs
-           and collect_branch uu___2 =
-             match uu___2 with
-             | (pat, t1, t2) ->
-                 (collect_pattern pat;
-                  FStar_Compiler_Util.iter_opt t1 collect_term;
-                  collect_term t2)
-           and collect_fieldname fn =
-             let uu___2 = let uu___3 = FStar_Ident.nsstr fn in uu___3 <> "" in
-             if uu___2
-             then
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Ident.ns_of_lid fn in
-                     FStar_Ident.lid_of_ids uu___6 in
-                   (false, uu___5) in
-                 P_dep uu___4 in
-               add_to_parsing_data uu___3
-             else () in
-           let uu___2 = FStar_Parser_Driver.parse_file filename in
-           match uu___2 with
-           | (ast, uu___3) ->
-               (collect_module ast;
-                (let pd1 =
-                   let uu___5 =
-                     let uu___6 = FStar_Compiler_Effect.op_Bang pd in
-                     FStar_Compiler_List.rev uu___6 in
-                   Mk_pd uu___5 in
-                 let uu___5 = from_parsing_data pd1 original_map filename in
-                 match uu___5 with
-                 | (deps1, has_inline_for_extraction, mo_roots) ->
-                     (pd1, deps1, has_inline_for_extraction, mo_roots))))
-let (collect_one_cache :
-  (dependence Prims.list * dependence Prims.list * Prims.bool)
-    FStar_Compiler_Util.smap FStar_Compiler_Effect.ref)
-  =
-  let uu___ = FStar_Compiler_Util.smap_create Prims.int_zero in
-  FStar_Compiler_Util.mk_ref uu___
-let (set_collect_one_cache :
-  (dependence Prims.list * dependence Prims.list * Prims.bool)
-    FStar_Compiler_Util.smap -> unit)
-  =
-  fun cache -> FStar_Compiler_Effect.op_Colon_Equals collect_one_cache cache
-let (dep_graph_copy : dependence_graph -> dependence_graph) =
-  fun dep_graph ->
-    let uu___ = dep_graph in
-    match uu___ with
-    | Deps g -> let uu___1 = FStar_Compiler_Util.smap_copy g in Deps uu___1
-let (widen_deps :
-  module_name Prims.list ->
-    dependence_graph ->
-      files_for_module_name -> Prims.bool -> (Prims.bool * dependence_graph))
-  =
-  fun friends ->
-    fun dep_graph ->
-      fun file_system_map ->
-        fun widened ->
-          let widened1 = FStar_Compiler_Util.mk_ref widened in
-          let uu___ = dep_graph in
-          match uu___ with
-          | Deps dg ->
-              let uu___1 = deps_empty () in
-              (match uu___1 with
-               | Deps dg' ->
-                   let widen_one deps1 =
-                     FStar_Compiler_Effect.op_Bar_Greater deps1
-                       (FStar_Compiler_List.map
-                          (fun d ->
-                             match d with
-                             | PreferInterface m when
-                                 (FStar_Compiler_List.contains m friends) &&
-                                   (has_implementation file_system_map m)
-                                 ->
-                                 (FStar_Compiler_Effect.op_Colon_Equals
-                                    widened1 true;
-                                  FriendImplementation m)
-                             | uu___2 -> d)) in
-                   (FStar_Compiler_Util.smap_fold dg
-                      (fun filename ->
-                         fun dep_node1 ->
-                           fun uu___3 ->
-                             let uu___4 =
-                               let uu___5 = widen_one dep_node1.edges in
-                               { edges = uu___5; color = White } in
-                             FStar_Compiler_Util.smap_add dg' filename uu___4)
-                      ();
-                    (let uu___3 = FStar_Compiler_Effect.op_Bang widened1 in
-                     (uu___3, (Deps dg')))))
-let (topological_dependences_of' :
-  files_for_module_name ->
-    dependence_graph ->
-      Prims.string Prims.list ->
-        file_name Prims.list ->
-          Prims.bool -> (file_name Prims.list * Prims.bool))
-  =
-  fun file_system_map ->
-    fun dep_graph ->
-      fun interfaces_needing_inlining ->
-        fun root_files ->
-          fun widened ->
-            let rec all_friend_deps_1 dep_graph1 cycle uu___ filename =
-              match uu___ with
-              | (all_friends, all_files) ->
-                  let dep_node1 =
-                    let uu___1 = deps_try_find dep_graph1 filename in
-                    FStar_Compiler_Util.must uu___1 in
-                  (match dep_node1.color with
-                   | Gray ->
-                       failwith
-                         "Impossible: cycle detected after cycle detection has passed"
-                   | Black -> (all_friends, all_files)
-                   | White ->
-                       ((let uu___2 =
-                           FStar_Options.debug_at_level_no_module
-                             (FStar_Options.Other "Dep") in
-                         if uu___2
-                         then
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Compiler_List.map dep_to_string
-                                 dep_node1.edges in
-                             FStar_String.concat ", " uu___4 in
-                           FStar_Compiler_Util.print2
-                             "Visiting %s: direct deps are %s\n" filename
-                             uu___3
-                         else ());
-                        deps_add_dep dep_graph1 filename
-                          { edges = (dep_node1.edges); color = Gray };
-                        (let uu___3 =
-                           let uu___4 =
-                             dependences_of file_system_map dep_graph1
-                               root_files filename in
-                           all_friend_deps dep_graph1 cycle
-                             (all_friends, all_files) uu___4 in
-                         match uu___3 with
-                         | (all_friends1, all_files1) ->
-                             (deps_add_dep dep_graph1 filename
-                                { edges = (dep_node1.edges); color = Black };
-                              (let uu___6 =
-                                 FStar_Options.debug_at_level_no_module
-                                   (FStar_Options.Other "Dep") in
-                               if uu___6
-                               then
-                                 FStar_Compiler_Util.print1 "Adding %s\n"
-                                   filename
-                               else ());
-                              (let uu___6 =
-                                 let uu___7 =
-                                   FStar_Compiler_List.collect
-                                     (fun uu___8 ->
-                                        match uu___8 with
-                                        | FriendImplementation m -> [m]
-                                        | d -> []) dep_node1.edges in
-                                 FStar_Compiler_List.op_At uu___7
-                                   all_friends1 in
-                               (uu___6, (filename :: all_files1)))))))
-            and all_friend_deps dep_graph1 cycle all_friends filenames =
-              FStar_Compiler_List.fold_left
-                (fun all_friends1 ->
-                   fun k ->
-                     all_friend_deps_1 dep_graph1 (k :: cycle) all_friends1 k)
-                all_friends filenames in
-            let uu___ = all_friend_deps dep_graph [] ([], []) root_files in
-            match uu___ with
-            | (friends, all_files_0) ->
-                ((let uu___2 =
-                    FStar_Options.debug_at_level_no_module
-                      (FStar_Options.Other "Dep") in
-                  if uu___2
-                  then
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_Util.remove_dups
-                          (fun x -> fun y -> x = y) friends in
-                      FStar_String.concat ", " uu___4 in
-                    FStar_Compiler_Util.print3
-                      "Phase1 complete:\n\tall_files = %s\n\tall_friends=%s\n\tinterfaces_with_inlining=%s\n"
-                      (FStar_String.concat ", " all_files_0) uu___3
-                      (FStar_String.concat ", " interfaces_needing_inlining)
-                  else ());
-                 (let uu___2 =
-                    widen_deps friends dep_graph file_system_map widened in
-                  match uu___2 with
-                  | (widened1, dep_graph1) ->
-                      let uu___3 =
-                        (let uu___5 =
-                           FStar_Options.debug_at_level_no_module
-                             (FStar_Options.Other "Dep") in
-                         if uu___5
-                         then
-                           FStar_Compiler_Util.print_string
-                             "==============Phase2==================\n"
-                         else ());
-                        all_friend_deps dep_graph1 [] ([], []) root_files in
-                      (match uu___3 with
-                       | (uu___4, all_files) ->
-                           ((let uu___6 =
-                               FStar_Options.debug_at_level_no_module
-                                 (FStar_Options.Other "Dep") in
-                             if uu___6
-                             then
-                               FStar_Compiler_Util.print1
-                                 "Phase2 complete: all_files = %s\n"
-                                 (FStar_String.concat ", " all_files)
-                             else ());
-                            (all_files, widened1)))))
-let (phase1 :
-  files_for_module_name ->
-    dependence_graph ->
-      module_name Prims.list -> Prims.bool -> (Prims.bool * dependence_graph))
-  =
-  fun file_system_map ->
-    fun dep_graph ->
-      fun interfaces_needing_inlining ->
-        fun for_extraction ->
-          (let uu___1 =
-             FStar_Options.debug_at_level_no_module
-               (FStar_Options.Other "Dep") in
-           if uu___1
-           then
-             FStar_Compiler_Util.print_string
-               "==============Phase1==================\n"
-           else ());
-          (let widened = false in
-           let uu___1 = (FStar_Options.cmi ()) && for_extraction in
-           if uu___1
-           then
-             widen_deps interfaces_needing_inlining dep_graph file_system_map
-               widened
-           else (widened, dep_graph))
-let (topological_dependences_of :
-  files_for_module_name ->
-    dependence_graph ->
-      Prims.string Prims.list ->
-        file_name Prims.list ->
-          Prims.bool -> (file_name Prims.list * Prims.bool))
-  =
-  fun file_system_map ->
-    fun dep_graph ->
-      fun interfaces_needing_inlining ->
-        fun root_files ->
-          fun for_extraction ->
-            let uu___ =
-              phase1 file_system_map dep_graph interfaces_needing_inlining
-                for_extraction in
-            match uu___ with
-            | (widened, dep_graph1) ->
-                topological_dependences_of' file_system_map dep_graph1
-                  interfaces_needing_inlining root_files widened
-let (collect :
-  Prims.string Prims.list ->
-    (Prims.string -> parsing_data FStar_Pervasives_Native.option) ->
-      (Prims.string Prims.list * deps))
-  =
-  fun all_cmd_line_files ->
-    fun get_parsing_data_from_cache ->
-      let all_cmd_line_files1 =
-        FStar_Compiler_Effect.op_Bar_Greater all_cmd_line_files
-          (FStar_Compiler_List.map
-             (fun fn ->
-                let uu___ = FStar_Options.find_file fn in
-                match uu___ with
-                | FStar_Pervasives_Native.None ->
-                    let uu___1 =
-                      let uu___2 =
-                        FStar_Compiler_Util.format1
-                          "File %s could not be found\n" fn in
-                      (FStar_Errors.Fatal_ModuleOrFileNotFound, uu___2) in
-                    FStar_Errors.raise_err uu___1
-                | FStar_Pervasives_Native.Some fn1 -> fn1)) in
-      let dep_graph = deps_empty () in
-      let file_system_map = build_map all_cmd_line_files1 in
-      let interfaces_needing_inlining = FStar_Compiler_Util.mk_ref [] in
-      let add_interface_for_inlining l =
-        let l1 = lowercase_module_name l in
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bang interfaces_needing_inlining in
-          l1 :: uu___1 in
-        FStar_Compiler_Effect.op_Colon_Equals interfaces_needing_inlining
-          uu___ in
-      let parse_results = FStar_Compiler_Util.smap_create (Prims.of_int (40)) in
-      let rec discover_one file_name1 =
-        let uu___ =
-          let uu___1 = deps_try_find dep_graph file_name1 in
-          uu___1 = FStar_Pervasives_Native.None in
-        if uu___
-        then
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Compiler_Effect.op_Bang collect_one_cache in
-              FStar_Compiler_Util.smap_try_find uu___3 file_name1 in
-            match uu___2 with
-            | FStar_Pervasives_Native.Some cached -> ((Mk_pd []), cached)
-            | FStar_Pervasives_Native.None ->
-                let uu___3 =
-                  collect_one file_system_map file_name1
-                    get_parsing_data_from_cache in
-                (match uu___3 with
-                 | (parsing_data1, deps1, needs_interface_inlining,
-                    additional_roots) ->
-                     (parsing_data1,
-                       (deps1, additional_roots, needs_interface_inlining))) in
-          match uu___1 with
-          | (parsing_data1, (deps1, mo_roots, needs_interface_inlining)) ->
-              (if needs_interface_inlining
-               then add_interface_for_inlining file_name1
-               else ();
-               FStar_Compiler_Util.smap_add parse_results file_name1
-                 parsing_data1;
-               (let deps2 =
-                  let module_name1 = lowercase_module_name file_name1 in
-                  let uu___4 =
-                    (is_implementation file_name1) &&
-                      (has_interface file_system_map module_name1) in
-                  if uu___4
-                  then
-                    FStar_Compiler_List.op_At deps1
-                      [UseInterface module_name1]
-                  else deps1 in
-                let dep_node1 =
-                  let uu___4 = FStar_Compiler_List.unique deps2 in
-                  { edges = uu___4; color = White } in
-                deps_add_dep dep_graph file_name1 dep_node1;
-                (let uu___5 =
-                   FStar_Compiler_List.map
-                     (file_of_dep file_system_map all_cmd_line_files1)
-                     (FStar_Compiler_List.op_At deps2 mo_roots) in
-                 FStar_Compiler_List.iter discover_one uu___5)))
-        else () in
-      profile
-        (fun uu___1 ->
-           FStar_Compiler_List.iter discover_one all_cmd_line_files1)
-        "FStar.Parser.Dep.discover";
-      (let cycle_detected dep_graph1 cycle filename =
-         FStar_Compiler_Util.print1
-           "The cycle contains a subset of the modules in:\n%s \n"
-           (FStar_String.concat "\n`used by` " cycle);
-         print_graph dep_graph1;
-         FStar_Compiler_Util.print_string "\n";
-         (let uu___4 =
-            let uu___5 =
-              FStar_Compiler_Util.format1
-                "Recursive dependency on module %s\n" filename in
-            (FStar_Errors.Fatal_CyclicDependence, uu___5) in
-          FStar_Errors.raise_err uu___4) in
-       let full_cycle_detection all_command_line_files file_system_map1 =
-         let dep_graph1 = dep_graph_copy dep_graph in
-         let mo_files = FStar_Compiler_Util.mk_ref [] in
-         let rec aux cycle filename =
-           let node =
-             let uu___1 = deps_try_find dep_graph1 filename in
-             match uu___1 with
-             | FStar_Pervasives_Native.Some node1 -> node1
-             | FStar_Pervasives_Native.None ->
-                 let uu___2 =
-                   FStar_Compiler_Util.format1
-                     "Impossible: Failed to find dependencies of %s" filename in
-                 failwith uu___2 in
-           let direct_deps =
-             FStar_Compiler_Effect.op_Bar_Greater node.edges
-               (FStar_Compiler_List.collect
-                  (fun x ->
-                     match x with
-                     | UseInterface f ->
-                         let uu___1 =
-                           implementation_of_internal file_system_map1 f in
-                         (match uu___1 with
-                          | FStar_Pervasives_Native.None -> [x]
-                          | FStar_Pervasives_Native.Some fn when
-                              fn = filename -> [x]
-                          | uu___2 -> [x; UseImplementation f])
-                     | PreferInterface f ->
-                         let uu___1 =
-                           implementation_of_internal file_system_map1 f in
-                         (match uu___1 with
-                          | FStar_Pervasives_Native.None -> [x]
-                          | FStar_Pervasives_Native.Some fn when
-                              fn = filename -> [x]
-                          | uu___2 -> [x; UseImplementation f])
-                     | uu___1 -> [x])) in
-           match node.color with
-           | Gray -> cycle_detected dep_graph1 cycle filename
-           | Black -> ()
-           | White ->
-               (deps_add_dep dep_graph1 filename
-                  { edges = direct_deps; color = Gray };
-                (let uu___3 =
-                   dependences_of file_system_map1 dep_graph1
-                     all_command_line_files filename in
-                 FStar_Compiler_List.iter (fun k -> aux (k :: cycle) k)
-                   uu___3);
-                deps_add_dep dep_graph1 filename
-                  { edges = direct_deps; color = Black };
-                (let uu___4 = is_interface filename in
-                 if uu___4
-                 then
-                   let uu___5 =
-                     let uu___6 = lowercase_module_name filename in
-                     implementation_of_internal file_system_map1 uu___6 in
-                   FStar_Compiler_Util.iter_opt uu___5
-                     (fun impl ->
-                        if
-                          Prims.op_Negation
-                            (FStar_Compiler_List.contains impl
-                               all_command_line_files)
-                        then
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Compiler_Effect.op_Bang mo_files in
-                            impl :: uu___7 in
-                          FStar_Compiler_Effect.op_Colon_Equals mo_files
-                            uu___6
-                        else ())
-                 else ())) in
-         FStar_Compiler_List.iter (aux []) all_command_line_files;
-         (let uu___2 = FStar_Compiler_Effect.op_Bang mo_files in
-          FStar_Compiler_List.iter (aux []) uu___2) in
-       full_cycle_detection all_cmd_line_files1 file_system_map;
-       FStar_Compiler_Effect.op_Bar_Greater all_cmd_line_files1
-         (FStar_Compiler_List.iter
-            (fun f ->
-               let m = lowercase_module_name f in
-               FStar_Options.add_verify_module m));
-       (let inlining_ifaces =
-          FStar_Compiler_Effect.op_Bang interfaces_needing_inlining in
-        let uu___3 =
-          profile
-            (fun uu___4 ->
-               let uu___5 =
-                 let uu___6 = FStar_Options.codegen () in
-                 uu___6 <> FStar_Pervasives_Native.None in
-               topological_dependences_of file_system_map dep_graph
-                 inlining_ifaces all_cmd_line_files1 uu___5)
-            "FStar.Parser.Dep.topological_dependences_of" in
-        match uu___3 with
-        | (all_files, uu___4) ->
-            ((let uu___6 =
-                FStar_Options.debug_at_level_no_module
-                  (FStar_Options.Other "Dep") in
-              if uu___6
-              then
-                FStar_Compiler_Util.print1
-                  "Interfaces needing inlining: %s\n"
-                  (FStar_String.concat ", " inlining_ifaces)
-              else ());
-             (all_files,
-               (mk_deps dep_graph file_system_map all_cmd_line_files1
-                  all_files inlining_ifaces parse_results)))))
-let (deps_of : deps -> Prims.string -> Prims.string Prims.list) =
-  fun deps1 ->
-    fun f ->
-      dependences_of deps1.file_system_map deps1.dep_graph
-        deps1.cmd_line_files f
-let (print_digest : (Prims.string * Prims.string) Prims.list -> Prims.string)
-  =
-  fun dig ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater dig
-        (FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with
-              | (m, d) ->
-                  let uu___2 = FStar_Compiler_Util.base64_encode d in
-                  FStar_Compiler_Util.format2 "%s:%s" m uu___2)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "\n")
-let (print_make : deps -> unit) =
-  fun deps1 ->
-    let file_system_map = deps1.file_system_map in
-    let all_cmd_line_files = deps1.cmd_line_files in
-    let deps2 = deps1.dep_graph in
-    let keys = deps_keys deps2 in
-    FStar_Compiler_Effect.op_Bar_Greater keys
-      (FStar_Compiler_List.iter
-         (fun f ->
-            let dep_node1 =
-              let uu___ = deps_try_find deps2 f in
-              FStar_Compiler_Effect.op_Bar_Greater uu___
-                FStar_Compiler_Option.get in
-            let files =
-              FStar_Compiler_List.map
-                (file_of_dep file_system_map all_cmd_line_files)
-                dep_node1.edges in
-            let files1 =
-              FStar_Compiler_List.map
-                (fun s -> FStar_Compiler_Util.replace_chars s 32 "\\ ") files in
-            FStar_Compiler_Util.print2 "%s: %s\n\n" f
-              (FStar_String.concat " " files1)))
-let (print_raw : deps -> unit) =
-  fun deps1 ->
-    let uu___ = deps1.dep_graph in
-    match uu___ with
-    | Deps deps2 ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_Util.smap_fold deps2
-              (fun k ->
-                 fun dep_node1 ->
-                   fun out ->
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Compiler_List.map dep_to_string
-                             dep_node1.edges in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___5
-                           (FStar_String.concat ";\n\t") in
-                       FStar_Compiler_Util.format2 "%s -> [\n\t%s\n] " k
-                         uu___4 in
-                     uu___3 :: out) [] in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (FStar_String.concat ";;\n") in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          FStar_Compiler_Util.print_endline
-let (print_full : deps -> unit) =
-  fun deps1 ->
-    let sort_output_files orig_output_file_map =
-      let order = FStar_Compiler_Util.mk_ref [] in
-      let remaining_output_files =
-        FStar_Compiler_Util.smap_copy orig_output_file_map in
-      let visited_other_modules =
-        FStar_Compiler_Util.smap_create (Prims.of_int (41)) in
-      let should_visit lc_module_name =
-        (let uu___ =
-           FStar_Compiler_Util.smap_try_find remaining_output_files
-             lc_module_name in
-         FStar_Compiler_Option.isSome uu___) ||
-          (let uu___ =
-             FStar_Compiler_Util.smap_try_find visited_other_modules
-               lc_module_name in
-           FStar_Compiler_Option.isNone uu___) in
-      let mark_visiting lc_module_name =
-        let ml_file_opt =
-          FStar_Compiler_Util.smap_try_find remaining_output_files
-            lc_module_name in
-        FStar_Compiler_Util.smap_remove remaining_output_files lc_module_name;
-        FStar_Compiler_Util.smap_add visited_other_modules lc_module_name
-          true;
-        ml_file_opt in
-      let emit_output_file_opt ml_file_opt =
-        match ml_file_opt with
-        | FStar_Pervasives_Native.None -> ()
-        | FStar_Pervasives_Native.Some ml_file ->
-            let uu___ =
-              let uu___1 = FStar_Compiler_Effect.op_Bang order in ml_file ::
-                uu___1 in
-            FStar_Compiler_Effect.op_Colon_Equals order uu___ in
-      let rec aux uu___ =
-        match uu___ with
-        | [] -> ()
-        | lc_module_name::modules_to_extract ->
-            let visit_file file_opt =
-              match file_opt with
-              | FStar_Pervasives_Native.None -> ()
-              | FStar_Pervasives_Native.Some file_name1 ->
-                  let uu___1 = deps_try_find deps1.dep_graph file_name1 in
-                  (match uu___1 with
-                   | FStar_Pervasives_Native.None ->
-                       let uu___2 =
-                         FStar_Compiler_Util.format2
-                           "Impossible: module %s: %s not found"
-                           lc_module_name file_name1 in
-                       failwith uu___2
-                   | FStar_Pervasives_Native.Some
-                       { edges = immediate_deps; color = uu___2;_} ->
-                       let immediate_deps1 =
-                         FStar_Compiler_List.map
-                           (fun x ->
-                              FStar_String.lowercase (module_name_of_dep x))
-                           immediate_deps in
-                       aux immediate_deps1) in
-            ((let uu___2 = should_visit lc_module_name in
-              if uu___2
-              then
-                let ml_file_opt = mark_visiting lc_module_name in
-                ((let uu___4 = implementation_of deps1 lc_module_name in
-                  visit_file uu___4);
-                 (let uu___5 = interface_of deps1 lc_module_name in
-                  visit_file uu___5);
-                 emit_output_file_opt ml_file_opt)
-              else ());
-             aux modules_to_extract) in
-      let all_extracted_modules =
-        FStar_Compiler_Util.smap_keys orig_output_file_map in
-      aux all_extracted_modules;
-      (let uu___1 = FStar_Compiler_Effect.op_Bang order in
-       FStar_Compiler_List.rev uu___1) in
-    let sb =
-      let uu___ = FStar_BigInt.of_int_fs (Prims.of_int (10000)) in
-      FStar_StringBuffer.create uu___ in
-    let pr str =
-      let uu___ = FStar_StringBuffer.add str sb in
-      FStar_Compiler_Effect.op_Less_Bar (fun uu___1 -> ()) uu___ in
-    let print_entry target first_dep all_deps =
-      pr target; pr ": "; pr first_dep; pr "\\\n\t"; pr all_deps; pr "\n\n" in
-    let keys = deps_keys deps1.dep_graph in
-    let output_file ext fst_file =
-      let ml_base_name =
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Util.basename fst_file in
-            check_and_strip_suffix uu___2 in
-          FStar_Compiler_Option.get uu___1 in
-        FStar_Compiler_Util.replace_chars uu___ 46 "_" in
-      let uu___ = FStar_String.op_Hat ml_base_name ext in
-      FStar_Options.prepend_output_dir uu___ in
-    let norm_path s =
-      FStar_Compiler_Util.replace_chars
-        (FStar_Compiler_Util.replace_chars s 92 "/") 32 "\\ " in
-    let output_fs_file f = let uu___ = output_file ".fs" f in norm_path uu___ in
-    let output_ml_file f = let uu___ = output_file ".ml" f in norm_path uu___ in
-    let output_krml_file f =
-      let uu___ = output_file ".krml" f in norm_path uu___ in
-    let output_cmx_file f =
-      let uu___ = output_file ".cmx" f in norm_path uu___ in
-    let cache_file f = let uu___ = cache_file_name f in norm_path uu___ in
-    let uu___ =
-      phase1 deps1.file_system_map deps1.dep_graph
-        deps1.interfaces_with_inlining true in
-    match uu___ with
-    | (widened, dep_graph) ->
-        let all_checked_files =
-          FStar_Compiler_Effect.op_Bar_Greater keys
-            (FStar_Compiler_List.fold_left
-               (fun all_checked_files1 ->
-                  fun file_name1 ->
-                    let process_one_key uu___1 =
-                      let dep_node1 =
-                        let uu___2 = deps_try_find deps1.dep_graph file_name1 in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___2
-                          FStar_Compiler_Option.get in
-                      let uu___2 =
-                        let uu___3 = is_interface file_name1 in
-                        if uu___3
-                        then
-                          (FStar_Pervasives_Native.None,
-                            FStar_Pervasives_Native.None)
-                        else
-                          (let uu___5 =
-                             let uu___6 = lowercase_module_name file_name1 in
-                             interface_of deps1 uu___6 in
-                           match uu___5 with
-                           | FStar_Pervasives_Native.None ->
-                               (FStar_Pervasives_Native.None,
-                                 FStar_Pervasives_Native.None)
-                           | FStar_Pervasives_Native.Some iface ->
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       deps_try_find deps1.dep_graph iface in
-                                     FStar_Compiler_Option.get uu___9 in
-                                   uu___8.edges in
-                                 FStar_Pervasives_Native.Some uu___7 in
-                               ((FStar_Pervasives_Native.Some iface), uu___6)) in
-                      match uu___2 with
-                      | (iface_fn, iface_deps) ->
-                          let iface_deps1 =
-                            FStar_Compiler_Util.map_opt iface_deps
-                              (FStar_Compiler_List.filter
-                                 (fun iface_dep ->
-                                    let uu___3 =
-                                      FStar_Compiler_Util.for_some
-                                        (dep_subsumed_by iface_dep)
-                                        dep_node1.edges in
-                                    Prims.op_Negation uu___3)) in
-                          let norm_f = norm_path file_name1 in
-                          let files =
-                            FStar_Compiler_List.map
-                              (file_of_dep_aux true deps1.file_system_map
-                                 deps1.cmd_line_files) dep_node1.edges in
-                          let files1 =
-                            match iface_deps1 with
-                            | FStar_Pervasives_Native.None -> files
-                            | FStar_Pervasives_Native.Some iface_deps2 ->
-                                let iface_files =
-                                  FStar_Compiler_List.map
-                                    (file_of_dep_aux true
-                                       deps1.file_system_map
-                                       deps1.cmd_line_files) iface_deps2 in
-                                FStar_Compiler_Util.remove_dups
-                                  (fun x -> fun y -> x = y)
-                                  (FStar_Compiler_List.op_At files
-                                     iface_files) in
-                          let files2 =
-                            let uu___3 =
-                              FStar_Compiler_Effect.op_Bar_Greater iface_fn
-                                FStar_Compiler_Util.is_some in
-                            if uu___3
-                            then
-                              let iface_fn1 =
-                                FStar_Compiler_Effect.op_Bar_Greater iface_fn
-                                  FStar_Compiler_Util.must in
-                              let uu___4 =
-                                FStar_Compiler_Effect.op_Bar_Greater files1
-                                  (FStar_Compiler_List.filter
-                                     (fun f -> f <> iface_fn1)) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___4
-                                (fun files3 ->
-                                   let uu___5 = cache_file_name iface_fn1 in
-                                   uu___5 :: files3)
-                            else files1 in
-                          let files3 =
-                            FStar_Compiler_List.map norm_path files2 in
-                          let files4 = FStar_String.concat "\\\n\t" files3 in
-                          let cache_file_name1 = cache_file file_name1 in
-                          let all_checked_files2 =
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 = module_name_of_file file_name1 in
-                                FStar_Options.should_be_already_cached uu___5 in
-                              Prims.op_Negation uu___4 in
-                            if uu___3
-                            then
-                              (print_entry cache_file_name1 norm_f files4;
-                               cache_file_name1
-                               ::
-                               all_checked_files1)
-                            else all_checked_files1 in
-                          let uu___3 =
-                            let uu___4 = FStar_Options.cmi () in
-                            if uu___4
-                            then
-                              profile
-                                (fun uu___5 ->
-                                   let uu___6 = dep_graph_copy dep_graph in
-                                   topological_dependences_of'
-                                     deps1.file_system_map uu___6
-                                     deps1.interfaces_with_inlining
-                                     [file_name1] widened)
-                                "FStar.Parser.Dep.topological_dependences_of_2"
-                            else
-                              (let maybe_widen_deps f_deps =
-                                 FStar_Compiler_List.map
-                                   (fun dep ->
-                                      file_of_dep_aux false
-                                        deps1.file_system_map
-                                        deps1.cmd_line_files dep) f_deps in
-                               let fst_files =
-                                 maybe_widen_deps dep_node1.edges in
-                               let fst_files_from_iface =
-                                 match iface_deps1 with
-                                 | FStar_Pervasives_Native.None -> []
-                                 | FStar_Pervasives_Native.Some iface_deps2
-                                     -> maybe_widen_deps iface_deps2 in
-                               let uu___6 =
-                                 FStar_Compiler_Util.remove_dups
-                                   (fun x -> fun y -> x = y)
-                                   (FStar_Compiler_List.op_At fst_files
-                                      fst_files_from_iface) in
-                               (uu___6, false)) in
-                          (match uu___3 with
-                           | (all_fst_files_dep, widened1) ->
-                               let all_checked_fst_dep_files =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   all_fst_files_dep
-                                   (FStar_Compiler_List.map cache_file) in
-                               let all_checked_fst_dep_files_string =
-                                 FStar_String.concat " \\\n\t"
-                                   all_checked_fst_dep_files in
-                               ((let uu___5 = is_implementation file_name1 in
-                                 if uu___5
-                                 then
-                                   ((let uu___7 =
-                                       (FStar_Options.cmi ()) && widened1 in
-                                     if uu___7
-                                     then
-                                       let mname =
-                                         lowercase_module_name file_name1 in
-                                       ((let uu___9 =
-                                           output_ml_file file_name1 in
-                                         print_entry uu___9 cache_file_name1
-                                           all_checked_fst_dep_files_string);
-                                        (let uu___10 =
-                                           FStar_Options.should_extract mname
-                                             FStar_Options.FSharp in
-                                         if uu___10
-                                         then
-                                           let uu___11 =
-                                             output_fs_file file_name1 in
-                                           print_entry uu___11
-                                             cache_file_name1
-                                             all_checked_fst_dep_files_string
-                                         else ());
-                                        (let uu___10 =
-                                           output_krml_file file_name1 in
-                                         print_entry uu___10 cache_file_name1
-                                           all_checked_fst_dep_files_string))
-                                     else
-                                       (let mname =
-                                          lowercase_module_name file_name1 in
-                                        (let uu___10 =
-                                           output_ml_file file_name1 in
-                                         print_entry uu___10 cache_file_name1
-                                           "");
-                                        (let uu___11 =
-                                           FStar_Options.should_extract mname
-                                             FStar_Options.FSharp in
-                                         if uu___11
-                                         then
-                                           let uu___12 =
-                                             output_fs_file file_name1 in
-                                           print_entry uu___12
-                                             cache_file_name1 ""
-                                         else ());
-                                        (let uu___11 =
-                                           output_krml_file file_name1 in
-                                         print_entry uu___11 cache_file_name1
-                                           "")));
-                                    (let cmx_files =
-                                       let extracted_fst_files =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           all_fst_files_dep
-                                           (FStar_Compiler_List.filter
-                                              (fun df ->
-                                                 (let uu___7 =
-                                                    lowercase_module_name df in
-                                                  let uu___8 =
-                                                    lowercase_module_name
-                                                      file_name1 in
-                                                  uu___7 <> uu___8) &&
-                                                   (let uu___7 =
-                                                      lowercase_module_name
-                                                        df in
-                                                    FStar_Options.should_extract
-                                                      uu___7
-                                                      FStar_Options.OCaml))) in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         extracted_fst_files
-                                         (FStar_Compiler_List.map
-                                            output_cmx_file) in
-                                     let uu___7 =
-                                       let uu___8 =
-                                         lowercase_module_name file_name1 in
-                                       FStar_Options.should_extract uu___8
-                                         FStar_Options.OCaml in
-                                     if uu___7
-                                     then
-                                       let cmx_files1 =
-                                         FStar_String.concat "\\\n\t"
-                                           cmx_files in
-                                       let uu___8 =
-                                         output_cmx_file file_name1 in
-                                       let uu___9 = output_ml_file file_name1 in
-                                       print_entry uu___8 uu___9 cmx_files1
-                                     else ()))
-                                 else
-                                   (let uu___7 =
-                                      (let uu___8 =
-                                         let uu___9 =
-                                           lowercase_module_name file_name1 in
-                                         has_implementation
-                                           deps1.file_system_map uu___9 in
-                                       Prims.op_Negation uu___8) &&
-                                        (is_interface file_name1) in
-                                    if uu___7
-                                    then
-                                      let uu___8 =
-                                        (FStar_Options.cmi ()) &&
-                                          (widened1 || true) in
-                                      (if uu___8
-                                       then
-                                         let uu___9 =
-                                           output_krml_file file_name1 in
-                                         print_entry uu___9 cache_file_name1
-                                           all_checked_fst_dep_files_string
-                                       else
-                                         (let uu___10 =
-                                            output_krml_file file_name1 in
-                                          print_entry uu___10
-                                            cache_file_name1 ""))
-                                    else ()));
-                                all_checked_files2)) in
-                    profile process_one_key
-                      "FStar.Parser.Dep.process_one_key") []) in
-        let all_fst_files =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater keys
-              (FStar_Compiler_List.filter is_implementation) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_Compiler_Util.sort_with FStar_String.compare) in
-        let all_fsti_files =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater keys
-              (FStar_Compiler_List.filter is_interface) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_Compiler_Util.sort_with FStar_String.compare) in
-        let all_ml_files =
-          let ml_file_map =
-            FStar_Compiler_Util.smap_create (Prims.of_int (41)) in
-          FStar_Compiler_Effect.op_Bar_Greater all_fst_files
-            (FStar_Compiler_List.iter
-               (fun fst_file ->
-                  let mname = lowercase_module_name fst_file in
-                  let uu___2 =
-                    FStar_Options.should_extract mname FStar_Options.OCaml in
-                  if uu___2
-                  then
-                    let uu___3 = output_ml_file fst_file in
-                    FStar_Compiler_Util.smap_add ml_file_map mname uu___3
-                  else ()));
-          sort_output_files ml_file_map in
-        let all_fs_files =
-          let fs_file_map =
-            FStar_Compiler_Util.smap_create (Prims.of_int (41)) in
-          FStar_Compiler_Effect.op_Bar_Greater all_fst_files
-            (FStar_Compiler_List.iter
-               (fun fst_file ->
-                  let mname = lowercase_module_name fst_file in
-                  let uu___2 =
-                    FStar_Options.should_extract mname FStar_Options.FSharp in
-                  if uu___2
-                  then
-                    let uu___3 = output_fs_file fst_file in
-                    FStar_Compiler_Util.smap_add fs_file_map mname uu___3
-                  else ()));
-          sort_output_files fs_file_map in
-        let all_krml_files =
-          let krml_file_map =
-            FStar_Compiler_Util.smap_create (Prims.of_int (41)) in
-          FStar_Compiler_Effect.op_Bar_Greater keys
-            (FStar_Compiler_List.iter
-               (fun fst_file ->
-                  let mname = lowercase_module_name fst_file in
-                  let uu___2 =
-                    FStar_Options.should_extract mname FStar_Options.Krml in
-                  if uu___2
-                  then
-                    let uu___3 = output_krml_file fst_file in
-                    FStar_Compiler_Util.smap_add krml_file_map mname uu___3
-                  else ()));
-          sort_output_files krml_file_map in
-        let print_all tag files =
-          pr tag;
-          pr "=\\\n\t";
-          FStar_Compiler_List.iter (fun f -> pr (norm_path f); pr " \\\n\t")
-            files;
-          pr "\n" in
-        (FStar_Compiler_Effect.op_Bar_Greater all_fsti_files
-           (FStar_Compiler_List.iter
-              (fun fsti ->
-                 let mn = lowercase_module_name fsti in
-                 let range_of_file fsti1 =
-                   let r =
-                     FStar_Compiler_Range.set_file_of_range
-                       FStar_Compiler_Range.dummyRange fsti1 in
-                   let uu___2 = FStar_Compiler_Range.def_range r in
-                   FStar_Compiler_Range.set_use_range r uu___2 in
-                 let uu___2 =
-                   let uu___3 = has_implementation deps1.file_system_map mn in
-                   Prims.op_Negation uu___3 in
-                 if uu___2
-                 then
-                   let uu___3 = range_of_file fsti in
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 = module_name_of_file fsti in
-                       FStar_Compiler_Util.format1
-                         "Interface %s is admitted without an implementation"
-                         uu___6 in
-                     (FStar_Errors.Warning_WarnOnUse, uu___5) in
-                   FStar_Errors.log_issue uu___3 uu___4
-                 else ()));
-         print_all "ALL_FST_FILES" all_fst_files;
-         print_all "ALL_FSTI_FILES" all_fsti_files;
-         print_all "ALL_CHECKED_FILES" all_checked_files;
-         print_all "ALL_FS_FILES" all_fs_files;
-         print_all "ALL_ML_FILES" all_ml_files;
-         print_all "ALL_KRML_FILES" all_krml_files;
-         FStar_StringBuffer.output_channel FStar_Compiler_Util.stdout sb)
-let (print : deps -> unit) =
-  fun deps1 ->
-    let uu___ = FStar_Options.dep () in
-    match uu___ with
-    | FStar_Pervasives_Native.Some "make" -> print_make deps1
-    | FStar_Pervasives_Native.Some "full" ->
-        profile (fun uu___1 -> print_full deps1)
-          "FStar.Parser.Deps.print_full_deps"
-    | FStar_Pervasives_Native.Some "graph" -> print_graph deps1.dep_graph
-    | FStar_Pervasives_Native.Some "raw" -> print_raw deps1
-    | FStar_Pervasives_Native.Some uu___1 ->
-        FStar_Errors.raise_err
-          (FStar_Errors.Fatal_UnknownToolForDep, "unknown tool for --dep\n")
-    | FStar_Pervasives_Native.None -> ()
-let (print_fsmap :
-  (Prims.string FStar_Pervasives_Native.option * Prims.string
-    FStar_Pervasives_Native.option) FStar_Compiler_Util.smap -> Prims.string)
-  =
-  fun fsmap ->
-    FStar_Compiler_Util.smap_fold fsmap
-      (fun k ->
-         fun uu___ ->
-           fun s ->
-             match uu___ with
-             | (v0, v1) ->
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Compiler_Util.format3 "%s -> (%s, %s)" k
-                       (FStar_Compiler_Util.dflt "_" v0)
-                       (FStar_Compiler_Util.dflt "_" v1) in
-                   FStar_String.op_Hat "; " uu___2 in
-                 FStar_String.op_Hat s uu___1) ""
-let (module_has_interface : deps -> FStar_Ident.lident -> Prims.bool) =
-  fun deps1 ->
-    fun module_name1 ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid module_name1 in
-        FStar_String.lowercase uu___1 in
-      has_interface deps1.file_system_map uu___
-let (deps_has_implementation : deps -> FStar_Ident.lident -> Prims.bool) =
-  fun deps1 ->
-    fun module_name1 ->
-      let m =
-        let uu___ = FStar_Ident.string_of_lid module_name1 in
-        FStar_String.lowercase uu___ in
-      FStar_Compiler_Effect.op_Bar_Greater deps1.all_files
-        (FStar_Compiler_Util.for_some
-           (fun f ->
-              (is_implementation f) &&
-                (let uu___ =
-                   let uu___1 = module_name_of_file f in
-                   FStar_String.lowercase uu___1 in
-                 uu___ = m)))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Parser_Driver.ml b/src/ocaml-output/FStar_Parser_Driver.ml
deleted file mode 100644
index 12772849058..00000000000
--- a/src/ocaml-output/FStar_Parser_Driver.ml
+++ /dev/null
@@ -1,54 +0,0 @@
-open Prims
-let (is_cache_file : Prims.string -> Prims.bool) =
-  fun fn ->
-    let uu___ = FStar_Compiler_Util.get_file_extension fn in uu___ = ".cache"
-type fragment =
-  | Empty 
-  | Modul of FStar_Parser_AST.modul 
-  | Decls of FStar_Parser_AST.decl Prims.list 
-let (uu___is_Empty : fragment -> Prims.bool) =
-  fun projectee -> match projectee with | Empty -> true | uu___ -> false
-let (uu___is_Modul : fragment -> Prims.bool) =
-  fun projectee -> match projectee with | Modul _0 -> true | uu___ -> false
-let (__proj__Modul__item___0 : fragment -> FStar_Parser_AST.modul) =
-  fun projectee -> match projectee with | Modul _0 -> _0
-let (uu___is_Decls : fragment -> Prims.bool) =
-  fun projectee -> match projectee with | Decls _0 -> true | uu___ -> false
-let (__proj__Decls__item___0 : fragment -> FStar_Parser_AST.decl Prims.list)
-  = fun projectee -> match projectee with | Decls _0 -> _0
-let (parse_fragment : FStar_Parser_ParseIt.input_frag -> fragment) =
-  fun frag ->
-    let uu___ =
-      FStar_Parser_ParseIt.parse (FStar_Parser_ParseIt.Toplevel frag) in
-    match uu___ with
-    | FStar_Parser_ParseIt.ASTFragment (FStar_Pervasives.Inl modul, uu___1)
-        -> Modul modul
-    | FStar_Parser_ParseIt.ASTFragment (FStar_Pervasives.Inr [], uu___1) ->
-        Empty
-    | FStar_Parser_ParseIt.ASTFragment (FStar_Pervasives.Inr decls, uu___1)
-        -> Decls decls
-    | FStar_Parser_ParseIt.ParseError (e, msg, r) ->
-        FStar_Errors.raise_error (e, msg) r
-    | FStar_Parser_ParseIt.Term uu___1 ->
-        failwith
-          "Impossible: parsing a Toplevel always results in an ASTFragment"
-let (parse_file :
-  Prims.string ->
-    (FStar_Parser_AST.file * (Prims.string * FStar_Compiler_Range.range)
-      Prims.list))
-  =
-  fun fn ->
-    let uu___ = FStar_Parser_ParseIt.parse (FStar_Parser_ParseIt.Filename fn) in
-    match uu___ with
-    | FStar_Parser_ParseIt.ASTFragment (FStar_Pervasives.Inl ast, comments)
-        -> (ast, comments)
-    | FStar_Parser_ParseIt.ASTFragment (FStar_Pervasives.Inr uu___1, uu___2)
-        ->
-        let msg = FStar_Compiler_Util.format1 "%s: expected a module\n" fn in
-        let r = FStar_Compiler_Range.dummyRange in
-        FStar_Errors.raise_error (FStar_Errors.Fatal_ModuleExpected, msg) r
-    | FStar_Parser_ParseIt.ParseError (e, msg, r) ->
-        FStar_Errors.raise_error (e, msg) r
-    | FStar_Parser_ParseIt.Term uu___1 ->
-        failwith
-          "Impossible: parsing a Filename always results in an ASTFragment"
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Parser_ToDocument.ml b/src/ocaml-output/FStar_Parser_ToDocument.ml
deleted file mode 100644
index 8d38b4b08d3..00000000000
--- a/src/ocaml-output/FStar_Parser_ToDocument.ml
+++ /dev/null
@@ -1,4917 +0,0 @@
-open Prims
-let (maybe_unthunk : FStar_Parser_AST.term -> FStar_Parser_AST.term) =
-  fun t ->
-    match t.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Abs (uu___::[], body) -> body
-    | uu___ -> t
-let (min : Prims.int -> Prims.int -> Prims.int) =
-  fun x -> fun y -> if x > y then y else x
-let (max : Prims.int -> Prims.int -> Prims.int) =
-  fun x -> fun y -> if x > y then x else y
-let map_rev : 'a 'b . ('a -> 'b) -> 'a Prims.list -> 'b Prims.list =
-  fun f ->
-    fun l ->
-      let rec aux l1 acc =
-        match l1 with
-        | [] -> acc
-        | x::xs ->
-            let uu___ = let uu___1 = f x in uu___1 :: acc in aux xs uu___ in
-      aux l []
-let map_if_all :
-  'a 'b .
-    ('a -> 'b FStar_Pervasives_Native.option) ->
-      'a Prims.list -> 'b Prims.list FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun l ->
-      let rec aux l1 acc =
-        match l1 with
-        | [] -> acc
-        | x::xs ->
-            let uu___ = f x in
-            (match uu___ with
-             | FStar_Pervasives_Native.Some r -> aux xs (r :: acc)
-             | FStar_Pervasives_Native.None -> []) in
-      let r = aux l [] in
-      if (FStar_Compiler_List.length l) = (FStar_Compiler_List.length r)
-      then FStar_Pervasives_Native.Some r
-      else FStar_Pervasives_Native.None
-let rec all : 'a . ('a -> Prims.bool) -> 'a Prims.list -> Prims.bool =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> true
-      | x::xs -> let uu___ = f x in if uu___ then all f xs else false
-let (all1_explicit :
-  (FStar_Parser_AST.term * FStar_Parser_AST.imp) Prims.list -> Prims.bool) =
-  fun args ->
-    (Prims.op_Negation (FStar_Compiler_List.isEmpty args)) &&
-      (FStar_Compiler_Util.for_all
-         (fun uu___ ->
-            match uu___ with
-            | (uu___1, FStar_Parser_AST.Nothing) -> true
-            | uu___1 -> false) args)
-let (unfold_tuples : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref true
-let (str : Prims.string -> FStar_Pprint.document) =
-  fun s -> FStar_Pprint.doc_of_string s
-let default_or_map :
-  'uuuuu 'uuuuu1 .
-    'uuuuu ->
-      ('uuuuu1 -> 'uuuuu) -> 'uuuuu1 FStar_Pervasives_Native.option -> 'uuuuu
-  =
-  fun n ->
-    fun f ->
-      fun x ->
-        match x with
-        | FStar_Pervasives_Native.None -> n
-        | FStar_Pervasives_Native.Some x' -> f x'
-let (prefix2 :
-  FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document) =
-  fun prefix_ ->
-    fun body ->
-      FStar_Pprint.prefix (Prims.of_int (2)) Prims.int_one prefix_ body
-let (prefix2_nonempty :
-  FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document) =
-  fun prefix_ ->
-    fun body ->
-      if body = FStar_Pprint.empty then prefix_ else prefix2 prefix_ body
-let (op_Hat_Slash_Plus_Hat :
-  FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document) =
-  fun prefix_ -> fun body -> prefix2 prefix_ body
-let (jump2 : FStar_Pprint.document -> FStar_Pprint.document) =
-  fun body -> FStar_Pprint.jump (Prims.of_int (2)) Prims.int_one body
-let (infix2 :
-  FStar_Pprint.document ->
-    FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document)
-  = FStar_Pprint.infix (Prims.of_int (2)) Prims.int_one
-let (infix0 :
-  FStar_Pprint.document ->
-    FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document)
-  = FStar_Pprint.infix Prims.int_zero Prims.int_one
-let (break1 : FStar_Pprint.document) = FStar_Pprint.break_ Prims.int_one
-let separate_break_map :
-  'uuuuu .
-    FStar_Pprint.document ->
-      ('uuuuu -> FStar_Pprint.document) ->
-        'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun sep ->
-    fun f ->
-      fun l ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Pprint.op_Hat_Hat sep break1 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-          FStar_Pprint.separate_map uu___1 f l in
-        FStar_Pprint.group uu___
-let precede_break_separate_map :
-  'uuuuu .
-    FStar_Pprint.document ->
-      FStar_Pprint.document ->
-        ('uuuuu -> FStar_Pprint.document) ->
-          'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun prec ->
-    fun sep ->
-      fun f ->
-        fun l ->
-          let uu___ =
-            let uu___1 = FStar_Pprint.op_Hat_Hat prec FStar_Pprint.space in
-            let uu___2 =
-              let uu___3 = FStar_Compiler_List.hd l in
-              FStar_Compiler_Effect.op_Bar_Greater uu___3 f in
-            FStar_Pprint.precede uu___1 uu___2 in
-          let uu___1 =
-            let uu___2 = FStar_Compiler_List.tl l in
-            FStar_Pprint.concat_map
-              (fun x ->
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = f x in
-                     FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___5 in
-                   FStar_Pprint.op_Hat_Hat sep uu___4 in
-                 FStar_Pprint.op_Hat_Hat break1 uu___3) uu___2 in
-          FStar_Pprint.op_Hat_Hat uu___ uu___1
-let concat_break_map :
-  'uuuuu .
-    ('uuuuu -> FStar_Pprint.document) ->
-      'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun f ->
-    fun l ->
-      let uu___ =
-        FStar_Pprint.concat_map
-          (fun x -> let uu___1 = f x in FStar_Pprint.op_Hat_Hat uu___1 break1)
-          l in
-      FStar_Pprint.group uu___
-let (parens_with_nesting : FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    FStar_Pprint.surround (Prims.of_int (2)) Prims.int_zero
-      FStar_Pprint.lparen contents FStar_Pprint.rparen
-let (soft_parens_with_nesting :
-  FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    FStar_Pprint.soft_surround (Prims.of_int (2)) Prims.int_zero
-      FStar_Pprint.lparen contents FStar_Pprint.rparen
-let (braces_with_nesting : FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-      FStar_Pprint.lbrace contents FStar_Pprint.rbrace
-let (soft_braces_with_nesting :
-  FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    FStar_Pprint.soft_surround (Prims.of_int (2)) Prims.int_one
-      FStar_Pprint.lbrace contents FStar_Pprint.rbrace
-let (soft_braces_with_nesting_tight :
-  FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    FStar_Pprint.soft_surround (Prims.of_int (2)) Prims.int_zero
-      FStar_Pprint.lbrace contents FStar_Pprint.rbrace
-let (brackets_with_nesting : FStar_Pprint.document -> FStar_Pprint.document)
-  =
-  fun contents ->
-    FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-      FStar_Pprint.lbracket contents FStar_Pprint.rbracket
-let (soft_brackets_with_nesting :
-  FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    FStar_Pprint.soft_surround (Prims.of_int (2)) Prims.int_one
-      FStar_Pprint.lbracket contents FStar_Pprint.rbracket
-let (soft_begin_end_with_nesting :
-  FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    let uu___ = str "begin" in
-    let uu___1 = str "end" in
-    FStar_Pprint.soft_surround (Prims.of_int (2)) Prims.int_one uu___
-      contents uu___1
-let (tc_arg : FStar_Pprint.document -> FStar_Pprint.document) =
-  fun contents ->
-    let uu___ = str "{|" in
-    let uu___1 = str "|}" in
-    FStar_Pprint.soft_surround (Prims.of_int (2)) Prims.int_one uu___
-      contents uu___1
-let (is_tc_binder : FStar_Parser_AST.binder -> Prims.bool) =
-  fun b ->
-    match b.FStar_Parser_AST.aqual with
-    | FStar_Pervasives_Native.Some (FStar_Parser_AST.TypeClassArg) -> true
-    | uu___ -> false
-let (is_meta_qualifier :
-  FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option -> Prims.bool)
-  =
-  fun aq ->
-    match aq with
-    | FStar_Pervasives_Native.Some (FStar_Parser_AST.Meta uu___) -> true
-    | uu___ -> false
-let (is_joinable_binder : FStar_Parser_AST.binder -> Prims.bool) =
-  fun b ->
-    (let uu___ = is_tc_binder b in Prims.op_Negation uu___) &&
-      (Prims.op_Negation (is_meta_qualifier b.FStar_Parser_AST.aqual))
-let separate_map_last :
-  'uuuuu .
-    FStar_Pprint.document ->
-      (Prims.bool -> 'uuuuu -> FStar_Pprint.document) ->
-        'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun sep ->
-    fun f ->
-      fun es ->
-        let l = FStar_Compiler_List.length es in
-        let es1 =
-          FStar_Compiler_List.mapi
-            (fun i -> fun e -> f (i <> (l - Prims.int_one)) e) es in
-        FStar_Pprint.separate sep es1
-let separate_break_map_last :
-  'uuuuu .
-    FStar_Pprint.document ->
-      (Prims.bool -> 'uuuuu -> FStar_Pprint.document) ->
-        'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun sep ->
-    fun f ->
-      fun l ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Pprint.op_Hat_Hat sep break1 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-          separate_map_last uu___1 f l in
-        FStar_Pprint.group uu___
-let separate_map_or_flow :
-  'uuuuu .
-    FStar_Pprint.document ->
-      ('uuuuu -> FStar_Pprint.document) ->
-        'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun sep ->
-    fun f ->
-      fun l ->
-        if (FStar_Compiler_List.length l) < (Prims.of_int (10))
-        then FStar_Pprint.separate_map sep f l
-        else FStar_Pprint.flow_map sep f l
-let flow_map_last :
-  'uuuuu .
-    FStar_Pprint.document ->
-      (Prims.bool -> 'uuuuu -> FStar_Pprint.document) ->
-        'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun sep ->
-    fun f ->
-      fun es ->
-        let l = FStar_Compiler_List.length es in
-        let es1 =
-          FStar_Compiler_List.mapi
-            (fun i -> fun e -> f (i <> (l - Prims.int_one)) e) es in
-        FStar_Pprint.flow sep es1
-let separate_map_or_flow_last :
-  'uuuuu .
-    FStar_Pprint.document ->
-      (Prims.bool -> 'uuuuu -> FStar_Pprint.document) ->
-        'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun sep ->
-    fun f ->
-      fun l ->
-        if (FStar_Compiler_List.length l) < (Prims.of_int (10))
-        then separate_map_last sep f l
-        else flow_map_last sep f l
-let (separate_or_flow :
-  FStar_Pprint.document ->
-    FStar_Pprint.document Prims.list -> FStar_Pprint.document)
-  = fun sep -> fun l -> separate_map_or_flow sep FStar_Pervasives.id l
-let (surround_maybe_empty :
-  Prims.int ->
-    Prims.int ->
-      FStar_Pprint.document ->
-        FStar_Pprint.document ->
-          FStar_Pprint.document -> FStar_Pprint.document)
-  =
-  fun n ->
-    fun b ->
-      fun doc1 ->
-        fun doc2 ->
-          fun doc3 ->
-            if doc2 = FStar_Pprint.empty
-            then
-              let uu___ = FStar_Pprint.op_Hat_Slash_Hat doc1 doc3 in
-              FStar_Pprint.group uu___
-            else FStar_Pprint.surround n b doc1 doc2 doc3
-let soft_surround_separate_map :
-  'uuuuu .
-    Prims.int ->
-      Prims.int ->
-        FStar_Pprint.document ->
-          FStar_Pprint.document ->
-            FStar_Pprint.document ->
-              FStar_Pprint.document ->
-                ('uuuuu -> FStar_Pprint.document) ->
-                  'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun n ->
-    fun b ->
-      fun void_ ->
-        fun opening ->
-          fun sep ->
-            fun closing ->
-              fun f ->
-                fun xs ->
-                  if xs = []
-                  then void_
-                  else
-                    (let uu___1 = FStar_Pprint.separate_map sep f xs in
-                     FStar_Pprint.soft_surround n b opening uu___1 closing)
-let soft_surround_map_or_flow :
-  'uuuuu .
-    Prims.int ->
-      Prims.int ->
-        FStar_Pprint.document ->
-          FStar_Pprint.document ->
-            FStar_Pprint.document ->
-              FStar_Pprint.document ->
-                ('uuuuu -> FStar_Pprint.document) ->
-                  'uuuuu Prims.list -> FStar_Pprint.document
-  =
-  fun n ->
-    fun b ->
-      fun void_ ->
-        fun opening ->
-          fun sep ->
-            fun closing ->
-              fun f ->
-                fun xs ->
-                  if xs = []
-                  then void_
-                  else
-                    (let uu___1 = separate_map_or_flow sep f xs in
-                     FStar_Pprint.soft_surround n b opening uu___1 closing)
-let (is_unit : FStar_Parser_AST.term -> Prims.bool) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Const (FStar_Const.Const_unit) -> true
-    | uu___ -> false
-let (matches_var : FStar_Parser_AST.term -> FStar_Ident.ident -> Prims.bool)
-  =
-  fun t ->
-    fun x ->
-      match t.FStar_Parser_AST.tm with
-      | FStar_Parser_AST.Var y ->
-          let uu___ = FStar_Ident.string_of_id x in
-          let uu___1 = FStar_Ident.string_of_lid y in uu___ = uu___1
-      | uu___ -> false
-let (is_tuple_constructor : FStar_Ident.lident -> Prims.bool) =
-  FStar_Parser_Const.is_tuple_data_lid'
-let (is_dtuple_constructor : FStar_Ident.lident -> Prims.bool) =
-  FStar_Parser_Const.is_dtuple_data_lid'
-let (is_list_structure :
-  FStar_Ident.lident ->
-    FStar_Ident.lident -> FStar_Parser_AST.term -> Prims.bool)
-  =
-  fun cons_lid ->
-    fun nil_lid ->
-      let rec aux e =
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.Construct (lid, []) ->
-            FStar_Ident.lid_equals lid nil_lid
-        | FStar_Parser_AST.Construct (lid, uu___::(e2, uu___1)::[]) ->
-            (FStar_Ident.lid_equals lid cons_lid) && (aux e2)
-        | uu___ -> false in
-      aux
-let (is_list : FStar_Parser_AST.term -> Prims.bool) =
-  is_list_structure FStar_Parser_Const.cons_lid FStar_Parser_Const.nil_lid
-let rec (extract_from_list :
-  FStar_Parser_AST.term -> FStar_Parser_AST.term Prims.list) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Construct (uu___, []) -> []
-    | FStar_Parser_AST.Construct
-        (uu___,
-         (e1, FStar_Parser_AST.Nothing)::(e2, FStar_Parser_AST.Nothing)::[])
-        -> let uu___1 = extract_from_list e2 in e1 :: uu___1
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Parser_AST.term_to_string e in
-          FStar_Compiler_Util.format1 "Not a list %s" uu___2 in
-        failwith uu___1
-let (is_array : FStar_Parser_AST.term -> Prims.bool) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.App
-        ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var lid;
-           FStar_Parser_AST.range = uu___; FStar_Parser_AST.level = uu___1;_},
-         l, FStar_Parser_AST.Nothing)
-        ->
-        (FStar_Ident.lid_equals lid FStar_Parser_Const.array_of_list_lid) &&
-          (is_list l)
-    | uu___ -> false
-let rec (is_ref_set : FStar_Parser_AST.term -> Prims.bool) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Var maybe_empty_lid ->
-        FStar_Ident.lid_equals maybe_empty_lid FStar_Parser_Const.set_empty
-    | FStar_Parser_AST.App
-        ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var maybe_singleton_lid;
-           FStar_Parser_AST.range = uu___; FStar_Parser_AST.level = uu___1;_},
-         {
-           FStar_Parser_AST.tm = FStar_Parser_AST.App
-             ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var maybe_addr_of_lid;
-                FStar_Parser_AST.range = uu___2;
-                FStar_Parser_AST.level = uu___3;_},
-              e1, FStar_Parser_AST.Nothing);
-           FStar_Parser_AST.range = uu___4;
-           FStar_Parser_AST.level = uu___5;_},
-         FStar_Parser_AST.Nothing)
-        ->
-        (FStar_Ident.lid_equals maybe_singleton_lid
-           FStar_Parser_Const.set_singleton)
-          &&
-          (FStar_Ident.lid_equals maybe_addr_of_lid
-             FStar_Parser_Const.heap_addr_of_lid)
-    | FStar_Parser_AST.App
-        ({
-           FStar_Parser_AST.tm = FStar_Parser_AST.App
-             ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var maybe_union_lid;
-                FStar_Parser_AST.range = uu___;
-                FStar_Parser_AST.level = uu___1;_},
-              e1, FStar_Parser_AST.Nothing);
-           FStar_Parser_AST.range = uu___2;
-           FStar_Parser_AST.level = uu___3;_},
-         e2, FStar_Parser_AST.Nothing)
-        ->
-        ((FStar_Ident.lid_equals maybe_union_lid FStar_Parser_Const.set_union)
-           && (is_ref_set e1))
-          && (is_ref_set e2)
-    | uu___ -> false
-let rec (extract_from_ref_set :
-  FStar_Parser_AST.term -> FStar_Parser_AST.term Prims.list) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Var uu___ -> []
-    | FStar_Parser_AST.App
-        ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var uu___;
-           FStar_Parser_AST.range = uu___1;
-           FStar_Parser_AST.level = uu___2;_},
-         {
-           FStar_Parser_AST.tm = FStar_Parser_AST.App
-             ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var uu___3;
-                FStar_Parser_AST.range = uu___4;
-                FStar_Parser_AST.level = uu___5;_},
-              e1, FStar_Parser_AST.Nothing);
-           FStar_Parser_AST.range = uu___6;
-           FStar_Parser_AST.level = uu___7;_},
-         FStar_Parser_AST.Nothing)
-        -> [e1]
-    | FStar_Parser_AST.App
-        ({
-           FStar_Parser_AST.tm = FStar_Parser_AST.App
-             ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var uu___;
-                FStar_Parser_AST.range = uu___1;
-                FStar_Parser_AST.level = uu___2;_},
-              e1, FStar_Parser_AST.Nothing);
-           FStar_Parser_AST.range = uu___3;
-           FStar_Parser_AST.level = uu___4;_},
-         e2, FStar_Parser_AST.Nothing)
-        ->
-        let uu___5 = extract_from_ref_set e1 in
-        let uu___6 = extract_from_ref_set e2 in
-        FStar_Compiler_List.op_At uu___5 uu___6
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Parser_AST.term_to_string e in
-          FStar_Compiler_Util.format1 "Not a ref set %s" uu___2 in
-        failwith uu___1
-let (is_general_application : FStar_Parser_AST.term -> Prims.bool) =
-  fun e ->
-    let uu___ = (is_array e) || (is_ref_set e) in Prims.op_Negation uu___
-let (is_general_construction : FStar_Parser_AST.term -> Prims.bool) =
-  fun e -> let uu___ = is_list e in Prims.op_Negation uu___
-let (is_general_prefix_op : FStar_Ident.ident -> Prims.bool) =
-  fun op ->
-    let op_starting_char =
-      let uu___ = FStar_Ident.string_of_id op in
-      FStar_Compiler_Util.char_at uu___ Prims.int_zero in
-    ((op_starting_char = 33) || (op_starting_char = 63)) ||
-      ((op_starting_char = 126) &&
-         (let uu___ = FStar_Ident.string_of_id op in uu___ <> "~"))
-let (head_and_args :
-  FStar_Parser_AST.term ->
-    (FStar_Parser_AST.term * (FStar_Parser_AST.term * FStar_Parser_AST.imp)
-      Prims.list))
-  =
-  fun e ->
-    let rec aux e1 acc =
-      match e1.FStar_Parser_AST.tm with
-      | FStar_Parser_AST.App (head, arg, imp) -> aux head ((arg, imp) :: acc)
-      | uu___ -> (e1, acc) in
-    aux e []
-type associativity =
-  | Left 
-  | Right 
-  | NonAssoc 
-let (uu___is_Left : associativity -> Prims.bool) =
-  fun projectee -> match projectee with | Left -> true | uu___ -> false
-let (uu___is_Right : associativity -> Prims.bool) =
-  fun projectee -> match projectee with | Right -> true | uu___ -> false
-let (uu___is_NonAssoc : associativity -> Prims.bool) =
-  fun projectee -> match projectee with | NonAssoc -> true | uu___ -> false
-type token =
-  | StartsWith of FStar_Char.char 
-  | Exact of Prims.string 
-  | UnicodeOperator 
-let (uu___is_StartsWith : token -> Prims.bool) =
-  fun projectee ->
-    match projectee with | StartsWith _0 -> true | uu___ -> false
-let (__proj__StartsWith__item___0 : token -> FStar_Char.char) =
-  fun projectee -> match projectee with | StartsWith _0 -> _0
-let (uu___is_Exact : token -> Prims.bool) =
-  fun projectee -> match projectee with | Exact _0 -> true | uu___ -> false
-let (__proj__Exact__item___0 : token -> Prims.string) =
-  fun projectee -> match projectee with | Exact _0 -> _0
-let (uu___is_UnicodeOperator : token -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnicodeOperator -> true | uu___ -> false
-type associativity_level = (associativity * token Prims.list)
-let (token_to_string : token -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | StartsWith c ->
-        Prims.op_Hat (FStar_Compiler_Util.string_of_char c) ".*"
-    | Exact s -> s
-    | UnicodeOperator -> "<unicode-op>"
-let (is_non_latin_char : FStar_Char.char -> Prims.bool) =
-  fun s -> (FStar_Compiler_Util.int_of_char s) > (Prims.of_int (0x024f))
-let (matches_token : Prims.string -> token -> Prims.bool) =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | StartsWith c ->
-          let uu___1 = FStar_String.get s Prims.int_zero in uu___1 = c
-      | Exact s' -> s = s'
-      | UnicodeOperator ->
-          let uu___1 = FStar_String.get s Prims.int_zero in
-          is_non_latin_char uu___1
-let matches_level :
-  'uuuuu . Prims.string -> ('uuuuu * token Prims.list) -> Prims.bool =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | (assoc_levels, tokens) ->
-          let uu___1 = FStar_Compiler_List.tryFind (matches_token s) tokens in
-          uu___1 <> FStar_Pervasives_Native.None
-let (opinfix4 : associativity_level) = (Right, [Exact "**"; UnicodeOperator])
-let (opinfix3 : associativity_level) =
-  (Left, [StartsWith 42; StartsWith 47; StartsWith 37])
-let (opinfix2 : associativity_level) = (Left, [StartsWith 43; StartsWith 45])
-let (minus_lvl : associativity_level) = (Left, [Exact "-"])
-let (opinfix1 : associativity_level) =
-  (Right, [StartsWith 64; StartsWith 94])
-let (pipe_right : associativity_level) = (Left, [Exact "|>"])
-let (opinfix0d : associativity_level) = (Left, [StartsWith 36])
-let (opinfix0c : associativity_level) =
-  (Left, [StartsWith 61; StartsWith 60; StartsWith 62])
-let (equal : associativity_level) = (Left, [Exact "="])
-let (opinfix0b : associativity_level) = (Left, [StartsWith 38])
-let (opinfix0a : associativity_level) = (Left, [StartsWith 124])
-let (colon_equals : associativity_level) = (NonAssoc, [Exact ":="])
-let (amp : associativity_level) = (Right, [Exact "&"])
-let (colon_colon : associativity_level) = (Right, [Exact "::"])
-let (level_associativity_spec : associativity_level Prims.list) =
-  [opinfix4;
-  opinfix3;
-  opinfix2;
-  opinfix1;
-  pipe_right;
-  opinfix0d;
-  opinfix0c;
-  opinfix0b;
-  opinfix0a;
-  colon_equals;
-  amp;
-  colon_colon]
-let (level_table :
-  ((Prims.int * Prims.int * Prims.int) * token Prims.list) Prims.list) =
-  let levels_from_associativity l uu___ =
-    match uu___ with
-    | Left -> (l, l, (l - Prims.int_one))
-    | Right -> ((l - Prims.int_one), l, l)
-    | NonAssoc -> ((l - Prims.int_one), l, (l - Prims.int_one)) in
-  FStar_Compiler_List.mapi
-    (fun i ->
-       fun uu___ ->
-         match uu___ with
-         | (assoc, tokens) -> ((levels_from_associativity i assoc), tokens))
-    level_associativity_spec
-let (assign_levels :
-  associativity_level Prims.list ->
-    Prims.string -> (Prims.int * Prims.int * Prims.int))
-  =
-  fun token_associativity_spec ->
-    fun s ->
-      let uu___ = FStar_Compiler_List.tryFind (matches_level s) level_table in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (assoc_levels, uu___1) -> assoc_levels
-      | uu___1 -> failwith (Prims.op_Hat "Unrecognized operator " s)
-let max_level : 'uuuuu . ('uuuuu * token Prims.list) Prims.list -> Prims.int
-  =
-  fun l ->
-    let find_level_and_max n level =
-      let uu___ =
-        FStar_Compiler_List.tryFind
-          (fun uu___1 ->
-             match uu___1 with
-             | (uu___2, tokens) ->
-                 tokens = (FStar_Pervasives_Native.snd level)) level_table in
-      match uu___ with
-      | FStar_Pervasives_Native.Some ((uu___1, l1, uu___2), uu___3) ->
-          max n l1
-      | FStar_Pervasives_Native.None ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_List.map token_to_string
-                  (FStar_Pervasives_Native.snd level) in
-              FStar_String.concat "," uu___3 in
-            FStar_Compiler_Util.format1 "Undefined associativity level %s"
-              uu___2 in
-          failwith uu___1 in
-    FStar_Compiler_List.fold_left find_level_and_max Prims.int_zero l
-let (levels : Prims.string -> (Prims.int * Prims.int * Prims.int)) =
-  fun op ->
-    let uu___ = assign_levels level_associativity_spec op in
-    match uu___ with
-    | (left, mine, right) ->
-        if op = "*"
-        then ((left - Prims.int_one), mine, right)
-        else (left, mine, right)
-let (operatorInfix0ad12 : associativity_level Prims.list) =
-  [opinfix0a; opinfix0b; opinfix0c; opinfix0d; opinfix1; opinfix2]
-let (is_operatorInfix0ad12 : FStar_Ident.ident -> Prims.bool) =
-  fun op ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_Ident.string_of_id op in
-        FStar_Compiler_Effect.op_Less_Bar matches_level uu___2 in
-      FStar_Compiler_List.tryFind uu___1 operatorInfix0ad12 in
-    uu___ <> FStar_Pervasives_Native.None
-let (is_operatorInfix34 : FStar_Ident.ident -> Prims.bool) =
-  let opinfix34 = [opinfix3; opinfix4] in
-  fun op ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_Ident.string_of_id op in
-        FStar_Compiler_Effect.op_Less_Bar matches_level uu___2 in
-      FStar_Compiler_List.tryFind uu___1 opinfix34 in
-    uu___ <> FStar_Pervasives_Native.None
-let (handleable_args_length : FStar_Ident.ident -> Prims.int) =
-  fun op ->
-    let op_s = FStar_Ident.string_of_id op in
-    let uu___ =
-      (is_general_prefix_op op) || (FStar_Compiler_List.mem op_s ["-"; "~"]) in
-    if uu___
-    then Prims.int_one
-    else
-      (let uu___2 =
-         ((is_operatorInfix0ad12 op) || (is_operatorInfix34 op)) ||
-           (FStar_Compiler_List.mem op_s
-              ["<==>"; "==>"; "\\/"; "/\\"; "="; "|>"; ":="; ".()"; ".[]"]) in
-       if uu___2
-       then (Prims.of_int (2))
-       else
-         if FStar_Compiler_List.mem op_s [".()<-"; ".[]<-"]
-         then (Prims.of_int (3))
-         else Prims.int_zero)
-let handleable_op :
-  'uuuuu . FStar_Ident.ident -> 'uuuuu Prims.list -> Prims.bool =
-  fun op ->
-    fun args ->
-      match FStar_Compiler_List.length args with
-      | uu___ when uu___ = Prims.int_zero -> true
-      | uu___ when uu___ = Prims.int_one ->
-          (is_general_prefix_op op) ||
-            (let uu___1 = FStar_Ident.string_of_id op in
-             FStar_Compiler_List.mem uu___1 ["-"; "~"])
-      | uu___ when uu___ = (Prims.of_int (2)) ->
-          ((is_operatorInfix0ad12 op) || (is_operatorInfix34 op)) ||
-            (let uu___1 = FStar_Ident.string_of_id op in
-             FStar_Compiler_List.mem uu___1
-               ["<==>"; "==>"; "\\/"; "/\\"; "="; "|>"; ":="; ".()"; ".[]"])
-      | uu___ when uu___ = (Prims.of_int (3)) ->
-          let uu___1 = FStar_Ident.string_of_id op in
-          FStar_Compiler_List.mem uu___1 [".()<-"; ".[]<-"]
-      | uu___ -> false
-type annotation_style =
-  | Binders of (Prims.int * Prims.int * Prims.bool) 
-  | Arrows of (Prims.int * Prims.int) 
-let (uu___is_Binders : annotation_style -> Prims.bool) =
-  fun projectee -> match projectee with | Binders _0 -> true | uu___ -> false
-let (__proj__Binders__item___0 :
-  annotation_style -> (Prims.int * Prims.int * Prims.bool)) =
-  fun projectee -> match projectee with | Binders _0 -> _0
-let (uu___is_Arrows : annotation_style -> Prims.bool) =
-  fun projectee -> match projectee with | Arrows _0 -> true | uu___ -> false
-let (__proj__Arrows__item___0 : annotation_style -> (Prims.int * Prims.int))
-  = fun projectee -> match projectee with | Arrows _0 -> _0
-let (all_binders_annot : FStar_Parser_AST.term -> Prims.bool) =
-  fun e ->
-    let is_binder_annot b =
-      match b.FStar_Parser_AST.b with
-      | FStar_Parser_AST.Annotated uu___ -> true
-      | uu___ -> false in
-    let rec all_binders e1 l =
-      match e1.FStar_Parser_AST.tm with
-      | FStar_Parser_AST.Product (bs, tgt) ->
-          let uu___ = FStar_Compiler_List.for_all is_binder_annot bs in
-          if uu___
-          then all_binders tgt (l + (FStar_Compiler_List.length bs))
-          else (false, Prims.int_zero)
-      | uu___ -> (true, (l + Prims.int_one)) in
-    let uu___ = all_binders e Prims.int_zero in
-    match uu___ with
-    | (b, l) -> if b && (l > Prims.int_one) then true else false
-type catf =
-  FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document
-let (cat_with_colon :
-  FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document) =
-  fun x ->
-    fun y ->
-      let uu___ = FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon y in
-      FStar_Pprint.op_Hat_Hat x uu___
-let (comment_stack :
-  (Prims.string * FStar_Compiler_Range.range) Prims.list
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref []
-type decl_meta =
-  {
-  r: FStar_Compiler_Range.range ;
-  has_qs: Prims.bool ;
-  has_attrs: Prims.bool }
-let (__proj__Mkdecl_meta__item__r : decl_meta -> FStar_Compiler_Range.range)
-  = fun projectee -> match projectee with | { r; has_qs; has_attrs;_} -> r
-let (__proj__Mkdecl_meta__item__has_qs : decl_meta -> Prims.bool) =
-  fun projectee -> match projectee with | { r; has_qs; has_attrs;_} -> has_qs
-let (__proj__Mkdecl_meta__item__has_attrs : decl_meta -> Prims.bool) =
-  fun projectee ->
-    match projectee with | { r; has_qs; has_attrs;_} -> has_attrs
-let (dummy_meta : decl_meta) =
-  { r = FStar_Compiler_Range.dummyRange; has_qs = false; has_attrs = false }
-let with_comment :
-  'uuuuu .
-    ('uuuuu -> FStar_Pprint.document) ->
-      'uuuuu -> FStar_Compiler_Range.range -> FStar_Pprint.document
-  =
-  fun printer ->
-    fun tm ->
-      fun tmrange ->
-        let rec comments_before_pos acc print_pos lookahead_pos =
-          let uu___ = FStar_Compiler_Effect.op_Bang comment_stack in
-          match uu___ with
-          | [] -> (acc, false)
-          | (c, crange)::cs ->
-              let comment =
-                let uu___1 = str c in
-                FStar_Pprint.op_Hat_Hat uu___1 FStar_Pprint.hardline in
-              let uu___1 =
-                FStar_Compiler_Range.range_before_pos crange print_pos in
-              if uu___1
-              then
-                (FStar_Compiler_Effect.op_Colon_Equals comment_stack cs;
-                 (let uu___3 = FStar_Pprint.op_Hat_Hat acc comment in
-                  comments_before_pos uu___3 print_pos lookahead_pos))
-              else
-                (let uu___3 =
-                   FStar_Compiler_Range.range_before_pos crange lookahead_pos in
-                 (acc, uu___3)) in
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Range.start_of_range tmrange in
-            FStar_Compiler_Range.end_of_line uu___2 in
-          let uu___2 = FStar_Compiler_Range.end_of_range tmrange in
-          comments_before_pos FStar_Pprint.empty uu___1 uu___2 in
-        match uu___ with
-        | (comments, has_lookahead) ->
-            let printed_e = printer tm in
-            let comments1 =
-              if has_lookahead
-              then
-                let pos = FStar_Compiler_Range.end_of_range tmrange in
-                let uu___1 = comments_before_pos comments pos pos in
-                FStar_Pervasives_Native.fst uu___1
-              else comments in
-            if comments1 = FStar_Pprint.empty
-            then printed_e
-            else
-              (let uu___2 = FStar_Pprint.op_Hat_Hat comments1 printed_e in
-               FStar_Pprint.group uu___2)
-let with_comment_sep :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu -> 'uuuuu1) ->
-      'uuuuu ->
-        FStar_Compiler_Range.range -> (FStar_Pprint.document * 'uuuuu1)
-  =
-  fun printer ->
-    fun tm ->
-      fun tmrange ->
-        let rec comments_before_pos acc print_pos lookahead_pos =
-          let uu___ = FStar_Compiler_Effect.op_Bang comment_stack in
-          match uu___ with
-          | [] -> (acc, false)
-          | (c, crange)::cs ->
-              let comment = str c in
-              let uu___1 =
-                FStar_Compiler_Range.range_before_pos crange print_pos in
-              if uu___1
-              then
-                (FStar_Compiler_Effect.op_Colon_Equals comment_stack cs;
-                 (let uu___3 =
-                    if acc = FStar_Pprint.empty
-                    then comment
-                    else
-                      (let uu___5 =
-                         FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                           comment in
-                       FStar_Pprint.op_Hat_Hat acc uu___5) in
-                  comments_before_pos uu___3 print_pos lookahead_pos))
-              else
-                (let uu___3 =
-                   FStar_Compiler_Range.range_before_pos crange lookahead_pos in
-                 (acc, uu___3)) in
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Range.start_of_range tmrange in
-            FStar_Compiler_Range.end_of_line uu___2 in
-          let uu___2 = FStar_Compiler_Range.end_of_range tmrange in
-          comments_before_pos FStar_Pprint.empty uu___1 uu___2 in
-        match uu___ with
-        | (comments, has_lookahead) ->
-            let printed_e = printer tm in
-            let comments1 =
-              if has_lookahead
-              then
-                let pos = FStar_Compiler_Range.end_of_range tmrange in
-                let uu___1 = comments_before_pos comments pos pos in
-                FStar_Pervasives_Native.fst uu___1
-              else comments in
-            (comments1, printed_e)
-let rec (place_comments_until_pos :
-  Prims.int ->
-    Prims.int ->
-      FStar_Compiler_Range.pos ->
-        decl_meta ->
-          FStar_Pprint.document ->
-            Prims.bool -> Prims.bool -> FStar_Pprint.document)
-  =
-  fun k ->
-    fun lbegin ->
-      fun pos ->
-        fun meta_decl ->
-          fun doc ->
-            fun r ->
-              fun init ->
-                let uu___ = FStar_Compiler_Effect.op_Bang comment_stack in
-                match uu___ with
-                | (comment, crange)::cs when
-                    FStar_Compiler_Range.range_before_pos crange pos ->
-                    (FStar_Compiler_Effect.op_Colon_Equals comment_stack cs;
-                     (let lnum =
-                        let uu___2 =
-                          let uu___3 =
-                            let uu___4 =
-                              FStar_Compiler_Range.start_of_range crange in
-                            FStar_Compiler_Range.line_of_pos uu___4 in
-                          uu___3 - lbegin in
-                        max k uu___2 in
-                      let lnum1 = min (Prims.of_int (2)) lnum in
-                      let doc1 =
-                        let uu___2 =
-                          let uu___3 =
-                            FStar_Pprint.repeat lnum1 FStar_Pprint.hardline in
-                          let uu___4 = str comment in
-                          FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                        FStar_Pprint.op_Hat_Hat doc uu___2 in
-                      let uu___2 =
-                        let uu___3 = FStar_Compiler_Range.end_of_range crange in
-                        FStar_Compiler_Range.line_of_pos uu___3 in
-                      place_comments_until_pos Prims.int_one uu___2 pos
-                        meta_decl doc1 true init))
-                | uu___1 ->
-                    if doc = FStar_Pprint.empty
-                    then FStar_Pprint.empty
-                    else
-                      (let lnum =
-                         let uu___3 = FStar_Compiler_Range.line_of_pos pos in
-                         uu___3 - lbegin in
-                       let lnum1 = min (Prims.of_int (3)) lnum in
-                       let lnum2 =
-                         if meta_decl.has_qs || meta_decl.has_attrs
-                         then lnum1 - Prims.int_one
-                         else lnum1 in
-                       let lnum3 = max k lnum2 in
-                       let lnum4 =
-                         if meta_decl.has_qs && meta_decl.has_attrs
-                         then (Prims.of_int (2))
-                         else lnum3 in
-                       let lnum5 = if init then (Prims.of_int (2)) else lnum4 in
-                       let uu___3 =
-                         FStar_Pprint.repeat lnum5 FStar_Pprint.hardline in
-                       FStar_Pprint.op_Hat_Hat doc uu___3)
-let separate_map_with_comments :
-  'uuuuu .
-    FStar_Pprint.document ->
-      FStar_Pprint.document ->
-        ('uuuuu -> FStar_Pprint.document) ->
-          'uuuuu Prims.list -> ('uuuuu -> decl_meta) -> FStar_Pprint.document
-  =
-  fun prefix ->
-    fun sep ->
-      fun f ->
-        fun xs ->
-          fun extract_meta ->
-            let fold_fun uu___ x =
-              match uu___ with
-              | (last_line, doc) ->
-                  let meta_decl = extract_meta x in
-                  let r = meta_decl.r in
-                  let doc1 =
-                    let uu___1 = FStar_Compiler_Range.start_of_range r in
-                    place_comments_until_pos Prims.int_one last_line uu___1
-                      meta_decl doc false false in
-                  let uu___1 =
-                    let uu___2 = FStar_Compiler_Range.end_of_range r in
-                    FStar_Compiler_Range.line_of_pos uu___2 in
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = f x in FStar_Pprint.op_Hat_Hat sep uu___4 in
-                    FStar_Pprint.op_Hat_Hat doc1 uu___3 in
-                  (uu___1, uu___2) in
-            let uu___ =
-              let uu___1 = FStar_Compiler_List.hd xs in
-              let uu___2 = FStar_Compiler_List.tl xs in (uu___1, uu___2) in
-            match uu___ with
-            | (x, xs1) ->
-                let init =
-                  let meta_decl = extract_meta x in
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Range.end_of_range meta_decl.r in
-                    FStar_Compiler_Range.line_of_pos uu___2 in
-                  let uu___2 =
-                    let uu___3 = f x in FStar_Pprint.op_Hat_Hat prefix uu___3 in
-                  (uu___1, uu___2) in
-                let uu___1 = FStar_Compiler_List.fold_left fold_fun init xs1 in
-                FStar_Pervasives_Native.snd uu___1
-let separate_map_with_comments_kw :
-  'uuuuu 'uuuuu1 .
-    'uuuuu ->
-      'uuuuu ->
-        ('uuuuu -> 'uuuuu1 -> FStar_Pprint.document) ->
-          'uuuuu1 Prims.list ->
-            ('uuuuu1 -> decl_meta) -> FStar_Pprint.document
-  =
-  fun prefix ->
-    fun sep ->
-      fun f ->
-        fun xs ->
-          fun extract_meta ->
-            let fold_fun uu___ x =
-              match uu___ with
-              | (last_line, doc) ->
-                  let meta_decl = extract_meta x in
-                  let r = meta_decl.r in
-                  let doc1 =
-                    let uu___1 = FStar_Compiler_Range.start_of_range r in
-                    place_comments_until_pos Prims.int_one last_line uu___1
-                      meta_decl doc false false in
-                  let uu___1 =
-                    let uu___2 = FStar_Compiler_Range.end_of_range r in
-                    FStar_Compiler_Range.line_of_pos uu___2 in
-                  let uu___2 =
-                    let uu___3 = f sep x in
-                    FStar_Pprint.op_Hat_Hat doc1 uu___3 in
-                  (uu___1, uu___2) in
-            let uu___ =
-              let uu___1 = FStar_Compiler_List.hd xs in
-              let uu___2 = FStar_Compiler_List.tl xs in (uu___1, uu___2) in
-            match uu___ with
-            | (x, xs1) ->
-                let init =
-                  let meta_decl = extract_meta x in
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Range.end_of_range meta_decl.r in
-                    FStar_Compiler_Range.line_of_pos uu___2 in
-                  let uu___2 = f prefix x in (uu___1, uu___2) in
-                let uu___1 = FStar_Compiler_List.fold_left fold_fun init xs1 in
-                FStar_Pervasives_Native.snd uu___1
-let rec (p_decl : FStar_Parser_AST.decl -> FStar_Pprint.document) =
-  fun d ->
-    let qualifiers =
-      match ((d.FStar_Parser_AST.quals), (d.FStar_Parser_AST.d)) with
-      | ((FStar_Parser_AST.Assumption)::[], FStar_Parser_AST.Assume
-         (id, uu___)) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Ident.string_of_id id in
-              FStar_Compiler_Util.char_at uu___3 Prims.int_zero in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              FStar_Compiler_Util.is_upper in
-          if uu___1
-          then
-            let uu___2 = p_qualifier FStar_Parser_AST.Assumption in
-            FStar_Pprint.op_Hat_Hat uu___2 FStar_Pprint.space
-          else p_qualifiers d.FStar_Parser_AST.quals
-      | uu___ -> p_qualifiers d.FStar_Parser_AST.quals in
-    let uu___ = p_attributes true d.FStar_Parser_AST.attrs in
-    let uu___1 =
-      let uu___2 = p_rawDecl d in FStar_Pprint.op_Hat_Hat qualifiers uu___2 in
-    FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_attributes :
-  Prims.bool -> FStar_Parser_AST.attributes_ -> FStar_Pprint.document) =
-  fun isTopLevel ->
-    fun attrs ->
-      match attrs with
-      | [] -> FStar_Pprint.empty
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = str (if isTopLevel then "@@ " else "@@@ ") in
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 = str "; " in
-                    let uu___8 =
-                      FStar_Compiler_List.map
-                        (p_noSeqTermAndComment false false) attrs in
-                    FStar_Pprint.flow uu___7 uu___8 in
-                  FStar_Pprint.op_Hat_Hat uu___6 FStar_Pprint.rbracket in
-                FStar_Pprint.align uu___5 in
-              FStar_Pprint.op_Hat_Hat uu___4
-                (if isTopLevel
-                 then FStar_Pprint.hardline
-                 else FStar_Pprint.empty) in
-            FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.lbracket uu___1
-and (p_justSig : FStar_Parser_AST.decl -> FStar_Pprint.document) =
-  fun d ->
-    match d.FStar_Parser_AST.d with
-    | FStar_Parser_AST.Val (lid, t) ->
-        let uu___ =
-          let uu___1 = str "val" in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = p_lident lid in
-              let uu___5 =
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space FStar_Pprint.colon in
-              FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        let uu___1 = p_typ false false t in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.TopLevelLet (uu___, lbs) ->
-        FStar_Pprint.separate_map FStar_Pprint.hardline
-          (fun lb ->
-             let uu___1 = let uu___2 = str "let" in p_letlhs uu___2 lb false in
-             FStar_Pprint.group uu___1) lbs
-    | uu___ -> FStar_Pprint.empty
-and (p_list :
-  (FStar_Ident.ident -> FStar_Pprint.document) ->
-    FStar_Pprint.document ->
-      FStar_Ident.ident Prims.list -> FStar_Pprint.document)
-  =
-  fun f ->
-    fun sep ->
-      fun l ->
-        let rec p_list' uu___ =
-          match uu___ with
-          | [] -> FStar_Pprint.empty
-          | x::[] -> f x
-          | x::xs ->
-              let uu___1 = f x in
-              let uu___2 =
-                let uu___3 = p_list' xs in FStar_Pprint.op_Hat_Hat sep uu___3 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        let uu___ = str "[" in
-        let uu___1 =
-          let uu___2 = p_list' l in
-          let uu___3 = str "]" in FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_rawDecl : FStar_Parser_AST.decl -> FStar_Pprint.document) =
-  fun d ->
-    match d.FStar_Parser_AST.d with
-    | FStar_Parser_AST.Open uid ->
-        let uu___ =
-          let uu___1 = str "open" in
-          let uu___2 = p_quident uid in
-          FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.Include uid ->
-        let uu___ =
-          let uu___1 = str "include" in
-          let uu___2 = p_quident uid in
-          FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.Friend uid ->
-        let uu___ =
-          let uu___1 = str "friend" in
-          let uu___2 = p_quident uid in
-          FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.ModuleAbbrev (uid1, uid2) ->
-        let uu___ =
-          let uu___1 = str "module" in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = p_uident uid1 in
-              let uu___5 =
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                  FStar_Pprint.equals in
-              FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        let uu___1 = p_quident uid2 in op_Hat_Slash_Plus_Hat uu___ uu___1
-    | FStar_Parser_AST.TopLevelModule uid ->
-        let uu___ =
-          let uu___1 = str "module" in
-          let uu___2 =
-            let uu___3 = p_quident uid in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.Tycon
-        (true, uu___, (FStar_Parser_AST.TyconAbbrev
-         (uid, tpars, FStar_Pervasives_Native.None, t))::[])
-        ->
-        let effect_prefix_doc =
-          let uu___1 = str "effect" in
-          let uu___2 =
-            let uu___3 = p_uident uid in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        let uu___1 =
-          let uu___2 = p_typars tpars in
-          FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-            effect_prefix_doc uu___2 FStar_Pprint.equals in
-        let uu___2 = p_typ false false t in
-        op_Hat_Slash_Plus_Hat uu___1 uu___2
-    | FStar_Parser_AST.Tycon (false, tc, tcdefs) ->
-        let s = if tc then str "class" else str "type" in
-        let uu___ =
-          let uu___1 = FStar_Compiler_List.hd tcdefs in
-          p_typeDeclWithKw s uu___1 in
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.tl tcdefs in
-          FStar_Compiler_Effect.op_Less_Bar
-            (FStar_Pprint.concat_map
-               (fun x ->
-                  let uu___3 =
-                    let uu___4 = str "and" in p_typeDeclWithKw uu___4 x in
-                  FStar_Pprint.op_Hat_Hat break1 uu___3)) uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.TopLevelLet (q, lbs) ->
-        let let_doc =
-          let uu___ = str "let" in
-          let uu___1 = p_letqualifier q in
-          FStar_Pprint.op_Hat_Hat uu___ uu___1 in
-        let uu___ = str "and" in
-        separate_map_with_comments_kw let_doc uu___ p_letbinding lbs
-          (fun uu___1 ->
-             match uu___1 with
-             | (p, t) ->
-                 let uu___2 =
-                   FStar_Compiler_Range.union_ranges
-                     p.FStar_Parser_AST.prange t.FStar_Parser_AST.range in
-                 { r = uu___2; has_qs = false; has_attrs = false })
-    | FStar_Parser_AST.Val (lid, t) ->
-        let uu___ =
-          let uu___1 = str "val" in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = p_lident lid in
-              let uu___5 = sig_as_binders_if_possible t false in
-              FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        FStar_Compiler_Effect.op_Less_Bar FStar_Pprint.group uu___
-    | FStar_Parser_AST.Assume (id, t) ->
-        let decl_keyword =
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Ident.string_of_id id in
-              FStar_Compiler_Util.char_at uu___2 Prims.int_zero in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              FStar_Compiler_Util.is_upper in
-          if uu___
-          then FStar_Pprint.empty
-          else
-            (let uu___2 = str "val" in
-             FStar_Pprint.op_Hat_Hat uu___2 FStar_Pprint.space) in
-        let uu___ =
-          let uu___1 = p_ident id in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = p_typ false false t in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___5 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.colon uu___4 in
-            FStar_Pprint.group uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        FStar_Pprint.op_Hat_Hat decl_keyword uu___
-    | FStar_Parser_AST.Exception (uid, t_opt) ->
-        let uu___ = str "exception" in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = p_uident uid in
-            let uu___4 =
-              FStar_Pprint.optional
-                (fun t ->
-                   let uu___5 =
-                     let uu___6 = str "of" in
-                     let uu___7 = p_typ false false t in
-                     op_Hat_Slash_Plus_Hat uu___6 uu___7 in
-                   FStar_Pprint.op_Hat_Hat break1 uu___5) t_opt in
-            FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.NewEffect ne ->
-        let uu___ = str "new_effect" in
-        let uu___1 =
-          let uu___2 = p_newEffect ne in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.SubEffect se ->
-        let uu___ = str "sub_effect" in
-        let uu___1 =
-          let uu___2 = p_subEffect se in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.LayeredEffect ne ->
-        let uu___ = str "layered_effect" in
-        let uu___1 =
-          let uu___2 = p_newEffect ne in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.Polymonadic_bind (l1, l2, l3, t) ->
-        let uu___ = str "polymonadic_bind" in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = p_quident l1 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 = p_quident l2 in
-                  let uu___8 =
-                    let uu___9 =
-                      let uu___10 = str "|>" in
-                      let uu___11 =
-                        let uu___12 = p_quident l3 in
-                        let uu___13 =
-                          let uu___14 = p_simpleTerm false false t in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.equals uu___14 in
-                        FStar_Pprint.op_Hat_Hat uu___12 uu___13 in
-                      FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.rparen uu___9 in
-                  FStar_Pprint.op_Hat_Hat uu___7 uu___8 in
-                FStar_Pprint.op_Hat_Hat break1 uu___6 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.comma uu___5 in
-            FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.Pragma p -> p_pragma p
-    | FStar_Parser_AST.Tycon (true, uu___, uu___1) ->
-        failwith
-          "Effect abbreviation is expected to be defined by an abbreviation"
-    | FStar_Parser_AST.Splice (ids, t) ->
-        let uu___ = str "%splice" in
-        let uu___1 =
-          let uu___2 = let uu___3 = str ";" in p_list p_uident uu___3 ids in
-          let uu___3 =
-            let uu___4 = p_term false false t in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-          FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_pragma : FStar_Parser_AST.pragma -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.SetOptions s ->
-        let uu___1 = str "#set-options" in
-        let uu___2 =
-          let uu___3 = let uu___4 = str s in FStar_Pprint.dquotes uu___4 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___1 uu___2
-    | FStar_Parser_AST.ResetOptions s_opt ->
-        let uu___1 = str "#reset-options" in
-        let uu___2 =
-          FStar_Pprint.optional
-            (fun s ->
-               let uu___3 = let uu___4 = str s in FStar_Pprint.dquotes uu___4 in
-               FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3) s_opt in
-        FStar_Pprint.op_Hat_Hat uu___1 uu___2
-    | FStar_Parser_AST.PushOptions s_opt ->
-        let uu___1 = str "#push-options" in
-        let uu___2 =
-          FStar_Pprint.optional
-            (fun s ->
-               let uu___3 = let uu___4 = str s in FStar_Pprint.dquotes uu___4 in
-               FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3) s_opt in
-        FStar_Pprint.op_Hat_Hat uu___1 uu___2
-    | FStar_Parser_AST.PopOptions -> str "#pop-options"
-    | FStar_Parser_AST.RestartSolver -> str "#restart-solver"
-    | FStar_Parser_AST.PrintEffectsGraph -> str "#print-effects-graph"
-and (p_typars : FStar_Parser_AST.binder Prims.list -> FStar_Pprint.document)
-  = fun bs -> p_binders true bs
-and (p_typeDeclWithKw :
-  FStar_Pprint.document -> FStar_Parser_AST.tycon -> FStar_Pprint.document) =
-  fun kw ->
-    fun typedecl ->
-      let uu___ = p_typeDecl kw typedecl in
-      match uu___ with
-      | (comm, decl, body, pre) ->
-          if comm = FStar_Pprint.empty
-          then let uu___1 = pre body in FStar_Pprint.op_Hat_Hat decl uu___1
-          else
-            (let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = pre body in
-                   FStar_Pprint.op_Hat_Slash_Hat uu___5 comm in
-                 FStar_Pprint.op_Hat_Hat decl uu___4 in
-               let uu___4 =
-                 let uu___5 =
-                   let uu___6 =
-                     let uu___7 =
-                       let uu___8 =
-                         FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline body in
-                       FStar_Pprint.op_Hat_Hat comm uu___8 in
-                     FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___7 in
-                   FStar_Pprint.nest (Prims.of_int (2)) uu___6 in
-                 FStar_Pprint.op_Hat_Hat decl uu___5 in
-               FStar_Pprint.ifflat uu___3 uu___4 in
-             FStar_Compiler_Effect.op_Less_Bar FStar_Pprint.group uu___2)
-and (p_typeDecl :
-  FStar_Pprint.document ->
-    FStar_Parser_AST.tycon ->
-      (FStar_Pprint.document * FStar_Pprint.document * FStar_Pprint.document
-        * (FStar_Pprint.document -> FStar_Pprint.document)))
-  =
-  fun pre ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Parser_AST.TyconAbstract (lid, bs, typ_opt) ->
-          let uu___1 = p_typeDeclPrefix pre false lid bs typ_opt in
-          (FStar_Pprint.empty, uu___1, FStar_Pprint.empty,
-            FStar_Pervasives.id)
-      | FStar_Parser_AST.TyconAbbrev (lid, bs, typ_opt, t) ->
-          let uu___1 = p_typ_sep false false t in
-          (match uu___1 with
-           | (comm, doc) ->
-               let uu___2 = p_typeDeclPrefix pre true lid bs typ_opt in
-               (comm, uu___2, doc, jump2))
-      | FStar_Parser_AST.TyconRecord
-          (lid, bs, typ_opt, attrs, record_field_decls) ->
-          let uu___1 = p_typeDeclPrefix pre true lid bs typ_opt in
-          let uu___2 =
-            let uu___3 = p_attributes false attrs in
-            let uu___4 = p_typeDeclRecord record_field_decls in
-            FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-          (FStar_Pprint.empty, uu___1, uu___2,
-            ((fun d -> FStar_Pprint.op_Hat_Hat FStar_Pprint.space d)))
-      | FStar_Parser_AST.TyconVariant (lid, bs, typ_opt, ct_decls) ->
-          let p_constructorBranchAndComments uu___1 =
-            match uu___1 with
-            | (uid, payload, attrs) ->
-                let range =
-                  let uu___2 =
-                    let uu___3 = FStar_Ident.range_of_id uid in
-                    let uu___4 =
-                      FStar_Compiler_Util.bind_opt payload
-                        (fun uu___5 ->
-                           match uu___5 with
-                           | FStar_Parser_AST.VpOfNotation t ->
-                               FStar_Pervasives_Native.Some
-                                 (t.FStar_Parser_AST.range)
-                           | FStar_Parser_AST.VpArbitrary t ->
-                               FStar_Pervasives_Native.Some
-                                 (t.FStar_Parser_AST.range)
-                           | FStar_Parser_AST.VpRecord (record, uu___6) ->
-                               FStar_Pervasives_Native.None) in
-                    FStar_Compiler_Util.dflt uu___3 uu___4 in
-                  FStar_Compiler_Range.extend_to_end_of_line uu___2 in
-                let uu___2 =
-                  with_comment_sep p_constructorBranch (uid, payload, attrs)
-                    range in
-                (match uu___2 with
-                 | (comm, ctor) ->
-                     inline_comment_or_above comm ctor FStar_Pprint.empty) in
-          let datacon_doc =
-            FStar_Pprint.separate_map FStar_Pprint.hardline
-              p_constructorBranchAndComments ct_decls in
-          let uu___1 = p_typeDeclPrefix pre true lid bs typ_opt in
-          (FStar_Pprint.empty, uu___1, datacon_doc, jump2)
-and (p_typeDeclRecord :
-  FStar_Parser_AST.tycon_record -> FStar_Pprint.document) =
-  fun fields ->
-    let p_recordField ps uu___ =
-      match uu___ with
-      | (lid, aq, attrs, t) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Range.extend_to_end_of_line
-                t.FStar_Parser_AST.range in
-            with_comment_sep (p_recordFieldDecl ps) (lid, aq, attrs, t)
-              uu___2 in
-          (match uu___1 with
-           | (comm, field) ->
-               let sep = if ps then FStar_Pprint.semi else FStar_Pprint.empty in
-               inline_comment_or_above comm field sep) in
-    let uu___ = separate_map_last FStar_Pprint.hardline p_recordField fields in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ braces_with_nesting
-and (p_typeDeclPrefix :
-  FStar_Pprint.document ->
-    Prims.bool ->
-      FStar_Ident.ident ->
-        FStar_Parser_AST.binder Prims.list ->
-          FStar_Parser_AST.knd FStar_Pervasives_Native.option ->
-            FStar_Pprint.document)
-  =
-  fun kw ->
-    fun eq ->
-      fun lid ->
-        fun bs ->
-          fun typ_opt ->
-            let with_kw cont =
-              let lid_doc = p_ident lid in
-              let kw_lid =
-                let uu___ = FStar_Pprint.op_Hat_Slash_Hat kw lid_doc in
-                FStar_Pprint.group uu___ in
-              cont kw_lid in
-            let typ =
-              let maybe_eq =
-                if eq then FStar_Pprint.equals else FStar_Pprint.empty in
-              match typ_opt with
-              | FStar_Pervasives_Native.None -> maybe_eq
-              | FStar_Pervasives_Native.Some t ->
-                  let uu___ =
-                    let uu___1 =
-                      let uu___2 = p_typ false false t in
-                      FStar_Pprint.op_Hat_Slash_Hat uu___2 maybe_eq in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___1 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.colon uu___ in
-            if bs = []
-            then with_kw (fun n -> prefix2 n typ)
-            else
-              (let binders = p_binders_list true bs in
-               with_kw
-                 (fun n ->
-                    let uu___1 =
-                      let uu___2 = FStar_Pprint.flow break1 binders in
-                      prefix2 n uu___2 in
-                    prefix2 uu___1 typ))
-and (p_recordFieldDecl :
-  Prims.bool ->
-    (FStar_Ident.ident * FStar_Parser_AST.aqual *
-      FStar_Parser_AST.attributes_ * FStar_Parser_AST.term) ->
-      FStar_Pprint.document)
-  =
-  fun ps ->
-    fun uu___ ->
-      match uu___ with
-      | (lid, aq, attrs, t) ->
-          let uu___1 =
-            let uu___2 = FStar_Pprint.optional p_aqual aq in
-            let uu___3 =
-              let uu___4 = p_attributes false attrs in
-              let uu___5 =
-                let uu___6 = p_lident lid in
-                let uu___7 =
-                  let uu___8 = p_typ ps false t in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.colon uu___8 in
-                FStar_Pprint.op_Hat_Hat uu___6 uu___7 in
-              FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-            FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-          FStar_Pprint.group uu___1
-and (p_constructorBranch :
-  (FStar_Ident.ident * FStar_Parser_AST.constructor_payload
-    FStar_Pervasives_Native.option * FStar_Parser_AST.attributes_) ->
-    FStar_Pprint.document)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (uid, variant, attrs) ->
-        let h isOf t =
-          let uu___1 = if isOf then str "of" else FStar_Pprint.colon in
-          let uu___2 =
-            let uu___3 = p_typ false false t in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = p_attributes false attrs in
-                let uu___6 = p_uident uid in
-                FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.bar uu___3 in
-          FStar_Pprint.group uu___2 in
-        let uu___2 =
-          default_or_map FStar_Pprint.empty
-            (fun payload ->
-               let uu___3 =
-                 let uu___4 =
-                   match payload with
-                   | FStar_Parser_AST.VpOfNotation t -> h true t
-                   | FStar_Parser_AST.VpArbitrary t -> h false t
-                   | FStar_Parser_AST.VpRecord (r, t) ->
-                       let uu___5 = p_typeDeclRecord r in
-                       let uu___6 =
-                         default_or_map FStar_Pprint.empty (h false) t in
-                       FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                 FStar_Pprint.group uu___4 in
-               FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3) variant in
-        FStar_Pprint.op_Hat_Hat uu___1 uu___2
-and (p_letlhs :
-  FStar_Pprint.document ->
-    (FStar_Parser_AST.pattern * FStar_Parser_AST.term) ->
-      Prims.bool -> FStar_Pprint.document)
-  =
-  fun kw ->
-    fun uu___ ->
-      fun inner_let ->
-        match uu___ with
-        | (pat, uu___1) ->
-            let uu___2 =
-              match pat.FStar_Parser_AST.pat with
-              | FStar_Parser_AST.PatAscribed
-                  (pat1, (t, FStar_Pervasives_Native.None)) ->
-                  (pat1,
-                    (FStar_Pervasives_Native.Some (t, FStar_Pprint.empty)))
-              | FStar_Parser_AST.PatAscribed
-                  (pat1, (t, FStar_Pervasives_Native.Some tac)) ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 = str "by" in
-                            let uu___9 =
-                              let uu___10 = p_atomicTerm (maybe_unthunk tac) in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___10 in
-                            FStar_Pprint.op_Hat_Hat uu___8 uu___9 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                        FStar_Pprint.group uu___6 in
-                      (t, uu___5) in
-                    FStar_Pervasives_Native.Some uu___4 in
-                  (pat1, uu___3)
-              | uu___3 -> (pat, FStar_Pervasives_Native.None) in
-            (match uu___2 with
-             | (pat1, ascr) ->
-                 (match pat1.FStar_Parser_AST.pat with
-                  | FStar_Parser_AST.PatApp
-                      ({
-                         FStar_Parser_AST.pat = FStar_Parser_AST.PatVar
-                           (lid, uu___3, uu___4);
-                         FStar_Parser_AST.prange = uu___5;_},
-                       pats)
-                      ->
-                      let ascr_doc =
-                        match ascr with
-                        | FStar_Pervasives_Native.Some (t, tac) ->
-                            let uu___6 = sig_as_binders_if_possible t true in
-                            FStar_Pprint.op_Hat_Hat uu___6 tac
-                        | FStar_Pervasives_Native.None -> FStar_Pprint.empty in
-                      let uu___6 =
-                        if inner_let
-                        then
-                          let uu___7 = pats_as_binders_if_possible pats in
-                          match uu___7 with | (bs, style) -> (bs, style)
-                        else
-                          (let uu___8 = pats_as_binders_if_possible pats in
-                           match uu___8 with | (bs, style) -> (bs, style)) in
-                      (match uu___6 with
-                       | (terms, style) ->
-                           let uu___7 =
-                             let uu___8 =
-                               let uu___9 =
-                                 let uu___10 = p_lident lid in
-                                 let uu___11 =
-                                   format_sig style terms ascr_doc true true in
-                                 FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                               FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                 uu___9 in
-                             FStar_Pprint.op_Hat_Hat kw uu___8 in
-                           FStar_Compiler_Effect.op_Less_Bar
-                             FStar_Pprint.group uu___7)
-                  | uu___3 ->
-                      let ascr_doc =
-                        match ascr with
-                        | FStar_Pervasives_Native.Some (t, tac) ->
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  p_typ_top
-                                    (Arrows
-                                       ((Prims.of_int (2)),
-                                         (Prims.of_int (2)))) false false t in
-                                FStar_Pprint.op_Hat_Hat FStar_Pprint.colon
-                                  uu___6 in
-                              FStar_Pprint.group uu___5 in
-                            FStar_Pprint.op_Hat_Hat uu___4 tac
-                        | FStar_Pervasives_Native.None -> FStar_Pprint.empty in
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 = p_tuplePattern pat1 in
-                            FStar_Pprint.op_Hat_Slash_Hat kw uu___7 in
-                          FStar_Pprint.group uu___6 in
-                        FStar_Pprint.op_Hat_Hat uu___5 ascr_doc in
-                      FStar_Pprint.group uu___4))
-and (p_letbinding :
-  FStar_Pprint.document ->
-    (FStar_Parser_AST.pattern * FStar_Parser_AST.term) ->
-      FStar_Pprint.document)
-  =
-  fun kw ->
-    fun uu___ ->
-      match uu___ with
-      | (pat, e) ->
-          let doc_pat = p_letlhs kw (pat, e) false in
-          let uu___1 = p_term_sep false false e in
-          (match uu___1 with
-           | (comm, doc_expr) ->
-               let doc_expr1 =
-                 inline_comment_or_above comm doc_expr FStar_Pprint.empty in
-               let uu___2 =
-                 let uu___3 =
-                   FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.equals
-                     doc_expr1 in
-                 FStar_Pprint.op_Hat_Slash_Hat doc_pat uu___3 in
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 = jump2 doc_expr1 in
-                       FStar_Pprint.op_Hat_Hat FStar_Pprint.equals uu___7 in
-                     FStar_Pprint.group uu___6 in
-                   FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___5 in
-                 FStar_Pprint.op_Hat_Hat doc_pat uu___4 in
-               FStar_Pprint.ifflat uu___2 uu___3)
-and (p_term_list :
-  Prims.bool ->
-    Prims.bool -> FStar_Parser_AST.term Prims.list -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun l ->
-        let rec aux uu___ =
-          match uu___ with
-          | [] -> FStar_Pprint.empty
-          | x::[] -> p_term ps pb x
-          | x::xs ->
-              let uu___1 = p_term ps pb x in
-              let uu___2 =
-                let uu___3 = str ";" in
-                let uu___4 = aux xs in FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        let uu___ = str "[" in
-        let uu___1 =
-          let uu___2 = aux l in
-          let uu___3 = str "]" in FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_newEffect : FStar_Parser_AST.effect_decl -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.RedefineEffect (lid, bs, t) ->
-        p_effectRedefinition lid bs t
-    | FStar_Parser_AST.DefineEffect (lid, bs, t, eff_decls) ->
-        p_effectDefinition lid bs t eff_decls
-and (p_effectRedefinition :
-  FStar_Ident.ident ->
-    FStar_Parser_AST.binder Prims.list ->
-      FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun uid ->
-    fun bs ->
-      fun t ->
-        let uu___ = p_uident uid in
-        let uu___1 = p_binders true bs in
-        let uu___2 =
-          let uu___3 = p_simpleTerm false false t in
-          prefix2 FStar_Pprint.equals uu___3 in
-        surround_maybe_empty (Prims.of_int (2)) Prims.int_one uu___ uu___1
-          uu___2
-and (p_effectDefinition :
-  FStar_Ident.ident ->
-    FStar_Parser_AST.binder Prims.list ->
-      FStar_Parser_AST.term ->
-        FStar_Parser_AST.decl Prims.list -> FStar_Pprint.document)
-  =
-  fun uid ->
-    fun bs ->
-      fun t ->
-        fun eff_decls ->
-          let binders = p_binders true bs in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = p_uident uid in
-                let uu___4 = p_binders true bs in
-                let uu___5 =
-                  let uu___6 = p_typ false false t in
-                  prefix2 FStar_Pprint.colon uu___6 in
-                surround_maybe_empty (Prims.of_int (2)) Prims.int_one uu___3
-                  uu___4 uu___5 in
-              FStar_Pprint.group uu___2 in
-            let uu___2 =
-              let uu___3 = str "with" in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 =
-                        let uu___9 =
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.semi
-                            FStar_Pprint.space in
-                        FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___9 in
-                      separate_map_last uu___8 p_effectDecl eff_decls in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___6 in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___5 in
-              FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-            FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-          braces_with_nesting uu___
-and (p_effectDecl :
-  Prims.bool -> FStar_Parser_AST.decl -> FStar_Pprint.document) =
-  fun ps ->
-    fun d ->
-      match d.FStar_Parser_AST.d with
-      | FStar_Parser_AST.Tycon
-          (false, uu___, (FStar_Parser_AST.TyconAbbrev
-           (lid, [], FStar_Pervasives_Native.None, e))::[])
-          ->
-          let uu___1 =
-            let uu___2 = p_lident lid in
-            let uu___3 =
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space FStar_Pprint.equals in
-            FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-          let uu___2 = p_simpleTerm ps false e in prefix2 uu___1 uu___2
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Parser_AST.decl_to_string d in
-            FStar_Compiler_Util.format1
-              "Not a declaration of an effect member... or at least I hope so : %s"
-              uu___2 in
-          failwith uu___1
-and (p_subEffect : FStar_Parser_AST.lift -> FStar_Pprint.document) =
-  fun lift ->
-    let lift_op_doc =
-      let lifts =
-        match lift.FStar_Parser_AST.lift_op with
-        | FStar_Parser_AST.NonReifiableLift t -> [("lift_wp", t)]
-        | FStar_Parser_AST.ReifiableLift (t1, t2) ->
-            [("lift_wp", t1); ("lift", t2)]
-        | FStar_Parser_AST.LiftForFree t -> [("lift", t)] in
-      let p_lift ps uu___ =
-        match uu___ with
-        | (kwd, t) ->
-            let uu___1 =
-              let uu___2 = str kwd in
-              let uu___3 =
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                  FStar_Pprint.equals in
-              FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-            let uu___2 = p_simpleTerm ps false t in prefix2 uu___1 uu___2 in
-      separate_break_map_last FStar_Pprint.semi p_lift lifts in
-    let uu___ =
-      let uu___1 =
-        let uu___2 = p_quident lift.FStar_Parser_AST.msource in
-        let uu___3 =
-          let uu___4 = str "~>" in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-        FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-      let uu___2 = p_quident lift.FStar_Parser_AST.mdest in
-      prefix2 uu___1 uu___2 in
-    let uu___1 =
-      let uu___2 = braces_with_nesting lift_op_doc in
-      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-    FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_qualifier : FStar_Parser_AST.qualifier -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.Private -> str "private"
-    | FStar_Parser_AST.Noeq -> str "noeq"
-    | FStar_Parser_AST.Unopteq -> str "unopteq"
-    | FStar_Parser_AST.Assumption -> str "assume"
-    | FStar_Parser_AST.DefaultEffect -> str "default"
-    | FStar_Parser_AST.TotalEffect -> str "total"
-    | FStar_Parser_AST.Effect_qual -> FStar_Pprint.empty
-    | FStar_Parser_AST.New -> str "new"
-    | FStar_Parser_AST.Inline -> str "inline"
-    | FStar_Parser_AST.Visible -> FStar_Pprint.empty
-    | FStar_Parser_AST.Unfold_for_unification_and_vcgen -> str "unfold"
-    | FStar_Parser_AST.Inline_for_extraction -> str "inline_for_extraction"
-    | FStar_Parser_AST.Irreducible -> str "irreducible"
-    | FStar_Parser_AST.NoExtract -> str "noextract"
-    | FStar_Parser_AST.Reifiable -> str "reifiable"
-    | FStar_Parser_AST.Reflectable -> str "reflectable"
-    | FStar_Parser_AST.Opaque -> str "opaque"
-    | FStar_Parser_AST.Logic -> str "logic"
-and (p_qualifiers : FStar_Parser_AST.qualifiers -> FStar_Pprint.document) =
-  fun qs ->
-    match qs with
-    | [] -> FStar_Pprint.empty
-    | q::[] ->
-        let uu___ = p_qualifier q in
-        FStar_Pprint.op_Hat_Hat uu___ FStar_Pprint.hardline
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.map p_qualifier qs in
-          FStar_Pprint.flow break1 uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___1 FStar_Pprint.hardline
-and (p_letqualifier :
-  FStar_Parser_AST.let_qualifier -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.Rec ->
-        let uu___1 = str "rec" in
-        FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___1
-    | FStar_Parser_AST.NoLetQualifier -> FStar_Pprint.empty
-and (p_aqual : FStar_Parser_AST.arg_qualifier -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.Implicit -> str "#"
-    | FStar_Parser_AST.Equality -> str "$"
-    | FStar_Parser_AST.Meta t ->
-        let t1 =
-          match t.FStar_Parser_AST.tm with
-          | FStar_Parser_AST.Abs (uu___1, e) -> e
-          | uu___1 ->
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.App
-                   (t,
-                     (FStar_Parser_AST.unit_const t.FStar_Parser_AST.range),
-                     FStar_Parser_AST.Nothing)) t.FStar_Parser_AST.range
-                FStar_Parser_AST.Expr in
-        let uu___1 = str "#[" in
-        let uu___2 =
-          let uu___3 = p_term false false t1 in
-          let uu___4 =
-            let uu___5 = str "]" in FStar_Pprint.op_Hat_Hat uu___5 break1 in
-          FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-        FStar_Pprint.op_Hat_Hat uu___1 uu___2
-    | FStar_Parser_AST.TypeClassArg -> FStar_Pprint.empty
-and (p_disjunctivePattern :
-  FStar_Parser_AST.pattern -> FStar_Pprint.document) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatOr pats ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.bar FStar_Pprint.space in
-            FStar_Pprint.op_Hat_Hat break1 uu___2 in
-          FStar_Pprint.separate_map uu___1 p_tuplePattern pats in
-        FStar_Pprint.group uu___
-    | uu___ -> p_tuplePattern p
-and (p_tuplePattern : FStar_Parser_AST.pattern -> FStar_Pprint.document) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatTuple (pats, false) ->
-        let uu___ =
-          let uu___1 = FStar_Pprint.op_Hat_Hat FStar_Pprint.comma break1 in
-          FStar_Pprint.separate_map uu___1 p_constructorPattern pats in
-        FStar_Pprint.group uu___
-    | uu___ -> p_constructorPattern p
-and (p_constructorPattern :
-  FStar_Parser_AST.pattern -> FStar_Pprint.document) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatApp
-        ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatName maybe_cons_lid;
-           FStar_Parser_AST.prange = uu___;_},
-         hd::tl::[])
-        when
-        FStar_Ident.lid_equals maybe_cons_lid FStar_Parser_Const.cons_lid ->
-        let uu___1 =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.colon FStar_Pprint.colon in
-        let uu___2 = p_constructorPattern hd in
-        let uu___3 = p_constructorPattern tl in infix0 uu___1 uu___2 uu___3
-    | FStar_Parser_AST.PatApp
-        ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatName uid;
-           FStar_Parser_AST.prange = uu___;_},
-         pats)
-        ->
-        let uu___1 = p_quident uid in
-        let uu___2 = FStar_Pprint.separate_map break1 p_atomicPattern pats in
-        prefix2 uu___1 uu___2
-    | uu___ -> p_atomicPattern p
-and (p_atomicPattern : FStar_Parser_AST.pattern -> FStar_Pprint.document) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatAscribed (pat, (t, FStar_Pervasives_Native.None))
-        ->
-        (match ((pat.FStar_Parser_AST.pat), (t.FStar_Parser_AST.tm)) with
-         | (FStar_Parser_AST.PatVar (lid, aqual, attrs),
-            FStar_Parser_AST.Refine
-            ({ FStar_Parser_AST.b = FStar_Parser_AST.Annotated (lid', t1);
-               FStar_Parser_AST.brange = uu___;
-               FStar_Parser_AST.blevel = uu___1;
-               FStar_Parser_AST.aqual = uu___2;
-               FStar_Parser_AST.battributes = uu___3;_},
-             phi)) when
-             let uu___4 = FStar_Ident.string_of_id lid in
-             let uu___5 = FStar_Ident.string_of_id lid' in uu___4 = uu___5 ->
-             let uu___4 =
-               let uu___5 = p_ident lid in
-               p_refinement aqual attrs uu___5 t1 phi in
-             soft_parens_with_nesting uu___4
-         | (FStar_Parser_AST.PatWild (aqual, attrs), FStar_Parser_AST.Refine
-            ({ FStar_Parser_AST.b = FStar_Parser_AST.NoName t1;
-               FStar_Parser_AST.brange = uu___;
-               FStar_Parser_AST.blevel = uu___1;
-               FStar_Parser_AST.aqual = uu___2;
-               FStar_Parser_AST.battributes = uu___3;_},
-             phi)) ->
-             let uu___4 =
-               p_refinement aqual attrs FStar_Pprint.underscore t1 phi in
-             soft_parens_with_nesting uu___4
-         | (FStar_Parser_AST.PatVar (uu___, aqual, uu___1), uu___2) ->
-             let wrap =
-               if
-                 aqual =
-                   (FStar_Pervasives_Native.Some
-                      FStar_Parser_AST.TypeClassArg)
-               then tc_arg
-               else soft_parens_with_nesting in
-             let uu___3 =
-               let uu___4 = p_tuplePattern pat in
-               let uu___5 =
-                 let uu___6 = p_tmEqNoRefinement t in
-                 FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon uu___6 in
-               FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-             wrap uu___3
-         | (FStar_Parser_AST.PatWild (aqual, uu___), uu___1) ->
-             let wrap =
-               if
-                 aqual =
-                   (FStar_Pervasives_Native.Some
-                      FStar_Parser_AST.TypeClassArg)
-               then tc_arg
-               else soft_parens_with_nesting in
-             let uu___2 =
-               let uu___3 = p_tuplePattern pat in
-               let uu___4 =
-                 let uu___5 = p_tmEqNoRefinement t in
-                 FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon uu___5 in
-               FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-             wrap uu___2
-         | uu___ ->
-             let uu___1 =
-               let uu___2 = p_tuplePattern pat in
-               let uu___3 =
-                 let uu___4 = p_tmEqNoRefinement t in
-                 FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon uu___4 in
-               FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-             soft_parens_with_nesting uu___1)
-    | FStar_Parser_AST.PatList pats ->
-        let uu___ = separate_break_map FStar_Pprint.semi p_tuplePattern pats in
-        FStar_Pprint.surround (Prims.of_int (2)) Prims.int_zero
-          FStar_Pprint.lbracket uu___ FStar_Pprint.rbracket
-    | FStar_Parser_AST.PatRecord pats ->
-        let p_recordFieldPat uu___ =
-          match uu___ with
-          | (lid, pat) ->
-              let uu___1 = p_qlident lid in
-              let uu___2 = p_tuplePattern pat in
-              infix2 FStar_Pprint.equals uu___1 uu___2 in
-        let uu___ =
-          separate_break_map FStar_Pprint.semi p_recordFieldPat pats in
-        soft_braces_with_nesting uu___
-    | FStar_Parser_AST.PatTuple (pats, true) ->
-        let uu___ =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen FStar_Pprint.bar in
-        let uu___1 =
-          separate_break_map FStar_Pprint.comma p_constructorPattern pats in
-        let uu___2 =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.bar FStar_Pprint.rparen in
-        FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one uu___ uu___1
-          uu___2
-    | FStar_Parser_AST.PatTvar (tv, arg_qualifier_opt, attrs) -> p_tvar tv
-    | FStar_Parser_AST.PatOp op ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Ident.string_of_id op in str uu___3 in
-            let uu___3 =
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space FStar_Pprint.rparen in
-            FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___1 in
-        FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen uu___
-    | FStar_Parser_AST.PatWild (aqual, attrs) ->
-        let uu___ = FStar_Pprint.optional p_aqual aqual in
-        let uu___1 =
-          let uu___2 = p_attributes false attrs in
-          FStar_Pprint.op_Hat_Hat uu___2 FStar_Pprint.underscore in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.PatConst c -> p_constant c
-    | FStar_Parser_AST.PatVQuote e ->
-        let uu___ =
-          let uu___1 = str "`%" in
-          let uu___2 = p_noSeqTermAndComment false false e in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.PatVar (lid, aqual, attrs) ->
-        let uu___ = FStar_Pprint.optional p_aqual aqual in
-        let uu___1 =
-          let uu___2 = p_attributes false attrs in
-          let uu___3 = p_lident lid in FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.PatName uid -> p_quident uid
-    | FStar_Parser_AST.PatOr uu___ -> failwith "Inner or pattern !"
-    | FStar_Parser_AST.PatApp
-        ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatName uu___;
-           FStar_Parser_AST.prange = uu___1;_},
-         uu___2)
-        -> let uu___3 = p_tuplePattern p in soft_parens_with_nesting uu___3
-    | FStar_Parser_AST.PatTuple (uu___, false) ->
-        let uu___1 = p_tuplePattern p in soft_parens_with_nesting uu___1
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Parser_AST.pat_to_string p in
-          FStar_Compiler_Util.format1 "Invalid pattern %s" uu___2 in
-        failwith uu___1
-and (is_typ_tuple : FStar_Parser_AST.term -> Prims.bool) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Op (id, uu___) when
-        let uu___1 = FStar_Ident.string_of_id id in uu___1 = "*" -> true
-    | uu___ -> false
-and (p_binder :
-  Prims.bool -> FStar_Parser_AST.binder -> FStar_Pprint.document) =
-  fun is_atomic ->
-    fun b ->
-      let is_tc = is_tc_binder b in
-      let uu___ = p_binder' false (is_atomic && (Prims.op_Negation is_tc)) b in
-      match uu___ with
-      | (b', t') ->
-          let d =
-            match t' with
-            | FStar_Pervasives_Native.Some (typ, catf1) -> catf1 b' typ
-            | FStar_Pervasives_Native.None -> b' in
-          if is_tc then tc_arg d else d
-and (p_binder' :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_Parser_AST.binder ->
-        (FStar_Pprint.document * (FStar_Pprint.document * catf)
-          FStar_Pervasives_Native.option))
-  =
-  fun no_pars ->
-    fun is_atomic ->
-      fun b ->
-        match b.FStar_Parser_AST.b with
-        | FStar_Parser_AST.Variable lid ->
-            let uu___ =
-              let uu___1 =
-                FStar_Pprint.optional p_aqual b.FStar_Parser_AST.aqual in
-              let uu___2 =
-                let uu___3 =
-                  p_attributes false b.FStar_Parser_AST.battributes in
-                let uu___4 = p_lident lid in
-                FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            (uu___, FStar_Pervasives_Native.None)
-        | FStar_Parser_AST.TVariable lid ->
-            let uu___ =
-              let uu___1 = p_attributes false b.FStar_Parser_AST.battributes in
-              let uu___2 = p_lident lid in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            (uu___, FStar_Pervasives_Native.None)
-        | FStar_Parser_AST.Annotated (lid, t) ->
-            let uu___ =
-              match t.FStar_Parser_AST.tm with
-              | FStar_Parser_AST.Refine
-                  ({
-                     FStar_Parser_AST.b = FStar_Parser_AST.Annotated
-                       (lid', t1);
-                     FStar_Parser_AST.brange = uu___1;
-                     FStar_Parser_AST.blevel = uu___2;
-                     FStar_Parser_AST.aqual = uu___3;
-                     FStar_Parser_AST.battributes = uu___4;_},
-                   phi)
-                  when
-                  let uu___5 = FStar_Ident.string_of_id lid in
-                  let uu___6 = FStar_Ident.string_of_id lid' in
-                  uu___5 = uu___6 ->
-                  let uu___5 = p_lident lid in
-                  p_refinement' b.FStar_Parser_AST.aqual
-                    b.FStar_Parser_AST.battributes uu___5 t1 phi
-              | uu___1 ->
-                  let t' =
-                    let uu___2 = is_typ_tuple t in
-                    if uu___2
-                    then
-                      let uu___3 = p_tmFormula t in
-                      soft_parens_with_nesting uu___3
-                    else p_tmFormula t in
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Pprint.optional p_aqual b.FStar_Parser_AST.aqual in
-                    let uu___4 =
-                      let uu___5 =
-                        p_attributes false b.FStar_Parser_AST.battributes in
-                      let uu___6 = p_lident lid in
-                      FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                    FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                  (uu___2, t') in
-            (match uu___ with
-             | (b', t') ->
-                 let catf1 =
-                   if
-                     is_atomic ||
-                       ((is_meta_qualifier b.FStar_Parser_AST.aqual) &&
-                          (Prims.op_Negation no_pars))
-                   then
-                     fun x ->
-                       fun y ->
-                         let uu___1 =
-                           let uu___2 =
-                             let uu___3 = cat_with_colon x y in
-                             FStar_Pprint.op_Hat_Hat uu___3
-                               FStar_Pprint.rparen in
-                           FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen uu___2 in
-                         FStar_Pprint.group uu___1
-                   else
-                     (fun x ->
-                        fun y ->
-                          let uu___2 = cat_with_colon x y in
-                          FStar_Pprint.group uu___2) in
-                 (b', (FStar_Pervasives_Native.Some (t', catf1))))
-        | FStar_Parser_AST.TAnnotated uu___ ->
-            failwith "Is this still used ?"
-        | FStar_Parser_AST.NoName t ->
-            (match t.FStar_Parser_AST.tm with
-             | FStar_Parser_AST.Refine
-                 ({ FStar_Parser_AST.b = FStar_Parser_AST.NoName t1;
-                    FStar_Parser_AST.brange = uu___;
-                    FStar_Parser_AST.blevel = uu___1;
-                    FStar_Parser_AST.aqual = uu___2;
-                    FStar_Parser_AST.battributes = uu___3;_},
-                  phi)
-                 ->
-                 let uu___4 =
-                   p_refinement' b.FStar_Parser_AST.aqual
-                     b.FStar_Parser_AST.battributes FStar_Pprint.underscore
-                     t1 phi in
-                 (match uu___4 with
-                  | (b', t') ->
-                      (b',
-                        (FStar_Pervasives_Native.Some (t', cat_with_colon))))
-             | uu___ ->
-                 let pref =
-                   let uu___1 =
-                     FStar_Pprint.optional p_aqual b.FStar_Parser_AST.aqual in
-                   let uu___2 =
-                     p_attributes false b.FStar_Parser_AST.battributes in
-                   FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-                 let p_Tm = if is_atomic then p_atomicTerm else p_appTerm in
-                 let uu___1 =
-                   let uu___2 = p_Tm t in FStar_Pprint.op_Hat_Hat pref uu___2 in
-                 (uu___1, FStar_Pervasives_Native.None))
-and (p_refinement :
-  FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option ->
-    FStar_Parser_AST.term Prims.list ->
-      FStar_Pprint.document ->
-        FStar_Parser_AST.term ->
-          FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun aqual_opt ->
-    fun attrs ->
-      fun binder ->
-        fun t ->
-          fun phi ->
-            let uu___ = p_refinement' aqual_opt attrs binder t phi in
-            match uu___ with | (b, typ) -> cat_with_colon b typ
-and (p_refinement' :
-  FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option ->
-    FStar_Parser_AST.term Prims.list ->
-      FStar_Pprint.document ->
-        FStar_Parser_AST.term ->
-          FStar_Parser_AST.term ->
-            (FStar_Pprint.document * FStar_Pprint.document))
-  =
-  fun aqual_opt ->
-    fun attrs ->
-      fun binder ->
-        fun t ->
-          fun phi ->
-            let is_t_atomic =
-              match t.FStar_Parser_AST.tm with
-              | FStar_Parser_AST.Construct uu___ -> false
-              | FStar_Parser_AST.App uu___ -> false
-              | FStar_Parser_AST.Op uu___ -> false
-              | uu___ -> true in
-            let uu___ = p_noSeqTerm false false phi in
-            match uu___ with
-            | (comm, phi1) ->
-                let phi2 =
-                  if comm = FStar_Pprint.empty
-                  then phi1
-                  else
-                    (let uu___2 =
-                       FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline phi1 in
-                     FStar_Pprint.op_Hat_Hat comm uu___2) in
-                let jump_break =
-                  if is_t_atomic then Prims.int_zero else Prims.int_one in
-                let uu___1 =
-                  let uu___2 = FStar_Pprint.optional p_aqual aqual_opt in
-                  let uu___3 =
-                    let uu___4 = p_attributes false attrs in
-                    FStar_Pprint.op_Hat_Hat uu___4 binder in
-                  FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-                let uu___2 =
-                  let uu___3 = p_appTerm t in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 = soft_braces_with_nesting_tight phi2 in
-                        let uu___8 = soft_braces_with_nesting phi2 in
-                        FStar_Pprint.ifflat uu___7 uu___8 in
-                      FStar_Pprint.group uu___6 in
-                    FStar_Pprint.jump (Prims.of_int (2)) jump_break uu___5 in
-                  FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                (uu___1, uu___2)
-and (p_binders_list :
-  Prims.bool ->
-    FStar_Parser_AST.binder Prims.list -> FStar_Pprint.document Prims.list)
-  =
-  fun is_atomic -> fun bs -> FStar_Compiler_List.map (p_binder is_atomic) bs
-and (p_binders :
-  Prims.bool -> FStar_Parser_AST.binder Prims.list -> FStar_Pprint.document)
-  =
-  fun is_atomic ->
-    fun bs ->
-      let uu___ = p_binders_list is_atomic bs in
-      separate_or_flow break1 uu___
-and (p_binders_sep :
-  FStar_Parser_AST.binder Prims.list -> FStar_Pprint.document) =
-  fun bs ->
-    let uu___ = p_binders_list true bs in
-    FStar_Pprint.separate_map FStar_Pprint.space (fun x -> x) uu___
-and (string_of_id_or_underscore : FStar_Ident.ident -> FStar_Pprint.document)
-  =
-  fun lid ->
-    let uu___ =
-      (let uu___1 = FStar_Ident.string_of_id lid in
-       FStar_Compiler_Util.starts_with uu___1 FStar_Ident.reserved_prefix) &&
-        (let uu___1 = FStar_Options.print_real_names () in
-         Prims.op_Negation uu___1) in
-    if uu___
-    then FStar_Pprint.underscore
-    else (let uu___2 = FStar_Ident.string_of_id lid in str uu___2)
-and (text_of_lid_or_underscore : FStar_Ident.lident -> FStar_Pprint.document)
-  =
-  fun lid ->
-    let uu___ =
-      (let uu___1 =
-         let uu___2 = FStar_Ident.ident_of_lid lid in
-         FStar_Ident.string_of_id uu___2 in
-       FStar_Compiler_Util.starts_with uu___1 FStar_Ident.reserved_prefix) &&
-        (let uu___1 = FStar_Options.print_real_names () in
-         Prims.op_Negation uu___1) in
-    if uu___
-    then FStar_Pprint.underscore
-    else (let uu___2 = FStar_Ident.string_of_lid lid in str uu___2)
-and (p_qlident : FStar_Ident.lid -> FStar_Pprint.document) =
-  fun lid -> text_of_lid_or_underscore lid
-and (p_quident : FStar_Ident.lid -> FStar_Pprint.document) =
-  fun lid -> text_of_lid_or_underscore lid
-and (p_ident : FStar_Ident.ident -> FStar_Pprint.document) =
-  fun lid -> string_of_id_or_underscore lid
-and (p_lident : FStar_Ident.ident -> FStar_Pprint.document) =
-  fun lid -> string_of_id_or_underscore lid
-and (p_uident : FStar_Ident.ident -> FStar_Pprint.document) =
-  fun lid -> string_of_id_or_underscore lid
-and (p_tvar : FStar_Ident.ident -> FStar_Pprint.document) =
-  fun lid -> string_of_id_or_underscore lid
-and (paren_if : Prims.bool -> FStar_Pprint.document -> FStar_Pprint.document)
-  = fun b -> if b then soft_parens_with_nesting else (fun x -> x)
-and (inline_comment_or_above :
-  FStar_Pprint.document ->
-    FStar_Pprint.document -> FStar_Pprint.document -> FStar_Pprint.document)
-  =
-  fun comm ->
-    fun doc ->
-      fun sep ->
-        if comm = FStar_Pprint.empty
-        then
-          let uu___ = FStar_Pprint.op_Hat_Hat doc sep in
-          FStar_Pprint.group uu___
-        else
-          (let uu___1 =
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = FStar_Pprint.op_Hat_Hat break1 comm in
-                   FStar_Pprint.op_Hat_Hat sep uu___5 in
-                 FStar_Pprint.op_Hat_Hat doc uu___4 in
-               FStar_Pprint.group uu___3 in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = FStar_Pprint.op_Hat_Hat doc sep in
-                 FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___5 in
-               FStar_Pprint.op_Hat_Hat comm uu___4 in
-             FStar_Pprint.ifflat uu___2 uu___3 in
-           FStar_Compiler_Effect.op_Less_Bar FStar_Pprint.group uu___1)
-and (p_term :
-  Prims.bool -> Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun e ->
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.Seq (e1, e2) ->
-            let uu___ = p_noSeqTerm true false e1 in
-            (match uu___ with
-             | (comm, t1) ->
-                 let uu___1 =
-                   inline_comment_or_above comm t1 FStar_Pprint.semi in
-                 let uu___2 =
-                   let uu___3 = p_term ps pb e2 in
-                   FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___3 in
-                 FStar_Pprint.op_Hat_Hat uu___1 uu___2)
-        | FStar_Parser_AST.Bind (x, e1, e2) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = p_lident x in
-                  let uu___4 =
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                      FStar_Pprint.long_left_arrow in
-                  FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                let uu___3 =
-                  let uu___4 = p_noSeqTermAndComment true false e1 in
-                  let uu___5 =
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                      FStar_Pprint.semi in
-                  FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-                op_Hat_Slash_Plus_Hat uu___2 uu___3 in
-              FStar_Pprint.group uu___1 in
-            let uu___1 = p_term ps pb e2 in
-            FStar_Pprint.op_Hat_Slash_Hat uu___ uu___1
-        | uu___ ->
-            let uu___1 = p_noSeqTermAndComment ps pb e in
-            FStar_Pprint.group uu___1
-and (p_term_sep :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_Parser_AST.term ->
-        (FStar_Pprint.document * FStar_Pprint.document))
-  =
-  fun ps ->
-    fun pb ->
-      fun e ->
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.Seq (e1, e2) ->
-            let uu___ = p_noSeqTerm true false e1 in
-            (match uu___ with
-             | (comm, t1) ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Pprint.op_Hat_Hat t1 FStar_Pprint.semi in
-                     FStar_Pprint.group uu___3 in
-                   let uu___3 =
-                     let uu___4 = p_term ps pb e2 in
-                     FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___4 in
-                   FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-                 (comm, uu___1))
-        | FStar_Parser_AST.Bind (x, e1, e2) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = p_lident x in
-                    let uu___5 =
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                        FStar_Pprint.long_left_arrow in
-                    FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-                  let uu___4 =
-                    let uu___5 = p_noSeqTermAndComment true false e1 in
-                    let uu___6 =
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                        FStar_Pprint.semi in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  op_Hat_Slash_Plus_Hat uu___3 uu___4 in
-                FStar_Pprint.group uu___2 in
-              let uu___2 = p_term ps pb e2 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-            (FStar_Pprint.empty, uu___)
-        | uu___ -> p_noSeqTerm ps pb e
-and (p_noSeqTerm :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_Parser_AST.term ->
-        (FStar_Pprint.document * FStar_Pprint.document))
-  =
-  fun ps ->
-    fun pb ->
-      fun e ->
-        with_comment_sep (p_noSeqTerm' ps pb) e e.FStar_Parser_AST.range
-and (p_noSeqTermAndComment :
-  Prims.bool -> Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun e -> with_comment (p_noSeqTerm' ps pb) e e.FStar_Parser_AST.range
-and (p_noSeqTerm' :
-  Prims.bool -> Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun e ->
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.Ascribed
-            (e1, t, FStar_Pervasives_Native.None, use_eq) ->
-            let uu___ =
-              let uu___1 = p_tmIff e1 in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = p_typ ps pb t in
-                  FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon uu___4 in
-                FStar_Pprint.op_Hat_Hat
-                  (if use_eq
-                   then FStar_Pprint.dollar
-                   else FStar_Pprint.langle) uu___3 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Ascribed
-            (e1, t, FStar_Pervasives_Native.Some tac, use_eq) ->
-            let uu___ =
-              let uu___1 = p_tmIff e1 in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = p_typ false false t in
-                    let uu___6 =
-                      let uu___7 = str "by" in
-                      let uu___8 = p_typ ps pb (maybe_unthunk tac) in
-                      FStar_Pprint.op_Hat_Slash_Hat uu___7 uu___8 in
-                    FStar_Pprint.op_Hat_Slash_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon uu___4 in
-                FStar_Pprint.op_Hat_Hat
-                  (if use_eq
-                   then FStar_Pprint.dollar
-                   else FStar_Pprint.langle) uu___3 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Op (id, e1::e2::e3::[]) when
-            let uu___ = FStar_Ident.string_of_id id in uu___ = ".()<-" ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = p_atomicTermNotQUident e1 in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 = p_term false false e2 in
-                        soft_parens_with_nesting uu___7 in
-                      let uu___7 =
-                        FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                          FStar_Pprint.larrow in
-                      FStar_Pprint.op_Hat_Hat uu___6 uu___7 in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___5 in
-                  FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                FStar_Pprint.group uu___2 in
-              let uu___2 =
-                let uu___3 = p_noSeqTermAndComment ps pb e3 in jump2 uu___3 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Op (id, e1::e2::e3::[]) when
-            let uu___ = FStar_Ident.string_of_id id in uu___ = ".[]<-" ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = p_atomicTermNotQUident e1 in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 = p_term false false e2 in
-                        soft_brackets_with_nesting uu___7 in
-                      let uu___7 =
-                        FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                          FStar_Pprint.larrow in
-                      FStar_Pprint.op_Hat_Hat uu___6 uu___7 in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___5 in
-                  FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                FStar_Pprint.group uu___2 in
-              let uu___2 =
-                let uu___3 = p_noSeqTermAndComment ps pb e3 in jump2 uu___3 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Requires (e1, wtf) ->
-            let uu___1 =
-              let uu___2 = str "requires" in
-              let uu___3 = p_typ ps pb e1 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-            FStar_Pprint.group uu___1
-        | FStar_Parser_AST.Ensures (e1, wtf) ->
-            let uu___1 =
-              let uu___2 = str "ensures" in
-              let uu___3 = p_typ ps pb e1 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-            FStar_Pprint.group uu___1
-        | FStar_Parser_AST.WFOrder (rel, e1) -> p_dec_wf ps pb rel e1
-        | FStar_Parser_AST.LexList l ->
-            let uu___ =
-              let uu___1 = str "%" in
-              let uu___2 = p_term_list ps pb l in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Decreases (e1, wtf) ->
-            let uu___1 =
-              let uu___2 = str "decreases" in
-              let uu___3 = p_typ ps pb e1 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-            FStar_Pprint.group uu___1
-        | FStar_Parser_AST.Attributes es ->
-            let uu___ =
-              let uu___1 = str "attributes" in
-              let uu___2 = FStar_Pprint.separate_map break1 p_atomicTerm es in
-              FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.If (e1, op_opt, ret_opt, e2, e3) ->
-            if is_unit e3
-            then
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_Compiler_Util.map_opt op_opt
-                              FStar_Ident.string_of_id in
-                          FStar_Compiler_Util.bind_opt uu___6
-                            (FStar_Parser_AST.strip_prefix "let") in
-                        FStar_Compiler_Util.dflt "" uu___5 in
-                      Prims.op_Hat "if" uu___4 in
-                    str uu___3 in
-                  let uu___3 = p_noSeqTermAndComment false false e1 in
-                  op_Hat_Slash_Plus_Hat uu___2 uu___3 in
-                let uu___2 =
-                  let uu___3 = str "then" in
-                  let uu___4 = p_noSeqTermAndComment ps pb e2 in
-                  op_Hat_Slash_Plus_Hat uu___3 uu___4 in
-                FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-              FStar_Pprint.group uu___
-            else
-              (let e2_doc =
-                 match e2.FStar_Parser_AST.tm with
-                 | FStar_Parser_AST.If (uu___1, uu___2, uu___3, uu___4, e31)
-                     when is_unit e31 ->
-                     let uu___5 = p_noSeqTermAndComment false false e2 in
-                     soft_parens_with_nesting uu___5
-                 | uu___1 -> p_noSeqTermAndComment false false e2 in
-               match ret_opt with
-               | FStar_Pervasives_Native.None ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 = str "if" in
-                       let uu___4 = p_noSeqTermAndComment false false e1 in
-                       op_Hat_Slash_Plus_Hat uu___3 uu___4 in
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 = str "then" in
-                         op_Hat_Slash_Plus_Hat uu___5 e2_doc in
-                       let uu___5 =
-                         let uu___6 = str "else" in
-                         let uu___7 = p_noSeqTermAndComment ps pb e3 in
-                         op_Hat_Slash_Plus_Hat uu___6 uu___7 in
-                       FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-                     FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-                   FStar_Pprint.group uu___1
-               | FStar_Pervasives_Native.Some (as_opt, ret, use_eq) ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 = str "if" in
-                       let uu___4 = p_noSeqTermAndComment false false e1 in
-                       op_Hat_Slash_Plus_Hat uu___3 uu___4 in
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           match as_opt with
-                           | FStar_Pervasives_Native.None ->
-                               FStar_Pprint.empty
-                           | FStar_Pervasives_Native.Some as_ident ->
-                               let uu___6 = str "as" in
-                               let uu___7 = p_ident as_ident in
-                               FStar_Pprint.op_Hat_Slash_Hat uu___6 uu___7 in
-                         let uu___6 =
-                           let uu___7 =
-                             str (if use_eq then "returns$" else "returns") in
-                           let uu___8 = p_tmIff ret in
-                           op_Hat_Slash_Plus_Hat uu___7 uu___8 in
-                         FStar_Pprint.op_Hat_Slash_Hat uu___5 uu___6 in
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 = str "then" in
-                           op_Hat_Slash_Plus_Hat uu___7 e2_doc in
-                         let uu___7 =
-                           let uu___8 = str "else" in
-                           let uu___9 = p_noSeqTermAndComment ps pb e3 in
-                           op_Hat_Slash_Plus_Hat uu___8 uu___9 in
-                         FStar_Pprint.op_Hat_Slash_Hat uu___6 uu___7 in
-                       FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-                     FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-                   FStar_Pprint.group uu___1)
-        | FStar_Parser_AST.TryWith (e1, branches) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = str "try" in
-                  let uu___4 = p_noSeqTermAndComment false false e1 in
-                  prefix2 uu___3 uu___4 in
-                let uu___3 =
-                  let uu___4 = str "with" in
-                  let uu___5 =
-                    separate_map_last FStar_Pprint.hardline p_patternBranch
-                      branches in
-                  FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-                FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-              FStar_Pprint.group uu___1 in
-            let uu___1 = paren_if (ps || pb) in uu___1 uu___
-        | FStar_Parser_AST.Match (e1, op_opt, ret_opt, branches) ->
-            let match_doc =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Compiler_Util.map_opt op_opt
-                        FStar_Ident.string_of_id in
-                    FStar_Compiler_Util.bind_opt uu___3
-                      (FStar_Parser_AST.strip_prefix "let") in
-                  FStar_Compiler_Util.dflt "" uu___2 in
-                Prims.op_Hat "match" uu___1 in
-              str uu___ in
-            let uu___ =
-              let uu___1 =
-                match ret_opt with
-                | FStar_Pervasives_Native.None ->
-                    let uu___2 =
-                      let uu___3 = p_noSeqTermAndComment false false e1 in
-                      let uu___4 = str "with" in
-                      FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-                        match_doc uu___3 uu___4 in
-                    FStar_Pprint.group uu___2
-                | FStar_Pervasives_Native.Some (as_opt, ret, use_eq) ->
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = p_noSeqTermAndComment false false e1 in
-                        let uu___5 =
-                          let uu___6 =
-                            match as_opt with
-                            | FStar_Pervasives_Native.None ->
-                                FStar_Pprint.empty
-                            | FStar_Pervasives_Native.Some as_ident ->
-                                let uu___7 = str "as" in
-                                let uu___8 = p_ident as_ident in
-                                op_Hat_Slash_Plus_Hat uu___7 uu___8 in
-                          let uu___7 =
-                            let uu___8 =
-                              str (if use_eq then "returns$" else "returns") in
-                            let uu___9 = p_tmIff ret in
-                            op_Hat_Slash_Plus_Hat uu___8 uu___9 in
-                          op_Hat_Slash_Plus_Hat uu___6 uu___7 in
-                        op_Hat_Slash_Plus_Hat uu___4 uu___5 in
-                      let uu___4 = str "with" in
-                      FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-                        match_doc uu___3 uu___4 in
-                    FStar_Pprint.group uu___2 in
-              let uu___2 =
-                separate_map_last FStar_Pprint.hardline p_patternBranch
-                  branches in
-              FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-            let uu___1 = paren_if (ps || pb) in uu___1 uu___
-        | FStar_Parser_AST.LetOpen (uid, e1) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = str "let open" in
-                  let uu___4 = p_quident uid in
-                  let uu___5 = str "in" in
-                  FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-                    uu___3 uu___4 uu___5 in
-                let uu___3 = p_term false pb e1 in
-                FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-              FStar_Pprint.group uu___1 in
-            let uu___1 = paren_if ps in uu___1 uu___
-        | FStar_Parser_AST.LetOpenRecord (r, rty, e1) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = str "let open" in
-                  let uu___4 = p_term false pb r in
-                  let uu___5 = str "as" in
-                  FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-                    uu___3 uu___4 uu___5 in
-                let uu___3 =
-                  let uu___4 = p_term false pb rty in
-                  let uu___5 =
-                    let uu___6 = str "in" in
-                    let uu___7 = p_term false pb e1 in
-                    FStar_Pprint.op_Hat_Slash_Hat uu___6 uu___7 in
-                  FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-                FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-              FStar_Pprint.group uu___1 in
-            let uu___1 = paren_if ps in uu___1 uu___
-        | FStar_Parser_AST.LetOperator (lets, body) ->
-            let p_let uu___ is_last =
-              match uu___ with
-              | (id, pat, e1) ->
-                  let doc_let_or_and =
-                    let uu___1 = FStar_Ident.string_of_id id in str uu___1 in
-                  let doc_pat = p_letlhs doc_let_or_and (pat, e1) true in
-                  (match ((pat.FStar_Parser_AST.pat),
-                           (e1.FStar_Parser_AST.tm))
-                   with
-                   | (FStar_Parser_AST.PatVar (pid, uu___1, uu___2),
-                      FStar_Parser_AST.Name tid) when
-                       let uu___3 = FStar_Ident.string_of_id pid in
-                       let uu___4 =
-                         let uu___5 = FStar_Ident.path_of_lid tid in
-                         FStar_Compiler_List.last uu___5 in
-                       uu___3 = uu___4 ->
-                       let uu___3 =
-                         if is_last then str "in" else FStar_Pprint.empty in
-                       FStar_Pprint.op_Hat_Slash_Hat doc_pat uu___3
-                   | (FStar_Parser_AST.PatVar (pid, uu___1, uu___2),
-                      FStar_Parser_AST.Var tid) when
-                       let uu___3 = FStar_Ident.string_of_id pid in
-                       let uu___4 =
-                         let uu___5 = FStar_Ident.path_of_lid tid in
-                         FStar_Compiler_List.last uu___5 in
-                       uu___3 = uu___4 ->
-                       let uu___3 =
-                         if is_last then str "in" else FStar_Pprint.empty in
-                       FStar_Pprint.op_Hat_Slash_Hat doc_pat uu___3
-                   | uu___1 ->
-                       let uu___2 = p_term_sep false false e1 in
-                       (match uu___2 with
-                        | (comm, doc_expr) ->
-                            let doc_expr1 =
-                              inline_comment_or_above comm doc_expr
-                                FStar_Pprint.empty in
-                            if is_last
-                            then
-                              let uu___3 =
-                                FStar_Pprint.flow break1
-                                  [doc_pat; FStar_Pprint.equals] in
-                              let uu___4 = str "in" in
-                              FStar_Pprint.surround (Prims.of_int (2))
-                                Prims.int_one uu___3 doc_expr1 uu___4
-                            else
-                              (let uu___4 =
-                                 FStar_Pprint.flow break1
-                                   [doc_pat; FStar_Pprint.equals; doc_expr1] in
-                               FStar_Pprint.hang (Prims.of_int (2)) uu___4))) in
-            let l = FStar_Compiler_List.length lets in
-            let lets_docs =
-              FStar_Compiler_List.mapi
-                (fun i ->
-                   fun lb ->
-                     let uu___ = p_let lb (i = (l - Prims.int_one)) in
-                     FStar_Pprint.group uu___) lets in
-            let lets_doc =
-              let uu___ = FStar_Pprint.separate break1 lets_docs in
-              FStar_Pprint.group uu___ in
-            let r =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = p_term false pb body in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___3 in
-                  FStar_Pprint.op_Hat_Hat lets_doc uu___2 in
-                FStar_Pprint.group uu___1 in
-              let uu___1 = paren_if ps in uu___1 uu___ in
-            r
-        | FStar_Parser_AST.Let (q, lbs, e1) ->
-            let p_lb q1 uu___ is_last =
-              match uu___ with
-              | (a, (pat, e2)) ->
-                  let attrs = p_attrs_opt true a in
-                  let doc_let_or_and =
-                    match q1 with
-                    | FStar_Pervasives_Native.Some (FStar_Parser_AST.Rec) ->
-                        let uu___1 =
-                          let uu___2 = str "let" in
-                          let uu___3 = str "rec" in
-                          FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-                        FStar_Pprint.group uu___1
-                    | FStar_Pervasives_Native.Some
-                        (FStar_Parser_AST.NoLetQualifier) -> str "let"
-                    | uu___1 -> str "and" in
-                  let doc_pat = p_letlhs doc_let_or_and (pat, e2) true in
-                  let uu___1 = p_term_sep false false e2 in
-                  (match uu___1 with
-                   | (comm, doc_expr) ->
-                       let doc_expr1 =
-                         inline_comment_or_above comm doc_expr
-                           FStar_Pprint.empty in
-                       let uu___2 =
-                         if is_last
-                         then
-                           let uu___3 =
-                             FStar_Pprint.flow break1
-                               [doc_pat; FStar_Pprint.equals] in
-                           let uu___4 = str "in" in
-                           FStar_Pprint.surround (Prims.of_int (2))
-                             Prims.int_one uu___3 doc_expr1 uu___4
-                         else
-                           (let uu___4 =
-                              FStar_Pprint.flow break1
-                                [doc_pat; FStar_Pprint.equals; doc_expr1] in
-                            FStar_Pprint.hang (Prims.of_int (2)) uu___4) in
-                       FStar_Pprint.op_Hat_Hat attrs uu___2) in
-            let l = FStar_Compiler_List.length lbs in
-            let lbs_docs =
-              FStar_Compiler_List.mapi
-                (fun i ->
-                   fun lb ->
-                     if i = Prims.int_zero
-                     then
-                       let uu___ =
-                         p_lb (FStar_Pervasives_Native.Some q) lb
-                           (i = (l - Prims.int_one)) in
-                       FStar_Pprint.group uu___
-                     else
-                       (let uu___1 =
-                          p_lb FStar_Pervasives_Native.None lb
-                            (i = (l - Prims.int_one)) in
-                        FStar_Pprint.group uu___1)) lbs in
-            let lbs_doc =
-              let uu___ = FStar_Pprint.separate break1 lbs_docs in
-              FStar_Pprint.group uu___ in
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = p_term false pb e1 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___3 in
-                FStar_Pprint.op_Hat_Hat lbs_doc uu___2 in
-              FStar_Pprint.group uu___1 in
-            let uu___1 = paren_if ps in uu___1 uu___
-        | FStar_Parser_AST.Abs
-            ({
-               FStar_Parser_AST.pat = FStar_Parser_AST.PatVar
-                 (x, typ_opt, uu___);
-               FStar_Parser_AST.prange = uu___1;_}::[],
-             {
-               FStar_Parser_AST.tm = FStar_Parser_AST.Match
-                 (maybe_x, FStar_Pervasives_Native.None,
-                  FStar_Pervasives_Native.None, branches);
-               FStar_Parser_AST.range = uu___2;
-               FStar_Parser_AST.level = uu___3;_})
-            when matches_var maybe_x x ->
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = str "function" in
-                let uu___7 =
-                  separate_map_last FStar_Pprint.hardline p_patternBranch
-                    branches in
-                FStar_Pprint.op_Hat_Slash_Hat uu___6 uu___7 in
-              FStar_Pprint.group uu___5 in
-            let uu___5 = paren_if (ps || pb) in uu___5 uu___4
-        | FStar_Parser_AST.Quote (e1, FStar_Parser_AST.Dynamic) ->
-            let uu___ =
-              let uu___1 = str "quote" in
-              let uu___2 = p_noSeqTermAndComment ps pb e1 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Quote (e1, FStar_Parser_AST.Static) ->
-            let uu___ =
-              let uu___1 = str "`" in
-              let uu___2 = p_noSeqTermAndComment ps pb e1 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.VQuote e1 ->
-            let uu___ =
-              let uu___1 = str "`%" in
-              let uu___2 = p_noSeqTermAndComment ps pb e1 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Antiquote
-            {
-              FStar_Parser_AST.tm = FStar_Parser_AST.Quote
-                (e1, FStar_Parser_AST.Dynamic);
-              FStar_Parser_AST.range = uu___;
-              FStar_Parser_AST.level = uu___1;_}
-            ->
-            let uu___2 =
-              let uu___3 = str "`@" in
-              let uu___4 = p_noSeqTermAndComment ps pb e1 in
-              FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-            FStar_Pprint.group uu___2
-        | FStar_Parser_AST.Antiquote e1 ->
-            let uu___ =
-              let uu___1 = str "`#" in
-              let uu___2 = p_noSeqTermAndComment ps pb e1 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.CalcProof (rel, init, steps) ->
-            let head =
-              let uu___ = str "calc" in
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = p_noSeqTermAndComment false false rel in
-                  let uu___4 =
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                      FStar_Pprint.lbrace in
-                  FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-              FStar_Pprint.op_Hat_Hat uu___ uu___1 in
-            let bot = FStar_Pprint.rbrace in
-            let uu___ = FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline bot in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = p_noSeqTermAndComment false false init in
-                  let uu___5 =
-                    let uu___6 = str ";" in
-                    let uu___7 =
-                      let uu___8 =
-                        separate_map_last FStar_Pprint.hardline p_calcStep
-                          steps in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___8 in
-                    FStar_Pprint.op_Hat_Hat uu___6 uu___7 in
-                  FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___3 in
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_Pprint.nest (Prims.of_int (2))) uu___2 in
-            FStar_Pprint.enclose head uu___ uu___1
-        | FStar_Parser_AST.IntroForall (xs, p, e1) ->
-            let p1 = p_noSeqTermAndComment false false p in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let xs1 = p_binders_sep xs in
-            let uu___ = str "introduce forall" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "." in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "with" in
-                            let uu___11 =
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space e2 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat p1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat xs1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.IntroExists (xs, p, vs, e1) ->
-            let p1 = p_noSeqTermAndComment false false p in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let xs1 = p_binders_sep xs in
-            let uu___ = str "introduce" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = str "exists" in
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = str "." in
-                      let uu___8 =
-                        let uu___9 =
-                          let uu___10 =
-                            let uu___11 = str "with" in
-                            let uu___12 =
-                              let uu___13 =
-                                let uu___14 =
-                                  FStar_Pprint.separate_map
-                                    FStar_Pprint.space p_atomicTerm vs in
-                                let uu___15 =
-                                  let uu___16 =
-                                    let uu___17 = str "and" in
-                                    let uu___18 =
-                                      FStar_Pprint.op_Hat_Hat
-                                        FStar_Pprint.space e2 in
-                                    FStar_Pprint.op_Hat_Hat uu___17 uu___18 in
-                                  FStar_Pprint.op_Hat_Hat
-                                    FStar_Pprint.hardline uu___16 in
-                                FStar_Pprint.op_Hat_Hat uu___14 uu___15 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___13 in
-                            FStar_Pprint.op_Hat_Hat uu___11 uu___12 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___10 in
-                        FStar_Pprint.op_Hat_Hat p1 uu___9 in
-                      FStar_Pprint.op_Hat_Hat uu___7 uu___8 in
-                    FStar_Pprint.op_Hat_Hat xs1 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___5 in
-                FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.IntroImplies (p, q, x, e1) ->
-            let p1 = p_tmFormula p in
-            let q1 = p_tmFormula q in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let x1 = p_binders_sep [x] in
-            let uu___ = str "introduce" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "==>" in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "with" in
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  let uu___14 = str "." in
-                                  let uu___15 =
-                                    FStar_Pprint.op_Hat_Hat
-                                      FStar_Pprint.space e2 in
-                                  FStar_Pprint.op_Hat_Hat uu___14 uu___15 in
-                                FStar_Pprint.op_Hat_Hat x1 uu___13 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___12 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat p1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.IntroOr (b, p, q, e1) ->
-            let p1 = p_tmFormula p in
-            let q1 = p_tmFormula q in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let uu___ = str "introduce" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "\\/" in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "with" in
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  if b then str "Left" else str "Right" in
-                                let uu___14 =
-                                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                    e2 in
-                                FStar_Pprint.op_Hat_Hat uu___13 uu___14 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___12 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat p1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.IntroAnd (p, q, e1, e2) ->
-            let p1 = p_tmFormula p in
-            let q1 = p_tmTuple q in
-            let e11 = p_noSeqTermAndComment false false e1 in
-            let e21 = p_noSeqTermAndComment false false e2 in
-            let uu___ = str "introduce" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "/\\" in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "with" in
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  let uu___14 =
-                                    let uu___15 = str "and" in
-                                    let uu___16 =
-                                      FStar_Pprint.op_Hat_Hat
-                                        FStar_Pprint.space e21 in
-                                    FStar_Pprint.op_Hat_Hat uu___15 uu___16 in
-                                  FStar_Pprint.op_Hat_Hat
-                                    FStar_Pprint.hardline uu___14 in
-                                FStar_Pprint.op_Hat_Hat e11 uu___13 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___12 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat p1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.ElimForall (xs, p, vs) ->
-            let xs1 = p_binders_sep xs in
-            let p1 = p_noSeqTermAndComment false false p in
-            let vs1 =
-              FStar_Pprint.separate_map FStar_Pprint.space p_atomicTerm vs in
-            let uu___ = str "eliminate" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = str "forall" in
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = str "." in
-                      let uu___8 =
-                        let uu___9 =
-                          let uu___10 =
-                            let uu___11 =
-                              let uu___12 = str "with" in
-                              let uu___13 =
-                                FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                  vs1 in
-                              FStar_Pprint.op_Hat_Hat uu___12 uu___13 in
-                            FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                              uu___11 in
-                          FStar_Pprint.op_Hat_Hat p1 uu___10 in
-                        FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___9 in
-                      FStar_Pprint.op_Hat_Hat uu___7 uu___8 in
-                    FStar_Pprint.op_Hat_Hat xs1 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___5 in
-                FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.ElimExists (bs, p, q, b, e1) ->
-            let head =
-              let uu___ = str "eliminate exists" in
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = p_binders_sep bs in
-                  let uu___4 = str "." in
-                  FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-              FStar_Pprint.op_Hat_Hat uu___ uu___1 in
-            let p1 = p_noSeqTermAndComment false false p in
-            let q1 = p_noSeqTermAndComment false false q in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = str "returns" in
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            let uu___9 = str "with" in
-                            let uu___10 =
-                              let uu___11 =
-                                let uu___12 = p_binders_sep [b] in
-                                let uu___13 =
-                                  let uu___14 = str "." in
-                                  let uu___15 =
-                                    FStar_Pprint.op_Hat_Hat
-                                      FStar_Pprint.hardline e2 in
-                                  FStar_Pprint.op_Hat_Hat uu___14 uu___15 in
-                                FStar_Pprint.op_Hat_Hat uu___12 uu___13 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___11 in
-                            FStar_Pprint.op_Hat_Hat uu___9 uu___10 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___8 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___7 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___6 in
-                    FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___3 in
-                FStar_Pprint.op_Hat_Hat p1 uu___2 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___1 in
-            FStar_Pprint.op_Hat_Hat head uu___
-        | FStar_Parser_AST.ElimImplies (p, q, e1) ->
-            let p1 = p_tmFormula p in
-            let q1 = p_tmFormula q in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let uu___ = str "eliminate" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "==>" in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "with" in
-                            let uu___11 =
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space e2 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat p1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.ElimOr (p, q, r, x, e1, y, e2) ->
-            let p1 = p_tmFormula p in
-            let q1 = p_tmFormula q in
-            let r1 = p_noSeqTermAndComment false false r in
-            let x1 = p_binders_sep [x] in
-            let e11 = p_noSeqTermAndComment false false e1 in
-            let y1 = p_binders_sep [y] in
-            let e21 = p_noSeqTermAndComment false false e2 in
-            let uu___ = str "eliminate" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "\\/" in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "returns" in
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  let uu___14 =
-                                    let uu___15 = str "with" in
-                                    let uu___16 =
-                                      let uu___17 =
-                                        let uu___18 =
-                                          let uu___19 =
-                                            let uu___20 = str "." in
-                                            let uu___21 =
-                                              let uu___22 =
-                                                let uu___23 =
-                                                  let uu___24 =
-                                                    let uu___25 = str "and" in
-                                                    let uu___26 =
-                                                      let uu___27 =
-                                                        let uu___28 =
-                                                          let uu___29 =
-                                                            let uu___30 =
-                                                              str "." in
-                                                            let uu___31 =
-                                                              FStar_Pprint.op_Hat_Hat
-                                                                FStar_Pprint.space
-                                                                e21 in
-                                                            FStar_Pprint.op_Hat_Hat
-                                                              uu___30 uu___31 in
-                                                          FStar_Pprint.op_Hat_Hat
-                                                            FStar_Pprint.space
-                                                            uu___29 in
-                                                        FStar_Pprint.op_Hat_Hat
-                                                          y1 uu___28 in
-                                                      FStar_Pprint.op_Hat_Hat
-                                                        FStar_Pprint.space
-                                                        uu___27 in
-                                                    FStar_Pprint.op_Hat_Hat
-                                                      uu___25 uu___26 in
-                                                  FStar_Pprint.op_Hat_Hat
-                                                    FStar_Pprint.hardline
-                                                    uu___24 in
-                                                FStar_Pprint.op_Hat_Hat e11
-                                                  uu___23 in
-                                              FStar_Pprint.op_Hat_Hat
-                                                FStar_Pprint.space uu___22 in
-                                            FStar_Pprint.op_Hat_Hat uu___20
-                                              uu___21 in
-                                          FStar_Pprint.op_Hat_Hat
-                                            FStar_Pprint.space uu___19 in
-                                        FStar_Pprint.op_Hat_Hat x1 uu___18 in
-                                      FStar_Pprint.op_Hat_Hat
-                                        FStar_Pprint.space uu___17 in
-                                    FStar_Pprint.op_Hat_Hat uu___15 uu___16 in
-                                  FStar_Pprint.op_Hat_Hat
-                                    FStar_Pprint.hardline uu___14 in
-                                FStar_Pprint.op_Hat_Hat r1 uu___13 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___12 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat p1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | FStar_Parser_AST.ElimAnd (p, q, r, x, y, e1) ->
-            let p1 = p_tmFormula p in
-            let q1 = p_tmTuple q in
-            let r1 = p_noSeqTermAndComment false false r in
-            let xy = p_binders_sep [x; y] in
-            let e2 = p_noSeqTermAndComment false false e1 in
-            let uu___ = str "eliminate" in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = str "/\\" in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 = str "returns" in
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  let uu___14 =
-                                    let uu___15 = str "with" in
-                                    let uu___16 =
-                                      let uu___17 =
-                                        let uu___18 =
-                                          let uu___19 =
-                                            let uu___20 = str "." in
-                                            let uu___21 =
-                                              FStar_Pprint.op_Hat_Hat
-                                                FStar_Pprint.space e2 in
-                                            FStar_Pprint.op_Hat_Hat uu___20
-                                              uu___21 in
-                                          FStar_Pprint.op_Hat_Hat
-                                            FStar_Pprint.space uu___19 in
-                                        FStar_Pprint.op_Hat_Hat xy uu___18 in
-                                      FStar_Pprint.op_Hat_Hat
-                                        FStar_Pprint.space uu___17 in
-                                    FStar_Pprint.op_Hat_Hat uu___15 uu___16 in
-                                  FStar_Pprint.op_Hat_Hat
-                                    FStar_Pprint.hardline uu___14 in
-                                FStar_Pprint.op_Hat_Hat r1 uu___13 in
-                              FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                                uu___12 in
-                            FStar_Pprint.op_Hat_Hat uu___10 uu___11 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___9 in
-                        FStar_Pprint.op_Hat_Hat q1 uu___8 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                    FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___4 in
-                FStar_Pprint.op_Hat_Hat p1 uu___3 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-            FStar_Pprint.op_Hat_Hat uu___ uu___1
-        | uu___ -> p_typ ps pb e
-and (p_dec_wf :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_Parser_AST.term -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun rel ->
-        fun e ->
-          let uu___ =
-            let uu___1 = str "{:well-founded " in
-            let uu___2 =
-              let uu___3 = p_typ ps pb rel in
-              let uu___4 =
-                let uu___5 = p_typ ps pb e in
-                let uu___6 = str " }" in
-                FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-              FStar_Pprint.op_Hat_Slash_Hat uu___3 uu___4 in
-            FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-          FStar_Pprint.group uu___
-and (p_calcStep :
-  Prims.bool -> FStar_Parser_AST.calc_step -> FStar_Pprint.document) =
-  fun uu___ ->
-    fun uu___1 ->
-      match uu___1 with
-      | FStar_Parser_AST.CalcStep (rel, just, next) ->
-          let uu___2 =
-            let uu___3 = p_noSeqTermAndComment false false rel in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 = p_noSeqTermAndComment false false just in
-                    let uu___9 =
-                      let uu___10 =
-                        let uu___11 =
-                          let uu___12 =
-                            let uu___13 =
-                              p_noSeqTermAndComment false false next in
-                            let uu___14 = str ";" in
-                            FStar_Pprint.op_Hat_Hat uu___13 uu___14 in
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline
-                            uu___12 in
-                        FStar_Pprint.op_Hat_Hat FStar_Pprint.rbrace uu___11 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___10 in
-                    FStar_Pprint.op_Hat_Hat uu___8 uu___9 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___7 in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.lbrace uu___6 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___5 in
-            FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-          FStar_Pprint.group uu___2
-and (p_attrs_opt :
-  Prims.bool ->
-    FStar_Parser_AST.term Prims.list FStar_Pervasives_Native.option ->
-      FStar_Pprint.document)
-  =
-  fun isTopLevel ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pprint.empty
-      | FStar_Pervasives_Native.Some terms ->
-          let uu___1 =
-            let uu___2 = str (if isTopLevel then "[@@" else "[@@@") in
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = str "; " in
-                FStar_Pprint.separate_map uu___5
-                  (p_noSeqTermAndComment false false) terms in
-              let uu___5 = str "]" in
-              FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-            FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-          FStar_Pprint.group uu___1
-and (p_typ :
-  Prims.bool -> Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb -> fun e -> with_comment (p_typ' ps pb) e e.FStar_Parser_AST.range
-and (p_typ_sep :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_Parser_AST.term ->
-        (FStar_Pprint.document * FStar_Pprint.document))
-  =
-  fun ps ->
-    fun pb ->
-      fun e -> with_comment_sep (p_typ' ps pb) e e.FStar_Parser_AST.range
-and (p_typ' :
-  Prims.bool -> Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun e ->
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.QForall (bs, (uu___, trigger), e1) ->
-            let binders_doc = p_binders true bs in
-            let term_doc = p_noSeqTermAndComment ps pb e1 in
-            (match trigger with
-             | [] ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = p_quantifier e in
-                     FStar_Pprint.op_Hat_Hat uu___3 FStar_Pprint.space in
-                   FStar_Pprint.soft_surround (Prims.of_int (2))
-                     Prims.int_zero uu___2 binders_doc FStar_Pprint.dot in
-                 prefix2 uu___1 term_doc
-             | pats ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 = p_quantifier e in
-                         FStar_Pprint.op_Hat_Hat uu___5 FStar_Pprint.space in
-                       FStar_Pprint.soft_surround (Prims.of_int (2))
-                         Prims.int_zero uu___4 binders_doc FStar_Pprint.dot in
-                     let uu___4 = p_trigger trigger in prefix2 uu___3 uu___4 in
-                   FStar_Pprint.group uu___2 in
-                 prefix2 uu___1 term_doc)
-        | FStar_Parser_AST.QExists (bs, (uu___, trigger), e1) ->
-            let binders_doc = p_binders true bs in
-            let term_doc = p_noSeqTermAndComment ps pb e1 in
-            (match trigger with
-             | [] ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = p_quantifier e in
-                     FStar_Pprint.op_Hat_Hat uu___3 FStar_Pprint.space in
-                   FStar_Pprint.soft_surround (Prims.of_int (2))
-                     Prims.int_zero uu___2 binders_doc FStar_Pprint.dot in
-                 prefix2 uu___1 term_doc
-             | pats ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 = p_quantifier e in
-                         FStar_Pprint.op_Hat_Hat uu___5 FStar_Pprint.space in
-                       FStar_Pprint.soft_surround (Prims.of_int (2))
-                         Prims.int_zero uu___4 binders_doc FStar_Pprint.dot in
-                     let uu___4 = p_trigger trigger in prefix2 uu___3 uu___4 in
-                   FStar_Pprint.group uu___2 in
-                 prefix2 uu___1 term_doc)
-        | uu___ -> p_simpleTerm ps pb e
-and (p_typ_top :
-  annotation_style ->
-    Prims.bool ->
-      Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun style ->
-    fun ps ->
-      fun pb ->
-        fun e ->
-          with_comment (p_typ_top' style ps pb) e e.FStar_Parser_AST.range
-and (p_typ_top' :
-  annotation_style ->
-    Prims.bool ->
-      Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun style ->
-    fun ps -> fun pb -> fun e -> p_tmArrow style true p_tmFormula e
-and (sig_as_binders_if_possible :
-  FStar_Parser_AST.term -> Prims.bool -> FStar_Pprint.document) =
-  fun t ->
-    fun extra_space ->
-      let s = if extra_space then FStar_Pprint.space else FStar_Pprint.empty in
-      let uu___ = all_binders_annot t in
-      if uu___
-      then
-        let uu___1 =
-          p_typ_top (Binders ((Prims.of_int (4)), Prims.int_zero, true))
-            false false t in
-        FStar_Pprint.op_Hat_Hat s uu___1
-      else
-        (let uu___2 =
-           let uu___3 =
-             let uu___4 =
-               p_typ_top (Arrows ((Prims.of_int (2)), (Prims.of_int (2))))
-                 false false t in
-             FStar_Pprint.op_Hat_Hat s uu___4 in
-           FStar_Pprint.op_Hat_Hat FStar_Pprint.colon uu___3 in
-         FStar_Pprint.group uu___2)
-and (collapse_pats :
-  (FStar_Pprint.document * FStar_Pprint.document * Prims.bool * Prims.bool)
-    Prims.list -> FStar_Pprint.document Prims.list)
-  =
-  fun pats ->
-    let fold_fun bs x =
-      let uu___ = x in
-      match uu___ with
-      | (b1, t1, tc1, j1) ->
-          (match bs with
-           | [] -> [([b1], t1, tc1, j1)]
-           | hd::tl ->
-               let uu___1 = hd in
-               (match uu___1 with
-                | (b2s, t2, tc2, j2) ->
-                    if ((t1 = t2) && j1) && j2
-                    then
-                      ((FStar_Compiler_List.op_At b2s [b1]), t1, false, true)
-                      :: tl
-                    else ([b1], t1, tc1, j1) :: hd :: tl)) in
-    let p_collapsed_binder cb =
-      let uu___ = cb in
-      match uu___ with
-      | (bs, typ, istcarg, uu___1) ->
-          let body =
-            match bs with
-            | [] -> failwith "Impossible"
-            | hd::tl ->
-                let uu___2 =
-                  FStar_Compiler_List.fold_left
-                    (fun x ->
-                       fun y ->
-                         let uu___3 =
-                           FStar_Pprint.op_Hat_Hat FStar_Pprint.space y in
-                         FStar_Pprint.op_Hat_Hat x uu___3) hd tl in
-                cat_with_colon uu___2 typ in
-          if istcarg then tc_arg body else soft_parens_with_nesting body in
-    let binders =
-      FStar_Compiler_List.fold_left fold_fun []
-        (FStar_Compiler_List.rev pats) in
-    map_rev p_collapsed_binder binders
-and (pats_as_binders_if_possible :
-  FStar_Parser_AST.pattern Prims.list ->
-    (FStar_Pprint.document Prims.list * annotation_style))
-  =
-  fun pats ->
-    let all_binders p =
-      match p.FStar_Parser_AST.pat with
-      | FStar_Parser_AST.PatAscribed (pat, (t, FStar_Pervasives_Native.None))
-          ->
-          (match ((pat.FStar_Parser_AST.pat), (t.FStar_Parser_AST.tm)) with
-           | (FStar_Parser_AST.PatVar (lid, aqual, attrs),
-              FStar_Parser_AST.Refine
-              ({ FStar_Parser_AST.b = FStar_Parser_AST.Annotated (lid', t1);
-                 FStar_Parser_AST.brange = uu___;
-                 FStar_Parser_AST.blevel = uu___1;
-                 FStar_Parser_AST.aqual = uu___2;
-                 FStar_Parser_AST.battributes = uu___3;_},
-               phi)) when
-               let uu___4 = FStar_Ident.string_of_id lid in
-               let uu___5 = FStar_Ident.string_of_id lid' in uu___4 = uu___5
-               ->
-               let uu___4 =
-                 let uu___5 = p_ident lid in
-                 p_refinement' aqual attrs uu___5 t1 phi in
-               (match uu___4 with
-                | (x, y) -> FStar_Pervasives_Native.Some (x, y, false, false))
-           | (FStar_Parser_AST.PatVar (lid, aqual, attrs), uu___) ->
-               let is_tc =
-                 aqual =
-                   (FStar_Pervasives_Native.Some
-                      FStar_Parser_AST.TypeClassArg) in
-               let is_meta =
-                 match aqual with
-                 | FStar_Pervasives_Native.Some (FStar_Parser_AST.Meta
-                     uu___1) -> true
-                 | uu___1 -> false in
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 = FStar_Pprint.optional p_aqual aqual in
-                   let uu___4 =
-                     let uu___5 = p_attributes false attrs in
-                     let uu___6 = p_ident lid in
-                     FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                   FStar_Pprint.op_Hat_Hat uu___3 uu___4 in
-                 let uu___3 = p_tmEqNoRefinement t in
-                 (uu___2, uu___3, is_tc,
-                   ((Prims.op_Negation is_tc) && (Prims.op_Negation is_meta))) in
-               FStar_Pervasives_Native.Some uu___1
-           | uu___ -> FStar_Pervasives_Native.None)
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = map_if_all all_binders pats in
-    match uu___ with
-    | FStar_Pervasives_Native.Some bs ->
-        let uu___1 = collapse_pats bs in
-        (uu___1, (Binders ((Prims.of_int (4)), Prims.int_zero, true)))
-    | FStar_Pervasives_Native.None ->
-        let uu___1 = FStar_Compiler_List.map p_atomicPattern pats in
-        (uu___1, (Binders ((Prims.of_int (4)), Prims.int_zero, false)))
-and (p_quantifier : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.QForall uu___ -> str "forall"
-    | FStar_Parser_AST.QExists uu___ -> str "exists"
-    | uu___ ->
-        failwith "Imposible : p_quantifier called on a non-quantifier term"
-and (p_trigger :
-  FStar_Parser_AST.term Prims.list Prims.list -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | [] -> FStar_Pprint.empty
-    | pats ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = str "pattern" in
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 = p_disjunctivePats pats in
-                  FStar_Pprint.jump (Prims.of_int (2)) Prims.int_zero uu___7 in
-                FStar_Pprint.op_Hat_Hat uu___6 FStar_Pprint.rbrace in
-              FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.colon uu___3 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.lbrace uu___2 in
-        FStar_Pprint.group uu___1
-and (p_disjunctivePats :
-  FStar_Parser_AST.term Prims.list Prims.list -> FStar_Pprint.document) =
-  fun pats ->
-    let uu___ = str "\\/" in
-    FStar_Pprint.separate_map uu___ p_conjunctivePats pats
-and (p_conjunctivePats :
-  FStar_Parser_AST.term Prims.list -> FStar_Pprint.document) =
-  fun pats ->
-    let uu___ =
-      let uu___1 = FStar_Pprint.op_Hat_Hat FStar_Pprint.semi break1 in
-      FStar_Pprint.separate_map uu___1 p_appTerm pats in
-    FStar_Pprint.group uu___
-and (p_simpleTerm :
-  Prims.bool -> Prims.bool -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun pb ->
-      fun e ->
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.Abs (pats, e1) ->
-            let uu___ = p_term_sep false pb e1 in
-            (match uu___ with
-             | (comm, doc) ->
-                 let prefix =
-                   let uu___1 = str "fun" in
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Pprint.separate_map break1 p_atomicPattern pats in
-                     FStar_Pprint.op_Hat_Slash_Hat uu___3 FStar_Pprint.rarrow in
-                   op_Hat_Slash_Plus_Hat uu___1 uu___2 in
-                 let uu___1 =
-                   if comm <> FStar_Pprint.empty
-                   then
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline doc in
-                         FStar_Pprint.op_Hat_Hat comm uu___4 in
-                       FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline uu___3 in
-                     FStar_Pprint.op_Hat_Hat prefix uu___2
-                   else
-                     (let uu___3 = op_Hat_Slash_Plus_Hat prefix doc in
-                      FStar_Pprint.group uu___3) in
-                 let uu___2 = paren_if ps in uu___2 uu___1)
-        | uu___ -> p_tmIff e
-and (p_maybeFocusArrow : Prims.bool -> FStar_Pprint.document) =
-  fun b -> if b then str "~>" else FStar_Pprint.rarrow
-and (p_patternBranch :
-  Prims.bool ->
-    (FStar_Parser_AST.pattern * FStar_Parser_AST.term
-      FStar_Pervasives_Native.option * FStar_Parser_AST.term) ->
-      FStar_Pprint.document)
-  =
-  fun pb ->
-    fun uu___ ->
-      match uu___ with
-      | (pat, when_opt, e) ->
-          let one_pattern_branch p =
-            let branch =
-              match when_opt with
-              | FStar_Pervasives_Native.None ->
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = p_tuplePattern p in
-                        let uu___5 =
-                          FStar_Pprint.op_Hat_Hat FStar_Pprint.space
-                            FStar_Pprint.rarrow in
-                        FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.bar uu___2 in
-                  FStar_Pprint.group uu___1
-              | FStar_Pervasives_Native.Some f ->
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 = p_tuplePattern p in
-                            let uu___7 = str "when" in
-                            FStar_Pprint.op_Hat_Slash_Hat uu___6 uu___7 in
-                          FStar_Pprint.group uu___5 in
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 = p_tmFormula f in
-                            [uu___7; FStar_Pprint.rarrow] in
-                          FStar_Pprint.flow break1 uu___6 in
-                        FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.bar uu___2 in
-                  FStar_Pprint.hang (Prims.of_int (2)) uu___1 in
-            let uu___1 = p_term_sep false pb e in
-            match uu___1 with
-            | (comm, doc) ->
-                if pb
-                then
-                  (if comm = FStar_Pprint.empty
-                   then
-                     let uu___2 = op_Hat_Slash_Plus_Hat branch doc in
-                     FStar_Pprint.group uu___2
-                   else
-                     (let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                FStar_Pprint.op_Hat_Hat break1 comm in
-                              FStar_Pprint.op_Hat_Hat doc uu___7 in
-                            op_Hat_Slash_Plus_Hat branch uu___6 in
-                          FStar_Pprint.group uu___5 in
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              inline_comment_or_above comm doc
-                                FStar_Pprint.empty in
-                            jump2 uu___7 in
-                          FStar_Pprint.op_Hat_Hat branch uu___6 in
-                        FStar_Pprint.ifflat uu___4 uu___5 in
-                      FStar_Pprint.group uu___3))
-                else
-                  if comm <> FStar_Pprint.empty
-                  then
-                    (let uu___3 =
-                       let uu___4 =
-                         FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline doc in
-                       FStar_Pprint.op_Hat_Hat comm uu___4 in
-                     op_Hat_Slash_Plus_Hat branch uu___3)
-                  else op_Hat_Slash_Plus_Hat branch doc in
-          (match pat.FStar_Parser_AST.pat with
-           | FStar_Parser_AST.PatOr pats ->
-               (match FStar_Compiler_List.rev pats with
-                | hd::tl ->
-                    let last_pat_branch = one_pattern_branch hd in
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Pprint.op_Hat_Hat FStar_Pprint.bar
-                                  FStar_Pprint.space in
-                              FStar_Pprint.op_Hat_Hat break1 uu___6 in
-                            FStar_Pprint.separate_map uu___5 p_tuplePattern
-                              (FStar_Compiler_List.rev tl) in
-                          FStar_Pprint.op_Hat_Slash_Hat uu___4
-                            last_pat_branch in
-                        FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.bar uu___2 in
-                    FStar_Pprint.group uu___1
-                | [] ->
-                    failwith "Impossible: disjunctive pattern can't be empty")
-           | uu___1 -> one_pattern_branch pat)
-and (p_tmIff : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Op (id, e1::e2::[]) when
-        let uu___ = FStar_Ident.string_of_id id in uu___ = "<==>" ->
-        let uu___ = str "<==>" in
-        let uu___1 = p_tmImplies e1 in
-        let uu___2 = p_tmIff e2 in infix0 uu___ uu___1 uu___2
-    | uu___ -> p_tmImplies e
-and (p_tmImplies : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Op (id, e1::e2::[]) when
-        let uu___ = FStar_Ident.string_of_id id in uu___ = "==>" ->
-        let uu___ = str "==>" in
-        let uu___1 =
-          p_tmArrow (Arrows ((Prims.of_int (2)), (Prims.of_int (2)))) false
-            p_tmFormula e1 in
-        let uu___2 = p_tmImplies e2 in infix0 uu___ uu___1 uu___2
-    | uu___ ->
-        p_tmArrow (Arrows ((Prims.of_int (2)), (Prims.of_int (2)))) false
-          p_tmFormula e
-and (format_sig :
-  annotation_style ->
-    FStar_Pprint.document Prims.list ->
-      FStar_Pprint.document ->
-        Prims.bool -> Prims.bool -> FStar_Pprint.document)
-  =
-  fun style ->
-    fun terms ->
-      fun ret_d ->
-        fun no_last_op ->
-          fun flat_space ->
-            let uu___ =
-              match style with
-              | Arrows (n, ln) ->
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Pprint.op_Hat_Hat FStar_Pprint.rarrow break1 in
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-                  let uu___2 =
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.rarrow
-                      FStar_Pprint.space in
-                  (n, ln, uu___1, uu___2)
-              | Binders (n, ln, parens) ->
-                  let uu___1 =
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.colon
-                      FStar_Pprint.space in
-                  (n, ln, break1, uu___1) in
-            match uu___ with
-            | (n, last_n, sep, last_op) ->
-                let last_op1 =
-                  if
-                    ((FStar_Compiler_List.length terms) > Prims.int_zero) &&
-                      (Prims.op_Negation no_last_op)
-                  then last_op
-                  else FStar_Pprint.empty in
-                let one_line_space =
-                  if
-                    (Prims.op_Negation (ret_d = FStar_Pprint.empty)) ||
-                      (Prims.op_Negation no_last_op)
-                  then FStar_Pprint.space
-                  else FStar_Pprint.empty in
-                let single_line_arg_indent =
-                  FStar_Pprint.repeat n FStar_Pprint.space in
-                let fs =
-                  if flat_space
-                  then FStar_Pprint.space
-                  else FStar_Pprint.empty in
-                (match FStar_Compiler_List.length terms with
-                 | uu___1 when uu___1 = Prims.int_zero -> ret_d
-                 | uu___1 ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 = FStar_Pprint.separate sep terms in
-                           let uu___6 =
-                             let uu___7 =
-                               FStar_Pprint.op_Hat_Hat last_op1 ret_d in
-                             FStar_Pprint.op_Hat_Hat one_line_space uu___7 in
-                           FStar_Pprint.op_Hat_Hat uu___5 uu___6 in
-                         FStar_Pprint.op_Hat_Hat fs uu___4 in
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 = FStar_Pprint.separate sep terms in
-                               FStar_Pprint.op_Hat_Hat fs uu___8 in
-                             let uu___8 =
-                               let uu___9 =
-                                 let uu___10 =
-                                   let uu___11 =
-                                     FStar_Pprint.op_Hat_Hat sep
-                                       single_line_arg_indent in
-                                   let uu___12 =
-                                     FStar_Compiler_List.map
-                                       (fun x ->
-                                          let uu___13 =
-                                            FStar_Pprint.hang
-                                              (Prims.of_int (2)) x in
-                                          FStar_Pprint.align uu___13) terms in
-                                   FStar_Pprint.separate uu___11 uu___12 in
-                                 FStar_Pprint.op_Hat_Hat
-                                   single_line_arg_indent uu___10 in
-                               jump2 uu___9 in
-                             FStar_Pprint.ifflat uu___7 uu___8 in
-                           FStar_Pprint.group uu___6 in
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_Pprint.op_Hat_Hat last_op1 ret_d in
-                             FStar_Pprint.hang last_n uu___8 in
-                           FStar_Pprint.align uu___7 in
-                         FStar_Pprint.prefix n Prims.int_one uu___5 uu___6 in
-                       FStar_Pprint.ifflat uu___3 uu___4 in
-                     FStar_Pprint.group uu___2)
-and (p_tmArrow :
-  annotation_style ->
-    Prims.bool ->
-      (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-        FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun style ->
-    fun flat_space ->
-      fun p_Tm ->
-        fun e ->
-          let uu___ =
-            match style with
-            | Arrows uu___1 -> p_tmArrow' p_Tm e
-            | Binders uu___1 -> collapse_binders style p_Tm e in
-          match uu___ with
-          | (terms, ret_d) -> format_sig style terms ret_d false flat_space
-and (p_tmArrow' :
-  (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-    FStar_Parser_AST.term ->
-      (FStar_Pprint.document Prims.list * FStar_Pprint.document))
-  =
-  fun p_Tm ->
-    fun e ->
-      match e.FStar_Parser_AST.tm with
-      | FStar_Parser_AST.Product (bs, tgt) ->
-          let bs_ds = FStar_Compiler_List.map (fun b -> p_binder false b) bs in
-          let uu___ = p_tmArrow' p_Tm tgt in
-          (match uu___ with
-           | (bs_ds', ret) -> ((FStar_Compiler_List.op_At bs_ds bs_ds'), ret))
-      | uu___ -> let uu___1 = p_Tm e in ([], uu___1)
-and (collapse_binders :
-  annotation_style ->
-    (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-      FStar_Parser_AST.term ->
-        (FStar_Pprint.document Prims.list * FStar_Pprint.document))
-  =
-  fun style ->
-    fun p_Tm ->
-      fun e ->
-        let atomize =
-          match style with | Binders (uu___, uu___1, a) -> a | uu___ -> false in
-        let wrap is_tc doc =
-          if is_tc
-          then tc_arg doc
-          else if atomize then soft_parens_with_nesting doc else doc in
-        let rec accumulate_binders p_Tm1 e1 =
-          match e1.FStar_Parser_AST.tm with
-          | FStar_Parser_AST.Product (bs, tgt) ->
-              let bs_ds =
-                FStar_Compiler_List.map
-                  (fun b ->
-                     let uu___ = p_binder' true false b in
-                     let uu___1 = is_tc_binder b in
-                     let uu___2 = is_joinable_binder b in
-                     (uu___, uu___1, uu___2)) bs in
-              let uu___ = accumulate_binders p_Tm1 tgt in
-              (match uu___ with
-               | (bs_ds', ret) ->
-                   ((FStar_Compiler_List.op_At bs_ds bs_ds'), ret))
-          | uu___ -> let uu___1 = p_Tm1 e1 in ([], uu___1) in
-        let fold_fun bs x =
-          let uu___ = x in
-          match uu___ with
-          | ((b1, t1), tc1, j1) ->
-              (match bs with
-               | [] -> [([b1], t1, tc1, j1)]
-               | hd::tl ->
-                   let uu___1 = hd in
-                   (match uu___1 with
-                    | (b2s, t2, tc2, j2) ->
-                        (match (t1, t2) with
-                         | (FStar_Pervasives_Native.Some (typ1, catf1),
-                            FStar_Pervasives_Native.Some (typ2, uu___2)) when
-                             ((typ1 = typ2) && j1) && j2 ->
-                             ((FStar_Compiler_List.op_At b2s [b1]), t1,
-                               false, true)
-                             :: tl
-                         | uu___2 -> ([b1], t1, tc1, j1) :: bs))) in
-        let p_collapsed_binder cb =
-          let uu___ = cb in
-          match uu___ with
-          | (bs, t, is_tc, uu___1) ->
-              (match t with
-               | FStar_Pervasives_Native.None ->
-                   (match bs with
-                    | b::[] -> wrap is_tc b
-                    | uu___2 -> failwith "Impossible")
-               | FStar_Pervasives_Native.Some (typ, f) ->
-                   (match bs with
-                    | [] -> failwith "Impossible"
-                    | hd::tl ->
-                        let uu___2 =
-                          let uu___3 =
-                            FStar_Compiler_List.fold_left
-                              (fun x ->
-                                 fun y ->
-                                   let uu___4 =
-                                     FStar_Pprint.op_Hat_Hat
-                                       FStar_Pprint.space y in
-                                   FStar_Pprint.op_Hat_Hat x uu___4) hd tl in
-                          f uu___3 typ in
-                        FStar_Compiler_Effect.op_Less_Bar (wrap is_tc) uu___2)) in
-        let uu___ = accumulate_binders p_Tm e in
-        match uu___ with
-        | (bs_ds, ret_d) ->
-            let binders = FStar_Compiler_List.fold_left fold_fun [] bs_ds in
-            let uu___1 = map_rev p_collapsed_binder binders in
-            (uu___1, ret_d)
-and (p_tmFormula : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    let conj =
-      let uu___ =
-        let uu___1 = str "/\\" in FStar_Pprint.op_Hat_Hat uu___1 break1 in
-      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___ in
-    let disj =
-      let uu___ =
-        let uu___1 = str "\\/" in FStar_Pprint.op_Hat_Hat uu___1 break1 in
-      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___ in
-    let formula = p_tmDisjunction e in
-    FStar_Pprint.flow_map disj
-      (fun d -> FStar_Pprint.flow_map conj (fun x -> FStar_Pprint.group x) d)
-      formula
-and (p_tmDisjunction :
-  FStar_Parser_AST.term -> FStar_Pprint.document Prims.list Prims.list) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Op (id, e1::e2::[]) when
-        let uu___ = FStar_Ident.string_of_id id in uu___ = "\\/" ->
-        let uu___ = p_tmDisjunction e1 in
-        let uu___1 = let uu___2 = p_tmConjunction e2 in [uu___2] in
-        FStar_Compiler_List.op_At uu___ uu___1
-    | uu___ -> let uu___1 = p_tmConjunction e in [uu___1]
-and (p_tmConjunction :
-  FStar_Parser_AST.term -> FStar_Pprint.document Prims.list) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Op (id, e1::e2::[]) when
-        let uu___ = FStar_Ident.string_of_id id in uu___ = "/\\" ->
-        let uu___ = p_tmConjunction e1 in
-        let uu___1 = let uu___2 = p_tmTuple e2 in [uu___2] in
-        FStar_Compiler_List.op_At uu___ uu___1
-    | uu___ -> let uu___1 = p_tmTuple e in [uu___1]
-and (p_tmTuple : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e -> with_comment p_tmTuple' e e.FStar_Parser_AST.range
-and (p_tmTuple' : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Construct (lid, args) when
-        (is_tuple_constructor lid) && (all1_explicit args) ->
-        let uu___ = FStar_Pprint.op_Hat_Hat FStar_Pprint.comma break1 in
-        FStar_Pprint.separate_map uu___
-          (fun uu___1 -> match uu___1 with | (e1, uu___2) -> p_tmEq e1) args
-    | uu___ -> p_tmEq e
-and (paren_if_gt :
-  Prims.int -> Prims.int -> FStar_Pprint.document -> FStar_Pprint.document) =
-  fun curr ->
-    fun mine ->
-      fun doc ->
-        if mine <= curr
-        then doc
-        else
-          (let uu___1 =
-             let uu___2 = FStar_Pprint.op_Hat_Hat doc FStar_Pprint.rparen in
-             FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen uu___2 in
-           FStar_Pprint.group uu___1)
-and (p_tmEqWith :
-  (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-    FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun p_X ->
-    fun e ->
-      let n =
-        max_level
-          (FStar_Compiler_List.op_At [colon_equals; pipe_right]
-             operatorInfix0ad12) in
-      p_tmEqWith' p_X n e
-and (p_tmEqWith' :
-  (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-    Prims.int -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun p_X ->
-    fun curr ->
-      fun e ->
-        match e.FStar_Parser_AST.tm with
-        | FStar_Parser_AST.Op (op, e1::e2::[]) when
-            (let uu___ =
-               (let uu___1 = FStar_Ident.string_of_id op in uu___1 = "==>")
-                 ||
-                 (let uu___1 = FStar_Ident.string_of_id op in uu___1 = "<==>") in
-             Prims.op_Negation uu___) &&
-              (((is_operatorInfix0ad12 op) ||
-                  (let uu___ = FStar_Ident.string_of_id op in uu___ = "="))
-                 || (let uu___ = FStar_Ident.string_of_id op in uu___ = "|>"))
-            ->
-            let op1 = FStar_Ident.string_of_id op in
-            let uu___ = levels op1 in
-            (match uu___ with
-             | (left, mine, right) ->
-                 let uu___1 =
-                   let uu___2 = FStar_Compiler_Effect.op_Less_Bar str op1 in
-                   let uu___3 = p_tmEqWith' p_X left e1 in
-                   let uu___4 = p_tmEqWith' p_X right e2 in
-                   infix0 uu___2 uu___3 uu___4 in
-                 paren_if_gt curr mine uu___1)
-        | FStar_Parser_AST.Op (id, e1::e2::[]) when
-            let uu___ = FStar_Ident.string_of_id id in uu___ = ":=" ->
-            let uu___ =
-              let uu___1 = p_tmEqWith p_X e1 in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = p_tmEqWith p_X e2 in
-                    op_Hat_Slash_Plus_Hat FStar_Pprint.equals uu___5 in
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.colon uu___4 in
-                FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-              FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-            FStar_Pprint.group uu___
-        | FStar_Parser_AST.Op (id, e1::[]) when
-            let uu___ = FStar_Ident.string_of_id id in uu___ = "-" ->
-            let uu___ = levels "-" in
-            (match uu___ with
-             | (left, mine, right) ->
-                 let uu___1 = p_tmEqWith' p_X mine e1 in
-                 FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.minus uu___1)
-        | uu___ -> p_tmNoEqWith p_X e
-and (p_tmNoEqWith :
-  (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-    FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun p_X ->
-    fun e ->
-      let n = max_level [colon_colon; amp; opinfix3; opinfix4] in
-      p_tmNoEqWith' false p_X n e
-and (p_tmNoEqWith' :
-  Prims.bool ->
-    (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-      Prims.int -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun inside_tuple ->
-    fun p_X ->
-      fun curr ->
-        fun e ->
-          match e.FStar_Parser_AST.tm with
-          | FStar_Parser_AST.Construct (lid, (e1, uu___)::(e2, uu___1)::[])
-              when
-              (FStar_Ident.lid_equals lid FStar_Parser_Const.cons_lid) &&
-                (let uu___2 = is_list e in Prims.op_Negation uu___2)
-              ->
-              let op = "::" in
-              let uu___2 = levels op in
-              (match uu___2 with
-               | (left, mine, right) ->
-                   let uu___3 =
-                     let uu___4 = str op in
-                     let uu___5 = p_tmNoEqWith' false p_X left e1 in
-                     let uu___6 = p_tmNoEqWith' false p_X right e2 in
-                     infix0 uu___4 uu___5 uu___6 in
-                   paren_if_gt curr mine uu___3)
-          | FStar_Parser_AST.Sum (binders, res) ->
-              let op = "&" in
-              let uu___ = levels op in
-              (match uu___ with
-               | (left, mine, right) ->
-                   let p_dsumfst bt =
-                     match bt with
-                     | FStar_Pervasives.Inl b ->
-                         let uu___1 = p_binder false b in
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = str op in
-                             FStar_Pprint.op_Hat_Hat uu___4 break1 in
-                           FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-                         FStar_Pprint.op_Hat_Hat uu___1 uu___2
-                     | FStar_Pervasives.Inr t ->
-                         let uu___1 = p_tmNoEqWith' false p_X left t in
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = str op in
-                             FStar_Pprint.op_Hat_Hat uu___4 break1 in
-                           FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___3 in
-                         FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-                   let uu___1 =
-                     let uu___2 = FStar_Pprint.concat_map p_dsumfst binders in
-                     let uu___3 = p_tmNoEqWith' false p_X right res in
-                     FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-                   paren_if_gt curr mine uu___1)
-          | FStar_Parser_AST.Op (id, e1::e2::[]) when
-              (let uu___ = FStar_Ident.string_of_id id in uu___ = "*") &&
-                (FStar_Compiler_Effect.op_Bang unfold_tuples)
-              ->
-              let op = "*" in
-              let uu___ = levels op in
-              (match uu___ with
-               | (left, mine, right) ->
-                   if inside_tuple
-                   then
-                     let uu___1 = str op in
-                     let uu___2 = p_tmNoEqWith' true p_X left e1 in
-                     let uu___3 = p_tmNoEqWith' true p_X right e2 in
-                     infix0 uu___1 uu___2 uu___3
-                   else
-                     (let uu___2 =
-                        let uu___3 = str op in
-                        let uu___4 = p_tmNoEqWith' true p_X left e1 in
-                        let uu___5 = p_tmNoEqWith' true p_X right e2 in
-                        infix0 uu___3 uu___4 uu___5 in
-                      paren_if_gt curr mine uu___2))
-          | FStar_Parser_AST.Op (op, e1::e2::[]) when is_operatorInfix34 op
-              ->
-              let op1 = FStar_Ident.string_of_id op in
-              let uu___ = levels op1 in
-              (match uu___ with
-               | (left, mine, right) ->
-                   let uu___1 =
-                     let uu___2 = str op1 in
-                     let uu___3 = p_tmNoEqWith' false p_X left e1 in
-                     let uu___4 = p_tmNoEqWith' false p_X right e2 in
-                     infix0 uu___2 uu___3 uu___4 in
-                   paren_if_gt curr mine uu___1)
-          | FStar_Parser_AST.Record (with_opt, record_fields) ->
-              let uu___ =
-                let uu___1 =
-                  default_or_map FStar_Pprint.empty p_with_clause with_opt in
-                let uu___2 =
-                  let uu___3 =
-                    FStar_Pprint.op_Hat_Hat FStar_Pprint.semi break1 in
-                  separate_map_last uu___3 p_simpleDef record_fields in
-                FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-              braces_with_nesting uu___
-          | FStar_Parser_AST.Op (id, e1::[]) when
-              let uu___ = FStar_Ident.string_of_id id in uu___ = "~" ->
-              let uu___ =
-                let uu___1 = str "~" in
-                let uu___2 = p_atomicTerm e1 in
-                FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-              FStar_Pprint.group uu___
-          | FStar_Parser_AST.Paren p when inside_tuple ->
-              (match p.FStar_Parser_AST.tm with
-               | FStar_Parser_AST.Op (id, e1::e2::[]) when
-                   let uu___ = FStar_Ident.string_of_id id in uu___ = "*" ->
-                   let op = "*" in
-                   let uu___ = levels op in
-                   (match uu___ with
-                    | (left, mine, right) ->
-                        let uu___1 =
-                          let uu___2 = str op in
-                          let uu___3 = p_tmNoEqWith' true p_X left e1 in
-                          let uu___4 = p_tmNoEqWith' true p_X right e2 in
-                          infix0 uu___2 uu___3 uu___4 in
-                        paren_if_gt curr mine uu___1)
-               | uu___ -> p_X e)
-          | uu___ -> p_X e
-and (p_tmEqNoRefinement : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e -> p_tmEqWith p_appTerm e
-and (p_tmEq : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e -> p_tmEqWith p_tmRefinement e
-and (p_tmNoEq : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e -> p_tmNoEqWith p_tmRefinement e
-and (p_tmRefinement : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.NamedTyp (lid, e1) ->
-        let uu___ =
-          let uu___1 = p_lident lid in
-          let uu___2 =
-            let uu___3 = p_appTerm e1 in
-            FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.colon uu___3 in
-          FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.Refine (b, phi) -> p_refinedBinder b phi
-    | uu___ -> p_appTerm e
-and (p_with_clause : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    let uu___ = p_appTerm e in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 = str "with" in FStar_Pprint.op_Hat_Hat uu___3 break1 in
-      FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___2 in
-    FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_refinedBinder :
-  FStar_Parser_AST.binder -> FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun b ->
-    fun phi ->
-      match b.FStar_Parser_AST.b with
-      | FStar_Parser_AST.Annotated (lid, t) ->
-          let uu___ = p_lident lid in
-          p_refinement b.FStar_Parser_AST.aqual
-            b.FStar_Parser_AST.battributes uu___ t phi
-      | FStar_Parser_AST.Variable lid ->
-          let uu___ = p_lident lid in
-          let uu___1 =
-            let uu___2 = FStar_Ident.range_of_id lid in
-            FStar_Parser_AST.mk_term FStar_Parser_AST.Wild uu___2
-              FStar_Parser_AST.Type_level in
-          p_refinement b.FStar_Parser_AST.aqual
-            b.FStar_Parser_AST.battributes uu___ uu___1 phi
-      | FStar_Parser_AST.TAnnotated uu___ -> failwith "Is this still used ?"
-      | FStar_Parser_AST.TVariable uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Parser_AST.binder_to_string b in
-            FStar_Compiler_Util.format1
-              "Impossible: a refined binder ought to be annotated (%s)"
-              uu___2 in
-          failwith uu___1
-      | FStar_Parser_AST.NoName uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Parser_AST.binder_to_string b in
-            FStar_Compiler_Util.format1
-              "Impossible: a refined binder ought to be annotated (%s)"
-              uu___2 in
-          failwith uu___1
-and (p_simpleDef :
-  Prims.bool ->
-    (FStar_Ident.lid * FStar_Parser_AST.term) -> FStar_Pprint.document)
-  =
-  fun ps ->
-    fun uu___ ->
-      match uu___ with
-      | (lid, e) ->
-          let uu___1 =
-            let uu___2 = p_qlident lid in
-            let uu___3 =
-              let uu___4 = p_noSeqTermAndComment ps false e in
-              FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.equals uu___4 in
-            FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3 in
-          FStar_Pprint.group uu___1
-and (p_appTerm : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.App uu___ when is_general_application e ->
-        let uu___1 = head_and_args e in
-        (match uu___1 with
-         | (head, args) ->
-             (match args with
-              | e1::e2::[] when
-                  (FStar_Pervasives_Native.snd e1) = FStar_Parser_AST.Infix
-                  ->
-                  let uu___2 = p_argTerm e1 in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = str "`" in
-                        let uu___7 =
-                          let uu___8 = p_indexingTerm head in
-                          let uu___9 = str "`" in
-                          FStar_Pprint.op_Hat_Hat uu___8 uu___9 in
-                        FStar_Pprint.op_Hat_Hat uu___6 uu___7 in
-                      FStar_Pprint.group uu___5 in
-                    let uu___5 = p_argTerm e2 in
-                    FStar_Pprint.op_Hat_Slash_Hat uu___4 uu___5 in
-                  FStar_Pprint.op_Hat_Slash_Hat uu___2 uu___3
-              | uu___2 ->
-                  let uu___3 =
-                    let uu___4 = p_indexingTerm head in (uu___4, args) in
-                  (match uu___3 with
-                   | (head_doc, args1) ->
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Pprint.op_Hat_Hat head_doc
-                             FStar_Pprint.space in
-                         soft_surround_map_or_flow (Prims.of_int (2))
-                           Prims.int_zero head_doc uu___5 break1
-                           FStar_Pprint.empty p_argTerm args1 in
-                       FStar_Pprint.group uu___4)))
-    | FStar_Parser_AST.Construct (lid, args) when
-        (is_general_construction e) &&
-          (let uu___ = (is_dtuple_constructor lid) && (all1_explicit args) in
-           Prims.op_Negation uu___)
-        ->
-        (match args with
-         | [] -> p_quident lid
-         | arg::[] ->
-             let uu___ =
-               let uu___1 = p_quident lid in
-               let uu___2 = p_argTerm arg in
-               FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-             FStar_Pprint.group uu___
-         | hd::tl ->
-             let uu___ =
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 = p_quident lid in
-                   let uu___4 = p_argTerm hd in prefix2 uu___3 uu___4 in
-                 FStar_Pprint.group uu___2 in
-               let uu___2 =
-                 let uu___3 = FStar_Pprint.separate_map break1 p_argTerm tl in
-                 jump2 uu___3 in
-               FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-             FStar_Pprint.group uu___)
-    | uu___ -> p_indexingTerm e
-and (p_argTerm :
-  (FStar_Parser_AST.term * FStar_Parser_AST.imp) -> FStar_Pprint.document) =
-  fun arg_imp ->
-    match arg_imp with
-    | (u, FStar_Parser_AST.UnivApp) -> p_universe u
-    | (e, FStar_Parser_AST.FsTypApp) ->
-        (FStar_Errors.log_issue e.FStar_Parser_AST.range
-           (FStar_Errors.Warning_UnexpectedFsTypApp,
-             "Unexpected FsTypApp, output might not be formatted correctly.");
-         (let uu___1 = p_indexingTerm e in
-          FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one
-            FStar_Pprint.langle uu___1 FStar_Pprint.rangle))
-    | (e, FStar_Parser_AST.Hash) ->
-        let uu___ = str "#" in
-        let uu___1 = p_indexingTerm e in FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | (e, FStar_Parser_AST.HashBrace t) ->
-        let uu___ = str "#[" in
-        let uu___1 =
-          let uu___2 = p_indexingTerm t in
-          let uu___3 =
-            let uu___4 = str "]" in
-            let uu___5 = p_indexingTerm e in
-            FStar_Pprint.op_Hat_Hat uu___4 uu___5 in
-          FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | (e, FStar_Parser_AST.Infix) -> p_indexingTerm e
-    | (e, FStar_Parser_AST.Nothing) -> p_indexingTerm e
-and (p_indexingTerm_aux :
-  (FStar_Parser_AST.term -> FStar_Pprint.document) ->
-    FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun exit ->
-    fun e ->
-      match e.FStar_Parser_AST.tm with
-      | FStar_Parser_AST.Op (id, e1::e2::[]) when
-          let uu___ = FStar_Ident.string_of_id id in uu___ = ".()" ->
-          let uu___ =
-            let uu___1 = p_indexingTerm_aux p_atomicTermNotQUident e1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = p_term false false e2 in
-                soft_parens_with_nesting uu___4 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___3 in
-            FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-          FStar_Pprint.group uu___
-      | FStar_Parser_AST.Op (id, e1::e2::[]) when
-          let uu___ = FStar_Ident.string_of_id id in uu___ = ".[]" ->
-          let uu___ =
-            let uu___1 = p_indexingTerm_aux p_atomicTermNotQUident e1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = p_term false false e2 in
-                soft_brackets_with_nesting uu___4 in
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___3 in
-            FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-          FStar_Pprint.group uu___
-      | uu___ -> exit e
-and (p_indexingTerm : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e -> p_indexingTerm_aux p_atomicTerm e
-and (p_atomicTerm : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.LetOpen (lid, e1) ->
-        let uu___ = p_quident lid in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = p_term false false e1 in
-            soft_parens_with_nesting uu___3 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.Name lid -> p_quident lid
-    | FStar_Parser_AST.Construct (lid, []) when is_general_construction e ->
-        p_quident lid
-    | FStar_Parser_AST.Op (op, e1::[]) when is_general_prefix_op op ->
-        let uu___ = let uu___1 = FStar_Ident.string_of_id op in str uu___1 in
-        let uu___1 = p_atomicTerm e1 in FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | uu___ -> p_atomicTermNotQUident e
-and (p_atomicTermNotQUident : FStar_Parser_AST.term -> FStar_Pprint.document)
-  =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Wild -> FStar_Pprint.underscore
-    | FStar_Parser_AST.Var lid when
-        FStar_Ident.lid_equals lid FStar_Parser_Const.assert_lid ->
-        str "assert"
-    | FStar_Parser_AST.Var lid when
-        FStar_Ident.lid_equals lid FStar_Parser_Const.assume_lid ->
-        str "assume"
-    | FStar_Parser_AST.Tvar tv -> p_tvar tv
-    | FStar_Parser_AST.Const c ->
-        (match c with
-         | FStar_Const.Const_char x when x = 10 -> str "0x0Az"
-         | uu___ -> p_constant c)
-    | FStar_Parser_AST.Name lid when
-        FStar_Ident.lid_equals lid FStar_Parser_Const.true_lid -> str "True"
-    | FStar_Parser_AST.Name lid when
-        FStar_Ident.lid_equals lid FStar_Parser_Const.false_lid ->
-        str "False"
-    | FStar_Parser_AST.Op (op, e1::[]) when is_general_prefix_op op ->
-        let uu___ = let uu___1 = FStar_Ident.string_of_id op in str uu___1 in
-        let uu___1 = p_atomicTermNotQUident e1 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.Op (op, []) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Ident.string_of_id op in str uu___3 in
-            let uu___3 =
-              FStar_Pprint.op_Hat_Hat FStar_Pprint.space FStar_Pprint.rparen in
-            FStar_Pprint.op_Hat_Hat uu___2 uu___3 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.space uu___1 in
-        FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen uu___
-    | FStar_Parser_AST.Construct (lid, args) when
-        (is_dtuple_constructor lid) && (all1_explicit args) ->
-        let uu___ =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.lparen FStar_Pprint.bar in
-        let uu___1 =
-          let uu___2 = FStar_Pprint.op_Hat_Hat FStar_Pprint.comma break1 in
-          FStar_Pprint.separate_map uu___2
-            (fun uu___3 -> match uu___3 with | (e1, uu___4) -> p_tmEq e1)
-            args in
-        let uu___2 =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.bar FStar_Pprint.rparen in
-        FStar_Pprint.surround (Prims.of_int (2)) Prims.int_one uu___ uu___1
-          uu___2
-    | FStar_Parser_AST.Project (e1, lid) ->
-        let uu___ =
-          let uu___1 = p_atomicTermNotQUident e1 in
-          let uu___2 =
-            let uu___3 = p_qlident lid in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___3 in
-          FStar_Pprint.prefix (Prims.of_int (2)) Prims.int_zero uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | uu___ -> p_projectionLHS e
-and (p_projectionLHS : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    match e.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Var lid -> p_qlident lid
-    | FStar_Parser_AST.Projector (constr_lid, field_lid) ->
-        let uu___ = p_quident constr_lid in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = p_lident field_lid in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___3 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.qmark uu___2 in
-        FStar_Pprint.op_Hat_Hat uu___ uu___1
-    | FStar_Parser_AST.Discrim constr_lid ->
-        let uu___ = p_quident constr_lid in
-        FStar_Pprint.op_Hat_Hat uu___ FStar_Pprint.qmark
-    | FStar_Parser_AST.Paren e1 ->
-        let uu___ = p_term_sep false false e1 in
-        (match uu___ with
-         | (comm, t) ->
-             let doc = soft_parens_with_nesting t in
-             if comm = FStar_Pprint.empty
-             then doc
-             else
-               (let uu___2 =
-                  FStar_Pprint.op_Hat_Hat FStar_Pprint.hardline doc in
-                FStar_Pprint.op_Hat_Hat comm uu___2))
-    | uu___ when is_array e ->
-        let es = extract_from_list e in
-        let uu___1 =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.lbracket FStar_Pprint.bar in
-        let uu___2 =
-          let uu___3 = FStar_Pprint.op_Hat_Hat FStar_Pprint.semi break1 in
-          separate_map_or_flow_last uu___3
-            (fun ps -> p_noSeqTermAndComment ps false) es in
-        let uu___3 =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.bar FStar_Pprint.rbracket in
-        FStar_Pprint.surround (Prims.of_int (2)) Prims.int_zero uu___1 uu___2
-          uu___3
-    | uu___ when is_list e ->
-        let uu___1 =
-          let uu___2 = FStar_Pprint.op_Hat_Hat FStar_Pprint.semi break1 in
-          let uu___3 = extract_from_list e in
-          separate_map_or_flow_last uu___2
-            (fun ps -> p_noSeqTermAndComment ps false) uu___3 in
-        FStar_Pprint.surround (Prims.of_int (2)) Prims.int_zero
-          FStar_Pprint.lbracket uu___1 FStar_Pprint.rbracket
-    | uu___ when is_ref_set e ->
-        let es = extract_from_ref_set e in
-        let uu___1 =
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.bang FStar_Pprint.lbrace in
-        let uu___2 =
-          let uu___3 = FStar_Pprint.op_Hat_Hat FStar_Pprint.comma break1 in
-          separate_map_or_flow uu___3 p_appTerm es in
-        FStar_Pprint.surround (Prims.of_int (2)) Prims.int_zero uu___1 uu___2
-          FStar_Pprint.rbrace
-    | FStar_Parser_AST.Labeled (e1, s, b) ->
-        let uu___ = str (Prims.op_Hat "(*" (Prims.op_Hat s "*)")) in
-        let uu___1 = p_term false false e1 in
-        FStar_Pprint.op_Hat_Slash_Hat uu___ uu___1
-    | FStar_Parser_AST.Op (op, args) when
-        let uu___ = handleable_op op args in Prims.op_Negation uu___ ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_id op in
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_Util.string_of_int
-                    (FStar_Compiler_List.length args) in
-                Prims.op_Hat uu___5
-                  " arguments couldn't be handled by the pretty printer" in
-              Prims.op_Hat " with " uu___4 in
-            Prims.op_Hat uu___2 uu___3 in
-          Prims.op_Hat "Operation " uu___1 in
-        failwith uu___
-    | FStar_Parser_AST.Uvar id ->
-        failwith "Unexpected universe variable out of universe context"
-    | FStar_Parser_AST.Wild ->
-        let uu___ = p_term false false e in soft_parens_with_nesting uu___
-    | FStar_Parser_AST.Const uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Op uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Tvar uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Var uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Name uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Construct uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Abs uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.App uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Let uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.LetOpen uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.LetOpenRecord uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Seq uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Bind uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.If uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Match uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.TryWith uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Ascribed uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Record uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Project uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Product uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Sum uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.QForall uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.QExists uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Refine uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.NamedTyp uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Requires uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Ensures uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Decreases uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Attributes uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Quote uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.VQuote uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Antiquote uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.CalcProof uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.ElimExists uu___ ->
-        let uu___1 = p_term false false e in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.LexList l ->
-        let uu___ =
-          let uu___1 = str "%" in
-          let uu___2 = p_term_list false false l in
-          FStar_Pprint.op_Hat_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.WFOrder (rel, e1) -> p_dec_wf false false rel e1
-and (p_constant : FStar_Const.sconst -> FStar_Pprint.document) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Const.Const_effect -> str "Effect"
-    | FStar_Const.Const_unit -> str "()"
-    | FStar_Const.Const_bool b -> FStar_Pprint.doc_of_bool b
-    | FStar_Const.Const_real r -> str (Prims.op_Hat r "R")
-    | FStar_Const.Const_char x -> FStar_Pprint.doc_of_char x
-    | FStar_Const.Const_string (s, uu___1) ->
-        let uu___2 = str (FStar_String.escaped s) in
-        FStar_Pprint.dquotes uu___2
-    | FStar_Const.Const_int (repr, sign_width_opt) ->
-        let signedness uu___1 =
-          match uu___1 with
-          | FStar_Const.Unsigned -> str "u"
-          | FStar_Const.Signed -> FStar_Pprint.empty in
-        let width uu___1 =
-          match uu___1 with
-          | FStar_Const.Int8 -> str "y"
-          | FStar_Const.Int16 -> str "s"
-          | FStar_Const.Int32 -> str "l"
-          | FStar_Const.Int64 -> str "L" in
-        let suffix uu___1 =
-          match uu___1 with
-          | (s, w) ->
-              (match (s, w) with
-               | (uu___2, FStar_Const.Sizet) -> str "sz"
-               | uu___2 ->
-                   let uu___3 = signedness s in
-                   let uu___4 = width w in
-                   FStar_Pprint.op_Hat_Hat uu___3 uu___4) in
-        let ending = default_or_map FStar_Pprint.empty suffix sign_width_opt in
-        let uu___1 = str repr in FStar_Pprint.op_Hat_Hat uu___1 ending
-    | FStar_Const.Const_range_of -> str "range_of"
-    | FStar_Const.Const_set_range_of -> str "set_range_of"
-    | FStar_Const.Const_range r ->
-        let uu___1 = FStar_Compiler_Range.string_of_range r in str uu___1
-    | FStar_Const.Const_reify -> str "reify"
-    | FStar_Const.Const_reflect lid ->
-        let uu___1 = p_quident lid in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = str "reflect" in
-            FStar_Pprint.op_Hat_Hat FStar_Pprint.dot uu___4 in
-          FStar_Pprint.op_Hat_Hat FStar_Pprint.qmark uu___3 in
-        FStar_Pprint.op_Hat_Hat uu___1 uu___2
-and (p_universe : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun u ->
-    let uu___ = str "u#" in
-    let uu___1 = p_atomicUniverse u in FStar_Pprint.op_Hat_Hat uu___ uu___1
-and (p_universeFrom : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun u ->
-    match u.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Op (id, u1::u2::[]) when
-        let uu___ = FStar_Ident.string_of_id id in uu___ = "+" ->
-        let uu___ =
-          let uu___1 = p_universeFrom u1 in
-          let uu___2 =
-            let uu___3 = p_universeFrom u2 in
-            FStar_Pprint.op_Hat_Slash_Hat FStar_Pprint.plus uu___3 in
-          FStar_Pprint.op_Hat_Slash_Hat uu___1 uu___2 in
-        FStar_Pprint.group uu___
-    | FStar_Parser_AST.App uu___ ->
-        let uu___1 = head_and_args u in
-        (match uu___1 with
-         | (head, args) ->
-             (match head.FStar_Parser_AST.tm with
-              | FStar_Parser_AST.Var maybe_max_lid when
-                  FStar_Ident.lid_equals maybe_max_lid
-                    FStar_Parser_Const.max_lid
-                  ->
-                  let uu___2 =
-                    let uu___3 = p_qlident FStar_Parser_Const.max_lid in
-                    let uu___4 =
-                      FStar_Pprint.separate_map FStar_Pprint.space
-                        (fun uu___5 ->
-                           match uu___5 with
-                           | (u1, uu___6) -> p_atomicUniverse u1) args in
-                    op_Hat_Slash_Plus_Hat uu___3 uu___4 in
-                  FStar_Pprint.group uu___2
-              | uu___2 ->
-                  let uu___3 =
-                    let uu___4 = FStar_Parser_AST.term_to_string u in
-                    FStar_Compiler_Util.format1
-                      "Invalid term in universe context %s" uu___4 in
-                  failwith uu___3))
-    | uu___ -> p_atomicUniverse u
-and (p_atomicUniverse : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun u ->
-    match u.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Wild -> FStar_Pprint.underscore
-    | FStar_Parser_AST.Const (FStar_Const.Const_int (r, sw)) ->
-        p_constant (FStar_Const.Const_int (r, sw))
-    | FStar_Parser_AST.Uvar id ->
-        let uu___ = FStar_Ident.string_of_id id in str uu___
-    | FStar_Parser_AST.Paren u1 ->
-        let uu___ = p_universeFrom u1 in soft_parens_with_nesting uu___
-    | FStar_Parser_AST.App uu___ ->
-        let uu___1 = p_universeFrom u in soft_parens_with_nesting uu___1
-    | FStar_Parser_AST.Op (id, uu___::uu___1::[]) when
-        let uu___2 = FStar_Ident.string_of_id id in uu___2 = "+" ->
-        let uu___2 = p_universeFrom u in soft_parens_with_nesting uu___2
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Parser_AST.term_to_string u in
-          FStar_Compiler_Util.format1 "Invalid term in universe context %s"
-            uu___2 in
-        failwith uu___1
-let (term_to_document : FStar_Parser_AST.term -> FStar_Pprint.document) =
-  fun e ->
-    let old_unfold_tuples = FStar_Compiler_Effect.op_Bang unfold_tuples in
-    FStar_Compiler_Effect.op_Colon_Equals unfold_tuples false;
-    (let res = p_term false false e in
-     FStar_Compiler_Effect.op_Colon_Equals unfold_tuples old_unfold_tuples;
-     res)
-let (signature_to_document : FStar_Parser_AST.decl -> FStar_Pprint.document)
-  = fun e -> p_justSig e
-let (decl_to_document : FStar_Parser_AST.decl -> FStar_Pprint.document) =
-  fun e -> p_decl e
-let (pat_to_document : FStar_Parser_AST.pattern -> FStar_Pprint.document) =
-  fun p -> p_disjunctivePattern p
-let (binder_to_document : FStar_Parser_AST.binder -> FStar_Pprint.document) =
-  fun b -> p_binder true b
-let (modul_to_document : FStar_Parser_AST.modul -> FStar_Pprint.document) =
-  fun m ->
-    match m with
-    | FStar_Parser_AST.Module (uu___, decls) ->
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater decls
-            (FStar_Compiler_List.map decl_to_document) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          (FStar_Pprint.separate FStar_Pprint.hardline)
-    | FStar_Parser_AST.Interface (uu___, decls, uu___1) ->
-        let uu___2 =
-          FStar_Compiler_Effect.op_Bar_Greater decls
-            (FStar_Compiler_List.map decl_to_document) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___2
-          (FStar_Pprint.separate FStar_Pprint.hardline)
-let (comments_to_document :
-  (Prims.string * FStar_Compiler_Range.range) Prims.list ->
-    FStar_Pprint.document)
-  =
-  fun comments ->
-    FStar_Pprint.separate_map FStar_Pprint.hardline
-      (fun uu___ -> match uu___ with | (comment, range) -> str comment)
-      comments
-let (extract_decl_range : FStar_Parser_AST.decl -> decl_meta) =
-  fun d ->
-    let has_qs =
-      match ((d.FStar_Parser_AST.quals), (d.FStar_Parser_AST.d)) with
-      | ((FStar_Parser_AST.Assumption)::[], FStar_Parser_AST.Assume
-         (id, uu___)) -> false
-      | ([], uu___) -> false
-      | uu___ -> true in
-    {
-      r = (d.FStar_Parser_AST.drange);
-      has_qs;
-      has_attrs =
-        (Prims.op_Negation
-           (FStar_Compiler_List.isEmpty d.FStar_Parser_AST.attrs))
-    }
-let (modul_with_comments_to_document :
-  FStar_Parser_AST.modul ->
-    (Prims.string * FStar_Compiler_Range.range) Prims.list ->
-      (FStar_Pprint.document * (Prims.string * FStar_Compiler_Range.range)
-        Prims.list))
-  =
-  fun m ->
-    fun comments ->
-      let decls =
-        match m with
-        | FStar_Parser_AST.Module (uu___, decls1) -> decls1
-        | FStar_Parser_AST.Interface (uu___, decls1, uu___1) -> decls1 in
-      match decls with
-      | [] -> (FStar_Pprint.empty, comments)
-      | d::ds ->
-          let uu___ = ((d :: ds), (d.FStar_Parser_AST.drange)) in
-          (match uu___ with
-           | (decls1, first_range) ->
-               (FStar_Compiler_Effect.op_Colon_Equals comment_stack comments;
-                (let initial_comment =
-                   let uu___2 =
-                     FStar_Compiler_Range.start_of_range first_range in
-                   place_comments_until_pos Prims.int_zero Prims.int_one
-                     uu___2 dummy_meta FStar_Pprint.empty false true in
-                 let doc =
-                   separate_map_with_comments FStar_Pprint.empty
-                     FStar_Pprint.empty p_decl decls1 extract_decl_range in
-                 let comments1 = FStar_Compiler_Effect.op_Bang comment_stack in
-                 FStar_Compiler_Effect.op_Colon_Equals comment_stack [];
-                 (let uu___3 = FStar_Pprint.op_Hat_Hat initial_comment doc in
-                  (uu___3, comments1)))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Pervasives.ml b/src/ocaml-output/FStar_Pervasives.ml
deleted file mode 100644
index 3f23bf286bd..00000000000
--- a/src/ocaml-output/FStar_Pervasives.ml
+++ /dev/null
@@ -1,277 +0,0 @@
-open Prims
-type pattern = unit
-
-
-type eqtype_u = unit
-type 'p spinoff = 'p
-let id : 'a . 'a -> 'a = fun x -> x
-type ('a, 'uuuuu) trivial_pure_post = unit
-type ('uuuuu, 'uuuuu1) ambient = unit
-let normalize_term : 'uuuuu . 'uuuuu -> 'uuuuu = fun x -> x
-type 'a normalize = 'a
-type norm_step =
-  | Simpl 
-  | Weak 
-  | HNF 
-  | Primops 
-  | Delta 
-  | Zeta 
-  | ZetaFull 
-  | Iota 
-  | NBE 
-  | Reify 
-  | UnfoldOnly of Prims.string Prims.list 
-  | UnfoldFully of Prims.string Prims.list 
-  | UnfoldAttr of Prims.string Prims.list 
-  | UnfoldQual of Prims.string Prims.list 
-  | UnfoldNamespace of Prims.string Prims.list 
-  | Unmeta 
-  | Unascribe 
-let (uu___is_Simpl : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Simpl -> true | uu___ -> false
-let (uu___is_Weak : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Weak -> true | uu___ -> false
-let (uu___is_HNF : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | HNF -> true | uu___ -> false
-let (uu___is_Primops : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Primops -> true | uu___ -> false
-let (uu___is_Delta : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Delta -> true | uu___ -> false
-let (uu___is_Zeta : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Zeta -> true | uu___ -> false
-let (uu___is_ZetaFull : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | ZetaFull -> true | uu___ -> false
-let (uu___is_Iota : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Iota -> true | uu___ -> false
-let (uu___is_NBE : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | NBE -> true | uu___ -> false
-let (uu___is_Reify : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Reify -> true | uu___ -> false
-let (uu___is_UnfoldOnly : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldOnly _0 -> true | uu___ -> false
-let (__proj__UnfoldOnly__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldOnly _0 -> _0
-let (uu___is_UnfoldFully : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldFully _0 -> true | uu___ -> false
-let (__proj__UnfoldFully__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldFully _0 -> _0
-let (uu___is_UnfoldAttr : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldAttr _0 -> true | uu___ -> false
-let (__proj__UnfoldAttr__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldAttr _0 -> _0
-let (uu___is_UnfoldQual : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldQual _0 -> true | uu___ -> false
-let (__proj__UnfoldQual__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldQual _0 -> _0
-let (uu___is_UnfoldNamespace : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldNamespace _0 -> true | uu___ -> false
-let (__proj__UnfoldNamespace__item___0 :
-  norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldNamespace _0 -> _0
-let (uu___is_Unmeta : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Unmeta -> true | uu___ -> false
-let (uu___is_Unascribe : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Unascribe -> true | uu___ -> false
-let (simplify : norm_step) = Simpl
-let (weak : norm_step) = Weak
-let (hnf : norm_step) = HNF
-let (primops : norm_step) = Primops
-let (delta : norm_step) = Delta
-let (zeta : norm_step) = Zeta
-let (zeta_full : norm_step) = ZetaFull
-let (iota : norm_step) = Iota
-let (nbe : norm_step) = NBE
-let (reify_ : norm_step) = Reify
-let (delta_only : Prims.string Prims.list -> norm_step) =
-  fun s -> UnfoldOnly s
-let (delta_fully : Prims.string Prims.list -> norm_step) =
-  fun s -> UnfoldFully s
-let (delta_attr : Prims.string Prims.list -> norm_step) =
-  fun s -> UnfoldAttr s
-let (delta_qualifier : Prims.string Prims.list -> norm_step) =
-  fun s -> UnfoldAttr s
-let (delta_namespace : Prims.string Prims.list -> norm_step) =
-  fun s -> UnfoldNamespace s
-let (unmeta : norm_step) = Unmeta
-let (unascribe : norm_step) = Unascribe
-let (norm : norm_step Prims.list -> unit -> Obj.t -> Obj.t) =
-  fun uu___ -> fun uu___1 -> fun x -> x
-type ('a, 'x, 'uuuuu) pure_return = unit
-type ('a, 'b, 'wp1, 'wp2, 'uuuuu) pure_bind_wp = 'wp1
-type ('a, 'p, 'wputhen, 'wpuelse, 'uuuuu) pure_if_then_else = unit
-type ('a, 'wp, 'uuuuu) pure_ite_wp = unit
-type ('a, 'b, 'wp, 'uuuuu) pure_close_wp = unit
-type ('a, 'uuuuu) pure_null_wp = unit
-type ('p, 'uuuuu) pure_assert_wp = unit
-type ('p, 'uuuuu) pure_assume_wp = unit
-type ('a, 'pre, 'post, 'uuuuu) div_hoare_to_wp = unit
-type 'heap st_pre_h = unit
-type ('heap, 'a, 'pre) st_post_h' = unit
-type ('heap, 'a) st_post_h = unit
-type ('heap, 'a) st_wp_h = unit
-type ('heap, 'a, 'x, 'p, 'uuuuu) st_return = 'p
-type ('heap, 'a, 'b, 'wp1, 'wp2, 'p, 'h0) st_bind_wp = 'wp1
-type ('heap, 'a, 'p, 'wputhen, 'wpuelse, 'post, 'h0) st_if_then_else = unit
-type ('heap, 'a, 'wp, 'post, 'h0) st_ite_wp = unit
-type ('heap, 'a, 'wp1, 'wp2) st_stronger = unit
-type ('heap, 'a, 'b, 'wp, 'p, 'h) st_close_wp = unit
-type ('heap, 'a, 'wp) st_trivial = unit
-type 'a result =
-  | V of 'a 
-  | E of Prims.exn 
-  | Err of Prims.string 
-let uu___is_V : 'a . 'a result -> Prims.bool =
-  fun projectee -> match projectee with | V v -> true | uu___ -> false
-let __proj__V__item__v : 'a . 'a result -> 'a =
-  fun projectee -> match projectee with | V v -> v
-let uu___is_E : 'a . 'a result -> Prims.bool =
-  fun projectee -> match projectee with | E e -> true | uu___ -> false
-let __proj__E__item__e : 'a . 'a result -> Prims.exn =
-  fun projectee -> match projectee with | E e -> e
-let uu___is_Err : 'a . 'a result -> Prims.bool =
-  fun projectee -> match projectee with | Err msg -> true | uu___ -> false
-let __proj__Err__item__msg : 'a . 'a result -> Prims.string =
-  fun projectee -> match projectee with | Err msg -> msg
-type ex_pre = unit
-type ('a, 'pre) ex_post' = unit
-type 'a ex_post = unit
-type 'a ex_wp = unit
-type ('a, 'x, 'p) ex_return = 'p
-type ('a, 'b, 'wp1, 'wp2, 'p) ex_bind_wp = unit
-type ('a, 'p, 'wputhen, 'wpuelse, 'post) ex_if_then_else = unit
-type ('a, 'wp, 'post) ex_ite_wp = unit
-type ('a, 'wp1, 'wp2) ex_stronger = unit
-type ('a, 'b, 'wp, 'p) ex_close_wp = unit
-type ('a, 'wp) ex_trivial = 'wp
-type ('a, 'wp, 'p) lift_div_exn = 'wp
-type 'h all_pre_h = unit
-type ('h, 'a, 'pre) all_post_h' = unit
-type ('h, 'a) all_post_h = unit
-type ('h, 'a) all_wp_h = unit
-type ('heap, 'a, 'x, 'p, 'uuuuu) all_return = 'p
-type ('heap, 'a, 'b, 'wp1, 'wp2, 'p, 'h0) all_bind_wp = 'wp1
-type ('heap, 'a, 'p, 'wputhen, 'wpuelse, 'post, 'h0) all_if_then_else = unit
-type ('heap, 'a, 'wp, 'post, 'h0) all_ite_wp = unit
-type ('heap, 'a, 'wp1, 'wp2) all_stronger = unit
-type ('heap, 'a, 'b, 'wp, 'p, 'h) all_close_wp = unit
-type ('heap, 'a, 'wp) all_trivial = unit
-type 'uuuuu inversion = unit
-type ('a, 'b) either =
-  | Inl of 'a 
-  | Inr of 'b 
-let uu___is_Inl : 'a 'b . ('a, 'b) either -> Prims.bool =
-  fun projectee -> match projectee with | Inl v -> true | uu___ -> false
-let __proj__Inl__item__v : 'a 'b . ('a, 'b) either -> 'a =
-  fun projectee -> match projectee with | Inl v -> v
-let uu___is_Inr : 'a 'b . ('a, 'b) either -> Prims.bool =
-  fun projectee -> match projectee with | Inr v -> true | uu___ -> false
-let __proj__Inr__item__v : 'a 'b . ('a, 'b) either -> 'b =
-  fun projectee -> match projectee with | Inr v -> v
-let dfst : 'a 'b . ('a, 'b) Prims.dtuple2 -> 'a =
-  fun t -> Prims.__proj__Mkdtuple2__item___1 t
-let dsnd : 'a 'b . ('a, 'b) Prims.dtuple2 -> 'b =
-  fun t -> Prims.__proj__Mkdtuple2__item___2 t
-type ('a, 'b, 'c) dtuple3 =
-  | Mkdtuple3 of 'a * 'b * 'c 
-let uu___is_Mkdtuple3 : 'a 'b 'c . ('a, 'b, 'c) dtuple3 -> Prims.bool =
-  fun projectee -> true
-let __proj__Mkdtuple3__item___1 : 'a 'b 'c . ('a, 'b, 'c) dtuple3 -> 'a =
-  fun projectee -> match projectee with | Mkdtuple3 (_1, _2, _3) -> _1
-let __proj__Mkdtuple3__item___2 : 'a 'b 'c . ('a, 'b, 'c) dtuple3 -> 'b =
-  fun projectee -> match projectee with | Mkdtuple3 (_1, _2, _3) -> _2
-let __proj__Mkdtuple3__item___3 : 'a 'b 'c . ('a, 'b, 'c) dtuple3 -> 'c =
-  fun projectee -> match projectee with | Mkdtuple3 (_1, _2, _3) -> _3
-type ('a, 'b, 'c, 'd) dtuple4 =
-  | Mkdtuple4 of 'a * 'b * 'c * 'd 
-let uu___is_Mkdtuple4 : 'a 'b 'c 'd . ('a, 'b, 'c, 'd) dtuple4 -> Prims.bool
-  = fun projectee -> true
-let __proj__Mkdtuple4__item___1 :
-  'a 'b 'c 'd . ('a, 'b, 'c, 'd) dtuple4 -> 'a =
-  fun projectee -> match projectee with | Mkdtuple4 (_1, _2, _3, _4) -> _1
-let __proj__Mkdtuple4__item___2 :
-  'a 'b 'c 'd . ('a, 'b, 'c, 'd) dtuple4 -> 'b =
-  fun projectee -> match projectee with | Mkdtuple4 (_1, _2, _3, _4) -> _2
-let __proj__Mkdtuple4__item___3 :
-  'a 'b 'c 'd . ('a, 'b, 'c, 'd) dtuple4 -> 'c =
-  fun projectee -> match projectee with | Mkdtuple4 (_1, _2, _3, _4) -> _3
-let __proj__Mkdtuple4__item___4 :
-  'a 'b 'c 'd . ('a, 'b, 'c, 'd) dtuple4 -> 'd =
-  fun projectee -> match projectee with | Mkdtuple4 (_1, _2, _3, _4) -> _4
-let rec false_elim : 'uuuuu . unit -> 'uuuuu = fun uu___ -> false_elim ()
-type __internal_ocaml_attributes =
-  | PpxDerivingShow 
-  | PpxDerivingShowConstant of Prims.string 
-  | PpxDerivingYoJson 
-  | CInline 
-  | Substitute 
-  | Gc 
-  | Comment of Prims.string 
-  | CPrologue of Prims.string 
-  | CEpilogue of Prims.string 
-  | CConst of Prims.string 
-  | CCConv of Prims.string 
-  | CAbstractStruct 
-  | CIfDef 
-  | CMacro 
-let (uu___is_PpxDerivingShow : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PpxDerivingShow -> true | uu___ -> false
-let (uu___is_PpxDerivingShowConstant :
-  __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | PpxDerivingShowConstant _0 -> true
-    | uu___ -> false
-let (__proj__PpxDerivingShowConstant__item___0 :
-  __internal_ocaml_attributes -> Prims.string) =
-  fun projectee -> match projectee with | PpxDerivingShowConstant _0 -> _0
-let (uu___is_PpxDerivingYoJson : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PpxDerivingYoJson -> true | uu___ -> false
-let (uu___is_CInline : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | CInline -> true | uu___ -> false
-let (uu___is_Substitute : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | Substitute -> true | uu___ -> false
-let (uu___is_Gc : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | Gc -> true | uu___ -> false
-let (uu___is_Comment : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | Comment _0 -> true | uu___ -> false
-let (__proj__Comment__item___0 : __internal_ocaml_attributes -> Prims.string)
-  = fun projectee -> match projectee with | Comment _0 -> _0
-let (uu___is_CPrologue : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CPrologue _0 -> true | uu___ -> false
-let (__proj__CPrologue__item___0 :
-  __internal_ocaml_attributes -> Prims.string) =
-  fun projectee -> match projectee with | CPrologue _0 -> _0
-let (uu___is_CEpilogue : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CEpilogue _0 -> true | uu___ -> false
-let (__proj__CEpilogue__item___0 :
-  __internal_ocaml_attributes -> Prims.string) =
-  fun projectee -> match projectee with | CEpilogue _0 -> _0
-let (uu___is_CConst : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | CConst _0 -> true | uu___ -> false
-let (__proj__CConst__item___0 : __internal_ocaml_attributes -> Prims.string)
-  = fun projectee -> match projectee with | CConst _0 -> _0
-let (uu___is_CCConv : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | CCConv _0 -> true | uu___ -> false
-let (__proj__CCConv__item___0 : __internal_ocaml_attributes -> Prims.string)
-  = fun projectee -> match projectee with | CCConv _0 -> _0
-let (uu___is_CAbstractStruct : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CAbstractStruct -> true | uu___ -> false
-let (uu___is_CIfDef : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | CIfDef -> true | uu___ -> false
-let (uu___is_CMacro : __internal_ocaml_attributes -> Prims.bool) =
-  fun projectee -> match projectee with | CMacro -> true | uu___ -> false
-let singleton : 'uuuuu . 'uuuuu -> 'uuuuu = fun x -> x
-let with_type : 'uuuuu . 'uuuuu -> 'uuuuu = fun e -> e
-type 'a eqtype_as_type = 'a
-let coerce_eq : 'a 'b . unit -> 'a -> 'b =
-  fun uu___1 -> fun uu___ -> (fun uu___ -> fun x -> Obj.magic x) uu___1 uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Prettyprint.ml b/src/ocaml-output/FStar_Prettyprint.ml
deleted file mode 100644
index bd9491081ca..00000000000
--- a/src/ocaml-output/FStar_Prettyprint.ml
+++ /dev/null
@@ -1,90 +0,0 @@
-open Prims
-type printing_mode =
-  | ToTempFile 
-  | FromTempToStdout 
-  | FromTempToFile 
-let (uu___is_ToTempFile : printing_mode -> Prims.bool) =
-  fun projectee -> match projectee with | ToTempFile -> true | uu___ -> false
-let (uu___is_FromTempToStdout : printing_mode -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FromTempToStdout -> true | uu___ -> false
-let (uu___is_FromTempToFile : printing_mode -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FromTempToFile -> true | uu___ -> false
-let (temp_file_name : Prims.string -> Prims.string) =
-  fun f -> FStar_Compiler_Util.format1 "%s.print_.fst" f
-let (generate : printing_mode -> Prims.string Prims.list -> unit) =
-  fun m ->
-    fun filenames ->
-      let parse_and_prettyprint m1 filename =
-        let uu___ = FStar_Parser_Driver.parse_file filename in
-        match uu___ with
-        | (modul, comments) ->
-            let outf =
-              match m1 with
-              | FromTempToStdout -> FStar_Pervasives_Native.None
-              | FromTempToFile ->
-                  let outf1 =
-                    FStar_Compiler_Util.open_file_for_writing filename in
-                  FStar_Pervasives_Native.Some outf1
-              | ToTempFile ->
-                  let outf1 =
-                    let uu___1 = temp_file_name filename in
-                    FStar_Compiler_Util.open_file_for_writing uu___1 in
-                  FStar_Pervasives_Native.Some outf1 in
-            let leftover_comments =
-              let comments1 = FStar_Compiler_List.rev comments in
-              let uu___1 =
-                FStar_Parser_ToDocument.modul_with_comments_to_document modul
-                  comments1 in
-              match uu___1 with
-              | (doc, comments2) ->
-                  ((match outf with
-                    | FStar_Pervasives_Native.Some f ->
-                        let uu___3 =
-                          FStar_Pprint.pretty_string
-                            (FStar_Compiler_Util.float_of_string "1.0")
-                            (Prims.of_int (100)) doc in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_Compiler_Util.append_to_file f) uu___3
-                    | FStar_Pervasives_Native.None ->
-                        FStar_Pprint.pretty_out_channel
-                          (FStar_Compiler_Util.float_of_string "1.0")
-                          (Prims.of_int (100)) doc FStar_Compiler_Util.stdout);
-                   comments2) in
-            let left_over_doc =
-              if
-                Prims.op_Negation
-                  (FStar_Compiler_List.isEmpty leftover_comments)
-              then
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Parser_ToDocument.comments_to_document
-                          leftover_comments in
-                      [uu___4] in
-                    FStar_Pprint.hardline :: uu___3 in
-                  FStar_Pprint.hardline :: uu___2 in
-                FStar_Pprint.concat uu___1
-              else
-                if m1 = FromTempToStdout
-                then
-                  FStar_Pprint.concat
-                    [FStar_Pprint.hardline; FStar_Pprint.hardline]
-                else FStar_Pprint.empty in
-            (match outf with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Pprint.pretty_out_channel
-                   (FStar_Compiler_Util.float_of_string "1.0")
-                   (Prims.of_int (100)) left_over_doc
-                   FStar_Compiler_Util.stdout
-             | FStar_Pervasives_Native.Some outf1 ->
-                 ((let uu___2 =
-                     FStar_Pprint.pretty_string
-                       (FStar_Compiler_Util.float_of_string "1.0")
-                       (Prims.of_int (100)) left_over_doc in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Compiler_Util.append_to_file outf1) uu___2);
-                  FStar_Compiler_Util.close_file outf1)) in
-      FStar_Compiler_List.iter (parse_and_prettyprint m) filenames
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Profiling.ml b/src/ocaml-output/FStar_Profiling.ml
deleted file mode 100644
index 6ed548cdc93..00000000000
--- a/src/ocaml-output/FStar_Profiling.ml
+++ /dev/null
@@ -1,111 +0,0 @@
-open Prims
-type counter =
-  {
-  cid: Prims.string ;
-  total_time: Prims.int FStar_Compiler_Effect.ref ;
-  running: Prims.bool FStar_Compiler_Effect.ref ;
-  undercount: Prims.bool FStar_Compiler_Effect.ref }
-let (__proj__Mkcounter__item__cid : counter -> Prims.string) =
-  fun projectee ->
-    match projectee with | { cid; total_time; running; undercount;_} -> cid
-let (__proj__Mkcounter__item__total_time :
-  counter -> Prims.int FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with
-    | { cid; total_time; running; undercount;_} -> total_time
-let (__proj__Mkcounter__item__running :
-  counter -> Prims.bool FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with
-    | { cid; total_time; running; undercount;_} -> running
-let (__proj__Mkcounter__item__undercount :
-  counter -> Prims.bool FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with
-    | { cid; total_time; running; undercount;_} -> undercount
-let (new_counter : Prims.string -> counter) =
-  fun cid ->
-    let uu___ = FStar_Compiler_Util.mk_ref Prims.int_zero in
-    let uu___1 = FStar_Compiler_Util.mk_ref false in
-    let uu___2 = FStar_Compiler_Util.mk_ref false in
-    { cid; total_time = uu___; running = uu___1; undercount = uu___2 }
-let (all_counters : counter FStar_Compiler_Util.smap) =
-  FStar_Compiler_Util.smap_create (Prims.of_int (20))
-let (create_or_lookup_counter : Prims.string -> counter) =
-  fun cid ->
-    let uu___ = FStar_Compiler_Util.smap_try_find all_counters cid in
-    match uu___ with
-    | FStar_Pervasives_Native.Some c -> c
-    | FStar_Pervasives_Native.None ->
-        let c = new_counter cid in
-        (FStar_Compiler_Util.smap_add all_counters cid c; c)
-let profile :
-  'a .
-    (unit -> 'a) ->
-      Prims.string FStar_Pervasives_Native.option -> Prims.string -> 'a
-  =
-  fun f ->
-    fun module_name ->
-      fun cid ->
-        let uu___ = FStar_Options.profile_enabled module_name cid in
-        if uu___
-        then
-          let c = create_or_lookup_counter cid in
-          let uu___1 = FStar_Compiler_Effect.op_Bang c.running in
-          (if uu___1
-           then f ()
-           else
-             (try
-                (fun uu___3 ->
-                   match () with
-                   | () ->
-                       (FStar_Compiler_Effect.op_Colon_Equals c.running true;
-                        (let uu___5 = FStar_Compiler_Util.record_time f in
-                         match uu___5 with
-                         | (res, elapsed) ->
-                             ((let uu___7 =
-                                 let uu___8 =
-                                   FStar_Compiler_Effect.op_Bang c.total_time in
-                                 uu___8 + elapsed in
-                               FStar_Compiler_Effect.op_Colon_Equals
-                                 c.total_time uu___7);
-                              FStar_Compiler_Effect.op_Colon_Equals c.running
-                                false;
-                              res)))) ()
-              with
-              | uu___3 ->
-                  (FStar_Compiler_Effect.op_Colon_Equals c.running false;
-                   FStar_Compiler_Effect.op_Colon_Equals c.undercount true;
-                   FStar_Compiler_Effect.raise uu___3)))
-        else f ()
-let (report_and_clear : Prims.string -> unit) =
-  fun tag ->
-    let ctrs =
-      FStar_Compiler_Util.smap_fold all_counters
-        (fun uu___ -> fun v -> fun l -> v :: l) [] in
-    FStar_Compiler_Util.smap_clear all_counters;
-    (let ctrs1 =
-       FStar_Compiler_Util.sort_with
-         (fun c1 ->
-            fun c2 ->
-              let uu___1 = FStar_Compiler_Effect.op_Bang c2.total_time in
-              let uu___2 = FStar_Compiler_Effect.op_Bang c1.total_time in
-              uu___1 - uu___2) ctrs in
-     FStar_Compiler_Effect.op_Bar_Greater ctrs1
-       (FStar_Compiler_List.iter
-          (fun c ->
-             let warn =
-               let uu___1 = FStar_Compiler_Effect.op_Bang c.running in
-               if uu___1
-               then " (Warning, this counter is still running)"
-               else
-                 (let uu___3 = FStar_Compiler_Effect.op_Bang c.undercount in
-                  if uu___3
-                  then
-                    " (Warning, some operations raised exceptions and we not accounted for)"
-                  else "") in
-             let uu___1 =
-               let uu___2 = FStar_Compiler_Effect.op_Bang c.total_time in
-               FStar_Compiler_Util.string_of_int uu___2 in
-             FStar_Compiler_Util.print4 "%s, profiled %s:\t %s ms%s\n" tag
-               c.cid uu___1 warn)))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Reflection_Basic.ml b/src/ocaml-output/FStar_Reflection_Basic.ml
deleted file mode 100644
index b6ec552a431..00000000000
--- a/src/ocaml-output/FStar_Reflection_Basic.ml
+++ /dev/null
@@ -1,1293 +0,0 @@
-open Prims
-let (get_env : unit -> FStar_TypeChecker_Env.env) =
-  fun uu___ ->
-    let uu___1 =
-      FStar_Compiler_Effect.op_Bang
-        FStar_TypeChecker_Normalize.reflection_env_hook in
-    match uu___1 with
-    | FStar_Pervasives_Native.None ->
-        failwith "impossible: env_hook unset in reflection"
-    | FStar_Pervasives_Native.Some e -> e
-let (inspect_bqual :
-  FStar_Syntax_Syntax.bqual -> FStar_Reflection_Data.aqualv) =
-  fun bq ->
-    match bq with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit uu___) ->
-        FStar_Reflection_Data.Q_Implicit
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-        FStar_Reflection_Data.Q_Meta t
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality) ->
-        FStar_Reflection_Data.Q_Explicit
-    | FStar_Pervasives_Native.None -> FStar_Reflection_Data.Q_Explicit
-let (inspect_aqual :
-  FStar_Syntax_Syntax.aqual -> FStar_Reflection_Data.aqualv) =
-  fun aq ->
-    match aq with
-    | FStar_Pervasives_Native.Some
-        { FStar_Syntax_Syntax.aqual_implicit = true;
-          FStar_Syntax_Syntax.aqual_attributes = uu___;_}
-        -> FStar_Reflection_Data.Q_Implicit
-    | uu___ -> FStar_Reflection_Data.Q_Explicit
-let (pack_bqual : FStar_Reflection_Data.aqualv -> FStar_Syntax_Syntax.bqual)
-  =
-  fun aqv ->
-    match aqv with
-    | FStar_Reflection_Data.Q_Explicit -> FStar_Pervasives_Native.None
-    | FStar_Reflection_Data.Q_Implicit ->
-        FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit false)
-    | FStar_Reflection_Data.Q_Meta t ->
-        FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t)
-let (pack_aqual : FStar_Reflection_Data.aqualv -> FStar_Syntax_Syntax.aqual)
-  =
-  fun aqv ->
-    match aqv with
-    | FStar_Reflection_Data.Q_Implicit ->
-        FStar_Syntax_Syntax.as_aqual_implicit true
-    | uu___ -> FStar_Pervasives_Native.None
-let (inspect_fv : FStar_Syntax_Syntax.fv -> Prims.string Prims.list) =
-  fun fv ->
-    let uu___ = FStar_Syntax_Syntax.lid_of_fv fv in
-    FStar_Ident.path_of_lid uu___
-let (pack_fv : Prims.string Prims.list -> FStar_Syntax_Syntax.fv) =
-  fun ns ->
-    let lid = FStar_Parser_Const.p2l ns in
-    let fallback uu___ =
-      let quals =
-        let uu___1 = FStar_Ident.lid_equals lid FStar_Parser_Const.cons_lid in
-        if uu___1
-        then FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor
-        else
-          (let uu___3 = FStar_Ident.lid_equals lid FStar_Parser_Const.nil_lid in
-           if uu___3
-           then FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor
-           else
-             (let uu___5 =
-                FStar_Ident.lid_equals lid FStar_Parser_Const.some_lid in
-              if uu___5
-              then FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor
-              else
-                (let uu___7 =
-                   FStar_Ident.lid_equals lid FStar_Parser_Const.none_lid in
-                 if uu___7
-                 then
-                   FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor
-                 else FStar_Pervasives_Native.None))) in
-      let uu___1 = FStar_Parser_Const.p2l ns in
-      FStar_Syntax_Syntax.lid_as_fv uu___1
-        (FStar_Syntax_Syntax.Delta_constant_at_level (Prims.of_int (999)))
-        quals in
-    let uu___ =
-      FStar_Compiler_Effect.op_Bang
-        FStar_TypeChecker_Normalize.reflection_env_hook in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> fallback ()
-    | FStar_Pervasives_Native.Some env ->
-        let qninfo = FStar_TypeChecker_Env.lookup_qname env lid in
-        (match qninfo with
-         | FStar_Pervasives_Native.Some
-             (FStar_Pervasives.Inr (se, _us), _rng) ->
-             let quals = FStar_Syntax_DsEnv.fv_qual_of_se se in
-             let uu___1 = FStar_Parser_Const.p2l ns in
-             FStar_Syntax_Syntax.lid_as_fv uu___1
-               (FStar_Syntax_Syntax.Delta_constant_at_level
-                  (Prims.of_int (999))) quals
-         | uu___1 -> fallback ())
-let rec last : 'a . 'a Prims.list -> 'a =
-  fun l ->
-    match l with
-    | [] -> failwith "last: empty list"
-    | x::[] -> x
-    | uu___::xs -> last xs
-let rec init : 'a . 'a Prims.list -> 'a Prims.list =
-  fun l ->
-    match l with
-    | [] -> failwith "init: empty list"
-    | x::[] -> []
-    | x::xs -> let uu___ = init xs in x :: uu___
-let (inspect_const :
-  FStar_Syntax_Syntax.sconst -> FStar_Reflection_Data.vconst) =
-  fun c ->
-    match c with
-    | FStar_Const.Const_unit -> FStar_Reflection_Data.C_Unit
-    | FStar_Const.Const_int (s, uu___) ->
-        let uu___1 = FStar_BigInt.big_int_of_string s in
-        FStar_Reflection_Data.C_Int uu___1
-    | FStar_Const.Const_bool (true) -> FStar_Reflection_Data.C_True
-    | FStar_Const.Const_bool (false) -> FStar_Reflection_Data.C_False
-    | FStar_Const.Const_string (s, uu___) -> FStar_Reflection_Data.C_String s
-    | FStar_Const.Const_range r -> FStar_Reflection_Data.C_Range r
-    | FStar_Const.Const_reify -> FStar_Reflection_Data.C_Reify
-    | FStar_Const.Const_reflect l ->
-        let uu___ = FStar_Ident.path_of_lid l in
-        FStar_Reflection_Data.C_Reflect uu___
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Print.const_to_string c in
-          FStar_Compiler_Util.format1 "unknown constant: %s" uu___2 in
-        failwith uu___1
-let (inspect_universe :
-  FStar_Syntax_Syntax.universe -> FStar_Reflection_Data.universe_view) =
-  fun u ->
-    match u with
-    | FStar_Syntax_Syntax.U_zero -> FStar_Reflection_Data.Uv_Zero
-    | FStar_Syntax_Syntax.U_succ u1 -> FStar_Reflection_Data.Uv_Succ u1
-    | FStar_Syntax_Syntax.U_max us -> FStar_Reflection_Data.Uv_Max us
-    | FStar_Syntax_Syntax.U_bvar n ->
-        let uu___ = FStar_BigInt.of_int_fs n in
-        FStar_Reflection_Data.Uv_BVar uu___
-    | FStar_Syntax_Syntax.U_name i ->
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_id i in
-          let uu___2 = FStar_Ident.range_of_id i in (uu___1, uu___2) in
-        FStar_Reflection_Data.Uv_Name uu___
-    | FStar_Syntax_Syntax.U_unif u1 -> FStar_Reflection_Data.Uv_Unif u1
-    | FStar_Syntax_Syntax.U_unknown -> FStar_Reflection_Data.Uv_Unk
-let (pack_universe :
-  FStar_Reflection_Data.universe_view -> FStar_Syntax_Syntax.universe) =
-  fun uv ->
-    match uv with
-    | FStar_Reflection_Data.Uv_Zero -> FStar_Syntax_Syntax.U_zero
-    | FStar_Reflection_Data.Uv_Succ u -> FStar_Syntax_Syntax.U_succ u
-    | FStar_Reflection_Data.Uv_Max us -> FStar_Syntax_Syntax.U_max us
-    | FStar_Reflection_Data.Uv_BVar n ->
-        let uu___ = FStar_BigInt.to_int_fs n in
-        FStar_Syntax_Syntax.U_bvar uu___
-    | FStar_Reflection_Data.Uv_Name i ->
-        let uu___ = FStar_Ident.mk_ident i in
-        FStar_Syntax_Syntax.U_name uu___
-    | FStar_Reflection_Data.Uv_Unif u -> FStar_Syntax_Syntax.U_unif u
-    | FStar_Reflection_Data.Uv_Unk -> FStar_Syntax_Syntax.U_unknown
-let rec (inspect_ln :
-  FStar_Syntax_Syntax.term -> FStar_Reflection_Data.term_view) =
-  fun t ->
-    let t1 = FStar_Syntax_Util.unlazy_emb t in
-    let t2 = FStar_Syntax_Subst.compress t1 in
-    match t2.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_meta (t3, uu___) -> inspect_ln t3
-    | FStar_Syntax_Syntax.Tm_name bv -> FStar_Reflection_Data.Tv_Var bv
-    | FStar_Syntax_Syntax.Tm_bvar bv -> FStar_Reflection_Data.Tv_BVar bv
-    | FStar_Syntax_Syntax.Tm_fvar fv -> FStar_Reflection_Data.Tv_FVar fv
-    | FStar_Syntax_Syntax.Tm_uinst (t3, us) ->
-        let t4 =
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater t3
-                FStar_Syntax_Subst.compress in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              FStar_Syntax_Util.unascribe in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Syntax_Util.unlazy_emb in
-        (match t4.FStar_Syntax_Syntax.n with
-         | FStar_Syntax_Syntax.Tm_fvar fv ->
-             FStar_Reflection_Data.Tv_UInst (fv, us)
-         | uu___ ->
-             failwith "Reflection::inspect_ln: uinst for a non-fvar node")
-    | FStar_Syntax_Syntax.Tm_ascribed
-        (t3, (FStar_Pervasives.Inl ty, tacopt, eq), _elid) ->
-        FStar_Reflection_Data.Tv_AscribedT (t3, ty, tacopt, eq)
-    | FStar_Syntax_Syntax.Tm_ascribed
-        (t3, (FStar_Pervasives.Inr cty, tacopt, eq), elid) ->
-        FStar_Reflection_Data.Tv_AscribedC (t3, cty, tacopt, eq)
-    | FStar_Syntax_Syntax.Tm_app (hd, []) ->
-        failwith "inspect_ln: empty arguments on Tm_app"
-    | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-        let uu___ = last args in
-        (match uu___ with
-         | (a, q) ->
-             let q' = inspect_aqual q in
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 = init args in FStar_Syntax_Util.mk_app hd uu___3 in
-               (uu___2, (a, q')) in
-             FStar_Reflection_Data.Tv_App uu___1)
-    | FStar_Syntax_Syntax.Tm_abs ([], uu___, uu___1) ->
-        failwith "inspect_ln: empty arguments on Tm_abs"
-    | FStar_Syntax_Syntax.Tm_abs (b::bs, t3, k) ->
-        let body =
-          match bs with
-          | [] -> t3
-          | bs1 ->
-              FStar_Syntax_Syntax.mk
-                (FStar_Syntax_Syntax.Tm_abs (bs1, t3, k))
-                t3.FStar_Syntax_Syntax.pos in
-        FStar_Reflection_Data.Tv_Abs (b, body)
-    | FStar_Syntax_Syntax.Tm_type u -> FStar_Reflection_Data.Tv_Type u
-    | FStar_Syntax_Syntax.Tm_arrow ([], k) ->
-        failwith "inspect_ln: empty binders on arrow"
-    | FStar_Syntax_Syntax.Tm_arrow uu___ ->
-        let uu___1 = FStar_Syntax_Util.arrow_one_ln t2 in
-        (match uu___1 with
-         | FStar_Pervasives_Native.Some (b, c) ->
-             FStar_Reflection_Data.Tv_Arrow (b, c)
-         | FStar_Pervasives_Native.None -> failwith "impossible")
-    | FStar_Syntax_Syntax.Tm_refine (bv, t3) ->
-        FStar_Reflection_Data.Tv_Refine (bv, t3)
-    | FStar_Syntax_Syntax.Tm_constant c ->
-        let uu___ = inspect_const c in FStar_Reflection_Data.Tv_Const uu___
-    | FStar_Syntax_Syntax.Tm_uvar (ctx_u, s) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Syntax_Unionfind.uvar_id
-                ctx_u.FStar_Syntax_Syntax.ctx_uvar_head in
-            FStar_BigInt.of_int_fs uu___2 in
-          (uu___1, (ctx_u, s)) in
-        FStar_Reflection_Data.Tv_Uvar uu___
-    | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), t21) ->
-        if lb.FStar_Syntax_Syntax.lbunivs <> []
-        then FStar_Reflection_Data.Tv_Unknown
-        else
-          (match lb.FStar_Syntax_Syntax.lbname with
-           | FStar_Pervasives.Inr uu___1 -> FStar_Reflection_Data.Tv_Unknown
-           | FStar_Pervasives.Inl bv ->
-               FStar_Reflection_Data.Tv_Let
-                 (false, (lb.FStar_Syntax_Syntax.lbattrs), bv,
-                   (lb.FStar_Syntax_Syntax.lbdef), t21))
-    | FStar_Syntax_Syntax.Tm_let ((true, lb::[]), t21) ->
-        if lb.FStar_Syntax_Syntax.lbunivs <> []
-        then FStar_Reflection_Data.Tv_Unknown
-        else
-          (match lb.FStar_Syntax_Syntax.lbname with
-           | FStar_Pervasives.Inr uu___1 -> FStar_Reflection_Data.Tv_Unknown
-           | FStar_Pervasives.Inl bv ->
-               FStar_Reflection_Data.Tv_Let
-                 (true, (lb.FStar_Syntax_Syntax.lbattrs), bv,
-                   (lb.FStar_Syntax_Syntax.lbdef), t21))
-    | FStar_Syntax_Syntax.Tm_match (t3, ret_opt, brs, uu___) ->
-        let rec inspect_pat p =
-          match p.FStar_Syntax_Syntax.v with
-          | FStar_Syntax_Syntax.Pat_constant c ->
-              let uu___1 = inspect_const c in
-              FStar_Reflection_Data.Pat_Constant uu___1
-          | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, ps) ->
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_List.map
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | (p1, b) ->
-                           let uu___4 = inspect_pat p1 in (uu___4, b)) ps in
-                (fv, us_opt, uu___2) in
-              FStar_Reflection_Data.Pat_Cons uu___1
-          | FStar_Syntax_Syntax.Pat_var bv ->
-              FStar_Reflection_Data.Pat_Var bv
-          | FStar_Syntax_Syntax.Pat_wild bv ->
-              FStar_Reflection_Data.Pat_Wild bv
-          | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-              FStar_Reflection_Data.Pat_Dot_Term eopt in
-        let brs1 =
-          FStar_Compiler_List.map
-            (fun uu___1 ->
-               match uu___1 with
-               | (pat, uu___2, t4) ->
-                   let uu___3 = inspect_pat pat in (uu___3, t4)) brs in
-        FStar_Reflection_Data.Tv_Match (t3, ret_opt, brs1)
-    | FStar_Syntax_Syntax.Tm_unknown -> FStar_Reflection_Data.Tv_Unknown
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Syntax_Print.tag_of_term t2 in
-              let uu___5 = FStar_Syntax_Print.term_to_string t2 in
-              FStar_Compiler_Util.format2
-                "inspect_ln: outside of expected syntax (%s, %s)\n" uu___4
-                uu___5 in
-            (FStar_Errors.Warning_CantInspect, uu___3) in
-          FStar_Errors.log_issue t2.FStar_Syntax_Syntax.pos uu___2);
-         FStar_Reflection_Data.Tv_Unknown)
-let (inspect_comp :
-  FStar_Syntax_Syntax.comp -> FStar_Reflection_Data.comp_view) =
-  fun c ->
-    let get_dec flags =
-      let uu___ =
-        FStar_Compiler_List.tryFind
-          (fun uu___1 ->
-             match uu___1 with
-             | FStar_Syntax_Syntax.DECREASES uu___2 -> true
-             | uu___2 -> false) flags in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> []
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.DECREASES
-          (FStar_Syntax_Syntax.Decreases_lex ts)) -> ts
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.DECREASES
-          (FStar_Syntax_Syntax.Decreases_wf uu___1)) ->
-          ((let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.comp_to_string c in
-                FStar_Compiler_Util.format1
-                  "inspect_comp: inspecting comp with wf decreases clause is not yet supported: %s skipping the decreases clause"
-                  uu___5 in
-              (FStar_Errors.Warning_CantInspect, uu___4) in
-            FStar_Errors.log_issue c.FStar_Syntax_Syntax.pos uu___3);
-           [])
-      | uu___1 -> failwith "Impossible!" in
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t -> FStar_Reflection_Data.C_Total t
-    | FStar_Syntax_Syntax.GTotal t -> FStar_Reflection_Data.C_GTotal t
-    | FStar_Syntax_Syntax.Comp ct ->
-        let uopt =
-          if
-            (FStar_Compiler_List.length ct.FStar_Syntax_Syntax.comp_univs) =
-              Prims.int_zero
-          then FStar_Syntax_Syntax.U_unknown
-          else
-            FStar_Compiler_Effect.op_Bar_Greater
-              ct.FStar_Syntax_Syntax.comp_univs FStar_Compiler_List.hd in
-        let uu___ =
-          FStar_Ident.lid_equals ct.FStar_Syntax_Syntax.effect_name
-            FStar_Parser_Const.effect_Lemma_lid in
-        if uu___
-        then
-          (match ct.FStar_Syntax_Syntax.effect_args with
-           | (pre, uu___1)::(post, uu___2)::(pats, uu___3)::uu___4 ->
-               FStar_Reflection_Data.C_Lemma (pre, post, pats)
-           | uu___1 ->
-               failwith "inspect_comp: Lemma does not have enough arguments?")
-        else
-          (let inspect_arg uu___2 =
-             match uu___2 with
-             | (a, q) -> let uu___3 = inspect_aqual q in (a, uu___3) in
-           let uu___2 =
-             let uu___3 =
-               FStar_Ident.path_of_lid ct.FStar_Syntax_Syntax.effect_name in
-             let uu___4 =
-               FStar_Compiler_List.map inspect_arg
-                 ct.FStar_Syntax_Syntax.effect_args in
-             let uu___5 = get_dec ct.FStar_Syntax_Syntax.flags in
-             ((ct.FStar_Syntax_Syntax.comp_univs), uu___3,
-               (ct.FStar_Syntax_Syntax.result_typ), uu___4, uu___5) in
-           FStar_Reflection_Data.C_Eff uu___2)
-let (pack_comp : FStar_Reflection_Data.comp_view -> FStar_Syntax_Syntax.comp)
-  =
-  fun cv ->
-    let urefl_to_univs u =
-      if u = FStar_Syntax_Syntax.U_unknown then [] else [u] in
-    let urefl_to_univ_opt u =
-      if u = FStar_Syntax_Syntax.U_unknown
-      then FStar_Pervasives_Native.None
-      else FStar_Pervasives_Native.Some u in
-    match cv with
-    | FStar_Reflection_Data.C_Total t -> FStar_Syntax_Syntax.mk_Total t
-    | FStar_Reflection_Data.C_GTotal t -> FStar_Syntax_Syntax.mk_GTotal t
-    | FStar_Reflection_Data.C_Lemma (pre, post, pats) ->
-        let ct =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.as_arg pre in
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.as_arg post in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg pats in [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          {
-            FStar_Syntax_Syntax.comp_univs = [];
-            FStar_Syntax_Syntax.effect_name =
-              FStar_Parser_Const.effect_Lemma_lid;
-            FStar_Syntax_Syntax.result_typ = FStar_Syntax_Syntax.t_unit;
-            FStar_Syntax_Syntax.effect_args = uu___;
-            FStar_Syntax_Syntax.flags = []
-          } in
-        FStar_Syntax_Syntax.mk_Comp ct
-    | FStar_Reflection_Data.C_Eff (us, ef, res, args, decrs) ->
-        let pack_arg uu___ =
-          match uu___ with
-          | (a, q) -> let uu___1 = pack_aqual q in (a, uu___1) in
-        let flags =
-          if (FStar_Compiler_List.length decrs) = Prims.int_zero
-          then []
-          else
-            [FStar_Syntax_Syntax.DECREASES
-               (FStar_Syntax_Syntax.Decreases_lex decrs)] in
-        let ct =
-          let uu___ =
-            FStar_Ident.lid_of_path ef FStar_Compiler_Range.dummyRange in
-          let uu___1 = FStar_Compiler_List.map pack_arg args in
-          {
-            FStar_Syntax_Syntax.comp_univs = us;
-            FStar_Syntax_Syntax.effect_name = uu___;
-            FStar_Syntax_Syntax.result_typ = res;
-            FStar_Syntax_Syntax.effect_args = uu___1;
-            FStar_Syntax_Syntax.flags = flags
-          } in
-        FStar_Syntax_Syntax.mk_Comp ct
-let (pack_const : FStar_Reflection_Data.vconst -> FStar_Syntax_Syntax.sconst)
-  =
-  fun c ->
-    match c with
-    | FStar_Reflection_Data.C_Unit -> FStar_Const.Const_unit
-    | FStar_Reflection_Data.C_Int i ->
-        let uu___ =
-          let uu___1 = FStar_BigInt.string_of_big_int i in
-          (uu___1, FStar_Pervasives_Native.None) in
-        FStar_Const.Const_int uu___
-    | FStar_Reflection_Data.C_True -> FStar_Const.Const_bool true
-    | FStar_Reflection_Data.C_False -> FStar_Const.Const_bool false
-    | FStar_Reflection_Data.C_String s ->
-        FStar_Const.Const_string (s, FStar_Compiler_Range.dummyRange)
-    | FStar_Reflection_Data.C_Range r -> FStar_Const.Const_range r
-    | FStar_Reflection_Data.C_Reify -> FStar_Const.Const_reify
-    | FStar_Reflection_Data.C_Reflect ns ->
-        let uu___ =
-          FStar_Ident.lid_of_path ns FStar_Compiler_Range.dummyRange in
-        FStar_Const.Const_reflect uu___
-let (pack_ln : FStar_Reflection_Data.term_view -> FStar_Syntax_Syntax.term) =
-  fun tv ->
-    match tv with
-    | FStar_Reflection_Data.Tv_Var bv -> FStar_Syntax_Syntax.bv_to_name bv
-    | FStar_Reflection_Data.Tv_BVar bv -> FStar_Syntax_Syntax.bv_to_tm bv
-    | FStar_Reflection_Data.Tv_FVar fv -> FStar_Syntax_Syntax.fv_to_tm fv
-    | FStar_Reflection_Data.Tv_UInst (fv, us) ->
-        let uu___ = FStar_Syntax_Syntax.fv_to_tm fv in
-        FStar_Syntax_Syntax.mk_Tm_uinst uu___ us
-    | FStar_Reflection_Data.Tv_App (l, (r, q)) ->
-        let q' = pack_aqual q in FStar_Syntax_Util.mk_app l [(r, q')]
-    | FStar_Reflection_Data.Tv_Abs (b, t) ->
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_abs ([b], t, FStar_Pervasives_Native.None))
-          t.FStar_Syntax_Syntax.pos
-    | FStar_Reflection_Data.Tv_Arrow (b, c) ->
-        FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_arrow ([b], c))
-          c.FStar_Syntax_Syntax.pos
-    | FStar_Reflection_Data.Tv_Type u ->
-        FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-          FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_Refine (bv, t) ->
-        FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_refine (bv, t))
-          t.FStar_Syntax_Syntax.pos
-    | FStar_Reflection_Data.Tv_Const c ->
-        let uu___ =
-          let uu___1 = pack_const c in FStar_Syntax_Syntax.Tm_constant uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_Uvar (u, ctx_u_s) ->
-        FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_uvar ctx_u_s)
-          FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_Let (false, attrs, bv, t1, t2) ->
-        let lb =
-          FStar_Syntax_Util.mk_letbinding (FStar_Pervasives.Inl bv) []
-            bv.FStar_Syntax_Syntax.sort FStar_Parser_Const.effect_Tot_lid t1
-            attrs FStar_Compiler_Range.dummyRange in
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_let ((false, [lb]), t2))
-          FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_Let (true, attrs, bv, t1, t2) ->
-        let lb =
-          FStar_Syntax_Util.mk_letbinding (FStar_Pervasives.Inl bv) []
-            bv.FStar_Syntax_Syntax.sort FStar_Parser_Const.effect_Tot_lid t1
-            attrs FStar_Compiler_Range.dummyRange in
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_let ((true, [lb]), t2))
-          FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_Match (t, ret_opt, brs) ->
-        let wrap v =
-          {
-            FStar_Syntax_Syntax.v = v;
-            FStar_Syntax_Syntax.p = FStar_Compiler_Range.dummyRange
-          } in
-        let rec pack_pat p =
-          match p with
-          | FStar_Reflection_Data.Pat_Constant c ->
-              let uu___ =
-                let uu___1 = pack_const c in
-                FStar_Syntax_Syntax.Pat_constant uu___1 in
-              FStar_Compiler_Effect.op_Less_Bar wrap uu___
-          | FStar_Reflection_Data.Pat_Cons (fv, us_opt, ps) ->
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Compiler_List.map
-                      (fun uu___3 ->
-                         match uu___3 with
-                         | (p1, b) -> let uu___4 = pack_pat p1 in (uu___4, b))
-                      ps in
-                  (fv, us_opt, uu___2) in
-                FStar_Syntax_Syntax.Pat_cons uu___1 in
-              FStar_Compiler_Effect.op_Less_Bar wrap uu___
-          | FStar_Reflection_Data.Pat_Var bv ->
-              FStar_Compiler_Effect.op_Less_Bar wrap
-                (FStar_Syntax_Syntax.Pat_var bv)
-          | FStar_Reflection_Data.Pat_Wild bv ->
-              FStar_Compiler_Effect.op_Less_Bar wrap
-                (FStar_Syntax_Syntax.Pat_wild bv)
-          | FStar_Reflection_Data.Pat_Dot_Term eopt ->
-              FStar_Compiler_Effect.op_Less_Bar wrap
-                (FStar_Syntax_Syntax.Pat_dot_term eopt) in
-        let brs1 =
-          FStar_Compiler_List.map
-            (fun uu___ ->
-               match uu___ with
-               | (pat, t1) ->
-                   let uu___1 = pack_pat pat in
-                   (uu___1, FStar_Pervasives_Native.None, t1)) brs in
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_match
-             (t, ret_opt, brs1, FStar_Pervasives_Native.None))
-          FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_AscribedT (e, t, tacopt, use_eq) ->
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_ascribed
-             (e, ((FStar_Pervasives.Inl t), tacopt, use_eq),
-               FStar_Pervasives_Native.None)) FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_AscribedC (e, c, tacopt, use_eq) ->
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_ascribed
-             (e, ((FStar_Pervasives.Inr c), tacopt, use_eq),
-               FStar_Pervasives_Native.None)) FStar_Compiler_Range.dummyRange
-    | FStar_Reflection_Data.Tv_Unknown ->
-        FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-          FStar_Compiler_Range.dummyRange
-let (compare_bv :
-  FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.bv -> FStar_Order.order) =
-  fun x ->
-    fun y ->
-      let n = FStar_Syntax_Syntax.order_bv x y in
-      if n < Prims.int_zero
-      then FStar_Order.Lt
-      else if n = Prims.int_zero then FStar_Order.Eq else FStar_Order.Gt
-let (is_free :
-  FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun x -> fun t -> FStar_Syntax_Util.is_free_in x t
-let (free_bvs :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.bv Prims.list) =
-  fun t ->
-    let uu___ = FStar_Syntax_Free.names t in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      FStar_Compiler_Util.set_elements
-let (free_uvars : FStar_Syntax_Syntax.term -> FStar_BigInt.t Prims.list) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Free.uvars_uncached t in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        FStar_Compiler_Util.set_elements in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (FStar_Compiler_List.map
-         (fun u ->
-            let uu___1 =
-              FStar_Syntax_Unionfind.uvar_id
-                u.FStar_Syntax_Syntax.ctx_uvar_head in
-            FStar_BigInt.of_int_fs uu___1))
-let (lookup_attr :
-  FStar_Syntax_Syntax.term ->
-    FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.fv Prims.list)
-  =
-  fun attr ->
-    fun env ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress attr in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let ses =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Syntax.lid_of_fv fv in
-              FStar_Ident.string_of_lid uu___2 in
-            FStar_TypeChecker_Env.lookup_attr env uu___1 in
-          FStar_Compiler_List.concatMap
-            (fun se ->
-               let uu___1 = FStar_Syntax_Util.lid_of_sigelt se in
-               match uu___1 with
-               | FStar_Pervasives_Native.None -> []
-               | FStar_Pervasives_Native.Some l ->
-                   let uu___2 =
-                     FStar_Syntax_Syntax.lid_as_fv l
-                       (FStar_Syntax_Syntax.Delta_constant_at_level
-                          (Prims.of_int (999))) FStar_Pervasives_Native.None in
-                   [uu___2]) ses
-      | uu___1 -> []
-let (all_defs_in_env :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.fv Prims.list) =
-  fun env ->
-    let uu___ = FStar_TypeChecker_Env.lidents env in
-    FStar_Compiler_List.map
-      (fun l ->
-         FStar_Syntax_Syntax.lid_as_fv l
-           (FStar_Syntax_Syntax.Delta_constant_at_level (Prims.of_int (999)))
-           FStar_Pervasives_Native.None) uu___
-let (defs_in_module :
-  FStar_TypeChecker_Env.env ->
-    FStar_Reflection_Data.name -> FStar_Syntax_Syntax.fv Prims.list)
-  =
-  fun env ->
-    fun modul ->
-      let uu___ = FStar_TypeChecker_Env.lidents env in
-      FStar_Compiler_List.concatMap
-        (fun l ->
-           let ns =
-             let uu___1 =
-               let uu___2 = FStar_Ident.ids_of_lid l in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2 init in
-             FStar_Compiler_Effect.op_Bar_Greater uu___1
-               (FStar_Compiler_List.map FStar_Ident.string_of_id) in
-           if ns = modul
-           then
-             let uu___1 =
-               FStar_Syntax_Syntax.lid_as_fv l
-                 (FStar_Syntax_Syntax.Delta_constant_at_level
-                    (Prims.of_int (999))) FStar_Pervasives_Native.None in
-             [uu___1]
-           else []) uu___
-let (lookup_typ :
-  FStar_TypeChecker_Env.env ->
-    Prims.string Prims.list ->
-      FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun ns ->
-      let lid = FStar_Parser_Const.p2l ns in
-      FStar_TypeChecker_Env.lookup_sigelt env lid
-let (sigelt_attrs :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.attribute Prims.list) =
-  fun se -> se.FStar_Syntax_Syntax.sigattrs
-let (set_sigelt_attrs :
-  FStar_Syntax_Syntax.attribute Prims.list ->
-    FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun attrs ->
-    fun se ->
-      {
-        FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-        FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-        FStar_Syntax_Syntax.sigquals = (se.FStar_Syntax_Syntax.sigquals);
-        FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-        FStar_Syntax_Syntax.sigattrs = attrs;
-        FStar_Syntax_Syntax.sigopts = (se.FStar_Syntax_Syntax.sigopts)
-      }
-let (rd_to_syntax_qual :
-  FStar_Reflection_Data.qualifier -> FStar_Syntax_Syntax.qualifier) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Reflection_Data.Assumption -> FStar_Syntax_Syntax.Assumption
-    | FStar_Reflection_Data.New -> FStar_Syntax_Syntax.New
-    | FStar_Reflection_Data.Private -> FStar_Syntax_Syntax.Private
-    | FStar_Reflection_Data.Unfold_for_unification_and_vcgen ->
-        FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen
-    | FStar_Reflection_Data.Visible_default ->
-        FStar_Syntax_Syntax.Visible_default
-    | FStar_Reflection_Data.Irreducible -> FStar_Syntax_Syntax.Irreducible
-    | FStar_Reflection_Data.Inline_for_extraction ->
-        FStar_Syntax_Syntax.Inline_for_extraction
-    | FStar_Reflection_Data.NoExtract -> FStar_Syntax_Syntax.NoExtract
-    | FStar_Reflection_Data.Noeq -> FStar_Syntax_Syntax.Noeq
-    | FStar_Reflection_Data.Unopteq -> FStar_Syntax_Syntax.Unopteq
-    | FStar_Reflection_Data.TotalEffect -> FStar_Syntax_Syntax.TotalEffect
-    | FStar_Reflection_Data.Logic -> FStar_Syntax_Syntax.Logic
-    | FStar_Reflection_Data.Reifiable -> FStar_Syntax_Syntax.Reifiable
-    | FStar_Reflection_Data.Reflectable l ->
-        FStar_Syntax_Syntax.Reflectable l
-    | FStar_Reflection_Data.Discriminator l ->
-        FStar_Syntax_Syntax.Discriminator l
-    | FStar_Reflection_Data.Projector (l, i) ->
-        FStar_Syntax_Syntax.Projector (l, i)
-    | FStar_Reflection_Data.RecordType (l1, l2) ->
-        FStar_Syntax_Syntax.RecordType (l1, l2)
-    | FStar_Reflection_Data.RecordConstructor (l1, l2) ->
-        FStar_Syntax_Syntax.RecordConstructor (l1, l2)
-    | FStar_Reflection_Data.Action l -> FStar_Syntax_Syntax.Action l
-    | FStar_Reflection_Data.ExceptionConstructor ->
-        FStar_Syntax_Syntax.ExceptionConstructor
-    | FStar_Reflection_Data.HasMaskedEffect ->
-        FStar_Syntax_Syntax.HasMaskedEffect
-    | FStar_Reflection_Data.Effect -> FStar_Syntax_Syntax.Effect
-    | FStar_Reflection_Data.OnlyName -> FStar_Syntax_Syntax.OnlyName
-let (syntax_to_rd_qual :
-  FStar_Syntax_Syntax.qualifier -> FStar_Reflection_Data.qualifier) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Assumption -> FStar_Reflection_Data.Assumption
-    | FStar_Syntax_Syntax.New -> FStar_Reflection_Data.New
-    | FStar_Syntax_Syntax.Private -> FStar_Reflection_Data.Private
-    | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen ->
-        FStar_Reflection_Data.Unfold_for_unification_and_vcgen
-    | FStar_Syntax_Syntax.Visible_default ->
-        FStar_Reflection_Data.Visible_default
-    | FStar_Syntax_Syntax.Irreducible -> FStar_Reflection_Data.Irreducible
-    | FStar_Syntax_Syntax.Inline_for_extraction ->
-        FStar_Reflection_Data.Inline_for_extraction
-    | FStar_Syntax_Syntax.NoExtract -> FStar_Reflection_Data.NoExtract
-    | FStar_Syntax_Syntax.Noeq -> FStar_Reflection_Data.Noeq
-    | FStar_Syntax_Syntax.Unopteq -> FStar_Reflection_Data.Unopteq
-    | FStar_Syntax_Syntax.TotalEffect -> FStar_Reflection_Data.TotalEffect
-    | FStar_Syntax_Syntax.Logic -> FStar_Reflection_Data.Logic
-    | FStar_Syntax_Syntax.Reifiable -> FStar_Reflection_Data.Reifiable
-    | FStar_Syntax_Syntax.Reflectable l ->
-        FStar_Reflection_Data.Reflectable l
-    | FStar_Syntax_Syntax.Discriminator l ->
-        FStar_Reflection_Data.Discriminator l
-    | FStar_Syntax_Syntax.Projector (l, i) ->
-        FStar_Reflection_Data.Projector (l, i)
-    | FStar_Syntax_Syntax.RecordType (l1, l2) ->
-        FStar_Reflection_Data.RecordType (l1, l2)
-    | FStar_Syntax_Syntax.RecordConstructor (l1, l2) ->
-        FStar_Reflection_Data.RecordConstructor (l1, l2)
-    | FStar_Syntax_Syntax.Action l -> FStar_Reflection_Data.Action l
-    | FStar_Syntax_Syntax.ExceptionConstructor ->
-        FStar_Reflection_Data.ExceptionConstructor
-    | FStar_Syntax_Syntax.HasMaskedEffect ->
-        FStar_Reflection_Data.HasMaskedEffect
-    | FStar_Syntax_Syntax.Effect -> FStar_Reflection_Data.Effect
-    | FStar_Syntax_Syntax.OnlyName -> FStar_Reflection_Data.OnlyName
-let (sigelt_quals :
-  FStar_Syntax_Syntax.sigelt -> FStar_Reflection_Data.qualifier Prims.list) =
-  fun se ->
-    FStar_Compiler_Effect.op_Bar_Greater se.FStar_Syntax_Syntax.sigquals
-      (FStar_Compiler_List.map syntax_to_rd_qual)
-let (set_sigelt_quals :
-  FStar_Reflection_Data.qualifier Prims.list ->
-    FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun quals ->
-    fun se ->
-      let uu___ = FStar_Compiler_List.map rd_to_syntax_qual quals in
-      {
-        FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-        FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-        FStar_Syntax_Syntax.sigquals = uu___;
-        FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-        FStar_Syntax_Syntax.sigattrs = (se.FStar_Syntax_Syntax.sigattrs);
-        FStar_Syntax_Syntax.sigopts = (se.FStar_Syntax_Syntax.sigopts)
-      }
-let (sigelt_opts :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_VConfig.vconfig FStar_Pervasives_Native.option)
-  = fun se -> se.FStar_Syntax_Syntax.sigopts
-let (embed_vconfig : FStar_VConfig.vconfig -> FStar_Syntax_Syntax.term) =
-  fun vcfg ->
-    let uu___ =
-      FStar_Syntax_Embeddings.embed FStar_Syntax_Embeddings.e_vconfig vcfg in
-    uu___ FStar_Compiler_Range.dummyRange FStar_Pervasives_Native.None
-      FStar_Syntax_Embeddings.id_norm_cb
-let (inspect_sigelt :
-  FStar_Syntax_Syntax.sigelt -> FStar_Reflection_Data.sigelt_view) =
-  fun se ->
-    match se.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_let ((r, lbs), uu___) ->
-        let inspect_letbinding lb =
-          let uu___1 = lb in
-          match uu___1 with
-          | { FStar_Syntax_Syntax.lbname = nm;
-              FStar_Syntax_Syntax.lbunivs = us;
-              FStar_Syntax_Syntax.lbtyp = typ;
-              FStar_Syntax_Syntax.lbeff = eff;
-              FStar_Syntax_Syntax.lbdef = def;
-              FStar_Syntax_Syntax.lbattrs = attrs;
-              FStar_Syntax_Syntax.lbpos = pos;_} ->
-              let uu___2 = FStar_Syntax_Subst.univ_var_opening us in
-              (match uu___2 with
-               | (s, us1) ->
-                   let typ1 = FStar_Syntax_Subst.subst s typ in
-                   let def1 = FStar_Syntax_Subst.subst s def in
-                   FStar_Syntax_Util.mk_letbinding nm us1 typ1 eff def1 attrs
-                     pos) in
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.map inspect_letbinding lbs in
-          (r, uu___2) in
-        FStar_Reflection_Data.Sg_Let uu___1
-    | FStar_Syntax_Syntax.Sig_inductive_typ
-        (lid, us, param_bs, _num_uniform, ty, _mutual, c_lids) ->
-        let nm = FStar_Ident.path_of_lid lid in
-        let uu___ = FStar_Syntax_Subst.univ_var_opening us in
-        (match uu___ with
-         | (s, us1) ->
-             let param_bs1 = FStar_Syntax_Subst.subst_binders s param_bs in
-             let ty1 = FStar_Syntax_Subst.subst s ty in
-             let uu___1 = FStar_Syntax_Subst.open_term param_bs1 ty1 in
-             (match uu___1 with
-              | (param_bs2, ty2) ->
-                  let inspect_ctor c_lid =
-                    let uu___2 =
-                      let uu___3 = get_env () in
-                      FStar_TypeChecker_Env.lookup_sigelt uu___3 c_lid in
-                    match uu___2 with
-                    | FStar_Pervasives_Native.Some
-                        {
-                          FStar_Syntax_Syntax.sigel =
-                            FStar_Syntax_Syntax.Sig_datacon
-                            (lid1, us2, cty, _ty_lid_, nparam, _mutual1);
-                          FStar_Syntax_Syntax.sigrng = uu___3;
-                          FStar_Syntax_Syntax.sigquals = uu___4;
-                          FStar_Syntax_Syntax.sigmeta = uu___5;
-                          FStar_Syntax_Syntax.sigattrs = uu___6;
-                          FStar_Syntax_Syntax.sigopts = uu___7;_}
-                        ->
-                        let cty1 = FStar_Syntax_Subst.subst s cty in
-                        let uu___8 =
-                          let uu___9 = get_env () in
-                          FStar_TypeChecker_Normalize.get_n_binders uu___9
-                            nparam cty1 in
-                        (match uu___8 with
-                         | (param_ctor_bs, c) ->
-                             (if
-                                (FStar_Compiler_List.length param_ctor_bs) <>
-                                  nparam
-                              then
-                                failwith
-                                  "impossible: inspect_sigelt: could not obtain sufficient ctor param binders"
-                              else ();
-                              (let uu___11 =
-                                 let uu___12 =
-                                   FStar_Syntax_Util.is_total_comp c in
-                                 Prims.op_Negation uu___12 in
-                               if uu___11
-                               then
-                                 failwith
-                                   "impossible: inspect_sigelt: removed parameters and got an effectful comp"
-                               else ());
-                              (let cty2 = FStar_Syntax_Util.comp_result c in
-                               let s' =
-                                 FStar_Compiler_List.map2
-                                   (fun b1 ->
-                                      fun b2 ->
-                                        let uu___11 =
-                                          let uu___12 =
-                                            FStar_Syntax_Syntax.bv_to_name
-                                              b2.FStar_Syntax_Syntax.binder_bv in
-                                          ((b1.FStar_Syntax_Syntax.binder_bv),
-                                            uu___12) in
-                                        FStar_Syntax_Syntax.NT uu___11)
-                                   param_ctor_bs param_bs2 in
-                               let cty3 = FStar_Syntax_Subst.subst s' cty2 in
-                               let cty4 = FStar_Syntax_Util.remove_inacc cty3 in
-                               let uu___11 = FStar_Ident.path_of_lid lid1 in
-                               (uu___11, cty4))))
-                    | uu___3 ->
-                        failwith
-                          "impossible: inspect_sigelt: did not find ctor" in
-                  let uu___2 =
-                    let uu___3 = FStar_Compiler_List.map inspect_ctor c_lids in
-                    (nm, us1, param_bs2, ty2, uu___3) in
-                  FStar_Reflection_Data.Sg_Inductive uu___2))
-    | FStar_Syntax_Syntax.Sig_declare_typ (lid, us, ty) ->
-        let nm = FStar_Ident.path_of_lid lid in
-        let uu___ = FStar_Syntax_Subst.open_univ_vars us ty in
-        (match uu___ with
-         | (us1, ty1) -> FStar_Reflection_Data.Sg_Val (nm, us1, ty1))
-    | uu___ -> FStar_Reflection_Data.Unk
-let (pack_sigelt :
-  FStar_Reflection_Data.sigelt_view -> FStar_Syntax_Syntax.sigelt) =
-  fun sv ->
-    let check_lid lid =
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Ident.path_of_lid lid in
-          FStar_Compiler_List.length uu___2 in
-        uu___1 <= Prims.int_one in
-      if uu___
-      then
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Ident.string_of_lid lid in
-            Prims.op_Hat uu___3 "\" (did you forget a module path?)" in
-          Prims.op_Hat "pack_sigelt: invalid long identifier \"" uu___2 in
-        failwith uu___1
-      else () in
-    match sv with
-    | FStar_Reflection_Data.Sg_Let (r, lbs) ->
-        let pack_letbinding lb =
-          let uu___ = lb in
-          match uu___ with
-          | { FStar_Syntax_Syntax.lbname = nm;
-              FStar_Syntax_Syntax.lbunivs = us;
-              FStar_Syntax_Syntax.lbtyp = typ;
-              FStar_Syntax_Syntax.lbeff = eff;
-              FStar_Syntax_Syntax.lbdef = def;
-              FStar_Syntax_Syntax.lbattrs = attrs;
-              FStar_Syntax_Syntax.lbpos = pos;_} ->
-              let lid =
-                match nm with
-                | FStar_Pervasives.Inr fv -> FStar_Syntax_Syntax.lid_of_fv fv
-                | uu___1 ->
-                    failwith
-                      "impossible: pack_sigelt: bv in toplevel let binding" in
-              (check_lid lid;
-               (let s = FStar_Syntax_Subst.univ_var_closing us in
-                let typ1 = FStar_Syntax_Subst.subst s typ in
-                let def1 = FStar_Syntax_Subst.subst s def in
-                let lb1 =
-                  FStar_Syntax_Util.mk_letbinding nm us typ1 eff def1 attrs
-                    pos in
-                (lid, lb1))) in
-        let packed = FStar_Compiler_List.map pack_letbinding lbs in
-        let lbs1 = FStar_Compiler_List.map FStar_Pervasives_Native.snd packed in
-        let lids = FStar_Compiler_List.map FStar_Pervasives_Native.fst packed in
-        FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_sigelt
-          (FStar_Syntax_Syntax.Sig_let ((r, lbs1), lids))
-    | FStar_Reflection_Data.Sg_Inductive (nm, us_names, param_bs, ty, ctors)
-        ->
-        let ind_lid =
-          FStar_Ident.lid_of_path nm FStar_Compiler_Range.dummyRange in
-        (check_lid ind_lid;
-         (let s = FStar_Syntax_Subst.univ_var_closing us_names in
-          let nparam = FStar_Compiler_List.length param_bs in
-          let pack_ctor c =
-            let uu___1 = c in
-            match uu___1 with
-            | (nm1, ty1) ->
-                let lid =
-                  FStar_Ident.lid_of_path nm1 FStar_Compiler_Range.dummyRange in
-                let ty2 =
-                  let uu___2 = FStar_Syntax_Syntax.mk_Total ty1 in
-                  FStar_Syntax_Util.arrow param_bs uu___2 in
-                let ty3 = FStar_Syntax_Subst.subst s ty2 in
-                FStar_Compiler_Effect.op_Less_Bar
-                  FStar_Syntax_Syntax.mk_sigelt
-                  (FStar_Syntax_Syntax.Sig_datacon
-                     (lid, us_names, ty3, ind_lid, nparam, [])) in
-          let ctor_ses = FStar_Compiler_List.map pack_ctor ctors in
-          let c_lids =
-            FStar_Compiler_List.map
-              (fun se ->
-                 let uu___1 = FStar_Syntax_Util.lid_of_sigelt se in
-                 FStar_Compiler_Util.must uu___1) ctor_ses in
-          let ind_se =
-            let param_bs1 = FStar_Syntax_Subst.close_binders param_bs in
-            let ty1 = FStar_Syntax_Subst.close param_bs1 ty in
-            let param_bs2 = FStar_Syntax_Subst.subst_binders s param_bs1 in
-            let ty2 = FStar_Syntax_Subst.subst s ty1 in
-            FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_sigelt
-              (FStar_Syntax_Syntax.Sig_inductive_typ
-                 (ind_lid, us_names, param_bs2, FStar_Pervasives_Native.None,
-                   ty2, [], c_lids)) in
-          let se =
-            FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_sigelt
-              (FStar_Syntax_Syntax.Sig_bundle
-                 ((ind_se :: ctor_ses), (ind_lid :: c_lids))) in
-          {
-            FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-            FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-            FStar_Syntax_Syntax.sigquals = (FStar_Syntax_Syntax.Noeq ::
-              (se.FStar_Syntax_Syntax.sigquals));
-            FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-            FStar_Syntax_Syntax.sigattrs = (se.FStar_Syntax_Syntax.sigattrs);
-            FStar_Syntax_Syntax.sigopts = (se.FStar_Syntax_Syntax.sigopts)
-          }))
-    | FStar_Reflection_Data.Sg_Val (nm, us_names, ty) ->
-        let val_lid =
-          FStar_Ident.lid_of_path nm FStar_Compiler_Range.dummyRange in
-        (check_lid val_lid;
-         (let typ = FStar_Syntax_Subst.close_univ_vars us_names ty in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_sigelt
-            (FStar_Syntax_Syntax.Sig_declare_typ (val_lid, us_names, typ))))
-    | FStar_Reflection_Data.Unk -> failwith "packing Unk, sorry"
-let (inspect_lb :
-  FStar_Syntax_Syntax.letbinding -> FStar_Reflection_Data.lb_view) =
-  fun lb ->
-    let uu___ = lb in
-    match uu___ with
-    | { FStar_Syntax_Syntax.lbname = nm; FStar_Syntax_Syntax.lbunivs = us;
-        FStar_Syntax_Syntax.lbtyp = typ; FStar_Syntax_Syntax.lbeff = eff;
-        FStar_Syntax_Syntax.lbdef = def; FStar_Syntax_Syntax.lbattrs = attrs;
-        FStar_Syntax_Syntax.lbpos = pos;_} ->
-        let uu___1 = FStar_Syntax_Subst.univ_var_opening us in
-        (match uu___1 with
-         | (s, us1) ->
-             let typ1 = FStar_Syntax_Subst.subst s typ in
-             let def1 = FStar_Syntax_Subst.subst s def in
-             (match nm with
-              | FStar_Pervasives.Inr fv ->
-                  {
-                    FStar_Reflection_Data.lb_fv = fv;
-                    FStar_Reflection_Data.lb_us = us1;
-                    FStar_Reflection_Data.lb_typ = typ1;
-                    FStar_Reflection_Data.lb_def = def1
-                  }
-              | uu___2 -> failwith "Impossible: bv in top-level let binding"))
-let (pack_lb :
-  FStar_Reflection_Data.lb_view -> FStar_Syntax_Syntax.letbinding) =
-  fun lbv ->
-    let uu___ = lbv in
-    match uu___ with
-    | { FStar_Reflection_Data.lb_fv = fv; FStar_Reflection_Data.lb_us = us;
-        FStar_Reflection_Data.lb_typ = typ;
-        FStar_Reflection_Data.lb_def = def;_} ->
-        let s = FStar_Syntax_Subst.univ_var_closing us in
-        let typ1 = FStar_Syntax_Subst.subst s typ in
-        let def1 = FStar_Syntax_Subst.subst s def in
-        FStar_Syntax_Util.mk_letbinding (FStar_Pervasives.Inr fv) us typ1
-          FStar_Parser_Const.effect_Tot_lid def1 []
-          FStar_Compiler_Range.dummyRange
-let (inspect_bv : FStar_Syntax_Syntax.bv -> FStar_Reflection_Data.bv_view) =
-  fun bv ->
-    let uu___ = FStar_Ident.string_of_id bv.FStar_Syntax_Syntax.ppname in
-    let uu___1 = FStar_BigInt.of_int_fs bv.FStar_Syntax_Syntax.index in
-    {
-      FStar_Reflection_Data.bv_ppname = uu___;
-      FStar_Reflection_Data.bv_index = uu___1;
-      FStar_Reflection_Data.bv_sort = (bv.FStar_Syntax_Syntax.sort)
-    }
-let (pack_bv : FStar_Reflection_Data.bv_view -> FStar_Syntax_Syntax.bv) =
-  fun bvv ->
-    let uu___ =
-      FStar_Ident.mk_ident
-        ((bvv.FStar_Reflection_Data.bv_ppname),
-          FStar_Compiler_Range.dummyRange) in
-    let uu___1 = FStar_BigInt.to_int_fs bvv.FStar_Reflection_Data.bv_index in
-    {
-      FStar_Syntax_Syntax.ppname = uu___;
-      FStar_Syntax_Syntax.index = uu___1;
-      FStar_Syntax_Syntax.sort = (bvv.FStar_Reflection_Data.bv_sort)
-    }
-let (inspect_binder :
-  FStar_Syntax_Syntax.binder ->
-    (FStar_Syntax_Syntax.bv * (FStar_Reflection_Data.aqualv *
-      FStar_Syntax_Syntax.term Prims.list)))
-  =
-  fun b ->
-    let uu___ =
-      let uu___1 = inspect_bqual b.FStar_Syntax_Syntax.binder_qual in
-      (uu___1, (b.FStar_Syntax_Syntax.binder_attrs)) in
-    ((b.FStar_Syntax_Syntax.binder_bv), uu___)
-let (pack_binder :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Reflection_Data.aqualv ->
-      FStar_Syntax_Syntax.term Prims.list -> FStar_Syntax_Syntax.binder)
-  =
-  fun bv ->
-    fun aqv ->
-      fun attrs ->
-        let uu___ = pack_bqual aqv in
-        {
-          FStar_Syntax_Syntax.binder_bv = bv;
-          FStar_Syntax_Syntax.binder_qual = uu___;
-          FStar_Syntax_Syntax.binder_attrs = attrs
-        }
-let (moduleof : FStar_TypeChecker_Env.env -> Prims.string Prims.list) =
-  fun e -> FStar_Ident.path_of_lid e.FStar_TypeChecker_Env.curmodule
-let (env_open_modules :
-  FStar_TypeChecker_Env.env -> FStar_Reflection_Data.name Prims.list) =
-  fun e ->
-    let uu___ = FStar_Syntax_DsEnv.open_modules e.FStar_TypeChecker_Env.dsenv in
-    FStar_Compiler_List.map
-      (fun uu___1 ->
-         match uu___1 with
-         | (l, m) ->
-             let uu___2 = FStar_Ident.ids_of_lid l in
-             FStar_Compiler_List.map FStar_Ident.string_of_id uu___2) uu___
-let (binders_of_env :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.binders) =
-  fun e -> FStar_TypeChecker_Env.all_binders e
-let eqopt :
-  'uuuuu .
-    unit ->
-      ('uuuuu -> 'uuuuu -> Prims.bool) ->
-        'uuuuu FStar_Pervasives_Native.option ->
-          'uuuuu FStar_Pervasives_Native.option -> Prims.bool
-  = fun uu___ -> FStar_Syntax_Util.eqopt
-let eqlist :
-  'uuuuu .
-    unit ->
-      ('uuuuu -> 'uuuuu -> Prims.bool) ->
-        'uuuuu Prims.list -> 'uuuuu Prims.list -> Prims.bool
-  = fun uu___ -> FStar_Syntax_Util.eqlist
-let eqprod :
-  'uuuuu 'uuuuu1 .
-    unit ->
-      ('uuuuu -> 'uuuuu -> Prims.bool) ->
-        ('uuuuu1 -> 'uuuuu1 -> Prims.bool) ->
-          ('uuuuu * 'uuuuu1) -> ('uuuuu * 'uuuuu1) -> Prims.bool
-  = fun uu___ -> FStar_Syntax_Util.eqprod
-let rec (term_eq :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t1 ->
-    fun t2 ->
-      let uu___ =
-        let uu___1 = inspect_ln t1 in
-        let uu___2 = inspect_ln t2 in (uu___1, uu___2) in
-      match uu___ with
-      | (FStar_Reflection_Data.Tv_Var bv1, FStar_Reflection_Data.Tv_Var bv2)
-          -> bv_eq bv1 bv2
-      | (FStar_Reflection_Data.Tv_BVar bv1, FStar_Reflection_Data.Tv_BVar
-         bv2) -> bv_eq bv1 bv2
-      | (FStar_Reflection_Data.Tv_FVar fv1, FStar_Reflection_Data.Tv_FVar
-         fv2) -> FStar_Syntax_Syntax.fv_eq fv1 fv2
-      | (FStar_Reflection_Data.Tv_UInst (fv1, us1),
-         FStar_Reflection_Data.Tv_UInst (fv2, us2)) ->
-          (FStar_Syntax_Syntax.fv_eq fv1 fv2) && (univs_eq us1 us2)
-      | (FStar_Reflection_Data.Tv_App (h1, arg1),
-         FStar_Reflection_Data.Tv_App (h2, arg2)) ->
-          (term_eq h1 h2) && (arg_eq arg1 arg2)
-      | (FStar_Reflection_Data.Tv_Abs (b1, t11), FStar_Reflection_Data.Tv_Abs
-         (b2, t21)) -> (binder_eq b1 b2) && (term_eq t11 t21)
-      | (FStar_Reflection_Data.Tv_Arrow (b1, c1),
-         FStar_Reflection_Data.Tv_Arrow (b2, c2)) ->
-          (binder_eq b1 b2) && (comp_eq c1 c2)
-      | (FStar_Reflection_Data.Tv_Type u1, FStar_Reflection_Data.Tv_Type u2)
-          -> univ_eq u1 u2
-      | (FStar_Reflection_Data.Tv_Refine (b1, t11),
-         FStar_Reflection_Data.Tv_Refine (b2, t21)) ->
-          (term_eq b1.FStar_Syntax_Syntax.sort b2.FStar_Syntax_Syntax.sort)
-            && (term_eq t11 t21)
-      | (FStar_Reflection_Data.Tv_Const c1, FStar_Reflection_Data.Tv_Const
-         c2) -> const_eq c1 c2
-      | (FStar_Reflection_Data.Tv_Uvar (n1, uv1),
-         FStar_Reflection_Data.Tv_Uvar (n2, uv2)) -> n1 = n2
-      | (FStar_Reflection_Data.Tv_Let (r1, ats1, bv1, m1, n1),
-         FStar_Reflection_Data.Tv_Let (r2, ats2, bv2, m2, n2)) ->
-          ((((r1 = r2) && ((eqlist ()) term_eq ats1 ats2)) &&
-              (term_eq bv1.FStar_Syntax_Syntax.sort
-                 bv2.FStar_Syntax_Syntax.sort))
-             && (term_eq m1 m2))
-            && (term_eq n1 n2)
-      | (FStar_Reflection_Data.Tv_Match (h1, an1, brs1),
-         FStar_Reflection_Data.Tv_Match (h2, an2, brs2)) ->
-          ((term_eq h1 h2) && ((eqopt ()) match_ret_asc_eq an1 an2)) &&
-            ((eqlist ()) branch_eq brs1 brs2)
-      | (FStar_Reflection_Data.Tv_AscribedT (e1, t11, topt1, eq1),
-         FStar_Reflection_Data.Tv_AscribedT (e2, t21, topt2, eq2)) ->
-          (((term_eq e1 e2) && (term_eq t11 t21)) &&
-             ((eqopt ()) term_eq topt1 topt2))
-            && (eq1 = eq2)
-      | (FStar_Reflection_Data.Tv_AscribedC (e1, c1, topt1, eq1),
-         FStar_Reflection_Data.Tv_AscribedC (e2, c2, topt2, eq2)) ->
-          (((term_eq e1 e2) && (comp_eq c1 c2)) &&
-             ((eqopt ()) term_eq topt1 topt2))
-            && (eq1 = eq2)
-      | (FStar_Reflection_Data.Tv_Unknown, FStar_Reflection_Data.Tv_Unknown)
-          -> true
-      | uu___1 -> false
-and (arg_eq :
-  FStar_Reflection_Data.argv -> FStar_Reflection_Data.argv -> Prims.bool) =
-  fun arg1 ->
-    fun arg2 ->
-      let uu___ = arg1 in
-      match uu___ with
-      | (a1, aq1) ->
-          let uu___1 = arg2 in
-          (match uu___1 with
-           | (a2, aq2) -> (term_eq a1 a2) && (aqual_eq aq1 aq2))
-and (aqual_eq :
-  FStar_Reflection_Data.aqualv -> FStar_Reflection_Data.aqualv -> Prims.bool)
-  =
-  fun aq1 ->
-    fun aq2 ->
-      match (aq1, aq2) with
-      | (FStar_Reflection_Data.Q_Implicit, FStar_Reflection_Data.Q_Implicit)
-          -> true
-      | (FStar_Reflection_Data.Q_Explicit, FStar_Reflection_Data.Q_Explicit)
-          -> true
-      | (FStar_Reflection_Data.Q_Meta t1, FStar_Reflection_Data.Q_Meta t2) ->
-          term_eq t1 t2
-      | uu___ -> false
-and (binder_eq :
-  FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder -> Prims.bool) =
-  fun b1 ->
-    fun b2 ->
-      let uu___ = inspect_binder b1 in
-      match uu___ with
-      | (bv1, (bq1, bats1)) ->
-          let uu___1 = inspect_binder b2 in
-          (match uu___1 with
-           | (bv2, (bq2, bats2)) ->
-               ((binding_bv_eq bv1 bv2) && (aqual_eq bq1 bq2)) &&
-                 ((eqlist ()) term_eq bats1 bats2))
-and (binding_bv_eq :
-  FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.bv -> Prims.bool) =
-  fun bv1 ->
-    fun bv2 ->
-      term_eq bv1.FStar_Syntax_Syntax.sort bv2.FStar_Syntax_Syntax.sort
-and (bv_eq : FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.bv -> Prims.bool)
-  =
-  fun bv1 ->
-    fun bv2 -> bv1.FStar_Syntax_Syntax.index = bv2.FStar_Syntax_Syntax.index
-and (comp_eq :
-  FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp -> Prims.bool) =
-  fun c1 ->
-    fun c2 ->
-      let uu___ =
-        let uu___1 = inspect_comp c1 in
-        let uu___2 = inspect_comp c2 in (uu___1, uu___2) in
-      match uu___ with
-      | (FStar_Reflection_Data.C_Total t1, FStar_Reflection_Data.C_Total t2)
-          -> term_eq t1 t2
-      | (FStar_Reflection_Data.C_GTotal t1, FStar_Reflection_Data.C_GTotal
-         t2) -> term_eq t1 t2
-      | (FStar_Reflection_Data.C_Lemma (pre1, post1, pats1),
-         FStar_Reflection_Data.C_Lemma (pre2, post2, pats2)) ->
-          ((term_eq pre1 pre2) && (term_eq post1 post2)) &&
-            (term_eq pats1 pats2)
-      | (FStar_Reflection_Data.C_Eff (us1, name1, t1, args1, decrs1),
-         FStar_Reflection_Data.C_Eff (us2, name2, t2, args2, decrs2)) ->
-          ((((univs_eq us1 us2) && (name1 = name2)) && (term_eq t1 t2)) &&
-             ((eqlist ()) arg_eq args1 args2))
-            && ((eqlist ()) term_eq decrs1 decrs2)
-      | uu___1 -> false
-and (match_ret_asc_eq :
-  FStar_Syntax_Syntax.match_returns_ascription ->
-    FStar_Syntax_Syntax.match_returns_ascription -> Prims.bool)
-  = fun a1 -> fun a2 -> (eqprod ()) binder_eq ascription_eq a1 a2
-and (ascription_eq :
-  FStar_Syntax_Syntax.ascription ->
-    FStar_Syntax_Syntax.ascription -> Prims.bool)
-  =
-  fun asc1 ->
-    fun asc2 ->
-      let uu___ = asc1 in
-      match uu___ with
-      | (a1, topt1, eq1) ->
-          let uu___1 = asc2 in
-          (match uu___1 with
-           | (a2, topt2, eq2) ->
-               ((match (a1, a2) with
-                 | (FStar_Pervasives.Inl t1, FStar_Pervasives.Inl t2) ->
-                     term_eq t1 t2
-                 | (FStar_Pervasives.Inr c1, FStar_Pervasives.Inr c2) ->
-                     comp_eq c1 c2)
-                  && ((eqopt ()) term_eq topt1 topt2))
-                 && (eq1 = eq2))
-and (branch_eq :
-  FStar_Reflection_Data.branch -> FStar_Reflection_Data.branch -> Prims.bool)
-  = fun c1 -> fun c2 -> (eqprod ()) pattern_eq term_eq c1 c2
-and (pattern_eq :
-  FStar_Reflection_Data.pattern ->
-    FStar_Reflection_Data.pattern -> Prims.bool)
-  =
-  fun p1 ->
-    fun p2 ->
-      match (p1, p2) with
-      | (FStar_Reflection_Data.Pat_Constant c1,
-         FStar_Reflection_Data.Pat_Constant c2) -> const_eq c1 c2
-      | (FStar_Reflection_Data.Pat_Cons (fv1, us1, subpats1),
-         FStar_Reflection_Data.Pat_Cons (fv2, us2, subpats2)) ->
-          ((FStar_Syntax_Syntax.fv_eq fv1 fv2) &&
-             ((eqopt ()) ((eqlist ()) univ_eq) us1 us2))
-            &&
-            ((eqlist ())
-               ((eqprod ()) pattern_eq (fun b1 -> fun b2 -> b1 = b2))
-               subpats1 subpats2)
-      | (FStar_Reflection_Data.Pat_Var bv1, FStar_Reflection_Data.Pat_Var
-         bv2) -> binding_bv_eq bv1 bv2
-      | (FStar_Reflection_Data.Pat_Wild bv1, FStar_Reflection_Data.Pat_Wild
-         bv2) -> binding_bv_eq bv1 bv2
-      | (FStar_Reflection_Data.Pat_Dot_Term topt1,
-         FStar_Reflection_Data.Pat_Dot_Term topt2) ->
-          (eqopt ()) term_eq topt1 topt2
-      | uu___ -> false
-and (const_eq :
-  FStar_Reflection_Data.vconst -> FStar_Reflection_Data.vconst -> Prims.bool)
-  = fun c1 -> fun c2 -> c1 = c2
-and (univ_eq :
-  FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe -> Prims.bool)
-  = fun u1 -> fun u2 -> FStar_Syntax_Util.eq_univs u1 u2
-and (univs_eq :
-  FStar_Syntax_Syntax.universe Prims.list ->
-    FStar_Syntax_Syntax.universe Prims.list -> Prims.bool)
-  = fun us1 -> fun us2 -> (eqlist ()) univ_eq us1 us2
-let (implode_qn : Prims.string Prims.list -> Prims.string) =
-  fun ns -> FStar_String.concat "." ns
-let (explode_qn : Prims.string -> Prims.string Prims.list) =
-  fun s -> FStar_String.split [46] s
-let (compare_string : Prims.string -> Prims.string -> FStar_BigInt.t) =
-  fun s1 -> fun s2 -> FStar_BigInt.of_int_fs (FStar_String.compare s1 s2)
-let (push_binder :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binder -> FStar_TypeChecker_Env.env)
-  = fun e -> fun b -> FStar_TypeChecker_Env.push_binders e [b]
-let (subst :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun x ->
-    fun n ->
-      fun m -> FStar_Syntax_Subst.subst [FStar_Syntax_Syntax.NT (x, n)] m
-let (close_term :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun b -> fun t -> FStar_Syntax_Subst.close [b] t
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Reflection_Constants.ml b/src/ocaml-output/FStar_Reflection_Constants.ml
deleted file mode 100644
index a21b15a8fdc..00000000000
--- a/src/ocaml-output/FStar_Reflection_Constants.ml
+++ /dev/null
@@ -1,408 +0,0 @@
-open Prims
-type refl_constant =
-  {
-  lid: FStar_Ident.lid ;
-  fv: FStar_Syntax_Syntax.fv ;
-  t: FStar_Syntax_Syntax.term }
-let (__proj__Mkrefl_constant__item__lid : refl_constant -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | { lid; fv; t;_} -> lid
-let (__proj__Mkrefl_constant__item__fv :
-  refl_constant -> FStar_Syntax_Syntax.fv) =
-  fun projectee -> match projectee with | { lid; fv; t;_} -> fv
-let (__proj__Mkrefl_constant__item__t :
-  refl_constant -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | { lid; fv; t;_} -> t
-let (refl_constant_lid : refl_constant -> FStar_Ident.lid) = fun rc -> rc.lid
-let (refl_constant_term : refl_constant -> FStar_Syntax_Syntax.term) =
-  fun rc -> rc.t
-let (fstar_refl_lid : Prims.string Prims.list -> FStar_Ident.lident) =
-  fun s ->
-    FStar_Ident.lid_of_path
-      (FStar_Compiler_List.op_At ["FStar"; "Reflection"] s)
-      FStar_Compiler_Range.dummyRange
-let (fstar_refl_builtins_lid : Prims.string -> FStar_Ident.lident) =
-  fun s -> fstar_refl_lid ["Builtins"; s]
-let (fstar_refl_syntax_lid : Prims.string -> FStar_Ident.lident) =
-  fun s -> fstar_refl_lid ["Syntax"; s]
-let (fstar_refl_types_lid : Prims.string -> FStar_Ident.lident) =
-  fun s -> fstar_refl_lid ["Types"; s]
-let (fstar_refl_data_lid : Prims.string -> FStar_Ident.lident) =
-  fun s -> fstar_refl_lid ["Data"; s]
-let (fstar_refl_data_const : Prims.string -> refl_constant) =
-  fun s ->
-    let lid = fstar_refl_data_lid s in
-    let uu___ =
-      FStar_Syntax_Syntax.lid_as_fv lid FStar_Syntax_Syntax.delta_constant
-        (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor) in
-    let uu___1 = FStar_Syntax_Syntax.tdataconstr lid in
-    { lid; fv = uu___; t = uu___1 }
-let (mk_refl_types_lid_as_term : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s ->
-    let uu___ = fstar_refl_types_lid s in FStar_Syntax_Syntax.tconst uu___
-let (mk_refl_types_lid_as_fv : Prims.string -> FStar_Syntax_Syntax.fv) =
-  fun s ->
-    let uu___ = fstar_refl_types_lid s in FStar_Syntax_Syntax.fvconst uu___
-let (mk_refl_syntax_lid_as_term : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s ->
-    let uu___ = fstar_refl_syntax_lid s in FStar_Syntax_Syntax.tconst uu___
-let (mk_refl_syntax_lid_as_fv : Prims.string -> FStar_Syntax_Syntax.fv) =
-  fun s ->
-    let uu___ = fstar_refl_syntax_lid s in FStar_Syntax_Syntax.fvconst uu___
-let (mk_refl_data_lid_as_term : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s ->
-    let uu___ = fstar_refl_data_lid s in FStar_Syntax_Syntax.tconst uu___
-let (mk_refl_data_lid_as_fv : Prims.string -> FStar_Syntax_Syntax.fv) =
-  fun s ->
-    let uu___ = fstar_refl_data_lid s in FStar_Syntax_Syntax.fvconst uu___
-let (mk_inspect_pack_pair : Prims.string -> (refl_constant * refl_constant))
-  =
-  fun s ->
-    let inspect_lid = fstar_refl_builtins_lid (Prims.op_Hat "inspect" s) in
-    let pack_lid = fstar_refl_builtins_lid (Prims.op_Hat "pack" s) in
-    let inspect_fv =
-      FStar_Syntax_Syntax.lid_as_fv inspect_lid
-        (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-        FStar_Pervasives_Native.None in
-    let pack_fv =
-      FStar_Syntax_Syntax.lid_as_fv pack_lid
-        (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-        FStar_Pervasives_Native.None in
-    let inspect =
-      let uu___ = FStar_Syntax_Syntax.fv_to_tm inspect_fv in
-      { lid = inspect_lid; fv = inspect_fv; t = uu___ } in
-    let pack =
-      let uu___ = FStar_Syntax_Syntax.fv_to_tm pack_fv in
-      { lid = pack_lid; fv = pack_fv; t = uu___ } in
-    (inspect, pack)
-let (uu___34 : (refl_constant * refl_constant)) = mk_inspect_pack_pair "_ln"
-let (fstar_refl_inspect_ln : refl_constant) =
-  match uu___34 with
-  | (fstar_refl_inspect_ln1, fstar_refl_pack_ln) -> fstar_refl_inspect_ln1
-let (fstar_refl_pack_ln : refl_constant) =
-  match uu___34 with
-  | (fstar_refl_inspect_ln1, fstar_refl_pack_ln1) -> fstar_refl_pack_ln1
-let (uu___41 : (refl_constant * refl_constant)) = mk_inspect_pack_pair "_fv"
-let (fstar_refl_inspect_fv : refl_constant) =
-  match uu___41 with
-  | (fstar_refl_inspect_fv1, fstar_refl_pack_fv) -> fstar_refl_inspect_fv1
-let (fstar_refl_pack_fv : refl_constant) =
-  match uu___41 with
-  | (fstar_refl_inspect_fv1, fstar_refl_pack_fv1) -> fstar_refl_pack_fv1
-let (uu___48 : (refl_constant * refl_constant)) = mk_inspect_pack_pair "_bv"
-let (fstar_refl_inspect_bv : refl_constant) =
-  match uu___48 with
-  | (fstar_refl_inspect_bv1, fstar_refl_pack_bv) -> fstar_refl_inspect_bv1
-let (fstar_refl_pack_bv : refl_constant) =
-  match uu___48 with
-  | (fstar_refl_inspect_bv1, fstar_refl_pack_bv1) -> fstar_refl_pack_bv1
-let (uu___55 : (refl_constant * refl_constant)) =
-  mk_inspect_pack_pair "_binder"
-let (fstar_refl_inspect_binder : refl_constant) =
-  match uu___55 with
-  | (fstar_refl_inspect_binder1, fstar_refl_pack_binder) ->
-      fstar_refl_inspect_binder1
-let (fstar_refl_pack_binder : refl_constant) =
-  match uu___55 with
-  | (fstar_refl_inspect_binder1, fstar_refl_pack_binder1) ->
-      fstar_refl_pack_binder1
-let (uu___62 : (refl_constant * refl_constant)) =
-  mk_inspect_pack_pair "_comp"
-let (fstar_refl_inspect_comp : refl_constant) =
-  match uu___62 with
-  | (fstar_refl_inspect_comp1, fstar_refl_pack_comp) ->
-      fstar_refl_inspect_comp1
-let (fstar_refl_pack_comp : refl_constant) =
-  match uu___62 with
-  | (fstar_refl_inspect_comp1, fstar_refl_pack_comp1) ->
-      fstar_refl_pack_comp1
-let (uu___69 : (refl_constant * refl_constant)) =
-  mk_inspect_pack_pair "_sigelt"
-let (fstar_refl_inspect_sigelt : refl_constant) =
-  match uu___69 with
-  | (fstar_refl_inspect_sigelt1, fstar_refl_pack_sigelt) ->
-      fstar_refl_inspect_sigelt1
-let (fstar_refl_pack_sigelt : refl_constant) =
-  match uu___69 with
-  | (fstar_refl_inspect_sigelt1, fstar_refl_pack_sigelt1) ->
-      fstar_refl_pack_sigelt1
-let (uu___76 : (refl_constant * refl_constant)) = mk_inspect_pack_pair "_lb"
-let (fstar_refl_inspect_lb : refl_constant) =
-  match uu___76 with
-  | (fstar_refl_inspect_lb1, fstar_refl_pack_lb) -> fstar_refl_inspect_lb1
-let (fstar_refl_pack_lb : refl_constant) =
-  match uu___76 with
-  | (fstar_refl_inspect_lb1, fstar_refl_pack_lb1) -> fstar_refl_pack_lb1
-let (uu___83 : (refl_constant * refl_constant)) =
-  mk_inspect_pack_pair "_universe"
-let (fstar_refl_inspect_universe : refl_constant) =
-  match uu___83 with
-  | (fstar_refl_inspect_universe1, fstar_refl_pack_universe) ->
-      fstar_refl_inspect_universe1
-let (fstar_refl_pack_universe : refl_constant) =
-  match uu___83 with
-  | (fstar_refl_inspect_universe1, fstar_refl_pack_universe1) ->
-      fstar_refl_pack_universe1
-let (fstar_refl_env : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "env"
-let (fstar_refl_env_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "env"
-let (fstar_refl_bv : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "bv"
-let (fstar_refl_bv_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "bv"
-let (fstar_refl_fv : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "fv"
-let (fstar_refl_fv_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "fv"
-let (fstar_refl_comp : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "comp"
-let (fstar_refl_comp_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "comp"
-let (fstar_refl_binder : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "binder"
-let (fstar_refl_binder_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "binder"
-let (fstar_refl_sigelt : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "sigelt"
-let (fstar_refl_sigelt_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "sigelt"
-let (fstar_refl_term : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "term"
-let (fstar_refl_term_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "term"
-let (fstar_refl_letbinding : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "letbinding"
-let (fstar_refl_letbinding_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "letbinding"
-let (fstar_refl_ident : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "ident"
-let (fstar_refl_ident_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "ident"
-let (fstar_refl_univ_name : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "univ_name"
-let (fstar_refl_univ_name_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "univ_name"
-let (fstar_refl_optionstate : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "optionstate"
-let (fstar_refl_optionstate_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "optionstate"
-let (fstar_refl_universe : FStar_Syntax_Syntax.term) =
-  mk_refl_types_lid_as_term "universe"
-let (fstar_refl_universe_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_types_lid_as_fv "universe"
-let (fstar_refl_aqualv : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "aqualv"
-let (fstar_refl_aqualv_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "aqualv"
-let (fstar_refl_comp_view : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "comp_view"
-let (fstar_refl_comp_view_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "comp_view"
-let (fstar_refl_term_view : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "term_view"
-let (fstar_refl_term_view_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "term_view"
-let (fstar_refl_pattern : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "pattern"
-let (fstar_refl_pattern_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "pattern"
-let (fstar_refl_branch : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "branch"
-let (fstar_refl_branch_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "branch"
-let (fstar_refl_bv_view : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "bv_view"
-let (fstar_refl_bv_view_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "bv_view"
-let (fstar_refl_vconst : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "vconst"
-let (fstar_refl_vconst_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "vconst"
-let (fstar_refl_lb_view : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "lb_view"
-let (fstar_refl_lb_view_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "lb_view"
-let (fstar_refl_sigelt_view : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "sigelt_view"
-let (fstar_refl_sigelt_view_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "sigelt_view"
-let (fstar_refl_exp : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "exp"
-let (fstar_refl_exp_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "exp"
-let (fstar_refl_qualifier : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "qualifier"
-let (fstar_refl_qualifier_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "qualifier"
-let (fstar_refl_universe_view : FStar_Syntax_Syntax.term) =
-  mk_refl_data_lid_as_term "universe_view"
-let (fstar_refl_universe_view_fv : FStar_Syntax_Syntax.fv) =
-  mk_refl_data_lid_as_fv "universe_view"
-let (ref_Mk_bv : refl_constant) =
-  let lid = fstar_refl_data_lid "Mkbv_view" in
-  let attr =
-    let uu___ =
-      let uu___1 = fstar_refl_data_lid "bv_view" in
-      let uu___2 =
-        let uu___3 =
-          FStar_Ident.mk_ident ("bv_ppname", FStar_Compiler_Range.dummyRange) in
-        let uu___4 =
-          let uu___5 =
-            FStar_Ident.mk_ident
-              ("bv_index", FStar_Compiler_Range.dummyRange) in
-          let uu___6 =
-            let uu___7 =
-              FStar_Ident.mk_ident
-                ("bv_sort", FStar_Compiler_Range.dummyRange) in
-            [uu___7] in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      (uu___1, uu___2) in
-    FStar_Syntax_Syntax.Record_ctor uu___ in
-  let fv =
-    FStar_Syntax_Syntax.lid_as_fv lid FStar_Syntax_Syntax.delta_constant
-      (FStar_Pervasives_Native.Some attr) in
-  let uu___ = FStar_Syntax_Syntax.fv_to_tm fv in { lid; fv; t = uu___ }
-let (ref_Mk_lb : refl_constant) =
-  let lid = fstar_refl_data_lid "Mklb_view" in
-  let attr =
-    let uu___ =
-      let uu___1 = fstar_refl_data_lid "lb_view" in
-      let uu___2 =
-        let uu___3 =
-          FStar_Ident.mk_ident ("lb_fv", FStar_Compiler_Range.dummyRange) in
-        let uu___4 =
-          let uu___5 =
-            FStar_Ident.mk_ident ("lb_us", FStar_Compiler_Range.dummyRange) in
-          let uu___6 =
-            let uu___7 =
-              FStar_Ident.mk_ident
-                ("lb_typ", FStar_Compiler_Range.dummyRange) in
-            let uu___8 =
-              let uu___9 =
-                FStar_Ident.mk_ident
-                  ("lb_def", FStar_Compiler_Range.dummyRange) in
-              [uu___9] in
-            uu___7 :: uu___8 in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      (uu___1, uu___2) in
-    FStar_Syntax_Syntax.Record_ctor uu___ in
-  let fv =
-    FStar_Syntax_Syntax.lid_as_fv lid FStar_Syntax_Syntax.delta_constant
-      (FStar_Pervasives_Native.Some attr) in
-  let uu___ = FStar_Syntax_Syntax.fv_to_tm fv in { lid; fv; t = uu___ }
-let (ref_Q_Explicit : refl_constant) = fstar_refl_data_const "Q_Explicit"
-let (ref_Q_Implicit : refl_constant) = fstar_refl_data_const "Q_Implicit"
-let (ref_Q_Meta : refl_constant) = fstar_refl_data_const "Q_Meta"
-let (ref_C_Unit : refl_constant) = fstar_refl_data_const "C_Unit"
-let (ref_C_True : refl_constant) = fstar_refl_data_const "C_True"
-let (ref_C_False : refl_constant) = fstar_refl_data_const "C_False"
-let (ref_C_Int : refl_constant) = fstar_refl_data_const "C_Int"
-let (ref_C_String : refl_constant) = fstar_refl_data_const "C_String"
-let (ref_C_Range : refl_constant) = fstar_refl_data_const "C_Range"
-let (ref_C_Reify : refl_constant) = fstar_refl_data_const "C_Reify"
-let (ref_C_Reflect : refl_constant) = fstar_refl_data_const "C_Reflect"
-let (ref_Pat_Constant : refl_constant) = fstar_refl_data_const "Pat_Constant"
-let (ref_Pat_Cons : refl_constant) = fstar_refl_data_const "Pat_Cons"
-let (ref_Pat_Var : refl_constant) = fstar_refl_data_const "Pat_Var"
-let (ref_Pat_Wild : refl_constant) = fstar_refl_data_const "Pat_Wild"
-let (ref_Pat_Dot_Term : refl_constant) = fstar_refl_data_const "Pat_Dot_Term"
-let (ref_Uv_Zero : refl_constant) = fstar_refl_data_const "Uv_Zero"
-let (ref_Uv_Succ : refl_constant) = fstar_refl_data_const "Uv_Succ"
-let (ref_Uv_Max : refl_constant) = fstar_refl_data_const "Uv_Max"
-let (ref_Uv_BVar : refl_constant) = fstar_refl_data_const "Uv_BVar"
-let (ref_Uv_Name : refl_constant) = fstar_refl_data_const "Uv_Name"
-let (ref_Uv_Unif : refl_constant) = fstar_refl_data_const "Uv_Unif"
-let (ref_Uv_Unk : refl_constant) = fstar_refl_data_const "Uv_Unk"
-let (ref_Tv_Var : refl_constant) = fstar_refl_data_const "Tv_Var"
-let (ref_Tv_BVar : refl_constant) = fstar_refl_data_const "Tv_BVar"
-let (ref_Tv_FVar : refl_constant) = fstar_refl_data_const "Tv_FVar"
-let (ref_Tv_UInst : refl_constant) = fstar_refl_data_const "Tv_UInst"
-let (ref_Tv_App : refl_constant) = fstar_refl_data_const "Tv_App"
-let (ref_Tv_Abs : refl_constant) = fstar_refl_data_const "Tv_Abs"
-let (ref_Tv_Arrow : refl_constant) = fstar_refl_data_const "Tv_Arrow"
-let (ref_Tv_Type : refl_constant) = fstar_refl_data_const "Tv_Type"
-let (ref_Tv_Refine : refl_constant) = fstar_refl_data_const "Tv_Refine"
-let (ref_Tv_Const : refl_constant) = fstar_refl_data_const "Tv_Const"
-let (ref_Tv_Uvar : refl_constant) = fstar_refl_data_const "Tv_Uvar"
-let (ref_Tv_Let : refl_constant) = fstar_refl_data_const "Tv_Let"
-let (ref_Tv_Match : refl_constant) = fstar_refl_data_const "Tv_Match"
-let (ref_Tv_AscT : refl_constant) = fstar_refl_data_const "Tv_AscribedT"
-let (ref_Tv_AscC : refl_constant) = fstar_refl_data_const "Tv_AscribedC"
-let (ref_Tv_Unknown : refl_constant) = fstar_refl_data_const "Tv_Unknown"
-let (ref_C_Total : refl_constant) = fstar_refl_data_const "C_Total"
-let (ref_C_GTotal : refl_constant) = fstar_refl_data_const "C_GTotal"
-let (ref_C_Lemma : refl_constant) = fstar_refl_data_const "C_Lemma"
-let (ref_C_Eff : refl_constant) = fstar_refl_data_const "C_Eff"
-let (ref_Sg_Let : refl_constant) = fstar_refl_data_const "Sg_Let"
-let (ref_Sg_Inductive : refl_constant) = fstar_refl_data_const "Sg_Inductive"
-let (ref_Sg_Val : refl_constant) = fstar_refl_data_const "Sg_Val"
-let (ref_Unk : refl_constant) = fstar_refl_data_const "Unk"
-let (ref_qual_Assumption : refl_constant) =
-  fstar_refl_data_const "Assumption"
-let (ref_qual_New : refl_constant) = fstar_refl_data_const "New"
-let (ref_qual_Private : refl_constant) = fstar_refl_data_const "Private"
-let (ref_qual_Unfold_for_unification_and_vcgen : refl_constant) =
-  fstar_refl_data_const "Unfold_for_unification_and_vcgen"
-let (ref_qual_Visible_default : refl_constant) =
-  fstar_refl_data_const "Visible_default"
-let (ref_qual_Irreducible : refl_constant) =
-  fstar_refl_data_const "Irreducible"
-let (ref_qual_Inline_for_extraction : refl_constant) =
-  fstar_refl_data_const "Inline_for_extraction"
-let (ref_qual_NoExtract : refl_constant) = fstar_refl_data_const "NoExtract"
-let (ref_qual_Noeq : refl_constant) = fstar_refl_data_const "Noeq"
-let (ref_qual_Unopteq : refl_constant) = fstar_refl_data_const "Unopteq"
-let (ref_qual_TotalEffect : refl_constant) =
-  fstar_refl_data_const "TotalEffect"
-let (ref_qual_Logic : refl_constant) = fstar_refl_data_const "Logic"
-let (ref_qual_Reifiable : refl_constant) = fstar_refl_data_const "Reifiable"
-let (ref_qual_Reflectable : refl_constant) =
-  fstar_refl_data_const "Reflectable"
-let (ref_qual_Discriminator : refl_constant) =
-  fstar_refl_data_const "Discriminator"
-let (ref_qual_Projector : refl_constant) = fstar_refl_data_const "Projector"
-let (ref_qual_RecordType : refl_constant) =
-  fstar_refl_data_const "RecordType"
-let (ref_qual_RecordConstructor : refl_constant) =
-  fstar_refl_data_const "RecordConstructor"
-let (ref_qual_Action : refl_constant) = fstar_refl_data_const "Action"
-let (ref_qual_ExceptionConstructor : refl_constant) =
-  fstar_refl_data_const "ExceptionConstructor"
-let (ref_qual_HasMaskedEffect : refl_constant) =
-  fstar_refl_data_const "HasMaskedEffect"
-let (ref_qual_Effect : refl_constant) = fstar_refl_data_const "Effect"
-let (ref_qual_OnlyName : refl_constant) = fstar_refl_data_const "OnlyName"
-let (ref_E_Unit : refl_constant) = fstar_refl_data_const "Unit"
-let (ref_E_Var : refl_constant) = fstar_refl_data_const "Var"
-let (ref_E_Mult : refl_constant) = fstar_refl_data_const "Mult"
-let (t_exp : FStar_Syntax_Syntax.term) =
-  let uu___ =
-    FStar_Ident.lid_of_path ["FStar"; "Reflection"; "Data"; "exp"]
-      FStar_Compiler_Range.dummyRange in
-  FStar_Syntax_Syntax.tconst uu___
-let (ord_Lt_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Order"; "Lt"]
-    FStar_Compiler_Range.dummyRange
-let (ord_Eq_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Order"; "Eq"]
-    FStar_Compiler_Range.dummyRange
-let (ord_Gt_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["FStar"; "Order"; "Gt"]
-    FStar_Compiler_Range.dummyRange
-let (ord_Lt : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tdataconstr ord_Lt_lid
-let (ord_Eq : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tdataconstr ord_Eq_lid
-let (ord_Gt : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tdataconstr ord_Gt_lid
-let (ord_Lt_fv : FStar_Syntax_Syntax.fv) =
-  FStar_Syntax_Syntax.lid_as_fv ord_Lt_lid FStar_Syntax_Syntax.delta_constant
-    (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
-let (ord_Eq_fv : FStar_Syntax_Syntax.fv) =
-  FStar_Syntax_Syntax.lid_as_fv ord_Eq_lid FStar_Syntax_Syntax.delta_constant
-    (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
-let (ord_Gt_fv : FStar_Syntax_Syntax.fv) =
-  FStar_Syntax_Syntax.lid_as_fv ord_Gt_lid FStar_Syntax_Syntax.delta_constant
-    (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Reflection_Data.ml b/src/ocaml-output/FStar_Reflection_Data.ml
deleted file mode 100644
index 25957025e66..00000000000
--- a/src/ocaml-output/FStar_Reflection_Data.ml
+++ /dev/null
@@ -1,446 +0,0 @@
-open Prims
-type name = Prims.string Prims.list
-type typ = FStar_Syntax_Syntax.term
-type binders = FStar_Syntax_Syntax.binder Prims.list
-type vconst =
-  | C_Unit 
-  | C_Int of FStar_BigInt.t 
-  | C_True 
-  | C_False 
-  | C_String of Prims.string 
-  | C_Range of FStar_Compiler_Range.range 
-  | C_Reify 
-  | C_Reflect of name 
-let (uu___is_C_Unit : vconst -> Prims.bool) =
-  fun projectee -> match projectee with | C_Unit -> true | uu___ -> false
-let (uu___is_C_Int : vconst -> Prims.bool) =
-  fun projectee -> match projectee with | C_Int _0 -> true | uu___ -> false
-let (__proj__C_Int__item___0 : vconst -> FStar_BigInt.t) =
-  fun projectee -> match projectee with | C_Int _0 -> _0
-let (uu___is_C_True : vconst -> Prims.bool) =
-  fun projectee -> match projectee with | C_True -> true | uu___ -> false
-let (uu___is_C_False : vconst -> Prims.bool) =
-  fun projectee -> match projectee with | C_False -> true | uu___ -> false
-let (uu___is_C_String : vconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | C_String _0 -> true | uu___ -> false
-let (__proj__C_String__item___0 : vconst -> Prims.string) =
-  fun projectee -> match projectee with | C_String _0 -> _0
-let (uu___is_C_Range : vconst -> Prims.bool) =
-  fun projectee -> match projectee with | C_Range _0 -> true | uu___ -> false
-let (__proj__C_Range__item___0 : vconst -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | C_Range _0 -> _0
-let (uu___is_C_Reify : vconst -> Prims.bool) =
-  fun projectee -> match projectee with | C_Reify -> true | uu___ -> false
-let (uu___is_C_Reflect : vconst -> Prims.bool) =
-  fun projectee ->
-    match projectee with | C_Reflect _0 -> true | uu___ -> false
-let (__proj__C_Reflect__item___0 : vconst -> name) =
-  fun projectee -> match projectee with | C_Reflect _0 -> _0
-type universes = FStar_Syntax_Syntax.universe Prims.list
-type pattern =
-  | Pat_Constant of vconst 
-  | Pat_Cons of (FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universe
-  Prims.list FStar_Pervasives_Native.option * (pattern * Prims.bool)
-  Prims.list) 
-  | Pat_Var of FStar_Syntax_Syntax.bv 
-  | Pat_Wild of FStar_Syntax_Syntax.bv 
-  | Pat_Dot_Term of FStar_Syntax_Syntax.term FStar_Pervasives_Native.option 
-let (uu___is_Pat_Constant : pattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_Constant _0 -> true | uu___ -> false
-let (__proj__Pat_Constant__item___0 : pattern -> vconst) =
-  fun projectee -> match projectee with | Pat_Constant _0 -> _0
-let (uu___is_Pat_Cons : pattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_Cons _0 -> true | uu___ -> false
-let (__proj__Pat_Cons__item___0 :
-  pattern ->
-    (FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universe Prims.list
-      FStar_Pervasives_Native.option * (pattern * Prims.bool) Prims.list))
-  = fun projectee -> match projectee with | Pat_Cons _0 -> _0
-let (uu___is_Pat_Var : pattern -> Prims.bool) =
-  fun projectee -> match projectee with | Pat_Var _0 -> true | uu___ -> false
-let (__proj__Pat_Var__item___0 : pattern -> FStar_Syntax_Syntax.bv) =
-  fun projectee -> match projectee with | Pat_Var _0 -> _0
-let (uu___is_Pat_Wild : pattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_Wild _0 -> true | uu___ -> false
-let (__proj__Pat_Wild__item___0 : pattern -> FStar_Syntax_Syntax.bv) =
-  fun projectee -> match projectee with | Pat_Wild _0 -> _0
-let (uu___is_Pat_Dot_Term : pattern -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_Dot_Term _0 -> true | uu___ -> false
-let (__proj__Pat_Dot_Term__item___0 :
-  pattern -> FStar_Syntax_Syntax.term FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | Pat_Dot_Term _0 -> _0
-type branch = (pattern * FStar_Syntax_Syntax.term)
-type aqualv =
-  | Q_Implicit 
-  | Q_Explicit 
-  | Q_Meta of FStar_Syntax_Syntax.term 
-let (uu___is_Q_Implicit : aqualv -> Prims.bool) =
-  fun projectee -> match projectee with | Q_Implicit -> true | uu___ -> false
-let (uu___is_Q_Explicit : aqualv -> Prims.bool) =
-  fun projectee -> match projectee with | Q_Explicit -> true | uu___ -> false
-let (uu___is_Q_Meta : aqualv -> Prims.bool) =
-  fun projectee -> match projectee with | Q_Meta _0 -> true | uu___ -> false
-let (__proj__Q_Meta__item___0 : aqualv -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | Q_Meta _0 -> _0
-type argv = (FStar_Syntax_Syntax.term * aqualv)
-type universe_view =
-  | Uv_Zero 
-  | Uv_Succ of FStar_Syntax_Syntax.universe 
-  | Uv_Max of universes 
-  | Uv_BVar of FStar_BigInt.t 
-  | Uv_Name of (Prims.string * FStar_Compiler_Range.range) 
-  | Uv_Unif of FStar_Syntax_Syntax.universe_uvar 
-  | Uv_Unk 
-let (uu___is_Uv_Zero : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_Zero -> true | uu___ -> false
-let (uu___is_Uv_Succ : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_Succ _0 -> true | uu___ -> false
-let (__proj__Uv_Succ__item___0 :
-  universe_view -> FStar_Syntax_Syntax.universe) =
-  fun projectee -> match projectee with | Uv_Succ _0 -> _0
-let (uu___is_Uv_Max : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_Max _0 -> true | uu___ -> false
-let (__proj__Uv_Max__item___0 : universe_view -> universes) =
-  fun projectee -> match projectee with | Uv_Max _0 -> _0
-let (uu___is_Uv_BVar : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_BVar _0 -> true | uu___ -> false
-let (__proj__Uv_BVar__item___0 : universe_view -> FStar_BigInt.t) =
-  fun projectee -> match projectee with | Uv_BVar _0 -> _0
-let (uu___is_Uv_Name : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_Name _0 -> true | uu___ -> false
-let (__proj__Uv_Name__item___0 :
-  universe_view -> (Prims.string * FStar_Compiler_Range.range)) =
-  fun projectee -> match projectee with | Uv_Name _0 -> _0
-let (uu___is_Uv_Unif : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_Unif _0 -> true | uu___ -> false
-let (__proj__Uv_Unif__item___0 :
-  universe_view -> FStar_Syntax_Syntax.universe_uvar) =
-  fun projectee -> match projectee with | Uv_Unif _0 -> _0
-let (uu___is_Uv_Unk : universe_view -> Prims.bool) =
-  fun projectee -> match projectee with | Uv_Unk -> true | uu___ -> false
-type term_view =
-  | Tv_Var of FStar_Syntax_Syntax.bv 
-  | Tv_BVar of FStar_Syntax_Syntax.bv 
-  | Tv_FVar of FStar_Syntax_Syntax.fv 
-  | Tv_UInst of (FStar_Syntax_Syntax.fv * universes) 
-  | Tv_App of (FStar_Syntax_Syntax.term * argv) 
-  | Tv_Abs of (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.term) 
-  | Tv_Arrow of (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.comp) 
-  | Tv_Type of FStar_Syntax_Syntax.universe 
-  | Tv_Refine of (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term) 
-  | Tv_Const of vconst 
-  | Tv_Uvar of (FStar_BigInt.t * FStar_Syntax_Syntax.ctx_uvar_and_subst) 
-  | Tv_Let of (Prims.bool * FStar_Syntax_Syntax.term Prims.list *
-  FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term *
-  FStar_Syntax_Syntax.term) 
-  | Tv_Match of (FStar_Syntax_Syntax.term *
-  FStar_Syntax_Syntax.match_returns_ascription FStar_Pervasives_Native.option
-  * branch Prims.list) 
-  | Tv_AscribedT of (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option * Prims.bool) 
-  | Tv_AscribedC of (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option * Prims.bool) 
-  | Tv_Unknown 
-let (uu___is_Tv_Var : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_Var _0 -> true | uu___ -> false
-let (__proj__Tv_Var__item___0 : term_view -> FStar_Syntax_Syntax.bv) =
-  fun projectee -> match projectee with | Tv_Var _0 -> _0
-let (uu___is_Tv_BVar : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_BVar _0 -> true | uu___ -> false
-let (__proj__Tv_BVar__item___0 : term_view -> FStar_Syntax_Syntax.bv) =
-  fun projectee -> match projectee with | Tv_BVar _0 -> _0
-let (uu___is_Tv_FVar : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_FVar _0 -> true | uu___ -> false
-let (__proj__Tv_FVar__item___0 : term_view -> FStar_Syntax_Syntax.fv) =
-  fun projectee -> match projectee with | Tv_FVar _0 -> _0
-let (uu___is_Tv_UInst : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_UInst _0 -> true | uu___ -> false
-let (__proj__Tv_UInst__item___0 :
-  term_view -> (FStar_Syntax_Syntax.fv * universes)) =
-  fun projectee -> match projectee with | Tv_UInst _0 -> _0
-let (uu___is_Tv_App : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_App _0 -> true | uu___ -> false
-let (__proj__Tv_App__item___0 :
-  term_view -> (FStar_Syntax_Syntax.term * argv)) =
-  fun projectee -> match projectee with | Tv_App _0 -> _0
-let (uu___is_Tv_Abs : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_Abs _0 -> true | uu___ -> false
-let (__proj__Tv_Abs__item___0 :
-  term_view -> (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.term)) =
-  fun projectee -> match projectee with | Tv_Abs _0 -> _0
-let (uu___is_Tv_Arrow : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_Arrow _0 -> true | uu___ -> false
-let (__proj__Tv_Arrow__item___0 :
-  term_view -> (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.comp)) =
-  fun projectee -> match projectee with | Tv_Arrow _0 -> _0
-let (uu___is_Tv_Type : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_Type _0 -> true | uu___ -> false
-let (__proj__Tv_Type__item___0 : term_view -> FStar_Syntax_Syntax.universe) =
-  fun projectee -> match projectee with | Tv_Type _0 -> _0
-let (uu___is_Tv_Refine : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_Refine _0 -> true | uu___ -> false
-let (__proj__Tv_Refine__item___0 :
-  term_view -> (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term)) =
-  fun projectee -> match projectee with | Tv_Refine _0 -> _0
-let (uu___is_Tv_Const : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_Const _0 -> true | uu___ -> false
-let (__proj__Tv_Const__item___0 : term_view -> vconst) =
-  fun projectee -> match projectee with | Tv_Const _0 -> _0
-let (uu___is_Tv_Uvar : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_Uvar _0 -> true | uu___ -> false
-let (__proj__Tv_Uvar__item___0 :
-  term_view -> (FStar_BigInt.t * FStar_Syntax_Syntax.ctx_uvar_and_subst)) =
-  fun projectee -> match projectee with | Tv_Uvar _0 -> _0
-let (uu___is_Tv_Let : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_Let _0 -> true | uu___ -> false
-let (__proj__Tv_Let__item___0 :
-  term_view ->
-    (Prims.bool * FStar_Syntax_Syntax.term Prims.list *
-      FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.term))
-  = fun projectee -> match projectee with | Tv_Let _0 -> _0
-let (uu___is_Tv_Match : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_Match _0 -> true | uu___ -> false
-let (__proj__Tv_Match__item___0 :
-  term_view ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.match_returns_ascription
-      FStar_Pervasives_Native.option * branch Prims.list))
-  = fun projectee -> match projectee with | Tv_Match _0 -> _0
-let (uu___is_Tv_AscribedT : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_AscribedT _0 -> true | uu___ -> false
-let (__proj__Tv_AscribedT__item___0 :
-  term_view ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option * Prims.bool))
-  = fun projectee -> match projectee with | Tv_AscribedT _0 -> _0
-let (uu___is_Tv_AscribedC : term_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tv_AscribedC _0 -> true | uu___ -> false
-let (__proj__Tv_AscribedC__item___0 :
-  term_view ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option * Prims.bool))
-  = fun projectee -> match projectee with | Tv_AscribedC _0 -> _0
-let (uu___is_Tv_Unknown : term_view -> Prims.bool) =
-  fun projectee -> match projectee with | Tv_Unknown -> true | uu___ -> false
-type qualifier =
-  | Assumption 
-  | New 
-  | Private 
-  | Unfold_for_unification_and_vcgen 
-  | Visible_default 
-  | Irreducible 
-  | Inline_for_extraction 
-  | NoExtract 
-  | Noeq 
-  | Unopteq 
-  | TotalEffect 
-  | Logic 
-  | Reifiable 
-  | Reflectable of FStar_Ident.lid 
-  | Discriminator of FStar_Ident.lid 
-  | Projector of (FStar_Ident.lid * FStar_Ident.ident) 
-  | RecordType of (FStar_Ident.ident Prims.list * FStar_Ident.ident
-  Prims.list) 
-  | RecordConstructor of (FStar_Ident.ident Prims.list * FStar_Ident.ident
-  Prims.list) 
-  | Action of FStar_Ident.lid 
-  | ExceptionConstructor 
-  | HasMaskedEffect 
-  | Effect 
-  | OnlyName 
-let (uu___is_Assumption : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Assumption -> true | uu___ -> false
-let (uu___is_New : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | New -> true | uu___ -> false
-let (uu___is_Private : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Private -> true | uu___ -> false
-let (uu___is_Unfold_for_unification_and_vcgen : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Unfold_for_unification_and_vcgen -> true
-    | uu___ -> false
-let (uu___is_Visible_default : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Visible_default -> true | uu___ -> false
-let (uu___is_Irreducible : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Irreducible -> true | uu___ -> false
-let (uu___is_Inline_for_extraction : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Inline_for_extraction -> true | uu___ -> false
-let (uu___is_NoExtract : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | NoExtract -> true | uu___ -> false
-let (uu___is_Noeq : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Noeq -> true | uu___ -> false
-let (uu___is_Unopteq : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Unopteq -> true | uu___ -> false
-let (uu___is_TotalEffect : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TotalEffect -> true | uu___ -> false
-let (uu___is_Logic : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Logic -> true | uu___ -> false
-let (uu___is_Reifiable : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Reifiable -> true | uu___ -> false
-let (uu___is_Reflectable : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Reflectable _0 -> true | uu___ -> false
-let (__proj__Reflectable__item___0 : qualifier -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Reflectable _0 -> _0
-let (uu___is_Discriminator : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Discriminator _0 -> true | uu___ -> false
-let (__proj__Discriminator__item___0 : qualifier -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Discriminator _0 -> _0
-let (uu___is_Projector : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Projector _0 -> true | uu___ -> false
-let (__proj__Projector__item___0 :
-  qualifier -> (FStar_Ident.lid * FStar_Ident.ident)) =
-  fun projectee -> match projectee with | Projector _0 -> _0
-let (uu___is_RecordType : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RecordType _0 -> true | uu___ -> false
-let (__proj__RecordType__item___0 :
-  qualifier -> (FStar_Ident.ident Prims.list * FStar_Ident.ident Prims.list))
-  = fun projectee -> match projectee with | RecordType _0 -> _0
-let (uu___is_RecordConstructor : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RecordConstructor _0 -> true | uu___ -> false
-let (__proj__RecordConstructor__item___0 :
-  qualifier -> (FStar_Ident.ident Prims.list * FStar_Ident.ident Prims.list))
-  = fun projectee -> match projectee with | RecordConstructor _0 -> _0
-let (uu___is_Action : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Action _0 -> true | uu___ -> false
-let (__proj__Action__item___0 : qualifier -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Action _0 -> _0
-let (uu___is_ExceptionConstructor : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ExceptionConstructor -> true | uu___ -> false
-let (uu___is_HasMaskedEffect : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | HasMaskedEffect -> true | uu___ -> false
-let (uu___is_Effect : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Effect -> true | uu___ -> false
-let (uu___is_OnlyName : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | OnlyName -> true | uu___ -> false
-type qualifiers = qualifier Prims.list
-type bv_view =
-  {
-  bv_ppname: Prims.string ;
-  bv_index: FStar_BigInt.t ;
-  bv_sort: typ }
-let (__proj__Mkbv_view__item__bv_ppname : bv_view -> Prims.string) =
-  fun projectee ->
-    match projectee with | { bv_ppname; bv_index; bv_sort;_} -> bv_ppname
-let (__proj__Mkbv_view__item__bv_index : bv_view -> FStar_BigInt.t) =
-  fun projectee ->
-    match projectee with | { bv_ppname; bv_index; bv_sort;_} -> bv_index
-let (__proj__Mkbv_view__item__bv_sort : bv_view -> typ) =
-  fun projectee ->
-    match projectee with | { bv_ppname; bv_index; bv_sort;_} -> bv_sort
-type binder_view =
-  (FStar_Syntax_Syntax.bv * (aqualv * FStar_Syntax_Syntax.term Prims.list))
-type comp_view =
-  | C_Total of typ 
-  | C_GTotal of typ 
-  | C_Lemma of (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-  FStar_Syntax_Syntax.term) 
-  | C_Eff of (universes * name * FStar_Syntax_Syntax.term * argv Prims.list *
-  FStar_Syntax_Syntax.term Prims.list) 
-let (uu___is_C_Total : comp_view -> Prims.bool) =
-  fun projectee -> match projectee with | C_Total _0 -> true | uu___ -> false
-let (__proj__C_Total__item___0 : comp_view -> typ) =
-  fun projectee -> match projectee with | C_Total _0 -> _0
-let (uu___is_C_GTotal : comp_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | C_GTotal _0 -> true | uu___ -> false
-let (__proj__C_GTotal__item___0 : comp_view -> typ) =
-  fun projectee -> match projectee with | C_GTotal _0 -> _0
-let (uu___is_C_Lemma : comp_view -> Prims.bool) =
-  fun projectee -> match projectee with | C_Lemma _0 -> true | uu___ -> false
-let (__proj__C_Lemma__item___0 :
-  comp_view ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.term))
-  = fun projectee -> match projectee with | C_Lemma _0 -> _0
-let (uu___is_C_Eff : comp_view -> Prims.bool) =
-  fun projectee -> match projectee with | C_Eff _0 -> true | uu___ -> false
-let (__proj__C_Eff__item___0 :
-  comp_view ->
-    (universes * name * FStar_Syntax_Syntax.term * argv Prims.list *
-      FStar_Syntax_Syntax.term Prims.list))
-  = fun projectee -> match projectee with | C_Eff _0 -> _0
-type ctor = (name * typ)
-type lb_view =
-  {
-  lb_fv: FStar_Syntax_Syntax.fv ;
-  lb_us: FStar_Syntax_Syntax.univ_name Prims.list ;
-  lb_typ: typ ;
-  lb_def: FStar_Syntax_Syntax.term }
-let (__proj__Mklb_view__item__lb_fv : lb_view -> FStar_Syntax_Syntax.fv) =
-  fun projectee ->
-    match projectee with | { lb_fv; lb_us; lb_typ; lb_def;_} -> lb_fv
-let (__proj__Mklb_view__item__lb_us :
-  lb_view -> FStar_Syntax_Syntax.univ_name Prims.list) =
-  fun projectee ->
-    match projectee with | { lb_fv; lb_us; lb_typ; lb_def;_} -> lb_us
-let (__proj__Mklb_view__item__lb_typ : lb_view -> typ) =
-  fun projectee ->
-    match projectee with | { lb_fv; lb_us; lb_typ; lb_def;_} -> lb_typ
-let (__proj__Mklb_view__item__lb_def : lb_view -> FStar_Syntax_Syntax.term) =
-  fun projectee ->
-    match projectee with | { lb_fv; lb_us; lb_typ; lb_def;_} -> lb_def
-type sigelt_view =
-  | Sg_Let of (Prims.bool * FStar_Syntax_Syntax.letbinding Prims.list) 
-  | Sg_Inductive of (name * FStar_Syntax_Syntax.univ_name Prims.list *
-  FStar_Syntax_Syntax.binder Prims.list * typ * ctor Prims.list) 
-  | Sg_Val of (name * FStar_Syntax_Syntax.univ_name Prims.list * typ) 
-  | Unk 
-let (uu___is_Sg_Let : sigelt_view -> Prims.bool) =
-  fun projectee -> match projectee with | Sg_Let _0 -> true | uu___ -> false
-let (__proj__Sg_Let__item___0 :
-  sigelt_view -> (Prims.bool * FStar_Syntax_Syntax.letbinding Prims.list)) =
-  fun projectee -> match projectee with | Sg_Let _0 -> _0
-let (uu___is_Sg_Inductive : sigelt_view -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sg_Inductive _0 -> true | uu___ -> false
-let (__proj__Sg_Inductive__item___0 :
-  sigelt_view ->
-    (name * FStar_Syntax_Syntax.univ_name Prims.list *
-      FStar_Syntax_Syntax.binder Prims.list * typ * ctor Prims.list))
-  = fun projectee -> match projectee with | Sg_Inductive _0 -> _0
-let (uu___is_Sg_Val : sigelt_view -> Prims.bool) =
-  fun projectee -> match projectee with | Sg_Val _0 -> true | uu___ -> false
-let (__proj__Sg_Val__item___0 :
-  sigelt_view -> (name * FStar_Syntax_Syntax.univ_name Prims.list * typ)) =
-  fun projectee -> match projectee with | Sg_Val _0 -> _0
-let (uu___is_Unk : sigelt_view -> Prims.bool) =
-  fun projectee -> match projectee with | Unk -> true | uu___ -> false
-type var = FStar_BigInt.t
-type exp =
-  | Unit 
-  | Var of var 
-  | Mult of (exp * exp) 
-let (uu___is_Unit : exp -> Prims.bool) =
-  fun projectee -> match projectee with | Unit -> true | uu___ -> false
-let (uu___is_Var : exp -> Prims.bool) =
-  fun projectee -> match projectee with | Var _0 -> true | uu___ -> false
-let (__proj__Var__item___0 : exp -> var) =
-  fun projectee -> match projectee with | Var _0 -> _0
-let (uu___is_Mult : exp -> Prims.bool) =
-  fun projectee -> match projectee with | Mult _0 -> true | uu___ -> false
-let (__proj__Mult__item___0 : exp -> (exp * exp)) =
-  fun projectee -> match projectee with | Mult _0 -> _0
-type decls = FStar_Syntax_Syntax.sigelt Prims.list
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Reflection_Embeddings.ml b/src/ocaml-output/FStar_Reflection_Embeddings.ml
deleted file mode 100644
index 03695ff56da..00000000000
--- a/src/ocaml-output/FStar_Reflection_Embeddings.ml
+++ /dev/null
@@ -1,2612 +0,0 @@
-open Prims
-let mk_emb :
-  'uuuuu .
-    (FStar_Compiler_Range.range -> 'uuuuu -> FStar_Syntax_Syntax.term) ->
-      (Prims.bool ->
-         FStar_Syntax_Syntax.term -> 'uuuuu FStar_Pervasives_Native.option)
-        ->
-        FStar_Syntax_Syntax.term -> 'uuuuu FStar_Syntax_Embeddings.embedding
-  =
-  fun f ->
-    fun g ->
-      fun t ->
-        let uu___ = FStar_Syntax_Embeddings.term_as_fv t in
-        FStar_Syntax_Embeddings.mk_emb
-          (fun x -> fun r -> fun _topt -> fun _norm -> f r x)
-          (fun x -> fun w -> fun _norm -> g w x) uu___
-let embed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Compiler_Range.range -> 'uuuuu -> FStar_Syntax_Syntax.term
-  =
-  fun e ->
-    fun r ->
-      fun x ->
-        let uu___ = FStar_Syntax_Embeddings.embed e x in
-        uu___ r FStar_Pervasives_Native.None
-          FStar_Syntax_Embeddings.id_norm_cb
-let unembed' :
-  'uuuuu .
-    Prims.bool ->
-      'uuuuu FStar_Syntax_Embeddings.embedding ->
-        FStar_Syntax_Syntax.term -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun w ->
-    fun e ->
-      fun x ->
-        let uu___ = FStar_Syntax_Embeddings.unembed e x in
-        uu___ w FStar_Syntax_Embeddings.id_norm_cb
-let (e_bv : FStar_Syntax_Syntax.bv FStar_Syntax_Embeddings.embedding) =
-  let embed_bv rng bv =
-    FStar_Syntax_Util.mk_lazy bv FStar_Reflection_Constants.fstar_refl_bv
-      FStar_Syntax_Syntax.Lazy_bv (FStar_Pervasives_Native.Some rng) in
-  let unembed_bv w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_bv;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded bv: %s" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_bv unembed_bv FStar_Reflection_Constants.fstar_refl_bv
-let (e_binder : FStar_Syntax_Syntax.binder FStar_Syntax_Embeddings.embedding)
-  =
-  let embed_binder rng b =
-    FStar_Syntax_Util.mk_lazy b FStar_Reflection_Constants.fstar_refl_binder
-      FStar_Syntax_Syntax.Lazy_binder (FStar_Pervasives_Native.Some rng) in
-  let unembed_binder w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_binder;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded binder: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_binder unembed_binder
-    FStar_Reflection_Constants.fstar_refl_binder
-let rec mapM_opt :
-  'a 'b .
-    ('a -> 'b FStar_Pervasives_Native.option) ->
-      'a Prims.list -> 'b Prims.list FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> FStar_Pervasives_Native.Some []
-      | x::xs ->
-          let uu___ = f x in
-          FStar_Compiler_Util.bind_opt uu___
-            (fun x1 ->
-               let uu___1 = mapM_opt f xs in
-               FStar_Compiler_Util.bind_opt uu___1
-                 (fun xs1 -> FStar_Pervasives_Native.Some (x1 :: xs1)))
-let (e_term_aq :
-  FStar_Syntax_Syntax.antiquotations ->
-    FStar_Syntax_Syntax.term FStar_Syntax_Embeddings.embedding)
-  =
-  fun aq ->
-    let embed_term rng t =
-      let qi =
-        {
-          FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_static;
-          FStar_Syntax_Syntax.antiquotes = aq
-        } in
-      FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_quoted (t, qi)) rng in
-    let rec unembed_term w t =
-      let apply_antiquotes t1 aq1 =
-        let uu___ =
-          mapM_opt
-            (fun uu___1 ->
-               match uu___1 with
-               | (bv, e) ->
-                   let uu___2 = unembed_term w e in
-                   FStar_Compiler_Util.bind_opt uu___2
-                     (fun e1 ->
-                        FStar_Pervasives_Native.Some
-                          (FStar_Syntax_Syntax.NT (bv, e1)))) aq1 in
-        FStar_Compiler_Util.bind_opt uu___
-          (fun s ->
-             let uu___1 = FStar_Syntax_Subst.subst s t1 in
-             FStar_Pervasives_Native.Some uu___1) in
-      let t1 = FStar_Syntax_Util.unmeta t in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t1 in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_quoted (tm, qi) ->
-          apply_antiquotes tm qi.FStar_Syntax_Syntax.antiquotes
-      | uu___1 ->
-          (if w
-           then
-             (let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                  FStar_Compiler_Util.format1 "Not an embedded term: %s"
-                    uu___5 in
-                (FStar_Errors.Warning_NotEmbedded, uu___4) in
-              FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___3)
-           else ();
-           FStar_Pervasives_Native.None) in
-    mk_emb embed_term unembed_term FStar_Syntax_Syntax.t_term
-let (e_term : FStar_Syntax_Syntax.term FStar_Syntax_Embeddings.embedding) =
-  e_term_aq []
-let (e_aqualv :
-  FStar_Reflection_Data.aqualv FStar_Syntax_Embeddings.embedding) =
-  let embed_aqualv rng q =
-    let r =
-      match q with
-      | FStar_Reflection_Data.Q_Explicit ->
-          FStar_Reflection_Constants.ref_Q_Explicit.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Q_Implicit ->
-          FStar_Reflection_Constants.ref_Q_Implicit.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Q_Meta t ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_term rng t in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Q_Meta.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange in
-    {
-      FStar_Syntax_Syntax.n = (r.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (r.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (r.FStar_Syntax_Syntax.hash_code)
-    } in
-  let unembed_aqualv w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Q_Explicit.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Q_Explicit
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Q_Implicit.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Q_Implicit
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (t2, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Q_Meta.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_term t2 in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun t3 ->
-                  FStar_Pervasives_Native.Some
-                    (FStar_Reflection_Data.Q_Meta t3))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1 "Not an embedded aqualv: %s"
-                       uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_aqualv unembed_aqualv
-    FStar_Reflection_Constants.fstar_refl_aqualv
-let (e_binders :
-  FStar_Syntax_Syntax.binders FStar_Syntax_Embeddings.embedding) =
-  FStar_Syntax_Embeddings.e_list e_binder
-let (e_fv : FStar_Syntax_Syntax.fv FStar_Syntax_Embeddings.embedding) =
-  let embed_fv rng fv =
-    FStar_Syntax_Util.mk_lazy fv FStar_Reflection_Constants.fstar_refl_fv
-      FStar_Syntax_Syntax.Lazy_fvar (FStar_Pervasives_Native.Some rng) in
-  let unembed_fv w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_fvar;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded fvar: %s" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_fv unembed_fv FStar_Reflection_Constants.fstar_refl_fv
-let (e_comp : FStar_Syntax_Syntax.comp FStar_Syntax_Embeddings.embedding) =
-  let embed_comp rng c =
-    FStar_Syntax_Util.mk_lazy c FStar_Reflection_Constants.fstar_refl_comp
-      FStar_Syntax_Syntax.Lazy_comp (FStar_Pervasives_Native.Some rng) in
-  let unembed_comp w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_comp;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded comp: %s" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_comp unembed_comp FStar_Reflection_Constants.fstar_refl_comp
-let (e_universe :
-  FStar_Syntax_Syntax.universe FStar_Syntax_Embeddings.embedding) =
-  let embed_universe rng u =
-    FStar_Syntax_Util.mk_lazy u
-      FStar_Reflection_Constants.fstar_refl_universe
-      FStar_Syntax_Syntax.Lazy_universe (FStar_Pervasives_Native.Some rng) in
-  let unembed_universe w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_universe;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded universe: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_universe unembed_universe
-    FStar_Reflection_Constants.fstar_refl_universe
-let (e_ident : FStar_Ident.ident FStar_Syntax_Embeddings.embedding) =
-  let repr =
-    FStar_Syntax_Embeddings.e_tuple2 FStar_Syntax_Embeddings.e_string
-      FStar_Syntax_Embeddings.e_range in
-  FStar_Syntax_Embeddings.embed_as repr FStar_Ident.mk_ident
-    (fun i ->
-       let uu___ = FStar_Ident.string_of_id i in
-       let uu___1 = FStar_Ident.range_of_id i in (uu___, uu___1))
-    (FStar_Pervasives_Native.Some FStar_Reflection_Constants.fstar_refl_ident)
-let (e_universe_view :
-  FStar_Reflection_Data.universe_view FStar_Syntax_Embeddings.embedding) =
-  let embed_universe_view rng uv =
-    match uv with
-    | FStar_Reflection_Data.Uv_Zero ->
-        FStar_Reflection_Constants.ref_Uv_Zero.FStar_Reflection_Constants.t
-    | FStar_Reflection_Data.Uv_Succ u ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed e_universe rng u in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Uv_Succ.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Uv_Max us ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Embeddings.e_list e_universe in
-              embed uu___3 rng us in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Uv_Max.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Uv_BVar n ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed FStar_Syntax_Embeddings.e_int rng n in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Uv_BVar.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Uv_Name i ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Syntax_Embeddings.e_tuple2
-                  FStar_Syntax_Embeddings.e_string
-                  FStar_Syntax_Embeddings.e_range in
-              embed uu___3 rng i in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Uv_Name.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Uv_Unif u ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Syntax_Util.mk_lazy u FStar_Syntax_Util.t_universe_uvar
-                FStar_Syntax_Syntax.Lazy_universe_uvar
-                FStar_Pervasives_Native.None in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Uv_Unif.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Uv_Unk ->
-        FStar_Reflection_Constants.ref_Uv_Unk.FStar_Reflection_Constants.t in
-  let unembed_universe_view w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_Zero.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Uv_Zero
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (u, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_Succ.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_universe u in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun u1 ->
-                  let uu___4 =
-                    FStar_Compiler_Effect.op_Bar_Greater u1
-                      (fun uu___5 -> FStar_Reflection_Data.Uv_Succ uu___5) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (fun uu___5 -> FStar_Pervasives_Native.Some uu___5))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (us, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_Max.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 =
-               let uu___4 = FStar_Syntax_Embeddings.e_list e_universe in
-               unembed' w uu___4 us in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun us1 ->
-                  let uu___4 =
-                    FStar_Compiler_Effect.op_Bar_Greater us1
-                      (fun uu___5 -> FStar_Reflection_Data.Uv_Max uu___5) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (fun uu___5 -> FStar_Pervasives_Native.Some uu___5))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (n, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_BVar.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w FStar_Syntax_Embeddings.e_int n in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun n1 ->
-                  let uu___4 =
-                    FStar_Compiler_Effect.op_Bar_Greater n1
-                      (fun uu___5 -> FStar_Reflection_Data.Uv_BVar uu___5) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (fun uu___5 -> FStar_Pervasives_Native.Some uu___5))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (i, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_Name.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 =
-               let uu___4 =
-                 FStar_Syntax_Embeddings.e_tuple2
-                   FStar_Syntax_Embeddings.e_string
-                   FStar_Syntax_Embeddings.e_range in
-               unembed' w uu___4 i in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun i1 ->
-                  let uu___4 =
-                    FStar_Compiler_Effect.op_Bar_Greater i1
-                      (fun uu___5 -> FStar_Reflection_Data.Uv_Name uu___5) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (fun uu___5 -> FStar_Pervasives_Native.Some uu___5))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (u, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_Unif.FStar_Reflection_Constants.lid
-             ->
-             let u1 =
-               FStar_Syntax_Util.unlazy_as_t
-                 FStar_Syntax_Syntax.Lazy_universe_uvar u in
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater u1
-                 (fun uu___4 -> FStar_Reflection_Data.Uv_Unif uu___4) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Uv_Unk.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Uv_Unk
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded universe view: %s" uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_universe_view unembed_universe_view
-    FStar_Reflection_Constants.fstar_refl_universe_view
-let (e_env : FStar_TypeChecker_Env.env FStar_Syntax_Embeddings.embedding) =
-  let embed_env rng e =
-    FStar_Syntax_Util.mk_lazy e FStar_Reflection_Constants.fstar_refl_env
-      FStar_Syntax_Syntax.Lazy_env (FStar_Pervasives_Native.Some rng) in
-  let unembed_env w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_env;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded env: %s" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_env unembed_env FStar_Reflection_Constants.fstar_refl_env
-let (e_const :
-  FStar_Reflection_Data.vconst FStar_Syntax_Embeddings.embedding) =
-  let embed_const rng c =
-    let r =
-      match c with
-      | FStar_Reflection_Data.C_Unit ->
-          FStar_Reflection_Constants.ref_C_Unit.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.C_True ->
-          FStar_Reflection_Constants.ref_C_True.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.C_False ->
-          FStar_Reflection_Constants.ref_C_False.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.C_Int i ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_BigInt.string_of_big_int i in
-                FStar_Syntax_Util.exp_int uu___3 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_C_Int.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.C_String s ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed FStar_Syntax_Embeddings.e_string rng s in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_C_String.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.C_Range r1 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed FStar_Syntax_Embeddings.e_range rng r1 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_C_Range.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.C_Reify ->
-          FStar_Reflection_Constants.ref_C_Reify.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.C_Reflect ns ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed FStar_Syntax_Embeddings.e_string_list rng ns in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_C_Reflect.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange in
-    {
-      FStar_Syntax_Syntax.n = (r.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (r.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (r.FStar_Syntax_Syntax.hash_code)
-    } in
-  let unembed_const w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Unit.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_Unit
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_True.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_True
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_False.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_False
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (i, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Int.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w FStar_Syntax_Embeddings.e_int i in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun i1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.C_Int i1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (s, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_String.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w FStar_Syntax_Embeddings.e_string s in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun s1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.C_String s1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (r, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Range.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w FStar_Syntax_Embeddings.e_range r in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun r1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.C_Range r1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Reify.FStar_Reflection_Constants.lid
-             ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-               FStar_Reflection_Data.C_Reify
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (ns, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Reflect.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w FStar_Syntax_Embeddings.e_string_list ns in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun ns1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.C_Reflect ns1))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1 "Not an embedded vconst: %s"
-                       uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_const unembed_const
-    FStar_Reflection_Constants.fstar_refl_vconst
-let rec (e_pattern' :
-  unit -> FStar_Reflection_Data.pattern FStar_Syntax_Embeddings.embedding) =
-  fun uu___ ->
-    let rec embed_pattern rng p =
-      match p with
-      | FStar_Reflection_Data.Pat_Constant c ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = embed e_const rng c in
-              FStar_Syntax_Syntax.as_arg uu___3 in
-            [uu___2] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Pat_Constant.FStar_Reflection_Constants.t
-            uu___1 rng
-      | FStar_Reflection_Data.Pat_Cons (fv, us_opt, ps) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = embed e_fv rng fv in
-              FStar_Syntax_Syntax.as_arg uu___3 in
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 = FStar_Syntax_Embeddings.e_list e_universe in
-                    FStar_Syntax_Embeddings.e_option uu___7 in
-                  embed uu___6 rng us_opt in
-                FStar_Syntax_Syntax.as_arg uu___5 in
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 =
-                        let uu___10 = e_pattern' () in
-                        FStar_Syntax_Embeddings.e_tuple2 uu___10
-                          FStar_Syntax_Embeddings.e_bool in
-                      FStar_Syntax_Embeddings.e_list uu___9 in
-                    embed uu___8 rng ps in
-                  FStar_Syntax_Syntax.as_arg uu___7 in
-                [uu___6] in
-              uu___4 :: uu___5 in
-            uu___2 :: uu___3 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Pat_Cons.FStar_Reflection_Constants.t
-            uu___1 rng
-      | FStar_Reflection_Data.Pat_Var bv ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = embed e_bv rng bv in
-              FStar_Syntax_Syntax.as_arg uu___3 in
-            [uu___2] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Pat_Var.FStar_Reflection_Constants.t
-            uu___1 rng
-      | FStar_Reflection_Data.Pat_Wild bv ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = embed e_bv rng bv in
-              FStar_Syntax_Syntax.as_arg uu___3 in
-            [uu___2] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Pat_Wild.FStar_Reflection_Constants.t
-            uu___1 rng
-      | FStar_Reflection_Data.Pat_Dot_Term eopt ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Embeddings.e_option e_term in
-                embed uu___4 rng eopt in
-              FStar_Syntax_Syntax.as_arg uu___3 in
-            [uu___2] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Pat_Dot_Term.FStar_Reflection_Constants.t
-            uu___1 rng in
-    let rec unembed_pattern w t =
-      let t1 = FStar_Syntax_Util.unascribe t in
-      let uu___1 = FStar_Syntax_Util.head_and_args t1 in
-      match uu___1 with
-      | (hd, args) ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Syntax_Util.un_uinst hd in
-              uu___4.FStar_Syntax_Syntax.n in
-            (uu___3, args) in
-          (match uu___2 with
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (c, uu___3)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Pat_Constant.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_const c in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun c1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Pat_Constant c1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv,
-              (f, uu___3)::(us_opt, uu___4)::(ps, uu___5)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Pat_Cons.FStar_Reflection_Constants.lid
-               ->
-               let uu___6 = unembed' w e_fv f in
-               FStar_Compiler_Util.bind_opt uu___6
-                 (fun f1 ->
-                    let uu___7 =
-                      let uu___8 =
-                        let uu___9 =
-                          FStar_Syntax_Embeddings.e_list e_universe in
-                        FStar_Syntax_Embeddings.e_option uu___9 in
-                      unembed' w uu___8 us_opt in
-                    FStar_Compiler_Util.bind_opt uu___7
-                      (fun us_opt1 ->
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               let uu___11 = e_pattern' () in
-                               FStar_Syntax_Embeddings.e_tuple2 uu___11
-                                 FStar_Syntax_Embeddings.e_bool in
-                             FStar_Syntax_Embeddings.e_list uu___10 in
-                           unembed' w uu___9 ps in
-                         FStar_Compiler_Util.bind_opt uu___8
-                           (fun ps1 ->
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (fun uu___9 ->
-                                   FStar_Pervasives_Native.Some uu___9)
-                                (FStar_Reflection_Data.Pat_Cons
-                                   (f1, us_opt1, ps1)))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (bv, uu___3)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Pat_Var.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_bv bv in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun bv1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Pat_Var bv1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (bv, uu___3)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Pat_Wild.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_bv bv in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun bv1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Pat_Wild bv1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (eopt, uu___3)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Pat_Dot_Term.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 =
-                 let uu___5 = FStar_Syntax_Embeddings.e_option e_term in
-                 unembed' w uu___5 eopt in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun eopt1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Pat_Dot_Term eopt1))
-           | uu___3 ->
-               (if w
-                then
-                  (let uu___5 =
-                     let uu___6 =
-                       let uu___7 = FStar_Syntax_Print.term_to_string t1 in
-                       FStar_Compiler_Util.format1
-                         "Not an embedded pattern: %s" uu___7 in
-                     (FStar_Errors.Warning_NotEmbedded, uu___6) in
-                   FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___5)
-                else ();
-                FStar_Pervasives_Native.None)) in
-    mk_emb embed_pattern unembed_pattern
-      FStar_Reflection_Constants.fstar_refl_pattern
-let (e_pattern :
-  FStar_Reflection_Data.pattern FStar_Syntax_Embeddings.embedding) =
-  e_pattern' ()
-let (e_branch :
-  FStar_Reflection_Data.branch FStar_Syntax_Embeddings.embedding) =
-  FStar_Syntax_Embeddings.e_tuple2 e_pattern e_term
-let (e_argv : FStar_Reflection_Data.argv FStar_Syntax_Embeddings.embedding) =
-  FStar_Syntax_Embeddings.e_tuple2 e_term e_aqualv
-let (e_args :
-  FStar_Reflection_Data.argv Prims.list FStar_Syntax_Embeddings.embedding) =
-  FStar_Syntax_Embeddings.e_list e_argv
-let (e_branch_aq :
-  FStar_Syntax_Syntax.antiquotations ->
-    (FStar_Reflection_Data.pattern * FStar_Syntax_Syntax.term)
-      FStar_Syntax_Embeddings.embedding)
-  =
-  fun aq ->
-    let uu___ = e_term_aq aq in
-    FStar_Syntax_Embeddings.e_tuple2 e_pattern uu___
-let (e_argv_aq :
-  FStar_Syntax_Syntax.antiquotations ->
-    (FStar_Syntax_Syntax.term * FStar_Reflection_Data.aqualv)
-      FStar_Syntax_Embeddings.embedding)
-  =
-  fun aq ->
-    let uu___ = e_term_aq aq in
-    FStar_Syntax_Embeddings.e_tuple2 uu___ e_aqualv
-let (e_match_returns_annotation :
-  (FStar_Syntax_Syntax.binder * ((FStar_Syntax_Syntax.term,
-    FStar_Syntax_Syntax.comp) FStar_Pervasives.either *
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option * Prims.bool))
-    FStar_Pervasives_Native.option FStar_Syntax_Embeddings.embedding)
-  =
-  let uu___ =
-    let uu___1 =
-      let uu___2 = FStar_Syntax_Embeddings.e_either e_term e_comp in
-      let uu___3 = FStar_Syntax_Embeddings.e_option e_term in
-      FStar_Syntax_Embeddings.e_tuple3 uu___2 uu___3
-        FStar_Syntax_Embeddings.e_bool in
-    FStar_Syntax_Embeddings.e_tuple2 e_binder uu___1 in
-  FStar_Syntax_Embeddings.e_option uu___
-let (e_term_view_aq :
-  FStar_Syntax_Syntax.antiquotations ->
-    FStar_Reflection_Data.term_view FStar_Syntax_Embeddings.embedding)
-  =
-  fun aq ->
-    let embed_term_view rng t =
-      match t with
-      | FStar_Reflection_Data.Tv_FVar fv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_fv rng fv in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_FVar.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_BVar fv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_bv rng fv in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_BVar.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Var bv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_bv rng bv in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Var.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_UInst (fv, us) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_fv rng fv in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Embeddings.e_list e_universe in
-                  embed uu___5 rng us in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_UInst.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_App (hd, a) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = let uu___3 = e_term_aq aq in embed uu___3 rng hd in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = let uu___5 = e_argv_aq aq in embed uu___5 rng a in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_App.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Abs (b, t1) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_binder rng b in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = let uu___5 = e_term_aq aq in embed uu___5 rng t1 in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Abs.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Arrow (b, c) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_binder rng b in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = embed e_comp rng c in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Arrow.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Type u ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_universe rng u in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Type.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Refine (bv, t1) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_bv rng bv in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = let uu___5 = e_term_aq aq in embed uu___5 rng t1 in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Refine.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Const c ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_const rng c in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Const.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Uvar (u, d) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed FStar_Syntax_Embeddings.e_int rng u in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  FStar_Syntax_Util.mk_lazy (u, d)
-                    FStar_Syntax_Util.t_ctx_uvar_and_sust
-                    FStar_Syntax_Syntax.Lazy_uvar
-                    FStar_Pervasives_Native.None in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Uvar.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Let (r, attrs, b, t1, t2) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed FStar_Syntax_Embeddings.e_bool rng r in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Embeddings.e_list e_term in
-                  embed uu___5 rng attrs in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 = embed e_bv rng b in
-                  FStar_Syntax_Syntax.as_arg uu___6 in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 = e_term_aq aq in embed uu___9 rng t1 in
-                    FStar_Syntax_Syntax.as_arg uu___8 in
-                  let uu___8 =
-                    let uu___9 =
-                      let uu___10 =
-                        let uu___11 = e_term_aq aq in embed uu___11 rng t2 in
-                      FStar_Syntax_Syntax.as_arg uu___10 in
-                    [uu___9] in
-                  uu___7 :: uu___8 in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Let.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Match (t1, ret_opt, brs) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = let uu___3 = e_term_aq aq in embed uu___3 rng t1 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = embed e_match_returns_annotation rng ret_opt in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = e_branch_aq aq in
-                      FStar_Syntax_Embeddings.e_list uu___8 in
-                    embed uu___7 rng brs in
-                  FStar_Syntax_Syntax.as_arg uu___6 in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_Match.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_AscribedT (e, t1, tacopt, use_eq) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = let uu___3 = e_term_aq aq in embed uu___3 rng e in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = let uu___5 = e_term_aq aq in embed uu___5 rng t1 in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = e_term_aq aq in
-                      FStar_Syntax_Embeddings.e_option uu___8 in
-                    embed uu___7 rng tacopt in
-                  FStar_Syntax_Syntax.as_arg uu___6 in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      embed FStar_Syntax_Embeddings.e_bool rng use_eq in
-                    FStar_Syntax_Syntax.as_arg uu___8 in
-                  [uu___7] in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_AscT.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_AscribedC (e, c, tacopt, use_eq) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = let uu___3 = e_term_aq aq in embed uu___3 rng e in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = embed e_comp rng c in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = e_term_aq aq in
-                      FStar_Syntax_Embeddings.e_option uu___8 in
-                    embed uu___7 rng tacopt in
-                  FStar_Syntax_Syntax.as_arg uu___6 in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      embed FStar_Syntax_Embeddings.e_bool rng use_eq in
-                    FStar_Syntax_Syntax.as_arg uu___8 in
-                  [uu___7] in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_Tv_AscC.FStar_Reflection_Constants.t
-            uu___ rng
-      | FStar_Reflection_Data.Tv_Unknown ->
-          let uu___ =
-            FStar_Reflection_Constants.ref_Tv_Unknown.FStar_Reflection_Constants.t in
-          {
-            FStar_Syntax_Syntax.n = (uu___.FStar_Syntax_Syntax.n);
-            FStar_Syntax_Syntax.pos = rng;
-            FStar_Syntax_Syntax.vars = (uu___.FStar_Syntax_Syntax.vars);
-            FStar_Syntax_Syntax.hash_code =
-              (uu___.FStar_Syntax_Syntax.hash_code)
-          } in
-    let unembed_term_view w t =
-      let uu___ = FStar_Syntax_Util.head_and_args t in
-      match uu___ with
-      | (hd, args) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Util.un_uinst hd in
-              uu___3.FStar_Syntax_Syntax.n in
-            (uu___2, args) in
-          (match uu___1 with
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (b, uu___2)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Var.FStar_Reflection_Constants.lid
-               ->
-               let uu___3 = unembed' w e_bv b in
-               FStar_Compiler_Util.bind_opt uu___3
-                 (fun b1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                      (FStar_Reflection_Data.Tv_Var b1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (b, uu___2)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_BVar.FStar_Reflection_Constants.lid
-               ->
-               let uu___3 = unembed' w e_bv b in
-               FStar_Compiler_Util.bind_opt uu___3
-                 (fun b1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                      (FStar_Reflection_Data.Tv_BVar b1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (f, uu___2)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_FVar.FStar_Reflection_Constants.lid
-               ->
-               let uu___3 = unembed' w e_fv f in
-               FStar_Compiler_Util.bind_opt uu___3
-                 (fun f1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                      (FStar_Reflection_Data.Tv_FVar f1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (f, uu___2)::(us, uu___3)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_UInst.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_fv f in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun f1 ->
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Embeddings.e_list e_universe in
-                      unembed' w uu___6 us in
-                    FStar_Compiler_Util.bind_opt uu___5
-                      (fun us1 ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                           (FStar_Reflection_Data.Tv_UInst (f1, us1))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::(r, uu___3)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_App.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_term l in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun l1 ->
-                    let uu___5 = unembed' w e_argv r in
-                    FStar_Compiler_Util.bind_opt uu___5
-                      (fun r1 ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                           (FStar_Reflection_Data.Tv_App (l1, r1))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (b, uu___2)::(t1, uu___3)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Abs.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_binder b in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun b1 ->
-                    let uu___5 = unembed' w e_term t1 in
-                    FStar_Compiler_Util.bind_opt uu___5
-                      (fun t2 ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                           (FStar_Reflection_Data.Tv_Abs (b1, t2))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (b, uu___2)::(t1, uu___3)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Arrow.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_binder b in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun b1 ->
-                    let uu___5 = unembed' w e_comp t1 in
-                    FStar_Compiler_Util.bind_opt uu___5
-                      (fun c ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                           (FStar_Reflection_Data.Tv_Arrow (b1, c))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (u, uu___2)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Type.FStar_Reflection_Constants.lid
-               ->
-               let uu___3 = unembed' w e_universe u in
-               FStar_Compiler_Util.bind_opt uu___3
-                 (fun u1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                      (FStar_Reflection_Data.Tv_Type u1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (b, uu___2)::(t1, uu___3)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Refine.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w e_bv b in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun b1 ->
-                    let uu___5 = unembed' w e_term t1 in
-                    FStar_Compiler_Util.bind_opt uu___5
-                      (fun t2 ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                           (FStar_Reflection_Data.Tv_Refine (b1, t2))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (c, uu___2)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Const.FStar_Reflection_Constants.lid
-               ->
-               let uu___3 = unembed' w e_const c in
-               FStar_Compiler_Util.bind_opt uu___3
-                 (fun c1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                      (FStar_Reflection_Data.Tv_Const c1))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, (u, uu___2)::(l, uu___3)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Uvar.FStar_Reflection_Constants.lid
-               ->
-               let uu___4 = unembed' w FStar_Syntax_Embeddings.e_int u in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun u1 ->
-                    let ctx_u_s =
-                      FStar_Syntax_Util.unlazy_as_t
-                        FStar_Syntax_Syntax.Lazy_uvar l in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Tv_Uvar (u1, ctx_u_s)))
-           | (FStar_Syntax_Syntax.Tm_fvar fv,
-              (r, uu___2)::(attrs, uu___3)::(b, uu___4)::(t1, uu___5)::
-              (t2, uu___6)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Let.FStar_Reflection_Constants.lid
-               ->
-               let uu___7 = unembed' w FStar_Syntax_Embeddings.e_bool r in
-               FStar_Compiler_Util.bind_opt uu___7
-                 (fun r1 ->
-                    let uu___8 =
-                      let uu___9 = FStar_Syntax_Embeddings.e_list e_term in
-                      unembed' w uu___9 attrs in
-                    FStar_Compiler_Util.bind_opt uu___8
-                      (fun attrs1 ->
-                         let uu___9 = unembed' w e_bv b in
-                         FStar_Compiler_Util.bind_opt uu___9
-                           (fun b1 ->
-                              let uu___10 = unembed' w e_term t1 in
-                              FStar_Compiler_Util.bind_opt uu___10
-                                (fun t11 ->
-                                   let uu___11 = unembed' w e_term t2 in
-                                   FStar_Compiler_Util.bind_opt uu___11
-                                     (fun t21 ->
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (fun uu___12 ->
-                                             FStar_Pervasives_Native.Some
-                                               uu___12)
-                                          (FStar_Reflection_Data.Tv_Let
-                                             (r1, attrs1, b1, t11, t21)))))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv,
-              (t1, uu___2)::(ret_opt, uu___3)::(brs, uu___4)::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Match.FStar_Reflection_Constants.lid
-               ->
-               let uu___5 = unembed' w e_term t1 in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun t2 ->
-                    let uu___6 =
-                      let uu___7 = FStar_Syntax_Embeddings.e_list e_branch in
-                      unembed' w uu___7 brs in
-                    FStar_Compiler_Util.bind_opt uu___6
-                      (fun brs1 ->
-                         let uu___7 =
-                           unembed' w e_match_returns_annotation ret_opt in
-                         FStar_Compiler_Util.bind_opt uu___7
-                           (fun ret_opt1 ->
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (fun uu___8 ->
-                                   FStar_Pervasives_Native.Some uu___8)
-                                (FStar_Reflection_Data.Tv_Match
-                                   (t2, ret_opt1, brs1)))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv,
-              (e, uu___2)::(t1, uu___3)::(tacopt, uu___4)::(use_eq, uu___5)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_AscT.FStar_Reflection_Constants.lid
-               ->
-               let uu___6 = unembed' w e_term e in
-               FStar_Compiler_Util.bind_opt uu___6
-                 (fun e1 ->
-                    let uu___7 = unembed' w e_term t1 in
-                    FStar_Compiler_Util.bind_opt uu___7
-                      (fun t2 ->
-                         let uu___8 =
-                           let uu___9 =
-                             FStar_Syntax_Embeddings.e_option e_term in
-                           unembed' w uu___9 tacopt in
-                         FStar_Compiler_Util.bind_opt uu___8
-                           (fun tacopt1 ->
-                              let uu___9 =
-                                unembed' w FStar_Syntax_Embeddings.e_bool
-                                  use_eq in
-                              FStar_Compiler_Util.bind_opt uu___9
-                                (fun use_eq1 ->
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (fun uu___10 ->
-                                        FStar_Pervasives_Native.Some uu___10)
-                                     (FStar_Reflection_Data.Tv_AscribedT
-                                        (e1, t2, tacopt1, use_eq1))))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv,
-              (e, uu___2)::(c, uu___3)::(tacopt, uu___4)::(use_eq, uu___5)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_AscC.FStar_Reflection_Constants.lid
-               ->
-               let uu___6 = unembed' w e_term e in
-               FStar_Compiler_Util.bind_opt uu___6
-                 (fun e1 ->
-                    let uu___7 = unembed' w e_comp c in
-                    FStar_Compiler_Util.bind_opt uu___7
-                      (fun c1 ->
-                         let uu___8 =
-                           let uu___9 =
-                             FStar_Syntax_Embeddings.e_option e_term in
-                           unembed' w uu___9 tacopt in
-                         FStar_Compiler_Util.bind_opt uu___8
-                           (fun tacopt1 ->
-                              let uu___9 =
-                                unembed' w FStar_Syntax_Embeddings.e_bool
-                                  use_eq in
-                              FStar_Compiler_Util.bind_opt uu___9
-                                (fun use_eq1 ->
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (fun uu___10 ->
-                                        FStar_Pervasives_Native.Some uu___10)
-                                     (FStar_Reflection_Data.Tv_AscribedC
-                                        (e1, c1, tacopt1, use_eq1))))))
-           | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-               FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Reflection_Constants.ref_Tv_Unknown.FStar_Reflection_Constants.lid
-               ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-                 FStar_Reflection_Data.Tv_Unknown
-           | uu___2 ->
-               (if w
-                then
-                  (let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Syntax_Print.term_to_string t in
-                       FStar_Compiler_Util.format1
-                         "Not an embedded term_view: %s" uu___6 in
-                     (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                   FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___4)
-                else ();
-                FStar_Pervasives_Native.None)) in
-    mk_emb embed_term_view unembed_term_view
-      FStar_Reflection_Constants.fstar_refl_term_view
-let (e_term_view :
-  FStar_Reflection_Data.term_view FStar_Syntax_Embeddings.embedding) =
-  e_term_view_aq []
-let (e_lid : FStar_Ident.lid FStar_Syntax_Embeddings.embedding) =
-  let embed1 rng lid =
-    let uu___ = FStar_Ident.path_of_lid lid in
-    embed FStar_Syntax_Embeddings.e_string_list rng uu___ in
-  let unembed w t =
-    let uu___ = unembed' w FStar_Syntax_Embeddings.e_string_list t in
-    FStar_Compiler_Util.map_opt uu___
-      (fun p -> FStar_Ident.lid_of_path p t.FStar_Syntax_Syntax.pos) in
-  let uu___ = FStar_Syntax_Syntax.t_list_of FStar_Syntax_Syntax.t_string in
-  FStar_Syntax_Embeddings.mk_emb_full
-    (fun x -> fun r -> fun uu___1 -> fun uu___2 -> embed1 r x)
-    (fun x -> fun w -> fun uu___1 -> unembed w x) uu___
-    FStar_Ident.string_of_lid FStar_Syntax_Syntax.ET_abstract
-let (e_bv_view :
-  FStar_Reflection_Data.bv_view FStar_Syntax_Embeddings.embedding) =
-  let embed_bv_view rng bvv =
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          embed FStar_Syntax_Embeddings.e_string rng
-            bvv.FStar_Reflection_Data.bv_ppname in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            embed FStar_Syntax_Embeddings.e_int rng
-              bvv.FStar_Reflection_Data.bv_index in
-          FStar_Syntax_Syntax.as_arg uu___4 in
-        let uu___4 =
-          let uu___5 =
-            let uu___6 = embed e_term rng bvv.FStar_Reflection_Data.bv_sort in
-            FStar_Syntax_Syntax.as_arg uu___6 in
-          [uu___5] in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.ref_Mk_bv.FStar_Reflection_Constants.t uu___
-      rng in
-  let unembed_bv_view w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (nm, uu___2)::(idx, uu___3)::(s, uu___4)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Mk_bv.FStar_Reflection_Constants.lid
-             ->
-             let uu___5 = unembed' w FStar_Syntax_Embeddings.e_string nm in
-             FStar_Compiler_Util.bind_opt uu___5
-               (fun nm1 ->
-                  let uu___6 = unembed' w FStar_Syntax_Embeddings.e_int idx in
-                  FStar_Compiler_Util.bind_opt uu___6
-                    (fun idx1 ->
-                       let uu___7 = unembed' w e_term s in
-                       FStar_Compiler_Util.bind_opt uu___7
-                         (fun s1 ->
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (fun uu___8 ->
-                                 FStar_Pervasives_Native.Some uu___8)
-                              {
-                                FStar_Reflection_Data.bv_ppname = nm1;
-                                FStar_Reflection_Data.bv_index = idx1;
-                                FStar_Reflection_Data.bv_sort = s1
-                              })))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded bv_view: %s" uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_bv_view unembed_bv_view
-    FStar_Reflection_Constants.fstar_refl_bv_view
-let (e_comp_view :
-  FStar_Reflection_Data.comp_view FStar_Syntax_Embeddings.embedding) =
-  let embed_comp_view rng cv =
-    match cv with
-    | FStar_Reflection_Data.C_Total t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed e_term rng t in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_C_Total.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.C_GTotal t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed e_term rng t in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          [uu___1] in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_C_GTotal.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.C_Lemma (pre, post, pats) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed e_term rng pre in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = embed e_term rng post in
-              FStar_Syntax_Syntax.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = embed e_term rng pats in
-                FStar_Syntax_Syntax.as_arg uu___6 in
-              [uu___5] in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_C_Lemma.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.C_Eff (us, eff, res, args, decrs) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Embeddings.e_list e_universe in
-              embed uu___3 rng us in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                embed FStar_Syntax_Embeddings.e_string_list rng eff in
-              FStar_Syntax_Syntax.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = embed e_term rng res in
-                FStar_Syntax_Syntax.as_arg uu___6 in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    let uu___9 = FStar_Syntax_Embeddings.e_list e_argv in
-                    embed uu___9 rng args in
-                  FStar_Syntax_Syntax.as_arg uu___8 in
-                let uu___8 =
-                  let uu___9 =
-                    let uu___10 =
-                      let uu___11 = FStar_Syntax_Embeddings.e_list e_term in
-                      embed uu___11 rng decrs in
-                    FStar_Syntax_Syntax.as_arg uu___10 in
-                  [uu___9] in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_C_Eff.FStar_Reflection_Constants.t
-          uu___ rng in
-  let unembed_comp_view w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (t2, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Total.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_term t2 in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun t3 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.C_Total t3))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (t2, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_GTotal.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_term t2 in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun t3 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.C_GTotal t3))
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (pre, uu___2)::(post, uu___3)::(pats, uu___4)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Lemma.FStar_Reflection_Constants.lid
-             ->
-             let uu___5 = unembed' w e_term pre in
-             FStar_Compiler_Util.bind_opt uu___5
-               (fun pre1 ->
-                  let uu___6 = unembed' w e_term post in
-                  FStar_Compiler_Util.bind_opt uu___6
-                    (fun post1 ->
-                       let uu___7 = unembed' w e_term pats in
-                       FStar_Compiler_Util.bind_opt uu___7
-                         (fun pats1 ->
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (fun uu___8 ->
-                                 FStar_Pervasives_Native.Some uu___8)
-                              (FStar_Reflection_Data.C_Lemma
-                                 (pre1, post1, pats1)))))
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (us, uu___2)::(eff, uu___3)::(res, uu___4)::(args1, uu___5)::
-            (decrs, uu___6)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_C_Eff.FStar_Reflection_Constants.lid
-             ->
-             let uu___7 =
-               let uu___8 = FStar_Syntax_Embeddings.e_list e_universe in
-               unembed' w uu___8 us in
-             FStar_Compiler_Util.bind_opt uu___7
-               (fun us1 ->
-                  let uu___8 =
-                    unembed' w FStar_Syntax_Embeddings.e_string_list eff in
-                  FStar_Compiler_Util.bind_opt uu___8
-                    (fun eff1 ->
-                       let uu___9 = unembed' w e_term res in
-                       FStar_Compiler_Util.bind_opt uu___9
-                         (fun res1 ->
-                            let uu___10 =
-                              let uu___11 =
-                                FStar_Syntax_Embeddings.e_list e_argv in
-                              unembed' w uu___11 args1 in
-                            FStar_Compiler_Util.bind_opt uu___10
-                              (fun args2 ->
-                                 let uu___11 =
-                                   let uu___12 =
-                                     FStar_Syntax_Embeddings.e_list e_term in
-                                   unembed' w uu___12 decrs in
-                                 FStar_Compiler_Util.bind_opt uu___11
-                                   (fun decrs1 ->
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        (fun uu___12 ->
-                                           FStar_Pervasives_Native.Some
-                                             uu___12)
-                                        (FStar_Reflection_Data.C_Eff
-                                           (us1, eff1, res1, args2, decrs1)))))))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded comp_view: %s" uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_comp_view unembed_comp_view
-    FStar_Reflection_Constants.fstar_refl_comp_view
-let (e_order : FStar_Order.order FStar_Syntax_Embeddings.embedding) =
-  let embed_order rng o =
-    let r =
-      match o with
-      | FStar_Order.Lt -> FStar_Reflection_Constants.ord_Lt
-      | FStar_Order.Eq -> FStar_Reflection_Constants.ord_Eq
-      | FStar_Order.Gt -> FStar_Reflection_Constants.ord_Gt in
-    {
-      FStar_Syntax_Syntax.n = (r.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (r.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (r.FStar_Syntax_Syntax.hash_code)
-    } in
-  let unembed_order w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ord_Lt_lid
-             -> FStar_Pervasives_Native.Some FStar_Order.Lt
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ord_Eq_lid
-             -> FStar_Pervasives_Native.Some FStar_Order.Eq
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ord_Gt_lid
-             -> FStar_Pervasives_Native.Some FStar_Order.Gt
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1 "Not an embedded order: %s"
-                       uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_order unembed_order FStar_Syntax_Syntax.t_order
-let (e_sigelt : FStar_Syntax_Syntax.sigelt FStar_Syntax_Embeddings.embedding)
-  =
-  let embed_sigelt rng se =
-    FStar_Syntax_Util.mk_lazy se FStar_Reflection_Constants.fstar_refl_sigelt
-      FStar_Syntax_Syntax.Lazy_sigelt (FStar_Pervasives_Native.Some rng) in
-  let unembed_sigelt w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_sigelt;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded sigelt: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_sigelt unembed_sigelt
-    FStar_Reflection_Constants.fstar_refl_sigelt
-let (e_univ_name :
-  FStar_Syntax_Syntax.univ_name FStar_Syntax_Embeddings.embedding) =
-  FStar_Syntax_Embeddings.set_type
-    FStar_Reflection_Constants.fstar_refl_univ_name e_ident
-let (e_univ_names :
-  FStar_Syntax_Syntax.univ_name Prims.list FStar_Syntax_Embeddings.embedding)
-  = FStar_Syntax_Embeddings.e_list e_univ_name
-let (e_ctor :
-  (Prims.string Prims.list * FStar_Syntax_Syntax.term)
-    FStar_Syntax_Embeddings.embedding)
-  =
-  FStar_Syntax_Embeddings.e_tuple2 FStar_Syntax_Embeddings.e_string_list
-    e_term
-let (e_lb_view :
-  FStar_Reflection_Data.lb_view FStar_Syntax_Embeddings.embedding) =
-  let embed_lb_view rng lbv =
-    let uu___ =
-      let uu___1 =
-        let uu___2 = embed e_fv rng lbv.FStar_Reflection_Data.lb_fv in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 = embed e_univ_names rng lbv.FStar_Reflection_Data.lb_us in
-          FStar_Syntax_Syntax.as_arg uu___4 in
-        let uu___4 =
-          let uu___5 =
-            let uu___6 = embed e_term rng lbv.FStar_Reflection_Data.lb_typ in
-            FStar_Syntax_Syntax.as_arg uu___6 in
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = embed e_term rng lbv.FStar_Reflection_Data.lb_def in
-              FStar_Syntax_Syntax.as_arg uu___8 in
-            [uu___7] in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.ref_Mk_lb.FStar_Reflection_Constants.t uu___
-      rng in
-  let unembed_lb_view w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (fv', uu___2)::(us, uu___3)::(typ, uu___4)::(def, uu___5)::[])
-             when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Mk_lb.FStar_Reflection_Constants.lid
-             ->
-             let uu___6 = unembed' w e_fv fv' in
-             FStar_Compiler_Util.bind_opt uu___6
-               (fun fv'1 ->
-                  let uu___7 = unembed' w e_univ_names us in
-                  FStar_Compiler_Util.bind_opt uu___7
-                    (fun us1 ->
-                       let uu___8 = unembed' w e_term typ in
-                       FStar_Compiler_Util.bind_opt uu___8
-                         (fun typ1 ->
-                            let uu___9 = unembed' w e_term def in
-                            FStar_Compiler_Util.bind_opt uu___9
-                              (fun def1 ->
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (fun uu___10 ->
-                                      FStar_Pervasives_Native.Some uu___10)
-                                   {
-                                     FStar_Reflection_Data.lb_fv = fv'1;
-                                     FStar_Reflection_Data.lb_us = us1;
-                                     FStar_Reflection_Data.lb_typ = typ1;
-                                     FStar_Reflection_Data.lb_def = def1
-                                   }))))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded lb_view: %s" uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_lb_view unembed_lb_view
-    FStar_Reflection_Constants.fstar_refl_lb_view
-let (e_attribute :
-  FStar_Syntax_Syntax.attribute FStar_Syntax_Embeddings.embedding) = e_term
-let (e_attributes :
-  FStar_Syntax_Syntax.attribute Prims.list FStar_Syntax_Embeddings.embedding)
-  = FStar_Syntax_Embeddings.e_list e_attribute
-let (e_letbinding :
-  FStar_Syntax_Syntax.letbinding FStar_Syntax_Embeddings.embedding) =
-  let embed_letbinding rng lb =
-    FStar_Syntax_Util.mk_lazy lb
-      FStar_Reflection_Constants.fstar_refl_letbinding
-      FStar_Syntax_Syntax.Lazy_letbinding (FStar_Pervasives_Native.Some rng) in
-  let unembed_letbinding w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = lb;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_letbinding;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn lb in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded letbinding: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_letbinding unembed_letbinding
-    FStar_Reflection_Constants.fstar_refl_letbinding
-let (e_sigelt_view :
-  FStar_Reflection_Data.sigelt_view FStar_Syntax_Embeddings.embedding) =
-  let embed_sigelt_view rng sev =
-    match sev with
-    | FStar_Reflection_Data.Sg_Let (r, lbs) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed FStar_Syntax_Embeddings.e_bool rng r in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Embeddings.e_list e_letbinding in
-                embed uu___5 rng lbs in
-              FStar_Syntax_Syntax.as_arg uu___4 in
-            [uu___3] in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Sg_Let.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Sg_Inductive (nm, univs, bs, t, dcs) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed FStar_Syntax_Embeddings.e_string_list rng nm in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = embed e_univ_names rng univs in
-              FStar_Syntax_Syntax.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = embed e_binders rng bs in
-                FStar_Syntax_Syntax.as_arg uu___6 in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 = embed e_term rng t in
-                  FStar_Syntax_Syntax.as_arg uu___8 in
-                let uu___8 =
-                  let uu___9 =
-                    let uu___10 =
-                      let uu___11 = FStar_Syntax_Embeddings.e_list e_ctor in
-                      embed uu___11 rng dcs in
-                    FStar_Syntax_Syntax.as_arg uu___10 in
-                  [uu___9] in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Sg_Inductive.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Sg_Val (nm, univs, t) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed FStar_Syntax_Embeddings.e_string_list rng nm in
-            FStar_Syntax_Syntax.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = embed e_univ_names rng univs in
-              FStar_Syntax_Syntax.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = embed e_term rng t in
-                FStar_Syntax_Syntax.as_arg uu___6 in
-              [uu___5] in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.ref_Sg_Val.FStar_Reflection_Constants.t
-          uu___ rng
-    | FStar_Reflection_Data.Unk ->
-        let uu___ =
-          FStar_Reflection_Constants.ref_Unk.FStar_Reflection_Constants.t in
-        {
-          FStar_Syntax_Syntax.n = (uu___.FStar_Syntax_Syntax.n);
-          FStar_Syntax_Syntax.pos = rng;
-          FStar_Syntax_Syntax.vars = (uu___.FStar_Syntax_Syntax.vars);
-          FStar_Syntax_Syntax.hash_code =
-            (uu___.FStar_Syntax_Syntax.hash_code)
-        } in
-  let unembed_sigelt_view w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (nm, uu___2)::(us, uu___3)::(bs, uu___4)::(t2, uu___5)::(dcs,
-                                                                    uu___6)::[])
-             when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Sg_Inductive.FStar_Reflection_Constants.lid
-             ->
-             let uu___7 = unembed' w FStar_Syntax_Embeddings.e_string_list nm in
-             FStar_Compiler_Util.bind_opt uu___7
-               (fun nm1 ->
-                  let uu___8 = unembed' w e_univ_names us in
-                  FStar_Compiler_Util.bind_opt uu___8
-                    (fun us1 ->
-                       let uu___9 = unembed' w e_binders bs in
-                       FStar_Compiler_Util.bind_opt uu___9
-                         (fun bs1 ->
-                            let uu___10 = unembed' w e_term t2 in
-                            FStar_Compiler_Util.bind_opt uu___10
-                              (fun t3 ->
-                                 let uu___11 =
-                                   let uu___12 =
-                                     FStar_Syntax_Embeddings.e_list e_ctor in
-                                   unembed' w uu___12 dcs in
-                                 FStar_Compiler_Util.bind_opt uu___11
-                                   (fun dcs1 ->
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        (fun uu___12 ->
-                                           FStar_Pervasives_Native.Some
-                                             uu___12)
-                                        (FStar_Reflection_Data.Sg_Inductive
-                                           (nm1, us1, bs1, t3, dcs1)))))))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (r, uu___2)::(lbs, uu___3)::[])
-             when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Sg_Let.FStar_Reflection_Constants.lid
-             ->
-             let uu___4 = unembed' w FStar_Syntax_Embeddings.e_bool r in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun r1 ->
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_Embeddings.e_list e_letbinding in
-                    unembed' w uu___6 lbs in
-                  FStar_Compiler_Util.bind_opt uu___5
-                    (fun lbs1 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                         (FStar_Reflection_Data.Sg_Let (r1, lbs1))))
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (nm, uu___2)::(us, uu___3)::(t2, uu___4)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Sg_Val.FStar_Reflection_Constants.lid
-             ->
-             let uu___5 = unembed' w FStar_Syntax_Embeddings.e_string_list nm in
-             FStar_Compiler_Util.bind_opt uu___5
-               (fun nm1 ->
-                  let uu___6 = unembed' w e_univ_names us in
-                  FStar_Compiler_Util.bind_opt uu___6
-                    (fun us1 ->
-                       let uu___7 = unembed' w e_term t2 in
-                       FStar_Compiler_Util.bind_opt uu___7
-                         (fun t3 ->
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (fun uu___8 ->
-                                 FStar_Pervasives_Native.Some uu___8)
-                              (FStar_Reflection_Data.Sg_Val (nm1, us1, t3)))))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_Unk.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Unk
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded sigelt_view: %s " uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_sigelt_view unembed_sigelt_view
-    FStar_Reflection_Constants.fstar_refl_sigelt_view
-let (e_exp : FStar_Reflection_Data.exp FStar_Syntax_Embeddings.embedding) =
-  let rec embed_exp rng e =
-    let r =
-      match e with
-      | FStar_Reflection_Data.Unit ->
-          FStar_Reflection_Constants.ref_E_Unit.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Var i ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_BigInt.string_of_big_int i in
-                FStar_Syntax_Util.exp_int uu___3 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_E_Var.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.Mult (e1, e2) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed_exp rng e1 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = embed_exp rng e2 in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_E_Mult.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange in
-    {
-      FStar_Syntax_Syntax.n = (r.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (r.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (r.FStar_Syntax_Syntax.hash_code)
-    } in
-  let rec unembed_exp w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_E_Unit.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Unit
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (i, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_E_Var.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w FStar_Syntax_Embeddings.e_int i in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun i1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.Var i1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (e1, uu___2)::(e2, uu___3)::[])
-             when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_E_Mult.FStar_Reflection_Constants.lid
-             ->
-             let uu___4 = unembed_exp w e1 in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun e11 ->
-                  let uu___5 = unembed_exp w e2 in
-                  FStar_Compiler_Util.bind_opt uu___5
-                    (fun e21 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                         (FStar_Reflection_Data.Mult (e11, e21))))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1 "Not an embedded exp: %s"
-                       uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed_exp unembed_exp FStar_Reflection_Constants.fstar_refl_exp
-let (e_binder_view :
-  FStar_Reflection_Data.binder_view FStar_Syntax_Embeddings.embedding) =
-  let uu___ = FStar_Syntax_Embeddings.e_tuple2 e_aqualv e_attributes in
-  FStar_Syntax_Embeddings.e_tuple2 e_bv uu___
-let (e_qualifier :
-  FStar_Reflection_Data.qualifier FStar_Syntax_Embeddings.embedding) =
-  let embed1 rng q =
-    let r =
-      match q with
-      | FStar_Reflection_Data.Assumption ->
-          FStar_Reflection_Constants.ref_qual_Assumption.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.New ->
-          FStar_Reflection_Constants.ref_qual_New.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Private ->
-          FStar_Reflection_Constants.ref_qual_Private.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Unfold_for_unification_and_vcgen ->
-          FStar_Reflection_Constants.ref_qual_Unfold_for_unification_and_vcgen.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Visible_default ->
-          FStar_Reflection_Constants.ref_qual_Visible_default.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Irreducible ->
-          FStar_Reflection_Constants.ref_qual_Irreducible.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Inline_for_extraction ->
-          FStar_Reflection_Constants.ref_qual_Inline_for_extraction.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.NoExtract ->
-          FStar_Reflection_Constants.ref_qual_NoExtract.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Noeq ->
-          FStar_Reflection_Constants.ref_qual_Noeq.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Unopteq ->
-          FStar_Reflection_Constants.ref_qual_Unopteq.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.TotalEffect ->
-          FStar_Reflection_Constants.ref_qual_TotalEffect.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Logic ->
-          FStar_Reflection_Constants.ref_qual_Logic.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Reifiable ->
-          FStar_Reflection_Constants.ref_qual_Reifiable.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.ExceptionConstructor ->
-          FStar_Reflection_Constants.ref_qual_ExceptionConstructor.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.HasMaskedEffect ->
-          FStar_Reflection_Constants.ref_qual_HasMaskedEffect.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Effect ->
-          FStar_Reflection_Constants.ref_qual_Effect.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.OnlyName ->
-          FStar_Reflection_Constants.ref_qual_OnlyName.FStar_Reflection_Constants.t
-      | FStar_Reflection_Data.Reflectable l ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_lid rng l in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_qual_Reflectable.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.Discriminator l ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_lid rng l in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_qual_Discriminator.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.Action l ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_lid rng l in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            [uu___1] in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_qual_Action.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.Projector (l, i) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = embed e_lid rng l in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = embed e_ident rng i in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_qual_Projector.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.RecordType (ids1, ids2) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Embeddings.e_list e_ident in
-                embed uu___3 rng ids1 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Embeddings.e_list e_ident in
-                  embed uu___5 rng ids2 in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_qual_RecordType.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange
-      | FStar_Reflection_Data.RecordConstructor (ids1, ids2) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Embeddings.e_list e_ident in
-                embed uu___3 rng ids1 in
-              FStar_Syntax_Syntax.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Embeddings.e_list e_ident in
-                  embed uu___5 rng ids2 in
-                FStar_Syntax_Syntax.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app
-            FStar_Reflection_Constants.ref_qual_RecordConstructor.FStar_Reflection_Constants.t
-            uu___ FStar_Compiler_Range.dummyRange in
-    {
-      FStar_Syntax_Syntax.n = (r.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (r.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (r.FStar_Syntax_Syntax.hash_code)
-    } in
-  let unembed w t =
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.head_and_args t1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Assumption.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Assumption
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_New.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.New
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Private.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Private
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Unfold_for_unification_and_vcgen.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some
-               FStar_Reflection_Data.Unfold_for_unification_and_vcgen
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Visible_default.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some
-               FStar_Reflection_Data.Visible_default
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Irreducible.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some FStar_Reflection_Data.Irreducible
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Inline_for_extraction.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some
-               FStar_Reflection_Data.Inline_for_extraction
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_NoExtract.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.NoExtract
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Noeq.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Noeq
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Unopteq.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Unopteq
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_TotalEffect.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some FStar_Reflection_Data.TotalEffect
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Logic.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Logic
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Reifiable.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Reifiable
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_ExceptionConstructor.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some
-               FStar_Reflection_Data.ExceptionConstructor
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_HasMaskedEffect.FStar_Reflection_Constants.lid
-             ->
-             FStar_Pervasives_Native.Some
-               FStar_Reflection_Data.HasMaskedEffect
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Effect.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Effect
-         | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_OnlyName.FStar_Reflection_Constants.lid
-             -> FStar_Pervasives_Native.Some FStar_Reflection_Data.OnlyName
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Reflectable.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_lid l in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun l1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.Reflectable l1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Discriminator.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_lid l in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun l1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.Discriminator l1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Action.FStar_Reflection_Constants.lid
-             ->
-             let uu___3 = unembed' w e_lid l in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun l1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                    (FStar_Reflection_Data.Action l1))
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::(i, uu___3)::[])
-             when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_Projector.FStar_Reflection_Constants.lid
-             ->
-             let uu___4 = unembed' w e_lid l in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun l1 ->
-                  let uu___5 = unembed' w e_ident i in
-                  FStar_Compiler_Util.bind_opt uu___5
-                    (fun i1 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                         (FStar_Reflection_Data.Projector (l1, i1))))
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (ids1, uu___2)::(ids2, uu___3)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_RecordType.FStar_Reflection_Constants.lid
-             ->
-             let uu___4 =
-               let uu___5 = FStar_Syntax_Embeddings.e_list e_ident in
-               unembed' w uu___5 ids1 in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun ids11 ->
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_Embeddings.e_list e_ident in
-                    unembed' w uu___6 ids2 in
-                  FStar_Compiler_Util.bind_opt uu___5
-                    (fun ids21 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                         (FStar_Reflection_Data.RecordType (ids11, ids21))))
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (ids1, uu___2)::(ids2, uu___3)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Reflection_Constants.ref_qual_RecordConstructor.FStar_Reflection_Constants.lid
-             ->
-             let uu___4 =
-               let uu___5 = FStar_Syntax_Embeddings.e_list e_ident in
-               unembed' w uu___5 ids1 in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun ids11 ->
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_Embeddings.e_list e_ident in
-                    unembed' w uu___6 ids2 in
-                  FStar_Compiler_Util.bind_opt uu___5
-                    (fun ids21 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)
-                         (FStar_Reflection_Data.RecordConstructor
-                            (ids11, ids21))))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded qualifier: %s" uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t1.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb embed1 unembed FStar_Reflection_Constants.fstar_refl_qualifier
-let (e_qualifiers :
-  FStar_Reflection_Data.qualifier Prims.list
-    FStar_Syntax_Embeddings.embedding)
-  = FStar_Syntax_Embeddings.e_list e_qualifier
-let (unfold_lazy_bv :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let bv = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Reflection_Basic.inspect_bv bv in
-          embed e_bv_view i.FStar_Syntax_Syntax.rng uu___3 in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      [uu___1] in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.fstar_refl_pack_bv.FStar_Reflection_Constants.t
-      uu___ i.FStar_Syntax_Syntax.rng
-let (unfold_lazy_binder :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let binder = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let uu___ = FStar_Reflection_Basic.inspect_binder binder in
-    match uu___ with
-    | (bv, (aq, attrs)) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = embed e_bv i.FStar_Syntax_Syntax.rng bv in
-            FStar_Syntax_Syntax.as_arg uu___3 in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = embed e_aqualv i.FStar_Syntax_Syntax.rng aq in
-              FStar_Syntax_Syntax.as_arg uu___5 in
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  embed e_attributes i.FStar_Syntax_Syntax.rng attrs in
-                FStar_Syntax_Syntax.as_arg uu___7 in
-              [uu___6] in
-            uu___4 :: uu___5 in
-          uu___2 :: uu___3 in
-        FStar_Syntax_Syntax.mk_Tm_app
-          FStar_Reflection_Constants.fstar_refl_pack_binder.FStar_Reflection_Constants.t
-          uu___1 i.FStar_Syntax_Syntax.rng
-let (unfold_lazy_letbinding :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let lb = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let lbv = FStar_Reflection_Basic.inspect_lb lb in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          embed e_fv i.FStar_Syntax_Syntax.rng
-            lbv.FStar_Reflection_Data.lb_fv in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            embed e_univ_names i.FStar_Syntax_Syntax.rng
-              lbv.FStar_Reflection_Data.lb_us in
-          FStar_Syntax_Syntax.as_arg uu___4 in
-        let uu___4 =
-          let uu___5 =
-            let uu___6 =
-              embed e_term i.FStar_Syntax_Syntax.rng
-                lbv.FStar_Reflection_Data.lb_typ in
-            FStar_Syntax_Syntax.as_arg uu___6 in
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                embed e_term i.FStar_Syntax_Syntax.rng
-                  lbv.FStar_Reflection_Data.lb_def in
-              FStar_Syntax_Syntax.as_arg uu___8 in
-            [uu___7] in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.fstar_refl_pack_lb.FStar_Reflection_Constants.t
-      uu___ i.FStar_Syntax_Syntax.rng
-let (unfold_lazy_fvar :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let fv = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            FStar_Syntax_Embeddings.e_list FStar_Syntax_Embeddings.e_string in
-          let uu___4 = FStar_Reflection_Basic.inspect_fv fv in
-          embed uu___3 i.FStar_Syntax_Syntax.rng uu___4 in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      [uu___1] in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.fstar_refl_pack_fv.FStar_Reflection_Constants.t
-      uu___ i.FStar_Syntax_Syntax.rng
-let (unfold_lazy_comp :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let comp = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Reflection_Basic.inspect_comp comp in
-          embed e_comp_view i.FStar_Syntax_Syntax.rng uu___3 in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      [uu___1] in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.fstar_refl_pack_comp.FStar_Reflection_Constants.t
-      uu___ i.FStar_Syntax_Syntax.rng
-let (unfold_lazy_env :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i -> FStar_Syntax_Util.exp_unit
-let (unfold_lazy_optionstate :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i -> FStar_Syntax_Util.exp_unit
-let (unfold_lazy_sigelt :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let sigelt = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Reflection_Basic.inspect_sigelt sigelt in
-          embed e_sigelt_view i.FStar_Syntax_Syntax.rng uu___3 in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      [uu___1] in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.fstar_refl_pack_sigelt.FStar_Reflection_Constants.t
-      uu___ i.FStar_Syntax_Syntax.rng
-let (unfold_lazy_universe :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    let u = FStar_Compiler_Dyn.undyn i.FStar_Syntax_Syntax.blob in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Reflection_Basic.inspect_universe u in
-          embed e_universe_view i.FStar_Syntax_Syntax.rng uu___3 in
-        FStar_Syntax_Syntax.as_arg uu___2 in
-      [uu___1] in
-    FStar_Syntax_Syntax.mk_Tm_app
-      FStar_Reflection_Constants.fstar_refl_pack_universe.FStar_Reflection_Constants.t
-      uu___ i.FStar_Syntax_Syntax.rng
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Reflection_Interpreter.ml b/src/ocaml-output/FStar_Reflection_Interpreter.ml
deleted file mode 100644
index 652e51ebc5a..00000000000
--- a/src/ocaml-output/FStar_Reflection_Interpreter.ml
+++ /dev/null
@@ -1,721 +0,0 @@
-open Prims
-let unembed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Embeddings.norm_cb ->
-          'uuuuu FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun a ->
-      fun norm_cb ->
-        let uu___ = FStar_Syntax_Embeddings.unembed ea a in
-        uu___ true norm_cb
-let try_unembed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Embeddings.norm_cb ->
-          'uuuuu FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun a ->
-      fun norm_cb ->
-        let uu___ = FStar_Syntax_Embeddings.unembed ea a in
-        uu___ false norm_cb
-let embed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Compiler_Range.range ->
-        'uuuuu -> FStar_Syntax_Embeddings.norm_cb -> FStar_Syntax_Syntax.term
-  =
-  fun ea ->
-    fun r ->
-      fun x ->
-        fun norm_cb ->
-          let uu___ = FStar_Syntax_Embeddings.embed ea x in
-          uu___ r FStar_Pervasives_Native.None norm_cb
-let int1 :
-  'a 'r .
-    FStar_Ident.lid ->
-      ('a -> 'r) ->
-        'a FStar_Syntax_Embeddings.embedding ->
-          'r FStar_Syntax_Embeddings.embedding ->
-            FStar_TypeChecker_Cfg.psc ->
-              FStar_Syntax_Embeddings.norm_cb ->
-                FStar_Syntax_Syntax.args ->
-                  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun f ->
-      fun ea ->
-        fun er ->
-          fun psc ->
-            fun n ->
-              fun args ->
-                match args with
-                | (a1, uu___)::[] ->
-                    let uu___1 = try_unembed ea a1 n in
-                    FStar_Compiler_Util.bind_opt uu___1
-                      (fun a2 ->
-                         let uu___2 =
-                           let uu___3 = FStar_TypeChecker_Cfg.psc_range psc in
-                           let uu___4 = f a2 in embed er uu___3 uu___4 n in
-                         FStar_Pervasives_Native.Some uu___2)
-                | uu___ -> FStar_Pervasives_Native.None
-let int2 :
-  'a 'b 'r .
-    FStar_Ident.lid ->
-      ('a -> 'b -> 'r) ->
-        'a FStar_Syntax_Embeddings.embedding ->
-          'b FStar_Syntax_Embeddings.embedding ->
-            'r FStar_Syntax_Embeddings.embedding ->
-              FStar_TypeChecker_Cfg.psc ->
-                FStar_Syntax_Embeddings.norm_cb ->
-                  FStar_Syntax_Syntax.args ->
-                    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun f ->
-      fun ea ->
-        fun eb ->
-          fun er ->
-            fun psc ->
-              fun n ->
-                fun args ->
-                  match args with
-                  | (a1, uu___)::(b1, uu___1)::[] ->
-                      let uu___2 = try_unembed ea a1 n in
-                      FStar_Compiler_Util.bind_opt uu___2
-                        (fun a2 ->
-                           let uu___3 = try_unembed eb b1 n in
-                           FStar_Compiler_Util.bind_opt uu___3
-                             (fun b2 ->
-                                let uu___4 =
-                                  let uu___5 =
-                                    FStar_TypeChecker_Cfg.psc_range psc in
-                                  let uu___6 = f a2 b2 in
-                                  embed er uu___5 uu___6 n in
-                                FStar_Pervasives_Native.Some uu___4))
-                  | uu___ -> FStar_Pervasives_Native.None
-let int3 :
-  'a 'b 'c 'r .
-    FStar_Ident.lid ->
-      ('a -> 'b -> 'c -> 'r) ->
-        'a FStar_Syntax_Embeddings.embedding ->
-          'b FStar_Syntax_Embeddings.embedding ->
-            'c FStar_Syntax_Embeddings.embedding ->
-              'r FStar_Syntax_Embeddings.embedding ->
-                FStar_TypeChecker_Cfg.psc ->
-                  FStar_Syntax_Embeddings.norm_cb ->
-                    FStar_Syntax_Syntax.args ->
-                      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun f ->
-      fun ea ->
-        fun eb ->
-          fun ec ->
-            fun er ->
-              fun psc ->
-                fun n ->
-                  fun args ->
-                    match args with
-                    | (a1, uu___)::(b1, uu___1)::(c1, uu___2)::[] ->
-                        let uu___3 = try_unembed ea a1 n in
-                        FStar_Compiler_Util.bind_opt uu___3
-                          (fun a2 ->
-                             let uu___4 = try_unembed eb b1 n in
-                             FStar_Compiler_Util.bind_opt uu___4
-                               (fun b2 ->
-                                  let uu___5 = try_unembed ec c1 n in
-                                  FStar_Compiler_Util.bind_opt uu___5
-                                    (fun c2 ->
-                                       let uu___6 =
-                                         let uu___7 =
-                                           FStar_TypeChecker_Cfg.psc_range
-                                             psc in
-                                         let uu___8 = f a2 b2 c2 in
-                                         embed er uu___7 uu___8 n in
-                                       FStar_Pervasives_Native.Some uu___6)))
-                    | uu___ -> FStar_Pervasives_Native.None
-let nbe_int1 :
-  'a 'r .
-    FStar_Ident.lid ->
-      ('a -> 'r) ->
-        'a FStar_TypeChecker_NBETerm.embedding ->
-          'r FStar_TypeChecker_NBETerm.embedding ->
-            FStar_TypeChecker_NBETerm.nbe_cbs ->
-              FStar_TypeChecker_NBETerm.args ->
-                FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun f ->
-      fun ea ->
-        fun er ->
-          fun cb ->
-            fun args ->
-              match args with
-              | (a1, uu___)::[] ->
-                  let uu___1 = FStar_TypeChecker_NBETerm.unembed ea cb a1 in
-                  FStar_Compiler_Util.bind_opt uu___1
-                    (fun a2 ->
-                       let uu___2 =
-                         let uu___3 = f a2 in
-                         FStar_TypeChecker_NBETerm.embed er cb uu___3 in
-                       FStar_Pervasives_Native.Some uu___2)
-              | uu___ -> FStar_Pervasives_Native.None
-let nbe_int2 :
-  'a 'b 'r .
-    FStar_Ident.lid ->
-      ('a -> 'b -> 'r) ->
-        'a FStar_TypeChecker_NBETerm.embedding ->
-          'b FStar_TypeChecker_NBETerm.embedding ->
-            'r FStar_TypeChecker_NBETerm.embedding ->
-              FStar_TypeChecker_NBETerm.nbe_cbs ->
-                FStar_TypeChecker_NBETerm.args ->
-                  FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun f ->
-      fun ea ->
-        fun eb ->
-          fun er ->
-            fun cb ->
-              fun args ->
-                match args with
-                | (a1, uu___)::(b1, uu___1)::[] ->
-                    let uu___2 = FStar_TypeChecker_NBETerm.unembed ea cb a1 in
-                    FStar_Compiler_Util.bind_opt uu___2
-                      (fun a2 ->
-                         let uu___3 =
-                           FStar_TypeChecker_NBETerm.unembed eb cb b1 in
-                         FStar_Compiler_Util.bind_opt uu___3
-                           (fun b2 ->
-                              let uu___4 =
-                                let uu___5 = f a2 b2 in
-                                FStar_TypeChecker_NBETerm.embed er cb uu___5 in
-                              FStar_Pervasives_Native.Some uu___4))
-                | uu___ -> FStar_Pervasives_Native.None
-let nbe_int3 :
-  'a 'b 'c 'r .
-    FStar_Ident.lid ->
-      ('a -> 'b -> 'c -> 'r) ->
-        'a FStar_TypeChecker_NBETerm.embedding ->
-          'b FStar_TypeChecker_NBETerm.embedding ->
-            'c FStar_TypeChecker_NBETerm.embedding ->
-              'r FStar_TypeChecker_NBETerm.embedding ->
-                FStar_TypeChecker_NBETerm.nbe_cbs ->
-                  FStar_TypeChecker_NBETerm.args ->
-                    FStar_TypeChecker_NBETerm.t
-                      FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun f ->
-      fun ea ->
-        fun eb ->
-          fun ec ->
-            fun er ->
-              fun cb ->
-                fun args ->
-                  match args with
-                  | (a1, uu___)::(b1, uu___1)::(c1, uu___2)::[] ->
-                      let uu___3 = FStar_TypeChecker_NBETerm.unembed ea cb a1 in
-                      FStar_Compiler_Util.bind_opt uu___3
-                        (fun a2 ->
-                           let uu___4 =
-                             FStar_TypeChecker_NBETerm.unembed eb cb b1 in
-                           FStar_Compiler_Util.bind_opt uu___4
-                             (fun b2 ->
-                                let uu___5 =
-                                  FStar_TypeChecker_NBETerm.unembed ec cb c1 in
-                                FStar_Compiler_Util.bind_opt uu___5
-                                  (fun c2 ->
-                                     let uu___6 =
-                                       let uu___7 = f a2 b2 c2 in
-                                       FStar_TypeChecker_NBETerm.embed er cb
-                                         uu___7 in
-                                     FStar_Pervasives_Native.Some uu___6)))
-                  | uu___ -> FStar_Pervasives_Native.None
-let (mklid : Prims.string -> FStar_Ident.lid) =
-  fun nm -> FStar_Reflection_Constants.fstar_refl_builtins_lid nm
-let (mk :
-  FStar_Ident.lid ->
-    Prims.int ->
-      (FStar_TypeChecker_Cfg.psc ->
-         FStar_Syntax_Embeddings.norm_cb ->
-           FStar_Syntax_Syntax.args ->
-             FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-        ->
-        (FStar_TypeChecker_NBETerm.nbe_cbs ->
-           FStar_TypeChecker_NBETerm.args ->
-             FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option)
-          -> FStar_TypeChecker_Cfg.primitive_step)
-  =
-  fun l ->
-    fun arity ->
-      fun fn ->
-        fun nbe_fn ->
-          {
-            FStar_TypeChecker_Cfg.name = l;
-            FStar_TypeChecker_Cfg.arity = arity;
-            FStar_TypeChecker_Cfg.univ_arity = Prims.int_zero;
-            FStar_TypeChecker_Cfg.auto_reflect = FStar_Pervasives_Native.None;
-            FStar_TypeChecker_Cfg.strong_reduction_ok = true;
-            FStar_TypeChecker_Cfg.requires_binder_substitution = false;
-            FStar_TypeChecker_Cfg.interpretation =
-              (fun psc -> fun cbs -> fun _us -> fun args -> fn psc cbs args);
-            FStar_TypeChecker_Cfg.interpretation_nbe =
-              (fun cbs -> fun _us -> fun args -> nbe_fn cbs args)
-          }
-type 'a dualemb =
-  ('a FStar_Syntax_Embeddings.embedding * 'a
-    FStar_TypeChecker_NBETerm.embedding)
-let (e_int : FStar_BigInt.t dualemb) =
-  (FStar_Syntax_Embeddings.e_int, FStar_TypeChecker_NBETerm.e_int)
-let (e_bool : Prims.bool dualemb) =
-  (FStar_Syntax_Embeddings.e_bool, FStar_TypeChecker_NBETerm.e_bool)
-let (e_string : Prims.string dualemb) =
-  (FStar_Syntax_Embeddings.e_string, FStar_TypeChecker_NBETerm.e_string)
-let (e_order : FStar_Order.order dualemb) =
-  (FStar_Reflection_Embeddings.e_order,
-    FStar_Reflection_NBEEmbeddings.e_order)
-let (e_term : FStar_Syntax_Syntax.term dualemb) =
-  (FStar_Reflection_Embeddings.e_term, FStar_Reflection_NBEEmbeddings.e_term)
-let (e_term_view : FStar_Reflection_Data.term_view dualemb) =
-  (FStar_Reflection_Embeddings.e_term_view,
-    FStar_Reflection_NBEEmbeddings.e_term_view)
-let (e_fv : FStar_Syntax_Syntax.fv dualemb) =
-  (FStar_Reflection_Embeddings.e_fv, FStar_Reflection_NBEEmbeddings.e_fv)
-let (e_bv : FStar_Syntax_Syntax.bv dualemb) =
-  (FStar_Reflection_Embeddings.e_bv, FStar_Reflection_NBEEmbeddings.e_bv)
-let (e_bv_view : FStar_Reflection_Data.bv_view dualemb) =
-  (FStar_Reflection_Embeddings.e_bv_view,
-    FStar_Reflection_NBEEmbeddings.e_bv_view)
-let (e_comp : FStar_Syntax_Syntax.comp dualemb) =
-  (FStar_Reflection_Embeddings.e_comp, FStar_Reflection_NBEEmbeddings.e_comp)
-let (e_comp_view : FStar_Reflection_Data.comp_view dualemb) =
-  (FStar_Reflection_Embeddings.e_comp_view,
-    FStar_Reflection_NBEEmbeddings.e_comp_view)
-let (e_universe : FStar_Syntax_Syntax.universe dualemb) =
-  (FStar_Reflection_Embeddings.e_universe,
-    FStar_Reflection_NBEEmbeddings.e_universe)
-let (e_universe_view : FStar_Reflection_Data.universe_view dualemb) =
-  (FStar_Reflection_Embeddings.e_universe_view,
-    FStar_Reflection_NBEEmbeddings.e_universe_view)
-let (e_sigelt : FStar_Syntax_Syntax.sigelt dualemb) =
-  (FStar_Reflection_Embeddings.e_sigelt,
-    FStar_Reflection_NBEEmbeddings.e_sigelt)
-let (e_sigelt_view : FStar_Reflection_Data.sigelt_view dualemb) =
-  (FStar_Reflection_Embeddings.e_sigelt_view,
-    FStar_Reflection_NBEEmbeddings.e_sigelt_view)
-let (e_binder : FStar_Syntax_Syntax.binder dualemb) =
-  (FStar_Reflection_Embeddings.e_binder,
-    FStar_Reflection_NBEEmbeddings.e_binder)
-let (e_binder_view : FStar_Reflection_Data.binder_view dualemb) =
-  (FStar_Reflection_Embeddings.e_binder_view,
-    FStar_Reflection_NBEEmbeddings.e_binder_view)
-let (e_binders : FStar_Syntax_Syntax.binders dualemb) =
-  (FStar_Reflection_Embeddings.e_binders,
-    FStar_Reflection_NBEEmbeddings.e_binders)
-let (e_letbinding : FStar_Syntax_Syntax.letbinding dualemb) =
-  (FStar_Reflection_Embeddings.e_letbinding,
-    FStar_Reflection_NBEEmbeddings.e_letbinding)
-let (e_lb_view : FStar_Reflection_Data.lb_view dualemb) =
-  (FStar_Reflection_Embeddings.e_lb_view,
-    FStar_Reflection_NBEEmbeddings.e_lb_view)
-let (e_env : FStar_TypeChecker_Env.env dualemb) =
-  (FStar_Reflection_Embeddings.e_env, FStar_Reflection_NBEEmbeddings.e_env)
-let (e_aqualv : FStar_Reflection_Data.aqualv dualemb) =
-  (FStar_Reflection_Embeddings.e_aqualv,
-    FStar_Reflection_NBEEmbeddings.e_aqualv)
-let (e_vconfig : FStar_VConfig.vconfig dualemb) =
-  (FStar_Syntax_Embeddings.e_vconfig, FStar_TypeChecker_NBETerm.e_vconfig)
-let (e_attributes : FStar_Syntax_Syntax.attribute Prims.list dualemb) =
-  (FStar_Reflection_Embeddings.e_attributes,
-    FStar_Reflection_NBEEmbeddings.e_attributes)
-let (e_qualifiers : FStar_Reflection_Data.qualifiers dualemb) =
-  (FStar_Reflection_Embeddings.e_qualifiers,
-    FStar_Reflection_NBEEmbeddings.e_qualifiers)
-let e_list : 'a . 'a dualemb -> 'a Prims.list dualemb =
-  fun e ->
-    let uu___ =
-      FStar_Syntax_Embeddings.e_list (FStar_Pervasives_Native.fst e) in
-    let uu___1 =
-      FStar_TypeChecker_NBETerm.e_list (FStar_Pervasives_Native.snd e) in
-    (uu___, uu___1)
-let e_option : 'a . 'a dualemb -> 'a FStar_Pervasives_Native.option dualemb =
-  fun e ->
-    let uu___ =
-      FStar_Syntax_Embeddings.e_option (FStar_Pervasives_Native.fst e) in
-    let uu___1 =
-      FStar_TypeChecker_NBETerm.e_option (FStar_Pervasives_Native.snd e) in
-    (uu___, uu___1)
-let (e_string_list : Prims.string Prims.list dualemb) = e_list e_string
-let mk1 :
-  'a 'r .
-    Prims.string ->
-      ('a -> 'r) ->
-        'a dualemb -> 'r dualemb -> FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nm ->
-    fun f ->
-      fun ea ->
-        fun er ->
-          let l = mklid nm in
-          mk l Prims.int_one
-            (int1 l f (FStar_Pervasives_Native.fst ea)
-               (FStar_Pervasives_Native.fst er))
-            (nbe_int1 l f (FStar_Pervasives_Native.snd ea)
-               (FStar_Pervasives_Native.snd er))
-let mk2 :
-  'a 'b 'r .
-    Prims.string ->
-      ('a -> 'b -> 'r) ->
-        'a dualemb ->
-          'b dualemb -> 'r dualemb -> FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nm ->
-    fun f ->
-      fun ea ->
-        fun eb ->
-          fun er ->
-            let l = mklid nm in
-            mk l (Prims.of_int (2))
-              (int2 l f (FStar_Pervasives_Native.fst ea)
-                 (FStar_Pervasives_Native.fst eb)
-                 (FStar_Pervasives_Native.fst er))
-              (nbe_int2 l f (FStar_Pervasives_Native.snd ea)
-                 (FStar_Pervasives_Native.snd eb)
-                 (FStar_Pervasives_Native.snd er))
-let mk3 :
-  'a 'b 'c 'r .
-    Prims.string ->
-      ('a -> 'b -> 'c -> 'r) ->
-        'a dualemb ->
-          'b dualemb ->
-            'c dualemb -> 'r dualemb -> FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nm ->
-    fun f ->
-      fun ea ->
-        fun eb ->
-          fun ec ->
-            fun er ->
-              let l = mklid nm in
-              mk l (Prims.of_int (3))
-                (int3 l f (FStar_Pervasives_Native.fst ea)
-                   (FStar_Pervasives_Native.fst eb)
-                   (FStar_Pervasives_Native.fst ec)
-                   (FStar_Pervasives_Native.fst er))
-                (nbe_int3 l f (FStar_Pervasives_Native.snd ea)
-                   (FStar_Pervasives_Native.snd eb)
-                   (FStar_Pervasives_Native.snd ec)
-                   (FStar_Pervasives_Native.snd er))
-let (reflection_primops : FStar_TypeChecker_Cfg.primitive_step Prims.list) =
-  let uu___ =
-    mk1 "inspect_ln" FStar_Reflection_Basic.inspect_ln e_term e_term_view in
-  let uu___1 =
-    let uu___2 =
-      mk1 "pack_ln" FStar_Reflection_Basic.pack_ln e_term_view e_term in
-    let uu___3 =
-      let uu___4 =
-        mk1 "inspect_fv" FStar_Reflection_Basic.inspect_fv e_fv e_string_list in
-      let uu___5 =
-        let uu___6 =
-          mk1 "pack_fv" FStar_Reflection_Basic.pack_fv e_string_list e_fv in
-        let uu___7 =
-          let uu___8 =
-            mk1 "inspect_comp" FStar_Reflection_Basic.inspect_comp e_comp
-              e_comp_view in
-          let uu___9 =
-            let uu___10 =
-              mk1 "pack_comp" FStar_Reflection_Basic.pack_comp e_comp_view
-                e_comp in
-            let uu___11 =
-              let uu___12 =
-                mk1 "inspect_universe"
-                  FStar_Reflection_Basic.inspect_universe e_universe
-                  e_universe_view in
-              let uu___13 =
-                let uu___14 =
-                  mk1 "pack_universe" FStar_Reflection_Basic.pack_universe
-                    e_universe_view e_universe in
-                let uu___15 =
-                  let uu___16 =
-                    mk1 "inspect_sigelt"
-                      FStar_Reflection_Basic.inspect_sigelt e_sigelt
-                      e_sigelt_view in
-                  let uu___17 =
-                    let uu___18 =
-                      mk1 "pack_sigelt" FStar_Reflection_Basic.pack_sigelt
-                        e_sigelt_view e_sigelt in
-                    let uu___19 =
-                      let uu___20 =
-                        mk1 "inspect_lb" FStar_Reflection_Basic.inspect_lb
-                          e_letbinding e_lb_view in
-                      let uu___21 =
-                        let uu___22 =
-                          mk1 "pack_lb" FStar_Reflection_Basic.pack_lb
-                            e_lb_view e_letbinding in
-                        let uu___23 =
-                          let uu___24 =
-                            mk1 "inspect_bv"
-                              FStar_Reflection_Basic.inspect_bv e_bv
-                              e_bv_view in
-                          let uu___25 =
-                            let uu___26 =
-                              mk1 "pack_bv" FStar_Reflection_Basic.pack_bv
-                                e_bv_view e_bv in
-                            let uu___27 =
-                              let uu___28 =
-                                mk1 "inspect_binder"
-                                  FStar_Reflection_Basic.inspect_binder
-                                  e_binder e_binder_view in
-                              let uu___29 =
-                                let uu___30 =
-                                  let uu___31 = e_list e_term in
-                                  mk3 "pack_binder"
-                                    FStar_Reflection_Basic.pack_binder e_bv
-                                    e_aqualv uu___31 e_binder in
-                                let uu___31 =
-                                  let uu___32 =
-                                    let uu___33 = e_option e_vconfig in
-                                    mk1 "sigelt_opts"
-                                      FStar_Reflection_Basic.sigelt_opts
-                                      e_sigelt uu___33 in
-                                  let uu___33 =
-                                    let uu___34 =
-                                      mk1 "embed_vconfig"
-                                        FStar_Reflection_Basic.embed_vconfig
-                                        e_vconfig e_term in
-                                    let uu___35 =
-                                      let uu___36 =
-                                        mk1 "sigelt_attrs"
-                                          FStar_Reflection_Basic.sigelt_attrs
-                                          e_sigelt e_attributes in
-                                      let uu___37 =
-                                        let uu___38 =
-                                          mk2 "set_sigelt_attrs"
-                                            FStar_Reflection_Basic.set_sigelt_attrs
-                                            e_attributes e_sigelt e_sigelt in
-                                        let uu___39 =
-                                          let uu___40 =
-                                            mk1 "sigelt_quals"
-                                              FStar_Reflection_Basic.sigelt_quals
-                                              e_sigelt e_qualifiers in
-                                          let uu___41 =
-                                            let uu___42 =
-                                              mk2 "set_sigelt_quals"
-                                                FStar_Reflection_Basic.set_sigelt_quals
-                                                e_qualifiers e_sigelt
-                                                e_sigelt in
-                                            let uu___43 =
-                                              let uu___44 =
-                                                mk3 "subst"
-                                                  FStar_Reflection_Basic.subst
-                                                  e_bv e_term e_term e_term in
-                                              let uu___45 =
-                                                let uu___46 =
-                                                  mk2 "close_term"
-                                                    FStar_Reflection_Basic.close_term
-                                                    e_binder e_term e_term in
-                                                let uu___47 =
-                                                  let uu___48 =
-                                                    mk2 "compare_bv"
-                                                      FStar_Reflection_Basic.compare_bv
-                                                      e_bv e_bv e_order in
-                                                  let uu___49 =
-                                                    let uu___50 =
-                                                      mk2 "is_free"
-                                                        FStar_Reflection_Basic.is_free
-                                                        e_bv e_term e_bool in
-                                                    let uu___51 =
-                                                      let uu___52 =
-                                                        let uu___53 =
-                                                          e_list e_bv in
-                                                        mk1 "free_bvs"
-                                                          FStar_Reflection_Basic.free_bvs
-                                                          e_term uu___53 in
-                                                      let uu___53 =
-                                                        let uu___54 =
-                                                          let uu___55 =
-                                                            e_list e_int in
-                                                          mk1 "free_uvars"
-                                                            FStar_Reflection_Basic.free_uvars
-                                                            e_term uu___55 in
-                                                        let uu___55 =
-                                                          let uu___56 =
-                                                            let uu___57 =
-                                                              e_list e_fv in
-                                                            mk2 "lookup_attr"
-                                                              FStar_Reflection_Basic.lookup_attr
-                                                              e_term e_env
-                                                              uu___57 in
-                                                          let uu___57 =
-                                                            let uu___58 =
-                                                              let uu___59 =
-                                                                e_list e_fv in
-                                                              mk1
-                                                                "all_defs_in_env"
-                                                                FStar_Reflection_Basic.all_defs_in_env
-                                                                e_env uu___59 in
-                                                            let uu___59 =
-                                                              let uu___60 =
-                                                                let uu___61 =
-                                                                  e_list e_fv in
-                                                                mk2
-                                                                  "defs_in_module"
-                                                                  FStar_Reflection_Basic.defs_in_module
-                                                                  e_env
-                                                                  e_string_list
-                                                                  uu___61 in
-                                                              let uu___61 =
-                                                                let uu___62 =
-                                                                  mk2
-                                                                    "term_eq"
-                                                                    FStar_Reflection_Basic.term_eq
-                                                                    e_term
-                                                                    e_term
-                                                                    e_bool in
-                                                                let uu___63 =
-                                                                  let uu___64
-                                                                    =
-                                                                    mk1
-                                                                    "moduleof"
-                                                                    FStar_Reflection_Basic.moduleof
-                                                                    e_env
-                                                                    e_string_list in
-                                                                  let uu___65
-                                                                    =
-                                                                    let uu___66
-                                                                    =
-                                                                    mk1
-                                                                    "binders_of_env"
-                                                                    FStar_Reflection_Basic.binders_of_env
-                                                                    e_env
-                                                                    e_binders in
-                                                                    let uu___67
-                                                                    =
-                                                                    let uu___68
-                                                                    =
-                                                                    let uu___69
-                                                                    =
-                                                                    e_option
-                                                                    e_sigelt in
-                                                                    mk2
-                                                                    "lookup_typ"
-                                                                    FStar_Reflection_Basic.lookup_typ
-                                                                    e_env
-                                                                    e_string_list
-                                                                    uu___69 in
-                                                                    let uu___69
-                                                                    =
-                                                                    let uu___70
-                                                                    =
-                                                                    let uu___71
-                                                                    =
-                                                                    e_list
-                                                                    e_string_list in
-                                                                    mk1
-                                                                    "env_open_modules"
-                                                                    FStar_Reflection_Basic.env_open_modules
-                                                                    e_env
-                                                                    uu___71 in
-                                                                    let uu___71
-                                                                    =
-                                                                    let uu___72
-                                                                    =
-                                                                    mk1
-                                                                    "implode_qn"
-                                                                    FStar_Reflection_Basic.implode_qn
-                                                                    e_string_list
-                                                                    e_string in
-                                                                    let uu___73
-                                                                    =
-                                                                    let uu___74
-                                                                    =
-                                                                    mk1
-                                                                    "explode_qn"
-                                                                    FStar_Reflection_Basic.explode_qn
-                                                                    e_string
-                                                                    e_string_list in
-                                                                    let uu___75
-                                                                    =
-                                                                    let uu___76
-                                                                    =
-                                                                    mk2
-                                                                    "compare_string"
-                                                                    FStar_Reflection_Basic.compare_string
-                                                                    e_string
-                                                                    e_string
-                                                                    e_int in
-                                                                    let uu___77
-                                                                    =
-                                                                    let uu___78
-                                                                    =
-                                                                    mk2
-                                                                    "push_binder"
-                                                                    FStar_Reflection_Basic.push_binder
-                                                                    e_env
-                                                                    e_binder
-                                                                    e_env in
-                                                                    [uu___78] in
-                                                                    uu___76
-                                                                    ::
-                                                                    uu___77 in
-                                                                    uu___74
-                                                                    ::
-                                                                    uu___75 in
-                                                                    uu___72
-                                                                    ::
-                                                                    uu___73 in
-                                                                    uu___70
-                                                                    ::
-                                                                    uu___71 in
-                                                                    uu___68
-                                                                    ::
-                                                                    uu___69 in
-                                                                    uu___66
-                                                                    ::
-                                                                    uu___67 in
-                                                                  uu___64 ::
-                                                                    uu___65 in
-                                                                uu___62 ::
-                                                                  uu___63 in
-                                                              uu___60 ::
-                                                                uu___61 in
-                                                            uu___58 ::
-                                                              uu___59 in
-                                                          uu___56 :: uu___57 in
-                                                        uu___54 :: uu___55 in
-                                                      uu___52 :: uu___53 in
-                                                    uu___50 :: uu___51 in
-                                                  uu___48 :: uu___49 in
-                                                uu___46 :: uu___47 in
-                                              uu___44 :: uu___45 in
-                                            uu___42 :: uu___43 in
-                                          uu___40 :: uu___41 in
-                                        uu___38 :: uu___39 in
-                                      uu___36 :: uu___37 in
-                                    uu___34 :: uu___35 in
-                                  uu___32 :: uu___33 in
-                                uu___30 :: uu___31 in
-                              uu___28 :: uu___29 in
-                            uu___26 :: uu___27 in
-                          uu___24 :: uu___25 in
-                        uu___22 :: uu___23 in
-                      uu___20 :: uu___21 in
-                    uu___18 :: uu___19 in
-                  uu___16 :: uu___17 in
-                uu___14 :: uu___15 in
-              uu___12 :: uu___13 in
-            uu___10 :: uu___11 in
-          uu___8 :: uu___9 in
-        uu___6 :: uu___7 in
-      uu___4 :: uu___5 in
-    uu___2 :: uu___3 in
-  uu___ :: uu___1
-let (uu___200 : unit) =
-  FStar_Compiler_List.iter FStar_TypeChecker_Cfg.register_extra_step
-    reflection_primops
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Reflection_NBEEmbeddings.ml b/src/ocaml-output/FStar_Reflection_NBEEmbeddings.ml
deleted file mode 100644
index 29a02076816..00000000000
--- a/src/ocaml-output/FStar_Reflection_NBEEmbeddings.ml
+++ /dev/null
@@ -1,2450 +0,0 @@
-open Prims
-let (mkFV :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.universe Prims.list ->
-      (FStar_TypeChecker_NBETerm.t * FStar_Syntax_Syntax.aqual) Prims.list ->
-        FStar_TypeChecker_NBETerm.t)
-  =
-  fun fv ->
-    fun us ->
-      fun ts ->
-        FStar_TypeChecker_NBETerm.mkFV fv (FStar_Compiler_List.rev us)
-          (FStar_Compiler_List.rev ts)
-let (mkConstruct :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.universe Prims.list ->
-      (FStar_TypeChecker_NBETerm.t * FStar_Syntax_Syntax.aqual) Prims.list ->
-        FStar_TypeChecker_NBETerm.t)
-  =
-  fun fv ->
-    fun us ->
-      fun ts ->
-        FStar_TypeChecker_NBETerm.mkConstruct fv (FStar_Compiler_List.rev us)
-          (FStar_Compiler_List.rev ts)
-let (fv_as_emb_typ : FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.emb_typ) =
-  fun fv ->
-    let uu___ =
-      let uu___1 =
-        FStar_Ident.string_of_lid
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      (uu___1, []) in
-    FStar_Syntax_Syntax.ET_app uu___
-let mk_emb' :
-  'uuuuu .
-    (FStar_TypeChecker_NBETerm.nbe_cbs ->
-       'uuuuu -> FStar_TypeChecker_NBETerm.t)
-      ->
-      (FStar_TypeChecker_NBETerm.nbe_cbs ->
-         FStar_TypeChecker_NBETerm.t -> 'uuuuu FStar_Pervasives_Native.option)
-        ->
-        FStar_Syntax_Syntax.fv -> 'uuuuu FStar_TypeChecker_NBETerm.embedding
-  =
-  fun x ->
-    fun y ->
-      fun fv ->
-        let uu___ = mkFV fv [] [] in
-        let uu___1 = fv_as_emb_typ fv in
-        FStar_TypeChecker_NBETerm.mk_emb x y uu___ uu___1
-let mk_lazy :
-  'uuuuu .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      'uuuuu ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.lazy_kind -> FStar_TypeChecker_NBETerm.t
-  =
-  fun cb ->
-    fun obj ->
-      fun ty ->
-        fun kind ->
-          let li =
-            let uu___ = FStar_Compiler_Dyn.mkdyn obj in
-            {
-              FStar_Syntax_Syntax.blob = uu___;
-              FStar_Syntax_Syntax.lkind = kind;
-              FStar_Syntax_Syntax.ltyp = ty;
-              FStar_Syntax_Syntax.rng = FStar_Compiler_Range.dummyRange
-            } in
-          let thunk =
-            FStar_Thunk.mk
-              (fun uu___ ->
-                 let uu___1 = FStar_Syntax_Util.unfold_lazy li in
-                 FStar_TypeChecker_NBETerm.translate_cb cb uu___1) in
-          FStar_TypeChecker_NBETerm.mk_t
-            (FStar_TypeChecker_NBETerm.Lazy
-               ((FStar_Pervasives.Inl li), thunk))
-let (e_bv : FStar_Syntax_Syntax.bv FStar_TypeChecker_NBETerm.embedding) =
-  let embed_bv cb bv =
-    mk_lazy cb bv FStar_Reflection_Constants.fstar_refl_bv
-      FStar_Syntax_Syntax.Lazy_bv in
-  let unembed_bv cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_bv;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___4 -> FStar_Pervasives_Native.Some uu___4) uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded bv: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_bv unembed_bv FStar_Reflection_Constants.fstar_refl_bv_fv
-let (e_binder :
-  FStar_Syntax_Syntax.binder FStar_TypeChecker_NBETerm.embedding) =
-  let embed_binder cb b =
-    mk_lazy cb b FStar_Reflection_Constants.fstar_refl_binder
-      FStar_Syntax_Syntax.Lazy_binder in
-  let unembed_binder cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_binder;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded binder: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_binder unembed_binder
-    FStar_Reflection_Constants.fstar_refl_binder_fv
-let rec mapM_opt :
-  'a 'b .
-    ('a -> 'b FStar_Pervasives_Native.option) ->
-      'a Prims.list -> 'b Prims.list FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> FStar_Pervasives_Native.Some []
-      | x::xs ->
-          let uu___ = f x in
-          FStar_Compiler_Util.bind_opt uu___
-            (fun x1 ->
-               let uu___1 = mapM_opt f xs in
-               FStar_Compiler_Util.bind_opt uu___1
-                 (fun xs1 -> FStar_Pervasives_Native.Some (x1 :: xs1)))
-let (e_term_aq :
-  (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) Prims.list ->
-    FStar_Syntax_Syntax.term FStar_TypeChecker_NBETerm.embedding)
-  =
-  fun aq ->
-    let embed_term cb t =
-      let qi =
-        {
-          FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_static;
-          FStar_Syntax_Syntax.antiquotes = aq
-        } in
-      FStar_TypeChecker_NBETerm.mk_t
-        (FStar_TypeChecker_NBETerm.Quote (t, qi)) in
-    let rec unembed_term cb t =
-      match t.FStar_TypeChecker_NBETerm.nbe_t with
-      | FStar_TypeChecker_NBETerm.Quote (tm, qi) ->
-          FStar_Pervasives_Native.Some tm
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = mkFV FStar_Reflection_Constants.fstar_refl_term_fv [] [] in
-    let uu___1 = fv_as_emb_typ FStar_Reflection_Constants.fstar_refl_term_fv in
-    {
-      FStar_TypeChecker_NBETerm.em = embed_term;
-      FStar_TypeChecker_NBETerm.un = unembed_term;
-      FStar_TypeChecker_NBETerm.typ = uu___;
-      FStar_TypeChecker_NBETerm.emb_typ = uu___1
-    }
-let (e_term : FStar_Syntax_Syntax.term FStar_TypeChecker_NBETerm.embedding) =
-  e_term_aq []
-let (e_aqualv :
-  FStar_Reflection_Data.aqualv FStar_TypeChecker_NBETerm.embedding) =
-  let embed_aqualv cb q =
-    match q with
-    | FStar_Reflection_Data.Q_Explicit ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_Q_Explicit.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Q_Implicit ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_Q_Implicit.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Q_Meta t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_term cb t in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Q_Meta.FStar_Reflection_Constants.fv
-          [] uu___ in
-  let unembed_aqualv cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Q_Explicit.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Q_Explicit
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Q_Implicit.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Q_Implicit
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (t1, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Q_Meta.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun t2 ->
-             FStar_Pervasives_Native.Some (FStar_Reflection_Data.Q_Meta t2))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded aqualv: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    mkConstruct FStar_Reflection_Constants.fstar_refl_aqualv_fv [] [] in
-  let uu___1 = fv_as_emb_typ FStar_Reflection_Constants.fstar_refl_aqualv_fv in
-  FStar_TypeChecker_NBETerm.mk_emb embed_aqualv unembed_aqualv uu___ uu___1
-let (e_binders :
-  FStar_Syntax_Syntax.binders FStar_TypeChecker_NBETerm.embedding) =
-  FStar_TypeChecker_NBETerm.e_list e_binder
-let (e_fv : FStar_Syntax_Syntax.fv FStar_TypeChecker_NBETerm.embedding) =
-  let embed_fv cb fv =
-    mk_lazy cb fv FStar_Reflection_Constants.fstar_refl_fv
-      FStar_Syntax_Syntax.Lazy_fvar in
-  let unembed_fv cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_fvar;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded fvar: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_fv unembed_fv FStar_Reflection_Constants.fstar_refl_fv_fv
-let (e_comp : FStar_Syntax_Syntax.comp FStar_TypeChecker_NBETerm.embedding) =
-  let embed_comp cb c =
-    mk_lazy cb c FStar_Reflection_Constants.fstar_refl_comp
-      FStar_Syntax_Syntax.Lazy_comp in
-  let unembed_comp cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_comp;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded comp: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_comp unembed_comp
-    FStar_Reflection_Constants.fstar_refl_comp_fv
-let (e_env : FStar_TypeChecker_Env.env FStar_TypeChecker_NBETerm.embedding) =
-  let embed_env cb e =
-    mk_lazy cb e FStar_Reflection_Constants.fstar_refl_env
-      FStar_Syntax_Syntax.Lazy_env in
-  let unembed_env cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_env;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded env: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_env unembed_env FStar_Reflection_Constants.fstar_refl_env_fv
-let (e_const :
-  FStar_Reflection_Data.vconst FStar_TypeChecker_NBETerm.embedding) =
-  let embed_const cb c =
-    match c with
-    | FStar_Reflection_Data.C_Unit ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Unit.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.C_True ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_True.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.C_False ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_False.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.C_Int i ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Effect.op_Less_Bar
-                FStar_TypeChecker_NBETerm.mk_t
-                (FStar_TypeChecker_NBETerm.Constant
-                   (FStar_TypeChecker_NBETerm.Int i)) in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Int.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.C_String s ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.embed
-                FStar_TypeChecker_NBETerm.e_string cb s in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_String.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.C_Range r ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.embed
-                FStar_TypeChecker_NBETerm.e_range cb r in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Range.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.C_Reify ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Reify.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.C_Reflect ns ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.embed
-                FStar_TypeChecker_NBETerm.e_string_list cb ns in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Reflect.FStar_Reflection_Constants.fv
-          [] uu___ in
-  let unembed_const cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Unit.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_Unit
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_True.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_True
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_False.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_False
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (i, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Int.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 =
-          FStar_TypeChecker_NBETerm.unembed FStar_TypeChecker_NBETerm.e_int
-            cb i in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun i1 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-               (FStar_Reflection_Data.C_Int i1))
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (s, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_String.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 =
-          FStar_TypeChecker_NBETerm.unembed
-            FStar_TypeChecker_NBETerm.e_string cb s in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun s1 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-               (FStar_Reflection_Data.C_String s1))
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (r, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Range.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 =
-          FStar_TypeChecker_NBETerm.unembed FStar_TypeChecker_NBETerm.e_range
-            cb r in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun r1 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-               (FStar_Reflection_Data.C_Range r1))
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Reify.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.C_Reify
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (ns, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Reflect.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 =
-          FStar_TypeChecker_NBETerm.unembed
-            FStar_TypeChecker_NBETerm.e_string_list cb ns in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun ns1 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-               (FStar_Reflection_Data.C_Reflect ns1))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded vconst: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_const unembed_const
-    FStar_Reflection_Constants.fstar_refl_vconst_fv
-let (e_universe :
-  FStar_Syntax_Syntax.universe FStar_TypeChecker_NBETerm.embedding) =
-  let embed_universe cb u =
-    mk_lazy cb u FStar_Reflection_Constants.fstar_refl_universe
-      FStar_Syntax_Syntax.Lazy_universe in
-  let unembed_universe cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_universe;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded universe: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_universe unembed_universe
-    FStar_Reflection_Constants.fstar_refl_universe_fv
-let rec (e_pattern' :
-  unit -> FStar_Reflection_Data.pattern FStar_TypeChecker_NBETerm.embedding)
-  =
-  fun uu___ ->
-    let embed_pattern cb p =
-      match p with
-      | FStar_Reflection_Data.Pat_Constant c ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.embed e_const cb c in
-              FStar_TypeChecker_NBETerm.as_arg uu___3 in
-            [uu___2] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Pat_Constant.FStar_Reflection_Constants.fv
-            [] uu___1
-      | FStar_Reflection_Data.Pat_Cons (fv, us_opt, ps) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.embed e_fv cb fv in
-              FStar_TypeChecker_NBETerm.as_arg uu___3 in
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 = FStar_TypeChecker_NBETerm.e_list e_universe in
-                    FStar_TypeChecker_NBETerm.e_option uu___7 in
-                  FStar_TypeChecker_NBETerm.embed uu___6 cb us_opt in
-                FStar_TypeChecker_NBETerm.as_arg uu___5 in
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 =
-                        let uu___10 = e_pattern' () in
-                        FStar_TypeChecker_NBETerm.e_tuple2 uu___10
-                          FStar_TypeChecker_NBETerm.e_bool in
-                      FStar_TypeChecker_NBETerm.e_list uu___9 in
-                    FStar_TypeChecker_NBETerm.embed uu___8 cb ps in
-                  FStar_TypeChecker_NBETerm.as_arg uu___7 in
-                [uu___6] in
-              uu___4 :: uu___5 in
-            uu___2 :: uu___3 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Pat_Cons.FStar_Reflection_Constants.fv
-            [] uu___1
-      | FStar_Reflection_Data.Pat_Var bv ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.embed e_bv cb bv in
-              FStar_TypeChecker_NBETerm.as_arg uu___3 in
-            [uu___2] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Pat_Var.FStar_Reflection_Constants.fv
-            [] uu___1
-      | FStar_Reflection_Data.Pat_Wild bv ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.embed e_bv cb bv in
-              FStar_TypeChecker_NBETerm.as_arg uu___3 in
-            [uu___2] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Pat_Wild.FStar_Reflection_Constants.fv
-            [] uu___1
-      | FStar_Reflection_Data.Pat_Dot_Term eopt ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_TypeChecker_NBETerm.e_option e_term in
-                FStar_TypeChecker_NBETerm.embed uu___4 cb eopt in
-              FStar_TypeChecker_NBETerm.as_arg uu___3 in
-            [uu___2] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Pat_Dot_Term.FStar_Reflection_Constants.fv
-            [] uu___1 in
-    let unembed_pattern cb t =
-      match t.FStar_TypeChecker_NBETerm.nbe_t with
-      | FStar_TypeChecker_NBETerm.Construct (fv, [], (c, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Pat_Constant.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_const cb c in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun c1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Pat_Constant c1))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, [], (ps, uu___1)::(us_opt, uu___2)::(f, uu___3)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Pat_Cons.FStar_Reflection_Constants.lid
-          ->
-          let uu___4 = FStar_TypeChecker_NBETerm.unembed e_fv cb f in
-          FStar_Compiler_Util.bind_opt uu___4
-            (fun f1 ->
-               let uu___5 =
-                 let uu___6 =
-                   let uu___7 = FStar_TypeChecker_NBETerm.e_list e_universe in
-                   FStar_TypeChecker_NBETerm.e_option uu___7 in
-                 FStar_TypeChecker_NBETerm.unembed uu___6 cb us_opt in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun us ->
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 = e_pattern' () in
-                          FStar_TypeChecker_NBETerm.e_tuple2 uu___9
-                            FStar_TypeChecker_NBETerm.e_bool in
-                        FStar_TypeChecker_NBETerm.e_list uu___8 in
-                      FStar_TypeChecker_NBETerm.unembed uu___7 cb ps in
-                    FStar_Compiler_Util.bind_opt uu___6
-                      (fun ps1 ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___7 -> FStar_Pervasives_Native.Some uu___7)
-                           (FStar_Reflection_Data.Pat_Cons (f1, us, ps1)))))
-      | FStar_TypeChecker_NBETerm.Construct (fv, [], (bv, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Pat_Var.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_bv cb bv in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun bv1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Pat_Var bv1))
-      | FStar_TypeChecker_NBETerm.Construct (fv, [], (bv, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Pat_Wild.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_bv cb bv in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun bv1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Pat_Wild bv1))
-      | FStar_TypeChecker_NBETerm.Construct (fv, [], (eopt, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Pat_Dot_Term.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 =
-            let uu___3 = FStar_TypeChecker_NBETerm.e_option e_term in
-            FStar_TypeChecker_NBETerm.unembed uu___3 cb eopt in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun eopt1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Pat_Dot_Term eopt1))
-      | uu___1 ->
-          ((let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_TypeChecker_NBETerm.t_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded pattern: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___3);
-           FStar_Pervasives_Native.None) in
-    mk_emb' embed_pattern unembed_pattern
-      FStar_Reflection_Constants.fstar_refl_pattern_fv
-let (e_pattern :
-  FStar_Reflection_Data.pattern FStar_TypeChecker_NBETerm.embedding) =
-  e_pattern' ()
-let (e_branch :
-  FStar_Reflection_Data.branch FStar_TypeChecker_NBETerm.embedding) =
-  FStar_TypeChecker_NBETerm.e_tuple2 e_pattern e_term
-let (e_argv : FStar_Reflection_Data.argv FStar_TypeChecker_NBETerm.embedding)
-  = FStar_TypeChecker_NBETerm.e_tuple2 e_term e_aqualv
-let (e_branch_aq :
-  (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) Prims.list ->
-    (FStar_Reflection_Data.pattern * FStar_Syntax_Syntax.term)
-      FStar_TypeChecker_NBETerm.embedding)
-  =
-  fun aq ->
-    let uu___ = e_term_aq aq in
-    FStar_TypeChecker_NBETerm.e_tuple2 e_pattern uu___
-let (e_argv_aq :
-  (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) Prims.list ->
-    (FStar_Syntax_Syntax.term * FStar_Reflection_Data.aqualv)
-      FStar_TypeChecker_NBETerm.embedding)
-  =
-  fun aq ->
-    let uu___ = e_term_aq aq in
-    FStar_TypeChecker_NBETerm.e_tuple2 uu___ e_aqualv
-let (e_match_returns_annotation :
-  (FStar_Syntax_Syntax.binder * ((FStar_Syntax_Syntax.term,
-    FStar_Syntax_Syntax.comp) FStar_Pervasives.either *
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option * Prims.bool))
-    FStar_Pervasives_Native.option FStar_TypeChecker_NBETerm.embedding)
-  =
-  let uu___ =
-    let uu___1 =
-      let uu___2 = FStar_TypeChecker_NBETerm.e_either e_term e_comp in
-      let uu___3 = FStar_TypeChecker_NBETerm.e_option e_term in
-      FStar_TypeChecker_NBETerm.e_tuple3 uu___2 uu___3
-        FStar_TypeChecker_NBETerm.e_bool in
-    FStar_TypeChecker_NBETerm.e_tuple2 e_binder uu___1 in
-  FStar_TypeChecker_NBETerm.e_option uu___
-let unlazy_as_t :
-  'uuuuu .
-    FStar_Syntax_Syntax.lazy_kind -> FStar_TypeChecker_NBETerm.t -> 'uuuuu
-  =
-  fun k ->
-    fun t ->
-      match t.FStar_TypeChecker_NBETerm.nbe_t with
-      | FStar_TypeChecker_NBETerm.Lazy
-          (FStar_Pervasives.Inl
-           { FStar_Syntax_Syntax.blob = v; FStar_Syntax_Syntax.lkind = k';
-             FStar_Syntax_Syntax.ltyp = uu___;
-             FStar_Syntax_Syntax.rng = uu___1;_},
-           uu___2)
-          when FStar_Syntax_Util.eq_lazy_kind k k' ->
-          FStar_Compiler_Dyn.undyn v
-      | uu___ -> failwith "Not a Lazy of the expected kind (NBE)"
-let (e_ident : FStar_Ident.ident FStar_TypeChecker_NBETerm.embedding) =
-  let repr =
-    FStar_TypeChecker_NBETerm.e_tuple2 FStar_TypeChecker_NBETerm.e_range
-      FStar_TypeChecker_NBETerm.e_string in
-  let embed_ident cb i =
-    let uu___ =
-      let uu___1 = FStar_Ident.range_of_id i in
-      let uu___2 = FStar_Ident.string_of_id i in (uu___1, uu___2) in
-    FStar_TypeChecker_NBETerm.embed repr cb uu___ in
-  let unembed_ident cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.unembed repr cb t in
-    match uu___ with
-    | FStar_Pervasives_Native.Some (rng, s) ->
-        let uu___1 = FStar_Ident.mk_ident (s, rng) in
-        FStar_Pervasives_Native.Some uu___1
-    | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None in
-  let range_fv =
-    FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.range_lid
-      FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-  let string_fv =
-    FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.string_lid
-      FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-  let et =
-    let uu___ =
-      let uu___1 = FStar_Ident.string_of_lid FStar_Parser_Const.lid_tuple2 in
-      let uu___2 =
-        let uu___3 = fv_as_emb_typ range_fv in
-        let uu___4 = let uu___5 = fv_as_emb_typ string_fv in [uu___5] in
-        uu___3 :: uu___4 in
-      (uu___1, uu___2) in
-    FStar_Syntax_Syntax.ET_app uu___ in
-  let uu___ =
-    let uu___1 =
-      FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.lid_tuple2
-        FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-    let uu___2 =
-      let uu___3 =
-        let uu___4 = mkFV range_fv [] [] in
-        FStar_TypeChecker_NBETerm.as_arg uu___4 in
-      let uu___4 =
-        let uu___5 =
-          let uu___6 = mkFV string_fv [] [] in
-          FStar_TypeChecker_NBETerm.as_arg uu___6 in
-        [uu___5] in
-      uu___3 :: uu___4 in
-    mkFV uu___1 [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero]
-      uu___2 in
-  FStar_TypeChecker_NBETerm.mk_emb embed_ident unembed_ident uu___ et
-let (e_universe_view :
-  FStar_Reflection_Data.universe_view FStar_TypeChecker_NBETerm.embedding) =
-  let embed_universe_view cb uv =
-    match uv with
-    | FStar_Reflection_Data.Uv_Zero ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_Zero.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Uv_Succ u ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_universe cb u in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_Succ.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Uv_Max us ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.e_list e_universe in
-              FStar_TypeChecker_NBETerm.embed uu___3 cb us in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_Max.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Uv_BVar n ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.embed FStar_TypeChecker_NBETerm.e_int
-                cb n in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_BVar.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Uv_Name i ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_TypeChecker_NBETerm.e_tuple2
-                  FStar_TypeChecker_NBETerm.e_string
-                  FStar_TypeChecker_NBETerm.e_range in
-              FStar_TypeChecker_NBETerm.embed uu___3 cb i in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_Name.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Uv_Unif u ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              mk_lazy cb u FStar_Syntax_Util.t_universe_uvar
-                FStar_Syntax_Syntax.Lazy_universe_uvar in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_Unif.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Uv_Unk ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_Uv_Unk.FStar_Reflection_Constants.fv
-          [] [] in
-  let unembed_universe_view cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_Zero.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Uv_Zero
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (u, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_Succ.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 = FStar_TypeChecker_NBETerm.unembed e_universe cb u in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun u1 ->
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater u1
-                 (fun uu___4 -> FStar_Reflection_Data.Uv_Succ uu___4) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               (fun uu___4 -> FStar_Pervasives_Native.Some uu___4))
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (us, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_Max.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_NBETerm.e_list e_universe in
-          FStar_TypeChecker_NBETerm.unembed uu___3 cb us in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun us1 ->
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater us1
-                 (fun uu___4 -> FStar_Reflection_Data.Uv_Max uu___4) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               (fun uu___4 -> FStar_Pervasives_Native.Some uu___4))
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (n, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_BVar.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 =
-          FStar_TypeChecker_NBETerm.unembed FStar_TypeChecker_NBETerm.e_int
-            cb n in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun n1 ->
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater n1
-                 (fun uu___4 -> FStar_Reflection_Data.Uv_BVar uu___4) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               (fun uu___4 -> FStar_Pervasives_Native.Some uu___4))
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (i, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_Name.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 =
-          let uu___3 =
-            FStar_TypeChecker_NBETerm.e_tuple2
-              FStar_TypeChecker_NBETerm.e_string
-              FStar_TypeChecker_NBETerm.e_range in
-          FStar_TypeChecker_NBETerm.unembed uu___3 cb i in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun i1 ->
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater i1
-                 (fun uu___4 -> FStar_Reflection_Data.Uv_Name uu___4) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               (fun uu___4 -> FStar_Pervasives_Native.Some uu___4))
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (u, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_Unif.FStar_Reflection_Constants.lid
-        ->
-        let u1 = unlazy_as_t FStar_Syntax_Syntax.Lazy_universe_uvar u in
-        let uu___2 =
-          FStar_Compiler_Effect.op_Bar_Greater u1
-            (fun uu___3 -> FStar_Reflection_Data.Uv_Unif uu___3) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___2
-          (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Uv_Unk.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Uv_Unk
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded universe view: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_universe_view unembed_universe_view
-    FStar_Reflection_Constants.fstar_refl_universe_view_fv
-let (e_term_view_aq :
-  (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) Prims.list ->
-    FStar_Reflection_Data.term_view FStar_TypeChecker_NBETerm.embedding)
-  =
-  fun aq ->
-    let embed_term_view cb tv =
-      match tv with
-      | FStar_Reflection_Data.Tv_FVar fv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_fv cb fv in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            [uu___1] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_FVar.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_BVar bv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_bv cb bv in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            [uu___1] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_BVar.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Var bv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_bv cb bv in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            [uu___1] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Var.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_UInst (fv, us) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_fv cb fv in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_TypeChecker_NBETerm.e_list e_universe in
-                  FStar_TypeChecker_NBETerm.embed uu___5 cb us in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_UInst.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_App (hd, a) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = e_term_aq aq in
-                FStar_TypeChecker_NBETerm.embed uu___3 cb hd in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = e_argv_aq aq in
-                  FStar_TypeChecker_NBETerm.embed uu___5 cb a in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_App.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Abs (b, t) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_binder cb b in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = e_term_aq aq in
-                  FStar_TypeChecker_NBETerm.embed uu___5 cb t in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Abs.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Arrow (b, c) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_binder cb b in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_TypeChecker_NBETerm.embed e_comp cb c in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Arrow.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Type u ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_universe cb u in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            [uu___1] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Type.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Refine (bv, t) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_bv cb bv in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = e_term_aq aq in
-                  FStar_TypeChecker_NBETerm.embed uu___5 cb t in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Refine.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Const c ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.embed e_const cb c in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            [uu___1] in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Const.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Uvar (u, d) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                FStar_TypeChecker_NBETerm.embed
-                  FStar_TypeChecker_NBETerm.e_int cb u in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  mk_lazy cb (u, d) FStar_Syntax_Util.t_ctx_uvar_and_sust
-                    FStar_Syntax_Syntax.Lazy_uvar in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              [uu___3] in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Uvar.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Let (r, attrs, b, t1, t2) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                FStar_TypeChecker_NBETerm.embed
-                  FStar_TypeChecker_NBETerm.e_bool cb r in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_TypeChecker_NBETerm.e_list e_term in
-                  FStar_TypeChecker_NBETerm.embed uu___5 cb attrs in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 = FStar_TypeChecker_NBETerm.embed e_bv cb b in
-                  FStar_TypeChecker_NBETerm.as_arg uu___6 in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 = e_term_aq aq in
-                      FStar_TypeChecker_NBETerm.embed uu___9 cb t1 in
-                    FStar_TypeChecker_NBETerm.as_arg uu___8 in
-                  let uu___8 =
-                    let uu___9 =
-                      let uu___10 =
-                        let uu___11 = e_term_aq aq in
-                        FStar_TypeChecker_NBETerm.embed uu___11 cb t2 in
-                      FStar_TypeChecker_NBETerm.as_arg uu___10 in
-                    [uu___9] in
-                  uu___7 :: uu___8 in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Let.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Match (t, ret_opt, brs) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = e_term_aq aq in
-                FStar_TypeChecker_NBETerm.embed uu___3 cb t in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  FStar_TypeChecker_NBETerm.embed e_match_returns_annotation
-                    cb ret_opt in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = e_branch_aq aq in
-                      FStar_TypeChecker_NBETerm.e_list uu___8 in
-                    FStar_TypeChecker_NBETerm.embed uu___7 cb brs in
-                  FStar_TypeChecker_NBETerm.as_arg uu___6 in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Match.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_AscribedT (e, t, tacopt, use_eq) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = e_term_aq aq in
-                FStar_TypeChecker_NBETerm.embed uu___3 cb e in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = e_term_aq aq in
-                  FStar_TypeChecker_NBETerm.embed uu___5 cb t in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = e_term_aq aq in
-                      FStar_TypeChecker_NBETerm.e_option uu___8 in
-                    FStar_TypeChecker_NBETerm.embed uu___7 cb tacopt in
-                  FStar_TypeChecker_NBETerm.as_arg uu___6 in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      FStar_TypeChecker_NBETerm.embed
-                        FStar_TypeChecker_NBETerm.e_bool cb use_eq in
-                    FStar_TypeChecker_NBETerm.as_arg uu___8 in
-                  [uu___7] in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_AscT.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_AscribedC (e, c, tacopt, use_eq) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = e_term_aq aq in
-                FStar_TypeChecker_NBETerm.embed uu___3 cb e in
-              FStar_TypeChecker_NBETerm.as_arg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_TypeChecker_NBETerm.embed e_comp cb c in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = e_term_aq aq in
-                      FStar_TypeChecker_NBETerm.e_option uu___8 in
-                    FStar_TypeChecker_NBETerm.embed uu___7 cb tacopt in
-                  FStar_TypeChecker_NBETerm.as_arg uu___6 in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      FStar_TypeChecker_NBETerm.embed
-                        FStar_TypeChecker_NBETerm.e_bool cb use_eq in
-                    FStar_TypeChecker_NBETerm.as_arg uu___8 in
-                  [uu___7] in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_AscT.FStar_Reflection_Constants.fv
-            [] uu___
-      | FStar_Reflection_Data.Tv_Unknown ->
-          mkConstruct
-            FStar_Reflection_Constants.ref_Tv_Unknown.FStar_Reflection_Constants.fv
-            [] [] in
-    let unembed_term_view cb t =
-      match t.FStar_TypeChecker_NBETerm.nbe_t with
-      | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (b, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Var.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_bv cb b in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun b1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Tv_Var b1))
-      | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (b, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_BVar.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_bv cb b in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun b1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Tv_BVar b1))
-      | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (f, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_FVar.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_fv cb f in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun f1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Tv_FVar f1))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (f, uu___1)::(us, uu___2)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_UInst.FStar_Reflection_Constants.lid
-          ->
-          let uu___3 = FStar_TypeChecker_NBETerm.unembed e_fv cb f in
-          FStar_Compiler_Util.bind_opt uu___3
-            (fun f1 ->
-               let uu___4 =
-                 let uu___5 = FStar_TypeChecker_NBETerm.e_list e_universe in
-                 FStar_TypeChecker_NBETerm.unembed uu___5 cb us in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun us1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Tv_UInst (f1, us1))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (r, uu___1)::(l, uu___2)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_App.FStar_Reflection_Constants.lid
-          ->
-          let uu___3 = FStar_TypeChecker_NBETerm.unembed e_term cb l in
-          FStar_Compiler_Util.bind_opt uu___3
-            (fun l1 ->
-               let uu___4 = FStar_TypeChecker_NBETerm.unembed e_argv cb r in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun r1 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Tv_App (l1, r1))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (t1, uu___1)::(b, uu___2)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Abs.FStar_Reflection_Constants.lid
-          ->
-          let uu___3 = FStar_TypeChecker_NBETerm.unembed e_binder cb b in
-          FStar_Compiler_Util.bind_opt uu___3
-            (fun b1 ->
-               let uu___4 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun t2 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Tv_Abs (b1, t2))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (t1, uu___1)::(b, uu___2)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Arrow.FStar_Reflection_Constants.lid
-          ->
-          let uu___3 = FStar_TypeChecker_NBETerm.unembed e_binder cb b in
-          FStar_Compiler_Util.bind_opt uu___3
-            (fun b1 ->
-               let uu___4 = FStar_TypeChecker_NBETerm.unembed e_comp cb t1 in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun c ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Tv_Arrow (b1, c))))
-      | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (u, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Type.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_universe cb u in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun u1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Tv_Type u1))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (t1, uu___1)::(b, uu___2)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Refine.FStar_Reflection_Constants.lid
-          ->
-          let uu___3 = FStar_TypeChecker_NBETerm.unembed e_bv cb b in
-          FStar_Compiler_Util.bind_opt uu___3
-            (fun b1 ->
-               let uu___4 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-               FStar_Compiler_Util.bind_opt uu___4
-                 (fun t2 ->
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                      (FStar_Reflection_Data.Tv_Refine (b1, t2))))
-      | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (c, uu___1)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Const.FStar_Reflection_Constants.lid
-          ->
-          let uu___2 = FStar_TypeChecker_NBETerm.unembed e_const cb c in
-          FStar_Compiler_Util.bind_opt uu___2
-            (fun c1 ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-                 (FStar_Reflection_Data.Tv_Const c1))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (l, uu___1)::(u, uu___2)::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Uvar.FStar_Reflection_Constants.lid
-          ->
-          let uu___3 =
-            FStar_TypeChecker_NBETerm.unembed FStar_TypeChecker_NBETerm.e_int
-              cb u in
-          FStar_Compiler_Util.bind_opt uu___3
-            (fun u1 ->
-               let ctx_u_s = unlazy_as_t FStar_Syntax_Syntax.Lazy_uvar l in
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                 (FStar_Reflection_Data.Tv_Uvar (u1, ctx_u_s)))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___,
-           (t2, uu___1)::(t1, uu___2)::(b, uu___3)::(attrs, uu___4)::
-           (r, uu___5)::[])
-          when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Let.FStar_Reflection_Constants.lid
-          ->
-          let uu___6 =
-            FStar_TypeChecker_NBETerm.unembed
-              FStar_TypeChecker_NBETerm.e_bool cb r in
-          FStar_Compiler_Util.bind_opt uu___6
-            (fun r1 ->
-               let uu___7 =
-                 let uu___8 = FStar_TypeChecker_NBETerm.e_list e_term in
-                 FStar_TypeChecker_NBETerm.unembed uu___8 cb attrs in
-               FStar_Compiler_Util.bind_opt uu___7
-                 (fun attrs1 ->
-                    let uu___8 = FStar_TypeChecker_NBETerm.unembed e_bv cb b in
-                    FStar_Compiler_Util.bind_opt uu___8
-                      (fun b1 ->
-                         let uu___9 =
-                           FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-                         FStar_Compiler_Util.bind_opt uu___9
-                           (fun t11 ->
-                              let uu___10 =
-                                FStar_TypeChecker_NBETerm.unembed e_term cb
-                                  t2 in
-                              FStar_Compiler_Util.bind_opt uu___10
-                                (fun t21 ->
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (fun uu___11 ->
-                                        FStar_Pervasives_Native.Some uu___11)
-                                     (FStar_Reflection_Data.Tv_Let
-                                        (r1, attrs1, b1, t11, t21)))))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___, (brs, uu___1)::(ret_opt, uu___2)::(t1, uu___3)::[])
-          when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Match.FStar_Reflection_Constants.lid
-          ->
-          let uu___4 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-          FStar_Compiler_Util.bind_opt uu___4
-            (fun t2 ->
-               let uu___5 =
-                 let uu___6 = FStar_TypeChecker_NBETerm.e_list e_branch in
-                 FStar_TypeChecker_NBETerm.unembed uu___6 cb brs in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun brs1 ->
-                    let uu___6 =
-                      FStar_TypeChecker_NBETerm.unembed
-                        e_match_returns_annotation cb ret_opt in
-                    FStar_Compiler_Util.bind_opt uu___6
-                      (fun ret_opt1 ->
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (fun uu___7 -> FStar_Pervasives_Native.Some uu___7)
-                           (FStar_Reflection_Data.Tv_Match
-                              (t2, ret_opt1, brs1)))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___,
-           (tacopt, uu___1)::(t1, uu___2)::(e, uu___3)::(use_eq, uu___4)::[])
-          when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_AscT.FStar_Reflection_Constants.lid
-          ->
-          let uu___5 = FStar_TypeChecker_NBETerm.unembed e_term cb e in
-          FStar_Compiler_Util.bind_opt uu___5
-            (fun e1 ->
-               let uu___6 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-               FStar_Compiler_Util.bind_opt uu___6
-                 (fun t2 ->
-                    let uu___7 =
-                      let uu___8 = FStar_TypeChecker_NBETerm.e_option e_term in
-                      FStar_TypeChecker_NBETerm.unembed uu___8 cb tacopt in
-                    FStar_Compiler_Util.bind_opt uu___7
-                      (fun tacopt1 ->
-                         let uu___8 =
-                           FStar_TypeChecker_NBETerm.unembed
-                             FStar_TypeChecker_NBETerm.e_bool cb use_eq in
-                         FStar_Compiler_Util.bind_opt uu___8
-                           (fun use_eq1 ->
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (fun uu___9 ->
-                                   FStar_Pervasives_Native.Some uu___9)
-                                (FStar_Reflection_Data.Tv_AscribedT
-                                   (e1, t2, tacopt1, use_eq1))))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___,
-           (tacopt, uu___1)::(c, uu___2)::(e, uu___3)::(use_eq, uu___4)::[])
-          when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_AscC.FStar_Reflection_Constants.lid
-          ->
-          let uu___5 = FStar_TypeChecker_NBETerm.unembed e_term cb e in
-          FStar_Compiler_Util.bind_opt uu___5
-            (fun e1 ->
-               let uu___6 = FStar_TypeChecker_NBETerm.unembed e_comp cb c in
-               FStar_Compiler_Util.bind_opt uu___6
-                 (fun c1 ->
-                    let uu___7 =
-                      let uu___8 = FStar_TypeChecker_NBETerm.e_option e_term in
-                      FStar_TypeChecker_NBETerm.unembed uu___8 cb tacopt in
-                    FStar_Compiler_Util.bind_opt uu___7
-                      (fun tacopt1 ->
-                         let uu___8 =
-                           FStar_TypeChecker_NBETerm.unembed
-                             FStar_TypeChecker_NBETerm.e_bool cb use_eq in
-                         FStar_Compiler_Util.bind_opt uu___8
-                           (fun use_eq1 ->
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (fun uu___9 ->
-                                   FStar_Pervasives_Native.Some uu___9)
-                                (FStar_Reflection_Data.Tv_AscribedC
-                                   (e1, c1, tacopt1, use_eq1))))))
-      | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-          FStar_Syntax_Syntax.fv_eq_lid fv
-            FStar_Reflection_Constants.ref_Tv_Unknown.FStar_Reflection_Constants.lid
-          ->
-          FStar_Compiler_Effect.op_Less_Bar
-            (fun uu___1 -> FStar_Pervasives_Native.Some uu___1)
-            FStar_Reflection_Data.Tv_Unknown
-      | uu___ ->
-          ((let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded term_view: %s"
-                  uu___4 in
-              (FStar_Errors.Warning_NotEmbedded, uu___3) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-           FStar_Pervasives_Native.None) in
-    mk_emb' embed_term_view unembed_term_view
-      FStar_Reflection_Constants.fstar_refl_term_view_fv
-let (e_term_view :
-  FStar_Reflection_Data.term_view FStar_TypeChecker_NBETerm.embedding) =
-  e_term_view_aq []
-let (e_bv_view :
-  FStar_Reflection_Data.bv_view FStar_TypeChecker_NBETerm.embedding) =
-  let embed_bv_view cb bvv =
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          FStar_TypeChecker_NBETerm.embed FStar_TypeChecker_NBETerm.e_string
-            cb bvv.FStar_Reflection_Data.bv_ppname in
-        FStar_TypeChecker_NBETerm.as_arg uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            FStar_TypeChecker_NBETerm.embed FStar_TypeChecker_NBETerm.e_int
-              cb bvv.FStar_Reflection_Data.bv_index in
-          FStar_TypeChecker_NBETerm.as_arg uu___4 in
-        let uu___4 =
-          let uu___5 =
-            let uu___6 =
-              FStar_TypeChecker_NBETerm.embed e_term cb
-                bvv.FStar_Reflection_Data.bv_sort in
-            FStar_TypeChecker_NBETerm.as_arg uu___6 in
-          [uu___5] in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    mkConstruct
-      FStar_Reflection_Constants.ref_Mk_bv.FStar_Reflection_Constants.fv []
-      uu___ in
-  let unembed_bv_view cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___, (s, uu___1)::(idx, uu___2)::(nm, uu___3)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Mk_bv.FStar_Reflection_Constants.lid
-        ->
-        let uu___4 =
-          FStar_TypeChecker_NBETerm.unembed
-            FStar_TypeChecker_NBETerm.e_string cb nm in
-        FStar_Compiler_Util.bind_opt uu___4
-          (fun nm1 ->
-             let uu___5 =
-               FStar_TypeChecker_NBETerm.unembed
-                 FStar_TypeChecker_NBETerm.e_int cb idx in
-             FStar_Compiler_Util.bind_opt uu___5
-               (fun idx1 ->
-                  let uu___6 = FStar_TypeChecker_NBETerm.unembed e_term cb s in
-                  FStar_Compiler_Util.bind_opt uu___6
-                    (fun s1 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___7 -> FStar_Pervasives_Native.Some uu___7)
-                         {
-                           FStar_Reflection_Data.bv_ppname = nm1;
-                           FStar_Reflection_Data.bv_index = idx1;
-                           FStar_Reflection_Data.bv_sort = s1
-                         })))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded bv_view: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_bv_view unembed_bv_view
-    FStar_Reflection_Constants.fstar_refl_bv_view_fv
-let (e_comp_view :
-  FStar_Reflection_Data.comp_view FStar_TypeChecker_NBETerm.embedding) =
-  let embed_comp_view cb cv =
-    match cv with
-    | FStar_Reflection_Data.C_Total t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_term cb t in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Total.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.C_GTotal t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_term cb t in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_GTotal.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.C_Lemma (pre, post, pats) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_term cb pre in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.embed e_term cb post in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.embed e_term cb pats in
-                FStar_TypeChecker_NBETerm.as_arg uu___6 in
-              [uu___5] in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Lemma.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.C_Eff (us, eff, res, args, decrs) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.e_list e_universe in
-              FStar_TypeChecker_NBETerm.embed uu___3 cb us in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_TypeChecker_NBETerm.embed
-                  FStar_TypeChecker_NBETerm.e_string_list cb eff in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.embed e_term cb res in
-                FStar_TypeChecker_NBETerm.as_arg uu___6 in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    let uu___9 = FStar_TypeChecker_NBETerm.e_list e_argv in
-                    FStar_TypeChecker_NBETerm.embed uu___9 cb args in
-                  FStar_TypeChecker_NBETerm.as_arg uu___8 in
-                let uu___8 =
-                  let uu___9 =
-                    let uu___10 =
-                      let uu___11 = FStar_TypeChecker_NBETerm.e_list e_term in
-                      FStar_TypeChecker_NBETerm.embed uu___11 cb decrs in
-                    FStar_TypeChecker_NBETerm.as_arg uu___10 in
-                  [uu___9] in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_C_Eff.FStar_Reflection_Constants.fv
-          [] uu___ in
-  let unembed_comp_view cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (t1, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Total.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun t2 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Reflection_Data.C_Total t2))
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (t1, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_GTotal.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun t2 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Reflection_Data.C_GTotal t2))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___, (post, uu___1)::(pre, uu___2)::(pats, uu___3)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Lemma.FStar_Reflection_Constants.lid
-        ->
-        let uu___4 = FStar_TypeChecker_NBETerm.unembed e_term cb pre in
-        FStar_Compiler_Util.bind_opt uu___4
-          (fun pre1 ->
-             let uu___5 = FStar_TypeChecker_NBETerm.unembed e_term cb post in
-             FStar_Compiler_Util.bind_opt uu___5
-               (fun post1 ->
-                  let uu___6 =
-                    FStar_TypeChecker_NBETerm.unembed e_term cb pats in
-                  FStar_Compiler_Util.bind_opt uu___6
-                    (fun pats1 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___7 -> FStar_Pervasives_Native.Some uu___7)
-                         (FStar_Reflection_Data.C_Lemma (pre1, post1, pats1)))))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___,
-         (decrs, uu___1)::(args, uu___2)::(res, uu___3)::(eff, uu___4)::
-         (us, uu___5)::[])
-        when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_C_Eff.FStar_Reflection_Constants.lid
-        ->
-        let uu___6 =
-          let uu___7 = FStar_TypeChecker_NBETerm.e_list e_universe in
-          FStar_TypeChecker_NBETerm.unembed uu___7 cb us in
-        FStar_Compiler_Util.bind_opt uu___6
-          (fun us1 ->
-             let uu___7 =
-               FStar_TypeChecker_NBETerm.unembed
-                 FStar_TypeChecker_NBETerm.e_string_list cb eff in
-             FStar_Compiler_Util.bind_opt uu___7
-               (fun eff1 ->
-                  let uu___8 =
-                    FStar_TypeChecker_NBETerm.unembed e_term cb res in
-                  FStar_Compiler_Util.bind_opt uu___8
-                    (fun res1 ->
-                       let uu___9 =
-                         let uu___10 =
-                           FStar_TypeChecker_NBETerm.e_list e_argv in
-                         FStar_TypeChecker_NBETerm.unembed uu___10 cb args in
-                       FStar_Compiler_Util.bind_opt uu___9
-                         (fun args1 ->
-                            let uu___10 =
-                              let uu___11 =
-                                FStar_TypeChecker_NBETerm.e_list e_term in
-                              FStar_TypeChecker_NBETerm.unembed uu___11 cb
-                                decrs in
-                            FStar_Compiler_Util.bind_opt uu___10
-                              (fun decrs1 ->
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (fun uu___11 ->
-                                      FStar_Pervasives_Native.Some uu___11)
-                                   (FStar_Reflection_Data.C_Eff
-                                      (us1, eff1, res1, args1, decrs1)))))))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded comp_view: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_comp_view unembed_comp_view
-    FStar_Reflection_Constants.fstar_refl_comp_view_fv
-let (e_order : FStar_Order.order FStar_TypeChecker_NBETerm.embedding) =
-  let embed_order cb o =
-    match o with
-    | FStar_Order.Lt ->
-        mkConstruct FStar_Reflection_Constants.ord_Lt_fv [] []
-    | FStar_Order.Eq ->
-        mkConstruct FStar_Reflection_Constants.ord_Eq_fv [] []
-    | FStar_Order.Gt ->
-        mkConstruct FStar_Reflection_Constants.ord_Gt_fv [] [] in
-  let unembed_order cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ord_Lt_lid
-        -> FStar_Pervasives_Native.Some FStar_Order.Lt
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ord_Eq_lid
-        -> FStar_Pervasives_Native.Some FStar_Order.Eq
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ord_Gt_lid
-        -> FStar_Pervasives_Native.Some FStar_Order.Gt
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded order: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.order_lid
-      FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-  mk_emb' embed_order unembed_order uu___
-let (e_sigelt :
-  FStar_Syntax_Syntax.sigelt FStar_TypeChecker_NBETerm.embedding) =
-  let embed_sigelt cb se =
-    mk_lazy cb se FStar_Reflection_Constants.fstar_refl_sigelt
-      FStar_Syntax_Syntax.Lazy_sigelt in
-  let unembed_sigelt cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_sigelt;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded sigelt: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_sigelt unembed_sigelt
-    FStar_Reflection_Constants.fstar_refl_sigelt_fv
-let (e_univ_name :
-  FStar_Syntax_Syntax.univ_name FStar_TypeChecker_NBETerm.embedding) =
-  e_ident
-let (e_univ_names :
-  FStar_Syntax_Syntax.univ_name Prims.list
-    FStar_TypeChecker_NBETerm.embedding)
-  = FStar_TypeChecker_NBETerm.e_list e_univ_name
-let (e_string_list :
-  Prims.string Prims.list FStar_TypeChecker_NBETerm.embedding) =
-  FStar_TypeChecker_NBETerm.e_list FStar_TypeChecker_NBETerm.e_string
-let (e_ctor :
-  (Prims.string Prims.list * FStar_Syntax_Syntax.term)
-    FStar_TypeChecker_NBETerm.embedding)
-  = FStar_TypeChecker_NBETerm.e_tuple2 e_string_list e_term
-let (e_lb_view :
-  FStar_Reflection_Data.lb_view FStar_TypeChecker_NBETerm.embedding) =
-  let embed_lb_view cb lbv =
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          FStar_TypeChecker_NBETerm.embed e_fv cb
-            lbv.FStar_Reflection_Data.lb_fv in
-        FStar_TypeChecker_NBETerm.as_arg uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            FStar_TypeChecker_NBETerm.embed e_univ_names cb
-              lbv.FStar_Reflection_Data.lb_us in
-          FStar_TypeChecker_NBETerm.as_arg uu___4 in
-        let uu___4 =
-          let uu___5 =
-            let uu___6 =
-              FStar_TypeChecker_NBETerm.embed e_term cb
-                lbv.FStar_Reflection_Data.lb_typ in
-            FStar_TypeChecker_NBETerm.as_arg uu___6 in
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                FStar_TypeChecker_NBETerm.embed e_term cb
-                  lbv.FStar_Reflection_Data.lb_def in
-              FStar_TypeChecker_NBETerm.as_arg uu___8 in
-            [uu___7] in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    mkConstruct
-      FStar_Reflection_Constants.ref_Mk_lb.FStar_Reflection_Constants.fv []
-      uu___ in
-  let unembed_lb_view cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___,
-         (fv', uu___1)::(us, uu___2)::(typ, uu___3)::(def, uu___4)::[])
-        when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Mk_lb.FStar_Reflection_Constants.lid
-        ->
-        let uu___5 = FStar_TypeChecker_NBETerm.unembed e_fv cb fv' in
-        FStar_Compiler_Util.bind_opt uu___5
-          (fun fv'1 ->
-             let uu___6 =
-               FStar_TypeChecker_NBETerm.unembed e_univ_names cb us in
-             FStar_Compiler_Util.bind_opt uu___6
-               (fun us1 ->
-                  let uu___7 =
-                    FStar_TypeChecker_NBETerm.unembed e_term cb typ in
-                  FStar_Compiler_Util.bind_opt uu___7
-                    (fun typ1 ->
-                       let uu___8 =
-                         FStar_TypeChecker_NBETerm.unembed e_term cb def in
-                       FStar_Compiler_Util.bind_opt uu___8
-                         (fun def1 ->
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (fun uu___9 ->
-                                 FStar_Pervasives_Native.Some uu___9)
-                              {
-                                FStar_Reflection_Data.lb_fv = fv'1;
-                                FStar_Reflection_Data.lb_us = us1;
-                                FStar_Reflection_Data.lb_typ = typ1;
-                                FStar_Reflection_Data.lb_def = def1
-                              }))))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded lb_view: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_lb_view unembed_lb_view
-    FStar_Reflection_Constants.fstar_refl_lb_view_fv
-let (e_attribute :
-  FStar_Syntax_Syntax.attribute FStar_TypeChecker_NBETerm.embedding) = e_term
-let (e_attributes :
-  FStar_Syntax_Syntax.attribute Prims.list
-    FStar_TypeChecker_NBETerm.embedding)
-  = FStar_TypeChecker_NBETerm.e_list e_attribute
-let (e_lid : FStar_Ident.lid FStar_TypeChecker_NBETerm.embedding) =
-  let embed rng lid =
-    let uu___ = FStar_Ident.path_of_lid lid in
-    FStar_TypeChecker_NBETerm.embed e_string_list rng uu___ in
-  let unembed cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.unembed e_string_list cb t in
-    FStar_Compiler_Util.map_opt uu___
-      (fun p -> FStar_Ident.lid_of_path p FStar_Compiler_Range.dummyRange) in
-  let uu___ =
-    mkConstruct FStar_Reflection_Constants.fstar_refl_aqualv_fv [] [] in
-  let uu___1 = fv_as_emb_typ FStar_Reflection_Constants.fstar_refl_aqualv_fv in
-  FStar_TypeChecker_NBETerm.mk_emb embed unembed uu___ uu___1
-let (e_letbinding :
-  FStar_Syntax_Syntax.letbinding FStar_TypeChecker_NBETerm.embedding) =
-  let embed_letbinding cb lb =
-    mk_lazy cb lb FStar_Reflection_Constants.fstar_refl_letbinding
-      FStar_Syntax_Syntax.Lazy_letbinding in
-  let unembed_letbinding cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = lb;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_letbinding;
-           FStar_Syntax_Syntax.ltyp = uu___;
-           FStar_Syntax_Syntax.rng = uu___1;_},
-         uu___2)
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn lb in
-        FStar_Pervasives_Native.Some uu___3
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded letbinding: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_letbinding unembed_letbinding
-    FStar_Reflection_Constants.fstar_refl_letbinding_fv
-let (e_sigelt_view :
-  FStar_Reflection_Data.sigelt_view FStar_TypeChecker_NBETerm.embedding) =
-  let embed_sigelt_view cb sev =
-    match sev with
-    | FStar_Reflection_Data.Sg_Let (r, lbs) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.embed
-                FStar_TypeChecker_NBETerm.e_bool cb r in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_TypeChecker_NBETerm.e_list e_letbinding in
-                FStar_TypeChecker_NBETerm.embed uu___5 cb lbs in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            [uu___3] in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Sg_Let.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Sg_Inductive (nm, univs, bs, t, dcs) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_string_list cb nm in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_TypeChecker_NBETerm.embed e_univ_names cb univs in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.embed e_binders cb bs in
-                FStar_TypeChecker_NBETerm.as_arg uu___6 in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 = FStar_TypeChecker_NBETerm.embed e_term cb t in
-                  FStar_TypeChecker_NBETerm.as_arg uu___8 in
-                let uu___8 =
-                  let uu___9 =
-                    let uu___10 =
-                      let uu___11 = FStar_TypeChecker_NBETerm.e_list e_ctor in
-                      FStar_TypeChecker_NBETerm.embed uu___11 cb dcs in
-                    FStar_TypeChecker_NBETerm.as_arg uu___10 in
-                  [uu___9] in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Sg_Inductive.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Sg_Val (nm, univs, t) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_string_list cb nm in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_TypeChecker_NBETerm.embed e_univ_names cb univs in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.embed e_term cb t in
-                FStar_TypeChecker_NBETerm.as_arg uu___6 in
-              [uu___5] in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_Sg_Val.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Unk ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_Unk.FStar_Reflection_Constants.fv []
-          [] in
-  let unembed_sigelt_view cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___,
-         (dcs, uu___1)::(t1, uu___2)::(bs, uu___3)::(us, uu___4)::(nm,
-                                                                   uu___5)::[])
-        when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Sg_Inductive.FStar_Reflection_Constants.lid
-        ->
-        let uu___6 = FStar_TypeChecker_NBETerm.unembed e_string_list cb nm in
-        FStar_Compiler_Util.bind_opt uu___6
-          (fun nm1 ->
-             let uu___7 =
-               FStar_TypeChecker_NBETerm.unembed e_univ_names cb us in
-             FStar_Compiler_Util.bind_opt uu___7
-               (fun us1 ->
-                  let uu___8 =
-                    FStar_TypeChecker_NBETerm.unembed e_binders cb bs in
-                  FStar_Compiler_Util.bind_opt uu___8
-                    (fun bs1 ->
-                       let uu___9 =
-                         FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-                       FStar_Compiler_Util.bind_opt uu___9
-                         (fun t2 ->
-                            let uu___10 =
-                              let uu___11 =
-                                FStar_TypeChecker_NBETerm.e_list e_ctor in
-                              FStar_TypeChecker_NBETerm.unembed uu___11 cb
-                                dcs in
-                            FStar_Compiler_Util.bind_opt uu___10
-                              (fun dcs1 ->
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (fun uu___11 ->
-                                      FStar_Pervasives_Native.Some uu___11)
-                                   (FStar_Reflection_Data.Sg_Inductive
-                                      (nm1, us1, bs1, t2, dcs1)))))))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___, (lbs, uu___1)::(r, uu___2)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Sg_Let.FStar_Reflection_Constants.lid
-        ->
-        let uu___3 =
-          FStar_TypeChecker_NBETerm.unembed FStar_TypeChecker_NBETerm.e_bool
-            cb r in
-        FStar_Compiler_Util.bind_opt uu___3
-          (fun r1 ->
-             let uu___4 =
-               let uu___5 = FStar_TypeChecker_NBETerm.e_list e_letbinding in
-               FStar_TypeChecker_NBETerm.unembed uu___5 cb lbs in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun lbs1 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                    (FStar_Reflection_Data.Sg_Let (r1, lbs1))))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___, (t1, uu___1)::(us, uu___2)::(nm, uu___3)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Sg_Val.FStar_Reflection_Constants.lid
-        ->
-        let uu___4 = FStar_TypeChecker_NBETerm.unembed e_string_list cb nm in
-        FStar_Compiler_Util.bind_opt uu___4
-          (fun nm1 ->
-             let uu___5 =
-               FStar_TypeChecker_NBETerm.unembed e_univ_names cb us in
-             FStar_Compiler_Util.bind_opt uu___5
-               (fun us1 ->
-                  let uu___6 = FStar_TypeChecker_NBETerm.unembed e_term cb t1 in
-                  FStar_Compiler_Util.bind_opt uu___6
-                    (fun t2 ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___7 -> FStar_Pervasives_Native.Some uu___7)
-                         (FStar_Reflection_Data.Sg_Val (nm1, us1, t2)))))
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_Unk.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Unk
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded sigelt_view: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_sigelt_view unembed_sigelt_view
-    FStar_Reflection_Constants.fstar_refl_sigelt_view_fv
-let (e_exp : FStar_Reflection_Data.exp FStar_TypeChecker_NBETerm.embedding) =
-  let rec embed_exp cb e =
-    match e with
-    | FStar_Reflection_Data.Unit ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_E_Unit.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Var i ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.mk_t
-                (FStar_TypeChecker_NBETerm.Constant
-                   (FStar_TypeChecker_NBETerm.Int i)) in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_E_Var.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Mult (e1, e2) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = embed_exp cb e1 in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = embed_exp cb e2 in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            [uu___3] in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_E_Mult.FStar_Reflection_Constants.fv
-          [] uu___ in
-  let rec unembed_exp cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_E_Unit.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Unit
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___, (i, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_E_Var.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 =
-          FStar_TypeChecker_NBETerm.unembed FStar_TypeChecker_NBETerm.e_int
-            cb i in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun i1 ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Reflection_Data.Var i1))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, uu___, (e2, uu___1)::(e1, uu___2)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_E_Mult.FStar_Reflection_Constants.lid
-        ->
-        let uu___3 = unembed_exp cb e1 in
-        FStar_Compiler_Util.bind_opt uu___3
-          (fun e11 ->
-             let uu___4 = unembed_exp cb e2 in
-             FStar_Compiler_Util.bind_opt uu___4
-               (fun e21 ->
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                    (FStar_Reflection_Data.Mult (e11, e21))))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded exp: %s" uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  mk_emb' embed_exp unembed_exp FStar_Reflection_Constants.fstar_refl_exp_fv
-let (e_binder_view :
-  FStar_Reflection_Data.binder_view FStar_TypeChecker_NBETerm.embedding) =
-  let uu___ =
-    let uu___1 = FStar_TypeChecker_NBETerm.e_list e_term in
-    FStar_TypeChecker_NBETerm.e_tuple2 e_aqualv uu___1 in
-  FStar_TypeChecker_NBETerm.e_tuple2 e_bv uu___
-let (e_qualifier :
-  FStar_Reflection_Data.qualifier FStar_TypeChecker_NBETerm.embedding) =
-  let embed cb q =
-    match q with
-    | FStar_Reflection_Data.Assumption ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Assumption.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.New ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_New.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Private ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Private.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Unfold_for_unification_and_vcgen ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Unfold_for_unification_and_vcgen.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Visible_default ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Visible_default.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Irreducible ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Irreducible.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Inline_for_extraction ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Inline_for_extraction.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.NoExtract ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_NoExtract.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Noeq ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Noeq.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Unopteq ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Unopteq.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.TotalEffect ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_TotalEffect.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Logic ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Logic.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Reifiable ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Reifiable.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.ExceptionConstructor ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_ExceptionConstructor.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.HasMaskedEffect ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_HasMaskedEffect.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Effect ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Effect.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.OnlyName ->
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_OnlyName.FStar_Reflection_Constants.fv
-          [] []
-    | FStar_Reflection_Data.Reflectable l ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_lid cb l in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Reflectable.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Discriminator l ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_lid cb l in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Discriminator.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Action l ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_lid cb l in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Action.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.Projector (l, i) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_NBETerm.embed e_lid cb l in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.embed e_ident cb i in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            [uu___3] in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_Projector.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.RecordType (ids1, ids2) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.e_list e_ident in
-              FStar_TypeChecker_NBETerm.embed uu___3 cb ids1 in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_TypeChecker_NBETerm.e_list e_ident in
-                FStar_TypeChecker_NBETerm.embed uu___5 cb ids2 in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            [uu___3] in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_RecordType.FStar_Reflection_Constants.fv
-          [] uu___
-    | FStar_Reflection_Data.RecordConstructor (ids1, ids2) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.e_list e_ident in
-              FStar_TypeChecker_NBETerm.embed uu___3 cb ids1 in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_TypeChecker_NBETerm.e_list e_ident in
-                FStar_TypeChecker_NBETerm.embed uu___5 cb ids2 in
-              FStar_TypeChecker_NBETerm.as_arg uu___4 in
-            [uu___3] in
-          uu___1 :: uu___2 in
-        mkConstruct
-          FStar_Reflection_Constants.ref_qual_RecordConstructor.FStar_Reflection_Constants.fv
-          [] uu___ in
-  let unembed cb t =
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Assumption.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Assumption
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_New.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.New
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Private.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Private
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Unfold_for_unification_and_vcgen.FStar_Reflection_Constants.lid
-        ->
-        FStar_Pervasives_Native.Some
-          FStar_Reflection_Data.Unfold_for_unification_and_vcgen
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Visible_default.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Visible_default
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Irreducible.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Irreducible
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Inline_for_extraction.FStar_Reflection_Constants.lid
-        ->
-        FStar_Pervasives_Native.Some
-          FStar_Reflection_Data.Inline_for_extraction
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_NoExtract.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.NoExtract
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Noeq.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Noeq
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Unopteq.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Unopteq
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_TotalEffect.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.TotalEffect
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Logic.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Logic
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Reifiable.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Reifiable
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_ExceptionConstructor.FStar_Reflection_Constants.lid
-        ->
-        FStar_Pervasives_Native.Some
-          FStar_Reflection_Data.ExceptionConstructor
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_HasMaskedEffect.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.HasMaskedEffect
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Effect.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.Effect
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_OnlyName.FStar_Reflection_Constants.lid
-        -> FStar_Pervasives_Native.Some FStar_Reflection_Data.OnlyName
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (l, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Reflectable.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 = FStar_TypeChecker_NBETerm.unembed e_lid cb l in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun l1 ->
-             FStar_Pervasives_Native.Some
-               (FStar_Reflection_Data.Reflectable l1))
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (l, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Discriminator.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 = FStar_TypeChecker_NBETerm.unembed e_lid cb l in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun l1 ->
-             FStar_Pervasives_Native.Some
-               (FStar_Reflection_Data.Discriminator l1))
-    | FStar_TypeChecker_NBETerm.Construct (fv, [], (l, uu___)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Action.FStar_Reflection_Constants.lid
-        ->
-        let uu___1 = FStar_TypeChecker_NBETerm.unembed e_lid cb l in
-        FStar_Compiler_Util.bind_opt uu___1
-          (fun l1 ->
-             FStar_Pervasives_Native.Some (FStar_Reflection_Data.Action l1))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, [], (i, uu___)::(l, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_Projector.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 = FStar_TypeChecker_NBETerm.unembed e_ident cb i in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun i1 ->
-             let uu___3 = FStar_TypeChecker_NBETerm.unembed e_lid cb l in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun l1 ->
-                  FStar_Pervasives_Native.Some
-                    (FStar_Reflection_Data.Projector (l1, i1))))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, [], (ids2, uu___)::(ids1, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_RecordType.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_NBETerm.e_list e_ident in
-          FStar_TypeChecker_NBETerm.unembed uu___3 cb ids1 in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ids11 ->
-             let uu___3 =
-               let uu___4 = FStar_TypeChecker_NBETerm.e_list e_ident in
-               FStar_TypeChecker_NBETerm.unembed uu___4 cb ids2 in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun ids21 ->
-                  FStar_Pervasives_Native.Some
-                    (FStar_Reflection_Data.RecordType (ids11, ids21))))
-    | FStar_TypeChecker_NBETerm.Construct
-        (fv, [], (ids2, uu___)::(ids1, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Reflection_Constants.ref_qual_RecordConstructor.FStar_Reflection_Constants.lid
-        ->
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_NBETerm.e_list e_ident in
-          FStar_TypeChecker_NBETerm.unembed uu___3 cb ids1 in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ids11 ->
-             let uu___3 =
-               let uu___4 = FStar_TypeChecker_NBETerm.e_list e_ident in
-               FStar_TypeChecker_NBETerm.unembed uu___4 cb ids2 in
-             FStar_Compiler_Util.bind_opt uu___3
-               (fun ids21 ->
-                  FStar_Pervasives_Native.Some
-                    (FStar_Reflection_Data.RecordConstructor (ids11, ids21))))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-              FStar_Compiler_Util.format1 "Not an embedded qualifier: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    mkConstruct FStar_Reflection_Constants.fstar_refl_qualifier_fv [] [] in
-  let uu___1 =
-    fv_as_emb_typ FStar_Reflection_Constants.fstar_refl_qualifier_fv in
-  FStar_TypeChecker_NBETerm.mk_emb embed unembed uu___ uu___1
-let (e_qualifiers :
-  FStar_Reflection_Data.qualifier Prims.list
-    FStar_TypeChecker_NBETerm.embedding)
-  = FStar_TypeChecker_NBETerm.e_list e_qualifier
-let (e_vconfig : FStar_Order.order FStar_TypeChecker_NBETerm.embedding) =
-  let emb cb o = failwith "emb vconfig NBE" in
-  let unemb cb t = failwith "unemb vconfig NBE" in
-  let uu___ =
-    FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.vconfig_lid
-      FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-  mk_emb' emb unemb uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_Encode.ml b/src/ocaml-output/FStar_SMTEncoding_Encode.ml
deleted file mode 100644
index d5e2e31f119..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_Encode.ml
+++ /dev/null
@@ -1,7783 +0,0 @@
-open Prims
-let (norm_before_encoding :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      let steps =
-        [FStar_TypeChecker_Env.Eager_unfolding;
-        FStar_TypeChecker_Env.Simplify;
-        FStar_TypeChecker_Env.Primops;
-        FStar_TypeChecker_Env.AllowUnboundUniverses;
-        FStar_TypeChecker_Env.EraseUniverses;
-        FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta] in
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            FStar_TypeChecker_Env.current_module
-              env.FStar_SMTEncoding_Env.tcenv in
-          FStar_Ident.string_of_lid uu___2 in
-        FStar_Pervasives_Native.Some uu___1 in
-      FStar_Profiling.profile
-        (fun uu___1 ->
-           FStar_TypeChecker_Normalize.normalize steps
-             env.FStar_SMTEncoding_Env.tcenv t) uu___
-        "FStar.SMTEncoding.Encode.norm_before_encoding"
-let (norm_with_steps :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun steps ->
-    fun env ->
-      fun t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module env in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 -> FStar_TypeChecker_Normalize.normalize steps env t)
-          uu___ "FStar.SMTEncoding.Encode.norm"
-type prims_t =
-  {
-  mk:
-    FStar_Ident.lident ->
-      Prims.string ->
-        (FStar_SMTEncoding_Term.term * Prims.int *
-          FStar_SMTEncoding_Term.decl Prims.list)
-    ;
-  is: FStar_Ident.lident -> Prims.bool }
-let (__proj__Mkprims_t__item__mk :
-  prims_t ->
-    FStar_Ident.lident ->
-      Prims.string ->
-        (FStar_SMTEncoding_Term.term * Prims.int *
-          FStar_SMTEncoding_Term.decl Prims.list))
-  = fun projectee -> match projectee with | { mk; is;_} -> mk
-let (__proj__Mkprims_t__item__is :
-  prims_t -> FStar_Ident.lident -> Prims.bool) =
-  fun projectee -> match projectee with | { mk; is;_} -> is
-let (prims : prims_t) =
-  let module_name = "Prims" in
-  let uu___ =
-    FStar_SMTEncoding_Env.fresh_fvar module_name "a"
-      FStar_SMTEncoding_Term.Term_sort in
-  match uu___ with
-  | (asym, a) ->
-      let uu___1 =
-        FStar_SMTEncoding_Env.fresh_fvar module_name "x"
-          FStar_SMTEncoding_Term.Term_sort in
-      (match uu___1 with
-       | (xsym, x) ->
-           let uu___2 =
-             FStar_SMTEncoding_Env.fresh_fvar module_name "y"
-               FStar_SMTEncoding_Term.Term_sort in
-           (match uu___2 with
-            | (ysym, y) ->
-                let quant vars body rng x1 =
-                  let xname_decl =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_Effect.op_Bar_Greater vars
-                          (FStar_Compiler_List.map
-                             FStar_SMTEncoding_Term.fv_sort) in
-                      (x1, uu___4, FStar_SMTEncoding_Term.Term_sort,
-                        FStar_Pervasives_Native.None) in
-                    FStar_SMTEncoding_Term.DeclFun uu___3 in
-                  let xtok = Prims.op_Hat x1 "@tok" in
-                  let xtok_decl =
-                    FStar_SMTEncoding_Term.DeclFun
-                      (xtok, [], FStar_SMTEncoding_Term.Term_sort,
-                        FStar_Pervasives_Native.None) in
-                  let xapp =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_List.map
-                          FStar_SMTEncoding_Util.mkFreeV vars in
-                      (x1, uu___4) in
-                    FStar_SMTEncoding_Util.mkApp uu___3 in
-                  let xtok1 = FStar_SMTEncoding_Util.mkApp (xtok, []) in
-                  let xtok_app =
-                    FStar_SMTEncoding_EncodeTerm.mk_Apply xtok1 vars in
-                  let tot_fun_axioms =
-                    let all_vars_but_one =
-                      FStar_Compiler_Effect.op_Bar_Greater
-                        (FStar_Compiler_Util.prefix vars)
-                        FStar_Pervasives_Native.fst in
-                    let axiom_name = Prims.op_Hat "primitive_tot_fun_" x1 in
-                    let tot_fun_axiom_for_x =
-                      let uu___3 =
-                        let uu___4 = FStar_SMTEncoding_Term.mk_IsTotFun xtok1 in
-                        (uu___4, FStar_Pervasives_Native.None, axiom_name) in
-                      FStar_SMTEncoding_Util.mkAssume uu___3 in
-                    let uu___3 =
-                      FStar_Compiler_List.fold_left
-                        (fun uu___4 ->
-                           fun var ->
-                             match uu___4 with
-                             | (axioms, app, vars1) ->
-                                 let app1 =
-                                   FStar_SMTEncoding_EncodeTerm.mk_Apply app
-                                     [var] in
-                                 let vars2 =
-                                   FStar_Compiler_List.op_At vars1 [var] in
-                                 let axiom_name1 =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           vars2 FStar_Compiler_List.length in
-                                       Prims.string_of_int uu___7 in
-                                     Prims.op_Hat "." uu___6 in
-                                   Prims.op_Hat axiom_name uu___5 in
-                                 let uu___5 =
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_SMTEncoding_Term.mk_IsTotFun
-                                                 app1 in
-                                             ([[app1]], vars2, uu___11) in
-                                           FStar_SMTEncoding_Term.mkForall
-                                             rng uu___10 in
-                                         (uu___9,
-                                           FStar_Pervasives_Native.None,
-                                           axiom_name1) in
-                                       FStar_SMTEncoding_Util.mkAssume uu___8 in
-                                     [uu___7] in
-                                   FStar_Compiler_List.op_At axioms uu___6 in
-                                 (uu___5, app1, vars2))
-                        ([tot_fun_axiom_for_x], xtok1, []) all_vars_but_one in
-                    match uu___3 with | (axioms, uu___4, uu___5) -> axioms in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_SMTEncoding_Util.mkEq (xapp, body) in
-                                  ([[xapp]], vars, uu___11) in
-                                FStar_SMTEncoding_Term.mkForall rng uu___10 in
-                              (uu___9, FStar_Pervasives_Native.None,
-                                (Prims.op_Hat "primitive_" x1)) in
-                            FStar_SMTEncoding_Util.mkAssume uu___8 in
-                          [uu___7] in
-                        xtok_decl :: uu___6 in
-                      xname_decl :: uu___5 in
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            let uu___9 =
-                              let uu___10 =
-                                let uu___11 =
-                                  FStar_SMTEncoding_Util.mkEq
-                                    (xtok_app, xapp) in
-                                ([[xtok_app]], vars, uu___11) in
-                              FStar_SMTEncoding_Term.mkForall rng uu___10 in
-                            (uu___9,
-                              (FStar_Pervasives_Native.Some
-                                 "Name-token correspondence"),
-                              (Prims.op_Hat "token_correspondence_" x1)) in
-                          FStar_SMTEncoding_Util.mkAssume uu___8 in
-                        [uu___7] in
-                      FStar_Compiler_List.op_At tot_fun_axioms uu___6 in
-                    FStar_Compiler_List.op_At uu___4 uu___5 in
-                  (xtok1, (FStar_Compiler_List.length vars), uu___3) in
-                let axy =
-                  FStar_Compiler_List.map FStar_SMTEncoding_Term.mk_fv
-                    [(asym, FStar_SMTEncoding_Term.Term_sort);
-                    (xsym, FStar_SMTEncoding_Term.Term_sort);
-                    (ysym, FStar_SMTEncoding_Term.Term_sort)] in
-                let xy =
-                  FStar_Compiler_List.map FStar_SMTEncoding_Term.mk_fv
-                    [(xsym, FStar_SMTEncoding_Term.Term_sort);
-                    (ysym, FStar_SMTEncoding_Term.Term_sort)] in
-                let qx =
-                  FStar_Compiler_List.map FStar_SMTEncoding_Term.mk_fv
-                    [(xsym, FStar_SMTEncoding_Term.Term_sort)] in
-                let prims1 =
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = FStar_SMTEncoding_Util.mkEq (x, y) in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          FStar_SMTEncoding_Term.boxBool uu___6 in
-                      quant axy uu___5 in
-                    (FStar_Parser_Const.op_Eq, uu___4) in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            let uu___9 = FStar_SMTEncoding_Util.mkEq (x, y) in
-                            FStar_SMTEncoding_Util.mkNot uu___9 in
-                          FStar_Compiler_Effect.op_Less_Bar
-                            FStar_SMTEncoding_Term.boxBool uu___8 in
-                        quant axy uu___7 in
-                      (FStar_Parser_Const.op_notEq, uu___6) in
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 =
-                              let uu___11 =
-                                let uu___12 =
-                                  FStar_SMTEncoding_Term.unboxBool x in
-                                let uu___13 =
-                                  FStar_SMTEncoding_Term.unboxBool y in
-                                (uu___12, uu___13) in
-                              FStar_SMTEncoding_Util.mkAnd uu___11 in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_SMTEncoding_Term.boxBool uu___10 in
-                          quant xy uu___9 in
-                        (FStar_Parser_Const.op_And, uu___8) in
-                      let uu___8 =
-                        let uu___9 =
-                          let uu___10 =
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  let uu___14 =
-                                    FStar_SMTEncoding_Term.unboxBool x in
-                                  let uu___15 =
-                                    FStar_SMTEncoding_Term.unboxBool y in
-                                  (uu___14, uu___15) in
-                                FStar_SMTEncoding_Util.mkOr uu___13 in
-                              FStar_Compiler_Effect.op_Less_Bar
-                                FStar_SMTEncoding_Term.boxBool uu___12 in
-                            quant xy uu___11 in
-                          (FStar_Parser_Const.op_Or, uu___10) in
-                        let uu___10 =
-                          let uu___11 =
-                            let uu___12 =
-                              let uu___13 =
-                                let uu___14 =
-                                  let uu___15 =
-                                    FStar_SMTEncoding_Term.unboxBool x in
-                                  FStar_SMTEncoding_Util.mkNot uu___15 in
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  FStar_SMTEncoding_Term.boxBool uu___14 in
-                              quant qx uu___13 in
-                            (FStar_Parser_Const.op_Negation, uu___12) in
-                          let uu___12 =
-                            let uu___13 =
-                              let uu___14 =
-                                let uu___15 =
-                                  let uu___16 =
-                                    let uu___17 =
-                                      let uu___18 =
-                                        FStar_SMTEncoding_Term.unboxInt x in
-                                      let uu___19 =
-                                        FStar_SMTEncoding_Term.unboxInt y in
-                                      (uu___18, uu___19) in
-                                    FStar_SMTEncoding_Util.mkLT uu___17 in
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    FStar_SMTEncoding_Term.boxBool uu___16 in
-                                quant xy uu___15 in
-                              (FStar_Parser_Const.op_LT, uu___14) in
-                            let uu___14 =
-                              let uu___15 =
-                                let uu___16 =
-                                  let uu___17 =
-                                    let uu___18 =
-                                      let uu___19 =
-                                        let uu___20 =
-                                          FStar_SMTEncoding_Term.unboxInt x in
-                                        let uu___21 =
-                                          FStar_SMTEncoding_Term.unboxInt y in
-                                        (uu___20, uu___21) in
-                                      FStar_SMTEncoding_Util.mkLTE uu___19 in
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      FStar_SMTEncoding_Term.boxBool uu___18 in
-                                  quant xy uu___17 in
-                                (FStar_Parser_Const.op_LTE, uu___16) in
-                              let uu___16 =
-                                let uu___17 =
-                                  let uu___18 =
-                                    let uu___19 =
-                                      let uu___20 =
-                                        let uu___21 =
-                                          let uu___22 =
-                                            FStar_SMTEncoding_Term.unboxInt x in
-                                          let uu___23 =
-                                            FStar_SMTEncoding_Term.unboxInt y in
-                                          (uu___22, uu___23) in
-                                        FStar_SMTEncoding_Util.mkGT uu___21 in
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        FStar_SMTEncoding_Term.boxBool
-                                        uu___20 in
-                                    quant xy uu___19 in
-                                  (FStar_Parser_Const.op_GT, uu___18) in
-                                let uu___18 =
-                                  let uu___19 =
-                                    let uu___20 =
-                                      let uu___21 =
-                                        let uu___22 =
-                                          let uu___23 =
-                                            let uu___24 =
-                                              FStar_SMTEncoding_Term.unboxInt
-                                                x in
-                                            let uu___25 =
-                                              FStar_SMTEncoding_Term.unboxInt
-                                                y in
-                                            (uu___24, uu___25) in
-                                          FStar_SMTEncoding_Util.mkGTE
-                                            uu___23 in
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          FStar_SMTEncoding_Term.boxBool
-                                          uu___22 in
-                                      quant xy uu___21 in
-                                    (FStar_Parser_Const.op_GTE, uu___20) in
-                                  let uu___20 =
-                                    let uu___21 =
-                                      let uu___22 =
-                                        let uu___23 =
-                                          let uu___24 =
-                                            let uu___25 =
-                                              let uu___26 =
-                                                FStar_SMTEncoding_Term.unboxInt
-                                                  x in
-                                              let uu___27 =
-                                                FStar_SMTEncoding_Term.unboxInt
-                                                  y in
-                                              (uu___26, uu___27) in
-                                            FStar_SMTEncoding_Util.mkSub
-                                              uu___25 in
-                                          FStar_Compiler_Effect.op_Less_Bar
-                                            FStar_SMTEncoding_Term.boxInt
-                                            uu___24 in
-                                        quant xy uu___23 in
-                                      (FStar_Parser_Const.op_Subtraction,
-                                        uu___22) in
-                                    let uu___22 =
-                                      let uu___23 =
-                                        let uu___24 =
-                                          let uu___25 =
-                                            let uu___26 =
-                                              let uu___27 =
-                                                FStar_SMTEncoding_Term.unboxInt
-                                                  x in
-                                              FStar_SMTEncoding_Util.mkMinus
-                                                uu___27 in
-                                            FStar_Compiler_Effect.op_Less_Bar
-                                              FStar_SMTEncoding_Term.boxInt
-                                              uu___26 in
-                                          quant qx uu___25 in
-                                        (FStar_Parser_Const.op_Minus,
-                                          uu___24) in
-                                      let uu___24 =
-                                        let uu___25 =
-                                          let uu___26 =
-                                            let uu___27 =
-                                              let uu___28 =
-                                                let uu___29 =
-                                                  let uu___30 =
-                                                    FStar_SMTEncoding_Term.unboxInt
-                                                      x in
-                                                  let uu___31 =
-                                                    FStar_SMTEncoding_Term.unboxInt
-                                                      y in
-                                                  (uu___30, uu___31) in
-                                                FStar_SMTEncoding_Util.mkAdd
-                                                  uu___29 in
-                                              FStar_Compiler_Effect.op_Less_Bar
-                                                FStar_SMTEncoding_Term.boxInt
-                                                uu___28 in
-                                            quant xy uu___27 in
-                                          (FStar_Parser_Const.op_Addition,
-                                            uu___26) in
-                                        let uu___26 =
-                                          let uu___27 =
-                                            let uu___28 =
-                                              let uu___29 =
-                                                let uu___30 =
-                                                  let uu___31 =
-                                                    let uu___32 =
-                                                      FStar_SMTEncoding_Term.unboxInt
-                                                        x in
-                                                    let uu___33 =
-                                                      FStar_SMTEncoding_Term.unboxInt
-                                                        y in
-                                                    (uu___32, uu___33) in
-                                                  FStar_SMTEncoding_Util.mkMul
-                                                    uu___31 in
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  FStar_SMTEncoding_Term.boxInt
-                                                  uu___30 in
-                                              quant xy uu___29 in
-                                            (FStar_Parser_Const.op_Multiply,
-                                              uu___28) in
-                                          let uu___28 =
-                                            let uu___29 =
-                                              let uu___30 =
-                                                let uu___31 =
-                                                  let uu___32 =
-                                                    let uu___33 =
-                                                      let uu___34 =
-                                                        FStar_SMTEncoding_Term.unboxInt
-                                                          x in
-                                                      let uu___35 =
-                                                        FStar_SMTEncoding_Term.unboxInt
-                                                          y in
-                                                      (uu___34, uu___35) in
-                                                    FStar_SMTEncoding_Util.mkDiv
-                                                      uu___33 in
-                                                  FStar_Compiler_Effect.op_Less_Bar
-                                                    FStar_SMTEncoding_Term.boxInt
-                                                    uu___32 in
-                                                quant xy uu___31 in
-                                              (FStar_Parser_Const.op_Division,
-                                                uu___30) in
-                                            let uu___30 =
-                                              let uu___31 =
-                                                let uu___32 =
-                                                  let uu___33 =
-                                                    let uu___34 =
-                                                      let uu___35 =
-                                                        let uu___36 =
-                                                          FStar_SMTEncoding_Term.unboxInt
-                                                            x in
-                                                        let uu___37 =
-                                                          FStar_SMTEncoding_Term.unboxInt
-                                                            y in
-                                                        (uu___36, uu___37) in
-                                                      FStar_SMTEncoding_Util.mkMod
-                                                        uu___35 in
-                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                      FStar_SMTEncoding_Term.boxInt
-                                                      uu___34 in
-                                                  quant xy uu___33 in
-                                                (FStar_Parser_Const.op_Modulus,
-                                                  uu___32) in
-                                              let uu___32 =
-                                                let uu___33 =
-                                                  let uu___34 =
-                                                    let uu___35 =
-                                                      let uu___36 =
-                                                        let uu___37 =
-                                                          let uu___38 =
-                                                            FStar_SMTEncoding_Term.unboxReal
-                                                              x in
-                                                          let uu___39 =
-                                                            FStar_SMTEncoding_Term.unboxReal
-                                                              y in
-                                                          (uu___38, uu___39) in
-                                                        FStar_SMTEncoding_Util.mkLT
-                                                          uu___37 in
-                                                      FStar_Compiler_Effect.op_Less_Bar
-                                                        FStar_SMTEncoding_Term.boxBool
-                                                        uu___36 in
-                                                    quant xy uu___35 in
-                                                  (FStar_Parser_Const.real_op_LT,
-                                                    uu___34) in
-                                                let uu___34 =
-                                                  let uu___35 =
-                                                    let uu___36 =
-                                                      let uu___37 =
-                                                        let uu___38 =
-                                                          let uu___39 =
-                                                            let uu___40 =
-                                                              FStar_SMTEncoding_Term.unboxReal
-                                                                x in
-                                                            let uu___41 =
-                                                              FStar_SMTEncoding_Term.unboxReal
-                                                                y in
-                                                            (uu___40,
-                                                              uu___41) in
-                                                          FStar_SMTEncoding_Util.mkLTE
-                                                            uu___39 in
-                                                        FStar_Compiler_Effect.op_Less_Bar
-                                                          FStar_SMTEncoding_Term.boxBool
-                                                          uu___38 in
-                                                      quant xy uu___37 in
-                                                    (FStar_Parser_Const.real_op_LTE,
-                                                      uu___36) in
-                                                  let uu___36 =
-                                                    let uu___37 =
-                                                      let uu___38 =
-                                                        let uu___39 =
-                                                          let uu___40 =
-                                                            let uu___41 =
-                                                              let uu___42 =
-                                                                FStar_SMTEncoding_Term.unboxReal
-                                                                  x in
-                                                              let uu___43 =
-                                                                FStar_SMTEncoding_Term.unboxReal
-                                                                  y in
-                                                              (uu___42,
-                                                                uu___43) in
-                                                            FStar_SMTEncoding_Util.mkGT
-                                                              uu___41 in
-                                                          FStar_Compiler_Effect.op_Less_Bar
-                                                            FStar_SMTEncoding_Term.boxBool
-                                                            uu___40 in
-                                                        quant xy uu___39 in
-                                                      (FStar_Parser_Const.real_op_GT,
-                                                        uu___38) in
-                                                    let uu___38 =
-                                                      let uu___39 =
-                                                        let uu___40 =
-                                                          let uu___41 =
-                                                            let uu___42 =
-                                                              let uu___43 =
-                                                                let uu___44 =
-                                                                  FStar_SMTEncoding_Term.unboxReal
-                                                                    x in
-                                                                let uu___45 =
-                                                                  FStar_SMTEncoding_Term.unboxReal
-                                                                    y in
-                                                                (uu___44,
-                                                                  uu___45) in
-                                                              FStar_SMTEncoding_Util.mkGTE
-                                                                uu___43 in
-                                                            FStar_Compiler_Effect.op_Less_Bar
-                                                              FStar_SMTEncoding_Term.boxBool
-                                                              uu___42 in
-                                                          quant xy uu___41 in
-                                                        (FStar_Parser_Const.real_op_GTE,
-                                                          uu___40) in
-                                                      let uu___40 =
-                                                        let uu___41 =
-                                                          let uu___42 =
-                                                            let uu___43 =
-                                                              let uu___44 =
-                                                                let uu___45 =
-                                                                  let uu___46
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    x in
-                                                                  let uu___47
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    y in
-                                                                  (uu___46,
-                                                                    uu___47) in
-                                                                FStar_SMTEncoding_Util.mkSub
-                                                                  uu___45 in
-                                                              FStar_Compiler_Effect.op_Less_Bar
-                                                                FStar_SMTEncoding_Term.boxReal
-                                                                uu___44 in
-                                                            quant xy uu___43 in
-                                                          (FStar_Parser_Const.real_op_Subtraction,
-                                                            uu___42) in
-                                                        let uu___42 =
-                                                          let uu___43 =
-                                                            let uu___44 =
-                                                              let uu___45 =
-                                                                let uu___46 =
-                                                                  let uu___47
-                                                                    =
-                                                                    let uu___48
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    x in
-                                                                    let uu___49
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    y in
-                                                                    (uu___48,
-                                                                    uu___49) in
-                                                                  FStar_SMTEncoding_Util.mkAdd
-                                                                    uu___47 in
-                                                                FStar_Compiler_Effect.op_Less_Bar
-                                                                  FStar_SMTEncoding_Term.boxReal
-                                                                  uu___46 in
-                                                              quant xy
-                                                                uu___45 in
-                                                            (FStar_Parser_Const.real_op_Addition,
-                                                              uu___44) in
-                                                          let uu___44 =
-                                                            let uu___45 =
-                                                              let uu___46 =
-                                                                let uu___47 =
-                                                                  let uu___48
-                                                                    =
-                                                                    let uu___49
-                                                                    =
-                                                                    let uu___50
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    x in
-                                                                    let uu___51
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    y in
-                                                                    (uu___50,
-                                                                    uu___51) in
-                                                                    FStar_SMTEncoding_Util.mkMul
-                                                                    uu___49 in
-                                                                  FStar_Compiler_Effect.op_Less_Bar
-                                                                    FStar_SMTEncoding_Term.boxReal
-                                                                    uu___48 in
-                                                                quant xy
-                                                                  uu___47 in
-                                                              (FStar_Parser_Const.real_op_Multiply,
-                                                                uu___46) in
-                                                            let uu___46 =
-                                                              let uu___47 =
-                                                                let uu___48 =
-                                                                  let uu___49
-                                                                    =
-                                                                    let uu___50
-                                                                    =
-                                                                    let uu___51
-                                                                    =
-                                                                    let uu___52
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    x in
-                                                                    let uu___53
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxReal
-                                                                    y in
-                                                                    (uu___52,
-                                                                    uu___53) in
-                                                                    FStar_SMTEncoding_Util.mkRealDiv
-                                                                    uu___51 in
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    FStar_SMTEncoding_Term.boxReal
-                                                                    uu___50 in
-                                                                  quant xy
-                                                                    uu___49 in
-                                                                (FStar_Parser_Const.real_op_Division,
-                                                                  uu___48) in
-                                                              let uu___48 =
-                                                                let uu___49 =
-                                                                  let uu___50
-                                                                    =
-                                                                    let uu___51
-                                                                    =
-                                                                    let uu___52
-                                                                    =
-                                                                    let uu___53
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.unboxInt
-                                                                    x in
-                                                                    FStar_SMTEncoding_Term.mkRealOfInt
-                                                                    uu___53
-                                                                    FStar_Compiler_Range.dummyRange in
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    FStar_SMTEncoding_Term.boxReal
-                                                                    uu___52 in
-                                                                    quant qx
-                                                                    uu___51 in
-                                                                  (FStar_Parser_Const.real_of_int,
-                                                                    uu___50) in
-                                                                [uu___49] in
-                                                              uu___47 ::
-                                                                uu___48 in
-                                                            uu___45 ::
-                                                              uu___46 in
-                                                          uu___43 :: uu___44 in
-                                                        uu___41 :: uu___42 in
-                                                      uu___39 :: uu___40 in
-                                                    uu___37 :: uu___38 in
-                                                  uu___35 :: uu___36 in
-                                                uu___33 :: uu___34 in
-                                              uu___31 :: uu___32 in
-                                            uu___29 :: uu___30 in
-                                          uu___27 :: uu___28 in
-                                        uu___25 :: uu___26 in
-                                      uu___23 :: uu___24 in
-                                    uu___21 :: uu___22 in
-                                  uu___19 :: uu___20 in
-                                uu___17 :: uu___18 in
-                              uu___15 :: uu___16 in
-                            uu___13 :: uu___14 in
-                          uu___11 :: uu___12 in
-                        uu___9 :: uu___10 in
-                      uu___7 :: uu___8 in
-                    uu___5 :: uu___6 in
-                  uu___3 :: uu___4 in
-                let mk l v =
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_Effect.op_Bar_Greater prims1
-                        (FStar_Compiler_List.find
-                           (fun uu___5 ->
-                              match uu___5 with
-                              | (l', uu___6) -> FStar_Ident.lid_equals l l')) in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___4
-                      (FStar_Compiler_Option.map
-                         (fun uu___5 ->
-                            match uu___5 with
-                            | (uu___6, b) ->
-                                let uu___7 = FStar_Ident.range_of_lid l in
-                                b uu___7 v)) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___3
-                    FStar_Compiler_Option.get in
-                let is l =
-                  FStar_Compiler_Effect.op_Bar_Greater prims1
-                    (FStar_Compiler_Util.for_some
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | (l', uu___4) -> FStar_Ident.lid_equals l l')) in
-                { mk; is }))
-let (pretype_axiom :
-  FStar_Compiler_Range.range ->
-    FStar_SMTEncoding_Env.env_t ->
-      FStar_SMTEncoding_Term.term ->
-        (Prims.string * FStar_SMTEncoding_Term.sort * Prims.bool) Prims.list
-          -> FStar_SMTEncoding_Term.decl)
-  =
-  fun rng ->
-    fun env ->
-      fun tapp ->
-        fun vars ->
-          let uu___ =
-            FStar_SMTEncoding_Env.fresh_fvar
-              env.FStar_SMTEncoding_Env.current_module_name "x"
-              FStar_SMTEncoding_Term.Term_sort in
-          match uu___ with
-          | (xxsym, xx) ->
-              let uu___1 =
-                FStar_SMTEncoding_Env.fresh_fvar
-                  env.FStar_SMTEncoding_Env.current_module_name "f"
-                  FStar_SMTEncoding_Term.Fuel_sort in
-              (match uu___1 with
-               | (ffsym, ff) ->
-                   let xx_has_type =
-                     FStar_SMTEncoding_Term.mk_HasTypeFuel ff xx tapp in
-                   let tapp_hash = FStar_SMTEncoding_Term.hash_of_term tapp in
-                   let module_name =
-                     env.FStar_SMTEncoding_Env.current_module_name in
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 =
-                             FStar_SMTEncoding_Term.mk_fv
-                               (xxsym, FStar_SMTEncoding_Term.Term_sort) in
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_SMTEncoding_Term.mk_fv
-                                 (ffsym, FStar_SMTEncoding_Term.Fuel_sort) in
-                             uu___8 :: vars in
-                           uu___6 :: uu___7 in
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_SMTEncoding_Util.mkApp
-                                     ("PreType", [xx]) in
-                                 (tapp, uu___10) in
-                               FStar_SMTEncoding_Util.mkEq uu___9 in
-                             (xx_has_type, uu___8) in
-                           FStar_SMTEncoding_Util.mkImp uu___7 in
-                         ([[xx_has_type]], uu___5, uu___6) in
-                       FStar_SMTEncoding_Term.mkForall rng uu___4 in
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 =
-                             FStar_Compiler_Util.digest_of_string tapp_hash in
-                           Prims.op_Hat "_pretyping_" uu___7 in
-                         Prims.op_Hat module_name uu___6 in
-                       FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.mk_unique
-                         uu___5 in
-                     (uu___3, (FStar_Pervasives_Native.Some "pretyping"),
-                       uu___4) in
-                   FStar_SMTEncoding_Util.mkAssume uu___2)
-let (primitive_type_axioms :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      Prims.string ->
-        FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.decl Prims.list)
-  =
-  let xx =
-    FStar_SMTEncoding_Term.mk_fv ("x", FStar_SMTEncoding_Term.Term_sort) in
-  let x = FStar_SMTEncoding_Util.mkFreeV xx in
-  let yy =
-    FStar_SMTEncoding_Term.mk_fv ("y", FStar_SMTEncoding_Term.Term_sort) in
-  let y = FStar_SMTEncoding_Util.mkFreeV yy in
-  let mkForall_fuel env =
-    let uu___ =
-      let uu___1 = FStar_TypeChecker_Env.current_module env in
-      FStar_Ident.string_of_lid uu___1 in
-    FStar_SMTEncoding_EncodeTerm.mkForall_fuel uu___ in
-  let mk_unit env nm tt =
-    let typing_pred = FStar_SMTEncoding_Term.mk_HasType x tt in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          FStar_SMTEncoding_Term.mk_HasType
-            FStar_SMTEncoding_Term.mk_Term_unit tt in
-        (uu___2, (FStar_Pervasives_Native.Some "unit typing"), "unit_typing") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    FStar_SMTEncoding_Util.mkEq
-                      (x, FStar_SMTEncoding_Term.mk_Term_unit) in
-                  (typing_pred, uu___8) in
-                FStar_SMTEncoding_Util.mkImp uu___7 in
-              ([[typing_pred]], [xx], uu___6) in
-            let uu___6 =
-              let uu___7 = FStar_TypeChecker_Env.get_range env in
-              let uu___8 = mkForall_fuel env in uu___8 uu___7 in
-            uu___6 uu___5 in
-          (uu___4, (FStar_Pervasives_Native.Some "unit inversion"),
-            "unit_inversion") in
-        FStar_SMTEncoding_Util.mkAssume uu___3 in
-      [uu___2] in
-    uu___ :: uu___1 in
-  let mk_bool env nm tt =
-    let typing_pred = FStar_SMTEncoding_Term.mk_HasType x tt in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.Bool_sort) in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Term.boxBool b in [uu___7] in
-              [uu___6] in
-            let uu___6 =
-              let uu___7 = FStar_SMTEncoding_Term.boxBool b in
-              FStar_SMTEncoding_Term.mk_HasType uu___7 tt in
-            (uu___5, [bb], uu___6) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "bool typing"), "bool_typing") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    FStar_SMTEncoding_Term.mk_tester
-                      (FStar_Pervasives_Native.fst
-                         FStar_SMTEncoding_Term.boxBoolFun) x in
-                  (typing_pred, uu___8) in
-                FStar_SMTEncoding_Util.mkImp uu___7 in
-              ([[typing_pred]], [xx], uu___6) in
-            let uu___6 =
-              let uu___7 = FStar_TypeChecker_Env.get_range env in
-              let uu___8 = mkForall_fuel env in uu___8 uu___7 in
-            uu___6 uu___5 in
-          (uu___4, (FStar_Pervasives_Native.Some "bool inversion"),
-            "bool_inversion") in
-        FStar_SMTEncoding_Util.mkAssume uu___3 in
-      [uu___2] in
-    uu___ :: uu___1 in
-  let mk_int env nm tt =
-    let lex_t =
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Ident.string_of_lid FStar_Parser_Const.lex_t_lid in
-          (uu___2, FStar_SMTEncoding_Term.Term_sort) in
-        FStar_SMTEncoding_Term.mk_fv uu___1 in
-      FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkFreeV uu___ in
-    let typing_pred = FStar_SMTEncoding_Term.mk_HasType x tt in
-    let typing_pred_y = FStar_SMTEncoding_Term.mk_HasType y tt in
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Int_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.Int_sort) in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let precedes_y_x =
-      let uu___ =
-        FStar_SMTEncoding_Util.mkApp ("Prims.precedes", [lex_t; lex_t; y; x]) in
-      FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Term.mk_Valid uu___ in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Term.boxInt b in [uu___7] in
-              [uu___6] in
-            let uu___6 =
-              let uu___7 = FStar_SMTEncoding_Term.boxInt b in
-              FStar_SMTEncoding_Term.mk_HasType uu___7 tt in
-            (uu___5, [bb], uu___6) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "int typing"), "int_typing") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    FStar_SMTEncoding_Term.mk_tester
-                      (FStar_Pervasives_Native.fst
-                         FStar_SMTEncoding_Term.boxIntFun) x in
-                  (typing_pred, uu___8) in
-                FStar_SMTEncoding_Util.mkImp uu___7 in
-              ([[typing_pred]], [xx], uu___6) in
-            let uu___6 =
-              let uu___7 = FStar_TypeChecker_Env.get_range env in
-              let uu___8 = mkForall_fuel env in uu___8 uu___7 in
-            uu___6 uu___5 in
-          (uu___4, (FStar_Pervasives_Native.Some "int inversion"),
-            "int_inversion") in
-        FStar_SMTEncoding_Util.mkAssume uu___3 in
-      let uu___3 =
-        let uu___4 =
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 =
-                  let uu___9 =
-                    let uu___10 =
-                      let uu___11 =
-                        let uu___12 =
-                          let uu___13 =
-                            let uu___14 =
-                              let uu___15 =
-                                let uu___16 =
-                                  FStar_SMTEncoding_Term.unboxInt x in
-                                let uu___17 =
-                                  FStar_SMTEncoding_Util.mkInteger'
-                                    Prims.int_zero in
-                                (uu___16, uu___17) in
-                              FStar_SMTEncoding_Util.mkGT uu___15 in
-                            let uu___15 =
-                              let uu___16 =
-                                let uu___17 =
-                                  let uu___18 =
-                                    FStar_SMTEncoding_Term.unboxInt y in
-                                  let uu___19 =
-                                    FStar_SMTEncoding_Util.mkInteger'
-                                      Prims.int_zero in
-                                  (uu___18, uu___19) in
-                                FStar_SMTEncoding_Util.mkGTE uu___17 in
-                              let uu___17 =
-                                let uu___18 =
-                                  let uu___19 =
-                                    let uu___20 =
-                                      FStar_SMTEncoding_Term.unboxInt y in
-                                    let uu___21 =
-                                      FStar_SMTEncoding_Term.unboxInt x in
-                                    (uu___20, uu___21) in
-                                  FStar_SMTEncoding_Util.mkLT uu___19 in
-                                [uu___18] in
-                              uu___16 :: uu___17 in
-                            uu___14 :: uu___15 in
-                          typing_pred_y :: uu___13 in
-                        typing_pred :: uu___12 in
-                      FStar_SMTEncoding_Util.mk_and_l uu___11 in
-                    (uu___10, precedes_y_x) in
-                  FStar_SMTEncoding_Util.mkImp uu___9 in
-                ([[typing_pred; typing_pred_y; precedes_y_x]], [xx; yy],
-                  uu___8) in
-              let uu___8 =
-                let uu___9 = FStar_TypeChecker_Env.get_range env in
-                let uu___10 = mkForall_fuel env in uu___10 uu___9 in
-              uu___8 uu___7 in
-            (uu___6,
-              (FStar_Pervasives_Native.Some
-                 "well-founded ordering on nat (alt)"),
-              "well-founded-ordering-on-nat") in
-          FStar_SMTEncoding_Util.mkAssume uu___5 in
-        [uu___4] in
-      uu___2 :: uu___3 in
-    uu___ :: uu___1 in
-  let mk_real env nm tt =
-    let typing_pred = FStar_SMTEncoding_Term.mk_HasType x tt in
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv
-        ("a", (FStar_SMTEncoding_Term.Sort "Real")) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv
-        ("b", (FStar_SMTEncoding_Term.Sort "Real")) in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Term.boxReal b in [uu___7] in
-              [uu___6] in
-            let uu___6 =
-              let uu___7 = FStar_SMTEncoding_Term.boxReal b in
-              FStar_SMTEncoding_Term.mk_HasType uu___7 tt in
-            (uu___5, [bb], uu___6) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "real typing"), "real_typing") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    FStar_SMTEncoding_Term.mk_tester
-                      (FStar_Pervasives_Native.fst
-                         FStar_SMTEncoding_Term.boxRealFun) x in
-                  (typing_pred, uu___8) in
-                FStar_SMTEncoding_Util.mkImp uu___7 in
-              ([[typing_pred]], [xx], uu___6) in
-            let uu___6 =
-              let uu___7 = FStar_TypeChecker_Env.get_range env in
-              let uu___8 = mkForall_fuel env in uu___8 uu___7 in
-            uu___6 uu___5 in
-          (uu___4, (FStar_Pervasives_Native.Some "real inversion"),
-            "real_inversion") in
-        FStar_SMTEncoding_Util.mkAssume uu___3 in
-      [uu___2] in
-    uu___ :: uu___1 in
-  let mk_str env nm tt =
-    let typing_pred = FStar_SMTEncoding_Term.mk_HasType x tt in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.String_sort) in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Term.boxString b in [uu___7] in
-              [uu___6] in
-            let uu___6 =
-              let uu___7 = FStar_SMTEncoding_Term.boxString b in
-              FStar_SMTEncoding_Term.mk_HasType uu___7 tt in
-            (uu___5, [bb], uu___6) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "string typing"),
-          "string_typing") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    FStar_SMTEncoding_Term.mk_tester
-                      (FStar_Pervasives_Native.fst
-                         FStar_SMTEncoding_Term.boxStringFun) x in
-                  (typing_pred, uu___8) in
-                FStar_SMTEncoding_Util.mkImp uu___7 in
-              ([[typing_pred]], [xx], uu___6) in
-            let uu___6 =
-              let uu___7 = FStar_TypeChecker_Env.get_range env in
-              let uu___8 = mkForall_fuel env in uu___8 uu___7 in
-            uu___6 uu___5 in
-          (uu___4, (FStar_Pervasives_Native.Some "string inversion"),
-            "string_inversion") in
-        FStar_SMTEncoding_Util.mkAssume uu___3 in
-      [uu___2] in
-    uu___ :: uu___1 in
-  let mk_true_interp env nm true_tm =
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [true_tm]) in
-    let uu___ =
-      FStar_SMTEncoding_Util.mkAssume
-        (valid, (FStar_Pervasives_Native.Some "True interpretation"),
-          "true_interp") in
-    [uu___] in
-  let mk_false_interp env nm false_tm =
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [false_tm]) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          FStar_SMTEncoding_Util.mkIff
-            (FStar_SMTEncoding_Util.mkFalse, valid) in
-        (uu___2, (FStar_Pervasives_Native.Some "False interpretation"),
-          "false_interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_and_interp env conj uu___ =
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Term_sort) in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.Term_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let l_and_a_b = FStar_SMTEncoding_Util.mkApp (conj, [a; b]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [l_and_a_b]) in
-    let valid_a = FStar_SMTEncoding_Util.mkApp ("Valid", [a]) in
-    let valid_b = FStar_SMTEncoding_Util.mkApp ("Valid", [b]) in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 = FStar_TypeChecker_Env.get_range env in
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = FStar_SMTEncoding_Util.mkAnd (valid_a, valid_b) in
-                (uu___8, valid) in
-              FStar_SMTEncoding_Util.mkIff uu___7 in
-            ([[l_and_a_b]], [aa; bb], uu___6) in
-          FStar_SMTEncoding_Term.mkForall uu___4 uu___5 in
-        (uu___3, (FStar_Pervasives_Native.Some "/\\ interpretation"),
-          "l_and-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___2 in
-    [uu___1] in
-  let mk_or_interp env disj uu___ =
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Term_sort) in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.Term_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let l_or_a_b = FStar_SMTEncoding_Util.mkApp (disj, [a; b]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [l_or_a_b]) in
-    let valid_a = FStar_SMTEncoding_Util.mkApp ("Valid", [a]) in
-    let valid_b = FStar_SMTEncoding_Util.mkApp ("Valid", [b]) in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 = FStar_TypeChecker_Env.get_range env in
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = FStar_SMTEncoding_Util.mkOr (valid_a, valid_b) in
-                (uu___8, valid) in
-              FStar_SMTEncoding_Util.mkIff uu___7 in
-            ([[l_or_a_b]], [aa; bb], uu___6) in
-          FStar_SMTEncoding_Term.mkForall uu___4 uu___5 in
-        (uu___3, (FStar_Pervasives_Native.Some "\\/ interpretation"),
-          "l_or-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___2 in
-    [uu___1] in
-  let mk_eq2_interp env eq2 tt =
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Term_sort) in
-    let xx1 =
-      FStar_SMTEncoding_Term.mk_fv ("x", FStar_SMTEncoding_Term.Term_sort) in
-    let yy1 =
-      FStar_SMTEncoding_Term.mk_fv ("y", FStar_SMTEncoding_Term.Term_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let x1 = FStar_SMTEncoding_Util.mkFreeV xx1 in
-    let y1 = FStar_SMTEncoding_Util.mkFreeV yy1 in
-    let eq2_x_y = FStar_SMTEncoding_Util.mkApp (eq2, [a; x1; y1]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [eq2_x_y]) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Util.mkEq (x1, y1) in
-                (uu___7, valid) in
-              FStar_SMTEncoding_Util.mkIff uu___6 in
-            ([[eq2_x_y]], [aa; xx1; yy1], uu___5) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "Eq2 interpretation"),
-          "eq2-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_imp_interp env imp tt =
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Term_sort) in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.Term_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let l_imp_a_b = FStar_SMTEncoding_Util.mkApp (imp, [a; b]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [l_imp_a_b]) in
-    let valid_a = FStar_SMTEncoding_Util.mkApp ("Valid", [a]) in
-    let valid_b = FStar_SMTEncoding_Util.mkApp ("Valid", [b]) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Util.mkImp (valid_a, valid_b) in
-                (uu___7, valid) in
-              FStar_SMTEncoding_Util.mkIff uu___6 in
-            ([[l_imp_a_b]], [aa; bb], uu___5) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "==> interpretation"),
-          "l_imp-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_iff_interp env iff tt =
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Term_sort) in
-    let bb =
-      FStar_SMTEncoding_Term.mk_fv ("b", FStar_SMTEncoding_Term.Term_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let b = FStar_SMTEncoding_Util.mkFreeV bb in
-    let l_iff_a_b = FStar_SMTEncoding_Util.mkApp (iff, [a; b]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [l_iff_a_b]) in
-    let valid_a = FStar_SMTEncoding_Util.mkApp ("Valid", [a]) in
-    let valid_b = FStar_SMTEncoding_Util.mkApp ("Valid", [b]) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Util.mkIff (valid_a, valid_b) in
-                (uu___7, valid) in
-              FStar_SMTEncoding_Util.mkIff uu___6 in
-            ([[l_iff_a_b]], [aa; bb], uu___5) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "<==> interpretation"),
-          "l_iff-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_not_interp env l_not tt =
-    let aa =
-      FStar_SMTEncoding_Term.mk_fv ("a", FStar_SMTEncoding_Term.Term_sort) in
-    let a = FStar_SMTEncoding_Util.mkFreeV aa in
-    let l_not_a = FStar_SMTEncoding_Util.mkApp (l_not, [a]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [l_not_a]) in
-    let not_valid_a =
-      let uu___ = FStar_SMTEncoding_Util.mkApp ("Valid", [a]) in
-      FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkNot uu___ in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 = FStar_SMTEncoding_Util.mkIff (not_valid_a, valid) in
-            ([[l_not_a]], [aa], uu___5) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "not interpretation"),
-          "l_not-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_range_interp env range tt =
-    let range_ty = FStar_SMTEncoding_Util.mkApp (range, []) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_SMTEncoding_Term.mk_Range_const () in
-          FStar_SMTEncoding_Term.mk_HasTypeZ uu___3 range_ty in
-        let uu___3 =
-          FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.mk_unique
-            "typing_range_const" in
-        (uu___2, (FStar_Pervasives_Native.Some "Range_const typing"), uu___3) in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_inversion_axiom env inversion tt =
-    let tt1 =
-      FStar_SMTEncoding_Term.mk_fv ("t", FStar_SMTEncoding_Term.Term_sort) in
-    let t = FStar_SMTEncoding_Util.mkFreeV tt1 in
-    let xx1 =
-      FStar_SMTEncoding_Term.mk_fv ("x", FStar_SMTEncoding_Term.Term_sort) in
-    let x1 = FStar_SMTEncoding_Util.mkFreeV xx1 in
-    let inversion_t = FStar_SMTEncoding_Util.mkApp (inversion, [t]) in
-    let valid = FStar_SMTEncoding_Util.mkApp ("Valid", [inversion_t]) in
-    let body =
-      let hastypeZ = FStar_SMTEncoding_Term.mk_HasTypeZ x1 t in
-      let hastypeS =
-        let uu___ = FStar_SMTEncoding_Term.n_fuel Prims.int_one in
-        FStar_SMTEncoding_Term.mk_HasTypeFuel uu___ x1 t in
-      let uu___ = FStar_TypeChecker_Env.get_range env in
-      let uu___1 =
-        let uu___2 = FStar_SMTEncoding_Util.mkImp (hastypeZ, hastypeS) in
-        ([[hastypeZ]], [xx1], uu___2) in
-      FStar_SMTEncoding_Term.mkForall uu___ uu___1 in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 = FStar_SMTEncoding_Util.mkImp (valid, body) in
-            ([[inversion_t]], [tt1], uu___5) in
-          FStar_SMTEncoding_Term.mkForall uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "inversion interpretation"),
-          "inversion-interp") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let mk_with_type_axiom env with_type tt =
-    let tt1 =
-      FStar_SMTEncoding_Term.mk_fv ("t", FStar_SMTEncoding_Term.Term_sort) in
-    let t = FStar_SMTEncoding_Util.mkFreeV tt1 in
-    let ee =
-      FStar_SMTEncoding_Term.mk_fv ("e", FStar_SMTEncoding_Term.Term_sort) in
-    let e = FStar_SMTEncoding_Util.mkFreeV ee in
-    let with_type_t_e = FStar_SMTEncoding_Util.mkApp (with_type, [t; e]) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_TypeChecker_Env.get_range env in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_SMTEncoding_Util.mkEq (with_type_t_e, e) in
-                let uu___8 =
-                  FStar_SMTEncoding_Term.mk_HasType with_type_t_e t in
-                (uu___7, uu___8) in
-              FStar_SMTEncoding_Util.mkAnd uu___6 in
-            ([[with_type_t_e]],
-              (FStar_Pervasives_Native.Some Prims.int_zero), [tt1; ee],
-              uu___5) in
-          FStar_SMTEncoding_Term.mkForall' uu___3 uu___4 in
-        (uu___2, (FStar_Pervasives_Native.Some "with_type primitive axiom"),
-          "@with_type_primitive_axiom") in
-      FStar_SMTEncoding_Util.mkAssume uu___1 in
-    [uu___] in
-  let prims1 =
-    [(FStar_Parser_Const.unit_lid, mk_unit);
-    (FStar_Parser_Const.bool_lid, mk_bool);
-    (FStar_Parser_Const.int_lid, mk_int);
-    (FStar_Parser_Const.real_lid, mk_real);
-    (FStar_Parser_Const.string_lid, mk_str);
-    (FStar_Parser_Const.true_lid, mk_true_interp);
-    (FStar_Parser_Const.false_lid, mk_false_interp);
-    (FStar_Parser_Const.and_lid, mk_and_interp);
-    (FStar_Parser_Const.or_lid, mk_or_interp);
-    (FStar_Parser_Const.eq2_lid, mk_eq2_interp);
-    (FStar_Parser_Const.imp_lid, mk_imp_interp);
-    (FStar_Parser_Const.iff_lid, mk_iff_interp);
-    (FStar_Parser_Const.not_lid, mk_not_interp);
-    (FStar_Parser_Const.range_lid, mk_range_interp);
-    (FStar_Parser_Const.inversion_lid, mk_inversion_axiom);
-    (FStar_Parser_Const.with_type_lid, mk_with_type_axiom)] in
-  fun env ->
-    fun t ->
-      fun s ->
-        fun tt ->
-          let uu___ =
-            FStar_Compiler_Util.find_opt
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (l, uu___2) -> FStar_Ident.lid_equals l t) prims1 in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> []
-          | FStar_Pervasives_Native.Some (uu___1, f) -> f env s tt
-let (encode_smt_lemma :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_Syntax_Syntax.typ -> FStar_SMTEncoding_Term.decls_elt Prims.list)
-  =
-  fun env ->
-    fun fv ->
-      fun t ->
-        let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-        let uu___ =
-          FStar_SMTEncoding_EncodeTerm.encode_function_type_as_formula t env in
-        match uu___ with
-        | (form, decls) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 = FStar_Ident.string_of_lid lid in
-                        Prims.op_Hat "Lemma: " uu___7 in
-                      FStar_Pervasives_Native.Some uu___6 in
-                    let uu___6 =
-                      let uu___7 = FStar_Ident.string_of_lid lid in
-                      Prims.op_Hat "lemma_" uu___7 in
-                    (form, uu___5, uu___6) in
-                  FStar_SMTEncoding_Util.mkAssume uu___4 in
-                [uu___3] in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_SMTEncoding_Term.mk_decls_trivial in
-            FStar_Compiler_List.op_At decls uu___1
-let (encode_free_var :
-  Prims.bool ->
-    FStar_SMTEncoding_Env.env_t ->
-      FStar_Syntax_Syntax.fv ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Syntax_Syntax.qualifier Prims.list ->
-              (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.env_t))
-  =
-  fun uninterpreted ->
-    fun env ->
-      fun fv ->
-        fun tt ->
-          fun t_norm ->
-            fun quals ->
-              let lid =
-                (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-              let uu___ =
-                ((let uu___1 =
-                    (FStar_Syntax_Util.is_pure_or_ghost_function t_norm) ||
-                      (FStar_SMTEncoding_Util.is_smt_reifiable_function
-                         env.FStar_SMTEncoding_Env.tcenv t_norm) in
-                  FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___1)
-                   || (FStar_Syntax_Util.is_lemma t_norm))
-                  || uninterpreted in
-              if uu___
-              then
-                let arg_sorts =
-                  let uu___1 =
-                    let uu___2 = FStar_Syntax_Subst.compress t_norm in
-                    uu___2.FStar_Syntax_Syntax.n in
-                  match uu___1 with
-                  | FStar_Syntax_Syntax.Tm_arrow (binders, uu___2) ->
-                      FStar_Compiler_Effect.op_Bar_Greater binders
-                        (FStar_Compiler_List.map
-                           (fun uu___3 -> FStar_SMTEncoding_Term.Term_sort))
-                  | uu___2 -> [] in
-                let arity = FStar_Compiler_List.length arg_sorts in
-                let uu___1 =
-                  FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid
-                    env lid arity in
-                match uu___1 with
-                | (vname, vtok, env1) ->
-                    let d =
-                      FStar_SMTEncoding_Term.DeclFun
-                        (vname, arg_sorts, FStar_SMTEncoding_Term.Term_sort,
-                          (FStar_Pervasives_Native.Some
-                             "Uninterpreted function symbol for impure function")) in
-                    let dd =
-                      FStar_SMTEncoding_Term.DeclFun
-                        (vtok, [], FStar_SMTEncoding_Term.Term_sort,
-                          (FStar_Pervasives_Native.Some
-                             "Uninterpreted name for impure function")) in
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bar_Greater [d; dd]
-                        FStar_SMTEncoding_Term.mk_decls_trivial in
-                    (uu___2, env1)
-              else
-                (let uu___2 = prims.is lid in
-                 if uu___2
-                 then
-                   let vname =
-                     FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.new_fvar
-                       lid in
-                   let uu___3 = prims.mk lid vname in
-                   match uu___3 with
-                   | (tok, arity, definition) ->
-                       let env1 =
-                         FStar_SMTEncoding_Env.push_free_var env lid arity
-                           vname (FStar_Pervasives_Native.Some tok) in
-                       let uu___4 =
-                         FStar_Compiler_Effect.op_Bar_Greater definition
-                           FStar_SMTEncoding_Term.mk_decls_trivial in
-                       (uu___4, env1)
-                 else
-                   (let encode_non_total_function_typ =
-                      let uu___4 = FStar_Ident.nsstr lid in uu___4 <> "Prims" in
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_SMTEncoding_EncodeTerm.curried_arrow_formals_comp
-                          t_norm in
-                      match uu___5 with
-                      | (args, comp) ->
-                          let tcenv_comp =
-                            FStar_TypeChecker_Env.push_binders
-                              env.FStar_SMTEncoding_Env.tcenv args in
-                          let comp1 =
-                            let uu___6 =
-                              FStar_SMTEncoding_Util.is_smt_reifiable_comp
-                                env.FStar_SMTEncoding_Env.tcenv comp in
-                            if uu___6
-                            then
-                              let uu___7 =
-                                FStar_TypeChecker_Env.reify_comp
-                                  {
-                                    FStar_TypeChecker_Env.solver =
-                                      (tcenv_comp.FStar_TypeChecker_Env.solver);
-                                    FStar_TypeChecker_Env.range =
-                                      (tcenv_comp.FStar_TypeChecker_Env.range);
-                                    FStar_TypeChecker_Env.curmodule =
-                                      (tcenv_comp.FStar_TypeChecker_Env.curmodule);
-                                    FStar_TypeChecker_Env.gamma =
-                                      (tcenv_comp.FStar_TypeChecker_Env.gamma);
-                                    FStar_TypeChecker_Env.gamma_sig =
-                                      (tcenv_comp.FStar_TypeChecker_Env.gamma_sig);
-                                    FStar_TypeChecker_Env.gamma_cache =
-                                      (tcenv_comp.FStar_TypeChecker_Env.gamma_cache);
-                                    FStar_TypeChecker_Env.modules =
-                                      (tcenv_comp.FStar_TypeChecker_Env.modules);
-                                    FStar_TypeChecker_Env.expected_typ =
-                                      (tcenv_comp.FStar_TypeChecker_Env.expected_typ);
-                                    FStar_TypeChecker_Env.sigtab =
-                                      (tcenv_comp.FStar_TypeChecker_Env.sigtab);
-                                    FStar_TypeChecker_Env.attrtab =
-                                      (tcenv_comp.FStar_TypeChecker_Env.attrtab);
-                                    FStar_TypeChecker_Env.instantiate_imp =
-                                      (tcenv_comp.FStar_TypeChecker_Env.instantiate_imp);
-                                    FStar_TypeChecker_Env.effects =
-                                      (tcenv_comp.FStar_TypeChecker_Env.effects);
-                                    FStar_TypeChecker_Env.generalize =
-                                      (tcenv_comp.FStar_TypeChecker_Env.generalize);
-                                    FStar_TypeChecker_Env.letrecs =
-                                      (tcenv_comp.FStar_TypeChecker_Env.letrecs);
-                                    FStar_TypeChecker_Env.top_level =
-                                      (tcenv_comp.FStar_TypeChecker_Env.top_level);
-                                    FStar_TypeChecker_Env.check_uvars =
-                                      (tcenv_comp.FStar_TypeChecker_Env.check_uvars);
-                                    FStar_TypeChecker_Env.use_eq_strict =
-                                      (tcenv_comp.FStar_TypeChecker_Env.use_eq_strict);
-                                    FStar_TypeChecker_Env.is_iface =
-                                      (tcenv_comp.FStar_TypeChecker_Env.is_iface);
-                                    FStar_TypeChecker_Env.admit =
-                                      (tcenv_comp.FStar_TypeChecker_Env.admit);
-                                    FStar_TypeChecker_Env.lax = true;
-                                    FStar_TypeChecker_Env.lax_universes =
-                                      (tcenv_comp.FStar_TypeChecker_Env.lax_universes);
-                                    FStar_TypeChecker_Env.phase1 =
-                                      (tcenv_comp.FStar_TypeChecker_Env.phase1);
-                                    FStar_TypeChecker_Env.failhard =
-                                      (tcenv_comp.FStar_TypeChecker_Env.failhard);
-                                    FStar_TypeChecker_Env.nosynth =
-                                      (tcenv_comp.FStar_TypeChecker_Env.nosynth);
-                                    FStar_TypeChecker_Env.uvar_subtyping =
-                                      (tcenv_comp.FStar_TypeChecker_Env.uvar_subtyping);
-                                    FStar_TypeChecker_Env.tc_term =
-                                      (tcenv_comp.FStar_TypeChecker_Env.tc_term);
-                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.universe_of =
-                                      (tcenv_comp.FStar_TypeChecker_Env.universe_of);
-                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.teq_nosmt_force =
-                                      (tcenv_comp.FStar_TypeChecker_Env.teq_nosmt_force);
-                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                    FStar_TypeChecker_Env.normalized_eff_names
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.normalized_eff_names);
-                                    FStar_TypeChecker_Env.fv_delta_depths =
-                                      (tcenv_comp.FStar_TypeChecker_Env.fv_delta_depths);
-                                    FStar_TypeChecker_Env.proof_ns =
-                                      (tcenv_comp.FStar_TypeChecker_Env.proof_ns);
-                                    FStar_TypeChecker_Env.synth_hook =
-                                      (tcenv_comp.FStar_TypeChecker_Env.synth_hook);
-                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                    FStar_TypeChecker_Env.splice =
-                                      (tcenv_comp.FStar_TypeChecker_Env.splice);
-                                    FStar_TypeChecker_Env.mpreprocess =
-                                      (tcenv_comp.FStar_TypeChecker_Env.mpreprocess);
-                                    FStar_TypeChecker_Env.postprocess =
-                                      (tcenv_comp.FStar_TypeChecker_Env.postprocess);
-                                    FStar_TypeChecker_Env.identifier_info =
-                                      (tcenv_comp.FStar_TypeChecker_Env.identifier_info);
-                                    FStar_TypeChecker_Env.tc_hooks =
-                                      (tcenv_comp.FStar_TypeChecker_Env.tc_hooks);
-                                    FStar_TypeChecker_Env.dsenv =
-                                      (tcenv_comp.FStar_TypeChecker_Env.dsenv);
-                                    FStar_TypeChecker_Env.nbe =
-                                      (tcenv_comp.FStar_TypeChecker_Env.nbe);
-                                    FStar_TypeChecker_Env.strict_args_tab =
-                                      (tcenv_comp.FStar_TypeChecker_Env.strict_args_tab);
-                                    FStar_TypeChecker_Env.erasable_types_tab
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.erasable_types_tab);
-                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                    FStar_TypeChecker_Env.erase_erasable_args
-                                      =
-                                      (tcenv_comp.FStar_TypeChecker_Env.erase_erasable_args);
-                                    FStar_TypeChecker_Env.core_check =
-                                      (tcenv_comp.FStar_TypeChecker_Env.core_check)
-                                  } comp FStar_Syntax_Syntax.U_unknown in
-                              FStar_Syntax_Syntax.mk_Total uu___7
-                            else comp in
-                          if encode_non_total_function_typ
-                          then
-                            let uu___6 =
-                              FStar_TypeChecker_Util.pure_or_ghost_pre_and_post
-                                tcenv_comp comp1 in
-                            (args, uu___6)
-                          else
-                            (args,
-                              (FStar_Pervasives_Native.None,
-                                (FStar_Syntax_Util.comp_result comp1))) in
-                    match uu___4 with
-                    | (formals, (pre_opt, res_t)) ->
-                        let mk_disc_proj_axioms guard encoded_res_t vapp vars
-                          =
-                          FStar_Compiler_Effect.op_Bar_Greater quals
-                            (FStar_Compiler_List.collect
-                               (fun uu___5 ->
-                                  match uu___5 with
-                                  | FStar_Syntax_Syntax.Discriminator d ->
-                                      let uu___6 =
-                                        FStar_Compiler_Util.prefix vars in
-                                      (match uu___6 with
-                                       | (uu___7, xxv) ->
-                                           let xx =
-                                             let uu___8 =
-                                               let uu___9 =
-                                                 let uu___10 =
-                                                   FStar_SMTEncoding_Term.fv_name
-                                                     xxv in
-                                                 (uu___10,
-                                                   FStar_SMTEncoding_Term.Term_sort) in
-                                               FStar_SMTEncoding_Term.mk_fv
-                                                 uu___9 in
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               FStar_SMTEncoding_Util.mkFreeV
-                                               uu___8 in
-                                           let uu___8 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_Syntax_Syntax.range_of_fv
-                                                     fv in
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     let uu___14 =
-                                                       let uu___15 =
-                                                         let uu___16 =
-                                                           let uu___17 =
-                                                             let uu___18 =
-                                                               FStar_Ident.string_of_lid
-                                                                 d in
-                                                             FStar_SMTEncoding_Env.escape
-                                                               uu___18 in
-                                                           FStar_SMTEncoding_Term.mk_tester
-                                                             uu___17 xx in
-                                                         FStar_Compiler_Effect.op_Less_Bar
-                                                           FStar_SMTEncoding_Term.boxBool
-                                                           uu___16 in
-                                                       (vapp, uu___15) in
-                                                     FStar_SMTEncoding_Util.mkEq
-                                                       uu___14 in
-                                                   ([[vapp]], vars, uu___13) in
-                                                 FStar_SMTEncoding_Term.mkForall
-                                                   uu___11 uu___12 in
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     FStar_Ident.string_of_lid
-                                                       d in
-                                                   FStar_SMTEncoding_Env.escape
-                                                     uu___13 in
-                                                 Prims.op_Hat
-                                                   "disc_equation_" uu___12 in
-                                               (uu___10,
-                                                 (FStar_Pervasives_Native.Some
-                                                    "Discriminator equation"),
-                                                 uu___11) in
-                                             FStar_SMTEncoding_Util.mkAssume
-                                               uu___9 in
-                                           [uu___8])
-                                  | FStar_Syntax_Syntax.Projector (d, f) ->
-                                      let uu___6 =
-                                        FStar_Compiler_Util.prefix vars in
-                                      (match uu___6 with
-                                       | (uu___7, xxv) ->
-                                           let xx =
-                                             let uu___8 =
-                                               let uu___9 =
-                                                 let uu___10 =
-                                                   FStar_SMTEncoding_Term.fv_name
-                                                     xxv in
-                                                 (uu___10,
-                                                   FStar_SMTEncoding_Term.Term_sort) in
-                                               FStar_SMTEncoding_Term.mk_fv
-                                                 uu___9 in
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               FStar_SMTEncoding_Util.mkFreeV
-                                               uu___8 in
-                                           let f1 =
-                                             {
-                                               FStar_Syntax_Syntax.ppname = f;
-                                               FStar_Syntax_Syntax.index =
-                                                 Prims.int_zero;
-                                               FStar_Syntax_Syntax.sort =
-                                                 FStar_Syntax_Syntax.tun
-                                             } in
-                                           let tp_name =
-                                             FStar_SMTEncoding_Env.mk_term_projector_name
-                                               d f1 in
-                                           let prim_app =
-                                             FStar_SMTEncoding_Util.mkApp
-                                               (tp_name, [xx]) in
-                                           let uu___8 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_Syntax_Syntax.range_of_fv
-                                                     fv in
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     FStar_SMTEncoding_Util.mkEq
-                                                       (vapp, prim_app) in
-                                                   ([[vapp]], vars, uu___13) in
-                                                 FStar_SMTEncoding_Term.mkForall
-                                                   uu___11 uu___12 in
-                                               (uu___10,
-                                                 (FStar_Pervasives_Native.Some
-                                                    "Projector equation"),
-                                                 (Prims.op_Hat
-                                                    "proj_equation_" tp_name)) in
-                                             FStar_SMTEncoding_Util.mkAssume
-                                               uu___9 in
-                                           [uu___8])
-                                  | uu___6 -> [])) in
-                        let uu___5 =
-                          FStar_SMTEncoding_EncodeTerm.encode_binders
-                            FStar_Pervasives_Native.None formals env in
-                        (match uu___5 with
-                         | (vars, guards, env', decls1, uu___6) ->
-                             let uu___7 =
-                               match pre_opt with
-                               | FStar_Pervasives_Native.None ->
-                                   let uu___8 =
-                                     FStar_SMTEncoding_Util.mk_and_l guards in
-                                   (uu___8, decls1)
-                               | FStar_Pervasives_Native.Some p ->
-                                   let uu___8 =
-                                     FStar_SMTEncoding_EncodeTerm.encode_formula
-                                       p env' in
-                                   (match uu___8 with
-                                    | (g, ds) ->
-                                        let uu___9 =
-                                          FStar_SMTEncoding_Util.mk_and_l (g
-                                            :: guards) in
-                                        (uu___9,
-                                          (FStar_Compiler_List.op_At decls1
-                                             ds))) in
-                             (match uu___7 with
-                              | (guard, decls11) ->
-                                  let dummy_var =
-                                    FStar_SMTEncoding_Term.mk_fv
-                                      ("@dummy",
-                                        FStar_SMTEncoding_Term.dummy_sort) in
-                                  let dummy_tm =
-                                    FStar_SMTEncoding_Term.mkFreeV dummy_var
-                                      FStar_Compiler_Range.dummyRange in
-                                  let should_thunk uu___8 =
-                                    let is_type t =
-                                      let uu___9 =
-                                        let uu___10 =
-                                          FStar_Syntax_Subst.compress t in
-                                        uu___10.FStar_Syntax_Syntax.n in
-                                      match uu___9 with
-                                      | FStar_Syntax_Syntax.Tm_type uu___10
-                                          -> true
-                                      | uu___10 -> false in
-                                    let is_squash t =
-                                      let uu___9 =
-                                        FStar_Syntax_Util.head_and_args t in
-                                      match uu___9 with
-                                      | (head, uu___10) ->
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_Syntax_Util.un_uinst head in
-                                            uu___12.FStar_Syntax_Syntax.n in
-                                          (match uu___11 with
-                                           | FStar_Syntax_Syntax.Tm_fvar fv1
-                                               ->
-                                               FStar_Syntax_Syntax.fv_eq_lid
-                                                 fv1
-                                                 FStar_Parser_Const.squash_lid
-                                           | FStar_Syntax_Syntax.Tm_refine
-                                               ({
-                                                  FStar_Syntax_Syntax.ppname
-                                                    = uu___12;
-                                                  FStar_Syntax_Syntax.index =
-                                                    uu___13;
-                                                  FStar_Syntax_Syntax.sort =
-                                                    {
-                                                      FStar_Syntax_Syntax.n =
-                                                        FStar_Syntax_Syntax.Tm_fvar
-                                                        fv1;
-                                                      FStar_Syntax_Syntax.pos
-                                                        = uu___14;
-                                                      FStar_Syntax_Syntax.vars
-                                                        = uu___15;
-                                                      FStar_Syntax_Syntax.hash_code
-                                                        = uu___16;_};_},
-                                                uu___17)
-                                               ->
-                                               FStar_Syntax_Syntax.fv_eq_lid
-                                                 fv1
-                                                 FStar_Parser_Const.unit_lid
-                                           | uu___12 -> false) in
-                                    (((let uu___9 = FStar_Ident.nsstr lid in
-                                       uu___9 <> "Prims") &&
-                                        (let uu___9 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             quals
-                                             (FStar_Compiler_List.contains
-                                                FStar_Syntax_Syntax.Logic) in
-                                         Prims.op_Negation uu___9))
-                                       &&
-                                       (let uu___9 = is_squash t_norm in
-                                        Prims.op_Negation uu___9))
-                                      &&
-                                      (let uu___9 = is_type t_norm in
-                                       Prims.op_Negation uu___9) in
-                                  let uu___8 =
-                                    match vars with
-                                    | [] when should_thunk () ->
-                                        (true, [dummy_var])
-                                    | uu___9 -> (false, vars) in
-                                  (match uu___8 with
-                                   | (thunked, vars1) ->
-                                       let arity =
-                                         FStar_Compiler_List.length formals in
-                                       let uu___9 =
-                                         FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid_maybe_thunked
-                                           env lid arity thunked in
-                                       (match uu___9 with
-                                        | (vname, vtok_opt, env1) ->
-                                            let get_vtok uu___10 =
-                                              FStar_Compiler_Option.get
-                                                vtok_opt in
-                                            let vtok_tm =
-                                              match formals with
-                                              | [] when
-                                                  Prims.op_Negation thunked
-                                                  ->
-                                                  FStar_SMTEncoding_Util.mkApp
-                                                    (vname, [])
-                                              | [] when thunked ->
-                                                  FStar_SMTEncoding_Util.mkApp
-                                                    (vname, [dummy_tm])
-                                              | uu___10 ->
-                                                  let uu___11 =
-                                                    let uu___12 = get_vtok () in
-                                                    (uu___12, []) in
-                                                  FStar_SMTEncoding_Util.mkApp
-                                                    uu___11 in
-                                            let vtok_app =
-                                              FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                                vtok_tm vars1 in
-                                            let vapp =
-                                              let uu___10 =
-                                                let uu___11 =
-                                                  FStar_Compiler_List.map
-                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                    vars1 in
-                                                (vname, uu___11) in
-                                              FStar_SMTEncoding_Util.mkApp
-                                                uu___10 in
-                                            let uu___10 =
-                                              let vname_decl =
-                                                let uu___11 =
-                                                  let uu___12 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      vars1
-                                                      (FStar_Compiler_List.map
-                                                         FStar_SMTEncoding_Term.fv_sort) in
-                                                  (vname, uu___12,
-                                                    FStar_SMTEncoding_Term.Term_sort,
-                                                    FStar_Pervasives_Native.None) in
-                                                FStar_SMTEncoding_Term.DeclFun
-                                                  uu___11 in
-                                              let uu___11 =
-                                                let env2 =
-                                                  {
-                                                    FStar_SMTEncoding_Env.bvar_bindings
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.bvar_bindings);
-                                                    FStar_SMTEncoding_Env.fvar_bindings
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.fvar_bindings);
-                                                    FStar_SMTEncoding_Env.depth
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.depth);
-                                                    FStar_SMTEncoding_Env.tcenv
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.tcenv);
-                                                    FStar_SMTEncoding_Env.warn
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.warn);
-                                                    FStar_SMTEncoding_Env.nolabels
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.nolabels);
-                                                    FStar_SMTEncoding_Env.use_zfuel_name
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.use_zfuel_name);
-                                                    FStar_SMTEncoding_Env.encode_non_total_function_typ
-                                                      =
-                                                      encode_non_total_function_typ;
-                                                    FStar_SMTEncoding_Env.current_module_name
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.current_module_name);
-                                                    FStar_SMTEncoding_Env.encoding_quantifier
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.encoding_quantifier);
-                                                    FStar_SMTEncoding_Env.global_cache
-                                                      =
-                                                      (env1.FStar_SMTEncoding_Env.global_cache)
-                                                  } in
-                                                let uu___12 =
-                                                  let uu___13 =
-                                                    FStar_SMTEncoding_EncodeTerm.head_normal
-                                                      env2 tt in
-                                                  Prims.op_Negation uu___13 in
-                                                if uu___12
-                                                then
-                                                  FStar_SMTEncoding_EncodeTerm.encode_term_pred
-                                                    FStar_Pervasives_Native.None
-                                                    tt env2 vtok_tm
-                                                else
-                                                  FStar_SMTEncoding_EncodeTerm.encode_term_pred
-                                                    FStar_Pervasives_Native.None
-                                                    t_norm env2 vtok_tm in
-                                              match uu___11 with
-                                              | (tok_typing, decls2) ->
-                                                  let uu___12 =
-                                                    match vars1 with
-                                                    | [] ->
-                                                        let tok_typing1 =
-                                                          FStar_SMTEncoding_Util.mkAssume
-                                                            (tok_typing,
-                                                              (FStar_Pervasives_Native.Some
-                                                                 "function token typing"),
-                                                              (Prims.op_Hat
-                                                                 "function_token_typing_"
-                                                                 vname)) in
-                                                        let uu___13 =
-                                                          let uu___14 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              [tok_typing1]
-                                                              FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                          FStar_Compiler_List.op_At
-                                                            decls2 uu___14 in
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              FStar_SMTEncoding_Util.mkApp
-                                                                (vname, []) in
-                                                            FStar_Compiler_Effect.op_Less_Bar
-                                                              (fun uu___17 ->
-                                                                 FStar_Pervasives_Native.Some
-                                                                   uu___17)
-                                                              uu___16 in
-                                                          FStar_SMTEncoding_Env.push_free_var
-                                                            env1 lid arity
-                                                            vname uu___15 in
-                                                        (uu___13, uu___14)
-                                                    | uu___13 when thunked ->
-                                                        (decls2, env1)
-                                                    | uu___13 ->
-                                                        let vtok =
-                                                          get_vtok () in
-                                                        let vtok_decl =
-                                                          FStar_SMTEncoding_Term.DeclFun
-                                                            (vtok, [],
-                                                              FStar_SMTEncoding_Term.Term_sort,
-                                                              FStar_Pervasives_Native.None) in
-                                                        let name_tok_corr_formula
-                                                          pat =
-                                                          let uu___14 =
-                                                            FStar_Syntax_Syntax.range_of_fv
-                                                              fv in
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              FStar_SMTEncoding_Util.mkEq
-                                                                (vtok_app,
-                                                                  vapp) in
-                                                            ([[pat]], vars1,
-                                                              uu___16) in
-                                                          FStar_SMTEncoding_Term.mkForall
-                                                            uu___14 uu___15 in
-                                                        let name_tok_corr =
-                                                          let uu___14 =
-                                                            let uu___15 =
-                                                              name_tok_corr_formula
-                                                                vtok_app in
-                                                            (uu___15,
-                                                              (FStar_Pervasives_Native.Some
-                                                                 "Name-token correspondence"),
-                                                              (Prims.op_Hat
-                                                                 "token_correspondence_"
-                                                                 vname)) in
-                                                          FStar_SMTEncoding_Util.mkAssume
-                                                            uu___14 in
-                                                        let tok_typing1 =
-                                                          let ff =
-                                                            FStar_SMTEncoding_Term.mk_fv
-                                                              ("ty",
-                                                                FStar_SMTEncoding_Term.Term_sort) in
-                                                          let f =
-                                                            FStar_SMTEncoding_Util.mkFreeV
-                                                              ff in
-                                                          let vtok_app_r =
-                                                            let uu___14 =
-                                                              let uu___15 =
-                                                                FStar_SMTEncoding_Term.mk_fv
-                                                                  (vtok,
-                                                                    FStar_SMTEncoding_Term.Term_sort) in
-                                                              [uu___15] in
-                                                            FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                                              f uu___14 in
-                                                          let guarded_tok_typing
-                                                            =
-                                                            let uu___14 =
-                                                              FStar_Syntax_Syntax.range_of_fv
-                                                                fv in
-                                                            let uu___15 =
-                                                              let uu___16 =
-                                                                let uu___17 =
-                                                                  let uu___18
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_NoHoist
-                                                                    f
-                                                                    tok_typing in
-                                                                  let uu___19
-                                                                    =
-                                                                    name_tok_corr_formula
-                                                                    vapp in
-                                                                  (uu___18,
-                                                                    uu___19) in
-                                                                FStar_SMTEncoding_Util.mkAnd
-                                                                  uu___17 in
-                                                              ([[vtok_app_r]],
-                                                                [ff],
-                                                                uu___16) in
-                                                            FStar_SMTEncoding_Term.mkForall
-                                                              uu___14 uu___15 in
-                                                          FStar_SMTEncoding_Util.mkAssume
-                                                            (guarded_tok_typing,
-                                                              (FStar_Pervasives_Native.Some
-                                                                 "function token typing"),
-                                                              (Prims.op_Hat
-                                                                 "function_token_typing_"
-                                                                 vname)) in
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              [vtok_decl;
-                                                              name_tok_corr;
-                                                              tok_typing1]
-                                                              FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                          FStar_Compiler_List.op_At
-                                                            decls2 uu___15 in
-                                                        (uu___14, env1) in
-                                                  (match uu___12 with
-                                                   | (tok_decl, env2) ->
-                                                       let uu___13 =
-                                                         let uu___14 =
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             [vname_decl]
-                                                             FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                         FStar_Compiler_List.op_At
-                                                           uu___14 tok_decl in
-                                                       (uu___13, env2)) in
-                                            (match uu___10 with
-                                             | (decls2, env2) ->
-                                                 let uu___11 =
-                                                   let res_t1 =
-                                                     FStar_Syntax_Subst.compress
-                                                       res_t in
-                                                   let uu___12 =
-                                                     FStar_SMTEncoding_EncodeTerm.encode_term
-                                                       res_t1 env' in
-                                                   match uu___12 with
-                                                   | (encoded_res_t, decls)
-                                                       ->
-                                                       let uu___13 =
-                                                         FStar_SMTEncoding_Term.mk_HasType
-                                                           vapp encoded_res_t in
-                                                       (encoded_res_t,
-                                                         uu___13, decls) in
-                                                 (match uu___11 with
-                                                  | (encoded_res_t, ty_pred,
-                                                     decls3) ->
-                                                      let typingAx =
-                                                        let uu___12 =
-                                                          let uu___13 =
-                                                            let uu___14 =
-                                                              FStar_Syntax_Syntax.range_of_fv
-                                                                fv in
-                                                            let uu___15 =
-                                                              let uu___16 =
-                                                                FStar_SMTEncoding_Util.mkImp
-                                                                  (guard,
-                                                                    ty_pred) in
-                                                              ([[vapp]],
-                                                                vars1,
-                                                                uu___16) in
-                                                            FStar_SMTEncoding_Term.mkForall
-                                                              uu___14 uu___15 in
-                                                          (uu___13,
-                                                            (FStar_Pervasives_Native.Some
-                                                               "free var typing"),
-                                                            (Prims.op_Hat
-                                                               "typing_"
-                                                               vname)) in
-                                                        FStar_SMTEncoding_Util.mkAssume
-                                                          uu___12 in
-                                                      let freshness =
-                                                        let uu___12 =
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            quals
-                                                            (FStar_Compiler_List.contains
-                                                               FStar_Syntax_Syntax.New) in
-                                                        if uu___12
-                                                        then
-                                                          let uu___13 =
-                                                            let uu___14 =
-                                                              FStar_Syntax_Syntax.range_of_fv
-                                                                fv in
-                                                            let uu___15 =
-                                                              let uu___16 =
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  vars1
-                                                                  (FStar_Compiler_List.map
-                                                                    FStar_SMTEncoding_Term.fv_sort) in
-                                                              let uu___17 =
-                                                                FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.next_id
-                                                                  () in
-                                                              (vname,
-                                                                uu___16,
-                                                                FStar_SMTEncoding_Term.Term_sort,
-                                                                uu___17) in
-                                                            FStar_SMTEncoding_Term.fresh_constructor
-                                                              uu___14 uu___15 in
-                                                          let uu___14 =
-                                                            let uu___15 =
-                                                              let uu___16 =
-                                                                FStar_Syntax_Syntax.range_of_fv
-                                                                  fv in
-                                                              pretype_axiom
-                                                                uu___16 env2
-                                                                vapp vars1 in
-                                                            [uu___15] in
-                                                          uu___13 :: uu___14
-                                                        else [] in
-                                                      let g =
-                                                        let uu___12 =
-                                                          let uu___13 =
-                                                            let uu___14 =
-                                                              let uu___15 =
-                                                                let uu___16 =
-                                                                  let uu___17
-                                                                    =
-                                                                    mk_disc_proj_axioms
-                                                                    guard
-                                                                    encoded_res_t
-                                                                    vapp
-                                                                    vars1 in
-                                                                  typingAx ::
-                                                                    uu___17 in
-                                                                FStar_Compiler_List.op_At
-                                                                  freshness
-                                                                  uu___16 in
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                uu___15
-                                                                FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                            FStar_Compiler_List.op_At
-                                                              decls3 uu___14 in
-                                                          FStar_Compiler_List.op_At
-                                                            decls2 uu___13 in
-                                                        FStar_Compiler_List.op_At
-                                                          decls11 uu___12 in
-                                                      (g, env2)))))))))
-let (declare_top_level_let :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term ->
-          (FStar_SMTEncoding_Env.fvar_binding *
-            FStar_SMTEncoding_Term.decls_elt Prims.list *
-            FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun x ->
-      fun t ->
-        fun t_norm ->
-          let uu___ =
-            FStar_SMTEncoding_Env.lookup_fvar_binding env
-              (x.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          match uu___ with
-          | FStar_Pervasives_Native.None ->
-              let uu___1 = encode_free_var false env x t t_norm [] in
-              (match uu___1 with
-               | (decls, env1) ->
-                   let fvb =
-                     FStar_SMTEncoding_Env.lookup_lid env1
-                       (x.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                   (fvb, decls, env1))
-          | FStar_Pervasives_Native.Some fvb -> (fvb, [], env)
-let (encode_top_level_val :
-  Prims.bool ->
-    FStar_SMTEncoding_Env.env_t ->
-      FStar_Syntax_Syntax.fv ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.qualifier Prims.list ->
-            (FStar_SMTEncoding_Term.decls_elt Prims.list *
-              FStar_SMTEncoding_Env.env_t))
-  =
-  fun uninterpreted ->
-    fun env ->
-      fun fv ->
-        fun t ->
-          fun quals ->
-            let tt =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Syntax.lid_of_fv fv in
-                  FStar_Ident.nsstr uu___2 in
-                uu___1 = "FStar.Ghost" in
-              if uu___
-              then
-                norm_with_steps
-                  [FStar_TypeChecker_Env.Eager_unfolding;
-                  FStar_TypeChecker_Env.Simplify;
-                  FStar_TypeChecker_Env.AllowUnboundUniverses;
-                  FStar_TypeChecker_Env.EraseUniverses;
-                  FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta]
-                  env.FStar_SMTEncoding_Env.tcenv t
-              else norm_before_encoding env t in
-            let uu___ = encode_free_var uninterpreted env fv t tt quals in
-            match uu___ with
-            | (decls, env1) ->
-                let uu___1 = FStar_Syntax_Util.is_smt_lemma t in
-                if uu___1
-                then
-                  let uu___2 =
-                    let uu___3 = encode_smt_lemma env1 fv tt in
-                    FStar_Compiler_List.op_At decls uu___3 in
-                  (uu___2, env1)
-                else (decls, env1)
-let (encode_top_level_vals :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.letbinding Prims.list ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        (FStar_SMTEncoding_Term.decls_elt Prims.list *
-          FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun bindings ->
-      fun quals ->
-        FStar_Compiler_Effect.op_Bar_Greater bindings
-          (FStar_Compiler_List.fold_left
-             (fun uu___ ->
-                fun lb ->
-                  match uu___ with
-                  | (decls, env1) ->
-                      let uu___1 =
-                        let uu___2 =
-                          FStar_Compiler_Util.right
-                            lb.FStar_Syntax_Syntax.lbname in
-                        encode_top_level_val false env1 uu___2
-                          lb.FStar_Syntax_Syntax.lbtyp quals in
-                      (match uu___1 with
-                       | (decls', env2) ->
-                           ((FStar_Compiler_List.op_At decls decls'), env2)))
-             ([], env))
-exception Let_rec_unencodeable 
-let (uu___is_Let_rec_unencodeable : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Let_rec_unencodeable -> true | uu___ -> false
-let (copy_env : FStar_SMTEncoding_Env.env_t -> FStar_SMTEncoding_Env.env_t) =
-  fun en ->
-    let uu___ =
-      FStar_Compiler_Util.smap_copy en.FStar_SMTEncoding_Env.global_cache in
-    {
-      FStar_SMTEncoding_Env.bvar_bindings =
-        (en.FStar_SMTEncoding_Env.bvar_bindings);
-      FStar_SMTEncoding_Env.fvar_bindings =
-        (en.FStar_SMTEncoding_Env.fvar_bindings);
-      FStar_SMTEncoding_Env.depth = (en.FStar_SMTEncoding_Env.depth);
-      FStar_SMTEncoding_Env.tcenv = (en.FStar_SMTEncoding_Env.tcenv);
-      FStar_SMTEncoding_Env.warn = (en.FStar_SMTEncoding_Env.warn);
-      FStar_SMTEncoding_Env.nolabels = (en.FStar_SMTEncoding_Env.nolabels);
-      FStar_SMTEncoding_Env.use_zfuel_name =
-        (en.FStar_SMTEncoding_Env.use_zfuel_name);
-      FStar_SMTEncoding_Env.encode_non_total_function_typ =
-        (en.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-      FStar_SMTEncoding_Env.current_module_name =
-        (en.FStar_SMTEncoding_Env.current_module_name);
-      FStar_SMTEncoding_Env.encoding_quantifier =
-        (en.FStar_SMTEncoding_Env.encoding_quantifier);
-      FStar_SMTEncoding_Env.global_cache = uu___
-    }
-let (encode_top_level_let :
-  FStar_SMTEncoding_Env.env_t ->
-    (Prims.bool * FStar_Syntax_Syntax.letbinding Prims.list) ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun uu___ ->
-      fun quals ->
-        match uu___ with
-        | (is_rec, bindings) ->
-            let eta_expand binders formals body t =
-              let nbinders = FStar_Compiler_List.length binders in
-              let uu___1 = FStar_Compiler_Util.first_N nbinders formals in
-              match uu___1 with
-              | (formals1, extra_formals) ->
-                  let subst =
-                    FStar_Compiler_List.map2
-                      (fun uu___2 ->
-                         fun uu___3 ->
-                           match (uu___2, uu___3) with
-                           | ({ FStar_Syntax_Syntax.binder_bv = formal;
-                                FStar_Syntax_Syntax.binder_qual = uu___4;
-                                FStar_Syntax_Syntax.binder_attrs = uu___5;_},
-                              { FStar_Syntax_Syntax.binder_bv = binder;
-                                FStar_Syntax_Syntax.binder_qual = uu___6;
-                                FStar_Syntax_Syntax.binder_attrs = uu___7;_})
-                               ->
-                               let uu___8 =
-                                 let uu___9 =
-                                   FStar_Syntax_Syntax.bv_to_name binder in
-                                 (formal, uu___9) in
-                               FStar_Syntax_Syntax.NT uu___8) formals1
-                      binders in
-                  let extra_formals1 =
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bar_Greater extra_formals
-                        (FStar_Compiler_List.map
-                           (fun b ->
-                              let uu___3 =
-                                let uu___4 = b.FStar_Syntax_Syntax.binder_bv in
-                                let uu___5 =
-                                  FStar_Syntax_Subst.subst subst
-                                    (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                {
-                                  FStar_Syntax_Syntax.ppname =
-                                    (uu___4.FStar_Syntax_Syntax.ppname);
-                                  FStar_Syntax_Syntax.index =
-                                    (uu___4.FStar_Syntax_Syntax.index);
-                                  FStar_Syntax_Syntax.sort = uu___5
-                                } in
-                              {
-                                FStar_Syntax_Syntax.binder_bv = uu___3;
-                                FStar_Syntax_Syntax.binder_qual =
-                                  (b.FStar_Syntax_Syntax.binder_qual);
-                                FStar_Syntax_Syntax.binder_attrs =
-                                  (b.FStar_Syntax_Syntax.binder_attrs)
-                              })) in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___2
-                      FStar_Syntax_Util.name_binders in
-                  let body1 =
-                    let uu___2 = FStar_Syntax_Subst.compress body in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Syntax_Util.args_of_binders extra_formals1 in
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Pervasives_Native.snd uu___4 in
-                    FStar_Syntax_Syntax.extend_app_n uu___2 uu___3
-                      body.FStar_Syntax_Syntax.pos in
-                  ((FStar_Compiler_List.op_At binders extra_formals1), body1) in
-            let destruct_bound_function t e =
-              let tcenv =
-                let uu___1 = env.FStar_SMTEncoding_Env.tcenv in
-                {
-                  FStar_TypeChecker_Env.solver =
-                    (uu___1.FStar_TypeChecker_Env.solver);
-                  FStar_TypeChecker_Env.range =
-                    (uu___1.FStar_TypeChecker_Env.range);
-                  FStar_TypeChecker_Env.curmodule =
-                    (uu___1.FStar_TypeChecker_Env.curmodule);
-                  FStar_TypeChecker_Env.gamma =
-                    (uu___1.FStar_TypeChecker_Env.gamma);
-                  FStar_TypeChecker_Env.gamma_sig =
-                    (uu___1.FStar_TypeChecker_Env.gamma_sig);
-                  FStar_TypeChecker_Env.gamma_cache =
-                    (uu___1.FStar_TypeChecker_Env.gamma_cache);
-                  FStar_TypeChecker_Env.modules =
-                    (uu___1.FStar_TypeChecker_Env.modules);
-                  FStar_TypeChecker_Env.expected_typ =
-                    (uu___1.FStar_TypeChecker_Env.expected_typ);
-                  FStar_TypeChecker_Env.sigtab =
-                    (uu___1.FStar_TypeChecker_Env.sigtab);
-                  FStar_TypeChecker_Env.attrtab =
-                    (uu___1.FStar_TypeChecker_Env.attrtab);
-                  FStar_TypeChecker_Env.instantiate_imp =
-                    (uu___1.FStar_TypeChecker_Env.instantiate_imp);
-                  FStar_TypeChecker_Env.effects =
-                    (uu___1.FStar_TypeChecker_Env.effects);
-                  FStar_TypeChecker_Env.generalize =
-                    (uu___1.FStar_TypeChecker_Env.generalize);
-                  FStar_TypeChecker_Env.letrecs =
-                    (uu___1.FStar_TypeChecker_Env.letrecs);
-                  FStar_TypeChecker_Env.top_level =
-                    (uu___1.FStar_TypeChecker_Env.top_level);
-                  FStar_TypeChecker_Env.check_uvars =
-                    (uu___1.FStar_TypeChecker_Env.check_uvars);
-                  FStar_TypeChecker_Env.use_eq_strict =
-                    (uu___1.FStar_TypeChecker_Env.use_eq_strict);
-                  FStar_TypeChecker_Env.is_iface =
-                    (uu___1.FStar_TypeChecker_Env.is_iface);
-                  FStar_TypeChecker_Env.admit =
-                    (uu___1.FStar_TypeChecker_Env.admit);
-                  FStar_TypeChecker_Env.lax = true;
-                  FStar_TypeChecker_Env.lax_universes =
-                    (uu___1.FStar_TypeChecker_Env.lax_universes);
-                  FStar_TypeChecker_Env.phase1 =
-                    (uu___1.FStar_TypeChecker_Env.phase1);
-                  FStar_TypeChecker_Env.failhard =
-                    (uu___1.FStar_TypeChecker_Env.failhard);
-                  FStar_TypeChecker_Env.nosynth =
-                    (uu___1.FStar_TypeChecker_Env.nosynth);
-                  FStar_TypeChecker_Env.uvar_subtyping =
-                    (uu___1.FStar_TypeChecker_Env.uvar_subtyping);
-                  FStar_TypeChecker_Env.tc_term =
-                    (uu___1.FStar_TypeChecker_Env.tc_term);
-                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                    (uu___1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                  FStar_TypeChecker_Env.universe_of =
-                    (uu___1.FStar_TypeChecker_Env.universe_of);
-                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                    (uu___1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                  FStar_TypeChecker_Env.teq_nosmt_force =
-                    (uu___1.FStar_TypeChecker_Env.teq_nosmt_force);
-                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                    (uu___1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                    (uu___1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                  FStar_TypeChecker_Env.normalized_eff_names =
-                    (uu___1.FStar_TypeChecker_Env.normalized_eff_names);
-                  FStar_TypeChecker_Env.fv_delta_depths =
-                    (uu___1.FStar_TypeChecker_Env.fv_delta_depths);
-                  FStar_TypeChecker_Env.proof_ns =
-                    (uu___1.FStar_TypeChecker_Env.proof_ns);
-                  FStar_TypeChecker_Env.synth_hook =
-                    (uu___1.FStar_TypeChecker_Env.synth_hook);
-                  FStar_TypeChecker_Env.try_solve_implicits_hook =
-                    (uu___1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                  FStar_TypeChecker_Env.splice =
-                    (uu___1.FStar_TypeChecker_Env.splice);
-                  FStar_TypeChecker_Env.mpreprocess =
-                    (uu___1.FStar_TypeChecker_Env.mpreprocess);
-                  FStar_TypeChecker_Env.postprocess =
-                    (uu___1.FStar_TypeChecker_Env.postprocess);
-                  FStar_TypeChecker_Env.identifier_info =
-                    (uu___1.FStar_TypeChecker_Env.identifier_info);
-                  FStar_TypeChecker_Env.tc_hooks =
-                    (uu___1.FStar_TypeChecker_Env.tc_hooks);
-                  FStar_TypeChecker_Env.dsenv =
-                    (uu___1.FStar_TypeChecker_Env.dsenv);
-                  FStar_TypeChecker_Env.nbe =
-                    (uu___1.FStar_TypeChecker_Env.nbe);
-                  FStar_TypeChecker_Env.strict_args_tab =
-                    (uu___1.FStar_TypeChecker_Env.strict_args_tab);
-                  FStar_TypeChecker_Env.erasable_types_tab =
-                    (uu___1.FStar_TypeChecker_Env.erasable_types_tab);
-                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                    (uu___1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                  FStar_TypeChecker_Env.unif_allow_ref_guards =
-                    (uu___1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                  FStar_TypeChecker_Env.erase_erasable_args =
-                    (uu___1.FStar_TypeChecker_Env.erase_erasable_args);
-                  FStar_TypeChecker_Env.core_check =
-                    (uu___1.FStar_TypeChecker_Env.core_check)
-                } in
-              let subst_comp formals actuals comp =
-                let subst =
-                  FStar_Compiler_List.map2
-                    (fun uu___1 ->
-                       fun uu___2 ->
-                         match (uu___1, uu___2) with
-                         | ({ FStar_Syntax_Syntax.binder_bv = x;
-                              FStar_Syntax_Syntax.binder_qual = uu___3;
-                              FStar_Syntax_Syntax.binder_attrs = uu___4;_},
-                            { FStar_Syntax_Syntax.binder_bv = b;
-                              FStar_Syntax_Syntax.binder_qual = uu___5;
-                              FStar_Syntax_Syntax.binder_attrs = uu___6;_})
-                             ->
-                             let uu___7 =
-                               let uu___8 = FStar_Syntax_Syntax.bv_to_name b in
-                               (x, uu___8) in
-                             FStar_Syntax_Syntax.NT uu___7) formals actuals in
-                FStar_Syntax_Subst.subst_comp subst comp in
-              let rec arrow_formals_comp_norm norm t1 =
-                let t2 =
-                  let uu___1 = FStar_Syntax_Subst.compress t1 in
-                  FStar_Compiler_Effect.op_Less_Bar
-                    FStar_Syntax_Util.unascribe uu___1 in
-                match t2.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_arrow (formals, comp) ->
-                    FStar_Syntax_Subst.open_comp formals comp
-                | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-                    let uu___2 = FStar_Syntax_Util.unrefine t2 in
-                    arrow_formals_comp_norm norm uu___2
-                | uu___1 when Prims.op_Negation norm ->
-                    let t_norm =
-                      norm_with_steps
-                        [FStar_TypeChecker_Env.AllowUnboundUniverses;
-                        FStar_TypeChecker_Env.Beta;
-                        FStar_TypeChecker_Env.Weak;
-                        FStar_TypeChecker_Env.HNF;
-                        FStar_TypeChecker_Env.Exclude
-                          FStar_TypeChecker_Env.Zeta;
-                        FStar_TypeChecker_Env.UnfoldUntil
-                          FStar_Syntax_Syntax.delta_constant;
-                        FStar_TypeChecker_Env.EraseUniverses] tcenv t2 in
-                    arrow_formals_comp_norm true t_norm
-                | uu___1 ->
-                    let uu___2 = FStar_Syntax_Syntax.mk_Total t2 in
-                    ([], uu___2) in
-              let aux t1 e1 =
-                let uu___1 = FStar_Syntax_Util.abs_formals e1 in
-                match uu___1 with
-                | (binders, body, lopt) ->
-                    let uu___2 =
-                      match binders with
-                      | [] -> arrow_formals_comp_norm true t1
-                      | uu___3 -> arrow_formals_comp_norm false t1 in
-                    (match uu___2 with
-                     | (formals, comp) ->
-                         let nformals = FStar_Compiler_List.length formals in
-                         let nbinders = FStar_Compiler_List.length binders in
-                         let uu___3 =
-                           if nformals < nbinders
-                           then
-                             let uu___4 =
-                               FStar_Compiler_Util.first_N nformals binders in
-                             match uu___4 with
-                             | (bs0, rest) ->
-                                 let body1 =
-                                   FStar_Syntax_Util.abs rest body lopt in
-                                 let uu___5 = subst_comp formals bs0 comp in
-                                 (bs0, body1, uu___5)
-                           else
-                             if nformals > nbinders
-                             then
-                               (let uu___5 =
-                                  eta_expand binders formals body
-                                    (FStar_Syntax_Util.comp_result comp) in
-                                match uu___5 with
-                                | (binders1, body1) ->
-                                    let uu___6 =
-                                      subst_comp formals binders1 comp in
-                                    (binders1, body1, uu___6))
-                             else
-                               (let uu___6 = subst_comp formals binders comp in
-                                (binders, body, uu___6)) in
-                         (match uu___3 with
-                          | (binders1, body1, comp1) ->
-                              (binders1, body1, comp1))) in
-              let uu___1 = aux t e in
-              match uu___1 with
-              | (binders, body, comp) ->
-                  let uu___2 =
-                    let tcenv1 =
-                      FStar_TypeChecker_Env.push_binders tcenv binders in
-                    let uu___3 =
-                      FStar_SMTEncoding_Util.is_smt_reifiable_comp tcenv1
-                        comp in
-                    if uu___3
-                    then
-                      let comp1 =
-                        FStar_TypeChecker_Env.reify_comp tcenv1 comp
-                          FStar_Syntax_Syntax.U_unknown in
-                      let body1 =
-                        FStar_TypeChecker_Util.reify_body tcenv1 [] body in
-                      let uu___4 = aux comp1 body1 in
-                      match uu___4 with
-                      | (more_binders, body2, comp2) ->
-                          ((FStar_Compiler_List.op_At binders more_binders),
-                            body2, comp2)
-                    else (binders, body, comp) in
-                  (match uu___2 with
-                   | (binders1, body1, comp1) ->
-                       let uu___3 =
-                         FStar_Syntax_Util.ascribe body1
-                           ((FStar_Pervasives.Inl
-                               (FStar_Syntax_Util.comp_result comp1)),
-                             FStar_Pervasives_Native.None, false) in
-                       (binders1, uu___3, comp1)) in
-            (try
-               (fun uu___1 ->
-                  match () with
-                  | () ->
-                      let uu___2 =
-                        FStar_Compiler_Effect.op_Bar_Greater bindings
-                          (FStar_Compiler_Util.for_all
-                             (fun lb ->
-                                FStar_Syntax_Util.is_lemma
-                                  lb.FStar_Syntax_Syntax.lbtyp)) in
-                      if uu___2
-                      then encode_top_level_vals env bindings quals
-                      else
-                        (let uu___4 =
-                           FStar_Compiler_Effect.op_Bar_Greater bindings
-                             (FStar_Compiler_List.fold_left
-                                (fun uu___5 ->
-                                   fun lb ->
-                                     match uu___5 with
-                                     | (toks, typs, decls, env1) ->
-                                         ((let uu___7 =
-                                             FStar_Syntax_Util.is_lemma
-                                               lb.FStar_Syntax_Syntax.lbtyp in
-                                           if uu___7
-                                           then
-                                             FStar_Compiler_Effect.raise
-                                               Let_rec_unencodeable
-                                           else ());
-                                          (let t_norm =
-                                             norm_before_encoding env1
-                                               lb.FStar_Syntax_Syntax.lbtyp in
-                                           let uu___7 =
-                                             let uu___8 =
-                                               FStar_Compiler_Util.right
-                                                 lb.FStar_Syntax_Syntax.lbname in
-                                             declare_top_level_let env1
-                                               uu___8
-                                               lb.FStar_Syntax_Syntax.lbtyp
-                                               t_norm in
-                                           match uu___7 with
-                                           | (tok, decl, env2) ->
-                                               ((tok :: toks), (t_norm ::
-                                                 typs), (decl :: decls),
-                                                 env2)))) ([], [], [], env)) in
-                         match uu___4 with
-                         | (toks, typs, decls, env1) ->
-                             let toks_fvbs = FStar_Compiler_List.rev toks in
-                             let decls1 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 (FStar_Compiler_List.rev decls)
-                                 FStar_Compiler_List.flatten in
-                             let env_decls = copy_env env1 in
-                             let typs1 = FStar_Compiler_List.rev typs in
-                             let encode_non_rec_lbdef bindings1 typs2 toks1
-                               env2 =
-                               match (bindings1, typs2, toks1) with
-                               | ({ FStar_Syntax_Syntax.lbname = lbn;
-                                    FStar_Syntax_Syntax.lbunivs = uvs;
-                                    FStar_Syntax_Syntax.lbtyp = uu___5;
-                                    FStar_Syntax_Syntax.lbeff = uu___6;
-                                    FStar_Syntax_Syntax.lbdef = e;
-                                    FStar_Syntax_Syntax.lbattrs = uu___7;
-                                    FStar_Syntax_Syntax.lbpos = uu___8;_}::[],
-                                  t_norm::[], fvb::[]) ->
-                                   let flid =
-                                     fvb.FStar_SMTEncoding_Env.fvar_lid in
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_TypeChecker_Env.open_universes_in
-                                         env2.FStar_SMTEncoding_Env.tcenv uvs
-                                         [e; t_norm] in
-                                     match uu___10 with
-                                     | (tcenv', uu___11, e_t) ->
-                                         let uu___12 =
-                                           match e_t with
-                                           | e1::t_norm1::[] -> (e1, t_norm1)
-                                           | uu___13 -> failwith "Impossible" in
-                                         (match uu___12 with
-                                          | (e1, t_norm1) ->
-                                              ({
-                                                 FStar_SMTEncoding_Env.bvar_bindings
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.bvar_bindings);
-                                                 FStar_SMTEncoding_Env.fvar_bindings
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.fvar_bindings);
-                                                 FStar_SMTEncoding_Env.depth
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.depth);
-                                                 FStar_SMTEncoding_Env.tcenv
-                                                   = tcenv';
-                                                 FStar_SMTEncoding_Env.warn =
-                                                   (env2.FStar_SMTEncoding_Env.warn);
-                                                 FStar_SMTEncoding_Env.nolabels
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.nolabels);
-                                                 FStar_SMTEncoding_Env.use_zfuel_name
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.use_zfuel_name);
-                                                 FStar_SMTEncoding_Env.encode_non_total_function_typ
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-                                                 FStar_SMTEncoding_Env.current_module_name
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.current_module_name);
-                                                 FStar_SMTEncoding_Env.encoding_quantifier
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.encoding_quantifier);
-                                                 FStar_SMTEncoding_Env.global_cache
-                                                   =
-                                                   (env2.FStar_SMTEncoding_Env.global_cache)
-                                               }, e1, t_norm1)) in
-                                   (match uu___9 with
-                                    | (env', e1, t_norm1) ->
-                                        let uu___10 =
-                                          destruct_bound_function t_norm1 e1 in
-                                        (match uu___10 with
-                                         | (binders, body, t_body_comp) ->
-                                             let t_body =
-                                               FStar_Syntax_Util.comp_result
-                                                 t_body_comp in
-                                             ((let uu___12 =
-                                                 FStar_Compiler_Effect.op_Less_Bar
-                                                   (FStar_TypeChecker_Env.debug
-                                                      env2.FStar_SMTEncoding_Env.tcenv)
-                                                   (FStar_Options.Other
-                                                      "SMTEncoding") in
-                                               if uu___12
-                                               then
-                                                 let uu___13 =
-                                                   FStar_Syntax_Print.binders_to_string
-                                                     ", " binders in
-                                                 let uu___14 =
-                                                   FStar_Syntax_Print.term_to_string
-                                                     body in
-                                                 FStar_Compiler_Util.print2
-                                                   "Encoding let : binders=[%s], body=%s\n"
-                                                   uu___13 uu___14
-                                               else ());
-                                              (let uu___12 =
-                                                 FStar_SMTEncoding_EncodeTerm.encode_binders
-                                                   FStar_Pervasives_Native.None
-                                                   binders env' in
-                                               match uu___12 with
-                                               | (vars, _guards, env'1,
-                                                  binder_decls, uu___13) ->
-                                                   let uu___14 =
-                                                     if
-                                                       fvb.FStar_SMTEncoding_Env.fvb_thunked
-                                                         && (vars = [])
-                                                     then
-                                                       let dummy_var =
-                                                         FStar_SMTEncoding_Term.mk_fv
-                                                           ("@dummy",
-                                                             FStar_SMTEncoding_Term.dummy_sort) in
-                                                       let dummy_tm =
-                                                         FStar_SMTEncoding_Term.mkFreeV
-                                                           dummy_var
-                                                           FStar_Compiler_Range.dummyRange in
-                                                       let app =
-                                                         let uu___15 =
-                                                           FStar_Syntax_Util.range_of_lbname
-                                                             lbn in
-                                                         FStar_SMTEncoding_Term.mkApp
-                                                           ((fvb.FStar_SMTEncoding_Env.smt_id),
-                                                             [dummy_tm])
-                                                           uu___15 in
-                                                       ([dummy_var], app)
-                                                     else
-                                                       (let uu___16 =
-                                                          let uu___17 =
-                                                            FStar_Syntax_Util.range_of_lbname
-                                                              lbn in
-                                                          let uu___18 =
-                                                            FStar_Compiler_List.map
-                                                              FStar_SMTEncoding_Util.mkFreeV
-                                                              vars in
-                                                          FStar_SMTEncoding_EncodeTerm.maybe_curry_fvb
-                                                            uu___17 fvb
-                                                            uu___18 in
-                                                        (vars, uu___16)) in
-                                                   (match uu___14 with
-                                                    | (vars1, app) ->
-                                                        let is_logical =
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              FStar_Syntax_Subst.compress
-                                                                t_body in
-                                                            uu___16.FStar_Syntax_Syntax.n in
-                                                          match uu___15 with
-                                                          | FStar_Syntax_Syntax.Tm_fvar
-                                                              fv when
-                                                              FStar_Syntax_Syntax.fv_eq_lid
-                                                                fv
-                                                                FStar_Parser_Const.logical_lid
-                                                              -> true
-                                                          | uu___16 -> false in
-                                                        let is_smt_theory_symbol
-                                                          =
-                                                          let fv =
-                                                            FStar_Compiler_Util.right
-                                                              lbn in
-                                                          FStar_TypeChecker_Env.fv_has_attr
-                                                            env2.FStar_SMTEncoding_Env.tcenv
-                                                            fv
-                                                            FStar_Parser_Const.smt_theory_symbol_attr_lid in
-                                                        let should_encode_logical
-                                                          =
-                                                          (Prims.op_Negation
-                                                             is_smt_theory_symbol)
-                                                            &&
-                                                            ((FStar_Compiler_Effect.op_Bar_Greater
-                                                                quals
-                                                                (FStar_Compiler_List.contains
-                                                                   FStar_Syntax_Syntax.Logic))
-                                                               || is_logical) in
-                                                        let make_eqn name pat
-                                                          app1 body1 =
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              let uu___17 =
-                                                                FStar_Syntax_Util.range_of_lbname
-                                                                  lbn in
-                                                              let uu___18 =
-                                                                let uu___19 =
-                                                                  FStar_SMTEncoding_Util.mkEq
-                                                                    (app1,
-                                                                    body1) in
-                                                                ([[pat]],
-                                                                  vars1,
-                                                                  uu___19) in
-                                                              FStar_SMTEncoding_Term.mkForall
-                                                                uu___17
-                                                                uu___18 in
-                                                            let uu___17 =
-                                                              let uu___18 =
-                                                                let uu___19 =
-                                                                  FStar_Ident.string_of_lid
-                                                                    flid in
-                                                                FStar_Compiler_Util.format1
-                                                                  "Equation for %s"
-                                                                  uu___19 in
-                                                              FStar_Pervasives_Native.Some
-                                                                uu___18 in
-                                                            (uu___16,
-                                                              uu___17,
-                                                              (Prims.op_Hat
-                                                                 name
-                                                                 (Prims.op_Hat
-                                                                    "_"
-                                                                    fvb.FStar_SMTEncoding_Env.smt_id))) in
-                                                          FStar_SMTEncoding_Util.mkAssume
-                                                            uu___15 in
-                                                        let uu___15 =
-                                                          let basic_eqn_name
-                                                            =
-                                                            if
-                                                              should_encode_logical
-                                                            then
-                                                              "defn_equation"
-                                                            else "equation" in
-                                                          let uu___16 =
-                                                            let uu___17 =
-                                                              FStar_SMTEncoding_EncodeTerm.encode_term
-                                                                body env'1 in
-                                                            match uu___17
-                                                            with
-                                                            | (body1, decls2)
-                                                                ->
-                                                                let pat =
-                                                                  if
-                                                                    should_encode_logical
-                                                                  then
-                                                                    FStar_SMTEncoding_Term.mk_subtype_of_unit
-                                                                    app
-                                                                  else app in
-                                                                let uu___18 =
-                                                                  make_eqn
-                                                                    basic_eqn_name
-                                                                    pat app
-                                                                    body1 in
-                                                                (uu___18,
-                                                                  decls2) in
-                                                          match uu___16 with
-                                                          | (basic_eqn,
-                                                             decls2) ->
-                                                              if
-                                                                should_encode_logical
-                                                              then
-                                                                let uu___17 =
-                                                                  let uu___18
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_Valid
-                                                                    app in
-                                                                  let uu___19
-                                                                    =
-                                                                    FStar_SMTEncoding_EncodeTerm.encode_formula
-                                                                    body
-                                                                    env'1 in
-                                                                  (app,
-                                                                    uu___18,
-                                                                    uu___19) in
-                                                                (match uu___17
-                                                                 with
-                                                                 | (pat,
-                                                                    app1,
-                                                                    (body1,
-                                                                    decls21))
-                                                                    ->
-                                                                    let logical_eqn
-                                                                    =
-                                                                    make_eqn
-                                                                    "equation"
-                                                                    pat app1
-                                                                    body1 in
-                                                                    ([logical_eqn;
-                                                                    basic_eqn],
-                                                                    (FStar_Compiler_List.op_At
-                                                                    decls2
-                                                                    decls21)))
-                                                              else
-                                                                ([basic_eqn],
-                                                                  decls2) in
-                                                        (match uu___15 with
-                                                         | (eqns, decls2) ->
-                                                             let uu___16 =
-                                                               let uu___17 =
-                                                                 let uu___18
-                                                                   =
-                                                                   let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    primitive_type_axioms
-                                                                    env2.FStar_SMTEncoding_Env.tcenv
-                                                                    flid
-                                                                    fvb.FStar_SMTEncoding_Env.smt_id
-                                                                    app in
-                                                                    FStar_Compiler_List.op_At
-                                                                    eqns
-                                                                    uu___21 in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___20
-                                                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                                   FStar_Compiler_List.op_At
-                                                                    decls2
-                                                                    uu___19 in
-                                                                 FStar_Compiler_List.op_At
-                                                                   binder_decls
-                                                                   uu___18 in
-                                                               FStar_Compiler_List.op_At
-                                                                 decls1
-                                                                 uu___17 in
-                                                             (uu___16, env2)))))))
-                               | uu___5 -> failwith "Impossible" in
-                             let encode_rec_lbdefs bindings1 typs2 toks1 env2
-                               =
-                               let fuel =
-                                 let uu___5 =
-                                   let uu___6 =
-                                     FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.fresh
-                                       env2.FStar_SMTEncoding_Env.current_module_name
-                                       "fuel" in
-                                   (uu___6, FStar_SMTEncoding_Term.Fuel_sort) in
-                                 FStar_SMTEncoding_Term.mk_fv uu___5 in
-                               let fuel_tm =
-                                 FStar_SMTEncoding_Util.mkFreeV fuel in
-                               let env0 = env2 in
-                               let uu___5 =
-                                 FStar_Compiler_Effect.op_Bar_Greater toks1
-                                   (FStar_Compiler_List.fold_left
-                                      (fun uu___6 ->
-                                         fun fvb ->
-                                           match uu___6 with
-                                           | (gtoks, env3) ->
-                                               let flid =
-                                                 fvb.FStar_SMTEncoding_Env.fvar_lid in
-                                               let g =
-                                                 let uu___7 =
-                                                   FStar_Ident.lid_add_suffix
-                                                     flid "fuel_instrumented" in
-                                                 FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.new_fvar
-                                                   uu___7 in
-                                               let gtok =
-                                                 let uu___7 =
-                                                   FStar_Ident.lid_add_suffix
-                                                     flid
-                                                     "fuel_instrumented_token" in
-                                                 FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.new_fvar
-                                                   uu___7 in
-                                               let env4 =
-                                                 let uu___7 =
-                                                   let uu___8 =
-                                                     FStar_SMTEncoding_Util.mkApp
-                                                       (g, [fuel_tm]) in
-                                                   FStar_Compiler_Effect.op_Less_Bar
-                                                     (fun uu___9 ->
-                                                        FStar_Pervasives_Native.Some
-                                                          uu___9) uu___8 in
-                                                 FStar_SMTEncoding_Env.push_free_var
-                                                   env3 flid
-                                                   fvb.FStar_SMTEncoding_Env.smt_arity
-                                                   gtok uu___7 in
-                                               (((fvb, g, gtok) :: gtoks),
-                                                 env4)) ([], env2)) in
-                               match uu___5 with
-                               | (gtoks, env3) ->
-                                   let gtoks1 = FStar_Compiler_List.rev gtoks in
-                                   let encode_one_binding env01 uu___6 t_norm
-                                     uu___7 =
-                                     match (uu___6, uu___7) with
-                                     | ((fvb, g, gtok),
-                                        { FStar_Syntax_Syntax.lbname = lbn;
-                                          FStar_Syntax_Syntax.lbunivs = uvs;
-                                          FStar_Syntax_Syntax.lbtyp = uu___8;
-                                          FStar_Syntax_Syntax.lbeff = uu___9;
-                                          FStar_Syntax_Syntax.lbdef = e;
-                                          FStar_Syntax_Syntax.lbattrs =
-                                            uu___10;
-                                          FStar_Syntax_Syntax.lbpos = uu___11;_})
-                                         ->
-                                         let uu___12 =
-                                           let uu___13 =
-                                             FStar_TypeChecker_Env.open_universes_in
-                                               env3.FStar_SMTEncoding_Env.tcenv
-                                               uvs [e; t_norm] in
-                                           match uu___13 with
-                                           | (tcenv', uu___14, e_t) ->
-                                               let uu___15 =
-                                                 match e_t with
-                                                 | e1::t_norm1::[] ->
-                                                     (e1, t_norm1)
-                                                 | uu___16 ->
-                                                     failwith "Impossible" in
-                                               (match uu___15 with
-                                                | (e1, t_norm1) ->
-                                                    ({
-                                                       FStar_SMTEncoding_Env.bvar_bindings
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.bvar_bindings);
-                                                       FStar_SMTEncoding_Env.fvar_bindings
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.fvar_bindings);
-                                                       FStar_SMTEncoding_Env.depth
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.depth);
-                                                       FStar_SMTEncoding_Env.tcenv
-                                                         = tcenv';
-                                                       FStar_SMTEncoding_Env.warn
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.warn);
-                                                       FStar_SMTEncoding_Env.nolabels
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.nolabels);
-                                                       FStar_SMTEncoding_Env.use_zfuel_name
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.use_zfuel_name);
-                                                       FStar_SMTEncoding_Env.encode_non_total_function_typ
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-                                                       FStar_SMTEncoding_Env.current_module_name
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.current_module_name);
-                                                       FStar_SMTEncoding_Env.encoding_quantifier
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.encoding_quantifier);
-                                                       FStar_SMTEncoding_Env.global_cache
-                                                         =
-                                                         (env3.FStar_SMTEncoding_Env.global_cache)
-                                                     }, e1, t_norm1)) in
-                                         (match uu___12 with
-                                          | (env', e1, t_norm1) ->
-                                              ((let uu___14 =
-                                                  FStar_Compiler_Effect.op_Less_Bar
-                                                    (FStar_TypeChecker_Env.debug
-                                                       env01.FStar_SMTEncoding_Env.tcenv)
-                                                    (FStar_Options.Other
-                                                       "SMTEncoding") in
-                                                if uu___14
-                                                then
-                                                  let uu___15 =
-                                                    FStar_Syntax_Print.lbname_to_string
-                                                      lbn in
-                                                  let uu___16 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      t_norm1 in
-                                                  let uu___17 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      e1 in
-                                                  FStar_Compiler_Util.print3
-                                                    "Encoding let rec %s : %s = %s\n"
-                                                    uu___15 uu___16 uu___17
-                                                else ());
-                                               (let uu___14 =
-                                                  destruct_bound_function
-                                                    t_norm1 e1 in
-                                                match uu___14 with
-                                                | (binders, body, tres_comp)
-                                                    ->
-                                                    let curry =
-                                                      fvb.FStar_SMTEncoding_Env.smt_arity
-                                                        <>
-                                                        (FStar_Compiler_List.length
-                                                           binders) in
-                                                    let uu___15 =
-                                                      FStar_TypeChecker_Util.pure_or_ghost_pre_and_post
-                                                        env3.FStar_SMTEncoding_Env.tcenv
-                                                        tres_comp in
-                                                    (match uu___15 with
-                                                     | (pre_opt, tres) ->
-                                                         ((let uu___17 =
-                                                             FStar_Compiler_Effect.op_Less_Bar
-                                                               (FStar_TypeChecker_Env.debug
-                                                                  env01.FStar_SMTEncoding_Env.tcenv)
-                                                               (FStar_Options.Other
-                                                                  "SMTEncodingReify") in
-                                                           if uu___17
-                                                           then
-                                                             let uu___18 =
-                                                               FStar_Syntax_Print.lbname_to_string
-                                                                 lbn in
-                                                             let uu___19 =
-                                                               FStar_Syntax_Print.binders_to_string
-                                                                 ", " binders in
-                                                             let uu___20 =
-                                                               FStar_Syntax_Print.term_to_string
-                                                                 body in
-                                                             let uu___21 =
-                                                               FStar_Syntax_Print.comp_to_string
-                                                                 tres_comp in
-                                                             FStar_Compiler_Util.print4
-                                                               "Encoding let rec %s: \n\tbinders=[%s], \n\tbody=%s, \n\ttres=%s\n"
-                                                               uu___18
-                                                               uu___19
-                                                               uu___20
-                                                               uu___21
-                                                           else ());
-                                                          (let uu___17 =
-                                                             FStar_SMTEncoding_EncodeTerm.encode_binders
-                                                               FStar_Pervasives_Native.None
-                                                               binders env' in
-                                                           match uu___17 with
-                                                           | (vars, guards,
-                                                              env'1,
-                                                              binder_decls,
-                                                              uu___18) ->
-                                                               let uu___19 =
-                                                                 match pre_opt
-                                                                 with
-                                                                 | FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    guards in
-                                                                    (uu___20,
-                                                                    [])
-                                                                 | FStar_Pervasives_Native.Some
-                                                                    pre ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_SMTEncoding_EncodeTerm.encode_formula
-                                                                    pre env'1 in
-                                                                    (match uu___20
-                                                                    with
-                                                                    | 
-                                                                    (guard,
-                                                                    decls0)
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    (FStar_Compiler_List.op_At
-                                                                    guards
-                                                                    [guard]) in
-                                                                    (uu___21,
-                                                                    decls0)) in
-                                                               (match uu___19
-                                                                with
-                                                                | (guard,
-                                                                   guard_decls)
-                                                                    ->
-                                                                    let binder_decls1
-                                                                    =
-                                                                    FStar_Compiler_List.op_At
-                                                                    binder_decls
-                                                                    guard_decls in
-                                                                    let decl_g
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Compiler_Util.first_N
-                                                                    fvb.FStar_SMTEncoding_Env.smt_arity
-                                                                    vars in
-                                                                    FStar_Pervasives_Native.fst
-                                                                    uu___24 in
-                                                                    FStar_Compiler_List.map
-                                                                    FStar_SMTEncoding_Term.fv_sort
-                                                                    uu___23 in
-                                                                    FStar_SMTEncoding_Term.Fuel_sort
-                                                                    ::
-                                                                    uu___22 in
-                                                                    (g,
-                                                                    uu___21,
-                                                                    FStar_SMTEncoding_Term.Term_sort,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "Fuel-instrumented function name")) in
-                                                                    FStar_SMTEncoding_Term.DeclFun
-                                                                    uu___20 in
-                                                                    let decl_g_tok
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.DeclFun
-                                                                    (gtok,
-                                                                    [],
-                                                                    FStar_SMTEncoding_Term.Term_sort,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "Token for fuel-instrumented partial applications")) in
-                                                                    let env02
-                                                                    =
-                                                                    FStar_SMTEncoding_Env.push_zfuel_name
-                                                                    env01
-                                                                    fvb.FStar_SMTEncoding_Env.fvar_lid
-                                                                    g gtok in
-                                                                    let vars_tm
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    vars in
-                                                                    let rng =
-                                                                    FStar_Syntax_Util.range_of_lbname
-                                                                    lbn in
-                                                                    let app =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    vars in
-                                                                    FStar_SMTEncoding_EncodeTerm.maybe_curry_fvb
-                                                                    rng fvb
-                                                                    uu___20 in
-                                                                    let mk_g_app
-                                                                    args =
-                                                                    FStar_SMTEncoding_EncodeTerm.maybe_curry_app
-                                                                    rng
-                                                                    (FStar_Pervasives.Inl
-                                                                    (FStar_SMTEncoding_Term.Var
-                                                                    g))
-                                                                    (fvb.FStar_SMTEncoding_Env.smt_arity
-                                                                    +
-                                                                    Prims.int_one)
-                                                                    args in
-                                                                    let gsapp
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkApp
-                                                                    ("SFuel",
-                                                                    [fuel_tm]) in
-                                                                    uu___21
-                                                                    ::
-                                                                    vars_tm in
-                                                                    mk_g_app
-                                                                    uu___20 in
-                                                                    let gmax
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkApp
-                                                                    ("MaxFuel",
-                                                                    []) in
-                                                                    uu___21
-                                                                    ::
-                                                                    vars_tm in
-                                                                    mk_g_app
-                                                                    uu___20 in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_SMTEncoding_EncodeTerm.encode_term
-                                                                    body
-                                                                    env'1 in
-                                                                    (match uu___20
-                                                                    with
-                                                                    | 
-                                                                    (body_tm,
-                                                                    decls2)
-                                                                    ->
-                                                                    let eqn_g
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Util.range_of_lbname
-                                                                    lbn in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (gsapp,
-                                                                    body_tm) in
-                                                                    (guard,
-                                                                    uu___27) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___26 in
-                                                                    ([
-                                                                    [gsapp]],
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    Prims.int_zero),
-                                                                    (fuel ::
-                                                                    vars),
-                                                                    uu___25) in
-                                                                    FStar_SMTEncoding_Term.mkForall'
-                                                                    uu___23
-                                                                    uu___24 in
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    fvb.FStar_SMTEncoding_Env.fvar_lid in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "Equation for fuel-instrumented recursive function: %s"
-                                                                    uu___25 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24 in
-                                                                    (uu___22,
-                                                                    uu___23,
-                                                                    (Prims.op_Hat
-                                                                    "equation_with_fuel_"
-                                                                    g)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___21 in
-                                                                    let eqn_f
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Util.range_of_lbname
-                                                                    lbn in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (app,
-                                                                    gmax) in
-                                                                    ([[app]],
-                                                                    vars,
-                                                                    uu___25) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___23
-                                                                    uu___24 in
-                                                                    (uu___22,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "Correspondence of recursive function to instrumented version"),
-                                                                    (Prims.op_Hat
-                                                                    "@fuel_correspondence_"
-                                                                    g)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___21 in
-                                                                    let eqn_g'
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Util.range_of_lbname
-                                                                    lbn in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.n_fuel
-                                                                    Prims.int_zero in
-                                                                    uu___29
-                                                                    ::
-                                                                    vars_tm in
-                                                                    mk_g_app
-                                                                    uu___28 in
-                                                                    (gsapp,
-                                                                    uu___27) in
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    uu___26 in
-                                                                    ([
-                                                                    [gsapp]],
-                                                                    (fuel ::
-                                                                    vars),
-                                                                    uu___25) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___23
-                                                                    uu___24 in
-                                                                    (uu___22,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "Fuel irrelevance"),
-                                                                    (Prims.op_Hat
-                                                                    "@fuel_irrelevance_"
-                                                                    g)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___21 in
-                                                                    let uu___21
-                                                                    =
-                                                                    let gapp
-                                                                    =
-                                                                    mk_g_app
-                                                                    (fuel_tm
-                                                                    ::
-                                                                    vars_tm) in
-                                                                    let tok_corr
-                                                                    =
-                                                                    let tok_app
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (gtok,
-                                                                    FStar_SMTEncoding_Term.Term_sort) in
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    uu___23 in
-                                                                    FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                                                    uu___22
-                                                                    (fuel ::
-                                                                    vars) in
-                                                                    let tot_fun_axioms
-                                                                    =
-                                                                    let head
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (gtok,
-                                                                    FStar_SMTEncoding_Term.Term_sort) in
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    uu___22 in
-                                                                    let vars1
-                                                                    = fuel ::
-                                                                    vars in
-                                                                    let guards1
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___22
-                                                                    ->
-                                                                    FStar_SMTEncoding_Util.mkTrue)
-                                                                    vars1 in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Util.is_pure_comp
-                                                                    tres_comp in
-                                                                    FStar_SMTEncoding_EncodeTerm.isTotFun_axioms
-                                                                    rng head
-                                                                    vars1
-                                                                    guards1
-                                                                    uu___22 in
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Util.range_of_lbname
-                                                                    lbn in
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (tok_app,
-                                                                    gapp) in
-                                                                    ([
-                                                                    [tok_app]],
-                                                                    (fuel ::
-                                                                    vars),
-                                                                    uu___28) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___26
-                                                                    uu___27 in
-                                                                    (uu___25,
-                                                                    tot_fun_axioms) in
-                                                                    FStar_SMTEncoding_Util.mkAnd
-                                                                    uu___24 in
-                                                                    (uu___23,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "Fuel token correspondence"),
-                                                                    (Prims.op_Hat
-                                                                    "fuel_token_correspondence_"
-                                                                    gtok)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___22 in
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_SMTEncoding_EncodeTerm.encode_term_pred
-                                                                    FStar_Pervasives_Native.None
-                                                                    tres
-                                                                    env'1
-                                                                    gapp in
-                                                                    match uu___23
-                                                                    with
-                                                                    | 
-                                                                    (g_typing,
-                                                                    d3) ->
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Util.range_of_lbname
-                                                                    lbn in
-                                                                    let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    (guard,
-                                                                    g_typing) in
-                                                                    ([[gapp]],
-                                                                    (fuel ::
-                                                                    vars),
-                                                                    uu___30) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___28
-                                                                    uu___29 in
-                                                                    (uu___27,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "Typing correspondence of token to term"),
-                                                                    (Prims.op_Hat
-                                                                    "token_correspondence_"
-                                                                    g)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___26 in
-                                                                    [uu___25] in
-                                                                    (d3,
-                                                                    uu___24) in
-                                                                    match uu___22
-                                                                    with
-                                                                    | 
-                                                                    (aux_decls,
-                                                                    typing_corr)
-                                                                    ->
-                                                                    (aux_decls,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    typing_corr
-                                                                    [tok_corr])) in
-                                                                    (match uu___21
-                                                                    with
-                                                                    | 
-                                                                    (aux_decls,
-                                                                    g_typing)
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    [decl_g;
-                                                                    decl_g_tok]
-                                                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                                    FStar_Compiler_List.op_At
-                                                                    aux_decls
-                                                                    uu___25 in
-                                                                    FStar_Compiler_List.op_At
-                                                                    decls2
-                                                                    uu___24 in
-                                                                    FStar_Compiler_List.op_At
-                                                                    binder_decls1
-                                                                    uu___23 in
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Compiler_List.op_At
-                                                                    [eqn_g;
-                                                                    eqn_g';
-                                                                    eqn_f]
-                                                                    g_typing)
-                                                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                                    (uu___22,
-                                                                    uu___23,
-                                                                    env02)))))))))) in
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_Compiler_List.zip3 gtoks1 typs2
-                                         bindings1 in
-                                     FStar_Compiler_List.fold_left
-                                       (fun uu___8 ->
-                                          fun uu___9 ->
-                                            match (uu___8, uu___9) with
-                                            | ((decls2, eqns, env01),
-                                               (gtok, ty, lb)) ->
-                                                let uu___10 =
-                                                  encode_one_binding env01
-                                                    gtok ty lb in
-                                                (match uu___10 with
-                                                 | (decls', eqns', env02) ->
-                                                     ((decls' :: decls2),
-                                                       (FStar_Compiler_List.op_At
-                                                          eqns' eqns), env02)))
-                                       ([decls1], [], env0) uu___7 in
-                                   (match uu___6 with
-                                    | (decls2, eqns, env01) ->
-                                        let uu___7 =
-                                          let isDeclFun uu___8 =
-                                            match uu___8 with
-                                            | FStar_SMTEncoding_Term.DeclFun
-                                                uu___9 -> true
-                                            | uu___9 -> false in
-                                          let uu___8 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              decls2
-                                              FStar_Compiler_List.flatten in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___8
-                                            (fun decls3 ->
-                                               let uu___9 =
-                                                 FStar_Compiler_List.fold_left
-                                                   (fun uu___10 ->
-                                                      fun elt ->
-                                                        match uu___10 with
-                                                        | (prefix_decls,
-                                                           elts, rest) ->
-                                                            let uu___11 =
-                                                              (FStar_Compiler_Effect.op_Bar_Greater
-                                                                 elt.FStar_SMTEncoding_Term.key
-                                                                 FStar_Compiler_Util.is_some)
-                                                                &&
-                                                                (FStar_Compiler_List.existsb
-                                                                   isDeclFun
-                                                                   elt.FStar_SMTEncoding_Term.decls) in
-                                                            if uu___11
-                                                            then
-                                                              (prefix_decls,
-                                                                (FStar_Compiler_List.op_At
-                                                                   elts 
-                                                                   [elt]),
-                                                                rest)
-                                                            else
-                                                              (let uu___13 =
-                                                                 FStar_Compiler_List.partition
-                                                                   isDeclFun
-                                                                   elt.FStar_SMTEncoding_Term.decls in
-                                                               match uu___13
-                                                               with
-                                                               | (elt_decl_funs,
-                                                                  elt_rest)
-                                                                   ->
-                                                                   ((FStar_Compiler_List.op_At
-                                                                    prefix_decls
-                                                                    elt_decl_funs),
-                                                                    elts,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    rest
-                                                                    [
-                                                                    {
-                                                                    FStar_SMTEncoding_Term.sym_name
-                                                                    =
-                                                                    (elt.FStar_SMTEncoding_Term.sym_name);
-                                                                    FStar_SMTEncoding_Term.key
-                                                                    =
-                                                                    (elt.FStar_SMTEncoding_Term.key);
-                                                                    FStar_SMTEncoding_Term.decls
-                                                                    =
-                                                                    elt_rest;
-                                                                    FStar_SMTEncoding_Term.a_names
-                                                                    =
-                                                                    (elt.FStar_SMTEncoding_Term.a_names)
-                                                                    }]))))
-                                                   ([], [], []) decls3 in
-                                               match uu___9 with
-                                               | (prefix_decls, elts, rest)
-                                                   ->
-                                                   let uu___10 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       prefix_decls
-                                                       FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                   (uu___10, elts, rest)) in
-                                        (match uu___7 with
-                                         | (prefix_decls, elts, rest) ->
-                                             let eqns1 =
-                                               FStar_Compiler_List.rev eqns in
-                                             ((FStar_Compiler_List.op_At
-                                                 prefix_decls
-                                                 (FStar_Compiler_List.op_At
-                                                    elts
-                                                    (FStar_Compiler_List.op_At
-                                                       rest eqns1))), env01))) in
-                             let uu___5 =
-                               (FStar_Compiler_Effect.op_Bar_Greater quals
-                                  (FStar_Compiler_Util.for_some
-                                     (fun uu___6 ->
-                                        match uu___6 with
-                                        | FStar_Syntax_Syntax.HasMaskedEffect
-                                            -> true
-                                        | uu___7 -> false)))
-                                 ||
-                                 (FStar_Compiler_Effect.op_Bar_Greater typs1
-                                    (FStar_Compiler_Util.for_some
-                                       (fun t ->
-                                          let uu___6 =
-                                            (FStar_Syntax_Util.is_pure_or_ghost_function
-                                               t)
-                                              ||
-                                              (FStar_SMTEncoding_Util.is_smt_reifiable_function
-                                                 env1.FStar_SMTEncoding_Env.tcenv
-                                                 t) in
-                                          FStar_Compiler_Effect.op_Less_Bar
-                                            Prims.op_Negation uu___6))) in
-                             if uu___5
-                             then (decls1, env_decls)
-                             else
-                               (try
-                                  (fun uu___7 ->
-                                     match () with
-                                     | () ->
-                                         if Prims.op_Negation is_rec
-                                         then
-                                           encode_non_rec_lbdef bindings
-                                             typs1 toks_fvbs env1
-                                         else
-                                           encode_rec_lbdefs bindings typs1
-                                             toks_fvbs env1) ()
-                                with
-                                | FStar_SMTEncoding_Env.Inner_let_rec names
-                                    ->
-                                    let plural =
-                                      (FStar_Compiler_List.length names) >
-                                        Prims.int_one in
-                                    let r =
-                                      let uu___8 =
-                                        FStar_Compiler_List.hd names in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___8 FStar_Pervasives_Native.snd in
-                                    ((let uu___9 =
-                                        let uu___10 =
-                                          let uu___11 =
-                                            let uu___12 =
-                                              let uu___13 =
-                                                FStar_Compiler_List.map
-                                                  FStar_Pervasives_Native.fst
-                                                  names in
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                uu___13
-                                                (FStar_String.concat ",") in
-                                            FStar_Compiler_Util.format3
-                                              "Definitions of inner let-rec%s %s and %s enclosing top-level letbinding are not encoded to the solver, you will only be able to reason with their types"
-                                              (if plural then "s" else "")
-                                              uu___12
-                                              (if plural
-                                               then "their"
-                                               else "its") in
-                                          let uu___12 =
-                                            FStar_Errors.get_ctx () in
-                                          (FStar_Errors.Warning_DefinitionNotTranslated,
-                                            uu___11, r, uu___12) in
-                                        [uu___10] in
-                                      FStar_TypeChecker_Err.add_errors
-                                        env1.FStar_SMTEncoding_Env.tcenv
-                                        uu___9);
-                                     (decls1, env_decls))))) ()
-             with
-             | Let_rec_unencodeable ->
-                 let msg =
-                   let uu___2 =
-                     FStar_Compiler_Effect.op_Bar_Greater bindings
-                       (FStar_Compiler_List.map
-                          (fun lb ->
-                             FStar_Syntax_Print.lbname_to_string
-                               lb.FStar_Syntax_Syntax.lbname)) in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___2
-                     (FStar_String.concat " and ") in
-                 let decl =
-                   FStar_SMTEncoding_Term.Caption
-                     (Prims.op_Hat "let rec unencodeable: Skipping: " msg) in
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater [decl]
-                     FStar_SMTEncoding_Term.mk_decls_trivial in
-                 (uu___2, env))
-let rec (encode_sigelt :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun se ->
-      let nm =
-        let uu___ = FStar_Syntax_Util.lid_of_sigelt se in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> ""
-        | FStar_Pervasives_Native.Some l -> FStar_Ident.string_of_lid l in
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Print.sigelt_to_string_short se in
-          FStar_Compiler_Util.format1
-            "While encoding top-level declaration `%s`" uu___2 in
-        FStar_Errors.with_ctx uu___1 (fun uu___2 -> encode_sigelt' env se) in
-      match uu___ with
-      | (g, env1) ->
-          let g1 =
-            match g with
-            | [] ->
-                ((let uu___2 =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_TypeChecker_Env.debug
-                         env1.FStar_SMTEncoding_Env.tcenv)
-                      (FStar_Options.Other "SMTEncoding") in
-                  if uu___2
-                  then
-                    FStar_Compiler_Util.print1 "Skipped encoding of %s\n" nm
-                  else ());
-                 (let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_Util.format1 "<Skipped %s/>" nm in
-                      FStar_SMTEncoding_Term.Caption uu___4 in
-                    [uu___3] in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___2
-                    FStar_SMTEncoding_Term.mk_decls_trivial))
-            | uu___1 ->
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_Compiler_Util.format1 "<Start encoding %s>" nm in
-                      FStar_SMTEncoding_Term.Caption uu___5 in
-                    [uu___4] in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___3
-                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          FStar_Compiler_Util.format1 "</end encoding %s>" nm in
-                        FStar_SMTEncoding_Term.Caption uu___7 in
-                      [uu___6] in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___5
-                      FStar_SMTEncoding_Term.mk_decls_trivial in
-                  FStar_Compiler_List.op_At g uu___4 in
-                FStar_Compiler_List.op_At uu___2 uu___3 in
-          (g1, env1)
-and (encode_sigelt' :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun se ->
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Less_Bar
-           (FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv)
-           (FStar_Options.Other "SMTEncoding") in
-       if uu___1
-       then
-         let uu___2 = FStar_Syntax_Print.sigelt_to_string se in
-         FStar_Compiler_Util.print1 "@@@Encoding sigelt %s\n" uu___2
-       else ());
-      (let is_opaque_to_smt t =
-         let uu___1 =
-           let uu___2 = FStar_Syntax_Subst.compress t in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_string
-             (s, uu___2)) -> s = "opaque_to_smt"
-         | uu___2 -> false in
-       let is_uninterpreted_by_smt t =
-         let uu___1 =
-           let uu___2 = FStar_Syntax_Subst.compress t in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_string
-             (s, uu___2)) -> s = "uninterpreted_by_smt"
-         | uu___2 -> false in
-       match se.FStar_Syntax_Syntax.sigel with
-       | FStar_Syntax_Syntax.Sig_splice uu___1 ->
-           failwith "impossible -- splice should have been removed by Tc.fs"
-       | FStar_Syntax_Syntax.Sig_fail uu___1 ->
-           failwith
-             "impossible -- Sig_fail should have been removed by Tc.fs"
-       | FStar_Syntax_Syntax.Sig_pragma uu___1 -> ([], env)
-       | FStar_Syntax_Syntax.Sig_effect_abbrev uu___1 -> ([], env)
-       | FStar_Syntax_Syntax.Sig_sub_effect uu___1 -> ([], env)
-       | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___1 -> ([], env)
-       | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___1 -> ([], env)
-       | FStar_Syntax_Syntax.Sig_new_effect ed ->
-           let uu___1 =
-             let uu___2 =
-               FStar_SMTEncoding_Util.is_smt_reifiable_effect
-                 env.FStar_SMTEncoding_Env.tcenv ed.FStar_Syntax_Syntax.mname in
-             Prims.op_Negation uu___2 in
-           if uu___1
-           then ([], env)
-           else
-             (let close_effect_params tm =
-                match ed.FStar_Syntax_Syntax.binders with
-                | [] -> tm
-                | uu___3 ->
-                    FStar_Syntax_Syntax.mk
-                      (FStar_Syntax_Syntax.Tm_abs
-                         ((ed.FStar_Syntax_Syntax.binders), tm,
-                           (FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Util.mk_residual_comp
-                                 FStar_Parser_Const.effect_Tot_lid
-                                 FStar_Pervasives_Native.None
-                                 [FStar_Syntax_Syntax.TOTAL]))))
-                      tm.FStar_Syntax_Syntax.pos in
-              let encode_action env1 a =
-                let action_defn =
-                  let uu___3 =
-                    close_effect_params a.FStar_Syntax_Syntax.action_defn in
-                  norm_before_encoding env1 uu___3 in
-                let uu___3 =
-                  FStar_Syntax_Util.arrow_formals_comp
-                    a.FStar_Syntax_Syntax.action_typ in
-                match uu___3 with
-                | (formals, uu___4) ->
-                    let arity = FStar_Compiler_List.length formals in
-                    let uu___5 =
-                      FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid
-                        env1 a.FStar_Syntax_Syntax.action_name arity in
-                    (match uu___5 with
-                     | (aname, atok, env2) ->
-                         let uu___6 =
-                           FStar_SMTEncoding_EncodeTerm.encode_term
-                             action_defn env2 in
-                         (match uu___6 with
-                          | (tm, decls) ->
-                              let a_decls =
-                                let uu___7 =
-                                  let uu___8 =
-                                    let uu___9 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        formals
-                                        (FStar_Compiler_List.map
-                                           (fun uu___10 ->
-                                              FStar_SMTEncoding_Term.Term_sort)) in
-                                    (aname, uu___9,
-                                      FStar_SMTEncoding_Term.Term_sort,
-                                      (FStar_Pervasives_Native.Some "Action")) in
-                                  FStar_SMTEncoding_Term.DeclFun uu___8 in
-                                [uu___7;
-                                FStar_SMTEncoding_Term.DeclFun
-                                  (atok, [],
-                                    FStar_SMTEncoding_Term.Term_sort,
-                                    (FStar_Pervasives_Native.Some
-                                       "Action token"))] in
-                              let uu___7 =
-                                let aux uu___8 uu___9 =
-                                  match (uu___8, uu___9) with
-                                  | ({ FStar_Syntax_Syntax.binder_bv = bv;
-                                       FStar_Syntax_Syntax.binder_qual =
-                                         uu___10;
-                                       FStar_Syntax_Syntax.binder_attrs =
-                                         uu___11;_},
-                                     (env3, acc_sorts, acc)) ->
-                                      let uu___12 =
-                                        FStar_SMTEncoding_Env.gen_term_var
-                                          env3 bv in
-                                      (match uu___12 with
-                                       | (xxsym, xx, env4) ->
-                                           let uu___13 =
-                                             let uu___14 =
-                                               FStar_SMTEncoding_Term.mk_fv
-                                                 (xxsym,
-                                                   FStar_SMTEncoding_Term.Term_sort) in
-                                             uu___14 :: acc_sorts in
-                                           (env4, uu___13, (xx :: acc))) in
-                                FStar_Compiler_List.fold_right aux formals
-                                  (env2, [], []) in
-                              (match uu___7 with
-                               | (uu___8, xs_sorts, xs) ->
-                                   let app =
-                                     FStar_SMTEncoding_Util.mkApp (aname, xs) in
-                                   let a_eq =
-                                     let uu___9 =
-                                       let uu___10 =
-                                         let uu___11 =
-                                           FStar_Ident.range_of_lid
-                                             a.FStar_Syntax_Syntax.action_name in
-                                         let uu___12 =
-                                           let uu___13 =
-                                             let uu___14 =
-                                               let uu___15 =
-                                                 FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                                   tm xs_sorts in
-                                               (app, uu___15) in
-                                             FStar_SMTEncoding_Util.mkEq
-                                               uu___14 in
-                                           ([[app]], xs_sorts, uu___13) in
-                                         FStar_SMTEncoding_Term.mkForall
-                                           uu___11 uu___12 in
-                                       (uu___10,
-                                         (FStar_Pervasives_Native.Some
-                                            "Action equality"),
-                                         (Prims.op_Hat aname "_equality")) in
-                                     FStar_SMTEncoding_Util.mkAssume uu___9 in
-                                   let tok_correspondence =
-                                     let tok_term =
-                                       let uu___9 =
-                                         FStar_SMTEncoding_Term.mk_fv
-                                           (atok,
-                                             FStar_SMTEncoding_Term.Term_sort) in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         FStar_SMTEncoding_Util.mkFreeV
-                                         uu___9 in
-                                     let tok_app =
-                                       FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                         tok_term xs_sorts in
-                                     let uu___9 =
-                                       let uu___10 =
-                                         let uu___11 =
-                                           FStar_Ident.range_of_lid
-                                             a.FStar_Syntax_Syntax.action_name in
-                                         let uu___12 =
-                                           let uu___13 =
-                                             FStar_SMTEncoding_Util.mkEq
-                                               (tok_app, app) in
-                                           ([[tok_app]], xs_sorts, uu___13) in
-                                         FStar_SMTEncoding_Term.mkForall
-                                           uu___11 uu___12 in
-                                       (uu___10,
-                                         (FStar_Pervasives_Native.Some
-                                            "Action token correspondence"),
-                                         (Prims.op_Hat aname
-                                            "_token_correspondence")) in
-                                     FStar_SMTEncoding_Util.mkAssume uu___9 in
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         (FStar_Compiler_List.op_At a_decls
-                                            [a_eq; tok_correspondence])
-                                         FStar_SMTEncoding_Term.mk_decls_trivial in
-                                     FStar_Compiler_List.op_At decls uu___10 in
-                                   (env2, uu___9)))) in
-              let uu___3 =
-                FStar_Compiler_Util.fold_map encode_action env
-                  ed.FStar_Syntax_Syntax.actions in
-              match uu___3 with
-              | (env1, decls2) ->
-                  ((FStar_Compiler_List.flatten decls2), env1))
-       | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___1, uu___2) when
-           FStar_Ident.lid_equals lid FStar_Parser_Const.precedes_lid ->
-           let uu___3 =
-             FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid env lid
-               (Prims.of_int (4)) in
-           (match uu___3 with | (tname, ttok, env1) -> ([], env1))
-       | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___1, t) ->
-           let quals = se.FStar_Syntax_Syntax.sigquals in
-           let will_encode_definition =
-             let uu___2 =
-               FStar_Compiler_Effect.op_Bar_Greater quals
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | FStar_Syntax_Syntax.Assumption -> true
-                       | FStar_Syntax_Syntax.Projector uu___4 -> true
-                       | FStar_Syntax_Syntax.Discriminator uu___4 -> true
-                       | FStar_Syntax_Syntax.Irreducible -> true
-                       | uu___4 -> false)) in
-             Prims.op_Negation uu___2 in
-           if will_encode_definition
-           then ([], env)
-           else
-             (let fv =
-                FStar_Syntax_Syntax.lid_as_fv lid
-                  FStar_Syntax_Syntax.delta_constant
-                  FStar_Pervasives_Native.None in
-              let uu___3 =
-                let uu___4 =
-                  FStar_Compiler_Effect.op_Bar_Greater
-                    se.FStar_Syntax_Syntax.sigattrs
-                    (FStar_Compiler_Util.for_some is_uninterpreted_by_smt) in
-                encode_top_level_val uu___4 env fv t quals in
-              match uu___3 with
-              | (decls, env1) ->
-                  let tname = FStar_Ident.string_of_lid lid in
-                  let tsym =
-                    let uu___4 =
-                      FStar_SMTEncoding_Env.try_lookup_free_var env1 lid in
-                    FStar_Compiler_Option.get uu___4 in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        primitive_type_axioms
-                          env1.FStar_SMTEncoding_Env.tcenv lid tname tsym in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___6
-                        FStar_SMTEncoding_Term.mk_decls_trivial in
-                    FStar_Compiler_List.op_At decls uu___5 in
-                  (uu___4, env1))
-       | FStar_Syntax_Syntax.Sig_assume (l, us, f) ->
-           let uu___1 = FStar_Syntax_Subst.open_univ_vars us f in
-           (match uu___1 with
-            | (uvs, f1) ->
-                let env1 =
-                  let uu___2 =
-                    FStar_TypeChecker_Env.push_univ_vars
-                      env.FStar_SMTEncoding_Env.tcenv uvs in
-                  {
-                    FStar_SMTEncoding_Env.bvar_bindings =
-                      (env.FStar_SMTEncoding_Env.bvar_bindings);
-                    FStar_SMTEncoding_Env.fvar_bindings =
-                      (env.FStar_SMTEncoding_Env.fvar_bindings);
-                    FStar_SMTEncoding_Env.depth =
-                      (env.FStar_SMTEncoding_Env.depth);
-                    FStar_SMTEncoding_Env.tcenv = uu___2;
-                    FStar_SMTEncoding_Env.warn =
-                      (env.FStar_SMTEncoding_Env.warn);
-                    FStar_SMTEncoding_Env.nolabels =
-                      (env.FStar_SMTEncoding_Env.nolabels);
-                    FStar_SMTEncoding_Env.use_zfuel_name =
-                      (env.FStar_SMTEncoding_Env.use_zfuel_name);
-                    FStar_SMTEncoding_Env.encode_non_total_function_typ =
-                      (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-                    FStar_SMTEncoding_Env.current_module_name =
-                      (env.FStar_SMTEncoding_Env.current_module_name);
-                    FStar_SMTEncoding_Env.encoding_quantifier =
-                      (env.FStar_SMTEncoding_Env.encoding_quantifier);
-                    FStar_SMTEncoding_Env.global_cache =
-                      (env.FStar_SMTEncoding_Env.global_cache)
-                  } in
-                let f2 = norm_before_encoding env1 f1 in
-                let uu___2 =
-                  FStar_SMTEncoding_EncodeTerm.encode_formula f2 env1 in
-                (match uu___2 with
-                 | (f3, decls) ->
-                     let g =
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 =
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Syntax_Print.lid_to_string l in
-                                 FStar_Compiler_Util.format1 "Assumption: %s"
-                                   uu___8 in
-                               FStar_Pervasives_Native.Some uu___7 in
-                             let uu___7 =
-                               let uu___8 =
-                                 let uu___9 = FStar_Ident.string_of_lid l in
-                                 Prims.op_Hat "assumption_" uu___9 in
-                               FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.mk_unique
-                                 uu___8 in
-                             (f3, uu___6, uu___7) in
-                           FStar_SMTEncoding_Util.mkAssume uu___5 in
-                         [uu___4] in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___3
-                         FStar_SMTEncoding_Term.mk_decls_trivial in
-                     ((FStar_Compiler_List.op_At decls g), env1)))
-       | FStar_Syntax_Syntax.Sig_let (lbs, uu___1) when
-           (FStar_Compiler_Effect.op_Bar_Greater
-              se.FStar_Syntax_Syntax.sigquals
-              (FStar_Compiler_List.contains FStar_Syntax_Syntax.Irreducible))
-             ||
-             (FStar_Compiler_Effect.op_Bar_Greater
-                se.FStar_Syntax_Syntax.sigattrs
-                (FStar_Compiler_Util.for_some is_opaque_to_smt))
-           ->
-           let attrs = se.FStar_Syntax_Syntax.sigattrs in
-           let uu___2 =
-             FStar_Compiler_Util.fold_map
-               (fun env1 ->
-                  fun lb ->
-                    let lid =
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Compiler_Util.right
-                            lb.FStar_Syntax_Syntax.lbname in
-                        uu___4.FStar_Syntax_Syntax.fv_name in
-                      uu___3.FStar_Syntax_Syntax.v in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_TypeChecker_Env.try_lookup_val_decl
-                          env1.FStar_SMTEncoding_Env.tcenv lid in
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Compiler_Option.isNone uu___4 in
-                    if uu___3
-                    then
-                      let val_decl =
-                        {
-                          FStar_Syntax_Syntax.sigel =
-                            (FStar_Syntax_Syntax.Sig_declare_typ
-                               (lid, (lb.FStar_Syntax_Syntax.lbunivs),
-                                 (lb.FStar_Syntax_Syntax.lbtyp)));
-                          FStar_Syntax_Syntax.sigrng =
-                            (se.FStar_Syntax_Syntax.sigrng);
-                          FStar_Syntax_Syntax.sigquals =
-                            (FStar_Syntax_Syntax.Irreducible ::
-                            (se.FStar_Syntax_Syntax.sigquals));
-                          FStar_Syntax_Syntax.sigmeta =
-                            (se.FStar_Syntax_Syntax.sigmeta);
-                          FStar_Syntax_Syntax.sigattrs =
-                            (se.FStar_Syntax_Syntax.sigattrs);
-                          FStar_Syntax_Syntax.sigopts =
-                            (se.FStar_Syntax_Syntax.sigopts)
-                        } in
-                      let uu___4 = encode_sigelt' env1 val_decl in
-                      match uu___4 with | (decls, env2) -> (env2, decls)
-                    else (env1, [])) env (FStar_Pervasives_Native.snd lbs) in
-           (match uu___2 with
-            | (env1, decls) -> ((FStar_Compiler_List.flatten decls), env1))
-       | FStar_Syntax_Syntax.Sig_let
-           ((uu___1,
-             { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr b2t;
-               FStar_Syntax_Syntax.lbunivs = uu___2;
-               FStar_Syntax_Syntax.lbtyp = uu___3;
-               FStar_Syntax_Syntax.lbeff = uu___4;
-               FStar_Syntax_Syntax.lbdef = uu___5;
-               FStar_Syntax_Syntax.lbattrs = uu___6;
-               FStar_Syntax_Syntax.lbpos = uu___7;_}::[]),
-            uu___8)
-           when FStar_Syntax_Syntax.fv_eq_lid b2t FStar_Parser_Const.b2t_lid
-           ->
-           let uu___9 =
-             FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid env
-               (b2t.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-               Prims.int_one in
-           (match uu___9 with
-            | (tname, ttok, env1) ->
-                let xx =
-                  FStar_SMTEncoding_Term.mk_fv
-                    ("x", FStar_SMTEncoding_Term.Term_sort) in
-                let x = FStar_SMTEncoding_Util.mkFreeV xx in
-                let b2t_x = FStar_SMTEncoding_Util.mkApp ("Prims.b2t", [x]) in
-                let valid_b2t_x =
-                  FStar_SMTEncoding_Util.mkApp ("Valid", [b2t_x]) in
-                let bool_ty =
-                  let uu___10 =
-                    FStar_Syntax_Syntax.withsort FStar_Parser_Const.bool_lid in
-                  FStar_SMTEncoding_Env.lookup_free_var env1 uu___10 in
-                let decls =
-                  let uu___10 =
-                    let uu___11 =
-                      let uu___12 =
-                        let uu___13 =
-                          let uu___14 = FStar_Syntax_Syntax.range_of_fv b2t in
-                          let uu___15 =
-                            let uu___16 =
-                              let uu___17 =
-                                let uu___18 =
-                                  FStar_SMTEncoding_Util.mkApp
-                                    ((FStar_Pervasives_Native.snd
-                                        FStar_SMTEncoding_Term.boxBoolFun),
-                                      [x]) in
-                                (valid_b2t_x, uu___18) in
-                              FStar_SMTEncoding_Util.mkEq uu___17 in
-                            ([[b2t_x]], [xx], uu___16) in
-                          FStar_SMTEncoding_Term.mkForall uu___14 uu___15 in
-                        (uu___13, (FStar_Pervasives_Native.Some "b2t def"),
-                          "b2t_def") in
-                      FStar_SMTEncoding_Util.mkAssume uu___12 in
-                    let uu___12 =
-                      let uu___13 =
-                        let uu___14 =
-                          let uu___15 =
-                            let uu___16 = FStar_Syntax_Syntax.range_of_fv b2t in
-                            let uu___17 =
-                              let uu___18 =
-                                let uu___19 =
-                                  let uu___20 =
-                                    FStar_SMTEncoding_Term.mk_HasType x
-                                      bool_ty in
-                                  let uu___21 =
-                                    FStar_SMTEncoding_Term.mk_HasType b2t_x
-                                      FStar_SMTEncoding_Term.mk_Term_type in
-                                  (uu___20, uu___21) in
-                                FStar_SMTEncoding_Util.mkImp uu___19 in
-                              ([[b2t_x]], [xx], uu___18) in
-                            FStar_SMTEncoding_Term.mkForall uu___16 uu___17 in
-                          (uu___15,
-                            (FStar_Pervasives_Native.Some "b2t typing"),
-                            "b2t_typing") in
-                        FStar_SMTEncoding_Util.mkAssume uu___14 in
-                      [uu___13] in
-                    uu___11 :: uu___12 in
-                  (FStar_SMTEncoding_Term.DeclFun
-                     (tname, [FStar_SMTEncoding_Term.Term_sort],
-                       FStar_SMTEncoding_Term.Term_sort,
-                       FStar_Pervasives_Native.None))
-                    :: uu___10 in
-                let uu___10 =
-                  FStar_Compiler_Effect.op_Bar_Greater decls
-                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                (uu___10, env1))
-       | FStar_Syntax_Syntax.Sig_let (uu___1, uu___2) when
-           FStar_Compiler_Effect.op_Bar_Greater
-             se.FStar_Syntax_Syntax.sigquals
-             (FStar_Compiler_Util.for_some
-                (fun uu___3 ->
-                   match uu___3 with
-                   | FStar_Syntax_Syntax.Discriminator uu___4 -> true
-                   | uu___4 -> false))
-           ->
-           ((let uu___4 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv)
-                 (FStar_Options.Other "SMTEncoding") in
-             if uu___4
-             then
-               let uu___5 = FStar_Syntax_Print.sigelt_to_string_short se in
-               FStar_Compiler_Util.print1 "Not encoding discriminator '%s'\n"
-                 uu___5
-             else ());
-            ([], env))
-       | FStar_Syntax_Syntax.Sig_let (uu___1, lids) when
-           (FStar_Compiler_Effect.op_Bar_Greater lids
-              (FStar_Compiler_Util.for_some
-                 (fun l ->
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = FStar_Ident.ns_of_lid l in
-                        FStar_Compiler_List.hd uu___4 in
-                      FStar_Ident.string_of_id uu___3 in
-                    uu___2 = "Prims")))
-             &&
-             (FStar_Compiler_Effect.op_Bar_Greater
-                se.FStar_Syntax_Syntax.sigquals
-                (FStar_Compiler_Util.for_some
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen
-                          -> true
-                      | uu___3 -> false)))
-           ->
-           ((let uu___3 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv)
-                 (FStar_Options.Other "SMTEncoding") in
-             if uu___3
-             then
-               let uu___4 = FStar_Syntax_Print.sigelt_to_string_short se in
-               FStar_Compiler_Util.print1
-                 "Not encoding unfold let from Prims '%s'\n" uu___4
-             else ());
-            ([], env))
-       | FStar_Syntax_Syntax.Sig_let ((false, lb::[]), uu___1) when
-           FStar_Compiler_Effect.op_Bar_Greater
-             se.FStar_Syntax_Syntax.sigquals
-             (FStar_Compiler_Util.for_some
-                (fun uu___2 ->
-                   match uu___2 with
-                   | FStar_Syntax_Syntax.Projector uu___3 -> true
-                   | uu___3 -> false))
-           ->
-           let fv = FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-           let l = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-           let uu___2 = FStar_SMTEncoding_Env.try_lookup_free_var env l in
-           (match uu___2 with
-            | FStar_Pervasives_Native.Some uu___3 -> ([], env)
-            | FStar_Pervasives_Native.None ->
-                let se1 =
-                  let uu___3 = FStar_Ident.range_of_lid l in
-                  {
-                    FStar_Syntax_Syntax.sigel =
-                      (FStar_Syntax_Syntax.Sig_declare_typ
-                         (l, (lb.FStar_Syntax_Syntax.lbunivs),
-                           (lb.FStar_Syntax_Syntax.lbtyp)));
-                    FStar_Syntax_Syntax.sigrng = uu___3;
-                    FStar_Syntax_Syntax.sigquals =
-                      (se.FStar_Syntax_Syntax.sigquals);
-                    FStar_Syntax_Syntax.sigmeta =
-                      (se.FStar_Syntax_Syntax.sigmeta);
-                    FStar_Syntax_Syntax.sigattrs =
-                      (se.FStar_Syntax_Syntax.sigattrs);
-                    FStar_Syntax_Syntax.sigopts =
-                      (se.FStar_Syntax_Syntax.sigopts)
-                  } in
-                encode_sigelt env se1)
-       | FStar_Syntax_Syntax.Sig_let ((is_rec, bindings), uu___1) ->
-           let bindings1 =
-             FStar_Compiler_List.map
-               (fun lb ->
-                  let def =
-                    norm_before_encoding env lb.FStar_Syntax_Syntax.lbdef in
-                  let typ =
-                    norm_before_encoding env lb.FStar_Syntax_Syntax.lbtyp in
-                  {
-                    FStar_Syntax_Syntax.lbname =
-                      (lb.FStar_Syntax_Syntax.lbname);
-                    FStar_Syntax_Syntax.lbunivs =
-                      (lb.FStar_Syntax_Syntax.lbunivs);
-                    FStar_Syntax_Syntax.lbtyp = typ;
-                    FStar_Syntax_Syntax.lbeff =
-                      (lb.FStar_Syntax_Syntax.lbeff);
-                    FStar_Syntax_Syntax.lbdef = def;
-                    FStar_Syntax_Syntax.lbattrs =
-                      (lb.FStar_Syntax_Syntax.lbattrs);
-                    FStar_Syntax_Syntax.lbpos =
-                      (lb.FStar_Syntax_Syntax.lbpos)
-                  }) bindings in
-           encode_top_level_let env (is_rec, bindings1)
-             se.FStar_Syntax_Syntax.sigquals
-       | FStar_Syntax_Syntax.Sig_bundle (ses, uu___1) ->
-           let uu___2 = encode_sigelts env ses in
-           (match uu___2 with
-            | (g, env1) ->
-                let uu___3 =
-                  FStar_Compiler_List.fold_left
-                    (fun uu___4 ->
-                       fun elt ->
-                         match uu___4 with
-                         | (g', inversions) ->
-                             let uu___5 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 elt.FStar_SMTEncoding_Term.decls
-                                 (FStar_Compiler_List.partition
-                                    (fun uu___6 ->
-                                       match uu___6 with
-                                       | FStar_SMTEncoding_Term.Assume
-                                           {
-                                             FStar_SMTEncoding_Term.assumption_term
-                                               = uu___7;
-                                             FStar_SMTEncoding_Term.assumption_caption
-                                               = FStar_Pervasives_Native.Some
-                                               "inversion axiom";
-                                             FStar_SMTEncoding_Term.assumption_name
-                                               = uu___8;
-                                             FStar_SMTEncoding_Term.assumption_fact_ids
-                                               = uu___9;_}
-                                           -> false
-                                       | uu___7 -> true)) in
-                             (match uu___5 with
-                              | (elt_g', elt_inversions) ->
-                                  ((FStar_Compiler_List.op_At g'
-                                      [{
-                                         FStar_SMTEncoding_Term.sym_name =
-                                           (elt.FStar_SMTEncoding_Term.sym_name);
-                                         FStar_SMTEncoding_Term.key =
-                                           (elt.FStar_SMTEncoding_Term.key);
-                                         FStar_SMTEncoding_Term.decls =
-                                           elt_g';
-                                         FStar_SMTEncoding_Term.a_names =
-                                           (elt.FStar_SMTEncoding_Term.a_names)
-                                       }]),
-                                    (FStar_Compiler_List.op_At inversions
-                                       elt_inversions)))) ([], []) g in
-                (match uu___3 with
-                 | (g', inversions) ->
-                     let uu___4 =
-                       FStar_Compiler_List.fold_left
-                         (fun uu___5 ->
-                            fun elt ->
-                              match uu___5 with
-                              | (decls, elts, rest) ->
-                                  let uu___6 =
-                                    (FStar_Compiler_Effect.op_Bar_Greater
-                                       elt.FStar_SMTEncoding_Term.key
-                                       FStar_Compiler_Util.is_some)
-                                      &&
-                                      (FStar_Compiler_List.existsb
-                                         (fun uu___7 ->
-                                            match uu___7 with
-                                            | FStar_SMTEncoding_Term.DeclFun
-                                                uu___8 -> true
-                                            | uu___8 -> false)
-                                         elt.FStar_SMTEncoding_Term.decls) in
-                                  if uu___6
-                                  then
-                                    (decls,
-                                      (FStar_Compiler_List.op_At elts [elt]),
-                                      rest)
-                                  else
-                                    (let uu___8 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         elt.FStar_SMTEncoding_Term.decls
-                                         (FStar_Compiler_List.partition
-                                            (fun uu___9 ->
-                                               match uu___9 with
-                                               | FStar_SMTEncoding_Term.DeclFun
-                                                   uu___10 -> true
-                                               | uu___10 -> false)) in
-                                     match uu___8 with
-                                     | (elt_decls, elt_rest) ->
-                                         ((FStar_Compiler_List.op_At decls
-                                             elt_decls), elts,
-                                           (FStar_Compiler_List.op_At rest
-                                              [{
-                                                 FStar_SMTEncoding_Term.sym_name
-                                                   =
-                                                   (elt.FStar_SMTEncoding_Term.sym_name);
-                                                 FStar_SMTEncoding_Term.key =
-                                                   (elt.FStar_SMTEncoding_Term.key);
-                                                 FStar_SMTEncoding_Term.decls
-                                                   = elt_rest;
-                                                 FStar_SMTEncoding_Term.a_names
-                                                   =
-                                                   (elt.FStar_SMTEncoding_Term.a_names)
-                                               }])))) ([], [], []) g' in
-                     (match uu___4 with
-                      | (decls, elts, rest) ->
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Compiler_Effect.op_Bar_Greater decls
-                                FStar_SMTEncoding_Term.mk_decls_trivial in
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    inversions
-                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                FStar_Compiler_List.op_At rest uu___9 in
-                              FStar_Compiler_List.op_At elts uu___8 in
-                            FStar_Compiler_List.op_At uu___6 uu___7 in
-                          (uu___5, env1))))
-       | FStar_Syntax_Syntax.Sig_inductive_typ
-           (t, universe_names, tps, _num_uniform, k, uu___1, datas) ->
-           let tcenv = env.FStar_SMTEncoding_Env.tcenv in
-           let is_injective =
-             let uu___2 = FStar_Syntax_Subst.univ_var_opening universe_names in
-             match uu___2 with
-             | (usubst, uvs) ->
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_TypeChecker_Env.push_univ_vars tcenv uvs in
-                   let uu___5 = FStar_Syntax_Subst.subst_binders usubst tps in
-                   let uu___6 =
-                     let uu___7 =
-                       FStar_Syntax_Subst.shift_subst
-                         (FStar_Compiler_List.length tps) usubst in
-                     FStar_Syntax_Subst.subst uu___7 k in
-                   (uu___4, uu___5, uu___6) in
-                 (match uu___3 with
-                  | (env1, tps1, k1) ->
-                      let uu___4 = FStar_Syntax_Subst.open_term tps1 k1 in
-                      (match uu___4 with
-                       | (tps2, k2) ->
-                           let uu___5 = FStar_Syntax_Util.arrow_formals k2 in
-                           (match uu___5 with
-                            | (uu___6, k3) ->
-                                let uu___7 =
-                                  FStar_TypeChecker_TcTerm.tc_binders env1
-                                    tps2 in
-                                (match uu___7 with
-                                 | (tps3, env_tps, uu___8, us) ->
-                                     let u_k =
-                                       let uu___9 =
-                                         let uu___10 =
-                                           FStar_Syntax_Syntax.fvar t
-                                             (FStar_Syntax_Syntax.Delta_constant_at_level
-                                                Prims.int_zero)
-                                             FStar_Pervasives_Native.None in
-                                         let uu___11 =
-                                           let uu___12 =
-                                             FStar_Syntax_Util.args_of_binders
-                                               tps3 in
-                                           FStar_Pervasives_Native.snd
-                                             uu___12 in
-                                         let uu___12 =
-                                           FStar_Ident.range_of_lid t in
-                                         FStar_Syntax_Syntax.mk_Tm_app
-                                           uu___10 uu___11 uu___12 in
-                                       FStar_TypeChecker_TcTerm.level_of_type
-                                         env_tps uu___9 k3 in
-                                     let rec universe_leq u v =
-                                       match (u, v) with
-                                       | (FStar_Syntax_Syntax.U_zero, uu___9)
-                                           -> true
-                                       | (FStar_Syntax_Syntax.U_succ u0,
-                                          FStar_Syntax_Syntax.U_succ v0) ->
-                                           universe_leq u0 v0
-                                       | (FStar_Syntax_Syntax.U_name u0,
-                                          FStar_Syntax_Syntax.U_name v0) ->
-                                           FStar_Ident.ident_equals u0 v0
-                                       | (FStar_Syntax_Syntax.U_name uu___9,
-                                          FStar_Syntax_Syntax.U_succ v0) ->
-                                           universe_leq u v0
-                                       | (FStar_Syntax_Syntax.U_max us1,
-                                          uu___9) ->
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             us1
-                                             (FStar_Compiler_Util.for_all
-                                                (fun u1 -> universe_leq u1 v))
-                                       | (uu___9, FStar_Syntax_Syntax.U_max
-                                          vs) ->
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             vs
-                                             (FStar_Compiler_Util.for_some
-                                                (universe_leq u))
-                                       | (FStar_Syntax_Syntax.U_unknown,
-                                          uu___9) ->
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_Ident.string_of_lid t in
-                                             let uu___12 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 u in
-                                             let uu___13 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 v in
-                                             FStar_Compiler_Util.format3
-                                               "Impossible: Unresolved or unknown universe in inductive type %s (%s, %s)"
-                                               uu___11 uu___12 uu___13 in
-                                           failwith uu___10
-                                       | (uu___9,
-                                          FStar_Syntax_Syntax.U_unknown) ->
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_Ident.string_of_lid t in
-                                             let uu___12 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 u in
-                                             let uu___13 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 v in
-                                             FStar_Compiler_Util.format3
-                                               "Impossible: Unresolved or unknown universe in inductive type %s (%s, %s)"
-                                               uu___11 uu___12 uu___13 in
-                                           failwith uu___10
-                                       | (FStar_Syntax_Syntax.U_unif uu___9,
-                                          uu___10) ->
-                                           let uu___11 =
-                                             let uu___12 =
-                                               FStar_Ident.string_of_lid t in
-                                             let uu___13 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 u in
-                                             let uu___14 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 v in
-                                             FStar_Compiler_Util.format3
-                                               "Impossible: Unresolved or unknown universe in inductive type %s (%s, %s)"
-                                               uu___12 uu___13 uu___14 in
-                                           failwith uu___11
-                                       | (uu___9, FStar_Syntax_Syntax.U_unif
-                                          uu___10) ->
-                                           let uu___11 =
-                                             let uu___12 =
-                                               FStar_Ident.string_of_lid t in
-                                             let uu___13 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 u in
-                                             let uu___14 =
-                                               FStar_Syntax_Print.univ_to_string
-                                                 v in
-                                             FStar_Compiler_Util.format3
-                                               "Impossible: Unresolved or unknown universe in inductive type %s (%s, %s)"
-                                               uu___12 uu___13 uu___14 in
-                                           failwith uu___11
-                                       | uu___9 -> false in
-                                     let u_leq_u_k u =
-                                       let uu___9 =
-                                         FStar_TypeChecker_Normalize.normalize_universe
-                                           env_tps u in
-                                       universe_leq uu___9 u_k in
-                                     let tp_ok tp u_tp =
-                                       let t_tp =
-                                         (tp.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                       let uu___9 = u_leq_u_k u_tp in
-                                       if uu___9
-                                       then true
-                                       else
-                                         (let uu___11 =
-                                            FStar_Syntax_Util.arrow_formals
-                                              t_tp in
-                                          match uu___11 with
-                                          | (formals, uu___12) ->
-                                              let uu___13 =
-                                                FStar_TypeChecker_TcTerm.tc_binders
-                                                  env_tps formals in
-                                              (match uu___13 with
-                                               | (uu___14, uu___15, uu___16,
-                                                  u_formals) ->
-                                                   FStar_Compiler_Util.for_all
-                                                     (fun u_formal ->
-                                                        u_leq_u_k u_formal)
-                                                     u_formals)) in
-                                     FStar_Compiler_List.forall2 tp_ok tps3
-                                       us)))) in
-           ((let uu___3 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv)
-                 (FStar_Options.Other "SMTEncoding") in
-             if uu___3
-             then
-               let uu___4 = FStar_Ident.string_of_lid t in
-               FStar_Compiler_Util.print2 "%s injectivity for %s\n"
-                 (if is_injective then "YES" else "NO") uu___4
-             else ());
-            (let quals = se.FStar_Syntax_Syntax.sigquals in
-             let is_logical =
-               FStar_Compiler_Effect.op_Bar_Greater quals
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | FStar_Syntax_Syntax.Logic -> true
-                       | FStar_Syntax_Syntax.Assumption -> true
-                       | uu___4 -> false)) in
-             let constructor_or_logic_type_decl c =
-               if is_logical
-               then
-                 let uu___3 = c in
-                 match uu___3 with
-                 | (name, args, uu___4, uu___5, uu___6) ->
-                     let uu___7 =
-                       let uu___8 =
-                         let uu___9 =
-                           FStar_Compiler_Effect.op_Bar_Greater args
-                             (FStar_Compiler_List.map
-                                (fun uu___10 ->
-                                   match uu___10 with
-                                   | (uu___11, sort, uu___12) -> sort)) in
-                         (name, uu___9, FStar_SMTEncoding_Term.Term_sort,
-                           FStar_Pervasives_Native.None) in
-                       FStar_SMTEncoding_Term.DeclFun uu___8 in
-                     [uu___7]
-               else
-                 (let uu___4 = FStar_Ident.range_of_lid t in
-                  FStar_SMTEncoding_Term.constructor_to_decl uu___4 c) in
-             let inversion_axioms env1 tapp vars =
-               let uu___3 =
-                 FStar_Compiler_Effect.op_Bar_Greater datas
-                   (FStar_Compiler_Util.for_some
-                      (fun l ->
-                         let uu___4 =
-                           FStar_TypeChecker_Env.try_lookup_lid
-                             env1.FStar_SMTEncoding_Env.tcenv l in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___4
-                           FStar_Compiler_Option.isNone)) in
-               if uu___3
-               then []
-               else
-                 (let uu___5 =
-                    FStar_SMTEncoding_Env.fresh_fvar
-                      env1.FStar_SMTEncoding_Env.current_module_name "x"
-                      FStar_SMTEncoding_Term.Term_sort in
-                  match uu___5 with
-                  | (xxsym, xx) ->
-                      let uu___6 =
-                        FStar_Compiler_Effect.op_Bar_Greater datas
-                          (FStar_Compiler_List.fold_left
-                             (fun uu___7 ->
-                                fun l ->
-                                  match uu___7 with
-                                  | (out, decls) ->
-                                      let uu___8 =
-                                        FStar_TypeChecker_Env.lookup_datacon
-                                          env1.FStar_SMTEncoding_Env.tcenv l in
-                                      (match uu___8 with
-                                       | (uu___9, data_t) ->
-                                           let uu___10 =
-                                             FStar_Syntax_Util.arrow_formals
-                                               data_t in
-                                           (match uu___10 with
-                                            | (args, res) ->
-                                                let indices =
-                                                  let uu___11 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      res
-                                                      FStar_Syntax_Util.head_and_args_full in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___11
-                                                    FStar_Pervasives_Native.snd in
-                                                let env2 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    args
-                                                    (FStar_Compiler_List.fold_left
-                                                       (fun env3 ->
-                                                          fun uu___11 ->
-                                                            match uu___11
-                                                            with
-                                                            | {
-                                                                FStar_Syntax_Syntax.binder_bv
-                                                                  = x;
-                                                                FStar_Syntax_Syntax.binder_qual
-                                                                  = uu___12;
-                                                                FStar_Syntax_Syntax.binder_attrs
-                                                                  = uu___13;_}
-                                                                ->
-                                                                let uu___14 =
-                                                                  let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_SMTEncoding_Env.mk_term_projector_name
-                                                                    l x in
-                                                                    (uu___16,
-                                                                    [xx]) in
-                                                                  FStar_SMTEncoding_Util.mkApp
-                                                                    uu___15 in
-                                                                FStar_SMTEncoding_Env.push_term_var
-                                                                  env3 x
-                                                                  uu___14)
-                                                       env1) in
-                                                let uu___11 =
-                                                  FStar_SMTEncoding_EncodeTerm.encode_args
-                                                    indices env2 in
-                                                (match uu___11 with
-                                                 | (indices1, decls') ->
-                                                     (if
-                                                        (FStar_Compiler_List.length
-                                                           indices1)
-                                                          <>
-                                                          (FStar_Compiler_List.length
-                                                             vars)
-                                                      then
-                                                        failwith "Impossible"
-                                                      else ();
-                                                      (let eqs =
-                                                         if is_injective
-                                                         then
-                                                           FStar_Compiler_List.map2
-                                                             (fun v ->
-                                                                fun a ->
-                                                                  let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    v in
-                                                                    (uu___14,
-                                                                    a) in
-                                                                  FStar_SMTEncoding_Util.mkEq
-                                                                    uu___13)
-                                                             vars indices1
-                                                         else [] in
-                                                       let uu___13 =
-                                                         let uu___14 =
-                                                           let uu___15 =
-                                                             let uu___16 =
-                                                               let uu___17 =
-                                                                 FStar_SMTEncoding_Env.mk_data_tester
-                                                                   env2 l xx in
-                                                               let uu___18 =
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   eqs
-                                                                   FStar_SMTEncoding_Util.mk_and_l in
-                                                               (uu___17,
-                                                                 uu___18) in
-                                                             FStar_SMTEncoding_Util.mkAnd
-                                                               uu___16 in
-                                                           (out, uu___15) in
-                                                         FStar_SMTEncoding_Util.mkOr
-                                                           uu___14 in
-                                                       (uu___13,
-                                                         (FStar_Compiler_List.op_At
-                                                            decls decls'))))))))
-                             (FStar_SMTEncoding_Util.mkFalse, [])) in
-                      (match uu___6 with
-                       | (data_ax, decls) ->
-                           let uu___7 =
-                             FStar_SMTEncoding_Env.fresh_fvar
-                               env1.FStar_SMTEncoding_Env.current_module_name
-                               "f" FStar_SMTEncoding_Term.Fuel_sort in
-                           (match uu___7 with
-                            | (ffsym, ff) ->
-                                let fuel_guarded_inversion =
-                                  let xx_has_type_sfuel =
-                                    if
-                                      (FStar_Compiler_List.length datas) >
-                                        Prims.int_one
-                                    then
-                                      let uu___8 =
-                                        FStar_SMTEncoding_Util.mkApp
-                                          ("SFuel", [ff]) in
-                                      FStar_SMTEncoding_Term.mk_HasTypeFuel
-                                        uu___8 xx tapp
-                                    else
-                                      FStar_SMTEncoding_Term.mk_HasTypeFuel
-                                        ff xx tapp in
-                                  let uu___8 =
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_Ident.range_of_lid t in
-                                      let uu___11 =
-                                        let uu___12 =
-                                          let uu___13 =
-                                            FStar_SMTEncoding_Term.mk_fv
-                                              (ffsym,
-                                                FStar_SMTEncoding_Term.Fuel_sort) in
-                                          let uu___14 =
-                                            let uu___15 =
-                                              FStar_SMTEncoding_Term.mk_fv
-                                                (xxsym,
-                                                  FStar_SMTEncoding_Term.Term_sort) in
-                                            uu___15 :: vars in
-                                          FStar_SMTEncoding_Env.add_fuel
-                                            uu___13 uu___14 in
-                                        let uu___13 =
-                                          FStar_SMTEncoding_Util.mkImp
-                                            (xx_has_type_sfuel, data_ax) in
-                                        ([[xx_has_type_sfuel]], uu___12,
-                                          uu___13) in
-                                      FStar_SMTEncoding_Term.mkForall uu___10
-                                        uu___11 in
-                                    let uu___10 =
-                                      let uu___11 =
-                                        let uu___12 =
-                                          FStar_Ident.string_of_lid t in
-                                        Prims.op_Hat
-                                          "fuel_guarded_inversion_" uu___12 in
-                                      FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.mk_unique
-                                        uu___11 in
-                                    (uu___9,
-                                      (FStar_Pervasives_Native.Some
-                                         "inversion axiom"), uu___10) in
-                                  FStar_SMTEncoding_Util.mkAssume uu___8 in
-                                let uu___8 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    [fuel_guarded_inversion]
-                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                FStar_Compiler_List.op_At decls uu___8))) in
-             let uu___3 =
-               let k1 =
-                 match tps with
-                 | [] -> k
-                 | uu___4 ->
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 = FStar_Syntax_Syntax.mk_Total k in
-                         (tps, uu___7) in
-                       FStar_Syntax_Syntax.Tm_arrow uu___6 in
-                     FStar_Syntax_Syntax.mk uu___5 k.FStar_Syntax_Syntax.pos in
-               let k2 = norm_before_encoding env k1 in
-               FStar_Syntax_Util.arrow_formals k2 in
-             match uu___3 with
-             | (formals, res) ->
-                 let uu___4 =
-                   FStar_SMTEncoding_EncodeTerm.encode_binders
-                     FStar_Pervasives_Native.None formals env in
-                 (match uu___4 with
-                  | (vars, guards, env', binder_decls, uu___5) ->
-                      let arity = FStar_Compiler_List.length vars in
-                      let uu___6 =
-                        FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid
-                          env t arity in
-                      (match uu___6 with
-                       | (tname, ttok, env1) ->
-                           let ttok_tm =
-                             FStar_SMTEncoding_Util.mkApp (ttok, []) in
-                           let guard = FStar_SMTEncoding_Util.mk_and_l guards in
-                           let tapp =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Compiler_List.map
-                                   FStar_SMTEncoding_Util.mkFreeV vars in
-                               (tname, uu___8) in
-                             FStar_SMTEncoding_Util.mkApp uu___7 in
-                           let uu___7 =
-                             let tname_decl =
-                               let uu___8 =
-                                 let uu___9 =
-                                   FStar_Compiler_Effect.op_Bar_Greater vars
-                                     (FStar_Compiler_List.map
-                                        (fun fv ->
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_SMTEncoding_Term.fv_name
-                                                 fv in
-                                             Prims.op_Hat tname uu___11 in
-                                           let uu___11 =
-                                             FStar_SMTEncoding_Term.fv_sort
-                                               fv in
-                                           (uu___10, uu___11, false))) in
-                                 let uu___10 =
-                                   FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.next_id
-                                     () in
-                                 (tname, uu___9,
-                                   FStar_SMTEncoding_Term.Term_sort, uu___10,
-                                   false) in
-                               constructor_or_logic_type_decl uu___8 in
-                             let uu___8 =
-                               match vars with
-                               | [] ->
-                                   let uu___9 =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         FStar_SMTEncoding_Util.mkApp
-                                           (tname, []) in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         (fun uu___12 ->
-                                            FStar_Pervasives_Native.Some
-                                              uu___12) uu___11 in
-                                     FStar_SMTEncoding_Env.push_free_var env1
-                                       t arity tname uu___10 in
-                                   ([], uu___9)
-                               | uu___9 ->
-                                   let ttok_decl =
-                                     FStar_SMTEncoding_Term.DeclFun
-                                       (ttok, [],
-                                         FStar_SMTEncoding_Term.Term_sort,
-                                         (FStar_Pervasives_Native.Some
-                                            "token")) in
-                                   let ttok_fresh =
-                                     let uu___10 =
-                                       FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.next_id
-                                         () in
-                                     FStar_SMTEncoding_Term.fresh_token
-                                       (ttok,
-                                         FStar_SMTEncoding_Term.Term_sort)
-                                       uu___10 in
-                                   let ttok_app =
-                                     FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                       ttok_tm vars in
-                                   let pats = [[ttok_app]; [tapp]] in
-                                   let name_tok_corr =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         let uu___12 =
-                                           FStar_Ident.range_of_lid t in
-                                         let uu___13 =
-                                           let uu___14 =
-                                             FStar_SMTEncoding_Util.mkEq
-                                               (ttok_app, tapp) in
-                                           (pats,
-                                             FStar_Pervasives_Native.None,
-                                             vars, uu___14) in
-                                         FStar_SMTEncoding_Term.mkForall'
-                                           uu___12 uu___13 in
-                                       (uu___11,
-                                         (FStar_Pervasives_Native.Some
-                                            "name-token correspondence"),
-                                         (Prims.op_Hat
-                                            "token_correspondence_" ttok)) in
-                                     FStar_SMTEncoding_Util.mkAssume uu___10 in
-                                   ([ttok_decl; ttok_fresh; name_tok_corr],
-                                     env1) in
-                             match uu___8 with
-                             | (tok_decls, env2) ->
-                                 ((FStar_Compiler_List.op_At tname_decl
-                                     tok_decls), env2) in
-                           (match uu___7 with
-                            | (decls, env2) ->
-                                let kindingAx =
-                                  let uu___8 =
-                                    FStar_SMTEncoding_EncodeTerm.encode_term_pred
-                                      FStar_Pervasives_Native.None res env'
-                                      tapp in
-                                  match uu___8 with
-                                  | (k1, decls1) ->
-                                      let karr =
-                                        if
-                                          (FStar_Compiler_List.length formals)
-                                            > Prims.int_zero
-                                        then
-                                          let uu___9 =
-                                            let uu___10 =
-                                              let uu___11 =
-                                                let uu___12 =
-                                                  FStar_SMTEncoding_Term.mk_PreType
-                                                    ttok_tm in
-                                                FStar_SMTEncoding_Term.mk_tester
-                                                  "Tm_arrow" uu___12 in
-                                              (uu___11,
-                                                (FStar_Pervasives_Native.Some
-                                                   "kinding"),
-                                                (Prims.op_Hat "pre_kinding_"
-                                                   ttok)) in
-                                            FStar_SMTEncoding_Util.mkAssume
-                                              uu___10 in
-                                          [uu___9]
-                                        else [] in
-                                      let rng = FStar_Ident.range_of_lid t in
-                                      let tot_fun_axioms =
-                                        let uu___9 =
-                                          FStar_Compiler_List.map
-                                            (fun uu___10 ->
-                                               FStar_SMTEncoding_Util.mkTrue)
-                                            vars in
-                                        FStar_SMTEncoding_EncodeTerm.isTotFun_axioms
-                                          rng ttok_tm vars uu___9 true in
-                                      let uu___9 =
-                                        let uu___10 =
-                                          let uu___11 =
-                                            let uu___12 =
-                                              let uu___13 =
-                                                let uu___14 =
-                                                  let uu___15 =
-                                                    let uu___16 =
-                                                      let uu___17 =
-                                                        let uu___18 =
-                                                          FStar_SMTEncoding_Util.mkImp
-                                                            (guard, k1) in
-                                                        ([[tapp]], vars,
-                                                          uu___18) in
-                                                      FStar_SMTEncoding_Term.mkForall
-                                                        rng uu___17 in
-                                                    (tot_fun_axioms, uu___16) in
-                                                  FStar_SMTEncoding_Util.mkAnd
-                                                    uu___15 in
-                                                (uu___14,
-                                                  FStar_Pervasives_Native.None,
-                                                  (Prims.op_Hat "kinding_"
-                                                     ttok)) in
-                                              FStar_SMTEncoding_Util.mkAssume
-                                                uu___13 in
-                                            [uu___12] in
-                                          FStar_Compiler_List.op_At karr
-                                            uu___11 in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___10
-                                          FStar_SMTEncoding_Term.mk_decls_trivial in
-                                      FStar_Compiler_List.op_At decls1 uu___9 in
-                                let aux =
-                                  let uu___8 =
-                                    let uu___9 =
-                                      inversion_axioms env2 tapp vars in
-                                    let uu___10 =
-                                      let uu___11 =
-                                        let uu___12 =
-                                          let uu___13 =
-                                            FStar_Ident.range_of_lid t in
-                                          pretype_axiom uu___13 env2 tapp
-                                            vars in
-                                        [uu___12] in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___11
-                                        FStar_SMTEncoding_Term.mk_decls_trivial in
-                                    FStar_Compiler_List.op_At uu___9 uu___10 in
-                                  FStar_Compiler_List.op_At kindingAx uu___8 in
-                                let g =
-                                  let uu___8 =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      decls
-                                      FStar_SMTEncoding_Term.mk_decls_trivial in
-                                  FStar_Compiler_List.op_At uu___8
-                                    (FStar_Compiler_List.op_At binder_decls
-                                       aux) in
-                                (g, env2))))))
-       | FStar_Syntax_Syntax.Sig_datacon
-           (d, uu___1, t, uu___2, n_tps, mutuals) ->
-           let quals = se.FStar_Syntax_Syntax.sigquals in
-           let t1 = norm_before_encoding env t in
-           let uu___3 = FStar_Syntax_Util.arrow_formals t1 in
-           (match uu___3 with
-            | (formals, t_res) ->
-                let arity = FStar_Compiler_List.length formals in
-                let uu___4 =
-                  FStar_SMTEncoding_Env.new_term_constant_and_tok_from_lid
-                    env d arity in
-                (match uu___4 with
-                 | (ddconstrsym, ddtok, env1) ->
-                     let ddtok_tm = FStar_SMTEncoding_Util.mkApp (ddtok, []) in
-                     let uu___5 =
-                       FStar_SMTEncoding_Env.fresh_fvar
-                         env1.FStar_SMTEncoding_Env.current_module_name "f"
-                         FStar_SMTEncoding_Term.Fuel_sort in
-                     (match uu___5 with
-                      | (fuel_var, fuel_tm) ->
-                          let s_fuel_tm =
-                            FStar_SMTEncoding_Util.mkApp ("SFuel", [fuel_tm]) in
-                          let uu___6 =
-                            FStar_SMTEncoding_EncodeTerm.encode_binders
-                              (FStar_Pervasives_Native.Some fuel_tm) formals
-                              env1 in
-                          (match uu___6 with
-                           | (vars, guards, env', binder_decls, names) ->
-                               let fields =
-                                 FStar_Compiler_Effect.op_Bar_Greater names
-                                   (FStar_Compiler_List.mapi
-                                      (fun n ->
-                                         fun x ->
-                                           let projectible = true in
-                                           let uu___7 =
-                                             FStar_SMTEncoding_Env.mk_term_projector_name
-                                               d x in
-                                           (uu___7,
-                                             FStar_SMTEncoding_Term.Term_sort,
-                                             projectible))) in
-                               let datacons =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.next_id
-                                       () in
-                                   (ddconstrsym, fields,
-                                     FStar_SMTEncoding_Term.Term_sort,
-                                     uu___8, true) in
-                                 let uu___8 =
-                                   let uu___9 = FStar_Ident.range_of_lid d in
-                                   FStar_SMTEncoding_Term.constructor_to_decl
-                                     uu___9 in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                   uu___8 in
-                               let app =
-                                 FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                   ddtok_tm vars in
-                               let guard =
-                                 FStar_SMTEncoding_Util.mk_and_l guards in
-                               let xvars =
-                                 FStar_Compiler_List.map
-                                   FStar_SMTEncoding_Util.mkFreeV vars in
-                               let dapp =
-                                 FStar_SMTEncoding_Util.mkApp
-                                   (ddconstrsym, xvars) in
-                               let uu___7 =
-                                 FStar_SMTEncoding_EncodeTerm.encode_term_pred
-                                   FStar_Pervasives_Native.None t1 env1
-                                   ddtok_tm in
-                               (match uu___7 with
-                                | (tok_typing, decls3) ->
-                                    let tok_typing1 =
-                                      match fields with
-                                      | uu___8::uu___9 ->
-                                          let ff =
-                                            FStar_SMTEncoding_Term.mk_fv
-                                              ("ty",
-                                                FStar_SMTEncoding_Term.Term_sort) in
-                                          let f =
-                                            FStar_SMTEncoding_Util.mkFreeV ff in
-                                          let vtok_app_l =
-                                            FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                              ddtok_tm [ff] in
-                                          let vtok_app_r =
-                                            let uu___10 =
-                                              let uu___11 =
-                                                FStar_SMTEncoding_Term.mk_fv
-                                                  (ddtok,
-                                                    FStar_SMTEncoding_Term.Term_sort) in
-                                              [uu___11] in
-                                            FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                              f uu___10 in
-                                          let uu___10 =
-                                            FStar_Ident.range_of_lid d in
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_SMTEncoding_Term.mk_NoHoist
-                                                f tok_typing in
-                                            ([[vtok_app_l]; [vtok_app_r]],
-                                              [ff], uu___12) in
-                                          FStar_SMTEncoding_Term.mkForall
-                                            uu___10 uu___11
-                                      | uu___8 -> tok_typing in
-                                    let uu___8 =
-                                      let uu___9 =
-                                        FStar_SMTEncoding_EncodeTerm.encode_term
-                                          t_res env' in
-                                      match uu___9 with
-                                      | (t_res_tm, t_res_decls) ->
-                                          let uu___10 =
-                                            FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                              (FStar_Pervasives_Native.Some
-                                                 fuel_tm) dapp t_res_tm in
-                                          (uu___10, t_res_tm, t_res_decls) in
-                                    (match uu___8 with
-                                     | (ty_pred', t_res_tm, decls_pred) ->
-                                         let proxy_fresh =
-                                           match formals with
-                                           | [] -> []
-                                           | uu___9 ->
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.next_id
-                                                     () in
-                                                 FStar_SMTEncoding_Term.fresh_token
-                                                   (ddtok,
-                                                     FStar_SMTEncoding_Term.Term_sort)
-                                                   uu___11 in
-                                               [uu___10] in
-                                         let encode_elim uu___9 =
-                                           let uu___10 =
-                                             FStar_Syntax_Util.head_and_args
-                                               t_res in
-                                           match uu___10 with
-                                           | (head, args) ->
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Syntax_Subst.compress
-                                                     head in
-                                                 uu___12.FStar_Syntax_Syntax.n in
-                                               (match uu___11 with
-                                                | FStar_Syntax_Syntax.Tm_uinst
-                                                    ({
-                                                       FStar_Syntax_Syntax.n
-                                                         =
-                                                         FStar_Syntax_Syntax.Tm_fvar
-                                                         fv;
-                                                       FStar_Syntax_Syntax.pos
-                                                         = uu___12;
-                                                       FStar_Syntax_Syntax.vars
-                                                         = uu___13;
-                                                       FStar_Syntax_Syntax.hash_code
-                                                         = uu___14;_},
-                                                     uu___15)
-                                                    ->
-                                                    let encoded_head_fvb =
-                                                      FStar_SMTEncoding_Env.lookup_free_var_name
-                                                        env'
-                                                        fv.FStar_Syntax_Syntax.fv_name in
-                                                    let uu___16 =
-                                                      FStar_SMTEncoding_EncodeTerm.encode_args
-                                                        args env' in
-                                                    (match uu___16 with
-                                                     | (encoded_args,
-                                                        arg_decls) ->
-                                                         let guards_for_parameter
-                                                           orig_arg arg xv =
-                                                           let fv1 =
-                                                             match arg.FStar_SMTEncoding_Term.tm
-                                                             with
-                                                             | FStar_SMTEncoding_Term.FreeV
-                                                                 fv2 -> fv2
-                                                             | uu___17 ->
-                                                                 let uu___18
-                                                                   =
-                                                                   let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    orig_arg in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "Inductive type parameter %s must be a variable ; You may want to change it to an index."
-                                                                    uu___20 in
-                                                                   (FStar_Errors.Fatal_NonVariableInductiveTypeParameter,
-                                                                    uu___19) in
-                                                                 FStar_Errors.raise_error
-                                                                   uu___18
-                                                                   orig_arg.FStar_Syntax_Syntax.pos in
-                                                           let guards1 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               guards
-                                                               (FStar_Compiler_List.collect
-                                                                  (fun g ->
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.free_variables
-                                                                    g in
-                                                                    FStar_Compiler_List.contains
-                                                                    fv1
-                                                                    uu___18 in
-                                                                    if
-                                                                    uu___17
-                                                                    then
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.subst
-                                                                    g fv1 xv in
-                                                                    [uu___18]
-                                                                    else [])) in
-                                                           FStar_SMTEncoding_Util.mk_and_l
-                                                             guards1 in
-                                                         let uu___17 =
-                                                           let uu___18 =
-                                                             FStar_Compiler_List.zip
-                                                               args
-                                                               encoded_args in
-                                                           FStar_Compiler_List.fold_left
-                                                             (fun uu___19 ->
-                                                                fun uu___20
-                                                                  ->
-                                                                  match 
-                                                                    (uu___19,
-                                                                    uu___20)
-                                                                  with
-                                                                  | ((env2,
-                                                                    arg_vars,
-                                                                    eqns_or_guards,
-                                                                    i),
-                                                                    (orig_arg,
-                                                                    arg)) ->
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Syntax.new_bv
-                                                                    FStar_Pervasives_Native.None
-                                                                    FStar_Syntax_Syntax.tun in
-                                                                    FStar_SMTEncoding_Env.gen_term_var
-                                                                    env2
-                                                                    uu___22 in
-                                                                    (match uu___21
-                                                                    with
-                                                                    | 
-                                                                    (uu___22,
-                                                                    xv, env3)
-                                                                    ->
-                                                                    let eqns
-                                                                    =
-                                                                    if
-                                                                    i < n_tps
-                                                                    then
-                                                                    let uu___23
-                                                                    =
-                                                                    guards_for_parameter
-                                                                    (FStar_Pervasives_Native.fst
-                                                                    orig_arg)
-                                                                    arg xv in
-                                                                    uu___23
-                                                                    ::
-                                                                    eqns_or_guards
-                                                                    else
-                                                                    (let uu___24
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (arg, xv) in
-                                                                    uu___24
-                                                                    ::
-                                                                    eqns_or_guards) in
-                                                                    (env3,
-                                                                    (xv ::
-                                                                    arg_vars),
-                                                                    eqns,
-                                                                    (i +
-                                                                    Prims.int_one))))
-                                                             (env', [], [],
-                                                               Prims.int_zero)
-                                                             uu___18 in
-                                                         (match uu___17 with
-                                                          | (uu___18,
-                                                             arg_vars,
-                                                             elim_eqns_or_guards,
-                                                             uu___19) ->
-                                                              let arg_vars1 =
-                                                                FStar_Compiler_List.rev
-                                                                  arg_vars in
-                                                              let ty =
-                                                                FStar_SMTEncoding_EncodeTerm.maybe_curry_fvb
-                                                                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.p
-                                                                  encoded_head_fvb
-                                                                  arg_vars1 in
-                                                              let xvars1 =
-                                                                FStar_Compiler_List.map
-                                                                  FStar_SMTEncoding_Util.mkFreeV
-                                                                  vars in
-                                                              let dapp1 =
-                                                                FStar_SMTEncoding_Util.mkApp
-                                                                  (ddconstrsym,
-                                                                    xvars1) in
-                                                              let ty_pred =
-                                                                FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                                                  (FStar_Pervasives_Native.Some
-                                                                    s_fuel_tm)
-                                                                  dapp1 ty in
-                                                              let arg_binders
-                                                                =
-                                                                FStar_Compiler_List.map
-                                                                  FStar_SMTEncoding_Term.fv_of_term
-                                                                  arg_vars1 in
-                                                              let typing_inversion
-                                                                =
-                                                                let uu___20 =
-                                                                  let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (fuel_var,
-                                                                    FStar_SMTEncoding_Term.Fuel_sort) in
-                                                                    FStar_SMTEncoding_Env.add_fuel
-                                                                    uu___25
-                                                                    (FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    arg_binders) in
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    (FStar_Compiler_List.op_At
-                                                                    elim_eqns_or_guards
-                                                                    guards) in
-                                                                    (ty_pred,
-                                                                    uu___27) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___26 in
-                                                                    ([
-                                                                    [ty_pred]],
-                                                                    uu___24,
-                                                                    uu___25) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___22
-                                                                    uu___23 in
-                                                                  (uu___21,
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    "data constructor typing elim"),
-                                                                    (
-                                                                    Prims.op_Hat
-                                                                    "data_elim_"
-                                                                    ddconstrsym)) in
-                                                                FStar_SMTEncoding_Util.mkAssume
-                                                                  uu___20 in
-                                                              let lex_t =
-                                                                let uu___20 =
-                                                                  let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    FStar_Parser_Const.lex_t_lid in
-                                                                    (uu___22,
-                                                                    FStar_SMTEncoding_Term.Term_sort) in
-                                                                  FStar_SMTEncoding_Term.mk_fv
-                                                                    uu___21 in
-                                                                FStar_Compiler_Effect.op_Less_Bar
-                                                                  FStar_SMTEncoding_Util.mkFreeV
-                                                                  uu___20 in
-                                                              let subterm_ordering
-                                                                =
-                                                                let prec =
-                                                                  let uu___20
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    vars
-                                                                    (FStar_Compiler_List.mapi
-                                                                    (fun i ->
-                                                                    fun v ->
-                                                                    if
-                                                                    i < n_tps
-                                                                    then []
-                                                                    else
-                                                                    (let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    v in
-                                                                    FStar_SMTEncoding_Util.mk_Precedes
-                                                                    lex_t
-                                                                    lex_t
-                                                                    uu___23
-                                                                    dapp1 in
-                                                                    [uu___22]))) in
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___20
-                                                                    FStar_Compiler_List.flatten in
-                                                                let uu___20 =
-                                                                  let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (fuel_var,
-                                                                    FStar_SMTEncoding_Term.Fuel_sort) in
-                                                                    FStar_SMTEncoding_Env.add_fuel
-                                                                    uu___25
-                                                                    (FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    arg_binders) in
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    prec in
-                                                                    (ty_pred,
-                                                                    uu___27) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___26 in
-                                                                    ([
-                                                                    [ty_pred]],
-                                                                    uu___24,
-                                                                    uu___25) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___22
-                                                                    uu___23 in
-                                                                  (uu___21,
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    "subterm ordering"),
-                                                                    (
-                                                                    Prims.op_Hat
-                                                                    "subterm_ordering_"
-                                                                    ddconstrsym)) in
-                                                                FStar_SMTEncoding_Util.mkAssume
-                                                                  uu___20 in
-                                                              let uu___20 =
-                                                                let uu___21 =
-                                                                  FStar_Compiler_Util.first_N
-                                                                    n_tps
-                                                                    formals in
-                                                                match uu___21
-                                                                with
-                                                                | (uu___22,
-                                                                   formals')
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Compiler_Util.first_N
-                                                                    n_tps
-                                                                    vars in
-                                                                    (match uu___23
-                                                                    with
-                                                                    | 
-                                                                    (uu___24,
-                                                                    vars') ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun
-                                                                    uu___26
-                                                                    ->
-                                                                    fun
-                                                                    formal ->
-                                                                    fun var
-                                                                    ->
-                                                                    match uu___26
-                                                                    with
-                                                                    | 
-                                                                    (codomain_prec_l,
-                                                                    cod_decls)
-                                                                    ->
-                                                                    let rec binder_and_codomain_type
-                                                                    t2 =
-                                                                    let t3 =
-                                                                    FStar_Syntax_Util.unrefine
-                                                                    t2 in
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    t3 in
-                                                                    uu___28.FStar_Syntax_Syntax.n in
-                                                                    match uu___27
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_arrow
-                                                                    uu___28
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_Syntax_Util.unrefine
-                                                                    t3 in
-                                                                    FStar_Syntax_Util.arrow_formals_comp
-                                                                    uu___30 in
-                                                                    (match uu___29
-                                                                    with
-                                                                    | 
-                                                                    (bs, c)
-                                                                    ->
-                                                                    (match bs
-                                                                    with
-                                                                    | 
-                                                                    [] ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    uu___30
-                                                                    when
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Util.is_tot_or_gtot_comp
-                                                                    c in
-                                                                    Prims.op_Negation
-                                                                    uu___31
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    uu___30
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Util.is_lemma_comp
-                                                                    c in
-                                                                    if
-                                                                    uu___31
-                                                                    then
-                                                                    FStar_Pervasives_Native.None
-                                                                    else
-                                                                    (let t4 =
-                                                                    FStar_Syntax_Util.unrefine
-                                                                    (FStar_Syntax_Util.comp_result
-                                                                    c) in
-                                                                    let uu___33
-                                                                    =
-                                                                    (FStar_Syntax_Syntax.is_type
-                                                                    t4) ||
-                                                                    (FStar_Syntax_Util.is_sub_singleton
-                                                                    t4) in
-                                                                    if
-                                                                    uu___33
-                                                                    then
-                                                                    FStar_Pervasives_Native.None
-                                                                    else
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (bs, c))))
-                                                                    | 
-                                                                    uu___28
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Util.head_and_args
-                                                                    t3 in
-                                                                    (match uu___29
-                                                                    with
-                                                                    | 
-                                                                    (head1,
-                                                                    uu___30)
-                                                                    ->
-                                                                    let t' =
-                                                                    FStar_TypeChecker_Normalize.unfold_whnf'
-                                                                    [FStar_TypeChecker_Env.AllowUnboundUniverses;
-                                                                    FStar_TypeChecker_Env.EraseUniverses;
-                                                                    FStar_TypeChecker_Env.Unascribe;
-                                                                    FStar_TypeChecker_Env.Exclude
-                                                                    FStar_TypeChecker_Env.Zeta]
-                                                                    env'.FStar_SMTEncoding_Env.tcenv
-                                                                    t3 in
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Util.head_and_args
-                                                                    t' in
-                                                                    (match uu___31
-                                                                    with
-                                                                    | 
-                                                                    (head',
-                                                                    uu___32)
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Syntax_Util.eq_tm
-                                                                    head1
-                                                                    head' in
-                                                                    (match uu___33
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Util.Equal
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    FStar_Syntax_Util.NotEqual
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    uu___34
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    head1 in
-                                                                    uu___36.FStar_Syntax_Syntax.n in
-                                                                    (match uu___35
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_fvar
-                                                                    uu___36
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_name
-                                                                    uu___36
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_uinst
-                                                                    uu___36
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    uu___36
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None)))) in
-                                                                    let uu___27
-                                                                    =
-                                                                    binder_and_codomain_type
-                                                                    (formal.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    (match uu___27
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    (codomain_prec_l,
-                                                                    cod_decls)
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (bs, c)
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_SMTEncoding_EncodeTerm.encode_binders
-                                                                    FStar_Pervasives_Native.None
-                                                                    bs env' in
-                                                                    (match uu___28
-                                                                    with
-                                                                    | 
-                                                                    (bs',
-                                                                    guards',
-                                                                    _env',
-                                                                    bs_decls,
-                                                                    uu___29)
-                                                                    ->
-                                                                    let fun_app
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    var in
-                                                                    FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                                                    uu___30
-                                                                    bs' in
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_Precedes
-                                                                    lex_t
-                                                                    lex_t
-                                                                    fun_app
-                                                                    dapp1 in
-                                                                    [uu___36] in
-                                                                    [uu___35] in
-                                                                    let uu___35
-                                                                    =
-                                                                    let uu___36
-                                                                    =
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    (ty_pred'
-                                                                    ::
-                                                                    guards') in
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_Precedes
-                                                                    lex_t
-                                                                    lex_t
-                                                                    fun_app
-                                                                    dapp1 in
-                                                                    (uu___37,
-                                                                    uu___38) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___36 in
-                                                                    (uu___34,
-                                                                    bs',
-                                                                    uu___35) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___32
-                                                                    uu___33 in
-                                                                    uu___31
-                                                                    ::
-                                                                    codomain_prec_l in
-                                                                    (uu___30,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    bs_decls
-                                                                    cod_decls)))))
-                                                                    ([], [])
-                                                                    formals'
-                                                                    vars' in
-                                                                    (match uu___25
-                                                                    with
-                                                                    | 
-                                                                    (codomain_prec_l,
-                                                                    cod_decls)
-                                                                    ->
-                                                                    (match codomain_prec_l
-                                                                    with
-                                                                    | 
-                                                                    [] ->
-                                                                    ([],
-                                                                    cod_decls)
-                                                                    | 
-                                                                    uu___26
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (fuel_var,
-                                                                    FStar_SMTEncoding_Term.Fuel_sort) in
-                                                                    FStar_SMTEncoding_Env.add_fuel
-                                                                    uu___34
-                                                                    (FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    arg_binders) in
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    codomain_prec_l in
-                                                                    ([
-                                                                    [ty_pred]],
-                                                                    uu___33,
-                                                                    uu___34) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___31
-                                                                    uu___32 in
-                                                                    (uu___30,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "well-founded ordering on codomain"),
-                                                                    (Prims.op_Hat
-                                                                    "well_founded_ordering_on_codomain_"
-                                                                    ddconstrsym)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___29 in
-                                                                    [uu___28] in
-                                                                    (uu___27,
-                                                                    cod_decls)))) in
-                                                              (match uu___20
-                                                               with
-                                                               | (codomain_ordering,
-                                                                  codomain_decls)
-                                                                   ->
-                                                                   ((FStar_Compiler_List.op_At
-                                                                    arg_decls
-                                                                    codomain_decls),
-                                                                    (FStar_Compiler_List.op_At
-                                                                    [typing_inversion;
-                                                                    subterm_ordering]
-                                                                    codomain_ordering)))))
-                                                | FStar_Syntax_Syntax.Tm_fvar
-                                                    fv ->
-                                                    let encoded_head_fvb =
-                                                      FStar_SMTEncoding_Env.lookup_free_var_name
-                                                        env'
-                                                        fv.FStar_Syntax_Syntax.fv_name in
-                                                    let uu___12 =
-                                                      FStar_SMTEncoding_EncodeTerm.encode_args
-                                                        args env' in
-                                                    (match uu___12 with
-                                                     | (encoded_args,
-                                                        arg_decls) ->
-                                                         let guards_for_parameter
-                                                           orig_arg arg xv =
-                                                           let fv1 =
-                                                             match arg.FStar_SMTEncoding_Term.tm
-                                                             with
-                                                             | FStar_SMTEncoding_Term.FreeV
-                                                                 fv2 -> fv2
-                                                             | uu___13 ->
-                                                                 let uu___14
-                                                                   =
-                                                                   let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    orig_arg in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "Inductive type parameter %s must be a variable ; You may want to change it to an index."
-                                                                    uu___16 in
-                                                                   (FStar_Errors.Fatal_NonVariableInductiveTypeParameter,
-                                                                    uu___15) in
-                                                                 FStar_Errors.raise_error
-                                                                   uu___14
-                                                                   orig_arg.FStar_Syntax_Syntax.pos in
-                                                           let guards1 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               guards
-                                                               (FStar_Compiler_List.collect
-                                                                  (fun g ->
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.free_variables
-                                                                    g in
-                                                                    FStar_Compiler_List.contains
-                                                                    fv1
-                                                                    uu___14 in
-                                                                    if
-                                                                    uu___13
-                                                                    then
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.subst
-                                                                    g fv1 xv in
-                                                                    [uu___14]
-                                                                    else [])) in
-                                                           FStar_SMTEncoding_Util.mk_and_l
-                                                             guards1 in
-                                                         let uu___13 =
-                                                           let uu___14 =
-                                                             FStar_Compiler_List.zip
-                                                               args
-                                                               encoded_args in
-                                                           FStar_Compiler_List.fold_left
-                                                             (fun uu___15 ->
-                                                                fun uu___16
-                                                                  ->
-                                                                  match 
-                                                                    (uu___15,
-                                                                    uu___16)
-                                                                  with
-                                                                  | ((env2,
-                                                                    arg_vars,
-                                                                    eqns_or_guards,
-                                                                    i),
-                                                                    (orig_arg,
-                                                                    arg)) ->
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Syntax_Syntax.new_bv
-                                                                    FStar_Pervasives_Native.None
-                                                                    FStar_Syntax_Syntax.tun in
-                                                                    FStar_SMTEncoding_Env.gen_term_var
-                                                                    env2
-                                                                    uu___18 in
-                                                                    (match uu___17
-                                                                    with
-                                                                    | 
-                                                                    (uu___18,
-                                                                    xv, env3)
-                                                                    ->
-                                                                    let eqns
-                                                                    =
-                                                                    if
-                                                                    i < n_tps
-                                                                    then
-                                                                    let uu___19
-                                                                    =
-                                                                    guards_for_parameter
-                                                                    (FStar_Pervasives_Native.fst
-                                                                    orig_arg)
-                                                                    arg xv in
-                                                                    uu___19
-                                                                    ::
-                                                                    eqns_or_guards
-                                                                    else
-                                                                    (let uu___20
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (arg, xv) in
-                                                                    uu___20
-                                                                    ::
-                                                                    eqns_or_guards) in
-                                                                    (env3,
-                                                                    (xv ::
-                                                                    arg_vars),
-                                                                    eqns,
-                                                                    (i +
-                                                                    Prims.int_one))))
-                                                             (env', [], [],
-                                                               Prims.int_zero)
-                                                             uu___14 in
-                                                         (match uu___13 with
-                                                          | (uu___14,
-                                                             arg_vars,
-                                                             elim_eqns_or_guards,
-                                                             uu___15) ->
-                                                              let arg_vars1 =
-                                                                FStar_Compiler_List.rev
-                                                                  arg_vars in
-                                                              let ty =
-                                                                FStar_SMTEncoding_EncodeTerm.maybe_curry_fvb
-                                                                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.p
-                                                                  encoded_head_fvb
-                                                                  arg_vars1 in
-                                                              let xvars1 =
-                                                                FStar_Compiler_List.map
-                                                                  FStar_SMTEncoding_Util.mkFreeV
-                                                                  vars in
-                                                              let dapp1 =
-                                                                FStar_SMTEncoding_Util.mkApp
-                                                                  (ddconstrsym,
-                                                                    xvars1) in
-                                                              let ty_pred =
-                                                                FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                                                  (FStar_Pervasives_Native.Some
-                                                                    s_fuel_tm)
-                                                                  dapp1 ty in
-                                                              let arg_binders
-                                                                =
-                                                                FStar_Compiler_List.map
-                                                                  FStar_SMTEncoding_Term.fv_of_term
-                                                                  arg_vars1 in
-                                                              let typing_inversion
-                                                                =
-                                                                let uu___16 =
-                                                                  let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (fuel_var,
-                                                                    FStar_SMTEncoding_Term.Fuel_sort) in
-                                                                    FStar_SMTEncoding_Env.add_fuel
-                                                                    uu___21
-                                                                    (FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    arg_binders) in
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    (FStar_Compiler_List.op_At
-                                                                    elim_eqns_or_guards
-                                                                    guards) in
-                                                                    (ty_pred,
-                                                                    uu___23) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___22 in
-                                                                    ([
-                                                                    [ty_pred]],
-                                                                    uu___20,
-                                                                    uu___21) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___18
-                                                                    uu___19 in
-                                                                  (uu___17,
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    "data constructor typing elim"),
-                                                                    (
-                                                                    Prims.op_Hat
-                                                                    "data_elim_"
-                                                                    ddconstrsym)) in
-                                                                FStar_SMTEncoding_Util.mkAssume
-                                                                  uu___16 in
-                                                              let lex_t =
-                                                                let uu___16 =
-                                                                  let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    FStar_Parser_Const.lex_t_lid in
-                                                                    (uu___18,
-                                                                    FStar_SMTEncoding_Term.Term_sort) in
-                                                                  FStar_SMTEncoding_Term.mk_fv
-                                                                    uu___17 in
-                                                                FStar_Compiler_Effect.op_Less_Bar
-                                                                  FStar_SMTEncoding_Util.mkFreeV
-                                                                  uu___16 in
-                                                              let subterm_ordering
-                                                                =
-                                                                let prec =
-                                                                  let uu___16
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    vars
-                                                                    (FStar_Compiler_List.mapi
-                                                                    (fun i ->
-                                                                    fun v ->
-                                                                    if
-                                                                    i < n_tps
-                                                                    then []
-                                                                    else
-                                                                    (let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    v in
-                                                                    FStar_SMTEncoding_Util.mk_Precedes
-                                                                    lex_t
-                                                                    lex_t
-                                                                    uu___19
-                                                                    dapp1 in
-                                                                    [uu___18]))) in
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___16
-                                                                    FStar_Compiler_List.flatten in
-                                                                let uu___16 =
-                                                                  let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (fuel_var,
-                                                                    FStar_SMTEncoding_Term.Fuel_sort) in
-                                                                    FStar_SMTEncoding_Env.add_fuel
-                                                                    uu___21
-                                                                    (FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    arg_binders) in
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    prec in
-                                                                    (ty_pred,
-                                                                    uu___23) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___22 in
-                                                                    ([
-                                                                    [ty_pred]],
-                                                                    uu___20,
-                                                                    uu___21) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___18
-                                                                    uu___19 in
-                                                                  (uu___17,
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    "subterm ordering"),
-                                                                    (
-                                                                    Prims.op_Hat
-                                                                    "subterm_ordering_"
-                                                                    ddconstrsym)) in
-                                                                FStar_SMTEncoding_Util.mkAssume
-                                                                  uu___16 in
-                                                              let uu___16 =
-                                                                let uu___17 =
-                                                                  FStar_Compiler_Util.first_N
-                                                                    n_tps
-                                                                    formals in
-                                                                match uu___17
-                                                                with
-                                                                | (uu___18,
-                                                                   formals')
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Util.first_N
-                                                                    n_tps
-                                                                    vars in
-                                                                    (match uu___19
-                                                                    with
-                                                                    | 
-                                                                    (uu___20,
-                                                                    vars') ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun
-                                                                    uu___22
-                                                                    ->
-                                                                    fun
-                                                                    formal ->
-                                                                    fun var
-                                                                    ->
-                                                                    match uu___22
-                                                                    with
-                                                                    | 
-                                                                    (codomain_prec_l,
-                                                                    cod_decls)
-                                                                    ->
-                                                                    let rec binder_and_codomain_type
-                                                                    t2 =
-                                                                    let t3 =
-                                                                    FStar_Syntax_Util.unrefine
-                                                                    t2 in
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    t3 in
-                                                                    uu___24.FStar_Syntax_Syntax.n in
-                                                                    match uu___23
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_arrow
-                                                                    uu___24
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Util.unrefine
-                                                                    t3 in
-                                                                    FStar_Syntax_Util.arrow_formals_comp
-                                                                    uu___26 in
-                                                                    (match uu___25
-                                                                    with
-                                                                    | 
-                                                                    (bs, c)
-                                                                    ->
-                                                                    (match bs
-                                                                    with
-                                                                    | 
-                                                                    [] ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    uu___26
-                                                                    when
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Util.is_tot_or_gtot_comp
-                                                                    c in
-                                                                    Prims.op_Negation
-                                                                    uu___27
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    uu___26
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Util.is_lemma_comp
-                                                                    c in
-                                                                    if
-                                                                    uu___27
-                                                                    then
-                                                                    FStar_Pervasives_Native.None
-                                                                    else
-                                                                    (let t4 =
-                                                                    FStar_Syntax_Util.unrefine
-                                                                    (FStar_Syntax_Util.comp_result
-                                                                    c) in
-                                                                    let uu___29
-                                                                    =
-                                                                    (FStar_Syntax_Syntax.is_type
-                                                                    t4) ||
-                                                                    (FStar_Syntax_Util.is_sub_singleton
-                                                                    t4) in
-                                                                    if
-                                                                    uu___29
-                                                                    then
-                                                                    FStar_Pervasives_Native.None
-                                                                    else
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (bs, c))))
-                                                                    | 
-                                                                    uu___24
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Syntax_Util.head_and_args
-                                                                    t3 in
-                                                                    (match uu___25
-                                                                    with
-                                                                    | 
-                                                                    (head1,
-                                                                    uu___26)
-                                                                    ->
-                                                                    let t' =
-                                                                    FStar_TypeChecker_Normalize.unfold_whnf'
-                                                                    [FStar_TypeChecker_Env.AllowUnboundUniverses;
-                                                                    FStar_TypeChecker_Env.EraseUniverses;
-                                                                    FStar_TypeChecker_Env.Unascribe;
-                                                                    FStar_TypeChecker_Env.Exclude
-                                                                    FStar_TypeChecker_Env.Zeta]
-                                                                    env'.FStar_SMTEncoding_Env.tcenv
-                                                                    t3 in
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Util.head_and_args
-                                                                    t' in
-                                                                    (match uu___27
-                                                                    with
-                                                                    | 
-                                                                    (head',
-                                                                    uu___28)
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Util.eq_tm
-                                                                    head1
-                                                                    head' in
-                                                                    (match uu___29
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Util.Equal
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    FStar_Syntax_Util.NotEqual
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    uu___30
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    head1 in
-                                                                    uu___32.FStar_Syntax_Syntax.n in
-                                                                    (match uu___31
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_fvar
-                                                                    uu___32
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_name
-                                                                    uu___32
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_uinst
-                                                                    uu___32
-                                                                    ->
-                                                                    binder_and_codomain_type
-                                                                    t'
-                                                                    | 
-                                                                    uu___32
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None)))) in
-                                                                    let uu___23
-                                                                    =
-                                                                    binder_and_codomain_type
-                                                                    (formal.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    (match uu___23
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    (codomain_prec_l,
-                                                                    cod_decls)
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (bs, c)
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_SMTEncoding_EncodeTerm.encode_binders
-                                                                    FStar_Pervasives_Native.None
-                                                                    bs env' in
-                                                                    (match uu___24
-                                                                    with
-                                                                    | 
-                                                                    (bs',
-                                                                    guards',
-                                                                    _env',
-                                                                    bs_decls,
-                                                                    uu___25)
-                                                                    ->
-                                                                    let fun_app
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkFreeV
-                                                                    var in
-                                                                    FStar_SMTEncoding_EncodeTerm.mk_Apply
-                                                                    uu___26
-                                                                    bs' in
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_Precedes
-                                                                    lex_t
-                                                                    lex_t
-                                                                    fun_app
-                                                                    dapp1 in
-                                                                    [uu___32] in
-                                                                    [uu___31] in
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    (ty_pred'
-                                                                    ::
-                                                                    guards') in
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_Precedes
-                                                                    lex_t
-                                                                    lex_t
-                                                                    fun_app
-                                                                    dapp1 in
-                                                                    (uu___33,
-                                                                    uu___34) in
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    uu___32 in
-                                                                    (uu___30,
-                                                                    bs',
-                                                                    uu___31) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___28
-                                                                    uu___29 in
-                                                                    uu___27
-                                                                    ::
-                                                                    codomain_prec_l in
-                                                                    (uu___26,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    bs_decls
-                                                                    cod_decls)))))
-                                                                    ([], [])
-                                                                    formals'
-                                                                    vars' in
-                                                                    (match uu___21
-                                                                    with
-                                                                    | 
-                                                                    (codomain_prec_l,
-                                                                    cod_decls)
-                                                                    ->
-                                                                    (match codomain_prec_l
-                                                                    with
-                                                                    | 
-                                                                    [] ->
-                                                                    ([],
-                                                                    cod_decls)
-                                                                    | 
-                                                                    uu___22
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (fuel_var,
-                                                                    FStar_SMTEncoding_Term.Fuel_sort) in
-                                                                    FStar_SMTEncoding_Env.add_fuel
-                                                                    uu___30
-                                                                    (FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    arg_binders) in
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mk_and_l
-                                                                    codomain_prec_l in
-                                                                    ([
-                                                                    [ty_pred]],
-                                                                    uu___29,
-                                                                    uu___30) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___27
-                                                                    uu___28 in
-                                                                    (uu___26,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "well-founded ordering on codomain"),
-                                                                    (Prims.op_Hat
-                                                                    "well_founded_ordering_on_codomain_"
-                                                                    ddconstrsym)) in
-                                                                    FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___25 in
-                                                                    [uu___24] in
-                                                                    (uu___23,
-                                                                    cod_decls)))) in
-                                                              (match uu___16
-                                                               with
-                                                               | (codomain_ordering,
-                                                                  codomain_decls)
-                                                                   ->
-                                                                   ((FStar_Compiler_List.op_At
-                                                                    arg_decls
-                                                                    codomain_decls),
-                                                                    (FStar_Compiler_List.op_At
-                                                                    [typing_inversion;
-                                                                    subterm_ordering]
-                                                                    codomain_ordering)))))
-                                                | uu___12 ->
-                                                    ((let uu___14 =
-                                                        let uu___15 =
-                                                          let uu___16 =
-                                                            FStar_Syntax_Print.lid_to_string
-                                                              d in
-                                                          let uu___17 =
-                                                            FStar_Syntax_Print.term_to_string
-                                                              head in
-                                                          FStar_Compiler_Util.format2
-                                                            "Constructor %s builds an unexpected type %s\n"
-                                                            uu___16 uu___17 in
-                                                        (FStar_Errors.Warning_ConstructorBuildsUnexpectedType,
-                                                          uu___15) in
-                                                      FStar_Errors.log_issue
-                                                        se.FStar_Syntax_Syntax.sigrng
-                                                        uu___14);
-                                                     ([], []))) in
-                                         let uu___9 = encode_elim () in
-                                         (match uu___9 with
-                                          | (decls2, elim) ->
-                                              let data_cons_typing_intro_decl
-                                                =
-                                                let uu___10 =
-                                                  match t_res_tm.FStar_SMTEncoding_Term.tm
-                                                  with
-                                                  | FStar_SMTEncoding_Term.App
-                                                      (op, args) ->
-                                                      let uu___11 =
-                                                        FStar_Compiler_List.splitAt
-                                                          n_tps args in
-                                                      (match uu___11 with
-                                                       | (targs, iargs) ->
-                                                           let uu___12 =
-                                                             let uu___13 =
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 iargs
-                                                                 (FStar_Compiler_List.map
-                                                                    (
-                                                                    fun
-                                                                    uu___14
-                                                                    ->
-                                                                    FStar_SMTEncoding_Env.fresh_fvar
-                                                                    env1.FStar_SMTEncoding_Env.current_module_name
-                                                                    "i"
-                                                                    FStar_SMTEncoding_Term.Term_sort)) in
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               uu___13
-                                                               FStar_Compiler_List.split in
-                                                           (match uu___12
-                                                            with
-                                                            | (fresh_ivars,
-                                                               fresh_iargs)
-                                                                ->
-                                                                let additional_guards
-                                                                  =
-                                                                  let uu___13
-                                                                    =
-                                                                    FStar_Compiler_List.map2
-                                                                    (fun a ->
-                                                                    fun
-                                                                    fresh_a
-                                                                    ->
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (a,
-                                                                    fresh_a))
-                                                                    iargs
-                                                                    fresh_iargs in
-                                                                  FStar_SMTEncoding_Util.mk_and_l
-                                                                    uu___13 in
-                                                                let uu___13 =
-                                                                  FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    fuel_tm)
-                                                                    dapp
-                                                                    {
-                                                                    FStar_SMTEncoding_Term.tm
-                                                                    =
-                                                                    (FStar_SMTEncoding_Term.App
-                                                                    (op,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    targs
-                                                                    fresh_iargs)));
-                                                                    FStar_SMTEncoding_Term.freevars
-                                                                    =
-                                                                    (t_res_tm.FStar_SMTEncoding_Term.freevars);
-                                                                    FStar_SMTEncoding_Term.rng
-                                                                    =
-                                                                    (t_res_tm.FStar_SMTEncoding_Term.rng)
-                                                                    } in
-                                                                let uu___14 =
-                                                                  let uu___15
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    fresh_ivars
-                                                                    (FStar_Compiler_List.map
-                                                                    (fun s ->
-                                                                    FStar_SMTEncoding_Term.mk_fv
-                                                                    (s,
-                                                                    FStar_SMTEncoding_Term.Term_sort))) in
-                                                                  FStar_Compiler_List.op_At
-                                                                    vars
-                                                                    uu___15 in
-                                                                let uu___15 =
-                                                                  FStar_SMTEncoding_Util.mkAnd
-                                                                    (guard,
-                                                                    additional_guards) in
-                                                                (uu___13,
-                                                                  uu___14,
-                                                                  uu___15)))
-                                                  | uu___11 ->
-                                                      (ty_pred', vars, guard) in
-                                                match uu___10 with
-                                                | (ty_pred'1, vars1, guard1)
-                                                    ->
-                                                    let uu___11 =
-                                                      let uu___12 =
-                                                        let uu___13 =
-                                                          FStar_Ident.range_of_lid
-                                                            d in
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              FStar_SMTEncoding_Term.mk_fv
-                                                                (fuel_var,
-                                                                  FStar_SMTEncoding_Term.Fuel_sort) in
-                                                            FStar_SMTEncoding_Env.add_fuel
-                                                              uu___16 vars1 in
-                                                          let uu___16 =
-                                                            FStar_SMTEncoding_Util.mkImp
-                                                              (guard1,
-                                                                ty_pred'1) in
-                                                          ([[ty_pred'1]],
-                                                            uu___15, uu___16) in
-                                                        FStar_SMTEncoding_Term.mkForall
-                                                          uu___13 uu___14 in
-                                                      (uu___12,
-                                                        (FStar_Pervasives_Native.Some
-                                                           "data constructor typing intro"),
-                                                        (Prims.op_Hat
-                                                           "data_typing_intro_"
-                                                           ddtok)) in
-                                                    FStar_SMTEncoding_Util.mkAssume
-                                                      uu___11 in
-                                              let g =
-                                                let uu___10 =
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              let uu___17 =
-                                                                let uu___18 =
-                                                                  let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.lid_to_string
-                                                                    d in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "data constructor proxy: %s"
-                                                                    uu___20 in
-                                                                  FStar_Pervasives_Native.Some
-                                                                    uu___19 in
-                                                                (ddtok, [],
-                                                                  FStar_SMTEncoding_Term.Term_sort,
-                                                                  uu___18) in
-                                                              FStar_SMTEncoding_Term.DeclFun
-                                                                uu___17 in
-                                                            [uu___16] in
-                                                          FStar_Compiler_List.op_At
-                                                            uu___15
-                                                            proxy_fresh in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___14
-                                                          FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                      let uu___14 =
-                                                        let uu___15 =
-                                                          let uu___16 =
-                                                            let uu___17 =
-                                                              let uu___18 =
-                                                                FStar_SMTEncoding_Util.mkAssume
-                                                                  (tok_typing1,
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    "typing for data constructor proxy"),
-                                                                    (
-                                                                    Prims.op_Hat
-                                                                    "typing_tok_"
-                                                                    ddtok)) in
-                                                              let uu___19 =
-                                                                let uu___20 =
-                                                                  let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Ident.range_of_lid
-                                                                    d in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkEq
-                                                                    (app,
-                                                                    dapp) in
-                                                                    ([[app]],
-                                                                    vars,
-                                                                    uu___25) in
-                                                                    FStar_SMTEncoding_Term.mkForall
-                                                                    uu___23
-                                                                    uu___24 in
-                                                                    (uu___22,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "equality for proxy"),
-                                                                    (Prims.op_Hat
-                                                                    "equality_tok_"
-                                                                    ddtok)) in
-                                                                  FStar_SMTEncoding_Util.mkAssume
-                                                                    uu___21 in
-                                                                [uu___20;
-                                                                data_cons_typing_intro_decl] in
-                                                              uu___18 ::
-                                                                uu___19 in
-                                                            FStar_Compiler_List.op_At
-                                                              uu___17 elim in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___16
-                                                            FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                        FStar_Compiler_List.op_At
-                                                          decls_pred uu___15 in
-                                                      FStar_Compiler_List.op_At
-                                                        uu___13 uu___14 in
-                                                    FStar_Compiler_List.op_At
-                                                      decls3 uu___12 in
-                                                  FStar_Compiler_List.op_At
-                                                    decls2 uu___11 in
-                                                FStar_Compiler_List.op_At
-                                                  binder_decls uu___10 in
-                                              let uu___10 =
-                                                let uu___11 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    datacons
-                                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                FStar_Compiler_List.op_At
-                                                  uu___11 g in
-                                              (uu___10, env1)))))))))
-and (encode_sigelts :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun ses ->
-      FStar_Compiler_Effect.op_Bar_Greater ses
-        (FStar_Compiler_List.fold_left
-           (fun uu___ ->
-              fun se ->
-                match uu___ with
-                | (g, env1) ->
-                    let uu___1 = encode_sigelt env1 se in
-                    (match uu___1 with
-                     | (g', env2) -> ((FStar_Compiler_List.op_At g g'), env2)))
-           ([], env))
-let (encode_env_bindings :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.binding Prims.list ->
-      (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun bindings ->
-      let encode_binding b uu___ =
-        match uu___ with
-        | (i, decls, env1) ->
-            (match b with
-             | FStar_Syntax_Syntax.Binding_univ uu___1 ->
-                 ((i + Prims.int_one), decls, env1)
-             | FStar_Syntax_Syntax.Binding_var x ->
-                 let t1 =
-                   norm_before_encoding env1 x.FStar_Syntax_Syntax.sort in
-                 ((let uu___2 =
-                     FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_TypeChecker_Env.debug
-                          env1.FStar_SMTEncoding_Env.tcenv)
-                       (FStar_Options.Other "SMTEncoding") in
-                   if uu___2
-                   then
-                     let uu___3 = FStar_Syntax_Print.bv_to_string x in
-                     let uu___4 =
-                       FStar_Syntax_Print.term_to_string
-                         x.FStar_Syntax_Syntax.sort in
-                     let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.print3 "Normalized %s : %s to %s\n"
-                       uu___3 uu___4 uu___5
-                   else ());
-                  (let uu___2 =
-                     FStar_SMTEncoding_EncodeTerm.encode_term t1 env1 in
-                   match uu___2 with
-                   | (t, decls') ->
-                       let t_hash = FStar_SMTEncoding_Term.hash_of_term t in
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Compiler_Util.digest_of_string t_hash in
-                             Prims.op_Hat uu___6
-                               (Prims.op_Hat "_" (Prims.string_of_int i)) in
-                           Prims.op_Hat "x_" uu___5 in
-                         FStar_SMTEncoding_Env.new_term_constant_from_string
-                           env1 x uu___4 in
-                       (match uu___3 with
-                        | (xxsym, xx, env') ->
-                            let t2 =
-                              FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                FStar_Pervasives_Native.None xx t in
-                            let caption =
-                              let uu___4 = FStar_Options.log_queries () in
-                              if uu___4
-                              then
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Syntax_Print.bv_to_string x in
-                                  let uu___7 =
-                                    FStar_Syntax_Print.term_to_string
-                                      x.FStar_Syntax_Syntax.sort in
-                                  let uu___8 =
-                                    FStar_Syntax_Print.term_to_string t1 in
-                                  FStar_Compiler_Util.format3 "%s : %s (%s)"
-                                    uu___6 uu___7 uu___8 in
-                                FStar_Pervasives_Native.Some uu___5
-                              else FStar_Pervasives_Native.None in
-                            let ax =
-                              let a_name = Prims.op_Hat "binder_" xxsym in
-                              FStar_SMTEncoding_Util.mkAssume
-                                (t2, (FStar_Pervasives_Native.Some a_name),
-                                  a_name) in
-                            let g =
-                              let uu___4 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  [FStar_SMTEncoding_Term.DeclFun
-                                     (xxsym, [],
-                                       FStar_SMTEncoding_Term.Term_sort,
-                                       caption)]
-                                  FStar_SMTEncoding_Term.mk_decls_trivial in
-                              let uu___5 =
-                                let uu___6 =
-                                  FStar_Compiler_Effect.op_Bar_Greater 
-                                    [ax]
-                                    FStar_SMTEncoding_Term.mk_decls_trivial in
-                                FStar_Compiler_List.op_At decls' uu___6 in
-                              FStar_Compiler_List.op_At uu___4 uu___5 in
-                            ((i + Prims.int_one),
-                              (FStar_Compiler_List.op_At decls g), env'))))
-             | FStar_Syntax_Syntax.Binding_lid (x, (uu___1, t)) ->
-                 let t_norm = norm_before_encoding env1 t in
-                 let fv =
-                   FStar_Syntax_Syntax.lid_as_fv x
-                     FStar_Syntax_Syntax.delta_constant
-                     FStar_Pervasives_Native.None in
-                 let uu___2 = encode_free_var false env1 fv t t_norm [] in
-                 (match uu___2 with
-                  | (g, env') ->
-                      ((i + Prims.int_one),
-                        (FStar_Compiler_List.op_At decls g), env'))) in
-      let uu___ =
-        FStar_Compiler_List.fold_right encode_binding bindings
-          (Prims.int_zero, [], env) in
-      match uu___ with | (uu___1, decls, env1) -> (decls, env1)
-let (encode_labels :
-  FStar_SMTEncoding_Term.error_label Prims.list ->
-    (FStar_SMTEncoding_Term.decl Prims.list * FStar_SMTEncoding_Term.decl
-      Prims.list))
-  =
-  fun labs ->
-    let prefix =
-      FStar_Compiler_Effect.op_Bar_Greater labs
-        (FStar_Compiler_List.map
-           (fun uu___ ->
-              match uu___ with
-              | (l, uu___1, uu___2) ->
-                  let uu___3 =
-                    let uu___4 = FStar_SMTEncoding_Term.fv_name l in
-                    (uu___4, [], FStar_SMTEncoding_Term.Bool_sort,
-                      FStar_Pervasives_Native.None) in
-                  FStar_SMTEncoding_Term.DeclFun uu___3)) in
-    let suffix =
-      FStar_Compiler_Effect.op_Bar_Greater labs
-        (FStar_Compiler_List.collect
-           (fun uu___ ->
-              match uu___ with
-              | (l, uu___1, uu___2) ->
-                  let uu___3 =
-                    let uu___4 = FStar_SMTEncoding_Term.fv_name l in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_SMTEncoding_Term.Echo uu___5)
-                      uu___4 in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = FStar_SMTEncoding_Util.mkFreeV l in
-                      FStar_SMTEncoding_Term.Eval uu___6 in
-                    [uu___5] in
-                  uu___3 :: uu___4)) in
-    (prefix, suffix)
-let (last_env :
-  FStar_SMTEncoding_Env.env_t Prims.list FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let (init_env : FStar_TypeChecker_Env.env -> unit) =
-  fun tcenv ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_Compiler_Util.psmap_empty () in
-        let uu___3 =
-          let uu___4 = FStar_Compiler_Util.psmap_empty () in (uu___4, []) in
-        let uu___4 =
-          let uu___5 = FStar_TypeChecker_Env.current_module tcenv in
-          FStar_Compiler_Effect.op_Bar_Greater uu___5
-            FStar_Ident.string_of_lid in
-        let uu___5 = FStar_Compiler_Util.smap_create (Prims.of_int (100)) in
-        {
-          FStar_SMTEncoding_Env.bvar_bindings = uu___2;
-          FStar_SMTEncoding_Env.fvar_bindings = uu___3;
-          FStar_SMTEncoding_Env.depth = Prims.int_zero;
-          FStar_SMTEncoding_Env.tcenv = tcenv;
-          FStar_SMTEncoding_Env.warn = true;
-          FStar_SMTEncoding_Env.nolabels = false;
-          FStar_SMTEncoding_Env.use_zfuel_name = false;
-          FStar_SMTEncoding_Env.encode_non_total_function_typ = true;
-          FStar_SMTEncoding_Env.current_module_name = uu___4;
-          FStar_SMTEncoding_Env.encoding_quantifier = false;
-          FStar_SMTEncoding_Env.global_cache = uu___5
-        } in
-      [uu___1] in
-    FStar_Compiler_Effect.op_Colon_Equals last_env uu___
-let (get_env :
-  FStar_Ident.lident ->
-    FStar_TypeChecker_Env.env -> FStar_SMTEncoding_Env.env_t)
-  =
-  fun cmn ->
-    fun tcenv ->
-      let uu___ = FStar_Compiler_Effect.op_Bang last_env in
-      match uu___ with
-      | [] -> failwith "No env; call init first!"
-      | e::uu___1 ->
-          let uu___2 = FStar_Ident.string_of_lid cmn in
-          {
-            FStar_SMTEncoding_Env.bvar_bindings =
-              (e.FStar_SMTEncoding_Env.bvar_bindings);
-            FStar_SMTEncoding_Env.fvar_bindings =
-              (e.FStar_SMTEncoding_Env.fvar_bindings);
-            FStar_SMTEncoding_Env.depth = (e.FStar_SMTEncoding_Env.depth);
-            FStar_SMTEncoding_Env.tcenv = tcenv;
-            FStar_SMTEncoding_Env.warn = (e.FStar_SMTEncoding_Env.warn);
-            FStar_SMTEncoding_Env.nolabels =
-              (e.FStar_SMTEncoding_Env.nolabels);
-            FStar_SMTEncoding_Env.use_zfuel_name =
-              (e.FStar_SMTEncoding_Env.use_zfuel_name);
-            FStar_SMTEncoding_Env.encode_non_total_function_typ =
-              (e.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-            FStar_SMTEncoding_Env.current_module_name = uu___2;
-            FStar_SMTEncoding_Env.encoding_quantifier =
-              (e.FStar_SMTEncoding_Env.encoding_quantifier);
-            FStar_SMTEncoding_Env.global_cache =
-              (e.FStar_SMTEncoding_Env.global_cache)
-          }
-let (set_env : FStar_SMTEncoding_Env.env_t -> unit) =
-  fun env ->
-    let uu___ = FStar_Compiler_Effect.op_Bang last_env in
-    match uu___ with
-    | [] -> failwith "Empty env stack"
-    | uu___1::tl ->
-        FStar_Compiler_Effect.op_Colon_Equals last_env (env :: tl)
-let (push_env : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang last_env in
-    match uu___1 with
-    | [] -> failwith "Empty env stack"
-    | hd::tl ->
-        let top = copy_env hd in
-        FStar_Compiler_Effect.op_Colon_Equals last_env (top :: hd :: tl)
-let (pop_env : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang last_env in
-    match uu___1 with
-    | [] -> failwith "Popping an empty stack"
-    | uu___2::tl -> FStar_Compiler_Effect.op_Colon_Equals last_env tl
-let (snapshot_env : unit -> (Prims.int * unit)) =
-  fun uu___ -> FStar_Common.snapshot push_env last_env ()
-let (rollback_env : Prims.int FStar_Pervasives_Native.option -> unit) =
-  fun depth -> FStar_Common.rollback pop_env last_env depth
-let (init : FStar_TypeChecker_Env.env -> unit) =
-  fun tcenv ->
-    init_env tcenv;
-    FStar_SMTEncoding_Z3.init ();
-    FStar_SMTEncoding_Z3.giveZ3 [FStar_SMTEncoding_Term.DefPrelude]
-let (snapshot :
-  Prims.string -> (FStar_TypeChecker_Env.solver_depth_t * unit)) =
-  fun msg ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         let uu___1 = snapshot_env () in
-         match uu___1 with
-         | (env_depth, ()) ->
-             let uu___2 =
-               FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.snapshot () in
-             (match uu___2 with
-              | (varops_depth, ()) ->
-                  let uu___3 = FStar_SMTEncoding_Z3.snapshot msg in
-                  (match uu___3 with
-                   | (z3_depth, ()) ->
-                       ((env_depth, varops_depth, z3_depth), ()))))
-let (rollback :
-  Prims.string ->
-    FStar_TypeChecker_Env.solver_depth_t FStar_Pervasives_Native.option ->
-      unit)
-  =
-  fun msg ->
-    fun depth ->
-      FStar_Compiler_Util.atomically
-        (fun uu___ ->
-           let uu___1 =
-             match depth with
-             | FStar_Pervasives_Native.Some (s1, s2, s3) ->
-                 ((FStar_Pervasives_Native.Some s1),
-                   (FStar_Pervasives_Native.Some s2),
-                   (FStar_Pervasives_Native.Some s3))
-             | FStar_Pervasives_Native.None ->
-                 (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None,
-                   FStar_Pervasives_Native.None) in
-           match uu___1 with
-           | (env_depth, varops_depth, z3_depth) ->
-               (rollback_env env_depth;
-                FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.rollback
-                  varops_depth;
-                FStar_SMTEncoding_Z3.rollback msg z3_depth))
-let (push : Prims.string -> unit) = fun msg -> let uu___ = snapshot msg in ()
-let (pop : Prims.string -> unit) =
-  fun msg -> rollback msg FStar_Pervasives_Native.None
-let (open_fact_db_tags :
-  FStar_SMTEncoding_Env.env_t -> FStar_SMTEncoding_Term.fact_db_id Prims.list)
-  = fun env -> []
-let (place_decl_in_fact_dbs :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_SMTEncoding_Term.fact_db_id Prims.list ->
-      FStar_SMTEncoding_Term.decl -> FStar_SMTEncoding_Term.decl)
-  =
-  fun env ->
-    fun fact_db_ids ->
-      fun d ->
-        match (fact_db_ids, d) with
-        | (uu___::uu___1, FStar_SMTEncoding_Term.Assume a) ->
-            FStar_SMTEncoding_Term.Assume
-              {
-                FStar_SMTEncoding_Term.assumption_term =
-                  (a.FStar_SMTEncoding_Term.assumption_term);
-                FStar_SMTEncoding_Term.assumption_caption =
-                  (a.FStar_SMTEncoding_Term.assumption_caption);
-                FStar_SMTEncoding_Term.assumption_name =
-                  (a.FStar_SMTEncoding_Term.assumption_name);
-                FStar_SMTEncoding_Term.assumption_fact_ids = fact_db_ids
-              }
-        | uu___ -> d
-let (place_decl_elt_in_fact_dbs :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_SMTEncoding_Term.fact_db_id Prims.list ->
-      FStar_SMTEncoding_Term.decls_elt -> FStar_SMTEncoding_Term.decls_elt)
-  =
-  fun env ->
-    fun fact_db_ids ->
-      fun elt ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater
-            elt.FStar_SMTEncoding_Term.decls
-            (FStar_Compiler_List.map (place_decl_in_fact_dbs env fact_db_ids)) in
-        {
-          FStar_SMTEncoding_Term.sym_name =
-            (elt.FStar_SMTEncoding_Term.sym_name);
-          FStar_SMTEncoding_Term.key = (elt.FStar_SMTEncoding_Term.key);
-          FStar_SMTEncoding_Term.decls = uu___;
-          FStar_SMTEncoding_Term.a_names =
-            (elt.FStar_SMTEncoding_Term.a_names)
-        }
-let (fact_dbs_for_lid :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Ident.lid -> FStar_SMTEncoding_Term.fact_db_id Prims.list)
-  =
-  fun env ->
-    fun lid ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Ident.ns_of_lid lid in
-            FStar_Ident.lid_of_ids uu___3 in
-          FStar_SMTEncoding_Term.Namespace uu___2 in
-        let uu___2 = open_fact_db_tags env in uu___1 :: uu___2 in
-      (FStar_SMTEncoding_Term.Name lid) :: uu___
-let (encode_top_level_facts :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_SMTEncoding_Term.decls_elt Prims.list *
-        FStar_SMTEncoding_Env.env_t))
-  =
-  fun env ->
-    fun se ->
-      let fact_db_ids =
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Syntax_Util.lids_of_sigelt se)
-          (FStar_Compiler_List.collect (fact_dbs_for_lid env)) in
-      let uu___ = encode_sigelt env se in
-      match uu___ with
-      | (g, env1) ->
-          let g1 =
-            FStar_Compiler_Effect.op_Bar_Greater g
-              (FStar_Compiler_List.map
-                 (place_decl_elt_in_fact_dbs env1 fact_db_ids)) in
-          (g1, env1)
-let (recover_caching_and_update_env :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_SMTEncoding_Term.decls_t -> FStar_SMTEncoding_Term.decls_t)
-  =
-  fun env ->
-    fun decls ->
-      FStar_Compiler_Effect.op_Bar_Greater decls
-        (FStar_Compiler_List.collect
-           (fun elt ->
-              if
-                elt.FStar_SMTEncoding_Term.key = FStar_Pervasives_Native.None
-              then [elt]
-              else
-                (let uu___1 =
-                   let uu___2 =
-                     FStar_Compiler_Effect.op_Bar_Greater
-                       elt.FStar_SMTEncoding_Term.key
-                       FStar_Compiler_Util.must in
-                   FStar_Compiler_Util.smap_try_find
-                     env.FStar_SMTEncoding_Env.global_cache uu___2 in
-                 match uu___1 with
-                 | FStar_Pervasives_Native.Some cache_elt ->
-                     FStar_Compiler_Effect.op_Bar_Greater
-                       [FStar_SMTEncoding_Term.RetainAssumptions
-                          (cache_elt.FStar_SMTEncoding_Term.a_names)]
-                       FStar_SMTEncoding_Term.mk_decls_trivial
-                 | FStar_Pervasives_Native.None ->
-                     ((let uu___3 =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           elt.FStar_SMTEncoding_Term.key
-                           FStar_Compiler_Util.must in
-                       FStar_Compiler_Util.smap_add
-                         env.FStar_SMTEncoding_Env.global_cache uu___3 elt);
-                      [elt]))))
-let (encode_sig :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun tcenv ->
-    fun se ->
-      let caption decls =
-        let uu___ = FStar_Options.log_queries () in
-        if uu___
-        then
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  FStar_Compiler_Effect.op_Bar_Greater
-                    (FStar_Syntax_Util.lids_of_sigelt se)
-                    (FStar_Compiler_List.map FStar_Syntax_Print.lid_to_string) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                  (FStar_String.concat ", ") in
-              Prims.op_Hat "encoding sigelt " uu___3 in
-            FStar_SMTEncoding_Term.Caption uu___2 in
-          uu___1 :: decls
-        else decls in
-      (let uu___1 = FStar_TypeChecker_Env.debug tcenv FStar_Options.Medium in
-       if uu___1
-       then
-         let uu___2 = FStar_Syntax_Print.sigelt_to_string se in
-         FStar_Compiler_Util.print1 "+++++++++++Encoding sigelt %s\n" uu___2
-       else ());
-      (let env =
-         let uu___1 = FStar_TypeChecker_Env.current_module tcenv in
-         get_env uu___1 tcenv in
-       let uu___1 = encode_top_level_facts env se in
-       match uu___1 with
-       | (decls, env1) ->
-           (set_env env1;
-            (let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_Effect.op_Bar_Greater decls
-                     (recover_caching_and_update_env env1) in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                   FStar_SMTEncoding_Term.decls_list_of in
-               caption uu___4 in
-             FStar_SMTEncoding_Z3.giveZ3 uu___3)))
-let (give_decls_to_z3_and_set_env :
-  FStar_SMTEncoding_Env.env_t ->
-    Prims.string -> FStar_SMTEncoding_Term.decls_t -> unit)
-  =
-  fun env ->
-    fun name ->
-      fun decls ->
-        let caption decls1 =
-          let uu___ = FStar_Options.log_queries () in
-          if uu___
-          then
-            let msg = Prims.op_Hat "Externals for " name in
-            [FStar_SMTEncoding_Term.Module
-               (name,
-                 (FStar_Compiler_List.op_At
-                    ((FStar_SMTEncoding_Term.Caption msg) :: decls1)
-                    [FStar_SMTEncoding_Term.Caption (Prims.op_Hat "End " msg)]))]
-          else [FStar_SMTEncoding_Term.Module (name, decls1)] in
-        set_env
-          {
-            FStar_SMTEncoding_Env.bvar_bindings =
-              (env.FStar_SMTEncoding_Env.bvar_bindings);
-            FStar_SMTEncoding_Env.fvar_bindings =
-              (env.FStar_SMTEncoding_Env.fvar_bindings);
-            FStar_SMTEncoding_Env.depth = (env.FStar_SMTEncoding_Env.depth);
-            FStar_SMTEncoding_Env.tcenv = (env.FStar_SMTEncoding_Env.tcenv);
-            FStar_SMTEncoding_Env.warn = true;
-            FStar_SMTEncoding_Env.nolabels =
-              (env.FStar_SMTEncoding_Env.nolabels);
-            FStar_SMTEncoding_Env.use_zfuel_name =
-              (env.FStar_SMTEncoding_Env.use_zfuel_name);
-            FStar_SMTEncoding_Env.encode_non_total_function_typ =
-              (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-            FStar_SMTEncoding_Env.current_module_name =
-              (env.FStar_SMTEncoding_Env.current_module_name);
-            FStar_SMTEncoding_Env.encoding_quantifier =
-              (env.FStar_SMTEncoding_Env.encoding_quantifier);
-            FStar_SMTEncoding_Env.global_cache =
-              (env.FStar_SMTEncoding_Env.global_cache)
-          };
-        (let z3_decls =
-           let uu___1 =
-             let uu___2 =
-               FStar_Compiler_Effect.op_Bar_Greater decls
-                 (recover_caching_and_update_env env) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___2
-               FStar_SMTEncoding_Term.decls_list_of in
-           caption uu___1 in
-         FStar_SMTEncoding_Z3.giveZ3 z3_decls)
-let (encode_modul :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul ->
-      (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.fvar_binding
-        Prims.list))
-  =
-  fun tcenv ->
-    fun modul ->
-      let uu___ = (FStar_Options.lax ()) && (FStar_Options.ml_ish ()) in
-      if uu___
-      then ([], [])
-      else
-        FStar_Syntax_Unionfind.with_uf_enabled
-          (fun uu___2 ->
-             FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.reset_fresh
-               ();
-             (let name =
-                let uu___4 =
-                  FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-                FStar_Compiler_Util.format2 "%s %s"
-                  (if modul.FStar_Syntax_Syntax.is_interface
-                   then "interface"
-                   else "module") uu___4 in
-              (let uu___5 =
-                 FStar_TypeChecker_Env.debug tcenv FStar_Options.Medium in
-               if uu___5
-               then
-                 let uu___6 =
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     (FStar_Compiler_List.length
-                        modul.FStar_Syntax_Syntax.declarations)
-                     Prims.string_of_int in
-                 FStar_Compiler_Util.print2
-                   "+++++++++++Encoding externals for %s ... %s declarations\n"
-                   name uu___6
-               else ());
-              (let env =
-                 let uu___5 = get_env modul.FStar_Syntax_Syntax.name tcenv in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                   FStar_SMTEncoding_Env.reset_current_module_fvbs in
-               let encode_signature env1 ses =
-                 FStar_Compiler_Effect.op_Bar_Greater ses
-                   (FStar_Compiler_List.fold_left
-                      (fun uu___5 ->
-                         fun se ->
-                           match uu___5 with
-                           | (g, env2) ->
-                               let uu___6 = encode_top_level_facts env2 se in
-                               (match uu___6 with
-                                | (g', env3) ->
-                                    ((FStar_Compiler_List.op_At g g'), env3)))
-                      ([], env1)) in
-               let uu___5 =
-                 encode_signature
-                   {
-                     FStar_SMTEncoding_Env.bvar_bindings =
-                       (env.FStar_SMTEncoding_Env.bvar_bindings);
-                     FStar_SMTEncoding_Env.fvar_bindings =
-                       (env.FStar_SMTEncoding_Env.fvar_bindings);
-                     FStar_SMTEncoding_Env.depth =
-                       (env.FStar_SMTEncoding_Env.depth);
-                     FStar_SMTEncoding_Env.tcenv =
-                       (env.FStar_SMTEncoding_Env.tcenv);
-                     FStar_SMTEncoding_Env.warn = false;
-                     FStar_SMTEncoding_Env.nolabels =
-                       (env.FStar_SMTEncoding_Env.nolabels);
-                     FStar_SMTEncoding_Env.use_zfuel_name =
-                       (env.FStar_SMTEncoding_Env.use_zfuel_name);
-                     FStar_SMTEncoding_Env.encode_non_total_function_typ =
-                       (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-                     FStar_SMTEncoding_Env.current_module_name =
-                       (env.FStar_SMTEncoding_Env.current_module_name);
-                     FStar_SMTEncoding_Env.encoding_quantifier =
-                       (env.FStar_SMTEncoding_Env.encoding_quantifier);
-                     FStar_SMTEncoding_Env.global_cache =
-                       (env.FStar_SMTEncoding_Env.global_cache)
-                   } modul.FStar_Syntax_Syntax.declarations in
-               match uu___5 with
-               | (decls, env1) ->
-                   (give_decls_to_z3_and_set_env env1 name decls;
-                    (let uu___8 =
-                       FStar_TypeChecker_Env.debug tcenv FStar_Options.Medium in
-                     if uu___8
-                     then
-                       FStar_Compiler_Util.print1
-                         "Done encoding externals for %s\n" name
-                     else ());
-                    (let uu___8 =
-                       FStar_Compiler_Effect.op_Bar_Greater env1
-                         FStar_SMTEncoding_Env.get_current_module_fvbs in
-                     (decls, uu___8))))))
-let (encode_modul_from_cache :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul ->
-      (FStar_SMTEncoding_Term.decls_t * FStar_SMTEncoding_Env.fvar_binding
-        Prims.list) -> unit)
-  =
-  fun tcenv ->
-    fun tcmod ->
-      fun uu___ ->
-        match uu___ with
-        | (decls, fvbs) ->
-            let uu___1 = (FStar_Options.lax ()) && (FStar_Options.ml_ish ()) in
-            if uu___1
-            then ()
-            else
-              (let name =
-                 let uu___3 =
-                   FStar_Ident.string_of_lid tcmod.FStar_Syntax_Syntax.name in
-                 FStar_Compiler_Util.format2 "%s %s"
-                   (if tcmod.FStar_Syntax_Syntax.is_interface
-                    then "interface"
-                    else "module") uu___3 in
-               (let uu___4 =
-                  FStar_TypeChecker_Env.debug tcenv FStar_Options.Medium in
-                if uu___4
-                then
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      (FStar_Compiler_List.length decls) Prims.string_of_int in
-                  FStar_Compiler_Util.print2
-                    "+++++++++++Encoding externals from cache for %s ... %s decls\n"
-                    name uu___5
-                else ());
-               (let env =
-                  let uu___4 = get_env tcmod.FStar_Syntax_Syntax.name tcenv in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    FStar_SMTEncoding_Env.reset_current_module_fvbs in
-                let env1 =
-                  let uu___4 =
-                    FStar_Compiler_Effect.op_Bar_Greater fvbs
-                      FStar_Compiler_List.rev in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (FStar_Compiler_List.fold_left
-                       (fun env2 ->
-                          fun fvb ->
-                            FStar_SMTEncoding_Env.add_fvar_binding_to_env fvb
-                              env2) env) in
-                give_decls_to_z3_and_set_env env1 name decls;
-                (let uu___5 =
-                   FStar_TypeChecker_Env.debug tcenv FStar_Options.Medium in
-                 if uu___5
-                 then
-                   FStar_Compiler_Util.print1
-                     "Done encoding externals from cache for %s\n" name
-                 else ())))
-let (encode_query :
-  (unit -> Prims.string) FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_SMTEncoding_Term.decl Prims.list *
-          FStar_SMTEncoding_ErrorReporting.label Prims.list *
-          FStar_SMTEncoding_Term.decl * FStar_SMTEncoding_Term.decl
-          Prims.list))
-  =
-  fun use_env_msg ->
-    fun tcenv ->
-      fun q ->
-        FStar_Errors.with_ctx "While encoding a query"
-          (fun uu___ ->
-             (let uu___2 =
-                let uu___3 = FStar_TypeChecker_Env.current_module tcenv in
-                FStar_Ident.string_of_lid uu___3 in
-              FStar_SMTEncoding_Z3.query_logging.FStar_SMTEncoding_Z3.set_module_name
-                uu___2);
-             (let env =
-                let uu___2 = FStar_TypeChecker_Env.current_module tcenv in
-                get_env uu___2 tcenv in
-              let uu___2 =
-                let rec aux bindings =
-                  match bindings with
-                  | (FStar_Syntax_Syntax.Binding_var x)::rest ->
-                      let uu___3 = aux rest in
-                      (match uu___3 with
-                       | (out, rest1) ->
-                           let t =
-                             let uu___4 =
-                               FStar_Syntax_Util.destruct_typ_as_formula
-                                 x.FStar_Syntax_Syntax.sort in
-                             match uu___4 with
-                             | FStar_Pervasives_Native.Some uu___5 ->
-                                 let uu___6 =
-                                   FStar_Syntax_Syntax.new_bv
-                                     FStar_Pervasives_Native.None
-                                     FStar_Syntax_Syntax.t_unit in
-                                 FStar_Syntax_Util.refine uu___6
-                                   x.FStar_Syntax_Syntax.sort
-                             | uu___5 -> x.FStar_Syntax_Syntax.sort in
-                           let t1 =
-                             norm_with_steps
-                               [FStar_TypeChecker_Env.Eager_unfolding;
-                               FStar_TypeChecker_Env.Beta;
-                               FStar_TypeChecker_Env.Simplify;
-                               FStar_TypeChecker_Env.Primops;
-                               FStar_TypeChecker_Env.EraseUniverses]
-                               env.FStar_SMTEncoding_Env.tcenv t in
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_Syntax_Syntax.mk_binder
-                                 {
-                                   FStar_Syntax_Syntax.ppname =
-                                     (x.FStar_Syntax_Syntax.ppname);
-                                   FStar_Syntax_Syntax.index =
-                                     (x.FStar_Syntax_Syntax.index);
-                                   FStar_Syntax_Syntax.sort = t1
-                                 } in
-                             uu___5 :: out in
-                           (uu___4, rest1))
-                  | uu___3 -> ([], bindings) in
-                let uu___3 = aux tcenv.FStar_TypeChecker_Env.gamma in
-                match uu___3 with
-                | (closing, bindings) ->
-                    let uu___4 =
-                      FStar_Syntax_Util.close_forall_no_univs
-                        (FStar_Compiler_List.rev closing) q in
-                    (uu___4, bindings) in
-              match uu___2 with
-              | (q1, bindings) ->
-                  let uu___3 = encode_env_bindings env bindings in
-                  (match uu___3 with
-                   | (env_decls, env1) ->
-                       ((let uu___5 =
-                           ((FStar_TypeChecker_Env.debug tcenv
-                               FStar_Options.Medium)
-                              ||
-                              (FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_TypeChecker_Env.debug tcenv)
-                                 (FStar_Options.Other "SMTEncoding")))
-                             ||
-                             (FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug tcenv)
-                                (FStar_Options.Other "SMTQuery")) in
-                         if uu___5
-                         then
-                           let uu___6 = FStar_Syntax_Print.term_to_string q1 in
-                           FStar_Compiler_Util.print1
-                             "Encoding query formula {: %s\n" uu___6
-                         else ());
-                        (let uu___5 =
-                           FStar_Compiler_Util.record_time
-                             (fun uu___6 ->
-                                FStar_SMTEncoding_EncodeTerm.encode_formula
-                                  q1 env1) in
-                         match uu___5 with
-                         | ((phi, qdecls), ms) ->
-                             let uu___6 =
-                               let uu___7 =
-                                 FStar_TypeChecker_Env.get_range tcenv in
-                               FStar_SMTEncoding_ErrorReporting.label_goals
-                                 use_env_msg uu___7 phi in
-                             (match uu___6 with
-                              | (labels, phi1) ->
-                                  let uu___7 = encode_labels labels in
-                                  (match uu___7 with
-                                   | (label_prefix, label_suffix) ->
-                                       let caption =
-                                         let uu___8 =
-                                           FStar_Options.log_queries () in
-                                         if uu___8
-                                         then
-                                           let uu___9 =
-                                             let uu___10 =
-                                               let uu___11 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   q1 in
-                                               Prims.op_Hat
-                                                 "Encoding query formula : "
-                                                 uu___11 in
-                                             FStar_SMTEncoding_Term.Caption
-                                               uu___10 in
-                                           [uu___9]
-                                         else [] in
-                                       let query_prelude =
-                                         let uu___8 =
-                                           let uu___9 =
-                                             let uu___10 =
-                                               let uu___11 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   label_prefix
-                                                   FStar_SMTEncoding_Term.mk_decls_trivial in
-                                               let uu___12 =
-                                                 let uu___13 =
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     caption
-                                                     FStar_SMTEncoding_Term.mk_decls_trivial in
-                                                 FStar_Compiler_List.op_At
-                                                   qdecls uu___13 in
-                                               FStar_Compiler_List.op_At
-                                                 uu___11 uu___12 in
-                                             FStar_Compiler_List.op_At
-                                               env_decls uu___10 in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___9
-                                             (recover_caching_and_update_env
-                                                env1) in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___8
-                                           FStar_SMTEncoding_Term.decls_list_of in
-                                       let qry =
-                                         let uu___8 =
-                                           let uu___9 =
-                                             FStar_SMTEncoding_Util.mkNot
-                                               phi1 in
-                                           let uu___10 =
-                                             FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.mk_unique
-                                               "@query" in
-                                           (uu___9,
-                                             (FStar_Pervasives_Native.Some
-                                                "query"), uu___10) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___8 in
-                                       let suffix =
-                                         FStar_Compiler_List.op_At
-                                           [FStar_SMTEncoding_Term.Echo
-                                              "<labels>"]
-                                           (FStar_Compiler_List.op_At
-                                              label_suffix
-                                              [FStar_SMTEncoding_Term.Echo
-                                                 "</labels>";
-                                              FStar_SMTEncoding_Term.Echo
-                                                "Done!"]) in
-                                       ((let uu___9 =
-                                           ((FStar_TypeChecker_Env.debug
-                                               tcenv FStar_Options.Medium)
-                                              ||
-                                              (FStar_Compiler_Effect.op_Less_Bar
-                                                 (FStar_TypeChecker_Env.debug
-                                                    tcenv)
-                                                 (FStar_Options.Other
-                                                    "SMTEncoding")))
-                                             ||
-                                             (FStar_Compiler_Effect.op_Less_Bar
-                                                (FStar_TypeChecker_Env.debug
-                                                   tcenv)
-                                                (FStar_Options.Other
-                                                   "SMTQuery")) in
-                                         if uu___9
-                                         then
-                                           FStar_Compiler_Util.print_string
-                                             "} Done encoding\n"
-                                         else ());
-                                        (let uu___10 =
-                                           (((FStar_TypeChecker_Env.debug
-                                                tcenv FStar_Options.Medium)
-                                               ||
-                                               (FStar_Compiler_Effect.op_Less_Bar
-                                                  (FStar_TypeChecker_Env.debug
-                                                     tcenv)
-                                                  (FStar_Options.Other
-                                                     "SMTEncoding")))
-                                              ||
-                                              (FStar_Compiler_Effect.op_Less_Bar
-                                                 (FStar_TypeChecker_Env.debug
-                                                    tcenv)
-                                                 (FStar_Options.Other
-                                                    "SMTQuery")))
-                                             ||
-                                             (FStar_Compiler_Effect.op_Less_Bar
-                                                (FStar_TypeChecker_Env.debug
-                                                   tcenv)
-                                                (FStar_Options.Other "Time")) in
-                                         if uu___10
-                                         then
-                                           FStar_Compiler_Util.print1
-                                             "Encoding took %sms\n"
-                                             (Prims.string_of_int ms)
-                                         else ());
-                                        (query_prelude, labels, qry, suffix)))))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_EncodeTerm.ml b/src/ocaml-output/FStar_SMTEncoding_EncodeTerm.ml
deleted file mode 100644
index 6eb51eb54e7..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_EncodeTerm.ml
+++ /dev/null
@@ -1,3958 +0,0 @@
-open Prims
-let mkForall_fuel' :
-  'uuuuu .
-    Prims.string ->
-      FStar_Compiler_Range.range ->
-        'uuuuu ->
-          (FStar_SMTEncoding_Term.pat Prims.list Prims.list *
-            FStar_SMTEncoding_Term.fvs * FStar_SMTEncoding_Term.term) ->
-            FStar_SMTEncoding_Term.term
-  =
-  fun mname ->
-    fun r ->
-      fun n ->
-        fun uu___ ->
-          match uu___ with
-          | (pats, vars, body) ->
-              let fallback uu___1 =
-                FStar_SMTEncoding_Term.mkForall r (pats, vars, body) in
-              let uu___1 = FStar_Options.unthrottle_inductives () in
-              if uu___1
-              then fallback ()
-              else
-                (let uu___3 =
-                   FStar_SMTEncoding_Env.fresh_fvar mname "f"
-                     FStar_SMTEncoding_Term.Fuel_sort in
-                 match uu___3 with
-                 | (fsym, fterm) ->
-                     let add_fuel tms =
-                       FStar_Compiler_Effect.op_Bar_Greater tms
-                         (FStar_Compiler_List.map
-                            (fun p ->
-                               match p.FStar_SMTEncoding_Term.tm with
-                               | FStar_SMTEncoding_Term.App
-                                   (FStar_SMTEncoding_Term.Var "HasType",
-                                    args)
-                                   ->
-                                   FStar_SMTEncoding_Util.mkApp
-                                     ("HasTypeFuel", (fterm :: args))
-                               | uu___4 -> p)) in
-                     let pats1 = FStar_Compiler_List.map add_fuel pats in
-                     let body1 =
-                       match body.FStar_SMTEncoding_Term.tm with
-                       | FStar_SMTEncoding_Term.App
-                           (FStar_SMTEncoding_Term.Imp, guard::body'::[]) ->
-                           let guard1 =
-                             match guard.FStar_SMTEncoding_Term.tm with
-                             | FStar_SMTEncoding_Term.App
-                                 (FStar_SMTEncoding_Term.And, guards) ->
-                                 let uu___4 = add_fuel guards in
-                                 FStar_SMTEncoding_Util.mk_and_l uu___4
-                             | uu___4 ->
-                                 let uu___5 = add_fuel [guard] in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                   FStar_Compiler_List.hd in
-                           FStar_SMTEncoding_Util.mkImp (guard1, body')
-                       | uu___4 -> body in
-                     let vars1 =
-                       let uu___4 =
-                         FStar_SMTEncoding_Term.mk_fv
-                           (fsym, FStar_SMTEncoding_Term.Fuel_sort) in
-                       uu___4 :: vars in
-                     FStar_SMTEncoding_Term.mkForall r (pats1, vars1, body1))
-let (mkForall_fuel :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      (FStar_SMTEncoding_Term.pat Prims.list Prims.list *
-        FStar_SMTEncoding_Term.fvs * FStar_SMTEncoding_Term.term) ->
-        FStar_SMTEncoding_Term.term)
-  = fun mname -> fun r -> mkForall_fuel' mname r Prims.int_one
-let (head_normal :
-  FStar_SMTEncoding_Env.env_t -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      let t1 = FStar_Syntax_Util.unmeta t in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_arrow uu___ -> true
-      | FStar_Syntax_Syntax.Tm_refine uu___ -> true
-      | FStar_Syntax_Syntax.Tm_bvar uu___ -> true
-      | FStar_Syntax_Syntax.Tm_uvar uu___ -> true
-      | FStar_Syntax_Syntax.Tm_abs uu___ -> true
-      | FStar_Syntax_Syntax.Tm_constant uu___ -> true
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let uu___ =
-            FStar_TypeChecker_Env.lookup_definition
-              [FStar_TypeChecker_Env.Eager_unfolding_only]
-              env.FStar_SMTEncoding_Env.tcenv
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Compiler_Option.isNone
-      | FStar_Syntax_Syntax.Tm_app
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___;
-             FStar_Syntax_Syntax.vars = uu___1;
-             FStar_Syntax_Syntax.hash_code = uu___2;_},
-           uu___3)
-          ->
-          let uu___4 =
-            FStar_TypeChecker_Env.lookup_definition
-              [FStar_TypeChecker_Env.Eager_unfolding_only]
-              env.FStar_SMTEncoding_Env.tcenv
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          FStar_Compiler_Effect.op_Bar_Greater uu___4
-            FStar_Compiler_Option.isNone
-      | uu___ -> false
-let (head_redex :
-  FStar_SMTEncoding_Env.env_t -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Util.un_uinst t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_abs
-          (uu___1, uu___2, FStar_Pervasives_Native.Some rc) ->
-          ((FStar_Ident.lid_equals rc.FStar_Syntax_Syntax.residual_effect
-              FStar_Parser_Const.effect_Tot_lid)
-             ||
-             (FStar_Ident.lid_equals rc.FStar_Syntax_Syntax.residual_effect
-                FStar_Parser_Const.effect_GTot_lid))
-            ||
-            (FStar_Compiler_List.existsb
-               (fun uu___3 ->
-                  match uu___3 with
-                  | FStar_Syntax_Syntax.TOTAL -> true
-                  | uu___4 -> false) rc.FStar_Syntax_Syntax.residual_flags)
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let uu___1 =
-            FStar_TypeChecker_Env.lookup_definition
-              [FStar_TypeChecker_Env.Eager_unfolding_only]
-              env.FStar_SMTEncoding_Env.tcenv
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_Option.isSome
-      | uu___1 -> false
-let (norm_with_steps :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun steps ->
-    fun env ->
-      fun t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module env in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 -> FStar_TypeChecker_Normalize.normalize steps env t)
-          uu___ "FStar.SMTEncoding.EncodeTerm.norm_with_steps"
-let (normalize_refinement :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun steps ->
-    fun env ->
-      fun t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module env in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 ->
-             FStar_TypeChecker_Normalize.normalize_refinement steps env t)
-          uu___ "FStar.SMTEncoding.EncodeTerm.normalize_refinement"
-let (whnf :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      let uu___ = head_normal env t in
-      if uu___
-      then t
-      else
-        norm_with_steps
-          [FStar_TypeChecker_Env.Beta;
-          FStar_TypeChecker_Env.Weak;
-          FStar_TypeChecker_Env.HNF;
-          FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-          FStar_TypeChecker_Env.Eager_unfolding;
-          FStar_TypeChecker_Env.EraseUniverses]
-          env.FStar_SMTEncoding_Env.tcenv t
-let (norm :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      norm_with_steps
-        [FStar_TypeChecker_Env.Beta;
-        FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-        FStar_TypeChecker_Env.Eager_unfolding;
-        FStar_TypeChecker_Env.EraseUniverses] env.FStar_SMTEncoding_Env.tcenv
-        t
-let (maybe_whnf :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t ->
-      let t' = whnf env t in
-      let uu___ = FStar_Syntax_Util.head_and_args t' in
-      match uu___ with
-      | (head', uu___1) ->
-          let uu___2 = head_redex env head' in
-          if uu___2
-          then FStar_Pervasives_Native.None
-          else FStar_Pervasives_Native.Some t'
-let (trivial_post : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ = let uu___1 = FStar_Syntax_Syntax.null_binder t in [uu___1] in
-    let uu___1 =
-      FStar_Syntax_Syntax.fvar FStar_Parser_Const.true_lid
-        FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-    FStar_Syntax_Util.abs uu___ uu___1 FStar_Pervasives_Native.None
-let (mk_Apply :
-  FStar_SMTEncoding_Term.term ->
-    FStar_SMTEncoding_Term.fvs -> FStar_SMTEncoding_Term.term)
-  =
-  fun e ->
-    fun vars ->
-      FStar_Compiler_Effect.op_Bar_Greater vars
-        (FStar_Compiler_List.fold_left
-           (fun out ->
-              fun var ->
-                let uu___ = FStar_SMTEncoding_Term.fv_sort var in
-                match uu___ with
-                | FStar_SMTEncoding_Term.Fuel_sort ->
-                    let uu___1 = FStar_SMTEncoding_Util.mkFreeV var in
-                    FStar_SMTEncoding_Term.mk_ApplyTF out uu___1
-                | s ->
-                    let uu___1 = FStar_SMTEncoding_Util.mkFreeV var in
-                    FStar_SMTEncoding_Util.mk_ApplyTT out uu___1) e)
-let (mk_Apply_args :
-  FStar_SMTEncoding_Term.term ->
-    FStar_SMTEncoding_Term.term Prims.list -> FStar_SMTEncoding_Term.term)
-  =
-  fun e ->
-    fun args ->
-      FStar_Compiler_Effect.op_Bar_Greater args
-        (FStar_Compiler_List.fold_left FStar_SMTEncoding_Util.mk_ApplyTT e)
-let raise_arity_mismatch :
-  'a .
-    Prims.string ->
-      Prims.int -> Prims.int -> FStar_Compiler_Range.range -> 'a
-  =
-  fun head ->
-    fun arity ->
-      fun n_args ->
-        fun rng ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Compiler_Util.string_of_int arity in
-              let uu___3 = FStar_Compiler_Util.string_of_int n_args in
-              FStar_Compiler_Util.format3
-                "Head symbol %s expects at least %s arguments; got only %s"
-                head uu___2 uu___3 in
-            (FStar_Errors.Fatal_SMTEncodingArityMismatch, uu___1) in
-          FStar_Errors.raise_error uu___ rng
-let (isTotFun_axioms :
-  FStar_Compiler_Range.range ->
-    FStar_SMTEncoding_Term.term ->
-      FStar_SMTEncoding_Term.fvs ->
-        FStar_SMTEncoding_Term.term Prims.list ->
-          Prims.bool -> FStar_SMTEncoding_Term.term)
-  =
-  fun pos ->
-    fun head ->
-      fun vars ->
-        fun guards ->
-          fun is_pure ->
-            let maybe_mkForall pat vars1 body =
-              match vars1 with
-              | [] -> body
-              | uu___ ->
-                  FStar_SMTEncoding_Term.mkForall pos (pat, vars1, body) in
-            let rec is_tot_fun_axioms ctx ctx_guard head1 vars1 guards1 =
-              match (vars1, guards1) with
-              | ([], []) -> FStar_SMTEncoding_Util.mkTrue
-              | (uu___::[], uu___1) ->
-                  if is_pure
-                  then
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = FStar_SMTEncoding_Term.mk_IsTotFun head1 in
-                        (ctx_guard, uu___4) in
-                      FStar_SMTEncoding_Util.mkImp uu___3 in
-                    maybe_mkForall [[head1]] ctx uu___2
-                  else FStar_SMTEncoding_Util.mkTrue
-              | (x::vars2, g_x::guards2) ->
-                  let is_tot_fun_head =
-                    let uu___ =
-                      let uu___1 =
-                        let uu___2 = FStar_SMTEncoding_Term.mk_IsTotFun head1 in
-                        (ctx_guard, uu___2) in
-                      FStar_SMTEncoding_Util.mkImp uu___1 in
-                    maybe_mkForall [[head1]] ctx uu___ in
-                  let app = mk_Apply head1 [x] in
-                  let ctx1 = FStar_Compiler_List.op_At ctx [x] in
-                  let ctx_guard1 =
-                    FStar_SMTEncoding_Util.mkAnd (ctx_guard, g_x) in
-                  let rest =
-                    is_tot_fun_axioms ctx1 ctx_guard1 app vars2 guards2 in
-                  FStar_SMTEncoding_Util.mkAnd (is_tot_fun_head, rest)
-              | uu___ -> failwith "impossible: isTotFun_axioms" in
-            is_tot_fun_axioms [] FStar_SMTEncoding_Util.mkTrue head vars
-              guards
-let (maybe_curry_app :
-  FStar_Compiler_Range.range ->
-    (FStar_SMTEncoding_Term.op, FStar_SMTEncoding_Term.term)
-      FStar_Pervasives.either ->
-      Prims.int ->
-        FStar_SMTEncoding_Term.term Prims.list -> FStar_SMTEncoding_Term.term)
-  =
-  fun rng ->
-    fun head ->
-      fun arity ->
-        fun args ->
-          let n_args = FStar_Compiler_List.length args in
-          match head with
-          | FStar_Pervasives.Inr head1 -> mk_Apply_args head1 args
-          | FStar_Pervasives.Inl head1 ->
-              if n_args = arity
-              then FStar_SMTEncoding_Util.mkApp' (head1, args)
-              else
-                if n_args > arity
-                then
-                  (let uu___1 = FStar_Compiler_Util.first_N arity args in
-                   match uu___1 with
-                   | (args1, rest) ->
-                       let head2 =
-                         FStar_SMTEncoding_Util.mkApp' (head1, args1) in
-                       mk_Apply_args head2 rest)
-                else
-                  (let uu___2 = FStar_SMTEncoding_Term.op_to_string head1 in
-                   raise_arity_mismatch uu___2 arity n_args rng)
-let (maybe_curry_fvb :
-  FStar_Compiler_Range.range ->
-    FStar_SMTEncoding_Env.fvar_binding ->
-      FStar_SMTEncoding_Term.term Prims.list -> FStar_SMTEncoding_Term.term)
-  =
-  fun rng ->
-    fun fvb ->
-      fun args ->
-        if fvb.FStar_SMTEncoding_Env.fvb_thunked
-        then
-          let uu___ = FStar_SMTEncoding_Env.force_thunk fvb in
-          mk_Apply_args uu___ args
-        else
-          maybe_curry_app rng
-            (FStar_Pervasives.Inl
-               (FStar_SMTEncoding_Term.Var (fvb.FStar_SMTEncoding_Env.smt_id)))
-            fvb.FStar_SMTEncoding_Env.smt_arity args
-let (is_app : FStar_SMTEncoding_Term.op -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_SMTEncoding_Term.Var "ApplyTT" -> true
-    | FStar_SMTEncoding_Term.Var "ApplyTF" -> true
-    | uu___1 -> false
-let check_pattern_vars :
-  'uuuuu .
-    FStar_SMTEncoding_Env.env_t ->
-      FStar_Syntax_Syntax.binder Prims.list ->
-        (FStar_Syntax_Syntax.term * 'uuuuu) Prims.list -> unit
-  =
-  fun env ->
-    fun vars ->
-      fun pats ->
-        let pats1 =
-          FStar_Compiler_Effect.op_Bar_Greater pats
-            (FStar_Compiler_List.map
-               (fun uu___ ->
-                  match uu___ with
-                  | (x, uu___1) ->
-                      norm_with_steps
-                        [FStar_TypeChecker_Env.Beta;
-                        FStar_TypeChecker_Env.AllowUnboundUniverses;
-                        FStar_TypeChecker_Env.EraseUniverses]
-                        env.FStar_SMTEncoding_Env.tcenv x)) in
-        match pats1 with
-        | [] -> ()
-        | hd::tl ->
-            let pat_vars =
-              let uu___ = FStar_Syntax_Free.names hd in
-              FStar_Compiler_List.fold_left
-                (fun out ->
-                   fun x ->
-                     let uu___1 = FStar_Syntax_Free.names x in
-                     FStar_Compiler_Util.set_union out uu___1) uu___ tl in
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater vars
-                (FStar_Compiler_Util.find_opt
-                   (fun uu___1 ->
-                      match uu___1 with
-                      | { FStar_Syntax_Syntax.binder_bv = b;
-                          FStar_Syntax_Syntax.binder_qual = uu___2;
-                          FStar_Syntax_Syntax.binder_attrs = uu___3;_} ->
-                          let uu___4 = FStar_Compiler_Util.set_mem b pat_vars in
-                          Prims.op_Negation uu___4)) in
-            (match uu___ with
-             | FStar_Pervasives_Native.None -> ()
-             | FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.binder_bv = x;
-                   FStar_Syntax_Syntax.binder_qual = uu___1;
-                   FStar_Syntax_Syntax.binder_attrs = uu___2;_}
-                 ->
-                 let pos =
-                   FStar_Compiler_List.fold_left
-                     (fun out ->
-                        fun t ->
-                          FStar_Compiler_Range.union_ranges out
-                            t.FStar_Syntax_Syntax.pos)
-                     hd.FStar_Syntax_Syntax.pos tl in
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = FStar_Syntax_Print.bv_to_string x in
-                     FStar_Compiler_Util.format1
-                       "SMT pattern misses at least one bound variable: %s"
-                       uu___5 in
-                   (FStar_Errors.Warning_SMTPatternIllFormed, uu___4) in
-                 FStar_Errors.log_issue pos uu___3)
-type label =
-  (FStar_SMTEncoding_Term.fv * Prims.string * FStar_Compiler_Range.range)
-type labels = label Prims.list
-type pattern =
-  {
-  pat_vars: (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.fv) Prims.list ;
-  pat_term:
-    unit -> (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t) ;
-  guard: FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term ;
-  projections:
-    FStar_SMTEncoding_Term.term ->
-      (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.term) Prims.list
-    }
-let (__proj__Mkpattern__item__pat_vars :
-  pattern -> (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.fv) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { pat_vars; pat_term; guard; projections;_} -> pat_vars
-let (__proj__Mkpattern__item__pat_term :
-  pattern ->
-    unit -> (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun projectee ->
-    match projectee with
-    | { pat_vars; pat_term; guard; projections;_} -> pat_term
-let (__proj__Mkpattern__item__guard :
-  pattern -> FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term) =
-  fun projectee ->
-    match projectee with
-    | { pat_vars; pat_term; guard; projections;_} -> guard
-let (__proj__Mkpattern__item__projections :
-  pattern ->
-    FStar_SMTEncoding_Term.term ->
-      (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.term) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { pat_vars; pat_term; guard; projections;_} -> projections
-let (as_function_typ :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t0 ->
-      let rec aux norm1 t =
-        let t1 = FStar_Syntax_Subst.compress t in
-        match t1.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_arrow uu___ -> t1
-        | FStar_Syntax_Syntax.Tm_refine uu___ ->
-            let uu___1 = FStar_Syntax_Util.unrefine t1 in aux true uu___1
-        | uu___ ->
-            if norm1
-            then let uu___1 = whnf env t1 in aux false uu___1
-            else
-              (let uu___2 =
-                 let uu___3 =
-                   FStar_Compiler_Range.string_of_range
-                     t0.FStar_Syntax_Syntax.pos in
-                 let uu___4 = FStar_Syntax_Print.term_to_string t0 in
-                 FStar_Compiler_Util.format2
-                   "(%s) Expected a function typ; got %s" uu___3 uu___4 in
-               failwith uu___2) in
-      aux true t0
-let rec (curried_arrow_formals_comp :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp))
-  =
-  fun k ->
-    let k1 = FStar_Syntax_Subst.compress k in
-    match k1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-        FStar_Syntax_Subst.open_comp bs c
-    | FStar_Syntax_Syntax.Tm_refine (bv, uu___) ->
-        let uu___1 = curried_arrow_formals_comp bv.FStar_Syntax_Syntax.sort in
-        (match uu___1 with
-         | (args, res) ->
-             (match args with
-              | [] ->
-                  let uu___2 = FStar_Syntax_Syntax.mk_Total k1 in
-                  ([], uu___2)
-              | uu___2 -> (args, res)))
-    | uu___ -> let uu___1 = FStar_Syntax_Syntax.mk_Total k1 in ([], uu___1)
-let is_arithmetic_primitive :
-  'uuuuu .
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      'uuuuu Prims.list -> Prims.bool
-  =
-  fun head ->
-    fun args ->
-      match ((head.FStar_Syntax_Syntax.n), args) with
-      | (FStar_Syntax_Syntax.Tm_fvar fv, uu___::uu___1::[]) ->
-          ((((((((((((FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.op_Addition)
-                       ||
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.op_Subtraction))
-                      ||
-                      (FStar_Syntax_Syntax.fv_eq_lid fv
-                         FStar_Parser_Const.op_Multiply))
-                     ||
-                     (FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.op_Division))
-                    ||
-                    (FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.op_Modulus))
-                   ||
-                   (FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.real_op_LT))
-                  ||
-                  (FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.real_op_LTE))
-                 ||
-                 (FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.real_op_GT))
-                ||
-                (FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.real_op_GTE))
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.real_op_Addition))
-              ||
-              (FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Parser_Const.real_op_Subtraction))
-             ||
-             (FStar_Syntax_Syntax.fv_eq_lid fv
-                FStar_Parser_Const.real_op_Multiply))
-            ||
-            (FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Parser_Const.real_op_Division)
-      | (FStar_Syntax_Syntax.Tm_fvar fv, uu___::[]) ->
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.op_Minus
-      | uu___ -> false
-let (isInteger : FStar_Syntax_Syntax.term' -> Prims.bool) =
-  fun tm ->
-    match tm with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_int
-        (n, FStar_Pervasives_Native.None)) -> true
-    | uu___ -> false
-let (getInteger : FStar_Syntax_Syntax.term' -> Prims.int) =
-  fun tm ->
-    match tm with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_int
-        (n, FStar_Pervasives_Native.None)) ->
-        FStar_Compiler_Util.int_of_string n
-    | uu___ -> failwith "Expected an Integer term"
-let is_BitVector_primitive :
-  'uuuuu .
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax * 'uuuuu)
-        Prims.list -> Prims.bool
-  =
-  fun head ->
-    fun args ->
-      match ((head.FStar_Syntax_Syntax.n), args) with
-      | (FStar_Syntax_Syntax.Tm_fvar fv, (sz_arg, uu___)::uu___1::uu___2::[])
-          ->
-          ((((((((((((FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.bv_and_lid)
-                       ||
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.bv_xor_lid))
-                      ||
-                      (FStar_Syntax_Syntax.fv_eq_lid fv
-                         FStar_Parser_Const.bv_or_lid))
-                     ||
-                     (FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.bv_add_lid))
-                    ||
-                    (FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.bv_sub_lid))
-                   ||
-                   (FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.bv_shift_left_lid))
-                  ||
-                  (FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.bv_shift_right_lid))
-                 ||
-                 (FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.bv_udiv_lid))
-                ||
-                (FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.bv_mod_lid))
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.bv_ult_lid))
-              ||
-              (FStar_Syntax_Syntax.fv_eq_lid fv
-                 FStar_Parser_Const.bv_uext_lid))
-             ||
-             (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.bv_mul_lid))
-            && (isInteger sz_arg.FStar_Syntax_Syntax.n)
-      | (FStar_Syntax_Syntax.Tm_fvar fv, (sz_arg, uu___)::uu___1::[]) ->
-          ((FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.nat_to_bv_lid)
-             ||
-             (FStar_Syntax_Syntax.fv_eq_lid fv
-                FStar_Parser_Const.bv_to_nat_lid))
-            && (isInteger sz_arg.FStar_Syntax_Syntax.n)
-      | uu___ -> false
-let rec (encode_const :
-  FStar_Const.sconst ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun c ->
-    fun env ->
-      match c with
-      | FStar_Const.Const_unit -> (FStar_SMTEncoding_Term.mk_Term_unit, [])
-      | FStar_Const.Const_bool (true) ->
-          let uu___ =
-            FStar_SMTEncoding_Term.boxBool FStar_SMTEncoding_Util.mkTrue in
-          (uu___, [])
-      | FStar_Const.Const_bool (false) ->
-          let uu___ =
-            FStar_SMTEncoding_Term.boxBool FStar_SMTEncoding_Util.mkFalse in
-          (uu___, [])
-      | FStar_Const.Const_char c1 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    FStar_SMTEncoding_Util.mkInteger'
-                      (FStar_Compiler_Util.int_of_char c1) in
-                  FStar_SMTEncoding_Term.boxInt uu___4 in
-                [uu___3] in
-              ("FStar.Char.__char_of_int", uu___2) in
-            FStar_SMTEncoding_Util.mkApp uu___1 in
-          (uu___, [])
-      | FStar_Const.Const_int (i, FStar_Pervasives_Native.None) ->
-          let uu___ =
-            let uu___1 = FStar_SMTEncoding_Util.mkInteger i in
-            FStar_SMTEncoding_Term.boxInt uu___1 in
-          (uu___, [])
-      | FStar_Const.Const_int (repr, FStar_Pervasives_Native.Some sw) ->
-          let syntax_term =
-            FStar_ToSyntax_ToSyntax.desugar_machine_integer
-              (env.FStar_SMTEncoding_Env.tcenv).FStar_TypeChecker_Env.dsenv
-              repr sw FStar_Compiler_Range.dummyRange in
-          encode_term syntax_term env
-      | FStar_Const.Const_string (s, uu___) ->
-          let uu___1 =
-            let uu___2 = FStar_SMTEncoding_Util.mk_String_const s in
-            FStar_Compiler_Effect.op_Less_Bar
-              FStar_SMTEncoding_Term.boxString uu___2 in
-          (uu___1, [])
-      | FStar_Const.Const_range uu___ ->
-          let uu___1 = FStar_SMTEncoding_Term.mk_Range_const () in
-          (uu___1, [])
-      | FStar_Const.Const_effect -> (FStar_SMTEncoding_Term.mk_Term_type, [])
-      | FStar_Const.Const_real r ->
-          let uu___ =
-            let uu___1 = FStar_SMTEncoding_Util.mkReal r in
-            FStar_SMTEncoding_Term.boxReal uu___1 in
-          (uu___, [])
-      | c1 ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Print.const_to_string c1 in
-            FStar_Compiler_Util.format1 "Unhandled constant: %s" uu___1 in
-          failwith uu___
-and (encode_binders :
-  FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_SMTEncoding_Env.env_t ->
-        (FStar_SMTEncoding_Term.fv Prims.list * FStar_SMTEncoding_Term.term
-          Prims.list * FStar_SMTEncoding_Env.env_t *
-          FStar_SMTEncoding_Term.decls_t * FStar_Syntax_Syntax.bv Prims.list))
-  =
-  fun fuel_opt ->
-    fun bs ->
-      fun env ->
-        (let uu___1 =
-           FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv
-             FStar_Options.Medium in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.binders_to_string ", " bs in
-           FStar_Compiler_Util.print1 "Encoding binders %s\n" uu___2
-         else ());
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Bar_Greater bs
-             (FStar_Compiler_List.fold_left
-                (fun uu___2 ->
-                   fun b ->
-                     match uu___2 with
-                     | (vars, guards, env1, decls, names) ->
-                         let uu___3 =
-                           let x = b.FStar_Syntax_Syntax.binder_bv in
-                           let uu___4 =
-                             FStar_SMTEncoding_Env.gen_term_var env1 x in
-                           match uu___4 with
-                           | (xxsym, xx, env') ->
-                               let uu___5 =
-                                 let uu___6 =
-                                   norm env1 x.FStar_Syntax_Syntax.sort in
-                                 encode_term_pred fuel_opt uu___6 env1 xx in
-                               (match uu___5 with
-                                | (guard_x_t, decls') ->
-                                    let uu___6 =
-                                      FStar_SMTEncoding_Term.mk_fv
-                                        (xxsym,
-                                          FStar_SMTEncoding_Term.Term_sort) in
-                                    (uu___6, guard_x_t, env', decls', x)) in
-                         (match uu___3 with
-                          | (v, g, env2, decls', n) ->
-                              ((v :: vars), (g :: guards), env2,
-                                (FStar_Compiler_List.op_At decls decls'), (n
-                                :: names)))) ([], [], env, [], [])) in
-         match uu___1 with
-         | (vars, guards, env1, decls, names) ->
-             ((FStar_Compiler_List.rev vars),
-               (FStar_Compiler_List.rev guards), env1, decls,
-               (FStar_Compiler_List.rev names)))
-and (encode_term_pred :
-  FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_SMTEncoding_Env.env_t ->
-        FStar_SMTEncoding_Term.term ->
-          (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun fuel_opt ->
-    fun t ->
-      fun env ->
-        fun e ->
-          let uu___ = encode_term t env in
-          match uu___ with
-          | (t1, decls) ->
-              let uu___1 =
-                FStar_SMTEncoding_Term.mk_HasTypeWithFuel fuel_opt e t1 in
-              (uu___1, decls)
-and (encode_arith_term :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.args ->
-        (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun env ->
-    fun head ->
-      fun args_e ->
-        let uu___ = encode_args args_e env in
-        match uu___ with
-        | (arg_tms, decls) ->
-            let head_fv =
-              match head.FStar_Syntax_Syntax.n with
-              | FStar_Syntax_Syntax.Tm_fvar fv -> fv
-              | uu___1 -> failwith "Impossible" in
-            let unary unbox arg_tms1 =
-              let uu___1 = FStar_Compiler_List.hd arg_tms1 in unbox uu___1 in
-            let binary unbox arg_tms1 =
-              let uu___1 =
-                let uu___2 = FStar_Compiler_List.hd arg_tms1 in unbox uu___2 in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Compiler_List.tl arg_tms1 in
-                  FStar_Compiler_List.hd uu___4 in
-                unbox uu___3 in
-              (uu___1, uu___2) in
-            let mk_default uu___1 =
-              let uu___2 =
-                FStar_SMTEncoding_Env.lookup_free_var_sym env
-                  head_fv.FStar_Syntax_Syntax.fv_name in
-              match uu___2 with
-              | (fname, fuel_args, arity) ->
-                  let args = FStar_Compiler_List.op_At fuel_args arg_tms in
-                  maybe_curry_app head.FStar_Syntax_Syntax.pos fname arity
-                    args in
-            let mk_l box op mk_args ts =
-              let uu___1 = FStar_Options.smtencoding_l_arith_native () in
-              if uu___1
-              then
-                let uu___2 = let uu___3 = mk_args ts in op uu___3 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___2 box
-              else mk_default () in
-            let mk_nl box unbox nm op ts =
-              let uu___1 = FStar_Options.smtencoding_nl_arith_wrapped () in
-              if uu___1
-              then
-                let uu___2 = binary unbox ts in
-                match uu___2 with
-                | (t1, t2) ->
-                    let uu___3 = FStar_SMTEncoding_Util.mkApp (nm, [t1; t2]) in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___3 box
-              else
-                (let uu___3 = FStar_Options.smtencoding_nl_arith_native () in
-                 if uu___3
-                 then
-                   let uu___4 = let uu___5 = binary unbox ts in op uu___5 in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___4 box
-                 else mk_default ()) in
-            let add box unbox =
-              mk_l box FStar_SMTEncoding_Util.mkAdd (binary unbox) in
-            let sub box unbox =
-              mk_l box FStar_SMTEncoding_Util.mkSub (binary unbox) in
-            let minus box unbox =
-              mk_l box FStar_SMTEncoding_Util.mkMinus (unary unbox) in
-            let mul box unbox nm =
-              mk_nl box unbox nm FStar_SMTEncoding_Util.mkMul in
-            let div box unbox nm =
-              mk_nl box unbox nm FStar_SMTEncoding_Util.mkDiv in
-            let modulus box unbox =
-              mk_nl box unbox "_mod" FStar_SMTEncoding_Util.mkMod in
-            let ops =
-              [(FStar_Parser_Const.op_Addition,
-                 (add FStar_SMTEncoding_Term.boxInt
-                    FStar_SMTEncoding_Term.unboxInt));
-              (FStar_Parser_Const.op_Subtraction,
-                (sub FStar_SMTEncoding_Term.boxInt
-                   FStar_SMTEncoding_Term.unboxInt));
-              (FStar_Parser_Const.op_Multiply,
-                (mul FStar_SMTEncoding_Term.boxInt
-                   FStar_SMTEncoding_Term.unboxInt "_mul"));
-              (FStar_Parser_Const.op_Division,
-                (div FStar_SMTEncoding_Term.boxInt
-                   FStar_SMTEncoding_Term.unboxInt "_div"));
-              (FStar_Parser_Const.op_Modulus,
-                (modulus FStar_SMTEncoding_Term.boxInt
-                   FStar_SMTEncoding_Term.unboxInt));
-              (FStar_Parser_Const.op_Minus,
-                (minus FStar_SMTEncoding_Term.boxInt
-                   FStar_SMTEncoding_Term.unboxInt));
-              (FStar_Parser_Const.real_op_Addition,
-                (add FStar_SMTEncoding_Term.boxReal
-                   FStar_SMTEncoding_Term.unboxReal));
-              (FStar_Parser_Const.real_op_Subtraction,
-                (sub FStar_SMTEncoding_Term.boxReal
-                   FStar_SMTEncoding_Term.unboxReal));
-              (FStar_Parser_Const.real_op_Multiply,
-                (mul FStar_SMTEncoding_Term.boxReal
-                   FStar_SMTEncoding_Term.unboxReal "_rmul"));
-              (FStar_Parser_Const.real_op_Division,
-                (mk_nl FStar_SMTEncoding_Term.boxReal
-                   FStar_SMTEncoding_Term.unboxReal "_rdiv"
-                   FStar_SMTEncoding_Util.mkRealDiv));
-              (FStar_Parser_Const.real_op_LT,
-                (mk_l FStar_SMTEncoding_Term.boxBool
-                   FStar_SMTEncoding_Util.mkLT
-                   (binary FStar_SMTEncoding_Term.unboxReal)));
-              (FStar_Parser_Const.real_op_LTE,
-                (mk_l FStar_SMTEncoding_Term.boxBool
-                   FStar_SMTEncoding_Util.mkLTE
-                   (binary FStar_SMTEncoding_Term.unboxReal)));
-              (FStar_Parser_Const.real_op_GT,
-                (mk_l FStar_SMTEncoding_Term.boxBool
-                   FStar_SMTEncoding_Util.mkGT
-                   (binary FStar_SMTEncoding_Term.unboxReal)));
-              (FStar_Parser_Const.real_op_GTE,
-                (mk_l FStar_SMTEncoding_Term.boxBool
-                   FStar_SMTEncoding_Util.mkGTE
-                   (binary FStar_SMTEncoding_Term.unboxReal)))] in
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_List.tryFind
-                  (fun uu___3 ->
-                     match uu___3 with
-                     | (l, uu___4) -> FStar_Syntax_Syntax.fv_eq_lid head_fv l)
-                  ops in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_Compiler_Util.must in
-            (match uu___1 with
-             | (uu___2, op) -> let uu___3 = op arg_tms in (uu___3, decls))
-and (encode_BitVector_term :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list ->
-        (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_elt
-          Prims.list))
-  =
-  fun env ->
-    fun head ->
-      fun args_e ->
-        let uu___ = FStar_Compiler_List.hd args_e in
-        match uu___ with
-        | (tm_sz, uu___1) ->
-            let uu___2 = uu___ in
-            let sz = getInteger tm_sz.FStar_Syntax_Syntax.n in
-            let sz_key =
-              FStar_Compiler_Util.format1 "BitVector_%s"
-                (Prims.string_of_int sz) in
-            let sz_decls =
-              let t_decls = FStar_SMTEncoding_Term.mkBvConstructor sz in
-              FStar_SMTEncoding_Term.mk_decls "" sz_key t_decls [] in
-            let uu___3 =
-              match ((head.FStar_Syntax_Syntax.n), args_e) with
-              | (FStar_Syntax_Syntax.Tm_fvar fv,
-                 uu___4::(sz_arg, uu___5)::uu___6::[]) when
-                  (FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.bv_uext_lid)
-                    && (isInteger sz_arg.FStar_Syntax_Syntax.n)
-                  ->
-                  let uu___7 =
-                    let uu___8 = FStar_Compiler_List.tail args_e in
-                    FStar_Compiler_List.tail uu___8 in
-                  let uu___8 =
-                    let uu___9 = getInteger sz_arg.FStar_Syntax_Syntax.n in
-                    FStar_Pervasives_Native.Some uu___9 in
-                  (uu___7, uu___8)
-              | (FStar_Syntax_Syntax.Tm_fvar fv,
-                 uu___4::(sz_arg, uu___5)::uu___6::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.bv_uext_lid
-                  ->
-                  let uu___7 =
-                    let uu___8 = FStar_Syntax_Print.term_to_string sz_arg in
-                    FStar_Compiler_Util.format1
-                      "Not a constant bitvector extend size: %s" uu___8 in
-                  failwith uu___7
-              | uu___4 ->
-                  let uu___5 = FStar_Compiler_List.tail args_e in
-                  (uu___5, FStar_Pervasives_Native.None) in
-            (match uu___3 with
-             | (arg_tms, ext_sz) ->
-                 let uu___4 = encode_args arg_tms env in
-                 (match uu___4 with
-                  | (arg_tms1, decls) ->
-                      let head_fv =
-                        match head.FStar_Syntax_Syntax.n with
-                        | FStar_Syntax_Syntax.Tm_fvar fv -> fv
-                        | uu___5 -> failwith "Impossible" in
-                      let unary arg_tms2 =
-                        let uu___5 = FStar_Compiler_List.hd arg_tms2 in
-                        FStar_SMTEncoding_Term.unboxBitVec sz uu___5 in
-                      let unary_arith arg_tms2 =
-                        let uu___5 = FStar_Compiler_List.hd arg_tms2 in
-                        FStar_SMTEncoding_Term.unboxInt uu___5 in
-                      let binary arg_tms2 =
-                        let uu___5 =
-                          let uu___6 = FStar_Compiler_List.hd arg_tms2 in
-                          FStar_SMTEncoding_Term.unboxBitVec sz uu___6 in
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 = FStar_Compiler_List.tl arg_tms2 in
-                            FStar_Compiler_List.hd uu___8 in
-                          FStar_SMTEncoding_Term.unboxBitVec sz uu___7 in
-                        (uu___5, uu___6) in
-                      let binary_arith arg_tms2 =
-                        let uu___5 =
-                          let uu___6 = FStar_Compiler_List.hd arg_tms2 in
-                          FStar_SMTEncoding_Term.unboxBitVec sz uu___6 in
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 = FStar_Compiler_List.tl arg_tms2 in
-                            FStar_Compiler_List.hd uu___8 in
-                          FStar_SMTEncoding_Term.unboxInt uu___7 in
-                        (uu___5, uu___6) in
-                      let mk_bv op mk_args resBox ts =
-                        let uu___5 = let uu___6 = mk_args ts in op uu___6 in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___5 resBox in
-                      let bv_and =
-                        mk_bv FStar_SMTEncoding_Util.mkBvAnd binary
-                          (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_xor =
-                        mk_bv FStar_SMTEncoding_Util.mkBvXor binary
-                          (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_or =
-                        mk_bv FStar_SMTEncoding_Util.mkBvOr binary
-                          (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_add =
-                        mk_bv FStar_SMTEncoding_Util.mkBvAdd binary
-                          (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_sub =
-                        mk_bv FStar_SMTEncoding_Util.mkBvSub binary
-                          (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_shl =
-                        mk_bv (FStar_SMTEncoding_Util.mkBvShl sz)
-                          binary_arith (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_shr =
-                        mk_bv (FStar_SMTEncoding_Util.mkBvShr sz)
-                          binary_arith (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_udiv =
-                        mk_bv (FStar_SMTEncoding_Util.mkBvUdiv sz)
-                          binary_arith (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_mod =
-                        mk_bv (FStar_SMTEncoding_Util.mkBvMod sz)
-                          binary_arith (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_mul =
-                        mk_bv (FStar_SMTEncoding_Util.mkBvMul sz)
-                          binary_arith (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let bv_ult =
-                        mk_bv FStar_SMTEncoding_Util.mkBvUlt binary
-                          FStar_SMTEncoding_Term.boxBool in
-                      let bv_uext arg_tms2 =
-                        let uu___5 =
-                          let uu___6 =
-                            match ext_sz with
-                            | FStar_Pervasives_Native.Some x -> x
-                            | FStar_Pervasives_Native.None ->
-                                failwith "impossible" in
-                          FStar_SMTEncoding_Util.mkBvUext uu___6 in
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              match ext_sz with
-                              | FStar_Pervasives_Native.Some x -> x
-                              | FStar_Pervasives_Native.None ->
-                                  failwith "impossible" in
-                            sz + uu___8 in
-                          FStar_SMTEncoding_Term.boxBitVec uu___7 in
-                        mk_bv uu___5 unary uu___6 arg_tms2 in
-                      let to_int =
-                        mk_bv FStar_SMTEncoding_Util.mkBvToNat unary
-                          FStar_SMTEncoding_Term.boxInt in
-                      let bv_to =
-                        mk_bv (FStar_SMTEncoding_Util.mkNatToBv sz)
-                          unary_arith (FStar_SMTEncoding_Term.boxBitVec sz) in
-                      let ops =
-                        [(FStar_Parser_Const.bv_and_lid, bv_and);
-                        (FStar_Parser_Const.bv_xor_lid, bv_xor);
-                        (FStar_Parser_Const.bv_or_lid, bv_or);
-                        (FStar_Parser_Const.bv_add_lid, bv_add);
-                        (FStar_Parser_Const.bv_sub_lid, bv_sub);
-                        (FStar_Parser_Const.bv_shift_left_lid, bv_shl);
-                        (FStar_Parser_Const.bv_shift_right_lid, bv_shr);
-                        (FStar_Parser_Const.bv_udiv_lid, bv_udiv);
-                        (FStar_Parser_Const.bv_mod_lid, bv_mod);
-                        (FStar_Parser_Const.bv_mul_lid, bv_mul);
-                        (FStar_Parser_Const.bv_ult_lid, bv_ult);
-                        (FStar_Parser_Const.bv_uext_lid, bv_uext);
-                        (FStar_Parser_Const.bv_to_nat_lid, to_int);
-                        (FStar_Parser_Const.nat_to_bv_lid, bv_to)] in
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Compiler_List.tryFind
-                            (fun uu___7 ->
-                               match uu___7 with
-                               | (l, uu___8) ->
-                                   FStar_Syntax_Syntax.fv_eq_lid head_fv l)
-                            ops in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___6
-                          FStar_Compiler_Util.must in
-                      (match uu___5 with
-                       | (uu___6, op) ->
-                           let uu___7 = op arg_tms1 in
-                           (uu___7,
-                             (FStar_Compiler_List.op_At sz_decls decls)))))
-and (encode_deeply_embedded_quantifier :
-  FStar_Syntax_Syntax.term ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun t ->
-    fun env ->
-      let env1 =
-        {
-          FStar_SMTEncoding_Env.bvar_bindings =
-            (env.FStar_SMTEncoding_Env.bvar_bindings);
-          FStar_SMTEncoding_Env.fvar_bindings =
-            (env.FStar_SMTEncoding_Env.fvar_bindings);
-          FStar_SMTEncoding_Env.depth = (env.FStar_SMTEncoding_Env.depth);
-          FStar_SMTEncoding_Env.tcenv = (env.FStar_SMTEncoding_Env.tcenv);
-          FStar_SMTEncoding_Env.warn = (env.FStar_SMTEncoding_Env.warn);
-          FStar_SMTEncoding_Env.nolabels =
-            (env.FStar_SMTEncoding_Env.nolabels);
-          FStar_SMTEncoding_Env.use_zfuel_name =
-            (env.FStar_SMTEncoding_Env.use_zfuel_name);
-          FStar_SMTEncoding_Env.encode_non_total_function_typ =
-            (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-          FStar_SMTEncoding_Env.current_module_name =
-            (env.FStar_SMTEncoding_Env.current_module_name);
-          FStar_SMTEncoding_Env.encoding_quantifier = true;
-          FStar_SMTEncoding_Env.global_cache =
-            (env.FStar_SMTEncoding_Env.global_cache)
-        } in
-      let uu___ = encode_term t env1 in
-      match uu___ with
-      | (tm, decls) ->
-          let vars = FStar_SMTEncoding_Term.free_variables tm in
-          let valid_tm = FStar_SMTEncoding_Term.mk_Valid tm in
-          let key =
-            FStar_SMTEncoding_Term.mkForall t.FStar_Syntax_Syntax.pos
-              ([], vars, valid_tm) in
-          let tkey_hash = FStar_SMTEncoding_Term.hash_of_term key in
-          (match tm.FStar_SMTEncoding_Term.tm with
-           | FStar_SMTEncoding_Term.App
-               (uu___1,
-                {
-                  FStar_SMTEncoding_Term.tm = FStar_SMTEncoding_Term.FreeV
-                    uu___2;
-                  FStar_SMTEncoding_Term.freevars = uu___3;
-                  FStar_SMTEncoding_Term.rng = uu___4;_}::{
-                                                            FStar_SMTEncoding_Term.tm
-                                                              =
-                                                              FStar_SMTEncoding_Term.FreeV
-                                                              uu___5;
-                                                            FStar_SMTEncoding_Term.freevars
-                                                              = uu___6;
-                                                            FStar_SMTEncoding_Term.rng
-                                                              = uu___7;_}::[])
-               ->
-               (FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos
-                  (FStar_Errors.Warning_QuantifierWithoutPattern,
-                    "Not encoding deeply embedded, unguarded quantifier to SMT");
-                (tm, decls))
-           | uu___1 ->
-               let uu___2 = encode_formula t env1 in
-               (match uu___2 with
-                | (phi, decls') ->
-                    let interp =
-                      match vars with
-                      | [] ->
-                          let uu___3 =
-                            let uu___4 = FStar_SMTEncoding_Term.mk_Valid tm in
-                            (uu___4, phi) in
-                          FStar_SMTEncoding_Util.mkIff uu___3
-                      | uu___3 ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_SMTEncoding_Term.mk_Valid tm in
-                                (uu___7, phi) in
-                              FStar_SMTEncoding_Util.mkIff uu___6 in
-                            ([[valid_tm]], vars, uu___5) in
-                          FStar_SMTEncoding_Term.mkForall
-                            t.FStar_Syntax_Syntax.pos uu___4 in
-                    let ax =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_Compiler_Util.digest_of_string tkey_hash in
-                          Prims.op_Hat "l_quant_interp_" uu___5 in
-                        (interp,
-                          (FStar_Pervasives_Native.Some
-                             "Interpretation of deeply embedded quantifier"),
-                          uu___4) in
-                      FStar_SMTEncoding_Util.mkAssume uu___3 in
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_SMTEncoding_Term.mk_decls "" tkey_hash 
-                            [ax] (FStar_Compiler_List.op_At decls decls') in
-                        FStar_Compiler_List.op_At decls' uu___5 in
-                      FStar_Compiler_List.op_At decls uu___4 in
-                    (tm, uu___3)))
-and (encode_term :
-  FStar_Syntax_Syntax.typ ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun t ->
-    fun env ->
-      FStar_TypeChecker_Env.def_check_closed_in_env t.FStar_Syntax_Syntax.pos
-        "encode_term" env.FStar_SMTEncoding_Env.tcenv t;
-      (let t1 = FStar_Syntax_Subst.compress t in
-       let t0 = t1 in
-       (let uu___2 =
-          FStar_Compiler_Effect.op_Less_Bar
-            (FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv)
-            (FStar_Options.Other "SMTEncoding") in
-        if uu___2
-        then
-          let uu___3 = FStar_Syntax_Print.tag_of_term t1 in
-          let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-          FStar_Compiler_Util.print2 "(%s)   %s\n" uu___3 uu___4
-        else ());
-       (match t1.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_delayed uu___2 ->
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  FStar_Compiler_Range.string_of_range
-                  t1.FStar_Syntax_Syntax.pos in
-              let uu___5 = FStar_Syntax_Print.tag_of_term t1 in
-              let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format3 "(%s) Impossible: %s\n%s\n" uu___4
-                uu___5 uu___6 in
-            failwith uu___3
-        | FStar_Syntax_Syntax.Tm_unknown ->
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  FStar_Compiler_Range.string_of_range
-                  t1.FStar_Syntax_Syntax.pos in
-              let uu___4 = FStar_Syntax_Print.tag_of_term t1 in
-              let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format3 "(%s) Impossible: %s\n%s\n" uu___3
-                uu___4 uu___5 in
-            failwith uu___2
-        | FStar_Syntax_Syntax.Tm_lazy i ->
-            let e = FStar_Syntax_Util.unfold_lazy i in
-            ((let uu___3 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug
-                     env.FStar_SMTEncoding_Env.tcenv)
-                  (FStar_Options.Other "SMTEncoding") in
-              if uu___3
-              then
-                let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-                let uu___5 = FStar_Syntax_Print.term_to_string e in
-                FStar_Compiler_Util.print2 ">> Unfolded (%s) ~> (%s)\n"
-                  uu___4 uu___5
-              else ());
-             encode_term e env)
-        | FStar_Syntax_Syntax.Tm_bvar x ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.bv_to_string x in
-              FStar_Compiler_Util.format1
-                "Impossible: locally nameless; got %s" uu___3 in
-            failwith uu___2
-        | FStar_Syntax_Syntax.Tm_ascribed (t2, (k, uu___2, uu___3), uu___4)
-            ->
-            let uu___5 =
-              match k with
-              | FStar_Pervasives.Inl t3 -> FStar_Syntax_Util.is_unit t3
-              | uu___6 -> false in
-            if uu___5
-            then (FStar_SMTEncoding_Term.mk_Term_unit, [])
-            else encode_term t2 env
-        | FStar_Syntax_Syntax.Tm_quoted (qt, uu___2) ->
-            let tv =
-              let uu___3 =
-                let uu___4 = FStar_Reflection_Basic.inspect_ln qt in
-                FStar_Syntax_Embeddings.embed
-                  FStar_Reflection_Embeddings.e_term_view uu___4 in
-              uu___3 t1.FStar_Syntax_Syntax.pos FStar_Pervasives_Native.None
-                FStar_Syntax_Embeddings.id_norm_cb in
-            ((let uu___4 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug
-                     env.FStar_SMTEncoding_Env.tcenv)
-                  (FStar_Options.Other "SMTEncoding") in
-              if uu___4
-              then
-                let uu___5 = FStar_Syntax_Print.term_to_string t0 in
-                let uu___6 = FStar_Syntax_Print.term_to_string tv in
-                FStar_Compiler_Util.print2 ">> Inspected (%s) ~> (%s)\n"
-                  uu___5 uu___6
-              else ());
-             (let t2 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Syntax.as_arg tv in [uu___5] in
-                FStar_Syntax_Util.mk_app
-                  (FStar_Reflection_Constants.refl_constant_term
-                     FStar_Reflection_Constants.fstar_refl_pack_ln) uu___4 in
-              encode_term t2 env))
-        | FStar_Syntax_Syntax.Tm_meta
-            (t2, FStar_Syntax_Syntax.Meta_pattern uu___2) ->
-            encode_term t2
-              {
-                FStar_SMTEncoding_Env.bvar_bindings =
-                  (env.FStar_SMTEncoding_Env.bvar_bindings);
-                FStar_SMTEncoding_Env.fvar_bindings =
-                  (env.FStar_SMTEncoding_Env.fvar_bindings);
-                FStar_SMTEncoding_Env.depth =
-                  (env.FStar_SMTEncoding_Env.depth);
-                FStar_SMTEncoding_Env.tcenv =
-                  (env.FStar_SMTEncoding_Env.tcenv);
-                FStar_SMTEncoding_Env.warn = (env.FStar_SMTEncoding_Env.warn);
-                FStar_SMTEncoding_Env.nolabels =
-                  (env.FStar_SMTEncoding_Env.nolabels);
-                FStar_SMTEncoding_Env.use_zfuel_name =
-                  (env.FStar_SMTEncoding_Env.use_zfuel_name);
-                FStar_SMTEncoding_Env.encode_non_total_function_typ =
-                  (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-                FStar_SMTEncoding_Env.current_module_name =
-                  (env.FStar_SMTEncoding_Env.current_module_name);
-                FStar_SMTEncoding_Env.encoding_quantifier = false;
-                FStar_SMTEncoding_Env.global_cache =
-                  (env.FStar_SMTEncoding_Env.global_cache)
-              }
-        | FStar_Syntax_Syntax.Tm_meta (t2, uu___2) -> encode_term t2 env
-        | FStar_Syntax_Syntax.Tm_name x ->
-            let t2 = FStar_SMTEncoding_Env.lookup_term_var env x in (t2, [])
-        | FStar_Syntax_Syntax.Tm_fvar v ->
-            let encode_freev uu___2 =
-              let fvb =
-                FStar_SMTEncoding_Env.lookup_free_var_name env
-                  v.FStar_Syntax_Syntax.fv_name in
-              let tok =
-                FStar_SMTEncoding_Env.lookup_free_var env
-                  v.FStar_Syntax_Syntax.fv_name in
-              let tkey_hash = FStar_SMTEncoding_Term.hash_of_term tok in
-              let uu___3 =
-                if fvb.FStar_SMTEncoding_Env.smt_arity > Prims.int_zero
-                then
-                  match tok.FStar_SMTEncoding_Term.tm with
-                  | FStar_SMTEncoding_Term.FreeV uu___4 ->
-                      let sym_name =
-                        let uu___5 =
-                          FStar_Compiler_Util.digest_of_string tkey_hash in
-                        Prims.op_Hat "@kick_partial_app_" uu___5 in
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              FStar_SMTEncoding_Term.kick_partial_app tok in
-                            (uu___8,
-                              (FStar_Pervasives_Native.Some
-                                 "kick_partial_app"), sym_name) in
-                          FStar_SMTEncoding_Util.mkAssume uu___7 in
-                        [uu___6] in
-                      (uu___5, sym_name)
-                  | FStar_SMTEncoding_Term.App (uu___4, []) ->
-                      let sym_name =
-                        let uu___5 =
-                          FStar_Compiler_Util.digest_of_string tkey_hash in
-                        Prims.op_Hat "@kick_partial_app_" uu___5 in
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              FStar_SMTEncoding_Term.kick_partial_app tok in
-                            (uu___8,
-                              (FStar_Pervasives_Native.Some
-                                 "kick_partial_app"), sym_name) in
-                          FStar_SMTEncoding_Util.mkAssume uu___7 in
-                        [uu___6] in
-                      (uu___5, sym_name)
-                  | uu___4 -> ([], "")
-                else ([], "") in
-              match uu___3 with
-              | (aux_decls, sym_name) ->
-                  let uu___4 =
-                    if aux_decls = []
-                    then
-                      FStar_Compiler_Effect.op_Bar_Greater []
-                        FStar_SMTEncoding_Term.mk_decls_trivial
-                    else
-                      FStar_SMTEncoding_Term.mk_decls sym_name tkey_hash
-                        aux_decls [] in
-                  (tok, uu___4) in
-            let uu___2 = head_redex env t1 in
-            if uu___2
-            then
-              let uu___3 = maybe_whnf env t1 in
-              (match uu___3 with
-               | FStar_Pervasives_Native.None -> encode_freev ()
-               | FStar_Pervasives_Native.Some t2 -> encode_term t2 env)
-            else encode_freev ()
-        | FStar_Syntax_Syntax.Tm_type uu___2 ->
-            (FStar_SMTEncoding_Term.mk_Term_type, [])
-        | FStar_Syntax_Syntax.Tm_uinst (t2, uu___2) -> encode_term t2 env
-        | FStar_Syntax_Syntax.Tm_constant c -> encode_const c env
-        | FStar_Syntax_Syntax.Tm_arrow (binders, c) ->
-            let module_name = env.FStar_SMTEncoding_Env.current_module_name in
-            let uu___2 = FStar_Syntax_Subst.open_comp binders c in
-            (match uu___2 with
-             | (binders1, res) ->
-                 let uu___3 =
-                   (env.FStar_SMTEncoding_Env.encode_non_total_function_typ
-                      && (FStar_Syntax_Util.is_pure_or_ghost_comp res))
-                     || (FStar_Syntax_Util.is_tot_or_gtot_comp res) in
-                 if uu___3
-                 then
-                   let uu___4 =
-                     encode_binders FStar_Pervasives_Native.None binders1 env in
-                   (match uu___4 with
-                    | (vars, guards_l, env', decls, uu___5) ->
-                        let fsym =
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.fresh
-                                module_name "f" in
-                            (uu___7, FStar_SMTEncoding_Term.Term_sort) in
-                          FStar_SMTEncoding_Term.mk_fv uu___6 in
-                        let f = FStar_SMTEncoding_Util.mkFreeV fsym in
-                        let app = mk_Apply f vars in
-                        let tcenv_bs =
-                          let uu___6 =
-                            FStar_TypeChecker_Env.push_binders
-                              env.FStar_SMTEncoding_Env.tcenv binders1 in
-                          {
-                            FStar_TypeChecker_Env.solver =
-                              (uu___6.FStar_TypeChecker_Env.solver);
-                            FStar_TypeChecker_Env.range =
-                              (uu___6.FStar_TypeChecker_Env.range);
-                            FStar_TypeChecker_Env.curmodule =
-                              (uu___6.FStar_TypeChecker_Env.curmodule);
-                            FStar_TypeChecker_Env.gamma =
-                              (uu___6.FStar_TypeChecker_Env.gamma);
-                            FStar_TypeChecker_Env.gamma_sig =
-                              (uu___6.FStar_TypeChecker_Env.gamma_sig);
-                            FStar_TypeChecker_Env.gamma_cache =
-                              (uu___6.FStar_TypeChecker_Env.gamma_cache);
-                            FStar_TypeChecker_Env.modules =
-                              (uu___6.FStar_TypeChecker_Env.modules);
-                            FStar_TypeChecker_Env.expected_typ =
-                              (uu___6.FStar_TypeChecker_Env.expected_typ);
-                            FStar_TypeChecker_Env.sigtab =
-                              (uu___6.FStar_TypeChecker_Env.sigtab);
-                            FStar_TypeChecker_Env.attrtab =
-                              (uu___6.FStar_TypeChecker_Env.attrtab);
-                            FStar_TypeChecker_Env.instantiate_imp =
-                              (uu___6.FStar_TypeChecker_Env.instantiate_imp);
-                            FStar_TypeChecker_Env.effects =
-                              (uu___6.FStar_TypeChecker_Env.effects);
-                            FStar_TypeChecker_Env.generalize =
-                              (uu___6.FStar_TypeChecker_Env.generalize);
-                            FStar_TypeChecker_Env.letrecs =
-                              (uu___6.FStar_TypeChecker_Env.letrecs);
-                            FStar_TypeChecker_Env.top_level =
-                              (uu___6.FStar_TypeChecker_Env.top_level);
-                            FStar_TypeChecker_Env.check_uvars =
-                              (uu___6.FStar_TypeChecker_Env.check_uvars);
-                            FStar_TypeChecker_Env.use_eq_strict =
-                              (uu___6.FStar_TypeChecker_Env.use_eq_strict);
-                            FStar_TypeChecker_Env.is_iface =
-                              (uu___6.FStar_TypeChecker_Env.is_iface);
-                            FStar_TypeChecker_Env.admit =
-                              (uu___6.FStar_TypeChecker_Env.admit);
-                            FStar_TypeChecker_Env.lax = true;
-                            FStar_TypeChecker_Env.lax_universes =
-                              (uu___6.FStar_TypeChecker_Env.lax_universes);
-                            FStar_TypeChecker_Env.phase1 =
-                              (uu___6.FStar_TypeChecker_Env.phase1);
-                            FStar_TypeChecker_Env.failhard =
-                              (uu___6.FStar_TypeChecker_Env.failhard);
-                            FStar_TypeChecker_Env.nosynth =
-                              (uu___6.FStar_TypeChecker_Env.nosynth);
-                            FStar_TypeChecker_Env.uvar_subtyping =
-                              (uu___6.FStar_TypeChecker_Env.uvar_subtyping);
-                            FStar_TypeChecker_Env.tc_term =
-                              (uu___6.FStar_TypeChecker_Env.tc_term);
-                            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                              (uu___6.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                            FStar_TypeChecker_Env.universe_of =
-                              (uu___6.FStar_TypeChecker_Env.universe_of);
-                            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                              =
-                              (uu___6.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                            FStar_TypeChecker_Env.teq_nosmt_force =
-                              (uu___6.FStar_TypeChecker_Env.teq_nosmt_force);
-                            FStar_TypeChecker_Env.subtype_nosmt_force =
-                              (uu___6.FStar_TypeChecker_Env.subtype_nosmt_force);
-                            FStar_TypeChecker_Env.qtbl_name_and_index =
-                              (uu___6.FStar_TypeChecker_Env.qtbl_name_and_index);
-                            FStar_TypeChecker_Env.normalized_eff_names =
-                              (uu___6.FStar_TypeChecker_Env.normalized_eff_names);
-                            FStar_TypeChecker_Env.fv_delta_depths =
-                              (uu___6.FStar_TypeChecker_Env.fv_delta_depths);
-                            FStar_TypeChecker_Env.proof_ns =
-                              (uu___6.FStar_TypeChecker_Env.proof_ns);
-                            FStar_TypeChecker_Env.synth_hook =
-                              (uu___6.FStar_TypeChecker_Env.synth_hook);
-                            FStar_TypeChecker_Env.try_solve_implicits_hook =
-                              (uu___6.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                            FStar_TypeChecker_Env.splice =
-                              (uu___6.FStar_TypeChecker_Env.splice);
-                            FStar_TypeChecker_Env.mpreprocess =
-                              (uu___6.FStar_TypeChecker_Env.mpreprocess);
-                            FStar_TypeChecker_Env.postprocess =
-                              (uu___6.FStar_TypeChecker_Env.postprocess);
-                            FStar_TypeChecker_Env.identifier_info =
-                              (uu___6.FStar_TypeChecker_Env.identifier_info);
-                            FStar_TypeChecker_Env.tc_hooks =
-                              (uu___6.FStar_TypeChecker_Env.tc_hooks);
-                            FStar_TypeChecker_Env.dsenv =
-                              (uu___6.FStar_TypeChecker_Env.dsenv);
-                            FStar_TypeChecker_Env.nbe =
-                              (uu___6.FStar_TypeChecker_Env.nbe);
-                            FStar_TypeChecker_Env.strict_args_tab =
-                              (uu___6.FStar_TypeChecker_Env.strict_args_tab);
-                            FStar_TypeChecker_Env.erasable_types_tab =
-                              (uu___6.FStar_TypeChecker_Env.erasable_types_tab);
-                            FStar_TypeChecker_Env.enable_defer_to_tac =
-                              (uu___6.FStar_TypeChecker_Env.enable_defer_to_tac);
-                            FStar_TypeChecker_Env.unif_allow_ref_guards =
-                              (uu___6.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                            FStar_TypeChecker_Env.erase_erasable_args =
-                              (uu___6.FStar_TypeChecker_Env.erase_erasable_args);
-                            FStar_TypeChecker_Env.core_check =
-                              (uu___6.FStar_TypeChecker_Env.core_check)
-                          } in
-                        let uu___6 =
-                          FStar_TypeChecker_Util.pure_or_ghost_pre_and_post
-                            tcenv_bs res in
-                        (match uu___6 with
-                         | (pre_opt, res_t) ->
-                             let uu___7 =
-                               encode_term_pred FStar_Pervasives_Native.None
-                                 res_t env' app in
-                             (match uu___7 with
-                              | (res_pred, decls') ->
-                                  let uu___8 =
-                                    match pre_opt with
-                                    | FStar_Pervasives_Native.None ->
-                                        let uu___9 =
-                                          FStar_SMTEncoding_Util.mk_and_l
-                                            guards_l in
-                                        (uu___9, [])
-                                    | FStar_Pervasives_Native.Some pre ->
-                                        let uu___9 = encode_formula pre env' in
-                                        (match uu___9 with
-                                         | (guard, decls0) ->
-                                             let uu___10 =
-                                               FStar_SMTEncoding_Util.mk_and_l
-                                                 (guard :: guards_l) in
-                                             (uu___10, decls0)) in
-                                  (match uu___8 with
-                                   | (guards, guard_decls) ->
-                                       let is_pure =
-                                         let uu___9 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             res
-                                             (FStar_TypeChecker_Normalize.maybe_ghost_to_pure
-                                                env.FStar_SMTEncoding_Env.tcenv) in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___9
-                                           FStar_Syntax_Util.is_pure_comp in
-                                       let t_interp =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_SMTEncoding_Util.mkImp
-                                               (guards, res_pred) in
-                                           ([[app]], vars, uu___10) in
-                                         FStar_SMTEncoding_Term.mkForall
-                                           t1.FStar_Syntax_Syntax.pos uu___9 in
-                                       let t_interp1 =
-                                         let tot_fun_axioms =
-                                           isTotFun_axioms
-                                             t1.FStar_Syntax_Syntax.pos f
-                                             vars guards_l is_pure in
-                                         FStar_SMTEncoding_Util.mkAnd
-                                           (t_interp, tot_fun_axioms) in
-                                       let cvars =
-                                         let uu___9 =
-                                           FStar_SMTEncoding_Term.free_variables
-                                             t_interp1 in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___9
-                                           (FStar_Compiler_List.filter
-                                              (fun x ->
-                                                 let uu___10 =
-                                                   FStar_SMTEncoding_Term.fv_name
-                                                     x in
-                                                 let uu___11 =
-                                                   FStar_SMTEncoding_Term.fv_name
-                                                     fsym in
-                                                 uu___10 <> uu___11)) in
-                                       let tkey =
-                                         FStar_SMTEncoding_Term.mkForall
-                                           t1.FStar_Syntax_Syntax.pos
-                                           ([], (fsym :: cvars), t_interp1) in
-                                       let prefix =
-                                         if is_pure
-                                         then "Tm_arrow_"
-                                         else "Tm_ghost_arrow_" in
-                                       let tkey_hash =
-                                         let uu___9 =
-                                           FStar_SMTEncoding_Term.hash_of_term
-                                             tkey in
-                                         Prims.op_Hat prefix uu___9 in
-                                       let tsym =
-                                         let uu___9 =
-                                           FStar_Compiler_Util.digest_of_string
-                                             tkey_hash in
-                                         Prims.op_Hat prefix uu___9 in
-                                       let cvar_sorts =
-                                         FStar_Compiler_List.map
-                                           FStar_SMTEncoding_Term.fv_sort
-                                           cvars in
-                                       let caption =
-                                         let uu___9 =
-                                           FStar_Options.log_queries () in
-                                         if uu___9
-                                         then
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_TypeChecker_Normalize.term_to_string
-                                                 env.FStar_SMTEncoding_Env.tcenv
-                                                 t0 in
-                                             FStar_Compiler_Util.replace_char
-                                               uu___11 10 32 in
-                                           FStar_Pervasives_Native.Some
-                                             uu___10
-                                         else FStar_Pervasives_Native.None in
-                                       let tdecl =
-                                         FStar_SMTEncoding_Term.DeclFun
-                                           (tsym, cvar_sorts,
-                                             FStar_SMTEncoding_Term.Term_sort,
-                                             caption) in
-                                       let t2 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Compiler_List.map
-                                               FStar_SMTEncoding_Util.mkFreeV
-                                               cvars in
-                                           (tsym, uu___10) in
-                                         FStar_SMTEncoding_Util.mkApp uu___9 in
-                                       let t_has_kind =
-                                         FStar_SMTEncoding_Term.mk_HasType t2
-                                           FStar_SMTEncoding_Term.mk_Term_type in
-                                       let k_assumption =
-                                         let a_name =
-                                           Prims.op_Hat "kinding_" tsym in
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_SMTEncoding_Term.mkForall
-                                               t0.FStar_Syntax_Syntax.pos
-                                               ([[t_has_kind]], cvars,
-                                                 t_has_kind) in
-                                           (uu___10,
-                                             (FStar_Pervasives_Native.Some
-                                                a_name), a_name) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___9 in
-                                       let f_has_t =
-                                         FStar_SMTEncoding_Term.mk_HasType f
-                                           t2 in
-                                       let f_has_t_z =
-                                         FStar_SMTEncoding_Term.mk_HasTypeZ f
-                                           t2 in
-                                       let pre_typing =
-                                         let a_name =
-                                           Prims.op_Hat "pre_typing_" tsym in
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 let uu___13 =
-                                                   let uu___14 =
-                                                     let uu___15 =
-                                                       FStar_SMTEncoding_Term.mk_PreType
-                                                         f in
-                                                     FStar_SMTEncoding_Term.mk_tester
-                                                       "Tm_arrow" uu___15 in
-                                                   (f_has_t, uu___14) in
-                                                 FStar_SMTEncoding_Util.mkImp
-                                                   uu___13 in
-                                               ([[f_has_t]], (fsym :: cvars),
-                                                 uu___12) in
-                                             let uu___12 =
-                                               mkForall_fuel module_name
-                                                 t0.FStar_Syntax_Syntax.pos in
-                                             uu___12 uu___11 in
-                                           (uu___10,
-                                             (FStar_Pervasives_Native.Some
-                                                "pre-typing for functions"),
-                                             (Prims.op_Hat module_name
-                                                (Prims.op_Hat "_" a_name))) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___9 in
-                                       let t_interp2 =
-                                         let a_name =
-                                           Prims.op_Hat "interpretation_"
-                                             tsym in
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_SMTEncoding_Util.mkIff
-                                                   (f_has_t_z, t_interp1) in
-                                               ([[f_has_t_z]], (fsym ::
-                                                 cvars), uu___12) in
-                                             FStar_SMTEncoding_Term.mkForall
-                                               t0.FStar_Syntax_Syntax.pos
-                                               uu___11 in
-                                           (uu___10,
-                                             (FStar_Pervasives_Native.Some
-                                                a_name),
-                                             (Prims.op_Hat module_name
-                                                (Prims.op_Hat "_" a_name))) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___9 in
-                                       let t_decls =
-                                         [tdecl;
-                                         k_assumption;
-                                         pre_typing;
-                                         t_interp2] in
-                                       let uu___9 =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             let uu___12 =
-                                               FStar_SMTEncoding_Term.mk_decls
-                                                 tsym tkey_hash t_decls
-                                                 (FStar_Compiler_List.op_At
-                                                    decls
-                                                    (FStar_Compiler_List.op_At
-                                                       decls' guard_decls)) in
-                                             FStar_Compiler_List.op_At
-                                               guard_decls uu___12 in
-                                           FStar_Compiler_List.op_At decls'
-                                             uu___11 in
-                                         FStar_Compiler_List.op_At decls
-                                           uu___10 in
-                                       (t2, uu___9)))))
-                 else
-                   (let tkey_hash =
-                      let uu___5 =
-                        encode_binders FStar_Pervasives_Native.None binders1
-                          env in
-                      match uu___5 with
-                      | (vars, guards_l, env_bs, uu___6, uu___7) ->
-                          let c1 =
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_TypeChecker_Env.push_binders
-                                  env.FStar_SMTEncoding_Env.tcenv binders1 in
-                              FStar_TypeChecker_Env.unfold_effect_abbrev
-                                uu___9 res in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___8
-                              FStar_Syntax_Syntax.mk_Comp in
-                          let uu___8 =
-                            let uu___9 =
-                              FStar_Compiler_Effect.op_Bar_Greater c1
-                                FStar_Syntax_Util.comp_result in
-                            encode_term uu___9 env_bs in
-                          (match uu___8 with
-                           | (ct, uu___9) ->
-                               let uu___10 =
-                                 let uu___11 =
-                                   FStar_Compiler_Effect.op_Bar_Greater c1
-                                     FStar_Syntax_Util.comp_effect_args in
-                                 encode_args uu___11 env_bs in
-                               (match uu___10 with
-                                | (effect_args, uu___11) ->
-                                    let tkey =
-                                      let uu___12 =
-                                        let uu___13 =
-                                          FStar_SMTEncoding_Util.mk_and_l
-                                            (FStar_Compiler_List.op_At
-                                               guards_l
-                                               (FStar_Compiler_List.op_At
-                                                  [ct] effect_args)) in
-                                        ([], vars, uu___13) in
-                                      FStar_SMTEncoding_Term.mkForall
-                                        t1.FStar_Syntax_Syntax.pos uu___12 in
-                                    let tkey_hash1 =
-                                      let uu___12 =
-                                        let uu___13 =
-                                          FStar_SMTEncoding_Term.hash_of_term
-                                            tkey in
-                                        let uu___14 =
-                                          let uu___15 =
-                                            let uu___16 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                c1
-                                                FStar_Syntax_Util.comp_effect_name in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___16
-                                              FStar_Ident.string_of_lid in
-                                          Prims.op_Hat "@Effect=" uu___15 in
-                                        Prims.op_Hat uu___13 uu___14 in
-                                      Prims.op_Hat "Non_total_Tm_arrow"
-                                        uu___12 in
-                                    FStar_Compiler_Util.digest_of_string
-                                      tkey_hash1)) in
-                    let tsym = Prims.op_Hat "Non_total_Tm_arrow_" tkey_hash in
-                    let tdecl =
-                      FStar_SMTEncoding_Term.DeclFun
-                        (tsym, [], FStar_SMTEncoding_Term.Term_sort,
-                          FStar_Pervasives_Native.None) in
-                    let t2 = FStar_SMTEncoding_Util.mkApp (tsym, []) in
-                    let t_kinding =
-                      let a_name =
-                        Prims.op_Hat "non_total_function_typing_" tsym in
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_SMTEncoding_Term.mk_HasType t2
-                            FStar_SMTEncoding_Term.mk_Term_type in
-                        (uu___6,
-                          (FStar_Pervasives_Native.Some
-                             "Typing for non-total arrows"), a_name) in
-                      FStar_SMTEncoding_Util.mkAssume uu___5 in
-                    let fsym =
-                      FStar_SMTEncoding_Term.mk_fv
-                        ("f", FStar_SMTEncoding_Term.Term_sort) in
-                    let f = FStar_SMTEncoding_Util.mkFreeV fsym in
-                    let f_has_t = FStar_SMTEncoding_Term.mk_HasType f t2 in
-                    let t_interp =
-                      let a_name = Prims.op_Hat "pre_typing_" tsym in
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_SMTEncoding_Term.mk_PreType f in
-                                  FStar_SMTEncoding_Term.mk_tester "Tm_arrow"
-                                    uu___11 in
-                                (f_has_t, uu___10) in
-                              FStar_SMTEncoding_Util.mkImp uu___9 in
-                            ([[f_has_t]], [fsym], uu___8) in
-                          let uu___8 =
-                            mkForall_fuel module_name
-                              t0.FStar_Syntax_Syntax.pos in
-                          uu___8 uu___7 in
-                        (uu___6, (FStar_Pervasives_Native.Some a_name),
-                          a_name) in
-                      FStar_SMTEncoding_Util.mkAssume uu___5 in
-                    let uu___5 =
-                      FStar_SMTEncoding_Term.mk_decls tsym tkey_hash
-                        [tdecl; t_kinding; t_interp] [] in
-                    (t2, uu___5)))
-        | FStar_Syntax_Syntax.Tm_refine uu___2 ->
-            let uu___3 =
-              let steps =
-                [FStar_TypeChecker_Env.Weak;
-                FStar_TypeChecker_Env.HNF;
-                FStar_TypeChecker_Env.EraseUniverses] in
-              let uu___4 =
-                normalize_refinement steps env.FStar_SMTEncoding_Env.tcenv t0 in
-              match uu___4 with
-              | {
-                  FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_refine
-                    (x, f);
-                  FStar_Syntax_Syntax.pos = uu___5;
-                  FStar_Syntax_Syntax.vars = uu___6;
-                  FStar_Syntax_Syntax.hash_code = uu___7;_} ->
-                  let uu___8 =
-                    let uu___9 =
-                      let uu___10 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___10] in
-                    FStar_Syntax_Subst.open_term uu___9 f in
-                  (match uu___8 with
-                   | (b, f1) ->
-                       let uu___9 =
-                         let uu___10 = FStar_Compiler_List.hd b in
-                         uu___10.FStar_Syntax_Syntax.binder_bv in
-                       (uu___9, f1))
-              | uu___5 -> failwith "impossible" in
-            (match uu___3 with
-             | (x, f) ->
-                 let uu___4 = encode_term x.FStar_Syntax_Syntax.sort env in
-                 (match uu___4 with
-                  | (base_t, decls) ->
-                      let uu___5 = FStar_SMTEncoding_Env.gen_term_var env x in
-                      (match uu___5 with
-                       | (x1, xtm, env') ->
-                           let uu___6 = encode_formula f env' in
-                           (match uu___6 with
-                            | (refinement, decls') ->
-                                let uu___7 =
-                                  FStar_SMTEncoding_Env.fresh_fvar
-                                    env.FStar_SMTEncoding_Env.current_module_name
-                                    "f" FStar_SMTEncoding_Term.Fuel_sort in
-                                (match uu___7 with
-                                 | (fsym, fterm) ->
-                                     let tm_has_type_with_fuel =
-                                       FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                         (FStar_Pervasives_Native.Some fterm)
-                                         xtm base_t in
-                                     let encoding =
-                                       FStar_SMTEncoding_Util.mkAnd
-                                         (tm_has_type_with_fuel, refinement) in
-                                     let cvars =
-                                       let uu___8 =
-                                         let uu___9 =
-                                           FStar_SMTEncoding_Term.free_variables
-                                             refinement in
-                                         let uu___10 =
-                                           FStar_SMTEncoding_Term.free_variables
-                                             tm_has_type_with_fuel in
-                                         FStar_Compiler_List.op_At uu___9
-                                           uu___10 in
-                                       FStar_Compiler_Util.remove_dups
-                                         FStar_SMTEncoding_Term.fv_eq uu___8 in
-                                     let cvars1 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         cvars
-                                         (FStar_Compiler_List.filter
-                                            (fun y ->
-                                               (let uu___8 =
-                                                  FStar_SMTEncoding_Term.fv_name
-                                                    y in
-                                                uu___8 <> x1) &&
-                                                 (let uu___8 =
-                                                    FStar_SMTEncoding_Term.fv_name
-                                                      y in
-                                                  uu___8 <> fsym))) in
-                                     let xfv =
-                                       FStar_SMTEncoding_Term.mk_fv
-                                         (x1,
-                                           FStar_SMTEncoding_Term.Term_sort) in
-                                     let ffv =
-                                       FStar_SMTEncoding_Term.mk_fv
-                                         (fsym,
-                                           FStar_SMTEncoding_Term.Fuel_sort) in
-                                     let tkey =
-                                       FStar_SMTEncoding_Term.mkForall
-                                         t0.FStar_Syntax_Syntax.pos
-                                         ([], (ffv :: xfv :: cvars1),
-                                           encoding) in
-                                     let tkey_hash =
-                                       FStar_SMTEncoding_Term.hash_of_term
-                                         tkey in
-                                     ((let uu___9 =
-                                         FStar_TypeChecker_Env.debug
-                                           env.FStar_SMTEncoding_Env.tcenv
-                                           (FStar_Options.Other "SMTEncoding") in
-                                       if uu___9
-                                       then
-                                         let uu___10 =
-                                           FStar_Syntax_Print.term_to_string
-                                             f in
-                                         let uu___11 =
-                                           FStar_Compiler_Util.digest_of_string
-                                             tkey_hash in
-                                         FStar_Compiler_Util.print3
-                                           "Encoding Tm_refine %s with tkey_hash %s and digest %s\n"
-                                           uu___10 tkey_hash uu___11
-                                       else ());
-                                      (let tsym =
-                                         let uu___9 =
-                                           FStar_Compiler_Util.digest_of_string
-                                             tkey_hash in
-                                         Prims.op_Hat "Tm_refine_" uu___9 in
-                                       let cvar_sorts =
-                                         FStar_Compiler_List.map
-                                           FStar_SMTEncoding_Term.fv_sort
-                                           cvars1 in
-                                       let tdecl =
-                                         FStar_SMTEncoding_Term.DeclFun
-                                           (tsym, cvar_sorts,
-                                             FStar_SMTEncoding_Term.Term_sort,
-                                             FStar_Pervasives_Native.None) in
-                                       let t2 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Compiler_List.map
-                                               FStar_SMTEncoding_Util.mkFreeV
-                                               cvars1 in
-                                           (tsym, uu___10) in
-                                         FStar_SMTEncoding_Util.mkApp uu___9 in
-                                       let x_has_base_t =
-                                         FStar_SMTEncoding_Term.mk_HasType
-                                           xtm base_t in
-                                       let x_has_t =
-                                         FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                           (FStar_Pervasives_Native.Some
-                                              fterm) xtm t2 in
-                                       let t_has_kind =
-                                         FStar_SMTEncoding_Term.mk_HasType t2
-                                           FStar_SMTEncoding_Term.mk_Term_type in
-                                       let t_haseq_base =
-                                         FStar_SMTEncoding_Term.mk_haseq
-                                           base_t in
-                                       let t_haseq_ref =
-                                         FStar_SMTEncoding_Term.mk_haseq t2 in
-                                       let t_haseq =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_SMTEncoding_Util.mkIff
-                                                   (t_haseq_ref,
-                                                     t_haseq_base) in
-                                               ([[t_haseq_ref]], cvars1,
-                                                 uu___12) in
-                                             FStar_SMTEncoding_Term.mkForall
-                                               t0.FStar_Syntax_Syntax.pos
-                                               uu___11 in
-                                           (uu___10,
-                                             (FStar_Pervasives_Native.Some
-                                                (Prims.op_Hat "haseq for "
-                                                   tsym)),
-                                             (Prims.op_Hat "haseq" tsym)) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___9 in
-                                       let t_kinding =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_SMTEncoding_Term.mkForall
-                                               t0.FStar_Syntax_Syntax.pos
-                                               ([[t_has_kind]], cvars1,
-                                                 t_has_kind) in
-                                           (uu___10,
-                                             (FStar_Pervasives_Native.Some
-                                                "refinement kinding"),
-                                             (Prims.op_Hat
-                                                "refinement_kinding_" tsym)) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___9 in
-                                       let t_interp =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_SMTEncoding_Util.mkIff
-                                                   (x_has_t, encoding) in
-                                               ([[x_has_t]], (ffv :: xfv ::
-                                                 cvars1), uu___12) in
-                                             FStar_SMTEncoding_Term.mkForall
-                                               t0.FStar_Syntax_Syntax.pos
-                                               uu___11 in
-                                           (uu___10,
-                                             (FStar_Pervasives_Native.Some
-                                                "refinement_interpretation"),
-                                             (Prims.op_Hat
-                                                "refinement_interpretation_"
-                                                tsym)) in
-                                         FStar_SMTEncoding_Util.mkAssume
-                                           uu___9 in
-                                       let t_decls =
-                                         [tdecl;
-                                         t_kinding;
-                                         t_interp;
-                                         t_haseq] in
-                                       let uu___9 =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             FStar_SMTEncoding_Term.mk_decls
-                                               tsym tkey_hash t_decls
-                                               (FStar_Compiler_List.op_At
-                                                  decls decls') in
-                                           FStar_Compiler_List.op_At decls'
-                                             uu___11 in
-                                         FStar_Compiler_List.op_At decls
-                                           uu___10 in
-                                       (t2, uu___9))))))))
-        | FStar_Syntax_Syntax.Tm_uvar (uv, uu___2) ->
-            let ttm =
-              let uu___3 =
-                FStar_Syntax_Unionfind.uvar_id
-                  uv.FStar_Syntax_Syntax.ctx_uvar_head in
-              FStar_SMTEncoding_Util.mk_Term_uvar uu___3 in
-            let uu___3 =
-              let uu___4 = FStar_Syntax_Util.ctx_uvar_typ uv in
-              encode_term_pred FStar_Pervasives_Native.None uu___4 env ttm in
-            (match uu___3 with
-             | (t_has_k, decls) ->
-                 let d =
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 =
-                           let uu___8 =
-                             FStar_Syntax_Unionfind.uvar_id
-                               uv.FStar_Syntax_Syntax.ctx_uvar_head in
-                           FStar_Compiler_Util.string_of_int uu___8 in
-                         FStar_Compiler_Util.format1 "uvar_typing_%s" uu___7 in
-                       FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.mk_unique
-                         uu___6 in
-                     (t_has_k, (FStar_Pervasives_Native.Some "Uvar typing"),
-                       uu___5) in
-                   FStar_SMTEncoding_Util.mkAssume uu___4 in
-                 let uu___4 =
-                   let uu___5 =
-                     FStar_Compiler_Effect.op_Bar_Greater [d]
-                       FStar_SMTEncoding_Term.mk_decls_trivial in
-                   FStar_Compiler_List.op_At decls uu___5 in
-                 (ttm, uu___4))
-        | FStar_Syntax_Syntax.Tm_app uu___2 ->
-            let uu___3 = FStar_Syntax_Util.head_and_args t0 in
-            (match uu___3 with
-             | (head, args_e) ->
-                 let uu___4 =
-                   let uu___5 = head_redex env head in
-                   if uu___5
-                   then
-                     let uu___6 = maybe_whnf env t0 in
-                     match uu___6 with
-                     | FStar_Pervasives_Native.None -> (head, args_e)
-                     | FStar_Pervasives_Native.Some t2 ->
-                         FStar_Syntax_Util.head_and_args t2
-                   else (head, args_e) in
-                 (match uu___4 with
-                  | (head1, args_e1) ->
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 = FStar_Syntax_Subst.compress head1 in
-                          uu___7.FStar_Syntax_Syntax.n in
-                        (uu___6, args_e1) in
-                      (match uu___5 with
-                       | uu___6 when is_arithmetic_primitive head1 args_e1 ->
-                           encode_arith_term env head1 args_e1
-                       | uu___6 when is_BitVector_primitive head1 args_e1 ->
-                           encode_BitVector_term env head1 args_e1
-                       | (FStar_Syntax_Syntax.Tm_fvar fv, (arg, uu___6)::[])
-                           when
-                           ((FStar_Syntax_Syntax.fv_eq_lid fv
-                               FStar_Parser_Const.squash_lid)
-                              ||
-                              (FStar_Syntax_Syntax.fv_eq_lid fv
-                                 FStar_Parser_Const.auto_squash_lid))
-                             &&
-                             (let uu___7 =
-                                FStar_Syntax_Util.destruct_typ_as_formula arg in
-                              FStar_Compiler_Option.isSome uu___7)
-                           ->
-                           let dummy =
-                             FStar_Syntax_Syntax.new_bv
-                               FStar_Pervasives_Native.None
-                               FStar_Syntax_Syntax.t_unit in
-                           let t2 = FStar_Syntax_Util.refine dummy arg in
-                           encode_term t2 env
-                       | (FStar_Syntax_Syntax.Tm_uinst
-                          ({
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.Tm_fvar fv;
-                             FStar_Syntax_Syntax.pos = uu___6;
-                             FStar_Syntax_Syntax.vars = uu___7;
-                             FStar_Syntax_Syntax.hash_code = uu___8;_},
-                           uu___9),
-                          (arg, uu___10)::[]) when
-                           ((FStar_Syntax_Syntax.fv_eq_lid fv
-                               FStar_Parser_Const.squash_lid)
-                              ||
-                              (FStar_Syntax_Syntax.fv_eq_lid fv
-                                 FStar_Parser_Const.auto_squash_lid))
-                             &&
-                             (let uu___11 =
-                                FStar_Syntax_Util.destruct_typ_as_formula arg in
-                              FStar_Compiler_Option.isSome uu___11)
-                           ->
-                           let dummy =
-                             FStar_Syntax_Syntax.new_bv
-                               FStar_Pervasives_Native.None
-                               FStar_Syntax_Syntax.t_unit in
-                           let t2 = FStar_Syntax_Util.refine dummy arg in
-                           encode_term t2 env
-                       | (FStar_Syntax_Syntax.Tm_fvar fv, uu___6) when
-                           (Prims.op_Negation
-                              env.FStar_SMTEncoding_Env.encoding_quantifier)
-                             &&
-                             ((FStar_Syntax_Syntax.fv_eq_lid fv
-                                 FStar_Parser_Const.forall_lid)
-                                ||
-                                (FStar_Syntax_Syntax.fv_eq_lid fv
-                                   FStar_Parser_Const.exists_lid))
-                           -> encode_deeply_embedded_quantifier t0 env
-                       | (FStar_Syntax_Syntax.Tm_uinst
-                          ({
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.Tm_fvar fv;
-                             FStar_Syntax_Syntax.pos = uu___6;
-                             FStar_Syntax_Syntax.vars = uu___7;
-                             FStar_Syntax_Syntax.hash_code = uu___8;_},
-                           uu___9),
-                          uu___10) when
-                           (Prims.op_Negation
-                              env.FStar_SMTEncoding_Env.encoding_quantifier)
-                             &&
-                             ((FStar_Syntax_Syntax.fv_eq_lid fv
-                                 FStar_Parser_Const.forall_lid)
-                                ||
-                                (FStar_Syntax_Syntax.fv_eq_lid fv
-                                   FStar_Parser_Const.exists_lid))
-                           -> encode_deeply_embedded_quantifier t0 env
-                       | (FStar_Syntax_Syntax.Tm_constant
-                          (FStar_Const.Const_range_of), (arg, uu___6)::[]) ->
-                           encode_const
-                             (FStar_Const.Const_range
-                                (arg.FStar_Syntax_Syntax.pos)) env
-                       | (FStar_Syntax_Syntax.Tm_constant
-                          (FStar_Const.Const_set_range_of),
-                          (arg, uu___6)::(rng, uu___7)::[]) ->
-                           encode_term arg env
-                       | (FStar_Syntax_Syntax.Tm_constant
-                          (FStar_Const.Const_reify), uu___6) ->
-                           let e0 =
-                             let uu___7 = FStar_Compiler_List.hd args_e1 in
-                             FStar_TypeChecker_Util.reify_body_with_arg
-                               env.FStar_SMTEncoding_Env.tcenv [] head1
-                               uu___7 in
-                           ((let uu___8 =
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_TypeChecker_Env.debug
-                                    env.FStar_SMTEncoding_Env.tcenv)
-                                 (FStar_Options.Other "SMTEncodingReify") in
-                             if uu___8
-                             then
-                               let uu___9 =
-                                 FStar_Syntax_Print.term_to_string e0 in
-                               FStar_Compiler_Util.print1
-                                 "Result of normalization %s\n" uu___9
-                             else ());
-                            (let e =
-                               let uu___8 =
-                                 FStar_TypeChecker_Util.remove_reify e0 in
-                               let uu___9 = FStar_Compiler_List.tl args_e1 in
-                               FStar_Syntax_Syntax.mk_Tm_app uu___8 uu___9
-                                 t0.FStar_Syntax_Syntax.pos in
-                             encode_term e env))
-                       | (FStar_Syntax_Syntax.Tm_constant
-                          (FStar_Const.Const_reflect uu___6),
-                          (arg, uu___7)::[]) -> encode_term arg env
-                       | (FStar_Syntax_Syntax.Tm_fvar fv,
-                          uu___6::(phi, uu___7)::[]) when
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.by_tactic_lid
-                           -> encode_term phi env
-                       | (FStar_Syntax_Syntax.Tm_uinst
-                          ({
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.Tm_fvar fv;
-                             FStar_Syntax_Syntax.pos = uu___6;
-                             FStar_Syntax_Syntax.vars = uu___7;
-                             FStar_Syntax_Syntax.hash_code = uu___8;_},
-                           uu___9),
-                          uu___10::(phi, uu___11)::[]) when
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.by_tactic_lid
-                           -> encode_term phi env
-                       | (FStar_Syntax_Syntax.Tm_fvar fv,
-                          uu___6::uu___7::(phi, uu___8)::[]) when
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.rewrite_by_tactic_lid
-                           -> encode_term phi env
-                       | (FStar_Syntax_Syntax.Tm_uinst
-                          ({
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.Tm_fvar fv;
-                             FStar_Syntax_Syntax.pos = uu___6;
-                             FStar_Syntax_Syntax.vars = uu___7;
-                             FStar_Syntax_Syntax.hash_code = uu___8;_},
-                           uu___9),
-                          uu___10::uu___11::(phi, uu___12)::[]) when
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.rewrite_by_tactic_lid
-                           -> encode_term phi env
-                       | uu___6 ->
-                           let uu___7 = encode_args args_e1 env in
-                           (match uu___7 with
-                            | (args, decls) ->
-                                let encode_partial_app ht_opt =
-                                  let uu___8 = encode_term head1 env in
-                                  match uu___8 with
-                                  | (smt_head, decls') ->
-                                      let app_tm =
-                                        mk_Apply_args smt_head args in
-                                      (match ht_opt with
-                                       | uu___9 when
-                                           Prims.int_one = Prims.int_one ->
-                                           (app_tm,
-                                             (FStar_Compiler_List.op_At decls
-                                                decls'))
-                                       | FStar_Pervasives_Native.Some
-                                           (head_type, formals, c) ->
-                                           ((let uu___10 =
-                                               FStar_TypeChecker_Env.debug
-                                                 env.FStar_SMTEncoding_Env.tcenv
-                                                 (FStar_Options.Other
-                                                    "PartialApp") in
-                                             if uu___10
-                                             then
-                                               let uu___11 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   head1 in
-                                               let uu___12 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   head_type in
-                                               let uu___13 =
-                                                 FStar_Syntax_Print.binders_to_string
-                                                   ", " formals in
-                                               let uu___14 =
-                                                 FStar_Syntax_Print.comp_to_string
-                                                   c in
-                                               let uu___15 =
-                                                 FStar_Syntax_Print.args_to_string
-                                                   args_e1 in
-                                               FStar_Compiler_Util.print5
-                                                 "Encoding partial application:\n\thead=%s\n\thead_type=%s\n\tformals=%s\n\tcomp=%s\n\tactual args=%s\n"
-                                                 uu___11 uu___12 uu___13
-                                                 uu___14 uu___15
-                                             else ());
-                                            (let uu___10 =
-                                               FStar_Compiler_Util.first_N
-                                                 (FStar_Compiler_List.length
-                                                    args_e1) formals in
-                                             match uu___10 with
-                                             | (formals1, rest) ->
-                                                 let subst =
-                                                   FStar_Compiler_List.map2
-                                                     (fun uu___11 ->
-                                                        fun uu___12 ->
-                                                          match (uu___11,
-                                                                  uu___12)
-                                                          with
-                                                          | ({
-                                                               FStar_Syntax_Syntax.binder_bv
-                                                                 = bv;
-                                                               FStar_Syntax_Syntax.binder_qual
-                                                                 = uu___13;
-                                                               FStar_Syntax_Syntax.binder_attrs
-                                                                 = uu___14;_},
-                                                             (a, uu___15)) ->
-                                                              FStar_Syntax_Syntax.NT
-                                                                (bv, a))
-                                                     formals1 args_e1 in
-                                                 let ty =
-                                                   let uu___11 =
-                                                     FStar_Syntax_Util.arrow
-                                                       rest c in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___11
-                                                     (FStar_Syntax_Subst.subst
-                                                        subst) in
-                                                 ((let uu___12 =
-                                                     FStar_TypeChecker_Env.debug
-                                                       env.FStar_SMTEncoding_Env.tcenv
-                                                       (FStar_Options.Other
-                                                          "PartialApp") in
-                                                   if uu___12
-                                                   then
-                                                     let uu___13 =
-                                                       FStar_Syntax_Print.term_to_string
-                                                         ty in
-                                                     FStar_Compiler_Util.print1
-                                                       "Encoding partial application, after subst:\n\tty=%s\n"
-                                                       uu___13
-                                                   else ());
-                                                  (let uu___12 =
-                                                     let uu___13 =
-                                                       FStar_Compiler_List.fold_left2
-                                                         (fun uu___14 ->
-                                                            fun uu___15 ->
-                                                              fun e ->
-                                                                match 
-                                                                  (uu___14,
-                                                                    uu___15)
-                                                                with
-                                                                | ((t_hyps,
-                                                                    decls1),
-                                                                   {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___16;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___17;_})
-                                                                    ->
-                                                                    let t2 =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    subst
-                                                                    bv.FStar_Syntax_Syntax.sort in
-                                                                    let uu___18
-                                                                    =
-                                                                    encode_term_pred
-                                                                    FStar_Pervasives_Native.None
-                                                                    t2 env e in
-                                                                    (match uu___18
-                                                                    with
-                                                                    | 
-                                                                    (t_hyp,
-                                                                    decls'1)
-                                                                    ->
-                                                                    ((
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_Env.debug
-                                                                    env.FStar_SMTEncoding_Env.tcenv
-                                                                    (FStar_Options.Other
-                                                                    "PartialApp") in
-                                                                    if
-                                                                    uu___20
-                                                                    then
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t2 in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.print_smt_term
-                                                                    t_hyp in
-                                                                    FStar_Compiler_Util.print2
-                                                                    "Encoded typing hypothesis for %s ... got %s\n"
-                                                                    uu___21
-                                                                    uu___22
-                                                                    else ());
-                                                                    ((t_hyp
-                                                                    ::
-                                                                    t_hyps),
-                                                                    (FStar_Compiler_List.op_At
-                                                                    decls1
-                                                                    decls'1)))))
-                                                         ([], []) formals1
-                                                         args in
-                                                     match uu___13 with
-                                                     | (t_hyps, decls1) ->
-                                                         let uu___14 =
-                                                           match smt_head.FStar_SMTEncoding_Term.tm
-                                                           with
-                                                           | FStar_SMTEncoding_Term.FreeV
-                                                               uu___15 ->
-                                                               encode_term_pred
-                                                                 FStar_Pervasives_Native.None
-                                                                 head_type
-                                                                 env smt_head
-                                                           | uu___15 ->
-                                                               (FStar_SMTEncoding_Util.mkTrue,
-                                                                 []) in
-                                                         (match uu___14 with
-                                                          | (t_head_hyp,
-                                                             decls'1) ->
-                                                              let hyp =
-                                                                FStar_SMTEncoding_Term.mk_and_l
-                                                                  (t_head_hyp
-                                                                  :: t_hyps)
-                                                                  FStar_Compiler_Range.dummyRange in
-                                                              let uu___15 =
-                                                                encode_term_pred
-                                                                  FStar_Pervasives_Native.None
-                                                                  ty env
-                                                                  app_tm in
-                                                              (match uu___15
-                                                               with
-                                                               | (has_type_conclusion,
-                                                                  decls'') ->
-                                                                   let has_type
-                                                                    =
-                                                                    FStar_SMTEncoding_Util.mkImp
-                                                                    (hyp,
-                                                                    has_type_conclusion) in
-                                                                   let cvars
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.free_variables
-                                                                    has_type in
-                                                                   let app_tm_vars
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.free_variables
-                                                                    app_tm in
-                                                                   let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.fvs_subset_of
-                                                                    cvars
-                                                                    app_tm_vars in
-                                                                    if
-                                                                    uu___17
-                                                                    then
-                                                                    ([app_tm],
-                                                                    app_tm_vars)
-                                                                    else
-                                                                    (let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.free_variables
-                                                                    has_type_conclusion in
-                                                                    FStar_SMTEncoding_Term.fvs_subset_of
-                                                                    cvars
-                                                                    uu___20 in
-                                                                    if
-                                                                    uu___19
-                                                                    then
-                                                                    ([has_type_conclusion],
-                                                                    cvars)
-                                                                    else
-                                                                    ((
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t0 in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "No SMT pattern for partial application %s"
-                                                                    uu___24 in
-                                                                    (FStar_Errors.Warning_SMTPatternIllFormed,
-                                                                    uu___23) in
-                                                                    FStar_Errors.log_issue
-                                                                    t0.FStar_Syntax_Syntax.pos
-                                                                    uu___22);
-                                                                    ([],
-                                                                    cvars))) in
-                                                                   (match uu___16
-                                                                    with
-                                                                    | 
-                                                                    (pattern1,
-                                                                    vars) ->
-                                                                    (vars,
-                                                                    pattern1,
-                                                                    has_type,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    decls1
-                                                                    (FStar_Compiler_List.op_At
-                                                                    decls'1
-                                                                    decls'')))))) in
-                                                   match uu___12 with
-                                                   | (vars, pattern1,
-                                                      has_type, decls'') ->
-                                                       ((let uu___14 =
-                                                           FStar_TypeChecker_Env.debug
-                                                             env.FStar_SMTEncoding_Env.tcenv
-                                                             (FStar_Options.Other
-                                                                "PartialApp") in
-                                                         if uu___14
-                                                         then
-                                                           let uu___15 =
-                                                             FStar_SMTEncoding_Term.print_smt_term
-                                                               has_type in
-                                                           FStar_Compiler_Util.print1
-                                                             "Encoding partial application, after SMT encoded predicate:\n\t=%s\n"
-                                                             uu___15
-                                                         else ());
-                                                        (let tkey_hash =
-                                                           FStar_SMTEncoding_Term.hash_of_term
-                                                             app_tm in
-                                                         let e_typing =
-                                                           let uu___14 =
-                                                             let uu___15 =
-                                                               FStar_SMTEncoding_Term.mkForall
-                                                                 t0.FStar_Syntax_Syntax.pos
-                                                                 ([pattern1],
-                                                                   vars,
-                                                                   has_type) in
-                                                             let uu___16 =
-                                                               let uu___17 =
-                                                                 let uu___18
-                                                                   =
-                                                                   FStar_SMTEncoding_Term.hash_of_term
-                                                                    app_tm in
-                                                                 FStar_Compiler_Util.digest_of_string
-                                                                   uu___18 in
-                                                               Prims.op_Hat
-                                                                 "partial_app_typing_"
-                                                                 uu___17 in
-                                                             (uu___15,
-                                                               (FStar_Pervasives_Native.Some
-                                                                  "Partial app typing"),
-                                                               uu___16) in
-                                                           FStar_SMTEncoding_Util.mkAssume
-                                                             uu___14 in
-                                                         let uu___14 =
-                                                           let uu___15 =
-                                                             let uu___16 =
-                                                               let uu___17 =
-                                                                 FStar_SMTEncoding_Term.mk_decls
-                                                                   ""
-                                                                   tkey_hash
-                                                                   [e_typing]
-                                                                   (FStar_Compiler_List.op_At
-                                                                    decls
-                                                                    (FStar_Compiler_List.op_At
-                                                                    decls'
-                                                                    decls'')) in
-                                                               FStar_Compiler_List.op_At
-                                                                 decls''
-                                                                 uu___17 in
-                                                             FStar_Compiler_List.op_At
-                                                               decls' uu___16 in
-                                                           FStar_Compiler_List.op_At
-                                                             decls uu___15 in
-                                                         (app_tm, uu___14)))))))
-                                       | FStar_Pervasives_Native.None ->
-                                           failwith "impossible") in
-                                let encode_full_app fv =
-                                  let uu___8 =
-                                    FStar_SMTEncoding_Env.lookup_free_var_sym
-                                      env fv in
-                                  match uu___8 with
-                                  | (fname, fuel_args, arity) ->
-                                      let tm =
-                                        maybe_curry_app
-                                          t0.FStar_Syntax_Syntax.pos fname
-                                          arity
-                                          (FStar_Compiler_List.op_At
-                                             fuel_args args) in
-                                      (tm, decls) in
-                                let head2 = FStar_Syntax_Subst.compress head1 in
-                                let head_type =
-                                  match head2.FStar_Syntax_Syntax.n with
-                                  | FStar_Syntax_Syntax.Tm_uinst
-                                      ({
-                                         FStar_Syntax_Syntax.n =
-                                           FStar_Syntax_Syntax.Tm_name x;
-                                         FStar_Syntax_Syntax.pos = uu___8;
-                                         FStar_Syntax_Syntax.vars = uu___9;
-                                         FStar_Syntax_Syntax.hash_code =
-                                           uu___10;_},
-                                       uu___11)
-                                      ->
-                                      FStar_Pervasives_Native.Some
-                                        (x.FStar_Syntax_Syntax.sort)
-                                  | FStar_Syntax_Syntax.Tm_name x ->
-                                      FStar_Pervasives_Native.Some
-                                        (x.FStar_Syntax_Syntax.sort)
-                                  | FStar_Syntax_Syntax.Tm_uinst
-                                      ({
-                                         FStar_Syntax_Syntax.n =
-                                           FStar_Syntax_Syntax.Tm_fvar fv;
-                                         FStar_Syntax_Syntax.pos = uu___8;
-                                         FStar_Syntax_Syntax.vars = uu___9;
-                                         FStar_Syntax_Syntax.hash_code =
-                                           uu___10;_},
-                                       uu___11)
-                                      ->
-                                      let uu___12 =
-                                        let uu___13 =
-                                          let uu___14 =
-                                            FStar_TypeChecker_Env.lookup_lid
-                                              env.FStar_SMTEncoding_Env.tcenv
-                                              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___14
-                                            FStar_Pervasives_Native.fst in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___13 FStar_Pervasives_Native.snd in
-                                      FStar_Pervasives_Native.Some uu___12
-                                  | FStar_Syntax_Syntax.Tm_fvar fv ->
-                                      let uu___8 =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            FStar_TypeChecker_Env.lookup_lid
-                                              env.FStar_SMTEncoding_Env.tcenv
-                                              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___10
-                                            FStar_Pervasives_Native.fst in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___9 FStar_Pervasives_Native.snd in
-                                      FStar_Pervasives_Native.Some uu___8
-                                  | FStar_Syntax_Syntax.Tm_ascribed
-                                      (uu___8,
-                                       (FStar_Pervasives.Inl t2, uu___9,
-                                        uu___10),
-                                       uu___11)
-                                      -> FStar_Pervasives_Native.Some t2
-                                  | FStar_Syntax_Syntax.Tm_ascribed
-                                      (uu___8,
-                                       (FStar_Pervasives.Inr c, uu___9,
-                                        uu___10),
-                                       uu___11)
-                                      ->
-                                      FStar_Pervasives_Native.Some
-                                        (FStar_Syntax_Util.comp_result c)
-                                  | uu___8 -> FStar_Pervasives_Native.None in
-                                (match head_type with
-                                 | FStar_Pervasives_Native.None ->
-                                     encode_partial_app
-                                       FStar_Pervasives_Native.None
-                                 | FStar_Pervasives_Native.Some head_type1 ->
-                                     let uu___8 =
-                                       let head_type2 =
-                                         let uu___9 =
-                                           normalize_refinement
-                                             [FStar_TypeChecker_Env.Weak;
-                                             FStar_TypeChecker_Env.HNF;
-                                             FStar_TypeChecker_Env.EraseUniverses]
-                                             env.FStar_SMTEncoding_Env.tcenv
-                                             head_type1 in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           FStar_Syntax_Util.unrefine uu___9 in
-                                       let uu___9 =
-                                         curried_arrow_formals_comp
-                                           head_type2 in
-                                       match uu___9 with
-                                       | (formals, c) ->
-                                           if
-                                             (FStar_Compiler_List.length
-                                                formals)
-                                               <
-                                               (FStar_Compiler_List.length
-                                                  args)
-                                           then
-                                             let head_type3 =
-                                               let uu___10 =
-                                                 normalize_refinement
-                                                   [FStar_TypeChecker_Env.Weak;
-                                                   FStar_TypeChecker_Env.HNF;
-                                                   FStar_TypeChecker_Env.EraseUniverses;
-                                                   FStar_TypeChecker_Env.UnfoldUntil
-                                                     FStar_Syntax_Syntax.delta_constant]
-                                                   env.FStar_SMTEncoding_Env.tcenv
-                                                   head_type2 in
-                                               FStar_Compiler_Effect.op_Less_Bar
-                                                 FStar_Syntax_Util.unrefine
-                                                 uu___10 in
-                                             let uu___10 =
-                                               curried_arrow_formals_comp
-                                                 head_type3 in
-                                             (match uu___10 with
-                                              | (formals1, c1) ->
-                                                  (head_type3, formals1, c1))
-                                           else (head_type2, formals, c) in
-                                     (match uu___8 with
-                                      | (head_type2, formals, c) ->
-                                          ((let uu___10 =
-                                              FStar_TypeChecker_Env.debug
-                                                env.FStar_SMTEncoding_Env.tcenv
-                                                (FStar_Options.Other
-                                                   "PartialApp") in
-                                            if uu___10
-                                            then
-                                              let uu___11 =
-                                                FStar_Syntax_Print.term_to_string
-                                                  head_type2 in
-                                              let uu___12 =
-                                                FStar_Syntax_Print.binders_to_string
-                                                  ", " formals in
-                                              let uu___13 =
-                                                FStar_Syntax_Print.args_to_string
-                                                  args_e1 in
-                                              FStar_Compiler_Util.print3
-                                                "Encoding partial application, head_type = %s, formals = %s, args = %s\n"
-                                                uu___11 uu___12 uu___13
-                                            else ());
-                                           (match head2.FStar_Syntax_Syntax.n
-                                            with
-                                            | FStar_Syntax_Syntax.Tm_uinst
-                                                ({
-                                                   FStar_Syntax_Syntax.n =
-                                                     FStar_Syntax_Syntax.Tm_fvar
-                                                     fv;
-                                                   FStar_Syntax_Syntax.pos =
-                                                     uu___10;
-                                                   FStar_Syntax_Syntax.vars =
-                                                     uu___11;
-                                                   FStar_Syntax_Syntax.hash_code
-                                                     = uu___12;_},
-                                                 uu___13)
-                                                when
-                                                (FStar_Compiler_List.length
-                                                   formals)
-                                                  =
-                                                  (FStar_Compiler_List.length
-                                                     args)
-                                                ->
-                                                encode_full_app
-                                                  fv.FStar_Syntax_Syntax.fv_name
-                                            | FStar_Syntax_Syntax.Tm_fvar fv
-                                                when
-                                                (FStar_Compiler_List.length
-                                                   formals)
-                                                  =
-                                                  (FStar_Compiler_List.length
-                                                     args)
-                                                ->
-                                                encode_full_app
-                                                  fv.FStar_Syntax_Syntax.fv_name
-                                            | uu___10 ->
-                                                if
-                                                  (FStar_Compiler_List.length
-                                                     formals)
-                                                    >
-                                                    (FStar_Compiler_List.length
-                                                       args)
-                                                then
-                                                  encode_partial_app
-                                                    (FStar_Pervasives_Native.Some
-                                                       (head_type2, formals,
-                                                         c))
-                                                else
-                                                  encode_partial_app
-                                                    FStar_Pervasives_Native.None))))))))
-        | FStar_Syntax_Syntax.Tm_abs (bs, body, lopt) ->
-            let uu___2 = FStar_Syntax_Subst.open_term' bs body in
-            (match uu___2 with
-             | (bs1, body1, opening) ->
-                 let fallback uu___3 =
-                   let f =
-                     FStar_SMTEncoding_Env.varops.FStar_SMTEncoding_Env.fresh
-                       env.FStar_SMTEncoding_Env.current_module_name "Tm_abs" in
-                   let decl =
-                     FStar_SMTEncoding_Term.DeclFun
-                       (f, [], FStar_SMTEncoding_Term.Term_sort,
-                         (FStar_Pervasives_Native.Some
-                            "Imprecise function encoding")) in
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_SMTEncoding_Term.mk_fv
-                         (f, FStar_SMTEncoding_Term.Term_sort) in
-                     FStar_Compiler_Effect.op_Less_Bar
-                       FStar_SMTEncoding_Util.mkFreeV uu___5 in
-                   let uu___5 =
-                     FStar_Compiler_Effect.op_Bar_Greater [decl]
-                       FStar_SMTEncoding_Term.mk_decls_trivial in
-                   (uu___4, uu___5) in
-                 let is_impure rc =
-                   let uu___3 =
-                     FStar_TypeChecker_Util.is_pure_or_ghost_effect
-                       env.FStar_SMTEncoding_Env.tcenv
-                       rc.FStar_Syntax_Syntax.residual_effect in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___3
-                     Prims.op_Negation in
-                 let codomain_eff rc =
-                   let res_typ =
-                     match rc.FStar_Syntax_Syntax.residual_typ with
-                     | FStar_Pervasives_Native.None ->
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_TypeChecker_Env.get_range
-                               env.FStar_SMTEncoding_Env.tcenv in
-                           FStar_TypeChecker_Util.new_implicit_var
-                             "SMTEncoding codomain" uu___4
-                             env.FStar_SMTEncoding_Env.tcenv
-                             FStar_Syntax_Util.ktype0 in
-                         (match uu___3 with | (t2, uu___4, uu___5) -> t2)
-                     | FStar_Pervasives_Native.Some t2 -> t2 in
-                   let uu___3 =
-                     FStar_Ident.lid_equals
-                       rc.FStar_Syntax_Syntax.residual_effect
-                       FStar_Parser_Const.effect_Tot_lid in
-                   if uu___3
-                   then
-                     let uu___4 = FStar_Syntax_Syntax.mk_Total res_typ in
-                     FStar_Pervasives_Native.Some uu___4
-                   else
-                     (let uu___5 =
-                        FStar_Ident.lid_equals
-                          rc.FStar_Syntax_Syntax.residual_effect
-                          FStar_Parser_Const.effect_GTot_lid in
-                      if uu___5
-                      then
-                        let uu___6 = FStar_Syntax_Syntax.mk_GTotal res_typ in
-                        FStar_Pervasives_Native.Some uu___6
-                      else FStar_Pervasives_Native.None) in
-                 (match lopt with
-                  | FStar_Pervasives_Native.None ->
-                      ((let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Syntax_Print.term_to_string t0 in
-                            FStar_Compiler_Util.format1
-                              "Losing precision when encoding a function literal: %s\n(Unnannotated abstraction in the compiler ?)"
-                              uu___6 in
-                          (FStar_Errors.Warning_FunctionLiteralPrecisionLoss,
-                            uu___5) in
-                        FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                          uu___4);
-                       fallback ())
-                  | FStar_Pervasives_Native.Some rc ->
-                      let uu___3 =
-                        (is_impure rc) &&
-                          (let uu___4 =
-                             FStar_SMTEncoding_Util.is_smt_reifiable_rc
-                               env.FStar_SMTEncoding_Env.tcenv rc in
-                           Prims.op_Negation uu___4) in
-                      if uu___3
-                      then fallback ()
-                      else
-                        (let uu___5 =
-                           encode_binders FStar_Pervasives_Native.None bs1
-                             env in
-                         match uu___5 with
-                         | (vars, guards, envbody, decls, uu___6) ->
-                             let body2 =
-                               let uu___7 =
-                                 FStar_SMTEncoding_Util.is_smt_reifiable_rc
-                                   env.FStar_SMTEncoding_Env.tcenv rc in
-                               if uu___7
-                               then
-                                 FStar_TypeChecker_Util.reify_body
-                                   env.FStar_SMTEncoding_Env.tcenv [] body1
-                               else body1 in
-                             let uu___7 = encode_term body2 envbody in
-                             (match uu___7 with
-                              | (body3, decls') ->
-                                  let is_pure =
-                                    FStar_Syntax_Util.is_pure_effect
-                                      rc.FStar_Syntax_Syntax.residual_effect in
-                                  let uu___8 =
-                                    let uu___9 = codomain_eff rc in
-                                    match uu___9 with
-                                    | FStar_Pervasives_Native.None ->
-                                        (FStar_Pervasives_Native.None, [])
-                                    | FStar_Pervasives_Native.Some c ->
-                                        let tfun =
-                                          FStar_Syntax_Util.arrow bs1 c in
-                                        let uu___10 = encode_term tfun env in
-                                        (match uu___10 with
-                                         | (t2, decls1) ->
-                                             ((FStar_Pervasives_Native.Some
-                                                 t2), decls1)) in
-                                  (match uu___8 with
-                                   | (arrow_t_opt, decls'') ->
-                                       let key_body =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_SMTEncoding_Util.mk_and_l
-                                                   guards in
-                                               (uu___12, body3) in
-                                             FStar_SMTEncoding_Util.mkImp
-                                               uu___11 in
-                                           ([], vars, uu___10) in
-                                         FStar_SMTEncoding_Term.mkForall
-                                           t0.FStar_Syntax_Syntax.pos uu___9 in
-                                       let cvars =
-                                         FStar_SMTEncoding_Term.free_variables
-                                           key_body in
-                                       let uu___9 =
-                                         match arrow_t_opt with
-                                         | FStar_Pervasives_Native.None ->
-                                             (cvars, key_body)
-                                         | FStar_Pervasives_Native.Some t2 ->
-                                             let uu___10 =
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_SMTEncoding_Term.free_variables
-                                                     t2 in
-                                                 FStar_Compiler_List.op_At
-                                                   uu___12 cvars in
-                                               FStar_Compiler_Util.remove_dups
-                                                 FStar_SMTEncoding_Term.fv_eq
-                                                 uu___11 in
-                                             let uu___11 =
-                                               FStar_SMTEncoding_Util.mkAnd
-                                                 (key_body, t2) in
-                                             (uu___10, uu___11) in
-                                       (match uu___9 with
-                                        | (cvars1, key_body1) ->
-                                            let tkey =
-                                              FStar_SMTEncoding_Term.mkForall
-                                                t0.FStar_Syntax_Syntax.pos
-                                                ([], cvars1, key_body1) in
-                                            let tkey_hash =
-                                              FStar_SMTEncoding_Term.hash_of_term
-                                                tkey in
-                                            ((let uu___11 =
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  (FStar_TypeChecker_Env.debug
-                                                     env.FStar_SMTEncoding_Env.tcenv)
-                                                  (FStar_Options.Other
-                                                     "PartialApp") in
-                                              if uu___11
-                                              then
-                                                let uu___12 =
-                                                  let uu___13 =
-                                                    FStar_Compiler_List.map
-                                                      FStar_SMTEncoding_Term.fv_name
-                                                      vars in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___13
-                                                    (FStar_String.concat ", ") in
-                                                let uu___13 =
-                                                  FStar_SMTEncoding_Term.print_smt_term
-                                                    body3 in
-                                                FStar_Compiler_Util.print2
-                                                  "Checking eta expansion of\n\tvars={%s}\n\tbody=%s\n"
-                                                  uu___12 uu___13
-                                              else ());
-                                             (let cvar_sorts =
-                                                FStar_Compiler_List.map
-                                                  FStar_SMTEncoding_Term.fv_sort
-                                                  cvars1 in
-                                              let fsym =
-                                                let uu___11 =
-                                                  FStar_Compiler_Util.digest_of_string
-                                                    tkey_hash in
-                                                Prims.op_Hat "Tm_abs_"
-                                                  uu___11 in
-                                              let fdecl =
-                                                FStar_SMTEncoding_Term.DeclFun
-                                                  (fsym, cvar_sorts,
-                                                    FStar_SMTEncoding_Term.Term_sort,
-                                                    FStar_Pervasives_Native.None) in
-                                              let f =
-                                                let uu___11 =
-                                                  let uu___12 =
-                                                    FStar_Compiler_List.map
-                                                      FStar_SMTEncoding_Util.mkFreeV
-                                                      cvars1 in
-                                                  (fsym, uu___12) in
-                                                FStar_SMTEncoding_Util.mkApp
-                                                  uu___11 in
-                                              let app = mk_Apply f vars in
-                                              let typing_f =
-                                                match arrow_t_opt with
-                                                | FStar_Pervasives_Native.None
-                                                    ->
-                                                    let tot_fun_ax =
-                                                      let ax =
-                                                        let uu___11 =
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            vars
-                                                            (FStar_Compiler_List.map
-                                                               (fun uu___12
-                                                                  ->
-                                                                  FStar_SMTEncoding_Util.mkTrue)) in
-                                                        isTotFun_axioms
-                                                          t0.FStar_Syntax_Syntax.pos
-                                                          f vars uu___11
-                                                          is_pure in
-                                                      match cvars1 with
-                                                      | [] -> ax
-                                                      | uu___11 ->
-                                                          FStar_SMTEncoding_Term.mkForall
-                                                            t0.FStar_Syntax_Syntax.pos
-                                                            ([[f]], cvars1,
-                                                              ax) in
-                                                    let a_name =
-                                                      Prims.op_Hat "tot_fun_"
-                                                        fsym in
-                                                    let uu___11 =
-                                                      FStar_SMTEncoding_Util.mkAssume
-                                                        (tot_fun_ax,
-                                                          (FStar_Pervasives_Native.Some
-                                                             a_name), a_name) in
-                                                    [uu___11]
-                                                | FStar_Pervasives_Native.Some
-                                                    t2 ->
-                                                    let f_has_t =
-                                                      FStar_SMTEncoding_Term.mk_HasTypeWithFuel
-                                                        FStar_Pervasives_Native.None
-                                                        f t2 in
-                                                    let a_name =
-                                                      Prims.op_Hat "typing_"
-                                                        fsym in
-                                                    let uu___11 =
-                                                      let uu___12 =
-                                                        let uu___13 =
-                                                          FStar_SMTEncoding_Term.mkForall
-                                                            t0.FStar_Syntax_Syntax.pos
-                                                            ([[f]], cvars1,
-                                                              f_has_t) in
-                                                        (uu___13,
-                                                          (FStar_Pervasives_Native.Some
-                                                             a_name), a_name) in
-                                                      FStar_SMTEncoding_Util.mkAssume
-                                                        uu___12 in
-                                                    [uu___11] in
-                                              let interp_f =
-                                                let a_name =
-                                                  Prims.op_Hat
-                                                    "interpretation_" fsym in
-                                                let uu___11 =
-                                                  let uu___12 =
-                                                    let uu___13 =
-                                                      let uu___14 =
-                                                        FStar_SMTEncoding_Util.mkEq
-                                                          (app, body3) in
-                                                      ([[app]],
-                                                        (FStar_Compiler_List.op_At
-                                                           vars cvars1),
-                                                        uu___14) in
-                                                    FStar_SMTEncoding_Term.mkForall
-                                                      t0.FStar_Syntax_Syntax.pos
-                                                      uu___13 in
-                                                  (uu___12,
-                                                    (FStar_Pervasives_Native.Some
-                                                       a_name), a_name) in
-                                                FStar_SMTEncoding_Util.mkAssume
-                                                  uu___11 in
-                                              let f_decls =
-                                                FStar_Compiler_List.op_At
-                                                  (fdecl :: typing_f)
-                                                  [interp_f] in
-                                              let uu___11 =
-                                                let uu___12 =
-                                                  let uu___13 =
-                                                    let uu___14 =
-                                                      FStar_SMTEncoding_Term.mk_decls
-                                                        fsym tkey_hash
-                                                        f_decls
-                                                        (FStar_Compiler_List.op_At
-                                                           decls
-                                                           (FStar_Compiler_List.op_At
-                                                              decls' decls'')) in
-                                                    FStar_Compiler_List.op_At
-                                                      decls'' uu___14 in
-                                                  FStar_Compiler_List.op_At
-                                                    decls' uu___13 in
-                                                FStar_Compiler_List.op_At
-                                                  decls uu___12 in
-                                              (f, uu___11)))))))))
-        | FStar_Syntax_Syntax.Tm_let
-            ((uu___2,
-              { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr uu___3;
-                FStar_Syntax_Syntax.lbunivs = uu___4;
-                FStar_Syntax_Syntax.lbtyp = uu___5;
-                FStar_Syntax_Syntax.lbeff = uu___6;
-                FStar_Syntax_Syntax.lbdef = uu___7;
-                FStar_Syntax_Syntax.lbattrs = uu___8;
-                FStar_Syntax_Syntax.lbpos = uu___9;_}::uu___10),
-             uu___11)
-            -> failwith "Impossible: already handled by encoding of Sig_let"
-        | FStar_Syntax_Syntax.Tm_let
-            ((false,
-              { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inl x;
-                FStar_Syntax_Syntax.lbunivs = uu___2;
-                FStar_Syntax_Syntax.lbtyp = t11;
-                FStar_Syntax_Syntax.lbeff = uu___3;
-                FStar_Syntax_Syntax.lbdef = e1;
-                FStar_Syntax_Syntax.lbattrs = uu___4;
-                FStar_Syntax_Syntax.lbpos = uu___5;_}::[]),
-             e2)
-            -> encode_let x t11 e1 e2 env encode_term
-        | FStar_Syntax_Syntax.Tm_let ((false, uu___2::uu___3), uu___4) ->
-            failwith "Impossible: non-recursive let with multiple bindings"
-        | FStar_Syntax_Syntax.Tm_let ((uu___2, lbs), uu___3) ->
-            let names =
-              FStar_Compiler_Effect.op_Bar_Greater lbs
-                (FStar_Compiler_List.map
-                   (fun lb ->
-                      let uu___4 = lb in
-                      match uu___4 with
-                      | { FStar_Syntax_Syntax.lbname = lbname;
-                          FStar_Syntax_Syntax.lbunivs = uu___5;
-                          FStar_Syntax_Syntax.lbtyp = uu___6;
-                          FStar_Syntax_Syntax.lbeff = uu___7;
-                          FStar_Syntax_Syntax.lbdef = uu___8;
-                          FStar_Syntax_Syntax.lbattrs = uu___9;
-                          FStar_Syntax_Syntax.lbpos = uu___10;_} ->
-                          let x = FStar_Compiler_Util.left lbname in
-                          let uu___11 =
-                            FStar_Ident.string_of_id
-                              x.FStar_Syntax_Syntax.ppname in
-                          let uu___12 = FStar_Syntax_Syntax.range_of_bv x in
-                          (uu___11, uu___12))) in
-            FStar_Compiler_Effect.raise
-              (FStar_SMTEncoding_Env.Inner_let_rec names)
-        | FStar_Syntax_Syntax.Tm_match (e, uu___2, pats, uu___3) ->
-            encode_match e pats FStar_SMTEncoding_Term.mk_Term_unit env
-              encode_term))
-and (encode_let :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term ->
-          FStar_SMTEncoding_Env.env_t ->
-            (FStar_Syntax_Syntax.term ->
-               FStar_SMTEncoding_Env.env_t ->
-                 (FStar_SMTEncoding_Term.term *
-                   FStar_SMTEncoding_Term.decls_t))
-              ->
-              (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun x ->
-    fun t1 ->
-      fun e1 ->
-        fun e2 ->
-          fun env ->
-            fun encode_body ->
-              let uu___ =
-                let uu___1 =
-                  FStar_Syntax_Util.ascribe e1
-                    ((FStar_Pervasives.Inl t1), FStar_Pervasives_Native.None,
-                      false) in
-                encode_term uu___1 env in
-              match uu___ with
-              | (ee1, decls1) ->
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___3] in
-                    FStar_Syntax_Subst.open_term uu___2 e2 in
-                  (match uu___1 with
-                   | (xs, e21) ->
-                       let x1 =
-                         let uu___2 = FStar_Compiler_List.hd xs in
-                         uu___2.FStar_Syntax_Syntax.binder_bv in
-                       let env' =
-                         FStar_SMTEncoding_Env.push_term_var env x1 ee1 in
-                       let uu___2 = encode_body e21 env' in
-                       (match uu___2 with
-                        | (ee2, decls2) ->
-                            (ee2, (FStar_Compiler_List.op_At decls1 decls2))))
-and (encode_match :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.branch Prims.list ->
-      FStar_SMTEncoding_Term.term ->
-        FStar_SMTEncoding_Env.env_t ->
-          (FStar_Syntax_Syntax.term ->
-             FStar_SMTEncoding_Env.env_t ->
-               (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-            -> (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun e ->
-    fun pats ->
-      fun default_case ->
-        fun env ->
-          fun encode_br ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-                    FStar_Compiler_Range.dummyRange in
-                FStar_Syntax_Syntax.null_bv uu___2 in
-              FStar_SMTEncoding_Env.gen_term_var env uu___1 in
-            match uu___ with
-            | (scrsym, scr', env1) ->
-                let uu___1 = encode_term e env1 in
-                (match uu___1 with
-                 | (scr, decls) ->
-                     let uu___2 =
-                       let encode_branch b uu___3 =
-                         match uu___3 with
-                         | (else_case, decls1) ->
-                             let uu___4 = FStar_Syntax_Subst.open_branch b in
-                             (match uu___4 with
-                              | (p, w, br) ->
-                                  let uu___5 = encode_pat env1 p in
-                                  (match uu___5 with
-                                   | (env0, pattern1) ->
-                                       let guard = pattern1.guard scr' in
-                                       let projections =
-                                         pattern1.projections scr' in
-                                       let env2 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           projections
-                                           (FStar_Compiler_List.fold_left
-                                              (fun env3 ->
-                                                 fun uu___6 ->
-                                                   match uu___6 with
-                                                   | (x, t) ->
-                                                       FStar_SMTEncoding_Env.push_term_var
-                                                         env3 x t) env1) in
-                                       let uu___6 =
-                                         match w with
-                                         | FStar_Pervasives_Native.None ->
-                                             (guard, [])
-                                         | FStar_Pervasives_Native.Some w1 ->
-                                             let uu___7 = encode_term w1 env2 in
-                                             (match uu___7 with
-                                              | (w2, decls2) ->
-                                                  let uu___8 =
-                                                    let uu___9 =
-                                                      let uu___10 =
-                                                        let uu___11 =
-                                                          let uu___12 =
-                                                            FStar_SMTEncoding_Term.boxBool
-                                                              FStar_SMTEncoding_Util.mkTrue in
-                                                          (w2, uu___12) in
-                                                        FStar_SMTEncoding_Util.mkEq
-                                                          uu___11 in
-                                                      (guard, uu___10) in
-                                                    FStar_SMTEncoding_Util.mkAnd
-                                                      uu___9 in
-                                                  (uu___8, decls2)) in
-                                       (match uu___6 with
-                                        | (guard1, decls2) ->
-                                            let uu___7 = encode_br br env2 in
-                                            (match uu___7 with
-                                             | (br1, decls3) ->
-                                                 let uu___8 =
-                                                   FStar_SMTEncoding_Util.mkITE
-                                                     (guard1, br1, else_case) in
-                                                 (uu___8,
-                                                   (FStar_Compiler_List.op_At
-                                                      decls1
-                                                      (FStar_Compiler_List.op_At
-                                                         decls2 decls3))))))) in
-                       FStar_Compiler_List.fold_right encode_branch pats
-                         (default_case, decls) in
-                     (match uu___2 with
-                      | (match_tm, decls1) ->
-                          let uu___3 =
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  let uu___7 =
-                                    FStar_SMTEncoding_Term.mk_fv
-                                      (scrsym,
-                                        FStar_SMTEncoding_Term.Term_sort) in
-                                  (uu___7, scr) in
-                                [uu___6] in
-                              (uu___5, match_tm) in
-                            FStar_SMTEncoding_Term.mkLet' uu___4
-                              FStar_Compiler_Range.dummyRange in
-                          (uu___3, decls1)))
-and (encode_pat :
-  FStar_SMTEncoding_Env.env_t ->
-    FStar_Syntax_Syntax.pat -> (FStar_SMTEncoding_Env.env_t * pattern))
-  =
-  fun env ->
-    fun pat ->
-      (let uu___1 =
-         FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv
-           FStar_Options.Medium in
-       if uu___1
-       then
-         let uu___2 = FStar_Syntax_Print.pat_to_string pat in
-         FStar_Compiler_Util.print1 "Encoding pattern %s\n" uu___2
-       else ());
-      (let uu___1 = FStar_TypeChecker_Util.decorated_pattern_as_term pat in
-       match uu___1 with
-       | (vars, pat_term) ->
-           let uu___2 =
-             FStar_Compiler_Effect.op_Bar_Greater vars
-               (FStar_Compiler_List.fold_left
-                  (fun uu___3 ->
-                     fun v ->
-                       match uu___3 with
-                       | (env1, vars1) ->
-                           let uu___4 =
-                             FStar_SMTEncoding_Env.gen_term_var env1 v in
-                           (match uu___4 with
-                            | (xx, uu___5, env2) ->
-                                let uu___6 =
-                                  let uu___7 =
-                                    let uu___8 =
-                                      FStar_SMTEncoding_Term.mk_fv
-                                        (xx,
-                                          FStar_SMTEncoding_Term.Term_sort) in
-                                    (v, uu___8) in
-                                  uu___7 :: vars1 in
-                                (env2, uu___6))) (env, [])) in
-           (match uu___2 with
-            | (env1, vars1) ->
-                let rec mk_guard pat1 scrutinee =
-                  match pat1.FStar_Syntax_Syntax.v with
-                  | FStar_Syntax_Syntax.Pat_var uu___3 ->
-                      FStar_SMTEncoding_Util.mkTrue
-                  | FStar_Syntax_Syntax.Pat_wild uu___3 ->
-                      FStar_SMTEncoding_Util.mkTrue
-                  | FStar_Syntax_Syntax.Pat_dot_term uu___3 ->
-                      FStar_SMTEncoding_Util.mkTrue
-                  | FStar_Syntax_Syntax.Pat_constant c ->
-                      let uu___3 = encode_const c env1 in
-                      (match uu___3 with
-                       | (tm, decls) ->
-                           ((match decls with
-                             | uu___5::uu___6 ->
-                                 failwith
-                                   "Unexpected encoding of constant pattern"
-                             | uu___5 -> ());
-                            FStar_SMTEncoding_Util.mkEq (scrutinee, tm)))
-                  | FStar_Syntax_Syntax.Pat_cons (f, uu___3, args) ->
-                      let is_f =
-                        let tc_name =
-                          FStar_TypeChecker_Env.typ_of_datacon
-                            env1.FStar_SMTEncoding_Env.tcenv
-                            (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                        let uu___4 =
-                          FStar_TypeChecker_Env.datacons_of_typ
-                            env1.FStar_SMTEncoding_Env.tcenv tc_name in
-                        match uu___4 with
-                        | (uu___5, uu___6::[]) ->
-                            FStar_SMTEncoding_Util.mkTrue
-                        | uu___5 ->
-                            FStar_SMTEncoding_Env.mk_data_tester env1
-                              (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                              scrutinee in
-                      let sub_term_guards =
-                        FStar_Compiler_Effect.op_Bar_Greater args
-                          (FStar_Compiler_List.mapi
-                             (fun i ->
-                                fun uu___4 ->
-                                  match uu___4 with
-                                  | (arg, uu___5) ->
-                                      let proj =
-                                        FStar_SMTEncoding_Env.primitive_projector_by_pos
-                                          env1.FStar_SMTEncoding_Env.tcenv
-                                          (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                          i in
-                                      let uu___6 =
-                                        FStar_SMTEncoding_Util.mkApp
-                                          (proj, [scrutinee]) in
-                                      mk_guard arg uu___6)) in
-                      FStar_SMTEncoding_Util.mk_and_l (is_f ::
-                        sub_term_guards) in
-                let rec mk_projections pat1 scrutinee =
-                  match pat1.FStar_Syntax_Syntax.v with
-                  | FStar_Syntax_Syntax.Pat_dot_term uu___3 -> []
-                  | FStar_Syntax_Syntax.Pat_var x -> [(x, scrutinee)]
-                  | FStar_Syntax_Syntax.Pat_wild x -> [(x, scrutinee)]
-                  | FStar_Syntax_Syntax.Pat_constant uu___3 -> []
-                  | FStar_Syntax_Syntax.Pat_cons (f, uu___3, args) ->
-                      let uu___4 =
-                        FStar_Compiler_Effect.op_Bar_Greater args
-                          (FStar_Compiler_List.mapi
-                             (fun i ->
-                                fun uu___5 ->
-                                  match uu___5 with
-                                  | (arg, uu___6) ->
-                                      let proj =
-                                        FStar_SMTEncoding_Env.primitive_projector_by_pos
-                                          env1.FStar_SMTEncoding_Env.tcenv
-                                          (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                          i in
-                                      let uu___7 =
-                                        FStar_SMTEncoding_Util.mkApp
-                                          (proj, [scrutinee]) in
-                                      mk_projections arg uu___7)) in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___4
-                        FStar_Compiler_List.flatten in
-                let pat_term1 uu___3 = encode_term pat_term env1 in
-                let pattern1 =
-                  {
-                    pat_vars = vars1;
-                    pat_term = pat_term1;
-                    guard = (mk_guard pat);
-                    projections = (mk_projections pat)
-                  } in
-                (env1, pattern1)))
-and (encode_args :
-  FStar_Syntax_Syntax.args ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term Prims.list *
-        FStar_SMTEncoding_Term.decls_t))
-  =
-  fun l ->
-    fun env ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater l
-          (FStar_Compiler_List.fold_left
-             (fun uu___1 ->
-                fun uu___2 ->
-                  match (uu___1, uu___2) with
-                  | ((tms, decls), (t, uu___3)) ->
-                      let uu___4 = encode_term t env in
-                      (match uu___4 with
-                       | (t1, decls') ->
-                           ((t1 :: tms),
-                             (FStar_Compiler_List.op_At decls decls'))))
-             ([], [])) in
-      match uu___ with | (l1, decls) -> ((FStar_Compiler_List.rev l1), decls)
-and (encode_smt_patterns :
-  FStar_Syntax_Syntax.arg Prims.list Prims.list ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term Prims.list Prims.list *
-        FStar_SMTEncoding_Term.decls_t))
-  =
-  fun pats_l ->
-    fun env ->
-      let env1 =
-        {
-          FStar_SMTEncoding_Env.bvar_bindings =
-            (env.FStar_SMTEncoding_Env.bvar_bindings);
-          FStar_SMTEncoding_Env.fvar_bindings =
-            (env.FStar_SMTEncoding_Env.fvar_bindings);
-          FStar_SMTEncoding_Env.depth = (env.FStar_SMTEncoding_Env.depth);
-          FStar_SMTEncoding_Env.tcenv = (env.FStar_SMTEncoding_Env.tcenv);
-          FStar_SMTEncoding_Env.warn = (env.FStar_SMTEncoding_Env.warn);
-          FStar_SMTEncoding_Env.nolabels =
-            (env.FStar_SMTEncoding_Env.nolabels);
-          FStar_SMTEncoding_Env.use_zfuel_name = true;
-          FStar_SMTEncoding_Env.encode_non_total_function_typ =
-            (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-          FStar_SMTEncoding_Env.current_module_name =
-            (env.FStar_SMTEncoding_Env.current_module_name);
-          FStar_SMTEncoding_Env.encoding_quantifier =
-            (env.FStar_SMTEncoding_Env.encoding_quantifier);
-          FStar_SMTEncoding_Env.global_cache =
-            (env.FStar_SMTEncoding_Env.global_cache)
-        } in
-      let encode_smt_pattern t =
-        let uu___ = FStar_Syntax_Util.head_and_args t in
-        match uu___ with
-        | (head, args) ->
-            let head1 = FStar_Syntax_Util.un_uinst head in
-            (match ((head1.FStar_Syntax_Syntax.n), args) with
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                uu___1::(x, uu___2)::(t1, uu___3)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.has_type_lid
-                 ->
-                 let uu___4 = encode_term x env1 in
-                 (match uu___4 with
-                  | (x1, decls) ->
-                      let uu___5 = encode_term t1 env1 in
-                      (match uu___5 with
-                       | (t2, decls') ->
-                           let uu___6 =
-                             FStar_SMTEncoding_Term.mk_HasType x1 t2 in
-                           (uu___6, (FStar_Compiler_List.op_At decls decls'))))
-             | uu___1 -> encode_term t env1) in
-      FStar_Compiler_List.fold_right
-        (fun pats ->
-           fun uu___ ->
-             match uu___ with
-             | (pats_l1, decls) ->
-                 let uu___1 =
-                   FStar_Compiler_List.fold_right
-                     (fun uu___2 ->
-                        fun uu___3 ->
-                          match (uu___2, uu___3) with
-                          | ((p, uu___4), (pats1, decls1)) ->
-                              let uu___5 = encode_smt_pattern p in
-                              (match uu___5 with
-                               | (t, d) ->
-                                   let uu___6 =
-                                     FStar_SMTEncoding_Term.check_pattern_ok
-                                       t in
-                                   (match uu___6 with
-                                    | FStar_Pervasives_Native.None ->
-                                        ((t :: pats1),
-                                          (FStar_Compiler_List.op_At d decls1))
-                                    | FStar_Pervasives_Native.Some
-                                        illegal_subterm ->
-                                        ((let uu___8 =
-                                            let uu___9 =
-                                              let uu___10 =
-                                                FStar_Syntax_Print.term_to_string
-                                                  p in
-                                              let uu___11 =
-                                                FStar_SMTEncoding_Term.print_smt_term
-                                                  illegal_subterm in
-                                              FStar_Compiler_Util.format2
-                                                "Pattern %s contains illegal sub-term (%s); dropping it"
-                                                uu___10 uu___11 in
-                                            (FStar_Errors.Warning_SMTPatternIllFormed,
-                                              uu___9) in
-                                          FStar_Errors.log_issue
-                                            p.FStar_Syntax_Syntax.pos uu___8);
-                                         (pats1,
-                                           (FStar_Compiler_List.op_At d
-                                              decls1)))))) pats ([], decls) in
-                 (match uu___1 with
-                  | (pats1, decls1) -> ((pats1 :: pats_l1), decls1))) pats_l
-        ([], [])
-and (encode_formula :
-  FStar_Syntax_Syntax.typ ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun phi ->
-    fun env ->
-      let debug phi1 =
-        let uu___ =
-          FStar_Compiler_Effect.op_Less_Bar
-            (FStar_TypeChecker_Env.debug env.FStar_SMTEncoding_Env.tcenv)
-            (FStar_Options.Other "SMTEncoding") in
-        if uu___
-        then
-          let uu___1 = FStar_Syntax_Print.tag_of_term phi1 in
-          let uu___2 = FStar_Syntax_Print.term_to_string phi1 in
-          FStar_Compiler_Util.print2 "Formula (%s)  %s\n" uu___1 uu___2
-        else () in
-      let enc f r l =
-        let uu___ =
-          FStar_Compiler_Util.fold_map
-            (fun decls ->
-               fun x ->
-                 let uu___1 = encode_term (FStar_Pervasives_Native.fst x) env in
-                 match uu___1 with
-                 | (t, decls') ->
-                     ((FStar_Compiler_List.op_At decls decls'), t)) [] l in
-        match uu___ with
-        | (decls, args) ->
-            let uu___1 =
-              let uu___2 = f args in
-              {
-                FStar_SMTEncoding_Term.tm =
-                  (uu___2.FStar_SMTEncoding_Term.tm);
-                FStar_SMTEncoding_Term.freevars =
-                  (uu___2.FStar_SMTEncoding_Term.freevars);
-                FStar_SMTEncoding_Term.rng = r
-              } in
-            (uu___1, decls) in
-      let const_op f r uu___ = let uu___1 = f r in (uu___1, []) in
-      let un_op f l =
-        let uu___ = FStar_Compiler_List.hd l in
-        FStar_Compiler_Effect.op_Less_Bar f uu___ in
-      let bin_op f uu___ =
-        match uu___ with
-        | t1::t2::[] -> f (t1, t2)
-        | uu___1 -> failwith "Impossible" in
-      let enc_prop_c f r l =
-        let uu___ =
-          FStar_Compiler_Util.fold_map
-            (fun decls ->
-               fun uu___1 ->
-                 match uu___1 with
-                 | (t, uu___2) ->
-                     let uu___3 = encode_formula t env in
-                     (match uu___3 with
-                      | (phi1, decls') ->
-                          ((FStar_Compiler_List.op_At decls decls'), phi1)))
-            [] l in
-        match uu___ with
-        | (decls, phis) ->
-            let uu___1 =
-              let uu___2 = f phis in
-              {
-                FStar_SMTEncoding_Term.tm =
-                  (uu___2.FStar_SMTEncoding_Term.tm);
-                FStar_SMTEncoding_Term.freevars =
-                  (uu___2.FStar_SMTEncoding_Term.freevars);
-                FStar_SMTEncoding_Term.rng = r
-              } in
-            (uu___1, decls) in
-      let eq_op r args =
-        let rf =
-          FStar_Compiler_List.filter
-            (fun uu___ ->
-               match uu___ with
-               | (a, q) ->
-                   (match q with
-                    | FStar_Pervasives_Native.Some
-                        { FStar_Syntax_Syntax.aqual_implicit = true;
-                          FStar_Syntax_Syntax.aqual_attributes = uu___1;_}
-                        -> false
-                    | uu___1 -> true)) args in
-        if (FStar_Compiler_List.length rf) <> (Prims.of_int (2))
-        then
-          let uu___ =
-            FStar_Compiler_Util.format1
-              "eq_op: got %s non-implicit arguments instead of 2?"
-              (Prims.string_of_int (FStar_Compiler_List.length rf)) in
-          failwith uu___
-        else
-          (let uu___1 = enc (bin_op FStar_SMTEncoding_Util.mkEq) in
-           uu___1 r rf) in
-      let mk_imp r uu___ =
-        match uu___ with
-        | (lhs, uu___1)::(rhs, uu___2)::[] ->
-            let uu___3 = encode_formula rhs env in
-            (match uu___3 with
-             | (l1, decls1) ->
-                 (match l1.FStar_SMTEncoding_Term.tm with
-                  | FStar_SMTEncoding_Term.App
-                      (FStar_SMTEncoding_Term.TrueOp, uu___4) -> (l1, decls1)
-                  | uu___4 ->
-                      let uu___5 = encode_formula lhs env in
-                      (match uu___5 with
-                       | (l2, decls2) ->
-                           let uu___6 =
-                             FStar_SMTEncoding_Term.mkImp (l2, l1) r in
-                           (uu___6,
-                             (FStar_Compiler_List.op_At decls1 decls2)))))
-        | uu___1 -> failwith "impossible" in
-      let mk_ite r uu___ =
-        match uu___ with
-        | (guard, uu___1)::(_then, uu___2)::(_else, uu___3)::[] ->
-            let uu___4 = encode_formula guard env in
-            (match uu___4 with
-             | (g, decls1) ->
-                 let uu___5 = encode_formula _then env in
-                 (match uu___5 with
-                  | (t, decls2) ->
-                      let uu___6 = encode_formula _else env in
-                      (match uu___6 with
-                       | (e, decls3) ->
-                           let res = FStar_SMTEncoding_Term.mkITE (g, t, e) r in
-                           (res,
-                             (FStar_Compiler_List.op_At decls1
-                                (FStar_Compiler_List.op_At decls2 decls3))))))
-        | uu___1 -> failwith "impossible" in
-      let unboxInt_l f l =
-        let uu___ = FStar_Compiler_List.map FStar_SMTEncoding_Term.unboxInt l in
-        f uu___ in
-      let connectives =
-        let uu___ =
-          let uu___1 = enc_prop_c (bin_op FStar_SMTEncoding_Util.mkAnd) in
-          (FStar_Parser_Const.and_lid, uu___1) in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = enc_prop_c (bin_op FStar_SMTEncoding_Util.mkOr) in
-            (FStar_Parser_Const.or_lid, uu___3) in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = enc_prop_c (bin_op FStar_SMTEncoding_Util.mkIff) in
-                (FStar_Parser_Const.iff_lid, uu___6) in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    let uu___9 =
-                      enc_prop_c (un_op FStar_SMTEncoding_Util.mkNot) in
-                    (FStar_Parser_Const.not_lid, uu___9) in
-                  [uu___8;
-                  (FStar_Parser_Const.eq2_lid, eq_op);
-                  (FStar_Parser_Const.c_eq2_lid, eq_op);
-                  (FStar_Parser_Const.true_lid,
-                    (const_op FStar_SMTEncoding_Term.mkTrue));
-                  (FStar_Parser_Const.false_lid,
-                    (const_op FStar_SMTEncoding_Term.mkFalse))] in
-                (FStar_Parser_Const.ite_lid, mk_ite) :: uu___7 in
-              uu___5 :: uu___6 in
-            (FStar_Parser_Const.imp_lid, mk_imp) :: uu___4 in
-          uu___2 :: uu___3 in
-        uu___ :: uu___1 in
-      let rec fallback phi1 =
-        match phi1.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_meta
-            (phi', FStar_Syntax_Syntax.Meta_labeled (msg, r, b)) ->
-            let uu___ = encode_formula phi' env in
-            (match uu___ with
-             | (phi2, decls) ->
-                 let uu___1 =
-                   FStar_SMTEncoding_Term.mk
-                     (FStar_SMTEncoding_Term.Labeled (phi2, msg, r)) r in
-                 (uu___1, decls))
-        | FStar_Syntax_Syntax.Tm_meta uu___ ->
-            let uu___1 = FStar_Syntax_Util.unmeta phi1 in
-            encode_formula uu___1 env
-        | FStar_Syntax_Syntax.Tm_match (e, uu___, pats, uu___1) ->
-            let uu___2 =
-              encode_match e pats FStar_SMTEncoding_Term.mkUnreachable env
-                encode_formula in
-            (match uu___2 with | (t, decls) -> (t, decls))
-        | FStar_Syntax_Syntax.Tm_let
-            ((false,
-              { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inl x;
-                FStar_Syntax_Syntax.lbunivs = uu___;
-                FStar_Syntax_Syntax.lbtyp = t1;
-                FStar_Syntax_Syntax.lbeff = uu___1;
-                FStar_Syntax_Syntax.lbdef = e1;
-                FStar_Syntax_Syntax.lbattrs = uu___2;
-                FStar_Syntax_Syntax.lbpos = uu___3;_}::[]),
-             e2)
-            ->
-            let uu___4 = encode_let x t1 e1 e2 env encode_formula in
-            (match uu___4 with | (t, decls) -> (t, decls))
-        | FStar_Syntax_Syntax.Tm_app (head, args) ->
-            let head1 = FStar_Syntax_Util.un_uinst head in
-            (match ((head1.FStar_Syntax_Syntax.n), args) with
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                uu___::(x, uu___1)::(t, uu___2)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.has_type_lid
-                 ->
-                 let uu___3 = encode_term x env in
-                 (match uu___3 with
-                  | (x1, decls) ->
-                      let uu___4 = encode_term t env in
-                      (match uu___4 with
-                       | (t1, decls') ->
-                           let uu___5 =
-                             FStar_SMTEncoding_Term.mk_HasType x1 t1 in
-                           (uu___5, (FStar_Compiler_List.op_At decls decls'))))
-             | (FStar_Syntax_Syntax.Tm_fvar fv, uu___::(phi2, uu___1)::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.by_tactic_lid
-                 -> encode_formula phi2 env
-             | (FStar_Syntax_Syntax.Tm_uinst
-                ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                   FStar_Syntax_Syntax.pos = uu___;
-                   FStar_Syntax_Syntax.vars = uu___1;
-                   FStar_Syntax_Syntax.hash_code = uu___2;_},
-                 uu___3),
-                uu___4::(phi2, uu___5)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.by_tactic_lid
-                 -> encode_formula phi2 env
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                uu___::uu___1::(phi2, uu___2)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.rewrite_by_tactic_lid
-                 -> encode_formula phi2 env
-             | (FStar_Syntax_Syntax.Tm_uinst
-                ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                   FStar_Syntax_Syntax.pos = uu___;
-                   FStar_Syntax_Syntax.vars = uu___1;
-                   FStar_Syntax_Syntax.hash_code = uu___2;_},
-                 uu___3),
-                uu___4::uu___5::(phi2, uu___6)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.rewrite_by_tactic_lid
-                 -> encode_formula phi2 env
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (r, uu___)::(msg, uu___1)::(phi2, uu___2)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.labeled_lid
-                 ->
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Syntax_Embeddings.unembed
-                         FStar_Syntax_Embeddings.e_range r in
-                     uu___5 false FStar_Syntax_Embeddings.id_norm_cb in
-                   let uu___5 =
-                     let uu___6 =
-                       FStar_Syntax_Embeddings.unembed
-                         FStar_Syntax_Embeddings.e_string msg in
-                     uu___6 false FStar_Syntax_Embeddings.id_norm_cb in
-                   (uu___4, uu___5) in
-                 (match uu___3 with
-                  | (FStar_Pervasives_Native.Some r1,
-                     FStar_Pervasives_Native.Some s) ->
-                      let phi3 =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_meta
-                             (phi2,
-                               (FStar_Syntax_Syntax.Meta_labeled
-                                  (s, r1, false)))) r1 in
-                      fallback phi3
-                  | (FStar_Pervasives_Native.None,
-                     FStar_Pervasives_Native.Some s) ->
-                      let phi3 =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_meta
-                             (phi2,
-                               (FStar_Syntax_Syntax.Meta_labeled
-                                  (s, (phi2.FStar_Syntax_Syntax.pos), false))))
-                          phi2.FStar_Syntax_Syntax.pos in
-                      fallback phi3
-                  | uu___4 -> fallback phi2)
-             | (FStar_Syntax_Syntax.Tm_fvar fv, (t, uu___)::[]) when
-                 (FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.squash_lid)
-                   ||
-                   (FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.auto_squash_lid)
-                 -> encode_formula t env
-             | uu___ ->
-                 let encode_valid uu___1 =
-                   let uu___2 = encode_term phi1 env in
-                   match uu___2 with
-                   | (tt, decls) ->
-                       let tt1 =
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Compiler_Range.use_range
-                               tt.FStar_SMTEncoding_Term.rng in
-                           let uu___5 =
-                             FStar_Compiler_Range.use_range
-                               phi1.FStar_Syntax_Syntax.pos in
-                           FStar_Compiler_Range.rng_included uu___4 uu___5 in
-                         if uu___3
-                         then tt
-                         else
-                           {
-                             FStar_SMTEncoding_Term.tm =
-                               (tt.FStar_SMTEncoding_Term.tm);
-                             FStar_SMTEncoding_Term.freevars =
-                               (tt.FStar_SMTEncoding_Term.freevars);
-                             FStar_SMTEncoding_Term.rng =
-                               (phi1.FStar_Syntax_Syntax.pos)
-                           } in
-                       let uu___3 = FStar_SMTEncoding_Term.mk_Valid tt1 in
-                       (uu___3, decls) in
-                 let uu___1 = head_redex env head1 in
-                 if uu___1
-                 then
-                   let uu___2 = maybe_whnf env head1 in
-                   (match uu___2 with
-                    | FStar_Pervasives_Native.None -> encode_valid ()
-                    | FStar_Pervasives_Native.Some phi2 ->
-                        encode_formula phi2 env)
-                 else encode_valid ())
-        | uu___ ->
-            let uu___1 = encode_term phi1 env in
-            (match uu___1 with
-             | (tt, decls) ->
-                 let tt1 =
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Compiler_Range.use_range
-                         tt.FStar_SMTEncoding_Term.rng in
-                     let uu___4 =
-                       FStar_Compiler_Range.use_range
-                         phi1.FStar_Syntax_Syntax.pos in
-                     FStar_Compiler_Range.rng_included uu___3 uu___4 in
-                   if uu___2
-                   then tt
-                   else
-                     {
-                       FStar_SMTEncoding_Term.tm =
-                         (tt.FStar_SMTEncoding_Term.tm);
-                       FStar_SMTEncoding_Term.freevars =
-                         (tt.FStar_SMTEncoding_Term.freevars);
-                       FStar_SMTEncoding_Term.rng =
-                         (phi1.FStar_Syntax_Syntax.pos)
-                     } in
-                 let uu___2 = FStar_SMTEncoding_Term.mk_Valid tt1 in
-                 (uu___2, decls)) in
-      let encode_q_body env1 bs ps body =
-        let uu___ = encode_binders FStar_Pervasives_Native.None bs env1 in
-        match uu___ with
-        | (vars, guards, env2, decls, uu___1) ->
-            let uu___2 = encode_smt_patterns ps env2 in
-            (match uu___2 with
-             | (pats, decls') ->
-                 let uu___3 = encode_formula body env2 in
-                 (match uu___3 with
-                  | (body1, decls'') ->
-                      let guards1 =
-                        match pats with
-                        | ({
-                             FStar_SMTEncoding_Term.tm =
-                               FStar_SMTEncoding_Term.App
-                               (FStar_SMTEncoding_Term.Var gf, p::[]);
-                             FStar_SMTEncoding_Term.freevars = uu___4;
-                             FStar_SMTEncoding_Term.rng = uu___5;_}::[])::[]
-                            when
-                            let uu___6 =
-                              FStar_Ident.string_of_lid
-                                FStar_Parser_Const.guard_free in
-                            uu___6 = gf -> []
-                        | uu___4 -> guards in
-                      let uu___4 = FStar_SMTEncoding_Util.mk_and_l guards1 in
-                      (vars, pats, uu___4, body1,
-                        (FStar_Compiler_List.op_At decls
-                           (FStar_Compiler_List.op_At decls' decls''))))) in
-      debug phi;
-      (let phi1 = FStar_Syntax_Util.unascribe phi in
-       let uu___1 = FStar_Syntax_Util.destruct_typ_as_formula phi1 in
-       match uu___1 with
-       | FStar_Pervasives_Native.None -> fallback phi1
-       | FStar_Pervasives_Native.Some (FStar_Syntax_Util.BaseConn (op, arms))
-           ->
-           let uu___2 =
-             FStar_Compiler_Effect.op_Bar_Greater connectives
-               (FStar_Compiler_List.tryFind
-                  (fun uu___3 ->
-                     match uu___3 with
-                     | (l, uu___4) -> FStar_Ident.lid_equals op l)) in
-           (match uu___2 with
-            | FStar_Pervasives_Native.None -> fallback phi1
-            | FStar_Pervasives_Native.Some (uu___3, f) ->
-                f phi1.FStar_Syntax_Syntax.pos arms)
-       | FStar_Pervasives_Native.Some (FStar_Syntax_Util.QAll
-           (vars, pats, body)) ->
-           (FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.iter (check_pattern_vars env vars));
-            (let uu___3 = encode_q_body env vars pats body in
-             match uu___3 with
-             | (vars1, pats1, guard, body1, decls) ->
-                 let tm =
-                   let uu___4 =
-                     let uu___5 = FStar_SMTEncoding_Util.mkImp (guard, body1) in
-                     (pats1, vars1, uu___5) in
-                   FStar_SMTEncoding_Term.mkForall
-                     phi1.FStar_Syntax_Syntax.pos uu___4 in
-                 (tm, decls)))
-       | FStar_Pervasives_Native.Some (FStar_Syntax_Util.QEx
-           (vars, pats, body)) ->
-           (FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.iter (check_pattern_vars env vars));
-            (let uu___3 = encode_q_body env vars pats body in
-             match uu___3 with
-             | (vars1, pats1, guard, body1, decls) ->
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_SMTEncoding_Util.mkAnd (guard, body1) in
-                     (pats1, vars1, uu___6) in
-                   FStar_SMTEncoding_Term.mkExists
-                     phi1.FStar_Syntax_Syntax.pos uu___5 in
-                 (uu___4, decls))))
-let (encode_function_type_as_formula :
-  FStar_Syntax_Syntax.typ ->
-    FStar_SMTEncoding_Env.env_t ->
-      (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.decls_t))
-  =
-  fun t ->
-    fun env ->
-      let universe_of_binders binders =
-        FStar_Compiler_List.map (fun uu___ -> FStar_Syntax_Syntax.U_zero)
-          binders in
-      let quant = FStar_Syntax_Util.smt_lemma_as_forall t universe_of_binders in
-      let env1 =
-        {
-          FStar_SMTEncoding_Env.bvar_bindings =
-            (env.FStar_SMTEncoding_Env.bvar_bindings);
-          FStar_SMTEncoding_Env.fvar_bindings =
-            (env.FStar_SMTEncoding_Env.fvar_bindings);
-          FStar_SMTEncoding_Env.depth = (env.FStar_SMTEncoding_Env.depth);
-          FStar_SMTEncoding_Env.tcenv = (env.FStar_SMTEncoding_Env.tcenv);
-          FStar_SMTEncoding_Env.warn = (env.FStar_SMTEncoding_Env.warn);
-          FStar_SMTEncoding_Env.nolabels =
-            (env.FStar_SMTEncoding_Env.nolabels);
-          FStar_SMTEncoding_Env.use_zfuel_name = true;
-          FStar_SMTEncoding_Env.encode_non_total_function_typ =
-            (env.FStar_SMTEncoding_Env.encode_non_total_function_typ);
-          FStar_SMTEncoding_Env.current_module_name =
-            (env.FStar_SMTEncoding_Env.current_module_name);
-          FStar_SMTEncoding_Env.encoding_quantifier =
-            (env.FStar_SMTEncoding_Env.encoding_quantifier);
-          FStar_SMTEncoding_Env.global_cache =
-            (env.FStar_SMTEncoding_Env.global_cache)
-        } in
-      encode_formula quant env1
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_Env.ml b/src/ocaml-output/FStar_SMTEncoding_Env.ml
deleted file mode 100644
index 3f81711bc1d..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_Env.ml
+++ /dev/null
@@ -1,1118 +0,0 @@
-open Prims
-exception Inner_let_rec of (Prims.string * FStar_Compiler_Range.range)
-  Prims.list 
-let (uu___is_Inner_let_rec : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Inner_let_rec uu___ -> true | uu___ -> false
-let (__proj__Inner_let_rec__item__uu___ :
-  Prims.exn -> (Prims.string * FStar_Compiler_Range.range) Prims.list) =
-  fun projectee -> match projectee with | Inner_let_rec uu___ -> uu___
-let add_fuel : 'uuuuu . 'uuuuu -> 'uuuuu Prims.list -> 'uuuuu Prims.list =
-  fun x ->
-    fun tl ->
-      let uu___ = FStar_Options.unthrottle_inductives () in
-      if uu___ then tl else x :: tl
-let withenv :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    'uuuuu -> ('uuuuu1 * 'uuuuu2) -> ('uuuuu1 * 'uuuuu2 * 'uuuuu)
-  = fun c -> fun uu___ -> match uu___ with | (a, b) -> (a, b, c)
-let vargs :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    (('uuuuu, 'uuuuu1) FStar_Pervasives.either * 'uuuuu2) Prims.list ->
-      (('uuuuu, 'uuuuu1) FStar_Pervasives.either * 'uuuuu2) Prims.list
-  =
-  fun args ->
-    FStar_Compiler_List.filter
-      (fun uu___ ->
-         match uu___ with
-         | (FStar_Pervasives.Inl uu___1, uu___2) -> false
-         | uu___1 -> true) args
-let (escape : Prims.string -> Prims.string) =
-  fun s -> FStar_Compiler_Util.replace_char s 39 95
-let (mk_term_projector_name :
-  FStar_Ident.lident -> FStar_Syntax_Syntax.bv -> Prims.string) =
-  fun lid ->
-    fun a ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid lid in
-        let uu___2 = FStar_Ident.string_of_id a.FStar_Syntax_Syntax.ppname in
-        FStar_Compiler_Util.format2 "%s_%s" uu___1 uu___2 in
-      FStar_Compiler_Effect.op_Less_Bar escape uu___
-let (primitive_projector_by_pos :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident -> Prims.int -> Prims.string)
-  =
-  fun env ->
-    fun lid ->
-      fun i ->
-        let fail uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_lid lid in
-            FStar_Compiler_Util.format2
-              "Projector %s on data constructor %s not found"
-              (Prims.string_of_int i) uu___2 in
-          failwith uu___1 in
-        let uu___ = FStar_TypeChecker_Env.lookup_datacon env lid in
-        match uu___ with
-        | (uu___1, t) ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Subst.compress t in
-              uu___3.FStar_Syntax_Syntax.n in
-            (match uu___2 with
-             | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                 let uu___3 = FStar_Syntax_Subst.open_comp bs c in
-                 (match uu___3 with
-                  | (binders, uu___4) ->
-                      if
-                        (i < Prims.int_zero) ||
-                          (i >= (FStar_Compiler_List.length binders))
-                      then fail ()
-                      else
-                        (let b = FStar_Compiler_List.nth binders i in
-                         mk_term_projector_name lid
-                           b.FStar_Syntax_Syntax.binder_bv))
-             | uu___3 -> fail ())
-let (mk_term_projector_name_by_pos :
-  FStar_Ident.lident -> Prims.int -> Prims.string) =
-  fun lid ->
-    fun i ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid lid in
-        FStar_Compiler_Util.format2 "%s_%s" uu___1 (Prims.string_of_int i) in
-      FStar_Compiler_Effect.op_Less_Bar escape uu___
-let (mk_term_projector :
-  FStar_Ident.lident -> FStar_Syntax_Syntax.bv -> FStar_SMTEncoding_Term.term)
-  =
-  fun lid ->
-    fun a ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = mk_term_projector_name lid a in
-          (uu___2,
-            (FStar_SMTEncoding_Term.Arrow
-               (FStar_SMTEncoding_Term.Term_sort,
-                 FStar_SMTEncoding_Term.Term_sort))) in
-        FStar_SMTEncoding_Term.mk_fv uu___1 in
-      FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkFreeV uu___
-let (mk_term_projector_by_pos :
-  FStar_Ident.lident -> Prims.int -> FStar_SMTEncoding_Term.term) =
-  fun lid ->
-    fun i ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = mk_term_projector_name_by_pos lid i in
-          (uu___2,
-            (FStar_SMTEncoding_Term.Arrow
-               (FStar_SMTEncoding_Term.Term_sort,
-                 FStar_SMTEncoding_Term.Term_sort))) in
-        FStar_SMTEncoding_Term.mk_fv uu___1 in
-      FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkFreeV uu___
-let mk_data_tester :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Ident.lident ->
-        FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term
-  =
-  fun env ->
-    fun l ->
-      fun x ->
-        let uu___ = let uu___1 = FStar_Ident.string_of_lid l in escape uu___1 in
-        FStar_SMTEncoding_Term.mk_tester uu___ x
-type varops_t =
-  {
-  push: unit -> unit ;
-  pop: unit -> unit ;
-  snapshot: unit -> (Prims.int * unit) ;
-  rollback: Prims.int FStar_Pervasives_Native.option -> unit ;
-  new_var: FStar_Ident.ident -> Prims.int -> Prims.string ;
-  new_fvar: FStar_Ident.lident -> Prims.string ;
-  fresh: Prims.string -> Prims.string -> Prims.string ;
-  reset_fresh: unit -> unit ;
-  next_id: unit -> Prims.int ;
-  mk_unique: Prims.string -> Prims.string }
-let (__proj__Mkvarops_t__item__push : varops_t -> unit -> unit) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> push
-let (__proj__Mkvarops_t__item__pop : varops_t -> unit -> unit) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> pop
-let (__proj__Mkvarops_t__item__snapshot :
-  varops_t -> unit -> (Prims.int * unit)) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> snapshot
-let (__proj__Mkvarops_t__item__rollback :
-  varops_t -> Prims.int FStar_Pervasives_Native.option -> unit) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> rollback
-let (__proj__Mkvarops_t__item__new_var :
-  varops_t -> FStar_Ident.ident -> Prims.int -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> new_var
-let (__proj__Mkvarops_t__item__new_fvar :
-  varops_t -> FStar_Ident.lident -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> new_fvar
-let (__proj__Mkvarops_t__item__fresh :
-  varops_t -> Prims.string -> Prims.string -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> fresh
-let (__proj__Mkvarops_t__item__reset_fresh : varops_t -> unit -> unit) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> reset_fresh
-let (__proj__Mkvarops_t__item__next_id : varops_t -> unit -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> next_id
-let (__proj__Mkvarops_t__item__mk_unique :
-  varops_t -> Prims.string -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { push; pop; snapshot; rollback; new_var; new_fvar; fresh; reset_fresh;
-        next_id; mk_unique;_} -> mk_unique
-let (varops : varops_t) =
-  let initial_ctr = (Prims.of_int (100)) in
-  let ctr = FStar_Compiler_Util.mk_ref initial_ctr in
-  let new_scope uu___ = FStar_Compiler_Util.smap_create (Prims.of_int (100)) in
-  let scopes =
-    let uu___ = let uu___1 = new_scope () in [uu___1] in
-    FStar_Compiler_Util.mk_ref uu___ in
-  let mk_unique y =
-    let y1 = escape y in
-    let y2 =
-      let uu___ =
-        let uu___1 = FStar_Compiler_Effect.op_Bang scopes in
-        FStar_Compiler_Util.find_map uu___1
-          (fun names -> FStar_Compiler_Util.smap_try_find names y1) in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> y1
-      | FStar_Pervasives_Native.Some uu___1 ->
-          (FStar_Compiler_Util.incr ctr;
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Compiler_Effect.op_Bang ctr in
-                Prims.string_of_int uu___5 in
-              Prims.op_Hat "__" uu___4 in
-            Prims.op_Hat y1 uu___3)) in
-    let top_scope =
-      let uu___ = FStar_Compiler_Effect.op_Bang scopes in
-      FStar_Compiler_List.hd uu___ in
-    FStar_Compiler_Util.smap_add top_scope y2 true; y2 in
-  let new_var pp rn =
-    let uu___ =
-      let uu___1 = FStar_Ident.string_of_id pp in
-      Prims.op_Hat uu___1 (Prims.op_Hat "__" (Prims.string_of_int rn)) in
-    FStar_Compiler_Effect.op_Less_Bar mk_unique uu___ in
-  let new_fvar lid =
-    let uu___ = FStar_Ident.string_of_lid lid in mk_unique uu___ in
-  let next_id uu___ =
-    FStar_Compiler_Util.incr ctr; FStar_Compiler_Effect.op_Bang ctr in
-  let fresh mname pfx =
-    let uu___ =
-      let uu___1 = next_id () in
-      FStar_Compiler_Effect.op_Less_Bar Prims.string_of_int uu___1 in
-    FStar_Compiler_Util.format3 "%s_%s_%s" pfx mname uu___ in
-  let reset_fresh uu___ =
-    FStar_Compiler_Effect.op_Colon_Equals ctr initial_ctr in
-  let push uu___ =
-    let uu___1 =
-      let uu___2 = new_scope () in
-      let uu___3 = FStar_Compiler_Effect.op_Bang scopes in uu___2 :: uu___3 in
-    FStar_Compiler_Effect.op_Colon_Equals scopes uu___1 in
-  let pop uu___ =
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang scopes in
-      FStar_Compiler_List.tl uu___2 in
-    FStar_Compiler_Effect.op_Colon_Equals scopes uu___1 in
-  let snapshot uu___ = FStar_Common.snapshot push scopes () in
-  let rollback depth = FStar_Common.rollback pop scopes depth in
-  {
-    push;
-    pop;
-    snapshot;
-    rollback;
-    new_var;
-    new_fvar;
-    fresh;
-    reset_fresh;
-    next_id;
-    mk_unique
-  }
-type fvar_binding =
-  {
-  fvar_lid: FStar_Ident.lident ;
-  smt_arity: Prims.int ;
-  smt_id: Prims.string ;
-  smt_token: FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option ;
-  smt_fuel_partial_app:
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term)
-      FStar_Pervasives_Native.option
-    ;
-  fvb_thunked: Prims.bool }
-let (__proj__Mkfvar_binding__item__fvar_lid :
-  fvar_binding -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { fvar_lid; smt_arity; smt_id; smt_token; smt_fuel_partial_app;
-        fvb_thunked;_} -> fvar_lid
-let (__proj__Mkfvar_binding__item__smt_arity : fvar_binding -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { fvar_lid; smt_arity; smt_id; smt_token; smt_fuel_partial_app;
-        fvb_thunked;_} -> smt_arity
-let (__proj__Mkfvar_binding__item__smt_id : fvar_binding -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { fvar_lid; smt_arity; smt_id; smt_token; smt_fuel_partial_app;
-        fvb_thunked;_} -> smt_id
-let (__proj__Mkfvar_binding__item__smt_token :
-  fvar_binding -> FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { fvar_lid; smt_arity; smt_id; smt_token; smt_fuel_partial_app;
-        fvb_thunked;_} -> smt_token
-let (__proj__Mkfvar_binding__item__smt_fuel_partial_app :
-  fvar_binding ->
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term)
-      FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { fvar_lid; smt_arity; smt_id; smt_token; smt_fuel_partial_app;
-        fvb_thunked;_} -> smt_fuel_partial_app
-let (__proj__Mkfvar_binding__item__fvb_thunked : fvar_binding -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { fvar_lid; smt_arity; smt_id; smt_token; smt_fuel_partial_app;
-        fvb_thunked;_} -> fvb_thunked
-let (fvb_to_string : fvar_binding -> Prims.string) =
-  fun fvb ->
-    let term_opt_to_string uu___ =
-      match uu___ with
-      | FStar_Pervasives_Native.None -> "None"
-      | FStar_Pervasives_Native.Some s ->
-          FStar_SMTEncoding_Term.print_smt_term s in
-    let term_pair_opt_to_string uu___ =
-      match uu___ with
-      | FStar_Pervasives_Native.None -> "None"
-      | FStar_Pervasives_Native.Some (s0, s1) ->
-          let uu___1 = FStar_SMTEncoding_Term.print_smt_term s0 in
-          let uu___2 = FStar_SMTEncoding_Term.print_smt_term s1 in
-          FStar_Compiler_Util.format2 "(%s, %s)" uu___1 uu___2 in
-    let uu___ = FStar_Ident.string_of_lid fvb.fvar_lid in
-    let uu___1 = term_opt_to_string fvb.smt_token in
-    let uu___2 = term_pair_opt_to_string fvb.smt_fuel_partial_app in
-    let uu___3 = FStar_Compiler_Util.string_of_bool fvb.fvb_thunked in
-    FStar_Compiler_Util.format5
-      "{ lid = %s;\n  smt_id = %s;\n  smt_token = %s;\n smt_fuel_partial_app = %s;\n fvb_thunked = %s }"
-      uu___ fvb.smt_id uu___1 uu___2 uu___3
-let (check_valid_fvb : fvar_binding -> unit) =
-  fun fvb ->
-    if
-      ((FStar_Compiler_Option.isSome fvb.smt_token) ||
-         (FStar_Compiler_Option.isSome fvb.smt_fuel_partial_app))
-        && fvb.fvb_thunked
-    then
-      (let uu___1 =
-         let uu___2 = FStar_Ident.string_of_lid fvb.fvar_lid in
-         FStar_Compiler_Util.format1 "Unexpected thunked SMT symbol: %s"
-           uu___2 in
-       failwith uu___1)
-    else
-      if fvb.fvb_thunked && (fvb.smt_arity <> Prims.int_zero)
-      then
-        (let uu___2 =
-           let uu___3 = FStar_Ident.string_of_lid fvb.fvar_lid in
-           FStar_Compiler_Util.format1
-             "Unexpected arity of thunked SMT symbol: %s" uu___3 in
-         failwith uu___2)
-      else ();
-    (match fvb.smt_token with
-     | FStar_Pervasives_Native.Some
-         { FStar_SMTEncoding_Term.tm = FStar_SMTEncoding_Term.FreeV uu___1;
-           FStar_SMTEncoding_Term.freevars = uu___2;
-           FStar_SMTEncoding_Term.rng = uu___3;_}
-         ->
-         let uu___4 =
-           let uu___5 = fvb_to_string fvb in
-           FStar_Compiler_Util.format1 "bad fvb\n%s" uu___5 in
-         failwith uu___4
-     | uu___1 -> ())
-let binder_of_eithervar :
-  'uuuuu 'uuuuu1 .
-    'uuuuu -> ('uuuuu * 'uuuuu1 FStar_Pervasives_Native.option)
-  = fun v -> (v, FStar_Pervasives_Native.None)
-type env_t =
-  {
-  bvar_bindings:
-    (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.term)
-      FStar_Compiler_Util.pimap FStar_Compiler_Util.psmap
-    ;
-  fvar_bindings:
-    (fvar_binding FStar_Compiler_Util.psmap * fvar_binding Prims.list) ;
-  depth: Prims.int ;
-  tcenv: FStar_TypeChecker_Env.env ;
-  warn: Prims.bool ;
-  nolabels: Prims.bool ;
-  use_zfuel_name: Prims.bool ;
-  encode_non_total_function_typ: Prims.bool ;
-  current_module_name: Prims.string ;
-  encoding_quantifier: Prims.bool ;
-  global_cache: FStar_SMTEncoding_Term.decls_elt FStar_Compiler_Util.smap }
-let (__proj__Mkenv_t__item__bvar_bindings :
-  env_t ->
-    (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.term)
-      FStar_Compiler_Util.pimap FStar_Compiler_Util.psmap)
-  =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> bvar_bindings
-let (__proj__Mkenv_t__item__fvar_bindings :
-  env_t -> (fvar_binding FStar_Compiler_Util.psmap * fvar_binding Prims.list))
-  =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> fvar_bindings
-let (__proj__Mkenv_t__item__depth : env_t -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> depth
-let (__proj__Mkenv_t__item__tcenv : env_t -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> tcenv
-let (__proj__Mkenv_t__item__warn : env_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> warn
-let (__proj__Mkenv_t__item__nolabels : env_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> nolabels
-let (__proj__Mkenv_t__item__use_zfuel_name : env_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> use_zfuel_name
-let (__proj__Mkenv_t__item__encode_non_total_function_typ :
-  env_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> encode_non_total_function_typ
-let (__proj__Mkenv_t__item__current_module_name : env_t -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> current_module_name
-let (__proj__Mkenv_t__item__encoding_quantifier : env_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> encoding_quantifier
-let (__proj__Mkenv_t__item__global_cache :
-  env_t -> FStar_SMTEncoding_Term.decls_elt FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { bvar_bindings; fvar_bindings; depth; tcenv; warn; nolabels;
-        use_zfuel_name; encode_non_total_function_typ; current_module_name;
-        encoding_quantifier; global_cache;_} -> global_cache
-let (print_env : env_t -> Prims.string) =
-  fun e ->
-    let bvars =
-      FStar_Compiler_Util.psmap_fold e.bvar_bindings
-        (fun _k ->
-           fun pi ->
-             fun acc ->
-               FStar_Compiler_Util.pimap_fold pi
-                 (fun _i ->
-                    fun uu___ ->
-                      fun acc1 ->
-                        match uu___ with
-                        | (x, _term) ->
-                            let uu___1 = FStar_Syntax_Print.bv_to_string x in
-                            uu___1 :: acc1) acc) [] in
-    let allvars =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater e.fvar_bindings
-          FStar_Pervasives_Native.fst in
-      FStar_Compiler_Util.psmap_fold uu___
-        (fun _k -> fun fvb -> fun acc -> (fvb.fvar_lid) :: acc) [] in
-    let last_fvar =
-      match FStar_Compiler_List.rev allvars with
-      | [] -> ""
-      | l::uu___ ->
-          let uu___1 = FStar_Syntax_Print.lid_to_string l in
-          Prims.op_Hat "...," uu___1 in
-    FStar_String.concat ", " (last_fvar :: bvars)
-let (lookup_bvar_binding :
-  env_t ->
-    FStar_Syntax_Syntax.bv ->
-      (FStar_Syntax_Syntax.bv * FStar_SMTEncoding_Term.term)
-        FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun bv ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_id bv.FStar_Syntax_Syntax.ppname in
-        FStar_Compiler_Util.psmap_try_find env.bvar_bindings uu___1 in
-      match uu___ with
-      | FStar_Pervasives_Native.Some bvs ->
-          FStar_Compiler_Util.pimap_try_find bvs bv.FStar_Syntax_Syntax.index
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (lookup_fvar_binding :
-  env_t -> FStar_Ident.lident -> fvar_binding FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun lid ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater env.fvar_bindings
-          FStar_Pervasives_Native.fst in
-      let uu___1 = FStar_Ident.string_of_lid lid in
-      FStar_Compiler_Util.psmap_try_find uu___ uu___1
-let add_bvar_binding :
-  'uuuuu .
-    (FStar_Syntax_Syntax.bv * 'uuuuu) ->
-      (FStar_Syntax_Syntax.bv * 'uuuuu) FStar_Compiler_Util.pimap
-        FStar_Compiler_Util.psmap ->
-        (FStar_Syntax_Syntax.bv * 'uuuuu) FStar_Compiler_Util.pimap
-          FStar_Compiler_Util.psmap
-  =
-  fun bvb ->
-    fun bvbs ->
-      let uu___ =
-        FStar_Ident.string_of_id
-          (FStar_Pervasives_Native.fst bvb).FStar_Syntax_Syntax.ppname in
-      FStar_Compiler_Util.psmap_modify bvbs uu___
-        (fun pimap_opt ->
-           let uu___1 =
-             let uu___2 = FStar_Compiler_Util.pimap_empty () in
-             FStar_Compiler_Util.dflt uu___2 pimap_opt in
-           FStar_Compiler_Util.pimap_add uu___1
-             (FStar_Pervasives_Native.fst bvb).FStar_Syntax_Syntax.index bvb)
-let (add_fvar_binding :
-  fvar_binding ->
-    (fvar_binding FStar_Compiler_Util.psmap * fvar_binding Prims.list) ->
-      (fvar_binding FStar_Compiler_Util.psmap * fvar_binding Prims.list))
-  =
-  fun fvb ->
-    fun uu___ ->
-      match uu___ with
-      | (fvb_map, fvb_list) ->
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_lid fvb.fvar_lid in
-            FStar_Compiler_Util.psmap_add fvb_map uu___2 fvb in
-          (uu___1, (fvb :: fvb_list))
-let (fresh_fvar :
-  Prims.string ->
-    Prims.string ->
-      FStar_SMTEncoding_Term.sort ->
-        (Prims.string * FStar_SMTEncoding_Term.term))
-  =
-  fun mname ->
-    fun x ->
-      fun s ->
-        let xsym = varops.fresh mname x in
-        let uu___ =
-          let uu___1 = FStar_SMTEncoding_Term.mk_fv (xsym, s) in
-          FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkFreeV
-            uu___1 in
-        (xsym, uu___)
-let (gen_term_var :
-  env_t ->
-    FStar_Syntax_Syntax.bv ->
-      (Prims.string * FStar_SMTEncoding_Term.term * env_t))
-  =
-  fun env ->
-    fun x ->
-      let ysym = Prims.op_Hat "@x" (Prims.string_of_int env.depth) in
-      let y =
-        let uu___ =
-          FStar_SMTEncoding_Term.mk_fv
-            (ysym, FStar_SMTEncoding_Term.Term_sort) in
-        FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkFreeV
-          uu___ in
-      let uu___ =
-        let uu___1 = add_bvar_binding (x, y) env.bvar_bindings in
-        let uu___2 = FStar_TypeChecker_Env.push_bv env.tcenv x in
-        {
-          bvar_bindings = uu___1;
-          fvar_bindings = (env.fvar_bindings);
-          depth = (env.depth + Prims.int_one);
-          tcenv = uu___2;
-          warn = (env.warn);
-          nolabels = (env.nolabels);
-          use_zfuel_name = (env.use_zfuel_name);
-          encode_non_total_function_typ = (env.encode_non_total_function_typ);
-          current_module_name = (env.current_module_name);
-          encoding_quantifier = (env.encoding_quantifier);
-          global_cache = (env.global_cache)
-        } in
-      (ysym, y, uu___)
-let (new_term_constant :
-  env_t ->
-    FStar_Syntax_Syntax.bv ->
-      (Prims.string * FStar_SMTEncoding_Term.term * env_t))
-  =
-  fun env ->
-    fun x ->
-      let ysym =
-        varops.new_var x.FStar_Syntax_Syntax.ppname
-          x.FStar_Syntax_Syntax.index in
-      let y = FStar_SMTEncoding_Util.mkApp (ysym, []) in
-      let uu___ =
-        let uu___1 = add_bvar_binding (x, y) env.bvar_bindings in
-        let uu___2 = FStar_TypeChecker_Env.push_bv env.tcenv x in
-        {
-          bvar_bindings = uu___1;
-          fvar_bindings = (env.fvar_bindings);
-          depth = (env.depth);
-          tcenv = uu___2;
-          warn = (env.warn);
-          nolabels = (env.nolabels);
-          use_zfuel_name = (env.use_zfuel_name);
-          encode_non_total_function_typ = (env.encode_non_total_function_typ);
-          current_module_name = (env.current_module_name);
-          encoding_quantifier = (env.encoding_quantifier);
-          global_cache = (env.global_cache)
-        } in
-      (ysym, y, uu___)
-let (new_term_constant_from_string :
-  env_t ->
-    FStar_Syntax_Syntax.bv ->
-      Prims.string -> (Prims.string * FStar_SMTEncoding_Term.term * env_t))
-  =
-  fun env ->
-    fun x ->
-      fun str ->
-        let ysym = varops.mk_unique str in
-        let y = FStar_SMTEncoding_Util.mkApp (ysym, []) in
-        let uu___ =
-          let uu___1 = add_bvar_binding (x, y) env.bvar_bindings in
-          let uu___2 = FStar_TypeChecker_Env.push_bv env.tcenv x in
-          {
-            bvar_bindings = uu___1;
-            fvar_bindings = (env.fvar_bindings);
-            depth = (env.depth);
-            tcenv = uu___2;
-            warn = (env.warn);
-            nolabels = (env.nolabels);
-            use_zfuel_name = (env.use_zfuel_name);
-            encode_non_total_function_typ =
-              (env.encode_non_total_function_typ);
-            current_module_name = (env.current_module_name);
-            encoding_quantifier = (env.encoding_quantifier);
-            global_cache = (env.global_cache)
-          } in
-        (ysym, y, uu___)
-let (push_term_var :
-  env_t -> FStar_Syntax_Syntax.bv -> FStar_SMTEncoding_Term.term -> env_t) =
-  fun env ->
-    fun x ->
-      fun t ->
-        let uu___ = add_bvar_binding (x, t) env.bvar_bindings in
-        let uu___1 = FStar_TypeChecker_Env.push_bv env.tcenv x in
-        {
-          bvar_bindings = uu___;
-          fvar_bindings = (env.fvar_bindings);
-          depth = (env.depth);
-          tcenv = uu___1;
-          warn = (env.warn);
-          nolabels = (env.nolabels);
-          use_zfuel_name = (env.use_zfuel_name);
-          encode_non_total_function_typ = (env.encode_non_total_function_typ);
-          current_module_name = (env.current_module_name);
-          encoding_quantifier = (env.encoding_quantifier);
-          global_cache = (env.global_cache)
-        }
-let (lookup_term_var :
-  env_t -> FStar_Syntax_Syntax.bv -> FStar_SMTEncoding_Term.term) =
-  fun env ->
-    fun a ->
-      let uu___ = lookup_bvar_binding env a in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = lookup_bvar_binding env a in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Print.bv_to_string a in
-                 let uu___4 = print_env env in
-                 FStar_Compiler_Util.format2
-                   "Bound term variable not found  %s in environment: %s"
-                   uu___3 uu___4 in
-               failwith uu___2
-           | FStar_Pervasives_Native.Some (b, t) -> t)
-      | FStar_Pervasives_Native.Some (b, t) -> t
-let (mk_fvb :
-  FStar_Ident.lident ->
-    Prims.string ->
-      Prims.int ->
-        FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option ->
-          (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term)
-            FStar_Pervasives_Native.option -> Prims.bool -> fvar_binding)
-  =
-  fun lid ->
-    fun fname ->
-      fun arity ->
-        fun ftok ->
-          fun fuel_partial_app ->
-            fun thunked ->
-              let fvb =
-                {
-                  fvar_lid = lid;
-                  smt_arity = arity;
-                  smt_id = fname;
-                  smt_token = ftok;
-                  smt_fuel_partial_app = fuel_partial_app;
-                  fvb_thunked = thunked
-                } in
-              check_valid_fvb fvb; fvb
-let (new_term_constant_and_tok_from_lid_aux :
-  env_t ->
-    FStar_Ident.lident ->
-      Prims.int ->
-        Prims.bool ->
-          (Prims.string * Prims.string FStar_Pervasives_Native.option *
-            env_t))
-  =
-  fun env ->
-    fun x ->
-      fun arity ->
-        fun thunked ->
-          let fname = varops.new_fvar x in
-          let uu___ =
-            if thunked
-            then (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None)
-            else
-              (let ftok_name = Prims.op_Hat fname "@tok" in
-               let ftok = FStar_SMTEncoding_Util.mkApp (ftok_name, []) in
-               ((FStar_Pervasives_Native.Some ftok_name),
-                 (FStar_Pervasives_Native.Some ftok))) in
-          match uu___ with
-          | (ftok_name, ftok) ->
-              let fvb =
-                mk_fvb x fname arity ftok FStar_Pervasives_Native.None
-                  thunked in
-              let uu___1 =
-                let uu___2 = add_fvar_binding fvb env.fvar_bindings in
-                {
-                  bvar_bindings = (env.bvar_bindings);
-                  fvar_bindings = uu___2;
-                  depth = (env.depth);
-                  tcenv = (env.tcenv);
-                  warn = (env.warn);
-                  nolabels = (env.nolabels);
-                  use_zfuel_name = (env.use_zfuel_name);
-                  encode_non_total_function_typ =
-                    (env.encode_non_total_function_typ);
-                  current_module_name = (env.current_module_name);
-                  encoding_quantifier = (env.encoding_quantifier);
-                  global_cache = (env.global_cache)
-                } in
-              (fname, ftok_name, uu___1)
-let (new_term_constant_and_tok_from_lid :
-  env_t ->
-    FStar_Ident.lident -> Prims.int -> (Prims.string * Prims.string * env_t))
-  =
-  fun env ->
-    fun x ->
-      fun arity ->
-        let uu___ = new_term_constant_and_tok_from_lid_aux env x arity false in
-        match uu___ with
-        | (fname, ftok_name_opt, env1) ->
-            let uu___1 = FStar_Compiler_Option.get ftok_name_opt in
-            (fname, uu___1, env1)
-let (new_term_constant_and_tok_from_lid_maybe_thunked :
-  env_t ->
-    FStar_Ident.lident ->
-      Prims.int ->
-        Prims.bool ->
-          (Prims.string * Prims.string FStar_Pervasives_Native.option *
-            env_t))
-  =
-  fun env ->
-    fun x ->
-      fun arity ->
-        fun th -> new_term_constant_and_tok_from_lid_aux env x arity th
-let fail_fvar_lookup : 'uuuuu . env_t -> FStar_Ident.lident -> 'uuuuu =
-  fun env ->
-    fun a ->
-      let q = FStar_TypeChecker_Env.lookup_qname env.tcenv a in
-      match q with
-      | FStar_Pervasives_Native.None ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Print.lid_to_string a in
-            FStar_Compiler_Util.format1
-              "Name %s not found in the smtencoding and typechecker env"
-              uu___1 in
-          failwith uu___
-      | uu___ ->
-          let quals = FStar_TypeChecker_Env.quals_of_qninfo q in
-          let uu___1 =
-            (FStar_Compiler_Util.is_some quals) &&
-              (let uu___2 =
-                 FStar_Compiler_Effect.op_Bar_Greater quals
-                   FStar_Compiler_Util.must in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                 (FStar_Compiler_List.contains
-                    FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen)) in
-          if uu___1
-          then
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.lid_to_string a in
-                FStar_Compiler_Util.format1
-                  "Name %s not found in the smtencoding env (the symbol is marked unfold, expected it to reduce)"
-                  uu___4 in
-              (FStar_Errors.Fatal_IdentifierNotFound, uu___3) in
-            let uu___3 = FStar_Ident.range_of_lid a in
-            FStar_Errors.raise_error uu___2 uu___3
-          else
-            (let uu___3 =
-               let uu___4 = FStar_Syntax_Print.lid_to_string a in
-               FStar_Compiler_Util.format1
-                 "Name %s not found in the smtencoding env" uu___4 in
-             failwith uu___3)
-let (lookup_lid : env_t -> FStar_Ident.lident -> fvar_binding) =
-  fun env ->
-    fun a ->
-      let uu___ = lookup_fvar_binding env a in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> fail_fvar_lookup env a
-      | FStar_Pervasives_Native.Some s -> (check_valid_fvb s; s)
-let (push_free_var_maybe_thunked :
-  env_t ->
-    FStar_Ident.lident ->
-      Prims.int ->
-        Prims.string ->
-          FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option ->
-            Prims.bool -> env_t)
-  =
-  fun env ->
-    fun x ->
-      fun arity ->
-        fun fname ->
-          fun ftok ->
-            fun thunked ->
-              let fvb =
-                mk_fvb x fname arity ftok FStar_Pervasives_Native.None
-                  thunked in
-              let uu___ = add_fvar_binding fvb env.fvar_bindings in
-              {
-                bvar_bindings = (env.bvar_bindings);
-                fvar_bindings = uu___;
-                depth = (env.depth);
-                tcenv = (env.tcenv);
-                warn = (env.warn);
-                nolabels = (env.nolabels);
-                use_zfuel_name = (env.use_zfuel_name);
-                encode_non_total_function_typ =
-                  (env.encode_non_total_function_typ);
-                current_module_name = (env.current_module_name);
-                encoding_quantifier = (env.encoding_quantifier);
-                global_cache = (env.global_cache)
-              }
-let (push_free_var :
-  env_t ->
-    FStar_Ident.lident ->
-      Prims.int ->
-        Prims.string ->
-          FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option -> env_t)
-  =
-  fun env ->
-    fun x ->
-      fun arity ->
-        fun fname ->
-          fun ftok ->
-            push_free_var_maybe_thunked env x arity fname ftok false
-let (push_free_var_thunk :
-  env_t ->
-    FStar_Ident.lident ->
-      Prims.int ->
-        Prims.string ->
-          FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option -> env_t)
-  =
-  fun env ->
-    fun x ->
-      fun arity ->
-        fun fname ->
-          fun ftok ->
-            push_free_var_maybe_thunked env x arity fname ftok
-              (arity = Prims.int_zero)
-let (push_zfuel_name :
-  env_t -> FStar_Ident.lident -> Prims.string -> Prims.string -> env_t) =
-  fun env ->
-    fun x ->
-      fun f ->
-        fun ftok ->
-          let fvb = lookup_lid env x in
-          let t3 =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_SMTEncoding_Util.mkApp ("ZFuel", []) in
-                [uu___2] in
-              (f, uu___1) in
-            FStar_SMTEncoding_Util.mkApp uu___ in
-          let t3' =
-            let uu___ = FStar_SMTEncoding_Util.mkApp (ftok, []) in
-            let uu___1 = FStar_SMTEncoding_Util.mkApp ("ZFuel", []) in
-            FStar_SMTEncoding_Term.mk_ApplyTF uu___ uu___1 in
-          let fvb1 =
-            mk_fvb x fvb.smt_id fvb.smt_arity fvb.smt_token
-              (FStar_Pervasives_Native.Some (t3, t3')) false in
-          let uu___ = add_fvar_binding fvb1 env.fvar_bindings in
-          {
-            bvar_bindings = (env.bvar_bindings);
-            fvar_bindings = uu___;
-            depth = (env.depth);
-            tcenv = (env.tcenv);
-            warn = (env.warn);
-            nolabels = (env.nolabels);
-            use_zfuel_name = (env.use_zfuel_name);
-            encode_non_total_function_typ =
-              (env.encode_non_total_function_typ);
-            current_module_name = (env.current_module_name);
-            encoding_quantifier = (env.encoding_quantifier);
-            global_cache = (env.global_cache)
-          }
-let (force_thunk : fvar_binding -> FStar_SMTEncoding_Term.term) =
-  fun fvb ->
-    if
-      (Prims.op_Negation fvb.fvb_thunked) ||
-        (fvb.smt_arity <> Prims.int_zero)
-    then failwith "Forcing a non-thunk in the SMT encoding"
-    else ();
-    FStar_Compiler_Effect.op_Less_Bar FStar_SMTEncoding_Util.mkFreeV
-      ((fvb.smt_id), FStar_SMTEncoding_Term.Term_sort, true)
-let (try_lookup_free_var :
-  env_t ->
-    FStar_Ident.lident ->
-      FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun l ->
-      let uu___ = lookup_fvar_binding env l in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some fvb ->
-          ((let uu___2 =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env.tcenv)
-                (FStar_Options.Other "PartialApp") in
-            if uu___2
-            then
-              let uu___3 = FStar_Ident.string_of_lid l in
-              let uu___4 = fvb_to_string fvb in
-              FStar_Compiler_Util.print2 "Looked up %s found\n%s\n" uu___3
-                uu___4
-            else ());
-           if fvb.fvb_thunked
-           then
-             (let uu___2 = force_thunk fvb in
-              FStar_Pervasives_Native.Some uu___2)
-           else
-             (match fvb.smt_fuel_partial_app with
-              | FStar_Pervasives_Native.Some (uu___3, f) when
-                  env.use_zfuel_name -> FStar_Pervasives_Native.Some f
-              | uu___3 ->
-                  (match fvb.smt_token with
-                   | FStar_Pervasives_Native.Some t ->
-                       (match t.FStar_SMTEncoding_Term.tm with
-                        | FStar_SMTEncoding_Term.App (uu___4, fuel::[]) ->
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_SMTEncoding_Term.fv_of_term fuel in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                  FStar_SMTEncoding_Term.fv_name in
-                              FStar_Compiler_Util.starts_with uu___6 "fuel" in
-                            if uu___5
-                            then
-                              let uu___6 =
-                                let uu___7 =
-                                  let uu___8 =
-                                    FStar_SMTEncoding_Term.mk_fv
-                                      ((fvb.smt_id),
-                                        FStar_SMTEncoding_Term.Term_sort) in
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    FStar_SMTEncoding_Util.mkFreeV uu___8 in
-                                FStar_SMTEncoding_Term.mk_ApplyTF uu___7 fuel in
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (fun uu___7 ->
-                                   FStar_Pervasives_Native.Some uu___7)
-                                uu___6
-                            else FStar_Pervasives_Native.Some t
-                        | uu___4 -> FStar_Pervasives_Native.Some t)
-                   | uu___4 -> FStar_Pervasives_Native.None)))
-let (lookup_free_var :
-  env_t ->
-    FStar_Ident.lident FStar_Syntax_Syntax.withinfo_t ->
-      FStar_SMTEncoding_Term.term)
-  =
-  fun env ->
-    fun a ->
-      let uu___ = try_lookup_free_var env a.FStar_Syntax_Syntax.v in
-      match uu___ with
-      | FStar_Pervasives_Native.Some t -> t
-      | FStar_Pervasives_Native.None ->
-          fail_fvar_lookup env a.FStar_Syntax_Syntax.v
-let (lookup_free_var_name :
-  env_t -> FStar_Ident.lident FStar_Syntax_Syntax.withinfo_t -> fvar_binding)
-  = fun env -> fun a -> lookup_lid env a.FStar_Syntax_Syntax.v
-let (lookup_free_var_sym :
-  env_t ->
-    FStar_Ident.lident FStar_Syntax_Syntax.withinfo_t ->
-      ((FStar_SMTEncoding_Term.op, FStar_SMTEncoding_Term.term)
-        FStar_Pervasives.either * FStar_SMTEncoding_Term.term Prims.list *
-        Prims.int))
-  =
-  fun env ->
-    fun a ->
-      let fvb = lookup_lid env a.FStar_Syntax_Syntax.v in
-      match fvb.smt_fuel_partial_app with
-      | FStar_Pervasives_Native.Some
-          ({ FStar_SMTEncoding_Term.tm = FStar_SMTEncoding_Term.App (g, zf);
-             FStar_SMTEncoding_Term.freevars = uu___;
-             FStar_SMTEncoding_Term.rng = uu___1;_},
-           uu___2)
-          when env.use_zfuel_name ->
-          ((FStar_Pervasives.Inl g), zf, (fvb.smt_arity + Prims.int_one))
-      | uu___ ->
-          (match fvb.smt_token with
-           | FStar_Pervasives_Native.None when fvb.fvb_thunked ->
-               let uu___1 =
-                 let uu___2 = force_thunk fvb in FStar_Pervasives.Inr uu___2 in
-               (uu___1, [], (fvb.smt_arity))
-           | FStar_Pervasives_Native.None ->
-               ((FStar_Pervasives.Inl
-                   (FStar_SMTEncoding_Term.Var (fvb.smt_id))), [],
-                 (fvb.smt_arity))
-           | FStar_Pervasives_Native.Some sym ->
-               (match sym.FStar_SMTEncoding_Term.tm with
-                | FStar_SMTEncoding_Term.App (g, fuel::[]) ->
-                    ((FStar_Pervasives.Inl g), [fuel],
-                      (fvb.smt_arity + Prims.int_one))
-                | uu___1 ->
-                    ((FStar_Pervasives.Inl
-                        (FStar_SMTEncoding_Term.Var (fvb.smt_id))), [],
-                      (fvb.smt_arity))))
-let (tok_of_name :
-  env_t ->
-    Prims.string ->
-      FStar_SMTEncoding_Term.term FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun nm ->
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater env.fvar_bindings
-            FStar_Pervasives_Native.fst in
-        FStar_Compiler_Util.psmap_find_map uu___1
-          (fun uu___2 ->
-             fun fvb ->
-               check_valid_fvb fvb;
-               if fvb.smt_id = nm
-               then fvb.smt_token
-               else FStar_Pervasives_Native.None) in
-      match uu___ with
-      | FStar_Pervasives_Native.Some b -> FStar_Pervasives_Native.Some b
-      | FStar_Pervasives_Native.None ->
-          FStar_Compiler_Util.psmap_find_map env.bvar_bindings
-            (fun uu___1 ->
-               fun pi ->
-                 FStar_Compiler_Util.pimap_fold pi
-                   (fun uu___2 ->
-                      fun y ->
-                        fun res ->
-                          match (res, y) with
-                          | (FStar_Pervasives_Native.Some uu___3, uu___4) ->
-                              res
-                          | (FStar_Pervasives_Native.None,
-                             (uu___3,
-                              {
-                                FStar_SMTEncoding_Term.tm =
-                                  FStar_SMTEncoding_Term.App
-                                  (FStar_SMTEncoding_Term.Var sym, []);
-                                FStar_SMTEncoding_Term.freevars = uu___4;
-                                FStar_SMTEncoding_Term.rng = uu___5;_}))
-                              when sym = nm ->
-                              FStar_Pervasives_Native.Some
-                                (FStar_Pervasives_Native.snd y)
-                          | uu___3 -> FStar_Pervasives_Native.None)
-                   FStar_Pervasives_Native.None)
-let (reset_current_module_fvbs : env_t -> env_t) =
-  fun env ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater env.fvar_bindings
-          FStar_Pervasives_Native.fst in
-      (uu___1, []) in
-    {
-      bvar_bindings = (env.bvar_bindings);
-      fvar_bindings = uu___;
-      depth = (env.depth);
-      tcenv = (env.tcenv);
-      warn = (env.warn);
-      nolabels = (env.nolabels);
-      use_zfuel_name = (env.use_zfuel_name);
-      encode_non_total_function_typ = (env.encode_non_total_function_typ);
-      current_module_name = (env.current_module_name);
-      encoding_quantifier = (env.encoding_quantifier);
-      global_cache = (env.global_cache)
-    }
-let (get_current_module_fvbs : env_t -> fvar_binding Prims.list) =
-  fun env ->
-    FStar_Compiler_Effect.op_Bar_Greater env.fvar_bindings
-      FStar_Pervasives_Native.snd
-let (add_fvar_binding_to_env : fvar_binding -> env_t -> env_t) =
-  fun fvb ->
-    fun env ->
-      let uu___ = add_fvar_binding fvb env.fvar_bindings in
-      {
-        bvar_bindings = (env.bvar_bindings);
-        fvar_bindings = uu___;
-        depth = (env.depth);
-        tcenv = (env.tcenv);
-        warn = (env.warn);
-        nolabels = (env.nolabels);
-        use_zfuel_name = (env.use_zfuel_name);
-        encode_non_total_function_typ = (env.encode_non_total_function_typ);
-        current_module_name = (env.current_module_name);
-        encoding_quantifier = (env.encoding_quantifier);
-        global_cache = (env.global_cache)
-      }
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_ErrorReporting.ml b/src/ocaml-output/FStar_SMTEncoding_ErrorReporting.ml
deleted file mode 100644
index 5534219802d..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_ErrorReporting.ml
+++ /dev/null
@@ -1,852 +0,0 @@
-open Prims
-type label = FStar_SMTEncoding_Term.error_label
-type labels = label Prims.list
-exception Not_a_wp_implication of Prims.string 
-let (uu___is_Not_a_wp_implication : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Not_a_wp_implication uu___ -> true
-    | uu___ -> false
-let (__proj__Not_a_wp_implication__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | Not_a_wp_implication uu___ -> uu___
-let (sort_labels :
-  (FStar_SMTEncoding_Term.error_label * Prims.bool) Prims.list ->
-    ((FStar_SMTEncoding_Term.fv * Prims.string * FStar_Compiler_Range.range)
-      * Prims.bool) Prims.list)
-  =
-  fun l ->
-    FStar_Compiler_List.sortWith
-      (fun uu___ ->
-         fun uu___1 ->
-           match (uu___, uu___1) with
-           | (((uu___2, uu___3, r1), uu___4), ((uu___5, uu___6, r2), uu___7))
-               -> FStar_Compiler_Range.compare r1 r2) l
-let (remove_dups :
-  labels ->
-    (FStar_SMTEncoding_Term.fv * Prims.string * FStar_Compiler_Range.range)
-      Prims.list)
-  =
-  fun l ->
-    FStar_Compiler_Util.remove_dups
-      (fun uu___ ->
-         fun uu___1 ->
-           match (uu___, uu___1) with
-           | ((uu___2, m1, r1), (uu___3, m2, r2)) -> (r1 = r2) && (m1 = m2))
-      l
-type msg = (Prims.string * FStar_Compiler_Range.range)
-type ranges =
-  (Prims.string FStar_Pervasives_Native.option * FStar_Compiler_Range.range)
-    Prims.list
-let (fresh_label :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      FStar_SMTEncoding_Term.term -> (label * FStar_SMTEncoding_Term.term))
-  =
-  let ctr = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  fun message ->
-    fun range ->
-      fun t ->
-        let l =
-          FStar_Compiler_Util.incr ctr;
-          (let uu___1 =
-             let uu___2 = FStar_Compiler_Effect.op_Bang ctr in
-             FStar_Compiler_Util.string_of_int uu___2 in
-           FStar_Compiler_Util.format1 "label_%s" uu___1) in
-        let lvar =
-          FStar_SMTEncoding_Term.mk_fv (l, FStar_SMTEncoding_Term.Bool_sort) in
-        let label1 = (lvar, message, range) in
-        let lterm = FStar_SMTEncoding_Util.mkFreeV lvar in
-        let lt = FStar_SMTEncoding_Term.mkOr (lterm, t) range in (label1, lt)
-let (label_goals :
-  (unit -> Prims.string) FStar_Pervasives_Native.option ->
-    FStar_Compiler_Range.range ->
-      FStar_SMTEncoding_Term.term -> (labels * FStar_SMTEncoding_Term.term))
-  =
-  fun use_env_msg ->
-    fun r ->
-      fun q ->
-        let rec is_a_post_condition post_name_opt tm =
-          match (post_name_opt, (tm.FStar_SMTEncoding_Term.tm)) with
-          | (FStar_Pervasives_Native.None, uu___) -> false
-          | (FStar_Pervasives_Native.Some nm, FStar_SMTEncoding_Term.FreeV
-             fv) ->
-              let uu___ = FStar_SMTEncoding_Term.fv_name fv in nm = uu___
-          | (uu___, FStar_SMTEncoding_Term.App
-             (FStar_SMTEncoding_Term.Var "Valid", tm1::[])) ->
-              is_a_post_condition post_name_opt tm1
-          | (uu___, FStar_SMTEncoding_Term.App
-             (FStar_SMTEncoding_Term.Var "ApplyTT", tm1::uu___1)) ->
-              is_a_post_condition post_name_opt tm1
-          | uu___ -> false in
-        let conjuncts t =
-          match t.FStar_SMTEncoding_Term.tm with
-          | FStar_SMTEncoding_Term.App (FStar_SMTEncoding_Term.And, cs) -> cs
-          | uu___ -> [t] in
-        let is_guard_free tm =
-          match tm.FStar_SMTEncoding_Term.tm with
-          | FStar_SMTEncoding_Term.Quant
-              (FStar_SMTEncoding_Term.Forall,
-               ({
-                  FStar_SMTEncoding_Term.tm = FStar_SMTEncoding_Term.App
-                    (FStar_SMTEncoding_Term.Var "Prims.guard_free", p::[]);
-                  FStar_SMTEncoding_Term.freevars = uu___;
-                  FStar_SMTEncoding_Term.rng = uu___1;_}::[])::[],
-               iopt, uu___2,
-               {
-                 FStar_SMTEncoding_Term.tm = FStar_SMTEncoding_Term.App
-                   (FStar_SMTEncoding_Term.Imp, l::r1::[]);
-                 FStar_SMTEncoding_Term.freevars = uu___3;
-                 FStar_SMTEncoding_Term.rng = uu___4;_})
-              -> true
-          | uu___ -> false in
-        let is_a_named_continuation lhs =
-          FStar_Compiler_Effect.op_Bar_Greater (conjuncts lhs)
-            (FStar_Compiler_Util.for_some is_guard_free) in
-        let uu___ =
-          match use_env_msg with
-          | FStar_Pervasives_Native.None -> (false, "")
-          | FStar_Pervasives_Native.Some f ->
-              let uu___1 = f () in (true, uu___1) in
-        match uu___ with
-        | (flag, msg_prefix) ->
-            let fresh_label1 msg1 ropt rng t =
-              let msg2 =
-                if flag
-                then
-                  Prims.op_Hat "Failed to verify implicit argument: "
-                    (Prims.op_Hat msg_prefix (Prims.op_Hat " :: " msg1))
-                else msg1 in
-              let rng1 =
-                match ropt with
-                | FStar_Pervasives_Native.None -> rng
-                | FStar_Pervasives_Native.Some r1 ->
-                    let uu___1 =
-                      let uu___2 = FStar_Compiler_Range.use_range rng in
-                      let uu___3 = FStar_Compiler_Range.use_range r1 in
-                      FStar_Compiler_Range.rng_included uu___2 uu___3 in
-                    if uu___1
-                    then rng
-                    else
-                      (let uu___3 = FStar_Compiler_Range.def_range rng in
-                       FStar_Compiler_Range.set_def_range r1 uu___3) in
-              fresh_label msg2 rng1 t in
-            let rec aux default_msg ropt post_name_opt labels1 q1 =
-              match q1.FStar_SMTEncoding_Term.tm with
-              | FStar_SMTEncoding_Term.BoundV uu___1 -> (labels1, q1)
-              | FStar_SMTEncoding_Term.Integer uu___1 -> (labels1, q1)
-              | FStar_SMTEncoding_Term.String uu___1 -> (labels1, q1)
-              | FStar_SMTEncoding_Term.Real uu___1 -> (labels1, q1)
-              | FStar_SMTEncoding_Term.LblPos uu___1 -> failwith "Impossible"
-              | FStar_SMTEncoding_Term.Labeled
-                  (arg, "could not prove post-condition", label_range) ->
-                  let fallback debug_msg =
-                    aux default_msg
-                      (FStar_Pervasives_Native.Some label_range)
-                      post_name_opt labels1 arg in
-                  (try
-                     (fun uu___1 ->
-                        match () with
-                        | () ->
-                            (match arg.FStar_SMTEncoding_Term.tm with
-                             | FStar_SMTEncoding_Term.Quant
-                                 (FStar_SMTEncoding_Term.Forall, pats, iopt,
-                                  post::sorts,
-                                  {
-                                    FStar_SMTEncoding_Term.tm =
-                                      FStar_SMTEncoding_Term.App
-                                      (FStar_SMTEncoding_Term.Imp,
-                                       lhs::rhs::[]);
-                                    FStar_SMTEncoding_Term.freevars = uu___2;
-                                    FStar_SMTEncoding_Term.rng = rng;_})
-                                 ->
-                                 let post_name =
-                                   let uu___3 =
-                                     let uu___4 = FStar_Ident.next_id () in
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       FStar_Compiler_Util.string_of_int
-                                       uu___4 in
-                                   Prims.op_Hat "^^post_condition_" uu___3 in
-                                 let names =
-                                   let uu___3 =
-                                     FStar_SMTEncoding_Term.mk_fv
-                                       (post_name, post) in
-                                   let uu___4 =
-                                     FStar_Compiler_List.map
-                                       (fun s ->
-                                          let uu___5 =
-                                            let uu___6 =
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  FStar_Ident.next_id () in
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  FStar_Compiler_Util.string_of_int
-                                                  uu___8 in
-                                              Prims.op_Hat "^^" uu___7 in
-                                            (uu___6, s) in
-                                          FStar_SMTEncoding_Term.mk_fv uu___5)
-                                       sorts in
-                                   uu___3 :: uu___4 in
-                                 let instantiation =
-                                   FStar_Compiler_List.map
-                                     FStar_SMTEncoding_Util.mkFreeV names in
-                                 let uu___3 =
-                                   let uu___4 =
-                                     FStar_SMTEncoding_Term.inst
-                                       instantiation lhs in
-                                   let uu___5 =
-                                     FStar_SMTEncoding_Term.inst
-                                       instantiation rhs in
-                                   (uu___4, uu___5) in
-                                 (match uu___3 with
-                                  | (lhs1, rhs1) ->
-                                      let uu___4 =
-                                        match lhs1.FStar_SMTEncoding_Term.tm
-                                        with
-                                        | FStar_SMTEncoding_Term.App
-                                            (FStar_SMTEncoding_Term.And,
-                                             clauses_lhs)
-                                            ->
-                                            let uu___5 =
-                                              FStar_Compiler_Util.prefix
-                                                clauses_lhs in
-                                            (match uu___5 with
-                                             | (req, ens) ->
-                                                 (match ens.FStar_SMTEncoding_Term.tm
-                                                  with
-                                                  | FStar_SMTEncoding_Term.Quant
-                                                      (FStar_SMTEncoding_Term.Forall,
-                                                       pats_ens, iopt_ens,
-                                                       sorts_ens,
-                                                       {
-                                                         FStar_SMTEncoding_Term.tm
-                                                           =
-                                                           FStar_SMTEncoding_Term.App
-                                                           (FStar_SMTEncoding_Term.Imp,
-                                                            ensures_conjuncts::post1::[]);
-                                                         FStar_SMTEncoding_Term.freevars
-                                                           = uu___6;
-                                                         FStar_SMTEncoding_Term.rng
-                                                           = rng_ens;_})
-                                                      ->
-                                                      let uu___7 =
-                                                        is_a_post_condition
-                                                          (FStar_Pervasives_Native.Some
-                                                             post_name) post1 in
-                                                      if uu___7
-                                                      then
-                                                        let uu___8 =
-                                                          aux
-                                                            "could not prove post-condition"
-                                                            FStar_Pervasives_Native.None
-                                                            (FStar_Pervasives_Native.Some
-                                                               post_name)
-                                                            labels1
-                                                            ensures_conjuncts in
-                                                        (match uu___8 with
-                                                         | (labels2,
-                                                            ensures_conjuncts1)
-                                                             ->
-                                                             let pats_ens1 =
-                                                               match pats_ens
-                                                               with
-                                                               | [] ->
-                                                                   [[post1]]
-                                                               | []::[] ->
-                                                                   [[post1]]
-                                                               | uu___9 ->
-                                                                   pats_ens in
-                                                             let ens1 =
-                                                               let uu___9 =
-                                                                 let uu___10
-                                                                   =
-                                                                   let uu___11
-                                                                    =
-                                                                    FStar_SMTEncoding_Term.mk
-                                                                    (FStar_SMTEncoding_Term.App
-                                                                    (FStar_SMTEncoding_Term.Imp,
-                                                                    [ensures_conjuncts1;
-                                                                    post1]))
-                                                                    rng_ens in
-                                                                   (FStar_SMTEncoding_Term.Forall,
-                                                                    pats_ens1,
-                                                                    iopt_ens,
-                                                                    sorts_ens,
-                                                                    uu___11) in
-                                                                 FStar_SMTEncoding_Term.Quant
-                                                                   uu___10 in
-                                                               FStar_SMTEncoding_Term.mk
-                                                                 uu___9
-                                                                 ens.FStar_SMTEncoding_Term.rng in
-                                                             let lhs2 =
-                                                               FStar_SMTEncoding_Term.mk
-                                                                 (FStar_SMTEncoding_Term.App
-                                                                    (FStar_SMTEncoding_Term.And,
-                                                                    (FStar_Compiler_List.op_At
-                                                                    req
-                                                                    [ens1])))
-                                                                 lhs1.FStar_SMTEncoding_Term.rng in
-                                                             let uu___9 =
-                                                               FStar_SMTEncoding_Term.abstr
-                                                                 names lhs2 in
-                                                             (labels2,
-                                                               uu___9))
-                                                      else
-                                                        (let uu___9 =
-                                                           let uu___10 =
-                                                             let uu___11 =
-                                                               let uu___12 =
-                                                                 let uu___13
-                                                                   =
-                                                                   FStar_SMTEncoding_Term.print_smt_term
-                                                                    post1 in
-                                                                 Prims.op_Hat
-                                                                   "  ... "
-                                                                   uu___13 in
-                                                               Prims.op_Hat
-                                                                 post_name
-                                                                 uu___12 in
-                                                             Prims.op_Hat
-                                                               "Ensures clause doesn't match post name:  "
-                                                               uu___11 in
-                                                           Not_a_wp_implication
-                                                             uu___10 in
-                                                         FStar_Compiler_Effect.raise
-                                                           uu___9)
-                                                  | uu___6 ->
-                                                      let uu___7 =
-                                                        let uu___8 =
-                                                          let uu___9 =
-                                                            let uu___10 =
-                                                              let uu___11 =
-                                                                FStar_SMTEncoding_Term.print_smt_term
-                                                                  ens in
-                                                              Prims.op_Hat
-                                                                "  ... "
-                                                                uu___11 in
-                                                            Prims.op_Hat
-                                                              post_name
-                                                              uu___10 in
-                                                          Prims.op_Hat
-                                                            "Ensures clause doesn't have the expected shape for post-condition "
-                                                            uu___9 in
-                                                        Not_a_wp_implication
-                                                          uu___8 in
-                                                      FStar_Compiler_Effect.raise
-                                                        uu___7))
-                                        | uu___5 ->
-                                            let uu___6 =
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  FStar_SMTEncoding_Term.print_smt_term
-                                                    lhs1 in
-                                                Prims.op_Hat
-                                                  "LHS not a conjunct: "
-                                                  uu___8 in
-                                              Not_a_wp_implication uu___7 in
-                                            FStar_Compiler_Effect.raise
-                                              uu___6 in
-                                      (match uu___4 with
-                                       | (labels2, lhs2) ->
-                                           let uu___5 =
-                                             let uu___6 =
-                                               aux default_msg
-                                                 FStar_Pervasives_Native.None
-                                                 (FStar_Pervasives_Native.Some
-                                                    post_name) labels2 rhs1 in
-                                             match uu___6 with
-                                             | (labels3, rhs2) ->
-                                                 let uu___7 =
-                                                   FStar_SMTEncoding_Term.abstr
-                                                     names rhs2 in
-                                                 (labels3, uu___7) in
-                                           (match uu___5 with
-                                            | (labels3, rhs2) ->
-                                                let body =
-                                                  FStar_SMTEncoding_Term.mkImp
-                                                    (lhs2, rhs2) rng in
-                                                let uu___6 =
-                                                  FStar_SMTEncoding_Term.mk
-                                                    (FStar_SMTEncoding_Term.Quant
-                                                       (FStar_SMTEncoding_Term.Forall,
-                                                         pats, iopt, (post ::
-                                                         sorts), body))
-                                                    q1.FStar_SMTEncoding_Term.rng in
-                                                (labels3, uu___6))))
-                             | uu___2 ->
-                                 let uu___3 =
-                                   let uu___4 =
-                                     FStar_SMTEncoding_Term.print_smt_term
-                                       arg in
-                                   Prims.op_Hat "arg not a quant: " uu___4 in
-                                 fallback uu___3)) ()
-                   with | Not_a_wp_implication msg1 -> fallback msg1)
-              | FStar_SMTEncoding_Term.Labeled (arg, reason, r1) ->
-                  aux reason (FStar_Pervasives_Native.Some r1) post_name_opt
-                    labels1 arg
-              | FStar_SMTEncoding_Term.Quant
-                  (FStar_SMTEncoding_Term.Forall, [],
-                   FStar_Pervasives_Native.None, sorts,
-                   {
-                     FStar_SMTEncoding_Term.tm = FStar_SMTEncoding_Term.App
-                       (FStar_SMTEncoding_Term.Imp, lhs::rhs::[]);
-                     FStar_SMTEncoding_Term.freevars = uu___1;
-                     FStar_SMTEncoding_Term.rng = rng;_})
-                  when is_a_named_continuation lhs ->
-                  let uu___2 = FStar_Compiler_Util.prefix sorts in
-                  (match uu___2 with
-                   | (sorts', post) ->
-                       let new_post_name =
-                         let uu___3 =
-                           let uu___4 = FStar_Ident.next_id () in
-                           FStar_Compiler_Effect.op_Less_Bar
-                             FStar_Compiler_Util.string_of_int uu___4 in
-                         Prims.op_Hat "^^post_condition_" uu___3 in
-                       let names =
-                         let uu___3 =
-                           FStar_Compiler_List.map
-                             (fun s ->
-                                let uu___4 =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      let uu___7 = FStar_Ident.next_id () in
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        FStar_Compiler_Util.string_of_int
-                                        uu___7 in
-                                    Prims.op_Hat "^^" uu___6 in
-                                  (uu___5, s) in
-                                FStar_SMTEncoding_Term.mk_fv uu___4) sorts' in
-                         let uu___4 =
-                           let uu___5 =
-                             FStar_SMTEncoding_Term.mk_fv
-                               (new_post_name, post) in
-                           [uu___5] in
-                         FStar_Compiler_List.op_At uu___3 uu___4 in
-                       let instantiation =
-                         FStar_Compiler_List.map
-                           FStar_SMTEncoding_Util.mkFreeV names in
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_SMTEncoding_Term.inst instantiation lhs in
-                         let uu___5 =
-                           FStar_SMTEncoding_Term.inst instantiation rhs in
-                         (uu___4, uu___5) in
-                       (match uu___3 with
-                        | (lhs1, rhs1) ->
-                            let uu___4 =
-                              FStar_Compiler_Util.fold_map
-                                (fun labels2 ->
-                                   fun tm ->
-                                     match tm.FStar_SMTEncoding_Term.tm with
-                                     | FStar_SMTEncoding_Term.Quant
-                                         (FStar_SMTEncoding_Term.Forall,
-                                          ({
-                                             FStar_SMTEncoding_Term.tm =
-                                               FStar_SMTEncoding_Term.App
-                                               (FStar_SMTEncoding_Term.Var
-                                                "Prims.guard_free", p::[]);
-                                             FStar_SMTEncoding_Term.freevars
-                                               = uu___5;
-                                             FStar_SMTEncoding_Term.rng =
-                                               uu___6;_}::[])::[],
-                                          iopt, sorts1,
-                                          {
-                                            FStar_SMTEncoding_Term.tm =
-                                              FStar_SMTEncoding_Term.App
-                                              (FStar_SMTEncoding_Term.Imp,
-                                               l0::r1::[]);
-                                            FStar_SMTEncoding_Term.freevars =
-                                              uu___7;
-                                            FStar_SMTEncoding_Term.rng =
-                                              uu___8;_})
-                                         ->
-                                         let uu___9 =
-                                           is_a_post_condition
-                                             (FStar_Pervasives_Native.Some
-                                                new_post_name) r1 in
-                                         if uu___9
-                                         then
-                                           let uu___10 =
-                                             aux default_msg
-                                               FStar_Pervasives_Native.None
-                                               post_name_opt labels2 l0 in
-                                           (match uu___10 with
-                                            | (labels3, l) ->
-                                                let uu___11 =
-                                                  let uu___12 =
-                                                    let uu___13 =
-                                                      let uu___14 =
-                                                        FStar_SMTEncoding_Util.norng
-                                                          FStar_SMTEncoding_Term.mk
-                                                          (FStar_SMTEncoding_Term.App
-                                                             (FStar_SMTEncoding_Term.Imp,
-                                                               [l; r1])) in
-                                                      (FStar_SMTEncoding_Term.Forall,
-                                                        [[p]],
-                                                        (FStar_Pervasives_Native.Some
-                                                           Prims.int_zero),
-                                                        sorts1, uu___14) in
-                                                    FStar_SMTEncoding_Term.Quant
-                                                      uu___13 in
-                                                  FStar_SMTEncoding_Term.mk
-                                                    uu___12
-                                                    q1.FStar_SMTEncoding_Term.rng in
-                                                (labels3, uu___11))
-                                         else (labels2, tm)
-                                     | uu___5 -> (labels2, tm)) labels1
-                                (conjuncts lhs1) in
-                            (match uu___4 with
-                             | (labels2, lhs_conjs) ->
-                                 let uu___5 =
-                                   aux default_msg
-                                     FStar_Pervasives_Native.None
-                                     (FStar_Pervasives_Native.Some
-                                        new_post_name) labels2 rhs1 in
-                                 (match uu___5 with
-                                  | (labels3, rhs2) ->
-                                      let body =
-                                        let uu___6 =
-                                          let uu___7 =
-                                            let uu___8 =
-                                              FStar_SMTEncoding_Term.mk_and_l
-                                                lhs_conjs
-                                                lhs1.FStar_SMTEncoding_Term.rng in
-                                            (uu___8, rhs2) in
-                                          FStar_SMTEncoding_Term.mkImp uu___7
-                                            rng in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___6
-                                          (FStar_SMTEncoding_Term.abstr names) in
-                                      let q2 =
-                                        FStar_SMTEncoding_Term.mk
-                                          (FStar_SMTEncoding_Term.Quant
-                                             (FStar_SMTEncoding_Term.Forall,
-                                               [],
-                                               FStar_Pervasives_Native.None,
-                                               sorts, body))
-                                          q1.FStar_SMTEncoding_Term.rng in
-                                      (labels3, q2)))))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Imp, lhs::rhs::[]) ->
-                  let uu___1 = aux default_msg ropt post_name_opt labels1 rhs in
-                  (match uu___1 with
-                   | (labels2, rhs1) ->
-                       let uu___2 = FStar_SMTEncoding_Util.mkImp (lhs, rhs1) in
-                       (labels2, uu___2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.And, conjuncts1) ->
-                  let uu___1 =
-                    FStar_Compiler_Util.fold_map
-                      (aux default_msg ropt post_name_opt) labels1 conjuncts1 in
-                  (match uu___1 with
-                   | (labels2, conjuncts2) ->
-                       let uu___2 =
-                         FStar_SMTEncoding_Term.mk_and_l conjuncts2
-                           q1.FStar_SMTEncoding_Term.rng in
-                       (labels2, uu___2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.ITE, hd::q11::q2::[]) ->
-                  let uu___1 = aux default_msg ropt post_name_opt labels1 q11 in
-                  (match uu___1 with
-                   | (labels2, q12) ->
-                       let uu___2 =
-                         aux default_msg ropt post_name_opt labels2 q2 in
-                       (match uu___2 with
-                        | (labels3, q21) ->
-                            let uu___3 =
-                              FStar_SMTEncoding_Term.mkITE (hd, q12, q21)
-                                q1.FStar_SMTEncoding_Term.rng in
-                            (labels3, uu___3)))
-              | FStar_SMTEncoding_Term.Quant
-                  (FStar_SMTEncoding_Term.Exists, uu___1, uu___2, uu___3,
-                   uu___4)
-                  ->
-                  let uu___5 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___5 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Iff, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Or, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Var "Unreachable", uu___1) ->
-                  (labels1, q1)
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Var uu___1, uu___2) when
-                  is_a_post_condition post_name_opt q1 -> (labels1, q1)
-              | FStar_SMTEncoding_Term.FreeV uu___1 ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.TrueOp, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.FalseOp, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Not, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Eq, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.LT, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.LTE, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.GT, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.GTE, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvUlt, uu___1) ->
-                  let uu___2 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___2 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Var uu___1, uu___2) ->
-                  let uu___3 =
-                    fresh_label1 default_msg ropt
-                      q1.FStar_SMTEncoding_Term.rng q1 in
-                  (match uu___3 with | (lab, q2) -> ((lab :: labels1), q2))
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.RealDiv, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Add, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Sub, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Div, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Mul, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Minus, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Mod, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvAnd, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvXor, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvOr, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvAdd, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvSub, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvShl, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvShr, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvUdiv, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvMod, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvMul, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvUext uu___1, uu___2) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.BvToNat, uu___1) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.NatToBv uu___1, uu___2) ->
-                  failwith "Impossible: non-propositional term"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.ITE, uu___1) ->
-                  failwith "Impossible: arity mismatch"
-              | FStar_SMTEncoding_Term.App
-                  (FStar_SMTEncoding_Term.Imp, uu___1) ->
-                  failwith "Impossible: arity mismatch"
-              | FStar_SMTEncoding_Term.Quant
-                  (FStar_SMTEncoding_Term.Forall, pats, iopt, sorts, body) ->
-                  let uu___1 =
-                    aux default_msg ropt post_name_opt labels1 body in
-                  (match uu___1 with
-                   | (labels2, body1) ->
-                       let uu___2 =
-                         FStar_SMTEncoding_Term.mk
-                           (FStar_SMTEncoding_Term.Quant
-                              (FStar_SMTEncoding_Term.Forall, pats, iopt,
-                                sorts, body1)) q1.FStar_SMTEncoding_Term.rng in
-                       (labels2, uu___2))
-              | FStar_SMTEncoding_Term.Let (es, body) ->
-                  let uu___1 =
-                    aux default_msg ropt post_name_opt labels1 body in
-                  (match uu___1 with
-                   | (labels2, body1) ->
-                       let uu___2 =
-                         FStar_SMTEncoding_Term.mkLet (es, body1)
-                           q1.FStar_SMTEncoding_Term.rng in
-                       (labels2, uu___2)) in
-            aux "assertion failed" FStar_Pervasives_Native.None
-              FStar_Pervasives_Native.None [] q
-let (detail_errors :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      labels ->
-        (FStar_SMTEncoding_Term.decl Prims.list ->
-           FStar_SMTEncoding_Z3.z3result)
-          -> unit)
-  =
-  fun hint_replay ->
-    fun env ->
-      fun all_labels ->
-        fun askZ3 ->
-          let print_banner uu___ =
-            let msg1 =
-              let uu___1 =
-                let uu___2 = FStar_TypeChecker_Env.get_range env in
-                FStar_Compiler_Range.string_of_range uu___2 in
-              let uu___2 =
-                FStar_Compiler_Util.string_of_int (Prims.of_int (5)) in
-              let uu___3 =
-                FStar_Compiler_Util.string_of_int
-                  (FStar_Compiler_List.length all_labels) in
-              FStar_Compiler_Util.format4
-                "Detailed %s report follows for %s\nTaking %s seconds per proof obligation (%s proofs in total)\n"
-                (if hint_replay then "hint replay" else "error") uu___1
-                uu___2 uu___3 in
-            FStar_Compiler_Util.print_error msg1 in
-          let print_result uu___ =
-            match uu___ with
-            | ((uu___1, msg1, r), success) ->
-                if success
-                then
-                  let uu___2 = FStar_Compiler_Range.string_of_range r in
-                  FStar_Compiler_Util.print1
-                    "OK: proof obligation at %s was proven in isolation\n"
-                    uu___2
-                else
-                  if hint_replay
-                  then
-                    FStar_Errors.log_issue r
-                      (FStar_Errors.Warning_HintFailedToReplayProof,
-                        (Prims.op_Hat
-                           "Hint failed to replay this sub-proof: " msg1))
-                  else
-                    (let uu___4 =
-                       let uu___5 =
-                         let uu___6 = FStar_Compiler_Range.string_of_range r in
-                         FStar_Compiler_Util.format2
-                           "XX: proof obligation at %s failed\n\t%s\n" uu___6
-                           msg1 in
-                       (FStar_Errors.Error_ProofObligationFailed, uu___5) in
-                     FStar_Errors.log_issue r uu___4) in
-          let elim labs =
-            FStar_Compiler_Effect.op_Bar_Greater labs
-              (FStar_Compiler_List.map
-                 (fun uu___ ->
-                    match uu___ with
-                    | (l, uu___1, uu___2) ->
-                        let a =
-                          let uu___3 =
-                            let uu___4 =
-                              let uu___5 = FStar_SMTEncoding_Util.mkFreeV l in
-                              (uu___5, FStar_SMTEncoding_Util.mkTrue) in
-                            FStar_SMTEncoding_Util.mkEq uu___4 in
-                          let uu___4 =
-                            let uu___5 = FStar_SMTEncoding_Term.fv_name l in
-                            Prims.op_Hat "@disable_label_" uu___5 in
-                          {
-                            FStar_SMTEncoding_Term.assumption_term = uu___3;
-                            FStar_SMTEncoding_Term.assumption_caption =
-                              (FStar_Pervasives_Native.Some "Disabling label");
-                            FStar_SMTEncoding_Term.assumption_name = uu___4;
-                            FStar_SMTEncoding_Term.assumption_fact_ids = []
-                          } in
-                        FStar_SMTEncoding_Term.Assume a)) in
-          let rec linear_check eliminated errors active =
-            FStar_SMTEncoding_Z3.refresh ();
-            (match active with
-             | [] ->
-                 let results =
-                   let uu___1 =
-                     FStar_Compiler_List.map (fun x -> (x, true)) eliminated in
-                   let uu___2 =
-                     FStar_Compiler_List.map (fun x -> (x, false)) errors in
-                   FStar_Compiler_List.op_At uu___1 uu___2 in
-                 sort_labels results
-             | hd::tl ->
-                 ((let uu___2 =
-                     FStar_Compiler_Util.string_of_int
-                       (FStar_Compiler_List.length active) in
-                   FStar_Compiler_Util.print1 "%s, " uu___2);
-                  (let decls =
-                     FStar_Compiler_Effect.op_Less_Bar elim
-                       (FStar_Compiler_List.op_At eliminated
-                          (FStar_Compiler_List.op_At errors tl)) in
-                   let result = askZ3 decls in
-                   match result.FStar_SMTEncoding_Z3.z3result_status with
-                   | FStar_SMTEncoding_Z3.UNSAT uu___2 ->
-                       linear_check (hd :: eliminated) errors tl
-                   | uu___2 -> linear_check eliminated (hd :: errors) tl))) in
-          print_banner ();
-          FStar_Options.set_option "z3rlimit"
-            (FStar_Options.Int (Prims.of_int (5)));
-          (let res = linear_check [] [] all_labels in
-           FStar_Compiler_Util.print_string "\n";
-           FStar_Compiler_Effect.op_Bar_Greater res
-             (FStar_Compiler_List.iter print_result);
-           (let uu___4 =
-              FStar_Compiler_Util.for_all FStar_Pervasives_Native.snd res in
-            if uu___4
-            then
-              FStar_Compiler_Util.print_string
-                "Failed: the heuristic of trying each proof in isolation failed to identify a precise error\n"
-            else ()))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_Solver.ml b/src/ocaml-output/FStar_SMTEncoding_Solver.ml
deleted file mode 100644
index 83583a59411..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_Solver.ml
+++ /dev/null
@@ -1,1912 +0,0 @@
-open Prims
-exception SplitQueryAndRetry 
-let (uu___is_SplitQueryAndRetry : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SplitQueryAndRetry -> true | uu___ -> false
-let (z3_replay_result : (unit * unit)) = ((), ())
-let z3_result_as_replay_result :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    ('uuuuu, ('uuuuu1 * 'uuuuu2)) FStar_Pervasives.either ->
-      ('uuuuu, 'uuuuu1) FStar_Pervasives.either
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives.Inl l -> FStar_Pervasives.Inl l
-    | FStar_Pervasives.Inr (r, uu___1) -> FStar_Pervasives.Inr r
-let (recorded_hints :
-  FStar_Compiler_Util.hints FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (replaying_hints :
-  FStar_Compiler_Util.hints FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let initialize_hints_db : 'uuuuu . Prims.string -> 'uuuuu -> unit =
-  fun src_filename ->
-    fun format_filename ->
-      (let uu___1 = FStar_Options.record_hints () in
-       if uu___1
-       then
-         FStar_Compiler_Effect.op_Colon_Equals recorded_hints
-           (FStar_Pervasives_Native.Some [])
-       else ());
-      (let norm_src_filename =
-         FStar_Compiler_Util.normalize_file_path src_filename in
-       let val_filename = FStar_Options.hint_file_for_src norm_src_filename in
-       let uu___1 = FStar_Compiler_Util.read_hints val_filename in
-       match uu___1 with
-       | FStar_Compiler_Util.HintsOK hints ->
-           let expected_digest =
-             FStar_Compiler_Util.digest_of_file norm_src_filename in
-           ((let uu___3 = FStar_Options.hint_info () in
-             if uu___3
-             then
-               FStar_Compiler_Util.print3 "(%s) digest is %s from %s.\n"
-                 norm_src_filename
-                 (if
-                    hints.FStar_Compiler_Util.module_digest = expected_digest
-                  then "valid; using hints"
-                  else "invalid; using potentially stale hints") val_filename
-             else ());
-            FStar_Compiler_Effect.op_Colon_Equals replaying_hints
-              (FStar_Pervasives_Native.Some (hints.FStar_Compiler_Util.hints)))
-       | FStar_Compiler_Util.MalformedJson ->
-           let uu___3 = FStar_Options.use_hints () in
-           if uu___3
-           then
-             let uu___4 =
-               let uu___5 =
-                 FStar_Compiler_Util.format1
-                   "Malformed JSON hints file: %s; ran without hints"
-                   val_filename in
-               (FStar_Errors.Warning_CouldNotReadHints, uu___5) in
-             FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___4
-           else ()
-       | FStar_Compiler_Util.UnableToOpen ->
-           let uu___3 = FStar_Options.use_hints () in
-           if uu___3
-           then
-             let uu___4 =
-               let uu___5 =
-                 FStar_Compiler_Util.format1
-                   "Unable to open hints file: %s; ran without hints"
-                   val_filename in
-               (FStar_Errors.Warning_CouldNotReadHints, uu___5) in
-             FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___4
-           else ())
-let (finalize_hints_db : Prims.string -> unit) =
-  fun src_filename ->
-    (let uu___1 = FStar_Options.record_hints () in
-     if uu___1
-     then
-       let hints =
-         let uu___2 = FStar_Compiler_Effect.op_Bang recorded_hints in
-         FStar_Compiler_Option.get uu___2 in
-       let hints_db =
-         let uu___2 = FStar_Compiler_Util.digest_of_file src_filename in
-         {
-           FStar_Compiler_Util.module_digest = uu___2;
-           FStar_Compiler_Util.hints = hints
-         } in
-       let norm_src_filename =
-         FStar_Compiler_Util.normalize_file_path src_filename in
-       let val_filename = FStar_Options.hint_file_for_src norm_src_filename in
-       FStar_Compiler_Util.write_hints val_filename hints_db
-     else ());
-    FStar_Compiler_Effect.op_Colon_Equals recorded_hints
-      FStar_Pervasives_Native.None;
-    FStar_Compiler_Effect.op_Colon_Equals replaying_hints
-      FStar_Pervasives_Native.None
-let with_hints_db : 'a . Prims.string -> (unit -> 'a) -> 'a =
-  fun fname ->
-    fun f ->
-      initialize_hints_db fname false;
-      (let result = f () in finalize_hints_db fname; result)
-let (filter_using_facts_from :
-  FStar_TypeChecker_Env.env ->
-    FStar_SMTEncoding_Term.decl Prims.list ->
-      FStar_SMTEncoding_Term.decl Prims.list)
-  =
-  fun e ->
-    fun theory ->
-      let matches_fact_ids include_assumption_names a =
-        match a.FStar_SMTEncoding_Term.assumption_fact_ids with
-        | [] -> true
-        | uu___ ->
-            (FStar_Compiler_Effect.op_Bar_Greater
-               a.FStar_SMTEncoding_Term.assumption_fact_ids
-               (FStar_Compiler_Util.for_some
-                  (fun uu___1 ->
-                     match uu___1 with
-                     | FStar_SMTEncoding_Term.Name lid ->
-                         FStar_TypeChecker_Env.should_enc_lid e lid
-                     | uu___2 -> false)))
-              ||
-              (let uu___1 =
-                 FStar_Compiler_Util.smap_try_find include_assumption_names
-                   a.FStar_SMTEncoding_Term.assumption_name in
-               FStar_Compiler_Option.isSome uu___1) in
-      let theory_rev = FStar_Compiler_List.rev theory in
-      let pruned_theory =
-        let include_assumption_names =
-          FStar_Compiler_Util.smap_create (Prims.of_int (10000)) in
-        let keep_decl uu___ =
-          match uu___ with
-          | FStar_SMTEncoding_Term.Assume a ->
-              matches_fact_ids include_assumption_names a
-          | FStar_SMTEncoding_Term.RetainAssumptions names ->
-              (FStar_Compiler_List.iter
-                 (fun x ->
-                    FStar_Compiler_Util.smap_add include_assumption_names x
-                      true) names;
-               true)
-          | FStar_SMTEncoding_Term.Module uu___1 ->
-              failwith
-                "Solver.fs::keep_decl should never have been called with a Module decl"
-          | uu___1 -> true in
-        FStar_Compiler_List.fold_left
-          (fun out ->
-             fun d ->
-               match d with
-               | FStar_SMTEncoding_Term.Module (name, decls) ->
-                   let uu___ =
-                     FStar_Compiler_Effect.op_Bar_Greater decls
-                       (FStar_Compiler_List.filter keep_decl) in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___
-                     (fun decls1 ->
-                        (FStar_SMTEncoding_Term.Module (name, decls1)) :: out)
-               | uu___ ->
-                   let uu___1 = keep_decl d in
-                   if uu___1 then d :: out else out) [] theory_rev in
-      pruned_theory
-let rec (filter_assertions_with_stats :
-  FStar_TypeChecker_Env.env ->
-    FStar_SMTEncoding_Z3.unsat_core ->
-      FStar_SMTEncoding_Term.decl Prims.list ->
-        (FStar_SMTEncoding_Term.decl Prims.list * Prims.bool * Prims.int *
-          Prims.int))
-  =
-  fun e ->
-    fun core ->
-      fun theory ->
-        match core with
-        | FStar_Pervasives_Native.None ->
-            let uu___ = filter_using_facts_from e theory in
-            (uu___, false, Prims.int_zero, Prims.int_zero)
-        | FStar_Pervasives_Native.Some core1 ->
-            let theory_rev = FStar_Compiler_List.rev theory in
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_Compiler_Effect.op_Bar_Greater core1
-                          (FStar_String.concat ", ") in
-                      Prims.op_Hat "UNSAT CORE: " uu___5 in
-                    FStar_SMTEncoding_Term.Caption uu___4 in
-                  [uu___3] in
-                (uu___2, Prims.int_zero, Prims.int_zero) in
-              FStar_Compiler_List.fold_left
-                (fun uu___2 ->
-                   fun d ->
-                     match uu___2 with
-                     | (theory1, n_retained, n_pruned) ->
-                         (match d with
-                          | FStar_SMTEncoding_Term.Assume a ->
-                              if
-                                FStar_Compiler_List.contains
-                                  a.FStar_SMTEncoding_Term.assumption_name
-                                  core1
-                              then
-                                ((d :: theory1),
-                                  (n_retained + Prims.int_one), n_pruned)
-                              else
-                                if
-                                  FStar_Compiler_Util.starts_with
-                                    a.FStar_SMTEncoding_Term.assumption_name
-                                    "@"
-                                then ((d :: theory1), n_retained, n_pruned)
-                                else
-                                  (theory1, n_retained,
-                                    (n_pruned + Prims.int_one))
-                          | FStar_SMTEncoding_Term.Module (name, decls) ->
-                              let uu___3 =
-                                FStar_Compiler_Effect.op_Bar_Greater decls
-                                  (filter_assertions_with_stats e
-                                     (FStar_Pervasives_Native.Some core1)) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                (fun uu___4 ->
-                                   match uu___4 with
-                                   | (decls1, uu___5, r, p) ->
-                                       (((FStar_SMTEncoding_Term.Module
-                                            (name, decls1)) :: theory1),
-                                         (n_retained + r), (n_pruned + p)))
-                          | uu___3 -> ((d :: theory1), n_retained, n_pruned)))
-                uu___1 theory_rev in
-            (match uu___ with
-             | (theory', n_retained, n_pruned) ->
-                 (theory', true, n_retained, n_pruned))
-let (filter_assertions :
-  FStar_TypeChecker_Env.env ->
-    FStar_SMTEncoding_Z3.unsat_core ->
-      FStar_SMTEncoding_Term.decl Prims.list ->
-        (FStar_SMTEncoding_Term.decl Prims.list * Prims.bool))
-  =
-  fun e ->
-    fun core ->
-      fun theory ->
-        let uu___ = filter_assertions_with_stats e core theory in
-        match uu___ with | (theory1, b, uu___1, uu___2) -> (theory1, b)
-let (filter_facts_without_core :
-  FStar_TypeChecker_Env.env ->
-    FStar_SMTEncoding_Term.decl Prims.list ->
-      (FStar_SMTEncoding_Term.decl Prims.list * Prims.bool))
-  =
-  fun e -> fun x -> let uu___ = filter_using_facts_from e x in (uu___, false)
-type errors =
-  {
-  error_reason: Prims.string ;
-  error_fuel: Prims.int ;
-  error_ifuel: Prims.int ;
-  error_hint: Prims.string Prims.list FStar_Pervasives_Native.option ;
-  error_messages: FStar_Errors.error Prims.list }
-let (__proj__Mkerrors__item__error_reason : errors -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { error_reason; error_fuel; error_ifuel; error_hint; error_messages;_}
-        -> error_reason
-let (__proj__Mkerrors__item__error_fuel : errors -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { error_reason; error_fuel; error_ifuel; error_hint; error_messages;_}
-        -> error_fuel
-let (__proj__Mkerrors__item__error_ifuel : errors -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { error_reason; error_fuel; error_ifuel; error_hint; error_messages;_}
-        -> error_ifuel
-let (__proj__Mkerrors__item__error_hint :
-  errors -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { error_reason; error_fuel; error_ifuel; error_hint; error_messages;_}
-        -> error_hint
-let (__proj__Mkerrors__item__error_messages :
-  errors -> FStar_Errors.error Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { error_reason; error_fuel; error_ifuel; error_hint; error_messages;_}
-        -> error_messages
-let (error_to_short_string : errors -> Prims.string) =
-  fun err ->
-    let uu___ = FStar_Compiler_Util.string_of_int err.error_fuel in
-    let uu___1 = FStar_Compiler_Util.string_of_int err.error_ifuel in
-    FStar_Compiler_Util.format4 "%s (fuel=%s; ifuel=%s%s)" err.error_reason
-      uu___ uu___1
-      (if FStar_Compiler_Option.isSome err.error_hint
-       then "; with hint"
-       else "")
-let (error_to_is_timeout : errors -> Prims.string Prims.list) =
-  fun err ->
-    if FStar_Compiler_Util.ends_with err.error_reason "canceled"
-    then
-      let uu___ =
-        let uu___1 = FStar_Compiler_Util.string_of_int err.error_fuel in
-        let uu___2 = FStar_Compiler_Util.string_of_int err.error_ifuel in
-        FStar_Compiler_Util.format4 "timeout (fuel=%s; ifuel=%s; %s)"
-          err.error_reason uu___1 uu___2
-          (if FStar_Compiler_Option.isSome err.error_hint
-           then "with hint"
-           else "") in
-      [uu___]
-    else []
-type query_settings =
-  {
-  query_env: FStar_TypeChecker_Env.env ;
-  query_decl: FStar_SMTEncoding_Term.decl ;
-  query_name: Prims.string ;
-  query_index: Prims.int ;
-  query_range: FStar_Compiler_Range.range ;
-  query_fuel: Prims.int ;
-  query_ifuel: Prims.int ;
-  query_rlimit: Prims.int ;
-  query_hint: FStar_SMTEncoding_Z3.unsat_core ;
-  query_errors: errors Prims.list ;
-  query_all_labels: FStar_SMTEncoding_Term.error_labels ;
-  query_suffix: FStar_SMTEncoding_Term.decl Prims.list ;
-  query_hash: Prims.string FStar_Pervasives_Native.option ;
-  query_can_be_split_and_retried: Prims.bool ;
-  query_term: FStar_Syntax_Syntax.term }
-let (__proj__Mkquery_settings__item__query_env :
-  query_settings -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_env
-let (__proj__Mkquery_settings__item__query_decl :
-  query_settings -> FStar_SMTEncoding_Term.decl) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_decl
-let (__proj__Mkquery_settings__item__query_name :
-  query_settings -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_name
-let (__proj__Mkquery_settings__item__query_index :
-  query_settings -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_index
-let (__proj__Mkquery_settings__item__query_range :
-  query_settings -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_range
-let (__proj__Mkquery_settings__item__query_fuel :
-  query_settings -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_fuel
-let (__proj__Mkquery_settings__item__query_ifuel :
-  query_settings -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_ifuel
-let (__proj__Mkquery_settings__item__query_rlimit :
-  query_settings -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_rlimit
-let (__proj__Mkquery_settings__item__query_hint :
-  query_settings -> FStar_SMTEncoding_Z3.unsat_core) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_hint
-let (__proj__Mkquery_settings__item__query_errors :
-  query_settings -> errors Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_errors
-let (__proj__Mkquery_settings__item__query_all_labels :
-  query_settings -> FStar_SMTEncoding_Term.error_labels) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_all_labels
-let (__proj__Mkquery_settings__item__query_suffix :
-  query_settings -> FStar_SMTEncoding_Term.decl Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_suffix
-let (__proj__Mkquery_settings__item__query_hash :
-  query_settings -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_hash
-let (__proj__Mkquery_settings__item__query_can_be_split_and_retried :
-  query_settings -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} ->
-        query_can_be_split_and_retried
-let (__proj__Mkquery_settings__item__query_term :
-  query_settings -> FStar_Syntax_Syntax.term) =
-  fun projectee ->
-    match projectee with
-    | { query_env; query_decl; query_name; query_index; query_range;
-        query_fuel; query_ifuel; query_rlimit; query_hint; query_errors;
-        query_all_labels; query_suffix; query_hash;
-        query_can_be_split_and_retried; query_term;_} -> query_term
-let (with_fuel_and_diagnostics :
-  query_settings ->
-    FStar_SMTEncoding_Term.decl Prims.list ->
-      FStar_SMTEncoding_Term.decl Prims.list)
-  =
-  fun settings ->
-    fun label_assumptions ->
-      let n = settings.query_fuel in
-      let i = settings.query_ifuel in
-      let rlimit = settings.query_rlimit in
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Util.string_of_int n in
-            let uu___4 = FStar_Compiler_Util.string_of_int i in
-            FStar_Compiler_Util.format2 "<fuel='%s' ifuel='%s'>" uu___3
-              uu___4 in
-          FStar_SMTEncoding_Term.Caption uu___2 in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 = FStar_SMTEncoding_Util.mkApp ("MaxFuel", []) in
-                  let uu___8 = FStar_SMTEncoding_Term.n_fuel n in
-                  (uu___7, uu___8) in
-                FStar_SMTEncoding_Util.mkEq uu___6 in
-              (uu___5, FStar_Pervasives_Native.None, "@MaxFuel_assumption") in
-            FStar_SMTEncoding_Util.mkAssume uu___4 in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    let uu___9 =
-                      FStar_SMTEncoding_Util.mkApp ("MaxIFuel", []) in
-                    let uu___10 = FStar_SMTEncoding_Term.n_fuel i in
-                    (uu___9, uu___10) in
-                  FStar_SMTEncoding_Util.mkEq uu___8 in
-                (uu___7, FStar_Pervasives_Native.None,
-                  "@MaxIFuel_assumption") in
-              FStar_SMTEncoding_Util.mkAssume uu___6 in
-            [uu___5; settings.query_decl] in
-          uu___3 :: uu___4 in
-        uu___1 :: uu___2 in
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_Compiler_Util.string_of_int rlimit in
-                ("rlimit", uu___6) in
-              FStar_SMTEncoding_Term.SetOption uu___5 in
-            [uu___4;
-            FStar_SMTEncoding_Term.CheckSat;
-            FStar_SMTEncoding_Term.SetOption ("rlimit", "0");
-            FStar_SMTEncoding_Term.GetReasonUnknown;
-            FStar_SMTEncoding_Term.GetUnsatCore] in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                (FStar_Options.print_z3_statistics ()) ||
-                  (FStar_Options.query_stats ()) in
-              if uu___6 then [FStar_SMTEncoding_Term.GetStatistics] else [] in
-            FStar_Compiler_List.op_At uu___5 settings.query_suffix in
-          FStar_Compiler_List.op_At uu___3 uu___4 in
-        FStar_Compiler_List.op_At label_assumptions uu___2 in
-      FStar_Compiler_List.op_At uu___ uu___1
-let (used_hint : query_settings -> Prims.bool) =
-  fun s -> FStar_Compiler_Option.isSome s.query_hint
-let (get_hint_for :
-  Prims.string ->
-    Prims.int -> FStar_Compiler_Util.hint FStar_Pervasives_Native.option)
-  =
-  fun qname ->
-    fun qindex ->
-      let uu___ = FStar_Compiler_Effect.op_Bang replaying_hints in
-      match uu___ with
-      | FStar_Pervasives_Native.Some hints ->
-          FStar_Compiler_Util.find_map hints
-            (fun uu___1 ->
-               match uu___1 with
-               | FStar_Pervasives_Native.Some hint when
-                   (hint.FStar_Compiler_Util.hint_name = qname) &&
-                     (hint.FStar_Compiler_Util.hint_index = qindex)
-                   -> FStar_Pervasives_Native.Some hint
-               | uu___2 -> FStar_Pervasives_Native.None)
-      | uu___1 -> FStar_Pervasives_Native.None
-let (query_errors :
-  query_settings ->
-    FStar_SMTEncoding_Z3.z3result -> errors FStar_Pervasives_Native.option)
-  =
-  fun settings ->
-    fun z3result ->
-      match z3result.FStar_SMTEncoding_Z3.z3result_status with
-      | FStar_SMTEncoding_Z3.UNSAT uu___ -> FStar_Pervasives_Native.None
-      | uu___ ->
-          let uu___1 =
-            FStar_SMTEncoding_Z3.status_string_and_errors
-              z3result.FStar_SMTEncoding_Z3.z3result_status in
-          (match uu___1 with
-           | (msg, error_labels) ->
-               let err =
-                 let uu___2 =
-                   FStar_Compiler_List.map
-                     (fun uu___3 ->
-                        match uu___3 with
-                        | (uu___4, x, y) ->
-                            let uu___5 = FStar_Errors.get_ctx () in
-                            (FStar_Errors.Error_Z3SolverError, x, y, uu___5))
-                     error_labels in
-                 {
-                   error_reason = msg;
-                   error_fuel = (settings.query_fuel);
-                   error_ifuel = (settings.query_ifuel);
-                   error_hint = (settings.query_hint);
-                   error_messages = uu___2
-                 } in
-               FStar_Pervasives_Native.Some err)
-let (detail_hint_replay :
-  query_settings -> FStar_SMTEncoding_Z3.z3result -> unit) =
-  fun settings ->
-    fun z3result ->
-      let uu___ =
-        (used_hint settings) && (FStar_Options.detail_hint_replay ()) in
-      if uu___
-      then
-        match z3result.FStar_SMTEncoding_Z3.z3result_status with
-        | FStar_SMTEncoding_Z3.UNSAT uu___1 -> ()
-        | _failed ->
-            let ask_z3 label_assumptions =
-              let uu___1 =
-                with_fuel_and_diagnostics settings label_assumptions in
-              FStar_SMTEncoding_Z3.ask settings.query_range
-                (filter_assertions settings.query_env settings.query_hint)
-                settings.query_hash settings.query_all_labels uu___1
-                FStar_Pervasives_Native.None false in
-            FStar_SMTEncoding_ErrorReporting.detail_errors true
-              settings.query_env settings.query_all_labels ask_z3
-      else ()
-let (find_localized_errors :
-  errors Prims.list -> errors FStar_Pervasives_Native.option) =
-  fun errs ->
-    FStar_Compiler_Effect.op_Bar_Greater errs
-      (FStar_Compiler_List.tryFind
-         (fun err ->
-            match err.error_messages with | [] -> false | uu___ -> true))
-let (errors_to_report : query_settings -> FStar_Errors.error Prims.list) =
-  fun settings ->
-    let format_smt_error msg =
-      FStar_Compiler_Util.format1
-        "SMT solver says:\n\t%s;\n\tNote: 'canceled' or 'resource limits reached' means the SMT query timed out, so you might want to increase the rlimit;\n\t'incomplete quantifiers' means Z3 could not prove the query, so try to spell out your proof out in greater detail, increase fuel or ifuel\n\t'unknown' means Z3 provided no further reason for the proof failing"
-        msg in
-    let basic_errors =
-      let smt_error =
-        let uu___ = FStar_Options.query_stats () in
-        if uu___
-        then
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater settings.query_errors
-                  (FStar_Compiler_List.map error_to_short_string) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                (FStar_String.concat ";\n\t") in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 format_smt_error in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (fun uu___2 -> FStar_Pervasives.Inr uu___2)
-        else
-          (let uu___2 =
-             FStar_Compiler_List.fold_left
-               (fun uu___3 ->
-                  fun err ->
-                    match uu___3 with
-                    | (ic, cc, uc) ->
-                        let err1 =
-                          FStar_Compiler_Util.substring_from err.error_reason
-                            (FStar_String.length "unknown because ") in
-                        if
-                          ((FStar_Compiler_Util.starts_with err1 "canceled")
-                             ||
-                             (FStar_Compiler_Util.starts_with err1
-                                "(resource"))
-                            ||
-                            (FStar_Compiler_Util.starts_with err1 "timeout")
-                        then (ic, (cc + Prims.int_one), uc)
-                        else
-                          if
-                            FStar_Compiler_Util.starts_with err1
-                              "(incomplete"
-                          then ((ic + Prims.int_one), cc, uc)
-                          else (ic, cc, (uc + Prims.int_one)))
-               (Prims.int_zero, Prims.int_zero, Prims.int_zero)
-               settings.query_errors in
-           match uu___2 with
-           | (incomplete_count, canceled_count, unknown_count) ->
-               FStar_Compiler_Effect.op_Bar_Greater
-                 (match (incomplete_count, canceled_count, unknown_count)
-                  with
-                  | (uu___3, uu___4, uu___5) when
-                      ((uu___4 = Prims.int_zero) && (uu___5 = Prims.int_zero))
-                        && (incomplete_count > Prims.int_zero)
-                      ->
-                      "The SMT solver could not prove the query. Use --query_stats for more details."
-                  | (uu___3, uu___4, uu___5) when
-                      ((uu___3 = Prims.int_zero) && (uu___5 = Prims.int_zero))
-                        && (canceled_count > Prims.int_zero)
-                      ->
-                      "The SMT query timed out, you might want to increase the rlimit"
-                  | (uu___3, uu___4, uu___5) ->
-                      "Try with --query_stats to get more details")
-                 (fun uu___3 -> FStar_Pervasives.Inl uu___3)) in
-      let uu___ =
-        let uu___1 = find_localized_errors settings.query_errors in
-        (uu___1, (settings.query_all_labels)) in
-      match uu___ with
-      | (FStar_Pervasives_Native.Some err, uu___1) ->
-          FStar_TypeChecker_Err.errors_smt_detail settings.query_env
-            err.error_messages smt_error
-      | (FStar_Pervasives_Native.None, (uu___1, msg, rng)::[]) ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Errors.get_ctx () in
-              (FStar_Errors.Error_Z3SolverError, msg, rng, uu___4) in
-            [uu___3] in
-          FStar_TypeChecker_Err.errors_smt_detail settings.query_env uu___2
-            (FStar_Pervasives.Inl "")
-      | (FStar_Pervasives_Native.None, uu___1) ->
-          let uu___2 =
-            settings.query_can_be_split_and_retried &&
-              (let uu___3 = FStar_Options.split_queries () in
-               Prims.op_Negation uu___3) in
-          if uu___2
-          then FStar_Compiler_Effect.raise SplitQueryAndRetry
-          else
-            (let l = FStar_Compiler_List.length settings.query_all_labels in
-             let labels =
-               if l = Prims.int_zero
-               then
-                 let dummy_fv =
-                   FStar_SMTEncoding_Term.mk_fv
-                     ("", FStar_SMTEncoding_Term.dummy_sort) in
-                 let msg =
-                   let uu___4 =
-                     FStar_Syntax_Print.term_to_string settings.query_term in
-                   FStar_Compiler_Util.format1
-                     "Failed to prove the following goal, although it appears to be trivial: %s"
-                     uu___4 in
-                 let range =
-                   FStar_TypeChecker_Env.get_range settings.query_env in
-                 [(dummy_fv, msg, range)]
-               else
-                 if l > Prims.int_one
-                 then
-                   ((let uu___6 =
-                       FStar_TypeChecker_Env.get_range settings.query_env in
-                     FStar_TypeChecker_Err.log_issue settings.query_env
-                       uu___6
-                       (FStar_Errors.Warning_SplitAndRetryQueries,
-                         "The verification condition was to be split into several atomic sub-goals, but this query has multiple sub-goals---the error report may be inaccurate"));
-                    settings.query_all_labels)
-                 else settings.query_all_labels in
-             FStar_Compiler_Effect.op_Bar_Greater labels
-               (FStar_Compiler_List.collect
-                  (fun uu___4 ->
-                     match uu___4 with
-                     | (uu___5, msg, rng) ->
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 = FStar_Errors.get_ctx () in
-                             (FStar_Errors.Error_Z3SolverError, msg, rng,
-                               uu___8) in
-                           [uu___7] in
-                         FStar_TypeChecker_Err.errors_smt_detail
-                           settings.query_env uu___6
-                           (FStar_Pervasives.Inl "")))) in
-    (let uu___ = FStar_Options.detail_errors () in
-     if uu___
-     then
-       let initial_fuel =
-         let uu___1 = FStar_Options.initial_fuel () in
-         let uu___2 = FStar_Options.initial_ifuel () in
-         {
-           query_env = (settings.query_env);
-           query_decl = (settings.query_decl);
-           query_name = (settings.query_name);
-           query_index = (settings.query_index);
-           query_range = (settings.query_range);
-           query_fuel = uu___1;
-           query_ifuel = uu___2;
-           query_rlimit = (settings.query_rlimit);
-           query_hint = FStar_Pervasives_Native.None;
-           query_errors = (settings.query_errors);
-           query_all_labels = (settings.query_all_labels);
-           query_suffix = (settings.query_suffix);
-           query_hash = (settings.query_hash);
-           query_can_be_split_and_retried =
-             (settings.query_can_be_split_and_retried);
-           query_term = (settings.query_term)
-         } in
-       let ask_z3 label_assumptions =
-         let uu___1 =
-           with_fuel_and_diagnostics initial_fuel label_assumptions in
-         FStar_SMTEncoding_Z3.ask settings.query_range
-           (filter_facts_without_core settings.query_env) settings.query_hash
-           settings.query_all_labels uu___1 FStar_Pervasives_Native.None
-           false in
-       FStar_SMTEncoding_ErrorReporting.detail_errors false
-         settings.query_env settings.query_all_labels ask_z3
-     else ());
-    basic_errors
-let (report_errors : query_settings -> unit) =
-  fun qry_settings ->
-    let uu___ = errors_to_report qry_settings in
-    FStar_Errors.add_errors uu___
-let (query_info : query_settings -> FStar_SMTEncoding_Z3.z3result -> unit) =
-  fun settings ->
-    fun z3result ->
-      let process_unsat_core core =
-        let accumulator uu___ =
-          let r = FStar_Compiler_Util.mk_ref [] in
-          let uu___1 =
-            let module_names = FStar_Compiler_Util.mk_ref [] in
-            ((fun m ->
-                let ms = FStar_Compiler_Effect.op_Bang module_names in
-                if FStar_Compiler_List.contains m ms
-                then ()
-                else
-                  FStar_Compiler_Effect.op_Colon_Equals module_names (m ::
-                    ms)),
-              (fun uu___2 ->
-                 let uu___3 = FStar_Compiler_Effect.op_Bang module_names in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                   (FStar_Compiler_Util.sort_with FStar_String.compare))) in
-          match uu___1 with | (add, get) -> (add, get) in
-        let uu___ = accumulator () in
-        match uu___ with
-        | (add_module_name, get_module_names) ->
-            let uu___1 = accumulator () in
-            (match uu___1 with
-             | (add_discarded_name, get_discarded_names) ->
-                 let parse_axiom_name s =
-                   let chars = FStar_String.list_of_string s in
-                   let first_upper_index =
-                     FStar_Compiler_Util.try_find_index
-                       FStar_Compiler_Util.is_upper chars in
-                   match first_upper_index with
-                   | FStar_Pervasives_Native.None ->
-                       (add_discarded_name s; [])
-                   | FStar_Pervasives_Native.Some first_upper_index1 ->
-                       let name_and_suffix =
-                         FStar_Compiler_Util.substring_from s
-                           first_upper_index1 in
-                       let components =
-                         FStar_String.split [46] name_and_suffix in
-                       let excluded_suffixes =
-                         ["fuel_instrumented";
-                         "_pretyping";
-                         "_Tm_refine";
-                         "_Tm_abs";
-                         "@";
-                         "_interpretation_Tm_arrow";
-                         "MaxFuel_assumption";
-                         "MaxIFuel_assumption"] in
-                       let exclude_suffix s1 =
-                         let s2 = FStar_Compiler_Util.trim_string s1 in
-                         let sopt =
-                           FStar_Compiler_Util.find_map excluded_suffixes
-                             (fun sfx ->
-                                if FStar_Compiler_Util.contains s2 sfx
-                                then
-                                  let uu___2 =
-                                    FStar_Compiler_List.hd
-                                      (FStar_Compiler_Util.split s2 sfx) in
-                                  FStar_Pervasives_Native.Some uu___2
-                                else FStar_Pervasives_Native.None) in
-                         match sopt with
-                         | FStar_Pervasives_Native.None ->
-                             if s2 = "" then [] else [s2]
-                         | FStar_Pervasives_Native.Some s3 ->
-                             if s3 = "" then [] else [s3] in
-                       let components1 =
-                         match components with
-                         | [] -> []
-                         | uu___2 ->
-                             let uu___3 =
-                               FStar_Compiler_Util.prefix components in
-                             (match uu___3 with
-                              | (module_name, last) ->
-                                  let components2 =
-                                    let uu___4 = exclude_suffix last in
-                                    FStar_Compiler_List.op_At module_name
-                                      uu___4 in
-                                  ((match components2 with
-                                    | [] -> ()
-                                    | uu___5::[] -> ()
-                                    | uu___5 ->
-                                        add_module_name
-                                          (FStar_String.concat "."
-                                             module_name));
-                                   components2)) in
-                       if components1 = []
-                       then (add_discarded_name s; [])
-                       else
-                         (let uu___3 =
-                            FStar_Compiler_Effect.op_Bar_Greater components1
-                              (FStar_String.concat ".") in
-                          [uu___3]) in
-                 (match core with
-                  | FStar_Pervasives_Native.None ->
-                      FStar_Compiler_Util.print_string "no unsat core\n"
-                  | FStar_Pervasives_Native.Some core1 ->
-                      let core2 =
-                        FStar_Compiler_List.collect parse_axiom_name core1 in
-                      ((let uu___3 =
-                          let uu___4 = get_module_names () in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___4
-                            (FStar_String.concat "\nZ3 Proof Stats:\t") in
-                        FStar_Compiler_Util.print1
-                          "Z3 Proof Stats: Modules relevant to this proof:\nZ3 Proof Stats:\t%s\n"
-                          uu___3);
-                       FStar_Compiler_Util.print1
-                         "Z3 Proof Stats (Detail 1): Specifically:\nZ3 Proof Stats (Detail 1):\t%s\n"
-                         (FStar_String.concat
-                            "\nZ3 Proof Stats (Detail 1):\t" core2);
-                       (let uu___4 =
-                          let uu___5 = get_discarded_names () in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            (FStar_String.concat ", ") in
-                        FStar_Compiler_Util.print1
-                          "Z3 Proof Stats (Detail 2): Note, this report ignored the following names in the context: %s\n"
-                          uu___4)))) in
-      let uu___ =
-        (FStar_Options.hint_info ()) || (FStar_Options.query_stats ()) in
-      if uu___
-      then
-        let uu___1 =
-          FStar_SMTEncoding_Z3.status_string_and_errors
-            z3result.FStar_SMTEncoding_Z3.z3result_status in
-        match uu___1 with
-        | (status_string, errs) ->
-            let at_log_file =
-              match z3result.FStar_SMTEncoding_Z3.z3result_log_file with
-              | FStar_Pervasives_Native.None -> ""
-              | FStar_Pervasives_Native.Some s -> Prims.op_Hat "@" s in
-            let uu___2 =
-              match z3result.FStar_SMTEncoding_Z3.z3result_status with
-              | FStar_SMTEncoding_Z3.UNSAT core -> ("succeeded", core)
-              | uu___3 ->
-                  ((Prims.op_Hat "failed {reason-unknown="
-                      (Prims.op_Hat status_string "}")),
-                    FStar_Pervasives_Native.None) in
-            (match uu___2 with
-             | (tag, core) ->
-                 let range =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_Range.string_of_range
-                         settings.query_range in
-                     Prims.op_Hat uu___4 (Prims.op_Hat at_log_file ")") in
-                   Prims.op_Hat "(" uu___3 in
-                 let used_hint_tag =
-                   if used_hint settings then " (with hint)" else "" in
-                 let stats =
-                   let uu___3 = FStar_Options.query_stats () in
-                   if uu___3
-                   then
-                     let f k v a =
-                       Prims.op_Hat a
-                         (Prims.op_Hat k
-                            (Prims.op_Hat "=" (Prims.op_Hat v " "))) in
-                     let str =
-                       FStar_Compiler_Util.smap_fold
-                         z3result.FStar_SMTEncoding_Z3.z3result_statistics f
-                         "statistics={" in
-                     let uu___4 =
-                       FStar_Compiler_Util.substring str Prims.int_zero
-                         ((FStar_String.length str) - Prims.int_one) in
-                     Prims.op_Hat uu___4 "}"
-                   else "" in
-                 ((let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 =
-                           FStar_Compiler_Util.string_of_int
-                             settings.query_index in
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               let uu___11 =
-                                 FStar_Compiler_Util.string_of_int
-                                   z3result.FStar_SMTEncoding_Z3.z3result_time in
-                               let uu___12 =
-                                 let uu___13 =
-                                   FStar_Compiler_Util.string_of_int
-                                     settings.query_fuel in
-                                 let uu___14 =
-                                   let uu___15 =
-                                     FStar_Compiler_Util.string_of_int
-                                       settings.query_ifuel in
-                                   let uu___16 =
-                                     let uu___17 =
-                                       FStar_Compiler_Util.string_of_int
-                                         settings.query_rlimit in
-                                     [uu___17; stats] in
-                                   uu___15 :: uu___16 in
-                                 uu___13 :: uu___14 in
-                               uu___11 :: uu___12 in
-                             used_hint_tag :: uu___10 in
-                           tag :: uu___9 in
-                         uu___7 :: uu___8 in
-                       (settings.query_name) :: uu___6 in
-                     range :: uu___5 in
-                   FStar_Compiler_Util.print
-                     "%s\tQuery-stats (%s, %s)\t%s%s in %s milliseconds with fuel %s and ifuel %s and rlimit %s %s\n"
-                     uu___4);
-                  (let uu___5 = FStar_Options.print_z3_statistics () in
-                   if uu___5 then process_unsat_core core else ());
-                  FStar_Compiler_Effect.op_Bar_Greater errs
-                    (FStar_Compiler_List.iter
-                       (fun uu___5 ->
-                          match uu___5 with
-                          | (uu___6, msg, range1) ->
-                              let tag1 =
-                                if used_hint settings
-                                then "(Hint-replay failed): "
-                                else "" in
-                              FStar_Errors.log_issue range1
-                                (FStar_Errors.Warning_HitReplayFailed,
-                                  (Prims.op_Hat tag1 msg))))))
-      else ()
-let (store_hint : FStar_Compiler_Util.hint -> unit) =
-  fun hint ->
-    let uu___ = FStar_Compiler_Effect.op_Bang recorded_hints in
-    match uu___ with
-    | FStar_Pervasives_Native.Some l ->
-        FStar_Compiler_Effect.op_Colon_Equals recorded_hints
-          (FStar_Pervasives_Native.Some
-             (FStar_Compiler_List.op_At l [FStar_Pervasives_Native.Some hint]))
-    | uu___1 -> ()
-let (record_hint : query_settings -> FStar_SMTEncoding_Z3.z3result -> unit) =
-  fun settings ->
-    fun z3result ->
-      let uu___ =
-        let uu___1 = FStar_Options.record_hints () in
-        Prims.op_Negation uu___1 in
-      if uu___
-      then ()
-      else
-        (let mk_hint core =
-           {
-             FStar_Compiler_Util.hint_name = (settings.query_name);
-             FStar_Compiler_Util.hint_index = (settings.query_index);
-             FStar_Compiler_Util.fuel = (settings.query_fuel);
-             FStar_Compiler_Util.ifuel = (settings.query_ifuel);
-             FStar_Compiler_Util.unsat_core = core;
-             FStar_Compiler_Util.query_elapsed_time = Prims.int_zero;
-             FStar_Compiler_Util.hash =
-               (match z3result.FStar_SMTEncoding_Z3.z3result_status with
-                | FStar_SMTEncoding_Z3.UNSAT core1 ->
-                    z3result.FStar_SMTEncoding_Z3.z3result_query_hash
-                | uu___2 -> FStar_Pervasives_Native.None)
-           } in
-         match z3result.FStar_SMTEncoding_Z3.z3result_status with
-         | FStar_SMTEncoding_Z3.UNSAT (FStar_Pervasives_Native.None) ->
-             let uu___2 =
-               let uu___3 =
-                 get_hint_for settings.query_name settings.query_index in
-               FStar_Compiler_Option.get uu___3 in
-             store_hint uu___2
-         | FStar_SMTEncoding_Z3.UNSAT unsat_core ->
-             if used_hint settings
-             then store_hint (mk_hint settings.query_hint)
-             else store_hint (mk_hint unsat_core)
-         | uu___2 -> ())
-let (process_result :
-  query_settings ->
-    FStar_SMTEncoding_Z3.z3result -> errors FStar_Pervasives_Native.option)
-  =
-  fun settings ->
-    fun result ->
-      let errs = query_errors settings result in
-      query_info settings result;
-      record_hint settings result;
-      detail_hint_replay settings result;
-      errs
-let (fold_queries :
-  query_settings Prims.list ->
-    (query_settings -> FStar_SMTEncoding_Z3.z3result) ->
-      (query_settings ->
-         FStar_SMTEncoding_Z3.z3result ->
-           errors FStar_Pervasives_Native.option)
-        -> (errors Prims.list, query_settings) FStar_Pervasives.either)
-  =
-  fun qs ->
-    fun ask ->
-      fun f ->
-        let rec aux acc qs1 =
-          match qs1 with
-          | [] -> FStar_Pervasives.Inl acc
-          | q::qs2 ->
-              let res = ask q in
-              let uu___ = f q res in
-              (match uu___ with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives.Inr q
-               | FStar_Pervasives_Native.Some errs -> aux (errs :: acc) qs2) in
-        aux [] qs
-let (full_query_id : query_settings -> Prims.string) =
-  fun settings ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = FStar_Compiler_Util.string_of_int settings.query_index in
-          Prims.op_Hat uu___3 ")" in
-        Prims.op_Hat ", " uu___2 in
-      Prims.op_Hat settings.query_name uu___1 in
-    Prims.op_Hat "(" uu___
-let collect : 'a . 'a Prims.list -> ('a * Prims.int) Prims.list =
-  fun l ->
-    let acc = [] in
-    let rec add_one acc1 x =
-      match acc1 with
-      | [] -> [(x, Prims.int_one)]
-      | (h, n)::t ->
-          if h = x
-          then (h, (n + Prims.int_one)) :: t
-          else (let uu___1 = add_one t x in (h, n) :: uu___1) in
-    FStar_Compiler_List.fold_left add_one acc l
-let (ask_and_report_errors :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_SMTEncoding_Term.error_labels ->
-        FStar_SMTEncoding_Term.decl Prims.list ->
-          FStar_SMTEncoding_Term.decl ->
-            FStar_Syntax_Syntax.term ->
-              FStar_SMTEncoding_Term.decl Prims.list -> unit)
-  =
-  fun is_being_retried ->
-    fun env ->
-      fun all_labels ->
-        fun prefix ->
-          fun query ->
-            fun query_term ->
-              fun suffix ->
-                FStar_SMTEncoding_Z3.giveZ3 prefix;
-                (let uu___1 =
-                   let uu___2 =
-                     match env.FStar_TypeChecker_Env.qtbl_name_and_index with
-                     | (uu___3, FStar_Pervasives_Native.None) ->
-                         failwith "No query name set!"
-                     | (uu___3, FStar_Pervasives_Native.Some (q, n)) ->
-                         let uu___4 = FStar_Ident.string_of_lid q in
-                         (uu___4, n) in
-                   match uu___2 with
-                   | (qname, index) ->
-                       let rlimit =
-                         let uu___3 = FStar_Options.z3_rlimit_factor () in
-                         let uu___4 =
-                           let uu___5 = FStar_Options.z3_rlimit () in
-                           uu___5 * (Prims.parse_int "544656") in
-                         uu___3 * uu___4 in
-                       let next_hint = get_hint_for qname index in
-                       let default_settings =
-                         let uu___3 = FStar_TypeChecker_Env.get_range env in
-                         let uu___4 = FStar_Options.initial_fuel () in
-                         let uu___5 = FStar_Options.initial_ifuel () in
-                         {
-                           query_env = env;
-                           query_decl = query;
-                           query_name = qname;
-                           query_index = index;
-                           query_range = uu___3;
-                           query_fuel = uu___4;
-                           query_ifuel = uu___5;
-                           query_rlimit = rlimit;
-                           query_hint = FStar_Pervasives_Native.None;
-                           query_errors = [];
-                           query_all_labels = all_labels;
-                           query_suffix = suffix;
-                           query_hash =
-                             (match next_hint with
-                              | FStar_Pervasives_Native.None ->
-                                  FStar_Pervasives_Native.None
-                              | FStar_Pervasives_Native.Some
-                                  { FStar_Compiler_Util.hint_name = uu___6;
-                                    FStar_Compiler_Util.hint_index = uu___7;
-                                    FStar_Compiler_Util.fuel = uu___8;
-                                    FStar_Compiler_Util.ifuel = uu___9;
-                                    FStar_Compiler_Util.unsat_core = uu___10;
-                                    FStar_Compiler_Util.query_elapsed_time =
-                                      uu___11;
-                                    FStar_Compiler_Util.hash = h;_}
-                                  -> h);
-                           query_can_be_split_and_retried =
-                             (Prims.op_Negation is_being_retried);
-                           query_term
-                         } in
-                       (default_settings, next_hint) in
-                 match uu___1 with
-                 | (default_settings, next_hint) ->
-                     let use_hints_setting =
-                       let uu___2 =
-                         (FStar_Options.use_hints ()) &&
-                           (FStar_Compiler_Effect.op_Bar_Greater next_hint
-                              FStar_Compiler_Util.is_some) in
-                       if uu___2
-                       then
-                         let uu___3 =
-                           FStar_Compiler_Effect.op_Bar_Greater next_hint
-                             FStar_Compiler_Util.must in
-                         match uu___3 with
-                         | { FStar_Compiler_Util.hint_name = uu___4;
-                             FStar_Compiler_Util.hint_index = uu___5;
-                             FStar_Compiler_Util.fuel = i;
-                             FStar_Compiler_Util.ifuel = j;
-                             FStar_Compiler_Util.unsat_core =
-                               FStar_Pervasives_Native.Some core;
-                             FStar_Compiler_Util.query_elapsed_time = uu___6;
-                             FStar_Compiler_Util.hash = h;_} ->
-                             [{
-                                query_env = (default_settings.query_env);
-                                query_decl = (default_settings.query_decl);
-                                query_name = (default_settings.query_name);
-                                query_index = (default_settings.query_index);
-                                query_range = (default_settings.query_range);
-                                query_fuel = i;
-                                query_ifuel = j;
-                                query_rlimit =
-                                  (default_settings.query_rlimit);
-                                query_hint =
-                                  (FStar_Pervasives_Native.Some core);
-                                query_errors =
-                                  (default_settings.query_errors);
-                                query_all_labels =
-                                  (default_settings.query_all_labels);
-                                query_suffix =
-                                  (default_settings.query_suffix);
-                                query_hash = (default_settings.query_hash);
-                                query_can_be_split_and_retried =
-                                  (default_settings.query_can_be_split_and_retried);
-                                query_term = (default_settings.query_term)
-                              }]
-                       else [] in
-                     let initial_fuel_max_ifuel =
-                       let uu___2 =
-                         let uu___3 = FStar_Options.max_ifuel () in
-                         let uu___4 = FStar_Options.initial_ifuel () in
-                         uu___3 > uu___4 in
-                       if uu___2
-                       then
-                         let uu___3 =
-                           let uu___4 = FStar_Options.max_ifuel () in
-                           {
-                             query_env = (default_settings.query_env);
-                             query_decl = (default_settings.query_decl);
-                             query_name = (default_settings.query_name);
-                             query_index = (default_settings.query_index);
-                             query_range = (default_settings.query_range);
-                             query_fuel = (default_settings.query_fuel);
-                             query_ifuel = uu___4;
-                             query_rlimit = (default_settings.query_rlimit);
-                             query_hint = (default_settings.query_hint);
-                             query_errors = (default_settings.query_errors);
-                             query_all_labels =
-                               (default_settings.query_all_labels);
-                             query_suffix = (default_settings.query_suffix);
-                             query_hash = (default_settings.query_hash);
-                             query_can_be_split_and_retried =
-                               (default_settings.query_can_be_split_and_retried);
-                             query_term = (default_settings.query_term)
-                           } in
-                         [uu___3]
-                       else [] in
-                     let half_max_fuel_max_ifuel =
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 = FStar_Options.max_fuel () in
-                           uu___4 / (Prims.of_int (2)) in
-                         let uu___4 = FStar_Options.initial_fuel () in
-                         uu___3 > uu___4 in
-                       if uu___2
-                       then
-                         let uu___3 =
-                           let uu___4 =
-                             let uu___5 = FStar_Options.max_fuel () in
-                             uu___5 / (Prims.of_int (2)) in
-                           let uu___5 = FStar_Options.max_ifuel () in
-                           {
-                             query_env = (default_settings.query_env);
-                             query_decl = (default_settings.query_decl);
-                             query_name = (default_settings.query_name);
-                             query_index = (default_settings.query_index);
-                             query_range = (default_settings.query_range);
-                             query_fuel = uu___4;
-                             query_ifuel = uu___5;
-                             query_rlimit = (default_settings.query_rlimit);
-                             query_hint = (default_settings.query_hint);
-                             query_errors = (default_settings.query_errors);
-                             query_all_labels =
-                               (default_settings.query_all_labels);
-                             query_suffix = (default_settings.query_suffix);
-                             query_hash = (default_settings.query_hash);
-                             query_can_be_split_and_retried =
-                               (default_settings.query_can_be_split_and_retried);
-                             query_term = (default_settings.query_term)
-                           } in
-                         [uu___3]
-                       else [] in
-                     let max_fuel_max_ifuel =
-                       let uu___2 =
-                         (let uu___3 = FStar_Options.max_fuel () in
-                          let uu___4 = FStar_Options.initial_fuel () in
-                          uu___3 > uu___4) &&
-                           (let uu___3 = FStar_Options.max_ifuel () in
-                            let uu___4 = FStar_Options.initial_ifuel () in
-                            uu___3 >= uu___4) in
-                       if uu___2
-                       then
-                         let uu___3 =
-                           let uu___4 = FStar_Options.max_fuel () in
-                           let uu___5 = FStar_Options.max_ifuel () in
-                           {
-                             query_env = (default_settings.query_env);
-                             query_decl = (default_settings.query_decl);
-                             query_name = (default_settings.query_name);
-                             query_index = (default_settings.query_index);
-                             query_range = (default_settings.query_range);
-                             query_fuel = uu___4;
-                             query_ifuel = uu___5;
-                             query_rlimit = (default_settings.query_rlimit);
-                             query_hint = (default_settings.query_hint);
-                             query_errors = (default_settings.query_errors);
-                             query_all_labels =
-                               (default_settings.query_all_labels);
-                             query_suffix = (default_settings.query_suffix);
-                             query_hash = (default_settings.query_hash);
-                             query_can_be_split_and_retried =
-                               (default_settings.query_can_be_split_and_retried);
-                             query_term = (default_settings.query_term)
-                           } in
-                         [uu___3]
-                       else [] in
-                     let all_configs =
-                       if is_being_retried
-                       then [default_settings]
-                       else
-                         FStar_Compiler_List.op_At use_hints_setting
-                           (FStar_Compiler_List.op_At [default_settings]
-                              (FStar_Compiler_List.op_At
-                                 initial_fuel_max_ifuel
-                                 (FStar_Compiler_List.op_At
-                                    half_max_fuel_max_ifuel
-                                    max_fuel_max_ifuel))) in
-                     let check_one_config config =
-                       (let uu___3 = FStar_Options.z3_refresh () in
-                        if uu___3
-                        then FStar_SMTEncoding_Z3.refresh ()
-                        else ());
-                       (let uu___3 = with_fuel_and_diagnostics config [] in
-                        let uu___4 =
-                          let uu___5 = FStar_SMTEncoding_Z3.mk_fresh_scope () in
-                          FStar_Pervasives_Native.Some uu___5 in
-                        FStar_SMTEncoding_Z3.ask config.query_range
-                          (filter_assertions config.query_env
-                             config.query_hint) config.query_hash
-                          config.query_all_labels uu___3 uu___4
-                          (used_hint config)) in
-                     let check_all_configs configs =
-                       fold_queries configs check_one_config process_result in
-                     let quake_and_check_all_configs configs =
-                       let lo = FStar_Options.quake_lo () in
-                       let hi = FStar_Options.quake_hi () in
-                       let seed = FStar_Options.z3_seed () in
-                       let name = full_query_id default_settings in
-                       let quaking =
-                         (hi > Prims.int_one) &&
-                           (let uu___2 = FStar_Options.retry () in
-                            Prims.op_Negation uu___2) in
-                       let quaking_or_retrying = hi > Prims.int_one in
-                       let hi1 =
-                         if hi < Prims.int_one then Prims.int_one else hi in
-                       let lo1 =
-                         if lo < Prims.int_one
-                         then Prims.int_one
-                         else if lo > hi1 then hi1 else lo in
-                       let run_one seed1 =
-                         let uu___2 = FStar_Options.z3_refresh () in
-                         if uu___2
-                         then
-                           FStar_Options.with_saved_options
-                             (fun uu___3 ->
-                                FStar_Options.set_option "z3seed"
-                                  (FStar_Options.Int seed1);
-                                check_all_configs configs)
-                         else check_all_configs configs in
-                       let rec fold_nat' f acc lo2 hi2 =
-                         if lo2 > hi2
-                         then acc
-                         else
-                           (let uu___3 = f acc lo2 in
-                            fold_nat' f uu___3 (lo2 + Prims.int_one) hi2) in
-                       let best_fuel =
-                         FStar_Compiler_Util.mk_ref
-                           FStar_Pervasives_Native.None in
-                       let best_ifuel =
-                         FStar_Compiler_Util.mk_ref
-                           FStar_Pervasives_Native.None in
-                       let maybe_improve r n =
-                         let uu___2 = FStar_Compiler_Effect.op_Bang r in
-                         match uu___2 with
-                         | FStar_Pervasives_Native.None ->
-                             FStar_Compiler_Effect.op_Colon_Equals r
-                               (FStar_Pervasives_Native.Some n)
-                         | FStar_Pervasives_Native.Some m ->
-                             if n < m
-                             then
-                               FStar_Compiler_Effect.op_Colon_Equals r
-                                 (FStar_Pervasives_Native.Some n)
-                             else () in
-                       let uu___2 =
-                         fold_nat'
-                           (fun uu___3 ->
-                              fun n ->
-                                match uu___3 with
-                                | (nsucc, nfail, rs) ->
-                                    let uu___4 =
-                                      (let uu___5 =
-                                         FStar_Options.quake_keep () in
-                                       Prims.op_Negation uu___5) &&
-                                        ((nsucc >= lo1) ||
-                                           (nfail > (hi1 - lo1))) in
-                                    if uu___4
-                                    then (nsucc, nfail, rs)
-                                    else
-                                      ((let uu___7 =
-                                          (quaking_or_retrying &&
-                                             ((FStar_Options.interactive ())
-                                                ||
-                                                (FStar_Options.debug_any ())))
-                                            && (n > Prims.int_zero) in
-                                        if uu___7
-                                        then
-                                          let uu___8 =
-                                            if quaking
-                                            then
-                                              let uu___9 =
-                                                FStar_Compiler_Util.string_of_int
-                                                  nsucc in
-                                              FStar_Compiler_Util.format1
-                                                "succeeded %s times and "
-                                                uu___9
-                                            else "" in
-                                          let uu___9 =
-                                            if quaking
-                                            then
-                                              FStar_Compiler_Util.string_of_int
-                                                nfail
-                                            else
-                                              (let uu___11 =
-                                                 FStar_Compiler_Util.string_of_int
-                                                   nfail in
-                                               Prims.op_Hat uu___11 " times") in
-                                          let uu___10 =
-                                            FStar_Compiler_Util.string_of_int
-                                              (hi1 - n) in
-                                          FStar_Compiler_Util.print5
-                                            "%s: so far query %s %sfailed %s (%s runs remain)\n"
-                                            (if quaking
-                                             then "Quake"
-                                             else "Retry") name uu___8 uu___9
-                                            uu___10
-                                        else ());
-                                       (let r = run_one (seed + n) in
-                                        let uu___7 =
-                                          match r with
-                                          | FStar_Pervasives.Inr cfg ->
-                                              (maybe_improve best_fuel
-                                                 cfg.query_fuel;
-                                               maybe_improve best_ifuel
-                                                 cfg.query_ifuel;
-                                               ((nsucc + Prims.int_one),
-                                                 nfail))
-                                          | uu___8 ->
-                                              (nsucc,
-                                                (nfail + Prims.int_one)) in
-                                        match uu___7 with
-                                        | (nsucc1, nfail1) ->
-                                            (nsucc1, nfail1, (r :: rs)))))
-                           (Prims.int_zero, Prims.int_zero, [])
-                           Prims.int_zero (hi1 - Prims.int_one) in
-                       match uu___2 with
-                       | (nsuccess, nfailures, rs) ->
-                           let total_ran = nsuccess + nfailures in
-                           (if quaking
-                            then
-                              (let fuel_msg =
-                                 let uu___4 =
-                                   let uu___5 =
-                                     FStar_Compiler_Effect.op_Bang best_fuel in
-                                   let uu___6 =
-                                     FStar_Compiler_Effect.op_Bang best_ifuel in
-                                   (uu___5, uu___6) in
-                                 match uu___4 with
-                                 | (FStar_Pervasives_Native.Some f,
-                                    FStar_Pervasives_Native.Some i) ->
-                                     let uu___5 =
-                                       FStar_Compiler_Util.string_of_int f in
-                                     let uu___6 =
-                                       FStar_Compiler_Util.string_of_int i in
-                                     FStar_Compiler_Util.format2
-                                       " (best fuel=%s, best ifuel=%s)"
-                                       uu___5 uu___6
-                                 | (uu___5, uu___6) -> "" in
-                               let uu___4 =
-                                 FStar_Compiler_Util.string_of_int nsuccess in
-                               let uu___5 =
-                                 FStar_Compiler_Util.string_of_int total_ran in
-                               FStar_Compiler_Util.print5
-                                 "Quake: query %s succeeded %s/%s times%s%s\n"
-                                 name uu___4 uu___5
-                                 (if total_ran < hi1
-                                  then " (early finish)"
-                                  else "") fuel_msg)
-                            else ();
-                            if nsuccess < lo1
-                            then
-                              (let all_errs =
-                                 FStar_Compiler_List.concatMap
-                                   (fun uu___4 ->
-                                      match uu___4 with
-                                      | FStar_Pervasives.Inr uu___5 -> []
-                                      | FStar_Pervasives.Inl es -> [es]) rs in
-                               let uu___4 =
-                                 quaking_or_retrying &&
-                                   (let uu___5 = FStar_Options.query_stats () in
-                                    Prims.op_Negation uu___5) in
-                               if uu___4
-                               then
-                                 let errors_to_report1 errs =
-                                   errors_to_report
-                                     {
-                                       query_env =
-                                         (default_settings.query_env);
-                                       query_decl =
-                                         (default_settings.query_decl);
-                                       query_name =
-                                         (default_settings.query_name);
-                                       query_index =
-                                         (default_settings.query_index);
-                                       query_range =
-                                         (default_settings.query_range);
-                                       query_fuel =
-                                         (default_settings.query_fuel);
-                                       query_ifuel =
-                                         (default_settings.query_ifuel);
-                                       query_rlimit =
-                                         (default_settings.query_rlimit);
-                                       query_hint =
-                                         (default_settings.query_hint);
-                                       query_errors = errs;
-                                       query_all_labels =
-                                         (default_settings.query_all_labels);
-                                       query_suffix =
-                                         (default_settings.query_suffix);
-                                       query_hash =
-                                         (default_settings.query_hash);
-                                       query_can_be_split_and_retried =
-                                         (default_settings.query_can_be_split_and_retried);
-                                       query_term =
-                                         (default_settings.query_term)
-                                     } in
-                                 let errs =
-                                   FStar_Compiler_List.map errors_to_report1
-                                     all_errs in
-                                 let errs1 =
-                                   let uu___5 =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       errs FStar_Compiler_List.flatten in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___5 collect in
-                                 let errs2 =
-                                   FStar_Compiler_Effect.op_Bar_Greater errs1
-                                     (FStar_Compiler_List.map
-                                        (fun uu___5 ->
-                                           match uu___5 with
-                                           | ((e, m, r, ctx), n) ->
-                                               if n > Prims.int_one
-                                               then
-                                                 let uu___6 =
-                                                   let uu___7 =
-                                                     let uu___8 =
-                                                       FStar_Compiler_Util.string_of_int
-                                                         n in
-                                                     FStar_Compiler_Util.format1
-                                                       " (%s times)" uu___8 in
-                                                   Prims.op_Hat m uu___7 in
-                                                 (e, uu___6, r, ctx)
-                                               else (e, m, r, ctx))) in
-                                 (FStar_Errors.add_errors errs2;
-                                  (let rng =
-                                     match FStar_Pervasives_Native.snd
-                                             env.FStar_TypeChecker_Env.qtbl_name_and_index
-                                     with
-                                     | FStar_Pervasives_Native.Some
-                                         (l, uu___6) ->
-                                         FStar_Ident.range_of_lid l
-                                     | uu___6 ->
-                                         FStar_Compiler_Range.dummyRange in
-                                   if quaking
-                                   then
-                                     let uu___6 =
-                                       let uu___7 =
-                                         let uu___8 =
-                                           FStar_Compiler_Util.string_of_int
-                                             nsuccess in
-                                         let uu___9 =
-                                           FStar_Compiler_Util.string_of_int
-                                             total_ran in
-                                         let uu___10 =
-                                           FStar_Compiler_Util.string_of_int
-                                             lo1 in
-                                         let uu___11 =
-                                           FStar_Compiler_Util.string_of_int
-                                             hi1 in
-                                         FStar_Compiler_Util.format6
-                                           "Query %s failed the quake test, %s out of %s attempts succeded, but the threshold was %s out of %s%s"
-                                           name uu___8 uu___9 uu___10 uu___11
-                                           (if total_ran < hi1
-                                            then " (early abort)"
-                                            else "") in
-                                       (FStar_Errors.Error_QuakeFailed,
-                                         uu___7) in
-                                     FStar_TypeChecker_Err.log_issue env rng
-                                       uu___6
-                                   else ()))
-                               else
-                                 (let report errs =
-                                    report_errors
-                                      {
-                                        query_env =
-                                          (default_settings.query_env);
-                                        query_decl =
-                                          (default_settings.query_decl);
-                                        query_name =
-                                          (default_settings.query_name);
-                                        query_index =
-                                          (default_settings.query_index);
-                                        query_range =
-                                          (default_settings.query_range);
-                                        query_fuel =
-                                          (default_settings.query_fuel);
-                                        query_ifuel =
-                                          (default_settings.query_ifuel);
-                                        query_rlimit =
-                                          (default_settings.query_rlimit);
-                                        query_hint =
-                                          (default_settings.query_hint);
-                                        query_errors = errs;
-                                        query_all_labels =
-                                          (default_settings.query_all_labels);
-                                        query_suffix =
-                                          (default_settings.query_suffix);
-                                        query_hash =
-                                          (default_settings.query_hash);
-                                        query_can_be_split_and_retried =
-                                          (default_settings.query_can_be_split_and_retried);
-                                        query_term =
-                                          (default_settings.query_term)
-                                      } in
-                                  FStar_Compiler_List.iter report all_errs))
-                            else ()) in
-                     let skip =
-                       ((FStar_Options.admit_smt_queries ()) ||
-                          (FStar_TypeChecker_Env.too_early_in_prims env))
-                         ||
-                         (let uu___2 = FStar_Options.admit_except () in
-                          match uu___2 with
-                          | FStar_Pervasives_Native.Some id ->
-                              if FStar_Compiler_Util.starts_with id "("
-                              then
-                                let uu___3 = full_query_id default_settings in
-                                uu___3 <> id
-                              else default_settings.query_name <> id
-                          | FStar_Pervasives_Native.None -> false) in
-                     if skip
-                     then
-                       let uu___2 =
-                         (FStar_Options.record_hints ()) &&
-                           (FStar_Compiler_Effect.op_Bar_Greater next_hint
-                              FStar_Compiler_Util.is_some) in
-                       (if uu___2
-                        then
-                          let uu___3 =
-                            FStar_Compiler_Effect.op_Bar_Greater next_hint
-                              FStar_Compiler_Util.must in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___3
-                            store_hint
-                        else ())
-                     else quake_and_check_all_configs all_configs)
-type solver_cfg =
-  {
-  seed: Prims.int ;
-  cliopt: Prims.string Prims.list ;
-  smtopt: Prims.string Prims.list ;
-  facts: (Prims.string Prims.list * Prims.bool) Prims.list ;
-  valid_intro: Prims.bool ;
-  valid_elim: Prims.bool }
-let (__proj__Mksolver_cfg__item__seed : solver_cfg -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { seed; cliopt; smtopt; facts; valid_intro; valid_elim;_} -> seed
-let (__proj__Mksolver_cfg__item__cliopt :
-  solver_cfg -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { seed; cliopt; smtopt; facts; valid_intro; valid_elim;_} -> cliopt
-let (__proj__Mksolver_cfg__item__smtopt :
-  solver_cfg -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { seed; cliopt; smtopt; facts; valid_intro; valid_elim;_} -> smtopt
-let (__proj__Mksolver_cfg__item__facts :
-  solver_cfg -> (Prims.string Prims.list * Prims.bool) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { seed; cliopt; smtopt; facts; valid_intro; valid_elim;_} -> facts
-let (__proj__Mksolver_cfg__item__valid_intro : solver_cfg -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { seed; cliopt; smtopt; facts; valid_intro; valid_elim;_} ->
-        valid_intro
-let (__proj__Mksolver_cfg__item__valid_elim : solver_cfg -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { seed; cliopt; smtopt; facts; valid_intro; valid_elim;_} -> valid_elim
-let (_last_cfg :
-  solver_cfg FStar_Pervasives_Native.option FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (get_cfg : FStar_TypeChecker_Env.env -> solver_cfg) =
-  fun env ->
-    let uu___ = FStar_Options.z3_seed () in
-    let uu___1 = FStar_Options.z3_cliopt () in
-    let uu___2 = FStar_Options.z3_smtopt () in
-    let uu___3 = FStar_Options.smtencoding_valid_intro () in
-    let uu___4 = FStar_Options.smtencoding_valid_elim () in
-    {
-      seed = uu___;
-      cliopt = uu___1;
-      smtopt = uu___2;
-      facts = (env.FStar_TypeChecker_Env.proof_ns);
-      valid_intro = uu___3;
-      valid_elim = uu___4
-    }
-let (save_cfg : FStar_TypeChecker_Env.env -> unit) =
-  fun env ->
-    let uu___ =
-      let uu___1 = get_cfg env in FStar_Pervasives_Native.Some uu___1 in
-    FStar_Compiler_Effect.op_Colon_Equals _last_cfg uu___
-let (should_refresh : FStar_TypeChecker_Env.env -> Prims.bool) =
-  fun env ->
-    let uu___ = FStar_Compiler_Effect.op_Bang _last_cfg in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> (save_cfg env; false)
-    | FStar_Pervasives_Native.Some cfg ->
-        let uu___1 = let uu___2 = get_cfg env in cfg = uu___2 in
-        Prims.op_Negation uu___1
-let rec (do_solve :
-  Prims.bool ->
-    (unit -> Prims.string) FStar_Pervasives_Native.option ->
-      FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun is_retry ->
-    fun use_env_msg ->
-      fun tcenv ->
-        fun q ->
-          (let uu___1 = should_refresh tcenv in
-           if uu___1
-           then (save_cfg tcenv; FStar_SMTEncoding_Z3.refresh ())
-           else ());
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_TypeChecker_Env.get_range tcenv in
-               FStar_Compiler_Effect.op_Less_Bar
-                 FStar_Compiler_Range.string_of_range uu___4 in
-             FStar_Compiler_Util.format1 "Starting query at %s" uu___3 in
-           FStar_SMTEncoding_Encode.push uu___2);
-          (let pop uu___2 =
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = FStar_TypeChecker_Env.get_range tcenv in
-                 FStar_Compiler_Effect.op_Less_Bar
-                   FStar_Compiler_Range.string_of_range uu___5 in
-               FStar_Compiler_Util.format1 "Ending query at %s" uu___4 in
-             FStar_SMTEncoding_Encode.pop uu___3 in
-           try
-             (fun uu___2 ->
-                match () with
-                | () ->
-                    let uu___3 =
-                      FStar_SMTEncoding_Encode.encode_query use_env_msg tcenv
-                        q in
-                    (match uu___3 with
-                     | (prefix, labels, qry, suffix) ->
-                         let tcenv1 =
-                           FStar_TypeChecker_Env.incr_query_index tcenv in
-                         (match qry with
-                          | FStar_SMTEncoding_Term.Assume
-                              {
-                                FStar_SMTEncoding_Term.assumption_term =
-                                  {
-                                    FStar_SMTEncoding_Term.tm =
-                                      FStar_SMTEncoding_Term.App
-                                      (FStar_SMTEncoding_Term.FalseOp,
-                                       uu___4);
-                                    FStar_SMTEncoding_Term.freevars = uu___5;
-                                    FStar_SMTEncoding_Term.rng = uu___6;_};
-                                FStar_SMTEncoding_Term.assumption_caption =
-                                  uu___7;
-                                FStar_SMTEncoding_Term.assumption_name =
-                                  uu___8;
-                                FStar_SMTEncoding_Term.assumption_fact_ids =
-                                  uu___9;_}
-                              -> pop ()
-                          | uu___4 when tcenv1.FStar_TypeChecker_Env.admit ->
-                              pop ()
-                          | FStar_SMTEncoding_Term.Assume uu___4 ->
-                              ((let uu___6 =
-                                  (is_retry ||
-                                     (FStar_Options.split_queries ()))
-                                    && (FStar_Options.debug_any ()) in
-                                if uu___6
-                                then
-                                  let n = FStar_Compiler_List.length labels in
-                                  (if n <> Prims.int_one
-                                   then
-                                     let uu___7 =
-                                       FStar_TypeChecker_Env.get_range tcenv1 in
-                                     let uu___8 =
-                                       let uu___9 =
-                                         FStar_Syntax_Print.term_to_string q in
-                                       let uu___10 =
-                                         FStar_SMTEncoding_Term.declToSmt ""
-                                           qry in
-                                       let uu___11 =
-                                         FStar_Compiler_Util.string_of_int n in
-                                       FStar_Compiler_Util.format3
-                                         "Encoded split query %s\nto %s\nwith %s labels"
-                                         uu___9 uu___10 uu___11 in
-                                     FStar_Errors.diag uu___7 uu___8
-                                   else ())
-                                else ());
-                               ask_and_report_errors is_retry tcenv1 labels
-                                 prefix qry q suffix;
-                               pop ())
-                          | uu___4 -> failwith "Impossible"))) ()
-           with
-           | SplitQueryAndRetry ->
-               (pop ();
-                if is_retry
-                then
-                  failwith
-                    "Impossible: retried queries should always produce an error reportand cannot be split and retried further"
-                else ();
-                (let uu___6 = FStar_TypeChecker_Env.split_smt_query tcenv q in
-                 match uu___6 with
-                 | FStar_Pervasives_Native.None ->
-                     failwith "Impossible: split_query callback is not set"
-                 | FStar_Pervasives_Native.Some goals ->
-                     FStar_Compiler_Effect.op_Bar_Greater goals
-                       (FStar_Compiler_List.iter
-                          (fun uu___7 ->
-                             match uu___7 with
-                             | (env, goal) ->
-                                 do_solve true use_env_msg env goal)));
-                (let uu___6 =
-                   let uu___7 = FStar_Errors.get_err_count () in
-                   uu___7 = Prims.int_zero in
-                 if uu___6
-                 then
-                   FStar_TypeChecker_Err.log_issue tcenv
-                     tcenv.FStar_TypeChecker_Env.range
-                     (FStar_Errors.Warning_SplitAndRetryQueries,
-                       "The verification condition succeeded after splitting it to localize potential errors, although the original non-split verification condition failed. If you want to rely on splitting queries for verifying your program please use the --split_queries option rather than relying on it implicitly.")
-                 else ()))
-           | FStar_SMTEncoding_Env.Inner_let_rec names ->
-               (pop ();
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 =
-                         FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                           names in
-                       FStar_String.concat "," uu___7 in
-                     FStar_Compiler_Util.format1
-                       "Could not encode the query since F* does not support precise smtencoding of inner let-recs yet (in this case %s)"
-                       uu___6 in
-                   (FStar_Errors.Error_NonTopRecFunctionNotFullyEncoded,
-                     uu___5) in
-                 FStar_TypeChecker_Err.log_issue tcenv
-                   tcenv.FStar_TypeChecker_Env.range uu___4)))
-let (solve :
-  (unit -> Prims.string) FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun use_env_msg ->
-    fun tcenv ->
-      fun q ->
-        let uu___ = FStar_Options.no_smt () in
-        if uu___
-        then
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string q in
-              FStar_Compiler_Util.format1
-                "Q = %s\nA query could not be solved internally, and --no_smt was given"
-                uu___3 in
-            (FStar_Errors.Error_NoSMTButNeeded, uu___2) in
-          FStar_TypeChecker_Err.log_issue tcenv
-            tcenv.FStar_TypeChecker_Env.range uu___1
-        else
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_TypeChecker_Env.current_module tcenv in
-               FStar_Ident.string_of_lid uu___4 in
-             FStar_Pervasives_Native.Some uu___3 in
-           FStar_Profiling.profile
-             (fun uu___3 -> do_solve false use_env_msg tcenv q) uu___2
-             "FStar.SMTEncoding.solve_top_level")
-let (solver : FStar_TypeChecker_Env.solver_t) =
-  {
-    FStar_TypeChecker_Env.init =
-      (fun e -> save_cfg e; FStar_SMTEncoding_Encode.init e);
-    FStar_TypeChecker_Env.push = FStar_SMTEncoding_Encode.push;
-    FStar_TypeChecker_Env.pop = FStar_SMTEncoding_Encode.pop;
-    FStar_TypeChecker_Env.snapshot = FStar_SMTEncoding_Encode.snapshot;
-    FStar_TypeChecker_Env.rollback = FStar_SMTEncoding_Encode.rollback;
-    FStar_TypeChecker_Env.encode_sig = FStar_SMTEncoding_Encode.encode_sig;
-    FStar_TypeChecker_Env.preprocess =
-      (fun e ->
-         fun g ->
-           let uu___ = let uu___1 = FStar_Options.peek () in (e, g, uu___1) in
-           [uu___]);
-    FStar_TypeChecker_Env.spinoff_strictly_positive_goals =
-      FStar_Pervasives_Native.None;
-    FStar_TypeChecker_Env.handle_smt_goal = (fun e -> fun g -> [(e, g)]);
-    FStar_TypeChecker_Env.solve = solve;
-    FStar_TypeChecker_Env.finish = FStar_SMTEncoding_Z3.finish;
-    FStar_TypeChecker_Env.refresh = FStar_SMTEncoding_Z3.refresh
-  }
-let (dummy : FStar_TypeChecker_Env.solver_t) =
-  {
-    FStar_TypeChecker_Env.init = (fun uu___ -> ());
-    FStar_TypeChecker_Env.push = (fun uu___ -> ());
-    FStar_TypeChecker_Env.pop = (fun uu___ -> ());
-    FStar_TypeChecker_Env.snapshot =
-      (fun uu___ -> ((Prims.int_zero, Prims.int_zero, Prims.int_zero), ()));
-    FStar_TypeChecker_Env.rollback = (fun uu___ -> fun uu___1 -> ());
-    FStar_TypeChecker_Env.encode_sig = (fun uu___ -> fun uu___1 -> ());
-    FStar_TypeChecker_Env.preprocess =
-      (fun e ->
-         fun g ->
-           let uu___ = let uu___1 = FStar_Options.peek () in (e, g, uu___1) in
-           [uu___]);
-    FStar_TypeChecker_Env.spinoff_strictly_positive_goals =
-      FStar_Pervasives_Native.None;
-    FStar_TypeChecker_Env.handle_smt_goal = (fun e -> fun g -> [(e, g)]);
-    FStar_TypeChecker_Env.solve =
-      (fun uu___ -> fun uu___1 -> fun uu___2 -> ());
-    FStar_TypeChecker_Env.finish = (fun uu___ -> ());
-    FStar_TypeChecker_Env.refresh = (fun uu___ -> ())
-  }
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_Term.ml b/src/ocaml-output/FStar_SMTEncoding_Term.ml
deleted file mode 100644
index 202d3a43fdf..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_Term.ml
+++ /dev/null
@@ -1,2221 +0,0 @@
-open Prims
-type sort =
-  | Bool_sort 
-  | Int_sort 
-  | String_sort 
-  | Term_sort 
-  | Fuel_sort 
-  | BitVec_sort of Prims.int 
-  | Array of (sort * sort) 
-  | Arrow of (sort * sort) 
-  | Sort of Prims.string 
-let (uu___is_Bool_sort : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Bool_sort -> true | uu___ -> false
-let (uu___is_Int_sort : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Int_sort -> true | uu___ -> false
-let (uu___is_String_sort : sort -> Prims.bool) =
-  fun projectee ->
-    match projectee with | String_sort -> true | uu___ -> false
-let (uu___is_Term_sort : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Term_sort -> true | uu___ -> false
-let (uu___is_Fuel_sort : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Fuel_sort -> true | uu___ -> false
-let (uu___is_BitVec_sort : sort -> Prims.bool) =
-  fun projectee ->
-    match projectee with | BitVec_sort _0 -> true | uu___ -> false
-let (__proj__BitVec_sort__item___0 : sort -> Prims.int) =
-  fun projectee -> match projectee with | BitVec_sort _0 -> _0
-let (uu___is_Array : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Array _0 -> true | uu___ -> false
-let (__proj__Array__item___0 : sort -> (sort * sort)) =
-  fun projectee -> match projectee with | Array _0 -> _0
-let (uu___is_Arrow : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Arrow _0 -> true | uu___ -> false
-let (__proj__Arrow__item___0 : sort -> (sort * sort)) =
-  fun projectee -> match projectee with | Arrow _0 -> _0
-let (uu___is_Sort : sort -> Prims.bool) =
-  fun projectee -> match projectee with | Sort _0 -> true | uu___ -> false
-let (__proj__Sort__item___0 : sort -> Prims.string) =
-  fun projectee -> match projectee with | Sort _0 -> _0
-type op =
-  | TrueOp 
-  | FalseOp 
-  | Not 
-  | And 
-  | Or 
-  | Imp 
-  | Iff 
-  | Eq 
-  | LT 
-  | LTE 
-  | GT 
-  | GTE 
-  | Add 
-  | Sub 
-  | Div 
-  | RealDiv 
-  | Mul 
-  | Minus 
-  | Mod 
-  | BvAnd 
-  | BvXor 
-  | BvOr 
-  | BvAdd 
-  | BvSub 
-  | BvShl 
-  | BvShr 
-  | BvUdiv 
-  | BvMod 
-  | BvMul 
-  | BvUlt 
-  | BvUext of Prims.int 
-  | NatToBv of Prims.int 
-  | BvToNat 
-  | ITE 
-  | Var of Prims.string 
-let (uu___is_TrueOp : op -> Prims.bool) =
-  fun projectee -> match projectee with | TrueOp -> true | uu___ -> false
-let (uu___is_FalseOp : op -> Prims.bool) =
-  fun projectee -> match projectee with | FalseOp -> true | uu___ -> false
-let (uu___is_Not : op -> Prims.bool) =
-  fun projectee -> match projectee with | Not -> true | uu___ -> false
-let (uu___is_And : op -> Prims.bool) =
-  fun projectee -> match projectee with | And -> true | uu___ -> false
-let (uu___is_Or : op -> Prims.bool) =
-  fun projectee -> match projectee with | Or -> true | uu___ -> false
-let (uu___is_Imp : op -> Prims.bool) =
-  fun projectee -> match projectee with | Imp -> true | uu___ -> false
-let (uu___is_Iff : op -> Prims.bool) =
-  fun projectee -> match projectee with | Iff -> true | uu___ -> false
-let (uu___is_Eq : op -> Prims.bool) =
-  fun projectee -> match projectee with | Eq -> true | uu___ -> false
-let (uu___is_LT : op -> Prims.bool) =
-  fun projectee -> match projectee with | LT -> true | uu___ -> false
-let (uu___is_LTE : op -> Prims.bool) =
-  fun projectee -> match projectee with | LTE -> true | uu___ -> false
-let (uu___is_GT : op -> Prims.bool) =
-  fun projectee -> match projectee with | GT -> true | uu___ -> false
-let (uu___is_GTE : op -> Prims.bool) =
-  fun projectee -> match projectee with | GTE -> true | uu___ -> false
-let (uu___is_Add : op -> Prims.bool) =
-  fun projectee -> match projectee with | Add -> true | uu___ -> false
-let (uu___is_Sub : op -> Prims.bool) =
-  fun projectee -> match projectee with | Sub -> true | uu___ -> false
-let (uu___is_Div : op -> Prims.bool) =
-  fun projectee -> match projectee with | Div -> true | uu___ -> false
-let (uu___is_RealDiv : op -> Prims.bool) =
-  fun projectee -> match projectee with | RealDiv -> true | uu___ -> false
-let (uu___is_Mul : op -> Prims.bool) =
-  fun projectee -> match projectee with | Mul -> true | uu___ -> false
-let (uu___is_Minus : op -> Prims.bool) =
-  fun projectee -> match projectee with | Minus -> true | uu___ -> false
-let (uu___is_Mod : op -> Prims.bool) =
-  fun projectee -> match projectee with | Mod -> true | uu___ -> false
-let (uu___is_BvAnd : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvAnd -> true | uu___ -> false
-let (uu___is_BvXor : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvXor -> true | uu___ -> false
-let (uu___is_BvOr : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvOr -> true | uu___ -> false
-let (uu___is_BvAdd : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvAdd -> true | uu___ -> false
-let (uu___is_BvSub : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvSub -> true | uu___ -> false
-let (uu___is_BvShl : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvShl -> true | uu___ -> false
-let (uu___is_BvShr : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvShr -> true | uu___ -> false
-let (uu___is_BvUdiv : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvUdiv -> true | uu___ -> false
-let (uu___is_BvMod : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvMod -> true | uu___ -> false
-let (uu___is_BvMul : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvMul -> true | uu___ -> false
-let (uu___is_BvUlt : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvUlt -> true | uu___ -> false
-let (uu___is_BvUext : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvUext _0 -> true | uu___ -> false
-let (__proj__BvUext__item___0 : op -> Prims.int) =
-  fun projectee -> match projectee with | BvUext _0 -> _0
-let (uu___is_NatToBv : op -> Prims.bool) =
-  fun projectee -> match projectee with | NatToBv _0 -> true | uu___ -> false
-let (__proj__NatToBv__item___0 : op -> Prims.int) =
-  fun projectee -> match projectee with | NatToBv _0 -> _0
-let (uu___is_BvToNat : op -> Prims.bool) =
-  fun projectee -> match projectee with | BvToNat -> true | uu___ -> false
-let (uu___is_ITE : op -> Prims.bool) =
-  fun projectee -> match projectee with | ITE -> true | uu___ -> false
-let (uu___is_Var : op -> Prims.bool) =
-  fun projectee -> match projectee with | Var _0 -> true | uu___ -> false
-let (__proj__Var__item___0 : op -> Prims.string) =
-  fun projectee -> match projectee with | Var _0 -> _0
-type qop =
-  | Forall 
-  | Exists 
-let (uu___is_Forall : qop -> Prims.bool) =
-  fun projectee -> match projectee with | Forall -> true | uu___ -> false
-let (uu___is_Exists : qop -> Prims.bool) =
-  fun projectee -> match projectee with | Exists -> true | uu___ -> false
-type term' =
-  | Integer of Prims.string 
-  | String of Prims.string 
-  | Real of Prims.string 
-  | BoundV of Prims.int 
-  | FreeV of (Prims.string * sort * Prims.bool) 
-  | App of (op * term Prims.list) 
-  | Quant of (qop * term Prims.list Prims.list * Prims.int
-  FStar_Pervasives_Native.option * sort Prims.list * term) 
-  | Let of (term Prims.list * term) 
-  | Labeled of (term * Prims.string * FStar_Compiler_Range.range) 
-  | LblPos of (term * Prims.string) 
-and term =
-  {
-  tm: term' ;
-  freevars:
-    (Prims.string * sort * Prims.bool) Prims.list FStar_Syntax_Syntax.memo ;
-  rng: FStar_Compiler_Range.range }
-let (uu___is_Integer : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Integer _0 -> true | uu___ -> false
-let (__proj__Integer__item___0 : term' -> Prims.string) =
-  fun projectee -> match projectee with | Integer _0 -> _0
-let (uu___is_String : term' -> Prims.bool) =
-  fun projectee -> match projectee with | String _0 -> true | uu___ -> false
-let (__proj__String__item___0 : term' -> Prims.string) =
-  fun projectee -> match projectee with | String _0 -> _0
-let (uu___is_Real : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Real _0 -> true | uu___ -> false
-let (__proj__Real__item___0 : term' -> Prims.string) =
-  fun projectee -> match projectee with | Real _0 -> _0
-let (uu___is_BoundV : term' -> Prims.bool) =
-  fun projectee -> match projectee with | BoundV _0 -> true | uu___ -> false
-let (__proj__BoundV__item___0 : term' -> Prims.int) =
-  fun projectee -> match projectee with | BoundV _0 -> _0
-let (uu___is_FreeV : term' -> Prims.bool) =
-  fun projectee -> match projectee with | FreeV _0 -> true | uu___ -> false
-let (__proj__FreeV__item___0 : term' -> (Prims.string * sort * Prims.bool)) =
-  fun projectee -> match projectee with | FreeV _0 -> _0
-let (uu___is_App : term' -> Prims.bool) =
-  fun projectee -> match projectee with | App _0 -> true | uu___ -> false
-let (__proj__App__item___0 : term' -> (op * term Prims.list)) =
-  fun projectee -> match projectee with | App _0 -> _0
-let (uu___is_Quant : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Quant _0 -> true | uu___ -> false
-let (__proj__Quant__item___0 :
-  term' ->
-    (qop * term Prims.list Prims.list * Prims.int
-      FStar_Pervasives_Native.option * sort Prims.list * term))
-  = fun projectee -> match projectee with | Quant _0 -> _0
-let (uu___is_Let : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Let _0 -> true | uu___ -> false
-let (__proj__Let__item___0 : term' -> (term Prims.list * term)) =
-  fun projectee -> match projectee with | Let _0 -> _0
-let (uu___is_Labeled : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Labeled _0 -> true | uu___ -> false
-let (__proj__Labeled__item___0 :
-  term' -> (term * Prims.string * FStar_Compiler_Range.range)) =
-  fun projectee -> match projectee with | Labeled _0 -> _0
-let (uu___is_LblPos : term' -> Prims.bool) =
-  fun projectee -> match projectee with | LblPos _0 -> true | uu___ -> false
-let (__proj__LblPos__item___0 : term' -> (term * Prims.string)) =
-  fun projectee -> match projectee with | LblPos _0 -> _0
-let (__proj__Mkterm__item__tm : term -> term') =
-  fun projectee -> match projectee with | { tm; freevars; rng;_} -> tm
-let (__proj__Mkterm__item__freevars :
-  term ->
-    (Prims.string * sort * Prims.bool) Prims.list FStar_Syntax_Syntax.memo)
-  =
-  fun projectee -> match projectee with | { tm; freevars; rng;_} -> freevars
-let (__proj__Mkterm__item__rng : term -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | { tm; freevars; rng;_} -> rng
-type pat = term
-type fv = (Prims.string * sort * Prims.bool)
-type fvs = (Prims.string * sort * Prims.bool) Prims.list
-type caption = Prims.string FStar_Pervasives_Native.option
-type binders = (Prims.string * sort) Prims.list
-type constructor_field = (Prims.string * sort * Prims.bool)
-type constructor_t =
-  (Prims.string * constructor_field Prims.list * sort * Prims.int *
-    Prims.bool)
-type constructors = constructor_t Prims.list
-type fact_db_id =
-  | Name of FStar_Ident.lid 
-  | Namespace of FStar_Ident.lid 
-  | Tag of Prims.string 
-let (uu___is_Name : fact_db_id -> Prims.bool) =
-  fun projectee -> match projectee with | Name _0 -> true | uu___ -> false
-let (__proj__Name__item___0 : fact_db_id -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Name _0 -> _0
-let (uu___is_Namespace : fact_db_id -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Namespace _0 -> true | uu___ -> false
-let (__proj__Namespace__item___0 : fact_db_id -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | Namespace _0 -> _0
-let (uu___is_Tag : fact_db_id -> Prims.bool) =
-  fun projectee -> match projectee with | Tag _0 -> true | uu___ -> false
-let (__proj__Tag__item___0 : fact_db_id -> Prims.string) =
-  fun projectee -> match projectee with | Tag _0 -> _0
-type assumption =
-  {
-  assumption_term: term ;
-  assumption_caption: caption ;
-  assumption_name: Prims.string ;
-  assumption_fact_ids: fact_db_id Prims.list }
-let (__proj__Mkassumption__item__assumption_term : assumption -> term) =
-  fun projectee ->
-    match projectee with
-    | { assumption_term; assumption_caption; assumption_name;
-        assumption_fact_ids;_} -> assumption_term
-let (__proj__Mkassumption__item__assumption_caption : assumption -> caption)
-  =
-  fun projectee ->
-    match projectee with
-    | { assumption_term; assumption_caption; assumption_name;
-        assumption_fact_ids;_} -> assumption_caption
-let (__proj__Mkassumption__item__assumption_name :
-  assumption -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { assumption_term; assumption_caption; assumption_name;
-        assumption_fact_ids;_} -> assumption_name
-let (__proj__Mkassumption__item__assumption_fact_ids :
-  assumption -> fact_db_id Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { assumption_term; assumption_caption; assumption_name;
-        assumption_fact_ids;_} -> assumption_fact_ids
-type decl =
-  | DefPrelude 
-  | DeclFun of (Prims.string * sort Prims.list * sort * caption) 
-  | DefineFun of (Prims.string * sort Prims.list * sort * term * caption) 
-  | Assume of assumption 
-  | Caption of Prims.string 
-  | Module of (Prims.string * decl Prims.list) 
-  | Eval of term 
-  | Echo of Prims.string 
-  | RetainAssumptions of Prims.string Prims.list 
-  | Push 
-  | Pop 
-  | CheckSat 
-  | GetUnsatCore 
-  | SetOption of (Prims.string * Prims.string) 
-  | GetStatistics 
-  | GetReasonUnknown 
-let (uu___is_DefPrelude : decl -> Prims.bool) =
-  fun projectee -> match projectee with | DefPrelude -> true | uu___ -> false
-let (uu___is_DeclFun : decl -> Prims.bool) =
-  fun projectee -> match projectee with | DeclFun _0 -> true | uu___ -> false
-let (__proj__DeclFun__item___0 :
-  decl -> (Prims.string * sort Prims.list * sort * caption)) =
-  fun projectee -> match projectee with | DeclFun _0 -> _0
-let (uu___is_DefineFun : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DefineFun _0 -> true | uu___ -> false
-let (__proj__DefineFun__item___0 :
-  decl -> (Prims.string * sort Prims.list * sort * term * caption)) =
-  fun projectee -> match projectee with | DefineFun _0 -> _0
-let (uu___is_Assume : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Assume _0 -> true | uu___ -> false
-let (__proj__Assume__item___0 : decl -> assumption) =
-  fun projectee -> match projectee with | Assume _0 -> _0
-let (uu___is_Caption : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Caption _0 -> true | uu___ -> false
-let (__proj__Caption__item___0 : decl -> Prims.string) =
-  fun projectee -> match projectee with | Caption _0 -> _0
-let (uu___is_Module : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Module _0 -> true | uu___ -> false
-let (__proj__Module__item___0 : decl -> (Prims.string * decl Prims.list)) =
-  fun projectee -> match projectee with | Module _0 -> _0
-let (uu___is_Eval : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Eval _0 -> true | uu___ -> false
-let (__proj__Eval__item___0 : decl -> term) =
-  fun projectee -> match projectee with | Eval _0 -> _0
-let (uu___is_Echo : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Echo _0 -> true | uu___ -> false
-let (__proj__Echo__item___0 : decl -> Prims.string) =
-  fun projectee -> match projectee with | Echo _0 -> _0
-let (uu___is_RetainAssumptions : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RetainAssumptions _0 -> true | uu___ -> false
-let (__proj__RetainAssumptions__item___0 : decl -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | RetainAssumptions _0 -> _0
-let (uu___is_Push : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Push -> true | uu___ -> false
-let (uu___is_Pop : decl -> Prims.bool) =
-  fun projectee -> match projectee with | Pop -> true | uu___ -> false
-let (uu___is_CheckSat : decl -> Prims.bool) =
-  fun projectee -> match projectee with | CheckSat -> true | uu___ -> false
-let (uu___is_GetUnsatCore : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | GetUnsatCore -> true | uu___ -> false
-let (uu___is_SetOption : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SetOption _0 -> true | uu___ -> false
-let (__proj__SetOption__item___0 : decl -> (Prims.string * Prims.string)) =
-  fun projectee -> match projectee with | SetOption _0 -> _0
-let (uu___is_GetStatistics : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | GetStatistics -> true | uu___ -> false
-let (uu___is_GetReasonUnknown : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | GetReasonUnknown -> true | uu___ -> false
-type decls_elt =
-  {
-  sym_name: Prims.string FStar_Pervasives_Native.option ;
-  key: Prims.string FStar_Pervasives_Native.option ;
-  decls: decl Prims.list ;
-  a_names: Prims.string Prims.list }
-let (__proj__Mkdecls_elt__item__sym_name :
-  decls_elt -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with | { sym_name; key; decls; a_names;_} -> sym_name
-let (__proj__Mkdecls_elt__item__key :
-  decls_elt -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with | { sym_name; key; decls; a_names;_} -> key
-let (__proj__Mkdecls_elt__item__decls : decls_elt -> decl Prims.list) =
-  fun projectee ->
-    match projectee with | { sym_name; key; decls; a_names;_} -> decls
-let (__proj__Mkdecls_elt__item__a_names :
-  decls_elt -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with | { sym_name; key; decls; a_names;_} -> a_names
-type decls_t = decls_elt Prims.list
-let (escape : Prims.string -> Prims.string) =
-  fun s -> FStar_Compiler_Util.replace_char s 39 95
-let rec (strSort : sort -> Prims.string) =
-  fun x ->
-    match x with
-    | Bool_sort -> "Bool"
-    | Int_sort -> "Int"
-    | Term_sort -> "Term"
-    | String_sort -> "FString"
-    | Fuel_sort -> "Fuel"
-    | BitVec_sort n ->
-        let uu___ = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "(_ BitVec %s)" uu___
-    | Array (s1, s2) ->
-        let uu___ = strSort s1 in
-        let uu___1 = strSort s2 in
-        FStar_Compiler_Util.format2 "(Array %s %s)" uu___ uu___1
-    | Arrow (s1, s2) ->
-        let uu___ = strSort s1 in
-        let uu___1 = strSort s2 in
-        FStar_Compiler_Util.format2 "(%s -> %s)" uu___ uu___1
-    | Sort s -> s
-let (mk_decls :
-  Prims.string ->
-    Prims.string -> decl Prims.list -> decls_elt Prims.list -> decls_t)
-  =
-  fun name ->
-    fun key ->
-      fun decls ->
-        fun aux_decls ->
-          let uu___ =
-            let uu___1 =
-              let sm = FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-              FStar_Compiler_List.iter
-                (fun elt ->
-                   FStar_Compiler_List.iter
-                     (fun s -> FStar_Compiler_Util.smap_add sm s "0")
-                     elt.a_names) aux_decls;
-              FStar_Compiler_List.iter
-                (fun d ->
-                   match d with
-                   | Assume a ->
-                       FStar_Compiler_Util.smap_add sm a.assumption_name "0"
-                   | uu___4 -> ()) decls;
-              FStar_Compiler_Util.smap_keys sm in
-            {
-              sym_name = (FStar_Pervasives_Native.Some name);
-              key = (FStar_Pervasives_Native.Some key);
-              decls;
-              a_names = uu___1
-            } in
-          [uu___]
-let (mk_decls_trivial : decl Prims.list -> decls_t) =
-  fun decls ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_List.collect
-          (fun uu___2 ->
-             match uu___2 with
-             | Assume a -> [a.assumption_name]
-             | uu___3 -> []) decls in
-      {
-        sym_name = FStar_Pervasives_Native.None;
-        key = FStar_Pervasives_Native.None;
-        decls;
-        a_names = uu___1
-      } in
-    [uu___]
-let (decls_list_of : decls_t -> decl Prims.list) =
-  fun l ->
-    FStar_Compiler_Effect.op_Bar_Greater l
-      (FStar_Compiler_List.collect (fun elt -> elt.decls))
-let (mk_fv : (Prims.string * sort) -> fv) =
-  fun uu___ -> match uu___ with | (x, y) -> (x, y, false)
-let (fv_name : fv -> Prims.string) =
-  fun x -> let uu___ = x in match uu___ with | (nm, uu___1, uu___2) -> nm
-let (fv_sort : fv -> sort) =
-  fun x ->
-    let uu___ = x in match uu___ with | (uu___1, sort1, uu___2) -> sort1
-let (fv_force : fv -> Prims.bool) =
-  fun x ->
-    let uu___ = x in match uu___ with | (uu___1, uu___2, force) -> force
-type error_label = (fv * Prims.string * FStar_Compiler_Range.range)
-type error_labels = error_label Prims.list
-let (fv_eq : fv -> fv -> Prims.bool) =
-  fun x ->
-    fun y ->
-      let uu___ = fv_name x in let uu___1 = fv_name y in uu___ = uu___1
-let (fvs_subset_of : fvs -> fvs -> Prims.bool) =
-  fun x ->
-    fun y ->
-      let cmp_fv x1 y1 =
-        let uu___ = fv_name x1 in
-        let uu___1 = fv_name y1 in FStar_Compiler_Util.compare uu___ uu___1 in
-      let uu___ = FStar_Compiler_Util.as_set x cmp_fv in
-      let uu___1 = FStar_Compiler_Util.as_set y cmp_fv in
-      FStar_Compiler_Util.set_is_subset_of uu___ uu___1
-let (freevar_eq : term -> term -> Prims.bool) =
-  fun x ->
-    fun y ->
-      match ((x.tm), (y.tm)) with
-      | (FreeV x1, FreeV y1) -> fv_eq x1 y1
-      | uu___ -> false
-let (freevar_sort : term -> sort) =
-  fun uu___ ->
-    match uu___ with
-    | { tm = FreeV x; freevars = uu___1; rng = uu___2;_} -> fv_sort x
-    | uu___1 -> failwith "impossible"
-let (fv_of_term : term -> fv) =
-  fun uu___ ->
-    match uu___ with
-    | { tm = FreeV fv1; freevars = uu___1; rng = uu___2;_} -> fv1
-    | uu___1 -> failwith "impossible"
-let rec (freevars : term -> (Prims.string * sort * Prims.bool) Prims.list) =
-  fun t ->
-    match t.tm with
-    | Integer uu___ -> []
-    | String uu___ -> []
-    | Real uu___ -> []
-    | BoundV uu___ -> []
-    | FreeV fv1 when fv_force fv1 -> []
-    | FreeV fv1 -> [fv1]
-    | App (uu___, tms) -> FStar_Compiler_List.collect freevars tms
-    | Quant (uu___, uu___1, uu___2, uu___3, t1) -> freevars t1
-    | Labeled (t1, uu___, uu___1) -> freevars t1
-    | LblPos (t1, uu___) -> freevars t1
-    | Let (es, body) -> FStar_Compiler_List.collect freevars (body :: es)
-let (free_variables : term -> fvs) =
-  fun t ->
-    let uu___ = FStar_Compiler_Effect.op_Bang t.freevars in
-    match uu___ with
-    | FStar_Pervasives_Native.Some b -> b
-    | FStar_Pervasives_Native.None ->
-        let fvs1 =
-          let uu___1 = freevars t in
-          FStar_Compiler_Util.remove_dups fv_eq uu___1 in
-        (FStar_Compiler_Effect.op_Colon_Equals t.freevars
-           (FStar_Pervasives_Native.Some fvs1);
-         fvs1)
-let (qop_to_string : qop -> Prims.string) =
-  fun uu___ -> match uu___ with | Forall -> "forall" | Exists -> "exists"
-let (op_to_string : op -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | TrueOp -> "true"
-    | FalseOp -> "false"
-    | Not -> "not"
-    | And -> "and"
-    | Or -> "or"
-    | Imp -> "implies"
-    | Iff -> "iff"
-    | Eq -> "="
-    | LT -> "<"
-    | LTE -> "<="
-    | GT -> ">"
-    | GTE -> ">="
-    | Add -> "+"
-    | Sub -> "-"
-    | Div -> "div"
-    | RealDiv -> "/"
-    | Mul -> "*"
-    | Minus -> "-"
-    | Mod -> "mod"
-    | ITE -> "ite"
-    | BvAnd -> "bvand"
-    | BvXor -> "bvxor"
-    | BvOr -> "bvor"
-    | BvAdd -> "bvadd"
-    | BvSub -> "bvsub"
-    | BvShl -> "bvshl"
-    | BvShr -> "bvlshr"
-    | BvUdiv -> "bvudiv"
-    | BvMod -> "bvurem"
-    | BvMul -> "bvmul"
-    | BvUlt -> "bvult"
-    | BvToNat -> "bv2int"
-    | BvUext n ->
-        let uu___1 = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "(_ zero_extend %s)" uu___1
-    | NatToBv n ->
-        let uu___1 = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "(_ int2bv %s)" uu___1
-    | Var s -> s
-let (weightToSmt : Prims.int FStar_Pervasives_Native.option -> Prims.string)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> ""
-    | FStar_Pervasives_Native.Some i ->
-        let uu___1 = FStar_Compiler_Util.string_of_int i in
-        FStar_Compiler_Util.format1 ":weight %s\n" uu___1
-let rec (hash_of_term' : term' -> Prims.string) =
-  fun t ->
-    match t with
-    | Integer i -> i
-    | String s -> s
-    | Real r -> r
-    | BoundV i ->
-        let uu___ = FStar_Compiler_Util.string_of_int i in
-        Prims.op_Hat "@" uu___
-    | FreeV x ->
-        let uu___ = fv_name x in
-        let uu___1 =
-          let uu___2 = let uu___3 = fv_sort x in strSort uu___3 in
-          Prims.op_Hat ":" uu___2 in
-        Prims.op_Hat uu___ uu___1
-    | App (op1, tms) ->
-        let uu___ =
-          let uu___1 = op_to_string op1 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Compiler_List.map hash_of_term tms in
-              FStar_Compiler_Effect.op_Bar_Greater uu___4
-                (FStar_String.concat " ") in
-            Prims.op_Hat uu___3 ")" in
-          Prims.op_Hat uu___1 uu___2 in
-        Prims.op_Hat "(" uu___
-    | Labeled (t1, r1, r2) ->
-        let uu___ = hash_of_term t1 in
-        let uu___1 =
-          let uu___2 = FStar_Compiler_Range.string_of_range r2 in
-          Prims.op_Hat r1 uu___2 in
-        Prims.op_Hat uu___ uu___1
-    | LblPos (t1, r) ->
-        let uu___ =
-          let uu___1 = hash_of_term t1 in
-          Prims.op_Hat uu___1 (Prims.op_Hat " :lblpos " (Prims.op_Hat r ")")) in
-        Prims.op_Hat "(! " uu___
-    | Quant (qop1, pats, wopt, sorts, body) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Compiler_List.map strSort sorts in
-                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                  (FStar_String.concat " ") in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 = hash_of_term body in
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 = weightToSmt wopt in
-                      let uu___10 =
-                        let uu___11 =
-                          let uu___12 =
-                            let uu___13 =
-                              FStar_Compiler_Effect.op_Bar_Greater pats
-                                (FStar_Compiler_List.map
-                                   (fun pats1 ->
-                                      let uu___14 =
-                                        FStar_Compiler_List.map hash_of_term
-                                          pats1 in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___14 (FStar_String.concat " "))) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___13
-                              (FStar_String.concat "; ") in
-                          Prims.op_Hat uu___12 "))" in
-                        Prims.op_Hat " " uu___11 in
-                      Prims.op_Hat uu___9 uu___10 in
-                    Prims.op_Hat " " uu___8 in
-                  Prims.op_Hat uu___6 uu___7 in
-                Prims.op_Hat ")(! " uu___5 in
-              Prims.op_Hat uu___3 uu___4 in
-            Prims.op_Hat " (" uu___2 in
-          Prims.op_Hat (qop_to_string qop1) uu___1 in
-        Prims.op_Hat "(" uu___
-    | Let (es, body) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_List.map hash_of_term es in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (FStar_String.concat " ") in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = hash_of_term body in Prims.op_Hat uu___4 ")" in
-            Prims.op_Hat ") " uu___3 in
-          Prims.op_Hat uu___1 uu___2 in
-        Prims.op_Hat "(let (" uu___
-and (hash_of_term : term -> Prims.string) = fun tm -> hash_of_term' tm.tm
-let (mkBoxFunctions : Prims.string -> (Prims.string * Prims.string)) =
-  fun s -> (s, (Prims.op_Hat s "_proj_0"))
-let (boxIntFun : (Prims.string * Prims.string)) = mkBoxFunctions "BoxInt"
-let (boxBoolFun : (Prims.string * Prims.string)) = mkBoxFunctions "BoxBool"
-let (boxStringFun : (Prims.string * Prims.string)) =
-  mkBoxFunctions "BoxString"
-let (boxBitVecFun : Prims.int -> (Prims.string * Prims.string)) =
-  fun sz ->
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.string_of_int sz in
-      Prims.op_Hat "BoxBitVec" uu___1 in
-    mkBoxFunctions uu___
-let (boxRealFun : (Prims.string * Prims.string)) = mkBoxFunctions "BoxReal"
-let (isInjective : Prims.string -> Prims.bool) =
-  fun s ->
-    if (FStar_String.length s) >= (Prims.of_int (3))
-    then
-      (let uu___ = FStar_String.substring s Prims.int_zero (Prims.of_int (3)) in
-       uu___ = "Box") &&
-        (let uu___ =
-           let uu___1 = FStar_String.list_of_string s in
-           FStar_Compiler_List.existsML (fun c -> c = 46) uu___1 in
-         Prims.op_Negation uu___)
-    else false
-let (mk : term' -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun r ->
-      let uu___ = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-      { tm = t; freevars = uu___; rng = r }
-let (mkTrue : FStar_Compiler_Range.range -> term) =
-  fun r -> mk (App (TrueOp, [])) r
-let (mkFalse : FStar_Compiler_Range.range -> term) =
-  fun r -> mk (App (FalseOp, [])) r
-let (mkUnreachable : term) =
-  mk (App ((Var "Unreachable"), [])) FStar_Compiler_Range.dummyRange
-let (mkInteger : Prims.string -> FStar_Compiler_Range.range -> term) =
-  fun i ->
-    fun r ->
-      let uu___ =
-        let uu___1 = FStar_Compiler_Util.ensure_decimal i in Integer uu___1 in
-      mk uu___ r
-let (mkInteger' : Prims.int -> FStar_Compiler_Range.range -> term) =
-  fun i ->
-    fun r ->
-      let uu___ = FStar_Compiler_Util.string_of_int i in mkInteger uu___ r
-let (mkReal : Prims.string -> FStar_Compiler_Range.range -> term) =
-  fun i -> fun r -> mk (Real i) r
-let (mkBoundV : Prims.int -> FStar_Compiler_Range.range -> term) =
-  fun i -> fun r -> mk (BoundV i) r
-let (mkFreeV : fv -> FStar_Compiler_Range.range -> term) =
-  fun x -> fun r -> mk (FreeV x) r
-let (mkApp' : (op * term Prims.list) -> FStar_Compiler_Range.range -> term) =
-  fun f -> fun r -> mk (App f) r
-let (mkApp :
-  (Prims.string * term Prims.list) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r -> match uu___ with | (s, args) -> mk (App ((Var s), args)) r
-let (mkNot : term -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun r ->
-      match t.tm with
-      | App (TrueOp, uu___) -> mkFalse r
-      | App (FalseOp, uu___) -> mkTrue r
-      | uu___ -> mkApp' (Not, [t]) r
-let (mkAnd : (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (t1, t2) ->
-          (match ((t1.tm), (t2.tm)) with
-           | (App (TrueOp, uu___1), uu___2) -> t2
-           | (uu___1, App (TrueOp, uu___2)) -> t1
-           | (App (FalseOp, uu___1), uu___2) -> mkFalse r
-           | (uu___1, App (FalseOp, uu___2)) -> mkFalse r
-           | (App (And, ts1), App (And, ts2)) ->
-               mkApp' (And, (FStar_Compiler_List.op_At ts1 ts2)) r
-           | (uu___1, App (And, ts2)) -> mkApp' (And, (t1 :: ts2)) r
-           | (App (And, ts1), uu___1) ->
-               mkApp' (And, (FStar_Compiler_List.op_At ts1 [t2])) r
-           | uu___1 -> mkApp' (And, [t1; t2]) r)
-let (mkOr : (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (t1, t2) ->
-          (match ((t1.tm), (t2.tm)) with
-           | (App (TrueOp, uu___1), uu___2) -> mkTrue r
-           | (uu___1, App (TrueOp, uu___2)) -> mkTrue r
-           | (App (FalseOp, uu___1), uu___2) -> t2
-           | (uu___1, App (FalseOp, uu___2)) -> t1
-           | (App (Or, ts1), App (Or, ts2)) ->
-               mkApp' (Or, (FStar_Compiler_List.op_At ts1 ts2)) r
-           | (uu___1, App (Or, ts2)) -> mkApp' (Or, (t1 :: ts2)) r
-           | (App (Or, ts1), uu___1) ->
-               mkApp' (Or, (FStar_Compiler_List.op_At ts1 [t2])) r
-           | uu___1 -> mkApp' (Or, [t1; t2]) r)
-let (mkImp : (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (t1, t2) ->
-          (match ((t1.tm), (t2.tm)) with
-           | (uu___1, App (TrueOp, uu___2)) -> mkTrue r
-           | (App (FalseOp, uu___1), uu___2) -> mkTrue r
-           | (App (TrueOp, uu___1), uu___2) -> t2
-           | (uu___1, App (Imp, t1'::t2'::[])) ->
-               let uu___2 =
-                 let uu___3 = let uu___4 = mkAnd (t1, t1') r in [uu___4; t2'] in
-                 (Imp, uu___3) in
-               mkApp' uu___2 r
-           | uu___1 -> mkApp' (Imp, [t1; t2]) r)
-let (mk_bin_op : op -> (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun op1 ->
-    fun uu___ ->
-      fun r -> match uu___ with | (t1, t2) -> mkApp' (op1, [t1; t2]) r
-let (mkMinus : term -> FStar_Compiler_Range.range -> term) =
-  fun t -> fun r -> mkApp' (Minus, [t]) r
-let (mkNatToBv : Prims.int -> term -> FStar_Compiler_Range.range -> term) =
-  fun sz -> fun t -> fun r -> mkApp' ((NatToBv sz), [t]) r
-let (mkBvUext : Prims.int -> term -> FStar_Compiler_Range.range -> term) =
-  fun sz -> fun t -> fun r -> mkApp' ((BvUext sz), [t]) r
-let (mkBvToNat : term -> FStar_Compiler_Range.range -> term) =
-  fun t -> fun r -> mkApp' (BvToNat, [t]) r
-let (mkBvAnd : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op BvAnd
-let (mkBvXor : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op BvXor
-let (mkBvOr : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op BvOr
-let (mkBvAdd : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op BvAdd
-let (mkBvSub : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op BvSub
-let (mkBvShl :
-  Prims.int -> (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun sz ->
-    fun uu___ ->
-      fun r ->
-        match uu___ with
-        | (t1, t2) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = let uu___4 = mkNatToBv sz t2 r in [uu___4] in t1
-                  :: uu___3 in
-              (BvShl, uu___2) in
-            mkApp' uu___1 r
-let (mkBvShr :
-  Prims.int -> (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun sz ->
-    fun uu___ ->
-      fun r ->
-        match uu___ with
-        | (t1, t2) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = let uu___4 = mkNatToBv sz t2 r in [uu___4] in t1
-                  :: uu___3 in
-              (BvShr, uu___2) in
-            mkApp' uu___1 r
-let (mkBvUdiv :
-  Prims.int -> (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun sz ->
-    fun uu___ ->
-      fun r ->
-        match uu___ with
-        | (t1, t2) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = let uu___4 = mkNatToBv sz t2 r in [uu___4] in t1
-                  :: uu___3 in
-              (BvUdiv, uu___2) in
-            mkApp' uu___1 r
-let (mkBvMod :
-  Prims.int -> (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun sz ->
-    fun uu___ ->
-      fun r ->
-        match uu___ with
-        | (t1, t2) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = let uu___4 = mkNatToBv sz t2 r in [uu___4] in t1
-                  :: uu___3 in
-              (BvMod, uu___2) in
-            mkApp' uu___1 r
-let (mkBvMul :
-  Prims.int -> (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun sz ->
-    fun uu___ ->
-      fun r ->
-        match uu___ with
-        | (t1, t2) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = let uu___4 = mkNatToBv sz t2 r in [uu___4] in t1
-                  :: uu___3 in
-              (BvMul, uu___2) in
-            mkApp' uu___1 r
-let (mkBvUlt : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op BvUlt
-let (mkIff : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op Iff
-let (mkEq : (term * term) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (t1, t2) ->
-          (match ((t1.tm), (t2.tm)) with
-           | (App (Var f1, s1::[]), App (Var f2, s2::[])) when
-               (f1 = f2) && (isInjective f1) -> mk_bin_op Eq (s1, s2) r
-           | uu___1 -> mk_bin_op Eq (t1, t2) r)
-let (mkLT : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op LT
-let (mkLTE : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op LTE
-let (mkGT : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op GT
-let (mkGTE : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op GTE
-let (mkAdd : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op Add
-let (mkSub : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op Sub
-let (mkDiv : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op Div
-let (mkRealDiv : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op RealDiv
-let (mkMul : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op Mul
-let (mkMod : (term * term) -> FStar_Compiler_Range.range -> term) =
-  mk_bin_op Mod
-let (mkRealOfInt : term -> FStar_Compiler_Range.range -> term) =
-  fun t -> fun r -> mkApp ("to_real", [t]) r
-let (mkITE : (term * term * term) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (t1, t2, t3) ->
-          (match t1.tm with
-           | App (TrueOp, uu___1) -> t2
-           | App (FalseOp, uu___1) -> t3
-           | uu___1 ->
-               (match ((t2.tm), (t3.tm)) with
-                | (App (TrueOp, uu___2), App (TrueOp, uu___3)) -> mkTrue r
-                | (App (TrueOp, uu___2), uu___3) ->
-                    let uu___4 = let uu___5 = mkNot t1 t1.rng in (uu___5, t3) in
-                    mkImp uu___4 r
-                | (uu___2, App (TrueOp, uu___3)) -> mkImp (t1, t2) r
-                | (uu___2, uu___3) -> mkApp' (ITE, [t1; t2; t3]) r))
-let (mkCases : term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun r ->
-      match t with
-      | [] -> failwith "Impos"
-      | hd::tl ->
-          FStar_Compiler_List.fold_left
-            (fun out -> fun t1 -> mkAnd (out, t1) r) hd tl
-let (check_pattern_ok : term -> term FStar_Pervasives_Native.option) =
-  fun t ->
-    let rec aux t1 =
-      match t1.tm with
-      | Integer uu___ -> FStar_Pervasives_Native.None
-      | String uu___ -> FStar_Pervasives_Native.None
-      | Real uu___ -> FStar_Pervasives_Native.None
-      | BoundV uu___ -> FStar_Pervasives_Native.None
-      | FreeV uu___ -> FStar_Pervasives_Native.None
-      | Let (tms, tm) -> aux_l (tm :: tms)
-      | App (head, terms) ->
-          let head_ok =
-            match head with
-            | Var uu___ -> true
-            | TrueOp -> true
-            | FalseOp -> true
-            | Not -> false
-            | And -> false
-            | Or -> false
-            | Imp -> false
-            | Iff -> false
-            | Eq -> false
-            | LT -> true
-            | LTE -> true
-            | GT -> true
-            | GTE -> true
-            | Add -> true
-            | Sub -> true
-            | Div -> true
-            | RealDiv -> true
-            | Mul -> true
-            | Minus -> true
-            | Mod -> true
-            | BvAnd -> false
-            | BvXor -> false
-            | BvOr -> false
-            | BvAdd -> false
-            | BvSub -> false
-            | BvShl -> false
-            | BvShr -> false
-            | BvUdiv -> false
-            | BvMod -> false
-            | BvMul -> false
-            | BvUlt -> false
-            | BvUext uu___ -> false
-            | NatToBv uu___ -> false
-            | BvToNat -> false
-            | ITE -> false in
-          if Prims.op_Negation head_ok
-          then FStar_Pervasives_Native.Some t1
-          else aux_l terms
-      | Labeled (t2, uu___, uu___1) -> aux t2
-      | Quant uu___ -> FStar_Pervasives_Native.Some t1
-      | LblPos uu___ -> FStar_Pervasives_Native.Some t1
-    and aux_l ts =
-      match ts with
-      | [] -> FStar_Pervasives_Native.None
-      | t1::ts1 ->
-          let uu___ = aux t1 in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some t2 ->
-               FStar_Pervasives_Native.Some t2
-           | FStar_Pervasives_Native.None -> aux_l ts1) in
-    aux t
-let rec (print_smt_term : term -> Prims.string) =
-  fun t ->
-    match t.tm with
-    | Integer n -> FStar_Compiler_Util.format1 "(Integer %s)" n
-    | String s -> FStar_Compiler_Util.format1 "(String %s)" s
-    | Real r -> FStar_Compiler_Util.format1 "(Real %s)" r
-    | BoundV n ->
-        let uu___ = FStar_Compiler_Util.string_of_int n in
-        FStar_Compiler_Util.format1 "(BoundV %s)" uu___
-    | FreeV fv1 ->
-        let uu___ = fv_name fv1 in
-        FStar_Compiler_Util.format1 "(FreeV %s)" uu___
-    | App (op1, l) ->
-        let uu___ = op_to_string op1 in
-        let uu___1 = print_smt_term_list l in
-        FStar_Compiler_Util.format2 "(%s %s)" uu___ uu___1
-    | Labeled (t1, r1, r2) ->
-        let uu___ = print_smt_term t1 in
-        FStar_Compiler_Util.format2 "(Labeled '%s' %s)" r1 uu___
-    | LblPos (t1, s) ->
-        let uu___ = print_smt_term t1 in
-        FStar_Compiler_Util.format2 "(LblPos %s %s)" s uu___
-    | Quant (qop1, l, uu___, uu___1, t1) ->
-        let uu___2 = print_smt_term_list_list l in
-        let uu___3 = print_smt_term t1 in
-        FStar_Compiler_Util.format3 "(%s %s %s)" (qop_to_string qop1) uu___2
-          uu___3
-    | Let (es, body) ->
-        let uu___ = print_smt_term_list es in
-        let uu___1 = print_smt_term body in
-        FStar_Compiler_Util.format2 "(let %s %s)" uu___ uu___1
-and (print_smt_term_list : term Prims.list -> Prims.string) =
-  fun l ->
-    let uu___ = FStar_Compiler_List.map print_smt_term l in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat " ")
-and (print_smt_term_list_list : term Prims.list Prims.list -> Prims.string) =
-  fun l ->
-    FStar_Compiler_List.fold_left
-      (fun s ->
-         fun l1 ->
-           let uu___ =
-             let uu___1 =
-               let uu___2 = print_smt_term_list l1 in
-               Prims.op_Hat uu___2 " ] " in
-             Prims.op_Hat "; [ " uu___1 in
-           Prims.op_Hat s uu___) "" l
-let (mkQuant :
-  FStar_Compiler_Range.range ->
-    Prims.bool ->
-      (qop * term Prims.list Prims.list * Prims.int
-        FStar_Pervasives_Native.option * sort Prims.list * term) -> term)
-  =
-  fun r ->
-    fun check_pats ->
-      fun uu___ ->
-        match uu___ with
-        | (qop1, pats, wopt, vars, body) ->
-            let all_pats_ok pats1 =
-              if Prims.op_Negation check_pats
-              then pats1
-              else
-                (let uu___2 =
-                   FStar_Compiler_Util.find_map pats1
-                     (fun x ->
-                        FStar_Compiler_Util.find_map x check_pattern_ok) in
-                 match uu___2 with
-                 | FStar_Pervasives_Native.None -> pats1
-                 | FStar_Pervasives_Native.Some p ->
-                     ((let uu___4 =
-                         let uu___5 =
-                           let uu___6 = print_smt_term p in
-                           FStar_Compiler_Util.format1
-                             "Pattern (%s) contains illegal symbols; dropping it"
-                             uu___6 in
-                         (FStar_Errors.Warning_SMTPatternIllFormed, uu___5) in
-                       FStar_Errors.log_issue r uu___4);
-                      [])) in
-            if (FStar_Compiler_List.length vars) = Prims.int_zero
-            then body
-            else
-              (match body.tm with
-               | App (TrueOp, uu___2) -> body
-               | uu___2 ->
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = all_pats_ok pats in
-                       (qop1, uu___5, wopt, vars, body) in
-                     Quant uu___4 in
-                   mk uu___3 r)
-let (mkLet : (term Prims.list * term) -> FStar_Compiler_Range.range -> term)
-  =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (es, body) ->
-          if (FStar_Compiler_List.length es) = Prims.int_zero
-          then body
-          else mk (Let (es, body)) r
-let (abstr : fv Prims.list -> term -> term) =
-  fun fvs1 ->
-    fun t ->
-      let nvars = FStar_Compiler_List.length fvs1 in
-      let index_of fv1 =
-        let uu___ = FStar_Compiler_Util.try_find_index (fv_eq fv1) fvs1 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some i ->
-            FStar_Pervasives_Native.Some (nvars - (i + Prims.int_one)) in
-      let rec aux ix t1 =
-        let uu___ = FStar_Compiler_Effect.op_Bang t1.freevars in
-        match uu___ with
-        | FStar_Pervasives_Native.Some [] -> t1
-        | uu___1 ->
-            (match t1.tm with
-             | Integer uu___2 -> t1
-             | String uu___2 -> t1
-             | Real uu___2 -> t1
-             | BoundV uu___2 -> t1
-             | FreeV x ->
-                 let uu___2 = index_of x in
-                 (match uu___2 with
-                  | FStar_Pervasives_Native.None -> t1
-                  | FStar_Pervasives_Native.Some i ->
-                      mkBoundV (i + ix) t1.rng)
-             | App (op1, tms) ->
-                 let uu___2 =
-                   let uu___3 = FStar_Compiler_List.map (aux ix) tms in
-                   (op1, uu___3) in
-                 mkApp' uu___2 t1.rng
-             | Labeled (t2, r1, r2) ->
-                 let uu___2 =
-                   let uu___3 = let uu___4 = aux ix t2 in (uu___4, r1, r2) in
-                   Labeled uu___3 in
-                 mk uu___2 t2.rng
-             | LblPos (t2, r) ->
-                 let uu___2 =
-                   let uu___3 = let uu___4 = aux ix t2 in (uu___4, r) in
-                   LblPos uu___3 in
-                 mk uu___2 t2.rng
-             | Quant (qop1, pats, wopt, vars, body) ->
-                 let n = FStar_Compiler_List.length vars in
-                 let uu___2 =
-                   let uu___3 =
-                     FStar_Compiler_Effect.op_Bar_Greater pats
-                       (FStar_Compiler_List.map
-                          (FStar_Compiler_List.map (aux (ix + n)))) in
-                   let uu___4 = aux (ix + n) body in
-                   (qop1, uu___3, wopt, vars, uu___4) in
-                 mkQuant t1.rng false uu___2
-             | Let (es, body) ->
-                 let uu___2 =
-                   FStar_Compiler_List.fold_left
-                     (fun uu___3 ->
-                        fun e ->
-                          match uu___3 with
-                          | (ix1, l) ->
-                              let uu___4 =
-                                let uu___5 = aux ix1 e in uu___5 :: l in
-                              ((ix1 + Prims.int_one), uu___4)) (ix, []) es in
-                 (match uu___2 with
-                  | (ix1, es_rev) ->
-                      let uu___3 =
-                        let uu___4 = aux ix1 body in
-                        ((FStar_Compiler_List.rev es_rev), uu___4) in
-                      mkLet uu___3 t1.rng)) in
-      aux Prims.int_zero t
-let (inst : term Prims.list -> term -> term) =
-  fun tms ->
-    fun t ->
-      let tms1 = FStar_Compiler_List.rev tms in
-      let n = FStar_Compiler_List.length tms1 in
-      let rec aux shift t1 =
-        match t1.tm with
-        | Integer uu___ -> t1
-        | String uu___ -> t1
-        | Real uu___ -> t1
-        | FreeV uu___ -> t1
-        | BoundV i ->
-            if (Prims.int_zero <= (i - shift)) && ((i - shift) < n)
-            then FStar_Compiler_List.nth tms1 (i - shift)
-            else t1
-        | App (op1, tms2) ->
-            let uu___ =
-              let uu___1 = FStar_Compiler_List.map (aux shift) tms2 in
-              (op1, uu___1) in
-            mkApp' uu___ t1.rng
-        | Labeled (t2, r1, r2) ->
-            let uu___ =
-              let uu___1 = let uu___2 = aux shift t2 in (uu___2, r1, r2) in
-              Labeled uu___1 in
-            mk uu___ t2.rng
-        | LblPos (t2, r) ->
-            let uu___ =
-              let uu___1 = let uu___2 = aux shift t2 in (uu___2, r) in
-              LblPos uu___1 in
-            mk uu___ t2.rng
-        | Quant (qop1, pats, wopt, vars, body) ->
-            let m = FStar_Compiler_List.length vars in
-            let shift1 = shift + m in
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_Effect.op_Bar_Greater pats
-                  (FStar_Compiler_List.map
-                     (FStar_Compiler_List.map (aux shift1))) in
-              let uu___2 = aux shift1 body in
-              (qop1, uu___1, wopt, vars, uu___2) in
-            mkQuant t1.rng false uu___
-        | Let (es, body) ->
-            let uu___ =
-              FStar_Compiler_List.fold_left
-                (fun uu___1 ->
-                   fun e ->
-                     match uu___1 with
-                     | (ix, es1) ->
-                         let uu___2 =
-                           let uu___3 = aux shift e in uu___3 :: es1 in
-                         ((shift + Prims.int_one), uu___2)) (shift, []) es in
-            (match uu___ with
-             | (shift1, es_rev) ->
-                 let uu___1 =
-                   let uu___2 = aux shift1 body in
-                   ((FStar_Compiler_List.rev es_rev), uu___2) in
-                 mkLet uu___1 t1.rng) in
-      aux Prims.int_zero t
-let (subst : term -> fv -> term -> term) =
-  fun t -> fun fv1 -> fun s -> let uu___ = abstr [fv1] t in inst [s] uu___
-let (mkQuant' :
-  FStar_Compiler_Range.range ->
-    (qop * term Prims.list Prims.list * Prims.int
-      FStar_Pervasives_Native.option * fv Prims.list * term) -> term)
-  =
-  fun r ->
-    fun uu___ ->
-      match uu___ with
-      | (qop1, pats, wopt, vars, body) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater pats
-                (FStar_Compiler_List.map
-                   (FStar_Compiler_List.map (abstr vars))) in
-            let uu___3 = FStar_Compiler_List.map fv_sort vars in
-            let uu___4 = abstr vars body in
-            (qop1, uu___2, wopt, uu___3, uu___4) in
-          mkQuant r true uu___1
-let (mkForall :
-  FStar_Compiler_Range.range ->
-    (pat Prims.list Prims.list * fvs * term) -> term)
-  =
-  fun r ->
-    fun uu___ ->
-      match uu___ with
-      | (pats, vars, body) ->
-          mkQuant' r (Forall, pats, FStar_Pervasives_Native.None, vars, body)
-let (mkForall'' :
-  FStar_Compiler_Range.range ->
-    (pat Prims.list Prims.list * Prims.int FStar_Pervasives_Native.option *
-      sort Prims.list * term) -> term)
-  =
-  fun r ->
-    fun uu___ ->
-      match uu___ with
-      | (pats, wopt, sorts, body) ->
-          mkQuant r true (Forall, pats, wopt, sorts, body)
-let (mkForall' :
-  FStar_Compiler_Range.range ->
-    (pat Prims.list Prims.list * Prims.int FStar_Pervasives_Native.option *
-      fvs * term) -> term)
-  =
-  fun r ->
-    fun uu___ ->
-      match uu___ with
-      | (pats, wopt, vars, body) ->
-          mkQuant' r (Forall, pats, wopt, vars, body)
-let (mkExists :
-  FStar_Compiler_Range.range ->
-    (pat Prims.list Prims.list * fvs * term) -> term)
-  =
-  fun r ->
-    fun uu___ ->
-      match uu___ with
-      | (pats, vars, body) ->
-          mkQuant' r (Exists, pats, FStar_Pervasives_Native.None, vars, body)
-let (mkLet' :
-  ((fv * term) Prims.list * term) -> FStar_Compiler_Range.range -> term) =
-  fun uu___ ->
-    fun r ->
-      match uu___ with
-      | (bindings, body) ->
-          let uu___1 = FStar_Compiler_List.split bindings in
-          (match uu___1 with
-           | (vars, es) ->
-               let uu___2 = let uu___3 = abstr vars body in (es, uu___3) in
-               mkLet uu___2 r)
-let (norng : FStar_Compiler_Range.range) = FStar_Compiler_Range.dummyRange
-let (mkDefineFun :
-  (Prims.string * fv Prims.list * sort * term * caption) -> decl) =
-  fun uu___ ->
-    match uu___ with
-    | (nm, vars, s, tm, c) ->
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.map fv_sort vars in
-          let uu___3 = abstr vars tm in (nm, uu___2, s, uu___3, c) in
-        DefineFun uu___1
-let (constr_id_of_sort : sort -> Prims.string) =
-  fun sort1 ->
-    let uu___ = strSort sort1 in
-    FStar_Compiler_Util.format1 "%s_constr_id" uu___
-let (fresh_token : (Prims.string * sort) -> Prims.int -> decl) =
-  fun uu___ ->
-    fun id ->
-      match uu___ with
-      | (tok_name, sort1) ->
-          let a_name = Prims.op_Hat "fresh_token_" tok_name in
-          let a =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = mkInteger' id norng in
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 = constr_id_of_sort sort1 in
-                    let uu___7 =
-                      let uu___8 = mkApp (tok_name, []) norng in [uu___8] in
-                    (uu___6, uu___7) in
-                  mkApp uu___5 norng in
-                (uu___3, uu___4) in
-              mkEq uu___2 norng in
-            let uu___2 = escape a_name in
-            {
-              assumption_term = uu___1;
-              assumption_caption =
-                (FStar_Pervasives_Native.Some "fresh token");
-              assumption_name = uu___2;
-              assumption_fact_ids = []
-            } in
-          Assume a
-let (fresh_constructor :
-  FStar_Compiler_Range.range ->
-    (Prims.string * sort Prims.list * sort * Prims.int) -> decl)
-  =
-  fun rng ->
-    fun uu___ ->
-      match uu___ with
-      | (name, arg_sorts, sort1, id) ->
-          let id1 = FStar_Compiler_Util.string_of_int id in
-          let bvars =
-            FStar_Compiler_Effect.op_Bar_Greater arg_sorts
-              (FStar_Compiler_List.mapi
-                 (fun i ->
-                    fun s ->
-                      let uu___1 =
-                        let uu___2 =
-                          let uu___3 =
-                            let uu___4 = FStar_Compiler_Util.string_of_int i in
-                            Prims.op_Hat "x_" uu___4 in
-                          (uu___3, s) in
-                        mk_fv uu___2 in
-                      mkFreeV uu___1 norng)) in
-          let bvar_names = FStar_Compiler_List.map fv_of_term bvars in
-          let capp = mkApp (name, bvars) norng in
-          let cid_app =
-            let uu___1 =
-              let uu___2 = constr_id_of_sort sort1 in (uu___2, [capp]) in
-            mkApp uu___1 norng in
-          let a_name = Prims.op_Hat "constructor_distinct_" name in
-          let a =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = mkInteger id1 norng in (uu___5, cid_app) in
-                  mkEq uu___4 norng in
-                ([[capp]], bvar_names, uu___3) in
-              mkForall rng uu___2 in
-            let uu___2 = escape a_name in
-            {
-              assumption_term = uu___1;
-              assumption_caption =
-                (FStar_Pervasives_Native.Some "Constructor distinct");
-              assumption_name = uu___2;
-              assumption_fact_ids = []
-            } in
-          Assume a
-let (injective_constructor :
-  FStar_Compiler_Range.range ->
-    (Prims.string * constructor_field Prims.list * sort) -> decl Prims.list)
-  =
-  fun rng ->
-    fun uu___ ->
-      match uu___ with
-      | (name, fields, sort1) ->
-          let n_bvars = FStar_Compiler_List.length fields in
-          let bvar_name i =
-            let uu___1 = FStar_Compiler_Util.string_of_int i in
-            Prims.op_Hat "x_" uu___1 in
-          let bvar_index i = n_bvars - (i + Prims.int_one) in
-          let bvar i s =
-            let uu___1 =
-              let uu___2 = let uu___3 = bvar_name i in (uu___3, s) in
-              mk_fv uu___2 in
-            FStar_Compiler_Effect.op_Less_Bar mkFreeV uu___1 in
-          let bvars =
-            FStar_Compiler_Effect.op_Bar_Greater fields
-              (FStar_Compiler_List.mapi
-                 (fun i ->
-                    fun uu___1 ->
-                      match uu___1 with
-                      | (uu___2, s, uu___3) ->
-                          let uu___4 = bvar i s in uu___4 norng)) in
-          let bvar_names = FStar_Compiler_List.map fv_of_term bvars in
-          let capp = mkApp (name, bvars) norng in
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater fields
-              (FStar_Compiler_List.mapi
-                 (fun i ->
-                    fun uu___2 ->
-                      match uu___2 with
-                      | (name1, s, projectible) ->
-                          let cproj_app = mkApp (name1, [capp]) norng in
-                          let proj_name =
-                            DeclFun
-                              (name1, [sort1], s,
-                                (FStar_Pervasives_Native.Some "Projector")) in
-                          if projectible
-                          then
-                            let a =
-                              let uu___3 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      let uu___7 =
-                                        let uu___8 = bvar i s in uu___8 norng in
-                                      (cproj_app, uu___7) in
-                                    mkEq uu___6 norng in
-                                  ([[capp]], bvar_names, uu___5) in
-                                mkForall rng uu___4 in
-                              let uu___4 =
-                                escape
-                                  (Prims.op_Hat "projection_inverse_" name1) in
-                              {
-                                assumption_term = uu___3;
-                                assumption_caption =
-                                  (FStar_Pervasives_Native.Some
-                                     "Projection inverse");
-                                assumption_name = uu___4;
-                                assumption_fact_ids = []
-                              } in
-                            [proj_name; Assume a]
-                          else [proj_name])) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_List.flatten
-let (constructor_to_decl :
-  FStar_Compiler_Range.range -> constructor_t -> decl Prims.list) =
-  fun rng ->
-    fun uu___ ->
-      match uu___ with
-      | (name, fields, sort1, id, injective) ->
-          let injective1 = injective || true in
-          let field_sorts =
-            FStar_Compiler_Effect.op_Bar_Greater fields
-              (FStar_Compiler_List.map
-                 (fun uu___1 ->
-                    match uu___1 with | (uu___2, sort2, uu___3) -> sort2)) in
-          let cdecl =
-            DeclFun
-              (name, field_sorts, sort1,
-                (FStar_Pervasives_Native.Some "Constructor")) in
-          let cid = fresh_constructor rng (name, field_sorts, sort1, id) in
-          let disc =
-            let disc_name = Prims.op_Hat "is-" name in
-            let xfv = mk_fv ("x", sort1) in
-            let xx = mkFreeV xfv norng in
-            let disc_eq =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = constr_id_of_sort sort1 in (uu___4, [xx]) in
-                  mkApp uu___3 norng in
-                let uu___3 =
-                  let uu___4 = FStar_Compiler_Util.string_of_int id in
-                  mkInteger uu___4 norng in
-                (uu___2, uu___3) in
-              mkEq uu___1 norng in
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_Effect.op_Bar_Greater fields
-                  (FStar_Compiler_List.mapi
-                     (fun i ->
-                        fun uu___3 ->
-                          match uu___3 with
-                          | (proj, s, projectible) ->
-                              if projectible
-                              then
-                                let uu___4 = mkApp (proj, [xx]) norng in
-                                (uu___4, [])
-                              else
-                                (let fi =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Compiler_Util.string_of_int i in
-                                       Prims.op_Hat "f_" uu___7 in
-                                     (uu___6, s) in
-                                   mk_fv uu___5 in
-                                 let uu___5 = mkFreeV fi norng in
-                                 (uu___5, [fi])))) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_Compiler_List.split in
-            match uu___1 with
-            | (proj_terms, ex_vars) ->
-                let ex_vars1 = FStar_Compiler_List.flatten ex_vars in
-                let disc_inv_body =
-                  let uu___2 =
-                    let uu___3 = mkApp (name, proj_terms) norng in
-                    (xx, uu___3) in
-                  mkEq uu___2 norng in
-                let disc_inv_body1 =
-                  match ex_vars1 with
-                  | [] -> disc_inv_body
-                  | uu___2 -> mkExists norng ([], ex_vars1, disc_inv_body) in
-                let disc_ax = mkAnd (disc_eq, disc_inv_body1) norng in
-                let def =
-                  mkDefineFun
-                    (disc_name, [xfv], Bool_sort, disc_ax,
-                      (FStar_Pervasives_Native.Some
-                         "Discriminator definition")) in
-                def in
-          let projs =
-            if injective1
-            then injective_constructor rng (name, fields, sort1)
-            else [] in
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Util.format1 "<start constructor %s>" name in
-              Caption uu___3 in
-            uu___2 :: cdecl :: cid :: projs in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_Util.format1 "</end constructor %s>" name in
-                Caption uu___5 in
-              [uu___4] in
-            FStar_Compiler_List.op_At [disc] uu___3 in
-          FStar_Compiler_List.op_At uu___1 uu___2
-let (name_binders_inner :
-  Prims.string FStar_Pervasives_Native.option ->
-    fv Prims.list ->
-      Prims.int ->
-        sort Prims.list ->
-          (fv Prims.list * Prims.string Prims.list * Prims.int))
-  =
-  fun prefix_opt ->
-    fun outer_names ->
-      fun start ->
-        fun sorts ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater sorts
-              (FStar_Compiler_List.fold_left
-                 (fun uu___1 ->
-                    fun s ->
-                      match uu___1 with
-                      | (names, binders1, n) ->
-                          let prefix =
-                            match s with | Term_sort -> "@x" | uu___2 -> "@u" in
-                          let prefix1 =
-                            match prefix_opt with
-                            | FStar_Pervasives_Native.None -> prefix
-                            | FStar_Pervasives_Native.Some p ->
-                                Prims.op_Hat p prefix in
-                          let nm =
-                            let uu___2 = FStar_Compiler_Util.string_of_int n in
-                            Prims.op_Hat prefix1 uu___2 in
-                          let names1 =
-                            let uu___2 = mk_fv (nm, s) in uu___2 :: names in
-                          let b =
-                            let uu___2 = strSort s in
-                            FStar_Compiler_Util.format2 "(%s %s)" nm uu___2 in
-                          (names1, (b :: binders1), (n + Prims.int_one)))
-                 (outer_names, [], start)) in
-          match uu___ with
-          | (names, binders1, n) ->
-              (names, (FStar_Compiler_List.rev binders1), n)
-let (name_macro_binders :
-  sort Prims.list -> (fv Prims.list * Prims.string Prims.list)) =
-  fun sorts ->
-    let uu___ =
-      name_binders_inner (FStar_Pervasives_Native.Some "__") []
-        Prims.int_zero sorts in
-    match uu___ with
-    | (names, binders1, n) -> ((FStar_Compiler_List.rev names), binders1)
-let (termToSmt : Prims.bool -> Prims.string -> term -> Prims.string) =
-  let string_id_counter = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let string_cache = FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-  fun print_ranges ->
-    fun enclosing_name ->
-      fun t ->
-        let next_qid =
-          let ctr = FStar_Compiler_Util.mk_ref Prims.int_zero in
-          fun depth ->
-            let n = FStar_Compiler_Effect.op_Bang ctr in
-            FStar_Compiler_Util.incr ctr;
-            if n = Prims.int_zero
-            then enclosing_name
-            else
-              (let uu___2 = FStar_Compiler_Util.string_of_int n in
-               FStar_Compiler_Util.format2 "%s.%s" enclosing_name uu___2) in
-        let remove_guard_free pats =
-          FStar_Compiler_Effect.op_Bar_Greater pats
-            (FStar_Compiler_List.map
-               (fun ps ->
-                  FStar_Compiler_Effect.op_Bar_Greater ps
-                    (FStar_Compiler_List.map
-                       (fun tm ->
-                          match tm.tm with
-                          | App
-                              (Var "Prims.guard_free",
-                               { tm = BoundV uu___; freevars = uu___1;
-                                 rng = uu___2;_}::[])
-                              -> tm
-                          | App (Var "Prims.guard_free", p::[]) -> p
-                          | uu___ -> tm)))) in
-        let rec aux' depth n names t1 =
-          let aux1 = aux (depth + Prims.int_one) in
-          match t1.tm with
-          | Integer i -> i
-          | Real r -> r
-          | String s ->
-              let id_opt = FStar_Compiler_Util.smap_try_find string_cache s in
-              (match id_opt with
-               | FStar_Pervasives_Native.Some id -> id
-               | FStar_Pervasives_Native.None ->
-                   let id =
-                     let uu___ =
-                       FStar_Compiler_Effect.op_Bang string_id_counter in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___
-                       FStar_Compiler_Util.string_of_int in
-                   (FStar_Compiler_Util.incr string_id_counter;
-                    FStar_Compiler_Util.smap_add string_cache s id;
-                    id))
-          | BoundV i ->
-              let uu___ = FStar_Compiler_List.nth names i in
-              FStar_Compiler_Effect.op_Bar_Greater uu___ fv_name
-          | FreeV x when fv_force x ->
-              let uu___ =
-                let uu___1 = fv_name x in Prims.op_Hat uu___1 " Dummy_value)" in
-              Prims.op_Hat "(" uu___
-          | FreeV x -> fv_name x
-          | App (op1, []) -> op_to_string op1
-          | App (op1, tms) ->
-              let uu___ = op_to_string op1 in
-              let uu___1 =
-                let uu___2 = FStar_Compiler_List.map (aux1 n names) tms in
-                FStar_Compiler_Effect.op_Bar_Greater uu___2
-                  (FStar_String.concat "\n") in
-              FStar_Compiler_Util.format2 "(%s %s)" uu___ uu___1
-          | Labeled (t2, uu___, uu___1) -> aux1 n names t2
-          | LblPos (t2, s) ->
-              let uu___ = aux1 n names t2 in
-              FStar_Compiler_Util.format2 "(! %s :lblpos %s)" uu___ s
-          | Quant (qop1, pats, wopt, sorts, body) ->
-              let qid = next_qid () in
-              let uu___ =
-                name_binders_inner FStar_Pervasives_Native.None names n sorts in
-              (match uu___ with
-               | (names1, binders1, n1) ->
-                   let binders2 =
-                     FStar_Compiler_Effect.op_Bar_Greater binders1
-                       (FStar_String.concat " ") in
-                   let pats1 = remove_guard_free pats in
-                   let pats_str =
-                     match pats1 with
-                     | []::[] -> ";;no pats"
-                     | [] -> ";;no pats"
-                     | uu___1 ->
-                         let uu___2 =
-                           FStar_Compiler_Effect.op_Bar_Greater pats1
-                             (FStar_Compiler_List.map
-                                (fun pats2 ->
-                                   let uu___3 =
-                                     let uu___4 =
-                                       FStar_Compiler_List.map
-                                         (fun p ->
-                                            let uu___5 = aux1 n1 names1 p in
-                                            FStar_Compiler_Util.format1 "%s"
-                                              uu___5) pats2 in
-                                     FStar_String.concat " " uu___4 in
-                                   FStar_Compiler_Util.format1
-                                     "\n:pattern (%s)" uu___3)) in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___2
-                           (FStar_String.concat "\n") in
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = aux1 n1 names1 body in
-                         let uu___5 =
-                           let uu___6 = weightToSmt wopt in
-                           [uu___6; pats_str; qid] in
-                         uu___4 :: uu___5 in
-                       binders2 :: uu___3 in
-                     (qop_to_string qop1) :: uu___2 in
-                   FStar_Compiler_Util.format
-                     "(%s (%s)\n (! %s\n %s\n%s\n:qid %s))" uu___1)
-          | Let (es, body) ->
-              let uu___ =
-                FStar_Compiler_List.fold_left
-                  (fun uu___1 ->
-                     fun e ->
-                       match uu___1 with
-                       | (names0, binders1, n0) ->
-                           let nm =
-                             let uu___2 =
-                               FStar_Compiler_Util.string_of_int n0 in
-                             Prims.op_Hat "@lb" uu___2 in
-                           let names01 =
-                             let uu___2 = mk_fv (nm, Term_sort) in uu___2 ::
-                               names0 in
-                           let b =
-                             let uu___2 = aux1 n names e in
-                             FStar_Compiler_Util.format2 "(%s %s)" nm uu___2 in
-                           (names01, (b :: binders1), (n0 + Prims.int_one)))
-                  (names, [], n) es in
-              (match uu___ with
-               | (names1, binders1, n1) ->
-                   let uu___1 = aux1 n1 names1 body in
-                   FStar_Compiler_Util.format2 "(let (%s)\n%s)"
-                     (FStar_String.concat " " binders1) uu___1)
-        and aux depth n names t1 =
-          let s = aux' depth n names t1 in
-          if print_ranges && (t1.rng <> norng)
-          then
-            let uu___ = FStar_Compiler_Range.string_of_range t1.rng in
-            let uu___1 = FStar_Compiler_Range.string_of_use_range t1.rng in
-            FStar_Compiler_Util.format3 "\n;; def=%s; use=%s\n%s\n" uu___
-              uu___1 s
-          else s in
-        aux Prims.int_zero Prims.int_zero [] t
-let (caption_to_string :
-  Prims.bool -> Prims.string FStar_Pervasives_Native.option -> Prims.string)
-  =
-  fun print_captions ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some c when print_captions ->
-          let c1 =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                (FStar_String.split [10] c)
-                (FStar_Compiler_List.map FStar_Compiler_Util.trim_string) in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (FStar_String.concat " ") in
-          Prims.op_Hat ";;;;;;;;;;;;;;;;" (Prims.op_Hat c1 "\n")
-      | uu___1 -> ""
-let rec (declToSmt' : Prims.bool -> Prims.string -> decl -> Prims.string) =
-  fun print_captions ->
-    fun z3options ->
-      fun decl1 ->
-        match decl1 with
-        | DefPrelude -> mkPrelude z3options
-        | Module (s, decls) ->
-            let res =
-              let uu___ =
-                FStar_Compiler_List.map (declToSmt' print_captions z3options)
-                  decls in
-              FStar_Compiler_Effect.op_Bar_Greater uu___
-                (FStar_String.concat "\n") in
-            let uu___ = FStar_Options.keep_query_captions () in
-            if uu___
-            then
-              let uu___1 =
-                FStar_Compiler_Util.string_of_int
-                  (FStar_Compiler_List.length decls) in
-              let uu___2 =
-                FStar_Compiler_Util.string_of_int (FStar_String.length res) in
-              FStar_Compiler_Util.format5
-                "\n;;; Start %s\n%s\n;;; End %s (%s decls; total size %s)" s
-                res s uu___1 uu___2
-            else res
-        | Caption c ->
-            if print_captions
-            then
-              let uu___ =
-                let uu___1 =
-                  FStar_Compiler_Effect.op_Bar_Greater
-                    (FStar_Compiler_Util.splitlines c)
-                    (FStar_Compiler_List.map
-                       (fun s -> Prims.op_Hat "; " (Prims.op_Hat s "\n"))) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___1
-                  (FStar_String.concat "") in
-              Prims.op_Hat "\n" uu___
-            else ""
-        | DeclFun (f, argsorts, retsort, c) ->
-            let l = FStar_Compiler_List.map strSort argsorts in
-            let uu___ = caption_to_string print_captions c in
-            let uu___1 = strSort retsort in
-            FStar_Compiler_Util.format4 "%s(declare-fun %s (%s) %s)" uu___ f
-              (FStar_String.concat " " l) uu___1
-        | DefineFun (f, arg_sorts, retsort, body, c) ->
-            let uu___ = name_macro_binders arg_sorts in
-            (match uu___ with
-             | (names, binders1) ->
-                 let body1 =
-                   let uu___1 =
-                     FStar_Compiler_List.map (fun x -> mkFreeV x norng) names in
-                   inst uu___1 body in
-                 let uu___1 = caption_to_string print_captions c in
-                 let uu___2 = strSort retsort in
-                 let uu___3 =
-                   let uu___4 = escape f in
-                   termToSmt print_captions uu___4 body1 in
-                 FStar_Compiler_Util.format5 "%s(define-fun %s (%s) %s\n %s)"
-                   uu___1 f (FStar_String.concat " " binders1) uu___2 uu___3)
-        | Assume a ->
-            let fact_ids_to_string ids =
-              FStar_Compiler_Effect.op_Bar_Greater ids
-                (FStar_Compiler_List.map
-                   (fun uu___ ->
-                      match uu___ with
-                      | Name n ->
-                          let uu___1 = FStar_Ident.string_of_lid n in
-                          Prims.op_Hat "Name " uu___1
-                      | Namespace ns ->
-                          let uu___1 = FStar_Ident.string_of_lid ns in
-                          Prims.op_Hat "Namespace " uu___1
-                      | Tag t -> Prims.op_Hat "Tag " t)) in
-            let fids =
-              if print_captions
-              then
-                let uu___ =
-                  let uu___1 = fact_ids_to_string a.assumption_fact_ids in
-                  FStar_String.concat "; " uu___1 in
-                FStar_Compiler_Util.format1 ";;; Fact-ids: %s\n" uu___
-              else "" in
-            let n = a.assumption_name in
-            let uu___ = caption_to_string print_captions a.assumption_caption in
-            let uu___1 = termToSmt print_captions n a.assumption_term in
-            FStar_Compiler_Util.format4 "%s%s(assert (! %s\n:named %s))"
-              uu___ fids uu___1 n
-        | Eval t ->
-            let uu___ = termToSmt print_captions "eval" t in
-            FStar_Compiler_Util.format1 "(eval %s)" uu___
-        | Echo s -> FStar_Compiler_Util.format1 "(echo \"%s\")" s
-        | RetainAssumptions uu___ -> ""
-        | CheckSat ->
-            "(echo \"<result>\")\n(check-sat)\n(echo \"</result>\")"
-        | GetUnsatCore ->
-            "(echo \"<unsat-core>\")\n(get-unsat-core)\n(echo \"</unsat-core>\")"
-        | Push -> "(push)"
-        | Pop -> "(pop)"
-        | SetOption (s, v) ->
-            FStar_Compiler_Util.format2 "(set-option :%s %s)" s v
-        | GetStatistics ->
-            "(echo \"<statistics>\")\n(get-info :all-statistics)\n(echo \"</statistics>\")"
-        | GetReasonUnknown ->
-            "(echo \"<reason-unknown>\")\n(get-info :reason-unknown)\n(echo \"</reason-unknown>\")"
-and (declToSmt : Prims.string -> decl -> Prims.string) =
-  fun z3options ->
-    fun decl1 ->
-      let uu___ = FStar_Options.keep_query_captions () in
-      declToSmt' uu___ z3options decl1
-and (mkPrelude : Prims.string -> Prims.string) =
-  fun z3options ->
-    let basic =
-      Prims.op_Hat z3options
-        "(declare-sort FString)\n(declare-fun FString_constr_id (FString) Int)\n\n(declare-sort Term)\n(declare-fun Term_constr_id (Term) Int)\n(declare-sort Dummy_sort)\n(declare-fun Dummy_value () Dummy_sort)\n(declare-datatypes () ((Fuel \n(ZFuel) \n(SFuel (prec Fuel)))))\n(declare-fun MaxIFuel () Fuel)\n(declare-fun MaxFuel () Fuel)\n(declare-fun PreType (Term) Term)\n(declare-fun Valid (Term) Bool)\n(declare-fun HasTypeFuel (Fuel Term Term) Bool)\n(define-fun HasTypeZ ((x Term) (t Term)) Bool\n(HasTypeFuel ZFuel x t))\n(define-fun HasType ((x Term) (t Term)) Bool\n(HasTypeFuel MaxIFuel x t))\n(declare-fun IsTotFun (Term) Bool)\n\n                ;;fuel irrelevance\n(assert (forall ((f Fuel) (x Term) (t Term))\n(! (= (HasTypeFuel (SFuel f) x t)\n(HasTypeZ x t))\n:pattern ((HasTypeFuel (SFuel f) x t)))))\n(declare-fun NoHoist (Term Bool) Bool)\n;;no-hoist\n(assert (forall ((dummy Term) (b Bool))\n(! (= (NoHoist dummy b)\nb)\n:pattern ((NoHoist dummy b)))))\n(define-fun  IsTyped ((x Term)) Bool\n(exists ((t Term)) (HasTypeZ x t)))\n(declare-fun ApplyTF (Term Fuel) Term)\n(declare-fun ApplyTT (Term Term) Term)\n(declare-fun Prec (Term Term) Bool)\n(assert (forall ((x Term) (y Term) (z Term))\n(! (implies (and (Prec x y) (Prec y z))\n(Prec x z))\n                                   :pattern ((Prec x z) (Prec x y)))))\n(assert (forall ((x Term) (y Term))\n(implies (Prec x y)\n(not (Prec y x)))))\n(declare-fun Closure (Term) Term)\n(declare-fun ConsTerm (Term Term) Term)\n(declare-fun ConsFuel (Fuel Term) Term)\n(declare-fun Tm_uvar (Int) Term)\n(define-fun Reify ((x Term)) Term x)\n(declare-fun Prims.precedes (Term Term Term Term) Term)\n(declare-fun Range_const (Int) Term)\n(declare-fun _mul (Int Int) Int)\n(declare-fun _div (Int Int) Int)\n(declare-fun _mod (Int Int) Int)\n(declare-fun __uu__PartialApp () Term)\n(assert (forall ((x Int) (y Int)) (! (= (_mul x y) (* x y)) :pattern ((_mul x y)))))\n(assert (forall ((x Int) (y Int)) (! (= (_div x y) (div x y)) :pattern ((_div x y)))))\n(assert (forall ((x Int) (y Int)) (! (= (_mod x y) (mod x y)) :pattern ((_mod x y)))))\n(declare-fun _rmul (Real Real) Real)\n(declare-fun _rdiv (Real Real) Real)\n(assert (forall ((x Real) (y Real)) (! (= (_rmul x y) (* x y)) :pattern ((_rmul x y)))))\n(assert (forall ((x Real) (y Real)) (! (= (_rdiv x y) (/ x y)) :pattern ((_rdiv x y)))))\n(define-fun Unreachable () Bool false)" in
-    let constrs =
-      [("FString_const", [("FString_const_proj_0", Int_sort, true)],
-         String_sort, Prims.int_zero, true);
-      ("Tm_type", [], Term_sort, (Prims.of_int (2)), true);
-      ("Tm_arrow", [("Tm_arrow_id", Int_sort, true)], Term_sort,
-        (Prims.of_int (3)), false);
-      ("Tm_unit", [], Term_sort, (Prims.of_int (6)), true);
-      ((FStar_Pervasives_Native.fst boxIntFun),
-        [((FStar_Pervasives_Native.snd boxIntFun), Int_sort, true)],
-        Term_sort, (Prims.of_int (7)), true);
-      ((FStar_Pervasives_Native.fst boxBoolFun),
-        [((FStar_Pervasives_Native.snd boxBoolFun), Bool_sort, true)],
-        Term_sort, (Prims.of_int (8)), true);
-      ((FStar_Pervasives_Native.fst boxStringFun),
-        [((FStar_Pervasives_Native.snd boxStringFun), String_sort, true)],
-        Term_sort, (Prims.of_int (9)), true);
-      ((FStar_Pervasives_Native.fst boxRealFun),
-        [((FStar_Pervasives_Native.snd boxRealFun), (Sort "Real"), true)],
-        Term_sort, (Prims.of_int (10)), true)] in
-    let bcons =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater constrs
-            (FStar_Compiler_List.collect (constructor_to_decl norng)) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          (FStar_Compiler_List.map (declToSmt z3options)) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "\n") in
-    let precedes_partial_app =
-      "\n(declare-fun Prims.precedes@tok () Term)\n(assert\n(forall ((@x0 Term) (@x1 Term) (@x2 Term) (@x3 Term))\n(! (= (ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.precedes@tok\n@x0)\n@x1)\n@x2)\n@x3)\n(Prims.precedes @x0 @x1 @x2 @x3))\n\n:pattern ((ApplyTT (ApplyTT (ApplyTT (ApplyTT Prims.precedes@tok\n@x0)\n@x1)\n@x2)\n@x3)))))\n" in
-    let lex_ordering =
-      "\n(declare-fun Prims.lex_t () Term)\n(assert (forall ((t1 Term) (t2 Term) (e1 Term) (e2 Term))\n(! (iff (Valid (Prims.precedes t1 t2 e1 e2))\n(Valid (Prims.precedes Prims.lex_t Prims.lex_t e1 e2)))\n:pattern (Prims.precedes t1 t2 e1 e2))))\n(assert (forall ((t1 Term) (t2 Term))\n(! (iff (Valid (Prims.precedes Prims.lex_t Prims.lex_t t1 t2)) \n(Prec t1 t2))\n:pattern ((Prims.precedes Prims.lex_t Prims.lex_t t1 t2)))))\n" in
-    let valid_intro =
-      "(assert (forall ((e Term) (t Term))\n(! (implies (HasType e t)\n(Valid t))\n:pattern ((HasType e t)\n(Valid t))\n:qid __prelude_valid_intro)))\n" in
-    let valid_elim =
-      "(assert (forall ((t Term))\n(! (implies (Valid t)\n(exists ((e Term)) (HasType e t)))\n:pattern ((Valid t))\n:qid __prelude_valid_elim)))\n" in
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Options.smtencoding_valid_intro () in
-              if uu___5 then valid_intro else "" in
-            let uu___5 =
-              let uu___6 = FStar_Options.smtencoding_valid_elim () in
-              if uu___6 then valid_elim else "" in
-            Prims.op_Hat uu___4 uu___5 in
-          Prims.op_Hat lex_ordering uu___3 in
-        Prims.op_Hat precedes_partial_app uu___2 in
-      Prims.op_Hat bcons uu___1 in
-    Prims.op_Hat basic uu___
-let (declsToSmt : Prims.string -> decl Prims.list -> Prims.string) =
-  fun z3options ->
-    fun decls ->
-      let uu___ = FStar_Compiler_List.map (declToSmt z3options) decls in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "\n")
-let (declToSmt_no_caps : Prims.string -> decl -> Prims.string) =
-  fun z3options -> fun decl1 -> declToSmt' false z3options decl1
-let (mkBvConstructor : Prims.int -> decl Prims.list) =
-  fun sz ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = boxBitVecFun sz in FStar_Pervasives_Native.fst uu___2 in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 = boxBitVecFun sz in
-            FStar_Pervasives_Native.snd uu___5 in
-          (uu___4, (BitVec_sort sz), true) in
-        [uu___3] in
-      (uu___1, uu___2, Term_sort, ((Prims.of_int (12)) + sz), true) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (constructor_to_decl norng)
-let (__range_c : Prims.int FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref Prims.int_zero
-let (mk_Range_const : unit -> term) =
-  fun uu___ ->
-    let i = FStar_Compiler_Effect.op_Bang __range_c in
-    (let uu___2 =
-       let uu___3 = FStar_Compiler_Effect.op_Bang __range_c in
-       uu___3 + Prims.int_one in
-     FStar_Compiler_Effect.op_Colon_Equals __range_c uu___2);
-    (let uu___2 =
-       let uu___3 = let uu___4 = mkInteger' i norng in [uu___4] in
-       ("Range_const", uu___3) in
-     mkApp uu___2 norng)
-let (mk_Term_type : term) = mkApp ("Tm_type", []) norng
-let (mk_Term_app : term -> term -> FStar_Compiler_Range.range -> term) =
-  fun t1 -> fun t2 -> fun r -> mkApp ("Tm_app", [t1; t2]) r
-let (mk_Term_uvar : Prims.int -> FStar_Compiler_Range.range -> term) =
-  fun i ->
-    fun r ->
-      let uu___ =
-        let uu___1 = let uu___2 = mkInteger' i norng in [uu___2] in
-        ("Tm_uvar", uu___1) in
-      mkApp uu___ r
-let (mk_Term_unit : term) = mkApp ("Tm_unit", []) norng
-let (elim_box : Prims.bool -> Prims.string -> Prims.string -> term -> term) =
-  fun cond ->
-    fun u ->
-      fun v ->
-        fun t ->
-          match t.tm with
-          | App (Var v', t1::[]) when (v = v') && cond -> t1
-          | uu___ -> mkApp (u, [t]) t.rng
-let (maybe_elim_box : Prims.string -> Prims.string -> term -> term) =
-  fun u ->
-    fun v ->
-      fun t ->
-        let uu___ = FStar_Options.smtencoding_elim_box () in
-        elim_box uu___ u v t
-let (boxInt : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.fst boxIntFun)
-      (FStar_Pervasives_Native.snd boxIntFun) t
-let (unboxInt : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.snd boxIntFun)
-      (FStar_Pervasives_Native.fst boxIntFun) t
-let (boxBool : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.fst boxBoolFun)
-      (FStar_Pervasives_Native.snd boxBoolFun) t
-let (unboxBool : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.snd boxBoolFun)
-      (FStar_Pervasives_Native.fst boxBoolFun) t
-let (boxString : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.fst boxStringFun)
-      (FStar_Pervasives_Native.snd boxStringFun) t
-let (unboxString : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.snd boxStringFun)
-      (FStar_Pervasives_Native.fst boxStringFun) t
-let (boxReal : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.fst boxRealFun)
-      (FStar_Pervasives_Native.snd boxRealFun) t
-let (unboxReal : term -> term) =
-  fun t ->
-    maybe_elim_box (FStar_Pervasives_Native.snd boxRealFun)
-      (FStar_Pervasives_Native.fst boxRealFun) t
-let (boxBitVec : Prims.int -> term -> term) =
-  fun sz ->
-    fun t ->
-      let uu___ =
-        let uu___1 = boxBitVecFun sz in FStar_Pervasives_Native.fst uu___1 in
-      let uu___1 =
-        let uu___2 = boxBitVecFun sz in FStar_Pervasives_Native.snd uu___2 in
-      elim_box true uu___ uu___1 t
-let (unboxBitVec : Prims.int -> term -> term) =
-  fun sz ->
-    fun t ->
-      let uu___ =
-        let uu___1 = boxBitVecFun sz in FStar_Pervasives_Native.snd uu___1 in
-      let uu___1 =
-        let uu___2 = boxBitVecFun sz in FStar_Pervasives_Native.fst uu___2 in
-      elim_box true uu___ uu___1 t
-let (boxTerm : sort -> term -> term) =
-  fun sort1 ->
-    fun t ->
-      match sort1 with
-      | Int_sort -> boxInt t
-      | Bool_sort -> boxBool t
-      | String_sort -> boxString t
-      | BitVec_sort sz -> boxBitVec sz t
-      | Sort "Real" -> boxReal t
-      | uu___ -> FStar_Compiler_Effect.raise FStar_Compiler_Util.Impos
-let (unboxTerm : sort -> term -> term) =
-  fun sort1 ->
-    fun t ->
-      match sort1 with
-      | Int_sort -> unboxInt t
-      | Bool_sort -> unboxBool t
-      | String_sort -> unboxString t
-      | BitVec_sort sz -> unboxBitVec sz t
-      | Sort "Real" -> unboxReal t
-      | uu___ -> FStar_Compiler_Effect.raise FStar_Compiler_Util.Impos
-let (getBoxedInteger : term -> Prims.int FStar_Pervasives_Native.option) =
-  fun t ->
-    match t.tm with
-    | App (Var s, t2::[]) when s = (FStar_Pervasives_Native.fst boxIntFun) ->
-        (match t2.tm with
-         | Integer n ->
-             let uu___ = FStar_Compiler_Util.int_of_string n in
-             FStar_Pervasives_Native.Some uu___
-         | uu___ -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (mk_PreType : term -> term) = fun t -> mkApp ("PreType", [t]) t.rng
-let (mk_Valid : term -> term) =
-  fun t ->
-    match t.tm with
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_Equality", uu___::t1::t2::[]);
-           freevars = uu___1; rng = uu___2;_}::[])
-        -> mkEq (t1, t2) t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_disEquality", uu___::t1::t2::[]);
-           freevars = uu___1; rng = uu___2;_}::[])
-        -> let uu___3 = mkEq (t1, t2) norng in mkNot uu___3 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_LessThanOrEqual", t1::t2::[]);
-           freevars = uu___; rng = uu___1;_}::[])
-        ->
-        let uu___2 =
-          let uu___3 = unboxInt t1 in
-          let uu___4 = unboxInt t2 in (uu___3, uu___4) in
-        mkLTE uu___2 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_LessThan", t1::t2::[]); freevars = uu___;
-           rng = uu___1;_}::[])
-        ->
-        let uu___2 =
-          let uu___3 = unboxInt t1 in
-          let uu___4 = unboxInt t2 in (uu___3, uu___4) in
-        mkLT uu___2 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_GreaterThanOrEqual", t1::t2::[]);
-           freevars = uu___; rng = uu___1;_}::[])
-        ->
-        let uu___2 =
-          let uu___3 = unboxInt t1 in
-          let uu___4 = unboxInt t2 in (uu___3, uu___4) in
-        mkGTE uu___2 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_GreaterThan", t1::t2::[]);
-           freevars = uu___; rng = uu___1;_}::[])
-        ->
-        let uu___2 =
-          let uu___3 = unboxInt t1 in
-          let uu___4 = unboxInt t2 in (uu___3, uu___4) in
-        mkGT uu___2 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_AmpAmp", t1::t2::[]); freevars = uu___;
-           rng = uu___1;_}::[])
-        ->
-        let uu___2 =
-          let uu___3 = unboxBool t1 in
-          let uu___4 = unboxBool t2 in (uu___3, uu___4) in
-        mkAnd uu___2 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_BarBar", t1::t2::[]); freevars = uu___;
-           rng = uu___1;_}::[])
-        ->
-        let uu___2 =
-          let uu___3 = unboxBool t1 in
-          let uu___4 = unboxBool t2 in (uu___3, uu___4) in
-        mkOr uu___2 t.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "Prims.op_Negation", t1::[]); freevars = uu___;
-           rng = uu___1;_}::[])
-        -> let uu___2 = unboxBool t1 in mkNot uu___2 t1.rng
-    | App
-        (Var "Prims.b2t",
-         { tm = App (Var "FStar.BV.bvult", t0::t1::t2::[]); freevars = uu___;
-           rng = uu___1;_}::[])
-        when
-        let uu___2 = getBoxedInteger t0 in FStar_Compiler_Util.is_some uu___2
-        ->
-        let sz =
-          let uu___2 = getBoxedInteger t0 in
-          match uu___2 with
-          | FStar_Pervasives_Native.Some sz1 -> sz1
-          | uu___3 -> failwith "impossible" in
-        let uu___2 =
-          let uu___3 = unboxBitVec sz t1 in
-          let uu___4 = unboxBitVec sz t2 in (uu___3, uu___4) in
-        mkBvUlt uu___2 t.rng
-    | App
-        (Var "Prims.equals",
-         uu___::{ tm = App (Var "FStar.BV.bvult", t0::t1::t2::[]);
-                  freevars = uu___1; rng = uu___2;_}::uu___3::[])
-        when
-        let uu___4 = getBoxedInteger t0 in FStar_Compiler_Util.is_some uu___4
-        ->
-        let sz =
-          let uu___4 = getBoxedInteger t0 in
-          match uu___4 with
-          | FStar_Pervasives_Native.Some sz1 -> sz1
-          | uu___5 -> failwith "impossible" in
-        let uu___4 =
-          let uu___5 = unboxBitVec sz t1 in
-          let uu___6 = unboxBitVec sz t2 in (uu___5, uu___6) in
-        mkBvUlt uu___4 t.rng
-    | App (Var "Prims.b2t", t1::[]) ->
-        let uu___ = unboxBool t1 in
-        { tm = (uu___.tm); freevars = (uu___.freevars); rng = (t.rng) }
-    | uu___ -> mkApp ("Valid", [t]) t.rng
-let (mk_unit_type : term) = mkApp ("Prims.unit", []) norng
-let (mk_subtype_of_unit : term -> term) =
-  fun v -> mkApp ("Prims.subtype_of", [v; mk_unit_type]) v.rng
-let (mk_HasType : term -> term -> term) =
-  fun v -> fun t -> mkApp ("HasType", [v; t]) t.rng
-let (mk_HasTypeZ : term -> term -> term) =
-  fun v -> fun t -> mkApp ("HasTypeZ", [v; t]) t.rng
-let (mk_IsTotFun : term -> term) = fun t -> mkApp ("IsTotFun", [t]) t.rng
-let (mk_HasTypeFuel : term -> term -> term -> term) =
-  fun f ->
-    fun v ->
-      fun t ->
-        let uu___ = FStar_Options.unthrottle_inductives () in
-        if uu___
-        then mk_HasType v t
-        else mkApp ("HasTypeFuel", [f; v; t]) t.rng
-let (mk_HasTypeWithFuel :
-  term FStar_Pervasives_Native.option -> term -> term -> term) =
-  fun f ->
-    fun v ->
-      fun t ->
-        match f with
-        | FStar_Pervasives_Native.None -> mk_HasType v t
-        | FStar_Pervasives_Native.Some f1 -> mk_HasTypeFuel f1 v t
-let (mk_NoHoist : term -> term -> term) =
-  fun dummy -> fun b -> mkApp ("NoHoist", [dummy; b]) b.rng
-let (mk_tester : Prims.string -> term -> term) =
-  fun n -> fun t -> mkApp ((Prims.op_Hat "is-" n), [t]) t.rng
-let (mk_ApplyTF : term -> term -> term) =
-  fun t -> fun t' -> mkApp ("ApplyTF", [t; t']) t.rng
-let (mk_ApplyTT : term -> term -> FStar_Compiler_Range.range -> term) =
-  fun t -> fun t' -> fun r -> mkApp ("ApplyTT", [t; t']) r
-let (kick_partial_app : term -> term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = mkApp ("__uu__PartialApp", []) t.rng in
-      mk_ApplyTT uu___1 t t.rng in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ mk_Valid
-let (mk_String_const : Prims.string -> FStar_Compiler_Range.range -> term) =
-  fun s ->
-    fun r ->
-      let uu___ =
-        let uu___1 = let uu___2 = mk (String s) r in [uu___2] in
-        ("FString_const", uu___1) in
-      mkApp uu___ r
-let (mk_Precedes :
-  term -> term -> term -> term -> FStar_Compiler_Range.range -> term) =
-  fun x1 ->
-    fun x2 ->
-      fun x3 ->
-        fun x4 ->
-          fun r ->
-            let uu___ = mkApp ("Prims.precedes", [x1; x2; x3; x4]) r in
-            FStar_Compiler_Effect.op_Bar_Greater uu___ mk_Valid
-let rec (n_fuel : Prims.int -> term) =
-  fun n ->
-    if n = Prims.int_zero
-    then mkApp ("ZFuel", []) norng
-    else
-      (let uu___1 =
-         let uu___2 = let uu___3 = n_fuel (n - Prims.int_one) in [uu___3] in
-         ("SFuel", uu___2) in
-       mkApp uu___1 norng)
-let (mk_and_l : term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun l ->
-    fun r ->
-      let uu___ = mkTrue r in
-      FStar_Compiler_List.fold_right (fun p1 -> fun p2 -> mkAnd (p1, p2) r) l
-        uu___
-let (mk_or_l : term Prims.list -> FStar_Compiler_Range.range -> term) =
-  fun l ->
-    fun r ->
-      let uu___ = mkFalse r in
-      FStar_Compiler_List.fold_right (fun p1 -> fun p2 -> mkOr (p1, p2) r) l
-        uu___
-let (mk_haseq : term -> term) =
-  fun t -> let uu___ = mkApp ("Prims.hasEq", [t]) t.rng in mk_Valid uu___
-let (dummy_sort : sort) = Sort "Dummy_sort"
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_Util.ml b/src/ocaml-output/FStar_SMTEncoding_Util.ml
deleted file mode 100644
index ac7a239eae5..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_Util.ml
+++ /dev/null
@@ -1,259 +0,0 @@
-open Prims
-let (mkAssume :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.caption *
-    Prims.string) -> FStar_SMTEncoding_Term.decl)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (tm, cap, nm) ->
-        let uu___1 =
-          let uu___2 = FStar_SMTEncoding_Term.escape nm in
-          {
-            FStar_SMTEncoding_Term.assumption_term = tm;
-            FStar_SMTEncoding_Term.assumption_caption = cap;
-            FStar_SMTEncoding_Term.assumption_name = uu___2;
-            FStar_SMTEncoding_Term.assumption_fact_ids = []
-          } in
-        FStar_SMTEncoding_Term.Assume uu___1
-let norng :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu -> FStar_Compiler_Range.range -> 'uuuuu1) -> 'uuuuu -> 'uuuuu1
-  = fun f -> fun x -> f x FStar_Compiler_Range.dummyRange
-let (mkTrue : FStar_SMTEncoding_Term.term) =
-  FStar_SMTEncoding_Term.mkTrue FStar_Compiler_Range.dummyRange
-let (mkFalse : FStar_SMTEncoding_Term.term) =
-  FStar_SMTEncoding_Term.mkFalse FStar_Compiler_Range.dummyRange
-let (mkInteger : Prims.string -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkInteger
-let (mkInteger' : Prims.int -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkInteger'
-let (mkReal : Prims.string -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkReal
-let (mkBoundV : Prims.int -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkBoundV
-let (mkFreeV : FStar_SMTEncoding_Term.fv -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkFreeV
-let (mkApp' :
-  (FStar_SMTEncoding_Term.op * FStar_SMTEncoding_Term.term Prims.list) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkApp'
-let (mkApp :
-  (Prims.string * FStar_SMTEncoding_Term.term Prims.list) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkApp
-let (mkNot : FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkNot
-let (mkMinus : FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkMinus
-let (mkAnd :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkAnd
-let (mkOr :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkOr
-let (mkImp :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkImp
-let (mkIff :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkIff
-let (mkEq :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkEq
-let (mkLT :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkLT
-let (mkLTE :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkLTE
-let (mkGT :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkGT
-let (mkGTE :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkGTE
-let (mkAdd :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkAdd
-let (mkSub :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkSub
-let (mkDiv :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkDiv
-let (mkRealDiv :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkRealDiv
-let (mkMul :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkMul
-let (mkMod :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkMod
-let (mkNatToBv :
-  Prims.int -> FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term) =
-  fun sz -> norng (FStar_SMTEncoding_Term.mkNatToBv sz)
-let (mkBvAnd :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvAnd
-let (mkBvXor :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvXor
-let (mkBvOr :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvOr
-let (mkBvAdd :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvAdd
-let (mkBvSub :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvSub
-let (mkBvShl :
-  Prims.int ->
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-      FStar_SMTEncoding_Term.term)
-  = fun sz -> norng (FStar_SMTEncoding_Term.mkBvShl sz)
-let (mkBvShr :
-  Prims.int ->
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-      FStar_SMTEncoding_Term.term)
-  = fun sz -> norng (FStar_SMTEncoding_Term.mkBvShr sz)
-let (mkBvUdiv :
-  Prims.int ->
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-      FStar_SMTEncoding_Term.term)
-  = fun sz -> norng (FStar_SMTEncoding_Term.mkBvUdiv sz)
-let (mkBvMod :
-  Prims.int ->
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-      FStar_SMTEncoding_Term.term)
-  = fun sz -> norng (FStar_SMTEncoding_Term.mkBvMod sz)
-let (mkBvMul :
-  Prims.int ->
-    (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-      FStar_SMTEncoding_Term.term)
-  = fun sz -> norng (FStar_SMTEncoding_Term.mkBvMul sz)
-let (mkBvUlt :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term) ->
-    FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvUlt
-let (mkBvUext :
-  Prims.int -> FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term) =
-  fun sz -> norng (FStar_SMTEncoding_Term.mkBvUext sz)
-let (mkBvToNat : FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkBvToNat
-let (mkITE :
-  (FStar_SMTEncoding_Term.term * FStar_SMTEncoding_Term.term *
-    FStar_SMTEncoding_Term.term) -> FStar_SMTEncoding_Term.term)
-  = norng FStar_SMTEncoding_Term.mkITE
-let (mkCases :
-  FStar_SMTEncoding_Term.term Prims.list -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mkCases
-let norng2 :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    ('uuuuu -> 'uuuuu1 -> FStar_Compiler_Range.range -> 'uuuuu2) ->
-      'uuuuu -> 'uuuuu1 -> 'uuuuu2
-  = fun f -> fun x -> fun y -> f x y FStar_Compiler_Range.dummyRange
-let norng3 :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 .
-    ('uuuuu -> 'uuuuu1 -> 'uuuuu2 -> FStar_Compiler_Range.range -> 'uuuuu3)
-      -> 'uuuuu -> 'uuuuu1 -> 'uuuuu2 -> 'uuuuu3
-  =
-  fun f -> fun x -> fun y -> fun z -> f x y z FStar_Compiler_Range.dummyRange
-let norng4 :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 'uuuuu4 .
-    ('uuuuu ->
-       'uuuuu1 -> 'uuuuu2 -> 'uuuuu3 -> FStar_Compiler_Range.range -> 'uuuuu4)
-      -> 'uuuuu -> 'uuuuu1 -> 'uuuuu2 -> 'uuuuu3 -> 'uuuuu4
-  =
-  fun f ->
-    fun x ->
-      fun y -> fun z -> fun w -> f x y z w FStar_Compiler_Range.dummyRange
-let (mk_Term_app :
-  FStar_SMTEncoding_Term.term ->
-    FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term)
-  = norng2 FStar_SMTEncoding_Term.mk_Term_app
-let (mk_Term_uvar : Prims.int -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mk_Term_uvar
-let (mk_and_l :
-  FStar_SMTEncoding_Term.term Prims.list -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mk_and_l
-let (mk_or_l :
-  FStar_SMTEncoding_Term.term Prims.list -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mk_or_l
-let (mk_ApplyTT :
-  FStar_SMTEncoding_Term.term ->
-    FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term)
-  = norng2 FStar_SMTEncoding_Term.mk_ApplyTT
-let (mk_String_const : Prims.string -> FStar_SMTEncoding_Term.term) =
-  norng FStar_SMTEncoding_Term.mk_String_const
-let (mk_Precedes :
-  FStar_SMTEncoding_Term.term ->
-    FStar_SMTEncoding_Term.term ->
-      FStar_SMTEncoding_Term.term ->
-        FStar_SMTEncoding_Term.term -> FStar_SMTEncoding_Term.term)
-  = norng4 FStar_SMTEncoding_Term.mk_Precedes
-let (is_smt_reifiable_effect :
-  FStar_TypeChecker_Env.env -> FStar_Ident.lident -> Prims.bool) =
-  fun en ->
-    fun l ->
-      let l1 = FStar_TypeChecker_Env.norm_eff_name en l in
-      (FStar_TypeChecker_Env.is_reifiable_effect en l1) &&
-        (let uu___ =
-           let uu___1 =
-             FStar_Compiler_Effect.op_Bar_Greater l1
-               (FStar_TypeChecker_Env.get_effect_decl en) in
-           FStar_Compiler_Effect.op_Bar_Greater uu___1
-             FStar_Syntax_Util.is_layered in
-         Prims.op_Negation uu___)
-let (is_smt_reifiable_comp :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.comp -> Prims.bool) =
-  fun en ->
-    fun c ->
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Comp ct ->
-          is_smt_reifiable_effect en ct.FStar_Syntax_Syntax.effect_name
-      | uu___ -> false
-let (is_smt_reifiable_rc :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.residual_comp -> Prims.bool)
-  =
-  fun en ->
-    fun rc ->
-      FStar_Compiler_Effect.op_Bar_Greater
-        rc.FStar_Syntax_Syntax.residual_effect (is_smt_reifiable_effect en)
-let (is_smt_reifiable_function :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun en ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-          let uu___2 =
-            FStar_Compiler_Effect.op_Bar_Greater c
-              FStar_Syntax_Util.comp_effect_name in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (is_smt_reifiable_effect en)
-      | uu___1 -> false
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_SMTEncoding_Z3.ml b/src/ocaml-output/FStar_SMTEncoding_Z3.ml
deleted file mode 100644
index 70cb38524e9..00000000000
--- a/src/ocaml-output/FStar_SMTEncoding_Z3.ml
+++ /dev/null
@@ -1,1047 +0,0 @@
-open Prims
-type unsat_core = Prims.string Prims.list FStar_Pervasives_Native.option
-type scope_t = FStar_SMTEncoding_Term.decl Prims.list Prims.list
-type z3status =
-  | UNSAT of unsat_core 
-  | SAT of (FStar_SMTEncoding_Term.error_labels * Prims.string
-  FStar_Pervasives_Native.option) 
-  | UNKNOWN of (FStar_SMTEncoding_Term.error_labels * Prims.string
-  FStar_Pervasives_Native.option) 
-  | TIMEOUT of (FStar_SMTEncoding_Term.error_labels * Prims.string
-  FStar_Pervasives_Native.option) 
-  | KILLED 
-let (uu___is_UNSAT : z3status -> Prims.bool) =
-  fun projectee -> match projectee with | UNSAT _0 -> true | uu___ -> false
-let (__proj__UNSAT__item___0 : z3status -> unsat_core) =
-  fun projectee -> match projectee with | UNSAT _0 -> _0
-let (uu___is_SAT : z3status -> Prims.bool) =
-  fun projectee -> match projectee with | SAT _0 -> true | uu___ -> false
-let (__proj__SAT__item___0 :
-  z3status ->
-    (FStar_SMTEncoding_Term.error_labels * Prims.string
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | SAT _0 -> _0
-let (uu___is_UNKNOWN : z3status -> Prims.bool) =
-  fun projectee -> match projectee with | UNKNOWN _0 -> true | uu___ -> false
-let (__proj__UNKNOWN__item___0 :
-  z3status ->
-    (FStar_SMTEncoding_Term.error_labels * Prims.string
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | UNKNOWN _0 -> _0
-let (uu___is_TIMEOUT : z3status -> Prims.bool) =
-  fun projectee -> match projectee with | TIMEOUT _0 -> true | uu___ -> false
-let (__proj__TIMEOUT__item___0 :
-  z3status ->
-    (FStar_SMTEncoding_Term.error_labels * Prims.string
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | TIMEOUT _0 -> _0
-let (uu___is_KILLED : z3status -> Prims.bool) =
-  fun projectee -> match projectee with | KILLED -> true | uu___ -> false
-type z3statistics = Prims.string FStar_Compiler_Util.smap
-type z3result =
-  {
-  z3result_status: z3status ;
-  z3result_time: Prims.int ;
-  z3result_statistics: z3statistics ;
-  z3result_query_hash: Prims.string FStar_Pervasives_Native.option ;
-  z3result_log_file: Prims.string FStar_Pervasives_Native.option }
-let (__proj__Mkz3result__item__z3result_status : z3result -> z3status) =
-  fun projectee ->
-    match projectee with
-    | { z3result_status; z3result_time; z3result_statistics;
-        z3result_query_hash; z3result_log_file;_} -> z3result_status
-let (__proj__Mkz3result__item__z3result_time : z3result -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { z3result_status; z3result_time; z3result_statistics;
-        z3result_query_hash; z3result_log_file;_} -> z3result_time
-let (__proj__Mkz3result__item__z3result_statistics :
-  z3result -> z3statistics) =
-  fun projectee ->
-    match projectee with
-    | { z3result_status; z3result_time; z3result_statistics;
-        z3result_query_hash; z3result_log_file;_} -> z3result_statistics
-let (__proj__Mkz3result__item__z3result_query_hash :
-  z3result -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { z3result_status; z3result_time; z3result_statistics;
-        z3result_query_hash; z3result_log_file;_} -> z3result_query_hash
-let (__proj__Mkz3result__item__z3result_log_file :
-  z3result -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { z3result_status; z3result_time; z3result_statistics;
-        z3result_query_hash; z3result_log_file;_} -> z3result_log_file
-type query_log =
-  {
-  get_module_name: unit -> Prims.string ;
-  set_module_name: Prims.string -> unit ;
-  write_to_log: Prims.bool -> Prims.string -> Prims.string ;
-  close_log: unit -> unit }
-let (__proj__Mkquery_log__item__get_module_name :
-  query_log -> unit -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { get_module_name; set_module_name; write_to_log; close_log;_} ->
-        get_module_name
-let (__proj__Mkquery_log__item__set_module_name :
-  query_log -> Prims.string -> unit) =
-  fun projectee ->
-    match projectee with
-    | { get_module_name; set_module_name; write_to_log; close_log;_} ->
-        set_module_name
-let (__proj__Mkquery_log__item__write_to_log :
-  query_log -> Prims.bool -> Prims.string -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { get_module_name; set_module_name; write_to_log; close_log;_} ->
-        write_to_log
-let (__proj__Mkquery_log__item__close_log : query_log -> unit -> unit) =
-  fun projectee ->
-    match projectee with
-    | { get_module_name; set_module_name; write_to_log; close_log;_} ->
-        close_log
-let (_z3version_checked : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref false
-let (_z3version_expected : Prims.string) = "Z3 version 4.8.5"
-let (_z3url : Prims.string) =
-  "https://github.com/FStarLang/binaries/tree/master/z3-tested"
-let (parse_z3_version_lines :
-  Prims.string -> Prims.string FStar_Pervasives_Native.option) =
-  fun out ->
-    match FStar_Compiler_Util.splitlines out with
-    | version::uu___ ->
-        if FStar_Compiler_Util.starts_with version _z3version_expected
-        then
-          ((let uu___2 = FStar_Options.debug_any () in
-            if uu___2
-            then
-              let uu___3 =
-                FStar_Compiler_Util.format1
-                  "Successfully found expected Z3 version %s\n" version in
-              FStar_Compiler_Util.print_string uu___3
-            else ());
-           FStar_Pervasives_Native.None)
-        else
-          (let msg =
-             FStar_Compiler_Util.format2
-               "Expected Z3 version \"%s\", got \"%s\"" _z3version_expected
-               out in
-           FStar_Pervasives_Native.Some msg)
-    | uu___ -> FStar_Pervasives_Native.Some "No Z3 version string found"
-let (z3version_warning_message :
-  unit ->
-    (FStar_Errors.raw_error * Prims.string) FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    let run_proc_result =
-      try
-        (fun uu___1 ->
-           match () with
-           | () ->
-               let uu___2 =
-                 let uu___3 = FStar_Options.z3_exe () in
-                 FStar_Compiler_Util.run_process "z3_version" uu___3
-                   ["-version"] FStar_Pervasives_Native.None in
-               FStar_Pervasives_Native.Some uu___2) ()
-      with | uu___1 -> FStar_Pervasives_Native.None in
-    match run_proc_result with
-    | FStar_Pervasives_Native.None ->
-        FStar_Pervasives_Native.Some
-          (FStar_Errors.Error_Z3InvocationError, "Could not run Z3")
-    | FStar_Pervasives_Native.Some out ->
-        let uu___1 = parse_z3_version_lines out in
-        (match uu___1 with
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-         | FStar_Pervasives_Native.Some msg ->
-             FStar_Pervasives_Native.Some
-               (FStar_Errors.Warning_Z3InvocationWarning, msg))
-let (check_z3version : unit -> unit) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang _z3version_checked in
-      Prims.op_Negation uu___2 in
-    if uu___1
-    then
-      (FStar_Compiler_Effect.op_Colon_Equals _z3version_checked true;
-       (let uu___3 = z3version_warning_message () in
-        match uu___3 with
-        | FStar_Pervasives_Native.None -> ()
-        | FStar_Pervasives_Native.Some (e, msg) ->
-            let msg1 =
-              FStar_Compiler_Util.format4 "%s\n%s\n%s\n%s\n" msg
-                "Please download the version of Z3 corresponding to your platform from:"
-                _z3url "and add the bin/ subdirectory into your PATH" in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange (e, msg1)))
-    else ()
-type label = Prims.string
-let (status_tag : z3status -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | SAT uu___1 -> "sat"
-    | UNSAT uu___1 -> "unsat"
-    | UNKNOWN uu___1 -> "unknown"
-    | TIMEOUT uu___1 -> "timeout"
-    | KILLED -> "killed"
-let (status_string_and_errors :
-  z3status -> (Prims.string * FStar_SMTEncoding_Term.error_labels)) =
-  fun s ->
-    match s with
-    | KILLED -> ((status_tag s), [])
-    | UNSAT uu___ -> ((status_tag s), [])
-    | SAT (errs, msg) ->
-        let uu___ =
-          FStar_Compiler_Util.format2 "%s%s" (status_tag s)
-            (match msg with
-             | FStar_Pervasives_Native.None -> ""
-             | FStar_Pervasives_Native.Some msg1 ->
-                 Prims.op_Hat " because " msg1) in
-        (uu___, errs)
-    | UNKNOWN (errs, msg) ->
-        let uu___ =
-          FStar_Compiler_Util.format2 "%s%s" (status_tag s)
-            (match msg with
-             | FStar_Pervasives_Native.None -> ""
-             | FStar_Pervasives_Native.Some msg1 ->
-                 Prims.op_Hat " because " msg1) in
-        (uu___, errs)
-    | TIMEOUT (errs, msg) ->
-        let uu___ =
-          FStar_Compiler_Util.format2 "%s%s" (status_tag s)
-            (match msg with
-             | FStar_Pervasives_Native.None -> ""
-             | FStar_Pervasives_Native.Some msg1 ->
-                 Prims.op_Hat " because " msg1) in
-        (uu___, errs)
-let (query_logging : query_log) =
-  let query_number = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let log_file_opt = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let used_file_names = FStar_Compiler_Util.mk_ref [] in
-  let current_module_name =
-    FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let current_file_name =
-    FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let set_module_name n =
-    FStar_Compiler_Effect.op_Colon_Equals current_module_name
-      (FStar_Pervasives_Native.Some n) in
-  let get_module_name uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang current_module_name in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> failwith "Module name not set"
-    | FStar_Pervasives_Native.Some n -> n in
-  let next_file_name uu___ =
-    let n = get_module_name () in
-    let file_name =
-      let uu___1 =
-        let uu___2 = FStar_Compiler_Effect.op_Bang used_file_names in
-        FStar_Compiler_List.tryFind
-          (fun uu___3 -> match uu___3 with | (m, uu___4) -> n = m) uu___2 in
-      match uu___1 with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___3 =
-              let uu___4 = FStar_Compiler_Effect.op_Bang used_file_names in
-              (n, Prims.int_zero) :: uu___4 in
-            FStar_Compiler_Effect.op_Colon_Equals used_file_names uu___3);
-           n)
-      | FStar_Pervasives_Native.Some (uu___2, k) ->
-          ((let uu___4 =
-              let uu___5 = FStar_Compiler_Effect.op_Bang used_file_names in
-              (n, (k + Prims.int_one)) :: uu___5 in
-            FStar_Compiler_Effect.op_Colon_Equals used_file_names uu___4);
-           (let uu___4 =
-              FStar_Compiler_Util.string_of_int (k + Prims.int_one) in
-            FStar_Compiler_Util.format2 "%s-%s" n uu___4)) in
-    FStar_Compiler_Util.format1 "queries-%s.smt2" file_name in
-  let new_log_file uu___ =
-    let file_name = next_file_name () in
-    FStar_Compiler_Effect.op_Colon_Equals current_file_name
-      (FStar_Pervasives_Native.Some file_name);
-    (let fh = FStar_Compiler_Util.open_file_for_writing file_name in
-     FStar_Compiler_Effect.op_Colon_Equals log_file_opt
-       (FStar_Pervasives_Native.Some (fh, file_name));
-     (fh, file_name)) in
-  let get_log_file uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang log_file_opt in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> new_log_file ()
-    | FStar_Pervasives_Native.Some fh -> fh in
-  let append_to_log str =
-    let uu___ = get_log_file () in
-    match uu___ with
-    | (f, nm) -> (FStar_Compiler_Util.append_to_file f str; nm) in
-  let write_to_new_log str =
-    let file_name = next_file_name () in
-    FStar_Compiler_Util.write_file file_name str; file_name in
-  let write_to_log fresh str =
-    if fresh then write_to_new_log str else append_to_log str in
-  let close_log uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang log_file_opt in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> ()
-    | FStar_Pervasives_Native.Some (fh, uu___2) ->
-        (FStar_Compiler_Util.close_file fh;
-         FStar_Compiler_Effect.op_Colon_Equals log_file_opt
-           FStar_Pervasives_Native.None) in
-  let log_file_name uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang current_file_name in
-    match uu___1 with
-    | FStar_Pervasives_Native.None -> failwith "no log file"
-    | FStar_Pervasives_Native.Some n -> n in
-  { get_module_name; set_module_name; write_to_log; close_log }
-let (z3_cmd_and_args : unit -> (Prims.string * Prims.string Prims.list)) =
-  fun uu___ ->
-    let cmd = FStar_Options.z3_exe () in
-    let cmd_args =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_Options.z3_seed () in
-                FStar_Compiler_Util.string_of_int uu___6 in
-              FStar_Compiler_Util.format1 "smt.random_seed=%s" uu___5 in
-            [uu___4] in
-          "-in" :: uu___3 in
-        "-smt2" :: uu___2 in
-      let uu___2 = FStar_Options.z3_cliopt () in
-      FStar_Compiler_List.append uu___1 uu___2 in
-    (cmd, cmd_args)
-let (new_z3proc :
-  Prims.string ->
-    (Prims.string * Prims.string Prims.list) -> FStar_Compiler_Util.proc)
-  =
-  fun id ->
-    fun cmd_and_args ->
-      check_z3version ();
-      FStar_Compiler_Util.start_process id
-        (FStar_Pervasives_Native.fst cmd_and_args)
-        (FStar_Pervasives_Native.snd cmd_and_args) (fun s -> s = "Done!")
-let (new_z3proc_with_id :
-  (Prims.string * Prims.string Prims.list) -> FStar_Compiler_Util.proc) =
-  let ctr = FStar_Compiler_Util.mk_ref (~- Prims.int_one) in
-  fun cmd_and_args ->
-    let p =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Util.incr ctr;
-          (let uu___3 = FStar_Compiler_Effect.op_Bang ctr in
-           FStar_Compiler_Effect.op_Bar_Greater uu___3
-             FStar_Compiler_Util.string_of_int) in
-        FStar_Compiler_Util.format1 "bg-%s" uu___1 in
-      new_z3proc uu___ cmd_and_args in
-    let reply =
-      FStar_Compiler_Util.ask_process p "(echo \"Test\")\n(echo \"Done!\")\n"
-        (fun uu___ -> "Killed") in
-    if reply = "Test\n"
-    then p
-    else
-      (let uu___1 =
-         FStar_Compiler_Util.format1
-           "Failed to start and test Z3 process, expected output \"Test\" got \"%s\""
-           reply in
-       failwith uu___1)
-type bgproc =
-  {
-  ask: Prims.string -> Prims.string ;
-  refresh: unit -> unit ;
-  restart: unit -> unit }
-let (__proj__Mkbgproc__item__ask : bgproc -> Prims.string -> Prims.string) =
-  fun projectee -> match projectee with | { ask; refresh; restart;_} -> ask
-let (__proj__Mkbgproc__item__refresh : bgproc -> unit -> unit) =
-  fun projectee ->
-    match projectee with | { ask; refresh; restart;_} -> refresh
-let (__proj__Mkbgproc__item__restart : bgproc -> unit -> unit) =
-  fun projectee ->
-    match projectee with | { ask; refresh; restart;_} -> restart
-let (cmd_and_args_to_string :
-  (Prims.string * Prims.string Prims.list) -> Prims.string) =
-  fun cmd_and_args ->
-    FStar_String.concat ""
-      ["cmd=";
-      FStar_Pervasives_Native.fst cmd_and_args;
-      " args=[";
-      FStar_String.concat ", " (FStar_Pervasives_Native.snd cmd_and_args);
-      "]"]
-let (bg_z3_proc : bgproc FStar_Compiler_Effect.ref) =
-  let the_z3proc = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-  let the_z3proc_params =
-    FStar_Compiler_Util.mk_ref (FStar_Pervasives_Native.Some ("", [""])) in
-  let the_z3proc_ask_count = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let make_new_z3_proc cmd_and_args =
-    (let uu___1 =
-       let uu___2 = new_z3proc_with_id cmd_and_args in
-       FStar_Pervasives_Native.Some uu___2 in
-     FStar_Compiler_Effect.op_Colon_Equals the_z3proc uu___1);
-    FStar_Compiler_Effect.op_Colon_Equals the_z3proc_params
-      (FStar_Pervasives_Native.Some cmd_and_args);
-    FStar_Compiler_Effect.op_Colon_Equals the_z3proc_ask_count Prims.int_zero in
-  let z3proc uu___ =
-    (let uu___2 =
-       let uu___3 = FStar_Compiler_Effect.op_Bang the_z3proc in
-       uu___3 = FStar_Pervasives_Native.None in
-     if uu___2
-     then let uu___3 = z3_cmd_and_args () in make_new_z3_proc uu___3
-     else ());
-    (let uu___2 = FStar_Compiler_Effect.op_Bang the_z3proc in
-     FStar_Compiler_Util.must uu___2) in
-  let ask input =
-    FStar_Compiler_Util.incr the_z3proc_ask_count;
-    (let kill_handler uu___1 = "\nkilled\n" in
-     let uu___1 = z3proc () in
-     FStar_Compiler_Util.ask_process uu___1 input kill_handler) in
-  let maybe_kill_z3proc uu___ =
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang the_z3proc in
-      uu___2 <> FStar_Pervasives_Native.None in
-    if uu___1
-    then
-      ((let uu___3 =
-          let uu___4 = FStar_Compiler_Effect.op_Bang the_z3proc in
-          FStar_Compiler_Util.must uu___4 in
-        FStar_Compiler_Util.kill_process uu___3);
-       FStar_Compiler_Effect.op_Colon_Equals the_z3proc
-         FStar_Pervasives_Native.None)
-    else () in
-  let refresh uu___ =
-    let next_params = z3_cmd_and_args () in
-    let old_params =
-      let uu___1 = FStar_Compiler_Effect.op_Bang the_z3proc_params in
-      FStar_Compiler_Util.must uu___1 in
-    (let uu___2 =
-       ((FStar_Options.log_queries ()) ||
-          (let uu___3 = FStar_Compiler_Effect.op_Bang the_z3proc_ask_count in
-           uu___3 > Prims.int_zero))
-         || (Prims.op_Negation (old_params = next_params)) in
-     if uu___2
-     then
-       (maybe_kill_z3proc ();
-        (let uu___5 = FStar_Options.query_stats () in
-         if uu___5
-         then
-           let uu___6 =
-             let uu___7 = FStar_Compiler_Effect.op_Bang the_z3proc_ask_count in
-             FStar_Compiler_Util.string_of_int uu___7 in
-           FStar_Compiler_Util.print3
-             "Refreshing the z3proc (ask_count=%s old=[%s] new=[%s]) \n"
-             uu___6 (cmd_and_args_to_string old_params)
-             (cmd_and_args_to_string next_params)
-         else ());
-        make_new_z3_proc next_params)
-     else ());
-    query_logging.close_log () in
-  let restart uu___ =
-    maybe_kill_z3proc ();
-    query_logging.close_log ();
-    (let next_params = z3_cmd_and_args () in make_new_z3_proc next_params) in
-  let x = [] in
-  FStar_Compiler_Util.mk_ref
-    {
-      ask = (FStar_Compiler_Util.with_monitor x ask);
-      refresh = (FStar_Compiler_Util.with_monitor x refresh);
-      restart = (FStar_Compiler_Util.with_monitor x restart)
-    }
-type smt_output_section = Prims.string Prims.list
-type smt_output =
-  {
-  smt_result: smt_output_section ;
-  smt_reason_unknown: smt_output_section FStar_Pervasives_Native.option ;
-  smt_unsat_core: smt_output_section FStar_Pervasives_Native.option ;
-  smt_statistics: smt_output_section FStar_Pervasives_Native.option ;
-  smt_labels: smt_output_section FStar_Pervasives_Native.option }
-let (__proj__Mksmt_output__item__smt_result :
-  smt_output -> smt_output_section) =
-  fun projectee ->
-    match projectee with
-    | { smt_result; smt_reason_unknown; smt_unsat_core; smt_statistics;
-        smt_labels;_} -> smt_result
-let (__proj__Mksmt_output__item__smt_reason_unknown :
-  smt_output -> smt_output_section FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { smt_result; smt_reason_unknown; smt_unsat_core; smt_statistics;
-        smt_labels;_} -> smt_reason_unknown
-let (__proj__Mksmt_output__item__smt_unsat_core :
-  smt_output -> smt_output_section FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { smt_result; smt_reason_unknown; smt_unsat_core; smt_statistics;
-        smt_labels;_} -> smt_unsat_core
-let (__proj__Mksmt_output__item__smt_statistics :
-  smt_output -> smt_output_section FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { smt_result; smt_reason_unknown; smt_unsat_core; smt_statistics;
-        smt_labels;_} -> smt_statistics
-let (__proj__Mksmt_output__item__smt_labels :
-  smt_output -> smt_output_section FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { smt_result; smt_reason_unknown; smt_unsat_core; smt_statistics;
-        smt_labels;_} -> smt_labels
-let (smt_output_sections :
-  Prims.string FStar_Pervasives_Native.option ->
-    FStar_Compiler_Range.range -> Prims.string Prims.list -> smt_output)
-  =
-  fun log_file ->
-    fun r ->
-      fun lines ->
-        let rec until tag lines1 =
-          match lines1 with
-          | [] -> FStar_Pervasives_Native.None
-          | l::lines2 ->
-              if tag = l
-              then FStar_Pervasives_Native.Some ([], lines2)
-              else
-                (let uu___1 = until tag lines2 in
-                 FStar_Compiler_Util.map_opt uu___1
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (until_tag, rest) -> ((l :: until_tag), rest))) in
-        let start_tag tag = Prims.op_Hat "<" (Prims.op_Hat tag ">") in
-        let end_tag tag = Prims.op_Hat "</" (Prims.op_Hat tag ">") in
-        let find_section tag lines1 =
-          let uu___ = until (start_tag tag) lines1 in
-          match uu___ with
-          | FStar_Pervasives_Native.None ->
-              (FStar_Pervasives_Native.None, lines1)
-          | FStar_Pervasives_Native.Some (prefix, suffix) ->
-              let uu___1 = until (end_tag tag) suffix in
-              (match uu___1 with
-               | FStar_Pervasives_Native.None ->
-                   failwith
-                     (Prims.op_Hat "Parse error: "
-                        (Prims.op_Hat (end_tag tag) " not found"))
-               | FStar_Pervasives_Native.Some (section, suffix1) ->
-                   ((FStar_Pervasives_Native.Some section),
-                     (FStar_Compiler_List.op_At prefix suffix1))) in
-        let uu___ = find_section "result" lines in
-        match uu___ with
-        | (result_opt, lines1) ->
-            let result = FStar_Compiler_Util.must result_opt in
-            let uu___1 = find_section "reason-unknown" lines1 in
-            (match uu___1 with
-             | (reason_unknown, lines2) ->
-                 let uu___2 = find_section "unsat-core" lines2 in
-                 (match uu___2 with
-                  | (unsat_core1, lines3) ->
-                      let uu___3 = find_section "statistics" lines3 in
-                      (match uu___3 with
-                       | (statistics, lines4) ->
-                           let uu___4 = find_section "labels" lines4 in
-                           (match uu___4 with
-                            | (labels, lines5) ->
-                                let remaining =
-                                  let uu___5 = until "Done!" lines5 in
-                                  match uu___5 with
-                                  | FStar_Pervasives_Native.None -> lines5
-                                  | FStar_Pervasives_Native.Some
-                                      (prefix, suffix) ->
-                                      FStar_Compiler_List.op_At prefix suffix in
-                                ((match remaining with
-                                  | [] -> ()
-                                  | uu___6 ->
-                                      let msg =
-                                        FStar_Compiler_Util.format2
-                                          "%sUnexpected output from Z3: %s\n"
-                                          (match log_file with
-                                           | FStar_Pervasives_Native.None ->
-                                               ""
-                                           | FStar_Pervasives_Native.Some f
-                                               -> Prims.op_Hat f ": ")
-                                          (FStar_String.concat "\n" remaining) in
-                                      FStar_Errors.log_issue r
-                                        (FStar_Errors.Warning_UnexpectedZ3Output,
-                                          msg));
-                                 (let uu___6 =
-                                    FStar_Compiler_Util.must result_opt in
-                                  {
-                                    smt_result = uu___6;
-                                    smt_reason_unknown = reason_unknown;
-                                    smt_unsat_core = unsat_core1;
-                                    smt_statistics = statistics;
-                                    smt_labels = labels
-                                  }))))))
-let (doZ3Exe :
-  Prims.string FStar_Pervasives_Native.option ->
-    FStar_Compiler_Range.range ->
-      Prims.bool ->
-        Prims.string ->
-          FStar_SMTEncoding_Term.error_labels -> (z3status * z3statistics))
-  =
-  fun log_file ->
-    fun r ->
-      fun fresh ->
-        fun input ->
-          fun label_messages ->
-            let parse z3out =
-              let lines =
-                FStar_Compiler_Effect.op_Bar_Greater
-                  (FStar_String.split [10] z3out)
-                  (FStar_Compiler_List.map FStar_Compiler_Util.trim_string) in
-              let smt_output1 = smt_output_sections log_file r lines in
-              let unsat_core1 =
-                match smt_output1.smt_unsat_core with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Pervasives_Native.None
-                | FStar_Pervasives_Native.Some s ->
-                    let s1 =
-                      FStar_Compiler_Util.trim_string
-                        (FStar_String.concat " " s) in
-                    let s2 =
-                      FStar_Compiler_Util.substring s1 Prims.int_one
-                        ((FStar_String.length s1) - (Prims.of_int (2))) in
-                    if FStar_Compiler_Util.starts_with s2 "error"
-                    then FStar_Pervasives_Native.None
-                    else
-                      (let uu___1 =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           (FStar_Compiler_Util.split s2 " ")
-                           (FStar_Compiler_Util.sort_with
-                              FStar_String.compare) in
-                       FStar_Pervasives_Native.Some uu___1) in
-              let labels =
-                match smt_output1.smt_labels with
-                | FStar_Pervasives_Native.None -> []
-                | FStar_Pervasives_Native.Some lines1 ->
-                    let rec lblnegs lines2 =
-                      match lines2 with
-                      | lname::"false"::rest when
-                          FStar_Compiler_Util.starts_with lname "label_" ->
-                          let uu___ = lblnegs rest in lname :: uu___
-                      | lname::uu___::rest when
-                          FStar_Compiler_Util.starts_with lname "label_" ->
-                          lblnegs rest
-                      | uu___ -> [] in
-                    let lblnegs1 = lblnegs lines1 in
-                    FStar_Compiler_Effect.op_Bar_Greater lblnegs1
-                      (FStar_Compiler_List.collect
-                         (fun l ->
-                            let uu___ =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                label_messages
-                                (FStar_Compiler_List.tryFind
-                                   (fun uu___1 ->
-                                      match uu___1 with
-                                      | (m, uu___2, uu___3) ->
-                                          let uu___4 =
-                                            FStar_SMTEncoding_Term.fv_name m in
-                                          uu___4 = l)) in
-                            match uu___ with
-                            | FStar_Pervasives_Native.None -> []
-                            | FStar_Pervasives_Native.Some (lbl, msg, r1) ->
-                                [(lbl, msg, r1)])) in
-              let statistics =
-                let statistics1 =
-                  FStar_Compiler_Util.smap_create Prims.int_zero in
-                match smt_output1.smt_statistics with
-                | FStar_Pervasives_Native.None -> statistics1
-                | FStar_Pervasives_Native.Some lines1 ->
-                    let parse_line line =
-                      let pline =
-                        FStar_Compiler_Util.split
-                          (FStar_Compiler_Util.trim_string line) ":" in
-                      match pline with
-                      | "("::entry::[] ->
-                          let tokens = FStar_Compiler_Util.split entry " " in
-                          let key = FStar_Compiler_List.hd tokens in
-                          let ltok =
-                            FStar_Compiler_List.nth tokens
-                              ((FStar_Compiler_List.length tokens) -
-                                 Prims.int_one) in
-                          let value =
-                            if FStar_Compiler_Util.ends_with ltok ")"
-                            then
-                              FStar_Compiler_Util.substring ltok
-                                Prims.int_zero
-                                ((FStar_String.length ltok) - Prims.int_one)
-                            else ltok in
-                          FStar_Compiler_Util.smap_add statistics1 key value
-                      | ""::entry::[] ->
-                          let tokens = FStar_Compiler_Util.split entry " " in
-                          let key = FStar_Compiler_List.hd tokens in
-                          let ltok =
-                            FStar_Compiler_List.nth tokens
-                              ((FStar_Compiler_List.length tokens) -
-                                 Prims.int_one) in
-                          let value =
-                            if FStar_Compiler_Util.ends_with ltok ")"
-                            then
-                              FStar_Compiler_Util.substring ltok
-                                Prims.int_zero
-                                ((FStar_String.length ltok) - Prims.int_one)
-                            else ltok in
-                          FStar_Compiler_Util.smap_add statistics1 key value
-                      | uu___ -> () in
-                    (FStar_Compiler_List.iter parse_line lines1; statistics1) in
-              let reason_unknown =
-                FStar_Compiler_Util.map_opt smt_output1.smt_reason_unknown
-                  (fun x ->
-                     let ru = FStar_String.concat " " x in
-                     if
-                       FStar_Compiler_Util.starts_with ru
-                         "(:reason-unknown \""
-                     then
-                       let reason =
-                         FStar_Compiler_Util.substring_from ru
-                           (FStar_String.length "(:reason-unknown \"") in
-                       let res =
-                         FStar_String.substring reason Prims.int_zero
-                           ((FStar_String.length reason) - (Prims.of_int (2))) in
-                       res
-                     else ru) in
-              let status =
-                (let uu___1 = FStar_Options.debug_any () in
-                 if uu___1
-                 then
-                   let uu___2 =
-                     FStar_Compiler_Util.format1 "Z3 says: %s\n"
-                       (FStar_String.concat "\n" smt_output1.smt_result) in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     FStar_Compiler_Util.print_string uu___2
-                 else ());
-                (match smt_output1.smt_result with
-                 | "unsat"::[] -> UNSAT unsat_core1
-                 | "sat"::[] -> SAT (labels, reason_unknown)
-                 | "unknown"::[] -> UNKNOWN (labels, reason_unknown)
-                 | "timeout"::[] -> TIMEOUT (labels, reason_unknown)
-                 | "killed"::[] ->
-                     ((let uu___2 = FStar_Compiler_Effect.op_Bang bg_z3_proc in
-                       uu___2.restart ());
-                      KILLED)
-                 | uu___1 ->
-                     let uu___2 =
-                       FStar_Compiler_Util.format1
-                         "Unexpected output from Z3: got output result: %s\n"
-                         (FStar_String.concat "\n" smt_output1.smt_result) in
-                     failwith uu___2) in
-              (status, statistics) in
-            let stdout =
-              if fresh
-              then
-                let proc =
-                  let uu___ = z3_cmd_and_args () in new_z3proc_with_id uu___ in
-                let kill_handler uu___ = "\nkilled\n" in
-                let out =
-                  FStar_Compiler_Util.ask_process proc input kill_handler in
-                (FStar_Compiler_Util.kill_process proc; out)
-              else
-                (let uu___1 = FStar_Compiler_Effect.op_Bang bg_z3_proc in
-                 uu___1.ask input) in
-            parse (FStar_Compiler_Util.trim_string stdout)
-let (z3_options : Prims.string FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    "(set-option :global-decls false)\n(set-option :smt.mbqi false)\n(set-option :auto_config false)\n(set-option :produce-unsat-cores true)\n(set-option :model true)\n(set-option :smt.case_split 3)\n(set-option :smt.relevancy 2)\n"
-let (set_z3_options : Prims.string -> unit) =
-  fun opts -> FStar_Compiler_Effect.op_Colon_Equals z3_options opts
-let (init : unit -> unit) = fun uu___ -> ()
-let (finish : unit -> unit) = fun uu___ -> ()
-let (fresh_scope : scope_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref [[]]
-let (mk_fresh_scope : unit -> scope_t) =
-  fun uu___ -> FStar_Compiler_Effect.op_Bang fresh_scope
-let (flatten_fresh_scope : unit -> FStar_SMTEncoding_Term.decl Prims.list) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang fresh_scope in
-      FStar_Compiler_List.rev uu___2 in
-    FStar_Compiler_List.flatten uu___1
-let (bg_scope :
-  FStar_SMTEncoding_Term.decl Prims.list FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let (push : Prims.string -> unit) =
-  fun msg ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         (let uu___2 =
-            let uu___3 = FStar_Compiler_Effect.op_Bang fresh_scope in
-            [FStar_SMTEncoding_Term.Caption msg; FStar_SMTEncoding_Term.Push]
-              :: uu___3 in
-          FStar_Compiler_Effect.op_Colon_Equals fresh_scope uu___2);
-         (let uu___2 =
-            let uu___3 = FStar_Compiler_Effect.op_Bang bg_scope in
-            FStar_Compiler_List.op_At uu___3
-              [FStar_SMTEncoding_Term.Push;
-              FStar_SMTEncoding_Term.Caption msg] in
-          FStar_Compiler_Effect.op_Colon_Equals bg_scope uu___2))
-let (pop : Prims.string -> unit) =
-  fun msg ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         (let uu___2 =
-            let uu___3 = FStar_Compiler_Effect.op_Bang fresh_scope in
-            FStar_Compiler_List.tl uu___3 in
-          FStar_Compiler_Effect.op_Colon_Equals fresh_scope uu___2);
-         (let uu___2 =
-            let uu___3 = FStar_Compiler_Effect.op_Bang bg_scope in
-            FStar_Compiler_List.op_At uu___3
-              [FStar_SMTEncoding_Term.Caption msg;
-              FStar_SMTEncoding_Term.Pop] in
-          FStar_Compiler_Effect.op_Colon_Equals bg_scope uu___2))
-let (snapshot : Prims.string -> (Prims.int * unit)) =
-  fun msg -> FStar_Common.snapshot push fresh_scope msg
-let (rollback :
-  Prims.string -> Prims.int FStar_Pervasives_Native.option -> unit) =
-  fun msg ->
-    fun depth ->
-      FStar_Common.rollback (fun uu___ -> pop msg) fresh_scope depth
-let (giveZ3 : FStar_SMTEncoding_Term.decl Prims.list -> unit) =
-  fun decls ->
-    FStar_Compiler_Effect.op_Bar_Greater decls
-      (FStar_Compiler_List.iter
-         (fun uu___1 ->
-            match uu___1 with
-            | FStar_SMTEncoding_Term.Push -> failwith "Unexpected push/pop"
-            | FStar_SMTEncoding_Term.Pop -> failwith "Unexpected push/pop"
-            | uu___2 -> ()));
-    (let uu___2 = FStar_Compiler_Effect.op_Bang fresh_scope in
-     match uu___2 with
-     | hd::tl ->
-         FStar_Compiler_Effect.op_Colon_Equals fresh_scope
-           ((FStar_Compiler_List.op_At hd decls) :: tl)
-     | uu___3 -> failwith "Impossible");
-    (let uu___2 =
-       let uu___3 = FStar_Compiler_Effect.op_Bang bg_scope in
-       FStar_Compiler_List.op_At uu___3 decls in
-     FStar_Compiler_Effect.op_Colon_Equals bg_scope uu___2)
-let (refresh : unit -> unit) =
-  fun uu___ ->
-    (let uu___2 = FStar_Compiler_Effect.op_Bang bg_z3_proc in
-     uu___2.refresh ());
-    (let uu___2 = flatten_fresh_scope () in
-     FStar_Compiler_Effect.op_Colon_Equals bg_scope uu___2)
-let (context_profile : FStar_SMTEncoding_Term.decl Prims.list -> unit) =
-  fun theory ->
-    let uu___ =
-      FStar_Compiler_List.fold_left
-        (fun uu___1 ->
-           fun d ->
-             match uu___1 with
-             | (out, _total) ->
-                 (match d with
-                  | FStar_SMTEncoding_Term.Module (name, decls) ->
-                      let decls1 =
-                        FStar_Compiler_List.filter
-                          (fun uu___2 ->
-                             match uu___2 with
-                             | FStar_SMTEncoding_Term.Assume uu___3 -> true
-                             | uu___3 -> false) decls in
-                      let n = FStar_Compiler_List.length decls1 in
-                      (((name, n) :: out), (n + _total))
-                  | uu___2 -> (out, _total))) ([], Prims.int_zero) theory in
-    match uu___ with
-    | (modules, total_decls) ->
-        let modules1 =
-          FStar_Compiler_List.sortWith
-            (fun uu___1 ->
-               fun uu___2 ->
-                 match (uu___1, uu___2) with
-                 | ((uu___3, n), (uu___4, m)) -> m - n) modules in
-        (if modules1 <> []
-         then
-           (let uu___2 = FStar_Compiler_Util.string_of_int total_decls in
-            FStar_Compiler_Util.print1
-              "Z3 Proof Stats: context_profile with %s assertions\n" uu___2)
-         else ();
-         FStar_Compiler_List.iter
-           (fun uu___2 ->
-              match uu___2 with
-              | (m, n) ->
-                  if n <> Prims.int_zero
-                  then
-                    let uu___3 = FStar_Compiler_Util.string_of_int n in
-                    FStar_Compiler_Util.print2
-                      "Z3 Proof Stats: %s produced %s SMT decls\n" m uu___3
-                  else ()) modules1)
-let (mk_input :
-  Prims.bool ->
-    FStar_SMTEncoding_Term.decl Prims.list ->
-      (Prims.string * Prims.string FStar_Pervasives_Native.option *
-        Prims.string FStar_Pervasives_Native.option))
-  =
-  fun fresh ->
-    fun theory ->
-      let options = FStar_Compiler_Effect.op_Bang z3_options in
-      let options1 =
-        let uu___ =
-          let uu___1 = FStar_Options.z3_smtopt () in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_String.concat "\n") in
-        Prims.op_Hat options uu___ in
-      (let uu___1 = FStar_Options.print_z3_statistics () in
-       if uu___1 then context_profile theory else ());
-      (let uu___1 =
-         let uu___2 =
-           (FStar_Options.record_hints ()) ||
-             ((FStar_Options.use_hints ()) &&
-                (FStar_Options.use_hint_hashes ())) in
-         if uu___2
-         then
-           let uu___3 =
-             let uu___4 =
-               FStar_Compiler_Effect.op_Bar_Greater theory
-                 (FStar_Compiler_Util.prefix_until
-                    (fun uu___5 ->
-                       match uu___5 with
-                       | FStar_SMTEncoding_Term.CheckSat -> true
-                       | uu___6 -> false)) in
-             FStar_Compiler_Effect.op_Bar_Greater uu___4
-               FStar_Compiler_Option.get in
-           match uu___3 with
-           | (prefix, check_sat, suffix) ->
-               let pp =
-                 FStar_Compiler_List.map
-                   (FStar_SMTEncoding_Term.declToSmt options1) in
-               let suffix1 = check_sat :: suffix in
-               let ps_lines = pp prefix in
-               let ss_lines = pp suffix1 in
-               let ps = FStar_String.concat "\n" ps_lines in
-               let ss = FStar_String.concat "\n" ss_lines in
-               let hs =
-                 let uu___4 = FStar_Options.keep_query_captions () in
-                 if uu___4
-                 then
-                   let uu___5 =
-                     FStar_Compiler_Effect.op_Bar_Greater prefix
-                       (FStar_Compiler_List.map
-                          (FStar_SMTEncoding_Term.declToSmt_no_caps options1)) in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___5
-                     (FStar_String.concat "\n")
-                 else ps in
-               let uu___4 =
-                 let uu___5 = FStar_Compiler_Util.digest_of_string hs in
-                 FStar_Pervasives_Native.Some uu___5 in
-               ((Prims.op_Hat ps (Prims.op_Hat "\n" ss)), uu___4)
-         else
-           (let uu___4 =
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (FStar_SMTEncoding_Term.declToSmt options1) theory in
-              FStar_Compiler_Effect.op_Bar_Greater uu___5
-                (FStar_String.concat "\n") in
-            (uu___4, FStar_Pervasives_Native.None)) in
-       match uu___1 with
-       | (r, hash) ->
-           let log_file_name =
-             let uu___2 = FStar_Options.log_queries () in
-             if uu___2
-             then
-               let uu___3 = query_logging.write_to_log fresh r in
-               FStar_Pervasives_Native.Some uu___3
-             else FStar_Pervasives_Native.None in
-           (r, hash, log_file_name))
-let (cache_hit :
-  Prims.string FStar_Pervasives_Native.option ->
-    Prims.string FStar_Pervasives_Native.option ->
-      Prims.string FStar_Pervasives_Native.option ->
-        z3result FStar_Pervasives_Native.option)
-  =
-  fun log_file ->
-    fun cache ->
-      fun qhash ->
-        let uu___ =
-          (FStar_Options.use_hints ()) && (FStar_Options.use_hint_hashes ()) in
-        if uu___
-        then
-          match qhash with
-          | FStar_Pervasives_Native.Some x when qhash = cache ->
-              let stats = FStar_Compiler_Util.smap_create Prims.int_zero in
-              (FStar_Compiler_Util.smap_add stats "fstar_cache_hit" "1";
-               (let result =
-                  {
-                    z3result_status = (UNSAT FStar_Pervasives_Native.None);
-                    z3result_time = Prims.int_zero;
-                    z3result_statistics = stats;
-                    z3result_query_hash = qhash;
-                    z3result_log_file = log_file
-                  } in
-                FStar_Pervasives_Native.Some result))
-          | uu___1 -> FStar_Pervasives_Native.None
-        else FStar_Pervasives_Native.None
-let (z3_job :
-  Prims.string FStar_Pervasives_Native.option ->
-    FStar_Compiler_Range.range ->
-      Prims.bool ->
-        FStar_SMTEncoding_Term.error_labels ->
-          Prims.string ->
-            Prims.string FStar_Pervasives_Native.option -> unit -> z3result)
-  =
-  fun log_file ->
-    fun r ->
-      fun fresh ->
-        fun label_messages ->
-          fun input ->
-            fun qhash ->
-              fun uu___ ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = query_logging.get_module_name () in
-                    FStar_Pervasives_Native.Some uu___3 in
-                  FStar_Profiling.profile
-                    (fun uu___3 ->
-                       try
-                         (fun uu___4 ->
-                            match () with
-                            | () ->
-                                FStar_Compiler_Util.record_time
-                                  (fun uu___5 ->
-                                     doZ3Exe log_file r fresh input
-                                       label_messages)) ()
-                       with
-                       | uu___4 ->
-                           (refresh (); FStar_Compiler_Effect.raise uu___4))
-                    uu___2 "FStar.SMTEncoding.Z3 (aggregate query time)" in
-                match uu___1 with
-                | ((status, statistics), elapsed_time) ->
-                    {
-                      z3result_status = status;
-                      z3result_time = elapsed_time;
-                      z3result_statistics = statistics;
-                      z3result_query_hash = qhash;
-                      z3result_log_file = log_file
-                    }
-let (ask :
-  FStar_Compiler_Range.range ->
-    (FStar_SMTEncoding_Term.decl Prims.list ->
-       (FStar_SMTEncoding_Term.decl Prims.list * Prims.bool))
-      ->
-      Prims.string FStar_Pervasives_Native.option ->
-        FStar_SMTEncoding_Term.error_labels ->
-          FStar_SMTEncoding_Term.decl Prims.list ->
-            scope_t FStar_Pervasives_Native.option -> Prims.bool -> z3result)
-  =
-  fun r ->
-    fun filter_theory ->
-      fun cache ->
-        fun label_messages ->
-          fun qry ->
-            fun _scope ->
-              fun fresh ->
-                let theory =
-                  if fresh
-                  then flatten_fresh_scope ()
-                  else
-                    (let theory1 = FStar_Compiler_Effect.op_Bang bg_scope in
-                     FStar_Compiler_Effect.op_Colon_Equals bg_scope [];
-                     theory1) in
-                let theory1 =
-                  FStar_Compiler_List.op_At theory
-                    (FStar_Compiler_List.op_At [FStar_SMTEncoding_Term.Push]
-                       (FStar_Compiler_List.op_At qry
-                          [FStar_SMTEncoding_Term.Pop])) in
-                let uu___ = filter_theory theory1 in
-                match uu___ with
-                | (theory2, _used_unsat_core) ->
-                    let uu___1 = mk_input fresh theory2 in
-                    (match uu___1 with
-                     | (input, qhash, log_file_name) ->
-                         let just_ask uu___2 =
-                           z3_job log_file_name r fresh label_messages input
-                             qhash () in
-                         if fresh
-                         then
-                           let uu___2 = cache_hit log_file_name cache qhash in
-                           (match uu___2 with
-                            | FStar_Pervasives_Native.Some z3r -> z3r
-                            | FStar_Pervasives_Native.None -> just_ask ())
-                         else just_ask ())
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_DsEnv.ml b/src/ocaml-output/FStar_Syntax_DsEnv.ml
deleted file mode 100644
index 95b9bb9885e..00000000000
--- a/src/ocaml-output/FStar_Syntax_DsEnv.ml
+++ /dev/null
@@ -1,3364 +0,0 @@
-open Prims
-type used_marker = Prims.bool FStar_Compiler_Effect.ref
-type open_kind =
-  | Open_module 
-  | Open_namespace 
-let (uu___is_Open_module : open_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Open_module -> true | uu___ -> false
-let (uu___is_Open_namespace : open_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Open_namespace -> true | uu___ -> false
-type open_module_or_namespace = (FStar_Ident.lident * open_kind)
-type record_or_dc =
-  {
-  typename: FStar_Ident.lident ;
-  constrname: FStar_Ident.ident ;
-  parms: FStar_Syntax_Syntax.binders ;
-  fields: (FStar_Ident.ident * FStar_Syntax_Syntax.typ) Prims.list ;
-  is_private: Prims.bool ;
-  is_record: Prims.bool }
-let (__proj__Mkrecord_or_dc__item__typename :
-  record_or_dc -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { typename; constrname; parms; fields; is_private; is_record;_} ->
-        typename
-let (__proj__Mkrecord_or_dc__item__constrname :
-  record_or_dc -> FStar_Ident.ident) =
-  fun projectee ->
-    match projectee with
-    | { typename; constrname; parms; fields; is_private; is_record;_} ->
-        constrname
-let (__proj__Mkrecord_or_dc__item__parms :
-  record_or_dc -> FStar_Syntax_Syntax.binders) =
-  fun projectee ->
-    match projectee with
-    | { typename; constrname; parms; fields; is_private; is_record;_} ->
-        parms
-let (__proj__Mkrecord_or_dc__item__fields :
-  record_or_dc -> (FStar_Ident.ident * FStar_Syntax_Syntax.typ) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { typename; constrname; parms; fields; is_private; is_record;_} ->
-        fields
-let (__proj__Mkrecord_or_dc__item__is_private : record_or_dc -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { typename; constrname; parms; fields; is_private; is_record;_} ->
-        is_private
-let (__proj__Mkrecord_or_dc__item__is_record : record_or_dc -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { typename; constrname; parms; fields; is_private; is_record;_} ->
-        is_record
-type local_binding =
-  (FStar_Ident.ident * FStar_Syntax_Syntax.bv * used_marker)
-type rec_binding =
-  (FStar_Ident.ident * FStar_Ident.lid * FStar_Syntax_Syntax.delta_depth *
-    used_marker)
-type module_abbrev = (FStar_Ident.ident * FStar_Ident.lident)
-type scope_mod =
-  | Local_binding of local_binding 
-  | Rec_binding of rec_binding 
-  | Module_abbrev of module_abbrev 
-  | Open_module_or_namespace of open_module_or_namespace 
-  | Top_level_def of FStar_Ident.ident 
-  | Record_or_dc of record_or_dc 
-let (uu___is_Local_binding : scope_mod -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Local_binding _0 -> true | uu___ -> false
-let (__proj__Local_binding__item___0 : scope_mod -> local_binding) =
-  fun projectee -> match projectee with | Local_binding _0 -> _0
-let (uu___is_Rec_binding : scope_mod -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Rec_binding _0 -> true | uu___ -> false
-let (__proj__Rec_binding__item___0 : scope_mod -> rec_binding) =
-  fun projectee -> match projectee with | Rec_binding _0 -> _0
-let (uu___is_Module_abbrev : scope_mod -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Module_abbrev _0 -> true | uu___ -> false
-let (__proj__Module_abbrev__item___0 : scope_mod -> module_abbrev) =
-  fun projectee -> match projectee with | Module_abbrev _0 -> _0
-let (uu___is_Open_module_or_namespace : scope_mod -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Open_module_or_namespace _0 -> true
-    | uu___ -> false
-let (__proj__Open_module_or_namespace__item___0 :
-  scope_mod -> open_module_or_namespace) =
-  fun projectee -> match projectee with | Open_module_or_namespace _0 -> _0
-let (uu___is_Top_level_def : scope_mod -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Top_level_def _0 -> true | uu___ -> false
-let (__proj__Top_level_def__item___0 : scope_mod -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | Top_level_def _0 -> _0
-let (uu___is_Record_or_dc : scope_mod -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Record_or_dc _0 -> true | uu___ -> false
-let (__proj__Record_or_dc__item___0 : scope_mod -> record_or_dc) =
-  fun projectee -> match projectee with | Record_or_dc _0 -> _0
-type string_set = Prims.string FStar_Compiler_Util.set
-type exported_id_kind =
-  | Exported_id_term_type 
-  | Exported_id_field 
-let (uu___is_Exported_id_term_type : exported_id_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Exported_id_term_type -> true | uu___ -> false
-let (uu___is_Exported_id_field : exported_id_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Exported_id_field -> true | uu___ -> false
-type exported_id_set =
-  exported_id_kind -> string_set FStar_Compiler_Effect.ref
-type env =
-  {
-  curmodule: FStar_Ident.lident FStar_Pervasives_Native.option ;
-  curmonad: FStar_Ident.ident FStar_Pervasives_Native.option ;
-  modules: (FStar_Ident.lident * FStar_Syntax_Syntax.modul) Prims.list ;
-  scope_mods: scope_mod Prims.list ;
-  exported_ids: exported_id_set FStar_Compiler_Util.smap ;
-  trans_exported_ids: exported_id_set FStar_Compiler_Util.smap ;
-  includes:
-    FStar_Ident.lident Prims.list FStar_Compiler_Effect.ref
-      FStar_Compiler_Util.smap
-    ;
-  sigaccum: FStar_Syntax_Syntax.sigelts ;
-  sigmap: (FStar_Syntax_Syntax.sigelt * Prims.bool) FStar_Compiler_Util.smap ;
-  iface: Prims.bool ;
-  admitted_iface: Prims.bool ;
-  expect_typ: Prims.bool ;
-  remaining_iface_decls:
-    (FStar_Ident.lident * FStar_Parser_AST.decl Prims.list) Prims.list ;
-  syntax_only: Prims.bool ;
-  ds_hooks: dsenv_hooks ;
-  dep_graph: FStar_Parser_Dep.deps }
-and dsenv_hooks =
-  {
-  ds_push_open_hook: env -> open_module_or_namespace -> unit ;
-  ds_push_include_hook: env -> FStar_Ident.lident -> unit ;
-  ds_push_module_abbrev_hook:
-    env -> FStar_Ident.ident -> FStar_Ident.lident -> unit }
-let (__proj__Mkenv__item__curmodule :
-  env -> FStar_Ident.lident FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> curmodule
-let (__proj__Mkenv__item__curmonad :
-  env -> FStar_Ident.ident FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> curmonad
-let (__proj__Mkenv__item__modules :
-  env -> (FStar_Ident.lident * FStar_Syntax_Syntax.modul) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> modules
-let (__proj__Mkenv__item__scope_mods : env -> scope_mod Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> scope_mods
-let (__proj__Mkenv__item__exported_ids :
-  env -> exported_id_set FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> exported_ids
-let (__proj__Mkenv__item__trans_exported_ids :
-  env -> exported_id_set FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> trans_exported_ids
-let (__proj__Mkenv__item__includes :
-  env ->
-    FStar_Ident.lident Prims.list FStar_Compiler_Effect.ref
-      FStar_Compiler_Util.smap)
-  =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> includes
-let (__proj__Mkenv__item__sigaccum : env -> FStar_Syntax_Syntax.sigelts) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> sigaccum
-let (__proj__Mkenv__item__sigmap :
-  env -> (FStar_Syntax_Syntax.sigelt * Prims.bool) FStar_Compiler_Util.smap)
-  =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> sigmap
-let (__proj__Mkenv__item__iface : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> iface
-let (__proj__Mkenv__item__admitted_iface : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> admitted_iface
-let (__proj__Mkenv__item__expect_typ : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> expect_typ
-let (__proj__Mkenv__item__remaining_iface_decls :
-  env -> (FStar_Ident.lident * FStar_Parser_AST.decl Prims.list) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> remaining_iface_decls
-let (__proj__Mkenv__item__syntax_only : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> syntax_only
-let (__proj__Mkenv__item__ds_hooks : env -> dsenv_hooks) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> ds_hooks
-let (__proj__Mkenv__item__dep_graph : env -> FStar_Parser_Dep.deps) =
-  fun projectee ->
-    match projectee with
-    | { curmodule; curmonad; modules; scope_mods; exported_ids;
-        trans_exported_ids; includes; sigaccum; sigmap; iface;
-        admitted_iface; expect_typ; remaining_iface_decls; syntax_only;
-        ds_hooks; dep_graph;_} -> dep_graph
-let (__proj__Mkdsenv_hooks__item__ds_push_open_hook :
-  dsenv_hooks -> env -> open_module_or_namespace -> unit) =
-  fun projectee ->
-    match projectee with
-    | { ds_push_open_hook; ds_push_include_hook;
-        ds_push_module_abbrev_hook;_} -> ds_push_open_hook
-let (__proj__Mkdsenv_hooks__item__ds_push_include_hook :
-  dsenv_hooks -> env -> FStar_Ident.lident -> unit) =
-  fun projectee ->
-    match projectee with
-    | { ds_push_open_hook; ds_push_include_hook;
-        ds_push_module_abbrev_hook;_} -> ds_push_include_hook
-let (__proj__Mkdsenv_hooks__item__ds_push_module_abbrev_hook :
-  dsenv_hooks -> env -> FStar_Ident.ident -> FStar_Ident.lident -> unit) =
-  fun projectee ->
-    match projectee with
-    | { ds_push_open_hook; ds_push_include_hook;
-        ds_push_module_abbrev_hook;_} -> ds_push_module_abbrev_hook
-let (mk_dsenv_hooks :
-  (env -> open_module_or_namespace -> unit) ->
-    (env -> FStar_Ident.lident -> unit) ->
-      (env -> FStar_Ident.ident -> FStar_Ident.lident -> unit) -> dsenv_hooks)
-  =
-  fun open_hook ->
-    fun include_hook ->
-      fun module_abbrev_hook ->
-        {
-          ds_push_open_hook = open_hook;
-          ds_push_include_hook = include_hook;
-          ds_push_module_abbrev_hook = module_abbrev_hook
-        }
-type 'a withenv = env -> ('a * env)
-type foundname =
-  | Term_name of (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.attribute
-  Prims.list) 
-  | Eff_name of (FStar_Syntax_Syntax.sigelt * FStar_Ident.lident) 
-let (uu___is_Term_name : foundname -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Term_name _0 -> true | uu___ -> false
-let (__proj__Term_name__item___0 :
-  foundname ->
-    (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.attribute Prims.list))
-  = fun projectee -> match projectee with | Term_name _0 -> _0
-let (uu___is_Eff_name : foundname -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Eff_name _0 -> true | uu___ -> false
-let (__proj__Eff_name__item___0 :
-  foundname -> (FStar_Syntax_Syntax.sigelt * FStar_Ident.lident)) =
-  fun projectee -> match projectee with | Eff_name _0 -> _0
-let (default_ds_hooks : dsenv_hooks) =
-  {
-    ds_push_open_hook = (fun uu___ -> fun uu___1 -> ());
-    ds_push_include_hook = (fun uu___ -> fun uu___1 -> ());
-    ds_push_module_abbrev_hook =
-      (fun uu___ -> fun uu___1 -> fun uu___2 -> ())
-  }
-let (set_iface : env -> Prims.bool -> env) =
-  fun env1 ->
-    fun b ->
-      {
-        curmodule = (env1.curmodule);
-        curmonad = (env1.curmonad);
-        modules = (env1.modules);
-        scope_mods = (env1.scope_mods);
-        exported_ids = (env1.exported_ids);
-        trans_exported_ids = (env1.trans_exported_ids);
-        includes = (env1.includes);
-        sigaccum = (env1.sigaccum);
-        sigmap = (env1.sigmap);
-        iface = b;
-        admitted_iface = (env1.admitted_iface);
-        expect_typ = (env1.expect_typ);
-        remaining_iface_decls = (env1.remaining_iface_decls);
-        syntax_only = (env1.syntax_only);
-        ds_hooks = (env1.ds_hooks);
-        dep_graph = (env1.dep_graph)
-      }
-let (iface : env -> Prims.bool) = fun e -> e.iface
-let (set_admitted_iface : env -> Prims.bool -> env) =
-  fun e ->
-    fun b ->
-      {
-        curmodule = (e.curmodule);
-        curmonad = (e.curmonad);
-        modules = (e.modules);
-        scope_mods = (e.scope_mods);
-        exported_ids = (e.exported_ids);
-        trans_exported_ids = (e.trans_exported_ids);
-        includes = (e.includes);
-        sigaccum = (e.sigaccum);
-        sigmap = (e.sigmap);
-        iface = (e.iface);
-        admitted_iface = b;
-        expect_typ = (e.expect_typ);
-        remaining_iface_decls = (e.remaining_iface_decls);
-        syntax_only = (e.syntax_only);
-        ds_hooks = (e.ds_hooks);
-        dep_graph = (e.dep_graph)
-      }
-let (admitted_iface : env -> Prims.bool) = fun e -> e.admitted_iface
-let (set_expect_typ : env -> Prims.bool -> env) =
-  fun e ->
-    fun b ->
-      {
-        curmodule = (e.curmodule);
-        curmonad = (e.curmonad);
-        modules = (e.modules);
-        scope_mods = (e.scope_mods);
-        exported_ids = (e.exported_ids);
-        trans_exported_ids = (e.trans_exported_ids);
-        includes = (e.includes);
-        sigaccum = (e.sigaccum);
-        sigmap = (e.sigmap);
-        iface = (e.iface);
-        admitted_iface = (e.admitted_iface);
-        expect_typ = b;
-        remaining_iface_decls = (e.remaining_iface_decls);
-        syntax_only = (e.syntax_only);
-        ds_hooks = (e.ds_hooks);
-        dep_graph = (e.dep_graph)
-      }
-let (expect_typ : env -> Prims.bool) = fun e -> e.expect_typ
-let (all_exported_id_kinds : exported_id_kind Prims.list) =
-  [Exported_id_field; Exported_id_term_type]
-let (transitive_exported_ids :
-  env -> FStar_Ident.lident -> Prims.string Prims.list) =
-  fun env1 ->
-    fun lid ->
-      let module_name = FStar_Ident.string_of_lid lid in
-      let uu___ =
-        FStar_Compiler_Util.smap_try_find env1.trans_exported_ids module_name in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> []
-      | FStar_Pervasives_Native.Some exported_id_set1 ->
-          let uu___1 =
-            let uu___2 = exported_id_set1 Exported_id_term_type in
-            FStar_Compiler_Effect.op_Bang uu___2 in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_Util.set_elements
-let (open_modules :
-  env -> (FStar_Ident.lident * FStar_Syntax_Syntax.modul) Prims.list) =
-  fun e -> e.modules
-let (open_modules_and_namespaces : env -> FStar_Ident.lident Prims.list) =
-  fun env1 ->
-    FStar_Compiler_List.filter_map
-      (fun uu___ ->
-         match uu___ with
-         | Open_module_or_namespace (lid, _info) ->
-             FStar_Pervasives_Native.Some lid
-         | uu___1 -> FStar_Pervasives_Native.None) env1.scope_mods
-let (set_current_module : env -> FStar_Ident.lident -> env) =
-  fun e ->
-    fun l ->
-      {
-        curmodule = (FStar_Pervasives_Native.Some l);
-        curmonad = (e.curmonad);
-        modules = (e.modules);
-        scope_mods = (e.scope_mods);
-        exported_ids = (e.exported_ids);
-        trans_exported_ids = (e.trans_exported_ids);
-        includes = (e.includes);
-        sigaccum = (e.sigaccum);
-        sigmap = (e.sigmap);
-        iface = (e.iface);
-        admitted_iface = (e.admitted_iface);
-        expect_typ = (e.expect_typ);
-        remaining_iface_decls = (e.remaining_iface_decls);
-        syntax_only = (e.syntax_only);
-        ds_hooks = (e.ds_hooks);
-        dep_graph = (e.dep_graph)
-      }
-let (current_module : env -> FStar_Ident.lident) =
-  fun env1 ->
-    match env1.curmodule with
-    | FStar_Pervasives_Native.None -> failwith "Unset current module"
-    | FStar_Pervasives_Native.Some m -> m
-let (iface_decls :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Parser_AST.decl Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater env1.remaining_iface_decls
-          (FStar_Compiler_List.tryFind
-             (fun uu___1 ->
-                match uu___1 with | (m, uu___2) -> FStar_Ident.lid_equals l m)) in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (uu___1, decls) ->
-          FStar_Pervasives_Native.Some decls
-let (set_iface_decls :
-  env -> FStar_Ident.lident -> FStar_Parser_AST.decl Prims.list -> env) =
-  fun env1 ->
-    fun l ->
-      fun ds ->
-        let uu___ =
-          FStar_Compiler_List.partition
-            (fun uu___1 ->
-               match uu___1 with | (m, uu___2) -> FStar_Ident.lid_equals l m)
-            env1.remaining_iface_decls in
-        match uu___ with
-        | (uu___1, rest) ->
-            {
-              curmodule = (env1.curmodule);
-              curmonad = (env1.curmonad);
-              modules = (env1.modules);
-              scope_mods = (env1.scope_mods);
-              exported_ids = (env1.exported_ids);
-              trans_exported_ids = (env1.trans_exported_ids);
-              includes = (env1.includes);
-              sigaccum = (env1.sigaccum);
-              sigmap = (env1.sigmap);
-              iface = (env1.iface);
-              admitted_iface = (env1.admitted_iface);
-              expect_typ = (env1.expect_typ);
-              remaining_iface_decls = ((l, ds) :: rest);
-              syntax_only = (env1.syntax_only);
-              ds_hooks = (env1.ds_hooks);
-              dep_graph = (env1.dep_graph)
-            }
-let (qual : FStar_Ident.lident -> FStar_Ident.ident -> FStar_Ident.lident) =
-  FStar_Ident.qual_id
-let (qualify : env -> FStar_Ident.ident -> FStar_Ident.lident) =
-  fun env1 ->
-    fun id ->
-      match env1.curmonad with
-      | FStar_Pervasives_Native.None ->
-          let uu___ = current_module env1 in qual uu___ id
-      | FStar_Pervasives_Native.Some monad ->
-          let uu___ = let uu___1 = current_module env1 in qual uu___1 monad in
-          FStar_Syntax_Util.mk_field_projector_name_from_ident uu___ id
-let (syntax_only : env -> Prims.bool) = fun env1 -> env1.syntax_only
-let (set_syntax_only : env -> Prims.bool -> env) =
-  fun env1 ->
-    fun b ->
-      {
-        curmodule = (env1.curmodule);
-        curmonad = (env1.curmonad);
-        modules = (env1.modules);
-        scope_mods = (env1.scope_mods);
-        exported_ids = (env1.exported_ids);
-        trans_exported_ids = (env1.trans_exported_ids);
-        includes = (env1.includes);
-        sigaccum = (env1.sigaccum);
-        sigmap = (env1.sigmap);
-        iface = (env1.iface);
-        admitted_iface = (env1.admitted_iface);
-        expect_typ = (env1.expect_typ);
-        remaining_iface_decls = (env1.remaining_iface_decls);
-        syntax_only = b;
-        ds_hooks = (env1.ds_hooks);
-        dep_graph = (env1.dep_graph)
-      }
-let (ds_hooks : env -> dsenv_hooks) = fun env1 -> env1.ds_hooks
-let (set_ds_hooks : env -> dsenv_hooks -> env) =
-  fun env1 ->
-    fun hooks ->
-      {
-        curmodule = (env1.curmodule);
-        curmonad = (env1.curmonad);
-        modules = (env1.modules);
-        scope_mods = (env1.scope_mods);
-        exported_ids = (env1.exported_ids);
-        trans_exported_ids = (env1.trans_exported_ids);
-        includes = (env1.includes);
-        sigaccum = (env1.sigaccum);
-        sigmap = (env1.sigmap);
-        iface = (env1.iface);
-        admitted_iface = (env1.admitted_iface);
-        expect_typ = (env1.expect_typ);
-        remaining_iface_decls = (env1.remaining_iface_decls);
-        syntax_only = (env1.syntax_only);
-        ds_hooks = hooks;
-        dep_graph = (env1.dep_graph)
-      }
-let new_sigmap : 'uuuuu . unit -> 'uuuuu FStar_Compiler_Util.smap =
-  fun uu___ -> FStar_Compiler_Util.smap_create (Prims.of_int (100))
-let (empty_env : FStar_Parser_Dep.deps -> env) =
-  fun deps ->
-    let uu___ = new_sigmap () in
-    let uu___1 = new_sigmap () in
-    let uu___2 = new_sigmap () in
-    let uu___3 = new_sigmap () in
-    {
-      curmodule = FStar_Pervasives_Native.None;
-      curmonad = FStar_Pervasives_Native.None;
-      modules = [];
-      scope_mods = [];
-      exported_ids = uu___;
-      trans_exported_ids = uu___1;
-      includes = uu___2;
-      sigaccum = [];
-      sigmap = uu___3;
-      iface = false;
-      admitted_iface = false;
-      expect_typ = false;
-      remaining_iface_decls = [];
-      syntax_only = false;
-      ds_hooks = default_ds_hooks;
-      dep_graph = deps
-    }
-let (dep_graph : env -> FStar_Parser_Dep.deps) = fun env1 -> env1.dep_graph
-let (set_dep_graph : env -> FStar_Parser_Dep.deps -> env) =
-  fun env1 ->
-    fun ds ->
-      {
-        curmodule = (env1.curmodule);
-        curmonad = (env1.curmonad);
-        modules = (env1.modules);
-        scope_mods = (env1.scope_mods);
-        exported_ids = (env1.exported_ids);
-        trans_exported_ids = (env1.trans_exported_ids);
-        includes = (env1.includes);
-        sigaccum = (env1.sigaccum);
-        sigmap = (env1.sigmap);
-        iface = (env1.iface);
-        admitted_iface = (env1.admitted_iface);
-        expect_typ = (env1.expect_typ);
-        remaining_iface_decls = (env1.remaining_iface_decls);
-        syntax_only = (env1.syntax_only);
-        ds_hooks = (env1.ds_hooks);
-        dep_graph = ds
-      }
-let (sigmap :
-  env -> (FStar_Syntax_Syntax.sigelt * Prims.bool) FStar_Compiler_Util.smap)
-  = fun env1 -> env1.sigmap
-let (has_all_in_scope : env -> Prims.bool) =
-  fun env1 ->
-    FStar_Compiler_List.existsb
-      (fun uu___ ->
-         match uu___ with
-         | (m, uu___1) -> FStar_Ident.lid_equals m FStar_Parser_Const.all_lid)
-      env1.modules
-let (set_bv_range :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Compiler_Range.range -> FStar_Syntax_Syntax.bv)
-  =
-  fun bv ->
-    fun r ->
-      let id = FStar_Ident.set_id_range r bv.FStar_Syntax_Syntax.ppname in
-      {
-        FStar_Syntax_Syntax.ppname = id;
-        FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-        FStar_Syntax_Syntax.sort = (bv.FStar_Syntax_Syntax.sort)
-      }
-let (bv_to_name :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Compiler_Range.range -> FStar_Syntax_Syntax.term)
-  =
-  fun bv ->
-    fun r ->
-      let uu___ = set_bv_range bv r in FStar_Syntax_Syntax.bv_to_name uu___
-let (unmangleMap :
-  (Prims.string * Prims.string * FStar_Syntax_Syntax.delta_depth *
-    FStar_Syntax_Syntax.fv_qual FStar_Pervasives_Native.option) Prims.list)
-  =
-  [("op_ColonColon", "Cons", FStar_Syntax_Syntax.delta_constant,
-     (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor));
-  ("not", "op_Negation", FStar_Syntax_Syntax.delta_equational,
-    FStar_Pervasives_Native.None)]
-let (unmangleOpName :
-  FStar_Ident.ident ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun id ->
-    FStar_Compiler_Util.find_map unmangleMap
-      (fun uu___ ->
-         match uu___ with
-         | (x, y, dd, dq) ->
-             let uu___1 =
-               let uu___2 = FStar_Ident.string_of_id id in uu___2 = x in
-             if uu___1
-             then
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Ident.range_of_id id in
-                   FStar_Ident.lid_of_path ["Prims"; y] uu___4 in
-                 FStar_Syntax_Syntax.fvar uu___3 dd dq in
-               FStar_Pervasives_Native.Some uu___2
-             else FStar_Pervasives_Native.None)
-type 'a cont_t =
-  | Cont_ok of 'a 
-  | Cont_fail 
-  | Cont_ignore 
-let uu___is_Cont_ok : 'a . 'a cont_t -> Prims.bool =
-  fun projectee -> match projectee with | Cont_ok _0 -> true | uu___ -> false
-let __proj__Cont_ok__item___0 : 'a . 'a cont_t -> 'a =
-  fun projectee -> match projectee with | Cont_ok _0 -> _0
-let uu___is_Cont_fail : 'a . 'a cont_t -> Prims.bool =
-  fun projectee -> match projectee with | Cont_fail -> true | uu___ -> false
-let uu___is_Cont_ignore : 'a . 'a cont_t -> Prims.bool =
-  fun projectee ->
-    match projectee with | Cont_ignore -> true | uu___ -> false
-let option_of_cont :
-  'a .
-    (unit -> 'a FStar_Pervasives_Native.option) ->
-      'a cont_t -> 'a FStar_Pervasives_Native.option
-  =
-  fun k_ignore ->
-    fun uu___ ->
-      match uu___ with
-      | Cont_ok a1 -> FStar_Pervasives_Native.Some a1
-      | Cont_fail -> FStar_Pervasives_Native.None
-      | Cont_ignore -> k_ignore ()
-let find_in_record :
-  'uuuuu .
-    FStar_Ident.ident Prims.list ->
-      FStar_Ident.ident ->
-        record_or_dc -> (record_or_dc -> 'uuuuu cont_t) -> 'uuuuu cont_t
-  =
-  fun ns ->
-    fun id ->
-      fun record ->
-        fun cont ->
-          let typename' =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Ident.ident_of_lid record.typename in
-                [uu___2] in
-              FStar_Compiler_List.op_At ns uu___1 in
-            FStar_Ident.lid_of_ids uu___ in
-          let uu___ = FStar_Ident.lid_equals typename' record.typename in
-          if uu___
-          then
-            let fname =
-              let uu___1 =
-                let uu___2 = FStar_Ident.ns_of_lid record.typename in
-                FStar_Compiler_List.op_At uu___2 [id] in
-              FStar_Ident.lid_of_ids uu___1 in
-            let find =
-              FStar_Compiler_Util.find_map record.fields
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (f, uu___2) ->
-                       let uu___3 =
-                         let uu___4 = FStar_Ident.string_of_id id in
-                         let uu___5 = FStar_Ident.string_of_id f in
-                         uu___4 = uu___5 in
-                       if uu___3
-                       then FStar_Pervasives_Native.Some record
-                       else FStar_Pervasives_Native.None) in
-            match find with
-            | FStar_Pervasives_Native.Some r -> cont r
-            | FStar_Pervasives_Native.None -> Cont_ignore
-          else Cont_ignore
-let (get_exported_id_set :
-  env ->
-    Prims.string ->
-      (exported_id_kind -> string_set FStar_Compiler_Effect.ref)
-        FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    fun mname -> FStar_Compiler_Util.smap_try_find e.exported_ids mname
-let (get_trans_exported_id_set :
-  env ->
-    Prims.string ->
-      (exported_id_kind -> string_set FStar_Compiler_Effect.ref)
-        FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    fun mname -> FStar_Compiler_Util.smap_try_find e.trans_exported_ids mname
-let (string_of_exported_id_kind : exported_id_kind -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Exported_id_field -> "field"
-    | Exported_id_term_type -> "term/type"
-let (is_exported_id_termtype : exported_id_kind -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with | Exported_id_term_type -> true | uu___1 -> false
-let (is_exported_id_field : exported_id_kind -> Prims.bool) =
-  fun uu___ -> match uu___ with | Exported_id_field -> true | uu___1 -> false
-let find_in_module_with_includes :
-  'a .
-    exported_id_kind ->
-      (FStar_Ident.lident -> 'a cont_t) ->
-        'a cont_t ->
-          env -> FStar_Ident.lident -> FStar_Ident.ident -> 'a cont_t
-  =
-  fun eikind ->
-    fun find_in_module ->
-      fun find_in_module_default ->
-        fun env1 ->
-          fun ns ->
-            fun id ->
-              let idstr = FStar_Ident.string_of_id id in
-              let rec aux uu___ =
-                match uu___ with
-                | [] -> find_in_module_default
-                | modul::q ->
-                    let mname = FStar_Ident.string_of_lid modul in
-                    let not_shadowed =
-                      let uu___1 = get_exported_id_set env1 mname in
-                      match uu___1 with
-                      | FStar_Pervasives_Native.None -> true
-                      | FStar_Pervasives_Native.Some mex ->
-                          let mexports =
-                            let uu___2 = mex eikind in
-                            FStar_Compiler_Effect.op_Bang uu___2 in
-                          FStar_Compiler_Util.set_mem idstr mexports in
-                    let mincludes =
-                      let uu___1 =
-                        FStar_Compiler_Util.smap_try_find env1.includes mname in
-                      match uu___1 with
-                      | FStar_Pervasives_Native.None -> []
-                      | FStar_Pervasives_Native.Some minc ->
-                          FStar_Compiler_Effect.op_Bang minc in
-                    let look_into =
-                      if not_shadowed
-                      then
-                        let uu___1 = qual modul id in find_in_module uu___1
-                      else Cont_ignore in
-                    (match look_into with
-                     | Cont_ignore ->
-                         aux (FStar_Compiler_List.op_At mincludes q)
-                     | uu___1 -> look_into) in
-              aux [ns]
-let try_lookup_id'' :
-  'a .
-    env ->
-      FStar_Ident.ident ->
-        exported_id_kind ->
-          (local_binding -> 'a cont_t) ->
-            (rec_binding -> 'a cont_t) ->
-              (record_or_dc -> 'a cont_t) ->
-                (FStar_Ident.lident -> 'a cont_t) ->
-                  ('a cont_t -> FStar_Ident.ident -> 'a cont_t) ->
-                    'a FStar_Pervasives_Native.option
-  =
-  fun env1 ->
-    fun id ->
-      fun eikind ->
-        fun k_local_binding ->
-          fun k_rec_binding ->
-            fun k_record ->
-              fun find_in_module ->
-                fun lookup_default_id ->
-                  let check_local_binding_id uu___ =
-                    match uu___ with
-                    | (id', uu___1, uu___2) ->
-                        let uu___3 = FStar_Ident.string_of_id id' in
-                        let uu___4 = FStar_Ident.string_of_id id in
-                        uu___3 = uu___4 in
-                  let check_rec_binding_id uu___ =
-                    match uu___ with
-                    | (id', uu___1, uu___2, uu___3) ->
-                        let uu___4 = FStar_Ident.string_of_id id' in
-                        let uu___5 = FStar_Ident.string_of_id id in
-                        uu___4 = uu___5 in
-                  let curmod_ns =
-                    let uu___ = current_module env1 in
-                    FStar_Ident.ids_of_lid uu___ in
-                  let proc uu___ =
-                    match uu___ with
-                    | Local_binding l when check_local_binding_id l ->
-                        let uu___1 = l in
-                        (match uu___1 with
-                         | (uu___2, uu___3, used_marker1) ->
-                             (FStar_Compiler_Effect.op_Colon_Equals
-                                used_marker1 true;
-                              k_local_binding l))
-                    | Rec_binding r when check_rec_binding_id r ->
-                        let uu___1 = r in
-                        (match uu___1 with
-                         | (uu___2, uu___3, uu___4, used_marker1) ->
-                             (FStar_Compiler_Effect.op_Colon_Equals
-                                used_marker1 true;
-                              k_rec_binding r))
-                    | Open_module_or_namespace (ns, Open_module) ->
-                        find_in_module_with_includes eikind find_in_module
-                          Cont_ignore env1 ns id
-                    | Top_level_def id' when
-                        let uu___1 = FStar_Ident.string_of_id id' in
-                        let uu___2 = FStar_Ident.string_of_id id in
-                        uu___1 = uu___2 -> lookup_default_id Cont_ignore id
-                    | Record_or_dc r when is_exported_id_field eikind ->
-                        let uu___1 = FStar_Ident.lid_of_ids curmod_ns in
-                        find_in_module_with_includes Exported_id_field
-                          (fun lid ->
-                             let id1 = FStar_Ident.ident_of_lid lid in
-                             let uu___2 = FStar_Ident.ns_of_lid lid in
-                             find_in_record uu___2 id1 r k_record)
-                          Cont_ignore env1 uu___1 id
-                    | Record_or_dc r when is_exported_id_termtype eikind ->
-                        let uu___1 =
-                          let uu___2 = FStar_Ident.ident_of_lid r.typename in
-                          FStar_Ident.ident_equals uu___2 id in
-                        if uu___1 then k_record r else Cont_ignore
-                    | uu___1 -> Cont_ignore in
-                  let rec aux uu___ =
-                    match uu___ with
-                    | a1::q ->
-                        let uu___1 = proc a1 in
-                        option_of_cont (fun uu___2 -> aux q) uu___1
-                    | [] ->
-                        let uu___1 = lookup_default_id Cont_fail id in
-                        option_of_cont
-                          (fun uu___2 -> FStar_Pervasives_Native.None) uu___1 in
-                  aux env1.scope_mods
-let found_local_binding :
-  'uuuuu 'uuuuu1 .
-    FStar_Compiler_Range.range ->
-      ('uuuuu * FStar_Syntax_Syntax.bv * 'uuuuu1) -> FStar_Syntax_Syntax.term
-  =
-  fun r -> fun uu___ -> match uu___ with | (id', x, uu___1) -> bv_to_name x r
-let find_in_module :
-  'uuuuu .
-    env ->
-      FStar_Ident.lident ->
-        (FStar_Ident.lident ->
-           (FStar_Syntax_Syntax.sigelt * Prims.bool) -> 'uuuuu)
-          -> 'uuuuu -> 'uuuuu
-  =
-  fun env1 ->
-    fun lid ->
-      fun k_global_def ->
-        fun k_not_found ->
-          let uu___ =
-            let uu___1 = FStar_Ident.string_of_lid lid in
-            FStar_Compiler_Util.smap_try_find (sigmap env1) uu___1 in
-          match uu___ with
-          | FStar_Pervasives_Native.Some sb -> k_global_def lid sb
-          | FStar_Pervasives_Native.None -> k_not_found
-let (try_lookup_id :
-  env ->
-    FStar_Ident.ident ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun id ->
-      let uu___ = unmangleOpName id in
-      match uu___ with
-      | FStar_Pervasives_Native.Some f -> FStar_Pervasives_Native.Some f
-      | uu___1 ->
-          try_lookup_id'' env1 id Exported_id_term_type
-            (fun r ->
-               let uu___2 =
-                 let uu___3 = FStar_Ident.range_of_id id in
-                 found_local_binding uu___3 r in
-               Cont_ok uu___2) (fun uu___2 -> Cont_fail)
-            (fun uu___2 -> Cont_ignore)
-            (fun i ->
-               find_in_module env1 i (fun uu___2 -> fun uu___3 -> Cont_fail)
-                 Cont_ignore) (fun uu___2 -> fun uu___3 -> Cont_fail)
-let lookup_default_id :
-  'a .
-    env ->
-      FStar_Ident.ident ->
-        (FStar_Ident.lident ->
-           (FStar_Syntax_Syntax.sigelt * Prims.bool) -> 'a cont_t)
-          -> 'a cont_t -> 'a cont_t
-  =
-  fun env1 ->
-    fun id ->
-      fun k_global_def ->
-        fun k_not_found ->
-          let find_in_monad =
-            match env1.curmonad with
-            | FStar_Pervasives_Native.Some uu___ ->
-                let lid = qualify env1 id in
-                let uu___1 =
-                  let uu___2 = FStar_Ident.string_of_lid lid in
-                  FStar_Compiler_Util.smap_try_find (sigmap env1) uu___2 in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.Some r ->
-                     let uu___2 = k_global_def lid r in
-                     FStar_Pervasives_Native.Some uu___2
-                 | FStar_Pervasives_Native.None ->
-                     FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None in
-          match find_in_monad with
-          | FStar_Pervasives_Native.Some v -> v
-          | FStar_Pervasives_Native.None ->
-              let lid = let uu___ = current_module env1 in qual uu___ id in
-              find_in_module env1 lid k_global_def k_not_found
-let (lid_is_curmod : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      match env1.curmodule with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some m -> FStar_Ident.lid_equals lid m
-let (module_is_defined : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      (lid_is_curmod env1 lid) ||
-        (FStar_Compiler_List.existsb
-           (fun x ->
-              FStar_Ident.lid_equals lid (FStar_Pervasives_Native.fst x))
-           env1.modules)
-let (resolve_module_name :
-  env ->
-    FStar_Ident.lident ->
-      Prims.bool -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      fun honor_ns ->
-        let nslen =
-          let uu___ = FStar_Ident.ns_of_lid lid in
-          FStar_Compiler_List.length uu___ in
-        let rec aux uu___ =
-          match uu___ with
-          | [] ->
-              let uu___1 = module_is_defined env1 lid in
-              if uu___1
-              then FStar_Pervasives_Native.Some lid
-              else FStar_Pervasives_Native.None
-          | (Open_module_or_namespace (ns, Open_namespace))::q when honor_ns
-              ->
-              let new_lid =
-                let uu___1 =
-                  let uu___2 = FStar_Ident.path_of_lid ns in
-                  let uu___3 = FStar_Ident.path_of_lid lid in
-                  FStar_Compiler_List.op_At uu___2 uu___3 in
-                let uu___2 = FStar_Ident.range_of_lid lid in
-                FStar_Ident.lid_of_path uu___1 uu___2 in
-              let uu___1 = module_is_defined env1 new_lid in
-              if uu___1 then FStar_Pervasives_Native.Some new_lid else aux q
-          | (Module_abbrev (name, modul))::uu___1 when
-              (nslen = Prims.int_zero) &&
-                (let uu___2 = FStar_Ident.string_of_id name in
-                 let uu___3 =
-                   let uu___4 = FStar_Ident.ident_of_lid lid in
-                   FStar_Ident.string_of_id uu___4 in
-                 uu___2 = uu___3)
-              -> FStar_Pervasives_Native.Some modul
-          | uu___1::q -> aux q in
-        aux env1.scope_mods
-let (is_open : env -> FStar_Ident.lident -> open_kind -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      fun open_kind1 ->
-        FStar_Compiler_List.existsb
-          (fun uu___ ->
-             match uu___ with
-             | Open_module_or_namespace (ns, k) ->
-                 (k = open_kind1) && (FStar_Ident.lid_equals lid ns)
-             | uu___1 -> false) env1.scope_mods
-let (namespace_is_open : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 -> fun lid -> is_open env1 lid Open_namespace
-let (module_is_open : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid -> (lid_is_curmod env1 lid) || (is_open env1 lid Open_module)
-let (shorten_module_path :
-  env ->
-    FStar_Ident.ident Prims.list ->
-      Prims.bool ->
-        (FStar_Ident.ident Prims.list * FStar_Ident.ident Prims.list))
-  =
-  fun env1 ->
-    fun ids ->
-      fun is_full_path ->
-        let rec aux revns id =
-          let lid =
-            FStar_Ident.lid_of_ns_and_id (FStar_Compiler_List.rev revns) id in
-          let uu___ = namespace_is_open env1 lid in
-          if uu___
-          then
-            FStar_Pervasives_Native.Some
-              ((FStar_Compiler_List.rev (id :: revns)), [])
-          else
-            (match revns with
-             | [] -> FStar_Pervasives_Native.None
-             | ns_last_id::rev_ns_prefix ->
-                 let uu___2 = aux rev_ns_prefix ns_last_id in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___2
-                   (FStar_Compiler_Util.map_option
-                      (fun uu___3 ->
-                         match uu___3 with
-                         | (stripped_ids, rev_kept_ids) ->
-                             (stripped_ids, (id :: rev_kept_ids))))) in
-        let do_shorten env2 ids1 =
-          match FStar_Compiler_List.rev ids1 with
-          | [] -> ([], [])
-          | ns_last_id::ns_rev_prefix ->
-              let uu___ = aux ns_rev_prefix ns_last_id in
-              (match uu___ with
-               | FStar_Pervasives_Native.None -> ([], ids1)
-               | FStar_Pervasives_Native.Some (stripped_ids, rev_kept_ids) ->
-                   (stripped_ids, (FStar_Compiler_List.rev rev_kept_ids))) in
-        if
-          is_full_path && ((FStar_Compiler_List.length ids) > Prims.int_zero)
-        then
-          let uu___ =
-            let uu___1 = FStar_Ident.lid_of_ids ids in
-            resolve_module_name env1 uu___1 true in
-          match uu___ with
-          | FStar_Pervasives_Native.Some m when module_is_open env1 m ->
-              (ids, [])
-          | uu___1 -> do_shorten env1 ids
-        else do_shorten env1 ids
-let resolve_in_open_namespaces'' :
-  'a .
-    env ->
-      FStar_Ident.lident ->
-        exported_id_kind ->
-          (local_binding -> 'a cont_t) ->
-            (rec_binding -> 'a cont_t) ->
-              (record_or_dc -> 'a cont_t) ->
-                (FStar_Ident.lident -> 'a cont_t) ->
-                  ('a cont_t -> FStar_Ident.ident -> 'a cont_t) ->
-                    'a FStar_Pervasives_Native.option
-  =
-  fun env1 ->
-    fun lid ->
-      fun eikind ->
-        fun k_local_binding ->
-          fun k_rec_binding ->
-            fun k_record ->
-              fun f_module ->
-                fun l_default ->
-                  let uu___ = FStar_Ident.ns_of_lid lid in
-                  match uu___ with
-                  | uu___1::uu___2 ->
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Ident.ns_of_lid lid in
-                            FStar_Ident.lid_of_ids uu___6 in
-                          let uu___6 = FStar_Ident.range_of_lid lid in
-                          FStar_Ident.set_lid_range uu___5 uu___6 in
-                        resolve_module_name env1 uu___4 true in
-                      (match uu___3 with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.None
-                       | FStar_Pervasives_Native.Some modul ->
-                           let uu___4 =
-                             let uu___5 = FStar_Ident.ident_of_lid lid in
-                             find_in_module_with_includes eikind f_module
-                               Cont_fail env1 modul uu___5 in
-                           option_of_cont
-                             (fun uu___5 -> FStar_Pervasives_Native.None)
-                             uu___4)
-                  | [] ->
-                      let uu___1 = FStar_Ident.ident_of_lid lid in
-                      try_lookup_id'' env1 uu___1 eikind k_local_binding
-                        k_rec_binding k_record f_module l_default
-let cont_of_option :
-  'a . 'a cont_t -> 'a FStar_Pervasives_Native.option -> 'a cont_t =
-  fun k_none ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some v -> Cont_ok v
-      | FStar_Pervasives_Native.None -> k_none
-let resolve_in_open_namespaces' :
-  'a .
-    env ->
-      FStar_Ident.lident ->
-        (local_binding -> 'a FStar_Pervasives_Native.option) ->
-          (rec_binding -> 'a FStar_Pervasives_Native.option) ->
-            (FStar_Ident.lident ->
-               (FStar_Syntax_Syntax.sigelt * Prims.bool) ->
-                 'a FStar_Pervasives_Native.option)
-              -> 'a FStar_Pervasives_Native.option
-  =
-  fun env1 ->
-    fun lid ->
-      fun k_local_binding ->
-        fun k_rec_binding ->
-          fun k_global_def ->
-            let k_global_def' k lid1 def =
-              let uu___ = k_global_def lid1 def in cont_of_option k uu___ in
-            let f_module lid' =
-              let k = Cont_ignore in
-              find_in_module env1 lid' (k_global_def' k) k in
-            let l_default k i = lookup_default_id env1 i (k_global_def' k) k in
-            resolve_in_open_namespaces'' env1 lid Exported_id_term_type
-              (fun l ->
-                 let uu___ = k_local_binding l in
-                 cont_of_option Cont_fail uu___)
-              (fun r ->
-                 let uu___ = k_rec_binding r in
-                 cont_of_option Cont_fail uu___) (fun uu___ -> Cont_ignore)
-              f_module l_default
-let (fv_qual_of_se :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Syntax_Syntax.fv_qual FStar_Pervasives_Native.option)
-  =
-  fun se ->
-    match se.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_datacon
-        (uu___, uu___1, uu___2, l, uu___3, uu___4) ->
-        let qopt =
-          FStar_Compiler_Util.find_map se.FStar_Syntax_Syntax.sigquals
-            (fun uu___5 ->
-               match uu___5 with
-               | FStar_Syntax_Syntax.RecordConstructor (uu___6, fs) ->
-                   FStar_Pervasives_Native.Some
-                     (FStar_Syntax_Syntax.Record_ctor (l, fs))
-               | uu___6 -> FStar_Pervasives_Native.None) in
-        (match qopt with
-         | FStar_Pervasives_Native.None ->
-             FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor
-         | x -> x)
-    | FStar_Syntax_Syntax.Sig_declare_typ (uu___, uu___1, uu___2) ->
-        FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (lb_fv :
-  FStar_Syntax_Syntax.letbinding Prims.list ->
-    FStar_Ident.lident -> FStar_Syntax_Syntax.fv)
-  =
-  fun lbs ->
-    fun lid ->
-      let uu___ =
-        FStar_Compiler_Util.find_map lbs
-          (fun lb ->
-             let fv = FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-             let uu___1 = FStar_Syntax_Syntax.fv_eq_lid fv lid in
-             if uu___1
-             then FStar_Pervasives_Native.Some fv
-             else FStar_Pervasives_Native.None) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Compiler_Util.must
-let (ns_of_lid_equals :
-  FStar_Ident.lident -> FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    fun ns ->
-      (let uu___ =
-         let uu___1 = FStar_Ident.ns_of_lid lid in
-         FStar_Compiler_List.length uu___1 in
-       let uu___1 =
-         let uu___2 = FStar_Ident.ids_of_lid ns in
-         FStar_Compiler_List.length uu___2 in
-       uu___ = uu___1) &&
-        (let uu___ =
-           let uu___1 = FStar_Ident.ns_of_lid lid in
-           FStar_Ident.lid_of_ids uu___1 in
-         FStar_Ident.lid_equals uu___ ns)
-let (delta_depth_of_declaration :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Syntax_Syntax.delta_depth)
-  =
-  fun lid ->
-    fun quals ->
-      let dd =
-        let uu___ =
-          (FStar_Syntax_Util.is_primop_lid lid) ||
-            (FStar_Compiler_Effect.op_Bar_Greater quals
-               (FStar_Compiler_Util.for_some
-                  (fun uu___1 ->
-                     match uu___1 with
-                     | FStar_Syntax_Syntax.Projector uu___2 -> true
-                     | FStar_Syntax_Syntax.Discriminator uu___2 -> true
-                     | uu___2 -> false))) in
-        if uu___
-        then FStar_Syntax_Syntax.delta_equational
-        else FStar_Syntax_Syntax.delta_constant in
-      let uu___ =
-        (FStar_Compiler_Effect.op_Bar_Greater quals
-           (FStar_Compiler_Util.for_some
-              (fun uu___1 ->
-                 match uu___1 with
-                 | FStar_Syntax_Syntax.Assumption -> true
-                 | uu___2 -> false)))
-          &&
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Bar_Greater quals
-               (FStar_Compiler_Util.for_some
-                  (fun uu___2 ->
-                     match uu___2 with
-                     | FStar_Syntax_Syntax.New -> true
-                     | uu___3 -> false)) in
-           Prims.op_Negation uu___1) in
-      if uu___ then FStar_Syntax_Syntax.Delta_abstract dd else dd
-let (try_lookup_name :
-  Prims.bool ->
-    Prims.bool ->
-      env -> FStar_Ident.lident -> foundname FStar_Pervasives_Native.option)
-  =
-  fun any_val ->
-    fun exclude_interf ->
-      fun env1 ->
-        fun lid ->
-          let occurrence_range = FStar_Ident.range_of_lid lid in
-          let k_global_def source_lid uu___ =
-            match uu___ with
-            | (uu___1, true) when exclude_interf ->
-                FStar_Pervasives_Native.None
-            | (se, uu___1) ->
-                (match se.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_inductive_typ uu___2 ->
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Syntax_Syntax.fvar source_lid
-                             FStar_Syntax_Syntax.delta_constant
-                             FStar_Pervasives_Native.None in
-                         (uu___5, (se.FStar_Syntax_Syntax.sigattrs)) in
-                       Term_name uu___4 in
-                     FStar_Pervasives_Native.Some uu___3
-                 | FStar_Syntax_Syntax.Sig_datacon uu___2 ->
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 = fv_qual_of_se se in
-                           FStar_Syntax_Syntax.fvar source_lid
-                             FStar_Syntax_Syntax.delta_constant uu___6 in
-                         (uu___5, (se.FStar_Syntax_Syntax.sigattrs)) in
-                       Term_name uu___4 in
-                     FStar_Pervasives_Native.Some uu___3
-                 | FStar_Syntax_Syntax.Sig_let ((uu___2, lbs), uu___3) ->
-                     let fv = lb_fv lbs source_lid in
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Syntax_Syntax.fvar source_lid
-                             fv.FStar_Syntax_Syntax.fv_delta
-                             fv.FStar_Syntax_Syntax.fv_qual in
-                         (uu___6, (se.FStar_Syntax_Syntax.sigattrs)) in
-                       Term_name uu___5 in
-                     FStar_Pervasives_Native.Some uu___4
-                 | FStar_Syntax_Syntax.Sig_declare_typ (lid1, uu___2, uu___3)
-                     ->
-                     let quals = se.FStar_Syntax_Syntax.sigquals in
-                     let uu___4 =
-                       any_val ||
-                         (FStar_Compiler_Effect.op_Bar_Greater quals
-                            (FStar_Compiler_Util.for_some
-                               (fun uu___5 ->
-                                  match uu___5 with
-                                  | FStar_Syntax_Syntax.Assumption -> true
-                                  | uu___6 -> false))) in
-                     if uu___4
-                     then
-                       let lid2 =
-                         let uu___5 = FStar_Ident.range_of_lid source_lid in
-                         FStar_Ident.set_lid_range lid1 uu___5 in
-                       let dd = delta_depth_of_declaration lid2 quals in
-                       let uu___5 =
-                         FStar_Compiler_Util.find_map quals
-                           (fun uu___6 ->
-                              match uu___6 with
-                              | FStar_Syntax_Syntax.Reflectable refl_monad ->
-                                  FStar_Pervasives_Native.Some refl_monad
-                              | uu___7 -> FStar_Pervasives_Native.None) in
-                       (match uu___5 with
-                        | FStar_Pervasives_Native.Some refl_monad ->
-                            let refl_const =
-                              FStar_Syntax_Syntax.mk
-                                (FStar_Syntax_Syntax.Tm_constant
-                                   (FStar_Const.Const_reflect refl_monad))
-                                occurrence_range in
-                            FStar_Pervasives_Native.Some
-                              (Term_name
-                                 (refl_const,
-                                   (se.FStar_Syntax_Syntax.sigattrs)))
-                        | uu___6 ->
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 = fv_qual_of_se se in
-                                  FStar_Syntax_Syntax.fvar lid2 dd uu___10 in
-                                (uu___9, (se.FStar_Syntax_Syntax.sigattrs)) in
-                              Term_name uu___8 in
-                            FStar_Pervasives_Native.Some uu___7)
-                     else FStar_Pervasives_Native.None
-                 | FStar_Syntax_Syntax.Sig_new_effect ne ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 = FStar_Ident.range_of_lid source_lid in
-                           FStar_Ident.set_lid_range
-                             ne.FStar_Syntax_Syntax.mname uu___5 in
-                         (se, uu___4) in
-                       Eff_name uu___3 in
-                     FStar_Pervasives_Native.Some uu___2
-                 | FStar_Syntax_Syntax.Sig_effect_abbrev uu___2 ->
-                     FStar_Pervasives_Native.Some (Eff_name (se, source_lid))
-                 | FStar_Syntax_Syntax.Sig_splice (lids, t) ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_Syntax_Syntax.fvar source_lid
-                             (FStar_Syntax_Syntax.Delta_constant_at_level
-                                Prims.int_one) FStar_Pervasives_Native.None in
-                         (uu___4, []) in
-                       Term_name uu___3 in
-                     FStar_Pervasives_Native.Some uu___2
-                 | uu___2 -> FStar_Pervasives_Native.None) in
-          let k_local_binding r =
-            let t =
-              let uu___ = FStar_Ident.range_of_lid lid in
-              found_local_binding uu___ r in
-            FStar_Pervasives_Native.Some (Term_name (t, [])) in
-          let k_rec_binding uu___ =
-            match uu___ with
-            | (id, l, dd, used_marker1) ->
-                (FStar_Compiler_Effect.op_Colon_Equals used_marker1 true;
-                 (let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 = FStar_Ident.range_of_lid lid in
-                          FStar_Ident.set_lid_range l uu___6 in
-                        FStar_Syntax_Syntax.fvar uu___5 dd
-                          FStar_Pervasives_Native.None in
-                      (uu___4, []) in
-                    Term_name uu___3 in
-                  FStar_Pervasives_Native.Some uu___2)) in
-          let found_unmangled =
-            let uu___ = FStar_Ident.ns_of_lid lid in
-            match uu___ with
-            | [] ->
-                let uu___1 =
-                  let uu___2 = FStar_Ident.ident_of_lid lid in
-                  unmangleOpName uu___2 in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.Some t ->
-                     FStar_Pervasives_Native.Some (Term_name (t, []))
-                 | uu___2 -> FStar_Pervasives_Native.None)
-            | uu___1 -> FStar_Pervasives_Native.None in
-          match found_unmangled with
-          | FStar_Pervasives_Native.None ->
-              resolve_in_open_namespaces' env1 lid k_local_binding
-                k_rec_binding k_global_def
-          | x -> x
-let (try_lookup_effect_name' :
-  Prims.bool ->
-    env ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.sigelt * FStar_Ident.lident)
-          FStar_Pervasives_Native.option)
-  =
-  fun exclude_interf ->
-    fun env1 ->
-      fun lid ->
-        let uu___ = try_lookup_name true exclude_interf env1 lid in
-        match uu___ with
-        | FStar_Pervasives_Native.Some (Eff_name (o, l)) ->
-            FStar_Pervasives_Native.Some (o, l)
-        | uu___1 -> FStar_Pervasives_Native.None
-let (try_lookup_effect_name :
-  env ->
-    FStar_Ident.lident -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ =
-        try_lookup_effect_name' (Prims.op_Negation env1.iface) env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (o, l1) ->
-          FStar_Pervasives_Native.Some l1
-      | uu___1 -> FStar_Pervasives_Native.None
-let (try_lookup_effect_name_and_attributes :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Ident.lident * FStar_Syntax_Syntax.cflag Prims.list)
-        FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ =
-        try_lookup_effect_name' (Prims.op_Negation env1.iface) env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_new_effect
-               ne;
-             FStar_Syntax_Syntax.sigrng = uu___1;
-             FStar_Syntax_Syntax.sigquals = uu___2;
-             FStar_Syntax_Syntax.sigmeta = uu___3;
-             FStar_Syntax_Syntax.sigattrs = uu___4;
-             FStar_Syntax_Syntax.sigopts = uu___5;_},
-           l1)
-          ->
-          FStar_Pervasives_Native.Some
-            (l1, (ne.FStar_Syntax_Syntax.cattributes))
-      | FStar_Pervasives_Native.Some
-          ({
-             FStar_Syntax_Syntax.sigel =
-               FStar_Syntax_Syntax.Sig_effect_abbrev
-               (uu___1, uu___2, uu___3, uu___4, cattributes);
-             FStar_Syntax_Syntax.sigrng = uu___5;
-             FStar_Syntax_Syntax.sigquals = uu___6;
-             FStar_Syntax_Syntax.sigmeta = uu___7;
-             FStar_Syntax_Syntax.sigattrs = uu___8;
-             FStar_Syntax_Syntax.sigopts = uu___9;_},
-           l1)
-          -> FStar_Pervasives_Native.Some (l1, cattributes)
-      | uu___1 -> FStar_Pervasives_Native.None
-let (try_lookup_effect_defn :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.eff_decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ =
-        try_lookup_effect_name' (Prims.op_Negation env1.iface) env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_new_effect
-               ne;
-             FStar_Syntax_Syntax.sigrng = uu___1;
-             FStar_Syntax_Syntax.sigquals = uu___2;
-             FStar_Syntax_Syntax.sigmeta = uu___3;
-             FStar_Syntax_Syntax.sigattrs = uu___4;
-             FStar_Syntax_Syntax.sigopts = uu___5;_},
-           uu___6)
-          -> FStar_Pervasives_Native.Some ne
-      | uu___1 -> FStar_Pervasives_Native.None
-let (is_effect_name : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = try_lookup_effect_name env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some uu___1 -> true
-let (try_lookup_root_effect_name :
-  env ->
-    FStar_Ident.lident -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ =
-        try_lookup_effect_name' (Prims.op_Negation env1.iface) env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          ({
-             FStar_Syntax_Syntax.sigel =
-               FStar_Syntax_Syntax.Sig_effect_abbrev
-               (l', uu___1, uu___2, uu___3, uu___4);
-             FStar_Syntax_Syntax.sigrng = uu___5;
-             FStar_Syntax_Syntax.sigquals = uu___6;
-             FStar_Syntax_Syntax.sigmeta = uu___7;
-             FStar_Syntax_Syntax.sigattrs = uu___8;
-             FStar_Syntax_Syntax.sigopts = uu___9;_},
-           uu___10)
-          ->
-          let rec aux new_name =
-            let uu___11 =
-              let uu___12 = FStar_Ident.string_of_lid new_name in
-              FStar_Compiler_Util.smap_try_find (sigmap env1) uu___12 in
-            match uu___11 with
-            | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-            | FStar_Pervasives_Native.Some (s, uu___12) ->
-                (match s.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_new_effect ne ->
-                     let uu___13 =
-                       let uu___14 = FStar_Ident.range_of_lid l in
-                       FStar_Ident.set_lid_range ne.FStar_Syntax_Syntax.mname
-                         uu___14 in
-                     FStar_Pervasives_Native.Some uu___13
-                 | FStar_Syntax_Syntax.Sig_effect_abbrev
-                     (uu___13, uu___14, uu___15, cmp, uu___16) ->
-                     let l'' = FStar_Syntax_Util.comp_effect_name cmp in
-                     aux l''
-                 | uu___13 -> FStar_Pervasives_Native.None) in
-          aux l'
-      | FStar_Pervasives_Native.Some (uu___1, l') ->
-          FStar_Pervasives_Native.Some l'
-      | uu___1 -> FStar_Pervasives_Native.None
-let (lookup_letbinding_quals_and_attrs :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.qualifier Prims.list *
-        FStar_Syntax_Syntax.attribute Prims.list))
-  =
-  fun env1 ->
-    fun lid ->
-      let k_global_def lid1 uu___ =
-        match uu___ with
-        | ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_declare_typ
-               (uu___1, uu___2, uu___3);
-             FStar_Syntax_Syntax.sigrng = uu___4;
-             FStar_Syntax_Syntax.sigquals = quals;
-             FStar_Syntax_Syntax.sigmeta = uu___5;
-             FStar_Syntax_Syntax.sigattrs = attrs;
-             FStar_Syntax_Syntax.sigopts = uu___6;_},
-           uu___7) -> FStar_Pervasives_Native.Some (quals, attrs)
-        | uu___1 -> FStar_Pervasives_Native.None in
-      let uu___ =
-        resolve_in_open_namespaces' env1 lid
-          (fun uu___1 -> FStar_Pervasives_Native.None)
-          (fun uu___1 -> FStar_Pervasives_Native.None) k_global_def in
-      match uu___ with
-      | FStar_Pervasives_Native.Some qa -> qa
-      | uu___1 -> ([], [])
-let (try_lookup_module :
-  env ->
-    FStar_Ident.path ->
-      FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun path ->
-      let uu___ =
-        FStar_Compiler_List.tryFind
-          (fun uu___1 ->
-             match uu___1 with
-             | (mlid, modul) ->
-                 let uu___2 = FStar_Ident.path_of_lid mlid in uu___2 = path)
-          env1.modules in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (uu___1, modul) ->
-          FStar_Pervasives_Native.Some modul
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (try_lookup_let :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let k_global_def lid1 uu___ =
-        match uu___ with
-        | ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_let
-               ((uu___1, lbs), uu___2);
-             FStar_Syntax_Syntax.sigrng = uu___3;
-             FStar_Syntax_Syntax.sigquals = uu___4;
-             FStar_Syntax_Syntax.sigmeta = uu___5;
-             FStar_Syntax_Syntax.sigattrs = uu___6;
-             FStar_Syntax_Syntax.sigopts = uu___7;_},
-           uu___8) ->
-            let fv = lb_fv lbs lid1 in
-            let uu___9 =
-              FStar_Syntax_Syntax.fvar lid1 fv.FStar_Syntax_Syntax.fv_delta
-                fv.FStar_Syntax_Syntax.fv_qual in
-            FStar_Pervasives_Native.Some uu___9
-        | uu___1 -> FStar_Pervasives_Native.None in
-      resolve_in_open_namespaces' env1 lid
-        (fun uu___ -> FStar_Pervasives_Native.None)
-        (fun uu___ -> FStar_Pervasives_Native.None) k_global_def
-let (try_lookup_definition :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let k_global_def lid1 uu___ =
-        match uu___ with
-        | ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_let
-               (lbs, uu___1);
-             FStar_Syntax_Syntax.sigrng = uu___2;
-             FStar_Syntax_Syntax.sigquals = uu___3;
-             FStar_Syntax_Syntax.sigmeta = uu___4;
-             FStar_Syntax_Syntax.sigattrs = uu___5;
-             FStar_Syntax_Syntax.sigopts = uu___6;_},
-           uu___7) ->
-            FStar_Compiler_Util.find_map (FStar_Pervasives_Native.snd lbs)
-              (fun lb ->
-                 match lb.FStar_Syntax_Syntax.lbname with
-                 | FStar_Pervasives.Inr fv when
-                     FStar_Syntax_Syntax.fv_eq_lid fv lid1 ->
-                     FStar_Pervasives_Native.Some
-                       (lb.FStar_Syntax_Syntax.lbdef)
-                 | uu___8 -> FStar_Pervasives_Native.None)
-        | uu___1 -> FStar_Pervasives_Native.None in
-      resolve_in_open_namespaces' env1 lid
-        (fun uu___ -> FStar_Pervasives_Native.None)
-        (fun uu___ -> FStar_Pervasives_Native.None) k_global_def
-let (empty_include_smap :
-  FStar_Ident.lident Prims.list FStar_Compiler_Effect.ref
-    FStar_Compiler_Util.smap)
-  = new_sigmap ()
-let (empty_exported_id_smap : exported_id_set FStar_Compiler_Util.smap) =
-  new_sigmap ()
-let (try_lookup_lid' :
-  Prims.bool ->
-    Prims.bool ->
-      env ->
-        FStar_Ident.lident ->
-          (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.attribute
-            Prims.list) FStar_Pervasives_Native.option)
-  =
-  fun any_val ->
-    fun exclude_interface ->
-      fun env1 ->
-        fun lid ->
-          let uu___ = try_lookup_name any_val exclude_interface env1 lid in
-          match uu___ with
-          | FStar_Pervasives_Native.Some (Term_name (e, attrs)) ->
-              FStar_Pervasives_Native.Some (e, attrs)
-          | uu___1 -> FStar_Pervasives_Native.None
-let (drop_attributes :
-  (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.attribute Prims.list)
-    FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun x ->
-    match x with
-    | FStar_Pervasives_Native.Some (t, uu___) ->
-        FStar_Pervasives_Native.Some t
-    | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (try_lookup_lid_with_attributes :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.attribute Prims.list)
-        FStar_Pervasives_Native.option)
-  = fun env1 -> fun l -> try_lookup_lid' env1.iface false env1 l
-let (try_lookup_lid :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ = try_lookup_lid_with_attributes env1 l in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ drop_attributes
-let (resolve_to_fully_qualified_name :
-  env ->
-    FStar_Ident.lident -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ = try_lookup_lid env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some e ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Subst.compress e in
-            uu___2.FStar_Syntax_Syntax.n in
-          (match uu___1 with
-           | FStar_Syntax_Syntax.Tm_fvar fv ->
-               FStar_Pervasives_Native.Some
-                 ((fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-           | uu___2 -> FStar_Pervasives_Native.None)
-let (shorten_lid' : env -> FStar_Ident.lident -> FStar_Ident.lident) =
-  fun env1 ->
-    fun lid ->
-      let uu___ =
-        let uu___1 = FStar_Ident.ns_of_lid lid in
-        shorten_module_path env1 uu___1 true in
-      match uu___ with
-      | (uu___1, short) ->
-          let uu___2 = FStar_Ident.ident_of_lid lid in
-          FStar_Ident.lid_of_ns_and_id short uu___2
-let (shorten_lid : env -> FStar_Ident.lid -> FStar_Ident.lid) =
-  fun env1 ->
-    fun lid ->
-      match env1.curmodule with
-      | FStar_Pervasives_Native.None -> shorten_lid' env1 lid
-      | uu___ ->
-          let lid_without_ns =
-            let uu___1 = FStar_Ident.ident_of_lid lid in
-            FStar_Ident.lid_of_ns_and_id [] uu___1 in
-          let uu___1 = resolve_to_fully_qualified_name env1 lid_without_ns in
-          (match uu___1 with
-           | FStar_Pervasives_Native.Some lid' when
-               let uu___2 = FStar_Ident.string_of_lid lid' in
-               let uu___3 = FStar_Ident.string_of_lid lid in uu___2 = uu___3
-               -> lid_without_ns
-           | uu___2 -> shorten_lid' env1 lid)
-let (try_lookup_lid_with_attributes_no_resolve :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.attribute Prims.list)
-        FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let env' =
-        {
-          curmodule = (env1.curmodule);
-          curmonad = (env1.curmonad);
-          modules = (env1.modules);
-          scope_mods = [];
-          exported_ids = empty_exported_id_smap;
-          trans_exported_ids = (env1.trans_exported_ids);
-          includes = empty_include_smap;
-          sigaccum = (env1.sigaccum);
-          sigmap = (env1.sigmap);
-          iface = (env1.iface);
-          admitted_iface = (env1.admitted_iface);
-          expect_typ = (env1.expect_typ);
-          remaining_iface_decls = (env1.remaining_iface_decls);
-          syntax_only = (env1.syntax_only);
-          ds_hooks = (env1.ds_hooks);
-          dep_graph = (env1.dep_graph)
-        } in
-      try_lookup_lid_with_attributes env' l
-let (try_lookup_lid_no_resolve :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ = try_lookup_lid_with_attributes_no_resolve env1 l in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ drop_attributes
-let (try_lookup_datacon :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.fv FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let k_global_def lid1 se =
-        match se with
-        | ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_declare_typ
-               (uu___, uu___1, uu___2);
-             FStar_Syntax_Syntax.sigrng = uu___3;
-             FStar_Syntax_Syntax.sigquals = quals;
-             FStar_Syntax_Syntax.sigmeta = uu___4;
-             FStar_Syntax_Syntax.sigattrs = uu___5;
-             FStar_Syntax_Syntax.sigopts = uu___6;_},
-           uu___7) ->
-            let uu___8 =
-              FStar_Compiler_Effect.op_Bar_Greater quals
-                (FStar_Compiler_Util.for_some
-                   (fun uu___9 ->
-                      match uu___9 with
-                      | FStar_Syntax_Syntax.Assumption -> true
-                      | uu___10 -> false)) in
-            if uu___8
-            then
-              let uu___9 =
-                FStar_Syntax_Syntax.lid_as_fv lid1
-                  FStar_Syntax_Syntax.delta_constant
-                  FStar_Pervasives_Native.None in
-              FStar_Pervasives_Native.Some uu___9
-            else FStar_Pervasives_Native.None
-        | ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_splice uu___;
-             FStar_Syntax_Syntax.sigrng = uu___1;
-             FStar_Syntax_Syntax.sigquals = uu___2;
-             FStar_Syntax_Syntax.sigmeta = uu___3;
-             FStar_Syntax_Syntax.sigattrs = uu___4;
-             FStar_Syntax_Syntax.sigopts = uu___5;_},
-           uu___6) ->
-            let qual1 = fv_qual_of_se (FStar_Pervasives_Native.fst se) in
-            let uu___7 =
-              FStar_Syntax_Syntax.lid_as_fv lid1
-                FStar_Syntax_Syntax.delta_constant qual1 in
-            FStar_Pervasives_Native.Some uu___7
-        | ({
-             FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-               uu___;
-             FStar_Syntax_Syntax.sigrng = uu___1;
-             FStar_Syntax_Syntax.sigquals = uu___2;
-             FStar_Syntax_Syntax.sigmeta = uu___3;
-             FStar_Syntax_Syntax.sigattrs = uu___4;
-             FStar_Syntax_Syntax.sigopts = uu___5;_},
-           uu___6) ->
-            let qual1 = fv_qual_of_se (FStar_Pervasives_Native.fst se) in
-            let uu___7 =
-              FStar_Syntax_Syntax.lid_as_fv lid1
-                FStar_Syntax_Syntax.delta_constant qual1 in
-            FStar_Pervasives_Native.Some uu___7
-        | uu___ -> FStar_Pervasives_Native.None in
-      resolve_in_open_namespaces' env1 lid
-        (fun uu___ -> FStar_Pervasives_Native.None)
-        (fun uu___ -> FStar_Pervasives_Native.None) k_global_def
-let (find_all_datacons :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let k_global_def lid1 uu___ =
-        match uu___ with
-        | ({
-             FStar_Syntax_Syntax.sigel =
-               FStar_Syntax_Syntax.Sig_inductive_typ
-               (uu___1, uu___2, uu___3, uu___4, uu___5, datas, uu___6);
-             FStar_Syntax_Syntax.sigrng = uu___7;
-             FStar_Syntax_Syntax.sigquals = uu___8;
-             FStar_Syntax_Syntax.sigmeta = uu___9;
-             FStar_Syntax_Syntax.sigattrs = uu___10;
-             FStar_Syntax_Syntax.sigopts = uu___11;_},
-           uu___12) -> FStar_Pervasives_Native.Some datas
-        | uu___1 -> FStar_Pervasives_Native.None in
-      resolve_in_open_namespaces' env1 lid
-        (fun uu___ -> FStar_Pervasives_Native.None)
-        (fun uu___ -> FStar_Pervasives_Native.None) k_global_def
-let (record_cache_aux_with_filter :
-  ((((unit -> unit) * (unit -> unit)) * (((unit -> (Prims.int * unit)) *
-    (Prims.int FStar_Pervasives_Native.option -> unit)) *
-    ((unit -> record_or_dc Prims.list) * (record_or_dc -> unit)))) *
-    (unit -> unit)))
-  =
-  let record_cache = FStar_Compiler_Util.mk_ref [[]] in
-  let push uu___ =
-    let uu___1 =
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Effect.op_Bang record_cache in
-        FStar_Compiler_List.hd uu___3 in
-      let uu___3 = FStar_Compiler_Effect.op_Bang record_cache in uu___2 ::
-        uu___3 in
-    FStar_Compiler_Effect.op_Colon_Equals record_cache uu___1 in
-  let pop uu___ =
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang record_cache in
-      FStar_Compiler_List.tl uu___2 in
-    FStar_Compiler_Effect.op_Colon_Equals record_cache uu___1 in
-  let snapshot uu___ = FStar_Common.snapshot push record_cache () in
-  let rollback depth = FStar_Common.rollback pop record_cache depth in
-  let peek uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang record_cache in
-    FStar_Compiler_List.hd uu___1 in
-  let insert r =
-    let uu___ =
-      let uu___1 = let uu___2 = peek () in r :: uu___2 in
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Effect.op_Bang record_cache in
-        FStar_Compiler_List.tl uu___3 in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Effect.op_Colon_Equals record_cache uu___ in
-  let filter uu___ =
-    let rc = peek () in
-    let filtered =
-      FStar_Compiler_List.filter (fun r -> Prims.op_Negation r.is_private) rc in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Effect.op_Bang record_cache in
-        FStar_Compiler_List.tl uu___3 in
-      filtered :: uu___2 in
-    FStar_Compiler_Effect.op_Colon_Equals record_cache uu___1 in
-  let aux = ((push, pop), ((snapshot, rollback), (peek, insert))) in
-  (aux, filter)
-let (record_cache_aux :
-  (((unit -> unit) * (unit -> unit)) * (((unit -> (Prims.int * unit)) *
-    (Prims.int FStar_Pervasives_Native.option -> unit)) *
-    ((unit -> record_or_dc Prims.list) * (record_or_dc -> unit)))))
-  = FStar_Pervasives_Native.fst record_cache_aux_with_filter
-let (filter_record_cache : unit -> unit) =
-  FStar_Pervasives_Native.snd record_cache_aux_with_filter
-let (push_record_cache : unit -> unit) =
-  FStar_Pervasives_Native.fst (FStar_Pervasives_Native.fst record_cache_aux)
-let (pop_record_cache : unit -> unit) =
-  FStar_Pervasives_Native.snd (FStar_Pervasives_Native.fst record_cache_aux)
-let (snapshot_record_cache : unit -> (Prims.int * unit)) =
-  FStar_Pervasives_Native.fst
-    (FStar_Pervasives_Native.fst
-       (FStar_Pervasives_Native.snd record_cache_aux))
-let (rollback_record_cache :
-  Prims.int FStar_Pervasives_Native.option -> unit) =
-  FStar_Pervasives_Native.snd
-    (FStar_Pervasives_Native.fst
-       (FStar_Pervasives_Native.snd record_cache_aux))
-let (peek_record_cache : unit -> record_or_dc Prims.list) =
-  FStar_Pervasives_Native.fst
-    (FStar_Pervasives_Native.snd
-       (FStar_Pervasives_Native.snd record_cache_aux))
-let (insert_record_cache : record_or_dc -> unit) =
-  FStar_Pervasives_Native.snd
-    (FStar_Pervasives_Native.snd
-       (FStar_Pervasives_Native.snd record_cache_aux))
-let (extract_record :
-  env ->
-    scope_mod Prims.list FStar_Compiler_Effect.ref ->
-      FStar_Syntax_Syntax.sigelt -> unit)
-  =
-  fun e ->
-    fun new_globs ->
-      fun se ->
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_bundle (sigs, uu___) ->
-            let is_record =
-              FStar_Compiler_Util.for_some
-                (fun uu___1 ->
-                   match uu___1 with
-                   | FStar_Syntax_Syntax.RecordType uu___2 -> true
-                   | FStar_Syntax_Syntax.RecordConstructor uu___2 -> true
-                   | uu___2 -> false) in
-            let find_dc dc =
-              FStar_Compiler_Effect.op_Bar_Greater sigs
-                (FStar_Compiler_Util.find_opt
-                   (fun uu___1 ->
-                      match uu___1 with
-                      | {
-                          FStar_Syntax_Syntax.sigel =
-                            FStar_Syntax_Syntax.Sig_datacon
-                            (lid, uu___2, uu___3, uu___4, uu___5, uu___6);
-                          FStar_Syntax_Syntax.sigrng = uu___7;
-                          FStar_Syntax_Syntax.sigquals = uu___8;
-                          FStar_Syntax_Syntax.sigmeta = uu___9;
-                          FStar_Syntax_Syntax.sigattrs = uu___10;
-                          FStar_Syntax_Syntax.sigopts = uu___11;_} ->
-                          FStar_Ident.lid_equals dc lid
-                      | uu___2 -> false)) in
-            FStar_Compiler_Effect.op_Bar_Greater sigs
-              (FStar_Compiler_List.iter
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | {
-                        FStar_Syntax_Syntax.sigel =
-                          FStar_Syntax_Syntax.Sig_inductive_typ
-                          (typename, univs, parms, uu___2, uu___3, uu___4,
-                           dc::[]);
-                        FStar_Syntax_Syntax.sigrng = uu___5;
-                        FStar_Syntax_Syntax.sigquals = typename_quals;
-                        FStar_Syntax_Syntax.sigmeta = uu___6;
-                        FStar_Syntax_Syntax.sigattrs = uu___7;
-                        FStar_Syntax_Syntax.sigopts = uu___8;_} ->
-                        let uu___9 =
-                          let uu___10 = find_dc dc in
-                          FStar_Compiler_Effect.op_Less_Bar
-                            FStar_Compiler_Util.must uu___10 in
-                        (match uu___9 with
-                         | {
-                             FStar_Syntax_Syntax.sigel =
-                               FStar_Syntax_Syntax.Sig_datacon
-                               (constrname, uu___10, t, uu___11, n, uu___12);
-                             FStar_Syntax_Syntax.sigrng = uu___13;
-                             FStar_Syntax_Syntax.sigquals = uu___14;
-                             FStar_Syntax_Syntax.sigmeta = uu___15;
-                             FStar_Syntax_Syntax.sigattrs = uu___16;
-                             FStar_Syntax_Syntax.sigopts = uu___17;_} ->
-                             let uu___18 = FStar_Syntax_Util.arrow_formals t in
-                             (match uu___18 with
-                              | (all_formals, uu___19) ->
-                                  let uu___20 =
-                                    FStar_Compiler_Util.first_N n all_formals in
-                                  (match uu___20 with
-                                   | (_params, formals) ->
-                                       let is_rec = is_record typename_quals in
-                                       let formals' =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           formals
-                                           (FStar_Compiler_List.collect
-                                              (fun f ->
-                                                 let uu___21 =
-                                                   (FStar_Syntax_Syntax.is_null_bv
-                                                      f.FStar_Syntax_Syntax.binder_bv)
-                                                     ||
-                                                     (is_rec &&
-                                                        (FStar_Syntax_Syntax.is_bqual_implicit
-                                                           f.FStar_Syntax_Syntax.binder_qual)) in
-                                                 if uu___21 then [] else [f])) in
-                                       let fields' =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           formals'
-                                           (FStar_Compiler_List.map
-                                              (fun f ->
-                                                 (((f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.ppname),
-                                                   ((f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)))) in
-                                       let fields = fields' in
-                                       let record =
-                                         let uu___21 =
-                                           FStar_Ident.ident_of_lid
-                                             constrname in
-                                         {
-                                           typename;
-                                           constrname = uu___21;
-                                           parms;
-                                           fields;
-                                           is_private =
-                                             (FStar_Compiler_List.contains
-                                                FStar_Syntax_Syntax.Private
-                                                typename_quals);
-                                           is_record = is_rec
-                                         } in
-                                       ((let uu___22 =
-                                           let uu___23 =
-                                             FStar_Compiler_Effect.op_Bang
-                                               new_globs in
-                                           (Record_or_dc record) :: uu___23 in
-                                         FStar_Compiler_Effect.op_Colon_Equals
-                                           new_globs uu___22);
-                                        (match () with
-                                         | () ->
-                                             ((let add_field uu___23 =
-                                                 match uu___23 with
-                                                 | (id, uu___24) ->
-                                                     let modul =
-                                                       let uu___25 =
-                                                         let uu___26 =
-                                                           FStar_Ident.ns_of_lid
-                                                             constrname in
-                                                         FStar_Ident.lid_of_ids
-                                                           uu___26 in
-                                                       FStar_Ident.string_of_lid
-                                                         uu___25 in
-                                                     let uu___25 =
-                                                       get_exported_id_set e
-                                                         modul in
-                                                     (match uu___25 with
-                                                      | FStar_Pervasives_Native.Some
-                                                          my_ex ->
-                                                          let my_exported_ids
-                                                            =
-                                                            my_ex
-                                                              Exported_id_field in
-                                                          ((let uu___27 =
-                                                              let uu___28 =
-                                                                FStar_Ident.string_of_id
-                                                                  id in
-                                                              let uu___29 =
-                                                                FStar_Compiler_Effect.op_Bang
-                                                                  my_exported_ids in
-                                                              FStar_Compiler_Util.set_add
-                                                                uu___28
-                                                                uu___29 in
-                                                            FStar_Compiler_Effect.op_Colon_Equals
-                                                              my_exported_ids
-                                                              uu___27);
-                                                           (match () with
-                                                            | () ->
-                                                                let projname
-                                                                  =
-                                                                  let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Util.mk_field_projector_name_from_ident
-                                                                    constrname
-                                                                    id in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___28
-                                                                    FStar_Ident.ident_of_lid in
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___27
-                                                                    FStar_Ident.string_of_id in
-                                                                let uu___28 =
-                                                                  let uu___29
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bang
-                                                                    my_exported_ids in
-                                                                  FStar_Compiler_Util.set_add
-                                                                    projname
-                                                                    uu___29 in
-                                                                FStar_Compiler_Effect.op_Colon_Equals
-                                                                  my_exported_ids
-                                                                  uu___28))
-                                                      | FStar_Pervasives_Native.None
-                                                          -> ()) in
-                                               FStar_Compiler_List.iter
-                                                 add_field fields');
-                                              (match () with
-                                               | () ->
-                                                   insert_record_cache record))))))
-                         | uu___10 -> ())
-                    | uu___2 -> ()))
-        | uu___ -> ()
-let (try_lookup_record_or_dc_by_field_name :
-  env -> FStar_Ident.lident -> record_or_dc FStar_Pervasives_Native.option) =
-  fun env1 ->
-    fun fieldname ->
-      let find_in_cache fieldname1 =
-        let uu___ =
-          let uu___1 = FStar_Ident.ns_of_lid fieldname1 in
-          let uu___2 = FStar_Ident.ident_of_lid fieldname1 in
-          (uu___1, uu___2) in
-        match uu___ with
-        | (ns, id) ->
-            let uu___1 = peek_record_cache () in
-            FStar_Compiler_Util.find_map uu___1
-              (fun record ->
-                 let uu___2 =
-                   find_in_record ns id record (fun r -> Cont_ok r) in
-                 option_of_cont (fun uu___3 -> FStar_Pervasives_Native.None)
-                   uu___2) in
-      resolve_in_open_namespaces'' env1 fieldname Exported_id_field
-        (fun uu___ -> Cont_ignore) (fun uu___ -> Cont_ignore)
-        (fun r -> Cont_ok r)
-        (fun fn ->
-           let uu___ = find_in_cache fn in cont_of_option Cont_ignore uu___)
-        (fun k -> fun uu___ -> k)
-let (try_lookup_record_by_field_name :
-  env -> FStar_Ident.lident -> record_or_dc FStar_Pervasives_Native.option) =
-  fun env1 ->
-    fun fieldname ->
-      let uu___ = try_lookup_record_or_dc_by_field_name env1 fieldname in
-      match uu___ with
-      | FStar_Pervasives_Native.Some r when r.is_record ->
-          FStar_Pervasives_Native.Some r
-      | uu___1 -> FStar_Pervasives_Native.None
-let (try_lookup_record_type :
-  env -> FStar_Ident.lident -> record_or_dc FStar_Pervasives_Native.option) =
-  fun env1 ->
-    fun typename ->
-      let find_in_cache name =
-        let uu___ =
-          let uu___1 = FStar_Ident.ns_of_lid name in
-          let uu___2 = FStar_Ident.ident_of_lid name in (uu___1, uu___2) in
-        match uu___ with
-        | (ns, id) ->
-            let uu___1 = peek_record_cache () in
-            FStar_Compiler_Util.find_map uu___1
-              (fun record ->
-                 let uu___2 =
-                   let uu___3 = FStar_Ident.ident_of_lid record.typename in
-                   FStar_Ident.ident_equals uu___3 id in
-                 if uu___2
-                 then FStar_Pervasives_Native.Some record
-                 else FStar_Pervasives_Native.None) in
-      resolve_in_open_namespaces'' env1 typename Exported_id_term_type
-        (fun uu___ -> Cont_ignore) (fun uu___ -> Cont_ignore)
-        (fun r -> Cont_ok r)
-        (fun l ->
-           let uu___ = find_in_cache l in cont_of_option Cont_ignore uu___)
-        (fun k -> fun uu___ -> k)
-let (belongs_to_record :
-  env -> FStar_Ident.lident -> record_or_dc -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      fun record ->
-        let uu___ = try_lookup_record_by_field_name env1 lid in
-        match uu___ with
-        | FStar_Pervasives_Native.Some record' when
-            let uu___1 = FStar_Ident.nsstr record.typename in
-            let uu___2 = FStar_Ident.nsstr record'.typename in
-            uu___1 = uu___2 ->
-            let uu___1 =
-              let uu___2 = FStar_Ident.ns_of_lid record.typename in
-              let uu___3 = FStar_Ident.ident_of_lid lid in
-              find_in_record uu___2 uu___3 record (fun uu___4 -> Cont_ok ()) in
-            (match uu___1 with | Cont_ok uu___2 -> true | uu___2 -> false)
-        | uu___1 -> false
-let (try_lookup_dc_by_field_name :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Ident.lident * Prims.bool) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fieldname ->
-      let uu___ = try_lookup_record_or_dc_by_field_name env1 fieldname in
-      match uu___ with
-      | FStar_Pervasives_Native.Some r ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Ident.ns_of_lid r.typename in
-                  FStar_Compiler_List.op_At uu___5 [r.constrname] in
-                FStar_Ident.lid_of_ids uu___4 in
-              let uu___4 = FStar_Ident.range_of_lid fieldname in
-              FStar_Ident.set_lid_range uu___3 uu___4 in
-            (uu___2, (r.is_record)) in
-          FStar_Pervasives_Native.Some uu___1
-      | uu___1 -> FStar_Pervasives_Native.None
-let (string_set_ref_new :
-  unit -> Prims.string FStar_Compiler_Util.set FStar_Compiler_Effect.ref) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Util.new_set FStar_Compiler_Util.compare in
-    FStar_Compiler_Util.mk_ref uu___1
-let (exported_id_set_new :
-  unit ->
-    exported_id_kind ->
-      Prims.string FStar_Compiler_Util.set FStar_Compiler_Effect.ref)
-  =
-  fun uu___ ->
-    let term_type_set = string_set_ref_new () in
-    let field_set = string_set_ref_new () in
-    fun uu___1 ->
-      match uu___1 with
-      | Exported_id_term_type -> term_type_set
-      | Exported_id_field -> field_set
-let (unique :
-  Prims.bool -> Prims.bool -> env -> FStar_Ident.lident -> Prims.bool) =
-  fun any_val ->
-    fun exclude_interface ->
-      fun env1 ->
-        fun lid ->
-          let filter_scope_mods uu___ =
-            match uu___ with | Rec_binding uu___1 -> true | uu___1 -> false in
-          let this_env =
-            let uu___ =
-              FStar_Compiler_List.filter filter_scope_mods env1.scope_mods in
-            {
-              curmodule = (env1.curmodule);
-              curmonad = (env1.curmonad);
-              modules = (env1.modules);
-              scope_mods = uu___;
-              exported_ids = empty_exported_id_smap;
-              trans_exported_ids = (env1.trans_exported_ids);
-              includes = empty_include_smap;
-              sigaccum = (env1.sigaccum);
-              sigmap = (env1.sigmap);
-              iface = (env1.iface);
-              admitted_iface = (env1.admitted_iface);
-              expect_typ = (env1.expect_typ);
-              remaining_iface_decls = (env1.remaining_iface_decls);
-              syntax_only = (env1.syntax_only);
-              ds_hooks = (env1.ds_hooks);
-              dep_graph = (env1.dep_graph)
-            } in
-          let uu___ = try_lookup_lid' any_val exclude_interface this_env lid in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> true
-          | FStar_Pervasives_Native.Some uu___1 -> false
-let (push_scope_mod : env -> scope_mod -> env) =
-  fun env1 ->
-    fun scope_mod1 ->
-      {
-        curmodule = (env1.curmodule);
-        curmonad = (env1.curmonad);
-        modules = (env1.modules);
-        scope_mods = (scope_mod1 :: (env1.scope_mods));
-        exported_ids = (env1.exported_ids);
-        trans_exported_ids = (env1.trans_exported_ids);
-        includes = (env1.includes);
-        sigaccum = (env1.sigaccum);
-        sigmap = (env1.sigmap);
-        iface = (env1.iface);
-        admitted_iface = (env1.admitted_iface);
-        expect_typ = (env1.expect_typ);
-        remaining_iface_decls = (env1.remaining_iface_decls);
-        syntax_only = (env1.syntax_only);
-        ds_hooks = (env1.ds_hooks);
-        dep_graph = (env1.dep_graph)
-      }
-let (push_bv' :
-  env -> FStar_Ident.ident -> (env * FStar_Syntax_Syntax.bv * used_marker)) =
-  fun env1 ->
-    fun x ->
-      let r = FStar_Ident.range_of_id x in
-      let bv =
-        let uu___ = FStar_Ident.string_of_id x in
-        FStar_Syntax_Syntax.gen_bv uu___ (FStar_Pervasives_Native.Some r)
-          {
-            FStar_Syntax_Syntax.n =
-              (FStar_Syntax_Syntax.tun.FStar_Syntax_Syntax.n);
-            FStar_Syntax_Syntax.pos = r;
-            FStar_Syntax_Syntax.vars =
-              (FStar_Syntax_Syntax.tun.FStar_Syntax_Syntax.vars);
-            FStar_Syntax_Syntax.hash_code =
-              (FStar_Syntax_Syntax.tun.FStar_Syntax_Syntax.hash_code)
-          } in
-      let used_marker1 = FStar_Compiler_Util.mk_ref false in
-      ((push_scope_mod env1 (Local_binding (x, bv, used_marker1))), bv,
-        used_marker1)
-let (push_bv : env -> FStar_Ident.ident -> (env * FStar_Syntax_Syntax.bv)) =
-  fun env1 ->
-    fun x ->
-      let uu___ = push_bv' env1 x in
-      match uu___ with | (env2, bv, uu___1) -> (env2, bv)
-let (push_top_level_rec_binding :
-  env ->
-    FStar_Ident.ident ->
-      FStar_Syntax_Syntax.delta_depth ->
-        (env * Prims.bool FStar_Compiler_Effect.ref))
-  =
-  fun env0 ->
-    fun x ->
-      fun dd ->
-        let l = qualify env0 x in
-        let uu___ =
-          (unique false true env0 l) || (FStar_Options.interactive ()) in
-        if uu___
-        then
-          let used_marker1 = FStar_Compiler_Util.mk_ref false in
-          ((push_scope_mod env0 (Rec_binding (x, l, dd, used_marker1))),
-            used_marker1)
-        else
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Ident.string_of_lid l in
-               Prims.op_Hat "Duplicate top-level names " uu___4 in
-             (FStar_Errors.Fatal_DuplicateTopLevelNames, uu___3) in
-           let uu___3 = FStar_Ident.range_of_lid l in
-           FStar_Errors.raise_error uu___2 uu___3)
-let (push_sigelt' : Prims.bool -> env -> FStar_Syntax_Syntax.sigelt -> env) =
-  fun fail_on_dup ->
-    fun env1 ->
-      fun s ->
-        let err l =
-          let sopt =
-            let uu___ = FStar_Ident.string_of_lid l in
-            FStar_Compiler_Util.smap_try_find (sigmap env1) uu___ in
-          let r =
-            match sopt with
-            | FStar_Pervasives_Native.Some (se, uu___) ->
-                let uu___1 =
-                  FStar_Compiler_Util.find_opt (FStar_Ident.lid_equals l)
-                    (FStar_Syntax_Util.lids_of_sigelt se) in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.Some l1 ->
-                     let uu___2 = FStar_Ident.range_of_lid l1 in
-                     FStar_Compiler_Effect.op_Less_Bar
-                       FStar_Compiler_Range.string_of_range uu___2
-                 | FStar_Pervasives_Native.None -> "<unknown>")
-            | FStar_Pervasives_Native.None -> "<unknown>" in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Ident.string_of_lid l in
-              FStar_Compiler_Util.format2
-                "Duplicate top-level names [%s]; previously declared at %s"
-                uu___2 r in
-            (FStar_Errors.Fatal_DuplicateTopLevelNames, uu___1) in
-          let uu___1 = FStar_Ident.range_of_lid l in
-          FStar_Errors.raise_error uu___ uu___1 in
-        let globals = FStar_Compiler_Util.mk_ref env1.scope_mods in
-        let env2 =
-          let uu___ =
-            match s.FStar_Syntax_Syntax.sigel with
-            | FStar_Syntax_Syntax.Sig_let uu___1 -> (false, true)
-            | FStar_Syntax_Syntax.Sig_bundle uu___1 -> (false, true)
-            | uu___1 -> (false, false) in
-          match uu___ with
-          | (any_val, exclude_interface) ->
-              let lids = FStar_Syntax_Util.lids_of_sigelt s in
-              let uu___1 =
-                FStar_Compiler_Util.find_map lids
-                  (fun l ->
-                     let uu___2 =
-                       let uu___3 = unique any_val exclude_interface env1 l in
-                       Prims.op_Negation uu___3 in
-                     if uu___2
-                     then FStar_Pervasives_Native.Some l
-                     else FStar_Pervasives_Native.None) in
-              (match uu___1 with
-               | FStar_Pervasives_Native.Some l when fail_on_dup -> err l
-               | uu___2 ->
-                   (extract_record env1 globals s;
-                    {
-                      curmodule = (env1.curmodule);
-                      curmonad = (env1.curmonad);
-                      modules = (env1.modules);
-                      scope_mods = (env1.scope_mods);
-                      exported_ids = (env1.exported_ids);
-                      trans_exported_ids = (env1.trans_exported_ids);
-                      includes = (env1.includes);
-                      sigaccum = (s :: (env1.sigaccum));
-                      sigmap = (env1.sigmap);
-                      iface = (env1.iface);
-                      admitted_iface = (env1.admitted_iface);
-                      expect_typ = (env1.expect_typ);
-                      remaining_iface_decls = (env1.remaining_iface_decls);
-                      syntax_only = (env1.syntax_only);
-                      ds_hooks = (env1.ds_hooks);
-                      dep_graph = (env1.dep_graph)
-                    })) in
-        let env3 =
-          let uu___ = FStar_Compiler_Effect.op_Bang globals in
-          {
-            curmodule = (env2.curmodule);
-            curmonad = (env2.curmonad);
-            modules = (env2.modules);
-            scope_mods = uu___;
-            exported_ids = (env2.exported_ids);
-            trans_exported_ids = (env2.trans_exported_ids);
-            includes = (env2.includes);
-            sigaccum = (env2.sigaccum);
-            sigmap = (env2.sigmap);
-            iface = (env2.iface);
-            admitted_iface = (env2.admitted_iface);
-            expect_typ = (env2.expect_typ);
-            remaining_iface_decls = (env2.remaining_iface_decls);
-            syntax_only = (env2.syntax_only);
-            ds_hooks = (env2.ds_hooks);
-            dep_graph = (env2.dep_graph)
-          } in
-        let uu___ =
-          match s.FStar_Syntax_Syntax.sigel with
-          | FStar_Syntax_Syntax.Sig_bundle (ses, uu___1) ->
-              let uu___2 =
-                FStar_Compiler_List.map
-                  (fun se -> ((FStar_Syntax_Util.lids_of_sigelt se), se)) ses in
-              (env3, uu___2)
-          | uu___1 -> (env3, [((FStar_Syntax_Util.lids_of_sigelt s), s)]) in
-        match uu___ with
-        | (env4, lss) ->
-            (FStar_Compiler_Effect.op_Bar_Greater lss
-               (FStar_Compiler_List.iter
-                  (fun uu___2 ->
-                     match uu___2 with
-                     | (lids, se) ->
-                         FStar_Compiler_Effect.op_Bar_Greater lids
-                           (FStar_Compiler_List.iter
-                              (fun lid ->
-                                 (let uu___4 =
-                                    let uu___5 =
-                                      let uu___6 =
-                                        FStar_Ident.ident_of_lid lid in
-                                      Top_level_def uu___6 in
-                                    let uu___6 =
-                                      FStar_Compiler_Effect.op_Bang globals in
-                                    uu___5 :: uu___6 in
-                                  FStar_Compiler_Effect.op_Colon_Equals
-                                    globals uu___4);
-                                 (match () with
-                                  | () ->
-                                      let modul =
-                                        let uu___4 =
-                                          let uu___5 =
-                                            FStar_Ident.ns_of_lid lid in
-                                          FStar_Ident.lid_of_ids uu___5 in
-                                        FStar_Ident.string_of_lid uu___4 in
-                                      ((let uu___5 =
-                                          get_exported_id_set env4 modul in
-                                        match uu___5 with
-                                        | FStar_Pervasives_Native.Some f ->
-                                            let my_exported_ids =
-                                              f Exported_id_term_type in
-                                            let uu___6 =
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  FStar_Ident.ident_of_lid
-                                                    lid in
-                                                FStar_Ident.string_of_id
-                                                  uu___8 in
-                                              let uu___8 =
-                                                FStar_Compiler_Effect.op_Bang
-                                                  my_exported_ids in
-                                              FStar_Compiler_Util.set_add
-                                                uu___7 uu___8 in
-                                            FStar_Compiler_Effect.op_Colon_Equals
-                                              my_exported_ids uu___6
-                                        | FStar_Pervasives_Native.None -> ());
-                                       (match () with
-                                        | () ->
-                                            let is_iface =
-                                              env4.iface &&
-                                                (Prims.op_Negation
-                                                   env4.admitted_iface) in
-                                            let uu___5 =
-                                              FStar_Ident.string_of_lid lid in
-                                            FStar_Compiler_Util.smap_add
-                                              (sigmap env4) uu___5
-                                              (se,
-                                                (env4.iface &&
-                                                   (Prims.op_Negation
-                                                      env4.admitted_iface))))))))));
-             (let env5 =
-                let uu___2 = FStar_Compiler_Effect.op_Bang globals in
-                {
-                  curmodule = (env4.curmodule);
-                  curmonad = (env4.curmonad);
-                  modules = (env4.modules);
-                  scope_mods = uu___2;
-                  exported_ids = (env4.exported_ids);
-                  trans_exported_ids = (env4.trans_exported_ids);
-                  includes = (env4.includes);
-                  sigaccum = (env4.sigaccum);
-                  sigmap = (env4.sigmap);
-                  iface = (env4.iface);
-                  admitted_iface = (env4.admitted_iface);
-                  expect_typ = (env4.expect_typ);
-                  remaining_iface_decls = (env4.remaining_iface_decls);
-                  syntax_only = (env4.syntax_only);
-                  ds_hooks = (env4.ds_hooks);
-                  dep_graph = (env4.dep_graph)
-                } in
-              env5))
-let (push_sigelt : env -> FStar_Syntax_Syntax.sigelt -> env) =
-  fun env1 -> fun se -> push_sigelt' true env1 se
-let (push_sigelt_force : env -> FStar_Syntax_Syntax.sigelt -> env) =
-  fun env1 -> fun se -> push_sigelt' false env1 se
-let (push_namespace : env -> FStar_Ident.lident -> env) =
-  fun env1 ->
-    fun ns ->
-      let uu___ =
-        let uu___1 = resolve_module_name env1 ns false in
-        match uu___1 with
-        | FStar_Pervasives_Native.None ->
-            let modules = env1.modules in
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater modules
-                (FStar_Compiler_Util.for_some
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (m, uu___4) ->
-                          let uu___5 =
-                            let uu___6 = FStar_Ident.string_of_lid m in
-                            Prims.op_Hat uu___6 "." in
-                          let uu___6 =
-                            let uu___7 = FStar_Ident.string_of_lid ns in
-                            Prims.op_Hat uu___7 "." in
-                          FStar_Compiler_Util.starts_with uu___5 uu___6)) in
-            if uu___2
-            then (ns, Open_namespace)
-            else
-              (let uu___4 =
-                 let uu___5 =
-                   let uu___6 = FStar_Ident.string_of_lid ns in
-                   FStar_Compiler_Util.format1 "Namespace %s cannot be found"
-                     uu___6 in
-                 (FStar_Errors.Fatal_NameSpaceNotFound, uu___5) in
-               let uu___5 = FStar_Ident.range_of_lid ns in
-               FStar_Errors.raise_error uu___4 uu___5)
-        | FStar_Pervasives_Native.Some ns' -> (ns', Open_module) in
-      match uu___ with
-      | (ns', kd) ->
-          ((env1.ds_hooks).ds_push_open_hook env1 (ns', kd);
-           push_scope_mod env1 (Open_module_or_namespace (ns', kd)))
-let (push_include : env -> FStar_Ident.lident -> env) =
-  fun env1 ->
-    fun ns ->
-      let ns0 = ns in
-      let uu___ = resolve_module_name env1 ns false in
-      match uu___ with
-      | FStar_Pervasives_Native.Some ns1 ->
-          ((env1.ds_hooks).ds_push_include_hook env1 ns1;
-           (let env2 =
-              push_scope_mod env1
-                (Open_module_or_namespace (ns1, Open_module)) in
-            let curmod =
-              let uu___2 = current_module env2 in
-              FStar_Ident.string_of_lid uu___2 in
-            (let uu___3 =
-               FStar_Compiler_Util.smap_try_find env2.includes curmod in
-             match uu___3 with
-             | FStar_Pervasives_Native.None -> ()
-             | FStar_Pervasives_Native.Some incl ->
-                 let uu___4 =
-                   let uu___5 = FStar_Compiler_Effect.op_Bang incl in ns1 ::
-                     uu___5 in
-                 FStar_Compiler_Effect.op_Colon_Equals incl uu___4);
-            (match () with
-             | () ->
-                 let uu___3 =
-                   let uu___4 = FStar_Ident.string_of_lid ns1 in
-                   get_trans_exported_id_set env2 uu___4 in
-                 (match uu___3 with
-                  | FStar_Pervasives_Native.Some ns_trans_exports ->
-                      ((let uu___5 =
-                          let uu___6 = get_exported_id_set env2 curmod in
-                          let uu___7 = get_trans_exported_id_set env2 curmod in
-                          (uu___6, uu___7) in
-                        match uu___5 with
-                        | (FStar_Pervasives_Native.Some cur_exports,
-                           FStar_Pervasives_Native.Some cur_trans_exports) ->
-                            let update_exports k =
-                              let ns_ex =
-                                let uu___6 = ns_trans_exports k in
-                                FStar_Compiler_Effect.op_Bang uu___6 in
-                              let ex = cur_exports k in
-                              (let uu___7 =
-                                 let uu___8 =
-                                   FStar_Compiler_Effect.op_Bang ex in
-                                 FStar_Compiler_Util.set_difference uu___8
-                                   ns_ex in
-                               FStar_Compiler_Effect.op_Colon_Equals ex
-                                 uu___7);
-                              (match () with
-                               | () ->
-                                   let trans_ex = cur_trans_exports k in
-                                   let uu___8 =
-                                     let uu___9 =
-                                       FStar_Compiler_Effect.op_Bang trans_ex in
-                                     FStar_Compiler_Util.set_union uu___9
-                                       ns_ex in
-                                   FStar_Compiler_Effect.op_Colon_Equals
-                                     trans_ex uu___8) in
-                            FStar_Compiler_List.iter update_exports
-                              all_exported_id_kinds
-                        | uu___6 -> ());
-                       (match () with | () -> env2))
-                  | FStar_Pervasives_Native.None ->
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 = FStar_Ident.string_of_lid ns1 in
-                          FStar_Compiler_Util.format1
-                            "include: Module %s was not prepared" uu___6 in
-                        (FStar_Errors.Fatal_IncludeModuleNotPrepared, uu___5) in
-                      let uu___5 = FStar_Ident.range_of_lid ns1 in
-                      FStar_Errors.raise_error uu___4 uu___5))))
-      | uu___1 ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Ident.string_of_lid ns in
-              FStar_Compiler_Util.format1
-                "include: Module %s cannot be found" uu___4 in
-            (FStar_Errors.Fatal_ModuleNotFound, uu___3) in
-          let uu___3 = FStar_Ident.range_of_lid ns in
-          FStar_Errors.raise_error uu___2 uu___3
-let (push_module_abbrev :
-  env -> FStar_Ident.ident -> FStar_Ident.lident -> env) =
-  fun env1 ->
-    fun x ->
-      fun l ->
-        let uu___ = module_is_defined env1 l in
-        if uu___
-        then
-          ((env1.ds_hooks).ds_push_module_abbrev_hook env1 x l;
-           push_scope_mod env1 (Module_abbrev (x, l)))
-        else
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Ident.string_of_lid l in
-               FStar_Compiler_Util.format1 "Module %s cannot be found" uu___4 in
-             (FStar_Errors.Fatal_ModuleNotFound, uu___3) in
-           let uu___3 = FStar_Ident.range_of_lid l in
-           FStar_Errors.raise_error uu___2 uu___3)
-let (check_admits :
-  env -> FStar_Syntax_Syntax.modul -> FStar_Syntax_Syntax.modul) =
-  fun env1 ->
-    fun m ->
-      let admitted_sig_lids =
-        FStar_Compiler_Effect.op_Bar_Greater env1.sigaccum
-          (FStar_Compiler_List.fold_left
-             (fun lids ->
-                fun se ->
-                  match se.FStar_Syntax_Syntax.sigel with
-                  | FStar_Syntax_Syntax.Sig_declare_typ (l, u, t) when
-                      let uu___ =
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          se.FStar_Syntax_Syntax.sigquals
-                          (FStar_Compiler_List.contains
-                             FStar_Syntax_Syntax.Assumption) in
-                      Prims.op_Negation uu___ ->
-                      let uu___ =
-                        let uu___1 = FStar_Ident.string_of_lid l in
-                        FStar_Compiler_Util.smap_try_find (sigmap env1)
-                          uu___1 in
-                      (match uu___ with
-                       | FStar_Pervasives_Native.Some
-                           ({
-                              FStar_Syntax_Syntax.sigel =
-                                FStar_Syntax_Syntax.Sig_let uu___1;
-                              FStar_Syntax_Syntax.sigrng = uu___2;
-                              FStar_Syntax_Syntax.sigquals = uu___3;
-                              FStar_Syntax_Syntax.sigmeta = uu___4;
-                              FStar_Syntax_Syntax.sigattrs = uu___5;
-                              FStar_Syntax_Syntax.sigopts = uu___6;_},
-                            uu___7)
-                           -> lids
-                       | FStar_Pervasives_Native.Some
-                           ({
-                              FStar_Syntax_Syntax.sigel =
-                                FStar_Syntax_Syntax.Sig_inductive_typ uu___1;
-                              FStar_Syntax_Syntax.sigrng = uu___2;
-                              FStar_Syntax_Syntax.sigquals = uu___3;
-                              FStar_Syntax_Syntax.sigmeta = uu___4;
-                              FStar_Syntax_Syntax.sigattrs = uu___5;
-                              FStar_Syntax_Syntax.sigopts = uu___6;_},
-                            uu___7)
-                           -> lids
-                       | uu___1 ->
-                           ((let uu___3 =
-                               let uu___4 = FStar_Options.interactive () in
-                               Prims.op_Negation uu___4 in
-                             if uu___3
-                             then
-                               let uu___4 = FStar_Ident.range_of_lid l in
-                               let uu___5 =
-                                 let uu___6 =
-                                   let uu___7 = FStar_Ident.string_of_lid l in
-                                   FStar_Compiler_Util.format1
-                                     "Admitting %s without a definition"
-                                     uu___7 in
-                                 (FStar_Errors.Warning_AdmitWithoutDefinition,
-                                   uu___6) in
-                               FStar_Errors.log_issue uu___4 uu___5
-                             else ());
-                            (let quals = FStar_Syntax_Syntax.Assumption ::
-                               (se.FStar_Syntax_Syntax.sigquals) in
-                             (let uu___4 = FStar_Ident.string_of_lid l in
-                              FStar_Compiler_Util.smap_add (sigmap env1)
-                                uu___4
-                                ({
-                                   FStar_Syntax_Syntax.sigel =
-                                     (se.FStar_Syntax_Syntax.sigel);
-                                   FStar_Syntax_Syntax.sigrng =
-                                     (se.FStar_Syntax_Syntax.sigrng);
-                                   FStar_Syntax_Syntax.sigquals = quals;
-                                   FStar_Syntax_Syntax.sigmeta =
-                                     (se.FStar_Syntax_Syntax.sigmeta);
-                                   FStar_Syntax_Syntax.sigattrs =
-                                     (se.FStar_Syntax_Syntax.sigattrs);
-                                   FStar_Syntax_Syntax.sigopts =
-                                     (se.FStar_Syntax_Syntax.sigopts)
-                                 }, false));
-                             l
-                             ::
-                             lids)))
-                  | uu___ -> lids) []) in
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater
-          m.FStar_Syntax_Syntax.declarations
-          (FStar_Compiler_List.map
-             (fun s ->
-                match s.FStar_Syntax_Syntax.sigel with
-                | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___1, uu___2)
-                    when
-                    FStar_Compiler_List.existsb
-                      (fun l -> FStar_Ident.lid_equals l lid)
-                      admitted_sig_lids
-                    ->
-                    {
-                      FStar_Syntax_Syntax.sigel =
-                        (s.FStar_Syntax_Syntax.sigel);
-                      FStar_Syntax_Syntax.sigrng =
-                        (s.FStar_Syntax_Syntax.sigrng);
-                      FStar_Syntax_Syntax.sigquals =
-                        (FStar_Syntax_Syntax.Assumption ::
-                        (s.FStar_Syntax_Syntax.sigquals));
-                      FStar_Syntax_Syntax.sigmeta =
-                        (s.FStar_Syntax_Syntax.sigmeta);
-                      FStar_Syntax_Syntax.sigattrs =
-                        (s.FStar_Syntax_Syntax.sigattrs);
-                      FStar_Syntax_Syntax.sigopts =
-                        (s.FStar_Syntax_Syntax.sigopts)
-                    }
-                | uu___1 -> s)) in
-      {
-        FStar_Syntax_Syntax.name = (m.FStar_Syntax_Syntax.name);
-        FStar_Syntax_Syntax.declarations = uu___;
-        FStar_Syntax_Syntax.is_interface =
-          (m.FStar_Syntax_Syntax.is_interface)
-      }
-let (finish : env -> FStar_Syntax_Syntax.modul -> env) =
-  fun env1 ->
-    fun modul ->
-      FStar_Compiler_Effect.op_Bar_Greater
-        modul.FStar_Syntax_Syntax.declarations
-        (FStar_Compiler_List.iter
-           (fun se ->
-              let quals = se.FStar_Syntax_Syntax.sigquals in
-              match se.FStar_Syntax_Syntax.sigel with
-              | FStar_Syntax_Syntax.Sig_bundle (ses, uu___1) ->
-                  if
-                    FStar_Compiler_List.contains FStar_Syntax_Syntax.Private
-                      quals
-                  then
-                    FStar_Compiler_Effect.op_Bar_Greater ses
-                      (FStar_Compiler_List.iter
-                         (fun se1 ->
-                            match se1.FStar_Syntax_Syntax.sigel with
-                            | FStar_Syntax_Syntax.Sig_datacon
-                                (lid, uu___2, uu___3, uu___4, uu___5, uu___6)
-                                ->
-                                let uu___7 = FStar_Ident.string_of_lid lid in
-                                FStar_Compiler_Util.smap_remove (sigmap env1)
-                                  uu___7
-                            | FStar_Syntax_Syntax.Sig_inductive_typ
-                                (lid, univ_names, binders, uu___2, typ,
-                                 uu___3, uu___4)
-                                ->
-                                ((let uu___6 = FStar_Ident.string_of_lid lid in
-                                  FStar_Compiler_Util.smap_remove
-                                    (sigmap env1) uu___6);
-                                 if
-                                   Prims.op_Negation
-                                     (FStar_Compiler_List.contains
-                                        FStar_Syntax_Syntax.Private quals)
-                                 then
-                                   (let sigel =
-                                      let uu___6 =
-                                        let uu___7 =
-                                          let uu___8 =
-                                            let uu___9 =
-                                              let uu___10 =
-                                                FStar_Syntax_Syntax.mk_Total
-                                                  typ in
-                                              (binders, uu___10) in
-                                            FStar_Syntax_Syntax.Tm_arrow
-                                              uu___9 in
-                                          let uu___9 =
-                                            FStar_Ident.range_of_lid lid in
-                                          FStar_Syntax_Syntax.mk uu___8
-                                            uu___9 in
-                                        (lid, univ_names, uu___7) in
-                                      FStar_Syntax_Syntax.Sig_declare_typ
-                                        uu___6 in
-                                    let se2 =
-                                      {
-                                        FStar_Syntax_Syntax.sigel = sigel;
-                                        FStar_Syntax_Syntax.sigrng =
-                                          (se1.FStar_Syntax_Syntax.sigrng);
-                                        FStar_Syntax_Syntax.sigquals =
-                                          (FStar_Syntax_Syntax.Assumption ::
-                                          quals);
-                                        FStar_Syntax_Syntax.sigmeta =
-                                          (se1.FStar_Syntax_Syntax.sigmeta);
-                                        FStar_Syntax_Syntax.sigattrs =
-                                          (se1.FStar_Syntax_Syntax.sigattrs);
-                                        FStar_Syntax_Syntax.sigopts =
-                                          (se1.FStar_Syntax_Syntax.sigopts)
-                                      } in
-                                    let uu___6 =
-                                      FStar_Ident.string_of_lid lid in
-                                    FStar_Compiler_Util.smap_add
-                                      (sigmap env1) uu___6 (se2, false))
-                                 else ())
-                            | uu___2 -> ()))
-                  else ()
-              | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___1, uu___2) ->
-                  if
-                    FStar_Compiler_List.contains FStar_Syntax_Syntax.Private
-                      quals
-                  then
-                    let uu___3 = FStar_Ident.string_of_lid lid in
-                    FStar_Compiler_Util.smap_remove (sigmap env1) uu___3
-                  else ()
-              | FStar_Syntax_Syntax.Sig_let ((uu___1, lbs), uu___2) ->
-                  if
-                    FStar_Compiler_List.contains FStar_Syntax_Syntax.Private
-                      quals
-                  then
-                    FStar_Compiler_Effect.op_Bar_Greater lbs
-                      (FStar_Compiler_List.iter
-                         (fun lb ->
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Compiler_Util.right
-                                      lb.FStar_Syntax_Syntax.lbname in
-                                  uu___6.FStar_Syntax_Syntax.fv_name in
-                                uu___5.FStar_Syntax_Syntax.v in
-                              FStar_Ident.string_of_lid uu___4 in
-                            FStar_Compiler_Util.smap_remove (sigmap env1)
-                              uu___3))
-                  else ()
-              | uu___1 -> ()));
-      (let curmod =
-         let uu___1 = current_module env1 in FStar_Ident.string_of_lid uu___1 in
-       (let uu___2 =
-          let uu___3 = get_exported_id_set env1 curmod in
-          let uu___4 = get_trans_exported_id_set env1 curmod in
-          (uu___3, uu___4) in
-        match uu___2 with
-        | (FStar_Pervasives_Native.Some cur_ex, FStar_Pervasives_Native.Some
-           cur_trans_ex) ->
-            let update_exports eikind =
-              let cur_ex_set =
-                let uu___3 = cur_ex eikind in
-                FStar_Compiler_Effect.op_Bang uu___3 in
-              let cur_trans_ex_set_ref = cur_trans_ex eikind in
-              let uu___3 =
-                let uu___4 =
-                  FStar_Compiler_Effect.op_Bang cur_trans_ex_set_ref in
-                FStar_Compiler_Util.set_union cur_ex_set uu___4 in
-              FStar_Compiler_Effect.op_Colon_Equals cur_trans_ex_set_ref
-                uu___3 in
-            FStar_Compiler_List.iter update_exports all_exported_id_kinds
-        | uu___3 -> ());
-       (match () with
-        | () ->
-            (filter_record_cache ();
-             (match () with
-              | () ->
-                  {
-                    curmodule = FStar_Pervasives_Native.None;
-                    curmonad = (env1.curmonad);
-                    modules = (((modul.FStar_Syntax_Syntax.name), modul) ::
-                      (env1.modules));
-                    scope_mods = [];
-                    exported_ids = (env1.exported_ids);
-                    trans_exported_ids = (env1.trans_exported_ids);
-                    includes = (env1.includes);
-                    sigaccum = [];
-                    sigmap = (env1.sigmap);
-                    iface = (env1.iface);
-                    admitted_iface = (env1.admitted_iface);
-                    expect_typ = (env1.expect_typ);
-                    remaining_iface_decls = (env1.remaining_iface_decls);
-                    syntax_only = (env1.syntax_only);
-                    ds_hooks = (env1.ds_hooks);
-                    dep_graph = (env1.dep_graph)
-                  }))))
-let (stack : env Prims.list FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let (push : env -> env) =
-  fun env1 ->
-    FStar_Compiler_Util.atomically
-      (fun uu___ ->
-         push_record_cache ();
-         (let uu___3 =
-            let uu___4 = FStar_Compiler_Effect.op_Bang stack in env1 ::
-              uu___4 in
-          FStar_Compiler_Effect.op_Colon_Equals stack uu___3);
-         (let uu___3 = FStar_Compiler_Util.smap_copy env1.exported_ids in
-          let uu___4 = FStar_Compiler_Util.smap_copy env1.trans_exported_ids in
-          let uu___5 = FStar_Compiler_Util.smap_copy env1.includes in
-          let uu___6 = FStar_Compiler_Util.smap_copy env1.sigmap in
-          {
-            curmodule = (env1.curmodule);
-            curmonad = (env1.curmonad);
-            modules = (env1.modules);
-            scope_mods = (env1.scope_mods);
-            exported_ids = uu___3;
-            trans_exported_ids = uu___4;
-            includes = uu___5;
-            sigaccum = (env1.sigaccum);
-            sigmap = uu___6;
-            iface = (env1.iface);
-            admitted_iface = (env1.admitted_iface);
-            expect_typ = (env1.expect_typ);
-            remaining_iface_decls = (env1.remaining_iface_decls);
-            syntax_only = (env1.syntax_only);
-            ds_hooks = (env1.ds_hooks);
-            dep_graph = (env1.dep_graph)
-          }))
-let (pop : unit -> env) =
-  fun uu___ ->
-    FStar_Compiler_Util.atomically
-      (fun uu___1 ->
-         let uu___2 = FStar_Compiler_Effect.op_Bang stack in
-         match uu___2 with
-         | env1::tl ->
-             (pop_record_cache ();
-              FStar_Compiler_Effect.op_Colon_Equals stack tl;
-              env1)
-         | uu___3 -> failwith "Impossible: Too many pops")
-let (snapshot : env -> (Prims.int * env)) =
-  fun env1 -> FStar_Common.snapshot push stack env1
-let (rollback : Prims.int FStar_Pervasives_Native.option -> env) =
-  fun depth -> FStar_Common.rollback pop stack depth
-let (export_interface : FStar_Ident.lident -> env -> env) =
-  fun m ->
-    fun env1 ->
-      let sigelt_in_m se =
-        match FStar_Syntax_Util.lids_of_sigelt se with
-        | l::uu___ ->
-            let uu___1 = FStar_Ident.nsstr l in
-            let uu___2 = FStar_Ident.string_of_lid m in uu___1 = uu___2
-        | uu___ -> false in
-      let sm = sigmap env1 in
-      let env2 = pop () in
-      let keys = FStar_Compiler_Util.smap_keys sm in
-      let sm' = sigmap env2 in
-      FStar_Compiler_Effect.op_Bar_Greater keys
-        (FStar_Compiler_List.iter
-           (fun k ->
-              let uu___1 = FStar_Compiler_Util.smap_try_find sm' k in
-              match uu___1 with
-              | FStar_Pervasives_Native.Some (se, true) when sigelt_in_m se
-                  ->
-                  (FStar_Compiler_Util.smap_remove sm' k;
-                   (let se1 =
-                      match se.FStar_Syntax_Syntax.sigel with
-                      | FStar_Syntax_Syntax.Sig_declare_typ (l, u, t) ->
-                          {
-                            FStar_Syntax_Syntax.sigel =
-                              (se.FStar_Syntax_Syntax.sigel);
-                            FStar_Syntax_Syntax.sigrng =
-                              (se.FStar_Syntax_Syntax.sigrng);
-                            FStar_Syntax_Syntax.sigquals =
-                              (FStar_Syntax_Syntax.Assumption ::
-                              (se.FStar_Syntax_Syntax.sigquals));
-                            FStar_Syntax_Syntax.sigmeta =
-                              (se.FStar_Syntax_Syntax.sigmeta);
-                            FStar_Syntax_Syntax.sigattrs =
-                              (se.FStar_Syntax_Syntax.sigattrs);
-                            FStar_Syntax_Syntax.sigopts =
-                              (se.FStar_Syntax_Syntax.sigopts)
-                          }
-                      | uu___3 -> se in
-                    FStar_Compiler_Util.smap_add sm' k (se1, false)))
-              | uu___2 -> ()));
-      env2
-let (finish_module_or_interface :
-  env -> FStar_Syntax_Syntax.modul -> (env * FStar_Syntax_Syntax.modul)) =
-  fun env1 ->
-    fun modul ->
-      let modul1 =
-        if Prims.op_Negation modul.FStar_Syntax_Syntax.is_interface
-        then check_admits env1 modul
-        else modul in
-      let uu___ = finish env1 modul1 in (uu___, modul1)
-type exported_ids =
-  {
-  exported_id_terms: Prims.string Prims.list ;
-  exported_id_fields: Prims.string Prims.list }
-let (__proj__Mkexported_ids__item__exported_id_terms :
-  exported_ids -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { exported_id_terms; exported_id_fields;_} -> exported_id_terms
-let (__proj__Mkexported_ids__item__exported_id_fields :
-  exported_ids -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { exported_id_terms; exported_id_fields;_} -> exported_id_fields
-let (as_exported_ids : exported_id_set -> exported_ids) =
-  fun e ->
-    let terms =
-      let uu___ =
-        let uu___1 = e Exported_id_term_type in
-        FStar_Compiler_Effect.op_Bang uu___1 in
-      FStar_Compiler_Util.set_elements uu___ in
-    let fields =
-      let uu___ =
-        let uu___1 = e Exported_id_field in
-        FStar_Compiler_Effect.op_Bang uu___1 in
-      FStar_Compiler_Util.set_elements uu___ in
-    { exported_id_terms = terms; exported_id_fields = fields }
-let (as_exported_id_set :
-  exported_ids FStar_Pervasives_Native.option ->
-    exported_id_kind ->
-      Prims.string FStar_Compiler_Util.set FStar_Compiler_Effect.ref)
-  =
-  fun e ->
-    match e with
-    | FStar_Pervasives_Native.None -> exported_id_set_new ()
-    | FStar_Pervasives_Native.Some e1 ->
-        let terms =
-          let uu___ =
-            FStar_Compiler_Util.as_set e1.exported_id_terms
-              FStar_Compiler_Util.compare in
-          FStar_Compiler_Util.mk_ref uu___ in
-        let fields =
-          let uu___ =
-            FStar_Compiler_Util.as_set e1.exported_id_fields
-              FStar_Compiler_Util.compare in
-          FStar_Compiler_Util.mk_ref uu___ in
-        (fun uu___ ->
-           match uu___ with
-           | Exported_id_term_type -> terms
-           | Exported_id_field -> fields)
-type module_inclusion_info =
-  {
-  mii_exported_ids: exported_ids FStar_Pervasives_Native.option ;
-  mii_trans_exported_ids: exported_ids FStar_Pervasives_Native.option ;
-  mii_includes: FStar_Ident.lident Prims.list FStar_Pervasives_Native.option }
-let (__proj__Mkmodule_inclusion_info__item__mii_exported_ids :
-  module_inclusion_info -> exported_ids FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { mii_exported_ids; mii_trans_exported_ids; mii_includes;_} ->
-        mii_exported_ids
-let (__proj__Mkmodule_inclusion_info__item__mii_trans_exported_ids :
-  module_inclusion_info -> exported_ids FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { mii_exported_ids; mii_trans_exported_ids; mii_includes;_} ->
-        mii_trans_exported_ids
-let (__proj__Mkmodule_inclusion_info__item__mii_includes :
-  module_inclusion_info ->
-    FStar_Ident.lident Prims.list FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { mii_exported_ids; mii_trans_exported_ids; mii_includes;_} ->
-        mii_includes
-let (default_mii : module_inclusion_info) =
-  {
-    mii_exported_ids = FStar_Pervasives_Native.None;
-    mii_trans_exported_ids = FStar_Pervasives_Native.None;
-    mii_includes = FStar_Pervasives_Native.None
-  }
-let as_includes :
-  'uuuuu .
-    'uuuuu Prims.list FStar_Pervasives_Native.option ->
-      'uuuuu Prims.list FStar_Compiler_Effect.ref
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> FStar_Compiler_Util.mk_ref []
-    | FStar_Pervasives_Native.Some l -> FStar_Compiler_Util.mk_ref l
-let (inclusion_info : env -> FStar_Ident.lident -> module_inclusion_info) =
-  fun env1 ->
-    fun l ->
-      let mname = FStar_Ident.string_of_lid l in
-      let as_ids_opt m =
-        let uu___ = FStar_Compiler_Util.smap_try_find m mname in
-        FStar_Compiler_Util.map_opt uu___ as_exported_ids in
-      let uu___ = as_ids_opt env1.exported_ids in
-      let uu___1 = as_ids_opt env1.trans_exported_ids in
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Util.smap_try_find env1.includes mname in
-        FStar_Compiler_Util.map_opt uu___3
-          (fun r -> FStar_Compiler_Effect.op_Bang r) in
-      {
-        mii_exported_ids = uu___;
-        mii_trans_exported_ids = uu___1;
-        mii_includes = uu___2
-      }
-let (prepare_module_or_interface :
-  Prims.bool ->
-    Prims.bool ->
-      env ->
-        FStar_Ident.lident -> module_inclusion_info -> (env * Prims.bool))
-  =
-  fun intf ->
-    fun admitted ->
-      fun env1 ->
-        fun mname ->
-          fun mii ->
-            let prep env2 =
-              let filename =
-                let uu___ = FStar_Ident.string_of_lid mname in
-                FStar_Compiler_Util.strcat uu___ ".fst" in
-              let auto_open =
-                FStar_Parser_Dep.hard_coded_dependencies filename in
-              let auto_open1 =
-                let convert_kind uu___ =
-                  match uu___ with
-                  | FStar_Parser_Dep.Open_namespace -> Open_namespace
-                  | FStar_Parser_Dep.Open_module -> Open_module in
-                FStar_Compiler_List.map
-                  (fun uu___ ->
-                     match uu___ with
-                     | (lid, kind) -> (lid, (convert_kind kind))) auto_open in
-              let namespace_of_module =
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 = FStar_Ident.ns_of_lid mname in
-                    FStar_Compiler_List.length uu___2 in
-                  uu___1 > Prims.int_zero in
-                if uu___
-                then
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 = FStar_Ident.ns_of_lid mname in
-                      FStar_Ident.lid_of_ids uu___3 in
-                    (uu___2, Open_namespace) in
-                  [uu___1]
-                else [] in
-              let auto_open2 =
-                FStar_Compiler_List.op_At namespace_of_module
-                  (FStar_Compiler_List.rev auto_open1) in
-              (let uu___1 = FStar_Ident.string_of_lid mname in
-               let uu___2 = as_exported_id_set mii.mii_exported_ids in
-               FStar_Compiler_Util.smap_add env2.exported_ids uu___1 uu___2);
-              (match () with
-               | () ->
-                   ((let uu___2 = FStar_Ident.string_of_lid mname in
-                     let uu___3 =
-                       as_exported_id_set mii.mii_trans_exported_ids in
-                     FStar_Compiler_Util.smap_add env2.trans_exported_ids
-                       uu___2 uu___3);
-                    (match () with
-                     | () ->
-                         ((let uu___3 = FStar_Ident.string_of_lid mname in
-                           let uu___4 = as_includes mii.mii_includes in
-                           FStar_Compiler_Util.smap_add env2.includes uu___3
-                             uu___4);
-                          (match () with
-                           | () ->
-                               let env' =
-                                 let uu___3 =
-                                   FStar_Compiler_List.map
-                                     (fun x -> Open_module_or_namespace x)
-                                     auto_open2 in
-                                 {
-                                   curmodule =
-                                     (FStar_Pervasives_Native.Some mname);
-                                   curmonad = (env2.curmonad);
-                                   modules = (env2.modules);
-                                   scope_mods = uu___3;
-                                   exported_ids = (env2.exported_ids);
-                                   trans_exported_ids =
-                                     (env2.trans_exported_ids);
-                                   includes = (env2.includes);
-                                   sigaccum = (env2.sigaccum);
-                                   sigmap = (env2.sigmap);
-                                   iface = intf;
-                                   admitted_iface = admitted;
-                                   expect_typ = (env2.expect_typ);
-                                   remaining_iface_decls =
-                                     (env2.remaining_iface_decls);
-                                   syntax_only = (env2.syntax_only);
-                                   ds_hooks = (env2.ds_hooks);
-                                   dep_graph = (env2.dep_graph)
-                                 } in
-                               (FStar_Compiler_List.iter
-                                  (fun op ->
-                                     (env2.ds_hooks).ds_push_open_hook env'
-                                       op)
-                                  (FStar_Compiler_List.rev auto_open2);
-                                env')))))) in
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater env1.modules
-                (FStar_Compiler_Util.find_opt
-                   (fun uu___1 ->
-                      match uu___1 with
-                      | (l, uu___2) -> FStar_Ident.lid_equals l mname)) in
-            match uu___ with
-            | FStar_Pervasives_Native.None ->
-                let uu___1 = prep env1 in (uu___1, false)
-            | FStar_Pervasives_Native.Some (uu___1, m) ->
-                ((let uu___3 =
-                    (let uu___4 = FStar_Options.interactive () in
-                     Prims.op_Negation uu___4) &&
-                      ((Prims.op_Negation m.FStar_Syntax_Syntax.is_interface)
-                         || intf) in
-                  if uu___3
-                  then
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = FStar_Ident.string_of_lid mname in
-                        FStar_Compiler_Util.format1
-                          "Duplicate module or interface name: %s" uu___6 in
-                      (FStar_Errors.Fatal_DuplicateModuleOrInterface, uu___5) in
-                    let uu___5 = FStar_Ident.range_of_lid mname in
-                    FStar_Errors.raise_error uu___4 uu___5
-                  else ());
-                 (let uu___3 = let uu___4 = push env1 in prep uu___4 in
-                  (uu___3, true)))
-let (enter_monad_scope : env -> FStar_Ident.ident -> env) =
-  fun env1 ->
-    fun mname ->
-      match env1.curmonad with
-      | FStar_Pervasives_Native.Some mname' ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Ident.string_of_id mname in
-                let uu___4 =
-                  let uu___5 = FStar_Ident.string_of_id mname' in
-                  Prims.op_Hat ", but already in monad scope " uu___5 in
-                Prims.op_Hat uu___3 uu___4 in
-              Prims.op_Hat "Trying to define monad " uu___2 in
-            (FStar_Errors.Fatal_MonadAlreadyDefined, uu___1) in
-          let uu___1 = FStar_Ident.range_of_id mname in
-          FStar_Errors.raise_error uu___ uu___1
-      | FStar_Pervasives_Native.None ->
-          {
-            curmodule = (env1.curmodule);
-            curmonad = (FStar_Pervasives_Native.Some mname);
-            modules = (env1.modules);
-            scope_mods = (env1.scope_mods);
-            exported_ids = (env1.exported_ids);
-            trans_exported_ids = (env1.trans_exported_ids);
-            includes = (env1.includes);
-            sigaccum = (env1.sigaccum);
-            sigmap = (env1.sigmap);
-            iface = (env1.iface);
-            admitted_iface = (env1.admitted_iface);
-            expect_typ = (env1.expect_typ);
-            remaining_iface_decls = (env1.remaining_iface_decls);
-            syntax_only = (env1.syntax_only);
-            ds_hooks = (env1.ds_hooks);
-            dep_graph = (env1.dep_graph)
-          }
-let fail_or :
-  'a .
-    env ->
-      (FStar_Ident.lident -> 'a FStar_Pervasives_Native.option) ->
-        FStar_Ident.lident -> 'a
-  =
-  fun env1 ->
-    fun lookup ->
-      fun lid ->
-        let uu___ = lookup lid in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            let opened_modules =
-              FStar_Compiler_List.map
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (lid1, uu___2) -> FStar_Ident.string_of_lid lid1)
-                env1.modules in
-            let msg =
-              let uu___1 = FStar_Ident.string_of_lid lid in
-              FStar_Compiler_Util.format1 "Identifier not found: [%s]" uu___1 in
-            let msg1 =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = FStar_Ident.ns_of_lid lid in
-                  FStar_Compiler_List.length uu___3 in
-                uu___2 = Prims.int_zero in
-              if uu___1
-              then msg
-              else
-                (let modul =
-                   let uu___3 =
-                     let uu___4 = FStar_Ident.ns_of_lid lid in
-                     FStar_Ident.lid_of_ids uu___4 in
-                   let uu___4 = FStar_Ident.range_of_lid lid in
-                   FStar_Ident.set_lid_range uu___3 uu___4 in
-                 let uu___3 = resolve_module_name env1 modul true in
-                 match uu___3 with
-                 | FStar_Pervasives_Native.None ->
-                     let opened_modules1 =
-                       FStar_String.concat ", " opened_modules in
-                     let uu___4 = FStar_Ident.string_of_lid modul in
-                     FStar_Compiler_Util.format3
-                       "%s\nModule %s does not belong to the list of modules in scope, namely %s"
-                       msg uu___4 opened_modules1
-                 | FStar_Pervasives_Native.Some modul' when
-                     let uu___4 =
-                       FStar_Compiler_List.existsb
-                         (fun m ->
-                            let uu___5 = FStar_Ident.string_of_lid modul' in
-                            m = uu___5) opened_modules in
-                     Prims.op_Negation uu___4 ->
-                     let opened_modules1 =
-                       FStar_String.concat ", " opened_modules in
-                     let uu___4 = FStar_Ident.string_of_lid modul in
-                     let uu___5 = FStar_Ident.string_of_lid modul' in
-                     FStar_Compiler_Util.format4
-                       "%s\nModule %s resolved into %s, which does not belong to the list of modules in scope, namely %s"
-                       msg uu___4 uu___5 opened_modules1
-                 | FStar_Pervasives_Native.Some modul' ->
-                     let uu___4 = FStar_Ident.string_of_lid modul in
-                     let uu___5 = FStar_Ident.string_of_lid modul' in
-                     let uu___6 =
-                       let uu___7 = FStar_Ident.ident_of_lid lid in
-                       FStar_Ident.string_of_id uu___7 in
-                     FStar_Compiler_Util.format4
-                       "%s\nModule %s resolved into %s, definition %s not found"
-                       msg uu___4 uu___5 uu___6) in
-            let uu___1 = FStar_Ident.range_of_lid lid in
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_IdentifierNotFound, msg1) uu___1
-        | FStar_Pervasives_Native.Some r -> r
-let fail_or2 :
-  'a .
-    (FStar_Ident.ident -> 'a FStar_Pervasives_Native.option) ->
-      FStar_Ident.ident -> 'a
-  =
-  fun lookup ->
-    fun id ->
-      let uu___ = lookup id in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Ident.string_of_id id in
-                Prims.op_Hat uu___4 "]" in
-              Prims.op_Hat "Identifier not found [" uu___3 in
-            (FStar_Errors.Fatal_IdentifierNotFound, uu___2) in
-          let uu___2 = FStar_Ident.range_of_id id in
-          FStar_Errors.raise_error uu___1 uu___2
-      | FStar_Pervasives_Native.Some r -> r
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Embeddings.ml b/src/ocaml-output/FStar_Syntax_Embeddings.ml
deleted file mode 100644
index 6e2e3cbca1a..00000000000
--- a/src/ocaml-output/FStar_Syntax_Embeddings.ml
+++ /dev/null
@@ -1,2695 +0,0 @@
-open Prims
-type norm_step =
-  | Simpl 
-  | Weak 
-  | HNF 
-  | Primops 
-  | Delta 
-  | Zeta 
-  | ZetaFull 
-  | Iota 
-  | Reify 
-  | UnfoldOnly of Prims.string Prims.list 
-  | UnfoldFully of Prims.string Prims.list 
-  | UnfoldAttr of Prims.string Prims.list 
-  | UnfoldQual of Prims.string Prims.list 
-  | UnfoldNamespace of Prims.string Prims.list 
-  | Unascribe 
-  | NBE 
-  | Unmeta 
-let (uu___is_Simpl : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Simpl -> true | uu___ -> false
-let (uu___is_Weak : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Weak -> true | uu___ -> false
-let (uu___is_HNF : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | HNF -> true | uu___ -> false
-let (uu___is_Primops : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Primops -> true | uu___ -> false
-let (uu___is_Delta : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Delta -> true | uu___ -> false
-let (uu___is_Zeta : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Zeta -> true | uu___ -> false
-let (uu___is_ZetaFull : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | ZetaFull -> true | uu___ -> false
-let (uu___is_Iota : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Iota -> true | uu___ -> false
-let (uu___is_Reify : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Reify -> true | uu___ -> false
-let (uu___is_UnfoldOnly : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldOnly _0 -> true | uu___ -> false
-let (__proj__UnfoldOnly__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldOnly _0 -> _0
-let (uu___is_UnfoldFully : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldFully _0 -> true | uu___ -> false
-let (__proj__UnfoldFully__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldFully _0 -> _0
-let (uu___is_UnfoldAttr : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldAttr _0 -> true | uu___ -> false
-let (__proj__UnfoldAttr__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldAttr _0 -> _0
-let (uu___is_UnfoldQual : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldQual _0 -> true | uu___ -> false
-let (__proj__UnfoldQual__item___0 : norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldQual _0 -> _0
-let (uu___is_UnfoldNamespace : norm_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldNamespace _0 -> true | uu___ -> false
-let (__proj__UnfoldNamespace__item___0 :
-  norm_step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldNamespace _0 -> _0
-let (uu___is_Unascribe : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Unascribe -> true | uu___ -> false
-let (uu___is_NBE : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | NBE -> true | uu___ -> false
-let (uu___is_Unmeta : norm_step -> Prims.bool) =
-  fun projectee -> match projectee with | Unmeta -> true | uu___ -> false
-type norm_cb =
-  (FStar_Ident.lident, FStar_Syntax_Syntax.term) FStar_Pervasives.either ->
-    FStar_Syntax_Syntax.term
-type shadow_term =
-  FStar_Syntax_Syntax.term FStar_Thunk.t FStar_Pervasives_Native.option
-type embed_t =
-  FStar_Compiler_Range.range ->
-    shadow_term -> norm_cb -> FStar_Syntax_Syntax.term
-type 'a unembed_t =
-  Prims.bool -> norm_cb -> 'a FStar_Pervasives_Native.option
-type 'a raw_embedder = 'a -> embed_t
-type 'a raw_unembedder = FStar_Syntax_Syntax.term -> 'a unembed_t
-let (id_norm_cb : norm_cb) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives.Inr x -> x
-    | FStar_Pervasives.Inl l ->
-        let uu___1 =
-          FStar_Syntax_Syntax.lid_as_fv l
-            FStar_Syntax_Syntax.delta_equational FStar_Pervasives_Native.None in
-        FStar_Syntax_Syntax.fv_to_tm uu___1
-exception Embedding_failure 
-let (uu___is_Embedding_failure : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Embedding_failure -> true | uu___ -> false
-exception Unembedding_failure 
-let (uu___is_Unembedding_failure : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Unembedding_failure -> true | uu___ -> false
-let (map_shadow :
-  shadow_term ->
-    (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) -> shadow_term)
-  = fun s -> fun f -> FStar_Compiler_Util.map_opt s (FStar_Thunk.map f)
-let (force_shadow :
-  shadow_term -> FStar_Syntax_Syntax.term FStar_Pervasives_Native.option) =
-  fun s -> FStar_Compiler_Util.map_opt s FStar_Thunk.force
-type 'a printer = 'a -> Prims.string
-type 'a embedding =
-  {
-  em: 'a -> embed_t ;
-  un: FStar_Syntax_Syntax.term -> 'a unembed_t ;
-  typ: FStar_Syntax_Syntax.typ ;
-  print: 'a printer ;
-  emb_typ: FStar_Syntax_Syntax.emb_typ }
-let __proj__Mkembedding__item__em : 'a . 'a embedding -> 'a -> embed_t =
-  fun projectee ->
-    match projectee with | { em; un; typ; print; emb_typ;_} -> em
-let __proj__Mkembedding__item__un :
-  'a . 'a embedding -> FStar_Syntax_Syntax.term -> 'a unembed_t =
-  fun projectee ->
-    match projectee with | { em; un; typ; print; emb_typ;_} -> un
-let __proj__Mkembedding__item__typ :
-  'a . 'a embedding -> FStar_Syntax_Syntax.typ =
-  fun projectee ->
-    match projectee with | { em; un; typ; print; emb_typ;_} -> typ
-let __proj__Mkembedding__item__print : 'a . 'a embedding -> 'a printer =
-  fun projectee ->
-    match projectee with | { em; un; typ; print; emb_typ;_} -> print
-let __proj__Mkembedding__item__emb_typ :
-  'a . 'a embedding -> FStar_Syntax_Syntax.emb_typ =
-  fun projectee ->
-    match projectee with | { em; un; typ; print; emb_typ;_} -> emb_typ
-let emb_typ_of : 'a . 'a embedding -> FStar_Syntax_Syntax.emb_typ =
-  fun e -> e.emb_typ
-let unknown_printer :
-  'uuuuu . FStar_Syntax_Syntax.term -> 'uuuuu -> Prims.string =
-  fun typ ->
-    fun uu___ ->
-      let uu___1 = FStar_Syntax_Print.term_to_string typ in
-      FStar_Compiler_Util.format1 "unknown %s" uu___1
-let (term_as_fv : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.fv) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv -> fv
-    | uu___1 ->
-        let uu___2 =
-          let uu___3 = FStar_Syntax_Print.term_to_string t in
-          FStar_Compiler_Util.format1 "Embeddings not defined for type %s"
-            uu___3 in
-        failwith uu___2
-let mk_emb :
-  'a .
-    'a raw_embedder ->
-      'a raw_unembedder -> FStar_Syntax_Syntax.fv -> 'a embedding
-  =
-  fun em ->
-    fun un ->
-      fun fv ->
-        let typ = FStar_Syntax_Syntax.fv_to_tm fv in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.lid_of_fv fv in
-              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                FStar_Ident.string_of_lid in
-            (uu___2, []) in
-          FStar_Syntax_Syntax.ET_app uu___1 in
-        { em; un; typ; print = (unknown_printer typ); emb_typ = uu___ }
-let mk_emb_full :
-  'a .
-    'a raw_embedder ->
-      'a raw_unembedder ->
-        FStar_Syntax_Syntax.typ ->
-          ('a -> Prims.string) -> FStar_Syntax_Syntax.emb_typ -> 'a embedding
-  =
-  fun em ->
-    fun un ->
-      fun typ ->
-        fun printer1 ->
-          fun emb_typ -> { em; un; typ; print = printer1; emb_typ }
-let rec (unmeta_div_results :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_meta
-        (t', FStar_Syntax_Syntax.Meta_monadic_lift (src, dst, uu___1)) ->
-        let uu___2 =
-          (FStar_Ident.lid_equals src FStar_Parser_Const.effect_PURE_lid) &&
-            (FStar_Ident.lid_equals dst FStar_Parser_Const.effect_DIV_lid) in
-        if uu___2 then unmeta_div_results t' else t
-    | FStar_Syntax_Syntax.Tm_meta
-        (t', FStar_Syntax_Syntax.Meta_monadic (m, uu___1)) ->
-        let uu___2 =
-          FStar_Ident.lid_equals m FStar_Parser_Const.effect_DIV_lid in
-        if uu___2 then unmeta_div_results t' else t
-    | FStar_Syntax_Syntax.Tm_meta (t', uu___1) -> unmeta_div_results t'
-    | FStar_Syntax_Syntax.Tm_ascribed (t', uu___1, uu___2) ->
-        unmeta_div_results t'
-    | uu___1 -> t
-let embed : 'a . 'a embedding -> 'a -> embed_t = fun e -> fun x -> e.em x
-let unembed : 'a . 'a embedding -> FStar_Syntax_Syntax.term -> 'a unembed_t =
-  fun e -> fun t -> let uu___ = unmeta_div_results t in e.un uu___
-let warn_unembed :
-  'a .
-    'a embedding ->
-      FStar_Syntax_Syntax.term ->
-        norm_cb -> 'a FStar_Pervasives_Native.option
-  = fun e -> fun t -> fun n -> let uu___ = unembed e t in uu___ true n
-let try_unembed :
-  'a .
-    'a embedding ->
-      FStar_Syntax_Syntax.term ->
-        norm_cb -> 'a FStar_Pervasives_Native.option
-  = fun e -> fun t -> fun n -> let uu___ = unembed e t in uu___ false n
-let type_of : 'a . 'a embedding -> FStar_Syntax_Syntax.typ = fun e -> e.typ
-let set_type : 'a . FStar_Syntax_Syntax.typ -> 'a embedding -> 'a embedding =
-  fun ty ->
-    fun e ->
-      {
-        em = (e.em);
-        un = (e.un);
-        typ = ty;
-        print = (e.print);
-        emb_typ = (e.emb_typ)
-      }
-let embed_as :
-  'a 'b .
-    'a embedding ->
-      ('a -> 'b) ->
-        ('b -> 'a) ->
-          FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option ->
-            'b embedding
-  =
-  fun ea ->
-    fun ab ->
-      fun ba ->
-        fun o ->
-          let uu___ =
-            match o with
-            | FStar_Pervasives_Native.Some t -> t
-            | uu___1 -> type_of ea in
-          mk_emb_full (fun x -> let uu___1 = ba x in embed ea uu___1)
-            (fun t ->
-               fun w ->
-                 fun cb ->
-                   let uu___1 = let uu___2 = unembed ea t in uu___2 w cb in
-                   FStar_Compiler_Util.map_opt uu___1 ab) uu___
-            (fun x ->
-               let uu___1 = let uu___2 = ba x in ea.print uu___2 in
-               FStar_Compiler_Util.format1 "(embed_as>> %s)\n" uu___1)
-            ea.emb_typ
-let lazy_embed :
-  'a .
-    'a printer ->
-      FStar_Syntax_Syntax.emb_typ ->
-        FStar_Compiler_Range.range ->
-          FStar_Syntax_Syntax.term ->
-            'a ->
-              (unit -> FStar_Syntax_Syntax.term) -> FStar_Syntax_Syntax.term
-  =
-  fun pa ->
-    fun et ->
-      fun rng ->
-        fun ta ->
-          fun x ->
-            fun f ->
-              (let uu___1 =
-                 FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-               if uu___1
-               then
-                 let uu___2 = FStar_Syntax_Print.term_to_string ta in
-                 let uu___3 = FStar_Syntax_Print.emb_typ_to_string et in
-                 let uu___4 = pa x in
-                 FStar_Compiler_Util.print3
-                   "Embedding a %s\n\temb_typ=%s\n\tvalue is %s\n" uu___2
-                   uu___3 uu___4
-               else ());
-              (let uu___1 =
-                 FStar_Compiler_Effect.op_Bang FStar_Options.eager_embedding in
-               if uu___1
-               then f ()
-               else
-                 (let thunk = FStar_Thunk.mk f in
-                  FStar_Syntax_Util.mk_lazy x FStar_Syntax_Syntax.tun
-                    (FStar_Syntax_Syntax.Lazy_embedding (et, thunk))
-                    (FStar_Pervasives_Native.Some rng)))
-let lazy_unembed :
-  'a .
-    'a printer ->
-      FStar_Syntax_Syntax.emb_typ ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term ->
-            (FStar_Syntax_Syntax.term -> 'a FStar_Pervasives_Native.option)
-              -> 'a FStar_Pervasives_Native.option
-  =
-  fun pa ->
-    fun et ->
-      fun x ->
-        fun ta ->
-          fun f ->
-            let x1 = FStar_Syntax_Subst.compress x in
-            match x1.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Tm_lazy
-                { FStar_Syntax_Syntax.blob = b;
-                  FStar_Syntax_Syntax.lkind =
-                    FStar_Syntax_Syntax.Lazy_embedding (et', t);
-                  FStar_Syntax_Syntax.ltyp = uu___;
-                  FStar_Syntax_Syntax.rng = uu___1;_}
-                ->
-                let uu___2 =
-                  (et <> et') ||
-                    (FStar_Compiler_Effect.op_Bang
-                       FStar_Options.eager_embedding) in
-                if uu___2
-                then
-                  let res = let uu___3 = FStar_Thunk.force t in f uu___3 in
-                  ((let uu___4 =
-                      FStar_Compiler_Effect.op_Bang
-                        FStar_Options.debug_embedding in
-                    if uu___4
-                    then
-                      let uu___5 = FStar_Syntax_Print.emb_typ_to_string et in
-                      let uu___6 = FStar_Syntax_Print.emb_typ_to_string et' in
-                      let uu___7 =
-                        match res with
-                        | FStar_Pervasives_Native.None -> "None"
-                        | FStar_Pervasives_Native.Some x2 ->
-                            let uu___8 = pa x2 in Prims.op_Hat "Some " uu___8 in
-                      FStar_Compiler_Util.print3
-                        "Unembed cancellation failed\n\t%s <> %s\nvalue is %s\n"
-                        uu___5 uu___6 uu___7
-                    else ());
-                   res)
-                else
-                  (let a1 = FStar_Compiler_Dyn.undyn b in
-                   (let uu___5 =
-                      FStar_Compiler_Effect.op_Bang
-                        FStar_Options.debug_embedding in
-                    if uu___5
-                    then
-                      let uu___6 = FStar_Syntax_Print.emb_typ_to_string et in
-                      let uu___7 = pa a1 in
-                      FStar_Compiler_Util.print2
-                        "Unembed cancelled for %s\n\tvalue is %s\n" uu___6
-                        uu___7
-                    else ());
-                   FStar_Pervasives_Native.Some a1)
-            | uu___ ->
-                let aopt = f x1 in
-                ((let uu___2 =
-                    FStar_Compiler_Effect.op_Bang
-                      FStar_Options.debug_embedding in
-                  if uu___2
-                  then
-                    let uu___3 = FStar_Syntax_Print.emb_typ_to_string et in
-                    let uu___4 = FStar_Syntax_Print.term_to_string x1 in
-                    let uu___5 =
-                      match aopt with
-                      | FStar_Pervasives_Native.None -> "None"
-                      | FStar_Pervasives_Native.Some a1 ->
-                          let uu___6 = pa a1 in Prims.op_Hat "Some " uu___6 in
-                    FStar_Compiler_Util.print3
-                      "Unembedding:\n\temb_typ=%s\n\tterm is %s\n\tvalue is %s\n"
-                      uu___3 uu___4 uu___5
-                  else ());
-                 aopt)
-let (mk_any_emb :
-  FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term embedding) =
-  fun typ ->
-    let em t _r _topt _norm =
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-       if uu___1
-       then
-         let uu___2 = unknown_printer typ t in
-         FStar_Compiler_Util.print1 "Embedding abstract: %s\n" uu___2
-       else ());
-      t in
-    let un t _w _n =
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-       if uu___1
-       then
-         let uu___2 = unknown_printer typ t in
-         FStar_Compiler_Util.print1 "Unembedding abstract: %s\n" uu___2
-       else ());
-      FStar_Pervasives_Native.Some t in
-    mk_emb_full em un typ (unknown_printer typ)
-      FStar_Syntax_Syntax.ET_abstract
-let (e_any : FStar_Syntax_Syntax.term embedding) =
-  let em t _r _topt _norm = t in
-  let un t _w _n = FStar_Pervasives_Native.Some t in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.term_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  mk_emb_full em un FStar_Syntax_Syntax.t_term
-    FStar_Syntax_Print.term_to_string uu___
-let (e_unit : unit embedding) =
-  let em u rng _topt _norm =
-    {
-      FStar_Syntax_Syntax.n =
-        (FStar_Syntax_Util.exp_unit.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars =
-        (FStar_Syntax_Util.exp_unit.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code =
-        (FStar_Syntax_Util.exp_unit.FStar_Syntax_Syntax.hash_code)
-    } in
-  let un t0 w _norm =
-    let t = FStar_Syntax_Util.unascribe t0 in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_unit) ->
-        FStar_Pervasives_Native.Some ()
-    | uu___ ->
-        (if w
-         then
-           (let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded unit: %s" uu___4 in
-              (FStar_Errors.Warning_NotEmbedded, uu___3) in
-            FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___2)
-         else ();
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.unit_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  mk_emb_full em un FStar_Syntax_Syntax.t_unit (fun uu___1 -> "()") uu___
-let (e_bool : Prims.bool embedding) =
-  let em b rng _topt _norm =
-    let t =
-      if b
-      then FStar_Syntax_Util.exp_true_bool
-      else FStar_Syntax_Util.exp_false_bool in
-    {
-      FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (t.FStar_Syntax_Syntax.hash_code)
-    } in
-  let un t0 w _norm =
-    let t = unmeta_div_results t0 in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_bool b) ->
-        FStar_Pervasives_Native.Some b
-    | uu___ ->
-        (if w
-         then
-           (let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.term_to_string t0 in
-                FStar_Compiler_Util.format1 "Not an embedded bool: %s" uu___4 in
-              (FStar_Errors.Warning_NotEmbedded, uu___3) in
-            FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___2)
-         else ();
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.bool_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  mk_emb_full em un FStar_Syntax_Syntax.t_bool
-    FStar_Compiler_Util.string_of_bool uu___
-let (e_char : FStar_Char.char embedding) =
-  let em c rng _topt _norm =
-    let t = FStar_Syntax_Util.exp_char c in
-    {
-      FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = rng;
-      FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code = (t.FStar_Syntax_Syntax.hash_code)
-    } in
-  let un t0 w _norm =
-    let t = unmeta_div_results t0 in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_char c) ->
-        FStar_Pervasives_Native.Some c
-    | uu___ ->
-        (if w
-         then
-           (let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.term_to_string t0 in
-                FStar_Compiler_Util.format1 "Not an embedded char: %s" uu___4 in
-              (FStar_Errors.Warning_NotEmbedded, uu___3) in
-            FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___2)
-         else ();
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.char_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  mk_emb_full em un FStar_Syntax_Syntax.t_char
-    FStar_Compiler_Util.string_of_char uu___
-let (e_int : FStar_BigInt.t embedding) =
-  let t_int = FStar_Syntax_Util.fvar_const FStar_Parser_Const.int_lid in
-  let emb_t_int =
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.int_lid
-          FStar_Ident.string_of_lid in
-      (uu___1, []) in
-    FStar_Syntax_Syntax.ET_app uu___ in
-  let em i rng _topt _norm =
-    lazy_embed FStar_BigInt.string_of_big_int emb_t_int rng t_int i
-      (fun uu___ ->
-         let uu___1 = FStar_BigInt.string_of_big_int i in
-         FStar_Syntax_Util.exp_int uu___1) in
-  let un t0 w _norm =
-    let t = unmeta_div_results t0 in
-    lazy_unembed FStar_BigInt.string_of_big_int emb_t_int t t_int
-      (fun t1 ->
-         match t1.FStar_Syntax_Syntax.n with
-         | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_int (s, uu___))
-             ->
-             let uu___1 = FStar_BigInt.big_int_of_string s in
-             FStar_Pervasives_Native.Some uu___1
-         | uu___ ->
-             (if w
-              then
-                (let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Print.term_to_string t0 in
-                     FStar_Compiler_Util.format1 "Not an embedded int: %s"
-                       uu___4 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___3) in
-                 FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___2)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  mk_emb_full em un FStar_Syntax_Syntax.t_int FStar_BigInt.string_of_big_int
-    emb_t_int
-let (e_fsint : Prims.int embedding) =
-  embed_as e_int FStar_BigInt.to_int_fs FStar_BigInt.of_int_fs
-    FStar_Pervasives_Native.None
-let (e_string : Prims.string embedding) =
-  let emb_t_string =
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.string_lid
-          FStar_Ident.string_of_lid in
-      (uu___1, []) in
-    FStar_Syntax_Syntax.ET_app uu___ in
-  let em s rng _topt _norm =
-    FStar_Syntax_Syntax.mk
-      (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_string (s, rng)))
-      rng in
-  let un t0 w _norm =
-    let t = unmeta_div_results t0 in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_string (s, uu___))
-        -> FStar_Pervasives_Native.Some s
-    | uu___ ->
-        (if w
-         then
-           (let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.term_to_string t0 in
-                FStar_Compiler_Util.format1 "Not an embedded string: %s"
-                  uu___4 in
-              (FStar_Errors.Warning_NotEmbedded, uu___3) in
-            FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___2)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb_full em un FStar_Syntax_Syntax.t_string
-    (fun x -> Prims.op_Hat "\"" (Prims.op_Hat x "\"")) emb_t_string
-let e_option :
-  'a . 'a embedding -> 'a FStar_Pervasives_Native.option embedding =
-  fun ea ->
-    let t_option_a =
-      let t_opt = FStar_Syntax_Util.fvar_const FStar_Parser_Const.option_lid in
-      let uu___ = let uu___1 = FStar_Syntax_Syntax.as_arg ea.typ in [uu___1] in
-      FStar_Syntax_Syntax.mk_Tm_app t_opt uu___
-        FStar_Compiler_Range.dummyRange in
-    let emb_t_option_a =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.option_lid
-            FStar_Ident.string_of_lid in
-        (uu___1, [ea.emb_typ]) in
-      FStar_Syntax_Syntax.ET_app uu___ in
-    let printer1 uu___ =
-      match uu___ with
-      | FStar_Pervasives_Native.None -> "None"
-      | FStar_Pervasives_Native.Some x ->
-          let uu___1 = let uu___2 = ea.print x in Prims.op_Hat uu___2 ")" in
-          Prims.op_Hat "(Some " uu___1 in
-    let em o rng topt norm =
-      lazy_embed printer1 emb_t_option_a rng t_option_a o
-        (fun uu___ ->
-           match o with
-           | FStar_Pervasives_Native.None ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Syntax.tdataconstr
-                     FStar_Parser_Const.none_lid in
-                 FStar_Syntax_Syntax.mk_Tm_uinst uu___2
-                   [FStar_Syntax_Syntax.U_zero] in
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = type_of ea in FStar_Syntax_Syntax.iarg uu___4 in
-                 [uu___3] in
-               FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng
-           | FStar_Pervasives_Native.Some a1 ->
-               let shadow_a =
-                 map_shadow topt
-                   (fun t ->
-                      let v = FStar_Ident.mk_ident ("v", rng) in
-                      let some_v =
-                        FStar_Syntax_Util.mk_field_projector_name_from_ident
-                          FStar_Parser_Const.some_lid v in
-                      let some_v_tm =
-                        let uu___1 =
-                          FStar_Syntax_Syntax.lid_as_fv some_v
-                            FStar_Syntax_Syntax.delta_equational
-                            FStar_Pervasives_Native.None in
-                        FStar_Syntax_Syntax.fv_to_tm uu___1 in
-                      let uu___1 =
-                        FStar_Syntax_Syntax.mk_Tm_uinst some_v_tm
-                          [FStar_Syntax_Syntax.U_zero] in
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 = type_of ea in
-                          FStar_Syntax_Syntax.iarg uu___4 in
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.as_arg t in
-                          [uu___5] in
-                        uu___3 :: uu___4 in
-                      FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng) in
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Syntax.tdataconstr
-                     FStar_Parser_Const.some_lid in
-                 FStar_Syntax_Syntax.mk_Tm_uinst uu___2
-                   [FStar_Syntax_Syntax.U_zero] in
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = type_of ea in FStar_Syntax_Syntax.iarg uu___4 in
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 = embed ea a1 in uu___7 rng shadow_a norm in
-                     FStar_Syntax_Syntax.as_arg uu___6 in
-                   [uu___5] in
-                 uu___3 :: uu___4 in
-               FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng) in
-    let un t0 w norm =
-      let t = unmeta_div_results t0 in
-      lazy_unembed printer1 emb_t_option_a t t_option_a
-        (fun t1 ->
-           let uu___ = FStar_Syntax_Util.head_and_args_full t1 in
-           match uu___ with
-           | (hd, args) ->
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 (uu___2, args) in
-               (match uu___1 with
-                | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2) when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.none_lid
-                    ->
-                    FStar_Pervasives_Native.Some FStar_Pervasives_Native.None
-                | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2::(a1, uu___3)::[])
-                    when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.some_lid
-                    ->
-                    let uu___4 = let uu___5 = unembed ea a1 in uu___5 w norm in
-                    FStar_Compiler_Util.bind_opt uu___4
-                      (fun a2 ->
-                         FStar_Pervasives_Native.Some
-                           (FStar_Pervasives_Native.Some a2))
-                | uu___2 ->
-                    (if w
-                     then
-                       (let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Syntax_Print.term_to_string t0 in
-                            FStar_Compiler_Util.format1
-                              "Not an embedded option: %s" uu___6 in
-                          (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                        FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                          uu___4)
-                     else ();
-                     FStar_Pervasives_Native.None))) in
-    let uu___ =
-      let uu___1 = type_of ea in FStar_Syntax_Syntax.t_option_of uu___1 in
-    mk_emb_full em un uu___ printer1 emb_t_option_a
-let e_tuple2 : 'a 'b . 'a embedding -> 'b embedding -> ('a * 'b) embedding =
-  fun ea ->
-    fun eb ->
-      let t_pair_a_b =
-        let t_tup2 =
-          FStar_Syntax_Util.fvar_const FStar_Parser_Const.lid_tuple2 in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Syntax.as_arg ea.typ in
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Syntax.as_arg eb.typ in [uu___3] in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app t_tup2 uu___
-          FStar_Compiler_Range.dummyRange in
-      let emb_t_pair_a_b =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              FStar_Parser_Const.lid_tuple2 FStar_Ident.string_of_lid in
-          (uu___1, [ea.emb_typ; eb.emb_typ]) in
-        FStar_Syntax_Syntax.ET_app uu___ in
-      let printer1 uu___ =
-        match uu___ with
-        | (x, y) ->
-            let uu___1 = ea.print x in
-            let uu___2 = eb.print y in
-            FStar_Compiler_Util.format2 "(%s, %s)" uu___1 uu___2 in
-      let em x rng topt norm =
-        lazy_embed printer1 emb_t_pair_a_b rng t_pair_a_b x
-          (fun uu___ ->
-             let proj i ab =
-               let proj_1 =
-                 let uu___1 =
-                   FStar_Parser_Const.mk_tuple_data_lid (Prims.of_int (2))
-                     rng in
-                 let uu___2 =
-                   FStar_Syntax_Syntax.null_bv FStar_Syntax_Syntax.tun in
-                 FStar_Syntax_Util.mk_field_projector_name uu___1 uu___2 i in
-               let proj_1_tm =
-                 let uu___1 =
-                   FStar_Syntax_Syntax.lid_as_fv proj_1
-                     FStar_Syntax_Syntax.delta_equational
-                     FStar_Pervasives_Native.None in
-                 FStar_Syntax_Syntax.fv_to_tm uu___1 in
-               let uu___1 =
-                 FStar_Syntax_Syntax.mk_Tm_uinst proj_1_tm
-                   [FStar_Syntax_Syntax.U_zero] in
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = type_of ea in FStar_Syntax_Syntax.iarg uu___4 in
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 = type_of eb in
-                     FStar_Syntax_Syntax.iarg uu___6 in
-                   let uu___6 =
-                     let uu___7 = FStar_Syntax_Syntax.as_arg ab in [uu___7] in
-                   uu___5 :: uu___6 in
-                 uu___3 :: uu___4 in
-               FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng in
-             let shadow_a = map_shadow topt (proj Prims.int_one) in
-             let shadow_b = map_shadow topt (proj (Prims.of_int (2))) in
-             let uu___1 =
-               let uu___2 =
-                 FStar_Syntax_Syntax.tdataconstr
-                   FStar_Parser_Const.lid_Mktuple2 in
-               FStar_Syntax_Syntax.mk_Tm_uinst uu___2
-                 [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero] in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = type_of ea in FStar_Syntax_Syntax.iarg uu___4 in
-               let uu___4 =
-                 let uu___5 =
-                   let uu___6 = type_of eb in FStar_Syntax_Syntax.iarg uu___6 in
-                 let uu___6 =
-                   let uu___7 =
-                     let uu___8 =
-                       let uu___9 = embed ea (FStar_Pervasives_Native.fst x) in
-                       uu___9 rng shadow_a norm in
-                     FStar_Syntax_Syntax.as_arg uu___8 in
-                   let uu___8 =
-                     let uu___9 =
-                       let uu___10 =
-                         let uu___11 =
-                           embed eb (FStar_Pervasives_Native.snd x) in
-                         uu___11 rng shadow_b norm in
-                       FStar_Syntax_Syntax.as_arg uu___10 in
-                     [uu___9] in
-                   uu___7 :: uu___8 in
-                 uu___5 :: uu___6 in
-               uu___3 :: uu___4 in
-             FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng) in
-      let un t0 w norm =
-        let t = unmeta_div_results t0 in
-        lazy_unembed printer1 emb_t_pair_a_b t t_pair_a_b
-          (fun t1 ->
-             let uu___ = FStar_Syntax_Util.head_and_args_full t1 in
-             match uu___ with
-             | (hd, args) ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                     uu___3.FStar_Syntax_Syntax.n in
-                   (uu___2, args) in
-                 (match uu___1 with
-                  | (FStar_Syntax_Syntax.Tm_fvar fv,
-                     uu___2::uu___3::(a1, uu___4)::(b1, uu___5)::[]) when
-                      FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.lid_Mktuple2
-                      ->
-                      let uu___6 =
-                        let uu___7 = unembed ea a1 in uu___7 w norm in
-                      FStar_Compiler_Util.bind_opt uu___6
-                        (fun a2 ->
-                           let uu___7 =
-                             let uu___8 = unembed eb b1 in uu___8 w norm in
-                           FStar_Compiler_Util.bind_opt uu___7
-                             (fun b2 -> FStar_Pervasives_Native.Some (a2, b2)))
-                  | uu___2 ->
-                      (if w
-                       then
-                         (let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Syntax_Print.term_to_string t0 in
-                              FStar_Compiler_Util.format1
-                                "Not an embedded pair: %s" uu___6 in
-                            (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                          FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                            uu___4)
-                       else ();
-                       FStar_Pervasives_Native.None))) in
-      let uu___ =
-        let uu___1 = type_of ea in
-        let uu___2 = type_of eb in
-        FStar_Syntax_Syntax.t_tuple2_of uu___1 uu___2 in
-      mk_emb_full em un uu___ printer1 emb_t_pair_a_b
-let e_tuple3 :
-  'a 'b 'c .
-    'a embedding -> 'b embedding -> 'c embedding -> ('a * 'b * 'c) embedding
-  =
-  fun ea ->
-    fun eb ->
-      fun ec ->
-        let t_pair_a_b_c =
-          let t_tup3 =
-            FStar_Syntax_Util.fvar_const FStar_Parser_Const.lid_tuple3 in
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.as_arg ea.typ in
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.as_arg eb.typ in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg ec.typ in [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          FStar_Syntax_Syntax.mk_Tm_app t_tup3 uu___
-            FStar_Compiler_Range.dummyRange in
-        let emb_t_pair_a_b_c =
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                FStar_Parser_Const.lid_tuple3 FStar_Ident.string_of_lid in
-            (uu___1, [ea.emb_typ; eb.emb_typ; ec.emb_typ]) in
-          FStar_Syntax_Syntax.ET_app uu___ in
-        let printer1 uu___ =
-          match uu___ with
-          | (x, y, z) ->
-              let uu___1 = ea.print x in
-              let uu___2 = eb.print y in
-              let uu___3 = ec.print z in
-              FStar_Compiler_Util.format3 "(%s, %s, %s)" uu___1 uu___2 uu___3 in
-        let em uu___ rng topt norm =
-          match uu___ with
-          | (x1, x2, x3) ->
-              lazy_embed printer1 emb_t_pair_a_b_c rng t_pair_a_b_c
-                (x1, x2, x3)
-                (fun uu___1 ->
-                   let proj i abc =
-                     let proj_i =
-                       let uu___2 =
-                         FStar_Parser_Const.mk_tuple_data_lid
-                           (Prims.of_int (3)) rng in
-                       let uu___3 =
-                         FStar_Syntax_Syntax.null_bv FStar_Syntax_Syntax.tun in
-                       FStar_Syntax_Util.mk_field_projector_name uu___2
-                         uu___3 i in
-                     let proj_i_tm =
-                       let uu___2 =
-                         FStar_Syntax_Syntax.lid_as_fv proj_i
-                           FStar_Syntax_Syntax.delta_equational
-                           FStar_Pervasives_Native.None in
-                       FStar_Syntax_Syntax.fv_to_tm uu___2 in
-                     let uu___2 =
-                       FStar_Syntax_Syntax.mk_Tm_uinst proj_i_tm
-                         [FStar_Syntax_Syntax.U_zero] in
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 = type_of ea in
-                         FStar_Syntax_Syntax.iarg uu___5 in
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 = type_of eb in
-                           FStar_Syntax_Syntax.iarg uu___7 in
-                         let uu___7 =
-                           let uu___8 =
-                             let uu___9 = type_of ec in
-                             FStar_Syntax_Syntax.iarg uu___9 in
-                           let uu___9 =
-                             let uu___10 = FStar_Syntax_Syntax.as_arg abc in
-                             [uu___10] in
-                           uu___8 :: uu___9 in
-                         uu___6 :: uu___7 in
-                       uu___4 :: uu___5 in
-                     FStar_Syntax_Syntax.mk_Tm_app uu___2 uu___3 rng in
-                   let shadow_a = map_shadow topt (proj Prims.int_one) in
-                   let shadow_b = map_shadow topt (proj (Prims.of_int (2))) in
-                   let shadow_c = map_shadow topt (proj (Prims.of_int (3))) in
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Syntax_Syntax.tdataconstr
-                         FStar_Parser_Const.lid_Mktuple3 in
-                     FStar_Syntax_Syntax.mk_Tm_uinst uu___3
-                       [FStar_Syntax_Syntax.U_zero;
-                       FStar_Syntax_Syntax.U_zero;
-                       FStar_Syntax_Syntax.U_zero] in
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = type_of ea in
-                       FStar_Syntax_Syntax.iarg uu___5 in
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 = type_of eb in
-                         FStar_Syntax_Syntax.iarg uu___7 in
-                       let uu___7 =
-                         let uu___8 =
-                           let uu___9 = type_of ec in
-                           FStar_Syntax_Syntax.iarg uu___9 in
-                         let uu___9 =
-                           let uu___10 =
-                             let uu___11 =
-                               let uu___12 = embed ea x1 in
-                               uu___12 rng shadow_a norm in
-                             FStar_Syntax_Syntax.as_arg uu___11 in
-                           let uu___11 =
-                             let uu___12 =
-                               let uu___13 =
-                                 let uu___14 = embed eb x2 in
-                                 uu___14 rng shadow_b norm in
-                               FStar_Syntax_Syntax.as_arg uu___13 in
-                             let uu___13 =
-                               let uu___14 =
-                                 let uu___15 =
-                                   let uu___16 = embed ec x3 in
-                                   uu___16 rng shadow_c norm in
-                                 FStar_Syntax_Syntax.as_arg uu___15 in
-                               [uu___14] in
-                             uu___12 :: uu___13 in
-                           uu___10 :: uu___11 in
-                         uu___8 :: uu___9 in
-                       uu___6 :: uu___7 in
-                     uu___4 :: uu___5 in
-                   FStar_Syntax_Syntax.mk_Tm_app uu___2 uu___3 rng) in
-        let un t0 w norm =
-          let t = unmeta_div_results t0 in
-          lazy_unembed printer1 emb_t_pair_a_b_c t t_pair_a_b_c
-            (fun t1 ->
-               let uu___ = FStar_Syntax_Util.head_and_args_full t1 in
-               match uu___ with
-               | (hd, args) ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                       uu___3.FStar_Syntax_Syntax.n in
-                     (uu___2, args) in
-                   (match uu___1 with
-                    | (FStar_Syntax_Syntax.Tm_fvar fv,
-                       uu___2::uu___3::uu___4::(a1, uu___5)::(b1, uu___6)::
-                       (c1, uu___7)::[]) when
-                        FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.lid_Mktuple3
-                        ->
-                        let uu___8 =
-                          let uu___9 = unembed ea a1 in uu___9 w norm in
-                        FStar_Compiler_Util.bind_opt uu___8
-                          (fun a2 ->
-                             let uu___9 =
-                               let uu___10 = unembed eb b1 in uu___10 w norm in
-                             FStar_Compiler_Util.bind_opt uu___9
-                               (fun b2 ->
-                                  let uu___10 =
-                                    let uu___11 = unembed ec c1 in
-                                    uu___11 w norm in
-                                  FStar_Compiler_Util.bind_opt uu___10
-                                    (fun c2 ->
-                                       FStar_Pervasives_Native.Some
-                                         (a2, b2, c2))))
-                    | uu___2 ->
-                        (if w
-                         then
-                           (let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  FStar_Syntax_Print.term_to_string t0 in
-                                FStar_Compiler_Util.format1
-                                  "Not an embedded pair: %s" uu___6 in
-                              (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                            FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                              uu___4)
-                         else ();
-                         FStar_Pervasives_Native.None))) in
-        let uu___ =
-          let uu___1 = type_of ea in
-          let uu___2 = type_of eb in
-          let uu___3 = type_of ec in
-          FStar_Syntax_Syntax.t_tuple3_of uu___1 uu___2 uu___3 in
-        mk_emb_full em un uu___ printer1 emb_t_pair_a_b_c
-let e_either :
-  'a 'b .
-    'a embedding ->
-      'b embedding -> ('a, 'b) FStar_Pervasives.either embedding
-  =
-  fun ea ->
-    fun eb ->
-      let t_sum_a_b =
-        let t_either =
-          FStar_Syntax_Util.fvar_const FStar_Parser_Const.either_lid in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Syntax.as_arg ea.typ in
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Syntax.as_arg eb.typ in [uu___3] in
-          uu___1 :: uu___2 in
-        FStar_Syntax_Syntax.mk_Tm_app t_either uu___
-          FStar_Compiler_Range.dummyRange in
-      let emb_t_sum_a_b =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              FStar_Parser_Const.either_lid FStar_Ident.string_of_lid in
-          (uu___1, [ea.emb_typ; eb.emb_typ]) in
-        FStar_Syntax_Syntax.ET_app uu___ in
-      let printer1 s =
-        match s with
-        | FStar_Pervasives.Inl a1 ->
-            let uu___ = ea.print a1 in
-            FStar_Compiler_Util.format1 "Inl %s" uu___
-        | FStar_Pervasives.Inr b1 ->
-            let uu___ = eb.print b1 in
-            FStar_Compiler_Util.format1 "Inr %s" uu___ in
-      let em s rng topt norm =
-        lazy_embed printer1 emb_t_sum_a_b rng t_sum_a_b s
-          (match s with
-           | FStar_Pervasives.Inl a1 ->
-               (fun uu___ ->
-                  let shadow_a =
-                    map_shadow topt
-                      (fun t ->
-                         let v = FStar_Ident.mk_ident ("v", rng) in
-                         let some_v =
-                           FStar_Syntax_Util.mk_field_projector_name_from_ident
-                             FStar_Parser_Const.inl_lid v in
-                         let some_v_tm =
-                           let uu___1 =
-                             FStar_Syntax_Syntax.lid_as_fv some_v
-                               FStar_Syntax_Syntax.delta_equational
-                               FStar_Pervasives_Native.None in
-                           FStar_Syntax_Syntax.fv_to_tm uu___1 in
-                         let uu___1 =
-                           FStar_Syntax_Syntax.mk_Tm_uinst some_v_tm
-                             [FStar_Syntax_Syntax.U_zero] in
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = type_of ea in
-                             FStar_Syntax_Syntax.iarg uu___4 in
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 = type_of eb in
-                               FStar_Syntax_Syntax.iarg uu___6 in
-                             let uu___6 =
-                               let uu___7 = FStar_Syntax_Syntax.as_arg t in
-                               [uu___7] in
-                             uu___5 :: uu___6 in
-                           uu___3 :: uu___4 in
-                         FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng) in
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Syntax_Syntax.tdataconstr
-                        FStar_Parser_Const.inl_lid in
-                    FStar_Syntax_Syntax.mk_Tm_uinst uu___2
-                      [FStar_Syntax_Syntax.U_zero;
-                      FStar_Syntax_Syntax.U_zero] in
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = type_of ea in
-                      FStar_Syntax_Syntax.iarg uu___4 in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = type_of eb in
-                        FStar_Syntax_Syntax.iarg uu___6 in
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            let uu___9 = embed ea a1 in
-                            uu___9 rng shadow_a norm in
-                          FStar_Syntax_Syntax.as_arg uu___8 in
-                        [uu___7] in
-                      uu___5 :: uu___6 in
-                    uu___3 :: uu___4 in
-                  FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng)
-           | FStar_Pervasives.Inr b1 ->
-               (fun uu___ ->
-                  let shadow_b =
-                    map_shadow topt
-                      (fun t ->
-                         let v = FStar_Ident.mk_ident ("v", rng) in
-                         let some_v =
-                           FStar_Syntax_Util.mk_field_projector_name_from_ident
-                             FStar_Parser_Const.inr_lid v in
-                         let some_v_tm =
-                           let uu___1 =
-                             FStar_Syntax_Syntax.lid_as_fv some_v
-                               FStar_Syntax_Syntax.delta_equational
-                               FStar_Pervasives_Native.None in
-                           FStar_Syntax_Syntax.fv_to_tm uu___1 in
-                         let uu___1 =
-                           FStar_Syntax_Syntax.mk_Tm_uinst some_v_tm
-                             [FStar_Syntax_Syntax.U_zero] in
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = type_of ea in
-                             FStar_Syntax_Syntax.iarg uu___4 in
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 = type_of eb in
-                               FStar_Syntax_Syntax.iarg uu___6 in
-                             let uu___6 =
-                               let uu___7 = FStar_Syntax_Syntax.as_arg t in
-                               [uu___7] in
-                             uu___5 :: uu___6 in
-                           uu___3 :: uu___4 in
-                         FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng) in
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Syntax_Syntax.tdataconstr
-                        FStar_Parser_Const.inr_lid in
-                    FStar_Syntax_Syntax.mk_Tm_uinst uu___2
-                      [FStar_Syntax_Syntax.U_zero;
-                      FStar_Syntax_Syntax.U_zero] in
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = type_of ea in
-                      FStar_Syntax_Syntax.iarg uu___4 in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = type_of eb in
-                        FStar_Syntax_Syntax.iarg uu___6 in
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            let uu___9 = embed eb b1 in
-                            uu___9 rng shadow_b norm in
-                          FStar_Syntax_Syntax.as_arg uu___8 in
-                        [uu___7] in
-                      uu___5 :: uu___6 in
-                    uu___3 :: uu___4 in
-                  FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng)) in
-      let un t0 w norm =
-        let t = unmeta_div_results t0 in
-        lazy_unembed printer1 emb_t_sum_a_b t t_sum_a_b
-          (fun t1 ->
-             let uu___ = FStar_Syntax_Util.head_and_args_full t1 in
-             match uu___ with
-             | (hd, args) ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                     uu___3.FStar_Syntax_Syntax.n in
-                   (uu___2, args) in
-                 (match uu___1 with
-                  | (FStar_Syntax_Syntax.Tm_fvar fv,
-                     uu___2::uu___3::(a1, uu___4)::[]) when
-                      FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.inl_lid
-                      ->
-                      let uu___5 =
-                        let uu___6 = unembed ea a1 in uu___6 w norm in
-                      FStar_Compiler_Util.bind_opt uu___5
-                        (fun a2 ->
-                           FStar_Pervasives_Native.Some
-                             (FStar_Pervasives.Inl a2))
-                  | (FStar_Syntax_Syntax.Tm_fvar fv,
-                     uu___2::uu___3::(b1, uu___4)::[]) when
-                      FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.inr_lid
-                      ->
-                      let uu___5 =
-                        let uu___6 = unembed eb b1 in uu___6 w norm in
-                      FStar_Compiler_Util.bind_opt uu___5
-                        (fun b2 ->
-                           FStar_Pervasives_Native.Some
-                             (FStar_Pervasives.Inr b2))
-                  | uu___2 ->
-                      (if w
-                       then
-                         (let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Syntax_Print.term_to_string t0 in
-                              FStar_Compiler_Util.format1
-                                "Not an embedded sum: %s" uu___6 in
-                            (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                          FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                            uu___4)
-                       else ();
-                       FStar_Pervasives_Native.None))) in
-      let uu___ =
-        let uu___1 = type_of ea in
-        let uu___2 = type_of eb in
-        FStar_Syntax_Syntax.t_either_of uu___1 uu___2 in
-      mk_emb_full em un uu___ printer1 emb_t_sum_a_b
-let e_list : 'a . 'a embedding -> 'a Prims.list embedding =
-  fun ea ->
-    let t_list_a =
-      let t_list = FStar_Syntax_Util.fvar_const FStar_Parser_Const.list_lid in
-      let uu___ = let uu___1 = FStar_Syntax_Syntax.as_arg ea.typ in [uu___1] in
-      FStar_Syntax_Syntax.mk_Tm_app t_list uu___
-        FStar_Compiler_Range.dummyRange in
-    let emb_t_list_a =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.list_lid
-            FStar_Ident.string_of_lid in
-        (uu___1, [ea.emb_typ]) in
-      FStar_Syntax_Syntax.ET_app uu___ in
-    let printer1 l =
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.map ea.print l in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (FStar_String.concat "; ") in
-        Prims.op_Hat uu___1 "]" in
-      Prims.op_Hat "[" uu___ in
-    let rec em l rng shadow_l norm =
-      lazy_embed printer1 emb_t_list_a rng t_list_a l
-        (fun uu___ ->
-           let t = let uu___1 = type_of ea in FStar_Syntax_Syntax.iarg uu___1 in
-           match l with
-           | [] ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Syntax.tdataconstr FStar_Parser_Const.nil_lid in
-                 FStar_Syntax_Syntax.mk_Tm_uinst uu___2
-                   [FStar_Syntax_Syntax.U_zero] in
-               FStar_Syntax_Syntax.mk_Tm_app uu___1 [t] rng
-           | hd::tl ->
-               let cons =
-                 let uu___1 =
-                   FStar_Syntax_Syntax.tdataconstr
-                     FStar_Parser_Const.cons_lid in
-                 FStar_Syntax_Syntax.mk_Tm_uinst uu___1
-                   [FStar_Syntax_Syntax.U_zero] in
-               let proj f cons_tm =
-                 let fid = FStar_Ident.mk_ident (f, rng) in
-                 let proj1 =
-                   FStar_Syntax_Util.mk_field_projector_name_from_ident
-                     FStar_Parser_Const.cons_lid fid in
-                 let proj_tm =
-                   let uu___1 =
-                     FStar_Syntax_Syntax.lid_as_fv proj1
-                       FStar_Syntax_Syntax.delta_equational
-                       FStar_Pervasives_Native.None in
-                   FStar_Syntax_Syntax.fv_to_tm uu___1 in
-                 let uu___1 =
-                   FStar_Syntax_Syntax.mk_Tm_uinst proj_tm
-                     [FStar_Syntax_Syntax.U_zero] in
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = type_of ea in
-                     FStar_Syntax_Syntax.iarg uu___4 in
-                   let uu___4 =
-                     let uu___5 = FStar_Syntax_Syntax.as_arg cons_tm in
-                     [uu___5] in
-                   uu___3 :: uu___4 in
-                 FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 rng in
-               let shadow_hd = map_shadow shadow_l (proj "hd") in
-               let shadow_tl = map_shadow shadow_l (proj "tl") in
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = embed ea hd in uu___5 rng shadow_hd norm in
-                     FStar_Syntax_Syntax.as_arg uu___4 in
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 = em tl rng shadow_tl norm in
-                       FStar_Syntax_Syntax.as_arg uu___6 in
-                     [uu___5] in
-                   uu___3 :: uu___4 in
-                 t :: uu___2 in
-               FStar_Syntax_Syntax.mk_Tm_app cons uu___1 rng) in
-    let rec un t0 w norm =
-      let t = unmeta_div_results t0 in
-      lazy_unembed printer1 emb_t_list_a t t_list_a
-        (fun t1 ->
-           let uu___ = FStar_Syntax_Util.head_and_args_full t1 in
-           match uu___ with
-           | (hd, args) ->
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 (uu___2, args) in
-               (match uu___1 with
-                | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2) when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.nil_lid
-                    -> FStar_Pervasives_Native.Some []
-                | (FStar_Syntax_Syntax.Tm_fvar fv,
-                   (uu___2, FStar_Pervasives_Native.Some
-                    { FStar_Syntax_Syntax.aqual_implicit = true;
-                      FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::
-                   (hd1, FStar_Pervasives_Native.None)::(tl,
-                                                         FStar_Pervasives_Native.None)::[])
-                    when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.cons_lid
-                    ->
-                    let uu___4 = let uu___5 = unembed ea hd1 in uu___5 w norm in
-                    FStar_Compiler_Util.bind_opt uu___4
-                      (fun hd2 ->
-                         let uu___5 = un tl w norm in
-                         FStar_Compiler_Util.bind_opt uu___5
-                           (fun tl1 ->
-                              FStar_Pervasives_Native.Some (hd2 :: tl1)))
-                | (FStar_Syntax_Syntax.Tm_fvar fv,
-                   (hd1, FStar_Pervasives_Native.None)::(tl,
-                                                         FStar_Pervasives_Native.None)::[])
-                    when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.cons_lid
-                    ->
-                    let uu___2 = let uu___3 = unembed ea hd1 in uu___3 w norm in
-                    FStar_Compiler_Util.bind_opt uu___2
-                      (fun hd2 ->
-                         let uu___3 = un tl w norm in
-                         FStar_Compiler_Util.bind_opt uu___3
-                           (fun tl1 ->
-                              FStar_Pervasives_Native.Some (hd2 :: tl1)))
-                | uu___2 ->
-                    (if w
-                     then
-                       (let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Syntax_Print.term_to_string t0 in
-                            FStar_Compiler_Util.format1
-                              "Not an embedded list: %s" uu___6 in
-                          (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                        FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                          uu___4)
-                     else ();
-                     FStar_Pervasives_Native.None))) in
-    let uu___ =
-      let uu___1 = type_of ea in FStar_Syntax_Syntax.t_list_of uu___1 in
-    mk_emb_full em un uu___ printer1 emb_t_list_a
-let (e_string_list : Prims.string Prims.list embedding) = e_list e_string
-let (steps_Simpl : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_simpl
-let (steps_Weak : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_weak
-let (steps_HNF : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_hnf
-let (steps_Primops : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_primops
-let (steps_Delta : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_delta
-let (steps_Zeta : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_zeta
-let (steps_ZetaFull : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_zeta_full
-let (steps_Iota : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_iota
-let (steps_Reify : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_reify
-let (steps_UnfoldOnly : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unfoldonly
-let (steps_UnfoldFully : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unfoldonly
-let (steps_UnfoldAttr : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unfoldattr
-let (steps_UnfoldQual : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unfoldqual
-let (steps_UnfoldNamespace : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unfoldnamespace
-let (steps_Unascribe : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unascribe
-let (steps_NBE : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_nbe
-let (steps_Unmeta : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.tconst FStar_Parser_Const.steps_unmeta
-let (e_norm_step : norm_step embedding) =
-  let t_norm_step =
-    let uu___ = FStar_Ident.lid_of_str "FStar.Syntax.Embeddings.norm_step" in
-    FStar_Syntax_Util.fvar_const uu___ in
-  let emb_t_norm_step =
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.norm_step_lid
-          FStar_Ident.string_of_lid in
-      (uu___1, []) in
-    FStar_Syntax_Syntax.ET_app uu___ in
-  let printer1 uu___ = "norm_step" in
-  let em n rng _topt norm =
-    lazy_embed printer1 emb_t_norm_step rng t_norm_step n
-      (fun uu___ ->
-         match n with
-         | Simpl -> steps_Simpl
-         | Weak -> steps_Weak
-         | HNF -> steps_HNF
-         | Primops -> steps_Primops
-         | Delta -> steps_Delta
-         | Zeta -> steps_Zeta
-         | ZetaFull -> steps_ZetaFull
-         | Iota -> steps_Iota
-         | Unascribe -> steps_Unascribe
-         | NBE -> steps_NBE
-         | Unmeta -> steps_Unmeta
-         | Reify -> steps_Reify
-         | UnfoldOnly l ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = e_list e_string in embed uu___5 l in
-                   uu___4 rng FStar_Pervasives_Native.None norm in
-                 FStar_Syntax_Syntax.as_arg uu___3 in
-               [uu___2] in
-             FStar_Syntax_Syntax.mk_Tm_app steps_UnfoldOnly uu___1 rng
-         | UnfoldFully l ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = e_list e_string in embed uu___5 l in
-                   uu___4 rng FStar_Pervasives_Native.None norm in
-                 FStar_Syntax_Syntax.as_arg uu___3 in
-               [uu___2] in
-             FStar_Syntax_Syntax.mk_Tm_app steps_UnfoldFully uu___1 rng
-         | UnfoldAttr l ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = e_list e_string in embed uu___5 l in
-                   uu___4 rng FStar_Pervasives_Native.None norm in
-                 FStar_Syntax_Syntax.as_arg uu___3 in
-               [uu___2] in
-             FStar_Syntax_Syntax.mk_Tm_app steps_UnfoldAttr uu___1 rng
-         | UnfoldQual l ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = e_list e_string in embed uu___5 l in
-                   uu___4 rng FStar_Pervasives_Native.None norm in
-                 FStar_Syntax_Syntax.as_arg uu___3 in
-               [uu___2] in
-             FStar_Syntax_Syntax.mk_Tm_app steps_UnfoldQual uu___1 rng
-         | UnfoldNamespace l ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = e_list e_string in embed uu___5 l in
-                   uu___4 rng FStar_Pervasives_Native.None norm in
-                 FStar_Syntax_Syntax.as_arg uu___3 in
-               [uu___2] in
-             FStar_Syntax_Syntax.mk_Tm_app steps_UnfoldNamespace uu___1 rng) in
-  let un t0 w norm =
-    let t = unmeta_div_results t0 in
-    lazy_unembed printer1 emb_t_norm_step t t_norm_step
-      (fun t1 ->
-         let uu___ = FStar_Syntax_Util.head_and_args t1 in
-         match uu___ with
-         | (hd, args) ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                 uu___3.FStar_Syntax_Syntax.n in
-               (uu___2, args) in
-             (match uu___1 with
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_simpl
-                  -> FStar_Pervasives_Native.Some Simpl
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_weak
-                  -> FStar_Pervasives_Native.Some Weak
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_hnf
-                  -> FStar_Pervasives_Native.Some HNF
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_primops
-                  -> FStar_Pervasives_Native.Some Primops
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_delta
-                  -> FStar_Pervasives_Native.Some Delta
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_zeta
-                  -> FStar_Pervasives_Native.Some Zeta
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_zeta_full
-                  -> FStar_Pervasives_Native.Some ZetaFull
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_iota
-                  -> FStar_Pervasives_Native.Some Iota
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unascribe
-                  -> FStar_Pervasives_Native.Some Unascribe
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_nbe
-                  -> FStar_Pervasives_Native.Some NBE
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unmeta
-                  -> FStar_Pervasives_Native.Some Unmeta
-              | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_reify
-                  -> FStar_Pervasives_Native.Some Reify
-              | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unfoldonly
-                  ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = e_list e_string in unembed uu___5 l in
-                    uu___4 w norm in
-                  FStar_Compiler_Util.bind_opt uu___3
-                    (fun ss ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                         (UnfoldOnly ss))
-              | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unfoldfully
-                  ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = e_list e_string in unembed uu___5 l in
-                    uu___4 w norm in
-                  FStar_Compiler_Util.bind_opt uu___3
-                    (fun ss ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                         (UnfoldFully ss))
-              | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unfoldattr
-                  ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = e_list e_string in unembed uu___5 l in
-                    uu___4 w norm in
-                  FStar_Compiler_Util.bind_opt uu___3
-                    (fun ss ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                         (UnfoldAttr ss))
-              | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unfoldqual
-                  ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = e_list e_string in unembed uu___5 l in
-                    uu___4 w norm in
-                  FStar_Compiler_Util.bind_opt uu___3
-                    (fun ss ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                         (UnfoldQual ss))
-              | (FStar_Syntax_Syntax.Tm_fvar fv, (l, uu___2)::[]) when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.steps_unfoldnamespace
-                  ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = e_list e_string in unembed uu___5 l in
-                    uu___4 w norm in
-                  FStar_Compiler_Util.bind_opt uu___3
-                    (fun ss ->
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                         (UnfoldNamespace ss))
-              | uu___2 ->
-                  (if w
-                   then
-                     (let uu___4 =
-                        let uu___5 =
-                          let uu___6 = FStar_Syntax_Print.term_to_string t0 in
-                          FStar_Compiler_Util.format1
-                            "Not an embedded norm_step: %s" uu___6 in
-                        (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                      FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos
-                        uu___4)
-                   else ();
-                   FStar_Pervasives_Native.None))) in
-  mk_emb_full em un FStar_Syntax_Syntax.t_norm_step printer1 emb_t_norm_step
-let (e_range : FStar_Compiler_Range.range embedding) =
-  let em r rng _shadow _norm =
-    FStar_Syntax_Syntax.mk
-      (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_range r)) rng in
-  let un t0 w _norm =
-    let t = unmeta_div_results t0 in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_range r) ->
-        FStar_Pervasives_Native.Some r
-    | uu___ ->
-        (if w
-         then
-           (let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.term_to_string t0 in
-                FStar_Compiler_Util.format1 "Not an embedded range: %s"
-                  uu___4 in
-              (FStar_Errors.Warning_NotEmbedded, uu___3) in
-            FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___2)
-         else ();
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.range_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  mk_emb_full em un FStar_Syntax_Syntax.t_range
-    FStar_Compiler_Range.string_of_range uu___
-let (e_vconfig : FStar_VConfig.vconfig embedding) =
-  let em vcfg rng _shadow norm =
-    let uu___ =
-      FStar_Syntax_Syntax.tdataconstr FStar_Parser_Const.mkvconfig_lid in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          let uu___4 = embed e_fsint vcfg.FStar_VConfig.initial_fuel in
-          uu___4 rng FStar_Pervasives_Native.None norm in
-        FStar_Syntax_Syntax.as_arg uu___3 in
-      let uu___3 =
-        let uu___4 =
-          let uu___5 =
-            let uu___6 = embed e_fsint vcfg.FStar_VConfig.max_fuel in
-            uu___6 rng FStar_Pervasives_Native.None norm in
-          FStar_Syntax_Syntax.as_arg uu___5 in
-        let uu___5 =
-          let uu___6 =
-            let uu___7 =
-              let uu___8 = embed e_fsint vcfg.FStar_VConfig.initial_ifuel in
-              uu___8 rng FStar_Pervasives_Native.None norm in
-            FStar_Syntax_Syntax.as_arg uu___7 in
-          let uu___7 =
-            let uu___8 =
-              let uu___9 =
-                let uu___10 = embed e_fsint vcfg.FStar_VConfig.max_ifuel in
-                uu___10 rng FStar_Pervasives_Native.None norm in
-              FStar_Syntax_Syntax.as_arg uu___9 in
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 = embed e_bool vcfg.FStar_VConfig.detail_errors in
-                  uu___12 rng FStar_Pervasives_Native.None norm in
-                FStar_Syntax_Syntax.as_arg uu___11 in
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 =
-                      embed e_bool vcfg.FStar_VConfig.detail_hint_replay in
-                    uu___14 rng FStar_Pervasives_Native.None norm in
-                  FStar_Syntax_Syntax.as_arg uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 =
-                      let uu___16 = embed e_bool vcfg.FStar_VConfig.no_smt in
-                      uu___16 rng FStar_Pervasives_Native.None norm in
-                    FStar_Syntax_Syntax.as_arg uu___15 in
-                  let uu___15 =
-                    let uu___16 =
-                      let uu___17 =
-                        let uu___18 =
-                          embed e_fsint vcfg.FStar_VConfig.quake_lo in
-                        uu___18 rng FStar_Pervasives_Native.None norm in
-                      FStar_Syntax_Syntax.as_arg uu___17 in
-                    let uu___17 =
-                      let uu___18 =
-                        let uu___19 =
-                          let uu___20 =
-                            embed e_fsint vcfg.FStar_VConfig.quake_hi in
-                          uu___20 rng FStar_Pervasives_Native.None norm in
-                        FStar_Syntax_Syntax.as_arg uu___19 in
-                      let uu___19 =
-                        let uu___20 =
-                          let uu___21 =
-                            let uu___22 =
-                              embed e_bool vcfg.FStar_VConfig.quake_keep in
-                            uu___22 rng FStar_Pervasives_Native.None norm in
-                          FStar_Syntax_Syntax.as_arg uu___21 in
-                        let uu___21 =
-                          let uu___22 =
-                            let uu___23 =
-                              let uu___24 =
-                                embed e_bool vcfg.FStar_VConfig.retry in
-                              uu___24 rng FStar_Pervasives_Native.None norm in
-                            FStar_Syntax_Syntax.as_arg uu___23 in
-                          let uu___23 =
-                            let uu___24 =
-                              let uu___25 =
-                                let uu___26 =
-                                  embed e_bool
-                                    vcfg.FStar_VConfig.smtencoding_elim_box in
-                                uu___26 rng FStar_Pervasives_Native.None norm in
-                              FStar_Syntax_Syntax.as_arg uu___25 in
-                            let uu___25 =
-                              let uu___26 =
-                                let uu___27 =
-                                  let uu___28 =
-                                    embed e_string
-                                      vcfg.FStar_VConfig.smtencoding_nl_arith_repr in
-                                  uu___28 rng FStar_Pervasives_Native.None
-                                    norm in
-                                FStar_Syntax_Syntax.as_arg uu___27 in
-                              let uu___27 =
-                                let uu___28 =
-                                  let uu___29 =
-                                    let uu___30 =
-                                      embed e_string
-                                        vcfg.FStar_VConfig.smtencoding_l_arith_repr in
-                                    uu___30 rng FStar_Pervasives_Native.None
-                                      norm in
-                                  FStar_Syntax_Syntax.as_arg uu___29 in
-                                let uu___29 =
-                                  let uu___30 =
-                                    let uu___31 =
-                                      let uu___32 =
-                                        embed e_bool
-                                          vcfg.FStar_VConfig.smtencoding_valid_intro in
-                                      uu___32 rng
-                                        FStar_Pervasives_Native.None norm in
-                                    FStar_Syntax_Syntax.as_arg uu___31 in
-                                  let uu___31 =
-                                    let uu___32 =
-                                      let uu___33 =
-                                        let uu___34 =
-                                          embed e_bool
-                                            vcfg.FStar_VConfig.smtencoding_valid_elim in
-                                        uu___34 rng
-                                          FStar_Pervasives_Native.None norm in
-                                      FStar_Syntax_Syntax.as_arg uu___33 in
-                                    let uu___33 =
-                                      let uu___34 =
-                                        let uu___35 =
-                                          let uu___36 =
-                                            embed e_bool
-                                              vcfg.FStar_VConfig.tcnorm in
-                                          uu___36 rng
-                                            FStar_Pervasives_Native.None norm in
-                                        FStar_Syntax_Syntax.as_arg uu___35 in
-                                      let uu___35 =
-                                        let uu___36 =
-                                          let uu___37 =
-                                            let uu___38 =
-                                              embed e_bool
-                                                vcfg.FStar_VConfig.no_plugins in
-                                            uu___38 rng
-                                              FStar_Pervasives_Native.None
-                                              norm in
-                                          FStar_Syntax_Syntax.as_arg uu___37 in
-                                        let uu___37 =
-                                          let uu___38 =
-                                            let uu___39 =
-                                              let uu___40 =
-                                                embed e_bool
-                                                  vcfg.FStar_VConfig.no_tactics in
-                                              uu___40 rng
-                                                FStar_Pervasives_Native.None
-                                                norm in
-                                            FStar_Syntax_Syntax.as_arg
-                                              uu___39 in
-                                          let uu___39 =
-                                            let uu___40 =
-                                              let uu___41 =
-                                                let uu___42 =
-                                                  let uu___43 =
-                                                    e_option e_string in
-                                                  embed uu___43
-                                                    vcfg.FStar_VConfig.vcgen_optimize_bind_as_seq in
-                                                uu___42 rng
-                                                  FStar_Pervasives_Native.None
-                                                  norm in
-                                              FStar_Syntax_Syntax.as_arg
-                                                uu___41 in
-                                            let uu___41 =
-                                              let uu___42 =
-                                                let uu___43 =
-                                                  let uu___44 =
-                                                    embed e_string_list
-                                                      vcfg.FStar_VConfig.z3cliopt in
-                                                  uu___44 rng
-                                                    FStar_Pervasives_Native.None
-                                                    norm in
-                                                FStar_Syntax_Syntax.as_arg
-                                                  uu___43 in
-                                              let uu___43 =
-                                                let uu___44 =
-                                                  let uu___45 =
-                                                    let uu___46 =
-                                                      embed e_string_list
-                                                        vcfg.FStar_VConfig.z3smtopt in
-                                                    uu___46 rng
-                                                      FStar_Pervasives_Native.None
-                                                      norm in
-                                                  FStar_Syntax_Syntax.as_arg
-                                                    uu___45 in
-                                                let uu___45 =
-                                                  let uu___46 =
-                                                    let uu___47 =
-                                                      let uu___48 =
-                                                        embed e_bool
-                                                          vcfg.FStar_VConfig.z3refresh in
-                                                      uu___48 rng
-                                                        FStar_Pervasives_Native.None
-                                                        norm in
-                                                    FStar_Syntax_Syntax.as_arg
-                                                      uu___47 in
-                                                  let uu___47 =
-                                                    let uu___48 =
-                                                      let uu___49 =
-                                                        let uu___50 =
-                                                          embed e_fsint
-                                                            vcfg.FStar_VConfig.z3rlimit in
-                                                        uu___50 rng
-                                                          FStar_Pervasives_Native.None
-                                                          norm in
-                                                      FStar_Syntax_Syntax.as_arg
-                                                        uu___49 in
-                                                    let uu___49 =
-                                                      let uu___50 =
-                                                        let uu___51 =
-                                                          let uu___52 =
-                                                            embed e_fsint
-                                                              vcfg.FStar_VConfig.z3rlimit_factor in
-                                                          uu___52 rng
-                                                            FStar_Pervasives_Native.None
-                                                            norm in
-                                                        FStar_Syntax_Syntax.as_arg
-                                                          uu___51 in
-                                                      let uu___51 =
-                                                        let uu___52 =
-                                                          let uu___53 =
-                                                            let uu___54 =
-                                                              embed e_fsint
-                                                                vcfg.FStar_VConfig.z3seed in
-                                                            uu___54 rng
-                                                              FStar_Pervasives_Native.None
-                                                              norm in
-                                                          FStar_Syntax_Syntax.as_arg
-                                                            uu___53 in
-                                                        let uu___53 =
-                                                          let uu___54 =
-                                                            let uu___55 =
-                                                              let uu___56 =
-                                                                embed e_bool
-                                                                  vcfg.FStar_VConfig.trivial_pre_for_unannotated_effectful_fns in
-                                                              uu___56 rng
-                                                                FStar_Pervasives_Native.None
-                                                                norm in
-                                                            FStar_Syntax_Syntax.as_arg
-                                                              uu___55 in
-                                                          let uu___55 =
-                                                            let uu___56 =
-                                                              let uu___57 =
-                                                                let uu___58 =
-                                                                  let uu___59
-                                                                    =
-                                                                    e_option
-                                                                    e_string in
-                                                                  embed
-                                                                    uu___59
-                                                                    vcfg.FStar_VConfig.reuse_hint_for in
-                                                                uu___58 rng
-                                                                  FStar_Pervasives_Native.None
-                                                                  norm in
-                                                              FStar_Syntax_Syntax.as_arg
-                                                                uu___57 in
-                                                            [uu___56] in
-                                                          uu___54 :: uu___55 in
-                                                        uu___52 :: uu___53 in
-                                                      uu___50 :: uu___51 in
-                                                    uu___48 :: uu___49 in
-                                                  uu___46 :: uu___47 in
-                                                uu___44 :: uu___45 in
-                                              uu___42 :: uu___43 in
-                                            uu___40 :: uu___41 in
-                                          uu___38 :: uu___39 in
-                                        uu___36 :: uu___37 in
-                                      uu___34 :: uu___35 in
-                                    uu___32 :: uu___33 in
-                                  uu___30 :: uu___31 in
-                                uu___28 :: uu___29 in
-                              uu___26 :: uu___27 in
-                            uu___24 :: uu___25 in
-                          uu___22 :: uu___23 in
-                        uu___20 :: uu___21 in
-                      uu___18 :: uu___19 in
-                    uu___16 :: uu___17 in
-                  uu___14 :: uu___15 in
-                uu___12 :: uu___13 in
-              uu___10 :: uu___11 in
-            uu___8 :: uu___9 in
-          uu___6 :: uu___7 in
-        uu___4 :: uu___5 in
-      uu___2 :: uu___3 in
-    FStar_Syntax_Syntax.mk_Tm_app uu___ uu___1 rng in
-  let un t0 w norm =
-    let t = FStar_Syntax_Util.unascribe t0 in
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Util.un_uinst hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            (initial_fuel, uu___2)::(max_fuel, uu___3)::(initial_ifuel,
-                                                         uu___4)::(max_ifuel,
-                                                                   uu___5)::
-            (detail_errors, uu___6)::(detail_hint_replay, uu___7)::(no_smt,
-                                                                    uu___8)::
-            (quake_lo, uu___9)::(quake_hi, uu___10)::(quake_keep, uu___11)::
-            (retry, uu___12)::(smtencoding_elim_box, uu___13)::(smtencoding_nl_arith_repr,
-                                                                uu___14)::
-            (smtencoding_l_arith_repr, uu___15)::(smtencoding_valid_intro,
-                                                  uu___16)::(smtencoding_valid_elim,
-                                                             uu___17)::
-            (tcnorm, uu___18)::(no_plugins, uu___19)::(no_tactics, uu___20)::
-            (vcgen_optimize_bind_as_seq, uu___21)::(z3cliopt, uu___22)::
-            (z3smtopt, uu___23)::(z3refresh, uu___24)::(z3rlimit, uu___25)::
-            (z3rlimit_factor, uu___26)::(z3seed, uu___27)::(trivial_pre_for_unannotated_effectful_fns,
-                                                            uu___28)::
-            (reuse_hint_for, uu___29)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Parser_Const.mkvconfig_lid
-             ->
-             let uu___30 =
-               let uu___31 = unembed e_fsint initial_fuel in uu___31 w norm in
-             FStar_Compiler_Util.bind_opt uu___30
-               (fun initial_fuel1 ->
-                  let uu___31 =
-                    let uu___32 = unembed e_fsint max_fuel in uu___32 w norm in
-                  FStar_Compiler_Util.bind_opt uu___31
-                    (fun max_fuel1 ->
-                       let uu___32 =
-                         let uu___33 = unembed e_fsint initial_ifuel in
-                         uu___33 w norm in
-                       FStar_Compiler_Util.bind_opt uu___32
-                         (fun initial_ifuel1 ->
-                            let uu___33 =
-                              let uu___34 = unembed e_fsint max_ifuel in
-                              uu___34 w norm in
-                            FStar_Compiler_Util.bind_opt uu___33
-                              (fun max_ifuel1 ->
-                                 let uu___34 =
-                                   let uu___35 = unembed e_bool detail_errors in
-                                   uu___35 w norm in
-                                 FStar_Compiler_Util.bind_opt uu___34
-                                   (fun detail_errors1 ->
-                                      let uu___35 =
-                                        let uu___36 =
-                                          unembed e_bool detail_hint_replay in
-                                        uu___36 w norm in
-                                      FStar_Compiler_Util.bind_opt uu___35
-                                        (fun detail_hint_replay1 ->
-                                           let uu___36 =
-                                             let uu___37 =
-                                               unembed e_bool no_smt in
-                                             uu___37 w norm in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___36
-                                             (fun no_smt1 ->
-                                                let uu___37 =
-                                                  let uu___38 =
-                                                    unembed e_fsint quake_lo in
-                                                  uu___38 w norm in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___37
-                                                  (fun quake_lo1 ->
-                                                     let uu___38 =
-                                                       let uu___39 =
-                                                         unembed e_fsint
-                                                           quake_hi in
-                                                       uu___39 w norm in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___38
-                                                       (fun quake_hi1 ->
-                                                          let uu___39 =
-                                                            let uu___40 =
-                                                              unembed e_bool
-                                                                quake_keep in
-                                                            uu___40 w norm in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___39
-                                                            (fun quake_keep1
-                                                               ->
-                                                               let uu___40 =
-                                                                 let uu___41
-                                                                   =
-                                                                   unembed
-                                                                    e_bool
-                                                                    retry in
-                                                                 uu___41 w
-                                                                   norm in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___40
-                                                                 (fun retry1
-                                                                    ->
-                                                                    let uu___41
-                                                                    =
-                                                                    let uu___42
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    smtencoding_elim_box in
-                                                                    uu___42 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___41
-                                                                    (fun
-                                                                    smtencoding_elim_box1
-                                                                    ->
-                                                                    let uu___42
-                                                                    =
-                                                                    let uu___43
-                                                                    =
-                                                                    unembed
-                                                                    e_string
-                                                                    smtencoding_nl_arith_repr in
-                                                                    uu___43 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___42
-                                                                    (fun
-                                                                    smtencoding_nl_arith_repr1
-                                                                    ->
-                                                                    let uu___43
-                                                                    =
-                                                                    let uu___44
-                                                                    =
-                                                                    unembed
-                                                                    e_string
-                                                                    smtencoding_l_arith_repr in
-                                                                    uu___44 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___43
-                                                                    (fun
-                                                                    smtencoding_l_arith_repr1
-                                                                    ->
-                                                                    let uu___44
-                                                                    =
-                                                                    let uu___45
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    smtencoding_valid_intro in
-                                                                    uu___45 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___44
-                                                                    (fun
-                                                                    smtencoding_valid_intro1
-                                                                    ->
-                                                                    let uu___45
-                                                                    =
-                                                                    let uu___46
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    smtencoding_valid_elim in
-                                                                    uu___46 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___45
-                                                                    (fun
-                                                                    smtencoding_valid_elim1
-                                                                    ->
-                                                                    let uu___46
-                                                                    =
-                                                                    let uu___47
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    tcnorm in
-                                                                    uu___47 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___46
-                                                                    (fun
-                                                                    tcnorm1
-                                                                    ->
-                                                                    let uu___47
-                                                                    =
-                                                                    let uu___48
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    no_plugins in
-                                                                    uu___48 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___47
-                                                                    (fun
-                                                                    no_plugins1
-                                                                    ->
-                                                                    let uu___48
-                                                                    =
-                                                                    let uu___49
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    no_tactics in
-                                                                    uu___49 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___48
-                                                                    (fun
-                                                                    no_tactics1
-                                                                    ->
-                                                                    let uu___49
-                                                                    =
-                                                                    let uu___50
-                                                                    =
-                                                                    let uu___51
-                                                                    =
-                                                                    e_option
-                                                                    e_string in
-                                                                    unembed
-                                                                    uu___51
-                                                                    vcgen_optimize_bind_as_seq in
-                                                                    uu___50 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___49
-                                                                    (fun
-                                                                    vcgen_optimize_bind_as_seq1
-                                                                    ->
-                                                                    let uu___50
-                                                                    =
-                                                                    let uu___51
-                                                                    =
-                                                                    unembed
-                                                                    e_string_list
-                                                                    z3cliopt in
-                                                                    uu___51 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___50
-                                                                    (fun
-                                                                    z3cliopt1
-                                                                    ->
-                                                                    let uu___51
-                                                                    =
-                                                                    let uu___52
-                                                                    =
-                                                                    unembed
-                                                                    e_string_list
-                                                                    z3smtopt in
-                                                                    uu___52 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___51
-                                                                    (fun
-                                                                    z3smtopt1
-                                                                    ->
-                                                                    let uu___52
-                                                                    =
-                                                                    let uu___53
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    z3refresh in
-                                                                    uu___53 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___52
-                                                                    (fun
-                                                                    z3refresh1
-                                                                    ->
-                                                                    let uu___53
-                                                                    =
-                                                                    let uu___54
-                                                                    =
-                                                                    unembed
-                                                                    e_fsint
-                                                                    z3rlimit in
-                                                                    uu___54 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___53
-                                                                    (fun
-                                                                    z3rlimit1
-                                                                    ->
-                                                                    let uu___54
-                                                                    =
-                                                                    let uu___55
-                                                                    =
-                                                                    unembed
-                                                                    e_fsint
-                                                                    z3rlimit_factor in
-                                                                    uu___55 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___54
-                                                                    (fun
-                                                                    z3rlimit_factor1
-                                                                    ->
-                                                                    let uu___55
-                                                                    =
-                                                                    let uu___56
-                                                                    =
-                                                                    unembed
-                                                                    e_fsint
-                                                                    z3seed in
-                                                                    uu___56 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___55
-                                                                    (fun
-                                                                    z3seed1
-                                                                    ->
-                                                                    let uu___56
-                                                                    =
-                                                                    let uu___57
-                                                                    =
-                                                                    unembed
-                                                                    e_bool
-                                                                    trivial_pre_for_unannotated_effectful_fns in
-                                                                    uu___57 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___56
-                                                                    (fun
-                                                                    trivial_pre_for_unannotated_effectful_fns1
-                                                                    ->
-                                                                    let uu___57
-                                                                    =
-                                                                    let uu___58
-                                                                    =
-                                                                    let uu___59
-                                                                    =
-                                                                    e_option
-                                                                    e_string in
-                                                                    unembed
-                                                                    uu___59
-                                                                    reuse_hint_for in
-                                                                    uu___58 w
-                                                                    norm in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___57
-                                                                    (fun
-                                                                    reuse_hint_for1
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    {
-                                                                    FStar_VConfig.initial_fuel
-                                                                    =
-                                                                    initial_fuel1;
-                                                                    FStar_VConfig.max_fuel
-                                                                    =
-                                                                    max_fuel1;
-                                                                    FStar_VConfig.initial_ifuel
-                                                                    =
-                                                                    initial_ifuel1;
-                                                                    FStar_VConfig.max_ifuel
-                                                                    =
-                                                                    max_ifuel1;
-                                                                    FStar_VConfig.detail_errors
-                                                                    =
-                                                                    detail_errors1;
-                                                                    FStar_VConfig.detail_hint_replay
-                                                                    =
-                                                                    detail_hint_replay1;
-                                                                    FStar_VConfig.no_smt
-                                                                    = no_smt1;
-                                                                    FStar_VConfig.quake_lo
-                                                                    =
-                                                                    quake_lo1;
-                                                                    FStar_VConfig.quake_hi
-                                                                    =
-                                                                    quake_hi1;
-                                                                    FStar_VConfig.quake_keep
-                                                                    =
-                                                                    quake_keep1;
-                                                                    FStar_VConfig.retry
-                                                                    = retry1;
-                                                                    FStar_VConfig.smtencoding_elim_box
-                                                                    =
-                                                                    smtencoding_elim_box1;
-                                                                    FStar_VConfig.smtencoding_nl_arith_repr
-                                                                    =
-                                                                    smtencoding_nl_arith_repr1;
-                                                                    FStar_VConfig.smtencoding_l_arith_repr
-                                                                    =
-                                                                    smtencoding_l_arith_repr1;
-                                                                    FStar_VConfig.smtencoding_valid_intro
-                                                                    =
-                                                                    smtencoding_valid_intro1;
-                                                                    FStar_VConfig.smtencoding_valid_elim
-                                                                    =
-                                                                    smtencoding_valid_elim1;
-                                                                    FStar_VConfig.tcnorm
-                                                                    = tcnorm1;
-                                                                    FStar_VConfig.no_plugins
-                                                                    =
-                                                                    no_plugins1;
-                                                                    FStar_VConfig.no_tactics
-                                                                    =
-                                                                    no_tactics1;
-                                                                    FStar_VConfig.vcgen_optimize_bind_as_seq
-                                                                    =
-                                                                    vcgen_optimize_bind_as_seq1;
-                                                                    FStar_VConfig.z3cliopt
-                                                                    =
-                                                                    z3cliopt1;
-                                                                    FStar_VConfig.z3smtopt
-                                                                    =
-                                                                    z3smtopt1;
-                                                                    FStar_VConfig.z3refresh
-                                                                    =
-                                                                    z3refresh1;
-                                                                    FStar_VConfig.z3rlimit
-                                                                    =
-                                                                    z3rlimit1;
-                                                                    FStar_VConfig.z3rlimit_factor
-                                                                    =
-                                                                    z3rlimit_factor1;
-                                                                    FStar_VConfig.z3seed
-                                                                    = z3seed1;
-                                                                    FStar_VConfig.trivial_pre_for_unannotated_effectful_fns
-                                                                    =
-                                                                    trivial_pre_for_unannotated_effectful_fns1;
-                                                                    FStar_VConfig.reuse_hint_for
-                                                                    =
-                                                                    reuse_hint_for1
-                                                                    }))))))))))))))))))))))))))))
-         | uu___2 ->
-             (if w
-              then
-                (let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t0 in
-                     FStar_Compiler_Util.format1
-                       "Not an embedded vconfig: %s" uu___6 in
-                   (FStar_Errors.Warning_NotEmbedded, uu___5) in
-                 FStar_Errors.log_issue t0.FStar_Syntax_Syntax.pos uu___4)
-              else ();
-              FStar_Pervasives_Native.None)) in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.vconfig_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  mk_emb_full em un FStar_Syntax_Syntax.t_vconfig (fun uu___1 -> "vconfig")
-    uu___
-let or_else : 'a . 'a FStar_Pervasives_Native.option -> (unit -> 'a) -> 'a =
-  fun f ->
-    fun g ->
-      match f with
-      | FStar_Pervasives_Native.Some x -> x
-      | FStar_Pervasives_Native.None -> g ()
-let e_arrow : 'a 'b . 'a embedding -> 'b embedding -> ('a -> 'b) embedding =
-  fun ea ->
-    fun eb ->
-      let t_arrow =
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Syntax.null_bv ea.typ in
-                FStar_Syntax_Syntax.mk_binder uu___4 in
-              [uu___3] in
-            let uu___3 = FStar_Syntax_Syntax.mk_Total eb.typ in
-            (uu___2, uu___3) in
-          FStar_Syntax_Syntax.Tm_arrow uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange in
-      let emb_t_arr_a_b =
-        FStar_Syntax_Syntax.ET_fun ((ea.emb_typ), (eb.emb_typ)) in
-      let printer1 f = "<fun>" in
-      let em f rng shadow_f norm =
-        lazy_embed (fun uu___ -> "<fun>") emb_t_arr_a_b rng t_arrow f
-          (fun uu___ ->
-             let uu___1 = force_shadow shadow_f in
-             match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Compiler_Effect.raise Embedding_failure
-             | FStar_Pervasives_Native.Some repr_f ->
-                 ((let uu___3 =
-                     FStar_Compiler_Effect.op_Bang
-                       FStar_Options.debug_embedding in
-                   if uu___3
-                   then
-                     let uu___4 = FStar_Syntax_Print.term_to_string repr_f in
-                     let uu___5 = FStar_Compiler_Util.stack_dump () in
-                     FStar_Compiler_Util.print2
-                       "e_arrow forced back to term using shadow %s; repr=%s\n"
-                       uu___4 uu___5
-                   else ());
-                  (let res = norm (FStar_Pervasives.Inr repr_f) in
-                   (let uu___4 =
-                      FStar_Compiler_Effect.op_Bang
-                        FStar_Options.debug_embedding in
-                    if uu___4
-                    then
-                      let uu___5 = FStar_Syntax_Print.term_to_string repr_f in
-                      let uu___6 = FStar_Syntax_Print.term_to_string res in
-                      let uu___7 = FStar_Compiler_Util.stack_dump () in
-                      FStar_Compiler_Util.print3
-                        "e_arrow forced back to term using shadow %s; repr=%s\n\t%s\n"
-                        uu___5 uu___6 uu___7
-                    else ());
-                   res))) in
-      let un f w norm =
-        lazy_unembed printer1 emb_t_arr_a_b f t_arrow
-          (fun f1 ->
-             let f_wrapped a1 =
-               (let uu___1 =
-                  FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-                if uu___1
-                then
-                  let uu___2 = FStar_Syntax_Print.term_to_string f1 in
-                  let uu___3 = FStar_Compiler_Util.stack_dump () in
-                  FStar_Compiler_Util.print2
-                    "Calling back into normalizer for %s\n%s\n" uu___2 uu___3
-                else ());
-               (let a_tm =
-                  let uu___1 = embed ea a1 in
-                  uu___1 f1.FStar_Syntax_Syntax.pos
-                    FStar_Pervasives_Native.None norm in
-                let b_tm =
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Syntax.as_arg a_tm in
-                        [uu___4] in
-                      FStar_Syntax_Syntax.mk_Tm_app f1 uu___3
-                        f1.FStar_Syntax_Syntax.pos in
-                    FStar_Pervasives.Inr uu___2 in
-                  norm uu___1 in
-                let uu___1 = let uu___2 = unembed eb b_tm in uu___2 w norm in
-                match uu___1 with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Compiler_Effect.raise Unembedding_failure
-                | FStar_Pervasives_Native.Some b1 -> b1) in
-             FStar_Pervasives_Native.Some f_wrapped) in
-      mk_emb_full em un t_arrow printer1 emb_t_arr_a_b
-let arrow_as_prim_step_1 :
-  'a 'b .
-    'a embedding ->
-      'b embedding ->
-        ('a -> 'b) ->
-          Prims.int ->
-            FStar_Ident.lid ->
-              norm_cb ->
-                FStar_Syntax_Syntax.args ->
-                  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun eb ->
-      fun f ->
-        fun n_tvars ->
-          fun fv_lid ->
-            fun norm ->
-              let rng = FStar_Ident.range_of_lid fv_lid in
-              let f_wrapped args =
-                let uu___ = FStar_Compiler_List.splitAt n_tvars args in
-                match uu___ with
-                | (_tvar_args, rest_args) ->
-                    let uu___1 = FStar_Compiler_List.hd rest_args in
-                    (match uu___1 with
-                     | (x, uu___2) ->
-                         let shadow_app =
-                           let uu___3 =
-                             FStar_Thunk.mk
-                               (fun uu___4 ->
-                                  let uu___5 =
-                                    norm (FStar_Pervasives.Inl fv_lid) in
-                                  FStar_Syntax_Syntax.mk_Tm_app uu___5 args
-                                    rng) in
-                           FStar_Pervasives_Native.Some uu___3 in
-                         let uu___3 =
-                           let uu___4 =
-                             let uu___5 = unembed ea x in uu___5 true norm in
-                           FStar_Compiler_Util.map_opt uu___4
-                             (fun x1 ->
-                                let uu___5 =
-                                  let uu___6 = f x1 in embed eb uu___6 in
-                                uu___5 rng shadow_app norm) in
-                         (match uu___3 with
-                          | FStar_Pervasives_Native.Some x1 ->
-                              FStar_Pervasives_Native.Some x1
-                          | FStar_Pervasives_Native.None ->
-                              force_shadow shadow_app)) in
-              f_wrapped
-let arrow_as_prim_step_2 :
-  'a 'b 'c .
-    'a embedding ->
-      'b embedding ->
-        'c embedding ->
-          ('a -> 'b -> 'c) ->
-            Prims.int ->
-              FStar_Ident.lid ->
-                norm_cb ->
-                  FStar_Syntax_Syntax.args ->
-                    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun eb ->
-      fun ec ->
-        fun f ->
-          fun n_tvars ->
-            fun fv_lid ->
-              fun norm ->
-                let rng = FStar_Ident.range_of_lid fv_lid in
-                let f_wrapped args =
-                  let uu___ = FStar_Compiler_List.splitAt n_tvars args in
-                  match uu___ with
-                  | (_tvar_args, rest_args) ->
-                      let uu___1 = FStar_Compiler_List.hd rest_args in
-                      (match uu___1 with
-                       | (x, uu___2) ->
-                           let uu___3 =
-                             let uu___4 = FStar_Compiler_List.tl rest_args in
-                             FStar_Compiler_List.hd uu___4 in
-                           (match uu___3 with
-                            | (y, uu___4) ->
-                                let shadow_app =
-                                  let uu___5 =
-                                    FStar_Thunk.mk
-                                      (fun uu___6 ->
-                                         let uu___7 =
-                                           norm (FStar_Pervasives.Inl fv_lid) in
-                                         FStar_Syntax_Syntax.mk_Tm_app uu___7
-                                           args rng) in
-                                  FStar_Pervasives_Native.Some uu___5 in
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 = unembed ea x in
-                                    uu___7 true norm in
-                                  FStar_Compiler_Util.bind_opt uu___6
-                                    (fun x1 ->
-                                       let uu___7 =
-                                         let uu___8 = unembed eb y in
-                                         uu___8 true norm in
-                                       FStar_Compiler_Util.bind_opt uu___7
-                                         (fun y1 ->
-                                            let uu___8 =
-                                              let uu___9 =
-                                                let uu___10 = f x1 y1 in
-                                                embed ec uu___10 in
-                                              uu___9 rng shadow_app norm in
-                                            FStar_Pervasives_Native.Some
-                                              uu___8)) in
-                                (match uu___5 with
-                                 | FStar_Pervasives_Native.Some x1 ->
-                                     FStar_Pervasives_Native.Some x1
-                                 | FStar_Pervasives_Native.None ->
-                                     force_shadow shadow_app))) in
-                f_wrapped
-let arrow_as_prim_step_3 :
-  'a 'b 'c 'd .
-    'a embedding ->
-      'b embedding ->
-        'c embedding ->
-          'd embedding ->
-            ('a -> 'b -> 'c -> 'd) ->
-              Prims.int ->
-                FStar_Ident.lid ->
-                  norm_cb ->
-                    FStar_Syntax_Syntax.args ->
-                      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun eb ->
-      fun ec ->
-        fun ed ->
-          fun f ->
-            fun n_tvars ->
-              fun fv_lid ->
-                fun norm ->
-                  let rng = FStar_Ident.range_of_lid fv_lid in
-                  let f_wrapped args =
-                    let uu___ = FStar_Compiler_List.splitAt n_tvars args in
-                    match uu___ with
-                    | (_tvar_args, rest_args) ->
-                        let uu___1 = FStar_Compiler_List.hd rest_args in
-                        (match uu___1 with
-                         | (x, uu___2) ->
-                             let uu___3 =
-                               let uu___4 = FStar_Compiler_List.tl rest_args in
-                               FStar_Compiler_List.hd uu___4 in
-                             (match uu___3 with
-                              | (y, uu___4) ->
-                                  let uu___5 =
-                                    let uu___6 =
-                                      let uu___7 =
-                                        FStar_Compiler_List.tl rest_args in
-                                      FStar_Compiler_List.tl uu___7 in
-                                    FStar_Compiler_List.hd uu___6 in
-                                  (match uu___5 with
-                                   | (z, uu___6) ->
-                                       let shadow_app =
-                                         let uu___7 =
-                                           FStar_Thunk.mk
-                                             (fun uu___8 ->
-                                                let uu___9 =
-                                                  norm
-                                                    (FStar_Pervasives.Inl
-                                                       fv_lid) in
-                                                FStar_Syntax_Syntax.mk_Tm_app
-                                                  uu___9 args rng) in
-                                         FStar_Pervasives_Native.Some uu___7 in
-                                       let uu___7 =
-                                         let uu___8 =
-                                           let uu___9 = unembed ea x in
-                                           uu___9 true norm in
-                                         FStar_Compiler_Util.bind_opt uu___8
-                                           (fun x1 ->
-                                              let uu___9 =
-                                                let uu___10 = unembed eb y in
-                                                uu___10 true norm in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___9
-                                                (fun y1 ->
-                                                   let uu___10 =
-                                                     let uu___11 =
-                                                       unembed ec z in
-                                                     uu___11 true norm in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___10
-                                                     (fun z1 ->
-                                                        let uu___11 =
-                                                          let uu___12 =
-                                                            let uu___13 =
-                                                              f x1 y1 z1 in
-                                                            embed ed uu___13 in
-                                                          uu___12 rng
-                                                            shadow_app norm in
-                                                        FStar_Pervasives_Native.Some
-                                                          uu___11))) in
-                                       (match uu___7 with
-                                        | FStar_Pervasives_Native.Some x1 ->
-                                            FStar_Pervasives_Native.Some x1
-                                        | FStar_Pervasives_Native.None ->
-                                            force_shadow shadow_app)))) in
-                  f_wrapped
-let debug_wrap : 'a . Prims.string -> (unit -> 'a) -> 'a =
-  fun s ->
-    fun f ->
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-       if uu___1
-       then FStar_Compiler_Util.print1 "++++starting %s\n" s
-       else ());
-      (let res = f () in
-       (let uu___2 =
-          FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-        if uu___2
-        then FStar_Compiler_Util.print1 "------ending %s\n" s
-        else ());
-       res)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Free.ml b/src/ocaml-output/FStar_Syntax_Free.ml
deleted file mode 100644
index b746e49a06c..00000000000
--- a/src/ocaml-output/FStar_Syntax_Free.ml
+++ /dev/null
@@ -1,582 +0,0 @@
-open Prims
-let (ctx_uvar_typ :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun u ->
-    let uu___ =
-      FStar_Syntax_Unionfind.find_decoration
-        u.FStar_Syntax_Syntax.ctx_uvar_head in
-    uu___.FStar_Syntax_Syntax.uvar_decoration_typ
-type use_cache_t =
-  | Def 
-  | NoCache 
-  | Full 
-let (uu___is_Def : use_cache_t -> Prims.bool) =
-  fun projectee -> match projectee with | Def -> true | uu___ -> false
-let (uu___is_NoCache : use_cache_t -> Prims.bool) =
-  fun projectee -> match projectee with | NoCache -> true | uu___ -> false
-let (uu___is_Full : use_cache_t -> Prims.bool) =
-  fun projectee -> match projectee with | Full -> true | uu___ -> false
-type free_vars_and_fvars =
-  (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-    FStar_Compiler_Util.set)
-let (no_free_vars :
-  (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-    FStar_Compiler_Util.set))
-  =
-  let uu___ = FStar_Syntax_Syntax.new_fv_set () in
-  ({
-     FStar_Syntax_Syntax.free_names = [];
-     FStar_Syntax_Syntax.free_uvars = [];
-     FStar_Syntax_Syntax.free_univs = [];
-     FStar_Syntax_Syntax.free_univ_names = []
-   }, uu___)
-let (singleton_fvar :
-  FStar_Syntax_Syntax.fv ->
-    (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-      FStar_Compiler_Util.set))
-  =
-  fun fv ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Syntax.new_fv_set () in
-      FStar_Compiler_Util.set_add
-        (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v uu___1 in
-    ((FStar_Pervasives_Native.fst no_free_vars), uu___)
-let (singleton_bv :
-  FStar_Syntax_Syntax.bv ->
-    (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-      FStar_Compiler_Util.set))
-  =
-  fun x ->
-    ((let uu___ = FStar_Pervasives_Native.fst no_free_vars in
-      {
-        FStar_Syntax_Syntax.free_names = [x];
-        FStar_Syntax_Syntax.free_uvars =
-          (uu___.FStar_Syntax_Syntax.free_uvars);
-        FStar_Syntax_Syntax.free_univs =
-          (uu___.FStar_Syntax_Syntax.free_univs);
-        FStar_Syntax_Syntax.free_univ_names =
-          (uu___.FStar_Syntax_Syntax.free_univ_names)
-      }), (FStar_Pervasives_Native.snd no_free_vars))
-let (singleton_uv :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-      FStar_Compiler_Util.set))
-  =
-  fun x ->
-    ((let uu___ = FStar_Pervasives_Native.fst no_free_vars in
-      {
-        FStar_Syntax_Syntax.free_names =
-          (uu___.FStar_Syntax_Syntax.free_names);
-        FStar_Syntax_Syntax.free_uvars = [x];
-        FStar_Syntax_Syntax.free_univs =
-          (uu___.FStar_Syntax_Syntax.free_univs);
-        FStar_Syntax_Syntax.free_univ_names =
-          (uu___.FStar_Syntax_Syntax.free_univ_names)
-      }), (FStar_Pervasives_Native.snd no_free_vars))
-let (singleton_univ :
-  FStar_Syntax_Syntax.universe_uvar ->
-    (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-      FStar_Compiler_Util.set))
-  =
-  fun x ->
-    ((let uu___ = FStar_Pervasives_Native.fst no_free_vars in
-      {
-        FStar_Syntax_Syntax.free_names =
-          (uu___.FStar_Syntax_Syntax.free_names);
-        FStar_Syntax_Syntax.free_uvars =
-          (uu___.FStar_Syntax_Syntax.free_uvars);
-        FStar_Syntax_Syntax.free_univs = [x];
-        FStar_Syntax_Syntax.free_univ_names =
-          (uu___.FStar_Syntax_Syntax.free_univ_names)
-      }), (FStar_Pervasives_Native.snd no_free_vars))
-let (singleton_univ_name :
-  FStar_Syntax_Syntax.univ_name ->
-    (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-      FStar_Compiler_Util.set))
-  =
-  fun x ->
-    ((let uu___ = FStar_Pervasives_Native.fst no_free_vars in
-      {
-        FStar_Syntax_Syntax.free_names =
-          (uu___.FStar_Syntax_Syntax.free_names);
-        FStar_Syntax_Syntax.free_uvars =
-          (uu___.FStar_Syntax_Syntax.free_uvars);
-        FStar_Syntax_Syntax.free_univs =
-          (uu___.FStar_Syntax_Syntax.free_univs);
-        FStar_Syntax_Syntax.free_univ_names = [x]
-      }), (FStar_Pervasives_Native.snd no_free_vars))
-let (union :
-  free_vars_and_fvars ->
-    free_vars_and_fvars ->
-      (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-        FStar_Compiler_Util.set))
-  =
-  fun f1 ->
-    fun f2 ->
-      let uu___ =
-        FStar_Compiler_Util.set_union (FStar_Pervasives_Native.snd f1)
-          (FStar_Pervasives_Native.snd f2) in
-      ({
-         FStar_Syntax_Syntax.free_names =
-           (FStar_Compiler_List.op_At
-              (FStar_Pervasives_Native.fst f1).FStar_Syntax_Syntax.free_names
-              (FStar_Pervasives_Native.fst f2).FStar_Syntax_Syntax.free_names);
-         FStar_Syntax_Syntax.free_uvars =
-           (FStar_Compiler_List.op_At
-              (FStar_Pervasives_Native.fst f1).FStar_Syntax_Syntax.free_uvars
-              (FStar_Pervasives_Native.fst f2).FStar_Syntax_Syntax.free_uvars);
-         FStar_Syntax_Syntax.free_univs =
-           (FStar_Compiler_List.op_At
-              (FStar_Pervasives_Native.fst f1).FStar_Syntax_Syntax.free_univs
-              (FStar_Pervasives_Native.fst f2).FStar_Syntax_Syntax.free_univs);
-         FStar_Syntax_Syntax.free_univ_names =
-           (FStar_Compiler_List.op_At
-              (FStar_Pervasives_Native.fst f1).FStar_Syntax_Syntax.free_univ_names
-              (FStar_Pervasives_Native.fst f2).FStar_Syntax_Syntax.free_univ_names)
-       }, uu___)
-let rec (free_univs : FStar_Syntax_Syntax.universe -> free_vars_and_fvars) =
-  fun u ->
-    let uu___ = FStar_Syntax_Subst.compress_univ u in
-    match uu___ with
-    | FStar_Syntax_Syntax.U_zero -> no_free_vars
-    | FStar_Syntax_Syntax.U_bvar uu___1 -> no_free_vars
-    | FStar_Syntax_Syntax.U_unknown -> no_free_vars
-    | FStar_Syntax_Syntax.U_name uname -> singleton_univ_name uname
-    | FStar_Syntax_Syntax.U_succ u1 -> free_univs u1
-    | FStar_Syntax_Syntax.U_max us ->
-        FStar_Compiler_List.fold_left
-          (fun out -> fun x -> let uu___1 = free_univs x in union out uu___1)
-          no_free_vars us
-    | FStar_Syntax_Syntax.U_unif u1 -> singleton_univ u1
-let rec (free_names_and_uvs' :
-  FStar_Syntax_Syntax.term -> use_cache_t -> free_vars_and_fvars) =
-  fun tm ->
-    fun use_cache ->
-      let aux_binders bs from_body =
-        let from_binders = free_names_and_uvars_binders bs use_cache in
-        union from_binders from_body in
-      let t = FStar_Syntax_Subst.compress tm in
-      match t.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_delayed uu___ -> failwith "Impossible"
-      | FStar_Syntax_Syntax.Tm_name x -> singleton_bv x
-      | FStar_Syntax_Syntax.Tm_uvar (uv, (s, uu___)) ->
-          let uu___1 =
-            if use_cache = Full
-            then
-              let uu___2 = ctx_uvar_typ uv in
-              free_names_and_uvars uu___2 use_cache
-            else no_free_vars in
-          union (singleton_uv uv) uu___1
-      | FStar_Syntax_Syntax.Tm_type u -> free_univs u
-      | FStar_Syntax_Syntax.Tm_bvar uu___ -> no_free_vars
-      | FStar_Syntax_Syntax.Tm_fvar fv -> singleton_fvar fv
-      | FStar_Syntax_Syntax.Tm_constant uu___ -> no_free_vars
-      | FStar_Syntax_Syntax.Tm_lazy uu___ -> no_free_vars
-      | FStar_Syntax_Syntax.Tm_unknown -> no_free_vars
-      | FStar_Syntax_Syntax.Tm_uinst (t1, us) ->
-          let f = free_names_and_uvars t1 use_cache in
-          FStar_Compiler_List.fold_left
-            (fun out -> fun u -> let uu___ = free_univs u in union out uu___)
-            f us
-      | FStar_Syntax_Syntax.Tm_abs (bs, t1, ropt) ->
-          let uu___ =
-            let uu___1 = free_names_and_uvars t1 use_cache in
-            aux_binders bs uu___1 in
-          let uu___1 =
-            match ropt with
-            | FStar_Pervasives_Native.Some
-                { FStar_Syntax_Syntax.residual_effect = uu___2;
-                  FStar_Syntax_Syntax.residual_typ =
-                    FStar_Pervasives_Native.Some t2;
-                  FStar_Syntax_Syntax.residual_flags = uu___3;_}
-                -> free_names_and_uvars t2 use_cache
-            | uu___2 -> no_free_vars in
-          union uu___ uu___1
-      | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-          let uu___ = free_names_and_uvars_comp c use_cache in
-          aux_binders bs uu___
-      | FStar_Syntax_Syntax.Tm_refine (bv, t1) ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.mk_binder bv in [uu___1] in
-          let uu___1 = free_names_and_uvars t1 use_cache in
-          aux_binders uu___ uu___1
-      | FStar_Syntax_Syntax.Tm_app (t1, args) ->
-          let uu___ = free_names_and_uvars t1 use_cache in
-          free_names_and_uvars_args args uu___ use_cache
-      | FStar_Syntax_Syntax.Tm_match (t1, asc_opt, pats, uu___) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = free_names_and_uvars t1 use_cache in
-              let uu___4 =
-                match asc_opt with
-                | FStar_Pervasives_Native.None -> no_free_vars
-                | FStar_Pervasives_Native.Some (b, asc) ->
-                    let uu___5 = free_names_and_uvars_binders [b] use_cache in
-                    let uu___6 =
-                      free_names_and_uvars_ascription asc use_cache in
-                    union uu___5 uu___6 in
-              union uu___3 uu___4 in
-            FStar_Compiler_List.fold_left
-              (fun n ->
-                 fun uu___3 ->
-                   match uu___3 with
-                   | (p, wopt, t2) ->
-                       let n1 =
-                         match wopt with
-                         | FStar_Pervasives_Native.None -> no_free_vars
-                         | FStar_Pervasives_Native.Some w ->
-                             free_names_and_uvars w use_cache in
-                       let n2 = free_names_and_uvars t2 use_cache in
-                       let n3 =
-                         let uu___4 = FStar_Syntax_Syntax.pat_bvs p in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___4
-                           (FStar_Compiler_List.fold_left
-                              (fun n4 ->
-                                 fun x ->
-                                   let uu___5 =
-                                     free_names_and_uvars
-                                       x.FStar_Syntax_Syntax.sort use_cache in
-                                   union n4 uu___5) n) in
-                       let uu___4 = union n1 n2 in union n3 uu___4) uu___2 in
-          FStar_Compiler_Effect.op_Bar_Greater pats uu___1
-      | FStar_Syntax_Syntax.Tm_ascribed (t1, asc, uu___) ->
-          let uu___1 = free_names_and_uvars t1 use_cache in
-          let uu___2 = free_names_and_uvars_ascription asc use_cache in
-          union uu___1 uu___2
-      | FStar_Syntax_Syntax.Tm_let (lbs, t1) ->
-          let uu___ =
-            let uu___1 = free_names_and_uvars t1 use_cache in
-            FStar_Compiler_List.fold_left
-              (fun n ->
-                 fun lb ->
-                   let uu___2 =
-                     let uu___3 =
-                       free_names_and_uvars lb.FStar_Syntax_Syntax.lbtyp
-                         use_cache in
-                     let uu___4 =
-                       free_names_and_uvars lb.FStar_Syntax_Syntax.lbdef
-                         use_cache in
-                     union uu___3 uu___4 in
-                   union n uu___2) uu___1 in
-          FStar_Compiler_Effect.op_Bar_Greater
-            (FStar_Pervasives_Native.snd lbs) uu___
-      | FStar_Syntax_Syntax.Tm_quoted (tm1, qi) ->
-          (match qi.FStar_Syntax_Syntax.qkind with
-           | FStar_Syntax_Syntax.Quote_static ->
-               FStar_Compiler_List.fold_left
-                 (fun n ->
-                    fun uu___ ->
-                      match uu___ with
-                      | (uu___1, t1) ->
-                          let uu___2 = free_names_and_uvars t1 use_cache in
-                          union n uu___2) no_free_vars
-                 qi.FStar_Syntax_Syntax.antiquotes
-           | FStar_Syntax_Syntax.Quote_dynamic ->
-               free_names_and_uvars tm1 use_cache)
-      | FStar_Syntax_Syntax.Tm_meta (t1, m) ->
-          let u1 = free_names_and_uvars t1 use_cache in
-          (match m with
-           | FStar_Syntax_Syntax.Meta_pattern (uu___, args) ->
-               FStar_Compiler_List.fold_right
-                 (fun a ->
-                    fun acc -> free_names_and_uvars_args a acc use_cache)
-                 args u1
-           | FStar_Syntax_Syntax.Meta_monadic (uu___, t') ->
-               let uu___1 = free_names_and_uvars t' use_cache in
-               union u1 uu___1
-           | FStar_Syntax_Syntax.Meta_monadic_lift (uu___, uu___1, t') ->
-               let uu___2 = free_names_and_uvars t' use_cache in
-               union u1 uu___2
-           | FStar_Syntax_Syntax.Meta_labeled uu___ -> u1
-           | FStar_Syntax_Syntax.Meta_desugared uu___ -> u1
-           | FStar_Syntax_Syntax.Meta_named uu___ -> u1)
-and (free_names_and_uvars_binders :
-  FStar_Syntax_Syntax.binders -> use_cache_t -> free_vars_and_fvars) =
-  fun bs ->
-    fun use_cache ->
-      FStar_Compiler_Effect.op_Bar_Greater bs
-        (FStar_Compiler_List.fold_left
-           (fun n ->
-              fun b ->
-                let uu___ =
-                  free_names_and_uvars
-                    (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                    use_cache in
-                union n uu___) no_free_vars)
-and (free_names_and_uvars_ascription :
-  ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-    FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-    -> use_cache_t -> free_vars_and_fvars)
-  =
-  fun asc ->
-    fun use_cache ->
-      let uu___ = asc in
-      match uu___ with
-      | (asc1, tacopt, uu___1) ->
-          let uu___2 =
-            match asc1 with
-            | FStar_Pervasives.Inl t -> free_names_and_uvars t use_cache
-            | FStar_Pervasives.Inr c -> free_names_and_uvars_comp c use_cache in
-          let uu___3 =
-            match tacopt with
-            | FStar_Pervasives_Native.None -> no_free_vars
-            | FStar_Pervasives_Native.Some tac ->
-                free_names_and_uvars tac use_cache in
-          union uu___2 uu___3
-and (free_names_and_uvars :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    use_cache_t -> free_vars_and_fvars)
-  =
-  fun t ->
-    fun use_cache ->
-      let t1 = FStar_Syntax_Subst.compress t in
-      let uu___ = FStar_Compiler_Effect.op_Bang t1.FStar_Syntax_Syntax.vars in
-      match uu___ with
-      | FStar_Pervasives_Native.Some n when
-          let uu___1 = should_invalidate_cache n use_cache in
-          Prims.op_Negation uu___1 ->
-          let uu___1 = FStar_Syntax_Syntax.new_fv_set () in (n, uu___1)
-      | uu___1 ->
-          (FStar_Compiler_Effect.op_Colon_Equals t1.FStar_Syntax_Syntax.vars
-             FStar_Pervasives_Native.None;
-           (let n = free_names_and_uvs' t1 use_cache in
-            if use_cache <> Full
-            then
-              FStar_Compiler_Effect.op_Colon_Equals
-                t1.FStar_Syntax_Syntax.vars
-                (FStar_Pervasives_Native.Some (FStar_Pervasives_Native.fst n))
-            else ();
-            n))
-and (free_names_and_uvars_args :
-  (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-    Prims.list ->
-    (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-      FStar_Compiler_Util.set) ->
-      use_cache_t ->
-        (FStar_Syntax_Syntax.free_vars * FStar_Ident.lident
-          FStar_Compiler_Util.set))
-  =
-  fun args ->
-    fun acc ->
-      fun use_cache ->
-        FStar_Compiler_Effect.op_Bar_Greater args
-          (FStar_Compiler_List.fold_left
-             (fun n ->
-                fun uu___ ->
-                  match uu___ with
-                  | (x, uu___1) ->
-                      let uu___2 = free_names_and_uvars x use_cache in
-                      union n uu___2) acc)
-and (free_names_and_uvars_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    use_cache_t -> free_vars_and_fvars)
-  =
-  fun c ->
-    fun use_cache ->
-      let uu___ = FStar_Compiler_Effect.op_Bang c.FStar_Syntax_Syntax.vars in
-      match uu___ with
-      | FStar_Pervasives_Native.Some n ->
-          let uu___1 = should_invalidate_cache n use_cache in
-          if uu___1
-          then
-            (FStar_Compiler_Effect.op_Colon_Equals c.FStar_Syntax_Syntax.vars
-               FStar_Pervasives_Native.None;
-             free_names_and_uvars_comp c use_cache)
-          else
-            (let uu___3 = FStar_Syntax_Syntax.new_fv_set () in (n, uu___3))
-      | uu___1 ->
-          let n =
-            match c.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.GTotal t ->
-                free_names_and_uvars t use_cache
-            | FStar_Syntax_Syntax.Total t -> free_names_and_uvars t use_cache
-            | FStar_Syntax_Syntax.Comp ct ->
-                let decreases_vars =
-                  let uu___2 =
-                    FStar_Compiler_List.tryFind
-                      (fun uu___3 ->
-                         match uu___3 with
-                         | FStar_Syntax_Syntax.DECREASES uu___4 -> true
-                         | uu___4 -> false) ct.FStar_Syntax_Syntax.flags in
-                  match uu___2 with
-                  | FStar_Pervasives_Native.None -> no_free_vars
-                  | FStar_Pervasives_Native.Some
-                      (FStar_Syntax_Syntax.DECREASES dec_order) ->
-                      free_names_and_uvars_dec_order dec_order use_cache in
-                let us =
-                  let uu___2 =
-                    free_names_and_uvars ct.FStar_Syntax_Syntax.result_typ
-                      use_cache in
-                  union uu___2 decreases_vars in
-                let us1 =
-                  free_names_and_uvars_args
-                    ct.FStar_Syntax_Syntax.effect_args us use_cache in
-                FStar_Compiler_List.fold_left
-                  (fun us2 ->
-                     fun u -> let uu___2 = free_univs u in union us2 uu___2)
-                  us1 ct.FStar_Syntax_Syntax.comp_univs in
-          (FStar_Compiler_Effect.op_Colon_Equals c.FStar_Syntax_Syntax.vars
-             (FStar_Pervasives_Native.Some (FStar_Pervasives_Native.fst n));
-           n)
-and (free_names_and_uvars_dec_order :
-  FStar_Syntax_Syntax.decreases_order -> use_cache_t -> free_vars_and_fvars)
-  =
-  fun dec_order ->
-    fun use_cache ->
-      match dec_order with
-      | FStar_Syntax_Syntax.Decreases_lex l ->
-          FStar_Compiler_Effect.op_Bar_Greater l
-            (FStar_Compiler_List.fold_left
-               (fun acc ->
-                  fun t ->
-                    let uu___ = free_names_and_uvars t use_cache in
-                    union acc uu___) no_free_vars)
-      | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-          let uu___ = free_names_and_uvars rel use_cache in
-          let uu___1 = free_names_and_uvars e use_cache in union uu___ uu___1
-and (should_invalidate_cache :
-  FStar_Syntax_Syntax.free_vars -> use_cache_t -> Prims.bool) =
-  fun n ->
-    fun use_cache ->
-      ((use_cache <> Def) ||
-         (FStar_Compiler_Effect.op_Bar_Greater
-            n.FStar_Syntax_Syntax.free_uvars
-            (FStar_Compiler_Util.for_some
-               (fun u ->
-                  let uu___ =
-                    FStar_Syntax_Unionfind.find
-                      u.FStar_Syntax_Syntax.ctx_uvar_head in
-                  match uu___ with
-                  | FStar_Pervasives_Native.Some uu___1 -> true
-                  | uu___1 -> false))))
-        ||
-        (FStar_Compiler_Effect.op_Bar_Greater
-           n.FStar_Syntax_Syntax.free_univs
-           (FStar_Compiler_Util.for_some
-              (fun u ->
-                 let uu___ = FStar_Syntax_Unionfind.univ_find u in
-                 match uu___ with
-                 | FStar_Pervasives_Native.Some uu___1 -> true
-                 | FStar_Pervasives_Native.None -> false)))
-let (compare_uv :
-  FStar_Syntax_Syntax.ctx_uvar -> FStar_Syntax_Syntax.ctx_uvar -> Prims.int)
-  =
-  fun uv1 ->
-    fun uv2 ->
-      let uu___ =
-        FStar_Syntax_Unionfind.uvar_id uv1.FStar_Syntax_Syntax.ctx_uvar_head in
-      let uu___1 =
-        FStar_Syntax_Unionfind.uvar_id uv2.FStar_Syntax_Syntax.ctx_uvar_head in
-      uu___ - uu___1
-let (new_uv_set : unit -> FStar_Syntax_Syntax.uvars) =
-  fun uu___ -> FStar_Compiler_Util.new_set compare_uv
-let (compare_universe_uvar :
-  FStar_Syntax_Syntax.universe_uvar ->
-    FStar_Syntax_Syntax.universe_uvar -> Prims.int)
-  =
-  fun x ->
-    fun y ->
-      let uu___ = FStar_Syntax_Unionfind.univ_uvar_id x in
-      let uu___1 = FStar_Syntax_Unionfind.univ_uvar_id y in uu___ - uu___1
-let (new_universe_uvar_set :
-  unit -> FStar_Syntax_Syntax.universe_uvar FStar_Compiler_Util.set) =
-  fun uu___ -> FStar_Compiler_Util.new_set compare_universe_uvar
-let (empty : FStar_Syntax_Syntax.bv FStar_Compiler_Util.set) =
-  FStar_Compiler_Util.new_set FStar_Syntax_Syntax.order_bv
-let (names :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.bv FStar_Compiler_Util.set)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars t Def in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_names in
-    FStar_Compiler_Util.as_set uu___ FStar_Syntax_Syntax.order_bv
-let (uvars :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars t Def in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_uvars in
-    FStar_Compiler_Util.as_set uu___ compare_uv
-let (univs :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.universe_uvar FStar_Compiler_Util.set)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars t Def in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_univs in
-    FStar_Compiler_Util.as_set uu___ compare_universe_uvar
-let (univnames :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.univ_name FStar_Compiler_Util.set)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars t Def in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_univ_names in
-    FStar_Compiler_Util.as_set uu___ FStar_Syntax_Syntax.order_univ_name
-let (univnames_comp :
-  FStar_Syntax_Syntax.comp ->
-    FStar_Syntax_Syntax.univ_name FStar_Compiler_Util.set)
-  =
-  fun c ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars_comp c Def in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_univ_names in
-    FStar_Compiler_Util.as_set uu___ FStar_Syntax_Syntax.order_univ_name
-let (fvars :
-  FStar_Syntax_Syntax.term -> FStar_Ident.lident FStar_Compiler_Util.set) =
-  fun t ->
-    let uu___ = free_names_and_uvars t NoCache in
-    FStar_Pervasives_Native.snd uu___
-let (names_of_binders :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.bv FStar_Compiler_Util.set)
-  =
-  fun bs ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars_binders bs Def in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_names in
-    FStar_Compiler_Util.as_set uu___ FStar_Syntax_Syntax.order_bv
-let (uvars_uncached :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars t NoCache in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_uvars in
-    FStar_Compiler_Util.as_set uu___ compare_uv
-let (uvars_full :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = free_names_and_uvars t Full in
-        FStar_Pervasives_Native.fst uu___2 in
-      uu___1.FStar_Syntax_Syntax.free_uvars in
-    FStar_Compiler_Util.as_set uu___ compare_uv
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Hash.ml b/src/ocaml-output/FStar_Syntax_Hash.ml
deleted file mode 100644
index 57dd69fd395..00000000000
--- a/src/ocaml-output/FStar_Syntax_Hash.ml
+++ /dev/null
@@ -1,1174 +0,0 @@
-open Prims
-type 't mm = Prims.bool -> ('t * Prims.bool)
-let op_let_Question : 's 't . 't mm -> ('t -> 's mm) -> 's mm =
-  fun f ->
-    fun g ->
-      fun b ->
-        let uu___ = f b in
-        match uu___ with | (t1, b1) -> let uu___1 = g t1 in uu___1 b1
-let ret : 't . 't -> 't mm = fun x -> fun b -> (x, b)
-let (should_memo : Prims.bool mm) = fun b -> (b, b)
-let (no_memo : unit mm) = fun uu___ -> ((), false)
-let maybe_memoize :
-  'a .
-    'a FStar_Syntax_Syntax.syntax ->
-      ('a FStar_Syntax_Syntax.syntax -> FStar_Hash.hash_code mm) ->
-        FStar_Hash.hash_code mm
-  =
-  fun h ->
-    fun f ->
-      fun should_memo1 ->
-        if should_memo1
-        then
-          let uu___ =
-            FStar_Compiler_Effect.op_Bang h.FStar_Syntax_Syntax.hash_code in
-          match uu___ with
-          | FStar_Pervasives_Native.Some c -> (c, should_memo1)
-          | FStar_Pervasives_Native.None ->
-              let uu___1 = let uu___2 = f h in uu___2 should_memo1 in
-              (match uu___1 with
-               | (c, should_memo2) ->
-                   (if should_memo2
-                    then
-                      FStar_Compiler_Effect.op_Colon_Equals
-                        h.FStar_Syntax_Syntax.hash_code
-                        (FStar_Pervasives_Native.Some c)
-                    else ();
-                    (c, should_memo2)))
-        else (let uu___1 = f h in uu___1 should_memo1)
-let (of_int : Prims.int -> FStar_Hash.hash_code mm) =
-  fun i -> let uu___ = FStar_Hash.of_int i in ret uu___
-let (of_string : Prims.string -> FStar_Hash.hash_code mm) =
-  fun s -> let uu___ = FStar_Hash.of_string s in ret uu___
-let (mix :
-  FStar_Hash.hash_code mm ->
-    FStar_Hash.hash_code mm -> FStar_Hash.hash_code mm)
-  =
-  fun f ->
-    fun g ->
-      fun b ->
-        let uu___ = f b in
-        match uu___ with
-        | (x, b0) ->
-            let uu___1 = g b in
-            (match uu___1 with
-             | (y, b1) ->
-                 let uu___2 = FStar_Hash.mix x y in (uu___2, (b0 && b1)))
-let (nil_hc : FStar_Hash.hash_code mm) = of_int (Prims.of_int (1229))
-let (cons_hc : FStar_Hash.hash_code mm) = of_int (Prims.of_int (1231))
-let (mix_list :
-  FStar_Hash.hash_code mm Prims.list -> FStar_Hash.hash_code mm) =
-  fun l -> FStar_Compiler_List.fold_right mix l nil_hc
-let (mix_list_lit :
-  FStar_Hash.hash_code mm Prims.list -> FStar_Hash.hash_code mm) = mix_list
-let hash_list :
-  'a .
-    ('a -> FStar_Hash.hash_code mm) ->
-      'a Prims.list -> FStar_Hash.hash_code mm
-  =
-  fun h ->
-    fun ts -> let uu___ = FStar_Compiler_List.map h ts in mix_list uu___
-let hash_option :
-  'a .
-    ('a -> FStar_Hash.hash_code mm) ->
-      'a FStar_Pervasives_Native.option -> FStar_Hash.hash_code mm
-  =
-  fun h ->
-    fun o ->
-      match o with
-      | FStar_Pervasives_Native.None ->
-          let uu___ = FStar_Hash.of_int (Prims.of_int (1237)) in ret uu___
-      | FStar_Pervasives_Native.Some o1 ->
-          let uu___ =
-            let uu___1 = FStar_Hash.of_int (Prims.of_int (1249)) in
-            ret uu___1 in
-          let uu___1 = h o1 in mix uu___ uu___1
-let hash_pair :
-  'a 'b .
-    ('a -> FStar_Hash.hash_code mm) ->
-      ('b -> FStar_Hash.hash_code mm) -> ('a * 'b) -> FStar_Hash.hash_code mm
-  =
-  fun h ->
-    fun i ->
-      fun x ->
-        let uu___ = h (FStar_Pervasives_Native.fst x) in
-        let uu___1 = i (FStar_Pervasives_Native.snd x) in mix uu___ uu___1
-let (hash_byte : FStar_BaseTypes.byte -> FStar_Hash.hash_code mm) =
-  fun b -> let uu___ = FStar_Hash.of_int (FStar_UInt8.v b) in ret uu___
-let rec (hash_term : FStar_Syntax_Syntax.term -> FStar_Hash.hash_code mm) =
-  fun t -> maybe_memoize t hash_term'
-and (hash_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Hash.hash_code mm)
-  = fun c -> maybe_memoize c hash_comp'
-and (hash_term' : FStar_Syntax_Syntax.term -> FStar_Hash.hash_code mm) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_bvar bv ->
-        let uu___1 = of_int (Prims.of_int (3)) in
-        let uu___2 = of_int bv.FStar_Syntax_Syntax.index in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_name bv ->
-        let uu___1 = of_int (Prims.of_int (5)) in
-        let uu___2 = of_int bv.FStar_Syntax_Syntax.index in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        let uu___1 = of_int (Prims.of_int (7)) in
-        let uu___2 = hash_fv fv in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_uinst (t1, us) ->
-        let uu___1 = of_int (Prims.of_int (11)) in
-        let uu___2 =
-          let uu___3 = hash_term t1 in
-          let uu___4 = hash_list hash_universe us in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_constant sc ->
-        let uu___1 = of_int (Prims.of_int (13)) in
-        let uu___2 = hash_constant sc in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_type u ->
-        let uu___1 = of_int (Prims.of_int (17)) in
-        let uu___2 = hash_universe u in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_abs (bs, t1, rcopt) ->
-        let uu___1 = of_int (Prims.of_int (19)) in
-        let uu___2 =
-          let uu___3 = hash_list hash_binder bs in
-          let uu___4 =
-            let uu___5 = hash_term t1 in
-            let uu___6 = hash_option hash_rc rcopt in mix uu___5 uu___6 in
-          mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-        let uu___1 = of_int (Prims.of_int (23)) in
-        let uu___2 =
-          let uu___3 = hash_list hash_binder bs in
-          let uu___4 = hash_comp c in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_refine (b, t1) ->
-        let uu___1 = of_int (Prims.of_int (29)) in
-        let uu___2 =
-          let uu___3 = hash_bv b in
-          let uu___4 = hash_term t1 in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_app (t1, args) ->
-        let uu___1 = of_int (Prims.of_int (31)) in
-        let uu___2 =
-          let uu___3 = hash_term t1 in
-          let uu___4 = hash_list hash_arg args in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_match (t1, asc_opt, branches, rcopt) ->
-        let uu___1 = of_int (Prims.of_int (37)) in
-        let uu___2 =
-          let uu___3 = hash_option hash_match_returns asc_opt in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 = hash_term t1 in
-              let uu___7 = hash_list hash_branch branches in
-              mix uu___6 uu___7 in
-            let uu___6 = hash_option hash_rc rcopt in mix uu___5 uu___6 in
-          mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, a, lopt) ->
-        let uu___1 = of_int (Prims.of_int (43)) in
-        let uu___2 =
-          let uu___3 = hash_term t1 in
-          let uu___4 =
-            let uu___5 = hash_ascription a in
-            let uu___6 = hash_option hash_lid lopt in mix uu___5 uu___6 in
-          mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), t1) ->
-        let uu___1 = of_int (Prims.of_int (47)) in
-        let uu___2 =
-          let uu___3 = hash_lb lb in
-          let uu___4 = hash_term t1 in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_let ((uu___1, lbs), t1) ->
-        let uu___2 = of_int (Prims.of_int (51)) in
-        let uu___3 =
-          let uu___4 = hash_list hash_lb lbs in
-          let uu___5 = hash_term t1 in mix uu___4 uu___5 in
-        mix uu___2 uu___3
-    | FStar_Syntax_Syntax.Tm_uvar uv ->
-        let uu___1 = of_int (Prims.of_int (53)) in
-        let uu___2 = hash_uvar uv in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_meta (t1, m) ->
-        let uu___1 = of_int (Prims.of_int (61)) in
-        let uu___2 =
-          let uu___3 = hash_term t1 in
-          let uu___4 = hash_meta m in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_lazy li ->
-        let uu___1 = of_int (Prims.of_int (67)) in
-        let uu___2 = hash_lazyinfo li in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_quoted (t1, qi) ->
-        let uu___1 = of_int (Prims.of_int (71)) in
-        let uu___2 =
-          let uu___3 = hash_term t1 in
-          let uu___4 = hash_quoteinfo qi in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_unknown -> of_int (Prims.of_int (73))
-    | FStar_Syntax_Syntax.Tm_delayed uu___1 -> failwith "Impossible"
-and (hash_comp' : FStar_Syntax_Syntax.comp -> FStar_Hash.hash_code mm) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (811)) in
-          let uu___2 = let uu___3 = hash_term t in [uu___3] in uu___1 ::
-            uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.GTotal t ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (821)) in
-          let uu___2 = let uu___3 = hash_term t in [uu___3] in uu___1 ::
-            uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.Comp ct ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (823)) in
-          let uu___2 =
-            let uu___3 =
-              hash_list hash_universe ct.FStar_Syntax_Syntax.comp_univs in
-            let uu___4 =
-              let uu___5 = hash_lid ct.FStar_Syntax_Syntax.effect_name in
-              let uu___6 =
-                let uu___7 = hash_term ct.FStar_Syntax_Syntax.result_typ in
-                let uu___8 =
-                  let uu___9 =
-                    hash_list hash_arg ct.FStar_Syntax_Syntax.effect_args in
-                  let uu___10 =
-                    let uu___11 =
-                      hash_list hash_flag ct.FStar_Syntax_Syntax.flags in
-                    [uu___11] in
-                  uu___9 :: uu___10 in
-                uu___7 :: uu___8 in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-and (hash_lb : FStar_Syntax_Syntax.letbinding -> FStar_Hash.hash_code mm) =
-  fun lb ->
-    let uu___ =
-      let uu___1 = of_int (Prims.of_int (79)) in
-      let uu___2 =
-        let uu___3 = hash_lbname lb.FStar_Syntax_Syntax.lbname in
-        let uu___4 =
-          let uu___5 = hash_list hash_ident lb.FStar_Syntax_Syntax.lbunivs in
-          let uu___6 =
-            let uu___7 = hash_term lb.FStar_Syntax_Syntax.lbtyp in
-            let uu___8 =
-              let uu___9 = hash_lid lb.FStar_Syntax_Syntax.lbeff in
-              let uu___10 =
-                let uu___11 = hash_term lb.FStar_Syntax_Syntax.lbdef in
-                let uu___12 =
-                  let uu___13 =
-                    hash_list hash_term lb.FStar_Syntax_Syntax.lbattrs in
-                  [uu___13] in
-                uu___11 :: uu___12 in
-              uu___9 :: uu___10 in
-            uu___7 :: uu___8 in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    mix_list_lit uu___
-and (hash_match_returns :
-  (FStar_Syntax_Syntax.binder *
-    ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-    FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool))
-    -> FStar_Hash.hash_code mm)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (b, asc) ->
-        let uu___1 = hash_binder b in
-        let uu___2 = hash_ascription asc in mix uu___1 uu___2
-and (hash_branch :
-  (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-    FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) -> FStar_Hash.hash_code mm)
-  =
-  fun b ->
-    let uu___ = b in
-    match uu___ with
-    | (p, topt, t) ->
-        let uu___1 =
-          let uu___2 = of_int (Prims.of_int (83)) in
-          let uu___3 =
-            let uu___4 = hash_pat p in
-            let uu___5 =
-              let uu___6 = hash_option hash_term topt in
-              let uu___7 = let uu___8 = hash_term t in [uu___8] in uu___6 ::
-                uu___7 in
-            uu___4 :: uu___5 in
-          uu___2 :: uu___3 in
-        mix_list_lit uu___1
-and (hash_pat :
-  FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t ->
-    FStar_Hash.hash_code mm)
-  =
-  fun p ->
-    match p.FStar_Syntax_Syntax.v with
-    | FStar_Syntax_Syntax.Pat_constant c ->
-        let uu___ = of_int (Prims.of_int (89)) in
-        let uu___1 = hash_constant c in mix uu___ uu___1
-    | FStar_Syntax_Syntax.Pat_cons (fv, us, args) ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (97)) in
-          let uu___2 =
-            let uu___3 = hash_fv fv in
-            let uu___4 =
-              let uu___5 = hash_option (hash_list hash_universe) us in
-              let uu___6 =
-                let uu___7 = hash_list (hash_pair hash_pat hash_bool) args in
-                [uu___7] in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.Pat_var bv ->
-        let uu___ = of_int (Prims.of_int (101)) in
-        let uu___1 = hash_bv bv in mix uu___ uu___1
-    | FStar_Syntax_Syntax.Pat_wild bv ->
-        let uu___ = of_int (Prims.of_int (103)) in
-        let uu___1 = hash_bv bv in mix uu___ uu___1
-    | FStar_Syntax_Syntax.Pat_dot_term t ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (107)) in
-          let uu___2 = let uu___3 = hash_option hash_term t in [uu___3] in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-and (hash_bv : FStar_Syntax_Syntax.bv -> FStar_Hash.hash_code mm) =
-  fun b -> hash_term b.FStar_Syntax_Syntax.sort
-and (hash_fv : FStar_Syntax_Syntax.fv -> FStar_Hash.hash_code mm) =
-  fun fv ->
-    let uu___ =
-      FStar_Ident.string_of_lid
-        (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-    of_string uu___
-and (hash_binder : FStar_Syntax_Syntax.binder -> FStar_Hash.hash_code mm) =
-  fun b ->
-    let uu___ =
-      let uu___1 = hash_bv b.FStar_Syntax_Syntax.binder_bv in
-      let uu___2 =
-        let uu___3 = hash_option hash_bqual b.FStar_Syntax_Syntax.binder_qual in
-        let uu___4 =
-          let uu___5 = hash_list hash_term b.FStar_Syntax_Syntax.binder_attrs in
-          [uu___5] in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    mix_list_lit uu___
-and (hash_universe : FStar_Syntax_Syntax.universe -> FStar_Hash.hash_code mm)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.U_zero -> of_int (Prims.of_int (179))
-    | FStar_Syntax_Syntax.U_succ u ->
-        let uu___1 = of_int (Prims.of_int (181)) in
-        let uu___2 = hash_universe u in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.U_max us ->
-        let uu___1 = of_int (Prims.of_int (191)) in
-        let uu___2 = hash_list hash_universe us in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.U_bvar i ->
-        let uu___1 = of_int (Prims.of_int (193)) in
-        let uu___2 = of_int i in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.U_name i ->
-        let uu___1 = of_int (Prims.of_int (197)) in
-        let uu___2 = hash_ident i in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.U_unif uv ->
-        let uu___1 = of_int (Prims.of_int (199)) in
-        let uu___2 = hash_universe_uvar uv in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.U_unknown -> of_int (Prims.of_int (211))
-and (hash_arg :
-  (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option) ->
-    FStar_Hash.hash_code mm)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (t, aq) ->
-        let uu___1 = hash_term t in
-        let uu___2 = hash_option hash_arg_qualifier aq in mix uu___1 uu___2
-and (hash_arg_qualifier :
-  FStar_Syntax_Syntax.arg_qualifier -> FStar_Hash.hash_code mm) =
-  fun aq ->
-    let uu___ = hash_bool aq.FStar_Syntax_Syntax.aqual_implicit in
-    let uu___1 = hash_list hash_term aq.FStar_Syntax_Syntax.aqual_attributes in
-    mix uu___ uu___1
-and (hash_bqual :
-  FStar_Syntax_Syntax.binder_qualifier -> FStar_Hash.hash_code mm) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Implicit (true) -> of_int (Prims.of_int (419))
-    | FStar_Syntax_Syntax.Implicit (false) -> of_int (Prims.of_int (421))
-    | FStar_Syntax_Syntax.Meta t ->
-        let uu___1 = of_int (Prims.of_int (431)) in
-        let uu___2 = hash_term t in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.Equality -> of_int (Prims.of_int (433))
-and (hash_uvar :
-  (FStar_Syntax_Syntax.ctx_uvar * (FStar_Syntax_Syntax.subst_elt Prims.list
-    Prims.list * FStar_Syntax_Syntax.maybe_set_use_range)) ->
-    FStar_Hash.hash_code mm)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (u, uu___1) ->
-        let uu___2 =
-          FStar_Syntax_Unionfind.uvar_id u.FStar_Syntax_Syntax.ctx_uvar_head in
-        of_int uu___2
-and (hash_universe_uvar :
-  (FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option
-    FStar_Unionfind.p_uvar * FStar_Syntax_Syntax.version *
-    FStar_Compiler_Range.range) -> FStar_Hash.hash_code mm)
-  =
-  fun u -> let uu___ = FStar_Syntax_Unionfind.univ_uvar_id u in of_int uu___
-and (hash_ascription :
-  ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-    FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-    -> FStar_Hash.hash_code mm)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (a, to1, b) ->
-        let uu___1 =
-          match a with
-          | FStar_Pervasives.Inl t -> hash_term t
-          | FStar_Pervasives.Inr c -> hash_comp c in
-        let uu___2 = hash_option hash_term to1 in mix uu___1 uu___2
-and (hash_bool : Prims.bool -> FStar_Hash.hash_code mm) =
-  fun b ->
-    if b then of_int (Prims.of_int (307)) else of_int (Prims.of_int (311))
-and (hash_constant : FStar_Syntax_Syntax.sconst -> FStar_Hash.hash_code mm) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Const.Const_effect -> of_int (Prims.of_int (283))
-    | FStar_Const.Const_unit -> of_int (Prims.of_int (293))
-    | FStar_Const.Const_bool b -> hash_bool b
-    | FStar_Const.Const_int (s, o) ->
-        let uu___1 = of_int (Prims.of_int (313)) in
-        let uu___2 =
-          let uu___3 = of_string s in
-          let uu___4 = hash_option hash_sw o in mix uu___3 uu___4 in
-        mix uu___1 uu___2
-    | FStar_Const.Const_char c ->
-        let uu___1 = of_int (Prims.of_int (317)) in
-        let uu___2 = of_int (FStar_UInt32.v (FStar_Char.u32_of_char c)) in
-        mix uu___1 uu___2
-    | FStar_Const.Const_real s ->
-        let uu___1 = of_int (Prims.of_int (337)) in
-        let uu___2 = of_string s in mix uu___1 uu___2
-    | FStar_Const.Const_string (s, uu___1) ->
-        let uu___2 = of_int (Prims.of_int (349)) in
-        let uu___3 = of_string s in mix uu___2 uu___3
-    | FStar_Const.Const_range_of -> of_int (Prims.of_int (353))
-    | FStar_Const.Const_set_range_of -> of_int (Prims.of_int (359))
-    | FStar_Const.Const_range r ->
-        let uu___1 = of_int (Prims.of_int (367)) in
-        let uu___2 =
-          let uu___3 = FStar_Compiler_Range.string_of_range r in
-          of_string uu___3 in
-        mix uu___1 uu___2
-    | FStar_Const.Const_reify -> of_int (Prims.of_int (367))
-    | FStar_Const.Const_reflect l ->
-        let uu___1 = of_int (Prims.of_int (373)) in
-        let uu___2 = hash_lid l in mix uu___1 uu___2
-and (hash_sw :
-  (FStar_Const.signedness * FStar_Const.width) -> FStar_Hash.hash_code mm) =
-  fun uu___ ->
-    match uu___ with
-    | (s, w) ->
-        let uu___1 =
-          match s with
-          | FStar_Const.Unsigned -> of_int (Prims.of_int (547))
-          | FStar_Const.Signed -> of_int (Prims.of_int (557)) in
-        let uu___2 =
-          match w with
-          | FStar_Const.Int8 -> of_int (Prims.of_int (563))
-          | FStar_Const.Int16 -> of_int (Prims.of_int (569))
-          | FStar_Const.Int32 -> of_int (Prims.of_int (571))
-          | FStar_Const.Int64 -> of_int (Prims.of_int (577))
-          | FStar_Const.Sizet -> of_int (Prims.of_int (583)) in
-        mix uu___1 uu___2
-and (hash_ident : FStar_Syntax_Syntax.univ_name -> FStar_Hash.hash_code mm) =
-  fun i -> let uu___ = FStar_Ident.string_of_id i in of_string uu___
-and (hash_lid : FStar_Ident.lident -> FStar_Hash.hash_code mm) =
-  fun l -> let uu___ = FStar_Ident.string_of_lid l in of_string uu___
-and (hash_lbname :
-  (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either ->
-    FStar_Hash.hash_code mm)
-  =
-  fun l ->
-    match l with
-    | FStar_Pervasives.Inl bv -> hash_bv bv
-    | FStar_Pervasives.Inr fv -> hash_fv fv
-and (hash_rc : FStar_Syntax_Syntax.residual_comp -> FStar_Hash.hash_code mm)
-  =
-  fun rc ->
-    let uu___ =
-      let uu___1 = hash_lid rc.FStar_Syntax_Syntax.residual_effect in
-      let uu___2 =
-        let uu___3 =
-          hash_option hash_term rc.FStar_Syntax_Syntax.residual_typ in
-        let uu___4 =
-          let uu___5 =
-            hash_list hash_flag rc.FStar_Syntax_Syntax.residual_flags in
-          [uu___5] in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    mix_list_lit uu___
-and (hash_flag : FStar_Syntax_Syntax.cflag -> FStar_Hash.hash_code mm) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.TOTAL -> of_int (Prims.of_int (947))
-    | FStar_Syntax_Syntax.MLEFFECT -> of_int (Prims.of_int (953))
-    | FStar_Syntax_Syntax.LEMMA -> of_int (Prims.of_int (967))
-    | FStar_Syntax_Syntax.RETURN -> of_int (Prims.of_int (971))
-    | FStar_Syntax_Syntax.PARTIAL_RETURN -> of_int (Prims.of_int (977))
-    | FStar_Syntax_Syntax.SOMETRIVIAL -> of_int (Prims.of_int (983))
-    | FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION ->
-        of_int (Prims.of_int (991))
-    | FStar_Syntax_Syntax.SHOULD_NOT_INLINE -> of_int (Prims.of_int (997))
-    | FStar_Syntax_Syntax.CPS -> of_int (Prims.of_int (1009))
-    | FStar_Syntax_Syntax.DECREASES (FStar_Syntax_Syntax.Decreases_lex ts) ->
-        let uu___1 = of_int (Prims.of_int (1013)) in
-        let uu___2 = hash_list hash_term ts in mix uu___1 uu___2
-    | FStar_Syntax_Syntax.DECREASES (FStar_Syntax_Syntax.Decreases_wf
-        (t0, t1)) ->
-        let uu___1 = of_int (Prims.of_int (2341)) in
-        let uu___2 = hash_list hash_term [t0; t1] in mix uu___1 uu___2
-and (hash_meta : FStar_Syntax_Syntax.metadata -> FStar_Hash.hash_code mm) =
-  fun m ->
-    match m with
-    | FStar_Syntax_Syntax.Meta_pattern (ts, args) ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (1019)) in
-          let uu___2 =
-            let uu___3 = hash_list hash_term ts in
-            let uu___4 =
-              let uu___5 = hash_list (hash_list hash_arg) args in [uu___5] in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.Meta_named l ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (1021)) in
-          let uu___2 = let uu___3 = hash_lid l in [uu___3] in uu___1 ::
-            uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.Meta_labeled (s, r, uu___) ->
-        let uu___1 =
-          let uu___2 = of_int (Prims.of_int (1031)) in
-          let uu___3 =
-            let uu___4 = of_string s in
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_Compiler_Range.string_of_range r in
-                of_string uu___7 in
-              [uu___6] in
-            uu___4 :: uu___5 in
-          uu___2 :: uu___3 in
-        mix_list_lit uu___1
-    | FStar_Syntax_Syntax.Meta_desugared msi ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (1033)) in
-          let uu___2 = let uu___3 = hash_meta_source_info msi in [uu___3] in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.Meta_monadic (m1, t) ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (1039)) in
-          let uu___2 =
-            let uu___3 = hash_lid m1 in
-            let uu___4 = let uu___5 = hash_term t in [uu___5] in uu___3 ::
-              uu___4 in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-    | FStar_Syntax_Syntax.Meta_monadic_lift (m0, m1, t) ->
-        let uu___ =
-          let uu___1 = of_int (Prims.of_int (1069)) in
-          let uu___2 =
-            let uu___3 = hash_lid m0 in
-            let uu___4 =
-              let uu___5 = hash_lid m1 in
-              let uu___6 = let uu___7 = hash_term t in [uu___7] in uu___5 ::
-                uu___6 in
-            uu___3 :: uu___4 in
-          uu___1 :: uu___2 in
-        mix_list_lit uu___
-and (hash_meta_source_info :
-  FStar_Syntax_Syntax.meta_source_info -> FStar_Hash.hash_code mm) =
-  fun m ->
-    match m with
-    | FStar_Syntax_Syntax.Sequence -> of_int (Prims.of_int (1049))
-    | FStar_Syntax_Syntax.Primop -> of_int (Prims.of_int (1051))
-    | FStar_Syntax_Syntax.Masked_effect -> of_int (Prims.of_int (1061))
-    | FStar_Syntax_Syntax.Meta_smt_pat -> of_int (Prims.of_int (1063))
-    | FStar_Syntax_Syntax.Machine_integer sw ->
-        let uu___ = of_int (Prims.of_int (1069)) in
-        let uu___1 = hash_sw sw in mix uu___ uu___1
-and (hash_lazyinfo : FStar_Syntax_Syntax.lazyinfo -> FStar_Hash.hash_code mm)
-  = fun li -> of_int Prims.int_zero
-and (hash_quoteinfo :
-  FStar_Syntax_Syntax.quoteinfo -> FStar_Hash.hash_code mm) =
-  fun qi ->
-    let uu___ =
-      hash_bool
-        (qi.FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_static) in
-    let uu___1 =
-      hash_list (hash_pair hash_bv hash_term)
-        qi.FStar_Syntax_Syntax.antiquotes in
-    mix uu___ uu___1
-let rec equal_list :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu -> 'uuuuu1 -> Prims.bool) ->
-      'uuuuu Prims.list -> 'uuuuu1 Prims.list -> Prims.bool
-  =
-  fun f ->
-    fun l1 ->
-      fun l2 ->
-        match (l1, l2) with
-        | ([], []) -> true
-        | (h1::t1, h2::t2) -> (f h1 h2) && (equal_list f t1 t2)
-        | uu___ -> false
-let equal_opt :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu -> 'uuuuu1 -> Prims.bool) ->
-      'uuuuu FStar_Pervasives_Native.option ->
-        'uuuuu1 FStar_Pervasives_Native.option -> Prims.bool
-  =
-  fun f ->
-    fun o1 ->
-      fun o2 ->
-        match (o1, o2) with
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-            true
-        | (FStar_Pervasives_Native.Some a, FStar_Pervasives_Native.Some b) ->
-            f a b
-        | uu___ -> false
-let equal_pair :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 .
-    ('uuuuu -> 'uuuuu1 -> Prims.bool) ->
-      ('uuuuu2 -> 'uuuuu3 -> Prims.bool) ->
-        ('uuuuu * 'uuuuu2) -> ('uuuuu1 * 'uuuuu3) -> Prims.bool
-  =
-  fun f ->
-    fun g ->
-      fun uu___ ->
-        fun uu___1 ->
-          match (uu___, uu___1) with
-          | ((x1, y1), (x2, y2)) -> (f x1 x2) && (g y1 y2)
-let equal_poly : 'uuuuu . 'uuuuu -> 'uuuuu -> Prims.bool =
-  fun x -> fun y -> x = y
-let (ext_hash_term : FStar_Syntax_Syntax.term -> FStar_Hash.hash_code) =
-  fun t ->
-    let uu___ = let uu___1 = hash_term t in uu___1 true in
-    FStar_Pervasives_Native.fst uu___
-let (ext_hash_term_no_memo :
-  FStar_Syntax_Syntax.term -> FStar_Hash.hash_code) =
-  fun t ->
-    let uu___ = let uu___1 = hash_term t in uu___1 false in
-    FStar_Pervasives_Native.fst uu___
-let rec (equal_term :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t1 ->
-    fun t2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality t1 t2 in
-      if uu___
-      then true
-      else
-        (let uu___2 =
-           FStar_Compiler_Util.physical_equality t1.FStar_Syntax_Syntax.n
-             t2.FStar_Syntax_Syntax.n in
-         if uu___2
-         then true
-         else
-           (let uu___4 =
-              let uu___5 = ext_hash_term t1 in
-              let uu___6 = ext_hash_term t2 in uu___5 <> uu___6 in
-            if uu___4
-            then false
-            else
-              (let uu___6 =
-                 let uu___7 =
-                   let uu___8 = FStar_Syntax_Subst.compress t1 in
-                   uu___8.FStar_Syntax_Syntax.n in
-                 let uu___8 =
-                   let uu___9 = FStar_Syntax_Subst.compress t2 in
-                   uu___9.FStar_Syntax_Syntax.n in
-                 (uu___7, uu___8) in
-               match uu___6 with
-               | (FStar_Syntax_Syntax.Tm_bvar x, FStar_Syntax_Syntax.Tm_bvar
-                  y) ->
-                   x.FStar_Syntax_Syntax.index = y.FStar_Syntax_Syntax.index
-               | (FStar_Syntax_Syntax.Tm_name x, FStar_Syntax_Syntax.Tm_name
-                  y) ->
-                   x.FStar_Syntax_Syntax.index = y.FStar_Syntax_Syntax.index
-               | (FStar_Syntax_Syntax.Tm_fvar f, FStar_Syntax_Syntax.Tm_fvar
-                  g) -> equal_fv f g
-               | (FStar_Syntax_Syntax.Tm_uinst (t11, u1),
-                  FStar_Syntax_Syntax.Tm_uinst (t21, u2)) ->
-                   (equal_term t11 t21) && (equal_list equal_universe u1 u2)
-               | (FStar_Syntax_Syntax.Tm_constant c1,
-                  FStar_Syntax_Syntax.Tm_constant c2) -> equal_constant c1 c2
-               | (FStar_Syntax_Syntax.Tm_type u1, FStar_Syntax_Syntax.Tm_type
-                  u2) -> equal_universe u1 u2
-               | (FStar_Syntax_Syntax.Tm_abs (bs1, t11, rc1),
-                  FStar_Syntax_Syntax.Tm_abs (bs2, t21, rc2)) ->
-                   ((equal_list equal_binder bs1 bs2) && (equal_term t11 t21))
-                     && (equal_opt equal_rc rc1 rc2)
-               | (FStar_Syntax_Syntax.Tm_arrow (bs1, c1),
-                  FStar_Syntax_Syntax.Tm_arrow (bs2, c2)) ->
-                   (equal_list equal_binder bs1 bs2) && (equal_comp c1 c2)
-               | (FStar_Syntax_Syntax.Tm_refine (b1, t11),
-                  FStar_Syntax_Syntax.Tm_refine (b2, t21)) ->
-                   (equal_bv b1 b2) && (equal_term t11 t21)
-               | (FStar_Syntax_Syntax.Tm_app (t11, as1),
-                  FStar_Syntax_Syntax.Tm_app (t21, as2)) ->
-                   (equal_term t11 t21) && (equal_list equal_arg as1 as2)
-               | (FStar_Syntax_Syntax.Tm_match (t11, asc_opt1, bs1, ropt1),
-                  FStar_Syntax_Syntax.Tm_match (t21, asc_opt2, bs2, ropt2))
-                   ->
-                   (((equal_term t11 t21) &&
-                       (equal_opt equal_match_returns asc_opt1 asc_opt2))
-                      && (equal_list equal_branch bs1 bs2))
-                     && (equal_opt equal_rc ropt1 ropt2)
-               | (FStar_Syntax_Syntax.Tm_ascribed (t11, a1, l1),
-                  FStar_Syntax_Syntax.Tm_ascribed (t21, a2, l2)) ->
-                   ((equal_term t11 t21) && (equal_ascription a1 a2)) &&
-                     (equal_opt FStar_Ident.lid_equals l1 l2)
-               | (FStar_Syntax_Syntax.Tm_let ((r1, lbs1), t11),
-                  FStar_Syntax_Syntax.Tm_let ((r2, lbs2), t21)) ->
-                   ((r1 = r2) && (equal_list equal_letbinding lbs1 lbs2)) &&
-                     (equal_term t11 t21)
-               | (FStar_Syntax_Syntax.Tm_uvar u1, FStar_Syntax_Syntax.Tm_uvar
-                  u2) -> equal_uvar u1 u2
-               | (FStar_Syntax_Syntax.Tm_meta (t11, m1),
-                  FStar_Syntax_Syntax.Tm_meta (t21, m2)) ->
-                   (equal_term t11 t21) && (equal_meta m1 m2)
-               | (FStar_Syntax_Syntax.Tm_lazy l1, FStar_Syntax_Syntax.Tm_lazy
-                  l2) -> equal_lazyinfo l1 l2
-               | (FStar_Syntax_Syntax.Tm_quoted (t11, q1),
-                  FStar_Syntax_Syntax.Tm_quoted (t21, q2)) ->
-                   (equal_term t11 t21) && (equal_quoteinfo q1 q2)
-               | (FStar_Syntax_Syntax.Tm_unknown,
-                  FStar_Syntax_Syntax.Tm_unknown) -> true
-               | uu___7 -> false)))
-and (equal_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool)
-  =
-  fun c1 ->
-    fun c2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality c1 c2 in
-      if uu___
-      then true
-      else
-        (match ((c1.FStar_Syntax_Syntax.n), (c2.FStar_Syntax_Syntax.n)) with
-         | (FStar_Syntax_Syntax.Total t1, FStar_Syntax_Syntax.Total t2) ->
-             equal_term t1 t2
-         | (FStar_Syntax_Syntax.GTotal t1, FStar_Syntax_Syntax.GTotal t2) ->
-             equal_term t1 t2
-         | (FStar_Syntax_Syntax.Comp ct1, FStar_Syntax_Syntax.Comp ct2) ->
-             ((((FStar_Ident.lid_equals ct1.FStar_Syntax_Syntax.effect_name
-                   ct2.FStar_Syntax_Syntax.effect_name)
-                  &&
-                  (equal_list equal_universe
-                     ct1.FStar_Syntax_Syntax.comp_univs
-                     ct2.FStar_Syntax_Syntax.comp_univs))
-                 &&
-                 (equal_term ct1.FStar_Syntax_Syntax.result_typ
-                    ct2.FStar_Syntax_Syntax.result_typ))
-                &&
-                (equal_list equal_arg ct1.FStar_Syntax_Syntax.effect_args
-                   ct2.FStar_Syntax_Syntax.effect_args))
-               &&
-               (equal_list equal_flag ct1.FStar_Syntax_Syntax.flags
-                  ct2.FStar_Syntax_Syntax.flags))
-and (equal_binder :
-  FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder -> Prims.bool) =
-  fun b1 ->
-    fun b2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality b1 b2 in
-      if uu___
-      then true
-      else
-        ((equal_bv b1.FStar_Syntax_Syntax.binder_bv
-            b2.FStar_Syntax_Syntax.binder_bv)
-           &&
-           (equal_bqual b1.FStar_Syntax_Syntax.binder_qual
-              b2.FStar_Syntax_Syntax.binder_qual))
-          &&
-          (equal_list equal_term b1.FStar_Syntax_Syntax.binder_attrs
-             b2.FStar_Syntax_Syntax.binder_attrs)
-and (equal_match_returns :
-  (FStar_Syntax_Syntax.binder *
-    ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-    FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool))
-    ->
-    (FStar_Syntax_Syntax.binder *
-      ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-      FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-      Prims.bool)) -> Prims.bool)
-  =
-  fun uu___ ->
-    fun uu___1 ->
-      match (uu___, uu___1) with
-      | ((b1, asc1), (b2, asc2)) ->
-          (equal_binder b1 b2) && (equal_ascription asc1 asc2)
-and (equal_ascription :
-  ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-    FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-    ->
-    ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-      FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-      -> Prims.bool)
-  =
-  fun x1 ->
-    fun x2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality x1 x2 in
-      if uu___
-      then true
-      else
-        (let uu___2 = x1 in
-         match uu___2 with
-         | (a1, t1, b1) ->
-             let uu___3 = x2 in
-             (match uu___3 with
-              | (a2, t2, b2) ->
-                  ((match (a1, a2) with
-                    | (FStar_Pervasives.Inl t11, FStar_Pervasives.Inl t21) ->
-                        equal_term t11 t21
-                    | (FStar_Pervasives.Inr c1, FStar_Pervasives.Inr c2) ->
-                        equal_comp c1 c2
-                    | uu___4 -> false) && (equal_opt equal_term t1 t2)) &&
-                    (b1 = b2)))
-and (equal_letbinding :
-  FStar_Syntax_Syntax.letbinding ->
-    FStar_Syntax_Syntax.letbinding -> Prims.bool)
-  =
-  fun l1 ->
-    fun l2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality l1 l2 in
-      if uu___
-      then true
-      else
-        (((((equal_lbname l1.FStar_Syntax_Syntax.lbname
-               l2.FStar_Syntax_Syntax.lbname)
-              &&
-              (equal_list FStar_Ident.ident_equals
-                 l1.FStar_Syntax_Syntax.lbunivs
-                 l2.FStar_Syntax_Syntax.lbunivs))
-             &&
-             (equal_term l1.FStar_Syntax_Syntax.lbtyp
-                l2.FStar_Syntax_Syntax.lbtyp))
-            &&
-            (FStar_Ident.lid_equals l1.FStar_Syntax_Syntax.lbeff
-               l2.FStar_Syntax_Syntax.lbeff))
-           &&
-           (equal_term l1.FStar_Syntax_Syntax.lbdef
-              l2.FStar_Syntax_Syntax.lbdef))
-          &&
-          (equal_list equal_term l1.FStar_Syntax_Syntax.lbattrs
-             l2.FStar_Syntax_Syntax.lbattrs)
-and (equal_uvar :
-  (FStar_Syntax_Syntax.ctx_uvar * (FStar_Syntax_Syntax.subst_elt Prims.list
-    Prims.list * FStar_Syntax_Syntax.maybe_set_use_range)) ->
-    (FStar_Syntax_Syntax.ctx_uvar * (FStar_Syntax_Syntax.subst_elt Prims.list
-      Prims.list * FStar_Syntax_Syntax.maybe_set_use_range)) -> Prims.bool)
-  =
-  fun uu___ ->
-    fun uu___1 ->
-      match (uu___, uu___1) with
-      | ((u1, (s1, uu___2)), (u2, (s2, uu___3))) ->
-          (FStar_Syntax_Unionfind.equiv u1.FStar_Syntax_Syntax.ctx_uvar_head
-             u2.FStar_Syntax_Syntax.ctx_uvar_head)
-            && (equal_list (equal_list equal_subst_elt) s1 s2)
-and (equal_bv :
-  FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.bv -> Prims.bool) =
-  fun b1 ->
-    fun b2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality b1 b2 in
-      if uu___
-      then true
-      else
-        (FStar_Ident.ident_equals b1.FStar_Syntax_Syntax.ppname
-           b2.FStar_Syntax_Syntax.ppname)
-          &&
-          (equal_term b1.FStar_Syntax_Syntax.sort b2.FStar_Syntax_Syntax.sort)
-and (equal_fv :
-  FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun f1 ->
-    fun f2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality f1 f2 in
-      if uu___
-      then true
-      else
-        FStar_Ident.lid_equals
-          (f1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-          (f2.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-and (equal_universe :
-  FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe -> Prims.bool)
-  =
-  fun u1 ->
-    fun u2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality u1 u2 in
-      if uu___
-      then true
-      else
-        (let uu___2 =
-           let uu___3 = FStar_Syntax_Subst.compress_univ u1 in
-           let uu___4 = FStar_Syntax_Subst.compress_univ u2 in
-           (uu___3, uu___4) in
-         match uu___2 with
-         | (FStar_Syntax_Syntax.U_zero, FStar_Syntax_Syntax.U_zero) -> true
-         | (FStar_Syntax_Syntax.U_succ u11, FStar_Syntax_Syntax.U_succ u21)
-             -> equal_universe u11 u21
-         | (FStar_Syntax_Syntax.U_max us1, FStar_Syntax_Syntax.U_max us2) ->
-             equal_list equal_universe us1 us2
-         | (FStar_Syntax_Syntax.U_bvar i1, FStar_Syntax_Syntax.U_bvar i2) ->
-             i1 = i2
-         | (FStar_Syntax_Syntax.U_name x1, FStar_Syntax_Syntax.U_name x2) ->
-             FStar_Ident.ident_equals x1 x2
-         | (FStar_Syntax_Syntax.U_unif u11, FStar_Syntax_Syntax.U_unif u21)
-             -> FStar_Syntax_Unionfind.univ_equiv u11 u21
-         | (FStar_Syntax_Syntax.U_unknown, FStar_Syntax_Syntax.U_unknown) ->
-             true
-         | uu___3 -> false)
-and (equal_constant :
-  FStar_Syntax_Syntax.sconst -> FStar_Syntax_Syntax.sconst -> Prims.bool) =
-  fun c1 ->
-    fun c2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality c1 c2 in
-      if uu___
-      then true
-      else
-        (match (c1, c2) with
-         | (FStar_Const.Const_effect, FStar_Const.Const_effect) -> true
-         | (FStar_Const.Const_unit, FStar_Const.Const_unit) -> true
-         | (FStar_Const.Const_bool b1, FStar_Const.Const_bool b2) -> b1 = b2
-         | (FStar_Const.Const_int (s1, o1), FStar_Const.Const_int (s2, o2))
-             -> (s1 = s2) && (o1 = o2)
-         | (FStar_Const.Const_char c11, FStar_Const.Const_char c21) ->
-             c11 = c21
-         | (FStar_Const.Const_real s1, FStar_Const.Const_real s2) -> s1 = s2
-         | (FStar_Const.Const_string (s1, uu___2), FStar_Const.Const_string
-            (s2, uu___3)) -> s1 = s2
-         | (FStar_Const.Const_range_of, FStar_Const.Const_range_of) -> true
-         | (FStar_Const.Const_set_range_of, FStar_Const.Const_set_range_of)
-             -> true
-         | (FStar_Const.Const_range r1, FStar_Const.Const_range r2) ->
-             let uu___2 = FStar_Compiler_Range.compare r1 r2 in
-             uu___2 = Prims.int_zero
-         | (FStar_Const.Const_reify, FStar_Const.Const_reify) -> true
-         | (FStar_Const.Const_reflect l1, FStar_Const.Const_reflect l2) ->
-             FStar_Ident.lid_equals l1 l2
-         | uu___2 -> false)
-and (equal_arg :
-  (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option) ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option) ->
-      Prims.bool)
-  =
-  fun arg1 ->
-    fun arg2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality arg1 arg2 in
-      if uu___
-      then true
-      else
-        (let uu___2 = arg1 in
-         match uu___2 with
-         | (t1, a1) ->
-             let uu___3 = arg2 in
-             (match uu___3 with
-              | (t2, a2) ->
-                  (equal_term t1 t2) && (equal_opt equal_arg_qualifier a1 a2)))
-and (equal_bqual :
-  FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-      Prims.bool)
-  = fun b1 -> fun b2 -> equal_opt equal_binder_qualifier b1 b2
-and (equal_binder_qualifier :
-  FStar_Syntax_Syntax.binder_qualifier ->
-    FStar_Syntax_Syntax.binder_qualifier -> Prims.bool)
-  =
-  fun b1 ->
-    fun b2 ->
-      match (b1, b2) with
-      | (FStar_Syntax_Syntax.Implicit b11, FStar_Syntax_Syntax.Implicit b21)
-          -> b11 = b21
-      | (FStar_Syntax_Syntax.Equality, FStar_Syntax_Syntax.Equality) -> true
-      | (FStar_Syntax_Syntax.Meta t1, FStar_Syntax_Syntax.Meta t2) ->
-          equal_term t1 t2
-      | uu___ -> false
-and (equal_branch :
-  (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-    FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) ->
-    (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax) -> Prims.bool)
-  =
-  fun uu___ ->
-    fun uu___1 ->
-      match (uu___, uu___1) with
-      | ((p1, w1, t1), (p2, w2, t2)) ->
-          ((equal_pat p1 p2) && (equal_opt equal_term w1 w2)) &&
-            (equal_term t1 t2)
-and (equal_pat :
-  FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t ->
-    FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t -> Prims.bool)
-  =
-  fun p1 ->
-    fun p2 ->
-      let uu___ = FStar_Compiler_Util.physical_equality p1 p2 in
-      if uu___
-      then true
-      else
-        (match ((p1.FStar_Syntax_Syntax.v), (p2.FStar_Syntax_Syntax.v)) with
-         | (FStar_Syntax_Syntax.Pat_constant c1,
-            FStar_Syntax_Syntax.Pat_constant c2) -> equal_constant c1 c2
-         | (FStar_Syntax_Syntax.Pat_cons (fv1, us1, args1),
-            FStar_Syntax_Syntax.Pat_cons (fv2, us2, args2)) ->
-             ((equal_fv fv1 fv2) &&
-                (equal_opt (equal_list equal_universe) us1 us2))
-               && (equal_list (equal_pair equal_pat equal_poly) args1 args2)
-         | (FStar_Syntax_Syntax.Pat_var bv1, FStar_Syntax_Syntax.Pat_var bv2)
-             -> equal_bv bv1 bv2
-         | (FStar_Syntax_Syntax.Pat_wild bv1, FStar_Syntax_Syntax.Pat_wild
-            bv2) -> equal_bv bv1 bv2
-         | (FStar_Syntax_Syntax.Pat_dot_term t1,
-            FStar_Syntax_Syntax.Pat_dot_term t2) ->
-             equal_opt equal_term t1 t2
-         | uu___2 -> false)
-and (equal_meta :
-  FStar_Syntax_Syntax.metadata -> FStar_Syntax_Syntax.metadata -> Prims.bool)
-  =
-  fun m1 ->
-    fun m2 ->
-      match (m1, m2) with
-      | (FStar_Syntax_Syntax.Meta_pattern (ts1, args1),
-         FStar_Syntax_Syntax.Meta_pattern (ts2, args2)) ->
-          (equal_list equal_term ts1 ts2) &&
-            (equal_list (equal_list equal_arg) args1 args2)
-      | (FStar_Syntax_Syntax.Meta_named l1, FStar_Syntax_Syntax.Meta_named
-         l2) -> FStar_Ident.lid_equals l1 l2
-      | (FStar_Syntax_Syntax.Meta_labeled (s1, r1, uu___),
-         FStar_Syntax_Syntax.Meta_labeled (s2, r2, uu___1)) ->
-          (s1 = s2) &&
-            (let uu___2 = FStar_Compiler_Range.compare r1 r2 in
-             uu___2 = Prims.int_zero)
-      | (FStar_Syntax_Syntax.Meta_desugared msi1,
-         FStar_Syntax_Syntax.Meta_desugared msi2) -> msi1 = msi2
-      | (FStar_Syntax_Syntax.Meta_monadic (m11, t1),
-         FStar_Syntax_Syntax.Meta_monadic (m21, t2)) ->
-          (FStar_Ident.lid_equals m11 m21) && (equal_term t1 t2)
-      | (FStar_Syntax_Syntax.Meta_monadic_lift (m11, n1, t1),
-         FStar_Syntax_Syntax.Meta_monadic_lift (m21, n2, t2)) ->
-          ((FStar_Ident.lid_equals m11 m21) && (FStar_Ident.lid_equals n1 n2))
-            && (equal_term t1 t2)
-and (equal_lazyinfo :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.lazyinfo -> Prims.bool)
-  = fun l1 -> fun l2 -> l1 = l2
-and (equal_quoteinfo :
-  FStar_Syntax_Syntax.quoteinfo ->
-    FStar_Syntax_Syntax.quoteinfo -> Prims.bool)
-  =
-  fun q1 ->
-    fun q2 ->
-      (q1.FStar_Syntax_Syntax.qkind = q2.FStar_Syntax_Syntax.qkind) &&
-        (equal_list (equal_pair equal_bv equal_term)
-           q1.FStar_Syntax_Syntax.antiquotes
-           q2.FStar_Syntax_Syntax.antiquotes)
-and (equal_rc :
-  FStar_Syntax_Syntax.residual_comp ->
-    FStar_Syntax_Syntax.residual_comp -> Prims.bool)
-  =
-  fun r1 ->
-    fun r2 ->
-      ((FStar_Ident.lid_equals r1.FStar_Syntax_Syntax.residual_effect
-          r2.FStar_Syntax_Syntax.residual_effect)
-         &&
-         (equal_opt equal_term r1.FStar_Syntax_Syntax.residual_typ
-            r2.FStar_Syntax_Syntax.residual_typ))
-        &&
-        (equal_list equal_flag r1.FStar_Syntax_Syntax.residual_flags
-           r2.FStar_Syntax_Syntax.residual_flags)
-and (equal_flag :
-  FStar_Syntax_Syntax.cflag -> FStar_Syntax_Syntax.cflag -> Prims.bool) =
-  fun f1 ->
-    fun f2 ->
-      match (f1, f2) with
-      | (FStar_Syntax_Syntax.DECREASES t1, FStar_Syntax_Syntax.DECREASES t2)
-          -> equal_decreases_order t1 t2
-      | uu___ -> f1 = f2
-and (equal_decreases_order :
-  FStar_Syntax_Syntax.decreases_order ->
-    FStar_Syntax_Syntax.decreases_order -> Prims.bool)
-  =
-  fun d1 ->
-    fun d2 ->
-      match (d1, d2) with
-      | (FStar_Syntax_Syntax.Decreases_lex ts1,
-         FStar_Syntax_Syntax.Decreases_lex ts2) ->
-          equal_list equal_term ts1 ts2
-      | (FStar_Syntax_Syntax.Decreases_wf (t1, t1'),
-         FStar_Syntax_Syntax.Decreases_wf (t2, t2')) ->
-          (equal_term t1 t2) && (equal_term t1' t2')
-and (equal_arg_qualifier :
-  FStar_Syntax_Syntax.arg_qualifier ->
-    FStar_Syntax_Syntax.arg_qualifier -> Prims.bool)
-  =
-  fun a1 ->
-    fun a2 ->
-      (a1.FStar_Syntax_Syntax.aqual_implicit =
-         a2.FStar_Syntax_Syntax.aqual_implicit)
-        &&
-        (equal_list equal_term a1.FStar_Syntax_Syntax.aqual_attributes
-           a2.FStar_Syntax_Syntax.aqual_attributes)
-and (equal_lbname :
-  (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either ->
-    (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either
-      -> Prims.bool)
-  =
-  fun l1 ->
-    fun l2 ->
-      match (l1, l2) with
-      | (FStar_Pervasives.Inl b1, FStar_Pervasives.Inl b2) ->
-          FStar_Ident.ident_equals b1.FStar_Syntax_Syntax.ppname
-            b2.FStar_Syntax_Syntax.ppname
-      | (FStar_Pervasives.Inr f1, FStar_Pervasives.Inr f2) ->
-          FStar_Ident.lid_equals
-            (f1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-            (f2.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-and (equal_subst_elt :
-  FStar_Syntax_Syntax.subst_elt ->
-    FStar_Syntax_Syntax.subst_elt -> Prims.bool)
-  =
-  fun s1 ->
-    fun s2 ->
-      match (s1, s2) with
-      | (FStar_Syntax_Syntax.DB (i1, bv1), FStar_Syntax_Syntax.DB (i2, bv2))
-          -> (i1 = i2) && (equal_bv bv1 bv2)
-      | (FStar_Syntax_Syntax.NM (bv1, i1), FStar_Syntax_Syntax.NM (bv2, i2))
-          -> (i1 = i2) && (equal_bv bv1 bv2)
-      | (FStar_Syntax_Syntax.NT (bv1, t1), FStar_Syntax_Syntax.NT (bv2, t2))
-          -> (equal_bv bv1 bv2) && (equal_term t1 t2)
-      | (FStar_Syntax_Syntax.UN (i1, u1), FStar_Syntax_Syntax.UN (i2, u2)) ->
-          (i1 = i2) && (equal_universe u1 u2)
-      | (FStar_Syntax_Syntax.UD (un1, i1), FStar_Syntax_Syntax.UD (un2, i2))
-          -> (i1 = i2) && (FStar_Ident.ident_equals un1 un2)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_InstFV.ml b/src/ocaml-output/FStar_Syntax_InstFV.ml
deleted file mode 100644
index e005b735aa2..00000000000
--- a/src/ocaml-output/FStar_Syntax_InstFV.ml
+++ /dev/null
@@ -1,332 +0,0 @@
-open Prims
-type inst_t = (FStar_Ident.lident * FStar_Syntax_Syntax.universes) Prims.list
-let mk :
-  'uuuuu 'uuuuu1 .
-    'uuuuu FStar_Syntax_Syntax.syntax ->
-      'uuuuu1 -> 'uuuuu1 FStar_Syntax_Syntax.syntax
-  = fun t -> fun s -> FStar_Syntax_Syntax.mk s t.FStar_Syntax_Syntax.pos
-let rec (inst :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun s ->
-    fun t ->
-      let t1 = FStar_Syntax_Subst.compress t in
-      let mk1 = mk t1 in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_delayed uu___ -> failwith "Impossible"
-      | FStar_Syntax_Syntax.Tm_name uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_uvar uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_uvar uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_type uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_bvar uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_constant uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_quoted uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_unknown -> t1
-      | FStar_Syntax_Syntax.Tm_uinst uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_lazy uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_fvar fv -> s t1 fv
-      | FStar_Syntax_Syntax.Tm_abs (bs, body, lopt) ->
-          let bs1 = inst_binders s bs in
-          let body1 = inst s body in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = inst_lcomp_opt s lopt in (bs1, body1, uu___2) in
-            FStar_Syntax_Syntax.Tm_abs uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-          let bs1 = inst_binders s bs in
-          let c1 = inst_comp s c in
-          mk1 (FStar_Syntax_Syntax.Tm_arrow (bs1, c1))
-      | FStar_Syntax_Syntax.Tm_refine (bv, t2) ->
-          let bv1 =
-            let uu___ = inst s bv.FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (bv.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___
-            } in
-          let t3 = inst s t2 in mk1 (FStar_Syntax_Syntax.Tm_refine (bv1, t3))
-      | FStar_Syntax_Syntax.Tm_app (t2, args) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = inst s t2 in
-              let uu___3 = inst_args s args in (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_app uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_match (t2, asc_opt, pats, lopt) ->
-          let pats1 =
-            FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.map
-                 (fun uu___ ->
-                    match uu___ with
-                    | (p, wopt, t3) ->
-                        let wopt1 =
-                          match wopt with
-                          | FStar_Pervasives_Native.None ->
-                              FStar_Pervasives_Native.None
-                          | FStar_Pervasives_Native.Some w ->
-                              let uu___1 = inst s w in
-                              FStar_Pervasives_Native.Some uu___1 in
-                        let t4 = inst s t3 in (p, wopt1, t4))) in
-          let asc_opt1 =
-            match asc_opt with
-            | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-            | FStar_Pervasives_Native.Some (b, asc) ->
-                let uu___ =
-                  let uu___1 = inst_binder s b in
-                  let uu___2 = inst_ascription s asc in (uu___1, uu___2) in
-                FStar_Pervasives_Native.Some uu___ in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = inst s t2 in
-              let uu___3 = inst_lcomp_opt s lopt in
-              (uu___2, asc_opt1, pats1, uu___3) in
-            FStar_Syntax_Syntax.Tm_match uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_ascribed (t11, asc, f) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = inst s t11 in
-              let uu___3 = inst_ascription s asc in (uu___2, uu___3, f) in
-            FStar_Syntax_Syntax.Tm_ascribed uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_let (lbs, t2) ->
-          let lbs1 =
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater
-                (FStar_Pervasives_Native.snd lbs)
-                (FStar_Compiler_List.map
-                   (fun lb ->
-                      let uu___1 = inst s lb.FStar_Syntax_Syntax.lbtyp in
-                      let uu___2 = inst s lb.FStar_Syntax_Syntax.lbdef in
-                      {
-                        FStar_Syntax_Syntax.lbname =
-                          (lb.FStar_Syntax_Syntax.lbname);
-                        FStar_Syntax_Syntax.lbunivs =
-                          (lb.FStar_Syntax_Syntax.lbunivs);
-                        FStar_Syntax_Syntax.lbtyp = uu___1;
-                        FStar_Syntax_Syntax.lbeff =
-                          (lb.FStar_Syntax_Syntax.lbeff);
-                        FStar_Syntax_Syntax.lbdef = uu___2;
-                        FStar_Syntax_Syntax.lbattrs =
-                          (lb.FStar_Syntax_Syntax.lbattrs);
-                        FStar_Syntax_Syntax.lbpos =
-                          (lb.FStar_Syntax_Syntax.lbpos)
-                      })) in
-            ((FStar_Pervasives_Native.fst lbs), uu___) in
-          let uu___ =
-            let uu___1 = let uu___2 = inst s t2 in (lbs1, uu___2) in
-            FStar_Syntax_Syntax.Tm_let uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_meta
-          (t2, FStar_Syntax_Syntax.Meta_pattern (bvs, args)) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = inst s t2 in
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Bar_Greater args
-                      (FStar_Compiler_List.map (inst_args s)) in
-                  (bvs, uu___5) in
-                FStar_Syntax_Syntax.Meta_pattern uu___4 in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_meta
-          (t2, FStar_Syntax_Syntax.Meta_monadic (m, t')) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = inst s t2 in
-              let uu___3 =
-                let uu___4 = let uu___5 = inst s t' in (m, uu___5) in
-                FStar_Syntax_Syntax.Meta_monadic uu___4 in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk1 uu___
-      | FStar_Syntax_Syntax.Tm_meta (t2, tag) ->
-          let uu___ =
-            let uu___1 = let uu___2 = inst s t2 in (uu___2, tag) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk1 uu___
-and (inst_binder :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    -> FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder)
-  =
-  fun s ->
-    fun b ->
-      let uu___ =
-        let uu___1 = b.FStar_Syntax_Syntax.binder_bv in
-        let uu___2 =
-          inst s (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-        {
-          FStar_Syntax_Syntax.ppname = (uu___1.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index = (uu___1.FStar_Syntax_Syntax.index);
-          FStar_Syntax_Syntax.sort = uu___2
-        } in
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater
-          b.FStar_Syntax_Syntax.binder_attrs
-          (FStar_Compiler_List.map (inst s)) in
-      {
-        FStar_Syntax_Syntax.binder_bv = uu___;
-        FStar_Syntax_Syntax.binder_qual = (b.FStar_Syntax_Syntax.binder_qual);
-        FStar_Syntax_Syntax.binder_attrs = uu___1
-      }
-and (inst_binders :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    -> FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders)
-  =
-  fun s ->
-    fun bs ->
-      FStar_Compiler_Effect.op_Bar_Greater bs
-        (FStar_Compiler_List.map (inst_binder s))
-and (inst_args :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-      Prims.list ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list)
-  =
-  fun s ->
-    fun args ->
-      FStar_Compiler_Effect.op_Bar_Greater args
-        (FStar_Compiler_List.map
-           (fun uu___ ->
-              match uu___ with
-              | (a, imp) -> let uu___1 = inst s a in (uu___1, imp)))
-and (inst_comp :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  =
-  fun s ->
-    fun c ->
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Total t ->
-          let uu___ = inst s t in FStar_Syntax_Syntax.mk_Total uu___
-      | FStar_Syntax_Syntax.GTotal t ->
-          let uu___ = inst s t in FStar_Syntax_Syntax.mk_GTotal uu___
-      | FStar_Syntax_Syntax.Comp ct ->
-          let ct1 =
-            let uu___ = inst s ct.FStar_Syntax_Syntax.result_typ in
-            let uu___1 = inst_args s ct.FStar_Syntax_Syntax.effect_args in
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                ct.FStar_Syntax_Syntax.flags
-                (FStar_Compiler_List.map
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | FStar_Syntax_Syntax.DECREASES dec_order ->
-                          let uu___4 = inst_decreases_order s dec_order in
-                          FStar_Syntax_Syntax.DECREASES uu___4
-                      | f -> f)) in
-            {
-              FStar_Syntax_Syntax.comp_univs =
-                (ct.FStar_Syntax_Syntax.comp_univs);
-              FStar_Syntax_Syntax.effect_name =
-                (ct.FStar_Syntax_Syntax.effect_name);
-              FStar_Syntax_Syntax.result_typ = uu___;
-              FStar_Syntax_Syntax.effect_args = uu___1;
-              FStar_Syntax_Syntax.flags = uu___2
-            } in
-          FStar_Syntax_Syntax.mk_Comp ct1
-and (inst_decreases_order :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    ->
-    FStar_Syntax_Syntax.decreases_order ->
-      FStar_Syntax_Syntax.decreases_order)
-  =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Syntax_Syntax.Decreases_lex l ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater l
-              (FStar_Compiler_List.map (inst s)) in
-          FStar_Syntax_Syntax.Decreases_lex uu___1
-      | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-          let uu___1 =
-            let uu___2 = inst s rel in
-            let uu___3 = inst s e in (uu___2, uu___3) in
-          FStar_Syntax_Syntax.Decreases_wf uu___1
-and (inst_lcomp_opt :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    ->
-    FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option)
-  =
-  fun s ->
-    fun l ->
-      match l with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some rc ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Util.map_opt rc.FStar_Syntax_Syntax.residual_typ
-                (inst s) in
-            {
-              FStar_Syntax_Syntax.residual_effect =
-                (rc.FStar_Syntax_Syntax.residual_effect);
-              FStar_Syntax_Syntax.residual_typ = uu___1;
-              FStar_Syntax_Syntax.residual_flags =
-                (rc.FStar_Syntax_Syntax.residual_flags)
-            } in
-          FStar_Pervasives_Native.Some uu___
-and (inst_ascription :
-  (FStar_Syntax_Syntax.term ->
-     FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-    ->
-    FStar_Syntax_Syntax.ascription ->
-      ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-        FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-        FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-        Prims.bool))
-  =
-  fun s ->
-    fun asc ->
-      let uu___ = asc in
-      match uu___ with
-      | (annot, topt, use_eq) ->
-          let annot1 =
-            match annot with
-            | FStar_Pervasives.Inl t ->
-                let uu___1 = inst s t in FStar_Pervasives.Inl uu___1
-            | FStar_Pervasives.Inr c ->
-                let uu___1 = inst_comp s c in FStar_Pervasives.Inr uu___1 in
-          let topt1 = FStar_Compiler_Util.map_opt topt (inst s) in
-          (annot1, topt1, use_eq)
-let (instantiate :
-  inst_t -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun i ->
-    fun t ->
-      match i with
-      | [] -> t
-      | uu___ ->
-          let inst_fv t1 fv =
-            let uu___1 =
-              FStar_Compiler_Util.find_opt
-                (fun uu___2 ->
-                   match uu___2 with
-                   | (x, uu___3) ->
-                       FStar_Ident.lid_equals x
-                         (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-                i in
-            match uu___1 with
-            | FStar_Pervasives_Native.None -> t1
-            | FStar_Pervasives_Native.Some (uu___2, us) ->
-                mk t1 (FStar_Syntax_Syntax.Tm_uinst (t1, us)) in
-          inst inst_fv t
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_MutRecTy.ml b/src/ocaml-output/FStar_Syntax_MutRecTy.ml
deleted file mode 100644
index a6b0942d1d5..00000000000
--- a/src/ocaml-output/FStar_Syntax_MutRecTy.ml
+++ /dev/null
@@ -1,376 +0,0 @@
-open Prims
-let (disentangle_abbrevs_from_bundle :
-  FStar_Syntax_Syntax.sigelt Prims.list ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Ident.lident Prims.list ->
-        FStar_Compiler_Range.range ->
-          (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.sigelt
-            Prims.list))
-  =
-  fun sigelts ->
-    fun quals ->
-      fun members ->
-        fun rng ->
-          let sigattrs =
-            FStar_Compiler_List.collect
-              (fun s -> s.FStar_Syntax_Syntax.sigattrs) sigelts in
-          let type_abbrev_sigelts =
-            FStar_Compiler_Effect.op_Bar_Greater sigelts
-              (FStar_Compiler_List.collect
-                 (fun x ->
-                    match x.FStar_Syntax_Syntax.sigel with
-                    | FStar_Syntax_Syntax.Sig_let
-                        ((false,
-                          {
-                            FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr
-                              uu___;
-                            FStar_Syntax_Syntax.lbunivs = uu___1;
-                            FStar_Syntax_Syntax.lbtyp = uu___2;
-                            FStar_Syntax_Syntax.lbeff = uu___3;
-                            FStar_Syntax_Syntax.lbdef = uu___4;
-                            FStar_Syntax_Syntax.lbattrs = uu___5;
-                            FStar_Syntax_Syntax.lbpos = uu___6;_}::[]),
-                         uu___7)
-                        -> [x]
-                    | FStar_Syntax_Syntax.Sig_let (uu___, uu___1) ->
-                        failwith
-                          "mutrecty: disentangle_abbrevs_from_bundle: type_abbrev_sigelts: impossible"
-                    | uu___ -> [])) in
-          match type_abbrev_sigelts with
-          | [] ->
-              ({
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_bundle (sigelts, members));
-                 FStar_Syntax_Syntax.sigrng = rng;
-                 FStar_Syntax_Syntax.sigquals = quals;
-                 FStar_Syntax_Syntax.sigmeta =
-                   FStar_Syntax_Syntax.default_sigmeta;
-                 FStar_Syntax_Syntax.sigattrs = sigattrs;
-                 FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-               }, [])
-          | uu___ ->
-              let type_abbrevs =
-                FStar_Compiler_Effect.op_Bar_Greater type_abbrev_sigelts
-                  (FStar_Compiler_List.map
-                     (fun x ->
-                        match x.FStar_Syntax_Syntax.sigel with
-                        | FStar_Syntax_Syntax.Sig_let
-                            ((uu___1,
-                              {
-                                FStar_Syntax_Syntax.lbname =
-                                  FStar_Pervasives.Inr fv;
-                                FStar_Syntax_Syntax.lbunivs = uu___2;
-                                FStar_Syntax_Syntax.lbtyp = uu___3;
-                                FStar_Syntax_Syntax.lbeff = uu___4;
-                                FStar_Syntax_Syntax.lbdef = uu___5;
-                                FStar_Syntax_Syntax.lbattrs = uu___6;
-                                FStar_Syntax_Syntax.lbpos = uu___7;_}::[]),
-                             uu___8)
-                            ->
-                            (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                        | uu___1 ->
-                            failwith
-                              "mutrecty: disentangle_abbrevs_from_bundle: type_abbrevs: impossible")) in
-              let unfolded_type_abbrevs =
-                let rev_unfolded_type_abbrevs = FStar_Compiler_Util.mk_ref [] in
-                let in_progress = FStar_Compiler_Util.mk_ref [] in
-                let not_unfolded_yet =
-                  FStar_Compiler_Util.mk_ref type_abbrev_sigelts in
-                let remove_not_unfolded lid =
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bang not_unfolded_yet in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___2
-                      (FStar_Compiler_List.filter
-                         (fun x ->
-                            match x.FStar_Syntax_Syntax.sigel with
-                            | FStar_Syntax_Syntax.Sig_let
-                                ((uu___3,
-                                  {
-                                    FStar_Syntax_Syntax.lbname =
-                                      FStar_Pervasives.Inr fv;
-                                    FStar_Syntax_Syntax.lbunivs = uu___4;
-                                    FStar_Syntax_Syntax.lbtyp = uu___5;
-                                    FStar_Syntax_Syntax.lbeff = uu___6;
-                                    FStar_Syntax_Syntax.lbdef = uu___7;
-                                    FStar_Syntax_Syntax.lbattrs = uu___8;
-                                    FStar_Syntax_Syntax.lbpos = uu___9;_}::[]),
-                                 uu___10)
-                                ->
-                                let uu___11 =
-                                  FStar_Ident.lid_equals lid
-                                    (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                Prims.op_Negation uu___11
-                            | uu___3 -> true)) in
-                  FStar_Compiler_Effect.op_Colon_Equals not_unfolded_yet
-                    uu___1 in
-                let rec unfold_abbrev_fv t fv =
-                  let replacee x =
-                    match x.FStar_Syntax_Syntax.sigel with
-                    | FStar_Syntax_Syntax.Sig_let
-                        ((uu___1,
-                          {
-                            FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr
-                              fv';
-                            FStar_Syntax_Syntax.lbunivs = uu___2;
-                            FStar_Syntax_Syntax.lbtyp = uu___3;
-                            FStar_Syntax_Syntax.lbeff = uu___4;
-                            FStar_Syntax_Syntax.lbdef = uu___5;
-                            FStar_Syntax_Syntax.lbattrs = uu___6;
-                            FStar_Syntax_Syntax.lbpos = uu___7;_}::[]),
-                         uu___8)
-                        when
-                        FStar_Ident.lid_equals
-                          (fv'.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                        -> FStar_Pervasives_Native.Some x
-                    | uu___1 -> FStar_Pervasives_Native.None in
-                  let replacee_term x =
-                    match replacee x with
-                    | FStar_Pervasives_Native.Some
-                        {
-                          FStar_Syntax_Syntax.sigel =
-                            FStar_Syntax_Syntax.Sig_let
-                            ((uu___1,
-                              { FStar_Syntax_Syntax.lbname = uu___2;
-                                FStar_Syntax_Syntax.lbunivs = uu___3;
-                                FStar_Syntax_Syntax.lbtyp = uu___4;
-                                FStar_Syntax_Syntax.lbeff = uu___5;
-                                FStar_Syntax_Syntax.lbdef = tm;
-                                FStar_Syntax_Syntax.lbattrs = uu___6;
-                                FStar_Syntax_Syntax.lbpos = uu___7;_}::[]),
-                             uu___8);
-                          FStar_Syntax_Syntax.sigrng = uu___9;
-                          FStar_Syntax_Syntax.sigquals = uu___10;
-                          FStar_Syntax_Syntax.sigmeta = uu___11;
-                          FStar_Syntax_Syntax.sigattrs = uu___12;
-                          FStar_Syntax_Syntax.sigopts = uu___13;_}
-                        -> FStar_Pervasives_Native.Some tm
-                    | uu___1 -> FStar_Pervasives_Native.None in
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bang rev_unfolded_type_abbrevs in
-                    FStar_Compiler_Util.find_map uu___2 replacee_term in
-                  match uu___1 with
-                  | FStar_Pervasives_Native.Some x -> x
-                  | FStar_Pervasives_Native.None ->
-                      let uu___2 =
-                        FStar_Compiler_Util.find_map type_abbrev_sigelts
-                          replacee in
-                      (match uu___2 with
-                       | FStar_Pervasives_Native.Some se ->
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Compiler_Effect.op_Bang in_progress in
-                             FStar_Compiler_List.existsb
-                               (fun x ->
-                                  FStar_Ident.lid_equals x
-                                    (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-                               uu___4 in
-                           if uu___3
-                           then
-                             let msg =
-                               let uu___4 =
-                                 FStar_Ident.string_of_lid
-                                   (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                               FStar_Compiler_Util.format1
-                                 "Cycle on %s in mutually recursive type abbreviations"
-                                 uu___4 in
-                             let uu___4 =
-                               FStar_Ident.range_of_lid
-                                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                             FStar_Errors.raise_error
-                               (FStar_Errors.Fatal_CycleInRecTypeAbbreviation,
-                                 msg) uu___4
-                           else unfold_abbrev se
-                       | uu___3 -> t)
-                and unfold_abbrev x =
-                  match x.FStar_Syntax_Syntax.sigel with
-                  | FStar_Syntax_Syntax.Sig_let ((false, lb::[]), uu___1) ->
-                      let quals1 =
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          x.FStar_Syntax_Syntax.sigquals
-                          (FStar_Compiler_List.filter
-                             (fun uu___2 ->
-                                match uu___2 with
-                                | FStar_Syntax_Syntax.Noeq -> false
-                                | uu___3 -> true)) in
-                      let lid =
-                        match lb.FStar_Syntax_Syntax.lbname with
-                        | FStar_Pervasives.Inr fv ->
-                            (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                        | uu___2 ->
-                            failwith
-                              "mutrecty: disentangle_abbrevs_from_bundle: rename_abbrev: lid: impossible" in
-                      ((let uu___3 =
-                          let uu___4 =
-                            FStar_Compiler_Effect.op_Bang in_progress in
-                          lid :: uu___4 in
-                        FStar_Compiler_Effect.op_Colon_Equals in_progress
-                          uu___3);
-                       (match () with
-                        | () ->
-                            (remove_not_unfolded lid;
-                             (match () with
-                              | () ->
-                                  let ty' =
-                                    FStar_Syntax_InstFV.inst unfold_abbrev_fv
-                                      lb.FStar_Syntax_Syntax.lbtyp in
-                                  let tm' =
-                                    FStar_Syntax_InstFV.inst unfold_abbrev_fv
-                                      lb.FStar_Syntax_Syntax.lbdef in
-                                  let lb' =
-                                    {
-                                      FStar_Syntax_Syntax.lbname =
-                                        (lb.FStar_Syntax_Syntax.lbname);
-                                      FStar_Syntax_Syntax.lbunivs =
-                                        (lb.FStar_Syntax_Syntax.lbunivs);
-                                      FStar_Syntax_Syntax.lbtyp = ty';
-                                      FStar_Syntax_Syntax.lbeff =
-                                        (lb.FStar_Syntax_Syntax.lbeff);
-                                      FStar_Syntax_Syntax.lbdef = tm';
-                                      FStar_Syntax_Syntax.lbattrs =
-                                        (lb.FStar_Syntax_Syntax.lbattrs);
-                                      FStar_Syntax_Syntax.lbpos =
-                                        (lb.FStar_Syntax_Syntax.lbpos)
-                                    } in
-                                  let sigelt' =
-                                    FStar_Syntax_Syntax.Sig_let
-                                      ((false, [lb']), [lid]) in
-                                  ((let uu___5 =
-                                      let uu___6 =
-                                        FStar_Compiler_Effect.op_Bang
-                                          rev_unfolded_type_abbrevs in
-                                      {
-                                        FStar_Syntax_Syntax.sigel = sigelt';
-                                        FStar_Syntax_Syntax.sigrng =
-                                          (x.FStar_Syntax_Syntax.sigrng);
-                                        FStar_Syntax_Syntax.sigquals = quals1;
-                                        FStar_Syntax_Syntax.sigmeta =
-                                          (x.FStar_Syntax_Syntax.sigmeta);
-                                        FStar_Syntax_Syntax.sigattrs =
-                                          (x.FStar_Syntax_Syntax.sigattrs);
-                                        FStar_Syntax_Syntax.sigopts =
-                                          (x.FStar_Syntax_Syntax.sigopts)
-                                      } :: uu___6 in
-                                    FStar_Compiler_Effect.op_Colon_Equals
-                                      rev_unfolded_type_abbrevs uu___5);
-                                   (match () with
-                                    | () ->
-                                        ((let uu___6 =
-                                            let uu___7 =
-                                              FStar_Compiler_Effect.op_Bang
-                                                in_progress in
-                                            FStar_Compiler_List.tl uu___7 in
-                                          FStar_Compiler_Effect.op_Colon_Equals
-                                            in_progress uu___6);
-                                         (match () with | () -> tm'))))))))
-                  | uu___1 ->
-                      failwith
-                        "mutrecty: disentangle_abbrevs_from_bundle: rename_abbrev: impossible" in
-                let rec aux uu___1 =
-                  let uu___2 = FStar_Compiler_Effect.op_Bang not_unfolded_yet in
-                  match uu___2 with
-                  | x::uu___3 -> let _unused = unfold_abbrev x in aux ()
-                  | uu___3 ->
-                      let uu___4 =
-                        FStar_Compiler_Effect.op_Bang
-                          rev_unfolded_type_abbrevs in
-                      FStar_Compiler_List.rev uu___4 in
-                aux () in
-              let filter_out_type_abbrevs l =
-                FStar_Compiler_List.filter
-                  (fun lid ->
-                     FStar_Compiler_List.for_all
-                       (fun lid' ->
-                          let uu___1 = FStar_Ident.lid_equals lid lid' in
-                          Prims.op_Negation uu___1) type_abbrevs) l in
-              let inductives_with_abbrevs_unfolded =
-                let find_in_unfolded fv =
-                  FStar_Compiler_Util.find_map unfolded_type_abbrevs
-                    (fun x ->
-                       match x.FStar_Syntax_Syntax.sigel with
-                       | FStar_Syntax_Syntax.Sig_let
-                           ((uu___1,
-                             {
-                               FStar_Syntax_Syntax.lbname =
-                                 FStar_Pervasives.Inr fv';
-                               FStar_Syntax_Syntax.lbunivs = uu___2;
-                               FStar_Syntax_Syntax.lbtyp = uu___3;
-                               FStar_Syntax_Syntax.lbeff = uu___4;
-                               FStar_Syntax_Syntax.lbdef = tm;
-                               FStar_Syntax_Syntax.lbattrs = uu___5;
-                               FStar_Syntax_Syntax.lbpos = uu___6;_}::[]),
-                            uu___7)
-                           when
-                           FStar_Ident.lid_equals
-                             (fv'.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                             (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                           -> FStar_Pervasives_Native.Some tm
-                       | uu___1 -> FStar_Pervasives_Native.None) in
-                let unfold_fv t fv =
-                  let uu___1 = find_in_unfolded fv in
-                  match uu___1 with
-                  | FStar_Pervasives_Native.Some t' -> t'
-                  | uu___2 -> t in
-                let unfold_in_sig x =
-                  match x.FStar_Syntax_Syntax.sigel with
-                  | FStar_Syntax_Syntax.Sig_inductive_typ
-                      (lid, univs, bnd, num_uniform, ty, mut, dc) ->
-                      let bnd' =
-                        FStar_Syntax_InstFV.inst_binders unfold_fv bnd in
-                      let ty' = FStar_Syntax_InstFV.inst unfold_fv ty in
-                      let mut' = filter_out_type_abbrevs mut in
-                      [{
-                         FStar_Syntax_Syntax.sigel =
-                           (FStar_Syntax_Syntax.Sig_inductive_typ
-                              (lid, univs, bnd', num_uniform, ty', mut', dc));
-                         FStar_Syntax_Syntax.sigrng =
-                           (x.FStar_Syntax_Syntax.sigrng);
-                         FStar_Syntax_Syntax.sigquals =
-                           (x.FStar_Syntax_Syntax.sigquals);
-                         FStar_Syntax_Syntax.sigmeta =
-                           (x.FStar_Syntax_Syntax.sigmeta);
-                         FStar_Syntax_Syntax.sigattrs =
-                           (x.FStar_Syntax_Syntax.sigattrs);
-                         FStar_Syntax_Syntax.sigopts =
-                           (x.FStar_Syntax_Syntax.sigopts)
-                       }]
-                  | FStar_Syntax_Syntax.Sig_datacon
-                      (lid, univs, ty, res, npars, mut) ->
-                      let ty' = FStar_Syntax_InstFV.inst unfold_fv ty in
-                      let mut' = filter_out_type_abbrevs mut in
-                      [{
-                         FStar_Syntax_Syntax.sigel =
-                           (FStar_Syntax_Syntax.Sig_datacon
-                              (lid, univs, ty', res, npars, mut'));
-                         FStar_Syntax_Syntax.sigrng =
-                           (x.FStar_Syntax_Syntax.sigrng);
-                         FStar_Syntax_Syntax.sigquals =
-                           (x.FStar_Syntax_Syntax.sigquals);
-                         FStar_Syntax_Syntax.sigmeta =
-                           (x.FStar_Syntax_Syntax.sigmeta);
-                         FStar_Syntax_Syntax.sigattrs =
-                           (x.FStar_Syntax_Syntax.sigattrs);
-                         FStar_Syntax_Syntax.sigopts =
-                           (x.FStar_Syntax_Syntax.sigopts)
-                       }]
-                  | FStar_Syntax_Syntax.Sig_let (uu___1, uu___2) -> []
-                  | uu___1 ->
-                      failwith
-                        "mutrecty: inductives_with_abbrevs_unfolded: unfold_in_sig: impossible" in
-                FStar_Compiler_List.collect unfold_in_sig sigelts in
-              let new_members = filter_out_type_abbrevs members in
-              let new_bundle =
-                {
-                  FStar_Syntax_Syntax.sigel =
-                    (FStar_Syntax_Syntax.Sig_bundle
-                       (inductives_with_abbrevs_unfolded, new_members));
-                  FStar_Syntax_Syntax.sigrng = rng;
-                  FStar_Syntax_Syntax.sigquals = quals;
-                  FStar_Syntax_Syntax.sigmeta =
-                    FStar_Syntax_Syntax.default_sigmeta;
-                  FStar_Syntax_Syntax.sigattrs = sigattrs;
-                  FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-                } in
-              (new_bundle, unfolded_type_abbrevs)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Print.ml b/src/ocaml-output/FStar_Syntax_Print.ml
deleted file mode 100644
index 15e61b451b6..00000000000
--- a/src/ocaml-output/FStar_Syntax_Print.ml
+++ /dev/null
@@ -1,1759 +0,0 @@
-open Prims
-let rec (delta_depth_to_string :
-  FStar_Syntax_Syntax.delta_depth -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Delta_constant_at_level i ->
-        let uu___1 = FStar_Compiler_Util.string_of_int i in
-        Prims.op_Hat "Delta_constant_at_level " uu___1
-    | FStar_Syntax_Syntax.Delta_equational_at_level i ->
-        let uu___1 = FStar_Compiler_Util.string_of_int i in
-        Prims.op_Hat "Delta_equational_at_level " uu___1
-    | FStar_Syntax_Syntax.Delta_abstract d ->
-        let uu___1 =
-          let uu___2 = delta_depth_to_string d in Prims.op_Hat uu___2 ")" in
-        Prims.op_Hat "Delta_abstract (" uu___1
-let (sli : FStar_Ident.lident -> Prims.string) =
-  fun l ->
-    let uu___ = FStar_Options.print_real_names () in
-    if uu___
-    then FStar_Ident.string_of_lid l
-    else
-      (let uu___2 = FStar_Ident.ident_of_lid l in
-       FStar_Ident.string_of_id uu___2)
-let (lid_to_string : FStar_Ident.lid -> Prims.string) = fun l -> sli l
-let (fv_to_string : FStar_Syntax_Syntax.fv -> Prims.string) =
-  fun fv ->
-    lid_to_string (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-let (bv_to_string : FStar_Syntax_Syntax.bv -> Prims.string) =
-  fun bv ->
-    let uu___ = FStar_Ident.string_of_id bv.FStar_Syntax_Syntax.ppname in
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Util.string_of_int bv.FStar_Syntax_Syntax.index in
-      Prims.op_Hat "#" uu___2 in
-    Prims.op_Hat uu___ uu___1
-let (nm_to_string : FStar_Syntax_Syntax.bv -> Prims.string) =
-  fun bv ->
-    let uu___ = FStar_Options.print_real_names () in
-    if uu___
-    then bv_to_string bv
-    else FStar_Ident.string_of_id bv.FStar_Syntax_Syntax.ppname
-let (db_to_string : FStar_Syntax_Syntax.bv -> Prims.string) =
-  fun bv ->
-    let uu___ = FStar_Ident.string_of_id bv.FStar_Syntax_Syntax.ppname in
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Util.string_of_int bv.FStar_Syntax_Syntax.index in
-      Prims.op_Hat "@" uu___2 in
-    Prims.op_Hat uu___ uu___1
-let (filter_imp :
-  FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-    Prims.bool)
-  =
-  fun aq ->
-    match aq with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) when
-        FStar_Syntax_Util.is_fvar FStar_Parser_Const.tcresolve_lid t -> true
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit uu___) ->
-        false
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta uu___) -> false
-    | uu___ -> true
-let filter_imp_args :
-  'uuuuu .
-    ('uuuuu * FStar_Syntax_Syntax.arg_qualifier
-      FStar_Pervasives_Native.option) Prims.list ->
-      ('uuuuu * FStar_Syntax_Syntax.arg_qualifier
-        FStar_Pervasives_Native.option) Prims.list
-  =
-  fun args ->
-    FStar_Compiler_Effect.op_Bar_Greater args
-      (FStar_Compiler_List.filter
-         (fun uu___ ->
-            match uu___ with
-            | (uu___1, FStar_Pervasives_Native.None) -> true
-            | (uu___1, FStar_Pervasives_Native.Some a) ->
-                Prims.op_Negation a.FStar_Syntax_Syntax.aqual_implicit))
-let (filter_imp_binders :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun bs ->
-    FStar_Compiler_Effect.op_Bar_Greater bs
-      (FStar_Compiler_List.filter
-         (fun b ->
-            FStar_Compiler_Effect.op_Bar_Greater
-              b.FStar_Syntax_Syntax.binder_qual filter_imp))
-let (const_to_string : FStar_Const.sconst -> Prims.string) =
-  FStar_Parser_Const.const_to_string
-let (lbname_to_string : FStar_Syntax_Syntax.lbname -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives.Inl l -> bv_to_string l
-    | FStar_Pervasives.Inr l ->
-        lid_to_string (l.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-let (uvar_to_string : FStar_Syntax_Syntax.uvar -> Prims.string) =
-  fun u ->
-    let uu___ = FStar_Options.hide_uvar_nums () in
-    if uu___
-    then "?"
-    else
-      (let uu___2 =
-         let uu___3 = FStar_Syntax_Unionfind.uvar_id u in
-         FStar_Compiler_Effect.op_Bar_Greater uu___3
-           FStar_Compiler_Util.string_of_int in
-       Prims.op_Hat "?" uu___2)
-let (version_to_string : FStar_Syntax_Syntax.version -> Prims.string) =
-  fun v ->
-    let uu___ = FStar_Compiler_Util.string_of_int v.FStar_Syntax_Syntax.major in
-    let uu___1 =
-      FStar_Compiler_Util.string_of_int v.FStar_Syntax_Syntax.minor in
-    FStar_Compiler_Util.format2 "%s.%s" uu___ uu___1
-let (univ_uvar_to_string :
-  (FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option
-    FStar_Unionfind.p_uvar * FStar_Syntax_Syntax.version *
-    FStar_Compiler_Range.range) -> Prims.string)
-  =
-  fun u ->
-    let uu___ = FStar_Options.hide_uvar_nums () in
-    if uu___
-    then "?"
-    else
-      (let uu___2 =
-         let uu___3 =
-           let uu___4 = FStar_Syntax_Unionfind.univ_uvar_id u in
-           FStar_Compiler_Effect.op_Bar_Greater uu___4
-             FStar_Compiler_Util.string_of_int in
-         let uu___4 =
-           let uu___5 =
-             FStar_Compiler_Effect.op_Bar_Greater u
-               (fun uu___6 ->
-                  match uu___6 with
-                  | (uu___7, u1, uu___8) -> version_to_string u1) in
-           Prims.op_Hat ":" uu___5 in
-         Prims.op_Hat uu___3 uu___4 in
-       Prims.op_Hat "?" uu___2)
-let rec (int_of_univ :
-  Prims.int ->
-    FStar_Syntax_Syntax.universe ->
-      (Prims.int * FStar_Syntax_Syntax.universe
-        FStar_Pervasives_Native.option))
-  =
-  fun n ->
-    fun u ->
-      let uu___ = FStar_Syntax_Subst.compress_univ u in
-      match uu___ with
-      | FStar_Syntax_Syntax.U_zero -> (n, FStar_Pervasives_Native.None)
-      | FStar_Syntax_Syntax.U_succ u1 -> int_of_univ (n + Prims.int_one) u1
-      | uu___1 -> (n, (FStar_Pervasives_Native.Some u))
-let rec (univ_to_string : FStar_Syntax_Syntax.universe -> Prims.string) =
-  fun u ->
-    FStar_Errors.with_ctx "While printing universe"
-      (fun uu___ ->
-         let uu___1 = FStar_Syntax_Subst.compress_univ u in
-         match uu___1 with
-         | FStar_Syntax_Syntax.U_unif u1 ->
-             let uu___2 = univ_uvar_to_string u1 in
-             Prims.op_Hat "U_unif " uu___2
-         | FStar_Syntax_Syntax.U_name x ->
-             let uu___2 = FStar_Ident.string_of_id x in
-             Prims.op_Hat "U_name " uu___2
-         | FStar_Syntax_Syntax.U_bvar x ->
-             let uu___2 = FStar_Compiler_Util.string_of_int x in
-             Prims.op_Hat "@" uu___2
-         | FStar_Syntax_Syntax.U_zero -> "0"
-         | FStar_Syntax_Syntax.U_succ u1 ->
-             let uu___2 = int_of_univ Prims.int_one u1 in
-             (match uu___2 with
-              | (n, FStar_Pervasives_Native.None) ->
-                  FStar_Compiler_Util.string_of_int n
-              | (n, FStar_Pervasives_Native.Some u2) ->
-                  let uu___3 = univ_to_string u2 in
-                  let uu___4 = FStar_Compiler_Util.string_of_int n in
-                  FStar_Compiler_Util.format2 "(%s + %s)" uu___3 uu___4)
-         | FStar_Syntax_Syntax.U_max us ->
-             let uu___2 =
-               let uu___3 = FStar_Compiler_List.map univ_to_string us in
-               FStar_Compiler_Effect.op_Bar_Greater uu___3
-                 (FStar_String.concat ", ") in
-             FStar_Compiler_Util.format1 "(max %s)" uu___2
-         | FStar_Syntax_Syntax.U_unknown -> "unknown")
-let (univs_to_string : FStar_Syntax_Syntax.universes -> Prims.string) =
-  fun us ->
-    let uu___ = FStar_Compiler_List.map univ_to_string us in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let (univ_names_to_string : FStar_Syntax_Syntax.univ_names -> Prims.string) =
-  fun us ->
-    let uu___ =
-      FStar_Compiler_List.map (fun x -> FStar_Ident.string_of_id x) us in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let (qual_to_string : FStar_Syntax_Syntax.qualifier -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Assumption -> "assume"
-    | FStar_Syntax_Syntax.InternalAssumption -> "internal_assume"
-    | FStar_Syntax_Syntax.New -> "new"
-    | FStar_Syntax_Syntax.Private -> "private"
-    | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen -> "unfold"
-    | FStar_Syntax_Syntax.Inline_for_extraction -> "inline_for_extraction"
-    | FStar_Syntax_Syntax.NoExtract -> "noextract"
-    | FStar_Syntax_Syntax.Visible_default -> "visible"
-    | FStar_Syntax_Syntax.Irreducible -> "irreducible"
-    | FStar_Syntax_Syntax.Noeq -> "noeq"
-    | FStar_Syntax_Syntax.Unopteq -> "unopteq"
-    | FStar_Syntax_Syntax.Logic -> "logic"
-    | FStar_Syntax_Syntax.TotalEffect -> "total"
-    | FStar_Syntax_Syntax.Discriminator l ->
-        let uu___1 = lid_to_string l in
-        FStar_Compiler_Util.format1 "(Discriminator %s)" uu___1
-    | FStar_Syntax_Syntax.Projector (l, x) ->
-        let uu___1 = lid_to_string l in
-        let uu___2 = FStar_Ident.string_of_id x in
-        FStar_Compiler_Util.format2 "(Projector %s %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.RecordType (ns, fns) ->
-        let uu___1 =
-          let uu___2 = FStar_Ident.path_of_ns ns in
-          FStar_Ident.text_of_path uu___2 in
-        let uu___2 =
-          let uu___3 =
-            FStar_Compiler_Effect.op_Bar_Greater fns
-              (FStar_Compiler_List.map FStar_Ident.string_of_id) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3
-            (FStar_String.concat ", ") in
-        FStar_Compiler_Util.format2 "(RecordType %s %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.RecordConstructor (ns, fns) ->
-        let uu___1 =
-          let uu___2 = FStar_Ident.path_of_ns ns in
-          FStar_Ident.text_of_path uu___2 in
-        let uu___2 =
-          let uu___3 =
-            FStar_Compiler_Effect.op_Bar_Greater fns
-              (FStar_Compiler_List.map FStar_Ident.string_of_id) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3
-            (FStar_String.concat ", ") in
-        FStar_Compiler_Util.format2 "(RecordConstructor %s %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.Action eff_lid ->
-        let uu___1 = lid_to_string eff_lid in
-        FStar_Compiler_Util.format1 "(Action %s)" uu___1
-    | FStar_Syntax_Syntax.ExceptionConstructor -> "ExceptionConstructor"
-    | FStar_Syntax_Syntax.HasMaskedEffect -> "HasMaskedEffect"
-    | FStar_Syntax_Syntax.Effect -> "Effect"
-    | FStar_Syntax_Syntax.Reifiable -> "reify"
-    | FStar_Syntax_Syntax.Reflectable l ->
-        let uu___1 = FStar_Ident.string_of_lid l in
-        FStar_Compiler_Util.format1 "(reflect %s)" uu___1
-    | FStar_Syntax_Syntax.OnlyName -> "OnlyName"
-let (quals_to_string :
-  FStar_Syntax_Syntax.qualifier Prims.list -> Prims.string) =
-  fun quals ->
-    match quals with
-    | [] -> ""
-    | uu___ ->
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater quals
-            (FStar_Compiler_List.map qual_to_string) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1 (FStar_String.concat " ")
-let (quals_to_string' :
-  FStar_Syntax_Syntax.qualifier Prims.list -> Prims.string) =
-  fun quals ->
-    match quals with
-    | [] -> ""
-    | uu___ -> let uu___1 = quals_to_string quals in Prims.op_Hat uu___1 " "
-let (paren : Prims.string -> Prims.string) =
-  fun s -> Prims.op_Hat "(" (Prims.op_Hat s ")")
-let rec (tag_of_term : FStar_Syntax_Syntax.term -> Prims.string) =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_bvar x ->
-        let uu___ = db_to_string x in Prims.op_Hat "Tm_bvar: " uu___
-    | FStar_Syntax_Syntax.Tm_name x ->
-        let uu___ = nm_to_string x in Prims.op_Hat "Tm_name: " uu___
-    | FStar_Syntax_Syntax.Tm_fvar x ->
-        let uu___ =
-          lid_to_string (x.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-        Prims.op_Hat "Tm_fvar: " uu___
-    | FStar_Syntax_Syntax.Tm_uinst uu___ -> "Tm_uinst"
-    | FStar_Syntax_Syntax.Tm_constant uu___ -> "Tm_constant"
-    | FStar_Syntax_Syntax.Tm_type uu___ -> "Tm_type"
-    | FStar_Syntax_Syntax.Tm_quoted
-        (uu___,
-         { FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_static;
-           FStar_Syntax_Syntax.antiquotes = uu___1;_})
-        -> "Tm_quoted (static)"
-    | FStar_Syntax_Syntax.Tm_quoted
-        (uu___,
-         { FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_dynamic;
-           FStar_Syntax_Syntax.antiquotes = uu___1;_})
-        -> "Tm_quoted (dynamic)"
-    | FStar_Syntax_Syntax.Tm_abs uu___ -> "Tm_abs"
-    | FStar_Syntax_Syntax.Tm_arrow uu___ -> "Tm_arrow"
-    | FStar_Syntax_Syntax.Tm_refine uu___ -> "Tm_refine"
-    | FStar_Syntax_Syntax.Tm_app uu___ -> "Tm_app"
-    | FStar_Syntax_Syntax.Tm_match uu___ -> "Tm_match"
-    | FStar_Syntax_Syntax.Tm_ascribed uu___ -> "Tm_ascribed"
-    | FStar_Syntax_Syntax.Tm_let uu___ -> "Tm_let"
-    | FStar_Syntax_Syntax.Tm_uvar uu___ -> "Tm_uvar"
-    | FStar_Syntax_Syntax.Tm_delayed uu___ -> "Tm_delayed"
-    | FStar_Syntax_Syntax.Tm_meta (uu___, m) ->
-        let uu___1 = metadata_to_string m in Prims.op_Hat "Tm_meta:" uu___1
-    | FStar_Syntax_Syntax.Tm_unknown -> "Tm_unknown"
-    | FStar_Syntax_Syntax.Tm_lazy uu___ -> "Tm_lazy"
-and (term_to_string : FStar_Syntax_Syntax.term -> Prims.string) =
-  fun x ->
-    let uu___ =
-      let uu___1 = FStar_Options.ugly () in Prims.op_Negation uu___1 in
-    if uu___
-    then FStar_Syntax_Print_Pretty.term_to_string x
-    else
-      FStar_Errors.with_ctx "While ugly-printing a term"
-        (fun uu___2 ->
-           let x1 = FStar_Syntax_Subst.compress x in
-           let x2 =
-             let uu___3 = FStar_Options.print_implicits () in
-             if uu___3 then x1 else FStar_Syntax_Util.unmeta x1 in
-           match x2.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_delayed uu___3 -> failwith "impossible"
-           | FStar_Syntax_Syntax.Tm_app (uu___3, []) ->
-               failwith "Empty args!"
-           | FStar_Syntax_Syntax.Tm_lazy
-               { FStar_Syntax_Syntax.blob = b;
-                 FStar_Syntax_Syntax.lkind =
-                   FStar_Syntax_Syntax.Lazy_embedding (uu___3, thunk);
-                 FStar_Syntax_Syntax.ltyp = uu___4;
-                 FStar_Syntax_Syntax.rng = uu___5;_}
-               ->
-               let uu___6 =
-                 let uu___7 =
-                   let uu___8 = FStar_Thunk.force thunk in
-                   term_to_string uu___8 in
-                 Prims.op_Hat uu___7 "]" in
-               Prims.op_Hat "[LAZYEMB:" uu___6
-           | FStar_Syntax_Syntax.Tm_lazy i ->
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 =
-                         FStar_Compiler_Effect.op_Bang
-                           FStar_Syntax_Syntax.lazy_chooser in
-                       FStar_Compiler_Util.must uu___7 in
-                     uu___6 i.FStar_Syntax_Syntax.lkind i in
-                   term_to_string uu___5 in
-                 Prims.op_Hat uu___4 "]" in
-               Prims.op_Hat "[lazy:" uu___3
-           | FStar_Syntax_Syntax.Tm_quoted (tm, qi) ->
-               (match qi.FStar_Syntax_Syntax.qkind with
-                | FStar_Syntax_Syntax.Quote_static ->
-                    let print_aq uu___3 =
-                      match uu___3 with
-                      | (bv, t) ->
-                          let uu___4 = bv_to_string bv in
-                          let uu___5 = term_to_string t in
-                          FStar_Compiler_Util.format2 "%s -> %s" uu___4
-                            uu___5 in
-                    let uu___3 = term_to_string tm in
-                    let uu___4 =
-                      (FStar_Common.string_of_list ()) print_aq
-                        qi.FStar_Syntax_Syntax.antiquotes in
-                    FStar_Compiler_Util.format2 "`(%s)%s" uu___3 uu___4
-                | FStar_Syntax_Syntax.Quote_dynamic ->
-                    let uu___3 = term_to_string tm in
-                    FStar_Compiler_Util.format1 "quote (%s)" uu___3)
-           | FStar_Syntax_Syntax.Tm_meta
-               (t, FStar_Syntax_Syntax.Meta_pattern (uu___3, ps)) ->
-               let pats =
-                 let uu___4 =
-                   FStar_Compiler_Effect.op_Bar_Greater ps
-                     (FStar_Compiler_List.map
-                        (fun args ->
-                           let uu___5 =
-                             FStar_Compiler_Effect.op_Bar_Greater args
-                               (FStar_Compiler_List.map
-                                  (fun uu___6 ->
-                                     match uu___6 with
-                                     | (t1, uu___7) -> term_to_string t1)) in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___5
-                             (FStar_String.concat "; "))) in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___4
-                   (FStar_String.concat "\\/") in
-               let uu___4 = term_to_string t in
-               FStar_Compiler_Util.format2 "{:pattern %s} %s" pats uu___4
-           | FStar_Syntax_Syntax.Tm_meta
-               (t, FStar_Syntax_Syntax.Meta_monadic (m, t')) ->
-               let uu___3 = sli m in
-               let uu___4 = term_to_string t' in
-               let uu___5 = tag_of_term t in
-               let uu___6 = term_to_string t in
-               FStar_Compiler_Util.format4 "(MetaMonadic-{%s %s} (%s) %s)"
-                 uu___3 uu___4 uu___5 uu___6
-           | FStar_Syntax_Syntax.Tm_meta
-               (t, FStar_Syntax_Syntax.Meta_monadic_lift (m0, m1, t')) ->
-               let uu___3 = term_to_string t' in
-               let uu___4 = sli m0 in
-               let uu___5 = sli m1 in
-               let uu___6 = term_to_string t in
-               FStar_Compiler_Util.format4
-                 "(MetaMonadicLift-{%s : %s -> %s} %s)" uu___3 uu___4 uu___5
-                 uu___6
-           | FStar_Syntax_Syntax.Tm_meta
-               (t, FStar_Syntax_Syntax.Meta_labeled (l, r, b)) ->
-               let uu___3 = FStar_Compiler_Range.string_of_range r in
-               let uu___4 = term_to_string t in
-               FStar_Compiler_Util.format3 "Meta_labeled(%s, %s){%s}" l
-                 uu___3 uu___4
-           | FStar_Syntax_Syntax.Tm_meta
-               (t, FStar_Syntax_Syntax.Meta_named l) ->
-               let uu___3 = lid_to_string l in
-               let uu___4 =
-                 FStar_Compiler_Range.string_of_range
-                   t.FStar_Syntax_Syntax.pos in
-               let uu___5 = term_to_string t in
-               FStar_Compiler_Util.format3 "Meta_named(%s, %s){%s}" uu___3
-                 uu___4 uu___5
-           | FStar_Syntax_Syntax.Tm_meta
-               (t, FStar_Syntax_Syntax.Meta_desugared uu___3) ->
-               let uu___4 = term_to_string t in
-               FStar_Compiler_Util.format1 "Meta_desugared{%s}" uu___4
-           | FStar_Syntax_Syntax.Tm_bvar x3 ->
-               let uu___3 = db_to_string x3 in
-               let uu___4 =
-                 let uu___5 =
-                   let uu___6 = tag_of_term x3.FStar_Syntax_Syntax.sort in
-                   Prims.op_Hat uu___6 ")" in
-                 Prims.op_Hat ":(" uu___5 in
-               Prims.op_Hat uu___3 uu___4
-           | FStar_Syntax_Syntax.Tm_name x3 -> nm_to_string x3
-           | FStar_Syntax_Syntax.Tm_fvar f ->
-               let pref =
-                 match f.FStar_Syntax_Syntax.fv_qual with
-                 | FStar_Pervasives_Native.Some
-                     (FStar_Syntax_Syntax.Unresolved_projector uu___3) ->
-                     "(Unresolved_projector)"
-                 | FStar_Pervasives_Native.Some
-                     (FStar_Syntax_Syntax.Unresolved_constructor uu___3) ->
-                     "(Unresolved_constructor)"
-                 | uu___3 -> "" in
-               let uu___3 = fv_to_string f in Prims.op_Hat pref uu___3
-           | FStar_Syntax_Syntax.Tm_uvar (u, ([], uu___3)) ->
-               let uu___4 =
-                 (FStar_Options.print_bound_var_types ()) &&
-                   (FStar_Options.print_effect_args ()) in
-               if uu___4
-               then ctx_uvar_to_string_aux true u
-               else
-                 (let uu___6 =
-                    let uu___7 =
-                      FStar_Syntax_Unionfind.uvar_id
-                        u.FStar_Syntax_Syntax.ctx_uvar_head in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      FStar_Compiler_Util.string_of_int uu___7 in
-                  Prims.op_Hat "?" uu___6)
-           | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-               let uu___3 =
-                 (FStar_Options.print_bound_var_types ()) &&
-                   (FStar_Options.print_effect_args ()) in
-               if uu___3
-               then
-                 let uu___4 = ctx_uvar_to_string_aux true u in
-                 let uu___5 =
-                   let uu___6 =
-                     FStar_Compiler_List.map subst_to_string
-                       (FStar_Pervasives_Native.fst s) in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___6
-                     (FStar_String.concat "; ") in
-                 FStar_Compiler_Util.format2 "(%s @ %s)" uu___4 uu___5
-               else
-                 (let uu___5 =
-                    let uu___6 =
-                      FStar_Syntax_Unionfind.uvar_id
-                        u.FStar_Syntax_Syntax.ctx_uvar_head in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      FStar_Compiler_Util.string_of_int uu___6 in
-                  Prims.op_Hat "?" uu___5)
-           | FStar_Syntax_Syntax.Tm_constant c -> const_to_string c
-           | FStar_Syntax_Syntax.Tm_type u ->
-               let uu___3 = FStar_Options.print_universes () in
-               if uu___3
-               then
-                 let uu___4 = univ_to_string u in
-                 FStar_Compiler_Util.format1 "Type u#(%s)" uu___4
-               else "Type"
-           | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-               let uu___3 = binders_to_string " -> " bs in
-               let uu___4 = comp_to_string c in
-               FStar_Compiler_Util.format2 "(%s -> %s)" uu___3 uu___4
-           | FStar_Syntax_Syntax.Tm_abs (bs, t2, lc) ->
-               (match lc with
-                | FStar_Pervasives_Native.Some rc when
-                    FStar_Options.print_implicits () ->
-                    let uu___3 = binders_to_string " " bs in
-                    let uu___4 = term_to_string t2 in
-                    let uu___5 =
-                      FStar_Ident.string_of_lid
-                        rc.FStar_Syntax_Syntax.residual_effect in
-                    let uu___6 =
-                      if
-                        FStar_Compiler_Option.isNone
-                          rc.FStar_Syntax_Syntax.residual_typ
-                      then "None"
-                      else
-                        (let uu___8 =
-                           FStar_Compiler_Option.get
-                             rc.FStar_Syntax_Syntax.residual_typ in
-                         term_to_string uu___8) in
-                    FStar_Compiler_Util.format4
-                      "(fun %s -> (%s $$ (residual) %s %s))" uu___3 uu___4
-                      uu___5 uu___6
-                | uu___3 ->
-                    let uu___4 = binders_to_string " " bs in
-                    let uu___5 = term_to_string t2 in
-                    FStar_Compiler_Util.format2 "(fun %s -> %s)" uu___4
-                      uu___5)
-           | FStar_Syntax_Syntax.Tm_refine (xt, f) ->
-               let uu___3 = bv_to_string xt in
-               let uu___4 =
-                 FStar_Compiler_Effect.op_Bar_Greater
-                   xt.FStar_Syntax_Syntax.sort term_to_string in
-               let uu___5 =
-                 FStar_Compiler_Effect.op_Bar_Greater f formula_to_string in
-               FStar_Compiler_Util.format3 "(%s:%s{%s})" uu___3 uu___4 uu___5
-           | FStar_Syntax_Syntax.Tm_app (t, args) ->
-               let uu___3 = term_to_string t in
-               let uu___4 = args_to_string args in
-               FStar_Compiler_Util.format2 "(%s %s)" uu___3 uu___4
-           | FStar_Syntax_Syntax.Tm_let (lbs, e) ->
-               let uu___3 = lbs_to_string [] lbs in
-               let uu___4 = term_to_string e in
-               FStar_Compiler_Util.format2 "%s\nin\n%s" uu___3 uu___4
-           | FStar_Syntax_Syntax.Tm_ascribed (e, (annot, topt, b), eff_name)
-               ->
-               let annot1 =
-                 match annot with
-                 | FStar_Pervasives.Inl t ->
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Compiler_Util.map_opt eff_name
-                           FStar_Ident.string_of_lid in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         (FStar_Compiler_Util.dflt "default") in
-                     let uu___4 = term_to_string t in
-                     FStar_Compiler_Util.format2 "[%s] %s" uu___3 uu___4
-                 | FStar_Pervasives.Inr c -> comp_to_string c in
-               let topt1 =
-                 match topt with
-                 | FStar_Pervasives_Native.None -> ""
-                 | FStar_Pervasives_Native.Some t ->
-                     let uu___3 = term_to_string t in
-                     FStar_Compiler_Util.format1 "by %s" uu___3 in
-               let s = if b then "ascribed_eq" else "ascribed" in
-               let uu___3 = term_to_string e in
-               FStar_Compiler_Util.format4 "(%s <%s: %s %s)" uu___3 s annot1
-                 topt1
-           | FStar_Syntax_Syntax.Tm_match (head, asc_opt, branches, lc) ->
-               let lc_str =
-                 match lc with
-                 | FStar_Pervasives_Native.Some lc1 when
-                     FStar_Options.print_implicits () ->
-                     let uu___3 =
-                       if
-                         FStar_Compiler_Option.isNone
-                           lc1.FStar_Syntax_Syntax.residual_typ
-                       then "None"
-                       else
-                         (let uu___5 =
-                            FStar_Compiler_Option.get
-                              lc1.FStar_Syntax_Syntax.residual_typ in
-                          term_to_string uu___5) in
-                     FStar_Compiler_Util.format1 " (residual_comp:%s)" uu___3
-                 | uu___3 -> "" in
-               let uu___3 = term_to_string head in
-               let uu___4 =
-                 match asc_opt with
-                 | FStar_Pervasives_Native.None -> ""
-                 | FStar_Pervasives_Native.Some (b, (asc, tacopt, use_eq)) ->
-                     let s = if use_eq then "returns$" else "returns" in
-                     let uu___5 = binder_to_string b in
-                     let uu___6 =
-                       match asc with
-                       | FStar_Pervasives.Inl t -> term_to_string t
-                       | FStar_Pervasives.Inr c -> comp_to_string c in
-                     let uu___7 =
-                       match tacopt with
-                       | FStar_Pervasives_Native.None -> ""
-                       | FStar_Pervasives_Native.Some tac ->
-                           let uu___8 = term_to_string tac in
-                           FStar_Compiler_Util.format1 " by %s" uu___8 in
-                     FStar_Compiler_Util.format4 "as %s %s %s%s " uu___5 s
-                       uu___6 uu___7 in
-               let uu___5 =
-                 let uu___6 =
-                   FStar_Compiler_Effect.op_Bar_Greater branches
-                     (FStar_Compiler_List.map branch_to_string) in
-                 FStar_Compiler_Util.concat_l "\n\t|" uu___6 in
-               FStar_Compiler_Util.format4 "(match %s %swith\n\t| %s%s)"
-                 uu___3 uu___4 uu___5 lc_str
-           | FStar_Syntax_Syntax.Tm_uinst (t, us) ->
-               let uu___3 = FStar_Options.print_universes () in
-               if uu___3
-               then
-                 let uu___4 = term_to_string t in
-                 let uu___5 = univs_to_string us in
-                 FStar_Compiler_Util.format2 "%s<%s>" uu___4 uu___5
-               else term_to_string t
-           | FStar_Syntax_Syntax.Tm_unknown -> "_")
-and (branch_to_string : FStar_Syntax_Syntax.branch -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | (p, wopt, e) ->
-        let uu___1 = FStar_Compiler_Effect.op_Bar_Greater p pat_to_string in
-        let uu___2 =
-          match wopt with
-          | FStar_Pervasives_Native.None -> ""
-          | FStar_Pervasives_Native.Some w ->
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater w term_to_string in
-              FStar_Compiler_Util.format1 "when %s" uu___3 in
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater e term_to_string in
-        FStar_Compiler_Util.format3 "%s %s -> %s" uu___1 uu___2 uu___3
-and (ctx_uvar_to_string_aux :
-  Prims.bool -> FStar_Syntax_Syntax.ctx_uvar -> Prims.string) =
-  fun print_reason ->
-    fun ctx_uvar ->
-      let reason_string =
-        if print_reason
-        then
-          FStar_Compiler_Util.format1 "(* %s *)\n"
-            ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_reason
-        else
-          (let uu___1 =
-             let uu___2 =
-               FStar_Compiler_Range.start_of_range
-                 ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_range in
-             FStar_Compiler_Range.string_of_pos uu___2 in
-           let uu___2 =
-             let uu___3 =
-               FStar_Compiler_Range.end_of_range
-                 ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_range in
-             FStar_Compiler_Range.string_of_pos uu___3 in
-           FStar_Compiler_Util.format2 "(%s-%s) " uu___1 uu___2) in
-      let uu___ =
-        binders_to_string ", " ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_binders in
-      let uu___1 = uvar_to_string ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_head in
-      let uu___2 =
-        let uu___3 = FStar_Syntax_Util.ctx_uvar_typ ctx_uvar in
-        term_to_string uu___3 in
-      let uu___3 =
-        let uu___4 = FStar_Syntax_Util.ctx_uvar_should_check ctx_uvar in
-        match uu___4 with
-        | FStar_Syntax_Syntax.Allow_unresolved s ->
-            Prims.op_Hat "Allow_unresolved " s
-        | FStar_Syntax_Syntax.Allow_untyped s ->
-            Prims.op_Hat "Allow_untyped " s
-        | FStar_Syntax_Syntax.Allow_ghost s -> Prims.op_Hat "Allow_ghost " s
-        | FStar_Syntax_Syntax.Strict -> "Strict"
-        | FStar_Syntax_Syntax.Already_checked -> "Already_checked" in
-      FStar_Compiler_Util.format5 "%s(%s |- %s : %s) %s" reason_string uu___
-        uu___1 uu___2 uu___3
-and (subst_elt_to_string : FStar_Syntax_Syntax.subst_elt -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.DB (i, x) ->
-        let uu___1 = FStar_Compiler_Util.string_of_int i in
-        let uu___2 = bv_to_string x in
-        FStar_Compiler_Util.format2 "DB (%s, %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.NM (x, i) ->
-        let uu___1 = bv_to_string x in
-        let uu___2 = FStar_Compiler_Util.string_of_int i in
-        FStar_Compiler_Util.format2 "NM (%s, %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.NT (x, t) ->
-        let uu___1 = bv_to_string x in
-        let uu___2 = term_to_string t in
-        FStar_Compiler_Util.format2 "NT (%s, %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.UN (i, u) ->
-        let uu___1 = FStar_Compiler_Util.string_of_int i in
-        let uu___2 = univ_to_string u in
-        FStar_Compiler_Util.format2 "UN (%s, %s)" uu___1 uu___2
-    | FStar_Syntax_Syntax.UD (u, i) ->
-        let uu___1 = FStar_Ident.string_of_id u in
-        let uu___2 = FStar_Compiler_Util.string_of_int i in
-        FStar_Compiler_Util.format2 "UD (%s, %s)" uu___1 uu___2
-and (subst_to_string : FStar_Syntax_Syntax.subst_t -> Prims.string) =
-  fun s ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater s
-        (FStar_Compiler_List.map subst_elt_to_string) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "; ")
-and (pat_to_string : FStar_Syntax_Syntax.pat -> Prims.string) =
-  fun x ->
-    let uu___ =
-      let uu___1 = FStar_Options.ugly () in Prims.op_Negation uu___1 in
-    if uu___
-    then FStar_Syntax_Print_Pretty.pat_to_string x
-    else
-      (match x.FStar_Syntax_Syntax.v with
-       | FStar_Syntax_Syntax.Pat_cons (l, us_opt, pats) ->
-           let uu___2 = fv_to_string l in
-           let uu___3 =
-             let uu___4 =
-               let uu___5 = FStar_Options.print_universes () in
-               Prims.op_Negation uu___5 in
-             if uu___4
-             then " "
-             else
-               (match us_opt with
-                | FStar_Pervasives_Native.None -> " "
-                | FStar_Pervasives_Native.Some us ->
-                    let uu___6 =
-                      let uu___7 = FStar_Compiler_List.map univ_to_string us in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___7
-                        (FStar_String.concat " ") in
-                    FStar_Compiler_Util.format1 " %s " uu___6) in
-           let uu___4 =
-             let uu___5 =
-               FStar_Compiler_List.map
-                 (fun uu___6 ->
-                    match uu___6 with
-                    | (x1, b) ->
-                        let p = pat_to_string x1 in
-                        if b then Prims.op_Hat "#" p else p) pats in
-             FStar_Compiler_Effect.op_Bar_Greater uu___5
-               (FStar_String.concat " ") in
-           FStar_Compiler_Util.format3 "(%s%s%s)" uu___2 uu___3 uu___4
-       | FStar_Syntax_Syntax.Pat_dot_term topt ->
-           let uu___2 = FStar_Options.print_bound_var_types () in
-           if uu___2
-           then
-             let uu___3 =
-               if topt = FStar_Pervasives_Native.None
-               then "_"
-               else
-                 (let uu___5 =
-                    FStar_Compiler_Effect.op_Bar_Greater topt
-                      FStar_Compiler_Util.must in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___5 term_to_string) in
-             FStar_Compiler_Util.format1 ".%s" uu___3
-           else "._"
-       | FStar_Syntax_Syntax.Pat_var x1 ->
-           let uu___2 = FStar_Options.print_bound_var_types () in
-           if uu___2
-           then
-             let uu___3 = bv_to_string x1 in
-             let uu___4 = term_to_string x1.FStar_Syntax_Syntax.sort in
-             FStar_Compiler_Util.format2 "%s:%s" uu___3 uu___4
-           else bv_to_string x1
-       | FStar_Syntax_Syntax.Pat_constant c -> const_to_string c
-       | FStar_Syntax_Syntax.Pat_wild x1 ->
-           let uu___2 = FStar_Options.print_bound_var_types () in
-           if uu___2
-           then
-             let uu___3 = bv_to_string x1 in
-             let uu___4 = term_to_string x1.FStar_Syntax_Syntax.sort in
-             FStar_Compiler_Util.format2 "_wild_%s:%s" uu___3 uu___4
-           else bv_to_string x1)
-and (lbs_to_string :
-  FStar_Syntax_Syntax.qualifier Prims.list ->
-    FStar_Syntax_Syntax.letbindings -> Prims.string)
-  =
-  fun quals ->
-    fun lbs ->
-      let uu___ = quals_to_string' quals in
-      let uu___1 =
-        let uu___2 =
-          FStar_Compiler_Effect.op_Bar_Greater
-            (FStar_Pervasives_Native.snd lbs)
-            (FStar_Compiler_List.map
-               (fun lb ->
-                  let uu___3 = attrs_to_string lb.FStar_Syntax_Syntax.lbattrs in
-                  let uu___4 = lbname_to_string lb.FStar_Syntax_Syntax.lbname in
-                  let uu___5 =
-                    let uu___6 = FStar_Options.print_universes () in
-                    if uu___6
-                    then
-                      let uu___7 =
-                        let uu___8 =
-                          univ_names_to_string lb.FStar_Syntax_Syntax.lbunivs in
-                        Prims.op_Hat uu___8 ">" in
-                      Prims.op_Hat "<" uu___7
-                    else "" in
-                  let uu___6 = term_to_string lb.FStar_Syntax_Syntax.lbtyp in
-                  let uu___7 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      lb.FStar_Syntax_Syntax.lbdef term_to_string in
-                  FStar_Compiler_Util.format5 "%s%s %s : %s = %s" uu___3
-                    uu___4 uu___5 uu___6 uu___7)) in
-        FStar_Compiler_Util.concat_l "\n and " uu___2 in
-      FStar_Compiler_Util.format3 "%slet %s %s" uu___
-        (if FStar_Pervasives_Native.fst lbs then "rec" else "") uu___1
-and (attrs_to_string :
-  FStar_Syntax_Syntax.attribute Prims.list -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | [] -> ""
-    | tms ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_List.map
-              (fun t -> let uu___3 = term_to_string t in paren uu___3) tms in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (FStar_String.concat "; ") in
-        FStar_Compiler_Util.format1 "[@ %s]" uu___1
-and (bqual_to_string' :
-  Prims.string ->
-    FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-      Prims.string)
-  =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit (false))
-          -> Prims.op_Hat "#" s
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit (true)) ->
-          Prims.op_Hat "#." s
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality) ->
-          Prims.op_Hat "$" s
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) when
-          FStar_Syntax_Util.is_fvar FStar_Parser_Const.tcresolve_lid t ->
-          Prims.op_Hat "{|" (Prims.op_Hat s "|}")
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-          let uu___1 =
-            let uu___2 = term_to_string t in
-            Prims.op_Hat uu___2 (Prims.op_Hat "]" s) in
-          Prims.op_Hat "#[" uu___1
-      | FStar_Pervasives_Native.None -> s
-and (aqual_to_string' :
-  Prims.string ->
-    FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option ->
-      Prims.string)
-  =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          { FStar_Syntax_Syntax.aqual_implicit = true;
-            FStar_Syntax_Syntax.aqual_attributes = uu___1;_}
-          -> Prims.op_Hat "#" s
-      | uu___1 -> s
-and (binder_to_string' :
-  Prims.bool -> FStar_Syntax_Syntax.binder -> Prims.string) =
-  fun is_arrow ->
-    fun b ->
-      let uu___ =
-        let uu___1 = FStar_Options.ugly () in Prims.op_Negation uu___1 in
-      if uu___
-      then FStar_Syntax_Print_Pretty.binder_to_string' is_arrow b
-      else
-        (let attrs = attrs_to_string b.FStar_Syntax_Syntax.binder_attrs in
-         let uu___2 = FStar_Syntax_Syntax.is_null_binder b in
-         if uu___2
-         then
-           let uu___3 =
-             let uu___4 =
-               term_to_string
-                 (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-             Prims.op_Hat "_:" uu___4 in
-           Prims.op_Hat attrs uu___3
-         else
-           (let uu___4 =
-              (Prims.op_Negation is_arrow) &&
-                (let uu___5 = FStar_Options.print_bound_var_types () in
-                 Prims.op_Negation uu___5) in
-            if uu___4
-            then
-              let uu___5 =
-                let uu___6 = nm_to_string b.FStar_Syntax_Syntax.binder_bv in
-                Prims.op_Hat attrs uu___6 in
-              bqual_to_string' uu___5 b.FStar_Syntax_Syntax.binder_qual
-            else
-              (let uu___6 =
-                 let uu___7 =
-                   let uu___8 = nm_to_string b.FStar_Syntax_Syntax.binder_bv in
-                   let uu___9 =
-                     let uu___10 =
-                       term_to_string
-                         (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                     Prims.op_Hat ":" uu___10 in
-                   Prims.op_Hat uu___8 uu___9 in
-                 Prims.op_Hat attrs uu___7 in
-               bqual_to_string' uu___6 b.FStar_Syntax_Syntax.binder_qual)))
-and (binder_to_string : FStar_Syntax_Syntax.binder -> Prims.string) =
-  fun b -> binder_to_string' false b
-and (arrow_binder_to_string : FStar_Syntax_Syntax.binder -> Prims.string) =
-  fun b -> binder_to_string' true b
-and (binders_to_string :
-  Prims.string -> FStar_Syntax_Syntax.binders -> Prims.string) =
-  fun sep ->
-    fun bs ->
-      let bs1 =
-        let uu___ = FStar_Options.print_implicits () in
-        if uu___ then bs else filter_imp_binders bs in
-      if sep = " -> "
-      then
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater bs1
-            (FStar_Compiler_List.map arrow_binder_to_string) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat sep)
-      else
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Bar_Greater bs1
-             (FStar_Compiler_List.map binder_to_string) in
-         FStar_Compiler_Effect.op_Bar_Greater uu___1
-           (FStar_String.concat sep))
-and (arg_to_string :
-  (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.arg_qualifier
-    FStar_Pervasives_Native.option) -> Prims.string)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (a, imp) ->
-        let uu___1 = term_to_string a in aqual_to_string' uu___1 imp
-and (args_to_string : FStar_Syntax_Syntax.args -> Prims.string) =
-  fun args ->
-    let args1 =
-      let uu___ = FStar_Options.print_implicits () in
-      if uu___ then args else filter_imp_args args in
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater args1
-        (FStar_Compiler_List.map arg_to_string) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat " ")
-and (comp_to_string : FStar_Syntax_Syntax.comp -> Prims.string) =
-  fun c ->
-    let uu___ =
-      let uu___1 = FStar_Options.ugly () in Prims.op_Negation uu___1 in
-    if uu___
-    then FStar_Syntax_Print_Pretty.comp_to_string c
-    else
-      FStar_Errors.with_ctx "While ugly-printing a computation"
-        (fun uu___2 ->
-           match c.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Total t ->
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Subst.compress t in
-                 uu___4.FStar_Syntax_Syntax.n in
-               (match uu___3 with
-                | FStar_Syntax_Syntax.Tm_type uu___4 when
-                    let uu___5 =
-                      (FStar_Options.print_implicits ()) ||
-                        (FStar_Options.print_universes ()) in
-                    Prims.op_Negation uu___5 -> term_to_string t
-                | uu___4 ->
-                    let uu___5 = term_to_string t in
-                    FStar_Compiler_Util.format1 "Tot %s" uu___5)
-           | FStar_Syntax_Syntax.GTotal t ->
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Subst.compress t in
-                 uu___4.FStar_Syntax_Syntax.n in
-               (match uu___3 with
-                | FStar_Syntax_Syntax.Tm_type uu___4 when
-                    let uu___5 =
-                      (FStar_Options.print_implicits ()) ||
-                        (FStar_Options.print_universes ()) in
-                    Prims.op_Negation uu___5 -> term_to_string t
-                | uu___4 ->
-                    let uu___5 = term_to_string t in
-                    FStar_Compiler_Util.format1 "GTot %s" uu___5)
-           | FStar_Syntax_Syntax.Comp c1 ->
-               let basic =
-                 let uu___3 = FStar_Options.print_effect_args () in
-                 if uu___3
-                 then
-                   let uu___4 = sli c1.FStar_Syntax_Syntax.effect_name in
-                   let uu___5 =
-                     let uu___6 =
-                       FStar_Compiler_Effect.op_Bar_Greater
-                         c1.FStar_Syntax_Syntax.comp_univs
-                         (FStar_Compiler_List.map univ_to_string) in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___6
-                       (FStar_String.concat ", ") in
-                   let uu___6 =
-                     term_to_string c1.FStar_Syntax_Syntax.result_typ in
-                   let uu___7 =
-                     let uu___8 =
-                       FStar_Compiler_Effect.op_Bar_Greater
-                         c1.FStar_Syntax_Syntax.effect_args
-                         (FStar_Compiler_List.map arg_to_string) in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___8
-                       (FStar_String.concat ", ") in
-                   let uu___8 = cflags_to_string c1.FStar_Syntax_Syntax.flags in
-                   FStar_Compiler_Util.format5
-                     "%s<%s> (%s) %s (attributes %s)" uu___4 uu___5 uu___6
-                     uu___7 uu___8
-                 else
-                   (let uu___5 =
-                      (FStar_Compiler_Effect.op_Bar_Greater
-                         c1.FStar_Syntax_Syntax.flags
-                         (FStar_Compiler_Util.for_some
-                            (fun uu___6 ->
-                               match uu___6 with
-                               | FStar_Syntax_Syntax.TOTAL -> true
-                               | uu___7 -> false)))
-                        &&
-                        (let uu___6 = FStar_Options.print_effect_args () in
-                         Prims.op_Negation uu___6) in
-                    if uu___5
-                    then
-                      let uu___6 =
-                        term_to_string c1.FStar_Syntax_Syntax.result_typ in
-                      FStar_Compiler_Util.format1 "Tot %s" uu___6
-                    else
-                      (let uu___7 =
-                         ((let uu___8 = FStar_Options.print_effect_args () in
-                           Prims.op_Negation uu___8) &&
-                            (let uu___8 = FStar_Options.print_implicits () in
-                             Prims.op_Negation uu___8))
-                           &&
-                           (let uu___8 = FStar_Parser_Const.effect_ML_lid () in
-                            FStar_Ident.lid_equals
-                              c1.FStar_Syntax_Syntax.effect_name uu___8) in
-                       if uu___7
-                       then term_to_string c1.FStar_Syntax_Syntax.result_typ
-                       else
-                         (let uu___9 =
-                            (let uu___10 = FStar_Options.print_effect_args () in
-                             Prims.op_Negation uu___10) &&
-                              (FStar_Compiler_Effect.op_Bar_Greater
-                                 c1.FStar_Syntax_Syntax.flags
-                                 (FStar_Compiler_Util.for_some
-                                    (fun uu___10 ->
-                                       match uu___10 with
-                                       | FStar_Syntax_Syntax.MLEFFECT -> true
-                                       | uu___11 -> false))) in
-                          if uu___9
-                          then
-                            let uu___10 =
-                              term_to_string
-                                c1.FStar_Syntax_Syntax.result_typ in
-                            FStar_Compiler_Util.format1 "ALL %s" uu___10
-                          else
-                            (let uu___11 =
-                               sli c1.FStar_Syntax_Syntax.effect_name in
-                             let uu___12 =
-                               term_to_string
-                                 c1.FStar_Syntax_Syntax.result_typ in
-                             FStar_Compiler_Util.format2 "%s (%s)" uu___11
-                               uu___12)))) in
-               let dec =
-                 let uu___3 =
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     c1.FStar_Syntax_Syntax.flags
-                     (FStar_Compiler_List.collect
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | FStar_Syntax_Syntax.DECREASES dec_order ->
-                               (match dec_order with
-                                | FStar_Syntax_Syntax.Decreases_lex l ->
-                                    let uu___5 =
-                                      let uu___6 =
-                                        match l with
-                                        | [] -> ""
-                                        | hd::tl ->
-                                            let uu___7 =
-                                              let uu___8 = term_to_string hd in
-                                              FStar_Compiler_List.fold_left
-                                                (fun s ->
-                                                   fun t ->
-                                                     let uu___9 =
-                                                       let uu___10 =
-                                                         term_to_string t in
-                                                       Prims.op_Hat ";"
-                                                         uu___10 in
-                                                     Prims.op_Hat s uu___9)
-                                                uu___8 in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              tl uu___7 in
-                                      FStar_Compiler_Util.format1
-                                        " (decreases [%s])" uu___6 in
-                                    [uu___5]
-                                | FStar_Syntax_Syntax.Decreases_wf (rel, e)
-                                    ->
-                                    let uu___5 =
-                                      let uu___6 = term_to_string rel in
-                                      let uu___7 = term_to_string e in
-                                      FStar_Compiler_Util.format2
-                                        "(decreases {:well-founded %s %s})"
-                                        uu___6 uu___7 in
-                                    [uu___5])
-                           | uu___5 -> [])) in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                   (FStar_String.concat " ") in
-               FStar_Compiler_Util.format2 "%s%s" basic dec)
-and (cflag_to_string : FStar_Syntax_Syntax.cflag -> Prims.string) =
-  fun c ->
-    match c with
-    | FStar_Syntax_Syntax.TOTAL -> "total"
-    | FStar_Syntax_Syntax.MLEFFECT -> "ml"
-    | FStar_Syntax_Syntax.RETURN -> "return"
-    | FStar_Syntax_Syntax.PARTIAL_RETURN -> "partial_return"
-    | FStar_Syntax_Syntax.SOMETRIVIAL -> "sometrivial"
-    | FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION -> "trivial_postcondition"
-    | FStar_Syntax_Syntax.SHOULD_NOT_INLINE -> "should_not_inline"
-    | FStar_Syntax_Syntax.LEMMA -> "lemma"
-    | FStar_Syntax_Syntax.CPS -> "cps"
-    | FStar_Syntax_Syntax.DECREASES uu___ -> ""
-and (cflags_to_string : FStar_Syntax_Syntax.cflag Prims.list -> Prims.string)
-  = fun fs -> (FStar_Common.string_of_list ()) cflag_to_string fs
-and (formula_to_string :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> Prims.string) =
-  fun phi -> term_to_string phi
-and (metadata_to_string : FStar_Syntax_Syntax.metadata -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Meta_pattern (uu___1, ps) ->
-        let pats =
-          let uu___2 =
-            FStar_Compiler_Effect.op_Bar_Greater ps
-              (FStar_Compiler_List.map
-                 (fun args ->
-                    let uu___3 =
-                      FStar_Compiler_Effect.op_Bar_Greater args
-                        (FStar_Compiler_List.map
-                           (fun uu___4 ->
-                              match uu___4 with
-                              | (t, uu___5) -> term_to_string t)) in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___3
-                      (FStar_String.concat "; "))) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            (FStar_String.concat "\\/") in
-        FStar_Compiler_Util.format1 "{Meta_pattern %s}" pats
-    | FStar_Syntax_Syntax.Meta_named lid ->
-        let uu___1 = sli lid in
-        FStar_Compiler_Util.format1 "{Meta_named %s}" uu___1
-    | FStar_Syntax_Syntax.Meta_labeled (l, r, uu___1) ->
-        let uu___2 = FStar_Compiler_Range.string_of_range r in
-        FStar_Compiler_Util.format2 "{Meta_labeled (%s, %s)}" l uu___2
-    | FStar_Syntax_Syntax.Meta_desugared msi -> "{Meta_desugared}"
-    | FStar_Syntax_Syntax.Meta_monadic (m, t) ->
-        let uu___1 = sli m in
-        let uu___2 = term_to_string t in
-        FStar_Compiler_Util.format2 "{Meta_monadic(%s @ %s)}" uu___1 uu___2
-    | FStar_Syntax_Syntax.Meta_monadic_lift (m, m', t) ->
-        let uu___1 = sli m in
-        let uu___2 = sli m' in
-        let uu___3 = term_to_string t in
-        FStar_Compiler_Util.format3 "{Meta_monadic_lift(%s -> %s @ %s)}"
-          uu___1 uu___2 uu___3
-let (aqual_to_string : FStar_Syntax_Syntax.aqual -> Prims.string) =
-  fun aq -> aqual_to_string' "" aq
-let (bqual_to_string : FStar_Syntax_Syntax.bqual -> Prims.string) =
-  fun bq -> bqual_to_string' "" bq
-let (comp_to_string' :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.comp -> Prims.string) =
-  fun env ->
-    fun c ->
-      let uu___ = FStar_Options.ugly () in
-      if uu___
-      then comp_to_string c
-      else FStar_Syntax_Print_Pretty.comp_to_string' env c
-let (term_to_string' :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.term -> Prims.string) =
-  fun env ->
-    fun x ->
-      let uu___ = FStar_Options.ugly () in
-      if uu___
-      then term_to_string x
-      else FStar_Syntax_Print_Pretty.term_to_string' env x
-let (binder_to_json :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.binder -> FStar_Compiler_Util.json)
-  =
-  fun env ->
-    fun b ->
-      let n =
-        let uu___ =
-          let uu___1 = nm_to_string b.FStar_Syntax_Syntax.binder_bv in
-          bqual_to_string' uu___1 b.FStar_Syntax_Syntax.binder_qual in
-        FStar_Compiler_Util.JsonStr uu___ in
-      let t =
-        let uu___ =
-          term_to_string' env
-            (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-        FStar_Compiler_Util.JsonStr uu___ in
-      FStar_Compiler_Util.JsonAssoc [("name", n); ("type", t)]
-let (binders_to_json :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.binders -> FStar_Compiler_Util.json)
-  =
-  fun env ->
-    fun bs ->
-      let uu___ = FStar_Compiler_List.map (binder_to_json env) bs in
-      FStar_Compiler_Util.JsonList uu___
-let (enclose_universes : Prims.string -> Prims.string) =
-  fun s ->
-    let uu___ = FStar_Options.print_universes () in
-    if uu___ then Prims.op_Hat "<" (Prims.op_Hat s ">") else ""
-let (tscheme_to_string : FStar_Syntax_Syntax.tscheme -> Prims.string) =
-  fun s ->
-    let uu___ =
-      let uu___1 = FStar_Options.ugly () in Prims.op_Negation uu___1 in
-    if uu___
-    then FStar_Syntax_Print_Pretty.tscheme_to_string s
-    else
-      (let uu___2 = s in
-       match uu___2 with
-       | (us, t) ->
-           let uu___3 =
-             let uu___4 = univ_names_to_string us in
-             FStar_Compiler_Effect.op_Less_Bar enclose_universes uu___4 in
-           let uu___4 = term_to_string t in
-           FStar_Compiler_Util.format2 "%s%s" uu___3 uu___4)
-let (action_to_string : FStar_Syntax_Syntax.action -> Prims.string) =
-  fun a ->
-    let uu___ = sli a.FStar_Syntax_Syntax.action_name in
-    let uu___1 = binders_to_string " " a.FStar_Syntax_Syntax.action_params in
-    let uu___2 =
-      let uu___3 = univ_names_to_string a.FStar_Syntax_Syntax.action_univs in
-      FStar_Compiler_Effect.op_Less_Bar enclose_universes uu___3 in
-    let uu___3 = term_to_string a.FStar_Syntax_Syntax.action_typ in
-    let uu___4 = term_to_string a.FStar_Syntax_Syntax.action_defn in
-    FStar_Compiler_Util.format5 "%s%s %s : %s = %s" uu___ uu___1 uu___2
-      uu___3 uu___4
-let (wp_eff_combinators_to_string :
-  FStar_Syntax_Syntax.wp_eff_combinators -> Prims.string) =
-  fun combs ->
-    let tscheme_opt_to_string uu___ =
-      match uu___ with
-      | FStar_Pervasives_Native.Some ts -> tscheme_to_string ts
-      | FStar_Pervasives_Native.None -> "None" in
-    let uu___ =
-      let uu___1 = tscheme_to_string combs.FStar_Syntax_Syntax.ret_wp in
-      let uu___2 =
-        let uu___3 = tscheme_to_string combs.FStar_Syntax_Syntax.bind_wp in
-        let uu___4 =
-          let uu___5 = tscheme_to_string combs.FStar_Syntax_Syntax.stronger in
-          let uu___6 =
-            let uu___7 =
-              tscheme_to_string combs.FStar_Syntax_Syntax.if_then_else in
-            let uu___8 =
-              let uu___9 = tscheme_to_string combs.FStar_Syntax_Syntax.ite_wp in
-              let uu___10 =
-                let uu___11 =
-                  tscheme_to_string combs.FStar_Syntax_Syntax.close_wp in
-                let uu___12 =
-                  let uu___13 =
-                    tscheme_to_string combs.FStar_Syntax_Syntax.trivial in
-                  let uu___14 =
-                    let uu___15 =
-                      tscheme_opt_to_string combs.FStar_Syntax_Syntax.repr in
-                    let uu___16 =
-                      let uu___17 =
-                        tscheme_opt_to_string
-                          combs.FStar_Syntax_Syntax.return_repr in
-                      let uu___18 =
-                        let uu___19 =
-                          tscheme_opt_to_string
-                            combs.FStar_Syntax_Syntax.bind_repr in
-                        [uu___19] in
-                      uu___17 :: uu___18 in
-                    uu___15 :: uu___16 in
-                  uu___13 :: uu___14 in
-                uu___11 :: uu___12 in
-              uu___9 :: uu___10 in
-            uu___7 :: uu___8 in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.format
-      "{\nret_wp       = %s\n; bind_wp      = %s\n; stronger     = %s\n; if_then_else = %s\n; ite_wp       = %s\n; close_wp     = %s\n; trivial      = %s\n; repr         = %s\n; return_repr  = %s\n; bind_repr    = %s\n}\n"
-      uu___
-let (indexed_effect_binder_kind_to_string :
-  FStar_Syntax_Syntax.indexed_effect_binder_kind -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Type_binder -> "type_binder"
-    | FStar_Syntax_Syntax.Substitutive_binder -> "subst_binder"
-    | FStar_Syntax_Syntax.BindCont_no_abstraction_binder ->
-        "bind_g_no_abs_binder"
-    | FStar_Syntax_Syntax.Range_binder -> "range_binder"
-    | FStar_Syntax_Syntax.Repr_binder -> "repr_binder"
-    | FStar_Syntax_Syntax.Ad_hoc_binder -> "ad_hoc_binder"
-let (indexed_effect_combinator_kind_to_string :
-  FStar_Syntax_Syntax.indexed_effect_combinator_kind -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Substitutive_combinator l ->
-        let uu___1 =
-          (FStar_Common.string_of_list' ())
-            indexed_effect_binder_kind_to_string l in
-        FStar_Compiler_Util.format1 "standard_combinator (%s)" uu___1
-    | FStar_Syntax_Syntax.Substitutive_invariant_combinator ->
-        "substitutive_invariant"
-    | FStar_Syntax_Syntax.Ad_hoc_combinator -> "ad_hoc_combinator"
-let (indexed_effect_combinator_kind_opt_to_string :
-  FStar_Syntax_Syntax.indexed_effect_combinator_kind
-    FStar_Pervasives_Native.option -> Prims.string)
-  =
-  fun k ->
-    match k with
-    | FStar_Pervasives_Native.None -> "kind not set"
-    | FStar_Pervasives_Native.Some k1 ->
-        indexed_effect_combinator_kind_to_string k1
-let (layered_eff_combinators_to_string :
-  FStar_Syntax_Syntax.layered_eff_combinators -> Prims.string) =
-  fun combs ->
-    let to_str uu___ =
-      match uu___ with
-      | (ts_t, ts_ty, kopt) ->
-          let uu___1 = tscheme_to_string ts_t in
-          let uu___2 = tscheme_to_string ts_ty in
-          let uu___3 = indexed_effect_combinator_kind_opt_to_string kopt in
-          FStar_Compiler_Util.format3 "(%s) : (%s)<%s>" uu___1 uu___2 uu___3 in
-    let to_str2 uu___ =
-      match uu___ with
-      | (ts_t, ts_ty) ->
-          let uu___1 = tscheme_to_string ts_t in
-          let uu___2 = tscheme_to_string ts_ty in
-          FStar_Compiler_Util.format2 "(%s) : (%s)" uu___1 uu___2 in
-    let uu___ =
-      let uu___1 = to_str2 combs.FStar_Syntax_Syntax.l_repr in
-      let uu___2 =
-        let uu___3 = to_str2 combs.FStar_Syntax_Syntax.l_return in
-        let uu___4 =
-          let uu___5 = to_str combs.FStar_Syntax_Syntax.l_bind in
-          let uu___6 =
-            let uu___7 = to_str combs.FStar_Syntax_Syntax.l_subcomp in
-            let uu___8 =
-              let uu___9 = to_str combs.FStar_Syntax_Syntax.l_if_then_else in
-              [uu___9] in
-            uu___7 :: uu___8 in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.format
-      "{\n; l_repr = %s\n; l_return = %s\n; l_bind = %s\n; l_subcomp = %s\n; l_if_then_else = %s\n\n  }\n"
-      uu___
-let (eff_combinators_to_string :
-  FStar_Syntax_Syntax.eff_combinators -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        wp_eff_combinators_to_string combs
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        wp_eff_combinators_to_string combs
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        layered_eff_combinators_to_string combs
-let (eff_decl_to_string' :
-  Prims.bool ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.eff_decl -> Prims.string)
-  =
-  fun for_free ->
-    fun r ->
-      fun q ->
-        fun ed ->
-          let uu___ =
-            let uu___1 = FStar_Options.ugly () in Prims.op_Negation uu___1 in
-          if uu___
-          then FStar_Syntax_Print_Pretty.eff_decl_to_string' for_free r q ed
-          else
-            (let actions_to_string actions =
-               let uu___2 =
-                 FStar_Compiler_Effect.op_Bar_Greater actions
-                   (FStar_Compiler_List.map action_to_string) in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                 (FStar_String.concat ",\n\t") in
-             let eff_name =
-               let uu___2 = FStar_Syntax_Util.is_layered ed in
-               if uu___2 then "layered_effect" else "new_effect" in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = lid_to_string ed.FStar_Syntax_Syntax.mname in
-                   let uu___6 =
-                     let uu___7 =
-                       let uu___8 =
-                         univ_names_to_string ed.FStar_Syntax_Syntax.univs in
-                       FStar_Compiler_Effect.op_Less_Bar enclose_universes
-                         uu___8 in
-                     let uu___8 =
-                       let uu___9 =
-                         binders_to_string " " ed.FStar_Syntax_Syntax.binders in
-                       let uu___10 =
-                         let uu___11 =
-                           let uu___12 =
-                             FStar_Compiler_Effect.op_Bar_Greater
-                               ed.FStar_Syntax_Syntax.signature
-                               FStar_Syntax_Util.effect_sig_ts in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___12
-                             tscheme_to_string in
-                         let uu___12 =
-                           let uu___13 =
-                             eff_combinators_to_string
-                               ed.FStar_Syntax_Syntax.combinators in
-                           let uu___14 =
-                             let uu___15 =
-                               actions_to_string
-                                 ed.FStar_Syntax_Syntax.actions in
-                             [uu___15] in
-                           uu___13 :: uu___14 in
-                         uu___11 :: uu___12 in
-                       uu___9 :: uu___10 in
-                     uu___7 :: uu___8 in
-                   uu___5 :: uu___6 in
-                 (if for_free then "_for_free " else "") :: uu___4 in
-               eff_name :: uu___3 in
-             FStar_Compiler_Util.format
-               "%s%s { %s%s %s : %s \n  %s\nand effect_actions\n\t%s\n}\n"
-               uu___2)
-let (eff_decl_to_string :
-  Prims.bool -> FStar_Syntax_Syntax.eff_decl -> Prims.string) =
-  fun for_free ->
-    fun ed ->
-      eff_decl_to_string' for_free FStar_Compiler_Range.dummyRange [] ed
-let (sub_eff_to_string : FStar_Syntax_Syntax.sub_eff -> Prims.string) =
-  fun se ->
-    let tsopt_to_string ts_opt =
-      if FStar_Compiler_Util.is_some ts_opt
-      then
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater ts_opt
-            FStar_Compiler_Util.must in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ tscheme_to_string
-      else "<None>" in
-    let uu___ = lid_to_string se.FStar_Syntax_Syntax.source in
-    let uu___1 = lid_to_string se.FStar_Syntax_Syntax.target in
-    let uu___2 = tsopt_to_string se.FStar_Syntax_Syntax.lift in
-    let uu___3 = tsopt_to_string se.FStar_Syntax_Syntax.lift_wp in
-    FStar_Compiler_Util.format4
-      "sub_effect %s ~> %s : lift = %s ;; lift_wp = %s" uu___ uu___1 uu___2
-      uu___3
-let (pragma_to_string : FStar_Syntax_Syntax.pragma -> Prims.string) =
-  fun p ->
-    match p with
-    | FStar_Syntax_Syntax.ResetOptions (FStar_Pervasives_Native.None) ->
-        "#reset-options"
-    | FStar_Syntax_Syntax.ResetOptions (FStar_Pervasives_Native.Some s) ->
-        FStar_Compiler_Util.format1 "#reset-options \"%s\"" s
-    | FStar_Syntax_Syntax.SetOptions s ->
-        FStar_Compiler_Util.format1 "#set-options \"%s\"" s
-    | FStar_Syntax_Syntax.PushOptions (FStar_Pervasives_Native.None) ->
-        "#push-options"
-    | FStar_Syntax_Syntax.PushOptions (FStar_Pervasives_Native.Some s) ->
-        FStar_Compiler_Util.format1 "#push-options \"%s\"" s
-    | FStar_Syntax_Syntax.RestartSolver -> "#restart-solver"
-    | FStar_Syntax_Syntax.PrintEffectsGraph -> "#print-effects-graph"
-    | FStar_Syntax_Syntax.PopOptions -> "#pop-options"
-let rec (sigelt_to_string : FStar_Syntax_Syntax.sigelt -> Prims.string) =
-  fun x ->
-    let basic =
-      match x.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_pragma p -> pragma_to_string p
-      | FStar_Syntax_Syntax.Sig_inductive_typ
-          (lid, univs, tps, uu___, k, uu___1, uu___2) ->
-          let quals_str = quals_to_string' x.FStar_Syntax_Syntax.sigquals in
-          let binders_str = binders_to_string " " tps in
-          let term_str = term_to_string k in
-          let uu___3 = FStar_Options.print_universes () in
-          if uu___3
-          then
-            let uu___4 = FStar_Ident.string_of_lid lid in
-            let uu___5 = univ_names_to_string univs in
-            FStar_Compiler_Util.format5 "%stype %s<%s> %s : %s" quals_str
-              uu___4 uu___5 binders_str term_str
-          else
-            (let uu___5 = FStar_Ident.string_of_lid lid in
-             FStar_Compiler_Util.format4 "%stype %s %s : %s" quals_str uu___5
-               binders_str term_str)
-      | FStar_Syntax_Syntax.Sig_datacon
-          (lid, univs, t, uu___, uu___1, uu___2) ->
-          let uu___3 = FStar_Options.print_universes () in
-          if uu___3
-          then
-            let uu___4 = univ_names_to_string univs in
-            let uu___5 = FStar_Ident.string_of_lid lid in
-            let uu___6 = term_to_string t in
-            FStar_Compiler_Util.format3 "datacon<%s> %s : %s" uu___4 uu___5
-              uu___6
-          else
-            (let uu___5 = FStar_Ident.string_of_lid lid in
-             let uu___6 = term_to_string t in
-             FStar_Compiler_Util.format2 "datacon %s : %s" uu___5 uu___6)
-      | FStar_Syntax_Syntax.Sig_declare_typ (lid, univs, t) ->
-          let uu___ = quals_to_string' x.FStar_Syntax_Syntax.sigquals in
-          let uu___1 = FStar_Ident.string_of_lid lid in
-          let uu___2 =
-            let uu___3 = FStar_Options.print_universes () in
-            if uu___3
-            then
-              let uu___4 = univ_names_to_string univs in
-              FStar_Compiler_Util.format1 "<%s>" uu___4
-            else "" in
-          let uu___3 = term_to_string t in
-          FStar_Compiler_Util.format4 "%sval %s %s : %s" uu___ uu___1 uu___2
-            uu___3
-      | FStar_Syntax_Syntax.Sig_assume (lid, us, f) ->
-          let uu___ = FStar_Options.print_universes () in
-          if uu___
-          then
-            let uu___1 = FStar_Ident.string_of_lid lid in
-            let uu___2 = univ_names_to_string us in
-            let uu___3 = term_to_string f in
-            FStar_Compiler_Util.format3 "assume %s<%s> : %s" uu___1 uu___2
-              uu___3
-          else
-            (let uu___2 = FStar_Ident.string_of_lid lid in
-             let uu___3 = term_to_string f in
-             FStar_Compiler_Util.format2 "assume %s : %s" uu___2 uu___3)
-      | FStar_Syntax_Syntax.Sig_let (lbs, uu___) ->
-          lbs_to_string x.FStar_Syntax_Syntax.sigquals lbs
-      | FStar_Syntax_Syntax.Sig_bundle (ses, uu___) ->
-          let uu___1 =
-            let uu___2 = FStar_Compiler_List.map sigelt_to_string ses in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (FStar_String.concat "\n") in
-          Prims.op_Hat "(* Sig_bundle *)" uu___1
-      | FStar_Syntax_Syntax.Sig_fail (errs, lax, ses) ->
-          let uu___ = FStar_Compiler_Util.string_of_bool lax in
-          let uu___1 =
-            (FStar_Common.string_of_list ())
-              FStar_Compiler_Util.string_of_int errs in
-          let uu___2 =
-            let uu___3 = FStar_Compiler_List.map sigelt_to_string ses in
-            FStar_Compiler_Effect.op_Bar_Greater uu___3
-              (FStar_String.concat "\n") in
-          FStar_Compiler_Util.format3
-            "(* Sig_fail %s %s *)\n%s\n(* / Sig_fail*)\n" uu___ uu___1 uu___2
-      | FStar_Syntax_Syntax.Sig_new_effect ed ->
-          let uu___ = FStar_Syntax_Util.is_dm4f ed in
-          eff_decl_to_string' uu___ x.FStar_Syntax_Syntax.sigrng
-            x.FStar_Syntax_Syntax.sigquals ed
-      | FStar_Syntax_Syntax.Sig_sub_effect se -> sub_eff_to_string se
-      | FStar_Syntax_Syntax.Sig_effect_abbrev (l, univs, tps, c, flags) ->
-          let uu___ = FStar_Options.print_universes () in
-          if uu___
-          then
-            let uu___1 =
-              let uu___2 =
-                FStar_Syntax_Syntax.mk
-                  (FStar_Syntax_Syntax.Tm_arrow (tps, c))
-                  FStar_Compiler_Range.dummyRange in
-              FStar_Syntax_Subst.open_univ_vars univs uu___2 in
-            (match uu___1 with
-             | (univs1, t) ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Subst.compress t in
-                     uu___4.FStar_Syntax_Syntax.n in
-                   match uu___3 with
-                   | FStar_Syntax_Syntax.Tm_arrow (bs, c1) -> (bs, c1)
-                   | uu___4 -> failwith "impossible" in
-                 (match uu___2 with
-                  | (tps1, c1) ->
-                      let uu___3 = sli l in
-                      let uu___4 = univ_names_to_string univs1 in
-                      let uu___5 = binders_to_string " " tps1 in
-                      let uu___6 = comp_to_string c1 in
-                      FStar_Compiler_Util.format4 "effect %s<%s> %s = %s"
-                        uu___3 uu___4 uu___5 uu___6))
-          else
-            (let uu___2 = sli l in
-             let uu___3 = binders_to_string " " tps in
-             let uu___4 = comp_to_string c in
-             FStar_Compiler_Util.format3 "effect %s %s = %s" uu___2 uu___3
-               uu___4)
-      | FStar_Syntax_Syntax.Sig_splice (lids, t) ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map FStar_Ident.string_of_lid lids in
-            FStar_Compiler_Effect.op_Less_Bar (FStar_String.concat "; ")
-              uu___1 in
-          let uu___1 = term_to_string t in
-          FStar_Compiler_Util.format2 "splice[%s] (%s)" uu___ uu___1
-      | FStar_Syntax_Syntax.Sig_polymonadic_bind (m, n, p, t, ty, k) ->
-          let uu___ = FStar_Ident.string_of_lid m in
-          let uu___1 = FStar_Ident.string_of_lid n in
-          let uu___2 = FStar_Ident.string_of_lid p in
-          let uu___3 = tscheme_to_string t in
-          let uu___4 = tscheme_to_string ty in
-          let uu___5 = indexed_effect_combinator_kind_opt_to_string k in
-          FStar_Compiler_Util.format6
-            "polymonadic_bind (%s, %s) |> %s = (%s, %s)<%s>" uu___ uu___1
-            uu___2 uu___3 uu___4 uu___5
-      | FStar_Syntax_Syntax.Sig_polymonadic_subcomp (m, n, t, ty, k) ->
-          let uu___ = FStar_Ident.string_of_lid m in
-          let uu___1 = FStar_Ident.string_of_lid n in
-          let uu___2 = tscheme_to_string t in
-          let uu___3 = tscheme_to_string ty in
-          let uu___4 = indexed_effect_combinator_kind_opt_to_string k in
-          FStar_Compiler_Util.format5
-            "polymonadic_subcomp %s <: %s = (%s, %s)<%s>" uu___ uu___1 uu___2
-            uu___3 uu___4 in
-    match x.FStar_Syntax_Syntax.sigattrs with
-    | [] -> Prims.op_Hat "[@ ]" (Prims.op_Hat "\n" basic)
-    | uu___ ->
-        let uu___1 = attrs_to_string x.FStar_Syntax_Syntax.sigattrs in
-        Prims.op_Hat uu___1 (Prims.op_Hat "\n" basic)
-let rec (sigelt_to_string_short : FStar_Syntax_Syntax.sigelt -> Prims.string)
-  =
-  fun x ->
-    match x.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_pragma p -> pragma_to_string p
-    | FStar_Syntax_Syntax.Sig_let
-        ((false,
-          { FStar_Syntax_Syntax.lbname = lb;
-            FStar_Syntax_Syntax.lbunivs = uu___;
-            FStar_Syntax_Syntax.lbtyp = uu___1;
-            FStar_Syntax_Syntax.lbeff = uu___2;
-            FStar_Syntax_Syntax.lbdef = uu___3;
-            FStar_Syntax_Syntax.lbattrs = uu___4;
-            FStar_Syntax_Syntax.lbpos = uu___5;_}::[]),
-         uu___6)
-        ->
-        let uu___7 = lbname_to_string lb in
-        FStar_Compiler_Util.format1 "let %s" uu___7
-    | FStar_Syntax_Syntax.Sig_let
-        ((true,
-          { FStar_Syntax_Syntax.lbname = lb;
-            FStar_Syntax_Syntax.lbunivs = uu___;
-            FStar_Syntax_Syntax.lbtyp = uu___1;
-            FStar_Syntax_Syntax.lbeff = uu___2;
-            FStar_Syntax_Syntax.lbdef = uu___3;
-            FStar_Syntax_Syntax.lbattrs = uu___4;
-            FStar_Syntax_Syntax.lbpos = uu___5;_}::[]),
-         uu___6)
-        ->
-        let uu___7 = lbname_to_string lb in
-        FStar_Compiler_Util.format1 "let rec %s" uu___7
-    | FStar_Syntax_Syntax.Sig_let
-        ((true,
-          { FStar_Syntax_Syntax.lbname = lb;
-            FStar_Syntax_Syntax.lbunivs = uu___;
-            FStar_Syntax_Syntax.lbtyp = uu___1;
-            FStar_Syntax_Syntax.lbeff = uu___2;
-            FStar_Syntax_Syntax.lbdef = uu___3;
-            FStar_Syntax_Syntax.lbattrs = uu___4;
-            FStar_Syntax_Syntax.lbpos = uu___5;_}::uu___6),
-         uu___7)
-        ->
-        let uu___8 = lbname_to_string lb in
-        FStar_Compiler_Util.format1 "let rec %s and ..." uu___8
-    | FStar_Syntax_Syntax.Sig_let uu___ ->
-        failwith "Impossible: sigelt_to_string_short, ill-formed let"
-    | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___, t) ->
-        let uu___1 = FStar_Ident.string_of_lid lid in
-        FStar_Compiler_Util.format1 "val %s" uu___1
-    | FStar_Syntax_Syntax.Sig_inductive_typ
-        (lid, uu___, uu___1, uu___2, uu___3, uu___4, uu___5) ->
-        let uu___6 = FStar_Ident.string_of_lid lid in
-        FStar_Compiler_Util.format1 "type %s" uu___6
-    | FStar_Syntax_Syntax.Sig_datacon
-        (lid, uu___, uu___1, t_lid, uu___2, uu___3) ->
-        let uu___4 = FStar_Ident.string_of_lid lid in
-        let uu___5 = FStar_Ident.string_of_lid t_lid in
-        FStar_Compiler_Util.format2 "datacon %s for type %s" uu___4 uu___5
-    | FStar_Syntax_Syntax.Sig_assume (lid, us, uu___) ->
-        let uu___1 = FStar_Ident.string_of_lid lid in
-        FStar_Compiler_Util.format1 "assume %s" uu___1
-    | FStar_Syntax_Syntax.Sig_bundle (ses, uu___) ->
-        let uu___1 = FStar_Compiler_List.hd ses in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1 sigelt_to_string_short
-    | FStar_Syntax_Syntax.Sig_fail (errs, lax, ses) ->
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater ses FStar_Compiler_List.hd in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1 sigelt_to_string_short in
-        FStar_Compiler_Util.format1 "[@@expect_failure] %s" uu___
-    | FStar_Syntax_Syntax.Sig_new_effect ed ->
-        let kw =
-          let uu___ = FStar_Syntax_Util.is_layered ed in
-          if uu___
-          then "layered_effect"
-          else
-            (let uu___2 = FStar_Syntax_Util.is_dm4f ed in
-             if uu___2 then "new_effect_for_free" else "new_effect") in
-        let uu___ = lid_to_string ed.FStar_Syntax_Syntax.mname in
-        FStar_Compiler_Util.format2 "%s { %s ... }" kw uu___
-    | FStar_Syntax_Syntax.Sig_sub_effect se ->
-        let uu___ = lid_to_string se.FStar_Syntax_Syntax.source in
-        let uu___1 = lid_to_string se.FStar_Syntax_Syntax.target in
-        FStar_Compiler_Util.format2 "sub_effect %s ~> %s" uu___ uu___1
-    | FStar_Syntax_Syntax.Sig_effect_abbrev (l, univs, tps, c, flags) ->
-        let uu___ = sli l in
-        let uu___1 = binders_to_string " " tps in
-        let uu___2 = comp_to_string c in
-        FStar_Compiler_Util.format3 "effect %s %s = %s" uu___ uu___1 uu___2
-    | FStar_Syntax_Syntax.Sig_splice (lids, t) ->
-        let uu___ =
-          let uu___1 = FStar_Compiler_List.map FStar_Ident.string_of_lid lids in
-          FStar_Compiler_Effect.op_Less_Bar (FStar_String.concat "; ") uu___1 in
-        FStar_Compiler_Util.format2 "%splice[%s] (...)" "%s" uu___
-    | FStar_Syntax_Syntax.Sig_polymonadic_bind (m, n, p, t, ty, uu___) ->
-        let uu___1 = FStar_Ident.string_of_lid m in
-        let uu___2 = FStar_Ident.string_of_lid n in
-        let uu___3 = FStar_Ident.string_of_lid p in
-        FStar_Compiler_Util.format3 "polymonadic_bind (%s, %s) |> %s" uu___1
-          uu___2 uu___3
-    | FStar_Syntax_Syntax.Sig_polymonadic_subcomp (m, n, t, ty, uu___) ->
-        let uu___1 = FStar_Ident.string_of_lid m in
-        let uu___2 = FStar_Ident.string_of_lid n in
-        FStar_Compiler_Util.format2 "polymonadic_subcomp %s <: %s" uu___1
-          uu___2
-let (tag_of_sigelt : FStar_Syntax_Syntax.sigelt -> Prims.string) =
-  fun se ->
-    match se.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_inductive_typ uu___ -> "Sig_inductive_typ"
-    | FStar_Syntax_Syntax.Sig_bundle uu___ -> "Sig_bundle"
-    | FStar_Syntax_Syntax.Sig_datacon uu___ -> "Sig_datacon"
-    | FStar_Syntax_Syntax.Sig_declare_typ uu___ -> "Sig_declare_typ"
-    | FStar_Syntax_Syntax.Sig_let uu___ -> "Sig_let"
-    | FStar_Syntax_Syntax.Sig_assume uu___ -> "Sig_assume"
-    | FStar_Syntax_Syntax.Sig_new_effect uu___ -> "Sig_new_effect"
-    | FStar_Syntax_Syntax.Sig_sub_effect uu___ -> "Sig_sub_effect"
-    | FStar_Syntax_Syntax.Sig_effect_abbrev uu___ -> "Sig_effect_abbrev"
-    | FStar_Syntax_Syntax.Sig_pragma uu___ -> "Sig_pragma"
-    | FStar_Syntax_Syntax.Sig_splice uu___ -> "Sig_splice"
-    | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___ ->
-        "Sig_polymonadic_bind"
-    | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___ ->
-        "Sig_polymonadic_subcomp"
-    | FStar_Syntax_Syntax.Sig_fail uu___ -> "Sig_fail"
-let (modul_to_string : FStar_Syntax_Syntax.modul -> Prims.string) =
-  fun m ->
-    let uu___ = sli m.FStar_Syntax_Syntax.name in
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_List.map sigelt_to_string
-          m.FStar_Syntax_Syntax.declarations in
-      FStar_Compiler_Effect.op_Bar_Greater uu___2 (FStar_String.concat "\n") in
-    let uu___2 =
-      let uu___3 =
-        FStar_Compiler_List.map sigelt_to_string
-          m.FStar_Syntax_Syntax.declarations in
-      FStar_Compiler_Effect.op_Bar_Greater uu___3 (FStar_String.concat "\n") in
-    FStar_Compiler_Util.format3
-      "module %s\nDeclarations: [\n%s\n]\nExports: [\n%s\n]\n" uu___ uu___1
-      uu___2
-let (bvs_to_string :
-  Prims.string -> FStar_Syntax_Syntax.bv Prims.list -> Prims.string) =
-  fun sep ->
-    fun bvs ->
-      let uu___ = FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder bvs in
-      binders_to_string sep uu___
-let (ctx_uvar_to_string : FStar_Syntax_Syntax.ctx_uvar -> Prims.string) =
-  fun ctx_uvar -> ctx_uvar_to_string_aux true ctx_uvar
-let (ctx_uvar_to_string_no_reason :
-  FStar_Syntax_Syntax.ctx_uvar -> Prims.string) =
-  fun ctx_uvar -> ctx_uvar_to_string_aux false ctx_uvar
-let rec (emb_typ_to_string : FStar_Syntax_Syntax.emb_typ -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.ET_abstract -> "abstract"
-    | FStar_Syntax_Syntax.ET_app (h, []) -> h
-    | FStar_Syntax_Syntax.ET_app (h, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Compiler_List.map emb_typ_to_string args in
-                FStar_Compiler_Effect.op_Bar_Greater uu___5
-                  (FStar_String.concat " ") in
-              Prims.op_Hat uu___4 ")" in
-            Prims.op_Hat " " uu___3 in
-          Prims.op_Hat h uu___2 in
-        Prims.op_Hat "(" uu___1
-    | FStar_Syntax_Syntax.ET_fun (a, b) ->
-        let uu___1 =
-          let uu___2 = emb_typ_to_string a in
-          let uu___3 =
-            let uu___4 = emb_typ_to_string b in Prims.op_Hat ") -> " uu___4 in
-          Prims.op_Hat uu___2 uu___3 in
-        Prims.op_Hat "(" uu___1
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Print_Pretty.ml b/src/ocaml-output/FStar_Syntax_Print_Pretty.ml
deleted file mode 100644
index 76bdf29a60f..00000000000
--- a/src/ocaml-output/FStar_Syntax_Print_Pretty.ml
+++ /dev/null
@@ -1,91 +0,0 @@
-open Prims
-let (rfrac : FStar_BaseTypes.float) =
-  FStar_Compiler_Util.float_of_string "1.0"
-let (width : Prims.int) = (Prims.of_int (100))
-let (pp : FStar_Pprint.document -> Prims.string) =
-  fun d -> FStar_Pprint.pretty_string rfrac (Prims.of_int (100)) d
-let (term_to_string' :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.term -> Prims.string) =
-  fun env ->
-    fun tm ->
-      FStar_Ident.with_frozen_gensym
-        (fun uu___ ->
-           let e = FStar_Syntax_Resugar.resugar_term' env tm in
-           let d = FStar_Parser_ToDocument.term_to_document e in pp d)
-let (comp_to_string' :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.comp -> Prims.string) =
-  fun env ->
-    fun c ->
-      FStar_Ident.with_frozen_gensym
-        (fun uu___ ->
-           let e = FStar_Syntax_Resugar.resugar_comp' env c in
-           let d = FStar_Parser_ToDocument.term_to_document e in pp d)
-let (term_to_string : FStar_Syntax_Syntax.term -> Prims.string) =
-  fun tm ->
-    FStar_Ident.with_frozen_gensym
-      (fun uu___ ->
-         let e = FStar_Syntax_Resugar.resugar_term tm in
-         let d = FStar_Parser_ToDocument.term_to_document e in pp d)
-let (comp_to_string : FStar_Syntax_Syntax.comp -> Prims.string) =
-  fun c ->
-    FStar_Ident.with_frozen_gensym
-      (fun uu___ ->
-         let e = FStar_Syntax_Resugar.resugar_comp c in
-         let d = FStar_Parser_ToDocument.term_to_document e in pp d)
-let (univ_to_string : FStar_Syntax_Syntax.universe -> Prims.string) =
-  fun u ->
-    FStar_Ident.with_frozen_gensym
-      (fun uu___ ->
-         let e =
-           FStar_Syntax_Resugar.resugar_universe u
-             FStar_Compiler_Range.dummyRange in
-         let d = FStar_Parser_ToDocument.term_to_document e in pp d)
-let (tscheme_to_string : FStar_Syntax_Syntax.tscheme -> Prims.string) =
-  fun ts ->
-    FStar_Ident.with_frozen_gensym
-      (fun uu___ ->
-         let d = FStar_Syntax_Resugar.resugar_tscheme ts in
-         let d1 = FStar_Parser_ToDocument.decl_to_document d in pp d1)
-let (pat_to_string : FStar_Syntax_Syntax.pat -> Prims.string) =
-  fun p ->
-    FStar_Ident.with_frozen_gensym
-      (fun uu___ ->
-         let e =
-           FStar_Syntax_Resugar.resugar_pat p FStar_Syntax_Syntax.no_names in
-         let d = FStar_Parser_ToDocument.pat_to_document e in pp d)
-let (binder_to_string' :
-  Prims.bool -> FStar_Syntax_Syntax.binder -> Prims.string) =
-  fun is_arrow ->
-    fun b ->
-      FStar_Ident.with_frozen_gensym
-        (fun uu___ ->
-           let uu___1 =
-             FStar_Syntax_Resugar.resugar_binder b
-               FStar_Compiler_Range.dummyRange in
-           match uu___1 with
-           | FStar_Pervasives_Native.None -> ""
-           | FStar_Pervasives_Native.Some e ->
-               let d = FStar_Parser_ToDocument.binder_to_document e in pp d)
-let (sigelt_to_string : FStar_Syntax_Syntax.sigelt -> Prims.string) =
-  fun se ->
-    FStar_Ident.with_frozen_gensym
-      (fun uu___ ->
-         let uu___1 = FStar_Syntax_Resugar.resugar_sigelt se in
-         match uu___1 with
-         | FStar_Pervasives_Native.None -> ""
-         | FStar_Pervasives_Native.Some d ->
-             let d1 = FStar_Parser_ToDocument.decl_to_document d in pp d1)
-let (eff_decl_to_string' :
-  Prims.bool ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.eff_decl -> Prims.string)
-  =
-  fun for_free ->
-    fun r ->
-      fun q ->
-        fun ed ->
-          FStar_Ident.with_frozen_gensym
-            (fun uu___ ->
-               let d = FStar_Syntax_Resugar.resugar_eff_decl r q ed in
-               let d1 = FStar_Parser_ToDocument.decl_to_document d in pp d1)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Resugar.ml b/src/ocaml-output/FStar_Syntax_Resugar.ml
deleted file mode 100644
index 7d12de91093..00000000000
--- a/src/ocaml-output/FStar_Syntax_Resugar.ml
+++ /dev/null
@@ -1,2926 +0,0 @@
-open Prims
-let (doc_to_string : FStar_Pprint.document -> Prims.string) =
-  fun doc ->
-    FStar_Pprint.pretty_string (FStar_Compiler_Util.float_of_string "1.0")
-      (Prims.of_int (100)) doc
-let (parser_term_to_string : FStar_Parser_AST.term -> Prims.string) =
-  fun t ->
-    let uu___ = FStar_Parser_ToDocument.term_to_document t in
-    doc_to_string uu___
-let (parser_pat_to_string : FStar_Parser_AST.pattern -> Prims.string) =
-  fun t ->
-    let uu___ = FStar_Parser_ToDocument.pat_to_document t in
-    doc_to_string uu___
-let (tts : FStar_Syntax_Syntax.term -> Prims.string) =
-  fun t -> FStar_Syntax_Util.tts t
-let map_opt :
-  'uuuuu 'uuuuu1 .
-    unit ->
-      ('uuuuu -> 'uuuuu1 FStar_Pervasives_Native.option) ->
-        'uuuuu Prims.list -> 'uuuuu1 Prims.list
-  = fun uu___ -> FStar_Compiler_List.filter_map
-let (bv_as_unique_ident : FStar_Syntax_Syntax.bv -> FStar_Ident.ident) =
-  fun x ->
-    let unique_name =
-      let uu___ =
-        (let uu___1 = FStar_Ident.string_of_id x.FStar_Syntax_Syntax.ppname in
-         FStar_Compiler_Util.starts_with FStar_Ident.reserved_prefix uu___1)
-          || (FStar_Options.print_real_names ()) in
-      if uu___
-      then
-        let uu___1 = FStar_Ident.string_of_id x.FStar_Syntax_Syntax.ppname in
-        let uu___2 =
-          FStar_Compiler_Util.string_of_int x.FStar_Syntax_Syntax.index in
-        Prims.op_Hat uu___1 uu___2
-      else FStar_Ident.string_of_id x.FStar_Syntax_Syntax.ppname in
-    let uu___ =
-      let uu___1 = FStar_Ident.range_of_id x.FStar_Syntax_Syntax.ppname in
-      (unique_name, uu___1) in
-    FStar_Ident.mk_ident uu___
-let (filter_imp :
-  FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-    Prims.bool)
-  =
-  fun a ->
-    match a with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) when
-        FStar_Syntax_Util.is_fvar FStar_Parser_Const.tcresolve_lid t -> true
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit uu___) ->
-        false
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta uu___) -> false
-    | uu___ -> true
-let (filter_imp_args : FStar_Syntax_Syntax.args -> FStar_Syntax_Syntax.args)
-  =
-  fun args ->
-    FStar_Compiler_Effect.op_Bar_Greater args
-      (FStar_Compiler_List.filter
-         (fun uu___ ->
-            match uu___ with
-            | (uu___1, FStar_Pervasives_Native.None) -> true
-            | (uu___1, FStar_Pervasives_Native.Some arg) ->
-                Prims.op_Negation arg.FStar_Syntax_Syntax.aqual_implicit))
-let (filter_imp_bs :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun bs ->
-    FStar_Compiler_Effect.op_Bar_Greater bs
-      (FStar_Compiler_List.filter
-         (fun b ->
-            FStar_Compiler_Effect.op_Bar_Greater
-              b.FStar_Syntax_Syntax.binder_qual filter_imp))
-let filter_pattern_imp :
-  'uuuuu .
-    ('uuuuu * Prims.bool) Prims.list -> ('uuuuu * Prims.bool) Prims.list
-  =
-  fun xs ->
-    FStar_Compiler_List.filter
-      (fun uu___ ->
-         match uu___ with
-         | (uu___1, is_implicit) -> Prims.op_Negation is_implicit) xs
-let (label : Prims.string -> FStar_Parser_AST.term -> FStar_Parser_AST.term)
-  =
-  fun s ->
-    fun t ->
-      if s = ""
-      then t
-      else
-        FStar_Parser_AST.mk_term (FStar_Parser_AST.Labeled (t, s, true))
-          t.FStar_Parser_AST.range FStar_Parser_AST.Un
-let rec (universe_to_int :
-  Prims.int ->
-    FStar_Syntax_Syntax.universe ->
-      (Prims.int * FStar_Syntax_Syntax.universe))
-  =
-  fun n ->
-    fun u ->
-      match u with
-      | FStar_Syntax_Syntax.U_succ u1 ->
-          universe_to_int (n + Prims.int_one) u1
-      | uu___ -> (n, u)
-let (universe_to_string : FStar_Ident.ident Prims.list -> Prims.string) =
-  fun univs ->
-    let uu___ = FStar_Options.print_universes () in
-    if uu___
-    then
-      let uu___1 =
-        FStar_Compiler_List.map (fun x -> FStar_Ident.string_of_id x) univs in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 (FStar_String.concat ", ")
-    else ""
-let rec (resugar_universe :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Compiler_Range.range -> FStar_Parser_AST.term)
-  =
-  fun u ->
-    fun r ->
-      let mk a r1 = FStar_Parser_AST.mk_term a r1 FStar_Parser_AST.Un in
-      match u with
-      | FStar_Syntax_Syntax.U_zero ->
-          mk
-            (FStar_Parser_AST.Const
-               (FStar_Const.Const_int ("0", FStar_Pervasives_Native.None))) r
-      | FStar_Syntax_Syntax.U_succ uu___ ->
-          let uu___1 = universe_to_int Prims.int_zero u in
-          (match uu___1 with
-           | (n, u1) ->
-               (match u1 with
-                | FStar_Syntax_Syntax.U_zero ->
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Compiler_Util.string_of_int n in
-                          (uu___5, FStar_Pervasives_Native.None) in
-                        FStar_Const.Const_int uu___4 in
-                      FStar_Parser_AST.Const uu___3 in
-                    mk uu___2 r
-                | uu___2 ->
-                    let e1 =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Compiler_Util.string_of_int n in
-                            (uu___6, FStar_Pervasives_Native.None) in
-                          FStar_Const.Const_int uu___5 in
-                        FStar_Parser_AST.Const uu___4 in
-                      mk uu___3 r in
-                    let e2 = resugar_universe u1 r in
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 = FStar_Ident.id_of_text "+" in
-                        (uu___5, [e1; e2]) in
-                      FStar_Parser_AST.Op uu___4 in
-                    mk uu___3 r))
-      | FStar_Syntax_Syntax.U_max l ->
-          (match l with
-           | [] -> failwith "Impossible: U_max without arguments"
-           | uu___ ->
-               let t =
-                 let uu___1 =
-                   let uu___2 = FStar_Ident.lid_of_path ["max"] r in
-                   FStar_Parser_AST.Var uu___2 in
-                 mk uu___1 r in
-               FStar_Compiler_List.fold_left
-                 (fun acc ->
-                    fun x ->
-                      let uu___1 =
-                        let uu___2 =
-                          let uu___3 = resugar_universe x r in
-                          (acc, uu___3, FStar_Parser_AST.Nothing) in
-                        FStar_Parser_AST.App uu___2 in
-                      mk uu___1 r) t l)
-      | FStar_Syntax_Syntax.U_name u1 -> mk (FStar_Parser_AST.Uvar u1) r
-      | FStar_Syntax_Syntax.U_unif uu___ -> mk FStar_Parser_AST.Wild r
-      | FStar_Syntax_Syntax.U_bvar x ->
-          let id =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Compiler_Util.string_of_int x in
-                FStar_Compiler_Util.strcat "uu__univ_bvar_" uu___2 in
-              (uu___1, r) in
-            FStar_Ident.mk_ident uu___ in
-          mk (FStar_Parser_AST.Uvar id) r
-      | FStar_Syntax_Syntax.U_unknown -> mk FStar_Parser_AST.Wild r
-let (resugar_universe' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Compiler_Range.range -> FStar_Parser_AST.term)
-  = fun env -> fun u -> fun r -> resugar_universe u r
-type expected_arity = Prims.int FStar_Pervasives_Native.option
-let rec (resugar_term_as_op :
-  FStar_Syntax_Syntax.term ->
-    (Prims.string * expected_arity) FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let infix_prim_ops =
-      [(FStar_Parser_Const.op_Addition, "+");
-      (FStar_Parser_Const.op_Subtraction, "-");
-      (FStar_Parser_Const.op_Minus, "-");
-      (FStar_Parser_Const.op_Multiply, "*");
-      (FStar_Parser_Const.op_Division, "/");
-      (FStar_Parser_Const.op_Modulus, "%");
-      (FStar_Parser_Const.read_lid, "!");
-      (FStar_Parser_Const.list_append_lid, "@");
-      (FStar_Parser_Const.list_tot_append_lid, "@");
-      (FStar_Parser_Const.op_Eq, "=");
-      (FStar_Parser_Const.op_ColonEq, ":=");
-      (FStar_Parser_Const.op_notEq, "<>");
-      (FStar_Parser_Const.not_lid, "~");
-      (FStar_Parser_Const.op_And, "&&");
-      (FStar_Parser_Const.op_Or, "||");
-      (FStar_Parser_Const.op_LTE, "<=");
-      (FStar_Parser_Const.op_GTE, ">=");
-      (FStar_Parser_Const.op_LT, "<");
-      (FStar_Parser_Const.op_GT, ">");
-      (FStar_Parser_Const.op_Modulus, "mod");
-      (FStar_Parser_Const.and_lid, "/\\");
-      (FStar_Parser_Const.or_lid, "\\/");
-      (FStar_Parser_Const.imp_lid, "==>");
-      (FStar_Parser_Const.iff_lid, "<==>");
-      (FStar_Parser_Const.precedes_lid, "<<");
-      (FStar_Parser_Const.eq2_lid, "==");
-      (FStar_Parser_Const.forall_lid, "forall");
-      (FStar_Parser_Const.exists_lid, "exists");
-      (FStar_Parser_Const.salloc_lid, "alloc");
-      (FStar_Parser_Const.calc_finish_lid, "calc_finish")] in
-    let fallback fv =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater infix_prim_ops
-          (FStar_Compiler_Util.find_opt
-             (fun d ->
-                FStar_Syntax_Syntax.fv_eq_lid fv
-                  (FStar_Pervasives_Native.fst d))) in
-      match uu___ with
-      | FStar_Pervasives_Native.Some op ->
-          FStar_Pervasives_Native.Some
-            ((FStar_Pervasives_Native.snd op), FStar_Pervasives_Native.None)
-      | uu___1 ->
-          let length =
-            let uu___2 =
-              FStar_Ident.nsstr
-                (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-            FStar_String.length uu___2 in
-          let str =
-            if length = Prims.int_zero
-            then
-              FStar_Ident.string_of_lid
-                (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-            else
-              (let uu___3 =
-                 FStar_Ident.string_of_lid
-                   (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-               FStar_Compiler_Util.substring_from uu___3
-                 (length + Prims.int_one)) in
-          let uu___2 =
-            (FStar_Compiler_Util.starts_with str "dtuple") &&
-              (let uu___3 =
-                 let uu___4 =
-                   FStar_Compiler_Util.substring_from str (Prims.of_int (6)) in
-                 FStar_Compiler_Util.safe_int_of_string uu___4 in
-               FStar_Compiler_Option.isSome uu___3) in
-          if uu___2
-          then
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_Util.substring_from str (Prims.of_int (6)) in
-                FStar_Compiler_Util.safe_int_of_string uu___5 in
-              ("dtuple", uu___4) in
-            FStar_Pervasives_Native.Some uu___3
-          else
-            (let uu___4 =
-               (FStar_Compiler_Util.starts_with str "tuple") &&
-                 (let uu___5 =
-                    let uu___6 =
-                      FStar_Compiler_Util.substring_from str
-                        (Prims.of_int (5)) in
-                    FStar_Compiler_Util.safe_int_of_string uu___6 in
-                  FStar_Compiler_Option.isSome uu___5) in
-             if uu___4
-             then
-               let uu___5 =
-                 let uu___6 =
-                   let uu___7 =
-                     FStar_Compiler_Util.substring_from str
-                       (Prims.of_int (5)) in
-                   FStar_Compiler_Util.safe_int_of_string uu___7 in
-                 ("tuple", uu___6) in
-               FStar_Pervasives_Native.Some uu___5
-             else
-               if FStar_Compiler_Util.starts_with str "try_with"
-               then
-                 FStar_Pervasives_Native.Some
-                   ("try_with", FStar_Pervasives_Native.None)
-               else
-                 (let uu___7 =
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.sread_lid in
-                  if uu___7
-                  then
-                    let uu___8 =
-                      let uu___9 =
-                        FStar_Ident.string_of_lid
-                          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                      (uu___9, FStar_Pervasives_Native.None) in
-                    FStar_Pervasives_Native.Some uu___8
-                  else FStar_Pervasives_Native.None)) in
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        let length =
-          let uu___1 =
-            FStar_Ident.nsstr
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          FStar_String.length uu___1 in
-        let s =
-          if length = Prims.int_zero
-          then
-            FStar_Ident.string_of_lid
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-          else
-            (let uu___2 =
-               FStar_Ident.string_of_lid
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-             FStar_Compiler_Util.substring_from uu___2
-               (length + Prims.int_one)) in
-        let uu___1 = FStar_Parser_AST.string_to_op s in
-        (match uu___1 with
-         | FStar_Pervasives_Native.Some t1 -> FStar_Pervasives_Native.Some t1
-         | uu___2 -> fallback fv)
-    | FStar_Syntax_Syntax.Tm_uinst (e, us) -> resugar_term_as_op e
-    | uu___1 -> FStar_Pervasives_Native.None
-let (is_true_pat : FStar_Syntax_Syntax.pat -> Prims.bool) =
-  fun p ->
-    match p.FStar_Syntax_Syntax.v with
-    | FStar_Syntax_Syntax.Pat_constant (FStar_Const.Const_bool (true)) ->
-        true
-    | uu___ -> false
-let (is_wild_pat : FStar_Syntax_Syntax.pat -> Prims.bool) =
-  fun p ->
-    match p.FStar_Syntax_Syntax.v with
-    | FStar_Syntax_Syntax.Pat_wild uu___ -> true
-    | uu___ -> false
-let (is_tuple_constructor_lid : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    (FStar_Parser_Const.is_tuple_data_lid' lid) ||
-      (FStar_Parser_Const.is_dtuple_data_lid' lid)
-let (may_shorten : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    let uu___ = FStar_Ident.string_of_lid lid in
-    match uu___ with
-    | "Prims.Nil" -> false
-    | "Prims.Cons" -> false
-    | uu___1 ->
-        let uu___2 = is_tuple_constructor_lid lid in Prims.op_Negation uu___2
-let (maybe_shorten_fv :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.fv -> FStar_Ident.lident) =
-  fun env ->
-    fun fv ->
-      let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      let uu___ = may_shorten lid in
-      if uu___ then FStar_Syntax_DsEnv.shorten_lid env lid else lid
-let (serialize_machine_integer_desc :
-  (FStar_Const.signedness * FStar_Const.width) -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | (s, w) ->
-        FStar_Compiler_Util.format3 "FStar.%sInt%s.__%sint_to_t"
-          (match s with
-           | FStar_Const.Unsigned -> "U"
-           | FStar_Const.Signed -> "")
-          (match w with
-           | FStar_Const.Int8 -> "8"
-           | FStar_Const.Int16 -> "16"
-           | FStar_Const.Int32 -> "32"
-           | FStar_Const.Int64 -> "64")
-          (match s with
-           | FStar_Const.Unsigned -> "u"
-           | FStar_Const.Signed -> "")
-let (parse_machine_integer_desc :
-  FStar_Syntax_Syntax.fv ->
-    ((FStar_Const.signedness * FStar_Const.width) * Prims.string)
-      FStar_Pervasives_Native.option)
-  =
-  let signs = [FStar_Const.Unsigned; FStar_Const.Signed] in
-  let widths =
-    [FStar_Const.Int8;
-    FStar_Const.Int16;
-    FStar_Const.Int32;
-    FStar_Const.Int64] in
-  let descs =
-    FStar_Compiler_List.collect
-      (fun s ->
-         FStar_Compiler_List.map
-           (fun w ->
-              let uu___ = serialize_machine_integer_desc (s, w) in
-              ((s, w), uu___)) widths) signs in
-  fun fv ->
-    FStar_Compiler_List.tryFind
-      (fun uu___ ->
-         match uu___ with
-         | (uu___1, d) ->
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Syntax.lid_of_fv fv in
-               FStar_Ident.string_of_lid uu___3 in
-             d = uu___2) descs
-let (can_resugar_machine_integer : FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun fv ->
-    let uu___ = parse_machine_integer_desc fv in
-    FStar_Compiler_Option.isSome uu___
-let (resugar_machine_integer :
-  FStar_Syntax_Syntax.fv ->
-    Prims.string -> FStar_Compiler_Range.range -> FStar_Parser_AST.term)
-  =
-  fun fv ->
-    fun i ->
-      fun pos ->
-        let uu___ = parse_machine_integer_desc fv in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            failwith
-              "Impossible: should be guarded by can_resugar_machine_integer"
-        | FStar_Pervasives_Native.Some (sw, uu___1) ->
-            FStar_Parser_AST.mk_term
-              (FStar_Parser_AST.Const
-                 (FStar_Const.Const_int
-                    (i, (FStar_Pervasives_Native.Some sw)))) pos
-              FStar_Parser_AST.Un
-let rec (resugar_term' :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.term -> FStar_Parser_AST.term)
-  =
-  fun env ->
-    fun t ->
-      let mk a =
-        FStar_Parser_AST.mk_term a t.FStar_Syntax_Syntax.pos
-          FStar_Parser_AST.Un in
-      let name a r =
-        let uu___ = FStar_Ident.lid_of_path [a] r in
-        FStar_Parser_AST.Name uu___ in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_delayed uu___1 ->
-          failwith "Tm_delayed is impossible after compress"
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___1 = FStar_Syntax_Util.unfold_lazy i in
-          resugar_term' env uu___1
-      | FStar_Syntax_Syntax.Tm_bvar x ->
-          let l =
-            let uu___1 = let uu___2 = bv_as_unique_ident x in [uu___2] in
-            FStar_Ident.lid_of_ids uu___1 in
-          mk (FStar_Parser_AST.Var l)
-      | FStar_Syntax_Syntax.Tm_name x ->
-          let l =
-            let uu___1 = let uu___2 = bv_as_unique_ident x in [uu___2] in
-            FStar_Ident.lid_of_ids uu___1 in
-          mk (FStar_Parser_AST.Var l)
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let a = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          let length =
-            let uu___1 =
-              FStar_Ident.nsstr
-                (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-            FStar_String.length uu___1 in
-          let s =
-            if length = Prims.int_zero
-            then FStar_Ident.string_of_lid a
-            else
-              (let uu___2 = FStar_Ident.string_of_lid a in
-               FStar_Compiler_Util.substring_from uu___2
-                 (length + Prims.int_one)) in
-          let is_prefix = Prims.op_Hat FStar_Ident.reserved_prefix "is_" in
-          if FStar_Compiler_Util.starts_with s is_prefix
-          then
-            let rest =
-              FStar_Compiler_Util.substring_from s
-                (FStar_String.length is_prefix) in
-            let uu___1 =
-              let uu___2 =
-                FStar_Ident.lid_of_path [rest] t.FStar_Syntax_Syntax.pos in
-              FStar_Parser_AST.Discrim uu___2 in
-            mk uu___1
-          else
-            if
-              FStar_Compiler_Util.starts_with s
-                FStar_Syntax_Util.field_projector_prefix
-            then
-              (let rest =
-                 FStar_Compiler_Util.substring_from s
-                   (FStar_String.length
-                      FStar_Syntax_Util.field_projector_prefix) in
-               let r =
-                 FStar_Compiler_Util.split rest
-                   FStar_Syntax_Util.field_projector_sep in
-               match r with
-               | fst::snd::[] ->
-                   let l =
-                     FStar_Ident.lid_of_path [fst] t.FStar_Syntax_Syntax.pos in
-                   let r1 =
-                     FStar_Ident.mk_ident (snd, (t.FStar_Syntax_Syntax.pos)) in
-                   mk (FStar_Parser_AST.Projector (l, r1))
-               | uu___2 -> failwith "wrong projector format")
-            else
-              (let uu___3 =
-                 FStar_Ident.lid_equals a FStar_Parser_Const.smtpat_lid in
-               if uu___3
-               then
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 = FStar_Ident.range_of_lid a in
-                       ("SMTPat", uu___7) in
-                     FStar_Ident.mk_ident uu___6 in
-                   FStar_Parser_AST.Tvar uu___5 in
-                 mk uu___4
-               else
-                 (let uu___5 =
-                    FStar_Ident.lid_equals a FStar_Parser_Const.smtpatOr_lid in
-                  if uu___5
-                  then
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 = FStar_Ident.range_of_lid a in
-                          ("SMTPatOr", uu___9) in
-                        FStar_Ident.mk_ident uu___8 in
-                      FStar_Parser_AST.Tvar uu___7 in
-                    mk uu___6
-                  else
-                    (let uu___7 =
-                       ((FStar_Ident.lid_equals a
-                           FStar_Parser_Const.assert_lid)
-                          ||
-                          (FStar_Ident.lid_equals a
-                             FStar_Parser_Const.assume_lid))
-                         ||
-                         (let uu___8 =
-                            let uu___9 = FStar_String.get s Prims.int_zero in
-                            FStar_Char.uppercase uu___9 in
-                          let uu___9 = FStar_String.get s Prims.int_zero in
-                          uu___8 <> uu___9) in
-                     if uu___7
-                     then
-                       let uu___8 =
-                         let uu___9 = maybe_shorten_fv env fv in
-                         FStar_Parser_AST.Var uu___9 in
-                       mk uu___8
-                     else
-                       (let uu___9 =
-                          let uu___10 =
-                            let uu___11 = maybe_shorten_fv env fv in
-                            (uu___11, []) in
-                          FStar_Parser_AST.Construct uu___10 in
-                        mk uu___9))))
-      | FStar_Syntax_Syntax.Tm_uinst (e, universes) ->
-          let e1 = resugar_term' env e in
-          let uu___1 = FStar_Options.print_universes () in
-          if uu___1
-          then
-            let univs =
-              FStar_Compiler_List.map
-                (fun x -> resugar_universe x t.FStar_Syntax_Syntax.pos)
-                universes in
-            (match e1 with
-             | { FStar_Parser_AST.tm = FStar_Parser_AST.Construct (hd, args);
-                 FStar_Parser_AST.range = r; FStar_Parser_AST.level = l;_} ->
-                 let args1 =
-                   let uu___2 =
-                     FStar_Compiler_List.map
-                       (fun u -> (u, FStar_Parser_AST.UnivApp)) univs in
-                   FStar_Compiler_List.op_At args uu___2 in
-                 FStar_Parser_AST.mk_term
-                   (FStar_Parser_AST.Construct (hd, args1)) r l
-             | uu___2 ->
-                 FStar_Compiler_List.fold_left
-                   (fun acc ->
-                      fun u ->
-                        mk
-                          (FStar_Parser_AST.App
-                             (acc, u, FStar_Parser_AST.UnivApp))) e1 univs)
-          else e1
-      | FStar_Syntax_Syntax.Tm_constant c ->
-          let uu___1 = FStar_Syntax_Syntax.is_teff t in
-          if uu___1
-          then
-            let uu___2 = name "Effect" t.FStar_Syntax_Syntax.pos in mk uu___2
-          else mk (FStar_Parser_AST.Const c)
-      | FStar_Syntax_Syntax.Tm_type u ->
-          let uu___1 =
-            match u with
-            | FStar_Syntax_Syntax.U_zero -> ("Type0", false)
-            | FStar_Syntax_Syntax.U_unknown -> ("Type", false)
-            | uu___2 -> ("Type", true) in
-          (match uu___1 with
-           | (nm, needs_app) ->
-               let typ =
-                 let uu___2 = name nm t.FStar_Syntax_Syntax.pos in mk uu___2 in
-               let uu___2 = needs_app && (FStar_Options.print_universes ()) in
-               if uu___2
-               then
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 =
-                       resugar_universe u t.FStar_Syntax_Syntax.pos in
-                     (typ, uu___5, FStar_Parser_AST.UnivApp) in
-                   FStar_Parser_AST.App uu___4 in
-                 mk uu___3
-               else typ)
-      | FStar_Syntax_Syntax.Tm_abs (xs, body, uu___1) ->
-          let uu___2 = FStar_Syntax_Subst.open_term xs body in
-          (match uu___2 with
-           | (xs1, body1) ->
-               let xs2 =
-                 let uu___3 = FStar_Options.print_implicits () in
-                 if uu___3
-                 then xs1
-                 else
-                   FStar_Compiler_Effect.op_Bar_Greater xs1
-                     (FStar_Compiler_List.filter
-                        (fun x ->
-                           FStar_Compiler_Effect.op_Bar_Greater
-                             x.FStar_Syntax_Syntax.binder_qual filter_imp)) in
-               let body_bv = FStar_Syntax_Free.names body1 in
-               let patterns =
-                 FStar_Compiler_Effect.op_Bar_Greater xs2
-                   (FStar_Compiler_List.choose
-                      (fun x ->
-                         resugar_bv_as_pat env
-                           x.FStar_Syntax_Syntax.binder_bv
-                           x.FStar_Syntax_Syntax.binder_qual body_bv)) in
-               let body2 = resugar_term' env body1 in
-               if FStar_Compiler_List.isEmpty patterns
-               then body2
-               else mk (FStar_Parser_AST.Abs (patterns, body2)))
-      | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Util.canon_arrow t in
-                FStar_Syntax_Subst.compress uu___5 in
-              uu___4.FStar_Syntax_Syntax.n in
-            match uu___3 with
-            | FStar_Syntax_Syntax.Tm_arrow (xs, body) -> (xs, body)
-            | uu___4 -> failwith "impossible: Tm_arrow in resugar_term" in
-          (match uu___2 with
-           | (xs, body) ->
-               let uu___3 = FStar_Syntax_Subst.open_comp xs body in
-               (match uu___3 with
-                | (xs1, body1) ->
-                    let xs2 =
-                      let uu___4 = FStar_Options.print_implicits () in
-                      if uu___4 then xs1 else filter_imp_bs xs1 in
-                    let body2 = resugar_comp' env body1 in
-                    let xs3 =
-                      let uu___4 =
-                        FStar_Compiler_Effect.op_Bar_Greater xs2
-                          ((map_opt ())
-                             (fun b ->
-                                resugar_binder' env b
-                                  t.FStar_Syntax_Syntax.pos)) in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___4
-                        FStar_Compiler_List.rev in
-                    let rec aux body3 uu___4 =
-                      match uu___4 with
-                      | [] -> body3
-                      | hd::tl ->
-                          let body4 =
-                            mk (FStar_Parser_AST.Product ([hd], body3)) in
-                          aux body4 tl in
-                    aux body2 xs3))
-      | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.mk_binder x in [uu___3] in
-            FStar_Syntax_Subst.open_term uu___2 phi in
-          (match uu___1 with
-           | (x1, phi1) ->
-               let b =
-                 let uu___2 =
-                   let uu___3 = FStar_Compiler_List.hd x1 in
-                   resugar_binder' env uu___3 t.FStar_Syntax_Syntax.pos in
-                 FStar_Compiler_Util.must uu___2 in
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = resugar_term' env phi1 in (b, uu___4) in
-                 FStar_Parser_AST.Refine uu___3 in
-               mk uu___2)
-      | FStar_Syntax_Syntax.Tm_app
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           (e, uu___4)::[])
-          when
-          (let uu___5 = FStar_Options.print_implicits () in
-           Prims.op_Negation uu___5) &&
-            (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.b2t_lid)
-          -> resugar_term' env e
-      | FStar_Syntax_Syntax.Tm_app
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           ({
-              FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_int (i, FStar_Pervasives_Native.None));
-              FStar_Syntax_Syntax.pos = uu___4;
-              FStar_Syntax_Syntax.vars = uu___5;
-              FStar_Syntax_Syntax.hash_code = uu___6;_},
-            uu___7)::[])
-          when can_resugar_machine_integer fv ->
-          resugar_machine_integer fv i t.FStar_Syntax_Syntax.pos
-      | FStar_Syntax_Syntax.Tm_app (e, args) ->
-          let rec last uu___1 =
-            match uu___1 with
-            | hd::[] -> [hd]
-            | hd::tl -> last tl
-            | uu___2 -> failwith "last of an empty list" in
-          let first_two_explicit args1 =
-            let rec drop_implicits args2 =
-              match args2 with
-              | (uu___1, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___2;_})::tl
-                  -> drop_implicits tl
-              | uu___1 -> args2 in
-            let uu___1 = drop_implicits args1 in
-            match uu___1 with
-            | [] -> failwith "not_enough explicit_arguments"
-            | uu___2::[] -> failwith "not_enough explicit_arguments"
-            | a1::a2::uu___2 -> [a1; a2] in
-          let resugar_as_app e1 args1 =
-            let args2 =
-              FStar_Compiler_List.map
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (e2, qual) ->
-                       let uu___2 = resugar_term' env e2 in
-                       let uu___3 = resugar_aqual env qual in
-                       (uu___2, uu___3)) args1 in
-            let uu___1 = resugar_term' env e1 in
-            match uu___1 with
-            | {
-                FStar_Parser_AST.tm = FStar_Parser_AST.Construct
-                  (hd, previous_args);
-                FStar_Parser_AST.range = r; FStar_Parser_AST.level = l;_} ->
-                FStar_Parser_AST.mk_term
-                  (FStar_Parser_AST.Construct
-                     (hd, (FStar_Compiler_List.op_At previous_args args2))) r
-                  l
-            | e2 ->
-                FStar_Compiler_List.fold_left
-                  (fun acc ->
-                     fun uu___2 ->
-                       match uu___2 with
-                       | (x, qual) ->
-                           mk (FStar_Parser_AST.App (acc, x, qual))) e2 args2 in
-          let args1 =
-            let uu___1 = FStar_Options.print_implicits () in
-            if uu___1 then args else filter_imp_args args in
-          let uu___1 = resugar_term_as_op e in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None -> resugar_as_app e args1
-           | FStar_Pervasives_Native.Some ("calc_finish", uu___2) ->
-               let uu___3 = resugar_calc env t in
-               (match uu___3 with
-                | FStar_Pervasives_Native.Some r -> r
-                | uu___4 -> resugar_as_app e args1)
-           | FStar_Pervasives_Native.Some ("tuple", uu___2) ->
-               let out =
-                 FStar_Compiler_List.fold_left
-                   (fun out1 ->
-                      fun uu___3 ->
-                        match uu___3 with
-                        | (x, uu___4) ->
-                            let x1 = resugar_term' env x in
-                            (match out1 with
-                             | FStar_Pervasives_Native.None ->
-                                 FStar_Pervasives_Native.Some x1
-                             | FStar_Pervasives_Native.Some prefix ->
-                                 let uu___5 =
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         FStar_Ident.id_of_text "*" in
-                                       (uu___8, [prefix; x1]) in
-                                     FStar_Parser_AST.Op uu___7 in
-                                   mk uu___6 in
-                                 FStar_Pervasives_Native.Some uu___5))
-                   FStar_Pervasives_Native.None args1 in
-               FStar_Compiler_Option.get out
-           | FStar_Pervasives_Native.Some ("dtuple", uu___2) ->
-               resugar_as_app e args1
-           | FStar_Pervasives_Native.Some (ref_read, uu___2) when
-               let uu___3 =
-                 FStar_Ident.string_of_lid FStar_Parser_Const.sread_lid in
-               ref_read = uu___3 ->
-               let uu___3 = FStar_Compiler_List.hd args1 in
-               (match uu___3 with
-                | (t1, uu___4) ->
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Subst.compress t1 in
-                      uu___6.FStar_Syntax_Syntax.n in
-                    (match uu___5 with
-                     | FStar_Syntax_Syntax.Tm_fvar fv when
-                         let uu___6 =
-                           FStar_Ident.string_of_lid
-                             (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                         FStar_Syntax_Util.field_projector_contains_constructor
-                           uu___6
-                         ->
-                         let f =
-                           let uu___6 =
-                             let uu___7 =
-                               FStar_Ident.string_of_lid
-                                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                             [uu___7] in
-                           FStar_Ident.lid_of_path uu___6
-                             t1.FStar_Syntax_Syntax.pos in
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 = resugar_term' env t1 in (uu___8, f) in
-                           FStar_Parser_AST.Project uu___7 in
-                         mk uu___6
-                     | uu___6 -> resugar_term' env t1))
-           | FStar_Pervasives_Native.Some ("try_with", uu___2) when
-               (FStar_Compiler_List.length args1) > Prims.int_one ->
-               (try
-                  (fun uu___3 ->
-                     match () with
-                     | () ->
-                         let new_args = first_two_explicit args1 in
-                         let uu___4 =
-                           match new_args with
-                           | (a1, uu___5)::(a2, uu___6)::[] -> (a1, a2)
-                           | uu___5 -> failwith "wrong arguments to try_with" in
-                         (match uu___4 with
-                          | (body, handler) ->
-                              let decomp term =
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Syntax_Subst.compress term in
-                                  uu___6.FStar_Syntax_Syntax.n in
-                                match uu___5 with
-                                | FStar_Syntax_Syntax.Tm_abs (x, e1, uu___6)
-                                    ->
-                                    let uu___7 =
-                                      FStar_Syntax_Subst.open_term x e1 in
-                                    (match uu___7 with | (x1, e2) -> e2)
-                                | uu___6 ->
-                                    let uu___7 =
-                                      let uu___8 =
-                                        let uu___9 = resugar_term' env term in
-                                        FStar_Parser_AST.term_to_string
-                                          uu___9 in
-                                      Prims.op_Hat
-                                        "wrong argument format to try_with: "
-                                        uu___8 in
-                                    failwith uu___7 in
-                              let body1 =
-                                let uu___5 = decomp body in
-                                resugar_term' env uu___5 in
-                              let handler1 =
-                                let uu___5 = decomp handler in
-                                resugar_term' env uu___5 in
-                              let rec resugar_body t1 =
-                                match t1.FStar_Parser_AST.tm with
-                                | FStar_Parser_AST.Match
-                                    (e1, FStar_Pervasives_Native.None,
-                                     FStar_Pervasives_Native.None,
-                                     (uu___5, uu___6, b)::[])
-                                    -> b
-                                | FStar_Parser_AST.Let (uu___5, uu___6, b) ->
-                                    b
-                                | FStar_Parser_AST.Ascribed
-                                    (t11, t2, t3, use_eq) ->
-                                    let uu___5 =
-                                      let uu___6 =
-                                        let uu___7 = resugar_body t11 in
-                                        (uu___7, t2, t3, use_eq) in
-                                      FStar_Parser_AST.Ascribed uu___6 in
-                                    mk uu___5
-                                | uu___5 ->
-                                    failwith
-                                      "unexpected body format to try_with" in
-                              let e1 = resugar_body body1 in
-                              let rec resugar_branches t1 =
-                                match t1.FStar_Parser_AST.tm with
-                                | FStar_Parser_AST.Match
-                                    (e2, FStar_Pervasives_Native.None,
-                                     FStar_Pervasives_Native.None, branches)
-                                    -> branches
-                                | FStar_Parser_AST.Ascribed
-                                    (t11, t2, t3, uu___5) ->
-                                    resugar_branches t11
-                                | uu___5 -> [] in
-                              let branches = resugar_branches handler1 in
-                              mk (FStar_Parser_AST.TryWith (e1, branches))))
-                    ()
-                with | uu___4 -> resugar_as_app e args1)
-           | FStar_Pervasives_Native.Some ("try_with", uu___2) ->
-               resugar_as_app e args1
-           | FStar_Pervasives_Native.Some (op, uu___2) when
-               (((((((op = "=") || (op = "==")) || (op = "===")) ||
-                     (op = "@"))
-                    || (op = ":="))
-                   || (op = "|>"))
-                  || (op = "<<"))
-                 && (FStar_Options.print_implicits ())
-               -> resugar_as_app e args1
-           | FStar_Pervasives_Native.Some (op, uu___2) when
-               (op = "forall") || (op = "exists") ->
-               let rec uncurry xs pats t1 =
-                 match t1.FStar_Parser_AST.tm with
-                 | FStar_Parser_AST.QExists (xs', (uu___3, pats'), body) ->
-                     uncurry (FStar_Compiler_List.op_At xs xs')
-                       (FStar_Compiler_List.op_At pats pats') body
-                 | FStar_Parser_AST.QForall (xs', (uu___3, pats'), body) ->
-                     uncurry (FStar_Compiler_List.op_At xs xs')
-                       (FStar_Compiler_List.op_At pats pats') body
-                 | uu___3 -> (xs, pats, t1) in
-               let resugar_forall_body body =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Subst.compress body in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 match uu___3 with
-                 | FStar_Syntax_Syntax.Tm_abs (xs, body1, uu___4) ->
-                     let uu___5 = FStar_Syntax_Subst.open_term xs body1 in
-                     (match uu___5 with
-                      | (xs1, body2) ->
-                          let xs2 =
-                            let uu___6 = FStar_Options.print_implicits () in
-                            if uu___6 then xs1 else filter_imp_bs xs1 in
-                          let xs3 =
-                            FStar_Compiler_Effect.op_Bar_Greater xs2
-                              ((map_opt ())
-                                 (fun b ->
-                                    resugar_binder' env b
-                                      t.FStar_Syntax_Syntax.pos)) in
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 = FStar_Syntax_Subst.compress body2 in
-                              uu___8.FStar_Syntax_Syntax.n in
-                            match uu___7 with
-                            | FStar_Syntax_Syntax.Tm_meta (e1, m) ->
-                                let body3 = resugar_term' env e1 in
-                                let uu___8 =
-                                  match m with
-                                  | FStar_Syntax_Syntax.Meta_pattern
-                                      (uu___9, pats) ->
-                                      let uu___10 =
-                                        FStar_Compiler_List.map
-                                          (fun es ->
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               es
-                                               (FStar_Compiler_List.map
-                                                  (fun uu___11 ->
-                                                     match uu___11 with
-                                                     | (e2, uu___12) ->
-                                                         resugar_term' env e2)))
-                                          pats in
-                                      (uu___10, body3)
-                                  | FStar_Syntax_Syntax.Meta_labeled
-                                      (s, r, p) ->
-                                      let uu___9 =
-                                        mk
-                                          (FStar_Parser_AST.Labeled
-                                             (body3, s, p)) in
-                                      ([], uu___9)
-                                  | uu___9 ->
-                                      failwith
-                                        "wrong pattern format for QForall/QExists" in
-                                (match uu___8 with
-                                 | (pats, body4) -> (pats, body4))
-                            | uu___8 ->
-                                let uu___9 = resugar_term' env body2 in
-                                ([], uu___9) in
-                          (match uu___6 with
-                           | (pats, body3) ->
-                               let uu___7 = uncurry xs3 pats body3 in
-                               (match uu___7 with
-                                | (xs4, pats1, body4) ->
-                                    if op = "forall"
-                                    then
-                                      let uu___8 =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            let uu___11 =
-                                              FStar_Parser_AST.idents_of_binders
-                                                xs4 t.FStar_Syntax_Syntax.pos in
-                                            (uu___11, pats1) in
-                                          (xs4, uu___10, body4) in
-                                        FStar_Parser_AST.QForall uu___9 in
-                                      mk uu___8
-                                    else
-                                      (let uu___9 =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             let uu___12 =
-                                               FStar_Parser_AST.idents_of_binders
-                                                 xs4
-                                                 t.FStar_Syntax_Syntax.pos in
-                                             (uu___12, pats1) in
-                                           (xs4, uu___11, body4) in
-                                         FStar_Parser_AST.QExists uu___10 in
-                                       mk uu___9))))
-                 | uu___4 ->
-                     if op = "forall"
-                     then
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 = resugar_term' env body in
-                           ([], ([], []), uu___7) in
-                         FStar_Parser_AST.QForall uu___6 in
-                       mk uu___5
-                     else
-                       (let uu___6 =
-                          let uu___7 =
-                            let uu___8 = resugar_term' env body in
-                            ([], ([], []), uu___8) in
-                          FStar_Parser_AST.QExists uu___7 in
-                        mk uu___6) in
-               if (FStar_Compiler_List.length args1) > Prims.int_zero
-               then
-                 let args2 = last args1 in
-                 (match args2 with
-                  | (b, uu___3)::[] -> resugar_forall_body b
-                  | uu___3 -> failwith "wrong args format to QForall")
-               else resugar_as_app e args1
-           | FStar_Pervasives_Native.Some ("alloc", uu___2) ->
-               let uu___3 = FStar_Compiler_List.hd args1 in
-               (match uu___3 with | (e1, uu___4) -> resugar_term' env e1)
-           | FStar_Pervasives_Native.Some (op, expected_arity1) ->
-               let op1 = FStar_Ident.id_of_text op in
-               let resugar args2 =
-                 FStar_Compiler_Effect.op_Bar_Greater args2
-                   (FStar_Compiler_List.map
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | (e1, qual) ->
-                             let uu___3 = resugar_term' env e1 in
-                             let uu___4 = resugar_aqual env qual in
-                             (uu___3, uu___4))) in
-               (match expected_arity1 with
-                | FStar_Pervasives_Native.None ->
-                    let resugared_args = resugar args1 in
-                    let expect_n =
-                      FStar_Parser_ToDocument.handleable_args_length op1 in
-                    if
-                      (FStar_Compiler_List.length resugared_args) >= expect_n
-                    then
-                      let uu___2 =
-                        FStar_Compiler_Util.first_N expect_n resugared_args in
-                      (match uu___2 with
-                       | (op_args, rest) ->
-                           let head =
-                             let uu___3 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   FStar_Compiler_List.map
-                                     FStar_Pervasives_Native.fst op_args in
-                                 (op1, uu___5) in
-                               FStar_Parser_AST.Op uu___4 in
-                             mk uu___3 in
-                           FStar_Compiler_List.fold_left
-                             (fun head1 ->
-                                fun uu___3 ->
-                                  match uu___3 with
-                                  | (arg, qual) ->
-                                      mk
-                                        (FStar_Parser_AST.App
-                                           (head1, arg, qual))) head rest)
-                    else resugar_as_app e args1
-                | FStar_Pervasives_Native.Some n when
-                    (FStar_Compiler_List.length args1) = n ->
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = resugar args1 in
-                          FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                            uu___5 in
-                        (op1, uu___4) in
-                      FStar_Parser_AST.Op uu___3 in
-                    mk uu___2
-                | uu___2 -> resugar_as_app e args1))
-      | FStar_Syntax_Syntax.Tm_match
-          (e, FStar_Pervasives_Native.None, (pat, wopt, t1)::[], uu___1) ->
-          let uu___2 = FStar_Syntax_Subst.open_branch (pat, wopt, t1) in
-          (match uu___2 with
-           | (pat1, wopt1, t2) ->
-               let branch_bv = FStar_Syntax_Free.names t2 in
-               let bnds =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = resugar_pat' env pat1 branch_bv in
-                     let uu___6 = resugar_term' env e in (uu___5, uu___6) in
-                   (FStar_Pervasives_Native.None, uu___4) in
-                 [uu___3] in
-               let body = resugar_term' env t2 in
-               mk
-                 (FStar_Parser_AST.Let
-                    (FStar_Parser_AST.NoLetQualifier, bnds, body)))
-      | FStar_Syntax_Syntax.Tm_match
-          (e, asc_opt, (pat1, uu___1, t1)::(pat2, uu___2, t2)::[], uu___3)
-          when (is_true_pat pat1) && (is_wild_pat pat2) ->
-          let asc_opt1 =
-            resugar_match_returns env e t.FStar_Syntax_Syntax.pos asc_opt in
-          let uu___4 =
-            let uu___5 =
-              let uu___6 = resugar_term' env e in
-              let uu___7 = resugar_term' env t1 in
-              let uu___8 = resugar_term' env t2 in
-              (uu___6, FStar_Pervasives_Native.None, asc_opt1, uu___7,
-                uu___8) in
-            FStar_Parser_AST.If uu___5 in
-          mk uu___4
-      | FStar_Syntax_Syntax.Tm_match (e, asc_opt, branches, uu___1) ->
-          let resugar_branch uu___2 =
-            match uu___2 with
-            | (pat, wopt, b) ->
-                let uu___3 = FStar_Syntax_Subst.open_branch (pat, wopt, b) in
-                (match uu___3 with
-                 | (pat1, wopt1, b1) ->
-                     let branch_bv = FStar_Syntax_Free.names b1 in
-                     let pat2 = resugar_pat' env pat1 branch_bv in
-                     let wopt2 =
-                       match wopt1 with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.None
-                       | FStar_Pervasives_Native.Some e1 ->
-                           let uu___4 = resugar_term' env e1 in
-                           FStar_Pervasives_Native.Some uu___4 in
-                     let b2 = resugar_term' env b1 in (pat2, wopt2, b2)) in
-          let asc_opt1 =
-            resugar_match_returns env e t.FStar_Syntax_Syntax.pos asc_opt in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = resugar_term' env e in
-              let uu___5 = FStar_Compiler_List.map resugar_branch branches in
-              (uu___4, FStar_Pervasives_Native.None, asc_opt1, uu___5) in
-            FStar_Parser_AST.Match uu___3 in
-          mk uu___2
-      | FStar_Syntax_Syntax.Tm_ascribed (e, asc, uu___1) ->
-          let uu___2 = resugar_ascription env asc in
-          (match uu___2 with
-           | (asc1, tac_opt, b) ->
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = resugar_term' env e in
-                   (uu___5, asc1, tac_opt, b) in
-                 FStar_Parser_AST.Ascribed uu___4 in
-               mk uu___3)
-      | FStar_Syntax_Syntax.Tm_let ((is_rec, source_lbs), body) ->
-          let mk_pat a =
-            FStar_Parser_AST.mk_pattern a t.FStar_Syntax_Syntax.pos in
-          let uu___1 = FStar_Syntax_Subst.open_let_rec source_lbs body in
-          (match uu___1 with
-           | (source_lbs1, body1) ->
-               let resugar_one_binding bnd =
-                 let attrs_opt =
-                   match bnd.FStar_Syntax_Syntax.lbattrs with
-                   | [] -> FStar_Pervasives_Native.None
-                   | tms ->
-                       let uu___2 =
-                         FStar_Compiler_List.map (resugar_term' env) tms in
-                       FStar_Pervasives_Native.Some uu___2 in
-                 let uu___2 =
-                   let uu___3 =
-                     FStar_Syntax_Util.mk_conj bnd.FStar_Syntax_Syntax.lbtyp
-                       bnd.FStar_Syntax_Syntax.lbdef in
-                   FStar_Syntax_Subst.open_univ_vars
-                     bnd.FStar_Syntax_Syntax.lbunivs uu___3 in
-                 match uu___2 with
-                 | (univs, td) ->
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 = FStar_Syntax_Subst.compress td in
-                         uu___5.FStar_Syntax_Syntax.n in
-                       match uu___4 with
-                       | FStar_Syntax_Syntax.Tm_app
-                           (uu___5, (t1, uu___6)::(d, uu___7)::[]) -> 
-                           (t1, d)
-                       | uu___5 -> failwith "wrong let binding format" in
-                     (match uu___3 with
-                      | (typ, def) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = FStar_Syntax_Subst.compress def in
-                              uu___6.FStar_Syntax_Syntax.n in
-                            match uu___5 with
-                            | FStar_Syntax_Syntax.Tm_abs (b, t1, uu___6) ->
-                                let uu___7 =
-                                  FStar_Syntax_Subst.open_term b t1 in
-                                (match uu___7 with
-                                 | (b1, t2) ->
-                                     let b2 =
-                                       let uu___8 =
-                                         FStar_Options.print_implicits () in
-                                       if uu___8
-                                       then b1
-                                       else filter_imp_bs b1 in
-                                     (b2, t2, true))
-                            | uu___6 -> ([], def, false) in
-                          (match uu___4 with
-                           | (binders, term, is_pat_app) ->
-                               let uu___5 =
-                                 match bnd.FStar_Syntax_Syntax.lbname with
-                                 | FStar_Pervasives.Inr fv ->
-                                     ((mk_pat
-                                         (FStar_Parser_AST.PatName
-                                            ((fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v))),
-                                       term)
-                                 | FStar_Pervasives.Inl bv ->
-                                     let uu___6 =
-                                       let uu___7 =
-                                         let uu___8 =
-                                           let uu___9 = bv_as_unique_ident bv in
-                                           (uu___9,
-                                             FStar_Pervasives_Native.None,
-                                             []) in
-                                         FStar_Parser_AST.PatVar uu___8 in
-                                       mk_pat uu___7 in
-                                     (uu___6, term) in
-                               (match uu___5 with
-                                | (pat, term1) ->
-                                    let uu___6 =
-                                      if is_pat_app
-                                      then
-                                        let args =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            binders
-                                            ((map_opt ())
-                                               (fun b ->
-                                                  let uu___7 =
-                                                    resugar_bqual env
-                                                      b.FStar_Syntax_Syntax.binder_qual in
-                                                  FStar_Compiler_Util.map_opt
-                                                    uu___7
-                                                    (fun q ->
-                                                       let uu___8 =
-                                                         let uu___9 =
-                                                           let uu___10 =
-                                                             bv_as_unique_ident
-                                                               b.FStar_Syntax_Syntax.binder_bv in
-                                                           let uu___11 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               b.FStar_Syntax_Syntax.binder_attrs
-                                                               (FStar_Compiler_List.map
-                                                                  (resugar_term'
-                                                                    env)) in
-                                                           (uu___10, q,
-                                                             uu___11) in
-                                                         FStar_Parser_AST.PatVar
-                                                           uu___9 in
-                                                       mk_pat uu___8))) in
-                                        let uu___7 =
-                                          let uu___8 =
-                                            resugar_term' env term1 in
-                                          ((mk_pat
-                                              (FStar_Parser_AST.PatApp
-                                                 (pat, args))), uu___8) in
-                                        let uu___8 = universe_to_string univs in
-                                        (uu___7, uu___8)
-                                      else
-                                        (let uu___8 =
-                                           let uu___9 =
-                                             resugar_term' env term1 in
-                                           (pat, uu___9) in
-                                         let uu___9 =
-                                           universe_to_string univs in
-                                         (uu___8, uu___9)) in
-                                    (attrs_opt, uu___6)))) in
-               let r =
-                 FStar_Compiler_List.map resugar_one_binding source_lbs1 in
-               let bnds =
-                 let f uu___2 =
-                   match uu___2 with
-                   | (attrs, (pb, univs)) ->
-                       let uu___3 =
-                         let uu___4 = FStar_Options.print_universes () in
-                         Prims.op_Negation uu___4 in
-                       if uu___3
-                       then (attrs, pb)
-                       else
-                         (attrs,
-                           ((FStar_Pervasives_Native.fst pb),
-                             (label univs (FStar_Pervasives_Native.snd pb)))) in
-                 FStar_Compiler_List.map f r in
-               let body2 = resugar_term' env body1 in
-               mk
-                 (FStar_Parser_AST.Let
-                    ((if is_rec
-                      then FStar_Parser_AST.Rec
-                      else FStar_Parser_AST.NoLetQualifier), bnds, body2)))
-      | FStar_Syntax_Syntax.Tm_uvar (u, uu___1) ->
-          let s =
-            let uu___2 =
-              let uu___3 =
-                FStar_Syntax_Unionfind.uvar_id
-                  u.FStar_Syntax_Syntax.ctx_uvar_head in
-              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                FStar_Compiler_Util.string_of_int in
-            Prims.op_Hat "?u" uu___2 in
-          let uu___2 = mk FStar_Parser_AST.Wild in label s uu___2
-      | FStar_Syntax_Syntax.Tm_quoted (tm, qi) ->
-          let qi1 =
-            match qi.FStar_Syntax_Syntax.qkind with
-            | FStar_Syntax_Syntax.Quote_static -> FStar_Parser_AST.Static
-            | FStar_Syntax_Syntax.Quote_dynamic -> FStar_Parser_AST.Dynamic in
-          let uu___1 =
-            let uu___2 = let uu___3 = resugar_term' env tm in (uu___3, qi1) in
-            FStar_Parser_AST.Quote uu___2 in
-          mk uu___1
-      | FStar_Syntax_Syntax.Tm_meta (e, m) ->
-          let resugar_meta_desugared uu___1 =
-            match uu___1 with
-            | FStar_Syntax_Syntax.Sequence ->
-                let term = resugar_term' env e in
-                let rec resugar_seq t1 =
-                  match t1.FStar_Parser_AST.tm with
-                  | FStar_Parser_AST.Let (uu___2, (uu___3, (p, t11))::[], t2)
-                      -> mk (FStar_Parser_AST.Seq (t11, t2))
-                  | FStar_Parser_AST.Ascribed (t11, t2, t3, use_eq) ->
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 = resugar_seq t11 in
-                          (uu___4, t2, t3, use_eq) in
-                        FStar_Parser_AST.Ascribed uu___3 in
-                      mk uu___2
-                  | uu___2 -> t1 in
-                resugar_seq term
-            | FStar_Syntax_Syntax.Machine_integer (uu___2, uu___3) ->
-                resugar_term' env e
-            | FStar_Syntax_Syntax.Primop -> resugar_term' env e
-            | FStar_Syntax_Syntax.Masked_effect -> resugar_term' env e
-            | FStar_Syntax_Syntax.Meta_smt_pat -> resugar_term' env e in
-          (match m with
-           | FStar_Syntax_Syntax.Meta_pattern (uu___1, pats) ->
-               let pats1 =
-                 FStar_Compiler_Effect.op_Bar_Greater
-                   (FStar_Compiler_List.flatten pats)
-                   (FStar_Compiler_List.map
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | (x, uu___3) -> resugar_term' env x)) in
-               mk (FStar_Parser_AST.Attributes pats1)
-           | FStar_Syntax_Syntax.Meta_labeled uu___1 -> resugar_term' env e
-           | FStar_Syntax_Syntax.Meta_desugared i -> resugar_meta_desugared i
-           | FStar_Syntax_Syntax.Meta_named t1 ->
-               mk (FStar_Parser_AST.Name t1)
-           | FStar_Syntax_Syntax.Meta_monadic uu___1 -> resugar_term' env e
-           | FStar_Syntax_Syntax.Meta_monadic_lift uu___1 ->
-               resugar_term' env e)
-      | FStar_Syntax_Syntax.Tm_unknown -> mk FStar_Parser_AST.Wild
-and (resugar_ascription :
-  FStar_Syntax_DsEnv.env ->
-    ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-      FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-      ->
-      (FStar_Parser_AST.term * FStar_Parser_AST.term
-        FStar_Pervasives_Native.option * Prims.bool))
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | (asc, tac_opt, b) ->
-          let uu___1 =
-            match asc with
-            | FStar_Pervasives.Inl n -> resugar_term' env n
-            | FStar_Pervasives.Inr n -> resugar_comp' env n in
-          let uu___2 =
-            FStar_Compiler_Util.map_opt tac_opt (resugar_term' env) in
-          (uu___1, uu___2, b)
-and (resugar_calc :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Parser_AST.term FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t0 ->
-      let mk a =
-        FStar_Parser_AST.mk_term a t0.FStar_Syntax_Syntax.pos
-          FStar_Parser_AST.Un in
-      let resugar_calc_finish t =
-        let uu___ = FStar_Syntax_Util.head_and_args t in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Util.un_uinst hd in
-                  FStar_Syntax_Subst.compress uu___4 in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (uu___2, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::
-                (rel, FStar_Pervasives_Native.None)::(uu___4,
-                                                      FStar_Pervasives_Native.Some
-                                                      {
-                                                        FStar_Syntax_Syntax.aqual_implicit
-                                                          = true;
-                                                        FStar_Syntax_Syntax.aqual_attributes
-                                                          = uu___5;_})::
-                (uu___6, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___7;_})::
-                (uu___8, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___9;_})::
-                (pf, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.calc_finish_lid
-                 ->
-                 let pf1 = FStar_Syntax_Util.unthunk pf in
-                 FStar_Pervasives_Native.Some (rel, pf1)
-             | uu___2 -> FStar_Pervasives_Native.None) in
-      let un_eta_rel rel =
-        let bv_eq_tm b t =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Subst.compress t in
-            uu___1.FStar_Syntax_Syntax.n in
-          match uu___ with
-          | FStar_Syntax_Syntax.Tm_name b' when
-              FStar_Syntax_Syntax.bv_eq b b' -> true
-          | uu___1 -> false in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress rel in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_abs (b1::b2::[], body, uu___1) ->
-            let uu___2 = FStar_Syntax_Subst.open_term [b1; b2] body in
-            (match uu___2 with
-             | (b11::b21::[], body1) ->
-                 let body2 = FStar_Syntax_Util.unascribe body1 in
-                 let body3 =
-                   let uu___3 = FStar_Syntax_Util.unb2t body2 in
-                   match uu___3 with
-                   | FStar_Pervasives_Native.Some body4 -> body4
-                   | FStar_Pervasives_Native.None -> body2 in
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Subst.compress body3 in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 (match uu___3 with
-                  | FStar_Syntax_Syntax.Tm_app (e, args) when
-                      (FStar_Compiler_List.length args) >= (Prims.of_int (2))
-                      ->
-                      (match FStar_Compiler_List.rev args with
-                       | (a1, FStar_Pervasives_Native.None)::(a2,
-                                                              FStar_Pervasives_Native.None)::rest
-                           ->
-                           let uu___4 =
-                             (bv_eq_tm b11.FStar_Syntax_Syntax.binder_bv a2)
-                               &&
-                               (bv_eq_tm b21.FStar_Syntax_Syntax.binder_bv a1) in
-                           if uu___4
-                           then
-                             let uu___5 =
-                               FStar_Syntax_Util.mk_app e
-                                 (FStar_Compiler_List.rev rest) in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               (fun uu___6 ->
-                                  FStar_Pervasives_Native.Some uu___6) uu___5
-                           else FStar_Pervasives_Native.Some rel
-                       | uu___4 -> FStar_Pervasives_Native.Some rel)
-                  | uu___4 -> FStar_Pervasives_Native.Some rel))
-        | uu___1 -> FStar_Pervasives_Native.Some rel in
-      let resugar_step pack =
-        let uu___ = FStar_Syntax_Util.head_and_args pack in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Util.un_uinst hd in
-                  FStar_Syntax_Subst.compress uu___4 in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (uu___2, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::
-                (uu___4, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___5;_})::
-                (uu___6, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___7;_})::
-                (rel, FStar_Pervasives_Native.None)::(z,
-                                                      FStar_Pervasives_Native.None)::
-                (uu___8, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___9;_})::
-                (pf, FStar_Pervasives_Native.None)::(j,
-                                                     FStar_Pervasives_Native.None)::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.calc_step_lid
-                 ->
-                 let pf1 = FStar_Syntax_Util.unthunk pf in
-                 let j1 = FStar_Syntax_Util.unthunk j in
-                 FStar_Pervasives_Native.Some (z, rel, j1, pf1)
-             | uu___2 -> FStar_Pervasives_Native.None) in
-      let resugar_init pack =
-        let uu___ = FStar_Syntax_Util.head_and_args pack in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Util.un_uinst hd in
-                  FStar_Syntax_Subst.compress uu___4 in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (uu___2, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::
-                (x, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.calc_init_lid
-                 -> FStar_Pervasives_Native.Some x
-             | uu___2 -> FStar_Pervasives_Native.None) in
-      let rec resugar_all_steps pack =
-        let uu___ = resugar_step pack in
-        match uu___ with
-        | FStar_Pervasives_Native.Some (t, r, j, k) ->
-            let uu___1 = resugar_all_steps k in
-            FStar_Compiler_Util.bind_opt uu___1
-              (fun uu___2 ->
-                 match uu___2 with
-                 | (steps, k1) ->
-                     FStar_Pervasives_Native.Some (((t, r, j) :: steps), k1))
-        | FStar_Pervasives_Native.None ->
-            FStar_Pervasives_Native.Some ([], pack) in
-      let resugar_rel rel =
-        let rel1 =
-          let uu___ = un_eta_rel rel in
-          match uu___ with
-          | FStar_Pervasives_Native.Some rel2 -> rel2
-          | FStar_Pervasives_Native.None -> rel in
-        let fallback uu___ =
-          let uu___1 =
-            let uu___2 = resugar_term' env rel1 in
-            FStar_Parser_AST.Paren uu___2 in
-          mk uu___1 in
-        let uu___ = FStar_Syntax_Util.head_and_args rel1 in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              (FStar_Options.print_implicits ()) &&
-                (FStar_Compiler_List.existsb
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (uu___3, q) ->
-                          FStar_Syntax_Syntax.is_aqual_implicit q) args) in
-            if uu___1
-            then fallback ()
-            else
-              (let uu___3 = resugar_term_as_op hd in
-               match uu___3 with
-               | FStar_Pervasives_Native.Some
-                   (s, FStar_Pervasives_Native.None) ->
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Ident.id_of_text s in (uu___6, []) in
-                     FStar_Parser_AST.Op uu___5 in
-                   mk uu___4
-               | FStar_Pervasives_Native.Some
-                   (s, FStar_Pervasives_Native.Some uu___4) when
-                   uu___4 = (Prims.of_int (2)) ->
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 = FStar_Ident.id_of_text s in (uu___7, []) in
-                     FStar_Parser_AST.Op uu___6 in
-                   mk uu___5
-               | uu___4 -> fallback ()) in
-      let build_calc rel x0 steps =
-        let r = resugar_term' env in
-        let uu___ =
-          let uu___1 =
-            let uu___2 = resugar_rel rel in
-            let uu___3 = r x0 in
-            let uu___4 =
-              FStar_Compiler_List.map
-                (fun uu___5 ->
-                   match uu___5 with
-                   | (z, rel1, j) ->
-                       let uu___6 =
-                         let uu___7 = resugar_rel rel1 in
-                         let uu___8 = r j in
-                         let uu___9 = r z in (uu___7, uu___8, uu___9) in
-                       FStar_Parser_AST.CalcStep uu___6) steps in
-            (uu___2, uu___3, uu___4) in
-          FStar_Parser_AST.CalcProof uu___1 in
-        mk uu___ in
-      let uu___ = resugar_calc_finish t0 in
-      FStar_Compiler_Util.bind_opt uu___
-        (fun uu___1 ->
-           match uu___1 with
-           | (rel, pack) ->
-               let uu___2 = resugar_all_steps pack in
-               FStar_Compiler_Util.bind_opt uu___2
-                 (fun uu___3 ->
-                    match uu___3 with
-                    | (steps, k) ->
-                        let uu___4 = resugar_init k in
-                        FStar_Compiler_Util.bind_opt uu___4
-                          (fun x0 ->
-                             let uu___5 =
-                               build_calc rel x0
-                                 (FStar_Compiler_List.rev steps) in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               (fun uu___6 ->
-                                  FStar_Pervasives_Native.Some uu___6) uu___5)))
-and (resugar_match_returns :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Compiler_Range.range ->
-        (FStar_Syntax_Syntax.binder *
-          ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-          FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-          Prims.bool)) FStar_Pervasives_Native.option ->
-          (FStar_Ident.ident FStar_Pervasives_Native.option *
-            FStar_Parser_AST.term * Prims.bool)
-            FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun scrutinee ->
-      fun r ->
-        fun asc_opt ->
-          match asc_opt with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some (b, asc) ->
-              let uu___ =
-                let uu___1 = FStar_Syntax_Subst.open_ascription [b] asc in
-                match uu___1 with
-                | (bs, asc1) ->
-                    let b1 = FStar_Compiler_List.hd bs in
-                    let uu___2 =
-                      let uu___3 =
-                        FStar_Ident.string_of_id
-                          (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.ppname in
-                      uu___3 = FStar_Parser_Const.match_returns_def_name in
-                    if uu___2
-                    then
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Subst.compress scrutinee in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            FStar_Syntax_Util.unascribe in
-                        uu___4.FStar_Syntax_Syntax.n in
-                      (match uu___3 with
-                       | FStar_Syntax_Syntax.Tm_name sbv ->
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Syntax_Syntax.bv_to_name sbv in
-                                   ((b1.FStar_Syntax_Syntax.binder_bv),
-                                     uu___8) in
-                                 FStar_Syntax_Syntax.NT uu___7 in
-                               [uu___6] in
-                             FStar_Syntax_Subst.subst_ascription uu___5 asc1 in
-                           (FStar_Pervasives_Native.None, uu___4)
-                       | uu___4 -> (FStar_Pervasives_Native.None, asc1))
-                    else ((FStar_Pervasives_Native.Some b1), asc1) in
-              (match uu___ with
-               | (bopt, asc1) ->
-                   let bopt1 =
-                     FStar_Compiler_Util.map_option
-                       (fun b1 ->
-                          let uu___1 =
-                            let uu___2 = resugar_binder' env b1 r in
-                            FStar_Compiler_Util.must uu___2 in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___1
-                            (FStar_Parser_AST.ident_of_binder r)) bopt in
-                   let uu___1 =
-                     let uu___2 = resugar_ascription env asc1 in
-                     match uu___2 with
-                     | (asc2, FStar_Pervasives_Native.None, use_eq) ->
-                         (asc2, use_eq)
-                     | uu___3 ->
-                         failwith
-                           "resugaring does not support match return annotation with a tactic" in
-                   (match uu___1 with
-                    | (asc2, use_eq) ->
-                        FStar_Pervasives_Native.Some (bopt1, asc2, use_eq)))
-and (resugar_comp' :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.comp -> FStar_Parser_AST.term)
-  =
-  fun env ->
-    fun c ->
-      let mk a =
-        FStar_Parser_AST.mk_term a c.FStar_Syntax_Syntax.pos
-          FStar_Parser_AST.Un in
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Total typ ->
-          let t = resugar_term' env typ in
-          let uu___ =
-            let uu___1 = FStar_Options.print_implicits () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then t
-          else
-            mk
-              (FStar_Parser_AST.Construct
-                 (FStar_Parser_Const.effect_Tot_lid,
-                   [(t, FStar_Parser_AST.Nothing)]))
-      | FStar_Syntax_Syntax.GTotal typ ->
-          let t = resugar_term' env typ in
-          mk
-            (FStar_Parser_AST.Construct
-               (FStar_Parser_Const.effect_GTot_lid,
-                 [(t, FStar_Parser_AST.Nothing)]))
-      | FStar_Syntax_Syntax.Comp c1 ->
-          let result =
-            let uu___ = resugar_term' env c1.FStar_Syntax_Syntax.result_typ in
-            (uu___, FStar_Parser_AST.Nothing) in
-          let uu___ =
-            (FStar_Ident.lid_equals c1.FStar_Syntax_Syntax.effect_name
-               FStar_Parser_Const.effect_Lemma_lid)
-              &&
-              ((FStar_Compiler_List.length c1.FStar_Syntax_Syntax.effect_args)
-                 = (Prims.of_int (3))) in
-          if uu___
-          then
-            let args =
-              FStar_Compiler_List.map
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (e, uu___2) ->
-                       let uu___3 = resugar_term' env e in
-                       (uu___3, FStar_Parser_AST.Nothing))
-                c1.FStar_Syntax_Syntax.effect_args in
-            let uu___1 =
-              match c1.FStar_Syntax_Syntax.effect_args with
-              | (pre, uu___2)::(post, uu___3)::(pats, uu___4)::[] ->
-                  (pre, post, pats)
-              | uu___2 -> failwith "impossible" in
-            (match uu___1 with
-             | (pre, post, pats) ->
-                 let pre1 =
-                   let uu___2 =
-                     FStar_Syntax_Util.is_fvar FStar_Parser_Const.true_lid
-                       pre in
-                   if uu___2 then [] else [pre] in
-                 let post1 = FStar_Syntax_Util.unthunk_lemma_post post in
-                 let pats1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Util.head_of pats in
-                     FStar_Syntax_Util.is_fvar FStar_Parser_Const.nil_lid
-                       uu___3 in
-                   if uu___2 then [] else [pats] in
-                 let pre2 =
-                   FStar_Compiler_List.map
-                     (fun t ->
-                        let uu___2 =
-                          let uu___3 =
-                            let uu___4 = resugar_term' env t in
-                            (uu___4, FStar_Pervasives_Native.None) in
-                          FStar_Parser_AST.Requires uu___3 in
-                        mk uu___2) pre1 in
-                 let post2 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = resugar_term' env post1 in
-                       (uu___4, FStar_Pervasives_Native.None) in
-                     FStar_Parser_AST.Ensures uu___3 in
-                   mk uu___2 in
-                 let pats2 =
-                   FStar_Compiler_List.map (resugar_term' env) pats1 in
-                 let rec aux l uu___2 =
-                   match uu___2 with
-                   | [] -> l
-                   | hd::tl ->
-                       (match hd with
-                        | FStar_Syntax_Syntax.DECREASES dec_order ->
-                            let d =
-                              match dec_order with
-                              | FStar_Syntax_Syntax.Decreases_lex ts ->
-                                  let uu___3 =
-                                    let uu___4 =
-                                      FStar_Compiler_Effect.op_Bar_Greater ts
-                                        (FStar_Compiler_List.map
-                                           (resugar_term' env)) in
-                                    FStar_Parser_AST.LexList uu___4 in
-                                  mk uu___3
-                              | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-                                  let uu___3 =
-                                    let uu___4 =
-                                      let uu___5 = resugar_term' env rel in
-                                      let uu___6 = resugar_term' env e in
-                                      (uu___5, uu___6) in
-                                    FStar_Parser_AST.WFOrder uu___4 in
-                                  mk uu___3 in
-                            let e =
-                              mk
-                                (FStar_Parser_AST.Decreases
-                                   (d, FStar_Pervasives_Native.None)) in
-                            aux (e :: l) tl
-                        | uu___3 -> aux l tl) in
-                 let decrease = aux [] c1.FStar_Syntax_Syntax.flags in
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_List.map
-                         (fun t -> (t, FStar_Parser_AST.Nothing))
-                         (FStar_Compiler_List.op_At pre2
-                            (FStar_Compiler_List.op_At (post2 :: decrease)
-                               pats2)) in
-                     ((c1.FStar_Syntax_Syntax.effect_name), uu___4) in
-                   FStar_Parser_AST.Construct uu___3 in
-                 mk uu___2)
-          else
-            (let uu___2 = FStar_Options.print_effect_args () in
-             if uu___2
-             then
-               let args =
-                 FStar_Compiler_List.map
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (e, uu___4) ->
-                          let uu___5 = resugar_term' env e in
-                          (uu___5, FStar_Parser_AST.Nothing))
-                   c1.FStar_Syntax_Syntax.effect_args in
-               let rec aux l uu___3 =
-                 match uu___3 with
-                 | [] -> l
-                 | hd::tl ->
-                     (match hd with
-                      | FStar_Syntax_Syntax.DECREASES d ->
-                          let ts =
-                            match d with
-                            | FStar_Syntax_Syntax.Decreases_lex ts1 -> ts1
-                            | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-                                [rel; e] in
-                          let es =
-                            FStar_Compiler_Effect.op_Bar_Greater ts
-                              (FStar_Compiler_List.map
-                                 (fun e ->
-                                    let uu___4 = resugar_term' env e in
-                                    (uu___4, FStar_Parser_AST.Nothing))) in
-                          aux (FStar_Compiler_List.op_At es l) tl
-                      | uu___4 -> aux l tl) in
-               let decrease = aux [] c1.FStar_Syntax_Syntax.flags in
-               mk
-                 (FStar_Parser_AST.Construct
-                    ((c1.FStar_Syntax_Syntax.effect_name),
-                      (FStar_Compiler_List.op_At (result :: decrease) args)))
-             else
-               mk
-                 (FStar_Parser_AST.Construct
-                    ((c1.FStar_Syntax_Syntax.effect_name), [result])))
-and (resugar_binder' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.binder ->
-      FStar_Compiler_Range.range ->
-        FStar_Parser_AST.binder FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun b ->
-      fun r ->
-        let uu___ = resugar_bqual env b.FStar_Syntax_Syntax.binder_qual in
-        FStar_Compiler_Util.map_opt uu___
-          (fun imp ->
-             let e =
-               resugar_term' env
-                 (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-             match e.FStar_Parser_AST.tm with
-             | FStar_Parser_AST.Wild ->
-                 let uu___1 =
-                   let uu___2 =
-                     bv_as_unique_ident b.FStar_Syntax_Syntax.binder_bv in
-                   FStar_Parser_AST.Variable uu___2 in
-                 FStar_Parser_AST.mk_binder uu___1 r
-                   FStar_Parser_AST.Type_level imp
-             | uu___1 ->
-                 let uu___2 =
-                   FStar_Syntax_Syntax.is_null_bv
-                     b.FStar_Syntax_Syntax.binder_bv in
-                 if uu___2
-                 then
-                   FStar_Parser_AST.mk_binder (FStar_Parser_AST.NoName e) r
-                     FStar_Parser_AST.Type_level imp
-                 else
-                   (let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          bv_as_unique_ident b.FStar_Syntax_Syntax.binder_bv in
-                        (uu___6, e) in
-                      FStar_Parser_AST.Annotated uu___5 in
-                    FStar_Parser_AST.mk_binder uu___4 r
-                      FStar_Parser_AST.Type_level imp))
-and (resugar_bv_as_pat' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.bv FStar_Compiler_Util.set ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-            FStar_Pervasives_Native.option -> FStar_Parser_AST.pattern)
-  =
-  fun env ->
-    fun v ->
-      fun aqual ->
-        fun body_bv ->
-          fun typ_opt ->
-            let mk a =
-              let uu___ = FStar_Syntax_Syntax.range_of_bv v in
-              FStar_Parser_AST.mk_pattern a uu___ in
-            let used = FStar_Compiler_Util.set_mem v body_bv in
-            let pat =
-              let uu___ =
-                if used
-                then
-                  let uu___1 =
-                    let uu___2 = bv_as_unique_ident v in (uu___2, aqual, []) in
-                  FStar_Parser_AST.PatVar uu___1
-                else FStar_Parser_AST.PatWild (aqual, []) in
-              mk uu___ in
-            match typ_opt with
-            | FStar_Pervasives_Native.None -> pat
-            | FStar_Pervasives_Native.Some
-                { FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_unknown;
-                  FStar_Syntax_Syntax.pos = uu___;
-                  FStar_Syntax_Syntax.vars = uu___1;
-                  FStar_Syntax_Syntax.hash_code = uu___2;_}
-                -> pat
-            | FStar_Pervasives_Native.Some typ ->
-                let uu___ = FStar_Options.print_bound_var_types () in
-                if uu___
-                then
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = resugar_term' env typ in
-                        (uu___4, FStar_Pervasives_Native.None) in
-                      (pat, uu___3) in
-                    FStar_Parser_AST.PatAscribed uu___2 in
-                  mk uu___1
-                else pat
-and (resugar_bv_as_pat :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.bv FStar_Compiler_Util.set ->
-          FStar_Parser_AST.pattern FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun x ->
-      fun qual ->
-        fun body_bv ->
-          let uu___ = resugar_bqual env qual in
-          FStar_Compiler_Util.map_opt uu___
-            (fun bq ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Subst.compress x.FStar_Syntax_Syntax.sort in
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (fun uu___3 -> FStar_Pervasives_Native.Some uu___3) uu___2 in
-               resugar_bv_as_pat' env x bq body_bv uu___1)
-and (resugar_pat' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.pat ->
-      FStar_Syntax_Syntax.bv FStar_Compiler_Util.set ->
-        FStar_Parser_AST.pattern)
-  =
-  fun env ->
-    fun p ->
-      fun branch_bv ->
-        let mk a = FStar_Parser_AST.mk_pattern a p.FStar_Syntax_Syntax.p in
-        let to_arg_qual bopt =
-          FStar_Compiler_Util.bind_opt bopt
-            (fun b ->
-               if b
-               then FStar_Pervasives_Native.Some FStar_Parser_AST.Implicit
-               else FStar_Pervasives_Native.None) in
-        let may_drop_implicits args =
-          (let uu___ = FStar_Options.print_implicits () in
-           Prims.op_Negation uu___) &&
-            (let uu___ =
-               FStar_Compiler_List.existsML
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | (pattern, is_implicit) ->
-                        let might_be_used =
-                          match pattern.FStar_Syntax_Syntax.v with
-                          | FStar_Syntax_Syntax.Pat_var bv ->
-                              FStar_Compiler_Util.set_mem bv branch_bv
-                          | FStar_Syntax_Syntax.Pat_wild uu___2 -> false
-                          | uu___2 -> true in
-                        is_implicit && might_be_used) args in
-             Prims.op_Negation uu___) in
-        let resugar_plain_pat_cons' fv args =
-          mk
-            (FStar_Parser_AST.PatApp
-               ((mk
-                   (FStar_Parser_AST.PatName
-                      ((fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v))),
-                 args)) in
-        let rec resugar_plain_pat_cons fv args =
-          let args1 =
-            let uu___ = may_drop_implicits args in
-            if uu___ then filter_pattern_imp args else args in
-          let args2 =
-            FStar_Compiler_List.map
-              (fun uu___ ->
-                 match uu___ with
-                 | (p1, b) -> aux p1 (FStar_Pervasives_Native.Some b)) args1 in
-          resugar_plain_pat_cons' fv args2
-        and aux p1 imp_opt =
-          match p1.FStar_Syntax_Syntax.v with
-          | FStar_Syntax_Syntax.Pat_constant c ->
-              mk (FStar_Parser_AST.PatConst c)
-          | FStar_Syntax_Syntax.Pat_cons (fv, uu___, []) ->
-              mk
-                (FStar_Parser_AST.PatName
-                   ((fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v))
-          | FStar_Syntax_Syntax.Pat_cons (fv, uu___, args) when
-              (FStar_Ident.lid_equals
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                 FStar_Parser_Const.nil_lid)
-                && (may_drop_implicits args)
-              ->
-              ((let uu___2 =
-                  let uu___3 =
-                    let uu___4 = filter_pattern_imp args in
-                    FStar_Compiler_List.isEmpty uu___4 in
-                  Prims.op_Negation uu___3 in
-                if uu___2
-                then
-                  FStar_Errors.log_issue p1.FStar_Syntax_Syntax.p
-                    (FStar_Errors.Warning_NilGivenExplicitArgs,
-                      "Prims.Nil given explicit arguments")
-                else ());
-               mk (FStar_Parser_AST.PatList []))
-          | FStar_Syntax_Syntax.Pat_cons (fv, uu___, args) when
-              (FStar_Ident.lid_equals
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                 FStar_Parser_Const.cons_lid)
-                && (may_drop_implicits args)
-              ->
-              let uu___1 = filter_pattern_imp args in
-              (match uu___1 with
-               | (hd, false)::(tl, false)::[] ->
-                   let hd' = aux hd (FStar_Pervasives_Native.Some false) in
-                   let uu___2 = aux tl (FStar_Pervasives_Native.Some false) in
-                   (match uu___2 with
-                    | { FStar_Parser_AST.pat = FStar_Parser_AST.PatList tl';
-                        FStar_Parser_AST.prange = p2;_} ->
-                        FStar_Parser_AST.mk_pattern
-                          (FStar_Parser_AST.PatList (hd' :: tl')) p2
-                    | tl' -> resugar_plain_pat_cons' fv [hd'; tl'])
-               | args' ->
-                   ((let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Compiler_Effect.op_Less_Bar
-                             FStar_Compiler_Util.string_of_int
-                             (FStar_Compiler_List.length args') in
-                         FStar_Compiler_Util.format1
-                           "Prims.Cons applied to %s explicit arguments"
-                           uu___5 in
-                       (FStar_Errors.Warning_ConsAppliedExplicitArgs, uu___4) in
-                     FStar_Errors.log_issue p1.FStar_Syntax_Syntax.p uu___3);
-                    resugar_plain_pat_cons fv args))
-          | FStar_Syntax_Syntax.Pat_cons (fv, uu___, args) when
-              (is_tuple_constructor_lid
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-                && (may_drop_implicits args)
-              ->
-              let args1 =
-                FStar_Compiler_Effect.op_Bar_Greater args
-                  (FStar_Compiler_List.filter_map
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | (p2, is_implicit) ->
-                            if is_implicit
-                            then FStar_Pervasives_Native.None
-                            else
-                              (let uu___3 =
-                                 aux p2 (FStar_Pervasives_Native.Some false) in
-                               FStar_Pervasives_Native.Some uu___3))) in
-              let is_dependent_tuple =
-                FStar_Parser_Const.is_dtuple_data_lid'
-                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-              mk (FStar_Parser_AST.PatTuple (args1, is_dependent_tuple))
-          | FStar_Syntax_Syntax.Pat_cons
-              ({ FStar_Syntax_Syntax.fv_name = uu___;
-                 FStar_Syntax_Syntax.fv_delta = uu___1;
-                 FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-                   (FStar_Syntax_Syntax.Record_ctor (name, fields));_},
-               uu___2, args)
-              ->
-              let fields1 =
-                let uu___3 =
-                  FStar_Compiler_Effect.op_Bar_Greater fields
-                    (FStar_Compiler_List.map
-                       (fun f -> FStar_Ident.lid_of_ids [f])) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Compiler_List.rev in
-              let args1 =
-                let uu___3 =
-                  FStar_Compiler_Effect.op_Bar_Greater args
-                    (FStar_Compiler_List.map
-                       (fun uu___4 ->
-                          match uu___4 with
-                          | (p2, b) ->
-                              aux p2 (FStar_Pervasives_Native.Some b))) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Compiler_List.rev in
-              let rec map2 l1 l2 =
-                match (l1, l2) with
-                | ([], []) -> []
-                | ([], hd::tl) -> []
-                | (hd::tl, []) ->
-                    let uu___3 = map2 tl [] in
-                    (hd,
-                      (mk
-                         (FStar_Parser_AST.PatWild
-                            (FStar_Pervasives_Native.None, []))))
-                      :: uu___3
-                | (hd1::tl1, hd2::tl2) ->
-                    let uu___3 = map2 tl1 tl2 in (hd1, hd2) :: uu___3 in
-              let args2 =
-                let uu___3 = map2 fields1 args1 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Compiler_List.rev in
-              mk (FStar_Parser_AST.PatRecord args2)
-          | FStar_Syntax_Syntax.Pat_cons (fv, uu___, args) ->
-              resugar_plain_pat_cons fv args
-          | FStar_Syntax_Syntax.Pat_var v ->
-              let uu___ =
-                let uu___1 =
-                  FStar_Ident.string_of_id v.FStar_Syntax_Syntax.ppname in
-                FStar_Parser_AST.string_to_op uu___1 in
-              (match uu___ with
-               | FStar_Pervasives_Native.Some (op, uu___1) ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Ident.range_of_id
-                             v.FStar_Syntax_Syntax.ppname in
-                         (op, uu___5) in
-                       FStar_Ident.mk_ident uu___4 in
-                     FStar_Parser_AST.PatOp uu___3 in
-                   mk uu___2
-               | FStar_Pervasives_Native.None ->
-                   let uu___1 = to_arg_qual imp_opt in
-                   resugar_bv_as_pat' env v uu___1 branch_bv
-                     FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Pat_wild uu___ ->
-              let uu___1 =
-                let uu___2 = let uu___3 = to_arg_qual imp_opt in (uu___3, []) in
-                FStar_Parser_AST.PatWild uu___2 in
-              mk uu___1
-          | FStar_Syntax_Syntax.Pat_dot_term uu___ ->
-              mk
-                (FStar_Parser_AST.PatWild
-                   ((FStar_Pervasives_Native.Some FStar_Parser_AST.Implicit),
-                     [])) in
-        aux p FStar_Pervasives_Native.None
-and (resugar_bqual :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.bqual ->
-      FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option
-        FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun q ->
-      match q with
-      | FStar_Pervasives_Native.None ->
-          FStar_Pervasives_Native.Some FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit b) ->
-          if b
-          then FStar_Pervasives_Native.None
-          else
-            FStar_Pervasives_Native.Some
-              (FStar_Pervasives_Native.Some FStar_Parser_AST.Implicit)
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality) ->
-          FStar_Pervasives_Native.Some
-            (FStar_Pervasives_Native.Some FStar_Parser_AST.Equality)
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) when
-          FStar_Syntax_Util.is_fvar FStar_Parser_Const.tcresolve_lid t ->
-          FStar_Pervasives_Native.Some
-            (FStar_Pervasives_Native.Some FStar_Parser_AST.TypeClassArg)
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = resugar_term' env t in
-              FStar_Parser_AST.Meta uu___2 in
-            FStar_Pervasives_Native.Some uu___1 in
-          FStar_Pervasives_Native.Some uu___
-and (resugar_aqual :
-  FStar_Syntax_DsEnv.env -> FStar_Syntax_Syntax.aqual -> FStar_Parser_AST.imp)
-  =
-  fun env ->
-    fun q ->
-      match q with
-      | FStar_Pervasives_Native.None -> FStar_Parser_AST.Nothing
-      | FStar_Pervasives_Native.Some a ->
-          if a.FStar_Syntax_Syntax.aqual_implicit
-          then FStar_Parser_AST.Hash
-          else FStar_Parser_AST.Nothing
-let (resugar_qualifier :
-  FStar_Syntax_Syntax.qualifier ->
-    FStar_Parser_AST.qualifier FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Assumption ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Assumption
-    | FStar_Syntax_Syntax.InternalAssumption -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.New ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.New
-    | FStar_Syntax_Syntax.Private ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Private
-    | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen ->
-        FStar_Pervasives_Native.Some
-          FStar_Parser_AST.Unfold_for_unification_and_vcgen
-    | FStar_Syntax_Syntax.Visible_default -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Irreducible ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Irreducible
-    | FStar_Syntax_Syntax.Inline_for_extraction ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Inline_for_extraction
-    | FStar_Syntax_Syntax.NoExtract ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.NoExtract
-    | FStar_Syntax_Syntax.Noeq ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Noeq
-    | FStar_Syntax_Syntax.Unopteq ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Unopteq
-    | FStar_Syntax_Syntax.TotalEffect ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.TotalEffect
-    | FStar_Syntax_Syntax.Logic -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Reifiable ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Reifiable
-    | FStar_Syntax_Syntax.Reflectable uu___1 ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Reflectable
-    | FStar_Syntax_Syntax.Discriminator uu___1 ->
-        FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Projector uu___1 -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.RecordType uu___1 -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.RecordConstructor uu___1 ->
-        FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Action uu___1 -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.ExceptionConstructor ->
-        FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.HasMaskedEffect -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Effect ->
-        FStar_Pervasives_Native.Some FStar_Parser_AST.Effect_qual
-    | FStar_Syntax_Syntax.OnlyName -> FStar_Pervasives_Native.None
-let (resugar_pragma : FStar_Syntax_Syntax.pragma -> FStar_Parser_AST.pragma)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.SetOptions s -> FStar_Parser_AST.SetOptions s
-    | FStar_Syntax_Syntax.ResetOptions s -> FStar_Parser_AST.ResetOptions s
-    | FStar_Syntax_Syntax.PushOptions s -> FStar_Parser_AST.PushOptions s
-    | FStar_Syntax_Syntax.PopOptions -> FStar_Parser_AST.PopOptions
-    | FStar_Syntax_Syntax.RestartSolver -> FStar_Parser_AST.RestartSolver
-    | FStar_Syntax_Syntax.PrintEffectsGraph ->
-        FStar_Parser_AST.PrintEffectsGraph
-let (resugar_typ :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.sigelt ->
-        (FStar_Syntax_Syntax.sigelts * FStar_Parser_AST.tycon))
-  =
-  fun env ->
-    fun datacon_ses ->
-      fun se ->
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_inductive_typ
-            (tylid, uvs, bs, _num_uniform, t, uu___, datacons) ->
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater datacon_ses
-                (FStar_Compiler_List.partition
-                   (fun se1 ->
-                      match se1.FStar_Syntax_Syntax.sigel with
-                      | FStar_Syntax_Syntax.Sig_datacon
-                          (uu___2, uu___3, uu___4, inductive_lid, uu___5,
-                           uu___6)
-                          -> FStar_Ident.lid_equals inductive_lid tylid
-                      | uu___2 -> failwith "unexpected")) in
-            (match uu___1 with
-             | (current_datacons, other_datacons) ->
-                 let bs1 =
-                   let uu___3 = FStar_Options.print_implicits () in
-                   if uu___3 then bs else filter_imp_bs bs in
-                 let bs2 =
-                   FStar_Compiler_Effect.op_Bar_Greater bs1
-                     ((map_opt ())
-                        (fun b ->
-                           resugar_binder' env b t.FStar_Syntax_Syntax.pos)) in
-                 let tyc =
-                   let uu___3 =
-                     FStar_Compiler_Effect.op_Bar_Greater
-                       se.FStar_Syntax_Syntax.sigquals
-                       (FStar_Compiler_Util.for_some
-                          (fun uu___4 ->
-                             match uu___4 with
-                             | FStar_Syntax_Syntax.RecordType uu___5 -> true
-                             | uu___5 -> false)) in
-                   if uu___3
-                   then
-                     let resugar_datacon_as_fields fields se1 =
-                       match se1.FStar_Syntax_Syntax.sigel with
-                       | FStar_Syntax_Syntax.Sig_datacon
-                           (uu___4, univs, term, uu___5, num, uu___6) ->
-                           let uu___7 =
-                             let uu___8 = FStar_Syntax_Subst.compress term in
-                             uu___8.FStar_Syntax_Syntax.n in
-                           (match uu___7 with
-                            | FStar_Syntax_Syntax.Tm_arrow (bs3, uu___8) ->
-                                let mfields =
-                                  FStar_Compiler_Effect.op_Bar_Greater bs3
-                                    (FStar_Compiler_List.map
-                                       (fun b ->
-                                          let q =
-                                            let uu___9 =
-                                              resugar_bqual env
-                                                b.FStar_Syntax_Syntax.binder_qual in
-                                            match uu___9 with
-                                            | FStar_Pervasives_Native.Some q1
-                                                -> q1
-                                            | FStar_Pervasives_Native.None ->
-                                                failwith
-                                                  "Unexpected inaccesible implicit argument of a data constructor while resugaring a record field" in
-                                          let uu___9 =
-                                            bv_as_unique_ident
-                                              b.FStar_Syntax_Syntax.binder_bv in
-                                          let uu___10 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              b.FStar_Syntax_Syntax.binder_attrs
-                                              (FStar_Compiler_List.map
-                                                 (resugar_term' env)) in
-                                          let uu___11 =
-                                            resugar_term' env
-                                              (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                          (uu___9, q, uu___10, uu___11))) in
-                                FStar_Compiler_List.op_At mfields fields
-                            | uu___8 -> failwith "unexpected")
-                       | uu___4 -> failwith "unexpected" in
-                     let fields =
-                       FStar_Compiler_List.fold_left
-                         resugar_datacon_as_fields [] current_datacons in
-                     let uu___4 =
-                       let uu___5 = FStar_Ident.ident_of_lid tylid in
-                       let uu___6 =
-                         FStar_Compiler_List.map (resugar_term' env)
-                           se.FStar_Syntax_Syntax.sigattrs in
-                       (uu___5, bs2, FStar_Pervasives_Native.None, uu___6,
-                         fields) in
-                     FStar_Parser_AST.TyconRecord uu___4
-                   else
-                     (let resugar_datacon constructors se1 =
-                        match se1.FStar_Syntax_Syntax.sigel with
-                        | FStar_Syntax_Syntax.Sig_datacon
-                            (l, univs, term, uu___5, num, uu___6) ->
-                            let c =
-                              let uu___7 = FStar_Ident.ident_of_lid l in
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 = resugar_term' env term in
-                                  FStar_Parser_AST.VpArbitrary uu___10 in
-                                FStar_Pervasives_Native.Some uu___9 in
-                              let uu___9 =
-                                FStar_Compiler_List.map (resugar_term' env)
-                                  se1.FStar_Syntax_Syntax.sigattrs in
-                              (uu___7, uu___8, uu___9) in
-                            c :: constructors
-                        | uu___5 -> failwith "unexpected" in
-                      let constructors =
-                        FStar_Compiler_List.fold_left resugar_datacon []
-                          current_datacons in
-                      let uu___5 =
-                        let uu___6 = FStar_Ident.ident_of_lid tylid in
-                        (uu___6, bs2, FStar_Pervasives_Native.None,
-                          constructors) in
-                      FStar_Parser_AST.TyconVariant uu___5) in
-                 (other_datacons, tyc))
-        | uu___ ->
-            failwith
-              "Impossible : only Sig_inductive_typ can be resugared as types"
-let (mk_decl :
-  FStar_Compiler_Range.range ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Parser_AST.decl' -> FStar_Parser_AST.decl)
-  =
-  fun r ->
-    fun q ->
-      fun d' ->
-        let uu___ = FStar_Compiler_List.choose resugar_qualifier q in
-        {
-          FStar_Parser_AST.d = d';
-          FStar_Parser_AST.drange = r;
-          FStar_Parser_AST.quals = uu___;
-          FStar_Parser_AST.attrs = []
-        }
-let (decl'_to_decl :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Parser_AST.decl' -> FStar_Parser_AST.decl)
-  =
-  fun se ->
-    fun d' ->
-      mk_decl se.FStar_Syntax_Syntax.sigrng se.FStar_Syntax_Syntax.sigquals
-        d'
-let (resugar_tscheme'' :
-  FStar_Syntax_DsEnv.env ->
-    Prims.string -> FStar_Syntax_Syntax.tscheme -> FStar_Parser_AST.decl)
-  =
-  fun env ->
-    fun name ->
-      fun ts ->
-        let uu___ = ts in
-        match uu___ with
-        | (univs, typ) ->
-            let name1 =
-              FStar_Ident.mk_ident (name, (typ.FStar_Syntax_Syntax.pos)) in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = resugar_term' env typ in
-                      (name1, [], FStar_Pervasives_Native.None, uu___6) in
-                    FStar_Parser_AST.TyconAbbrev uu___5 in
-                  [uu___4] in
-                (false, false, uu___3) in
-              FStar_Parser_AST.Tycon uu___2 in
-            mk_decl typ.FStar_Syntax_Syntax.pos [] uu___1
-let (resugar_tscheme' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.tscheme -> FStar_Parser_AST.decl)
-  = fun env -> fun ts -> resugar_tscheme'' env "tscheme" ts
-let (resugar_wp_eff_combinators :
-  FStar_Syntax_DsEnv.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.wp_eff_combinators ->
-        FStar_Parser_AST.decl Prims.list)
-  =
-  fun env ->
-    fun for_free ->
-      fun combs ->
-        let resugar_opt name tsopt =
-          match tsopt with
-          | FStar_Pervasives_Native.Some ts ->
-              let uu___ = resugar_tscheme'' env name ts in [uu___]
-          | FStar_Pervasives_Native.None -> [] in
-        let repr = resugar_opt "repr" combs.FStar_Syntax_Syntax.repr in
-        let return_repr =
-          resugar_opt "return_repr" combs.FStar_Syntax_Syntax.return_repr in
-        let bind_repr =
-          resugar_opt "bind_repr" combs.FStar_Syntax_Syntax.bind_repr in
-        if for_free
-        then
-          FStar_Compiler_List.op_At repr
-            (FStar_Compiler_List.op_At return_repr bind_repr)
-        else
-          (let uu___1 =
-             resugar_tscheme'' env "ret_wp" combs.FStar_Syntax_Syntax.ret_wp in
-           let uu___2 =
-             let uu___3 =
-               resugar_tscheme'' env "bind_wp"
-                 combs.FStar_Syntax_Syntax.bind_wp in
-             let uu___4 =
-               let uu___5 =
-                 resugar_tscheme'' env "stronger"
-                   combs.FStar_Syntax_Syntax.stronger in
-               let uu___6 =
-                 let uu___7 =
-                   resugar_tscheme'' env "if_then_else"
-                     combs.FStar_Syntax_Syntax.if_then_else in
-                 let uu___8 =
-                   let uu___9 =
-                     resugar_tscheme'' env "ite_wp"
-                       combs.FStar_Syntax_Syntax.ite_wp in
-                   let uu___10 =
-                     let uu___11 =
-                       resugar_tscheme'' env "close_wp"
-                         combs.FStar_Syntax_Syntax.close_wp in
-                     let uu___12 =
-                       let uu___13 =
-                         resugar_tscheme'' env "trivial"
-                           combs.FStar_Syntax_Syntax.trivial in
-                       uu___13 ::
-                         (FStar_Compiler_List.op_At repr
-                            (FStar_Compiler_List.op_At return_repr bind_repr)) in
-                     uu___11 :: uu___12 in
-                   uu___9 :: uu___10 in
-                 uu___7 :: uu___8 in
-               uu___5 :: uu___6 in
-             uu___3 :: uu___4 in
-           uu___1 :: uu___2)
-let (resugar_layered_eff_combinators :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.layered_eff_combinators ->
-      FStar_Parser_AST.decl Prims.list)
-  =
-  fun env ->
-    fun combs ->
-      let resugar name uu___ =
-        match uu___ with
-        | (ts, uu___1, uu___2) -> resugar_tscheme'' env name ts in
-      let resugar2 name uu___ =
-        match uu___ with | (ts, uu___1) -> resugar_tscheme'' env name ts in
-      let uu___ = resugar2 "repr" combs.FStar_Syntax_Syntax.l_repr in
-      let uu___1 =
-        let uu___2 = resugar2 "return" combs.FStar_Syntax_Syntax.l_return in
-        let uu___3 =
-          let uu___4 = resugar "bind" combs.FStar_Syntax_Syntax.l_bind in
-          let uu___5 =
-            let uu___6 =
-              resugar "subcomp" combs.FStar_Syntax_Syntax.l_subcomp in
-            let uu___7 =
-              let uu___8 =
-                resugar "if_then_else"
-                  combs.FStar_Syntax_Syntax.l_if_then_else in
-              [uu___8] in
-            uu___6 :: uu___7 in
-          uu___4 :: uu___5 in
-        uu___2 :: uu___3 in
-      uu___ :: uu___1
-let (resugar_combinators :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.eff_combinators -> FStar_Parser_AST.decl Prims.list)
-  =
-  fun env ->
-    fun combs ->
-      match combs with
-      | FStar_Syntax_Syntax.Primitive_eff combs1 ->
-          resugar_wp_eff_combinators env false combs1
-      | FStar_Syntax_Syntax.DM4F_eff combs1 ->
-          resugar_wp_eff_combinators env true combs1
-      | FStar_Syntax_Syntax.Layered_eff combs1 ->
-          resugar_layered_eff_combinators env combs1
-let (resugar_eff_decl' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.eff_decl -> FStar_Parser_AST.decl)
-  =
-  fun env ->
-    fun r ->
-      fun q ->
-        fun ed ->
-          let resugar_action d for_free =
-            let action_params =
-              FStar_Syntax_Subst.open_binders
-                d.FStar_Syntax_Syntax.action_params in
-            let uu___ =
-              FStar_Syntax_Subst.open_term action_params
-                d.FStar_Syntax_Syntax.action_defn in
-            match uu___ with
-            | (bs, action_defn) ->
-                let uu___1 =
-                  FStar_Syntax_Subst.open_term action_params
-                    d.FStar_Syntax_Syntax.action_typ in
-                (match uu___1 with
-                 | (bs1, action_typ) ->
-                     let action_params1 =
-                       let uu___2 = FStar_Options.print_implicits () in
-                       if uu___2
-                       then action_params
-                       else filter_imp_bs action_params in
-                     let action_params2 =
-                       let uu___2 =
-                         FStar_Compiler_Effect.op_Bar_Greater action_params1
-                           ((map_opt ()) (fun b -> resugar_binder' env b r)) in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___2
-                         FStar_Compiler_List.rev in
-                     let action_defn1 = resugar_term' env action_defn in
-                     let action_typ1 = resugar_term' env action_typ in
-                     if for_free
-                     then
-                       let a =
-                         let uu___2 =
-                           let uu___3 = FStar_Ident.lid_of_str "construct" in
-                           (uu___3,
-                             [(action_defn1, FStar_Parser_AST.Nothing);
-                             (action_typ1, FStar_Parser_AST.Nothing)]) in
-                         FStar_Parser_AST.Construct uu___2 in
-                       let t =
-                         FStar_Parser_AST.mk_term a r FStar_Parser_AST.Un in
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   FStar_Ident.ident_of_lid
-                                     d.FStar_Syntax_Syntax.action_name in
-                                 (uu___7, action_params2,
-                                   FStar_Pervasives_Native.None, t) in
-                               FStar_Parser_AST.TyconAbbrev uu___6 in
-                             [uu___5] in
-                           (false, false, uu___4) in
-                         FStar_Parser_AST.Tycon uu___3 in
-                       mk_decl r q uu___2
-                     else
-                       (let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  let uu___8 =
-                                    FStar_Ident.ident_of_lid
-                                      d.FStar_Syntax_Syntax.action_name in
-                                  (uu___8, action_params2,
-                                    FStar_Pervasives_Native.None,
-                                    action_defn1) in
-                                FStar_Parser_AST.TyconAbbrev uu___7 in
-                              [uu___6] in
-                            (false, false, uu___5) in
-                          FStar_Parser_AST.Tycon uu___4 in
-                        mk_decl r q uu___3)) in
-          let eff_name =
-            FStar_Ident.ident_of_lid ed.FStar_Syntax_Syntax.mname in
-          let uu___ =
-            let sig_ts =
-              FStar_Syntax_Util.effect_sig_ts
-                ed.FStar_Syntax_Syntax.signature in
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater sig_ts
-                FStar_Pervasives_Native.snd in
-            FStar_Syntax_Subst.open_term ed.FStar_Syntax_Syntax.binders
-              uu___1 in
-          match uu___ with
-          | (eff_binders, eff_typ) ->
-              let eff_binders1 =
-                let uu___1 = FStar_Options.print_implicits () in
-                if uu___1 then eff_binders else filter_imp_bs eff_binders in
-              let eff_binders2 =
-                let uu___1 =
-                  FStar_Compiler_Effect.op_Bar_Greater eff_binders1
-                    ((map_opt ()) (fun b -> resugar_binder' env b r)) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___1
-                  FStar_Compiler_List.rev in
-              let eff_typ1 = resugar_term' env eff_typ in
-              let mandatory_members_decls =
-                resugar_combinators env ed.FStar_Syntax_Syntax.combinators in
-              let actions =
-                FStar_Compiler_Effect.op_Bar_Greater
-                  ed.FStar_Syntax_Syntax.actions
-                  (FStar_Compiler_List.map (fun a -> resugar_action a false)) in
-              let decls =
-                FStar_Compiler_List.op_At mandatory_members_decls actions in
-              mk_decl r q
-                (FStar_Parser_AST.NewEffect
-                   (FStar_Parser_AST.DefineEffect
-                      (eff_name, eff_binders2, eff_typ1, decls)))
-let (resugar_sigelt' :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.sigelt ->
-      FStar_Parser_AST.decl FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun se ->
-      match se.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_bundle (ses, uu___) ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater ses
-              (FStar_Compiler_List.partition
-                 (fun se1 ->
-                    match se1.FStar_Syntax_Syntax.sigel with
-                    | FStar_Syntax_Syntax.Sig_inductive_typ uu___2 -> true
-                    | FStar_Syntax_Syntax.Sig_declare_typ uu___2 -> true
-                    | FStar_Syntax_Syntax.Sig_datacon uu___2 -> false
-                    | uu___2 ->
-                        failwith
-                          "Found a sigelt which is neither a type declaration or a data constructor in a sigelt")) in
-          (match uu___1 with
-           | (decl_typ_ses, datacon_ses) ->
-               let retrieve_datacons_and_resugar uu___2 se1 =
-                 match uu___2 with
-                 | (datacon_ses1, tycons) ->
-                     let uu___3 = resugar_typ env datacon_ses1 se1 in
-                     (match uu___3 with
-                      | (datacon_ses2, tyc) ->
-                          (datacon_ses2, (tyc :: tycons))) in
-               let uu___2 =
-                 FStar_Compiler_List.fold_left retrieve_datacons_and_resugar
-                   (datacon_ses, []) decl_typ_ses in
-               (match uu___2 with
-                | (leftover_datacons, tycons) ->
-                    (match leftover_datacons with
-                     | [] ->
-                         let uu___3 =
-                           decl'_to_decl se
-                             (FStar_Parser_AST.Tycon (false, false, tycons)) in
-                         FStar_Pervasives_Native.Some uu___3
-                     | se1::[] ->
-                         (match se1.FStar_Syntax_Syntax.sigel with
-                          | FStar_Syntax_Syntax.Sig_datacon
-                              (l, uu___3, uu___4, uu___5, uu___6, uu___7) ->
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 =
-                                    let uu___11 = FStar_Ident.ident_of_lid l in
-                                    (uu___11, FStar_Pervasives_Native.None) in
-                                  FStar_Parser_AST.Exception uu___10 in
-                                decl'_to_decl se1 uu___9 in
-                              FStar_Pervasives_Native.Some uu___8
-                          | uu___3 ->
-                              failwith
-                                "wrong format for resguar to Exception")
-                     | uu___3 -> failwith "Should not happen hopefully")))
-      | FStar_Syntax_Syntax.Sig_fail uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Sig_let (lbs, uu___) ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              se.FStar_Syntax_Syntax.sigquals
-              (FStar_Compiler_Util.for_some
-                 (fun uu___2 ->
-                    match uu___2 with
-                    | FStar_Syntax_Syntax.Projector (uu___3, uu___4) -> true
-                    | FStar_Syntax_Syntax.Discriminator uu___3 -> true
-                    | uu___3 -> false)) in
-          if uu___1
-          then FStar_Pervasives_Native.None
-          else
-            (let mk e =
-               FStar_Syntax_Syntax.mk e se.FStar_Syntax_Syntax.sigrng in
-             let dummy = mk FStar_Syntax_Syntax.Tm_unknown in
-             let desugared_let = mk (FStar_Syntax_Syntax.Tm_let (lbs, dummy)) in
-             let t = resugar_term' env desugared_let in
-             match t.FStar_Parser_AST.tm with
-             | FStar_Parser_AST.Let (isrec, lets, uu___3) ->
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 =
-                         FStar_Compiler_List.map FStar_Pervasives_Native.snd
-                           lets in
-                       (isrec, uu___7) in
-                     FStar_Parser_AST.TopLevelLet uu___6 in
-                   decl'_to_decl se uu___5 in
-                 FStar_Pervasives_Native.Some uu___4
-             | uu___3 -> failwith "Should not happen hopefully")
-      | FStar_Syntax_Syntax.Sig_assume (lid, uu___, fml) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Ident.ident_of_lid lid in
-                let uu___5 = resugar_term' env fml in (uu___4, uu___5) in
-              FStar_Parser_AST.Assume uu___3 in
-            decl'_to_decl se uu___2 in
-          FStar_Pervasives_Native.Some uu___1
-      | FStar_Syntax_Syntax.Sig_new_effect ed ->
-          let uu___ =
-            resugar_eff_decl' env se.FStar_Syntax_Syntax.sigrng
-              se.FStar_Syntax_Syntax.sigquals ed in
-          FStar_Pervasives_Native.Some uu___
-      | FStar_Syntax_Syntax.Sig_sub_effect e ->
-          let src = e.FStar_Syntax_Syntax.source in
-          let dst = e.FStar_Syntax_Syntax.target in
-          let lift_wp =
-            match e.FStar_Syntax_Syntax.lift_wp with
-            | FStar_Pervasives_Native.Some (uu___, t) ->
-                let uu___1 = resugar_term' env t in
-                FStar_Pervasives_Native.Some uu___1
-            | uu___ -> FStar_Pervasives_Native.None in
-          let lift =
-            match e.FStar_Syntax_Syntax.lift with
-            | FStar_Pervasives_Native.Some (uu___, t) ->
-                let uu___1 = resugar_term' env t in
-                FStar_Pervasives_Native.Some uu___1
-            | uu___ -> FStar_Pervasives_Native.None in
-          let op =
-            match (lift_wp, lift) with
-            | (FStar_Pervasives_Native.Some t, FStar_Pervasives_Native.None)
-                -> FStar_Parser_AST.NonReifiableLift t
-            | (FStar_Pervasives_Native.Some wp, FStar_Pervasives_Native.Some
-               t) -> FStar_Parser_AST.ReifiableLift (wp, t)
-            | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some t)
-                -> FStar_Parser_AST.LiftForFree t
-            | uu___ -> failwith "Should not happen hopefully" in
-          let uu___ =
-            decl'_to_decl se
-              (FStar_Parser_AST.SubEffect
-                 {
-                   FStar_Parser_AST.msource = src;
-                   FStar_Parser_AST.mdest = dst;
-                   FStar_Parser_AST.lift_op = op
-                 }) in
-          FStar_Pervasives_Native.Some uu___
-      | FStar_Syntax_Syntax.Sig_effect_abbrev (lid, vs, bs, c, flags) ->
-          let uu___ = FStar_Syntax_Subst.open_comp bs c in
-          (match uu___ with
-           | (bs1, c1) ->
-               let bs2 =
-                 let uu___1 = FStar_Options.print_implicits () in
-                 if uu___1 then bs1 else filter_imp_bs bs1 in
-               let bs3 =
-                 FStar_Compiler_Effect.op_Bar_Greater bs2
-                   ((map_opt ())
-                      (fun b ->
-                         resugar_binder' env b se.FStar_Syntax_Syntax.sigrng)) in
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 = FStar_Ident.ident_of_lid lid in
-                           let uu___8 = resugar_comp' env c1 in
-                           (uu___7, bs3, FStar_Pervasives_Native.None,
-                             uu___8) in
-                         FStar_Parser_AST.TyconAbbrev uu___6 in
-                       [uu___5] in
-                     (false, false, uu___4) in
-                   FStar_Parser_AST.Tycon uu___3 in
-                 decl'_to_decl se uu___2 in
-               FStar_Pervasives_Native.Some uu___1)
-      | FStar_Syntax_Syntax.Sig_pragma p ->
-          let uu___ =
-            decl'_to_decl se (FStar_Parser_AST.Pragma (resugar_pragma p)) in
-          FStar_Pervasives_Native.Some uu___
-      | FStar_Syntax_Syntax.Sig_declare_typ (lid, uvs, t) ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater
-              se.FStar_Syntax_Syntax.sigquals
-              (FStar_Compiler_Util.for_some
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | FStar_Syntax_Syntax.Projector (uu___2, uu___3) -> true
-                    | FStar_Syntax_Syntax.Discriminator uu___2 -> true
-                    | uu___2 -> false)) in
-          if uu___
-          then FStar_Pervasives_Native.None
-          else
-            (let t' =
-               let uu___2 =
-                 (let uu___3 = FStar_Options.print_universes () in
-                  Prims.op_Negation uu___3) ||
-                   (FStar_Compiler_List.isEmpty uvs) in
-               if uu___2
-               then resugar_term' env t
-               else
-                 (let uu___4 = FStar_Syntax_Subst.open_univ_vars uvs t in
-                  match uu___4 with
-                  | (uvs1, t1) ->
-                      let universes = universe_to_string uvs1 in
-                      let uu___5 = resugar_term' env t1 in
-                      label universes uu___5) in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = FStar_Ident.ident_of_lid lid in (uu___5, t') in
-                 FStar_Parser_AST.Val uu___4 in
-               decl'_to_decl se uu___3 in
-             FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Sig_splice (ids, t) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_List.map
-                    (fun l -> FStar_Ident.ident_of_lid l) ids in
-                let uu___4 = resugar_term' env t in (uu___3, uu___4) in
-              FStar_Parser_AST.Splice uu___2 in
-            decl'_to_decl se uu___1 in
-          FStar_Pervasives_Native.Some uu___
-      | FStar_Syntax_Syntax.Sig_inductive_typ uu___ ->
-          FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Sig_datacon uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Sig_polymonadic_bind
-          (m, n, p, (uu___, t), uu___1, uu___2) ->
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = resugar_term' env t in (m, n, p, uu___6) in
-              FStar_Parser_AST.Polymonadic_bind uu___5 in
-            decl'_to_decl se uu___4 in
-          FStar_Pervasives_Native.Some uu___3
-      | FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-          (m, n, (uu___, t), uu___1, uu___2) ->
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = let uu___6 = resugar_term' env t in (m, n, uu___6) in
-              FStar_Parser_AST.Polymonadic_subcomp uu___5 in
-            decl'_to_decl se uu___4 in
-          FStar_Pervasives_Native.Some uu___3
-let (empty_env : FStar_Syntax_DsEnv.env) =
-  FStar_Syntax_DsEnv.empty_env FStar_Parser_Dep.empty_deps
-let noenv : 'a . (FStar_Syntax_DsEnv.env -> 'a) -> 'a = fun f -> f empty_env
-let (resugar_term : FStar_Syntax_Syntax.term -> FStar_Parser_AST.term) =
-  fun t -> let uu___ = noenv resugar_term' in uu___ t
-let (resugar_sigelt :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Parser_AST.decl FStar_Pervasives_Native.option)
-  = fun se -> let uu___ = noenv resugar_sigelt' in uu___ se
-let (resugar_comp : FStar_Syntax_Syntax.comp -> FStar_Parser_AST.term) =
-  fun c -> let uu___ = noenv resugar_comp' in uu___ c
-let (resugar_pat :
-  FStar_Syntax_Syntax.pat ->
-    FStar_Syntax_Syntax.bv FStar_Compiler_Util.set ->
-      FStar_Parser_AST.pattern)
-  =
-  fun p ->
-    fun branch_bv -> let uu___ = noenv resugar_pat' in uu___ p branch_bv
-let (resugar_binder :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Compiler_Range.range ->
-      FStar_Parser_AST.binder FStar_Pervasives_Native.option)
-  = fun b -> fun r -> let uu___ = noenv resugar_binder' in uu___ b r
-let (resugar_tscheme : FStar_Syntax_Syntax.tscheme -> FStar_Parser_AST.decl)
-  = fun ts -> let uu___ = noenv resugar_tscheme' in uu___ ts
-let (resugar_eff_decl :
-  FStar_Compiler_Range.range ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Syntax_Syntax.eff_decl -> FStar_Parser_AST.decl)
-  =
-  fun r ->
-    fun q -> fun ed -> let uu___ = noenv resugar_eff_decl' in uu___ r q ed
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Subst.ml b/src/ocaml-output/FStar_Syntax_Subst.ml
deleted file mode 100644
index f4f3988595b..00000000000
--- a/src/ocaml-output/FStar_Syntax_Subst.ml
+++ /dev/null
@@ -1,2185 +0,0 @@
-open Prims
-let subst_to_string :
-  'uuuuu . (FStar_Syntax_Syntax.bv * 'uuuuu) Prims.list -> Prims.string =
-  fun s ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater s
-        (FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with
-              | (b, uu___2) ->
-                  FStar_Ident.string_of_id b.FStar_Syntax_Syntax.ppname)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let rec apply_until_some :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu -> 'uuuuu1 FStar_Pervasives_Native.option) ->
-      'uuuuu Prims.list ->
-        ('uuuuu Prims.list * 'uuuuu1) FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun s ->
-      match s with
-      | [] -> FStar_Pervasives_Native.None
-      | s0::rest ->
-          let uu___ = f s0 in
-          (match uu___ with
-           | FStar_Pervasives_Native.None -> apply_until_some f rest
-           | FStar_Pervasives_Native.Some st ->
-               FStar_Pervasives_Native.Some (rest, st))
-let map_some_curry :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    ('uuuuu -> 'uuuuu1 -> 'uuuuu2) ->
-      'uuuuu2 -> ('uuuuu * 'uuuuu1) FStar_Pervasives_Native.option -> 'uuuuu2
-  =
-  fun f ->
-    fun x ->
-      fun uu___ ->
-        match uu___ with
-        | FStar_Pervasives_Native.None -> x
-        | FStar_Pervasives_Native.Some (a, b) -> f a b
-let apply_until_some_then_map :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    ('uuuuu -> 'uuuuu1 FStar_Pervasives_Native.option) ->
-      'uuuuu Prims.list ->
-        ('uuuuu Prims.list -> 'uuuuu1 -> 'uuuuu2) -> 'uuuuu2 -> 'uuuuu2
-  =
-  fun f ->
-    fun s ->
-      fun g ->
-        fun t ->
-          let uu___ = apply_until_some f s in
-          FStar_Compiler_Effect.op_Bar_Greater uu___ (map_some_curry g t)
-let compose_subst :
-  'uuuuu .
-    ('uuuuu Prims.list * FStar_Syntax_Syntax.maybe_set_use_range) ->
-      ('uuuuu Prims.list * FStar_Syntax_Syntax.maybe_set_use_range) ->
-        ('uuuuu Prims.list * FStar_Syntax_Syntax.maybe_set_use_range)
-  =
-  fun s1 ->
-    fun s2 ->
-      let s =
-        FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst s1)
-          (FStar_Pervasives_Native.fst s2) in
-      let ropt =
-        match FStar_Pervasives_Native.snd s2 with
-        | FStar_Syntax_Syntax.SomeUseRange uu___ ->
-            FStar_Pervasives_Native.snd s2
-        | uu___ -> FStar_Pervasives_Native.snd s1 in
-      (s, ropt)
-let (delay :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    (FStar_Syntax_Syntax.subst_elt Prims.list Prims.list *
-      FStar_Syntax_Syntax.maybe_set_use_range) -> FStar_Syntax_Syntax.term)
-  =
-  fun t ->
-    fun s ->
-      match t.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_delayed (t', s') ->
-          FStar_Syntax_Syntax.mk_Tm_delayed (t', (compose_subst s' s))
-            t.FStar_Syntax_Syntax.pos
-      | uu___ ->
-          FStar_Syntax_Syntax.mk_Tm_delayed (t, s) t.FStar_Syntax_Syntax.pos
-let rec (force_uvar' :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax * Prims.bool))
-  =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_uvar
-        ({ FStar_Syntax_Syntax.ctx_uvar_head = uv;
-           FStar_Syntax_Syntax.ctx_uvar_gamma = uu___;
-           FStar_Syntax_Syntax.ctx_uvar_binders = uu___1;
-           FStar_Syntax_Syntax.ctx_uvar_reason = uu___2;
-           FStar_Syntax_Syntax.ctx_uvar_range = uu___3;
-           FStar_Syntax_Syntax.ctx_uvar_meta = uu___4;_},
-         s)
-        ->
-        let uu___5 = FStar_Syntax_Unionfind.find uv in
-        (match uu___5 with
-         | FStar_Pervasives_Native.Some t' ->
-             let uu___6 =
-               let uu___7 = let uu___8 = delay t' s in force_uvar' uu___8 in
-               FStar_Pervasives_Native.fst uu___7 in
-             (uu___6, true)
-         | uu___6 -> (t, false))
-    | uu___ -> (t, false)
-let (force_uvar :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let uu___ = force_uvar' t in
-    match uu___ with
-    | (t', forced) ->
-        if forced
-        then
-          delay t'
-            ([],
-              (FStar_Syntax_Syntax.SomeUseRange (t.FStar_Syntax_Syntax.pos)))
-        else t
-let rec (compress_univ :
-  FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe) =
-  fun u ->
-    match u with
-    | FStar_Syntax_Syntax.U_unif u' ->
-        let uu___ = FStar_Syntax_Unionfind.univ_find u' in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some u1 -> compress_univ u1
-         | uu___1 -> u)
-    | uu___ -> u
-let (subst_bv :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.subst_elt Prims.list ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun a ->
-    fun s ->
-      FStar_Compiler_Util.find_map s
-        (fun uu___ ->
-           match uu___ with
-           | FStar_Syntax_Syntax.DB (i, x) when
-               i = a.FStar_Syntax_Syntax.index ->
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Syntax.range_of_bv a in
-                   FStar_Syntax_Syntax.set_range_of_bv x uu___3 in
-                 FStar_Syntax_Syntax.bv_to_name uu___2 in
-               FStar_Pervasives_Native.Some uu___1
-           | uu___1 -> FStar_Pervasives_Native.None)
-let (subst_nm :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.subst_elt Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option)
-  =
-  fun a ->
-    fun s ->
-      FStar_Compiler_Util.find_map s
-        (fun uu___ ->
-           match uu___ with
-           | FStar_Syntax_Syntax.NM (x, i) when FStar_Syntax_Syntax.bv_eq a x
-               ->
-               let uu___1 =
-                 FStar_Syntax_Syntax.bv_to_tm
-                   {
-                     FStar_Syntax_Syntax.ppname =
-                       (a.FStar_Syntax_Syntax.ppname);
-                     FStar_Syntax_Syntax.index = i;
-                     FStar_Syntax_Syntax.sort = (a.FStar_Syntax_Syntax.sort)
-                   } in
-               FStar_Pervasives_Native.Some uu___1
-           | FStar_Syntax_Syntax.NT (x, t) when FStar_Syntax_Syntax.bv_eq a x
-               -> FStar_Pervasives_Native.Some t
-           | uu___1 -> FStar_Pervasives_Native.None)
-let (subst_univ_bv :
-  Prims.int ->
-    FStar_Syntax_Syntax.subst_elt Prims.list ->
-      FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option)
-  =
-  fun x ->
-    fun s ->
-      FStar_Compiler_Util.find_map s
-        (fun uu___ ->
-           match uu___ with
-           | FStar_Syntax_Syntax.UN (y, t) when x = y ->
-               FStar_Pervasives_Native.Some t
-           | uu___1 -> FStar_Pervasives_Native.None)
-let (subst_univ_nm :
-  FStar_Syntax_Syntax.univ_name ->
-    FStar_Syntax_Syntax.subst_elt Prims.list ->
-      FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option)
-  =
-  fun x ->
-    fun s ->
-      FStar_Compiler_Util.find_map s
-        (fun uu___ ->
-           match uu___ with
-           | FStar_Syntax_Syntax.UD (y, i) when FStar_Ident.ident_equals x y
-               -> FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.U_bvar i)
-           | uu___1 -> FStar_Pervasives_Native.None)
-let rec (subst_univ :
-  FStar_Syntax_Syntax.subst_elt Prims.list Prims.list ->
-    FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe)
-  =
-  fun s ->
-    fun u ->
-      let u1 = compress_univ u in
-      match u1 with
-      | FStar_Syntax_Syntax.U_bvar x ->
-          apply_until_some_then_map (subst_univ_bv x) s subst_univ u1
-      | FStar_Syntax_Syntax.U_name x ->
-          apply_until_some_then_map (subst_univ_nm x) s subst_univ u1
-      | FStar_Syntax_Syntax.U_zero -> u1
-      | FStar_Syntax_Syntax.U_unknown -> u1
-      | FStar_Syntax_Syntax.U_unif uu___ -> u1
-      | FStar_Syntax_Syntax.U_succ u2 ->
-          let uu___ = subst_univ s u2 in FStar_Syntax_Syntax.U_succ uu___
-      | FStar_Syntax_Syntax.U_max us ->
-          let uu___ = FStar_Compiler_List.map (subst_univ s) us in
-          FStar_Syntax_Syntax.U_max uu___
-let tag_with_range :
-  'uuuuu .
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      ('uuuuu * FStar_Syntax_Syntax.maybe_set_use_range) ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-  =
-  fun t ->
-    fun s ->
-      match FStar_Pervasives_Native.snd s with
-      | FStar_Syntax_Syntax.NoUseRange -> t
-      | FStar_Syntax_Syntax.SomeUseRange r ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Range.use_range t.FStar_Syntax_Syntax.pos in
-            let uu___2 = FStar_Compiler_Range.use_range r in
-            FStar_Compiler_Range.rng_included uu___1 uu___2 in
-          if uu___
-          then t
-          else
-            (let r1 =
-               let uu___2 = FStar_Compiler_Range.use_range r in
-               FStar_Compiler_Range.set_use_range t.FStar_Syntax_Syntax.pos
-                 uu___2 in
-             let t' =
-               match t.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_bvar bv ->
-                   let uu___2 = FStar_Syntax_Syntax.set_range_of_bv bv r1 in
-                   FStar_Syntax_Syntax.Tm_bvar uu___2
-               | FStar_Syntax_Syntax.Tm_name bv ->
-                   let uu___2 = FStar_Syntax_Syntax.set_range_of_bv bv r1 in
-                   FStar_Syntax_Syntax.Tm_name uu___2
-               | FStar_Syntax_Syntax.Tm_fvar fv ->
-                   let l = FStar_Syntax_Syntax.lid_of_fv fv in
-                   let v =
-                     let uu___2 = fv.FStar_Syntax_Syntax.fv_name in
-                     let uu___3 = FStar_Ident.set_lid_range l r1 in
-                     {
-                       FStar_Syntax_Syntax.v = uu___3;
-                       FStar_Syntax_Syntax.p = (uu___2.FStar_Syntax_Syntax.p)
-                     } in
-                   let fv1 =
-                     {
-                       FStar_Syntax_Syntax.fv_name = v;
-                       FStar_Syntax_Syntax.fv_delta =
-                         (fv.FStar_Syntax_Syntax.fv_delta);
-                       FStar_Syntax_Syntax.fv_qual =
-                         (fv.FStar_Syntax_Syntax.fv_qual)
-                     } in
-                   FStar_Syntax_Syntax.Tm_fvar fv1
-               | t'1 -> t'1 in
-             {
-               FStar_Syntax_Syntax.n = t';
-               FStar_Syntax_Syntax.pos = r1;
-               FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-               FStar_Syntax_Syntax.hash_code =
-                 (t.FStar_Syntax_Syntax.hash_code)
-             })
-let tag_lid_with_range :
-  'uuuuu .
-    FStar_Ident.lident ->
-      ('uuuuu * FStar_Syntax_Syntax.maybe_set_use_range) ->
-        FStar_Ident.lident
-  =
-  fun l ->
-    fun s ->
-      match FStar_Pervasives_Native.snd s with
-      | FStar_Syntax_Syntax.NoUseRange -> l
-      | FStar_Syntax_Syntax.SomeUseRange r ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Ident.range_of_lid l in
-              FStar_Compiler_Range.use_range uu___2 in
-            let uu___2 = FStar_Compiler_Range.use_range r in
-            FStar_Compiler_Range.rng_included uu___1 uu___2 in
-          if uu___
-          then l
-          else
-            (let uu___2 =
-               let uu___3 = FStar_Ident.range_of_lid l in
-               let uu___4 = FStar_Compiler_Range.use_range r in
-               FStar_Compiler_Range.set_use_range uu___3 uu___4 in
-             FStar_Ident.set_lid_range l uu___2)
-let (mk_range :
-  FStar_Compiler_Range.range ->
-    FStar_Syntax_Syntax.subst_ts -> FStar_Compiler_Range.range)
-  =
-  fun r ->
-    fun s ->
-      match FStar_Pervasives_Native.snd s with
-      | FStar_Syntax_Syntax.NoUseRange -> r
-      | FStar_Syntax_Syntax.SomeUseRange r' ->
-          let uu___ =
-            let uu___1 = FStar_Compiler_Range.use_range r in
-            let uu___2 = FStar_Compiler_Range.use_range r' in
-            FStar_Compiler_Range.rng_included uu___1 uu___2 in
-          if uu___
-          then r
-          else
-            (let uu___2 = FStar_Compiler_Range.use_range r' in
-             FStar_Compiler_Range.set_use_range r uu___2)
-let rec (subst' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun s ->
-    fun t ->
-      let subst_tail tl = subst' (tl, (FStar_Pervasives_Native.snd s)) in
-      match s with
-      | ([], FStar_Syntax_Syntax.NoUseRange) -> t
-      | ([]::[], FStar_Syntax_Syntax.NoUseRange) -> t
-      | uu___ ->
-          let t0 = t in
-          (match t0.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_unknown -> tag_with_range t0 s
-           | FStar_Syntax_Syntax.Tm_constant uu___1 -> tag_with_range t0 s
-           | FStar_Syntax_Syntax.Tm_fvar uu___1 -> tag_with_range t0 s
-           | FStar_Syntax_Syntax.Tm_delayed (t', s') ->
-               FStar_Syntax_Syntax.mk_Tm_delayed (t', (compose_subst s' s))
-                 t.FStar_Syntax_Syntax.pos
-           | FStar_Syntax_Syntax.Tm_bvar a ->
-               apply_until_some_then_map (subst_bv a)
-                 (FStar_Pervasives_Native.fst s) subst_tail t0
-           | FStar_Syntax_Syntax.Tm_name a ->
-               apply_until_some_then_map (subst_nm a)
-                 (FStar_Pervasives_Native.fst s) subst_tail t0
-           | FStar_Syntax_Syntax.Tm_type u ->
-               let uu___1 =
-                 let uu___2 = subst_univ (FStar_Pervasives_Native.fst s) u in
-                 FStar_Syntax_Syntax.Tm_type uu___2 in
-               let uu___2 = mk_range t0.FStar_Syntax_Syntax.pos s in
-               FStar_Syntax_Syntax.mk uu___1 uu___2
-           | uu___1 ->
-               let uu___2 = mk_range t.FStar_Syntax_Syntax.pos s in
-               FStar_Syntax_Syntax.mk_Tm_delayed (t0, s) uu___2)
-let (subst_dec_order' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.decreases_order ->
-      FStar_Syntax_Syntax.decreases_order)
-  =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Syntax_Syntax.Decreases_lex l ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater l
-              (FStar_Compiler_List.map (subst' s)) in
-          FStar_Syntax_Syntax.Decreases_lex uu___1
-      | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-          let uu___1 =
-            let uu___2 = subst' s rel in
-            let uu___3 = subst' s e in (uu___2, uu___3) in
-          FStar_Syntax_Syntax.Decreases_wf uu___1
-let (subst_flags' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.cflag Prims.list ->
-      FStar_Syntax_Syntax.cflag Prims.list)
-  =
-  fun s ->
-    fun flags ->
-      FStar_Compiler_Effect.op_Bar_Greater flags
-        (FStar_Compiler_List.map
-           (fun uu___ ->
-              match uu___ with
-              | FStar_Syntax_Syntax.DECREASES dec_order ->
-                  let uu___1 = subst_dec_order' s dec_order in
-                  FStar_Syntax_Syntax.DECREASES uu___1
-              | f -> f))
-let (subst_bqual' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option)
-  =
-  fun s ->
-    fun i ->
-      match i with
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-          let uu___ =
-            let uu___1 = subst' s t in FStar_Syntax_Syntax.Meta uu___1 in
-          FStar_Pervasives_Native.Some uu___
-      | uu___ -> i
-let (subst_aqual' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.aqual -> FStar_Syntax_Syntax.aqual)
-  =
-  fun s ->
-    fun i ->
-      match i with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some a ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map (subst' s)
-                a.FStar_Syntax_Syntax.aqual_attributes in
-            {
-              FStar_Syntax_Syntax.aqual_implicit =
-                (a.FStar_Syntax_Syntax.aqual_implicit);
-              FStar_Syntax_Syntax.aqual_attributes = uu___1
-            } in
-          FStar_Pervasives_Native.Some uu___
-let (subst_comp_typ' :
-  (FStar_Syntax_Syntax.subst_elt Prims.list Prims.list *
-    FStar_Syntax_Syntax.maybe_set_use_range) ->
-    FStar_Syntax_Syntax.comp_typ -> FStar_Syntax_Syntax.comp_typ)
-  =
-  fun s ->
-    fun t ->
-      match s with
-      | ([], FStar_Syntax_Syntax.NoUseRange) -> t
-      | ([]::[], FStar_Syntax_Syntax.NoUseRange) -> t
-      | uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.map
-              (subst_univ (FStar_Pervasives_Native.fst s))
-              t.FStar_Syntax_Syntax.comp_univs in
-          let uu___2 = tag_lid_with_range t.FStar_Syntax_Syntax.effect_name s in
-          let uu___3 = subst' s t.FStar_Syntax_Syntax.result_typ in
-          let uu___4 =
-            FStar_Compiler_List.map
-              (fun uu___5 ->
-                 match uu___5 with
-                 | (t1, imp) ->
-                     let uu___6 = subst' s t1 in
-                     let uu___7 = subst_aqual' s imp in (uu___6, uu___7))
-              t.FStar_Syntax_Syntax.effect_args in
-          let uu___5 = subst_flags' s t.FStar_Syntax_Syntax.flags in
-          {
-            FStar_Syntax_Syntax.comp_univs = uu___1;
-            FStar_Syntax_Syntax.effect_name = uu___2;
-            FStar_Syntax_Syntax.result_typ = uu___3;
-            FStar_Syntax_Syntax.effect_args = uu___4;
-            FStar_Syntax_Syntax.flags = uu___5
-          }
-let (subst_comp' :
-  (FStar_Syntax_Syntax.subst_elt Prims.list Prims.list *
-    FStar_Syntax_Syntax.maybe_set_use_range) ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  =
-  fun s ->
-    fun t ->
-      match s with
-      | ([], FStar_Syntax_Syntax.NoUseRange) -> t
-      | ([]::[], FStar_Syntax_Syntax.NoUseRange) -> t
-      | uu___ ->
-          (match t.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Total t1 ->
-               let uu___1 = subst' s t1 in
-               FStar_Syntax_Syntax.mk_Total uu___1
-           | FStar_Syntax_Syntax.GTotal t1 ->
-               let uu___1 = subst' s t1 in
-               FStar_Syntax_Syntax.mk_GTotal uu___1
-           | FStar_Syntax_Syntax.Comp ct ->
-               let uu___1 = subst_comp_typ' s ct in
-               FStar_Syntax_Syntax.mk_Comp uu___1)
-let (subst_ascription' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.ascription ->
-      ((FStar_Syntax_Syntax.term,
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-        FStar_Pervasives.either * FStar_Syntax_Syntax.term
-        FStar_Pervasives_Native.option * Prims.bool))
-  =
-  fun s ->
-    fun asc ->
-      let uu___ = asc in
-      match uu___ with
-      | (annot, topt, use_eq) ->
-          let annot1 =
-            match annot with
-            | FStar_Pervasives.Inl t ->
-                let uu___1 = subst' s t in FStar_Pervasives.Inl uu___1
-            | FStar_Pervasives.Inr c ->
-                let uu___1 = subst_comp' s c in FStar_Pervasives.Inr uu___1 in
-          let uu___1 = FStar_Compiler_Util.map_opt topt (subst' s) in
-          (annot1, uu___1, use_eq)
-let (shift :
-  Prims.int -> FStar_Syntax_Syntax.subst_elt -> FStar_Syntax_Syntax.subst_elt)
-  =
-  fun n ->
-    fun s ->
-      match s with
-      | FStar_Syntax_Syntax.DB (i, t) -> FStar_Syntax_Syntax.DB ((i + n), t)
-      | FStar_Syntax_Syntax.UN (i, t) -> FStar_Syntax_Syntax.UN ((i + n), t)
-      | FStar_Syntax_Syntax.NM (x, i) -> FStar_Syntax_Syntax.NM (x, (i + n))
-      | FStar_Syntax_Syntax.UD (x, i) -> FStar_Syntax_Syntax.UD (x, (i + n))
-      | FStar_Syntax_Syntax.NT uu___ -> s
-let (shift_subst :
-  Prims.int -> FStar_Syntax_Syntax.subst_t -> FStar_Syntax_Syntax.subst_t) =
-  fun n -> fun s -> FStar_Compiler_List.map (shift n) s
-let shift_subst' :
-  'uuuuu .
-    Prims.int ->
-      (FStar_Syntax_Syntax.subst_t Prims.list * 'uuuuu) ->
-        (FStar_Syntax_Syntax.subst_t Prims.list * 'uuuuu)
-  =
-  fun n ->
-    fun s ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst s)
-          (FStar_Compiler_List.map (shift_subst n)) in
-      (uu___, (FStar_Pervasives_Native.snd s))
-let (subst_binder' :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder)
-  =
-  fun s ->
-    fun b ->
-      let uu___ =
-        let uu___1 = b.FStar_Syntax_Syntax.binder_bv in
-        let uu___2 =
-          subst' s (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-        {
-          FStar_Syntax_Syntax.ppname = (uu___1.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index = (uu___1.FStar_Syntax_Syntax.index);
-          FStar_Syntax_Syntax.sort = uu___2
-        } in
-      let uu___1 = subst_bqual' s b.FStar_Syntax_Syntax.binder_qual in
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater
-          b.FStar_Syntax_Syntax.binder_attrs
-          (FStar_Compiler_List.map (subst' s)) in
-      FStar_Syntax_Syntax.mk_binder_with_attrs uu___ uu___1 uu___2
-let (subst_binders' :
-  (FStar_Syntax_Syntax.subst_elt Prims.list Prims.list *
-    FStar_Syntax_Syntax.maybe_set_use_range) ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun s ->
-    fun bs ->
-      FStar_Compiler_Effect.op_Bar_Greater bs
-        (FStar_Compiler_List.mapi
-           (fun i ->
-              fun b ->
-                if i = Prims.int_zero
-                then subst_binder' s b
-                else
-                  (let uu___1 = shift_subst' i s in subst_binder' uu___1 b)))
-let (subst_binders :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders)
-  =
-  fun s -> fun bs -> subst_binders' ([s], FStar_Syntax_Syntax.NoUseRange) bs
-let subst_arg' :
-  'uuuuu .
-    FStar_Syntax_Syntax.subst_ts ->
-      (FStar_Syntax_Syntax.term * 'uuuuu) ->
-        (FStar_Syntax_Syntax.term * 'uuuuu)
-  =
-  fun s ->
-    fun uu___ ->
-      match uu___ with | (t, imp) -> let uu___1 = subst' s t in (uu___1, imp)
-let subst_args' :
-  'uuuuu .
-    FStar_Syntax_Syntax.subst_ts ->
-      (FStar_Syntax_Syntax.term * 'uuuuu) Prims.list ->
-        (FStar_Syntax_Syntax.term * 'uuuuu) Prims.list
-  = fun s -> FStar_Compiler_List.map (subst_arg' s)
-let (subst_univs_opt :
-  FStar_Syntax_Syntax.subst_elt Prims.list Prims.list ->
-    FStar_Syntax_Syntax.universe Prims.list FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.universe Prims.list FStar_Pervasives_Native.option)
-  =
-  fun sub ->
-    fun us_opt ->
-      match us_opt with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some us ->
-          let uu___ = FStar_Compiler_List.map (subst_univ sub) us in
-          FStar_Pervasives_Native.Some uu___
-let (subst_pat' :
-  (FStar_Syntax_Syntax.subst_t Prims.list *
-    FStar_Syntax_Syntax.maybe_set_use_range) ->
-    FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t ->
-      (FStar_Syntax_Syntax.pat * Prims.int))
-  =
-  fun s ->
-    fun p ->
-      let rec aux n p1 =
-        match p1.FStar_Syntax_Syntax.v with
-        | FStar_Syntax_Syntax.Pat_constant uu___ -> (p1, n)
-        | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-            let us_opt1 =
-              let uu___ =
-                let uu___1 = shift_subst' n s in
-                FStar_Pervasives_Native.fst uu___1 in
-              subst_univs_opt uu___ us_opt in
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater pats
-                (FStar_Compiler_List.fold_left
-                   (fun uu___1 ->
-                      fun uu___2 ->
-                        match (uu___1, uu___2) with
-                        | ((pats1, n1), (p2, imp)) ->
-                            let uu___3 = aux n1 p2 in
-                            (match uu___3 with
-                             | (p3, m) -> (((p3, imp) :: pats1), m))) 
-                   ([], n)) in
-            (match uu___ with
-             | (pats1, n1) ->
-                 ({
-                    FStar_Syntax_Syntax.v =
-                      (FStar_Syntax_Syntax.Pat_cons
-                         (fv, us_opt1, (FStar_Compiler_List.rev pats1)));
-                    FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-                  }, n1))
-        | FStar_Syntax_Syntax.Pat_var x ->
-            let s1 = shift_subst' n s in
-            let x1 =
-              let uu___ = subst' s1 x.FStar_Syntax_Syntax.sort in
-              {
-                FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-                FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                FStar_Syntax_Syntax.sort = uu___
-              } in
-            ({
-               FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_var x1);
-               FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-             }, (n + Prims.int_one))
-        | FStar_Syntax_Syntax.Pat_wild x ->
-            let s1 = shift_subst' n s in
-            let x1 =
-              let uu___ = subst' s1 x.FStar_Syntax_Syntax.sort in
-              {
-                FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-                FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                FStar_Syntax_Syntax.sort = uu___
-              } in
-            ({
-               FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_wild x1);
-               FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-             }, (n + Prims.int_one))
-        | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-            let s1 = shift_subst' n s in
-            let eopt1 = FStar_Compiler_Util.map_option (subst' s1) eopt in
-            ({
-               FStar_Syntax_Syntax.v =
-                 (FStar_Syntax_Syntax.Pat_dot_term eopt1);
-               FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-             }, n) in
-      aux Prims.int_zero p
-let (push_subst_lcomp :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option)
-  =
-  fun s ->
-    fun lopt ->
-      match lopt with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some rc ->
-          let residual_typ =
-            FStar_Compiler_Util.map_opt rc.FStar_Syntax_Syntax.residual_typ
-              (subst' s) in
-          let rc1 =
-            {
-              FStar_Syntax_Syntax.residual_effect =
-                (rc.FStar_Syntax_Syntax.residual_effect);
-              FStar_Syntax_Syntax.residual_typ = residual_typ;
-              FStar_Syntax_Syntax.residual_flags =
-                (rc.FStar_Syntax_Syntax.residual_flags)
-            } in
-          FStar_Pervasives_Native.Some rc1
-let (compose_uvar_subst :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.subst_ts ->
-      FStar_Syntax_Syntax.subst_ts -> FStar_Syntax_Syntax.subst_ts)
-  =
-  fun u ->
-    fun s0 ->
-      fun s ->
-        let should_retain x =
-          FStar_Compiler_Effect.op_Bar_Greater
-            u.FStar_Syntax_Syntax.ctx_uvar_binders
-            (FStar_Compiler_Util.for_some
-               (fun b ->
-                  FStar_Syntax_Syntax.bv_eq x b.FStar_Syntax_Syntax.binder_bv)) in
-        let rec aux uu___ =
-          match uu___ with
-          | [] -> []
-          | hd_subst::rest ->
-              let hd =
-                FStar_Compiler_Effect.op_Bar_Greater hd_subst
-                  (FStar_Compiler_List.collect
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | FStar_Syntax_Syntax.NT (x, t) ->
-                            let uu___2 = should_retain x in
-                            if uu___2
-                            then
-                              let uu___3 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    delay t
-                                      (rest, FStar_Syntax_Syntax.NoUseRange) in
-                                  (x, uu___5) in
-                                FStar_Syntax_Syntax.NT uu___4 in
-                              [uu___3]
-                            else []
-                        | FStar_Syntax_Syntax.NM (x, i) ->
-                            let uu___2 = should_retain x in
-                            if uu___2
-                            then
-                              let x_i =
-                                FStar_Syntax_Syntax.bv_to_tm
-                                  {
-                                    FStar_Syntax_Syntax.ppname =
-                                      (x.FStar_Syntax_Syntax.ppname);
-                                    FStar_Syntax_Syntax.index = i;
-                                    FStar_Syntax_Syntax.sort =
-                                      (x.FStar_Syntax_Syntax.sort)
-                                  } in
-                              let t =
-                                subst' (rest, FStar_Syntax_Syntax.NoUseRange)
-                                  x_i in
-                              (match t.FStar_Syntax_Syntax.n with
-                               | FStar_Syntax_Syntax.Tm_bvar x_j ->
-                                   [FStar_Syntax_Syntax.NM
-                                      (x, (x_j.FStar_Syntax_Syntax.index))]
-                               | uu___3 -> [FStar_Syntax_Syntax.NT (x, t)])
-                            else []
-                        | uu___2 -> [])) in
-              let uu___1 = aux rest in FStar_Compiler_List.op_At hd uu___1 in
-        let uu___ =
-          aux
-            (FStar_Compiler_List.op_At (FStar_Pervasives_Native.fst s0)
-               (FStar_Pervasives_Native.fst s)) in
-        match uu___ with
-        | [] -> ([], (FStar_Pervasives_Native.snd s))
-        | s' -> ([s'], (FStar_Pervasives_Native.snd s))
-let rec (push_subst :
-  FStar_Syntax_Syntax.subst_ts ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun s ->
-    fun t ->
-      let mk t' =
-        let uu___ = mk_range t.FStar_Syntax_Syntax.pos s in
-        FStar_Syntax_Syntax.mk t' uu___ in
-      match t.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-          failwith "Impossible (delayed node in push_subst)"
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          (match i.FStar_Syntax_Syntax.lkind with
-           | FStar_Syntax_Syntax.Lazy_embedding uu___ ->
-               let t1 =
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Compiler_Effect.op_Bang
-                       FStar_Syntax_Syntax.lazy_chooser in
-                   FStar_Compiler_Util.must uu___2 in
-                 uu___1 i.FStar_Syntax_Syntax.lkind i in
-               push_subst s t1
-           | uu___ -> tag_with_range t s)
-      | FStar_Syntax_Syntax.Tm_constant uu___ -> tag_with_range t s
-      | FStar_Syntax_Syntax.Tm_fvar uu___ -> tag_with_range t s
-      | FStar_Syntax_Syntax.Tm_unknown -> tag_with_range t s
-      | FStar_Syntax_Syntax.Tm_uvar (uv, s0) ->
-          let uu___ =
-            FStar_Syntax_Unionfind.find uv.FStar_Syntax_Syntax.ctx_uvar_head in
-          (match uu___ with
-           | FStar_Pervasives_Native.None ->
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = compose_uvar_subst uv s0 s in (uv, uu___4) in
-                   FStar_Syntax_Syntax.Tm_uvar uu___3 in
-                 {
-                   FStar_Syntax_Syntax.n = uu___2;
-                   FStar_Syntax_Syntax.pos = (t.FStar_Syntax_Syntax.pos);
-                   FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                   FStar_Syntax_Syntax.hash_code =
-                     (t.FStar_Syntax_Syntax.hash_code)
-                 } in
-               tag_with_range uu___1 s
-           | FStar_Pervasives_Native.Some t1 ->
-               push_subst (compose_subst s0 s) t1)
-      | FStar_Syntax_Syntax.Tm_type uu___ -> subst' s t
-      | FStar_Syntax_Syntax.Tm_bvar uu___ -> subst' s t
-      | FStar_Syntax_Syntax.Tm_name uu___ -> subst' s t
-      | FStar_Syntax_Syntax.Tm_uinst (t', us) ->
-          let us1 =
-            FStar_Compiler_List.map
-              (subst_univ (FStar_Pervasives_Native.fst s)) us in
-          let uu___ = mk (FStar_Syntax_Syntax.Tm_uinst (t', us1)) in
-          tag_with_range uu___ s
-      | FStar_Syntax_Syntax.Tm_app (t0, args) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst' s t0 in
-              let uu___3 = subst_args' s args in (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_app uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_ascribed (t0, asc, lopt) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst' s t0 in
-              let uu___3 = subst_ascription' s asc in (uu___2, uu___3, lopt) in
-            FStar_Syntax_Syntax.Tm_ascribed uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_abs (bs, body, lopt) ->
-          let n = FStar_Compiler_List.length bs in
-          let s' = shift_subst' n s in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst_binders' s bs in
-              let uu___3 = subst' s' body in
-              let uu___4 = push_subst_lcomp s' lopt in
-              (uu___2, uu___3, uu___4) in
-            FStar_Syntax_Syntax.Tm_abs uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_arrow (bs, comp) ->
-          let n = FStar_Compiler_List.length bs in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst_binders' s bs in
-              let uu___3 =
-                let uu___4 = shift_subst' n s in subst_comp' uu___4 comp in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_arrow uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-          let x1 =
-            let uu___ = subst' s x.FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___
-            } in
-          let phi1 =
-            let uu___ = shift_subst' Prims.int_one s in subst' uu___ phi in
-          mk (FStar_Syntax_Syntax.Tm_refine (x1, phi1))
-      | FStar_Syntax_Syntax.Tm_match (t0, asc_opt, pats, lopt) ->
-          let t01 = subst' s t0 in
-          let pats1 =
-            FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.map
-                 (fun uu___ ->
-                    match uu___ with
-                    | (pat, wopt, branch) ->
-                        let uu___1 = subst_pat' s pat in
-                        (match uu___1 with
-                         | (pat1, n) ->
-                             let s1 = shift_subst' n s in
-                             let wopt1 =
-                               match wopt with
-                               | FStar_Pervasives_Native.None ->
-                                   FStar_Pervasives_Native.None
-                               | FStar_Pervasives_Native.Some w ->
-                                   let uu___2 = subst' s1 w in
-                                   FStar_Pervasives_Native.Some uu___2 in
-                             let branch1 = subst' s1 branch in
-                             (pat1, wopt1, branch1)))) in
-          let asc_opt1 =
-            match asc_opt with
-            | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-            | FStar_Pervasives_Native.Some (b, asc) ->
-                let b1 = subst_binder' s b in
-                let asc1 =
-                  let uu___ = shift_subst' Prims.int_one s in
-                  subst_ascription' uu___ asc in
-                FStar_Pervasives_Native.Some (b1, asc1) in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = push_subst_lcomp s lopt in
-              (t01, asc_opt1, pats1, uu___2) in
-            FStar_Syntax_Syntax.Tm_match uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_let ((is_rec, lbs), body) ->
-          let n = FStar_Compiler_List.length lbs in
-          let sn = shift_subst' n s in
-          let body1 = subst' sn body in
-          let lbs1 =
-            FStar_Compiler_Effect.op_Bar_Greater lbs
-              (FStar_Compiler_List.map
-                 (fun lb ->
-                    let lbt = subst' s lb.FStar_Syntax_Syntax.lbtyp in
-                    let lbd =
-                      let uu___ =
-                        is_rec &&
-                          (FStar_Compiler_Util.is_left
-                             lb.FStar_Syntax_Syntax.lbname) in
-                      if uu___
-                      then subst' sn lb.FStar_Syntax_Syntax.lbdef
-                      else subst' s lb.FStar_Syntax_Syntax.lbdef in
-                    let lbname =
-                      match lb.FStar_Syntax_Syntax.lbname with
-                      | FStar_Pervasives.Inl x ->
-                          FStar_Pervasives.Inl
-                            {
-                              FStar_Syntax_Syntax.ppname =
-                                (x.FStar_Syntax_Syntax.ppname);
-                              FStar_Syntax_Syntax.index =
-                                (x.FStar_Syntax_Syntax.index);
-                              FStar_Syntax_Syntax.sort = lbt
-                            }
-                      | FStar_Pervasives.Inr fv -> FStar_Pervasives.Inr fv in
-                    let lbattrs =
-                      FStar_Compiler_List.map (subst' s)
-                        lb.FStar_Syntax_Syntax.lbattrs in
-                    {
-                      FStar_Syntax_Syntax.lbname = lbname;
-                      FStar_Syntax_Syntax.lbunivs =
-                        (lb.FStar_Syntax_Syntax.lbunivs);
-                      FStar_Syntax_Syntax.lbtyp = lbt;
-                      FStar_Syntax_Syntax.lbeff =
-                        (lb.FStar_Syntax_Syntax.lbeff);
-                      FStar_Syntax_Syntax.lbdef = lbd;
-                      FStar_Syntax_Syntax.lbattrs = lbattrs;
-                      FStar_Syntax_Syntax.lbpos =
-                        (lb.FStar_Syntax_Syntax.lbpos)
-                    })) in
-          mk (FStar_Syntax_Syntax.Tm_let ((is_rec, lbs1), body1))
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_pattern (bs, ps)) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst' s t0 in
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Compiler_List.map (subst' s) bs in
-                  let uu___6 =
-                    FStar_Compiler_Effect.op_Bar_Greater ps
-                      (FStar_Compiler_List.map (subst_args' s)) in
-                  (uu___5, uu___6) in
-                FStar_Syntax_Syntax.Meta_pattern uu___4 in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_monadic (m, t1)) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst' s t0 in
-              let uu___3 =
-                let uu___4 = let uu___5 = subst' s t1 in (m, uu___5) in
-                FStar_Syntax_Syntax.Meta_monadic uu___4 in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_monadic_lift (m1, m2, t1)) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = subst' s t0 in
-              let uu___3 =
-                let uu___4 = let uu___5 = subst' s t1 in (m1, m2, uu___5) in
-                FStar_Syntax_Syntax.Meta_monadic_lift uu___4 in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_quoted (tm, qi) ->
-          (match qi.FStar_Syntax_Syntax.qkind with
-           | FStar_Syntax_Syntax.Quote_dynamic ->
-               let uu___ =
-                 let uu___1 = let uu___2 = subst' s tm in (uu___2, qi) in
-                 FStar_Syntax_Syntax.Tm_quoted uu___1 in
-               mk uu___
-           | FStar_Syntax_Syntax.Quote_static ->
-               let qi1 = FStar_Syntax_Syntax.on_antiquoted (subst' s) qi in
-               mk (FStar_Syntax_Syntax.Tm_quoted (tm, qi1)))
-      | FStar_Syntax_Syntax.Tm_meta (t1, m) ->
-          let uu___ =
-            let uu___1 = let uu___2 = subst' s t1 in (uu___2, m) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk uu___
-let rec (compress_slow :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let t1 = force_uvar t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_delayed (t', s) ->
-        let uu___ = push_subst s t' in compress uu___
-    | uu___ -> t1
-and (compress : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_delayed (uu___, uu___1) ->
-        let r = compress_slow t in r
-    | FStar_Syntax_Syntax.Tm_uvar (uu___, uu___1) ->
-        let r = compress_slow t in r
-    | uu___ -> t
-let (subst :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun s -> fun t -> subst' ([s], FStar_Syntax_Syntax.NoUseRange) t
-let (set_use_range :
-  FStar_Compiler_Range.range ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun r ->
-    fun t ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Range.use_range r in
-            FStar_Compiler_Range.set_def_range r uu___3 in
-          FStar_Syntax_Syntax.SomeUseRange uu___2 in
-        ([], uu___1) in
-      subst' uu___ t
-let (subst_comp :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  = fun s -> fun t -> subst_comp' ([s], FStar_Syntax_Syntax.NoUseRange) t
-let (subst_bqual :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.bqual -> FStar_Syntax_Syntax.bqual)
-  =
-  fun s -> fun imp -> subst_bqual' ([s], FStar_Syntax_Syntax.NoUseRange) imp
-let (subst_aqual :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.aqual -> FStar_Syntax_Syntax.aqual)
-  =
-  fun s -> fun imp -> subst_aqual' ([s], FStar_Syntax_Syntax.NoUseRange) imp
-let (subst_ascription :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.ascription -> FStar_Syntax_Syntax.ascription)
-  =
-  fun s ->
-    fun asc -> subst_ascription' ([s], FStar_Syntax_Syntax.NoUseRange) asc
-let (subst_decreasing_order :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.decreases_order ->
-      FStar_Syntax_Syntax.decreases_order)
-  =
-  fun s ->
-    fun dec -> subst_dec_order' ([s], FStar_Syntax_Syntax.NoUseRange) dec
-let (subst_residual_comp :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.residual_comp -> FStar_Syntax_Syntax.residual_comp)
-  =
-  fun s ->
-    fun rc ->
-      match rc.FStar_Syntax_Syntax.residual_typ with
-      | FStar_Pervasives_Native.None -> rc
-      | FStar_Pervasives_Native.Some t ->
-          let uu___ =
-            let uu___1 = subst s t in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2) in
-          {
-            FStar_Syntax_Syntax.residual_effect =
-              (rc.FStar_Syntax_Syntax.residual_effect);
-            FStar_Syntax_Syntax.residual_typ = uu___;
-            FStar_Syntax_Syntax.residual_flags =
-              (rc.FStar_Syntax_Syntax.residual_flags)
-          }
-let (closing_subst :
-  FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.subst_elt Prims.list) =
-  fun bs ->
-    let uu___ =
-      FStar_Compiler_List.fold_right
-        (fun b ->
-           fun uu___1 ->
-             match uu___1 with
-             | (subst1, n) ->
-                 (((FStar_Syntax_Syntax.NM
-                      ((b.FStar_Syntax_Syntax.binder_bv), n)) :: subst1),
-                   (n + Prims.int_one))) bs ([], Prims.int_zero) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Pervasives_Native.fst
-let (open_binders' :
-  FStar_Syntax_Syntax.binders ->
-    (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.subst_t))
-  =
-  fun bs ->
-    let rec aux bs1 o =
-      match bs1 with
-      | [] -> ([], o)
-      | b::bs' ->
-          let x' =
-            let uu___ =
-              FStar_Syntax_Syntax.freshen_bv b.FStar_Syntax_Syntax.binder_bv in
-            let uu___1 =
-              subst o
-                (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (uu___.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___1
-            } in
-          let imp = subst_bqual o b.FStar_Syntax_Syntax.binder_qual in
-          let attrs =
-            FStar_Compiler_Effect.op_Bar_Greater
-              b.FStar_Syntax_Syntax.binder_attrs
-              (FStar_Compiler_List.map (subst o)) in
-          let o1 =
-            let uu___ = shift_subst Prims.int_one o in
-            (FStar_Syntax_Syntax.DB (Prims.int_zero, x')) :: uu___ in
-          let uu___ = aux bs' o1 in
-          (match uu___ with
-           | (bs'1, o2) ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Syntax.mk_binder_with_attrs x' imp attrs in
-                 uu___2 :: bs'1 in
-               (uu___1, o2)) in
-    aux bs []
-let (open_binders :
-  FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders) =
-  fun bs -> let uu___ = open_binders' bs in FStar_Pervasives_Native.fst uu___
-let (open_term' :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.subst_t))
-  =
-  fun bs ->
-    fun t ->
-      let uu___ = open_binders' bs in
-      match uu___ with
-      | (bs', opening) ->
-          let uu___1 = subst opening t in (bs', uu___1, opening)
-let (open_term :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term))
-  =
-  fun bs ->
-    fun t ->
-      let uu___ = open_term' bs t in
-      match uu___ with | (b, t1, uu___1) -> (b, t1)
-let (open_comp :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.comp ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp))
-  =
-  fun bs ->
-    fun t ->
-      let uu___ = open_binders' bs in
-      match uu___ with
-      | (bs', opening) -> let uu___1 = subst_comp opening t in (bs', uu___1)
-let (open_ascription :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.ascription ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.ascription))
-  =
-  fun bs ->
-    fun asc ->
-      let uu___ = open_binders' bs in
-      match uu___ with
-      | (bs', opening) ->
-          let uu___1 = subst_ascription opening asc in (bs', uu___1)
-let (open_pat :
-  FStar_Syntax_Syntax.pat ->
-    (FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.subst_t))
-  =
-  fun p ->
-    let rec open_pat_aux sub p1 =
-      match p1.FStar_Syntax_Syntax.v with
-      | FStar_Syntax_Syntax.Pat_constant uu___ -> (p1, sub)
-      | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-          let us_opt1 = subst_univs_opt [sub] us_opt in
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.fold_left
-                 (fun uu___1 ->
-                    fun uu___2 ->
-                      match (uu___1, uu___2) with
-                      | ((pats1, sub1), (p2, imp)) ->
-                          let uu___3 = open_pat_aux sub1 p2 in
-                          (match uu___3 with
-                           | (p3, sub2) -> (((p3, imp) :: pats1), sub2)))
-                 ([], sub)) in
-          (match uu___ with
-           | (pats1, sub1) ->
-               ({
-                  FStar_Syntax_Syntax.v =
-                    (FStar_Syntax_Syntax.Pat_cons
-                       (fv, us_opt1, (FStar_Compiler_List.rev pats1)));
-                  FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-                }, sub1))
-      | FStar_Syntax_Syntax.Pat_var x ->
-          let x' =
-            let uu___ = FStar_Syntax_Syntax.freshen_bv x in
-            let uu___1 = subst sub x.FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (uu___.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___1
-            } in
-          let sub1 =
-            let uu___ = shift_subst Prims.int_one sub in
-            (FStar_Syntax_Syntax.DB (Prims.int_zero, x')) :: uu___ in
-          ({
-             FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_var x');
-             FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-           }, sub1)
-      | FStar_Syntax_Syntax.Pat_wild x ->
-          let x' =
-            let uu___ = FStar_Syntax_Syntax.freshen_bv x in
-            let uu___1 = subst sub x.FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (uu___.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___1
-            } in
-          let sub1 =
-            let uu___ = shift_subst Prims.int_one sub in
-            (FStar_Syntax_Syntax.DB (Prims.int_zero, x')) :: uu___ in
-          ({
-             FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_wild x');
-             FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-           }, sub1)
-      | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-          let eopt1 = FStar_Compiler_Util.map_option (subst sub) eopt in
-          ({
-             FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_dot_term eopt1);
-             FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-           }, sub) in
-    open_pat_aux [] p
-let (open_branch' :
-  FStar_Syntax_Syntax.branch ->
-    (FStar_Syntax_Syntax.branch * FStar_Syntax_Syntax.subst_t))
-  =
-  fun uu___ ->
-    match uu___ with
-    | (p, wopt, e) ->
-        let uu___1 = open_pat p in
-        (match uu___1 with
-         | (p1, opening) ->
-             let wopt1 =
-               match wopt with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-               | FStar_Pervasives_Native.Some w ->
-                   let uu___2 = subst opening w in
-                   FStar_Pervasives_Native.Some uu___2 in
-             let e1 = subst opening e in ((p1, wopt1, e1), opening))
-let (open_branch : FStar_Syntax_Syntax.branch -> FStar_Syntax_Syntax.branch)
-  =
-  fun br ->
-    let uu___ = open_branch' br in match uu___ with | (br1, uu___1) -> br1
-let (close :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun bs -> fun t -> let uu___ = closing_subst bs in subst uu___ t
-let (close_comp :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  = fun bs -> fun c -> let uu___ = closing_subst bs in subst_comp uu___ c
-let (close_binders :
-  FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders) =
-  fun bs ->
-    let rec aux s bs1 =
-      match bs1 with
-      | [] -> []
-      | b::tl ->
-          let x =
-            let uu___ = b.FStar_Syntax_Syntax.binder_bv in
-            let uu___1 =
-              subst s
-                (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (uu___.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___1
-            } in
-          let imp = subst_bqual s b.FStar_Syntax_Syntax.binder_qual in
-          let attrs =
-            FStar_Compiler_Effect.op_Bar_Greater
-              b.FStar_Syntax_Syntax.binder_attrs
-              (FStar_Compiler_List.map (subst s)) in
-          let s' =
-            let uu___ = shift_subst Prims.int_one s in
-            (FStar_Syntax_Syntax.NM (x, Prims.int_zero)) :: uu___ in
-          let uu___ = FStar_Syntax_Syntax.mk_binder_with_attrs x imp attrs in
-          let uu___1 = aux s' tl in uu___ :: uu___1 in
-    aux [] bs
-let (close_ascription :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.ascription -> FStar_Syntax_Syntax.ascription)
-  =
-  fun bs ->
-    fun asc -> let uu___ = closing_subst bs in subst_ascription uu___ asc
-let (close_pat :
-  FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t ->
-    (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-      FStar_Syntax_Syntax.subst_elt Prims.list))
-  =
-  fun p ->
-    let rec aux sub p1 =
-      match p1.FStar_Syntax_Syntax.v with
-      | FStar_Syntax_Syntax.Pat_constant uu___ -> (p1, sub)
-      | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-          let us_opt1 = subst_univs_opt [sub] us_opt in
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.fold_left
-                 (fun uu___1 ->
-                    fun uu___2 ->
-                      match (uu___1, uu___2) with
-                      | ((pats1, sub1), (p2, imp)) ->
-                          let uu___3 = aux sub1 p2 in
-                          (match uu___3 with
-                           | (p3, sub2) -> (((p3, imp) :: pats1), sub2)))
-                 ([], sub)) in
-          (match uu___ with
-           | (pats1, sub1) ->
-               ({
-                  FStar_Syntax_Syntax.v =
-                    (FStar_Syntax_Syntax.Pat_cons
-                       (fv, us_opt1, (FStar_Compiler_List.rev pats1)));
-                  FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-                }, sub1))
-      | FStar_Syntax_Syntax.Pat_var x ->
-          let x1 =
-            let uu___ = subst sub x.FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___
-            } in
-          let sub1 =
-            let uu___ = shift_subst Prims.int_one sub in
-            (FStar_Syntax_Syntax.NM (x1, Prims.int_zero)) :: uu___ in
-          ({
-             FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_var x1);
-             FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-           }, sub1)
-      | FStar_Syntax_Syntax.Pat_wild x ->
-          let x1 =
-            let uu___ = subst sub x.FStar_Syntax_Syntax.sort in
-            {
-              FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = uu___
-            } in
-          let sub1 =
-            let uu___ = shift_subst Prims.int_one sub in
-            (FStar_Syntax_Syntax.NM (x1, Prims.int_zero)) :: uu___ in
-          ({
-             FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_wild x1);
-             FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-           }, sub1)
-      | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-          let eopt1 = FStar_Compiler_Util.map_option (subst sub) eopt in
-          ({
-             FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_dot_term eopt1);
-             FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-           }, sub) in
-    aux [] p
-let (close_branch : FStar_Syntax_Syntax.branch -> FStar_Syntax_Syntax.branch)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (p, wopt, e) ->
-        let uu___1 = close_pat p in
-        (match uu___1 with
-         | (p1, closing) ->
-             let wopt1 =
-               match wopt with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-               | FStar_Pervasives_Native.Some w ->
-                   let uu___2 = subst closing w in
-                   FStar_Pervasives_Native.Some uu___2 in
-             let e1 = subst closing e in (p1, wopt1, e1))
-let (univ_var_opening :
-  FStar_Syntax_Syntax.univ_names ->
-    (FStar_Syntax_Syntax.subst_elt Prims.list * FStar_Syntax_Syntax.univ_name
-      Prims.list))
-  =
-  fun us ->
-    let n = (FStar_Compiler_List.length us) - Prims.int_one in
-    let s =
-      FStar_Compiler_Effect.op_Bar_Greater us
-        (FStar_Compiler_List.mapi
-           (fun i ->
-              fun u ->
-                FStar_Syntax_Syntax.UN
-                  ((n - i), (FStar_Syntax_Syntax.U_name u)))) in
-    (s, us)
-let (univ_var_closing :
-  FStar_Syntax_Syntax.univ_names -> FStar_Syntax_Syntax.subst_elt Prims.list)
-  =
-  fun us ->
-    let n = (FStar_Compiler_List.length us) - Prims.int_one in
-    FStar_Compiler_Effect.op_Bar_Greater us
-      (FStar_Compiler_List.mapi
-         (fun i -> fun u -> FStar_Syntax_Syntax.UD (u, (n - i))))
-let (open_univ_vars :
-  FStar_Syntax_Syntax.univ_names ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term))
-  =
-  fun us ->
-    fun t ->
-      let uu___ = univ_var_opening us in
-      match uu___ with | (s, us') -> let t1 = subst s t in (us', t1)
-let (open_univ_vars_comp :
-  FStar_Syntax_Syntax.univ_names ->
-    FStar_Syntax_Syntax.comp ->
-      (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.comp))
-  =
-  fun us ->
-    fun c ->
-      let uu___ = univ_var_opening us in
-      match uu___ with
-      | (s, us') -> let uu___1 = subst_comp s c in (us', uu___1)
-let (close_univ_vars :
-  FStar_Syntax_Syntax.univ_names ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun us -> fun t -> let s = univ_var_closing us in subst s t
-let (close_univ_vars_comp :
-  FStar_Syntax_Syntax.univ_names ->
-    FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  =
-  fun us ->
-    fun c ->
-      let n = (FStar_Compiler_List.length us) - Prims.int_one in
-      let s =
-        FStar_Compiler_Effect.op_Bar_Greater us
-          (FStar_Compiler_List.mapi
-             (fun i -> fun u -> FStar_Syntax_Syntax.UD (u, (n - i)))) in
-      subst_comp s c
-let (open_let_rec :
-  FStar_Syntax_Syntax.letbinding Prims.list ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.letbinding Prims.list * FStar_Syntax_Syntax.term))
-  =
-  fun lbs ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Syntax.is_top_level lbs in
-        if uu___1
-        then (Prims.int_zero, lbs, [])
-        else
-          FStar_Compiler_List.fold_right
-            (fun lb ->
-               fun uu___3 ->
-                 match uu___3 with
-                 | (i, lbs1, out) ->
-                     let x =
-                       let uu___4 =
-                         FStar_Compiler_Util.left
-                           lb.FStar_Syntax_Syntax.lbname in
-                       FStar_Syntax_Syntax.freshen_bv uu___4 in
-                     ((i + Prims.int_one),
-                       ({
-                          FStar_Syntax_Syntax.lbname =
-                            (FStar_Pervasives.Inl x);
-                          FStar_Syntax_Syntax.lbunivs =
-                            (lb.FStar_Syntax_Syntax.lbunivs);
-                          FStar_Syntax_Syntax.lbtyp =
-                            (lb.FStar_Syntax_Syntax.lbtyp);
-                          FStar_Syntax_Syntax.lbeff =
-                            (lb.FStar_Syntax_Syntax.lbeff);
-                          FStar_Syntax_Syntax.lbdef =
-                            (lb.FStar_Syntax_Syntax.lbdef);
-                          FStar_Syntax_Syntax.lbattrs =
-                            (lb.FStar_Syntax_Syntax.lbattrs);
-                          FStar_Syntax_Syntax.lbpos =
-                            (lb.FStar_Syntax_Syntax.lbpos)
-                        } :: lbs1), ((FStar_Syntax_Syntax.DB (i, x)) :: out)))
-            lbs (Prims.int_zero, [], []) in
-      match uu___ with
-      | (n_let_recs, lbs1, let_rec_opening) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Compiler_List.hd lbs1 in
-              uu___3.FStar_Syntax_Syntax.lbunivs in
-            FStar_Compiler_List.fold_right
-              (fun u ->
-                 fun uu___3 ->
-                   match uu___3 with
-                   | (i, us, out) ->
-                       let u1 =
-                         FStar_Syntax_Syntax.new_univ_name
-                           FStar_Pervasives_Native.None in
-                       ((i + Prims.int_one), (u1 :: us),
-                         ((FStar_Syntax_Syntax.UN
-                             (i, (FStar_Syntax_Syntax.U_name u1))) :: out)))
-              uu___2 (n_let_recs, [], let_rec_opening) in
-          (match uu___1 with
-           | (uu___2, us, u_let_rec_opening) ->
-               let lbs2 =
-                 FStar_Compiler_Effect.op_Bar_Greater lbs1
-                   (FStar_Compiler_List.map
-                      (fun lb ->
-                         let uu___3 =
-                           subst u_let_rec_opening
-                             lb.FStar_Syntax_Syntax.lbtyp in
-                         let uu___4 =
-                           subst u_let_rec_opening
-                             lb.FStar_Syntax_Syntax.lbdef in
-                         {
-                           FStar_Syntax_Syntax.lbname =
-                             (lb.FStar_Syntax_Syntax.lbname);
-                           FStar_Syntax_Syntax.lbunivs = us;
-                           FStar_Syntax_Syntax.lbtyp = uu___3;
-                           FStar_Syntax_Syntax.lbeff =
-                             (lb.FStar_Syntax_Syntax.lbeff);
-                           FStar_Syntax_Syntax.lbdef = uu___4;
-                           FStar_Syntax_Syntax.lbattrs =
-                             (lb.FStar_Syntax_Syntax.lbattrs);
-                           FStar_Syntax_Syntax.lbpos =
-                             (lb.FStar_Syntax_Syntax.lbpos)
-                         })) in
-               let t1 = subst let_rec_opening t in (lbs2, t1))
-let (close_let_rec :
-  FStar_Syntax_Syntax.letbinding Prims.list ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.letbinding Prims.list * FStar_Syntax_Syntax.term))
-  =
-  fun lbs ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Syntax.is_top_level lbs in
-        if uu___1
-        then (Prims.int_zero, [])
-        else
-          FStar_Compiler_List.fold_right
-            (fun lb ->
-               fun uu___3 ->
-                 match uu___3 with
-                 | (i, out) ->
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 =
-                             FStar_Compiler_Util.left
-                               lb.FStar_Syntax_Syntax.lbname in
-                           (uu___7, i) in
-                         FStar_Syntax_Syntax.NM uu___6 in
-                       uu___5 :: out in
-                     ((i + Prims.int_one), uu___4)) lbs (Prims.int_zero, []) in
-      match uu___ with
-      | (n_let_recs, let_rec_closing) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Compiler_List.hd lbs in
-              uu___3.FStar_Syntax_Syntax.lbunivs in
-            FStar_Compiler_List.fold_right
-              (fun u ->
-                 fun uu___3 ->
-                   match uu___3 with
-                   | (i, out) ->
-                       ((i + Prims.int_one), ((FStar_Syntax_Syntax.UD (u, i))
-                         :: out))) uu___2 (n_let_recs, let_rec_closing) in
-          (match uu___1 with
-           | (uu___2, u_let_rec_closing) ->
-               let lbs1 =
-                 FStar_Compiler_Effect.op_Bar_Greater lbs
-                   (FStar_Compiler_List.map
-                      (fun lb ->
-                         let uu___3 =
-                           subst u_let_rec_closing
-                             lb.FStar_Syntax_Syntax.lbtyp in
-                         let uu___4 =
-                           subst u_let_rec_closing
-                             lb.FStar_Syntax_Syntax.lbdef in
-                         {
-                           FStar_Syntax_Syntax.lbname =
-                             (lb.FStar_Syntax_Syntax.lbname);
-                           FStar_Syntax_Syntax.lbunivs =
-                             (lb.FStar_Syntax_Syntax.lbunivs);
-                           FStar_Syntax_Syntax.lbtyp = uu___3;
-                           FStar_Syntax_Syntax.lbeff =
-                             (lb.FStar_Syntax_Syntax.lbeff);
-                           FStar_Syntax_Syntax.lbdef = uu___4;
-                           FStar_Syntax_Syntax.lbattrs =
-                             (lb.FStar_Syntax_Syntax.lbattrs);
-                           FStar_Syntax_Syntax.lbpos =
-                             (lb.FStar_Syntax_Syntax.lbpos)
-                         })) in
-               let t1 = subst let_rec_closing t in (lbs1, t1))
-let (close_tscheme :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun binders ->
-    fun uu___ ->
-      match uu___ with
-      | (us, t) ->
-          let n = (FStar_Compiler_List.length binders) - Prims.int_one in
-          let k = FStar_Compiler_List.length us in
-          let s =
-            FStar_Compiler_List.mapi
-              (fun i ->
-                 fun b ->
-                   FStar_Syntax_Syntax.NM
-                     ((b.FStar_Syntax_Syntax.binder_bv), (k + (n - i))))
-              binders in
-          let t1 = subst s t in (us, t1)
-let (close_univ_vars_tscheme :
-  FStar_Syntax_Syntax.univ_names ->
-    FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun us ->
-    fun uu___ ->
-      match uu___ with
-      | (us', t) ->
-          let n = (FStar_Compiler_List.length us) - Prims.int_one in
-          let k = FStar_Compiler_List.length us' in
-          let s =
-            FStar_Compiler_List.mapi
-              (fun i -> fun x -> FStar_Syntax_Syntax.UD (x, (k + (n - i))))
-              us in
-          let uu___1 = subst s t in (us', uu___1)
-let (subst_tscheme :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun s ->
-    fun uu___ ->
-      match uu___ with
-      | (us, t) ->
-          let s1 = shift_subst (FStar_Compiler_List.length us) s in
-          let uu___1 = subst s1 t in (us, uu___1)
-let (opening_of_binders :
-  FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.subst_t) =
-  fun bs ->
-    let n = (FStar_Compiler_List.length bs) - Prims.int_one in
-    FStar_Compiler_Effect.op_Bar_Greater bs
-      (FStar_Compiler_List.mapi
-         (fun i ->
-            fun b ->
-              FStar_Syntax_Syntax.DB
-                ((n - i), (b.FStar_Syntax_Syntax.binder_bv))))
-let (closing_of_binders :
-  FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.subst_t) =
-  fun bs -> closing_subst bs
-let (open_term_1 :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.term))
-  =
-  fun b ->
-    fun t ->
-      let uu___ = open_term [b] t in
-      match uu___ with
-      | (b1::[], t1) -> (b1, t1)
-      | uu___1 -> failwith "impossible: open_term_1"
-let (open_term_bvs :
-  FStar_Syntax_Syntax.bv Prims.list ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.bv Prims.list * FStar_Syntax_Syntax.term))
-  =
-  fun bvs ->
-    fun t ->
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder bvs in
-        open_term uu___1 t in
-      match uu___ with
-      | (bs, t1) ->
-          let uu___1 =
-            FStar_Compiler_List.map
-              (fun b -> b.FStar_Syntax_Syntax.binder_bv) bs in
-          (uu___1, t1)
-let (open_term_bv :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term))
-  =
-  fun bv ->
-    fun t ->
-      let uu___ = open_term_bvs [bv] t in
-      match uu___ with
-      | (bv1::[], t1) -> (bv1, t1)
-      | uu___1 -> failwith "impossible: open_term_bv"
-let rec (deep_compress :
-  Prims.bool -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun allow_uvars ->
-    fun t ->
-      let mk x = FStar_Syntax_Syntax.mk x t.FStar_Syntax_Syntax.pos in
-      let t1 = compress t in
-      let elim_bv x =
-        let uu___ = deep_compress allow_uvars x.FStar_Syntax_Syntax.sort in
-        {
-          FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-          FStar_Syntax_Syntax.sort = uu___
-        } in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-          failwith "Impossible (delayed node in deep_compress)"
-      | FStar_Syntax_Syntax.Tm_fvar uu___ ->
-          let uu___1 =
-            FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-          {
-            FStar_Syntax_Syntax.n = (t1.FStar_Syntax_Syntax.n);
-            FStar_Syntax_Syntax.pos = (t1.FStar_Syntax_Syntax.pos);
-            FStar_Syntax_Syntax.vars = uu___1;
-            FStar_Syntax_Syntax.hash_code =
-              (t1.FStar_Syntax_Syntax.hash_code)
-          }
-      | FStar_Syntax_Syntax.Tm_constant uu___ ->
-          let uu___1 =
-            FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-          {
-            FStar_Syntax_Syntax.n = (t1.FStar_Syntax_Syntax.n);
-            FStar_Syntax_Syntax.pos = (t1.FStar_Syntax_Syntax.pos);
-            FStar_Syntax_Syntax.vars = uu___1;
-            FStar_Syntax_Syntax.hash_code =
-              (t1.FStar_Syntax_Syntax.hash_code)
-          }
-      | FStar_Syntax_Syntax.Tm_unknown ->
-          let uu___ = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-          {
-            FStar_Syntax_Syntax.n = (t1.FStar_Syntax_Syntax.n);
-            FStar_Syntax_Syntax.pos = (t1.FStar_Syntax_Syntax.pos);
-            FStar_Syntax_Syntax.vars = uu___;
-            FStar_Syntax_Syntax.hash_code =
-              (t1.FStar_Syntax_Syntax.hash_code)
-          }
-      | FStar_Syntax_Syntax.Tm_bvar bv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = mk FStar_Syntax_Syntax.Tm_unknown in
-              {
-                FStar_Syntax_Syntax.ppname = (bv.FStar_Syntax_Syntax.ppname);
-                FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-                FStar_Syntax_Syntax.sort = uu___2
-              } in
-            FStar_Syntax_Syntax.Tm_bvar uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_name bv ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = mk FStar_Syntax_Syntax.Tm_unknown in
-              {
-                FStar_Syntax_Syntax.ppname = (bv.FStar_Syntax_Syntax.ppname);
-                FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-                FStar_Syntax_Syntax.sort = uu___2
-              } in
-            FStar_Syntax_Syntax.Tm_name uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_uinst (f, us) ->
-          let us1 =
-            FStar_Compiler_List.map (deep_compress_univ allow_uvars) us in
-          mk (FStar_Syntax_Syntax.Tm_uinst (f, us1))
-      | FStar_Syntax_Syntax.Tm_type u ->
-          let u1 = deep_compress_univ allow_uvars u in
-          mk (FStar_Syntax_Syntax.Tm_type u1)
-      | FStar_Syntax_Syntax.Tm_lazy li ->
-          let t2 =
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_Effect.op_Bang
-                  FStar_Syntax_Syntax.lazy_chooser in
-              FStar_Compiler_Util.must uu___1 in
-            uu___ li.FStar_Syntax_Syntax.lkind li in
-          deep_compress allow_uvars t2
-      | FStar_Syntax_Syntax.Tm_abs (bs, t2, rc_opt) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress_binders allow_uvars bs in
-              let uu___3 = deep_compress allow_uvars t2 in
-              let uu___4 =
-                FStar_Compiler_Util.map_opt rc_opt (elim_rc allow_uvars) in
-              (uu___2, uu___3, uu___4) in
-            FStar_Syntax_Syntax.Tm_abs uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress_binders allow_uvars bs in
-              let uu___3 = deep_compress_comp allow_uvars c in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_arrow uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_refine (bv, phi) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = elim_bv bv in
-              let uu___3 = deep_compress allow_uvars phi in (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_refine uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_app (t2, args) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress allow_uvars t2 in
-              let uu___3 = deep_compress_args allow_uvars args in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_app uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_match (t2, asc_opt, branches, rc_opt) ->
-          let rec elim_pat p =
-            match p.FStar_Syntax_Syntax.v with
-            | FStar_Syntax_Syntax.Pat_var x ->
-                let uu___ =
-                  let uu___1 = elim_bv x in
-                  FStar_Syntax_Syntax.Pat_var uu___1 in
-                {
-                  FStar_Syntax_Syntax.v = uu___;
-                  FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                }
-            | FStar_Syntax_Syntax.Pat_wild x ->
-                let uu___ =
-                  let uu___1 = elim_bv x in
-                  FStar_Syntax_Syntax.Pat_wild uu___1 in
-                {
-                  FStar_Syntax_Syntax.v = uu___;
-                  FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                }
-            | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-                let uu___ =
-                  let uu___1 =
-                    FStar_Compiler_Util.map_option
-                      (deep_compress allow_uvars) eopt in
-                  FStar_Syntax_Syntax.Pat_dot_term uu___1 in
-                {
-                  FStar_Syntax_Syntax.v = uu___;
-                  FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                }
-            | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-                let us_opt1 =
-                  match us_opt with
-                  | FStar_Pervasives_Native.None ->
-                      FStar_Pervasives_Native.None
-                  | FStar_Pervasives_Native.Some us ->
-                      let uu___ =
-                        FStar_Compiler_List.map
-                          (deep_compress_univ allow_uvars) us in
-                      FStar_Pervasives_Native.Some uu___ in
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_List.map
-                        (fun uu___3 ->
-                           match uu___3 with
-                           | (x, b) -> let uu___4 = elim_pat x in (uu___4, b))
-                        pats in
-                    (fv, us_opt1, uu___2) in
-                  FStar_Syntax_Syntax.Pat_cons uu___1 in
-                {
-                  FStar_Syntax_Syntax.v = uu___;
-                  FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                }
-            | FStar_Syntax_Syntax.Pat_constant uu___ -> p in
-          let elim_branch uu___ =
-            match uu___ with
-            | (pat, wopt, t3) ->
-                let uu___1 = elim_pat pat in
-                let uu___2 =
-                  FStar_Compiler_Util.map_opt wopt
-                    (deep_compress allow_uvars) in
-                let uu___3 = deep_compress allow_uvars t3 in
-                (uu___1, uu___2, uu___3) in
-          let asc_opt1 =
-            match asc_opt with
-            | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-            | FStar_Pervasives_Native.Some (b, asc) ->
-                let uu___ =
-                  let uu___1 = deep_compress_binder allow_uvars b in
-                  let uu___2 = elim_ascription allow_uvars asc in
-                  (uu___1, uu___2) in
-                FStar_Pervasives_Native.Some uu___ in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress allow_uvars t2 in
-              let uu___3 = FStar_Compiler_List.map elim_branch branches in
-              let uu___4 =
-                FStar_Compiler_Util.map_opt rc_opt (elim_rc allow_uvars) in
-              (uu___2, asc_opt1, uu___3, uu___4) in
-            FStar_Syntax_Syntax.Tm_match uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_ascribed (t2, a, lopt) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress allow_uvars t2 in
-              let uu___3 = elim_ascription allow_uvars a in
-              (uu___2, uu___3, lopt) in
-            FStar_Syntax_Syntax.Tm_ascribed uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_let (lbs, t2) ->
-          let elim_lb lb =
-            let uu___ =
-              match lb.FStar_Syntax_Syntax.lbname with
-              | FStar_Pervasives.Inl bv ->
-                  let uu___1 = elim_bv bv in FStar_Pervasives.Inl uu___1
-              | FStar_Pervasives.Inr fv -> FStar_Pervasives.Inr fv in
-            let uu___1 =
-              deep_compress allow_uvars lb.FStar_Syntax_Syntax.lbtyp in
-            let uu___2 =
-              deep_compress allow_uvars lb.FStar_Syntax_Syntax.lbdef in
-            {
-              FStar_Syntax_Syntax.lbname = uu___;
-              FStar_Syntax_Syntax.lbunivs = (lb.FStar_Syntax_Syntax.lbunivs);
-              FStar_Syntax_Syntax.lbtyp = uu___1;
-              FStar_Syntax_Syntax.lbeff = (lb.FStar_Syntax_Syntax.lbeff);
-              FStar_Syntax_Syntax.lbdef = uu___2;
-              FStar_Syntax_Syntax.lbattrs = (lb.FStar_Syntax_Syntax.lbattrs);
-              FStar_Syntax_Syntax.lbpos = (lb.FStar_Syntax_Syntax.lbpos)
-            } in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_List.map elim_lb
-                    (FStar_Pervasives_Native.snd lbs) in
-                ((FStar_Pervasives_Native.fst lbs), uu___3) in
-              let uu___3 = deep_compress allow_uvars t2 in (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_let uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_uvar uu___ ->
-          if allow_uvars
-          then t1
-          else
-            FStar_Errors.raise_err
-              (FStar_Errors.Error_UnexpectedUnresolvedUvar,
-                "Internal error: unexpected unresolved uvar in deep_compress")
-      | FStar_Syntax_Syntax.Tm_quoted (tm, qi) ->
-          let qi1 =
-            FStar_Syntax_Syntax.on_antiquoted (deep_compress allow_uvars) qi in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress allow_uvars tm in (uu___2, qi1) in
-            FStar_Syntax_Syntax.Tm_quoted uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_meta (t2, md) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = deep_compress allow_uvars t2 in
-              let uu___3 = deep_compress_meta allow_uvars md in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk uu___
-and (elim_ascription :
-  Prims.bool ->
-    ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-      FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-      ->
-      ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-        FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-        FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-        Prims.bool))
-  =
-  fun allow_uvars ->
-    fun uu___ ->
-      match uu___ with
-      | (tc, topt, b) ->
-          let uu___1 =
-            match tc with
-            | FStar_Pervasives.Inl t ->
-                let uu___2 = deep_compress allow_uvars t in
-                FStar_Pervasives.Inl uu___2
-            | FStar_Pervasives.Inr c ->
-                let uu___2 = deep_compress_comp allow_uvars c in
-                FStar_Pervasives.Inr uu___2 in
-          let uu___2 =
-            FStar_Compiler_Util.map_opt topt (deep_compress allow_uvars) in
-          (uu___1, uu___2, b)
-and (elim_rc :
-  Prims.bool ->
-    FStar_Syntax_Syntax.residual_comp -> FStar_Syntax_Syntax.residual_comp)
-  =
-  fun allow_uvars ->
-    fun rc ->
-      let uu___ =
-        FStar_Compiler_Util.map_opt rc.FStar_Syntax_Syntax.residual_typ
-          (deep_compress allow_uvars) in
-      let uu___1 =
-        deep_compress_cflags allow_uvars
-          rc.FStar_Syntax_Syntax.residual_flags in
-      {
-        FStar_Syntax_Syntax.residual_effect =
-          (rc.FStar_Syntax_Syntax.residual_effect);
-        FStar_Syntax_Syntax.residual_typ = uu___;
-        FStar_Syntax_Syntax.residual_flags = uu___1
-      }
-and (deep_compress_dec_order :
-  Prims.bool ->
-    FStar_Syntax_Syntax.decreases_order ->
-      FStar_Syntax_Syntax.decreases_order)
-  =
-  fun allow_uvars ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Syntax_Syntax.Decreases_lex l ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater l
-              (FStar_Compiler_List.map (deep_compress allow_uvars)) in
-          FStar_Syntax_Syntax.Decreases_lex uu___1
-      | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-          let uu___1 =
-            let uu___2 = deep_compress allow_uvars rel in
-            let uu___3 = deep_compress allow_uvars e in (uu___2, uu___3) in
-          FStar_Syntax_Syntax.Decreases_wf uu___1
-and (deep_compress_cflags :
-  Prims.bool ->
-    FStar_Syntax_Syntax.cflag Prims.list ->
-      FStar_Syntax_Syntax.cflag Prims.list)
-  =
-  fun allow_uvars ->
-    fun flags ->
-      FStar_Compiler_List.map
-        (fun f ->
-           match f with
-           | FStar_Syntax_Syntax.DECREASES dec_order ->
-               let uu___ = deep_compress_dec_order allow_uvars dec_order in
-               FStar_Syntax_Syntax.DECREASES uu___
-           | FStar_Syntax_Syntax.TOTAL -> f
-           | FStar_Syntax_Syntax.MLEFFECT -> f
-           | FStar_Syntax_Syntax.LEMMA -> f
-           | FStar_Syntax_Syntax.RETURN -> f
-           | FStar_Syntax_Syntax.PARTIAL_RETURN -> f
-           | FStar_Syntax_Syntax.SOMETRIVIAL -> f
-           | FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION -> f
-           | FStar_Syntax_Syntax.SHOULD_NOT_INLINE -> f
-           | FStar_Syntax_Syntax.CPS -> f) flags
-and (deep_compress_comp :
-  Prims.bool -> FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp) =
-  fun allow_uvars ->
-    fun c ->
-      let mk x = FStar_Syntax_Syntax.mk x c.FStar_Syntax_Syntax.pos in
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Total t ->
-          let uu___ =
-            let uu___1 = deep_compress allow_uvars t in
-            FStar_Syntax_Syntax.Total uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.GTotal t ->
-          let uu___ =
-            let uu___1 = deep_compress allow_uvars t in
-            FStar_Syntax_Syntax.GTotal uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Comp ct ->
-          let ct1 =
-            let uu___ =
-              FStar_Compiler_List.map (deep_compress_univ allow_uvars)
-                ct.FStar_Syntax_Syntax.comp_univs in
-            let uu___1 =
-              deep_compress allow_uvars ct.FStar_Syntax_Syntax.result_typ in
-            let uu___2 =
-              deep_compress_args allow_uvars
-                ct.FStar_Syntax_Syntax.effect_args in
-            let uu___3 =
-              deep_compress_cflags allow_uvars ct.FStar_Syntax_Syntax.flags in
-            {
-              FStar_Syntax_Syntax.comp_univs = uu___;
-              FStar_Syntax_Syntax.effect_name =
-                (ct.FStar_Syntax_Syntax.effect_name);
-              FStar_Syntax_Syntax.result_typ = uu___1;
-              FStar_Syntax_Syntax.effect_args = uu___2;
-              FStar_Syntax_Syntax.flags = uu___3
-            } in
-          mk (FStar_Syntax_Syntax.Comp ct1)
-and (deep_compress_univ :
-  Prims.bool -> FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe)
-  =
-  fun allow_uvars ->
-    fun u ->
-      let u1 = compress_univ u in
-      match u1 with
-      | FStar_Syntax_Syntax.U_max us ->
-          let uu___ =
-            FStar_Compiler_List.map (deep_compress_univ allow_uvars) us in
-          FStar_Syntax_Syntax.U_max uu___
-      | FStar_Syntax_Syntax.U_succ u2 ->
-          let uu___ = deep_compress_univ allow_uvars u2 in
-          FStar_Syntax_Syntax.U_succ uu___
-      | FStar_Syntax_Syntax.U_zero -> u1
-      | FStar_Syntax_Syntax.U_bvar uu___ -> u1
-      | FStar_Syntax_Syntax.U_name uu___ -> u1
-      | FStar_Syntax_Syntax.U_unknown -> u1
-      | FStar_Syntax_Syntax.U_unif uu___ ->
-          if allow_uvars
-          then u1
-          else
-            FStar_Errors.raise_err
-              (FStar_Errors.Error_UnexpectedUnresolvedUvar,
-                "Internal error: unexpected unresolved (universe) uvar in deep_compress")
-and (deep_compress_meta :
-  Prims.bool -> FStar_Syntax_Syntax.metadata -> FStar_Syntax_Syntax.metadata)
-  =
-  fun allow_uvars ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Syntax_Syntax.Meta_pattern (names, args) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_List.map (deep_compress allow_uvars) names in
-            let uu___3 =
-              FStar_Compiler_List.map (deep_compress_args allow_uvars) args in
-            (uu___2, uu___3) in
-          FStar_Syntax_Syntax.Meta_pattern uu___1
-      | FStar_Syntax_Syntax.Meta_monadic (m, t) ->
-          let uu___1 =
-            let uu___2 = deep_compress allow_uvars t in (m, uu___2) in
-          FStar_Syntax_Syntax.Meta_monadic uu___1
-      | FStar_Syntax_Syntax.Meta_monadic_lift (m1, m2, t) ->
-          let uu___1 =
-            let uu___2 = deep_compress allow_uvars t in (m1, m2, uu___2) in
-          FStar_Syntax_Syntax.Meta_monadic_lift uu___1
-      | m -> m
-and (deep_compress_args :
-  Prims.bool ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-      Prims.list ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list)
-  =
-  fun allow_uvars ->
-    fun args ->
-      FStar_Compiler_List.map
-        (fun uu___ ->
-           match uu___ with
-           | (t, q) ->
-               let t1 = deep_compress allow_uvars t in
-               let q1 = deep_compress_aqual allow_uvars q in (t1, q1)) args
-and (deep_compress_bqual :
-  Prims.bool -> FStar_Syntax_Syntax.bqual -> FStar_Syntax_Syntax.bqual) =
-  fun allow_uvars ->
-    fun q ->
-      match q with
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-          let uu___ =
-            let uu___1 = deep_compress allow_uvars t in
-            FStar_Syntax_Syntax.Meta uu___1 in
-          FStar_Pervasives_Native.Some uu___
-      | uu___ -> q
-and (deep_compress_aqual :
-  Prims.bool -> FStar_Syntax_Syntax.aqual -> FStar_Syntax_Syntax.aqual) =
-  fun allow_uvars ->
-    fun q ->
-      match q with
-      | FStar_Pervasives_Native.Some a ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map (deep_compress allow_uvars)
-                a.FStar_Syntax_Syntax.aqual_attributes in
-            {
-              FStar_Syntax_Syntax.aqual_implicit =
-                (a.FStar_Syntax_Syntax.aqual_implicit);
-              FStar_Syntax_Syntax.aqual_attributes = uu___1
-            } in
-          FStar_Pervasives_Native.Some uu___
-      | uu___ -> q
-and (deep_compress_binder :
-  Prims.bool -> FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder) =
-  fun allow_uvars ->
-    fun b ->
-      let x =
-        let uu___ = b.FStar_Syntax_Syntax.binder_bv in
-        let uu___1 =
-          deep_compress allow_uvars
-            (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-        {
-          FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index = (uu___.FStar_Syntax_Syntax.index);
-          FStar_Syntax_Syntax.sort = uu___1
-        } in
-      let q =
-        deep_compress_bqual allow_uvars b.FStar_Syntax_Syntax.binder_qual in
-      let attrs =
-        FStar_Compiler_Effect.op_Bar_Greater
-          b.FStar_Syntax_Syntax.binder_attrs
-          (FStar_Compiler_List.map (deep_compress allow_uvars)) in
-      FStar_Syntax_Syntax.mk_binder_with_attrs x q attrs
-and (deep_compress_binders :
-  Prims.bool ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun allow_uvars ->
-    fun bs ->
-      FStar_Compiler_Effect.op_Bar_Greater bs
-        (FStar_Compiler_List.map (deep_compress_binder allow_uvars))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Syntax.ml b/src/ocaml-output/FStar_Syntax_Syntax.ml
deleted file mode 100644
index 4ec6bceeb51..00000000000
--- a/src/ocaml-output/FStar_Syntax_Syntax.ml
+++ /dev/null
@@ -1,2202 +0,0 @@
-open Prims
-type 'a withinfo_t = {
-  v: 'a ;
-  p: FStar_Compiler_Range.range }[@@deriving yojson,show]
-let __proj__Mkwithinfo_t__item__v : 'a . 'a withinfo_t -> 'a =
-  fun projectee -> match projectee with | { v; p;_} -> v
-let __proj__Mkwithinfo_t__item__p :
-  'a . 'a withinfo_t -> FStar_Compiler_Range.range =
-  fun projectee -> match projectee with | { v; p;_} -> p
-type var = FStar_Ident.lident withinfo_t[@@deriving yojson,show]
-type sconst = FStar_Const.sconst[@@deriving yojson,show]
-type pragma =
-  | SetOptions of Prims.string 
-  | ResetOptions of Prims.string FStar_Pervasives_Native.option 
-  | PushOptions of Prims.string FStar_Pervasives_Native.option 
-  | PopOptions 
-  | RestartSolver 
-  | PrintEffectsGraph [@@deriving yojson,show]
-let (uu___is_SetOptions : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SetOptions _0 -> true | uu___ -> false
-let (__proj__SetOptions__item___0 : pragma -> Prims.string) =
-  fun projectee -> match projectee with | SetOptions _0 -> _0
-let (uu___is_ResetOptions : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ResetOptions _0 -> true | uu___ -> false
-let (__proj__ResetOptions__item___0 :
-  pragma -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | ResetOptions _0 -> _0
-let (uu___is_PushOptions : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PushOptions _0 -> true | uu___ -> false
-let (__proj__PushOptions__item___0 :
-  pragma -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | PushOptions _0 -> _0
-let (uu___is_PopOptions : pragma -> Prims.bool) =
-  fun projectee -> match projectee with | PopOptions -> true | uu___ -> false
-let (uu___is_RestartSolver : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RestartSolver -> true | uu___ -> false
-let (uu___is_PrintEffectsGraph : pragma -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PrintEffectsGraph -> true | uu___ -> false
-type 'a memo =
-  (('a FStar_Pervasives_Native.option FStar_Compiler_Effect.ref)[@printer
-                                                                  fun fmt ->
-                                                                    fun _ ->
-                                                                    Format.pp_print_string
-                                                                    fmt
-                                                                    "None"])
-[@@deriving yojson,show]
-type emb_typ =
-  | ET_abstract 
-  | ET_fun of (emb_typ * emb_typ) 
-  | ET_app of (Prims.string * emb_typ Prims.list) 
-let (uu___is_ET_abstract : emb_typ -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ET_abstract -> true | uu___ -> false
-let (uu___is_ET_fun : emb_typ -> Prims.bool) =
-  fun projectee -> match projectee with | ET_fun _0 -> true | uu___ -> false
-let (__proj__ET_fun__item___0 : emb_typ -> (emb_typ * emb_typ)) =
-  fun projectee -> match projectee with | ET_fun _0 -> _0
-let (uu___is_ET_app : emb_typ -> Prims.bool) =
-  fun projectee -> match projectee with | ET_app _0 -> true | uu___ -> false
-let (__proj__ET_app__item___0 :
-  emb_typ -> (Prims.string * emb_typ Prims.list)) =
-  fun projectee -> match projectee with | ET_app _0 -> _0
-type version = {
-  major: Prims.int ;
-  minor: Prims.int }[@@deriving yojson,show]
-let (__proj__Mkversion__item__major : version -> Prims.int) =
-  fun projectee -> match projectee with | { major; minor;_} -> major
-let (__proj__Mkversion__item__minor : version -> Prims.int) =
-  fun projectee -> match projectee with | { major; minor;_} -> minor
-type universe =
-  | U_zero 
-  | U_succ of universe 
-  | U_max of universe Prims.list 
-  | U_bvar of Prims.int 
-  | U_name of FStar_Ident.ident 
-  | U_unif of (universe FStar_Pervasives_Native.option FStar_Unionfind.p_uvar
-  * version * FStar_Compiler_Range.range) 
-  | U_unknown [@@deriving yojson,show]
-let (uu___is_U_zero : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_zero -> true | uu___ -> false
-let (uu___is_U_succ : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_succ _0 -> true | uu___ -> false
-let (__proj__U_succ__item___0 : universe -> universe) =
-  fun projectee -> match projectee with | U_succ _0 -> _0
-let (uu___is_U_max : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_max _0 -> true | uu___ -> false
-let (__proj__U_max__item___0 : universe -> universe Prims.list) =
-  fun projectee -> match projectee with | U_max _0 -> _0
-let (uu___is_U_bvar : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_bvar _0 -> true | uu___ -> false
-let (__proj__U_bvar__item___0 : universe -> Prims.int) =
-  fun projectee -> match projectee with | U_bvar _0 -> _0
-let (uu___is_U_name : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_name _0 -> true | uu___ -> false
-let (__proj__U_name__item___0 : universe -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | U_name _0 -> _0
-let (uu___is_U_unif : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_unif _0 -> true | uu___ -> false
-let (__proj__U_unif__item___0 :
-  universe ->
-    (universe FStar_Pervasives_Native.option FStar_Unionfind.p_uvar * version
-      * FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | U_unif _0 -> _0
-let (uu___is_U_unknown : universe -> Prims.bool) =
-  fun projectee -> match projectee with | U_unknown -> true | uu___ -> false
-type univ_name = FStar_Ident.ident[@@deriving yojson,show]
-type universe_uvar =
-  (universe FStar_Pervasives_Native.option FStar_Unionfind.p_uvar * version *
-    FStar_Compiler_Range.range)[@@deriving yojson,show]
-type univ_names = univ_name Prims.list[@@deriving yojson,show]
-type universes = universe Prims.list[@@deriving yojson,show]
-type monad_name = FStar_Ident.lident[@@deriving yojson,show]
-type quote_kind =
-  | Quote_static 
-  | Quote_dynamic [@@deriving yojson,show]
-let (uu___is_Quote_static : quote_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Quote_static -> true | uu___ -> false
-let (uu___is_Quote_dynamic : quote_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Quote_dynamic -> true | uu___ -> false
-type maybe_set_use_range =
-  | NoUseRange 
-  | SomeUseRange of FStar_Compiler_Range.range [@@deriving yojson,show]
-let (uu___is_NoUseRange : maybe_set_use_range -> Prims.bool) =
-  fun projectee -> match projectee with | NoUseRange -> true | uu___ -> false
-let (uu___is_SomeUseRange : maybe_set_use_range -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SomeUseRange _0 -> true | uu___ -> false
-let (__proj__SomeUseRange__item___0 :
-  maybe_set_use_range -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | SomeUseRange _0 -> _0
-type delta_depth =
-  | Delta_constant_at_level of Prims.int 
-  | Delta_equational_at_level of Prims.int 
-  | Delta_abstract of delta_depth [@@deriving yojson,show]
-let (uu___is_Delta_constant_at_level : delta_depth -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Delta_constant_at_level _0 -> true
-    | uu___ -> false
-let (__proj__Delta_constant_at_level__item___0 : delta_depth -> Prims.int) =
-  fun projectee -> match projectee with | Delta_constant_at_level _0 -> _0
-let (uu___is_Delta_equational_at_level : delta_depth -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Delta_equational_at_level _0 -> true
-    | uu___ -> false
-let (__proj__Delta_equational_at_level__item___0 : delta_depth -> Prims.int)
-  =
-  fun projectee -> match projectee with | Delta_equational_at_level _0 -> _0
-let (uu___is_Delta_abstract : delta_depth -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Delta_abstract _0 -> true | uu___ -> false
-let (__proj__Delta_abstract__item___0 : delta_depth -> delta_depth) =
-  fun projectee -> match projectee with | Delta_abstract _0 -> _0
-type should_check_uvar =
-  | Allow_unresolved of Prims.string 
-  | Allow_untyped of Prims.string 
-  | Allow_ghost of Prims.string 
-  | Strict 
-  | Already_checked [@@deriving yojson,show]
-let (uu___is_Allow_unresolved : should_check_uvar -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Allow_unresolved _0 -> true | uu___ -> false
-let (__proj__Allow_unresolved__item___0 : should_check_uvar -> Prims.string)
-  = fun projectee -> match projectee with | Allow_unresolved _0 -> _0
-let (uu___is_Allow_untyped : should_check_uvar -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Allow_untyped _0 -> true | uu___ -> false
-let (__proj__Allow_untyped__item___0 : should_check_uvar -> Prims.string) =
-  fun projectee -> match projectee with | Allow_untyped _0 -> _0
-let (uu___is_Allow_ghost : should_check_uvar -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Allow_ghost _0 -> true | uu___ -> false
-let (__proj__Allow_ghost__item___0 : should_check_uvar -> Prims.string) =
-  fun projectee -> match projectee with | Allow_ghost _0 -> _0
-let (uu___is_Strict : should_check_uvar -> Prims.bool) =
-  fun projectee -> match projectee with | Strict -> true | uu___ -> false
-let (uu___is_Already_checked : should_check_uvar -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Already_checked -> true | uu___ -> false
-type term' =
-  | Tm_bvar of bv 
-  | Tm_name of bv 
-  | Tm_fvar of fv 
-  | Tm_uinst of (term' syntax * universes) 
-  | Tm_constant of sconst 
-  | Tm_type of universe 
-  | Tm_abs of (binder Prims.list * term' syntax * residual_comp
-  FStar_Pervasives_Native.option) 
-  | Tm_arrow of (binder Prims.list * comp' syntax) 
-  | Tm_refine of (bv * term' syntax) 
-  | Tm_app of (term' syntax * (term' syntax * arg_qualifier
-  FStar_Pervasives_Native.option) Prims.list) 
-  | Tm_match of (term' syntax * (binder * ((term' syntax, comp' syntax)
-  FStar_Pervasives.either * term' syntax FStar_Pervasives_Native.option *
-  Prims.bool)) FStar_Pervasives_Native.option * (pat' withinfo_t * term'
-  syntax FStar_Pervasives_Native.option * term' syntax) Prims.list *
-  residual_comp FStar_Pervasives_Native.option) 
-  | Tm_ascribed of (term' syntax * ((term' syntax, comp' syntax)
-  FStar_Pervasives.either * term' syntax FStar_Pervasives_Native.option *
-  Prims.bool) * FStar_Ident.lident FStar_Pervasives_Native.option) 
-  | Tm_let of ((Prims.bool * letbinding Prims.list) * term' syntax) 
-  | Tm_uvar of (ctx_uvar * (subst_elt Prims.list Prims.list *
-  maybe_set_use_range)) 
-  | Tm_delayed of (term' syntax * (subst_elt Prims.list Prims.list *
-  maybe_set_use_range)) 
-  | Tm_meta of (term' syntax * metadata) 
-  | Tm_lazy of lazyinfo 
-  | Tm_quoted of (term' syntax * quoteinfo) 
-  | Tm_unknown 
-and ctx_uvar =
-  {
-  ctx_uvar_head:
-    ((term' syntax FStar_Pervasives_Native.option * uvar_decoration)
-      FStar_Unionfind.p_uvar * version * FStar_Compiler_Range.range)
-    ;
-  ctx_uvar_gamma: binding Prims.list ;
-  ctx_uvar_binders: binder Prims.list ;
-  ctx_uvar_reason: Prims.string ;
-  ctx_uvar_range: FStar_Compiler_Range.range ;
-  ctx_uvar_meta: ctx_uvar_meta_t FStar_Pervasives_Native.option }
-and ctx_uvar_meta_t =
-  | Ctx_uvar_meta_tac of (FStar_Compiler_Dyn.dyn * term' syntax) 
-  | Ctx_uvar_meta_attr of term' syntax 
-and uvar_decoration =
-  {
-  uvar_decoration_typ: term' syntax ;
-  uvar_decoration_typedness_depends_on: ctx_uvar Prims.list ;
-  uvar_decoration_should_check: should_check_uvar }
-and pat' =
-  | Pat_constant of sconst 
-  | Pat_cons of (fv * universes FStar_Pervasives_Native.option * (pat'
-  withinfo_t * Prims.bool) Prims.list) 
-  | Pat_var of bv 
-  | Pat_wild of bv 
-  | Pat_dot_term of term' syntax FStar_Pervasives_Native.option 
-and letbinding =
-  {
-  lbname: (bv, fv) FStar_Pervasives.either ;
-  lbunivs: univ_name Prims.list ;
-  lbtyp: term' syntax ;
-  lbeff: FStar_Ident.lident ;
-  lbdef: term' syntax ;
-  lbattrs: term' syntax Prims.list ;
-  lbpos: FStar_Compiler_Range.range }
-and quoteinfo =
-  {
-  qkind: quote_kind ;
-  antiquotes: (bv * term' syntax) Prims.list }
-and comp_typ =
-  {
-  comp_univs: universes ;
-  effect_name: FStar_Ident.lident ;
-  result_typ: term' syntax ;
-  effect_args:
-    (term' syntax * arg_qualifier FStar_Pervasives_Native.option) Prims.list ;
-  flags: cflag Prims.list }
-and comp' =
-  | Total of term' syntax 
-  | GTotal of term' syntax 
-  | Comp of comp_typ 
-and binder =
-  {
-  binder_bv: bv ;
-  binder_qual: binder_qualifier FStar_Pervasives_Native.option ;
-  binder_attrs: term' syntax Prims.list }
-and decreases_order =
-  | Decreases_lex of term' syntax Prims.list 
-  | Decreases_wf of (term' syntax * term' syntax) 
-and cflag =
-  | TOTAL 
-  | MLEFFECT 
-  | LEMMA 
-  | RETURN 
-  | PARTIAL_RETURN 
-  | SOMETRIVIAL 
-  | TRIVIAL_POSTCONDITION 
-  | SHOULD_NOT_INLINE 
-  | CPS 
-  | DECREASES of decreases_order 
-and metadata =
-  | Meta_pattern of (term' syntax Prims.list * (term' syntax * arg_qualifier
-  FStar_Pervasives_Native.option) Prims.list Prims.list) 
-  | Meta_named of FStar_Ident.lident 
-  | Meta_labeled of (Prims.string * FStar_Compiler_Range.range * Prims.bool)
-  
-  | Meta_desugared of meta_source_info 
-  | Meta_monadic of (monad_name * term' syntax) 
-  | Meta_monadic_lift of (monad_name * monad_name * term' syntax) 
-and meta_source_info =
-  | Sequence 
-  | Primop 
-  | Masked_effect 
-  | Meta_smt_pat 
-  | Machine_integer of (FStar_Const.signedness * FStar_Const.width) 
-and fv_qual =
-  | Data_ctor 
-  | Record_projector of (FStar_Ident.lident * FStar_Ident.ident) 
-  | Record_ctor of (FStar_Ident.lident * FStar_Ident.ident Prims.list) 
-  | Unresolved_projector of fv FStar_Pervasives_Native.option 
-  | Unresolved_constructor of unresolved_constructor 
-and unresolved_constructor =
-  {
-  uc_base_term: Prims.bool ;
-  uc_typename: FStar_Ident.lident FStar_Pervasives_Native.option ;
-  uc_fields: FStar_Ident.lident Prims.list }
-and subst_elt =
-  | DB of (Prims.int * bv) 
-  | NM of (bv * Prims.int) 
-  | NT of (bv * term' syntax) 
-  | UN of (Prims.int * universe) 
-  | UD of (univ_name * Prims.int) 
-and 'a syntax =
-  {
-  n: 'a ;
-  pos: FStar_Compiler_Range.range ;
-  vars: free_vars memo ;
-  hash_code: FStar_Hash.hash_code memo }
-and bv = {
-  ppname: FStar_Ident.ident ;
-  index: Prims.int ;
-  sort: term' syntax }
-and fv =
-  {
-  fv_name: var ;
-  fv_delta: delta_depth ;
-  fv_qual: fv_qual FStar_Pervasives_Native.option }
-and free_vars =
-  {
-  free_names: bv Prims.list ;
-  free_uvars: ctx_uvar Prims.list ;
-  free_univs: universe_uvar Prims.list ;
-  free_univ_names: univ_name Prims.list }
-and residual_comp =
-  {
-  residual_effect: FStar_Ident.lident ;
-  residual_typ: term' syntax FStar_Pervasives_Native.option ;
-  residual_flags: cflag Prims.list }
-and lazyinfo =
-  {
-  blob: FStar_Compiler_Dyn.dyn ;
-  lkind: lazy_kind ;
-  ltyp: term' syntax ;
-  rng: FStar_Compiler_Range.range }
-and lazy_kind =
-  | BadLazy 
-  | Lazy_bv 
-  | Lazy_binder 
-  | Lazy_optionstate 
-  | Lazy_fvar 
-  | Lazy_comp 
-  | Lazy_env 
-  | Lazy_proofstate 
-  | Lazy_goal 
-  | Lazy_sigelt 
-  | Lazy_uvar 
-  | Lazy_letbinding 
-  | Lazy_embedding of (emb_typ * term' syntax FStar_Thunk.t) 
-  | Lazy_universe 
-  | Lazy_universe_uvar 
-and binding =
-  | Binding_var of bv 
-  | Binding_lid of (FStar_Ident.lident * (univ_names * term' syntax)) 
-  | Binding_univ of univ_name 
-and binder_qualifier =
-  | Implicit of Prims.bool 
-  | Meta of term' syntax 
-  | Equality 
-and arg_qualifier =
-  {
-  aqual_implicit: Prims.bool ;
-  aqual_attributes: term' syntax Prims.list }
-let (uu___is_Tm_bvar : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_bvar _0 -> true | uu___ -> false
-let (__proj__Tm_bvar__item___0 : term' -> bv) =
-  fun projectee -> match projectee with | Tm_bvar _0 -> _0
-let (uu___is_Tm_name : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_name _0 -> true | uu___ -> false
-let (__proj__Tm_name__item___0 : term' -> bv) =
-  fun projectee -> match projectee with | Tm_name _0 -> _0
-let (uu___is_Tm_fvar : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_fvar _0 -> true | uu___ -> false
-let (__proj__Tm_fvar__item___0 : term' -> fv) =
-  fun projectee -> match projectee with | Tm_fvar _0 -> _0
-let (uu___is_Tm_uinst : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_uinst _0 -> true | uu___ -> false
-let (__proj__Tm_uinst__item___0 : term' -> (term' syntax * universes)) =
-  fun projectee -> match projectee with | Tm_uinst _0 -> _0
-let (uu___is_Tm_constant : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_constant _0 -> true | uu___ -> false
-let (__proj__Tm_constant__item___0 : term' -> sconst) =
-  fun projectee -> match projectee with | Tm_constant _0 -> _0
-let (uu___is_Tm_type : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_type _0 -> true | uu___ -> false
-let (__proj__Tm_type__item___0 : term' -> universe) =
-  fun projectee -> match projectee with | Tm_type _0 -> _0
-let (uu___is_Tm_abs : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_abs _0 -> true | uu___ -> false
-let (__proj__Tm_abs__item___0 :
-  term' ->
-    (binder Prims.list * term' syntax * residual_comp
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Tm_abs _0 -> _0
-let (uu___is_Tm_arrow : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_arrow _0 -> true | uu___ -> false
-let (__proj__Tm_arrow__item___0 :
-  term' -> (binder Prims.list * comp' syntax)) =
-  fun projectee -> match projectee with | Tm_arrow _0 -> _0
-let (uu___is_Tm_refine : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_refine _0 -> true | uu___ -> false
-let (__proj__Tm_refine__item___0 : term' -> (bv * term' syntax)) =
-  fun projectee -> match projectee with | Tm_refine _0 -> _0
-let (uu___is_Tm_app : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_app _0 -> true | uu___ -> false
-let (__proj__Tm_app__item___0 :
-  term' ->
-    (term' syntax * (term' syntax * arg_qualifier
-      FStar_Pervasives_Native.option) Prims.list))
-  = fun projectee -> match projectee with | Tm_app _0 -> _0
-let (uu___is_Tm_match : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_match _0 -> true | uu___ -> false
-let (__proj__Tm_match__item___0 :
-  term' ->
-    (term' syntax * (binder * ((term' syntax, comp' syntax)
-      FStar_Pervasives.either * term' syntax FStar_Pervasives_Native.option *
-      Prims.bool)) FStar_Pervasives_Native.option * (pat' withinfo_t * term'
-      syntax FStar_Pervasives_Native.option * term' syntax) Prims.list *
-      residual_comp FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Tm_match _0 -> _0
-let (uu___is_Tm_ascribed : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_ascribed _0 -> true | uu___ -> false
-let (__proj__Tm_ascribed__item___0 :
-  term' ->
-    (term' syntax * ((term' syntax, comp' syntax) FStar_Pervasives.either *
-      term' syntax FStar_Pervasives_Native.option * Prims.bool) *
-      FStar_Ident.lident FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Tm_ascribed _0 -> _0
-let (uu___is_Tm_let : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_let _0 -> true | uu___ -> false
-let (__proj__Tm_let__item___0 :
-  term' -> ((Prims.bool * letbinding Prims.list) * term' syntax)) =
-  fun projectee -> match projectee with | Tm_let _0 -> _0
-let (uu___is_Tm_uvar : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_uvar _0 -> true | uu___ -> false
-let (__proj__Tm_uvar__item___0 :
-  term' ->
-    (ctx_uvar * (subst_elt Prims.list Prims.list * maybe_set_use_range)))
-  = fun projectee -> match projectee with | Tm_uvar _0 -> _0
-let (uu___is_Tm_delayed : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_delayed _0 -> true | uu___ -> false
-let (__proj__Tm_delayed__item___0 :
-  term' ->
-    (term' syntax * (subst_elt Prims.list Prims.list * maybe_set_use_range)))
-  = fun projectee -> match projectee with | Tm_delayed _0 -> _0
-let (uu___is_Tm_meta : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_meta _0 -> true | uu___ -> false
-let (__proj__Tm_meta__item___0 : term' -> (term' syntax * metadata)) =
-  fun projectee -> match projectee with | Tm_meta _0 -> _0
-let (uu___is_Tm_lazy : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_lazy _0 -> true | uu___ -> false
-let (__proj__Tm_lazy__item___0 : term' -> lazyinfo) =
-  fun projectee -> match projectee with | Tm_lazy _0 -> _0
-let (uu___is_Tm_quoted : term' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Tm_quoted _0 -> true | uu___ -> false
-let (__proj__Tm_quoted__item___0 : term' -> (term' syntax * quoteinfo)) =
-  fun projectee -> match projectee with | Tm_quoted _0 -> _0
-let (uu___is_Tm_unknown : term' -> Prims.bool) =
-  fun projectee -> match projectee with | Tm_unknown -> true | uu___ -> false
-let (__proj__Mkctx_uvar__item__ctx_uvar_head :
-  ctx_uvar ->
-    ((term' syntax FStar_Pervasives_Native.option * uvar_decoration)
-      FStar_Unionfind.p_uvar * version * FStar_Compiler_Range.range))
-  =
-  fun projectee ->
-    match projectee with
-    | { ctx_uvar_head; ctx_uvar_gamma; ctx_uvar_binders; ctx_uvar_reason;
-        ctx_uvar_range; ctx_uvar_meta;_} -> ctx_uvar_head
-let (__proj__Mkctx_uvar__item__ctx_uvar_gamma :
-  ctx_uvar -> binding Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { ctx_uvar_head; ctx_uvar_gamma; ctx_uvar_binders; ctx_uvar_reason;
-        ctx_uvar_range; ctx_uvar_meta;_} -> ctx_uvar_gamma
-let (__proj__Mkctx_uvar__item__ctx_uvar_binders :
-  ctx_uvar -> binder Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { ctx_uvar_head; ctx_uvar_gamma; ctx_uvar_binders; ctx_uvar_reason;
-        ctx_uvar_range; ctx_uvar_meta;_} -> ctx_uvar_binders
-let (__proj__Mkctx_uvar__item__ctx_uvar_reason : ctx_uvar -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { ctx_uvar_head; ctx_uvar_gamma; ctx_uvar_binders; ctx_uvar_reason;
-        ctx_uvar_range; ctx_uvar_meta;_} -> ctx_uvar_reason
-let (__proj__Mkctx_uvar__item__ctx_uvar_range :
-  ctx_uvar -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { ctx_uvar_head; ctx_uvar_gamma; ctx_uvar_binders; ctx_uvar_reason;
-        ctx_uvar_range; ctx_uvar_meta;_} -> ctx_uvar_range
-let (__proj__Mkctx_uvar__item__ctx_uvar_meta :
-  ctx_uvar -> ctx_uvar_meta_t FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { ctx_uvar_head; ctx_uvar_gamma; ctx_uvar_binders; ctx_uvar_reason;
-        ctx_uvar_range; ctx_uvar_meta;_} -> ctx_uvar_meta
-let (uu___is_Ctx_uvar_meta_tac : ctx_uvar_meta_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Ctx_uvar_meta_tac _0 -> true | uu___ -> false
-let (__proj__Ctx_uvar_meta_tac__item___0 :
-  ctx_uvar_meta_t -> (FStar_Compiler_Dyn.dyn * term' syntax)) =
-  fun projectee -> match projectee with | Ctx_uvar_meta_tac _0 -> _0
-let (uu___is_Ctx_uvar_meta_attr : ctx_uvar_meta_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Ctx_uvar_meta_attr _0 -> true | uu___ -> false
-let (__proj__Ctx_uvar_meta_attr__item___0 : ctx_uvar_meta_t -> term' syntax)
-  = fun projectee -> match projectee with | Ctx_uvar_meta_attr _0 -> _0
-let (__proj__Mkuvar_decoration__item__uvar_decoration_typ :
-  uvar_decoration -> term' syntax) =
-  fun projectee ->
-    match projectee with
-    | { uvar_decoration_typ; uvar_decoration_typedness_depends_on;
-        uvar_decoration_should_check;_} -> uvar_decoration_typ
-let (__proj__Mkuvar_decoration__item__uvar_decoration_typedness_depends_on :
-  uvar_decoration -> ctx_uvar Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { uvar_decoration_typ; uvar_decoration_typedness_depends_on;
-        uvar_decoration_should_check;_} ->
-        uvar_decoration_typedness_depends_on
-let (__proj__Mkuvar_decoration__item__uvar_decoration_should_check :
-  uvar_decoration -> should_check_uvar) =
-  fun projectee ->
-    match projectee with
-    | { uvar_decoration_typ; uvar_decoration_typedness_depends_on;
-        uvar_decoration_should_check;_} -> uvar_decoration_should_check
-let (uu___is_Pat_constant : pat' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_constant _0 -> true | uu___ -> false
-let (__proj__Pat_constant__item___0 : pat' -> sconst) =
-  fun projectee -> match projectee with | Pat_constant _0 -> _0
-let (uu___is_Pat_cons : pat' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_cons _0 -> true | uu___ -> false
-let (__proj__Pat_cons__item___0 :
-  pat' ->
-    (fv * universes FStar_Pervasives_Native.option * (pat' withinfo_t *
-      Prims.bool) Prims.list))
-  = fun projectee -> match projectee with | Pat_cons _0 -> _0
-let (uu___is_Pat_var : pat' -> Prims.bool) =
-  fun projectee -> match projectee with | Pat_var _0 -> true | uu___ -> false
-let (__proj__Pat_var__item___0 : pat' -> bv) =
-  fun projectee -> match projectee with | Pat_var _0 -> _0
-let (uu___is_Pat_wild : pat' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_wild _0 -> true | uu___ -> false
-let (__proj__Pat_wild__item___0 : pat' -> bv) =
-  fun projectee -> match projectee with | Pat_wild _0 -> _0
-let (uu___is_Pat_dot_term : pat' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Pat_dot_term _0 -> true | uu___ -> false
-let (__proj__Pat_dot_term__item___0 :
-  pat' -> term' syntax FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | Pat_dot_term _0 -> _0
-let (__proj__Mkletbinding__item__lbname :
-  letbinding -> (bv, fv) FStar_Pervasives.either) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbname
-let (__proj__Mkletbinding__item__lbunivs :
-  letbinding -> univ_name Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbunivs
-let (__proj__Mkletbinding__item__lbtyp : letbinding -> term' syntax) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbtyp
-let (__proj__Mkletbinding__item__lbeff : letbinding -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbeff
-let (__proj__Mkletbinding__item__lbdef : letbinding -> term' syntax) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbdef
-let (__proj__Mkletbinding__item__lbattrs :
-  letbinding -> term' syntax Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbattrs
-let (__proj__Mkletbinding__item__lbpos :
-  letbinding -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { lbname; lbunivs; lbtyp; lbeff; lbdef; lbattrs; lbpos;_} -> lbpos
-let (__proj__Mkquoteinfo__item__qkind : quoteinfo -> quote_kind) =
-  fun projectee -> match projectee with | { qkind; antiquotes;_} -> qkind
-let (__proj__Mkquoteinfo__item__antiquotes :
-  quoteinfo -> (bv * term' syntax) Prims.list) =
-  fun projectee ->
-    match projectee with | { qkind; antiquotes;_} -> antiquotes
-let (__proj__Mkcomp_typ__item__comp_univs : comp_typ -> universes) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        comp_univs
-let (__proj__Mkcomp_typ__item__effect_name : comp_typ -> FStar_Ident.lident)
-  =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        effect_name
-let (__proj__Mkcomp_typ__item__result_typ : comp_typ -> term' syntax) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        result_typ
-let (__proj__Mkcomp_typ__item__effect_args :
-  comp_typ ->
-    (term' syntax * arg_qualifier FStar_Pervasives_Native.option) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        effect_args
-let (__proj__Mkcomp_typ__item__flags : comp_typ -> cflag Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} -> flags
-let (uu___is_Total : comp' -> Prims.bool) =
-  fun projectee -> match projectee with | Total _0 -> true | uu___ -> false
-let (__proj__Total__item___0 : comp' -> term' syntax) =
-  fun projectee -> match projectee with | Total _0 -> _0
-let (uu___is_GTotal : comp' -> Prims.bool) =
-  fun projectee -> match projectee with | GTotal _0 -> true | uu___ -> false
-let (__proj__GTotal__item___0 : comp' -> term' syntax) =
-  fun projectee -> match projectee with | GTotal _0 -> _0
-let (uu___is_Comp : comp' -> Prims.bool) =
-  fun projectee -> match projectee with | Comp _0 -> true | uu___ -> false
-let (__proj__Comp__item___0 : comp' -> comp_typ) =
-  fun projectee -> match projectee with | Comp _0 -> _0
-let (__proj__Mkbinder__item__binder_bv : binder -> bv) =
-  fun projectee ->
-    match projectee with
-    | { binder_bv; binder_qual; binder_attrs;_} -> binder_bv
-let (__proj__Mkbinder__item__binder_qual :
-  binder -> binder_qualifier FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { binder_bv; binder_qual; binder_attrs;_} -> binder_qual
-let (__proj__Mkbinder__item__binder_attrs :
-  binder -> term' syntax Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { binder_bv; binder_qual; binder_attrs;_} -> binder_attrs
-let (uu___is_Decreases_lex : decreases_order -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Decreases_lex _0 -> true | uu___ -> false
-let (__proj__Decreases_lex__item___0 :
-  decreases_order -> term' syntax Prims.list) =
-  fun projectee -> match projectee with | Decreases_lex _0 -> _0
-let (uu___is_Decreases_wf : decreases_order -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Decreases_wf _0 -> true | uu___ -> false
-let (__proj__Decreases_wf__item___0 :
-  decreases_order -> (term' syntax * term' syntax)) =
-  fun projectee -> match projectee with | Decreases_wf _0 -> _0
-let (uu___is_TOTAL : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | TOTAL -> true | uu___ -> false
-let (uu___is_MLEFFECT : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | MLEFFECT -> true | uu___ -> false
-let (uu___is_LEMMA : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | LEMMA -> true | uu___ -> false
-let (uu___is_RETURN : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | RETURN -> true | uu___ -> false
-let (uu___is_PARTIAL_RETURN : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PARTIAL_RETURN -> true | uu___ -> false
-let (uu___is_SOMETRIVIAL : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SOMETRIVIAL -> true | uu___ -> false
-let (uu___is_TRIVIAL_POSTCONDITION : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TRIVIAL_POSTCONDITION -> true | uu___ -> false
-let (uu___is_SHOULD_NOT_INLINE : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SHOULD_NOT_INLINE -> true | uu___ -> false
-let (uu___is_CPS : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | CPS -> true | uu___ -> false
-let (uu___is_DECREASES : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DECREASES _0 -> true | uu___ -> false
-let (__proj__DECREASES__item___0 : cflag -> decreases_order) =
-  fun projectee -> match projectee with | DECREASES _0 -> _0
-let (uu___is_Meta_pattern : metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_pattern _0 -> true | uu___ -> false
-let (__proj__Meta_pattern__item___0 :
-  metadata ->
-    (term' syntax Prims.list * (term' syntax * arg_qualifier
-      FStar_Pervasives_Native.option) Prims.list Prims.list))
-  = fun projectee -> match projectee with | Meta_pattern _0 -> _0
-let (uu___is_Meta_named : metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_named _0 -> true | uu___ -> false
-let (__proj__Meta_named__item___0 : metadata -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | Meta_named _0 -> _0
-let (uu___is_Meta_labeled : metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_labeled _0 -> true | uu___ -> false
-let (__proj__Meta_labeled__item___0 :
-  metadata -> (Prims.string * FStar_Compiler_Range.range * Prims.bool)) =
-  fun projectee -> match projectee with | Meta_labeled _0 -> _0
-let (uu___is_Meta_desugared : metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_desugared _0 -> true | uu___ -> false
-let (__proj__Meta_desugared__item___0 : metadata -> meta_source_info) =
-  fun projectee -> match projectee with | Meta_desugared _0 -> _0
-let (uu___is_Meta_monadic : metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_monadic _0 -> true | uu___ -> false
-let (__proj__Meta_monadic__item___0 :
-  metadata -> (monad_name * term' syntax)) =
-  fun projectee -> match projectee with | Meta_monadic _0 -> _0
-let (uu___is_Meta_monadic_lift : metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_monadic_lift _0 -> true | uu___ -> false
-let (__proj__Meta_monadic_lift__item___0 :
-  metadata -> (monad_name * monad_name * term' syntax)) =
-  fun projectee -> match projectee with | Meta_monadic_lift _0 -> _0
-let (uu___is_Sequence : meta_source_info -> Prims.bool) =
-  fun projectee -> match projectee with | Sequence -> true | uu___ -> false
-let (uu___is_Primop : meta_source_info -> Prims.bool) =
-  fun projectee -> match projectee with | Primop -> true | uu___ -> false
-let (uu___is_Masked_effect : meta_source_info -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Masked_effect -> true | uu___ -> false
-let (uu___is_Meta_smt_pat : meta_source_info -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Meta_smt_pat -> true | uu___ -> false
-let (uu___is_Machine_integer : meta_source_info -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Machine_integer _0 -> true | uu___ -> false
-let (__proj__Machine_integer__item___0 :
-  meta_source_info -> (FStar_Const.signedness * FStar_Const.width)) =
-  fun projectee -> match projectee with | Machine_integer _0 -> _0
-let (uu___is_Data_ctor : fv_qual -> Prims.bool) =
-  fun projectee -> match projectee with | Data_ctor -> true | uu___ -> false
-let (uu___is_Record_projector : fv_qual -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Record_projector _0 -> true | uu___ -> false
-let (__proj__Record_projector__item___0 :
-  fv_qual -> (FStar_Ident.lident * FStar_Ident.ident)) =
-  fun projectee -> match projectee with | Record_projector _0 -> _0
-let (uu___is_Record_ctor : fv_qual -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Record_ctor _0 -> true | uu___ -> false
-let (__proj__Record_ctor__item___0 :
-  fv_qual -> (FStar_Ident.lident * FStar_Ident.ident Prims.list)) =
-  fun projectee -> match projectee with | Record_ctor _0 -> _0
-let (uu___is_Unresolved_projector : fv_qual -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Unresolved_projector _0 -> true | uu___ -> false
-let (__proj__Unresolved_projector__item___0 :
-  fv_qual -> fv FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | Unresolved_projector _0 -> _0
-let (uu___is_Unresolved_constructor : fv_qual -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Unresolved_constructor _0 -> true | uu___ -> false
-let (__proj__Unresolved_constructor__item___0 :
-  fv_qual -> unresolved_constructor) =
-  fun projectee -> match projectee with | Unresolved_constructor _0 -> _0
-let (__proj__Mkunresolved_constructor__item__uc_base_term :
-  unresolved_constructor -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { uc_base_term; uc_typename; uc_fields;_} -> uc_base_term
-let (__proj__Mkunresolved_constructor__item__uc_typename :
-  unresolved_constructor -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { uc_base_term; uc_typename; uc_fields;_} -> uc_typename
-let (__proj__Mkunresolved_constructor__item__uc_fields :
-  unresolved_constructor -> FStar_Ident.lident Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { uc_base_term; uc_typename; uc_fields;_} -> uc_fields
-let (uu___is_DB : subst_elt -> Prims.bool) =
-  fun projectee -> match projectee with | DB _0 -> true | uu___ -> false
-let (__proj__DB__item___0 : subst_elt -> (Prims.int * bv)) =
-  fun projectee -> match projectee with | DB _0 -> _0
-let (uu___is_NM : subst_elt -> Prims.bool) =
-  fun projectee -> match projectee with | NM _0 -> true | uu___ -> false
-let (__proj__NM__item___0 : subst_elt -> (bv * Prims.int)) =
-  fun projectee -> match projectee with | NM _0 -> _0
-let (uu___is_NT : subst_elt -> Prims.bool) =
-  fun projectee -> match projectee with | NT _0 -> true | uu___ -> false
-let (__proj__NT__item___0 : subst_elt -> (bv * term' syntax)) =
-  fun projectee -> match projectee with | NT _0 -> _0
-let (uu___is_UN : subst_elt -> Prims.bool) =
-  fun projectee -> match projectee with | UN _0 -> true | uu___ -> false
-let (__proj__UN__item___0 : subst_elt -> (Prims.int * universe)) =
-  fun projectee -> match projectee with | UN _0 -> _0
-let (uu___is_UD : subst_elt -> Prims.bool) =
-  fun projectee -> match projectee with | UD _0 -> true | uu___ -> false
-let (__proj__UD__item___0 : subst_elt -> (univ_name * Prims.int)) =
-  fun projectee -> match projectee with | UD _0 -> _0
-let __proj__Mksyntax__item__n : 'a . 'a syntax -> 'a =
-  fun projectee -> match projectee with | { n; pos; vars; hash_code;_} -> n
-let __proj__Mksyntax__item__pos :
-  'a . 'a syntax -> FStar_Compiler_Range.range =
-  fun projectee -> match projectee with | { n; pos; vars; hash_code;_} -> pos
-let __proj__Mksyntax__item__vars : 'a . 'a syntax -> free_vars memo =
-  fun projectee ->
-    match projectee with | { n; pos; vars; hash_code;_} -> vars
-let __proj__Mksyntax__item__hash_code :
-  'a . 'a syntax -> FStar_Hash.hash_code memo =
-  fun projectee ->
-    match projectee with | { n; pos; vars; hash_code;_} -> hash_code
-let (__proj__Mkbv__item__ppname : bv -> FStar_Ident.ident) =
-  fun projectee -> match projectee with | { ppname; index; sort;_} -> ppname
-let (__proj__Mkbv__item__index : bv -> Prims.int) =
-  fun projectee -> match projectee with | { ppname; index; sort;_} -> index
-let (__proj__Mkbv__item__sort : bv -> term' syntax) =
-  fun projectee -> match projectee with | { ppname; index; sort;_} -> sort
-let (__proj__Mkfv__item__fv_name : fv -> var) =
-  fun projectee ->
-    match projectee with
-    | { fv_name; fv_delta; fv_qual = fv_qual1;_} -> fv_name
-let (__proj__Mkfv__item__fv_delta : fv -> delta_depth) =
-  fun projectee ->
-    match projectee with
-    | { fv_name; fv_delta; fv_qual = fv_qual1;_} -> fv_delta
-let (__proj__Mkfv__item__fv_qual :
-  fv -> fv_qual FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { fv_name; fv_delta; fv_qual = fv_qual1;_} -> fv_qual1
-let (__proj__Mkfree_vars__item__free_names : free_vars -> bv Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { free_names; free_uvars; free_univs; free_univ_names;_} -> free_names
-let (__proj__Mkfree_vars__item__free_uvars :
-  free_vars -> ctx_uvar Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { free_names; free_uvars; free_univs; free_univ_names;_} -> free_uvars
-let (__proj__Mkfree_vars__item__free_univs :
-  free_vars -> universe_uvar Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { free_names; free_uvars; free_univs; free_univ_names;_} -> free_univs
-let (__proj__Mkfree_vars__item__free_univ_names :
-  free_vars -> univ_name Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { free_names; free_uvars; free_univs; free_univ_names;_} ->
-        free_univ_names
-let (__proj__Mkresidual_comp__item__residual_effect :
-  residual_comp -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { residual_effect; residual_typ; residual_flags;_} -> residual_effect
-let (__proj__Mkresidual_comp__item__residual_typ :
-  residual_comp -> term' syntax FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { residual_effect; residual_typ; residual_flags;_} -> residual_typ
-let (__proj__Mkresidual_comp__item__residual_flags :
-  residual_comp -> cflag Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { residual_effect; residual_typ; residual_flags;_} -> residual_flags
-let (__proj__Mklazyinfo__item__blob : lazyinfo -> FStar_Compiler_Dyn.dyn) =
-  fun projectee -> match projectee with | { blob; lkind; ltyp; rng;_} -> blob
-let (__proj__Mklazyinfo__item__lkind : lazyinfo -> lazy_kind) =
-  fun projectee ->
-    match projectee with | { blob; lkind; ltyp; rng;_} -> lkind
-let (__proj__Mklazyinfo__item__ltyp : lazyinfo -> term' syntax) =
-  fun projectee -> match projectee with | { blob; lkind; ltyp; rng;_} -> ltyp
-let (__proj__Mklazyinfo__item__rng : lazyinfo -> FStar_Compiler_Range.range)
-  =
-  fun projectee -> match projectee with | { blob; lkind; ltyp; rng;_} -> rng
-let (uu___is_BadLazy : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | BadLazy -> true | uu___ -> false
-let (uu___is_Lazy_bv : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy_bv -> true | uu___ -> false
-let (uu___is_Lazy_binder : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_binder -> true | uu___ -> false
-let (uu___is_Lazy_optionstate : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_optionstate -> true | uu___ -> false
-let (uu___is_Lazy_fvar : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy_fvar -> true | uu___ -> false
-let (uu___is_Lazy_comp : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy_comp -> true | uu___ -> false
-let (uu___is_Lazy_env : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy_env -> true | uu___ -> false
-let (uu___is_Lazy_proofstate : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_proofstate -> true | uu___ -> false
-let (uu___is_Lazy_goal : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy_goal -> true | uu___ -> false
-let (uu___is_Lazy_sigelt : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_sigelt -> true | uu___ -> false
-let (uu___is_Lazy_uvar : lazy_kind -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy_uvar -> true | uu___ -> false
-let (uu___is_Lazy_letbinding : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_letbinding -> true | uu___ -> false
-let (uu___is_Lazy_embedding : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_embedding _0 -> true | uu___ -> false
-let (__proj__Lazy_embedding__item___0 :
-  lazy_kind -> (emb_typ * term' syntax FStar_Thunk.t)) =
-  fun projectee -> match projectee with | Lazy_embedding _0 -> _0
-let (uu___is_Lazy_universe : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_universe -> true | uu___ -> false
-let (uu___is_Lazy_universe_uvar : lazy_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Lazy_universe_uvar -> true | uu___ -> false
-let (uu___is_Binding_var : binding -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Binding_var _0 -> true | uu___ -> false
-let (__proj__Binding_var__item___0 : binding -> bv) =
-  fun projectee -> match projectee with | Binding_var _0 -> _0
-let (uu___is_Binding_lid : binding -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Binding_lid _0 -> true | uu___ -> false
-let (__proj__Binding_lid__item___0 :
-  binding -> (FStar_Ident.lident * (univ_names * term' syntax))) =
-  fun projectee -> match projectee with | Binding_lid _0 -> _0
-let (uu___is_Binding_univ : binding -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Binding_univ _0 -> true | uu___ -> false
-let (__proj__Binding_univ__item___0 : binding -> univ_name) =
-  fun projectee -> match projectee with | Binding_univ _0 -> _0
-let (uu___is_Implicit : binder_qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Implicit _0 -> true | uu___ -> false
-let (__proj__Implicit__item___0 : binder_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Implicit _0 -> _0
-let (uu___is_Meta : binder_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Meta _0 -> true | uu___ -> false
-let (__proj__Meta__item___0 : binder_qualifier -> term' syntax) =
-  fun projectee -> match projectee with | Meta _0 -> _0
-let (uu___is_Equality : binder_qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Equality -> true | uu___ -> false
-let (__proj__Mkarg_qualifier__item__aqual_implicit :
-  arg_qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { aqual_implicit; aqual_attributes;_} -> aqual_implicit
-let (__proj__Mkarg_qualifier__item__aqual_attributes :
-  arg_qualifier -> term' syntax Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { aqual_implicit; aqual_attributes;_} -> aqual_attributes
-type subst_ts = (subst_elt Prims.list Prims.list * maybe_set_use_range)
-type ctx_uvar_and_subst =
-  (ctx_uvar * (subst_elt Prims.list Prims.list * maybe_set_use_range))
-type term = term' syntax
-type uvar =
-  ((term' syntax FStar_Pervasives_Native.option * uvar_decoration)
-    FStar_Unionfind.p_uvar * version * FStar_Compiler_Range.range)
-type uvars = ctx_uvar FStar_Compiler_Util.set
-type comp = comp' syntax
-type ascription =
-  ((term' syntax, comp' syntax) FStar_Pervasives.either * term' syntax
-    FStar_Pervasives_Native.option * Prims.bool)
-type match_returns_ascription =
-  (binder * ((term' syntax, comp' syntax) FStar_Pervasives.either * term'
-    syntax FStar_Pervasives_Native.option * Prims.bool))
-type pat = pat' withinfo_t
-type branch =
-  (pat' withinfo_t * term' syntax FStar_Pervasives_Native.option * term'
-    syntax)
-type antiquotations = (bv * term' syntax) Prims.list
-type typ = term' syntax
-type aqual = arg_qualifier FStar_Pervasives_Native.option
-type arg = (term' syntax * arg_qualifier FStar_Pervasives_Native.option)
-type args =
-  (term' syntax * arg_qualifier FStar_Pervasives_Native.option) Prims.list
-type binders = binder Prims.list
-type lbname = (bv, fv) FStar_Pervasives.either
-type letbindings = (Prims.bool * letbinding Prims.list)
-type freenames = bv FStar_Compiler_Util.set
-type attribute = term' syntax
-type tscheme = (univ_name Prims.list * term' syntax)
-type gamma = binding Prims.list
-type bqual = binder_qualifier FStar_Pervasives_Native.option
-type freenames_l = bv Prims.list
-type formula = typ
-type formulae = typ Prims.list
-type qualifier =
-  | Assumption 
-  | InternalAssumption 
-  | New 
-  | Private 
-  | Unfold_for_unification_and_vcgen 
-  | Visible_default 
-  | Irreducible 
-  | Inline_for_extraction 
-  | NoExtract 
-  | Noeq 
-  | Unopteq 
-  | TotalEffect 
-  | Logic 
-  | Reifiable 
-  | Reflectable of FStar_Ident.lident 
-  | Discriminator of FStar_Ident.lident 
-  | Projector of (FStar_Ident.lident * FStar_Ident.ident) 
-  | RecordType of (FStar_Ident.ident Prims.list * FStar_Ident.ident
-  Prims.list) 
-  | RecordConstructor of (FStar_Ident.ident Prims.list * FStar_Ident.ident
-  Prims.list) 
-  | Action of FStar_Ident.lident 
-  | ExceptionConstructor 
-  | HasMaskedEffect 
-  | Effect 
-  | OnlyName 
-let (uu___is_Assumption : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Assumption -> true | uu___ -> false
-let (uu___is_InternalAssumption : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InternalAssumption -> true | uu___ -> false
-let (uu___is_New : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | New -> true | uu___ -> false
-let (uu___is_Private : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Private -> true | uu___ -> false
-let (uu___is_Unfold_for_unification_and_vcgen : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Unfold_for_unification_and_vcgen -> true
-    | uu___ -> false
-let (uu___is_Visible_default : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Visible_default -> true | uu___ -> false
-let (uu___is_Irreducible : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Irreducible -> true | uu___ -> false
-let (uu___is_Inline_for_extraction : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Inline_for_extraction -> true | uu___ -> false
-let (uu___is_NoExtract : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | NoExtract -> true | uu___ -> false
-let (uu___is_Noeq : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Noeq -> true | uu___ -> false
-let (uu___is_Unopteq : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Unopteq -> true | uu___ -> false
-let (uu___is_TotalEffect : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TotalEffect -> true | uu___ -> false
-let (uu___is_Logic : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Logic -> true | uu___ -> false
-let (uu___is_Reifiable : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Reifiable -> true | uu___ -> false
-let (uu___is_Reflectable : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Reflectable _0 -> true | uu___ -> false
-let (__proj__Reflectable__item___0 : qualifier -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | Reflectable _0 -> _0
-let (uu___is_Discriminator : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Discriminator _0 -> true | uu___ -> false
-let (__proj__Discriminator__item___0 : qualifier -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | Discriminator _0 -> _0
-let (uu___is_Projector : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Projector _0 -> true | uu___ -> false
-let (__proj__Projector__item___0 :
-  qualifier -> (FStar_Ident.lident * FStar_Ident.ident)) =
-  fun projectee -> match projectee with | Projector _0 -> _0
-let (uu___is_RecordType : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RecordType _0 -> true | uu___ -> false
-let (__proj__RecordType__item___0 :
-  qualifier -> (FStar_Ident.ident Prims.list * FStar_Ident.ident Prims.list))
-  = fun projectee -> match projectee with | RecordType _0 -> _0
-let (uu___is_RecordConstructor : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | RecordConstructor _0 -> true | uu___ -> false
-let (__proj__RecordConstructor__item___0 :
-  qualifier -> (FStar_Ident.ident Prims.list * FStar_Ident.ident Prims.list))
-  = fun projectee -> match projectee with | RecordConstructor _0 -> _0
-let (uu___is_Action : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Action _0 -> true | uu___ -> false
-let (__proj__Action__item___0 : qualifier -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | Action _0 -> _0
-let (uu___is_ExceptionConstructor : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ExceptionConstructor -> true | uu___ -> false
-let (uu___is_HasMaskedEffect : qualifier -> Prims.bool) =
-  fun projectee ->
-    match projectee with | HasMaskedEffect -> true | uu___ -> false
-let (uu___is_Effect : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | Effect -> true | uu___ -> false
-let (uu___is_OnlyName : qualifier -> Prims.bool) =
-  fun projectee -> match projectee with | OnlyName -> true | uu___ -> false
-type tycon = (FStar_Ident.lident * binders * typ)
-type monad_abbrev = {
-  mabbrev: FStar_Ident.lident ;
-  parms: binders ;
-  def: typ }
-let (__proj__Mkmonad_abbrev__item__mabbrev :
-  monad_abbrev -> FStar_Ident.lident) =
-  fun projectee -> match projectee with | { mabbrev; parms; def;_} -> mabbrev
-let (__proj__Mkmonad_abbrev__item__parms : monad_abbrev -> binders) =
-  fun projectee -> match projectee with | { mabbrev; parms; def;_} -> parms
-let (__proj__Mkmonad_abbrev__item__def : monad_abbrev -> typ) =
-  fun projectee -> match projectee with | { mabbrev; parms; def;_} -> def
-type indexed_effect_binder_kind =
-  | Type_binder 
-  | Substitutive_binder 
-  | BindCont_no_abstraction_binder 
-  | Range_binder 
-  | Repr_binder 
-  | Ad_hoc_binder 
-let (uu___is_Type_binder : indexed_effect_binder_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Type_binder -> true | uu___ -> false
-let (uu___is_Substitutive_binder : indexed_effect_binder_kind -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with | Substitutive_binder -> true | uu___ -> false
-let (uu___is_BindCont_no_abstraction_binder :
-  indexed_effect_binder_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | BindCont_no_abstraction_binder -> true
-    | uu___ -> false
-let (uu___is_Range_binder : indexed_effect_binder_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Range_binder -> true | uu___ -> false
-let (uu___is_Repr_binder : indexed_effect_binder_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Repr_binder -> true | uu___ -> false
-let (uu___is_Ad_hoc_binder : indexed_effect_binder_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Ad_hoc_binder -> true | uu___ -> false
-type indexed_effect_combinator_kind =
-  | Substitutive_combinator of indexed_effect_binder_kind Prims.list 
-  | Substitutive_invariant_combinator 
-  | Ad_hoc_combinator 
-let (uu___is_Substitutive_combinator :
-  indexed_effect_combinator_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Substitutive_combinator _0 -> true
-    | uu___ -> false
-let (__proj__Substitutive_combinator__item___0 :
-  indexed_effect_combinator_kind -> indexed_effect_binder_kind Prims.list) =
-  fun projectee -> match projectee with | Substitutive_combinator _0 -> _0
-let (uu___is_Substitutive_invariant_combinator :
-  indexed_effect_combinator_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Substitutive_invariant_combinator -> true
-    | uu___ -> false
-let (uu___is_Ad_hoc_combinator :
-  indexed_effect_combinator_kind -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Ad_hoc_combinator -> true | uu___ -> false
-type sub_eff =
-  {
-  source: FStar_Ident.lident ;
-  target: FStar_Ident.lident ;
-  lift_wp: tscheme FStar_Pervasives_Native.option ;
-  lift: tscheme FStar_Pervasives_Native.option ;
-  kind: indexed_effect_combinator_kind FStar_Pervasives_Native.option }
-let (__proj__Mksub_eff__item__source : sub_eff -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with | { source; target; lift_wp; lift; kind;_} -> source
-let (__proj__Mksub_eff__item__target : sub_eff -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with | { source; target; lift_wp; lift; kind;_} -> target
-let (__proj__Mksub_eff__item__lift_wp :
-  sub_eff -> tscheme FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { source; target; lift_wp; lift; kind;_} -> lift_wp
-let (__proj__Mksub_eff__item__lift :
-  sub_eff -> tscheme FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with | { source; target; lift_wp; lift; kind;_} -> lift
-let (__proj__Mksub_eff__item__kind :
-  sub_eff -> indexed_effect_combinator_kind FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with | { source; target; lift_wp; lift; kind;_} -> kind
-type action =
-  {
-  action_name: FStar_Ident.lident ;
-  action_unqualified_name: FStar_Ident.ident ;
-  action_univs: univ_names ;
-  action_params: binders ;
-  action_defn: term ;
-  action_typ: typ }
-let (__proj__Mkaction__item__action_name : action -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { action_name; action_unqualified_name; action_univs; action_params;
-        action_defn; action_typ;_} -> action_name
-let (__proj__Mkaction__item__action_unqualified_name :
-  action -> FStar_Ident.ident) =
-  fun projectee ->
-    match projectee with
-    | { action_name; action_unqualified_name; action_univs; action_params;
-        action_defn; action_typ;_} -> action_unqualified_name
-let (__proj__Mkaction__item__action_univs : action -> univ_names) =
-  fun projectee ->
-    match projectee with
-    | { action_name; action_unqualified_name; action_univs; action_params;
-        action_defn; action_typ;_} -> action_univs
-let (__proj__Mkaction__item__action_params : action -> binders) =
-  fun projectee ->
-    match projectee with
-    | { action_name; action_unqualified_name; action_univs; action_params;
-        action_defn; action_typ;_} -> action_params
-let (__proj__Mkaction__item__action_defn : action -> term) =
-  fun projectee ->
-    match projectee with
-    | { action_name; action_unqualified_name; action_univs; action_params;
-        action_defn; action_typ;_} -> action_defn
-let (__proj__Mkaction__item__action_typ : action -> typ) =
-  fun projectee ->
-    match projectee with
-    | { action_name; action_unqualified_name; action_univs; action_params;
-        action_defn; action_typ;_} -> action_typ
-type wp_eff_combinators =
-  {
-  ret_wp: tscheme ;
-  bind_wp: tscheme ;
-  stronger: tscheme ;
-  if_then_else: tscheme ;
-  ite_wp: tscheme ;
-  close_wp: tscheme ;
-  trivial: tscheme ;
-  repr: tscheme FStar_Pervasives_Native.option ;
-  return_repr: tscheme FStar_Pervasives_Native.option ;
-  bind_repr: tscheme FStar_Pervasives_Native.option }
-let (__proj__Mkwp_eff_combinators__item__ret_wp :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> ret_wp
-let (__proj__Mkwp_eff_combinators__item__bind_wp :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> bind_wp
-let (__proj__Mkwp_eff_combinators__item__stronger :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> stronger
-let (__proj__Mkwp_eff_combinators__item__if_then_else :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> if_then_else
-let (__proj__Mkwp_eff_combinators__item__ite_wp :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> ite_wp
-let (__proj__Mkwp_eff_combinators__item__close_wp :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> close_wp
-let (__proj__Mkwp_eff_combinators__item__trivial :
-  wp_eff_combinators -> tscheme) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> trivial
-let (__proj__Mkwp_eff_combinators__item__repr :
-  wp_eff_combinators -> tscheme FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> repr
-let (__proj__Mkwp_eff_combinators__item__return_repr :
-  wp_eff_combinators -> tscheme FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> return_repr
-let (__proj__Mkwp_eff_combinators__item__bind_repr :
-  wp_eff_combinators -> tscheme FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { ret_wp; bind_wp; stronger; if_then_else; ite_wp; close_wp; trivial;
-        repr; return_repr; bind_repr;_} -> bind_repr
-type layered_eff_combinators =
-  {
-  l_repr: (tscheme * tscheme) ;
-  l_return: (tscheme * tscheme) ;
-  l_bind:
-    (tscheme * tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option)
-    ;
-  l_subcomp:
-    (tscheme * tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option)
-    ;
-  l_if_then_else:
-    (tscheme * tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option)
-    }
-let (__proj__Mklayered_eff_combinators__item__l_repr :
-  layered_eff_combinators -> (tscheme * tscheme)) =
-  fun projectee ->
-    match projectee with
-    | { l_repr; l_return; l_bind; l_subcomp; l_if_then_else;_} -> l_repr
-let (__proj__Mklayered_eff_combinators__item__l_return :
-  layered_eff_combinators -> (tscheme * tscheme)) =
-  fun projectee ->
-    match projectee with
-    | { l_repr; l_return; l_bind; l_subcomp; l_if_then_else;_} -> l_return
-let (__proj__Mklayered_eff_combinators__item__l_bind :
-  layered_eff_combinators ->
-    (tscheme * tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option))
-  =
-  fun projectee ->
-    match projectee with
-    | { l_repr; l_return; l_bind; l_subcomp; l_if_then_else;_} -> l_bind
-let (__proj__Mklayered_eff_combinators__item__l_subcomp :
-  layered_eff_combinators ->
-    (tscheme * tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option))
-  =
-  fun projectee ->
-    match projectee with
-    | { l_repr; l_return; l_bind; l_subcomp; l_if_then_else;_} -> l_subcomp
-let (__proj__Mklayered_eff_combinators__item__l_if_then_else :
-  layered_eff_combinators ->
-    (tscheme * tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option))
-  =
-  fun projectee ->
-    match projectee with
-    | { l_repr; l_return; l_bind; l_subcomp; l_if_then_else;_} ->
-        l_if_then_else
-type eff_combinators =
-  | Primitive_eff of wp_eff_combinators 
-  | DM4F_eff of wp_eff_combinators 
-  | Layered_eff of layered_eff_combinators 
-let (uu___is_Primitive_eff : eff_combinators -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Primitive_eff _0 -> true | uu___ -> false
-let (__proj__Primitive_eff__item___0 : eff_combinators -> wp_eff_combinators)
-  = fun projectee -> match projectee with | Primitive_eff _0 -> _0
-let (uu___is_DM4F_eff : eff_combinators -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DM4F_eff _0 -> true | uu___ -> false
-let (__proj__DM4F_eff__item___0 : eff_combinators -> wp_eff_combinators) =
-  fun projectee -> match projectee with | DM4F_eff _0 -> _0
-let (uu___is_Layered_eff : eff_combinators -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Layered_eff _0 -> true | uu___ -> false
-let (__proj__Layered_eff__item___0 :
-  eff_combinators -> layered_eff_combinators) =
-  fun projectee -> match projectee with | Layered_eff _0 -> _0
-type effect_signature =
-  | Layered_eff_sig of (Prims.int * tscheme) 
-  | WP_eff_sig of tscheme 
-let (uu___is_Layered_eff_sig : effect_signature -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Layered_eff_sig _0 -> true | uu___ -> false
-let (__proj__Layered_eff_sig__item___0 :
-  effect_signature -> (Prims.int * tscheme)) =
-  fun projectee -> match projectee with | Layered_eff_sig _0 -> _0
-let (uu___is_WP_eff_sig : effect_signature -> Prims.bool) =
-  fun projectee ->
-    match projectee with | WP_eff_sig _0 -> true | uu___ -> false
-let (__proj__WP_eff_sig__item___0 : effect_signature -> tscheme) =
-  fun projectee -> match projectee with | WP_eff_sig _0 -> _0
-type eff_decl =
-  {
-  mname: FStar_Ident.lident ;
-  cattributes: cflag Prims.list ;
-  univs: univ_names ;
-  binders: binders ;
-  signature: effect_signature ;
-  combinators: eff_combinators ;
-  actions: action Prims.list ;
-  eff_attrs: attribute Prims.list }
-let (__proj__Mkeff_decl__item__mname : eff_decl -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> mname
-let (__proj__Mkeff_decl__item__cattributes : eff_decl -> cflag Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> cattributes
-let (__proj__Mkeff_decl__item__univs : eff_decl -> univ_names) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> univs
-let (__proj__Mkeff_decl__item__binders : eff_decl -> binders) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> binders1
-let (__proj__Mkeff_decl__item__signature : eff_decl -> effect_signature) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> signature
-let (__proj__Mkeff_decl__item__combinators : eff_decl -> eff_combinators) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> combinators
-let (__proj__Mkeff_decl__item__actions : eff_decl -> action Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> actions
-let (__proj__Mkeff_decl__item__eff_attrs : eff_decl -> attribute Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { mname; cattributes; univs; binders = binders1; signature;
-        combinators; actions; eff_attrs;_} -> eff_attrs
-type sig_metadata =
-  {
-  sigmeta_active: Prims.bool ;
-  sigmeta_fact_db_ids: Prims.string Prims.list ;
-  sigmeta_admit: Prims.bool }
-let (__proj__Mksig_metadata__item__sigmeta_active :
-  sig_metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { sigmeta_active; sigmeta_fact_db_ids; sigmeta_admit;_} ->
-        sigmeta_active
-let (__proj__Mksig_metadata__item__sigmeta_fact_db_ids :
-  sig_metadata -> Prims.string Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { sigmeta_active; sigmeta_fact_db_ids; sigmeta_admit;_} ->
-        sigmeta_fact_db_ids
-let (__proj__Mksig_metadata__item__sigmeta_admit :
-  sig_metadata -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { sigmeta_active; sigmeta_fact_db_ids; sigmeta_admit;_} ->
-        sigmeta_admit
-type sigelt' =
-  | Sig_inductive_typ of (FStar_Ident.lident * univ_names * binders *
-  Prims.int FStar_Pervasives_Native.option * typ * FStar_Ident.lident
-  Prims.list * FStar_Ident.lident Prims.list) 
-  | Sig_bundle of (sigelt Prims.list * FStar_Ident.lident Prims.list) 
-  | Sig_datacon of (FStar_Ident.lident * univ_names * typ *
-  FStar_Ident.lident * Prims.int * FStar_Ident.lident Prims.list) 
-  | Sig_declare_typ of (FStar_Ident.lident * univ_names * typ) 
-  | Sig_let of (letbindings * FStar_Ident.lident Prims.list) 
-  | Sig_assume of (FStar_Ident.lident * univ_names * formula) 
-  | Sig_new_effect of eff_decl 
-  | Sig_sub_effect of sub_eff 
-  | Sig_effect_abbrev of (FStar_Ident.lident * univ_names * binders * comp *
-  cflag Prims.list) 
-  | Sig_pragma of pragma 
-  | Sig_splice of (FStar_Ident.lident Prims.list * term) 
-  | Sig_polymonadic_bind of (FStar_Ident.lident * FStar_Ident.lident *
-  FStar_Ident.lident * tscheme * tscheme * indexed_effect_combinator_kind
-  FStar_Pervasives_Native.option) 
-  | Sig_polymonadic_subcomp of (FStar_Ident.lident * FStar_Ident.lident *
-  tscheme * tscheme * indexed_effect_combinator_kind
-  FStar_Pervasives_Native.option) 
-  | Sig_fail of (Prims.int Prims.list * Prims.bool * sigelt Prims.list) 
-and sigelt =
-  {
-  sigel: sigelt' ;
-  sigrng: FStar_Compiler_Range.range ;
-  sigquals: qualifier Prims.list ;
-  sigmeta: sig_metadata ;
-  sigattrs: attribute Prims.list ;
-  sigopts: FStar_VConfig.vconfig FStar_Pervasives_Native.option }
-let (uu___is_Sig_inductive_typ : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_inductive_typ _0 -> true | uu___ -> false
-let (__proj__Sig_inductive_typ__item___0 :
-  sigelt' ->
-    (FStar_Ident.lident * univ_names * binders * Prims.int
-      FStar_Pervasives_Native.option * typ * FStar_Ident.lident Prims.list *
-      FStar_Ident.lident Prims.list))
-  = fun projectee -> match projectee with | Sig_inductive_typ _0 -> _0
-let (uu___is_Sig_bundle : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_bundle _0 -> true | uu___ -> false
-let (__proj__Sig_bundle__item___0 :
-  sigelt' -> (sigelt Prims.list * FStar_Ident.lident Prims.list)) =
-  fun projectee -> match projectee with | Sig_bundle _0 -> _0
-let (uu___is_Sig_datacon : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_datacon _0 -> true | uu___ -> false
-let (__proj__Sig_datacon__item___0 :
-  sigelt' ->
-    (FStar_Ident.lident * univ_names * typ * FStar_Ident.lident * Prims.int *
-      FStar_Ident.lident Prims.list))
-  = fun projectee -> match projectee with | Sig_datacon _0 -> _0
-let (uu___is_Sig_declare_typ : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_declare_typ _0 -> true | uu___ -> false
-let (__proj__Sig_declare_typ__item___0 :
-  sigelt' -> (FStar_Ident.lident * univ_names * typ)) =
-  fun projectee -> match projectee with | Sig_declare_typ _0 -> _0
-let (uu___is_Sig_let : sigelt' -> Prims.bool) =
-  fun projectee -> match projectee with | Sig_let _0 -> true | uu___ -> false
-let (__proj__Sig_let__item___0 :
-  sigelt' -> (letbindings * FStar_Ident.lident Prims.list)) =
-  fun projectee -> match projectee with | Sig_let _0 -> _0
-let (uu___is_Sig_assume : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_assume _0 -> true | uu___ -> false
-let (__proj__Sig_assume__item___0 :
-  sigelt' -> (FStar_Ident.lident * univ_names * formula)) =
-  fun projectee -> match projectee with | Sig_assume _0 -> _0
-let (uu___is_Sig_new_effect : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_new_effect _0 -> true | uu___ -> false
-let (__proj__Sig_new_effect__item___0 : sigelt' -> eff_decl) =
-  fun projectee -> match projectee with | Sig_new_effect _0 -> _0
-let (uu___is_Sig_sub_effect : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_sub_effect _0 -> true | uu___ -> false
-let (__proj__Sig_sub_effect__item___0 : sigelt' -> sub_eff) =
-  fun projectee -> match projectee with | Sig_sub_effect _0 -> _0
-let (uu___is_Sig_effect_abbrev : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_effect_abbrev _0 -> true | uu___ -> false
-let (__proj__Sig_effect_abbrev__item___0 :
-  sigelt' ->
-    (FStar_Ident.lident * univ_names * binders * comp * cflag Prims.list))
-  = fun projectee -> match projectee with | Sig_effect_abbrev _0 -> _0
-let (uu___is_Sig_pragma : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_pragma _0 -> true | uu___ -> false
-let (__proj__Sig_pragma__item___0 : sigelt' -> pragma) =
-  fun projectee -> match projectee with | Sig_pragma _0 -> _0
-let (uu___is_Sig_splice : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_splice _0 -> true | uu___ -> false
-let (__proj__Sig_splice__item___0 :
-  sigelt' -> (FStar_Ident.lident Prims.list * term)) =
-  fun projectee -> match projectee with | Sig_splice _0 -> _0
-let (uu___is_Sig_polymonadic_bind : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_polymonadic_bind _0 -> true | uu___ -> false
-let (__proj__Sig_polymonadic_bind__item___0 :
-  sigelt' ->
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Ident.lident * tscheme *
-      tscheme * indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Sig_polymonadic_bind _0 -> _0
-let (uu___is_Sig_polymonadic_subcomp : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Sig_polymonadic_subcomp _0 -> true
-    | uu___ -> false
-let (__proj__Sig_polymonadic_subcomp__item___0 :
-  sigelt' ->
-    (FStar_Ident.lident * FStar_Ident.lident * tscheme * tscheme *
-      indexed_effect_combinator_kind FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Sig_polymonadic_subcomp _0 -> _0
-let (uu___is_Sig_fail : sigelt' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Sig_fail _0 -> true | uu___ -> false
-let (__proj__Sig_fail__item___0 :
-  sigelt' -> (Prims.int Prims.list * Prims.bool * sigelt Prims.list)) =
-  fun projectee -> match projectee with | Sig_fail _0 -> _0
-let (__proj__Mksigelt__item__sigel : sigelt -> sigelt') =
-  fun projectee ->
-    match projectee with
-    | { sigel; sigrng; sigquals; sigmeta; sigattrs; sigopts;_} -> sigel
-let (__proj__Mksigelt__item__sigrng : sigelt -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { sigel; sigrng; sigquals; sigmeta; sigattrs; sigopts;_} -> sigrng
-let (__proj__Mksigelt__item__sigquals : sigelt -> qualifier Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { sigel; sigrng; sigquals; sigmeta; sigattrs; sigopts;_} -> sigquals
-let (__proj__Mksigelt__item__sigmeta : sigelt -> sig_metadata) =
-  fun projectee ->
-    match projectee with
-    | { sigel; sigrng; sigquals; sigmeta; sigattrs; sigopts;_} -> sigmeta
-let (__proj__Mksigelt__item__sigattrs : sigelt -> attribute Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { sigel; sigrng; sigquals; sigmeta; sigattrs; sigopts;_} -> sigattrs
-let (__proj__Mksigelt__item__sigopts :
-  sigelt -> FStar_VConfig.vconfig FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { sigel; sigrng; sigquals; sigmeta; sigattrs; sigopts;_} -> sigopts
-type sigelts = sigelt Prims.list
-type modul =
-  {
-  name: FStar_Ident.lident ;
-  declarations: sigelts ;
-  is_interface: Prims.bool }
-let (__proj__Mkmodul__item__name : modul -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with | { name; declarations; is_interface;_} -> name
-let (__proj__Mkmodul__item__declarations : modul -> sigelts) =
-  fun projectee ->
-    match projectee with
-    | { name; declarations; is_interface;_} -> declarations
-let (__proj__Mkmodul__item__is_interface : modul -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { name; declarations; is_interface;_} -> is_interface
-let (lazy_chooser :
-  (lazy_kind -> lazyinfo -> term) FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (mod_name : modul -> FStar_Ident.lident) = fun m -> m.name
-let (contains_reflectable : qualifier Prims.list -> Prims.bool) =
-  fun l ->
-    FStar_Compiler_Util.for_some
-      (fun uu___ ->
-         match uu___ with | Reflectable uu___1 -> true | uu___1 -> false) l
-let withinfo : 'a . 'a -> FStar_Compiler_Range.range -> 'a withinfo_t =
-  fun v -> fun r -> { v; p = r }
-let withsort : 'a . 'a -> 'a withinfo_t =
-  fun v -> withinfo v FStar_Compiler_Range.dummyRange
-let (bv_eq : bv -> bv -> Prims.bool) =
-  fun bv1 -> fun bv2 -> bv1.index = bv2.index
-let (order_bv : bv -> bv -> Prims.int) =
-  fun x ->
-    fun y ->
-      let i =
-        let uu___ = FStar_Ident.string_of_id x.ppname in
-        let uu___1 = FStar_Ident.string_of_id y.ppname in
-        FStar_String.compare uu___ uu___1 in
-      if i = Prims.int_zero then x.index - y.index else i
-let (order_ident : FStar_Ident.ident -> FStar_Ident.ident -> Prims.int) =
-  fun x ->
-    fun y ->
-      let uu___ = FStar_Ident.string_of_id x in
-      let uu___1 = FStar_Ident.string_of_id y in
-      FStar_String.compare uu___ uu___1
-let (order_fv : FStar_Ident.lident -> FStar_Ident.lident -> Prims.int) =
-  fun x ->
-    fun y ->
-      let uu___ = FStar_Ident.string_of_lid x in
-      let uu___1 = FStar_Ident.string_of_lid y in
-      FStar_String.compare uu___ uu___1
-let (range_of_lbname : lbname -> FStar_Compiler_Range.range) =
-  fun l ->
-    match l with
-    | FStar_Pervasives.Inl x -> FStar_Ident.range_of_id x.ppname
-    | FStar_Pervasives.Inr fv1 -> FStar_Ident.range_of_lid (fv1.fv_name).v
-let (range_of_bv : bv -> FStar_Compiler_Range.range) =
-  fun x -> FStar_Ident.range_of_id x.ppname
-let (set_range_of_bv : bv -> FStar_Compiler_Range.range -> bv) =
-  fun x ->
-    fun r ->
-      let uu___ = FStar_Ident.set_id_range r x.ppname in
-      { ppname = uu___; index = (x.index); sort = (x.sort) }
-let (on_antiquoted : (term -> term) -> quoteinfo -> quoteinfo) =
-  fun f ->
-    fun qi ->
-      let aq =
-        FStar_Compiler_List.map
-          (fun uu___ ->
-             match uu___ with | (bv1, t) -> let uu___1 = f t in (bv1, uu___1))
-          qi.antiquotes in
-      { qkind = (qi.qkind); antiquotes = aq }
-let (lookup_aq : bv -> antiquotations -> term FStar_Pervasives_Native.option)
-  =
-  fun bv1 ->
-    fun aq ->
-      let uu___ =
-        FStar_Compiler_List.tryFind
-          (fun uu___1 -> match uu___1 with | (bv', uu___2) -> bv_eq bv1 bv')
-          aq in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (uu___1, e) ->
-          FStar_Pervasives_Native.Some e
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let syn :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    'uuuuu -> 'uuuuu1 -> ('uuuuu1 -> 'uuuuu -> 'uuuuu2) -> 'uuuuu2
-  = fun p -> fun k -> fun f -> f k p
-let mk_fvs :
-  'uuuuu .
-    unit -> 'uuuuu FStar_Pervasives_Native.option FStar_Compiler_Effect.ref
-  = fun uu___ -> FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let mk_uvs :
-  'uuuuu .
-    unit -> 'uuuuu FStar_Pervasives_Native.option FStar_Compiler_Effect.ref
-  = fun uu___ -> FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (new_bv_set : unit -> bv FStar_Compiler_Util.set) =
-  fun uu___ -> FStar_Compiler_Util.new_set order_bv
-let (new_id_set : unit -> FStar_Ident.ident FStar_Compiler_Util.set) =
-  fun uu___ -> FStar_Compiler_Util.new_set order_ident
-let (new_fv_set : unit -> FStar_Ident.lident FStar_Compiler_Util.set) =
-  fun uu___ -> FStar_Compiler_Util.new_set order_fv
-let (order_univ_name : univ_name -> univ_name -> Prims.int) =
-  fun x ->
-    fun y ->
-      let uu___ = FStar_Ident.string_of_id x in
-      let uu___1 = FStar_Ident.string_of_id y in
-      FStar_String.compare uu___ uu___1
-let (new_universe_names_set : unit -> univ_name FStar_Compiler_Util.set) =
-  fun uu___ -> FStar_Compiler_Util.new_set order_univ_name
-let (eq_binding : binding -> binding -> Prims.bool) =
-  fun b1 ->
-    fun b2 ->
-      match (b1, b2) with
-      | (Binding_var bv1, Binding_var bv2) -> bv_eq bv1 bv2
-      | (Binding_lid (lid1, uu___), Binding_lid (lid2, uu___1)) ->
-          FStar_Ident.lid_equals lid1 lid2
-      | (Binding_univ u1, Binding_univ u2) -> FStar_Ident.ident_equals u1 u2
-      | uu___ -> false
-type path = Prims.string Prims.list
-type subst_t = subst_elt Prims.list
-let (no_names : freenames) = new_bv_set ()
-let (no_fvars : FStar_Ident.lident FStar_Compiler_Util.set) = new_fv_set ()
-let (no_universe_names : univ_name FStar_Compiler_Util.set) =
-  new_universe_names_set ()
-let (freenames_of_list : bv Prims.list -> freenames) =
-  fun l ->
-    FStar_Compiler_List.fold_right FStar_Compiler_Util.set_add l no_names
-let (list_of_freenames : freenames -> bv Prims.list) =
-  fun fvs -> FStar_Compiler_Util.set_elements fvs
-let mk : 'a . 'a -> FStar_Compiler_Range.range -> 'a syntax =
-  fun t ->
-    fun r ->
-      let uu___ = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-      let uu___1 = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None in
-      { n = t; pos = r; vars = uu___; hash_code = uu___1 }
-let (bv_to_tm : bv -> term) =
-  fun bv1 -> let uu___ = range_of_bv bv1 in mk (Tm_bvar bv1) uu___
-let (bv_to_name : bv -> term) =
-  fun bv1 -> let uu___ = range_of_bv bv1 in mk (Tm_name bv1) uu___
-let (binders_to_names : binders -> term Prims.list) =
-  fun bs ->
-    FStar_Compiler_Effect.op_Bar_Greater bs
-      (FStar_Compiler_List.map (fun b -> bv_to_name b.binder_bv))
-let (mk_Tm_app : term -> args -> FStar_Compiler_Range.range -> term) =
-  fun t1 ->
-    fun args1 ->
-      fun p ->
-        match args1 with | [] -> t1 | uu___ -> mk (Tm_app (t1, args1)) p
-let (mk_Tm_uinst : term -> universes -> term) =
-  fun t ->
-    fun us ->
-      match t.n with
-      | Tm_fvar uu___ ->
-          (match us with | [] -> t | us1 -> mk (Tm_uinst (t, us1)) t.pos)
-      | uu___ -> failwith "Unexpected universe instantiation"
-let (extend_app_n : term -> args -> FStar_Compiler_Range.range -> term) =
-  fun t ->
-    fun args' ->
-      fun r ->
-        match t.n with
-        | Tm_app (head, args1) ->
-            mk_Tm_app head (FStar_Compiler_List.op_At args1 args') r
-        | uu___ -> mk_Tm_app t args' r
-let (extend_app : term -> arg -> FStar_Compiler_Range.range -> term) =
-  fun t -> fun arg1 -> fun r -> extend_app_n t [arg1] r
-let (mk_Tm_delayed : (term * subst_ts) -> FStar_Compiler_Range.range -> term)
-  = fun lr -> fun pos -> mk (Tm_delayed lr) pos
-let (mk_Total : typ -> comp) = fun t -> mk (Total t) t.pos
-let (mk_GTotal : typ -> comp) = fun t -> mk (GTotal t) t.pos
-let (mk_Comp : comp_typ -> comp) = fun ct -> mk (Comp ct) (ct.result_typ).pos
-let (mk_lb :
-  (lbname * univ_name Prims.list * FStar_Ident.lident * typ * term *
-    attribute Prims.list * FStar_Compiler_Range.range) -> letbinding)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (x, univs, eff, t, e, attrs, pos) ->
-        {
-          lbname = x;
-          lbunivs = univs;
-          lbtyp = t;
-          lbeff = eff;
-          lbdef = e;
-          lbattrs = attrs;
-          lbpos = pos
-        }
-let (mk_Tac : typ -> comp) =
-  fun t ->
-    mk_Comp
-      {
-        comp_univs = [U_zero];
-        effect_name = FStar_Parser_Const.effect_Tac_lid;
-        result_typ = t;
-        effect_args = [];
-        flags = [SOMETRIVIAL; TRIVIAL_POSTCONDITION]
-      }
-let (default_sigmeta : sig_metadata) =
-  { sigmeta_active = true; sigmeta_fact_db_ids = []; sigmeta_admit = false }
-let (mk_sigelt : sigelt' -> sigelt) =
-  fun e ->
-    {
-      sigel = e;
-      sigrng = FStar_Compiler_Range.dummyRange;
-      sigquals = [];
-      sigmeta = default_sigmeta;
-      sigattrs = [];
-      sigopts = FStar_Pervasives_Native.None
-    }
-let (mk_subst : subst_t -> subst_t) = fun s -> s
-let (extend_subst : subst_elt -> subst_elt Prims.list -> subst_t) =
-  fun x -> fun s -> x :: s
-let (argpos : arg -> FStar_Compiler_Range.range) =
-  fun x -> (FStar_Pervasives_Native.fst x).pos
-let (tun : term) = mk Tm_unknown FStar_Compiler_Range.dummyRange
-let (teff : term) =
-  mk (Tm_constant FStar_Const.Const_effect) FStar_Compiler_Range.dummyRange
-let (is_teff : term -> Prims.bool) =
-  fun t ->
-    match t.n with
-    | Tm_constant (FStar_Const.Const_effect) -> true
-    | uu___ -> false
-let (is_type : term -> Prims.bool) =
-  fun t -> match t.n with | Tm_type uu___ -> true | uu___ -> false
-let (null_id : FStar_Ident.ident) =
-  FStar_Ident.mk_ident ("_", FStar_Compiler_Range.dummyRange)
-let (null_bv : term -> bv) =
-  fun k ->
-    let uu___ = FStar_Ident.next_id () in
-    { ppname = null_id; index = uu___; sort = k }
-let (is_null_bv : bv -> Prims.bool) =
-  fun b ->
-    let uu___ = FStar_Ident.string_of_id b.ppname in
-    let uu___1 = FStar_Ident.string_of_id null_id in uu___ = uu___1
-let (is_null_binder : binder -> Prims.bool) = fun b -> is_null_bv b.binder_bv
-let (range_of_ropt :
-  FStar_Compiler_Range.range FStar_Pervasives_Native.option ->
-    FStar_Compiler_Range.range)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> FStar_Compiler_Range.dummyRange
-    | FStar_Pervasives_Native.Some r -> r
-let (gen_bv :
-  Prims.string ->
-    FStar_Compiler_Range.range FStar_Pervasives_Native.option -> typ -> bv)
-  =
-  fun s ->
-    fun r ->
-      fun t ->
-        let id = FStar_Ident.mk_ident (s, (range_of_ropt r)) in
-        let uu___ = FStar_Ident.next_id () in
-        { ppname = id; index = uu___; sort = t }
-let (new_bv :
-  FStar_Compiler_Range.range FStar_Pervasives_Native.option -> typ -> bv) =
-  fun ropt -> fun t -> gen_bv FStar_Ident.reserved_prefix ropt t
-let (freshen_bv : bv -> bv) =
-  fun bv1 ->
-    let uu___ = is_null_bv bv1 in
-    if uu___
-    then
-      let uu___1 =
-        let uu___2 = range_of_bv bv1 in FStar_Pervasives_Native.Some uu___2 in
-      new_bv uu___1 bv1.sort
-    else
-      (let uu___2 = FStar_Ident.next_id () in
-       { ppname = (bv1.ppname); index = uu___2; sort = (bv1.sort) })
-let (mk_binder_with_attrs : bv -> bqual -> attribute Prims.list -> binder) =
-  fun bv1 ->
-    fun aqual1 ->
-      fun attrs ->
-        { binder_bv = bv1; binder_qual = aqual1; binder_attrs = attrs }
-let (mk_binder : bv -> binder) =
-  fun a -> mk_binder_with_attrs a FStar_Pervasives_Native.None []
-let (null_binder : term -> binder) =
-  fun t -> let uu___ = null_bv t in mk_binder uu___
-let (imp_tag : binder_qualifier) = Implicit false
-let (iarg : term -> arg) =
-  fun t ->
-    (t,
-      (FStar_Pervasives_Native.Some
-         { aqual_implicit = true; aqual_attributes = [] }))
-let (as_arg : term -> arg) = fun t -> (t, FStar_Pervasives_Native.None)
-let (is_top_level : letbinding Prims.list -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | { lbname = FStar_Pervasives.Inr uu___1; lbunivs = uu___2;
-        lbtyp = uu___3; lbeff = uu___4; lbdef = uu___5; lbattrs = uu___6;
-        lbpos = uu___7;_}::uu___8 -> true
-    | uu___1 -> false
-let (freenames_of_binders : binders -> freenames) =
-  fun bs ->
-    FStar_Compiler_List.fold_right
-      (fun b -> fun out -> FStar_Compiler_Util.set_add b.binder_bv out) bs
-      no_names
-let (binders_of_list : bv Prims.list -> binders) =
-  fun fvs ->
-    FStar_Compiler_Effect.op_Bar_Greater fvs
-      (FStar_Compiler_List.map (fun t -> mk_binder t))
-let (binders_of_freenames : freenames -> binders) =
-  fun fvs ->
-    let uu___ = FStar_Compiler_Util.set_elements fvs in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ binders_of_list
-let (is_bqual_implicit : bqual -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some (Implicit uu___1) -> true
-    | uu___1 -> false
-let (is_aqual_implicit : aqual -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some
-        { aqual_implicit = b; aqual_attributes = uu___1;_} -> b
-    | uu___1 -> false
-let (is_bqual_implicit_or_meta : bqual -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some (Implicit uu___1) -> true
-    | FStar_Pervasives_Native.Some (Meta uu___1) -> true
-    | uu___1 -> false
-let (as_bqual_implicit : Prims.bool -> bqual) =
-  fun uu___ ->
-    if uu___
-    then FStar_Pervasives_Native.Some imp_tag
-    else FStar_Pervasives_Native.None
-let (as_aqual_implicit : Prims.bool -> aqual) =
-  fun uu___ ->
-    if uu___
-    then
-      FStar_Pervasives_Native.Some
-        { aqual_implicit = true; aqual_attributes = [] }
-    else FStar_Pervasives_Native.None
-let (pat_bvs : pat -> bv Prims.list) =
-  fun p ->
-    let rec aux b p1 =
-      match p1.v with
-      | Pat_dot_term uu___ -> b
-      | Pat_constant uu___ -> b
-      | Pat_wild x -> x :: b
-      | Pat_var x -> x :: b
-      | Pat_cons (uu___, uu___1, pats) ->
-          FStar_Compiler_List.fold_left
-            (fun b1 ->
-               fun uu___2 -> match uu___2 with | (p2, uu___3) -> aux b1 p2) b
-            pats in
-    let uu___ = aux [] p in
-    FStar_Compiler_Effect.op_Less_Bar FStar_Compiler_List.rev uu___
-let (freshen_binder : binder -> binder) =
-  fun b ->
-    let uu___ = freshen_bv b.binder_bv in
-    {
-      binder_bv = uu___;
-      binder_qual = (b.binder_qual);
-      binder_attrs = (b.binder_attrs)
-    }
-let (new_univ_name :
-  FStar_Compiler_Range.range FStar_Pervasives_Native.option -> univ_name) =
-  fun ropt ->
-    let id = FStar_Ident.next_id () in
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_Compiler_Util.string_of_int id in
-        Prims.op_Hat FStar_Ident.reserved_prefix uu___2 in
-      (uu___1, (range_of_ropt ropt)) in
-    FStar_Ident.mk_ident uu___
-let (lbname_eq :
-  (bv, FStar_Ident.lident) FStar_Pervasives.either ->
-    (bv, FStar_Ident.lident) FStar_Pervasives.either -> Prims.bool)
-  =
-  fun l1 ->
-    fun l2 ->
-      match (l1, l2) with
-      | (FStar_Pervasives.Inl x, FStar_Pervasives.Inl y) -> bv_eq x y
-      | (FStar_Pervasives.Inr l, FStar_Pervasives.Inr m) ->
-          FStar_Ident.lid_equals l m
-      | uu___ -> false
-let (fv_eq : fv -> fv -> Prims.bool) =
-  fun fv1 ->
-    fun fv2 -> FStar_Ident.lid_equals (fv1.fv_name).v (fv2.fv_name).v
-let (fv_eq_lid : fv -> FStar_Ident.lident -> Prims.bool) =
-  fun fv1 -> fun lid -> FStar_Ident.lid_equals (fv1.fv_name).v lid
-let (set_bv_range : bv -> FStar_Compiler_Range.range -> bv) =
-  fun bv1 ->
-    fun r ->
-      let uu___ = FStar_Ident.set_id_range r bv1.ppname in
-      { ppname = uu___; index = (bv1.index); sort = (bv1.sort) }
-let (lid_as_fv :
-  FStar_Ident.lident ->
-    delta_depth -> fv_qual FStar_Pervasives_Native.option -> fv)
-  =
-  fun l ->
-    fun dd ->
-      fun dq ->
-        let uu___ =
-          let uu___1 = FStar_Ident.range_of_lid l in withinfo l uu___1 in
-        { fv_name = uu___; fv_delta = dd; fv_qual = dq }
-let (fv_to_tm : fv -> term) =
-  fun fv1 ->
-    let uu___ = FStar_Ident.range_of_lid (fv1.fv_name).v in
-    mk (Tm_fvar fv1) uu___
-let (fvar :
-  FStar_Ident.lident ->
-    delta_depth -> fv_qual FStar_Pervasives_Native.option -> term)
-  =
-  fun l ->
-    fun dd -> fun dq -> let uu___ = lid_as_fv l dd dq in fv_to_tm uu___
-let (lid_of_fv : fv -> FStar_Ident.lid) = fun fv1 -> (fv1.fv_name).v
-let (range_of_fv : fv -> FStar_Compiler_Range.range) =
-  fun fv1 -> let uu___ = lid_of_fv fv1 in FStar_Ident.range_of_lid uu___
-let (set_range_of_fv : fv -> FStar_Compiler_Range.range -> fv) =
-  fun fv1 ->
-    fun r ->
-      let uu___ =
-        let uu___1 = fv1.fv_name in
-        let uu___2 =
-          let uu___3 = lid_of_fv fv1 in FStar_Ident.set_lid_range uu___3 r in
-        { v = uu___2; p = (uu___1.p) } in
-      { fv_name = uu___; fv_delta = (fv1.fv_delta); fv_qual = (fv1.fv_qual) }
-let (has_simple_attribute : term Prims.list -> Prims.string -> Prims.bool) =
-  fun l ->
-    fun s ->
-      FStar_Compiler_List.existsb
-        (fun uu___ ->
-           match uu___ with
-           | { n = Tm_constant (FStar_Const.Const_string (data, uu___1));
-               pos = uu___2; vars = uu___3; hash_code = uu___4;_} when
-               data = s -> true
-           | uu___1 -> false) l
-let rec (eq_pat : pat -> pat -> Prims.bool) =
-  fun p1 ->
-    fun p2 ->
-      match ((p1.v), (p2.v)) with
-      | (Pat_constant c1, Pat_constant c2) -> FStar_Const.eq_const c1 c2
-      | (Pat_cons (fv1, us1, as1), Pat_cons (fv2, us2, as2)) ->
-          let uu___ =
-            (fv_eq fv1 fv2) &&
-              ((FStar_Compiler_List.length as1) =
-                 (FStar_Compiler_List.length as2)) in
-          if uu___
-          then
-            (FStar_Compiler_List.forall2
-               (fun uu___1 ->
-                  fun uu___2 ->
-                    match (uu___1, uu___2) with
-                    | ((p11, b1), (p21, b2)) -> (b1 = b2) && (eq_pat p11 p21))
-               as1 as2)
-              &&
-              ((match (us1, us2) with
-                | (FStar_Pervasives_Native.None,
-                   FStar_Pervasives_Native.None) -> true
-                | (FStar_Pervasives_Native.Some us11,
-                   FStar_Pervasives_Native.Some us21) ->
-                    (FStar_Compiler_List.length us11) =
-                      (FStar_Compiler_List.length us21)
-                | uu___1 -> false))
-          else false
-      | (Pat_var uu___, Pat_var uu___1) -> true
-      | (Pat_wild uu___, Pat_wild uu___1) -> true
-      | (Pat_dot_term uu___, Pat_dot_term uu___1) -> true
-      | (uu___, uu___1) -> false
-let (delta_constant : delta_depth) = Delta_constant_at_level Prims.int_zero
-let (delta_equational : delta_depth) =
-  Delta_equational_at_level Prims.int_zero
-let (fvconst : FStar_Ident.lident -> fv) =
-  fun l -> lid_as_fv l delta_constant FStar_Pervasives_Native.None
-let (tconst : FStar_Ident.lident -> term) =
-  fun l ->
-    let uu___ = let uu___1 = fvconst l in Tm_fvar uu___1 in
-    mk uu___ FStar_Compiler_Range.dummyRange
-let (tabbrev : FStar_Ident.lident -> term) =
-  fun l ->
-    let uu___ =
-      let uu___1 =
-        lid_as_fv l (Delta_constant_at_level Prims.int_one)
-          FStar_Pervasives_Native.None in
-      Tm_fvar uu___1 in
-    mk uu___ FStar_Compiler_Range.dummyRange
-let (tdataconstr : FStar_Ident.lident -> term) =
-  fun l ->
-    let uu___ =
-      lid_as_fv l delta_constant (FStar_Pervasives_Native.Some Data_ctor) in
-    fv_to_tm uu___
-let (t_unit : term) = tconst FStar_Parser_Const.unit_lid
-let (t_bool : term) = tconst FStar_Parser_Const.bool_lid
-let (t_int : term) = tconst FStar_Parser_Const.int_lid
-let (t_string : term) = tconst FStar_Parser_Const.string_lid
-let (t_exn : term) = tconst FStar_Parser_Const.exn_lid
-let (t_real : term) = tconst FStar_Parser_Const.real_lid
-let (t_float : term) = tconst FStar_Parser_Const.float_lid
-let (t_char : term) = tabbrev FStar_Parser_Const.char_lid
-let (t_range : term) = tconst FStar_Parser_Const.range_lid
-let (t_vconfig : term) = tconst FStar_Parser_Const.vconfig_lid
-let (t_term : term) = tconst FStar_Parser_Const.term_lid
-let (t_term_view : term) = tabbrev FStar_Parser_Const.term_view_lid
-let (t_order : term) = tconst FStar_Parser_Const.order_lid
-let (t_decls : term) = tabbrev FStar_Parser_Const.decls_lid
-let (t_binder : term) = tconst FStar_Parser_Const.binder_lid
-let (t_binders : term) = tconst FStar_Parser_Const.binders_lid
-let (t_bv : term) = tconst FStar_Parser_Const.bv_lid
-let (t_fv : term) = tconst FStar_Parser_Const.fv_lid
-let (t_norm_step : term) = tconst FStar_Parser_Const.norm_step_lid
-let (t_tac_of : term -> term -> term) =
-  fun a ->
-    fun b ->
-      let uu___ =
-        let uu___1 = tabbrev FStar_Parser_Const.tac_lid in
-        mk_Tm_uinst uu___1 [U_zero; U_zero] in
-      let uu___1 =
-        let uu___2 = as_arg a in
-        let uu___3 = let uu___4 = as_arg b in [uu___4] in uu___2 :: uu___3 in
-      mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (t_tactic_of : term -> term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = tabbrev FStar_Parser_Const.tactic_lid in
-      mk_Tm_uinst uu___1 [U_zero] in
-    let uu___1 = let uu___2 = as_arg t in [uu___2] in
-    mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (t_tactic_unit : term) = t_tactic_of t_unit
-let (t_list_of : term -> term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = tabbrev FStar_Parser_Const.list_lid in
-      mk_Tm_uinst uu___1 [U_zero] in
-    let uu___1 = let uu___2 = as_arg t in [uu___2] in
-    mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (t_option_of : term -> term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = tabbrev FStar_Parser_Const.option_lid in
-      mk_Tm_uinst uu___1 [U_zero] in
-    let uu___1 = let uu___2 = as_arg t in [uu___2] in
-    mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (t_tuple2_of : term -> term -> term) =
-  fun t1 ->
-    fun t2 ->
-      let uu___ =
-        let uu___1 = tabbrev FStar_Parser_Const.lid_tuple2 in
-        mk_Tm_uinst uu___1 [U_zero; U_zero] in
-      let uu___1 =
-        let uu___2 = as_arg t1 in
-        let uu___3 = let uu___4 = as_arg t2 in [uu___4] in uu___2 :: uu___3 in
-      mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (t_tuple3_of : term -> term -> term -> term) =
-  fun t1 ->
-    fun t2 ->
-      fun t3 ->
-        let uu___ =
-          let uu___1 = tabbrev FStar_Parser_Const.lid_tuple3 in
-          mk_Tm_uinst uu___1 [U_zero; U_zero; U_zero] in
-        let uu___1 =
-          let uu___2 = as_arg t1 in
-          let uu___3 =
-            let uu___4 = as_arg t2 in
-            let uu___5 = let uu___6 = as_arg t3 in [uu___6] in uu___4 ::
-              uu___5 in
-          uu___2 :: uu___3 in
-        mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (t_either_of : term -> term -> term) =
-  fun t1 ->
-    fun t2 ->
-      let uu___ =
-        let uu___1 = tabbrev FStar_Parser_Const.either_lid in
-        mk_Tm_uinst uu___1 [U_zero; U_zero] in
-      let uu___1 =
-        let uu___2 = as_arg t1 in
-        let uu___3 = let uu___4 = as_arg t2 in [uu___4] in uu___2 :: uu___3 in
-      mk_Tm_app uu___ uu___1 FStar_Compiler_Range.dummyRange
-let (unit_const_with_range : FStar_Compiler_Range.range -> term) =
-  fun r -> mk (Tm_constant FStar_Const.Const_unit) r
-let (unit_const : term) =
-  unit_const_with_range FStar_Compiler_Range.dummyRange
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Unionfind.ml b/src/ocaml-output/FStar_Syntax_Unionfind.ml
deleted file mode 100644
index 721c88c6b77..00000000000
--- a/src/ocaml-output/FStar_Syntax_Unionfind.ml
+++ /dev/null
@@ -1,379 +0,0 @@
-open Prims
-type vops_t =
-  {
-  next_major: unit -> FStar_Syntax_Syntax.version ;
-  next_minor: unit -> FStar_Syntax_Syntax.version }
-let (__proj__Mkvops_t__item__next_major :
-  vops_t -> unit -> FStar_Syntax_Syntax.version) =
-  fun projectee ->
-    match projectee with | { next_major; next_minor;_} -> next_major
-let (__proj__Mkvops_t__item__next_minor :
-  vops_t -> unit -> FStar_Syntax_Syntax.version) =
-  fun projectee ->
-    match projectee with | { next_major; next_minor;_} -> next_minor
-let (vops : vops_t) =
-  let major = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let minor = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  let next_major uu___ =
-    FStar_Compiler_Effect.op_Colon_Equals minor Prims.int_zero;
-    (let uu___2 =
-       FStar_Compiler_Util.incr major; FStar_Compiler_Effect.op_Bang major in
-     {
-       FStar_Syntax_Syntax.major = uu___2;
-       FStar_Syntax_Syntax.minor = Prims.int_zero
-     }) in
-  let next_minor uu___ =
-    let uu___1 = FStar_Compiler_Effect.op_Bang major in
-    let uu___2 =
-      FStar_Compiler_Util.incr minor; FStar_Compiler_Effect.op_Bang minor in
-    { FStar_Syntax_Syntax.major = uu___1; FStar_Syntax_Syntax.minor = uu___2
-    } in
-  { next_major; next_minor }
-type tgraph =
-  (FStar_Syntax_Syntax.term FStar_Pervasives_Native.option *
-    FStar_Syntax_Syntax.uvar_decoration) FStar_Unionfind.puf
-type ugraph =
-  FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option
-    FStar_Unionfind.puf
-type uf =
-  {
-  term_graph: tgraph ;
-  univ_graph: ugraph ;
-  version: FStar_Syntax_Syntax.version ;
-  ro: Prims.bool }
-let (__proj__Mkuf__item__term_graph : uf -> tgraph) =
-  fun projectee ->
-    match projectee with
-    | { term_graph; univ_graph; version; ro;_} -> term_graph
-let (__proj__Mkuf__item__univ_graph : uf -> ugraph) =
-  fun projectee ->
-    match projectee with
-    | { term_graph; univ_graph; version; ro;_} -> univ_graph
-let (__proj__Mkuf__item__version : uf -> FStar_Syntax_Syntax.version) =
-  fun projectee ->
-    match projectee with
-    | { term_graph; univ_graph; version; ro;_} -> version
-let (__proj__Mkuf__item__ro : uf -> Prims.bool) =
-  fun projectee ->
-    match projectee with | { term_graph; univ_graph; version; ro;_} -> ro
-let (empty : FStar_Syntax_Syntax.version -> uf) =
-  fun v ->
-    let uu___ = FStar_Unionfind.puf_empty () in
-    let uu___1 = FStar_Unionfind.puf_empty () in
-    { term_graph = uu___; univ_graph = uu___1; version = v; ro = false }
-let (version_to_string : FStar_Syntax_Syntax.version -> Prims.string) =
-  fun v ->
-    let uu___ = FStar_Compiler_Util.string_of_int v.FStar_Syntax_Syntax.major in
-    let uu___1 =
-      FStar_Compiler_Util.string_of_int v.FStar_Syntax_Syntax.minor in
-    FStar_Compiler_Util.format2 "%s.%s" uu___ uu___1
-let (state : uf FStar_Compiler_Effect.ref) =
-  let uu___ = let uu___1 = vops.next_major () in empty uu___1 in
-  FStar_Compiler_Util.mk_ref uu___
-type tx =
-  | TX of uf 
-let (uu___is_TX : tx -> Prims.bool) = fun projectee -> true
-let (__proj__TX__item___0 : tx -> uf) =
-  fun projectee -> match projectee with | TX _0 -> _0
-let (get : unit -> uf) = fun uu___ -> FStar_Compiler_Effect.op_Bang state
-let (set_ro : unit -> unit) =
-  fun uu___ ->
-    let s = get () in
-    FStar_Compiler_Effect.op_Colon_Equals state
-      {
-        term_graph = (s.term_graph);
-        univ_graph = (s.univ_graph);
-        version = (s.version);
-        ro = true
-      }
-let (set_rw : unit -> unit) =
-  fun uu___ ->
-    let s = get () in
-    FStar_Compiler_Effect.op_Colon_Equals state
-      {
-        term_graph = (s.term_graph);
-        univ_graph = (s.univ_graph);
-        version = (s.version);
-        ro = false
-      }
-let with_uf_enabled : 'a . (unit -> 'a) -> 'a =
-  fun f ->
-    let s = get () in
-    set_rw ();
-    (let restore uu___1 = if s.ro then set_ro () else () in
-     let r =
-       let uu___1 = FStar_Options.trace_error () in
-       if uu___1
-       then f ()
-       else
-         (try (fun uu___3 -> match () with | () -> f ()) ()
-          with | uu___3 -> (restore (); FStar_Compiler_Effect.raise uu___3)) in
-     restore (); r)
-let (fail_if_ro : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = let uu___2 = get () in uu___2.ro in
-    if uu___1
-    then
-      FStar_Errors.raise_error
-        (FStar_Errors.Fatal_BadUvar,
-          "Internal error: UF graph was in read-only mode")
-        FStar_Compiler_Range.dummyRange
-    else ()
-let (set : uf -> unit) =
-  fun u -> fail_if_ro (); FStar_Compiler_Effect.op_Colon_Equals state u
-let (reset : unit -> unit) =
-  fun uu___ ->
-    fail_if_ro ();
-    (let v = vops.next_major () in
-     let uu___2 =
-       let uu___3 = empty v in
-       {
-         term_graph = (uu___3.term_graph);
-         univ_graph = (uu___3.univ_graph);
-         version = (uu___3.version);
-         ro = false
-       } in
-     set uu___2)
-let (new_transaction : unit -> tx) =
-  fun uu___ ->
-    let tx1 = let uu___1 = get () in TX uu___1 in
-    (let uu___2 =
-       let uu___3 = get () in
-       let uu___4 = vops.next_minor () in
-       {
-         term_graph = (uu___3.term_graph);
-         univ_graph = (uu___3.univ_graph);
-         version = uu___4;
-         ro = (uu___3.ro)
-       } in
-     set uu___2);
-    tx1
-let (commit : tx -> unit) = fun tx1 -> ()
-let (rollback : tx -> unit) =
-  fun uu___ -> match uu___ with | TX uf1 -> set uf1
-let update_in_tx : 'a . 'a FStar_Compiler_Effect.ref -> 'a -> unit =
-  fun r -> fun x -> ()
-let (get_term_graph : unit -> tgraph) =
-  fun uu___ -> let uu___1 = get () in uu___1.term_graph
-let (get_version : unit -> FStar_Syntax_Syntax.version) =
-  fun uu___ -> let uu___1 = get () in uu___1.version
-let (set_term_graph : tgraph -> unit) =
-  fun tg ->
-    let uu___ =
-      let uu___1 = get () in
-      {
-        term_graph = tg;
-        univ_graph = (uu___1.univ_graph);
-        version = (uu___1.version);
-        ro = (uu___1.ro)
-      } in
-    set uu___
-let (chk_v_t :
-  FStar_Syntax_Syntax.uvar ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option * FStar_Syntax_Syntax.uvar_decoration)
-      FStar_Unionfind.p_uvar)
-  =
-  fun su ->
-    let uu___ = su in
-    match uu___ with
-    | (u, v, rng) ->
-        let uvar_to_string u1 =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = get_term_graph () in
-              FStar_Unionfind.puf_id uu___3 u1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              FStar_Compiler_Util.string_of_int in
-          Prims.op_Hat "?" uu___1 in
-        let expected = get_version () in
-        if
-          (v.FStar_Syntax_Syntax.major = expected.FStar_Syntax_Syntax.major)
-            &&
-            (v.FStar_Syntax_Syntax.minor <=
-               expected.FStar_Syntax_Syntax.minor)
-        then u
-        else
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = uvar_to_string u in
-               let uu___5 = version_to_string expected in
-               let uu___6 = version_to_string v in
-               FStar_Compiler_Util.format3
-                 "Internal error: incompatible version for term unification variable %s: current version is %s; got version %s"
-                 uu___4 uu___5 uu___6 in
-             (FStar_Errors.Fatal_BadUvar, uu___3) in
-           FStar_Errors.raise_error uu___2 rng)
-let (uvar_id : FStar_Syntax_Syntax.uvar -> Prims.int) =
-  fun u ->
-    let uu___ = get_term_graph () in
-    let uu___1 = chk_v_t u in FStar_Unionfind.puf_id uu___ uu___1
-let (fresh :
-  FStar_Syntax_Syntax.uvar_decoration ->
-    FStar_Compiler_Range.range -> FStar_Syntax_Syntax.uvar)
-  =
-  fun decoration ->
-    fun rng ->
-      fail_if_ro ();
-      (let uu___1 =
-         let uu___2 = get_term_graph () in
-         FStar_Unionfind.puf_fresh uu___2
-           (FStar_Pervasives_Native.None, decoration) in
-       let uu___2 = get_version () in (uu___1, uu___2, rng))
-let (find_core :
-  FStar_Syntax_Syntax.uvar ->
-    (FStar_Syntax_Syntax.term FStar_Pervasives_Native.option *
-      FStar_Syntax_Syntax.uvar_decoration))
-  =
-  fun u ->
-    let uu___ = get_term_graph () in
-    let uu___1 = chk_v_t u in FStar_Unionfind.puf_find uu___ uu___1
-let (find :
-  FStar_Syntax_Syntax.uvar ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  = fun u -> let uu___ = find_core u in FStar_Pervasives_Native.fst uu___
-let (find_decoration :
-  FStar_Syntax_Syntax.uvar -> FStar_Syntax_Syntax.uvar_decoration) =
-  fun u -> let uu___ = find_core u in FStar_Pervasives_Native.snd uu___
-let (change : FStar_Syntax_Syntax.uvar -> FStar_Syntax_Syntax.term -> unit) =
-  fun u ->
-    fun t ->
-      let uu___ = find_core u in
-      match uu___ with
-      | (uu___1, dec) ->
-          let uu___2 =
-            let uu___3 = get_term_graph () in
-            let uu___4 = chk_v_t u in
-            FStar_Unionfind.puf_change uu___3 uu___4
-              ((FStar_Pervasives_Native.Some t), dec) in
-          set_term_graph uu___2
-let (change_decoration :
-  FStar_Syntax_Syntax.uvar -> FStar_Syntax_Syntax.uvar_decoration -> unit) =
-  fun u ->
-    fun d ->
-      let uu___ = find_core u in
-      match uu___ with
-      | (t, uu___1) ->
-          let uu___2 =
-            let uu___3 = get_term_graph () in
-            let uu___4 = chk_v_t u in
-            FStar_Unionfind.puf_change uu___3 uu___4 (t, d) in
-          set_term_graph uu___2
-let (equiv :
-  FStar_Syntax_Syntax.uvar -> FStar_Syntax_Syntax.uvar -> Prims.bool) =
-  fun u ->
-    fun v ->
-      let uu___ = get_term_graph () in
-      let uu___1 = chk_v_t u in
-      let uu___2 = chk_v_t v in
-      FStar_Unionfind.puf_equivalent uu___ uu___1 uu___2
-let (union : FStar_Syntax_Syntax.uvar -> FStar_Syntax_Syntax.uvar -> unit) =
-  fun u ->
-    fun v ->
-      let uu___ =
-        let uu___1 = get_term_graph () in
-        let uu___2 = chk_v_t u in
-        let uu___3 = chk_v_t v in
-        FStar_Unionfind.puf_union uu___1 uu___2 uu___3 in
-      set_term_graph uu___
-let (get_univ_graph : unit -> ugraph) =
-  fun uu___ -> let uu___1 = get () in uu___1.univ_graph
-let (chk_v_u :
-  (FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option
-    FStar_Unionfind.p_uvar * FStar_Syntax_Syntax.version *
-    FStar_Compiler_Range.range) ->
-    FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option
-      FStar_Unionfind.p_uvar)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (u, v, rng) ->
-        let uvar_to_string u1 =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = get_univ_graph () in
-              FStar_Unionfind.puf_id uu___3 u1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              FStar_Compiler_Util.string_of_int in
-          Prims.op_Hat "?" uu___1 in
-        let expected = get_version () in
-        if
-          (v.FStar_Syntax_Syntax.major = expected.FStar_Syntax_Syntax.major)
-            &&
-            (v.FStar_Syntax_Syntax.minor <=
-               expected.FStar_Syntax_Syntax.minor)
-        then u
-        else
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 = uvar_to_string u in
-               let uu___5 = version_to_string expected in
-               let uu___6 = version_to_string v in
-               FStar_Compiler_Util.format3
-                 "Internal error: incompatible version for universe unification variable %s: current version is %s; got version %s"
-                 uu___4 uu___5 uu___6 in
-             (FStar_Errors.Fatal_BadUvar, uu___3) in
-           FStar_Errors.raise_error uu___2 rng)
-let (set_univ_graph : ugraph -> unit) =
-  fun ug ->
-    let uu___ =
-      let uu___1 = get () in
-      {
-        term_graph = (uu___1.term_graph);
-        univ_graph = ug;
-        version = (uu___1.version);
-        ro = (uu___1.ro)
-      } in
-    set uu___
-let (univ_uvar_id : FStar_Syntax_Syntax.universe_uvar -> Prims.int) =
-  fun u ->
-    let uu___ = get_univ_graph () in
-    let uu___1 = chk_v_u u in FStar_Unionfind.puf_id uu___ uu___1
-let (univ_fresh :
-  FStar_Compiler_Range.range -> FStar_Syntax_Syntax.universe_uvar) =
-  fun rng ->
-    fail_if_ro ();
-    (let uu___1 =
-       let uu___2 = get_univ_graph () in
-       FStar_Unionfind.puf_fresh uu___2 FStar_Pervasives_Native.None in
-     let uu___2 = get_version () in (uu___1, uu___2, rng))
-let (univ_find :
-  FStar_Syntax_Syntax.universe_uvar ->
-    FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option)
-  =
-  fun u ->
-    let uu___ = get_univ_graph () in
-    let uu___1 = chk_v_u u in FStar_Unionfind.puf_find uu___ uu___1
-let (univ_change :
-  FStar_Syntax_Syntax.universe_uvar -> FStar_Syntax_Syntax.universe -> unit)
-  =
-  fun u ->
-    fun t ->
-      let uu___ =
-        let uu___1 = get_univ_graph () in
-        let uu___2 = chk_v_u u in
-        FStar_Unionfind.puf_change uu___1 uu___2
-          (FStar_Pervasives_Native.Some t) in
-      set_univ_graph uu___
-let (univ_equiv :
-  FStar_Syntax_Syntax.universe_uvar ->
-    FStar_Syntax_Syntax.universe_uvar -> Prims.bool)
-  =
-  fun u ->
-    fun v ->
-      let uu___ = get_univ_graph () in
-      let uu___1 = chk_v_u u in
-      let uu___2 = chk_v_u v in
-      FStar_Unionfind.puf_equivalent uu___ uu___1 uu___2
-let (univ_union :
-  FStar_Syntax_Syntax.universe_uvar ->
-    FStar_Syntax_Syntax.universe_uvar -> unit)
-  =
-  fun u ->
-    fun v ->
-      let uu___ =
-        let uu___1 = get_univ_graph () in
-        let uu___2 = chk_v_u u in
-        let uu___3 = chk_v_u v in
-        FStar_Unionfind.puf_union uu___1 uu___2 uu___3 in
-      set_univ_graph uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Syntax_Util.ml b/src/ocaml-output/FStar_Syntax_Util.ml
deleted file mode 100644
index 23f839374a3..00000000000
--- a/src/ocaml-output/FStar_Syntax_Util.ml
+++ /dev/null
@@ -1,4879 +0,0 @@
-open Prims
-let (tts_f :
-  (FStar_Syntax_Syntax.term -> Prims.string) FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (tts : FStar_Syntax_Syntax.term -> Prims.string) =
-  fun t ->
-    let uu___ = FStar_Compiler_Effect.op_Bang tts_f in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> "<<hook unset>>"
-    | FStar_Pervasives_Native.Some f -> f t
-let (mk_discriminator : FStar_Ident.lident -> FStar_Ident.lident) =
-  fun lid ->
-    let uu___ =
-      let uu___1 = FStar_Ident.ns_of_lid lid in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 = FStar_Ident.ident_of_lid lid in
-                  FStar_Ident.string_of_id uu___8 in
-                Prims.op_Hat "is_" uu___7 in
-              Prims.op_Hat FStar_Ident.reserved_prefix uu___6 in
-            let uu___6 = FStar_Ident.range_of_lid lid in (uu___5, uu___6) in
-          FStar_Ident.mk_ident uu___4 in
-        [uu___3] in
-      FStar_Compiler_List.op_At uu___1 uu___2 in
-    FStar_Ident.lid_of_ids uu___
-let (is_name : FStar_Ident.lident -> Prims.bool) =
-  fun lid ->
-    let c =
-      let uu___ =
-        let uu___1 = FStar_Ident.ident_of_lid lid in
-        FStar_Ident.string_of_id uu___1 in
-      FStar_Compiler_Util.char_at uu___ Prims.int_zero in
-    FStar_Compiler_Util.is_upper c
-let (aqual_of_binder :
-  FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.aqual) =
-  fun b ->
-    match ((b.FStar_Syntax_Syntax.binder_qual),
-            (b.FStar_Syntax_Syntax.binder_attrs))
-    with
-    | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit uu___),
-       uu___1) ->
-        FStar_Pervasives_Native.Some
-          {
-            FStar_Syntax_Syntax.aqual_implicit = true;
-            FStar_Syntax_Syntax.aqual_attributes =
-              (b.FStar_Syntax_Syntax.binder_attrs)
-          }
-    | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta uu___), uu___1)
-        ->
-        FStar_Pervasives_Native.Some
-          {
-            FStar_Syntax_Syntax.aqual_implicit = true;
-            FStar_Syntax_Syntax.aqual_attributes =
-              (b.FStar_Syntax_Syntax.binder_attrs)
-          }
-    | (uu___, uu___1::uu___2) ->
-        FStar_Pervasives_Native.Some
-          {
-            FStar_Syntax_Syntax.aqual_implicit = false;
-            FStar_Syntax_Syntax.aqual_attributes =
-              (b.FStar_Syntax_Syntax.binder_attrs)
-          }
-    | uu___ -> FStar_Pervasives_Native.None
-let (bqual_and_attrs_of_aqual :
-  FStar_Syntax_Syntax.aqual ->
-    (FStar_Syntax_Syntax.bqual * FStar_Syntax_Syntax.attribute Prims.list))
-  =
-  fun a ->
-    match a with
-    | FStar_Pervasives_Native.None -> (FStar_Pervasives_Native.None, [])
-    | FStar_Pervasives_Native.Some a1 ->
-        ((if a1.FStar_Syntax_Syntax.aqual_implicit
-          then FStar_Pervasives_Native.Some FStar_Syntax_Syntax.imp_tag
-          else FStar_Pervasives_Native.None),
-          (a1.FStar_Syntax_Syntax.aqual_attributes))
-let (arg_of_non_null_binder :
-  FStar_Syntax_Syntax.binder ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual))
-  =
-  fun b ->
-    let uu___ =
-      FStar_Syntax_Syntax.bv_to_name b.FStar_Syntax_Syntax.binder_bv in
-    let uu___1 = aqual_of_binder b in (uu___, uu___1)
-let (args_of_non_null_binders :
-  FStar_Syntax_Syntax.binders ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual) Prims.list)
-  =
-  fun binders ->
-    FStar_Compiler_Effect.op_Bar_Greater binders
-      (FStar_Compiler_List.collect
-         (fun b ->
-            let uu___ = FStar_Syntax_Syntax.is_null_binder b in
-            if uu___
-            then []
-            else (let uu___2 = arg_of_non_null_binder b in [uu___2])))
-let (args_of_binders :
-  FStar_Syntax_Syntax.binders ->
-    (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.args))
-  =
-  fun binders ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater binders
-        (FStar_Compiler_List.map
-           (fun b ->
-              let uu___1 = FStar_Syntax_Syntax.is_null_binder b in
-              if uu___1
-              then
-                let b1 =
-                  let uu___2 =
-                    FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                      (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                  {
-                    FStar_Syntax_Syntax.binder_bv = uu___2;
-                    FStar_Syntax_Syntax.binder_qual =
-                      (b.FStar_Syntax_Syntax.binder_qual);
-                    FStar_Syntax_Syntax.binder_attrs =
-                      (b.FStar_Syntax_Syntax.binder_attrs)
-                  } in
-                let uu___2 = arg_of_non_null_binder b1 in (b1, uu___2)
-              else (let uu___3 = arg_of_non_null_binder b in (b, uu___3)))) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Compiler_List.unzip
-let (name_binders :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun binders ->
-    FStar_Compiler_Effect.op_Bar_Greater binders
-      (FStar_Compiler_List.mapi
-         (fun i ->
-            fun b ->
-              let uu___ = FStar_Syntax_Syntax.is_null_binder b in
-              if uu___
-              then
-                let bname =
-                  let uu___1 =
-                    let uu___2 = FStar_Compiler_Util.string_of_int i in
-                    Prims.op_Hat "_" uu___2 in
-                  FStar_Ident.id_of_text uu___1 in
-                let bv =
-                  {
-                    FStar_Syntax_Syntax.ppname = bname;
-                    FStar_Syntax_Syntax.index = Prims.int_zero;
-                    FStar_Syntax_Syntax.sort =
-                      ((b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)
-                  } in
-                {
-                  FStar_Syntax_Syntax.binder_bv = bv;
-                  FStar_Syntax_Syntax.binder_qual =
-                    (b.FStar_Syntax_Syntax.binder_qual);
-                  FStar_Syntax_Syntax.binder_attrs =
-                    (b.FStar_Syntax_Syntax.binder_attrs)
-                }
-              else b))
-let (name_function_binders :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_arrow (binders, comp) ->
-        let uu___ =
-          let uu___1 = let uu___2 = name_binders binders in (uu___2, comp) in
-          FStar_Syntax_Syntax.Tm_arrow uu___1 in
-        FStar_Syntax_Syntax.mk uu___ t.FStar_Syntax_Syntax.pos
-    | uu___ -> t
-let (null_binders_of_tks :
-  (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.bqual) Prims.list ->
-    FStar_Syntax_Syntax.binders)
-  =
-  fun tks ->
-    FStar_Compiler_Effect.op_Bar_Greater tks
-      (FStar_Compiler_List.map
-         (fun uu___ ->
-            match uu___ with
-            | (t, imp) ->
-                let uu___1 = FStar_Syntax_Syntax.null_binder t in
-                {
-                  FStar_Syntax_Syntax.binder_bv =
-                    (uu___1.FStar_Syntax_Syntax.binder_bv);
-                  FStar_Syntax_Syntax.binder_qual = imp;
-                  FStar_Syntax_Syntax.binder_attrs =
-                    (uu___1.FStar_Syntax_Syntax.binder_attrs)
-                }))
-let (binders_of_tks :
-  (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.bqual) Prims.list ->
-    FStar_Syntax_Syntax.binders)
-  =
-  fun tks ->
-    FStar_Compiler_Effect.op_Bar_Greater tks
-      (FStar_Compiler_List.map
-         (fun uu___ ->
-            match uu___ with
-            | (t, imp) ->
-                let uu___1 =
-                  FStar_Syntax_Syntax.new_bv
-                    (FStar_Pervasives_Native.Some (t.FStar_Syntax_Syntax.pos))
-                    t in
-                FStar_Syntax_Syntax.mk_binder_with_attrs uu___1 imp []))
-let (binders_of_freevars :
-  FStar_Syntax_Syntax.bv FStar_Compiler_Util.set ->
-    FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun fvs ->
-    let uu___ = FStar_Compiler_Util.set_elements fvs in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder)
-let mk_subst : 'uuuuu . 'uuuuu -> 'uuuuu Prims.list = fun s -> [s]
-let (subst_of_list :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.args -> FStar_Syntax_Syntax.subst_t)
-  =
-  fun formals ->
-    fun actuals ->
-      if
-        (FStar_Compiler_List.length formals) =
-          (FStar_Compiler_List.length actuals)
-      then
-        FStar_Compiler_List.fold_right2
-          (fun f ->
-             fun a ->
-               fun out ->
-                 (FStar_Syntax_Syntax.NT
-                    ((f.FStar_Syntax_Syntax.binder_bv),
-                      (FStar_Pervasives_Native.fst a)))
-                 :: out) formals actuals []
-      else failwith "Ill-formed substitution"
-let (rename_binders :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.subst_t)
-  =
-  fun replace_xs ->
-    fun with_ys ->
-      if
-        (FStar_Compiler_List.length replace_xs) =
-          (FStar_Compiler_List.length with_ys)
-      then
-        FStar_Compiler_List.map2
-          (fun x ->
-             fun y ->
-               let uu___ =
-                 let uu___1 =
-                   FStar_Syntax_Syntax.bv_to_name
-                     y.FStar_Syntax_Syntax.binder_bv in
-                 ((x.FStar_Syntax_Syntax.binder_bv), uu___1) in
-               FStar_Syntax_Syntax.NT uu___) replace_xs with_ys
-      else failwith "Ill-formed substitution"
-let rec (unmeta : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun e ->
-    let e1 = FStar_Syntax_Subst.compress e in
-    match e1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_meta (e2, uu___) -> unmeta e2
-    | FStar_Syntax_Syntax.Tm_ascribed (e2, uu___, uu___1) -> unmeta e2
-    | uu___ -> e1
-let rec (unmeta_safe : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun e ->
-    let e1 = FStar_Syntax_Subst.compress e in
-    match e1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_meta (e', m) ->
-        (match m with
-         | FStar_Syntax_Syntax.Meta_monadic uu___ -> e1
-         | FStar_Syntax_Syntax.Meta_monadic_lift uu___ -> e1
-         | uu___ -> unmeta_safe e')
-    | FStar_Syntax_Syntax.Tm_ascribed (e2, uu___, uu___1) -> unmeta_safe e2
-    | uu___ -> e1
-let (unmeta_lift : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_meta
-        (t1, FStar_Syntax_Syntax.Meta_monadic_lift uu___1) -> t1
-    | uu___1 -> t
-let rec (univ_kernel :
-  FStar_Syntax_Syntax.universe -> (FStar_Syntax_Syntax.universe * Prims.int))
-  =
-  fun u ->
-    match u with
-    | FStar_Syntax_Syntax.U_unknown -> (u, Prims.int_zero)
-    | FStar_Syntax_Syntax.U_name uu___ -> (u, Prims.int_zero)
-    | FStar_Syntax_Syntax.U_unif uu___ -> (u, Prims.int_zero)
-    | FStar_Syntax_Syntax.U_max uu___ -> (u, Prims.int_zero)
-    | FStar_Syntax_Syntax.U_zero -> (u, Prims.int_zero)
-    | FStar_Syntax_Syntax.U_succ u1 ->
-        let uu___ = univ_kernel u1 in
-        (match uu___ with | (k, n) -> (k, (n + Prims.int_one)))
-    | FStar_Syntax_Syntax.U_bvar uu___ ->
-        failwith "Imposible: univ_kernel (U_bvar _)"
-let (constant_univ_as_nat : FStar_Syntax_Syntax.universe -> Prims.int) =
-  fun u -> let uu___ = univ_kernel u in FStar_Pervasives_Native.snd uu___
-let rec (compare_univs :
-  FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe -> Prims.int)
-  =
-  fun u1 ->
-    fun u2 ->
-      let rec compare_kernel uk1 uk2 =
-        match (uk1, uk2) with
-        | (FStar_Syntax_Syntax.U_bvar uu___, uu___1) ->
-            failwith "Impossible: compare_kernel bvar"
-        | (uu___, FStar_Syntax_Syntax.U_bvar uu___1) ->
-            failwith "Impossible: compare_kernel bvar"
-        | (FStar_Syntax_Syntax.U_succ uu___, uu___1) ->
-            failwith "Impossible: compare_kernel succ"
-        | (uu___, FStar_Syntax_Syntax.U_succ uu___1) ->
-            failwith "Impossible: compare_kernel succ"
-        | (FStar_Syntax_Syntax.U_unknown, FStar_Syntax_Syntax.U_unknown) ->
-            Prims.int_zero
-        | (FStar_Syntax_Syntax.U_unknown, uu___) -> ~- Prims.int_one
-        | (uu___, FStar_Syntax_Syntax.U_unknown) -> Prims.int_one
-        | (FStar_Syntax_Syntax.U_zero, FStar_Syntax_Syntax.U_zero) ->
-            Prims.int_zero
-        | (FStar_Syntax_Syntax.U_zero, uu___) -> ~- Prims.int_one
-        | (uu___, FStar_Syntax_Syntax.U_zero) -> Prims.int_one
-        | (FStar_Syntax_Syntax.U_name u11, FStar_Syntax_Syntax.U_name u21) ->
-            let uu___ = FStar_Ident.string_of_id u11 in
-            let uu___1 = FStar_Ident.string_of_id u21 in
-            FStar_String.compare uu___ uu___1
-        | (FStar_Syntax_Syntax.U_name uu___, uu___1) -> ~- Prims.int_one
-        | (uu___, FStar_Syntax_Syntax.U_name uu___1) -> Prims.int_one
-        | (FStar_Syntax_Syntax.U_unif u11, FStar_Syntax_Syntax.U_unif u21) ->
-            let uu___ = FStar_Syntax_Unionfind.univ_uvar_id u11 in
-            let uu___1 = FStar_Syntax_Unionfind.univ_uvar_id u21 in
-            uu___ - uu___1
-        | (FStar_Syntax_Syntax.U_unif uu___, uu___1) -> ~- Prims.int_one
-        | (uu___, FStar_Syntax_Syntax.U_unif uu___1) -> Prims.int_one
-        | (FStar_Syntax_Syntax.U_max us1, FStar_Syntax_Syntax.U_max us2) ->
-            let n1 = FStar_Compiler_List.length us1 in
-            let n2 = FStar_Compiler_List.length us2 in
-            if n1 <> n2
-            then n1 - n2
-            else
-              (let copt =
-                 let uu___1 = FStar_Compiler_List.zip us1 us2 in
-                 FStar_Compiler_Util.find_map uu___1
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (u11, u21) ->
-                          let c = compare_univs u11 u21 in
-                          if c <> Prims.int_zero
-                          then FStar_Pervasives_Native.Some c
-                          else FStar_Pervasives_Native.None) in
-               match copt with
-               | FStar_Pervasives_Native.None -> Prims.int_zero
-               | FStar_Pervasives_Native.Some c -> c) in
-      let uu___ = univ_kernel u1 in
-      match uu___ with
-      | (uk1, n1) ->
-          let uu___1 = univ_kernel u2 in
-          (match uu___1 with
-           | (uk2, n2) ->
-               let uu___2 = compare_kernel uk1 uk2 in
-               (match uu___2 with
-                | uu___3 when uu___3 = Prims.int_zero -> n1 - n2
-                | n -> n))
-let (eq_univs :
-  FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe -> Prims.bool)
-  =
-  fun u1 ->
-    fun u2 -> let uu___ = compare_univs u1 u2 in uu___ = Prims.int_zero
-let (ml_comp :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Compiler_Range.range -> FStar_Syntax_Syntax.comp)
-  =
-  fun t ->
-    fun r ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Parser_Const.effect_ML_lid () in
-          FStar_Ident.set_lid_range uu___2 r in
-        {
-          FStar_Syntax_Syntax.comp_univs = [FStar_Syntax_Syntax.U_zero];
-          FStar_Syntax_Syntax.effect_name = uu___1;
-          FStar_Syntax_Syntax.result_typ = t;
-          FStar_Syntax_Syntax.effect_args = [];
-          FStar_Syntax_Syntax.flags = [FStar_Syntax_Syntax.MLEFFECT]
-        } in
-      FStar_Syntax_Syntax.mk_Comp uu___
-let (comp_effect_name :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> FStar_Ident.lident)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Comp c1 -> c1.FStar_Syntax_Syntax.effect_name
-    | FStar_Syntax_Syntax.Total uu___ -> FStar_Parser_Const.effect_Tot_lid
-    | FStar_Syntax_Syntax.GTotal uu___ -> FStar_Parser_Const.effect_GTot_lid
-let (comp_flags :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.cflag Prims.list)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total uu___ -> [FStar_Syntax_Syntax.TOTAL]
-    | FStar_Syntax_Syntax.GTotal uu___ -> [FStar_Syntax_Syntax.SOMETRIVIAL]
-    | FStar_Syntax_Syntax.Comp ct -> ct.FStar_Syntax_Syntax.flags
-let (comp_eff_name_res_and_args :
-  FStar_Syntax_Syntax.comp ->
-    (FStar_Ident.lident * FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.args))
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t ->
-        (FStar_Parser_Const.effect_Tot_lid, t, [])
-    | FStar_Syntax_Syntax.GTotal t ->
-        (FStar_Parser_Const.effect_GTot_lid, t, [])
-    | FStar_Syntax_Syntax.Comp c1 ->
-        ((c1.FStar_Syntax_Syntax.effect_name),
-          (c1.FStar_Syntax_Syntax.result_typ),
-          (c1.FStar_Syntax_Syntax.effect_args))
-let (effect_indices_from_repr :
-  FStar_Syntax_Syntax.term ->
-    Prims.bool ->
-      FStar_Compiler_Range.range ->
-        Prims.string -> FStar_Syntax_Syntax.term Prims.list)
-  =
-  fun repr ->
-    fun is_layered ->
-      fun r ->
-        fun err ->
-          let err1 uu___ =
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_UnexpectedEffect, err) r in
-          let repr1 = FStar_Syntax_Subst.compress repr in
-          if is_layered
-          then
-            match repr1.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Tm_app (uu___, uu___1::is) ->
-                FStar_Compiler_Effect.op_Bar_Greater is
-                  (FStar_Compiler_List.map FStar_Pervasives_Native.fst)
-            | uu___ -> err1 ()
-          else
-            (match repr1.FStar_Syntax_Syntax.n with
-             | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater c
-                     comp_eff_name_res_and_args in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___2
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (uu___4, uu___5, args) ->
-                          FStar_Compiler_Effect.op_Bar_Greater args
-                            (FStar_Compiler_List.map
-                               FStar_Pervasives_Native.fst))
-             | uu___1 -> err1 ())
-let (destruct_comp :
-  FStar_Syntax_Syntax.comp_typ ->
-    (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.typ *
-      FStar_Syntax_Syntax.typ))
-  =
-  fun c ->
-    let wp =
-      match c.FStar_Syntax_Syntax.effect_args with
-      | (wp1, uu___)::[] -> wp1
-      | uu___ ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Ident.string_of_lid c.FStar_Syntax_Syntax.effect_name in
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_Effect.op_Bar_Greater
-                  c.FStar_Syntax_Syntax.effect_args
-                  FStar_Compiler_List.length in
-              FStar_Compiler_Effect.op_Bar_Greater uu___4
-                FStar_Compiler_Util.string_of_int in
-            FStar_Compiler_Util.format2
-              "Impossible: Got a computation %s with %s effect args" uu___2
-              uu___3 in
-          failwith uu___1 in
-    let uu___ = FStar_Compiler_List.hd c.FStar_Syntax_Syntax.comp_univs in
-    (uu___, (c.FStar_Syntax_Syntax.result_typ), wp)
-let (is_named_tot :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Comp c1 ->
-        FStar_Ident.lid_equals c1.FStar_Syntax_Syntax.effect_name
-          FStar_Parser_Const.effect_Tot_lid
-    | FStar_Syntax_Syntax.Total uu___ -> true
-    | FStar_Syntax_Syntax.GTotal uu___ -> false
-let (is_total_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    (FStar_Ident.lid_equals (comp_effect_name c)
-       FStar_Parser_Const.effect_Tot_lid)
-      ||
-      (FStar_Compiler_Effect.op_Bar_Greater (comp_flags c)
-         (FStar_Compiler_Util.for_some
-            (fun uu___ ->
-               match uu___ with
-               | FStar_Syntax_Syntax.TOTAL -> true
-               | FStar_Syntax_Syntax.RETURN -> true
-               | uu___1 -> false)))
-let (is_partial_return :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    FStar_Compiler_Effect.op_Bar_Greater (comp_flags c)
-      (FStar_Compiler_Util.for_some
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.RETURN -> true
-            | FStar_Syntax_Syntax.PARTIAL_RETURN -> true
-            | uu___1 -> false))
-let (is_tot_or_gtot_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    (is_total_comp c) ||
-      (FStar_Ident.lid_equals FStar_Parser_Const.effect_GTot_lid
-         (comp_effect_name c))
-let (is_pure_effect : FStar_Ident.lident -> Prims.bool) =
-  fun l ->
-    ((FStar_Ident.lid_equals l FStar_Parser_Const.effect_Tot_lid) ||
-       (FStar_Ident.lid_equals l FStar_Parser_Const.effect_PURE_lid))
-      || (FStar_Ident.lid_equals l FStar_Parser_Const.effect_Pure_lid)
-let (is_pure_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total uu___ -> true
-    | FStar_Syntax_Syntax.GTotal uu___ -> false
-    | FStar_Syntax_Syntax.Comp ct ->
-        ((is_total_comp c) ||
-           (is_pure_effect ct.FStar_Syntax_Syntax.effect_name))
-          ||
-          (FStar_Compiler_Effect.op_Bar_Greater ct.FStar_Syntax_Syntax.flags
-             (FStar_Compiler_Util.for_some
-                (fun uu___ ->
-                   match uu___ with
-                   | FStar_Syntax_Syntax.LEMMA -> true
-                   | uu___1 -> false)))
-let (is_ghost_effect : FStar_Ident.lident -> Prims.bool) =
-  fun l ->
-    ((FStar_Ident.lid_equals FStar_Parser_Const.effect_GTot_lid l) ||
-       (FStar_Ident.lid_equals FStar_Parser_Const.effect_GHOST_lid l))
-      || (FStar_Ident.lid_equals FStar_Parser_Const.effect_Ghost_lid l)
-let (is_div_effect : FStar_Ident.lident -> Prims.bool) =
-  fun l ->
-    ((FStar_Ident.lid_equals l FStar_Parser_Const.effect_DIV_lid) ||
-       (FStar_Ident.lid_equals l FStar_Parser_Const.effect_Div_lid))
-      || (FStar_Ident.lid_equals l FStar_Parser_Const.effect_Dv_lid)
-let (is_pure_or_ghost_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c -> (is_pure_comp c) || (is_ghost_effect (comp_effect_name c))
-let (is_pure_or_ghost_effect : FStar_Ident.lident -> Prims.bool) =
-  fun l -> (is_pure_effect l) || (is_ghost_effect l)
-let (is_pure_or_ghost_function : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) -> is_pure_or_ghost_comp c
-    | uu___1 -> true
-let (is_lemma_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Comp ct ->
-        FStar_Ident.lid_equals ct.FStar_Syntax_Syntax.effect_name
-          FStar_Parser_Const.effect_Lemma_lid
-    | uu___ -> false
-let (is_lemma : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) -> is_lemma_comp c
-    | uu___1 -> false
-let rec (head_of : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_app (t1, uu___1) -> head_of t1
-    | FStar_Syntax_Syntax.Tm_match (t1, uu___1, uu___2, uu___3) -> head_of t1
-    | FStar_Syntax_Syntax.Tm_abs (uu___1, t1, uu___2) -> head_of t1
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, uu___1, uu___2) -> head_of t1
-    | FStar_Syntax_Syntax.Tm_meta (t1, uu___1) -> head_of t1
-    | uu___1 -> t
-let (head_and_args :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-      Prims.list))
-  =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_app (head, args) -> (head, args)
-    | uu___ -> (t1, [])
-let rec (head_and_args_full :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax * FStar_Syntax_Syntax.arg_qualifier
-      FStar_Pervasives_Native.option) Prims.list))
-  =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_app (head, args) ->
-        let uu___ = head_and_args_full head in
-        (match uu___ with
-         | (head1, args') -> (head1, (FStar_Compiler_List.op_At args' args)))
-    | uu___ -> (t1, [])
-let rec (leftmost_head :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_app (t0, uu___) -> leftmost_head t0
-    | FStar_Syntax_Syntax.Tm_meta
-        (t0, FStar_Syntax_Syntax.Meta_pattern uu___) -> leftmost_head t0
-    | FStar_Syntax_Syntax.Tm_meta (t0, FStar_Syntax_Syntax.Meta_named uu___)
-        -> leftmost_head t0
-    | FStar_Syntax_Syntax.Tm_meta
-        (t0, FStar_Syntax_Syntax.Meta_labeled uu___) -> leftmost_head t0
-    | FStar_Syntax_Syntax.Tm_meta
-        (t0, FStar_Syntax_Syntax.Meta_desugared uu___) -> leftmost_head t0
-    | FStar_Syntax_Syntax.Tm_ascribed (t0, uu___, uu___1) -> leftmost_head t0
-    | uu___ -> t1
-let (leftmost_head_and_args :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax * FStar_Syntax_Syntax.arg_qualifier
-      FStar_Pervasives_Native.option) Prims.list))
-  =
-  fun t ->
-    let rec aux t1 args =
-      let t2 = FStar_Syntax_Subst.compress t1 in
-      match t2.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_app (t0, args') ->
-          aux t0 (FStar_Compiler_List.op_At args' args)
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_pattern uu___) -> aux t0 args
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_named uu___) -> aux t0 args
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_labeled uu___) -> aux t0 args
-      | FStar_Syntax_Syntax.Tm_meta
-          (t0, FStar_Syntax_Syntax.Meta_desugared uu___) -> aux t0 args
-      | FStar_Syntax_Syntax.Tm_ascribed (t0, uu___, uu___1) -> aux t0 args
-      | uu___ -> (t2, args) in
-    aux t []
-let (un_uinst : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_uinst (t2, uu___) ->
-        FStar_Syntax_Subst.compress t2
-    | uu___ -> t1
-let (is_ml_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Comp c1 ->
-        (let uu___ = FStar_Parser_Const.effect_ML_lid () in
-         FStar_Ident.lid_equals c1.FStar_Syntax_Syntax.effect_name uu___) ||
-          (FStar_Compiler_Effect.op_Bar_Greater c1.FStar_Syntax_Syntax.flags
-             (FStar_Compiler_Util.for_some
-                (fun uu___ ->
-                   match uu___ with
-                   | FStar_Syntax_Syntax.MLEFFECT -> true
-                   | uu___1 -> false)))
-    | uu___ -> false
-let (comp_result :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t -> t
-    | FStar_Syntax_Syntax.GTotal t -> t
-    | FStar_Syntax_Syntax.Comp ct -> ct.FStar_Syntax_Syntax.result_typ
-let (set_result_typ :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.comp)
-  =
-  fun c ->
-    fun t ->
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Total uu___ -> FStar_Syntax_Syntax.mk_Total t
-      | FStar_Syntax_Syntax.GTotal uu___ -> FStar_Syntax_Syntax.mk_GTotal t
-      | FStar_Syntax_Syntax.Comp ct ->
-          FStar_Syntax_Syntax.mk_Comp
-            {
-              FStar_Syntax_Syntax.comp_univs =
-                (ct.FStar_Syntax_Syntax.comp_univs);
-              FStar_Syntax_Syntax.effect_name =
-                (ct.FStar_Syntax_Syntax.effect_name);
-              FStar_Syntax_Syntax.result_typ = t;
-              FStar_Syntax_Syntax.effect_args =
-                (ct.FStar_Syntax_Syntax.effect_args);
-              FStar_Syntax_Syntax.flags = (ct.FStar_Syntax_Syntax.flags)
-            }
-let (is_trivial_wp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    FStar_Compiler_Effect.op_Bar_Greater (comp_flags c)
-      (FStar_Compiler_Util.for_some
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.TOTAL -> true
-            | FStar_Syntax_Syntax.RETURN -> true
-            | uu___1 -> false))
-let (comp_effect_args : FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.args)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total uu___ -> []
-    | FStar_Syntax_Syntax.GTotal uu___ -> []
-    | FStar_Syntax_Syntax.Comp ct -> ct.FStar_Syntax_Syntax.effect_args
-let (primops : FStar_Ident.lident Prims.list) =
-  [FStar_Parser_Const.op_Eq;
-  FStar_Parser_Const.op_notEq;
-  FStar_Parser_Const.op_LT;
-  FStar_Parser_Const.op_LTE;
-  FStar_Parser_Const.op_GT;
-  FStar_Parser_Const.op_GTE;
-  FStar_Parser_Const.op_Subtraction;
-  FStar_Parser_Const.op_Minus;
-  FStar_Parser_Const.op_Addition;
-  FStar_Parser_Const.op_Multiply;
-  FStar_Parser_Const.op_Division;
-  FStar_Parser_Const.op_Modulus;
-  FStar_Parser_Const.op_And;
-  FStar_Parser_Const.op_Or;
-  FStar_Parser_Const.op_Negation]
-let (is_primop_lid : FStar_Ident.lident -> Prims.bool) =
-  fun l ->
-    FStar_Compiler_Effect.op_Bar_Greater primops
-      (FStar_Compiler_Util.for_some (FStar_Ident.lid_equals l))
-let (is_primop :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun f ->
-    match f.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        is_primop_lid (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-    | uu___ -> false
-let rec (unascribe : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun e ->
-    let e1 = FStar_Syntax_Subst.compress e in
-    match e1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_ascribed (e2, uu___, uu___1) -> unascribe e2
-    | uu___ -> e1
-let rec (ascribe :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-      FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-      -> FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    fun k ->
-      match t.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_ascribed (t', uu___, uu___1) -> ascribe t' k
-      | uu___ ->
-          FStar_Syntax_Syntax.mk
-            (FStar_Syntax_Syntax.Tm_ascribed
-               (t, k, FStar_Pervasives_Native.None))
-            t.FStar_Syntax_Syntax.pos
-let (unfold_lazy : FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term)
-  =
-  fun i ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bang FStar_Syntax_Syntax.lazy_chooser in
-      FStar_Compiler_Util.must uu___1 in
-    uu___ i.FStar_Syntax_Syntax.lkind i
-let rec (unlazy : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy i ->
-        let uu___1 = unfold_lazy i in
-        FStar_Compiler_Effect.op_Less_Bar unlazy uu___1
-    | uu___1 -> t
-let (unlazy_emb : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy i ->
-        (match i.FStar_Syntax_Syntax.lkind with
-         | FStar_Syntax_Syntax.Lazy_embedding uu___1 ->
-             let uu___2 = unfold_lazy i in
-             FStar_Compiler_Effect.op_Less_Bar unlazy uu___2
-         | uu___1 -> t)
-    | uu___1 -> t
-let (eq_lazy_kind :
-  FStar_Syntax_Syntax.lazy_kind ->
-    FStar_Syntax_Syntax.lazy_kind -> Prims.bool)
-  =
-  fun k ->
-    fun k' ->
-      match (k, k') with
-      | (FStar_Syntax_Syntax.BadLazy, FStar_Syntax_Syntax.BadLazy) -> true
-      | (FStar_Syntax_Syntax.Lazy_bv, FStar_Syntax_Syntax.Lazy_bv) -> true
-      | (FStar_Syntax_Syntax.Lazy_binder, FStar_Syntax_Syntax.Lazy_binder) ->
-          true
-      | (FStar_Syntax_Syntax.Lazy_optionstate,
-         FStar_Syntax_Syntax.Lazy_optionstate) -> true
-      | (FStar_Syntax_Syntax.Lazy_fvar, FStar_Syntax_Syntax.Lazy_fvar) ->
-          true
-      | (FStar_Syntax_Syntax.Lazy_comp, FStar_Syntax_Syntax.Lazy_comp) ->
-          true
-      | (FStar_Syntax_Syntax.Lazy_env, FStar_Syntax_Syntax.Lazy_env) -> true
-      | (FStar_Syntax_Syntax.Lazy_proofstate,
-         FStar_Syntax_Syntax.Lazy_proofstate) -> true
-      | (FStar_Syntax_Syntax.Lazy_goal, FStar_Syntax_Syntax.Lazy_goal) ->
-          true
-      | (FStar_Syntax_Syntax.Lazy_sigelt, FStar_Syntax_Syntax.Lazy_sigelt) ->
-          true
-      | (FStar_Syntax_Syntax.Lazy_letbinding,
-         FStar_Syntax_Syntax.Lazy_letbinding) -> true
-      | (FStar_Syntax_Syntax.Lazy_uvar, FStar_Syntax_Syntax.Lazy_uvar) ->
-          true
-      | uu___ -> false
-let unlazy_as_t :
-  'uuuuu .
-    FStar_Syntax_Syntax.lazy_kind -> FStar_Syntax_Syntax.term -> 'uuuuu
-  =
-  fun k ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_lazy
-          { FStar_Syntax_Syntax.blob = v; FStar_Syntax_Syntax.lkind = k';
-            FStar_Syntax_Syntax.ltyp = uu___1;
-            FStar_Syntax_Syntax.rng = uu___2;_}
-          when eq_lazy_kind k k' -> FStar_Compiler_Dyn.undyn v
-      | uu___1 -> failwith "Not a Tm_lazy of the expected kind"
-let mk_lazy :
-  'a .
-    'a ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.lazy_kind ->
-          FStar_Compiler_Range.range FStar_Pervasives_Native.option ->
-            FStar_Syntax_Syntax.term
-  =
-  fun t ->
-    fun typ ->
-      fun k ->
-        fun r ->
-          let rng =
-            match r with
-            | FStar_Pervasives_Native.Some r1 -> r1
-            | FStar_Pervasives_Native.None -> FStar_Compiler_Range.dummyRange in
-          let i =
-            let uu___ = FStar_Compiler_Dyn.mkdyn t in
-            {
-              FStar_Syntax_Syntax.blob = uu___;
-              FStar_Syntax_Syntax.lkind = k;
-              FStar_Syntax_Syntax.ltyp = typ;
-              FStar_Syntax_Syntax.rng = rng
-            } in
-          FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_lazy i) rng
-let (canon_app :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term)
-  =
-  fun t ->
-    let uu___ = let uu___1 = unascribe t in head_and_args_full uu___1 in
-    match uu___ with
-    | (hd, args) ->
-        FStar_Syntax_Syntax.mk_Tm_app hd args t.FStar_Syntax_Syntax.pos
-type eq_result =
-  | Equal 
-  | NotEqual 
-  | Unknown 
-let (uu___is_Equal : eq_result -> Prims.bool) =
-  fun projectee -> match projectee with | Equal -> true | uu___ -> false
-let (uu___is_NotEqual : eq_result -> Prims.bool) =
-  fun projectee -> match projectee with | NotEqual -> true | uu___ -> false
-let (uu___is_Unknown : eq_result -> Prims.bool) =
-  fun projectee -> match projectee with | Unknown -> true | uu___ -> false
-let (injectives : Prims.string Prims.list) =
-  ["FStar.Int8.int_to_t";
-  "FStar.Int16.int_to_t";
-  "FStar.Int32.int_to_t";
-  "FStar.Int64.int_to_t";
-  "FStar.UInt8.uint_to_t";
-  "FStar.UInt16.uint_to_t";
-  "FStar.UInt32.uint_to_t";
-  "FStar.UInt64.uint_to_t";
-  "FStar.Int8.__int_to_t";
-  "FStar.Int16.__int_to_t";
-  "FStar.Int32.__int_to_t";
-  "FStar.Int64.__int_to_t";
-  "FStar.UInt8.__uint_to_t";
-  "FStar.UInt16.__uint_to_t";
-  "FStar.UInt32.__uint_to_t";
-  "FStar.UInt64.__uint_to_t"]
-let (eq_inj : eq_result -> eq_result -> eq_result) =
-  fun r ->
-    fun s ->
-      match (r, s) with
-      | (Equal, Equal) -> Equal
-      | (NotEqual, uu___) -> NotEqual
-      | (uu___, NotEqual) -> NotEqual
-      | (uu___, uu___1) -> Unknown
-let (equal_if : Prims.bool -> eq_result) =
-  fun uu___ -> if uu___ then Equal else Unknown
-let (equal_iff : Prims.bool -> eq_result) =
-  fun uu___ -> if uu___ then Equal else NotEqual
-let (eq_and : eq_result -> (unit -> eq_result) -> eq_result) =
-  fun r ->
-    fun s ->
-      let uu___ = (r = Equal) && (let uu___1 = s () in uu___1 = Equal) in
-      if uu___ then Equal else Unknown
-let rec (eq_tm :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> eq_result) =
-  fun t1 ->
-    fun t2 ->
-      let t11 = canon_app t1 in
-      let t21 = canon_app t2 in
-      let equal_data f1 args1 f2 args2 =
-        let uu___ = FStar_Syntax_Syntax.fv_eq f1 f2 in
-        if uu___
-        then
-          let uu___2 = FStar_Compiler_List.zip args1 args2 in
-          FStar_Compiler_Effect.op_Less_Bar
-            (FStar_Compiler_List.fold_left
-               (fun acc ->
-                  fun uu___3 ->
-                    match uu___3 with
-                    | ((a1, q1), (a2, q2)) ->
-                        let uu___4 = eq_tm a1 a2 in eq_inj acc uu___4) Equal)
-            uu___2
-        else NotEqual in
-      let qual_is_inj uu___ =
-        match uu___ with
-        | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Data_ctor) ->
-            true
-        | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-            uu___1) -> true
-        | uu___1 -> false in
-      let heads_and_args_in_case_both_data =
-        let uu___ =
-          let uu___1 = FStar_Compiler_Effect.op_Bar_Greater t11 unmeta in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1 head_and_args in
-        match uu___ with
-        | (head1, args1) ->
-            let uu___1 =
-              let uu___2 = FStar_Compiler_Effect.op_Bar_Greater t21 unmeta in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2 head_and_args in
-            (match uu___1 with
-             | (head2, args2) ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = un_uinst head1 in
-                     uu___4.FStar_Syntax_Syntax.n in
-                   let uu___4 =
-                     let uu___5 = un_uinst head2 in
-                     uu___5.FStar_Syntax_Syntax.n in
-                   (uu___3, uu___4) in
-                 (match uu___2 with
-                  | (FStar_Syntax_Syntax.Tm_fvar f,
-                     FStar_Syntax_Syntax.Tm_fvar g) when
-                      (qual_is_inj f.FStar_Syntax_Syntax.fv_qual) &&
-                        (qual_is_inj g.FStar_Syntax_Syntax.fv_qual)
-                      -> FStar_Pervasives_Native.Some (f, args1, g, args2)
-                  | uu___3 -> FStar_Pervasives_Native.None)) in
-      let t12 = unmeta t11 in
-      let t22 = unmeta t21 in
-      match ((t12.FStar_Syntax_Syntax.n), (t22.FStar_Syntax_Syntax.n)) with
-      | (FStar_Syntax_Syntax.Tm_bvar bv1, FStar_Syntax_Syntax.Tm_bvar bv2) ->
-          equal_if
-            (bv1.FStar_Syntax_Syntax.index = bv2.FStar_Syntax_Syntax.index)
-      | (FStar_Syntax_Syntax.Tm_lazy uu___, uu___1) ->
-          let uu___2 = unlazy t12 in eq_tm uu___2 t22
-      | (uu___, FStar_Syntax_Syntax.Tm_lazy uu___1) ->
-          let uu___2 = unlazy t22 in eq_tm t12 uu___2
-      | (FStar_Syntax_Syntax.Tm_name a, FStar_Syntax_Syntax.Tm_name b) ->
-          let uu___ = FStar_Syntax_Syntax.bv_eq a b in equal_if uu___
-      | uu___ when
-          FStar_Compiler_Effect.op_Bar_Greater
-            heads_and_args_in_case_both_data FStar_Compiler_Util.is_some
-          ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              heads_and_args_in_case_both_data FStar_Compiler_Util.must in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (fun uu___2 ->
-               match uu___2 with
-               | (f, args1, g, args2) -> equal_data f args1 g args2)
-      | (FStar_Syntax_Syntax.Tm_fvar f, FStar_Syntax_Syntax.Tm_fvar g) ->
-          let uu___ = FStar_Syntax_Syntax.fv_eq f g in equal_if uu___
-      | (FStar_Syntax_Syntax.Tm_uinst (f, us), FStar_Syntax_Syntax.Tm_uinst
-         (g, vs)) ->
-          let uu___ = eq_tm f g in
-          eq_and uu___
-            (fun uu___1 ->
-               let uu___2 = eq_univs_list us vs in equal_if uu___2)
-      | (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_range uu___),
-         FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_range uu___1)) ->
-          Unknown
-      | (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_real r1),
-         FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_real r2)) ->
-          equal_if (r1 = r2)
-      | (FStar_Syntax_Syntax.Tm_constant c, FStar_Syntax_Syntax.Tm_constant
-         d) -> let uu___ = FStar_Const.eq_const c d in equal_iff uu___
-      | (FStar_Syntax_Syntax.Tm_uvar (u1, ([], uu___)),
-         FStar_Syntax_Syntax.Tm_uvar (u2, ([], uu___1))) ->
-          let uu___2 =
-            FStar_Syntax_Unionfind.equiv u1.FStar_Syntax_Syntax.ctx_uvar_head
-              u2.FStar_Syntax_Syntax.ctx_uvar_head in
-          equal_if uu___2
-      | (FStar_Syntax_Syntax.Tm_app (h1, args1), FStar_Syntax_Syntax.Tm_app
-         (h2, args2)) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = un_uinst h1 in uu___2.FStar_Syntax_Syntax.n in
-            let uu___2 =
-              let uu___3 = un_uinst h2 in uu___3.FStar_Syntax_Syntax.n in
-            (uu___1, uu___2) in
-          (match uu___ with
-           | (FStar_Syntax_Syntax.Tm_fvar f1, FStar_Syntax_Syntax.Tm_fvar f2)
-               when
-               (FStar_Syntax_Syntax.fv_eq f1 f2) &&
-                 (let uu___1 =
-                    let uu___2 = FStar_Syntax_Syntax.lid_of_fv f1 in
-                    FStar_Ident.string_of_lid uu___2 in
-                  FStar_Compiler_List.mem uu___1 injectives)
-               -> equal_data f1 args1 f2 args2
-           | uu___1 ->
-               let uu___2 = eq_tm h1 h2 in
-               eq_and uu___2 (fun uu___3 -> eq_args args1 args2))
-      | (FStar_Syntax_Syntax.Tm_match (t13, uu___, bs1, uu___1),
-         FStar_Syntax_Syntax.Tm_match (t23, uu___2, bs2, uu___3)) ->
-          if
-            (FStar_Compiler_List.length bs1) =
-              (FStar_Compiler_List.length bs2)
-          then
-            let uu___4 = FStar_Compiler_List.zip bs1 bs2 in
-            let uu___5 = eq_tm t13 t23 in
-            FStar_Compiler_List.fold_right
-              (fun uu___6 ->
-                 fun a ->
-                   match uu___6 with
-                   | (b1, b2) ->
-                       eq_and a (fun uu___7 -> branch_matches b1 b2)) uu___4
-              uu___5
-          else Unknown
-      | (FStar_Syntax_Syntax.Tm_type u, FStar_Syntax_Syntax.Tm_type v) ->
-          let uu___ = eq_univs u v in equal_if uu___
-      | (FStar_Syntax_Syntax.Tm_quoted (t13, q1),
-         FStar_Syntax_Syntax.Tm_quoted (t23, q2)) -> Unknown
-      | (FStar_Syntax_Syntax.Tm_refine (t13, phi1),
-         FStar_Syntax_Syntax.Tm_refine (t23, phi2)) ->
-          let uu___ =
-            eq_tm t13.FStar_Syntax_Syntax.sort t23.FStar_Syntax_Syntax.sort in
-          eq_and uu___ (fun uu___1 -> eq_tm phi1 phi2)
-      | (FStar_Syntax_Syntax.Tm_abs (bs1, body1, _rc1),
-         FStar_Syntax_Syntax.Tm_abs (bs2, body2, _rc2)) when
-          (FStar_Compiler_List.length bs1) = (FStar_Compiler_List.length bs2)
-          ->
-          let uu___ =
-            FStar_Compiler_List.fold_left2
-              (fun r ->
-                 fun b1 ->
-                   fun b2 ->
-                     eq_and r
-                       (fun uu___1 ->
-                          eq_tm
-                            (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                            (b2.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort))
-              Equal bs1 bs2 in
-          eq_and uu___ (fun uu___1 -> eq_tm body1 body2)
-      | (FStar_Syntax_Syntax.Tm_arrow (bs1, c1), FStar_Syntax_Syntax.Tm_arrow
-         (bs2, c2)) when
-          (FStar_Compiler_List.length bs1) = (FStar_Compiler_List.length bs2)
-          ->
-          let uu___ =
-            FStar_Compiler_List.fold_left2
-              (fun r ->
-                 fun b1 ->
-                   fun b2 ->
-                     eq_and r
-                       (fun uu___1 ->
-                          eq_tm
-                            (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                            (b2.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort))
-              Equal bs1 bs2 in
-          eq_and uu___ (fun uu___1 -> eq_comp c1 c2)
-      | uu___ -> Unknown
-and (eq_antiquotes :
-  (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term) Prims.list ->
-    (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term) Prims.list ->
-      eq_result)
-  =
-  fun a1 ->
-    fun a2 ->
-      match (a1, a2) with
-      | ([], []) -> Equal
-      | ([], uu___) -> NotEqual
-      | (uu___, []) -> NotEqual
-      | ((x1, t1)::a11, (x2, t2)::a21) ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.bv_eq x1 x2 in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then NotEqual
-          else
-            (let uu___2 = eq_tm t1 t2 in
-             match uu___2 with
-             | NotEqual -> NotEqual
-             | Unknown ->
-                 let uu___3 = eq_antiquotes a11 a21 in
-                 (match uu___3 with
-                  | NotEqual -> NotEqual
-                  | uu___4 -> Unknown)
-             | Equal -> eq_antiquotes a11 a21)
-and (branch_matches :
-  (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-    FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) ->
-    (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax) -> eq_result)
-  =
-  fun b1 ->
-    fun b2 ->
-      let related_by f o1 o2 =
-        match (o1, o2) with
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-            true
-        | (FStar_Pervasives_Native.Some x, FStar_Pervasives_Native.Some y) ->
-            f x y
-        | (uu___, uu___1) -> false in
-      let uu___ = b1 in
-      match uu___ with
-      | (p1, w1, t1) ->
-          let uu___1 = b2 in
-          (match uu___1 with
-           | (p2, w2, t2) ->
-               let uu___2 = FStar_Syntax_Syntax.eq_pat p1 p2 in
-               if uu___2
-               then
-                 let uu___3 =
-                   (let uu___4 = eq_tm t1 t2 in uu___4 = Equal) &&
-                     (related_by
-                        (fun t11 ->
-                           fun t21 ->
-                             let uu___4 = eq_tm t11 t21 in uu___4 = Equal) w1
-                        w2) in
-                 (if uu___3 then Equal else Unknown)
-               else Unknown)
-and (eq_args :
-  FStar_Syntax_Syntax.args -> FStar_Syntax_Syntax.args -> eq_result) =
-  fun a1 ->
-    fun a2 ->
-      match (a1, a2) with
-      | ([], []) -> Equal
-      | ((a, uu___)::a11, (b, uu___1)::b1) ->
-          let uu___2 = eq_tm a b in
-          (match uu___2 with | Equal -> eq_args a11 b1 | uu___3 -> Unknown)
-      | uu___ -> Unknown
-and (eq_univs_list :
-  FStar_Syntax_Syntax.universes ->
-    FStar_Syntax_Syntax.universes -> Prims.bool)
-  =
-  fun us ->
-    fun vs ->
-      ((FStar_Compiler_List.length us) = (FStar_Compiler_List.length vs)) &&
-        (FStar_Compiler_List.forall2 eq_univs us vs)
-and (eq_comp :
-  FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp -> eq_result) =
-  fun c1 ->
-    fun c2 ->
-      match ((c1.FStar_Syntax_Syntax.n), (c2.FStar_Syntax_Syntax.n)) with
-      | (FStar_Syntax_Syntax.Total t1, FStar_Syntax_Syntax.Total t2) ->
-          eq_tm t1 t2
-      | (FStar_Syntax_Syntax.GTotal t1, FStar_Syntax_Syntax.GTotal t2) ->
-          eq_tm t1 t2
-      | (FStar_Syntax_Syntax.Comp ct1, FStar_Syntax_Syntax.Comp ct2) ->
-          let uu___ =
-            let uu___1 =
-              eq_univs_list ct1.FStar_Syntax_Syntax.comp_univs
-                ct2.FStar_Syntax_Syntax.comp_univs in
-            equal_if uu___1 in
-          eq_and uu___
-            (fun uu___1 ->
-               let uu___2 =
-                 let uu___3 =
-                   FStar_Ident.lid_equals ct1.FStar_Syntax_Syntax.effect_name
-                     ct2.FStar_Syntax_Syntax.effect_name in
-                 equal_if uu___3 in
-               eq_and uu___2
-                 (fun uu___3 ->
-                    let uu___4 =
-                      eq_tm ct1.FStar_Syntax_Syntax.result_typ
-                        ct2.FStar_Syntax_Syntax.result_typ in
-                    eq_and uu___4
-                      (fun uu___5 ->
-                         eq_args ct1.FStar_Syntax_Syntax.effect_args
-                           ct2.FStar_Syntax_Syntax.effect_args)))
-      | uu___ -> NotEqual
-let (eq_quoteinfo :
-  FStar_Syntax_Syntax.quoteinfo -> FStar_Syntax_Syntax.quoteinfo -> eq_result)
-  =
-  fun q1 ->
-    fun q2 ->
-      if q1.FStar_Syntax_Syntax.qkind <> q2.FStar_Syntax_Syntax.qkind
-      then NotEqual
-      else
-        eq_antiquotes q1.FStar_Syntax_Syntax.antiquotes
-          q2.FStar_Syntax_Syntax.antiquotes
-let (eq_bqual :
-  FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-      eq_result)
-  =
-  fun a1 ->
-    fun a2 ->
-      match (a1, a2) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) -> Equal
-      | (FStar_Pervasives_Native.None, uu___) -> NotEqual
-      | (uu___, FStar_Pervasives_Native.None) -> NotEqual
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit b1),
-         FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit b2)) when
-          b1 = b2 -> Equal
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t1),
-         FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t2)) ->
-          eq_tm t1 t2
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality),
-         FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality)) ->
-          Equal
-      | uu___ -> NotEqual
-let (eq_aqual :
-  FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option ->
-      eq_result)
-  =
-  fun a1 ->
-    fun a2 ->
-      match (a1, a2) with
-      | (FStar_Pervasives_Native.Some a11, FStar_Pervasives_Native.Some a21)
-          ->
-          if
-            (a11.FStar_Syntax_Syntax.aqual_implicit =
-               a21.FStar_Syntax_Syntax.aqual_implicit)
-              &&
-              ((FStar_Compiler_List.length
-                  a11.FStar_Syntax_Syntax.aqual_attributes)
-                 =
-                 (FStar_Compiler_List.length
-                    a21.FStar_Syntax_Syntax.aqual_attributes))
-          then
-            FStar_Compiler_List.fold_left2
-              (fun out ->
-                 fun t1 ->
-                   fun t2 ->
-                     match out with
-                     | NotEqual -> out
-                     | Unknown ->
-                         let uu___ = eq_tm t1 t2 in
-                         (match uu___ with
-                          | NotEqual -> NotEqual
-                          | uu___1 -> Unknown)
-                     | Equal -> eq_tm t1 t2) Equal
-              a11.FStar_Syntax_Syntax.aqual_attributes
-              a21.FStar_Syntax_Syntax.aqual_attributes
-          else NotEqual
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) -> Equal
-      | uu___ -> NotEqual
-let rec (unrefine : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_refine (x, uu___) ->
-        unrefine x.FStar_Syntax_Syntax.sort
-    | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___, uu___1) -> unrefine t2
-    | uu___ -> t1
-let rec (is_uvar : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_uvar uu___1 -> true
-    | FStar_Syntax_Syntax.Tm_uinst (t1, uu___1) -> is_uvar t1
-    | FStar_Syntax_Syntax.Tm_app uu___1 ->
-        let uu___2 =
-          let uu___3 = FStar_Compiler_Effect.op_Bar_Greater t head_and_args in
-          FStar_Compiler_Effect.op_Bar_Greater uu___3
-            FStar_Pervasives_Native.fst in
-        FStar_Compiler_Effect.op_Bar_Greater uu___2 is_uvar
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, uu___1, uu___2) -> is_uvar t1
-    | uu___1 -> false
-let rec (is_unit : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = let uu___1 = unrefine t in uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        ((FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.unit_lid) ||
-           (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.squash_lid))
-          ||
-          (FStar_Syntax_Syntax.fv_eq_lid fv
-             FStar_Parser_Const.auto_squash_lid)
-    | FStar_Syntax_Syntax.Tm_app (head, uu___1) -> is_unit head
-    | FStar_Syntax_Syntax.Tm_uinst (t1, uu___1) -> is_unit t1
-    | uu___1 -> false
-let (is_eqtype_no_unrefine : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.eqtype_lid
-    | uu___1 -> false
-let (is_fun : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun e ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress e in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_abs uu___1 -> true
-    | uu___1 -> false
-let (is_function_typ : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow uu___1 -> true
-    | uu___1 -> false
-let rec (pre_typ : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_refine (x, uu___) ->
-        pre_typ x.FStar_Syntax_Syntax.sort
-    | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___, uu___1) -> pre_typ t2
-    | uu___ -> t1
-let (destruct :
-  FStar_Syntax_Syntax.term ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list FStar_Pervasives_Native.option)
-  =
-  fun typ ->
-    fun lid ->
-      let typ1 = FStar_Syntax_Subst.compress typ in
-      let uu___ = let uu___1 = un_uinst typ1 in uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_app (head, args) ->
-          let head1 = un_uinst head in
-          (match head1.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_fvar tc when
-               FStar_Syntax_Syntax.fv_eq_lid tc lid ->
-               FStar_Pervasives_Native.Some args
-           | uu___1 -> FStar_Pervasives_Native.None)
-      | FStar_Syntax_Syntax.Tm_fvar tc when
-          FStar_Syntax_Syntax.fv_eq_lid tc lid ->
-          FStar_Pervasives_Native.Some []
-      | uu___1 -> FStar_Pervasives_Native.None
-let (lids_of_sigelt :
-  FStar_Syntax_Syntax.sigelt -> FStar_Ident.lident Prims.list) =
-  fun se ->
-    match se.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_let (uu___, lids) -> lids
-    | FStar_Syntax_Syntax.Sig_splice (lids, uu___) -> lids
-    | FStar_Syntax_Syntax.Sig_bundle (uu___, lids) -> lids
-    | FStar_Syntax_Syntax.Sig_inductive_typ
-        (lid, uu___, uu___1, uu___2, uu___3, uu___4, uu___5) -> [lid]
-    | FStar_Syntax_Syntax.Sig_effect_abbrev
-        (lid, uu___, uu___1, uu___2, uu___3) -> [lid]
-    | FStar_Syntax_Syntax.Sig_datacon
-        (lid, uu___, uu___1, uu___2, uu___3, uu___4) -> [lid]
-    | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___, uu___1) -> [lid]
-    | FStar_Syntax_Syntax.Sig_assume (lid, uu___, uu___1) -> [lid]
-    | FStar_Syntax_Syntax.Sig_new_effect n -> [n.FStar_Syntax_Syntax.mname]
-    | FStar_Syntax_Syntax.Sig_sub_effect uu___ -> []
-    | FStar_Syntax_Syntax.Sig_pragma uu___ -> []
-    | FStar_Syntax_Syntax.Sig_fail uu___ -> []
-    | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___ -> []
-    | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___ -> []
-let (lid_of_sigelt :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun se ->
-    match lids_of_sigelt se with
-    | l::[] -> FStar_Pervasives_Native.Some l
-    | uu___ -> FStar_Pervasives_Native.None
-let (quals_of_sigelt :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.qualifier Prims.list) =
-  fun x -> x.FStar_Syntax_Syntax.sigquals
-let (range_of_sigelt :
-  FStar_Syntax_Syntax.sigelt -> FStar_Compiler_Range.range) =
-  fun x -> x.FStar_Syntax_Syntax.sigrng
-let (range_of_lbname :
-  (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either ->
-    FStar_Compiler_Range.range)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives.Inl x -> FStar_Syntax_Syntax.range_of_bv x
-    | FStar_Pervasives.Inr fv ->
-        FStar_Ident.range_of_lid
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-let range_of_arg :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu FStar_Syntax_Syntax.syntax * 'uuuuu1) ->
-      FStar_Compiler_Range.range
-  =
-  fun uu___ -> match uu___ with | (hd, uu___1) -> hd.FStar_Syntax_Syntax.pos
-let range_of_args :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu FStar_Syntax_Syntax.syntax * 'uuuuu1) Prims.list ->
-      FStar_Compiler_Range.range -> FStar_Compiler_Range.range
-  =
-  fun args ->
-    fun r ->
-      FStar_Compiler_Effect.op_Bar_Greater args
-        (FStar_Compiler_List.fold_left
-           (fun r1 ->
-              fun a -> FStar_Compiler_Range.union_ranges r1 (range_of_arg a))
-           r)
-let (mk_app :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-      Prims.list -> FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun f ->
-    fun args ->
-      match args with
-      | [] -> f
-      | uu___ ->
-          let r = range_of_args args f.FStar_Syntax_Syntax.pos in
-          FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (f, args)) r
-let (mk_app_binders :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun f ->
-    fun bs ->
-      let uu___ =
-        FStar_Compiler_List.map
-          (fun b ->
-             let uu___1 =
-               FStar_Syntax_Syntax.bv_to_name b.FStar_Syntax_Syntax.binder_bv in
-             let uu___2 = aqual_of_binder b in (uu___1, uu___2)) bs in
-      mk_app f uu___
-let (field_projector_prefix : Prims.string) = "__proj__"
-let (field_projector_sep : Prims.string) = "__item__"
-let (field_projector_contains_constructor : Prims.string -> Prims.bool) =
-  fun s -> FStar_Compiler_Util.starts_with s field_projector_prefix
-let (mk_field_projector_name_from_string :
-  Prims.string -> Prims.string -> Prims.string) =
-  fun constr ->
-    fun field ->
-      Prims.op_Hat field_projector_prefix
-        (Prims.op_Hat constr (Prims.op_Hat field_projector_sep field))
-let (mk_field_projector_name_from_ident :
-  FStar_Ident.lident -> FStar_Ident.ident -> FStar_Ident.lident) =
-  fun lid ->
-    fun i ->
-      let itext = FStar_Ident.string_of_id i in
-      let newi =
-        if field_projector_contains_constructor itext
-        then i
-        else
-          (let uu___1 =
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Ident.ident_of_lid lid in
-                 FStar_Ident.string_of_id uu___4 in
-               mk_field_projector_name_from_string uu___3 itext in
-             let uu___3 = FStar_Ident.range_of_id i in (uu___2, uu___3) in
-           FStar_Ident.mk_ident uu___1) in
-      let uu___ =
-        let uu___1 = FStar_Ident.ns_of_lid lid in
-        FStar_Compiler_List.op_At uu___1 [newi] in
-      FStar_Ident.lid_of_ids uu___
-let (mk_field_projector_name :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.bv -> Prims.int -> FStar_Ident.lident)
-  =
-  fun lid ->
-    fun x ->
-      fun i ->
-        let nm =
-          let uu___ = FStar_Syntax_Syntax.is_null_bv x in
-          if uu___
-          then
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Compiler_Util.string_of_int i in
-                Prims.op_Hat "_" uu___3 in
-              let uu___3 = FStar_Syntax_Syntax.range_of_bv x in
-              (uu___2, uu___3) in
-            FStar_Ident.mk_ident uu___1
-          else x.FStar_Syntax_Syntax.ppname in
-        mk_field_projector_name_from_ident lid nm
-let (ses_of_sigbundle :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt Prims.list) =
-  fun se ->
-    match se.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_bundle (ses, uu___) -> ses
-    | uu___ -> failwith "ses_of_sigbundle: not a Sig_bundle"
-let (set_uvar : FStar_Syntax_Syntax.uvar -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun uv ->
-    fun t ->
-      let uu___ = FStar_Syntax_Unionfind.find uv in
-      match uu___ with
-      | FStar_Pervasives_Native.Some t' ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Unionfind.uvar_id uv in
-              FStar_Compiler_Effect.op_Less_Bar
-                FStar_Compiler_Util.string_of_int uu___3 in
-            let uu___3 = tts t in
-            let uu___4 = tts t' in
-            FStar_Compiler_Util.format3
-              "Changing a fixed uvar! ?%s to %s but it is already set to %s\n"
-              uu___2 uu___3 uu___4 in
-          failwith uu___1
-      | uu___1 -> FStar_Syntax_Unionfind.change uv t
-let (qualifier_equal :
-  FStar_Syntax_Syntax.qualifier ->
-    FStar_Syntax_Syntax.qualifier -> Prims.bool)
-  =
-  fun q1 ->
-    fun q2 ->
-      match (q1, q2) with
-      | (FStar_Syntax_Syntax.Discriminator l1,
-         FStar_Syntax_Syntax.Discriminator l2) ->
-          FStar_Ident.lid_equals l1 l2
-      | (FStar_Syntax_Syntax.Projector (l1a, l1b),
-         FStar_Syntax_Syntax.Projector (l2a, l2b)) ->
-          (FStar_Ident.lid_equals l1a l2a) &&
-            (let uu___ = FStar_Ident.string_of_id l1b in
-             let uu___1 = FStar_Ident.string_of_id l2b in uu___ = uu___1)
-      | (FStar_Syntax_Syntax.RecordType (ns1, f1),
-         FStar_Syntax_Syntax.RecordType (ns2, f2)) ->
-          ((((FStar_Compiler_List.length ns1) =
-               (FStar_Compiler_List.length ns2))
-              &&
-              (FStar_Compiler_List.forall2
-                 (fun x1 ->
-                    fun x2 ->
-                      let uu___ = FStar_Ident.string_of_id x1 in
-                      let uu___1 = FStar_Ident.string_of_id x2 in
-                      uu___ = uu___1) f1 f2))
-             &&
-             ((FStar_Compiler_List.length f1) =
-                (FStar_Compiler_List.length f2)))
-            &&
-            (FStar_Compiler_List.forall2
-               (fun x1 ->
-                  fun x2 ->
-                    let uu___ = FStar_Ident.string_of_id x1 in
-                    let uu___1 = FStar_Ident.string_of_id x2 in
-                    uu___ = uu___1) f1 f2)
-      | (FStar_Syntax_Syntax.RecordConstructor (ns1, f1),
-         FStar_Syntax_Syntax.RecordConstructor (ns2, f2)) ->
-          ((((FStar_Compiler_List.length ns1) =
-               (FStar_Compiler_List.length ns2))
-              &&
-              (FStar_Compiler_List.forall2
-                 (fun x1 ->
-                    fun x2 ->
-                      let uu___ = FStar_Ident.string_of_id x1 in
-                      let uu___1 = FStar_Ident.string_of_id x2 in
-                      uu___ = uu___1) f1 f2))
-             &&
-             ((FStar_Compiler_List.length f1) =
-                (FStar_Compiler_List.length f2)))
-            &&
-            (FStar_Compiler_List.forall2
-               (fun x1 ->
-                  fun x2 ->
-                    let uu___ = FStar_Ident.string_of_id x1 in
-                    let uu___1 = FStar_Ident.string_of_id x2 in
-                    uu___ = uu___1) f1 f2)
-      | uu___ -> q1 = q2
-let (abs :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun bs ->
-    fun t ->
-      fun lopt ->
-        let close_lopt lopt1 =
-          match lopt1 with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some rc ->
-              let uu___ =
-                let uu___1 =
-                  FStar_Compiler_Util.map_opt
-                    rc.FStar_Syntax_Syntax.residual_typ
-                    (FStar_Syntax_Subst.close bs) in
-                {
-                  FStar_Syntax_Syntax.residual_effect =
-                    (rc.FStar_Syntax_Syntax.residual_effect);
-                  FStar_Syntax_Syntax.residual_typ = uu___1;
-                  FStar_Syntax_Syntax.residual_flags =
-                    (rc.FStar_Syntax_Syntax.residual_flags)
-                } in
-              FStar_Pervasives_Native.Some uu___ in
-        match bs with
-        | [] -> t
-        | uu___ ->
-            let body =
-              let uu___1 = FStar_Syntax_Subst.close bs t in
-              FStar_Syntax_Subst.compress uu___1 in
-            (match body.FStar_Syntax_Syntax.n with
-             | FStar_Syntax_Syntax.Tm_abs (bs', t1, lopt') ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = FStar_Syntax_Subst.close_binders bs in
-                       FStar_Compiler_List.op_At uu___4 bs' in
-                     let uu___4 = close_lopt lopt' in (uu___3, t1, uu___4) in
-                   FStar_Syntax_Syntax.Tm_abs uu___2 in
-                 FStar_Syntax_Syntax.mk uu___1 t1.FStar_Syntax_Syntax.pos
-             | uu___1 ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Subst.close_binders bs in
-                     let uu___5 = close_lopt lopt in (uu___4, body, uu___5) in
-                   FStar_Syntax_Syntax.Tm_abs uu___3 in
-                 FStar_Syntax_Syntax.mk uu___2 t.FStar_Syntax_Syntax.pos)
-let (arrow :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun bs ->
-    fun c ->
-      match bs with
-      | [] -> comp_result c
-      | uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Subst.close_binders bs in
-              let uu___4 = FStar_Syntax_Subst.close_comp bs c in
-              (uu___3, uu___4) in
-            FStar_Syntax_Syntax.Tm_arrow uu___2 in
-          FStar_Syntax_Syntax.mk uu___1 c.FStar_Syntax_Syntax.pos
-let (flat_arrow :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun bs ->
-    fun c ->
-      let t = arrow bs c in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_arrow (bs1, c1) ->
-          (match c1.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Total tres ->
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress tres in
-                 uu___2.FStar_Syntax_Syntax.n in
-               (match uu___1 with
-                | FStar_Syntax_Syntax.Tm_arrow (bs', c') ->
-                    FStar_Syntax_Syntax.mk
-                      (FStar_Syntax_Syntax.Tm_arrow
-                         ((FStar_Compiler_List.op_At bs1 bs'), c'))
-                      t.FStar_Syntax_Syntax.pos
-                | uu___2 -> t)
-           | uu___1 -> t)
-      | uu___1 -> t
-let rec (canon_arrow :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-        let cn =
-          match c.FStar_Syntax_Syntax.n with
-          | FStar_Syntax_Syntax.Total t1 ->
-              let uu___1 = canon_arrow t1 in FStar_Syntax_Syntax.Total uu___1
-          | uu___1 -> c.FStar_Syntax_Syntax.n in
-        let c1 =
-          {
-            FStar_Syntax_Syntax.n = cn;
-            FStar_Syntax_Syntax.pos = (c.FStar_Syntax_Syntax.pos);
-            FStar_Syntax_Syntax.vars = (c.FStar_Syntax_Syntax.vars);
-            FStar_Syntax_Syntax.hash_code = (c.FStar_Syntax_Syntax.hash_code)
-          } in
-        flat_arrow bs c1
-    | uu___1 -> t
-let (refine :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun b ->
-    fun t ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Syntax_Syntax.mk_binder b in [uu___4] in
-            FStar_Syntax_Subst.close uu___3 t in
-          (b, uu___2) in
-        FStar_Syntax_Syntax.Tm_refine uu___1 in
-      let uu___1 =
-        let uu___2 = FStar_Syntax_Syntax.range_of_bv b in
-        FStar_Compiler_Range.union_ranges uu___2 t.FStar_Syntax_Syntax.pos in
-      FStar_Syntax_Syntax.mk uu___ uu___1
-let (branch : FStar_Syntax_Syntax.branch -> FStar_Syntax_Syntax.branch) =
-  fun b -> FStar_Syntax_Subst.close_branch b
-let (has_decreases : FStar_Syntax_Syntax.comp -> Prims.bool) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Comp ct ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater ct.FStar_Syntax_Syntax.flags
-            (FStar_Compiler_Util.find_opt
-               (fun uu___1 ->
-                  match uu___1 with
-                  | FStar_Syntax_Syntax.DECREASES uu___2 -> true
-                  | uu___2 -> false)) in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.DECREASES
-             uu___1) -> true
-         | uu___1 -> false)
-    | uu___ -> false
-let rec (arrow_formals_comp_ln :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binder Prims.list * FStar_Syntax_Syntax.comp))
-  =
-  fun k ->
-    let k1 = FStar_Syntax_Subst.compress k in
-    match k1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-        let uu___ =
-          (is_total_comp c) &&
-            (let uu___1 = has_decreases c in Prims.op_Negation uu___1) in
-        if uu___
-        then
-          let uu___1 = arrow_formals_comp_ln (comp_result c) in
-          (match uu___1 with
-           | (bs', k2) -> ((FStar_Compiler_List.op_At bs bs'), k2))
-        else (bs, c)
-    | FStar_Syntax_Syntax.Tm_refine
-        ({ FStar_Syntax_Syntax.ppname = uu___;
-           FStar_Syntax_Syntax.index = uu___1;
-           FStar_Syntax_Syntax.sort = s;_},
-         uu___2)
-        ->
-        let rec aux s1 k2 =
-          let uu___3 =
-            let uu___4 = FStar_Syntax_Subst.compress s1 in
-            uu___4.FStar_Syntax_Syntax.n in
-          match uu___3 with
-          | FStar_Syntax_Syntax.Tm_arrow uu___4 -> arrow_formals_comp_ln s1
-          | FStar_Syntax_Syntax.Tm_refine
-              ({ FStar_Syntax_Syntax.ppname = uu___4;
-                 FStar_Syntax_Syntax.index = uu___5;
-                 FStar_Syntax_Syntax.sort = s2;_},
-               uu___6)
-              -> aux s2 k2
-          | uu___4 ->
-              let uu___5 = FStar_Syntax_Syntax.mk_Total k2 in ([], uu___5) in
-        aux s k1
-    | uu___ -> let uu___1 = FStar_Syntax_Syntax.mk_Total k1 in ([], uu___1)
-let (arrow_formals_comp :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp))
-  =
-  fun k ->
-    let uu___ = arrow_formals_comp_ln k in
-    match uu___ with | (bs, c) -> FStar_Syntax_Subst.open_comp bs c
-let (arrow_formals_ln :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binder Prims.list * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax))
-  =
-  fun k ->
-    let uu___ = arrow_formals_comp_ln k in
-    match uu___ with | (bs, c) -> (bs, (comp_result c))
-let (arrow_formals :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax))
-  =
-  fun k ->
-    let uu___ = arrow_formals_comp k in
-    match uu___ with | (bs, c) -> (bs, (comp_result c))
-let (let_rec_arity :
-  FStar_Syntax_Syntax.letbinding ->
-    (Prims.int * Prims.bool Prims.list FStar_Pervasives_Native.option))
-  =
-  fun lb ->
-    let rec arrow_until_decreases k =
-      let k1 = FStar_Syntax_Subst.compress k in
-      match k1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-          let uu___ = FStar_Syntax_Subst.open_comp bs c in
-          (match uu___ with
-           | (bs1, c1) ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater c1 comp_flags in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___2
-                   (FStar_Compiler_Util.find_opt
-                      (fun uu___3 ->
-                         match uu___3 with
-                         | FStar_Syntax_Syntax.DECREASES uu___4 -> true
-                         | uu___4 -> false)) in
-               (match uu___1 with
-                | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.DECREASES
-                    d) -> (bs1, (FStar_Pervasives_Native.Some d))
-                | uu___2 ->
-                    let uu___3 = is_total_comp c1 in
-                    if uu___3
-                    then
-                      let uu___4 = arrow_until_decreases (comp_result c1) in
-                      (match uu___4 with
-                       | (bs', d) -> ((FStar_Compiler_List.op_At bs1 bs'), d))
-                    else (bs1, FStar_Pervasives_Native.None)))
-      | FStar_Syntax_Syntax.Tm_refine
-          ({ FStar_Syntax_Syntax.ppname = uu___;
-             FStar_Syntax_Syntax.index = uu___1;
-             FStar_Syntax_Syntax.sort = k2;_},
-           uu___2)
-          -> arrow_until_decreases k2
-      | uu___ -> ([], FStar_Pervasives_Native.None) in
-    let uu___ = arrow_until_decreases lb.FStar_Syntax_Syntax.lbtyp in
-    match uu___ with
-    | (bs, dopt) ->
-        let n_univs =
-          FStar_Compiler_List.length lb.FStar_Syntax_Syntax.lbunivs in
-        let uu___1 =
-          FStar_Compiler_Util.map_opt dopt
-            (fun d ->
-               let d_bvs =
-                 match d with
-                 | FStar_Syntax_Syntax.Decreases_lex l ->
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Compiler_Util.new_set
-                           FStar_Syntax_Syntax.order_bv in
-                       FStar_Compiler_List.fold_left
-                         (fun s ->
-                            fun t ->
-                              let uu___4 = FStar_Syntax_Free.names t in
-                              FStar_Compiler_Util.set_union s uu___4) uu___3 in
-                     FStar_Compiler_Effect.op_Bar_Greater l uu___2
-                 | FStar_Syntax_Syntax.Decreases_wf (rel, e) ->
-                     let uu___2 = FStar_Syntax_Free.names rel in
-                     let uu___3 = FStar_Syntax_Free.names e in
-                     FStar_Compiler_Util.set_union uu___2 uu___3 in
-               let uu___2 =
-                 FStar_Common.tabulate n_univs (fun uu___3 -> false) in
-               let uu___3 =
-                 FStar_Compiler_Effect.op_Bar_Greater bs
-                   (FStar_Compiler_List.map
-                      (fun b ->
-                         FStar_Compiler_Util.set_mem
-                           b.FStar_Syntax_Syntax.binder_bv d_bvs)) in
-               FStar_Compiler_List.op_At uu___2 uu___3) in
-        ((n_univs + (FStar_Compiler_List.length bs)), uu___1)
-let (abs_formals_maybe_unascribe_body :
-  Prims.bool ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option))
-  =
-  fun maybe_unascribe ->
-    fun t ->
-      let subst_lcomp_opt s l =
-        match l with
-        | FStar_Pervasives_Native.Some rc ->
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_Util.map_opt
-                  rc.FStar_Syntax_Syntax.residual_typ
-                  (FStar_Syntax_Subst.subst s) in
-              {
-                FStar_Syntax_Syntax.residual_effect =
-                  (rc.FStar_Syntax_Syntax.residual_effect);
-                FStar_Syntax_Syntax.residual_typ = uu___1;
-                FStar_Syntax_Syntax.residual_flags =
-                  (rc.FStar_Syntax_Syntax.residual_flags)
-              } in
-            FStar_Pervasives_Native.Some uu___
-        | uu___ -> l in
-      let rec aux t1 abs_body_lcomp =
-        let uu___ =
-          let uu___1 = unmeta_safe t1 in uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_abs (bs, t2, what) ->
-            if maybe_unascribe
-            then
-              let uu___1 = aux t2 what in
-              (match uu___1 with
-               | (bs', t3, what1) ->
-                   ((FStar_Compiler_List.op_At bs bs'), t3, what1))
-            else (bs, t2, what)
-        | uu___1 -> ([], t1, abs_body_lcomp) in
-      let uu___ = aux t FStar_Pervasives_Native.None in
-      match uu___ with
-      | (bs, t1, abs_body_lcomp) ->
-          let uu___1 = FStar_Syntax_Subst.open_term' bs t1 in
-          (match uu___1 with
-           | (bs1, t2, opening) ->
-               let abs_body_lcomp1 = subst_lcomp_opt opening abs_body_lcomp in
-               (bs1, t2, abs_body_lcomp1))
-let (abs_formals :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option))
-  = fun t -> abs_formals_maybe_unascribe_body true t
-let (remove_inacc : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let no_acc b =
-      let aq =
-        match b.FStar_Syntax_Syntax.binder_qual with
-        | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit (true))
-            ->
-            FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit false)
-        | aq1 -> aq1 in
-      {
-        FStar_Syntax_Syntax.binder_bv = (b.FStar_Syntax_Syntax.binder_bv);
-        FStar_Syntax_Syntax.binder_qual = aq;
-        FStar_Syntax_Syntax.binder_attrs =
-          (b.FStar_Syntax_Syntax.binder_attrs)
-      } in
-    let uu___ = arrow_formals_comp_ln t in
-    match uu___ with
-    | (bs, c) ->
-        (match bs with
-         | [] -> t
-         | uu___1 ->
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Compiler_List.map no_acc bs in
-                 (uu___4, c) in
-               FStar_Syntax_Syntax.Tm_arrow uu___3 in
-             FStar_Syntax_Syntax.mk uu___2 t.FStar_Syntax_Syntax.pos)
-let (mk_letbinding :
-  (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either ->
-    FStar_Syntax_Syntax.univ_name Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-            FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list
-              -> FStar_Compiler_Range.range -> FStar_Syntax_Syntax.letbinding)
-  =
-  fun lbname ->
-    fun univ_vars ->
-      fun typ ->
-        fun eff ->
-          fun def ->
-            fun lbattrs ->
-              fun pos ->
-                {
-                  FStar_Syntax_Syntax.lbname = lbname;
-                  FStar_Syntax_Syntax.lbunivs = univ_vars;
-                  FStar_Syntax_Syntax.lbtyp = typ;
-                  FStar_Syntax_Syntax.lbeff = eff;
-                  FStar_Syntax_Syntax.lbdef = def;
-                  FStar_Syntax_Syntax.lbattrs = lbattrs;
-                  FStar_Syntax_Syntax.lbpos = pos
-                }
-let (close_univs_and_mk_letbinding :
-  FStar_Syntax_Syntax.fv Prims.list FStar_Pervasives_Native.option ->
-    (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either
-      ->
-      FStar_Syntax_Syntax.univ_name Prims.list ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Ident.lident ->
-            FStar_Syntax_Syntax.term ->
-              FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list
-                ->
-                FStar_Compiler_Range.range -> FStar_Syntax_Syntax.letbinding)
-  =
-  fun recs ->
-    fun lbname ->
-      fun univ_vars ->
-        fun typ ->
-          fun eff ->
-            fun def ->
-              fun attrs ->
-                fun pos ->
-                  let def1 =
-                    match (recs, univ_vars) with
-                    | (FStar_Pervasives_Native.None, uu___) -> def
-                    | (uu___, []) -> def
-                    | (FStar_Pervasives_Native.Some fvs, uu___) ->
-                        let universes =
-                          FStar_Compiler_Effect.op_Bar_Greater univ_vars
-                            (FStar_Compiler_List.map
-                               (fun uu___1 ->
-                                  FStar_Syntax_Syntax.U_name uu___1)) in
-                        let inst =
-                          FStar_Compiler_Effect.op_Bar_Greater fvs
-                            (FStar_Compiler_List.map
-                               (fun fv ->
-                                  (((fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v),
-                                    universes))) in
-                        FStar_Syntax_InstFV.instantiate inst def in
-                  let typ1 = FStar_Syntax_Subst.close_univ_vars univ_vars typ in
-                  let def2 =
-                    FStar_Syntax_Subst.close_univ_vars univ_vars def1 in
-                  mk_letbinding lbname univ_vars typ1 eff def2 attrs pos
-let (open_univ_vars_binders_and_comp :
-  FStar_Syntax_Syntax.univ_names ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-        (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.binder
-          Prims.list * FStar_Syntax_Syntax.comp))
-  =
-  fun uvs ->
-    fun binders ->
-      fun c ->
-        match binders with
-        | [] ->
-            let uu___ = FStar_Syntax_Subst.open_univ_vars_comp uvs c in
-            (match uu___ with | (uvs1, c1) -> (uvs1, [], c1))
-        | uu___ ->
-            let t' = arrow binders c in
-            let uu___1 = FStar_Syntax_Subst.open_univ_vars uvs t' in
-            (match uu___1 with
-             | (uvs1, t'1) ->
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t'1 in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 (match uu___2 with
-                  | FStar_Syntax_Syntax.Tm_arrow (binders1, c1) ->
-                      (uvs1, binders1, c1)
-                  | uu___3 -> failwith "Impossible"))
-let (is_tuple_constructor : FStar_Syntax_Syntax.typ -> Prims.bool) =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        let uu___ =
-          FStar_Ident.string_of_lid
-            (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-        FStar_Parser_Const.is_tuple_constructor_string uu___
-    | uu___ -> false
-let (is_dtuple_constructor : FStar_Syntax_Syntax.typ -> Prims.bool) =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        FStar_Parser_Const.is_dtuple_constructor_lid
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-    | uu___ -> false
-let (is_lid_equality : FStar_Ident.lident -> Prims.bool) =
-  fun x -> FStar_Ident.lid_equals x FStar_Parser_Const.eq2_lid
-let (is_forall : FStar_Ident.lident -> Prims.bool) =
-  fun lid -> FStar_Ident.lid_equals lid FStar_Parser_Const.forall_lid
-let (is_exists : FStar_Ident.lident -> Prims.bool) =
-  fun lid -> FStar_Ident.lid_equals lid FStar_Parser_Const.exists_lid
-let (is_qlid : FStar_Ident.lident -> Prims.bool) =
-  fun lid -> (is_forall lid) || (is_exists lid)
-let (is_equality :
-  FStar_Ident.lident FStar_Syntax_Syntax.withinfo_t -> Prims.bool) =
-  fun x -> is_lid_equality x.FStar_Syntax_Syntax.v
-let (lid_is_connective : FStar_Ident.lident -> Prims.bool) =
-  let lst =
-    [FStar_Parser_Const.and_lid;
-    FStar_Parser_Const.or_lid;
-    FStar_Parser_Const.not_lid;
-    FStar_Parser_Const.iff_lid;
-    FStar_Parser_Const.imp_lid] in
-  fun lid -> FStar_Compiler_Util.for_some (FStar_Ident.lid_equals lid) lst
-let (is_constructor :
-  FStar_Syntax_Syntax.term -> FStar_Ident.lident -> Prims.bool) =
-  fun t ->
-    fun lid ->
-      let uu___ = let uu___1 = pre_typ t in uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar tc ->
-          FStar_Ident.lid_equals
-            (tc.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v lid
-      | uu___1 -> false
-let rec (is_constructed_typ :
-  FStar_Syntax_Syntax.term -> FStar_Ident.lident -> Prims.bool) =
-  fun t ->
-    fun lid ->
-      let uu___ = let uu___1 = pre_typ t in uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar uu___1 -> is_constructor t lid
-      | FStar_Syntax_Syntax.Tm_app (t1, uu___1) -> is_constructed_typ t1 lid
-      | FStar_Syntax_Syntax.Tm_uinst (t1, uu___1) ->
-          is_constructed_typ t1 lid
-      | uu___1 -> false
-let rec (get_tycon :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let t1 = pre_typ t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_bvar uu___ -> FStar_Pervasives_Native.Some t1
-    | FStar_Syntax_Syntax.Tm_name uu___ -> FStar_Pervasives_Native.Some t1
-    | FStar_Syntax_Syntax.Tm_fvar uu___ -> FStar_Pervasives_Native.Some t1
-    | FStar_Syntax_Syntax.Tm_app (t2, uu___) -> get_tycon t2
-    | uu___ -> FStar_Pervasives_Native.None
-let (is_fstar_tactics_by_tactic : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = let uu___1 = un_uinst t in uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.by_tactic_lid
-    | uu___1 -> false
-let (is_builtin_tactic : FStar_Ident.lident -> Prims.bool) =
-  fun md ->
-    let path = FStar_Ident.path_of_lid md in
-    if (FStar_Compiler_List.length path) > (Prims.of_int (2))
-    then
-      let uu___ =
-        let uu___1 = FStar_Compiler_List.splitAt (Prims.of_int (2)) path in
-        FStar_Pervasives_Native.fst uu___1 in
-      match uu___ with
-      | "FStar"::"Tactics"::[] -> true
-      | "FStar"::"Reflection"::[] -> true
-      | uu___1 -> false
-    else false
-let (ktype : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.mk
-    (FStar_Syntax_Syntax.Tm_type FStar_Syntax_Syntax.U_unknown)
-    FStar_Compiler_Range.dummyRange
-let (ktype0 : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.mk
-    (FStar_Syntax_Syntax.Tm_type FStar_Syntax_Syntax.U_zero)
-    FStar_Compiler_Range.dummyRange
-let (type_u :
-  unit -> (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.universe)) =
-  fun uu___ ->
-    let u =
-      let uu___1 =
-        FStar_Syntax_Unionfind.univ_fresh FStar_Compiler_Range.dummyRange in
-      FStar_Compiler_Effect.op_Less_Bar
-        (fun uu___2 -> FStar_Syntax_Syntax.U_unif uu___2) uu___1 in
-    let uu___1 =
-      FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-        FStar_Compiler_Range.dummyRange in
-    (uu___1, u)
-let (type_with_u : FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.typ) =
-  fun u ->
-    FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-      FStar_Compiler_Range.dummyRange
-let (attr_eq :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun a ->
-    fun a' ->
-      let uu___ = eq_tm a a' in
-      match uu___ with | Equal -> true | uu___1 -> false
-let (attr_substitute : FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  let uu___ =
-    let uu___1 =
-      FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.attr_substitute_lid
-        FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-    FStar_Syntax_Syntax.Tm_fvar uu___1 in
-  FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (exp_true_bool : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.mk
-    (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_bool true))
-    FStar_Compiler_Range.dummyRange
-let (exp_false_bool : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.mk
-    (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_bool false))
-    FStar_Compiler_Range.dummyRange
-let (exp_unit : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.mk
-    (FStar_Syntax_Syntax.Tm_constant FStar_Const.Const_unit)
-    FStar_Compiler_Range.dummyRange
-let (exp_int : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s ->
-    FStar_Syntax_Syntax.mk
-      (FStar_Syntax_Syntax.Tm_constant
-         (FStar_Const.Const_int (s, FStar_Pervasives_Native.None)))
-      FStar_Compiler_Range.dummyRange
-let (exp_char : FStar_BaseTypes.char -> FStar_Syntax_Syntax.term) =
-  fun c ->
-    FStar_Syntax_Syntax.mk
-      (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_char c))
-      FStar_Compiler_Range.dummyRange
-let (exp_string : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s ->
-    FStar_Syntax_Syntax.mk
-      (FStar_Syntax_Syntax.Tm_constant
-         (FStar_Const.Const_string (s, FStar_Compiler_Range.dummyRange)))
-      FStar_Compiler_Range.dummyRange
-let (fvar_const : FStar_Ident.lident -> FStar_Syntax_Syntax.term) =
-  fun l ->
-    FStar_Syntax_Syntax.fvar l FStar_Syntax_Syntax.delta_constant
-      FStar_Pervasives_Native.None
-let (tand : FStar_Syntax_Syntax.term) = fvar_const FStar_Parser_Const.and_lid
-let (tor : FStar_Syntax_Syntax.term) = fvar_const FStar_Parser_Const.or_lid
-let (timp : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.fvar FStar_Parser_Const.imp_lid
-    (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-    FStar_Pervasives_Native.None
-let (tiff : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.fvar FStar_Parser_Const.iff_lid
-    (FStar_Syntax_Syntax.Delta_constant_at_level (Prims.of_int (2)))
-    FStar_Pervasives_Native.None
-let (t_bool : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.bool_lid
-let (b2t_v : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.b2t_lid
-let (t_not : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.not_lid
-let (t_false : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.false_lid
-let (t_true : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.true_lid
-let (tac_opaque_attr : FStar_Syntax_Syntax.term) = exp_string "tac_opaque"
-let (dm4f_bind_range_attr : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.dm4f_bind_range_attr
-let (tcdecltime_attr : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.tcdecltime_attr
-let (inline_let_attr : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.inline_let_attr
-let (rename_let_attr : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.rename_let_attr
-let (t_ctx_uvar_and_sust : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.ctx_uvar_and_subst_lid
-let (t_universe_uvar : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.universe_uvar_lid
-let (mk_conj_opt :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-    FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option)
-  =
-  fun phi1 ->
-    fun phi2 ->
-      match phi1 with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.Some phi2
-      | FStar_Pervasives_Native.Some phi11 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Syntax.as_arg phi11 in
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_Syntax.as_arg phi2 in [uu___6] in
-                  uu___4 :: uu___5 in
-                (tand, uu___3) in
-              FStar_Syntax_Syntax.Tm_app uu___2 in
-            let uu___2 =
-              FStar_Compiler_Range.union_ranges phi11.FStar_Syntax_Syntax.pos
-                phi2.FStar_Syntax_Syntax.pos in
-            FStar_Syntax_Syntax.mk uu___1 uu___2 in
-          FStar_Pervasives_Native.Some uu___
-let (mk_binop :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun op_t ->
-    fun phi1 ->
-      fun phi2 ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.as_arg phi1 in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg phi2 in [uu___5] in
-              uu___3 :: uu___4 in
-            (op_t, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___1 in
-        let uu___1 =
-          FStar_Compiler_Range.union_ranges phi1.FStar_Syntax_Syntax.pos
-            phi2.FStar_Syntax_Syntax.pos in
-        FStar_Syntax_Syntax.mk uu___ uu___1
-let (mk_neg :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun phi ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = let uu___3 = FStar_Syntax_Syntax.as_arg phi in [uu___3] in
-        (t_not, uu___2) in
-      FStar_Syntax_Syntax.Tm_app uu___1 in
-    FStar_Syntax_Syntax.mk uu___ phi.FStar_Syntax_Syntax.pos
-let (mk_conj :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  = fun phi1 -> fun phi2 -> mk_binop tand phi1 phi2
-let (mk_conj_l :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun phi ->
-    match phi with
-    | [] ->
-        FStar_Syntax_Syntax.fvar FStar_Parser_Const.true_lid
-          FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None
-    | hd::tl -> FStar_Compiler_List.fold_right mk_conj tl hd
-let (mk_disj :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  = fun phi1 -> fun phi2 -> mk_binop tor phi1 phi2
-let (mk_disj_l :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun phi ->
-    match phi with
-    | [] -> t_false
-    | hd::tl -> FStar_Compiler_List.fold_right mk_disj tl hd
-let (mk_imp :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term)
-  = fun phi1 -> fun phi2 -> mk_binop timp phi1 phi2
-let (mk_iff :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term)
-  = fun phi1 -> fun phi2 -> mk_binop tiff phi1 phi2
-let (b2t :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun e ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = let uu___3 = FStar_Syntax_Syntax.as_arg e in [uu___3] in
-        (b2t_v, uu___2) in
-      FStar_Syntax_Syntax.Tm_app uu___1 in
-    FStar_Syntax_Syntax.mk uu___ e.FStar_Syntax_Syntax.pos
-let (unb2t :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    let uu___ = head_and_args e in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.compress hd in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (e1, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.b2t_lid ->
-             FStar_Pervasives_Native.Some e1
-         | uu___2 -> FStar_Pervasives_Native.None)
-let (is_t_true : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = let uu___1 = unmeta t in uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.true_lid
-    | uu___1 -> false
-let (mk_conj_simp :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t1 ->
-    fun t2 ->
-      let uu___ = is_t_true t1 in
-      if uu___
-      then t2
-      else
-        (let uu___2 = is_t_true t2 in if uu___2 then t1 else mk_conj t1 t2)
-let (mk_disj_simp :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t1 ->
-    fun t2 ->
-      let uu___ = is_t_true t1 in
-      if uu___
-      then t_true
-      else
-        (let uu___2 = is_t_true t2 in
-         if uu___2 then t_true else mk_disj t1 t2)
-let (teq : FStar_Syntax_Syntax.term) = fvar_const FStar_Parser_Const.eq2_lid
-let (mk_untyped_eq2 :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun e1 ->
-    fun e2 ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Syntax.as_arg e1 in
-            let uu___4 =
-              let uu___5 = FStar_Syntax_Syntax.as_arg e2 in [uu___5] in
-            uu___3 :: uu___4 in
-          (teq, uu___2) in
-        FStar_Syntax_Syntax.Tm_app uu___1 in
-      let uu___1 =
-        FStar_Compiler_Range.union_ranges e1.FStar_Syntax_Syntax.pos
-          e2.FStar_Syntax_Syntax.pos in
-      FStar_Syntax_Syntax.mk uu___ uu___1
-let (mk_eq2 :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun u ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          let eq_inst = FStar_Syntax_Syntax.mk_Tm_uinst teq [u] in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Syntax.iarg t in
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Syntax.as_arg e1 in
-                  let uu___6 =
-                    let uu___7 = FStar_Syntax_Syntax.as_arg e2 in [uu___7] in
-                  uu___5 :: uu___6 in
-                uu___3 :: uu___4 in
-              (eq_inst, uu___2) in
-            FStar_Syntax_Syntax.Tm_app uu___1 in
-          let uu___1 =
-            FStar_Compiler_Range.union_ranges e1.FStar_Syntax_Syntax.pos
-              e2.FStar_Syntax_Syntax.pos in
-          FStar_Syntax_Syntax.mk uu___ uu___1
-let (mk_eq3_no_univ :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  let teq3 = fvar_const FStar_Parser_Const.eq3_lid in
-  fun t1 ->
-    fun t2 ->
-      fun e1 ->
-        fun e2 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Syntax.iarg t1 in
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Syntax.iarg t2 in
-                  let uu___6 =
-                    let uu___7 = FStar_Syntax_Syntax.as_arg e1 in
-                    let uu___8 =
-                      let uu___9 = FStar_Syntax_Syntax.as_arg e2 in [uu___9] in
-                    uu___7 :: uu___8 in
-                  uu___5 :: uu___6 in
-                uu___3 :: uu___4 in
-              (teq3, uu___2) in
-            FStar_Syntax_Syntax.Tm_app uu___1 in
-          let uu___1 =
-            FStar_Compiler_Range.union_ranges e1.FStar_Syntax_Syntax.pos
-              e2.FStar_Syntax_Syntax.pos in
-          FStar_Syntax_Syntax.mk uu___ uu___1
-let (mk_has_type :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    fun x ->
-      fun t' ->
-        let t_has_type = fvar_const FStar_Parser_Const.has_type_lid in
-        let t_has_type1 =
-          FStar_Syntax_Syntax.mk
-            (FStar_Syntax_Syntax.Tm_uinst
-               (t_has_type,
-                 [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero]))
-            FStar_Compiler_Range.dummyRange in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.iarg t in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg x in
-                let uu___6 =
-                  let uu___7 = FStar_Syntax_Syntax.as_arg t' in [uu___7] in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            (t_has_type1, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (mk_with_type :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun u ->
-    fun t ->
-      fun e ->
-        let t_with_type =
-          FStar_Syntax_Syntax.fvar FStar_Parser_Const.with_type_lid
-            FStar_Syntax_Syntax.delta_equational FStar_Pervasives_Native.None in
-        let t_with_type1 =
-          FStar_Syntax_Syntax.mk
-            (FStar_Syntax_Syntax.Tm_uinst (t_with_type, [u]))
-            FStar_Compiler_Range.dummyRange in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.iarg t in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg e in [uu___5] in
-              uu___3 :: uu___4 in
-            (t_with_type1, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (tforall : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.fvar FStar_Parser_Const.forall_lid
-    (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-    FStar_Pervasives_Native.None
-let (texists : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.fvar FStar_Parser_Const.exists_lid
-    (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-    FStar_Pervasives_Native.None
-let (t_haseq : FStar_Syntax_Syntax.term) =
-  FStar_Syntax_Syntax.fvar FStar_Parser_Const.haseq_lid
-    FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None
-let (decidable_eq : FStar_Syntax_Syntax.term) =
-  fvar_const FStar_Parser_Const.op_Eq
-let (mk_decidable_eq :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.iarg t in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg e1 in
-                let uu___6 =
-                  let uu___7 = FStar_Syntax_Syntax.as_arg e2 in [uu___7] in
-                uu___5 :: uu___6 in
-              uu___3 :: uu___4 in
-            (decidable_eq, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___1 in
-        let uu___1 =
-          FStar_Compiler_Range.union_ranges e1.FStar_Syntax_Syntax.pos
-            e2.FStar_Syntax_Syntax.pos in
-        FStar_Syntax_Syntax.mk uu___ uu___1
-let (b_and : FStar_Syntax_Syntax.term) = fvar_const FStar_Parser_Const.op_And
-let (mk_and :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun e1 ->
-    fun e2 ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Syntax.as_arg e1 in
-            let uu___4 =
-              let uu___5 = FStar_Syntax_Syntax.as_arg e2 in [uu___5] in
-            uu___3 :: uu___4 in
-          (b_and, uu___2) in
-        FStar_Syntax_Syntax.Tm_app uu___1 in
-      let uu___1 =
-        FStar_Compiler_Range.union_ranges e1.FStar_Syntax_Syntax.pos
-          e2.FStar_Syntax_Syntax.pos in
-      FStar_Syntax_Syntax.mk uu___ uu___1
-let (mk_and_l :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun l ->
-    match l with
-    | [] -> exp_true_bool
-    | hd::tl -> FStar_Compiler_List.fold_left mk_and hd tl
-let (mk_boolean_negation :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun b ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = fvar_const FStar_Parser_Const.op_Negation in
-        let uu___3 = let uu___4 = FStar_Syntax_Syntax.as_arg b in [uu___4] in
-        (uu___2, uu___3) in
-      FStar_Syntax_Syntax.Tm_app uu___1 in
-    FStar_Syntax_Syntax.mk uu___ b.FStar_Syntax_Syntax.pos
-let (mk_residual_comp :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.cflag Prims.list ->
-        FStar_Syntax_Syntax.residual_comp)
-  =
-  fun l ->
-    fun t ->
-      fun f ->
-        {
-          FStar_Syntax_Syntax.residual_effect = l;
-          FStar_Syntax_Syntax.residual_typ = t;
-          FStar_Syntax_Syntax.residual_flags = f
-        }
-let (residual_tot :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.residual_comp)
-  =
-  fun t ->
-    {
-      FStar_Syntax_Syntax.residual_effect = FStar_Parser_Const.effect_Tot_lid;
-      FStar_Syntax_Syntax.residual_typ = (FStar_Pervasives_Native.Some t);
-      FStar_Syntax_Syntax.residual_flags = [FStar_Syntax_Syntax.TOTAL]
-    }
-let (residual_gtot :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.residual_comp)
-  =
-  fun t ->
-    {
-      FStar_Syntax_Syntax.residual_effect =
-        FStar_Parser_Const.effect_GTot_lid;
-      FStar_Syntax_Syntax.residual_typ = (FStar_Pervasives_Native.Some t);
-      FStar_Syntax_Syntax.residual_flags = [FStar_Syntax_Syntax.TOTAL]
-    }
-let (residual_comp_of_comp :
-  FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.residual_comp) =
-  fun c ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Less_Bar
-        (FStar_Compiler_List.filter
-           (fun uu___1 ->
-              match uu___1 with
-              | FStar_Syntax_Syntax.DECREASES uu___2 -> false
-              | uu___2 -> true)) (comp_flags c) in
-    {
-      FStar_Syntax_Syntax.residual_effect = (comp_effect_name c);
-      FStar_Syntax_Syntax.residual_typ =
-        (FStar_Pervasives_Native.Some (comp_result c));
-      FStar_Syntax_Syntax.residual_flags = uu___
-    }
-let (mk_forall_aux :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun fa ->
-    fun x ->
-      fun body ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Syntax_Syntax.iarg x.FStar_Syntax_Syntax.sort in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___8] in
-                    abs uu___7 body
-                      (FStar_Pervasives_Native.Some (residual_tot ktype0)) in
-                  FStar_Syntax_Syntax.as_arg uu___6 in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            (fa, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (mk_forall_no_univ :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  = fun x -> fun body -> mk_forall_aux tforall x body
-let (mk_forall :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun u ->
-    fun x ->
-      fun body ->
-        let tforall1 = FStar_Syntax_Syntax.mk_Tm_uinst tforall [u] in
-        mk_forall_aux tforall1 x body
-let (close_forall_no_univs :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun bs ->
-    fun f ->
-      FStar_Compiler_List.fold_right
-        (fun b ->
-           fun f1 ->
-             let uu___ = FStar_Syntax_Syntax.is_null_binder b in
-             if uu___
-             then f1
-             else mk_forall_no_univ b.FStar_Syntax_Syntax.binder_bv f1) bs f
-let (mk_exists_aux :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun fa ->
-    fun x ->
-      fun body ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Syntax_Syntax.iarg x.FStar_Syntax_Syntax.sort in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___8] in
-                    abs uu___7 body
-                      (FStar_Pervasives_Native.Some (residual_tot ktype0)) in
-                  FStar_Syntax_Syntax.as_arg uu___6 in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            (fa, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (mk_exists_no_univ :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  = fun x -> fun body -> mk_exists_aux texists x body
-let (mk_exists :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun u ->
-    fun x ->
-      fun body ->
-        let texists1 = FStar_Syntax_Syntax.mk_Tm_uinst texists [u] in
-        mk_exists_aux texists1 x body
-let (close_exists_no_univs :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun bs ->
-    fun f ->
-      FStar_Compiler_List.fold_right
-        (fun b ->
-           fun f1 ->
-             let uu___ = FStar_Syntax_Syntax.is_null_binder b in
-             if uu___
-             then f1
-             else mk_exists_no_univ b.FStar_Syntax_Syntax.binder_bv f1) bs f
-let (is_wild_pat :
-  FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t -> Prims.bool) =
-  fun p ->
-    match p.FStar_Syntax_Syntax.v with
-    | FStar_Syntax_Syntax.Pat_wild uu___ -> true
-    | uu___ -> false
-let (if_then_else :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun b ->
-    fun t1 ->
-      fun t2 ->
-        let then_branch =
-          let uu___ =
-            FStar_Syntax_Syntax.withinfo
-              (FStar_Syntax_Syntax.Pat_constant (FStar_Const.Const_bool true))
-              t1.FStar_Syntax_Syntax.pos in
-          (uu___, FStar_Pervasives_Native.None, t1) in
-        let else_branch =
-          let uu___ =
-            FStar_Syntax_Syntax.withinfo
-              (FStar_Syntax_Syntax.Pat_constant
-                 (FStar_Const.Const_bool false)) t2.FStar_Syntax_Syntax.pos in
-          (uu___, FStar_Pervasives_Native.None, t2) in
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Range.union_ranges t1.FStar_Syntax_Syntax.pos
-              t2.FStar_Syntax_Syntax.pos in
-          FStar_Compiler_Range.union_ranges b.FStar_Syntax_Syntax.pos uu___1 in
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_match
-             (b, FStar_Pervasives_Native.None, [then_branch; else_branch],
-               FStar_Pervasives_Native.None)) uu___
-let (mk_squash :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun u ->
-    fun p ->
-      let sq =
-        FStar_Syntax_Syntax.fvar FStar_Parser_Const.squash_lid
-          (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-          FStar_Pervasives_Native.None in
-      let uu___ = FStar_Syntax_Syntax.mk_Tm_uinst sq [u] in
-      let uu___1 = let uu___2 = FStar_Syntax_Syntax.as_arg p in [uu___2] in
-      mk_app uu___ uu___1
-let (mk_auto_squash :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun u ->
-    fun p ->
-      let sq =
-        FStar_Syntax_Syntax.fvar FStar_Parser_Const.auto_squash_lid
-          (FStar_Syntax_Syntax.Delta_constant_at_level (Prims.of_int (2)))
-          FStar_Pervasives_Native.None in
-      let uu___ = FStar_Syntax_Syntax.mk_Tm_uinst sq [u] in
-      let uu___1 = let uu___2 = FStar_Syntax_Syntax.as_arg p in [uu___2] in
-      mk_app uu___ uu___1
-let (un_squash :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let head1 = unascribe head in
-        let head2 = un_uinst head1 in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.compress head2 in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, (p, uu___2)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.squash_lid
-             -> FStar_Pervasives_Native.Some p
-         | (FStar_Syntax_Syntax.Tm_refine (b, p), []) ->
-             (match (b.FStar_Syntax_Syntax.sort).FStar_Syntax_Syntax.n with
-              | FStar_Syntax_Syntax.Tm_fvar fv when
-                  FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.unit_lid
-                  ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Syntax.mk_binder b in
-                      [uu___4] in
-                    FStar_Syntax_Subst.open_term uu___3 p in
-                  (match uu___2 with
-                   | (bs, p1) ->
-                       let b1 =
-                         match bs with
-                         | b2::[] -> b2
-                         | uu___3 -> failwith "impossible" in
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Free.names p1 in
-                         FStar_Compiler_Util.set_mem
-                           b1.FStar_Syntax_Syntax.binder_bv uu___4 in
-                       if uu___3
-                       then FStar_Pervasives_Native.None
-                       else FStar_Pervasives_Native.Some p1)
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___2 -> FStar_Pervasives_Native.None)
-let (is_squash :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax) FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.compress head in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_uinst
-            ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             u::[]),
-            (t1, uu___5)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.squash_lid
-             -> FStar_Pervasives_Native.Some (u, t1)
-         | uu___2 -> FStar_Pervasives_Native.None)
-let (is_auto_squash :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax) FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.compress head in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_uinst
-            ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             u::[]),
-            (t1, uu___5)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv
-               FStar_Parser_Const.auto_squash_lid
-             -> FStar_Pervasives_Native.Some (u, t1)
-         | uu___2 -> FStar_Pervasives_Native.None)
-let (is_sub_singleton : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = let uu___1 = unmeta t in head_and_args uu___1 in
-    match uu___ with
-    | (head, uu___1) ->
-        let uu___2 =
-          let uu___3 = un_uinst head in uu___3.FStar_Syntax_Syntax.n in
-        (match uu___2 with
-         | FStar_Syntax_Syntax.Tm_fvar fv ->
-             (((((((((((((((((FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.unit_lid)
-                               ||
-                               (FStar_Syntax_Syntax.fv_eq_lid fv
-                                  FStar_Parser_Const.squash_lid))
-                              ||
-                              (FStar_Syntax_Syntax.fv_eq_lid fv
-                                 FStar_Parser_Const.auto_squash_lid))
-                             ||
-                             (FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.and_lid))
-                            ||
-                            (FStar_Syntax_Syntax.fv_eq_lid fv
-                               FStar_Parser_Const.or_lid))
-                           ||
-                           (FStar_Syntax_Syntax.fv_eq_lid fv
-                              FStar_Parser_Const.not_lid))
-                          ||
-                          (FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.imp_lid))
-                         ||
-                         (FStar_Syntax_Syntax.fv_eq_lid fv
-                            FStar_Parser_Const.iff_lid))
-                        ||
-                        (FStar_Syntax_Syntax.fv_eq_lid fv
-                           FStar_Parser_Const.ite_lid))
-                       ||
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.exists_lid))
-                      ||
-                      (FStar_Syntax_Syntax.fv_eq_lid fv
-                         FStar_Parser_Const.forall_lid))
-                     ||
-                     (FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.true_lid))
-                    ||
-                    (FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.false_lid))
-                   ||
-                   (FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.eq2_lid))
-                  ||
-                  (FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.b2t_lid))
-                 ||
-                 (FStar_Syntax_Syntax.fv_eq_lid fv
-                    FStar_Parser_Const.haseq_lid))
-                ||
-                (FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.has_type_lid))
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.precedes_lid)
-         | uu___3 -> false)
-let (arrow_one_ln :
-  FStar_Syntax_Syntax.typ ->
-    (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.comp)
-      FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow ([], c) ->
-        failwith "fatal: empty binders on arrow?"
-    | FStar_Syntax_Syntax.Tm_arrow (b::[], c) ->
-        FStar_Pervasives_Native.Some (b, c)
-    | FStar_Syntax_Syntax.Tm_arrow (b::bs, c) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = arrow bs c in FStar_Syntax_Syntax.mk_Total uu___3 in
-          (b, uu___2) in
-        FStar_Pervasives_Native.Some uu___1
-    | uu___1 -> FStar_Pervasives_Native.None
-let (arrow_one :
-  FStar_Syntax_Syntax.typ ->
-    (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.comp)
-      FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = arrow_one_ln t in
-    FStar_Compiler_Util.bind_opt uu___
-      (fun uu___1 ->
-         match uu___1 with
-         | (b, c) ->
-             let uu___2 = FStar_Syntax_Subst.open_comp [b] c in
-             (match uu___2 with
-              | (bs, c1) ->
-                  let b1 =
-                    match bs with
-                    | b2::[] -> b2
-                    | uu___3 ->
-                        failwith
-                          "impossible: open_comp returned different amount of binders" in
-                  FStar_Pervasives_Native.Some (b1, c1)))
-let (is_free_in :
-  FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun bv ->
-    fun t ->
-      let uu___ = FStar_Syntax_Free.names t in
-      FStar_Compiler_Util.set_mem bv uu___
-type qpats = FStar_Syntax_Syntax.args Prims.list
-type connective =
-  | QAll of (FStar_Syntax_Syntax.binders * qpats * FStar_Syntax_Syntax.typ) 
-  | QEx of (FStar_Syntax_Syntax.binders * qpats * FStar_Syntax_Syntax.typ) 
-  | BaseConn of (FStar_Ident.lident * FStar_Syntax_Syntax.args) 
-let (uu___is_QAll : connective -> Prims.bool) =
-  fun projectee -> match projectee with | QAll _0 -> true | uu___ -> false
-let (__proj__QAll__item___0 :
-  connective ->
-    (FStar_Syntax_Syntax.binders * qpats * FStar_Syntax_Syntax.typ))
-  = fun projectee -> match projectee with | QAll _0 -> _0
-let (uu___is_QEx : connective -> Prims.bool) =
-  fun projectee -> match projectee with | QEx _0 -> true | uu___ -> false
-let (__proj__QEx__item___0 :
-  connective ->
-    (FStar_Syntax_Syntax.binders * qpats * FStar_Syntax_Syntax.typ))
-  = fun projectee -> match projectee with | QEx _0 -> _0
-let (uu___is_BaseConn : connective -> Prims.bool) =
-  fun projectee ->
-    match projectee with | BaseConn _0 -> true | uu___ -> false
-let (__proj__BaseConn__item___0 :
-  connective -> (FStar_Ident.lident * FStar_Syntax_Syntax.args)) =
-  fun projectee -> match projectee with | BaseConn _0 -> _0
-let (destruct_base_table :
-  (Prims.int * (FStar_Ident.lident * FStar_Ident.lident) Prims.list)
-    Prims.list)
-  =
-  let f x = (x, x) in
-  [(Prims.int_zero,
-     [f FStar_Parser_Const.true_lid; f FStar_Parser_Const.false_lid]);
-  ((Prims.of_int (2)),
-    [f FStar_Parser_Const.and_lid;
-    f FStar_Parser_Const.or_lid;
-    f FStar_Parser_Const.imp_lid;
-    f FStar_Parser_Const.iff_lid;
-    f FStar_Parser_Const.eq2_lid]);
-  (Prims.int_one, [f FStar_Parser_Const.not_lid]);
-  ((Prims.of_int (3)),
-    [f FStar_Parser_Const.ite_lid; f FStar_Parser_Const.eq2_lid])]
-let (destruct_sq_base_table :
-  (Prims.int * (FStar_Ident.lident * FStar_Ident.lident) Prims.list)
-    Prims.list)
-  =
-  [((Prims.of_int (2)),
-     [(FStar_Parser_Const.c_and_lid, FStar_Parser_Const.and_lid);
-     (FStar_Parser_Const.c_or_lid, FStar_Parser_Const.or_lid);
-     (FStar_Parser_Const.c_eq2_lid, FStar_Parser_Const.c_eq2_lid)]);
-  ((Prims.of_int (3)),
-    [(FStar_Parser_Const.c_eq2_lid, FStar_Parser_Const.c_eq2_lid)]);
-  (Prims.int_zero,
-    [(FStar_Parser_Const.c_true_lid, FStar_Parser_Const.true_lid);
-    (FStar_Parser_Const.empty_type_lid, FStar_Parser_Const.false_lid)])]
-let (destruct_typ_as_formula :
-  FStar_Syntax_Syntax.term -> connective FStar_Pervasives_Native.option) =
-  fun f ->
-    let rec unmeta_monadic f1 =
-      let f2 = FStar_Syntax_Subst.compress f1 in
-      match f2.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_meta
-          (t, FStar_Syntax_Syntax.Meta_monadic uu___) -> unmeta_monadic t
-      | FStar_Syntax_Syntax.Tm_meta
-          (t, FStar_Syntax_Syntax.Meta_monadic_lift uu___) ->
-          unmeta_monadic t
-      | uu___ -> f2 in
-    let lookup_arity_lid table target_lid args =
-      let arg_len = FStar_Compiler_List.length args in
-      let aux uu___ =
-        match uu___ with
-        | (arity, lids) ->
-            if arg_len = arity
-            then
-              FStar_Compiler_Util.find_map lids
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (lid, out_lid) ->
-                       let uu___2 = FStar_Ident.lid_equals target_lid lid in
-                       if uu___2
-                       then
-                         FStar_Pervasives_Native.Some
-                           (BaseConn (out_lid, args))
-                       else FStar_Pervasives_Native.None)
-            else FStar_Pervasives_Native.None in
-      FStar_Compiler_Util.find_map table aux in
-    let destruct_base_conn t =
-      let uu___ = head_and_args t in
-      match uu___ with
-      | (hd, args) ->
-          let uu___1 =
-            let uu___2 = un_uinst hd in uu___2.FStar_Syntax_Syntax.n in
-          (match uu___1 with
-           | FStar_Syntax_Syntax.Tm_fvar fv ->
-               lookup_arity_lid destruct_base_table
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v args
-           | uu___2 -> FStar_Pervasives_Native.None) in
-    let destruct_sq_base_conn t =
-      let uu___ = un_squash t in
-      FStar_Compiler_Util.bind_opt uu___
-        (fun t1 ->
-           let uu___1 = head_and_args_full t1 in
-           match uu___1 with
-           | (hd, args) ->
-               let uu___2 =
-                 let uu___3 = un_uinst hd in uu___3.FStar_Syntax_Syntax.n in
-               (match uu___2 with
-                | FStar_Syntax_Syntax.Tm_fvar fv ->
-                    lookup_arity_lid destruct_sq_base_table
-                      (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                      args
-                | uu___3 -> FStar_Pervasives_Native.None)) in
-    let patterns t =
-      let t1 = FStar_Syntax_Subst.compress t in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_meta
-          (t2, FStar_Syntax_Syntax.Meta_pattern (uu___, pats)) ->
-          let uu___1 = FStar_Syntax_Subst.compress t2 in (pats, uu___1)
-      | uu___ -> ([], t1) in
-    let destruct_q_conn t =
-      let is_q fa fv =
-        if fa
-        then is_forall (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-        else is_exists (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      let flat t1 =
-        let uu___ = head_and_args t1 in
-        match uu___ with
-        | (t2, args) ->
-            let uu___1 = un_uinst t2 in
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater args
-                (FStar_Compiler_List.map
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (t3, imp) ->
-                          let uu___4 = unascribe t3 in (uu___4, imp))) in
-            (uu___1, uu___2) in
-      let rec aux qopt out t1 =
-        let uu___ = let uu___1 = flat t1 in (qopt, uu___1) in
-        match uu___ with
-        | (FStar_Pervasives_Native.Some fa,
-           ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar tc;
-              FStar_Syntax_Syntax.pos = uu___1;
-              FStar_Syntax_Syntax.vars = uu___2;
-              FStar_Syntax_Syntax.hash_code = uu___3;_},
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_abs
-                 (b::[], t2, uu___4);
-               FStar_Syntax_Syntax.pos = uu___5;
-               FStar_Syntax_Syntax.vars = uu___6;
-               FStar_Syntax_Syntax.hash_code = uu___7;_},
-             uu___8)::[]))
-            when is_q fa tc -> aux qopt (b :: out) t2
-        | (FStar_Pervasives_Native.Some fa,
-           ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar tc;
-              FStar_Syntax_Syntax.pos = uu___1;
-              FStar_Syntax_Syntax.vars = uu___2;
-              FStar_Syntax_Syntax.hash_code = uu___3;_},
-            uu___4::({
-                       FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_abs
-                         (b::[], t2, uu___5);
-                       FStar_Syntax_Syntax.pos = uu___6;
-                       FStar_Syntax_Syntax.vars = uu___7;
-                       FStar_Syntax_Syntax.hash_code = uu___8;_},
-                     uu___9)::[]))
-            when is_q fa tc -> aux qopt (b :: out) t2
-        | (FStar_Pervasives_Native.None,
-           ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar tc;
-              FStar_Syntax_Syntax.pos = uu___1;
-              FStar_Syntax_Syntax.vars = uu___2;
-              FStar_Syntax_Syntax.hash_code = uu___3;_},
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_abs
-                 (b::[], t2, uu___4);
-               FStar_Syntax_Syntax.pos = uu___5;
-               FStar_Syntax_Syntax.vars = uu___6;
-               FStar_Syntax_Syntax.hash_code = uu___7;_},
-             uu___8)::[]))
-            when
-            is_qlid (tc.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v ->
-            let uu___9 =
-              let uu___10 =
-                is_forall
-                  (tc.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-              FStar_Pervasives_Native.Some uu___10 in
-            aux uu___9 (b :: out) t2
-        | (FStar_Pervasives_Native.None,
-           ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar tc;
-              FStar_Syntax_Syntax.pos = uu___1;
-              FStar_Syntax_Syntax.vars = uu___2;
-              FStar_Syntax_Syntax.hash_code = uu___3;_},
-            uu___4::({
-                       FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_abs
-                         (b::[], t2, uu___5);
-                       FStar_Syntax_Syntax.pos = uu___6;
-                       FStar_Syntax_Syntax.vars = uu___7;
-                       FStar_Syntax_Syntax.hash_code = uu___8;_},
-                     uu___9)::[]))
-            when
-            is_qlid (tc.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v ->
-            let uu___10 =
-              let uu___11 =
-                is_forall
-                  (tc.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-              FStar_Pervasives_Native.Some uu___11 in
-            aux uu___10 (b :: out) t2
-        | (FStar_Pervasives_Native.Some b, uu___1) ->
-            let bs = FStar_Compiler_List.rev out in
-            let uu___2 = FStar_Syntax_Subst.open_term bs t1 in
-            (match uu___2 with
-             | (bs1, t2) ->
-                 let uu___3 = patterns t2 in
-                 (match uu___3 with
-                  | (pats, body) ->
-                      if b
-                      then
-                        FStar_Pervasives_Native.Some (QAll (bs1, pats, body))
-                      else
-                        FStar_Pervasives_Native.Some (QEx (bs1, pats, body))))
-        | uu___1 -> FStar_Pervasives_Native.None in
-      aux FStar_Pervasives_Native.None [] t in
-    let rec destruct_sq_forall t =
-      let uu___ = un_squash t in
-      FStar_Compiler_Util.bind_opt uu___
-        (fun t1 ->
-           let uu___1 = arrow_one t1 in
-           match uu___1 with
-           | FStar_Pervasives_Native.Some (b, c) ->
-               let uu___2 =
-                 let uu___3 = is_tot_or_gtot_comp c in
-                 Prims.op_Negation uu___3 in
-               if uu___2
-               then FStar_Pervasives_Native.None
-               else
-                 (let q = comp_result c in
-                  let uu___4 = is_free_in b.FStar_Syntax_Syntax.binder_bv q in
-                  if uu___4
-                  then
-                    let uu___5 = patterns q in
-                    match uu___5 with
-                    | (pats, q1) ->
-                        FStar_Compiler_Effect.op_Less_Bar maybe_collect
-                          (FStar_Pervasives_Native.Some
-                             (QAll ([b], pats, q1)))
-                  else
-                    (let uu___6 =
-                       let uu___7 =
-                         let uu___8 =
-                           let uu___9 =
-                             FStar_Syntax_Syntax.as_arg
-                               (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                           let uu___10 =
-                             let uu___11 = FStar_Syntax_Syntax.as_arg q in
-                             [uu___11] in
-                           uu___9 :: uu___10 in
-                         (FStar_Parser_Const.imp_lid, uu___8) in
-                       BaseConn uu___7 in
-                     FStar_Pervasives_Native.Some uu___6))
-           | uu___2 -> FStar_Pervasives_Native.None)
-    and destruct_sq_exists t =
-      let uu___ = un_squash t in
-      FStar_Compiler_Util.bind_opt uu___
-        (fun t1 ->
-           let uu___1 = head_and_args_full t1 in
-           match uu___1 with
-           | (hd, args) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = un_uinst hd in uu___4.FStar_Syntax_Syntax.n in
-                 (uu___3, args) in
-               (match uu___2 with
-                | (FStar_Syntax_Syntax.Tm_fvar fv,
-                   (a1, uu___3)::(a2, uu___4)::[]) when
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.dtuple2_lid
-                    ->
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Subst.compress a2 in
-                      uu___6.FStar_Syntax_Syntax.n in
-                    (match uu___5 with
-                     | FStar_Syntax_Syntax.Tm_abs (b::[], q, uu___6) ->
-                         let uu___7 = FStar_Syntax_Subst.open_term [b] q in
-                         (match uu___7 with
-                          | (bs, q1) ->
-                              let b1 =
-                                match bs with
-                                | b2::[] -> b2
-                                | uu___8 -> failwith "impossible" in
-                              let uu___8 = patterns q1 in
-                              (match uu___8 with
-                               | (pats, q2) ->
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     maybe_collect
-                                     (FStar_Pervasives_Native.Some
-                                        (QEx ([b1], pats, q2)))))
-                     | uu___6 -> FStar_Pervasives_Native.None)
-                | uu___3 -> FStar_Pervasives_Native.None))
-    and maybe_collect f1 =
-      match f1 with
-      | FStar_Pervasives_Native.Some (QAll (bs, pats, phi)) ->
-          let uu___ = destruct_sq_forall phi in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some (QAll (bs', pats', psi)) ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___1 -> FStar_Pervasives_Native.Some uu___1)
-                 (QAll
-                    ((FStar_Compiler_List.op_At bs bs'),
-                      (FStar_Compiler_List.op_At pats pats'), psi))
-           | uu___1 -> f1)
-      | FStar_Pervasives_Native.Some (QEx (bs, pats, phi)) ->
-          let uu___ = destruct_sq_exists phi in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some (QEx (bs', pats', psi)) ->
-               FStar_Compiler_Effect.op_Less_Bar
-                 (fun uu___1 -> FStar_Pervasives_Native.Some uu___1)
-                 (QEx
-                    ((FStar_Compiler_List.op_At bs bs'),
-                      (FStar_Compiler_List.op_At pats pats'), psi))
-           | uu___1 -> f1)
-      | uu___ -> f1 in
-    let phi = unmeta_monadic f in
-    let uu___ = destruct_base_conn phi in
-    FStar_Compiler_Util.catch_opt uu___
-      (fun uu___1 ->
-         let uu___2 = destruct_q_conn phi in
-         FStar_Compiler_Util.catch_opt uu___2
-           (fun uu___3 ->
-              let uu___4 = destruct_sq_base_conn phi in
-              FStar_Compiler_Util.catch_opt uu___4
-                (fun uu___5 ->
-                   let uu___6 = destruct_sq_forall phi in
-                   FStar_Compiler_Util.catch_opt uu___6
-                     (fun uu___7 ->
-                        let uu___8 = destruct_sq_exists phi in
-                        FStar_Compiler_Util.catch_opt uu___8
-                          (fun uu___9 -> FStar_Pervasives_Native.None)))))
-let (action_as_lb :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.action ->
-      FStar_Compiler_Range.range -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun eff_lid ->
-    fun a ->
-      fun pos ->
-        let lb =
-          let uu___ =
-            let uu___1 =
-              FStar_Syntax_Syntax.lid_as_fv a.FStar_Syntax_Syntax.action_name
-                FStar_Syntax_Syntax.delta_equational
-                FStar_Pervasives_Native.None in
-            FStar_Pervasives.Inr uu___1 in
-          let uu___1 =
-            let uu___2 =
-              FStar_Syntax_Syntax.mk_Total a.FStar_Syntax_Syntax.action_typ in
-            arrow a.FStar_Syntax_Syntax.action_params uu___2 in
-          let uu___2 =
-            abs a.FStar_Syntax_Syntax.action_params
-              a.FStar_Syntax_Syntax.action_defn FStar_Pervasives_Native.None in
-          close_univs_and_mk_letbinding FStar_Pervasives_Native.None uu___
-            a.FStar_Syntax_Syntax.action_univs uu___1
-            FStar_Parser_Const.effect_Tot_lid uu___2 [] pos in
-        {
-          FStar_Syntax_Syntax.sigel =
-            (FStar_Syntax_Syntax.Sig_let
-               ((false, [lb]), [a.FStar_Syntax_Syntax.action_name]));
-          FStar_Syntax_Syntax.sigrng =
-            ((a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos);
-          FStar_Syntax_Syntax.sigquals =
-            [FStar_Syntax_Syntax.Visible_default;
-            FStar_Syntax_Syntax.Action eff_lid];
-          FStar_Syntax_Syntax.sigmeta = FStar_Syntax_Syntax.default_sigmeta;
-          FStar_Syntax_Syntax.sigattrs = [];
-          FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-        }
-let (mk_reify :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let reify_ =
-      FStar_Syntax_Syntax.mk
-        (FStar_Syntax_Syntax.Tm_constant FStar_Const.Const_reify)
-        t.FStar_Syntax_Syntax.pos in
-    let uu___ =
-      let uu___1 =
-        let uu___2 = let uu___3 = FStar_Syntax_Syntax.as_arg t in [uu___3] in
-        (reify_, uu___2) in
-      FStar_Syntax_Syntax.Tm_app uu___1 in
-    FStar_Syntax_Syntax.mk uu___ t.FStar_Syntax_Syntax.pos
-let (mk_reflect :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let reflect_ =
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Ident.lid_of_str "Bogus.Effect" in
-          FStar_Const.Const_reflect uu___2 in
-        FStar_Syntax_Syntax.Tm_constant uu___1 in
-      FStar_Syntax_Syntax.mk uu___ t.FStar_Syntax_Syntax.pos in
-    let uu___ =
-      let uu___1 =
-        let uu___2 = let uu___3 = FStar_Syntax_Syntax.as_arg t in [uu___3] in
-        (reflect_, uu___2) in
-      FStar_Syntax_Syntax.Tm_app uu___1 in
-    FStar_Syntax_Syntax.mk uu___ t.FStar_Syntax_Syntax.pos
-let rec (delta_qualifier :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.delta_depth) =
-  fun t ->
-    let t1 = FStar_Syntax_Subst.compress t in
-    match t1.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_delayed uu___ -> failwith "Impossible"
-    | FStar_Syntax_Syntax.Tm_lazy i ->
-        let uu___ = unfold_lazy i in delta_qualifier uu___
-    | FStar_Syntax_Syntax.Tm_fvar fv -> fv.FStar_Syntax_Syntax.fv_delta
-    | FStar_Syntax_Syntax.Tm_bvar uu___ ->
-        FStar_Syntax_Syntax.delta_equational
-    | FStar_Syntax_Syntax.Tm_name uu___ ->
-        FStar_Syntax_Syntax.delta_equational
-    | FStar_Syntax_Syntax.Tm_match uu___ ->
-        FStar_Syntax_Syntax.delta_equational
-    | FStar_Syntax_Syntax.Tm_uvar uu___ ->
-        FStar_Syntax_Syntax.delta_equational
-    | FStar_Syntax_Syntax.Tm_unknown -> FStar_Syntax_Syntax.delta_equational
-    | FStar_Syntax_Syntax.Tm_type uu___ -> FStar_Syntax_Syntax.delta_constant
-    | FStar_Syntax_Syntax.Tm_quoted uu___ ->
-        FStar_Syntax_Syntax.delta_constant
-    | FStar_Syntax_Syntax.Tm_constant uu___ ->
-        FStar_Syntax_Syntax.delta_constant
-    | FStar_Syntax_Syntax.Tm_arrow uu___ ->
-        FStar_Syntax_Syntax.delta_constant
-    | FStar_Syntax_Syntax.Tm_uinst (t2, uu___) -> delta_qualifier t2
-    | FStar_Syntax_Syntax.Tm_refine
-        ({ FStar_Syntax_Syntax.ppname = uu___;
-           FStar_Syntax_Syntax.index = uu___1;
-           FStar_Syntax_Syntax.sort = t2;_},
-         uu___2)
-        -> delta_qualifier t2
-    | FStar_Syntax_Syntax.Tm_meta (t2, uu___) -> delta_qualifier t2
-    | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___, uu___1) ->
-        delta_qualifier t2
-    | FStar_Syntax_Syntax.Tm_app (t2, uu___) -> delta_qualifier t2
-    | FStar_Syntax_Syntax.Tm_abs (uu___, t2, uu___1) -> delta_qualifier t2
-    | FStar_Syntax_Syntax.Tm_let (uu___, t2) -> delta_qualifier t2
-let rec (incr_delta_depth :
-  FStar_Syntax_Syntax.delta_depth -> FStar_Syntax_Syntax.delta_depth) =
-  fun d ->
-    match d with
-    | FStar_Syntax_Syntax.Delta_constant_at_level i ->
-        FStar_Syntax_Syntax.Delta_constant_at_level (i + Prims.int_one)
-    | FStar_Syntax_Syntax.Delta_equational_at_level i ->
-        FStar_Syntax_Syntax.Delta_equational_at_level (i + Prims.int_one)
-    | FStar_Syntax_Syntax.Delta_abstract d1 -> incr_delta_depth d1
-let (incr_delta_qualifier :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.delta_depth) =
-  fun t -> let uu___ = delta_qualifier t in incr_delta_depth uu___
-let (is_unknown : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_unknown -> true
-    | uu___1 -> false
-let rec apply_last :
-  'uuuuu . ('uuuuu -> 'uuuuu) -> 'uuuuu Prims.list -> 'uuuuu Prims.list =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> failwith "apply_last: got empty list"
-      | a::[] -> let uu___ = f a in [uu___]
-      | x::xs -> let uu___ = apply_last f xs in x :: uu___
-let (dm4f_lid :
-  FStar_Syntax_Syntax.eff_decl -> Prims.string -> FStar_Ident.lident) =
-  fun ed ->
-    fun name ->
-      let p = FStar_Ident.path_of_lid ed.FStar_Syntax_Syntax.mname in
-      let p' =
-        apply_last
-          (fun s ->
-             Prims.op_Hat "_dm4f_" (Prims.op_Hat s (Prims.op_Hat "_" name)))
-          p in
-      FStar_Ident.lid_of_path p' FStar_Compiler_Range.dummyRange
-let (mk_list :
-  FStar_Syntax_Syntax.term ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.term Prims.list -> FStar_Syntax_Syntax.term)
-  =
-  fun typ ->
-    fun rng ->
-      fun l ->
-        let ctor l1 =
-          let uu___ =
-            let uu___1 =
-              FStar_Syntax_Syntax.lid_as_fv l1
-                FStar_Syntax_Syntax.delta_constant
-                (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor) in
-            FStar_Syntax_Syntax.Tm_fvar uu___1 in
-          FStar_Syntax_Syntax.mk uu___ rng in
-        let cons args pos =
-          let uu___ =
-            let uu___1 = ctor FStar_Parser_Const.cons_lid in
-            FStar_Syntax_Syntax.mk_Tm_uinst uu___1
-              [FStar_Syntax_Syntax.U_zero] in
-          FStar_Syntax_Syntax.mk_Tm_app uu___ args pos in
-        let nil args pos =
-          let uu___ =
-            let uu___1 = ctor FStar_Parser_Const.nil_lid in
-            FStar_Syntax_Syntax.mk_Tm_uinst uu___1
-              [FStar_Syntax_Syntax.U_zero] in
-          FStar_Syntax_Syntax.mk_Tm_app uu___ args pos in
-        let uu___ =
-          let uu___1 = let uu___2 = FStar_Syntax_Syntax.iarg typ in [uu___2] in
-          nil uu___1 rng in
-        FStar_Compiler_List.fold_right
-          (fun t ->
-             fun a ->
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Syntax.iarg typ in
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Syntax.as_arg t in
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Syntax.as_arg a in [uu___6] in
-                   uu___4 :: uu___5 in
-                 uu___2 :: uu___3 in
-               cons uu___1 t.FStar_Syntax_Syntax.pos) l uu___
-let rec eqlist :
-  'a .
-    ('a -> 'a -> Prims.bool) -> 'a Prims.list -> 'a Prims.list -> Prims.bool
-  =
-  fun eq ->
-    fun xs ->
-      fun ys ->
-        match (xs, ys) with
-        | ([], []) -> true
-        | (x::xs1, y::ys1) -> (eq x y) && (eqlist eq xs1 ys1)
-        | uu___ -> false
-let eqsum :
-  'a 'b .
-    ('a -> 'a -> Prims.bool) ->
-      ('b -> 'b -> Prims.bool) ->
-        ('a, 'b) FStar_Pervasives.either ->
-          ('a, 'b) FStar_Pervasives.either -> Prims.bool
-  =
-  fun e1 ->
-    fun e2 ->
-      fun x ->
-        fun y ->
-          match (x, y) with
-          | (FStar_Pervasives.Inl x1, FStar_Pervasives.Inl y1) -> e1 x1 y1
-          | (FStar_Pervasives.Inr x1, FStar_Pervasives.Inr y1) -> e2 x1 y1
-          | uu___ -> false
-let eqprod :
-  'a 'b .
-    ('a -> 'a -> Prims.bool) ->
-      ('b -> 'b -> Prims.bool) -> ('a * 'b) -> ('a * 'b) -> Prims.bool
-  =
-  fun e1 ->
-    fun e2 ->
-      fun x ->
-        fun y ->
-          match (x, y) with
-          | ((x1, x2), (y1, y2)) -> (e1 x1 y1) && (e2 x2 y2)
-let eqopt :
-  'a .
-    ('a -> 'a -> Prims.bool) ->
-      'a FStar_Pervasives_Native.option ->
-        'a FStar_Pervasives_Native.option -> Prims.bool
-  =
-  fun e ->
-    fun x ->
-      fun y ->
-        match (x, y) with
-        | (FStar_Pervasives_Native.Some x1, FStar_Pervasives_Native.Some y1)
-            -> e x1 y1
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-            true
-        | uu___ -> false
-let (debug_term_eq : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref false
-let (check : Prims.string -> Prims.bool -> Prims.bool) =
-  fun msg ->
-    fun cond ->
-      if cond
-      then true
-      else
-        ((let uu___2 = FStar_Compiler_Effect.op_Bang debug_term_eq in
-          if uu___2
-          then FStar_Compiler_Util.print1 ">>> term_eq failing: %s\n" msg
-          else ());
-         false)
-let (fail : Prims.string -> Prims.bool) = fun msg -> check msg false
-let rec (term_eq_dbg :
-  Prims.bool ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool)
-  =
-  fun dbg ->
-    fun t1 ->
-      fun t2 ->
-        let t11 = let uu___ = unmeta_safe t1 in canon_app uu___ in
-        let t21 = let uu___ = unmeta_safe t2 in canon_app uu___ in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = un_uinst t11 in FStar_Syntax_Subst.compress uu___3 in
-            uu___2.FStar_Syntax_Syntax.n in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = un_uinst t21 in FStar_Syntax_Subst.compress uu___4 in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___1, uu___2) in
-        match uu___ with
-        | (FStar_Syntax_Syntax.Tm_uinst uu___1, uu___2) ->
-            failwith "term_eq: impossible, should have been removed"
-        | (uu___1, FStar_Syntax_Syntax.Tm_uinst uu___2) ->
-            failwith "term_eq: impossible, should have been removed"
-        | (FStar_Syntax_Syntax.Tm_delayed uu___1, uu___2) ->
-            failwith "term_eq: impossible, should have been removed"
-        | (uu___1, FStar_Syntax_Syntax.Tm_delayed uu___2) ->
-            failwith "term_eq: impossible, should have been removed"
-        | (FStar_Syntax_Syntax.Tm_ascribed uu___1, uu___2) ->
-            failwith "term_eq: impossible, should have been removed"
-        | (uu___1, FStar_Syntax_Syntax.Tm_ascribed uu___2) ->
-            failwith "term_eq: impossible, should have been removed"
-        | (FStar_Syntax_Syntax.Tm_bvar x, FStar_Syntax_Syntax.Tm_bvar y) ->
-            check "bvar"
-              (x.FStar_Syntax_Syntax.index = y.FStar_Syntax_Syntax.index)
-        | (FStar_Syntax_Syntax.Tm_name x, FStar_Syntax_Syntax.Tm_name y) ->
-            check "name"
-              (x.FStar_Syntax_Syntax.index = y.FStar_Syntax_Syntax.index)
-        | (FStar_Syntax_Syntax.Tm_fvar x, FStar_Syntax_Syntax.Tm_fvar y) ->
-            let uu___1 = FStar_Syntax_Syntax.fv_eq x y in check "fvar" uu___1
-        | (FStar_Syntax_Syntax.Tm_constant c1,
-           FStar_Syntax_Syntax.Tm_constant c2) ->
-            let uu___1 = FStar_Const.eq_const c1 c2 in check "const" uu___1
-        | (FStar_Syntax_Syntax.Tm_type uu___1, FStar_Syntax_Syntax.Tm_type
-           uu___2) -> true
-        | (FStar_Syntax_Syntax.Tm_abs (b1, t12, k1),
-           FStar_Syntax_Syntax.Tm_abs (b2, t22, k2)) ->
-            (let uu___1 = eqlist (binder_eq_dbg dbg) b1 b2 in
-             check "abs binders" uu___1) &&
-              (let uu___1 = term_eq_dbg dbg t12 t22 in
-               check "abs bodies" uu___1)
-        | (FStar_Syntax_Syntax.Tm_arrow (b1, c1),
-           FStar_Syntax_Syntax.Tm_arrow (b2, c2)) ->
-            (let uu___1 = eqlist (binder_eq_dbg dbg) b1 b2 in
-             check "arrow binders" uu___1) &&
-              (let uu___1 = comp_eq_dbg dbg c1 c2 in
-               check "arrow comp" uu___1)
-        | (FStar_Syntax_Syntax.Tm_refine (b1, t12),
-           FStar_Syntax_Syntax.Tm_refine (b2, t22)) ->
-            (let uu___1 =
-               term_eq_dbg dbg b1.FStar_Syntax_Syntax.sort
-                 b2.FStar_Syntax_Syntax.sort in
-             check "refine bv sort" uu___1) &&
-              (let uu___1 = term_eq_dbg dbg t12 t22 in
-               check "refine formula" uu___1)
-        | (FStar_Syntax_Syntax.Tm_app (f1, a1), FStar_Syntax_Syntax.Tm_app
-           (f2, a2)) ->
-            (let uu___1 = term_eq_dbg dbg f1 f2 in check "app head" uu___1)
-              &&
-              (let uu___1 = eqlist (arg_eq_dbg dbg) a1 a2 in
-               check "app args" uu___1)
-        | (FStar_Syntax_Syntax.Tm_match
-           (t12, FStar_Pervasives_Native.None, bs1, uu___1),
-           FStar_Syntax_Syntax.Tm_match
-           (t22, FStar_Pervasives_Native.None, bs2, uu___2)) ->
-            (let uu___3 = term_eq_dbg dbg t12 t22 in
-             check "match head" uu___3) &&
-              (let uu___3 = eqlist (branch_eq_dbg dbg) bs1 bs2 in
-               check "match branches" uu___3)
-        | (FStar_Syntax_Syntax.Tm_lazy uu___1, uu___2) ->
-            let uu___3 =
-              let uu___4 = unlazy t11 in term_eq_dbg dbg uu___4 t21 in
-            check "lazy_l" uu___3
-        | (uu___1, FStar_Syntax_Syntax.Tm_lazy uu___2) ->
-            let uu___3 =
-              let uu___4 = unlazy t21 in term_eq_dbg dbg t11 uu___4 in
-            check "lazy_r" uu___3
-        | (FStar_Syntax_Syntax.Tm_let ((b1, lbs1), t12),
-           FStar_Syntax_Syntax.Tm_let ((b2, lbs2), t22)) ->
-            ((check "let flag" (b1 = b2)) &&
-               (let uu___1 = eqlist (letbinding_eq_dbg dbg) lbs1 lbs2 in
-                check "let lbs" uu___1))
-              &&
-              (let uu___1 = term_eq_dbg dbg t12 t22 in
-               check "let body" uu___1)
-        | (FStar_Syntax_Syntax.Tm_uvar (u1, uu___1),
-           FStar_Syntax_Syntax.Tm_uvar (u2, uu___2)) ->
-            check "uvar"
-              (u1.FStar_Syntax_Syntax.ctx_uvar_head =
-                 u2.FStar_Syntax_Syntax.ctx_uvar_head)
-        | (FStar_Syntax_Syntax.Tm_quoted (qt1, qi1),
-           FStar_Syntax_Syntax.Tm_quoted (qt2, qi2)) ->
-            (let uu___1 = let uu___2 = eq_quoteinfo qi1 qi2 in uu___2 = Equal in
-             check "tm_quoted qi" uu___1) &&
-              (let uu___1 = term_eq_dbg dbg qt1 qt2 in
-               check "tm_quoted payload" uu___1)
-        | (FStar_Syntax_Syntax.Tm_meta (t12, m1), FStar_Syntax_Syntax.Tm_meta
-           (t22, m2)) ->
-            (match (m1, m2) with
-             | (FStar_Syntax_Syntax.Meta_monadic (n1, ty1),
-                FStar_Syntax_Syntax.Meta_monadic (n2, ty2)) ->
-                 (let uu___1 = FStar_Ident.lid_equals n1 n2 in
-                  check "meta_monadic lid" uu___1) &&
-                   (let uu___1 = term_eq_dbg dbg ty1 ty2 in
-                    check "meta_monadic type" uu___1)
-             | (FStar_Syntax_Syntax.Meta_monadic_lift (s1, t13, ty1),
-                FStar_Syntax_Syntax.Meta_monadic_lift (s2, t23, ty2)) ->
-                 ((let uu___1 = FStar_Ident.lid_equals s1 s2 in
-                   check "meta_monadic_lift src" uu___1) &&
-                    (let uu___1 = FStar_Ident.lid_equals t13 t23 in
-                     check "meta_monadic_lift tgt" uu___1))
-                   &&
-                   (let uu___1 = term_eq_dbg dbg ty1 ty2 in
-                    check "meta_monadic_lift type" uu___1)
-             | uu___1 -> fail "metas")
-        | (FStar_Syntax_Syntax.Tm_unknown, uu___1) -> fail "unk"
-        | (uu___1, FStar_Syntax_Syntax.Tm_unknown) -> fail "unk"
-        | (FStar_Syntax_Syntax.Tm_bvar uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_name uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_fvar uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_constant uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_type uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_abs uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_arrow uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_refine uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_app uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_match uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_let uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_uvar uu___1, uu___2) -> fail "bottom"
-        | (FStar_Syntax_Syntax.Tm_meta uu___1, uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_bvar uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_name uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_fvar uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_constant uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_type uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_abs uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_arrow uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_refine uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_app uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_match uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_let uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_uvar uu___2) -> fail "bottom"
-        | (uu___1, FStar_Syntax_Syntax.Tm_meta uu___2) -> fail "bottom"
-and (arg_eq_dbg :
-  Prims.bool ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option) ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option) ->
-        Prims.bool)
-  =
-  fun dbg ->
-    fun a1 ->
-      fun a2 ->
-        eqprod
-          (fun t1 ->
-             fun t2 ->
-               let uu___ = term_eq_dbg dbg t1 t2 in check "arg tm" uu___)
-          (fun q1 ->
-             fun q2 ->
-               let uu___ = let uu___1 = eq_aqual q1 q2 in uu___1 = Equal in
-               check "arg qual" uu___) a1 a2
-and (binder_eq_dbg :
-  Prims.bool ->
-    FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder -> Prims.bool)
-  =
-  fun dbg ->
-    fun b1 ->
-      fun b2 ->
-        ((let uu___ =
-            term_eq_dbg dbg
-              (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-              (b2.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-          check "binder_sort" uu___) &&
-           (let uu___ =
-              let uu___1 =
-                eq_bqual b1.FStar_Syntax_Syntax.binder_qual
-                  b2.FStar_Syntax_Syntax.binder_qual in
-              uu___1 = Equal in
-            check "binder qual" uu___))
-          &&
-          (let uu___ =
-             eqlist (term_eq_dbg dbg) b1.FStar_Syntax_Syntax.binder_attrs
-               b2.FStar_Syntax_Syntax.binder_attrs in
-           check "binder attrs" uu___)
-and (comp_eq_dbg :
-  Prims.bool ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool)
-  =
-  fun dbg ->
-    fun c1 ->
-      fun c2 ->
-        let uu___ = comp_eff_name_res_and_args c1 in
-        match uu___ with
-        | (eff1, res1, args1) ->
-            let uu___1 = comp_eff_name_res_and_args c2 in
-            (match uu___1 with
-             | (eff2, res2, args2) ->
-                 ((let uu___2 = FStar_Ident.lid_equals eff1 eff2 in
-                   check "comp eff" uu___2) &&
-                    (let uu___2 = term_eq_dbg dbg res1 res2 in
-                     check "comp result typ" uu___2))
-                   && true)
-and (branch_eq_dbg :
-  Prims.bool ->
-    (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax) ->
-      (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-        FStar_Syntax_Syntax.syntax) -> Prims.bool)
-  =
-  fun dbg ->
-    fun uu___ ->
-      fun uu___1 ->
-        match (uu___, uu___1) with
-        | ((p1, w1, t1), (p2, w2, t2)) ->
-            ((let uu___2 = FStar_Syntax_Syntax.eq_pat p1 p2 in
-              check "branch pat" uu___2) &&
-               (let uu___2 = term_eq_dbg dbg t1 t2 in
-                check "branch body" uu___2))
-              &&
-              (let uu___2 =
-                 match (w1, w2) with
-                 | (FStar_Pervasives_Native.Some x,
-                    FStar_Pervasives_Native.Some y) -> term_eq_dbg dbg x y
-                 | (FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.None) -> true
-                 | uu___3 -> false in
-               check "branch when" uu___2)
-and (letbinding_eq_dbg :
-  Prims.bool ->
-    FStar_Syntax_Syntax.letbinding ->
-      FStar_Syntax_Syntax.letbinding -> Prims.bool)
-  =
-  fun dbg ->
-    fun lb1 ->
-      fun lb2 ->
-        ((let uu___ =
-            eqsum (fun bv1 -> fun bv2 -> true) FStar_Syntax_Syntax.fv_eq
-              lb1.FStar_Syntax_Syntax.lbname lb2.FStar_Syntax_Syntax.lbname in
-          check "lb bv" uu___) &&
-           (let uu___ =
-              term_eq_dbg dbg lb1.FStar_Syntax_Syntax.lbtyp
-                lb2.FStar_Syntax_Syntax.lbtyp in
-            check "lb typ" uu___))
-          &&
-          (let uu___ =
-             term_eq_dbg dbg lb1.FStar_Syntax_Syntax.lbdef
-               lb2.FStar_Syntax_Syntax.lbdef in
-           check "lb def" uu___)
-let (term_eq :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t1 ->
-    fun t2 ->
-      let r =
-        let uu___ = FStar_Compiler_Effect.op_Bang debug_term_eq in
-        term_eq_dbg uu___ t1 t2 in
-      FStar_Compiler_Effect.op_Colon_Equals debug_term_eq false; r
-let rec (sizeof : FStar_Syntax_Syntax.term -> Prims.int) =
-  fun t ->
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress t in sizeof uu___2 in
-        Prims.int_one + uu___1
-    | FStar_Syntax_Syntax.Tm_bvar bv ->
-        let uu___ = sizeof bv.FStar_Syntax_Syntax.sort in
-        Prims.int_one + uu___
-    | FStar_Syntax_Syntax.Tm_name bv ->
-        let uu___ = sizeof bv.FStar_Syntax_Syntax.sort in
-        Prims.int_one + uu___
-    | FStar_Syntax_Syntax.Tm_uinst (t1, us) ->
-        let uu___ = sizeof t1 in (FStar_Compiler_List.length us) + uu___
-    | FStar_Syntax_Syntax.Tm_abs (bs, t1, uu___) ->
-        let uu___1 = sizeof t1 in
-        let uu___2 =
-          FStar_Compiler_List.fold_left
-            (fun acc ->
-               fun b ->
-                 let uu___3 =
-                   sizeof
-                     (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                 acc + uu___3) Prims.int_zero bs in
-        uu___1 + uu___2
-    | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-        let uu___ = sizeof hd in
-        let uu___1 =
-          FStar_Compiler_List.fold_left
-            (fun acc ->
-               fun uu___2 ->
-                 match uu___2 with
-                 | (arg, uu___3) -> let uu___4 = sizeof arg in acc + uu___4)
-            Prims.int_zero args in
-        uu___ + uu___1
-    | uu___ -> Prims.int_one
-let (is_fvar : FStar_Ident.lident -> FStar_Syntax_Syntax.term -> Prims.bool)
-  =
-  fun lid ->
-    fun t ->
-      let uu___ = let uu___1 = un_uinst t in uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          FStar_Syntax_Syntax.fv_eq_lid fv lid
-      | uu___1 -> false
-let (is_synth_by_tactic : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t -> is_fvar FStar_Parser_Const.synth_lid t
-let (has_attribute :
-  FStar_Syntax_Syntax.attribute Prims.list ->
-    FStar_Ident.lident -> Prims.bool)
-  =
-  fun attrs -> fun attr -> FStar_Compiler_Util.for_some (is_fvar attr) attrs
-let (get_attribute :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.attribute Prims.list ->
-      FStar_Syntax_Syntax.args FStar_Pervasives_Native.option)
-  =
-  fun attr ->
-    fun attrs ->
-      FStar_Compiler_List.tryPick
-        (fun t ->
-           let uu___ = head_and_args t in
-           match uu___ with
-           | (head, args) ->
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress head in
-                 uu___2.FStar_Syntax_Syntax.n in
-               (match uu___1 with
-                | FStar_Syntax_Syntax.Tm_fvar fv when
-                    FStar_Syntax_Syntax.fv_eq_lid fv attr ->
-                    FStar_Pervasives_Native.Some args
-                | uu___2 -> FStar_Pervasives_Native.None)) attrs
-let (remove_attr :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.attribute Prims.list ->
-      FStar_Syntax_Syntax.attribute Prims.list)
-  =
-  fun attr ->
-    fun attrs ->
-      FStar_Compiler_List.filter
-        (fun a -> let uu___ = is_fvar attr a in Prims.op_Negation uu___)
-        attrs
-let (process_pragma :
-  FStar_Syntax_Syntax.pragma -> FStar_Compiler_Range.range -> unit) =
-  fun p ->
-    fun r ->
-      FStar_Errors.set_option_warning_callback_range
-        (FStar_Pervasives_Native.Some r);
-      (let set_options s =
-         let uu___1 = FStar_Options.set_options s in
-         match uu___1 with
-         | FStar_Getopt.Success -> ()
-         | FStar_Getopt.Help ->
-             FStar_Errors.raise_error
-               (FStar_Errors.Fatal_FailToProcessPragma,
-                 "Failed to process pragma: use 'fstar --help' to see which options are available")
-               r
-         | FStar_Getopt.Error s1 ->
-             FStar_Errors.raise_error
-               (FStar_Errors.Fatal_FailToProcessPragma,
-                 (Prims.op_Hat "Failed to process pragma: " s1)) r in
-       match p with
-       | FStar_Syntax_Syntax.SetOptions o -> set_options o
-       | FStar_Syntax_Syntax.ResetOptions sopt ->
-           ((let uu___2 = FStar_Options.restore_cmd_line_options false in
-             FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()));
-            (match sopt with
-             | FStar_Pervasives_Native.None -> ()
-             | FStar_Pervasives_Native.Some s -> set_options s))
-       | FStar_Syntax_Syntax.PushOptions sopt ->
-           (FStar_Options.internal_push ();
-            (match sopt with
-             | FStar_Pervasives_Native.None -> ()
-             | FStar_Pervasives_Native.Some s -> set_options s))
-       | FStar_Syntax_Syntax.RestartSolver -> ()
-       | FStar_Syntax_Syntax.PopOptions ->
-           let uu___1 = FStar_Options.internal_pop () in
-           if uu___1
-           then ()
-           else
-             FStar_Errors.raise_error
-               (FStar_Errors.Fatal_FailToProcessPragma,
-                 "Cannot #pop-options, stack would become empty") r
-       | FStar_Syntax_Syntax.PrintEffectsGraph -> ())
-let rec (unbound_variables :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.bv Prims.list)
-  =
-  fun tm ->
-    let t = FStar_Syntax_Subst.compress tm in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_delayed uu___ -> failwith "Impossible"
-    | FStar_Syntax_Syntax.Tm_name x -> []
-    | FStar_Syntax_Syntax.Tm_uvar uu___ -> []
-    | FStar_Syntax_Syntax.Tm_type u -> []
-    | FStar_Syntax_Syntax.Tm_bvar x -> [x]
-    | FStar_Syntax_Syntax.Tm_fvar uu___ -> []
-    | FStar_Syntax_Syntax.Tm_constant uu___ -> []
-    | FStar_Syntax_Syntax.Tm_lazy uu___ -> []
-    | FStar_Syntax_Syntax.Tm_unknown -> []
-    | FStar_Syntax_Syntax.Tm_uinst (t1, us) -> unbound_variables t1
-    | FStar_Syntax_Syntax.Tm_abs (bs, t1, uu___) ->
-        let uu___1 = FStar_Syntax_Subst.open_term bs t1 in
-        (match uu___1 with
-         | (bs1, t2) ->
-             let uu___2 =
-               FStar_Compiler_List.collect
-                 (fun b ->
-                    unbound_variables
-                      (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)
-                 bs1 in
-             let uu___3 = unbound_variables t2 in
-             FStar_Compiler_List.op_At uu___2 uu___3)
-    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-        let uu___ = FStar_Syntax_Subst.open_comp bs c in
-        (match uu___ with
-         | (bs1, c1) ->
-             let uu___1 =
-               FStar_Compiler_List.collect
-                 (fun b ->
-                    unbound_variables
-                      (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)
-                 bs1 in
-             let uu___2 = unbound_variables_comp c1 in
-             FStar_Compiler_List.op_At uu___1 uu___2)
-    | FStar_Syntax_Syntax.Tm_refine (b, t1) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Syntax.mk_binder b in [uu___2] in
-          FStar_Syntax_Subst.open_term uu___1 t1 in
-        (match uu___ with
-         | (bs, t2) ->
-             let uu___1 =
-               FStar_Compiler_List.collect
-                 (fun b1 ->
-                    unbound_variables
-                      (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)
-                 bs in
-             let uu___2 = unbound_variables t2 in
-             FStar_Compiler_List.op_At uu___1 uu___2)
-    | FStar_Syntax_Syntax.Tm_app (t1, args) ->
-        let uu___ =
-          FStar_Compiler_List.collect
-            (fun uu___1 ->
-               match uu___1 with | (x, uu___2) -> unbound_variables x) args in
-        let uu___1 = unbound_variables t1 in
-        FStar_Compiler_List.op_At uu___ uu___1
-    | FStar_Syntax_Syntax.Tm_match (t1, asc_opt, pats, uu___) ->
-        let uu___1 = unbound_variables t1 in
-        let uu___2 =
-          let uu___3 =
-            match asc_opt with
-            | FStar_Pervasives_Native.None -> []
-            | FStar_Pervasives_Native.Some (b, asc) ->
-                let uu___4 = FStar_Syntax_Subst.open_ascription [b] asc in
-                (match uu___4 with
-                 | (bs, asc1) ->
-                     let uu___5 =
-                       FStar_Compiler_List.collect
-                         (fun b1 ->
-                            unbound_variables
-                              (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)
-                         bs in
-                     let uu___6 = unbound_variables_ascription asc1 in
-                     FStar_Compiler_List.op_At uu___5 uu___6) in
-          let uu___4 =
-            FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.collect
-                 (fun br ->
-                    let uu___5 = FStar_Syntax_Subst.open_branch br in
-                    match uu___5 with
-                    | (p, wopt, t2) ->
-                        let uu___6 = unbound_variables t2 in
-                        let uu___7 =
-                          match wopt with
-                          | FStar_Pervasives_Native.None -> []
-                          | FStar_Pervasives_Native.Some t3 ->
-                              unbound_variables t3 in
-                        FStar_Compiler_List.op_At uu___6 uu___7)) in
-          FStar_Compiler_List.op_At uu___3 uu___4 in
-        FStar_Compiler_List.op_At uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, asc, uu___) ->
-        let uu___1 = unbound_variables t1 in
-        let uu___2 = unbound_variables_ascription asc in
-        FStar_Compiler_List.op_At uu___1 uu___2
-    | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), t1) ->
-        let uu___ = unbound_variables lb.FStar_Syntax_Syntax.lbtyp in
-        let uu___1 =
-          let uu___2 = unbound_variables lb.FStar_Syntax_Syntax.lbdef in
-          let uu___3 =
-            match lb.FStar_Syntax_Syntax.lbname with
-            | FStar_Pervasives.Inr uu___4 -> unbound_variables t1
-            | FStar_Pervasives.Inl bv ->
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_Syntax.mk_binder bv in [uu___6] in
-                  FStar_Syntax_Subst.open_term uu___5 t1 in
-                (match uu___4 with | (uu___5, t2) -> unbound_variables t2) in
-          FStar_Compiler_List.op_At uu___2 uu___3 in
-        FStar_Compiler_List.op_At uu___ uu___1
-    | FStar_Syntax_Syntax.Tm_let ((uu___, lbs), t1) ->
-        let uu___1 = FStar_Syntax_Subst.open_let_rec lbs t1 in
-        (match uu___1 with
-         | (lbs1, t2) ->
-             let uu___2 = unbound_variables t2 in
-             let uu___3 =
-               FStar_Compiler_List.collect
-                 (fun lb ->
-                    let uu___4 =
-                      unbound_variables lb.FStar_Syntax_Syntax.lbtyp in
-                    let uu___5 =
-                      unbound_variables lb.FStar_Syntax_Syntax.lbdef in
-                    FStar_Compiler_List.op_At uu___4 uu___5) lbs1 in
-             FStar_Compiler_List.op_At uu___2 uu___3)
-    | FStar_Syntax_Syntax.Tm_quoted (tm1, qi) ->
-        (match qi.FStar_Syntax_Syntax.qkind with
-         | FStar_Syntax_Syntax.Quote_static -> []
-         | FStar_Syntax_Syntax.Quote_dynamic -> unbound_variables tm1)
-    | FStar_Syntax_Syntax.Tm_meta (t1, m) ->
-        let uu___ = unbound_variables t1 in
-        let uu___1 =
-          match m with
-          | FStar_Syntax_Syntax.Meta_pattern (uu___2, args) ->
-              FStar_Compiler_List.collect
-                (FStar_Compiler_List.collect
-                   (fun uu___3 ->
-                      match uu___3 with | (a, uu___4) -> unbound_variables a))
-                args
-          | FStar_Syntax_Syntax.Meta_monadic_lift (uu___2, uu___3, t') ->
-              unbound_variables t'
-          | FStar_Syntax_Syntax.Meta_monadic (uu___2, t') ->
-              unbound_variables t'
-          | FStar_Syntax_Syntax.Meta_labeled uu___2 -> []
-          | FStar_Syntax_Syntax.Meta_desugared uu___2 -> []
-          | FStar_Syntax_Syntax.Meta_named uu___2 -> [] in
-        FStar_Compiler_List.op_At uu___ uu___1
-and (unbound_variables_ascription :
-  ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-    FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option * Prims.bool)
-    -> FStar_Syntax_Syntax.bv Prims.list)
-  =
-  fun asc ->
-    let uu___ = asc in
-    match uu___ with
-    | (asc1, topt, uu___1) ->
-        let uu___2 =
-          match asc1 with
-          | FStar_Pervasives.Inl t2 -> unbound_variables t2
-          | FStar_Pervasives.Inr c2 -> unbound_variables_comp c2 in
-        let uu___3 =
-          match topt with
-          | FStar_Pervasives_Native.None -> []
-          | FStar_Pervasives_Native.Some tac -> unbound_variables tac in
-        FStar_Compiler_List.op_At uu___2 uu___3
-and (unbound_variables_comp :
-  FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.bv Prims.list) =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t -> unbound_variables t
-    | FStar_Syntax_Syntax.GTotal t -> unbound_variables t
-    | FStar_Syntax_Syntax.Comp ct ->
-        let uu___ = unbound_variables ct.FStar_Syntax_Syntax.result_typ in
-        let uu___1 =
-          FStar_Compiler_List.collect
-            (fun uu___2 ->
-               match uu___2 with | (a, uu___3) -> unbound_variables a)
-            ct.FStar_Syntax_Syntax.effect_args in
-        FStar_Compiler_List.op_At uu___ uu___1
-let (extract_attr' :
-  FStar_Ident.lid ->
-    FStar_Syntax_Syntax.term Prims.list ->
-      (FStar_Syntax_Syntax.term Prims.list * FStar_Syntax_Syntax.args)
-        FStar_Pervasives_Native.option)
-  =
-  fun attr_lid ->
-    fun attrs ->
-      let rec aux acc attrs1 =
-        match attrs1 with
-        | [] -> FStar_Pervasives_Native.None
-        | h::t ->
-            let uu___ = head_and_args h in
-            (match uu___ with
-             | (head, args) ->
-                 let uu___1 =
-                   let uu___2 = FStar_Syntax_Subst.compress head in
-                   uu___2.FStar_Syntax_Syntax.n in
-                 (match uu___1 with
-                  | FStar_Syntax_Syntax.Tm_fvar fv when
-                      FStar_Syntax_Syntax.fv_eq_lid fv attr_lid ->
-                      let attrs' = FStar_Compiler_List.rev_acc acc t in
-                      FStar_Pervasives_Native.Some (attrs', args)
-                  | uu___2 -> aux (h :: acc) t)) in
-      aux [] attrs
-let (extract_attr :
-  FStar_Ident.lid ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.args)
-        FStar_Pervasives_Native.option)
-  =
-  fun attr_lid ->
-    fun se ->
-      let uu___ = extract_attr' attr_lid se.FStar_Syntax_Syntax.sigattrs in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (attrs', t) ->
-          FStar_Pervasives_Native.Some
-            ({
-               FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-               FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-               FStar_Syntax_Syntax.sigquals =
-                 (se.FStar_Syntax_Syntax.sigquals);
-               FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-               FStar_Syntax_Syntax.sigattrs = attrs';
-               FStar_Syntax_Syntax.sigopts = (se.FStar_Syntax_Syntax.sigopts)
-             }, t)
-let (is_smt_lemma : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-        (match c.FStar_Syntax_Syntax.n with
-         | FStar_Syntax_Syntax.Comp ct when
-             FStar_Ident.lid_equals ct.FStar_Syntax_Syntax.effect_name
-               FStar_Parser_Const.effect_Lemma_lid
-             ->
-             (match ct.FStar_Syntax_Syntax.effect_args with
-              | _req::_ens::(pats, uu___2)::uu___3 ->
-                  let pats' = unmeta pats in
-                  let uu___4 = head_and_args pats' in
-                  (match uu___4 with
-                   | (head, uu___5) ->
-                       let uu___6 =
-                         let uu___7 = un_uinst head in
-                         uu___7.FStar_Syntax_Syntax.n in
-                       (match uu___6 with
-                        | FStar_Syntax_Syntax.Tm_fvar fv ->
-                            FStar_Syntax_Syntax.fv_eq_lid fv
-                              FStar_Parser_Const.cons_lid
-                        | uu___7 -> false))
-              | uu___2 -> false)
-         | uu___2 -> false)
-    | uu___1 -> false
-let rec (list_elements :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term Prims.list FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    let uu___ = let uu___1 = unmeta e in head_and_args uu___1 in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = un_uinst head in uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2) when
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.nil_lid ->
-             FStar_Pervasives_Native.Some []
-         | (FStar_Syntax_Syntax.Tm_fvar fv,
-            uu___2::(hd, uu___3)::(tl, uu___4)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid ->
-             let uu___5 =
-               let uu___6 =
-                 let uu___7 = list_elements tl in
-                 FStar_Compiler_Util.must uu___7 in
-               hd :: uu___6 in
-             FStar_Pervasives_Native.Some uu___5
-         | uu___2 -> FStar_Pervasives_Native.None)
-let (unthunk : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_abs (b::[], e, uu___1) ->
-        let uu___2 = FStar_Syntax_Subst.open_term [b] e in
-        (match uu___2 with
-         | (bs, e1) ->
-             let b1 = FStar_Compiler_List.hd bs in
-             let uu___3 = is_free_in b1.FStar_Syntax_Syntax.binder_bv e1 in
-             if uu___3
-             then
-               let uu___4 =
-                 let uu___5 = FStar_Syntax_Syntax.as_arg exp_unit in [uu___5] in
-               mk_app t uu___4
-             else e1)
-    | uu___1 ->
-        let uu___2 =
-          let uu___3 = FStar_Syntax_Syntax.as_arg exp_unit in [uu___3] in
-        mk_app t uu___2
-let (unthunk_lemma_post :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) = fun t -> unthunk t
-let (smt_lemma_as_forall :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.universe Prims.list)
-      -> FStar_Syntax_Syntax.term)
-  =
-  fun t ->
-    fun universe_of_binders ->
-      let list_elements1 e =
-        let uu___ = list_elements e in
-        match uu___ with
-        | FStar_Pervasives_Native.Some l -> l
-        | FStar_Pervasives_Native.None ->
-            (FStar_Errors.log_issue e.FStar_Syntax_Syntax.pos
-               (FStar_Errors.Warning_NonListLiteralSMTPattern,
-                 "SMT pattern is not a list literal; ignoring the pattern");
-             []) in
-      let one_pat p =
-        let uu___ =
-          let uu___1 = unmeta p in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1 head_and_args in
-        match uu___ with
-        | (head, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = un_uinst head in uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv, (uu___2, uu___3)::arg::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.smtpat_lid
-                 -> arg
-             | uu___2 ->
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = tts p in
-                     FStar_Compiler_Util.format1
-                       "Not an atomic SMT pattern: %s; patterns on lemmas must be a list of simple SMTPat's or a single SMTPatOr containing a list of lists of patterns"
-                       uu___5 in
-                   (FStar_Errors.Error_IllSMTPat, uu___4) in
-                 FStar_Errors.raise_error uu___3 p.FStar_Syntax_Syntax.pos) in
-      let lemma_pats p =
-        let elts = list_elements1 p in
-        let smt_pat_or t1 =
-          let uu___ =
-            let uu___1 = unmeta t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1 head_and_args in
-          match uu___ with
-          | (head, args) ->
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = un_uinst head in uu___3.FStar_Syntax_Syntax.n in
-                (uu___2, args) in
-              (match uu___1 with
-               | (FStar_Syntax_Syntax.Tm_fvar fv, (e, uu___2)::[]) when
-                   FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.smtpatOr_lid
-                   -> FStar_Pervasives_Native.Some e
-               | uu___2 -> FStar_Pervasives_Native.None) in
-        match elts with
-        | t1::[] ->
-            let uu___ = smt_pat_or t1 in
-            (match uu___ with
-             | FStar_Pervasives_Native.Some e ->
-                 let uu___1 = list_elements1 e in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___1
-                   (FStar_Compiler_List.map
-                      (fun branch1 ->
-                         let uu___2 = list_elements1 branch1 in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___2
-                           (FStar_Compiler_List.map one_pat)))
-             | uu___1 ->
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater elts
-                     (FStar_Compiler_List.map one_pat) in
-                 [uu___2])
-        | uu___ ->
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater elts
-                (FStar_Compiler_List.map one_pat) in
-            [uu___1] in
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress t in
-          uu___2.FStar_Syntax_Syntax.n in
-        match uu___1 with
-        | FStar_Syntax_Syntax.Tm_arrow (binders, c) ->
-            let uu___2 = FStar_Syntax_Subst.open_comp binders c in
-            (match uu___2 with
-             | (binders1, c1) ->
-                 (match c1.FStar_Syntax_Syntax.n with
-                  | FStar_Syntax_Syntax.Comp
-                      { FStar_Syntax_Syntax.comp_univs = uu___3;
-                        FStar_Syntax_Syntax.effect_name = uu___4;
-                        FStar_Syntax_Syntax.result_typ = uu___5;
-                        FStar_Syntax_Syntax.effect_args =
-                          (pre, uu___6)::(post, uu___7)::(pats, uu___8)::[];
-                        FStar_Syntax_Syntax.flags = uu___9;_}
-                      ->
-                      let uu___10 = lemma_pats pats in
-                      (binders1, pre, post, uu___10)
-                  | uu___3 -> failwith "impos"))
-        | uu___2 -> failwith "Impos" in
-      match uu___ with
-      | (binders, pre, post, patterns) ->
-          let post1 = unthunk_lemma_post post in
-          let body =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = mk_imp pre post1 in
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_Syntax.binders_to_names binders in
-                    (uu___6, patterns) in
-                  FStar_Syntax_Syntax.Meta_pattern uu___5 in
-                (uu___3, uu___4) in
-              FStar_Syntax_Syntax.Tm_meta uu___2 in
-            FStar_Syntax_Syntax.mk uu___1 t.FStar_Syntax_Syntax.pos in
-          let quant =
-            let uu___1 = universe_of_binders binders in
-            FStar_Compiler_List.fold_right2
-              (fun b ->
-                 fun u ->
-                   fun out -> mk_forall u b.FStar_Syntax_Syntax.binder_bv out)
-              binders uu___1 body in
-          quant
-let (effect_sig_ts :
-  FStar_Syntax_Syntax.effect_signature -> FStar_Syntax_Syntax.tscheme) =
-  fun sig1 ->
-    match sig1 with
-    | FStar_Syntax_Syntax.Layered_eff_sig (uu___, ts) -> ts
-    | FStar_Syntax_Syntax.WP_eff_sig ts -> ts
-let (apply_eff_sig :
-  (FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme) ->
-    FStar_Syntax_Syntax.effect_signature ->
-      FStar_Syntax_Syntax.effect_signature)
-  =
-  fun f ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Syntax_Syntax.Layered_eff_sig (n, ts) ->
-          let uu___1 = let uu___2 = f ts in (n, uu___2) in
-          FStar_Syntax_Syntax.Layered_eff_sig uu___1
-      | FStar_Syntax_Syntax.WP_eff_sig ts ->
-          let uu___1 = f ts in FStar_Syntax_Syntax.WP_eff_sig uu___1
-let (eff_decl_of_new_effect :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.eff_decl) =
-  fun se ->
-    match se.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_new_effect ne -> ne
-    | uu___ -> failwith "eff_decl_of_new_effect: not a Sig_new_effect"
-let (is_layered : FStar_Syntax_Syntax.eff_decl -> Prims.bool) =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Layered_eff uu___ -> true
-    | uu___ -> false
-let (is_dm4f : FStar_Syntax_Syntax.eff_decl -> Prims.bool) =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.DM4F_eff uu___ -> true
-    | uu___ -> false
-let (apply_wp_eff_combinators :
-  (FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme) ->
-    FStar_Syntax_Syntax.wp_eff_combinators ->
-      FStar_Syntax_Syntax.wp_eff_combinators)
-  =
-  fun f ->
-    fun combs ->
-      let uu___ = f combs.FStar_Syntax_Syntax.ret_wp in
-      let uu___1 = f combs.FStar_Syntax_Syntax.bind_wp in
-      let uu___2 = f combs.FStar_Syntax_Syntax.stronger in
-      let uu___3 = f combs.FStar_Syntax_Syntax.if_then_else in
-      let uu___4 = f combs.FStar_Syntax_Syntax.ite_wp in
-      let uu___5 = f combs.FStar_Syntax_Syntax.close_wp in
-      let uu___6 = f combs.FStar_Syntax_Syntax.trivial in
-      let uu___7 =
-        FStar_Compiler_Util.map_option f combs.FStar_Syntax_Syntax.repr in
-      let uu___8 =
-        FStar_Compiler_Util.map_option f
-          combs.FStar_Syntax_Syntax.return_repr in
-      let uu___9 =
-        FStar_Compiler_Util.map_option f combs.FStar_Syntax_Syntax.bind_repr in
-      {
-        FStar_Syntax_Syntax.ret_wp = uu___;
-        FStar_Syntax_Syntax.bind_wp = uu___1;
-        FStar_Syntax_Syntax.stronger = uu___2;
-        FStar_Syntax_Syntax.if_then_else = uu___3;
-        FStar_Syntax_Syntax.ite_wp = uu___4;
-        FStar_Syntax_Syntax.close_wp = uu___5;
-        FStar_Syntax_Syntax.trivial = uu___6;
-        FStar_Syntax_Syntax.repr = uu___7;
-        FStar_Syntax_Syntax.return_repr = uu___8;
-        FStar_Syntax_Syntax.bind_repr = uu___9
-      }
-let (apply_layered_eff_combinators :
-  (FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme) ->
-    FStar_Syntax_Syntax.layered_eff_combinators ->
-      FStar_Syntax_Syntax.layered_eff_combinators)
-  =
-  fun f ->
-    fun combs ->
-      let map2 uu___ =
-        match uu___ with
-        | (ts1, ts2) ->
-            let uu___1 = f ts1 in let uu___2 = f ts2 in (uu___1, uu___2) in
-      let map3 uu___ =
-        match uu___ with
-        | (ts1, ts2, k) ->
-            let uu___1 = f ts1 in let uu___2 = f ts2 in (uu___1, uu___2, k) in
-      let uu___ = map2 combs.FStar_Syntax_Syntax.l_repr in
-      let uu___1 = map2 combs.FStar_Syntax_Syntax.l_return in
-      let uu___2 = map3 combs.FStar_Syntax_Syntax.l_bind in
-      let uu___3 = map3 combs.FStar_Syntax_Syntax.l_subcomp in
-      let uu___4 = map3 combs.FStar_Syntax_Syntax.l_if_then_else in
-      {
-        FStar_Syntax_Syntax.l_repr = uu___;
-        FStar_Syntax_Syntax.l_return = uu___1;
-        FStar_Syntax_Syntax.l_bind = uu___2;
-        FStar_Syntax_Syntax.l_subcomp = uu___3;
-        FStar_Syntax_Syntax.l_if_then_else = uu___4
-      }
-let (apply_eff_combinators :
-  (FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.tscheme) ->
-    FStar_Syntax_Syntax.eff_combinators ->
-      FStar_Syntax_Syntax.eff_combinators)
-  =
-  fun f ->
-    fun combs ->
-      match combs with
-      | FStar_Syntax_Syntax.Primitive_eff combs1 ->
-          let uu___ = apply_wp_eff_combinators f combs1 in
-          FStar_Syntax_Syntax.Primitive_eff uu___
-      | FStar_Syntax_Syntax.DM4F_eff combs1 ->
-          let uu___ = apply_wp_eff_combinators f combs1 in
-          FStar_Syntax_Syntax.DM4F_eff uu___
-      | FStar_Syntax_Syntax.Layered_eff combs1 ->
-          let uu___ = apply_layered_eff_combinators f combs1 in
-          FStar_Syntax_Syntax.Layered_eff uu___
-let (get_wp_close_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        FStar_Pervasives_Native.Some (combs.FStar_Syntax_Syntax.close_wp)
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        FStar_Pervasives_Native.Some (combs.FStar_Syntax_Syntax.close_wp)
-    | uu___ -> FStar_Pervasives_Native.None
-let (get_eff_repr :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        combs.FStar_Syntax_Syntax.repr
-    | FStar_Syntax_Syntax.DM4F_eff combs -> combs.FStar_Syntax_Syntax.repr
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Pervasives_Native.fst combs.FStar_Syntax_Syntax.l_repr)
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-let (get_bind_vc_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    (FStar_Syntax_Syntax.tscheme *
-      FStar_Syntax_Syntax.indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option))
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        ((combs.FStar_Syntax_Syntax.bind_wp), FStar_Pervasives_Native.None)
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        ((combs.FStar_Syntax_Syntax.bind_wp), FStar_Pervasives_Native.None)
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        ((FStar_Pervasives_Native.__proj__Mktuple3__item___2
-            combs.FStar_Syntax_Syntax.l_bind),
-          (FStar_Pervasives_Native.__proj__Mktuple3__item___3
-             combs.FStar_Syntax_Syntax.l_bind))
-let (get_return_vc_combinator :
-  FStar_Syntax_Syntax.eff_decl -> FStar_Syntax_Syntax.tscheme) =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        combs.FStar_Syntax_Syntax.ret_wp
-    | FStar_Syntax_Syntax.DM4F_eff combs -> combs.FStar_Syntax_Syntax.ret_wp
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        FStar_Pervasives_Native.snd combs.FStar_Syntax_Syntax.l_return
-let (get_bind_repr :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        combs.FStar_Syntax_Syntax.bind_repr
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        combs.FStar_Syntax_Syntax.bind_repr
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Pervasives_Native.__proj__Mktuple3__item___1
-             combs.FStar_Syntax_Syntax.l_bind)
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-let (get_return_repr :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        combs.FStar_Syntax_Syntax.return_repr
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        combs.FStar_Syntax_Syntax.return_repr
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Pervasives_Native.fst combs.FStar_Syntax_Syntax.l_return)
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-let (get_wp_trivial_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          combs.FStar_Syntax_Syntax.trivial
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          combs.FStar_Syntax_Syntax.trivial
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-    | uu___ -> FStar_Pervasives_Native.None
-let (get_layered_if_then_else_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    (FStar_Syntax_Syntax.tscheme *
-      FStar_Syntax_Syntax.indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option) FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        FStar_Pervasives_Native.Some
-          ((FStar_Pervasives_Native.__proj__Mktuple3__item___1
-              combs.FStar_Syntax_Syntax.l_if_then_else),
-            (FStar_Pervasives_Native.__proj__Mktuple3__item___3
-               combs.FStar_Syntax_Syntax.l_if_then_else))
-    | uu___ -> FStar_Pervasives_Native.None
-let (get_wp_if_then_else_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          combs.FStar_Syntax_Syntax.if_then_else
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          combs.FStar_Syntax_Syntax.if_then_else
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-    | uu___ -> FStar_Pervasives_Native.None
-let (get_wp_ite_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater combs.FStar_Syntax_Syntax.ite_wp
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater combs.FStar_Syntax_Syntax.ite_wp
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-    | uu___ -> FStar_Pervasives_Native.None
-let (get_stronger_vc_combinator :
-  FStar_Syntax_Syntax.eff_decl ->
-    (FStar_Syntax_Syntax.tscheme *
-      FStar_Syntax_Syntax.indexed_effect_combinator_kind
-      FStar_Pervasives_Native.option))
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff combs ->
-        ((combs.FStar_Syntax_Syntax.stronger), FStar_Pervasives_Native.None)
-    | FStar_Syntax_Syntax.DM4F_eff combs ->
-        ((combs.FStar_Syntax_Syntax.stronger), FStar_Pervasives_Native.None)
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        ((FStar_Pervasives_Native.__proj__Mktuple3__item___2
-            combs.FStar_Syntax_Syntax.l_subcomp),
-          (FStar_Pervasives_Native.__proj__Mktuple3__item___3
-             combs.FStar_Syntax_Syntax.l_subcomp))
-let (get_stronger_repr :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option)
-  =
-  fun ed ->
-    match ed.FStar_Syntax_Syntax.combinators with
-    | FStar_Syntax_Syntax.Primitive_eff uu___ -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.DM4F_eff uu___ -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Layered_eff combs ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Pervasives_Native.__proj__Mktuple3__item___1
-             combs.FStar_Syntax_Syntax.l_subcomp)
-          (fun uu___ -> FStar_Pervasives_Native.Some uu___)
-let (aqual_is_erasable : FStar_Syntax_Syntax.aqual -> Prims.bool) =
-  fun aq ->
-    match aq with
-    | FStar_Pervasives_Native.None -> false
-    | FStar_Pervasives_Native.Some aq1 ->
-        FStar_Compiler_Util.for_some
-          (is_fvar FStar_Parser_Const.erasable_attr)
-          aq1.FStar_Syntax_Syntax.aqual_attributes
-let (is_erased_head :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.term)
-      FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        (match ((head.FStar_Syntax_Syntax.n), args) with
-         | (FStar_Syntax_Syntax.Tm_uinst
-            ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-               FStar_Syntax_Syntax.pos = uu___1;
-               FStar_Syntax_Syntax.vars = uu___2;
-               FStar_Syntax_Syntax.hash_code = uu___3;_},
-             u::[]),
-            (ty, uu___4)::[]) when
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.erased_lid
-             -> FStar_Pervasives_Native.Some (u, ty)
-         | uu___1 -> FStar_Pervasives_Native.None)
-let (apply_reveal :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun u ->
-    fun ty ->
-      fun v ->
-        let head =
-          let uu___ =
-            FStar_Ident.set_lid_range FStar_Parser_Const.reveal
-              v.FStar_Syntax_Syntax.pos in
-          FStar_Syntax_Syntax.fvar uu___
-            (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-            FStar_Pervasives_Native.None in
-        let uu___ = FStar_Syntax_Syntax.mk_Tm_uinst head [u] in
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Syntax.iarg ty in
-          let uu___3 = let uu___4 = FStar_Syntax_Syntax.as_arg v in [uu___4] in
-          uu___2 :: uu___3 in
-        FStar_Syntax_Syntax.mk_Tm_app uu___ uu___1 v.FStar_Syntax_Syntax.pos
-let (check_mutual_universes :
-  FStar_Syntax_Syntax.letbinding Prims.list -> unit) =
-  fun lbs ->
-    let uu___ = lbs in
-    match uu___ with
-    | lb::lbs1 ->
-        let expected = lb.FStar_Syntax_Syntax.lbunivs in
-        let expected_len = FStar_Compiler_List.length expected in
-        FStar_Compiler_List.iter
-          (fun lb1 ->
-             let uu___1 =
-               ((FStar_Compiler_List.length lb1.FStar_Syntax_Syntax.lbunivs)
-                  <> expected_len)
-                 ||
-                 (let uu___2 =
-                    FStar_Compiler_List.forall2 FStar_Ident.ident_equals
-                      lb1.FStar_Syntax_Syntax.lbunivs expected in
-                  Prims.op_Negation uu___2) in
-             if uu___1
-             then
-               FStar_Errors.raise_error
-                 (FStar_Errors.Fatal_IncompatibleUniverse,
-                   "Mutually recursive definitions do not abstract over the same universes")
-                 lb1.FStar_Syntax_Syntax.lbpos
-             else ()) lbs1
-let (ctx_uvar_should_check :
-  FStar_Syntax_Syntax.ctx_uvar -> FStar_Syntax_Syntax.should_check_uvar) =
-  fun u ->
-    let uu___ =
-      FStar_Syntax_Unionfind.find_decoration
-        u.FStar_Syntax_Syntax.ctx_uvar_head in
-    uu___.FStar_Syntax_Syntax.uvar_decoration_should_check
-let (ctx_uvar_typ :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun u ->
-    let uu___ =
-      FStar_Syntax_Unionfind.find_decoration
-        u.FStar_Syntax_Syntax.ctx_uvar_head in
-    uu___.FStar_Syntax_Syntax.uvar_decoration_typ
-let (ctx_uvar_typedness_deps :
-  FStar_Syntax_Syntax.ctx_uvar -> FStar_Syntax_Syntax.ctx_uvar Prims.list) =
-  fun u ->
-    let uu___ =
-      FStar_Syntax_Unionfind.find_decoration
-        u.FStar_Syntax_Syntax.ctx_uvar_head in
-    uu___.FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on
-let (flatten_refinement :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let rec aux t1 unascribe1 =
-      let t2 = FStar_Syntax_Subst.compress t1 in
-      match t2.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_ascribed (t3, uu___, uu___1) when unascribe1
-          -> aux t3 true
-      | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-          let t0 = aux x.FStar_Syntax_Syntax.sort true in
-          (match t0.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_refine (y, phi1) ->
-               let uu___ =
-                 let uu___1 =
-                   let uu___2 = mk_conj_simp phi1 phi in (y, uu___2) in
-                 FStar_Syntax_Syntax.Tm_refine uu___1 in
-               FStar_Syntax_Syntax.mk uu___ t0.FStar_Syntax_Syntax.pos
-           | uu___ -> t2)
-      | uu___ -> t2 in
-    aux t false
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Basic.ml b/src/ocaml-output/FStar_Tactics_Basic.ml
deleted file mode 100644
index bef7beb1972..00000000000
--- a/src/ocaml-output/FStar_Tactics_Basic.ml
+++ /dev/null
@@ -1,7317 +0,0 @@
-open Prims
-let (core_check :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term ->
-        Prims.bool ->
-          (FStar_Reflection_Data.typ FStar_Pervasives_Native.option,
-            FStar_TypeChecker_Core.error) FStar_Pervasives.either)
-  =
-  fun env ->
-    fun sol ->
-      fun t ->
-        fun must_tot ->
-          let uu___ =
-            let uu___1 = FStar_Options.compat_pre_core_should_check () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then FStar_Pervasives.Inl FStar_Pervasives_Native.None
-          else
-            (let debug f =
-               let uu___2 = FStar_Options.debug_any () in
-               if uu___2 then f () else () in
-             let uu___2 =
-               FStar_TypeChecker_Core.check_term env sol t must_tot in
-             match uu___2 with
-             | FStar_Pervasives.Inl (FStar_Pervasives_Native.None) ->
-                 FStar_Pervasives.Inl FStar_Pervasives_Native.None
-             | FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g) ->
-                 let uu___3 = FStar_Options.compat_pre_core_set () in
-                 if uu___3
-                 then FStar_Pervasives.Inl FStar_Pervasives_Native.None
-                 else FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g)
-             | FStar_Pervasives.Inr err ->
-                 (debug
-                    (fun uu___4 ->
-                       let uu___5 =
-                         let uu___6 = FStar_TypeChecker_Env.get_range env in
-                         FStar_Compiler_Range.string_of_range uu___6 in
-                       let uu___6 =
-                         FStar_TypeChecker_Core.print_error_short err in
-                       let uu___7 = FStar_Syntax_Print.term_to_string sol in
-                       let uu___8 = FStar_Syntax_Print.term_to_string t in
-                       let uu___9 = FStar_TypeChecker_Core.print_error err in
-                       FStar_Compiler_Util.print5
-                         "(%s) Core checking failed (%s) on term %s and type %s\n%s\n"
-                         uu___5 uu___6 uu___7 uu___8 uu___9);
-                  FStar_Pervasives.Inr err))
-type name = FStar_Syntax_Syntax.bv
-type env = FStar_TypeChecker_Env.env
-type implicits = FStar_TypeChecker_Env.implicits
-let (rangeof : FStar_Tactics_Types.goal -> FStar_Compiler_Range.range) =
-  fun g ->
-    (g.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_range
-let (normalize :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun s ->
-    fun e ->
-      fun t ->
-        FStar_TypeChecker_Normalize.normalize_with_primitive_steps
-          FStar_Reflection_Interpreter.reflection_primops s e t
-let (bnorm :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun e -> fun t -> normalize [] e t
-let (whnf :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun e -> fun t -> FStar_TypeChecker_Normalize.unfold_whnf e t
-let (tts :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.string) =
-  FStar_TypeChecker_Normalize.term_to_string
-let (set_uvar_expected_typ :
-  FStar_Syntax_Syntax.ctx_uvar -> FStar_Reflection_Data.typ -> unit) =
-  fun u ->
-    fun t ->
-      let dec =
-        FStar_Syntax_Unionfind.find_decoration
-          u.FStar_Syntax_Syntax.ctx_uvar_head in
-      FStar_Syntax_Unionfind.change_decoration
-        u.FStar_Syntax_Syntax.ctx_uvar_head
-        {
-          FStar_Syntax_Syntax.uvar_decoration_typ = t;
-          FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on =
-            (dec.FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on);
-          FStar_Syntax_Syntax.uvar_decoration_should_check =
-            (dec.FStar_Syntax_Syntax.uvar_decoration_should_check)
-        }
-let (mark_uvar_with_should_check_tag :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.should_check_uvar -> unit)
-  =
-  fun u ->
-    fun sc ->
-      let dec =
-        FStar_Syntax_Unionfind.find_decoration
-          u.FStar_Syntax_Syntax.ctx_uvar_head in
-      FStar_Syntax_Unionfind.change_decoration
-        u.FStar_Syntax_Syntax.ctx_uvar_head
-        {
-          FStar_Syntax_Syntax.uvar_decoration_typ =
-            (dec.FStar_Syntax_Syntax.uvar_decoration_typ);
-          FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on =
-            (dec.FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on);
-          FStar_Syntax_Syntax.uvar_decoration_should_check = sc
-        }
-let (mark_uvar_as_already_checked : FStar_Syntax_Syntax.ctx_uvar -> unit) =
-  fun u ->
-    mark_uvar_with_should_check_tag u FStar_Syntax_Syntax.Already_checked
-let (mark_goal_implicit_already_checked : FStar_Tactics_Types.goal -> unit) =
-  fun g -> mark_uvar_as_already_checked g.FStar_Tactics_Types.goal_ctx_uvar
-let (goal_with_type :
-  FStar_Tactics_Types.goal ->
-    FStar_Reflection_Data.typ -> FStar_Tactics_Types.goal)
-  =
-  fun g ->
-    fun t ->
-      let u = g.FStar_Tactics_Types.goal_ctx_uvar in
-      set_uvar_expected_typ u t; g
-let (bnorm_goal : FStar_Tactics_Types.goal -> FStar_Tactics_Types.goal) =
-  fun g ->
-    let uu___ =
-      let uu___1 = FStar_Tactics_Types.goal_env g in
-      let uu___2 = FStar_Tactics_Types.goal_type g in bnorm uu___1 uu___2 in
-    goal_with_type g uu___
-let (tacprint : Prims.string -> unit) =
-  fun s -> FStar_Compiler_Util.print1 "TAC>> %s\n" s
-let (tacprint1 : Prims.string -> Prims.string -> unit) =
-  fun s ->
-    fun x ->
-      let uu___ = FStar_Compiler_Util.format1 s x in
-      FStar_Compiler_Util.print1 "TAC>> %s\n" uu___
-let (tacprint2 : Prims.string -> Prims.string -> Prims.string -> unit) =
-  fun s ->
-    fun x ->
-      fun y ->
-        let uu___ = FStar_Compiler_Util.format2 s x y in
-        FStar_Compiler_Util.print1 "TAC>> %s\n" uu___
-let (tacprint3 :
-  Prims.string -> Prims.string -> Prims.string -> Prims.string -> unit) =
-  fun s ->
-    fun x ->
-      fun y ->
-        fun z ->
-          let uu___ = FStar_Compiler_Util.format3 s x y z in
-          FStar_Compiler_Util.print1 "TAC>> %s\n" uu___
-let (print : Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun msg ->
-    (let uu___1 =
-       let uu___2 = FStar_Options.silent () in Prims.op_Negation uu___2 in
-     if uu___1 then tacprint msg else ());
-    FStar_Tactics_Monad.ret ()
-let (debugging : unit -> Prims.bool FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-      (fun ps ->
-         let uu___1 =
-           FStar_TypeChecker_Env.debug ps.FStar_Tactics_Types.main_context
-             (FStar_Options.Other "Tac") in
-         FStar_Tactics_Monad.ret uu___1)
-let (do_dump_ps : Prims.string -> FStar_Tactics_Types.proofstate -> unit) =
-  fun msg ->
-    fun ps ->
-      let psc = ps.FStar_Tactics_Types.psc in
-      let subst = FStar_TypeChecker_Cfg.psc_subst psc in
-      FStar_Tactics_Printing.do_dump_proofstate ps msg
-let (dump : Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun msg ->
-    FStar_Tactics_Monad.mk_tac
-      (fun ps -> do_dump_ps msg ps; FStar_Tactics_Result.Success ((), ps))
-let (dump_all : Prims.bool -> Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun print_resolved ->
-    fun msg ->
-      FStar_Tactics_Monad.mk_tac
-        (fun ps ->
-           let gs =
-             FStar_Compiler_List.map
-               (fun i ->
-                  FStar_Tactics_Types.goal_of_implicit
-                    ps.FStar_Tactics_Types.main_context i)
-               ps.FStar_Tactics_Types.all_implicits in
-           let gs1 =
-             if print_resolved
-             then gs
-             else
-               FStar_Compiler_List.filter
-                 (fun g ->
-                    let uu___1 = FStar_Tactics_Types.check_goal_solved g in
-                    Prims.op_Negation uu___1) gs in
-           let ps' =
-             {
-               FStar_Tactics_Types.main_context =
-                 (ps.FStar_Tactics_Types.main_context);
-               FStar_Tactics_Types.all_implicits =
-                 (ps.FStar_Tactics_Types.all_implicits);
-               FStar_Tactics_Types.goals = gs1;
-               FStar_Tactics_Types.smt_goals = [];
-               FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-               FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-               FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-               FStar_Tactics_Types.entry_range =
-                 (ps.FStar_Tactics_Types.entry_range);
-               FStar_Tactics_Types.guard_policy =
-                 (ps.FStar_Tactics_Types.guard_policy);
-               FStar_Tactics_Types.freshness =
-                 (ps.FStar_Tactics_Types.freshness);
-               FStar_Tactics_Types.tac_verb_dbg =
-                 (ps.FStar_Tactics_Types.tac_verb_dbg);
-               FStar_Tactics_Types.local_state =
-                 (ps.FStar_Tactics_Types.local_state);
-               FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-             } in
-           do_dump_ps msg ps'; FStar_Tactics_Result.Success ((), ps))
-let (dump_uvars_of :
-  FStar_Tactics_Types.goal -> Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun g ->
-    fun msg ->
-      FStar_Tactics_Monad.mk_tac
-        (fun ps ->
-           let uvs =
-             let uu___ =
-               let uu___1 = FStar_Tactics_Types.goal_type g in
-               FStar_Syntax_Free.uvars uu___1 in
-             FStar_Compiler_Effect.op_Bar_Greater uu___
-               FStar_Compiler_Util.set_elements in
-           let gs =
-             FStar_Compiler_List.map (FStar_Tactics_Types.goal_of_ctx_uvar g)
-               uvs in
-           let gs1 =
-             FStar_Compiler_List.filter
-               (fun g1 ->
-                  let uu___ = FStar_Tactics_Types.check_goal_solved g1 in
-                  Prims.op_Negation uu___) gs in
-           let ps' =
-             {
-               FStar_Tactics_Types.main_context =
-                 (ps.FStar_Tactics_Types.main_context);
-               FStar_Tactics_Types.all_implicits =
-                 (ps.FStar_Tactics_Types.all_implicits);
-               FStar_Tactics_Types.goals = gs1;
-               FStar_Tactics_Types.smt_goals = [];
-               FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-               FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-               FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-               FStar_Tactics_Types.entry_range =
-                 (ps.FStar_Tactics_Types.entry_range);
-               FStar_Tactics_Types.guard_policy =
-                 (ps.FStar_Tactics_Types.guard_policy);
-               FStar_Tactics_Types.freshness =
-                 (ps.FStar_Tactics_Types.freshness);
-               FStar_Tactics_Types.tac_verb_dbg =
-                 (ps.FStar_Tactics_Types.tac_verb_dbg);
-               FStar_Tactics_Types.local_state =
-                 (ps.FStar_Tactics_Types.local_state);
-               FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-             } in
-           do_dump_ps msg ps'; FStar_Tactics_Result.Success ((), ps))
-let fail1 :
-  'uuuuu . Prims.string -> Prims.string -> 'uuuuu FStar_Tactics_Monad.tac =
-  fun msg ->
-    fun x ->
-      let uu___ = FStar_Compiler_Util.format1 msg x in
-      FStar_Tactics_Monad.fail uu___
-let fail2 :
-  'uuuuu .
-    Prims.string ->
-      Prims.string -> Prims.string -> 'uuuuu FStar_Tactics_Monad.tac
-  =
-  fun msg ->
-    fun x ->
-      fun y ->
-        let uu___ = FStar_Compiler_Util.format2 msg x y in
-        FStar_Tactics_Monad.fail uu___
-let fail3 :
-  'uuuuu .
-    Prims.string ->
-      Prims.string ->
-        Prims.string -> Prims.string -> 'uuuuu FStar_Tactics_Monad.tac
-  =
-  fun msg ->
-    fun x ->
-      fun y ->
-        fun z ->
-          let uu___ = FStar_Compiler_Util.format3 msg x y z in
-          FStar_Tactics_Monad.fail uu___
-let fail4 :
-  'uuuuu .
-    Prims.string ->
-      Prims.string ->
-        Prims.string ->
-          Prims.string -> Prims.string -> 'uuuuu FStar_Tactics_Monad.tac
-  =
-  fun msg ->
-    fun x ->
-      fun y ->
-        fun z ->
-          fun w ->
-            let uu___ = FStar_Compiler_Util.format4 msg x y z w in
-            FStar_Tactics_Monad.fail uu___
-let (destruct_eq' :
-  FStar_Reflection_Data.typ ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term)
-      FStar_Pervasives_Native.option)
-  =
-  fun typ ->
-    let uu___ = FStar_Syntax_Util.destruct_typ_as_formula typ in
-    match uu___ with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Util.BaseConn
-        (l,
-         uu___1::(e1, FStar_Pervasives_Native.None)::(e2,
-                                                      FStar_Pervasives_Native.None)::[]))
-        when
-        (FStar_Ident.lid_equals l FStar_Parser_Const.eq2_lid) ||
-          (FStar_Ident.lid_equals l FStar_Parser_Const.c_eq2_lid)
-        -> FStar_Pervasives_Native.Some (e1, e2)
-    | uu___1 ->
-        let uu___2 = FStar_Syntax_Util.unb2t typ in
-        (match uu___2 with
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-         | FStar_Pervasives_Native.Some t ->
-             let uu___3 = FStar_Syntax_Util.head_and_args t in
-             (match uu___3 with
-              | (hd, args) ->
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Subst.compress hd in
-                      uu___6.FStar_Syntax_Syntax.n in
-                    (uu___5, args) in
-                  (match uu___4 with
-                   | (FStar_Syntax_Syntax.Tm_fvar fv,
-                      (uu___5, FStar_Pervasives_Native.Some
-                       { FStar_Syntax_Syntax.aqual_implicit = true;
-                         FStar_Syntax_Syntax.aqual_attributes = uu___6;_})::
-                      (e1, FStar_Pervasives_Native.None)::(e2,
-                                                           FStar_Pervasives_Native.None)::[])
-                       when
-                       FStar_Syntax_Syntax.fv_eq_lid fv
-                         FStar_Parser_Const.op_Eq
-                       -> FStar_Pervasives_Native.Some (e1, e2)
-                   | uu___5 -> FStar_Pervasives_Native.None)))
-let (destruct_eq :
-  FStar_Reflection_Data.typ ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term)
-      FStar_Pervasives_Native.option)
-  =
-  fun typ ->
-    let uu___ = destruct_eq' typ in
-    match uu___ with
-    | FStar_Pervasives_Native.Some t -> FStar_Pervasives_Native.Some t
-    | FStar_Pervasives_Native.None ->
-        let uu___1 = FStar_Syntax_Util.un_squash typ in
-        (match uu___1 with
-         | FStar_Pervasives_Native.Some typ1 -> destruct_eq' typ1
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None)
-let (get_guard_policy :
-  unit -> FStar_Tactics_Types.guard_policy FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-      (fun ps -> FStar_Tactics_Monad.ret ps.FStar_Tactics_Types.guard_policy)
-let (set_guard_policy :
-  FStar_Tactics_Types.guard_policy -> unit FStar_Tactics_Monad.tac) =
-  fun pol ->
-    FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-      (fun ps ->
-         FStar_Tactics_Monad.set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy = pol;
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let with_policy :
-  'a .
-    FStar_Tactics_Types.guard_policy ->
-      'a FStar_Tactics_Monad.tac -> 'a FStar_Tactics_Monad.tac
-  =
-  fun pol ->
-    fun t ->
-      let uu___ = get_guard_policy () in
-      FStar_Tactics_Monad.bind uu___
-        (fun old_pol ->
-           let uu___1 = set_guard_policy pol in
-           FStar_Tactics_Monad.bind uu___1
-             (fun uu___2 ->
-                FStar_Tactics_Monad.bind t
-                  (fun r ->
-                     let uu___3 = set_guard_policy old_pol in
-                     FStar_Tactics_Monad.bind uu___3
-                       (fun uu___4 -> FStar_Tactics_Monad.ret r))))
-let (proc_guard' :
-  Prims.bool ->
-    Prims.string ->
-      env ->
-        FStar_TypeChecker_Common.guard_t ->
-          FStar_Syntax_Syntax.should_check_uvar
-            FStar_Pervasives_Native.option ->
-            FStar_Compiler_Range.range -> unit FStar_Tactics_Monad.tac)
-  =
-  fun simplify ->
-    fun reason ->
-      fun e ->
-        fun g ->
-          fun sc_opt ->
-            fun rng ->
-              FStar_Tactics_Monad.mlog
-                (fun uu___ ->
-                   let uu___1 = FStar_TypeChecker_Rel.guard_to_string e g in
-                   FStar_Compiler_Util.print2 "Processing guard (%s:%s)\n"
-                     reason uu___1)
-                (fun uu___ ->
-                   (match sc_opt with
-                    | FStar_Pervasives_Native.Some
-                        (FStar_Syntax_Syntax.Allow_untyped r) ->
-                        FStar_Compiler_List.iter
-                          (fun imp ->
-                             mark_uvar_with_should_check_tag
-                               imp.FStar_TypeChecker_Common.imp_uvar
-                               (FStar_Syntax_Syntax.Allow_untyped r))
-                          g.FStar_TypeChecker_Common.implicits
-                    | uu___2 -> ());
-                   (let uu___2 =
-                      FStar_Tactics_Monad.add_implicits
-                        g.FStar_TypeChecker_Common.implicits in
-                    FStar_Tactics_Monad.op_let_Bang uu___2
-                      (fun uu___3 ->
-                         let guard_f =
-                           if simplify
-                           then
-                             let uu___4 =
-                               FStar_TypeChecker_Rel.simplify_guard e g in
-                             uu___4.FStar_TypeChecker_Common.guard_f
-                           else g.FStar_TypeChecker_Common.guard_f in
-                         match guard_f with
-                         | FStar_TypeChecker_Common.Trivial ->
-                             FStar_Tactics_Monad.ret ()
-                         | FStar_TypeChecker_Common.NonTrivial f ->
-                             FStar_Tactics_Monad.op_let_Bang
-                               FStar_Tactics_Monad.get
-                               (fun ps ->
-                                  match ps.FStar_Tactics_Types.guard_policy
-                                  with
-                                  | FStar_Tactics_Types.Drop ->
-                                      ((let uu___5 =
-                                          let uu___6 =
-                                            let uu___7 =
-                                              FStar_TypeChecker_Rel.guard_to_string
-                                                e g in
-                                            FStar_Compiler_Util.format1
-                                              "Tactics admitted guard <%s>\n\n"
-                                              uu___7 in
-                                          (FStar_Errors.Warning_TacAdmit,
-                                            uu___6) in
-                                        FStar_Errors.log_issue
-                                          e.FStar_TypeChecker_Env.range
-                                          uu___5);
-                                       FStar_Tactics_Monad.ret ())
-                                  | FStar_Tactics_Types.Goal ->
-                                      FStar_Tactics_Monad.mlog
-                                        (fun uu___4 ->
-                                           let uu___5 =
-                                             FStar_TypeChecker_Rel.guard_to_string
-                                               e g in
-                                           FStar_Compiler_Util.print2
-                                             "Making guard (%s:%s) into a goal\n"
-                                             reason uu___5)
-                                        (fun uu___4 ->
-                                           let uu___5 =
-                                             FStar_Tactics_Monad.goal_of_guard
-                                               reason e f sc_opt rng in
-                                           FStar_Tactics_Monad.op_let_Bang
-                                             uu___5
-                                             (fun g1 ->
-                                                FStar_Tactics_Monad.push_goals
-                                                  [g1]))
-                                  | FStar_Tactics_Types.SMT ->
-                                      FStar_Tactics_Monad.mlog
-                                        (fun uu___4 ->
-                                           let uu___5 =
-                                             FStar_TypeChecker_Rel.guard_to_string
-                                               e g in
-                                           FStar_Compiler_Util.print2
-                                             "Sending guard (%s:%s) to SMT goal\n"
-                                             reason uu___5)
-                                        (fun uu___4 ->
-                                           let uu___5 =
-                                             FStar_Tactics_Monad.goal_of_guard
-                                               reason e f sc_opt rng in
-                                           FStar_Tactics_Monad.op_let_Bang
-                                             uu___5
-                                             (fun g1 ->
-                                                FStar_Tactics_Monad.push_smt_goals
-                                                  [g1]))
-                                  | FStar_Tactics_Types.Force ->
-                                      FStar_Tactics_Monad.mlog
-                                        (fun uu___4 ->
-                                           let uu___5 =
-                                             FStar_TypeChecker_Rel.guard_to_string
-                                               e g in
-                                           FStar_Compiler_Util.print2
-                                             "Forcing guard (%s:%s)\n" reason
-                                             uu___5)
-                                        (fun uu___4 ->
-                                           try
-                                             (fun uu___5 ->
-                                                match () with
-                                                | () ->
-                                                    let uu___6 =
-                                                      let uu___7 =
-                                                        let uu___8 =
-                                                          FStar_TypeChecker_Rel.discharge_guard_no_smt
-                                                            e g in
-                                                        FStar_Compiler_Effect.op_Less_Bar
-                                                          FStar_TypeChecker_Env.is_trivial
-                                                          uu___8 in
-                                                      Prims.op_Negation
-                                                        uu___7 in
-                                                    if uu___6
-                                                    then
-                                                      FStar_Tactics_Monad.mlog
-                                                        (fun uu___7 ->
-                                                           let uu___8 =
-                                                             FStar_TypeChecker_Rel.guard_to_string
-                                                               e g in
-                                                           FStar_Compiler_Util.print1
-                                                             "guard = %s\n"
-                                                             uu___8)
-                                                        (fun uu___7 ->
-                                                           fail1
-                                                             "Forcing the guard failed (%s)"
-                                                             reason)
-                                                    else
-                                                      FStar_Tactics_Monad.ret
-                                                        ()) ()
-                                           with
-                                           | uu___5 ->
-                                               FStar_Tactics_Monad.mlog
-                                                 (fun uu___6 ->
-                                                    let uu___7 =
-                                                      FStar_TypeChecker_Rel.guard_to_string
-                                                        e g in
-                                                    FStar_Compiler_Util.print1
-                                                      "guard = %s\n" uu___7)
-                                                 (fun uu___6 ->
-                                                    fail1
-                                                      "Forcing the guard failed (%s)"
-                                                      reason))))))
-let (proc_guard :
-  Prims.string ->
-    env ->
-      FStar_TypeChecker_Common.guard_t ->
-        FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option
-          -> FStar_Compiler_Range.range -> unit FStar_Tactics_Monad.tac)
-  = proc_guard' true
-let (tc_unifier_solved_implicits :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      Prims.bool ->
-        FStar_Syntax_Syntax.ctx_uvar Prims.list ->
-          unit FStar_Tactics_Monad.tac)
-  =
-  fun env1 ->
-    fun must_tot ->
-      fun allow_guards ->
-        fun uvs ->
-          let aux u =
-            let dec =
-              FStar_Syntax_Unionfind.find_decoration
-                u.FStar_Syntax_Syntax.ctx_uvar_head in
-            let sc = dec.FStar_Syntax_Syntax.uvar_decoration_should_check in
-            match sc with
-            | FStar_Syntax_Syntax.Allow_untyped uu___ ->
-                FStar_Tactics_Monad.ret ()
-            | FStar_Syntax_Syntax.Already_checked ->
-                FStar_Tactics_Monad.ret ()
-            | uu___ ->
-                let uu___1 =
-                  FStar_Syntax_Unionfind.find
-                    u.FStar_Syntax_Syntax.ctx_uvar_head in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.None -> FStar_Tactics_Monad.ret ()
-                 | FStar_Pervasives_Native.Some sol ->
-                     let env2 =
-                       {
-                         FStar_TypeChecker_Env.solver =
-                           (env1.FStar_TypeChecker_Env.solver);
-                         FStar_TypeChecker_Env.range =
-                           (env1.FStar_TypeChecker_Env.range);
-                         FStar_TypeChecker_Env.curmodule =
-                           (env1.FStar_TypeChecker_Env.curmodule);
-                         FStar_TypeChecker_Env.gamma =
-                           (u.FStar_Syntax_Syntax.ctx_uvar_gamma);
-                         FStar_TypeChecker_Env.gamma_sig =
-                           (env1.FStar_TypeChecker_Env.gamma_sig);
-                         FStar_TypeChecker_Env.gamma_cache =
-                           (env1.FStar_TypeChecker_Env.gamma_cache);
-                         FStar_TypeChecker_Env.modules =
-                           (env1.FStar_TypeChecker_Env.modules);
-                         FStar_TypeChecker_Env.expected_typ =
-                           (env1.FStar_TypeChecker_Env.expected_typ);
-                         FStar_TypeChecker_Env.sigtab =
-                           (env1.FStar_TypeChecker_Env.sigtab);
-                         FStar_TypeChecker_Env.attrtab =
-                           (env1.FStar_TypeChecker_Env.attrtab);
-                         FStar_TypeChecker_Env.instantiate_imp =
-                           (env1.FStar_TypeChecker_Env.instantiate_imp);
-                         FStar_TypeChecker_Env.effects =
-                           (env1.FStar_TypeChecker_Env.effects);
-                         FStar_TypeChecker_Env.generalize =
-                           (env1.FStar_TypeChecker_Env.generalize);
-                         FStar_TypeChecker_Env.letrecs =
-                           (env1.FStar_TypeChecker_Env.letrecs);
-                         FStar_TypeChecker_Env.top_level =
-                           (env1.FStar_TypeChecker_Env.top_level);
-                         FStar_TypeChecker_Env.check_uvars =
-                           (env1.FStar_TypeChecker_Env.check_uvars);
-                         FStar_TypeChecker_Env.use_eq_strict =
-                           (env1.FStar_TypeChecker_Env.use_eq_strict);
-                         FStar_TypeChecker_Env.is_iface =
-                           (env1.FStar_TypeChecker_Env.is_iface);
-                         FStar_TypeChecker_Env.admit =
-                           (env1.FStar_TypeChecker_Env.admit);
-                         FStar_TypeChecker_Env.lax =
-                           (env1.FStar_TypeChecker_Env.lax);
-                         FStar_TypeChecker_Env.lax_universes =
-                           (env1.FStar_TypeChecker_Env.lax_universes);
-                         FStar_TypeChecker_Env.phase1 =
-                           (env1.FStar_TypeChecker_Env.phase1);
-                         FStar_TypeChecker_Env.failhard =
-                           (env1.FStar_TypeChecker_Env.failhard);
-                         FStar_TypeChecker_Env.nosynth =
-                           (env1.FStar_TypeChecker_Env.nosynth);
-                         FStar_TypeChecker_Env.uvar_subtyping =
-                           (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                         FStar_TypeChecker_Env.tc_term =
-                           (env1.FStar_TypeChecker_Env.tc_term);
-                         FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                           (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.universe_of =
-                           (env1.FStar_TypeChecker_Env.universe_of);
-                         FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                           =
-                           (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.teq_nosmt_force =
-                           (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                         FStar_TypeChecker_Env.subtype_nosmt_force =
-                           (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                         FStar_TypeChecker_Env.qtbl_name_and_index =
-                           (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                         FStar_TypeChecker_Env.normalized_eff_names =
-                           (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                         FStar_TypeChecker_Env.fv_delta_depths =
-                           (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                         FStar_TypeChecker_Env.proof_ns =
-                           (env1.FStar_TypeChecker_Env.proof_ns);
-                         FStar_TypeChecker_Env.synth_hook =
-                           (env1.FStar_TypeChecker_Env.synth_hook);
-                         FStar_TypeChecker_Env.try_solve_implicits_hook =
-                           (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                         FStar_TypeChecker_Env.splice =
-                           (env1.FStar_TypeChecker_Env.splice);
-                         FStar_TypeChecker_Env.mpreprocess =
-                           (env1.FStar_TypeChecker_Env.mpreprocess);
-                         FStar_TypeChecker_Env.postprocess =
-                           (env1.FStar_TypeChecker_Env.postprocess);
-                         FStar_TypeChecker_Env.identifier_info =
-                           (env1.FStar_TypeChecker_Env.identifier_info);
-                         FStar_TypeChecker_Env.tc_hooks =
-                           (env1.FStar_TypeChecker_Env.tc_hooks);
-                         FStar_TypeChecker_Env.dsenv =
-                           (env1.FStar_TypeChecker_Env.dsenv);
-                         FStar_TypeChecker_Env.nbe =
-                           (env1.FStar_TypeChecker_Env.nbe);
-                         FStar_TypeChecker_Env.strict_args_tab =
-                           (env1.FStar_TypeChecker_Env.strict_args_tab);
-                         FStar_TypeChecker_Env.erasable_types_tab =
-                           (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                         FStar_TypeChecker_Env.enable_defer_to_tac =
-                           (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                         FStar_TypeChecker_Env.unif_allow_ref_guards =
-                           (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                         FStar_TypeChecker_Env.erase_erasable_args =
-                           (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                         FStar_TypeChecker_Env.core_check =
-                           (env1.FStar_TypeChecker_Env.core_check)
-                       } in
-                     let must_tot1 =
-                       must_tot &&
-                         (Prims.op_Negation
-                            (FStar_Syntax_Syntax.uu___is_Allow_ghost
-                               dec.FStar_Syntax_Syntax.uvar_decoration_should_check)) in
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Util.ctx_uvar_typ u in
-                       core_check env2 sol uu___3 must_tot1 in
-                     (match uu___2 with
-                      | FStar_Pervasives.Inl (FStar_Pervasives_Native.None)
-                          ->
-                          (mark_uvar_as_already_checked u;
-                           FStar_Tactics_Monad.ret ())
-                      | FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g)
-                          ->
-                          let guard =
-                            {
-                              FStar_TypeChecker_Common.guard_f =
-                                (FStar_TypeChecker_Common.NonTrivial g);
-                              FStar_TypeChecker_Common.deferred_to_tac =
-                                (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.deferred_to_tac);
-                              FStar_TypeChecker_Common.deferred =
-                                (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.deferred);
-                              FStar_TypeChecker_Common.univ_ineqs =
-                                (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.univ_ineqs);
-                              FStar_TypeChecker_Common.implicits =
-                                (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.implicits)
-                            } in
-                          let guard1 =
-                            FStar_TypeChecker_Rel.simplify_guard env2 guard in
-                          let uu___3 =
-                            ((FStar_Options.disallow_unification_guards ())
-                               && (Prims.op_Negation allow_guards))
-                              &&
-                              (FStar_TypeChecker_Common.uu___is_NonTrivial
-                                 guard1.FStar_TypeChecker_Common.guard_f) in
-                          if uu___3
-                          then
-                            let uu___4 =
-                              FStar_Syntax_Print.uvar_to_string
-                                u.FStar_Syntax_Syntax.ctx_uvar_head in
-                            let uu___5 =
-                              FStar_Syntax_Print.term_to_string sol in
-                            let uu___6 = FStar_Syntax_Print.term_to_string g in
-                            fail3
-                              "Could not typecheck unifier solved implicit %s to %s since it produced a guard and guards were not allowed;guard is\n%s"
-                              uu___4 uu___5 uu___6
-                          else
-                            (let uu___5 =
-                               proc_guard' false "guard for implicit" env2
-                                 guard1 (FStar_Pervasives_Native.Some sc)
-                                 u.FStar_Syntax_Syntax.ctx_uvar_range in
-                             FStar_Tactics_Monad.op_let_Bang uu___5
-                               (fun uu___6 ->
-                                  mark_uvar_as_already_checked u;
-                                  FStar_Tactics_Monad.ret ()))
-                      | FStar_Pervasives.Inr failed ->
-                          let uu___3 =
-                            FStar_Syntax_Print.uvar_to_string
-                              u.FStar_Syntax_Syntax.ctx_uvar_head in
-                          let uu___4 = FStar_Syntax_Print.term_to_string sol in
-                          let uu___5 =
-                            FStar_TypeChecker_Core.print_error failed in
-                          fail3
-                            "Could not typecheck unifier solved implicit %s to %s because %s"
-                            uu___3 uu___4 uu___5)) in
-          if env1.FStar_TypeChecker_Env.phase1
-          then FStar_Tactics_Monad.ret ()
-          else
-            FStar_Compiler_Effect.op_Bar_Greater uvs
-              (FStar_Tactics_Monad.iter_tac aux)
-type check_unifier_solved_implicits_side =
-  | Check_none 
-  | Check_left_only 
-  | Check_right_only 
-  | Check_both 
-let (uu___is_Check_none : check_unifier_solved_implicits_side -> Prims.bool)
-  =
-  fun projectee -> match projectee with | Check_none -> true | uu___ -> false
-let (uu___is_Check_left_only :
-  check_unifier_solved_implicits_side -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Check_left_only -> true | uu___ -> false
-let (uu___is_Check_right_only :
-  check_unifier_solved_implicits_side -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Check_right_only -> true | uu___ -> false
-let (uu___is_Check_both : check_unifier_solved_implicits_side -> Prims.bool)
-  =
-  fun projectee -> match projectee with | Check_both -> true | uu___ -> false
-let (__do_unify_wflags :
-  Prims.bool ->
-    Prims.bool ->
-      Prims.bool ->
-        check_unifier_solved_implicits_side ->
-          env ->
-            FStar_Syntax_Syntax.term ->
-              FStar_Syntax_Syntax.term ->
-                FStar_TypeChecker_Common.guard_t
-                  FStar_Pervasives_Native.option FStar_Tactics_Monad.tac)
-  =
-  fun dbg ->
-    fun allow_guards ->
-      fun must_tot ->
-        fun check_side ->
-          fun env1 ->
-            fun t1 ->
-              fun t2 ->
-                if dbg
-                then
-                  (let uu___1 = FStar_Syntax_Print.term_to_string t1 in
-                   let uu___2 = FStar_Syntax_Print.term_to_string t2 in
-                   FStar_Compiler_Util.print2 "%%%%%%%%do_unify %s =? %s\n"
-                     uu___1 uu___2)
-                else ();
-                (let all_uvars =
-                   let uu___1 =
-                     match check_side with
-                     | Check_none -> FStar_Syntax_Free.new_uv_set ()
-                     | Check_left_only -> FStar_Syntax_Free.uvars t1
-                     | Check_right_only -> FStar_Syntax_Free.uvars t2
-                     | Check_both ->
-                         let uu___2 = FStar_Syntax_Free.uvars t1 in
-                         let uu___3 = FStar_Syntax_Free.uvars t2 in
-                         FStar_Compiler_Util.set_union uu___2 uu___3 in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___1
-                     FStar_Compiler_Util.set_elements in
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Tactics_Monad.trytac
-                         FStar_Tactics_Monad.cur_goal in
-                     FStar_Tactics_Monad.bind uu___3
-                       (fun gopt ->
-                          try
-                            (fun uu___4 ->
-                               match () with
-                               | () ->
-                                   let res =
-                                     if allow_guards
-                                     then
-                                       FStar_TypeChecker_Rel.try_teq true
-                                         env1 t1 t2
-                                     else
-                                       FStar_TypeChecker_Rel.teq_nosmt env1
-                                         t1 t2 in
-                                   (if dbg
-                                    then
-                                      (let uu___6 =
-                                         FStar_Common.string_of_option
-                                           (FStar_TypeChecker_Rel.guard_to_string
-                                              env1) res in
-                                       let uu___7 =
-                                         FStar_Syntax_Print.term_to_string t1 in
-                                       let uu___8 =
-                                         FStar_Syntax_Print.term_to_string t2 in
-                                       FStar_Compiler_Util.print3
-                                         "%%%%%%%%do_unify (RESULT %s) %s =? %s\n"
-                                         uu___6 uu___7 uu___8)
-                                    else ();
-                                    (match res with
-                                     | FStar_Pervasives_Native.None ->
-                                         FStar_Tactics_Monad.ret
-                                           FStar_Pervasives_Native.None
-                                     | FStar_Pervasives_Native.Some g ->
-                                         let uu___6 =
-                                           tc_unifier_solved_implicits env1
-                                             must_tot allow_guards all_uvars in
-                                         FStar_Tactics_Monad.op_let_Bang
-                                           uu___6
-                                           (fun uu___7 ->
-                                              let uu___8 =
-                                                FStar_Tactics_Monad.add_implicits
-                                                  g.FStar_TypeChecker_Common.implicits in
-                                              FStar_Tactics_Monad.op_let_Bang
-                                                uu___8
-                                                (fun uu___9 ->
-                                                   FStar_Tactics_Monad.ret
-                                                     (FStar_Pervasives_Native.Some
-                                                        g)))))) ()
-                          with
-                          | FStar_Errors.Err (uu___5, msg, uu___6) ->
-                              FStar_Tactics_Monad.mlog
-                                (fun uu___7 ->
-                                   FStar_Compiler_Util.print1
-                                     ">> do_unify error, (%s)\n" msg)
-                                (fun uu___7 ->
-                                   FStar_Tactics_Monad.ret
-                                     FStar_Pervasives_Native.None)
-                          | FStar_Errors.Error (uu___5, msg, r, uu___6) ->
-                              FStar_Tactics_Monad.mlog
-                                (fun uu___7 ->
-                                   let uu___8 =
-                                     FStar_Compiler_Range.string_of_range r in
-                                   FStar_Compiler_Util.print2
-                                     ">> do_unify error, (%s) at (%s)\n" msg
-                                     uu___8)
-                                (fun uu___7 ->
-                                   FStar_Tactics_Monad.ret
-                                     FStar_Pervasives_Native.None)) in
-                   FStar_Tactics_Monad.catch uu___2 in
-                 FStar_Tactics_Monad.op_let_Bang uu___1
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | FStar_Pervasives.Inl exn ->
-                          FStar_Tactics_Monad.traise exn
-                      | FStar_Pervasives.Inr v -> FStar_Tactics_Monad.ret v))
-let (__do_unify :
-  Prims.bool ->
-    Prims.bool ->
-      check_unifier_solved_implicits_side ->
-        env ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Syntax_Syntax.term ->
-              FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option
-                FStar_Tactics_Monad.tac)
-  =
-  fun allow_guards ->
-    fun must_tot ->
-      fun check_side ->
-        fun env1 ->
-          fun t1 ->
-            fun t2 ->
-              let dbg =
-                FStar_TypeChecker_Env.debug env1
-                  (FStar_Options.Other "TacUnify") in
-              FStar_Tactics_Monad.bind FStar_Tactics_Monad.idtac
-                (fun uu___ ->
-                   if dbg
-                   then
-                     (FStar_Options.push ();
-                      (let uu___3 =
-                         FStar_Options.set_options
-                           "--debug_level Rel --debug_level RelCheck" in
-                       ()))
-                   else ();
-                   (let uu___2 =
-                      __do_unify_wflags dbg allow_guards must_tot check_side
-                        env1 t1 t2 in
-                    FStar_Tactics_Monad.bind uu___2
-                      (fun r ->
-                         if dbg then FStar_Options.pop () else ();
-                         FStar_Tactics_Monad.ret r)))
-let (do_unify_aux :
-  Prims.bool ->
-    check_unifier_solved_implicits_side ->
-      env ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun must_tot ->
-    fun check_side ->
-      fun env1 ->
-        fun t1 ->
-          fun t2 ->
-            let uu___ = __do_unify false must_tot check_side env1 t1 t2 in
-            FStar_Tactics_Monad.bind uu___
-              (fun uu___1 ->
-                 match uu___1 with
-                 | FStar_Pervasives_Native.None ->
-                     FStar_Tactics_Monad.ret false
-                 | FStar_Pervasives_Native.Some g ->
-                     ((let uu___3 =
-                         let uu___4 =
-                           FStar_TypeChecker_Env.is_trivial_guard_formula g in
-                         Prims.op_Negation uu___4 in
-                       if uu___3
-                       then
-                         failwith
-                           "internal error: do_unify: guard is not trivial"
-                       else ());
-                      FStar_Tactics_Monad.ret true))
-let (do_unify :
-  Prims.bool ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun must_tot ->
-    fun env1 ->
-      fun t1 -> fun t2 -> do_unify_aux must_tot Check_both env1 t1 t2
-let (do_unify_maybe_guards :
-  Prims.bool ->
-    Prims.bool ->
-      env ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term ->
-            FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option
-              FStar_Tactics_Monad.tac)
-  =
-  fun allow_guards ->
-    fun must_tot ->
-      fun env1 ->
-        fun t1 ->
-          fun t2 -> __do_unify allow_guards must_tot Check_both env1 t1 t2
-let (do_match :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun must_tot ->
-    fun env1 ->
-      fun t1 ->
-        fun t2 ->
-          let uu___ =
-            FStar_Tactics_Monad.mk_tac
-              (fun ps ->
-                 let tx = FStar_Syntax_Unionfind.new_transaction () in
-                 FStar_Tactics_Result.Success (tx, ps)) in
-          FStar_Tactics_Monad.bind uu___
-            (fun tx ->
-               let uvs1 = FStar_Syntax_Free.uvars_uncached t1 in
-               let uu___1 = do_unify_aux must_tot Check_right_only env1 t1 t2 in
-               FStar_Tactics_Monad.bind uu___1
-                 (fun r ->
-                    if r
-                    then
-                      let uvs2 = FStar_Syntax_Free.uvars_uncached t1 in
-                      let uu___2 =
-                        let uu___3 = FStar_Compiler_Util.set_eq uvs1 uvs2 in
-                        Prims.op_Negation uu___3 in
-                      (if uu___2
-                       then
-                         (FStar_Syntax_Unionfind.rollback tx;
-                          FStar_Tactics_Monad.ret false)
-                       else FStar_Tactics_Monad.ret true)
-                    else FStar_Tactics_Monad.ret false))
-let (do_match_on_lhs :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun must_tot ->
-    fun env1 ->
-      fun t1 ->
-        fun t2 ->
-          let uu___ =
-            FStar_Tactics_Monad.mk_tac
-              (fun ps ->
-                 let tx = FStar_Syntax_Unionfind.new_transaction () in
-                 FStar_Tactics_Result.Success (tx, ps)) in
-          FStar_Tactics_Monad.bind uu___
-            (fun tx ->
-               let uu___1 = destruct_eq t1 in
-               match uu___1 with
-               | FStar_Pervasives_Native.None ->
-                   FStar_Tactics_Monad.fail "do_match_on_lhs: not an eq"
-               | FStar_Pervasives_Native.Some (lhs, uu___2) ->
-                   let uvs1 = FStar_Syntax_Free.uvars_uncached lhs in
-                   let uu___3 =
-                     do_unify_aux must_tot Check_right_only env1 t1 t2 in
-                   FStar_Tactics_Monad.bind uu___3
-                     (fun r ->
-                        if r
-                        then
-                          let uvs2 = FStar_Syntax_Free.uvars_uncached lhs in
-                          let uu___4 =
-                            let uu___5 = FStar_Compiler_Util.set_eq uvs1 uvs2 in
-                            Prims.op_Negation uu___5 in
-                          (if uu___4
-                           then
-                             (FStar_Syntax_Unionfind.rollback tx;
-                              FStar_Tactics_Monad.ret false)
-                           else FStar_Tactics_Monad.ret true)
-                        else FStar_Tactics_Monad.ret false))
-let (set_solution :
-  FStar_Tactics_Types.goal ->
-    FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun goal ->
-    fun solution ->
-      let uu___ =
-        FStar_Syntax_Unionfind.find
-          (goal.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-      match uu___ with
-      | FStar_Pervasives_Native.Some uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Tactics_Printing.goal_to_string_verbose goal in
-            FStar_Compiler_Util.format1 "Goal %s is already solved" uu___3 in
-          FStar_Tactics_Monad.fail uu___2
-      | FStar_Pervasives_Native.None ->
-          (FStar_Syntax_Unionfind.change
-             (goal.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_head
-             solution;
-           mark_goal_implicit_already_checked goal;
-           FStar_Tactics_Monad.ret ())
-let (trysolve :
-  FStar_Tactics_Types.goal ->
-    FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun goal ->
-    fun solution ->
-      let must_tot = true in
-      let uu___ = FStar_Tactics_Types.goal_env goal in
-      let uu___1 = FStar_Tactics_Types.goal_witness goal in
-      do_unify must_tot uu___ solution uu___1
-let (solve :
-  FStar_Tactics_Types.goal ->
-    FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun goal ->
-    fun solution ->
-      let e = FStar_Tactics_Types.goal_env goal in
-      FStar_Tactics_Monad.mlog
-        (fun uu___ ->
-           let uu___1 =
-             let uu___2 = FStar_Tactics_Types.goal_witness goal in
-             FStar_Syntax_Print.term_to_string uu___2 in
-           let uu___2 = FStar_Syntax_Print.term_to_string solution in
-           FStar_Compiler_Util.print2 "solve %s := %s\n" uu___1 uu___2)
-        (fun uu___ ->
-           let uu___1 = trysolve goal solution in
-           FStar_Tactics_Monad.bind uu___1
-             (fun b ->
-                if b
-                then
-                  FStar_Tactics_Monad.bind FStar_Tactics_Monad.dismiss
-                    (fun uu___2 -> FStar_Tactics_Monad.remove_solved_goals)
-                else
-                  (let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_Tactics_Types.goal_env goal in
-                       tts uu___5 solution in
-                     let uu___5 =
-                       let uu___6 = FStar_Tactics_Types.goal_env goal in
-                       let uu___7 = FStar_Tactics_Types.goal_witness goal in
-                       tts uu___6 uu___7 in
-                     let uu___6 =
-                       let uu___7 = FStar_Tactics_Types.goal_env goal in
-                       let uu___8 = FStar_Tactics_Types.goal_type goal in
-                       tts uu___7 uu___8 in
-                     FStar_Compiler_Util.format3 "%s does not solve %s : %s"
-                       uu___4 uu___5 uu___6 in
-                   FStar_Tactics_Monad.fail uu___3)))
-let (solve' :
-  FStar_Tactics_Types.goal ->
-    FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun goal ->
-    fun solution ->
-      let uu___ = set_solution goal solution in
-      FStar_Tactics_Monad.bind uu___
-        (fun uu___1 ->
-           FStar_Tactics_Monad.bind FStar_Tactics_Monad.dismiss
-             (fun uu___2 -> FStar_Tactics_Monad.remove_solved_goals))
-let (is_true : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let t1 = FStar_Syntax_Util.unascribe t in
-    let uu___ = FStar_Syntax_Util.un_squash t1 in
-    match uu___ with
-    | FStar_Pervasives_Native.Some t' ->
-        let t'1 = FStar_Syntax_Util.unascribe t' in
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress t'1 in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_fvar fv ->
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.true_lid
-         | uu___2 -> false)
-    | uu___1 -> false
-let (is_false : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.un_squash t in
-    match uu___ with
-    | FStar_Pervasives_Native.Some t' ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress t' in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_fvar fv ->
-             FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.false_lid
-         | uu___2 -> false)
-    | uu___1 -> false
-let (tadmit_t : FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac) =
-  fun t ->
-    let uu___ =
-      FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-        (fun ps ->
-           FStar_Tactics_Monad.bind FStar_Tactics_Monad.cur_goal
-             (fun g ->
-                (let uu___2 =
-                   let uu___3 = FStar_Tactics_Types.goal_type g in
-                   uu___3.FStar_Syntax_Syntax.pos in
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Tactics_Printing.goal_to_string ""
-                         FStar_Pervasives_Native.None ps g in
-                     FStar_Compiler_Util.format1
-                       "Tactics admitted goal <%s>\n\n" uu___5 in
-                   (FStar_Errors.Warning_TacAdmit, uu___4) in
-                 FStar_Errors.log_issue uu___2 uu___3);
-                solve' g t)) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "tadmit_t") uu___
-let (fresh : unit -> FStar_BigInt.t FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-      (fun ps ->
-         let n = ps.FStar_Tactics_Types.freshness in
-         let ps1 =
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness = (n + Prims.int_one);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           } in
-         let uu___1 = FStar_Tactics_Monad.set ps1 in
-         FStar_Tactics_Monad.bind uu___1
-           (fun uu___2 ->
-              let uu___3 = FStar_BigInt.of_int_fs n in
-              FStar_Tactics_Monad.ret uu___3))
-let (curms : unit -> FStar_BigInt.t FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Util.now_ms () in
-      FStar_Compiler_Effect.op_Bar_Greater uu___2 FStar_BigInt.of_int_fs in
-    FStar_Tactics_Monad.ret uu___1
-let (__tc :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_Reflection_Data.typ *
-        FStar_TypeChecker_Common.guard_t) FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t ->
-      FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-        (fun ps ->
-           FStar_Tactics_Monad.mlog
-             (fun uu___ ->
-                let uu___1 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.print1 "Tac> __tc(%s)\n" uu___1)
-             (fun uu___ ->
-                let e1 =
-                  {
-                    FStar_TypeChecker_Env.solver =
-                      (e.FStar_TypeChecker_Env.solver);
-                    FStar_TypeChecker_Env.range =
-                      (e.FStar_TypeChecker_Env.range);
-                    FStar_TypeChecker_Env.curmodule =
-                      (e.FStar_TypeChecker_Env.curmodule);
-                    FStar_TypeChecker_Env.gamma =
-                      (e.FStar_TypeChecker_Env.gamma);
-                    FStar_TypeChecker_Env.gamma_sig =
-                      (e.FStar_TypeChecker_Env.gamma_sig);
-                    FStar_TypeChecker_Env.gamma_cache =
-                      (e.FStar_TypeChecker_Env.gamma_cache);
-                    FStar_TypeChecker_Env.modules =
-                      (e.FStar_TypeChecker_Env.modules);
-                    FStar_TypeChecker_Env.expected_typ =
-                      (e.FStar_TypeChecker_Env.expected_typ);
-                    FStar_TypeChecker_Env.sigtab =
-                      (e.FStar_TypeChecker_Env.sigtab);
-                    FStar_TypeChecker_Env.attrtab =
-                      (e.FStar_TypeChecker_Env.attrtab);
-                    FStar_TypeChecker_Env.instantiate_imp =
-                      (e.FStar_TypeChecker_Env.instantiate_imp);
-                    FStar_TypeChecker_Env.effects =
-                      (e.FStar_TypeChecker_Env.effects);
-                    FStar_TypeChecker_Env.generalize =
-                      (e.FStar_TypeChecker_Env.generalize);
-                    FStar_TypeChecker_Env.letrecs =
-                      (e.FStar_TypeChecker_Env.letrecs);
-                    FStar_TypeChecker_Env.top_level =
-                      (e.FStar_TypeChecker_Env.top_level);
-                    FStar_TypeChecker_Env.check_uvars =
-                      (e.FStar_TypeChecker_Env.check_uvars);
-                    FStar_TypeChecker_Env.use_eq_strict =
-                      (e.FStar_TypeChecker_Env.use_eq_strict);
-                    FStar_TypeChecker_Env.is_iface =
-                      (e.FStar_TypeChecker_Env.is_iface);
-                    FStar_TypeChecker_Env.admit =
-                      (e.FStar_TypeChecker_Env.admit);
-                    FStar_TypeChecker_Env.lax = (e.FStar_TypeChecker_Env.lax);
-                    FStar_TypeChecker_Env.lax_universes =
-                      (e.FStar_TypeChecker_Env.lax_universes);
-                    FStar_TypeChecker_Env.phase1 =
-                      (e.FStar_TypeChecker_Env.phase1);
-                    FStar_TypeChecker_Env.failhard =
-                      (e.FStar_TypeChecker_Env.failhard);
-                    FStar_TypeChecker_Env.nosynth =
-                      (e.FStar_TypeChecker_Env.nosynth);
-                    FStar_TypeChecker_Env.uvar_subtyping = false;
-                    FStar_TypeChecker_Env.tc_term =
-                      (e.FStar_TypeChecker_Env.tc_term);
-                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                      (e.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.universe_of =
-                      (e.FStar_TypeChecker_Env.universe_of);
-                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                      =
-                      (e.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.teq_nosmt_force =
-                      (e.FStar_TypeChecker_Env.teq_nosmt_force);
-                    FStar_TypeChecker_Env.subtype_nosmt_force =
-                      (e.FStar_TypeChecker_Env.subtype_nosmt_force);
-                    FStar_TypeChecker_Env.qtbl_name_and_index =
-                      (e.FStar_TypeChecker_Env.qtbl_name_and_index);
-                    FStar_TypeChecker_Env.normalized_eff_names =
-                      (e.FStar_TypeChecker_Env.normalized_eff_names);
-                    FStar_TypeChecker_Env.fv_delta_depths =
-                      (e.FStar_TypeChecker_Env.fv_delta_depths);
-                    FStar_TypeChecker_Env.proof_ns =
-                      (e.FStar_TypeChecker_Env.proof_ns);
-                    FStar_TypeChecker_Env.synth_hook =
-                      (e.FStar_TypeChecker_Env.synth_hook);
-                    FStar_TypeChecker_Env.try_solve_implicits_hook =
-                      (e.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                    FStar_TypeChecker_Env.splice =
-                      (e.FStar_TypeChecker_Env.splice);
-                    FStar_TypeChecker_Env.mpreprocess =
-                      (e.FStar_TypeChecker_Env.mpreprocess);
-                    FStar_TypeChecker_Env.postprocess =
-                      (e.FStar_TypeChecker_Env.postprocess);
-                    FStar_TypeChecker_Env.identifier_info =
-                      (e.FStar_TypeChecker_Env.identifier_info);
-                    FStar_TypeChecker_Env.tc_hooks =
-                      (e.FStar_TypeChecker_Env.tc_hooks);
-                    FStar_TypeChecker_Env.dsenv =
-                      (e.FStar_TypeChecker_Env.dsenv);
-                    FStar_TypeChecker_Env.nbe = (e.FStar_TypeChecker_Env.nbe);
-                    FStar_TypeChecker_Env.strict_args_tab =
-                      (e.FStar_TypeChecker_Env.strict_args_tab);
-                    FStar_TypeChecker_Env.erasable_types_tab =
-                      (e.FStar_TypeChecker_Env.erasable_types_tab);
-                    FStar_TypeChecker_Env.enable_defer_to_tac =
-                      (e.FStar_TypeChecker_Env.enable_defer_to_tac);
-                    FStar_TypeChecker_Env.unif_allow_ref_guards =
-                      (e.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                    FStar_TypeChecker_Env.erase_erasable_args =
-                      (e.FStar_TypeChecker_Env.erase_erasable_args);
-                    FStar_TypeChecker_Env.core_check =
-                      (e.FStar_TypeChecker_Env.core_check)
-                  } in
-                try
-                  (fun uu___1 ->
-                     match () with
-                     | () ->
-                         let uu___2 =
-                           FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term
-                             e1 t true in
-                         FStar_Tactics_Monad.ret uu___2) ()
-                with
-                | FStar_Errors.Err (uu___2, msg, uu___3) ->
-                    let uu___4 = tts e1 t in
-                    let uu___5 =
-                      let uu___6 = FStar_TypeChecker_Env.all_binders e1 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___6
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    fail3 "Cannot type (1) %s in context (%s). Error = (%s)"
-                      uu___4 uu___5 msg
-                | FStar_Errors.Error (uu___2, msg, uu___3, uu___4) ->
-                    let uu___5 = tts e1 t in
-                    let uu___6 =
-                      let uu___7 = FStar_TypeChecker_Env.all_binders e1 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___7
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    fail3 "Cannot type (1) %s in context (%s). Error = (%s)"
-                      uu___5 uu___6 msg))
-let (__tc_ghost :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_Reflection_Data.typ *
-        FStar_TypeChecker_Common.guard_t) FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t ->
-      FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-        (fun ps ->
-           FStar_Tactics_Monad.mlog
-             (fun uu___ ->
-                let uu___1 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.print1 "Tac> __tc_ghost(%s)\n" uu___1)
-             (fun uu___ ->
-                let e1 =
-                  {
-                    FStar_TypeChecker_Env.solver =
-                      (e.FStar_TypeChecker_Env.solver);
-                    FStar_TypeChecker_Env.range =
-                      (e.FStar_TypeChecker_Env.range);
-                    FStar_TypeChecker_Env.curmodule =
-                      (e.FStar_TypeChecker_Env.curmodule);
-                    FStar_TypeChecker_Env.gamma =
-                      (e.FStar_TypeChecker_Env.gamma);
-                    FStar_TypeChecker_Env.gamma_sig =
-                      (e.FStar_TypeChecker_Env.gamma_sig);
-                    FStar_TypeChecker_Env.gamma_cache =
-                      (e.FStar_TypeChecker_Env.gamma_cache);
-                    FStar_TypeChecker_Env.modules =
-                      (e.FStar_TypeChecker_Env.modules);
-                    FStar_TypeChecker_Env.expected_typ =
-                      (e.FStar_TypeChecker_Env.expected_typ);
-                    FStar_TypeChecker_Env.sigtab =
-                      (e.FStar_TypeChecker_Env.sigtab);
-                    FStar_TypeChecker_Env.attrtab =
-                      (e.FStar_TypeChecker_Env.attrtab);
-                    FStar_TypeChecker_Env.instantiate_imp =
-                      (e.FStar_TypeChecker_Env.instantiate_imp);
-                    FStar_TypeChecker_Env.effects =
-                      (e.FStar_TypeChecker_Env.effects);
-                    FStar_TypeChecker_Env.generalize =
-                      (e.FStar_TypeChecker_Env.generalize);
-                    FStar_TypeChecker_Env.letrecs =
-                      (e.FStar_TypeChecker_Env.letrecs);
-                    FStar_TypeChecker_Env.top_level =
-                      (e.FStar_TypeChecker_Env.top_level);
-                    FStar_TypeChecker_Env.check_uvars =
-                      (e.FStar_TypeChecker_Env.check_uvars);
-                    FStar_TypeChecker_Env.use_eq_strict =
-                      (e.FStar_TypeChecker_Env.use_eq_strict);
-                    FStar_TypeChecker_Env.is_iface =
-                      (e.FStar_TypeChecker_Env.is_iface);
-                    FStar_TypeChecker_Env.admit =
-                      (e.FStar_TypeChecker_Env.admit);
-                    FStar_TypeChecker_Env.lax = (e.FStar_TypeChecker_Env.lax);
-                    FStar_TypeChecker_Env.lax_universes =
-                      (e.FStar_TypeChecker_Env.lax_universes);
-                    FStar_TypeChecker_Env.phase1 =
-                      (e.FStar_TypeChecker_Env.phase1);
-                    FStar_TypeChecker_Env.failhard =
-                      (e.FStar_TypeChecker_Env.failhard);
-                    FStar_TypeChecker_Env.nosynth =
-                      (e.FStar_TypeChecker_Env.nosynth);
-                    FStar_TypeChecker_Env.uvar_subtyping = false;
-                    FStar_TypeChecker_Env.tc_term =
-                      (e.FStar_TypeChecker_Env.tc_term);
-                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                      (e.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.universe_of =
-                      (e.FStar_TypeChecker_Env.universe_of);
-                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                      =
-                      (e.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.teq_nosmt_force =
-                      (e.FStar_TypeChecker_Env.teq_nosmt_force);
-                    FStar_TypeChecker_Env.subtype_nosmt_force =
-                      (e.FStar_TypeChecker_Env.subtype_nosmt_force);
-                    FStar_TypeChecker_Env.qtbl_name_and_index =
-                      (e.FStar_TypeChecker_Env.qtbl_name_and_index);
-                    FStar_TypeChecker_Env.normalized_eff_names =
-                      (e.FStar_TypeChecker_Env.normalized_eff_names);
-                    FStar_TypeChecker_Env.fv_delta_depths =
-                      (e.FStar_TypeChecker_Env.fv_delta_depths);
-                    FStar_TypeChecker_Env.proof_ns =
-                      (e.FStar_TypeChecker_Env.proof_ns);
-                    FStar_TypeChecker_Env.synth_hook =
-                      (e.FStar_TypeChecker_Env.synth_hook);
-                    FStar_TypeChecker_Env.try_solve_implicits_hook =
-                      (e.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                    FStar_TypeChecker_Env.splice =
-                      (e.FStar_TypeChecker_Env.splice);
-                    FStar_TypeChecker_Env.mpreprocess =
-                      (e.FStar_TypeChecker_Env.mpreprocess);
-                    FStar_TypeChecker_Env.postprocess =
-                      (e.FStar_TypeChecker_Env.postprocess);
-                    FStar_TypeChecker_Env.identifier_info =
-                      (e.FStar_TypeChecker_Env.identifier_info);
-                    FStar_TypeChecker_Env.tc_hooks =
-                      (e.FStar_TypeChecker_Env.tc_hooks);
-                    FStar_TypeChecker_Env.dsenv =
-                      (e.FStar_TypeChecker_Env.dsenv);
-                    FStar_TypeChecker_Env.nbe = (e.FStar_TypeChecker_Env.nbe);
-                    FStar_TypeChecker_Env.strict_args_tab =
-                      (e.FStar_TypeChecker_Env.strict_args_tab);
-                    FStar_TypeChecker_Env.erasable_types_tab =
-                      (e.FStar_TypeChecker_Env.erasable_types_tab);
-                    FStar_TypeChecker_Env.enable_defer_to_tac =
-                      (e.FStar_TypeChecker_Env.enable_defer_to_tac);
-                    FStar_TypeChecker_Env.unif_allow_ref_guards =
-                      (e.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                    FStar_TypeChecker_Env.erase_erasable_args =
-                      (e.FStar_TypeChecker_Env.erase_erasable_args);
-                    FStar_TypeChecker_Env.core_check =
-                      (e.FStar_TypeChecker_Env.core_check)
-                  } in
-                let e2 =
-                  {
-                    FStar_TypeChecker_Env.solver =
-                      (e1.FStar_TypeChecker_Env.solver);
-                    FStar_TypeChecker_Env.range =
-                      (e1.FStar_TypeChecker_Env.range);
-                    FStar_TypeChecker_Env.curmodule =
-                      (e1.FStar_TypeChecker_Env.curmodule);
-                    FStar_TypeChecker_Env.gamma =
-                      (e1.FStar_TypeChecker_Env.gamma);
-                    FStar_TypeChecker_Env.gamma_sig =
-                      (e1.FStar_TypeChecker_Env.gamma_sig);
-                    FStar_TypeChecker_Env.gamma_cache =
-                      (e1.FStar_TypeChecker_Env.gamma_cache);
-                    FStar_TypeChecker_Env.modules =
-                      (e1.FStar_TypeChecker_Env.modules);
-                    FStar_TypeChecker_Env.expected_typ =
-                      (e1.FStar_TypeChecker_Env.expected_typ);
-                    FStar_TypeChecker_Env.sigtab =
-                      (e1.FStar_TypeChecker_Env.sigtab);
-                    FStar_TypeChecker_Env.attrtab =
-                      (e1.FStar_TypeChecker_Env.attrtab);
-                    FStar_TypeChecker_Env.instantiate_imp =
-                      (e1.FStar_TypeChecker_Env.instantiate_imp);
-                    FStar_TypeChecker_Env.effects =
-                      (e1.FStar_TypeChecker_Env.effects);
-                    FStar_TypeChecker_Env.generalize =
-                      (e1.FStar_TypeChecker_Env.generalize);
-                    FStar_TypeChecker_Env.letrecs = [];
-                    FStar_TypeChecker_Env.top_level =
-                      (e1.FStar_TypeChecker_Env.top_level);
-                    FStar_TypeChecker_Env.check_uvars =
-                      (e1.FStar_TypeChecker_Env.check_uvars);
-                    FStar_TypeChecker_Env.use_eq_strict =
-                      (e1.FStar_TypeChecker_Env.use_eq_strict);
-                    FStar_TypeChecker_Env.is_iface =
-                      (e1.FStar_TypeChecker_Env.is_iface);
-                    FStar_TypeChecker_Env.admit =
-                      (e1.FStar_TypeChecker_Env.admit);
-                    FStar_TypeChecker_Env.lax =
-                      (e1.FStar_TypeChecker_Env.lax);
-                    FStar_TypeChecker_Env.lax_universes =
-                      (e1.FStar_TypeChecker_Env.lax_universes);
-                    FStar_TypeChecker_Env.phase1 =
-                      (e1.FStar_TypeChecker_Env.phase1);
-                    FStar_TypeChecker_Env.failhard =
-                      (e1.FStar_TypeChecker_Env.failhard);
-                    FStar_TypeChecker_Env.nosynth =
-                      (e1.FStar_TypeChecker_Env.nosynth);
-                    FStar_TypeChecker_Env.uvar_subtyping =
-                      (e1.FStar_TypeChecker_Env.uvar_subtyping);
-                    FStar_TypeChecker_Env.tc_term =
-                      (e1.FStar_TypeChecker_Env.tc_term);
-                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                      (e1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.universe_of =
-                      (e1.FStar_TypeChecker_Env.universe_of);
-                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                      =
-                      (e1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.teq_nosmt_force =
-                      (e1.FStar_TypeChecker_Env.teq_nosmt_force);
-                    FStar_TypeChecker_Env.subtype_nosmt_force =
-                      (e1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                    FStar_TypeChecker_Env.qtbl_name_and_index =
-                      (e1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                    FStar_TypeChecker_Env.normalized_eff_names =
-                      (e1.FStar_TypeChecker_Env.normalized_eff_names);
-                    FStar_TypeChecker_Env.fv_delta_depths =
-                      (e1.FStar_TypeChecker_Env.fv_delta_depths);
-                    FStar_TypeChecker_Env.proof_ns =
-                      (e1.FStar_TypeChecker_Env.proof_ns);
-                    FStar_TypeChecker_Env.synth_hook =
-                      (e1.FStar_TypeChecker_Env.synth_hook);
-                    FStar_TypeChecker_Env.try_solve_implicits_hook =
-                      (e1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                    FStar_TypeChecker_Env.splice =
-                      (e1.FStar_TypeChecker_Env.splice);
-                    FStar_TypeChecker_Env.mpreprocess =
-                      (e1.FStar_TypeChecker_Env.mpreprocess);
-                    FStar_TypeChecker_Env.postprocess =
-                      (e1.FStar_TypeChecker_Env.postprocess);
-                    FStar_TypeChecker_Env.identifier_info =
-                      (e1.FStar_TypeChecker_Env.identifier_info);
-                    FStar_TypeChecker_Env.tc_hooks =
-                      (e1.FStar_TypeChecker_Env.tc_hooks);
-                    FStar_TypeChecker_Env.dsenv =
-                      (e1.FStar_TypeChecker_Env.dsenv);
-                    FStar_TypeChecker_Env.nbe =
-                      (e1.FStar_TypeChecker_Env.nbe);
-                    FStar_TypeChecker_Env.strict_args_tab =
-                      (e1.FStar_TypeChecker_Env.strict_args_tab);
-                    FStar_TypeChecker_Env.erasable_types_tab =
-                      (e1.FStar_TypeChecker_Env.erasable_types_tab);
-                    FStar_TypeChecker_Env.enable_defer_to_tac =
-                      (e1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                    FStar_TypeChecker_Env.unif_allow_ref_guards =
-                      (e1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                    FStar_TypeChecker_Env.erase_erasable_args =
-                      (e1.FStar_TypeChecker_Env.erase_erasable_args);
-                    FStar_TypeChecker_Env.core_check =
-                      (e1.FStar_TypeChecker_Env.core_check)
-                  } in
-                try
-                  (fun uu___1 ->
-                     match () with
-                     | () ->
-                         let uu___2 =
-                           FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term e2 t in
-                         (match uu___2 with
-                          | (t1, lc, g) ->
-                              FStar_Tactics_Monad.ret
-                                (t1, (lc.FStar_TypeChecker_Common.res_typ),
-                                  g))) ()
-                with
-                | FStar_Errors.Err (uu___2, msg, uu___3) ->
-                    let uu___4 = tts e2 t in
-                    let uu___5 =
-                      let uu___6 = FStar_TypeChecker_Env.all_binders e2 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___6
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    fail3 "Cannot type (2) %s in context (%s). Error = (%s)"
-                      uu___4 uu___5 msg
-                | FStar_Errors.Error (uu___2, msg, uu___3, uu___4) ->
-                    let uu___5 = tts e2 t in
-                    let uu___6 =
-                      let uu___7 = FStar_TypeChecker_Env.all_binders e2 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___7
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    fail3 "Cannot type (2) %s in context (%s). Error = (%s)"
-                      uu___5 uu___6 msg))
-let (__tc_lax :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Common.guard_t) FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t ->
-      FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-        (fun ps ->
-           FStar_Tactics_Monad.mlog
-             (fun uu___ ->
-                let uu___1 = FStar_Syntax_Print.term_to_string t in
-                let uu___2 =
-                  let uu___3 = FStar_TypeChecker_Env.all_binders e in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___3
-                    (FStar_Syntax_Print.binders_to_string ", ") in
-                FStar_Compiler_Util.print2 "Tac> __tc_lax(%s)(Context:%s)\n"
-                  uu___1 uu___2)
-             (fun uu___ ->
-                let e1 =
-                  {
-                    FStar_TypeChecker_Env.solver =
-                      (e.FStar_TypeChecker_Env.solver);
-                    FStar_TypeChecker_Env.range =
-                      (e.FStar_TypeChecker_Env.range);
-                    FStar_TypeChecker_Env.curmodule =
-                      (e.FStar_TypeChecker_Env.curmodule);
-                    FStar_TypeChecker_Env.gamma =
-                      (e.FStar_TypeChecker_Env.gamma);
-                    FStar_TypeChecker_Env.gamma_sig =
-                      (e.FStar_TypeChecker_Env.gamma_sig);
-                    FStar_TypeChecker_Env.gamma_cache =
-                      (e.FStar_TypeChecker_Env.gamma_cache);
-                    FStar_TypeChecker_Env.modules =
-                      (e.FStar_TypeChecker_Env.modules);
-                    FStar_TypeChecker_Env.expected_typ =
-                      (e.FStar_TypeChecker_Env.expected_typ);
-                    FStar_TypeChecker_Env.sigtab =
-                      (e.FStar_TypeChecker_Env.sigtab);
-                    FStar_TypeChecker_Env.attrtab =
-                      (e.FStar_TypeChecker_Env.attrtab);
-                    FStar_TypeChecker_Env.instantiate_imp =
-                      (e.FStar_TypeChecker_Env.instantiate_imp);
-                    FStar_TypeChecker_Env.effects =
-                      (e.FStar_TypeChecker_Env.effects);
-                    FStar_TypeChecker_Env.generalize =
-                      (e.FStar_TypeChecker_Env.generalize);
-                    FStar_TypeChecker_Env.letrecs =
-                      (e.FStar_TypeChecker_Env.letrecs);
-                    FStar_TypeChecker_Env.top_level =
-                      (e.FStar_TypeChecker_Env.top_level);
-                    FStar_TypeChecker_Env.check_uvars =
-                      (e.FStar_TypeChecker_Env.check_uvars);
-                    FStar_TypeChecker_Env.use_eq_strict =
-                      (e.FStar_TypeChecker_Env.use_eq_strict);
-                    FStar_TypeChecker_Env.is_iface =
-                      (e.FStar_TypeChecker_Env.is_iface);
-                    FStar_TypeChecker_Env.admit =
-                      (e.FStar_TypeChecker_Env.admit);
-                    FStar_TypeChecker_Env.lax = (e.FStar_TypeChecker_Env.lax);
-                    FStar_TypeChecker_Env.lax_universes =
-                      (e.FStar_TypeChecker_Env.lax_universes);
-                    FStar_TypeChecker_Env.phase1 =
-                      (e.FStar_TypeChecker_Env.phase1);
-                    FStar_TypeChecker_Env.failhard =
-                      (e.FStar_TypeChecker_Env.failhard);
-                    FStar_TypeChecker_Env.nosynth =
-                      (e.FStar_TypeChecker_Env.nosynth);
-                    FStar_TypeChecker_Env.uvar_subtyping = false;
-                    FStar_TypeChecker_Env.tc_term =
-                      (e.FStar_TypeChecker_Env.tc_term);
-                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                      (e.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.universe_of =
-                      (e.FStar_TypeChecker_Env.universe_of);
-                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                      =
-                      (e.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.teq_nosmt_force =
-                      (e.FStar_TypeChecker_Env.teq_nosmt_force);
-                    FStar_TypeChecker_Env.subtype_nosmt_force =
-                      (e.FStar_TypeChecker_Env.subtype_nosmt_force);
-                    FStar_TypeChecker_Env.qtbl_name_and_index =
-                      (e.FStar_TypeChecker_Env.qtbl_name_and_index);
-                    FStar_TypeChecker_Env.normalized_eff_names =
-                      (e.FStar_TypeChecker_Env.normalized_eff_names);
-                    FStar_TypeChecker_Env.fv_delta_depths =
-                      (e.FStar_TypeChecker_Env.fv_delta_depths);
-                    FStar_TypeChecker_Env.proof_ns =
-                      (e.FStar_TypeChecker_Env.proof_ns);
-                    FStar_TypeChecker_Env.synth_hook =
-                      (e.FStar_TypeChecker_Env.synth_hook);
-                    FStar_TypeChecker_Env.try_solve_implicits_hook =
-                      (e.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                    FStar_TypeChecker_Env.splice =
-                      (e.FStar_TypeChecker_Env.splice);
-                    FStar_TypeChecker_Env.mpreprocess =
-                      (e.FStar_TypeChecker_Env.mpreprocess);
-                    FStar_TypeChecker_Env.postprocess =
-                      (e.FStar_TypeChecker_Env.postprocess);
-                    FStar_TypeChecker_Env.identifier_info =
-                      (e.FStar_TypeChecker_Env.identifier_info);
-                    FStar_TypeChecker_Env.tc_hooks =
-                      (e.FStar_TypeChecker_Env.tc_hooks);
-                    FStar_TypeChecker_Env.dsenv =
-                      (e.FStar_TypeChecker_Env.dsenv);
-                    FStar_TypeChecker_Env.nbe = (e.FStar_TypeChecker_Env.nbe);
-                    FStar_TypeChecker_Env.strict_args_tab =
-                      (e.FStar_TypeChecker_Env.strict_args_tab);
-                    FStar_TypeChecker_Env.erasable_types_tab =
-                      (e.FStar_TypeChecker_Env.erasable_types_tab);
-                    FStar_TypeChecker_Env.enable_defer_to_tac =
-                      (e.FStar_TypeChecker_Env.enable_defer_to_tac);
-                    FStar_TypeChecker_Env.unif_allow_ref_guards =
-                      (e.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                    FStar_TypeChecker_Env.erase_erasable_args =
-                      (e.FStar_TypeChecker_Env.erase_erasable_args);
-                    FStar_TypeChecker_Env.core_check =
-                      (e.FStar_TypeChecker_Env.core_check)
-                  } in
-                let e2 =
-                  {
-                    FStar_TypeChecker_Env.solver =
-                      (e1.FStar_TypeChecker_Env.solver);
-                    FStar_TypeChecker_Env.range =
-                      (e1.FStar_TypeChecker_Env.range);
-                    FStar_TypeChecker_Env.curmodule =
-                      (e1.FStar_TypeChecker_Env.curmodule);
-                    FStar_TypeChecker_Env.gamma =
-                      (e1.FStar_TypeChecker_Env.gamma);
-                    FStar_TypeChecker_Env.gamma_sig =
-                      (e1.FStar_TypeChecker_Env.gamma_sig);
-                    FStar_TypeChecker_Env.gamma_cache =
-                      (e1.FStar_TypeChecker_Env.gamma_cache);
-                    FStar_TypeChecker_Env.modules =
-                      (e1.FStar_TypeChecker_Env.modules);
-                    FStar_TypeChecker_Env.expected_typ =
-                      (e1.FStar_TypeChecker_Env.expected_typ);
-                    FStar_TypeChecker_Env.sigtab =
-                      (e1.FStar_TypeChecker_Env.sigtab);
-                    FStar_TypeChecker_Env.attrtab =
-                      (e1.FStar_TypeChecker_Env.attrtab);
-                    FStar_TypeChecker_Env.instantiate_imp =
-                      (e1.FStar_TypeChecker_Env.instantiate_imp);
-                    FStar_TypeChecker_Env.effects =
-                      (e1.FStar_TypeChecker_Env.effects);
-                    FStar_TypeChecker_Env.generalize =
-                      (e1.FStar_TypeChecker_Env.generalize);
-                    FStar_TypeChecker_Env.letrecs =
-                      (e1.FStar_TypeChecker_Env.letrecs);
-                    FStar_TypeChecker_Env.top_level =
-                      (e1.FStar_TypeChecker_Env.top_level);
-                    FStar_TypeChecker_Env.check_uvars =
-                      (e1.FStar_TypeChecker_Env.check_uvars);
-                    FStar_TypeChecker_Env.use_eq_strict =
-                      (e1.FStar_TypeChecker_Env.use_eq_strict);
-                    FStar_TypeChecker_Env.is_iface =
-                      (e1.FStar_TypeChecker_Env.is_iface);
-                    FStar_TypeChecker_Env.admit =
-                      (e1.FStar_TypeChecker_Env.admit);
-                    FStar_TypeChecker_Env.lax = true;
-                    FStar_TypeChecker_Env.lax_universes =
-                      (e1.FStar_TypeChecker_Env.lax_universes);
-                    FStar_TypeChecker_Env.phase1 =
-                      (e1.FStar_TypeChecker_Env.phase1);
-                    FStar_TypeChecker_Env.failhard =
-                      (e1.FStar_TypeChecker_Env.failhard);
-                    FStar_TypeChecker_Env.nosynth =
-                      (e1.FStar_TypeChecker_Env.nosynth);
-                    FStar_TypeChecker_Env.uvar_subtyping =
-                      (e1.FStar_TypeChecker_Env.uvar_subtyping);
-                    FStar_TypeChecker_Env.tc_term =
-                      (e1.FStar_TypeChecker_Env.tc_term);
-                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                      (e1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.universe_of =
-                      (e1.FStar_TypeChecker_Env.universe_of);
-                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                      =
-                      (e1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.teq_nosmt_force =
-                      (e1.FStar_TypeChecker_Env.teq_nosmt_force);
-                    FStar_TypeChecker_Env.subtype_nosmt_force =
-                      (e1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                    FStar_TypeChecker_Env.qtbl_name_and_index =
-                      (e1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                    FStar_TypeChecker_Env.normalized_eff_names =
-                      (e1.FStar_TypeChecker_Env.normalized_eff_names);
-                    FStar_TypeChecker_Env.fv_delta_depths =
-                      (e1.FStar_TypeChecker_Env.fv_delta_depths);
-                    FStar_TypeChecker_Env.proof_ns =
-                      (e1.FStar_TypeChecker_Env.proof_ns);
-                    FStar_TypeChecker_Env.synth_hook =
-                      (e1.FStar_TypeChecker_Env.synth_hook);
-                    FStar_TypeChecker_Env.try_solve_implicits_hook =
-                      (e1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                    FStar_TypeChecker_Env.splice =
-                      (e1.FStar_TypeChecker_Env.splice);
-                    FStar_TypeChecker_Env.mpreprocess =
-                      (e1.FStar_TypeChecker_Env.mpreprocess);
-                    FStar_TypeChecker_Env.postprocess =
-                      (e1.FStar_TypeChecker_Env.postprocess);
-                    FStar_TypeChecker_Env.identifier_info =
-                      (e1.FStar_TypeChecker_Env.identifier_info);
-                    FStar_TypeChecker_Env.tc_hooks =
-                      (e1.FStar_TypeChecker_Env.tc_hooks);
-                    FStar_TypeChecker_Env.dsenv =
-                      (e1.FStar_TypeChecker_Env.dsenv);
-                    FStar_TypeChecker_Env.nbe =
-                      (e1.FStar_TypeChecker_Env.nbe);
-                    FStar_TypeChecker_Env.strict_args_tab =
-                      (e1.FStar_TypeChecker_Env.strict_args_tab);
-                    FStar_TypeChecker_Env.erasable_types_tab =
-                      (e1.FStar_TypeChecker_Env.erasable_types_tab);
-                    FStar_TypeChecker_Env.enable_defer_to_tac =
-                      (e1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                    FStar_TypeChecker_Env.unif_allow_ref_guards =
-                      (e1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                    FStar_TypeChecker_Env.erase_erasable_args =
-                      (e1.FStar_TypeChecker_Env.erase_erasable_args);
-                    FStar_TypeChecker_Env.core_check =
-                      (e1.FStar_TypeChecker_Env.core_check)
-                  } in
-                let e3 =
-                  {
-                    FStar_TypeChecker_Env.solver =
-                      (e2.FStar_TypeChecker_Env.solver);
-                    FStar_TypeChecker_Env.range =
-                      (e2.FStar_TypeChecker_Env.range);
-                    FStar_TypeChecker_Env.curmodule =
-                      (e2.FStar_TypeChecker_Env.curmodule);
-                    FStar_TypeChecker_Env.gamma =
-                      (e2.FStar_TypeChecker_Env.gamma);
-                    FStar_TypeChecker_Env.gamma_sig =
-                      (e2.FStar_TypeChecker_Env.gamma_sig);
-                    FStar_TypeChecker_Env.gamma_cache =
-                      (e2.FStar_TypeChecker_Env.gamma_cache);
-                    FStar_TypeChecker_Env.modules =
-                      (e2.FStar_TypeChecker_Env.modules);
-                    FStar_TypeChecker_Env.expected_typ =
-                      (e2.FStar_TypeChecker_Env.expected_typ);
-                    FStar_TypeChecker_Env.sigtab =
-                      (e2.FStar_TypeChecker_Env.sigtab);
-                    FStar_TypeChecker_Env.attrtab =
-                      (e2.FStar_TypeChecker_Env.attrtab);
-                    FStar_TypeChecker_Env.instantiate_imp =
-                      (e2.FStar_TypeChecker_Env.instantiate_imp);
-                    FStar_TypeChecker_Env.effects =
-                      (e2.FStar_TypeChecker_Env.effects);
-                    FStar_TypeChecker_Env.generalize =
-                      (e2.FStar_TypeChecker_Env.generalize);
-                    FStar_TypeChecker_Env.letrecs = [];
-                    FStar_TypeChecker_Env.top_level =
-                      (e2.FStar_TypeChecker_Env.top_level);
-                    FStar_TypeChecker_Env.check_uvars =
-                      (e2.FStar_TypeChecker_Env.check_uvars);
-                    FStar_TypeChecker_Env.use_eq_strict =
-                      (e2.FStar_TypeChecker_Env.use_eq_strict);
-                    FStar_TypeChecker_Env.is_iface =
-                      (e2.FStar_TypeChecker_Env.is_iface);
-                    FStar_TypeChecker_Env.admit =
-                      (e2.FStar_TypeChecker_Env.admit);
-                    FStar_TypeChecker_Env.lax =
-                      (e2.FStar_TypeChecker_Env.lax);
-                    FStar_TypeChecker_Env.lax_universes =
-                      (e2.FStar_TypeChecker_Env.lax_universes);
-                    FStar_TypeChecker_Env.phase1 =
-                      (e2.FStar_TypeChecker_Env.phase1);
-                    FStar_TypeChecker_Env.failhard =
-                      (e2.FStar_TypeChecker_Env.failhard);
-                    FStar_TypeChecker_Env.nosynth =
-                      (e2.FStar_TypeChecker_Env.nosynth);
-                    FStar_TypeChecker_Env.uvar_subtyping =
-                      (e2.FStar_TypeChecker_Env.uvar_subtyping);
-                    FStar_TypeChecker_Env.tc_term =
-                      (e2.FStar_TypeChecker_Env.tc_term);
-                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                      (e2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.universe_of =
-                      (e2.FStar_TypeChecker_Env.universe_of);
-                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                      =
-                      (e2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                    FStar_TypeChecker_Env.teq_nosmt_force =
-                      (e2.FStar_TypeChecker_Env.teq_nosmt_force);
-                    FStar_TypeChecker_Env.subtype_nosmt_force =
-                      (e2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                    FStar_TypeChecker_Env.qtbl_name_and_index =
-                      (e2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                    FStar_TypeChecker_Env.normalized_eff_names =
-                      (e2.FStar_TypeChecker_Env.normalized_eff_names);
-                    FStar_TypeChecker_Env.fv_delta_depths =
-                      (e2.FStar_TypeChecker_Env.fv_delta_depths);
-                    FStar_TypeChecker_Env.proof_ns =
-                      (e2.FStar_TypeChecker_Env.proof_ns);
-                    FStar_TypeChecker_Env.synth_hook =
-                      (e2.FStar_TypeChecker_Env.synth_hook);
-                    FStar_TypeChecker_Env.try_solve_implicits_hook =
-                      (e2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                    FStar_TypeChecker_Env.splice =
-                      (e2.FStar_TypeChecker_Env.splice);
-                    FStar_TypeChecker_Env.mpreprocess =
-                      (e2.FStar_TypeChecker_Env.mpreprocess);
-                    FStar_TypeChecker_Env.postprocess =
-                      (e2.FStar_TypeChecker_Env.postprocess);
-                    FStar_TypeChecker_Env.identifier_info =
-                      (e2.FStar_TypeChecker_Env.identifier_info);
-                    FStar_TypeChecker_Env.tc_hooks =
-                      (e2.FStar_TypeChecker_Env.tc_hooks);
-                    FStar_TypeChecker_Env.dsenv =
-                      (e2.FStar_TypeChecker_Env.dsenv);
-                    FStar_TypeChecker_Env.nbe =
-                      (e2.FStar_TypeChecker_Env.nbe);
-                    FStar_TypeChecker_Env.strict_args_tab =
-                      (e2.FStar_TypeChecker_Env.strict_args_tab);
-                    FStar_TypeChecker_Env.erasable_types_tab =
-                      (e2.FStar_TypeChecker_Env.erasable_types_tab);
-                    FStar_TypeChecker_Env.enable_defer_to_tac =
-                      (e2.FStar_TypeChecker_Env.enable_defer_to_tac);
-                    FStar_TypeChecker_Env.unif_allow_ref_guards =
-                      (e2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                    FStar_TypeChecker_Env.erase_erasable_args =
-                      (e2.FStar_TypeChecker_Env.erase_erasable_args);
-                    FStar_TypeChecker_Env.core_check =
-                      (e2.FStar_TypeChecker_Env.core_check)
-                  } in
-                try
-                  (fun uu___1 ->
-                     match () with
-                     | () ->
-                         let uu___2 = FStar_TypeChecker_TcTerm.tc_term e3 t in
-                         FStar_Tactics_Monad.ret uu___2) ()
-                with
-                | FStar_Errors.Err (uu___2, msg, uu___3) ->
-                    let uu___4 = tts e3 t in
-                    let uu___5 =
-                      let uu___6 = FStar_TypeChecker_Env.all_binders e3 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___6
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    fail3 "Cannot type (3) %s in context (%s). Error = (%s)"
-                      uu___4 uu___5 msg
-                | FStar_Errors.Error (uu___2, msg, uu___3, uu___4) ->
-                    let uu___5 = tts e3 t in
-                    let uu___6 =
-                      let uu___7 = FStar_TypeChecker_Env.all_binders e3 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___7
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    fail3 "Cannot type (3) %s in context (%s). Error = (%s)"
-                      uu___5 uu___6 msg))
-let (tcc :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.comp FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t ->
-      let uu___ =
-        let uu___1 = __tc_lax e t in
-        FStar_Tactics_Monad.bind uu___1
-          (fun uu___2 ->
-             match uu___2 with
-             | (uu___3, lc, uu___4) ->
-                 let uu___5 =
-                   let uu___6 = FStar_TypeChecker_Common.lcomp_comp lc in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___6
-                     FStar_Pervasives_Native.fst in
-                 FStar_Tactics_Monad.ret uu___5) in
-      FStar_Compiler_Effect.op_Less_Bar (FStar_Tactics_Monad.wrap_err "tcc")
-        uu___
-let (tc :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Reflection_Data.typ FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t ->
-      let uu___ =
-        let uu___1 = tcc e t in
-        FStar_Tactics_Monad.bind uu___1
-          (fun c -> FStar_Tactics_Monad.ret (FStar_Syntax_Util.comp_result c)) in
-      FStar_Compiler_Effect.op_Less_Bar (FStar_Tactics_Monad.wrap_err "tc")
-        uu___
-let divide :
-  'a 'b .
-    FStar_BigInt.t ->
-      'a FStar_Tactics_Monad.tac ->
-        'b FStar_Tactics_Monad.tac -> ('a * 'b) FStar_Tactics_Monad.tac
-  =
-  fun n ->
-    fun l ->
-      fun r ->
-        FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-          (fun p ->
-             let uu___ =
-               try
-                 (fun uu___1 ->
-                    match () with
-                    | () ->
-                        let uu___2 =
-                          let uu___3 = FStar_BigInt.to_int_fs n in
-                          FStar_Compiler_List.splitAt uu___3
-                            p.FStar_Tactics_Types.goals in
-                        FStar_Tactics_Monad.ret uu___2) ()
-               with
-               | uu___1 ->
-                   FStar_Tactics_Monad.fail "divide: not enough goals" in
-             FStar_Tactics_Monad.bind uu___
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (lgs, rgs) ->
-                      let lp =
-                        {
-                          FStar_Tactics_Types.main_context =
-                            (p.FStar_Tactics_Types.main_context);
-                          FStar_Tactics_Types.all_implicits =
-                            (p.FStar_Tactics_Types.all_implicits);
-                          FStar_Tactics_Types.goals = lgs;
-                          FStar_Tactics_Types.smt_goals = [];
-                          FStar_Tactics_Types.depth =
-                            (p.FStar_Tactics_Types.depth);
-                          FStar_Tactics_Types.__dump =
-                            (p.FStar_Tactics_Types.__dump);
-                          FStar_Tactics_Types.psc =
-                            (p.FStar_Tactics_Types.psc);
-                          FStar_Tactics_Types.entry_range =
-                            (p.FStar_Tactics_Types.entry_range);
-                          FStar_Tactics_Types.guard_policy =
-                            (p.FStar_Tactics_Types.guard_policy);
-                          FStar_Tactics_Types.freshness =
-                            (p.FStar_Tactics_Types.freshness);
-                          FStar_Tactics_Types.tac_verb_dbg =
-                            (p.FStar_Tactics_Types.tac_verb_dbg);
-                          FStar_Tactics_Types.local_state =
-                            (p.FStar_Tactics_Types.local_state);
-                          FStar_Tactics_Types.urgency =
-                            (p.FStar_Tactics_Types.urgency)
-                        } in
-                      let uu___2 = FStar_Tactics_Monad.set lp in
-                      FStar_Tactics_Monad.bind uu___2
-                        (fun uu___3 ->
-                           FStar_Tactics_Monad.bind l
-                             (fun a1 ->
-                                FStar_Tactics_Monad.bind
-                                  FStar_Tactics_Monad.get
-                                  (fun lp' ->
-                                     let rp =
-                                       {
-                                         FStar_Tactics_Types.main_context =
-                                           (lp'.FStar_Tactics_Types.main_context);
-                                         FStar_Tactics_Types.all_implicits =
-                                           (lp'.FStar_Tactics_Types.all_implicits);
-                                         FStar_Tactics_Types.goals = rgs;
-                                         FStar_Tactics_Types.smt_goals = [];
-                                         FStar_Tactics_Types.depth =
-                                           (lp'.FStar_Tactics_Types.depth);
-                                         FStar_Tactics_Types.__dump =
-                                           (lp'.FStar_Tactics_Types.__dump);
-                                         FStar_Tactics_Types.psc =
-                                           (lp'.FStar_Tactics_Types.psc);
-                                         FStar_Tactics_Types.entry_range =
-                                           (lp'.FStar_Tactics_Types.entry_range);
-                                         FStar_Tactics_Types.guard_policy =
-                                           (lp'.FStar_Tactics_Types.guard_policy);
-                                         FStar_Tactics_Types.freshness =
-                                           (lp'.FStar_Tactics_Types.freshness);
-                                         FStar_Tactics_Types.tac_verb_dbg =
-                                           (lp'.FStar_Tactics_Types.tac_verb_dbg);
-                                         FStar_Tactics_Types.local_state =
-                                           (lp'.FStar_Tactics_Types.local_state);
-                                         FStar_Tactics_Types.urgency =
-                                           (lp'.FStar_Tactics_Types.urgency)
-                                       } in
-                                     let uu___4 = FStar_Tactics_Monad.set rp in
-                                     FStar_Tactics_Monad.bind uu___4
-                                       (fun uu___5 ->
-                                          FStar_Tactics_Monad.bind r
-                                            (fun b1 ->
-                                               FStar_Tactics_Monad.bind
-                                                 FStar_Tactics_Monad.get
-                                                 (fun rp' ->
-                                                    let p' =
-                                                      {
-                                                        FStar_Tactics_Types.main_context
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.main_context);
-                                                        FStar_Tactics_Types.all_implicits
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.all_implicits);
-                                                        FStar_Tactics_Types.goals
-                                                          =
-                                                          (FStar_Compiler_List.op_At
-                                                             lp'.FStar_Tactics_Types.goals
-                                                             rp'.FStar_Tactics_Types.goals);
-                                                        FStar_Tactics_Types.smt_goals
-                                                          =
-                                                          (FStar_Compiler_List.op_At
-                                                             lp'.FStar_Tactics_Types.smt_goals
-                                                             (FStar_Compiler_List.op_At
-                                                                rp'.FStar_Tactics_Types.smt_goals
-                                                                p.FStar_Tactics_Types.smt_goals));
-                                                        FStar_Tactics_Types.depth
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.depth);
-                                                        FStar_Tactics_Types.__dump
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.__dump);
-                                                        FStar_Tactics_Types.psc
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.psc);
-                                                        FStar_Tactics_Types.entry_range
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.entry_range);
-                                                        FStar_Tactics_Types.guard_policy
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.guard_policy);
-                                                        FStar_Tactics_Types.freshness
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.freshness);
-                                                        FStar_Tactics_Types.tac_verb_dbg
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.tac_verb_dbg);
-                                                        FStar_Tactics_Types.local_state
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.local_state);
-                                                        FStar_Tactics_Types.urgency
-                                                          =
-                                                          (rp'.FStar_Tactics_Types.urgency)
-                                                      } in
-                                                    let uu___6 =
-                                                      FStar_Tactics_Monad.set
-                                                        p' in
-                                                    FStar_Tactics_Monad.bind
-                                                      uu___6
-                                                      (fun uu___7 ->
-                                                         FStar_Tactics_Monad.bind
-                                                           FStar_Tactics_Monad.remove_solved_goals
-                                                           (fun uu___8 ->
-                                                              FStar_Tactics_Monad.ret
-                                                                (a1, b1)))))))))))
-let focus : 'a . 'a FStar_Tactics_Monad.tac -> 'a FStar_Tactics_Monad.tac =
-  fun f ->
-    let uu___ = divide FStar_BigInt.one f FStar_Tactics_Monad.idtac in
-    FStar_Tactics_Monad.bind uu___
-      (fun uu___1 ->
-         match uu___1 with | (a1, ()) -> FStar_Tactics_Monad.ret a1)
-let rec map :
-  'a . 'a FStar_Tactics_Monad.tac -> 'a Prims.list FStar_Tactics_Monad.tac =
-  fun tau ->
-    FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-      (fun p ->
-         match p.FStar_Tactics_Types.goals with
-         | [] -> FStar_Tactics_Monad.ret []
-         | uu___::uu___1 ->
-             let uu___2 =
-               let uu___3 = map tau in divide FStar_BigInt.one tau uu___3 in
-             FStar_Tactics_Monad.bind uu___2
-               (fun uu___3 ->
-                  match uu___3 with
-                  | (h, t) -> FStar_Tactics_Monad.ret (h :: t)))
-let (seq :
-  unit FStar_Tactics_Monad.tac ->
-    unit FStar_Tactics_Monad.tac -> unit FStar_Tactics_Monad.tac)
-  =
-  fun t1 ->
-    fun t2 ->
-      let uu___ =
-        FStar_Tactics_Monad.bind t1
-          (fun uu___1 ->
-             let uu___2 = map t2 in
-             FStar_Tactics_Monad.bind uu___2
-               (fun uu___3 -> FStar_Tactics_Monad.ret ())) in
-      focus uu___
-let (should_check_goal_uvar :
-  FStar_Tactics_Types.goal -> FStar_Syntax_Syntax.should_check_uvar) =
-  fun g ->
-    FStar_Syntax_Util.ctx_uvar_should_check
-      g.FStar_Tactics_Types.goal_ctx_uvar
-let (goal_typedness_deps :
-  FStar_Tactics_Types.goal -> FStar_Syntax_Syntax.ctx_uvar Prims.list) =
-  fun g ->
-    FStar_Syntax_Util.ctx_uvar_typedness_deps
-      g.FStar_Tactics_Types.goal_ctx_uvar
-let (bnorm_and_replace :
-  FStar_Tactics_Types.goal -> unit FStar_Tactics_Monad.tac) =
-  fun g -> let uu___ = bnorm_goal g in FStar_Tactics_Monad.replace_cur uu___
-let (arrow_one :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.binder *
-        FStar_Syntax_Syntax.comp) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Syntax_Util.arrow_one_ln t in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (b, c) ->
-          let uu___1 = FStar_TypeChecker_Core.open_binders_in_comp env1 [b] c in
-          (match uu___1 with
-           | (env2, b1::[], c1) ->
-               FStar_Pervasives_Native.Some (env2, b1, c1))
-let (intro : unit -> FStar_Syntax_Syntax.binder FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    let uu___1 =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun goal ->
-           let uu___2 =
-             let uu___3 = FStar_Tactics_Types.goal_env goal in
-             let uu___4 =
-               let uu___5 = FStar_Tactics_Types.goal_env goal in
-               let uu___6 = FStar_Tactics_Types.goal_type goal in
-               whnf uu___5 uu___6 in
-             arrow_one uu___3 uu___4 in
-           match uu___2 with
-           | FStar_Pervasives_Native.Some (env', b, c) ->
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Util.is_total_comp c in
-                 Prims.op_Negation uu___4 in
-               if uu___3
-               then FStar_Tactics_Monad.fail "Codomain is effectful"
-               else
-                 (let typ' = FStar_Syntax_Util.comp_result c in
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = should_check_goal_uvar goal in
-                      FStar_Pervasives_Native.Some uu___7 in
-                    let uu___7 = goal_typedness_deps goal in
-                    FStar_Tactics_Monad.new_uvar "intro" env' typ' uu___6
-                      uu___7 (rangeof goal) in
-                  FStar_Tactics_Monad.op_let_Bang uu___5
-                    (fun uu___6 ->
-                       match uu___6 with
-                       | (body, ctx_uvar) ->
-                           let sol =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Syntax_Util.residual_comp_of_comp c in
-                               FStar_Pervasives_Native.Some uu___8 in
-                             FStar_Syntax_Util.abs [b] body uu___7 in
-                           let uu___7 = set_solution goal sol in
-                           FStar_Tactics_Monad.op_let_Bang uu___7
-                             (fun uu___8 ->
-                                let g =
-                                  FStar_Tactics_Types.mk_goal env' ctx_uvar
-                                    goal.FStar_Tactics_Types.opts
-                                    goal.FStar_Tactics_Types.is_guard
-                                    goal.FStar_Tactics_Types.label in
-                                let uu___9 = bnorm_and_replace g in
-                                FStar_Tactics_Monad.op_let_Bang uu___9
-                                  (fun uu___10 -> FStar_Tactics_Monad.ret b))))
-           | FStar_Pervasives_Native.None ->
-               let uu___3 =
-                 let uu___4 = FStar_Tactics_Types.goal_env goal in
-                 let uu___5 = FStar_Tactics_Types.goal_type goal in
-                 tts uu___4 uu___5 in
-               fail1 "goal is not an arrow (%s)" uu___3) in
-    FStar_Compiler_Effect.op_Less_Bar (FStar_Tactics_Monad.wrap_err "intro")
-      uu___1
-let (intro_rec :
-  unit ->
-    (FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.binder)
-      FStar_Tactics_Monad.tac)
-  =
-  fun uu___ ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun goal ->
-         FStar_Compiler_Util.print_string
-           "WARNING (intro_rec): calling this is known to cause normalizer loops\n";
-         FStar_Compiler_Util.print_string
-           "WARNING (intro_rec): proceed at your own risk...\n";
-         (let uu___3 =
-            let uu___4 = FStar_Tactics_Types.goal_env goal in
-            let uu___5 =
-              let uu___6 = FStar_Tactics_Types.goal_env goal in
-              let uu___7 = FStar_Tactics_Types.goal_type goal in
-              whnf uu___6 uu___7 in
-            arrow_one uu___4 uu___5 in
-          match uu___3 with
-          | FStar_Pervasives_Native.Some (env', b, c) ->
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Util.is_total_comp c in
-                Prims.op_Negation uu___5 in
-              if uu___4
-              then FStar_Tactics_Monad.fail "Codomain is effectful"
-              else
-                (let bv =
-                   let uu___6 = FStar_Tactics_Types.goal_type goal in
-                   FStar_Syntax_Syntax.gen_bv "__recf"
-                     FStar_Pervasives_Native.None uu___6 in
-                 let uu___6 =
-                   let uu___7 =
-                     let uu___8 = should_check_goal_uvar goal in
-                     FStar_Pervasives_Native.Some uu___8 in
-                   let uu___8 = goal_typedness_deps goal in
-                   FStar_Tactics_Monad.new_uvar "intro_rec" env'
-                     (FStar_Syntax_Util.comp_result c) uu___7 uu___8
-                     (rangeof goal) in
-                 FStar_Tactics_Monad.op_let_Bang uu___6
-                   (fun uu___7 ->
-                      match uu___7 with
-                      | (u, ctx_uvar_u) ->
-                          let lb =
-                            let uu___8 = FStar_Tactics_Types.goal_type goal in
-                            let uu___9 =
-                              FStar_Syntax_Util.abs [b] u
-                                FStar_Pervasives_Native.None in
-                            FStar_Syntax_Util.mk_letbinding
-                              (FStar_Pervasives.Inl bv) [] uu___8
-                              FStar_Parser_Const.effect_Tot_lid uu___9 []
-                              FStar_Compiler_Range.dummyRange in
-                          let body = FStar_Syntax_Syntax.bv_to_name bv in
-                          let uu___8 =
-                            FStar_Syntax_Subst.close_let_rec [lb] body in
-                          (match uu___8 with
-                           | (lbs, body1) ->
-                               let tm =
-                                 let uu___9 =
-                                   let uu___10 =
-                                     FStar_Tactics_Types.goal_witness goal in
-                                   uu___10.FStar_Syntax_Syntax.pos in
-                                 FStar_Syntax_Syntax.mk
-                                   (FStar_Syntax_Syntax.Tm_let
-                                      ((true, lbs), body1)) uu___9 in
-                               let uu___9 = set_solution goal tm in
-                               FStar_Tactics_Monad.op_let_Bang uu___9
-                                 (fun uu___10 ->
-                                    let uu___11 =
-                                      bnorm_and_replace
-                                        {
-                                          FStar_Tactics_Types.goal_main_env =
-                                            (goal.FStar_Tactics_Types.goal_main_env);
-                                          FStar_Tactics_Types.goal_ctx_uvar =
-                                            ctx_uvar_u;
-                                          FStar_Tactics_Types.opts =
-                                            (goal.FStar_Tactics_Types.opts);
-                                          FStar_Tactics_Types.is_guard =
-                                            (goal.FStar_Tactics_Types.is_guard);
-                                          FStar_Tactics_Types.label =
-                                            (goal.FStar_Tactics_Types.label)
-                                        } in
-                                    FStar_Tactics_Monad.op_let_Bang uu___11
-                                      (fun uu___12 ->
-                                         let uu___13 =
-                                           let uu___14 =
-                                             FStar_Syntax_Syntax.mk_binder bv in
-                                           (uu___14, b) in
-                                         FStar_Tactics_Monad.ret uu___13)))))
-          | FStar_Pervasives_Native.None ->
-              let uu___4 =
-                let uu___5 = FStar_Tactics_Types.goal_env goal in
-                let uu___6 = FStar_Tactics_Types.goal_type goal in
-                tts uu___5 uu___6 in
-              fail1 "intro_rec: goal is not an arrow (%s)" uu___4))
-let (norm :
-  FStar_Syntax_Embeddings.norm_step Prims.list ->
-    unit FStar_Tactics_Monad.tac)
-  =
-  fun s ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun goal ->
-         let uu___ =
-           FStar_Tactics_Monad.if_verbose
-             (fun uu___1 ->
-                let uu___2 =
-                  let uu___3 = FStar_Tactics_Types.goal_witness goal in
-                  FStar_Syntax_Print.term_to_string uu___3 in
-                FStar_Compiler_Util.print1 "norm: witness = %s\n" uu___2) in
-         FStar_Tactics_Monad.op_let_Bang uu___
-           (fun uu___1 ->
-              let steps =
-                let uu___2 = FStar_TypeChecker_Cfg.translate_norm_steps s in
-                FStar_Compiler_List.op_At
-                  [FStar_TypeChecker_Env.Reify;
-                  FStar_TypeChecker_Env.UnfoldTac] uu___2 in
-              let t =
-                let uu___2 = FStar_Tactics_Types.goal_env goal in
-                let uu___3 = FStar_Tactics_Types.goal_type goal in
-                normalize steps uu___2 uu___3 in
-              let uu___2 = goal_with_type goal t in
-              FStar_Tactics_Monad.replace_cur uu___2))
-let (norm_term_env :
-  env ->
-    FStar_Syntax_Embeddings.norm_step Prims.list ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun s ->
-      fun t ->
-        let uu___ =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-            (fun ps ->
-               let opts =
-                 match ps.FStar_Tactics_Types.goals with
-                 | g::uu___1 -> g.FStar_Tactics_Types.opts
-                 | uu___1 -> FStar_Options.peek () in
-               let uu___1 =
-                 FStar_Tactics_Monad.if_verbose
-                   (fun uu___2 ->
-                      let uu___3 = FStar_Syntax_Print.term_to_string t in
-                      FStar_Compiler_Util.print1 "norm_term_env: t = %s\n"
-                        uu___3) in
-               FStar_Tactics_Monad.op_let_Bang uu___1
-                 (fun uu___2 ->
-                    let uu___3 = __tc_lax e t in
-                    FStar_Tactics_Monad.op_let_Bang uu___3
-                      (fun uu___4 ->
-                         match uu___4 with
-                         | (t1, uu___5, uu___6) ->
-                             let steps =
-                               let uu___7 =
-                                 FStar_TypeChecker_Cfg.translate_norm_steps s in
-                               FStar_Compiler_List.op_At
-                                 [FStar_TypeChecker_Env.Reify;
-                                 FStar_TypeChecker_Env.UnfoldTac] uu___7 in
-                             let t2 =
-                               normalize steps
-                                 ps.FStar_Tactics_Types.main_context t1 in
-                             let uu___7 =
-                               FStar_Tactics_Monad.if_verbose
-                                 (fun uu___8 ->
-                                    let uu___9 =
-                                      FStar_Syntax_Print.term_to_string t2 in
-                                    FStar_Compiler_Util.print1
-                                      "norm_term_env: t' = %s\n" uu___9) in
-                             FStar_Tactics_Monad.op_let_Bang uu___7
-                               (fun uu___8 -> FStar_Tactics_Monad.ret t2)))) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "norm_term") uu___
-let (refine_intro : unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    let uu___1 =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun g ->
-           let uu___2 =
-             let uu___3 = FStar_Tactics_Types.goal_env g in
-             let uu___4 = FStar_Tactics_Types.goal_type g in
-             FStar_TypeChecker_Rel.base_and_refinement uu___3 uu___4 in
-           match uu___2 with
-           | (uu___3, FStar_Pervasives_Native.None) ->
-               FStar_Tactics_Monad.fail "not a refinement"
-           | (t, FStar_Pervasives_Native.Some (bv, phi)) ->
-               (mark_goal_implicit_already_checked g;
-                (let g1 = goal_with_type g t in
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 =
-                       let uu___7 = FStar_Syntax_Syntax.mk_binder bv in
-                       [uu___7] in
-                     FStar_Syntax_Subst.open_term uu___6 phi in
-                   match uu___5 with
-                   | (bvs, phi1) ->
-                       let uu___6 =
-                         let uu___7 = FStar_Compiler_List.hd bvs in
-                         uu___7.FStar_Syntax_Syntax.binder_bv in
-                       (uu___6, phi1) in
-                 match uu___4 with
-                 | (bv1, phi1) ->
-                     let uu___5 =
-                       let uu___6 = FStar_Tactics_Types.goal_env g in
-                       let uu___7 =
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               let uu___11 =
-                                 FStar_Tactics_Types.goal_witness g in
-                               (bv1, uu___11) in
-                             FStar_Syntax_Syntax.NT uu___10 in
-                           [uu___9] in
-                         FStar_Syntax_Subst.subst uu___8 phi1 in
-                       let uu___8 =
-                         let uu___9 = should_check_goal_uvar g in
-                         FStar_Pervasives_Native.Some uu___9 in
-                       FStar_Tactics_Monad.mk_irrelevant_goal
-                         "refine_intro refinement" uu___6 uu___7 uu___8
-                         (rangeof g) g.FStar_Tactics_Types.opts
-                         g.FStar_Tactics_Types.label in
-                     FStar_Tactics_Monad.op_let_Bang uu___5
-                       (fun g2 ->
-                          FStar_Tactics_Monad.op_let_Bang
-                            FStar_Tactics_Monad.dismiss
-                            (fun uu___6 ->
-                               FStar_Tactics_Monad.add_goals [g1; g2]))))) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "refine_intro") uu___1
-let (__exact_now :
-  Prims.bool -> FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac) =
-  fun set_expected_typ ->
-    fun t ->
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun goal ->
-           let env1 =
-             if set_expected_typ
-             then
-               let uu___ = FStar_Tactics_Types.goal_env goal in
-               let uu___1 = FStar_Tactics_Types.goal_type goal in
-               FStar_TypeChecker_Env.set_expected_typ uu___ uu___1
-             else FStar_Tactics_Types.goal_env goal in
-           let uu___ = __tc env1 t in
-           FStar_Tactics_Monad.op_let_Bang uu___
-             (fun uu___1 ->
-                match uu___1 with
-                | (t1, typ, guard) ->
-                    let uu___2 =
-                      FStar_Tactics_Monad.if_verbose
-                        (fun uu___3 ->
-                           let uu___4 = FStar_Syntax_Print.term_to_string typ in
-                           let uu___5 =
-                             let uu___6 = FStar_Tactics_Types.goal_env goal in
-                             FStar_TypeChecker_Rel.guard_to_string uu___6
-                               guard in
-                           FStar_Compiler_Util.print2
-                             "__exact_now: got type %s\n__exact_now: and guard %s\n"
-                             uu___4 uu___5) in
-                    FStar_Tactics_Monad.op_let_Bang uu___2
-                      (fun uu___3 ->
-                         let uu___4 =
-                           let uu___5 = FStar_Tactics_Types.goal_env goal in
-                           let uu___6 =
-                             let uu___7 = should_check_goal_uvar goal in
-                             FStar_Pervasives_Native.Some uu___7 in
-                           proc_guard "__exact typing" uu___5 guard uu___6
-                             (rangeof goal) in
-                         FStar_Tactics_Monad.op_let_Bang uu___4
-                           (fun uu___5 ->
-                              let uu___6 =
-                                FStar_Tactics_Monad.if_verbose
-                                  (fun uu___7 ->
-                                     let uu___8 =
-                                       FStar_Syntax_Print.term_to_string typ in
-                                     let uu___9 =
-                                       let uu___10 =
-                                         FStar_Tactics_Types.goal_type goal in
-                                       FStar_Syntax_Print.term_to_string
-                                         uu___10 in
-                                     FStar_Compiler_Util.print2
-                                       "__exact_now: unifying %s and %s\n"
-                                       uu___8 uu___9) in
-                              FStar_Tactics_Monad.op_let_Bang uu___6
-                                (fun uu___7 ->
-                                   let uu___8 =
-                                     let uu___9 =
-                                       FStar_Tactics_Types.goal_env goal in
-                                     let uu___10 =
-                                       FStar_Tactics_Types.goal_type goal in
-                                     do_unify true uu___9 typ uu___10 in
-                                   FStar_Tactics_Monad.op_let_Bang uu___8
-                                     (fun b ->
-                                        if b
-                                        then
-                                          (mark_goal_implicit_already_checked
-                                             goal;
-                                           solve goal t1)
-                                        else
-                                          (let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_Tactics_Types.goal_env
-                                                   goal in
-                                               tts uu___12 in
-                                             let uu___12 =
-                                               FStar_Tactics_Types.goal_type
-                                                 goal in
-                                             FStar_TypeChecker_Err.print_discrepancy
-                                               uu___11 typ uu___12 in
-                                           match uu___10 with
-                                           | (typ1, goalt) ->
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Tactics_Types.goal_env
-                                                     goal in
-                                                 tts uu___12 t1 in
-                                               let uu___12 =
-                                                 let uu___13 =
-                                                   FStar_Tactics_Types.goal_env
-                                                     goal in
-                                                 let uu___14 =
-                                                   FStar_Tactics_Types.goal_witness
-                                                     goal in
-                                                 tts uu___13 uu___14 in
-                                               fail4
-                                                 "%s : %s does not exactly solve the goal %s (witness = %s)"
-                                                 uu___11 typ1 goalt uu___12)))))))
-let (t_exact :
-  Prims.bool ->
-    Prims.bool -> FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun try_refine ->
-    fun set_expected_typ ->
-      fun tm ->
-        let uu___ =
-          let uu___1 =
-            FStar_Tactics_Monad.if_verbose
-              (fun uu___2 ->
-                 let uu___3 = FStar_Syntax_Print.term_to_string tm in
-                 FStar_Compiler_Util.print1 "t_exact: tm = %s\n" uu___3) in
-          FStar_Tactics_Monad.op_let_Bang uu___1
-            (fun uu___2 ->
-               let uu___3 =
-                 let uu___4 = __exact_now set_expected_typ tm in
-                 FStar_Tactics_Monad.catch uu___4 in
-               FStar_Tactics_Monad.op_let_Bang uu___3
-                 (fun uu___4 ->
-                    match uu___4 with
-                    | FStar_Pervasives.Inr r -> FStar_Tactics_Monad.ret ()
-                    | FStar_Pervasives.Inl e when
-                        Prims.op_Negation try_refine ->
-                        FStar_Tactics_Monad.traise e
-                    | FStar_Pervasives.Inl e ->
-                        let uu___5 =
-                          FStar_Tactics_Monad.if_verbose
-                            (fun uu___6 ->
-                               FStar_Compiler_Util.print_string
-                                 "__exact_now failed, trying refine...\n") in
-                        FStar_Tactics_Monad.op_let_Bang uu___5
-                          (fun uu___6 ->
-                             let uu___7 =
-                               let uu___8 =
-                                 let uu___9 =
-                                   norm [FStar_Syntax_Embeddings.Delta] in
-                                 FStar_Tactics_Monad.op_let_Bang uu___9
-                                   (fun uu___10 ->
-                                      let uu___11 = refine_intro () in
-                                      FStar_Tactics_Monad.op_let_Bang uu___11
-                                        (fun uu___12 ->
-                                           __exact_now set_expected_typ tm)) in
-                               FStar_Tactics_Monad.catch uu___8 in
-                             FStar_Tactics_Monad.op_let_Bang uu___7
-                               (fun uu___8 ->
-                                  match uu___8 with
-                                  | FStar_Pervasives.Inr r ->
-                                      let uu___9 =
-                                        FStar_Tactics_Monad.if_verbose
-                                          (fun uu___10 ->
-                                             FStar_Compiler_Util.print_string
-                                               "__exact_now: failed after refining too\n") in
-                                      FStar_Tactics_Monad.op_let_Bang uu___9
-                                        (fun uu___10 ->
-                                           FStar_Tactics_Monad.ret ())
-                                  | FStar_Pervasives.Inl uu___9 ->
-                                      let uu___10 =
-                                        FStar_Tactics_Monad.if_verbose
-                                          (fun uu___11 ->
-                                             FStar_Compiler_Util.print_string
-                                               "__exact_now: was not a refinement\n") in
-                                      FStar_Tactics_Monad.op_let_Bang uu___10
-                                        (fun uu___11 ->
-                                           FStar_Tactics_Monad.traise e))))) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "exact") uu___
-let (try_unify_by_application :
-  FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option ->
-    Prims.bool ->
-      env ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual *
-                FStar_Syntax_Syntax.ctx_uvar) Prims.list
-                FStar_Tactics_Monad.tac)
-  =
-  fun should_check ->
-    fun only_match ->
-      fun e ->
-        fun ty1 ->
-          fun ty2 ->
-            fun rng ->
-              let f = if only_match then do_match else do_unify in
-              let must_tot = true in
-              let rec aux acc typedness_deps ty11 =
-                let uu___ = f must_tot e ty2 ty11 in
-                FStar_Tactics_Monad.op_let_Bang uu___
-                  (fun uu___1 ->
-                     if uu___1
-                     then FStar_Tactics_Monad.ret acc
-                     else
-                       (let uu___2 = FStar_Syntax_Util.arrow_one ty11 in
-                        match uu___2 with
-                        | FStar_Pervasives_Native.None ->
-                            let uu___3 = tts e ty11 in
-                            let uu___4 = tts e ty2 in
-                            fail2 "Could not instantiate, %s to %s" uu___3
-                              uu___4
-                        | FStar_Pervasives_Native.Some (b, c) ->
-                            let uu___3 =
-                              let uu___4 = FStar_Syntax_Util.is_total_comp c in
-                              Prims.op_Negation uu___4 in
-                            if uu___3
-                            then
-                              FStar_Tactics_Monad.fail
-                                "Codomain is effectful"
-                            else
-                              (let uu___5 =
-                                 FStar_Tactics_Monad.new_uvar "apply arg" e
-                                   (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                   should_check typedness_deps rng in
-                               FStar_Tactics_Monad.op_let_Bang uu___5
-                                 (fun uu___6 ->
-                                    match uu___6 with
-                                    | (uvt, uv) ->
-                                        let uu___7 =
-                                          FStar_Tactics_Monad.if_verbose
-                                            (fun uu___8 ->
-                                               let uu___9 =
-                                                 FStar_Syntax_Print.ctx_uvar_to_string
-                                                   uv in
-                                               FStar_Compiler_Util.print1
-                                                 "t_apply: generated uvar %s\n"
-                                                 uu___9) in
-                                        FStar_Tactics_Monad.op_let_Bang
-                                          uu___7
-                                          (fun uu___8 ->
-                                             let typ =
-                                               FStar_Syntax_Util.comp_result
-                                                 c in
-                                             let typ' =
-                                               FStar_Syntax_Subst.subst
-                                                 [FStar_Syntax_Syntax.NT
-                                                    ((b.FStar_Syntax_Syntax.binder_bv),
-                                                      uvt)] typ in
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_Syntax_Util.aqual_of_binder
-                                                     b in
-                                                 (uvt, uu___11, uv) in
-                                               uu___10 :: acc in
-                                             aux uu___9 (uv ::
-                                               typedness_deps) typ'))))) in
-              aux [] [] ty1
-let (apply_implicits_as_goals :
-  FStar_TypeChecker_Env.env ->
-    FStar_Tactics_Types.goal FStar_Pervasives_Native.option ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.ctx_uvar) Prims.list ->
-        FStar_Tactics_Types.goal Prims.list Prims.list
-          FStar_Tactics_Monad.tac)
-  =
-  fun env1 ->
-    fun gl ->
-      fun imps ->
-        let one_implicit_as_goal uu___ =
-          match uu___ with
-          | (term, ctx_uvar) ->
-              let uu___1 = FStar_Syntax_Util.head_and_args term in
-              (match uu___1 with
-               | (hd, uu___2) ->
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Subst.compress hd in
-                     uu___4.FStar_Syntax_Syntax.n in
-                   (match uu___3 with
-                    | FStar_Syntax_Syntax.Tm_uvar (ctx_uvar1, uu___4) ->
-                        let gl1 =
-                          match gl with
-                          | FStar_Pervasives_Native.None ->
-                              let uu___5 = FStar_Options.peek () in
-                              FStar_Tactics_Types.mk_goal env1 ctx_uvar1
-                                uu___5 true "goal for unsolved implicit"
-                          | FStar_Pervasives_Native.Some gl2 ->
-                              {
-                                FStar_Tactics_Types.goal_main_env =
-                                  (gl2.FStar_Tactics_Types.goal_main_env);
-                                FStar_Tactics_Types.goal_ctx_uvar = ctx_uvar1;
-                                FStar_Tactics_Types.opts =
-                                  (gl2.FStar_Tactics_Types.opts);
-                                FStar_Tactics_Types.is_guard =
-                                  (gl2.FStar_Tactics_Types.is_guard);
-                                FStar_Tactics_Types.label =
-                                  (gl2.FStar_Tactics_Types.label)
-                              } in
-                        let gl2 = bnorm_goal gl1 in
-                        FStar_Tactics_Monad.ret [gl2]
-                    | uu___4 -> FStar_Tactics_Monad.ret [])) in
-        FStar_Compiler_Effect.op_Bar_Greater imps
-          (FStar_Tactics_Monad.mapM one_implicit_as_goal)
-let (t_apply :
-  Prims.bool ->
-    Prims.bool ->
-      Prims.bool -> FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun uopt ->
-    fun only_match ->
-      fun tc_resolved_uvars ->
-        fun tm ->
-          let uu___ =
-            let tc_resolved_uvars1 = true in
-            let uu___1 =
-              FStar_Tactics_Monad.if_verbose
-                (fun uu___2 ->
-                   let uu___3 = FStar_Compiler_Util.string_of_bool uopt in
-                   let uu___4 = FStar_Compiler_Util.string_of_bool only_match in
-                   let uu___5 =
-                     FStar_Compiler_Util.string_of_bool tc_resolved_uvars1 in
-                   let uu___6 = FStar_Syntax_Print.term_to_string tm in
-                   FStar_Compiler_Util.print4
-                     "t_apply: uopt %s, only_match %s, tc_resolved_uvars %s, tm = %s\n"
-                     uu___3 uu___4 uu___5 uu___6) in
-            FStar_Tactics_Monad.op_let_Bang uu___1
-              (fun uu___2 ->
-                 FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-                   (fun ps ->
-                      FStar_Tactics_Monad.op_let_Bang
-                        FStar_Tactics_Monad.cur_goal
-                        (fun goal ->
-                           let e = FStar_Tactics_Types.goal_env goal in
-                           let should_check = should_check_goal_uvar goal in
-                           FStar_Tactics_Monad.register_goal goal;
-                           (let uu___4 = __tc e tm in
-                            FStar_Tactics_Monad.op_let_Bang uu___4
-                              (fun uu___5 ->
-                                 match uu___5 with
-                                 | (tm1, typ, guard) ->
-                                     let uu___6 =
-                                       FStar_Tactics_Monad.if_verbose
-                                         (fun uu___7 ->
-                                            let uu___8 =
-                                              FStar_Syntax_Print.term_to_string
-                                                tm1 in
-                                            let uu___9 =
-                                              FStar_Tactics_Printing.goal_to_string_verbose
-                                                goal in
-                                            let uu___10 =
-                                              FStar_TypeChecker_Env.print_gamma
-                                                e.FStar_TypeChecker_Env.gamma in
-                                            let uu___11 =
-                                              FStar_Syntax_Print.term_to_string
-                                                typ in
-                                            let uu___12 =
-                                              FStar_TypeChecker_Rel.guard_to_string
-                                                e guard in
-                                            FStar_Compiler_Util.print5
-                                              "t_apply: tm = %s\nt_apply: goal = %s\nenv.gamma=%s\ntyp=%s\nguard=%s\n"
-                                              uu___8 uu___9 uu___10 uu___11
-                                              uu___12) in
-                                     FStar_Tactics_Monad.op_let_Bang uu___6
-                                       (fun uu___7 ->
-                                          let typ1 = bnorm e typ in
-                                          let uu___8 =
-                                            let uu___9 =
-                                              FStar_Tactics_Types.goal_type
-                                                goal in
-                                            try_unify_by_application
-                                              (FStar_Pervasives_Native.Some
-                                                 should_check) only_match e
-                                              typ1 uu___9 (rangeof goal) in
-                                          FStar_Tactics_Monad.op_let_Bang
-                                            uu___8
-                                            (fun uvs ->
-                                               let uu___9 =
-                                                 FStar_Tactics_Monad.if_verbose
-                                                   (fun uu___10 ->
-                                                      let uu___11 =
-                                                        (FStar_Common.string_of_list
-                                                           ())
-                                                          (fun uu___12 ->
-                                                             match uu___12
-                                                             with
-                                                             | (t, uu___13,
-                                                                uu___14) ->
-                                                                 FStar_Syntax_Print.term_to_string
-                                                                   t) uvs in
-                                                      FStar_Compiler_Util.print1
-                                                        "t_apply: found args = %s\n"
-                                                        uu___11) in
-                                               FStar_Tactics_Monad.op_let_Bang
-                                                 uu___9
-                                                 (fun uu___10 ->
-                                                    let w =
-                                                      FStar_Compiler_List.fold_right
-                                                        (fun uu___11 ->
-                                                           fun w1 ->
-                                                             match uu___11
-                                                             with
-                                                             | (uvt, q,
-                                                                uu___12) ->
-                                                                 FStar_Syntax_Util.mk_app
-                                                                   w1
-                                                                   [(uvt, q)])
-                                                        uvs tm1 in
-                                                    let uvset =
-                                                      let uu___11 =
-                                                        FStar_Syntax_Free.new_uv_set
-                                                          () in
-                                                      FStar_Compiler_List.fold_right
-                                                        (fun uu___12 ->
-                                                           fun s ->
-                                                             match uu___12
-                                                             with
-                                                             | (uu___13,
-                                                                uu___14, uv)
-                                                                 ->
-                                                                 let uu___15
-                                                                   =
-                                                                   let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Util.ctx_uvar_typ
-                                                                    uv in
-                                                                   FStar_Syntax_Free.uvars
-                                                                    uu___16 in
-                                                                 FStar_Compiler_Util.set_union
-                                                                   s uu___15)
-                                                        uvs uu___11 in
-                                                    let free_in_some_goal uv
-                                                      =
-                                                      FStar_Compiler_Util.set_mem
-                                                        uv uvset in
-                                                    let uu___11 =
-                                                      solve' goal w in
-                                                    FStar_Tactics_Monad.op_let_Bang
-                                                      uu___11
-                                                      (fun uu___12 ->
-                                                         let uvt_uv_l =
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uvs
-                                                             (FStar_Compiler_List.map
-                                                                (fun uu___13
-                                                                   ->
-                                                                   match uu___13
-                                                                   with
-                                                                   | 
-                                                                   (uvt, _q,
-                                                                    uv) ->
-                                                                    (uvt, uv))) in
-                                                         let uu___13 =
-                                                           apply_implicits_as_goals
-                                                             e
-                                                             (FStar_Pervasives_Native.Some
-                                                                goal)
-                                                             uvt_uv_l in
-                                                         FStar_Tactics_Monad.op_let_Bang
-                                                           uu___13
-                                                           (fun sub_goals ->
-                                                              let sub_goals1
-                                                                =
-                                                                let uu___14 =
-                                                                  let uu___15
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Compiler_List.flatten
-                                                                    sub_goals)
-                                                                    (FStar_Compiler_List.filter
-                                                                    (fun g ->
-                                                                    let uu___16
-                                                                    =
-                                                                    uopt &&
-                                                                    (free_in_some_goal
-                                                                    g.FStar_Tactics_Types.goal_ctx_uvar) in
-                                                                    Prims.op_Negation
-                                                                    uu___16)) in
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___15
-                                                                    (
-                                                                    FStar_Compiler_List.map
-                                                                    bnorm_goal) in
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  uu___14
-                                                                  FStar_Compiler_List.rev in
-                                                              let uu___14 =
-                                                                FStar_Tactics_Monad.add_goals
-                                                                  sub_goals1 in
-                                                              FStar_Tactics_Monad.op_let_Bang
-                                                                uu___14
-                                                                (fun uu___15
-                                                                   ->
-                                                                   proc_guard
-                                                                    "apply guard"
-                                                                    e guard
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    should_check)
-                                                                    (rangeof
-                                                                    goal)))))))))))) in
-          FStar_Compiler_Effect.op_Less_Bar
-            (FStar_Tactics_Monad.wrap_err "apply") uu___
-let (lemma_or_sq :
-  FStar_Syntax_Syntax.comp ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term)
-      FStar_Pervasives_Native.option)
-  =
-  fun c ->
-    let uu___ = FStar_Syntax_Util.comp_eff_name_res_and_args c in
-    match uu___ with
-    | (eff_name, res, args) ->
-        let uu___1 =
-          FStar_Ident.lid_equals eff_name FStar_Parser_Const.effect_Lemma_lid in
-        if uu___1
-        then
-          let uu___2 =
-            match args with
-            | pre::post::uu___3 ->
-                ((FStar_Pervasives_Native.fst pre),
-                  (FStar_Pervasives_Native.fst post))
-            | uu___3 -> failwith "apply_lemma: impossible: not a lemma" in
-          (match uu___2 with
-           | (pre, post) ->
-               let post1 =
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Syntax_Syntax.as_arg FStar_Syntax_Util.exp_unit in
-                   [uu___4] in
-                 FStar_Syntax_Util.mk_app post uu___3 in
-               FStar_Pervasives_Native.Some (pre, post1))
-        else
-          (let uu___3 =
-             (FStar_Syntax_Util.is_pure_effect eff_name) ||
-               (FStar_Syntax_Util.is_ghost_effect eff_name) in
-           if uu___3
-           then
-             let uu___4 = FStar_Syntax_Util.un_squash res in
-             FStar_Compiler_Util.map_opt uu___4
-               (fun post -> (FStar_Syntax_Util.t_true, post))
-           else FStar_Pervasives_Native.None)
-let rec fold_left :
-  'a 'b .
-    ('a -> 'b -> 'b FStar_Tactics_Monad.tac) ->
-      'b -> 'a Prims.list -> 'b FStar_Tactics_Monad.tac
-  =
-  fun f ->
-    fun e ->
-      fun xs ->
-        match xs with
-        | [] -> FStar_Tactics_Monad.ret e
-        | x::xs1 ->
-            let uu___ = f x e in
-            FStar_Tactics_Monad.bind uu___ (fun e' -> fold_left f e' xs1)
-let (t_apply_lemma :
-  Prims.bool ->
-    Prims.bool -> FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun noinst ->
-    fun noinst_lhs ->
-      fun tm ->
-        let uu___ =
-          let uu___1 =
-            FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-              (fun ps ->
-                 let uu___2 =
-                   FStar_Tactics_Monad.if_verbose
-                     (fun uu___3 ->
-                        let uu___4 = FStar_Syntax_Print.term_to_string tm in
-                        FStar_Compiler_Util.print1 "apply_lemma: tm = %s\n"
-                          uu___4) in
-                 FStar_Tactics_Monad.op_let_Bang uu___2
-                   (fun uu___3 ->
-                      let is_unit_t t =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Subst.compress t in
-                          uu___5.FStar_Syntax_Syntax.n in
-                        match uu___4 with
-                        | FStar_Syntax_Syntax.Tm_fvar fv when
-                            FStar_Syntax_Syntax.fv_eq_lid fv
-                              FStar_Parser_Const.unit_lid
-                            -> true
-                        | uu___5 -> false in
-                      FStar_Tactics_Monad.op_let_Bang
-                        FStar_Tactics_Monad.cur_goal
-                        (fun goal ->
-                           let env1 = FStar_Tactics_Types.goal_env goal in
-                           FStar_Tactics_Monad.register_goal goal;
-                           (let uu___5 = __tc env1 tm in
-                            FStar_Tactics_Monad.op_let_Bang uu___5
-                              (fun uu___6 ->
-                                 match uu___6 with
-                                 | (tm1, t, guard) ->
-                                     let uu___7 =
-                                       FStar_Syntax_Util.arrow_formals_comp t in
-                                     (match uu___7 with
-                                      | (bs, comp) ->
-                                          let uu___8 = lemma_or_sq comp in
-                                          (match uu___8 with
-                                           | FStar_Pervasives_Native.None ->
-                                               FStar_Tactics_Monad.fail
-                                                 "not a lemma or squashed function"
-                                           | FStar_Pervasives_Native.Some
-                                               (pre, post) ->
-                                               let uu___9 =
-                                                 fold_left
-                                                   (fun uu___10 ->
-                                                      fun uu___11 ->
-                                                        match (uu___10,
-                                                                uu___11)
-                                                        with
-                                                        | ({
-                                                             FStar_Syntax_Syntax.binder_bv
-                                                               = b;
-                                                             FStar_Syntax_Syntax.binder_qual
-                                                               = aq;
-                                                             FStar_Syntax_Syntax.binder_attrs
-                                                               = uu___12;_},
-                                                           (uvs, deps, imps,
-                                                            subst)) ->
-                                                            let b_t =
-                                                              FStar_Syntax_Subst.subst
-                                                                subst
-                                                                b.FStar_Syntax_Syntax.sort in
-                                                            let uu___13 =
-                                                              is_unit_t b_t in
-                                                            if uu___13
-                                                            then
-                                                              FStar_Compiler_Effect.op_Less_Bar
-                                                                FStar_Tactics_Monad.ret
-                                                                (((FStar_Syntax_Util.exp_unit,
-                                                                    aq) ::
-                                                                  uvs), deps,
-                                                                  imps,
-                                                                  ((FStar_Syntax_Syntax.NT
-                                                                    (b,
-                                                                    FStar_Syntax_Util.exp_unit))
-                                                                  :: subst))
-                                                            else
-                                                              (let uu___15 =
-                                                                 let uu___16
-                                                                   =
-                                                                   let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    goal
-                                                                    should_check_goal_uvar in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___18
-                                                                    (fun
-                                                                    uu___19
-                                                                    ->
-                                                                    match uu___19
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Strict
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Allow_ghost
-                                                                    "apply lemma uvar"
-                                                                    | 
-                                                                    x -> x) in
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___17
-                                                                    (fun
-                                                                    uu___18
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___18) in
-                                                                 FStar_Tactics_Monad.new_uvar
-                                                                   "apply_lemma"
-                                                                   env1 b_t
-                                                                   uu___16
-                                                                   deps
-                                                                   (rangeof
-                                                                    goal) in
-                                                               FStar_Tactics_Monad.op_let_Bang
-                                                                 uu___15
-                                                                 (fun uu___16
-                                                                    ->
-                                                                    match uu___16
-                                                                    with
-                                                                    | 
-                                                                    (t1, u)
-                                                                    ->
-                                                                    ((
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env1)
-                                                                    (FStar_Options.Other
-                                                                    "2635") in
-                                                                    if
-                                                                    uu___18
-                                                                    then
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Syntax_Print.ctx_uvar_to_string
-                                                                    u in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    tm1 in
-                                                                    FStar_Compiler_Util.print2
-                                                                    "Apply lemma created a new uvar %s while applying %s\n"
-                                                                    uu___19
-                                                                    uu___20
-                                                                    else ());
-                                                                    FStar_Tactics_Monad.ret
-                                                                    (((t1,
-                                                                    aq) ::
-                                                                    uvs), (u
-                                                                    :: deps),
-                                                                    ((t1, u)
-                                                                    :: imps),
-                                                                    ((FStar_Syntax_Syntax.NT
-                                                                    (b, t1))
-                                                                    ::
-                                                                    subst))))))
-                                                   ([], [], [], []) bs in
-                                               FStar_Tactics_Monad.op_let_Bang
-                                                 uu___9
-                                                 (fun uu___10 ->
-                                                    match uu___10 with
-                                                    | (uvs, uu___11,
-                                                       implicits1, subst) ->
-                                                        let implicits2 =
-                                                          FStar_Compiler_List.rev
-                                                            implicits1 in
-                                                        let uvs1 =
-                                                          FStar_Compiler_List.rev
-                                                            uvs in
-                                                        let pre1 =
-                                                          FStar_Syntax_Subst.subst
-                                                            subst pre in
-                                                        let post1 =
-                                                          FStar_Syntax_Subst.subst
-                                                            subst post in
-                                                        let post_u =
-                                                          env1.FStar_TypeChecker_Env.universe_of
-                                                            env1 post1 in
-                                                        let cmp_func =
-                                                          if noinst
-                                                          then do_match
-                                                          else
-                                                            if noinst_lhs
-                                                            then
-                                                              do_match_on_lhs
-                                                            else do_unify in
-                                                        let uu___12 =
-                                                          let must_tot =
-                                                            false in
-                                                          let uu___13 =
-                                                            FStar_Tactics_Types.goal_type
-                                                              goal in
-                                                          let uu___14 =
-                                                            FStar_Syntax_Util.mk_squash
-                                                              post_u post1 in
-                                                          cmp_func must_tot
-                                                            env1 uu___13
-                                                            uu___14 in
-                                                        FStar_Tactics_Monad.op_let_Bang
-                                                          uu___12
-                                                          (fun b ->
-                                                             if
-                                                               Prims.op_Negation
-                                                                 b
-                                                             then
-                                                               let uu___13 =
-                                                                 let uu___14
-                                                                   =
-                                                                   FStar_Syntax_Util.mk_squash
-                                                                    post_u
-                                                                    post1 in
-                                                                 let uu___15
-                                                                   =
-                                                                   FStar_Tactics_Types.goal_type
-                                                                    goal in
-                                                                 FStar_TypeChecker_Err.print_discrepancy
-                                                                   (tts env1)
-                                                                   uu___14
-                                                                   uu___15 in
-                                                               match uu___13
-                                                               with
-                                                               | (post2,
-                                                                  goalt) ->
-                                                                   let uu___14
-                                                                    =
-                                                                    tts env1
-                                                                    tm1 in
-                                                                   fail3
-                                                                    "Cannot instantiate lemma %s (with postcondition: %s) to match goal (%s)"
-                                                                    uu___14
-                                                                    post2
-                                                                    goalt
-                                                             else
-                                                               (let goal_sc =
-                                                                  should_check_goal_uvar
-                                                                    goal in
-                                                                let uu___14 =
-                                                                  solve' goal
-                                                                    FStar_Syntax_Util.exp_unit in
-                                                                FStar_Tactics_Monad.op_let_Bang
-                                                                  uu___14
-                                                                  (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    let is_free_uvar
-                                                                    uv t1 =
-                                                                    let free_uvars
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Syntax_Free.uvars
-                                                                    t1 in
-                                                                    FStar_Compiler_Util.set_elements
-                                                                    uu___17 in
-                                                                    FStar_Compiler_List.map
-                                                                    (fun x ->
-                                                                    x.FStar_Syntax_Syntax.ctx_uvar_head)
-                                                                    uu___16 in
-                                                                    FStar_Compiler_List.existsML
-                                                                    (fun u ->
-                                                                    FStar_Syntax_Unionfind.equiv
-                                                                    u uv)
-                                                                    free_uvars in
-                                                                    let appears
-                                                                    uv goals
-                                                                    =
-                                                                    FStar_Compiler_List.existsML
-                                                                    (fun g'
-                                                                    ->
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Tactics_Types.goal_type
-                                                                    g' in
-                                                                    is_free_uvar
-                                                                    uv
-                                                                    uu___16)
-                                                                    goals in
-                                                                    let checkone
-                                                                    t1 goals
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Util.head_and_args
-                                                                    t1 in
-                                                                    match uu___16
-                                                                    with
-                                                                    | 
-                                                                    (hd,
-                                                                    uu___17)
-                                                                    ->
-                                                                    (match 
-                                                                    hd.FStar_Syntax_Syntax.n
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_uvar
-                                                                    (uv,
-                                                                    uu___18)
-                                                                    ->
-                                                                    appears
-                                                                    uv.FStar_Syntax_Syntax.ctx_uvar_head
-                                                                    goals
-                                                                    | 
-                                                                    uu___18
-                                                                    -> false) in
-                                                                    let must_tot
-                                                                    = false in
-                                                                    let uu___16
-                                                                    =
-                                                                    apply_implicits_as_goals
-                                                                    env1
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    goal)
-                                                                    implicits2 in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___16
-                                                                    (fun
-                                                                    sub_goals
-                                                                    ->
-                                                                    let sub_goals1
-                                                                    =
-                                                                    FStar_Compiler_List.flatten
-                                                                    sub_goals in
-                                                                    let rec filter'
-                                                                    f xs =
-                                                                    match xs
-                                                                    with
-                                                                    | 
-                                                                    [] -> []
-                                                                    | 
-                                                                    x::xs1 ->
-                                                                    let uu___17
-                                                                    = f x xs1 in
-                                                                    if
-                                                                    uu___17
-                                                                    then
-                                                                    let uu___18
-                                                                    =
-                                                                    filter' f
-                                                                    xs1 in x
-                                                                    ::
-                                                                    uu___18
-                                                                    else
-                                                                    filter' f
-                                                                    xs1 in
-                                                                    let sub_goals2
-                                                                    =
-                                                                    filter'
-                                                                    (fun g ->
-                                                                    fun goals
-                                                                    ->
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Tactics_Types.goal_witness
-                                                                    g in
-                                                                    checkone
-                                                                    uu___18
-                                                                    goals in
-                                                                    Prims.op_Negation
-                                                                    uu___17)
-                                                                    sub_goals1 in
-                                                                    let uu___17
-                                                                    =
-                                                                    proc_guard
-                                                                    "apply_lemma guard"
-                                                                    env1
-                                                                    guard
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    goal_sc)
-                                                                    (rangeof
-                                                                    goal) in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___17
-                                                                    (fun
-                                                                    uu___18
-                                                                    ->
-                                                                    let pre_u
-                                                                    =
-                                                                    env1.FStar_TypeChecker_Env.universe_of
-                                                                    env1 pre1 in
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_Env.guard_of_guard_formula
-                                                                    (FStar_TypeChecker_Common.NonTrivial
-                                                                    pre1) in
-                                                                    FStar_TypeChecker_Rel.simplify_guard
-                                                                    env1
-                                                                    uu___22 in
-                                                                    uu___21.FStar_TypeChecker_Common.guard_f in
-                                                                    match uu___20
-                                                                    with
-                                                                    | 
-                                                                    FStar_TypeChecker_Common.Trivial
-                                                                    ->
-                                                                    FStar_Tactics_Monad.ret
-                                                                    ()
-                                                                    | 
-                                                                    FStar_TypeChecker_Common.NonTrivial
-                                                                    uu___21
-                                                                    ->
-                                                                    FStar_Tactics_Monad.add_irrelevant_goal
-                                                                    goal
-                                                                    "apply_lemma precondition"
-                                                                    env1 pre1
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    goal_sc) in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___19
-                                                                    (fun
-                                                                    uu___20
-                                                                    ->
-                                                                    FStar_Tactics_Monad.add_goals
-                                                                    sub_goals2)))))))))))))) in
-          focus uu___1 in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "apply_lemma") uu___
-let (split_env :
-  FStar_Syntax_Syntax.bv ->
-    env ->
-      (env * FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.bv Prims.list)
-        FStar_Pervasives_Native.option)
-  =
-  fun bvar ->
-    fun e ->
-      let rec aux e1 =
-        let uu___ = FStar_TypeChecker_Env.pop_bv e1 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some (bv', e') ->
-            let uu___1 = FStar_Syntax_Syntax.bv_eq bvar bv' in
-            if uu___1
-            then FStar_Pervasives_Native.Some (e', bv', [])
-            else
-              (let uu___3 = aux e' in
-               FStar_Compiler_Util.map_opt uu___3
-                 (fun uu___4 ->
-                    match uu___4 with
-                    | (e'', bv, bvs) -> (e'', bv, (bv' :: bvs)))) in
-      let uu___ = aux e in
-      FStar_Compiler_Util.map_opt uu___
-        (fun uu___1 ->
-           match uu___1 with
-           | (e', bv, bvs) -> (e', bv, (FStar_Compiler_List.rev bvs)))
-let (subst_goal :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.bv ->
-      FStar_Tactics_Types.goal ->
-        (FStar_Syntax_Syntax.bv * FStar_Tactics_Types.goal)
-          FStar_Pervasives_Native.option FStar_Tactics_Monad.tac)
-  =
-  fun b1 ->
-    fun b2 ->
-      fun g ->
-        let uu___ =
-          let uu___1 = FStar_Tactics_Types.goal_env g in split_env b1 uu___1 in
-        match uu___ with
-        | FStar_Pervasives_Native.Some (e0, b11, bvs) ->
-            let bs =
-              FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder (b11 ::
-                bvs) in
-            let t = FStar_Tactics_Types.goal_type g in
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Subst.close_binders bs in
-              let uu___3 = FStar_Syntax_Subst.close bs t in (uu___2, uu___3) in
-            (match uu___1 with
-             | (bs', t') ->
-                 let bs'1 =
-                   let uu___2 = FStar_Syntax_Syntax.mk_binder b2 in
-                   let uu___3 = FStar_Compiler_List.tail bs' in uu___2 ::
-                     uu___3 in
-                 let uu___2 =
-                   FStar_TypeChecker_Core.open_binders_in_term e0 bs'1 t' in
-                 (match uu___2 with
-                  | (new_env, bs'', t'') ->
-                      let b21 =
-                        let uu___3 = FStar_Compiler_List.hd bs'' in
-                        uu___3.FStar_Syntax_Syntax.binder_bv in
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = should_check_goal_uvar g in
-                          FStar_Pervasives_Native.Some uu___5 in
-                        let uu___5 = goal_typedness_deps g in
-                        FStar_Tactics_Monad.new_uvar "subst_goal" new_env t''
-                          uu___4 uu___5 (rangeof g) in
-                      FStar_Tactics_Monad.op_let_Bang uu___3
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | (uvt, uv) ->
-                               let goal' =
-                                 FStar_Tactics_Types.mk_goal new_env uv
-                                   g.FStar_Tactics_Types.opts
-                                   g.FStar_Tactics_Types.is_guard
-                                   g.FStar_Tactics_Types.label in
-                               let sol =
-                                 let uu___5 =
-                                   FStar_Syntax_Util.abs bs'' uvt
-                                     FStar_Pervasives_Native.None in
-                                 let uu___6 =
-                                   FStar_Compiler_List.map
-                                     (fun uu___7 ->
-                                        match uu___7 with
-                                        | {
-                                            FStar_Syntax_Syntax.binder_bv =
-                                              bv;
-                                            FStar_Syntax_Syntax.binder_qual =
-                                              q;
-                                            FStar_Syntax_Syntax.binder_attrs
-                                              = uu___8;_}
-                                            ->
-                                            let uu___9 =
-                                              FStar_Syntax_Syntax.bv_to_name
-                                                bv in
-                                            FStar_Syntax_Syntax.as_arg uu___9)
-                                     bs in
-                                 FStar_Syntax_Util.mk_app uu___5 uu___6 in
-                               let uu___5 = set_solution g sol in
-                               FStar_Tactics_Monad.op_let_Bang uu___5
-                                 (fun uu___6 ->
-                                    FStar_Tactics_Monad.ret
-                                      (FStar_Pervasives_Native.Some
-                                         (b21, goal'))))))
-        | FStar_Pervasives_Native.None ->
-            FStar_Tactics_Monad.ret FStar_Pervasives_Native.None
-let (rewrite : FStar_Syntax_Syntax.binder -> unit FStar_Tactics_Monad.tac) =
-  fun h ->
-    let uu___ =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun goal ->
-           let bv = h.FStar_Syntax_Syntax.binder_bv in
-           let uu___1 =
-             FStar_Tactics_Monad.if_verbose
-               (fun uu___2 ->
-                  let uu___3 = FStar_Syntax_Print.bv_to_string bv in
-                  let uu___4 =
-                    FStar_Syntax_Print.term_to_string
-                      bv.FStar_Syntax_Syntax.sort in
-                  FStar_Compiler_Util.print2 "+++Rewrite %s : %s\n" uu___3
-                    uu___4) in
-           FStar_Tactics_Monad.op_let_Bang uu___1
-             (fun uu___2 ->
-                let uu___3 =
-                  let uu___4 = FStar_Tactics_Types.goal_env goal in
-                  split_env bv uu___4 in
-                match uu___3 with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Tactics_Monad.fail
-                      "binder not found in environment"
-                | FStar_Pervasives_Native.Some (e0, bv1, bvs) ->
-                    let uu___4 =
-                      let uu___5 = whnf e0 bv1.FStar_Syntax_Syntax.sort in
-                      destruct_eq uu___5 in
-                    (match uu___4 with
-                     | FStar_Pervasives_Native.Some (x, e) ->
-                         let uu___5 =
-                           let uu___6 = FStar_Syntax_Subst.compress x in
-                           uu___6.FStar_Syntax_Syntax.n in
-                         (match uu___5 with
-                          | FStar_Syntax_Syntax.Tm_name x1 ->
-                              let s = [FStar_Syntax_Syntax.NT (x1, e)] in
-                              let t = FStar_Tactics_Types.goal_type goal in
-                              let bs =
-                                FStar_Compiler_List.map
-                                  FStar_Syntax_Syntax.mk_binder bvs in
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Subst.close_binders bs in
-                                let uu___8 = FStar_Syntax_Subst.close bs t in
-                                (uu___7, uu___8) in
-                              (match uu___6 with
-                               | (bs', t') ->
-                                   let uu___7 =
-                                     let uu___8 =
-                                       FStar_Syntax_Subst.subst_binders s bs' in
-                                     let uu___9 =
-                                       FStar_Syntax_Subst.subst s t' in
-                                     (uu___8, uu___9) in
-                                   (match uu___7 with
-                                    | (bs'1, t'1) ->
-                                        let e01 =
-                                          FStar_TypeChecker_Env.push_bvs e0
-                                            [bv1] in
-                                        let uu___8 =
-                                          FStar_TypeChecker_Core.open_binders_in_term
-                                            e01 bs'1 t'1 in
-                                        (match uu___8 with
-                                         | (new_env, bs'', t'') ->
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   should_check_goal_uvar
-                                                     goal in
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___11 in
-                                               let uu___11 =
-                                                 goal_typedness_deps goal in
-                                               FStar_Tactics_Monad.new_uvar
-                                                 "rewrite" new_env t''
-                                                 uu___10 uu___11
-                                                 (rangeof goal) in
-                                             FStar_Tactics_Monad.op_let_Bang
-                                               uu___9
-                                               (fun uu___10 ->
-                                                  match uu___10 with
-                                                  | (uvt, uv) ->
-                                                      let goal' =
-                                                        FStar_Tactics_Types.mk_goal
-                                                          new_env uv
-                                                          goal.FStar_Tactics_Types.opts
-                                                          goal.FStar_Tactics_Types.is_guard
-                                                          goal.FStar_Tactics_Types.label in
-                                                      let sol =
-                                                        let uu___11 =
-                                                          FStar_Syntax_Util.abs
-                                                            bs'' uvt
-                                                            FStar_Pervasives_Native.None in
-                                                        let uu___12 =
-                                                          FStar_Compiler_List.map
-                                                            (fun uu___13 ->
-                                                               match uu___13
-                                                               with
-                                                               | {
-                                                                   FStar_Syntax_Syntax.binder_bv
-                                                                    = bv2;
-                                                                   FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___14;
-                                                                   FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___15;_}
-                                                                   ->
-                                                                   let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    bv2 in
-                                                                   FStar_Syntax_Syntax.as_arg
-                                                                    uu___16)
-                                                            bs in
-                                                        FStar_Syntax_Util.mk_app
-                                                          uu___11 uu___12 in
-                                                      let uu___11 =
-                                                        set_solution goal sol in
-                                                      FStar_Tactics_Monad.op_let_Bang
-                                                        uu___11
-                                                        (fun uu___12 ->
-                                                           FStar_Tactics_Monad.replace_cur
-                                                             goal')))))
-                          | uu___6 ->
-                              FStar_Tactics_Monad.fail
-                                "Not an equality hypothesis with a variable on the LHS")
-                     | uu___5 ->
-                         FStar_Tactics_Monad.fail
-                           "Not an equality hypothesis"))) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "rewrite") uu___
-let (rename_to :
-  FStar_Syntax_Syntax.binder ->
-    Prims.string -> FStar_Syntax_Syntax.binder FStar_Tactics_Monad.tac)
-  =
-  fun b ->
-    fun s ->
-      let uu___ =
-        FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-          (fun goal ->
-             let bv = b.FStar_Syntax_Syntax.binder_bv in
-             let bv' =
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Ident.range_of_id bv.FStar_Syntax_Syntax.ppname in
-                     (s, uu___4) in
-                   FStar_Ident.mk_ident uu___3 in
-                 {
-                   FStar_Syntax_Syntax.ppname = uu___2;
-                   FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-                   FStar_Syntax_Syntax.sort = (bv.FStar_Syntax_Syntax.sort)
-                 } in
-               FStar_Syntax_Syntax.freshen_bv uu___1 in
-             let uu___1 = subst_goal bv bv' goal in
-             FStar_Tactics_Monad.op_let_Bang uu___1
-               (fun uu___2 ->
-                  match uu___2 with
-                  | FStar_Pervasives_Native.None ->
-                      FStar_Tactics_Monad.fail
-                        "binder not found in environment"
-                  | FStar_Pervasives_Native.Some (bv'1, goal1) ->
-                      let uu___3 = FStar_Tactics_Monad.replace_cur goal1 in
-                      FStar_Tactics_Monad.op_let_Bang uu___3
-                        (fun uu___4 ->
-                           FStar_Tactics_Monad.ret
-                             {
-                               FStar_Syntax_Syntax.binder_bv = bv'1;
-                               FStar_Syntax_Syntax.binder_qual =
-                                 (b.FStar_Syntax_Syntax.binder_qual);
-                               FStar_Syntax_Syntax.binder_attrs =
-                                 (b.FStar_Syntax_Syntax.binder_attrs)
-                             }))) in
-      FStar_Compiler_Effect.op_Less_Bar
-        (FStar_Tactics_Monad.wrap_err "rename_to") uu___
-let (binder_retype :
-  FStar_Syntax_Syntax.binder -> unit FStar_Tactics_Monad.tac) =
-  fun b ->
-    let uu___ =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun goal ->
-           let bv = b.FStar_Syntax_Syntax.binder_bv in
-           let uu___1 =
-             let uu___2 = FStar_Tactics_Types.goal_env goal in
-             split_env bv uu___2 in
-           match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               FStar_Tactics_Monad.fail
-                 "binder is not present in environment"
-           | FStar_Pervasives_Native.Some (e0, bv1, bvs) ->
-               let uu___2 = FStar_Syntax_Util.type_u () in
-               (match uu___2 with
-                | (ty, u) ->
-                    let goal_sc = should_check_goal_uvar goal in
-                    let uu___3 =
-                      let uu___4 = goal_typedness_deps goal in
-                      FStar_Tactics_Monad.new_uvar "binder_retype" e0 ty
-                        (FStar_Pervasives_Native.Some goal_sc) uu___4
-                        (rangeof goal) in
-                    FStar_Tactics_Monad.op_let_Bang uu___3
-                      (fun uu___4 ->
-                         match uu___4 with
-                         | (t', u_t') ->
-                             let bv'' =
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (bv1.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (bv1.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = t'
-                               } in
-                             let s =
-                               let uu___5 =
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Syntax_Syntax.bv_to_name bv'' in
-                                   (bv1, uu___7) in
-                                 FStar_Syntax_Syntax.NT uu___6 in
-                               [uu___5] in
-                             let bvs1 =
-                               FStar_Compiler_List.map
-                                 (fun b1 ->
-                                    let uu___5 =
-                                      FStar_Syntax_Subst.subst s
-                                        b1.FStar_Syntax_Syntax.sort in
-                                    {
-                                      FStar_Syntax_Syntax.ppname =
-                                        (b1.FStar_Syntax_Syntax.ppname);
-                                      FStar_Syntax_Syntax.index =
-                                        (b1.FStar_Syntax_Syntax.index);
-                                      FStar_Syntax_Syntax.sort = uu___5
-                                    }) bvs in
-                             let env' =
-                               FStar_TypeChecker_Env.push_bvs e0 (bv'' ::
-                                 bvs1) in
-                             FStar_Tactics_Monad.op_let_Bang
-                               FStar_Tactics_Monad.dismiss
-                               (fun uu___5 ->
-                                  let new_goal =
-                                    let uu___6 =
-                                      FStar_Tactics_Types.goal_with_env goal
-                                        env' in
-                                    let uu___7 =
-                                      let uu___8 =
-                                        FStar_Tactics_Types.goal_type goal in
-                                      FStar_Syntax_Subst.subst s uu___8 in
-                                    goal_with_type uu___6 uu___7 in
-                                  let uu___6 =
-                                    FStar_Tactics_Monad.add_goals [new_goal] in
-                                  FStar_Tactics_Monad.op_let_Bang uu___6
-                                    (fun uu___7 ->
-                                       let uu___8 =
-                                         FStar_Syntax_Util.mk_eq2
-                                           (FStar_Syntax_Syntax.U_succ u) ty
-                                           bv1.FStar_Syntax_Syntax.sort t' in
-                                       FStar_Tactics_Monad.add_irrelevant_goal
-                                         goal "binder_retype equation" e0
-                                         uu___8
-                                         (FStar_Pervasives_Native.Some
-                                            goal_sc)))))) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "binder_retype") uu___
-let (norm_binder_type :
-  FStar_Syntax_Embeddings.norm_step Prims.list ->
-    FStar_Syntax_Syntax.binder -> unit FStar_Tactics_Monad.tac)
-  =
-  fun s ->
-    fun b ->
-      let uu___ =
-        FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-          (fun goal ->
-             let bv = b.FStar_Syntax_Syntax.binder_bv in
-             let uu___1 =
-               let uu___2 = FStar_Tactics_Types.goal_env goal in
-               split_env bv uu___2 in
-             match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Tactics_Monad.fail
-                   "binder is not present in environment"
-             | FStar_Pervasives_Native.Some (e0, bv1, bvs) ->
-                 let steps =
-                   let uu___2 = FStar_TypeChecker_Cfg.translate_norm_steps s in
-                   FStar_Compiler_List.op_At
-                     [FStar_TypeChecker_Env.Reify;
-                     FStar_TypeChecker_Env.UnfoldTac] uu___2 in
-                 let sort' = normalize steps e0 bv1.FStar_Syntax_Syntax.sort in
-                 let bv' =
-                   {
-                     FStar_Syntax_Syntax.ppname =
-                       (bv1.FStar_Syntax_Syntax.ppname);
-                     FStar_Syntax_Syntax.index =
-                       (bv1.FStar_Syntax_Syntax.index);
-                     FStar_Syntax_Syntax.sort = sort'
-                   } in
-                 let env' = FStar_TypeChecker_Env.push_bvs e0 (bv' :: bvs) in
-                 let uu___2 = FStar_Tactics_Types.goal_with_env goal env' in
-                 FStar_Tactics_Monad.replace_cur uu___2) in
-      FStar_Compiler_Effect.op_Less_Bar
-        (FStar_Tactics_Monad.wrap_err "norm_binder_type") uu___
-let (revert : unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun goal ->
-         let uu___1 =
-           let uu___2 = FStar_Tactics_Types.goal_env goal in
-           FStar_TypeChecker_Env.pop_bv uu___2 in
-         match uu___1 with
-         | FStar_Pervasives_Native.None ->
-             FStar_Tactics_Monad.fail "Cannot revert; empty context"
-         | FStar_Pervasives_Native.Some (x, env') ->
-             let typ' =
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Syntax.mk_binder x in [uu___3] in
-               let uu___3 =
-                 let uu___4 = FStar_Tactics_Types.goal_type goal in
-                 FStar_Syntax_Syntax.mk_Total uu___4 in
-               FStar_Syntax_Util.arrow uu___2 uu___3 in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = should_check_goal_uvar goal in
-                 FStar_Pervasives_Native.Some uu___4 in
-               let uu___4 = goal_typedness_deps goal in
-               FStar_Tactics_Monad.new_uvar "revert" env' typ' uu___3 uu___4
-                 (rangeof goal) in
-             FStar_Tactics_Monad.op_let_Bang uu___2
-               (fun uu___3 ->
-                  match uu___3 with
-                  | (r, u_r) ->
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 = FStar_Syntax_Syntax.bv_to_name x in
-                              FStar_Syntax_Syntax.as_arg uu___8 in
-                            [uu___7] in
-                          let uu___7 =
-                            let uu___8 = FStar_Tactics_Types.goal_type goal in
-                            uu___8.FStar_Syntax_Syntax.pos in
-                          FStar_Syntax_Syntax.mk_Tm_app r uu___6 uu___7 in
-                        set_solution goal uu___5 in
-                      FStar_Tactics_Monad.op_let_Bang uu___4
-                        (fun uu___5 ->
-                           let g =
-                             FStar_Tactics_Types.mk_goal env' u_r
-                               goal.FStar_Tactics_Types.opts
-                               goal.FStar_Tactics_Types.is_guard
-                               goal.FStar_Tactics_Types.label in
-                           FStar_Tactics_Monad.replace_cur g)))
-let (free_in :
-  FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun bv ->
-    fun t ->
-      let uu___ = FStar_Syntax_Free.names t in
-      FStar_Compiler_Util.set_mem bv uu___
-let (clear : FStar_Syntax_Syntax.binder -> unit FStar_Tactics_Monad.tac) =
-  fun b ->
-    let bv = b.FStar_Syntax_Syntax.binder_bv in
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun goal ->
-         let uu___ =
-           FStar_Tactics_Monad.if_verbose
-             (fun uu___1 ->
-                let uu___2 = FStar_Syntax_Print.binder_to_string b in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = FStar_Tactics_Types.goal_env goal in
-                      FStar_TypeChecker_Env.all_binders uu___6 in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___5
-                      FStar_Compiler_List.length in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    FStar_Compiler_Util.string_of_int in
-                FStar_Compiler_Util.print2
-                  "Clear of (%s), env has %s binders\n" uu___2 uu___3) in
-         FStar_Tactics_Monad.op_let_Bang uu___
-           (fun uu___1 ->
-              let uu___2 =
-                let uu___3 = FStar_Tactics_Types.goal_env goal in
-                split_env bv uu___3 in
-              match uu___2 with
-              | FStar_Pervasives_Native.None ->
-                  FStar_Tactics_Monad.fail
-                    "Cannot clear; binder not in environment"
-              | FStar_Pervasives_Native.Some (e', bv1, bvs) ->
-                  let rec check bvs1 =
-                    match bvs1 with
-                    | [] -> FStar_Tactics_Monad.ret ()
-                    | bv'::bvs2 ->
-                        let uu___3 = free_in bv1 bv'.FStar_Syntax_Syntax.sort in
-                        if uu___3
-                        then
-                          let uu___4 =
-                            let uu___5 = FStar_Syntax_Print.bv_to_string bv' in
-                            FStar_Compiler_Util.format1
-                              "Cannot clear; binder present in the type of %s"
-                              uu___5 in
-                          FStar_Tactics_Monad.fail uu___4
-                        else check bvs2 in
-                  let uu___3 =
-                    let uu___4 = FStar_Tactics_Types.goal_type goal in
-                    free_in bv1 uu___4 in
-                  if uu___3
-                  then
-                    FStar_Tactics_Monad.fail
-                      "Cannot clear; binder present in goal"
-                  else
-                    (let uu___5 = check bvs in
-                     FStar_Tactics_Monad.op_let_Bang uu___5
-                       (fun uu___6 ->
-                          let env' = FStar_TypeChecker_Env.push_bvs e' bvs in
-                          let uu___7 =
-                            let uu___8 = FStar_Tactics_Types.goal_type goal in
-                            let uu___9 =
-                              let uu___10 = should_check_goal_uvar goal in
-                              FStar_Pervasives_Native.Some uu___10 in
-                            let uu___10 = goal_typedness_deps goal in
-                            FStar_Tactics_Monad.new_uvar "clear.witness" env'
-                              uu___8 uu___9 uu___10 (rangeof goal) in
-                          FStar_Tactics_Monad.op_let_Bang uu___7
-                            (fun uu___8 ->
-                               match uu___8 with
-                               | (ut, uvar_ut) ->
-                                   let uu___9 = set_solution goal ut in
-                                   FStar_Tactics_Monad.op_let_Bang uu___9
-                                     (fun uu___10 ->
-                                        let uu___11 =
-                                          FStar_Tactics_Types.mk_goal env'
-                                            uvar_ut
-                                            goal.FStar_Tactics_Types.opts
-                                            goal.FStar_Tactics_Types.is_guard
-                                            goal.FStar_Tactics_Types.label in
-                                        FStar_Tactics_Monad.replace_cur
-                                          uu___11))))))
-let (clear_top : unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun goal ->
-         let uu___1 =
-           let uu___2 = FStar_Tactics_Types.goal_env goal in
-           FStar_TypeChecker_Env.pop_bv uu___2 in
-         match uu___1 with
-         | FStar_Pervasives_Native.None ->
-             FStar_Tactics_Monad.fail "Cannot clear; empty context"
-         | FStar_Pervasives_Native.Some (x, uu___2) ->
-             let uu___3 = FStar_Syntax_Syntax.mk_binder x in clear uu___3)
-let (prune : Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun s ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun g ->
-         let ctx = FStar_Tactics_Types.goal_env g in
-         let ctx' =
-           let uu___ = FStar_Ident.path_of_text s in
-           FStar_TypeChecker_Env.rem_proof_ns ctx uu___ in
-         let g' = FStar_Tactics_Types.goal_with_env g ctx' in
-         FStar_Tactics_Monad.replace_cur g')
-let (addns : Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun s ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun g ->
-         let ctx = FStar_Tactics_Types.goal_env g in
-         let ctx' =
-           let uu___ = FStar_Ident.path_of_text s in
-           FStar_TypeChecker_Env.add_proof_ns ctx uu___ in
-         let g' = FStar_Tactics_Types.goal_with_env g ctx' in
-         FStar_Tactics_Monad.replace_cur g')
-let (guard_formula :
-  FStar_TypeChecker_Common.guard_t -> FStar_Syntax_Syntax.term) =
-  fun g ->
-    match g.FStar_TypeChecker_Common.guard_f with
-    | FStar_TypeChecker_Common.Trivial -> FStar_Syntax_Util.t_true
-    | FStar_TypeChecker_Common.NonTrivial f -> f
-let (_t_trefl :
-  Prims.bool ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun allow_guards ->
-    fun l ->
-      fun r ->
-        let should_register_trefl g =
-          let should_register = true in
-          let skip_register = false in
-          let uu___ =
-            let uu___1 = FStar_Options.compat_pre_core_should_register () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then skip_register
-          else
-            (let is_uvar_untyped_or_already_checked u =
-               let dec =
-                 FStar_Syntax_Unionfind.find_decoration
-                   u.FStar_Syntax_Syntax.ctx_uvar_head in
-               match dec.FStar_Syntax_Syntax.uvar_decoration_should_check
-               with
-               | FStar_Syntax_Syntax.Allow_untyped uu___2 -> true
-               | FStar_Syntax_Syntax.Already_checked -> true
-               | uu___2 -> false in
-             let is_uvar t =
-               let head = FStar_Syntax_Util.leftmost_head t in
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Subst.compress head in
-                 uu___3.FStar_Syntax_Syntax.n in
-               match uu___2 with
-               | FStar_Syntax_Syntax.Tm_uvar (u, uu___3) ->
-                   FStar_Pervasives.Inl (u, head, t)
-               | uu___3 -> FStar_Pervasives.Inr t in
-             let is_allow_untyped_uvar t =
-               let uu___2 = is_uvar t in
-               match uu___2 with
-               | FStar_Pervasives.Inr uu___3 -> false
-               | FStar_Pervasives.Inl (u, uu___3, uu___4) ->
-                   is_uvar_untyped_or_already_checked u in
-             let t =
-               FStar_Syntax_Util.ctx_uvar_typ
-                 g.FStar_Tactics_Types.goal_ctx_uvar in
-             let uvars =
-               let uu___2 = FStar_Syntax_Free.uvars t in
-               FStar_Compiler_Util.set_elements uu___2 in
-             let uu___2 =
-               FStar_Compiler_Util.for_all is_uvar_untyped_or_already_checked
-                 uvars in
-             if uu___2
-             then skip_register
-             else
-               (let uu___4 =
-                  let t1 =
-                    let uu___5 = FStar_Syntax_Util.un_squash t in
-                    match uu___5 with
-                    | FStar_Pervasives_Native.None -> t
-                    | FStar_Pervasives_Native.Some t2 -> t2 in
-                  FStar_Syntax_Util.leftmost_head_and_args t1 in
-                match uu___4 with
-                | (head, args) ->
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 = FStar_Syntax_Util.un_uinst head in
-                          FStar_Syntax_Subst.compress uu___8 in
-                        uu___7.FStar_Syntax_Syntax.n in
-                      (uu___6, args) in
-                    (match uu___5 with
-                     | (FStar_Syntax_Syntax.Tm_fvar fv,
-                        (ty, uu___6)::(t1, uu___7)::(t2, uu___8)::[]) when
-                         FStar_Syntax_Syntax.fv_eq_lid fv
-                           FStar_Parser_Const.eq2_lid
-                         ->
-                         let uu___9 =
-                           (is_allow_untyped_uvar t1) ||
-                             (is_allow_untyped_uvar t2) in
-                         if uu___9
-                         then skip_register
-                         else
-                           (let uu___11 =
-                              FStar_Tactics_Monad.is_goal_safe_as_well_typed
-                                g in
-                            if uu___11
-                            then
-                              let check_uvar_subtype u t3 =
-                                let env1 =
-                                  let uu___12 =
-                                    FStar_Tactics_Types.goal_env g in
-                                  {
-                                    FStar_TypeChecker_Env.solver =
-                                      (uu___12.FStar_TypeChecker_Env.solver);
-                                    FStar_TypeChecker_Env.range =
-                                      (uu___12.FStar_TypeChecker_Env.range);
-                                    FStar_TypeChecker_Env.curmodule =
-                                      (uu___12.FStar_TypeChecker_Env.curmodule);
-                                    FStar_TypeChecker_Env.gamma =
-                                      ((g.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_gamma);
-                                    FStar_TypeChecker_Env.gamma_sig =
-                                      (uu___12.FStar_TypeChecker_Env.gamma_sig);
-                                    FStar_TypeChecker_Env.gamma_cache =
-                                      (uu___12.FStar_TypeChecker_Env.gamma_cache);
-                                    FStar_TypeChecker_Env.modules =
-                                      (uu___12.FStar_TypeChecker_Env.modules);
-                                    FStar_TypeChecker_Env.expected_typ =
-                                      (uu___12.FStar_TypeChecker_Env.expected_typ);
-                                    FStar_TypeChecker_Env.sigtab =
-                                      (uu___12.FStar_TypeChecker_Env.sigtab);
-                                    FStar_TypeChecker_Env.attrtab =
-                                      (uu___12.FStar_TypeChecker_Env.attrtab);
-                                    FStar_TypeChecker_Env.instantiate_imp =
-                                      (uu___12.FStar_TypeChecker_Env.instantiate_imp);
-                                    FStar_TypeChecker_Env.effects =
-                                      (uu___12.FStar_TypeChecker_Env.effects);
-                                    FStar_TypeChecker_Env.generalize =
-                                      (uu___12.FStar_TypeChecker_Env.generalize);
-                                    FStar_TypeChecker_Env.letrecs =
-                                      (uu___12.FStar_TypeChecker_Env.letrecs);
-                                    FStar_TypeChecker_Env.top_level =
-                                      (uu___12.FStar_TypeChecker_Env.top_level);
-                                    FStar_TypeChecker_Env.check_uvars =
-                                      (uu___12.FStar_TypeChecker_Env.check_uvars);
-                                    FStar_TypeChecker_Env.use_eq_strict =
-                                      (uu___12.FStar_TypeChecker_Env.use_eq_strict);
-                                    FStar_TypeChecker_Env.is_iface =
-                                      (uu___12.FStar_TypeChecker_Env.is_iface);
-                                    FStar_TypeChecker_Env.admit =
-                                      (uu___12.FStar_TypeChecker_Env.admit);
-                                    FStar_TypeChecker_Env.lax =
-                                      (uu___12.FStar_TypeChecker_Env.lax);
-                                    FStar_TypeChecker_Env.lax_universes =
-                                      (uu___12.FStar_TypeChecker_Env.lax_universes);
-                                    FStar_TypeChecker_Env.phase1 =
-                                      (uu___12.FStar_TypeChecker_Env.phase1);
-                                    FStar_TypeChecker_Env.failhard =
-                                      (uu___12.FStar_TypeChecker_Env.failhard);
-                                    FStar_TypeChecker_Env.nosynth =
-                                      (uu___12.FStar_TypeChecker_Env.nosynth);
-                                    FStar_TypeChecker_Env.uvar_subtyping =
-                                      (uu___12.FStar_TypeChecker_Env.uvar_subtyping);
-                                    FStar_TypeChecker_Env.tc_term =
-                                      (uu___12.FStar_TypeChecker_Env.tc_term);
-                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.universe_of =
-                                      (uu___12.FStar_TypeChecker_Env.universe_of);
-                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.teq_nosmt_force =
-                                      (uu___12.FStar_TypeChecker_Env.teq_nosmt_force);
-                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                    FStar_TypeChecker_Env.normalized_eff_names
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.normalized_eff_names);
-                                    FStar_TypeChecker_Env.fv_delta_depths =
-                                      (uu___12.FStar_TypeChecker_Env.fv_delta_depths);
-                                    FStar_TypeChecker_Env.proof_ns =
-                                      (uu___12.FStar_TypeChecker_Env.proof_ns);
-                                    FStar_TypeChecker_Env.synth_hook =
-                                      (uu___12.FStar_TypeChecker_Env.synth_hook);
-                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                    FStar_TypeChecker_Env.splice =
-                                      (uu___12.FStar_TypeChecker_Env.splice);
-                                    FStar_TypeChecker_Env.mpreprocess =
-                                      (uu___12.FStar_TypeChecker_Env.mpreprocess);
-                                    FStar_TypeChecker_Env.postprocess =
-                                      (uu___12.FStar_TypeChecker_Env.postprocess);
-                                    FStar_TypeChecker_Env.identifier_info =
-                                      (uu___12.FStar_TypeChecker_Env.identifier_info);
-                                    FStar_TypeChecker_Env.tc_hooks =
-                                      (uu___12.FStar_TypeChecker_Env.tc_hooks);
-                                    FStar_TypeChecker_Env.dsenv =
-                                      (uu___12.FStar_TypeChecker_Env.dsenv);
-                                    FStar_TypeChecker_Env.nbe =
-                                      (uu___12.FStar_TypeChecker_Env.nbe);
-                                    FStar_TypeChecker_Env.strict_args_tab =
-                                      (uu___12.FStar_TypeChecker_Env.strict_args_tab);
-                                    FStar_TypeChecker_Env.erasable_types_tab
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.erasable_types_tab);
-                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                    FStar_TypeChecker_Env.erase_erasable_args
-                                      =
-                                      (uu___12.FStar_TypeChecker_Env.erase_erasable_args);
-                                    FStar_TypeChecker_Env.core_check =
-                                      (uu___12.FStar_TypeChecker_Env.core_check)
-                                  } in
-                                let uu___12 =
-                                  FStar_TypeChecker_Core.compute_term_type_handle_guards
-                                    env1 t3 false
-                                    (fun uu___13 -> fun uu___14 -> true) in
-                                match uu___12 with
-                                | FStar_Pervasives.Inr uu___13 -> false
-                                | FStar_Pervasives.Inl t_ty ->
-                                    let uu___13 =
-                                      FStar_TypeChecker_Core.check_term_subtyping
-                                        env1 ty t_ty in
-                                    (match uu___13 with
-                                     | FStar_Pervasives.Inl
-                                         (FStar_Pervasives_Native.None) ->
-                                         (mark_uvar_as_already_checked u;
-                                          true)
-                                     | uu___14 -> false) in
-                              let uu___12 =
-                                let uu___13 = is_uvar t1 in
-                                let uu___14 = is_uvar t2 in
-                                (uu___13, uu___14) in
-                              match uu___12 with
-                              | (FStar_Pervasives.Inl (u, uu___13, tu),
-                                 FStar_Pervasives.Inr uu___14) ->
-                                  let uu___15 = check_uvar_subtype u tu in
-                                  (if uu___15
-                                   then skip_register
-                                   else should_register)
-                              | (FStar_Pervasives.Inr uu___13,
-                                 FStar_Pervasives.Inl (u, uu___14, tu)) ->
-                                  let uu___15 = check_uvar_subtype u tu in
-                                  (if uu___15
-                                   then skip_register
-                                   else should_register)
-                              | uu___13 -> should_register
-                            else should_register)
-                     | uu___6 -> should_register))) in
-        FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-          (fun g ->
-             let should_check = should_check_goal_uvar g in
-             (let uu___1 = should_register_trefl g in
-              if uu___1 then FStar_Tactics_Monad.register_goal g else ());
-             (let must_tot = true in
-              let attempt l1 r1 =
-                let uu___1 =
-                  let uu___2 = FStar_Tactics_Types.goal_env g in
-                  do_unify_maybe_guards allow_guards must_tot uu___2 l1 r1 in
-                FStar_Tactics_Monad.op_let_Bang uu___1
-                  (fun uu___2 ->
-                     match uu___2 with
-                     | FStar_Pervasives_Native.None ->
-                         FStar_Tactics_Monad.ret false
-                     | FStar_Pervasives_Native.Some guard ->
-                         let uu___3 = solve' g FStar_Syntax_Util.exp_unit in
-                         FStar_Tactics_Monad.op_let_Bang uu___3
-                           (fun uu___4 ->
-                              if allow_guards
-                              then
-                                let uu___5 =
-                                  let uu___6 = FStar_Tactics_Types.goal_env g in
-                                  let uu___7 = guard_formula guard in
-                                  FStar_Tactics_Monad.goal_of_guard "t_trefl"
-                                    uu___6 uu___7
-                                    (FStar_Pervasives_Native.Some
-                                       should_check) (rangeof g) in
-                                FStar_Tactics_Monad.op_let_Bang uu___5
-                                  (fun goal ->
-                                     let uu___6 =
-                                       FStar_Tactics_Monad.push_goals [goal] in
-                                     FStar_Tactics_Monad.op_let_Bang uu___6
-                                       (fun uu___7 ->
-                                          FStar_Tactics_Monad.ret true))
-                              else
-                                (let uu___6 =
-                                   FStar_TypeChecker_Env.is_trivial_guard_formula
-                                     guard in
-                                 if uu___6
-                                 then FStar_Tactics_Monad.ret true
-                                 else
-                                   failwith
-                                     "internal error: _t_refl: guard is not trivial"))) in
-              let uu___1 = attempt l r in
-              FStar_Tactics_Monad.op_let_Bang uu___1
-                (fun uu___2 ->
-                   if uu___2
-                   then FStar_Tactics_Monad.ret ()
-                   else
-                     (let norm1 =
-                        let uu___3 = FStar_Tactics_Types.goal_env g in
-                        FStar_TypeChecker_Normalize.normalize
-                          [FStar_TypeChecker_Env.UnfoldUntil
-                             FStar_Syntax_Syntax.delta_constant;
-                          FStar_TypeChecker_Env.Primops;
-                          FStar_TypeChecker_Env.UnfoldTac] uu___3 in
-                      let uu___3 =
-                        let uu___4 = norm1 l in
-                        let uu___5 = norm1 r in attempt uu___4 uu___5 in
-                      FStar_Tactics_Monad.op_let_Bang uu___3
-                        (fun uu___4 ->
-                           if uu___4
-                           then FStar_Tactics_Monad.ret ()
-                           else
-                             (let uu___5 =
-                                let uu___6 =
-                                  let uu___7 = FStar_Tactics_Types.goal_env g in
-                                  tts uu___7 in
-                                FStar_TypeChecker_Err.print_discrepancy
-                                  uu___6 l r in
-                              match uu___5 with
-                              | (ls, rs) ->
-                                  fail2 "cannot unify (%s) and (%s)" ls rs))))))
-let (t_trefl : Prims.bool -> unit FStar_Tactics_Monad.tac) =
-  fun allow_guards ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-            (fun g ->
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = FStar_Tactics_Types.goal_env g in
-                   let uu___6 = FStar_Tactics_Types.goal_type g in
-                   whnf uu___5 uu___6 in
-                 destruct_eq uu___4 in
-               match uu___3 with
-               | FStar_Pervasives_Native.Some (l, r) ->
-                   _t_trefl allow_guards l r
-               | FStar_Pervasives_Native.None ->
-                   let uu___4 =
-                     let uu___5 = FStar_Tactics_Types.goal_env g in
-                     let uu___6 = FStar_Tactics_Types.goal_type g in
-                     tts uu___5 uu___6 in
-                   fail1 "not an equality (%s)" uu___4) in
-        FStar_Tactics_Monad.catch uu___2 in
-      FStar_Tactics_Monad.op_let_Bang uu___1
-        (fun uu___2 ->
-           match uu___2 with
-           | FStar_Pervasives.Inr v -> FStar_Tactics_Monad.ret ()
-           | FStar_Pervasives.Inl exn -> FStar_Tactics_Monad.traise exn) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "t_trefl") uu___
-let (dup : unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun g ->
-         let goal_sc = should_check_goal_uvar g in
-         let env1 = FStar_Tactics_Types.goal_env g in
-         let uu___1 =
-           let uu___2 = FStar_Tactics_Types.goal_type g in
-           let uu___3 =
-             let uu___4 = should_check_goal_uvar g in
-             FStar_Pervasives_Native.Some uu___4 in
-           let uu___4 = goal_typedness_deps g in
-           FStar_Tactics_Monad.new_uvar "dup" env1 uu___2 uu___3 uu___4
-             (rangeof g) in
-         FStar_Tactics_Monad.op_let_Bang uu___1
-           (fun uu___2 ->
-              match uu___2 with
-              | (u, u_uvar) ->
-                  (mark_uvar_as_already_checked
-                     g.FStar_Tactics_Types.goal_ctx_uvar;
-                   (let g' =
-                      {
-                        FStar_Tactics_Types.goal_main_env =
-                          (g.FStar_Tactics_Types.goal_main_env);
-                        FStar_Tactics_Types.goal_ctx_uvar = u_uvar;
-                        FStar_Tactics_Types.opts =
-                          (g.FStar_Tactics_Types.opts);
-                        FStar_Tactics_Types.is_guard =
-                          (g.FStar_Tactics_Types.is_guard);
-                        FStar_Tactics_Types.label =
-                          (g.FStar_Tactics_Types.label)
-                      } in
-                    FStar_Tactics_Monad.op_let_Bang
-                      FStar_Tactics_Monad.dismiss
-                      (fun uu___4 ->
-                         let t_eq =
-                           let uu___5 =
-                             let uu___6 = FStar_Tactics_Types.goal_type g in
-                             env1.FStar_TypeChecker_Env.universe_of env1
-                               uu___6 in
-                           let uu___6 = FStar_Tactics_Types.goal_type g in
-                           let uu___7 = FStar_Tactics_Types.goal_witness g in
-                           FStar_Syntax_Util.mk_eq2 uu___5 uu___6 u uu___7 in
-                         let uu___5 =
-                           FStar_Tactics_Monad.add_irrelevant_goal g
-                             "dup equation" env1 t_eq
-                             (FStar_Pervasives_Native.Some goal_sc) in
-                         FStar_Tactics_Monad.op_let_Bang uu___5
-                           (fun uu___6 -> FStar_Tactics_Monad.add_goals [g']))))))
-let longest_prefix :
-  'a .
-    ('a -> 'a -> Prims.bool) ->
-      'a Prims.list ->
-        'a Prims.list -> ('a Prims.list * 'a Prims.list * 'a Prims.list)
-  =
-  fun f ->
-    fun l1 ->
-      fun l2 ->
-        let rec aux acc l11 l21 =
-          match (l11, l21) with
-          | (x::xs, y::ys) ->
-              let uu___ = f x y in
-              if uu___ then aux (x :: acc) xs ys else (acc, xs, ys)
-          | uu___ -> (acc, l11, l21) in
-        let uu___ = aux [] l1 l2 in
-        match uu___ with
-        | (pr, t1, t2) -> ((FStar_Compiler_List.rev pr), t1, t2)
-let (join_goals :
-  FStar_Tactics_Types.goal ->
-    FStar_Tactics_Types.goal ->
-      FStar_Tactics_Types.goal FStar_Tactics_Monad.tac)
-  =
-  fun g1 ->
-    fun g2 ->
-      let close_forall_no_univs bs f =
-        FStar_Compiler_List.fold_right
-          (fun b ->
-             fun f1 ->
-               FStar_Syntax_Util.mk_forall_no_univ
-                 b.FStar_Syntax_Syntax.binder_bv f1) bs f in
-      let uu___ = FStar_Tactics_Types.get_phi g1 in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          FStar_Tactics_Monad.fail "goal 1 is not irrelevant"
-      | FStar_Pervasives_Native.Some phi1 ->
-          let uu___1 = FStar_Tactics_Types.get_phi g2 in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None ->
-               FStar_Tactics_Monad.fail "goal 2 is not irrelevant"
-           | FStar_Pervasives_Native.Some phi2 ->
-               let gamma1 =
-                 (g1.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_gamma in
-               let gamma2 =
-                 (g2.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_gamma in
-               let uu___2 =
-                 longest_prefix FStar_Syntax_Syntax.eq_binding
-                   (FStar_Compiler_List.rev gamma1)
-                   (FStar_Compiler_List.rev gamma2) in
-               (match uu___2 with
-                | (gamma, r1, r2) ->
-                    let t1 =
-                      let uu___3 =
-                        FStar_TypeChecker_Env.binders_of_bindings
-                          (FStar_Compiler_List.rev r1) in
-                      close_forall_no_univs uu___3 phi1 in
-                    let t2 =
-                      let uu___3 =
-                        FStar_TypeChecker_Env.binders_of_bindings
-                          (FStar_Compiler_List.rev r2) in
-                      close_forall_no_univs uu___3 phi2 in
-                    let goal_sc =
-                      let uu___3 =
-                        let uu___4 = should_check_goal_uvar g1 in
-                        let uu___5 = should_check_goal_uvar g2 in
-                        (uu___4, uu___5) in
-                      match uu___3 with
-                      | (FStar_Syntax_Syntax.Allow_untyped reason1,
-                         FStar_Syntax_Syntax.Allow_untyped uu___4) ->
-                          FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Allow_untyped reason1)
-                      | uu___4 -> FStar_Pervasives_Native.None in
-                    let uu___3 = set_solution g1 FStar_Syntax_Util.exp_unit in
-                    FStar_Tactics_Monad.op_let_Bang uu___3
-                      (fun uu___4 ->
-                         let uu___5 =
-                           set_solution g2 FStar_Syntax_Util.exp_unit in
-                         FStar_Tactics_Monad.op_let_Bang uu___5
-                           (fun uu___6 ->
-                              let ng = FStar_Syntax_Util.mk_conj t1 t2 in
-                              let nenv =
-                                let uu___7 = FStar_Tactics_Types.goal_env g1 in
-                                {
-                                  FStar_TypeChecker_Env.solver =
-                                    (uu___7.FStar_TypeChecker_Env.solver);
-                                  FStar_TypeChecker_Env.range =
-                                    (uu___7.FStar_TypeChecker_Env.range);
-                                  FStar_TypeChecker_Env.curmodule =
-                                    (uu___7.FStar_TypeChecker_Env.curmodule);
-                                  FStar_TypeChecker_Env.gamma =
-                                    (FStar_Compiler_List.rev gamma);
-                                  FStar_TypeChecker_Env.gamma_sig =
-                                    (uu___7.FStar_TypeChecker_Env.gamma_sig);
-                                  FStar_TypeChecker_Env.gamma_cache =
-                                    (uu___7.FStar_TypeChecker_Env.gamma_cache);
-                                  FStar_TypeChecker_Env.modules =
-                                    (uu___7.FStar_TypeChecker_Env.modules);
-                                  FStar_TypeChecker_Env.expected_typ =
-                                    (uu___7.FStar_TypeChecker_Env.expected_typ);
-                                  FStar_TypeChecker_Env.sigtab =
-                                    (uu___7.FStar_TypeChecker_Env.sigtab);
-                                  FStar_TypeChecker_Env.attrtab =
-                                    (uu___7.FStar_TypeChecker_Env.attrtab);
-                                  FStar_TypeChecker_Env.instantiate_imp =
-                                    (uu___7.FStar_TypeChecker_Env.instantiate_imp);
-                                  FStar_TypeChecker_Env.effects =
-                                    (uu___7.FStar_TypeChecker_Env.effects);
-                                  FStar_TypeChecker_Env.generalize =
-                                    (uu___7.FStar_TypeChecker_Env.generalize);
-                                  FStar_TypeChecker_Env.letrecs =
-                                    (uu___7.FStar_TypeChecker_Env.letrecs);
-                                  FStar_TypeChecker_Env.top_level =
-                                    (uu___7.FStar_TypeChecker_Env.top_level);
-                                  FStar_TypeChecker_Env.check_uvars =
-                                    (uu___7.FStar_TypeChecker_Env.check_uvars);
-                                  FStar_TypeChecker_Env.use_eq_strict =
-                                    (uu___7.FStar_TypeChecker_Env.use_eq_strict);
-                                  FStar_TypeChecker_Env.is_iface =
-                                    (uu___7.FStar_TypeChecker_Env.is_iface);
-                                  FStar_TypeChecker_Env.admit =
-                                    (uu___7.FStar_TypeChecker_Env.admit);
-                                  FStar_TypeChecker_Env.lax =
-                                    (uu___7.FStar_TypeChecker_Env.lax);
-                                  FStar_TypeChecker_Env.lax_universes =
-                                    (uu___7.FStar_TypeChecker_Env.lax_universes);
-                                  FStar_TypeChecker_Env.phase1 =
-                                    (uu___7.FStar_TypeChecker_Env.phase1);
-                                  FStar_TypeChecker_Env.failhard =
-                                    (uu___7.FStar_TypeChecker_Env.failhard);
-                                  FStar_TypeChecker_Env.nosynth =
-                                    (uu___7.FStar_TypeChecker_Env.nosynth);
-                                  FStar_TypeChecker_Env.uvar_subtyping =
-                                    (uu___7.FStar_TypeChecker_Env.uvar_subtyping);
-                                  FStar_TypeChecker_Env.tc_term =
-                                    (uu___7.FStar_TypeChecker_Env.tc_term);
-                                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                    =
-                                    (uu___7.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.universe_of =
-                                    (uu___7.FStar_TypeChecker_Env.universe_of);
-                                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                    =
-                                    (uu___7.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.teq_nosmt_force =
-                                    (uu___7.FStar_TypeChecker_Env.teq_nosmt_force);
-                                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                                    (uu___7.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                                    (uu___7.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                  FStar_TypeChecker_Env.normalized_eff_names
-                                    =
-                                    (uu___7.FStar_TypeChecker_Env.normalized_eff_names);
-                                  FStar_TypeChecker_Env.fv_delta_depths =
-                                    (uu___7.FStar_TypeChecker_Env.fv_delta_depths);
-                                  FStar_TypeChecker_Env.proof_ns =
-                                    (uu___7.FStar_TypeChecker_Env.proof_ns);
-                                  FStar_TypeChecker_Env.synth_hook =
-                                    (uu___7.FStar_TypeChecker_Env.synth_hook);
-                                  FStar_TypeChecker_Env.try_solve_implicits_hook
-                                    =
-                                    (uu___7.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                  FStar_TypeChecker_Env.splice =
-                                    (uu___7.FStar_TypeChecker_Env.splice);
-                                  FStar_TypeChecker_Env.mpreprocess =
-                                    (uu___7.FStar_TypeChecker_Env.mpreprocess);
-                                  FStar_TypeChecker_Env.postprocess =
-                                    (uu___7.FStar_TypeChecker_Env.postprocess);
-                                  FStar_TypeChecker_Env.identifier_info =
-                                    (uu___7.FStar_TypeChecker_Env.identifier_info);
-                                  FStar_TypeChecker_Env.tc_hooks =
-                                    (uu___7.FStar_TypeChecker_Env.tc_hooks);
-                                  FStar_TypeChecker_Env.dsenv =
-                                    (uu___7.FStar_TypeChecker_Env.dsenv);
-                                  FStar_TypeChecker_Env.nbe =
-                                    (uu___7.FStar_TypeChecker_Env.nbe);
-                                  FStar_TypeChecker_Env.strict_args_tab =
-                                    (uu___7.FStar_TypeChecker_Env.strict_args_tab);
-                                  FStar_TypeChecker_Env.erasable_types_tab =
-                                    (uu___7.FStar_TypeChecker_Env.erasable_types_tab);
-                                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                                    (uu___7.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                  FStar_TypeChecker_Env.unif_allow_ref_guards
-                                    =
-                                    (uu___7.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                  FStar_TypeChecker_Env.erase_erasable_args =
-                                    (uu___7.FStar_TypeChecker_Env.erase_erasable_args);
-                                  FStar_TypeChecker_Env.core_check =
-                                    (uu___7.FStar_TypeChecker_Env.core_check)
-                                } in
-                              let uu___7 =
-                                FStar_Tactics_Monad.mk_irrelevant_goal
-                                  "joined" nenv ng goal_sc (rangeof g1)
-                                  g1.FStar_Tactics_Types.opts
-                                  g1.FStar_Tactics_Types.label in
-                              FStar_Tactics_Monad.op_let_Bang uu___7
-                                (fun goal ->
-                                   let uu___8 =
-                                     FStar_Tactics_Monad.if_verbose
-                                       (fun uu___9 ->
-                                          let uu___10 =
-                                            FStar_Tactics_Printing.goal_to_string_verbose
-                                              g1 in
-                                          let uu___11 =
-                                            FStar_Tactics_Printing.goal_to_string_verbose
-                                              g2 in
-                                          let uu___12 =
-                                            FStar_Tactics_Printing.goal_to_string_verbose
-                                              goal in
-                                          FStar_Compiler_Util.print3
-                                            "join_goals of\n(%s)\nand\n(%s)\n= (%s)\n"
-                                            uu___10 uu___11 uu___12) in
-                                   FStar_Tactics_Monad.op_let_Bang uu___8
-                                     (fun uu___9 ->
-                                        FStar_Tactics_Monad.ret goal))))))
-let (join : unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-      (fun ps ->
-         match ps.FStar_Tactics_Types.goals with
-         | g1::g2::gs ->
-             let uu___1 =
-               FStar_Tactics_Monad.set
-                 {
-                   FStar_Tactics_Types.main_context =
-                     (ps.FStar_Tactics_Types.main_context);
-                   FStar_Tactics_Types.all_implicits =
-                     (ps.FStar_Tactics_Types.all_implicits);
-                   FStar_Tactics_Types.goals = gs;
-                   FStar_Tactics_Types.smt_goals =
-                     (ps.FStar_Tactics_Types.smt_goals);
-                   FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-                   FStar_Tactics_Types.__dump =
-                     (ps.FStar_Tactics_Types.__dump);
-                   FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-                   FStar_Tactics_Types.entry_range =
-                     (ps.FStar_Tactics_Types.entry_range);
-                   FStar_Tactics_Types.guard_policy =
-                     (ps.FStar_Tactics_Types.guard_policy);
-                   FStar_Tactics_Types.freshness =
-                     (ps.FStar_Tactics_Types.freshness);
-                   FStar_Tactics_Types.tac_verb_dbg =
-                     (ps.FStar_Tactics_Types.tac_verb_dbg);
-                   FStar_Tactics_Types.local_state =
-                     (ps.FStar_Tactics_Types.local_state);
-                   FStar_Tactics_Types.urgency =
-                     (ps.FStar_Tactics_Types.urgency)
-                 } in
-             FStar_Tactics_Monad.op_let_Bang uu___1
-               (fun uu___2 ->
-                  let uu___3 = join_goals g1 g2 in
-                  FStar_Tactics_Monad.op_let_Bang uu___3
-                    (fun g12 -> FStar_Tactics_Monad.add_goals [g12]))
-         | uu___1 -> FStar_Tactics_Monad.fail "join: less than 2 goals")
-let (set_options : Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun s ->
-    let uu___ =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun g ->
-           FStar_Options.push ();
-           (let uu___3 =
-              FStar_Compiler_Util.smap_copy g.FStar_Tactics_Types.opts in
-            FStar_Options.set uu___3);
-           (let res = FStar_Options.set_options s in
-            let opts' = FStar_Options.peek () in
-            FStar_Options.pop ();
-            (match res with
-             | FStar_Getopt.Success ->
-                 let g' =
-                   {
-                     FStar_Tactics_Types.goal_main_env =
-                       (g.FStar_Tactics_Types.goal_main_env);
-                     FStar_Tactics_Types.goal_ctx_uvar =
-                       (g.FStar_Tactics_Types.goal_ctx_uvar);
-                     FStar_Tactics_Types.opts = opts';
-                     FStar_Tactics_Types.is_guard =
-                       (g.FStar_Tactics_Types.is_guard);
-                     FStar_Tactics_Types.label =
-                       (g.FStar_Tactics_Types.label)
-                   } in
-                 FStar_Tactics_Monad.replace_cur g'
-             | FStar_Getopt.Error err ->
-                 fail2 "Setting options `%s` failed: %s" s err
-             | FStar_Getopt.Help ->
-                 fail1 "Setting options `%s` failed (got `Help`?)" s))) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "set_options") uu___
-let (top_env : unit -> env FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-      (fun ps ->
-         FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-           ps.FStar_Tactics_Types.main_context)
-let (lax_on : unit -> Prims.bool FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-      (fun g ->
-         let uu___1 =
-           (FStar_Options.lax ()) ||
-             (let uu___2 = FStar_Tactics_Types.goal_env g in
-              uu___2.FStar_TypeChecker_Env.lax) in
-         FStar_Tactics_Monad.ret uu___1)
-let (unquote :
-  FStar_Reflection_Data.typ ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun ty ->
-    fun tm ->
-      let uu___ =
-        let uu___1 =
-          FStar_Tactics_Monad.if_verbose
-            (fun uu___2 ->
-               let uu___3 = FStar_Syntax_Print.term_to_string tm in
-               FStar_Compiler_Util.print1 "unquote: tm = %s\n" uu___3) in
-        FStar_Tactics_Monad.op_let_Bang uu___1
-          (fun uu___2 ->
-             FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-               (fun goal ->
-                  let env1 =
-                    let uu___3 = FStar_Tactics_Types.goal_env goal in
-                    FStar_TypeChecker_Env.set_expected_typ uu___3 ty in
-                  let uu___3 = __tc_ghost env1 tm in
-                  FStar_Tactics_Monad.op_let_Bang uu___3
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | (tm1, typ, guard) ->
-                           let uu___5 =
-                             FStar_Tactics_Monad.if_verbose
-                               (fun uu___6 ->
-                                  let uu___7 =
-                                    FStar_Syntax_Print.term_to_string tm1 in
-                                  FStar_Compiler_Util.print1
-                                    "unquote: tm' = %s\n" uu___7) in
-                           FStar_Tactics_Monad.op_let_Bang uu___5
-                             (fun uu___6 ->
-                                let uu___7 =
-                                  FStar_Tactics_Monad.if_verbose
-                                    (fun uu___8 ->
-                                       let uu___9 =
-                                         FStar_Syntax_Print.term_to_string
-                                           typ in
-                                       FStar_Compiler_Util.print1
-                                         "unquote: typ = %s\n" uu___9) in
-                                FStar_Tactics_Monad.op_let_Bang uu___7
-                                  (fun uu___8 ->
-                                     let uu___9 =
-                                       let uu___10 =
-                                         let uu___11 =
-                                           should_check_goal_uvar goal in
-                                         FStar_Pervasives_Native.Some uu___11 in
-                                       proc_guard "unquote" env1 guard
-                                         uu___10 (rangeof goal) in
-                                     FStar_Tactics_Monad.op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          FStar_Tactics_Monad.ret tm1)))))) in
-      FStar_Compiler_Effect.op_Less_Bar
-        (FStar_Tactics_Monad.wrap_err "unquote") uu___
-let (uvar_env :
-  env ->
-    FStar_Reflection_Data.typ FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun env1 ->
-    fun ty ->
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-        (fun ps ->
-           let uu___ =
-             match ty with
-             | FStar_Pervasives_Native.Some ty1 ->
-                 let env2 =
-                   let uu___1 =
-                     let uu___2 = FStar_Syntax_Util.type_u () in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___2
-                       FStar_Pervasives_Native.fst in
-                   FStar_TypeChecker_Env.set_expected_typ env1 uu___1 in
-                 let uu___1 = __tc_ghost env2 ty1 in
-                 FStar_Tactics_Monad.op_let_Bang uu___1
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (ty2, uu___3, g) ->
-                          FStar_Tactics_Monad.ret
-                            (ty2, g, (ty2.FStar_Syntax_Syntax.pos)))
-             | FStar_Pervasives_Native.None ->
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Util.type_u () in
-                     FStar_Compiler_Effect.op_Less_Bar
-                       FStar_Pervasives_Native.fst uu___3 in
-                   FStar_Tactics_Monad.new_uvar "uvar_env.2" env1 uu___2
-                     FStar_Pervasives_Native.None []
-                     ps.FStar_Tactics_Types.entry_range in
-                 FStar_Tactics_Monad.op_let_Bang uu___1
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (typ, uvar_typ) ->
-                          FStar_Tactics_Monad.ret
-                            (typ, FStar_TypeChecker_Env.trivial_guard,
-                              FStar_Compiler_Range.dummyRange)) in
-           FStar_Tactics_Monad.op_let_Bang uu___
-             (fun uu___1 ->
-                match uu___1 with
-                | (typ, g, r) ->
-                    let uu___2 =
-                      proc_guard "uvar_env_typ" env1 g
-                        FStar_Pervasives_Native.None r in
-                    FStar_Tactics_Monad.op_let_Bang uu___2
-                      (fun uu___3 ->
-                         let uu___4 =
-                           FStar_Tactics_Monad.new_uvar "uvar_env" env1 typ
-                             FStar_Pervasives_Native.None []
-                             ps.FStar_Tactics_Types.entry_range in
-                         FStar_Tactics_Monad.op_let_Bang uu___4
-                           (fun uu___5 ->
-                              match uu___5 with
-                              | (t, uvar_t) -> FStar_Tactics_Monad.ret t))))
-let (ghost_uvar_env :
-  env ->
-    FStar_Reflection_Data.typ ->
-      FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun env1 ->
-    fun ty ->
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-        (fun ps ->
-           let uu___ = __tc_ghost env1 ty in
-           FStar_Tactics_Monad.op_let_Bang uu___
-             (fun uu___1 ->
-                match uu___1 with
-                | (typ, uu___2, g) ->
-                    let uu___3 =
-                      proc_guard "ghost_uvar_env_typ" env1 g
-                        FStar_Pervasives_Native.None
-                        ty.FStar_Syntax_Syntax.pos in
-                    FStar_Tactics_Monad.op_let_Bang uu___3
-                      (fun uu___4 ->
-                         let uu___5 =
-                           FStar_Tactics_Monad.new_uvar "uvar_env" env1 typ
-                             (FStar_Pervasives_Native.Some
-                                (FStar_Syntax_Syntax.Allow_ghost
-                                   "User ghost uvar")) []
-                             ps.FStar_Tactics_Types.entry_range in
-                         FStar_Tactics_Monad.op_let_Bang uu___5
-                           (fun uu___6 ->
-                              match uu___6 with
-                              | (t, uvar_t) -> FStar_Tactics_Monad.ret t))))
-let (fresh_universe_uvar :
-  unit -> FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Syntax_Util.type_u () in
-      FStar_Compiler_Effect.op_Bar_Greater uu___2 FStar_Pervasives_Native.fst in
-    FStar_Compiler_Effect.op_Bar_Greater uu___1 FStar_Tactics_Monad.ret
-let (unshelve : FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac) =
-  fun t ->
-    let uu___ =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-        (fun ps ->
-           let env1 = ps.FStar_Tactics_Types.main_context in
-           let opts =
-             match ps.FStar_Tactics_Types.goals with
-             | g::uu___1 -> g.FStar_Tactics_Types.opts
-             | uu___1 -> FStar_Options.peek () in
-           let uu___1 = FStar_Syntax_Util.head_and_args t in
-           match uu___1 with
-           | ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar
-                  (ctx_uvar, uu___2);
-                FStar_Syntax_Syntax.pos = uu___3;
-                FStar_Syntax_Syntax.vars = uu___4;
-                FStar_Syntax_Syntax.hash_code = uu___5;_},
-              uu___6) ->
-               let env2 =
-                 {
-                   FStar_TypeChecker_Env.solver =
-                     (env1.FStar_TypeChecker_Env.solver);
-                   FStar_TypeChecker_Env.range =
-                     (env1.FStar_TypeChecker_Env.range);
-                   FStar_TypeChecker_Env.curmodule =
-                     (env1.FStar_TypeChecker_Env.curmodule);
-                   FStar_TypeChecker_Env.gamma =
-                     (ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_gamma);
-                   FStar_TypeChecker_Env.gamma_sig =
-                     (env1.FStar_TypeChecker_Env.gamma_sig);
-                   FStar_TypeChecker_Env.gamma_cache =
-                     (env1.FStar_TypeChecker_Env.gamma_cache);
-                   FStar_TypeChecker_Env.modules =
-                     (env1.FStar_TypeChecker_Env.modules);
-                   FStar_TypeChecker_Env.expected_typ =
-                     (env1.FStar_TypeChecker_Env.expected_typ);
-                   FStar_TypeChecker_Env.sigtab =
-                     (env1.FStar_TypeChecker_Env.sigtab);
-                   FStar_TypeChecker_Env.attrtab =
-                     (env1.FStar_TypeChecker_Env.attrtab);
-                   FStar_TypeChecker_Env.instantiate_imp =
-                     (env1.FStar_TypeChecker_Env.instantiate_imp);
-                   FStar_TypeChecker_Env.effects =
-                     (env1.FStar_TypeChecker_Env.effects);
-                   FStar_TypeChecker_Env.generalize =
-                     (env1.FStar_TypeChecker_Env.generalize);
-                   FStar_TypeChecker_Env.letrecs =
-                     (env1.FStar_TypeChecker_Env.letrecs);
-                   FStar_TypeChecker_Env.top_level =
-                     (env1.FStar_TypeChecker_Env.top_level);
-                   FStar_TypeChecker_Env.check_uvars =
-                     (env1.FStar_TypeChecker_Env.check_uvars);
-                   FStar_TypeChecker_Env.use_eq_strict =
-                     (env1.FStar_TypeChecker_Env.use_eq_strict);
-                   FStar_TypeChecker_Env.is_iface =
-                     (env1.FStar_TypeChecker_Env.is_iface);
-                   FStar_TypeChecker_Env.admit =
-                     (env1.FStar_TypeChecker_Env.admit);
-                   FStar_TypeChecker_Env.lax =
-                     (env1.FStar_TypeChecker_Env.lax);
-                   FStar_TypeChecker_Env.lax_universes =
-                     (env1.FStar_TypeChecker_Env.lax_universes);
-                   FStar_TypeChecker_Env.phase1 =
-                     (env1.FStar_TypeChecker_Env.phase1);
-                   FStar_TypeChecker_Env.failhard =
-                     (env1.FStar_TypeChecker_Env.failhard);
-                   FStar_TypeChecker_Env.nosynth =
-                     (env1.FStar_TypeChecker_Env.nosynth);
-                   FStar_TypeChecker_Env.uvar_subtyping =
-                     (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                   FStar_TypeChecker_Env.tc_term =
-                     (env1.FStar_TypeChecker_Env.tc_term);
-                   FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                     (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                   FStar_TypeChecker_Env.universe_of =
-                     (env1.FStar_TypeChecker_Env.universe_of);
-                   FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                     (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                   FStar_TypeChecker_Env.teq_nosmt_force =
-                     (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                   FStar_TypeChecker_Env.subtype_nosmt_force =
-                     (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                   FStar_TypeChecker_Env.qtbl_name_and_index =
-                     (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                   FStar_TypeChecker_Env.normalized_eff_names =
-                     (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                   FStar_TypeChecker_Env.fv_delta_depths =
-                     (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                   FStar_TypeChecker_Env.proof_ns =
-                     (env1.FStar_TypeChecker_Env.proof_ns);
-                   FStar_TypeChecker_Env.synth_hook =
-                     (env1.FStar_TypeChecker_Env.synth_hook);
-                   FStar_TypeChecker_Env.try_solve_implicits_hook =
-                     (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                   FStar_TypeChecker_Env.splice =
-                     (env1.FStar_TypeChecker_Env.splice);
-                   FStar_TypeChecker_Env.mpreprocess =
-                     (env1.FStar_TypeChecker_Env.mpreprocess);
-                   FStar_TypeChecker_Env.postprocess =
-                     (env1.FStar_TypeChecker_Env.postprocess);
-                   FStar_TypeChecker_Env.identifier_info =
-                     (env1.FStar_TypeChecker_Env.identifier_info);
-                   FStar_TypeChecker_Env.tc_hooks =
-                     (env1.FStar_TypeChecker_Env.tc_hooks);
-                   FStar_TypeChecker_Env.dsenv =
-                     (env1.FStar_TypeChecker_Env.dsenv);
-                   FStar_TypeChecker_Env.nbe =
-                     (env1.FStar_TypeChecker_Env.nbe);
-                   FStar_TypeChecker_Env.strict_args_tab =
-                     (env1.FStar_TypeChecker_Env.strict_args_tab);
-                   FStar_TypeChecker_Env.erasable_types_tab =
-                     (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                   FStar_TypeChecker_Env.enable_defer_to_tac =
-                     (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                   FStar_TypeChecker_Env.unif_allow_ref_guards =
-                     (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                   FStar_TypeChecker_Env.erase_erasable_args =
-                     (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                   FStar_TypeChecker_Env.core_check =
-                     (env1.FStar_TypeChecker_Env.core_check)
-                 } in
-               let g =
-                 FStar_Tactics_Types.mk_goal env2 ctx_uvar opts false "" in
-               let g1 = bnorm_goal g in FStar_Tactics_Monad.add_goals [g1]
-           | uu___2 -> FStar_Tactics_Monad.fail "not a uvar") in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "unshelve") uu___
-let (tac_and :
-  Prims.bool FStar_Tactics_Monad.tac ->
-    Prims.bool FStar_Tactics_Monad.tac -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun t1 ->
-    fun t2 ->
-      let comp =
-        FStar_Tactics_Monad.op_let_Bang t1
-          (fun uu___ ->
-             if uu___
-             then
-               FStar_Tactics_Monad.op_let_Bang t2
-                 (fun uu___1 ->
-                    if uu___1
-                    then FStar_Tactics_Monad.ret true
-                    else FStar_Tactics_Monad.fail "")
-             else FStar_Tactics_Monad.fail "") in
-      let uu___ = FStar_Tactics_Monad.trytac comp in
-      FStar_Tactics_Monad.op_let_Bang uu___
-        (fun uu___1 ->
-           match uu___1 with
-           | FStar_Pervasives_Native.Some (true) ->
-               FStar_Tactics_Monad.ret true
-           | FStar_Pervasives_Native.Some (false) -> failwith "impossible"
-           | FStar_Pervasives_Native.None -> FStar_Tactics_Monad.ret false)
-let (match_env :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-            (fun ps ->
-               let uu___1 = __tc e t1 in
-               FStar_Tactics_Monad.op_let_Bang uu___1
-                 (fun uu___2 ->
-                    match uu___2 with
-                    | (t11, ty1, g1) ->
-                        let uu___3 = __tc e t2 in
-                        FStar_Tactics_Monad.op_let_Bang uu___3
-                          (fun uu___4 ->
-                             match uu___4 with
-                             | (t21, ty2, g2) ->
-                                 let uu___5 =
-                                   proc_guard "match_env g1" e g1
-                                     FStar_Pervasives_Native.None
-                                     ps.FStar_Tactics_Types.entry_range in
-                                 FStar_Tactics_Monad.op_let_Bang uu___5
-                                   (fun uu___6 ->
-                                      let uu___7 =
-                                        proc_guard "match_env g2" e g2
-                                          FStar_Pervasives_Native.None
-                                          ps.FStar_Tactics_Types.entry_range in
-                                      FStar_Tactics_Monad.op_let_Bang uu___7
-                                        (fun uu___8 ->
-                                           let must_tot = true in
-                                           let uu___9 =
-                                             do_match must_tot e ty1 ty2 in
-                                           let uu___10 =
-                                             do_match must_tot e t11 t21 in
-                                           tac_and uu___9 uu___10))))) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "match_env") uu___
-let (unify_env :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-            (fun ps ->
-               let uu___1 = __tc e t1 in
-               FStar_Tactics_Monad.op_let_Bang uu___1
-                 (fun uu___2 ->
-                    match uu___2 with
-                    | (t11, ty1, g1) ->
-                        let uu___3 = __tc e t2 in
-                        FStar_Tactics_Monad.op_let_Bang uu___3
-                          (fun uu___4 ->
-                             match uu___4 with
-                             | (t21, ty2, g2) ->
-                                 let uu___5 =
-                                   proc_guard "unify_env g1" e g1
-                                     FStar_Pervasives_Native.None
-                                     ps.FStar_Tactics_Types.entry_range in
-                                 FStar_Tactics_Monad.op_let_Bang uu___5
-                                   (fun uu___6 ->
-                                      let uu___7 =
-                                        proc_guard "unify_env g2" e g2
-                                          FStar_Pervasives_Native.None
-                                          ps.FStar_Tactics_Types.entry_range in
-                                      FStar_Tactics_Monad.op_let_Bang uu___7
-                                        (fun uu___8 ->
-                                           let must_tot = true in
-                                           let uu___9 =
-                                             do_unify must_tot e ty1 ty2 in
-                                           let uu___10 =
-                                             do_unify must_tot e t11 t21 in
-                                           tac_and uu___9 uu___10))))) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "unify_env") uu___
-let (unify_guard_env :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-            (fun ps ->
-               let uu___1 = __tc e t1 in
-               FStar_Tactics_Monad.op_let_Bang uu___1
-                 (fun uu___2 ->
-                    match uu___2 with
-                    | (t11, ty1, g1) ->
-                        let uu___3 = __tc e t2 in
-                        FStar_Tactics_Monad.op_let_Bang uu___3
-                          (fun uu___4 ->
-                             match uu___4 with
-                             | (t21, ty2, g2) ->
-                                 let uu___5 =
-                                   proc_guard "unify_guard_env g1" e g1
-                                     FStar_Pervasives_Native.None
-                                     ps.FStar_Tactics_Types.entry_range in
-                                 FStar_Tactics_Monad.op_let_Bang uu___5
-                                   (fun uu___6 ->
-                                      let uu___7 =
-                                        proc_guard "unify_guard_env g2" e g2
-                                          FStar_Pervasives_Native.None
-                                          ps.FStar_Tactics_Types.entry_range in
-                                      FStar_Tactics_Monad.op_let_Bang uu___7
-                                        (fun uu___8 ->
-                                           let must_tot = true in
-                                           let uu___9 =
-                                             do_unify_maybe_guards true
-                                               must_tot e ty1 ty2 in
-                                           FStar_Tactics_Monad.op_let_Bang
-                                             uu___9
-                                             (fun uu___10 ->
-                                                match uu___10 with
-                                                | FStar_Pervasives_Native.None
-                                                    ->
-                                                    FStar_Tactics_Monad.ret
-                                                      false
-                                                | FStar_Pervasives_Native.Some
-                                                    g11 ->
-                                                    let uu___11 =
-                                                      do_unify_maybe_guards
-                                                        true must_tot e t11
-                                                        t21 in
-                                                    FStar_Tactics_Monad.op_let_Bang
-                                                      uu___11
-                                                      (fun uu___12 ->
-                                                         match uu___12 with
-                                                         | FStar_Pervasives_Native.None
-                                                             ->
-                                                             FStar_Tactics_Monad.ret
-                                                               false
-                                                         | FStar_Pervasives_Native.Some
-                                                             g21 ->
-                                                             let formula =
-                                                               let uu___13 =
-                                                                 guard_formula
-                                                                   g11 in
-                                                               let uu___14 =
-                                                                 guard_formula
-                                                                   g21 in
-                                                               FStar_Syntax_Util.mk_conj
-                                                                 uu___13
-                                                                 uu___14 in
-                                                             let uu___13 =
-                                                               FStar_Tactics_Monad.goal_of_guard
-                                                                 "unify_guard_env.g2"
-                                                                 e formula
-                                                                 FStar_Pervasives_Native.None
-                                                                 ps.FStar_Tactics_Types.entry_range in
-                                                             FStar_Tactics_Monad.op_let_Bang
-                                                               uu___13
-                                                               (fun goal ->
-                                                                  let uu___14
-                                                                    =
-                                                                    FStar_Tactics_Monad.push_goals
-                                                                    [goal] in
-                                                                  FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___14
-                                                                    (
-                                                                    fun
-                                                                    uu___15
-                                                                    ->
-                                                                    FStar_Tactics_Monad.ret
-                                                                    true))))))))) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "unify_guard_env") uu___
-let (launch_process :
-  Prims.string ->
-    Prims.string Prims.list ->
-      Prims.string -> Prims.string FStar_Tactics_Monad.tac)
-  =
-  fun prog ->
-    fun args ->
-      fun input ->
-        FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.idtac
-          (fun uu___ ->
-             let uu___1 = FStar_Options.unsafe_tactic_exec () in
-             if uu___1
-             then
-               let s =
-                 FStar_Compiler_Util.run_process "tactic_launch" prog args
-                   (FStar_Pervasives_Native.Some input) in
-               FStar_Tactics_Monad.ret s
-             else
-               FStar_Tactics_Monad.fail
-                 "launch_process: will not run anything unless --unsafe_tactic_exec is provided")
-let (fresh_bv_named :
-  Prims.string ->
-    FStar_Reflection_Data.typ ->
-      FStar_Syntax_Syntax.bv FStar_Tactics_Monad.tac)
-  =
-  fun nm ->
-    fun t ->
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.idtac
-        (fun uu___ ->
-           let uu___1 =
-             FStar_Syntax_Syntax.gen_bv nm FStar_Pervasives_Native.None t in
-           FStar_Tactics_Monad.ret uu___1)
-let (change : FStar_Reflection_Data.typ -> unit FStar_Tactics_Monad.tac) =
-  fun ty ->
-    let uu___ =
-      let uu___1 =
-        FStar_Tactics_Monad.if_verbose
-          (fun uu___2 ->
-             let uu___3 = FStar_Syntax_Print.term_to_string ty in
-             FStar_Compiler_Util.print1 "change: ty = %s\n" uu___3) in
-      FStar_Tactics_Monad.op_let_Bang uu___1
-        (fun uu___2 ->
-           FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-             (fun g ->
-                let uu___3 =
-                  let uu___4 = FStar_Tactics_Types.goal_env g in
-                  __tc uu___4 ty in
-                FStar_Tactics_Monad.op_let_Bang uu___3
-                  (fun uu___4 ->
-                     match uu___4 with
-                     | (ty1, uu___5, guard) ->
-                         let uu___6 =
-                           let uu___7 = FStar_Tactics_Types.goal_env g in
-                           let uu___8 =
-                             let uu___9 = should_check_goal_uvar g in
-                             FStar_Pervasives_Native.Some uu___9 in
-                           proc_guard "change" uu___7 guard uu___8
-                             (rangeof g) in
-                         FStar_Tactics_Monad.op_let_Bang uu___6
-                           (fun uu___7 ->
-                              let must_tot = true in
-                              let uu___8 =
-                                let uu___9 = FStar_Tactics_Types.goal_env g in
-                                let uu___10 = FStar_Tactics_Types.goal_type g in
-                                do_unify must_tot uu___9 uu___10 ty1 in
-                              FStar_Tactics_Monad.op_let_Bang uu___8
-                                (fun bb ->
-                                   if bb
-                                   then
-                                     let uu___9 = goal_with_type g ty1 in
-                                     FStar_Tactics_Monad.replace_cur uu___9
-                                   else
-                                     (let steps =
-                                        [FStar_TypeChecker_Env.AllowUnboundUniverses;
-                                        FStar_TypeChecker_Env.UnfoldUntil
-                                          FStar_Syntax_Syntax.delta_constant;
-                                        FStar_TypeChecker_Env.Primops] in
-                                      let ng =
-                                        let uu___10 =
-                                          FStar_Tactics_Types.goal_env g in
-                                        let uu___11 =
-                                          FStar_Tactics_Types.goal_type g in
-                                        normalize steps uu___10 uu___11 in
-                                      let nty =
-                                        let uu___10 =
-                                          FStar_Tactics_Types.goal_env g in
-                                        normalize steps uu___10 ty1 in
-                                      let uu___10 =
-                                        let uu___11 =
-                                          FStar_Tactics_Types.goal_env g in
-                                        do_unify must_tot uu___11 ng nty in
-                                      FStar_Tactics_Monad.op_let_Bang uu___10
-                                        (fun b ->
-                                           if b
-                                           then
-                                             let uu___11 =
-                                               goal_with_type g ty1 in
-                                             FStar_Tactics_Monad.replace_cur
-                                               uu___11
-                                           else
-                                             FStar_Tactics_Monad.fail
-                                               "not convertible"))))))) in
-    FStar_Compiler_Effect.op_Less_Bar (FStar_Tactics_Monad.wrap_err "change")
-      uu___
-let (failwhen : Prims.bool -> Prims.string -> unit FStar_Tactics_Monad.tac) =
-  fun b ->
-    fun msg ->
-      if b then FStar_Tactics_Monad.fail msg else FStar_Tactics_Monad.ret ()
-let (t_destruct :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.fv * FStar_BigInt.t) Prims.list
-      FStar_Tactics_Monad.tac)
-  =
-  fun s_tm ->
-    let uu___ =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun g ->
-           let uu___1 =
-             let uu___2 = FStar_Tactics_Types.goal_env g in __tc uu___2 s_tm in
-           FStar_Tactics_Monad.op_let_Bang uu___1
-             (fun uu___2 ->
-                match uu___2 with
-                | (s_tm1, s_ty, guard) ->
-                    let uu___3 =
-                      let uu___4 = FStar_Tactics_Types.goal_env g in
-                      let uu___5 =
-                        let uu___6 = should_check_goal_uvar g in
-                        FStar_Pervasives_Native.Some uu___6 in
-                      proc_guard "destruct" uu___4 guard uu___5 (rangeof g) in
-                    FStar_Tactics_Monad.op_let_Bang uu___3
-                      (fun uu___4 ->
-                         let s_ty1 =
-                           let uu___5 = FStar_Tactics_Types.goal_env g in
-                           FStar_TypeChecker_Normalize.normalize
-                             [FStar_TypeChecker_Env.UnfoldTac;
-                             FStar_TypeChecker_Env.Weak;
-                             FStar_TypeChecker_Env.HNF;
-                             FStar_TypeChecker_Env.UnfoldUntil
-                               FStar_Syntax_Syntax.delta_constant] uu___5
-                             s_ty in
-                         let uu___5 =
-                           let uu___6 = FStar_Syntax_Util.unrefine s_ty1 in
-                           FStar_Syntax_Util.head_and_args_full uu___6 in
-                         match uu___5 with
-                         | (h, args) ->
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 = FStar_Syntax_Subst.compress h in
-                                 uu___8.FStar_Syntax_Syntax.n in
-                               match uu___7 with
-                               | FStar_Syntax_Syntax.Tm_fvar fv ->
-                                   FStar_Tactics_Monad.ret (fv, [])
-                               | FStar_Syntax_Syntax.Tm_uinst (h', us) ->
-                                   let uu___8 =
-                                     let uu___9 =
-                                       FStar_Syntax_Subst.compress h' in
-                                     uu___9.FStar_Syntax_Syntax.n in
-                                   (match uu___8 with
-                                    | FStar_Syntax_Syntax.Tm_fvar fv ->
-                                        FStar_Tactics_Monad.ret (fv, us)
-                                    | uu___9 ->
-                                        failwith
-                                          "impossible: uinst over something that's not an fvar")
-                               | uu___8 ->
-                                   FStar_Tactics_Monad.fail
-                                     "type is not an fv" in
-                             FStar_Tactics_Monad.op_let_Bang uu___6
-                               (fun uu___7 ->
-                                  match uu___7 with
-                                  | (fv, a_us) ->
-                                      let t_lid =
-                                        FStar_Syntax_Syntax.lid_of_fv fv in
-                                      let uu___8 =
-                                        let uu___9 =
-                                          FStar_Tactics_Types.goal_env g in
-                                        FStar_TypeChecker_Env.lookup_sigelt
-                                          uu___9 t_lid in
-                                      (match uu___8 with
-                                       | FStar_Pervasives_Native.None ->
-                                           FStar_Tactics_Monad.fail
-                                             "type not found in environment"
-                                       | FStar_Pervasives_Native.Some se ->
-                                           (match se.FStar_Syntax_Syntax.sigel
-                                            with
-                                            | FStar_Syntax_Syntax.Sig_inductive_typ
-                                                (_lid, t_us, t_ps,
-                                                 _num_uniform, t_ty, mut,
-                                                 c_lids)
-                                                ->
-                                                let erasable =
-                                                  FStar_Syntax_Util.has_attribute
-                                                    se.FStar_Syntax_Syntax.sigattrs
-                                                    FStar_Parser_Const.erasable_attr in
-                                                let uu___9 =
-                                                  let uu___10 =
-                                                    erasable &&
-                                                      (let uu___11 =
-                                                         FStar_Tactics_Types.is_irrelevant
-                                                           g in
-                                                       Prims.op_Negation
-                                                         uu___11) in
-                                                  failwhen uu___10
-                                                    "cannot destruct erasable type to solve proof-relevant goal" in
-                                                FStar_Tactics_Monad.op_let_Bang
-                                                  uu___9
-                                                  (fun uu___10 ->
-                                                     let uu___11 =
-                                                       failwhen
-                                                         ((FStar_Compiler_List.length
-                                                             a_us)
-                                                            <>
-                                                            (FStar_Compiler_List.length
-                                                               t_us))
-                                                         "t_us don't match?" in
-                                                     FStar_Tactics_Monad.op_let_Bang
-                                                       uu___11
-                                                       (fun uu___12 ->
-                                                          let uu___13 =
-                                                            FStar_Syntax_Subst.open_term
-                                                              t_ps t_ty in
-                                                          match uu___13 with
-                                                          | (t_ps1, t_ty1) ->
-                                                              let uu___14 =
-                                                                FStar_Tactics_Monad.mapM
-                                                                  (fun c_lid
-                                                                    ->
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Tactics_Types.goal_env
-                                                                    g in
-                                                                    FStar_TypeChecker_Env.lookup_sigelt
-                                                                    uu___16
-                                                                    c_lid in
-                                                                    match uu___15
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    FStar_Tactics_Monad.fail
-                                                                    "ctor not found?"
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    se1 ->
-                                                                    (match 
-                                                                    se1.FStar_Syntax_Syntax.sigel
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Sig_datacon
-                                                                    (_c_lid,
-                                                                    c_us,
-                                                                    c_ty,
-                                                                    _t_lid,
-                                                                    nparam,
-                                                                    mut1) ->
-                                                                    let fv1 =
-                                                                    FStar_Syntax_Syntax.lid_as_fv
-                                                                    c_lid
-                                                                    FStar_Syntax_Syntax.delta_constant
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    FStar_Syntax_Syntax.Data_ctor) in
-                                                                    let uu___16
-                                                                    =
-                                                                    failwhen
-                                                                    ((FStar_Compiler_List.length
-                                                                    a_us) <>
-                                                                    (FStar_Compiler_List.length
-                                                                    c_us))
-                                                                    "t_us don't match?" in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___16
-                                                                    (fun
-                                                                    uu___17
-                                                                    ->
-                                                                    let s =
-                                                                    FStar_TypeChecker_Env.mk_univ_subst
-                                                                    c_us a_us in
-                                                                    let c_ty1
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    s c_ty in
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_Env.inst_tscheme
-                                                                    (c_us,
-                                                                    c_ty1) in
-                                                                    match uu___18
-                                                                    with
-                                                                    | 
-                                                                    (c_us1,
-                                                                    c_ty2) ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Syntax_Util.arrow_formals_comp
-                                                                    c_ty2 in
-                                                                    (match uu___19
-                                                                    with
-                                                                    | 
-                                                                    (bs,
-                                                                    comp) ->
-                                                                    let uu___20
-                                                                    =
-                                                                    let rename_bv
-                                                                    bv =
-                                                                    let ppname
-                                                                    =
-                                                                    bv.FStar_Syntax_Syntax.ppname in
-                                                                    let ppname1
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Ident.string_of_id
-                                                                    ppname in
-                                                                    Prims.op_Hat
-                                                                    "a"
-                                                                    uu___23 in
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Ident.range_of_id
-                                                                    ppname in
-                                                                    (uu___22,
-                                                                    uu___23) in
-                                                                    FStar_Ident.mk_ident
-                                                                    uu___21 in
-                                                                    FStar_Syntax_Syntax.freshen_bv
-                                                                    {
-                                                                    FStar_Syntax_Syntax.ppname
-                                                                    = ppname1;
-                                                                    FStar_Syntax_Syntax.index
-                                                                    =
-                                                                    (bv.FStar_Syntax_Syntax.index);
-                                                                    FStar_Syntax_Syntax.sort
-                                                                    =
-                                                                    (bv.FStar_Syntax_Syntax.sort)
-                                                                    } in
-                                                                    let bs' =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun b ->
-                                                                    let uu___21
-                                                                    =
-                                                                    rename_bv
-                                                                    b.FStar_Syntax_Syntax.binder_bv in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = uu___21;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_qual);
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_attrs)
-                                                                    }) bs in
-                                                                    let subst
-                                                                    =
-                                                                    FStar_Compiler_List.map2
-                                                                    (fun
-                                                                    uu___21
-                                                                    ->
-                                                                    fun
-                                                                    uu___22
-                                                                    ->
-                                                                    match 
-                                                                    (uu___21,
-                                                                    uu___22)
-                                                                    with
-                                                                    | 
-                                                                    ({
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___23;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___24;_},
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv';
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___25;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___26;_})
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    bv' in
-                                                                    (bv,
-                                                                    uu___28) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___27)
-                                                                    bs bs' in
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst_binders
-                                                                    subst bs' in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst_comp
-                                                                    subst
-                                                                    comp in
-                                                                    (uu___21,
-                                                                    uu___22) in
-                                                                    (match uu___20
-                                                                    with
-                                                                    | 
-                                                                    (bs1,
-                                                                    comp1) ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    nparam
-                                                                    bs1 in
-                                                                    (match uu___21
-                                                                    with
-                                                                    | 
-                                                                    (d_ps,
-                                                                    bs2) ->
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Util.is_total_comp
-                                                                    comp1 in
-                                                                    Prims.op_Negation
-                                                                    uu___24 in
-                                                                    failwhen
-                                                                    uu___23
-                                                                    "not total?" in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___22
-                                                                    (fun
-                                                                    uu___23
-                                                                    ->
-                                                                    let mk_pat
-                                                                    p =
-                                                                    {
-                                                                    FStar_Syntax_Syntax.v
-                                                                    = p;
-                                                                    FStar_Syntax_Syntax.p
-                                                                    =
-                                                                    (s_tm1.FStar_Syntax_Syntax.pos)
-                                                                    } in
-                                                                    let is_imp
-                                                                    uu___24 =
-                                                                    match uu___24
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (FStar_Syntax_Syntax.Implicit
-                                                                    uu___25)
-                                                                    -> true
-                                                                    | 
-                                                                    uu___25
-                                                                    -> false in
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    nparam
-                                                                    args in
-                                                                    match uu___24
-                                                                    with
-                                                                    | 
-                                                                    (a_ps,
-                                                                    a_is) ->
-                                                                    let uu___25
-                                                                    =
-                                                                    failwhen
-                                                                    ((FStar_Compiler_List.length
-                                                                    a_ps) <>
-                                                                    (FStar_Compiler_List.length
-                                                                    d_ps))
-                                                                    "params not match?" in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___25
-                                                                    (fun
-                                                                    uu___26
-                                                                    ->
-                                                                    let d_ps_a_ps
-                                                                    =
-                                                                    FStar_Compiler_List.zip
-                                                                    d_ps a_ps in
-                                                                    let subst
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___27
-                                                                    ->
-                                                                    match uu___27
-                                                                    with
-                                                                    | 
-                                                                    ({
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___28;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___29;_},
-                                                                    (t,
-                                                                    uu___30))
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    (bv, t))
-                                                                    d_ps_a_ps in
-                                                                    let bs3 =
-                                                                    FStar_Syntax_Subst.subst_binders
-                                                                    subst bs2 in
-                                                                    let subpats_1
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___27
-                                                                    ->
-                                                                    match uu___27
-                                                                    with
-                                                                    | 
-                                                                    ({
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___28;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___29;_},
-                                                                    (t,
-                                                                    uu___30))
-                                                                    ->
-                                                                    ((mk_pat
-                                                                    (FStar_Syntax_Syntax.Pat_dot_term
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    t))),
-                                                                    true))
-                                                                    d_ps_a_ps in
-                                                                    let subpats_2
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___27
-                                                                    ->
-                                                                    match uu___27
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = bq;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___28;_}
-                                                                    ->
-                                                                    ((mk_pat
-                                                                    (FStar_Syntax_Syntax.Pat_var
-                                                                    bv)),
-                                                                    (is_imp
-                                                                    bq))) bs3 in
-                                                                    let subpats
-                                                                    =
-                                                                    FStar_Compiler_List.op_At
-                                                                    subpats_1
-                                                                    subpats_2 in
-                                                                    let pat =
-                                                                    mk_pat
-                                                                    (FStar_Syntax_Syntax.Pat_cons
-                                                                    (fv1,
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    a_us),
-                                                                    subpats)) in
-                                                                    let env1
-                                                                    =
-                                                                    FStar_Tactics_Types.goal_env
-                                                                    g in
-                                                                    let cod =
-                                                                    FStar_Tactics_Types.goal_type
-                                                                    g in
-                                                                    let equ =
-                                                                    env1.FStar_TypeChecker_Env.universe_of
-                                                                    env1
-                                                                    s_ty1 in
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_TcTerm.tc_pat
-                                                                    {
-                                                                    FStar_TypeChecker_Env.solver
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.solver);
-                                                                    FStar_TypeChecker_Env.range
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.range);
-                                                                    FStar_TypeChecker_Env.curmodule
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.curmodule);
-                                                                    FStar_TypeChecker_Env.gamma
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma);
-                                                                    FStar_TypeChecker_Env.gamma_sig
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma_sig);
-                                                                    FStar_TypeChecker_Env.gamma_cache
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma_cache);
-                                                                    FStar_TypeChecker_Env.modules
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.modules);
-                                                                    FStar_TypeChecker_Env.expected_typ
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.expected_typ);
-                                                                    FStar_TypeChecker_Env.sigtab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.sigtab);
-                                                                    FStar_TypeChecker_Env.attrtab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.attrtab);
-                                                                    FStar_TypeChecker_Env.instantiate_imp
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                                                    FStar_TypeChecker_Env.effects
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.effects);
-                                                                    FStar_TypeChecker_Env.generalize
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.generalize);
-                                                                    FStar_TypeChecker_Env.letrecs
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.letrecs);
-                                                                    FStar_TypeChecker_Env.top_level
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.top_level);
-                                                                    FStar_TypeChecker_Env.check_uvars
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.check_uvars);
-                                                                    FStar_TypeChecker_Env.use_eq_strict
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                                                    FStar_TypeChecker_Env.is_iface
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.is_iface);
-                                                                    FStar_TypeChecker_Env.admit
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.admit);
-                                                                    FStar_TypeChecker_Env.lax
-                                                                    = true;
-                                                                    FStar_TypeChecker_Env.lax_universes
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.lax_universes);
-                                                                    FStar_TypeChecker_Env.phase1
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.phase1);
-                                                                    FStar_TypeChecker_Env.failhard
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.failhard);
-                                                                    FStar_TypeChecker_Env.nosynth
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.nosynth);
-                                                                    FStar_TypeChecker_Env.uvar_subtyping
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                                                    FStar_TypeChecker_Env.tc_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.tc_term);
-                                                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.universe_of
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.universe_of);
-                                                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.teq_nosmt_force
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                                    FStar_TypeChecker_Env.normalized_eff_names
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                                                    FStar_TypeChecker_Env.fv_delta_depths
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                                                    FStar_TypeChecker_Env.proof_ns
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.proof_ns);
-                                                                    FStar_TypeChecker_Env.synth_hook
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.synth_hook);
-                                                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                                    FStar_TypeChecker_Env.splice
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.splice);
-                                                                    FStar_TypeChecker_Env.mpreprocess
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.mpreprocess);
-                                                                    FStar_TypeChecker_Env.postprocess
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.postprocess);
-                                                                    FStar_TypeChecker_Env.identifier_info
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.identifier_info);
-                                                                    FStar_TypeChecker_Env.tc_hooks
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.tc_hooks);
-                                                                    FStar_TypeChecker_Env.dsenv
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.dsenv);
-                                                                    FStar_TypeChecker_Env.nbe
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.nbe);
-                                                                    FStar_TypeChecker_Env.strict_args_tab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                                                    FStar_TypeChecker_Env.erasable_types_tab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                                    FStar_TypeChecker_Env.erase_erasable_args
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                                                    FStar_TypeChecker_Env.core_check
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.core_check)
-                                                                    } s_ty1
-                                                                    pat in
-                                                                    match uu___27
-                                                                    with
-                                                                    | 
-                                                                    (uu___28,
-                                                                    uu___29,
-                                                                    uu___30,
-                                                                    uu___31,
-                                                                    pat_t,
-                                                                    uu___32,
-                                                                    _guard_pat,
-                                                                    _erasable)
-                                                                    ->
-                                                                    let eq_b
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_Syntax_Util.mk_eq2
-                                                                    equ s_ty1
-                                                                    s_tm1
-                                                                    pat_t in
-                                                                    FStar_Syntax_Util.mk_squash
-                                                                    FStar_Syntax_Syntax.U_zero
-                                                                    uu___34 in
-                                                                    FStar_Syntax_Syntax.gen_bv
-                                                                    "breq"
-                                                                    FStar_Pervasives_Native.None
-                                                                    uu___33 in
-                                                                    let cod1
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    eq_b in
-                                                                    [uu___34] in
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    cod in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___33
-                                                                    uu___34 in
-                                                                    let nty =
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    cod1 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    bs3
-                                                                    uu___33 in
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    goal_typedness_deps
-                                                                    g in
-                                                                    FStar_Tactics_Monad.new_uvar
-                                                                    "destruct branch"
-                                                                    env1 nty
-                                                                    FStar_Pervasives_Native.None
-                                                                    uu___34
-                                                                    (rangeof
-                                                                    g) in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___33
-                                                                    (fun
-                                                                    uu___34
-                                                                    ->
-                                                                    match uu___34
-                                                                    with
-                                                                    | 
-                                                                    (uvt, uv)
-                                                                    ->
-                                                                    let g' =
-                                                                    FStar_Tactics_Types.mk_goal
-                                                                    env1 uv
-                                                                    g.FStar_Tactics_Types.opts
-                                                                    false
-                                                                    g.FStar_Tactics_Types.label in
-                                                                    let brt =
-                                                                    FStar_Syntax_Util.mk_app_binders
-                                                                    uvt bs3 in
-                                                                    let brt1
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_Syntax_Syntax.as_arg
-                                                                    FStar_Syntax_Util.exp_unit in
-                                                                    [uu___36] in
-                                                                    FStar_Syntax_Util.mk_app
-                                                                    brt
-                                                                    uu___35 in
-                                                                    let br =
-                                                                    FStar_Syntax_Subst.close_branch
-                                                                    (pat,
-                                                                    FStar_Pervasives_Native.None,
-                                                                    brt1) in
-                                                                    let uu___35
-                                                                    =
-                                                                    let uu___36
-                                                                    =
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_BigInt.of_int_fs
-                                                                    (FStar_Compiler_List.length
-                                                                    bs3) in
-                                                                    (fv1,
-                                                                    uu___37) in
-                                                                    (g', br,
-                                                                    uu___36) in
-                                                                    FStar_Tactics_Monad.ret
-                                                                    uu___35)))))))
-                                                                    | 
-                                                                    uu___16
-                                                                    ->
-                                                                    FStar_Tactics_Monad.fail
-                                                                    "impossible: not a ctor"))
-                                                                  c_lids in
-                                                              FStar_Tactics_Monad.op_let_Bang
-                                                                uu___14
-                                                                (fun goal_brs
-                                                                   ->
-                                                                   let uu___15
-                                                                    =
-                                                                    FStar_Compiler_List.unzip3
-                                                                    goal_brs in
-                                                                   match uu___15
-                                                                   with
-                                                                   | 
-                                                                   (goals,
-                                                                    brs,
-                                                                    infos) ->
-                                                                    let w =
-                                                                    FStar_Syntax_Syntax.mk
-                                                                    (FStar_Syntax_Syntax.Tm_match
-                                                                    (s_tm1,
-                                                                    FStar_Pervasives_Native.None,
-                                                                    brs,
-                                                                    FStar_Pervasives_Native.None))
-                                                                    s_tm1.FStar_Syntax_Syntax.pos in
-                                                                    let uu___16
-                                                                    =
-                                                                    solve' g
-                                                                    w in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___16
-                                                                    (fun
-                                                                    uu___17
-                                                                    ->
-                                                                    mark_goal_implicit_already_checked
-                                                                    g;
-                                                                    (
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Tactics_Monad.add_goals
-                                                                    goals in
-                                                                    FStar_Tactics_Monad.op_let_Bang
-                                                                    uu___19
-                                                                    (fun
-                                                                    uu___20
-                                                                    ->
-                                                                    FStar_Tactics_Monad.ret
-                                                                    infos))))))
-                                            | uu___9 ->
-                                                FStar_Tactics_Monad.fail
-                                                  "not an inductive type")))))) in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "destruct") uu___
-let (gather_explicit_guards_for_resolved_goals :
-  unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ -> FStar_Tactics_Monad.ret ()
-let rec last : 'a . 'a Prims.list -> 'a =
-  fun l ->
-    match l with
-    | [] -> failwith "last: empty list"
-    | x::[] -> x
-    | uu___::xs -> last xs
-let rec init : 'a . 'a Prims.list -> 'a Prims.list =
-  fun l ->
-    match l with
-    | [] -> failwith "init: empty list"
-    | x::[] -> []
-    | x::xs -> let uu___ = init xs in x :: uu___
-let rec (inspect :
-  FStar_Syntax_Syntax.term ->
-    FStar_Reflection_Data.term_view FStar_Tactics_Monad.tac)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 = top_env () in
-      FStar_Tactics_Monad.op_let_Bang uu___1
-        (fun e ->
-           let t1 = FStar_Syntax_Util.unlazy_emb t in
-           let t2 = FStar_Syntax_Subst.compress t1 in
-           match t2.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_meta (t3, uu___2) -> inspect t3
-           | FStar_Syntax_Syntax.Tm_name bv ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_Var bv)
-           | FStar_Syntax_Syntax.Tm_bvar bv ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_BVar bv)
-           | FStar_Syntax_Syntax.Tm_fvar fv ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_FVar fv)
-           | FStar_Syntax_Syntax.Tm_uinst (t3, us) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Compiler_Effect.op_Bar_Greater t3
-                       FStar_Syntax_Subst.compress in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___4
-                     FStar_Syntax_Util.unascribe in
-                 uu___3.FStar_Syntax_Syntax.n in
-               (match uu___2 with
-                | FStar_Syntax_Syntax.Tm_fvar fv ->
-                    FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                      (FStar_Reflection_Data.Tv_UInst (fv, us))
-                | uu___3 ->
-                    failwith "Tac::inspect: Tm_uinst head not an fvar")
-           | FStar_Syntax_Syntax.Tm_ascribed
-               (t3, (FStar_Pervasives.Inl ty, tacopt, eq), _elid) ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_AscribedT (t3, ty, tacopt, eq))
-           | FStar_Syntax_Syntax.Tm_ascribed
-               (t3, (FStar_Pervasives.Inr cty, tacopt, eq), elid) ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_AscribedC (t3, cty, tacopt, eq))
-           | FStar_Syntax_Syntax.Tm_app (hd, []) ->
-               failwith "empty arguments on Tm_app"
-           | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-               let uu___2 = last args in
-               (match uu___2 with
-                | (a, q) ->
-                    let q' = FStar_Reflection_Basic.inspect_aqual q in
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 = init args in
-                          FStar_Syntax_Syntax.mk_Tm_app hd uu___6
-                            t2.FStar_Syntax_Syntax.pos in
-                        (uu___5, (a, q')) in
-                      FStar_Reflection_Data.Tv_App uu___4 in
-                    FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                      uu___3)
-           | FStar_Syntax_Syntax.Tm_abs ([], uu___2, uu___3) ->
-               failwith "empty arguments on Tm_abs"
-           | FStar_Syntax_Syntax.Tm_abs (bs, t3, k) ->
-               let uu___2 = FStar_Syntax_Subst.open_term bs t3 in
-               (match uu___2 with
-                | (bs1, t4) ->
-                    (match bs1 with
-                     | [] -> failwith "impossible"
-                     | b::bs2 ->
-                         let uu___3 =
-                           let uu___4 =
-                             let uu___5 = FStar_Syntax_Util.abs bs2 t4 k in
-                             (b, uu___5) in
-                           FStar_Reflection_Data.Tv_Abs uu___4 in
-                         FStar_Compiler_Effect.op_Less_Bar
-                           FStar_Tactics_Monad.ret uu___3))
-           | FStar_Syntax_Syntax.Tm_type u ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_Type u)
-           | FStar_Syntax_Syntax.Tm_arrow ([], k) ->
-               failwith "empty binders on arrow"
-           | FStar_Syntax_Syntax.Tm_arrow uu___2 ->
-               let uu___3 = FStar_Syntax_Util.arrow_one t2 in
-               (match uu___3 with
-                | FStar_Pervasives_Native.Some (b, c) ->
-                    FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                      (FStar_Reflection_Data.Tv_Arrow (b, c))
-                | FStar_Pervasives_Native.None -> failwith "impossible")
-           | FStar_Syntax_Syntax.Tm_refine (bv, t3) ->
-               let b = FStar_Syntax_Syntax.mk_binder bv in
-               let uu___2 = FStar_Syntax_Subst.open_term [b] t3 in
-               (match uu___2 with
-                | (b', t4) ->
-                    let b1 =
-                      match b' with
-                      | b'1::[] -> b'1
-                      | uu___3 -> failwith "impossible" in
-                    FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                      (FStar_Reflection_Data.Tv_Refine
-                         ((b1.FStar_Syntax_Syntax.binder_bv), t4)))
-           | FStar_Syntax_Syntax.Tm_constant c ->
-               let uu___2 =
-                 let uu___3 = FStar_Reflection_Basic.inspect_const c in
-                 FStar_Reflection_Data.Tv_Const uu___3 in
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 uu___2
-           | FStar_Syntax_Syntax.Tm_uvar (ctx_u, s) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Syntax_Unionfind.uvar_id
-                         ctx_u.FStar_Syntax_Syntax.ctx_uvar_head in
-                     FStar_BigInt.of_int_fs uu___5 in
-                   (uu___4, (ctx_u, s)) in
-                 FStar_Reflection_Data.Tv_Uvar uu___3 in
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 uu___2
-           | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), t21) ->
-               if lb.FStar_Syntax_Syntax.lbunivs <> []
-               then
-                 FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                   FStar_Reflection_Data.Tv_Unknown
-               else
-                 (match lb.FStar_Syntax_Syntax.lbname with
-                  | FStar_Pervasives.Inr uu___3 ->
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Tactics_Monad.ret
-                        FStar_Reflection_Data.Tv_Unknown
-                  | FStar_Pervasives.Inl bv ->
-                      let b = FStar_Syntax_Syntax.mk_binder bv in
-                      let uu___3 = FStar_Syntax_Subst.open_term [b] t21 in
-                      (match uu___3 with
-                       | (bs, t22) ->
-                           let b1 =
-                             match bs with
-                             | b2::[] -> b2
-                             | uu___4 ->
-                                 failwith
-                                   "impossible: open_term returned different amount of binders" in
-                           FStar_Compiler_Effect.op_Less_Bar
-                             FStar_Tactics_Monad.ret
-                             (FStar_Reflection_Data.Tv_Let
-                                (false, (lb.FStar_Syntax_Syntax.lbattrs),
-                                  (b1.FStar_Syntax_Syntax.binder_bv),
-                                  (lb.FStar_Syntax_Syntax.lbdef), t22))))
-           | FStar_Syntax_Syntax.Tm_let ((true, lb::[]), t21) ->
-               if lb.FStar_Syntax_Syntax.lbunivs <> []
-               then
-                 FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                   FStar_Reflection_Data.Tv_Unknown
-               else
-                 (match lb.FStar_Syntax_Syntax.lbname with
-                  | FStar_Pervasives.Inr uu___3 ->
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Tactics_Monad.ret
-                        FStar_Reflection_Data.Tv_Unknown
-                  | FStar_Pervasives.Inl bv ->
-                      let uu___3 = FStar_Syntax_Subst.open_let_rec [lb] t21 in
-                      (match uu___3 with
-                       | (lbs, t22) ->
-                           (match lbs with
-                            | lb1::[] ->
-                                (match lb1.FStar_Syntax_Syntax.lbname with
-                                 | FStar_Pervasives.Inr uu___4 ->
-                                     FStar_Tactics_Monad.ret
-                                       FStar_Reflection_Data.Tv_Unknown
-                                 | FStar_Pervasives.Inl bv1 ->
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       FStar_Tactics_Monad.ret
-                                       (FStar_Reflection_Data.Tv_Let
-                                          (true,
-                                            (lb1.FStar_Syntax_Syntax.lbattrs),
-                                            bv1,
-                                            (lb1.FStar_Syntax_Syntax.lbdef),
-                                            t22)))
-                            | uu___4 ->
-                                failwith
-                                  "impossible: open_term returned different amount of binders")))
-           | FStar_Syntax_Syntax.Tm_match (t3, ret_opt, brs, uu___2) ->
-               let rec inspect_pat p =
-                 match p.FStar_Syntax_Syntax.v with
-                 | FStar_Syntax_Syntax.Pat_constant c ->
-                     let uu___3 = FStar_Reflection_Basic.inspect_const c in
-                     FStar_Reflection_Data.Pat_Constant uu___3
-                 | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, ps) ->
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Compiler_List.map
-                           (fun uu___5 ->
-                              match uu___5 with
-                              | (p1, b) ->
-                                  let uu___6 = inspect_pat p1 in (uu___6, b))
-                           ps in
-                       (fv, us_opt, uu___4) in
-                     FStar_Reflection_Data.Pat_Cons uu___3
-                 | FStar_Syntax_Syntax.Pat_var bv ->
-                     FStar_Reflection_Data.Pat_Var bv
-                 | FStar_Syntax_Syntax.Pat_wild bv ->
-                     FStar_Reflection_Data.Pat_Wild bv
-                 | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-                     FStar_Reflection_Data.Pat_Dot_Term eopt in
-               let brs1 =
-                 FStar_Compiler_List.map FStar_Syntax_Subst.open_branch brs in
-               let brs2 =
-                 FStar_Compiler_List.map
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (pat, uu___4, t4) ->
-                          let uu___5 = inspect_pat pat in (uu___5, t4)) brs1 in
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 (FStar_Reflection_Data.Tv_Match (t3, ret_opt, brs2))
-           | FStar_Syntax_Syntax.Tm_unknown ->
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 FStar_Reflection_Data.Tv_Unknown
-           | uu___2 ->
-               ((let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.tag_of_term t2 in
-                     let uu___7 = FStar_Syntax_Print.term_to_string t2 in
-                     FStar_Compiler_Util.format2
-                       "inspect: outside of expected syntax (%s, %s)\n"
-                       uu___6 uu___7 in
-                   (FStar_Errors.Warning_CantInspect, uu___5) in
-                 FStar_Errors.log_issue t2.FStar_Syntax_Syntax.pos uu___4);
-                FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                  FStar_Reflection_Data.Tv_Unknown)) in
-    FStar_Tactics_Monad.wrap_err "inspect" uu___
-let (pack' :
-  FStar_Reflection_Data.term_view ->
-    Prims.bool -> FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun tv ->
-    fun leave_curried ->
-      match tv with
-      | FStar_Reflection_Data.Tv_Var bv ->
-          let uu___ = FStar_Syntax_Syntax.bv_to_name bv in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_BVar bv ->
-          let uu___ = FStar_Syntax_Syntax.bv_to_tm bv in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_FVar fv ->
-          let uu___ = FStar_Syntax_Syntax.fv_to_tm fv in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_UInst (fv, us) ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.fv_to_tm fv in
-            FStar_Syntax_Syntax.mk_Tm_uinst uu___1 us in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_App (l, (r, q)) ->
-          let q' = FStar_Reflection_Basic.pack_aqual q in
-          let uu___ = FStar_Syntax_Util.mk_app l [(r, q')] in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Abs (b, t) ->
-          let uu___ =
-            FStar_Syntax_Util.abs [b] t FStar_Pervasives_Native.None in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Arrow (b, c) ->
-          let uu___ =
-            if leave_curried
-            then FStar_Syntax_Util.arrow [b] c
-            else
-              (let uu___2 = FStar_Syntax_Util.arrow [b] c in
-               FStar_Syntax_Util.canon_arrow uu___2) in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Type u ->
-          let uu___ =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-              FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Refine (bv, t) ->
-          let uu___ = FStar_Syntax_Util.refine bv t in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Const c ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Reflection_Basic.pack_const c in
-              FStar_Syntax_Syntax.Tm_constant uu___2 in
-            FStar_Syntax_Syntax.mk uu___1 FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Uvar (_u, ctx_u_s) ->
-          let uu___ =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_uvar ctx_u_s)
-              FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Let (false, attrs, bv, t1, t2) ->
-          let lb =
-            FStar_Syntax_Util.mk_letbinding (FStar_Pervasives.Inl bv) []
-              bv.FStar_Syntax_Syntax.sort FStar_Parser_Const.effect_Tot_lid
-              t1 attrs FStar_Compiler_Range.dummyRange in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = FStar_Syntax_Syntax.mk_binder bv in [uu___5] in
-                  FStar_Syntax_Subst.close uu___4 t2 in
-                ((false, [lb]), uu___3) in
-              FStar_Syntax_Syntax.Tm_let uu___2 in
-            FStar_Syntax_Syntax.mk uu___1 FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Let (true, attrs, bv, t1, t2) ->
-          let lb =
-            FStar_Syntax_Util.mk_letbinding (FStar_Pervasives.Inl bv) []
-              bv.FStar_Syntax_Syntax.sort FStar_Parser_Const.effect_Tot_lid
-              t1 attrs FStar_Compiler_Range.dummyRange in
-          let uu___ = FStar_Syntax_Subst.close_let_rec [lb] t2 in
-          (match uu___ with
-           | (lbs, body) ->
-               let uu___1 =
-                 FStar_Syntax_Syntax.mk
-                   (FStar_Syntax_Syntax.Tm_let ((true, lbs), body))
-                   FStar_Compiler_Range.dummyRange in
-               FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret
-                 uu___1)
-      | FStar_Reflection_Data.Tv_Match (t, ret_opt, brs) ->
-          let wrap v =
-            {
-              FStar_Syntax_Syntax.v = v;
-              FStar_Syntax_Syntax.p = FStar_Compiler_Range.dummyRange
-            } in
-          let rec pack_pat p =
-            match p with
-            | FStar_Reflection_Data.Pat_Constant c ->
-                let uu___ =
-                  let uu___1 = FStar_Reflection_Basic.pack_const c in
-                  FStar_Syntax_Syntax.Pat_constant uu___1 in
-                FStar_Compiler_Effect.op_Less_Bar wrap uu___
-            | FStar_Reflection_Data.Pat_Cons (fv, us_opt, ps) ->
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_List.map
-                        (fun uu___3 ->
-                           match uu___3 with
-                           | (p1, b) ->
-                               let uu___4 = pack_pat p1 in (uu___4, b)) ps in
-                    (fv, us_opt, uu___2) in
-                  FStar_Syntax_Syntax.Pat_cons uu___1 in
-                FStar_Compiler_Effect.op_Less_Bar wrap uu___
-            | FStar_Reflection_Data.Pat_Var bv ->
-                FStar_Compiler_Effect.op_Less_Bar wrap
-                  (FStar_Syntax_Syntax.Pat_var bv)
-            | FStar_Reflection_Data.Pat_Wild bv ->
-                FStar_Compiler_Effect.op_Less_Bar wrap
-                  (FStar_Syntax_Syntax.Pat_wild bv)
-            | FStar_Reflection_Data.Pat_Dot_Term eopt ->
-                FStar_Compiler_Effect.op_Less_Bar wrap
-                  (FStar_Syntax_Syntax.Pat_dot_term eopt) in
-          let brs1 =
-            FStar_Compiler_List.map
-              (fun uu___ ->
-                 match uu___ with
-                 | (pat, t1) ->
-                     let uu___1 = pack_pat pat in
-                     (uu___1, FStar_Pervasives_Native.None, t1)) brs in
-          let brs2 =
-            FStar_Compiler_List.map FStar_Syntax_Subst.close_branch brs1 in
-          let uu___ =
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_match
-                 (t, ret_opt, brs2, FStar_Pervasives_Native.None))
-              FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_AscribedT (e, t, tacopt, use_eq) ->
-          let uu___ =
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_ascribed
-                 (e, ((FStar_Pervasives.Inl t), tacopt, use_eq),
-                   FStar_Pervasives_Native.None))
-              FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_AscribedC (e, c, tacopt, use_eq) ->
-          let uu___ =
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_ascribed
-                 (e, ((FStar_Pervasives.Inr c), tacopt, use_eq),
-                   FStar_Pervasives_Native.None))
-              FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-      | FStar_Reflection_Data.Tv_Unknown ->
-          let uu___ =
-            FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-              FStar_Compiler_Range.dummyRange in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Tactics_Monad.ret uu___
-let (pack :
-  FStar_Reflection_Data.term_view ->
-    FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  = fun tv -> pack' tv false
-let (pack_curried :
-  FStar_Reflection_Data.term_view ->
-    FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  = fun tv -> pack' tv true
-let (lget :
-  FStar_Reflection_Data.typ ->
-    Prims.string -> FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun ty ->
-    fun k ->
-      let uu___ =
-        FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-          (fun ps ->
-             let uu___1 =
-               FStar_Compiler_Util.psmap_try_find
-                 ps.FStar_Tactics_Types.local_state k in
-             match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Tactics_Monad.fail "not found"
-             | FStar_Pervasives_Native.Some t -> unquote ty t) in
-      FStar_Compiler_Effect.op_Less_Bar (FStar_Tactics_Monad.wrap_err "lget")
-        uu___
-let (lset :
-  FStar_Reflection_Data.typ ->
-    Prims.string -> FStar_Syntax_Syntax.term -> unit FStar_Tactics_Monad.tac)
-  =
-  fun _ty ->
-    fun k ->
-      fun t ->
-        let uu___ =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-            (fun ps ->
-               let ps1 =
-                 let uu___1 =
-                   FStar_Compiler_Util.psmap_add
-                     ps.FStar_Tactics_Types.local_state k t in
-                 {
-                   FStar_Tactics_Types.main_context =
-                     (ps.FStar_Tactics_Types.main_context);
-                   FStar_Tactics_Types.all_implicits =
-                     (ps.FStar_Tactics_Types.all_implicits);
-                   FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-                   FStar_Tactics_Types.smt_goals =
-                     (ps.FStar_Tactics_Types.smt_goals);
-                   FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-                   FStar_Tactics_Types.__dump =
-                     (ps.FStar_Tactics_Types.__dump);
-                   FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-                   FStar_Tactics_Types.entry_range =
-                     (ps.FStar_Tactics_Types.entry_range);
-                   FStar_Tactics_Types.guard_policy =
-                     (ps.FStar_Tactics_Types.guard_policy);
-                   FStar_Tactics_Types.freshness =
-                     (ps.FStar_Tactics_Types.freshness);
-                   FStar_Tactics_Types.tac_verb_dbg =
-                     (ps.FStar_Tactics_Types.tac_verb_dbg);
-                   FStar_Tactics_Types.local_state = uu___1;
-                   FStar_Tactics_Types.urgency =
-                     (ps.FStar_Tactics_Types.urgency)
-                 } in
-               FStar_Tactics_Monad.set ps1) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "lset") uu___
-let (set_urgency : FStar_BigInt.t -> unit FStar_Tactics_Monad.tac) =
-  fun u ->
-    FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-      (fun ps ->
-         let ps1 =
-           let uu___ = FStar_BigInt.to_int_fs u in
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = uu___
-           } in
-         FStar_Tactics_Monad.set ps1)
-let (t_commute_applied_match : unit -> unit FStar_Tactics_Monad.tac) =
-  fun uu___ ->
-    let uu___1 =
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.cur_goal
-        (fun g ->
-           let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Tactics_Types.goal_env g in
-               let uu___5 = FStar_Tactics_Types.goal_type g in
-               whnf uu___4 uu___5 in
-             destruct_eq uu___3 in
-           match uu___2 with
-           | FStar_Pervasives_Native.Some (l, r) ->
-               let uu___3 = FStar_Syntax_Util.head_and_args_full l in
-               (match uu___3 with
-                | (lh, las) ->
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = FStar_Syntax_Util.unascribe lh in
-                        FStar_Syntax_Subst.compress uu___6 in
-                      uu___5.FStar_Syntax_Syntax.n in
-                    (match uu___4 with
-                     | FStar_Syntax_Syntax.Tm_match (e, asc_opt, brs, lopt)
-                         ->
-                         let brs' =
-                           FStar_Compiler_List.map
-                             (fun uu___5 ->
-                                match uu___5 with
-                                | (p, w, e1) ->
-                                    let uu___6 =
-                                      FStar_Syntax_Util.mk_app e1 las in
-                                    (p, w, uu___6)) brs in
-                         let lopt' =
-                           FStar_Compiler_Effect.op_Bar_Greater lopt
-                             (FStar_Compiler_Util.map_option
-                                (fun rc ->
-                                   let uu___5 =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       rc.FStar_Syntax_Syntax.residual_typ
-                                       (FStar_Compiler_Util.map_option
-                                          (fun t ->
-                                             let uu___6 =
-                                               let uu___7 =
-                                                 FStar_Tactics_Types.goal_env
-                                                   g in
-                                               FStar_TypeChecker_Normalize.get_n_binders
-                                                 uu___7
-                                                 (FStar_Compiler_List.length
-                                                    las) t in
-                                             match uu___6 with
-                                             | (bs, c) ->
-                                                 let uu___7 =
-                                                   FStar_Syntax_Subst.open_comp
-                                                     bs c in
-                                                 (match uu___7 with
-                                                  | (bs1, c1) ->
-                                                      let ss =
-                                                        FStar_Compiler_List.map2
-                                                          (fun b ->
-                                                             fun a ->
-                                                               FStar_Syntax_Syntax.NT
-                                                                 ((b.FStar_Syntax_Syntax.binder_bv),
-                                                                   (FStar_Pervasives_Native.fst
-                                                                    a))) bs1
-                                                          las in
-                                                      let c2 =
-                                                        FStar_Syntax_Subst.subst_comp
-                                                          ss c1 in
-                                                      FStar_Syntax_Util.comp_result
-                                                        c2))) in
-                                   {
-                                     FStar_Syntax_Syntax.residual_effect =
-                                       (rc.FStar_Syntax_Syntax.residual_effect);
-                                     FStar_Syntax_Syntax.residual_typ =
-                                       uu___5;
-                                     FStar_Syntax_Syntax.residual_flags =
-                                       (rc.FStar_Syntax_Syntax.residual_flags)
-                                   })) in
-                         let l' =
-                           FStar_Syntax_Syntax.mk
-                             (FStar_Syntax_Syntax.Tm_match
-                                (e, asc_opt, brs', lopt'))
-                             l.FStar_Syntax_Syntax.pos in
-                         let must_tot = true in
-                         let uu___5 =
-                           let uu___6 = FStar_Tactics_Types.goal_env g in
-                           do_unify_maybe_guards false must_tot uu___6 l' r in
-                         FStar_Tactics_Monad.op_let_Bang uu___5
-                           (fun uu___6 ->
-                              match uu___6 with
-                              | FStar_Pervasives_Native.None ->
-                                  FStar_Tactics_Monad.fail
-                                    "discharging the equality failed"
-                              | FStar_Pervasives_Native.Some guard ->
-                                  let uu___7 =
-                                    FStar_TypeChecker_Env.is_trivial_guard_formula
-                                      guard in
-                                  if uu___7
-                                  then
-                                    (mark_uvar_as_already_checked
-                                       g.FStar_Tactics_Types.goal_ctx_uvar;
-                                     solve g FStar_Syntax_Util.exp_unit)
-                                  else
-                                    failwith
-                                      "internal error: _t_refl: guard is not trivial"
-                              | uu___7 ->
-                                  FStar_Tactics_Monad.fail
-                                    "lhs is not a match")))
-           | FStar_Pervasives_Native.None ->
-               FStar_Tactics_Monad.fail "not an equality") in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Tactics_Monad.wrap_err "t_commute_applied_match") uu___1
-let (string_to_term :
-  env -> Prims.string -> FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac) =
-  fun e ->
-    fun s ->
-      let frag_of_text s1 =
-        {
-          FStar_Parser_ParseIt.frag_fname = "<string_of_term>";
-          FStar_Parser_ParseIt.frag_text = s1;
-          FStar_Parser_ParseIt.frag_line = Prims.int_one;
-          FStar_Parser_ParseIt.frag_col = Prims.int_zero
-        } in
-      let uu___ =
-        FStar_Parser_ParseIt.parse
-          (FStar_Parser_ParseIt.Fragment (frag_of_text s)) in
-      match uu___ with
-      | FStar_Parser_ParseIt.Term t ->
-          let dsenv =
-            let uu___1 = FStar_TypeChecker_Env.current_module e in
-            FStar_Syntax_DsEnv.set_current_module
-              e.FStar_TypeChecker_Env.dsenv uu___1 in
-          (try
-             (fun uu___1 ->
-                match () with
-                | () ->
-                    let uu___2 = FStar_ToSyntax_ToSyntax.desugar_term dsenv t in
-                    FStar_Tactics_Monad.ret uu___2) ()
-           with
-           | FStar_Errors.Error (uu___2, e1, uu___3, uu___4) ->
-               FStar_Tactics_Monad.fail (Prims.op_Hat "string_of_term: " e1)
-           | uu___2 ->
-               FStar_Tactics_Monad.fail "string_of_term: Unknown error")
-      | FStar_Parser_ParseIt.ASTFragment uu___1 ->
-          FStar_Tactics_Monad.fail
-            "string_of_term: expected a Term as a result, got an ASTFragment"
-      | FStar_Parser_ParseIt.ParseError (uu___1, err, uu___2) ->
-          FStar_Tactics_Monad.fail
-            (Prims.op_Hat "string_of_term: got error " err)
-let (push_bv_dsenv :
-  env ->
-    Prims.string -> (env * FStar_Syntax_Syntax.bv) FStar_Tactics_Monad.tac)
-  =
-  fun e ->
-    fun i ->
-      let ident = FStar_Ident.mk_ident (i, FStar_Compiler_Range.dummyRange) in
-      let uu___ =
-        FStar_Syntax_DsEnv.push_bv e.FStar_TypeChecker_Env.dsenv ident in
-      match uu___ with
-      | (dsenv, bv) ->
-          FStar_Tactics_Monad.ret
-            ({
-               FStar_TypeChecker_Env.solver =
-                 (e.FStar_TypeChecker_Env.solver);
-               FStar_TypeChecker_Env.range = (e.FStar_TypeChecker_Env.range);
-               FStar_TypeChecker_Env.curmodule =
-                 (e.FStar_TypeChecker_Env.curmodule);
-               FStar_TypeChecker_Env.gamma = (e.FStar_TypeChecker_Env.gamma);
-               FStar_TypeChecker_Env.gamma_sig =
-                 (e.FStar_TypeChecker_Env.gamma_sig);
-               FStar_TypeChecker_Env.gamma_cache =
-                 (e.FStar_TypeChecker_Env.gamma_cache);
-               FStar_TypeChecker_Env.modules =
-                 (e.FStar_TypeChecker_Env.modules);
-               FStar_TypeChecker_Env.expected_typ =
-                 (e.FStar_TypeChecker_Env.expected_typ);
-               FStar_TypeChecker_Env.sigtab =
-                 (e.FStar_TypeChecker_Env.sigtab);
-               FStar_TypeChecker_Env.attrtab =
-                 (e.FStar_TypeChecker_Env.attrtab);
-               FStar_TypeChecker_Env.instantiate_imp =
-                 (e.FStar_TypeChecker_Env.instantiate_imp);
-               FStar_TypeChecker_Env.effects =
-                 (e.FStar_TypeChecker_Env.effects);
-               FStar_TypeChecker_Env.generalize =
-                 (e.FStar_TypeChecker_Env.generalize);
-               FStar_TypeChecker_Env.letrecs =
-                 (e.FStar_TypeChecker_Env.letrecs);
-               FStar_TypeChecker_Env.top_level =
-                 (e.FStar_TypeChecker_Env.top_level);
-               FStar_TypeChecker_Env.check_uvars =
-                 (e.FStar_TypeChecker_Env.check_uvars);
-               FStar_TypeChecker_Env.use_eq_strict =
-                 (e.FStar_TypeChecker_Env.use_eq_strict);
-               FStar_TypeChecker_Env.is_iface =
-                 (e.FStar_TypeChecker_Env.is_iface);
-               FStar_TypeChecker_Env.admit = (e.FStar_TypeChecker_Env.admit);
-               FStar_TypeChecker_Env.lax = (e.FStar_TypeChecker_Env.lax);
-               FStar_TypeChecker_Env.lax_universes =
-                 (e.FStar_TypeChecker_Env.lax_universes);
-               FStar_TypeChecker_Env.phase1 =
-                 (e.FStar_TypeChecker_Env.phase1);
-               FStar_TypeChecker_Env.failhard =
-                 (e.FStar_TypeChecker_Env.failhard);
-               FStar_TypeChecker_Env.nosynth =
-                 (e.FStar_TypeChecker_Env.nosynth);
-               FStar_TypeChecker_Env.uvar_subtyping =
-                 (e.FStar_TypeChecker_Env.uvar_subtyping);
-               FStar_TypeChecker_Env.tc_term =
-                 (e.FStar_TypeChecker_Env.tc_term);
-               FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                 (e.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-               FStar_TypeChecker_Env.universe_of =
-                 (e.FStar_TypeChecker_Env.universe_of);
-               FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                 (e.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-               FStar_TypeChecker_Env.teq_nosmt_force =
-                 (e.FStar_TypeChecker_Env.teq_nosmt_force);
-               FStar_TypeChecker_Env.subtype_nosmt_force =
-                 (e.FStar_TypeChecker_Env.subtype_nosmt_force);
-               FStar_TypeChecker_Env.qtbl_name_and_index =
-                 (e.FStar_TypeChecker_Env.qtbl_name_and_index);
-               FStar_TypeChecker_Env.normalized_eff_names =
-                 (e.FStar_TypeChecker_Env.normalized_eff_names);
-               FStar_TypeChecker_Env.fv_delta_depths =
-                 (e.FStar_TypeChecker_Env.fv_delta_depths);
-               FStar_TypeChecker_Env.proof_ns =
-                 (e.FStar_TypeChecker_Env.proof_ns);
-               FStar_TypeChecker_Env.synth_hook =
-                 (e.FStar_TypeChecker_Env.synth_hook);
-               FStar_TypeChecker_Env.try_solve_implicits_hook =
-                 (e.FStar_TypeChecker_Env.try_solve_implicits_hook);
-               FStar_TypeChecker_Env.splice =
-                 (e.FStar_TypeChecker_Env.splice);
-               FStar_TypeChecker_Env.mpreprocess =
-                 (e.FStar_TypeChecker_Env.mpreprocess);
-               FStar_TypeChecker_Env.postprocess =
-                 (e.FStar_TypeChecker_Env.postprocess);
-               FStar_TypeChecker_Env.identifier_info =
-                 (e.FStar_TypeChecker_Env.identifier_info);
-               FStar_TypeChecker_Env.tc_hooks =
-                 (e.FStar_TypeChecker_Env.tc_hooks);
-               FStar_TypeChecker_Env.dsenv = dsenv;
-               FStar_TypeChecker_Env.nbe = (e.FStar_TypeChecker_Env.nbe);
-               FStar_TypeChecker_Env.strict_args_tab =
-                 (e.FStar_TypeChecker_Env.strict_args_tab);
-               FStar_TypeChecker_Env.erasable_types_tab =
-                 (e.FStar_TypeChecker_Env.erasable_types_tab);
-               FStar_TypeChecker_Env.enable_defer_to_tac =
-                 (e.FStar_TypeChecker_Env.enable_defer_to_tac);
-               FStar_TypeChecker_Env.unif_allow_ref_guards =
-                 (e.FStar_TypeChecker_Env.unif_allow_ref_guards);
-               FStar_TypeChecker_Env.erase_erasable_args =
-                 (e.FStar_TypeChecker_Env.erase_erasable_args);
-               FStar_TypeChecker_Env.core_check =
-                 (e.FStar_TypeChecker_Env.core_check)
-             }, bv)
-let (term_to_string :
-  FStar_Syntax_Syntax.term -> Prims.string FStar_Tactics_Monad.tac) =
-  fun t ->
-    let s = FStar_Syntax_Print.term_to_string t in FStar_Tactics_Monad.ret s
-let (comp_to_string :
-  FStar_Syntax_Syntax.comp -> Prims.string FStar_Tactics_Monad.tac) =
-  fun c ->
-    let s = FStar_Syntax_Print.comp_to_string c in FStar_Tactics_Monad.ret s
-let (term_eq_old :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term -> Prims.bool FStar_Tactics_Monad.tac)
-  =
-  fun t1 ->
-    fun t2 ->
-      FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.idtac
-        (fun uu___ ->
-           let uu___1 = FStar_Syntax_Util.term_eq t1 t2 in
-           FStar_Tactics_Monad.ret uu___1)
-let with_compat_pre_core :
-  'a .
-    FStar_BigInt.t ->
-      'a FStar_Tactics_Monad.tac -> 'a FStar_Tactics_Monad.tac
-  =
-  fun n ->
-    fun f ->
-      FStar_Tactics_Monad.mk_tac
-        (fun ps ->
-           FStar_Options.push ();
-           (let res = FStar_Options.set_options "--compat_pre_core 0" in
-            let r = FStar_Tactics_Monad.run f ps in FStar_Options.pop (); r))
-let (tac_env : FStar_TypeChecker_Env.env -> FStar_TypeChecker_Env.env) =
-  fun env1 ->
-    let uu___ = FStar_TypeChecker_Env.clear_expected_typ env1 in
-    match uu___ with
-    | (env2, uu___1) ->
-        let env3 =
-          {
-            FStar_TypeChecker_Env.solver =
-              (env2.FStar_TypeChecker_Env.solver);
-            FStar_TypeChecker_Env.range = (env2.FStar_TypeChecker_Env.range);
-            FStar_TypeChecker_Env.curmodule =
-              (env2.FStar_TypeChecker_Env.curmodule);
-            FStar_TypeChecker_Env.gamma = (env2.FStar_TypeChecker_Env.gamma);
-            FStar_TypeChecker_Env.gamma_sig =
-              (env2.FStar_TypeChecker_Env.gamma_sig);
-            FStar_TypeChecker_Env.gamma_cache =
-              (env2.FStar_TypeChecker_Env.gamma_cache);
-            FStar_TypeChecker_Env.modules =
-              (env2.FStar_TypeChecker_Env.modules);
-            FStar_TypeChecker_Env.expected_typ =
-              (env2.FStar_TypeChecker_Env.expected_typ);
-            FStar_TypeChecker_Env.sigtab =
-              (env2.FStar_TypeChecker_Env.sigtab);
-            FStar_TypeChecker_Env.attrtab =
-              (env2.FStar_TypeChecker_Env.attrtab);
-            FStar_TypeChecker_Env.instantiate_imp = false;
-            FStar_TypeChecker_Env.effects =
-              (env2.FStar_TypeChecker_Env.effects);
-            FStar_TypeChecker_Env.generalize =
-              (env2.FStar_TypeChecker_Env.generalize);
-            FStar_TypeChecker_Env.letrecs =
-              (env2.FStar_TypeChecker_Env.letrecs);
-            FStar_TypeChecker_Env.top_level =
-              (env2.FStar_TypeChecker_Env.top_level);
-            FStar_TypeChecker_Env.check_uvars =
-              (env2.FStar_TypeChecker_Env.check_uvars);
-            FStar_TypeChecker_Env.use_eq_strict =
-              (env2.FStar_TypeChecker_Env.use_eq_strict);
-            FStar_TypeChecker_Env.is_iface =
-              (env2.FStar_TypeChecker_Env.is_iface);
-            FStar_TypeChecker_Env.admit = (env2.FStar_TypeChecker_Env.admit);
-            FStar_TypeChecker_Env.lax = (env2.FStar_TypeChecker_Env.lax);
-            FStar_TypeChecker_Env.lax_universes =
-              (env2.FStar_TypeChecker_Env.lax_universes);
-            FStar_TypeChecker_Env.phase1 =
-              (env2.FStar_TypeChecker_Env.phase1);
-            FStar_TypeChecker_Env.failhard =
-              (env2.FStar_TypeChecker_Env.failhard);
-            FStar_TypeChecker_Env.nosynth =
-              (env2.FStar_TypeChecker_Env.nosynth);
-            FStar_TypeChecker_Env.uvar_subtyping =
-              (env2.FStar_TypeChecker_Env.uvar_subtyping);
-            FStar_TypeChecker_Env.tc_term =
-              (env2.FStar_TypeChecker_Env.tc_term);
-            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-              (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-            FStar_TypeChecker_Env.universe_of =
-              (env2.FStar_TypeChecker_Env.universe_of);
-            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-              (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-            FStar_TypeChecker_Env.teq_nosmt_force =
-              (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-            FStar_TypeChecker_Env.subtype_nosmt_force =
-              (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-            FStar_TypeChecker_Env.qtbl_name_and_index =
-              (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-            FStar_TypeChecker_Env.normalized_eff_names =
-              (env2.FStar_TypeChecker_Env.normalized_eff_names);
-            FStar_TypeChecker_Env.fv_delta_depths =
-              (env2.FStar_TypeChecker_Env.fv_delta_depths);
-            FStar_TypeChecker_Env.proof_ns =
-              (env2.FStar_TypeChecker_Env.proof_ns);
-            FStar_TypeChecker_Env.synth_hook =
-              (env2.FStar_TypeChecker_Env.synth_hook);
-            FStar_TypeChecker_Env.try_solve_implicits_hook =
-              (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-            FStar_TypeChecker_Env.splice =
-              (env2.FStar_TypeChecker_Env.splice);
-            FStar_TypeChecker_Env.mpreprocess =
-              (env2.FStar_TypeChecker_Env.mpreprocess);
-            FStar_TypeChecker_Env.postprocess =
-              (env2.FStar_TypeChecker_Env.postprocess);
-            FStar_TypeChecker_Env.identifier_info =
-              (env2.FStar_TypeChecker_Env.identifier_info);
-            FStar_TypeChecker_Env.tc_hooks =
-              (env2.FStar_TypeChecker_Env.tc_hooks);
-            FStar_TypeChecker_Env.dsenv = (env2.FStar_TypeChecker_Env.dsenv);
-            FStar_TypeChecker_Env.nbe = (env2.FStar_TypeChecker_Env.nbe);
-            FStar_TypeChecker_Env.strict_args_tab =
-              (env2.FStar_TypeChecker_Env.strict_args_tab);
-            FStar_TypeChecker_Env.erasable_types_tab =
-              (env2.FStar_TypeChecker_Env.erasable_types_tab);
-            FStar_TypeChecker_Env.enable_defer_to_tac =
-              (env2.FStar_TypeChecker_Env.enable_defer_to_tac);
-            FStar_TypeChecker_Env.unif_allow_ref_guards =
-              (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-            FStar_TypeChecker_Env.erase_erasable_args =
-              (env2.FStar_TypeChecker_Env.erase_erasable_args);
-            FStar_TypeChecker_Env.core_check =
-              (env2.FStar_TypeChecker_Env.core_check)
-          } in
-        let env4 =
-          {
-            FStar_TypeChecker_Env.solver =
-              (env3.FStar_TypeChecker_Env.solver);
-            FStar_TypeChecker_Env.range = (env3.FStar_TypeChecker_Env.range);
-            FStar_TypeChecker_Env.curmodule =
-              (env3.FStar_TypeChecker_Env.curmodule);
-            FStar_TypeChecker_Env.gamma = (env3.FStar_TypeChecker_Env.gamma);
-            FStar_TypeChecker_Env.gamma_sig =
-              (env3.FStar_TypeChecker_Env.gamma_sig);
-            FStar_TypeChecker_Env.gamma_cache =
-              (env3.FStar_TypeChecker_Env.gamma_cache);
-            FStar_TypeChecker_Env.modules =
-              (env3.FStar_TypeChecker_Env.modules);
-            FStar_TypeChecker_Env.expected_typ =
-              (env3.FStar_TypeChecker_Env.expected_typ);
-            FStar_TypeChecker_Env.sigtab =
-              (env3.FStar_TypeChecker_Env.sigtab);
-            FStar_TypeChecker_Env.attrtab =
-              (env3.FStar_TypeChecker_Env.attrtab);
-            FStar_TypeChecker_Env.instantiate_imp =
-              (env3.FStar_TypeChecker_Env.instantiate_imp);
-            FStar_TypeChecker_Env.effects =
-              (env3.FStar_TypeChecker_Env.effects);
-            FStar_TypeChecker_Env.generalize =
-              (env3.FStar_TypeChecker_Env.generalize);
-            FStar_TypeChecker_Env.letrecs =
-              (env3.FStar_TypeChecker_Env.letrecs);
-            FStar_TypeChecker_Env.top_level =
-              (env3.FStar_TypeChecker_Env.top_level);
-            FStar_TypeChecker_Env.check_uvars =
-              (env3.FStar_TypeChecker_Env.check_uvars);
-            FStar_TypeChecker_Env.use_eq_strict =
-              (env3.FStar_TypeChecker_Env.use_eq_strict);
-            FStar_TypeChecker_Env.is_iface =
-              (env3.FStar_TypeChecker_Env.is_iface);
-            FStar_TypeChecker_Env.admit = (env3.FStar_TypeChecker_Env.admit);
-            FStar_TypeChecker_Env.lax = (env3.FStar_TypeChecker_Env.lax);
-            FStar_TypeChecker_Env.lax_universes =
-              (env3.FStar_TypeChecker_Env.lax_universes);
-            FStar_TypeChecker_Env.phase1 =
-              (env3.FStar_TypeChecker_Env.phase1);
-            FStar_TypeChecker_Env.failhard = true;
-            FStar_TypeChecker_Env.nosynth =
-              (env3.FStar_TypeChecker_Env.nosynth);
-            FStar_TypeChecker_Env.uvar_subtyping =
-              (env3.FStar_TypeChecker_Env.uvar_subtyping);
-            FStar_TypeChecker_Env.tc_term =
-              (env3.FStar_TypeChecker_Env.tc_term);
-            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-              (env3.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-            FStar_TypeChecker_Env.universe_of =
-              (env3.FStar_TypeChecker_Env.universe_of);
-            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-              (env3.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-            FStar_TypeChecker_Env.teq_nosmt_force =
-              (env3.FStar_TypeChecker_Env.teq_nosmt_force);
-            FStar_TypeChecker_Env.subtype_nosmt_force =
-              (env3.FStar_TypeChecker_Env.subtype_nosmt_force);
-            FStar_TypeChecker_Env.qtbl_name_and_index =
-              (env3.FStar_TypeChecker_Env.qtbl_name_and_index);
-            FStar_TypeChecker_Env.normalized_eff_names =
-              (env3.FStar_TypeChecker_Env.normalized_eff_names);
-            FStar_TypeChecker_Env.fv_delta_depths =
-              (env3.FStar_TypeChecker_Env.fv_delta_depths);
-            FStar_TypeChecker_Env.proof_ns =
-              (env3.FStar_TypeChecker_Env.proof_ns);
-            FStar_TypeChecker_Env.synth_hook =
-              (env3.FStar_TypeChecker_Env.synth_hook);
-            FStar_TypeChecker_Env.try_solve_implicits_hook =
-              (env3.FStar_TypeChecker_Env.try_solve_implicits_hook);
-            FStar_TypeChecker_Env.splice =
-              (env3.FStar_TypeChecker_Env.splice);
-            FStar_TypeChecker_Env.mpreprocess =
-              (env3.FStar_TypeChecker_Env.mpreprocess);
-            FStar_TypeChecker_Env.postprocess =
-              (env3.FStar_TypeChecker_Env.postprocess);
-            FStar_TypeChecker_Env.identifier_info =
-              (env3.FStar_TypeChecker_Env.identifier_info);
-            FStar_TypeChecker_Env.tc_hooks =
-              (env3.FStar_TypeChecker_Env.tc_hooks);
-            FStar_TypeChecker_Env.dsenv = (env3.FStar_TypeChecker_Env.dsenv);
-            FStar_TypeChecker_Env.nbe = (env3.FStar_TypeChecker_Env.nbe);
-            FStar_TypeChecker_Env.strict_args_tab =
-              (env3.FStar_TypeChecker_Env.strict_args_tab);
-            FStar_TypeChecker_Env.erasable_types_tab =
-              (env3.FStar_TypeChecker_Env.erasable_types_tab);
-            FStar_TypeChecker_Env.enable_defer_to_tac =
-              (env3.FStar_TypeChecker_Env.enable_defer_to_tac);
-            FStar_TypeChecker_Env.unif_allow_ref_guards =
-              (env3.FStar_TypeChecker_Env.unif_allow_ref_guards);
-            FStar_TypeChecker_Env.erase_erasable_args =
-              (env3.FStar_TypeChecker_Env.erase_erasable_args);
-            FStar_TypeChecker_Env.core_check =
-              (env3.FStar_TypeChecker_Env.core_check)
-          } in
-        let env5 =
-          {
-            FStar_TypeChecker_Env.solver =
-              (env4.FStar_TypeChecker_Env.solver);
-            FStar_TypeChecker_Env.range = (env4.FStar_TypeChecker_Env.range);
-            FStar_TypeChecker_Env.curmodule =
-              (env4.FStar_TypeChecker_Env.curmodule);
-            FStar_TypeChecker_Env.gamma = (env4.FStar_TypeChecker_Env.gamma);
-            FStar_TypeChecker_Env.gamma_sig =
-              (env4.FStar_TypeChecker_Env.gamma_sig);
-            FStar_TypeChecker_Env.gamma_cache =
-              (env4.FStar_TypeChecker_Env.gamma_cache);
-            FStar_TypeChecker_Env.modules =
-              (env4.FStar_TypeChecker_Env.modules);
-            FStar_TypeChecker_Env.expected_typ =
-              (env4.FStar_TypeChecker_Env.expected_typ);
-            FStar_TypeChecker_Env.sigtab =
-              (env4.FStar_TypeChecker_Env.sigtab);
-            FStar_TypeChecker_Env.attrtab =
-              (env4.FStar_TypeChecker_Env.attrtab);
-            FStar_TypeChecker_Env.instantiate_imp =
-              (env4.FStar_TypeChecker_Env.instantiate_imp);
-            FStar_TypeChecker_Env.effects =
-              (env4.FStar_TypeChecker_Env.effects);
-            FStar_TypeChecker_Env.generalize =
-              (env4.FStar_TypeChecker_Env.generalize);
-            FStar_TypeChecker_Env.letrecs =
-              (env4.FStar_TypeChecker_Env.letrecs);
-            FStar_TypeChecker_Env.top_level =
-              (env4.FStar_TypeChecker_Env.top_level);
-            FStar_TypeChecker_Env.check_uvars =
-              (env4.FStar_TypeChecker_Env.check_uvars);
-            FStar_TypeChecker_Env.use_eq_strict =
-              (env4.FStar_TypeChecker_Env.use_eq_strict);
-            FStar_TypeChecker_Env.is_iface =
-              (env4.FStar_TypeChecker_Env.is_iface);
-            FStar_TypeChecker_Env.admit = (env4.FStar_TypeChecker_Env.admit);
-            FStar_TypeChecker_Env.lax = (env4.FStar_TypeChecker_Env.lax);
-            FStar_TypeChecker_Env.lax_universes =
-              (env4.FStar_TypeChecker_Env.lax_universes);
-            FStar_TypeChecker_Env.phase1 =
-              (env4.FStar_TypeChecker_Env.phase1);
-            FStar_TypeChecker_Env.failhard =
-              (env4.FStar_TypeChecker_Env.failhard);
-            FStar_TypeChecker_Env.nosynth =
-              (env4.FStar_TypeChecker_Env.nosynth);
-            FStar_TypeChecker_Env.uvar_subtyping =
-              (env4.FStar_TypeChecker_Env.uvar_subtyping);
-            FStar_TypeChecker_Env.tc_term =
-              (env4.FStar_TypeChecker_Env.tc_term);
-            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-              (env4.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-            FStar_TypeChecker_Env.universe_of =
-              (env4.FStar_TypeChecker_Env.universe_of);
-            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-              (env4.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-            FStar_TypeChecker_Env.teq_nosmt_force =
-              (env4.FStar_TypeChecker_Env.teq_nosmt_force);
-            FStar_TypeChecker_Env.subtype_nosmt_force =
-              (env4.FStar_TypeChecker_Env.subtype_nosmt_force);
-            FStar_TypeChecker_Env.qtbl_name_and_index =
-              (env4.FStar_TypeChecker_Env.qtbl_name_and_index);
-            FStar_TypeChecker_Env.normalized_eff_names =
-              (env4.FStar_TypeChecker_Env.normalized_eff_names);
-            FStar_TypeChecker_Env.fv_delta_depths =
-              (env4.FStar_TypeChecker_Env.fv_delta_depths);
-            FStar_TypeChecker_Env.proof_ns =
-              (env4.FStar_TypeChecker_Env.proof_ns);
-            FStar_TypeChecker_Env.synth_hook =
-              (env4.FStar_TypeChecker_Env.synth_hook);
-            FStar_TypeChecker_Env.try_solve_implicits_hook =
-              (env4.FStar_TypeChecker_Env.try_solve_implicits_hook);
-            FStar_TypeChecker_Env.splice =
-              (env4.FStar_TypeChecker_Env.splice);
-            FStar_TypeChecker_Env.mpreprocess =
-              (env4.FStar_TypeChecker_Env.mpreprocess);
-            FStar_TypeChecker_Env.postprocess =
-              (env4.FStar_TypeChecker_Env.postprocess);
-            FStar_TypeChecker_Env.identifier_info =
-              (env4.FStar_TypeChecker_Env.identifier_info);
-            FStar_TypeChecker_Env.tc_hooks =
-              (env4.FStar_TypeChecker_Env.tc_hooks);
-            FStar_TypeChecker_Env.dsenv = (env4.FStar_TypeChecker_Env.dsenv);
-            FStar_TypeChecker_Env.nbe = (env4.FStar_TypeChecker_Env.nbe);
-            FStar_TypeChecker_Env.strict_args_tab =
-              (env4.FStar_TypeChecker_Env.strict_args_tab);
-            FStar_TypeChecker_Env.erasable_types_tab =
-              (env4.FStar_TypeChecker_Env.erasable_types_tab);
-            FStar_TypeChecker_Env.enable_defer_to_tac = false;
-            FStar_TypeChecker_Env.unif_allow_ref_guards =
-              (env4.FStar_TypeChecker_Env.unif_allow_ref_guards);
-            FStar_TypeChecker_Env.erase_erasable_args =
-              (env4.FStar_TypeChecker_Env.erase_erasable_args);
-            FStar_TypeChecker_Env.core_check =
-              (env4.FStar_TypeChecker_Env.core_check)
-          } in
-        env5
-let (proofstate_of_goals :
-  FStar_Compiler_Range.range ->
-    env ->
-      FStar_Tactics_Types.goal Prims.list ->
-        FStar_TypeChecker_Common.implicit Prims.list ->
-          FStar_Tactics_Types.proofstate)
-  =
-  fun rng ->
-    fun env1 ->
-      fun goals ->
-        fun imps ->
-          let env2 = tac_env env1 in
-          let ps =
-            let uu___ =
-              FStar_TypeChecker_Env.debug env2
-                (FStar_Options.Other "TacVerbose") in
-            let uu___1 = FStar_Compiler_Util.psmap_empty () in
-            {
-              FStar_Tactics_Types.main_context = env2;
-              FStar_Tactics_Types.all_implicits = imps;
-              FStar_Tactics_Types.goals = goals;
-              FStar_Tactics_Types.smt_goals = [];
-              FStar_Tactics_Types.depth = Prims.int_zero;
-              FStar_Tactics_Types.__dump =
-                FStar_Tactics_Printing.do_dump_proofstate;
-              FStar_Tactics_Types.psc = FStar_TypeChecker_Cfg.null_psc;
-              FStar_Tactics_Types.entry_range = rng;
-              FStar_Tactics_Types.guard_policy = FStar_Tactics_Types.SMT;
-              FStar_Tactics_Types.freshness = Prims.int_zero;
-              FStar_Tactics_Types.tac_verb_dbg = uu___;
-              FStar_Tactics_Types.local_state = uu___1;
-              FStar_Tactics_Types.urgency = Prims.int_one
-            } in
-          ps
-let (proofstate_of_goal_ty :
-  FStar_Compiler_Range.range ->
-    env ->
-      FStar_Reflection_Data.typ ->
-        (FStar_Tactics_Types.proofstate * FStar_Syntax_Syntax.term))
-  =
-  fun rng ->
-    fun env1 ->
-      fun typ ->
-        let env2 = tac_env env1 in
-        let uu___ = FStar_Tactics_Types.goal_of_goal_ty env2 typ in
-        match uu___ with
-        | (g, g_u) ->
-            let ps =
-              proofstate_of_goals rng env2 [g]
-                g_u.FStar_TypeChecker_Common.implicits in
-            let uu___1 = FStar_Tactics_Types.goal_witness g in (ps, uu___1)
-let (proofstate_of_all_implicits :
-  FStar_Compiler_Range.range ->
-    env ->
-      implicits ->
-        (FStar_Tactics_Types.proofstate * FStar_Syntax_Syntax.term))
-  =
-  fun rng ->
-    fun env1 ->
-      fun imps ->
-        let env2 = tac_env env1 in
-        let goals =
-          FStar_Compiler_List.map (FStar_Tactics_Types.goal_of_implicit env2)
-            imps in
-        let w =
-          let uu___ = FStar_Compiler_List.hd goals in
-          FStar_Tactics_Types.goal_witness uu___ in
-        let ps =
-          let uu___ =
-            FStar_TypeChecker_Env.debug env2
-              (FStar_Options.Other "TacVerbose") in
-          let uu___1 = FStar_Compiler_Util.psmap_empty () in
-          {
-            FStar_Tactics_Types.main_context = env2;
-            FStar_Tactics_Types.all_implicits = imps;
-            FStar_Tactics_Types.goals = goals;
-            FStar_Tactics_Types.smt_goals = [];
-            FStar_Tactics_Types.depth = Prims.int_zero;
-            FStar_Tactics_Types.__dump =
-              FStar_Tactics_Printing.do_dump_proofstate;
-            FStar_Tactics_Types.psc = FStar_TypeChecker_Cfg.null_psc;
-            FStar_Tactics_Types.entry_range = rng;
-            FStar_Tactics_Types.guard_policy = FStar_Tactics_Types.SMT;
-            FStar_Tactics_Types.freshness = Prims.int_zero;
-            FStar_Tactics_Types.tac_verb_dbg = uu___;
-            FStar_Tactics_Types.local_state = uu___1;
-            FStar_Tactics_Types.urgency = Prims.int_one
-          } in
-        (ps, w)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Common.ml b/src/ocaml-output/FStar_Tactics_Common.ml
deleted file mode 100644
index 5688492522b..00000000000
--- a/src/ocaml-output/FStar_Tactics_Common.ml
+++ /dev/null
@@ -1,16 +0,0 @@
-open Prims
-exception NotAListLiteral 
-let (uu___is_NotAListLiteral : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NotAListLiteral -> true | uu___ -> false
-exception TacticFailure of Prims.string 
-let (uu___is_TacticFailure : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TacticFailure uu___ -> true | uu___ -> false
-let (__proj__TacticFailure__item__uu___ : Prims.exn -> Prims.string) =
-  fun projectee -> match projectee with | TacticFailure uu___ -> uu___
-exception EExn of FStar_Syntax_Syntax.term 
-let (uu___is_EExn : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | EExn uu___ -> true | uu___ -> false
-let (__proj__EExn__item__uu___ : Prims.exn -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | EExn uu___ -> uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_CtrlRewrite.ml b/src/ocaml-output/FStar_Tactics_CtrlRewrite.ml
deleted file mode 100644
index f731b91f293..00000000000
--- a/src/ocaml-output/FStar_Tactics_CtrlRewrite.ml
+++ /dev/null
@@ -1,843 +0,0 @@
-open Prims
-type controller_ty =
-  FStar_Syntax_Syntax.term ->
-    (Prims.bool * FStar_Tactics_Types.ctrl_flag) FStar_Tactics_Monad.tac
-type rewriter_ty = unit FStar_Tactics_Monad.tac
-let (rangeof : FStar_Tactics_Types.goal -> FStar_Compiler_Range.range) =
-  fun g ->
-    (g.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_range
-let (__do_rewrite :
-  FStar_Tactics_Types.goal ->
-    rewriter_ty ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun g0 ->
-    fun rewriter ->
-      fun env ->
-        fun tm ->
-          let should_skip =
-            let uu___ =
-              let uu___1 = FStar_Syntax_Subst.compress tm in
-              uu___1.FStar_Syntax_Syntax.n in
-            match uu___ with
-            | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify) ->
-                true
-            | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reflect
-                uu___1) -> true
-            | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_range_of) ->
-                true
-            | FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_set_range_of) -> true
-            | uu___1 -> false in
-          if should_skip
-          then FStar_Tactics_Monad.ret tm
-          else
-            (let res =
-               try
-                 (fun uu___1 ->
-                    match () with
-                    | () ->
-                        FStar_Errors.with_ctx
-                          "While typechecking a subterm for ctrl_rewrite"
-                          (fun uu___2 ->
-                             let uu___3 =
-                               env.FStar_TypeChecker_Env.tc_term
-                                 {
-                                   FStar_TypeChecker_Env.solver =
-                                     (env.FStar_TypeChecker_Env.solver);
-                                   FStar_TypeChecker_Env.range =
-                                     (env.FStar_TypeChecker_Env.range);
-                                   FStar_TypeChecker_Env.curmodule =
-                                     (env.FStar_TypeChecker_Env.curmodule);
-                                   FStar_TypeChecker_Env.gamma =
-                                     (env.FStar_TypeChecker_Env.gamma);
-                                   FStar_TypeChecker_Env.gamma_sig =
-                                     (env.FStar_TypeChecker_Env.gamma_sig);
-                                   FStar_TypeChecker_Env.gamma_cache =
-                                     (env.FStar_TypeChecker_Env.gamma_cache);
-                                   FStar_TypeChecker_Env.modules =
-                                     (env.FStar_TypeChecker_Env.modules);
-                                   FStar_TypeChecker_Env.expected_typ =
-                                     (env.FStar_TypeChecker_Env.expected_typ);
-                                   FStar_TypeChecker_Env.sigtab =
-                                     (env.FStar_TypeChecker_Env.sigtab);
-                                   FStar_TypeChecker_Env.attrtab =
-                                     (env.FStar_TypeChecker_Env.attrtab);
-                                   FStar_TypeChecker_Env.instantiate_imp =
-                                     (env.FStar_TypeChecker_Env.instantiate_imp);
-                                   FStar_TypeChecker_Env.effects =
-                                     (env.FStar_TypeChecker_Env.effects);
-                                   FStar_TypeChecker_Env.generalize =
-                                     (env.FStar_TypeChecker_Env.generalize);
-                                   FStar_TypeChecker_Env.letrecs =
-                                     (env.FStar_TypeChecker_Env.letrecs);
-                                   FStar_TypeChecker_Env.top_level =
-                                     (env.FStar_TypeChecker_Env.top_level);
-                                   FStar_TypeChecker_Env.check_uvars =
-                                     (env.FStar_TypeChecker_Env.check_uvars);
-                                   FStar_TypeChecker_Env.use_eq_strict =
-                                     (env.FStar_TypeChecker_Env.use_eq_strict);
-                                   FStar_TypeChecker_Env.is_iface =
-                                     (env.FStar_TypeChecker_Env.is_iface);
-                                   FStar_TypeChecker_Env.admit =
-                                     (env.FStar_TypeChecker_Env.admit);
-                                   FStar_TypeChecker_Env.lax = true;
-                                   FStar_TypeChecker_Env.lax_universes =
-                                     (env.FStar_TypeChecker_Env.lax_universes);
-                                   FStar_TypeChecker_Env.phase1 =
-                                     (env.FStar_TypeChecker_Env.phase1);
-                                   FStar_TypeChecker_Env.failhard =
-                                     (env.FStar_TypeChecker_Env.failhard);
-                                   FStar_TypeChecker_Env.nosynth =
-                                     (env.FStar_TypeChecker_Env.nosynth);
-                                   FStar_TypeChecker_Env.uvar_subtyping =
-                                     (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                   FStar_TypeChecker_Env.tc_term =
-                                     (env.FStar_TypeChecker_Env.tc_term);
-                                   FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                     =
-                                     (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                   FStar_TypeChecker_Env.universe_of =
-                                     (env.FStar_TypeChecker_Env.universe_of);
-                                   FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                     =
-                                     (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                   FStar_TypeChecker_Env.teq_nosmt_force =
-                                     (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                   FStar_TypeChecker_Env.subtype_nosmt_force
-                                     =
-                                     (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                   FStar_TypeChecker_Env.qtbl_name_and_index
-                                     =
-                                     (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                   FStar_TypeChecker_Env.normalized_eff_names
-                                     =
-                                     (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                   FStar_TypeChecker_Env.fv_delta_depths =
-                                     (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                   FStar_TypeChecker_Env.proof_ns =
-                                     (env.FStar_TypeChecker_Env.proof_ns);
-                                   FStar_TypeChecker_Env.synth_hook =
-                                     (env.FStar_TypeChecker_Env.synth_hook);
-                                   FStar_TypeChecker_Env.try_solve_implicits_hook
-                                     =
-                                     (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                   FStar_TypeChecker_Env.splice =
-                                     (env.FStar_TypeChecker_Env.splice);
-                                   FStar_TypeChecker_Env.mpreprocess =
-                                     (env.FStar_TypeChecker_Env.mpreprocess);
-                                   FStar_TypeChecker_Env.postprocess =
-                                     (env.FStar_TypeChecker_Env.postprocess);
-                                   FStar_TypeChecker_Env.identifier_info =
-                                     (env.FStar_TypeChecker_Env.identifier_info);
-                                   FStar_TypeChecker_Env.tc_hooks =
-                                     (env.FStar_TypeChecker_Env.tc_hooks);
-                                   FStar_TypeChecker_Env.dsenv =
-                                     (env.FStar_TypeChecker_Env.dsenv);
-                                   FStar_TypeChecker_Env.nbe =
-                                     (env.FStar_TypeChecker_Env.nbe);
-                                   FStar_TypeChecker_Env.strict_args_tab =
-                                     (env.FStar_TypeChecker_Env.strict_args_tab);
-                                   FStar_TypeChecker_Env.erasable_types_tab =
-                                     (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                   FStar_TypeChecker_Env.enable_defer_to_tac
-                                     =
-                                     (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                   FStar_TypeChecker_Env.unif_allow_ref_guards
-                                     =
-                                     (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                   FStar_TypeChecker_Env.erase_erasable_args
-                                     =
-                                     (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                   FStar_TypeChecker_Env.core_check =
-                                     (env.FStar_TypeChecker_Env.core_check)
-                                 } tm in
-                             FStar_Pervasives_Native.Some uu___3)) ()
-               with
-               | FStar_Errors.Error
-                   (FStar_Errors.Error_LayeredMissingAnnot, uu___2, uu___3,
-                    uu___4)
-                   -> FStar_Pervasives_Native.None
-               | e -> FStar_Compiler_Effect.raise e in
-             match res with
-             | FStar_Pervasives_Native.None -> FStar_Tactics_Monad.ret tm
-             | FStar_Pervasives_Native.Some (uu___1, lcomp, g) ->
-                 let uu___2 =
-                   let uu___3 =
-                     FStar_TypeChecker_Common.is_pure_or_ghost_lcomp lcomp in
-                   Prims.op_Negation uu___3 in
-                 if uu___2
-                 then FStar_Tactics_Monad.ret tm
-                 else
-                   (let g1 =
-                      FStar_TypeChecker_Rel.solve_deferred_constraints env g in
-                    let typ = lcomp.FStar_TypeChecker_Common.res_typ in
-                    let should_check =
-                      let uu___4 =
-                        FStar_TypeChecker_Common.is_total_lcomp lcomp in
-                      if uu___4
-                      then FStar_Pervasives_Native.None
-                      else
-                        FStar_Pervasives_Native.Some
-                          (FStar_Syntax_Syntax.Allow_ghost "do_rewrite.lhs") in
-                    let uu___4 =
-                      let uu___5 = FStar_Tactics_Basic.goal_typedness_deps g0 in
-                      FStar_Tactics_Monad.new_uvar "do_rewrite.rhs" env typ
-                        should_check uu___5 (rangeof g0) in
-                    FStar_Tactics_Monad.op_let_Bang uu___4
-                      (fun uu___5 ->
-                         match uu___5 with
-                         | (ut, uvar_t) ->
-                             let uu___6 =
-                               FStar_Tactics_Monad.if_verbose
-                                 (fun uu___7 ->
-                                    let uu___8 =
-                                      FStar_Syntax_Print.term_to_string tm in
-                                    let uu___9 =
-                                      FStar_Syntax_Print.term_to_string ut in
-                                    FStar_Compiler_Util.print2
-                                      "do_rewrite: making equality\n\t%s ==\n\t%s\n"
-                                      uu___8 uu___9) in
-                             FStar_Tactics_Monad.op_let_Bang uu___6
-                               (fun uu___7 ->
-                                  let uu___8 =
-                                    let uu___9 =
-                                      let uu___10 =
-                                        env.FStar_TypeChecker_Env.universe_of
-                                          env typ in
-                                      FStar_Syntax_Util.mk_eq2 uu___10 typ tm
-                                        ut in
-                                    FStar_Tactics_Monad.add_irrelevant_goal
-                                      g0 "do_rewrite.eq" env uu___9
-                                      FStar_Pervasives_Native.None in
-                                  FStar_Tactics_Monad.op_let_Bang uu___8
-                                    (fun uu___9 ->
-                                       let uu___10 =
-                                         FStar_Tactics_Basic.focus rewriter in
-                                       FStar_Tactics_Monad.op_let_Bang
-                                         uu___10
-                                         (fun uu___11 ->
-                                            let ut1 =
-                                              FStar_TypeChecker_Normalize.reduce_uvar_solutions
-                                                env ut in
-                                            let uu___12 =
-                                              FStar_Tactics_Monad.if_verbose
-                                                (fun uu___13 ->
-                                                   let uu___14 =
-                                                     FStar_Syntax_Print.term_to_string
-                                                       tm in
-                                                   let uu___15 =
-                                                     FStar_Syntax_Print.term_to_string
-                                                       ut1 in
-                                                   FStar_Compiler_Util.print2
-                                                     "rewrite_rec: succeeded rewriting\n\t%s to\n\t%s\n"
-                                                     uu___14 uu___15) in
-                                            FStar_Tactics_Monad.op_let_Bang
-                                              uu___12
-                                              (fun uu___13 ->
-                                                 FStar_Tactics_Monad.ret ut1)))))))
-let (do_rewrite :
-  FStar_Tactics_Types.goal ->
-    rewriter_ty ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun g0 ->
-    fun rewriter ->
-      fun env ->
-        fun tm ->
-          let uu___ =
-            let uu___1 = __do_rewrite g0 rewriter env tm in
-            FStar_Tactics_Monad.catch uu___1 in
-          FStar_Tactics_Monad.op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | FStar_Pervasives.Inl (FStar_Tactics_Common.TacticFailure
-                   "SKIP") -> FStar_Tactics_Monad.ret tm
-               | FStar_Pervasives.Inl e -> FStar_Tactics_Monad.traise e
-               | FStar_Pervasives.Inr tm' -> FStar_Tactics_Monad.ret tm')
-type 'a ctac =
-  'a -> ('a * FStar_Tactics_Types.ctrl_flag) FStar_Tactics_Monad.tac
-let seq_ctac : 'a . 'a ctac -> 'a ctac -> 'a ctac =
-  fun c1 ->
-    fun c2 ->
-      fun x ->
-        let uu___ = c1 x in
-        FStar_Tactics_Monad.op_let_Bang uu___
-          (fun uu___1 ->
-             match uu___1 with
-             | (x', flag) ->
-                 (match flag with
-                  | FStar_Tactics_Types.Abort ->
-                      FStar_Tactics_Monad.ret (x', FStar_Tactics_Types.Abort)
-                  | FStar_Tactics_Types.Skip ->
-                      FStar_Tactics_Monad.ret (x', FStar_Tactics_Types.Skip)
-                  | FStar_Tactics_Types.Continue -> c2 x'))
-let (par_combine :
-  (FStar_Tactics_Types.ctrl_flag * FStar_Tactics_Types.ctrl_flag) ->
-    FStar_Tactics_Types.ctrl_flag)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (FStar_Tactics_Types.Abort, uu___1) -> FStar_Tactics_Types.Abort
-    | (uu___1, FStar_Tactics_Types.Abort) -> FStar_Tactics_Types.Abort
-    | (FStar_Tactics_Types.Skip, uu___1) -> FStar_Tactics_Types.Skip
-    | (uu___1, FStar_Tactics_Types.Skip) -> FStar_Tactics_Types.Skip
-    | (FStar_Tactics_Types.Continue, FStar_Tactics_Types.Continue) ->
-        FStar_Tactics_Types.Continue
-let par_ctac : 'a 'b . 'a ctac -> 'b ctac -> ('a * 'b) ctac =
-  fun cl ->
-    fun cr ->
-      fun uu___ ->
-        match uu___ with
-        | (x, y) ->
-            let uu___1 = cl x in
-            FStar_Tactics_Monad.op_let_Bang uu___1
-              (fun uu___2 ->
-                 match uu___2 with
-                 | (x1, flag) ->
-                     (match flag with
-                      | FStar_Tactics_Types.Abort ->
-                          FStar_Tactics_Monad.ret
-                            ((x1, y), FStar_Tactics_Types.Abort)
-                      | fa ->
-                          let uu___3 = cr y in
-                          FStar_Tactics_Monad.op_let_Bang uu___3
-                            (fun uu___4 ->
-                               match uu___4 with
-                               | (y1, flag1) ->
-                                   (match flag1 with
-                                    | FStar_Tactics_Types.Abort ->
-                                        FStar_Tactics_Monad.ret
-                                          ((x1, y1),
-                                            FStar_Tactics_Types.Abort)
-                                    | fb ->
-                                        FStar_Tactics_Monad.ret
-                                          ((x1, y1), (par_combine (fa, fb)))))))
-let rec map_ctac : 'a . 'a ctac -> 'a Prims.list ctac =
-  fun c ->
-    fun xs ->
-      match xs with
-      | [] -> FStar_Tactics_Monad.ret ([], FStar_Tactics_Types.Continue)
-      | x::xs1 ->
-          let uu___ =
-            let uu___1 = let uu___2 = map_ctac c in par_ctac c uu___2 in
-            uu___1 (x, xs1) in
-          FStar_Tactics_Monad.op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | ((x1, xs2), flag) ->
-                   FStar_Tactics_Monad.ret ((x1 :: xs2), flag))
-let ctac_id :
-  'a . 'a -> ('a * FStar_Tactics_Types.ctrl_flag) FStar_Tactics_Monad.tac =
-  fun x -> FStar_Tactics_Monad.ret (x, FStar_Tactics_Types.Continue)
-let (ctac_args :
-  FStar_Syntax_Syntax.term ctac -> FStar_Syntax_Syntax.args ctac) =
-  fun c -> let uu___ = par_ctac c ctac_id in map_ctac uu___
-let (maybe_rewrite :
-  FStar_Tactics_Types.goal ->
-    controller_ty ->
-      rewriter_ty ->
-        FStar_TypeChecker_Env.env ->
-          FStar_Syntax_Syntax.term ->
-            (FStar_Syntax_Syntax.term * FStar_Tactics_Types.ctrl_flag)
-              FStar_Tactics_Monad.tac)
-  =
-  fun g0 ->
-    fun controller ->
-      fun rewriter ->
-        fun env ->
-          fun tm ->
-            let uu___ = controller tm in
-            FStar_Tactics_Monad.op_let_Bang uu___
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (rw, ctrl_flag) ->
-                     let uu___2 =
-                       if rw
-                       then do_rewrite g0 rewriter env tm
-                       else FStar_Tactics_Monad.ret tm in
-                     FStar_Tactics_Monad.op_let_Bang uu___2
-                       (fun tm' -> FStar_Tactics_Monad.ret (tm', ctrl_flag)))
-let rec (ctrl_fold_env :
-  FStar_Tactics_Types.goal ->
-    FStar_Tactics_Types.direction ->
-      controller_ty ->
-        rewriter_ty ->
-          FStar_TypeChecker_Env.env ->
-            FStar_Syntax_Syntax.term ->
-              (FStar_Syntax_Syntax.term * FStar_Tactics_Types.ctrl_flag)
-                FStar_Tactics_Monad.tac)
-  =
-  fun g0 ->
-    fun d ->
-      fun controller ->
-        fun rewriter ->
-          fun env ->
-            fun tm ->
-              let recurse tm1 =
-                ctrl_fold_env g0 d controller rewriter env tm1 in
-              match d with
-              | FStar_Tactics_Types.TopDown ->
-                  let uu___ =
-                    seq_ctac (maybe_rewrite g0 controller rewriter env)
-                      (on_subterms g0 d controller rewriter env) in
-                  uu___ tm
-              | FStar_Tactics_Types.BottomUp ->
-                  let uu___ =
-                    seq_ctac (on_subterms g0 d controller rewriter env)
-                      (maybe_rewrite g0 controller rewriter env) in
-                  uu___ tm
-and (recurse_option_residual_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.subst_elt Prims.list ->
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-        (FStar_TypeChecker_Env.env ->
-           FStar_Syntax_Syntax.term ->
-             (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-               FStar_Tactics_Types.ctrl_flag) FStar_Tactics_Monad.tac)
-          ->
-          (FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option *
-            FStar_Tactics_Types.ctrl_flag) FStar_Tactics_Monad.tac)
-  =
-  fun env ->
-    fun retyping_subst ->
-      fun rc_opt ->
-        fun recurse ->
-          match rc_opt with
-          | FStar_Pervasives_Native.None ->
-              FStar_Tactics_Monad.ret
-                (FStar_Pervasives_Native.None, FStar_Tactics_Types.Continue)
-          | FStar_Pervasives_Native.Some rc ->
-              (match rc.FStar_Syntax_Syntax.residual_typ with
-               | FStar_Pervasives_Native.None ->
-                   FStar_Tactics_Monad.ret
-                     ((FStar_Pervasives_Native.Some rc),
-                       FStar_Tactics_Types.Continue)
-               | FStar_Pervasives_Native.Some t ->
-                   let t1 = FStar_Syntax_Subst.subst retyping_subst t in
-                   let uu___ = recurse env t1 in
-                   FStar_Tactics_Monad.op_let_Bang uu___
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | (t2, flag) ->
-                            FStar_Tactics_Monad.ret
-                              ((FStar_Pervasives_Native.Some
-                                  {
-                                    FStar_Syntax_Syntax.residual_effect =
-                                      (rc.FStar_Syntax_Syntax.residual_effect);
-                                    FStar_Syntax_Syntax.residual_typ =
-                                      (FStar_Pervasives_Native.Some t2);
-                                    FStar_Syntax_Syntax.residual_flags =
-                                      (rc.FStar_Syntax_Syntax.residual_flags)
-                                  }), flag)))
-and (on_subterms :
-  FStar_Tactics_Types.goal ->
-    FStar_Tactics_Types.direction ->
-      controller_ty ->
-        rewriter_ty ->
-          FStar_TypeChecker_Env.env ->
-            FStar_Syntax_Syntax.term ->
-              (FStar_Syntax_Syntax.term * FStar_Tactics_Types.ctrl_flag)
-                FStar_Tactics_Monad.tac)
-  =
-  fun g0 ->
-    fun d ->
-      fun controller ->
-        fun rewriter ->
-          fun env ->
-            fun tm ->
-              let recurse env1 tm1 =
-                ctrl_fold_env g0 d controller rewriter env1 tm1 in
-              let rr = recurse env in
-              let rec descend_binders orig accum_binders retyping_subst
-                accum_flag env1 bs t k rebuild =
-                match bs with
-                | [] ->
-                    let t1 = FStar_Syntax_Subst.subst retyping_subst t in
-                    let uu___ = recurse env1 t1 in
-                    FStar_Tactics_Monad.op_let_Bang uu___
-                      (fun uu___1 ->
-                         match uu___1 with
-                         | (t2, t_flag) ->
-                             (match t_flag with
-                              | FStar_Tactics_Types.Abort ->
-                                  FStar_Tactics_Monad.ret
-                                    ((orig.FStar_Syntax_Syntax.n), t_flag)
-                              | uu___2 ->
-                                  let uu___3 =
-                                    recurse_option_residual_comp env1
-                                      retyping_subst k recurse in
-                                  FStar_Tactics_Monad.op_let_Bang uu___3
-                                    (fun uu___4 ->
-                                       match uu___4 with
-                                       | (k1, k_flag) ->
-                                           let bs1 =
-                                             FStar_Compiler_List.rev
-                                               accum_binders in
-                                           let subst =
-                                             FStar_Syntax_Subst.closing_of_binders
-                                               bs1 in
-                                           let bs2 =
-                                             FStar_Syntax_Subst.subst_binders
-                                               subst bs1 in
-                                           let t3 =
-                                             FStar_Syntax_Subst.subst subst
-                                               t2 in
-                                           let k2 =
-                                             FStar_Compiler_Util.map_option
-                                               (FStar_Syntax_Subst.subst_residual_comp
-                                                  subst) k1 in
-                                           let uu___5 =
-                                             let uu___6 = rebuild bs2 t3 k2 in
-                                             (uu___6,
-                                               (par_combine
-                                                  (accum_flag,
-                                                    (par_combine
-                                                       (t_flag, k_flag))))) in
-                                           FStar_Tactics_Monad.ret uu___5)))
-                | b::bs1 ->
-                    let s =
-                      FStar_Syntax_Subst.subst retyping_subst
-                        (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                    let uu___ = recurse env1 s in
-                    FStar_Tactics_Monad.op_let_Bang uu___
-                      (fun uu___1 ->
-                         match uu___1 with
-                         | (s1, flag) ->
-                             (match flag with
-                              | FStar_Tactics_Types.Abort ->
-                                  FStar_Tactics_Monad.ret
-                                    ((orig.FStar_Syntax_Syntax.n), flag)
-                              | uu___2 ->
-                                  let bv =
-                                    let uu___3 =
-                                      b.FStar_Syntax_Syntax.binder_bv in
-                                    {
-                                      FStar_Syntax_Syntax.ppname =
-                                        (uu___3.FStar_Syntax_Syntax.ppname);
-                                      FStar_Syntax_Syntax.index =
-                                        (uu___3.FStar_Syntax_Syntax.index);
-                                      FStar_Syntax_Syntax.sort = s1
-                                    } in
-                                  let b1 =
-                                    {
-                                      FStar_Syntax_Syntax.binder_bv = bv;
-                                      FStar_Syntax_Syntax.binder_qual =
-                                        (b.FStar_Syntax_Syntax.binder_qual);
-                                      FStar_Syntax_Syntax.binder_attrs =
-                                        (b.FStar_Syntax_Syntax.binder_attrs)
-                                    } in
-                                  let env2 =
-                                    FStar_TypeChecker_Env.push_binders env1
-                                      [b1] in
-                                  let retyping_subst1 =
-                                    let uu___3 =
-                                      let uu___4 =
-                                        let uu___5 =
-                                          FStar_Syntax_Syntax.bv_to_name bv in
-                                        (bv, uu___5) in
-                                      FStar_Syntax_Syntax.NT uu___4 in
-                                    uu___3 :: retyping_subst in
-                                  descend_binders orig (b1 :: accum_binders)
-                                    retyping_subst1
-                                    (par_combine (accum_flag, flag)) env2 bs1
-                                    t k rebuild)) in
-              let go uu___ =
-                let tm1 = FStar_Syntax_Subst.compress tm in
-                match tm1.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = ctac_args rr in par_ctac rr uu___3 in
-                      uu___2 (hd, args) in
-                    FStar_Tactics_Monad.op_let_Bang uu___1
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | ((hd1, args1), flag) ->
-                             FStar_Tactics_Monad.ret
-                               ((FStar_Syntax_Syntax.Tm_app (hd1, args1)),
-                                 flag))
-                | FStar_Syntax_Syntax.Tm_abs (bs, t, k) ->
-                    let uu___1 = FStar_Syntax_Subst.open_term' bs t in
-                    (match uu___1 with
-                     | (bs_orig, t1, subst) ->
-                         let k1 =
-                           FStar_Compiler_Effect.op_Bar_Greater k
-                             (FStar_Compiler_Util.map_option
-                                (FStar_Syntax_Subst.subst_residual_comp subst)) in
-                         descend_binders tm1 [] []
-                           FStar_Tactics_Types.Continue env bs_orig t1 k1
-                           (fun bs1 ->
-                              fun t2 ->
-                                fun k2 ->
-                                  FStar_Syntax_Syntax.Tm_abs (bs1, t2, k2)))
-                | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Syntax.mk_binder x in
-                        [uu___3] in
-                      FStar_Syntax_Subst.open_term uu___2 phi in
-                    (match uu___1 with
-                     | (bs, phi1) ->
-                         descend_binders tm1 [] []
-                           FStar_Tactics_Types.Continue env bs phi1
-                           FStar_Pervasives_Native.None
-                           (fun bs1 ->
-                              fun phi2 ->
-                                fun uu___2 ->
-                                  let x1 =
-                                    match bs1 with
-                                    | x2::[] ->
-                                        x2.FStar_Syntax_Syntax.binder_bv
-                                    | uu___3 -> failwith "Impossible" in
-                                  FStar_Syntax_Syntax.Tm_refine (x1, phi2)))
-                | FStar_Syntax_Syntax.Tm_arrow (bs, k) ->
-                    FStar_Tactics_Monad.ret
-                      ((tm1.FStar_Syntax_Syntax.n),
-                        FStar_Tactics_Types.Continue)
-                | FStar_Syntax_Syntax.Tm_match (hd, asc_opt, brs, lopt) ->
-                    let c_branch br =
-                      let uu___1 = FStar_Syntax_Subst.open_branch br in
-                      match uu___1 with
-                      | (pat, w, e) ->
-                          let bvs = FStar_Syntax_Syntax.pat_bvs pat in
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_TypeChecker_Env.push_bvs env bvs in
-                            recurse uu___3 e in
-                          FStar_Tactics_Monad.op_let_Bang uu___2
-                            (fun uu___3 ->
-                               match uu___3 with
-                               | (e1, flag) ->
-                                   let br1 =
-                                     FStar_Syntax_Subst.close_branch
-                                       (pat, w, e1) in
-                                   FStar_Tactics_Monad.ret (br1, flag)) in
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = map_ctac c_branch in par_ctac rr uu___3 in
-                      uu___2 (hd, brs) in
-                    FStar_Tactics_Monad.op_let_Bang uu___1
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | ((hd1, brs1), flag) ->
-                             FStar_Tactics_Monad.ret
-                               ((FStar_Syntax_Syntax.Tm_match
-                                   (hd1, asc_opt, brs1, lopt)), flag))
-                | FStar_Syntax_Syntax.Tm_let
-                    ((false,
-                      { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inl bv;
-                        FStar_Syntax_Syntax.lbunivs = uu___1;
-                        FStar_Syntax_Syntax.lbtyp = uu___2;
-                        FStar_Syntax_Syntax.lbeff = uu___3;
-                        FStar_Syntax_Syntax.lbdef = def;
-                        FStar_Syntax_Syntax.lbattrs = uu___4;
-                        FStar_Syntax_Syntax.lbpos = uu___5;_}::[]),
-                     e)
-                    ->
-                    let lb =
-                      let uu___6 =
-                        let uu___7 = FStar_Syntax_Subst.compress tm1 in
-                        uu___7.FStar_Syntax_Syntax.n in
-                      match uu___6 with
-                      | FStar_Syntax_Syntax.Tm_let ((false, lb1::[]), uu___7)
-                          -> lb1
-                      | uu___7 -> failwith "impossible" in
-                    let uu___6 = FStar_Syntax_Subst.open_term_bv bv e in
-                    (match uu___6 with
-                     | (bv1, e1) ->
-                         let uu___7 =
-                           let uu___8 =
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_TypeChecker_Env.push_bv env bv1 in
-                               recurse uu___10 in
-                             par_ctac rr uu___9 in
-                           uu___8 ((lb.FStar_Syntax_Syntax.lbdef), e1) in
-                         FStar_Tactics_Monad.op_let_Bang uu___7
-                           (fun uu___8 ->
-                              match uu___8 with
-                              | ((lbdef, e2), flag) ->
-                                  let lb1 =
-                                    {
-                                      FStar_Syntax_Syntax.lbname =
-                                        (lb.FStar_Syntax_Syntax.lbname);
-                                      FStar_Syntax_Syntax.lbunivs =
-                                        (lb.FStar_Syntax_Syntax.lbunivs);
-                                      FStar_Syntax_Syntax.lbtyp =
-                                        (lb.FStar_Syntax_Syntax.lbtyp);
-                                      FStar_Syntax_Syntax.lbeff =
-                                        (lb.FStar_Syntax_Syntax.lbeff);
-                                      FStar_Syntax_Syntax.lbdef = lbdef;
-                                      FStar_Syntax_Syntax.lbattrs =
-                                        (lb.FStar_Syntax_Syntax.lbattrs);
-                                      FStar_Syntax_Syntax.lbpos =
-                                        (lb.FStar_Syntax_Syntax.lbpos)
-                                    } in
-                                  let e3 =
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_Syntax_Syntax.mk_binder bv1 in
-                                      [uu___10] in
-                                    FStar_Syntax_Subst.close uu___9 e2 in
-                                  FStar_Tactics_Monad.ret
-                                    ((FStar_Syntax_Syntax.Tm_let
-                                        ((false, [lb1]), e3)), flag)))
-                | FStar_Syntax_Syntax.Tm_let ((true, lbs), e) ->
-                    let c_lb lb =
-                      let uu___1 = rr lb.FStar_Syntax_Syntax.lbdef in
-                      FStar_Tactics_Monad.op_let_Bang uu___1
-                        (fun uu___2 ->
-                           match uu___2 with
-                           | (def, flag) ->
-                               FStar_Tactics_Monad.ret
-                                 ({
-                                    FStar_Syntax_Syntax.lbname =
-                                      (lb.FStar_Syntax_Syntax.lbname);
-                                    FStar_Syntax_Syntax.lbunivs =
-                                      (lb.FStar_Syntax_Syntax.lbunivs);
-                                    FStar_Syntax_Syntax.lbtyp =
-                                      (lb.FStar_Syntax_Syntax.lbtyp);
-                                    FStar_Syntax_Syntax.lbeff =
-                                      (lb.FStar_Syntax_Syntax.lbeff);
-                                    FStar_Syntax_Syntax.lbdef = def;
-                                    FStar_Syntax_Syntax.lbattrs =
-                                      (lb.FStar_Syntax_Syntax.lbattrs);
-                                    FStar_Syntax_Syntax.lbpos =
-                                      (lb.FStar_Syntax_Syntax.lbpos)
-                                  }, flag)) in
-                    let uu___1 = FStar_Syntax_Subst.open_let_rec lbs e in
-                    (match uu___1 with
-                     | (lbs1, e1) ->
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = map_ctac c_lb in par_ctac uu___4 rr in
-                           uu___3 (lbs1, e1) in
-                         FStar_Tactics_Monad.op_let_Bang uu___2
-                           (fun uu___3 ->
-                              match uu___3 with
-                              | ((lbs2, e2), flag) ->
-                                  let uu___4 =
-                                    FStar_Syntax_Subst.close_let_rec lbs2 e2 in
-                                  (match uu___4 with
-                                   | (lbs3, e3) ->
-                                       FStar_Tactics_Monad.ret
-                                         ((FStar_Syntax_Syntax.Tm_let
-                                             ((true, lbs3), e3)), flag))))
-                | FStar_Syntax_Syntax.Tm_ascribed (t, asc, eff) ->
-                    let uu___1 = rr t in
-                    FStar_Tactics_Monad.op_let_Bang uu___1
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | (t1, flag) ->
-                             FStar_Tactics_Monad.ret
-                               ((FStar_Syntax_Syntax.Tm_ascribed
-                                   (t1, asc, eff)), flag))
-                | FStar_Syntax_Syntax.Tm_meta (t, m) ->
-                    let uu___1 = rr t in
-                    FStar_Tactics_Monad.op_let_Bang uu___1
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | (t1, flag) ->
-                             FStar_Tactics_Monad.ret
-                               ((FStar_Syntax_Syntax.Tm_meta (t1, m)), flag))
-                | uu___1 ->
-                    FStar_Tactics_Monad.ret
-                      ((tm1.FStar_Syntax_Syntax.n),
-                        FStar_Tactics_Types.Continue) in
-              let uu___ = go () in
-              FStar_Tactics_Monad.op_let_Bang uu___
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (tmn', flag) ->
-                       FStar_Tactics_Monad.ret
-                         ({
-                            FStar_Syntax_Syntax.n = tmn';
-                            FStar_Syntax_Syntax.pos =
-                              (tm.FStar_Syntax_Syntax.pos);
-                            FStar_Syntax_Syntax.vars =
-                              (tm.FStar_Syntax_Syntax.vars);
-                            FStar_Syntax_Syntax.hash_code =
-                              (tm.FStar_Syntax_Syntax.hash_code)
-                          }, flag))
-let (do_ctrl_rewrite :
-  FStar_Tactics_Types.goal ->
-    FStar_Tactics_Types.direction ->
-      controller_ty ->
-        rewriter_ty ->
-          FStar_TypeChecker_Env.env ->
-            FStar_Syntax_Syntax.term ->
-              FStar_Syntax_Syntax.term FStar_Tactics_Monad.tac)
-  =
-  fun g0 ->
-    fun dir ->
-      fun controller ->
-        fun rewriter ->
-          fun env ->
-            fun tm ->
-              let uu___ = ctrl_fold_env g0 dir controller rewriter env tm in
-              FStar_Tactics_Monad.op_let_Bang uu___
-                (fun uu___1 ->
-                   match uu___1 with
-                   | (tm', uu___2) -> FStar_Tactics_Monad.ret tm')
-let (ctrl_rewrite :
-  FStar_Tactics_Types.direction ->
-    controller_ty -> rewriter_ty -> unit FStar_Tactics_Monad.tac)
-  =
-  fun dir ->
-    fun controller ->
-      fun rewriter ->
-        let uu___ =
-          FStar_Tactics_Monad.op_let_Bang FStar_Tactics_Monad.get
-            (fun ps ->
-               let uu___1 =
-                 match ps.FStar_Tactics_Types.goals with
-                 | g::gs -> (g, gs)
-                 | [] -> failwith "no goals" in
-               match uu___1 with
-               | (g, gs) ->
-                   FStar_Tactics_Monad.op_let_Bang
-                     FStar_Tactics_Monad.dismiss_all
-                     (fun uu___2 ->
-                        let gt = FStar_Tactics_Types.goal_type g in
-                        let uu___3 =
-                          FStar_Tactics_Monad.if_verbose
-                            (fun uu___4 ->
-                               let uu___5 =
-                                 FStar_Syntax_Print.term_to_string gt in
-                               FStar_Compiler_Util.print1
-                                 "ctrl_rewrite starting with %s\n" uu___5) in
-                        FStar_Tactics_Monad.op_let_Bang uu___3
-                          (fun uu___4 ->
-                             let uu___5 =
-                               let uu___6 = FStar_Tactics_Types.goal_env g in
-                               do_ctrl_rewrite g dir controller rewriter
-                                 uu___6 gt in
-                             FStar_Tactics_Monad.op_let_Bang uu___5
-                               (fun gt' ->
-                                  let uu___6 =
-                                    FStar_Tactics_Monad.if_verbose
-                                      (fun uu___7 ->
-                                         let uu___8 =
-                                           FStar_Syntax_Print.term_to_string
-                                             gt' in
-                                         FStar_Compiler_Util.print1
-                                           "ctrl_rewrite seems to have succeded with %s\n"
-                                           uu___8) in
-                                  FStar_Tactics_Monad.op_let_Bang uu___6
-                                    (fun uu___7 ->
-                                       let uu___8 =
-                                         FStar_Tactics_Monad.push_goals gs in
-                                       FStar_Tactics_Monad.op_let_Bang uu___8
-                                         (fun uu___9 ->
-                                            let g1 =
-                                              FStar_Tactics_Basic.goal_with_type
-                                                g gt' in
-                                            FStar_Tactics_Monad.add_goals
-                                              [g1])))))) in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Tactics_Monad.wrap_err "ctrl_rewrite") uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Embedding.ml b/src/ocaml-output/FStar_Tactics_Embedding.ml
deleted file mode 100644
index 78cb067b961..00000000000
--- a/src/ocaml-output/FStar_Tactics_Embedding.ml
+++ /dev/null
@@ -1,826 +0,0 @@
-open Prims
-type name = FStar_Syntax_Syntax.bv
-let (fstar_tactics_lid' : Prims.string Prims.list -> FStar_Ident.lid) =
-  fun s -> FStar_Parser_Const.fstar_tactics_lid' s
-let (lid_as_tm : FStar_Ident.lident -> FStar_Syntax_Syntax.term) =
-  fun l ->
-    let uu___ =
-      FStar_Syntax_Syntax.lid_as_fv l FStar_Syntax_Syntax.delta_constant
-        FStar_Pervasives_Native.None in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Syntax_Syntax.fv_to_tm
-let (mk_tactic_lid_as_term : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s -> let uu___ = fstar_tactics_lid' ["Effect"; s] in lid_as_tm uu___
-type tac_constant =
-  {
-  lid: FStar_Ident.lid ;
-  fv: FStar_Syntax_Syntax.fv ;
-  t: FStar_Syntax_Syntax.term }
-let (__proj__Mktac_constant__item__lid : tac_constant -> FStar_Ident.lid) =
-  fun projectee -> match projectee with | { lid; fv; t;_} -> lid
-let (__proj__Mktac_constant__item__fv :
-  tac_constant -> FStar_Syntax_Syntax.fv) =
-  fun projectee -> match projectee with | { lid; fv; t;_} -> fv
-let (__proj__Mktac_constant__item__t :
-  tac_constant -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | { lid; fv; t;_} -> t
-let (lid_as_data_fv : FStar_Ident.lident -> FStar_Syntax_Syntax.fv) =
-  fun l ->
-    FStar_Syntax_Syntax.lid_as_fv l FStar_Syntax_Syntax.delta_constant
-      (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
-let (lid_as_data_tm : FStar_Ident.lident -> FStar_Syntax_Syntax.term) =
-  fun l -> let uu___ = lid_as_data_fv l in FStar_Syntax_Syntax.fv_to_tm uu___
-let (fstar_tactics_data : Prims.string Prims.list -> tac_constant) =
-  fun ns ->
-    let lid = fstar_tactics_lid' ns in
-    let uu___ = lid_as_data_fv lid in
-    let uu___1 = lid_as_data_tm lid in { lid; fv = uu___; t = uu___1 }
-let (fstar_tactics_const : Prims.string Prims.list -> tac_constant) =
-  fun ns ->
-    let lid = fstar_tactics_lid' ns in
-    let uu___ = FStar_Syntax_Syntax.fvconst lid in
-    let uu___1 = FStar_Syntax_Syntax.tconst lid in
-    { lid; fv = uu___; t = uu___1 }
-let (fstar_tactics_proofstate : tac_constant) =
-  fstar_tactics_const ["Types"; "proofstate"]
-let (fstar_tactics_goal : tac_constant) =
-  fstar_tactics_const ["Types"; "goal"]
-let (fstar_tactics_TacticFailure : tac_constant) =
-  fstar_tactics_data ["Common"; "TacticFailure"]
-let (fstar_tactics_result : tac_constant) =
-  fstar_tactics_const ["Types"; "result"]
-let (fstar_tactics_Success : tac_constant) =
-  fstar_tactics_data ["Result"; "Success"]
-let (fstar_tactics_Failed : tac_constant) =
-  fstar_tactics_data ["Result"; "Failed"]
-let (fstar_tactics_direction : tac_constant) =
-  fstar_tactics_const ["Types"; "direction"]
-let (fstar_tactics_topdown : tac_constant) =
-  fstar_tactics_data ["Types"; "TopDown"]
-let (fstar_tactics_bottomup : tac_constant) =
-  fstar_tactics_data ["Types"; "BottomUp"]
-let (fstar_tactics_ctrl_flag : tac_constant) =
-  fstar_tactics_const ["Types"; "ctrl_flag"]
-let (fstar_tactics_Continue : tac_constant) =
-  fstar_tactics_data ["Types"; "Continue"]
-let (fstar_tactics_Skip : tac_constant) =
-  fstar_tactics_data ["Types"; "Skip"]
-let (fstar_tactics_Abort : tac_constant) =
-  fstar_tactics_data ["Types"; "Abort"]
-let (fstar_tactics_guard_policy : tac_constant) =
-  fstar_tactics_const ["Types"; "guard_policy"]
-let (fstar_tactics_SMT : tac_constant) = fstar_tactics_data ["Types"; "SMT"]
-let (fstar_tactics_Goal : tac_constant) =
-  fstar_tactics_data ["Types"; "Goal"]
-let (fstar_tactics_Drop : tac_constant) =
-  fstar_tactics_data ["Types"; "Drop"]
-let (fstar_tactics_Force : tac_constant) =
-  fstar_tactics_data ["Types"; "Force"]
-let mk_emb :
-  'a .
-    (FStar_Compiler_Range.range -> 'a -> FStar_Syntax_Syntax.term) ->
-      (Prims.bool ->
-         FStar_Syntax_Syntax.term -> 'a FStar_Pervasives_Native.option)
-        -> FStar_Syntax_Syntax.term -> 'a FStar_Syntax_Embeddings.embedding
-  =
-  fun em ->
-    fun un ->
-      fun t ->
-        let uu___ = FStar_Syntax_Embeddings.term_as_fv t in
-        FStar_Syntax_Embeddings.mk_emb
-          (fun x -> fun r -> fun _topt -> fun _norm -> em r x)
-          (fun x -> fun w -> fun _norm -> un w x) uu___
-let embed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Compiler_Range.range -> 'uuuuu -> FStar_Syntax_Syntax.term
-  =
-  fun e ->
-    fun r ->
-      fun x ->
-        let uu___ = FStar_Syntax_Embeddings.embed e x in
-        uu___ r FStar_Pervasives_Native.None
-          FStar_Syntax_Embeddings.id_norm_cb
-let unembed' :
-  'uuuuu .
-    Prims.bool ->
-      'uuuuu FStar_Syntax_Embeddings.embedding ->
-        FStar_Syntax_Syntax.term -> 'uuuuu FStar_Pervasives_Native.option
-  =
-  fun w ->
-    fun e ->
-      fun x ->
-        let uu___ = FStar_Syntax_Embeddings.unembed e x in
-        uu___ w FStar_Syntax_Embeddings.id_norm_cb
-let (t_result_of :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t ->
-    let uu___ = let uu___1 = FStar_Syntax_Syntax.as_arg t in [uu___1] in
-    FStar_Syntax_Util.mk_app fstar_tactics_result.t uu___
-let (hd'_and_args :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.term' * (FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax * FStar_Syntax_Syntax.arg_qualifier
-      FStar_Pervasives_Native.option) Prims.list))
-  =
-  fun tm ->
-    let tm1 = FStar_Syntax_Util.unascribe tm in
-    let uu___ = FStar_Syntax_Util.head_and_args tm1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Util.un_uinst hd in
-          uu___2.FStar_Syntax_Syntax.n in
-        (uu___1, args)
-let (e_proofstate :
-  FStar_Tactics_Types.proofstate FStar_Syntax_Embeddings.embedding) =
-  let embed_proofstate rng ps =
-    FStar_Syntax_Util.mk_lazy ps fstar_tactics_proofstate.t
-      FStar_Syntax_Syntax.Lazy_proofstate (FStar_Pervasives_Native.Some rng) in
-  let unembed_proofstate w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_proofstate;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___4 -> FStar_Pervasives_Native.Some uu___4) uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1
-                  "Not an embedded proofstate: %s\n" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_proofstate unembed_proofstate fstar_tactics_proofstate.t
-let (unfold_lazy_proofstate :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i -> FStar_Syntax_Util.exp_string "(((proofstate)))"
-let (mkFV :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.universe Prims.list ->
-      (FStar_TypeChecker_NBETerm.t * FStar_Syntax_Syntax.aqual) Prims.list ->
-        FStar_TypeChecker_NBETerm.t)
-  =
-  fun fv ->
-    fun us ->
-      fun ts ->
-        FStar_TypeChecker_NBETerm.mkFV fv (FStar_Compiler_List.rev us)
-          (FStar_Compiler_List.rev ts)
-let (mkConstruct :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.universe Prims.list ->
-      (FStar_TypeChecker_NBETerm.t * FStar_Syntax_Syntax.aqual) Prims.list ->
-        FStar_TypeChecker_NBETerm.t)
-  =
-  fun fv ->
-    fun us ->
-      fun ts ->
-        FStar_TypeChecker_NBETerm.mkConstruct fv (FStar_Compiler_List.rev us)
-          (FStar_Compiler_List.rev ts)
-let (fv_as_emb_typ : FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.emb_typ) =
-  fun fv ->
-    let uu___ =
-      let uu___1 =
-        FStar_Ident.string_of_lid
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      (uu___1, []) in
-    FStar_Syntax_Syntax.ET_app uu___
-let (e_proofstate_nbe :
-  FStar_Tactics_Types.proofstate FStar_TypeChecker_NBETerm.embedding) =
-  let embed_proofstate _cb ps =
-    let li =
-      let uu___ = FStar_Compiler_Dyn.mkdyn ps in
-      {
-        FStar_Syntax_Syntax.blob = uu___;
-        FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_proofstate;
-        FStar_Syntax_Syntax.ltyp = (fstar_tactics_proofstate.t);
-        FStar_Syntax_Syntax.rng = FStar_Compiler_Range.dummyRange
-      } in
-    let thunk =
-      FStar_Thunk.mk
-        (fun uu___ ->
-           FStar_Compiler_Effect.op_Less_Bar FStar_TypeChecker_NBETerm.mk_t
-             (FStar_TypeChecker_NBETerm.Constant
-                (FStar_TypeChecker_NBETerm.String
-                   ("(((proofstate.nbe)))", FStar_Compiler_Range.dummyRange)))) in
-    FStar_TypeChecker_NBETerm.mk_t
-      (FStar_TypeChecker_NBETerm.Lazy ((FStar_Pervasives.Inl li), thunk)) in
-  let unembed_proofstate _cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-    match uu___ with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_proofstate;
-           FStar_Syntax_Syntax.ltyp = uu___1;
-           FStar_Syntax_Syntax.rng = uu___2;_},
-         uu___3)
-        ->
-        let uu___4 = FStar_Compiler_Dyn.undyn b in
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___5 -> FStar_Pervasives_Native.Some uu___5) uu___4
-    | uu___1 ->
-        ((let uu___3 =
-            FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-          if uu___3
-          then
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.t_to_string t in
-                FStar_Compiler_Util.format1
-                  "Not an embedded NBE proofstate: %s\n" uu___6 in
-              (FStar_Errors.Warning_NotEmbedded, uu___5) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___4
-          else ());
-         FStar_Pervasives_Native.None) in
-  let uu___ = mkFV fstar_tactics_proofstate.fv [] [] in
-  let uu___1 = fv_as_emb_typ fstar_tactics_proofstate.fv in
-  {
-    FStar_TypeChecker_NBETerm.em = embed_proofstate;
-    FStar_TypeChecker_NBETerm.un = unembed_proofstate;
-    FStar_TypeChecker_NBETerm.typ = uu___;
-    FStar_TypeChecker_NBETerm.emb_typ = uu___1
-  }
-let (e_goal : FStar_Tactics_Types.goal FStar_Syntax_Embeddings.embedding) =
-  let embed_goal rng g =
-    FStar_Syntax_Util.mk_lazy g fstar_tactics_goal.t
-      FStar_Syntax_Syntax.Lazy_goal (FStar_Pervasives_Native.Some rng) in
-  let unembed_goal w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_lazy
-        { FStar_Syntax_Syntax.blob = b;
-          FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_goal;
-          FStar_Syntax_Syntax.ltyp = uu___1;
-          FStar_Syntax_Syntax.rng = uu___2;_}
-        ->
-        let uu___3 = FStar_Compiler_Dyn.undyn b in
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___4 -> FStar_Pervasives_Native.Some uu___4) uu___3
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded goal: %s" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_goal unembed_goal fstar_tactics_goal.t
-let (unfold_lazy_goal :
-  FStar_Syntax_Syntax.lazyinfo -> FStar_Syntax_Syntax.term) =
-  fun i -> FStar_Syntax_Util.exp_string "(((goal)))"
-let (e_goal_nbe :
-  FStar_Tactics_Types.goal FStar_TypeChecker_NBETerm.embedding) =
-  let embed_goal _cb ps =
-    let li =
-      let uu___ = FStar_Compiler_Dyn.mkdyn ps in
-      {
-        FStar_Syntax_Syntax.blob = uu___;
-        FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_goal;
-        FStar_Syntax_Syntax.ltyp = (fstar_tactics_goal.t);
-        FStar_Syntax_Syntax.rng = FStar_Compiler_Range.dummyRange
-      } in
-    let thunk =
-      FStar_Thunk.mk
-        (fun uu___ ->
-           FStar_Compiler_Effect.op_Less_Bar FStar_TypeChecker_NBETerm.mk_t
-             (FStar_TypeChecker_NBETerm.Constant
-                (FStar_TypeChecker_NBETerm.String
-                   ("(((goal.nbe)))", FStar_Compiler_Range.dummyRange)))) in
-    FStar_Compiler_Effect.op_Less_Bar FStar_TypeChecker_NBETerm.mk_t
-      (FStar_TypeChecker_NBETerm.Lazy ((FStar_Pervasives.Inl li), thunk)) in
-  let unembed_goal _cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-    match uu___ with
-    | FStar_TypeChecker_NBETerm.Lazy
-        (FStar_Pervasives.Inl
-         { FStar_Syntax_Syntax.blob = b;
-           FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_goal;
-           FStar_Syntax_Syntax.ltyp = uu___1;
-           FStar_Syntax_Syntax.rng = uu___2;_},
-         uu___3)
-        ->
-        let uu___4 = FStar_Compiler_Dyn.undyn b in
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___5 -> FStar_Pervasives_Native.Some uu___5) uu___4
-    | uu___1 ->
-        ((let uu___3 =
-            FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-          if uu___3
-          then
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.t_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded NBE goal: %s"
-                  uu___6 in
-              (FStar_Errors.Warning_NotEmbedded, uu___5) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___4
-          else ());
-         FStar_Pervasives_Native.None) in
-  let uu___ = mkFV fstar_tactics_goal.fv [] [] in
-  let uu___1 = fv_as_emb_typ fstar_tactics_goal.fv in
-  {
-    FStar_TypeChecker_NBETerm.em = embed_goal;
-    FStar_TypeChecker_NBETerm.un = unembed_goal;
-    FStar_TypeChecker_NBETerm.typ = uu___;
-    FStar_TypeChecker_NBETerm.emb_typ = uu___1
-  }
-let (e_exn : Prims.exn FStar_Syntax_Embeddings.embedding) =
-  let embed_exn e rng uu___ uu___1 =
-    match e with
-    | FStar_Tactics_Common.TacticFailure s ->
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = embed FStar_Syntax_Embeddings.e_string rng s in
-            FStar_Syntax_Syntax.as_arg uu___4 in
-          [uu___3] in
-        FStar_Syntax_Syntax.mk_Tm_app fstar_tactics_TacticFailure.t uu___2
-          rng
-    | FStar_Tactics_Common.EExn t ->
-        {
-          FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-          FStar_Syntax_Syntax.pos = rng;
-          FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-          FStar_Syntax_Syntax.hash_code = (t.FStar_Syntax_Syntax.hash_code)
-        }
-    | e1 ->
-        let s =
-          let uu___2 = FStar_Compiler_Util.message_of_exn e1 in
-          Prims.op_Hat "uncaught exception: " uu___2 in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = embed FStar_Syntax_Embeddings.e_string rng s in
-            FStar_Syntax_Syntax.as_arg uu___4 in
-          [uu___3] in
-        FStar_Syntax_Syntax.mk_Tm_app fstar_tactics_TacticFailure.t uu___2
-          rng in
-  let unembed_exn t w uu___ =
-    let uu___1 = hd'_and_args t in
-    match uu___1 with
-    | (FStar_Syntax_Syntax.Tm_fvar fv, (s, uu___2)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_TacticFailure.lid ->
-        let uu___3 = unembed' w FStar_Syntax_Embeddings.e_string s in
-        FStar_Compiler_Util.bind_opt uu___3
-          (fun s1 ->
-             FStar_Pervasives_Native.Some
-               (FStar_Tactics_Common.TacticFailure s1))
-    | uu___2 -> FStar_Pervasives_Native.Some (FStar_Tactics_Common.EExn t) in
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.exn_lid
-          FStar_Ident.string_of_lid in
-      (uu___2, []) in
-    FStar_Syntax_Syntax.ET_app uu___1 in
-  FStar_Syntax_Embeddings.mk_emb_full embed_exn unembed_exn
-    FStar_Syntax_Syntax.t_exn (fun uu___1 -> "(exn)") uu___
-let (e_exn_nbe : Prims.exn FStar_TypeChecker_NBETerm.embedding) =
-  let embed_exn cb e =
-    match e with
-    | FStar_Tactics_Common.TacticFailure s ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_NBETerm.embed
-                FStar_TypeChecker_NBETerm.e_string cb s in
-            FStar_TypeChecker_NBETerm.as_arg uu___2 in
-          [uu___1] in
-        mkConstruct fstar_tactics_TacticFailure.fv [] uu___
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_Compiler_Util.message_of_exn e in
-          FStar_Compiler_Util.format1 "cannot embed exn (NBE) : %s" uu___2 in
-        failwith uu___1 in
-  let unembed_exn cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-    match uu___ with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, (s, uu___2)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_TacticFailure.lid ->
-        let uu___3 =
-          FStar_TypeChecker_NBETerm.unembed
-            FStar_TypeChecker_NBETerm.e_string cb s in
-        FStar_Compiler_Util.bind_opt uu___3
-          (fun s1 ->
-             FStar_Pervasives_Native.Some
-               (FStar_Tactics_Common.TacticFailure s1))
-    | uu___1 -> FStar_Pervasives_Native.None in
-  let fv_exn = FStar_Syntax_Syntax.fvconst FStar_Parser_Const.exn_lid in
-  let uu___ = mkFV fv_exn [] [] in
-  let uu___1 = fv_as_emb_typ fv_exn in
-  {
-    FStar_TypeChecker_NBETerm.em = embed_exn;
-    FStar_TypeChecker_NBETerm.un = unembed_exn;
-    FStar_TypeChecker_NBETerm.typ = uu___;
-    FStar_TypeChecker_NBETerm.emb_typ = uu___1
-  }
-let e_result :
-  'a .
-    'a FStar_Syntax_Embeddings.embedding ->
-      'a FStar_Tactics_Result.__result FStar_Syntax_Embeddings.embedding
-  =
-  fun ea ->
-    let embed_result res rng uu___ uu___1 =
-      match res with
-      | FStar_Tactics_Result.Success (a1, ps) ->
-          let uu___2 =
-            FStar_Syntax_Syntax.mk_Tm_uinst fstar_tactics_Success.t
-              [FStar_Syntax_Syntax.U_zero] in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Syntax_Embeddings.type_of ea in
-              FStar_Syntax_Syntax.iarg uu___5 in
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = embed ea rng a1 in
-                FStar_Syntax_Syntax.as_arg uu___7 in
-              let uu___7 =
-                let uu___8 =
-                  let uu___9 = embed e_proofstate rng ps in
-                  FStar_Syntax_Syntax.as_arg uu___9 in
-                [uu___8] in
-              uu___6 :: uu___7 in
-            uu___4 :: uu___5 in
-          FStar_Syntax_Syntax.mk_Tm_app uu___2 uu___3 rng
-      | FStar_Tactics_Result.Failed (e, ps) ->
-          let uu___2 =
-            FStar_Syntax_Syntax.mk_Tm_uinst fstar_tactics_Failed.t
-              [FStar_Syntax_Syntax.U_zero] in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Syntax_Embeddings.type_of ea in
-              FStar_Syntax_Syntax.iarg uu___5 in
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = embed e_exn rng e in
-                FStar_Syntax_Syntax.as_arg uu___7 in
-              let uu___7 =
-                let uu___8 =
-                  let uu___9 = embed e_proofstate rng ps in
-                  FStar_Syntax_Syntax.as_arg uu___9 in
-                [uu___8] in
-              uu___6 :: uu___7 in
-            uu___4 :: uu___5 in
-          FStar_Syntax_Syntax.mk_Tm_app uu___2 uu___3 rng in
-    let unembed_result t w uu___ =
-      let uu___1 = hd'_and_args t in
-      match uu___1 with
-      | (FStar_Syntax_Syntax.Tm_fvar fv, _t::(a1, uu___2)::(ps, uu___3)::[])
-          when FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Success.lid ->
-          let uu___4 = unembed' w ea a1 in
-          FStar_Compiler_Util.bind_opt uu___4
-            (fun a2 ->
-               let uu___5 = unembed' w e_proofstate ps in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun ps1 ->
-                    FStar_Pervasives_Native.Some
-                      (FStar_Tactics_Result.Success (a2, ps1))))
-      | (FStar_Syntax_Syntax.Tm_fvar fv, _t::(e, uu___2)::(ps, uu___3)::[])
-          when FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Failed.lid ->
-          let uu___4 = unembed' w e_exn e in
-          FStar_Compiler_Util.bind_opt uu___4
-            (fun e1 ->
-               let uu___5 = unembed' w e_proofstate ps in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun ps1 ->
-                    FStar_Pervasives_Native.Some
-                      (FStar_Tactics_Result.Failed (e1, ps1))))
-      | uu___2 ->
-          (if w
-           then
-             (let uu___4 =
-                let uu___5 =
-                  let uu___6 = FStar_Syntax_Print.term_to_string t in
-                  FStar_Compiler_Util.format1
-                    "Not an embedded tactic result: %s" uu___6 in
-                (FStar_Errors.Warning_NotEmbedded, uu___5) in
-              FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___4)
-           else ();
-           FStar_Pervasives_Native.None) in
-    let uu___ =
-      let uu___1 = FStar_Syntax_Embeddings.type_of ea in t_result_of uu___1 in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          FStar_Compiler_Effect.op_Bar_Greater fstar_tactics_result.lid
-            FStar_Ident.string_of_lid in
-        let uu___4 =
-          let uu___5 = FStar_Syntax_Embeddings.emb_typ_of ea in [uu___5] in
-        (uu___3, uu___4) in
-      FStar_Syntax_Syntax.ET_app uu___2 in
-    FStar_Syntax_Embeddings.mk_emb_full embed_result unembed_result uu___
-      (fun uu___2 -> "") uu___1
-let e_result_nbe :
-  'a .
-    'a FStar_TypeChecker_NBETerm.embedding ->
-      'a FStar_Tactics_Result.__result FStar_TypeChecker_NBETerm.embedding
-  =
-  fun ea ->
-    let embed_result cb res =
-      match res with
-      | FStar_Tactics_Result.Failed (e, ps) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.type_of ea in
-              FStar_TypeChecker_NBETerm.as_iarg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_TypeChecker_NBETerm.embed e_exn_nbe cb e in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    FStar_TypeChecker_NBETerm.embed e_proofstate_nbe cb ps in
-                  FStar_TypeChecker_NBETerm.as_arg uu___6 in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          mkConstruct fstar_tactics_Failed.fv [FStar_Syntax_Syntax.U_zero]
-            uu___
-      | FStar_Tactics_Result.Success (a1, ps) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_NBETerm.type_of ea in
-              FStar_TypeChecker_NBETerm.as_iarg uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_TypeChecker_NBETerm.embed ea cb a1 in
-                FStar_TypeChecker_NBETerm.as_arg uu___4 in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    FStar_TypeChecker_NBETerm.embed e_proofstate_nbe cb ps in
-                  FStar_TypeChecker_NBETerm.as_arg uu___6 in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          mkConstruct fstar_tactics_Success.fv [FStar_Syntax_Syntax.U_zero]
-            uu___ in
-    let unembed_result cb t =
-      let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-      match uu___ with
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___1, (ps, uu___2)::(a1, uu___3)::_t::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Success.lid ->
-          let uu___4 = FStar_TypeChecker_NBETerm.unembed ea cb a1 in
-          FStar_Compiler_Util.bind_opt uu___4
-            (fun a2 ->
-               let uu___5 =
-                 FStar_TypeChecker_NBETerm.unembed e_proofstate_nbe cb ps in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun ps1 ->
-                    FStar_Pervasives_Native.Some
-                      (FStar_Tactics_Result.Success (a2, ps1))))
-      | FStar_TypeChecker_NBETerm.Construct
-          (fv, uu___1, (ps, uu___2)::(e, uu___3)::_t::[]) when
-          FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Failed.lid ->
-          let uu___4 = FStar_TypeChecker_NBETerm.unembed e_exn_nbe cb e in
-          FStar_Compiler_Util.bind_opt uu___4
-            (fun e1 ->
-               let uu___5 =
-                 FStar_TypeChecker_NBETerm.unembed e_proofstate_nbe cb ps in
-               FStar_Compiler_Util.bind_opt uu___5
-                 (fun ps1 ->
-                    FStar_Pervasives_Native.Some
-                      (FStar_Tactics_Result.Failed (e1, ps1))))
-      | uu___1 -> FStar_Pervasives_Native.None in
-    let uu___ = mkFV fstar_tactics_result.fv [] [] in
-    let uu___1 = fv_as_emb_typ fstar_tactics_result.fv in
-    {
-      FStar_TypeChecker_NBETerm.em = embed_result;
-      FStar_TypeChecker_NBETerm.un = unembed_result;
-      FStar_TypeChecker_NBETerm.typ = uu___;
-      FStar_TypeChecker_NBETerm.emb_typ = uu___1
-    }
-let (e_direction :
-  FStar_Tactics_Types.direction FStar_Syntax_Embeddings.embedding) =
-  let embed_direction rng d =
-    match d with
-    | FStar_Tactics_Types.TopDown -> fstar_tactics_topdown.t
-    | FStar_Tactics_Types.BottomUp -> fstar_tactics_bottomup.t in
-  let unembed_direction w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_topdown.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.TopDown
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_bottomup.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.BottomUp
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded direction: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_direction unembed_direction fstar_tactics_direction.t
-let (e_direction_nbe :
-  FStar_Tactics_Types.direction FStar_TypeChecker_NBETerm.embedding) =
-  let embed_direction cb res =
-    match res with
-    | FStar_Tactics_Types.TopDown ->
-        mkConstruct fstar_tactics_topdown.fv [] []
-    | FStar_Tactics_Types.BottomUp ->
-        mkConstruct fstar_tactics_bottomup.fv [] [] in
-  let unembed_direction cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-    match uu___ with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_topdown.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.TopDown
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_bottomup.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.BottomUp
-    | uu___1 ->
-        ((let uu___3 =
-            FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-          if uu___3
-          then
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.t_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded direction: %s"
-                  uu___6 in
-              (FStar_Errors.Warning_NotEmbedded, uu___5) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___4
-          else ());
-         FStar_Pervasives_Native.None) in
-  let uu___ = mkFV fstar_tactics_direction.fv [] [] in
-  let uu___1 = fv_as_emb_typ fstar_tactics_direction.fv in
-  {
-    FStar_TypeChecker_NBETerm.em = embed_direction;
-    FStar_TypeChecker_NBETerm.un = unembed_direction;
-    FStar_TypeChecker_NBETerm.typ = uu___;
-    FStar_TypeChecker_NBETerm.emb_typ = uu___1
-  }
-let (e_ctrl_flag :
-  FStar_Tactics_Types.ctrl_flag FStar_Syntax_Embeddings.embedding) =
-  let embed_ctrl_flag rng d =
-    match d with
-    | FStar_Tactics_Types.Continue -> fstar_tactics_Continue.t
-    | FStar_Tactics_Types.Skip -> fstar_tactics_Skip.t
-    | FStar_Tactics_Types.Abort -> fstar_tactics_Abort.t in
-  let unembed_ctrl_flag w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Continue.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Continue
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Skip.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Skip
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Abort.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Abort
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded ctrl_flag: %s"
-                  uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_ctrl_flag unembed_ctrl_flag fstar_tactics_ctrl_flag.t
-let (e_ctrl_flag_nbe :
-  FStar_Tactics_Types.ctrl_flag FStar_TypeChecker_NBETerm.embedding) =
-  let embed_ctrl_flag cb res =
-    match res with
-    | FStar_Tactics_Types.Continue ->
-        mkConstruct fstar_tactics_Continue.fv [] []
-    | FStar_Tactics_Types.Skip -> mkConstruct fstar_tactics_Skip.fv [] []
-    | FStar_Tactics_Types.Abort -> mkConstruct fstar_tactics_Abort.fv [] [] in
-  let unembed_ctrl_flag cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-    match uu___ with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Continue.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Continue
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Skip.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Skip
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Abort.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Abort
-    | uu___1 ->
-        ((let uu___3 =
-            FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-          if uu___3
-          then
-            let uu___4 =
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_NBETerm.t_to_string t in
-                FStar_Compiler_Util.format1 "Not an embedded ctrl_flag: %s"
-                  uu___6 in
-              (FStar_Errors.Warning_NotEmbedded, uu___5) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___4
-          else ());
-         FStar_Pervasives_Native.None) in
-  let uu___ = mkFV fstar_tactics_ctrl_flag.fv [] [] in
-  let uu___1 = fv_as_emb_typ fstar_tactics_ctrl_flag.fv in
-  {
-    FStar_TypeChecker_NBETerm.em = embed_ctrl_flag;
-    FStar_TypeChecker_NBETerm.un = unembed_ctrl_flag;
-    FStar_TypeChecker_NBETerm.typ = uu___;
-    FStar_TypeChecker_NBETerm.emb_typ = uu___1
-  }
-let (e_guard_policy :
-  FStar_Tactics_Types.guard_policy FStar_Syntax_Embeddings.embedding) =
-  let embed_guard_policy rng p =
-    match p with
-    | FStar_Tactics_Types.SMT -> fstar_tactics_SMT.t
-    | FStar_Tactics_Types.Goal -> fstar_tactics_Goal.t
-    | FStar_Tactics_Types.Force -> fstar_tactics_Force.t
-    | FStar_Tactics_Types.Drop -> fstar_tactics_Drop.t in
-  let unembed_guard_policy w t =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_SMT.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.SMT
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Goal.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Goal
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Force.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Force
-    | FStar_Syntax_Syntax.Tm_fvar fv when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Drop.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Drop
-    | uu___1 ->
-        (if w
-         then
-           (let uu___3 =
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                FStar_Compiler_Util.format1
-                  "Not an embedded guard_policy: %s" uu___5 in
-              (FStar_Errors.Warning_NotEmbedded, uu___4) in
-            FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___3)
-         else ();
-         FStar_Pervasives_Native.None) in
-  mk_emb embed_guard_policy unembed_guard_policy fstar_tactics_guard_policy.t
-let (e_guard_policy_nbe :
-  FStar_Tactics_Types.guard_policy FStar_TypeChecker_NBETerm.embedding) =
-  let embed_guard_policy cb p =
-    match p with
-    | FStar_Tactics_Types.SMT -> mkConstruct fstar_tactics_SMT.fv [] []
-    | FStar_Tactics_Types.Goal -> mkConstruct fstar_tactics_Goal.fv [] []
-    | FStar_Tactics_Types.Force -> mkConstruct fstar_tactics_Force.fv [] []
-    | FStar_Tactics_Types.Drop -> mkConstruct fstar_tactics_Drop.fv [] [] in
-  let unembed_guard_policy cb t =
-    let uu___ = FStar_TypeChecker_NBETerm.nbe_t_of_t t in
-    match uu___ with
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_SMT.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.SMT
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Goal.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Goal
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Force.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Force
-    | FStar_TypeChecker_NBETerm.Construct (fv, uu___1, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv fstar_tactics_Drop.lid ->
-        FStar_Pervasives_Native.Some FStar_Tactics_Types.Drop
-    | uu___1 -> FStar_Pervasives_Native.None in
-  let uu___ = mkFV fstar_tactics_guard_policy.fv [] [] in
-  let uu___1 = fv_as_emb_typ fstar_tactics_guard_policy.fv in
-  {
-    FStar_TypeChecker_NBETerm.em = embed_guard_policy;
-    FStar_TypeChecker_NBETerm.un = unembed_guard_policy;
-    FStar_TypeChecker_NBETerm.typ = uu___;
-    FStar_TypeChecker_NBETerm.emb_typ = uu___1
-  }
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Hooks.ml b/src/ocaml-output/FStar_Tactics_Hooks.ml
deleted file mode 100644
index 169ac05b7a0..00000000000
--- a/src/ocaml-output/FStar_Tactics_Hooks.ml
+++ /dev/null
@@ -1,1870 +0,0 @@
-open Prims
-let (run_tactic_on_typ :
-  FStar_Compiler_Range.range ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.term ->
-        FStar_TypeChecker_Env.env ->
-          FStar_Syntax_Syntax.term ->
-            (FStar_Tactics_Types.goal Prims.list * FStar_Syntax_Syntax.term))
-  =
-  fun rng_tac ->
-    fun rng_goal ->
-      fun tactic ->
-        fun env ->
-          fun typ ->
-            let rng =
-              let uu___ = FStar_Compiler_Range.use_range rng_goal in
-              let uu___1 = FStar_Compiler_Range.use_range rng_tac in
-              FStar_Compiler_Range.range_of_rng uu___ uu___1 in
-            let uu___ = FStar_Tactics_Basic.proofstate_of_goal_ty rng env typ in
-            match uu___ with
-            | (ps, w) ->
-                let uu___1 =
-                  FStar_Tactics_Interpreter.run_tactic_on_ps rng_tac rng_goal
-                    false FStar_Syntax_Embeddings.e_unit ()
-                    FStar_Syntax_Embeddings.e_unit tactic ps in
-                (match uu___1 with | (gs, _res) -> (gs, w))
-let (run_tactic_on_all_implicits :
-  FStar_Compiler_Range.range ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.term ->
-        FStar_TypeChecker_Env.env ->
-          FStar_TypeChecker_Env.implicits ->
-            FStar_Tactics_Types.goal Prims.list)
-  =
-  fun rng_tac ->
-    fun rng_goal ->
-      fun tactic ->
-        fun env ->
-          fun imps ->
-            let uu___ =
-              FStar_Tactics_Basic.proofstate_of_all_implicits rng_goal env
-                imps in
-            match uu___ with
-            | (ps, uu___1) ->
-                let uu___2 =
-                  let uu___3 = FStar_TypeChecker_Env.get_range env in
-                  FStar_Tactics_Interpreter.run_tactic_on_ps uu___3 rng_goal
-                    true FStar_Syntax_Embeddings.e_unit ()
-                    FStar_Syntax_Embeddings.e_unit tactic ps in
-                (match uu___2 with | (goals, ()) -> goals)
-type pol =
-  | StrictlyPositive 
-  | Pos 
-  | Neg 
-  | Both 
-let (uu___is_StrictlyPositive : pol -> Prims.bool) =
-  fun projectee ->
-    match projectee with | StrictlyPositive -> true | uu___ -> false
-let (uu___is_Pos : pol -> Prims.bool) =
-  fun projectee -> match projectee with | Pos -> true | uu___ -> false
-let (uu___is_Neg : pol -> Prims.bool) =
-  fun projectee -> match projectee with | Neg -> true | uu___ -> false
-let (uu___is_Both : pol -> Prims.bool) =
-  fun projectee -> match projectee with | Both -> true | uu___ -> false
-type 'a tres_m =
-  | Unchanged of 'a 
-  | Simplified of ('a * FStar_Tactics_Types.goal Prims.list) 
-  | Dual of ('a * 'a * FStar_Tactics_Types.goal Prims.list) 
-let uu___is_Unchanged : 'a . 'a tres_m -> Prims.bool =
-  fun projectee ->
-    match projectee with | Unchanged _0 -> true | uu___ -> false
-let __proj__Unchanged__item___0 : 'a . 'a tres_m -> 'a =
-  fun projectee -> match projectee with | Unchanged _0 -> _0
-let uu___is_Simplified : 'a . 'a tres_m -> Prims.bool =
-  fun projectee ->
-    match projectee with | Simplified _0 -> true | uu___ -> false
-let __proj__Simplified__item___0 :
-  'a . 'a tres_m -> ('a * FStar_Tactics_Types.goal Prims.list) =
-  fun projectee -> match projectee with | Simplified _0 -> _0
-let uu___is_Dual : 'a . 'a tres_m -> Prims.bool =
-  fun projectee -> match projectee with | Dual _0 -> true | uu___ -> false
-let __proj__Dual__item___0 :
-  'a . 'a tres_m -> ('a * 'a * FStar_Tactics_Types.goal Prims.list) =
-  fun projectee -> match projectee with | Dual _0 -> _0
-type tres = FStar_Syntax_Syntax.term tres_m
-let tpure : 'uuuuu . 'uuuuu -> 'uuuuu tres_m = fun x -> Unchanged x
-let (flip : pol -> pol) =
-  fun p ->
-    match p with
-    | StrictlyPositive -> Neg
-    | Pos -> Neg
-    | Neg -> Pos
-    | Both -> Both
-let (getprop :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    fun t ->
-      let tn =
-        FStar_TypeChecker_Normalize.normalize
-          [FStar_TypeChecker_Env.Weak;
-          FStar_TypeChecker_Env.HNF;
-          FStar_TypeChecker_Env.UnfoldUntil
-            FStar_Syntax_Syntax.delta_constant] e t in
-      FStar_Syntax_Util.un_squash tn
-let (by_tactic_interp :
-  pol -> FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> tres) =
-  fun pol1 ->
-    fun e ->
-      fun t ->
-        let uu___ = FStar_Syntax_Util.head_and_args t in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (tactic, FStar_Pervasives_Native.None)::(assertion,
-                                                         FStar_Pervasives_Native.None)::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.by_tactic_lid
-                 ->
-                 (match pol1 with
-                  | StrictlyPositive ->
-                      let uu___2 =
-                        run_tactic_on_typ tactic.FStar_Syntax_Syntax.pos
-                          assertion.FStar_Syntax_Syntax.pos tactic e
-                          assertion in
-                      (match uu___2 with
-                       | (gs, uu___3) ->
-                           Simplified (FStar_Syntax_Util.t_true, gs))
-                  | Pos ->
-                      let uu___2 =
-                        run_tactic_on_typ tactic.FStar_Syntax_Syntax.pos
-                          assertion.FStar_Syntax_Syntax.pos tactic e
-                          assertion in
-                      (match uu___2 with
-                       | (gs, uu___3) ->
-                           Simplified (FStar_Syntax_Util.t_true, gs))
-                  | Both ->
-                      let uu___2 =
-                        run_tactic_on_typ tactic.FStar_Syntax_Syntax.pos
-                          assertion.FStar_Syntax_Syntax.pos tactic e
-                          assertion in
-                      (match uu___2 with
-                       | (gs, uu___3) ->
-                           Dual (assertion, FStar_Syntax_Util.t_true, gs))
-                  | Neg -> Simplified (assertion, []))
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (assertion, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.spinoff_lid
-                 ->
-                 (match pol1 with
-                  | StrictlyPositive ->
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Tactics_Types.goal_of_goal_ty e assertion in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_Pervasives_Native.fst uu___5 in
-                          [uu___4] in
-                        (FStar_Syntax_Util.t_true, uu___3) in
-                      Simplified uu___2
-                  | Pos ->
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Tactics_Types.goal_of_goal_ty e assertion in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_Pervasives_Native.fst uu___5 in
-                          [uu___4] in
-                        (FStar_Syntax_Util.t_true, uu___3) in
-                      Simplified uu___2
-                  | Both ->
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Tactics_Types.goal_of_goal_ty e assertion in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_Pervasives_Native.fst uu___5 in
-                          [uu___4] in
-                        (assertion, FStar_Syntax_Util.t_true, uu___3) in
-                      Dual uu___2
-                  | Neg -> Simplified (assertion, []))
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (tactic, FStar_Pervasives_Native.None)::(typ,
-                                                         FStar_Pervasives_Native.Some
-                                                         {
-                                                           FStar_Syntax_Syntax.aqual_implicit
-                                                             = true;
-                                                           FStar_Syntax_Syntax.aqual_attributes
-                                                             = uu___2;_})::
-                (tm, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.rewrite_by_tactic_lid
-                 ->
-                 let uu___3 =
-                   FStar_TypeChecker_Env.new_implicit_var_aux
-                     "rewrite_with_tactic RHS" tm.FStar_Syntax_Syntax.pos e
-                     typ FStar_Syntax_Syntax.Strict
-                     FStar_Pervasives_Native.None in
-                 (match uu___3 with
-                  | (uvtm, uu___4, g_imp) ->
-                      let u = e.FStar_TypeChecker_Env.universe_of e typ in
-                      let goal =
-                        let uu___5 = FStar_Syntax_Util.mk_eq2 u typ tm uvtm in
-                        FStar_Syntax_Util.mk_squash
-                          FStar_Syntax_Syntax.U_zero uu___5 in
-                      let uu___5 =
-                        run_tactic_on_typ tactic.FStar_Syntax_Syntax.pos
-                          tm.FStar_Syntax_Syntax.pos tactic e goal in
-                      (match uu___5 with
-                       | (gs, uu___6) ->
-                           let tagged_imps =
-                             FStar_TypeChecker_Rel.resolve_implicits_tac e
-                               g_imp in
-                           (FStar_Tactics_Interpreter.report_implicits
-                              tm.FStar_Syntax_Syntax.pos tagged_imps;
-                            Simplified (uvtm, gs))))
-             | uu___2 -> Unchanged t)
-let explode :
-  'a . 'a tres_m -> ('a * 'a * FStar_Tactics_Types.goal Prims.list) =
-  fun t ->
-    match t with
-    | Unchanged t1 -> (t1, t1, [])
-    | Simplified (t1, gs) -> (t1, t1, gs)
-    | Dual (tn, tp, gs) -> (tn, tp, gs)
-let comb1 : 'a 'b . ('a -> 'b) -> 'a tres_m -> 'b tres_m =
-  fun f ->
-    fun uu___ ->
-      match uu___ with
-      | Unchanged t -> let uu___1 = f t in Unchanged uu___1
-      | Simplified (t, gs) ->
-          let uu___1 = let uu___2 = f t in (uu___2, gs) in Simplified uu___1
-      | Dual (tn, tp, gs) ->
-          let uu___1 =
-            let uu___2 = f tn in let uu___3 = f tp in (uu___2, uu___3, gs) in
-          Dual uu___1
-let comb2 :
-  'a 'b 'c . ('a -> 'b -> 'c) -> 'a tres_m -> 'b tres_m -> 'c tres_m =
-  fun f ->
-    fun x ->
-      fun y ->
-        match (x, y) with
-        | (Unchanged t1, Unchanged t2) ->
-            let uu___ = f t1 t2 in Unchanged uu___
-        | (Unchanged t1, Simplified (t2, gs)) ->
-            let uu___ = let uu___1 = f t1 t2 in (uu___1, gs) in
-            Simplified uu___
-        | (Simplified (t1, gs), Unchanged t2) ->
-            let uu___ = let uu___1 = f t1 t2 in (uu___1, gs) in
-            Simplified uu___
-        | (Simplified (t1, gs1), Simplified (t2, gs2)) ->
-            let uu___ =
-              let uu___1 = f t1 t2 in
-              (uu___1, (FStar_Compiler_List.op_At gs1 gs2)) in
-            Simplified uu___
-        | uu___ ->
-            let uu___1 = explode x in
-            (match uu___1 with
-             | (n1, p1, gs1) ->
-                 let uu___2 = explode y in
-                 (match uu___2 with
-                  | (n2, p2, gs2) ->
-                      let uu___3 =
-                        let uu___4 = f n1 n2 in
-                        let uu___5 = f p1 p2 in
-                        (uu___4, uu___5, (FStar_Compiler_List.op_At gs1 gs2)) in
-                      Dual uu___3))
-let comb_list : 'a . 'a tres_m Prims.list -> 'a Prims.list tres_m =
-  fun rs ->
-    let rec aux rs1 acc =
-      match rs1 with
-      | [] -> acc
-      | hd::tl ->
-          let uu___ = comb2 (fun l -> fun r -> l :: r) hd acc in aux tl uu___ in
-    aux (FStar_Compiler_List.rev rs) (tpure [])
-let emit : 'a . FStar_Tactics_Types.goal Prims.list -> 'a tres_m -> 'a tres_m
-  =
-  fun gs -> fun m -> comb2 (fun uu___ -> fun x -> x) (Simplified ((), gs)) m
-let rec (traverse :
-  (pol -> FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> tres) ->
-    pol -> FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> tres)
-  =
-  fun f ->
-    fun pol1 ->
-      fun e ->
-        fun t ->
-          let r =
-            let uu___ =
-              let uu___1 = FStar_Syntax_Subst.compress t in
-              uu___1.FStar_Syntax_Syntax.n in
-            match uu___ with
-            | FStar_Syntax_Syntax.Tm_uinst (t1, us) ->
-                let tr = traverse f pol1 e t1 in
-                let uu___1 =
-                  comb1 (fun t' -> FStar_Syntax_Syntax.Tm_uinst (t', us)) in
-                uu___1 tr
-            | FStar_Syntax_Syntax.Tm_meta (t1, m) ->
-                let tr = traverse f pol1 e t1 in
-                let uu___1 =
-                  comb1 (fun t' -> FStar_Syntax_Syntax.Tm_meta (t', m)) in
-                uu___1 tr
-            | FStar_Syntax_Syntax.Tm_app
-                ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                   FStar_Syntax_Syntax.pos = uu___1;
-                   FStar_Syntax_Syntax.vars = uu___2;
-                   FStar_Syntax_Syntax.hash_code = uu___3;_},
-                 (p, uu___4)::(q, uu___5)::[])
-                when
-                FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.imp_lid
-                ->
-                let x =
-                  FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None p in
-                let r1 = traverse f (flip pol1) e p in
-                let r2 =
-                  let uu___6 = FStar_TypeChecker_Env.push_bv e x in
-                  traverse f pol1 uu___6 q in
-                comb2
-                  (fun l ->
-                     fun r3 ->
-                       let uu___6 = FStar_Syntax_Util.mk_imp l r3 in
-                       uu___6.FStar_Syntax_Syntax.n) r1 r2
-            | FStar_Syntax_Syntax.Tm_app
-                ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                   FStar_Syntax_Syntax.pos = uu___1;
-                   FStar_Syntax_Syntax.vars = uu___2;
-                   FStar_Syntax_Syntax.hash_code = uu___3;_},
-                 (p, uu___4)::(q, uu___5)::[])
-                when
-                FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.iff_lid
-                ->
-                let xp =
-                  FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None p in
-                let xq =
-                  FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None q in
-                let r1 =
-                  let uu___6 = FStar_TypeChecker_Env.push_bv e xq in
-                  traverse f Both uu___6 p in
-                let r2 =
-                  let uu___6 = FStar_TypeChecker_Env.push_bv e xp in
-                  traverse f Both uu___6 q in
-                (match (r1, r2) with
-                 | (Unchanged uu___6, Unchanged uu___7) ->
-                     comb2
-                       (fun l ->
-                          fun r3 ->
-                            let uu___8 = FStar_Syntax_Util.mk_iff l r3 in
-                            uu___8.FStar_Syntax_Syntax.n) r1 r2
-                 | uu___6 ->
-                     let uu___7 = explode r1 in
-                     (match uu___7 with
-                      | (pn, pp, gs1) ->
-                          let uu___8 = explode r2 in
-                          (match uu___8 with
-                           | (qn, qp, gs2) ->
-                               let t1 =
-                                 let uu___9 = FStar_Syntax_Util.mk_imp pn qp in
-                                 let uu___10 = FStar_Syntax_Util.mk_imp qn pp in
-                                 FStar_Syntax_Util.mk_conj uu___9 uu___10 in
-                               Simplified
-                                 ((t1.FStar_Syntax_Syntax.n),
-                                   (FStar_Compiler_List.op_At gs1 gs2)))))
-            | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-                let r0 = traverse f pol1 e hd in
-                let r1 =
-                  FStar_Compiler_List.fold_right
-                    (fun uu___1 ->
-                       fun r2 ->
-                         match uu___1 with
-                         | (a, q) ->
-                             let r' = traverse f pol1 e a in
-                             comb2 (fun a1 -> fun args1 -> (a1, q) :: args1)
-                               r' r2) args (tpure []) in
-                comb2
-                  (fun hd1 ->
-                     fun args1 -> FStar_Syntax_Syntax.Tm_app (hd1, args1)) r0
-                  r1
-            | FStar_Syntax_Syntax.Tm_abs (bs, t1, k) ->
-                let uu___1 = FStar_Syntax_Subst.open_term bs t1 in
-                (match uu___1 with
-                 | (bs1, topen) ->
-                     let e' = FStar_TypeChecker_Env.push_binders e bs1 in
-                     let r0 =
-                       FStar_Compiler_List.map
-                         (fun b ->
-                            let r1 =
-                              traverse f (flip pol1) e
-                                (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                            let uu___2 =
-                              comb1
-                                (fun s' ->
-                                   {
-                                     FStar_Syntax_Syntax.binder_bv =
-                                       (let uu___3 =
-                                          b.FStar_Syntax_Syntax.binder_bv in
-                                        {
-                                          FStar_Syntax_Syntax.ppname =
-                                            (uu___3.FStar_Syntax_Syntax.ppname);
-                                          FStar_Syntax_Syntax.index =
-                                            (uu___3.FStar_Syntax_Syntax.index);
-                                          FStar_Syntax_Syntax.sort = s'
-                                        });
-                                     FStar_Syntax_Syntax.binder_qual =
-                                       (b.FStar_Syntax_Syntax.binder_qual);
-                                     FStar_Syntax_Syntax.binder_attrs =
-                                       (b.FStar_Syntax_Syntax.binder_attrs)
-                                   }) in
-                            uu___2 r1) bs1 in
-                     let rbs = comb_list r0 in
-                     let rt = traverse f pol1 e' topen in
-                     comb2
-                       (fun bs2 ->
-                          fun t2 ->
-                            let uu___2 = FStar_Syntax_Util.abs bs2 t2 k in
-                            uu___2.FStar_Syntax_Syntax.n) rbs rt)
-            | FStar_Syntax_Syntax.Tm_ascribed (t1, asc, ef) ->
-                let uu___1 = traverse f pol1 e t1 in
-                let uu___2 =
-                  comb1
-                    (fun t2 -> FStar_Syntax_Syntax.Tm_ascribed (t2, asc, ef)) in
-                uu___2 uu___1
-            | FStar_Syntax_Syntax.Tm_match (sc, asc_opt, brs, lopt) ->
-                let uu___1 = traverse f pol1 e sc in
-                let uu___2 =
-                  let uu___3 =
-                    FStar_Compiler_List.map
-                      (fun br ->
-                         let uu___4 = FStar_Syntax_Subst.open_branch br in
-                         match uu___4 with
-                         | (pat, w, exp) ->
-                             let bvs = FStar_Syntax_Syntax.pat_bvs pat in
-                             let e1 = FStar_TypeChecker_Env.push_bvs e bvs in
-                             let r1 = traverse f pol1 e1 exp in
-                             let uu___5 =
-                               comb1
-                                 (fun exp1 ->
-                                    FStar_Syntax_Subst.close_branch
-                                      (pat, w, exp1)) in
-                             uu___5 r1) brs in
-                  comb_list uu___3 in
-                comb2
-                  (fun sc1 ->
-                     fun brs1 ->
-                       FStar_Syntax_Syntax.Tm_match
-                         (sc1, asc_opt, brs1, lopt)) uu___1 uu___2
-            | x -> tpure x in
-          match r with
-          | Unchanged tn' ->
-              f pol1 e
-                {
-                  FStar_Syntax_Syntax.n = tn';
-                  FStar_Syntax_Syntax.pos = (t.FStar_Syntax_Syntax.pos);
-                  FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                  FStar_Syntax_Syntax.hash_code =
-                    (t.FStar_Syntax_Syntax.hash_code)
-                }
-          | Simplified (tn', gs) ->
-              let uu___ =
-                f pol1 e
-                  {
-                    FStar_Syntax_Syntax.n = tn';
-                    FStar_Syntax_Syntax.pos = (t.FStar_Syntax_Syntax.pos);
-                    FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                    FStar_Syntax_Syntax.hash_code =
-                      (t.FStar_Syntax_Syntax.hash_code)
-                  } in
-              emit gs uu___
-          | Dual (tn, tp, gs) ->
-              let rp =
-                f pol1 e
-                  {
-                    FStar_Syntax_Syntax.n = tp;
-                    FStar_Syntax_Syntax.pos = (t.FStar_Syntax_Syntax.pos);
-                    FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                    FStar_Syntax_Syntax.hash_code =
-                      (t.FStar_Syntax_Syntax.hash_code)
-                  } in
-              let uu___ = explode rp in
-              (match uu___ with
-               | (uu___1, p', gs') ->
-                   Dual
-                     ({
-                        FStar_Syntax_Syntax.n = tn;
-                        FStar_Syntax_Syntax.pos = (t.FStar_Syntax_Syntax.pos);
-                        FStar_Syntax_Syntax.vars =
-                          (t.FStar_Syntax_Syntax.vars);
-                        FStar_Syntax_Syntax.hash_code =
-                          (t.FStar_Syntax_Syntax.hash_code)
-                      }, p', (FStar_Compiler_List.op_At gs gs')))
-let (preprocess :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.term *
-        FStar_Options.optionstate) Prims.list)
-  =
-  fun env ->
-    fun goal ->
-      FStar_Errors.with_ctx "While preprocessing VC with a tactic"
-        (fun uu___ ->
-           (let uu___2 =
-              FStar_TypeChecker_Env.debug env (FStar_Options.Other "Tac") in
-            FStar_Compiler_Effect.op_Colon_Equals
-              FStar_Tactics_Interpreter.tacdbg uu___2);
-           (let uu___3 =
-              FStar_Compiler_Effect.op_Bang FStar_Tactics_Interpreter.tacdbg in
-            if uu___3
-            then
-              let uu___4 =
-                let uu___5 = FStar_TypeChecker_Env.all_binders env in
-                FStar_Compiler_Effect.op_Bar_Greater uu___5
-                  (FStar_Syntax_Print.binders_to_string ",") in
-              let uu___5 = FStar_Syntax_Print.term_to_string goal in
-              FStar_Compiler_Util.print2 "About to preprocess %s |= %s\n"
-                uu___4 uu___5
-            else ());
-           (let initial = (Prims.int_one, []) in
-            let uu___3 =
-              let uu___4 = traverse by_tactic_interp Pos env goal in
-              match uu___4 with
-              | Unchanged t' -> (t', [])
-              | Simplified (t', gs) -> (t', gs)
-              | uu___5 ->
-                  failwith "preprocess: impossible, traverse returned a Dual" in
-            match uu___3 with
-            | (t', gs) ->
-                ((let uu___5 =
-                    FStar_Compiler_Effect.op_Bang
-                      FStar_Tactics_Interpreter.tacdbg in
-                  if uu___5
-                  then
-                    let uu___6 =
-                      let uu___7 = FStar_TypeChecker_Env.all_binders env in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___7
-                        (FStar_Syntax_Print.binders_to_string ", ") in
-                    let uu___7 = FStar_Syntax_Print.term_to_string t' in
-                    FStar_Compiler_Util.print2
-                      "Main goal simplified to: %s |- %s\n" uu___6 uu___7
-                  else ());
-                 (let s = initial in
-                  let s1 =
-                    FStar_Compiler_List.fold_left
-                      (fun uu___5 ->
-                         fun g ->
-                           match uu___5 with
-                           | (n, gs1) ->
-                               let phi =
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Tactics_Types.goal_env g in
-                                   let uu___8 =
-                                     FStar_Tactics_Types.goal_type g in
-                                   getprop uu___7 uu___8 in
-                                 match uu___6 with
-                                 | FStar_Pervasives_Native.None ->
-                                     let uu___7 =
-                                       let uu___8 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Tactics_Types.goal_type g in
-                                           FStar_Syntax_Print.term_to_string
-                                             uu___10 in
-                                         FStar_Compiler_Util.format1
-                                           "Tactic returned proof-relevant goal: %s"
-                                           uu___9 in
-                                       (FStar_Errors.Fatal_TacticProofRelevantGoal,
-                                         uu___8) in
-                                     FStar_Errors.raise_error uu___7
-                                       env.FStar_TypeChecker_Env.range
-                                 | FStar_Pervasives_Native.Some phi1 -> phi1 in
-                               ((let uu___7 =
-                                   FStar_Compiler_Effect.op_Bang
-                                     FStar_Tactics_Interpreter.tacdbg in
-                                 if uu___7
-                                 then
-                                   let uu___8 =
-                                     FStar_Compiler_Util.string_of_int n in
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Tactics_Types.goal_type g in
-                                     FStar_Syntax_Print.term_to_string
-                                       uu___10 in
-                                   FStar_Compiler_Util.print2
-                                     "Got goal #%s: %s\n" uu___8 uu___9
-                                 else ());
-                                (let label =
-                                   let uu___7 =
-                                     let uu___8 =
-                                       FStar_Tactics_Types.get_label g in
-                                     uu___8 = "" in
-                                   if uu___7
-                                   then
-                                     let uu___8 =
-                                       FStar_Compiler_Util.string_of_int n in
-                                     Prims.op_Hat "Could not prove goal #"
-                                       uu___8
-                                   else
-                                     (let uu___9 =
-                                        let uu___10 =
-                                          FStar_Compiler_Util.string_of_int n in
-                                        let uu___11 =
-                                          let uu___12 =
-                                            let uu___13 =
-                                              FStar_Tactics_Types.get_label g in
-                                            Prims.op_Hat uu___13 ")" in
-                                          Prims.op_Hat " (" uu___12 in
-                                        Prims.op_Hat uu___10 uu___11 in
-                                      Prims.op_Hat "Could not prove goal #"
-                                        uu___9) in
-                                 let gt' =
-                                   FStar_TypeChecker_Util.label label
-                                     goal.FStar_Syntax_Syntax.pos phi in
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       FStar_Tactics_Types.goal_env g in
-                                     (uu___9, gt',
-                                       (g.FStar_Tactics_Types.opts)) in
-                                   uu___8 :: gs1 in
-                                 ((n + Prims.int_one), uu___7)))) s gs in
-                  let uu___5 = s1 in
-                  match uu___5 with
-                  | (uu___6, gs1) ->
-                      let gs2 = FStar_Compiler_List.rev gs1 in
-                      let uu___7 =
-                        let uu___8 = FStar_Options.peek () in
-                        (env, t', uu___8) in
-                      uu___7 :: gs2))))
-let rec (traverse_for_spinoff :
-  pol ->
-    (Prims.string * FStar_Compiler_Range.range)
-      FStar_Pervasives_Native.option ->
-      FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> tres)
-  =
-  fun pol1 ->
-    fun label_ctx ->
-      fun e ->
-        fun t ->
-          let debug_any = FStar_Options.debug_any () in
-          let debug =
-            FStar_TypeChecker_Env.debug e (FStar_Options.Other "SpinoffAll") in
-          let traverse1 pol2 e1 t1 =
-            traverse_for_spinoff pol2 label_ctx e1 t1 in
-          let traverse_ctx pol2 ctx e1 t1 =
-            let print_lc uu___ =
-              match uu___ with
-              | (msg, rng) ->
-                  let uu___1 = FStar_Compiler_Range.string_of_def_range rng in
-                  let uu___2 = FStar_Compiler_Range.string_of_use_range rng in
-                  FStar_Compiler_Util.format3 "(%s,%s) : %s" uu___1 uu___2
-                    msg in
-            if debug
-            then
-              (let uu___1 =
-                 match label_ctx with
-                 | FStar_Pervasives_Native.None -> "None"
-                 | FStar_Pervasives_Native.Some lc -> print_lc lc in
-               let uu___2 = print_lc ctx in
-               FStar_Compiler_Util.print2
-                 "Changing label context from %s to %s" uu___1 uu___2)
-            else ();
-            traverse_for_spinoff pol2 (FStar_Pervasives_Native.Some ctx) e1
-              t1 in
-          let should_descend t1 =
-            let uu___ = FStar_Syntax_Util.head_and_args t1 in
-            match uu___ with
-            | (hd, args) ->
-                let res =
-                  let uu___1 =
-                    let uu___2 = FStar_Syntax_Util.un_uinst hd in
-                    uu___2.FStar_Syntax_Syntax.n in
-                  match uu___1 with
-                  | FStar_Syntax_Syntax.Tm_fvar fv ->
-                      ((((FStar_Syntax_Syntax.fv_eq_lid fv
-                            FStar_Parser_Const.and_lid)
-                           ||
-                           (FStar_Syntax_Syntax.fv_eq_lid fv
-                              FStar_Parser_Const.imp_lid))
-                          ||
-                          (FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.forall_lid))
-                         ||
-                         (FStar_Syntax_Syntax.fv_eq_lid fv
-                            FStar_Parser_Const.auto_squash_lid))
-                        ||
-                        (FStar_Syntax_Syntax.fv_eq_lid fv
-                           FStar_Parser_Const.squash_lid)
-                  | FStar_Syntax_Syntax.Tm_meta uu___2 -> true
-                  | FStar_Syntax_Syntax.Tm_ascribed uu___2 -> true
-                  | FStar_Syntax_Syntax.Tm_abs uu___2 -> true
-                  | uu___2 -> false in
-                res in
-          let maybe_spinoff pol2 label_ctx1 e1 t1 =
-            let label_goal uu___ =
-              match uu___ with
-              | (env, t2) ->
-                  let t3 =
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Subst.compress t2 in
-                        uu___3.FStar_Syntax_Syntax.n in
-                      (uu___2, label_ctx1) in
-                    match uu___1 with
-                    | (FStar_Syntax_Syntax.Tm_meta
-                       (uu___2, FStar_Syntax_Syntax.Meta_labeled uu___3),
-                       uu___4) -> t2
-                    | (uu___2, FStar_Pervasives_Native.Some (msg, r)) ->
-                        FStar_TypeChecker_Util.label msg r t2
-                    | uu___2 -> t2 in
-                  let t4 =
-                    let uu___1 = FStar_Syntax_Util.is_sub_singleton t3 in
-                    if uu___1
-                    then t3
-                    else
-                      FStar_Syntax_Util.mk_auto_squash
-                        FStar_Syntax_Syntax.U_zero t3 in
-                  let uu___1 = FStar_Tactics_Types.goal_of_goal_ty env t4 in
-                  FStar_Pervasives_Native.fst uu___1 in
-            let spinoff t2 =
-              match pol2 with
-              | StrictlyPositive ->
-                  (if debug
-                   then
-                     (let uu___1 = FStar_Syntax_Print.term_to_string t2 in
-                      FStar_Compiler_Util.print1 "Spinning off %s\n" uu___1)
-                   else ();
-                   (let uu___1 =
-                      let uu___2 =
-                        let uu___3 = label_goal (e1, t2) in [uu___3] in
-                      (FStar_Syntax_Util.t_true, uu___2) in
-                    Simplified uu___1))
-              | uu___ -> Unchanged t2 in
-            let t2 = FStar_Syntax_Subst.compress t1 in
-            let uu___ =
-              let uu___1 = should_descend t2 in Prims.op_Negation uu___1 in
-            if uu___ then spinoff t2 else Unchanged t2 in
-          let rewrite_boolean_conjunction t1 =
-            let uu___ = FStar_Syntax_Util.head_and_args t1 in
-            match uu___ with
-            | (hd, args) ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Util.un_uinst hd in
-                    uu___3.FStar_Syntax_Syntax.n in
-                  (uu___2, args) in
-                (match uu___1 with
-                 | (FStar_Syntax_Syntax.Tm_fvar fv, (t2, uu___2)::[]) when
-                     FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.b2t_lid
-                     ->
-                     let uu___3 = FStar_Syntax_Util.head_and_args t2 in
-                     (match uu___3 with
-                      | (hd1, args1) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = FStar_Syntax_Util.un_uinst hd1 in
-                              uu___6.FStar_Syntax_Syntax.n in
-                            (uu___5, args1) in
-                          (match uu___4 with
-                           | (FStar_Syntax_Syntax.Tm_fvar fv1,
-                              (t0, uu___5)::(t11, uu___6)::[]) when
-                               FStar_Syntax_Syntax.fv_eq_lid fv1
-                                 FStar_Parser_Const.op_And
-                               ->
-                               let t3 =
-                                 let uu___7 = FStar_Syntax_Util.b2t t0 in
-                                 let uu___8 = FStar_Syntax_Util.b2t t11 in
-                                 FStar_Syntax_Util.mk_conj uu___7 uu___8 in
-                               FStar_Pervasives_Native.Some t3
-                           | uu___5 -> FStar_Pervasives_Native.None))
-                 | uu___2 -> FStar_Pervasives_Native.None) in
-          let try_rewrite_match env t1 =
-            let rec pat_as_exp env1 p =
-              let uu___ =
-                FStar_TypeChecker_PatternUtils.raw_pat_as_exp env1 p in
-              match uu___ with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some (e1, uu___1) ->
-                  let uu___2 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-                  (match uu___2 with
-                   | (env2, uu___3) ->
-                       let uu___4 =
-                         FStar_TypeChecker_TcTerm.tc_trivial_guard
-                           {
-                             FStar_TypeChecker_Env.solver =
-                               (env2.FStar_TypeChecker_Env.solver);
-                             FStar_TypeChecker_Env.range =
-                               (env2.FStar_TypeChecker_Env.range);
-                             FStar_TypeChecker_Env.curmodule =
-                               (env2.FStar_TypeChecker_Env.curmodule);
-                             FStar_TypeChecker_Env.gamma =
-                               (env2.FStar_TypeChecker_Env.gamma);
-                             FStar_TypeChecker_Env.gamma_sig =
-                               (env2.FStar_TypeChecker_Env.gamma_sig);
-                             FStar_TypeChecker_Env.gamma_cache =
-                               (env2.FStar_TypeChecker_Env.gamma_cache);
-                             FStar_TypeChecker_Env.modules =
-                               (env2.FStar_TypeChecker_Env.modules);
-                             FStar_TypeChecker_Env.expected_typ =
-                               (env2.FStar_TypeChecker_Env.expected_typ);
-                             FStar_TypeChecker_Env.sigtab =
-                               (env2.FStar_TypeChecker_Env.sigtab);
-                             FStar_TypeChecker_Env.attrtab =
-                               (env2.FStar_TypeChecker_Env.attrtab);
-                             FStar_TypeChecker_Env.instantiate_imp =
-                               (env2.FStar_TypeChecker_Env.instantiate_imp);
-                             FStar_TypeChecker_Env.effects =
-                               (env2.FStar_TypeChecker_Env.effects);
-                             FStar_TypeChecker_Env.generalize =
-                               (env2.FStar_TypeChecker_Env.generalize);
-                             FStar_TypeChecker_Env.letrecs =
-                               (env2.FStar_TypeChecker_Env.letrecs);
-                             FStar_TypeChecker_Env.top_level =
-                               (env2.FStar_TypeChecker_Env.top_level);
-                             FStar_TypeChecker_Env.check_uvars =
-                               (env2.FStar_TypeChecker_Env.check_uvars);
-                             FStar_TypeChecker_Env.use_eq_strict =
-                               (env2.FStar_TypeChecker_Env.use_eq_strict);
-                             FStar_TypeChecker_Env.is_iface =
-                               (env2.FStar_TypeChecker_Env.is_iface);
-                             FStar_TypeChecker_Env.admit = true;
-                             FStar_TypeChecker_Env.lax =
-                               (env2.FStar_TypeChecker_Env.lax);
-                             FStar_TypeChecker_Env.lax_universes =
-                               (env2.FStar_TypeChecker_Env.lax_universes);
-                             FStar_TypeChecker_Env.phase1 =
-                               (env2.FStar_TypeChecker_Env.phase1);
-                             FStar_TypeChecker_Env.failhard =
-                               (env2.FStar_TypeChecker_Env.failhard);
-                             FStar_TypeChecker_Env.nosynth =
-                               (env2.FStar_TypeChecker_Env.nosynth);
-                             FStar_TypeChecker_Env.uvar_subtyping =
-                               (env2.FStar_TypeChecker_Env.uvar_subtyping);
-                             FStar_TypeChecker_Env.tc_term =
-                               (env2.FStar_TypeChecker_Env.tc_term);
-                             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                               (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.universe_of =
-                               (env2.FStar_TypeChecker_Env.universe_of);
-                             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                               =
-                               (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.teq_nosmt_force =
-                               (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-                             FStar_TypeChecker_Env.subtype_nosmt_force =
-                               (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                             FStar_TypeChecker_Env.qtbl_name_and_index =
-                               (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                             FStar_TypeChecker_Env.normalized_eff_names =
-                               (env2.FStar_TypeChecker_Env.normalized_eff_names);
-                             FStar_TypeChecker_Env.fv_delta_depths =
-                               (env2.FStar_TypeChecker_Env.fv_delta_depths);
-                             FStar_TypeChecker_Env.proof_ns =
-                               (env2.FStar_TypeChecker_Env.proof_ns);
-                             FStar_TypeChecker_Env.synth_hook =
-                               (env2.FStar_TypeChecker_Env.synth_hook);
-                             FStar_TypeChecker_Env.try_solve_implicits_hook =
-                               (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                             FStar_TypeChecker_Env.splice =
-                               (env2.FStar_TypeChecker_Env.splice);
-                             FStar_TypeChecker_Env.mpreprocess =
-                               (env2.FStar_TypeChecker_Env.mpreprocess);
-                             FStar_TypeChecker_Env.postprocess =
-                               (env2.FStar_TypeChecker_Env.postprocess);
-                             FStar_TypeChecker_Env.identifier_info =
-                               (env2.FStar_TypeChecker_Env.identifier_info);
-                             FStar_TypeChecker_Env.tc_hooks =
-                               (env2.FStar_TypeChecker_Env.tc_hooks);
-                             FStar_TypeChecker_Env.dsenv =
-                               (env2.FStar_TypeChecker_Env.dsenv);
-                             FStar_TypeChecker_Env.nbe =
-                               (env2.FStar_TypeChecker_Env.nbe);
-                             FStar_TypeChecker_Env.strict_args_tab =
-                               (env2.FStar_TypeChecker_Env.strict_args_tab);
-                             FStar_TypeChecker_Env.erasable_types_tab =
-                               (env2.FStar_TypeChecker_Env.erasable_types_tab);
-                             FStar_TypeChecker_Env.enable_defer_to_tac =
-                               (env2.FStar_TypeChecker_Env.enable_defer_to_tac);
-                             FStar_TypeChecker_Env.unif_allow_ref_guards =
-                               (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                             FStar_TypeChecker_Env.erase_erasable_args =
-                               (env2.FStar_TypeChecker_Env.erase_erasable_args);
-                             FStar_TypeChecker_Env.core_check =
-                               (env2.FStar_TypeChecker_Env.core_check)
-                           } e1 in
-                       (match uu___4 with
-                        | (e2, lc) ->
-                            let u =
-                              FStar_TypeChecker_TcTerm.universe_of env2
-                                lc.FStar_TypeChecker_Common.res_typ in
-                            FStar_Pervasives_Native.Some
-                              (e2, (lc.FStar_TypeChecker_Common.res_typ), u))) in
-            let bv_universes env1 bvs =
-              FStar_Compiler_List.map
-                (fun x ->
-                   let uu___ =
-                     FStar_TypeChecker_TcTerm.universe_of env1
-                       x.FStar_Syntax_Syntax.sort in
-                   (x, uu___)) bvs in
-            let mk_forall_l bv_univs term =
-              FStar_Compiler_List.fold_right
-                (fun uu___ ->
-                   fun out ->
-                     match uu___ with
-                     | (x, u) -> FStar_Syntax_Util.mk_forall u x out)
-                bv_univs term in
-            let mk_exists_l bv_univs term =
-              FStar_Compiler_List.fold_right
-                (fun uu___ ->
-                   fun out ->
-                     match uu___ with
-                     | (x, u) -> FStar_Syntax_Util.mk_exists u x out)
-                bv_univs term in
-            if pol1 <> StrictlyPositive
-            then FStar_Pervasives_Native.None
-            else
-              (let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress t1 in
-                 uu___2.FStar_Syntax_Syntax.n in
-               match uu___1 with
-               | FStar_Syntax_Syntax.Tm_match (sc, asc_opt, brs, lopt) ->
-                   let rec rewrite_branches path_condition branches =
-                     match branches with
-                     | [] ->
-                         let uu___2 =
-                           FStar_Syntax_Util.mk_imp path_condition
-                             FStar_Syntax_Util.t_false in
-                         FStar_Pervasives.Inr uu___2
-                     | br::branches1 ->
-                         let uu___2 = FStar_Syntax_Subst.open_branch br in
-                         (match uu___2 with
-                          | (pat, w, body) ->
-                              (match w with
-                               | FStar_Pervasives_Native.Some uu___3 ->
-                                   FStar_Pervasives.Inl "when clause"
-                               | uu___3 ->
-                                   let bvs = FStar_Syntax_Syntax.pat_bvs pat in
-                                   let env1 =
-                                     FStar_TypeChecker_Env.push_bvs env bvs in
-                                   let bvs_univs = bv_universes env1 bvs in
-                                   let uu___4 = pat_as_exp env1 pat in
-                                   (match uu___4 with
-                                    | FStar_Pervasives_Native.None ->
-                                        FStar_Pervasives.Inl
-                                          "Ill-typed pattern"
-                                    | FStar_Pervasives_Native.Some
-                                        (p_e, t2, u) ->
-                                        let eqn =
-                                          FStar_Syntax_Util.mk_eq2 u t2 sc
-                                            p_e in
-                                        let branch_goal =
-                                          let uu___5 =
-                                            FStar_Syntax_Util.mk_imp eqn body in
-                                          mk_forall_l bvs_univs uu___5 in
-                                        let branch_goal1 =
-                                          FStar_Syntax_Util.mk_imp
-                                            path_condition branch_goal in
-                                        let next_path_condition =
-                                          let uu___5 =
-                                            let uu___6 =
-                                              mk_exists_l bvs_univs eqn in
-                                            FStar_Syntax_Util.mk_neg uu___6 in
-                                          FStar_Syntax_Util.mk_conj
-                                            path_condition uu___5 in
-                                        let uu___5 =
-                                          rewrite_branches
-                                            next_path_condition branches1 in
-                                        (match uu___5 with
-                                         | FStar_Pervasives.Inl msg ->
-                                             FStar_Pervasives.Inl msg
-                                         | FStar_Pervasives.Inr rest ->
-                                             let uu___6 =
-                                               FStar_Syntax_Util.mk_conj
-                                                 branch_goal1 rest in
-                                             FStar_Pervasives.Inr uu___6)))) in
-                   let res = rewrite_branches FStar_Syntax_Util.t_true brs in
-                   (match res with
-                    | FStar_Pervasives.Inl msg ->
-                        (if debug_any
-                         then
-                           (let uu___3 = FStar_TypeChecker_Env.get_range env in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Syntax_Print.term_to_string t1 in
-                              FStar_Compiler_Util.format2
-                                "Failed to split match term because %s (%s)"
-                                msg uu___5 in
-                            FStar_Errors.diag uu___3 uu___4)
-                         else ();
-                         FStar_Pervasives_Native.None)
-                    | FStar_Pervasives.Inr res1 ->
-                        (if debug_any
-                         then
-                           (let uu___3 = FStar_TypeChecker_Env.get_range env in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Syntax_Print.term_to_string t1 in
-                              let uu___6 =
-                                FStar_Syntax_Print.term_to_string res1 in
-                              FStar_Compiler_Util.format2
-                                "Rewrote match term\n%s\ninto %s\n" uu___5
-                                uu___6 in
-                            FStar_Errors.diag uu___3 uu___4)
-                         else ();
-                         FStar_Pervasives_Native.Some res1))
-               | uu___2 -> FStar_Pervasives_Native.None) in
-          let maybe_rewrite_term t1 =
-            if pol1 <> StrictlyPositive
-            then FStar_Pervasives_Native.None
-            else
-              (let uu___1 = rewrite_boolean_conjunction t1 in
-               match uu___1 with
-               | FStar_Pervasives_Native.Some t2 ->
-                   FStar_Pervasives_Native.Some t2
-               | FStar_Pervasives_Native.None -> try_rewrite_match e t1) in
-          let uu___ = maybe_rewrite_term t in
-          match uu___ with
-          | FStar_Pervasives_Native.Some t1 -> traverse1 pol1 e t1
-          | uu___1 ->
-              let r =
-                let t1 = FStar_Syntax_Subst.compress t in
-                let uu___2 =
-                  let uu___3 = should_descend t1 in Prims.op_Negation uu___3 in
-                if uu___2
-                then tpure t1.FStar_Syntax_Syntax.n
-                else
-                  (match t1.FStar_Syntax_Syntax.n with
-                   | FStar_Syntax_Syntax.Tm_uinst (t2, us) ->
-                       let tr = traverse1 pol1 e t2 in
-                       let uu___4 =
-                         comb1
-                           (fun t' -> FStar_Syntax_Syntax.Tm_uinst (t', us)) in
-                       uu___4 tr
-                   | FStar_Syntax_Syntax.Tm_meta
-                       (t2, FStar_Syntax_Syntax.Meta_labeled
-                        (msg, r1, uu___4))
-                       ->
-                       let tr = traverse_ctx pol1 (msg, r1) e t2 in
-                       let uu___5 =
-                         comb1
-                           (fun t' ->
-                              FStar_Syntax_Syntax.Tm_meta
-                                (t',
-                                  (FStar_Syntax_Syntax.Meta_labeled
-                                     (msg, r1, false)))) in
-                       uu___5 tr
-                   | FStar_Syntax_Syntax.Tm_meta (t2, m) ->
-                       let tr = traverse1 pol1 e t2 in
-                       let uu___4 =
-                         comb1
-                           (fun t' -> FStar_Syntax_Syntax.Tm_meta (t', m)) in
-                       uu___4 tr
-                   | FStar_Syntax_Syntax.Tm_ascribed (t2, asc, ef) ->
-                       let uu___4 = traverse1 pol1 e t2 in
-                       let uu___5 =
-                         comb1
-                           (fun t3 ->
-                              FStar_Syntax_Syntax.Tm_ascribed (t3, asc, ef)) in
-                       uu___5 uu___4
-                   | FStar_Syntax_Syntax.Tm_app
-                       ({
-                          FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                            fv;
-                          FStar_Syntax_Syntax.pos = uu___4;
-                          FStar_Syntax_Syntax.vars = uu___5;
-                          FStar_Syntax_Syntax.hash_code = uu___6;_},
-                        (p, uu___7)::(q, uu___8)::[])
-                       when
-                       FStar_Syntax_Syntax.fv_eq_lid fv
-                         FStar_Parser_Const.imp_lid
-                       ->
-                       let x =
-                         FStar_Syntax_Syntax.new_bv
-                           FStar_Pervasives_Native.None p in
-                       let r1 = traverse1 (flip pol1) e p in
-                       let r2 =
-                         let uu___9 = FStar_TypeChecker_Env.push_bv e x in
-                         traverse1 pol1 uu___9 q in
-                       comb2
-                         (fun l ->
-                            fun r3 ->
-                              let uu___9 = FStar_Syntax_Util.mk_imp l r3 in
-                              uu___9.FStar_Syntax_Syntax.n) r1 r2
-                   | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 = FStar_Syntax_Util.un_uinst hd in
-                           uu___6.FStar_Syntax_Syntax.n in
-                         (uu___5, args) in
-                       (match uu___4 with
-                        | (FStar_Syntax_Syntax.Tm_fvar fv,
-                           (t2, FStar_Pervasives_Native.Some aq0)::(body, aq)::[])
-                            when
-                            ((FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.forall_lid)
-                               ||
-                               (FStar_Syntax_Syntax.fv_eq_lid fv
-                                  FStar_Parser_Const.exists_lid))
-                              && aq0.FStar_Syntax_Syntax.aqual_implicit
-                            ->
-                            let r0 = traverse1 pol1 e hd in
-                            let rt = traverse1 (flip pol1) e t2 in
-                            let rbody = traverse1 pol1 e body in
-                            let rargs =
-                              comb2
-                                (fun t3 ->
-                                   fun body1 ->
-                                     [(t3,
-                                        (FStar_Pervasives_Native.Some aq0));
-                                     (body1, aq)]) rt rbody in
-                            comb2
-                              (fun hd1 ->
-                                 fun args1 ->
-                                   FStar_Syntax_Syntax.Tm_app (hd1, args1))
-                              r0 rargs
-                        | uu___5 ->
-                            let r0 = traverse1 pol1 e hd in
-                            let r1 =
-                              FStar_Compiler_List.fold_right
-                                (fun uu___6 ->
-                                   fun r2 ->
-                                     match uu___6 with
-                                     | (a, q) ->
-                                         let r' = traverse1 pol1 e a in
-                                         comb2
-                                           (fun a1 ->
-                                              fun args1 -> (a1, q) :: args1)
-                                           r' r2) args (tpure []) in
-                            let simplified =
-                              (uu___is_Simplified r0) ||
-                                (uu___is_Simplified r1) in
-                            comb2
-                              (fun hd1 ->
-                                 fun args1 ->
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         FStar_Syntax_Util.un_uinst hd1 in
-                                       uu___8.FStar_Syntax_Syntax.n in
-                                     (uu___7, args1) in
-                                   match uu___6 with
-                                   | (FStar_Syntax_Syntax.Tm_fvar fv,
-                                      (t2, uu___7)::[]) when
-                                       (simplified &&
-                                          (FStar_Syntax_Syntax.fv_eq_lid fv
-                                             FStar_Parser_Const.squash_lid))
-                                         &&
-                                         (let uu___8 =
-                                            FStar_Syntax_Util.eq_tm t2
-                                              FStar_Syntax_Util.t_true in
-                                          uu___8 = FStar_Syntax_Util.Equal)
-                                       ->
-                                       (if debug
-                                        then
-                                          FStar_Compiler_Util.print_string
-                                            "Simplified squash True to True"
-                                        else ();
-                                        FStar_Syntax_Util.t_true.FStar_Syntax_Syntax.n)
-                                   | uu___7 ->
-                                       let t' =
-                                         FStar_Syntax_Syntax.Tm_app
-                                           (hd1, args1) in
-                                       t') r0 r1)
-                   | FStar_Syntax_Syntax.Tm_abs (bs, t2, k) ->
-                       let uu___4 = FStar_Syntax_Subst.open_term bs t2 in
-                       (match uu___4 with
-                        | (bs1, topen) ->
-                            let e' = FStar_TypeChecker_Env.push_binders e bs1 in
-                            let r0 =
-                              FStar_Compiler_List.map
-                                (fun b ->
-                                   let r1 =
-                                     traverse1 (flip pol1) e
-                                       (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                   let uu___5 =
-                                     comb1
-                                       (fun s' ->
-                                          {
-                                            FStar_Syntax_Syntax.binder_bv =
-                                              (let uu___6 =
-                                                 b.FStar_Syntax_Syntax.binder_bv in
-                                               {
-                                                 FStar_Syntax_Syntax.ppname =
-                                                   (uu___6.FStar_Syntax_Syntax.ppname);
-                                                 FStar_Syntax_Syntax.index =
-                                                   (uu___6.FStar_Syntax_Syntax.index);
-                                                 FStar_Syntax_Syntax.sort =
-                                                   s'
-                                               });
-                                            FStar_Syntax_Syntax.binder_qual =
-                                              (b.FStar_Syntax_Syntax.binder_qual);
-                                            FStar_Syntax_Syntax.binder_attrs
-                                              =
-                                              (b.FStar_Syntax_Syntax.binder_attrs)
-                                          }) in
-                                   uu___5 r1) bs1 in
-                            let rbs = comb_list r0 in
-                            let rt = traverse1 pol1 e' topen in
-                            comb2
-                              (fun bs2 ->
-                                 fun t3 ->
-                                   let uu___5 =
-                                     FStar_Syntax_Util.abs bs2 t3 k in
-                                   uu___5.FStar_Syntax_Syntax.n) rbs rt)
-                   | x -> tpure x) in
-              (match r with
-               | Unchanged tn' ->
-                   maybe_spinoff pol1 label_ctx e
-                     {
-                       FStar_Syntax_Syntax.n = tn';
-                       FStar_Syntax_Syntax.pos = (t.FStar_Syntax_Syntax.pos);
-                       FStar_Syntax_Syntax.vars =
-                         (t.FStar_Syntax_Syntax.vars);
-                       FStar_Syntax_Syntax.hash_code =
-                         (t.FStar_Syntax_Syntax.hash_code)
-                     }
-               | Simplified (tn', gs) ->
-                   let uu___2 =
-                     maybe_spinoff pol1 label_ctx e
-                       {
-                         FStar_Syntax_Syntax.n = tn';
-                         FStar_Syntax_Syntax.pos =
-                           (t.FStar_Syntax_Syntax.pos);
-                         FStar_Syntax_Syntax.vars =
-                           (t.FStar_Syntax_Syntax.vars);
-                         FStar_Syntax_Syntax.hash_code =
-                           (t.FStar_Syntax_Syntax.hash_code)
-                       } in
-                   emit gs uu___2
-               | Dual (tn, tp, gs) ->
-                   let rp =
-                     maybe_spinoff pol1 label_ctx e
-                       {
-                         FStar_Syntax_Syntax.n = tp;
-                         FStar_Syntax_Syntax.pos =
-                           (t.FStar_Syntax_Syntax.pos);
-                         FStar_Syntax_Syntax.vars =
-                           (t.FStar_Syntax_Syntax.vars);
-                         FStar_Syntax_Syntax.hash_code =
-                           (t.FStar_Syntax_Syntax.hash_code)
-                       } in
-                   let uu___2 = explode rp in
-                   (match uu___2 with
-                    | (uu___3, p', gs') ->
-                        Dual
-                          ({
-                             FStar_Syntax_Syntax.n = tn;
-                             FStar_Syntax_Syntax.pos =
-                               (t.FStar_Syntax_Syntax.pos);
-                             FStar_Syntax_Syntax.vars =
-                               (t.FStar_Syntax_Syntax.vars);
-                             FStar_Syntax_Syntax.hash_code =
-                               (t.FStar_Syntax_Syntax.hash_code)
-                           }, p', (FStar_Compiler_List.op_At gs gs'))))
-let (pol_to_string : pol -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | StrictlyPositive -> "StrictlyPositive"
-    | Pos -> "Positive"
-    | Neg -> "Negative"
-    | Both -> "Both"
-let (spinoff_strictly_positive_goals :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.term) Prims.list)
-  =
-  fun env ->
-    fun goal ->
-      let debug =
-        FStar_TypeChecker_Env.debug env (FStar_Options.Other "SpinoffAll") in
-      if debug
-      then
-        (let uu___1 = FStar_Syntax_Print.term_to_string goal in
-         FStar_Compiler_Util.print1 "spinoff_all called with %s\n" uu___1)
-      else ();
-      FStar_Errors.with_ctx "While spinning off all goals"
-        (fun uu___1 ->
-           let initial = (Prims.int_one, []) in
-           let uu___2 =
-             let uu___3 =
-               traverse_for_spinoff StrictlyPositive
-                 FStar_Pervasives_Native.None env goal in
-             match uu___3 with
-             | Unchanged t' -> (t', [])
-             | Simplified (t', gs) -> (t', gs)
-             | uu___4 ->
-                 failwith "preprocess: impossible, traverse returned a Dual" in
-           match uu___2 with
-           | (t', gs) ->
-               let t'1 =
-                 FStar_TypeChecker_Normalize.normalize
-                   [FStar_TypeChecker_Env.Eager_unfolding;
-                   FStar_TypeChecker_Env.Simplify;
-                   FStar_TypeChecker_Env.Primops] env t' in
-               let main_goal =
-                 let t = FStar_TypeChecker_Common.check_trivial t'1 in
-                 match t with
-                 | FStar_TypeChecker_Common.Trivial -> []
-                 | FStar_TypeChecker_Common.NonTrivial t1 ->
-                     (if debug
-                      then
-                        (let msg =
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_TypeChecker_Env.all_binders env in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___5
-                               (FStar_Syntax_Print.binders_to_string ", ") in
-                           let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                           FStar_Compiler_Util.format2
-                             "Main goal simplified to: %s |- %s\n" uu___4
-                             uu___5 in
-                         let uu___4 = FStar_TypeChecker_Env.get_range env in
-                         let uu___5 =
-                           FStar_Compiler_Util.format1
-                             "Verification condition was to be split into several atomic sub-goals, but this query had some sub-goals that couldn't be split---the error report, if any, may be inaccurate.\n%s\n"
-                             msg in
-                         FStar_Errors.diag uu___4 uu___5)
-                      else ();
-                      [(env, t1)]) in
-               let s = initial in
-               let s1 =
-                 FStar_Compiler_List.fold_left
-                   (fun uu___3 ->
-                      fun g ->
-                        match uu___3 with
-                        | (n, gs1) ->
-                            let phi = FStar_Tactics_Types.goal_type g in
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 = FStar_Tactics_Types.goal_env g in
-                                (uu___6, phi) in
-                              uu___5 :: gs1 in
-                            ((n + Prims.int_one), uu___4)) s gs in
-               let uu___3 = s1 in
-               (match uu___3 with
-                | (uu___4, gs1) ->
-                    let gs2 = FStar_Compiler_List.rev gs1 in
-                    let gs3 =
-                      FStar_Compiler_Effect.op_Bar_Greater gs2
-                        (FStar_Compiler_List.filter_map
-                           (fun uu___5 ->
-                              match uu___5 with
-                              | (env1, t) ->
-                                  let t1 =
-                                    FStar_TypeChecker_Normalize.normalize
-                                      [FStar_TypeChecker_Env.Eager_unfolding;
-                                      FStar_TypeChecker_Env.Simplify;
-                                      FStar_TypeChecker_Env.Primops] env1 t in
-                                  let uu___6 =
-                                    FStar_TypeChecker_Common.check_trivial t1 in
-                                  (match uu___6 with
-                                   | FStar_TypeChecker_Common.Trivial ->
-                                       FStar_Pervasives_Native.None
-                                   | FStar_TypeChecker_Common.NonTrivial t2
-                                       ->
-                                       (if debug
-                                        then
-                                          (let uu___8 =
-                                             FStar_Syntax_Print.term_to_string
-                                               t2 in
-                                           FStar_Compiler_Util.print1
-                                             "Got goal: %s\n" uu___8)
-                                        else ();
-                                        FStar_Pervasives_Native.Some
-                                          (env1, t2))))) in
-                    ((let uu___6 = FStar_TypeChecker_Env.get_range env in
-                      let uu___7 =
-                        let uu___8 =
-                          FStar_Compiler_Util.string_of_int
-                            (FStar_Compiler_List.length gs3) in
-                        FStar_Compiler_Util.format1
-                          "Split query into %s sub-goals" uu___8 in
-                      FStar_Errors.diag uu___6 uu___7);
-                     FStar_Compiler_List.op_At main_goal gs3)))
-let (synthesize :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun typ ->
-      fun tau ->
-        FStar_Errors.with_ctx "While synthesizing term with a tactic"
-          (fun uu___ ->
-             if env.FStar_TypeChecker_Env.nosynth
-             then
-               let uu___1 =
-                 FStar_TypeChecker_Util.fvar_const env
-                   FStar_Parser_Const.magic_lid in
-               let uu___2 =
-                 let uu___3 =
-                   FStar_Syntax_Syntax.as_arg FStar_Syntax_Util.exp_unit in
-                 [uu___3] in
-               FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2
-                 typ.FStar_Syntax_Syntax.pos
-             else
-               ((let uu___3 =
-                   FStar_TypeChecker_Env.debug env
-                     (FStar_Options.Other "Tac") in
-                 FStar_Compiler_Effect.op_Colon_Equals
-                   FStar_Tactics_Interpreter.tacdbg uu___3);
-                (let uu___3 =
-                   run_tactic_on_typ tau.FStar_Syntax_Syntax.pos
-                     typ.FStar_Syntax_Syntax.pos tau env typ in
-                 match uu___3 with
-                 | (gs, w) ->
-                     (FStar_Compiler_List.iter
-                        (fun g ->
-                           let uu___5 =
-                             let uu___6 = FStar_Tactics_Types.goal_env g in
-                             let uu___7 = FStar_Tactics_Types.goal_type g in
-                             getprop uu___6 uu___7 in
-                           match uu___5 with
-                           | FStar_Pervasives_Native.Some vc ->
-                               ((let uu___7 =
-                                   FStar_Compiler_Effect.op_Bang
-                                     FStar_Tactics_Interpreter.tacdbg in
-                                 if uu___7
-                                 then
-                                   let uu___8 =
-                                     FStar_Syntax_Print.term_to_string vc in
-                                   FStar_Compiler_Util.print1
-                                     "Synthesis left a goal: %s\n" uu___8
-                                 else ());
-                                (let guard =
-                                   {
-                                     FStar_TypeChecker_Common.guard_f =
-                                       (FStar_TypeChecker_Common.NonTrivial
-                                          vc);
-                                     FStar_TypeChecker_Common.deferred_to_tac
-                                       = [];
-                                     FStar_TypeChecker_Common.deferred = [];
-                                     FStar_TypeChecker_Common.univ_ineqs =
-                                       ([], []);
-                                     FStar_TypeChecker_Common.implicits = []
-                                   } in
-                                 let uu___7 = FStar_Tactics_Types.goal_env g in
-                                 FStar_TypeChecker_Rel.force_trivial_guard
-                                   uu___7 guard))
-                           | FStar_Pervasives_Native.None ->
-                               FStar_Errors.raise_error
-                                 (FStar_Errors.Fatal_OpenGoalsInSynthesis,
-                                   "synthesis left open goals")
-                                 typ.FStar_Syntax_Syntax.pos) gs;
-                      w))))
-let (solve_implicits :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_TypeChecker_Env.implicits -> unit)
-  =
-  fun env ->
-    fun tau ->
-      fun imps ->
-        FStar_Errors.with_ctx "While solving implicits with a tactic"
-          (fun uu___ ->
-             if env.FStar_TypeChecker_Env.nosynth
-             then ()
-             else
-               ((let uu___3 =
-                   FStar_TypeChecker_Env.debug env
-                     (FStar_Options.Other "Tac") in
-                 FStar_Compiler_Effect.op_Colon_Equals
-                   FStar_Tactics_Interpreter.tacdbg uu___3);
-                (let gs =
-                   let uu___3 = FStar_TypeChecker_Env.get_range env in
-                   run_tactic_on_all_implicits tau.FStar_Syntax_Syntax.pos
-                     uu___3 tau env imps in
-                 (let uu___4 =
-                    FStar_Options.profile_enabled
-                      FStar_Pervasives_Native.None "FStar.TypeChecker" in
-                  if uu___4
-                  then
-                    let uu___5 =
-                      FStar_Compiler_Util.string_of_int
-                        (FStar_Compiler_List.length gs) in
-                    FStar_Compiler_Util.print1
-                      "solve_implicits produced %s goals\n" uu___5
-                  else ());
-                 FStar_Options.with_saved_options
-                   (fun uu___4 ->
-                      let uu___5 = FStar_Options.set_options "--no_tactics" in
-                      FStar_Compiler_Effect.op_Bar_Greater gs
-                        (FStar_Compiler_List.iter
-                           (fun g ->
-                              let uu___6 =
-                                let uu___7 = FStar_Tactics_Types.goal_env g in
-                                let uu___8 = FStar_Tactics_Types.goal_type g in
-                                getprop uu___7 uu___8 in
-                              match uu___6 with
-                              | FStar_Pervasives_Native.Some vc ->
-                                  ((let uu___8 =
-                                      FStar_Compiler_Effect.op_Bang
-                                        FStar_Tactics_Interpreter.tacdbg in
-                                    if uu___8
-                                    then
-                                      let uu___9 =
-                                        FStar_Syntax_Print.term_to_string vc in
-                                      FStar_Compiler_Util.print1
-                                        "Synthesis left a goal: %s\n" uu___9
-                                    else ());
-                                   (let uu___8 =
-                                      let uu___9 =
-                                        FStar_Options.admit_smt_queries () in
-                                      Prims.op_Negation uu___9 in
-                                    if uu___8
-                                    then
-                                      let guard =
-                                        {
-                                          FStar_TypeChecker_Common.guard_f =
-                                            (FStar_TypeChecker_Common.NonTrivial
-                                               vc);
-                                          FStar_TypeChecker_Common.deferred_to_tac
-                                            = [];
-                                          FStar_TypeChecker_Common.deferred =
-                                            [];
-                                          FStar_TypeChecker_Common.univ_ineqs
-                                            = ([], []);
-                                          FStar_TypeChecker_Common.implicits
-                                            = []
-                                        } in
-                                      FStar_Profiling.profile
-                                        (fun uu___9 ->
-                                           let uu___10 =
-                                             FStar_Tactics_Types.goal_env g in
-                                           FStar_TypeChecker_Rel.force_trivial_guard
-                                             uu___10 guard)
-                                        FStar_Pervasives_Native.None
-                                        "FStar.TypeChecker.Hooks.force_trivial_guard"
-                                    else ()))
-                              | FStar_Pervasives_Native.None ->
-                                  let uu___7 =
-                                    FStar_TypeChecker_Env.get_range env in
-                                  FStar_Errors.raise_error
-                                    (FStar_Errors.Fatal_OpenGoalsInSynthesis,
-                                      "synthesis left open goals") uu___7))))))
-let (find_user_tac_for_attr :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun a ->
-      let hooks =
-        FStar_TypeChecker_Env.lookup_attr env
-          FStar_Parser_Const.handle_smt_goals_attr_string in
-      FStar_Compiler_Effect.op_Bar_Greater hooks
-        (FStar_Compiler_Util.try_find (fun uu___ -> true))
-let (handle_smt_goal :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Env.goal ->
-      (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.term) Prims.list)
-  =
-  fun env ->
-    fun goal ->
-      let uu___ = FStar_TypeChecker_Common.check_trivial goal in
-      match uu___ with
-      | FStar_TypeChecker_Common.Trivial -> [(env, goal)]
-      | FStar_TypeChecker_Common.NonTrivial goal1 ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Syntax_Syntax.tconst
-                FStar_Parser_Const.handle_smt_goals_attr in
-            find_user_tac_for_attr env uu___2 in
-          (match uu___1 with
-           | FStar_Pervasives_Native.Some tac ->
-               let tau =
-                 match tac.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_let (uu___2, lid::[]) ->
-                     let qn = FStar_TypeChecker_Env.lookup_qname env lid in
-                     let fv =
-                       FStar_Syntax_Syntax.lid_as_fv lid
-                         (FStar_Syntax_Syntax.Delta_constant_at_level
-                            Prims.int_zero) FStar_Pervasives_Native.None in
-                     let dd =
-                       let uu___3 =
-                         FStar_TypeChecker_Env.delta_depth_of_qninfo fv qn in
-                       match uu___3 with
-                       | FStar_Pervasives_Native.Some dd1 -> dd1
-                       | FStar_Pervasives_Native.None ->
-                           failwith "Expected a dd" in
-                     let uu___3 =
-                       FStar_Syntax_Syntax.lid_as_fv lid dd
-                         FStar_Pervasives_Native.None in
-                     FStar_Syntax_Syntax.fv_to_tm uu___3
-                 | uu___2 -> failwith "Resolve_tac not found" in
-               let gs =
-                 FStar_Errors.with_ctx
-                   "While handling an SMT goal with a tactic"
-                   (fun uu___2 ->
-                      (let uu___4 =
-                         FStar_TypeChecker_Env.debug env
-                           (FStar_Options.Other "Tac") in
-                       FStar_Compiler_Effect.op_Colon_Equals
-                         FStar_Tactics_Interpreter.tacdbg uu___4);
-                      (let uu___4 =
-                         let uu___5 = FStar_TypeChecker_Env.get_range env in
-                         let uu___6 =
-                           FStar_Syntax_Util.mk_squash
-                             FStar_Syntax_Syntax.U_zero goal1 in
-                         run_tactic_on_typ tau.FStar_Syntax_Syntax.pos uu___5
-                           tau env uu___6 in
-                       match uu___4 with
-                       | (gs1, uu___5) ->
-                           FStar_Compiler_Effect.op_Bar_Greater gs1
-                             (FStar_Compiler_List.map
-                                (fun g ->
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_Tactics_Types.goal_env g in
-                                     let uu___8 =
-                                       FStar_Tactics_Types.goal_type g in
-                                     getprop uu___7 uu___8 in
-                                   match uu___6 with
-                                   | FStar_Pervasives_Native.Some vc ->
-                                       ((let uu___8 =
-                                           FStar_Compiler_Effect.op_Bang
-                                             FStar_Tactics_Interpreter.tacdbg in
-                                         if uu___8
-                                         then
-                                           let uu___9 =
-                                             FStar_Syntax_Print.term_to_string
-                                               vc in
-                                           FStar_Compiler_Util.print1
-                                             "handle_smt_goals left a goal: %s\n"
-                                             uu___9
-                                         else ());
-                                        (let uu___8 =
-                                           FStar_Tactics_Types.goal_env g in
-                                         (uu___8, vc)))
-                                   | FStar_Pervasives_Native.None ->
-                                       let uu___7 =
-                                         FStar_TypeChecker_Env.get_range env in
-                                       FStar_Errors.raise_error
-                                         (FStar_Errors.Fatal_OpenGoalsInSynthesis,
-                                           "Handling an SMT goal by tactic left non-prop open goals")
-                                         uu___7)))) in
-               gs
-           | FStar_Pervasives_Native.None -> [(env, goal1)])
-let (splice :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun env ->
-    fun rng ->
-      fun tau ->
-        FStar_Errors.with_ctx "While running splice with a tactic"
-          (fun uu___ ->
-             if env.FStar_TypeChecker_Env.nosynth
-             then []
-             else
-               ((let uu___3 =
-                   FStar_TypeChecker_Env.debug env
-                     (FStar_Options.Other "Tac") in
-                 FStar_Compiler_Effect.op_Colon_Equals
-                   FStar_Tactics_Interpreter.tacdbg uu___3);
-                (let typ = FStar_Syntax_Syntax.t_decls in
-                 let ps =
-                   FStar_Tactics_Basic.proofstate_of_goals
-                     tau.FStar_Syntax_Syntax.pos env [] [] in
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Syntax_Embeddings.e_list
-                       FStar_Reflection_Embeddings.e_sigelt in
-                   FStar_Tactics_Interpreter.run_tactic_on_ps
-                     tau.FStar_Syntax_Syntax.pos tau.FStar_Syntax_Syntax.pos
-                     false FStar_Syntax_Embeddings.e_unit () uu___4 tau ps in
-                 match uu___3 with
-                 | (gs, sigelts) ->
-                     ((let uu___5 =
-                         FStar_Compiler_List.existsML
-                           (fun g ->
-                              let uu___6 =
-                                let uu___7 =
-                                  let uu___8 = FStar_Tactics_Types.goal_env g in
-                                  let uu___9 =
-                                    FStar_Tactics_Types.goal_type g in
-                                  getprop uu___8 uu___9 in
-                                FStar_Compiler_Option.isSome uu___7 in
-                              Prims.op_Negation uu___6) gs in
-                       if uu___5
-                       then
-                         FStar_Errors.raise_error
-                           (FStar_Errors.Fatal_OpenGoalsInSynthesis,
-                             "splice left open goals")
-                           typ.FStar_Syntax_Syntax.pos
-                       else ());
-                      (let uu___6 =
-                         FStar_Compiler_Effect.op_Bang
-                           FStar_Tactics_Interpreter.tacdbg in
-                       if uu___6
-                       then
-                         let uu___7 =
-                           (FStar_Common.string_of_list ())
-                             FStar_Syntax_Print.sigelt_to_string sigelts in
-                         FStar_Compiler_Util.print1
-                           "splice: got decls = {\n\n%s\n\n}\n" uu___7
-                       else ());
-                      (let sigelts1 =
-                         FStar_Compiler_Effect.op_Bar_Greater sigelts
-                           (FStar_Compiler_List.map
-                              (fun se ->
-                                 (match se.FStar_Syntax_Syntax.sigel with
-                                  | FStar_Syntax_Syntax.Sig_datacon uu___7 ->
-                                      let uu___8 =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            FStar_Syntax_Print.sigelt_to_string_short
-                                              se in
-                                          FStar_Compiler_Util.format1
-                                            "Tactic returned bad sigelt: %s\nIf you wanted to splice an inductive type, call `pack` providing a `Sg_Inductive` to get a proper sigelt."
-                                            uu___10 in
-                                        (FStar_Errors.Error_BadSplice,
-                                          uu___9) in
-                                      FStar_Errors.raise_error uu___8 rng
-                                  | FStar_Syntax_Syntax.Sig_inductive_typ
-                                      uu___7 ->
-                                      let uu___8 =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            FStar_Syntax_Print.sigelt_to_string_short
-                                              se in
-                                          FStar_Compiler_Util.format1
-                                            "Tactic returned bad sigelt: %s\nIf you wanted to splice an inductive type, call `pack` providing a `Sg_Inductive` to get a proper sigelt."
-                                            uu___10 in
-                                        (FStar_Errors.Error_BadSplice,
-                                          uu___9) in
-                                      FStar_Errors.raise_error uu___8 rng
-                                  | uu___7 -> ());
-                                 {
-                                   FStar_Syntax_Syntax.sigel =
-                                     (se.FStar_Syntax_Syntax.sigel);
-                                   FStar_Syntax_Syntax.sigrng = rng;
-                                   FStar_Syntax_Syntax.sigquals =
-                                     (se.FStar_Syntax_Syntax.sigquals);
-                                   FStar_Syntax_Syntax.sigmeta =
-                                     (se.FStar_Syntax_Syntax.sigmeta);
-                                   FStar_Syntax_Syntax.sigattrs =
-                                     (se.FStar_Syntax_Syntax.sigattrs);
-                                   FStar_Syntax_Syntax.sigopts =
-                                     (se.FStar_Syntax_Syntax.sigopts)
-                                 })) in
-                       sigelts1)))))
-let (mpreprocess :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun tau ->
-      fun tm ->
-        FStar_Errors.with_ctx
-          "While preprocessing a definition with a tactic"
-          (fun uu___ ->
-             if env.FStar_TypeChecker_Env.nosynth
-             then tm
-             else
-               ((let uu___3 =
-                   FStar_TypeChecker_Env.debug env
-                     (FStar_Options.Other "Tac") in
-                 FStar_Compiler_Effect.op_Colon_Equals
-                   FStar_Tactics_Interpreter.tacdbg uu___3);
-                (let ps =
-                   FStar_Tactics_Basic.proofstate_of_goals
-                     tm.FStar_Syntax_Syntax.pos env [] [] in
-                 let uu___3 =
-                   FStar_Tactics_Interpreter.run_tactic_on_ps
-                     tau.FStar_Syntax_Syntax.pos tm.FStar_Syntax_Syntax.pos
-                     false FStar_Reflection_Embeddings.e_term tm
-                     FStar_Reflection_Embeddings.e_term tau ps in
-                 match uu___3 with | (gs, tm1) -> tm1)))
-let (postprocess :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun tau ->
-      fun typ ->
-        fun tm ->
-          FStar_Errors.with_ctx
-            "While postprocessing a definition with a tactic"
-            (fun uu___ ->
-               if env.FStar_TypeChecker_Env.nosynth
-               then tm
-               else
-                 ((let uu___3 =
-                     FStar_TypeChecker_Env.debug env
-                       (FStar_Options.Other "Tac") in
-                   FStar_Compiler_Effect.op_Colon_Equals
-                     FStar_Tactics_Interpreter.tacdbg uu___3);
-                  (let uu___3 =
-                     FStar_TypeChecker_Env.new_implicit_var_aux
-                       "postprocess RHS" tm.FStar_Syntax_Syntax.pos env typ
-                       (FStar_Syntax_Syntax.Allow_untyped "postprocess")
-                       FStar_Pervasives_Native.None in
-                   match uu___3 with
-                   | (uvtm, uu___4, g_imp) ->
-                       let u = env.FStar_TypeChecker_Env.universe_of env typ in
-                       let goal =
-                         let uu___5 = FStar_Syntax_Util.mk_eq2 u typ tm uvtm in
-                         FStar_Syntax_Util.mk_squash
-                           FStar_Syntax_Syntax.U_zero uu___5 in
-                       let uu___5 =
-                         run_tactic_on_typ tau.FStar_Syntax_Syntax.pos
-                           tm.FStar_Syntax_Syntax.pos tau env goal in
-                       (match uu___5 with
-                        | (gs, w) ->
-                            (FStar_Compiler_List.iter
-                               (fun g ->
-                                  let uu___7 =
-                                    let uu___8 =
-                                      FStar_Tactics_Types.goal_env g in
-                                    let uu___9 =
-                                      FStar_Tactics_Types.goal_type g in
-                                    getprop uu___8 uu___9 in
-                                  match uu___7 with
-                                  | FStar_Pervasives_Native.Some vc ->
-                                      ((let uu___9 =
-                                          FStar_Compiler_Effect.op_Bang
-                                            FStar_Tactics_Interpreter.tacdbg in
-                                        if uu___9
-                                        then
-                                          let uu___10 =
-                                            FStar_Syntax_Print.term_to_string
-                                              vc in
-                                          FStar_Compiler_Util.print1
-                                            "Postprocessing left a goal: %s\n"
-                                            uu___10
-                                        else ());
-                                       (let guard =
-                                          {
-                                            FStar_TypeChecker_Common.guard_f
-                                              =
-                                              (FStar_TypeChecker_Common.NonTrivial
-                                                 vc);
-                                            FStar_TypeChecker_Common.deferred_to_tac
-                                              = [];
-                                            FStar_TypeChecker_Common.deferred
-                                              = [];
-                                            FStar_TypeChecker_Common.univ_ineqs
-                                              = ([], []);
-                                            FStar_TypeChecker_Common.implicits
-                                              = []
-                                          } in
-                                        let uu___9 =
-                                          FStar_Tactics_Types.goal_env g in
-                                        FStar_TypeChecker_Rel.force_trivial_guard
-                                          uu___9 guard))
-                                  | FStar_Pervasives_Native.None ->
-                                      FStar_Errors.raise_error
-                                        (FStar_Errors.Fatal_OpenGoalsInSynthesis,
-                                          "postprocessing left open goals")
-                                        typ.FStar_Syntax_Syntax.pos) gs;
-                             (let tagged_imps =
-                                FStar_TypeChecker_Rel.resolve_implicits_tac
-                                  env g_imp in
-                              FStar_Tactics_Interpreter.report_implicits
-                                tm.FStar_Syntax_Syntax.pos tagged_imps;
-                              uvtm))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_InterpFuns.ml b/src/ocaml-output/FStar_Tactics_InterpFuns.ml
deleted file mode 100644
index 9a943517395..00000000000
--- a/src/ocaml-output/FStar_Tactics_InterpFuns.ml
+++ /dev/null
@@ -1,16951 +0,0 @@
-open Prims
-let unembed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Embeddings.norm_cb ->
-          'uuuuu FStar_Pervasives_Native.option
-  =
-  fun e ->
-    fun t ->
-      fun n ->
-        let uu___ = FStar_Syntax_Embeddings.unembed e t in uu___ true n
-let embed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Compiler_Range.range ->
-        'uuuuu -> FStar_Syntax_Embeddings.norm_cb -> FStar_Syntax_Syntax.term
-  =
-  fun e ->
-    fun rng ->
-      fun t ->
-        fun n ->
-          let uu___ = FStar_Syntax_Embeddings.embed e t in
-          uu___ rng FStar_Pervasives_Native.None n
-let rec drop : 'uuuuu . Prims.int -> 'uuuuu Prims.list -> 'uuuuu Prims.list =
-  fun n ->
-    fun l ->
-      if n = Prims.int_zero
-      then l
-      else
-        (match l with
-         | [] -> failwith "drop: impossible"
-         | uu___1::xs -> drop (n - Prims.int_one) xs)
-let timing_int :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 .
-    FStar_Ident.lid ->
-      ('uuuuu -> 'uuuuu1 -> 'uuuuu2 -> 'uuuuu3) ->
-        'uuuuu -> 'uuuuu1 -> 'uuuuu2 -> 'uuuuu3
-  =
-  fun l ->
-    fun f -> fun psc -> fun cb -> fun args -> let r = f psc cb args in r
-let timing_nbe :
-  'uuuuu 'uuuuu1 'uuuuu2 .
-    FStar_Ident.lid ->
-      ('uuuuu -> 'uuuuu1 -> 'uuuuu2) -> 'uuuuu -> 'uuuuu1 -> 'uuuuu2
-  = fun l -> fun f -> fun nbe_cbs -> fun args -> let r = f nbe_cbs args in r
-let (mk :
-  Prims.string ->
-    Prims.int ->
-      Prims.int ->
-        (FStar_TypeChecker_Cfg.psc ->
-           FStar_Syntax_Embeddings.norm_cb ->
-             FStar_Syntax_Syntax.args ->
-               FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-          ->
-          (FStar_TypeChecker_NBETerm.nbe_cbs ->
-             FStar_TypeChecker_NBETerm.args ->
-               FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option)
-            -> FStar_TypeChecker_Cfg.primitive_step)
-  =
-  fun nm ->
-    fun arity ->
-      fun nunivs ->
-        fun interp ->
-          fun nbe_interp ->
-            let nm1 = FStar_Parser_Const.fstar_tactics_lid' ["Builtins"; nm] in
-            {
-              FStar_TypeChecker_Cfg.name = nm1;
-              FStar_TypeChecker_Cfg.arity = arity;
-              FStar_TypeChecker_Cfg.univ_arity = nunivs;
-              FStar_TypeChecker_Cfg.auto_reflect =
-                (FStar_Pervasives_Native.Some (arity - Prims.int_one));
-              FStar_TypeChecker_Cfg.strong_reduction_ok = true;
-              FStar_TypeChecker_Cfg.requires_binder_substitution = true;
-              FStar_TypeChecker_Cfg.interpretation =
-                (fun psc ->
-                   fun cbs ->
-                     fun _us ->
-                       fun args -> timing_int nm1 interp psc cbs args);
-              FStar_TypeChecker_Cfg.interpretation_nbe =
-                (fun cbs ->
-                   fun _us -> fun args -> timing_nbe nm1 nbe_interp cbs args)
-            }
-let (mkt :
-  Prims.string ->
-    Prims.int ->
-      Prims.int ->
-        (FStar_TypeChecker_Cfg.psc ->
-           FStar_Syntax_Embeddings.norm_cb ->
-             FStar_Syntax_Syntax.args ->
-               FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-          ->
-          (FStar_TypeChecker_NBETerm.nbe_cbs ->
-             FStar_TypeChecker_NBETerm.args ->
-               FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option)
-            -> FStar_TypeChecker_Cfg.primitive_step)
-  =
-  fun nm ->
-    fun arity ->
-      fun nunivs ->
-        fun interp ->
-          fun nbe_interp ->
-            let nm1 = FStar_Parser_Const.fstar_tactics_lid' ["Builtins"; nm] in
-            {
-              FStar_TypeChecker_Cfg.name = nm1;
-              FStar_TypeChecker_Cfg.arity = arity;
-              FStar_TypeChecker_Cfg.univ_arity = nunivs;
-              FStar_TypeChecker_Cfg.auto_reflect =
-                FStar_Pervasives_Native.None;
-              FStar_TypeChecker_Cfg.strong_reduction_ok = true;
-              FStar_TypeChecker_Cfg.requires_binder_substitution = true;
-              FStar_TypeChecker_Cfg.interpretation =
-                (fun psc ->
-                   fun cbs ->
-                     fun _us ->
-                       fun args -> timing_int nm1 interp psc cbs args);
-              FStar_TypeChecker_Cfg.interpretation_nbe =
-                (fun cbs ->
-                   fun _us -> fun args -> timing_nbe nm1 nbe_interp cbs args)
-            }
-let mk_total_interpretation_1_psc :
-  'r 't1 .
-    (FStar_TypeChecker_Cfg.psc -> 't1 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        'r FStar_Syntax_Embeddings.embedding ->
-          FStar_TypeChecker_Cfg.psc ->
-            FStar_Syntax_Embeddings.norm_cb ->
-              FStar_Syntax_Syntax.args ->
-                FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun er ->
-        fun psc ->
-          fun ncb ->
-            fun args ->
-              match args with
-              | (a1, uu___)::[] ->
-                  let uu___1 = unembed e1 a1 ncb in
-                  FStar_Compiler_Util.bind_opt uu___1
-                    (fun a11 ->
-                       let r1 = f psc a11 in
-                       let uu___2 =
-                         let uu___3 = FStar_TypeChecker_Cfg.psc_range psc in
-                         embed er uu___3 r1 ncb in
-                       FStar_Pervasives_Native.Some uu___2)
-              | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_1_psc :
-  'r 't1 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      (FStar_TypeChecker_Cfg.psc -> 't1 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          'r FStar_TypeChecker_NBETerm.embedding ->
-            FStar_TypeChecker_NBETerm.args ->
-              FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun er ->
-          fun args ->
-            match args with
-            | (a1, uu___)::[] ->
-                let uu___1 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                FStar_Compiler_Util.bind_opt uu___1
-                  (fun a11 ->
-                     let r1 = f FStar_TypeChecker_Cfg.null_psc a11 in
-                     let uu___2 = FStar_TypeChecker_NBETerm.embed er cb r1 in
-                     FStar_Pervasives_Native.Some uu___2)
-            | uu___ -> FStar_Pervasives_Native.None
-let mk_total_step_1_psc :
-  'a 'na 'nr 'r .
-    Prims.int ->
-      Prims.string ->
-        (FStar_TypeChecker_Cfg.psc -> 'a -> 'r) ->
-          'a FStar_Syntax_Embeddings.embedding ->
-            'r FStar_Syntax_Embeddings.embedding ->
-              (FStar_TypeChecker_Cfg.psc -> 'na -> 'nr) ->
-                'na FStar_TypeChecker_NBETerm.embedding ->
-                  'nr FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun ea ->
-          fun er ->
-            fun nf ->
-              fun nea ->
-                fun ner ->
-                  mkt name Prims.int_one nunivs
-                    (mk_total_interpretation_1_psc f ea er)
-                    (fun cb ->
-                       fun args ->
-                         let uu___ = drop nunivs args in
-                         mk_total_nbe_interpretation_1_psc cb nf nea ner
-                           uu___)
-let (max_tac_arity : Prims.int) = (Prims.of_int (20))
-let mk_tactic_interpretation_1 :
-  'r 't1 .
-    ('t1 -> 'r FStar_Tactics_Monad.tac) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        'r FStar_Syntax_Embeddings.embedding ->
-          FStar_TypeChecker_Cfg.psc ->
-            FStar_Syntax_Embeddings.norm_cb ->
-              FStar_Syntax_Syntax.args ->
-                FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun er ->
-        fun psc ->
-          fun ncb ->
-            fun args ->
-              match args with
-              | (a1, uu___)::(a2, uu___1)::[] ->
-                  let uu___2 = unembed e1 a1 ncb in
-                  FStar_Compiler_Util.bind_opt uu___2
-                    (fun a11 ->
-                       let uu___3 =
-                         unembed FStar_Tactics_Embedding.e_proofstate a2 ncb in
-                       FStar_Compiler_Util.bind_opt uu___3
-                         (fun ps ->
-                            let ps1 = FStar_Tactics_Types.set_ps_psc psc ps in
-                            let r1 =
-                              let uu___4 = t a11 in
-                              FStar_Tactics_Monad.run_safe uu___4 ps1 in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Tactics_Embedding.e_result er in
-                              let uu___6 =
-                                FStar_TypeChecker_Cfg.psc_range psc in
-                              embed uu___5 uu___6 r1 ncb in
-                            FStar_Pervasives_Native.Some uu___4))
-              | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_2 :
-  'r 't1 't2 .
-    ('t1 -> 't2 -> 'r FStar_Tactics_Monad.tac) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          'r FStar_Syntax_Embeddings.embedding ->
-            FStar_TypeChecker_Cfg.psc ->
-              FStar_Syntax_Embeddings.norm_cb ->
-                FStar_Syntax_Syntax.args ->
-                  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun er ->
-          fun psc ->
-            fun ncb ->
-              fun args ->
-                match args with
-                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::[] ->
-                    let uu___3 = unembed e1 a1 ncb in
-                    FStar_Compiler_Util.bind_opt uu___3
-                      (fun a11 ->
-                         let uu___4 = unembed e2 a2 ncb in
-                         FStar_Compiler_Util.bind_opt uu___4
-                           (fun a21 ->
-                              let uu___5 =
-                                unembed FStar_Tactics_Embedding.e_proofstate
-                                  a3 ncb in
-                              FStar_Compiler_Util.bind_opt uu___5
-                                (fun ps ->
-                                   let ps1 =
-                                     FStar_Tactics_Types.set_ps_psc psc ps in
-                                   let r1 =
-                                     let uu___6 = t a11 a21 in
-                                     FStar_Tactics_Monad.run_safe uu___6 ps1 in
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_Tactics_Embedding.e_result er in
-                                     let uu___8 =
-                                       FStar_TypeChecker_Cfg.psc_range psc in
-                                     embed uu___7 uu___8 r1 ncb in
-                                   FStar_Pervasives_Native.Some uu___6)))
-                | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_3 :
-  'r 't1 't2 't3 .
-    ('t1 -> 't2 -> 't3 -> 'r FStar_Tactics_Monad.tac) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            'r FStar_Syntax_Embeddings.embedding ->
-              FStar_TypeChecker_Cfg.psc ->
-                FStar_Syntax_Embeddings.norm_cb ->
-                  FStar_Syntax_Syntax.args ->
-                    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun er ->
-            fun psc ->
-              fun ncb ->
-                fun args ->
-                  match args with
-                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::[]
-                      ->
-                      let uu___4 = unembed e1 a1 ncb in
-                      FStar_Compiler_Util.bind_opt uu___4
-                        (fun a11 ->
-                           let uu___5 = unembed e2 a2 ncb in
-                           FStar_Compiler_Util.bind_opt uu___5
-                             (fun a21 ->
-                                let uu___6 = unembed e3 a3 ncb in
-                                FStar_Compiler_Util.bind_opt uu___6
-                                  (fun a31 ->
-                                     let uu___7 =
-                                       unembed
-                                         FStar_Tactics_Embedding.e_proofstate
-                                         a4 ncb in
-                                     FStar_Compiler_Util.bind_opt uu___7
-                                       (fun ps ->
-                                          let ps1 =
-                                            FStar_Tactics_Types.set_ps_psc
-                                              psc ps in
-                                          let r1 =
-                                            let uu___8 = t a11 a21 a31 in
-                                            FStar_Tactics_Monad.run_safe
-                                              uu___8 ps1 in
-                                          let uu___8 =
-                                            let uu___9 =
-                                              FStar_Tactics_Embedding.e_result
-                                                er in
-                                            let uu___10 =
-                                              FStar_TypeChecker_Cfg.psc_range
-                                                psc in
-                                            embed uu___9 uu___10 r1 ncb in
-                                          FStar_Pervasives_Native.Some uu___8))))
-                  | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_4 :
-  'r 't1 't2 't3 't4 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 'r FStar_Tactics_Monad.tac) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              'r FStar_Syntax_Embeddings.embedding ->
-                FStar_TypeChecker_Cfg.psc ->
-                  FStar_Syntax_Embeddings.norm_cb ->
-                    FStar_Syntax_Syntax.args ->
-                      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun er ->
-              fun psc ->
-                fun ncb ->
-                  fun args ->
-                    match args with
-                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                        (a5, uu___4)::[] ->
-                        let uu___5 = unembed e1 a1 ncb in
-                        FStar_Compiler_Util.bind_opt uu___5
-                          (fun a11 ->
-                             let uu___6 = unembed e2 a2 ncb in
-                             FStar_Compiler_Util.bind_opt uu___6
-                               (fun a21 ->
-                                  let uu___7 = unembed e3 a3 ncb in
-                                  FStar_Compiler_Util.bind_opt uu___7
-                                    (fun a31 ->
-                                       let uu___8 = unembed e4 a4 ncb in
-                                       FStar_Compiler_Util.bind_opt uu___8
-                                         (fun a41 ->
-                                            let uu___9 =
-                                              unembed
-                                                FStar_Tactics_Embedding.e_proofstate
-                                                a5 ncb in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___9
-                                              (fun ps ->
-                                                 let ps1 =
-                                                   FStar_Tactics_Types.set_ps_psc
-                                                     psc ps in
-                                                 let r1 =
-                                                   let uu___10 =
-                                                     t a11 a21 a31 a41 in
-                                                   FStar_Tactics_Monad.run_safe
-                                                     uu___10 ps1 in
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     FStar_Tactics_Embedding.e_result
-                                                       er in
-                                                   let uu___12 =
-                                                     FStar_TypeChecker_Cfg.psc_range
-                                                       psc in
-                                                   embed uu___11 uu___12 r1
-                                                     ncb in
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___10)))))
-                    | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_5 :
-  'r 't1 't2 't3 't4 't5 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 'r FStar_Tactics_Monad.tac) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                'r FStar_Syntax_Embeddings.embedding ->
-                  FStar_TypeChecker_Cfg.psc ->
-                    FStar_Syntax_Embeddings.norm_cb ->
-                      FStar_Syntax_Syntax.args ->
-                        FStar_Syntax_Syntax.term
-                          FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun er ->
-                fun psc ->
-                  fun ncb ->
-                    fun args ->
-                      match args with
-                      | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                          (a5, uu___4)::(a6, uu___5)::[] ->
-                          let uu___6 = unembed e1 a1 ncb in
-                          FStar_Compiler_Util.bind_opt uu___6
-                            (fun a11 ->
-                               let uu___7 = unembed e2 a2 ncb in
-                               FStar_Compiler_Util.bind_opt uu___7
-                                 (fun a21 ->
-                                    let uu___8 = unembed e3 a3 ncb in
-                                    FStar_Compiler_Util.bind_opt uu___8
-                                      (fun a31 ->
-                                         let uu___9 = unembed e4 a4 ncb in
-                                         FStar_Compiler_Util.bind_opt uu___9
-                                           (fun a41 ->
-                                              let uu___10 = unembed e5 a5 ncb in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___10
-                                                (fun a51 ->
-                                                   let uu___11 =
-                                                     unembed
-                                                       FStar_Tactics_Embedding.e_proofstate
-                                                       a6 ncb in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___11
-                                                     (fun ps ->
-                                                        let ps1 =
-                                                          FStar_Tactics_Types.set_ps_psc
-                                                            psc ps in
-                                                        let r1 =
-                                                          let uu___12 =
-                                                            t a11 a21 a31 a41
-                                                              a51 in
-                                                          FStar_Tactics_Monad.run_safe
-                                                            uu___12 ps1 in
-                                                        let uu___12 =
-                                                          let uu___13 =
-                                                            FStar_Tactics_Embedding.e_result
-                                                              er in
-                                                          let uu___14 =
-                                                            FStar_TypeChecker_Cfg.psc_range
-                                                              psc in
-                                                          embed uu___13
-                                                            uu___14 r1 ncb in
-                                                        FStar_Pervasives_Native.Some
-                                                          uu___12))))))
-                      | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_6 :
-  'r 't1 't2 't3 't4 't5 't6 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 'r FStar_Tactics_Monad.tac) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  'r FStar_Syntax_Embeddings.embedding ->
-                    FStar_TypeChecker_Cfg.psc ->
-                      FStar_Syntax_Embeddings.norm_cb ->
-                        FStar_Syntax_Syntax.args ->
-                          FStar_Syntax_Syntax.term
-                            FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun er ->
-                  fun psc ->
-                    fun ncb ->
-                      fun args ->
-                        match args with
-                        | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4,
-                                                                    uu___3)::
-                            (a5, uu___4)::(a6, uu___5)::(a7, uu___6)::[] ->
-                            let uu___7 = unembed e1 a1 ncb in
-                            FStar_Compiler_Util.bind_opt uu___7
-                              (fun a11 ->
-                                 let uu___8 = unembed e2 a2 ncb in
-                                 FStar_Compiler_Util.bind_opt uu___8
-                                   (fun a21 ->
-                                      let uu___9 = unembed e3 a3 ncb in
-                                      FStar_Compiler_Util.bind_opt uu___9
-                                        (fun a31 ->
-                                           let uu___10 = unembed e4 a4 ncb in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___10
-                                             (fun a41 ->
-                                                let uu___11 =
-                                                  unembed e5 a5 ncb in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___11
-                                                  (fun a51 ->
-                                                     let uu___12 =
-                                                       unembed e6 a6 ncb in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___12
-                                                       (fun a61 ->
-                                                          let uu___13 =
-                                                            unembed
-                                                              FStar_Tactics_Embedding.e_proofstate
-                                                              a7 ncb in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___13
-                                                            (fun ps ->
-                                                               let ps1 =
-                                                                 FStar_Tactics_Types.set_ps_psc
-                                                                   psc ps in
-                                                               let r1 =
-                                                                 let uu___14
-                                                                   =
-                                                                   t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61 in
-                                                                 FStar_Tactics_Monad.run_safe
-                                                                   uu___14
-                                                                   ps1 in
-                                                               let uu___14 =
-                                                                 let uu___15
-                                                                   =
-                                                                   FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                 let uu___16
-                                                                   =
-                                                                   FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                 embed
-                                                                   uu___15
-                                                                   uu___16 r1
-                                                                   ncb in
-                                                               FStar_Pervasives_Native.Some
-                                                                 uu___14)))))))
-                        | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_7 :
-  'r 't1 't2 't3 't4 't5 't6 't7 .
-    ('t1 ->
-       't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    'r FStar_Syntax_Embeddings.embedding ->
-                      FStar_TypeChecker_Cfg.psc ->
-                        FStar_Syntax_Embeddings.norm_cb ->
-                          FStar_Syntax_Syntax.args ->
-                            FStar_Syntax_Syntax.term
-                              FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun er ->
-                    fun psc ->
-                      fun ncb ->
-                        fun args ->
-                          match args with
-                          | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                              (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                              (a7, uu___6)::(a8, uu___7)::[] ->
-                              let uu___8 = unembed e1 a1 ncb in
-                              FStar_Compiler_Util.bind_opt uu___8
-                                (fun a11 ->
-                                   let uu___9 = unembed e2 a2 ncb in
-                                   FStar_Compiler_Util.bind_opt uu___9
-                                     (fun a21 ->
-                                        let uu___10 = unembed e3 a3 ncb in
-                                        FStar_Compiler_Util.bind_opt uu___10
-                                          (fun a31 ->
-                                             let uu___11 = unembed e4 a4 ncb in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___11
-                                               (fun a41 ->
-                                                  let uu___12 =
-                                                    unembed e5 a5 ncb in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___12
-                                                    (fun a51 ->
-                                                       let uu___13 =
-                                                         unembed e6 a6 ncb in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___13
-                                                         (fun a61 ->
-                                                            let uu___14 =
-                                                              unembed e7 a7
-                                                                ncb in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___14
-                                                              (fun a71 ->
-                                                                 let uu___15
-                                                                   =
-                                                                   unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a8 ncb in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___15
-                                                                   (fun ps ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___16
-                                                                    =
-                                                                    t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___16
-                                                                    ps1 in
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___17
-                                                                    uu___18
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___16))))))))
-                          | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_8 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 .
-    ('t1 ->
-       't2 ->
-         't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      'r FStar_Syntax_Embeddings.embedding ->
-                        FStar_TypeChecker_Cfg.psc ->
-                          FStar_Syntax_Embeddings.norm_cb ->
-                            FStar_Syntax_Syntax.args ->
-                              FStar_Syntax_Syntax.term
-                                FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun er ->
-                      fun psc ->
-                        fun ncb ->
-                          fun args ->
-                            match args with
-                            | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::[]
-                                ->
-                                let uu___9 = unembed e1 a1 ncb in
-                                FStar_Compiler_Util.bind_opt uu___9
-                                  (fun a11 ->
-                                     let uu___10 = unembed e2 a2 ncb in
-                                     FStar_Compiler_Util.bind_opt uu___10
-                                       (fun a21 ->
-                                          let uu___11 = unembed e3 a3 ncb in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___11
-                                            (fun a31 ->
-                                               let uu___12 =
-                                                 unembed e4 a4 ncb in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___12
-                                                 (fun a41 ->
-                                                    let uu___13 =
-                                                      unembed e5 a5 ncb in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___13
-                                                      (fun a51 ->
-                                                         let uu___14 =
-                                                           unembed e6 a6 ncb in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___14
-                                                           (fun a61 ->
-                                                              let uu___15 =
-                                                                unembed e7 a7
-                                                                  ncb in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___15
-                                                                (fun a71 ->
-                                                                   let uu___16
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___16
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___17
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___18
-                                                                    =
-                                                                    t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___18
-                                                                    ps1 in
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___19
-                                                                    uu___20
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___18)))))))))
-                            | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_9 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        'r FStar_Syntax_Embeddings.embedding ->
-                          FStar_TypeChecker_Cfg.psc ->
-                            FStar_Syntax_Embeddings.norm_cb ->
-                              FStar_Syntax_Syntax.args ->
-                                FStar_Syntax_Syntax.term
-                                  FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun er ->
-                        fun psc ->
-                          fun ncb ->
-                            fun args ->
-                              match args with
-                              | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                  (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                  (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                  (a10, uu___9)::[] ->
-                                  let uu___10 = unembed e1 a1 ncb in
-                                  FStar_Compiler_Util.bind_opt uu___10
-                                    (fun a11 ->
-                                       let uu___11 = unembed e2 a2 ncb in
-                                       FStar_Compiler_Util.bind_opt uu___11
-                                         (fun a21 ->
-                                            let uu___12 = unembed e3 a3 ncb in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___12
-                                              (fun a31 ->
-                                                 let uu___13 =
-                                                   unembed e4 a4 ncb in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___13
-                                                   (fun a41 ->
-                                                      let uu___14 =
-                                                        unembed e5 a5 ncb in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___14
-                                                        (fun a51 ->
-                                                           let uu___15 =
-                                                             unembed e6 a6
-                                                               ncb in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___15
-                                                             (fun a61 ->
-                                                                let uu___16 =
-                                                                  unembed e7
-                                                                    a7 ncb in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___16
-                                                                  (fun a71 ->
-                                                                    let uu___17
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a10 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___20
-                                                                    =
-                                                                    t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___20
-                                                                    ps1 in
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___21
-                                                                    uu___22
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___20))))))))))
-                              | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_10 :
-  'r 't1 't10 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          'r FStar_Syntax_Embeddings.embedding ->
-                            FStar_TypeChecker_Cfg.psc ->
-                              FStar_Syntax_Embeddings.norm_cb ->
-                                FStar_Syntax_Syntax.args ->
-                                  FStar_Syntax_Syntax.term
-                                    FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun er ->
-                          fun psc ->
-                            fun ncb ->
-                              fun args ->
-                                match args with
-                                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                    (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                    (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                    (a10, uu___9)::(a11, uu___10)::[] ->
-                                    let uu___11 = unembed e1 a1 ncb in
-                                    FStar_Compiler_Util.bind_opt uu___11
-                                      (fun a12 ->
-                                         let uu___12 = unembed e2 a2 ncb in
-                                         FStar_Compiler_Util.bind_opt uu___12
-                                           (fun a21 ->
-                                              let uu___13 = unembed e3 a3 ncb in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___13
-                                                (fun a31 ->
-                                                   let uu___14 =
-                                                     unembed e4 a4 ncb in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___14
-                                                     (fun a41 ->
-                                                        let uu___15 =
-                                                          unembed e5 a5 ncb in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___15
-                                                          (fun a51 ->
-                                                             let uu___16 =
-                                                               unembed e6 a6
-                                                                 ncb in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___16
-                                                               (fun a61 ->
-                                                                  let uu___17
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (
-                                                                    fun a71
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a11 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___22
-                                                                    =
-                                                                    t a12 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___22
-                                                                    ps1 in
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___23
-                                                                    uu___24
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___22)))))))))))
-                                | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_11 :
-  'r 't1 't10 't11 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 -> 't9 -> 't10 -> 't11 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            'r FStar_Syntax_Embeddings.embedding ->
-                              FStar_TypeChecker_Cfg.psc ->
-                                FStar_Syntax_Embeddings.norm_cb ->
-                                  FStar_Syntax_Syntax.args ->
-                                    FStar_Syntax_Syntax.term
-                                      FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun er ->
-                            fun psc ->
-                              fun ncb ->
-                                fun args ->
-                                  match args with
-                                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                      (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                      (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                   uu___8)::
-                                      (a10, uu___9)::(a11, uu___10)::
-                                      (a12, uu___11)::[] ->
-                                      let uu___12 = unembed e1 a1 ncb in
-                                      FStar_Compiler_Util.bind_opt uu___12
-                                        (fun a13 ->
-                                           let uu___13 = unembed e2 a2 ncb in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___13
-                                             (fun a21 ->
-                                                let uu___14 =
-                                                  unembed e3 a3 ncb in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___14
-                                                  (fun a31 ->
-                                                     let uu___15 =
-                                                       unembed e4 a4 ncb in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___15
-                                                       (fun a41 ->
-                                                          let uu___16 =
-                                                            unembed e5 a5 ncb in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___16
-                                                            (fun a51 ->
-                                                               let uu___17 =
-                                                                 unembed e6
-                                                                   a6 ncb in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___17
-                                                                 (fun a61 ->
-                                                                    let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a12 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___24
-                                                                    =
-                                                                    t a13 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___24
-                                                                    ps1 in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___25
-                                                                    uu___26
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24))))))))))))
-                                  | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_12 :
-  'r 't1 't10 't11 't12 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 -> 't11 -> 't12 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              'r FStar_Syntax_Embeddings.embedding ->
-                                FStar_TypeChecker_Cfg.psc ->
-                                  FStar_Syntax_Embeddings.norm_cb ->
-                                    FStar_Syntax_Syntax.args ->
-                                      FStar_Syntax_Syntax.term
-                                        FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun er ->
-                              fun psc ->
-                                fun ncb ->
-                                  fun args ->
-                                    match args with
-                                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                        (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                        (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                    uu___8)::
-                                        (a10, uu___9)::(a11, uu___10)::
-                                        (a12, uu___11)::(a13, uu___12)::[] ->
-                                        let uu___13 = unembed e1 a1 ncb in
-                                        FStar_Compiler_Util.bind_opt uu___13
-                                          (fun a14 ->
-                                             let uu___14 = unembed e2 a2 ncb in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___14
-                                               (fun a21 ->
-                                                  let uu___15 =
-                                                    unembed e3 a3 ncb in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___15
-                                                    (fun a31 ->
-                                                       let uu___16 =
-                                                         unembed e4 a4 ncb in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___16
-                                                         (fun a41 ->
-                                                            let uu___17 =
-                                                              unembed e5 a5
-                                                                ncb in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___17
-                                                              (fun a51 ->
-                                                                 let uu___18
-                                                                   =
-                                                                   unembed e6
-                                                                    a6 ncb in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___18
-                                                                   (fun a61
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a13 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___26
-                                                                    =
-                                                                    t a14 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___26
-                                                                    ps1 in
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___27
-                                                                    uu___28
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___26)))))))))))))
-                                    | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_13 :
-  'r 't1 't10 't11 't12 't13 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 -> 't12 -> 't13 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                'r FStar_Syntax_Embeddings.embedding ->
-                                  FStar_TypeChecker_Cfg.psc ->
-                                    FStar_Syntax_Embeddings.norm_cb ->
-                                      FStar_Syntax_Syntax.args ->
-                                        FStar_Syntax_Syntax.term
-                                          FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun er ->
-                                fun psc ->
-                                  fun ncb ->
-                                    fun args ->
-                                      match args with
-                                      | (a1, uu___)::(a2, uu___1)::(a3,
-                                                                    uu___2)::
-                                          (a4, uu___3)::(a5, uu___4)::
-                                          (a6, uu___5)::(a7, uu___6)::
-                                          (a8, uu___7)::(a9, uu___8)::
-                                          (a10, uu___9)::(a11, uu___10)::
-                                          (a12, uu___11)::(a13, uu___12)::
-                                          (a14, uu___13)::[] ->
-                                          let uu___14 = unembed e1 a1 ncb in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___14
-                                            (fun a15 ->
-                                               let uu___15 =
-                                                 unembed e2 a2 ncb in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___15
-                                                 (fun a21 ->
-                                                    let uu___16 =
-                                                      unembed e3 a3 ncb in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___16
-                                                      (fun a31 ->
-                                                         let uu___17 =
-                                                           unembed e4 a4 ncb in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___17
-                                                           (fun a41 ->
-                                                              let uu___18 =
-                                                                unembed e5 a5
-                                                                  ncb in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___18
-                                                                (fun a51 ->
-                                                                   let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a14 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___28
-                                                                    =
-                                                                    t a15 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___28
-                                                                    ps1 in
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___29
-                                                                    uu___30
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___28))))))))))))))
-                                      | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_interpretation_14 :
-  'r 't1 't10 't11 't12 't13 't14 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 -> 't13 -> 't14 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  'r FStar_Syntax_Embeddings.embedding ->
-                                    FStar_TypeChecker_Cfg.psc ->
-                                      FStar_Syntax_Embeddings.norm_cb ->
-                                        FStar_Syntax_Syntax.args ->
-                                          FStar_Syntax_Syntax.term
-                                            FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun er ->
-                                  fun psc ->
-                                    fun ncb ->
-                                      fun args ->
-                                        match args with
-                                        | (a1, uu___)::(a2, uu___1)::
-                                            (a3, uu___2)::(a4, uu___3)::
-                                            (a5, uu___4)::(a6, uu___5)::
-                                            (a7, uu___6)::(a8, uu___7)::
-                                            (a9, uu___8)::(a10, uu___9)::
-                                            (a11, uu___10)::(a12, uu___11)::
-                                            (a13, uu___12)::(a14, uu___13)::
-                                            (a15, uu___14)::[] ->
-                                            let uu___15 = unembed e1 a1 ncb in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___15
-                                              (fun a16 ->
-                                                 let uu___16 =
-                                                   unembed e2 a2 ncb in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___16
-                                                   (fun a21 ->
-                                                      let uu___17 =
-                                                        unembed e3 a3 ncb in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___17
-                                                        (fun a31 ->
-                                                           let uu___18 =
-                                                             unembed e4 a4
-                                                               ncb in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___18
-                                                             (fun a41 ->
-                                                                let uu___19 =
-                                                                  unembed e5
-                                                                    a5 ncb in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___19
-                                                                  (fun a51 ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a15 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___30
-                                                                    =
-                                                                    t a16 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___30
-                                                                    ps1 in
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___31
-                                                                    uu___32
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___30)))))))))))))))
-                                        | uu___ ->
-                                            FStar_Pervasives_Native.None
-let mk_tactic_interpretation_15 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 -> 't15 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    'r FStar_Syntax_Embeddings.embedding ->
-                                      FStar_TypeChecker_Cfg.psc ->
-                                        FStar_Syntax_Embeddings.norm_cb ->
-                                          FStar_Syntax_Syntax.args ->
-                                            FStar_Syntax_Syntax.term
-                                              FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun er ->
-                                    fun psc ->
-                                      fun ncb ->
-                                        fun args ->
-                                          match args with
-                                          | (a1, uu___)::(a2, uu___1)::
-                                              (a3, uu___2)::(a4, uu___3)::
-                                              (a5, uu___4)::(a6, uu___5)::
-                                              (a7, uu___6)::(a8, uu___7)::
-                                              (a9, uu___8)::(a10, uu___9)::
-                                              (a11, uu___10)::(a12, uu___11)::
-                                              (a13, uu___12)::(a14, uu___13)::
-                                              (a15, uu___14)::(a16, uu___15)::[]
-                                              ->
-                                              let uu___16 = unembed e1 a1 ncb in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___16
-                                                (fun a17 ->
-                                                   let uu___17 =
-                                                     unembed e2 a2 ncb in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___17
-                                                     (fun a21 ->
-                                                        let uu___18 =
-                                                          unembed e3 a3 ncb in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___18
-                                                          (fun a31 ->
-                                                             let uu___19 =
-                                                               unembed e4 a4
-                                                                 ncb in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___19
-                                                               (fun a41 ->
-                                                                  let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (
-                                                                    fun a51
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a16 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___32
-                                                                    =
-                                                                    t a17 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___32
-                                                                    ps1 in
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___33
-                                                                    uu___34
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___32))))))))))))))))
-                                          | uu___ ->
-                                              FStar_Pervasives_Native.None
-let mk_tactic_interpretation_16 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 -> 't16 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      'r FStar_Syntax_Embeddings.embedding ->
-                                        FStar_TypeChecker_Cfg.psc ->
-                                          FStar_Syntax_Embeddings.norm_cb ->
-                                            FStar_Syntax_Syntax.args ->
-                                              FStar_Syntax_Syntax.term
-                                                FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun er ->
-                                      fun psc ->
-                                        fun ncb ->
-                                          fun args ->
-                                            match args with
-                                            | (a1, uu___)::(a2, uu___1)::
-                                                (a3, uu___2)::(a4, uu___3)::
-                                                (a5, uu___4)::(a6, uu___5)::
-                                                (a7, uu___6)::(a8, uu___7)::
-                                                (a9, uu___8)::(a10, uu___9)::
-                                                (a11, uu___10)::(a12,
-                                                                 uu___11)::
-                                                (a13, uu___12)::(a14,
-                                                                 uu___13)::
-                                                (a15, uu___14)::(a16,
-                                                                 uu___15)::
-                                                (a17, uu___16)::[] ->
-                                                let uu___17 =
-                                                  unembed e1 a1 ncb in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___17
-                                                  (fun a18 ->
-                                                     let uu___18 =
-                                                       unembed e2 a2 ncb in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___18
-                                                       (fun a21 ->
-                                                          let uu___19 =
-                                                            unembed e3 a3 ncb in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___19
-                                                            (fun a31 ->
-                                                               let uu___20 =
-                                                                 unembed e4
-                                                                   a4 ncb in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___20
-                                                                 (fun a41 ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a17 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___34
-                                                                    =
-                                                                    t a18 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___34
-                                                                    ps1 in
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___35
-                                                                    uu___36
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___34)))))))))))))))))
-                                            | uu___ ->
-                                                FStar_Pervasives_Native.None
-let mk_tactic_interpretation_17 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't2 't3 't4 't5 't6 't7 't8
-    't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 ->
-                                   't16 -> 't17 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        'r FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          FStar_TypeChecker_Cfg.psc ->
-                                            FStar_Syntax_Embeddings.norm_cb
-                                              ->
-                                              FStar_Syntax_Syntax.args ->
-                                                FStar_Syntax_Syntax.term
-                                                  FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun er ->
-                                        fun psc ->
-                                          fun ncb ->
-                                            fun args ->
-                                              match args with
-                                              | (a1, uu___)::(a2, uu___1)::
-                                                  (a3, uu___2)::(a4, uu___3)::
-                                                  (a5, uu___4)::(a6, uu___5)::
-                                                  (a7, uu___6)::(a8, uu___7)::
-                                                  (a9, uu___8)::(a10, uu___9)::
-                                                  (a11, uu___10)::(a12,
-                                                                   uu___11)::
-                                                  (a13, uu___12)::(a14,
-                                                                   uu___13)::
-                                                  (a15, uu___14)::(a16,
-                                                                   uu___15)::
-                                                  (a17, uu___16)::(a18,
-                                                                   uu___17)::[]
-                                                  ->
-                                                  let uu___18 =
-                                                    unembed e1 a1 ncb in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___18
-                                                    (fun a19 ->
-                                                       let uu___19 =
-                                                         unembed e2 a2 ncb in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___19
-                                                         (fun a21 ->
-                                                            let uu___20 =
-                                                              unembed e3 a3
-                                                                ncb in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___20
-                                                              (fun a31 ->
-                                                                 let uu___21
-                                                                   =
-                                                                   unembed e4
-                                                                    a4 ncb in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___21
-                                                                   (fun a41
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a18 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___36
-                                                                    =
-                                                                    t a19 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161
-                                                                    a171 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___36
-                                                                    ps1 in
-                                                                    let uu___36
-                                                                    =
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___37
-                                                                    uu___38
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___36))))))))))))))))))
-                                              | uu___ ->
-                                                  FStar_Pervasives_Native.None
-let mk_tactic_interpretation_18 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't2 't3 't4 't5 't6 't7
-    't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 ->
-                                   't16 ->
-                                     't17 ->
-                                       't18 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't18
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          'r
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            FStar_TypeChecker_Cfg.psc ->
-                                              FStar_Syntax_Embeddings.norm_cb
-                                                ->
-                                                FStar_Syntax_Syntax.args ->
-                                                  FStar_Syntax_Syntax.term
-                                                    FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun e18 ->
-                                        fun er ->
-                                          fun psc ->
-                                            fun ncb ->
-                                              fun args ->
-                                                match args with
-                                                | (a1, uu___)::(a2, uu___1)::
-                                                    (a3, uu___2)::(a4,
-                                                                   uu___3)::
-                                                    (a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                                    (a7, uu___6)::(a8,
-                                                                   uu___7)::
-                                                    (a9, uu___8)::(a10,
-                                                                   uu___9)::
-                                                    (a11, uu___10)::(a12,
-                                                                    uu___11)::
-                                                    (a13, uu___12)::(a14,
-                                                                    uu___13)::
-                                                    (a15, uu___14)::(a16,
-                                                                    uu___15)::
-                                                    (a17, uu___16)::(a18,
-                                                                    uu___17)::
-                                                    (a19, uu___18)::[] ->
-                                                    let uu___19 =
-                                                      unembed e1 a1 ncb in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___19
-                                                      (fun a110 ->
-                                                         let uu___20 =
-                                                           unembed e2 a2 ncb in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___20
-                                                           (fun a21 ->
-                                                              let uu___21 =
-                                                                unembed e3 a3
-                                                                  ncb in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___21
-                                                                (fun a31 ->
-                                                                   let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e4 a4 ncb in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    unembed
-                                                                    e18 a18
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a19 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___38
-                                                                    =
-                                                                    t a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___38
-                                                                    ps1 in
-                                                                    let uu___38
-                                                                    =
-                                                                    let uu___39
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___40
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___39
-                                                                    uu___40
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___38)))))))))))))))))))
-                                                | uu___ ->
-                                                    FStar_Pervasives_Native.None
-let mk_tactic_interpretation_19 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't3 't4 't5
-    't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 ->
-                                   't16 ->
-                                     't17 ->
-                                       't18 ->
-                                         't19 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't18
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't19
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            'r
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              FStar_TypeChecker_Cfg.psc ->
-                                                FStar_Syntax_Embeddings.norm_cb
-                                                  ->
-                                                  FStar_Syntax_Syntax.args ->
-                                                    FStar_Syntax_Syntax.term
-                                                      FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun e18 ->
-                                        fun e19 ->
-                                          fun er ->
-                                            fun psc ->
-                                              fun ncb ->
-                                                fun args ->
-                                                  match args with
-                                                  | (a1, uu___)::(a2, uu___1)::
-                                                      (a3, uu___2)::(a4,
-                                                                    uu___3)::
-                                                      (a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                                      (a7, uu___6)::(a8,
-                                                                    uu___7)::
-                                                      (a9, uu___8)::(a10,
-                                                                    uu___9)::
-                                                      (a11, uu___10)::
-                                                      (a12, uu___11)::
-                                                      (a13, uu___12)::
-                                                      (a14, uu___13)::
-                                                      (a15, uu___14)::
-                                                      (a16, uu___15)::
-                                                      (a17, uu___16)::
-                                                      (a18, uu___17)::
-                                                      (a19, uu___18)::
-                                                      (a20, uu___19)::[] ->
-                                                      let uu___20 =
-                                                        unembed e1 a1 ncb in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___20
-                                                        (fun a110 ->
-                                                           let uu___21 =
-                                                             unembed e2 a2
-                                                               ncb in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___21
-                                                             (fun a21 ->
-                                                                let uu___22 =
-                                                                  unembed e3
-                                                                    a3 ncb in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___22
-                                                                  (fun a31 ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e4 a4 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    unembed
-                                                                    e18 a18
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___38
-                                                                    =
-                                                                    unembed
-                                                                    e19 a19
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___38
-                                                                    (fun a191
-                                                                    ->
-                                                                    let uu___39
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a20 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___39
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___40
-                                                                    =
-                                                                    t a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___40
-                                                                    ps1 in
-                                                                    let uu___40
-                                                                    =
-                                                                    let uu___41
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___42
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___41
-                                                                    uu___42
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___40))))))))))))))))))))
-                                                  | uu___ ->
-                                                      FStar_Pervasives_Native.None
-let mk_tactic_interpretation_20 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't20 't3 't4
-    't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 ->
-                                   't16 ->
-                                     't17 ->
-                                       't18 ->
-                                         't19 ->
-                                           't20 -> 'r FStar_Tactics_Monad.tac)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't18
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't19
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't20
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              'r
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                FStar_TypeChecker_Cfg.psc ->
-                                                  FStar_Syntax_Embeddings.norm_cb
-                                                    ->
-                                                    FStar_Syntax_Syntax.args
-                                                      ->
-                                                      FStar_Syntax_Syntax.term
-                                                        FStar_Pervasives_Native.option
-  =
-  fun t ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun e18 ->
-                                        fun e19 ->
-                                          fun e20 ->
-                                            fun er ->
-                                              fun psc ->
-                                                fun ncb ->
-                                                  fun args ->
-                                                    match args with
-                                                    | (a1, uu___)::(a2,
-                                                                    uu___1)::
-                                                        (a3, uu___2)::
-                                                        (a4, uu___3)::
-                                                        (a5, uu___4)::
-                                                        (a6, uu___5)::
-                                                        (a7, uu___6)::
-                                                        (a8, uu___7)::
-                                                        (a9, uu___8)::
-                                                        (a10, uu___9)::
-                                                        (a11, uu___10)::
-                                                        (a12, uu___11)::
-                                                        (a13, uu___12)::
-                                                        (a14, uu___13)::
-                                                        (a15, uu___14)::
-                                                        (a16, uu___15)::
-                                                        (a17, uu___16)::
-                                                        (a18, uu___17)::
-                                                        (a19, uu___18)::
-                                                        (a20, uu___19)::
-                                                        (a21, uu___20)::[] ->
-                                                        let uu___21 =
-                                                          unembed e1 a1 ncb in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___21
-                                                          (fun a110 ->
-                                                             let uu___22 =
-                                                               unembed e2 a2
-                                                                 ncb in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___22
-                                                               (fun a22 ->
-                                                                  let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e3 a3 ncb in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (
-                                                                    fun a31
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e4 a4 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___38
-                                                                    =
-                                                                    unembed
-                                                                    e18 a18
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___38
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___39
-                                                                    =
-                                                                    unembed
-                                                                    e19 a19
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___39
-                                                                    (fun a191
-                                                                    ->
-                                                                    let uu___40
-                                                                    =
-                                                                    unembed
-                                                                    e20 a20
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___40
-                                                                    (fun a201
-                                                                    ->
-                                                                    let uu___41
-                                                                    =
-                                                                    unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate
-                                                                    a21 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___41
-                                                                    (fun ps
-                                                                    ->
-                                                                    let ps1 =
-                                                                    FStar_Tactics_Types.set_ps_psc
-                                                                    psc ps in
-                                                                    let r1 =
-                                                                    let uu___42
-                                                                    =
-                                                                    t a110
-                                                                    a22 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191
-                                                                    a201 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___42
-                                                                    ps1 in
-                                                                    let uu___42
-                                                                    =
-                                                                    let uu___43
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result
-                                                                    er in
-                                                                    let uu___44
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed
-                                                                    uu___43
-                                                                    uu___44
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___42)))))))))))))))))))))
-                                                    | uu___ ->
-                                                        FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_1 :
-  'r 't1 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 'r FStar_Tactics_Monad.tac) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          'r FStar_TypeChecker_NBETerm.embedding ->
-            FStar_TypeChecker_NBETerm.args ->
-              FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun er ->
-          fun args ->
-            match args with
-            | (a1, uu___)::(a2, uu___1)::[] ->
-                let uu___2 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                FStar_Compiler_Util.bind_opt uu___2
-                  (fun a11 ->
-                     let uu___3 =
-                       FStar_TypeChecker_NBETerm.unembed
-                         FStar_Tactics_Embedding.e_proofstate_nbe cb a2 in
-                     FStar_Compiler_Util.bind_opt uu___3
-                       (fun ps ->
-                          let r1 =
-                            let uu___4 = t a11 in
-                            FStar_Tactics_Monad.run_safe uu___4 ps in
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Tactics_Embedding.e_result_nbe er in
-                            FStar_TypeChecker_NBETerm.embed uu___5 cb r1 in
-                          FStar_Pervasives_Native.Some uu___4))
-            | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_2 :
-  'r 't1 't2 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 'r FStar_Tactics_Monad.tac) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            'r FStar_TypeChecker_NBETerm.embedding ->
-              FStar_TypeChecker_NBETerm.args ->
-                FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun er ->
-            fun args ->
-              match args with
-              | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::[] ->
-                  let uu___3 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                  FStar_Compiler_Util.bind_opt uu___3
-                    (fun a11 ->
-                       let uu___4 =
-                         FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                       FStar_Compiler_Util.bind_opt uu___4
-                         (fun a21 ->
-                            let uu___5 =
-                              FStar_TypeChecker_NBETerm.unembed
-                                FStar_Tactics_Embedding.e_proofstate_nbe cb
-                                a3 in
-                            FStar_Compiler_Util.bind_opt uu___5
-                              (fun ps ->
-                                 let r1 =
-                                   let uu___6 = t a11 a21 in
-                                   FStar_Tactics_Monad.run_safe uu___6 ps in
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Tactics_Embedding.e_result_nbe er in
-                                   FStar_TypeChecker_NBETerm.embed uu___7 cb
-                                     r1 in
-                                 FStar_Pervasives_Native.Some uu___6)))
-              | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_3 :
-  'r 't1 't2 't3 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 'r FStar_Tactics_Monad.tac) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              'r FStar_TypeChecker_NBETerm.embedding ->
-                FStar_TypeChecker_NBETerm.args ->
-                  FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun er ->
-              fun args ->
-                match args with
-                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::[]
-                    ->
-                    let uu___4 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                    FStar_Compiler_Util.bind_opt uu___4
-                      (fun a11 ->
-                         let uu___5 =
-                           FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                         FStar_Compiler_Util.bind_opt uu___5
-                           (fun a21 ->
-                              let uu___6 =
-                                FStar_TypeChecker_NBETerm.unembed e3 cb a3 in
-                              FStar_Compiler_Util.bind_opt uu___6
-                                (fun a31 ->
-                                   let uu___7 =
-                                     FStar_TypeChecker_NBETerm.unembed
-                                       FStar_Tactics_Embedding.e_proofstate_nbe
-                                       cb a4 in
-                                   FStar_Compiler_Util.bind_opt uu___7
-                                     (fun ps ->
-                                        let r1 =
-                                          let uu___8 = t a11 a21 a31 in
-                                          FStar_Tactics_Monad.run_safe uu___8
-                                            ps in
-                                        let uu___8 =
-                                          let uu___9 =
-                                            FStar_Tactics_Embedding.e_result_nbe
-                                              er in
-                                          FStar_TypeChecker_NBETerm.embed
-                                            uu___9 cb r1 in
-                                        FStar_Pervasives_Native.Some uu___8))))
-                | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_4 :
-  'r 't1 't2 't3 't4 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 'r FStar_Tactics_Monad.tac) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                'r FStar_TypeChecker_NBETerm.embedding ->
-                  FStar_TypeChecker_NBETerm.args ->
-                    FStar_TypeChecker_NBETerm.t
-                      FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun er ->
-                fun args ->
-                  match args with
-                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                      (a5, uu___4)::[] ->
-                      let uu___5 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                      FStar_Compiler_Util.bind_opt uu___5
-                        (fun a11 ->
-                           let uu___6 =
-                             FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                           FStar_Compiler_Util.bind_opt uu___6
-                             (fun a21 ->
-                                let uu___7 =
-                                  FStar_TypeChecker_NBETerm.unembed e3 cb a3 in
-                                FStar_Compiler_Util.bind_opt uu___7
-                                  (fun a31 ->
-                                     let uu___8 =
-                                       FStar_TypeChecker_NBETerm.unembed e4
-                                         cb a4 in
-                                     FStar_Compiler_Util.bind_opt uu___8
-                                       (fun a41 ->
-                                          let uu___9 =
-                                            FStar_TypeChecker_NBETerm.unembed
-                                              FStar_Tactics_Embedding.e_proofstate_nbe
-                                              cb a5 in
-                                          FStar_Compiler_Util.bind_opt uu___9
-                                            (fun ps ->
-                                               let r1 =
-                                                 let uu___10 =
-                                                   t a11 a21 a31 a41 in
-                                                 FStar_Tactics_Monad.run_safe
-                                                   uu___10 ps in
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_Tactics_Embedding.e_result_nbe
-                                                     er in
-                                                 FStar_TypeChecker_NBETerm.embed
-                                                   uu___11 cb r1 in
-                                               FStar_Pervasives_Native.Some
-                                                 uu___10)))))
-                  | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_5 :
-  'r 't1 't2 't3 't4 't5 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 'r FStar_Tactics_Monad.tac) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  'r FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_NBETerm.args ->
-                      FStar_TypeChecker_NBETerm.t
-                        FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun er ->
-                  fun args ->
-                    match args with
-                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                        (a5, uu___4)::(a6, uu___5)::[] ->
-                        let uu___6 =
-                          FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                        FStar_Compiler_Util.bind_opt uu___6
-                          (fun a11 ->
-                             let uu___7 =
-                               FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                             FStar_Compiler_Util.bind_opt uu___7
-                               (fun a21 ->
-                                  let uu___8 =
-                                    FStar_TypeChecker_NBETerm.unembed e3 cb
-                                      a3 in
-                                  FStar_Compiler_Util.bind_opt uu___8
-                                    (fun a31 ->
-                                       let uu___9 =
-                                         FStar_TypeChecker_NBETerm.unembed e4
-                                           cb a4 in
-                                       FStar_Compiler_Util.bind_opt uu___9
-                                         (fun a41 ->
-                                            let uu___10 =
-                                              FStar_TypeChecker_NBETerm.unembed
-                                                e5 cb a5 in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___10
-                                              (fun a51 ->
-                                                 let uu___11 =
-                                                   FStar_TypeChecker_NBETerm.unembed
-                                                     FStar_Tactics_Embedding.e_proofstate_nbe
-                                                     cb a6 in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___11
-                                                   (fun ps ->
-                                                      let r1 =
-                                                        let uu___12 =
-                                                          t a11 a21 a31 a41
-                                                            a51 in
-                                                        FStar_Tactics_Monad.run_safe
-                                                          uu___12 ps in
-                                                      let uu___12 =
-                                                        let uu___13 =
-                                                          FStar_Tactics_Embedding.e_result_nbe
-                                                            er in
-                                                        FStar_TypeChecker_NBETerm.embed
-                                                          uu___13 cb r1 in
-                                                      FStar_Pervasives_Native.Some
-                                                        uu___12))))))
-                    | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_6 :
-  'r 't1 't2 't3 't4 't5 't6 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    'r FStar_TypeChecker_NBETerm.embedding ->
-                      FStar_TypeChecker_NBETerm.args ->
-                        FStar_TypeChecker_NBETerm.t
-                          FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun er ->
-                    fun args ->
-                      match args with
-                      | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                          (a5, uu___4)::(a6, uu___5)::(a7, uu___6)::[] ->
-                          let uu___7 =
-                            FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                          FStar_Compiler_Util.bind_opt uu___7
-                            (fun a11 ->
-                               let uu___8 =
-                                 FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                               FStar_Compiler_Util.bind_opt uu___8
-                                 (fun a21 ->
-                                    let uu___9 =
-                                      FStar_TypeChecker_NBETerm.unembed e3 cb
-                                        a3 in
-                                    FStar_Compiler_Util.bind_opt uu___9
-                                      (fun a31 ->
-                                         let uu___10 =
-                                           FStar_TypeChecker_NBETerm.unembed
-                                             e4 cb a4 in
-                                         FStar_Compiler_Util.bind_opt uu___10
-                                           (fun a41 ->
-                                              let uu___11 =
-                                                FStar_TypeChecker_NBETerm.unembed
-                                                  e5 cb a5 in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___11
-                                                (fun a51 ->
-                                                   let uu___12 =
-                                                     FStar_TypeChecker_NBETerm.unembed
-                                                       e6 cb a6 in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___12
-                                                     (fun a61 ->
-                                                        let uu___13 =
-                                                          FStar_TypeChecker_NBETerm.unembed
-                                                            FStar_Tactics_Embedding.e_proofstate_nbe
-                                                            cb a7 in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___13
-                                                          (fun ps ->
-                                                             let r1 =
-                                                               let uu___14 =
-                                                                 t a11 a21
-                                                                   a31 a41
-                                                                   a51 a61 in
-                                                               FStar_Tactics_Monad.run_safe
-                                                                 uu___14 ps in
-                                                             let uu___14 =
-                                                               let uu___15 =
-                                                                 FStar_Tactics_Embedding.e_result_nbe
-                                                                   er in
-                                                               FStar_TypeChecker_NBETerm.embed
-                                                                 uu___15 cb
-                                                                 r1 in
-                                                             FStar_Pervasives_Native.Some
-                                                               uu___14)))))))
-                      | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_7 :
-  'r 't1 't2 't3 't4 't5 't6 't7 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      'r FStar_TypeChecker_NBETerm.embedding ->
-                        FStar_TypeChecker_NBETerm.args ->
-                          FStar_TypeChecker_NBETerm.t
-                            FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun er ->
-                      fun args ->
-                        match args with
-                        | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4,
-                                                                    uu___3)::
-                            (a5, uu___4)::(a6, uu___5)::(a7, uu___6)::
-                            (a8, uu___7)::[] ->
-                            let uu___8 =
-                              FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                            FStar_Compiler_Util.bind_opt uu___8
-                              (fun a11 ->
-                                 let uu___9 =
-                                   FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                                 FStar_Compiler_Util.bind_opt uu___9
-                                   (fun a21 ->
-                                      let uu___10 =
-                                        FStar_TypeChecker_NBETerm.unembed e3
-                                          cb a3 in
-                                      FStar_Compiler_Util.bind_opt uu___10
-                                        (fun a31 ->
-                                           let uu___11 =
-                                             FStar_TypeChecker_NBETerm.unembed
-                                               e4 cb a4 in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___11
-                                             (fun a41 ->
-                                                let uu___12 =
-                                                  FStar_TypeChecker_NBETerm.unembed
-                                                    e5 cb a5 in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___12
-                                                  (fun a51 ->
-                                                     let uu___13 =
-                                                       FStar_TypeChecker_NBETerm.unembed
-                                                         e6 cb a6 in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___13
-                                                       (fun a61 ->
-                                                          let uu___14 =
-                                                            FStar_TypeChecker_NBETerm.unembed
-                                                              e7 cb a7 in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___14
-                                                            (fun a71 ->
-                                                               let uu___15 =
-                                                                 FStar_TypeChecker_NBETerm.unembed
-                                                                   FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                   cb a8 in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___15
-                                                                 (fun ps ->
-                                                                    let r1 =
-                                                                    let uu___16
-                                                                    =
-                                                                    t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___16
-                                                                    ps in
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___17
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___16))))))))
-                        | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_8 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        'r FStar_TypeChecker_NBETerm.embedding ->
-                          FStar_TypeChecker_NBETerm.args ->
-                            FStar_TypeChecker_NBETerm.t
-                              FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun er ->
-                        fun args ->
-                          match args with
-                          | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                              (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                              (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::[] ->
-                              let uu___9 =
-                                FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                              FStar_Compiler_Util.bind_opt uu___9
-                                (fun a11 ->
-                                   let uu___10 =
-                                     FStar_TypeChecker_NBETerm.unembed e2 cb
-                                       a2 in
-                                   FStar_Compiler_Util.bind_opt uu___10
-                                     (fun a21 ->
-                                        let uu___11 =
-                                          FStar_TypeChecker_NBETerm.unembed
-                                            e3 cb a3 in
-                                        FStar_Compiler_Util.bind_opt uu___11
-                                          (fun a31 ->
-                                             let uu___12 =
-                                               FStar_TypeChecker_NBETerm.unembed
-                                                 e4 cb a4 in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___12
-                                               (fun a41 ->
-                                                  let uu___13 =
-                                                    FStar_TypeChecker_NBETerm.unembed
-                                                      e5 cb a5 in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___13
-                                                    (fun a51 ->
-                                                       let uu___14 =
-                                                         FStar_TypeChecker_NBETerm.unembed
-                                                           e6 cb a6 in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___14
-                                                         (fun a61 ->
-                                                            let uu___15 =
-                                                              FStar_TypeChecker_NBETerm.unembed
-                                                                e7 cb a7 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___15
-                                                              (fun a71 ->
-                                                                 let uu___16
-                                                                   =
-                                                                   FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___16
-                                                                   (fun a81
-                                                                    ->
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___18
-                                                                    =
-                                                                    t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___18
-                                                                    ps in
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___19
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___18)))))))))
-                          | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_9 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          'r FStar_TypeChecker_NBETerm.embedding ->
-                            FStar_TypeChecker_NBETerm.args ->
-                              FStar_TypeChecker_NBETerm.t
-                                FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun er ->
-                          fun args ->
-                            match args with
-                            | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                (a10, uu___9)::[] ->
-                                let uu___10 =
-                                  FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                                FStar_Compiler_Util.bind_opt uu___10
-                                  (fun a11 ->
-                                     let uu___11 =
-                                       FStar_TypeChecker_NBETerm.unembed e2
-                                         cb a2 in
-                                     FStar_Compiler_Util.bind_opt uu___11
-                                       (fun a21 ->
-                                          let uu___12 =
-                                            FStar_TypeChecker_NBETerm.unembed
-                                              e3 cb a3 in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___12
-                                            (fun a31 ->
-                                               let uu___13 =
-                                                 FStar_TypeChecker_NBETerm.unembed
-                                                   e4 cb a4 in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___13
-                                                 (fun a41 ->
-                                                    let uu___14 =
-                                                      FStar_TypeChecker_NBETerm.unembed
-                                                        e5 cb a5 in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___14
-                                                      (fun a51 ->
-                                                         let uu___15 =
-                                                           FStar_TypeChecker_NBETerm.unembed
-                                                             e6 cb a6 in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___15
-                                                           (fun a61 ->
-                                                              let uu___16 =
-                                                                FStar_TypeChecker_NBETerm.unembed
-                                                                  e7 cb a7 in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___16
-                                                                (fun a71 ->
-                                                                   let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___20
-                                                                    =
-                                                                    t a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___20
-                                                                    ps in
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___21
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___20))))))))))
-                            | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_10 :
-  'r 't1 't10 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 -> 't8 -> 't9 -> 't10 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            'r FStar_TypeChecker_NBETerm.embedding ->
-                              FStar_TypeChecker_NBETerm.args ->
-                                FStar_TypeChecker_NBETerm.t
-                                  FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun er ->
-                            fun args ->
-                              match args with
-                              | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                  (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                  (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                  (a10, uu___9)::(a11, uu___10)::[] ->
-                                  let uu___11 =
-                                    FStar_TypeChecker_NBETerm.unembed e1 cb
-                                      a1 in
-                                  FStar_Compiler_Util.bind_opt uu___11
-                                    (fun a12 ->
-                                       let uu___12 =
-                                         FStar_TypeChecker_NBETerm.unembed e2
-                                           cb a2 in
-                                       FStar_Compiler_Util.bind_opt uu___12
-                                         (fun a21 ->
-                                            let uu___13 =
-                                              FStar_TypeChecker_NBETerm.unembed
-                                                e3 cb a3 in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___13
-                                              (fun a31 ->
-                                                 let uu___14 =
-                                                   FStar_TypeChecker_NBETerm.unembed
-                                                     e4 cb a4 in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___14
-                                                   (fun a41 ->
-                                                      let uu___15 =
-                                                        FStar_TypeChecker_NBETerm.unembed
-                                                          e5 cb a5 in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___15
-                                                        (fun a51 ->
-                                                           let uu___16 =
-                                                             FStar_TypeChecker_NBETerm.unembed
-                                                               e6 cb a6 in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___16
-                                                             (fun a61 ->
-                                                                let uu___17 =
-                                                                  FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___17
-                                                                  (fun a71 ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___22
-                                                                    =
-                                                                    t a12 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___22
-                                                                    ps in
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___23
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___22)))))))))))
-                              | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_11 :
-  'r 't1 't10 't11 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 -> 't9 -> 't10 -> 't11 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              'r FStar_TypeChecker_NBETerm.embedding ->
-                                FStar_TypeChecker_NBETerm.args ->
-                                  FStar_TypeChecker_NBETerm.t
-                                    FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun er ->
-                              fun args ->
-                                match args with
-                                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                    (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                    (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                    (a10, uu___9)::(a11, uu___10)::(a12,
-                                                                    uu___11)::[]
-                                    ->
-                                    let uu___12 =
-                                      FStar_TypeChecker_NBETerm.unembed e1 cb
-                                        a1 in
-                                    FStar_Compiler_Util.bind_opt uu___12
-                                      (fun a13 ->
-                                         let uu___13 =
-                                           FStar_TypeChecker_NBETerm.unembed
-                                             e2 cb a2 in
-                                         FStar_Compiler_Util.bind_opt uu___13
-                                           (fun a21 ->
-                                              let uu___14 =
-                                                FStar_TypeChecker_NBETerm.unembed
-                                                  e3 cb a3 in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___14
-                                                (fun a31 ->
-                                                   let uu___15 =
-                                                     FStar_TypeChecker_NBETerm.unembed
-                                                       e4 cb a4 in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___15
-                                                     (fun a41 ->
-                                                        let uu___16 =
-                                                          FStar_TypeChecker_NBETerm.unembed
-                                                            e5 cb a5 in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___16
-                                                          (fun a51 ->
-                                                             let uu___17 =
-                                                               FStar_TypeChecker_NBETerm.unembed
-                                                                 e6 cb a6 in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___17
-                                                               (fun a61 ->
-                                                                  let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (
-                                                                    fun a71
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___24
-                                                                    =
-                                                                    t a13 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___24
-                                                                    ps in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___25
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24))))))))))))
-                                | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_12 :
-  'r 't1 't10 't11 't12 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 -> 't11 -> 't12 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                'r FStar_TypeChecker_NBETerm.embedding ->
-                                  FStar_TypeChecker_NBETerm.args ->
-                                    FStar_TypeChecker_NBETerm.t
-                                      FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun er ->
-                                fun args ->
-                                  match args with
-                                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                      (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                      (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                   uu___8)::
-                                      (a10, uu___9)::(a11, uu___10)::
-                                      (a12, uu___11)::(a13, uu___12)::[] ->
-                                      let uu___13 =
-                                        FStar_TypeChecker_NBETerm.unembed e1
-                                          cb a1 in
-                                      FStar_Compiler_Util.bind_opt uu___13
-                                        (fun a14 ->
-                                           let uu___14 =
-                                             FStar_TypeChecker_NBETerm.unembed
-                                               e2 cb a2 in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___14
-                                             (fun a21 ->
-                                                let uu___15 =
-                                                  FStar_TypeChecker_NBETerm.unembed
-                                                    e3 cb a3 in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___15
-                                                  (fun a31 ->
-                                                     let uu___16 =
-                                                       FStar_TypeChecker_NBETerm.unembed
-                                                         e4 cb a4 in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___16
-                                                       (fun a41 ->
-                                                          let uu___17 =
-                                                            FStar_TypeChecker_NBETerm.unembed
-                                                              e5 cb a5 in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___17
-                                                            (fun a51 ->
-                                                               let uu___18 =
-                                                                 FStar_TypeChecker_NBETerm.unembed
-                                                                   e6 cb a6 in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___18
-                                                                 (fun a61 ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___26
-                                                                    =
-                                                                    t a14 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___26
-                                                                    ps in
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___27
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___26)))))))))))))
-                                  | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_13 :
-  'r 't1 't10 't11 't12 't13 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 -> 't12 -> 't13 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  'r FStar_TypeChecker_NBETerm.embedding ->
-                                    FStar_TypeChecker_NBETerm.args ->
-                                      FStar_TypeChecker_NBETerm.t
-                                        FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun er ->
-                                  fun args ->
-                                    match args with
-                                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                        (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                        (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                    uu___8)::
-                                        (a10, uu___9)::(a11, uu___10)::
-                                        (a12, uu___11)::(a13, uu___12)::
-                                        (a14, uu___13)::[] ->
-                                        let uu___14 =
-                                          FStar_TypeChecker_NBETerm.unembed
-                                            e1 cb a1 in
-                                        FStar_Compiler_Util.bind_opt uu___14
-                                          (fun a15 ->
-                                             let uu___15 =
-                                               FStar_TypeChecker_NBETerm.unembed
-                                                 e2 cb a2 in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___15
-                                               (fun a21 ->
-                                                  let uu___16 =
-                                                    FStar_TypeChecker_NBETerm.unembed
-                                                      e3 cb a3 in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___16
-                                                    (fun a31 ->
-                                                       let uu___17 =
-                                                         FStar_TypeChecker_NBETerm.unembed
-                                                           e4 cb a4 in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___17
-                                                         (fun a41 ->
-                                                            let uu___18 =
-                                                              FStar_TypeChecker_NBETerm.unembed
-                                                                e5 cb a5 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___18
-                                                              (fun a51 ->
-                                                                 let uu___19
-                                                                   =
-                                                                   FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___19
-                                                                   (fun a61
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___28
-                                                                    =
-                                                                    t a15 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___28
-                                                                    ps in
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___29
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___28))))))))))))))
-                                    | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_14 :
-  'r 't1 't10 't11 't12 't13 't14 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 -> 't14 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    'r FStar_TypeChecker_NBETerm.embedding ->
-                                      FStar_TypeChecker_NBETerm.args ->
-                                        FStar_TypeChecker_NBETerm.t
-                                          FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun er ->
-                                    fun args ->
-                                      match args with
-                                      | (a1, uu___)::(a2, uu___1)::(a3,
-                                                                    uu___2)::
-                                          (a4, uu___3)::(a5, uu___4)::
-                                          (a6, uu___5)::(a7, uu___6)::
-                                          (a8, uu___7)::(a9, uu___8)::
-                                          (a10, uu___9)::(a11, uu___10)::
-                                          (a12, uu___11)::(a13, uu___12)::
-                                          (a14, uu___13)::(a15, uu___14)::[]
-                                          ->
-                                          let uu___15 =
-                                            FStar_TypeChecker_NBETerm.unembed
-                                              e1 cb a1 in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___15
-                                            (fun a16 ->
-                                               let uu___16 =
-                                                 FStar_TypeChecker_NBETerm.unembed
-                                                   e2 cb a2 in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___16
-                                                 (fun a21 ->
-                                                    let uu___17 =
-                                                      FStar_TypeChecker_NBETerm.unembed
-                                                        e3 cb a3 in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___17
-                                                      (fun a31 ->
-                                                         let uu___18 =
-                                                           FStar_TypeChecker_NBETerm.unembed
-                                                             e4 cb a4 in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___18
-                                                           (fun a41 ->
-                                                              let uu___19 =
-                                                                FStar_TypeChecker_NBETerm.unembed
-                                                                  e5 cb a5 in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___19
-                                                                (fun a51 ->
-                                                                   let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___30
-                                                                    =
-                                                                    t a16 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___30
-                                                                    ps in
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___31
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___30)))))))))))))))
-                                      | uu___ -> FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_15 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 -> 't15 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'r FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        FStar_TypeChecker_NBETerm.args ->
-                                          FStar_TypeChecker_NBETerm.t
-                                            FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun er ->
-                                      fun args ->
-                                        match args with
-                                        | (a1, uu___)::(a2, uu___1)::
-                                            (a3, uu___2)::(a4, uu___3)::
-                                            (a5, uu___4)::(a6, uu___5)::
-                                            (a7, uu___6)::(a8, uu___7)::
-                                            (a9, uu___8)::(a10, uu___9)::
-                                            (a11, uu___10)::(a12, uu___11)::
-                                            (a13, uu___12)::(a14, uu___13)::
-                                            (a15, uu___14)::(a16, uu___15)::[]
-                                            ->
-                                            let uu___16 =
-                                              FStar_TypeChecker_NBETerm.unembed
-                                                e1 cb a1 in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___16
-                                              (fun a17 ->
-                                                 let uu___17 =
-                                                   FStar_TypeChecker_NBETerm.unembed
-                                                     e2 cb a2 in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___17
-                                                   (fun a21 ->
-                                                      let uu___18 =
-                                                        FStar_TypeChecker_NBETerm.unembed
-                                                          e3 cb a3 in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___18
-                                                        (fun a31 ->
-                                                           let uu___19 =
-                                                             FStar_TypeChecker_NBETerm.unembed
-                                                               e4 cb a4 in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___19
-                                                             (fun a41 ->
-                                                                let uu___20 =
-                                                                  FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___20
-                                                                  (fun a51 ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___32
-                                                                    =
-                                                                    t a17 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___32
-                                                                    ps in
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___33
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___32))))))))))))))))
-                                        | uu___ ->
-                                            FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_16 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 -> 't16 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'r
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          FStar_TypeChecker_NBETerm.args ->
-                                            FStar_TypeChecker_NBETerm.t
-                                              FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun er ->
-                                        fun args ->
-                                          match args with
-                                          | (a1, uu___)::(a2, uu___1)::
-                                              (a3, uu___2)::(a4, uu___3)::
-                                              (a5, uu___4)::(a6, uu___5)::
-                                              (a7, uu___6)::(a8, uu___7)::
-                                              (a9, uu___8)::(a10, uu___9)::
-                                              (a11, uu___10)::(a12, uu___11)::
-                                              (a13, uu___12)::(a14, uu___13)::
-                                              (a15, uu___14)::(a16, uu___15)::
-                                              (a17, uu___16)::[] ->
-                                              let uu___17 =
-                                                FStar_TypeChecker_NBETerm.unembed
-                                                  e1 cb a1 in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___17
-                                                (fun a18 ->
-                                                   let uu___18 =
-                                                     FStar_TypeChecker_NBETerm.unembed
-                                                       e2 cb a2 in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___18
-                                                     (fun a21 ->
-                                                        let uu___19 =
-                                                          FStar_TypeChecker_NBETerm.unembed
-                                                            e3 cb a3 in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___19
-                                                          (fun a31 ->
-                                                             let uu___20 =
-                                                               FStar_TypeChecker_NBETerm.unembed
-                                                                 e4 cb a4 in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___20
-                                                               (fun a41 ->
-                                                                  let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (
-                                                                    fun a51
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___34
-                                                                    =
-                                                                    t a18 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___34
-                                                                    ps in
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___35
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___34)))))))))))))))))
-                                          | uu___ ->
-                                              FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_17 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't2 't3 't4 't5 't6 't7 't8
-    't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 ->
-                                     't16 ->
-                                       't17 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'r
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            FStar_TypeChecker_NBETerm.args ->
-                                              FStar_TypeChecker_NBETerm.t
-                                                FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun er ->
-                                          fun args ->
-                                            match args with
-                                            | (a1, uu___)::(a2, uu___1)::
-                                                (a3, uu___2)::(a4, uu___3)::
-                                                (a5, uu___4)::(a6, uu___5)::
-                                                (a7, uu___6)::(a8, uu___7)::
-                                                (a9, uu___8)::(a10, uu___9)::
-                                                (a11, uu___10)::(a12,
-                                                                 uu___11)::
-                                                (a13, uu___12)::(a14,
-                                                                 uu___13)::
-                                                (a15, uu___14)::(a16,
-                                                                 uu___15)::
-                                                (a17, uu___16)::(a18,
-                                                                 uu___17)::[]
-                                                ->
-                                                let uu___18 =
-                                                  FStar_TypeChecker_NBETerm.unembed
-                                                    e1 cb a1 in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___18
-                                                  (fun a19 ->
-                                                     let uu___19 =
-                                                       FStar_TypeChecker_NBETerm.unembed
-                                                         e2 cb a2 in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___19
-                                                       (fun a21 ->
-                                                          let uu___20 =
-                                                            FStar_TypeChecker_NBETerm.unembed
-                                                              e3 cb a3 in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___20
-                                                            (fun a31 ->
-                                                               let uu___21 =
-                                                                 FStar_TypeChecker_NBETerm.unembed
-                                                                   e4 cb a4 in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___21
-                                                                 (fun a41 ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___36
-                                                                    =
-                                                                    t a19 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161
-                                                                    a171 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___36
-                                                                    ps in
-                                                                    let uu___36
-                                                                    =
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___37
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___36))))))))))))))))))
-                                            | uu___ ->
-                                                FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_18 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't2 't3 't4 't5 't6 't7
-    't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 ->
-                                     't16 ->
-                                       't17 ->
-                                         't18 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          't18
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'r
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              FStar_TypeChecker_NBETerm.args
-                                                ->
-                                                FStar_TypeChecker_NBETerm.t
-                                                  FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun e18 ->
-                                          fun er ->
-                                            fun args ->
-                                              match args with
-                                              | (a1, uu___)::(a2, uu___1)::
-                                                  (a3, uu___2)::(a4, uu___3)::
-                                                  (a5, uu___4)::(a6, uu___5)::
-                                                  (a7, uu___6)::(a8, uu___7)::
-                                                  (a9, uu___8)::(a10, uu___9)::
-                                                  (a11, uu___10)::(a12,
-                                                                   uu___11)::
-                                                  (a13, uu___12)::(a14,
-                                                                   uu___13)::
-                                                  (a15, uu___14)::(a16,
-                                                                   uu___15)::
-                                                  (a17, uu___16)::(a18,
-                                                                   uu___17)::
-                                                  (a19, uu___18)::[] ->
-                                                  let uu___19 =
-                                                    FStar_TypeChecker_NBETerm.unembed
-                                                      e1 cb a1 in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___19
-                                                    (fun a110 ->
-                                                       let uu___20 =
-                                                         FStar_TypeChecker_NBETerm.unembed
-                                                           e2 cb a2 in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___20
-                                                         (fun a21 ->
-                                                            let uu___21 =
-                                                              FStar_TypeChecker_NBETerm.unembed
-                                                                e3 cb a3 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___21
-                                                              (fun a31 ->
-                                                                 let uu___22
-                                                                   =
-                                                                   FStar_TypeChecker_NBETerm.unembed
-                                                                    e4 cb a4 in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___22
-                                                                   (fun a41
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e18 cb
-                                                                    a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a19 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___38
-                                                                    =
-                                                                    t a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___38
-                                                                    ps in
-                                                                    let uu___38
-                                                                    =
-                                                                    let uu___39
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___39
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___38)))))))))))))))))))
-                                              | uu___ ->
-                                                  FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_19 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't3 't4 't5
-    't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 ->
-                                     't16 ->
-                                       't17 ->
-                                         't18 ->
-                                           't19 -> 'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          't18
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            't19
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'r
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                FStar_TypeChecker_NBETerm.args
-                                                  ->
-                                                  FStar_TypeChecker_NBETerm.t
-                                                    FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun e18 ->
-                                          fun e19 ->
-                                            fun er ->
-                                              fun args ->
-                                                match args with
-                                                | (a1, uu___)::(a2, uu___1)::
-                                                    (a3, uu___2)::(a4,
-                                                                   uu___3)::
-                                                    (a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                                    (a7, uu___6)::(a8,
-                                                                   uu___7)::
-                                                    (a9, uu___8)::(a10,
-                                                                   uu___9)::
-                                                    (a11, uu___10)::(a12,
-                                                                    uu___11)::
-                                                    (a13, uu___12)::(a14,
-                                                                    uu___13)::
-                                                    (a15, uu___14)::(a16,
-                                                                    uu___15)::
-                                                    (a17, uu___16)::(a18,
-                                                                    uu___17)::
-                                                    (a19, uu___18)::(a20,
-                                                                    uu___19)::[]
-                                                    ->
-                                                    let uu___20 =
-                                                      FStar_TypeChecker_NBETerm.unembed
-                                                        e1 cb a1 in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___20
-                                                      (fun a110 ->
-                                                         let uu___21 =
-                                                           FStar_TypeChecker_NBETerm.unembed
-                                                             e2 cb a2 in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___21
-                                                           (fun a21 ->
-                                                              let uu___22 =
-                                                                FStar_TypeChecker_NBETerm.unembed
-                                                                  e3 cb a3 in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___22
-                                                                (fun a31 ->
-                                                                   let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e4 cb a4 in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e18 cb
-                                                                    a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e19 cb
-                                                                    a19 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___38
-                                                                    (fun a191
-                                                                    ->
-                                                                    let uu___39
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a20 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___39
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___40
-                                                                    =
-                                                                    t a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___40
-                                                                    ps in
-                                                                    let uu___40
-                                                                    =
-                                                                    let uu___41
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___41
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___40))))))))))))))))))))
-                                                | uu___ ->
-                                                    FStar_Pervasives_Native.None
-let mk_tactic_nbe_interpretation_20 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't20 't3 't4
-    't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 ->
-                                     't16 ->
-                                       't17 ->
-                                         't18 ->
-                                           't19 ->
-                                             't20 ->
-                                               'r FStar_Tactics_Monad.tac)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          't18
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            't19
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              't20
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'r
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  FStar_TypeChecker_NBETerm.args
-                                                    ->
-                                                    FStar_TypeChecker_NBETerm.t
-                                                      FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun t ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun e18 ->
-                                          fun e19 ->
-                                            fun e20 ->
-                                              fun er ->
-                                                fun args ->
-                                                  match args with
-                                                  | (a1, uu___)::(a2, uu___1)::
-                                                      (a3, uu___2)::(a4,
-                                                                    uu___3)::
-                                                      (a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                                      (a7, uu___6)::(a8,
-                                                                    uu___7)::
-                                                      (a9, uu___8)::(a10,
-                                                                    uu___9)::
-                                                      (a11, uu___10)::
-                                                      (a12, uu___11)::
-                                                      (a13, uu___12)::
-                                                      (a14, uu___13)::
-                                                      (a15, uu___14)::
-                                                      (a16, uu___15)::
-                                                      (a17, uu___16)::
-                                                      (a18, uu___17)::
-                                                      (a19, uu___18)::
-                                                      (a20, uu___19)::
-                                                      (a21, uu___20)::[] ->
-                                                      let uu___21 =
-                                                        FStar_TypeChecker_NBETerm.unembed
-                                                          e1 cb a1 in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___21
-                                                        (fun a110 ->
-                                                           let uu___22 =
-                                                             FStar_TypeChecker_NBETerm.unembed
-                                                               e2 cb a2 in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___22
-                                                             (fun a22 ->
-                                                                let uu___23 =
-                                                                  FStar_TypeChecker_NBETerm.unembed
-                                                                    e3 cb a3 in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___23
-                                                                  (fun a31 ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e4 cb a4 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e18 cb
-                                                                    a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___38
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___39
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e19 cb
-                                                                    a19 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___39
-                                                                    (fun a191
-                                                                    ->
-                                                                    let uu___40
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e20 cb
-                                                                    a20 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___40
-                                                                    (fun a201
-                                                                    ->
-                                                                    let uu___41
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    FStar_Tactics_Embedding.e_proofstate_nbe
-                                                                    cb a21 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___41
-                                                                    (fun ps
-                                                                    ->
-                                                                    let r1 =
-                                                                    let uu___42
-                                                                    =
-                                                                    t a110
-                                                                    a22 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191
-                                                                    a201 in
-                                                                    FStar_Tactics_Monad.run_safe
-                                                                    uu___42
-                                                                    ps in
-                                                                    let uu___42
-                                                                    =
-                                                                    let uu___43
-                                                                    =
-                                                                    FStar_Tactics_Embedding.e_result_nbe
-                                                                    er in
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    uu___43
-                                                                    cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___42)))))))))))))))))))))
-                                                  | uu___ ->
-                                                      FStar_Pervasives_Native.None
-let mk_total_interpretation_1 :
-  'r 't1 .
-    ('t1 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        'r FStar_Syntax_Embeddings.embedding ->
-          FStar_TypeChecker_Cfg.psc ->
-            FStar_Syntax_Embeddings.norm_cb ->
-              FStar_Syntax_Syntax.args ->
-                FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun er ->
-        fun psc ->
-          fun ncb ->
-            fun args ->
-              match args with
-              | (a1, uu___)::[] ->
-                  let uu___1 = unembed e1 a1 ncb in
-                  FStar_Compiler_Util.bind_opt uu___1
-                    (fun a11 ->
-                       let r1 = f a11 in
-                       let uu___2 =
-                         let uu___3 = FStar_TypeChecker_Cfg.psc_range psc in
-                         embed er uu___3 r1 ncb in
-                       FStar_Pervasives_Native.Some uu___2)
-              | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_2 :
-  'r 't1 't2 .
-    ('t1 -> 't2 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          'r FStar_Syntax_Embeddings.embedding ->
-            FStar_TypeChecker_Cfg.psc ->
-              FStar_Syntax_Embeddings.norm_cb ->
-                FStar_Syntax_Syntax.args ->
-                  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun er ->
-          fun psc ->
-            fun ncb ->
-              fun args ->
-                match args with
-                | (a1, uu___)::(a2, uu___1)::[] ->
-                    let uu___2 = unembed e1 a1 ncb in
-                    FStar_Compiler_Util.bind_opt uu___2
-                      (fun a11 ->
-                         let uu___3 = unembed e2 a2 ncb in
-                         FStar_Compiler_Util.bind_opt uu___3
-                           (fun a21 ->
-                              let r1 = f a11 a21 in
-                              let uu___4 =
-                                let uu___5 =
-                                  FStar_TypeChecker_Cfg.psc_range psc in
-                                embed er uu___5 r1 ncb in
-                              FStar_Pervasives_Native.Some uu___4))
-                | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_3 :
-  'r 't1 't2 't3 .
-    ('t1 -> 't2 -> 't3 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            'r FStar_Syntax_Embeddings.embedding ->
-              FStar_TypeChecker_Cfg.psc ->
-                FStar_Syntax_Embeddings.norm_cb ->
-                  FStar_Syntax_Syntax.args ->
-                    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun er ->
-            fun psc ->
-              fun ncb ->
-                fun args ->
-                  match args with
-                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::[] ->
-                      let uu___3 = unembed e1 a1 ncb in
-                      FStar_Compiler_Util.bind_opt uu___3
-                        (fun a11 ->
-                           let uu___4 = unembed e2 a2 ncb in
-                           FStar_Compiler_Util.bind_opt uu___4
-                             (fun a21 ->
-                                let uu___5 = unembed e3 a3 ncb in
-                                FStar_Compiler_Util.bind_opt uu___5
-                                  (fun a31 ->
-                                     let r1 = f a11 a21 a31 in
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_TypeChecker_Cfg.psc_range psc in
-                                       embed er uu___7 r1 ncb in
-                                     FStar_Pervasives_Native.Some uu___6)))
-                  | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_4 :
-  'r 't1 't2 't3 't4 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              'r FStar_Syntax_Embeddings.embedding ->
-                FStar_TypeChecker_Cfg.psc ->
-                  FStar_Syntax_Embeddings.norm_cb ->
-                    FStar_Syntax_Syntax.args ->
-                      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun er ->
-              fun psc ->
-                fun ncb ->
-                  fun args ->
-                    match args with
-                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::[]
-                        ->
-                        let uu___4 = unembed e1 a1 ncb in
-                        FStar_Compiler_Util.bind_opt uu___4
-                          (fun a11 ->
-                             let uu___5 = unembed e2 a2 ncb in
-                             FStar_Compiler_Util.bind_opt uu___5
-                               (fun a21 ->
-                                  let uu___6 = unembed e3 a3 ncb in
-                                  FStar_Compiler_Util.bind_opt uu___6
-                                    (fun a31 ->
-                                       let uu___7 = unembed e4 a4 ncb in
-                                       FStar_Compiler_Util.bind_opt uu___7
-                                         (fun a41 ->
-                                            let r1 = f a11 a21 a31 a41 in
-                                            let uu___8 =
-                                              let uu___9 =
-                                                FStar_TypeChecker_Cfg.psc_range
-                                                  psc in
-                                              embed er uu___9 r1 ncb in
-                                            FStar_Pervasives_Native.Some
-                                              uu___8))))
-                    | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_5 :
-  'r 't1 't2 't3 't4 't5 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                'r FStar_Syntax_Embeddings.embedding ->
-                  FStar_TypeChecker_Cfg.psc ->
-                    FStar_Syntax_Embeddings.norm_cb ->
-                      FStar_Syntax_Syntax.args ->
-                        FStar_Syntax_Syntax.term
-                          FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun er ->
-                fun psc ->
-                  fun ncb ->
-                    fun args ->
-                      match args with
-                      | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                          (a5, uu___4)::[] ->
-                          let uu___5 = unembed e1 a1 ncb in
-                          FStar_Compiler_Util.bind_opt uu___5
-                            (fun a11 ->
-                               let uu___6 = unembed e2 a2 ncb in
-                               FStar_Compiler_Util.bind_opt uu___6
-                                 (fun a21 ->
-                                    let uu___7 = unembed e3 a3 ncb in
-                                    FStar_Compiler_Util.bind_opt uu___7
-                                      (fun a31 ->
-                                         let uu___8 = unembed e4 a4 ncb in
-                                         FStar_Compiler_Util.bind_opt uu___8
-                                           (fun a41 ->
-                                              let uu___9 = unembed e5 a5 ncb in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___9
-                                                (fun a51 ->
-                                                   let r1 =
-                                                     f a11 a21 a31 a41 a51 in
-                                                   let uu___10 =
-                                                     let uu___11 =
-                                                       FStar_TypeChecker_Cfg.psc_range
-                                                         psc in
-                                                     embed er uu___11 r1 ncb in
-                                                   FStar_Pervasives_Native.Some
-                                                     uu___10)))))
-                      | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_6 :
-  'r 't1 't2 't3 't4 't5 't6 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  'r FStar_Syntax_Embeddings.embedding ->
-                    FStar_TypeChecker_Cfg.psc ->
-                      FStar_Syntax_Embeddings.norm_cb ->
-                        FStar_Syntax_Syntax.args ->
-                          FStar_Syntax_Syntax.term
-                            FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun er ->
-                  fun psc ->
-                    fun ncb ->
-                      fun args ->
-                        match args with
-                        | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4,
-                                                                    uu___3)::
-                            (a5, uu___4)::(a6, uu___5)::[] ->
-                            let uu___6 = unembed e1 a1 ncb in
-                            FStar_Compiler_Util.bind_opt uu___6
-                              (fun a11 ->
-                                 let uu___7 = unembed e2 a2 ncb in
-                                 FStar_Compiler_Util.bind_opt uu___7
-                                   (fun a21 ->
-                                      let uu___8 = unembed e3 a3 ncb in
-                                      FStar_Compiler_Util.bind_opt uu___8
-                                        (fun a31 ->
-                                           let uu___9 = unembed e4 a4 ncb in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___9
-                                             (fun a41 ->
-                                                let uu___10 =
-                                                  unembed e5 a5 ncb in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___10
-                                                  (fun a51 ->
-                                                     let uu___11 =
-                                                       unembed e6 a6 ncb in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___11
-                                                       (fun a61 ->
-                                                          let r1 =
-                                                            f a11 a21 a31 a41
-                                                              a51 a61 in
-                                                          let uu___12 =
-                                                            let uu___13 =
-                                                              FStar_TypeChecker_Cfg.psc_range
-                                                                psc in
-                                                            embed er uu___13
-                                                              r1 ncb in
-                                                          FStar_Pervasives_Native.Some
-                                                            uu___12))))))
-                        | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_7 :
-  'r 't1 't2 't3 't4 't5 't6 't7 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    'r FStar_Syntax_Embeddings.embedding ->
-                      FStar_TypeChecker_Cfg.psc ->
-                        FStar_Syntax_Embeddings.norm_cb ->
-                          FStar_Syntax_Syntax.args ->
-                            FStar_Syntax_Syntax.term
-                              FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun er ->
-                    fun psc ->
-                      fun ncb ->
-                        fun args ->
-                          match args with
-                          | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                              (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                              (a7, uu___6)::[] ->
-                              let uu___7 = unembed e1 a1 ncb in
-                              FStar_Compiler_Util.bind_opt uu___7
-                                (fun a11 ->
-                                   let uu___8 = unembed e2 a2 ncb in
-                                   FStar_Compiler_Util.bind_opt uu___8
-                                     (fun a21 ->
-                                        let uu___9 = unembed e3 a3 ncb in
-                                        FStar_Compiler_Util.bind_opt uu___9
-                                          (fun a31 ->
-                                             let uu___10 = unembed e4 a4 ncb in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___10
-                                               (fun a41 ->
-                                                  let uu___11 =
-                                                    unembed e5 a5 ncb in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___11
-                                                    (fun a51 ->
-                                                       let uu___12 =
-                                                         unembed e6 a6 ncb in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___12
-                                                         (fun a61 ->
-                                                            let uu___13 =
-                                                              unembed e7 a7
-                                                                ncb in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___13
-                                                              (fun a71 ->
-                                                                 let r1 =
-                                                                   f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 in
-                                                                 let uu___14
-                                                                   =
-                                                                   let uu___15
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                   embed er
-                                                                    uu___15
-                                                                    r1 ncb in
-                                                                 FStar_Pervasives_Native.Some
-                                                                   uu___14)))))))
-                          | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_8 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      'r FStar_Syntax_Embeddings.embedding ->
-                        FStar_TypeChecker_Cfg.psc ->
-                          FStar_Syntax_Embeddings.norm_cb ->
-                            FStar_Syntax_Syntax.args ->
-                              FStar_Syntax_Syntax.term
-                                FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun er ->
-                      fun psc ->
-                        fun ncb ->
-                          fun args ->
-                            match args with
-                            | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                (a7, uu___6)::(a8, uu___7)::[] ->
-                                let uu___8 = unembed e1 a1 ncb in
-                                FStar_Compiler_Util.bind_opt uu___8
-                                  (fun a11 ->
-                                     let uu___9 = unembed e2 a2 ncb in
-                                     FStar_Compiler_Util.bind_opt uu___9
-                                       (fun a21 ->
-                                          let uu___10 = unembed e3 a3 ncb in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___10
-                                            (fun a31 ->
-                                               let uu___11 =
-                                                 unembed e4 a4 ncb in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___11
-                                                 (fun a41 ->
-                                                    let uu___12 =
-                                                      unembed e5 a5 ncb in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___12
-                                                      (fun a51 ->
-                                                         let uu___13 =
-                                                           unembed e6 a6 ncb in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___13
-                                                           (fun a61 ->
-                                                              let uu___14 =
-                                                                unembed e7 a7
-                                                                  ncb in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___14
-                                                                (fun a71 ->
-                                                                   let uu___15
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___15
-                                                                    (fun a81
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81 in
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___17
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___16))))))))
-                            | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_9 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 'r) ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        'r FStar_Syntax_Embeddings.embedding ->
-                          FStar_TypeChecker_Cfg.psc ->
-                            FStar_Syntax_Embeddings.norm_cb ->
-                              FStar_Syntax_Syntax.args ->
-                                FStar_Syntax_Syntax.term
-                                  FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun er ->
-                        fun psc ->
-                          fun ncb ->
-                            fun args ->
-                              match args with
-                              | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                  (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                  (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::[]
-                                  ->
-                                  let uu___9 = unembed e1 a1 ncb in
-                                  FStar_Compiler_Util.bind_opt uu___9
-                                    (fun a11 ->
-                                       let uu___10 = unembed e2 a2 ncb in
-                                       FStar_Compiler_Util.bind_opt uu___10
-                                         (fun a21 ->
-                                            let uu___11 = unembed e3 a3 ncb in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___11
-                                              (fun a31 ->
-                                                 let uu___12 =
-                                                   unembed e4 a4 ncb in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___12
-                                                   (fun a41 ->
-                                                      let uu___13 =
-                                                        unembed e5 a5 ncb in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___13
-                                                        (fun a51 ->
-                                                           let uu___14 =
-                                                             unembed e6 a6
-                                                               ncb in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___14
-                                                             (fun a61 ->
-                                                                let uu___15 =
-                                                                  unembed e7
-                                                                    a7 ncb in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___15
-                                                                  (fun a71 ->
-                                                                    let uu___16
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___16
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___17
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a91
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 in
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___19
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___18)))))))))
-                              | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_10 :
-  'r 't1 't10 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          'r FStar_Syntax_Embeddings.embedding ->
-                            FStar_TypeChecker_Cfg.psc ->
-                              FStar_Syntax_Embeddings.norm_cb ->
-                                FStar_Syntax_Syntax.args ->
-                                  FStar_Syntax_Syntax.term
-                                    FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun er ->
-                          fun psc ->
-                            fun ncb ->
-                              fun args ->
-                                match args with
-                                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                    (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                    (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                    (a10, uu___9)::[] ->
-                                    let uu___10 = unembed e1 a1 ncb in
-                                    FStar_Compiler_Util.bind_opt uu___10
-                                      (fun a11 ->
-                                         let uu___11 = unembed e2 a2 ncb in
-                                         FStar_Compiler_Util.bind_opt uu___11
-                                           (fun a21 ->
-                                              let uu___12 = unembed e3 a3 ncb in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___12
-                                                (fun a31 ->
-                                                   let uu___13 =
-                                                     unembed e4 a4 ncb in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___13
-                                                     (fun a41 ->
-                                                        let uu___14 =
-                                                          unembed e5 a5 ncb in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___14
-                                                          (fun a51 ->
-                                                             let uu___15 =
-                                                               unembed e6 a6
-                                                                 ncb in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___15
-                                                               (fun a61 ->
-                                                                  let uu___16
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___16
-                                                                    (
-                                                                    fun a71
-                                                                    ->
-                                                                    let uu___17
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a101
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101 in
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___21
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___20))))))))))
-                                | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_11 :
-  'r 't1 't10 't11 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            'r FStar_Syntax_Embeddings.embedding ->
-                              FStar_TypeChecker_Cfg.psc ->
-                                FStar_Syntax_Embeddings.norm_cb ->
-                                  FStar_Syntax_Syntax.args ->
-                                    FStar_Syntax_Syntax.term
-                                      FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun er ->
-                            fun psc ->
-                              fun ncb ->
-                                fun args ->
-                                  match args with
-                                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                      (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                      (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                   uu___8)::
-                                      (a10, uu___9)::(a11, uu___10)::[] ->
-                                      let uu___11 = unembed e1 a1 ncb in
-                                      FStar_Compiler_Util.bind_opt uu___11
-                                        (fun a12 ->
-                                           let uu___12 = unembed e2 a2 ncb in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___12
-                                             (fun a21 ->
-                                                let uu___13 =
-                                                  unembed e3 a3 ncb in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___13
-                                                  (fun a31 ->
-                                                     let uu___14 =
-                                                       unembed e4 a4 ncb in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___14
-                                                       (fun a41 ->
-                                                          let uu___15 =
-                                                            unembed e5 a5 ncb in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___15
-                                                            (fun a51 ->
-                                                               let uu___16 =
-                                                                 unembed e6
-                                                                   a6 ncb in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___16
-                                                                 (fun a61 ->
-                                                                    let uu___17
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a111
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a12 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 in
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___23
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___22)))))))))))
-                                  | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_12 :
-  'r 't1 't10 't11 't12 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              'r FStar_Syntax_Embeddings.embedding ->
-                                FStar_TypeChecker_Cfg.psc ->
-                                  FStar_Syntax_Embeddings.norm_cb ->
-                                    FStar_Syntax_Syntax.args ->
-                                      FStar_Syntax_Syntax.term
-                                        FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun er ->
-                              fun psc ->
-                                fun ncb ->
-                                  fun args ->
-                                    match args with
-                                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                        (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                        (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                    uu___8)::
-                                        (a10, uu___9)::(a11, uu___10)::
-                                        (a12, uu___11)::[] ->
-                                        let uu___12 = unembed e1 a1 ncb in
-                                        FStar_Compiler_Util.bind_opt uu___12
-                                          (fun a13 ->
-                                             let uu___13 = unembed e2 a2 ncb in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___13
-                                               (fun a21 ->
-                                                  let uu___14 =
-                                                    unembed e3 a3 ncb in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___14
-                                                    (fun a31 ->
-                                                       let uu___15 =
-                                                         unembed e4 a4 ncb in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___15
-                                                         (fun a41 ->
-                                                            let uu___16 =
-                                                              unembed e5 a5
-                                                                ncb in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___16
-                                                              (fun a51 ->
-                                                                 let uu___17
-                                                                   =
-                                                                   unembed e6
-                                                                    a6 ncb in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___17
-                                                                   (fun a61
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a121
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a13 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121 in
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___25
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24))))))))))))
-                                    | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_13 :
-  'r 't1 't10 't11 't12 't13 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 't13 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                'r FStar_Syntax_Embeddings.embedding ->
-                                  FStar_TypeChecker_Cfg.psc ->
-                                    FStar_Syntax_Embeddings.norm_cb ->
-                                      FStar_Syntax_Syntax.args ->
-                                        FStar_Syntax_Syntax.term
-                                          FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun er ->
-                                fun psc ->
-                                  fun ncb ->
-                                    fun args ->
-                                      match args with
-                                      | (a1, uu___)::(a2, uu___1)::(a3,
-                                                                    uu___2)::
-                                          (a4, uu___3)::(a5, uu___4)::
-                                          (a6, uu___5)::(a7, uu___6)::
-                                          (a8, uu___7)::(a9, uu___8)::
-                                          (a10, uu___9)::(a11, uu___10)::
-                                          (a12, uu___11)::(a13, uu___12)::[]
-                                          ->
-                                          let uu___13 = unembed e1 a1 ncb in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___13
-                                            (fun a14 ->
-                                               let uu___14 =
-                                                 unembed e2 a2 ncb in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___14
-                                                 (fun a21 ->
-                                                    let uu___15 =
-                                                      unembed e3 a3 ncb in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___15
-                                                      (fun a31 ->
-                                                         let uu___16 =
-                                                           unembed e4 a4 ncb in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___16
-                                                           (fun a41 ->
-                                                              let uu___17 =
-                                                                unembed e5 a5
-                                                                  ncb in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___17
-                                                                (fun a51 ->
-                                                                   let uu___18
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a131
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a14 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 in
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___27
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___26)))))))))))))
-                                      | uu___ -> FStar_Pervasives_Native.None
-let mk_total_interpretation_14 :
-  'r 't1 't10 't11 't12 't13 't14 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 't13 -> 't14 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  'r FStar_Syntax_Embeddings.embedding ->
-                                    FStar_TypeChecker_Cfg.psc ->
-                                      FStar_Syntax_Embeddings.norm_cb ->
-                                        FStar_Syntax_Syntax.args ->
-                                          FStar_Syntax_Syntax.term
-                                            FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun er ->
-                                  fun psc ->
-                                    fun ncb ->
-                                      fun args ->
-                                        match args with
-                                        | (a1, uu___)::(a2, uu___1)::
-                                            (a3, uu___2)::(a4, uu___3)::
-                                            (a5, uu___4)::(a6, uu___5)::
-                                            (a7, uu___6)::(a8, uu___7)::
-                                            (a9, uu___8)::(a10, uu___9)::
-                                            (a11, uu___10)::(a12, uu___11)::
-                                            (a13, uu___12)::(a14, uu___13)::[]
-                                            ->
-                                            let uu___14 = unembed e1 a1 ncb in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___14
-                                              (fun a15 ->
-                                                 let uu___15 =
-                                                   unembed e2 a2 ncb in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___15
-                                                   (fun a21 ->
-                                                      let uu___16 =
-                                                        unembed e3 a3 ncb in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___16
-                                                        (fun a31 ->
-                                                           let uu___17 =
-                                                             unembed e4 a4
-                                                               ncb in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___17
-                                                             (fun a41 ->
-                                                                let uu___18 =
-                                                                  unembed e5
-                                                                    a5 ncb in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___18
-                                                                  (fun a51 ->
-                                                                    let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a141
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a15 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141 in
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___29
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___28))))))))))))))
-                                        | uu___ ->
-                                            FStar_Pervasives_Native.None
-let mk_total_interpretation_15 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 -> 't11 -> 't12 -> 't13 -> 't14 -> 't15 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    'r FStar_Syntax_Embeddings.embedding ->
-                                      FStar_TypeChecker_Cfg.psc ->
-                                        FStar_Syntax_Embeddings.norm_cb ->
-                                          FStar_Syntax_Syntax.args ->
-                                            FStar_Syntax_Syntax.term
-                                              FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun er ->
-                                    fun psc ->
-                                      fun ncb ->
-                                        fun args ->
-                                          match args with
-                                          | (a1, uu___)::(a2, uu___1)::
-                                              (a3, uu___2)::(a4, uu___3)::
-                                              (a5, uu___4)::(a6, uu___5)::
-                                              (a7, uu___6)::(a8, uu___7)::
-                                              (a9, uu___8)::(a10, uu___9)::
-                                              (a11, uu___10)::(a12, uu___11)::
-                                              (a13, uu___12)::(a14, uu___13)::
-                                              (a15, uu___14)::[] ->
-                                              let uu___15 = unembed e1 a1 ncb in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___15
-                                                (fun a16 ->
-                                                   let uu___16 =
-                                                     unembed e2 a2 ncb in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___16
-                                                     (fun a21 ->
-                                                        let uu___17 =
-                                                          unembed e3 a3 ncb in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___17
-                                                          (fun a31 ->
-                                                             let uu___18 =
-                                                               unembed e4 a4
-                                                                 ncb in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___18
-                                                               (fun a41 ->
-                                                                  let uu___19
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (
-                                                                    fun a51
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a151
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a16 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 in
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___31
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___30)))))))))))))))
-                                          | uu___ ->
-                                              FStar_Pervasives_Native.None
-let mk_total_interpretation_16 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't2 't3 't4 't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 -> 't12 -> 't13 -> 't14 -> 't15 -> 't16 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      'r FStar_Syntax_Embeddings.embedding ->
-                                        FStar_TypeChecker_Cfg.psc ->
-                                          FStar_Syntax_Embeddings.norm_cb ->
-                                            FStar_Syntax_Syntax.args ->
-                                              FStar_Syntax_Syntax.term
-                                                FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun er ->
-                                      fun psc ->
-                                        fun ncb ->
-                                          fun args ->
-                                            match args with
-                                            | (a1, uu___)::(a2, uu___1)::
-                                                (a3, uu___2)::(a4, uu___3)::
-                                                (a5, uu___4)::(a6, uu___5)::
-                                                (a7, uu___6)::(a8, uu___7)::
-                                                (a9, uu___8)::(a10, uu___9)::
-                                                (a11, uu___10)::(a12,
-                                                                 uu___11)::
-                                                (a13, uu___12)::(a14,
-                                                                 uu___13)::
-                                                (a15, uu___14)::(a16,
-                                                                 uu___15)::[]
-                                                ->
-                                                let uu___16 =
-                                                  unembed e1 a1 ncb in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___16
-                                                  (fun a17 ->
-                                                     let uu___17 =
-                                                       unembed e2 a2 ncb in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___17
-                                                       (fun a21 ->
-                                                          let uu___18 =
-                                                            unembed e3 a3 ncb in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___18
-                                                            (fun a31 ->
-                                                               let uu___19 =
-                                                                 unembed e4
-                                                                   a4 ncb in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___19
-                                                                 (fun a41 ->
-                                                                    let uu___20
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a161
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a17 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161 in
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___33
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___32))))))))))))))))
-                                            | uu___ ->
-                                                FStar_Pervasives_Native.None
-let mk_total_interpretation_17 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't2 't3 't4 't5 't6 't7 't8
-    't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 -> 't13 -> 't14 -> 't15 -> 't16 -> 't17 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        'r FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          FStar_TypeChecker_Cfg.psc ->
-                                            FStar_Syntax_Embeddings.norm_cb
-                                              ->
-                                              FStar_Syntax_Syntax.args ->
-                                                FStar_Syntax_Syntax.term
-                                                  FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun er ->
-                                        fun psc ->
-                                          fun ncb ->
-                                            fun args ->
-                                              match args with
-                                              | (a1, uu___)::(a2, uu___1)::
-                                                  (a3, uu___2)::(a4, uu___3)::
-                                                  (a5, uu___4)::(a6, uu___5)::
-                                                  (a7, uu___6)::(a8, uu___7)::
-                                                  (a9, uu___8)::(a10, uu___9)::
-                                                  (a11, uu___10)::(a12,
-                                                                   uu___11)::
-                                                  (a13, uu___12)::(a14,
-                                                                   uu___13)::
-                                                  (a15, uu___14)::(a16,
-                                                                   uu___15)::
-                                                  (a17, uu___16)::[] ->
-                                                  let uu___17 =
-                                                    unembed e1 a1 ncb in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___17
-                                                    (fun a18 ->
-                                                       let uu___18 =
-                                                         unembed e2 a2 ncb in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___18
-                                                         (fun a21 ->
-                                                            let uu___19 =
-                                                              unembed e3 a3
-                                                                ncb in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___19
-                                                              (fun a31 ->
-                                                                 let uu___20
-                                                                   =
-                                                                   unembed e4
-                                                                    a4 ncb in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___20
-                                                                   (fun a41
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a171
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a18 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161
-                                                                    a171 in
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___35
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___34)))))))))))))))))
-                                              | uu___ ->
-                                                  FStar_Pervasives_Native.None
-let mk_total_interpretation_18 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't2 't3 't4 't5 't6 't7
-    't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 -> 't15 -> 't16 -> 't17 -> 't18 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't18
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          'r
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            FStar_TypeChecker_Cfg.psc ->
-                                              FStar_Syntax_Embeddings.norm_cb
-                                                ->
-                                                FStar_Syntax_Syntax.args ->
-                                                  FStar_Syntax_Syntax.term
-                                                    FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun e18 ->
-                                        fun er ->
-                                          fun psc ->
-                                            fun ncb ->
-                                              fun args ->
-                                                match args with
-                                                | (a1, uu___)::(a2, uu___1)::
-                                                    (a3, uu___2)::(a4,
-                                                                   uu___3)::
-                                                    (a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                                    (a7, uu___6)::(a8,
-                                                                   uu___7)::
-                                                    (a9, uu___8)::(a10,
-                                                                   uu___9)::
-                                                    (a11, uu___10)::(a12,
-                                                                    uu___11)::
-                                                    (a13, uu___12)::(a14,
-                                                                    uu___13)::
-                                                    (a15, uu___14)::(a16,
-                                                                    uu___15)::
-                                                    (a17, uu___16)::(a18,
-                                                                    uu___17)::[]
-                                                    ->
-                                                    let uu___18 =
-                                                      unembed e1 a1 ncb in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___18
-                                                      (fun a19 ->
-                                                         let uu___19 =
-                                                           unembed e2 a2 ncb in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___19
-                                                           (fun a21 ->
-                                                              let uu___20 =
-                                                                unembed e3 a3
-                                                                  ncb in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___20
-                                                                (fun a31 ->
-                                                                   let uu___21
-                                                                    =
-                                                                    unembed
-                                                                    e4 a4 ncb in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    e18 a18
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a181
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a19 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161
-                                                                    a171 a181 in
-                                                                    let uu___36
-                                                                    =
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___37
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___36))))))))))))))))))
-                                                | uu___ ->
-                                                    FStar_Pervasives_Native.None
-let mk_total_interpretation_19 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't3 't4 't5
-    't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 -> 't16 -> 't17 -> 't18 -> 't19 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't18
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't19
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            'r
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              FStar_TypeChecker_Cfg.psc ->
-                                                FStar_Syntax_Embeddings.norm_cb
-                                                  ->
-                                                  FStar_Syntax_Syntax.args ->
-                                                    FStar_Syntax_Syntax.term
-                                                      FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun e18 ->
-                                        fun e19 ->
-                                          fun er ->
-                                            fun psc ->
-                                              fun ncb ->
-                                                fun args ->
-                                                  match args with
-                                                  | (a1, uu___)::(a2, uu___1)::
-                                                      (a3, uu___2)::(a4,
-                                                                    uu___3)::
-                                                      (a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                                      (a7, uu___6)::(a8,
-                                                                    uu___7)::
-                                                      (a9, uu___8)::(a10,
-                                                                    uu___9)::
-                                                      (a11, uu___10)::
-                                                      (a12, uu___11)::
-                                                      (a13, uu___12)::
-                                                      (a14, uu___13)::
-                                                      (a15, uu___14)::
-                                                      (a16, uu___15)::
-                                                      (a17, uu___16)::
-                                                      (a18, uu___17)::
-                                                      (a19, uu___18)::[] ->
-                                                      let uu___19 =
-                                                        unembed e1 a1 ncb in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___19
-                                                        (fun a110 ->
-                                                           let uu___20 =
-                                                             unembed e2 a2
-                                                               ncb in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___20
-                                                             (fun a21 ->
-                                                                let uu___21 =
-                                                                  unembed e3
-                                                                    a3 ncb in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___21
-                                                                  (fun a31 ->
-                                                                    let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e4 a4 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    unembed
-                                                                    e18 a18
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    unembed
-                                                                    e19 a19
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a191
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191 in
-                                                                    let uu___38
-                                                                    =
-                                                                    let uu___39
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___39
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___38)))))))))))))))))))
-                                                  | uu___ ->
-                                                      FStar_Pervasives_Native.None
-let mk_total_interpretation_20 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't20 't3 't4
-    't5 't6 't7 't8 't9 .
-    ('t1 ->
-       't2 ->
-         't3 ->
-           't4 ->
-             't5 ->
-               't6 ->
-                 't7 ->
-                   't8 ->
-                     't9 ->
-                       't10 ->
-                         't11 ->
-                           't12 ->
-                             't13 ->
-                               't14 ->
-                                 't15 ->
-                                   't16 -> 't17 -> 't18 -> 't19 -> 't20 -> 'r)
-      ->
-      't1 FStar_Syntax_Embeddings.embedding ->
-        't2 FStar_Syntax_Embeddings.embedding ->
-          't3 FStar_Syntax_Embeddings.embedding ->
-            't4 FStar_Syntax_Embeddings.embedding ->
-              't5 FStar_Syntax_Embeddings.embedding ->
-                't6 FStar_Syntax_Embeddings.embedding ->
-                  't7 FStar_Syntax_Embeddings.embedding ->
-                    't8 FStar_Syntax_Embeddings.embedding ->
-                      't9 FStar_Syntax_Embeddings.embedding ->
-                        't10 FStar_Syntax_Embeddings.embedding ->
-                          't11 FStar_Syntax_Embeddings.embedding ->
-                            't12 FStar_Syntax_Embeddings.embedding ->
-                              't13 FStar_Syntax_Embeddings.embedding ->
-                                't14 FStar_Syntax_Embeddings.embedding ->
-                                  't15 FStar_Syntax_Embeddings.embedding ->
-                                    't16 FStar_Syntax_Embeddings.embedding ->
-                                      't17 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't18
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't19
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't20
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              'r
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                FStar_TypeChecker_Cfg.psc ->
-                                                  FStar_Syntax_Embeddings.norm_cb
-                                                    ->
-                                                    FStar_Syntax_Syntax.args
-                                                      ->
-                                                      FStar_Syntax_Syntax.term
-                                                        FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun e1 ->
-      fun e2 ->
-        fun e3 ->
-          fun e4 ->
-            fun e5 ->
-              fun e6 ->
-                fun e7 ->
-                  fun e8 ->
-                    fun e9 ->
-                      fun e10 ->
-                        fun e11 ->
-                          fun e12 ->
-                            fun e13 ->
-                              fun e14 ->
-                                fun e15 ->
-                                  fun e16 ->
-                                    fun e17 ->
-                                      fun e18 ->
-                                        fun e19 ->
-                                          fun e20 ->
-                                            fun er ->
-                                              fun psc ->
-                                                fun ncb ->
-                                                  fun args ->
-                                                    match args with
-                                                    | (a1, uu___)::(a2,
-                                                                    uu___1)::
-                                                        (a3, uu___2)::
-                                                        (a4, uu___3)::
-                                                        (a5, uu___4)::
-                                                        (a6, uu___5)::
-                                                        (a7, uu___6)::
-                                                        (a8, uu___7)::
-                                                        (a9, uu___8)::
-                                                        (a10, uu___9)::
-                                                        (a11, uu___10)::
-                                                        (a12, uu___11)::
-                                                        (a13, uu___12)::
-                                                        (a14, uu___13)::
-                                                        (a15, uu___14)::
-                                                        (a16, uu___15)::
-                                                        (a17, uu___16)::
-                                                        (a18, uu___17)::
-                                                        (a19, uu___18)::
-                                                        (a20, uu___19)::[] ->
-                                                        let uu___20 =
-                                                          unembed e1 a1 ncb in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___20
-                                                          (fun a110 ->
-                                                             let uu___21 =
-                                                               unembed e2 a2
-                                                                 ncb in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___21
-                                                               (fun a21 ->
-                                                                  let uu___22
-                                                                    =
-                                                                    unembed
-                                                                    e3 a3 ncb in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (
-                                                                    fun a31
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    unembed
-                                                                    e4 a4 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    unembed
-                                                                    e5 a5 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    unembed
-                                                                    e6 a6 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    unembed
-                                                                    e7 a7 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    unembed
-                                                                    e8 a8 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    unembed
-                                                                    e9 a9 ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    unembed
-                                                                    e10 a10
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    unembed
-                                                                    e11 a11
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    unembed
-                                                                    e12 a12
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    unembed
-                                                                    e13 a13
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    unembed
-                                                                    e14 a14
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    unembed
-                                                                    e15 a15
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    unembed
-                                                                    e16 a16
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    unembed
-                                                                    e17 a17
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    unembed
-                                                                    e18 a18
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___38
-                                                                    =
-                                                                    unembed
-                                                                    e19 a19
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___38
-                                                                    (fun a191
-                                                                    ->
-                                                                    let uu___39
-                                                                    =
-                                                                    unembed
-                                                                    e20 a20
-                                                                    ncb in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___39
-                                                                    (fun a201
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191
-                                                                    a201 in
-                                                                    let uu___40
-                                                                    =
-                                                                    let uu___41
-                                                                    =
-                                                                    FStar_TypeChecker_Cfg.psc_range
-                                                                    psc in
-                                                                    embed er
-                                                                    uu___41
-                                                                    r1 ncb in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___40))))))))))))))))))))
-                                                    | uu___ ->
-                                                        FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_1 :
-  'r 't1 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          'r FStar_TypeChecker_NBETerm.embedding ->
-            FStar_TypeChecker_NBETerm.args ->
-              FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun er ->
-          fun args ->
-            match args with
-            | (a1, uu___)::[] ->
-                let uu___1 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                FStar_Compiler_Util.bind_opt uu___1
-                  (fun a11 ->
-                     let r1 = f a11 in
-                     let uu___2 = FStar_TypeChecker_NBETerm.embed er cb r1 in
-                     FStar_Pervasives_Native.Some uu___2)
-            | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_2 :
-  'r 't1 't2 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            'r FStar_TypeChecker_NBETerm.embedding ->
-              FStar_TypeChecker_NBETerm.args ->
-                FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun er ->
-            fun args ->
-              match args with
-              | (a1, uu___)::(a2, uu___1)::[] ->
-                  let uu___2 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                  FStar_Compiler_Util.bind_opt uu___2
-                    (fun a11 ->
-                       let uu___3 =
-                         FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                       FStar_Compiler_Util.bind_opt uu___3
-                         (fun a21 ->
-                            let r1 = f a11 a21 in
-                            let uu___4 =
-                              FStar_TypeChecker_NBETerm.embed er cb r1 in
-                            FStar_Pervasives_Native.Some uu___4))
-              | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_3 :
-  'r 't1 't2 't3 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              'r FStar_TypeChecker_NBETerm.embedding ->
-                FStar_TypeChecker_NBETerm.args ->
-                  FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun er ->
-              fun args ->
-                match args with
-                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::[] ->
-                    let uu___3 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                    FStar_Compiler_Util.bind_opt uu___3
-                      (fun a11 ->
-                         let uu___4 =
-                           FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                         FStar_Compiler_Util.bind_opt uu___4
-                           (fun a21 ->
-                              let uu___5 =
-                                FStar_TypeChecker_NBETerm.unembed e3 cb a3 in
-                              FStar_Compiler_Util.bind_opt uu___5
-                                (fun a31 ->
-                                   let r1 = f a11 a21 a31 in
-                                   let uu___6 =
-                                     FStar_TypeChecker_NBETerm.embed er cb r1 in
-                                   FStar_Pervasives_Native.Some uu___6)))
-                | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_4 :
-  'r 't1 't2 't3 't4 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                'r FStar_TypeChecker_NBETerm.embedding ->
-                  FStar_TypeChecker_NBETerm.args ->
-                    FStar_TypeChecker_NBETerm.t
-                      FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun er ->
-                fun args ->
-                  match args with
-                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::[]
-                      ->
-                      let uu___4 = FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                      FStar_Compiler_Util.bind_opt uu___4
-                        (fun a11 ->
-                           let uu___5 =
-                             FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                           FStar_Compiler_Util.bind_opt uu___5
-                             (fun a21 ->
-                                let uu___6 =
-                                  FStar_TypeChecker_NBETerm.unembed e3 cb a3 in
-                                FStar_Compiler_Util.bind_opt uu___6
-                                  (fun a31 ->
-                                     let uu___7 =
-                                       FStar_TypeChecker_NBETerm.unembed e4
-                                         cb a4 in
-                                     FStar_Compiler_Util.bind_opt uu___7
-                                       (fun a41 ->
-                                          let r1 = f a11 a21 a31 a41 in
-                                          let uu___8 =
-                                            FStar_TypeChecker_NBETerm.embed
-                                              er cb r1 in
-                                          FStar_Pervasives_Native.Some uu___8))))
-                  | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_5 :
-  'r 't1 't2 't3 't4 't5 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  'r FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_NBETerm.args ->
-                      FStar_TypeChecker_NBETerm.t
-                        FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun er ->
-                  fun args ->
-                    match args with
-                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                        (a5, uu___4)::[] ->
-                        let uu___5 =
-                          FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                        FStar_Compiler_Util.bind_opt uu___5
-                          (fun a11 ->
-                             let uu___6 =
-                               FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                             FStar_Compiler_Util.bind_opt uu___6
-                               (fun a21 ->
-                                  let uu___7 =
-                                    FStar_TypeChecker_NBETerm.unembed e3 cb
-                                      a3 in
-                                  FStar_Compiler_Util.bind_opt uu___7
-                                    (fun a31 ->
-                                       let uu___8 =
-                                         FStar_TypeChecker_NBETerm.unembed e4
-                                           cb a4 in
-                                       FStar_Compiler_Util.bind_opt uu___8
-                                         (fun a41 ->
-                                            let uu___9 =
-                                              FStar_TypeChecker_NBETerm.unembed
-                                                e5 cb a5 in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___9
-                                              (fun a51 ->
-                                                 let r1 =
-                                                   f a11 a21 a31 a41 a51 in
-                                                 let uu___10 =
-                                                   FStar_TypeChecker_NBETerm.embed
-                                                     er cb r1 in
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___10)))))
-                    | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_6 :
-  'r 't1 't2 't3 't4 't5 't6 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    'r FStar_TypeChecker_NBETerm.embedding ->
-                      FStar_TypeChecker_NBETerm.args ->
-                        FStar_TypeChecker_NBETerm.t
-                          FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun er ->
-                    fun args ->
-                      match args with
-                      | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4, uu___3)::
-                          (a5, uu___4)::(a6, uu___5)::[] ->
-                          let uu___6 =
-                            FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                          FStar_Compiler_Util.bind_opt uu___6
-                            (fun a11 ->
-                               let uu___7 =
-                                 FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                               FStar_Compiler_Util.bind_opt uu___7
-                                 (fun a21 ->
-                                    let uu___8 =
-                                      FStar_TypeChecker_NBETerm.unembed e3 cb
-                                        a3 in
-                                    FStar_Compiler_Util.bind_opt uu___8
-                                      (fun a31 ->
-                                         let uu___9 =
-                                           FStar_TypeChecker_NBETerm.unembed
-                                             e4 cb a4 in
-                                         FStar_Compiler_Util.bind_opt uu___9
-                                           (fun a41 ->
-                                              let uu___10 =
-                                                FStar_TypeChecker_NBETerm.unembed
-                                                  e5 cb a5 in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___10
-                                                (fun a51 ->
-                                                   let uu___11 =
-                                                     FStar_TypeChecker_NBETerm.unembed
-                                                       e6 cb a6 in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___11
-                                                     (fun a61 ->
-                                                        let r1 =
-                                                          f a11 a21 a31 a41
-                                                            a51 a61 in
-                                                        let uu___12 =
-                                                          FStar_TypeChecker_NBETerm.embed
-                                                            er cb r1 in
-                                                        FStar_Pervasives_Native.Some
-                                                          uu___12))))))
-                      | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_7 :
-  'r 't1 't2 't3 't4 't5 't6 't7 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      'r FStar_TypeChecker_NBETerm.embedding ->
-                        FStar_TypeChecker_NBETerm.args ->
-                          FStar_TypeChecker_NBETerm.t
-                            FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun er ->
-                      fun args ->
-                        match args with
-                        | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::(a4,
-                                                                    uu___3)::
-                            (a5, uu___4)::(a6, uu___5)::(a7, uu___6)::[] ->
-                            let uu___7 =
-                              FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                            FStar_Compiler_Util.bind_opt uu___7
-                              (fun a11 ->
-                                 let uu___8 =
-                                   FStar_TypeChecker_NBETerm.unembed e2 cb a2 in
-                                 FStar_Compiler_Util.bind_opt uu___8
-                                   (fun a21 ->
-                                      let uu___9 =
-                                        FStar_TypeChecker_NBETerm.unembed e3
-                                          cb a3 in
-                                      FStar_Compiler_Util.bind_opt uu___9
-                                        (fun a31 ->
-                                           let uu___10 =
-                                             FStar_TypeChecker_NBETerm.unembed
-                                               e4 cb a4 in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___10
-                                             (fun a41 ->
-                                                let uu___11 =
-                                                  FStar_TypeChecker_NBETerm.unembed
-                                                    e5 cb a5 in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___11
-                                                  (fun a51 ->
-                                                     let uu___12 =
-                                                       FStar_TypeChecker_NBETerm.unembed
-                                                         e6 cb a6 in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___12
-                                                       (fun a61 ->
-                                                          let uu___13 =
-                                                            FStar_TypeChecker_NBETerm.unembed
-                                                              e7 cb a7 in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___13
-                                                            (fun a71 ->
-                                                               let r1 =
-                                                                 f a11 a21
-                                                                   a31 a41
-                                                                   a51 a61
-                                                                   a71 in
-                                                               let uu___14 =
-                                                                 FStar_TypeChecker_NBETerm.embed
-                                                                   er cb r1 in
-                                                               FStar_Pervasives_Native.Some
-                                                                 uu___14)))))))
-                        | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_8 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        'r FStar_TypeChecker_NBETerm.embedding ->
-                          FStar_TypeChecker_NBETerm.args ->
-                            FStar_TypeChecker_NBETerm.t
-                              FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun er ->
-                        fun args ->
-                          match args with
-                          | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                              (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                              (a7, uu___6)::(a8, uu___7)::[] ->
-                              let uu___8 =
-                                FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                              FStar_Compiler_Util.bind_opt uu___8
-                                (fun a11 ->
-                                   let uu___9 =
-                                     FStar_TypeChecker_NBETerm.unembed e2 cb
-                                       a2 in
-                                   FStar_Compiler_Util.bind_opt uu___9
-                                     (fun a21 ->
-                                        let uu___10 =
-                                          FStar_TypeChecker_NBETerm.unembed
-                                            e3 cb a3 in
-                                        FStar_Compiler_Util.bind_opt uu___10
-                                          (fun a31 ->
-                                             let uu___11 =
-                                               FStar_TypeChecker_NBETerm.unembed
-                                                 e4 cb a4 in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___11
-                                               (fun a41 ->
-                                                  let uu___12 =
-                                                    FStar_TypeChecker_NBETerm.unembed
-                                                      e5 cb a5 in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___12
-                                                    (fun a51 ->
-                                                       let uu___13 =
-                                                         FStar_TypeChecker_NBETerm.unembed
-                                                           e6 cb a6 in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___13
-                                                         (fun a61 ->
-                                                            let uu___14 =
-                                                              FStar_TypeChecker_NBETerm.unembed
-                                                                e7 cb a7 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___14
-                                                              (fun a71 ->
-                                                                 let uu___15
-                                                                   =
-                                                                   FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___15
-                                                                   (fun a81
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81 in
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___16))))))))
-                          | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_9 :
-  'r 't1 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 'r) ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          'r FStar_TypeChecker_NBETerm.embedding ->
-                            FStar_TypeChecker_NBETerm.args ->
-                              FStar_TypeChecker_NBETerm.t
-                                FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun er ->
-                          fun args ->
-                            match args with
-                            | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::[]
-                                ->
-                                let uu___9 =
-                                  FStar_TypeChecker_NBETerm.unembed e1 cb a1 in
-                                FStar_Compiler_Util.bind_opt uu___9
-                                  (fun a11 ->
-                                     let uu___10 =
-                                       FStar_TypeChecker_NBETerm.unembed e2
-                                         cb a2 in
-                                     FStar_Compiler_Util.bind_opt uu___10
-                                       (fun a21 ->
-                                          let uu___11 =
-                                            FStar_TypeChecker_NBETerm.unembed
-                                              e3 cb a3 in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___11
-                                            (fun a31 ->
-                                               let uu___12 =
-                                                 FStar_TypeChecker_NBETerm.unembed
-                                                   e4 cb a4 in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___12
-                                                 (fun a41 ->
-                                                    let uu___13 =
-                                                      FStar_TypeChecker_NBETerm.unembed
-                                                        e5 cb a5 in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___13
-                                                      (fun a51 ->
-                                                         let uu___14 =
-                                                           FStar_TypeChecker_NBETerm.unembed
-                                                             e6 cb a6 in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___14
-                                                           (fun a61 ->
-                                                              let uu___15 =
-                                                                FStar_TypeChecker_NBETerm.unembed
-                                                                  e7 cb a7 in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___15
-                                                                (fun a71 ->
-                                                                   let uu___16
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___16
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a91
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 in
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___18)))))))))
-                            | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_10 :
-  'r 't1 't10 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            'r FStar_TypeChecker_NBETerm.embedding ->
-                              FStar_TypeChecker_NBETerm.args ->
-                                FStar_TypeChecker_NBETerm.t
-                                  FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun er ->
-                            fun args ->
-                              match args with
-                              | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                  (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                  (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                  (a10, uu___9)::[] ->
-                                  let uu___10 =
-                                    FStar_TypeChecker_NBETerm.unembed e1 cb
-                                      a1 in
-                                  FStar_Compiler_Util.bind_opt uu___10
-                                    (fun a11 ->
-                                       let uu___11 =
-                                         FStar_TypeChecker_NBETerm.unembed e2
-                                           cb a2 in
-                                       FStar_Compiler_Util.bind_opt uu___11
-                                         (fun a21 ->
-                                            let uu___12 =
-                                              FStar_TypeChecker_NBETerm.unembed
-                                                e3 cb a3 in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___12
-                                              (fun a31 ->
-                                                 let uu___13 =
-                                                   FStar_TypeChecker_NBETerm.unembed
-                                                     e4 cb a4 in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___13
-                                                   (fun a41 ->
-                                                      let uu___14 =
-                                                        FStar_TypeChecker_NBETerm.unembed
-                                                          e5 cb a5 in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___14
-                                                        (fun a51 ->
-                                                           let uu___15 =
-                                                             FStar_TypeChecker_NBETerm.unembed
-                                                               e6 cb a6 in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___15
-                                                             (fun a61 ->
-                                                                let uu___16 =
-                                                                  FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___16
-                                                                  (fun a71 ->
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a101
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a11 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101 in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___20))))))))))
-                              | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_11 :
-  'r 't1 't10 't11 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              'r FStar_TypeChecker_NBETerm.embedding ->
-                                FStar_TypeChecker_NBETerm.args ->
-                                  FStar_TypeChecker_NBETerm.t
-                                    FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun er ->
-                              fun args ->
-                                match args with
-                                | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                    (a4, uu___3)::(a5, uu___4)::(a6, uu___5)::
-                                    (a7, uu___6)::(a8, uu___7)::(a9, uu___8)::
-                                    (a10, uu___9)::(a11, uu___10)::[] ->
-                                    let uu___11 =
-                                      FStar_TypeChecker_NBETerm.unembed e1 cb
-                                        a1 in
-                                    FStar_Compiler_Util.bind_opt uu___11
-                                      (fun a12 ->
-                                         let uu___12 =
-                                           FStar_TypeChecker_NBETerm.unembed
-                                             e2 cb a2 in
-                                         FStar_Compiler_Util.bind_opt uu___12
-                                           (fun a21 ->
-                                              let uu___13 =
-                                                FStar_TypeChecker_NBETerm.unembed
-                                                  e3 cb a3 in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___13
-                                                (fun a31 ->
-                                                   let uu___14 =
-                                                     FStar_TypeChecker_NBETerm.unembed
-                                                       e4 cb a4 in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___14
-                                                     (fun a41 ->
-                                                        let uu___15 =
-                                                          FStar_TypeChecker_NBETerm.unembed
-                                                            e5 cb a5 in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___15
-                                                          (fun a51 ->
-                                                             let uu___16 =
-                                                               FStar_TypeChecker_NBETerm.unembed
-                                                                 e6 cb a6 in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___16
-                                                               (fun a61 ->
-                                                                  let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___17
-                                                                    (
-                                                                    fun a71
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a111
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a12 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___22)))))))))))
-                                | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_12 :
-  'r 't1 't10 't11 't12 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                'r FStar_TypeChecker_NBETerm.embedding ->
-                                  FStar_TypeChecker_NBETerm.args ->
-                                    FStar_TypeChecker_NBETerm.t
-                                      FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun er ->
-                                fun args ->
-                                  match args with
-                                  | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                      (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                      (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                   uu___8)::
-                                      (a10, uu___9)::(a11, uu___10)::
-                                      (a12, uu___11)::[] ->
-                                      let uu___12 =
-                                        FStar_TypeChecker_NBETerm.unembed e1
-                                          cb a1 in
-                                      FStar_Compiler_Util.bind_opt uu___12
-                                        (fun a13 ->
-                                           let uu___13 =
-                                             FStar_TypeChecker_NBETerm.unembed
-                                               e2 cb a2 in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___13
-                                             (fun a21 ->
-                                                let uu___14 =
-                                                  FStar_TypeChecker_NBETerm.unembed
-                                                    e3 cb a3 in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___14
-                                                  (fun a31 ->
-                                                     let uu___15 =
-                                                       FStar_TypeChecker_NBETerm.unembed
-                                                         e4 cb a4 in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___15
-                                                       (fun a41 ->
-                                                          let uu___16 =
-                                                            FStar_TypeChecker_NBETerm.unembed
-                                                              e5 cb a5 in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___16
-                                                            (fun a51 ->
-                                                               let uu___17 =
-                                                                 FStar_TypeChecker_NBETerm.unembed
-                                                                   e6 cb a6 in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___17
-                                                                 (fun a61 ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___18
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a121
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a13 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121 in
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24))))))))))))
-                                  | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_13 :
-  'r 't1 't10 't11 't12 't13 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 't13 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  'r FStar_TypeChecker_NBETerm.embedding ->
-                                    FStar_TypeChecker_NBETerm.args ->
-                                      FStar_TypeChecker_NBETerm.t
-                                        FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun er ->
-                                  fun args ->
-                                    match args with
-                                    | (a1, uu___)::(a2, uu___1)::(a3, uu___2)::
-                                        (a4, uu___3)::(a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                        (a7, uu___6)::(a8, uu___7)::(a9,
-                                                                    uu___8)::
-                                        (a10, uu___9)::(a11, uu___10)::
-                                        (a12, uu___11)::(a13, uu___12)::[] ->
-                                        let uu___13 =
-                                          FStar_TypeChecker_NBETerm.unembed
-                                            e1 cb a1 in
-                                        FStar_Compiler_Util.bind_opt uu___13
-                                          (fun a14 ->
-                                             let uu___14 =
-                                               FStar_TypeChecker_NBETerm.unembed
-                                                 e2 cb a2 in
-                                             FStar_Compiler_Util.bind_opt
-                                               uu___14
-                                               (fun a21 ->
-                                                  let uu___15 =
-                                                    FStar_TypeChecker_NBETerm.unembed
-                                                      e3 cb a3 in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___15
-                                                    (fun a31 ->
-                                                       let uu___16 =
-                                                         FStar_TypeChecker_NBETerm.unembed
-                                                           e4 cb a4 in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___16
-                                                         (fun a41 ->
-                                                            let uu___17 =
-                                                              FStar_TypeChecker_NBETerm.unembed
-                                                                e5 cb a5 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___17
-                                                              (fun a51 ->
-                                                                 let uu___18
-                                                                   =
-                                                                   FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___18
-                                                                   (fun a61
-                                                                    ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a131
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a14 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 in
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___26)))))))))))))
-                                    | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_14 :
-  'r 't1 't10 't11 't12 't13 't14 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 't13 -> 't14 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    'r FStar_TypeChecker_NBETerm.embedding ->
-                                      FStar_TypeChecker_NBETerm.args ->
-                                        FStar_TypeChecker_NBETerm.t
-                                          FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun er ->
-                                    fun args ->
-                                      match args with
-                                      | (a1, uu___)::(a2, uu___1)::(a3,
-                                                                    uu___2)::
-                                          (a4, uu___3)::(a5, uu___4)::
-                                          (a6, uu___5)::(a7, uu___6)::
-                                          (a8, uu___7)::(a9, uu___8)::
-                                          (a10, uu___9)::(a11, uu___10)::
-                                          (a12, uu___11)::(a13, uu___12)::
-                                          (a14, uu___13)::[] ->
-                                          let uu___14 =
-                                            FStar_TypeChecker_NBETerm.unembed
-                                              e1 cb a1 in
-                                          FStar_Compiler_Util.bind_opt
-                                            uu___14
-                                            (fun a15 ->
-                                               let uu___15 =
-                                                 FStar_TypeChecker_NBETerm.unembed
-                                                   e2 cb a2 in
-                                               FStar_Compiler_Util.bind_opt
-                                                 uu___15
-                                                 (fun a21 ->
-                                                    let uu___16 =
-                                                      FStar_TypeChecker_NBETerm.unembed
-                                                        e3 cb a3 in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___16
-                                                      (fun a31 ->
-                                                         let uu___17 =
-                                                           FStar_TypeChecker_NBETerm.unembed
-                                                             e4 cb a4 in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___17
-                                                           (fun a41 ->
-                                                              let uu___18 =
-                                                                FStar_TypeChecker_NBETerm.unembed
-                                                                  e5 cb a5 in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___18
-                                                                (fun a51 ->
-                                                                   let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___19
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a141
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a15 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141 in
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___28))))))))))))))
-                                      | uu___ -> FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_15 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 -> 't11 -> 't12 -> 't13 -> 't14 -> 't15 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'r FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        FStar_TypeChecker_NBETerm.args ->
-                                          FStar_TypeChecker_NBETerm.t
-                                            FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun er ->
-                                      fun args ->
-                                        match args with
-                                        | (a1, uu___)::(a2, uu___1)::
-                                            (a3, uu___2)::(a4, uu___3)::
-                                            (a5, uu___4)::(a6, uu___5)::
-                                            (a7, uu___6)::(a8, uu___7)::
-                                            (a9, uu___8)::(a10, uu___9)::
-                                            (a11, uu___10)::(a12, uu___11)::
-                                            (a13, uu___12)::(a14, uu___13)::
-                                            (a15, uu___14)::[] ->
-                                            let uu___15 =
-                                              FStar_TypeChecker_NBETerm.unembed
-                                                e1 cb a1 in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___15
-                                              (fun a16 ->
-                                                 let uu___16 =
-                                                   FStar_TypeChecker_NBETerm.unembed
-                                                     e2 cb a2 in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___16
-                                                   (fun a21 ->
-                                                      let uu___17 =
-                                                        FStar_TypeChecker_NBETerm.unembed
-                                                          e3 cb a3 in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___17
-                                                        (fun a31 ->
-                                                           let uu___18 =
-                                                             FStar_TypeChecker_NBETerm.unembed
-                                                               e4 cb a4 in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___18
-                                                             (fun a41 ->
-                                                                let uu___19 =
-                                                                  FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___19
-                                                                  (fun a51 ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a151
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a16 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 in
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___30)))))))))))))))
-                                        | uu___ ->
-                                            FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_16 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't2 't3 't4 't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 -> 't12 -> 't13 -> 't14 -> 't15 -> 't16 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'r
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          FStar_TypeChecker_NBETerm.args ->
-                                            FStar_TypeChecker_NBETerm.t
-                                              FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun er ->
-                                        fun args ->
-                                          match args with
-                                          | (a1, uu___)::(a2, uu___1)::
-                                              (a3, uu___2)::(a4, uu___3)::
-                                              (a5, uu___4)::(a6, uu___5)::
-                                              (a7, uu___6)::(a8, uu___7)::
-                                              (a9, uu___8)::(a10, uu___9)::
-                                              (a11, uu___10)::(a12, uu___11)::
-                                              (a13, uu___12)::(a14, uu___13)::
-                                              (a15, uu___14)::(a16, uu___15)::[]
-                                              ->
-                                              let uu___16 =
-                                                FStar_TypeChecker_NBETerm.unembed
-                                                  e1 cb a1 in
-                                              FStar_Compiler_Util.bind_opt
-                                                uu___16
-                                                (fun a17 ->
-                                                   let uu___17 =
-                                                     FStar_TypeChecker_NBETerm.unembed
-                                                       e2 cb a2 in
-                                                   FStar_Compiler_Util.bind_opt
-                                                     uu___17
-                                                     (fun a21 ->
-                                                        let uu___18 =
-                                                          FStar_TypeChecker_NBETerm.unembed
-                                                            e3 cb a3 in
-                                                        FStar_Compiler_Util.bind_opt
-                                                          uu___18
-                                                          (fun a31 ->
-                                                             let uu___19 =
-                                                               FStar_TypeChecker_NBETerm.unembed
-                                                                 e4 cb a4 in
-                                                             FStar_Compiler_Util.bind_opt
-                                                               uu___19
-                                                               (fun a41 ->
-                                                                  let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                  FStar_Compiler_Util.bind_opt
-                                                                    uu___20
-                                                                    (
-                                                                    fun a51
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a161
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a17 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161 in
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___32))))))))))))))))
-                                          | uu___ ->
-                                              FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_17 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't2 't3 't4 't5 't6 't7 't8
-    't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 -> 't14 -> 't15 -> 't16 -> 't17 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'r
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            FStar_TypeChecker_NBETerm.args ->
-                                              FStar_TypeChecker_NBETerm.t
-                                                FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun er ->
-                                          fun args ->
-                                            match args with
-                                            | (a1, uu___)::(a2, uu___1)::
-                                                (a3, uu___2)::(a4, uu___3)::
-                                                (a5, uu___4)::(a6, uu___5)::
-                                                (a7, uu___6)::(a8, uu___7)::
-                                                (a9, uu___8)::(a10, uu___9)::
-                                                (a11, uu___10)::(a12,
-                                                                 uu___11)::
-                                                (a13, uu___12)::(a14,
-                                                                 uu___13)::
-                                                (a15, uu___14)::(a16,
-                                                                 uu___15)::
-                                                (a17, uu___16)::[] ->
-                                                let uu___17 =
-                                                  FStar_TypeChecker_NBETerm.unembed
-                                                    e1 cb a1 in
-                                                FStar_Compiler_Util.bind_opt
-                                                  uu___17
-                                                  (fun a18 ->
-                                                     let uu___18 =
-                                                       FStar_TypeChecker_NBETerm.unembed
-                                                         e2 cb a2 in
-                                                     FStar_Compiler_Util.bind_opt
-                                                       uu___18
-                                                       (fun a21 ->
-                                                          let uu___19 =
-                                                            FStar_TypeChecker_NBETerm.unembed
-                                                              e3 cb a3 in
-                                                          FStar_Compiler_Util.bind_opt
-                                                            uu___19
-                                                            (fun a31 ->
-                                                               let uu___20 =
-                                                                 FStar_TypeChecker_NBETerm.unembed
-                                                                   e4 cb a4 in
-                                                               FStar_Compiler_Util.bind_opt
-                                                                 uu___20
-                                                                 (fun a41 ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___21
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a171
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a18 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161
-                                                                    a171 in
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___34)))))))))))))))))
-                                            | uu___ ->
-                                                FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_18 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't2 't3 't4 't5 't6 't7
-    't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 -> 't15 -> 't16 -> 't17 -> 't18 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          't18
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'r
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              FStar_TypeChecker_NBETerm.args
-                                                ->
-                                                FStar_TypeChecker_NBETerm.t
-                                                  FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun e18 ->
-                                          fun er ->
-                                            fun args ->
-                                              match args with
-                                              | (a1, uu___)::(a2, uu___1)::
-                                                  (a3, uu___2)::(a4, uu___3)::
-                                                  (a5, uu___4)::(a6, uu___5)::
-                                                  (a7, uu___6)::(a8, uu___7)::
-                                                  (a9, uu___8)::(a10, uu___9)::
-                                                  (a11, uu___10)::(a12,
-                                                                   uu___11)::
-                                                  (a13, uu___12)::(a14,
-                                                                   uu___13)::
-                                                  (a15, uu___14)::(a16,
-                                                                   uu___15)::
-                                                  (a17, uu___16)::(a18,
-                                                                   uu___17)::[]
-                                                  ->
-                                                  let uu___18 =
-                                                    FStar_TypeChecker_NBETerm.unembed
-                                                      e1 cb a1 in
-                                                  FStar_Compiler_Util.bind_opt
-                                                    uu___18
-                                                    (fun a19 ->
-                                                       let uu___19 =
-                                                         FStar_TypeChecker_NBETerm.unembed
-                                                           e2 cb a2 in
-                                                       FStar_Compiler_Util.bind_opt
-                                                         uu___19
-                                                         (fun a21 ->
-                                                            let uu___20 =
-                                                              FStar_TypeChecker_NBETerm.unembed
-                                                                e3 cb a3 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___20
-                                                              (fun a31 ->
-                                                                 let uu___21
-                                                                   =
-                                                                   FStar_TypeChecker_NBETerm.unembed
-                                                                    e4 cb a4 in
-                                                                 FStar_Compiler_Util.bind_opt
-                                                                   uu___21
-                                                                   (fun a41
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e18 cb
-                                                                    a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a181
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a19 a21
-                                                                    a31 a41
-                                                                    a51 a61
-                                                                    a71 a81
-                                                                    a91 a101
-                                                                    a111 a121
-                                                                    a131 a141
-                                                                    a151 a161
-                                                                    a171 a181 in
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___36))))))))))))))))))
-                                              | uu___ ->
-                                                  FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_19 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't3 't4 't5
-    't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 -> 't16 -> 't17 -> 't18 -> 't19 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          't18
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            't19
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'r
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                FStar_TypeChecker_NBETerm.args
-                                                  ->
-                                                  FStar_TypeChecker_NBETerm.t
-                                                    FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun e18 ->
-                                          fun e19 ->
-                                            fun er ->
-                                              fun args ->
-                                                match args with
-                                                | (a1, uu___)::(a2, uu___1)::
-                                                    (a3, uu___2)::(a4,
-                                                                   uu___3)::
-                                                    (a5, uu___4)::(a6,
-                                                                   uu___5)::
-                                                    (a7, uu___6)::(a8,
-                                                                   uu___7)::
-                                                    (a9, uu___8)::(a10,
-                                                                   uu___9)::
-                                                    (a11, uu___10)::(a12,
-                                                                    uu___11)::
-                                                    (a13, uu___12)::(a14,
-                                                                    uu___13)::
-                                                    (a15, uu___14)::(a16,
-                                                                    uu___15)::
-                                                    (a17, uu___16)::(a18,
-                                                                    uu___17)::
-                                                    (a19, uu___18)::[] ->
-                                                    let uu___19 =
-                                                      FStar_TypeChecker_NBETerm.unembed
-                                                        e1 cb a1 in
-                                                    FStar_Compiler_Util.bind_opt
-                                                      uu___19
-                                                      (fun a110 ->
-                                                         let uu___20 =
-                                                           FStar_TypeChecker_NBETerm.unembed
-                                                             e2 cb a2 in
-                                                         FStar_Compiler_Util.bind_opt
-                                                           uu___20
-                                                           (fun a21 ->
-                                                              let uu___21 =
-                                                                FStar_TypeChecker_NBETerm.unembed
-                                                                  e3 cb a3 in
-                                                              FStar_Compiler_Util.bind_opt
-                                                                uu___21
-                                                                (fun a31 ->
-                                                                   let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e4 cb a4 in
-                                                                   FStar_Compiler_Util.bind_opt
-                                                                    uu___22
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e18 cb
-                                                                    a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e19 cb
-                                                                    a19 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a191
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191 in
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___38)))))))))))))))))))
-                                                | uu___ ->
-                                                    FStar_Pervasives_Native.None
-let mk_total_nbe_interpretation_20 :
-  'r 't1 't10 't11 't12 't13 't14 't15 't16 't17 't18 't19 't2 't20 't3 't4
-    't5 't6 't7 't8 't9 .
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      ('t1 ->
-         't2 ->
-           't3 ->
-             't4 ->
-               't5 ->
-                 't6 ->
-                   't7 ->
-                     't8 ->
-                       't9 ->
-                         't10 ->
-                           't11 ->
-                             't12 ->
-                               't13 ->
-                                 't14 ->
-                                   't15 ->
-                                     't16 ->
-                                       't17 -> 't18 -> 't19 -> 't20 -> 'r)
-        ->
-        't1 FStar_TypeChecker_NBETerm.embedding ->
-          't2 FStar_TypeChecker_NBETerm.embedding ->
-            't3 FStar_TypeChecker_NBETerm.embedding ->
-              't4 FStar_TypeChecker_NBETerm.embedding ->
-                't5 FStar_TypeChecker_NBETerm.embedding ->
-                  't6 FStar_TypeChecker_NBETerm.embedding ->
-                    't7 FStar_TypeChecker_NBETerm.embedding ->
-                      't8 FStar_TypeChecker_NBETerm.embedding ->
-                        't9 FStar_TypeChecker_NBETerm.embedding ->
-                          't10 FStar_TypeChecker_NBETerm.embedding ->
-                            't11 FStar_TypeChecker_NBETerm.embedding ->
-                              't12 FStar_TypeChecker_NBETerm.embedding ->
-                                't13 FStar_TypeChecker_NBETerm.embedding ->
-                                  't14 FStar_TypeChecker_NBETerm.embedding ->
-                                    't15 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      't16
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        't17
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          't18
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            't19
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              't20
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'r
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  FStar_TypeChecker_NBETerm.args
-                                                    ->
-                                                    FStar_TypeChecker_NBETerm.t
-                                                      FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun f ->
-      fun e1 ->
-        fun e2 ->
-          fun e3 ->
-            fun e4 ->
-              fun e5 ->
-                fun e6 ->
-                  fun e7 ->
-                    fun e8 ->
-                      fun e9 ->
-                        fun e10 ->
-                          fun e11 ->
-                            fun e12 ->
-                              fun e13 ->
-                                fun e14 ->
-                                  fun e15 ->
-                                    fun e16 ->
-                                      fun e17 ->
-                                        fun e18 ->
-                                          fun e19 ->
-                                            fun e20 ->
-                                              fun er ->
-                                                fun args ->
-                                                  match args with
-                                                  | (a1, uu___)::(a2, uu___1)::
-                                                      (a3, uu___2)::(a4,
-                                                                    uu___3)::
-                                                      (a5, uu___4)::(a6,
-                                                                    uu___5)::
-                                                      (a7, uu___6)::(a8,
-                                                                    uu___7)::
-                                                      (a9, uu___8)::(a10,
-                                                                    uu___9)::
-                                                      (a11, uu___10)::
-                                                      (a12, uu___11)::
-                                                      (a13, uu___12)::
-                                                      (a14, uu___13)::
-                                                      (a15, uu___14)::
-                                                      (a16, uu___15)::
-                                                      (a17, uu___16)::
-                                                      (a18, uu___17)::
-                                                      (a19, uu___18)::
-                                                      (a20, uu___19)::[] ->
-                                                      let uu___20 =
-                                                        FStar_TypeChecker_NBETerm.unembed
-                                                          e1 cb a1 in
-                                                      FStar_Compiler_Util.bind_opt
-                                                        uu___20
-                                                        (fun a110 ->
-                                                           let uu___21 =
-                                                             FStar_TypeChecker_NBETerm.unembed
-                                                               e2 cb a2 in
-                                                           FStar_Compiler_Util.bind_opt
-                                                             uu___21
-                                                             (fun a21 ->
-                                                                let uu___22 =
-                                                                  FStar_TypeChecker_NBETerm.unembed
-                                                                    e3 cb a3 in
-                                                                FStar_Compiler_Util.bind_opt
-                                                                  uu___22
-                                                                  (fun a31 ->
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e4 cb a4 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___23
-                                                                    (fun a41
-                                                                    ->
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e5 cb a5 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___24
-                                                                    (fun a51
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e6 cb a6 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___25
-                                                                    (fun a61
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e7 cb a7 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___26
-                                                                    (fun a71
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e8 cb a8 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___27
-                                                                    (fun a81
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e9 cb a9 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___28
-                                                                    (fun a91
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e10 cb
-                                                                    a10 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___29
-                                                                    (fun a101
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e11 cb
-                                                                    a11 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___30
-                                                                    (fun a111
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e12 cb
-                                                                    a12 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___31
-                                                                    (fun a121
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e13 cb
-                                                                    a13 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___32
-                                                                    (fun a131
-                                                                    ->
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e14 cb
-                                                                    a14 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___33
-                                                                    (fun a141
-                                                                    ->
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e15 cb
-                                                                    a15 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___34
-                                                                    (fun a151
-                                                                    ->
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e16 cb
-                                                                    a16 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___35
-                                                                    (fun a161
-                                                                    ->
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e17 cb
-                                                                    a17 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___36
-                                                                    (fun a171
-                                                                    ->
-                                                                    let uu___37
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e18 cb
-                                                                    a18 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___37
-                                                                    (fun a181
-                                                                    ->
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e19 cb
-                                                                    a19 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___38
-                                                                    (fun a191
-                                                                    ->
-                                                                    let uu___39
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.unembed
-                                                                    e20 cb
-                                                                    a20 in
-                                                                    FStar_Compiler_Util.bind_opt
-                                                                    uu___39
-                                                                    (fun a201
-                                                                    ->
-                                                                    let r1 =
-                                                                    f a110
-                                                                    a21 a31
-                                                                    a41 a51
-                                                                    a61 a71
-                                                                    a81 a91
-                                                                    a101 a111
-                                                                    a121 a131
-                                                                    a141 a151
-                                                                    a161 a171
-                                                                    a181 a191
-                                                                    a201 in
-                                                                    let uu___40
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.embed
-                                                                    er cb r1 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___40))))))))))))))))))))
-                                                  | uu___ ->
-                                                      FStar_Pervasives_Native.None
-let mk_tac_step_1 :
-  'nr 'nt1 'r 't1 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 'r FStar_Tactics_Monad.tac) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            'r FStar_Syntax_Embeddings.embedding ->
-              ('nt1 -> 'nr FStar_Tactics_Monad.tac) ->
-                'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                  'nr FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun er ->
-            fun nt ->
-              fun ne1 ->
-                fun ner ->
-                  mk name (Prims.of_int (2)) nunivs
-                    (mk_tactic_interpretation_1 t e1 er)
-                    (fun cb ->
-                       fun args ->
-                         let uu___ = drop nunivs args in
-                         mk_tactic_nbe_interpretation_1 cb nt ne1 ner uu___)
-let mk_tac_step_2 :
-  'nr 'nt1 'nt2 'r 't1 't2 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 'r FStar_Tactics_Monad.tac) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              'r FStar_Syntax_Embeddings.embedding ->
-                ('nt1 -> 'nt2 -> 'nr FStar_Tactics_Monad.tac) ->
-                  'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                    'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                      'nr FStar_TypeChecker_NBETerm.embedding ->
-                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun er ->
-              fun nt ->
-                fun ne1 ->
-                  fun ne2 ->
-                    fun ner ->
-                      mk name (Prims.of_int (3)) nunivs
-                        (mk_tactic_interpretation_2 t e1 e2 er)
-                        (fun cb ->
-                           fun args ->
-                             let uu___ = drop nunivs args in
-                             mk_tactic_nbe_interpretation_2 cb nt ne1 ne2 ner
-                               uu___)
-let mk_tac_step_3 :
-  'nr 'nt1 'nt2 'nt3 'r 't1 't2 't3 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 'r FStar_Tactics_Monad.tac) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                'r FStar_Syntax_Embeddings.embedding ->
-                  ('nt1 -> 'nt2 -> 'nt3 -> 'nr FStar_Tactics_Monad.tac) ->
-                    'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                      'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                        'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                          'nr FStar_TypeChecker_NBETerm.embedding ->
-                            FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun er ->
-                fun nt ->
-                  fun ne1 ->
-                    fun ne2 ->
-                      fun ne3 ->
-                        fun ner ->
-                          mk name (Prims.of_int (4)) nunivs
-                            (mk_tactic_interpretation_3 t e1 e2 e3 er)
-                            (fun cb ->
-                               fun args ->
-                                 let uu___ = drop nunivs args in
-                                 mk_tactic_nbe_interpretation_3 cb nt ne1 ne2
-                                   ne3 ner uu___)
-let mk_tac_step_4 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'r 't1 't2 't3 't4 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 'r FStar_Tactics_Monad.tac) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  'r FStar_Syntax_Embeddings.embedding ->
-                    ('nt1 ->
-                       'nt2 -> 'nt3 -> 'nt4 -> 'nr FStar_Tactics_Monad.tac)
-                      ->
-                      'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                        'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                          'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                            'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                              'nr FStar_TypeChecker_NBETerm.embedding ->
-                                FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun er ->
-                  fun nt ->
-                    fun ne1 ->
-                      fun ne2 ->
-                        fun ne3 ->
-                          fun ne4 ->
-                            fun ner ->
-                              mk name (Prims.of_int (5)) nunivs
-                                (mk_tactic_interpretation_4 t e1 e2 e3 e4 er)
-                                (fun cb ->
-                                   fun args ->
-                                     let uu___ = drop nunivs args in
-                                     mk_tactic_nbe_interpretation_4 cb nt ne1
-                                       ne2 ne3 ne4 ner uu___)
-let mk_tac_step_5 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'r 't1 't2 't3 't4 't5 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 'r FStar_Tactics_Monad.tac) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    'r FStar_Syntax_Embeddings.embedding ->
-                      ('nt1 ->
-                         'nt2 ->
-                           'nt3 ->
-                             'nt4 -> 'nt5 -> 'nr FStar_Tactics_Monad.tac)
-                        ->
-                        'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                          'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                            'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                              'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt5 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nr FStar_TypeChecker_NBETerm.embedding ->
-                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun er ->
-                    fun nt ->
-                      fun ne1 ->
-                        fun ne2 ->
-                          fun ne3 ->
-                            fun ne4 ->
-                              fun ne5 ->
-                                fun ner ->
-                                  mk name (Prims.of_int (6)) nunivs
-                                    (mk_tactic_interpretation_5 t e1 e2 e3 e4
-                                       e5 er)
-                                    (fun cb ->
-                                       fun args ->
-                                         let uu___ = drop nunivs args in
-                                         mk_tactic_nbe_interpretation_5 cb nt
-                                           ne1 ne2 ne3 ne4 ne5 ner uu___)
-let mk_tac_step_6 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'r 't1 't2 't3 't4 't5 't6 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      'r FStar_Syntax_Embeddings.embedding ->
-                        ('nt1 ->
-                           'nt2 ->
-                             'nt3 ->
-                               'nt4 ->
-                                 'nt5 -> 'nt6 -> 'nr FStar_Tactics_Monad.tac)
-                          ->
-                          'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                            'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                              'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt5 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt6 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nr FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun er ->
-                      fun nt ->
-                        fun ne1 ->
-                          fun ne2 ->
-                            fun ne3 ->
-                              fun ne4 ->
-                                fun ne5 ->
-                                  fun ne6 ->
-                                    fun ner ->
-                                      mk name (Prims.of_int (7)) nunivs
-                                        (mk_tactic_interpretation_6 t e1 e2
-                                           e3 e4 e5 e6 er)
-                                        (fun cb ->
-                                           fun args ->
-                                             let uu___ = drop nunivs args in
-                                             mk_tactic_nbe_interpretation_6
-                                               cb nt ne1 ne2 ne3 ne4 ne5 ne6
-                                               ner uu___)
-let mk_tac_step_7 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'r 't1 't2 't3 't4 't5 't6 't7 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        'r FStar_Syntax_Embeddings.embedding ->
-                          ('nt1 ->
-                             'nt2 ->
-                               'nt3 ->
-                                 'nt4 ->
-                                   'nt5 ->
-                                     'nt6 ->
-                                       'nt7 -> 'nr FStar_Tactics_Monad.tac)
-                            ->
-                            'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                              'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt5 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt6
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt7
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nr
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun er ->
-                        fun nt ->
-                          fun ne1 ->
-                            fun ne2 ->
-                              fun ne3 ->
-                                fun ne4 ->
-                                  fun ne5 ->
-                                    fun ne6 ->
-                                      fun ne7 ->
-                                        fun ner ->
-                                          mk name (Prims.of_int (8)) nunivs
-                                            (mk_tactic_interpretation_7 t e1
-                                               e2 e3 e4 e5 e6 e7 er)
-                                            (fun cb ->
-                                               fun args ->
-                                                 let uu___ = drop nunivs args in
-                                                 mk_tactic_nbe_interpretation_7
-                                                   cb nt ne1 ne2 ne3 ne4 ne5
-                                                   ne6 ne7 ner uu___)
-let mk_tac_step_8 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'r 't1 't2 't3 't4 't5 't6 't7
-    't8 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          'r FStar_Syntax_Embeddings.embedding ->
-                            ('nt1 ->
-                               'nt2 ->
-                                 'nt3 ->
-                                   'nt4 ->
-                                     'nt5 ->
-                                       'nt6 ->
-                                         'nt7 ->
-                                           'nt8 ->
-                                             'nr FStar_Tactics_Monad.tac)
-                              ->
-                              'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt4 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt5
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt6
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt7
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt8
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nr
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun er ->
-                          fun nt ->
-                            fun ne1 ->
-                              fun ne2 ->
-                                fun ne3 ->
-                                  fun ne4 ->
-                                    fun ne5 ->
-                                      fun ne6 ->
-                                        fun ne7 ->
-                                          fun ne8 ->
-                                            fun ner ->
-                                              mk name (Prims.of_int (9))
-                                                nunivs
-                                                (mk_tactic_interpretation_8 t
-                                                   e1 e2 e3 e4 e5 e6 e7 e8 er)
-                                                (fun cb ->
-                                                   fun args ->
-                                                     let uu___ =
-                                                       drop nunivs args in
-                                                     mk_tactic_nbe_interpretation_8
-                                                       cb nt ne1 ne2 ne3 ne4
-                                                       ne5 ne6 ne7 ne8 ner
-                                                       uu___)
-let mk_tac_step_9 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't2 't3 't4 't5 't6
-    't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 -> 't7 -> 't8 -> 't9 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            'r FStar_Syntax_Embeddings.embedding ->
-                              ('nt1 ->
-                                 'nt2 ->
-                                   'nt3 ->
-                                     'nt4 ->
-                                       'nt5 ->
-                                         'nt6 ->
-                                           'nt7 ->
-                                             'nt8 ->
-                                               'nt9 ->
-                                                 'nr FStar_Tactics_Monad.tac)
-                                ->
-                                'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt3 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt4
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt5
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt6
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt7
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt8
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt9
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nr
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun er ->
-                            fun nt ->
-                              fun ne1 ->
-                                fun ne2 ->
-                                  fun ne3 ->
-                                    fun ne4 ->
-                                      fun ne5 ->
-                                        fun ne6 ->
-                                          fun ne7 ->
-                                            fun ne8 ->
-                                              fun ne9 ->
-                                                fun ner ->
-                                                  mk name (Prims.of_int (10))
-                                                    nunivs
-                                                    (mk_tactic_interpretation_9
-                                                       t e1 e2 e3 e4 e5 e6 e7
-                                                       e8 e9 er)
-                                                    (fun cb ->
-                                                       fun args ->
-                                                         let uu___ =
-                                                           drop nunivs args in
-                                                         mk_tactic_nbe_interpretation_9
-                                                           cb nt ne1 ne2 ne3
-                                                           ne4 ne5 ne6 ne7
-                                                           ne8 ne9 ner uu___)
-let mk_tac_step_10 :
-  'nr 'nt1 'nt10 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't2 't3
-    't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 -> 't8 -> 't9 -> 't10 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              'r FStar_Syntax_Embeddings.embedding ->
-                                ('nt1 ->
-                                   'nt2 ->
-                                     'nt3 ->
-                                       'nt4 ->
-                                         'nt5 ->
-                                           'nt6 ->
-                                             'nt7 ->
-                                               'nt8 ->
-                                                 'nt9 ->
-                                                   'nt10 ->
-                                                     'nr
-                                                       FStar_Tactics_Monad.tac)
-                                  ->
-                                  'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt2 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt3
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt4
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt5
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt6
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt7
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt8
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt9
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt10
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nr
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun er ->
-                              fun nt ->
-                                fun ne1 ->
-                                  fun ne2 ->
-                                    fun ne3 ->
-                                      fun ne4 ->
-                                        fun ne5 ->
-                                          fun ne6 ->
-                                            fun ne7 ->
-                                              fun ne8 ->
-                                                fun ne9 ->
-                                                  fun ne10 ->
-                                                    fun ner ->
-                                                      mk name
-                                                        (Prims.of_int (11))
-                                                        nunivs
-                                                        (mk_tactic_interpretation_10
-                                                           t e1 e2 e3 e4 e5
-                                                           e6 e7 e8 e9 e10 er)
-                                                        (fun cb ->
-                                                           fun args ->
-                                                             let uu___ =
-                                                               drop nunivs
-                                                                 args in
-                                                             mk_tactic_nbe_interpretation_10
-                                                               cb nt ne1 ne2
-                                                               ne3 ne4 ne5
-                                                               ne6 ne7 ne8
-                                                               ne9 ne10 ner
-                                                               uu___)
-let mk_tac_step_11 :
-  'nr 'nt1 'nt10 'nt11 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10
-    't11 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 -> 't10 -> 't11 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                'r FStar_Syntax_Embeddings.embedding ->
-                                  ('nt1 ->
-                                     'nt2 ->
-                                       'nt3 ->
-                                         'nt4 ->
-                                           'nt5 ->
-                                             'nt6 ->
-                                               'nt7 ->
-                                                 'nt8 ->
-                                                   'nt9 ->
-                                                     'nt10 ->
-                                                       'nt11 ->
-                                                         'nr
-                                                           FStar_Tactics_Monad.tac)
-                                    ->
-                                    'nt1 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt2
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt3
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt4
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt5
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt6
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt7
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt8
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt9
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt10
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt11
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nr
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun er ->
-                                fun nt ->
-                                  fun ne1 ->
-                                    fun ne2 ->
-                                      fun ne3 ->
-                                        fun ne4 ->
-                                          fun ne5 ->
-                                            fun ne6 ->
-                                              fun ne7 ->
-                                                fun ne8 ->
-                                                  fun ne9 ->
-                                                    fun ne10 ->
-                                                      fun ne11 ->
-                                                        fun ner ->
-                                                          mk name
-                                                            (Prims.of_int (12))
-                                                            nunivs
-                                                            (mk_tactic_interpretation_11
-                                                               t e1 e2 e3 e4
-                                                               e5 e6 e7 e8 e9
-                                                               e10 e11 er)
-                                                            (fun cb ->
-                                                               fun args ->
-                                                                 let uu___ =
-                                                                   drop
-                                                                    nunivs
-                                                                    args in
-                                                                 mk_tactic_nbe_interpretation_11
-                                                                   cb nt ne1
-                                                                   ne2 ne3
-                                                                   ne4 ne5
-                                                                   ne6 ne7
-                                                                   ne8 ne9
-                                                                   ne10 ne11
-                                                                   ner uu___)
-let mk_tac_step_12 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1
-    't10 't11 't12 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 -> 't11 -> 't12 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  'r FStar_Syntax_Embeddings.embedding ->
-                                    ('nt1 ->
-                                       'nt2 ->
-                                         'nt3 ->
-                                           'nt4 ->
-                                             'nt5 ->
-                                               'nt6 ->
-                                                 'nt7 ->
-                                                   'nt8 ->
-                                                     'nt9 ->
-                                                       'nt10 ->
-                                                         'nt11 ->
-                                                           'nt12 ->
-                                                             'nr
-                                                               FStar_Tactics_Monad.tac)
-                                      ->
-                                      'nt1
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt2
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt3
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt4
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt5
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt6
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt7
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt8
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt9
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt10
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt11
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt12
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nr
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun er ->
-                                  fun nt ->
-                                    fun ne1 ->
-                                      fun ne2 ->
-                                        fun ne3 ->
-                                          fun ne4 ->
-                                            fun ne5 ->
-                                              fun ne6 ->
-                                                fun ne7 ->
-                                                  fun ne8 ->
-                                                    fun ne9 ->
-                                                      fun ne10 ->
-                                                        fun ne11 ->
-                                                          fun ne12 ->
-                                                            fun ner ->
-                                                              mk name
-                                                                (Prims.of_int (13))
-                                                                nunivs
-                                                                (mk_tactic_interpretation_12
-                                                                   t e1 e2 e3
-                                                                   e4 e5 e6
-                                                                   e7 e8 e9
-                                                                   e10 e11
-                                                                   e12 er)
-                                                                (fun cb ->
-                                                                   fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_12
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ner
-                                                                    uu___)
-let mk_tac_step_13 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r
-    't1 't10 't11 't12 't13 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 -> 't13 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    'r FStar_Syntax_Embeddings.embedding ->
-                                      ('nt1 ->
-                                         'nt2 ->
-                                           'nt3 ->
-                                             'nt4 ->
-                                               'nt5 ->
-                                                 'nt6 ->
-                                                   'nt7 ->
-                                                     'nt8 ->
-                                                       'nt9 ->
-                                                         'nt10 ->
-                                                           'nt11 ->
-                                                             'nt12 ->
-                                                               'nt13 ->
-                                                                 'nr
-                                                                   FStar_Tactics_Monad.tac)
-                                        ->
-                                        'nt1
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt2
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt3
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt4
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt5
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt6
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt7
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt8
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt9
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt10
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt11
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt12
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt13
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun er ->
-                                    fun nt ->
-                                      fun ne1 ->
-                                        fun ne2 ->
-                                          fun ne3 ->
-                                            fun ne4 ->
-                                              fun ne5 ->
-                                                fun ne6 ->
-                                                  fun ne7 ->
-                                                    fun ne8 ->
-                                                      fun ne9 ->
-                                                        fun ne10 ->
-                                                          fun ne11 ->
-                                                            fun ne12 ->
-                                                              fun ne13 ->
-                                                                fun ner ->
-                                                                  mk name
-                                                                    (Prims.of_int (14))
-                                                                    nunivs
-                                                                    (
-                                                                    mk_tactic_interpretation_13
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 er)
-                                                                    (
-                                                                    fun cb ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_13
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ner uu___)
-let mk_tac_step_14 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8
-    'nt9 'r 't1 't10 't11 't12 't13 't14 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 -> 't14 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      'r FStar_Syntax_Embeddings.embedding ->
-                                        ('nt1 ->
-                                           'nt2 ->
-                                             'nt3 ->
-                                               'nt4 ->
-                                                 'nt5 ->
-                                                   'nt6 ->
-                                                     'nt7 ->
-                                                       'nt8 ->
-                                                         'nt9 ->
-                                                           'nt10 ->
-                                                             'nt11 ->
-                                                               'nt12 ->
-                                                                 'nt13 ->
-                                                                   'nt14 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                          ->
-                                          'nt1
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt2
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt3
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt4
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt5
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt6
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt7
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt8
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt9
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt10
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt11
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt12
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun er ->
-                                      fun nt ->
-                                        fun ne1 ->
-                                          fun ne2 ->
-                                            fun ne3 ->
-                                              fun ne4 ->
-                                                fun ne5 ->
-                                                  fun ne6 ->
-                                                    fun ne7 ->
-                                                      fun ne8 ->
-                                                        fun ne9 ->
-                                                          fun ne10 ->
-                                                            fun ne11 ->
-                                                              fun ne12 ->
-                                                                fun ne13 ->
-                                                                  fun ne14 ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (15))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_14
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_14
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ner
-                                                                    uu___)
-let mk_tac_step_15 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7
-    'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't2 't3 't4 't5 't6 't7
-    't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 -> 't15 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        'r FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          ('nt1 ->
-                                             'nt2 ->
-                                               'nt3 ->
-                                                 'nt4 ->
-                                                   'nt5 ->
-                                                     'nt6 ->
-                                                       'nt7 ->
-                                                         'nt8 ->
-                                                           'nt9 ->
-                                                             'nt10 ->
-                                                               'nt11 ->
-                                                                 'nt12 ->
-                                                                   'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                            ->
-                                            'nt1
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt2
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt3
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt4
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt5
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt6
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt7
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt8
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt9
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt10
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt11
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun er ->
-                                        fun nt ->
-                                          fun ne1 ->
-                                            fun ne2 ->
-                                              fun ne3 ->
-                                                fun ne4 ->
-                                                  fun ne5 ->
-                                                    fun ne6 ->
-                                                      fun ne7 ->
-                                                        fun ne8 ->
-                                                          fun ne9 ->
-                                                            fun ne10 ->
-                                                              fun ne11 ->
-                                                                fun ne12 ->
-                                                                  fun ne13 ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (16))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_15
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_15
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ner uu___)
-let mk_tac_step_16 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt2 'nt3 'nt4 'nt5 'nt6
-    'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't16 't2 't3 't4 't5
-    't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          'r
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            ('nt1 ->
-                                               'nt2 ->
-                                                 'nt3 ->
-                                                   'nt4 ->
-                                                     'nt5 ->
-                                                       'nt6 ->
-                                                         'nt7 ->
-                                                           'nt8 ->
-                                                             'nt9 ->
-                                                               'nt10 ->
-                                                                 'nt11 ->
-                                                                   'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                              ->
-                                              'nt1
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt2
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt3
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt4
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt5
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt6
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt7
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt8
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt9
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt10
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun er ->
-                                          fun nt ->
-                                            fun ne1 ->
-                                              fun ne2 ->
-                                                fun ne3 ->
-                                                  fun ne4 ->
-                                                    fun ne5 ->
-                                                      fun ne6 ->
-                                                        fun ne7 ->
-                                                          fun ne8 ->
-                                                            fun ne9 ->
-                                                              fun ne10 ->
-                                                                fun ne11 ->
-                                                                  fun ne12 ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (17))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_16
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_16
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ner
-                                                                    uu___)
-let mk_tac_step_17 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt2 'nt3 'nt4
-    'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't16 't17
-    't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 ->
-                                         't17 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            'r
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              ('nt1 ->
-                                                 'nt2 ->
-                                                   'nt3 ->
-                                                     'nt4 ->
-                                                       'nt5 ->
-                                                         'nt6 ->
-                                                           'nt7 ->
-                                                             'nt8 ->
-                                                               'nt9 ->
-                                                                 'nt10 ->
-                                                                   'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                                ->
-                                                'nt1
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt2
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt3
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt4
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt5
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt6
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt7
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt8
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt9
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun er ->
-                                            fun nt ->
-                                              fun ne1 ->
-                                                fun ne2 ->
-                                                  fun ne3 ->
-                                                    fun ne4 ->
-                                                      fun ne5 ->
-                                                        fun ne6 ->
-                                                          fun ne7 ->
-                                                            fun ne8 ->
-                                                              fun ne9 ->
-                                                                fun ne10 ->
-                                                                  fun ne11 ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (18))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_17
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_17
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ner uu___)
-let mk_tac_step_18 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt18 'nt2 'nt3
-    'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't16
-    't17 't18 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 ->
-                                         't17 ->
-                                           't18 -> 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't18
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              'r
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                ('nt1 ->
-                                                   'nt2 ->
-                                                     'nt3 ->
-                                                       'nt4 ->
-                                                         'nt5 ->
-                                                           'nt6 ->
-                                                             'nt7 ->
-                                                               'nt8 ->
-                                                                 'nt9 ->
-                                                                   'nt10 ->
-                                                                    'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nt18 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                                  ->
-                                                  'nt1
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt2
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt3
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt4
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt5
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt6
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt7
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt8
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt9
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt18
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun e18 ->
-                                            fun er ->
-                                              fun nt ->
-                                                fun ne1 ->
-                                                  fun ne2 ->
-                                                    fun ne3 ->
-                                                      fun ne4 ->
-                                                        fun ne5 ->
-                                                          fun ne6 ->
-                                                            fun ne7 ->
-                                                              fun ne8 ->
-                                                                fun ne9 ->
-                                                                  fun ne10 ->
-                                                                    fun ne11
-                                                                    ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ne18
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (19))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_18
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 e18
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_18
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ne18 ner
-                                                                    uu___)
-let mk_tac_step_19 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt18 'nt19 'nt2
-    'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15
-    't16 't17 't18 't19 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 ->
-                                         't17 ->
-                                           't18 ->
-                                             't19 ->
-                                               'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't18
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              't19
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                'r
-                                                  FStar_Syntax_Embeddings.embedding
-                                                  ->
-                                                  ('nt1 ->
-                                                     'nt2 ->
-                                                       'nt3 ->
-                                                         'nt4 ->
-                                                           'nt5 ->
-                                                             'nt6 ->
-                                                               'nt7 ->
-                                                                 'nt8 ->
-                                                                   'nt9 ->
-                                                                    'nt10 ->
-                                                                    'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nt18 ->
-                                                                    'nt19 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                                    ->
-                                                    'nt1
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt2
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt3
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt4
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt5
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt6
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt7
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt8
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt9
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt18
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt19
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun e18 ->
-                                            fun e19 ->
-                                              fun er ->
-                                                fun nt ->
-                                                  fun ne1 ->
-                                                    fun ne2 ->
-                                                      fun ne3 ->
-                                                        fun ne4 ->
-                                                          fun ne5 ->
-                                                            fun ne6 ->
-                                                              fun ne7 ->
-                                                                fun ne8 ->
-                                                                  fun ne9 ->
-                                                                    fun ne10
-                                                                    ->
-                                                                    fun ne11
-                                                                    ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ne18
-                                                                    ->
-                                                                    fun ne19
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (20))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_19
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 e18
-                                                                    e19 er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_19
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ne18 ne19
-                                                                    ner uu___)
-let mk_tac_step_20 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt18 'nt19 'nt2
-    'nt20 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14
-    't15 't16 't17 't18 't19 't2 't20 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 ->
-                                         't17 ->
-                                           't18 ->
-                                             't19 ->
-                                               't20 ->
-                                                 'r FStar_Tactics_Monad.tac)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't18
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              't19
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                't20
-                                                  FStar_Syntax_Embeddings.embedding
-                                                  ->
-                                                  'r
-                                                    FStar_Syntax_Embeddings.embedding
-                                                    ->
-                                                    ('nt1 ->
-                                                       'nt2 ->
-                                                         'nt3 ->
-                                                           'nt4 ->
-                                                             'nt5 ->
-                                                               'nt6 ->
-                                                                 'nt7 ->
-                                                                   'nt8 ->
-                                                                    'nt9 ->
-                                                                    'nt10 ->
-                                                                    'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nt18 ->
-                                                                    'nt19 ->
-                                                                    'nt20 ->
-                                                                    'nr
-                                                                    FStar_Tactics_Monad.tac)
-                                                      ->
-                                                      'nt1
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt2
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt3
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt4
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt5
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt6
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt7
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt8
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt9
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt18
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt19
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt20
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun t ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun e18 ->
-                                            fun e19 ->
-                                              fun e20 ->
-                                                fun er ->
-                                                  fun nt ->
-                                                    fun ne1 ->
-                                                      fun ne2 ->
-                                                        fun ne3 ->
-                                                          fun ne4 ->
-                                                            fun ne5 ->
-                                                              fun ne6 ->
-                                                                fun ne7 ->
-                                                                  fun ne8 ->
-                                                                    fun ne9
-                                                                    ->
-                                                                    fun ne10
-                                                                    ->
-                                                                    fun ne11
-                                                                    ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ne18
-                                                                    ->
-                                                                    fun ne19
-                                                                    ->
-                                                                    fun ne20
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (21))
-                                                                    nunivs
-                                                                    (mk_tactic_interpretation_20
-                                                                    t e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 e18
-                                                                    e19 e20
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_tactic_nbe_interpretation_20
-                                                                    cb nt ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ne18 ne19
-                                                                    ne20 ner
-                                                                    uu___)
-let mk_total_step_1 :
-  'nr 'nt1 'r 't1 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            'r FStar_Syntax_Embeddings.embedding ->
-              ('nt1 -> 'nr) ->
-                'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                  'nr FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun er ->
-            fun nf ->
-              fun ne1 ->
-                fun ner ->
-                  mk name Prims.int_one nunivs
-                    (mk_total_interpretation_1 f e1 er)
-                    (fun cb ->
-                       fun args ->
-                         let uu___ = drop nunivs args in
-                         mk_total_nbe_interpretation_1 cb nf ne1 ner uu___)
-let mk_total_step_2 :
-  'nr 'nt1 'nt2 'r 't1 't2 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              'r FStar_Syntax_Embeddings.embedding ->
-                ('nt1 -> 'nt2 -> 'nr) ->
-                  'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                    'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                      'nr FStar_TypeChecker_NBETerm.embedding ->
-                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun er ->
-              fun nf ->
-                fun ne1 ->
-                  fun ne2 ->
-                    fun ner ->
-                      mk name (Prims.of_int (2)) nunivs
-                        (mk_total_interpretation_2 f e1 e2 er)
-                        (fun cb ->
-                           fun args ->
-                             let uu___ = drop nunivs args in
-                             mk_total_nbe_interpretation_2 cb nf ne1 ne2 ner
-                               uu___)
-let mk_total_step_3 :
-  'nr 'nt1 'nt2 'nt3 'r 't1 't2 't3 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                'r FStar_Syntax_Embeddings.embedding ->
-                  ('nt1 -> 'nt2 -> 'nt3 -> 'nr) ->
-                    'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                      'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                        'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                          'nr FStar_TypeChecker_NBETerm.embedding ->
-                            FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun er ->
-                fun nf ->
-                  fun ne1 ->
-                    fun ne2 ->
-                      fun ne3 ->
-                        fun ner ->
-                          mk name (Prims.of_int (3)) nunivs
-                            (mk_total_interpretation_3 f e1 e2 e3 er)
-                            (fun cb ->
-                               fun args ->
-                                 let uu___ = drop nunivs args in
-                                 mk_total_nbe_interpretation_3 cb nf ne1 ne2
-                                   ne3 ner uu___)
-let mk_total_step_4 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'r 't1 't2 't3 't4 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  'r FStar_Syntax_Embeddings.embedding ->
-                    ('nt1 -> 'nt2 -> 'nt3 -> 'nt4 -> 'nr) ->
-                      'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                        'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                          'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                            'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                              'nr FStar_TypeChecker_NBETerm.embedding ->
-                                FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun er ->
-                  fun nf ->
-                    fun ne1 ->
-                      fun ne2 ->
-                        fun ne3 ->
-                          fun ne4 ->
-                            fun ner ->
-                              mk name (Prims.of_int (4)) nunivs
-                                (mk_total_interpretation_4 f e1 e2 e3 e4 er)
-                                (fun cb ->
-                                   fun args ->
-                                     let uu___ = drop nunivs args in
-                                     mk_total_nbe_interpretation_4 cb nf ne1
-                                       ne2 ne3 ne4 ner uu___)
-let mk_total_step_5 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'r 't1 't2 't3 't4 't5 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    'r FStar_Syntax_Embeddings.embedding ->
-                      ('nt1 -> 'nt2 -> 'nt3 -> 'nt4 -> 'nt5 -> 'nr) ->
-                        'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                          'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                            'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                              'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt5 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nr FStar_TypeChecker_NBETerm.embedding ->
-                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun er ->
-                    fun nf ->
-                      fun ne1 ->
-                        fun ne2 ->
-                          fun ne3 ->
-                            fun ne4 ->
-                              fun ne5 ->
-                                fun ner ->
-                                  mk name (Prims.of_int (5)) nunivs
-                                    (mk_total_interpretation_5 f e1 e2 e3 e4
-                                       e5 er)
-                                    (fun cb ->
-                                       fun args ->
-                                         let uu___ = drop nunivs args in
-                                         mk_total_nbe_interpretation_5 cb nf
-                                           ne1 ne2 ne3 ne4 ne5 ner uu___)
-let mk_total_step_6 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'r 't1 't2 't3 't4 't5 't6 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      'r FStar_Syntax_Embeddings.embedding ->
-                        ('nt1 -> 'nt2 -> 'nt3 -> 'nt4 -> 'nt5 -> 'nt6 -> 'nr)
-                          ->
-                          'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                            'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                              'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt5 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt6 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nr FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun er ->
-                      fun nf ->
-                        fun ne1 ->
-                          fun ne2 ->
-                            fun ne3 ->
-                              fun ne4 ->
-                                fun ne5 ->
-                                  fun ne6 ->
-                                    fun ner ->
-                                      mk name (Prims.of_int (6)) nunivs
-                                        (mk_total_interpretation_6 f e1 e2 e3
-                                           e4 e5 e6 er)
-                                        (fun cb ->
-                                           fun args ->
-                                             let uu___ = drop nunivs args in
-                                             mk_total_nbe_interpretation_6 cb
-                                               nf ne1 ne2 ne3 ne4 ne5 ne6 ner
-                                               uu___)
-let mk_total_step_7 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'r 't1 't2 't3 't4 't5 't6 't7 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        'r FStar_Syntax_Embeddings.embedding ->
-                          ('nt1 ->
-                             'nt2 ->
-                               'nt3 -> 'nt4 -> 'nt5 -> 'nt6 -> 'nt7 -> 'nr)
-                            ->
-                            'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                              'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt4 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt5 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt6
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt7
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nr
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun er ->
-                        fun nf ->
-                          fun ne1 ->
-                            fun ne2 ->
-                              fun ne3 ->
-                                fun ne4 ->
-                                  fun ne5 ->
-                                    fun ne6 ->
-                                      fun ne7 ->
-                                        fun ner ->
-                                          mk name (Prims.of_int (7)) nunivs
-                                            (mk_total_interpretation_7 f e1
-                                               e2 e3 e4 e5 e6 e7 er)
-                                            (fun cb ->
-                                               fun args ->
-                                                 let uu___ = drop nunivs args in
-                                                 mk_total_nbe_interpretation_7
-                                                   cb nf ne1 ne2 ne3 ne4 ne5
-                                                   ne6 ne7 ner uu___)
-let mk_total_step_8 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'r 't1 't2 't3 't4 't5 't6 't7
-    't8 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 'r) ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          'r FStar_Syntax_Embeddings.embedding ->
-                            ('nt1 ->
-                               'nt2 ->
-                                 'nt3 ->
-                                   'nt4 ->
-                                     'nt5 -> 'nt6 -> 'nt7 -> 'nt8 -> 'nr)
-                              ->
-                              'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                                'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt3 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt4 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt5
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt6
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt7
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt8
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nr
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun er ->
-                          fun nf ->
-                            fun ne1 ->
-                              fun ne2 ->
-                                fun ne3 ->
-                                  fun ne4 ->
-                                    fun ne5 ->
-                                      fun ne6 ->
-                                        fun ne7 ->
-                                          fun ne8 ->
-                                            fun ner ->
-                                              mk name (Prims.of_int (8))
-                                                nunivs
-                                                (mk_total_interpretation_8 f
-                                                   e1 e2 e3 e4 e5 e6 e7 e8 er)
-                                                (fun cb ->
-                                                   fun args ->
-                                                     let uu___ =
-                                                       drop nunivs args in
-                                                     mk_total_nbe_interpretation_8
-                                                       cb nf ne1 ne2 ne3 ne4
-                                                       ne5 ne6 ne7 ne8 ner
-                                                       uu___)
-let mk_total_step_9 :
-  'nr 'nt1 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't2 't3 't4 't5 't6
-    't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 -> 't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            'r FStar_Syntax_Embeddings.embedding ->
-                              ('nt1 ->
-                                 'nt2 ->
-                                   'nt3 ->
-                                     'nt4 ->
-                                       'nt5 ->
-                                         'nt6 -> 'nt7 -> 'nt8 -> 'nt9 -> 'nr)
-                                ->
-                                'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                                  'nt2 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt3 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt4
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt5
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt6
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt7
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt8
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt9
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nr
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun er ->
-                            fun nf ->
-                              fun ne1 ->
-                                fun ne2 ->
-                                  fun ne3 ->
-                                    fun ne4 ->
-                                      fun ne5 ->
-                                        fun ne6 ->
-                                          fun ne7 ->
-                                            fun ne8 ->
-                                              fun ne9 ->
-                                                fun ner ->
-                                                  mk name (Prims.of_int (9))
-                                                    nunivs
-                                                    (mk_total_interpretation_9
-                                                       f e1 e2 e3 e4 e5 e6 e7
-                                                       e8 e9 er)
-                                                    (fun cb ->
-                                                       fun args ->
-                                                         let uu___ =
-                                                           drop nunivs args in
-                                                         mk_total_nbe_interpretation_9
-                                                           cb nf ne1 ne2 ne3
-                                                           ne4 ne5 ne6 ne7
-                                                           ne8 ne9 ner uu___)
-let mk_total_step_10 :
-  'nr 'nt1 'nt10 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't2 't3
-    't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 -> 't3 -> 't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              'r FStar_Syntax_Embeddings.embedding ->
-                                ('nt1 ->
-                                   'nt2 ->
-                                     'nt3 ->
-                                       'nt4 ->
-                                         'nt5 ->
-                                           'nt6 ->
-                                             'nt7 ->
-                                               'nt8 -> 'nt9 -> 'nt10 -> 'nr)
-                                  ->
-                                  'nt1 FStar_TypeChecker_NBETerm.embedding ->
-                                    'nt2 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt3
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt4
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt5
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt6
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt7
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt8
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt9
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt10
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nr
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun er ->
-                              fun nf ->
-                                fun ne1 ->
-                                  fun ne2 ->
-                                    fun ne3 ->
-                                      fun ne4 ->
-                                        fun ne5 ->
-                                          fun ne6 ->
-                                            fun ne7 ->
-                                              fun ne8 ->
-                                                fun ne9 ->
-                                                  fun ne10 ->
-                                                    fun ner ->
-                                                      mk name
-                                                        (Prims.of_int (10))
-                                                        nunivs
-                                                        (mk_total_interpretation_10
-                                                           f e1 e2 e3 e4 e5
-                                                           e6 e7 e8 e9 e10 er)
-                                                        (fun cb ->
-                                                           fun args ->
-                                                             let uu___ =
-                                                               drop nunivs
-                                                                 args in
-                                                             mk_total_nbe_interpretation_10
-                                                               cb nf ne1 ne2
-                                                               ne3 ne4 ne5
-                                                               ne6 ne7 ne8
-                                                               ne9 ne10 ner
-                                                               uu___)
-let mk_total_step_11 :
-  'nr 'nt1 'nt10 'nt11 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10
-    't11 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 -> 't5 -> 't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                'r FStar_Syntax_Embeddings.embedding ->
-                                  ('nt1 ->
-                                     'nt2 ->
-                                       'nt3 ->
-                                         'nt4 ->
-                                           'nt5 ->
-                                             'nt6 ->
-                                               'nt7 ->
-                                                 'nt8 ->
-                                                   'nt9 ->
-                                                     'nt10 -> 'nt11 -> 'nr)
-                                    ->
-                                    'nt1 FStar_TypeChecker_NBETerm.embedding
-                                      ->
-                                      'nt2
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt3
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt4
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt5
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt6
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt7
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt8
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt9
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt10
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt11
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nr
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun er ->
-                                fun nf ->
-                                  fun ne1 ->
-                                    fun ne2 ->
-                                      fun ne3 ->
-                                        fun ne4 ->
-                                          fun ne5 ->
-                                            fun ne6 ->
-                                              fun ne7 ->
-                                                fun ne8 ->
-                                                  fun ne9 ->
-                                                    fun ne10 ->
-                                                      fun ne11 ->
-                                                        fun ner ->
-                                                          mk name
-                                                            (Prims.of_int (11))
-                                                            nunivs
-                                                            (mk_total_interpretation_11
-                                                               f e1 e2 e3 e4
-                                                               e5 e6 e7 e8 e9
-                                                               e10 e11 er)
-                                                            (fun cb ->
-                                                               fun args ->
-                                                                 let uu___ =
-                                                                   drop
-                                                                    nunivs
-                                                                    args in
-                                                                 mk_total_nbe_interpretation_11
-                                                                   cb nf ne1
-                                                                   ne2 ne3
-                                                                   ne4 ne5
-                                                                   ne6 ne7
-                                                                   ne8 ne9
-                                                                   ne10 ne11
-                                                                   ner uu___)
-let mk_total_step_12 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1
-    't10 't11 't12 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 -> 't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  'r FStar_Syntax_Embeddings.embedding ->
-                                    ('nt1 ->
-                                       'nt2 ->
-                                         'nt3 ->
-                                           'nt4 ->
-                                             'nt5 ->
-                                               'nt6 ->
-                                                 'nt7 ->
-                                                   'nt8 ->
-                                                     'nt9 ->
-                                                       'nt10 ->
-                                                         'nt11 ->
-                                                           'nt12 -> 'nr)
-                                      ->
-                                      'nt1
-                                        FStar_TypeChecker_NBETerm.embedding
-                                        ->
-                                        'nt2
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt3
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt4
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt5
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt6
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt7
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt8
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt9
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt10
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt11
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt12
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nr
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun er ->
-                                  fun nf ->
-                                    fun ne1 ->
-                                      fun ne2 ->
-                                        fun ne3 ->
-                                          fun ne4 ->
-                                            fun ne5 ->
-                                              fun ne6 ->
-                                                fun ne7 ->
-                                                  fun ne8 ->
-                                                    fun ne9 ->
-                                                      fun ne10 ->
-                                                        fun ne11 ->
-                                                          fun ne12 ->
-                                                            fun ner ->
-                                                              mk name
-                                                                (Prims.of_int (12))
-                                                                nunivs
-                                                                (mk_total_interpretation_12
-                                                                   f e1 e2 e3
-                                                                   e4 e5 e6
-                                                                   e7 e8 e9
-                                                                   e10 e11
-                                                                   e12 er)
-                                                                (fun cb ->
-                                                                   fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_12
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ner
-                                                                    uu___)
-let mk_total_step_13 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r
-    't1 't10 't11 't12 't13 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 -> 't8 -> 't9 -> 't10 -> 't11 -> 't12 -> 't13 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    'r FStar_Syntax_Embeddings.embedding ->
-                                      ('nt1 ->
-                                         'nt2 ->
-                                           'nt3 ->
-                                             'nt4 ->
-                                               'nt5 ->
-                                                 'nt6 ->
-                                                   'nt7 ->
-                                                     'nt8 ->
-                                                       'nt9 ->
-                                                         'nt10 ->
-                                                           'nt11 ->
-                                                             'nt12 ->
-                                                               'nt13 -> 'nr)
-                                        ->
-                                        'nt1
-                                          FStar_TypeChecker_NBETerm.embedding
-                                          ->
-                                          'nt2
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt3
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt4
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt5
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt6
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt7
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt8
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt9
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt10
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt11
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt12
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt13
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun er ->
-                                    fun nf ->
-                                      fun ne1 ->
-                                        fun ne2 ->
-                                          fun ne3 ->
-                                            fun ne4 ->
-                                              fun ne5 ->
-                                                fun ne6 ->
-                                                  fun ne7 ->
-                                                    fun ne8 ->
-                                                      fun ne9 ->
-                                                        fun ne10 ->
-                                                          fun ne11 ->
-                                                            fun ne12 ->
-                                                              fun ne13 ->
-                                                                fun ner ->
-                                                                  mk name
-                                                                    (Prims.of_int (13))
-                                                                    nunivs
-                                                                    (
-                                                                    mk_total_interpretation_13
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 er)
-                                                                    (
-                                                                    fun cb ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_13
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ner uu___)
-let mk_total_step_14 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8
-    'nt9 'r 't1 't10 't11 't12 't13 't14 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 -> 't10 -> 't11 -> 't12 -> 't13 -> 't14 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      'r FStar_Syntax_Embeddings.embedding ->
-                                        ('nt1 ->
-                                           'nt2 ->
-                                             'nt3 ->
-                                               'nt4 ->
-                                                 'nt5 ->
-                                                   'nt6 ->
-                                                     'nt7 ->
-                                                       'nt8 ->
-                                                         'nt9 ->
-                                                           'nt10 ->
-                                                             'nt11 ->
-                                                               'nt12 ->
-                                                                 'nt13 ->
-                                                                   'nt14 ->
-                                                                    'nr)
-                                          ->
-                                          'nt1
-                                            FStar_TypeChecker_NBETerm.embedding
-                                            ->
-                                            'nt2
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt3
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt4
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt5
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt6
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt7
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt8
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt9
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt10
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt11
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt12
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun er ->
-                                      fun nf ->
-                                        fun ne1 ->
-                                          fun ne2 ->
-                                            fun ne3 ->
-                                              fun ne4 ->
-                                                fun ne5 ->
-                                                  fun ne6 ->
-                                                    fun ne7 ->
-                                                      fun ne8 ->
-                                                        fun ne9 ->
-                                                          fun ne10 ->
-                                                            fun ne11 ->
-                                                              fun ne12 ->
-                                                                fun ne13 ->
-                                                                  fun ne14 ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (14))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_14
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_14
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ner
-                                                                    uu___)
-let mk_total_step_15 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt2 'nt3 'nt4 'nt5 'nt6 'nt7
-    'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't2 't3 't4 't5 't6 't7
-    't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 -> 't11 -> 't12 -> 't13 -> 't14 -> 't15 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        'r FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          ('nt1 ->
-                                             'nt2 ->
-                                               'nt3 ->
-                                                 'nt4 ->
-                                                   'nt5 ->
-                                                     'nt6 ->
-                                                       'nt7 ->
-                                                         'nt8 ->
-                                                           'nt9 ->
-                                                             'nt10 ->
-                                                               'nt11 ->
-                                                                 'nt12 ->
-                                                                   'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nr)
-                                            ->
-                                            'nt1
-                                              FStar_TypeChecker_NBETerm.embedding
-                                              ->
-                                              'nt2
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt3
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt4
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt5
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt6
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt7
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt8
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt9
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt10
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt11
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun er ->
-                                        fun nf ->
-                                          fun ne1 ->
-                                            fun ne2 ->
-                                              fun ne3 ->
-                                                fun ne4 ->
-                                                  fun ne5 ->
-                                                    fun ne6 ->
-                                                      fun ne7 ->
-                                                        fun ne8 ->
-                                                          fun ne9 ->
-                                                            fun ne10 ->
-                                                              fun ne11 ->
-                                                                fun ne12 ->
-                                                                  fun ne13 ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (15))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_15
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_15
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ner uu___)
-let mk_total_step_16 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt2 'nt3 'nt4 'nt5 'nt6
-    'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't16 't2 't3 't4 't5
-    't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 -> 't13 -> 't14 -> 't15 -> 't16 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          'r
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            ('nt1 ->
-                                               'nt2 ->
-                                                 'nt3 ->
-                                                   'nt4 ->
-                                                     'nt5 ->
-                                                       'nt6 ->
-                                                         'nt7 ->
-                                                           'nt8 ->
-                                                             'nt9 ->
-                                                               'nt10 ->
-                                                                 'nt11 ->
-                                                                   'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nr)
-                                              ->
-                                              'nt1
-                                                FStar_TypeChecker_NBETerm.embedding
-                                                ->
-                                                'nt2
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt3
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt4
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt5
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt6
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt7
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt8
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt9
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt10
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun er ->
-                                          fun nf ->
-                                            fun ne1 ->
-                                              fun ne2 ->
-                                                fun ne3 ->
-                                                  fun ne4 ->
-                                                    fun ne5 ->
-                                                      fun ne6 ->
-                                                        fun ne7 ->
-                                                          fun ne8 ->
-                                                            fun ne9 ->
-                                                              fun ne10 ->
-                                                                fun ne11 ->
-                                                                  fun ne12 ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (16))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_16
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_16
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ner
-                                                                    uu___)
-let mk_total_step_17 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt2 'nt3 'nt4
-    'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't16 't17
-    't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 -> 't14 -> 't15 -> 't16 -> 't17 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            'r
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              ('nt1 ->
-                                                 'nt2 ->
-                                                   'nt3 ->
-                                                     'nt4 ->
-                                                       'nt5 ->
-                                                         'nt6 ->
-                                                           'nt7 ->
-                                                             'nt8 ->
-                                                               'nt9 ->
-                                                                 'nt10 ->
-                                                                   'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nr)
-                                                ->
-                                                'nt1
-                                                  FStar_TypeChecker_NBETerm.embedding
-                                                  ->
-                                                  'nt2
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt3
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt4
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt5
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt6
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt7
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt8
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt9
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun er ->
-                                            fun nf ->
-                                              fun ne1 ->
-                                                fun ne2 ->
-                                                  fun ne3 ->
-                                                    fun ne4 ->
-                                                      fun ne5 ->
-                                                        fun ne6 ->
-                                                          fun ne7 ->
-                                                            fun ne8 ->
-                                                              fun ne9 ->
-                                                                fun ne10 ->
-                                                                  fun ne11 ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (17))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_17
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_17
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ner uu___)
-let mk_total_step_18 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt18 'nt2 'nt3
-    'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15 't16
-    't17 't18 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 -> 't15 -> 't16 -> 't17 -> 't18 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't18
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              'r
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                ('nt1 ->
-                                                   'nt2 ->
-                                                     'nt3 ->
-                                                       'nt4 ->
-                                                         'nt5 ->
-                                                           'nt6 ->
-                                                             'nt7 ->
-                                                               'nt8 ->
-                                                                 'nt9 ->
-                                                                   'nt10 ->
-                                                                    'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nt18 ->
-                                                                    'nr)
-                                                  ->
-                                                  'nt1
-                                                    FStar_TypeChecker_NBETerm.embedding
-                                                    ->
-                                                    'nt2
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt3
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt4
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt5
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt6
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt7
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt8
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt9
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt18
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun e18 ->
-                                            fun er ->
-                                              fun nf ->
-                                                fun ne1 ->
-                                                  fun ne2 ->
-                                                    fun ne3 ->
-                                                      fun ne4 ->
-                                                        fun ne5 ->
-                                                          fun ne6 ->
-                                                            fun ne7 ->
-                                                              fun ne8 ->
-                                                                fun ne9 ->
-                                                                  fun ne10 ->
-                                                                    fun ne11
-                                                                    ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ne18
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (18))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_18
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 e18
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_18
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ne18 ner
-                                                                    uu___)
-let mk_total_step_19 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt18 'nt19 'nt2
-    'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14 't15
-    't16 't17 't18 't19 't2 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 -> 't17 -> 't18 -> 't19 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't18
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              't19
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                'r
-                                                  FStar_Syntax_Embeddings.embedding
-                                                  ->
-                                                  ('nt1 ->
-                                                     'nt2 ->
-                                                       'nt3 ->
-                                                         'nt4 ->
-                                                           'nt5 ->
-                                                             'nt6 ->
-                                                               'nt7 ->
-                                                                 'nt8 ->
-                                                                   'nt9 ->
-                                                                    'nt10 ->
-                                                                    'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nt18 ->
-                                                                    'nt19 ->
-                                                                    'nr)
-                                                    ->
-                                                    'nt1
-                                                      FStar_TypeChecker_NBETerm.embedding
-                                                      ->
-                                                      'nt2
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt3
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt4
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt5
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt6
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt7
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt8
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt9
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt18
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt19
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun e18 ->
-                                            fun e19 ->
-                                              fun er ->
-                                                fun nf ->
-                                                  fun ne1 ->
-                                                    fun ne2 ->
-                                                      fun ne3 ->
-                                                        fun ne4 ->
-                                                          fun ne5 ->
-                                                            fun ne6 ->
-                                                              fun ne7 ->
-                                                                fun ne8 ->
-                                                                  fun ne9 ->
-                                                                    fun ne10
-                                                                    ->
-                                                                    fun ne11
-                                                                    ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ne18
-                                                                    ->
-                                                                    fun ne19
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (19))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_19
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 e18
-                                                                    e19 er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_19
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ne18 ne19
-                                                                    ner uu___)
-let mk_total_step_20 :
-  'nr 'nt1 'nt10 'nt11 'nt12 'nt13 'nt14 'nt15 'nt16 'nt17 'nt18 'nt19 'nt2
-    'nt20 'nt3 'nt4 'nt5 'nt6 'nt7 'nt8 'nt9 'r 't1 't10 't11 't12 't13 't14
-    't15 't16 't17 't18 't19 't2 't20 't3 't4 't5 't6 't7 't8 't9 .
-    Prims.int ->
-      Prims.string ->
-        ('t1 ->
-           't2 ->
-             't3 ->
-               't4 ->
-                 't5 ->
-                   't6 ->
-                     't7 ->
-                       't8 ->
-                         't9 ->
-                           't10 ->
-                             't11 ->
-                               't12 ->
-                                 't13 ->
-                                   't14 ->
-                                     't15 ->
-                                       't16 ->
-                                         't17 -> 't18 -> 't19 -> 't20 -> 'r)
-          ->
-          't1 FStar_Syntax_Embeddings.embedding ->
-            't2 FStar_Syntax_Embeddings.embedding ->
-              't3 FStar_Syntax_Embeddings.embedding ->
-                't4 FStar_Syntax_Embeddings.embedding ->
-                  't5 FStar_Syntax_Embeddings.embedding ->
-                    't6 FStar_Syntax_Embeddings.embedding ->
-                      't7 FStar_Syntax_Embeddings.embedding ->
-                        't8 FStar_Syntax_Embeddings.embedding ->
-                          't9 FStar_Syntax_Embeddings.embedding ->
-                            't10 FStar_Syntax_Embeddings.embedding ->
-                              't11 FStar_Syntax_Embeddings.embedding ->
-                                't12 FStar_Syntax_Embeddings.embedding ->
-                                  't13 FStar_Syntax_Embeddings.embedding ->
-                                    't14 FStar_Syntax_Embeddings.embedding ->
-                                      't15 FStar_Syntax_Embeddings.embedding
-                                        ->
-                                        't16
-                                          FStar_Syntax_Embeddings.embedding
-                                          ->
-                                          't17
-                                            FStar_Syntax_Embeddings.embedding
-                                            ->
-                                            't18
-                                              FStar_Syntax_Embeddings.embedding
-                                              ->
-                                              't19
-                                                FStar_Syntax_Embeddings.embedding
-                                                ->
-                                                't20
-                                                  FStar_Syntax_Embeddings.embedding
-                                                  ->
-                                                  'r
-                                                    FStar_Syntax_Embeddings.embedding
-                                                    ->
-                                                    ('nt1 ->
-                                                       'nt2 ->
-                                                         'nt3 ->
-                                                           'nt4 ->
-                                                             'nt5 ->
-                                                               'nt6 ->
-                                                                 'nt7 ->
-                                                                   'nt8 ->
-                                                                    'nt9 ->
-                                                                    'nt10 ->
-                                                                    'nt11 ->
-                                                                    'nt12 ->
-                                                                    'nt13 ->
-                                                                    'nt14 ->
-                                                                    'nt15 ->
-                                                                    'nt16 ->
-                                                                    'nt17 ->
-                                                                    'nt18 ->
-                                                                    'nt19 ->
-                                                                    'nt20 ->
-                                                                    'nr)
-                                                      ->
-                                                      'nt1
-                                                        FStar_TypeChecker_NBETerm.embedding
-                                                        ->
-                                                        'nt2
-                                                          FStar_TypeChecker_NBETerm.embedding
-                                                          ->
-                                                          'nt3
-                                                            FStar_TypeChecker_NBETerm.embedding
-                                                            ->
-                                                            'nt4
-                                                              FStar_TypeChecker_NBETerm.embedding
-                                                              ->
-                                                              'nt5
-                                                                FStar_TypeChecker_NBETerm.embedding
-                                                                ->
-                                                                'nt6
-                                                                  FStar_TypeChecker_NBETerm.embedding
-                                                                  ->
-                                                                  'nt7
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt8
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt9
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt10
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt11
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt12
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt13
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt14
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt15
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt16
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt17
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt18
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt19
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nt20
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    'nr
-                                                                    FStar_TypeChecker_NBETerm.embedding
-                                                                    ->
-                                                                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun nunivs ->
-    fun name ->
-      fun f ->
-        fun e1 ->
-          fun e2 ->
-            fun e3 ->
-              fun e4 ->
-                fun e5 ->
-                  fun e6 ->
-                    fun e7 ->
-                      fun e8 ->
-                        fun e9 ->
-                          fun e10 ->
-                            fun e11 ->
-                              fun e12 ->
-                                fun e13 ->
-                                  fun e14 ->
-                                    fun e15 ->
-                                      fun e16 ->
-                                        fun e17 ->
-                                          fun e18 ->
-                                            fun e19 ->
-                                              fun e20 ->
-                                                fun er ->
-                                                  fun nf ->
-                                                    fun ne1 ->
-                                                      fun ne2 ->
-                                                        fun ne3 ->
-                                                          fun ne4 ->
-                                                            fun ne5 ->
-                                                              fun ne6 ->
-                                                                fun ne7 ->
-                                                                  fun ne8 ->
-                                                                    fun ne9
-                                                                    ->
-                                                                    fun ne10
-                                                                    ->
-                                                                    fun ne11
-                                                                    ->
-                                                                    fun ne12
-                                                                    ->
-                                                                    fun ne13
-                                                                    ->
-                                                                    fun ne14
-                                                                    ->
-                                                                    fun ne15
-                                                                    ->
-                                                                    fun ne16
-                                                                    ->
-                                                                    fun ne17
-                                                                    ->
-                                                                    fun ne18
-                                                                    ->
-                                                                    fun ne19
-                                                                    ->
-                                                                    fun ne20
-                                                                    ->
-                                                                    fun ner
-                                                                    ->
-                                                                    mk name
-                                                                    (Prims.of_int (20))
-                                                                    nunivs
-                                                                    (mk_total_interpretation_20
-                                                                    f e1 e2
-                                                                    e3 e4 e5
-                                                                    e6 e7 e8
-                                                                    e9 e10
-                                                                    e11 e12
-                                                                    e13 e14
-                                                                    e15 e16
-                                                                    e17 e18
-                                                                    e19 e20
-                                                                    er)
-                                                                    (fun cb
-                                                                    ->
-                                                                    fun args
-                                                                    ->
-                                                                    let uu___
-                                                                    =
-                                                                    drop
-                                                                    nunivs
-                                                                    args in
-                                                                    mk_total_nbe_interpretation_20
-                                                                    cb nf ne1
-                                                                    ne2 ne3
-                                                                    ne4 ne5
-                                                                    ne6 ne7
-                                                                    ne8 ne9
-                                                                    ne10 ne11
-                                                                    ne12 ne13
-                                                                    ne14 ne15
-                                                                    ne16 ne17
-                                                                    ne18 ne19
-                                                                    ne20 ner
-                                                                    uu___)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Interpreter.ml b/src/ocaml-output/FStar_Tactics_Interpreter.ml
deleted file mode 100644
index ed9e410918f..00000000000
--- a/src/ocaml-output/FStar_Tactics_Interpreter.ml
+++ /dev/null
@@ -1,2140 +0,0 @@
-open Prims
-let (tacdbg : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref false
-let unembed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Embeddings.norm_cb ->
-          'uuuuu FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun a ->
-      fun norm_cb ->
-        let uu___ = FStar_Syntax_Embeddings.unembed ea a in
-        uu___ true norm_cb
-let embed :
-  'uuuuu .
-    'uuuuu FStar_Syntax_Embeddings.embedding ->
-      FStar_Compiler_Range.range ->
-        'uuuuu -> FStar_Syntax_Embeddings.norm_cb -> FStar_Syntax_Syntax.term
-  =
-  fun ea ->
-    fun r ->
-      fun x ->
-        fun norm_cb ->
-          let uu___ = FStar_Syntax_Embeddings.embed ea x in
-          uu___ r FStar_Pervasives_Native.None norm_cb
-let (native_tactics_steps :
-  unit -> FStar_TypeChecker_Cfg.primitive_step Prims.list) =
-  fun uu___ ->
-    let step_from_native_step s =
-      {
-        FStar_TypeChecker_Cfg.name = (s.FStar_Tactics_Native.name);
-        FStar_TypeChecker_Cfg.arity = (s.FStar_Tactics_Native.arity);
-        FStar_TypeChecker_Cfg.univ_arity = Prims.int_zero;
-        FStar_TypeChecker_Cfg.auto_reflect =
-          (FStar_Pervasives_Native.Some
-             (s.FStar_Tactics_Native.arity - Prims.int_one));
-        FStar_TypeChecker_Cfg.strong_reduction_ok =
-          (s.FStar_Tactics_Native.strong_reduction_ok);
-        FStar_TypeChecker_Cfg.requires_binder_substitution = false;
-        FStar_TypeChecker_Cfg.interpretation =
-          (fun psc ->
-             fun cb ->
-               fun _us -> fun t -> s.FStar_Tactics_Native.tactic psc cb t);
-        FStar_TypeChecker_Cfg.interpretation_nbe =
-          (fun _cb ->
-             fun _us ->
-               FStar_TypeChecker_NBETerm.dummy_interp
-                 s.FStar_Tactics_Native.name)
-      } in
-    let uu___1 = FStar_Tactics_Native.list_all () in
-    FStar_Compiler_List.map step_from_native_step uu___1
-let mk_total_step_1' :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 .
-    Prims.int ->
-      Prims.string ->
-        ('uuuuu -> 'uuuuu1) ->
-          'uuuuu FStar_Syntax_Embeddings.embedding ->
-            'uuuuu1 FStar_Syntax_Embeddings.embedding ->
-              ('uuuuu2 -> 'uuuuu3) ->
-                'uuuuu2 FStar_TypeChecker_NBETerm.embedding ->
-                  'uuuuu3 FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun uarity ->
-    fun nm ->
-      fun f ->
-        fun ea ->
-          fun er ->
-            fun nf ->
-              fun ena ->
-                fun enr ->
-                  let uu___ =
-                    FStar_Tactics_InterpFuns.mk_total_step_1 uarity nm f ea
-                      er nf ena enr in
-                  let uu___1 =
-                    FStar_Ident.lid_of_str
-                      (Prims.op_Hat "FStar.Tactics.Types." nm) in
-                  {
-                    FStar_TypeChecker_Cfg.name = uu___1;
-                    FStar_TypeChecker_Cfg.arity =
-                      (uu___.FStar_TypeChecker_Cfg.arity);
-                    FStar_TypeChecker_Cfg.univ_arity =
-                      (uu___.FStar_TypeChecker_Cfg.univ_arity);
-                    FStar_TypeChecker_Cfg.auto_reflect =
-                      (uu___.FStar_TypeChecker_Cfg.auto_reflect);
-                    FStar_TypeChecker_Cfg.strong_reduction_ok =
-                      (uu___.FStar_TypeChecker_Cfg.strong_reduction_ok);
-                    FStar_TypeChecker_Cfg.requires_binder_substitution =
-                      (uu___.FStar_TypeChecker_Cfg.requires_binder_substitution);
-                    FStar_TypeChecker_Cfg.interpretation =
-                      (uu___.FStar_TypeChecker_Cfg.interpretation);
-                    FStar_TypeChecker_Cfg.interpretation_nbe =
-                      (uu___.FStar_TypeChecker_Cfg.interpretation_nbe)
-                  }
-let mk_total_step_1'_psc :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 .
-    Prims.int ->
-      Prims.string ->
-        (FStar_TypeChecker_Cfg.psc -> 'uuuuu -> 'uuuuu1) ->
-          'uuuuu FStar_Syntax_Embeddings.embedding ->
-            'uuuuu1 FStar_Syntax_Embeddings.embedding ->
-              (FStar_TypeChecker_Cfg.psc -> 'uuuuu2 -> 'uuuuu3) ->
-                'uuuuu2 FStar_TypeChecker_NBETerm.embedding ->
-                  'uuuuu3 FStar_TypeChecker_NBETerm.embedding ->
-                    FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun uarity ->
-    fun nm ->
-      fun f ->
-        fun ea ->
-          fun er ->
-            fun nf ->
-              fun ena ->
-                fun enr ->
-                  let uu___ =
-                    FStar_Tactics_InterpFuns.mk_total_step_1_psc uarity nm f
-                      ea er nf ena enr in
-                  let uu___1 =
-                    FStar_Ident.lid_of_str
-                      (Prims.op_Hat "FStar.Tactics.Types." nm) in
-                  {
-                    FStar_TypeChecker_Cfg.name = uu___1;
-                    FStar_TypeChecker_Cfg.arity =
-                      (uu___.FStar_TypeChecker_Cfg.arity);
-                    FStar_TypeChecker_Cfg.univ_arity =
-                      (uu___.FStar_TypeChecker_Cfg.univ_arity);
-                    FStar_TypeChecker_Cfg.auto_reflect =
-                      (uu___.FStar_TypeChecker_Cfg.auto_reflect);
-                    FStar_TypeChecker_Cfg.strong_reduction_ok =
-                      (uu___.FStar_TypeChecker_Cfg.strong_reduction_ok);
-                    FStar_TypeChecker_Cfg.requires_binder_substitution =
-                      (uu___.FStar_TypeChecker_Cfg.requires_binder_substitution);
-                    FStar_TypeChecker_Cfg.interpretation =
-                      (uu___.FStar_TypeChecker_Cfg.interpretation);
-                    FStar_TypeChecker_Cfg.interpretation_nbe =
-                      (uu___.FStar_TypeChecker_Cfg.interpretation_nbe)
-                  }
-let mk_total_step_2' :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 'uuuuu4 'uuuuu5 .
-    Prims.int ->
-      Prims.string ->
-        ('uuuuu -> 'uuuuu1 -> 'uuuuu2) ->
-          'uuuuu FStar_Syntax_Embeddings.embedding ->
-            'uuuuu1 FStar_Syntax_Embeddings.embedding ->
-              'uuuuu2 FStar_Syntax_Embeddings.embedding ->
-                ('uuuuu3 -> 'uuuuu4 -> 'uuuuu5) ->
-                  'uuuuu3 FStar_TypeChecker_NBETerm.embedding ->
-                    'uuuuu4 FStar_TypeChecker_NBETerm.embedding ->
-                      'uuuuu5 FStar_TypeChecker_NBETerm.embedding ->
-                        FStar_TypeChecker_Cfg.primitive_step
-  =
-  fun uarity ->
-    fun nm ->
-      fun f ->
-        fun ea ->
-          fun eb ->
-            fun er ->
-              fun nf ->
-                fun ena ->
-                  fun enb ->
-                    fun enr ->
-                      let uu___ =
-                        FStar_Tactics_InterpFuns.mk_total_step_2 uarity nm f
-                          ea eb er nf ena enb enr in
-                      let uu___1 =
-                        FStar_Ident.lid_of_str
-                          (Prims.op_Hat "FStar.Tactics.Types." nm) in
-                      {
-                        FStar_TypeChecker_Cfg.name = uu___1;
-                        FStar_TypeChecker_Cfg.arity =
-                          (uu___.FStar_TypeChecker_Cfg.arity);
-                        FStar_TypeChecker_Cfg.univ_arity =
-                          (uu___.FStar_TypeChecker_Cfg.univ_arity);
-                        FStar_TypeChecker_Cfg.auto_reflect =
-                          (uu___.FStar_TypeChecker_Cfg.auto_reflect);
-                        FStar_TypeChecker_Cfg.strong_reduction_ok =
-                          (uu___.FStar_TypeChecker_Cfg.strong_reduction_ok);
-                        FStar_TypeChecker_Cfg.requires_binder_substitution =
-                          (uu___.FStar_TypeChecker_Cfg.requires_binder_substitution);
-                        FStar_TypeChecker_Cfg.interpretation =
-                          (uu___.FStar_TypeChecker_Cfg.interpretation);
-                        FStar_TypeChecker_Cfg.interpretation_nbe =
-                          (uu___.FStar_TypeChecker_Cfg.interpretation_nbe)
-                      }
-let (__primitive_steps_ref :
-  FStar_TypeChecker_Cfg.primitive_step Prims.list
-    FStar_Pervasives_Native.option FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (primitive_steps :
-  unit -> FStar_TypeChecker_Cfg.primitive_step Prims.list) =
-  fun uu___ ->
-    let uu___1 =
-      let uu___2 = FStar_Compiler_Effect.op_Bang __primitive_steps_ref in
-      FStar_Compiler_Util.must uu___2 in
-    let uu___2 = native_tactics_steps () in
-    FStar_Compiler_List.op_At uu___1 uu___2
-let unembed_tactic_0 :
-  'b .
-    'b FStar_Syntax_Embeddings.embedding ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Embeddings.norm_cb -> 'b FStar_Tactics_Monad.tac
-  =
-  fun eb ->
-    fun embedded_tac_b ->
-      fun ncb ->
-        FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-          (fun proof_state ->
-             let rng = embedded_tac_b.FStar_Syntax_Syntax.pos in
-             let embedded_tac_b1 = FStar_Syntax_Util.mk_reify embedded_tac_b in
-             let tm =
-               let uu___ =
-                 let uu___1 =
-                   let uu___2 =
-                     embed FStar_Tactics_Embedding.e_proofstate rng
-                       proof_state ncb in
-                   FStar_Syntax_Syntax.as_arg uu___2 in
-                 [uu___1] in
-               FStar_Syntax_Syntax.mk_Tm_app embedded_tac_b1 uu___ rng in
-             let steps =
-               [FStar_TypeChecker_Env.Weak;
-               FStar_TypeChecker_Env.Reify;
-               FStar_TypeChecker_Env.UnfoldUntil
-                 FStar_Syntax_Syntax.delta_constant;
-               FStar_TypeChecker_Env.UnfoldTac;
-               FStar_TypeChecker_Env.Primops;
-               FStar_TypeChecker_Env.Unascribe] in
-             let norm_f =
-               let uu___ = FStar_Options.tactics_nbe () in
-               if uu___
-               then FStar_TypeChecker_NBE.normalize
-               else
-                 FStar_TypeChecker_Normalize.normalize_with_primitive_steps in
-             let result =
-               let uu___ = primitive_steps () in
-               norm_f uu___ steps
-                 proof_state.FStar_Tactics_Types.main_context tm in
-             let res =
-               let uu___ = FStar_Tactics_Embedding.e_result eb in
-               unembed uu___ result ncb in
-             match res with
-             | FStar_Pervasives_Native.Some (FStar_Tactics_Result.Success
-                 (b1, ps)) ->
-                 let uu___ = FStar_Tactics_Monad.set ps in
-                 FStar_Tactics_Monad.bind uu___
-                   (fun uu___1 -> FStar_Tactics_Monad.ret b1)
-             | FStar_Pervasives_Native.Some (FStar_Tactics_Result.Failed
-                 (e, ps)) ->
-                 let uu___ = FStar_Tactics_Monad.set ps in
-                 FStar_Tactics_Monad.bind uu___
-                   (fun uu___1 -> FStar_Tactics_Monad.traise e)
-             | FStar_Pervasives_Native.None ->
-                 let uu___ =
-                   let uu___1 =
-                     let uu___2 = FStar_Syntax_Print.term_to_string result in
-                     FStar_Compiler_Util.format1
-                       "Tactic got stuck! Please file a bug report with a minimal reproduction of this issue.\n%s"
-                       uu___2 in
-                   (FStar_Errors.Fatal_TacticGotStuck, uu___1) in
-                 FStar_Errors.raise_error uu___
-                   (proof_state.FStar_Tactics_Types.main_context).FStar_TypeChecker_Env.range)
-let unembed_tactic_nbe_0 :
-  'b .
-    'b FStar_TypeChecker_NBETerm.embedding ->
-      FStar_TypeChecker_NBETerm.nbe_cbs ->
-        FStar_TypeChecker_NBETerm.t -> 'b FStar_Tactics_Monad.tac
-  =
-  fun eb ->
-    fun cb ->
-      fun embedded_tac_b ->
-        FStar_Tactics_Monad.bind FStar_Tactics_Monad.get
-          (fun proof_state ->
-             let result =
-               let uu___ =
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_TypeChecker_NBETerm.embed
-                       FStar_Tactics_Embedding.e_proofstate_nbe cb
-                       proof_state in
-                   FStar_TypeChecker_NBETerm.as_arg uu___2 in
-                 [uu___1] in
-               FStar_TypeChecker_NBETerm.iapp_cb cb embedded_tac_b uu___ in
-             let res =
-               let uu___ = FStar_Tactics_Embedding.e_result_nbe eb in
-               FStar_TypeChecker_NBETerm.unembed uu___ cb result in
-             match res with
-             | FStar_Pervasives_Native.Some (FStar_Tactics_Result.Success
-                 (b1, ps)) ->
-                 let uu___ = FStar_Tactics_Monad.set ps in
-                 FStar_Tactics_Monad.bind uu___
-                   (fun uu___1 -> FStar_Tactics_Monad.ret b1)
-             | FStar_Pervasives_Native.Some (FStar_Tactics_Result.Failed
-                 (e, ps)) ->
-                 let uu___ = FStar_Tactics_Monad.set ps in
-                 FStar_Tactics_Monad.bind uu___
-                   (fun uu___1 -> FStar_Tactics_Monad.traise e)
-             | FStar_Pervasives_Native.None ->
-                 let uu___ =
-                   let uu___1 =
-                     let uu___2 =
-                       FStar_TypeChecker_NBETerm.t_to_string result in
-                     FStar_Compiler_Util.format1
-                       "Tactic got stuck (in NBE)! Please file a bug report with a minimal reproduction of this issue.\n%s"
-                       uu___2 in
-                   (FStar_Errors.Fatal_TacticGotStuck, uu___1) in
-                 FStar_Errors.raise_error uu___
-                   (proof_state.FStar_Tactics_Types.main_context).FStar_TypeChecker_Env.range)
-let unembed_tactic_1 :
-  'a 'r .
-    'a FStar_Syntax_Embeddings.embedding ->
-      'r FStar_Syntax_Embeddings.embedding ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Embeddings.norm_cb -> 'a -> 'r FStar_Tactics_Monad.tac
-  =
-  fun ea ->
-    fun er ->
-      fun f ->
-        fun ncb ->
-          fun x ->
-            let rng = FStar_Compiler_Range.dummyRange in
-            let x_tm = embed ea rng x ncb in
-            let app =
-              let uu___ =
-                let uu___1 = FStar_Syntax_Syntax.as_arg x_tm in [uu___1] in
-              FStar_Syntax_Syntax.mk_Tm_app f uu___ rng in
-            unembed_tactic_0 er app ncb
-let unembed_tactic_nbe_1 :
-  'a 'r .
-    'a FStar_TypeChecker_NBETerm.embedding ->
-      'r FStar_TypeChecker_NBETerm.embedding ->
-        FStar_TypeChecker_NBETerm.nbe_cbs ->
-          FStar_TypeChecker_NBETerm.t -> 'a -> 'r FStar_Tactics_Monad.tac
-  =
-  fun ea ->
-    fun er ->
-      fun cb ->
-        fun f ->
-          fun x ->
-            let x_tm = FStar_TypeChecker_NBETerm.embed ea cb x in
-            let app =
-              let uu___ =
-                let uu___1 = FStar_TypeChecker_NBETerm.as_arg x_tm in
-                [uu___1] in
-              FStar_TypeChecker_NBETerm.iapp_cb cb f uu___ in
-            unembed_tactic_nbe_0 er cb app
-let e_tactic_thunk :
-  'r .
-    'r FStar_Syntax_Embeddings.embedding ->
-      'r FStar_Tactics_Monad.tac FStar_Syntax_Embeddings.embedding
-  =
-  fun er ->
-    let uu___ = FStar_Syntax_Embeddings.term_as_fv FStar_Syntax_Syntax.t_unit in
-    FStar_Syntax_Embeddings.mk_emb
-      (fun uu___1 ->
-         fun uu___2 ->
-           fun uu___3 ->
-             fun uu___4 -> failwith "Impossible: embedding tactic (thunk)?")
-      (fun t ->
-         fun w ->
-           fun cb ->
-             let uu___1 =
-               let uu___2 =
-                 unembed_tactic_1 FStar_Syntax_Embeddings.e_unit er t cb in
-               uu___2 () in
-             FStar_Pervasives_Native.Some uu___1) uu___
-let e_tactic_nbe_thunk :
-  'r .
-    'r FStar_TypeChecker_NBETerm.embedding ->
-      'r FStar_Tactics_Monad.tac FStar_TypeChecker_NBETerm.embedding
-  =
-  fun er ->
-    let uu___ =
-      FStar_TypeChecker_NBETerm.mk_t
-        (FStar_TypeChecker_NBETerm.Constant FStar_TypeChecker_NBETerm.Unit) in
-    let uu___1 =
-      FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_unit in
-    FStar_TypeChecker_NBETerm.mk_emb
-      (fun cb ->
-         fun uu___2 -> failwith "Impossible: NBE embedding tactic (thunk)?")
-      (fun cb ->
-         fun t ->
-           let uu___2 =
-             let uu___3 =
-               unembed_tactic_nbe_1 FStar_TypeChecker_NBETerm.e_unit er cb t in
-             uu___3 () in
-           FStar_Pervasives_Native.Some uu___2) uu___ uu___1
-let e_tactic_1 :
-  'a 'r .
-    'a FStar_Syntax_Embeddings.embedding ->
-      'r FStar_Syntax_Embeddings.embedding ->
-        ('a -> 'r FStar_Tactics_Monad.tac) FStar_Syntax_Embeddings.embedding
-  =
-  fun ea ->
-    fun er ->
-      let uu___ =
-        FStar_Syntax_Embeddings.term_as_fv FStar_Syntax_Syntax.t_unit in
-      FStar_Syntax_Embeddings.mk_emb
-        (fun uu___1 ->
-           fun uu___2 ->
-             fun uu___3 ->
-               fun uu___4 -> failwith "Impossible: embedding tactic (1)?")
-        (fun t ->
-           fun w ->
-             fun cb ->
-               let uu___1 = unembed_tactic_1 ea er t cb in
-               FStar_Pervasives_Native.Some uu___1) uu___
-let e_tactic_nbe_1 :
-  'a 'r .
-    'a FStar_TypeChecker_NBETerm.embedding ->
-      'r FStar_TypeChecker_NBETerm.embedding ->
-        ('a -> 'r FStar_Tactics_Monad.tac)
-          FStar_TypeChecker_NBETerm.embedding
-  =
-  fun ea ->
-    fun er ->
-      let uu___ =
-        FStar_TypeChecker_NBETerm.mk_t
-          (FStar_TypeChecker_NBETerm.Constant FStar_TypeChecker_NBETerm.Unit) in
-      let uu___1 =
-        FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_unit in
-      FStar_TypeChecker_NBETerm.mk_emb
-        (fun cb ->
-           fun uu___2 -> failwith "Impossible: NBE embedding tactic (1)?")
-        (fun cb ->
-           fun t ->
-             let uu___2 = unembed_tactic_nbe_1 ea er cb t in
-             FStar_Pervasives_Native.Some uu___2) uu___ uu___1
-let (uu___153 : unit) =
-  let uu___ =
-    let uu___1 =
-      let uu___2 =
-        mk_total_step_1'_psc Prims.int_zero "tracepoint"
-          FStar_Tactics_Types.tracepoint_with_psc
-          FStar_Tactics_Embedding.e_proofstate FStar_Syntax_Embeddings.e_bool
-          FStar_Tactics_Types.tracepoint_with_psc
-          FStar_Tactics_Embedding.e_proofstate_nbe
-          FStar_TypeChecker_NBETerm.e_bool in
-      let uu___3 =
-        let uu___4 =
-          mk_total_step_2' Prims.int_zero "set_proofstate_range"
-            FStar_Tactics_Types.set_proofstate_range
-            FStar_Tactics_Embedding.e_proofstate
-            FStar_Syntax_Embeddings.e_range
-            FStar_Tactics_Embedding.e_proofstate
-            FStar_Tactics_Types.set_proofstate_range
-            FStar_Tactics_Embedding.e_proofstate_nbe
-            FStar_TypeChecker_NBETerm.e_range
-            FStar_Tactics_Embedding.e_proofstate_nbe in
-        let uu___5 =
-          let uu___6 =
-            mk_total_step_1' Prims.int_zero "incr_depth"
-              FStar_Tactics_Types.incr_depth
-              FStar_Tactics_Embedding.e_proofstate
-              FStar_Tactics_Embedding.e_proofstate
-              FStar_Tactics_Types.incr_depth
-              FStar_Tactics_Embedding.e_proofstate_nbe
-              FStar_Tactics_Embedding.e_proofstate_nbe in
-          let uu___7 =
-            let uu___8 =
-              mk_total_step_1' Prims.int_zero "decr_depth"
-                FStar_Tactics_Types.decr_depth
-                FStar_Tactics_Embedding.e_proofstate
-                FStar_Tactics_Embedding.e_proofstate
-                FStar_Tactics_Types.decr_depth
-                FStar_Tactics_Embedding.e_proofstate_nbe
-                FStar_Tactics_Embedding.e_proofstate_nbe in
-            let uu___9 =
-              let uu___10 =
-                let uu___11 =
-                  FStar_Syntax_Embeddings.e_list
-                    FStar_Tactics_Embedding.e_goal in
-                let uu___12 =
-                  FStar_TypeChecker_NBETerm.e_list
-                    FStar_Tactics_Embedding.e_goal_nbe in
-                mk_total_step_1' Prims.int_zero "goals_of"
-                  FStar_Tactics_Types.goals_of
-                  FStar_Tactics_Embedding.e_proofstate uu___11
-                  FStar_Tactics_Types.goals_of
-                  FStar_Tactics_Embedding.e_proofstate_nbe uu___12 in
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    FStar_Syntax_Embeddings.e_list
-                      FStar_Tactics_Embedding.e_goal in
-                  let uu___14 =
-                    FStar_TypeChecker_NBETerm.e_list
-                      FStar_Tactics_Embedding.e_goal_nbe in
-                  mk_total_step_1' Prims.int_zero "smt_goals_of"
-                    FStar_Tactics_Types.smt_goals_of
-                    FStar_Tactics_Embedding.e_proofstate uu___13
-                    FStar_Tactics_Types.smt_goals_of
-                    FStar_Tactics_Embedding.e_proofstate_nbe uu___14 in
-                let uu___13 =
-                  let uu___14 =
-                    mk_total_step_1' Prims.int_zero "goal_env"
-                      FStar_Tactics_Types.goal_env
-                      FStar_Tactics_Embedding.e_goal
-                      FStar_Reflection_Embeddings.e_env
-                      FStar_Tactics_Types.goal_env
-                      FStar_Tactics_Embedding.e_goal_nbe
-                      FStar_Reflection_NBEEmbeddings.e_env in
-                  let uu___15 =
-                    let uu___16 =
-                      mk_total_step_1' Prims.int_zero "goal_type"
-                        FStar_Tactics_Types.goal_type
-                        FStar_Tactics_Embedding.e_goal
-                        FStar_Reflection_Embeddings.e_term
-                        FStar_Tactics_Types.goal_type
-                        FStar_Tactics_Embedding.e_goal_nbe
-                        FStar_Reflection_NBEEmbeddings.e_term in
-                    let uu___17 =
-                      let uu___18 =
-                        mk_total_step_1' Prims.int_zero "goal_witness"
-                          FStar_Tactics_Types.goal_witness
-                          FStar_Tactics_Embedding.e_goal
-                          FStar_Reflection_Embeddings.e_term
-                          FStar_Tactics_Types.goal_witness
-                          FStar_Tactics_Embedding.e_goal_nbe
-                          FStar_Reflection_NBEEmbeddings.e_term in
-                      let uu___19 =
-                        let uu___20 =
-                          mk_total_step_1' Prims.int_zero "is_guard"
-                            FStar_Tactics_Types.is_guard
-                            FStar_Tactics_Embedding.e_goal
-                            FStar_Syntax_Embeddings.e_bool
-                            FStar_Tactics_Types.is_guard
-                            FStar_Tactics_Embedding.e_goal_nbe
-                            FStar_TypeChecker_NBETerm.e_bool in
-                        let uu___21 =
-                          let uu___22 =
-                            mk_total_step_1' Prims.int_zero "get_label"
-                              FStar_Tactics_Types.get_label
-                              FStar_Tactics_Embedding.e_goal
-                              FStar_Syntax_Embeddings.e_string
-                              FStar_Tactics_Types.get_label
-                              FStar_Tactics_Embedding.e_goal_nbe
-                              FStar_TypeChecker_NBETerm.e_string in
-                          let uu___23 =
-                            let uu___24 =
-                              mk_total_step_2' Prims.int_zero "set_label"
-                                FStar_Tactics_Types.set_label
-                                FStar_Syntax_Embeddings.e_string
-                                FStar_Tactics_Embedding.e_goal
-                                FStar_Tactics_Embedding.e_goal
-                                FStar_Tactics_Types.set_label
-                                FStar_TypeChecker_NBETerm.e_string
-                                FStar_Tactics_Embedding.e_goal_nbe
-                                FStar_Tactics_Embedding.e_goal_nbe in
-                            let uu___25 =
-                              let uu___26 =
-                                let uu___27 =
-                                  FStar_Syntax_Embeddings.e_list
-                                    FStar_Tactics_Embedding.e_goal in
-                                let uu___28 =
-                                  FStar_TypeChecker_NBETerm.e_list
-                                    FStar_Tactics_Embedding.e_goal_nbe in
-                                FStar_Tactics_InterpFuns.mk_tac_step_1
-                                  Prims.int_zero "set_goals"
-                                  FStar_Tactics_Monad.set_goals uu___27
-                                  FStar_Syntax_Embeddings.e_unit
-                                  FStar_Tactics_Monad.set_goals uu___28
-                                  FStar_TypeChecker_NBETerm.e_unit in
-                              let uu___27 =
-                                let uu___28 =
-                                  let uu___29 =
-                                    FStar_Syntax_Embeddings.e_list
-                                      FStar_Tactics_Embedding.e_goal in
-                                  let uu___30 =
-                                    FStar_TypeChecker_NBETerm.e_list
-                                      FStar_Tactics_Embedding.e_goal_nbe in
-                                  FStar_Tactics_InterpFuns.mk_tac_step_1
-                                    Prims.int_zero "set_smt_goals"
-                                    FStar_Tactics_Monad.set_smt_goals uu___29
-                                    FStar_Syntax_Embeddings.e_unit
-                                    FStar_Tactics_Monad.set_smt_goals uu___30
-                                    FStar_TypeChecker_NBETerm.e_unit in
-                                let uu___29 =
-                                  let uu___30 =
-                                    let uu___31 =
-                                      e_tactic_thunk
-                                        FStar_Syntax_Embeddings.e_any in
-                                    let uu___32 =
-                                      FStar_Syntax_Embeddings.e_either
-                                        FStar_Tactics_Embedding.e_exn
-                                        FStar_Syntax_Embeddings.e_any in
-                                    let uu___33 =
-                                      e_tactic_nbe_thunk
-                                        FStar_TypeChecker_NBETerm.e_any in
-                                    let uu___34 =
-                                      FStar_TypeChecker_NBETerm.e_either
-                                        FStar_Tactics_Embedding.e_exn_nbe
-                                        FStar_TypeChecker_NBETerm.e_any in
-                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                      Prims.int_one "catch"
-                                      (fun uu___35 ->
-                                         FStar_Tactics_Monad.catch)
-                                      FStar_Syntax_Embeddings.e_any uu___31
-                                      uu___32
-                                      (fun uu___35 ->
-                                         FStar_Tactics_Monad.catch)
-                                      FStar_TypeChecker_NBETerm.e_any uu___33
-                                      uu___34 in
-                                  let uu___31 =
-                                    let uu___32 =
-                                      let uu___33 =
-                                        e_tactic_thunk
-                                          FStar_Syntax_Embeddings.e_any in
-                                      let uu___34 =
-                                        FStar_Syntax_Embeddings.e_either
-                                          FStar_Tactics_Embedding.e_exn
-                                          FStar_Syntax_Embeddings.e_any in
-                                      let uu___35 =
-                                        e_tactic_nbe_thunk
-                                          FStar_TypeChecker_NBETerm.e_any in
-                                      let uu___36 =
-                                        FStar_TypeChecker_NBETerm.e_either
-                                          FStar_Tactics_Embedding.e_exn_nbe
-                                          FStar_TypeChecker_NBETerm.e_any in
-                                      FStar_Tactics_InterpFuns.mk_tac_step_2
-                                        Prims.int_one "recover"
-                                        (fun uu___37 ->
-                                           FStar_Tactics_Monad.recover)
-                                        FStar_Syntax_Embeddings.e_any uu___33
-                                        uu___34
-                                        (fun uu___37 ->
-                                           FStar_Tactics_Monad.recover)
-                                        FStar_TypeChecker_NBETerm.e_any
-                                        uu___35 uu___36 in
-                                    let uu___33 =
-                                      let uu___34 =
-                                        FStar_Tactics_InterpFuns.mk_tac_step_1
-                                          Prims.int_zero "intro"
-                                          FStar_Tactics_Basic.intro
-                                          FStar_Syntax_Embeddings.e_unit
-                                          FStar_Reflection_Embeddings.e_binder
-                                          FStar_Tactics_Basic.intro
-                                          FStar_TypeChecker_NBETerm.e_unit
-                                          FStar_Reflection_NBEEmbeddings.e_binder in
-                                      let uu___35 =
-                                        let uu___36 =
-                                          let uu___37 =
-                                            FStar_Syntax_Embeddings.e_tuple2
-                                              FStar_Reflection_Embeddings.e_binder
-                                              FStar_Reflection_Embeddings.e_binder in
-                                          let uu___38 =
-                                            FStar_TypeChecker_NBETerm.e_tuple2
-                                              FStar_Reflection_NBEEmbeddings.e_binder
-                                              FStar_Reflection_NBEEmbeddings.e_binder in
-                                          FStar_Tactics_InterpFuns.mk_tac_step_1
-                                            Prims.int_zero "intro_rec"
-                                            FStar_Tactics_Basic.intro_rec
-                                            FStar_Syntax_Embeddings.e_unit
-                                            uu___37
-                                            FStar_Tactics_Basic.intro_rec
-                                            FStar_TypeChecker_NBETerm.e_unit
-                                            uu___38 in
-                                        let uu___37 =
-                                          let uu___38 =
-                                            let uu___39 =
-                                              FStar_Syntax_Embeddings.e_list
-                                                FStar_Syntax_Embeddings.e_norm_step in
-                                            let uu___40 =
-                                              FStar_TypeChecker_NBETerm.e_list
-                                                FStar_TypeChecker_NBETerm.e_norm_step in
-                                            FStar_Tactics_InterpFuns.mk_tac_step_1
-                                              Prims.int_zero "norm"
-                                              FStar_Tactics_Basic.norm
-                                              uu___39
-                                              FStar_Syntax_Embeddings.e_unit
-                                              FStar_Tactics_Basic.norm
-                                              uu___40
-                                              FStar_TypeChecker_NBETerm.e_unit in
-                                          let uu___39 =
-                                            let uu___40 =
-                                              let uu___41 =
-                                                FStar_Syntax_Embeddings.e_list
-                                                  FStar_Syntax_Embeddings.e_norm_step in
-                                              let uu___42 =
-                                                FStar_TypeChecker_NBETerm.e_list
-                                                  FStar_TypeChecker_NBETerm.e_norm_step in
-                                              FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                Prims.int_zero
-                                                "norm_term_env"
-                                                FStar_Tactics_Basic.norm_term_env
-                                                FStar_Reflection_Embeddings.e_env
-                                                uu___41
-                                                FStar_Reflection_Embeddings.e_term
-                                                FStar_Reflection_Embeddings.e_term
-                                                FStar_Tactics_Basic.norm_term_env
-                                                FStar_Reflection_NBEEmbeddings.e_env
-                                                uu___42
-                                                FStar_Reflection_NBEEmbeddings.e_term
-                                                FStar_Reflection_NBEEmbeddings.e_term in
-                                            let uu___41 =
-                                              let uu___42 =
-                                                let uu___43 =
-                                                  FStar_Syntax_Embeddings.e_list
-                                                    FStar_Syntax_Embeddings.e_norm_step in
-                                                let uu___44 =
-                                                  FStar_TypeChecker_NBETerm.e_list
-                                                    FStar_TypeChecker_NBETerm.e_norm_step in
-                                                FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                  Prims.int_zero
-                                                  "norm_binder_type"
-                                                  FStar_Tactics_Basic.norm_binder_type
-                                                  uu___43
-                                                  FStar_Reflection_Embeddings.e_binder
-                                                  FStar_Syntax_Embeddings.e_unit
-                                                  FStar_Tactics_Basic.norm_binder_type
-                                                  uu___44
-                                                  FStar_Reflection_NBEEmbeddings.e_binder
-                                                  FStar_TypeChecker_NBETerm.e_unit in
-                                              let uu___43 =
-                                                let uu___44 =
-                                                  FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                    Prims.int_zero
-                                                    "rename_to"
-                                                    FStar_Tactics_Basic.rename_to
-                                                    FStar_Reflection_Embeddings.e_binder
-                                                    FStar_Syntax_Embeddings.e_string
-                                                    FStar_Reflection_Embeddings.e_binder
-                                                    FStar_Tactics_Basic.rename_to
-                                                    FStar_Reflection_NBEEmbeddings.e_binder
-                                                    FStar_TypeChecker_NBETerm.e_string
-                                                    FStar_Reflection_NBEEmbeddings.e_binder in
-                                                let uu___45 =
-                                                  let uu___46 =
-                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                      Prims.int_zero
-                                                      "binder_retype"
-                                                      FStar_Tactics_Basic.binder_retype
-                                                      FStar_Reflection_Embeddings.e_binder
-                                                      FStar_Syntax_Embeddings.e_unit
-                                                      FStar_Tactics_Basic.binder_retype
-                                                      FStar_Reflection_NBEEmbeddings.e_binder
-                                                      FStar_TypeChecker_NBETerm.e_unit in
-                                                  let uu___47 =
-                                                    let uu___48 =
-                                                      FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                        Prims.int_zero
-                                                        "revert"
-                                                        FStar_Tactics_Basic.revert
-                                                        FStar_Syntax_Embeddings.e_unit
-                                                        FStar_Syntax_Embeddings.e_unit
-                                                        FStar_Tactics_Basic.revert
-                                                        FStar_TypeChecker_NBETerm.e_unit
-                                                        FStar_TypeChecker_NBETerm.e_unit in
-                                                    let uu___49 =
-                                                      let uu___50 =
-                                                        FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                          Prims.int_zero
-                                                          "clear_top"
-                                                          FStar_Tactics_Basic.clear_top
-                                                          FStar_Syntax_Embeddings.e_unit
-                                                          FStar_Syntax_Embeddings.e_unit
-                                                          FStar_Tactics_Basic.clear_top
-                                                          FStar_TypeChecker_NBETerm.e_unit
-                                                          FStar_TypeChecker_NBETerm.e_unit in
-                                                      let uu___51 =
-                                                        let uu___52 =
-                                                          FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                            Prims.int_zero
-                                                            "clear"
-                                                            FStar_Tactics_Basic.clear
-                                                            FStar_Reflection_Embeddings.e_binder
-                                                            FStar_Syntax_Embeddings.e_unit
-                                                            FStar_Tactics_Basic.clear
-                                                            FStar_Reflection_NBEEmbeddings.e_binder
-                                                            FStar_TypeChecker_NBETerm.e_unit in
-                                                        let uu___53 =
-                                                          let uu___54 =
-                                                            FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                              Prims.int_zero
-                                                              "rewrite"
-                                                              FStar_Tactics_Basic.rewrite
-                                                              FStar_Reflection_Embeddings.e_binder
-                                                              FStar_Syntax_Embeddings.e_unit
-                                                              FStar_Tactics_Basic.rewrite
-                                                              FStar_Reflection_NBEEmbeddings.e_binder
-                                                              FStar_TypeChecker_NBETerm.e_unit in
-                                                          let uu___55 =
-                                                            let uu___56 =
-                                                              FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                Prims.int_zero
-                                                                "refine_intro"
-                                                                FStar_Tactics_Basic.refine_intro
-                                                                FStar_Syntax_Embeddings.e_unit
-                                                                FStar_Syntax_Embeddings.e_unit
-                                                                FStar_Tactics_Basic.refine_intro
-                                                                FStar_TypeChecker_NBETerm.e_unit
-                                                                FStar_TypeChecker_NBETerm.e_unit in
-                                                            let uu___57 =
-                                                              let uu___58 =
-                                                                FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                  Prims.int_zero
-                                                                  "t_exact"
-                                                                  FStar_Tactics_Basic.t_exact
-                                                                  FStar_Syntax_Embeddings.e_bool
-                                                                  FStar_Syntax_Embeddings.e_bool
-                                                                  FStar_Reflection_Embeddings.e_term
-                                                                  FStar_Syntax_Embeddings.e_unit
-                                                                  FStar_Tactics_Basic.t_exact
-                                                                  FStar_TypeChecker_NBETerm.e_bool
-                                                                  FStar_TypeChecker_NBETerm.e_bool
-                                                                  FStar_Reflection_NBEEmbeddings.e_term
-                                                                  FStar_TypeChecker_NBETerm.e_unit in
-                                                              let uu___59 =
-                                                                let uu___60 =
-                                                                  FStar_Tactics_InterpFuns.mk_tac_step_4
-                                                                    Prims.int_zero
-                                                                    "t_apply"
-                                                                    FStar_Tactics_Basic.t_apply
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.t_apply
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                let uu___61 =
-                                                                  let uu___62
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_zero
-                                                                    "t_apply_lemma"
-                                                                    FStar_Tactics_Basic.t_apply_lemma
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.t_apply_lemma
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                  let uu___63
-                                                                    =
-                                                                    let uu___64
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "set_options"
-                                                                    FStar_Tactics_Basic.set_options
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.set_options
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___65
-                                                                    =
-                                                                    let uu___66
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "tcc"
-                                                                    FStar_Tactics_Basic.tcc
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_comp
-                                                                    FStar_Tactics_Basic.tcc
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_comp in
-                                                                    let uu___67
-                                                                    =
-                                                                    let uu___68
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "tc"
-                                                                    FStar_Tactics_Basic.tc
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Tactics_Basic.tc
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    let uu___69
-                                                                    =
-                                                                    let uu___70
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "unshelve"
-                                                                    FStar_Tactics_Basic.unshelve
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.unshelve
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___71
-                                                                    =
-                                                                    let uu___72
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_one
-                                                                    "unquote"
-                                                                    FStar_Tactics_Basic.unquote
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    (fun
-                                                                    uu___73
-                                                                    ->
-                                                                    fun
-                                                                    uu___74
-                                                                    ->
-                                                                    failwith
-                                                                    "NBE unquote")
-                                                                    FStar_TypeChecker_NBETerm.e_any
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_any in
-                                                                    let uu___73
-                                                                    =
-                                                                    let uu___74
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "prune"
-                                                                    FStar_Tactics_Basic.prune
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.prune
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___75
-                                                                    =
-                                                                    let uu___76
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "addns"
-                                                                    FStar_Tactics_Basic.addns
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.addns
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___77
-                                                                    =
-                                                                    let uu___78
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "print"
-                                                                    FStar_Tactics_Basic.print
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.print
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___79
-                                                                    =
-                                                                    let uu___80
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "debugging"
-                                                                    FStar_Tactics_Basic.debugging
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Basic.debugging
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_bool in
-                                                                    let uu___81
-                                                                    =
-                                                                    let uu___82
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "dump"
-                                                                    FStar_Tactics_Basic.dump
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.dump
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___83
-                                                                    =
-                                                                    let uu___84
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "dump_all"
-                                                                    FStar_Tactics_Basic.dump_all
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.dump_all
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___85
-                                                                    =
-                                                                    let uu___86
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "dump_uvars_of"
-                                                                    FStar_Tactics_Basic.dump_uvars_of
-                                                                    FStar_Tactics_Embedding.e_goal
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.dump_uvars_of
-                                                                    FStar_Tactics_Embedding.e_goal_nbe
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___87
-                                                                    =
-                                                                    let uu___88
-                                                                    =
-                                                                    let uu___89
-                                                                    =
-                                                                    let uu___90
-                                                                    =
-                                                                    FStar_Syntax_Embeddings.e_tuple2
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Embedding.e_ctrl_flag in
-                                                                    e_tactic_1
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    uu___90 in
-                                                                    let uu___90
-                                                                    =
-                                                                    e_tactic_thunk
-                                                                    FStar_Syntax_Embeddings.e_unit in
-                                                                    let uu___91
-                                                                    =
-                                                                    let uu___92
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.e_tuple2
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_Tactics_Embedding.e_ctrl_flag_nbe in
-                                                                    e_tactic_nbe_1
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    uu___92 in
-                                                                    let uu___92
-                                                                    =
-                                                                    e_tactic_nbe_thunk
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_zero
-                                                                    "ctrl_rewrite"
-                                                                    FStar_Tactics_CtrlRewrite.ctrl_rewrite
-                                                                    FStar_Tactics_Embedding.e_direction
-                                                                    uu___89
-                                                                    uu___90
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_CtrlRewrite.ctrl_rewrite
-                                                                    FStar_Tactics_Embedding.e_direction_nbe
-                                                                    uu___91
-                                                                    uu___92
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___89
-                                                                    =
-                                                                    let uu___90
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "t_trefl"
-                                                                    FStar_Tactics_Basic.t_trefl
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.t_trefl
-                                                                    FStar_TypeChecker_NBETerm.e_bool
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___91
-                                                                    =
-                                                                    let uu___92
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "dup"
-                                                                    FStar_Tactics_Basic.dup
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.dup
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___93
-                                                                    =
-                                                                    let uu___94
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "tadmit_t"
-                                                                    FStar_Tactics_Basic.tadmit_t
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.tadmit_t
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___95
-                                                                    =
-                                                                    let uu___96
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "join"
-                                                                    FStar_Tactics_Basic.join
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.join
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___97
-                                                                    =
-                                                                    let uu___98
-                                                                    =
-                                                                    let uu___99
-                                                                    =
-                                                                    let uu___100
-                                                                    =
-                                                                    FStar_Syntax_Embeddings.e_tuple2
-                                                                    FStar_Reflection_Embeddings.e_fv
-                                                                    FStar_Syntax_Embeddings.e_int in
-                                                                    FStar_Syntax_Embeddings.e_list
-                                                                    uu___100 in
-                                                                    let uu___100
-                                                                    =
-                                                                    let uu___101
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.e_tuple2
-                                                                    FStar_Reflection_NBEEmbeddings.e_fv
-                                                                    FStar_TypeChecker_NBETerm.e_int in
-                                                                    FStar_TypeChecker_NBETerm.e_list
-                                                                    uu___101 in
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "t_destruct"
-                                                                    FStar_Tactics_Basic.t_destruct
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    uu___99
-                                                                    FStar_Tactics_Basic.t_destruct
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    uu___100 in
-                                                                    let uu___99
-                                                                    =
-                                                                    let uu___100
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "top_env"
-                                                                    FStar_Tactics_Basic.top_env
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Tactics_Basic.top_env
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_Reflection_NBEEmbeddings.e_env in
-                                                                    let uu___101
-                                                                    =
-                                                                    let uu___102
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "inspect"
-                                                                    FStar_Tactics_Basic.inspect
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_term_view
-                                                                    FStar_Tactics_Basic.inspect
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_term_view in
-                                                                    let uu___103
-                                                                    =
-                                                                    let uu___104
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "pack"
-                                                                    FStar_Tactics_Basic.pack
-                                                                    FStar_Reflection_Embeddings.e_term_view
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Tactics_Basic.pack
-                                                                    FStar_Reflection_NBEEmbeddings.e_term_view
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    let uu___105
-                                                                    =
-                                                                    let uu___106
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "pack_curried"
-                                                                    FStar_Tactics_Basic.pack_curried
-                                                                    FStar_Reflection_Embeddings.e_term_view
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Tactics_Basic.pack_curried
-                                                                    FStar_Reflection_NBEEmbeddings.e_term_view
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    let uu___107
-                                                                    =
-                                                                    let uu___108
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "fresh"
-                                                                    FStar_Tactics_Basic.fresh
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_int
-                                                                    FStar_Tactics_Basic.fresh
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_int in
-                                                                    let uu___109
-                                                                    =
-                                                                    let uu___110
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "curms"
-                                                                    FStar_Tactics_Basic.curms
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_int
-                                                                    FStar_Tactics_Basic.curms
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_int in
-                                                                    let uu___111
-                                                                    =
-                                                                    let uu___112
-                                                                    =
-                                                                    let uu___113
-                                                                    =
-                                                                    FStar_Syntax_Embeddings.e_option
-                                                                    FStar_Reflection_Embeddings.e_term in
-                                                                    let uu___114
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.e_option
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "uvar_env"
-                                                                    FStar_Tactics_Basic.uvar_env
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    uu___113
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Tactics_Basic.uvar_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    uu___114
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    let uu___113
-                                                                    =
-                                                                    let uu___114
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "fresh_universe_uvar"
-                                                                    FStar_Tactics_Basic.fresh_universe_uvar
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Tactics_Basic.fresh_universe_uvar
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    let uu___115
-                                                                    =
-                                                                    let uu___116
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_zero
-                                                                    "unify_env"
-                                                                    FStar_Tactics_Basic.unify_env
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Basic.unify_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_bool in
-                                                                    let uu___117
-                                                                    =
-                                                                    let uu___118
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_zero
-                                                                    "unify_guard_env"
-                                                                    FStar_Tactics_Basic.unify_guard_env
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Basic.unify_guard_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_bool in
-                                                                    let uu___119
-                                                                    =
-                                                                    let uu___120
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_zero
-                                                                    "match_env"
-                                                                    FStar_Tactics_Basic.match_env
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Basic.match_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_bool in
-                                                                    let uu___121
-                                                                    =
-                                                                    let uu___122
-                                                                    =
-                                                                    let uu___123
-                                                                    =
-                                                                    FStar_Syntax_Embeddings.e_list
-                                                                    FStar_Syntax_Embeddings.e_string in
-                                                                    let uu___124
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.e_list
-                                                                    FStar_TypeChecker_NBETerm.e_string in
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_zero
-                                                                    "launch_process"
-                                                                    FStar_Tactics_Basic.launch_process
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    uu___123
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Tactics_Basic.launch_process
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    uu___124
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_string in
-                                                                    let uu___123
-                                                                    =
-                                                                    let uu___124
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "fresh_bv_named"
-                                                                    FStar_Tactics_Basic.fresh_bv_named
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_bv
-                                                                    FStar_Tactics_Basic.fresh_bv_named
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_bv in
-                                                                    let uu___125
-                                                                    =
-                                                                    let uu___126
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "change"
-                                                                    FStar_Tactics_Basic.change
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.change
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___127
-                                                                    =
-                                                                    let uu___128
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "get_guard_policy"
-                                                                    FStar_Tactics_Basic.get_guard_policy
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Embedding.e_guard_policy
-                                                                    FStar_Tactics_Basic.get_guard_policy
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_Tactics_Embedding.e_guard_policy_nbe in
-                                                                    let uu___129
-                                                                    =
-                                                                    let uu___130
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "set_guard_policy"
-                                                                    FStar_Tactics_Basic.set_guard_policy
-                                                                    FStar_Tactics_Embedding.e_guard_policy
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.set_guard_policy
-                                                                    FStar_Tactics_Embedding.e_guard_policy_nbe
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___131
-                                                                    =
-                                                                    let uu___132
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "lax_on"
-                                                                    FStar_Tactics_Basic.lax_on
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Basic.lax_on
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_bool in
-                                                                    let uu___133
-                                                                    =
-                                                                    let uu___134
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_one
-                                                                    "lget"
-                                                                    FStar_Tactics_Basic.lget
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    (fun
-                                                                    uu___135
-                                                                    ->
-                                                                    fun
-                                                                    uu___136
-                                                                    ->
-                                                                    FStar_Tactics_Monad.fail
-                                                                    "sorry, `lget` does not work in NBE")
-                                                                    FStar_TypeChecker_NBETerm.e_any
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_any in
-                                                                    let uu___135
-                                                                    =
-                                                                    let uu___136
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_one
-                                                                    "lset"
-                                                                    FStar_Tactics_Basic.lset
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    (fun
-                                                                    uu___137
-                                                                    ->
-                                                                    fun
-                                                                    uu___138
-                                                                    ->
-                                                                    fun
-                                                                    uu___139
-                                                                    ->
-                                                                    FStar_Tactics_Monad.fail
-                                                                    "sorry, `lset` does not work in NBE")
-                                                                    FStar_TypeChecker_NBETerm.e_any
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_TypeChecker_NBETerm.e_any
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___137
-                                                                    =
-                                                                    let uu___138
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_one
-                                                                    "set_urgency"
-                                                                    FStar_Tactics_Basic.set_urgency
-                                                                    FStar_Syntax_Embeddings.e_int
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.set_urgency
-                                                                    FStar_TypeChecker_NBETerm.e_int
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___139
-                                                                    =
-                                                                    let uu___140
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_one
-                                                                    "t_commute_applied_match"
-                                                                    FStar_Tactics_Basic.t_commute_applied_match
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.t_commute_applied_match
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___141
-                                                                    =
-                                                                    let uu___142
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "gather_or_solve_explicit_guards_for_resolved_goals"
-                                                                    FStar_Tactics_Basic.gather_explicit_guards_for_resolved_goals
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Syntax_Embeddings.e_unit
-                                                                    FStar_Tactics_Basic.gather_explicit_guards_for_resolved_goals
-                                                                    FStar_TypeChecker_NBETerm.e_unit
-                                                                    FStar_TypeChecker_NBETerm.e_unit in
-                                                                    let uu___143
-                                                                    =
-                                                                    let uu___144
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "string_to_term"
-                                                                    FStar_Tactics_Basic.string_to_term
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Tactics_Basic.string_to_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    FStar_Reflection_NBEEmbeddings.e_term in
-                                                                    let uu___145
-                                                                    =
-                                                                    let uu___146
-                                                                    =
-                                                                    let uu___147
-                                                                    =
-                                                                    FStar_Syntax_Embeddings.e_tuple2
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Reflection_Embeddings.e_bv in
-                                                                    let uu___148
-                                                                    =
-                                                                    FStar_TypeChecker_NBETerm.e_tuple2
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_Reflection_NBEEmbeddings.e_bv in
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "push_bv_dsenv"
-                                                                    FStar_Tactics_Basic.push_bv_dsenv
-                                                                    FStar_Reflection_Embeddings.e_env
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    uu___147
-                                                                    FStar_Tactics_Basic.push_bv_dsenv
-                                                                    FStar_Reflection_NBEEmbeddings.e_env
-                                                                    FStar_TypeChecker_NBETerm.e_string
-                                                                    uu___148 in
-                                                                    let uu___147
-                                                                    =
-                                                                    let uu___148
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "term_to_string"
-                                                                    FStar_Tactics_Basic.term_to_string
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Tactics_Basic.term_to_string
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_string in
-                                                                    let uu___149
-                                                                    =
-                                                                    let uu___150
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_1
-                                                                    Prims.int_zero
-                                                                    "comp_to_string"
-                                                                    FStar_Tactics_Basic.comp_to_string
-                                                                    FStar_Reflection_Embeddings.e_comp
-                                                                    FStar_Syntax_Embeddings.e_string
-                                                                    FStar_Tactics_Basic.comp_to_string
-                                                                    FStar_Reflection_NBEEmbeddings.e_comp
-                                                                    FStar_TypeChecker_NBETerm.e_string in
-                                                                    let uu___151
-                                                                    =
-                                                                    let uu___152
-                                                                    =
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_2
-                                                                    Prims.int_zero
-                                                                    "term_eq_old"
-                                                                    FStar_Tactics_Basic.term_eq_old
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Reflection_Embeddings.e_term
-                                                                    FStar_Syntax_Embeddings.e_bool
-                                                                    FStar_Tactics_Basic.term_eq_old
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_Reflection_NBEEmbeddings.e_term
-                                                                    FStar_TypeChecker_NBETerm.e_bool in
-                                                                    let uu___154
-                                                                    =
-                                                                    let uu___155
-                                                                    =
-                                                                    let uu___156
-                                                                    =
-                                                                    e_tactic_thunk
-                                                                    FStar_Syntax_Embeddings.e_any in
-                                                                    let uu___157
-                                                                    =
-                                                                    e_tactic_nbe_thunk
-                                                                    FStar_TypeChecker_NBETerm.e_any in
-                                                                    FStar_Tactics_InterpFuns.mk_tac_step_3
-                                                                    Prims.int_one
-                                                                    "with_compat_pre_core"
-                                                                    (fun
-                                                                    uu___158
-                                                                    ->
-                                                                    FStar_Tactics_Basic.with_compat_pre_core)
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    FStar_Syntax_Embeddings.e_int
-                                                                    uu___156
-                                                                    FStar_Syntax_Embeddings.e_any
-                                                                    (fun
-                                                                    uu___158
-                                                                    ->
-                                                                    FStar_Tactics_Basic.with_compat_pre_core)
-                                                                    FStar_TypeChecker_NBETerm.e_any
-                                                                    FStar_TypeChecker_NBETerm.e_int
-                                                                    uu___157
-                                                                    FStar_TypeChecker_NBETerm.e_any in
-                                                                    [uu___155] in
-                                                                    uu___152
-                                                                    ::
-                                                                    uu___154 in
-                                                                    uu___150
-                                                                    ::
-                                                                    uu___151 in
-                                                                    uu___148
-                                                                    ::
-                                                                    uu___149 in
-                                                                    uu___146
-                                                                    ::
-                                                                    uu___147 in
-                                                                    uu___144
-                                                                    ::
-                                                                    uu___145 in
-                                                                    uu___142
-                                                                    ::
-                                                                    uu___143 in
-                                                                    uu___140
-                                                                    ::
-                                                                    uu___141 in
-                                                                    uu___138
-                                                                    ::
-                                                                    uu___139 in
-                                                                    uu___136
-                                                                    ::
-                                                                    uu___137 in
-                                                                    uu___134
-                                                                    ::
-                                                                    uu___135 in
-                                                                    uu___132
-                                                                    ::
-                                                                    uu___133 in
-                                                                    uu___130
-                                                                    ::
-                                                                    uu___131 in
-                                                                    uu___128
-                                                                    ::
-                                                                    uu___129 in
-                                                                    uu___126
-                                                                    ::
-                                                                    uu___127 in
-                                                                    uu___124
-                                                                    ::
-                                                                    uu___125 in
-                                                                    uu___122
-                                                                    ::
-                                                                    uu___123 in
-                                                                    uu___120
-                                                                    ::
-                                                                    uu___121 in
-                                                                    uu___118
-                                                                    ::
-                                                                    uu___119 in
-                                                                    uu___116
-                                                                    ::
-                                                                    uu___117 in
-                                                                    uu___114
-                                                                    ::
-                                                                    uu___115 in
-                                                                    uu___112
-                                                                    ::
-                                                                    uu___113 in
-                                                                    uu___110
-                                                                    ::
-                                                                    uu___111 in
-                                                                    uu___108
-                                                                    ::
-                                                                    uu___109 in
-                                                                    uu___106
-                                                                    ::
-                                                                    uu___107 in
-                                                                    uu___104
-                                                                    ::
-                                                                    uu___105 in
-                                                                    uu___102
-                                                                    ::
-                                                                    uu___103 in
-                                                                    uu___100
-                                                                    ::
-                                                                    uu___101 in
-                                                                    uu___98
-                                                                    ::
-                                                                    uu___99 in
-                                                                    uu___96
-                                                                    ::
-                                                                    uu___97 in
-                                                                    uu___94
-                                                                    ::
-                                                                    uu___95 in
-                                                                    uu___92
-                                                                    ::
-                                                                    uu___93 in
-                                                                    uu___90
-                                                                    ::
-                                                                    uu___91 in
-                                                                    uu___88
-                                                                    ::
-                                                                    uu___89 in
-                                                                    uu___86
-                                                                    ::
-                                                                    uu___87 in
-                                                                    uu___84
-                                                                    ::
-                                                                    uu___85 in
-                                                                    uu___82
-                                                                    ::
-                                                                    uu___83 in
-                                                                    uu___80
-                                                                    ::
-                                                                    uu___81 in
-                                                                    uu___78
-                                                                    ::
-                                                                    uu___79 in
-                                                                    uu___76
-                                                                    ::
-                                                                    uu___77 in
-                                                                    uu___74
-                                                                    ::
-                                                                    uu___75 in
-                                                                    uu___72
-                                                                    ::
-                                                                    uu___73 in
-                                                                    uu___70
-                                                                    ::
-                                                                    uu___71 in
-                                                                    uu___68
-                                                                    ::
-                                                                    uu___69 in
-                                                                    uu___66
-                                                                    ::
-                                                                    uu___67 in
-                                                                    uu___64
-                                                                    ::
-                                                                    uu___65 in
-                                                                  uu___62 ::
-                                                                    uu___63 in
-                                                                uu___60 ::
-                                                                  uu___61 in
-                                                              uu___58 ::
-                                                                uu___59 in
-                                                            uu___56 ::
-                                                              uu___57 in
-                                                          uu___54 :: uu___55 in
-                                                        uu___52 :: uu___53 in
-                                                      uu___50 :: uu___51 in
-                                                    uu___48 :: uu___49 in
-                                                  uu___46 :: uu___47 in
-                                                uu___44 :: uu___45 in
-                                              uu___42 :: uu___43 in
-                                            uu___40 :: uu___41 in
-                                          uu___38 :: uu___39 in
-                                        uu___36 :: uu___37 in
-                                      uu___34 :: uu___35 in
-                                    uu___32 :: uu___33 in
-                                  uu___30 :: uu___31 in
-                                uu___28 :: uu___29 in
-                              uu___26 :: uu___27 in
-                            uu___24 :: uu___25 in
-                          uu___22 :: uu___23 in
-                        uu___20 :: uu___21 in
-                      uu___18 :: uu___19 in
-                    uu___16 :: uu___17 in
-                  uu___14 :: uu___15 in
-                uu___12 :: uu___13 in
-              uu___10 :: uu___11 in
-            uu___8 :: uu___9 in
-          uu___6 :: uu___7 in
-        uu___4 :: uu___5 in
-      uu___2 :: uu___3 in
-    FStar_Compiler_Effect.op_Less_Bar
-      (fun uu___2 -> FStar_Pervasives_Native.Some uu___2) uu___1 in
-  FStar_Compiler_Effect.op_Colon_Equals __primitive_steps_ref uu___
-let unembed_tactic_1_alt :
-  'a 'r .
-    'a FStar_Syntax_Embeddings.embedding ->
-      'r FStar_Syntax_Embeddings.embedding ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Embeddings.norm_cb ->
-            ('a -> 'r FStar_Tactics_Monad.tac) FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun er ->
-      fun f ->
-        fun ncb ->
-          FStar_Pervasives_Native.Some
-            (fun x ->
-               let rng = FStar_Compiler_Range.dummyRange in
-               let x_tm = embed ea rng x ncb in
-               let app =
-                 let uu___ =
-                   let uu___1 = FStar_Syntax_Syntax.as_arg x_tm in [uu___1] in
-                 FStar_Syntax_Syntax.mk_Tm_app f uu___ rng in
-               unembed_tactic_0 er app ncb)
-let e_tactic_1_alt :
-  'a 'r .
-    'a FStar_Syntax_Embeddings.embedding ->
-      'r FStar_Syntax_Embeddings.embedding ->
-        ('a ->
-           FStar_Tactics_Types.proofstate -> 'r FStar_Tactics_Result.__result)
-          FStar_Syntax_Embeddings.embedding
-  =
-  fun ea ->
-    fun er ->
-      let em uu___ uu___1 uu___2 uu___3 =
-        failwith "Impossible: embedding tactic (1)?" in
-      let un t0 w n =
-        let uu___ = unembed_tactic_1_alt ea er t0 n in
-        match uu___ with
-        | FStar_Pervasives_Native.Some f ->
-            FStar_Pervasives_Native.Some
-              ((fun x -> let uu___1 = f x in FStar_Tactics_Monad.run uu___1))
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None in
-      let uu___ =
-        FStar_Syntax_Embeddings.term_as_fv FStar_Syntax_Syntax.t_unit in
-      FStar_Syntax_Embeddings.mk_emb em un uu___
-let (report_implicits :
-  FStar_Compiler_Range.range ->
-    FStar_TypeChecker_Rel.tagged_implicits -> unit)
-  =
-  fun rng ->
-    fun is ->
-      FStar_Compiler_Effect.op_Bar_Greater is
-        (FStar_Compiler_List.iter
-           (fun uu___1 ->
-              match uu___1 with
-              | (imp, tag) ->
-                  (match tag with
-                   | FStar_TypeChecker_Rel.Implicit_unresolved ->
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Syntax_Print.uvar_to_string
-                               (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Syntax_Util.ctx_uvar_typ
-                                 imp.FStar_TypeChecker_Common.imp_uvar in
-                             FStar_Syntax_Print.term_to_string uu___6 in
-                           FStar_Compiler_Util.format3
-                             "Tactic left uninstantiated unification variable %s of type %s (reason = \"%s\")"
-                             uu___4 uu___5
-                             imp.FStar_TypeChecker_Common.imp_reason in
-                         (FStar_Errors.Error_UninstantiatedUnificationVarInTactic,
-                           uu___3) in
-                       FStar_Errors.log_issue rng uu___2
-                   | FStar_TypeChecker_Rel.Implicit_checking_defers_univ_constraint
-                       ->
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Syntax_Print.uvar_to_string
-                               (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Syntax_Util.ctx_uvar_typ
-                                 imp.FStar_TypeChecker_Common.imp_uvar in
-                             FStar_Syntax_Print.term_to_string uu___6 in
-                           FStar_Compiler_Util.format3
-                             "Tactic left uninstantiated unification variable %s of type %s (reason = \"%s\")"
-                             uu___4 uu___5
-                             imp.FStar_TypeChecker_Common.imp_reason in
-                         (FStar_Errors.Error_UninstantiatedUnificationVarInTactic,
-                           uu___3) in
-                       FStar_Errors.log_issue rng uu___2
-                   | FStar_TypeChecker_Rel.Implicit_has_typing_guard 
-                       (tm, ty) ->
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Syntax_Print.uvar_to_string
-                               (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Syntax_Util.ctx_uvar_typ
-                                 imp.FStar_TypeChecker_Common.imp_uvar in
-                             FStar_Syntax_Print.term_to_string uu___6 in
-                           let uu___6 = FStar_Syntax_Print.term_to_string tm in
-                           let uu___7 = FStar_Syntax_Print.term_to_string ty in
-                           FStar_Compiler_Util.format4
-                             "Tactic solved goal %s of type %s to %s : %s, but it has a non-trivial typing guard. Use gather_or_solve_explicit_guards_for_resolved_goals to inspect and prove these goals"
-                             uu___4 uu___5 uu___6 uu___7 in
-                         (FStar_Errors.Error_UninstantiatedUnificationVarInTactic,
-                           uu___3) in
-                       FStar_Errors.log_issue rng uu___2)));
-      FStar_Errors.stop_if_err ()
-let run_tactic_on_ps' :
-  'a 'b .
-    FStar_Compiler_Range.range ->
-      FStar_Compiler_Range.range ->
-        Prims.bool ->
-          'a FStar_Syntax_Embeddings.embedding ->
-            'a ->
-              'b FStar_Syntax_Embeddings.embedding ->
-                FStar_Syntax_Syntax.term ->
-                  FStar_Tactics_Types.proofstate ->
-                    (FStar_Tactics_Types.goal Prims.list * 'b)
-  =
-  fun rng_call ->
-    fun rng_goal ->
-      fun background ->
-        fun e_arg ->
-          fun arg ->
-            fun e_res ->
-              fun tactic ->
-                fun ps ->
-                  let env = ps.FStar_Tactics_Types.main_context in
-                  (let uu___1 = FStar_Compiler_Effect.op_Bang tacdbg in
-                   if uu___1
-                   then
-                     let uu___2 = FStar_Syntax_Print.term_to_string tactic in
-                     FStar_Compiler_Util.print1
-                       "Typechecking tactic: (%s) {\n" uu___2
-                   else ());
-                  (let uu___1 =
-                     let uu___2 = FStar_Syntax_Embeddings.type_of e_arg in
-                     let uu___3 = FStar_Syntax_Embeddings.type_of e_res in
-                     FStar_TypeChecker_TcTerm.tc_tactic uu___2 uu___3 env
-                       tactic in
-                   match uu___1 with
-                   | (uu___2, uu___3, g) ->
-                       ((let uu___5 = FStar_Compiler_Effect.op_Bang tacdbg in
-                         if uu___5
-                         then FStar_Compiler_Util.print_string "}\n"
-                         else ());
-                        FStar_TypeChecker_Rel.force_trivial_guard env g;
-                        FStar_Errors.stop_if_err ();
-                        (let tau =
-                           unembed_tactic_1 e_arg e_res tactic
-                             FStar_Syntax_Embeddings.id_norm_cb in
-                         let res =
-                           let uu___7 =
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_TypeChecker_Env.current_module
-                                   ps.FStar_Tactics_Types.main_context in
-                               FStar_Ident.string_of_lid uu___9 in
-                             FStar_Pervasives_Native.Some uu___8 in
-                           FStar_Profiling.profile
-                             (fun uu___8 ->
-                                let uu___9 = tau arg in
-                                FStar_Tactics_Monad.run_safe uu___9 ps)
-                             uu___7 "FStar.Tactics.Interpreter.run_safe" in
-                         (let uu___8 = FStar_Compiler_Effect.op_Bang tacdbg in
-                          if uu___8
-                          then FStar_Compiler_Util.print_string "}\n"
-                          else ());
-                         (match res with
-                          | FStar_Tactics_Result.Success (ret, ps1) ->
-                              let remaining_smt_goals =
-                                FStar_Compiler_List.op_At
-                                  ps1.FStar_Tactics_Types.goals
-                                  ps1.FStar_Tactics_Types.smt_goals in
-                              (FStar_Compiler_List.iter
-                                 (fun g1 ->
-                                    FStar_Tactics_Basic.mark_goal_implicit_already_checked
-                                      g1;
-                                    (let uu___10 =
-                                       FStar_Tactics_Types.is_irrelevant g1 in
-                                     if uu___10
-                                     then
-                                       ((let uu___12 =
-                                           FStar_Compiler_Effect.op_Bang
-                                             tacdbg in
-                                         if uu___12
-                                         then
-                                           let uu___13 =
-                                             let uu___14 =
-                                               FStar_Tactics_Types.goal_witness
-                                                 g1 in
-                                             FStar_Syntax_Print.term_to_string
-                                               uu___14 in
-                                           FStar_Compiler_Util.print1
-                                             "Assigning irrelevant goal %s\n"
-                                             uu___13
-                                         else ());
-                                        (let uu___12 =
-                                           let uu___13 =
-                                             FStar_Tactics_Types.goal_env g1 in
-                                           let uu___14 =
-                                             FStar_Tactics_Types.goal_witness
-                                               g1 in
-                                           FStar_TypeChecker_Rel.teq_nosmt_force
-                                             uu___13 uu___14
-                                             FStar_Syntax_Util.exp_unit in
-                                         if uu___12
-                                         then ()
-                                         else
-                                           (let uu___14 =
-                                              let uu___15 =
-                                                let uu___16 =
-                                                  FStar_Tactics_Types.goal_witness
-                                                    g1 in
-                                                FStar_Syntax_Print.term_to_string
-                                                  uu___16 in
-                                              FStar_Compiler_Util.format1
-                                                "Irrelevant tactic witness does not unify with (): %s"
-                                                uu___15 in
-                                            failwith uu___14)))
-                                     else ())) remaining_smt_goals;
-                               (let uu___10 =
-                                  FStar_Compiler_Effect.op_Bang tacdbg in
-                                if uu___10
-                                then
-                                  let uu___11 =
-                                    (FStar_Common.string_of_list ())
-                                      (fun imp ->
-                                         FStar_Syntax_Print.ctx_uvar_to_string
-                                           imp.FStar_TypeChecker_Common.imp_uvar)
-                                      ps1.FStar_Tactics_Types.all_implicits in
-                                  FStar_Compiler_Util.print1
-                                    "About to check tactic implicits: %s\n"
-                                    uu___11
-                                else ());
-                               (let g1 =
-                                  {
-                                    FStar_TypeChecker_Common.guard_f =
-                                      (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.guard_f);
-                                    FStar_TypeChecker_Common.deferred_to_tac
-                                      =
-                                      (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.deferred_to_tac);
-                                    FStar_TypeChecker_Common.deferred =
-                                      (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.deferred);
-                                    FStar_TypeChecker_Common.univ_ineqs =
-                                      (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.univ_ineqs);
-                                    FStar_TypeChecker_Common.implicits =
-                                      (ps1.FStar_Tactics_Types.all_implicits)
-                                  } in
-                                let g2 =
-                                  FStar_TypeChecker_Rel.solve_deferred_constraints
-                                    env g1 in
-                                (let uu___11 =
-                                   FStar_Compiler_Effect.op_Bang tacdbg in
-                                 if uu___11
-                                 then
-                                   let uu___12 =
-                                     FStar_Compiler_Util.string_of_int
-                                       (FStar_Compiler_List.length
-                                          ps1.FStar_Tactics_Types.all_implicits) in
-                                   let uu___13 =
-                                     (FStar_Common.string_of_list ())
-                                       (fun imp ->
-                                          FStar_Syntax_Print.ctx_uvar_to_string
-                                            imp.FStar_TypeChecker_Common.imp_uvar)
-                                       ps1.FStar_Tactics_Types.all_implicits in
-                                   FStar_Compiler_Util.print2
-                                     "Checked %s implicits (1): %s\n" uu___12
-                                     uu___13
-                                 else ());
-                                (let tagged_implicits =
-                                   FStar_TypeChecker_Rel.resolve_implicits_tac
-                                     env g2 in
-                                 (let uu___12 =
-                                    FStar_Compiler_Effect.op_Bang tacdbg in
-                                  if uu___12
-                                  then
-                                    let uu___13 =
-                                      FStar_Compiler_Util.string_of_int
-                                        (FStar_Compiler_List.length
-                                           ps1.FStar_Tactics_Types.all_implicits) in
-                                    let uu___14 =
-                                      (FStar_Common.string_of_list ())
-                                        (fun imp ->
-                                           FStar_Syntax_Print.ctx_uvar_to_string
-                                             imp.FStar_TypeChecker_Common.imp_uvar)
-                                        ps1.FStar_Tactics_Types.all_implicits in
-                                    FStar_Compiler_Util.print2
-                                      "Checked %s implicits (2): %s\n"
-                                      uu___13 uu___14
-                                  else ());
-                                 report_implicits rng_goal tagged_implicits;
-                                 (let uu___14 =
-                                    FStar_Compiler_Effect.op_Bang tacdbg in
-                                  if uu___14
-                                  then
-                                    FStar_Tactics_Printing.do_dump_proofstate
-                                      ps1 "at the finish line"
-                                  else ());
-                                 ((FStar_Compiler_List.op_At
-                                     ps1.FStar_Tactics_Types.goals
-                                     ps1.FStar_Tactics_Types.smt_goals), ret))))
-                          | FStar_Tactics_Result.Failed (e, ps1) ->
-                              (FStar_Tactics_Printing.do_dump_proofstate ps1
-                                 "at the time of failure";
-                               (let texn_to_string e1 =
-                                  match e1 with
-                                  | FStar_Tactics_Common.TacticFailure s -> s
-                                  | FStar_Tactics_Common.EExn t ->
-                                      let uu___9 =
-                                        FStar_Syntax_Print.term_to_string t in
-                                      Prims.op_Hat "uncaught exception: "
-                                        uu___9
-                                  | e2 -> FStar_Compiler_Effect.raise e2 in
-                                let rng =
-                                  if background
-                                  then
-                                    match ps1.FStar_Tactics_Types.goals with
-                                    | g1::uu___9 ->
-                                        (g1.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_range
-                                    | uu___9 -> rng_call
-                                  else ps1.FStar_Tactics_Types.entry_range in
-                                let uu___9 =
-                                  let uu___10 =
-                                    let uu___11 = texn_to_string e in
-                                    FStar_Compiler_Util.format1
-                                      "user tactic failed: `%s`" uu___11 in
-                                  (FStar_Errors.Fatal_UserTacticFailure,
-                                    uu___10) in
-                                FStar_Errors.raise_error uu___9 rng))))))
-let run_tactic_on_ps :
-  'a 'b .
-    FStar_Compiler_Range.range ->
-      FStar_Compiler_Range.range ->
-        Prims.bool ->
-          'a FStar_Syntax_Embeddings.embedding ->
-            'a ->
-              'b FStar_Syntax_Embeddings.embedding ->
-                FStar_Syntax_Syntax.term ->
-                  FStar_Tactics_Types.proofstate ->
-                    (FStar_Tactics_Types.goal Prims.list * 'b)
-  =
-  fun rng_call ->
-    fun rng_goal ->
-      fun background ->
-        fun e_arg ->
-          fun arg ->
-            fun e_res ->
-              fun tactic ->
-                fun ps ->
-                  let uu___ =
-                    let uu___1 =
-                      let uu___2 =
-                        FStar_TypeChecker_Env.current_module
-                          ps.FStar_Tactics_Types.main_context in
-                      FStar_Ident.string_of_lid uu___2 in
-                    FStar_Pervasives_Native.Some uu___1 in
-                  FStar_Profiling.profile
-                    (fun uu___1 ->
-                       run_tactic_on_ps' rng_call rng_goal background e_arg
-                         arg e_res tactic ps) uu___
-                    "FStar.Tactics.Interpreter.run_tactic_on_ps"
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Monad.ml b/src/ocaml-output/FStar_Tactics_Monad.ml
deleted file mode 100644
index 6809592c322..00000000000
--- a/src/ocaml-output/FStar_Tactics_Monad.ml
+++ /dev/null
@@ -1,936 +0,0 @@
-open Prims
-let (goal_ctr : Prims.int FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref Prims.int_zero
-let (get_goal_ctr : unit -> Prims.int) =
-  fun uu___ -> FStar_Compiler_Effect.op_Bang goal_ctr
-let (incr_goal_ctr : unit -> Prims.int) =
-  fun uu___ ->
-    let v = FStar_Compiler_Effect.op_Bang goal_ctr in
-    FStar_Compiler_Effect.op_Colon_Equals goal_ctr (v + Prims.int_one); v
-let (is_goal_safe_as_well_typed : FStar_Tactics_Types.goal -> Prims.bool) =
-  fun g ->
-    let uv = g.FStar_Tactics_Types.goal_ctx_uvar in
-    let all_deps_resolved =
-      let uu___ = FStar_Syntax_Util.ctx_uvar_typedness_deps uv in
-      FStar_Compiler_List.for_all
-        (fun uv1 ->
-           let uu___1 =
-             FStar_Syntax_Unionfind.find
-               uv1.FStar_Syntax_Syntax.ctx_uvar_head in
-           match uu___1 with
-           | FStar_Pervasives_Native.Some t ->
-               let uu___2 = FStar_Syntax_Free.uvars t in
-               FStar_Compiler_Util.set_is_empty uu___2
-           | uu___2 -> false) uu___ in
-    all_deps_resolved
-let (register_goal : FStar_Tactics_Types.goal -> unit) =
-  fun g ->
-    let uu___ =
-      let uu___1 = FStar_Options.compat_pre_core_should_register () in
-      Prims.op_Negation uu___1 in
-    if uu___
-    then ()
-    else
-      (let env = FStar_Tactics_Types.goal_env g in
-       if env.FStar_TypeChecker_Env.phase1 || env.FStar_TypeChecker_Env.lax
-       then ()
-       else
-         (let uv = g.FStar_Tactics_Types.goal_ctx_uvar in
-          let i = FStar_TypeChecker_Core.incr_goal_ctr () in
-          let uu___3 =
-            let uu___4 =
-              FStar_Syntax_Util.ctx_uvar_should_check
-                g.FStar_Tactics_Types.goal_ctx_uvar in
-            FStar_Syntax_Syntax.uu___is_Allow_untyped uu___4 in
-          if uu___3
-          then ()
-          else
-            (let env1 =
-               {
-                 FStar_TypeChecker_Env.solver =
-                   (env.FStar_TypeChecker_Env.solver);
-                 FStar_TypeChecker_Env.range =
-                   (env.FStar_TypeChecker_Env.range);
-                 FStar_TypeChecker_Env.curmodule =
-                   (env.FStar_TypeChecker_Env.curmodule);
-                 FStar_TypeChecker_Env.gamma =
-                   (uv.FStar_Syntax_Syntax.ctx_uvar_gamma);
-                 FStar_TypeChecker_Env.gamma_sig =
-                   (env.FStar_TypeChecker_Env.gamma_sig);
-                 FStar_TypeChecker_Env.gamma_cache =
-                   (env.FStar_TypeChecker_Env.gamma_cache);
-                 FStar_TypeChecker_Env.modules =
-                   (env.FStar_TypeChecker_Env.modules);
-                 FStar_TypeChecker_Env.expected_typ =
-                   (env.FStar_TypeChecker_Env.expected_typ);
-                 FStar_TypeChecker_Env.sigtab =
-                   (env.FStar_TypeChecker_Env.sigtab);
-                 FStar_TypeChecker_Env.attrtab =
-                   (env.FStar_TypeChecker_Env.attrtab);
-                 FStar_TypeChecker_Env.instantiate_imp =
-                   (env.FStar_TypeChecker_Env.instantiate_imp);
-                 FStar_TypeChecker_Env.effects =
-                   (env.FStar_TypeChecker_Env.effects);
-                 FStar_TypeChecker_Env.generalize =
-                   (env.FStar_TypeChecker_Env.generalize);
-                 FStar_TypeChecker_Env.letrecs =
-                   (env.FStar_TypeChecker_Env.letrecs);
-                 FStar_TypeChecker_Env.top_level =
-                   (env.FStar_TypeChecker_Env.top_level);
-                 FStar_TypeChecker_Env.check_uvars =
-                   (env.FStar_TypeChecker_Env.check_uvars);
-                 FStar_TypeChecker_Env.use_eq_strict =
-                   (env.FStar_TypeChecker_Env.use_eq_strict);
-                 FStar_TypeChecker_Env.is_iface =
-                   (env.FStar_TypeChecker_Env.is_iface);
-                 FStar_TypeChecker_Env.admit =
-                   (env.FStar_TypeChecker_Env.admit);
-                 FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-                 FStar_TypeChecker_Env.lax_universes =
-                   (env.FStar_TypeChecker_Env.lax_universes);
-                 FStar_TypeChecker_Env.phase1 =
-                   (env.FStar_TypeChecker_Env.phase1);
-                 FStar_TypeChecker_Env.failhard =
-                   (env.FStar_TypeChecker_Env.failhard);
-                 FStar_TypeChecker_Env.nosynth =
-                   (env.FStar_TypeChecker_Env.nosynth);
-                 FStar_TypeChecker_Env.uvar_subtyping =
-                   (env.FStar_TypeChecker_Env.uvar_subtyping);
-                 FStar_TypeChecker_Env.tc_term =
-                   (env.FStar_TypeChecker_Env.tc_term);
-                 FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                   (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                 FStar_TypeChecker_Env.universe_of =
-                   (env.FStar_TypeChecker_Env.universe_of);
-                 FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                   (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                 FStar_TypeChecker_Env.teq_nosmt_force =
-                   (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                 FStar_TypeChecker_Env.subtype_nosmt_force =
-                   (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                 FStar_TypeChecker_Env.qtbl_name_and_index =
-                   (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                 FStar_TypeChecker_Env.normalized_eff_names =
-                   (env.FStar_TypeChecker_Env.normalized_eff_names);
-                 FStar_TypeChecker_Env.fv_delta_depths =
-                   (env.FStar_TypeChecker_Env.fv_delta_depths);
-                 FStar_TypeChecker_Env.proof_ns =
-                   (env.FStar_TypeChecker_Env.proof_ns);
-                 FStar_TypeChecker_Env.synth_hook =
-                   (env.FStar_TypeChecker_Env.synth_hook);
-                 FStar_TypeChecker_Env.try_solve_implicits_hook =
-                   (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                 FStar_TypeChecker_Env.splice =
-                   (env.FStar_TypeChecker_Env.splice);
-                 FStar_TypeChecker_Env.mpreprocess =
-                   (env.FStar_TypeChecker_Env.mpreprocess);
-                 FStar_TypeChecker_Env.postprocess =
-                   (env.FStar_TypeChecker_Env.postprocess);
-                 FStar_TypeChecker_Env.identifier_info =
-                   (env.FStar_TypeChecker_Env.identifier_info);
-                 FStar_TypeChecker_Env.tc_hooks =
-                   (env.FStar_TypeChecker_Env.tc_hooks);
-                 FStar_TypeChecker_Env.dsenv =
-                   (env.FStar_TypeChecker_Env.dsenv);
-                 FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-                 FStar_TypeChecker_Env.strict_args_tab =
-                   (env.FStar_TypeChecker_Env.strict_args_tab);
-                 FStar_TypeChecker_Env.erasable_types_tab =
-                   (env.FStar_TypeChecker_Env.erasable_types_tab);
-                 FStar_TypeChecker_Env.enable_defer_to_tac =
-                   (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                 FStar_TypeChecker_Env.unif_allow_ref_guards =
-                   (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                 FStar_TypeChecker_Env.erase_erasable_args =
-                   (env.FStar_TypeChecker_Env.erase_erasable_args);
-                 FStar_TypeChecker_Env.core_check =
-                   (env.FStar_TypeChecker_Env.core_check)
-               } in
-             (let uu___6 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug env1)
-                  (FStar_Options.Other "CoreEq") in
-              if uu___6
-              then
-                let uu___7 = FStar_Compiler_Util.string_of_int i in
-                FStar_Compiler_Util.print1 "(%s) Registering goal\n" uu___7
-              else ());
-             (let should_register = is_goal_safe_as_well_typed g in
-              if Prims.op_Negation should_register
-              then
-                let uu___7 =
-                  (FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_TypeChecker_Env.debug env1)
-                     (FStar_Options.Other "Core"))
-                    ||
-                    (FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_TypeChecker_Env.debug env1)
-                       (FStar_Options.Other "RegisterGoal")) in
-                (if uu___7
-                 then
-                   let uu___8 = FStar_Compiler_Util.string_of_int i in
-                   FStar_Compiler_Util.print1
-                     "(%s) Not registering goal since it has unresolved uvar deps\n"
-                     uu___8
-                 else ())
-              else
-                ((let uu___8 =
-                    (FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_TypeChecker_Env.debug env1)
-                       (FStar_Options.Other "Core"))
-                      ||
-                      (FStar_Compiler_Effect.op_Less_Bar
-                         (FStar_TypeChecker_Env.debug env1)
-                         (FStar_Options.Other "RegisterGoal")) in
-                  if uu___8
-                  then
-                    let uu___9 = FStar_Compiler_Util.string_of_int i in
-                    let uu___10 = FStar_Syntax_Print.ctx_uvar_to_string uv in
-                    FStar_Compiler_Util.print2
-                      "(%s) Registering goal for %s\n" uu___9 uu___10
-                  else ());
-                 (let goal_ty = FStar_Syntax_Util.ctx_uvar_typ uv in
-                  let uu___8 =
-                    FStar_TypeChecker_Core.compute_term_type_handle_guards
-                      env1 goal_ty false (fun uu___9 -> fun uu___10 -> true) in
-                  match uu___8 with
-                  | FStar_Pervasives.Inl uu___9 -> ()
-                  | FStar_Pervasives.Inr err ->
-                      let msg =
-                        let uu___9 =
-                          let uu___10 = FStar_Syntax_Util.ctx_uvar_typ uv in
-                          FStar_Syntax_Print.term_to_string uu___10 in
-                        let uu___10 =
-                          FStar_TypeChecker_Core.print_error_short err in
-                        FStar_Compiler_Util.format2
-                          "Failed to check initial tactic goal %s because %s"
-                          uu___9 uu___10 in
-                      FStar_Errors.log_issue
-                        uv.FStar_Syntax_Syntax.ctx_uvar_range
-                        (FStar_Errors.Warning_FailedToCheckInitialTacticGoal,
-                          msg)))))))
-type 'a tac =
-  {
-  tac_f: FStar_Tactics_Types.proofstate -> 'a FStar_Tactics_Result.__result }
-let __proj__Mktac__item__tac_f :
-  'a .
-    'a tac ->
-      FStar_Tactics_Types.proofstate -> 'a FStar_Tactics_Result.__result
-  = fun projectee -> match projectee with | { tac_f;_} -> tac_f
-let mk_tac :
-  'a .
-    (FStar_Tactics_Types.proofstate -> 'a FStar_Tactics_Result.__result) ->
-      'a tac
-  = fun f -> { tac_f = f }
-let run :
-  'a .
-    'a tac ->
-      FStar_Tactics_Types.proofstate -> 'a FStar_Tactics_Result.__result
-  = fun t -> fun ps -> t.tac_f ps
-let run_safe :
-  'a .
-    'a tac ->
-      FStar_Tactics_Types.proofstate -> 'a FStar_Tactics_Result.__result
-  =
-  fun t ->
-    fun ps ->
-      let uu___ = FStar_Options.tactics_failhard () in
-      if uu___
-      then run t ps
-      else
-        (try (fun uu___2 -> match () with | () -> run t ps) ()
-         with
-         | FStar_Errors.Err (uu___3, msg, uu___4) ->
-             FStar_Tactics_Result.Failed
-               ((FStar_Tactics_Common.TacticFailure msg), ps)
-         | FStar_Errors.Error (uu___3, msg, uu___4, uu___5) ->
-             FStar_Tactics_Result.Failed
-               ((FStar_Tactics_Common.TacticFailure msg), ps)
-         | e -> FStar_Tactics_Result.Failed (e, ps))
-let ret : 'a . 'a -> 'a tac =
-  fun x -> mk_tac (fun ps -> FStar_Tactics_Result.Success (x, ps))
-let bind : 'a 'b . 'a tac -> ('a -> 'b tac) -> 'b tac =
-  fun t1 ->
-    fun t2 ->
-      mk_tac
-        (fun ps ->
-           let uu___ = run t1 ps in
-           match uu___ with
-           | FStar_Tactics_Result.Success (a1, q) ->
-               let uu___1 = t2 a1 in run uu___1 q
-           | FStar_Tactics_Result.Failed (msg, q) ->
-               FStar_Tactics_Result.Failed (msg, q))
-let op_let_Bang : 'a 'b . 'a tac -> ('a -> 'b tac) -> 'b tac =
-  fun t1 -> fun t2 -> bind t1 t2
-let (idtac : unit tac) = ret ()
-let (set : FStar_Tactics_Types.proofstate -> unit tac) =
-  fun ps -> mk_tac (fun uu___ -> FStar_Tactics_Result.Success ((), ps))
-let (get : FStar_Tactics_Types.proofstate tac) =
-  mk_tac (fun ps -> FStar_Tactics_Result.Success (ps, ps))
-let traise : 'a . Prims.exn -> 'a tac =
-  fun e -> mk_tac (fun ps -> FStar_Tactics_Result.Failed (e, ps))
-let (log : FStar_Tactics_Types.proofstate -> (unit -> unit) -> unit) =
-  fun ps -> fun f -> if ps.FStar_Tactics_Types.tac_verb_dbg then f () else ()
-let fail : 'a . Prims.string -> 'a tac =
-  fun msg ->
-    mk_tac
-      (fun ps ->
-         (let uu___1 =
-            FStar_TypeChecker_Env.debug ps.FStar_Tactics_Types.main_context
-              (FStar_Options.Other "TacFail") in
-          if uu___1
-          then
-            FStar_Tactics_Printing.do_dump_proofstate ps
-              (Prims.op_Hat "TACTIC FAILING: " msg)
-          else ());
-         FStar_Tactics_Result.Failed
-           ((FStar_Tactics_Common.TacticFailure msg), ps))
-let catch : 'a . 'a tac -> (Prims.exn, 'a) FStar_Pervasives.either tac =
-  fun t ->
-    mk_tac
-      (fun ps ->
-         let tx = FStar_Syntax_Unionfind.new_transaction () in
-         let uu___ = run t ps in
-         match uu___ with
-         | FStar_Tactics_Result.Success (a1, q) ->
-             (FStar_Syntax_Unionfind.commit tx;
-              FStar_Tactics_Result.Success ((FStar_Pervasives.Inr a1), q))
-         | FStar_Tactics_Result.Failed (m, q) ->
-             (FStar_Syntax_Unionfind.rollback tx;
-              (let ps1 =
-                 {
-                   FStar_Tactics_Types.main_context =
-                     (ps.FStar_Tactics_Types.main_context);
-                   FStar_Tactics_Types.all_implicits =
-                     (ps.FStar_Tactics_Types.all_implicits);
-                   FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-                   FStar_Tactics_Types.smt_goals =
-                     (ps.FStar_Tactics_Types.smt_goals);
-                   FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-                   FStar_Tactics_Types.__dump =
-                     (ps.FStar_Tactics_Types.__dump);
-                   FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-                   FStar_Tactics_Types.entry_range =
-                     (ps.FStar_Tactics_Types.entry_range);
-                   FStar_Tactics_Types.guard_policy =
-                     (ps.FStar_Tactics_Types.guard_policy);
-                   FStar_Tactics_Types.freshness =
-                     (q.FStar_Tactics_Types.freshness);
-                   FStar_Tactics_Types.tac_verb_dbg =
-                     (ps.FStar_Tactics_Types.tac_verb_dbg);
-                   FStar_Tactics_Types.local_state =
-                     (ps.FStar_Tactics_Types.local_state);
-                   FStar_Tactics_Types.urgency =
-                     (ps.FStar_Tactics_Types.urgency)
-                 } in
-               FStar_Tactics_Result.Success ((FStar_Pervasives.Inl m), ps1))))
-let recover : 'a . 'a tac -> (Prims.exn, 'a) FStar_Pervasives.either tac =
-  fun t ->
-    mk_tac
-      (fun ps ->
-         let uu___ = run t ps in
-         match uu___ with
-         | FStar_Tactics_Result.Success (a1, q) ->
-             FStar_Tactics_Result.Success ((FStar_Pervasives.Inr a1), q)
-         | FStar_Tactics_Result.Failed (m, q) ->
-             FStar_Tactics_Result.Success ((FStar_Pervasives.Inl m), q))
-let trytac : 'a . 'a tac -> 'a FStar_Pervasives_Native.option tac =
-  fun t ->
-    let uu___ = catch t in
-    bind uu___
-      (fun r ->
-         match r with
-         | FStar_Pervasives.Inr v -> ret (FStar_Pervasives_Native.Some v)
-         | FStar_Pervasives.Inl uu___1 -> ret FStar_Pervasives_Native.None)
-let trytac_exn : 'a . 'a tac -> 'a FStar_Pervasives_Native.option tac =
-  fun t ->
-    mk_tac
-      (fun ps ->
-         try
-           (fun uu___ ->
-              match () with | () -> let uu___1 = trytac t in run uu___1 ps)
-             ()
-         with
-         | FStar_Errors.Err (uu___1, msg, uu___2) ->
-             (log ps
-                (fun uu___4 ->
-                   FStar_Compiler_Util.print1 "trytac_exn error: (%s)" msg);
-              FStar_Tactics_Result.Success (FStar_Pervasives_Native.None, ps))
-         | FStar_Errors.Error (uu___1, msg, uu___2, uu___3) ->
-             (log ps
-                (fun uu___5 ->
-                   FStar_Compiler_Util.print1 "trytac_exn error: (%s)" msg);
-              FStar_Tactics_Result.Success (FStar_Pervasives_Native.None, ps)))
-let rec mapM : 'a 'b . ('a -> 'b tac) -> 'a Prims.list -> 'b Prims.list tac =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> ret []
-      | x::xs ->
-          let uu___ = f x in
-          bind uu___
-            (fun y ->
-               let uu___1 = mapM f xs in
-               bind uu___1 (fun ys -> ret (y :: ys)))
-let rec iter_tac : 'a . ('a -> unit tac) -> 'a Prims.list -> unit tac =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> ret ()
-      | hd::tl ->
-          let uu___ = f hd in op_let_Bang uu___ (fun uu___1 -> iter_tac f tl)
-let (nwarn : Prims.int FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref Prims.int_zero
-let (check_valid_goal : FStar_Tactics_Types.goal -> unit) =
-  fun g ->
-    let uu___ = FStar_Options.defensive () in
-    if uu___
-    then
-      let b = true in
-      let env = FStar_Tactics_Types.goal_env g in
-      let b1 =
-        b &&
-          (let uu___1 = FStar_Tactics_Types.goal_witness g in
-           FStar_TypeChecker_Env.closed env uu___1) in
-      let b2 =
-        b1 &&
-          (let uu___1 = FStar_Tactics_Types.goal_type g in
-           FStar_TypeChecker_Env.closed env uu___1) in
-      let rec aux b3 e =
-        let uu___1 = FStar_TypeChecker_Env.pop_bv e in
-        match uu___1 with
-        | FStar_Pervasives_Native.None -> b3
-        | FStar_Pervasives_Native.Some (bv, e1) ->
-            let b4 =
-              b3 &&
-                (FStar_TypeChecker_Env.closed e1 bv.FStar_Syntax_Syntax.sort) in
-            aux b4 e1 in
-      let uu___1 =
-        (let uu___2 = aux b2 env in Prims.op_Negation uu___2) &&
-          (let uu___2 = FStar_Compiler_Effect.op_Bang nwarn in
-           uu___2 < (Prims.of_int (5))) in
-      (if uu___1
-       then
-         ((let uu___3 =
-             let uu___4 = FStar_Tactics_Types.goal_type g in
-             uu___4.FStar_Syntax_Syntax.pos in
-           let uu___4 =
-             let uu___5 =
-               let uu___6 = FStar_Tactics_Printing.goal_to_string_verbose g in
-               FStar_Compiler_Util.format1
-                 "The following goal is ill-formed. Keeping calm and carrying on...\n<%s>\n\n"
-                 uu___6 in
-             (FStar_Errors.Warning_IllFormedGoal, uu___5) in
-           FStar_Errors.log_issue uu___3 uu___4);
-          (let uu___3 =
-             let uu___4 = FStar_Compiler_Effect.op_Bang nwarn in
-             uu___4 + Prims.int_one in
-           FStar_Compiler_Effect.op_Colon_Equals nwarn uu___3))
-       else ())
-    else ()
-let (check_valid_goals : FStar_Tactics_Types.goal Prims.list -> unit) =
-  fun gs ->
-    let uu___ = FStar_Options.defensive () in
-    if uu___ then FStar_Compiler_List.iter check_valid_goal gs else ()
-let (set_goals : FStar_Tactics_Types.goal Prims.list -> unit tac) =
-  fun gs ->
-    bind get
-      (fun ps ->
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = gs;
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (set_smt_goals : FStar_Tactics_Types.goal Prims.list -> unit tac) =
-  fun gs ->
-    bind get
-      (fun ps ->
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals = gs;
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (cur_goals : FStar_Tactics_Types.goal Prims.list tac) =
-  bind get (fun ps -> ret ps.FStar_Tactics_Types.goals)
-let (cur_goal_maybe_solved : FStar_Tactics_Types.goal tac) =
-  bind cur_goals
-    (fun uu___ ->
-       match uu___ with | [] -> fail "No more goals" | hd::tl -> ret hd)
-let (cur_goal : FStar_Tactics_Types.goal tac) =
-  bind cur_goals
-    (fun uu___ ->
-       match uu___ with
-       | [] -> fail "No more goals"
-       | hd::tl ->
-           let uu___1 = FStar_Tactics_Types.check_goal_solved' hd in
-           (match uu___1 with
-            | FStar_Pervasives_Native.None -> ret hd
-            | FStar_Pervasives_Native.Some t ->
-                ((let uu___3 =
-                    FStar_Tactics_Printing.goal_to_string_verbose hd in
-                  let uu___4 = FStar_Syntax_Print.term_to_string t in
-                  FStar_Compiler_Util.print2
-                    "!!!!!!!!!!!! GOAL IS ALREADY SOLVED! %s\nsol is %s\n"
-                    uu___3 uu___4);
-                 ret hd)))
-let (remove_solved_goals : unit tac) =
-  bind cur_goals
-    (fun gs ->
-       let gs1 =
-         FStar_Compiler_List.filter
-           (fun g ->
-              let uu___ = FStar_Tactics_Types.check_goal_solved g in
-              Prims.op_Negation uu___) gs in
-       set_goals gs1)
-let (dismiss_all : unit tac) = set_goals []
-let (dismiss : unit tac) =
-  bind get
-    (fun ps ->
-       let uu___ =
-         let uu___1 = FStar_Compiler_List.tl ps.FStar_Tactics_Types.goals in
-         {
-           FStar_Tactics_Types.main_context =
-             (ps.FStar_Tactics_Types.main_context);
-           FStar_Tactics_Types.all_implicits =
-             (ps.FStar_Tactics_Types.all_implicits);
-           FStar_Tactics_Types.goals = uu___1;
-           FStar_Tactics_Types.smt_goals = (ps.FStar_Tactics_Types.smt_goals);
-           FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-           FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-           FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-           FStar_Tactics_Types.entry_range =
-             (ps.FStar_Tactics_Types.entry_range);
-           FStar_Tactics_Types.guard_policy =
-             (ps.FStar_Tactics_Types.guard_policy);
-           FStar_Tactics_Types.freshness = (ps.FStar_Tactics_Types.freshness);
-           FStar_Tactics_Types.tac_verb_dbg =
-             (ps.FStar_Tactics_Types.tac_verb_dbg);
-           FStar_Tactics_Types.local_state =
-             (ps.FStar_Tactics_Types.local_state);
-           FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-         } in
-       set uu___)
-let (replace_cur : FStar_Tactics_Types.goal -> unit tac) =
-  fun g ->
-    bind get
-      (fun ps ->
-         check_valid_goal g;
-         (let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_List.tl ps.FStar_Tactics_Types.goals in
-              g :: uu___3 in
-            {
-              FStar_Tactics_Types.main_context =
-                (ps.FStar_Tactics_Types.main_context);
-              FStar_Tactics_Types.all_implicits =
-                (ps.FStar_Tactics_Types.all_implicits);
-              FStar_Tactics_Types.goals = uu___2;
-              FStar_Tactics_Types.smt_goals =
-                (ps.FStar_Tactics_Types.smt_goals);
-              FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-              FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-              FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-              FStar_Tactics_Types.entry_range =
-                (ps.FStar_Tactics_Types.entry_range);
-              FStar_Tactics_Types.guard_policy =
-                (ps.FStar_Tactics_Types.guard_policy);
-              FStar_Tactics_Types.freshness =
-                (ps.FStar_Tactics_Types.freshness);
-              FStar_Tactics_Types.tac_verb_dbg =
-                (ps.FStar_Tactics_Types.tac_verb_dbg);
-              FStar_Tactics_Types.local_state =
-                (ps.FStar_Tactics_Types.local_state);
-              FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-            } in
-          set uu___1))
-let (getopts : FStar_Options.optionstate tac) =
-  let uu___ = trytac cur_goal_maybe_solved in
-  bind uu___
-    (fun uu___1 ->
-       match uu___1 with
-       | FStar_Pervasives_Native.Some g -> ret g.FStar_Tactics_Types.opts
-       | FStar_Pervasives_Native.None ->
-           let uu___2 = FStar_Options.peek () in ret uu___2)
-let (add_goals : FStar_Tactics_Types.goal Prims.list -> unit tac) =
-  fun gs ->
-    bind get
-      (fun ps ->
-         check_valid_goals gs;
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals =
-               (FStar_Compiler_List.op_At gs ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (add_smt_goals : FStar_Tactics_Types.goal Prims.list -> unit tac) =
-  fun gs ->
-    bind get
-      (fun ps ->
-         check_valid_goals gs;
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (FStar_Compiler_List.op_At gs ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (push_goals : FStar_Tactics_Types.goal Prims.list -> unit tac) =
-  fun gs ->
-    bind get
-      (fun ps ->
-         check_valid_goals gs;
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals =
-               (FStar_Compiler_List.op_At ps.FStar_Tactics_Types.goals gs);
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (push_smt_goals : FStar_Tactics_Types.goal Prims.list -> unit tac) =
-  fun gs ->
-    bind get
-      (fun ps ->
-         check_valid_goals gs;
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (FStar_Compiler_List.op_At ps.FStar_Tactics_Types.smt_goals gs);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (add_implicits : FStar_TypeChecker_Env.implicits -> unit tac) =
-  fun i ->
-    bind get
-      (fun ps ->
-         set
-           {
-             FStar_Tactics_Types.main_context =
-               (ps.FStar_Tactics_Types.main_context);
-             FStar_Tactics_Types.all_implicits =
-               (FStar_Compiler_List.op_At i
-                  ps.FStar_Tactics_Types.all_implicits);
-             FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-             FStar_Tactics_Types.smt_goals =
-               (ps.FStar_Tactics_Types.smt_goals);
-             FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-             FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-             FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-             FStar_Tactics_Types.entry_range =
-               (ps.FStar_Tactics_Types.entry_range);
-             FStar_Tactics_Types.guard_policy =
-               (ps.FStar_Tactics_Types.guard_policy);
-             FStar_Tactics_Types.freshness =
-               (ps.FStar_Tactics_Types.freshness);
-             FStar_Tactics_Types.tac_verb_dbg =
-               (ps.FStar_Tactics_Types.tac_verb_dbg);
-             FStar_Tactics_Types.local_state =
-               (ps.FStar_Tactics_Types.local_state);
-             FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-           })
-let (new_uvar :
-  Prims.string ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option
-          ->
-          FStar_Syntax_Syntax.ctx_uvar Prims.list ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.ctx_uvar) tac)
-  =
-  fun reason ->
-    fun env ->
-      fun typ ->
-        fun sc_opt ->
-          fun uvar_typedness_deps ->
-            fun rng ->
-              let should_check =
-                match sc_opt with
-                | FStar_Pervasives_Native.Some sc -> sc
-                | uu___ -> FStar_Syntax_Syntax.Strict in
-              let uu___ =
-                FStar_TypeChecker_Env.new_tac_implicit_var reason rng env typ
-                  should_check uvar_typedness_deps
-                  FStar_Pervasives_Native.None in
-              match uu___ with
-              | (u, ctx_uvar, g_u) ->
-                  let uu___1 =
-                    add_implicits g_u.FStar_TypeChecker_Common.implicits in
-                  bind uu___1
-                    (fun uu___2 ->
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 = FStar_Compiler_List.hd ctx_uvar in
-                           FStar_Pervasives_Native.fst uu___5 in
-                         (u, uu___4) in
-                       ret uu___3)
-let (mk_irrelevant_goal :
-  Prims.string ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option
-          ->
-          FStar_Compiler_Range.range ->
-            FStar_Options.optionstate ->
-              Prims.string -> FStar_Tactics_Types.goal tac)
-  =
-  fun reason ->
-    fun env ->
-      fun phi ->
-        fun sc_opt ->
-          fun rng ->
-            fun opts ->
-              fun label ->
-                let typ =
-                  let uu___ = env.FStar_TypeChecker_Env.universe_of env phi in
-                  FStar_Syntax_Util.mk_squash uu___ phi in
-                let uu___ = new_uvar reason env typ sc_opt [] rng in
-                bind uu___
-                  (fun uu___1 ->
-                     match uu___1 with
-                     | (uu___2, ctx_uvar) ->
-                         let goal =
-                           FStar_Tactics_Types.mk_goal env ctx_uvar opts
-                             false label in
-                         ret goal)
-let (add_irrelevant_goal' :
-  Prims.string ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option
-          ->
-          FStar_Compiler_Range.range ->
-            FStar_Options.optionstate -> Prims.string -> unit tac)
-  =
-  fun reason ->
-    fun env ->
-      fun phi ->
-        fun sc_opt ->
-          fun rng ->
-            fun opts ->
-              fun label ->
-                let uu___ =
-                  mk_irrelevant_goal reason env phi sc_opt rng opts label in
-                bind uu___ (fun goal -> add_goals [goal])
-let (add_irrelevant_goal :
-  FStar_Tactics_Types.goal ->
-    Prims.string ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.should_check_uvar
-            FStar_Pervasives_Native.option -> unit tac)
-  =
-  fun base_goal ->
-    fun reason ->
-      fun env ->
-        fun phi ->
-          fun sc_opt ->
-            add_irrelevant_goal' reason env phi sc_opt
-              (base_goal.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_range
-              base_goal.FStar_Tactics_Types.opts
-              base_goal.FStar_Tactics_Types.label
-let (goal_of_guard :
-  Prims.string ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option
-          -> FStar_Compiler_Range.range -> FStar_Tactics_Types.goal tac)
-  =
-  fun reason ->
-    fun e ->
-      fun f ->
-        fun sc_opt ->
-          fun rng ->
-            bind getopts
-              (fun opts ->
-                 let uu___ = mk_irrelevant_goal reason e f sc_opt rng opts "" in
-                 bind uu___
-                   (fun goal ->
-                      let goal1 =
-                        {
-                          FStar_Tactics_Types.goal_main_env =
-                            (goal.FStar_Tactics_Types.goal_main_env);
-                          FStar_Tactics_Types.goal_ctx_uvar =
-                            (goal.FStar_Tactics_Types.goal_ctx_uvar);
-                          FStar_Tactics_Types.opts =
-                            (goal.FStar_Tactics_Types.opts);
-                          FStar_Tactics_Types.is_guard = true;
-                          FStar_Tactics_Types.label =
-                            (goal.FStar_Tactics_Types.label)
-                        } in
-                      ret goal1))
-let wrap_err : 'a . Prims.string -> 'a tac -> 'a tac =
-  fun pref ->
-    fun t ->
-      mk_tac
-        (fun ps ->
-           let uu___ = run t ps in
-           match uu___ with
-           | FStar_Tactics_Result.Success (a1, q) ->
-               FStar_Tactics_Result.Success (a1, q)
-           | FStar_Tactics_Result.Failed
-               (FStar_Tactics_Common.TacticFailure msg, q) ->
-               FStar_Tactics_Result.Failed
-                 ((FStar_Tactics_Common.TacticFailure
-                     (Prims.op_Hat pref (Prims.op_Hat ": " msg))), q)
-           | FStar_Tactics_Result.Failed (e, q) ->
-               FStar_Tactics_Result.Failed (e, q))
-let mlog : 'a . (unit -> unit) -> (unit -> 'a tac) -> 'a tac =
-  fun f -> fun cont -> op_let_Bang get (fun ps -> log ps f; cont ())
-let (if_verbose_tac : (unit -> unit tac) -> unit tac) =
-  fun f ->
-    op_let_Bang get
-      (fun ps -> if ps.FStar_Tactics_Types.tac_verb_dbg then f () else ret ())
-let (if_verbose : (unit -> unit) -> unit tac) =
-  fun f -> if_verbose_tac (fun uu___ -> f (); ret ())
-let (compress_implicits : unit tac) =
-  bind get
-    (fun ps ->
-       let imps = ps.FStar_Tactics_Types.all_implicits in
-       let g =
-         {
-           FStar_TypeChecker_Common.guard_f =
-             (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.guard_f);
-           FStar_TypeChecker_Common.deferred_to_tac =
-             (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.deferred_to_tac);
-           FStar_TypeChecker_Common.deferred =
-             (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.deferred);
-           FStar_TypeChecker_Common.univ_ineqs =
-             (FStar_TypeChecker_Env.trivial_guard.FStar_TypeChecker_Common.univ_ineqs);
-           FStar_TypeChecker_Common.implicits = imps
-         } in
-       let imps1 =
-         FStar_TypeChecker_Rel.resolve_implicits_tac
-           ps.FStar_Tactics_Types.main_context g in
-       let ps' =
-         let uu___ =
-           FStar_Compiler_List.map FStar_Pervasives_Native.fst imps1 in
-         {
-           FStar_Tactics_Types.main_context =
-             (ps.FStar_Tactics_Types.main_context);
-           FStar_Tactics_Types.all_implicits = uu___;
-           FStar_Tactics_Types.goals = (ps.FStar_Tactics_Types.goals);
-           FStar_Tactics_Types.smt_goals = (ps.FStar_Tactics_Types.smt_goals);
-           FStar_Tactics_Types.depth = (ps.FStar_Tactics_Types.depth);
-           FStar_Tactics_Types.__dump = (ps.FStar_Tactics_Types.__dump);
-           FStar_Tactics_Types.psc = (ps.FStar_Tactics_Types.psc);
-           FStar_Tactics_Types.entry_range =
-             (ps.FStar_Tactics_Types.entry_range);
-           FStar_Tactics_Types.guard_policy =
-             (ps.FStar_Tactics_Types.guard_policy);
-           FStar_Tactics_Types.freshness = (ps.FStar_Tactics_Types.freshness);
-           FStar_Tactics_Types.tac_verb_dbg =
-             (ps.FStar_Tactics_Types.tac_verb_dbg);
-           FStar_Tactics_Types.local_state =
-             (ps.FStar_Tactics_Types.local_state);
-           FStar_Tactics_Types.urgency = (ps.FStar_Tactics_Types.urgency)
-         } in
-       set ps')
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Printing.ml b/src/ocaml-output/FStar_Tactics_Printing.ml
deleted file mode 100644
index e93f1a7aed8..00000000000
--- a/src/ocaml-output/FStar_Tactics_Printing.ml
+++ /dev/null
@@ -1,357 +0,0 @@
-open Prims
-let (term_to_string :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.string) =
-  fun e ->
-    fun t ->
-      FStar_Syntax_Print.term_to_string' e.FStar_TypeChecker_Env.dsenv t
-let (goal_to_string_verbose : FStar_Tactics_Types.goal -> Prims.string) =
-  fun g ->
-    let uu___ =
-      FStar_Syntax_Print.ctx_uvar_to_string
-        g.FStar_Tactics_Types.goal_ctx_uvar in
-    let uu___1 =
-      let uu___2 = FStar_Tactics_Types.check_goal_solved' g in
-      match uu___2 with
-      | FStar_Pervasives_Native.None -> ""
-      | FStar_Pervasives_Native.Some t ->
-          let uu___3 =
-            let uu___4 = FStar_Tactics_Types.goal_env g in
-            term_to_string uu___4 t in
-          FStar_Compiler_Util.format1 "\tGOAL ALREADY SOLVED!: %s" uu___3 in
-    FStar_Compiler_Util.format2 "%s%s\n" uu___ uu___1
-let (unshadow :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term))
-  =
-  fun bs ->
-    fun t ->
-      let s b = FStar_Ident.string_of_id b.FStar_Syntax_Syntax.ppname in
-      let sset bv s1 =
-        let uu___ =
-          let uu___1 = FStar_Ident.range_of_id bv.FStar_Syntax_Syntax.ppname in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Syntax_Syntax.gen_bv s1 uu___ bv.FStar_Syntax_Syntax.sort in
-      let fresh_until b f =
-        let rec aux i =
-          let t1 =
-            let uu___ =
-              let uu___1 = FStar_Compiler_Util.string_of_int i in
-              Prims.op_Hat "'" uu___1 in
-            Prims.op_Hat b uu___ in
-          let uu___ = f t1 in if uu___ then t1 else aux (i + Prims.int_one) in
-        let uu___ = f b in if uu___ then b else aux Prims.int_zero in
-      let rec go seen subst bs1 bs' t1 =
-        match bs1 with
-        | [] ->
-            let uu___ = FStar_Syntax_Subst.subst subst t1 in
-            ((FStar_Compiler_List.rev bs'), uu___)
-        | b::bs2 ->
-            let b1 =
-              let uu___ = FStar_Syntax_Subst.subst_binders subst [b] in
-              match uu___ with
-              | b2::[] -> b2
-              | uu___1 -> failwith "impossible: unshadow subst_binders" in
-            let uu___ =
-              ((b1.FStar_Syntax_Syntax.binder_bv),
-                (b1.FStar_Syntax_Syntax.binder_qual)) in
-            (match uu___ with
-             | (bv0, q) ->
-                 let nbs =
-                   let uu___1 = s bv0 in
-                   fresh_until uu___1
-                     (fun s1 ->
-                        Prims.op_Negation (FStar_Compiler_List.mem s1 seen)) in
-                 let bv = sset bv0 nbs in
-                 let b2 =
-                   FStar_Syntax_Syntax.mk_binder_with_attrs bv q
-                     b1.FStar_Syntax_Syntax.binder_attrs in
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 = FStar_Syntax_Syntax.bv_to_name bv in
-                         (bv0, uu___5) in
-                       FStar_Syntax_Syntax.NT uu___4 in
-                     [uu___3] in
-                   FStar_Compiler_List.op_At subst uu___2 in
-                 go (nbs :: seen) uu___1 bs2 (b2 :: bs') t1) in
-      go [] [] bs [] t
-let (goal_to_string :
-  Prims.string ->
-    (Prims.int * Prims.int) FStar_Pervasives_Native.option ->
-      FStar_Tactics_Types.proofstate ->
-        FStar_Tactics_Types.goal -> Prims.string)
-  =
-  fun kind ->
-    fun maybe_num ->
-      fun ps ->
-        fun g ->
-          let w =
-            let uu___ = FStar_Options.print_implicits () in
-            if uu___
-            then
-              let uu___1 = FStar_Tactics_Types.goal_env g in
-              let uu___2 = FStar_Tactics_Types.goal_witness g in
-              term_to_string uu___1 uu___2
-            else
-              (let uu___2 = FStar_Tactics_Types.check_goal_solved' g in
-               match uu___2 with
-               | FStar_Pervasives_Native.None -> "_"
-               | FStar_Pervasives_Native.Some t ->
-                   let uu___3 = FStar_Tactics_Types.goal_env g in
-                   let uu___4 = FStar_Tactics_Types.goal_witness g in
-                   term_to_string uu___3 uu___4) in
-          let num =
-            match maybe_num with
-            | FStar_Pervasives_Native.None -> ""
-            | FStar_Pervasives_Native.Some (i, n) ->
-                let uu___ = FStar_Compiler_Util.string_of_int i in
-                let uu___1 = FStar_Compiler_Util.string_of_int n in
-                FStar_Compiler_Util.format2 " %s/%s" uu___ uu___1 in
-          let maybe_label =
-            match g.FStar_Tactics_Types.label with
-            | "" -> ""
-            | l -> Prims.op_Hat " (" (Prims.op_Hat l ")") in
-          let uu___ =
-            let rename_binders subst bs =
-              FStar_Compiler_Effect.op_Bar_Greater bs
-                (FStar_Compiler_List.map
-                   (fun uu___1 ->
-                      let x = uu___1.FStar_Syntax_Syntax.binder_bv in
-                      let y =
-                        let uu___2 = FStar_Syntax_Syntax.bv_to_name x in
-                        FStar_Syntax_Subst.subst subst uu___2 in
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Subst.compress y in
-                        uu___3.FStar_Syntax_Syntax.n in
-                      match uu___2 with
-                      | FStar_Syntax_Syntax.Tm_name y1 ->
-                          let uu___3 =
-                            let uu___4 = uu___1.FStar_Syntax_Syntax.binder_bv in
-                            let uu___5 =
-                              FStar_Syntax_Subst.subst subst
-                                x.FStar_Syntax_Syntax.sort in
-                            {
-                              FStar_Syntax_Syntax.ppname =
-                                (uu___4.FStar_Syntax_Syntax.ppname);
-                              FStar_Syntax_Syntax.index =
-                                (uu___4.FStar_Syntax_Syntax.index);
-                              FStar_Syntax_Syntax.sort = uu___5
-                            } in
-                          {
-                            FStar_Syntax_Syntax.binder_bv = uu___3;
-                            FStar_Syntax_Syntax.binder_qual =
-                              (uu___1.FStar_Syntax_Syntax.binder_qual);
-                            FStar_Syntax_Syntax.binder_attrs =
-                              (uu___1.FStar_Syntax_Syntax.binder_attrs)
-                          }
-                      | uu___3 -> failwith "Not a renaming")) in
-            let goal_binders =
-              (g.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_binders in
-            let goal_ty = FStar_Tactics_Types.goal_type g in
-            let uu___1 = FStar_Options.tactic_raw_binders () in
-            if uu___1
-            then (goal_binders, goal_ty)
-            else
-              (let subst =
-                 FStar_TypeChecker_Cfg.psc_subst ps.FStar_Tactics_Types.psc in
-               let binders = rename_binders subst goal_binders in
-               let ty = FStar_Syntax_Subst.subst subst goal_ty in
-               (binders, ty)) in
-          match uu___ with
-          | (goal_binders, goal_ty) ->
-              let uu___1 = unshadow goal_binders goal_ty in
-              (match uu___1 with
-               | (goal_binders1, goal_ty1) ->
-                   let actual_goal =
-                     if ps.FStar_Tactics_Types.tac_verb_dbg
-                     then goal_to_string_verbose g
-                     else
-                       (let uu___3 =
-                          FStar_Syntax_Print.binders_to_string ", "
-                            goal_binders1 in
-                        let uu___4 =
-                          let uu___5 = FStar_Tactics_Types.goal_env g in
-                          term_to_string uu___5 goal_ty1 in
-                        FStar_Compiler_Util.format3 "%s |- %s : %s\n" uu___3
-                          w uu___4) in
-                   FStar_Compiler_Util.format4 "%s%s%s:\n%s\n" kind num
-                     maybe_label actual_goal)
-let (ps_to_string :
-  (Prims.string * FStar_Tactics_Types.proofstate) -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | (msg, ps) ->
-        let p_imp imp =
-          FStar_Syntax_Print.uvar_to_string
-            (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-        let n_active =
-          FStar_Compiler_List.length ps.FStar_Tactics_Types.goals in
-        let n_smt =
-          FStar_Compiler_List.length ps.FStar_Tactics_Types.smt_goals in
-        let n = n_active + n_smt in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_Util.string_of_int
-                  ps.FStar_Tactics_Types.depth in
-              FStar_Compiler_Util.format2 "State dump @ depth %s (%s):\n"
-                uu___4 msg in
-            let uu___4 =
-              let uu___5 =
-                if
-                  ps.FStar_Tactics_Types.entry_range <>
-                    FStar_Compiler_Range.dummyRange
-                then
-                  let uu___6 =
-                    FStar_Compiler_Range.string_of_def_range
-                      ps.FStar_Tactics_Types.entry_range in
-                  FStar_Compiler_Util.format1 "Location: %s\n" uu___6
-                else "" in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 =
-                    FStar_TypeChecker_Env.debug
-                      ps.FStar_Tactics_Types.main_context
-                      (FStar_Options.Other "Imp") in
-                  if uu___8
-                  then
-                    let uu___9 =
-                      (FStar_Common.string_of_list ()) p_imp
-                        ps.FStar_Tactics_Types.all_implicits in
-                    FStar_Compiler_Util.format1 "Imps: %s\n" uu___9
-                  else "" in
-                [uu___7] in
-              uu___5 :: uu___6 in
-            uu___3 :: uu___4 in
-          let uu___3 =
-            let uu___4 =
-              FStar_Compiler_List.mapi
-                (fun i ->
-                   fun g ->
-                     goal_to_string "Goal"
-                       (FStar_Pervasives_Native.Some ((Prims.int_one + i), n))
-                       ps g) ps.FStar_Tactics_Types.goals in
-            let uu___5 =
-              FStar_Compiler_List.mapi
-                (fun i ->
-                   fun g ->
-                     goal_to_string "SMT Goal"
-                       (FStar_Pervasives_Native.Some
-                          (((Prims.int_one + n_active) + i), n)) ps g)
-                ps.FStar_Tactics_Types.smt_goals in
-            FStar_Compiler_List.op_At uu___4 uu___5 in
-          FStar_Compiler_List.op_At uu___2 uu___3 in
-        FStar_String.concat "" uu___1
-let (goal_to_json : FStar_Tactics_Types.goal -> FStar_Compiler_Util.json) =
-  fun g ->
-    let g_binders =
-      (g.FStar_Tactics_Types.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_binders in
-    let g_type = FStar_Tactics_Types.goal_type g in
-    let uu___ = unshadow g_binders g_type in
-    match uu___ with
-    | (g_binders1, g_type1) ->
-        let j_binders =
-          let uu___1 =
-            let uu___2 = FStar_Tactics_Types.goal_env g in
-            FStar_TypeChecker_Env.dsenv uu___2 in
-          FStar_Syntax_Print.binders_to_json uu___1 g_binders1 in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 =
-                        let uu___9 = FStar_Tactics_Types.goal_env g in
-                        let uu___10 = FStar_Tactics_Types.goal_witness g in
-                        term_to_string uu___9 uu___10 in
-                      FStar_Compiler_Util.JsonStr uu___8 in
-                    ("witness", uu___7) in
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 =
-                        let uu___10 =
-                          let uu___11 = FStar_Tactics_Types.goal_env g in
-                          term_to_string uu___11 g_type1 in
-                        FStar_Compiler_Util.JsonStr uu___10 in
-                      ("type", uu___9) in
-                    [uu___8;
-                    ("label",
-                      (FStar_Compiler_Util.JsonStr
-                         (g.FStar_Tactics_Types.label)))] in
-                  uu___6 :: uu___7 in
-                FStar_Compiler_Util.JsonAssoc uu___5 in
-              ("goal", uu___4) in
-            [uu___3] in
-          ("hyps", j_binders) :: uu___2 in
-        FStar_Compiler_Util.JsonAssoc uu___1
-let (ps_to_json :
-  (Prims.string * FStar_Tactics_Types.proofstate) -> FStar_Compiler_Util.json)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (msg, ps) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 =
-                        FStar_Compiler_List.map goal_to_json
-                          ps.FStar_Tactics_Types.goals in
-                      FStar_Compiler_Util.JsonList uu___8 in
-                    ("goals", uu___7) in
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 =
-                        let uu___10 =
-                          FStar_Compiler_List.map goal_to_json
-                            ps.FStar_Tactics_Types.smt_goals in
-                        FStar_Compiler_Util.JsonList uu___10 in
-                      ("smt-goals", uu___9) in
-                    [uu___8] in
-                  uu___6 :: uu___7 in
-                ("urgency",
-                  (FStar_Compiler_Util.JsonInt
-                     (ps.FStar_Tactics_Types.urgency)))
-                  :: uu___5 in
-              ("depth",
-                (FStar_Compiler_Util.JsonInt (ps.FStar_Tactics_Types.depth)))
-                :: uu___4 in
-            ("label", (FStar_Compiler_Util.JsonStr msg)) :: uu___3 in
-          let uu___3 =
-            if
-              ps.FStar_Tactics_Types.entry_range <>
-                FStar_Compiler_Range.dummyRange
-            then
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_Range.json_of_def_range
-                    ps.FStar_Tactics_Types.entry_range in
-                ("location", uu___5) in
-              [uu___4]
-            else [] in
-          FStar_Compiler_List.op_At uu___2 uu___3 in
-        FStar_Compiler_Util.JsonAssoc uu___1
-let (do_dump_proofstate :
-  FStar_Tactics_Types.proofstate -> Prims.string -> unit) =
-  fun ps ->
-    fun msg ->
-      let uu___ =
-        let uu___1 = FStar_Options.silent () in Prims.op_Negation uu___1 in
-      if uu___
-      then
-        FStar_Options.with_saved_options
-          (fun uu___1 ->
-             FStar_Options.set_option "print_effect_args"
-               (FStar_Options.Bool true);
-             FStar_Compiler_Util.print_generic "proof-state" ps_to_string
-               ps_to_json (msg, ps);
-             FStar_Compiler_Util.flush_stdout ())
-      else ()
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Result.ml b/src/ocaml-output/FStar_Tactics_Result.ml
deleted file mode 100644
index af48a66891a..00000000000
--- a/src/ocaml-output/FStar_Tactics_Result.ml
+++ /dev/null
@@ -1,14 +0,0 @@
-open Prims
-type 'a __result =
-  | Success of ('a * FStar_Tactics_Types.proofstate) 
-  | Failed of (Prims.exn * FStar_Tactics_Types.proofstate) 
-let uu___is_Success : 'a . 'a __result -> Prims.bool =
-  fun projectee -> match projectee with | Success _0 -> true | uu___ -> false
-let __proj__Success__item___0 :
-  'a . 'a __result -> ('a * FStar_Tactics_Types.proofstate) =
-  fun projectee -> match projectee with | Success _0 -> _0
-let uu___is_Failed : 'a . 'a __result -> Prims.bool =
-  fun projectee -> match projectee with | Failed _0 -> true | uu___ -> false
-let __proj__Failed__item___0 :
-  'a . 'a __result -> (Prims.exn * FStar_Tactics_Types.proofstate) =
-  fun projectee -> match projectee with | Failed _0 -> _0
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tactics_Types.ml b/src/ocaml-output/FStar_Tactics_Types.ml
deleted file mode 100644
index 43cad2f6c75..00000000000
--- a/src/ocaml-output/FStar_Tactics_Types.ml
+++ /dev/null
@@ -1,466 +0,0 @@
-open Prims
-type goal =
-  {
-  goal_main_env: FStar_TypeChecker_Env.env ;
-  goal_ctx_uvar: FStar_Syntax_Syntax.ctx_uvar ;
-  opts: FStar_Options.optionstate ;
-  is_guard: Prims.bool ;
-  label: Prims.string }
-let (__proj__Mkgoal__item__goal_main_env : goal -> FStar_TypeChecker_Env.env)
-  =
-  fun projectee ->
-    match projectee with
-    | { goal_main_env; goal_ctx_uvar; opts; is_guard; label;_} ->
-        goal_main_env
-let (__proj__Mkgoal__item__goal_ctx_uvar :
-  goal -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun projectee ->
-    match projectee with
-    | { goal_main_env; goal_ctx_uvar; opts; is_guard; label;_} ->
-        goal_ctx_uvar
-let (__proj__Mkgoal__item__opts : goal -> FStar_Options.optionstate) =
-  fun projectee ->
-    match projectee with
-    | { goal_main_env; goal_ctx_uvar; opts; is_guard; label;_} -> opts
-let (__proj__Mkgoal__item__is_guard : goal -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { goal_main_env; goal_ctx_uvar; opts; is_guard; label;_} -> is_guard
-let (__proj__Mkgoal__item__label : goal -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { goal_main_env; goal_ctx_uvar; opts; is_guard; label;_} -> label
-type guard_policy =
-  | Goal 
-  | SMT 
-  | Force 
-  | Drop 
-let (uu___is_Goal : guard_policy -> Prims.bool) =
-  fun projectee -> match projectee with | Goal -> true | uu___ -> false
-let (uu___is_SMT : guard_policy -> Prims.bool) =
-  fun projectee -> match projectee with | SMT -> true | uu___ -> false
-let (uu___is_Force : guard_policy -> Prims.bool) =
-  fun projectee -> match projectee with | Force -> true | uu___ -> false
-let (uu___is_Drop : guard_policy -> Prims.bool) =
-  fun projectee -> match projectee with | Drop -> true | uu___ -> false
-type proofstate =
-  {
-  main_context: FStar_TypeChecker_Env.env ;
-  all_implicits: FStar_TypeChecker_Common.implicits ;
-  goals: goal Prims.list ;
-  smt_goals: goal Prims.list ;
-  depth: Prims.int ;
-  __dump: proofstate -> Prims.string -> unit ;
-  psc: FStar_TypeChecker_Cfg.psc ;
-  entry_range: FStar_Compiler_Range.range ;
-  guard_policy: guard_policy ;
-  freshness: Prims.int ;
-  tac_verb_dbg: Prims.bool ;
-  local_state: FStar_Syntax_Syntax.term FStar_Compiler_Util.psmap ;
-  urgency: Prims.int }
-let (__proj__Mkproofstate__item__main_context :
-  proofstate -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> main_context
-let (__proj__Mkproofstate__item__all_implicits :
-  proofstate -> FStar_TypeChecker_Common.implicits) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> all_implicits
-let (__proj__Mkproofstate__item__goals : proofstate -> goal Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> goals
-let (__proj__Mkproofstate__item__smt_goals : proofstate -> goal Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> smt_goals
-let (__proj__Mkproofstate__item__depth : proofstate -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> depth
-let (__proj__Mkproofstate__item____dump :
-  proofstate -> proofstate -> Prims.string -> unit) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> __dump
-let (__proj__Mkproofstate__item__psc :
-  proofstate -> FStar_TypeChecker_Cfg.psc) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> psc
-let (__proj__Mkproofstate__item__entry_range :
-  proofstate -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> entry_range
-let (__proj__Mkproofstate__item__guard_policy : proofstate -> guard_policy) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> guard_policy1
-let (__proj__Mkproofstate__item__freshness : proofstate -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> freshness
-let (__proj__Mkproofstate__item__tac_verb_dbg : proofstate -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> tac_verb_dbg
-let (__proj__Mkproofstate__item__local_state :
-  proofstate -> FStar_Syntax_Syntax.term FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> local_state
-let (__proj__Mkproofstate__item__urgency : proofstate -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { main_context; all_implicits; goals; smt_goals; depth; __dump; 
-        psc; entry_range; guard_policy = guard_policy1; freshness;
-        tac_verb_dbg; local_state; urgency;_} -> urgency
-let (goal_env : goal -> FStar_TypeChecker_Env.env) = fun g -> g.goal_main_env
-let (goal_witness : goal -> FStar_Syntax_Syntax.term) =
-  fun g ->
-    FStar_Syntax_Syntax.mk
-      (FStar_Syntax_Syntax.Tm_uvar
-         ((g.goal_ctx_uvar), ([], FStar_Syntax_Syntax.NoUseRange)))
-      FStar_Compiler_Range.dummyRange
-let (goal_type : goal -> FStar_Syntax_Syntax.term) =
-  fun g -> FStar_Syntax_Util.ctx_uvar_typ g.goal_ctx_uvar
-let (goal_with_env : goal -> FStar_TypeChecker_Env.env -> goal) =
-  fun g ->
-    fun env ->
-      let c = g.goal_ctx_uvar in
-      let c' =
-        let uu___ = FStar_TypeChecker_Env.all_binders env in
-        {
-          FStar_Syntax_Syntax.ctx_uvar_head =
-            (c.FStar_Syntax_Syntax.ctx_uvar_head);
-          FStar_Syntax_Syntax.ctx_uvar_gamma =
-            (env.FStar_TypeChecker_Env.gamma);
-          FStar_Syntax_Syntax.ctx_uvar_binders = uu___;
-          FStar_Syntax_Syntax.ctx_uvar_reason =
-            (c.FStar_Syntax_Syntax.ctx_uvar_reason);
-          FStar_Syntax_Syntax.ctx_uvar_range =
-            (c.FStar_Syntax_Syntax.ctx_uvar_range);
-          FStar_Syntax_Syntax.ctx_uvar_meta =
-            (c.FStar_Syntax_Syntax.ctx_uvar_meta)
-        } in
-      {
-        goal_main_env = env;
-        goal_ctx_uvar = c';
-        opts = (g.opts);
-        is_guard = (g.is_guard);
-        label = (g.label)
-      }
-let (goal_of_ctx_uvar : goal -> FStar_Syntax_Syntax.ctx_uvar -> goal) =
-  fun g ->
-    fun ctx_u ->
-      {
-        goal_main_env = (g.goal_main_env);
-        goal_ctx_uvar = ctx_u;
-        opts = (g.opts);
-        is_guard = (g.is_guard);
-        label = (g.label)
-      }
-let (mk_goal :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.ctx_uvar ->
-      FStar_Options.optionstate -> Prims.bool -> Prims.string -> goal)
-  =
-  fun env ->
-    fun u ->
-      fun o ->
-        fun b ->
-          fun l ->
-            {
-              goal_main_env = env;
-              goal_ctx_uvar = u;
-              opts = o;
-              is_guard = b;
-              label = l
-            }
-let (goal_of_goal_ty :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ -> (goal * FStar_TypeChecker_Common.guard_t))
-  =
-  fun env ->
-    fun typ ->
-      let uu___ =
-        FStar_TypeChecker_Env.new_implicit_var_aux "proofstate_of_goal_ty"
-          typ.FStar_Syntax_Syntax.pos env typ FStar_Syntax_Syntax.Strict
-          FStar_Pervasives_Native.None in
-      match uu___ with
-      | (u, ctx_uvars, g_u) ->
-          let uu___1 = FStar_Compiler_List.hd ctx_uvars in
-          (match uu___1 with
-           | (ctx_uvar, uu___2) ->
-               let g =
-                 let uu___3 = FStar_Options.peek () in
-                 mk_goal env ctx_uvar uu___3 false "" in
-               (g, g_u))
-let (goal_of_implicit :
-  FStar_TypeChecker_Env.env -> FStar_TypeChecker_Common.implicit -> goal) =
-  fun env ->
-    fun i ->
-      let uu___ = FStar_Options.peek () in
-      mk_goal
-        {
-          FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-          FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-          FStar_TypeChecker_Env.curmodule =
-            (env.FStar_TypeChecker_Env.curmodule);
-          FStar_TypeChecker_Env.gamma =
-            ((i.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_gamma);
-          FStar_TypeChecker_Env.gamma_sig =
-            (env.FStar_TypeChecker_Env.gamma_sig);
-          FStar_TypeChecker_Env.gamma_cache =
-            (env.FStar_TypeChecker_Env.gamma_cache);
-          FStar_TypeChecker_Env.modules = (env.FStar_TypeChecker_Env.modules);
-          FStar_TypeChecker_Env.expected_typ =
-            (env.FStar_TypeChecker_Env.expected_typ);
-          FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-          FStar_TypeChecker_Env.attrtab = (env.FStar_TypeChecker_Env.attrtab);
-          FStar_TypeChecker_Env.instantiate_imp =
-            (env.FStar_TypeChecker_Env.instantiate_imp);
-          FStar_TypeChecker_Env.effects = (env.FStar_TypeChecker_Env.effects);
-          FStar_TypeChecker_Env.generalize =
-            (env.FStar_TypeChecker_Env.generalize);
-          FStar_TypeChecker_Env.letrecs = (env.FStar_TypeChecker_Env.letrecs);
-          FStar_TypeChecker_Env.top_level =
-            (env.FStar_TypeChecker_Env.top_level);
-          FStar_TypeChecker_Env.check_uvars =
-            (env.FStar_TypeChecker_Env.check_uvars);
-          FStar_TypeChecker_Env.use_eq_strict =
-            (env.FStar_TypeChecker_Env.use_eq_strict);
-          FStar_TypeChecker_Env.is_iface =
-            (env.FStar_TypeChecker_Env.is_iface);
-          FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-          FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-          FStar_TypeChecker_Env.lax_universes =
-            (env.FStar_TypeChecker_Env.lax_universes);
-          FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-          FStar_TypeChecker_Env.failhard =
-            (env.FStar_TypeChecker_Env.failhard);
-          FStar_TypeChecker_Env.nosynth = (env.FStar_TypeChecker_Env.nosynth);
-          FStar_TypeChecker_Env.uvar_subtyping =
-            (env.FStar_TypeChecker_Env.uvar_subtyping);
-          FStar_TypeChecker_Env.tc_term = (env.FStar_TypeChecker_Env.tc_term);
-          FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-            (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-          FStar_TypeChecker_Env.universe_of =
-            (env.FStar_TypeChecker_Env.universe_of);
-          FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-            (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-          FStar_TypeChecker_Env.teq_nosmt_force =
-            (env.FStar_TypeChecker_Env.teq_nosmt_force);
-          FStar_TypeChecker_Env.subtype_nosmt_force =
-            (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-          FStar_TypeChecker_Env.qtbl_name_and_index =
-            (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-          FStar_TypeChecker_Env.normalized_eff_names =
-            (env.FStar_TypeChecker_Env.normalized_eff_names);
-          FStar_TypeChecker_Env.fv_delta_depths =
-            (env.FStar_TypeChecker_Env.fv_delta_depths);
-          FStar_TypeChecker_Env.proof_ns =
-            (env.FStar_TypeChecker_Env.proof_ns);
-          FStar_TypeChecker_Env.synth_hook =
-            (env.FStar_TypeChecker_Env.synth_hook);
-          FStar_TypeChecker_Env.try_solve_implicits_hook =
-            (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-          FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-          FStar_TypeChecker_Env.mpreprocess =
-            (env.FStar_TypeChecker_Env.mpreprocess);
-          FStar_TypeChecker_Env.postprocess =
-            (env.FStar_TypeChecker_Env.postprocess);
-          FStar_TypeChecker_Env.identifier_info =
-            (env.FStar_TypeChecker_Env.identifier_info);
-          FStar_TypeChecker_Env.tc_hooks =
-            (env.FStar_TypeChecker_Env.tc_hooks);
-          FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-          FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-          FStar_TypeChecker_Env.strict_args_tab =
-            (env.FStar_TypeChecker_Env.strict_args_tab);
-          FStar_TypeChecker_Env.erasable_types_tab =
-            (env.FStar_TypeChecker_Env.erasable_types_tab);
-          FStar_TypeChecker_Env.enable_defer_to_tac =
-            (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-          FStar_TypeChecker_Env.unif_allow_ref_guards =
-            (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-          FStar_TypeChecker_Env.erase_erasable_args =
-            (env.FStar_TypeChecker_Env.erase_erasable_args);
-          FStar_TypeChecker_Env.core_check =
-            (env.FStar_TypeChecker_Env.core_check)
-        } i.FStar_TypeChecker_Common.imp_uvar uu___ false
-        i.FStar_TypeChecker_Common.imp_reason
-let (decr_depth : proofstate -> proofstate) =
-  fun ps ->
-    {
-      main_context = (ps.main_context);
-      all_implicits = (ps.all_implicits);
-      goals = (ps.goals);
-      smt_goals = (ps.smt_goals);
-      depth = (ps.depth - Prims.int_one);
-      __dump = (ps.__dump);
-      psc = (ps.psc);
-      entry_range = (ps.entry_range);
-      guard_policy = (ps.guard_policy);
-      freshness = (ps.freshness);
-      tac_verb_dbg = (ps.tac_verb_dbg);
-      local_state = (ps.local_state);
-      urgency = (ps.urgency)
-    }
-let (incr_depth : proofstate -> proofstate) =
-  fun ps ->
-    {
-      main_context = (ps.main_context);
-      all_implicits = (ps.all_implicits);
-      goals = (ps.goals);
-      smt_goals = (ps.smt_goals);
-      depth = (ps.depth + Prims.int_one);
-      __dump = (ps.__dump);
-      psc = (ps.psc);
-      entry_range = (ps.entry_range);
-      guard_policy = (ps.guard_policy);
-      freshness = (ps.freshness);
-      tac_verb_dbg = (ps.tac_verb_dbg);
-      local_state = (ps.local_state);
-      urgency = (ps.urgency)
-    }
-let (set_ps_psc : FStar_TypeChecker_Cfg.psc -> proofstate -> proofstate) =
-  fun psc ->
-    fun ps ->
-      {
-        main_context = (ps.main_context);
-        all_implicits = (ps.all_implicits);
-        goals = (ps.goals);
-        smt_goals = (ps.smt_goals);
-        depth = (ps.depth);
-        __dump = (ps.__dump);
-        psc;
-        entry_range = (ps.entry_range);
-        guard_policy = (ps.guard_policy);
-        freshness = (ps.freshness);
-        tac_verb_dbg = (ps.tac_verb_dbg);
-        local_state = (ps.local_state);
-        urgency = (ps.urgency)
-      }
-let (tracepoint_with_psc :
-  FStar_TypeChecker_Cfg.psc -> proofstate -> Prims.bool) =
-  fun psc ->
-    fun ps ->
-      (let uu___1 =
-         (FStar_Options.tactic_trace ()) ||
-           (let uu___2 = FStar_Options.tactic_trace_d () in
-            ps.depth <= uu___2) in
-       if uu___1
-       then let ps1 = set_ps_psc psc ps in ps1.__dump ps1 "TRACE"
-       else ());
-      true
-let (tracepoint : proofstate -> Prims.bool) =
-  fun ps ->
-    (let uu___1 =
-       (FStar_Options.tactic_trace ()) ||
-         (let uu___2 = FStar_Options.tactic_trace_d () in ps.depth <= uu___2) in
-     if uu___1 then ps.__dump ps "TRACE" else ());
-    true
-let (set_proofstate_range :
-  proofstate -> FStar_Compiler_Range.range -> proofstate) =
-  fun ps ->
-    fun r ->
-      let uu___ =
-        let uu___1 = FStar_Compiler_Range.def_range r in
-        FStar_Compiler_Range.set_def_range ps.entry_range uu___1 in
-      {
-        main_context = (ps.main_context);
-        all_implicits = (ps.all_implicits);
-        goals = (ps.goals);
-        smt_goals = (ps.smt_goals);
-        depth = (ps.depth);
-        __dump = (ps.__dump);
-        psc = (ps.psc);
-        entry_range = uu___;
-        guard_policy = (ps.guard_policy);
-        freshness = (ps.freshness);
-        tac_verb_dbg = (ps.tac_verb_dbg);
-        local_state = (ps.local_state);
-        urgency = (ps.urgency)
-      }
-let (goals_of : proofstate -> goal Prims.list) = fun ps -> ps.goals
-let (smt_goals_of : proofstate -> goal Prims.list) = fun ps -> ps.smt_goals
-let (is_guard : goal -> Prims.bool) = fun g -> g.is_guard
-let (get_label : goal -> Prims.string) = fun g -> g.label
-let (set_label : Prims.string -> goal -> goal) =
-  fun l ->
-    fun g ->
-      {
-        goal_main_env = (g.goal_main_env);
-        goal_ctx_uvar = (g.goal_ctx_uvar);
-        opts = (g.opts);
-        is_guard = (g.is_guard);
-        label = l
-      }
-type ctrl_flag =
-  | Continue 
-  | Skip 
-  | Abort 
-let (uu___is_Continue : ctrl_flag -> Prims.bool) =
-  fun projectee -> match projectee with | Continue -> true | uu___ -> false
-let (uu___is_Skip : ctrl_flag -> Prims.bool) =
-  fun projectee -> match projectee with | Skip -> true | uu___ -> false
-let (uu___is_Abort : ctrl_flag -> Prims.bool) =
-  fun projectee -> match projectee with | Abort -> true | uu___ -> false
-type direction =
-  | TopDown 
-  | BottomUp 
-let (uu___is_TopDown : direction -> Prims.bool) =
-  fun projectee -> match projectee with | TopDown -> true | uu___ -> false
-let (uu___is_BottomUp : direction -> Prims.bool) =
-  fun projectee -> match projectee with | BottomUp -> true | uu___ -> false
-let (check_goal_solved' :
-  goal -> FStar_Syntax_Syntax.term FStar_Pervasives_Native.option) =
-  fun goal1 ->
-    let uu___ =
-      FStar_Syntax_Unionfind.find
-        (goal1.goal_ctx_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-    match uu___ with
-    | FStar_Pervasives_Native.Some t -> FStar_Pervasives_Native.Some t
-    | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (check_goal_solved : goal -> Prims.bool) =
-  fun goal1 ->
-    let uu___ = check_goal_solved' goal1 in
-    FStar_Compiler_Option.isSome uu___
-let (get_phi :
-  goal -> FStar_Syntax_Syntax.term FStar_Pervasives_Native.option) =
-  fun g ->
-    let uu___ =
-      let uu___1 = goal_env g in
-      let uu___2 = goal_type g in
-      FStar_TypeChecker_Normalize.unfold_whnf uu___1 uu___2 in
-    FStar_Syntax_Util.un_squash uu___
-let (is_irrelevant : goal -> Prims.bool) =
-  fun g -> let uu___ = get_phi g in FStar_Compiler_Option.isSome uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tests_Norm.ml b/src/ocaml-output/FStar_Tests_Norm.ml
deleted file mode 100644
index 92eb91db6e9..00000000000
--- a/src/ocaml-output/FStar_Tests_Norm.ml
+++ /dev/null
@@ -1,1461 +0,0 @@
-open Prims
-let (b : FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.binder) =
-  FStar_Syntax_Syntax.mk_binder
-let (id : FStar_Syntax_Syntax.term) = FStar_Tests_Pars.pars "fun x -> x"
-let (apply : FStar_Syntax_Syntax.term) =
-  FStar_Tests_Pars.pars "fun f x -> f x"
-let (twice : FStar_Syntax_Syntax.term) =
-  FStar_Tests_Pars.pars "fun f x -> f (f x)"
-let (tt : FStar_Syntax_Syntax.term) = FStar_Tests_Pars.pars "fun x y -> x"
-let (ff : FStar_Syntax_Syntax.term) = FStar_Tests_Pars.pars "fun x y -> y"
-let (z : FStar_Syntax_Syntax.term) = FStar_Tests_Pars.pars "fun f x -> x"
-let (one : FStar_Syntax_Syntax.term) = FStar_Tests_Pars.pars "fun f x -> f x"
-let (two : FStar_Syntax_Syntax.term) =
-  FStar_Tests_Pars.pars "fun f x -> f (f x)"
-let (succ : FStar_Syntax_Syntax.term) =
-  FStar_Tests_Pars.pars "fun n f x -> f (n f x)"
-let (pred : FStar_Syntax_Syntax.term) =
-  FStar_Tests_Pars.pars
-    "fun n f x -> n (fun g h -> h (g f)) (fun y -> x) (fun y -> y)"
-let (mul : FStar_Syntax_Syntax.term) =
-  FStar_Tests_Pars.pars "fun m n f -> m (n f)"
-let rec (encode : Prims.int -> FStar_Syntax_Syntax.term) =
-  fun n ->
-    if n = Prims.int_zero
-    then z
-    else
-      (let uu___1 = let uu___2 = encode (n - Prims.int_one) in [uu___2] in
-       FStar_Tests_Util.app succ uu___1)
-let (minus :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  = fun m -> fun n -> FStar_Tests_Util.app n [pred; m]
-let (let_ :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term)
-  =
-  fun x ->
-    fun e ->
-      fun e' ->
-        let uu___ =
-          let uu___1 = let uu___2 = b x in [uu___2] in
-          FStar_Syntax_Util.abs uu___1 e' FStar_Pervasives_Native.None in
-        FStar_Tests_Util.app uu___ [e]
-let (mk_let :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun x ->
-    fun e ->
-      fun e' ->
-        let e'1 =
-          FStar_Syntax_Subst.subst
-            [FStar_Syntax_Syntax.NM (x, Prims.int_zero)] e' in
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_let
-             ((false,
-                [{
-                   FStar_Syntax_Syntax.lbname = (FStar_Pervasives.Inl x);
-                   FStar_Syntax_Syntax.lbunivs = [];
-                   FStar_Syntax_Syntax.lbtyp = FStar_Syntax_Syntax.tun;
-                   FStar_Syntax_Syntax.lbeff =
-                     FStar_Parser_Const.effect_Tot_lid;
-                   FStar_Syntax_Syntax.lbdef = e;
-                   FStar_Syntax_Syntax.lbattrs = [];
-                   FStar_Syntax_Syntax.lbpos =
-                     FStar_Compiler_Range.dummyRange
-                 }]), e'1)) FStar_Compiler_Range.dummyRange
-let (lid : Prims.string -> FStar_Ident.lident) =
-  fun x ->
-    FStar_Ident.lid_of_path ["Test"; x] FStar_Compiler_Range.dummyRange
-let (znat_l : FStar_Syntax_Syntax.fv) =
-  let uu___ = lid "Z" in
-  FStar_Syntax_Syntax.lid_as_fv uu___ FStar_Syntax_Syntax.delta_constant
-    (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
-let (snat_l : FStar_Syntax_Syntax.fv) =
-  let uu___ = lid "S" in
-  FStar_Syntax_Syntax.lid_as_fv uu___ FStar_Syntax_Syntax.delta_constant
-    (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
-let (tm_fv :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun fv ->
-    FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv)
-      FStar_Compiler_Range.dummyRange
-let (znat : FStar_Syntax_Syntax.term) = tm_fv znat_l
-let (snat :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun s ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = tm_fv snat_l in
-        let uu___3 = let uu___4 = FStar_Syntax_Syntax.as_arg s in [uu___4] in
-        (uu___2, uu___3) in
-      FStar_Syntax_Syntax.Tm_app uu___1 in
-    FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let pat : 'uuuuu . 'uuuuu -> 'uuuuu FStar_Syntax_Syntax.withinfo_t =
-  fun p -> FStar_Syntax_Syntax.withinfo p FStar_Compiler_Range.dummyRange
-let (snat_type : FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax) =
-  let uu___ =
-    let uu___1 = lid "snat" in
-    FStar_Syntax_Syntax.lid_as_fv uu___1 FStar_Syntax_Syntax.delta_constant
-      FStar_Pervasives_Native.None in
-  tm_fv uu___
-let (mk_match :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.branch Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun h ->
-    fun branches ->
-      let branches1 =
-        FStar_Compiler_Effect.op_Bar_Greater branches
-          (FStar_Compiler_List.map FStar_Syntax_Util.branch) in
-      FStar_Syntax_Syntax.mk
-        (FStar_Syntax_Syntax.Tm_match
-           (h, FStar_Pervasives_Native.None, branches1,
-             FStar_Pervasives_Native.None)) FStar_Compiler_Range.dummyRange
-let (pred_nat :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun s ->
-    let zbranch =
-      let uu___ =
-        pat
-          (FStar_Syntax_Syntax.Pat_cons
-             (znat_l, FStar_Pervasives_Native.None, [])) in
-      (uu___, FStar_Pervasives_Native.None, znat) in
-    let sbranch =
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  pat (FStar_Syntax_Syntax.Pat_var FStar_Tests_Util.x) in
-                (uu___5, false) in
-              [uu___4] in
-            (snat_l, FStar_Pervasives_Native.None, uu___3) in
-          FStar_Syntax_Syntax.Pat_cons uu___2 in
-        pat uu___1 in
-      let uu___1 =
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_bvar
-             {
-               FStar_Syntax_Syntax.ppname =
-                 (FStar_Tests_Util.x.FStar_Syntax_Syntax.ppname);
-               FStar_Syntax_Syntax.index = Prims.int_zero;
-               FStar_Syntax_Syntax.sort =
-                 (FStar_Tests_Util.x.FStar_Syntax_Syntax.sort)
-             }) FStar_Compiler_Range.dummyRange in
-      (uu___, FStar_Pervasives_Native.None, uu___1) in
-    mk_match s [zbranch; sbranch]
-let (minus_nat :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t1 ->
-    fun t2 ->
-      let minus1 = FStar_Tests_Util.m in
-      let x =
-        {
-          FStar_Syntax_Syntax.ppname =
-            (FStar_Tests_Util.x.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index =
-            (FStar_Tests_Util.x.FStar_Syntax_Syntax.index);
-          FStar_Syntax_Syntax.sort = snat_type
-        } in
-      let y =
-        {
-          FStar_Syntax_Syntax.ppname =
-            (FStar_Tests_Util.y.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index =
-            (FStar_Tests_Util.y.FStar_Syntax_Syntax.index);
-          FStar_Syntax_Syntax.sort = snat_type
-        } in
-      let zbranch =
-        let uu___ =
-          pat
-            (FStar_Syntax_Syntax.Pat_cons
-               (znat_l, FStar_Pervasives_Native.None, [])) in
-        let uu___1 = FStar_Tests_Util.nm x in
-        (uu___, FStar_Pervasives_Native.None, uu___1) in
-      let sbranch =
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    pat (FStar_Syntax_Syntax.Pat_var FStar_Tests_Util.n) in
-                  (uu___5, false) in
-                [uu___4] in
-              (snat_l, FStar_Pervasives_Native.None, uu___3) in
-            FStar_Syntax_Syntax.Pat_cons uu___2 in
-          pat uu___1 in
-        let uu___1 =
-          let uu___2 = FStar_Tests_Util.nm minus1 in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Tests_Util.nm x in pred_nat uu___5 in
-            let uu___5 =
-              let uu___6 = FStar_Tests_Util.nm FStar_Tests_Util.n in [uu___6] in
-            uu___4 :: uu___5 in
-          FStar_Tests_Util.app uu___2 uu___3 in
-        (uu___, FStar_Pervasives_Native.None, uu___1) in
-      let lb =
-        let uu___ =
-          FStar_Ident.lid_of_path ["Pure"] FStar_Compiler_Range.dummyRange in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = b x in
-              let uu___5 = let uu___6 = b y in [uu___6] in uu___4 :: uu___5 in
-            let uu___4 =
-              let uu___5 = FStar_Tests_Util.nm y in
-              mk_match uu___5 [zbranch; sbranch] in
-            FStar_Syntax_Util.abs uu___3 uu___4 FStar_Pervasives_Native.None in
-          FStar_Syntax_Subst.subst
-            [FStar_Syntax_Syntax.NM (minus1, Prims.int_zero)] uu___2 in
-        {
-          FStar_Syntax_Syntax.lbname = (FStar_Pervasives.Inl minus1);
-          FStar_Syntax_Syntax.lbunivs = [];
-          FStar_Syntax_Syntax.lbtyp = FStar_Syntax_Syntax.tun;
-          FStar_Syntax_Syntax.lbeff = uu___;
-          FStar_Syntax_Syntax.lbdef = uu___1;
-          FStar_Syntax_Syntax.lbattrs = [];
-          FStar_Syntax_Syntax.lbpos = FStar_Compiler_Range.dummyRange
-        } in
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Tests_Util.nm minus1 in
-              FStar_Tests_Util.app uu___4 [t1; t2] in
-            FStar_Syntax_Subst.subst
-              [FStar_Syntax_Syntax.NM (minus1, Prims.int_zero)] uu___3 in
-          ((true, [lb]), uu___2) in
-        FStar_Syntax_Syntax.Tm_let uu___1 in
-      FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (encode_nat : Prims.int -> FStar_Syntax_Syntax.term) =
-  fun n ->
-    let rec aux out n1 =
-      if n1 = Prims.int_zero
-      then out
-      else (let uu___1 = snat out in aux uu___1 (n1 - Prims.int_one)) in
-    aux znat n
-let (default_tests :
-  (Prims.int * FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax) Prims.list)
-  =
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let rec copy (x:list int) : Tot (list int) = match x with | [] -> []  | hd::tl -> hd::copy tl";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let recons (x:list 'a) : Tot (list 'a) = match x with | [] -> []  | hd::tl -> hd::tl";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let rev (x:list 'a) : Tot (list 'a) = let rec aux (x:list 'a) (out:list 'a) : Tot (list 'a) = match x with | [] -> out | hd::tl -> aux tl (hd::out) in aux x []";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "type t = | A : int -> int -> t | B : int -> int -> t let f = function | A x y | B y x -> y - x";
-  FStar_Tests_Pars.pars_and_tc_fragment "type snat = | Z | S : snat -> snat";
-  FStar_Tests_Pars.pars_and_tc_fragment "type tb = | T | F";
-  FStar_Tests_Pars.pars_and_tc_fragment "type rb = | A1 | A2 | A3";
-  FStar_Tests_Pars.pars_and_tc_fragment "type hb = | H : tb -> hb";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let select (i:tb) (x:'a) (y:'a) : Tot 'a = match i with | T -> x | F -> y";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let select_int3 (i:int) (x:'a) (y:'a) (z:'a) : Tot 'a = match i with | 0 -> x | 1 -> y | _ -> z";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let select_bool (b:bool) (x:'a) (y:'a) : Tot 'a = if b then x else y";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let select_string3 (s:string) (x:'a) (y:'a) (z:'a) : Tot 'a = match s with | \"abc\" -> x | \"def\" -> y | _ -> z";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let recons_m (x:list tb) = match x with | [] -> []  | hd::tl -> hd::tl";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let rec copy_tb_list_2 (x:list tb) : Tot (list tb) = match x with | [] -> []  | [hd] -> [hd]\n                                          | hd1::hd2::tl -> hd1::hd2::copy_tb_list_2 tl";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let rec copy_list_2 (x:list 'a) : Tot (list 'a) = match x with | [] -> []  | [hd] -> [hd]\n                                          | hd1::hd2::tl -> hd1::hd2::copy_list_2 tl";
-  FStar_Tests_Pars.pars_and_tc_fragment "let (x1:int{x1>3}) = 6";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let (x2:int{x2+1>3 /\\ not (x2-5>0)}) = 2";
-  FStar_Tests_Pars.pars_and_tc_fragment "let my_plus (x:int) (y:int) = x + y";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let (x3:int{forall (a:nat). a > x2}) = 7";
-  FStar_Tests_Pars.pars_and_tc_fragment "let idd (x: 'a) = x";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "let revtb (x: tb) = match x with | T -> F | F -> T";
-  FStar_Tests_Pars.pars_and_tc_fragment "let id_tb (x: tb) = x";
-  FStar_Tests_Pars.pars_and_tc_fragment "let fst_a (x: 'a) (y: 'a) = x";
-  FStar_Tests_Pars.pars_and_tc_fragment "let id_list (x: list 'a) = x";
-  FStar_Tests_Pars.pars_and_tc_fragment "let id_list_m (x: list tb) = x";
-  (let uu___25 =
-     let uu___26 =
-       let uu___27 =
-         let uu___28 =
-           let uu___29 =
-             let uu___30 = FStar_Tests_Util.nm FStar_Tests_Util.n in
-             [uu___30] in
-           id :: uu___29 in
-         one :: uu___28 in
-       FStar_Tests_Util.app apply uu___27 in
-     let uu___27 = FStar_Tests_Util.nm FStar_Tests_Util.n in
-     (Prims.int_zero, uu___26, uu___27) in
-   let uu___26 =
-     let uu___27 =
-       let uu___28 =
-         let uu___29 =
-           let uu___30 = FStar_Tests_Util.nm FStar_Tests_Util.x in [uu___30] in
-         FStar_Tests_Util.app id uu___29 in
-       let uu___29 = FStar_Tests_Util.nm FStar_Tests_Util.x in
-       (Prims.int_one, uu___28, uu___29) in
-     let uu___28 =
-       let uu___29 =
-         let uu___30 =
-           let uu___31 =
-             let uu___32 =
-               let uu___33 = FStar_Tests_Util.nm FStar_Tests_Util.n in
-               let uu___34 =
-                 let uu___35 = FStar_Tests_Util.nm FStar_Tests_Util.m in
-                 [uu___35] in
-               uu___33 :: uu___34 in
-             tt :: uu___32 in
-           FStar_Tests_Util.app apply uu___31 in
-         let uu___31 = FStar_Tests_Util.nm FStar_Tests_Util.n in
-         (Prims.int_one, uu___30, uu___31) in
-       let uu___30 =
-         let uu___31 =
-           let uu___32 =
-             let uu___33 =
-               let uu___34 =
-                 let uu___35 = FStar_Tests_Util.nm FStar_Tests_Util.n in
-                 let uu___36 =
-                   let uu___37 = FStar_Tests_Util.nm FStar_Tests_Util.m in
-                   [uu___37] in
-                 uu___35 :: uu___36 in
-               ff :: uu___34 in
-             FStar_Tests_Util.app apply uu___33 in
-           let uu___33 = FStar_Tests_Util.nm FStar_Tests_Util.m in
-           ((Prims.of_int (2)), uu___32, uu___33) in
-         let uu___32 =
-           let uu___33 =
-             let uu___34 =
-               let uu___35 =
-                 let uu___36 =
-                   let uu___37 =
-                     let uu___38 =
-                       let uu___39 =
-                         let uu___40 =
-                           let uu___41 =
-                             let uu___42 =
-                               FStar_Tests_Util.nm FStar_Tests_Util.n in
-                             let uu___43 =
-                               let uu___44 =
-                                 FStar_Tests_Util.nm FStar_Tests_Util.m in
-                               [uu___44] in
-                             uu___42 :: uu___43 in
-                           ff :: uu___41 in
-                         apply :: uu___40 in
-                       apply :: uu___39 in
-                     apply :: uu___38 in
-                   apply :: uu___37 in
-                 apply :: uu___36 in
-               FStar_Tests_Util.app apply uu___35 in
-             let uu___35 = FStar_Tests_Util.nm FStar_Tests_Util.m in
-             ((Prims.of_int (3)), uu___34, uu___35) in
-           let uu___34 =
-             let uu___35 =
-               let uu___36 =
-                 let uu___37 =
-                   let uu___38 =
-                     let uu___39 =
-                       let uu___40 = FStar_Tests_Util.nm FStar_Tests_Util.n in
-                       let uu___41 =
-                         let uu___42 = FStar_Tests_Util.nm FStar_Tests_Util.m in
-                         [uu___42] in
-                       uu___40 :: uu___41 in
-                     ff :: uu___39 in
-                   apply :: uu___38 in
-                 FStar_Tests_Util.app twice uu___37 in
-               let uu___37 = FStar_Tests_Util.nm FStar_Tests_Util.m in
-               ((Prims.of_int (4)), uu___36, uu___37) in
-             let uu___36 =
-               let uu___37 =
-                 let uu___38 = minus one z in
-                 ((Prims.of_int (5)), uu___38, one) in
-               let uu___38 =
-                 let uu___39 =
-                   let uu___40 = FStar_Tests_Util.app pred [one] in
-                   ((Prims.of_int (6)), uu___40, z) in
-                 let uu___40 =
-                   let uu___41 =
-                     let uu___42 = minus one one in
-                     ((Prims.of_int (7)), uu___42, z) in
-                   let uu___42 =
-                     let uu___43 =
-                       let uu___44 = FStar_Tests_Util.app mul [one; one] in
-                       ((Prims.of_int (8)), uu___44, one) in
-                     let uu___44 =
-                       let uu___45 =
-                         let uu___46 = FStar_Tests_Util.app mul [two; one] in
-                         ((Prims.of_int (9)), uu___46, two) in
-                       let uu___46 =
-                         let uu___47 =
-                           let uu___48 =
-                             let uu___49 =
-                               let uu___50 = FStar_Tests_Util.app succ [one] in
-                               [uu___50; one] in
-                             FStar_Tests_Util.app mul uu___49 in
-                           ((Prims.of_int (10)), uu___48, two) in
-                         let uu___48 =
-                           let uu___49 =
-                             let uu___50 =
-                               let uu___51 = encode (Prims.of_int (10)) in
-                               let uu___52 = encode (Prims.of_int (10)) in
-                               minus uu___51 uu___52 in
-                             ((Prims.of_int (11)), uu___50, z) in
-                           let uu___50 =
-                             let uu___51 =
-                               let uu___52 =
-                                 let uu___53 = encode (Prims.of_int (100)) in
-                                 let uu___54 = encode (Prims.of_int (100)) in
-                                 minus uu___53 uu___54 in
-                               ((Prims.of_int (12)), uu___52, z) in
-                             let uu___52 =
-                               let uu___53 =
-                                 let uu___54 =
-                                   let uu___55 = encode (Prims.of_int (100)) in
-                                   let uu___56 =
-                                     let uu___57 =
-                                       FStar_Tests_Util.nm FStar_Tests_Util.x in
-                                     let uu___58 =
-                                       FStar_Tests_Util.nm FStar_Tests_Util.x in
-                                     minus uu___57 uu___58 in
-                                   let_ FStar_Tests_Util.x uu___55 uu___56 in
-                                 ((Prims.of_int (13)), uu___54, z) in
-                               let uu___54 =
-                                 let uu___55 =
-                                   let uu___56 =
-                                     let uu___57 =
-                                       FStar_Tests_Util.app succ [one] in
-                                     let uu___58 =
-                                       let uu___59 =
-                                         let uu___60 =
-                                           let uu___61 =
-                                             FStar_Tests_Util.nm
-                                               FStar_Tests_Util.x in
-                                           let uu___62 =
-                                             let uu___63 =
-                                               FStar_Tests_Util.nm
-                                                 FStar_Tests_Util.x in
-                                             [uu___63] in
-                                           uu___61 :: uu___62 in
-                                         FStar_Tests_Util.app mul uu___60 in
-                                       let uu___60 =
-                                         let uu___61 =
-                                           let uu___62 =
-                                             let uu___63 =
-                                               FStar_Tests_Util.nm
-                                                 FStar_Tests_Util.y in
-                                             let uu___64 =
-                                               let uu___65 =
-                                                 FStar_Tests_Util.nm
-                                                   FStar_Tests_Util.y in
-                                               [uu___65] in
-                                             uu___63 :: uu___64 in
-                                           FStar_Tests_Util.app mul uu___62 in
-                                         let uu___62 =
-                                           let uu___63 =
-                                             FStar_Tests_Util.nm
-                                               FStar_Tests_Util.h in
-                                           let uu___64 =
-                                             FStar_Tests_Util.nm
-                                               FStar_Tests_Util.h in
-                                           minus uu___63 uu___64 in
-                                         let_ FStar_Tests_Util.h uu___61
-                                           uu___62 in
-                                       let_ FStar_Tests_Util.y uu___59
-                                         uu___60 in
-                                     let_ FStar_Tests_Util.x uu___57 uu___58 in
-                                   ((Prims.of_int (15)), uu___56, z) in
-                                 let uu___56 =
-                                   let uu___57 =
-                                     let uu___58 =
-                                       let uu___59 =
-                                         FStar_Tests_Util.app succ [one] in
-                                       let uu___60 =
-                                         let uu___61 =
-                                           let uu___62 =
-                                             let uu___63 =
-                                               FStar_Tests_Util.nm
-                                                 FStar_Tests_Util.x in
-                                             let uu___64 =
-                                               let uu___65 =
-                                                 FStar_Tests_Util.nm
-                                                   FStar_Tests_Util.x in
-                                               [uu___65] in
-                                             uu___63 :: uu___64 in
-                                           FStar_Tests_Util.app mul uu___62 in
-                                         let uu___62 =
-                                           let uu___63 =
-                                             let uu___64 =
-                                               let uu___65 =
-                                                 FStar_Tests_Util.nm
-                                                   FStar_Tests_Util.y in
-                                               let uu___66 =
-                                                 let uu___67 =
-                                                   FStar_Tests_Util.nm
-                                                     FStar_Tests_Util.y in
-                                                 [uu___67] in
-                                               uu___65 :: uu___66 in
-                                             FStar_Tests_Util.app mul uu___64 in
-                                           let uu___64 =
-                                             let uu___65 =
-                                               FStar_Tests_Util.nm
-                                                 FStar_Tests_Util.h in
-                                             let uu___66 =
-                                               FStar_Tests_Util.nm
-                                                 FStar_Tests_Util.h in
-                                             minus uu___65 uu___66 in
-                                           mk_let FStar_Tests_Util.h uu___63
-                                             uu___64 in
-                                         mk_let FStar_Tests_Util.y uu___61
-                                           uu___62 in
-                                       mk_let FStar_Tests_Util.x uu___59
-                                         uu___60 in
-                                     ((Prims.of_int (16)), uu___58, z) in
-                                   let uu___58 =
-                                     let uu___59 =
-                                       let uu___60 =
-                                         let uu___61 =
-                                           FStar_Tests_Util.app succ [one] in
-                                         let uu___62 =
-                                           let uu___63 =
-                                             let uu___64 =
-                                               let uu___65 =
-                                                 FStar_Tests_Util.nm
-                                                   FStar_Tests_Util.x in
-                                               let uu___66 =
-                                                 let uu___67 =
-                                                   FStar_Tests_Util.nm
-                                                     FStar_Tests_Util.x in
-                                                 [uu___67] in
-                                               uu___65 :: uu___66 in
-                                             FStar_Tests_Util.app mul uu___64 in
-                                           let uu___64 =
-                                             let uu___65 =
-                                               let uu___66 =
-                                                 let uu___67 =
-                                                   FStar_Tests_Util.nm
-                                                     FStar_Tests_Util.y in
-                                                 let uu___68 =
-                                                   let uu___69 =
-                                                     FStar_Tests_Util.nm
-                                                       FStar_Tests_Util.y in
-                                                   [uu___69] in
-                                                 uu___67 :: uu___68 in
-                                               FStar_Tests_Util.app mul
-                                                 uu___66 in
-                                             let uu___66 =
-                                               let uu___67 =
-                                                 FStar_Tests_Util.nm
-                                                   FStar_Tests_Util.h in
-                                               let uu___68 =
-                                                 FStar_Tests_Util.nm
-                                                   FStar_Tests_Util.h in
-                                               minus uu___67 uu___68 in
-                                             let_ FStar_Tests_Util.h uu___65
-                                               uu___66 in
-                                           let_ FStar_Tests_Util.y uu___63
-                                             uu___64 in
-                                         let_ FStar_Tests_Util.x uu___61
-                                           uu___62 in
-                                       ((Prims.of_int (17)), uu___60, z) in
-                                     let uu___60 =
-                                       let uu___61 =
-                                         let uu___62 =
-                                           let uu___63 =
-                                             let uu___64 = snat znat in
-                                             snat uu___64 in
-                                           pred_nat uu___63 in
-                                         let uu___63 = snat znat in
-                                         ((Prims.of_int (18)), uu___62,
-                                           uu___63) in
-                                       let uu___62 =
-                                         let uu___63 =
-                                           let uu___64 =
-                                             let uu___65 =
-                                               let uu___66 =
-                                                 let uu___67 = snat znat in
-                                                 snat uu___67 in
-                                               let uu___67 = snat znat in
-                                               minus_nat uu___66 uu___67 in
-                                             FStar_Tests_Pars.tc_term uu___65 in
-                                           let uu___65 = snat znat in
-                                           ((Prims.of_int (19)), uu___64,
-                                             uu___65) in
-                                         let uu___64 =
-                                           let uu___65 =
-                                             let uu___66 =
-                                               let uu___67 =
-                                                 let uu___68 =
-                                                   encode_nat
-                                                     (Prims.of_int (10)) in
-                                                 let uu___69 =
-                                                   encode_nat
-                                                     (Prims.of_int (10)) in
-                                                 minus_nat uu___68 uu___69 in
-                                               FStar_Tests_Pars.tc_term
-                                                 uu___67 in
-                                             ((Prims.of_int (20)), uu___66,
-                                               znat) in
-                                           let uu___66 =
-                                             let uu___67 =
-                                               let uu___68 =
-                                                 let uu___69 =
-                                                   let uu___70 =
-                                                     encode_nat
-                                                       (Prims.of_int (100)) in
-                                                   let uu___71 =
-                                                     encode_nat
-                                                       (Prims.of_int (100)) in
-                                                   minus_nat uu___70 uu___71 in
-                                                 FStar_Tests_Pars.tc_term
-                                                   uu___69 in
-                                               ((Prims.of_int (21)), uu___68,
-                                                 znat) in
-                                             let uu___68 =
-                                               let uu___69 =
-                                                 let uu___70 =
-                                                   FStar_Tests_Pars.tc
-                                                     "recons [0;1]" in
-                                                 let uu___71 =
-                                                   FStar_Tests_Pars.tc
-                                                     "[0;1]" in
-                                                 ((Prims.of_int (24)),
-                                                   uu___70, uu___71) in
-                                               let uu___70 =
-                                                 let uu___71 =
-                                                   let uu___72 =
-                                                     FStar_Tests_Pars.tc
-                                                       "recons [false;true;false]" in
-                                                   let uu___73 =
-                                                     FStar_Tests_Pars.tc
-                                                       "[false;true;false]" in
-                                                   ((Prims.of_int (241)),
-                                                     uu___72, uu___73) in
-                                                 let uu___72 =
-                                                   let uu___73 =
-                                                     let uu___74 =
-                                                       FStar_Tests_Pars.tc
-                                                         "copy [0;1]" in
-                                                     let uu___75 =
-                                                       FStar_Tests_Pars.tc
-                                                         "[0;1]" in
-                                                     ((Prims.of_int (25)),
-                                                       uu___74, uu___75) in
-                                                   let uu___74 =
-                                                     let uu___75 =
-                                                       let uu___76 =
-                                                         FStar_Tests_Pars.tc
-                                                           "rev [0;1;2;3;4;5;6;7;8;9;10]" in
-                                                       let uu___77 =
-                                                         FStar_Tests_Pars.tc
-                                                           "[10;9;8;7;6;5;4;3;2;1;0]" in
-                                                       ((Prims.of_int (26)),
-                                                         uu___76, uu___77) in
-                                                     let uu___76 =
-                                                       let uu___77 =
-                                                         let uu___78 =
-                                                           FStar_Tests_Pars.tc
-                                                             "(fun x y z q -> z) T T F T" in
-                                                         let uu___79 =
-                                                           FStar_Tests_Pars.tc
-                                                             "F" in
-                                                         ((Prims.of_int (28)),
-                                                           uu___78, uu___79) in
-                                                       let uu___78 =
-                                                         let uu___79 =
-                                                           let uu___80 =
-                                                             FStar_Tests_Pars.tc
-                                                               "[T; F]" in
-                                                           let uu___81 =
-                                                             FStar_Tests_Pars.tc
-                                                               "[T; F]" in
-                                                           ((Prims.of_int (29)),
-                                                             uu___80,
-                                                             uu___81) in
-                                                         let uu___80 =
-                                                           let uu___81 =
-                                                             let uu___82 =
-                                                               FStar_Tests_Pars.tc
-                                                                 "id_tb T" in
-                                                             let uu___83 =
-                                                               FStar_Tests_Pars.tc
-                                                                 "T" in
-                                                             ((Prims.of_int (31)),
-                                                               uu___82,
-                                                               uu___83) in
-                                                           let uu___82 =
-                                                             let uu___83 =
-                                                               let uu___84 =
-                                                                 FStar_Tests_Pars.tc
-                                                                   "(fun #a x -> x) #tb T" in
-                                                               let uu___85 =
-                                                                 FStar_Tests_Pars.tc
-                                                                   "T" in
-                                                               ((Prims.of_int (32)),
-                                                                 uu___84,
-                                                                 uu___85) in
-                                                             let uu___84 =
-                                                               let uu___85 =
-                                                                 let uu___86
-                                                                   =
-                                                                   FStar_Tests_Pars.tc
-                                                                    "revtb T" in
-                                                                 let uu___87
-                                                                   =
-                                                                   FStar_Tests_Pars.tc
-                                                                    "F" in
-                                                                 ((Prims.of_int (33)),
-                                                                   uu___86,
-                                                                   uu___87) in
-                                                               let uu___86 =
-                                                                 let uu___87
-                                                                   =
-                                                                   let uu___88
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "(fun x y -> x) T F" in
-                                                                   let uu___89
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "T" in
-                                                                   ((Prims.of_int (34)),
-                                                                    uu___88,
-                                                                    uu___89) in
-                                                                 let uu___88
-                                                                   =
-                                                                   let uu___89
-                                                                    =
-                                                                    let uu___90
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "fst_a T F" in
-                                                                    let uu___91
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "T" in
-                                                                    ((Prims.of_int (35)),
-                                                                    uu___90,
-                                                                    uu___91) in
-                                                                   let uu___90
-                                                                    =
-                                                                    let uu___91
-                                                                    =
-                                                                    let uu___92
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "idd T" in
-                                                                    let uu___93
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "T" in
-                                                                    ((Prims.of_int (36)),
-                                                                    uu___92,
-                                                                    uu___93) in
-                                                                    let uu___92
-                                                                    =
-                                                                    let uu___93
-                                                                    =
-                                                                    let uu___94
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "id_list [T]" in
-                                                                    let uu___95
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[T]" in
-                                                                    ((Prims.of_int (301)),
-                                                                    uu___94,
-                                                                    uu___95) in
-                                                                    let uu___94
-                                                                    =
-                                                                    let uu___95
-                                                                    =
-                                                                    let uu___96
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "id_list_m [T]" in
-                                                                    let uu___97
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[T]" in
-                                                                    ((Prims.of_int (3012)),
-                                                                    uu___96,
-                                                                    uu___97) in
-                                                                    let uu___96
-                                                                    =
-                                                                    let uu___97
-                                                                    =
-                                                                    let uu___98
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "recons_m [T; F]" in
-                                                                    let uu___99
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[T; F]" in
-                                                                    ((Prims.of_int (302)),
-                                                                    uu___98,
-                                                                    uu___99) in
-                                                                    let uu___98
-                                                                    =
-                                                                    let uu___99
-                                                                    =
-                                                                    let uu___100
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "select T A1 A3" in
-                                                                    let uu___101
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "A1" in
-                                                                    ((Prims.of_int (303)),
-                                                                    uu___100,
-                                                                    uu___101) in
-                                                                    let uu___100
-                                                                    =
-                                                                    let uu___101
-                                                                    =
-                                                                    let uu___102
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "select T 3 4" in
-                                                                    let uu___103
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "3" in
-                                                                    ((Prims.of_int (3031)),
-                                                                    uu___102,
-                                                                    uu___103) in
-                                                                    let uu___102
-                                                                    =
-                                                                    let uu___103
-                                                                    =
-                                                                    let uu___104
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "select_bool false 3 4" in
-                                                                    let uu___105
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "4" in
-                                                                    ((Prims.of_int (3032)),
-                                                                    uu___104,
-                                                                    uu___105) in
-                                                                    let uu___104
-                                                                    =
-                                                                    let uu___105
-                                                                    =
-                                                                    let uu___106
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "select_int3 1 7 8 9" in
-                                                                    let uu___107
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "8" in
-                                                                    ((Prims.of_int (3033)),
-                                                                    uu___106,
-                                                                    uu___107) in
-                                                                    let uu___106
-                                                                    =
-                                                                    let uu___107
-                                                                    =
-                                                                    let uu___108
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[5]" in
-                                                                    let uu___109
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[5]" in
-                                                                    ((Prims.of_int (3034)),
-                                                                    uu___108,
-                                                                    uu___109) in
-                                                                    let uu___108
-                                                                    =
-                                                                    let uu___109
-                                                                    =
-                                                                    let uu___110
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[\"abcd\"]" in
-                                                                    let uu___111
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[\"abcd\"]" in
-                                                                    ((Prims.of_int (3035)),
-                                                                    uu___110,
-                                                                    uu___111) in
-                                                                    let uu___110
-                                                                    =
-                                                                    let uu___111
-                                                                    =
-                                                                    let uu___112
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "select_string3 \"def\" 5 6 7" in
-                                                                    let uu___113
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "6" in
-                                                                    ((Prims.of_int (3036)),
-                                                                    uu___112,
-                                                                    uu___113) in
-                                                                    let uu___112
-                                                                    =
-                                                                    let uu___113
-                                                                    =
-                                                                    let uu___114
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "idd T" in
-                                                                    let uu___115
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "T" in
-                                                                    ((Prims.of_int (305)),
-                                                                    uu___114,
-                                                                    uu___115) in
-                                                                    let uu___114
-                                                                    =
-                                                                    let uu___115
-                                                                    =
-                                                                    let uu___116
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "recons [T]" in
-                                                                    let uu___117
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[T]" in
-                                                                    ((Prims.of_int (306)),
-                                                                    uu___116,
-                                                                    uu___117) in
-                                                                    let uu___116
-                                                                    =
-                                                                    let uu___117
-                                                                    =
-                                                                    let uu___118
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "copy_tb_list_2 [T;F;T;F;T;F;F]" in
-                                                                    let uu___119
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[T;F;T;F;T;F;F]" in
-                                                                    ((Prims.of_int (307)),
-                                                                    uu___118,
-                                                                    uu___119) in
-                                                                    let uu___118
-                                                                    =
-                                                                    let uu___119
-                                                                    =
-                                                                    let uu___120
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "copy_list_2    [T;F;T;F;T;F;F]" in
-                                                                    let uu___121
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[T;F;T;F;T;F;F]" in
-                                                                    ((Prims.of_int (308)),
-                                                                    uu___120,
-                                                                    uu___121) in
-                                                                    let uu___120
-                                                                    =
-                                                                    let uu___121
-                                                                    =
-                                                                    let uu___122
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "rev [T; F; F]" in
-                                                                    let uu___123
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[F; F; T]" in
-                                                                    ((Prims.of_int (304)),
-                                                                    uu___122,
-                                                                    uu___123) in
-                                                                    let uu___122
-                                                                    =
-                                                                    let uu___123
-                                                                    =
-                                                                    let uu___124
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "rev [[T]; [F; T]]" in
-                                                                    let uu___125
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "[[F; T]; [T]]" in
-                                                                    ((Prims.of_int (305)),
-                                                                    uu___124,
-                                                                    uu___125) in
-                                                                    let uu___124
-                                                                    =
-                                                                    let uu___125
-                                                                    =
-                                                                    let uu___126
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "x1" in
-                                                                    let uu___127
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "6" in
-                                                                    ((Prims.of_int (309)),
-                                                                    uu___126,
-                                                                    uu___127) in
-                                                                    let uu___126
-                                                                    =
-                                                                    let uu___127
-                                                                    =
-                                                                    let uu___128
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "x2" in
-                                                                    let uu___129
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "2" in
-                                                                    ((Prims.of_int (310)),
-                                                                    uu___128,
-                                                                    uu___129) in
-                                                                    let uu___128
-                                                                    =
-                                                                    let uu___129
-                                                                    =
-                                                                    let uu___130
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "7 + 3" in
-                                                                    let uu___131
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "10" in
-                                                                    ((Prims.of_int (401)),
-                                                                    uu___130,
-                                                                    uu___131) in
-                                                                    let uu___130
-                                                                    =
-                                                                    let uu___131
-                                                                    =
-                                                                    let uu___132
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "true && false" in
-                                                                    let uu___133
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "false" in
-                                                                    ((Prims.of_int (402)),
-                                                                    uu___132,
-                                                                    uu___133) in
-                                                                    let uu___132
-                                                                    =
-                                                                    let uu___133
-                                                                    =
-                                                                    let uu___134
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "3 = 5" in
-                                                                    let uu___135
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "false" in
-                                                                    ((Prims.of_int (403)),
-                                                                    uu___134,
-                                                                    uu___135) in
-                                                                    let uu___134
-                                                                    =
-                                                                    let uu___135
-                                                                    =
-                                                                    let uu___136
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "\"abc\" ^ \"def\"" in
-                                                                    let uu___137
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "\"abcdef\"" in
-                                                                    ((Prims.of_int (404)),
-                                                                    uu___136,
-                                                                    uu___137) in
-                                                                    let uu___136
-                                                                    =
-                                                                    let uu___137
-                                                                    =
-                                                                    let uu___138
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "(fun (x:list int) -> match x with | [] -> 0 | hd::tl -> 1) []" in
-                                                                    let uu___139
-                                                                    =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "0" in
-                                                                    ((Prims.of_int (405)),
-                                                                    uu___138,
-                                                                    uu___139) in
-                                                                    [uu___137] in
-                                                                    uu___135
-                                                                    ::
-                                                                    uu___136 in
-                                                                    uu___133
-                                                                    ::
-                                                                    uu___134 in
-                                                                    uu___131
-                                                                    ::
-                                                                    uu___132 in
-                                                                    uu___129
-                                                                    ::
-                                                                    uu___130 in
-                                                                    uu___127
-                                                                    ::
-                                                                    uu___128 in
-                                                                    uu___125
-                                                                    ::
-                                                                    uu___126 in
-                                                                    uu___123
-                                                                    ::
-                                                                    uu___124 in
-                                                                    uu___121
-                                                                    ::
-                                                                    uu___122 in
-                                                                    uu___119
-                                                                    ::
-                                                                    uu___120 in
-                                                                    uu___117
-                                                                    ::
-                                                                    uu___118 in
-                                                                    uu___115
-                                                                    ::
-                                                                    uu___116 in
-                                                                    uu___113
-                                                                    ::
-                                                                    uu___114 in
-                                                                    uu___111
-                                                                    ::
-                                                                    uu___112 in
-                                                                    uu___109
-                                                                    ::
-                                                                    uu___110 in
-                                                                    uu___107
-                                                                    ::
-                                                                    uu___108 in
-                                                                    uu___105
-                                                                    ::
-                                                                    uu___106 in
-                                                                    uu___103
-                                                                    ::
-                                                                    uu___104 in
-                                                                    uu___101
-                                                                    ::
-                                                                    uu___102 in
-                                                                    uu___99
-                                                                    ::
-                                                                    uu___100 in
-                                                                    uu___97
-                                                                    ::
-                                                                    uu___98 in
-                                                                    uu___95
-                                                                    ::
-                                                                    uu___96 in
-                                                                    uu___93
-                                                                    ::
-                                                                    uu___94 in
-                                                                    uu___91
-                                                                    ::
-                                                                    uu___92 in
-                                                                   uu___89 ::
-                                                                    uu___90 in
-                                                                 uu___87 ::
-                                                                   uu___88 in
-                                                               uu___85 ::
-                                                                 uu___86 in
-                                                             uu___83 ::
-                                                               uu___84 in
-                                                           uu___81 :: uu___82 in
-                                                         uu___79 :: uu___80 in
-                                                       uu___77 :: uu___78 in
-                                                     uu___75 :: uu___76 in
-                                                   uu___73 :: uu___74 in
-                                                 uu___71 :: uu___72 in
-                                               uu___69 :: uu___70 in
-                                             uu___67 :: uu___68 in
-                                           uu___65 :: uu___66 in
-                                         uu___63 :: uu___64 in
-                                       uu___61 :: uu___62 in
-                                     uu___59 :: uu___60 in
-                                   uu___57 :: uu___58 in
-                                 uu___55 :: uu___56 in
-                               uu___53 :: uu___54 in
-                             uu___51 :: uu___52 in
-                           uu___49 :: uu___50 in
-                         uu___47 :: uu___48 in
-                       uu___45 :: uu___46 in
-                     uu___43 :: uu___44 in
-                   uu___41 :: uu___42 in
-                 uu___39 :: uu___40 in
-               uu___37 :: uu___38 in
-             uu___35 :: uu___36 in
-           uu___33 :: uu___34 in
-         uu___31 :: uu___32 in
-       uu___29 :: uu___30 in
-     uu___27 :: uu___28 in
-   uu___25 :: uu___26)
-let run_either :
-  'uuuuu .
-    Prims.int ->
-      'uuuuu ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          (FStar_TypeChecker_Env.env -> 'uuuuu -> FStar_Syntax_Syntax.term)
-            -> unit
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        fun normalizer ->
-          (let uu___1 = FStar_Compiler_Util.string_of_int i in
-           FStar_Compiler_Util.print1 "%s: ... \n\n" uu___1);
-          (let tcenv = FStar_Tests_Pars.init () in
-           (let uu___2 = FStar_Main.process_args () in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()));
-           (let x = normalizer tcenv r in
-            FStar_Options.init ();
-            FStar_Options.set_option "print_universes"
-              (FStar_Options.Bool true);
-            FStar_Options.set_option "print_implicits"
-              (FStar_Options.Bool true);
-            FStar_Options.set_option "ugly" (FStar_Options.Bool true);
-            FStar_Options.set_option "print_bound_var_types"
-              (FStar_Options.Bool true);
-            (let uu___7 =
-               let uu___8 = FStar_Syntax_Util.unascribe x in
-               FStar_Tests_Util.term_eq uu___8 expected in
-             FStar_Tests_Util.always i uu___7)))
-let (run_whnf :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        let steps =
-          [FStar_TypeChecker_Env.Primops;
-          FStar_TypeChecker_Env.Weak;
-          FStar_TypeChecker_Env.HNF;
-          FStar_TypeChecker_Env.UnfoldUntil
-            FStar_Syntax_Syntax.delta_constant] in
-        run_either i r expected (FStar_TypeChecker_Normalize.normalize steps)
-let (run_interpreter :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        run_either i r expected
-          (FStar_TypeChecker_Normalize.normalize
-             [FStar_TypeChecker_Env.Beta;
-             FStar_TypeChecker_Env.UnfoldUntil
-               FStar_Syntax_Syntax.delta_constant;
-             FStar_TypeChecker_Env.Primops])
-let (run_nbe :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        run_either i r expected
-          (FStar_TypeChecker_NBE.normalize_for_unit_test
-             [FStar_TypeChecker_Env.UnfoldUntil
-                FStar_Syntax_Syntax.delta_constant])
-let (run_interpreter_with_time :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        (Prims.int * FStar_BaseTypes.float))
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        let interp uu___ = run_interpreter i r expected in
-        let uu___ =
-          let uu___1 = FStar_Compiler_Util.return_execution_time interp in
-          FStar_Pervasives_Native.snd uu___1 in
-        (i, uu___)
-let (run_whnf_with_time :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        (Prims.int * FStar_BaseTypes.float))
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        let whnf uu___ = run_whnf i r expected in
-        let uu___ =
-          let uu___1 = FStar_Compiler_Util.return_execution_time whnf in
-          FStar_Pervasives_Native.snd uu___1 in
-        (i, uu___)
-let (run_nbe_with_time :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        (Prims.int * FStar_BaseTypes.float))
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        let nbe uu___ = run_nbe i r expected in
-        let uu___ =
-          let uu___1 = FStar_Compiler_Util.return_execution_time nbe in
-          FStar_Pervasives_Native.snd uu___1 in
-        (i, uu___)
-let run_tests :
-  'uuuuu 'uuuuu1 'uuuuu2 'uuuuu3 .
-    ('uuuuu * 'uuuuu1 * 'uuuuu2) Prims.list ->
-      ('uuuuu -> 'uuuuu1 -> 'uuuuu2 -> 'uuuuu3) -> 'uuuuu3 Prims.list
-  =
-  fun tests ->
-    fun run ->
-      FStar_Options.__set_unit_tests ();
-      (let l =
-         FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with | (no, test, res) -> run no test res) tests in
-       FStar_Options.__clear_unit_tests (); l)
-let (whnf_tests :
-  (Prims.int * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term)
-    Prims.list)
-  =
-  FStar_Tests_Pars.pars_and_tc_fragment "assume val def : Type0";
-  FStar_Tests_Pars.pars_and_tc_fragment "assume val pred : Type0";
-  FStar_Tests_Pars.pars_and_tc_fragment "let def0 (y:int) = def";
-  FStar_Tests_Pars.pars_and_tc_fragment
-    "unfold let def1 (y:int) = x:def0 y { pred }";
-  (let def_def1 = FStar_Tests_Pars.tc "x:def0 17 { pred }" in
-   let def_def1_unfolded = FStar_Tests_Pars.tc "x:def { pred }" in
-   let tests =
-     let uu___4 =
-       let uu___5 = FStar_Tests_Pars.tc "def1 17" in
-       ((Prims.of_int (601)), uu___5, def_def1) in
-     [uu___4; ((Prims.of_int (602)), def_def1, def_def1_unfolded)] in
-   tests)
-let (run_all_whnf : unit -> unit) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing Normlizer WHNF\n";
-    (let uu___2 = run_tests whnf_tests run_whnf in
-     FStar_Compiler_Util.print_string "Normalizer WHNF ok\n")
-let (run_all_nbe : unit -> unit) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing NBE\n";
-    (let uu___2 = run_tests default_tests run_nbe in
-     FStar_Compiler_Util.print_string "NBE ok\n")
-let (run_all_interpreter : unit -> unit) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing the normalizer\n";
-    (let uu___2 = run_tests default_tests run_interpreter in
-     FStar_Compiler_Util.print_string "Normalizer ok\n")
-let (run_all_whnf_with_time :
-  unit -> (Prims.int * FStar_BaseTypes.float) Prims.list) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing WHNF\n";
-    (let l = run_tests whnf_tests run_whnf_with_time in
-     FStar_Compiler_Util.print_string "WHNF ok\n"; l)
-let (run_all_nbe_with_time :
-  unit -> (Prims.int * FStar_BaseTypes.float) Prims.list) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing NBE\n";
-    (let l = run_tests default_tests run_nbe_with_time in
-     FStar_Compiler_Util.print_string "NBE ok\n"; l)
-let (run_all_interpreter_with_time :
-  unit -> (Prims.int * FStar_BaseTypes.float) Prims.list) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing the normalizer\n";
-    (let l = run_tests default_tests run_interpreter_with_time in
-     FStar_Compiler_Util.print_string "Normalizer ok\n"; l)
-let (run_both_with_time :
-  Prims.int ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun i ->
-    fun r ->
-      fun expected ->
-        let nbe uu___ = run_nbe i r expected in
-        let norm uu___ = run_interpreter i r expected in
-        FStar_Compiler_Util.measure_execution_time "nbe" nbe;
-        FStar_Compiler_Util.print_string "\n";
-        FStar_Compiler_Util.measure_execution_time "normalizer" norm;
-        FStar_Compiler_Util.print_string "\n"
-let (compare : unit -> unit) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string
-      "Comparing times for normalization and nbe\n";
-    (let uu___2 =
-       let uu___3 = encode (Prims.of_int (1000)) in
-       let uu___4 =
-         let uu___5 = FStar_Tests_Util.nm FStar_Tests_Util.x in
-         let uu___6 = FStar_Tests_Util.nm FStar_Tests_Util.x in
-         minus uu___5 uu___6 in
-       let_ FStar_Tests_Util.x uu___3 uu___4 in
-     run_both_with_time (Prims.of_int (14)) uu___2 z)
-let (compare_times :
-  (Prims.int * FStar_BaseTypes.float) Prims.list ->
-    (Prims.int * FStar_BaseTypes.float) Prims.list -> unit)
-  =
-  fun l_int ->
-    fun l_nbe ->
-      FStar_Compiler_Util.print_string
-        "Comparing times for normalization and nbe\n";
-      FStar_Compiler_List.iter2
-        (fun res1 ->
-           fun res2 ->
-             let uu___1 = res1 in
-             match uu___1 with
-             | (t1, time_int) ->
-                 let uu___2 = res2 in
-                 (match uu___2 with
-                  | (t2, time_nbe) ->
-                      if t1 = t2
-                      then
-                        let uu___3 = FStar_Compiler_Util.string_of_int t1 in
-                        FStar_Compiler_Util.print3
-                          "Test %s\nNBE %s\nInterpreter %s\n" uu___3
-                          (FStar_Compiler_Util.string_of_float time_nbe)
-                          (FStar_Compiler_Util.string_of_float time_int)
-                      else
-                        FStar_Compiler_Util.print_string
-                          "Test numbers do not match...\n")) l_int l_nbe
-let (run_all : unit -> unit) =
-  fun uu___ ->
-    (let uu___2 = FStar_Syntax_Print.term_to_string znat in
-     FStar_Compiler_Util.print1 "%s" uu___2);
-    (let uu___2 = run_all_whnf_with_time () in
-     let l_int = run_all_interpreter_with_time () in
-     let l_nbe = run_all_nbe_with_time () in compare_times l_int l_nbe)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tests_Pars.ml b/src/ocaml-output/FStar_Tests_Pars.ml
deleted file mode 100644
index 5d794e5141d..00000000000
--- a/src/ocaml-output/FStar_Tests_Pars.ml
+++ /dev/null
@@ -1,624 +0,0 @@
-open Prims
-let (test_lid : FStar_Ident.lident) =
-  FStar_Ident.lid_of_path ["Test"] FStar_Compiler_Range.dummyRange
-let (tcenv_ref :
-  FStar_TypeChecker_Env.env FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (test_mod_ref :
-  FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  =
-  FStar_Compiler_Util.mk_ref
-    (FStar_Pervasives_Native.Some
-       {
-         FStar_Syntax_Syntax.name = test_lid;
-         FStar_Syntax_Syntax.declarations = [];
-         FStar_Syntax_Syntax.is_interface = false
-       })
-let (parse_mod :
-  Prims.string ->
-    FStar_Syntax_DsEnv.env ->
-      (FStar_Syntax_DsEnv.env * FStar_Syntax_Syntax.modul))
-  =
-  fun mod_name ->
-    fun dsenv ->
-      let uu___ =
-        FStar_Parser_ParseIt.parse (FStar_Parser_ParseIt.Filename mod_name) in
-      match uu___ with
-      | FStar_Parser_ParseIt.ASTFragment (FStar_Pervasives.Inl m, uu___1) ->
-          let uu___2 =
-            let uu___3 = FStar_ToSyntax_ToSyntax.ast_modul_to_modul m in
-            uu___3 dsenv in
-          (match uu___2 with
-           | (m1, env') ->
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Ident.lid_of_path ["Test"]
-                     FStar_Compiler_Range.dummyRange in
-                 FStar_Syntax_DsEnv.prepare_module_or_interface false false
-                   env' uu___4 FStar_Syntax_DsEnv.default_mii in
-               (match uu___3 with | (env'1, uu___4) -> (env'1, m1)))
-      | FStar_Parser_ParseIt.ParseError (err, msg, r) ->
-          FStar_Compiler_Effect.raise (FStar_Errors.Error (err, msg, r, []))
-      | FStar_Parser_ParseIt.ASTFragment
-          (FStar_Pervasives.Inr uu___1, uu___2) ->
-          let msg =
-            FStar_Compiler_Util.format1 "%s: expected a module\n" mod_name in
-          FStar_Errors.raise_error (FStar_Errors.Fatal_ModuleExpected, msg)
-            FStar_Compiler_Range.dummyRange
-      | FStar_Parser_ParseIt.Term uu___1 ->
-          failwith
-            "Impossible: parsing a Filename always results in an ASTFragment"
-let (add_mods :
-  Prims.string Prims.list ->
-    FStar_Syntax_DsEnv.env ->
-      FStar_TypeChecker_Env.env ->
-        (FStar_Syntax_DsEnv.env * FStar_TypeChecker_Env.env))
-  =
-  fun mod_names ->
-    fun dsenv ->
-      fun env ->
-        FStar_Compiler_List.fold_left
-          (fun uu___ ->
-             fun mod_name ->
-               match uu___ with
-               | (dsenv1, env1) ->
-                   let uu___1 = parse_mod mod_name dsenv1 in
-                   (match uu___1 with
-                    | (dsenv2, string_mod) ->
-                        let uu___2 =
-                          FStar_TypeChecker_Tc.check_module env1 string_mod
-                            false in
-                        (match uu___2 with | (_mod, env2) -> (dsenv2, env2))))
-          (dsenv, env) mod_names
-let (init_once : unit -> unit) =
-  fun uu___ ->
-    let solver = FStar_SMTEncoding_Solver.dummy in
-    let env =
-      FStar_TypeChecker_Env.initial_env FStar_Parser_Dep.empty_deps
-        FStar_TypeChecker_TcTerm.tc_term
-        FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term
-        FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term_fastpath
-        FStar_TypeChecker_TcTerm.universe_of
-        FStar_TypeChecker_Rel.teq_nosmt_force
-        FStar_TypeChecker_Rel.subtype_nosmt_force solver
-        FStar_Parser_Const.prims_lid
-        FStar_TypeChecker_NBE.normalize_for_unit_test
-        FStar_Universal.core_check in
-    (env.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.init env;
-    (let uu___2 =
-       let uu___3 = FStar_Options.prims () in
-       let uu___4 = FStar_Syntax_DsEnv.empty_env FStar_Parser_Dep.empty_deps in
-       parse_mod uu___3 uu___4 in
-     match uu___2 with
-     | (dsenv, prims_mod) ->
-         let env1 =
-           {
-             FStar_TypeChecker_Env.solver =
-               (env.FStar_TypeChecker_Env.solver);
-             FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-             FStar_TypeChecker_Env.curmodule =
-               (env.FStar_TypeChecker_Env.curmodule);
-             FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-             FStar_TypeChecker_Env.gamma_sig =
-               (env.FStar_TypeChecker_Env.gamma_sig);
-             FStar_TypeChecker_Env.gamma_cache =
-               (env.FStar_TypeChecker_Env.gamma_cache);
-             FStar_TypeChecker_Env.modules =
-               (env.FStar_TypeChecker_Env.modules);
-             FStar_TypeChecker_Env.expected_typ =
-               (env.FStar_TypeChecker_Env.expected_typ);
-             FStar_TypeChecker_Env.sigtab =
-               (env.FStar_TypeChecker_Env.sigtab);
-             FStar_TypeChecker_Env.attrtab =
-               (env.FStar_TypeChecker_Env.attrtab);
-             FStar_TypeChecker_Env.instantiate_imp =
-               (env.FStar_TypeChecker_Env.instantiate_imp);
-             FStar_TypeChecker_Env.effects =
-               (env.FStar_TypeChecker_Env.effects);
-             FStar_TypeChecker_Env.generalize =
-               (env.FStar_TypeChecker_Env.generalize);
-             FStar_TypeChecker_Env.letrecs =
-               (env.FStar_TypeChecker_Env.letrecs);
-             FStar_TypeChecker_Env.top_level =
-               (env.FStar_TypeChecker_Env.top_level);
-             FStar_TypeChecker_Env.check_uvars =
-               (env.FStar_TypeChecker_Env.check_uvars);
-             FStar_TypeChecker_Env.use_eq_strict =
-               (env.FStar_TypeChecker_Env.use_eq_strict);
-             FStar_TypeChecker_Env.is_iface =
-               (env.FStar_TypeChecker_Env.is_iface);
-             FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-             FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-             FStar_TypeChecker_Env.lax_universes =
-               (env.FStar_TypeChecker_Env.lax_universes);
-             FStar_TypeChecker_Env.phase1 =
-               (env.FStar_TypeChecker_Env.phase1);
-             FStar_TypeChecker_Env.failhard =
-               (env.FStar_TypeChecker_Env.failhard);
-             FStar_TypeChecker_Env.nosynth =
-               (env.FStar_TypeChecker_Env.nosynth);
-             FStar_TypeChecker_Env.uvar_subtyping =
-               (env.FStar_TypeChecker_Env.uvar_subtyping);
-             FStar_TypeChecker_Env.tc_term =
-               (env.FStar_TypeChecker_Env.tc_term);
-             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-               (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-             FStar_TypeChecker_Env.universe_of =
-               (env.FStar_TypeChecker_Env.universe_of);
-             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-               (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-             FStar_TypeChecker_Env.teq_nosmt_force =
-               (env.FStar_TypeChecker_Env.teq_nosmt_force);
-             FStar_TypeChecker_Env.subtype_nosmt_force =
-               (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-             FStar_TypeChecker_Env.qtbl_name_and_index =
-               (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-             FStar_TypeChecker_Env.normalized_eff_names =
-               (env.FStar_TypeChecker_Env.normalized_eff_names);
-             FStar_TypeChecker_Env.fv_delta_depths =
-               (env.FStar_TypeChecker_Env.fv_delta_depths);
-             FStar_TypeChecker_Env.proof_ns =
-               (env.FStar_TypeChecker_Env.proof_ns);
-             FStar_TypeChecker_Env.synth_hook =
-               (env.FStar_TypeChecker_Env.synth_hook);
-             FStar_TypeChecker_Env.try_solve_implicits_hook =
-               (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-             FStar_TypeChecker_Env.splice =
-               (env.FStar_TypeChecker_Env.splice);
-             FStar_TypeChecker_Env.mpreprocess =
-               (env.FStar_TypeChecker_Env.mpreprocess);
-             FStar_TypeChecker_Env.postprocess =
-               (env.FStar_TypeChecker_Env.postprocess);
-             FStar_TypeChecker_Env.identifier_info =
-               (env.FStar_TypeChecker_Env.identifier_info);
-             FStar_TypeChecker_Env.tc_hooks =
-               (env.FStar_TypeChecker_Env.tc_hooks);
-             FStar_TypeChecker_Env.dsenv = dsenv;
-             FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-             FStar_TypeChecker_Env.strict_args_tab =
-               (env.FStar_TypeChecker_Env.strict_args_tab);
-             FStar_TypeChecker_Env.erasable_types_tab =
-               (env.FStar_TypeChecker_Env.erasable_types_tab);
-             FStar_TypeChecker_Env.enable_defer_to_tac =
-               (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-             FStar_TypeChecker_Env.unif_allow_ref_guards =
-               (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-             FStar_TypeChecker_Env.erase_erasable_args =
-               (env.FStar_TypeChecker_Env.erase_erasable_args);
-             FStar_TypeChecker_Env.core_check =
-               (env.FStar_TypeChecker_Env.core_check)
-           } in
-         let uu___3 = FStar_TypeChecker_Tc.check_module env1 prims_mod false in
-         (match uu___3 with
-          | (_prims_mod, env2) ->
-              let env3 =
-                {
-                  FStar_TypeChecker_Env.solver =
-                    (env2.FStar_TypeChecker_Env.solver);
-                  FStar_TypeChecker_Env.range =
-                    (env2.FStar_TypeChecker_Env.range);
-                  FStar_TypeChecker_Env.curmodule =
-                    (env2.FStar_TypeChecker_Env.curmodule);
-                  FStar_TypeChecker_Env.gamma =
-                    (env2.FStar_TypeChecker_Env.gamma);
-                  FStar_TypeChecker_Env.gamma_sig =
-                    (env2.FStar_TypeChecker_Env.gamma_sig);
-                  FStar_TypeChecker_Env.gamma_cache =
-                    (env2.FStar_TypeChecker_Env.gamma_cache);
-                  FStar_TypeChecker_Env.modules =
-                    (env2.FStar_TypeChecker_Env.modules);
-                  FStar_TypeChecker_Env.expected_typ =
-                    (env2.FStar_TypeChecker_Env.expected_typ);
-                  FStar_TypeChecker_Env.sigtab =
-                    (env2.FStar_TypeChecker_Env.sigtab);
-                  FStar_TypeChecker_Env.attrtab =
-                    (env2.FStar_TypeChecker_Env.attrtab);
-                  FStar_TypeChecker_Env.instantiate_imp =
-                    (env2.FStar_TypeChecker_Env.instantiate_imp);
-                  FStar_TypeChecker_Env.effects =
-                    (env2.FStar_TypeChecker_Env.effects);
-                  FStar_TypeChecker_Env.generalize =
-                    (env2.FStar_TypeChecker_Env.generalize);
-                  FStar_TypeChecker_Env.letrecs =
-                    (env2.FStar_TypeChecker_Env.letrecs);
-                  FStar_TypeChecker_Env.top_level =
-                    (env2.FStar_TypeChecker_Env.top_level);
-                  FStar_TypeChecker_Env.check_uvars =
-                    (env2.FStar_TypeChecker_Env.check_uvars);
-                  FStar_TypeChecker_Env.use_eq_strict =
-                    (env2.FStar_TypeChecker_Env.use_eq_strict);
-                  FStar_TypeChecker_Env.is_iface =
-                    (env2.FStar_TypeChecker_Env.is_iface);
-                  FStar_TypeChecker_Env.admit =
-                    (env2.FStar_TypeChecker_Env.admit);
-                  FStar_TypeChecker_Env.lax =
-                    (env2.FStar_TypeChecker_Env.lax);
-                  FStar_TypeChecker_Env.lax_universes =
-                    (env2.FStar_TypeChecker_Env.lax_universes);
-                  FStar_TypeChecker_Env.phase1 =
-                    (env2.FStar_TypeChecker_Env.phase1);
-                  FStar_TypeChecker_Env.failhard =
-                    (env2.FStar_TypeChecker_Env.failhard);
-                  FStar_TypeChecker_Env.nosynth =
-                    (env2.FStar_TypeChecker_Env.nosynth);
-                  FStar_TypeChecker_Env.uvar_subtyping =
-                    (env2.FStar_TypeChecker_Env.uvar_subtyping);
-                  FStar_TypeChecker_Env.tc_term =
-                    (env2.FStar_TypeChecker_Env.tc_term);
-                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                    (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                  FStar_TypeChecker_Env.universe_of =
-                    (env2.FStar_TypeChecker_Env.universe_of);
-                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                    (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                  FStar_TypeChecker_Env.teq_nosmt_force =
-                    (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                    (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                    (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                  FStar_TypeChecker_Env.normalized_eff_names =
-                    (env2.FStar_TypeChecker_Env.normalized_eff_names);
-                  FStar_TypeChecker_Env.fv_delta_depths =
-                    (env2.FStar_TypeChecker_Env.fv_delta_depths);
-                  FStar_TypeChecker_Env.proof_ns =
-                    (env2.FStar_TypeChecker_Env.proof_ns);
-                  FStar_TypeChecker_Env.synth_hook =
-                    (env2.FStar_TypeChecker_Env.synth_hook);
-                  FStar_TypeChecker_Env.try_solve_implicits_hook =
-                    (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                  FStar_TypeChecker_Env.splice =
-                    (env2.FStar_TypeChecker_Env.splice);
-                  FStar_TypeChecker_Env.mpreprocess =
-                    (env2.FStar_TypeChecker_Env.mpreprocess);
-                  FStar_TypeChecker_Env.postprocess =
-                    (env2.FStar_TypeChecker_Env.postprocess);
-                  FStar_TypeChecker_Env.identifier_info =
-                    (env2.FStar_TypeChecker_Env.identifier_info);
-                  FStar_TypeChecker_Env.tc_hooks =
-                    (env2.FStar_TypeChecker_Env.tc_hooks);
-                  FStar_TypeChecker_Env.dsenv = dsenv;
-                  FStar_TypeChecker_Env.nbe =
-                    (env2.FStar_TypeChecker_Env.nbe);
-                  FStar_TypeChecker_Env.strict_args_tab =
-                    (env2.FStar_TypeChecker_Env.strict_args_tab);
-                  FStar_TypeChecker_Env.erasable_types_tab =
-                    (env2.FStar_TypeChecker_Env.erasable_types_tab);
-                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                    (env2.FStar_TypeChecker_Env.enable_defer_to_tac);
-                  FStar_TypeChecker_Env.unif_allow_ref_guards =
-                    (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                  FStar_TypeChecker_Env.erase_erasable_args =
-                    (env2.FStar_TypeChecker_Env.erase_erasable_args);
-                  FStar_TypeChecker_Env.core_check =
-                    (env2.FStar_TypeChecker_Env.core_check)
-                } in
-              let env4 =
-                FStar_TypeChecker_Env.set_current_module env3 test_lid in
-              FStar_Compiler_Effect.op_Colon_Equals tcenv_ref
-                (FStar_Pervasives_Native.Some env4)))
-let (uu___52 : unit) = FStar_Main.setup_hooks (); init_once ()
-let (init : unit -> FStar_TypeChecker_Env.env) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang tcenv_ref in
-    match uu___1 with
-    | FStar_Pervasives_Native.Some f -> f
-    | uu___2 ->
-        failwith
-          "Should have already been initialized by the top-level effect"
-let (frag_of_text : Prims.string -> FStar_Parser_ParseIt.input_frag) =
-  fun s ->
-    {
-      FStar_Parser_ParseIt.frag_fname = " input";
-      FStar_Parser_ParseIt.frag_text = s;
-      FStar_Parser_ParseIt.frag_line = Prims.int_one;
-      FStar_Parser_ParseIt.frag_col = Prims.int_zero
-    }
-let (pars : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s ->
-    try
-      (fun uu___ ->
-         match () with
-         | () ->
-             let tcenv = init () in
-             let uu___1 =
-               let uu___2 =
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (fun uu___3 -> FStar_Parser_ParseIt.Fragment uu___3)
-                   (frag_of_text s) in
-               FStar_Parser_ParseIt.parse uu___2 in
-             (match uu___1 with
-              | FStar_Parser_ParseIt.Term t ->
-                  FStar_ToSyntax_ToSyntax.desugar_term
-                    tcenv.FStar_TypeChecker_Env.dsenv t
-              | FStar_Parser_ParseIt.ParseError (e, msg, r) ->
-                  FStar_Errors.raise_error (e, msg) r
-              | FStar_Parser_ParseIt.ASTFragment uu___2 ->
-                  failwith
-                    "Impossible: parsing a Fragment always results in a Term"))
-        ()
-    with
-    | FStar_Errors.Error (err, msg, r, _ctx) when
-        let uu___1 = FStar_Options.trace_error () in
-        FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___1 ->
-        (if r = FStar_Compiler_Range.dummyRange
-         then FStar_Compiler_Util.print_string msg
-         else
-           (let uu___3 = FStar_Compiler_Range.string_of_range r in
-            FStar_Compiler_Util.print2 "%s: %s\n" uu___3 msg);
-         FStar_Compiler_Effect.exit Prims.int_one)
-    | e when
-        let uu___1 = FStar_Options.trace_error () in Prims.op_Negation uu___1
-        -> FStar_Compiler_Effect.raise e
-let (tc' :
-  Prims.string -> (FStar_Syntax_Syntax.term * FStar_TypeChecker_Env.env)) =
-  fun s ->
-    let tm = pars s in
-    let tcenv = init () in
-    let tcenv1 =
-      {
-        FStar_TypeChecker_Env.solver = (tcenv.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (tcenv.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (tcenv.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (tcenv.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (tcenv.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (tcenv.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (tcenv.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (tcenv.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (tcenv.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (tcenv.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (tcenv.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (tcenv.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (tcenv.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (tcenv.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level = false;
-        FStar_TypeChecker_Env.check_uvars =
-          (tcenv.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (tcenv.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (tcenv.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (tcenv.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (tcenv.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (tcenv.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (tcenv.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (tcenv.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (tcenv.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (tcenv.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (tcenv.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (tcenv.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (tcenv.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (tcenv.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (tcenv.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (tcenv.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (tcenv.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (tcenv.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (tcenv.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (tcenv.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (tcenv.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (tcenv.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (tcenv.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (tcenv.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (tcenv.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (tcenv.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (tcenv.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (tcenv.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (tcenv.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (tcenv.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (tcenv.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (tcenv.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (tcenv.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (tcenv.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (tcenv.FStar_TypeChecker_Env.core_check)
-      } in
-    let uu___ = FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term tcenv1 tm in
-    match uu___ with
-    | (tm1, uu___1, g) ->
-        (FStar_TypeChecker_Rel.force_trivial_guard tcenv1 g;
-         (let tm2 = FStar_Syntax_Subst.deep_compress false tm1 in
-          (tm2, tcenv1)))
-let (tc : Prims.string -> FStar_Syntax_Syntax.term) =
-  fun s -> let uu___ = tc' s in match uu___ with | (tm, uu___1) -> tm
-let (tc_term : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun tm ->
-    let tcenv = init () in
-    let tcenv1 =
-      {
-        FStar_TypeChecker_Env.solver = (tcenv.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (tcenv.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (tcenv.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (tcenv.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (tcenv.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (tcenv.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (tcenv.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (tcenv.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (tcenv.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (tcenv.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (tcenv.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (tcenv.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (tcenv.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (tcenv.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level = false;
-        FStar_TypeChecker_Env.check_uvars =
-          (tcenv.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (tcenv.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (tcenv.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (tcenv.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (tcenv.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (tcenv.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (tcenv.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (tcenv.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (tcenv.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (tcenv.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (tcenv.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (tcenv.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (tcenv.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (tcenv.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (tcenv.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (tcenv.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (tcenv.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (tcenv.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (tcenv.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (tcenv.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (tcenv.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (tcenv.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (tcenv.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (tcenv.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (tcenv.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (tcenv.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (tcenv.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (tcenv.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (tcenv.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (tcenv.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (tcenv.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (tcenv.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (tcenv.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (tcenv.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (tcenv.FStar_TypeChecker_Env.core_check)
-      } in
-    let uu___ = FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term tcenv1 tm in
-    match uu___ with
-    | (tm1, uu___1, g) ->
-        (FStar_TypeChecker_Rel.force_trivial_guard tcenv1 g;
-         (let tm2 = FStar_Syntax_Subst.deep_compress false tm1 in tm2))
-let (pars_and_tc_fragment : Prims.string -> unit) =
-  fun s ->
-    FStar_Options.set_option "trace_error" (FStar_Options.Bool true);
-    (let report uu___1 =
-       let uu___2 = FStar_Errors.report_all () in
-       FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()) in
-     try
-       (fun uu___1 ->
-          match () with
-          | () ->
-              let tcenv = init () in
-              let frag = frag_of_text s in
-              (try
-                 (fun uu___2 ->
-                    match () with
-                    | () ->
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Compiler_Effect.op_Bang test_mod_ref in
-                          FStar_Universal.tc_one_fragment uu___4 tcenv frag in
-                        (match uu___3 with
-                         | (test_mod', tcenv') ->
-                             (FStar_Compiler_Effect.op_Colon_Equals
-                                test_mod_ref test_mod';
-                              FStar_Compiler_Effect.op_Colon_Equals tcenv_ref
-                                (FStar_Pervasives_Native.Some tcenv');
-                              (let n = FStar_Errors.get_err_count () in
-                               if n <> Prims.int_zero
-                               then
-                                 (report ();
-                                  (let uu___7 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         FStar_Compiler_Util.string_of_int n in
-                                       FStar_Compiler_Util.format1
-                                         "%s errors were reported" uu___9 in
-                                     (FStar_Errors.Fatal_ErrorsReported,
-                                       uu___8) in
-                                   FStar_Errors.raise_err uu___7))
-                               else ())))) ()
-               with
-               | uu___2 ->
-                   (report ();
-                    FStar_Errors.raise_err
-                      (FStar_Errors.Fatal_TcOneFragmentFailed,
-                        (Prims.op_Hat "tc_one_fragment failed: " s))))) ()
-     with
-     | uu___1 ->
-         if
-           let uu___2 = FStar_Options.trace_error () in
-           Prims.op_Negation uu___2
-         then Obj.magic (Obj.repr (FStar_Compiler_Effect.raise uu___1))
-         else Obj.magic (Obj.repr (failwith "unreachable")))
-let (test_hashes : unit -> unit) =
-  fun uu___ ->
-    (let uu___2 = FStar_Main.process_args () in
-     FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()));
-    pars_and_tc_fragment "type unary_nat = | U0 | US of unary_nat";
-    (let test_one_hash n =
-       let rec aux n1 =
-         if n1 = Prims.int_zero
-         then "U0"
-         else
-           (let uu___4 =
-              let uu___5 = aux (n1 - Prims.int_one) in
-              Prims.op_Hat uu___5 ")" in
-            Prims.op_Hat "(US " uu___4) in
-       let tm = let uu___3 = aux n in tc uu___3 in
-       let hc = FStar_Syntax_Hash.ext_hash_term tm in
-       let uu___3 = FStar_Compiler_Util.string_of_int n in
-       let uu___4 = FStar_Hash.string_of_hash_code hc in
-       FStar_Compiler_Util.print2 "Hash of unary %s is %s\n" uu___3 uu___4 in
-     let rec aux n =
-       if n = Prims.int_zero
-       then ()
-       else (test_one_hash n; aux (n - Prims.int_one)) in
-     aux (Prims.of_int (100)); FStar_Options.init ())
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tests_Test.ml b/src/ocaml-output/FStar_Tests_Test.ml
deleted file mode 100644
index 2b2dcf9f2c9..00000000000
--- a/src/ocaml-output/FStar_Tests_Test.ml
+++ /dev/null
@@ -1,34 +0,0 @@
-open Prims
-let main : 'uuuuu 'uuuuu1 . 'uuuuu -> 'uuuuu1 =
-  fun argv ->
-    FStar_Compiler_Util.print_string "Initializing ...\n";
-    (try
-       (fun uu___1 ->
-          match () with
-          | () ->
-              (FStar_Main.setup_hooks ();
-               (let uu___4 = FStar_Tests_Pars.init () in
-                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                  (fun uu___5 -> ()));
-               FStar_Tests_Norm.run_all ();
-               (let uu___6 = FStar_Tests_Unif.run_all () in
-                if uu___6
-                then ()
-                else FStar_Compiler_Effect.exit Prims.int_one);
-               FStar_Compiler_Effect.exit Prims.int_zero)) ()
-     with
-     | FStar_Errors.Error (err, msg, r, _ctx) when
-         let uu___2 = FStar_Options.trace_error () in
-         FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___2 ->
-         (if r = FStar_Compiler_Range.dummyRange
-          then FStar_Compiler_Util.print_string msg
-          else
-            (let uu___4 = FStar_Compiler_Range.string_of_range r in
-             FStar_Compiler_Util.print2 "%s: %s\n" uu___4 msg);
-          FStar_Compiler_Effect.exit Prims.int_one)
-     | FStar_Errors.Err (raw_error, s, ls) when
-         let uu___2 = FStar_Options.trace_error () in
-         FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___2 ->
-         (FStar_Compiler_Util.print2 "%s : [%s]\n" s
-            (FStar_String.concat "; " ls);
-          FStar_Compiler_Effect.exit Prims.int_one))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tests_Unif.ml b/src/ocaml-output/FStar_Tests_Unif.ml
deleted file mode 100644
index 72f0be55ab1..00000000000
--- a/src/ocaml-output/FStar_Tests_Unif.ml
+++ /dev/null
@@ -1,578 +0,0 @@
-open Prims
-let (tcenv : unit -> FStar_TypeChecker_Env.env) =
-  fun uu___ -> FStar_Tests_Pars.init ()
-let (guard_to_string :
-  FStar_TypeChecker_Common.guard_formula -> Prims.string) =
-  fun g ->
-    match g with
-    | FStar_TypeChecker_Common.Trivial -> "trivial"
-    | FStar_TypeChecker_Common.NonTrivial f ->
-        let uu___ = tcenv () in
-        FStar_TypeChecker_Normalize.term_to_string uu___ f
-let (success : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref true
-let (fail : Prims.string -> unit) =
-  fun msg ->
-    FStar_Compiler_Util.print_string msg;
-    FStar_Compiler_Effect.op_Colon_Equals success false
-let (guard_eq :
-  Prims.int ->
-    FStar_TypeChecker_Common.guard_formula ->
-      FStar_TypeChecker_Common.guard_formula -> unit)
-  =
-  fun i ->
-    fun g ->
-      fun g' ->
-        let uu___ =
-          match (g, g') with
-          | (FStar_TypeChecker_Common.Trivial,
-             FStar_TypeChecker_Common.Trivial) -> (true, g, g')
-          | (FStar_TypeChecker_Common.NonTrivial f,
-             FStar_TypeChecker_Common.NonTrivial f') ->
-              let f1 =
-                let uu___1 = tcenv () in
-                FStar_TypeChecker_Normalize.normalize
-                  [FStar_TypeChecker_Env.EraseUniverses] uu___1 f in
-              let f'1 =
-                let uu___1 = tcenv () in
-                FStar_TypeChecker_Normalize.normalize
-                  [FStar_TypeChecker_Env.EraseUniverses] uu___1 f' in
-              let uu___1 = FStar_Tests_Util.term_eq f1 f'1 in
-              (uu___1, (FStar_TypeChecker_Common.NonTrivial f1),
-                (FStar_TypeChecker_Common.NonTrivial f'1))
-          | uu___1 -> (false, g, g') in
-        match uu___ with
-        | (b, g1, g'1) ->
-            (if Prims.op_Negation b
-             then
-               (let uu___2 =
-                  let uu___3 = FStar_Compiler_Util.string_of_int i in
-                  let uu___4 = guard_to_string g'1 in
-                  let uu___5 = guard_to_string g1 in
-                  FStar_Compiler_Util.format3
-                    "Test %s failed:\n\tExpected guard %s;\n\tGot guard      %s\n"
-                    uu___3 uu___4 uu___5 in
-                FStar_Compiler_Effect.op_Less_Bar fail uu___2)
-             else ();
-             (let uu___2 = (FStar_Compiler_Effect.op_Bang success) && b in
-              FStar_Compiler_Effect.op_Colon_Equals success uu___2))
-let (unify :
-  Prims.int ->
-    FStar_Syntax_Syntax.bv Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_TypeChecker_Common.guard_formula -> (unit -> unit) -> unit)
-  =
-  fun i ->
-    fun bvs ->
-      fun x ->
-        fun y ->
-          fun g' ->
-            fun check ->
-              (let uu___1 = FStar_Compiler_Util.string_of_int i in
-               FStar_Compiler_Util.print1 "%s ..." uu___1);
-              (let uu___2 = FStar_Main.process_args () in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()));
-              (let uu___3 = FStar_Syntax_Print.term_to_string x in
-               let uu___4 = FStar_Syntax_Print.term_to_string y in
-               FStar_Compiler_Util.print2 "Unify %s\nand %s\n" uu___3 uu___4);
-              (let tcenv1 = tcenv () in
-               let tcenv2 = FStar_TypeChecker_Env.push_bvs tcenv1 bvs in
-               let g =
-                 let uu___3 =
-                   let uu___4 = FStar_TypeChecker_Rel.teq tcenv2 x y in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___4
-                     (FStar_TypeChecker_Rel.solve_deferred_constraints tcenv2) in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                   (FStar_TypeChecker_Rel.simplify_guard tcenv2) in
-               guard_eq i g.FStar_TypeChecker_Common.guard_f g';
-               check ();
-               FStar_Options.init ())
-let (should_fail :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun x ->
-    fun y ->
-      try
-        (fun uu___ ->
-           match () with
-           | () ->
-               let g =
-                 let uu___1 =
-                   let uu___2 = tcenv () in
-                   FStar_TypeChecker_Rel.teq uu___2 x y in
-                 let uu___2 =
-                   let uu___3 = tcenv () in
-                   FStar_TypeChecker_Rel.solve_deferred_constraints uu___3 in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___1 uu___2 in
-               (match g.FStar_TypeChecker_Common.guard_f with
-                | FStar_TypeChecker_Common.Trivial ->
-                    let uu___1 =
-                      let uu___2 = FStar_Syntax_Print.term_to_string x in
-                      let uu___3 = FStar_Syntax_Print.term_to_string y in
-                      FStar_Compiler_Util.format2
-                        "%s and %s should not be unifiable\n" uu___2 uu___3 in
-                    fail uu___1
-                | FStar_TypeChecker_Common.NonTrivial f ->
-                    let uu___1 = FStar_Syntax_Print.term_to_string x in
-                    let uu___2 = FStar_Syntax_Print.term_to_string y in
-                    let uu___3 = FStar_Syntax_Print.term_to_string f in
-                    FStar_Compiler_Util.print3
-                      "%s and %s are unifiable if %s\n" uu___1 uu___2 uu___3))
-          ()
-      with
-      | FStar_Errors.Error (e, msg, r, _ctx) ->
-          FStar_Compiler_Util.print1 "%s\n" msg
-let (unify' : Prims.string -> Prims.string -> unit) =
-  fun x ->
-    fun y ->
-      let x1 = FStar_Tests_Pars.pars x in
-      let y1 = FStar_Tests_Pars.pars y in
-      let g =
-        let uu___ =
-          let uu___1 = tcenv () in FStar_TypeChecker_Rel.teq uu___1 x1 y1 in
-        let uu___1 =
-          let uu___2 = tcenv () in
-          FStar_TypeChecker_Rel.solve_deferred_constraints uu___2 in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ uu___1 in
-      let uu___ = FStar_Syntax_Print.term_to_string x1 in
-      let uu___1 = FStar_Syntax_Print.term_to_string y1 in
-      let uu___2 = guard_to_string g.FStar_TypeChecker_Common.guard_f in
-      FStar_Compiler_Util.print3 "%s and %s are unifiable with guard %s\n"
-        uu___ uu___1 uu___2
-let (norm : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ = tcenv () in FStar_TypeChecker_Normalize.normalize [] uu___ t
-let (check_core :
-  Prims.int ->
-    Prims.bool ->
-      Prims.bool ->
-        FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> unit)
-  =
-  fun i ->
-    fun subtyping ->
-      fun guard_ok ->
-        fun x ->
-          fun y ->
-            (let uu___1 = FStar_Main.process_args () in
-             FStar_Compiler_Effect.op_Bar_Greater uu___1 (fun uu___2 -> ()));
-            (let env = tcenv () in
-             let res =
-               if subtyping
-               then FStar_TypeChecker_Core.check_term_subtyping env x y
-               else FStar_TypeChecker_Core.check_term_equality env x y in
-             (match res with
-              | FStar_Pervasives.Inl (FStar_Pervasives_Native.None) ->
-                  let uu___2 = FStar_Compiler_Util.string_of_int i in
-                  FStar_Compiler_Util.print1 "%s core check ok\n" uu___2
-              | FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g) ->
-                  ((let uu___3 = FStar_Compiler_Util.string_of_int i in
-                    let uu___4 = FStar_Syntax_Print.term_to_string g in
-                    FStar_Compiler_Util.print2
-                      "%s core check computed guard %s ok\n" uu___3 uu___4);
-                   if Prims.op_Negation guard_ok
-                   then FStar_Compiler_Effect.op_Colon_Equals success false
-                   else ())
-              | FStar_Pervasives.Inr err ->
-                  (FStar_Compiler_Effect.op_Colon_Equals success false;
-                   (let uu___3 = FStar_Compiler_Util.string_of_int i in
-                    let uu___4 = FStar_TypeChecker_Core.print_error err in
-                    FStar_Compiler_Util.print2 "%s failed\n%s\n" uu___3
-                      uu___4)));
-             FStar_Options.init ())
-let (check_core_typing :
-  Prims.int -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.typ -> unit) =
-  fun i ->
-    fun e ->
-      fun t ->
-        (let uu___1 = FStar_Main.process_args () in
-         FStar_Compiler_Effect.op_Bar_Greater uu___1 (fun uu___2 -> ()));
-        (let env = tcenv () in
-         (let uu___2 = FStar_TypeChecker_Core.check_term env e t true in
-          match uu___2 with
-          | FStar_Pervasives.Inl (FStar_Pervasives_Native.None) ->
-              let uu___3 = FStar_Compiler_Util.string_of_int i in
-              FStar_Compiler_Util.print1 "%s core typing ok\n" uu___3
-          | FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g) ->
-              ((let uu___4 = FStar_Compiler_Util.string_of_int i in
-                FStar_Compiler_Util.print1
-                  "%s core typing produced a guard\n" uu___4);
-               FStar_Compiler_Effect.op_Colon_Equals success false)
-          | FStar_Pervasives.Inr err ->
-              (FStar_Compiler_Effect.op_Colon_Equals success false;
-               (let uu___4 = FStar_Compiler_Util.string_of_int i in
-                let uu___5 = FStar_TypeChecker_Core.print_error err in
-                FStar_Compiler_Util.print2 "%s failed\n%s\n" uu___4 uu___5)));
-         FStar_Options.init ())
-let (inst :
-  Prims.int ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term Prims.list))
-  =
-  fun n ->
-    fun tm ->
-      let rec aux out n1 =
-        if n1 = Prims.int_zero
-        then out
-        else
-          (let uu___1 =
-             let uu___2 = FStar_Tests_Pars.init () in
-             FStar_TypeChecker_Util.new_implicit_var ""
-               FStar_Compiler_Range.dummyRange uu___2
-               FStar_Syntax_Util.ktype0 in
-           match uu___1 with
-           | (t, uu___2, uu___3) ->
-               let uu___4 =
-                 let uu___5 = FStar_Tests_Pars.init () in
-                 FStar_TypeChecker_Util.new_implicit_var ""
-                   FStar_Compiler_Range.dummyRange uu___5 t in
-               (match uu___4 with
-                | (u, uu___5, uu___6) -> aux (u :: out) (n1 - Prims.int_one))) in
-      let us = aux [] n in
-      let uu___ = let uu___1 = FStar_Tests_Util.app tm us in norm uu___1 in
-      (uu___, us)
-let (run_all : unit -> Prims.bool) =
-  fun uu___ ->
-    FStar_Compiler_Util.print_string "Testing the unifier\n";
-    FStar_Options.__set_unit_tests ();
-    (let unify_check n bvs x y g f = unify n bvs x y g f in
-     let unify1 n bvs x y g = unify n bvs x y g (fun uu___3 -> ()) in
-     let int_t = FStar_Tests_Pars.tc "Prims.int" in
-     let x_bv =
-       FStar_Syntax_Syntax.gen_bv "x" FStar_Pervasives_Native.None int_t in
-     let y_bv =
-       FStar_Syntax_Syntax.gen_bv "y" FStar_Pervasives_Native.None int_t in
-     let x = FStar_Syntax_Syntax.bv_to_name x_bv in
-     let y = FStar_Syntax_Syntax.bv_to_name y_bv in
-     unify1 Prims.int_zero [x_bv] x x FStar_TypeChecker_Common.Trivial;
-     (let uu___5 =
-        let uu___6 =
-          FStar_Syntax_Util.mk_eq2 FStar_Syntax_Syntax.U_zero
-            FStar_Syntax_Util.t_bool x y in
-        FStar_TypeChecker_Common.NonTrivial uu___6 in
-      unify1 Prims.int_one [x_bv; y_bv] x y uu___5);
-     (let id = FStar_Tests_Pars.tc "fun (x:bool) -> x" in
-      (let uu___6 = FStar_Tests_Util.app id [x] in
-       unify1 (Prims.of_int (2)) [x_bv] x uu___6
-         FStar_TypeChecker_Common.Trivial);
-      (let id1 = FStar_Tests_Pars.tc "fun (x:bool) -> x" in
-       unify1 (Prims.of_int (3)) [] id1 id1 FStar_TypeChecker_Common.Trivial;
-       (let id2 = FStar_Tests_Pars.tc "fun (x:bool) -> x" in
-        let id' = FStar_Tests_Pars.tc "fun (y:bool) -> y" in
-        unify1 (Prims.of_int (4)) [] id2 id' FStar_TypeChecker_Common.Trivial;
-        (let uu___9 = FStar_Tests_Pars.tc "fun (x y:bool) -> x" in
-         let uu___10 = FStar_Tests_Pars.tc "fun (a b:bool) -> a" in
-         unify1 (Prims.of_int (5)) [] uu___9 uu___10
-           FStar_TypeChecker_Common.Trivial);
-        (let uu___10 = FStar_Tests_Pars.tc "fun (x y z:bool) -> y" in
-         let uu___11 = FStar_Tests_Pars.tc "fun (a b c:bool) -> b" in
-         unify1 (Prims.of_int (6)) [] uu___10 uu___11
-           FStar_TypeChecker_Common.Trivial);
-        (let uu___11 = FStar_Tests_Pars.tc "fun (x:int) (y:int) -> y" in
-         let uu___12 = FStar_Tests_Pars.tc "fun (x:int) (y:int) -> x" in
-         let uu___13 =
-           let uu___14 =
-             FStar_Tests_Pars.tc "(forall (x:int). (forall (y:int). y==x))" in
-           FStar_TypeChecker_Common.NonTrivial uu___14 in
-         unify1 (Prims.of_int (7)) [] uu___11 uu___12 uu___13);
-        (let uu___12 = FStar_Tests_Pars.tc "fun (x:int) (y:int) (z:int) -> y" in
-         let uu___13 = FStar_Tests_Pars.tc "fun (x:int) (y:int) (z:int) -> z" in
-         let uu___14 =
-           let uu___15 =
-             FStar_Tests_Pars.tc
-               "(forall (x:int). (forall (y:int). (forall (z:int). y==z)))" in
-           FStar_TypeChecker_Common.NonTrivial uu___15 in
-         unify1 (Prims.of_int (8)) [] uu___12 uu___13 uu___14);
-        (let uu___13 = FStar_Main.process_args () in
-         FStar_Compiler_Effect.op_Bar_Greater uu___13 (fun uu___14 -> ()));
-        (let uu___13 =
-           let uu___14 =
-             FStar_Tests_Pars.tc "fun (u:Type0 -> Type0) (x:Type0) -> u x" in
-           inst Prims.int_one uu___14 in
-         match uu___13 with
-         | (tm, us) ->
-             let sol = FStar_Tests_Pars.tc "fun (x:Type0) -> Prims.pair x x" in
-             ((let uu___15 =
-                 let uu___16 =
-                   FStar_Options.debug_at_level_no_module
-                     (FStar_Options.Other "Core") in
-                 FStar_Compiler_Util.string_of_bool uu___16 in
-               FStar_Compiler_Util.print1
-                 "Processed args: debug_at_level Core? %s\n" uu___15);
-              unify_check (Prims.of_int (9)) [] tm sol
-                FStar_TypeChecker_Common.Trivial
-                (fun uu___16 ->
-                   let uu___17 =
-                     let uu___18 =
-                       let uu___19 = FStar_Compiler_List.hd us in
-                       norm uu___19 in
-                     let uu___19 = norm sol in
-                     FStar_Tests_Util.term_eq uu___18 uu___19 in
-                   FStar_Tests_Util.always (Prims.of_int (9)) uu___17);
-              (let uu___16 =
-                 let uu___17 =
-                   FStar_Tests_Pars.tc
-                     "fun (u: int -> int -> int) (x:int) -> u x" in
-                 inst Prims.int_one uu___17 in
-               match uu___16 with
-               | (tm1, us1) ->
-                   let sol1 = FStar_Tests_Pars.tc "fun (x y:int) -> x + y" in
-                   (unify_check (Prims.of_int (10)) [] tm1 sol1
-                      FStar_TypeChecker_Common.Trivial
-                      (fun uu___18 ->
-                         let uu___19 =
-                           let uu___20 =
-                             let uu___21 = FStar_Compiler_List.hd us1 in
-                             norm uu___21 in
-                           let uu___21 = norm sol1 in
-                           FStar_Tests_Util.term_eq uu___20 uu___21 in
-                         FStar_Tests_Util.always (Prims.of_int (10)) uu___19);
-                    (let tm11 =
-                       FStar_Tests_Pars.tc "x:int -> y:int{eq2 y x} -> bool" in
-                     let tm2 = FStar_Tests_Pars.tc "x:int -> y:int -> bool" in
-                     (let uu___19 =
-                        let uu___20 =
-                          FStar_Tests_Pars.tc
-                            "forall (x:int). (forall (y:int). y==x)" in
-                        FStar_TypeChecker_Common.NonTrivial uu___20 in
-                      unify1 (Prims.of_int (11)) [] tm11 tm2 uu___19);
-                     (let tm12 =
-                        FStar_Tests_Pars.tc
-                          "a:Type0 -> b:(a -> Type0) -> x:a -> y:b x -> Tot Type0" in
-                      let tm21 =
-                        FStar_Tests_Pars.tc
-                          "a:Type0 -> b:(a -> Type0) -> x:a -> y:b x -> Tot Type0" in
-                      unify1 (Prims.of_int (12)) [] tm12 tm21
-                        FStar_TypeChecker_Common.Trivial;
-                      (let uu___20 =
-                         let int_typ = FStar_Tests_Pars.tc "int" in
-                         let x1 =
-                           FStar_Syntax_Syntax.new_bv
-                             FStar_Pervasives_Native.None int_typ in
-                         let typ = FStar_Tests_Pars.tc "unit -> Type0" in
-                         let l =
-                           FStar_Tests_Pars.tc
-                             "fun (q:(unit -> Type0)) -> q ()" in
-                         let q =
-                           FStar_Syntax_Syntax.new_bv
-                             FStar_Pervasives_Native.None typ in
-                         let tm13 =
-                           let uu___21 =
-                             let uu___22 =
-                               let uu___23 = FStar_Syntax_Syntax.bv_to_name q in
-                               [uu___23] in
-                             FStar_Tests_Util.app l uu___22 in
-                           norm uu___21 in
-                         let l1 =
-                           FStar_Tests_Pars.tc "fun (p:unit -> Type0) -> p" in
-                         let unit = FStar_Tests_Pars.tc "()" in
-                         let env =
-                           let uu___21 = FStar_Tests_Pars.init () in
-                           let uu___22 =
-                             let uu___23 = FStar_Syntax_Syntax.mk_binder x1 in
-                             let uu___24 =
-                               let uu___25 = FStar_Syntax_Syntax.mk_binder q in
-                               [uu___25] in
-                             uu___23 :: uu___24 in
-                           FStar_TypeChecker_Env.push_binders uu___21 uu___22 in
-                         let uu___21 =
-                           FStar_TypeChecker_Util.new_implicit_var ""
-                             FStar_Compiler_Range.dummyRange env typ in
-                         match uu___21 with
-                         | (u_p, uu___22, uu___23) ->
-                             let tm22 =
-                               let uu___24 =
-                                 let uu___25 = FStar_Tests_Util.app l1 [u_p] in
-                                 norm uu___25 in
-                               FStar_Tests_Util.app uu___24 [unit] in
-                             (tm13, tm22, [x1; q]) in
-                       match uu___20 with
-                       | (tm13, tm22, bvs_13) ->
-                           (unify1 (Prims.of_int (13)) bvs_13 tm13 tm22
-                              FStar_TypeChecker_Common.Trivial;
-                            (let uu___22 =
-                               let int_typ = FStar_Tests_Pars.tc "int" in
-                               let x1 =
-                                 FStar_Syntax_Syntax.new_bv
-                                   FStar_Pervasives_Native.None int_typ in
-                               let typ = FStar_Tests_Pars.tc "pure_post unit" in
-                               let l =
-                                 FStar_Tests_Pars.tc
-                                   "fun (q:pure_post unit) -> q ()" in
-                               let q =
-                                 FStar_Syntax_Syntax.new_bv
-                                   FStar_Pervasives_Native.None typ in
-                               let tm14 =
-                                 let uu___23 =
-                                   let uu___24 =
-                                     let uu___25 =
-                                       FStar_Syntax_Syntax.bv_to_name q in
-                                     [uu___25] in
-                                   FStar_Tests_Util.app l uu___24 in
-                                 norm uu___23 in
-                               let l1 =
-                                 FStar_Tests_Pars.tc
-                                   "fun (p:pure_post unit) -> p" in
-                               let unit = FStar_Tests_Pars.tc "()" in
-                               let env =
-                                 let uu___23 = FStar_Tests_Pars.init () in
-                                 let uu___24 =
-                                   let uu___25 =
-                                     FStar_Syntax_Syntax.mk_binder x1 in
-                                   let uu___26 =
-                                     let uu___27 =
-                                       FStar_Syntax_Syntax.mk_binder q in
-                                     [uu___27] in
-                                   uu___25 :: uu___26 in
-                                 FStar_TypeChecker_Env.push_binders uu___23
-                                   uu___24 in
-                               let uu___23 =
-                                 FStar_TypeChecker_Util.new_implicit_var ""
-                                   FStar_Compiler_Range.dummyRange env typ in
-                               match uu___23 with
-                               | (u_p, uu___24, uu___25) ->
-                                   let tm23 =
-                                     let uu___26 =
-                                       let uu___27 =
-                                         FStar_Tests_Util.app l1 [u_p] in
-                                       norm uu___27 in
-                                     FStar_Tests_Util.app uu___26 [unit] in
-                                   (tm14, tm23, [x1; q]) in
-                             match uu___22 with
-                             | (tm14, tm23, bvs_14) ->
-                                 (unify1 (Prims.of_int (14)) bvs_14 tm14 tm23
-                                    FStar_TypeChecker_Common.Trivial;
-                                  (let uu___24 =
-                                     FStar_Tests_Pars.pars_and_tc_fragment
-                                       "let ty0 n = x:int { x >= n }\nlet ty1 n = x:ty0 n { x > n }\nassume val tc (t:Type0) : Type0";
-                                     (let t0 = FStar_Tests_Pars.tc "ty1 17" in
-                                      let t1 =
-                                        FStar_Tests_Pars.tc
-                                          "x:ty0 17 { x > 17 }" in
-                                      (t0, t1)) in
-                                   match uu___24 with
-                                   | (tm15, tm24) ->
-                                       (check_core (Prims.of_int (15)) false
-                                          false tm15 tm24;
-                                        (let uu___26 =
-                                           let t0 =
-                                             FStar_Tests_Pars.tc
-                                               "x:int { x >= 17 /\\ x > 17 }" in
-                                           let t1 =
-                                             FStar_Tests_Pars.tc
-                                               "x:ty0 17 { x > 17 }" in
-                                           (t0, t1) in
-                                         match uu___26 with
-                                         | (tm16, tm25) ->
-                                             (check_core (Prims.of_int (16))
-                                                false false tm16 tm25;
-                                              (let uu___28 =
-                                                 FStar_Tests_Pars.pars_and_tc_fragment
-                                                   "let defn17_0 (x:nat) : nat -> nat -> Type0 = fun y z -> a:int { a + x == y + z }";
-                                                 (let t0 =
-                                                    FStar_Tests_Pars.tc
-                                                      "defn17_0 0 1 2" in
-                                                  let t1_head =
-                                                    FStar_Tests_Pars.tc
-                                                      "(defn17_0 0)" in
-                                                  let arg1 =
-                                                    FStar_Tests_Pars.tc "1" in
-                                                  let arg2 =
-                                                    FStar_Tests_Pars.tc "2" in
-                                                  let t1 =
-                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                      t1_head
-                                                      [(arg1,
-                                                         FStar_Pervasives_Native.None);
-                                                      (arg2,
-                                                        FStar_Pervasives_Native.None)]
-                                                      t0.FStar_Syntax_Syntax.pos in
-                                                  (t0, t1)) in
-                                               match uu___28 with
-                                               | (tm17, tm26) ->
-                                                   (check_core
-                                                      (Prims.of_int (17))
-                                                      false false tm17 tm26;
-                                                    (let uu___30 =
-                                                       let t0 =
-                                                         FStar_Tests_Pars.tc
-                                                           "dp:((dtuple2 int (fun (y:int) -> z:int{ z > y })) <: Type0) { let (| x, _ |) = dp in x > 17 }" in
-                                                       let t1 =
-                                                         FStar_Tests_Pars.tc
-                                                           "(dtuple2 int (fun (y:int) -> z:int{ z > y }))" in
-                                                       (t0, t1) in
-                                                     match uu___30 with
-                                                     | (tm18, tm27) ->
-                                                         (check_core
-                                                            (Prims.of_int (18))
-                                                            true false tm18
-                                                            tm27;
-                                                          (let uu___32 =
-                                                             FStar_Tests_Pars.pars_and_tc_fragment
-                                                               "type vprop' = { t:Type0 ; n:nat }";
-                                                             (let t0 =
-                                                                FStar_Tests_Pars.tc
-                                                                  "x:(({ t=bool; n=0 }).t <: Type0) { x == false }" in
-                                                              let t1 =
-                                                                FStar_Tests_Pars.tc
-                                                                  "x:bool{ x == false }" in
-                                                              (t0, t1)) in
-                                                           match uu___32 with
-                                                           | (tm19, tm28) ->
-                                                               (check_core
-                                                                  (Prims.of_int (19))
-                                                                  false false
-                                                                  tm19 tm28;
-                                                                (let uu___34
-                                                                   =
-                                                                   let t0 =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "int" in
-                                                                   let t1 =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "j:(i:nat{ i > 17 } <: Type0){j > 42}" in
-                                                                   (t0, t1) in
-                                                                 match uu___34
-                                                                 with
-                                                                 | (tm110,
-                                                                    tm29) ->
-                                                                    (check_core
-                                                                    (Prims.of_int (20))
-                                                                    true true
-                                                                    tm110
-                                                                    tm29;
-                                                                    (let uu___36
-                                                                    =
-                                                                    FStar_Tests_Pars.pars_and_tc_fragment
-                                                                    "assume val tstr21 (x:string) : Type0";
-                                                                    (
-                                                                    let t0 =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "(fun (x:bool) (y:int) (z: (fun (x:string) -> tstr21 x) \"hello\") -> x)" in
-                                                                    let ty =
-                                                                    FStar_Tests_Pars.tc
-                                                                    "bool -> int -> tstr21 \"hello\" -> bool" in
-                                                                    (t0, ty)) in
-                                                                    match uu___36
-                                                                    with
-                                                                    | 
-                                                                    (tm3, ty)
-                                                                    ->
-                                                                    (check_core_typing
-                                                                    (Prims.of_int (21))
-                                                                    tm3 ty;
-                                                                    FStar_Options.__clear_unit_tests
-                                                                    ();
-                                                                    (let uu___40
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bang
-                                                                    success in
-                                                                    if
-                                                                    uu___40
-                                                                    then
-                                                                    FStar_Compiler_Util.print_string
-                                                                    "Unifier ok\n"
-                                                                    else ());
-                                                                    FStar_Compiler_Effect.op_Bang
-                                                                    success))))))))))))))))))))))))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Tests_Util.ml b/src/ocaml-output/FStar_Tests_Util.ml
deleted file mode 100644
index 8e6a84c9e73..00000000000
--- a/src/ocaml-output/FStar_Tests_Util.ml
+++ /dev/null
@@ -1,262 +0,0 @@
-open Prims
-let (always : Prims.int -> Prims.bool -> unit) =
-  fun id ->
-    fun b ->
-      if b
-      then ()
-      else
-        (let uu___1 =
-           let uu___2 =
-             let uu___3 = FStar_Compiler_Util.string_of_int id in
-             FStar_Compiler_Util.format1 "Assertion failed: test %s" uu___3 in
-           (FStar_Errors.Fatal_AssertionFailure, uu___2) in
-         FStar_Errors.raise_error uu___1 FStar_Compiler_Range.dummyRange)
-let (x : FStar_Syntax_Syntax.bv) =
-  FStar_Syntax_Syntax.gen_bv "x" FStar_Pervasives_Native.None
-    FStar_Syntax_Syntax.tun
-let (y : FStar_Syntax_Syntax.bv) =
-  FStar_Syntax_Syntax.gen_bv "y" FStar_Pervasives_Native.None
-    FStar_Syntax_Syntax.tun
-let (n : FStar_Syntax_Syntax.bv) =
-  FStar_Syntax_Syntax.gen_bv "n" FStar_Pervasives_Native.None
-    FStar_Syntax_Syntax.tun
-let (h : FStar_Syntax_Syntax.bv) =
-  FStar_Syntax_Syntax.gen_bv "h" FStar_Pervasives_Native.None
-    FStar_Syntax_Syntax.tun
-let (m : FStar_Syntax_Syntax.bv) =
-  FStar_Syntax_Syntax.gen_bv "m" FStar_Pervasives_Native.None
-    FStar_Syntax_Syntax.tun
-let tm : 'uuuuu . 'uuuuu -> 'uuuuu FStar_Syntax_Syntax.syntax =
-  fun t -> FStar_Syntax_Syntax.mk t FStar_Compiler_Range.dummyRange
-let (nm : FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.term) =
-  fun x1 -> FStar_Syntax_Syntax.bv_to_name x1
-let (app :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun x1 ->
-    fun ts ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_Compiler_List.map FStar_Syntax_Syntax.as_arg ts in
-          (x1, uu___2) in
-        FStar_Syntax_Syntax.Tm_app uu___1 in
-      FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let rec (term_eq' :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> Prims.bool)
-  =
-  fun t1 ->
-    fun t2 ->
-      let t11 = FStar_Syntax_Subst.compress t1 in
-      let t21 = FStar_Syntax_Subst.compress t2 in
-      let binders_eq xs ys =
-        ((FStar_Compiler_List.length xs) = (FStar_Compiler_List.length ys))
-          &&
-          (FStar_Compiler_List.forall2
-             (fun x1 ->
-                fun y1 ->
-                  term_eq'
-                    (x1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                    (y1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)
-             xs ys) in
-      let args_eq xs ys =
-        ((FStar_Compiler_List.length xs) = (FStar_Compiler_List.length ys))
-          &&
-          (FStar_Compiler_List.forall2
-             (fun uu___ ->
-                fun uu___1 ->
-                  match (uu___, uu___1) with
-                  | ((a, imp), (b, imp')) ->
-                      (term_eq' a b) &&
-                        (let uu___2 = FStar_Syntax_Util.eq_aqual imp imp' in
-                         uu___2 = FStar_Syntax_Util.Equal)) xs ys) in
-      let comp_eq c d =
-        match ((c.FStar_Syntax_Syntax.n), (d.FStar_Syntax_Syntax.n)) with
-        | (FStar_Syntax_Syntax.Total t, FStar_Syntax_Syntax.Total s) ->
-            term_eq' t s
-        | (FStar_Syntax_Syntax.Comp ct1, FStar_Syntax_Syntax.Comp ct2) ->
-            ((FStar_Ident.lid_equals ct1.FStar_Syntax_Syntax.effect_name
-                ct2.FStar_Syntax_Syntax.effect_name)
-               &&
-               (term_eq' ct1.FStar_Syntax_Syntax.result_typ
-                  ct2.FStar_Syntax_Syntax.result_typ))
-              &&
-              (args_eq ct1.FStar_Syntax_Syntax.effect_args
-                 ct2.FStar_Syntax_Syntax.effect_args)
-        | uu___ -> false in
-      match ((t11.FStar_Syntax_Syntax.n), (t21.FStar_Syntax_Syntax.n)) with
-      | (FStar_Syntax_Syntax.Tm_lazy l, uu___) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bang
-                  FStar_Syntax_Syntax.lazy_chooser in
-              FStar_Compiler_Util.must uu___3 in
-            uu___2 l.FStar_Syntax_Syntax.lkind l in
-          term_eq' uu___1 t21
-      | (uu___, FStar_Syntax_Syntax.Tm_lazy l) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bang
-                  FStar_Syntax_Syntax.lazy_chooser in
-              FStar_Compiler_Util.must uu___3 in
-            uu___2 l.FStar_Syntax_Syntax.lkind l in
-          term_eq' t11 uu___1
-      | (FStar_Syntax_Syntax.Tm_bvar x1, FStar_Syntax_Syntax.Tm_bvar y1) ->
-          x1.FStar_Syntax_Syntax.index = y1.FStar_Syntax_Syntax.index
-      | (FStar_Syntax_Syntax.Tm_name x1, FStar_Syntax_Syntax.Tm_name y1) ->
-          FStar_Syntax_Syntax.bv_eq x1 y1
-      | (FStar_Syntax_Syntax.Tm_fvar f, FStar_Syntax_Syntax.Tm_fvar g) ->
-          FStar_Syntax_Syntax.fv_eq f g
-      | (FStar_Syntax_Syntax.Tm_uinst (t, uu___),
-         FStar_Syntax_Syntax.Tm_uinst (s, uu___1)) -> term_eq' t s
-      | (FStar_Syntax_Syntax.Tm_constant c1, FStar_Syntax_Syntax.Tm_constant
-         c2) -> FStar_Const.eq_const c1 c2
-      | (FStar_Syntax_Syntax.Tm_type u, FStar_Syntax_Syntax.Tm_type v) ->
-          u = v
-      | (FStar_Syntax_Syntax.Tm_abs (xs, t, uu___),
-         FStar_Syntax_Syntax.Tm_abs (ys, u, uu___1)) when
-          (FStar_Compiler_List.length xs) = (FStar_Compiler_List.length ys)
-          -> (binders_eq xs ys) && (term_eq' t u)
-      | (FStar_Syntax_Syntax.Tm_abs (xs, t, uu___),
-         FStar_Syntax_Syntax.Tm_abs (ys, u, uu___1)) ->
-          if
-            (FStar_Compiler_List.length xs) > (FStar_Compiler_List.length ys)
-          then
-            let uu___2 =
-              FStar_Compiler_Util.first_N (FStar_Compiler_List.length ys) xs in
-            (match uu___2 with
-             | (xs1, xs') ->
-                 let t12 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Syntax_Syntax.mk
-                           (FStar_Syntax_Syntax.Tm_abs
-                              (xs', t, FStar_Pervasives_Native.None))
-                           t11.FStar_Syntax_Syntax.pos in
-                       (xs1, uu___5, FStar_Pervasives_Native.None) in
-                     FStar_Syntax_Syntax.Tm_abs uu___4 in
-                   FStar_Syntax_Syntax.mk uu___3 t11.FStar_Syntax_Syntax.pos in
-                 term_eq' t12 t21)
-          else
-            (let uu___3 =
-               FStar_Compiler_Util.first_N (FStar_Compiler_List.length xs) ys in
-             match uu___3 with
-             | (ys1, ys') ->
-                 let t22 =
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Syntax_Syntax.mk
-                           (FStar_Syntax_Syntax.Tm_abs
-                              (ys', u, FStar_Pervasives_Native.None))
-                           t21.FStar_Syntax_Syntax.pos in
-                       (ys1, uu___6, FStar_Pervasives_Native.None) in
-                     FStar_Syntax_Syntax.Tm_abs uu___5 in
-                   FStar_Syntax_Syntax.mk uu___4 t21.FStar_Syntax_Syntax.pos in
-                 term_eq' t11 t22)
-      | (FStar_Syntax_Syntax.Tm_arrow (xs, c), FStar_Syntax_Syntax.Tm_arrow
-         (ys, d)) -> (binders_eq xs ys) && (comp_eq c d)
-      | (FStar_Syntax_Syntax.Tm_refine (x1, t), FStar_Syntax_Syntax.Tm_refine
-         (y1, u)) ->
-          (term_eq' x1.FStar_Syntax_Syntax.sort y1.FStar_Syntax_Syntax.sort)
-            && (term_eq' t u)
-      | (FStar_Syntax_Syntax.Tm_app
-         ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv_eq_1;
-            FStar_Syntax_Syntax.pos = uu___;
-            FStar_Syntax_Syntax.vars = uu___1;
-            FStar_Syntax_Syntax.hash_code = uu___2;_},
-          (uu___3, FStar_Pervasives_Native.Some
-           { FStar_Syntax_Syntax.aqual_implicit = true;
-             FStar_Syntax_Syntax.aqual_attributes = uu___4;_})::t12::t22::[]),
-         FStar_Syntax_Syntax.Tm_app
-         ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv_eq_2;
-            FStar_Syntax_Syntax.pos = uu___5;
-            FStar_Syntax_Syntax.vars = uu___6;
-            FStar_Syntax_Syntax.hash_code = uu___7;_},
-          (uu___8, FStar_Pervasives_Native.Some
-           { FStar_Syntax_Syntax.aqual_implicit = true;
-             FStar_Syntax_Syntax.aqual_attributes = uu___9;_})::s1::s2::[]))
-          when
-          (FStar_Syntax_Syntax.fv_eq_lid fv_eq_1 FStar_Parser_Const.eq2_lid)
-            &&
-            (FStar_Syntax_Syntax.fv_eq_lid fv_eq_2 FStar_Parser_Const.eq2_lid)
-          -> args_eq [s1; s2] [t12; t22]
-      | (FStar_Syntax_Syntax.Tm_app (t, args), FStar_Syntax_Syntax.Tm_app
-         (s, args')) -> (term_eq' t s) && (args_eq args args')
-      | (FStar_Syntax_Syntax.Tm_match
-         (t, FStar_Pervasives_Native.None, pats, uu___),
-         FStar_Syntax_Syntax.Tm_match
-         (t', FStar_Pervasives_Native.None, pats', uu___1)) ->
-          (((FStar_Compiler_List.length pats) =
-              (FStar_Compiler_List.length pats'))
-             &&
-             (FStar_Compiler_List.forall2
-                (fun uu___2 ->
-                   fun uu___3 ->
-                     match (uu___2, uu___3) with
-                     | ((uu___4, uu___5, e), (uu___6, uu___7, e')) ->
-                         term_eq' e e') pats pats'))
-            && (term_eq' t t')
-      | (FStar_Syntax_Syntax.Tm_ascribed
-         (t12, (FStar_Pervasives.Inl t22, uu___, uu___1), uu___2),
-         FStar_Syntax_Syntax.Tm_ascribed
-         (s1, (FStar_Pervasives.Inl s2, uu___3, uu___4), uu___5)) ->
-          (term_eq' t12 s1) && (term_eq' t22 s2)
-      | (FStar_Syntax_Syntax.Tm_let ((is_rec, lbs), t),
-         FStar_Syntax_Syntax.Tm_let ((is_rec', lbs'), s)) when
-          is_rec = is_rec' ->
-          (((FStar_Compiler_List.length lbs) =
-              (FStar_Compiler_List.length lbs'))
-             &&
-             (FStar_Compiler_List.forall2
-                (fun lb1 ->
-                   fun lb2 ->
-                     (term_eq' lb1.FStar_Syntax_Syntax.lbtyp
-                        lb2.FStar_Syntax_Syntax.lbtyp)
-                       &&
-                       (term_eq' lb1.FStar_Syntax_Syntax.lbdef
-                          lb2.FStar_Syntax_Syntax.lbdef)) lbs lbs'))
-            && (term_eq' t s)
-      | (FStar_Syntax_Syntax.Tm_uvar (u, uu___), FStar_Syntax_Syntax.Tm_uvar
-         (u', uu___1)) ->
-          FStar_Syntax_Unionfind.equiv u.FStar_Syntax_Syntax.ctx_uvar_head
-            u'.FStar_Syntax_Syntax.ctx_uvar_head
-      | (FStar_Syntax_Syntax.Tm_meta (t12, uu___), uu___1) ->
-          term_eq' t12 t21
-      | (uu___, FStar_Syntax_Syntax.Tm_meta (t22, uu___1)) ->
-          term_eq' t11 t22
-      | (FStar_Syntax_Syntax.Tm_delayed uu___, uu___1) ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.tag_of_term t11 in
-            let uu___4 = FStar_Syntax_Print.tag_of_term t21 in
-            FStar_Compiler_Util.format2 "Impossible: %s and %s" uu___3 uu___4 in
-          failwith uu___2
-      | (uu___, FStar_Syntax_Syntax.Tm_delayed uu___1) ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.tag_of_term t11 in
-            let uu___4 = FStar_Syntax_Print.tag_of_term t21 in
-            FStar_Compiler_Util.format2 "Impossible: %s and %s" uu___3 uu___4 in
-          failwith uu___2
-      | (FStar_Syntax_Syntax.Tm_unknown, FStar_Syntax_Syntax.Tm_unknown) ->
-          true
-      | uu___ -> false
-let (term_eq :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> Prims.bool)
-  =
-  fun t1 ->
-    fun t2 ->
-      let b = term_eq' t1 t2 in
-      if Prims.op_Negation b
-      then
-        (let uu___1 = FStar_Syntax_Print.term_to_string t1 in
-         let uu___2 = FStar_Syntax_Print.term_to_string t2 in
-         FStar_Compiler_Util.print2 ">>>>>>>>>>>Term %s is not equal to %s\n"
-           uu___1 uu___2)
-      else ();
-      b
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Thunk.ml b/src/ocaml-output/FStar_Thunk.ml
deleted file mode 100644
index aa8c96b3a03..00000000000
--- a/src/ocaml-output/FStar_Thunk.ml
+++ /dev/null
@@ -1,19 +0,0 @@
-open Prims
-type 'a thunk =
-  (unit -> 'a, 'a) FStar_Pervasives.either FStar_Compiler_Effect.ref
-type 'a t = 'a thunk
-let mk : 'a . (unit -> 'a) -> 'a thunk =
-  fun f -> FStar_Compiler_Effect.alloc (FStar_Pervasives.Inl f)
-let mkv : 'a . 'a -> 'a thunk =
-  fun v -> FStar_Compiler_Effect.alloc (FStar_Pervasives.Inr v)
-let force : 'a . 'a thunk -> 'a =
-  fun t1 ->
-    let uu___ = FStar_Compiler_Effect.op_Bang t1 in
-    match uu___ with
-    | FStar_Pervasives.Inr a1 -> a1
-    | FStar_Pervasives.Inl f ->
-        let a1 = f () in
-        (FStar_Compiler_Effect.op_Colon_Equals t1 (FStar_Pervasives.Inr a1);
-         a1)
-let map : 'a 'b . ('a -> 'b) -> 'a thunk -> 'b thunk =
-  fun f -> fun t1 -> mk (fun uu___ -> let uu___1 = force t1 in f uu___1)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_ToSyntax_Interleave.ml b/src/ocaml-output/FStar_ToSyntax_Interleave.ml
deleted file mode 100644
index 060ebfc66b4..00000000000
--- a/src/ocaml-output/FStar_ToSyntax_Interleave.ml
+++ /dev/null
@@ -1,601 +0,0 @@
-open Prims
-let (id_eq_lid : FStar_Ident.ident -> FStar_Ident.lident -> Prims.bool) =
-  fun i ->
-    fun l ->
-      let uu___ = FStar_Ident.string_of_id i in
-      let uu___1 =
-        let uu___2 = FStar_Ident.ident_of_lid l in
-        FStar_Ident.string_of_id uu___2 in
-      uu___ = uu___1
-let (is_val : FStar_Ident.ident -> FStar_Parser_AST.decl -> Prims.bool) =
-  fun x ->
-    fun d ->
-      match d.FStar_Parser_AST.d with
-      | FStar_Parser_AST.Val (y, uu___) ->
-          let uu___1 = FStar_Ident.string_of_id x in
-          let uu___2 = FStar_Ident.string_of_id y in uu___1 = uu___2
-      | uu___ -> false
-let (is_type : FStar_Ident.ident -> FStar_Parser_AST.decl -> Prims.bool) =
-  fun x ->
-    fun d ->
-      match d.FStar_Parser_AST.d with
-      | FStar_Parser_AST.Tycon (uu___, uu___1, tys) ->
-          FStar_Compiler_Effect.op_Bar_Greater tys
-            (FStar_Compiler_Util.for_some
-               (fun t ->
-                  let uu___2 = FStar_Parser_AST.id_of_tycon t in
-                  let uu___3 = FStar_Ident.string_of_id x in uu___2 = uu___3))
-      | uu___ -> false
-let (definition_lids :
-  FStar_Parser_AST.decl -> FStar_Ident.lident Prims.list) =
-  fun d ->
-    match d.FStar_Parser_AST.d with
-    | FStar_Parser_AST.TopLevelLet (uu___, defs) ->
-        FStar_Parser_AST.lids_of_let defs
-    | FStar_Parser_AST.Tycon (uu___, uu___1, tys) ->
-        FStar_Compiler_Effect.op_Bar_Greater tys
-          (FStar_Compiler_List.collect
-             (fun uu___2 ->
-                match uu___2 with
-                | FStar_Parser_AST.TyconAbbrev (id, uu___3, uu___4, uu___5)
-                    -> let uu___6 = FStar_Ident.lid_of_ids [id] in [uu___6]
-                | FStar_Parser_AST.TyconRecord
-                    (id, uu___3, uu___4, uu___5, uu___6) ->
-                    let uu___7 = FStar_Ident.lid_of_ids [id] in [uu___7]
-                | FStar_Parser_AST.TyconVariant (id, uu___3, uu___4, uu___5)
-                    -> let uu___6 = FStar_Ident.lid_of_ids [id] in [uu___6]
-                | uu___3 -> []))
-    | uu___ -> []
-let (is_definition_of :
-  FStar_Ident.ident -> FStar_Parser_AST.decl -> Prims.bool) =
-  fun x ->
-    fun d ->
-      let uu___ = definition_lids d in
-      FStar_Compiler_Util.for_some (id_eq_lid x) uu___
-let rec (prefix_with_iface_decls :
-  FStar_Parser_AST.decl Prims.list ->
-    FStar_Parser_AST.decl ->
-      (FStar_Parser_AST.decl Prims.list * FStar_Parser_AST.decl Prims.list))
-  =
-  fun iface ->
-    fun impl ->
-      let qualify_karamel_private impl1 =
-        let karamel_private =
-          FStar_Parser_AST.mk_term
-            (FStar_Parser_AST.Const
-               (FStar_Const.Const_string
-                  ("KrmlPrivate", (impl1.FStar_Parser_AST.drange))))
-            impl1.FStar_Parser_AST.drange FStar_Parser_AST.Expr in
-        {
-          FStar_Parser_AST.d = (impl1.FStar_Parser_AST.d);
-          FStar_Parser_AST.drange = (impl1.FStar_Parser_AST.drange);
-          FStar_Parser_AST.quals = (impl1.FStar_Parser_AST.quals);
-          FStar_Parser_AST.attrs = (karamel_private ::
-            (impl1.FStar_Parser_AST.attrs))
-        } in
-      match iface with
-      | [] -> ([], [qualify_karamel_private impl])
-      | iface_hd::iface_tl ->
-          (match iface_hd.FStar_Parser_AST.d with
-           | FStar_Parser_AST.Tycon (uu___, uu___1, tys) when
-               FStar_Compiler_Effect.op_Bar_Greater tys
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___2 ->
-                       match uu___2 with
-                       | FStar_Parser_AST.TyconAbstract uu___3 -> true
-                       | uu___3 -> false))
-               ->
-               FStar_Errors.raise_error
-                 (FStar_Errors.Fatal_AbstractTypeDeclarationInInterface,
-                   "Interface contains an abstract 'type' declaration; use 'val' instead")
-                 impl.FStar_Parser_AST.drange
-           | FStar_Parser_AST.Val (x, t) ->
-               let def_ids = definition_lids impl in
-               let defines_x =
-                 FStar_Compiler_Util.for_some (id_eq_lid x) def_ids in
-               if Prims.op_Negation defines_x
-               then
-                 let uu___ =
-                   FStar_Compiler_Effect.op_Bar_Greater def_ids
-                     (FStar_Compiler_Util.for_some
-                        (fun y ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = FStar_Ident.ident_of_lid y in
-                               is_val uu___3 in
-                             FStar_Compiler_Util.for_some uu___2 in
-                           FStar_Compiler_Effect.op_Bar_Greater iface_tl
-                             uu___1)) in
-                 (if uu___
-                  then
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = FStar_Ident.string_of_id x in
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_Compiler_Effect.op_Bar_Greater def_ids
-                              (FStar_Compiler_List.map
-                                 FStar_Ident.string_of_lid) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            (FStar_String.concat ", ") in
-                        FStar_Compiler_Util.format2
-                          "Expected the definition of %s to precede %s"
-                          uu___3 uu___4 in
-                      (FStar_Errors.Fatal_WrongDefinitionOrder, uu___2) in
-                    FStar_Errors.raise_error uu___1
-                      impl.FStar_Parser_AST.drange
-                  else (iface, [qualify_karamel_private impl]))
-               else
-                 (let mutually_defined_with_x =
-                    FStar_Compiler_Effect.op_Bar_Greater def_ids
-                      (FStar_Compiler_List.filter
-                         (fun y ->
-                            let uu___1 = id_eq_lid x y in
-                            Prims.op_Negation uu___1)) in
-                  let rec aux mutuals iface1 =
-                    match (mutuals, iface1) with
-                    | ([], uu___1) -> ([], iface1)
-                    | (uu___1::uu___2, []) -> ([], [])
-                    | (y::ys, iface_hd1::iface_tl1) ->
-                        let uu___1 =
-                          let uu___2 = FStar_Ident.ident_of_lid y in
-                          is_val uu___2 iface_hd1 in
-                        if uu___1
-                        then
-                          let uu___2 = aux ys iface_tl1 in
-                          (match uu___2 with
-                           | (val_ys, iface2) ->
-                               ((iface_hd1 :: val_ys), iface2))
-                        else
-                          (let uu___3 =
-                             let uu___4 =
-                               let uu___5 =
-                                 let uu___6 = FStar_Ident.ident_of_lid y in
-                                 is_val uu___6 in
-                               FStar_Compiler_List.tryFind uu___5 iface_tl1 in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               FStar_Compiler_Option.isSome uu___4 in
-                           if uu___3
-                           then
-                             let uu___4 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Parser_AST.decl_to_string iface_hd1 in
-                                 let uu___7 = FStar_Ident.string_of_lid y in
-                                 FStar_Compiler_Util.format2
-                                   "%s is out of order with the definition of %s"
-                                   uu___6 uu___7 in
-                               (FStar_Errors.Fatal_WrongDefinitionOrder,
-                                 uu___5) in
-                             FStar_Errors.raise_error uu___4
-                               iface_hd1.FStar_Parser_AST.drange
-                           else aux ys iface1) in
-                  let uu___1 = aux mutually_defined_with_x iface_tl in
-                  match uu___1 with
-                  | (take_iface, rest_iface) ->
-                      (rest_iface,
-                        (FStar_Compiler_List.op_At (iface_hd :: take_iface)
-                           [impl])))
-           | FStar_Parser_AST.Pragma uu___ ->
-               prefix_with_iface_decls iface_tl impl
-           | uu___ ->
-               let uu___1 = prefix_with_iface_decls iface_tl impl in
-               (match uu___1 with
-                | (iface1, ds) -> (iface1, (iface_hd :: ds))))
-let (check_initial_interface :
-  FStar_Parser_AST.decl Prims.list -> FStar_Parser_AST.decl Prims.list) =
-  fun iface ->
-    let rec aux iface1 =
-      match iface1 with
-      | [] -> ()
-      | hd::tl ->
-          (match hd.FStar_Parser_AST.d with
-           | FStar_Parser_AST.Tycon (uu___, uu___1, tys) when
-               FStar_Compiler_Effect.op_Bar_Greater tys
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___2 ->
-                       match uu___2 with
-                       | FStar_Parser_AST.TyconAbstract uu___3 -> true
-                       | uu___3 -> false))
-               ->
-               FStar_Errors.raise_error
-                 (FStar_Errors.Fatal_AbstractTypeDeclarationInInterface,
-                   "Interface contains an abstract 'type' declaration; use 'val' instead")
-                 hd.FStar_Parser_AST.drange
-           | FStar_Parser_AST.Val (x, t) ->
-               let uu___ =
-                 FStar_Compiler_Util.for_some (is_definition_of x) tl in
-               if uu___
-               then
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Ident.string_of_id x in
-                     let uu___4 = FStar_Ident.string_of_id x in
-                     FStar_Compiler_Util.format2
-                       "'val %s' and 'let %s' cannot both be provided in an interface"
-                       uu___3 uu___4 in
-                   (FStar_Errors.Fatal_BothValAndLetInInterface, uu___2) in
-                 FStar_Errors.raise_error uu___1 hd.FStar_Parser_AST.drange
-               else
-                 (let uu___2 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      hd.FStar_Parser_AST.quals
-                      (FStar_Compiler_List.contains
-                         FStar_Parser_AST.Assumption) in
-                  if uu___2
-                  then
-                    FStar_Errors.raise_error
-                      (FStar_Errors.Fatal_AssumeValInInterface,
-                        "Interfaces cannot use `assume val x : t`; just write `val x : t` instead")
-                      hd.FStar_Parser_AST.drange
-                  else ())
-           | uu___ -> ()) in
-    aux iface;
-    FStar_Compiler_Effect.op_Bar_Greater iface
-      (FStar_Compiler_List.filter
-         (fun d ->
-            match d.FStar_Parser_AST.d with
-            | FStar_Parser_AST.TopLevelModule uu___1 -> false
-            | uu___1 -> true))
-let (ml_mode_prefix_with_iface_decls :
-  FStar_Parser_AST.decl Prims.list ->
-    FStar_Parser_AST.decl ->
-      (FStar_Parser_AST.decl Prims.list * FStar_Parser_AST.decl Prims.list))
-  =
-  fun iface ->
-    fun impl ->
-      match impl.FStar_Parser_AST.d with
-      | FStar_Parser_AST.TopLevelModule uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.span
-              (fun d ->
-                 match d.FStar_Parser_AST.d with
-                 | FStar_Parser_AST.Open uu___2 -> true
-                 | FStar_Parser_AST.ModuleAbbrev uu___2 -> true
-                 | uu___2 -> false) iface in
-          (match uu___1 with
-           | (iface_prefix_opens, iface1) ->
-               let iface2 =
-                 FStar_Compiler_List.filter
-                   (fun d ->
-                      match d.FStar_Parser_AST.d with
-                      | FStar_Parser_AST.Val uu___2 -> true
-                      | FStar_Parser_AST.Tycon uu___2 -> true
-                      | uu___2 -> false) iface1 in
-               (iface2,
-                 (FStar_Compiler_List.op_At [impl] iface_prefix_opens)))
-      | FStar_Parser_AST.Open uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.span
-              (fun d ->
-                 match d.FStar_Parser_AST.d with
-                 | FStar_Parser_AST.Open uu___2 -> true
-                 | FStar_Parser_AST.ModuleAbbrev uu___2 -> true
-                 | uu___2 -> false) iface in
-          (match uu___1 with
-           | (iface_prefix_opens, iface1) ->
-               let iface2 =
-                 FStar_Compiler_List.filter
-                   (fun d ->
-                      match d.FStar_Parser_AST.d with
-                      | FStar_Parser_AST.Val uu___2 -> true
-                      | FStar_Parser_AST.Tycon uu___2 -> true
-                      | uu___2 -> false) iface1 in
-               (iface2,
-                 (FStar_Compiler_List.op_At [impl] iface_prefix_opens)))
-      | FStar_Parser_AST.Friend uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.span
-              (fun d ->
-                 match d.FStar_Parser_AST.d with
-                 | FStar_Parser_AST.Open uu___2 -> true
-                 | FStar_Parser_AST.ModuleAbbrev uu___2 -> true
-                 | uu___2 -> false) iface in
-          (match uu___1 with
-           | (iface_prefix_opens, iface1) ->
-               let iface2 =
-                 FStar_Compiler_List.filter
-                   (fun d ->
-                      match d.FStar_Parser_AST.d with
-                      | FStar_Parser_AST.Val uu___2 -> true
-                      | FStar_Parser_AST.Tycon uu___2 -> true
-                      | uu___2 -> false) iface1 in
-               (iface2,
-                 (FStar_Compiler_List.op_At [impl] iface_prefix_opens)))
-      | FStar_Parser_AST.Include uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.span
-              (fun d ->
-                 match d.FStar_Parser_AST.d with
-                 | FStar_Parser_AST.Open uu___2 -> true
-                 | FStar_Parser_AST.ModuleAbbrev uu___2 -> true
-                 | uu___2 -> false) iface in
-          (match uu___1 with
-           | (iface_prefix_opens, iface1) ->
-               let iface2 =
-                 FStar_Compiler_List.filter
-                   (fun d ->
-                      match d.FStar_Parser_AST.d with
-                      | FStar_Parser_AST.Val uu___2 -> true
-                      | FStar_Parser_AST.Tycon uu___2 -> true
-                      | uu___2 -> false) iface1 in
-               (iface2,
-                 (FStar_Compiler_List.op_At [impl] iface_prefix_opens)))
-      | FStar_Parser_AST.ModuleAbbrev uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.span
-              (fun d ->
-                 match d.FStar_Parser_AST.d with
-                 | FStar_Parser_AST.Open uu___2 -> true
-                 | FStar_Parser_AST.ModuleAbbrev uu___2 -> true
-                 | uu___2 -> false) iface in
-          (match uu___1 with
-           | (iface_prefix_opens, iface1) ->
-               let iface2 =
-                 FStar_Compiler_List.filter
-                   (fun d ->
-                      match d.FStar_Parser_AST.d with
-                      | FStar_Parser_AST.Val uu___2 -> true
-                      | FStar_Parser_AST.Tycon uu___2 -> true
-                      | uu___2 -> false) iface1 in
-               (iface2,
-                 (FStar_Compiler_List.op_At [impl] iface_prefix_opens)))
-      | uu___ ->
-          let uu___1 =
-            FStar_Compiler_List.span
-              (fun d ->
-                 match d.FStar_Parser_AST.d with
-                 | FStar_Parser_AST.Tycon uu___2 -> true
-                 | uu___2 -> false) iface in
-          (match uu___1 with
-           | (iface_prefix_tycons, iface1) ->
-               let maybe_get_iface_vals lids iface2 =
-                 FStar_Compiler_List.partition
-                   (fun d ->
-                      FStar_Compiler_Effect.op_Bar_Greater lids
-                        (FStar_Compiler_Util.for_some
-                           (fun x ->
-                              let uu___2 = FStar_Ident.ident_of_lid x in
-                              is_val uu___2 d))) iface2 in
-               (match impl.FStar_Parser_AST.d with
-                | FStar_Parser_AST.TopLevelLet uu___2 ->
-                    let xs = definition_lids impl in
-                    let uu___3 = maybe_get_iface_vals xs iface1 in
-                    (match uu___3 with
-                     | (val_xs, rest_iface) ->
-                         (rest_iface,
-                           (FStar_Compiler_List.op_At iface_prefix_tycons
-                              (FStar_Compiler_List.op_At val_xs [impl]))))
-                | FStar_Parser_AST.Tycon uu___2 ->
-                    let xs = definition_lids impl in
-                    let uu___3 = maybe_get_iface_vals xs iface1 in
-                    (match uu___3 with
-                     | (val_xs, rest_iface) ->
-                         (rest_iface,
-                           (FStar_Compiler_List.op_At iface_prefix_tycons
-                              (FStar_Compiler_List.op_At val_xs [impl]))))
-                | uu___2 ->
-                    (iface1,
-                      (FStar_Compiler_List.op_At iface_prefix_tycons [impl]))))
-let ml_mode_check_initial_interface :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Parser_AST.decl Prims.list -> FStar_Parser_AST.decl Prims.list
-  =
-  fun mname ->
-    fun iface ->
-      FStar_Compiler_Effect.op_Bar_Greater iface
-        (FStar_Compiler_List.filter
-           (fun d ->
-              match d.FStar_Parser_AST.d with
-              | FStar_Parser_AST.Tycon (uu___, uu___1, tys) when
-                  FStar_Compiler_Effect.op_Bar_Greater tys
-                    (FStar_Compiler_Util.for_some
-                       (fun uu___2 ->
-                          match uu___2 with
-                          | FStar_Parser_AST.TyconAbstract uu___3 -> true
-                          | uu___3 -> false))
-                  ->
-                  FStar_Errors.raise_error
-                    (FStar_Errors.Fatal_AbstractTypeDeclarationInInterface,
-                      "Interface contains an abstract 'type' declaration; use 'val' instead")
-                    d.FStar_Parser_AST.drange
-              | FStar_Parser_AST.Tycon uu___ -> true
-              | FStar_Parser_AST.Val uu___ -> true
-              | FStar_Parser_AST.Open uu___ -> true
-              | FStar_Parser_AST.ModuleAbbrev uu___ -> true
-              | uu___ -> false))
-let (ulib_modules : Prims.string Prims.list) =
-  ["FStar.Calc";
-  "FStar.TSet";
-  "FStar.Seq.Base";
-  "FStar.Seq.Properties";
-  "FStar.UInt";
-  "FStar.UInt8";
-  "FStar.UInt16";
-  "FStar.UInt32";
-  "FStar.UInt64";
-  "FStar.Int";
-  "FStar.Int8";
-  "FStar.Int16";
-  "FStar.Int32";
-  "FStar.Int64"]
-let (apply_ml_mode_optimizations : FStar_Ident.lident -> Prims.bool) =
-  fun mname ->
-    ((FStar_Options.ml_ish ()) &&
-       (let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid mname in
-          FStar_Compiler_List.contains uu___1 FStar_Parser_Dep.core_modules in
-        Prims.op_Negation uu___))
-      &&
-      (let uu___ =
-         let uu___1 = FStar_Ident.string_of_lid mname in
-         FStar_Compiler_List.contains uu___1 ulib_modules in
-       Prims.op_Negation uu___)
-let (prefix_one_decl :
-  FStar_Ident.lident ->
-    FStar_Parser_AST.decl Prims.list ->
-      FStar_Parser_AST.decl ->
-        (FStar_Parser_AST.decl Prims.list * FStar_Parser_AST.decl Prims.list))
-  =
-  fun mname ->
-    fun iface ->
-      fun impl ->
-        match impl.FStar_Parser_AST.d with
-        | FStar_Parser_AST.TopLevelModule uu___ -> (iface, [impl])
-        | uu___ ->
-            let uu___1 = apply_ml_mode_optimizations mname in
-            if uu___1
-            then ml_mode_prefix_with_iface_decls iface impl
-            else prefix_with_iface_decls iface impl
-let (initialize_interface :
-  FStar_Ident.lident ->
-    FStar_Parser_AST.decl Prims.list -> unit FStar_Syntax_DsEnv.withenv)
-  =
-  fun mname ->
-    fun l ->
-      fun env ->
-        let decls =
-          let uu___ = apply_ml_mode_optimizations mname in
-          if uu___
-          then ml_mode_check_initial_interface mname l
-          else check_initial_interface l in
-        let uu___ = FStar_Syntax_DsEnv.iface_decls env mname in
-        match uu___ with
-        | FStar_Pervasives_Native.Some uu___1 ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Ident.string_of_lid mname in
-                FStar_Compiler_Util.format1
-                  "Interface %s has already been processed" uu___4 in
-              (FStar_Errors.Fatal_InterfaceAlreadyProcessed, uu___3) in
-            let uu___3 = FStar_Ident.range_of_lid mname in
-            FStar_Errors.raise_error uu___2 uu___3
-        | FStar_Pervasives_Native.None ->
-            let uu___1 = FStar_Syntax_DsEnv.set_iface_decls env mname decls in
-            ((), uu___1)
-let (prefix_with_interface_decls :
-  FStar_Ident.lident ->
-    FStar_Parser_AST.decl ->
-      FStar_Parser_AST.decl Prims.list FStar_Syntax_DsEnv.withenv)
-  =
-  fun mname ->
-    fun impl ->
-      fun env ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Syntax_DsEnv.current_module env in
-            FStar_Syntax_DsEnv.iface_decls env uu___2 in
-          match uu___1 with
-          | FStar_Pervasives_Native.None -> ([impl], env)
-          | FStar_Pervasives_Native.Some iface ->
-              let uu___2 = prefix_one_decl mname iface impl in
-              (match uu___2 with
-               | (iface1, impl1) ->
-                   let env1 =
-                     let uu___3 = FStar_Syntax_DsEnv.current_module env in
-                     FStar_Syntax_DsEnv.set_iface_decls env uu___3 iface1 in
-                   (impl1, env1)) in
-        match uu___ with
-        | (decls, env1) ->
-            ((let uu___2 =
-                let uu___3 = FStar_Ident.string_of_lid mname in
-                FStar_Options.dump_module uu___3 in
-              if uu___2
-              then
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Compiler_List.map FStar_Parser_AST.decl_to_string
-                      decls in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (FStar_String.concat "\n") in
-                FStar_Compiler_Util.print1 "Interleaved decls:\n%s\n" uu___3
-              else ());
-             (decls, env1))
-let (interleave_module :
-  FStar_Parser_AST.modul ->
-    Prims.bool -> FStar_Parser_AST.modul FStar_Syntax_DsEnv.withenv)
-  =
-  fun a ->
-    fun expect_complete_modul ->
-      fun env ->
-        match a with
-        | FStar_Parser_AST.Interface uu___ -> (a, env)
-        | FStar_Parser_AST.Module (l, impls) ->
-            let uu___ = FStar_Syntax_DsEnv.iface_decls env l in
-            (match uu___ with
-             | FStar_Pervasives_Native.None -> (a, env)
-             | FStar_Pervasives_Native.Some iface ->
-                 let uu___1 =
-                   FStar_Compiler_List.fold_left
-                     (fun uu___2 ->
-                        fun impl ->
-                          match uu___2 with
-                          | (iface1, impls1) ->
-                              let uu___3 = prefix_one_decl l iface1 impl in
-                              (match uu___3 with
-                               | (iface2, impls') ->
-                                   (iface2,
-                                     (FStar_Compiler_List.op_At impls1 impls'))))
-                     (iface, []) impls in
-                 (match uu___1 with
-                  | (iface1, impls1) ->
-                      let uu___2 =
-                        let uu___3 =
-                          FStar_Compiler_Util.prefix_until
-                            (fun uu___4 ->
-                               match uu___4 with
-                               | {
-                                   FStar_Parser_AST.d = FStar_Parser_AST.Val
-                                     uu___5;
-                                   FStar_Parser_AST.drange = uu___6;
-                                   FStar_Parser_AST.quals = uu___7;
-                                   FStar_Parser_AST.attrs = uu___8;_} -> true
-                               | uu___5 -> false) iface1 in
-                        match uu___3 with
-                        | FStar_Pervasives_Native.None -> (iface1, [])
-                        | FStar_Pervasives_Native.Some (lets, one_val, rest)
-                            -> (lets, (one_val :: rest)) in
-                      (match uu___2 with
-                       | (iface_lets, remaining_iface_vals) ->
-                           let impls2 =
-                             FStar_Compiler_List.op_At impls1 iface_lets in
-                           let env1 =
-                             let uu___3 = FStar_Options.interactive () in
-                             if uu___3
-                             then
-                               FStar_Syntax_DsEnv.set_iface_decls env l
-                                 remaining_iface_vals
-                             else env in
-                           let a1 = FStar_Parser_AST.Module (l, impls2) in
-                           (match remaining_iface_vals with
-                            | uu___3::uu___4 when expect_complete_modul ->
-                                let err =
-                                  let uu___5 =
-                                    FStar_Compiler_List.map
-                                      FStar_Parser_AST.decl_to_string
-                                      remaining_iface_vals in
-                                  FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                    (FStar_String.concat "\n\t") in
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 = FStar_Ident.string_of_lid l in
-                                    FStar_Compiler_Util.format2
-                                      "Some interface elements were not implemented by module %s:\n\t%s"
-                                      uu___7 err in
-                                  (FStar_Errors.Fatal_InterfaceNotImplementedByModule,
-                                    uu___6) in
-                                let uu___6 = FStar_Ident.range_of_lid l in
-                                FStar_Errors.raise_error uu___5 uu___6
-                            | uu___3 ->
-                                ((let uu___5 =
-                                    let uu___6 = FStar_Ident.string_of_lid l in
-                                    FStar_Options.dump_module uu___6 in
-                                  if uu___5
-                                  then
-                                    let uu___6 =
-                                      FStar_Parser_AST.modul_to_string a1 in
-                                    FStar_Compiler_Util.print1
-                                      "Interleaved module is:\n%s\n" uu___6
-                                  else ());
-                                 (a1, env1))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_ToSyntax_ToSyntax.ml b/src/ocaml-output/FStar_ToSyntax_ToSyntax.ml
deleted file mode 100644
index 06de284952c..00000000000
--- a/src/ocaml-output/FStar_ToSyntax_ToSyntax.ml
+++ /dev/null
@@ -1,9373 +0,0 @@
-open Prims
-let (tun_r : FStar_Compiler_Range.range -> FStar_Syntax_Syntax.term) =
-  fun r ->
-    {
-      FStar_Syntax_Syntax.n = (FStar_Syntax_Syntax.tun.FStar_Syntax_Syntax.n);
-      FStar_Syntax_Syntax.pos = r;
-      FStar_Syntax_Syntax.vars =
-        (FStar_Syntax_Syntax.tun.FStar_Syntax_Syntax.vars);
-      FStar_Syntax_Syntax.hash_code =
-        (FStar_Syntax_Syntax.tun.FStar_Syntax_Syntax.hash_code)
-    }
-type annotated_pat =
-  (FStar_Syntax_Syntax.pat * (FStar_Syntax_Syntax.bv *
-    FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.term Prims.list)
-    Prims.list)
-let (mk_thunk :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun e ->
-    let b =
-      let uu___ =
-        FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-          FStar_Syntax_Syntax.tun in
-      FStar_Syntax_Syntax.mk_binder uu___ in
-    FStar_Syntax_Util.abs [b] e FStar_Pervasives_Native.None
-let (qualify_field_names :
-  FStar_Ident.lident ->
-    FStar_Ident.lident Prims.list -> FStar_Ident.lident Prims.list)
-  =
-  fun record_or_dc_lid ->
-    fun field_names ->
-      let qualify_to_record l =
-        let ns = FStar_Ident.ns_of_lid record_or_dc_lid in
-        let uu___ = FStar_Ident.ident_of_lid l in
-        FStar_Ident.lid_of_ns_and_id ns uu___ in
-      let uu___ =
-        FStar_Compiler_List.fold_left
-          (fun uu___1 ->
-             fun l ->
-               match uu___1 with
-               | (ns_opt, out) ->
-                   let uu___2 = FStar_Ident.nsstr l in
-                   (match uu___2 with
-                    | "" ->
-                        if FStar_Compiler_Option.isSome ns_opt
-                        then
-                          let uu___3 =
-                            let uu___4 = qualify_to_record l in uu___4 :: out in
-                          (ns_opt, uu___3)
-                        else (ns_opt, (l :: out))
-                    | ns ->
-                        (match ns_opt with
-                         | FStar_Pervasives_Native.Some ns' ->
-                             if ns <> ns'
-                             then
-                               let uu___3 =
-                                 let uu___4 =
-                                   let uu___5 = FStar_Ident.string_of_lid l in
-                                   FStar_Compiler_Util.format2
-                                     "Field %s of record type was expected to be scoped to namespace %s"
-                                     uu___5 ns' in
-                                 (FStar_Errors.Fatal_MissingFieldInRecord,
-                                   uu___4) in
-                               let uu___4 = FStar_Ident.range_of_lid l in
-                               FStar_Errors.raise_error uu___3 uu___4
-                             else
-                               (let uu___4 =
-                                  let uu___5 = qualify_to_record l in uu___5
-                                    :: out in
-                                (ns_opt, uu___4))
-                         | FStar_Pervasives_Native.None ->
-                             let uu___3 =
-                               let uu___4 = qualify_to_record l in uu___4 ::
-                                 out in
-                             ((FStar_Pervasives_Native.Some ns), uu___3))))
-          (FStar_Pervasives_Native.None, []) field_names in
-      match uu___ with
-      | (uu___1, field_names_rev) -> FStar_Compiler_List.rev field_names_rev
-let desugar_disjunctive_pattern :
-  'uuuuu .
-    (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-      (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax * 'uuuuu) Prims.list) Prims.list ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.branch Prims.list
-  =
-  fun annotated_pats ->
-    fun when_opt ->
-      fun branch ->
-        FStar_Compiler_Effect.op_Bar_Greater annotated_pats
-          (FStar_Compiler_List.map
-             (fun uu___ ->
-                match uu___ with
-                | (pat, annots) ->
-                    let branch1 =
-                      FStar_Compiler_List.fold_left
-                        (fun br ->
-                           fun uu___1 ->
-                             match uu___1 with
-                             | (bv, ty, uu___2) ->
-                                 let lb =
-                                   let uu___3 =
-                                     FStar_Syntax_Syntax.bv_to_name bv in
-                                   FStar_Syntax_Util.mk_letbinding
-                                     (FStar_Pervasives.Inl bv) [] ty
-                                     FStar_Parser_Const.effect_Tot_lid uu___3
-                                     [] br.FStar_Syntax_Syntax.pos in
-                                 let branch2 =
-                                   let uu___3 =
-                                     let uu___4 =
-                                       FStar_Syntax_Syntax.mk_binder bv in
-                                     [uu___4] in
-                                   FStar_Syntax_Subst.close uu___3 branch in
-                                 FStar_Syntax_Syntax.mk
-                                   (FStar_Syntax_Syntax.Tm_let
-                                      ((false, [lb]), branch2))
-                                   br.FStar_Syntax_Syntax.pos) branch annots in
-                    FStar_Syntax_Util.branch (pat, when_opt, branch1)))
-let (trans_qual :
-  FStar_Compiler_Range.range ->
-    FStar_Ident.lident FStar_Pervasives_Native.option ->
-      FStar_Parser_AST.qualifier -> FStar_Syntax_Syntax.qualifier)
-  =
-  fun r ->
-    fun maybe_effect_id ->
-      fun uu___ ->
-        match uu___ with
-        | FStar_Parser_AST.Private -> FStar_Syntax_Syntax.Private
-        | FStar_Parser_AST.Assumption -> FStar_Syntax_Syntax.Assumption
-        | FStar_Parser_AST.Unfold_for_unification_and_vcgen ->
-            FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen
-        | FStar_Parser_AST.Inline_for_extraction ->
-            FStar_Syntax_Syntax.Inline_for_extraction
-        | FStar_Parser_AST.NoExtract -> FStar_Syntax_Syntax.NoExtract
-        | FStar_Parser_AST.Irreducible -> FStar_Syntax_Syntax.Irreducible
-        | FStar_Parser_AST.Logic -> FStar_Syntax_Syntax.Logic
-        | FStar_Parser_AST.TotalEffect -> FStar_Syntax_Syntax.TotalEffect
-        | FStar_Parser_AST.Effect_qual -> FStar_Syntax_Syntax.Effect
-        | FStar_Parser_AST.New -> FStar_Syntax_Syntax.New
-        | FStar_Parser_AST.Opaque ->
-            (FStar_Errors.log_issue r
-               (FStar_Errors.Warning_DeprecatedOpaqueQualifier,
-                 "The 'opaque' qualifier is deprecated since its use was strangely schizophrenic. There were two overloaded uses: (1) Given 'opaque val f : t', the behavior was to exclude the definition of 'f' to the SMT solver. This corresponds roughly to the new 'irreducible' qualifier. (2) Given 'opaque type t = t'', the behavior was to provide the definition of 't' to the SMT solver, but not to inline it, unless absolutely required for unification. This corresponds roughly to the behavior of 'unfoldable' (which is currently the default).");
-             FStar_Syntax_Syntax.Visible_default)
-        | FStar_Parser_AST.Reflectable ->
-            (match maybe_effect_id with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Errors.raise_error
-                   (FStar_Errors.Fatal_ReflectOnlySupportedOnEffects,
-                     "Qualifier reflect only supported on effects") r
-             | FStar_Pervasives_Native.Some effect_id ->
-                 FStar_Syntax_Syntax.Reflectable effect_id)
-        | FStar_Parser_AST.Reifiable -> FStar_Syntax_Syntax.Reifiable
-        | FStar_Parser_AST.Noeq -> FStar_Syntax_Syntax.Noeq
-        | FStar_Parser_AST.Unopteq -> FStar_Syntax_Syntax.Unopteq
-        | FStar_Parser_AST.DefaultEffect ->
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_DefaultQualifierNotAllowedOnEffects,
-                "The 'default' qualifier on effects is no longer supported")
-              r
-        | FStar_Parser_AST.Inline ->
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_UnsupportedQualifier,
-                "Unsupported qualifier") r
-        | FStar_Parser_AST.Visible ->
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_UnsupportedQualifier,
-                "Unsupported qualifier") r
-let (trans_pragma : FStar_Parser_AST.pragma -> FStar_Syntax_Syntax.pragma) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.SetOptions s -> FStar_Syntax_Syntax.SetOptions s
-    | FStar_Parser_AST.ResetOptions sopt ->
-        FStar_Syntax_Syntax.ResetOptions sopt
-    | FStar_Parser_AST.PushOptions sopt ->
-        FStar_Syntax_Syntax.PushOptions sopt
-    | FStar_Parser_AST.PopOptions -> FStar_Syntax_Syntax.PopOptions
-    | FStar_Parser_AST.RestartSolver -> FStar_Syntax_Syntax.RestartSolver
-    | FStar_Parser_AST.PrintEffectsGraph ->
-        FStar_Syntax_Syntax.PrintEffectsGraph
-let (as_imp :
-  FStar_Parser_AST.imp ->
-    FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Parser_AST.Hash -> FStar_Syntax_Syntax.as_aqual_implicit true
-    | uu___1 -> FStar_Pervasives_Native.None
-let arg_withimp_t :
-  'uuuuu .
-    FStar_Parser_AST.imp ->
-      'uuuuu ->
-        ('uuuuu * FStar_Syntax_Syntax.arg_qualifier
-          FStar_Pervasives_Native.option)
-  = fun imp -> fun t -> let uu___ = as_imp imp in (t, uu___)
-let (contains_binder : FStar_Parser_AST.binder Prims.list -> Prims.bool) =
-  fun binders ->
-    FStar_Compiler_Effect.op_Bar_Greater binders
-      (FStar_Compiler_Util.for_some
-         (fun b ->
-            match b.FStar_Parser_AST.b with
-            | FStar_Parser_AST.Annotated uu___ -> true
-            | uu___ -> false))
-let rec (unparen : FStar_Parser_AST.term -> FStar_Parser_AST.term) =
-  fun t ->
-    match t.FStar_Parser_AST.tm with
-    | FStar_Parser_AST.Paren t1 -> unparen t1
-    | uu___ -> t
-let (tm_type_z : FStar_Compiler_Range.range -> FStar_Parser_AST.term) =
-  fun r ->
-    let uu___ =
-      let uu___1 = FStar_Ident.lid_of_path ["Type0"] r in
-      FStar_Parser_AST.Name uu___1 in
-    FStar_Parser_AST.mk_term uu___ r FStar_Parser_AST.Kind
-let (tm_type : FStar_Compiler_Range.range -> FStar_Parser_AST.term) =
-  fun r ->
-    let uu___ =
-      let uu___1 = FStar_Ident.lid_of_path ["Type"] r in
-      FStar_Parser_AST.Name uu___1 in
-    FStar_Parser_AST.mk_term uu___ r FStar_Parser_AST.Kind
-let rec (is_comp_type :
-  FStar_Syntax_DsEnv.env -> FStar_Parser_AST.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      let uu___ = let uu___1 = unparen t in uu___1.FStar_Parser_AST.tm in
-      match uu___ with
-      | FStar_Parser_AST.Name l when
-          (let uu___1 = FStar_Syntax_DsEnv.current_module env in
-           FStar_Ident.lid_equals uu___1 FStar_Parser_Const.prims_lid) &&
-            (let s =
-               let uu___1 = FStar_Ident.ident_of_lid l in
-               FStar_Ident.string_of_id uu___1 in
-             (s = "Tot") || (s = "GTot"))
-          -> true
-      | FStar_Parser_AST.Name l ->
-          let uu___1 = FStar_Syntax_DsEnv.try_lookup_effect_name env l in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_Option.isSome
-      | FStar_Parser_AST.Construct (l, uu___1) ->
-          let uu___2 = FStar_Syntax_DsEnv.try_lookup_effect_name env l in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            FStar_Compiler_Option.isSome
-      | FStar_Parser_AST.App (head, uu___1, uu___2) -> is_comp_type env head
-      | FStar_Parser_AST.Paren t1 -> failwith "impossible"
-      | FStar_Parser_AST.Ascribed (t1, uu___1, uu___2, uu___3) ->
-          is_comp_type env t1
-      | FStar_Parser_AST.LetOpen (uu___1, t1) -> is_comp_type env t1
-      | uu___1 -> false
-let (unit_ty : FStar_Compiler_Range.range -> FStar_Parser_AST.term) =
-  fun rng ->
-    FStar_Parser_AST.mk_term
-      (FStar_Parser_AST.Name FStar_Parser_Const.unit_lid) rng
-      FStar_Parser_AST.Type_level
-type env_t = FStar_Syntax_DsEnv.env
-type lenv_t = FStar_Syntax_Syntax.bv Prims.list
-let (desugar_name' :
-  (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) ->
-    env_t ->
-      Prims.bool ->
-        FStar_Ident.lid ->
-          FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun setpos ->
-    fun env ->
-      fun resolve ->
-        fun l ->
-          let tm_attrs_opt =
-            if resolve
-            then FStar_Syntax_DsEnv.try_lookup_lid_with_attributes env l
-            else
-              FStar_Syntax_DsEnv.try_lookup_lid_with_attributes_no_resolve
-                env l in
-          match tm_attrs_opt with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some (tm, attrs) ->
-              let tm1 = setpos tm in FStar_Pervasives_Native.Some tm1
-let desugar_name :
-  'uuuuu .
-    'uuuuu ->
-      (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) ->
-        env_t -> Prims.bool -> FStar_Ident.lident -> FStar_Syntax_Syntax.term
-  =
-  fun mk ->
-    fun setpos ->
-      fun env ->
-        fun resolve ->
-          fun l ->
-            FStar_Syntax_DsEnv.fail_or env (desugar_name' setpos env resolve)
-              l
-let (compile_op_lid :
-  Prims.int ->
-    Prims.string -> FStar_Compiler_Range.range -> FStar_Ident.lident)
-  =
-  fun n ->
-    fun s ->
-      fun r ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Parser_AST.compile_op n s r in (uu___3, r) in
-            FStar_Ident.mk_ident uu___2 in
-          [uu___1] in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Ident.lid_of_ids
-let (op_as_term :
-  env_t ->
-    Prims.int ->
-      FStar_Ident.ident ->
-        FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun arity ->
-      fun op ->
-        let r l dd =
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Ident.range_of_id op in
-                FStar_Ident.set_lid_range l uu___3 in
-              FStar_Syntax_Syntax.lid_as_fv uu___2 dd
-                FStar_Pervasives_Native.None in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              FStar_Syntax_Syntax.fv_to_tm in
-          FStar_Pervasives_Native.Some uu___ in
-        let fallback uu___ =
-          let uu___1 = FStar_Ident.string_of_id op in
-          match uu___1 with
-          | "=" ->
-              r FStar_Parser_Const.op_Eq FStar_Syntax_Syntax.delta_equational
-          | "<" ->
-              r FStar_Parser_Const.op_LT FStar_Syntax_Syntax.delta_equational
-          | "<=" ->
-              r FStar_Parser_Const.op_LTE
-                FStar_Syntax_Syntax.delta_equational
-          | ">" ->
-              r FStar_Parser_Const.op_GT FStar_Syntax_Syntax.delta_equational
-          | ">=" ->
-              r FStar_Parser_Const.op_GTE
-                FStar_Syntax_Syntax.delta_equational
-          | "&&" ->
-              r FStar_Parser_Const.op_And
-                FStar_Syntax_Syntax.delta_equational
-          | "||" ->
-              r FStar_Parser_Const.op_Or FStar_Syntax_Syntax.delta_equational
-          | "+" ->
-              r FStar_Parser_Const.op_Addition
-                FStar_Syntax_Syntax.delta_equational
-          | "-" when arity = Prims.int_one ->
-              r FStar_Parser_Const.op_Minus
-                FStar_Syntax_Syntax.delta_equational
-          | "-" ->
-              r FStar_Parser_Const.op_Subtraction
-                FStar_Syntax_Syntax.delta_equational
-          | "/" ->
-              r FStar_Parser_Const.op_Division
-                FStar_Syntax_Syntax.delta_equational
-          | "%" ->
-              r FStar_Parser_Const.op_Modulus
-                FStar_Syntax_Syntax.delta_equational
-          | "@" ->
-              ((let uu___3 = FStar_Ident.range_of_id op in
-                FStar_Errors.log_issue uu___3
-                  (FStar_Errors.Warning_DeprecatedGeneric,
-                    "The operator '@' has been resolved to FStar.List.Tot.append even though FStar.List.Tot is not in scope. Please add an 'open FStar.List.Tot' to stop relying on this deprecated, special treatment of '@'"));
-               r FStar_Parser_Const.list_tot_append_lid
-                 (FStar_Syntax_Syntax.Delta_equational_at_level
-                    (Prims.of_int (2))))
-          | "<>" ->
-              r FStar_Parser_Const.op_notEq
-                FStar_Syntax_Syntax.delta_equational
-          | "~" ->
-              r FStar_Parser_Const.not_lid
-                (FStar_Syntax_Syntax.Delta_constant_at_level
-                   (Prims.of_int (2)))
-          | "==" ->
-              r FStar_Parser_Const.eq2_lid
-                (FStar_Syntax_Syntax.Delta_constant_at_level
-                   (Prims.of_int (2)))
-          | "<<" ->
-              r FStar_Parser_Const.precedes_lid
-                FStar_Syntax_Syntax.delta_constant
-          | "/\\" ->
-              r FStar_Parser_Const.and_lid
-                (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-          | "\\/" ->
-              r FStar_Parser_Const.or_lid
-                (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-          | "==>" ->
-              r FStar_Parser_Const.imp_lid
-                (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-          | "<==>" ->
-              r FStar_Parser_Const.iff_lid
-                (FStar_Syntax_Syntax.Delta_constant_at_level
-                   (Prims.of_int (2)))
-          | uu___2 -> FStar_Pervasives_Native.None in
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_id op in
-            let uu___3 = FStar_Ident.range_of_id op in
-            compile_op_lid arity uu___2 uu___3 in
-          desugar_name'
-            (fun t ->
-               let uu___2 = FStar_Ident.range_of_id op in
-               {
-                 FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-                 FStar_Syntax_Syntax.pos = uu___2;
-                 FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                 FStar_Syntax_Syntax.hash_code =
-                   (t.FStar_Syntax_Syntax.hash_code)
-               }) env true uu___1 in
-        match uu___ with
-        | FStar_Pervasives_Native.Some t -> FStar_Pervasives_Native.Some t
-        | uu___1 -> fallback ()
-let (sort_ftv : FStar_Ident.ident Prims.list -> FStar_Ident.ident Prims.list)
-  =
-  fun ftv ->
-    let uu___ =
-      FStar_Compiler_Util.remove_dups
-        (fun x ->
-           fun y ->
-             let uu___1 = FStar_Ident.string_of_id x in
-             let uu___2 = FStar_Ident.string_of_id y in uu___1 = uu___2) ftv in
-    FStar_Compiler_Effect.op_Less_Bar
-      (FStar_Compiler_Util.sort_with
-         (fun x ->
-            fun y ->
-              let uu___1 = FStar_Ident.string_of_id x in
-              let uu___2 = FStar_Ident.string_of_id y in
-              FStar_String.compare uu___1 uu___2)) uu___
-let rec (free_type_vars_b :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.binder ->
-      (FStar_Syntax_DsEnv.env * FStar_Ident.ident Prims.list))
-  =
-  fun env ->
-    fun binder ->
-      match binder.FStar_Parser_AST.b with
-      | FStar_Parser_AST.Variable uu___ -> (env, [])
-      | FStar_Parser_AST.TVariable x ->
-          let uu___ = FStar_Syntax_DsEnv.push_bv env x in
-          (match uu___ with | (env1, uu___1) -> (env1, [x]))
-      | FStar_Parser_AST.Annotated (uu___, term) ->
-          let uu___1 = free_type_vars env term in (env, uu___1)
-      | FStar_Parser_AST.TAnnotated (id, uu___) ->
-          let uu___1 = FStar_Syntax_DsEnv.push_bv env id in
-          (match uu___1 with | (env1, uu___2) -> (env1, []))
-      | FStar_Parser_AST.NoName t ->
-          let uu___ = free_type_vars env t in (env, uu___)
-and (free_type_vars_bs :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.binder Prims.list ->
-      (FStar_Syntax_DsEnv.env * FStar_Ident.ident Prims.list))
-  =
-  fun env ->
-    fun binders ->
-      FStar_Compiler_List.fold_left
-        (fun uu___ ->
-           fun binder ->
-             match uu___ with
-             | (env1, free) ->
-                 let uu___1 = free_type_vars_b env1 binder in
-                 (match uu___1 with
-                  | (env2, f) -> (env2, (FStar_Compiler_List.op_At f free))))
-        (env, []) binders
-and (free_type_vars :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.term -> FStar_Ident.ident Prims.list)
-  =
-  fun env ->
-    fun t ->
-      let uu___ = let uu___1 = unparen t in uu___1.FStar_Parser_AST.tm in
-      match uu___ with
-      | FStar_Parser_AST.Labeled uu___1 ->
-          failwith "Impossible --- labeled source term"
-      | FStar_Parser_AST.Tvar a ->
-          let uu___1 = FStar_Syntax_DsEnv.try_lookup_id env a in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None -> [a]
-           | uu___2 -> [])
-      | FStar_Parser_AST.Wild -> []
-      | FStar_Parser_AST.Const uu___1 -> []
-      | FStar_Parser_AST.Uvar uu___1 -> []
-      | FStar_Parser_AST.Var uu___1 -> []
-      | FStar_Parser_AST.Projector uu___1 -> []
-      | FStar_Parser_AST.Discrim uu___1 -> []
-      | FStar_Parser_AST.Name uu___1 -> []
-      | FStar_Parser_AST.Requires (t1, uu___1) -> free_type_vars env t1
-      | FStar_Parser_AST.Ensures (t1, uu___1) -> free_type_vars env t1
-      | FStar_Parser_AST.Decreases (t1, uu___1) -> free_type_vars env t1
-      | FStar_Parser_AST.NamedTyp (uu___1, t1) -> free_type_vars env t1
-      | FStar_Parser_AST.LexList l ->
-          FStar_Compiler_List.collect (free_type_vars env) l
-      | FStar_Parser_AST.WFOrder (rel, e) ->
-          let uu___1 = free_type_vars env rel in
-          let uu___2 = free_type_vars env e in
-          FStar_Compiler_List.op_At uu___1 uu___2
-      | FStar_Parser_AST.Paren t1 -> failwith "impossible"
-      | FStar_Parser_AST.Ascribed (t1, t', tacopt, uu___1) ->
-          let ts = t1 :: t' ::
-            (match tacopt with
-             | FStar_Pervasives_Native.None -> []
-             | FStar_Pervasives_Native.Some t2 -> [t2]) in
-          FStar_Compiler_List.collect (free_type_vars env) ts
-      | FStar_Parser_AST.Construct (uu___1, ts) ->
-          FStar_Compiler_List.collect
-            (fun uu___2 ->
-               match uu___2 with | (t1, uu___3) -> free_type_vars env t1) ts
-      | FStar_Parser_AST.Op (uu___1, ts) ->
-          FStar_Compiler_List.collect (free_type_vars env) ts
-      | FStar_Parser_AST.App (t1, t2, uu___1) ->
-          let uu___2 = free_type_vars env t1 in
-          let uu___3 = free_type_vars env t2 in
-          FStar_Compiler_List.op_At uu___2 uu___3
-      | FStar_Parser_AST.Refine (b, t1) ->
-          let uu___1 = free_type_vars_b env b in
-          (match uu___1 with
-           | (env1, f) ->
-               let uu___2 = free_type_vars env1 t1 in
-               FStar_Compiler_List.op_At f uu___2)
-      | FStar_Parser_AST.Sum (binders, body) ->
-          let uu___1 =
-            FStar_Compiler_List.fold_left
-              (fun uu___2 ->
-                 fun bt ->
-                   match uu___2 with
-                   | (env1, free) ->
-                       let uu___3 =
-                         match bt with
-                         | FStar_Pervasives.Inl binder ->
-                             free_type_vars_b env1 binder
-                         | FStar_Pervasives.Inr t1 ->
-                             let uu___4 = free_type_vars env1 t1 in
-                             (env1, uu___4) in
-                       (match uu___3 with
-                        | (env2, f) ->
-                            (env2, (FStar_Compiler_List.op_At f free))))
-              (env, []) binders in
-          (match uu___1 with
-           | (env1, free) ->
-               let uu___2 = free_type_vars env1 body in
-               FStar_Compiler_List.op_At free uu___2)
-      | FStar_Parser_AST.Product (binders, body) ->
-          let uu___1 = free_type_vars_bs env binders in
-          (match uu___1 with
-           | (env1, free) ->
-               let uu___2 = free_type_vars env1 body in
-               FStar_Compiler_List.op_At free uu___2)
-      | FStar_Parser_AST.Project (t1, uu___1) -> free_type_vars env t1
-      | FStar_Parser_AST.Attributes cattributes ->
-          FStar_Compiler_List.collect (free_type_vars env) cattributes
-      | FStar_Parser_AST.CalcProof (rel, init, steps) ->
-          let uu___1 = free_type_vars env rel in
-          let uu___2 =
-            let uu___3 = free_type_vars env init in
-            let uu___4 =
-              FStar_Compiler_List.collect
-                (fun uu___5 ->
-                   match uu___5 with
-                   | FStar_Parser_AST.CalcStep (rel1, just, next) ->
-                       let uu___6 = free_type_vars env rel1 in
-                       let uu___7 =
-                         let uu___8 = free_type_vars env just in
-                         let uu___9 = free_type_vars env next in
-                         FStar_Compiler_List.op_At uu___8 uu___9 in
-                       FStar_Compiler_List.op_At uu___6 uu___7) steps in
-            FStar_Compiler_List.op_At uu___3 uu___4 in
-          FStar_Compiler_List.op_At uu___1 uu___2
-      | FStar_Parser_AST.ElimForall (bs, t1, ts) ->
-          let uu___1 = free_type_vars_bs env bs in
-          (match uu___1 with
-           | (env', free) ->
-               let uu___2 =
-                 let uu___3 = free_type_vars env' t1 in
-                 let uu___4 =
-                   FStar_Compiler_List.collect (free_type_vars env') ts in
-                 FStar_Compiler_List.op_At uu___3 uu___4 in
-               FStar_Compiler_List.op_At free uu___2)
-      | FStar_Parser_AST.ElimExists (binders, p, q, y, e) ->
-          let uu___1 = free_type_vars_bs env binders in
-          (match uu___1 with
-           | (env', free) ->
-               let uu___2 = free_type_vars_b env' y in
-               (match uu___2 with
-                | (env'', free') ->
-                    let uu___3 =
-                      let uu___4 = free_type_vars env' p in
-                      let uu___5 =
-                        let uu___6 = free_type_vars env q in
-                        let uu___7 =
-                          let uu___8 = free_type_vars env'' e in
-                          FStar_Compiler_List.op_At free' uu___8 in
-                        FStar_Compiler_List.op_At uu___6 uu___7 in
-                      FStar_Compiler_List.op_At uu___4 uu___5 in
-                    FStar_Compiler_List.op_At free uu___3))
-      | FStar_Parser_AST.ElimImplies (p, q, e) ->
-          let uu___1 = free_type_vars env p in
-          let uu___2 =
-            let uu___3 = free_type_vars env q in
-            let uu___4 = free_type_vars env e in
-            FStar_Compiler_List.op_At uu___3 uu___4 in
-          FStar_Compiler_List.op_At uu___1 uu___2
-      | FStar_Parser_AST.ElimOr (p, q, r, x, e, x', e') ->
-          let uu___1 = free_type_vars env p in
-          let uu___2 =
-            let uu___3 = free_type_vars env q in
-            let uu___4 =
-              let uu___5 = free_type_vars env r in
-              let uu___6 =
-                let uu___7 =
-                  let uu___8 = free_type_vars_b env x in
-                  match uu___8 with
-                  | (env', free) ->
-                      let uu___9 = free_type_vars env' e in
-                      FStar_Compiler_List.op_At free uu___9 in
-                let uu___8 =
-                  let uu___9 = free_type_vars_b env x' in
-                  match uu___9 with
-                  | (env', free) ->
-                      let uu___10 = free_type_vars env' e' in
-                      FStar_Compiler_List.op_At free uu___10 in
-                FStar_Compiler_List.op_At uu___7 uu___8 in
-              FStar_Compiler_List.op_At uu___5 uu___6 in
-            FStar_Compiler_List.op_At uu___3 uu___4 in
-          FStar_Compiler_List.op_At uu___1 uu___2
-      | FStar_Parser_AST.ElimAnd (p, q, r, x, y, e) ->
-          let uu___1 = free_type_vars env p in
-          let uu___2 =
-            let uu___3 = free_type_vars env q in
-            let uu___4 =
-              let uu___5 = free_type_vars env r in
-              let uu___6 =
-                let uu___7 = free_type_vars_bs env [x; y] in
-                match uu___7 with
-                | (env', free) ->
-                    let uu___8 = free_type_vars env' e in
-                    FStar_Compiler_List.op_At free uu___8 in
-              FStar_Compiler_List.op_At uu___5 uu___6 in
-            FStar_Compiler_List.op_At uu___3 uu___4 in
-          FStar_Compiler_List.op_At uu___1 uu___2
-      | FStar_Parser_AST.Abs uu___1 -> []
-      | FStar_Parser_AST.Let uu___1 -> []
-      | FStar_Parser_AST.LetOpen uu___1 -> []
-      | FStar_Parser_AST.If uu___1 -> []
-      | FStar_Parser_AST.QForall uu___1 -> []
-      | FStar_Parser_AST.QExists uu___1 -> []
-      | FStar_Parser_AST.Record uu___1 -> []
-      | FStar_Parser_AST.Match uu___1 -> []
-      | FStar_Parser_AST.TryWith uu___1 -> []
-      | FStar_Parser_AST.Bind uu___1 -> []
-      | FStar_Parser_AST.Quote uu___1 -> []
-      | FStar_Parser_AST.VQuote uu___1 -> []
-      | FStar_Parser_AST.Antiquote uu___1 -> []
-      | FStar_Parser_AST.Seq uu___1 -> []
-let (head_and_args :
-  FStar_Parser_AST.term ->
-    (FStar_Parser_AST.term * (FStar_Parser_AST.term * FStar_Parser_AST.imp)
-      Prims.list))
-  =
-  fun t ->
-    let rec aux args t1 =
-      let uu___ = let uu___1 = unparen t1 in uu___1.FStar_Parser_AST.tm in
-      match uu___ with
-      | FStar_Parser_AST.App (t2, arg, imp) -> aux ((arg, imp) :: args) t2
-      | FStar_Parser_AST.Construct (l, args') ->
-          ({
-             FStar_Parser_AST.tm = (FStar_Parser_AST.Name l);
-             FStar_Parser_AST.range = (t1.FStar_Parser_AST.range);
-             FStar_Parser_AST.level = (t1.FStar_Parser_AST.level)
-           }, (FStar_Compiler_List.op_At args' args))
-      | uu___1 -> (t1, args) in
-    aux [] t
-let (close :
-  FStar_Syntax_DsEnv.env -> FStar_Parser_AST.term -> FStar_Parser_AST.term) =
-  fun env ->
-    fun t ->
-      let ftv =
-        let uu___ = free_type_vars env t in
-        FStar_Compiler_Effect.op_Less_Bar sort_ftv uu___ in
-      if (FStar_Compiler_List.length ftv) = Prims.int_zero
-      then t
-      else
-        (let binders =
-           FStar_Compiler_Effect.op_Bar_Greater ftv
-             (FStar_Compiler_List.map
-                (fun x ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = FStar_Ident.range_of_id x in
-                         tm_type uu___4 in
-                       (x, uu___3) in
-                     FStar_Parser_AST.TAnnotated uu___2 in
-                   let uu___2 = FStar_Ident.range_of_id x in
-                   FStar_Parser_AST.mk_binder uu___1 uu___2
-                     FStar_Parser_AST.Type_level
-                     (FStar_Pervasives_Native.Some FStar_Parser_AST.Implicit))) in
-         let result =
-           FStar_Parser_AST.mk_term (FStar_Parser_AST.Product (binders, t))
-             t.FStar_Parser_AST.range t.FStar_Parser_AST.level in
-         result)
-let (close_fun :
-  FStar_Syntax_DsEnv.env -> FStar_Parser_AST.term -> FStar_Parser_AST.term) =
-  fun env ->
-    fun t ->
-      let ftv =
-        let uu___ = free_type_vars env t in
-        FStar_Compiler_Effect.op_Less_Bar sort_ftv uu___ in
-      if (FStar_Compiler_List.length ftv) = Prims.int_zero
-      then t
-      else
-        (let binders =
-           FStar_Compiler_Effect.op_Bar_Greater ftv
-             (FStar_Compiler_List.map
-                (fun x ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = FStar_Ident.range_of_id x in
-                         tm_type uu___4 in
-                       (x, uu___3) in
-                     FStar_Parser_AST.TAnnotated uu___2 in
-                   let uu___2 = FStar_Ident.range_of_id x in
-                   FStar_Parser_AST.mk_binder uu___1 uu___2
-                     FStar_Parser_AST.Type_level
-                     (FStar_Pervasives_Native.Some FStar_Parser_AST.Implicit))) in
-         let t1 =
-           let uu___1 = let uu___2 = unparen t in uu___2.FStar_Parser_AST.tm in
-           match uu___1 with
-           | FStar_Parser_AST.Product uu___2 -> t
-           | uu___2 ->
-               FStar_Parser_AST.mk_term
-                 (FStar_Parser_AST.App
-                    ((FStar_Parser_AST.mk_term
-                        (FStar_Parser_AST.Name
-                           FStar_Parser_Const.effect_Tot_lid)
-                        t.FStar_Parser_AST.range t.FStar_Parser_AST.level),
-                      t, FStar_Parser_AST.Nothing)) t.FStar_Parser_AST.range
-                 t.FStar_Parser_AST.level in
-         let result =
-           FStar_Parser_AST.mk_term (FStar_Parser_AST.Product (binders, t1))
-             t1.FStar_Parser_AST.range t1.FStar_Parser_AST.level in
-         result)
-let rec (uncurry :
-  FStar_Parser_AST.binder Prims.list ->
-    FStar_Parser_AST.term ->
-      (FStar_Parser_AST.binder Prims.list * FStar_Parser_AST.term))
-  =
-  fun bs ->
-    fun t ->
-      match t.FStar_Parser_AST.tm with
-      | FStar_Parser_AST.Product (binders, t1) ->
-          uncurry (FStar_Compiler_List.op_At bs binders) t1
-      | uu___ -> (bs, t)
-let rec (is_var_pattern : FStar_Parser_AST.pattern -> Prims.bool) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatWild uu___ -> true
-    | FStar_Parser_AST.PatTvar uu___ -> true
-    | FStar_Parser_AST.PatVar uu___ -> true
-    | FStar_Parser_AST.PatAscribed (p1, uu___) -> is_var_pattern p1
-    | uu___ -> false
-let rec (is_app_pattern : FStar_Parser_AST.pattern -> Prims.bool) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatAscribed (p1, uu___) -> is_app_pattern p1
-    | FStar_Parser_AST.PatApp
-        ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatVar uu___;
-           FStar_Parser_AST.prange = uu___1;_},
-         uu___2)
-        -> true
-    | uu___ -> false
-let (replace_unit_pattern :
-  FStar_Parser_AST.pattern -> FStar_Parser_AST.pattern) =
-  fun p ->
-    match p.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatConst (FStar_Const.Const_unit) ->
-        FStar_Parser_AST.mk_pattern
-          (FStar_Parser_AST.PatAscribed
-             ((FStar_Parser_AST.mk_pattern
-                 (FStar_Parser_AST.PatWild (FStar_Pervasives_Native.None, []))
-                 p.FStar_Parser_AST.prange),
-               ((unit_ty p.FStar_Parser_AST.prange),
-                 FStar_Pervasives_Native.None))) p.FStar_Parser_AST.prange
-    | uu___ -> p
-let rec (destruct_app_pattern :
-  env_t ->
-    Prims.bool ->
-      FStar_Parser_AST.pattern ->
-        ((FStar_Ident.ident, FStar_Ident.lid) FStar_Pervasives.either *
-          FStar_Parser_AST.pattern Prims.list * (FStar_Parser_AST.term *
-          FStar_Parser_AST.term FStar_Pervasives_Native.option)
-          FStar_Pervasives_Native.option))
-  =
-  fun env ->
-    fun is_top_level ->
-      fun p ->
-        match p.FStar_Parser_AST.pat with
-        | FStar_Parser_AST.PatAscribed (p1, t) ->
-            let uu___ = destruct_app_pattern env is_top_level p1 in
-            (match uu___ with
-             | (name, args, uu___1) ->
-                 (name, args, (FStar_Pervasives_Native.Some t)))
-        | FStar_Parser_AST.PatApp
-            ({
-               FStar_Parser_AST.pat = FStar_Parser_AST.PatVar
-                 (id, uu___, uu___1);
-               FStar_Parser_AST.prange = uu___2;_},
-             args)
-            when is_top_level ->
-            let uu___3 =
-              let uu___4 = FStar_Syntax_DsEnv.qualify env id in
-              FStar_Pervasives.Inr uu___4 in
-            (uu___3, args, FStar_Pervasives_Native.None)
-        | FStar_Parser_AST.PatApp
-            ({
-               FStar_Parser_AST.pat = FStar_Parser_AST.PatVar
-                 (id, uu___, uu___1);
-               FStar_Parser_AST.prange = uu___2;_},
-             args)
-            ->
-            ((FStar_Pervasives.Inl id), args, FStar_Pervasives_Native.None)
-        | uu___ -> failwith "Not an app pattern"
-let rec (gather_pattern_bound_vars_maybe_top :
-  FStar_Ident.ident FStar_Compiler_Util.set ->
-    FStar_Parser_AST.pattern -> FStar_Ident.ident FStar_Compiler_Util.set)
-  =
-  fun acc ->
-    fun p ->
-      let gather_pattern_bound_vars_from_list =
-        FStar_Compiler_List.fold_left gather_pattern_bound_vars_maybe_top acc in
-      match p.FStar_Parser_AST.pat with
-      | FStar_Parser_AST.PatWild uu___ -> acc
-      | FStar_Parser_AST.PatConst uu___ -> acc
-      | FStar_Parser_AST.PatVQuote uu___ -> acc
-      | FStar_Parser_AST.PatName uu___ -> acc
-      | FStar_Parser_AST.PatOp uu___ -> acc
-      | FStar_Parser_AST.PatApp (phead, pats) ->
-          gather_pattern_bound_vars_from_list (phead :: pats)
-      | FStar_Parser_AST.PatTvar (x, uu___, uu___1) ->
-          FStar_Compiler_Util.set_add x acc
-      | FStar_Parser_AST.PatVar (x, uu___, uu___1) ->
-          FStar_Compiler_Util.set_add x acc
-      | FStar_Parser_AST.PatList pats ->
-          gather_pattern_bound_vars_from_list pats
-      | FStar_Parser_AST.PatTuple (pats, uu___) ->
-          gather_pattern_bound_vars_from_list pats
-      | FStar_Parser_AST.PatOr pats ->
-          gather_pattern_bound_vars_from_list pats
-      | FStar_Parser_AST.PatRecord guarded_pats ->
-          let uu___ =
-            FStar_Compiler_List.map FStar_Pervasives_Native.snd guarded_pats in
-          gather_pattern_bound_vars_from_list uu___
-      | FStar_Parser_AST.PatAscribed (pat, uu___) ->
-          gather_pattern_bound_vars_maybe_top acc pat
-let (gather_pattern_bound_vars :
-  FStar_Parser_AST.pattern -> FStar_Ident.ident FStar_Compiler_Util.set) =
-  let acc =
-    FStar_Compiler_Util.new_set
-      (fun id1 ->
-         fun id2 ->
-           let uu___ =
-             let uu___1 = FStar_Ident.string_of_id id1 in
-             let uu___2 = FStar_Ident.string_of_id id2 in uu___1 = uu___2 in
-           if uu___ then Prims.int_zero else Prims.int_one) in
-  fun p -> gather_pattern_bound_vars_maybe_top acc p
-type bnd =
-  | LocalBinder of (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.bqual *
-  FStar_Syntax_Syntax.term Prims.list) 
-  | LetBinder of (FStar_Ident.lident * (FStar_Syntax_Syntax.term *
-  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)) 
-let (uu___is_LocalBinder : bnd -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LocalBinder _0 -> true | uu___ -> false
-let (__proj__LocalBinder__item___0 :
-  bnd ->
-    (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.bqual *
-      FStar_Syntax_Syntax.term Prims.list))
-  = fun projectee -> match projectee with | LocalBinder _0 -> _0
-let (uu___is_LetBinder : bnd -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LetBinder _0 -> true | uu___ -> false
-let (__proj__LetBinder__item___0 :
-  bnd ->
-    (FStar_Ident.lident * (FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)))
-  = fun projectee -> match projectee with | LetBinder _0 -> _0
-let (is_implicit : bnd -> Prims.bool) =
-  fun b ->
-    match b with
-    | LocalBinder
-        (uu___, FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit
-         uu___1), uu___2)
-        -> true
-    | uu___ -> false
-let (binder_of_bnd :
-  bnd ->
-    (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.bqual *
-      FStar_Syntax_Syntax.term Prims.list))
-  =
-  fun uu___ ->
-    match uu___ with
-    | LocalBinder (a, aq, attrs) -> (a, aq, attrs)
-    | uu___1 -> failwith "Impossible"
-let (mk_lb :
-  (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list *
-    (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either
-    * FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    FStar_Compiler_Range.range) -> FStar_Syntax_Syntax.letbinding)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (attrs, n, t, e, pos) ->
-        let uu___1 = FStar_Parser_Const.effect_ALL_lid () in
-        {
-          FStar_Syntax_Syntax.lbname = n;
-          FStar_Syntax_Syntax.lbunivs = [];
-          FStar_Syntax_Syntax.lbtyp = t;
-          FStar_Syntax_Syntax.lbeff = uu___1;
-          FStar_Syntax_Syntax.lbdef = e;
-          FStar_Syntax_Syntax.lbattrs = attrs;
-          FStar_Syntax_Syntax.lbpos = pos
-        }
-let (no_annot_abs :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun bs -> fun t -> FStar_Syntax_Util.abs bs t FStar_Pervasives_Native.None
-let (mk_ref_read :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun tm ->
-    let tm' =
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.sread_lid
-              FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-          FStar_Syntax_Syntax.fv_to_tm uu___2 in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = FStar_Syntax_Syntax.as_aqual_implicit false in
-            (tm, uu___4) in
-          [uu___3] in
-        (uu___1, uu___2) in
-      FStar_Syntax_Syntax.Tm_app uu___ in
-    FStar_Syntax_Syntax.mk tm' tm.FStar_Syntax_Syntax.pos
-let (mk_ref_alloc :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun tm ->
-    let tm' =
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.salloc_lid
-              FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-          FStar_Syntax_Syntax.fv_to_tm uu___2 in
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = FStar_Syntax_Syntax.as_aqual_implicit false in
-            (tm, uu___4) in
-          [uu___3] in
-        (uu___1, uu___2) in
-      FStar_Syntax_Syntax.Tm_app uu___ in
-    FStar_Syntax_Syntax.mk tm' tm.FStar_Syntax_Syntax.pos
-let (mk_ref_assign :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Compiler_Range.range ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun t1 ->
-    fun t2 ->
-      fun pos ->
-        let tm =
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.swrite_lid
-                  FStar_Syntax_Syntax.delta_constant
-                  FStar_Pervasives_Native.None in
-              FStar_Syntax_Syntax.fv_to_tm uu___2 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Syntax.as_aqual_implicit false in
-                (t1, uu___4) in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 = FStar_Syntax_Syntax.as_aqual_implicit false in
-                  (t2, uu___6) in
-                [uu___5] in
-              uu___3 :: uu___4 in
-            (uu___1, uu___2) in
-          FStar_Syntax_Syntax.Tm_app uu___ in
-        FStar_Syntax_Syntax.mk tm pos
-let rec (generalize_annotated_univs :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt) =
-  fun s ->
-    let bs_univnames bs =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Util.new_set FStar_Syntax_Syntax.order_univ_name in
-        FStar_Compiler_List.fold_left
-          (fun uvs ->
-             fun b ->
-               let uu___2 =
-                 FStar_Syntax_Free.univnames
-                   (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-               FStar_Compiler_Util.set_union uvs uu___2) uu___1 in
-      FStar_Compiler_Effect.op_Bar_Greater bs uu___ in
-    let empty_set =
-      FStar_Compiler_Util.new_set FStar_Syntax_Syntax.order_univ_name in
-    match s.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_inductive_typ uu___ ->
-        failwith
-          "Impossible: collect_annotated_universes: bare data/type constructor"
-    | FStar_Syntax_Syntax.Sig_datacon uu___ ->
-        failwith
-          "Impossible: collect_annotated_universes: bare data/type constructor"
-    | FStar_Syntax_Syntax.Sig_bundle (sigs, lids) ->
-        let uvs =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater sigs
-              (FStar_Compiler_List.fold_left
-                 (fun uvs1 ->
-                    fun se ->
-                      let se_univs =
-                        match se.FStar_Syntax_Syntax.sigel with
-                        | FStar_Syntax_Syntax.Sig_inductive_typ
-                            (uu___1, uu___2, bs, uu___3, t, uu___4, uu___5)
-                            ->
-                            let uu___6 = bs_univnames bs in
-                            let uu___7 = FStar_Syntax_Free.univnames t in
-                            FStar_Compiler_Util.set_union uu___6 uu___7
-                        | FStar_Syntax_Syntax.Sig_datacon
-                            (uu___1, uu___2, t, uu___3, uu___4, uu___5) ->
-                            FStar_Syntax_Free.univnames t
-                        | uu___1 ->
-                            failwith
-                              "Impossible: collect_annotated_universes: Sig_bundle should not have a non data/type sigelt" in
-                      FStar_Compiler_Util.set_union uvs1 se_univs) empty_set) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Compiler_Util.set_elements in
-        let usubst = FStar_Syntax_Subst.univ_var_closing uvs in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater sigs
-                (FStar_Compiler_List.map
-                   (fun se ->
-                      match se.FStar_Syntax_Syntax.sigel with
-                      | FStar_Syntax_Syntax.Sig_inductive_typ
-                          (lid, uu___3, bs, num_uniform, t, lids1, lids2) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Syntax_Subst.subst_binders usubst bs in
-                              let uu___7 =
-                                let uu___8 =
-                                  FStar_Syntax_Subst.shift_subst
-                                    (FStar_Compiler_List.length bs) usubst in
-                                FStar_Syntax_Subst.subst uu___8 t in
-                              (lid, uvs, uu___6, num_uniform, uu___7, lids1,
-                                lids2) in
-                            FStar_Syntax_Syntax.Sig_inductive_typ uu___5 in
-                          {
-                            FStar_Syntax_Syntax.sigel = uu___4;
-                            FStar_Syntax_Syntax.sigrng =
-                              (se.FStar_Syntax_Syntax.sigrng);
-                            FStar_Syntax_Syntax.sigquals =
-                              (se.FStar_Syntax_Syntax.sigquals);
-                            FStar_Syntax_Syntax.sigmeta =
-                              (se.FStar_Syntax_Syntax.sigmeta);
-                            FStar_Syntax_Syntax.sigattrs =
-                              (se.FStar_Syntax_Syntax.sigattrs);
-                            FStar_Syntax_Syntax.sigopts =
-                              (se.FStar_Syntax_Syntax.sigopts)
-                          }
-                      | FStar_Syntax_Syntax.Sig_datacon
-                          (lid, uu___3, t, tlid, n, lids1) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = FStar_Syntax_Subst.subst usubst t in
-                              (lid, uvs, uu___6, tlid, n, lids1) in
-                            FStar_Syntax_Syntax.Sig_datacon uu___5 in
-                          {
-                            FStar_Syntax_Syntax.sigel = uu___4;
-                            FStar_Syntax_Syntax.sigrng =
-                              (se.FStar_Syntax_Syntax.sigrng);
-                            FStar_Syntax_Syntax.sigquals =
-                              (se.FStar_Syntax_Syntax.sigquals);
-                            FStar_Syntax_Syntax.sigmeta =
-                              (se.FStar_Syntax_Syntax.sigmeta);
-                            FStar_Syntax_Syntax.sigattrs =
-                              (se.FStar_Syntax_Syntax.sigattrs);
-                            FStar_Syntax_Syntax.sigopts =
-                              (se.FStar_Syntax_Syntax.sigopts)
-                          }
-                      | uu___3 ->
-                          failwith
-                            "Impossible: collect_annotated_universes: Sig_bundle should not have a non data/type sigelt")) in
-            (uu___2, lids) in
-          FStar_Syntax_Syntax.Sig_bundle uu___1 in
-        {
-          FStar_Syntax_Syntax.sigel = uu___;
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = (s.FStar_Syntax_Syntax.sigattrs);
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        }
-    | FStar_Syntax_Syntax.Sig_declare_typ (lid, uu___, t) ->
-        let uvs =
-          let uu___1 = FStar_Syntax_Free.univnames t in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_Util.set_elements in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.close_univ_vars uvs t in
-            (lid, uvs, uu___3) in
-          FStar_Syntax_Syntax.Sig_declare_typ uu___2 in
-        {
-          FStar_Syntax_Syntax.sigel = uu___1;
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = (s.FStar_Syntax_Syntax.sigattrs);
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        }
-    | FStar_Syntax_Syntax.Sig_let ((b, lbs), lids) ->
-        let lb_univnames lb =
-          let uu___ =
-            FStar_Syntax_Free.univnames lb.FStar_Syntax_Syntax.lbtyp in
-          let uu___1 =
-            FStar_Syntax_Free.univnames lb.FStar_Syntax_Syntax.lbdef in
-          FStar_Compiler_Util.set_union uu___ uu___1 in
-        let all_lb_univs =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater lbs
-              (FStar_Compiler_List.fold_left
-                 (fun uvs ->
-                    fun lb ->
-                      let uu___1 = lb_univnames lb in
-                      FStar_Compiler_Util.set_union uvs uu___1) empty_set) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Compiler_Util.set_elements in
-        let usubst = FStar_Syntax_Subst.univ_var_closing all_lb_univs in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater lbs
-                  (FStar_Compiler_List.map
-                     (fun lb ->
-                        let uu___4 =
-                          FStar_Syntax_Subst.subst usubst
-                            lb.FStar_Syntax_Syntax.lbtyp in
-                        let uu___5 =
-                          FStar_Syntax_Subst.subst usubst
-                            lb.FStar_Syntax_Syntax.lbdef in
-                        {
-                          FStar_Syntax_Syntax.lbname =
-                            (lb.FStar_Syntax_Syntax.lbname);
-                          FStar_Syntax_Syntax.lbunivs = all_lb_univs;
-                          FStar_Syntax_Syntax.lbtyp = uu___4;
-                          FStar_Syntax_Syntax.lbeff =
-                            (lb.FStar_Syntax_Syntax.lbeff);
-                          FStar_Syntax_Syntax.lbdef = uu___5;
-                          FStar_Syntax_Syntax.lbattrs =
-                            (lb.FStar_Syntax_Syntax.lbattrs);
-                          FStar_Syntax_Syntax.lbpos =
-                            (lb.FStar_Syntax_Syntax.lbpos)
-                        })) in
-              (b, uu___3) in
-            (uu___2, lids) in
-          FStar_Syntax_Syntax.Sig_let uu___1 in
-        {
-          FStar_Syntax_Syntax.sigel = uu___;
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = (s.FStar_Syntax_Syntax.sigattrs);
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        }
-    | FStar_Syntax_Syntax.Sig_assume (lid, uu___, fml) ->
-        let uvs =
-          let uu___1 = FStar_Syntax_Free.univnames fml in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_Util.set_elements in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.close_univ_vars uvs fml in
-            (lid, uvs, uu___3) in
-          FStar_Syntax_Syntax.Sig_assume uu___2 in
-        {
-          FStar_Syntax_Syntax.sigel = uu___1;
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = (s.FStar_Syntax_Syntax.sigattrs);
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        }
-    | FStar_Syntax_Syntax.Sig_effect_abbrev (lid, uu___, bs, c, flags) ->
-        let uvs =
-          let uu___1 =
-            let uu___2 = bs_univnames bs in
-            let uu___3 = FStar_Syntax_Free.univnames_comp c in
-            FStar_Compiler_Util.set_union uu___2 uu___3 in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_Util.set_elements in
-        let usubst = FStar_Syntax_Subst.univ_var_closing uvs in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Subst.subst_binders usubst bs in
-            let uu___4 = FStar_Syntax_Subst.subst_comp usubst c in
-            (lid, uvs, uu___3, uu___4, flags) in
-          FStar_Syntax_Syntax.Sig_effect_abbrev uu___2 in
-        {
-          FStar_Syntax_Syntax.sigel = uu___1;
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = (s.FStar_Syntax_Syntax.sigattrs);
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        }
-    | FStar_Syntax_Syntax.Sig_fail (errs, lax, ses) ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_List.map generalize_annotated_univs ses in
-            (errs, lax, uu___2) in
-          FStar_Syntax_Syntax.Sig_fail uu___1 in
-        {
-          FStar_Syntax_Syntax.sigel = uu___;
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = (s.FStar_Syntax_Syntax.sigattrs);
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        }
-    | FStar_Syntax_Syntax.Sig_new_effect uu___ -> s
-    | FStar_Syntax_Syntax.Sig_sub_effect uu___ -> s
-    | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___ -> s
-    | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___ -> s
-    | FStar_Syntax_Syntax.Sig_splice uu___ -> s
-    | FStar_Syntax_Syntax.Sig_pragma uu___ -> s
-let (is_special_effect_combinator : Prims.string -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | "lift1" -> true
-    | "lift2" -> true
-    | "pure" -> true
-    | "app" -> true
-    | "push" -> true
-    | "wp_if_then_else" -> true
-    | "wp_assert" -> true
-    | "wp_assume" -> true
-    | "wp_close" -> true
-    | "stronger" -> true
-    | "ite_wp" -> true
-    | "wp_trivial" -> true
-    | "ctx" -> true
-    | "gctx" -> true
-    | "lift_from_pure" -> true
-    | "return_wp" -> true
-    | "return_elab" -> true
-    | "bind_wp" -> true
-    | "bind_elab" -> true
-    | "repr" -> true
-    | "post" -> true
-    | "pre" -> true
-    | "wp" -> true
-    | uu___1 -> false
-let rec (sum_to_universe :
-  FStar_Syntax_Syntax.universe -> Prims.int -> FStar_Syntax_Syntax.universe)
-  =
-  fun u ->
-    fun n ->
-      if n = Prims.int_zero
-      then u
-      else
-        (let uu___1 = sum_to_universe u (n - Prims.int_one) in
-         FStar_Syntax_Syntax.U_succ uu___1)
-let (int_to_universe : Prims.int -> FStar_Syntax_Syntax.universe) =
-  fun n -> sum_to_universe FStar_Syntax_Syntax.U_zero n
-let rec (desugar_maybe_non_constant_universe :
-  FStar_Parser_AST.term ->
-    (Prims.int, FStar_Syntax_Syntax.universe) FStar_Pervasives.either)
-  =
-  fun t ->
-    let uu___ = let uu___1 = unparen t in uu___1.FStar_Parser_AST.tm in
-    match uu___ with
-    | FStar_Parser_AST.Wild ->
-        FStar_Pervasives.Inr FStar_Syntax_Syntax.U_unknown
-    | FStar_Parser_AST.Uvar u ->
-        FStar_Pervasives.Inr (FStar_Syntax_Syntax.U_name u)
-    | FStar_Parser_AST.Const (FStar_Const.Const_int (repr, uu___1)) ->
-        let n = FStar_Compiler_Util.int_of_string repr in
-        (if n < Prims.int_zero
-         then
-           FStar_Errors.raise_error
-             (FStar_Errors.Fatal_NegativeUniverseConstFatal_NotSupported,
-               (Prims.op_Hat
-                  "Negative universe constant  are not supported : " repr))
-             t.FStar_Parser_AST.range
-         else ();
-         FStar_Pervasives.Inl n)
-    | FStar_Parser_AST.Op (op_plus, t1::t2::[]) ->
-        ((let uu___3 =
-            let uu___4 = FStar_Ident.string_of_id op_plus in uu___4 = "+" in
-          ());
-         (let u1 = desugar_maybe_non_constant_universe t1 in
-          let u2 = desugar_maybe_non_constant_universe t2 in
-          match (u1, u2) with
-          | (FStar_Pervasives.Inl n1, FStar_Pervasives.Inl n2) ->
-              FStar_Pervasives.Inl (n1 + n2)
-          | (FStar_Pervasives.Inl n, FStar_Pervasives.Inr u) ->
-              let uu___2 = sum_to_universe u n in FStar_Pervasives.Inr uu___2
-          | (FStar_Pervasives.Inr u, FStar_Pervasives.Inl n) ->
-              let uu___2 = sum_to_universe u n in FStar_Pervasives.Inr uu___2
-          | (FStar_Pervasives.Inr u11, FStar_Pervasives.Inr u21) ->
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Parser_AST.term_to_string t in
-                  Prims.op_Hat
-                    "This universe might contain a sum of two universe variables "
-                    uu___4 in
-                (FStar_Errors.Fatal_UniverseMightContainSumOfTwoUnivVars,
-                  uu___3) in
-              FStar_Errors.raise_error uu___2 t.FStar_Parser_AST.range))
-    | FStar_Parser_AST.App uu___1 ->
-        let rec aux t1 univargs =
-          let uu___2 = let uu___3 = unparen t1 in uu___3.FStar_Parser_AST.tm in
-          match uu___2 with
-          | FStar_Parser_AST.App (t2, targ, uu___3) ->
-              let uarg = desugar_maybe_non_constant_universe targ in
-              aux t2 (uarg :: univargs)
-          | FStar_Parser_AST.Var max_lid ->
-              ((let uu___5 =
-                  let uu___6 = FStar_Ident.string_of_lid max_lid in
-                  uu___6 = "max" in
-                ());
-               (let uu___4 =
-                  FStar_Compiler_List.existsb
-                    (fun uu___5 ->
-                       match uu___5 with
-                       | FStar_Pervasives.Inr uu___6 -> true
-                       | uu___6 -> false) univargs in
-                if uu___4
-                then
-                  let uu___5 =
-                    let uu___6 =
-                      FStar_Compiler_List.map
-                        (fun uu___7 ->
-                           match uu___7 with
-                           | FStar_Pervasives.Inl n -> int_to_universe n
-                           | FStar_Pervasives.Inr u -> u) univargs in
-                    FStar_Syntax_Syntax.U_max uu___6 in
-                  FStar_Pervasives.Inr uu___5
-                else
-                  (let nargs =
-                     FStar_Compiler_List.map
-                       (fun uu___6 ->
-                          match uu___6 with
-                          | FStar_Pervasives.Inl n -> n
-                          | FStar_Pervasives.Inr uu___7 ->
-                              failwith "impossible") univargs in
-                   let uu___6 =
-                     FStar_Compiler_List.fold_left
-                       (fun m -> fun n -> if m > n then m else n)
-                       Prims.int_zero nargs in
-                   FStar_Pervasives.Inl uu___6)))
-          | uu___3 ->
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 = FStar_Parser_AST.term_to_string t1 in
-                    Prims.op_Hat uu___7 " in universe context" in
-                  Prims.op_Hat "Unexpected term " uu___6 in
-                (FStar_Errors.Fatal_UnexpectedTermInUniverse, uu___5) in
-              FStar_Errors.raise_error uu___4 t1.FStar_Parser_AST.range in
-        aux t []
-    | uu___1 ->
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = FStar_Parser_AST.term_to_string t in
-              Prims.op_Hat uu___5 " in universe context" in
-            Prims.op_Hat "Unexpected term " uu___4 in
-          (FStar_Errors.Fatal_UnexpectedTermInUniverse, uu___3) in
-        FStar_Errors.raise_error uu___2 t.FStar_Parser_AST.range
-let (desugar_universe :
-  FStar_Parser_AST.term -> FStar_Syntax_Syntax.universe) =
-  fun t ->
-    let u = desugar_maybe_non_constant_universe t in
-    match u with
-    | FStar_Pervasives.Inl n -> int_to_universe n
-    | FStar_Pervasives.Inr u1 -> u1
-let (check_no_aq : FStar_Syntax_Syntax.antiquotations -> unit) =
-  fun aq ->
-    match aq with
-    | [] -> ()
-    | (bv,
-       {
-         FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_quoted
-           (e,
-            { FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_dynamic;
-              FStar_Syntax_Syntax.antiquotes = uu___;_});
-         FStar_Syntax_Syntax.pos = uu___1; FStar_Syntax_Syntax.vars = uu___2;
-         FStar_Syntax_Syntax.hash_code = uu___3;_})::uu___4
-        ->
-        let uu___5 =
-          let uu___6 =
-            let uu___7 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format1 "Unexpected antiquotation: `@(%s)"
-              uu___7 in
-          (FStar_Errors.Fatal_UnexpectedAntiquotation, uu___6) in
-        FStar_Errors.raise_error uu___5 e.FStar_Syntax_Syntax.pos
-    | (bv, e)::uu___ ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format1 "Unexpected antiquotation: `#(%s)"
-              uu___3 in
-          (FStar_Errors.Fatal_UnexpectedAntiquotation, uu___2) in
-        FStar_Errors.raise_error uu___1 e.FStar_Syntax_Syntax.pos
-let (check_linear_pattern_variables :
-  FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t Prims.list ->
-    FStar_Compiler_Range.range -> unit)
-  =
-  fun pats ->
-    fun r ->
-      let rec pat_vars p =
-        match p.FStar_Syntax_Syntax.v with
-        | FStar_Syntax_Syntax.Pat_dot_term uu___ ->
-            FStar_Syntax_Syntax.no_names
-        | FStar_Syntax_Syntax.Pat_wild uu___ -> FStar_Syntax_Syntax.no_names
-        | FStar_Syntax_Syntax.Pat_constant uu___ ->
-            FStar_Syntax_Syntax.no_names
-        | FStar_Syntax_Syntax.Pat_var x ->
-            FStar_Compiler_Util.set_add x FStar_Syntax_Syntax.no_names
-        | FStar_Syntax_Syntax.Pat_cons (uu___, uu___1, pats1) ->
-            let aux out uu___2 =
-              match uu___2 with
-              | (p1, uu___3) ->
-                  let p_vars = pat_vars p1 in
-                  let intersection =
-                    FStar_Compiler_Util.set_intersect p_vars out in
-                  let uu___4 = FStar_Compiler_Util.set_is_empty intersection in
-                  if uu___4
-                  then FStar_Compiler_Util.set_union out p_vars
-                  else
-                    (let duplicate_bv =
-                       let uu___6 =
-                         FStar_Compiler_Util.set_elements intersection in
-                       FStar_Compiler_List.hd uu___6 in
-                     let uu___6 =
-                       let uu___7 =
-                         let uu___8 =
-                           FStar_Ident.string_of_id
-                             duplicate_bv.FStar_Syntax_Syntax.ppname in
-                         FStar_Compiler_Util.format1
-                           "Non-linear patterns are not permitted: `%s` appears more than once in this pattern."
-                           uu___8 in
-                       (FStar_Errors.Fatal_NonLinearPatternNotPermitted,
-                         uu___7) in
-                     FStar_Errors.raise_error uu___6 r) in
-            FStar_Compiler_List.fold_left aux FStar_Syntax_Syntax.no_names
-              pats1 in
-      match pats with
-      | [] -> ()
-      | p::[] ->
-          let uu___ = pat_vars p in
-          FStar_Compiler_Effect.op_Bar_Greater uu___ (fun uu___1 -> ())
-      | p::ps ->
-          let pvars = pat_vars p in
-          let aux p1 =
-            let uu___ =
-              let uu___1 = pat_vars p1 in
-              FStar_Compiler_Util.set_eq pvars uu___1 in
-            if uu___
-            then ()
-            else
-              (let nonlinear_vars =
-                 let uu___2 = pat_vars p1 in
-                 FStar_Compiler_Util.set_symmetric_difference pvars uu___2 in
-               let first_nonlinear_var =
-                 let uu___2 = FStar_Compiler_Util.set_elements nonlinear_vars in
-                 FStar_Compiler_List.hd uu___2 in
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Ident.string_of_id
-                       first_nonlinear_var.FStar_Syntax_Syntax.ppname in
-                   FStar_Compiler_Util.format1
-                     "Patterns in this match are incoherent, variable %s is bound in some but not all patterns."
-                     uu___4 in
-                 (FStar_Errors.Fatal_IncoherentPatterns, uu___3) in
-               FStar_Errors.raise_error uu___2 r) in
-          FStar_Compiler_List.iter aux ps
-let (smt_pat_lid : FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun r -> FStar_Ident.set_lid_range FStar_Parser_Const.smtpat_lid r
-let (smt_pat_or_lid : FStar_Compiler_Range.range -> FStar_Ident.lident) =
-  fun r -> FStar_Ident.set_lid_range FStar_Parser_Const.smtpatOr_lid r
-let rec (hoist_pat_ascription' :
-  FStar_Parser_AST.pattern ->
-    (FStar_Parser_AST.pattern * FStar_Parser_AST.term
-      FStar_Pervasives_Native.option))
-  =
-  fun pat ->
-    let mk tm =
-      FStar_Parser_AST.mk_term tm pat.FStar_Parser_AST.prange
-        FStar_Parser_AST.Type_level in
-    let handle_list type_lid pat_cons pats =
-      let uu___ =
-        let uu___1 = FStar_Compiler_List.map hoist_pat_ascription' pats in
-        FStar_Compiler_List.unzip uu___1 in
-      match uu___ with
-      | (pats1, terms) ->
-          let uu___1 =
-            FStar_Compiler_List.for_all FStar_Pervasives_Native.uu___is_None
-              terms in
-          if uu___1
-          then (pat, FStar_Pervasives_Native.None)
-          else
-            (let terms1 =
-               FStar_Compiler_List.map
-                 (fun uu___3 ->
-                    match uu___3 with
-                    | FStar_Pervasives_Native.Some t -> t
-                    | FStar_Pervasives_Native.None ->
-                        mk FStar_Parser_AST.Wild) terms in
-             let uu___3 =
-               let uu___4 = pat_cons pats1 in
-               {
-                 FStar_Parser_AST.pat = uu___4;
-                 FStar_Parser_AST.prange = (pat.FStar_Parser_AST.prange)
-               } in
-             let uu___4 =
-               let uu___5 =
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun t -> (t, FStar_Parser_AST.Nothing)) terms1 in
-                 FStar_Parser_AST.mkApp (mk type_lid) uu___6
-                   pat.FStar_Parser_AST.prange in
-               FStar_Pervasives_Native.Some uu___5 in
-             (uu___3, uu___4)) in
-    match pat.FStar_Parser_AST.pat with
-    | FStar_Parser_AST.PatList pats ->
-        handle_list (FStar_Parser_AST.Var FStar_Parser_Const.list_lid)
-          (fun uu___ -> FStar_Parser_AST.PatList uu___) pats
-    | FStar_Parser_AST.PatTuple (pats, dep) ->
-        let uu___ =
-          let uu___1 =
-            (if dep
-             then FStar_Parser_Const.mk_dtuple_lid
-             else FStar_Parser_Const.mk_tuple_lid)
-              (FStar_Compiler_List.length pats) pat.FStar_Parser_AST.prange in
-          FStar_Parser_AST.Var uu___1 in
-        handle_list uu___
-          (fun pats1 -> FStar_Parser_AST.PatTuple (pats1, dep)) pats
-    | FStar_Parser_AST.PatAscribed
-        (pat1, (typ, FStar_Pervasives_Native.None)) ->
-        (pat1, (FStar_Pervasives_Native.Some typ))
-    | uu___ -> (pat, FStar_Pervasives_Native.None)
-let (hoist_pat_ascription :
-  FStar_Parser_AST.pattern -> FStar_Parser_AST.pattern) =
-  fun pat ->
-    let uu___ = hoist_pat_ascription' pat in
-    match uu___ with
-    | (pat1, typ) ->
-        (match typ with
-         | FStar_Pervasives_Native.Some typ1 ->
-             {
-               FStar_Parser_AST.pat =
-                 (FStar_Parser_AST.PatAscribed
-                    (pat1, (typ1, FStar_Pervasives_Native.None)));
-               FStar_Parser_AST.prange = (pat1.FStar_Parser_AST.prange)
-             }
-         | FStar_Pervasives_Native.None -> pat1)
-let rec (desugar_data_pat :
-  Prims.bool ->
-    env_t ->
-      FStar_Parser_AST.pattern -> (env_t * bnd * annotated_pat Prims.list))
-  =
-  fun top_level_ascr_allowed ->
-    fun env ->
-      fun p ->
-        let resolvex l e x =
-          let uu___ =
-            FStar_Compiler_Util.find_opt
-              (fun y ->
-                 let uu___1 =
-                   FStar_Ident.string_of_id y.FStar_Syntax_Syntax.ppname in
-                 let uu___2 = FStar_Ident.string_of_id x in uu___1 = uu___2)
-              l in
-          match uu___ with
-          | FStar_Pervasives_Native.Some y -> (l, e, y)
-          | uu___1 ->
-              let uu___2 = FStar_Syntax_DsEnv.push_bv e x in
-              (match uu___2 with | (e1, xbv) -> ((xbv :: l), e1, xbv)) in
-        let rec aux' top loc env1 p1 =
-          let pos q =
-            FStar_Syntax_Syntax.withinfo q p1.FStar_Parser_AST.prange in
-          let pos_r r q = FStar_Syntax_Syntax.withinfo q r in
-          let orig = p1 in
-          match p1.FStar_Parser_AST.pat with
-          | FStar_Parser_AST.PatOr uu___ ->
-              failwith "impossible: PatOr handled below"
-          | FStar_Parser_AST.PatOp op ->
-              let id_op =
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 = FStar_Ident.string_of_id op in
-                    let uu___3 = FStar_Ident.range_of_id op in
-                    FStar_Parser_AST.compile_op Prims.int_zero uu___2 uu___3 in
-                  let uu___2 = FStar_Ident.range_of_id op in (uu___1, uu___2) in
-                FStar_Ident.mk_ident uu___ in
-              let p2 =
-                {
-                  FStar_Parser_AST.pat =
-                    (FStar_Parser_AST.PatVar
-                       (id_op, FStar_Pervasives_Native.None, []));
-                  FStar_Parser_AST.prange = (p1.FStar_Parser_AST.prange)
-                } in
-              aux loc env1 p2
-          | FStar_Parser_AST.PatAscribed (p2, (t, tacopt)) ->
-              ((match tacopt with
-                | FStar_Pervasives_Native.None -> ()
-                | FStar_Pervasives_Native.Some uu___1 ->
-                    FStar_Errors.raise_error
-                      (FStar_Errors.Fatal_TypeWithinPatternsAllowedOnVariablesOnly,
-                        "Type ascriptions within patterns cannot be associated with a tactic")
-                      orig.FStar_Parser_AST.prange);
-               (let uu___1 = aux loc env1 p2 in
-                match uu___1 with
-                | (loc1, env', binder, p3, annots) ->
-                    let uu___2 =
-                      match binder with
-                      | LetBinder uu___3 -> failwith "impossible"
-                      | LocalBinder (x, aq, attrs) ->
-                          let t1 =
-                            let uu___3 = close_fun env1 t in
-                            desugar_term env1 uu___3 in
-                          let x1 =
-                            {
-                              FStar_Syntax_Syntax.ppname =
-                                (x.FStar_Syntax_Syntax.ppname);
-                              FStar_Syntax_Syntax.index =
-                                (x.FStar_Syntax_Syntax.index);
-                              FStar_Syntax_Syntax.sort = t1
-                            } in
-                          ([(x1, t1, attrs)], (LocalBinder (x1, aq, attrs))) in
-                    (match uu___2 with
-                     | (annots', binder1) ->
-                         ((match p3.FStar_Syntax_Syntax.v with
-                           | FStar_Syntax_Syntax.Pat_var uu___4 -> ()
-                           | FStar_Syntax_Syntax.Pat_wild uu___4 -> ()
-                           | uu___4 when top && top_level_ascr_allowed -> ()
-                           | uu___4 ->
-                               FStar_Errors.raise_error
-                                 (FStar_Errors.Fatal_TypeWithinPatternsAllowedOnVariablesOnly,
-                                   "Type ascriptions within patterns are only allowed on variables")
-                                 orig.FStar_Parser_AST.prange);
-                          (loc1, env', binder1, p3,
-                            (FStar_Compiler_List.op_At annots' annots))))))
-          | FStar_Parser_AST.PatWild (aq, attrs) ->
-              let aq1 = trans_bqual env1 aq in
-              let attrs1 =
-                FStar_Compiler_Effect.op_Bar_Greater attrs
-                  (FStar_Compiler_List.map (desugar_term env1)) in
-              let x =
-                let uu___ = tun_r p1.FStar_Parser_AST.prange in
-                FStar_Syntax_Syntax.new_bv
-                  (FStar_Pervasives_Native.Some (p1.FStar_Parser_AST.prange))
-                  uu___ in
-              let uu___ =
-                FStar_Compiler_Effect.op_Less_Bar pos
-                  (FStar_Syntax_Syntax.Pat_wild x) in
-              (loc, env1, (LocalBinder (x, aq1, attrs1)), uu___, [])
-          | FStar_Parser_AST.PatConst c ->
-              let x =
-                let uu___ = tun_r p1.FStar_Parser_AST.prange in
-                FStar_Syntax_Syntax.new_bv
-                  (FStar_Pervasives_Native.Some (p1.FStar_Parser_AST.prange))
-                  uu___ in
-              let uu___ =
-                FStar_Compiler_Effect.op_Less_Bar pos
-                  (FStar_Syntax_Syntax.Pat_constant c) in
-              (loc, env1,
-                (LocalBinder (x, FStar_Pervasives_Native.None, [])), uu___,
-                [])
-          | FStar_Parser_AST.PatVQuote e ->
-              let pat =
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      desugar_vquote env1 e p1.FStar_Parser_AST.prange in
-                    (uu___2, (p1.FStar_Parser_AST.prange)) in
-                  FStar_Const.Const_string uu___1 in
-                FStar_Parser_AST.PatConst uu___ in
-              aux' top loc env1
-                {
-                  FStar_Parser_AST.pat = pat;
-                  FStar_Parser_AST.prange = (p1.FStar_Parser_AST.prange)
-                }
-          | FStar_Parser_AST.PatTvar (x, aq, attrs) ->
-              let aq1 = trans_bqual env1 aq in
-              let attrs1 =
-                FStar_Compiler_Effect.op_Bar_Greater attrs
-                  (FStar_Compiler_List.map (desugar_term env1)) in
-              let uu___ = resolvex loc env1 x in
-              (match uu___ with
-               | (loc1, env2, xbv) ->
-                   let uu___1 =
-                     FStar_Compiler_Effect.op_Less_Bar pos
-                       (FStar_Syntax_Syntax.Pat_var xbv) in
-                   (loc1, env2, (LocalBinder (xbv, aq1, attrs1)), uu___1, []))
-          | FStar_Parser_AST.PatVar (x, aq, attrs) ->
-              let aq1 = trans_bqual env1 aq in
-              let attrs1 =
-                FStar_Compiler_Effect.op_Bar_Greater attrs
-                  (FStar_Compiler_List.map (desugar_term env1)) in
-              let uu___ = resolvex loc env1 x in
-              (match uu___ with
-               | (loc1, env2, xbv) ->
-                   let uu___1 =
-                     FStar_Compiler_Effect.op_Less_Bar pos
-                       (FStar_Syntax_Syntax.Pat_var xbv) in
-                   (loc1, env2, (LocalBinder (xbv, aq1, attrs1)), uu___1, []))
-          | FStar_Parser_AST.PatName l ->
-              let l1 =
-                FStar_Syntax_DsEnv.fail_or env1
-                  (FStar_Syntax_DsEnv.try_lookup_datacon env1) l in
-              let x =
-                let uu___ = tun_r p1.FStar_Parser_AST.prange in
-                FStar_Syntax_Syntax.new_bv
-                  (FStar_Pervasives_Native.Some (p1.FStar_Parser_AST.prange))
-                  uu___ in
-              let uu___ =
-                FStar_Compiler_Effect.op_Less_Bar pos
-                  (FStar_Syntax_Syntax.Pat_cons
-                     (l1, FStar_Pervasives_Native.None, [])) in
-              (loc, env1,
-                (LocalBinder (x, FStar_Pervasives_Native.None, [])), uu___,
-                [])
-          | FStar_Parser_AST.PatApp
-              ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatName l;
-                 FStar_Parser_AST.prange = uu___;_},
-               args)
-              ->
-              let uu___1 =
-                FStar_Compiler_List.fold_right
-                  (fun arg ->
-                     fun uu___2 ->
-                       match uu___2 with
-                       | (loc1, env2, annots, args1) ->
-                           let uu___3 = aux loc1 env2 arg in
-                           (match uu___3 with
-                            | (loc2, env3, b, arg1, ans) ->
-                                let imp = is_implicit b in
-                                (loc2, env3,
-                                  (FStar_Compiler_List.op_At ans annots),
-                                  ((arg1, imp) :: args1)))) args
-                  (loc, env1, [], []) in
-              (match uu___1 with
-               | (loc1, env2, annots, args1) ->
-                   let l1 =
-                     FStar_Syntax_DsEnv.fail_or env2
-                       (FStar_Syntax_DsEnv.try_lookup_datacon env2) l in
-                   let x =
-                     let uu___2 = tun_r p1.FStar_Parser_AST.prange in
-                     FStar_Syntax_Syntax.new_bv
-                       (FStar_Pervasives_Native.Some
-                          (p1.FStar_Parser_AST.prange)) uu___2 in
-                   let uu___2 =
-                     FStar_Compiler_Effect.op_Less_Bar pos
-                       (FStar_Syntax_Syntax.Pat_cons
-                          (l1, FStar_Pervasives_Native.None, args1)) in
-                   (loc1, env2,
-                     (LocalBinder (x, FStar_Pervasives_Native.None, [])),
-                     uu___2, annots))
-          | FStar_Parser_AST.PatApp uu___ ->
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_UnexpectedPattern, "Unexpected pattern")
-                p1.FStar_Parser_AST.prange
-          | FStar_Parser_AST.PatList pats ->
-              let uu___ =
-                FStar_Compiler_List.fold_right
-                  (fun pat ->
-                     fun uu___1 ->
-                       match uu___1 with
-                       | (loc1, env2, annots, pats1) ->
-                           let uu___2 = aux loc1 env2 pat in
-                           (match uu___2 with
-                            | (loc2, env3, uu___3, pat1, ans) ->
-                                (loc2, env3,
-                                  (FStar_Compiler_List.op_At ans annots),
-                                  (pat1 :: pats1)))) pats (loc, env1, [], []) in
-              (match uu___ with
-               | (loc1, env2, annots, pats1) ->
-                   let pat =
-                     let uu___1 =
-                       let uu___2 =
-                         let uu___3 =
-                           FStar_Compiler_Range.end_range
-                             p1.FStar_Parser_AST.prange in
-                         pos_r uu___3 in
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 =
-                             FStar_Syntax_Syntax.lid_as_fv
-                               FStar_Parser_Const.nil_lid
-                               FStar_Syntax_Syntax.delta_constant
-                               (FStar_Pervasives_Native.Some
-                                  FStar_Syntax_Syntax.Data_ctor) in
-                           (uu___5, FStar_Pervasives_Native.None, []) in
-                         FStar_Syntax_Syntax.Pat_cons uu___4 in
-                       FStar_Compiler_Effect.op_Less_Bar uu___2 uu___3 in
-                     FStar_Compiler_List.fold_right
-                       (fun hd ->
-                          fun tl ->
-                            let r =
-                              FStar_Compiler_Range.union_ranges
-                                hd.FStar_Syntax_Syntax.p
-                                tl.FStar_Syntax_Syntax.p in
-                            let uu___2 =
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Syntax_Syntax.lid_as_fv
-                                    FStar_Parser_Const.cons_lid
-                                    FStar_Syntax_Syntax.delta_constant
-                                    (FStar_Pervasives_Native.Some
-                                       FStar_Syntax_Syntax.Data_ctor) in
-                                (uu___4, FStar_Pervasives_Native.None,
-                                  [(hd, false); (tl, false)]) in
-                              FStar_Syntax_Syntax.Pat_cons uu___3 in
-                            FStar_Compiler_Effect.op_Less_Bar (pos_r r)
-                              uu___2) pats1 uu___1 in
-                   let x =
-                     let uu___1 = tun_r p1.FStar_Parser_AST.prange in
-                     FStar_Syntax_Syntax.new_bv
-                       (FStar_Pervasives_Native.Some
-                          (p1.FStar_Parser_AST.prange)) uu___1 in
-                   (loc1, env2,
-                     (LocalBinder (x, FStar_Pervasives_Native.None, [])),
-                     pat, annots))
-          | FStar_Parser_AST.PatTuple (args, dep) ->
-              let uu___ =
-                FStar_Compiler_List.fold_left
-                  (fun uu___1 ->
-                     fun p2 ->
-                       match uu___1 with
-                       | (loc1, env2, annots, pats) ->
-                           let uu___2 = aux loc1 env2 p2 in
-                           (match uu___2 with
-                            | (loc2, env3, uu___3, pat, ans) ->
-                                (loc2, env3,
-                                  (FStar_Compiler_List.op_At ans annots),
-                                  ((pat, false) :: pats))))
-                  (loc, env1, [], []) args in
-              (match uu___ with
-               | (loc1, env2, annots, args1) ->
-                   let args2 = FStar_Compiler_List.rev args1 in
-                   let l =
-                     if dep
-                     then
-                       FStar_Parser_Const.mk_dtuple_data_lid
-                         (FStar_Compiler_List.length args2)
-                         p1.FStar_Parser_AST.prange
-                     else
-                       FStar_Parser_Const.mk_tuple_data_lid
-                         (FStar_Compiler_List.length args2)
-                         p1.FStar_Parser_AST.prange in
-                   let constr =
-                     FStar_Syntax_DsEnv.fail_or env2
-                       (FStar_Syntax_DsEnv.try_lookup_lid env2) l in
-                   let l1 =
-                     match constr.FStar_Syntax_Syntax.n with
-                     | FStar_Syntax_Syntax.Tm_fvar fv -> fv
-                     | uu___1 -> failwith "impossible" in
-                   let x =
-                     let uu___1 = tun_r p1.FStar_Parser_AST.prange in
-                     FStar_Syntax_Syntax.new_bv
-                       (FStar_Pervasives_Native.Some
-                          (p1.FStar_Parser_AST.prange)) uu___1 in
-                   let uu___1 =
-                     FStar_Compiler_Effect.op_Less_Bar pos
-                       (FStar_Syntax_Syntax.Pat_cons
-                          (l1, FStar_Pervasives_Native.None, args2)) in
-                   (loc1, env2,
-                     (LocalBinder (x, FStar_Pervasives_Native.None, [])),
-                     uu___1, annots))
-          | FStar_Parser_AST.PatRecord [] ->
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_UnexpectedPattern, "Unexpected pattern")
-                p1.FStar_Parser_AST.prange
-          | FStar_Parser_AST.PatRecord fields ->
-              let uu___ = FStar_Compiler_List.hd fields in
-              (match uu___ with
-               | (f, uu___1) ->
-                   let uu___2 = FStar_Compiler_List.unzip fields in
-                   (match uu___2 with
-                    | (field_names, pats) ->
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Syntax_DsEnv.try_lookup_record_by_field_name
-                              env1 f in
-                          match uu___4 with
-                          | FStar_Pervasives_Native.None ->
-                              (FStar_Pervasives_Native.None, field_names)
-                          | FStar_Pervasives_Native.Some r ->
-                              let uu___5 =
-                                qualify_field_names
-                                  r.FStar_Syntax_DsEnv.typename field_names in
-                              ((FStar_Pervasives_Native.Some
-                                  (r.FStar_Syntax_DsEnv.typename)), uu___5) in
-                        (match uu___3 with
-                         | (typename, field_names1) ->
-                             let candidate_constructor =
-                               let lid =
-                                 FStar_Ident.lid_of_path ["__dummy__"]
-                                   p1.FStar_Parser_AST.prange in
-                               FStar_Syntax_Syntax.lid_as_fv lid
-                                 FStar_Syntax_Syntax.delta_constant
-                                 (FStar_Pervasives_Native.Some
-                                    (FStar_Syntax_Syntax.Unresolved_constructor
-                                       {
-                                         FStar_Syntax_Syntax.uc_base_term =
-                                           false;
-                                         FStar_Syntax_Syntax.uc_typename =
-                                           typename;
-                                         FStar_Syntax_Syntax.uc_fields =
-                                           field_names1
-                                       })) in
-                             let uu___4 =
-                               FStar_Compiler_List.fold_left
-                                 (fun uu___5 ->
-                                    fun p2 ->
-                                      match uu___5 with
-                                      | (loc1, env2, annots, pats1) ->
-                                          let uu___6 = aux loc1 env2 p2 in
-                                          (match uu___6 with
-                                           | (loc2, env3, uu___7, pat, ann)
-                                               ->
-                                               (loc2, env3,
-                                                 (FStar_Compiler_List.op_At
-                                                    ann annots),
-                                                 ((pat, false) :: pats1))))
-                                 (loc, env1, [], []) pats in
-                             (match uu___4 with
-                              | (loc1, env2, annots, pats1) ->
-                                  let pats2 = FStar_Compiler_List.rev pats1 in
-                                  let pat =
-                                    FStar_Compiler_Effect.op_Less_Bar pos
-                                      (FStar_Syntax_Syntax.Pat_cons
-                                         (candidate_constructor,
-                                           FStar_Pervasives_Native.None,
-                                           pats2)) in
-                                  let x =
-                                    let uu___5 =
-                                      tun_r p1.FStar_Parser_AST.prange in
-                                    FStar_Syntax_Syntax.new_bv
-                                      (FStar_Pervasives_Native.Some
-                                         (p1.FStar_Parser_AST.prange)) uu___5 in
-                                  (loc1, env2,
-                                    (LocalBinder
-                                       (x, FStar_Pervasives_Native.None, [])),
-                                    pat, annots)))))
-        and aux loc env1 p1 = aux' false loc env1 p1 in
-        let aux_maybe_or env1 p1 =
-          let loc = [] in
-          match p1.FStar_Parser_AST.pat with
-          | FStar_Parser_AST.PatOr [] -> failwith "impossible"
-          | FStar_Parser_AST.PatOr (p2::ps) ->
-              let uu___ = aux' true loc env1 p2 in
-              (match uu___ with
-               | (loc1, env2, var, p3, ans) ->
-                   let uu___1 =
-                     FStar_Compiler_List.fold_left
-                       (fun uu___2 ->
-                          fun p4 ->
-                            match uu___2 with
-                            | (loc2, env3, ps1) ->
-                                let uu___3 = aux' true loc2 env3 p4 in
-                                (match uu___3 with
-                                 | (loc3, env4, uu___4, p5, ans1) ->
-                                     (loc3, env4, ((p5, ans1) :: ps1))))
-                       (loc1, env2, []) ps in
-                   (match uu___1 with
-                    | (loc2, env3, ps1) ->
-                        let pats = (p3, ans) :: (FStar_Compiler_List.rev ps1) in
-                        (env3, var, pats)))
-          | uu___ ->
-              let uu___1 = aux' true loc env1 p1 in
-              (match uu___1 with
-               | (loc1, env2, var, pat, ans) -> (env2, var, [(pat, ans)])) in
-        let uu___ = aux_maybe_or env p in
-        match uu___ with
-        | (env1, b, pats) ->
-            ((let uu___2 =
-                FStar_Compiler_List.map FStar_Pervasives_Native.fst pats in
-              check_linear_pattern_variables uu___2 p.FStar_Parser_AST.prange);
-             (env1, b, pats))
-and (desugar_binding_pat_maybe_top :
-  Prims.bool ->
-    FStar_Syntax_DsEnv.env ->
-      FStar_Parser_AST.pattern -> (env_t * bnd * annotated_pat Prims.list))
-  =
-  fun top ->
-    fun env ->
-      fun p ->
-        if top
-        then
-          let mklet x ty tacopt =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_DsEnv.qualify env x in
-                (uu___2, (ty, tacopt)) in
-              LetBinder uu___1 in
-            (env, uu___, []) in
-          let op_to_ident x =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Ident.string_of_id x in
-                let uu___3 = FStar_Ident.range_of_id x in
-                FStar_Parser_AST.compile_op Prims.int_zero uu___2 uu___3 in
-              let uu___2 = FStar_Ident.range_of_id x in (uu___1, uu___2) in
-            FStar_Ident.mk_ident uu___ in
-          match p.FStar_Parser_AST.pat with
-          | FStar_Parser_AST.PatOp x ->
-              let uu___ = op_to_ident x in
-              let uu___1 =
-                let uu___2 = FStar_Ident.range_of_id x in tun_r uu___2 in
-              mklet uu___ uu___1 FStar_Pervasives_Native.None
-          | FStar_Parser_AST.PatVar (x, uu___, uu___1) ->
-              let uu___2 =
-                let uu___3 = FStar_Ident.range_of_id x in tun_r uu___3 in
-              mklet x uu___2 FStar_Pervasives_Native.None
-          | FStar_Parser_AST.PatAscribed
-              ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatOp x;
-                 FStar_Parser_AST.prange = uu___;_},
-               (t, tacopt))
-              ->
-              let tacopt1 =
-                FStar_Compiler_Util.map_opt tacopt (desugar_term env) in
-              let uu___1 = op_to_ident x in
-              let uu___2 = desugar_term env t in mklet uu___1 uu___2 tacopt1
-          | FStar_Parser_AST.PatAscribed
-              ({
-                 FStar_Parser_AST.pat = FStar_Parser_AST.PatVar
-                   (x, uu___, uu___1);
-                 FStar_Parser_AST.prange = uu___2;_},
-               (t, tacopt))
-              ->
-              let tacopt1 =
-                FStar_Compiler_Util.map_opt tacopt (desugar_term env) in
-              let uu___3 = desugar_term env t in mklet x uu___3 tacopt1
-          | uu___ ->
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_UnexpectedPattern,
-                  "Unexpected pattern at the top-level")
-                p.FStar_Parser_AST.prange
-        else
-          (let uu___1 = desugar_data_pat true env p in
-           match uu___1 with
-           | (env1, binder, p1) ->
-               let p2 =
-                 match p1 with
-                 | ({
-                      FStar_Syntax_Syntax.v = FStar_Syntax_Syntax.Pat_var
-                        uu___2;
-                      FStar_Syntax_Syntax.p = uu___3;_},
-                    uu___4)::[] -> []
-                 | ({
-                      FStar_Syntax_Syntax.v = FStar_Syntax_Syntax.Pat_wild
-                        uu___2;
-                      FStar_Syntax_Syntax.p = uu___3;_},
-                    uu___4)::[] -> []
-                 | uu___2 -> p1 in
-               (env1, binder, p2))
-and (desugar_binding_pat :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.pattern -> (env_t * bnd * annotated_pat Prims.list))
-  = fun env -> fun p -> desugar_binding_pat_maybe_top false env p
-and (desugar_match_pat_maybe_top :
-  Prims.bool ->
-    env_t -> FStar_Parser_AST.pattern -> (env_t * annotated_pat Prims.list))
-  =
-  fun uu___ ->
-    fun env ->
-      fun pat ->
-        let uu___1 = desugar_data_pat false env pat in
-        match uu___1 with | (env1, uu___2, pat1) -> (env1, pat1)
-and (desugar_match_pat :
-  env_t -> FStar_Parser_AST.pattern -> (env_t * annotated_pat Prims.list)) =
-  fun env -> fun p -> desugar_match_pat_maybe_top false env p
-and (desugar_term_aq :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.term ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.antiquotations))
-  =
-  fun env ->
-    fun e ->
-      let env1 = FStar_Syntax_DsEnv.set_expect_typ env false in
-      desugar_term_maybe_top false env1 e
-and (desugar_term :
-  FStar_Syntax_DsEnv.env -> FStar_Parser_AST.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun e ->
-      let uu___ = desugar_term_aq env e in
-      match uu___ with | (t, aq) -> (check_no_aq aq; t)
-and (desugar_typ_aq :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.term ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.antiquotations))
-  =
-  fun env ->
-    fun e ->
-      let env1 = FStar_Syntax_DsEnv.set_expect_typ env true in
-      desugar_term_maybe_top false env1 e
-and (desugar_typ :
-  FStar_Syntax_DsEnv.env -> FStar_Parser_AST.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun e ->
-      let uu___ = desugar_typ_aq env e in
-      match uu___ with | (t, aq) -> (check_no_aq aq; t)
-and (desugar_machine_integer :
-  FStar_Syntax_DsEnv.env ->
-    Prims.string ->
-      (FStar_Const.signedness * FStar_Const.width) ->
-        FStar_Compiler_Range.range -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun repr ->
-      fun uu___ ->
-        fun range ->
-          match uu___ with
-          | (signedness, width) ->
-              let tnm =
-                if width = FStar_Const.Sizet
-                then "FStar.SizeT"
-                else
-                  Prims.op_Hat "FStar."
-                    (Prims.op_Hat
-                       (match signedness with
-                        | FStar_Const.Unsigned -> "U"
-                        | FStar_Const.Signed -> "")
-                       (Prims.op_Hat "Int"
-                          (match width with
-                           | FStar_Const.Int8 -> "8"
-                           | FStar_Const.Int16 -> "16"
-                           | FStar_Const.Int32 -> "32"
-                           | FStar_Const.Int64 -> "64"))) in
-              ((let uu___2 =
-                  let uu___3 =
-                    FStar_Const.within_bounds repr signedness width in
-                  Prims.op_Negation uu___3 in
-                if uu___2
-                then
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_Util.format2
-                        "%s is not in the expected range for %s" repr tnm in
-                    (FStar_Errors.Error_OutOfRange, uu___4) in
-                  FStar_Errors.log_issue range uu___3
-                else ());
-               (let private_intro_nm =
-                  Prims.op_Hat tnm
-                    (Prims.op_Hat ".__"
-                       (Prims.op_Hat
-                          (match signedness with
-                           | FStar_Const.Unsigned -> "u"
-                           | FStar_Const.Signed -> "") "int_to_t")) in
-                let intro_nm =
-                  Prims.op_Hat tnm
-                    (Prims.op_Hat "."
-                       (Prims.op_Hat
-                          (match signedness with
-                           | FStar_Const.Unsigned -> "u"
-                           | FStar_Const.Signed -> "") "int_to_t")) in
-                let lid =
-                  let uu___2 = FStar_Ident.path_of_text intro_nm in
-                  FStar_Ident.lid_of_path uu___2 range in
-                let lid1 =
-                  let uu___2 = FStar_Syntax_DsEnv.try_lookup_lid env lid in
-                  match uu___2 with
-                  | FStar_Pervasives_Native.Some intro_term ->
-                      (match intro_term.FStar_Syntax_Syntax.n with
-                       | FStar_Syntax_Syntax.Tm_fvar fv ->
-                           let private_lid =
-                             let uu___3 =
-                               FStar_Ident.path_of_text private_intro_nm in
-                             FStar_Ident.lid_of_path uu___3 range in
-                           let private_fv =
-                             let uu___3 =
-                               FStar_Syntax_Util.incr_delta_depth
-                                 fv.FStar_Syntax_Syntax.fv_delta in
-                             FStar_Syntax_Syntax.lid_as_fv private_lid uu___3
-                               fv.FStar_Syntax_Syntax.fv_qual in
-                           {
-                             FStar_Syntax_Syntax.n =
-                               (FStar_Syntax_Syntax.Tm_fvar private_fv);
-                             FStar_Syntax_Syntax.pos =
-                               (intro_term.FStar_Syntax_Syntax.pos);
-                             FStar_Syntax_Syntax.vars =
-                               (intro_term.FStar_Syntax_Syntax.vars);
-                             FStar_Syntax_Syntax.hash_code =
-                               (intro_term.FStar_Syntax_Syntax.hash_code)
-                           }
-                       | uu___3 ->
-                           failwith
-                             (Prims.op_Hat "Unexpected non-fvar for "
-                                intro_nm))
-                  | FStar_Pervasives_Native.None ->
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Compiler_Util.format1
-                            "Unexpected numeric literal.  Restart F* to load %s."
-                            tnm in
-                        (FStar_Errors.Fatal_UnexpectedNumericLiteral, uu___4) in
-                      FStar_Errors.raise_error uu___3 range in
-                let repr' =
-                  FStar_Syntax_Syntax.mk
-                    (FStar_Syntax_Syntax.Tm_constant
-                       (FStar_Const.Const_int
-                          (repr, FStar_Pervasives_Native.None))) range in
-                let app =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_Syntax_Syntax.as_aqual_implicit false in
-                          (repr', uu___6) in
-                        [uu___5] in
-                      (lid1, uu___4) in
-                    FStar_Syntax_Syntax.Tm_app uu___3 in
-                  FStar_Syntax_Syntax.mk uu___2 range in
-                FStar_Syntax_Syntax.mk
-                  (FStar_Syntax_Syntax.Tm_meta
-                     (app,
-                       (FStar_Syntax_Syntax.Meta_desugared
-                          (FStar_Syntax_Syntax.Machine_integer
-                             (signedness, width))))) range))
-and (desugar_term_maybe_top :
-  Prims.bool ->
-    env_t ->
-      FStar_Parser_AST.term ->
-        (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.antiquotations))
-  =
-  fun top_level ->
-    fun env ->
-      fun top ->
-        let mk e = FStar_Syntax_Syntax.mk e top.FStar_Parser_AST.range in
-        let noaqs = [] in
-        let join_aqs aqs = FStar_Compiler_List.flatten aqs in
-        let setpos e =
-          {
-            FStar_Syntax_Syntax.n = (e.FStar_Syntax_Syntax.n);
-            FStar_Syntax_Syntax.pos = (top.FStar_Parser_AST.range);
-            FStar_Syntax_Syntax.vars = (e.FStar_Syntax_Syntax.vars);
-            FStar_Syntax_Syntax.hash_code = (e.FStar_Syntax_Syntax.hash_code)
-          } in
-        let desugar_binders env1 binders =
-          let uu___ =
-            FStar_Compiler_List.fold_left
-              (fun uu___1 ->
-                 fun b ->
-                   match uu___1 with
-                   | (env2, bs) ->
-                       let bb = desugar_binder env2 b in
-                       let uu___2 =
-                         as_binder env2 b.FStar_Parser_AST.aqual bb in
-                       (match uu___2 with | (b1, env3) -> (env3, (b1 :: bs))))
-              (env1, []) binders in
-          match uu___ with
-          | (env2, bs_rev) -> (env2, (FStar_Compiler_List.rev bs_rev)) in
-        let unqual_bv_of_binder b =
-          match b with
-          | { FStar_Syntax_Syntax.binder_bv = x;
-              FStar_Syntax_Syntax.binder_qual = FStar_Pervasives_Native.None;
-              FStar_Syntax_Syntax.binder_attrs = [];_} -> x
-          | uu___ ->
-              let uu___1 =
-                FStar_Syntax_Syntax.range_of_bv
-                  b.FStar_Syntax_Syntax.binder_bv in
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_UnexpectedTerm,
-                  "Unexpected qualified binder in ELIM_EXISTS") uu___1 in
-        let uu___ = let uu___1 = unparen top in uu___1.FStar_Parser_AST.tm in
-        match uu___ with
-        | FStar_Parser_AST.Wild -> ((setpos FStar_Syntax_Syntax.tun), noaqs)
-        | FStar_Parser_AST.Labeled uu___1 ->
-            let uu___2 = desugar_formula env top in (uu___2, noaqs)
-        | FStar_Parser_AST.Requires (t, lopt) ->
-            let uu___1 = desugar_formula env t in (uu___1, noaqs)
-        | FStar_Parser_AST.Ensures (t, lopt) ->
-            let uu___1 = desugar_formula env t in (uu___1, noaqs)
-        | FStar_Parser_AST.Attributes ts ->
-            failwith
-              "Attributes should not be desugared by desugar_term_maybe_top"
-        | FStar_Parser_AST.Const (FStar_Const.Const_int
-            (i, FStar_Pervasives_Native.Some size)) ->
-            let uu___1 =
-              desugar_machine_integer env i size top.FStar_Parser_AST.range in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Const c ->
-            let uu___1 = mk (FStar_Syntax_Syntax.Tm_constant c) in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Op (id, args) when
-            let uu___1 = FStar_Ident.string_of_id id in uu___1 = "=!=" ->
-            let r = FStar_Ident.range_of_id id in
-            let e =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = FStar_Ident.mk_ident ("==", r) in
-                  (uu___3, args) in
-                FStar_Parser_AST.Op uu___2 in
-              FStar_Parser_AST.mk_term uu___1 top.FStar_Parser_AST.range
-                top.FStar_Parser_AST.level in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Ident.mk_ident ("~", r) in (uu___4, [e]) in
-                FStar_Parser_AST.Op uu___3 in
-              FStar_Parser_AST.mk_term uu___2 top.FStar_Parser_AST.range
-                top.FStar_Parser_AST.level in
-            desugar_term_aq env uu___1
-        | FStar_Parser_AST.Op (op_star, lhs::rhs::[]) when
-            (let uu___1 = FStar_Ident.string_of_id op_star in uu___1 = "*")
-              &&
-              (let uu___1 = op_as_term env (Prims.of_int (2)) op_star in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 FStar_Compiler_Option.isNone)
-            ->
-            let rec flatten t =
-              match t.FStar_Parser_AST.tm with
-              | FStar_Parser_AST.Op (id, t1::t2::[]) when
-                  (let uu___1 = FStar_Ident.string_of_id id in uu___1 = "*")
-                    &&
-                    (let uu___1 = op_as_term env (Prims.of_int (2)) op_star in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___1
-                       FStar_Compiler_Option.isNone)
-                  ->
-                  let uu___1 = flatten t1 in
-                  FStar_Compiler_List.op_At uu___1 [t2]
-              | uu___1 -> [t] in
-            let terms = flatten lhs in
-            let t =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    FStar_Compiler_List.map
-                      (fun uu___4 -> FStar_Pervasives.Inr uu___4) terms in
-                  (uu___3, rhs) in
-                FStar_Parser_AST.Sum uu___2 in
-              {
-                FStar_Parser_AST.tm = uu___1;
-                FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-              } in
-            desugar_term_maybe_top top_level env t
-        | FStar_Parser_AST.Tvar a ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Syntax_DsEnv.fail_or2
-                  (FStar_Syntax_DsEnv.try_lookup_id env) a in
-              FStar_Compiler_Effect.op_Less_Bar setpos uu___2 in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Uvar u ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Ident.string_of_id u in
-                  Prims.op_Hat uu___4 " in non-universe context" in
-                Prims.op_Hat "Unexpected universe variable " uu___3 in
-              (FStar_Errors.Fatal_UnexpectedUniverseVariable, uu___2) in
-            FStar_Errors.raise_error uu___1 top.FStar_Parser_AST.range
-        | FStar_Parser_AST.Op (s, args) ->
-            let uu___1 = op_as_term env (FStar_Compiler_List.length args) s in
-            (match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Ident.string_of_id s in
-                     Prims.op_Hat "Unexpected or unbound operator: " uu___4 in
-                   (FStar_Errors.Fatal_UnepxectedOrUnboundOperator, uu___3) in
-                 FStar_Errors.raise_error uu___2 top.FStar_Parser_AST.range
-             | FStar_Pervasives_Native.Some op ->
-                 if (FStar_Compiler_List.length args) > Prims.int_zero
-                 then
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Compiler_Effect.op_Bar_Greater args
-                         (FStar_Compiler_List.map
-                            (fun t ->
-                               let uu___4 = desugar_term_aq env t in
-                               match uu___4 with
-                               | (t', s1) ->
-                                   ((t', FStar_Pervasives_Native.None), s1))) in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       FStar_Compiler_List.unzip in
-                   (match uu___2 with
-                    | (args1, aqs) ->
-                        let uu___3 =
-                          mk (FStar_Syntax_Syntax.Tm_app (op, args1)) in
-                        (uu___3, (join_aqs aqs)))
-                 else (op, noaqs))
-        | FStar_Parser_AST.Construct (n, (a, uu___1)::[]) when
-            let uu___2 = FStar_Ident.string_of_lid n in uu___2 = "SMTPat" ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = smt_pat_lid top.FStar_Parser_AST.range in
-                      FStar_Parser_AST.Var uu___7 in
-                    {
-                      FStar_Parser_AST.tm = uu___6;
-                      FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                      FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-                    } in
-                  (uu___5, a, FStar_Parser_AST.Nothing) in
-                FStar_Parser_AST.App uu___4 in
-              {
-                FStar_Parser_AST.tm = uu___3;
-                FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-              } in
-            desugar_term_maybe_top top_level env uu___2
-        | FStar_Parser_AST.Construct (n, (a, uu___1)::[]) when
-            let uu___2 = FStar_Ident.string_of_lid n in uu___2 = "SMTPatT" ->
-            (FStar_Errors.log_issue top.FStar_Parser_AST.range
-               (FStar_Errors.Warning_SMTPatTDeprecated,
-                 "SMTPatT is deprecated; please just use SMTPat");
-             (let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 = smt_pat_lid top.FStar_Parser_AST.range in
-                        FStar_Parser_AST.Var uu___8 in
-                      {
-                        FStar_Parser_AST.tm = uu___7;
-                        FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                        FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-                      } in
-                    (uu___6, a, FStar_Parser_AST.Nothing) in
-                  FStar_Parser_AST.App uu___5 in
-                {
-                  FStar_Parser_AST.tm = uu___4;
-                  FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                  FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-                } in
-              desugar_term_maybe_top top_level env uu___3))
-        | FStar_Parser_AST.Construct (n, (a, uu___1)::[]) when
-            let uu___2 = FStar_Ident.string_of_lid n in uu___2 = "SMTPatOr"
-            ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = smt_pat_or_lid top.FStar_Parser_AST.range in
-                      FStar_Parser_AST.Var uu___7 in
-                    {
-                      FStar_Parser_AST.tm = uu___6;
-                      FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                      FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-                    } in
-                  (uu___5, a, FStar_Parser_AST.Nothing) in
-                FStar_Parser_AST.App uu___4 in
-              {
-                FStar_Parser_AST.tm = uu___3;
-                FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-              } in
-            desugar_term_maybe_top top_level env uu___2
-        | FStar_Parser_AST.Name lid when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "Type0" ->
-            let uu___1 =
-              mk (FStar_Syntax_Syntax.Tm_type FStar_Syntax_Syntax.U_zero) in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Name lid when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "Type" ->
-            let uu___1 =
-              mk (FStar_Syntax_Syntax.Tm_type FStar_Syntax_Syntax.U_unknown) in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Construct (lid, (t, FStar_Parser_AST.UnivApp)::[])
-            when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "Type" ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = desugar_universe t in
-                FStar_Syntax_Syntax.Tm_type uu___3 in
-              mk uu___2 in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Name lid when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "Effect"
-            ->
-            let uu___1 =
-              mk (FStar_Syntax_Syntax.Tm_constant FStar_Const.Const_effect) in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Name lid when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "True" ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Ident.set_lid_range FStar_Parser_Const.true_lid
-                  top.FStar_Parser_AST.range in
-              FStar_Syntax_Syntax.fvar uu___2
-                FStar_Syntax_Syntax.delta_constant
-                FStar_Pervasives_Native.None in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Name lid when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "False" ->
-            let uu___1 =
-              let uu___2 =
-                FStar_Ident.set_lid_range FStar_Parser_Const.false_lid
-                  top.FStar_Parser_AST.range in
-              FStar_Syntax_Syntax.fvar uu___2
-                FStar_Syntax_Syntax.delta_constant
-                FStar_Pervasives_Native.None in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Projector (eff_name, id) when
-            (let uu___1 = FStar_Ident.string_of_id id in
-             is_special_effect_combinator uu___1) &&
-              (FStar_Syntax_DsEnv.is_effect_name env eff_name)
-            ->
-            let txt = FStar_Ident.string_of_id id in
-            let uu___1 =
-              FStar_Syntax_DsEnv.try_lookup_effect_defn env eff_name in
-            (match uu___1 with
-             | FStar_Pervasives_Native.Some ed ->
-                 let lid = FStar_Syntax_Util.dm4f_lid ed txt in
-                 let uu___2 =
-                   FStar_Syntax_Syntax.fvar lid
-                     (FStar_Syntax_Syntax.Delta_constant_at_level
-                        Prims.int_one) FStar_Pervasives_Native.None in
-                 (uu___2, noaqs)
-             | FStar_Pervasives_Native.None ->
-                 let uu___2 =
-                   let uu___3 = FStar_Ident.string_of_lid eff_name in
-                   FStar_Compiler_Util.format2
-                     "Member %s of effect %s is not accessible (using an effect abbreviation instead of the original effect ?)"
-                     uu___3 txt in
-                 failwith uu___2)
-        | FStar_Parser_AST.Var l ->
-            let uu___1 = desugar_name mk setpos env true l in (uu___1, noaqs)
-        | FStar_Parser_AST.Name l ->
-            let uu___1 = desugar_name mk setpos env true l in (uu___1, noaqs)
-        | FStar_Parser_AST.Projector (l, i) ->
-            let name =
-              let uu___1 = FStar_Syntax_DsEnv.try_lookup_datacon env l in
-              match uu___1 with
-              | FStar_Pervasives_Native.Some uu___2 ->
-                  FStar_Pervasives_Native.Some (true, l)
-              | FStar_Pervasives_Native.None ->
-                  let uu___2 =
-                    FStar_Syntax_DsEnv.try_lookup_root_effect_name env l in
-                  (match uu___2 with
-                   | FStar_Pervasives_Native.Some new_name ->
-                       FStar_Pervasives_Native.Some (false, new_name)
-                   | uu___3 -> FStar_Pervasives_Native.None) in
-            (match name with
-             | FStar_Pervasives_Native.Some (resolve, new_name) ->
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Syntax_Util.mk_field_projector_name_from_ident
-                       new_name i in
-                   desugar_name mk setpos env resolve uu___2 in
-                 (uu___1, noaqs)
-             | uu___1 ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Ident.string_of_lid l in
-                     FStar_Compiler_Util.format1
-                       "Data constructor or effect %s not found" uu___4 in
-                   (FStar_Errors.Fatal_EffectNotFound, uu___3) in
-                 FStar_Errors.raise_error uu___2 top.FStar_Parser_AST.range)
-        | FStar_Parser_AST.Discrim lid ->
-            let uu___1 = FStar_Syntax_DsEnv.try_lookup_datacon env lid in
-            (match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Ident.string_of_lid lid in
-                     FStar_Compiler_Util.format1
-                       "Data constructor %s not found" uu___4 in
-                   (FStar_Errors.Fatal_DataContructorNotFound, uu___3) in
-                 FStar_Errors.raise_error uu___2 top.FStar_Parser_AST.range
-             | uu___2 ->
-                 let lid' = FStar_Syntax_Util.mk_discriminator lid in
-                 let uu___3 = desugar_name mk setpos env true lid' in
-                 (uu___3, noaqs))
-        | FStar_Parser_AST.Construct (l, args) ->
-            let uu___1 = FStar_Syntax_DsEnv.try_lookup_datacon env l in
-            (match uu___1 with
-             | FStar_Pervasives_Native.Some head ->
-                 let head1 = mk (FStar_Syntax_Syntax.Tm_fvar head) in
-                 (match args with
-                  | [] -> (head1, noaqs)
-                  | uu___2 ->
-                      let uu___3 =
-                        FStar_Compiler_Util.take
-                          (fun uu___4 ->
-                             match uu___4 with
-                             | (uu___5, imp) ->
-                                 imp = FStar_Parser_AST.UnivApp) args in
-                      (match uu___3 with
-                       | (universes, args1) ->
-                           let universes1 =
-                             FStar_Compiler_List.map
-                               (fun x ->
-                                  desugar_universe
-                                    (FStar_Pervasives_Native.fst x))
-                               universes in
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_Compiler_List.map
-                                 (fun uu___6 ->
-                                    match uu___6 with
-                                    | (t, imp) ->
-                                        let uu___7 = desugar_term_aq env t in
-                                        (match uu___7 with
-                                         | (te, aq) ->
-                                             let uu___8 =
-                                               arg_withimp_t imp te in
-                                             (uu___8, aq))) args1 in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___5
-                               FStar_Compiler_List.unzip in
-                           (match uu___4 with
-                            | (args2, aqs) ->
-                                let head2 =
-                                  if universes1 = []
-                                  then head1
-                                  else
-                                    mk
-                                      (FStar_Syntax_Syntax.Tm_uinst
-                                         (head1, universes1)) in
-                                let tm =
-                                  if
-                                    (FStar_Compiler_List.length args2) =
-                                      Prims.int_zero
-                                  then head2
-                                  else
-                                    mk
-                                      (FStar_Syntax_Syntax.Tm_app
-                                         (head2, args2)) in
-                                (tm, (join_aqs aqs)))))
-             | FStar_Pervasives_Native.None ->
-                 let err =
-                   let uu___2 =
-                     FStar_Syntax_DsEnv.try_lookup_effect_name env l in
-                   match uu___2 with
-                   | FStar_Pervasives_Native.None ->
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 = FStar_Ident.string_of_lid l in
-                           Prims.op_Hat uu___5 " not found" in
-                         Prims.op_Hat "Constructor " uu___4 in
-                       (FStar_Errors.Fatal_ConstructorNotFound, uu___3)
-                   | FStar_Pervasives_Native.Some uu___3 ->
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 = FStar_Ident.string_of_lid l in
-                           Prims.op_Hat uu___6
-                             " used at an unexpected position" in
-                         Prims.op_Hat "Effect " uu___5 in
-                       (FStar_Errors.Fatal_UnexpectedEffect, uu___4) in
-                 FStar_Errors.raise_error err top.FStar_Parser_AST.range)
-        | FStar_Parser_AST.Sum (binders, t) when
-            FStar_Compiler_Util.for_all
-              (fun uu___1 ->
-                 match uu___1 with
-                 | FStar_Pervasives.Inr uu___2 -> true
-                 | uu___2 -> false) binders
-            ->
-            let terms =
-              let uu___1 =
-                FStar_Compiler_Effect.op_Bar_Greater binders
-                  (FStar_Compiler_List.map
-                     (fun uu___2 ->
-                        match uu___2 with
-                        | FStar_Pervasives.Inr x -> x
-                        | FStar_Pervasives.Inl uu___3 ->
-                            failwith "Impossible")) in
-              FStar_Compiler_List.op_At uu___1 [t] in
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_Effect.op_Bar_Greater terms
-                  (FStar_Compiler_List.map
-                     (fun t1 ->
-                        let uu___3 = desugar_typ_aq env t1 in
-                        match uu___3 with
-                        | (t', aq) ->
-                            let uu___4 = FStar_Syntax_Syntax.as_arg t' in
-                            (uu___4, aq))) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_Compiler_List.unzip in
-            (match uu___1 with
-             | (targs, aqs) ->
-                 let tup =
-                   let uu___2 =
-                     FStar_Parser_Const.mk_tuple_lid
-                       (FStar_Compiler_List.length targs)
-                       top.FStar_Parser_AST.range in
-                   FStar_Syntax_DsEnv.fail_or env
-                     (FStar_Syntax_DsEnv.try_lookup_lid env) uu___2 in
-                 let uu___2 = mk (FStar_Syntax_Syntax.Tm_app (tup, targs)) in
-                 (uu___2, (join_aqs aqs)))
-        | FStar_Parser_AST.Sum (binders, t) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (fun uu___5 -> FStar_Pervasives.Inl uu___5)
-                      (FStar_Parser_AST.mk_binder (FStar_Parser_AST.NoName t)
-                         t.FStar_Parser_AST.range FStar_Parser_AST.Type_level
-                         FStar_Pervasives_Native.None) in
-                  [uu___4] in
-                FStar_Compiler_List.op_At binders uu___3 in
-              FStar_Compiler_List.fold_left
-                (fun uu___3 ->
-                   fun b ->
-                     match uu___3 with
-                     | (env1, tparams, typs) ->
-                         let uu___4 =
-                           match b with
-                           | FStar_Pervasives.Inl b1 ->
-                               desugar_binder env1 b1
-                           | FStar_Pervasives.Inr t1 ->
-                               let uu___5 = desugar_typ env1 t1 in
-                               (FStar_Pervasives_Native.None, uu___5, []) in
-                         (match uu___4 with
-                          | (xopt, t1, attrs) ->
-                              let uu___5 =
-                                match xopt with
-                                | FStar_Pervasives_Native.None ->
-                                    let uu___6 =
-                                      FStar_Syntax_Syntax.new_bv
-                                        (FStar_Pervasives_Native.Some
-                                           (top.FStar_Parser_AST.range))
-                                        (setpos FStar_Syntax_Syntax.tun) in
-                                    (env1, uu___6)
-                                | FStar_Pervasives_Native.Some x ->
-                                    FStar_Syntax_DsEnv.push_bv env1 x in
-                              (match uu___5 with
-                               | (env2, x) ->
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         FStar_Syntax_Syntax.mk_binder_with_attrs
-                                           {
-                                             FStar_Syntax_Syntax.ppname =
-                                               (x.FStar_Syntax_Syntax.ppname);
-                                             FStar_Syntax_Syntax.index =
-                                               (x.FStar_Syntax_Syntax.index);
-                                             FStar_Syntax_Syntax.sort = t1
-                                           } FStar_Pervasives_Native.None
-                                           attrs in
-                                       [uu___8] in
-                                     FStar_Compiler_List.op_At tparams uu___7 in
-                                   let uu___7 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         let uu___10 =
-                                           no_annot_abs tparams t1 in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           FStar_Syntax_Syntax.as_arg uu___10 in
-                                       [uu___9] in
-                                     FStar_Compiler_List.op_At typs uu___8 in
-                                   (env2, uu___6, uu___7)))) (env, [], [])
-                uu___2 in
-            (match uu___1 with
-             | (env1, uu___2, targs) ->
-                 let tup =
-                   let uu___3 =
-                     FStar_Parser_Const.mk_dtuple_lid
-                       (FStar_Compiler_List.length targs)
-                       top.FStar_Parser_AST.range in
-                   FStar_Syntax_DsEnv.fail_or env1
-                     (FStar_Syntax_DsEnv.try_lookup_lid env1) uu___3 in
-                 let uu___3 =
-                   FStar_Compiler_Effect.op_Less_Bar mk
-                     (FStar_Syntax_Syntax.Tm_app (tup, targs)) in
-                 (uu___3, noaqs))
-        | FStar_Parser_AST.Product (binders, t) ->
-            let uu___1 = uncurry binders t in
-            (match uu___1 with
-             | (bs, t1) ->
-                 let rec aux env1 bs1 uu___2 =
-                   match uu___2 with
-                   | [] ->
-                       let cod =
-                         desugar_comp top.FStar_Parser_AST.range true env1 t1 in
-                       let uu___3 =
-                         FStar_Syntax_Util.arrow
-                           (FStar_Compiler_List.rev bs1) cod in
-                       FStar_Compiler_Effect.op_Less_Bar setpos uu___3
-                   | hd::tl ->
-                       let bb = desugar_binder env1 hd in
-                       let uu___3 =
-                         as_binder env1 hd.FStar_Parser_AST.aqual bb in
-                       (match uu___3 with
-                        | (b, env2) -> aux env2 (b :: bs1) tl) in
-                 let uu___2 = aux env [] bs in (uu___2, noaqs))
-        | FStar_Parser_AST.Refine (b, f) ->
-            let uu___1 = desugar_binder env b in
-            (match uu___1 with
-             | (FStar_Pervasives_Native.None, uu___2, uu___3) ->
-                 failwith "Missing binder in refinement"
-             | b1 ->
-                 let uu___2 = as_binder env FStar_Pervasives_Native.None b1 in
-                 (match uu___2 with
-                  | (b2, env1) ->
-                      let f1 = desugar_formula env1 f in
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Syntax_Util.refine
-                            b2.FStar_Syntax_Syntax.binder_bv f1 in
-                        FStar_Compiler_Effect.op_Less_Bar setpos uu___4 in
-                      (uu___3, noaqs)))
-        | FStar_Parser_AST.Abs (binders, body) ->
-            let bvss =
-              FStar_Compiler_List.map gather_pattern_bound_vars binders in
-            let check_disjoint sets =
-              let rec aux acc sets1 =
-                match sets1 with
-                | [] -> FStar_Pervasives_Native.None
-                | set::sets2 ->
-                    let i = FStar_Compiler_Util.set_intersect acc set in
-                    let uu___1 = FStar_Compiler_Util.set_is_empty i in
-                    if uu___1
-                    then
-                      let uu___2 = FStar_Compiler_Util.set_union acc set in
-                      aux uu___2 sets2
-                    else
-                      (let uu___3 =
-                         let uu___4 = FStar_Compiler_Util.set_elements i in
-                         FStar_Compiler_List.hd uu___4 in
-                       FStar_Pervasives_Native.Some uu___3) in
-              let uu___1 = FStar_Syntax_Syntax.new_id_set () in
-              aux uu___1 sets in
-            ((let uu___2 = check_disjoint bvss in
-              match uu___2 with
-              | FStar_Pervasives_Native.None -> ()
-              | FStar_Pervasives_Native.Some id ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = FStar_Ident.string_of_id id in
-                      FStar_Compiler_Util.format1
-                        "Non-linear patterns are not permitted: `%s` appears more than once in this function definition."
-                        uu___5 in
-                    (FStar_Errors.Fatal_NonLinearPatternNotPermitted, uu___4) in
-                  let uu___4 = FStar_Ident.range_of_id id in
-                  FStar_Errors.raise_error uu___3 uu___4);
-             (let binders1 =
-                FStar_Compiler_Effect.op_Bar_Greater binders
-                  (FStar_Compiler_List.map replace_unit_pattern) in
-              let uu___2 =
-                FStar_Compiler_List.fold_left
-                  (fun uu___3 ->
-                     fun pat ->
-                       match uu___3 with
-                       | (env1, ftvs) ->
-                           (match pat.FStar_Parser_AST.pat with
-                            | FStar_Parser_AST.PatAscribed
-                                (uu___4, (t, FStar_Pervasives_Native.None))
-                                ->
-                                let uu___5 =
-                                  let uu___6 = free_type_vars env1 t in
-                                  FStar_Compiler_List.op_At uu___6 ftvs in
-                                (env1, uu___5)
-                            | FStar_Parser_AST.PatAscribed
-                                (uu___4,
-                                 (t, FStar_Pervasives_Native.Some tac))
-                                ->
-                                let uu___5 =
-                                  let uu___6 = free_type_vars env1 t in
-                                  let uu___7 =
-                                    let uu___8 = free_type_vars env1 tac in
-                                    FStar_Compiler_List.op_At uu___8 ftvs in
-                                  FStar_Compiler_List.op_At uu___6 uu___7 in
-                                (env1, uu___5)
-                            | uu___4 -> (env1, ftvs))) (env, []) binders1 in
-              match uu___2 with
-              | (uu___3, ftv) ->
-                  let ftv1 = sort_ftv ftv in
-                  let binders2 =
-                    let uu___4 =
-                      FStar_Compiler_Effect.op_Bar_Greater ftv1
-                        (FStar_Compiler_List.map
-                           (fun a ->
-                              FStar_Parser_AST.mk_pattern
-                                (FStar_Parser_AST.PatTvar
-                                   (a,
-                                     (FStar_Pervasives_Native.Some
-                                        FStar_Parser_AST.Implicit), []))
-                                top.FStar_Parser_AST.range)) in
-                    FStar_Compiler_List.op_At uu___4 binders1 in
-                  let rec aux env1 bs sc_pat_opt pats =
-                    match pats with
-                    | [] ->
-                        let uu___4 = desugar_term_aq env1 body in
-                        (match uu___4 with
-                         | (body1, aq) ->
-                             let body2 =
-                               match sc_pat_opt with
-                               | FStar_Pervasives_Native.Some (sc, pat) ->
-                                   let body3 =
-                                     let uu___5 =
-                                       let uu___6 =
-                                         FStar_Syntax_Syntax.pat_bvs pat in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___6
-                                         (FStar_Compiler_List.map
-                                            FStar_Syntax_Syntax.mk_binder) in
-                                     FStar_Syntax_Subst.close uu___5 body1 in
-                                   FStar_Syntax_Syntax.mk
-                                     (FStar_Syntax_Syntax.Tm_match
-                                        (sc, FStar_Pervasives_Native.None,
-                                          [(pat,
-                                             FStar_Pervasives_Native.None,
-                                             body3)],
-                                          FStar_Pervasives_Native.None))
-                                     body3.FStar_Syntax_Syntax.pos
-                               | FStar_Pervasives_Native.None -> body1 in
-                             let uu___5 =
-                               let uu___6 =
-                                 no_annot_abs (FStar_Compiler_List.rev bs)
-                                   body2 in
-                               setpos uu___6 in
-                             (uu___5, aq))
-                    | p::rest ->
-                        let uu___4 = desugar_binding_pat env1 p in
-                        (match uu___4 with
-                         | (env2, b, pat) ->
-                             let pat1 =
-                               match pat with
-                               | [] -> FStar_Pervasives_Native.None
-                               | (p1, uu___5)::[] ->
-                                   FStar_Pervasives_Native.Some p1
-                               | uu___5 ->
-                                   FStar_Errors.raise_error
-                                     (FStar_Errors.Fatal_UnsupportedDisjuctivePatterns,
-                                       "Disjunctive patterns are not supported in abstractions")
-                                     p.FStar_Parser_AST.prange in
-                             let uu___5 =
-                               match b with
-                               | LetBinder uu___6 -> failwith "Impossible"
-                               | LocalBinder (x, aq, attrs) ->
-                                   let sc_pat_opt1 =
-                                     match (pat1, sc_pat_opt) with
-                                     | (FStar_Pervasives_Native.None, uu___6)
-                                         -> sc_pat_opt
-                                     | (FStar_Pervasives_Native.Some p1,
-                                        FStar_Pervasives_Native.None) ->
-                                         let uu___6 =
-                                           let uu___7 =
-                                             FStar_Syntax_Syntax.bv_to_name x in
-                                           (uu___7, p1) in
-                                         FStar_Pervasives_Native.Some uu___6
-                                     | (FStar_Pervasives_Native.Some p1,
-                                        FStar_Pervasives_Native.Some
-                                        (sc, p')) ->
-                                         (match ((sc.FStar_Syntax_Syntax.n),
-                                                  (p'.FStar_Syntax_Syntax.v))
-                                          with
-                                          | (FStar_Syntax_Syntax.Tm_name
-                                             uu___6, uu___7) ->
-                                              let tup2 =
-                                                let uu___8 =
-                                                  FStar_Parser_Const.mk_tuple_data_lid
-                                                    (Prims.of_int (2))
-                                                    top.FStar_Parser_AST.range in
-                                                FStar_Syntax_Syntax.lid_as_fv
-                                                  uu___8
-                                                  FStar_Syntax_Syntax.delta_constant
-                                                  (FStar_Pervasives_Native.Some
-                                                     FStar_Syntax_Syntax.Data_ctor) in
-                                              let sc1 =
-                                                let uu___8 =
-                                                  let uu___9 =
-                                                    let uu___10 =
-                                                      mk
-                                                        (FStar_Syntax_Syntax.Tm_fvar
-                                                           tup2) in
-                                                    let uu___11 =
-                                                      let uu___12 =
-                                                        FStar_Syntax_Syntax.as_arg
-                                                          sc in
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            FStar_Syntax_Syntax.bv_to_name
-                                                              x in
-                                                          FStar_Compiler_Effect.op_Less_Bar
-                                                            FStar_Syntax_Syntax.as_arg
-                                                            uu___15 in
-                                                        [uu___14] in
-                                                      uu___12 :: uu___13 in
-                                                    (uu___10, uu___11) in
-                                                  FStar_Syntax_Syntax.Tm_app
-                                                    uu___9 in
-                                                FStar_Syntax_Syntax.mk uu___8
-                                                  top.FStar_Parser_AST.range in
-                                              let p2 =
-                                                let uu___8 =
-                                                  FStar_Compiler_Range.union_ranges
-                                                    p'.FStar_Syntax_Syntax.p
-                                                    p1.FStar_Syntax_Syntax.p in
-                                                FStar_Syntax_Syntax.withinfo
-                                                  (FStar_Syntax_Syntax.Pat_cons
-                                                     (tup2,
-                                                       FStar_Pervasives_Native.None,
-                                                       [(p', false);
-                                                       (p1, false)])) uu___8 in
-                                              FStar_Pervasives_Native.Some
-                                                (sc1, p2)
-                                          | (FStar_Syntax_Syntax.Tm_app
-                                             (uu___6, args),
-                                             FStar_Syntax_Syntax.Pat_cons
-                                             (uu___7, uu___8, pats1)) ->
-                                              let tupn =
-                                                let uu___9 =
-                                                  FStar_Parser_Const.mk_tuple_data_lid
-                                                    (Prims.int_one +
-                                                       (FStar_Compiler_List.length
-                                                          args))
-                                                    top.FStar_Parser_AST.range in
-                                                FStar_Syntax_Syntax.lid_as_fv
-                                                  uu___9
-                                                  FStar_Syntax_Syntax.delta_constant
-                                                  (FStar_Pervasives_Native.Some
-                                                     FStar_Syntax_Syntax.Data_ctor) in
-                                              let sc1 =
-                                                let uu___9 =
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      mk
-                                                        (FStar_Syntax_Syntax.Tm_fvar
-                                                           tupn) in
-                                                    let uu___12 =
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            FStar_Syntax_Syntax.bv_to_name
-                                                              x in
-                                                          FStar_Compiler_Effect.op_Less_Bar
-                                                            FStar_Syntax_Syntax.as_arg
-                                                            uu___15 in
-                                                        [uu___14] in
-                                                      FStar_Compiler_List.op_At
-                                                        args uu___13 in
-                                                    (uu___11, uu___12) in
-                                                  FStar_Syntax_Syntax.Tm_app
-                                                    uu___10 in
-                                                mk uu___9 in
-                                              let p2 =
-                                                let uu___9 =
-                                                  FStar_Compiler_Range.union_ranges
-                                                    p'.FStar_Syntax_Syntax.p
-                                                    p1.FStar_Syntax_Syntax.p in
-                                                FStar_Syntax_Syntax.withinfo
-                                                  (FStar_Syntax_Syntax.Pat_cons
-                                                     (tupn,
-                                                       FStar_Pervasives_Native.None,
-                                                       (FStar_Compiler_List.op_At
-                                                          pats1 [(p1, false)])))
-                                                  uu___9 in
-                                              FStar_Pervasives_Native.Some
-                                                (sc1, p2)
-                                          | uu___6 -> failwith "Impossible") in
-                                   let uu___6 =
-                                     FStar_Syntax_Syntax.mk_binder_with_attrs
-                                       x aq attrs in
-                                   (uu___6, sc_pat_opt1) in
-                             (match uu___5 with
-                              | (b1, sc_pat_opt1) ->
-                                  aux env2 (b1 :: bs) sc_pat_opt1 rest)) in
-                  aux env [] FStar_Pervasives_Native.None binders2))
-        | FStar_Parser_AST.App (uu___1, uu___2, FStar_Parser_AST.UnivApp) ->
-            let rec aux universes e =
-              let uu___3 =
-                let uu___4 = unparen e in uu___4.FStar_Parser_AST.tm in
-              match uu___3 with
-              | FStar_Parser_AST.App (e1, t, FStar_Parser_AST.UnivApp) ->
-                  let univ_arg = desugar_universe t in
-                  aux (univ_arg :: universes) e1
-              | uu___4 ->
-                  let uu___5 = desugar_term_aq env e in
-                  (match uu___5 with
-                   | (head, aq) ->
-                       let uu___6 =
-                         mk (FStar_Syntax_Syntax.Tm_uinst (head, universes)) in
-                       (uu___6, aq)) in
-            aux [] top
-        | FStar_Parser_AST.App uu___1 ->
-            let rec aux args aqs e =
-              let uu___2 =
-                let uu___3 = unparen e in uu___3.FStar_Parser_AST.tm in
-              match uu___2 with
-              | FStar_Parser_AST.App (e1, t, imp) when
-                  imp <> FStar_Parser_AST.UnivApp ->
-                  let uu___3 = desugar_term_aq env t in
-                  (match uu___3 with
-                   | (t1, aq) ->
-                       let arg = arg_withimp_t imp t1 in
-                       aux (arg :: args) (aq :: aqs) e1)
-              | uu___3 ->
-                  let uu___4 = desugar_term_aq env e in
-                  (match uu___4 with
-                   | (head, aq) ->
-                       let uu___5 =
-                         FStar_Syntax_Syntax.extend_app_n head args
-                           top.FStar_Parser_AST.range in
-                       (uu___5, (join_aqs (aq :: aqs)))) in
-            aux [] [] top
-        | FStar_Parser_AST.Bind (x, t1, t2) ->
-            let xpat =
-              let uu___1 = FStar_Ident.range_of_id x in
-              FStar_Parser_AST.mk_pattern
-                (FStar_Parser_AST.PatVar
-                   (x, FStar_Pervasives_Native.None, [])) uu___1 in
-            let k =
-              FStar_Parser_AST.mk_term (FStar_Parser_AST.Abs ([xpat], t2))
-                t2.FStar_Parser_AST.range t2.FStar_Parser_AST.level in
-            let bind_lid =
-              let uu___1 = FStar_Ident.range_of_id x in
-              FStar_Ident.lid_of_path ["bind"] uu___1 in
-            let bind =
-              let uu___1 = FStar_Ident.range_of_id x in
-              FStar_Parser_AST.mk_term (FStar_Parser_AST.Var bind_lid) uu___1
-                FStar_Parser_AST.Expr in
-            let uu___1 =
-              FStar_Parser_AST.mkExplicitApp bind [t1; k]
-                top.FStar_Parser_AST.range in
-            desugar_term_aq env uu___1
-        | FStar_Parser_AST.Seq (t1, t2) ->
-            let p =
-              FStar_Parser_AST.mk_pattern
-                (FStar_Parser_AST.PatWild (FStar_Pervasives_Native.None, []))
-                t1.FStar_Parser_AST.range in
-            let p1 =
-              FStar_Parser_AST.mk_pattern
-                (FStar_Parser_AST.PatAscribed
-                   (p,
-                     ((unit_ty p.FStar_Parser_AST.prange),
-                       FStar_Pervasives_Native.None)))
-                p.FStar_Parser_AST.prange in
-            let t =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.Let
-                   (FStar_Parser_AST.NoLetQualifier,
-                     [(FStar_Pervasives_Native.None, (p1, t1))], t2))
-                top.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-            let uu___1 = desugar_term_aq env t in
-            (match uu___1 with
-             | (tm, s) ->
-                 let uu___2 =
-                   mk
-                     (FStar_Syntax_Syntax.Tm_meta
-                        (tm,
-                          (FStar_Syntax_Syntax.Meta_desugared
-                             FStar_Syntax_Syntax.Sequence))) in
-                 (uu___2, s))
-        | FStar_Parser_AST.LetOpen (lid, e) ->
-            let env1 = FStar_Syntax_DsEnv.push_namespace env lid in
-            let uu___1 =
-              let uu___2 = FStar_Syntax_DsEnv.expect_typ env1 in
-              if uu___2 then desugar_typ_aq else desugar_term_aq in
-            uu___1 env1 e
-        | FStar_Parser_AST.LetOpenRecord (r, rty, e) ->
-            let rec head_of t =
-              match t.FStar_Parser_AST.tm with
-              | FStar_Parser_AST.App (t1, uu___1, uu___2) -> head_of t1
-              | uu___1 -> t in
-            let tycon = head_of rty in
-            let tycon_name =
-              match tycon.FStar_Parser_AST.tm with
-              | FStar_Parser_AST.Var l -> l
-              | uu___1 ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = FStar_Parser_AST.term_to_string rty in
-                      FStar_Compiler_Util.format1
-                        "This type must be a (possibly applied) record name"
-                        uu___4 in
-                    (FStar_Errors.Error_BadLetOpenRecord, uu___3) in
-                  FStar_Errors.raise_error uu___2 rty.FStar_Parser_AST.range in
-            let record =
-              let uu___1 =
-                FStar_Syntax_DsEnv.try_lookup_record_type env tycon_name in
-              match uu___1 with
-              | FStar_Pervasives_Native.Some r1 -> r1
-              | FStar_Pervasives_Native.None ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = FStar_Parser_AST.term_to_string rty in
-                      FStar_Compiler_Util.format1 "Not a record type: `%s`"
-                        uu___4 in
-                    (FStar_Errors.Error_BadLetOpenRecord, uu___3) in
-                  FStar_Errors.raise_error uu___2 rty.FStar_Parser_AST.range in
-            let constrname =
-              let uu___1 =
-                FStar_Ident.ns_of_lid record.FStar_Syntax_DsEnv.typename in
-              FStar_Ident.lid_of_ns_and_id uu___1
-                record.FStar_Syntax_DsEnv.constrname in
-            let mk_pattern p =
-              FStar_Parser_AST.mk_pattern p r.FStar_Parser_AST.range in
-            let elab =
-              let pat =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Compiler_List.map
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | (field, uu___5) ->
-                               mk_pattern
-                                 (FStar_Parser_AST.PatVar
-                                    (field, FStar_Pervasives_Native.None, [])))
-                        record.FStar_Syntax_DsEnv.fields in
-                    ((mk_pattern (FStar_Parser_AST.PatName constrname)),
-                      uu___3) in
-                  FStar_Parser_AST.PatApp uu___2 in
-                mk_pattern uu___1 in
-              let branch = (pat, FStar_Pervasives_Native.None, e) in
-              let r1 =
-                FStar_Parser_AST.mk_term
-                  (FStar_Parser_AST.Ascribed
-                     (r, rty, FStar_Pervasives_Native.None, false))
-                  r.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-              {
-                FStar_Parser_AST.tm =
-                  (FStar_Parser_AST.Match
-                     (r1, FStar_Pervasives_Native.None,
-                       FStar_Pervasives_Native.None, [branch]));
-                FStar_Parser_AST.range = (top.FStar_Parser_AST.range);
-                FStar_Parser_AST.level = (top.FStar_Parser_AST.level)
-              } in
-            desugar_term_maybe_top top_level env elab
-        | FStar_Parser_AST.LetOperator (lets, body) ->
-            (match lets with
-             | [] ->
-                 failwith
-                   "Impossible: a LetOperator (e.g. let+, let*...) cannot contain zero let binding"
-             | (letOp, letPat, letDef)::tl ->
-                 let term_of_op op =
-                   let uu___1 = FStar_Ident.range_of_id op in
-                   FStar_Parser_AST.mk_term (FStar_Parser_AST.Op (op, []))
-                     uu___1 FStar_Parser_AST.Expr in
-                 let mproduct_def =
-                   FStar_Compiler_List.fold_left
-                     (fun def ->
-                        fun uu___1 ->
-                          match uu___1 with
-                          | (andOp, andPat, andDef) ->
-                              let uu___2 = term_of_op andOp in
-                              FStar_Parser_AST.mkExplicitApp uu___2
-                                [def; andDef] top.FStar_Parser_AST.range)
-                     letDef tl in
-                 let mproduct_pat =
-                   FStar_Compiler_List.fold_left
-                     (fun pat ->
-                        fun uu___1 ->
-                          match uu___1 with
-                          | (andOp, andPat, andDef) ->
-                              FStar_Parser_AST.mk_pattern
-                                (FStar_Parser_AST.PatTuple
-                                   ([pat; andPat], false))
-                                andPat.FStar_Parser_AST.prange) letPat tl in
-                 let fn =
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = hoist_pat_ascription mproduct_pat in
-                         [uu___4] in
-                       (uu___3, body) in
-                     FStar_Parser_AST.Abs uu___2 in
-                   FStar_Parser_AST.mk_term uu___1
-                     body.FStar_Parser_AST.range body.FStar_Parser_AST.level in
-                 let let_op = term_of_op letOp in
-                 let t =
-                   FStar_Parser_AST.mkExplicitApp let_op [mproduct_def; fn]
-                     top.FStar_Parser_AST.range in
-                 desugar_term_aq env t)
-        | FStar_Parser_AST.Let (qual, lbs, body) ->
-            let is_rec = qual = FStar_Parser_AST.Rec in
-            let ds_let_rec_or_app uu___1 =
-              let bindings = lbs in
-              let funs =
-                FStar_Compiler_Effect.op_Bar_Greater bindings
-                  (FStar_Compiler_List.map
-                     (fun uu___2 ->
-                        match uu___2 with
-                        | (attr_opt, (p, def)) ->
-                            let uu___3 = is_app_pattern p in
-                            if uu___3
-                            then
-                              let uu___4 =
-                                destruct_app_pattern env top_level p in
-                              (attr_opt, uu___4, def)
-                            else
-                              (match FStar_Parser_AST.un_function p def with
-                               | FStar_Pervasives_Native.Some (p1, def1) ->
-                                   let uu___5 =
-                                     destruct_app_pattern env top_level p1 in
-                                   (attr_opt, uu___5, def1)
-                               | uu___5 ->
-                                   (match p.FStar_Parser_AST.pat with
-                                    | FStar_Parser_AST.PatAscribed
-                                        ({
-                                           FStar_Parser_AST.pat =
-                                             FStar_Parser_AST.PatVar
-                                             (id, uu___6, uu___7);
-                                           FStar_Parser_AST.prange = uu___8;_},
-                                         t)
-                                        ->
-                                        if top_level
-                                        then
-                                          let uu___9 =
-                                            let uu___10 =
-                                              let uu___11 =
-                                                FStar_Syntax_DsEnv.qualify
-                                                  env id in
-                                              FStar_Pervasives.Inr uu___11 in
-                                            (uu___10, [],
-                                              (FStar_Pervasives_Native.Some t)) in
-                                          (attr_opt, uu___9, def)
-                                        else
-                                          (attr_opt,
-                                            ((FStar_Pervasives.Inl id), [],
-                                              (FStar_Pervasives_Native.Some t)),
-                                            def)
-                                    | FStar_Parser_AST.PatVar
-                                        (id, uu___6, uu___7) ->
-                                        if top_level
-                                        then
-                                          let uu___8 =
-                                            let uu___9 =
-                                              let uu___10 =
-                                                FStar_Syntax_DsEnv.qualify
-                                                  env id in
-                                              FStar_Pervasives.Inr uu___10 in
-                                            (uu___9, [],
-                                              FStar_Pervasives_Native.None) in
-                                          (attr_opt, uu___8, def)
-                                        else
-                                          (attr_opt,
-                                            ((FStar_Pervasives.Inl id), [],
-                                              FStar_Pervasives_Native.None),
-                                            def)
-                                    | uu___6 ->
-                                        FStar_Errors.raise_error
-                                          (FStar_Errors.Fatal_UnexpectedLetBinding,
-                                            "Unexpected let binding")
-                                          p.FStar_Parser_AST.prange)))) in
-              let uu___2 =
-                FStar_Compiler_List.fold_left
-                  (fun uu___3 ->
-                     fun uu___4 ->
-                       match (uu___3, uu___4) with
-                       | ((env1, fnames, rec_bindings, used_markers),
-                          (_attr_opt, (f, uu___5, uu___6), uu___7)) ->
-                           let uu___8 =
-                             match f with
-                             | FStar_Pervasives.Inl x ->
-                                 let uu___9 =
-                                   FStar_Syntax_DsEnv.push_bv' env1 x in
-                                 (match uu___9 with
-                                  | (env2, xx, used_marker) ->
-                                      let dummy_ref =
-                                        FStar_Compiler_Util.mk_ref true in
-                                      let uu___10 =
-                                        let uu___11 =
-                                          FStar_Syntax_Syntax.mk_binder xx in
-                                        uu___11 :: rec_bindings in
-                                      (env2, (FStar_Pervasives.Inl xx),
-                                        uu___10, (used_marker ::
-                                        used_markers)))
-                             | FStar_Pervasives.Inr l ->
-                                 let uu___9 =
-                                   let uu___10 = FStar_Ident.ident_of_lid l in
-                                   FStar_Syntax_DsEnv.push_top_level_rec_binding
-                                     env1 uu___10
-                                     FStar_Syntax_Syntax.delta_equational in
-                                 (match uu___9 with
-                                  | (env2, used_marker) ->
-                                      (env2, (FStar_Pervasives.Inr l),
-                                        rec_bindings, (used_marker ::
-                                        used_markers))) in
-                           (match uu___8 with
-                            | (env2, lbname, rec_bindings1, used_markers1) ->
-                                (env2, (lbname :: fnames), rec_bindings1,
-                                  used_markers1))) (env, [], [], []) funs in
-              match uu___2 with
-              | (env', fnames, rec_bindings, used_markers) ->
-                  let fnames1 = FStar_Compiler_List.rev fnames in
-                  let rec_bindings1 = FStar_Compiler_List.rev rec_bindings in
-                  let used_markers1 = FStar_Compiler_List.rev used_markers in
-                  let desugar_one_def env1 lbname uu___3 =
-                    match uu___3 with
-                    | (attrs_opt, (uu___4, args, result_t), def) ->
-                        let args1 =
-                          FStar_Compiler_Effect.op_Bar_Greater args
-                            (FStar_Compiler_List.map replace_unit_pattern) in
-                        let pos = def.FStar_Parser_AST.range in
-                        let def1 =
-                          match result_t with
-                          | FStar_Pervasives_Native.None -> def
-                          | FStar_Pervasives_Native.Some (t, tacopt) ->
-                              let t1 =
-                                let uu___5 = is_comp_type env1 t in
-                                if uu___5
-                                then
-                                  ((let uu___7 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        args1
-                                        (FStar_Compiler_List.tryFind
-                                           (fun x ->
-                                              let uu___8 = is_var_pattern x in
-                                              Prims.op_Negation uu___8)) in
-                                    match uu___7 with
-                                    | FStar_Pervasives_Native.None -> ()
-                                    | FStar_Pervasives_Native.Some p ->
-                                        FStar_Errors.raise_error
-                                          (FStar_Errors.Fatal_ComputationTypeNotAllowed,
-                                            "Computation type annotations are only permitted on let-bindings without inlined patterns; replace this pattern with a variable")
-                                          p.FStar_Parser_AST.prange);
-                                   t)
-                                else
-                                  (let uu___7 =
-                                     ((FStar_Options.ml_ish ()) &&
-                                        (let uu___8 =
-                                           let uu___9 =
-                                             FStar_Parser_Const.effect_ML_lid
-                                               () in
-                                           FStar_Syntax_DsEnv.try_lookup_effect_name
-                                             env1 uu___9 in
-                                         FStar_Compiler_Option.isSome uu___8))
-                                       &&
-                                       ((Prims.op_Negation is_rec) ||
-                                          ((FStar_Compiler_List.length args1)
-                                             <> Prims.int_zero)) in
-                                   if uu___7
-                                   then FStar_Parser_AST.ml_comp t
-                                   else FStar_Parser_AST.tot_comp t) in
-                              FStar_Parser_AST.mk_term
-                                (FStar_Parser_AST.Ascribed
-                                   (def, t1, tacopt, false))
-                                def.FStar_Parser_AST.range
-                                FStar_Parser_AST.Expr in
-                        let def2 =
-                          match args1 with
-                          | [] -> def1
-                          | uu___5 ->
-                              FStar_Parser_AST.mk_term
-                                (FStar_Parser_AST.un_curry_abs args1 def1)
-                                top.FStar_Parser_AST.range
-                                top.FStar_Parser_AST.level in
-                        let uu___5 = desugar_term_aq env1 def2 in
-                        (match uu___5 with
-                         | (body1, aq) ->
-                             let lbname1 =
-                               match lbname with
-                               | FStar_Pervasives.Inl x ->
-                                   FStar_Pervasives.Inl x
-                               | FStar_Pervasives.Inr l ->
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_Syntax_Util.incr_delta_qualifier
-                                         body1 in
-                                     FStar_Syntax_Syntax.lid_as_fv l uu___7
-                                       FStar_Pervasives_Native.None in
-                                   FStar_Pervasives.Inr uu___6 in
-                             let body2 =
-                               if is_rec
-                               then
-                                 FStar_Syntax_Subst.close rec_bindings1 body1
-                               else body1 in
-                             let attrs =
-                               match attrs_opt with
-                               | FStar_Pervasives_Native.None -> []
-                               | FStar_Pervasives_Native.Some l ->
-                                   FStar_Compiler_List.map
-                                     (desugar_term env1) l in
-                             let uu___6 =
-                               mk_lb
-                                 (attrs, lbname1,
-                                   (setpos FStar_Syntax_Syntax.tun), body2,
-                                   pos) in
-                             (uu___6, aq)) in
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_List.map2
-                        (desugar_one_def (if is_rec then env' else env))
-                        fnames1 funs in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___4
-                      FStar_Compiler_List.unzip in
-                  (match uu___3 with
-                   | (lbs1, aqss) ->
-                       let uu___4 = desugar_term_aq env' body in
-                       (match uu___4 with
-                        | (body1, aq) ->
-                            (if is_rec
-                             then
-                               FStar_Compiler_List.iter2
-                                 (fun uu___6 ->
-                                    fun used_marker ->
-                                      match uu___6 with
-                                      | (_attr_opt, (f, uu___7, uu___8),
-                                         uu___9) ->
-                                          let uu___10 =
-                                            let uu___11 =
-                                              FStar_Compiler_Effect.op_Bang
-                                                used_marker in
-                                            Prims.op_Negation uu___11 in
-                                          if uu___10
-                                          then
-                                            let uu___11 =
-                                              match f with
-                                              | FStar_Pervasives.Inl x ->
-                                                  let uu___12 =
-                                                    FStar_Ident.string_of_id
-                                                      x in
-                                                  let uu___13 =
-                                                    FStar_Ident.range_of_id x in
-                                                  (uu___12, "Local", uu___13)
-                                              | FStar_Pervasives.Inr l ->
-                                                  let uu___12 =
-                                                    FStar_Ident.string_of_lid
-                                                      l in
-                                                  let uu___13 =
-                                                    FStar_Ident.range_of_lid
-                                                      l in
-                                                  (uu___12, "Global",
-                                                    uu___13) in
-                                            (match uu___11 with
-                                             | (nm, gl, rng) ->
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     FStar_Compiler_Util.format2
-                                                       "%s binding %s is recursive but not used in its body"
-                                                       gl nm in
-                                                   (FStar_Errors.Warning_UnusedLetRec,
-                                                     uu___13) in
-                                                 FStar_Errors.log_issue rng
-                                                   uu___12)
-                                          else ()) funs used_markers1
-                             else ();
-                             (let uu___6 =
-                                let uu___7 =
-                                  let uu___8 =
-                                    let uu___9 =
-                                      FStar_Syntax_Subst.close rec_bindings1
-                                        body1 in
-                                    ((is_rec, lbs1), uu___9) in
-                                  FStar_Syntax_Syntax.Tm_let uu___8 in
-                                FStar_Compiler_Effect.op_Less_Bar mk uu___7 in
-                              (uu___6,
-                                (FStar_Compiler_List.op_At aq
-                                   (FStar_Compiler_List.flatten aqss))))))) in
-            let ds_non_rec attrs_opt pat t1 t2 =
-              let attrs =
-                match attrs_opt with
-                | FStar_Pervasives_Native.None -> []
-                | FStar_Pervasives_Native.Some l ->
-                    FStar_Compiler_List.map (desugar_term env) l in
-              let uu___1 = desugar_term_aq env t1 in
-              match uu___1 with
-              | (t11, aq0) ->
-                  let uu___2 =
-                    desugar_binding_pat_maybe_top top_level env pat in
-                  (match uu___2 with
-                   | (env1, binder, pat1) ->
-                       let uu___3 =
-                         match binder with
-                         | LetBinder (l, (t, tacopt)) ->
-                             ((let uu___5 =
-                                 FStar_Compiler_Effect.op_Bar_Greater tacopt
-                                   FStar_Compiler_Util.is_some in
-                               if uu___5
-                               then
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       tacopt FStar_Compiler_Util.must in
-                                   uu___7.FStar_Syntax_Syntax.pos in
-                                 FStar_Errors.log_issue uu___6
-                                   (FStar_Errors.Warning_DefinitionNotTranslated,
-                                     "Tactic annotation with a value type is not supported yet, try annotating with a computation type; this tactic annotation will be ignored")
-                               else ());
-                              (let uu___5 = desugar_term_aq env1 t2 in
-                               match uu___5 with
-                               | (body1, aq) ->
-                                   let fv =
-                                     let uu___6 =
-                                       FStar_Syntax_Util.incr_delta_qualifier
-                                         t11 in
-                                     FStar_Syntax_Syntax.lid_as_fv l uu___6
-                                       FStar_Pervasives_Native.None in
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               mk_lb
-                                                 (attrs,
-                                                   (FStar_Pervasives.Inr fv),
-                                                   t, t11,
-                                                   (t11.FStar_Syntax_Syntax.pos)) in
-                                             [uu___11] in
-                                           (false, uu___10) in
-                                         (uu___9, body1) in
-                                       FStar_Syntax_Syntax.Tm_let uu___8 in
-                                     FStar_Compiler_Effect.op_Less_Bar mk
-                                       uu___7 in
-                                   (uu___6, aq)))
-                         | LocalBinder (x, uu___4, uu___5) ->
-                             let uu___6 = desugar_term_aq env1 t2 in
-                             (match uu___6 with
-                              | (body1, aq) ->
-                                  let body2 =
-                                    match pat1 with
-                                    | [] -> body1
-                                    | ({
-                                         FStar_Syntax_Syntax.v =
-                                           FStar_Syntax_Syntax.Pat_wild
-                                           uu___7;
-                                         FStar_Syntax_Syntax.p = uu___8;_},
-                                       uu___9)::[] -> body1
-                                    | uu___7 ->
-                                        let uu___8 =
-                                          let uu___9 =
-                                            let uu___10 =
-                                              FStar_Syntax_Syntax.bv_to_name
-                                                x in
-                                            let uu___11 =
-                                              desugar_disjunctive_pattern
-                                                pat1
-                                                FStar_Pervasives_Native.None
-                                                body1 in
-                                            (uu___10,
-                                              FStar_Pervasives_Native.None,
-                                              uu___11,
-                                              FStar_Pervasives_Native.None) in
-                                          FStar_Syntax_Syntax.Tm_match uu___9 in
-                                        FStar_Syntax_Syntax.mk uu___8
-                                          top.FStar_Parser_AST.range in
-                                  let uu___7 =
-                                    let uu___8 =
-                                      let uu___9 =
-                                        let uu___10 =
-                                          let uu___11 =
-                                            let uu___12 =
-                                              mk_lb
-                                                (attrs,
-                                                  (FStar_Pervasives.Inl x),
-                                                  (x.FStar_Syntax_Syntax.sort),
-                                                  t11,
-                                                  (t11.FStar_Syntax_Syntax.pos)) in
-                                            [uu___12] in
-                                          (false, uu___11) in
-                                        let uu___11 =
-                                          let uu___12 =
-                                            let uu___13 =
-                                              FStar_Syntax_Syntax.mk_binder x in
-                                            [uu___13] in
-                                          FStar_Syntax_Subst.close uu___12
-                                            body2 in
-                                        (uu___10, uu___11) in
-                                      FStar_Syntax_Syntax.Tm_let uu___9 in
-                                    FStar_Compiler_Effect.op_Less_Bar mk
-                                      uu___8 in
-                                  (uu___7, aq)) in
-                       (match uu___3 with
-                        | (tm, aq1) ->
-                            (tm, (FStar_Compiler_List.op_At aq0 aq1)))) in
-            let uu___1 = FStar_Compiler_List.hd lbs in
-            (match uu___1 with
-             | (attrs, (head_pat, defn)) ->
-                 let uu___2 = is_rec || (is_app_pattern head_pat) in
-                 if uu___2
-                 then ds_let_rec_or_app ()
-                 else ds_non_rec attrs head_pat defn body)
-        | FStar_Parser_AST.If
-            (e, FStar_Pervasives_Native.Some op, asc_opt, t2, t3) ->
-            let var_id =
-              FStar_Ident.mk_ident
-                ((Prims.op_Hat FStar_Ident.reserved_prefix "if_op_head"),
-                  (e.FStar_Parser_AST.range)) in
-            let var =
-              let uu___1 =
-                let uu___2 = FStar_Ident.lid_of_ids [var_id] in
-                FStar_Parser_AST.Var uu___2 in
-              FStar_Parser_AST.mk_term uu___1 e.FStar_Parser_AST.range
-                FStar_Parser_AST.Expr in
-            let pat =
-              FStar_Parser_AST.mk_pattern
-                (FStar_Parser_AST.PatVar
-                   (var_id, FStar_Pervasives_Native.None, []))
-                e.FStar_Parser_AST.range in
-            let if_ =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.If
-                   (var, FStar_Pervasives_Native.None, asc_opt, t2, t3))
-                top.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-            let t =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.LetOperator ([(op, pat, e)], if_))
-                e.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-            desugar_term_aq env t
-        | FStar_Parser_AST.If
-            (t1, FStar_Pervasives_Native.None, asc_opt, t2, t3) ->
-            let x =
-              let uu___1 = tun_r t3.FStar_Parser_AST.range in
-              FStar_Syntax_Syntax.new_bv
-                (FStar_Pervasives_Native.Some (t3.FStar_Parser_AST.range))
-                uu___1 in
-            let t_bool =
-              let uu___1 =
-                let uu___2 =
-                  FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.bool_lid
-                    FStar_Syntax_Syntax.delta_constant
-                    FStar_Pervasives_Native.None in
-                FStar_Syntax_Syntax.Tm_fvar uu___2 in
-              mk uu___1 in
-            let uu___1 = desugar_term_aq env t1 in
-            (match uu___1 with
-             | (t1', aq1) ->
-                 let t1'1 =
-                   FStar_Syntax_Util.ascribe t1'
-                     ((FStar_Pervasives.Inl t_bool),
-                       FStar_Pervasives_Native.None, false) in
-                 let uu___2 = desugar_match_returns env t1'1 asc_opt in
-                 (match uu___2 with
-                  | (asc_opt1, aq0) ->
-                      let uu___3 = desugar_term_aq env t2 in
-                      (match uu___3 with
-                       | (t2', aq2) ->
-                           let uu___4 = desugar_term_aq env t3 in
-                           (match uu___4 with
-                            | (t3', aq3) ->
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      let uu___8 =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            FStar_Syntax_Syntax.withinfo
-                                              (FStar_Syntax_Syntax.Pat_constant
-                                                 (FStar_Const.Const_bool true))
-                                              t1.FStar_Parser_AST.range in
-                                          (uu___10,
-                                            FStar_Pervasives_Native.None,
-                                            t2') in
-                                        let uu___10 =
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_Syntax_Syntax.withinfo
-                                                (FStar_Syntax_Syntax.Pat_wild
-                                                   x)
-                                                t1.FStar_Parser_AST.range in
-                                            (uu___12,
-                                              FStar_Pervasives_Native.None,
-                                              t3') in
-                                          [uu___11] in
-                                        uu___9 :: uu___10 in
-                                      (t1'1, asc_opt1, uu___8,
-                                        FStar_Pervasives_Native.None) in
-                                    FStar_Syntax_Syntax.Tm_match uu___7 in
-                                  mk uu___6 in
-                                (uu___5, (join_aqs [aq1; aq0; aq2; aq3]))))))
-        | FStar_Parser_AST.TryWith (e, branches) ->
-            let r = top.FStar_Parser_AST.range in
-            let handler = FStar_Parser_AST.mk_function branches r r in
-            let body =
-              FStar_Parser_AST.mk_function
-                [((FStar_Parser_AST.mk_pattern
-                     (FStar_Parser_AST.PatConst FStar_Const.Const_unit) r),
-                   FStar_Pervasives_Native.None, e)] r r in
-            let try_with_lid = FStar_Ident.lid_of_path ["try_with"] r in
-            let try_with =
-              FStar_Parser_AST.mk_term (FStar_Parser_AST.Var try_with_lid) r
-                FStar_Parser_AST.Expr in
-            let a1 =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.App
-                   (try_with, body, FStar_Parser_AST.Nothing)) r
-                top.FStar_Parser_AST.level in
-            let a2 =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.App (a1, handler, FStar_Parser_AST.Nothing))
-                r top.FStar_Parser_AST.level in
-            desugar_term_aq env a2
-        | FStar_Parser_AST.Match
-            (e, FStar_Pervasives_Native.Some op, topt, branches) ->
-            let var_id =
-              FStar_Ident.mk_ident
-                ((Prims.op_Hat FStar_Ident.reserved_prefix "match_op_head"),
-                  (e.FStar_Parser_AST.range)) in
-            let var =
-              let uu___1 =
-                let uu___2 = FStar_Ident.lid_of_ids [var_id] in
-                FStar_Parser_AST.Var uu___2 in
-              FStar_Parser_AST.mk_term uu___1 e.FStar_Parser_AST.range
-                FStar_Parser_AST.Expr in
-            let pat =
-              FStar_Parser_AST.mk_pattern
-                (FStar_Parser_AST.PatVar
-                   (var_id, FStar_Pervasives_Native.None, []))
-                e.FStar_Parser_AST.range in
-            let mt =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.Match
-                   (var, FStar_Pervasives_Native.None, topt, branches))
-                top.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-            let t =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.LetOperator ([(op, pat, e)], mt))
-                e.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-            desugar_term_aq env t
-        | FStar_Parser_AST.Match
-            (e, FStar_Pervasives_Native.None, topt, branches) ->
-            let desugar_branch uu___1 =
-              match uu___1 with
-              | (pat, wopt, b) ->
-                  let uu___2 = desugar_match_pat env pat in
-                  (match uu___2 with
-                   | (env1, pat1) ->
-                       let wopt1 =
-                         match wopt with
-                         | FStar_Pervasives_Native.None ->
-                             FStar_Pervasives_Native.None
-                         | FStar_Pervasives_Native.Some e1 ->
-                             let uu___3 = desugar_term env1 e1 in
-                             FStar_Pervasives_Native.Some uu___3 in
-                       let uu___3 = desugar_term_aq env1 b in
-                       (match uu___3 with
-                        | (b1, aq) ->
-                            let uu___4 =
-                              desugar_disjunctive_pattern pat1 wopt1 b1 in
-                            (uu___4, aq))) in
-            let uu___1 = desugar_term_aq env e in
-            (match uu___1 with
-             | (e1, aq) ->
-                 let uu___2 = desugar_match_returns env e1 topt in
-                 (match uu___2 with
-                  | (asc_opt, aq0) ->
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_Compiler_List.map desugar_branch branches in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            FStar_Compiler_List.unzip in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___4
-                          (fun uu___5 ->
-                             match uu___5 with
-                             | (x, y) -> ((FStar_Compiler_List.flatten x), y)) in
-                      (match uu___3 with
-                       | (brs, aqs) ->
-                           let uu___4 =
-                             FStar_Compiler_Effect.op_Less_Bar mk
-                               (FStar_Syntax_Syntax.Tm_match
-                                  (e1, asc_opt, brs,
-                                    FStar_Pervasives_Native.None)) in
-                           (uu___4, (join_aqs (aq :: aq0 :: aqs))))))
-        | FStar_Parser_AST.Ascribed (e, t, tac_opt, use_eq) ->
-            let uu___1 = desugar_ascription env t tac_opt use_eq in
-            (match uu___1 with
-             | (asc, aq0) ->
-                 let uu___2 = desugar_term_aq env e in
-                 (match uu___2 with
-                  | (e1, aq) ->
-                      let uu___3 =
-                        FStar_Compiler_Effect.op_Less_Bar mk
-                          (FStar_Syntax_Syntax.Tm_ascribed
-                             (e1, asc, FStar_Pervasives_Native.None)) in
-                      (uu___3, (FStar_Compiler_List.op_At aq0 aq))))
-        | FStar_Parser_AST.Record (uu___1, []) ->
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_UnexpectedEmptyRecord,
-                "Unexpected empty record") top.FStar_Parser_AST.range
-        | FStar_Parser_AST.Record (eopt, fields) ->
-            let record_opt =
-              let uu___1 = FStar_Compiler_List.hd fields in
-              match uu___1 with
-              | (f, uu___2) ->
-                  FStar_Syntax_DsEnv.try_lookup_record_by_field_name env f in
-            let uu___1 =
-              let uu___2 =
-                FStar_Compiler_List.map
-                  (fun uu___3 ->
-                     match uu___3 with
-                     | (fn, fval) ->
-                         let uu___4 = desugar_term_aq env fval in
-                         (match uu___4 with
-                          | (fval1, aq) -> ((fn, fval1), aq))) fields in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_Compiler_List.unzip in
-            (match uu___1 with
-             | (fields1, aqs) ->
-                 let uu___2 = FStar_Compiler_List.unzip fields1 in
-                 (match uu___2 with
-                  | (field_names, assignments) ->
-                      let args =
-                        FStar_Compiler_List.map
-                          (fun f -> (f, FStar_Pervasives_Native.None))
-                          assignments in
-                      let aqs1 = FStar_Compiler_List.flatten aqs in
-                      let uc =
-                        match record_opt with
-                        | FStar_Pervasives_Native.None ->
-                            {
-                              FStar_Syntax_Syntax.uc_base_term =
-                                (FStar_Compiler_Option.isSome eopt);
-                              FStar_Syntax_Syntax.uc_typename =
-                                FStar_Pervasives_Native.None;
-                              FStar_Syntax_Syntax.uc_fields = field_names
-                            }
-                        | FStar_Pervasives_Native.Some record ->
-                            let uu___3 =
-                              qualify_field_names
-                                record.FStar_Syntax_DsEnv.typename
-                                field_names in
-                            {
-                              FStar_Syntax_Syntax.uc_base_term =
-                                (FStar_Compiler_Option.isSome eopt);
-                              FStar_Syntax_Syntax.uc_typename =
-                                (FStar_Pervasives_Native.Some
-                                   (record.FStar_Syntax_DsEnv.typename));
-                              FStar_Syntax_Syntax.uc_fields = uu___3
-                            } in
-                      let head =
-                        let lid =
-                          FStar_Ident.lid_of_path ["__dummy__"]
-                            top.FStar_Parser_AST.range in
-                        FStar_Syntax_Syntax.fvar lid
-                          FStar_Syntax_Syntax.delta_constant
-                          (FStar_Pervasives_Native.Some
-                             (FStar_Syntax_Syntax.Unresolved_constructor uc)) in
-                      let mk_result args1 =
-                        FStar_Syntax_Syntax.mk_Tm_app head args1
-                          top.FStar_Parser_AST.range in
-                      (match eopt with
-                       | FStar_Pervasives_Native.None ->
-                           let uu___3 = mk_result args in (uu___3, aqs1)
-                       | FStar_Pervasives_Native.Some e ->
-                           let uu___3 = desugar_term_aq env e in
-                           (match uu___3 with
-                            | (e1, aq) ->
-                                let tm =
-                                  let uu___4 =
-                                    let uu___5 =
-                                      FStar_Syntax_Subst.compress e1 in
-                                    uu___5.FStar_Syntax_Syntax.n in
-                                  match uu___4 with
-                                  | FStar_Syntax_Syntax.Tm_name uu___5 ->
-                                      mk_result
-                                        ((e1, FStar_Pervasives_Native.None)
-                                        :: args)
-                                  | FStar_Syntax_Syntax.Tm_fvar uu___5 ->
-                                      mk_result
-                                        ((e1, FStar_Pervasives_Native.None)
-                                        :: args)
-                                  | uu___5 ->
-                                      let x =
-                                        FStar_Ident.gen
-                                          e1.FStar_Syntax_Syntax.pos in
-                                      let uu___6 =
-                                        FStar_Syntax_DsEnv.push_bv env x in
-                                      (match uu___6 with
-                                       | (env', bv_x) ->
-                                           let nm =
-                                             FStar_Syntax_Syntax.bv_to_name
-                                               bv_x in
-                                           let body =
-                                             mk_result
-                                               ((nm,
-                                                  FStar_Pervasives_Native.None)
-                                               :: args) in
-                                           let body1 =
-                                             let uu___7 =
-                                               let uu___8 =
-                                                 FStar_Syntax_Syntax.mk_binder
-                                                   bv_x in
-                                               [uu___8] in
-                                             FStar_Syntax_Subst.close uu___7
-                                               body in
-                                           let lb =
-                                             mk_lb
-                                               ([],
-                                                 (FStar_Pervasives.Inl bv_x),
-                                                 FStar_Syntax_Syntax.tun, e1,
-                                                 (e1.FStar_Syntax_Syntax.pos)) in
-                                           mk
-                                             (FStar_Syntax_Syntax.Tm_let
-                                                ((false, [lb]), body1))) in
-                                (tm, (FStar_Compiler_List.op_At aq aqs1))))))
-        | FStar_Parser_AST.Project (e, f) ->
-            let uu___1 = desugar_term_aq env e in
-            (match uu___1 with
-             | (e1, s) ->
-                 let head =
-                   let uu___2 =
-                     FStar_Syntax_DsEnv.try_lookup_dc_by_field_name env f in
-                   match uu___2 with
-                   | FStar_Pervasives_Native.None ->
-                       FStar_Syntax_Syntax.fvar f
-                         (FStar_Syntax_Syntax.Delta_equational_at_level
-                            Prims.int_one)
-                         (FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Unresolved_projector
-                               FStar_Pervasives_Native.None))
-                   | FStar_Pervasives_Native.Some (constrname, is_rec) ->
-                       let projname =
-                         let uu___3 = FStar_Ident.ident_of_lid f in
-                         FStar_Syntax_Util.mk_field_projector_name_from_ident
-                           constrname uu___3 in
-                       let qual =
-                         if is_rec
-                         then
-                           let uu___3 =
-                             let uu___4 =
-                               let uu___5 = FStar_Ident.ident_of_lid f in
-                               (constrname, uu___5) in
-                             FStar_Syntax_Syntax.Record_projector uu___4 in
-                           FStar_Pervasives_Native.Some uu___3
-                         else FStar_Pervasives_Native.None in
-                       let candidate_projector =
-                         let uu___3 =
-                           FStar_Ident.set_lid_range projname
-                             top.FStar_Parser_AST.range in
-                         FStar_Syntax_Syntax.lid_as_fv uu___3
-                           (FStar_Syntax_Syntax.Delta_equational_at_level
-                              Prims.int_one) qual in
-                       let qual1 =
-                         FStar_Syntax_Syntax.Unresolved_projector
-                           (FStar_Pervasives_Native.Some candidate_projector) in
-                       let f1 =
-                         let uu___3 = qualify_field_names constrname [f] in
-                         FStar_Compiler_List.hd uu___3 in
-                       FStar_Syntax_Syntax.fvar f1
-                         (FStar_Syntax_Syntax.Delta_equational_at_level
-                            Prims.int_one)
-                         (FStar_Pervasives_Native.Some qual1) in
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 = FStar_Syntax_Syntax.as_arg e1 in
-                         [uu___6] in
-                       (head, uu___5) in
-                     FStar_Syntax_Syntax.Tm_app uu___4 in
-                   FStar_Compiler_Effect.op_Less_Bar mk uu___3 in
-                 (uu___2, s))
-        | FStar_Parser_AST.NamedTyp (n, e) ->
-            ((let uu___2 = FStar_Ident.range_of_id n in
-              FStar_Errors.log_issue uu___2
-                (FStar_Errors.Warning_IgnoredBinding,
-                  "This name is being ignored"));
-             desugar_term_aq env e)
-        | FStar_Parser_AST.Paren e -> failwith "impossible"
-        | FStar_Parser_AST.VQuote e ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = desugar_vquote env e top.FStar_Parser_AST.range in
-                FStar_Syntax_Util.exp_string uu___3 in
-              {
-                FStar_Syntax_Syntax.n = (uu___2.FStar_Syntax_Syntax.n);
-                FStar_Syntax_Syntax.pos = (e.FStar_Parser_AST.range);
-                FStar_Syntax_Syntax.vars = (uu___2.FStar_Syntax_Syntax.vars);
-                FStar_Syntax_Syntax.hash_code =
-                  (uu___2.FStar_Syntax_Syntax.hash_code)
-              } in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.Quote (e, FStar_Parser_AST.Static) ->
-            let uu___1 = desugar_term_aq env e in
-            (match uu___1 with
-             | (tm, vts) ->
-                 let qi =
-                   {
-                     FStar_Syntax_Syntax.qkind =
-                       FStar_Syntax_Syntax.Quote_static;
-                     FStar_Syntax_Syntax.antiquotes = vts
-                   } in
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Less_Bar mk
-                     (FStar_Syntax_Syntax.Tm_quoted (tm, qi)) in
-                 (uu___2, noaqs))
-        | FStar_Parser_AST.Antiquote e ->
-            let bv =
-              FStar_Syntax_Syntax.new_bv
-                (FStar_Pervasives_Native.Some (e.FStar_Parser_AST.range))
-                FStar_Syntax_Syntax.tun in
-            let uu___1 = FStar_Syntax_Syntax.bv_to_name bv in
-            let uu___2 =
-              let uu___3 = let uu___4 = desugar_term env e in (bv, uu___4) in
-              [uu___3] in
-            (uu___1, uu___2)
-        | FStar_Parser_AST.Quote (e, FStar_Parser_AST.Dynamic) ->
-            let qi =
-              {
-                FStar_Syntax_Syntax.qkind = FStar_Syntax_Syntax.Quote_dynamic;
-                FStar_Syntax_Syntax.antiquotes = []
-              } in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = let uu___4 = desugar_term env e in (uu___4, qi) in
-                FStar_Syntax_Syntax.Tm_quoted uu___3 in
-              FStar_Compiler_Effect.op_Less_Bar mk uu___2 in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.CalcProof (rel, init_expr, steps) ->
-            let is_impl rel1 =
-              let is_impl_t t =
-                match t.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_fvar fv ->
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.imp_lid
-                | uu___1 -> false in
-              let uu___1 =
-                let uu___2 = unparen rel1 in uu___2.FStar_Parser_AST.tm in
-              match uu___1 with
-              | FStar_Parser_AST.Op (id, uu___2) ->
-                  let uu___3 = op_as_term env (Prims.of_int (2)) id in
-                  (match uu___3 with
-                   | FStar_Pervasives_Native.Some t -> is_impl_t t
-                   | FStar_Pervasives_Native.None -> false)
-              | FStar_Parser_AST.Var lid ->
-                  let uu___2 = desugar_name' (fun x -> x) env true lid in
-                  (match uu___2 with
-                   | FStar_Pervasives_Native.Some t -> is_impl_t t
-                   | FStar_Pervasives_Native.None -> false)
-              | FStar_Parser_AST.Tvar id ->
-                  let uu___2 = FStar_Syntax_DsEnv.try_lookup_id env id in
-                  (match uu___2 with
-                   | FStar_Pervasives_Native.Some t -> is_impl_t t
-                   | FStar_Pervasives_Native.None -> false)
-              | uu___2 -> false in
-            let eta_and_annot rel1 =
-              let x = FStar_Ident.gen' "x" rel1.FStar_Parser_AST.range in
-              let y = FStar_Ident.gen' "y" rel1.FStar_Parser_AST.range in
-              let xt =
-                FStar_Parser_AST.mk_term (FStar_Parser_AST.Tvar x)
-                  rel1.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-              let yt =
-                FStar_Parser_AST.mk_term (FStar_Parser_AST.Tvar y)
-                  rel1.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-              let pats =
-                [FStar_Parser_AST.mk_pattern
-                   (FStar_Parser_AST.PatVar
-                      (x, FStar_Pervasives_Native.None, []))
-                   rel1.FStar_Parser_AST.range;
-                FStar_Parser_AST.mk_pattern
-                  (FStar_Parser_AST.PatVar
-                     (y, FStar_Pervasives_Native.None, []))
-                  rel1.FStar_Parser_AST.range] in
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Parser_AST.mkApp rel1
-                            [(xt, FStar_Parser_AST.Nothing);
-                            (yt, FStar_Parser_AST.Nothing)]
-                            rel1.FStar_Parser_AST.range in
-                        let uu___7 =
-                          let uu___8 =
-                            let uu___9 = FStar_Ident.lid_of_str "Type0" in
-                            FStar_Parser_AST.Name uu___9 in
-                          FStar_Parser_AST.mk_term uu___8
-                            rel1.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-                        (uu___6, uu___7, FStar_Pervasives_Native.None, false) in
-                      FStar_Parser_AST.Ascribed uu___5 in
-                    FStar_Parser_AST.mk_term uu___4
-                      rel1.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-                  (pats, uu___3) in
-                FStar_Parser_AST.Abs uu___2 in
-              FStar_Parser_AST.mk_term uu___1 rel1.FStar_Parser_AST.range
-                FStar_Parser_AST.Expr in
-            let rel1 = eta_and_annot rel in
-            let wild r =
-              FStar_Parser_AST.mk_term FStar_Parser_AST.Wild r
-                FStar_Parser_AST.Expr in
-            let init =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.Var FStar_Parser_Const.calc_init_lid)
-                init_expr.FStar_Parser_AST.range FStar_Parser_AST.Expr in
-            let push_impl r =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.Var FStar_Parser_Const.calc_push_impl_lid)
-                r FStar_Parser_AST.Expr in
-            let last_expr =
-              let uu___1 = FStar_Compiler_List.last_opt steps in
-              match uu___1 with
-              | FStar_Pervasives_Native.Some (FStar_Parser_AST.CalcStep
-                  (uu___2, uu___3, last_expr1)) -> last_expr1
-              | FStar_Pervasives_Native.None -> init_expr in
-            let step r =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.Var FStar_Parser_Const.calc_step_lid) r
-                FStar_Parser_AST.Expr in
-            let finish =
-              FStar_Parser_AST.mkApp
-                (FStar_Parser_AST.mk_term
-                   (FStar_Parser_AST.Var FStar_Parser_Const.calc_finish_lid)
-                   top.FStar_Parser_AST.range FStar_Parser_AST.Expr)
-                [(rel1, FStar_Parser_AST.Nothing)] top.FStar_Parser_AST.range in
-            let e =
-              FStar_Parser_AST.mkApp init
-                [(init_expr, FStar_Parser_AST.Nothing)]
-                init_expr.FStar_Parser_AST.range in
-            let uu___1 =
-              FStar_Compiler_List.fold_left
-                (fun uu___2 ->
-                   fun uu___3 ->
-                     match (uu___2, uu___3) with
-                     | ((e1, prev), FStar_Parser_AST.CalcStep
-                        (rel2, just, next_expr)) ->
-                         let just1 =
-                           let uu___4 = is_impl rel2 in
-                           if uu___4
-                           then
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 = FStar_Parser_AST.thunk just in
-                                 (uu___7, FStar_Parser_AST.Nothing) in
-                               [uu___6] in
-                             FStar_Parser_AST.mkApp
-                               (push_impl just.FStar_Parser_AST.range) uu___5
-                               just.FStar_Parser_AST.range
-                           else just in
-                         let pf =
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 = eta_and_annot rel2 in
-                                     (uu___9, FStar_Parser_AST.Nothing) in
-                                   let uu___9 =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         let uu___12 =
-                                           FStar_Parser_AST.thunk e1 in
-                                         (uu___12, FStar_Parser_AST.Nothing) in
-                                       let uu___12 =
-                                         let uu___13 =
-                                           let uu___14 =
-                                             FStar_Parser_AST.thunk just1 in
-                                           (uu___14,
-                                             FStar_Parser_AST.Nothing) in
-                                         [uu___13] in
-                                       uu___11 :: uu___12 in
-                                     (next_expr, FStar_Parser_AST.Nothing) ::
-                                       uu___10 in
-                                   uu___8 :: uu___9 in
-                                 (prev, FStar_Parser_AST.Hash) :: uu___7 in
-                               (init_expr, FStar_Parser_AST.Hash) :: uu___6 in
-                             ((wild rel2.FStar_Parser_AST.range),
-                               FStar_Parser_AST.Hash) :: uu___5 in
-                           FStar_Parser_AST.mkApp
-                             (step rel2.FStar_Parser_AST.range) uu___4
-                             FStar_Compiler_Range.dummyRange in
-                         (pf, next_expr)) (e, init_expr) steps in
-            (match uu___1 with
-             | (e1, uu___2) ->
-                 let e2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 = FStar_Parser_AST.thunk e1 in
-                           (uu___7, FStar_Parser_AST.Nothing) in
-                         [uu___6] in
-                       (last_expr, FStar_Parser_AST.Hash) :: uu___5 in
-                     (init_expr, FStar_Parser_AST.Hash) :: uu___4 in
-                   FStar_Parser_AST.mkApp finish uu___3
-                     top.FStar_Parser_AST.range in
-                 desugar_term_maybe_top top_level env e2)
-        | FStar_Parser_AST.IntroForall (bs, p, e) ->
-            let uu___1 = desugar_binders env bs in
-            (match uu___1 with
-             | (env', bs1) ->
-                 let p1 = desugar_term env' p in
-                 let e1 = desugar_term env' e in
-                 let mk_forall_intro t p2 pf =
-                   let head =
-                     let uu___2 =
-                       FStar_Syntax_Syntax.lid_as_fv
-                         FStar_Parser_Const.forall_intro_lid
-                         FStar_Syntax_Syntax.delta_equational
-                         FStar_Pervasives_Native.None in
-                     FStar_Syntax_Syntax.fv_to_tm uu___2 in
-                   let args =
-                     [(t, FStar_Pervasives_Native.None);
-                     (p2, FStar_Pervasives_Native.None);
-                     (pf, FStar_Pervasives_Native.None)] in
-                   FStar_Syntax_Syntax.mk_Tm_app head args
-                     top.FStar_Parser_AST.range in
-                 let rec aux bs2 =
-                   match bs2 with
-                   | [] ->
-                       let sq_p =
-                         FStar_Syntax_Util.mk_squash
-                           FStar_Syntax_Syntax.U_unknown p1 in
-                       FStar_Syntax_Util.ascribe e1
-                         ((FStar_Pervasives.Inl sq_p),
-                           FStar_Pervasives_Native.None, false)
-                   | b::bs3 ->
-                       let tail = aux bs3 in
-                       let x = unqual_bv_of_binder b in
-                       let uu___2 =
-                         let uu___3 =
-                           FStar_Syntax_Util.close_forall_no_univs bs3 p1 in
-                         FStar_Syntax_Util.abs [b] uu___3
-                           FStar_Pervasives_Native.None in
-                       let uu___3 =
-                         FStar_Syntax_Util.abs [b] tail
-                           FStar_Pervasives_Native.None in
-                       mk_forall_intro x.FStar_Syntax_Syntax.sort uu___2
-                         uu___3 in
-                 let uu___2 = aux bs1 in (uu___2, noaqs))
-        | FStar_Parser_AST.IntroExists (bs, p, vs, e) ->
-            let uu___1 = desugar_binders env bs in
-            (match uu___1 with
-             | (env', bs1) ->
-                 let p1 = desugar_term env' p in
-                 let vs1 = FStar_Compiler_List.map (desugar_term env) vs in
-                 let e1 = desugar_term env e in
-                 let mk_exists_intro t p2 v e2 =
-                   let head =
-                     let uu___2 =
-                       FStar_Syntax_Syntax.lid_as_fv
-                         FStar_Parser_Const.exists_intro_lid
-                         FStar_Syntax_Syntax.delta_equational
-                         FStar_Pervasives_Native.None in
-                     FStar_Syntax_Syntax.fv_to_tm uu___2 in
-                   let args =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 =
-                             let uu___6 = mk_thunk e2 in
-                             (uu___6, FStar_Pervasives_Native.None) in
-                           [uu___5] in
-                         (v, FStar_Pervasives_Native.None) :: uu___4 in
-                       (p2, FStar_Pervasives_Native.None) :: uu___3 in
-                     (t, FStar_Pervasives_Native.None) :: uu___2 in
-                   FStar_Syntax_Syntax.mk_Tm_app head args
-                     top.FStar_Parser_AST.range in
-                 let rec aux bs2 vs2 sub token =
-                   match (bs2, vs2) with
-                   | ([], []) -> token
-                   | (b::bs3, v::vs3) ->
-                       let x = unqual_bv_of_binder b in
-                       let token1 =
-                         let uu___2 =
-                           FStar_Syntax_Subst.subst_binders
-                             ((FStar_Syntax_Syntax.NT (x, v)) :: sub) bs3 in
-                         aux uu___2 vs3 ((FStar_Syntax_Syntax.NT (x, v)) ::
-                           sub) token in
-                       let token2 =
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = FStar_Syntax_Subst.subst sub p1 in
-                             FStar_Syntax_Util.close_exists_no_univs bs3
-                               uu___4 in
-                           FStar_Syntax_Util.abs [b] uu___3
-                             FStar_Pervasives_Native.None in
-                         mk_exists_intro x.FStar_Syntax_Syntax.sort uu___2 v
-                           token1 in
-                       token2
-                   | uu___2 ->
-                       FStar_Errors.raise_error
-                         (FStar_Errors.Fatal_UnexpectedTerm,
-                           "Unexpected number of instantiations in _intro_ exists")
-                         top.FStar_Parser_AST.range in
-                 let uu___2 = aux bs1 vs1 [] e1 in (uu___2, noaqs))
-        | FStar_Parser_AST.IntroImplies (p, q, x, e) ->
-            let p1 = desugar_term env p in
-            let q1 = desugar_term env q in
-            let uu___1 = desugar_binders env [x] in
-            (match uu___1 with
-             | (env', x1::[]) ->
-                 let e1 = desugar_term env' e in
-                 let head =
-                   let uu___2 =
-                     FStar_Syntax_Syntax.lid_as_fv
-                       FStar_Parser_Const.implies_intro_lid
-                       FStar_Syntax_Syntax.delta_equational
-                       FStar_Pervasives_Native.None in
-                   FStar_Syntax_Syntax.fv_to_tm uu___2 in
-                 let args =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = mk_thunk q1 in
-                       (uu___4, FStar_Pervasives_Native.None) in
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Syntax_Util.abs [x1] e1
-                             FStar_Pervasives_Native.None in
-                         (uu___6, FStar_Pervasives_Native.None) in
-                       [uu___5] in
-                     uu___3 :: uu___4 in
-                   (p1, FStar_Pervasives_Native.None) :: uu___2 in
-                 let uu___2 =
-                   FStar_Syntax_Syntax.mk_Tm_app head args
-                     top.FStar_Parser_AST.range in
-                 (uu___2, noaqs))
-        | FStar_Parser_AST.IntroOr (lr, p, q, e) ->
-            let p1 = desugar_term env p in
-            let q1 = desugar_term env q in
-            let e1 = desugar_term env e in
-            let lid =
-              if lr
-              then FStar_Parser_Const.or_intro_left_lid
-              else FStar_Parser_Const.or_intro_right_lid in
-            let head =
-              let uu___1 =
-                FStar_Syntax_Syntax.lid_as_fv lid
-                  FStar_Syntax_Syntax.delta_equational
-                  FStar_Pervasives_Native.None in
-              FStar_Syntax_Syntax.fv_to_tm uu___1 in
-            let args =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = mk_thunk q1 in
-                  (uu___3, FStar_Pervasives_Native.None) in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = mk_thunk e1 in
-                    (uu___5, FStar_Pervasives_Native.None) in
-                  [uu___4] in
-                uu___2 :: uu___3 in
-              (p1, FStar_Pervasives_Native.None) :: uu___1 in
-            let uu___1 =
-              FStar_Syntax_Syntax.mk_Tm_app head args
-                top.FStar_Parser_AST.range in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.IntroAnd (p, q, e1, e2) ->
-            let p1 = desugar_term env p in
-            let q1 = desugar_term env q in
-            let e11 = desugar_term env e1 in
-            let e21 = desugar_term env e2 in
-            let head =
-              let uu___1 =
-                FStar_Syntax_Syntax.lid_as_fv
-                  FStar_Parser_Const.and_intro_lid
-                  FStar_Syntax_Syntax.delta_equational
-                  FStar_Pervasives_Native.None in
-              FStar_Syntax_Syntax.fv_to_tm uu___1 in
-            let args =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = mk_thunk q1 in
-                  (uu___3, FStar_Pervasives_Native.None) in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = mk_thunk e11 in
-                    (uu___5, FStar_Pervasives_Native.None) in
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 = mk_thunk e21 in
-                      (uu___7, FStar_Pervasives_Native.None) in
-                    [uu___6] in
-                  uu___4 :: uu___5 in
-                uu___2 :: uu___3 in
-              (p1, FStar_Pervasives_Native.None) :: uu___1 in
-            let uu___1 =
-              FStar_Syntax_Syntax.mk_Tm_app head args
-                top.FStar_Parser_AST.range in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.ElimForall (bs, p, vs) ->
-            let uu___1 = desugar_binders env bs in
-            (match uu___1 with
-             | (env', bs1) ->
-                 let p1 = desugar_term env' p in
-                 let vs1 = FStar_Compiler_List.map (desugar_term env) vs in
-                 let mk_forall_elim a p2 v t =
-                   let head =
-                     let uu___2 =
-                       FStar_Syntax_Syntax.lid_as_fv
-                         FStar_Parser_Const.forall_elim_lid
-                         FStar_Syntax_Syntax.delta_equational
-                         FStar_Pervasives_Native.None in
-                     FStar_Syntax_Syntax.fv_to_tm uu___2 in
-                   let args =
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Syntax_Syntax.as_aqual_implicit true in
-                       (a, uu___3) in
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Syntax_Syntax.as_aqual_implicit true in
-                         (p2, uu___5) in
-                       [uu___4;
-                       (v, FStar_Pervasives_Native.None);
-                       (t, FStar_Pervasives_Native.None)] in
-                     uu___2 :: uu___3 in
-                   FStar_Syntax_Syntax.mk_Tm_app head args
-                     v.FStar_Syntax_Syntax.pos in
-                 let rec aux bs2 vs2 sub token =
-                   match (bs2, vs2) with
-                   | ([], []) -> token
-                   | (b::bs3, v::vs3) ->
-                       let x = unqual_bv_of_binder b in
-                       let token1 =
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = FStar_Syntax_Subst.subst sub p1 in
-                             FStar_Syntax_Util.close_forall_no_univs bs3
-                               uu___4 in
-                           FStar_Syntax_Util.abs [b] uu___3
-                             FStar_Pervasives_Native.None in
-                         mk_forall_elim x.FStar_Syntax_Syntax.sort uu___2 v
-                           token in
-                       let sub1 = (FStar_Syntax_Syntax.NT (x, v)) :: sub in
-                       let uu___2 = FStar_Syntax_Subst.subst_binders sub1 bs3 in
-                       aux uu___2 vs3 sub1 token1
-                   | uu___2 ->
-                       FStar_Errors.raise_error
-                         (FStar_Errors.Fatal_UnexpectedTerm,
-                           "Unexpected number of instantiations in _elim_forall_")
-                         top.FStar_Parser_AST.range in
-                 let uu___2 = aux bs1 vs1 [] FStar_Syntax_Util.exp_unit in
-                 (uu___2, noaqs))
-        | FStar_Parser_AST.ElimExists (binders, p, q, binder, e) ->
-            let uu___1 = desugar_binders env binders in
-            (match uu___1 with
-             | (env', bs) ->
-                 let p1 = desugar_term env' p in
-                 let q1 = desugar_term env q in
-                 let sq_q =
-                   FStar_Syntax_Util.mk_squash FStar_Syntax_Syntax.U_unknown
-                     q1 in
-                 let uu___2 = desugar_binders env' [binder] in
-                 (match uu___2 with
-                  | (env'', b_pf_p::[]) ->
-                      let e1 = desugar_term env'' e in
-                      let rec mk_exists bs1 p2 =
-                        match bs1 with
-                        | [] -> failwith "Impossible"
-                        | b::[] ->
-                            let x = b.FStar_Syntax_Syntax.binder_bv in
-                            let head =
-                              let uu___3 =
-                                FStar_Syntax_Syntax.lid_as_fv
-                                  FStar_Parser_Const.exists_lid
-                                  FStar_Syntax_Syntax.delta_equational
-                                  FStar_Pervasives_Native.None in
-                              FStar_Syntax_Syntax.fv_to_tm uu___3 in
-                            let args =
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Syntax_Syntax.as_aqual_implicit true in
-                                ((x.FStar_Syntax_Syntax.sort), uu___4) in
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      let uu___8 = FStar_Compiler_List.hd bs1 in
-                                      [uu___8] in
-                                    FStar_Syntax_Util.abs uu___7 p2
-                                      FStar_Pervasives_Native.None in
-                                  (uu___6, FStar_Pervasives_Native.None) in
-                                [uu___5] in
-                              uu___3 :: uu___4 in
-                            FStar_Syntax_Syntax.mk_Tm_app head args
-                              p2.FStar_Syntax_Syntax.pos
-                        | b::bs2 ->
-                            let body = mk_exists bs2 p2 in mk_exists [b] body in
-                      let mk_exists_elim t x_p s_ex_p f r =
-                        let head =
-                          let uu___3 =
-                            FStar_Syntax_Syntax.lid_as_fv
-                              FStar_Parser_Const.exists_elim_lid
-                              FStar_Syntax_Syntax.delta_equational
-                              FStar_Pervasives_Native.None in
-                          FStar_Syntax_Syntax.fv_to_tm uu___3 in
-                        let args =
-                          let uu___3 =
-                            let uu___4 =
-                              FStar_Syntax_Syntax.as_aqual_implicit true in
-                            (t, uu___4) in
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Syntax_Syntax.as_aqual_implicit true in
-                              (x_p, uu___6) in
-                            [uu___5;
-                            (s_ex_p, FStar_Pervasives_Native.None);
-                            (f, FStar_Pervasives_Native.None)] in
-                          uu___3 :: uu___4 in
-                        FStar_Syntax_Syntax.mk_Tm_app head args r in
-                      let rec aux binders1 squash_token =
-                        match binders1 with
-                        | [] ->
-                            FStar_Errors.raise_error
-                              (FStar_Errors.Fatal_UnexpectedTerm,
-                                "Empty binders in ELIM_EXISTS")
-                              top.FStar_Parser_AST.range
-                        | b::[] ->
-                            let x = unqual_bv_of_binder b in
-                            let uu___3 =
-                              FStar_Syntax_Util.abs [b] p1
-                                FStar_Pervasives_Native.None in
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Syntax_Util.ascribe e1
-                                  ((FStar_Pervasives.Inl sq_q),
-                                    FStar_Pervasives_Native.None, false) in
-                              FStar_Syntax_Util.abs [b; b_pf_p] uu___5
-                                FStar_Pervasives_Native.None in
-                            let uu___5 = FStar_Syntax_Syntax.range_of_bv x in
-                            mk_exists_elim x.FStar_Syntax_Syntax.sort uu___3
-                              squash_token uu___4 uu___5
-                        | b::bs1 ->
-                            let pf_i =
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Syntax_Syntax.range_of_bv
-                                    b.FStar_Syntax_Syntax.binder_bv in
-                                FStar_Pervasives_Native.Some uu___4 in
-                              FStar_Syntax_Syntax.gen_bv "pf" uu___3
-                                FStar_Syntax_Syntax.tun in
-                            let k =
-                              let uu___3 =
-                                FStar_Syntax_Syntax.bv_to_name pf_i in
-                              aux bs1 uu___3 in
-                            let x = unqual_bv_of_binder b in
-                            let uu___3 =
-                              let uu___4 = mk_exists bs1 p1 in
-                              FStar_Syntax_Util.abs [b] uu___4
-                                FStar_Pervasives_Native.None in
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  let uu___7 =
-                                    FStar_Syntax_Syntax.mk_binder pf_i in
-                                  [uu___7] in
-                                b :: uu___6 in
-                              FStar_Syntax_Util.abs uu___5 k
-                                FStar_Pervasives_Native.None in
-                            let uu___5 = FStar_Syntax_Syntax.range_of_bv x in
-                            mk_exists_elim x.FStar_Syntax_Syntax.sort uu___3
-                              squash_token uu___4 uu___5 in
-                      let uu___3 = aux bs FStar_Syntax_Util.exp_unit in
-                      (uu___3, noaqs)))
-        | FStar_Parser_AST.ElimImplies (p, q, e) ->
-            let p1 = desugar_term env p in
-            let q1 = desugar_term env q in
-            let e1 = desugar_term env e in
-            let head =
-              let uu___1 =
-                FStar_Syntax_Syntax.lid_as_fv
-                  FStar_Parser_Const.implies_elim_lid
-                  FStar_Syntax_Syntax.delta_equational
-                  FStar_Pervasives_Native.None in
-              FStar_Syntax_Syntax.fv_to_tm uu___1 in
-            let args =
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = mk_thunk e1 in
-                      (uu___5, FStar_Pervasives_Native.None) in
-                    [uu___4] in
-                  (FStar_Syntax_Util.exp_unit, FStar_Pervasives_Native.None)
-                    :: uu___3 in
-                (q1, FStar_Pervasives_Native.None) :: uu___2 in
-              (p1, FStar_Pervasives_Native.None) :: uu___1 in
-            let uu___1 =
-              FStar_Syntax_Syntax.mk_Tm_app head args
-                top.FStar_Parser_AST.range in
-            (uu___1, noaqs)
-        | FStar_Parser_AST.ElimOr (p, q, r, x, e1, y, e2) ->
-            let p1 = desugar_term env p in
-            let q1 = desugar_term env q in
-            let r1 = desugar_term env r in
-            let uu___1 = desugar_binders env [x] in
-            (match uu___1 with
-             | (env_x, x1::[]) ->
-                 let e11 = desugar_term env_x e1 in
-                 let uu___2 = desugar_binders env [y] in
-                 (match uu___2 with
-                  | (env_y, y1::[]) ->
-                      let e21 = desugar_term env_y e2 in
-                      let head =
-                        let uu___3 =
-                          FStar_Syntax_Syntax.lid_as_fv
-                            FStar_Parser_Const.or_elim_lid
-                            FStar_Syntax_Syntax.delta_equational
-                            FStar_Pervasives_Native.None in
-                        FStar_Syntax_Syntax.fv_to_tm uu___3 in
-                      let extra_binder =
-                        let uu___3 =
-                          FStar_Syntax_Syntax.new_bv
-                            FStar_Pervasives_Native.None
-                            FStar_Syntax_Syntax.tun in
-                        FStar_Syntax_Syntax.mk_binder uu___3 in
-                      let args =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 = mk_thunk q1 in
-                            (uu___5, FStar_Pervasives_Native.None) in
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Syntax_Util.abs [x1] e11
-                                      FStar_Pervasives_Native.None in
-                                  (uu___9, FStar_Pervasives_Native.None) in
-                                let uu___9 =
-                                  let uu___10 =
-                                    let uu___11 =
-                                      FStar_Syntax_Util.abs
-                                        [extra_binder; y1] e21
-                                        FStar_Pervasives_Native.None in
-                                    (uu___11, FStar_Pervasives_Native.None) in
-                                  [uu___10] in
-                                uu___8 :: uu___9 in
-                              (FStar_Syntax_Util.exp_unit,
-                                FStar_Pervasives_Native.None) :: uu___7 in
-                            (r1, FStar_Pervasives_Native.None) :: uu___6 in
-                          uu___4 :: uu___5 in
-                        (p1, FStar_Pervasives_Native.None) :: uu___3 in
-                      let uu___3 =
-                        FStar_Syntax_Syntax.mk_Tm_app head args
-                          top.FStar_Parser_AST.range in
-                      (uu___3, noaqs)))
-        | FStar_Parser_AST.ElimAnd (p, q, r, x, y, e) ->
-            let p1 = desugar_term env p in
-            let q1 = desugar_term env q in
-            let r1 = desugar_term env r in
-            let uu___1 = desugar_binders env [x; y] in
-            (match uu___1 with
-             | (env', x1::y1::[]) ->
-                 let e1 = desugar_term env' e in
-                 let head =
-                   let uu___2 =
-                     FStar_Syntax_Syntax.lid_as_fv
-                       FStar_Parser_Const.and_elim_lid
-                       FStar_Syntax_Syntax.delta_equational
-                       FStar_Pervasives_Native.None in
-                   FStar_Syntax_Syntax.fv_to_tm uu___2 in
-                 let args =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = mk_thunk q1 in
-                       (uu___4, FStar_Pervasives_Native.None) in
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_Syntax_Util.abs [x1; y1] e1
-                                 FStar_Pervasives_Native.None in
-                             (uu___8, FStar_Pervasives_Native.None) in
-                           [uu___7] in
-                         (FStar_Syntax_Util.exp_unit,
-                           FStar_Pervasives_Native.None) :: uu___6 in
-                       (r1, FStar_Pervasives_Native.None) :: uu___5 in
-                     uu___3 :: uu___4 in
-                   (p1, FStar_Pervasives_Native.None) :: uu___2 in
-                 let uu___2 =
-                   FStar_Syntax_Syntax.mk_Tm_app head args
-                     top.FStar_Parser_AST.range in
-                 (uu___2, noaqs))
-        | uu___1 when top.FStar_Parser_AST.level = FStar_Parser_AST.Formula
-            -> let uu___2 = desugar_formula env top in (uu___2, noaqs)
-        | uu___1 ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Parser_AST.term_to_string top in
-                Prims.op_Hat "Unexpected term: " uu___4 in
-              (FStar_Errors.Fatal_UnexpectedTerm, uu___3) in
-            FStar_Errors.raise_error uu___2 top.FStar_Parser_AST.range
-and (desugar_match_returns :
-  env_t ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      (FStar_Ident.ident FStar_Pervasives_Native.option *
-        FStar_Parser_AST.term * Prims.bool) FStar_Pervasives_Native.option ->
-        ((FStar_Syntax_Syntax.binder *
-          ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-          FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-          Prims.bool)) FStar_Pervasives_Native.option *
-          (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax) Prims.list))
-  =
-  fun env ->
-    fun scrutinee ->
-      fun asc_opt ->
-        match asc_opt with
-        | FStar_Pervasives_Native.None -> (FStar_Pervasives_Native.None, [])
-        | FStar_Pervasives_Native.Some asc ->
-            let uu___ = asc in
-            (match uu___ with
-             | (asc_b, asc_tc, asc_use_eq) ->
-                 let uu___1 =
-                   match asc_b with
-                   | FStar_Pervasives_Native.None ->
-                       let bv =
-                         FStar_Syntax_Syntax.gen_bv
-                           FStar_Parser_Const.match_returns_def_name
-                           (FStar_Pervasives_Native.Some
-                              (scrutinee.FStar_Syntax_Syntax.pos))
-                           FStar_Syntax_Syntax.tun in
-                       let uu___2 = FStar_Syntax_Syntax.mk_binder bv in
-                       (env, uu___2)
-                   | FStar_Pervasives_Native.Some b ->
-                       let uu___2 = FStar_Syntax_DsEnv.push_bv env b in
-                       (match uu___2 with
-                        | (env1, bv) ->
-                            let uu___3 = FStar_Syntax_Syntax.mk_binder bv in
-                            (env1, uu___3)) in
-                 (match uu___1 with
-                  | (env_asc, b) ->
-                      let uu___2 =
-                        desugar_ascription env_asc asc_tc
-                          FStar_Pervasives_Native.None asc_use_eq in
-                      (match uu___2 with
-                       | (asc1, aq) ->
-                           let asc2 =
-                             let uu___3 =
-                               let uu___4 =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   scrutinee FStar_Syntax_Util.unascribe in
-                               uu___4.FStar_Syntax_Syntax.n in
-                             match uu___3 with
-                             | FStar_Syntax_Syntax.Tm_name sbv ->
-                                 let uu___4 =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Syntax_Syntax.bv_to_name
-                                           b.FStar_Syntax_Syntax.binder_bv in
-                                       (sbv, uu___7) in
-                                     FStar_Syntax_Syntax.NT uu___6 in
-                                   [uu___5] in
-                                 FStar_Syntax_Subst.subst_ascription uu___4
-                                   asc1
-                             | uu___4 -> asc1 in
-                           let asc3 =
-                             FStar_Syntax_Subst.close_ascription [b] asc2 in
-                           let b1 =
-                             let uu___3 =
-                               FStar_Syntax_Subst.close_binders [b] in
-                             FStar_Compiler_List.hd uu___3 in
-                           ((FStar_Pervasives_Native.Some (b1, asc3)), aq))))
-and (desugar_ascription :
-  env_t ->
-    FStar_Parser_AST.term ->
-      FStar_Parser_AST.term FStar_Pervasives_Native.option ->
-        Prims.bool ->
-          (FStar_Syntax_Syntax.ascription *
-            FStar_Syntax_Syntax.antiquotations))
-  =
-  fun env ->
-    fun t ->
-      fun tac_opt ->
-        fun use_eq ->
-          let uu___ =
-            let uu___1 = is_comp_type env t in
-            if uu___1
-            then
-              (if use_eq
-               then
-                 FStar_Errors.raise_error
-                   (FStar_Errors.Fatal_NotSupported,
-                     "Equality ascription with computation types is not supported yet")
-                   t.FStar_Parser_AST.range
-               else
-                 (let comp = desugar_comp t.FStar_Parser_AST.range true env t in
-                  ((FStar_Pervasives.Inr comp), [])))
-            else
-              (let uu___3 = desugar_term_aq env t in
-               match uu___3 with
-               | (tm, aq) -> ((FStar_Pervasives.Inl tm), aq)) in
-          match uu___ with
-          | (annot, aq0) ->
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Util.map_opt tac_opt (desugar_term env) in
-                (annot, uu___2, use_eq) in
-              (uu___1, aq0)
-and (desugar_args :
-  FStar_Syntax_DsEnv.env ->
-    (FStar_Parser_AST.term * FStar_Parser_AST.imp) Prims.list ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.arg_qualifier
-        FStar_Pervasives_Native.option) Prims.list)
-  =
-  fun env ->
-    fun args ->
-      FStar_Compiler_Effect.op_Bar_Greater args
-        (FStar_Compiler_List.map
-           (fun uu___ ->
-              match uu___ with
-              | (a, imp) ->
-                  let uu___1 = desugar_term env a in arg_withimp_t imp uu___1))
-and (desugar_comp :
-  FStar_Compiler_Range.range ->
-    Prims.bool ->
-      FStar_Syntax_DsEnv.env ->
-        FStar_Parser_AST.term ->
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  =
-  fun r ->
-    fun allow_type_promotion ->
-      fun env ->
-        fun t ->
-          let fail err = FStar_Errors.raise_error err r in
-          let is_requires uu___ =
-            match uu___ with
-            | (t1, uu___1) ->
-                let uu___2 =
-                  let uu___3 = unparen t1 in uu___3.FStar_Parser_AST.tm in
-                (match uu___2 with
-                 | FStar_Parser_AST.Requires uu___3 -> true
-                 | uu___3 -> false) in
-          let is_ensures uu___ =
-            match uu___ with
-            | (t1, uu___1) ->
-                let uu___2 =
-                  let uu___3 = unparen t1 in uu___3.FStar_Parser_AST.tm in
-                (match uu___2 with
-                 | FStar_Parser_AST.Ensures uu___3 -> true
-                 | uu___3 -> false) in
-          let is_decreases uu___ =
-            match uu___ with
-            | (t1, uu___1) ->
-                let uu___2 =
-                  let uu___3 = unparen t1 in uu___3.FStar_Parser_AST.tm in
-                (match uu___2 with
-                 | FStar_Parser_AST.Decreases uu___3 -> true
-                 | uu___3 -> false) in
-          let is_smt_pat uu___ =
-            match uu___ with
-            | (t1, uu___1) ->
-                let uu___2 =
-                  let uu___3 = unparen t1 in uu___3.FStar_Parser_AST.tm in
-                (match uu___2 with
-                 | FStar_Parser_AST.Construct
-                     (cons,
-                      ({
-                         FStar_Parser_AST.tm = FStar_Parser_AST.Construct
-                           (smtpat, uu___3);
-                         FStar_Parser_AST.range = uu___4;
-                         FStar_Parser_AST.level = uu___5;_},
-                       uu___6)::uu___7::[])
-                     ->
-                     (FStar_Ident.lid_equals cons FStar_Parser_Const.cons_lid)
-                       &&
-                       (FStar_Compiler_Util.for_some
-                          (fun s ->
-                             let uu___8 = FStar_Ident.string_of_lid smtpat in
-                             uu___8 = s) ["SMTPat"; "SMTPatT"; "SMTPatOr"])
-                 | FStar_Parser_AST.Construct
-                     (cons,
-                      ({ FStar_Parser_AST.tm = FStar_Parser_AST.Var smtpat;
-                         FStar_Parser_AST.range = uu___3;
-                         FStar_Parser_AST.level = uu___4;_},
-                       uu___5)::uu___6::[])
-                     ->
-                     (FStar_Ident.lid_equals cons FStar_Parser_Const.cons_lid)
-                       &&
-                       (FStar_Compiler_Util.for_some
-                          (fun s ->
-                             let uu___7 = FStar_Ident.string_of_lid smtpat in
-                             uu___7 = s) ["smt_pat"; "smt_pat_or"])
-                 | uu___3 -> false) in
-          let pre_process_comp_typ t1 =
-            let uu___ = head_and_args t1 in
-            match uu___ with
-            | (head, args) ->
-                (match head.FStar_Parser_AST.tm with
-                 | FStar_Parser_AST.Name lemma when
-                     let uu___1 =
-                       let uu___2 = FStar_Ident.ident_of_lid lemma in
-                       FStar_Ident.string_of_id uu___2 in
-                     uu___1 = "Lemma" ->
-                     let unit_tm =
-                       ((FStar_Parser_AST.mk_term
-                           (FStar_Parser_AST.Name FStar_Parser_Const.unit_lid)
-                           t1.FStar_Parser_AST.range
-                           FStar_Parser_AST.Type_level),
-                         FStar_Parser_AST.Nothing) in
-                     let nil_pat =
-                       ((FStar_Parser_AST.mk_term
-                           (FStar_Parser_AST.Name FStar_Parser_Const.nil_lid)
-                           t1.FStar_Parser_AST.range FStar_Parser_AST.Expr),
-                         FStar_Parser_AST.Nothing) in
-                     let req_true =
-                       let req =
-                         FStar_Parser_AST.Requires
-                           ((FStar_Parser_AST.mk_term
-                               (FStar_Parser_AST.Name
-                                  FStar_Parser_Const.true_lid)
-                               t1.FStar_Parser_AST.range
-                               FStar_Parser_AST.Formula),
-                             FStar_Pervasives_Native.None) in
-                       ((FStar_Parser_AST.mk_term req
-                           t1.FStar_Parser_AST.range
-                           FStar_Parser_AST.Type_level),
-                         FStar_Parser_AST.Nothing) in
-                     let thunk_ens uu___1 =
-                       match uu___1 with
-                       | (e, i) ->
-                           let uu___2 = FStar_Parser_AST.thunk e in
-                           (uu___2, i) in
-                     let fail_lemma uu___1 =
-                       let expected_one_of =
-                         ["Lemma post";
-                         "Lemma (ensures post)";
-                         "Lemma (requires pre) (ensures post)";
-                         "Lemma post [SMTPat ...]";
-                         "Lemma (ensures post) [SMTPat ...]";
-                         "Lemma (ensures post) (decreases d)";
-                         "Lemma (ensures post) (decreases d) [SMTPat ...]";
-                         "Lemma (requires pre) (ensures post) (decreases d)";
-                         "Lemma (requires pre) (ensures post) [SMTPat ...]";
-                         "Lemma (requires pre) (ensures post) (decreases d) [SMTPat ...]"] in
-                       let msg = FStar_String.concat "\n\t" expected_one_of in
-                       FStar_Errors.raise_error
-                         (FStar_Errors.Fatal_InvalidLemmaArgument,
-                           (Prims.op_Hat
-                              "Invalid arguments to 'Lemma'; expected one of the following:\n\t"
-                              msg)) t1.FStar_Parser_AST.range in
-                     let args1 =
-                       match args with
-                       | [] -> fail_lemma ()
-                       | req::[] when is_requires req -> fail_lemma ()
-                       | smtpat::[] when is_smt_pat smtpat -> fail_lemma ()
-                       | dec::[] when is_decreases dec -> fail_lemma ()
-                       | ens::[] ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in
-                               [uu___3; nil_pat] in
-                             req_true :: uu___2 in
-                           unit_tm :: uu___1
-                       | req::ens::[] when
-                           (is_requires req) && (is_ensures ens) ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in
-                               [uu___3; nil_pat] in
-                             req :: uu___2 in
-                           unit_tm :: uu___1
-                       | ens::smtpat::[] when
-                           (((let uu___1 = is_requires ens in
-                              Prims.op_Negation uu___1) &&
-                               (let uu___1 = is_smt_pat ens in
-                                Prims.op_Negation uu___1))
-                              &&
-                              (let uu___1 = is_decreases ens in
-                               Prims.op_Negation uu___1))
-                             && (is_smt_pat smtpat)
-                           ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in [uu___3; smtpat] in
-                             req_true :: uu___2 in
-                           unit_tm :: uu___1
-                       | ens::dec::[] when
-                           (is_ensures ens) && (is_decreases dec) ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in
-                               [uu___3; nil_pat; dec] in
-                             req_true :: uu___2 in
-                           unit_tm :: uu___1
-                       | ens::dec::smtpat::[] when
-                           ((is_ensures ens) && (is_decreases dec)) &&
-                             (is_smt_pat smtpat)
-                           ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in
-                               [uu___3; smtpat; dec] in
-                             req_true :: uu___2 in
-                           unit_tm :: uu___1
-                       | req::ens::dec::[] when
-                           ((is_requires req) && (is_ensures ens)) &&
-                             (is_decreases dec)
-                           ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in
-                               [uu___3; nil_pat; dec] in
-                             req :: uu___2 in
-                           unit_tm :: uu___1
-                       | req::ens::smtpat::[] when
-                           ((is_requires req) && (is_ensures ens)) &&
-                             (is_smt_pat smtpat)
-                           ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in [uu___3; smtpat] in
-                             req :: uu___2 in
-                           unit_tm :: uu___1
-                       | req::ens::dec::smtpat::[] when
-                           (((is_requires req) && (is_ensures ens)) &&
-                              (is_smt_pat smtpat))
-                             && (is_decreases dec)
-                           ->
-                           let uu___1 =
-                             let uu___2 =
-                               let uu___3 = thunk_ens ens in
-                               [uu___3; dec; smtpat] in
-                             req :: uu___2 in
-                           unit_tm :: uu___1
-                       | _other -> fail_lemma () in
-                     let head_and_attributes =
-                       FStar_Syntax_DsEnv.fail_or env
-                         (FStar_Syntax_DsEnv.try_lookup_effect_name_and_attributes
-                            env) lemma in
-                     (head_and_attributes, args1)
-                 | FStar_Parser_AST.Name l when
-                     FStar_Syntax_DsEnv.is_effect_name env l ->
-                     let uu___1 =
-                       FStar_Syntax_DsEnv.fail_or env
-                         (FStar_Syntax_DsEnv.try_lookup_effect_name_and_attributes
-                            env) l in
-                     (uu___1, args)
-                 | FStar_Parser_AST.Name l when
-                     (let uu___1 = FStar_Syntax_DsEnv.current_module env in
-                      FStar_Ident.lid_equals uu___1
-                        FStar_Parser_Const.prims_lid)
-                       &&
-                       (let uu___1 =
-                          let uu___2 = FStar_Ident.ident_of_lid l in
-                          FStar_Ident.string_of_id uu___2 in
-                        uu___1 = "Tot")
-                     ->
-                     let uu___1 =
-                       let uu___2 =
-                         FStar_Ident.set_lid_range
-                           FStar_Parser_Const.effect_Tot_lid
-                           head.FStar_Parser_AST.range in
-                       (uu___2, []) in
-                     (uu___1, args)
-                 | FStar_Parser_AST.Name l when
-                     (let uu___1 = FStar_Syntax_DsEnv.current_module env in
-                      FStar_Ident.lid_equals uu___1
-                        FStar_Parser_Const.prims_lid)
-                       &&
-                       (let uu___1 =
-                          let uu___2 = FStar_Ident.ident_of_lid l in
-                          FStar_Ident.string_of_id uu___2 in
-                        uu___1 = "GTot")
-                     ->
-                     let uu___1 =
-                       let uu___2 =
-                         FStar_Ident.set_lid_range
-                           FStar_Parser_Const.effect_GTot_lid
-                           head.FStar_Parser_AST.range in
-                       (uu___2, []) in
-                     (uu___1, args)
-                 | FStar_Parser_AST.Name l when
-                     ((let uu___1 =
-                         let uu___2 = FStar_Ident.ident_of_lid l in
-                         FStar_Ident.string_of_id uu___2 in
-                       uu___1 = "Type") ||
-                        (let uu___1 =
-                           let uu___2 = FStar_Ident.ident_of_lid l in
-                           FStar_Ident.string_of_id uu___2 in
-                         uu___1 = "Type0"))
-                       ||
-                       (let uu___1 =
-                          let uu___2 = FStar_Ident.ident_of_lid l in
-                          FStar_Ident.string_of_id uu___2 in
-                        uu___1 = "Effect")
-                     ->
-                     let uu___1 =
-                       let uu___2 =
-                         FStar_Ident.set_lid_range
-                           FStar_Parser_Const.effect_Tot_lid
-                           head.FStar_Parser_AST.range in
-                       (uu___2, []) in
-                     (uu___1, [(t1, FStar_Parser_AST.Nothing)])
-                 | uu___1 when allow_type_promotion ->
-                     let default_effect =
-                       let uu___2 = FStar_Options.ml_ish () in
-                       if uu___2
-                       then FStar_Parser_Const.effect_ML_lid ()
-                       else
-                         ((let uu___5 = FStar_Options.warn_default_effects () in
-                           if uu___5
-                           then
-                             FStar_Errors.log_issue
-                               head.FStar_Parser_AST.range
-                               (FStar_Errors.Warning_UseDefaultEffect,
-                                 "Using default effect Tot")
-                           else ());
-                          FStar_Parser_Const.effect_Tot_lid) in
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Ident.set_lid_range default_effect
-                           head.FStar_Parser_AST.range in
-                       (uu___3, []) in
-                     (uu___2, [(t1, FStar_Parser_AST.Nothing)])
-                 | uu___1 ->
-                     FStar_Errors.raise_error
-                       (FStar_Errors.Fatal_EffectNotFound,
-                         "Expected an effect constructor")
-                       t1.FStar_Parser_AST.range) in
-          let uu___ = pre_process_comp_typ t in
-          match uu___ with
-          | ((eff, cattributes), args) ->
-              (if (FStar_Compiler_List.length args) = Prims.int_zero
-               then
-                 (let uu___2 =
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Print.lid_to_string eff in
-                      FStar_Compiler_Util.format1
-                        "Not enough args to effect %s" uu___4 in
-                    (FStar_Errors.Fatal_NotEnoughArgsToEffect, uu___3) in
-                  fail uu___2)
-               else ();
-               (let is_universe uu___2 =
-                  match uu___2 with
-                  | (uu___3, imp) -> imp = FStar_Parser_AST.UnivApp in
-                let uu___2 = FStar_Compiler_Util.take is_universe args in
-                match uu___2 with
-                | (universes, args1) ->
-                    let universes1 =
-                      FStar_Compiler_List.map
-                        (fun uu___3 ->
-                           match uu___3 with | (u, imp) -> desugar_universe u)
-                        universes in
-                    let uu___3 =
-                      let uu___4 = FStar_Compiler_List.hd args1 in
-                      let uu___5 = FStar_Compiler_List.tl args1 in
-                      (uu___4, uu___5) in
-                    (match uu___3 with
-                     | (result_arg, rest) ->
-                         let result_typ =
-                           desugar_typ env
-                             (FStar_Pervasives_Native.fst result_arg) in
-                         let uu___4 =
-                           let is_decrease t1 =
-                             let uu___5 =
-                               let uu___6 =
-                                 unparen (FStar_Pervasives_Native.fst t1) in
-                               uu___6.FStar_Parser_AST.tm in
-                             match uu___5 with
-                             | FStar_Parser_AST.Decreases uu___6 -> true
-                             | uu___6 -> false in
-                           FStar_Compiler_Effect.op_Bar_Greater rest
-                             (FStar_Compiler_List.partition is_decrease) in
-                         (match uu___4 with
-                          | (dec, rest1) ->
-                              let rest2 = desugar_args env rest1 in
-                              let decreases_clause =
-                                FStar_Compiler_Effect.op_Bar_Greater dec
-                                  (FStar_Compiler_List.map
-                                     (fun t1 ->
-                                        let uu___5 =
-                                          let uu___6 =
-                                            unparen
-                                              (FStar_Pervasives_Native.fst t1) in
-                                          uu___6.FStar_Parser_AST.tm in
-                                        match uu___5 with
-                                        | FStar_Parser_AST.Decreases
-                                            (t2, uu___6) ->
-                                            let dec_order =
-                                              let t3 = unparen t2 in
-                                              match t3.FStar_Parser_AST.tm
-                                              with
-                                              | FStar_Parser_AST.LexList l ->
-                                                  let uu___7 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      l
-                                                      (FStar_Compiler_List.map
-                                                         (desugar_term env)) in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___7
-                                                    (fun uu___8 ->
-                                                       FStar_Syntax_Syntax.Decreases_lex
-                                                         uu___8)
-                                              | FStar_Parser_AST.WFOrder
-                                                  (t11, t21) ->
-                                                  let uu___7 =
-                                                    let uu___8 =
-                                                      desugar_term env t11 in
-                                                    let uu___9 =
-                                                      desugar_term env t21 in
-                                                    (uu___8, uu___9) in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___7
-                                                    (fun uu___8 ->
-                                                       FStar_Syntax_Syntax.Decreases_wf
-                                                         uu___8)
-                                              | uu___7 ->
-                                                  let uu___8 =
-                                                    let uu___9 =
-                                                      desugar_term env t3 in
-                                                    [uu___9] in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___8
-                                                    (fun uu___9 ->
-                                                       FStar_Syntax_Syntax.Decreases_lex
-                                                         uu___9) in
-                                            FStar_Syntax_Syntax.DECREASES
-                                              dec_order
-                                        | uu___6 ->
-                                            fail
-                                              (FStar_Errors.Fatal_UnexpectedComputationTypeForLetRec,
-                                                "Unexpected decreases clause"))) in
-                              let no_additional_args =
-                                let is_empty l =
-                                  match l with | [] -> true | uu___5 -> false in
-                                (((is_empty decreases_clause) &&
-                                    (is_empty rest2))
-                                   && (is_empty cattributes))
-                                  && (is_empty universes1) in
-                              let uu___5 =
-                                no_additional_args &&
-                                  (FStar_Ident.lid_equals eff
-                                     FStar_Parser_Const.effect_Tot_lid) in
-                              if uu___5
-                              then FStar_Syntax_Syntax.mk_Total result_typ
-                              else
-                                (let uu___7 =
-                                   no_additional_args &&
-                                     (FStar_Ident.lid_equals eff
-                                        FStar_Parser_Const.effect_GTot_lid) in
-                                 if uu___7
-                                 then
-                                   FStar_Syntax_Syntax.mk_GTotal result_typ
-                                 else
-                                   (let flags =
-                                      let uu___9 =
-                                        FStar_Ident.lid_equals eff
-                                          FStar_Parser_Const.effect_Lemma_lid in
-                                      if uu___9
-                                      then [FStar_Syntax_Syntax.LEMMA]
-                                      else
-                                        (let uu___11 =
-                                           FStar_Ident.lid_equals eff
-                                             FStar_Parser_Const.effect_Tot_lid in
-                                         if uu___11
-                                         then [FStar_Syntax_Syntax.TOTAL]
-                                         else
-                                           (let uu___13 =
-                                              let uu___14 =
-                                                FStar_Parser_Const.effect_ML_lid
-                                                  () in
-                                              FStar_Ident.lid_equals eff
-                                                uu___14 in
-                                            if uu___13
-                                            then
-                                              [FStar_Syntax_Syntax.MLEFFECT]
-                                            else
-                                              (let uu___15 =
-                                                 FStar_Ident.lid_equals eff
-                                                   FStar_Parser_Const.effect_GTot_lid in
-                                               if uu___15
-                                               then
-                                                 [FStar_Syntax_Syntax.SOMETRIVIAL]
-                                               else []))) in
-                                    let flags1 =
-                                      FStar_Compiler_List.op_At flags
-                                        cattributes in
-                                    let rest3 =
-                                      let uu___9 =
-                                        FStar_Ident.lid_equals eff
-                                          FStar_Parser_Const.effect_Lemma_lid in
-                                      if uu___9
-                                      then
-                                        match rest2 with
-                                        | req::ens::(pat, aq)::[] ->
-                                            let pat1 =
-                                              match pat.FStar_Syntax_Syntax.n
-                                              with
-                                              | FStar_Syntax_Syntax.Tm_fvar
-                                                  fv when
-                                                  FStar_Syntax_Syntax.fv_eq_lid
-                                                    fv
-                                                    FStar_Parser_Const.nil_lid
-                                                  ->
-                                                  let nil =
-                                                    FStar_Syntax_Syntax.mk_Tm_uinst
-                                                      pat
-                                                      [FStar_Syntax_Syntax.U_zero] in
-                                                  let pattern =
-                                                    let uu___10 =
-                                                      FStar_Ident.set_lid_range
-                                                        FStar_Parser_Const.pattern_lid
-                                                        pat.FStar_Syntax_Syntax.pos in
-                                                    FStar_Syntax_Syntax.fvar
-                                                      uu___10
-                                                      FStar_Syntax_Syntax.delta_constant
-                                                      FStar_Pervasives_Native.None in
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      let uu___12 =
-                                                        FStar_Syntax_Syntax.as_aqual_implicit
-                                                          true in
-                                                      (pattern, uu___12) in
-                                                    [uu___11] in
-                                                  FStar_Syntax_Syntax.mk_Tm_app
-                                                    nil uu___10
-                                                    pat.FStar_Syntax_Syntax.pos
-                                              | uu___10 -> pat in
-                                            let uu___10 =
-                                              let uu___11 =
-                                                let uu___12 =
-                                                  let uu___13 =
-                                                    FStar_Syntax_Syntax.mk
-                                                      (FStar_Syntax_Syntax.Tm_meta
-                                                         (pat1,
-                                                           (FStar_Syntax_Syntax.Meta_desugared
-                                                              FStar_Syntax_Syntax.Meta_smt_pat)))
-                                                      pat1.FStar_Syntax_Syntax.pos in
-                                                  (uu___13, aq) in
-                                                [uu___12] in
-                                              ens :: uu___11 in
-                                            req :: uu___10
-                                        | uu___10 -> rest2
-                                      else rest2 in
-                                    FStar_Syntax_Syntax.mk_Comp
-                                      {
-                                        FStar_Syntax_Syntax.comp_univs =
-                                          universes1;
-                                        FStar_Syntax_Syntax.effect_name = eff;
-                                        FStar_Syntax_Syntax.result_typ =
-                                          result_typ;
-                                        FStar_Syntax_Syntax.effect_args =
-                                          rest3;
-                                        FStar_Syntax_Syntax.flags =
-                                          (FStar_Compiler_List.op_At flags1
-                                             decreases_clause)
-                                      }))))))
-and (desugar_formula :
-  FStar_Syntax_DsEnv.env -> FStar_Parser_AST.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun f ->
-      let mk t = FStar_Syntax_Syntax.mk t f.FStar_Parser_AST.range in
-      let setpos t =
-        {
-          FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-          FStar_Syntax_Syntax.pos = (f.FStar_Parser_AST.range);
-          FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-          FStar_Syntax_Syntax.hash_code = (t.FStar_Syntax_Syntax.hash_code)
-        } in
-      let desugar_quant q b pats body =
-        let tk =
-          desugar_binder env
-            {
-              FStar_Parser_AST.b = (b.FStar_Parser_AST.b);
-              FStar_Parser_AST.brange = (b.FStar_Parser_AST.brange);
-              FStar_Parser_AST.blevel = FStar_Parser_AST.Formula;
-              FStar_Parser_AST.aqual = (b.FStar_Parser_AST.aqual);
-              FStar_Parser_AST.battributes = (b.FStar_Parser_AST.battributes)
-            } in
-        let with_pats env1 uu___ body1 =
-          match uu___ with
-          | (names, pats1) ->
-              (match (names, pats1) with
-               | ([], []) -> body1
-               | ([], uu___1::uu___2) ->
-                   failwith
-                     "Impossible: Annotated pattern without binders in scope"
-               | uu___1 ->
-                   let names1 =
-                     FStar_Compiler_Effect.op_Bar_Greater names
-                       (FStar_Compiler_List.map
-                          (fun i ->
-                             let uu___2 =
-                               FStar_Syntax_DsEnv.fail_or2
-                                 (FStar_Syntax_DsEnv.try_lookup_id env1) i in
-                             let uu___3 = FStar_Ident.range_of_id i in
-                             {
-                               FStar_Syntax_Syntax.n =
-                                 (uu___2.FStar_Syntax_Syntax.n);
-                               FStar_Syntax_Syntax.pos = uu___3;
-                               FStar_Syntax_Syntax.vars =
-                                 (uu___2.FStar_Syntax_Syntax.vars);
-                               FStar_Syntax_Syntax.hash_code =
-                                 (uu___2.FStar_Syntax_Syntax.hash_code)
-                             })) in
-                   let pats2 =
-                     FStar_Compiler_Effect.op_Bar_Greater pats1
-                       (FStar_Compiler_List.map
-                          (fun es ->
-                             FStar_Compiler_Effect.op_Bar_Greater es
-                               (FStar_Compiler_List.map
-                                  (fun e ->
-                                     let uu___2 = desugar_term env1 e in
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (arg_withimp_t
-                                          FStar_Parser_AST.Nothing) uu___2)))) in
-                   mk
-                     (FStar_Syntax_Syntax.Tm_meta
-                        (body1,
-                          (FStar_Syntax_Syntax.Meta_pattern (names1, pats2))))) in
-        match tk with
-        | (FStar_Pervasives_Native.Some a, k, uu___) ->
-            let uu___1 = FStar_Syntax_DsEnv.push_bv env a in
-            (match uu___1 with
-             | (env1, a1) ->
-                 let a2 =
-                   {
-                     FStar_Syntax_Syntax.ppname =
-                       (a1.FStar_Syntax_Syntax.ppname);
-                     FStar_Syntax_Syntax.index =
-                       (a1.FStar_Syntax_Syntax.index);
-                     FStar_Syntax_Syntax.sort = k
-                   } in
-                 let body1 = desugar_formula env1 body in
-                 let body2 = with_pats env1 pats body1 in
-                 let body3 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = FStar_Syntax_Syntax.mk_binder a2 in
-                       [uu___4] in
-                     no_annot_abs uu___3 body2 in
-                   FStar_Compiler_Effect.op_Less_Bar setpos uu___2 in
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Ident.set_lid_range q
-                           b.FStar_Parser_AST.brange in
-                       FStar_Syntax_Syntax.fvar uu___5
-                         (FStar_Syntax_Syntax.Delta_constant_at_level
-                            Prims.int_one) FStar_Pervasives_Native.None in
-                     let uu___5 =
-                       let uu___6 = FStar_Syntax_Syntax.as_arg body3 in
-                       [uu___6] in
-                     (uu___4, uu___5) in
-                   FStar_Syntax_Syntax.Tm_app uu___3 in
-                 FStar_Compiler_Effect.op_Less_Bar mk uu___2)
-        | uu___ -> failwith "impossible" in
-      let push_quant q binders pats body =
-        match binders with
-        | b::b'::_rest ->
-            let rest = b' :: _rest in
-            let body1 =
-              let uu___ = q (rest, pats, body) in
-              let uu___1 =
-                FStar_Compiler_Range.union_ranges b'.FStar_Parser_AST.brange
-                  body.FStar_Parser_AST.range in
-              FStar_Parser_AST.mk_term uu___ uu___1 FStar_Parser_AST.Formula in
-            let uu___ = q ([b], ([], []), body1) in
-            FStar_Parser_AST.mk_term uu___ f.FStar_Parser_AST.range
-              FStar_Parser_AST.Formula
-        | uu___ -> failwith "impossible" in
-      let uu___ = let uu___1 = unparen f in uu___1.FStar_Parser_AST.tm in
-      match uu___ with
-      | FStar_Parser_AST.Labeled (f1, l, p) ->
-          let f2 = desugar_formula env f1 in
-          FStar_Compiler_Effect.op_Less_Bar mk
-            (FStar_Syntax_Syntax.Tm_meta
-               (f2,
-                 (FStar_Syntax_Syntax.Meta_labeled
-                    (l, (f2.FStar_Syntax_Syntax.pos), p))))
-      | FStar_Parser_AST.QForall ([], uu___1, uu___2) ->
-          failwith "Impossible: Quantifier without binders"
-      | FStar_Parser_AST.QExists ([], uu___1, uu___2) ->
-          failwith "Impossible: Quantifier without binders"
-      | FStar_Parser_AST.QForall (_1::_2::_3, pats, body) ->
-          let binders = _1 :: _2 :: _3 in
-          let uu___1 =
-            push_quant (fun x -> FStar_Parser_AST.QForall x) binders pats
-              body in
-          desugar_formula env uu___1
-      | FStar_Parser_AST.QExists (_1::_2::_3, pats, body) ->
-          let binders = _1 :: _2 :: _3 in
-          let uu___1 =
-            push_quant (fun x -> FStar_Parser_AST.QExists x) binders pats
-              body in
-          desugar_formula env uu___1
-      | FStar_Parser_AST.QForall (b::[], pats, body) ->
-          desugar_quant FStar_Parser_Const.forall_lid b pats body
-      | FStar_Parser_AST.QExists (b::[], pats, body) ->
-          desugar_quant FStar_Parser_Const.exists_lid b pats body
-      | FStar_Parser_AST.Paren f1 -> failwith "impossible"
-      | uu___1 -> desugar_term env f
-and (desugar_binder :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.binder ->
-      (FStar_Ident.ident FStar_Pervasives_Native.option *
-        FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.attribute Prims.list))
-  =
-  fun env ->
-    fun b ->
-      let attrs =
-        FStar_Compiler_Effect.op_Bar_Greater b.FStar_Parser_AST.battributes
-          (FStar_Compiler_List.map (desugar_term env)) in
-      match b.FStar_Parser_AST.b with
-      | FStar_Parser_AST.TAnnotated (x, t) ->
-          let uu___ = desugar_typ env t in
-          ((FStar_Pervasives_Native.Some x), uu___, attrs)
-      | FStar_Parser_AST.Annotated (x, t) ->
-          let uu___ = desugar_typ env t in
-          ((FStar_Pervasives_Native.Some x), uu___, attrs)
-      | FStar_Parser_AST.TVariable x ->
-          let uu___ =
-            let uu___1 = FStar_Ident.range_of_id x in
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_type FStar_Syntax_Syntax.U_unknown)
-              uu___1 in
-          ((FStar_Pervasives_Native.Some x), uu___, attrs)
-      | FStar_Parser_AST.NoName t ->
-          let uu___ = desugar_typ env t in
-          (FStar_Pervasives_Native.None, uu___, attrs)
-      | FStar_Parser_AST.Variable x ->
-          let uu___ = let uu___1 = FStar_Ident.range_of_id x in tun_r uu___1 in
-          ((FStar_Pervasives_Native.Some x), uu___, attrs)
-and (desugar_vquote :
-  env_t ->
-    FStar_Parser_AST.term -> FStar_Compiler_Range.range -> Prims.string)
-  =
-  fun env ->
-    fun e ->
-      fun r ->
-        let tm = desugar_term env e in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress tm in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_fvar fv ->
-            let uu___1 = FStar_Syntax_Syntax.lid_of_fv fv in
-            FStar_Ident.string_of_lid uu___1
-        | uu___1 ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Print.term_to_string tm in
-                Prims.op_Hat "VQuote, expected an fvar, got: " uu___4 in
-              (FStar_Errors.Fatal_UnexpectedTermVQuote, uu___3) in
-            FStar_Errors.raise_error uu___2 r
-and (as_binder :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option ->
-      (FStar_Ident.ident FStar_Pervasives_Native.option *
-        FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.attribute Prims.list)
-        -> (FStar_Syntax_Syntax.binder * FStar_Syntax_DsEnv.env))
-  =
-  fun env ->
-    fun imp ->
-      fun uu___ ->
-        match uu___ with
-        | (FStar_Pervasives_Native.None, k, attrs) ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Syntax.null_bv k in
-              let uu___3 = trans_bqual env imp in
-              FStar_Syntax_Syntax.mk_binder_with_attrs uu___2 uu___3 attrs in
-            (uu___1, env)
-        | (FStar_Pervasives_Native.Some a, k, attrs) ->
-            let uu___1 = FStar_Syntax_DsEnv.push_bv env a in
-            (match uu___1 with
-             | (env1, a1) ->
-                 let uu___2 =
-                   let uu___3 = trans_bqual env1 imp in
-                   FStar_Syntax_Syntax.mk_binder_with_attrs
-                     {
-                       FStar_Syntax_Syntax.ppname =
-                         (a1.FStar_Syntax_Syntax.ppname);
-                       FStar_Syntax_Syntax.index =
-                         (a1.FStar_Syntax_Syntax.index);
-                       FStar_Syntax_Syntax.sort = k
-                     } uu___3 attrs in
-                 (uu___2, env1))
-and (trans_bqual :
-  env_t ->
-    FStar_Parser_AST.arg_qualifier FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.bqual)
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives_Native.Some (FStar_Parser_AST.Implicit) ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.imp_tag
-      | FStar_Pervasives_Native.Some (FStar_Parser_AST.Equality) ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Equality
-      | FStar_Pervasives_Native.Some (FStar_Parser_AST.Meta t) ->
-          let uu___1 =
-            let uu___2 = desugar_term env t in
-            FStar_Syntax_Syntax.Meta uu___2 in
-          FStar_Pervasives_Native.Some uu___1
-      | FStar_Pervasives_Native.Some (FStar_Parser_AST.TypeClassArg) ->
-          let tcresolve =
-            desugar_term env
-              (FStar_Parser_AST.mk_term
-                 (FStar_Parser_AST.Var FStar_Parser_Const.tcresolve_lid)
-                 FStar_Compiler_Range.dummyRange FStar_Parser_AST.Expr) in
-          FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta tcresolve)
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (typars_of_binders :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.binder Prims.list ->
-      (FStar_Syntax_DsEnv.env * FStar_Syntax_Syntax.binders))
-  =
-  fun env ->
-    fun bs ->
-      let uu___ =
-        FStar_Compiler_List.fold_left
-          (fun uu___1 ->
-             fun b ->
-               match uu___1 with
-               | (env1, out) ->
-                   let tk =
-                     desugar_binder env1
-                       {
-                         FStar_Parser_AST.b = (b.FStar_Parser_AST.b);
-                         FStar_Parser_AST.brange =
-                           (b.FStar_Parser_AST.brange);
-                         FStar_Parser_AST.blevel = FStar_Parser_AST.Formula;
-                         FStar_Parser_AST.aqual = (b.FStar_Parser_AST.aqual);
-                         FStar_Parser_AST.battributes =
-                           (b.FStar_Parser_AST.battributes)
-                       } in
-                   (match tk with
-                    | (FStar_Pervasives_Native.Some a, k, attrs) ->
-                        let uu___2 = FStar_Syntax_DsEnv.push_bv env1 a in
-                        (match uu___2 with
-                         | (env2, a1) ->
-                             let a2 =
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (a1.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (a1.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = k
-                               } in
-                             let uu___3 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   trans_bqual env2 b.FStar_Parser_AST.aqual in
-                                 FStar_Syntax_Syntax.mk_binder_with_attrs a2
-                                   uu___5 attrs in
-                               uu___4 :: out in
-                             (env2, uu___3))
-                    | uu___2 ->
-                        FStar_Errors.raise_error
-                          (FStar_Errors.Fatal_UnexpectedBinder,
-                            "Unexpected binder") b.FStar_Parser_AST.brange))
-          (env, []) bs in
-      match uu___ with
-      | (env1, tpars) -> (env1, (FStar_Compiler_List.rev tpars))
-let (desugar_attributes :
-  env_t ->
-    FStar_Parser_AST.term Prims.list -> FStar_Syntax_Syntax.cflag Prims.list)
-  =
-  fun env ->
-    fun cattributes ->
-      let desugar_attribute t =
-        let uu___ = let uu___1 = unparen t in uu___1.FStar_Parser_AST.tm in
-        match uu___ with
-        | FStar_Parser_AST.Var lid when
-            let uu___1 = FStar_Ident.string_of_lid lid in uu___1 = "cps" ->
-            FStar_Syntax_Syntax.CPS
-        | uu___1 ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 = FStar_Parser_AST.term_to_string t in
-                Prims.op_Hat "Unknown attribute " uu___4 in
-              (FStar_Errors.Fatal_UnknownAttribute, uu___3) in
-            FStar_Errors.raise_error uu___2 t.FStar_Parser_AST.range in
-      FStar_Compiler_List.map desugar_attribute cattributes
-let (binder_ident :
-  FStar_Parser_AST.binder -> FStar_Ident.ident FStar_Pervasives_Native.option)
-  =
-  fun b ->
-    match b.FStar_Parser_AST.b with
-    | FStar_Parser_AST.TAnnotated (x, uu___) ->
-        FStar_Pervasives_Native.Some x
-    | FStar_Parser_AST.Annotated (x, uu___) -> FStar_Pervasives_Native.Some x
-    | FStar_Parser_AST.TVariable x -> FStar_Pervasives_Native.Some x
-    | FStar_Parser_AST.Variable x -> FStar_Pervasives_Native.Some x
-    | FStar_Parser_AST.NoName uu___ -> FStar_Pervasives_Native.None
-let (binder_idents :
-  FStar_Parser_AST.binder Prims.list -> FStar_Ident.ident Prims.list) =
-  fun bs ->
-    FStar_Compiler_List.collect
-      (fun b ->
-         let uu___ = binder_ident b in FStar_Common.list_of_option uu___) bs
-let (mk_data_discriminators :
-  FStar_Syntax_Syntax.qualifier Prims.list ->
-    FStar_Syntax_DsEnv.env ->
-      FStar_Ident.lident Prims.list -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun quals ->
-    fun env ->
-      fun datas ->
-        let quals1 =
-          FStar_Compiler_Effect.op_Bar_Greater quals
-            (FStar_Compiler_List.filter
-               (fun uu___ ->
-                  match uu___ with
-                  | FStar_Syntax_Syntax.NoExtract -> true
-                  | FStar_Syntax_Syntax.Private -> true
-                  | uu___1 -> false)) in
-        let quals2 q =
-          let uu___ =
-            (let uu___1 = FStar_Syntax_DsEnv.iface env in
-             Prims.op_Negation uu___1) ||
-              (FStar_Syntax_DsEnv.admitted_iface env) in
-          if uu___
-          then
-            FStar_Compiler_List.op_At (FStar_Syntax_Syntax.Assumption :: q)
-              quals1
-          else FStar_Compiler_List.op_At q quals1 in
-        FStar_Compiler_Effect.op_Bar_Greater datas
-          (FStar_Compiler_List.map
-             (fun d ->
-                let disc_name = FStar_Syntax_Util.mk_discriminator d in
-                let uu___ = FStar_Ident.range_of_lid disc_name in
-                let uu___1 =
-                  quals2
-                    [FStar_Syntax_Syntax.OnlyName;
-                    FStar_Syntax_Syntax.Discriminator d] in
-                {
-                  FStar_Syntax_Syntax.sigel =
-                    (FStar_Syntax_Syntax.Sig_declare_typ
-                       (disc_name, [], FStar_Syntax_Syntax.tun));
-                  FStar_Syntax_Syntax.sigrng = uu___;
-                  FStar_Syntax_Syntax.sigquals = uu___1;
-                  FStar_Syntax_Syntax.sigmeta =
-                    FStar_Syntax_Syntax.default_sigmeta;
-                  FStar_Syntax_Syntax.sigattrs = [];
-                  FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-                }))
-let (mk_indexed_projector_names :
-  FStar_Syntax_Syntax.qualifier Prims.list ->
-    FStar_Syntax_Syntax.fv_qual ->
-      FStar_Syntax_Syntax.attribute Prims.list ->
-        FStar_Syntax_DsEnv.env ->
-          FStar_Ident.lident ->
-            FStar_Syntax_Syntax.binder Prims.list ->
-              FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun iquals ->
-    fun fvq ->
-      fun attrs ->
-        fun env ->
-          fun lid ->
-            fun fields ->
-              let p = FStar_Ident.range_of_lid lid in
-              let uu___ =
-                FStar_Compiler_Effect.op_Bar_Greater fields
-                  (FStar_Compiler_List.mapi
-                     (fun i ->
-                        fun fld ->
-                          let x = fld.FStar_Syntax_Syntax.binder_bv in
-                          let field_name =
-                            FStar_Syntax_Util.mk_field_projector_name lid x i in
-                          let only_decl =
-                            ((let uu___1 =
-                                FStar_Syntax_DsEnv.current_module env in
-                              FStar_Ident.lid_equals
-                                FStar_Parser_Const.prims_lid uu___1)
-                               || (fvq <> FStar_Syntax_Syntax.Data_ctor))
-                              ||
-                              (FStar_Syntax_Util.has_attribute attrs
-                                 FStar_Parser_Const.no_auto_projectors_attr) in
-                          let no_decl =
-                            FStar_Syntax_Syntax.is_type
-                              x.FStar_Syntax_Syntax.sort in
-                          let quals q =
-                            if only_decl
-                            then FStar_Syntax_Syntax.Assumption :: q
-                            else q in
-                          let quals1 =
-                            let iquals1 =
-                              FStar_Compiler_Effect.op_Bar_Greater iquals
-                                (FStar_Compiler_List.filter
-                                   (fun uu___1 ->
-                                      match uu___1 with
-                                      | FStar_Syntax_Syntax.NoExtract -> true
-                                      | FStar_Syntax_Syntax.Private -> true
-                                      | uu___2 -> false)) in
-                            quals (FStar_Syntax_Syntax.OnlyName ::
-                              (FStar_Syntax_Syntax.Projector
-                                 (lid, (x.FStar_Syntax_Syntax.ppname))) ::
-                              iquals1) in
-                          let decl =
-                            let uu___1 = FStar_Ident.range_of_lid field_name in
-                            {
-                              FStar_Syntax_Syntax.sigel =
-                                (FStar_Syntax_Syntax.Sig_declare_typ
-                                   (field_name, [], FStar_Syntax_Syntax.tun));
-                              FStar_Syntax_Syntax.sigrng = uu___1;
-                              FStar_Syntax_Syntax.sigquals = quals1;
-                              FStar_Syntax_Syntax.sigmeta =
-                                FStar_Syntax_Syntax.default_sigmeta;
-                              FStar_Syntax_Syntax.sigattrs = [];
-                              FStar_Syntax_Syntax.sigopts =
-                                FStar_Pervasives_Native.None
-                            } in
-                          if only_decl
-                          then [decl]
-                          else
-                            (let dd =
-                               FStar_Syntax_Syntax.Delta_equational_at_level
-                                 Prims.int_one in
-                             let lb =
-                               let uu___2 =
-                                 let uu___3 =
-                                   FStar_Syntax_Syntax.lid_as_fv field_name
-                                     dd FStar_Pervasives_Native.None in
-                                 FStar_Pervasives.Inr uu___3 in
-                               {
-                                 FStar_Syntax_Syntax.lbname = uu___2;
-                                 FStar_Syntax_Syntax.lbunivs = [];
-                                 FStar_Syntax_Syntax.lbtyp =
-                                   FStar_Syntax_Syntax.tun;
-                                 FStar_Syntax_Syntax.lbeff =
-                                   FStar_Parser_Const.effect_Tot_lid;
-                                 FStar_Syntax_Syntax.lbdef =
-                                   FStar_Syntax_Syntax.tun;
-                                 FStar_Syntax_Syntax.lbattrs = [];
-                                 FStar_Syntax_Syntax.lbpos =
-                                   FStar_Compiler_Range.dummyRange
-                               } in
-                             let impl =
-                               let uu___2 =
-                                 let uu___3 =
-                                   let uu___4 =
-                                     let uu___5 =
-                                       let uu___6 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           lb.FStar_Syntax_Syntax.lbname
-                                           FStar_Compiler_Util.right in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___6
-                                         (fun fv ->
-                                            (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v) in
-                                     [uu___5] in
-                                   ((false, [lb]), uu___4) in
-                                 FStar_Syntax_Syntax.Sig_let uu___3 in
-                               {
-                                 FStar_Syntax_Syntax.sigel = uu___2;
-                                 FStar_Syntax_Syntax.sigrng = p;
-                                 FStar_Syntax_Syntax.sigquals = quals1;
-                                 FStar_Syntax_Syntax.sigmeta =
-                                   FStar_Syntax_Syntax.default_sigmeta;
-                                 FStar_Syntax_Syntax.sigattrs = [];
-                                 FStar_Syntax_Syntax.sigopts =
-                                   FStar_Pervasives_Native.None
-                               } in
-                             if no_decl then [impl] else [decl; impl]))) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___
-                FStar_Compiler_List.flatten
-let (mk_data_projector_names :
-  FStar_Syntax_Syntax.qualifier Prims.list ->
-    FStar_Syntax_DsEnv.env ->
-      FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun iquals ->
-    fun env ->
-      fun se ->
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_datacon (lid, uu___, t, uu___1, n, uu___2)
-            ->
-            let uu___3 = FStar_Syntax_Util.arrow_formals t in
-            (match uu___3 with
-             | (formals, uu___4) ->
-                 (match formals with
-                  | [] -> []
-                  | uu___5 ->
-                      let filter_records uu___6 =
-                        match uu___6 with
-                        | FStar_Syntax_Syntax.RecordConstructor (uu___7, fns)
-                            ->
-                            FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Record_ctor (lid, fns))
-                        | uu___7 -> FStar_Pervasives_Native.None in
-                      let fv_qual =
-                        let uu___6 =
-                          FStar_Compiler_Util.find_map
-                            se.FStar_Syntax_Syntax.sigquals filter_records in
-                        match uu___6 with
-                        | FStar_Pervasives_Native.None ->
-                            FStar_Syntax_Syntax.Data_ctor
-                        | FStar_Pervasives_Native.Some q -> q in
-                      let uu___6 = FStar_Compiler_Util.first_N n formals in
-                      (match uu___6 with
-                       | (uu___7, rest) ->
-                           mk_indexed_projector_names iquals fv_qual
-                             se.FStar_Syntax_Syntax.sigattrs env lid rest)))
-        | uu___ -> []
-let (mk_typ_abbrev :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.decl ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.univ_name Prims.list ->
-          FStar_Syntax_Syntax.binder Prims.list ->
-            FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option ->
-              FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-                FStar_Ident.lident Prims.list ->
-                  FStar_Syntax_Syntax.qualifier Prims.list ->
-                    FStar_Compiler_Range.range -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun env ->
-    fun d ->
-      fun lid ->
-        fun uvs ->
-          fun typars ->
-            fun kopt ->
-              fun t ->
-                fun lids ->
-                  fun quals ->
-                    fun rng ->
-                      let attrs =
-                        FStar_Compiler_List.map (desugar_term env)
-                          d.FStar_Parser_AST.attrs in
-                      let val_attrs =
-                        let uu___ =
-                          FStar_Syntax_DsEnv.lookup_letbinding_quals_and_attrs
-                            env lid in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___
-                          FStar_Pervasives_Native.snd in
-                      let dd = FStar_Syntax_Util.incr_delta_qualifier t in
-                      let lb =
-                        let uu___ =
-                          let uu___1 =
-                            FStar_Syntax_Syntax.lid_as_fv lid dd
-                              FStar_Pervasives_Native.None in
-                          FStar_Pervasives.Inr uu___1 in
-                        let uu___1 =
-                          if FStar_Compiler_Util.is_some kopt
-                          then
-                            let uu___2 =
-                              let uu___3 =
-                                FStar_Compiler_Effect.op_Bar_Greater kopt
-                                  FStar_Compiler_Util.must in
-                              FStar_Syntax_Syntax.mk_Total uu___3 in
-                            FStar_Syntax_Util.arrow typars uu___2
-                          else FStar_Syntax_Syntax.tun in
-                        let uu___2 = no_annot_abs typars t in
-                        {
-                          FStar_Syntax_Syntax.lbname = uu___;
-                          FStar_Syntax_Syntax.lbunivs = uvs;
-                          FStar_Syntax_Syntax.lbtyp = uu___1;
-                          FStar_Syntax_Syntax.lbeff =
-                            FStar_Parser_Const.effect_Tot_lid;
-                          FStar_Syntax_Syntax.lbdef = uu___2;
-                          FStar_Syntax_Syntax.lbattrs = [];
-                          FStar_Syntax_Syntax.lbpos = rng
-                        } in
-                      {
-                        FStar_Syntax_Syntax.sigel =
-                          (FStar_Syntax_Syntax.Sig_let ((false, [lb]), lids));
-                        FStar_Syntax_Syntax.sigrng = rng;
-                        FStar_Syntax_Syntax.sigquals = quals;
-                        FStar_Syntax_Syntax.sigmeta =
-                          FStar_Syntax_Syntax.default_sigmeta;
-                        FStar_Syntax_Syntax.sigattrs =
-                          (FStar_Compiler_List.op_At val_attrs attrs);
-                        FStar_Syntax_Syntax.sigopts =
-                          FStar_Pervasives_Native.None
-                      }
-let rec (desugar_tycon :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.decl ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Parser_AST.tycon Prims.list ->
-          (env_t * FStar_Syntax_Syntax.sigelts))
-  =
-  fun env ->
-    fun d ->
-      fun quals ->
-        fun tcs ->
-          let rng = d.FStar_Parser_AST.drange in
-          let tycon_id uu___ =
-            match uu___ with
-            | FStar_Parser_AST.TyconAbstract (id, uu___1, uu___2) -> id
-            | FStar_Parser_AST.TyconAbbrev (id, uu___1, uu___2, uu___3) -> id
-            | FStar_Parser_AST.TyconRecord
-                (id, uu___1, uu___2, uu___3, uu___4) -> id
-            | FStar_Parser_AST.TyconVariant (id, uu___1, uu___2, uu___3) ->
-                id in
-          let binder_to_term b =
-            match b.FStar_Parser_AST.b with
-            | FStar_Parser_AST.Annotated (x, uu___) ->
-                let uu___1 =
-                  let uu___2 = FStar_Ident.lid_of_ids [x] in
-                  FStar_Parser_AST.Var uu___2 in
-                let uu___2 = FStar_Ident.range_of_id x in
-                FStar_Parser_AST.mk_term uu___1 uu___2 FStar_Parser_AST.Expr
-            | FStar_Parser_AST.Variable x ->
-                let uu___ =
-                  let uu___1 = FStar_Ident.lid_of_ids [x] in
-                  FStar_Parser_AST.Var uu___1 in
-                let uu___1 = FStar_Ident.range_of_id x in
-                FStar_Parser_AST.mk_term uu___ uu___1 FStar_Parser_AST.Expr
-            | FStar_Parser_AST.TAnnotated (a, uu___) ->
-                let uu___1 = FStar_Ident.range_of_id a in
-                FStar_Parser_AST.mk_term (FStar_Parser_AST.Tvar a) uu___1
-                  FStar_Parser_AST.Type_level
-            | FStar_Parser_AST.TVariable a ->
-                let uu___ = FStar_Ident.range_of_id a in
-                FStar_Parser_AST.mk_term (FStar_Parser_AST.Tvar a) uu___
-                  FStar_Parser_AST.Type_level
-            | FStar_Parser_AST.NoName t -> t in
-          let desugar_tycon_variant_record uu___ =
-            match uu___ with
-            | FStar_Parser_AST.TyconVariant (id, bds, k, variants) ->
-                let uu___1 =
-                  let uu___2 =
-                    Obj.magic
-                      (FStar_Compiler_List.map
-                         (fun uu___3 ->
-                            match uu___3 with
-                            | (cid, payload, attrs) ->
-                                (match payload with
-                                 | FStar_Pervasives_Native.Some
-                                     (FStar_Parser_AST.VpRecord (r, k1)) ->
-                                     let record_id =
-                                       let uu___4 =
-                                         let uu___5 =
-                                           let uu___6 =
-                                             FStar_Ident.string_of_id id in
-                                           let uu___7 =
-                                             let uu___8 =
-                                               let uu___9 =
-                                                 FStar_Ident.string_of_id
-                                                   (Obj.magic cid) in
-                                               Prims.op_Hat uu___9
-                                                 "__payload" in
-                                             Prims.op_Hat "__" uu___8 in
-                                           Prims.op_Hat uu___6 uu___7 in
-                                         (uu___5,
-                                           (cid.FStar_Parser_AST.range)) in
-                                       FStar_Ident.mk_ident uu___4 in
-                                     let record_id_t =
-                                       let uu___4 =
-                                         let uu___5 =
-                                           FStar_Ident.lid_of_ns_and_id []
-                                             record_id in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___5
-                                           (fun uu___6 ->
-                                              FStar_Parser_AST.Var uu___6) in
-                                       {
-                                         FStar_Parser_AST.tm = uu___4;
-                                         FStar_Parser_AST.range =
-                                           (cid.FStar_Parser_AST.range);
-                                         FStar_Parser_AST.level =
-                                           FStar_Parser_AST.Type_level
-                                       } in
-                                     let payload_typ =
-                                       let uu___4 =
-                                         FStar_Compiler_List.map
-                                           (fun bd ->
-                                              let uu___5 = binder_to_term bd in
-                                              (uu___5,
-                                                FStar_Parser_AST.Nothing))
-                                           bds in
-                                       let uu___5 =
-                                         FStar_Ident.range_of_id record_id in
-                                       FStar_Parser_AST.mkApp record_id_t
-                                         uu___4 uu___5 in
-                                     let uu___4 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         (FStar_Parser_AST.TyconRecord
-                                            (record_id, bds,
-                                              FStar_Pervasives_Native.None,
-                                              attrs, r))
-                                         (fun uu___5 ->
-                                            FStar_Pervasives_Native.Some
-                                              uu___5) in
-                                     let uu___5 =
-                                       let uu___6 =
-                                         let uu___7 =
-                                           match k1 with
-                                           | FStar_Pervasives_Native.None ->
-                                               FStar_Parser_AST.VpOfNotation
-                                                 payload_typ
-                                           | FStar_Pervasives_Native.Some k2
-                                               ->
-                                               let uu___8 =
-                                                 let uu___9 =
-                                                   let uu___10 =
-                                                     let uu___11 =
-                                                       let uu___12 =
-                                                         let uu___13 =
-                                                           FStar_Ident.range_of_id
-                                                             record_id in
-                                                         FStar_Parser_AST.mk_binder
-                                                           (FStar_Parser_AST.NoName
-                                                              payload_typ)
-                                                           uu___13
-                                                           FStar_Parser_AST.Type_level
-                                                           FStar_Pervasives_Native.None in
-                                                       [uu___12] in
-                                                     (uu___11, k2) in
-                                                   FStar_Parser_AST.Product
-                                                     uu___10 in
-                                                 {
-                                                   FStar_Parser_AST.tm =
-                                                     uu___9;
-                                                   FStar_Parser_AST.range =
-                                                     (payload_typ.FStar_Parser_AST.range);
-                                                   FStar_Parser_AST.level =
-                                                     FStar_Parser_AST.Type_level
-                                                 } in
-                                               FStar_Parser_AST.VpArbitrary
-                                                 uu___8 in
-                                         FStar_Pervasives_Native.Some uu___7 in
-                                       (cid, uu___6, attrs) in
-                                     (uu___4, uu___5)
-                                 | uu___4 ->
-                                     (FStar_Pervasives_Native.None,
-                                       (cid, payload, attrs))))
-                         (Obj.magic variants)) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___2
-                    FStar_Compiler_List.unzip in
-                (match uu___1 with
-                 | (additional_records, variants1) ->
-                     let concat_options =
-                       FStar_Compiler_List.filter_map (fun r -> r) in
-                     let uu___2 = concat_options additional_records in
-                     FStar_Compiler_List.op_At uu___2
-                       [FStar_Parser_AST.TyconVariant (id, bds, k, variants1)])
-            | tycon -> [tycon] in
-          let tcs1 =
-            FStar_Compiler_List.concatMap desugar_tycon_variant_record tcs in
-          let tot =
-            FStar_Parser_AST.mk_term
-              (FStar_Parser_AST.Name FStar_Parser_Const.effect_Tot_lid) rng
-              FStar_Parser_AST.Expr in
-          let with_constructor_effect t =
-            FStar_Parser_AST.mk_term
-              (FStar_Parser_AST.App (tot, t, FStar_Parser_AST.Nothing))
-              t.FStar_Parser_AST.range t.FStar_Parser_AST.level in
-          let apply_binders t binders =
-            let imp_of_aqual b =
-              match b.FStar_Parser_AST.aqual with
-              | FStar_Pervasives_Native.Some (FStar_Parser_AST.Implicit) ->
-                  FStar_Parser_AST.Hash
-              | FStar_Pervasives_Native.Some (FStar_Parser_AST.Meta uu___) ->
-                  FStar_Parser_AST.Hash
-              | FStar_Pervasives_Native.Some (FStar_Parser_AST.TypeClassArg)
-                  -> FStar_Parser_AST.Hash
-              | uu___ -> FStar_Parser_AST.Nothing in
-            FStar_Compiler_List.fold_left
-              (fun out ->
-                 fun b ->
-                   let uu___ =
-                     let uu___1 =
-                       let uu___2 = binder_to_term b in
-                       (out, uu___2, (imp_of_aqual b)) in
-                     FStar_Parser_AST.App uu___1 in
-                   FStar_Parser_AST.mk_term uu___ out.FStar_Parser_AST.range
-                     out.FStar_Parser_AST.level) t binders in
-          let tycon_record_as_variant uu___ =
-            match uu___ with
-            | FStar_Parser_AST.TyconRecord (id, parms, kopt, attrs, fields)
-                ->
-                let constrName =
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 = FStar_Ident.string_of_id id in
-                      Prims.op_Hat "Mk" uu___3 in
-                    let uu___3 = FStar_Ident.range_of_id id in
-                    (uu___2, uu___3) in
-                  FStar_Ident.mk_ident uu___1 in
-                let mfields =
-                  FStar_Compiler_List.map
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | (x, q, attrs1, t) ->
-                           let uu___2 = FStar_Ident.range_of_id x in
-                           FStar_Parser_AST.mk_binder_with_attrs
-                             (FStar_Parser_AST.Annotated (x, t)) uu___2
-                             FStar_Parser_AST.Expr q attrs1) fields in
-                let result =
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 = FStar_Ident.lid_of_ids [id] in
-                      FStar_Parser_AST.Var uu___3 in
-                    let uu___3 = FStar_Ident.range_of_id id in
-                    FStar_Parser_AST.mk_term uu___2 uu___3
-                      FStar_Parser_AST.Type_level in
-                  apply_binders uu___1 parms in
-                let constrTyp =
-                  let uu___1 = FStar_Ident.range_of_id id in
-                  FStar_Parser_AST.mk_term
-                    (FStar_Parser_AST.Product
-                       (mfields, (with_constructor_effect result))) uu___1
-                    FStar_Parser_AST.Type_level in
-                let names = let uu___1 = binder_idents parms in id :: uu___1 in
-                (FStar_Compiler_List.iter
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (f, uu___3, uu___4, uu___5) ->
-                          let uu___6 =
-                            FStar_Compiler_Util.for_some
-                              (fun i -> FStar_Ident.ident_equals f i) names in
-                          if uu___6
-                          then
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 = FStar_Ident.string_of_id f in
-                                FStar_Compiler_Util.format1
-                                  "Field %s shadows the record's name or a parameter of it, please rename it"
-                                  uu___9 in
-                              (FStar_Errors.Error_FieldShadow, uu___8) in
-                            let uu___8 = FStar_Ident.range_of_id f in
-                            FStar_Errors.raise_error uu___7 uu___8
-                          else ()) fields;
-                 (let uu___2 =
-                    FStar_Compiler_Effect.op_Bar_Greater fields
-                      (FStar_Compiler_List.map
-                         (fun uu___3 ->
-                            match uu___3 with
-                            | (f, uu___4, uu___5, uu___6) -> f)) in
-                  ((FStar_Parser_AST.TyconVariant
-                      (id, parms, kopt,
-                        [(constrName,
-                           (FStar_Pervasives_Native.Some
-                              (FStar_Parser_AST.VpArbitrary constrTyp)),
-                           attrs)])), uu___2)))
-            | uu___1 -> failwith "impossible" in
-          let desugar_abstract_tc quals1 _env mutuals uu___ =
-            match uu___ with
-            | FStar_Parser_AST.TyconAbstract (id, binders, kopt) ->
-                let uu___1 = typars_of_binders _env binders in
-                (match uu___1 with
-                 | (_env', typars) ->
-                     let k =
-                       match kopt with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Syntax_Util.ktype
-                       | FStar_Pervasives_Native.Some k1 ->
-                           desugar_term _env' k1 in
-                     let tconstr =
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 = FStar_Ident.lid_of_ids [id] in
-                           FStar_Parser_AST.Var uu___4 in
-                         let uu___4 = FStar_Ident.range_of_id id in
-                         FStar_Parser_AST.mk_term uu___3 uu___4
-                           FStar_Parser_AST.Type_level in
-                       apply_binders uu___2 binders in
-                     let qlid = FStar_Syntax_DsEnv.qualify _env id in
-                     let typars1 = FStar_Syntax_Subst.close_binders typars in
-                     let k1 = FStar_Syntax_Subst.close typars1 k in
-                     let se =
-                       {
-                         FStar_Syntax_Syntax.sigel =
-                           (FStar_Syntax_Syntax.Sig_inductive_typ
-                              (qlid, [], typars1,
-                                FStar_Pervasives_Native.None, k1, mutuals,
-                                []));
-                         FStar_Syntax_Syntax.sigrng = rng;
-                         FStar_Syntax_Syntax.sigquals = quals1;
-                         FStar_Syntax_Syntax.sigmeta =
-                           FStar_Syntax_Syntax.default_sigmeta;
-                         FStar_Syntax_Syntax.sigattrs = [];
-                         FStar_Syntax_Syntax.sigopts =
-                           FStar_Pervasives_Native.None
-                       } in
-                     let uu___2 =
-                       FStar_Syntax_DsEnv.push_top_level_rec_binding _env id
-                         FStar_Syntax_Syntax.delta_constant in
-                     (match uu___2 with
-                      | (_env1, uu___3) ->
-                          let uu___4 =
-                            FStar_Syntax_DsEnv.push_top_level_rec_binding
-                              _env' id FStar_Syntax_Syntax.delta_constant in
-                          (match uu___4 with
-                           | (_env2, uu___5) -> (_env1, _env2, se, tconstr))))
-            | uu___1 -> failwith "Unexpected tycon" in
-          let push_tparams env1 bs =
-            let uu___ =
-              FStar_Compiler_List.fold_left
-                (fun uu___1 ->
-                   fun b ->
-                     match uu___1 with
-                     | (env2, tps) ->
-                         let uu___2 =
-                           FStar_Syntax_DsEnv.push_bv env2
-                             (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.ppname in
-                         (match uu___2 with
-                          | (env3, y) ->
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Syntax_Syntax.mk_binder_with_attrs y
-                                    b.FStar_Syntax_Syntax.binder_qual
-                                    b.FStar_Syntax_Syntax.binder_attrs in
-                                uu___4 :: tps in
-                              (env3, uu___3))) (env1, []) bs in
-            match uu___ with
-            | (env2, bs1) -> (env2, (FStar_Compiler_List.rev bs1)) in
-          match tcs1 with
-          | (FStar_Parser_AST.TyconAbstract (id, bs, kopt))::[] ->
-              let kopt1 =
-                match kopt with
-                | FStar_Pervasives_Native.None ->
-                    let uu___ =
-                      let uu___1 = FStar_Ident.range_of_id id in
-                      tm_type_z uu___1 in
-                    FStar_Pervasives_Native.Some uu___
-                | uu___ -> kopt in
-              let tc = FStar_Parser_AST.TyconAbstract (id, bs, kopt1) in
-              let uu___ = desugar_abstract_tc quals env [] tc in
-              (match uu___ with
-               | (uu___1, uu___2, se, uu___3) ->
-                   let se1 =
-                     match se.FStar_Syntax_Syntax.sigel with
-                     | FStar_Syntax_Syntax.Sig_inductive_typ
-                         (l, uu___4, typars, uu___5, k, [], []) ->
-                         let quals1 = se.FStar_Syntax_Syntax.sigquals in
-                         let quals2 =
-                           if
-                             FStar_Compiler_List.contains
-                               FStar_Syntax_Syntax.Assumption quals1
-                           then quals1
-                           else
-                             ((let uu___8 =
-                                 let uu___9 = FStar_Options.ml_ish () in
-                                 Prims.op_Negation uu___9 in
-                               if uu___8
-                               then
-                                 let uu___9 =
-                                   let uu___10 =
-                                     let uu___11 =
-                                       FStar_Syntax_Print.lid_to_string l in
-                                     FStar_Compiler_Util.format1
-                                       "Adding an implicit 'assume new' qualifier on %s"
-                                       uu___11 in
-                                   (FStar_Errors.Warning_AddImplicitAssumeNewQualifier,
-                                     uu___10) in
-                                 FStar_Errors.log_issue
-                                   se.FStar_Syntax_Syntax.sigrng uu___9
-                               else ());
-                              FStar_Syntax_Syntax.Assumption
-                              ::
-                              FStar_Syntax_Syntax.New
-                              ::
-                              quals1) in
-                         let t =
-                           match typars with
-                           | [] -> k
-                           | uu___6 ->
-                               let uu___7 =
-                                 let uu___8 =
-                                   let uu___9 =
-                                     FStar_Syntax_Syntax.mk_Total k in
-                                   (typars, uu___9) in
-                                 FStar_Syntax_Syntax.Tm_arrow uu___8 in
-                               FStar_Syntax_Syntax.mk uu___7
-                                 se.FStar_Syntax_Syntax.sigrng in
-                         {
-                           FStar_Syntax_Syntax.sigel =
-                             (FStar_Syntax_Syntax.Sig_declare_typ (l, [], t));
-                           FStar_Syntax_Syntax.sigrng =
-                             (se.FStar_Syntax_Syntax.sigrng);
-                           FStar_Syntax_Syntax.sigquals = quals2;
-                           FStar_Syntax_Syntax.sigmeta =
-                             (se.FStar_Syntax_Syntax.sigmeta);
-                           FStar_Syntax_Syntax.sigattrs =
-                             (se.FStar_Syntax_Syntax.sigattrs);
-                           FStar_Syntax_Syntax.sigopts =
-                             (se.FStar_Syntax_Syntax.sigopts)
-                         }
-                     | uu___4 -> failwith "Impossible" in
-                   let env1 = FStar_Syntax_DsEnv.push_sigelt env se1 in
-                   (env1, [se1]))
-          | (FStar_Parser_AST.TyconAbbrev (id, binders, kopt, t))::[] ->
-              let uu___ = typars_of_binders env binders in
-              (match uu___ with
-               | (env', typars) ->
-                   let kopt1 =
-                     match kopt with
-                     | FStar_Pervasives_Native.None ->
-                         let uu___1 =
-                           FStar_Compiler_Util.for_some
-                             (fun uu___2 ->
-                                match uu___2 with
-                                | FStar_Syntax_Syntax.Effect -> true
-                                | uu___3 -> false) quals in
-                         if uu___1
-                         then
-                           FStar_Pervasives_Native.Some
-                             FStar_Syntax_Syntax.teff
-                         else FStar_Pervasives_Native.None
-                     | FStar_Pervasives_Native.Some k ->
-                         let uu___1 = desugar_term env' k in
-                         FStar_Pervasives_Native.Some uu___1 in
-                   let t0 = t in
-                   let quals1 =
-                     let uu___1 =
-                       FStar_Compiler_Effect.op_Bar_Greater quals
-                         (FStar_Compiler_Util.for_some
-                            (fun uu___2 ->
-                               match uu___2 with
-                               | FStar_Syntax_Syntax.Logic -> true
-                               | uu___3 -> false)) in
-                     if uu___1
-                     then quals
-                     else
-                       if
-                         t0.FStar_Parser_AST.level = FStar_Parser_AST.Formula
-                       then FStar_Syntax_Syntax.Logic :: quals
-                       else quals in
-                   let qlid = FStar_Syntax_DsEnv.qualify env id in
-                   let se =
-                     let uu___1 =
-                       FStar_Compiler_Effect.op_Bar_Greater quals1
-                         (FStar_Compiler_List.contains
-                            FStar_Syntax_Syntax.Effect) in
-                     if uu___1
-                     then
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 = unparen t in
-                           uu___4.FStar_Parser_AST.tm in
-                         match uu___3 with
-                         | FStar_Parser_AST.Construct (head, args) ->
-                             let uu___4 =
-                               match FStar_Compiler_List.rev args with
-                               | (last_arg, uu___5)::args_rev ->
-                                   let uu___6 =
-                                     let uu___7 = unparen last_arg in
-                                     uu___7.FStar_Parser_AST.tm in
-                                   (match uu___6 with
-                                    | FStar_Parser_AST.Attributes ts ->
-                                        (ts,
-                                          (FStar_Compiler_List.rev args_rev))
-                                    | uu___7 -> ([], args))
-                               | uu___5 -> ([], args) in
-                             (match uu___4 with
-                              | (cattributes, args1) ->
-                                  let uu___5 =
-                                    desugar_attributes env cattributes in
-                                  ((FStar_Parser_AST.mk_term
-                                      (FStar_Parser_AST.Construct
-                                         (head, args1))
-                                      t.FStar_Parser_AST.range
-                                      t.FStar_Parser_AST.level), uu___5))
-                         | uu___4 -> (t, []) in
-                       match uu___2 with
-                       | (t1, cattributes) ->
-                           let c =
-                             desugar_comp t1.FStar_Parser_AST.range false
-                               env' t1 in
-                           let typars1 =
-                             FStar_Syntax_Subst.close_binders typars in
-                           let c1 = FStar_Syntax_Subst.close_comp typars1 c in
-                           let quals2 =
-                             FStar_Compiler_Effect.op_Bar_Greater quals1
-                               (FStar_Compiler_List.filter
-                                  (fun uu___3 ->
-                                     match uu___3 with
-                                     | FStar_Syntax_Syntax.Effect -> false
-                                     | uu___4 -> true)) in
-                           {
-                             FStar_Syntax_Syntax.sigel =
-                               (FStar_Syntax_Syntax.Sig_effect_abbrev
-                                  (qlid, [], typars1, c1,
-                                    (FStar_Compiler_List.op_At cattributes
-                                       (FStar_Syntax_Util.comp_flags c1))));
-                             FStar_Syntax_Syntax.sigrng = rng;
-                             FStar_Syntax_Syntax.sigquals = quals2;
-                             FStar_Syntax_Syntax.sigmeta =
-                               FStar_Syntax_Syntax.default_sigmeta;
-                             FStar_Syntax_Syntax.sigattrs = [];
-                             FStar_Syntax_Syntax.sigopts =
-                               FStar_Pervasives_Native.None
-                           }
-                     else
-                       (let t1 = desugar_typ env' t in
-                        mk_typ_abbrev env d qlid [] typars kopt1 t1 [qlid]
-                          quals1 rng) in
-                   let env1 = FStar_Syntax_DsEnv.push_sigelt env se in
-                   (env1, [se]))
-          | (FStar_Parser_AST.TyconRecord uu___)::[] ->
-              let trec = FStar_Compiler_List.hd tcs1 in
-              let uu___1 = tycon_record_as_variant trec in
-              (match uu___1 with
-               | (t, fs) ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 = FStar_Syntax_DsEnv.current_module env in
-                           FStar_Ident.ids_of_lid uu___6 in
-                         (uu___5, fs) in
-                       FStar_Syntax_Syntax.RecordType uu___4 in
-                     uu___3 :: quals in
-                   desugar_tycon env d uu___2 [t])
-          | uu___::uu___1 ->
-              let env0 = env in
-              let mutuals =
-                FStar_Compiler_List.map
-                  (fun x ->
-                     FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_Syntax_DsEnv.qualify env) (tycon_id x)) tcs1 in
-              let rec collect_tcs quals1 et tc =
-                let uu___2 = et in
-                match uu___2 with
-                | (env1, tcs2) ->
-                    (match tc with
-                     | FStar_Parser_AST.TyconRecord uu___3 ->
-                         let trec = tc in
-                         let uu___4 = tycon_record_as_variant trec in
-                         (match uu___4 with
-                          | (t, fs) ->
-                              let uu___5 =
-                                let uu___6 =
-                                  let uu___7 =
-                                    let uu___8 =
-                                      let uu___9 =
-                                        FStar_Syntax_DsEnv.current_module
-                                          env1 in
-                                      FStar_Ident.ids_of_lid uu___9 in
-                                    (uu___8, fs) in
-                                  FStar_Syntax_Syntax.RecordType uu___7 in
-                                uu___6 :: quals1 in
-                              collect_tcs uu___5 (env1, tcs2) t)
-                     | FStar_Parser_AST.TyconVariant
-                         (id, binders, kopt, constructors) ->
-                         let uu___3 =
-                           desugar_abstract_tc quals1 env1 mutuals
-                             (FStar_Parser_AST.TyconAbstract
-                                (id, binders, kopt)) in
-                         (match uu___3 with
-                          | (env2, uu___4, se, tconstr) ->
-                              (env2,
-                                ((FStar_Pervasives.Inl
-                                    (se, constructors, tconstr, quals1)) ::
-                                tcs2)))
-                     | FStar_Parser_AST.TyconAbbrev (id, binders, kopt, t) ->
-                         let uu___3 =
-                           desugar_abstract_tc quals1 env1 mutuals
-                             (FStar_Parser_AST.TyconAbstract
-                                (id, binders, kopt)) in
-                         (match uu___3 with
-                          | (env2, uu___4, se, tconstr) ->
-                              (env2,
-                                ((FStar_Pervasives.Inr
-                                    (se, binders, t, quals1)) :: tcs2)))
-                     | uu___3 ->
-                         FStar_Errors.raise_error
-                           (FStar_Errors.Fatal_NonInductiveInMutuallyDefinedType,
-                             "Mutually defined type contains a non-inductive element")
-                           rng) in
-              let uu___2 =
-                FStar_Compiler_List.fold_left (collect_tcs quals) (env, [])
-                  tcs1 in
-              (match uu___2 with
-               | (env1, tcs2) ->
-                   let tcs3 = FStar_Compiler_List.rev tcs2 in
-                   let tps_sigelts =
-                     FStar_Compiler_Effect.op_Bar_Greater tcs3
-                       (FStar_Compiler_List.collect
-                          (fun uu___3 ->
-                             match uu___3 with
-                             | FStar_Pervasives.Inr
-                                 ({
-                                    FStar_Syntax_Syntax.sigel =
-                                      FStar_Syntax_Syntax.Sig_inductive_typ
-                                      (id, uvs, tpars, uu___4, k, uu___5,
-                                       uu___6);
-                                    FStar_Syntax_Syntax.sigrng = uu___7;
-                                    FStar_Syntax_Syntax.sigquals = uu___8;
-                                    FStar_Syntax_Syntax.sigmeta = uu___9;
-                                    FStar_Syntax_Syntax.sigattrs = uu___10;
-                                    FStar_Syntax_Syntax.sigopts = uu___11;_},
-                                  binders, t, quals1)
-                                 ->
-                                 let t1 =
-                                   let uu___12 =
-                                     typars_of_binders env1 binders in
-                                   match uu___12 with
-                                   | (env2, tpars1) ->
-                                       let uu___13 = push_tparams env2 tpars1 in
-                                       (match uu___13 with
-                                        | (env_tps, tpars2) ->
-                                            let t2 = desugar_typ env_tps t in
-                                            let tpars3 =
-                                              FStar_Syntax_Subst.close_binders
-                                                tpars2 in
-                                            FStar_Syntax_Subst.close tpars3
-                                              t2) in
-                                 let uu___12 =
-                                   let uu___13 =
-                                     mk_typ_abbrev env1 d id uvs tpars
-                                       (FStar_Pervasives_Native.Some k) t1
-                                       [id] quals1 rng in
-                                   ([], uu___13) in
-                                 [uu___12]
-                             | FStar_Pervasives.Inl
-                                 ({
-                                    FStar_Syntax_Syntax.sigel =
-                                      FStar_Syntax_Syntax.Sig_inductive_typ
-                                      (tname, univs, tpars, num_uniform, k,
-                                       mutuals1, uu___4);
-                                    FStar_Syntax_Syntax.sigrng = uu___5;
-                                    FStar_Syntax_Syntax.sigquals =
-                                      tname_quals;
-                                    FStar_Syntax_Syntax.sigmeta = uu___6;
-                                    FStar_Syntax_Syntax.sigattrs = uu___7;
-                                    FStar_Syntax_Syntax.sigopts = uu___8;_},
-                                  constrs, tconstr, quals1)
-                                 ->
-                                 let mk_tot t =
-                                   let tot1 =
-                                     FStar_Parser_AST.mk_term
-                                       (FStar_Parser_AST.Name
-                                          FStar_Parser_Const.effect_Tot_lid)
-                                       t.FStar_Parser_AST.range
-                                       t.FStar_Parser_AST.level in
-                                   FStar_Parser_AST.mk_term
-                                     (FStar_Parser_AST.App
-                                        (tot1, t, FStar_Parser_AST.Nothing))
-                                     t.FStar_Parser_AST.range
-                                     t.FStar_Parser_AST.level in
-                                 let tycon = (tname, tpars, k) in
-                                 let uu___9 = push_tparams env1 tpars in
-                                 (match uu___9 with
-                                  | (env_tps, tps) ->
-                                      let data_tpars =
-                                        FStar_Compiler_List.map
-                                          (fun tp ->
-                                             {
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 =
-                                                 (tp.FStar_Syntax_Syntax.binder_bv);
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 =
-                                                 (FStar_Pervasives_Native.Some
-                                                    (FStar_Syntax_Syntax.Implicit
-                                                       true));
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 =
-                                                 (tp.FStar_Syntax_Syntax.binder_attrs)
-                                             }) tps in
-                                      let tot_tconstr = mk_tot tconstr in
-                                      let attrs =
-                                        FStar_Compiler_List.map
-                                          (desugar_term env1)
-                                          d.FStar_Parser_AST.attrs in
-                                      let val_attrs =
-                                        let uu___10 =
-                                          FStar_Syntax_DsEnv.lookup_letbinding_quals_and_attrs
-                                            env1 tname in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___10 FStar_Pervasives_Native.snd in
-                                      let uu___10 =
-                                        let uu___11 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            constrs
-                                            (FStar_Compiler_List.map
-                                               (fun uu___12 ->
-                                                  match uu___12 with
-                                                  | (id, payload, cons_attrs)
-                                                      ->
-                                                      let t =
-                                                        match payload with
-                                                        | FStar_Pervasives_Native.Some
-                                                            (FStar_Parser_AST.VpArbitrary
-                                                            t1) -> t1
-                                                        | FStar_Pervasives_Native.Some
-                                                            (FStar_Parser_AST.VpOfNotation
-                                                            t1) ->
-                                                            FStar_Parser_AST.mk_term
-                                                              (FStar_Parser_AST.Product
-                                                                 ([FStar_Parser_AST.mk_binder
-                                                                    (FStar_Parser_AST.NoName
-                                                                    t1)
-                                                                    t1.FStar_Parser_AST.range
-                                                                    t1.FStar_Parser_AST.level
-                                                                    FStar_Pervasives_Native.None],
-                                                                   tot_tconstr))
-                                                              t1.FStar_Parser_AST.range
-                                                              t1.FStar_Parser_AST.level
-                                                        | FStar_Pervasives_Native.Some
-                                                            (FStar_Parser_AST.VpRecord
-                                                            uu___13) ->
-                                                            failwith
-                                                              "Impossible: [VpRecord _] should have disappeared after [desugar_tycon_variant_record]"
-                                                        | FStar_Pervasives_Native.None
-                                                            -> tconstr in
-                                                      let t1 =
-                                                        let uu___13 =
-                                                          close env_tps t in
-                                                        desugar_term env_tps
-                                                          uu___13 in
-                                                      let name =
-                                                        FStar_Syntax_DsEnv.qualify
-                                                          env1 id in
-                                                      let quals2 =
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          tname_quals
-                                                          (FStar_Compiler_List.collect
-                                                             (fun uu___13 ->
-                                                                match uu___13
-                                                                with
-                                                                | FStar_Syntax_Syntax.RecordType
-                                                                    fns ->
-                                                                    [
-                                                                    FStar_Syntax_Syntax.RecordConstructor
-                                                                    fns]
-                                                                | uu___14 ->
-                                                                    [])) in
-                                                      let ntps =
-                                                        FStar_Compiler_List.length
-                                                          data_tpars in
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          let uu___15 =
-                                                            let uu___16 =
-                                                              let uu___17 =
-                                                                let uu___18 =
-                                                                  let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    t1
-                                                                    FStar_Syntax_Util.name_function_binders in
-                                                                  FStar_Syntax_Syntax.mk_Total
-                                                                    uu___19 in
-                                                                FStar_Syntax_Util.arrow
-                                                                  data_tpars
-                                                                  uu___18 in
-                                                              (name, univs,
-                                                                uu___17,
-                                                                tname, ntps,
-                                                                mutuals1) in
-                                                            FStar_Syntax_Syntax.Sig_datacon
-                                                              uu___16 in
-                                                          let uu___16 =
-                                                            let uu___17 =
-                                                              let uu___18 =
-                                                                FStar_Compiler_List.map
-                                                                  (desugar_term
-                                                                    env1)
-                                                                  cons_attrs in
-                                                              FStar_Compiler_List.op_At
-                                                                attrs uu___18 in
-                                                            FStar_Compiler_List.op_At
-                                                              val_attrs
-                                                              uu___17 in
-                                                          {
-                                                            FStar_Syntax_Syntax.sigel
-                                                              = uu___15;
-                                                            FStar_Syntax_Syntax.sigrng
-                                                              = rng;
-                                                            FStar_Syntax_Syntax.sigquals
-                                                              = quals2;
-                                                            FStar_Syntax_Syntax.sigmeta
-                                                              =
-                                                              FStar_Syntax_Syntax.default_sigmeta;
-                                                            FStar_Syntax_Syntax.sigattrs
-                                                              = uu___16;
-                                                            FStar_Syntax_Syntax.sigopts
-                                                              =
-                                                              FStar_Pervasives_Native.None
-                                                          } in
-                                                        (tps, uu___14) in
-                                                      (name, uu___13))) in
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          FStar_Compiler_List.split uu___11 in
-                                      (match uu___10 with
-                                       | (constrNames, constrs1) ->
-                                           ([],
-                                             {
-                                               FStar_Syntax_Syntax.sigel =
-                                                 (FStar_Syntax_Syntax.Sig_inductive_typ
-                                                    (tname, univs, tpars,
-                                                      num_uniform, k,
-                                                      mutuals1, constrNames));
-                                               FStar_Syntax_Syntax.sigrng =
-                                                 rng;
-                                               FStar_Syntax_Syntax.sigquals =
-                                                 tname_quals;
-                                               FStar_Syntax_Syntax.sigmeta =
-                                                 FStar_Syntax_Syntax.default_sigmeta;
-                                               FStar_Syntax_Syntax.sigattrs =
-                                                 (FStar_Compiler_List.op_At
-                                                    val_attrs attrs);
-                                               FStar_Syntax_Syntax.sigopts =
-                                                 FStar_Pervasives_Native.None
-                                             })
-                                           :: constrs1))
-                             | uu___4 -> failwith "impossible")) in
-                   let sigelts =
-                     FStar_Compiler_Effect.op_Bar_Greater tps_sigelts
-                       (FStar_Compiler_List.map
-                          (fun uu___3 ->
-                             match uu___3 with | (uu___4, se) -> se)) in
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_List.collect
-                         FStar_Syntax_Util.lids_of_sigelt sigelts in
-                     FStar_Syntax_MutRecTy.disentangle_abbrevs_from_bundle
-                       sigelts quals uu___4 rng in
-                   (match uu___3 with
-                    | (bundle, abbrevs) ->
-                        let env2 = FStar_Syntax_DsEnv.push_sigelt env0 bundle in
-                        let env3 =
-                          FStar_Compiler_List.fold_left
-                            FStar_Syntax_DsEnv.push_sigelt env2 abbrevs in
-                        let data_ops =
-                          FStar_Compiler_Effect.op_Bar_Greater tps_sigelts
-                            (FStar_Compiler_List.collect
-                               (fun uu___4 ->
-                                  match uu___4 with
-                                  | (tps, se) ->
-                                      mk_data_projector_names quals env3 se)) in
-                        let discs =
-                          FStar_Compiler_Effect.op_Bar_Greater sigelts
-                            (FStar_Compiler_List.collect
-                               (fun se ->
-                                  match se.FStar_Syntax_Syntax.sigel with
-                                  | FStar_Syntax_Syntax.Sig_inductive_typ
-                                      (tname, uu___4, tps, uu___5, k, uu___6,
-                                       constrs)
-                                      ->
-                                      let quals1 =
-                                        se.FStar_Syntax_Syntax.sigquals in
-                                      let uu___7 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          constrs
-                                          (FStar_Compiler_List.filter
-                                             (fun data_lid ->
-                                                let data_quals =
-                                                  let data_se =
-                                                    let uu___8 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        sigelts
-                                                        (FStar_Compiler_List.find
-                                                           (fun se1 ->
-                                                              match se1.FStar_Syntax_Syntax.sigel
-                                                              with
-                                                              | FStar_Syntax_Syntax.Sig_datacon
-                                                                  (name,
-                                                                   uu___9,
-                                                                   uu___10,
-                                                                   uu___11,
-                                                                   uu___12,
-                                                                   uu___13)
-                                                                  ->
-                                                                  FStar_Ident.lid_equals
-                                                                    name
-                                                                    data_lid
-                                                              | uu___9 ->
-                                                                  false)) in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      uu___8
-                                                      FStar_Compiler_Util.must in
-                                                  data_se.FStar_Syntax_Syntax.sigquals in
-                                                let uu___8 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    data_quals
-                                                    (FStar_Compiler_List.existsb
-                                                       (fun uu___9 ->
-                                                          match uu___9 with
-                                                          | FStar_Syntax_Syntax.RecordConstructor
-                                                              uu___10 -> true
-                                                          | uu___10 -> false)) in
-                                                Prims.op_Negation uu___8)) in
-                                      mk_data_discriminators quals1 env3
-                                        uu___7
-                                  | uu___4 -> [])) in
-                        let ops = FStar_Compiler_List.op_At discs data_ops in
-                        let env4 =
-                          FStar_Compiler_List.fold_left
-                            FStar_Syntax_DsEnv.push_sigelt env3 ops in
-                        (env4,
-                          (FStar_Compiler_List.op_At [bundle]
-                             (FStar_Compiler_List.op_At abbrevs ops)))))
-          | [] -> failwith "impossible"
-let (desugar_binders :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.binder Prims.list ->
-      (FStar_Syntax_DsEnv.env * FStar_Syntax_Syntax.binder Prims.list))
-  =
-  fun env ->
-    fun binders ->
-      let uu___ =
-        FStar_Compiler_List.fold_left
-          (fun uu___1 ->
-             fun b ->
-               match uu___1 with
-               | (env1, binders1) ->
-                   let uu___2 = desugar_binder env1 b in
-                   (match uu___2 with
-                    | (FStar_Pervasives_Native.Some a, k, attrs) ->
-                        let uu___3 =
-                          as_binder env1 b.FStar_Parser_AST.aqual
-                            ((FStar_Pervasives_Native.Some a), k, attrs) in
-                        (match uu___3 with
-                         | (binder, env2) -> (env2, (binder :: binders1)))
-                    | uu___3 ->
-                        FStar_Errors.raise_error
-                          (FStar_Errors.Fatal_MissingNameInBinder,
-                            "Missing name in binder")
-                          b.FStar_Parser_AST.brange)) (env, []) binders in
-      match uu___ with
-      | (env1, binders1) -> (env1, (FStar_Compiler_List.rev binders1))
-let (push_reflect_effect :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Syntax_Syntax.qualifier Prims.list ->
-      FStar_Ident.lid -> FStar_Compiler_Range.range -> FStar_Syntax_DsEnv.env)
-  =
-  fun env ->
-    fun quals ->
-      fun effect_name ->
-        fun range ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_Util.for_some
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | FStar_Syntax_Syntax.Reflectable uu___2 -> true
-                    | uu___2 -> false)) in
-          if uu___
-          then
-            let monad_env =
-              let uu___1 = FStar_Ident.ident_of_lid effect_name in
-              FStar_Syntax_DsEnv.enter_monad_scope env uu___1 in
-            let reflect_lid =
-              let uu___1 = FStar_Ident.id_of_text "reflect" in
-              FStar_Compiler_Effect.op_Bar_Greater uu___1
-                (FStar_Syntax_DsEnv.qualify monad_env) in
-            let quals1 =
-              [FStar_Syntax_Syntax.Assumption;
-              FStar_Syntax_Syntax.Reflectable effect_name] in
-            let refl_decl =
-              {
-                FStar_Syntax_Syntax.sigel =
-                  (FStar_Syntax_Syntax.Sig_declare_typ
-                     (reflect_lid, [], FStar_Syntax_Syntax.tun));
-                FStar_Syntax_Syntax.sigrng = range;
-                FStar_Syntax_Syntax.sigquals = quals1;
-                FStar_Syntax_Syntax.sigmeta =
-                  FStar_Syntax_Syntax.default_sigmeta;
-                FStar_Syntax_Syntax.sigattrs = [];
-                FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-              } in
-            FStar_Syntax_DsEnv.push_sigelt env refl_decl
-          else env
-let (parse_attr_with_list :
-  Prims.bool ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Ident.lident ->
-        (Prims.int Prims.list FStar_Pervasives_Native.option * Prims.bool))
-  =
-  fun warn ->
-    fun at ->
-      fun head ->
-        let warn1 uu___ =
-          if warn
-          then
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Ident.string_of_lid head in
-                FStar_Compiler_Util.format1
-                  "Found ill-applied '%s', argument should be a non-empty list of integer literals"
-                  uu___3 in
-              (FStar_Errors.Warning_UnappliedFail, uu___2) in
-            FStar_Errors.log_issue at.FStar_Syntax_Syntax.pos uu___1
-          else () in
-        let uu___ = FStar_Syntax_Util.head_and_args at in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Subst.compress hd in
-              uu___2.FStar_Syntax_Syntax.n in
-            (match uu___1 with
-             | FStar_Syntax_Syntax.Tm_fvar fv when
-                 FStar_Syntax_Syntax.fv_eq_lid fv head ->
-                 (match args with
-                  | [] -> ((FStar_Pervasives_Native.Some []), true)
-                  | (a1, uu___2)::[] ->
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_Syntax_Embeddings.e_list
-                              FStar_Syntax_Embeddings.e_int in
-                          FStar_Syntax_Embeddings.unembed uu___5 a1 in
-                        uu___4 true FStar_Syntax_Embeddings.id_norm_cb in
-                      (match uu___3 with
-                       | FStar_Pervasives_Native.Some es ->
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_Compiler_List.map FStar_BigInt.to_int_fs
-                                 es in
-                             FStar_Pervasives_Native.Some uu___5 in
-                           (uu___4, true)
-                       | uu___4 ->
-                           (warn1 (); (FStar_Pervasives_Native.None, true)))
-                  | uu___2 ->
-                      (warn1 (); (FStar_Pervasives_Native.None, true)))
-             | uu___2 -> (FStar_Pervasives_Native.None, false))
-let (get_fail_attr1 :
-  Prims.bool ->
-    FStar_Syntax_Syntax.term ->
-      (Prims.int Prims.list * Prims.bool) FStar_Pervasives_Native.option)
-  =
-  fun warn ->
-    fun at ->
-      let rebind res b =
-        match res with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some l ->
-            FStar_Pervasives_Native.Some (l, b) in
-      let uu___ = parse_attr_with_list warn at FStar_Parser_Const.fail_attr in
-      match uu___ with
-      | (res, matched) ->
-          if matched
-          then rebind res false
-          else
-            (let uu___2 =
-               parse_attr_with_list warn at FStar_Parser_Const.fail_lax_attr in
-             match uu___2 with | (res1, uu___3) -> rebind res1 true)
-let (get_fail_attr :
-  Prims.bool ->
-    FStar_Syntax_Syntax.term Prims.list ->
-      (Prims.int Prims.list * Prims.bool) FStar_Pervasives_Native.option)
-  =
-  fun warn ->
-    fun ats ->
-      let comb f1 f2 =
-        match (f1, f2) with
-        | (FStar_Pervasives_Native.Some (e1, l1),
-           FStar_Pervasives_Native.Some (e2, l2)) ->
-            FStar_Pervasives_Native.Some
-              ((FStar_Compiler_List.op_At e1 e2), (l1 || l2))
-        | (FStar_Pervasives_Native.Some (e, l), FStar_Pervasives_Native.None)
-            -> FStar_Pervasives_Native.Some (e, l)
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some (e, l))
-            -> FStar_Pervasives_Native.Some (e, l)
-        | uu___ -> FStar_Pervasives_Native.None in
-      FStar_Compiler_List.fold_right
-        (fun at ->
-           fun acc -> let uu___ = get_fail_attr1 warn at in comb uu___ acc)
-        ats FStar_Pervasives_Native.None
-let (lookup_effect_lid :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Ident.lident ->
-      FStar_Compiler_Range.range -> FStar_Syntax_Syntax.eff_decl)
-  =
-  fun env ->
-    fun l ->
-      fun r ->
-        let uu___ = FStar_Syntax_DsEnv.try_lookup_effect_defn env l in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Print.lid_to_string l in
-                  Prims.op_Hat uu___4 " not found" in
-                Prims.op_Hat "Effect name " uu___3 in
-              (FStar_Errors.Fatal_EffectNotFound, uu___2) in
-            FStar_Errors.raise_error uu___1 r
-        | FStar_Pervasives_Native.Some l1 -> l1
-let rec (desugar_effect :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.decl ->
-      FStar_Parser_AST.qualifiers ->
-        Prims.bool ->
-          FStar_Ident.ident ->
-            FStar_Parser_AST.binder Prims.list ->
-              FStar_Parser_AST.term ->
-                FStar_Parser_AST.decl Prims.list ->
-                  FStar_Parser_AST.term Prims.list ->
-                    (FStar_Syntax_DsEnv.env * FStar_Syntax_Syntax.sigelt
-                      Prims.list))
-  =
-  fun env ->
-    fun d ->
-      fun quals ->
-        fun is_layered ->
-          fun eff_name ->
-            fun eff_binders ->
-              fun eff_typ ->
-                fun eff_decls ->
-                  fun attrs ->
-                    let env0 = env in
-                    let monad_env =
-                      FStar_Syntax_DsEnv.enter_monad_scope env eff_name in
-                    let uu___ = desugar_binders monad_env eff_binders in
-                    match uu___ with
-                    | (env1, binders) ->
-                        let eff_t = desugar_term env1 eff_typ in
-                        let num_indices =
-                          let uu___1 =
-                            let uu___2 =
-                              FStar_Syntax_Util.arrow_formals eff_t in
-                            FStar_Pervasives_Native.fst uu___2 in
-                          FStar_Compiler_List.length uu___1 in
-                        let for_free =
-                          (num_indices = Prims.int_one) &&
-                            (Prims.op_Negation is_layered) in
-                        (if for_free
-                         then
-                           (let uu___2 =
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Ident.string_of_id eff_name in
-                                FStar_Compiler_Util.format1
-                                  "DM4Free feature is deprecated and will be removed soon, use layered effects to define %s"
-                                  uu___4 in
-                              (FStar_Errors.Warning_DeprecatedGeneric,
-                                uu___3) in
-                            FStar_Errors.log_issue d.FStar_Parser_AST.drange
-                              uu___2)
-                         else ();
-                         (let mandatory_members =
-                            let rr_members = ["repr"; "return"; "bind"] in
-                            if for_free
-                            then rr_members
-                            else
-                              if is_layered
-                              then
-                                FStar_Compiler_List.op_At rr_members
-                                  ["subcomp"; "if_then_else"]
-                              else
-                                FStar_Compiler_List.op_At rr_members
-                                  ["return_wp";
-                                  "bind_wp";
-                                  "if_then_else";
-                                  "ite_wp";
-                                  "stronger";
-                                  "close_wp";
-                                  "trivial"] in
-                          let name_of_eff_decl decl =
-                            match decl.FStar_Parser_AST.d with
-                            | FStar_Parser_AST.Tycon
-                                (uu___2, uu___3,
-                                 (FStar_Parser_AST.TyconAbbrev
-                                 (name, uu___4, uu___5, uu___6))::[])
-                                -> FStar_Ident.string_of_id name
-                            | uu___2 ->
-                                failwith
-                                  "Malformed effect member declaration." in
-                          let uu___2 =
-                            FStar_Compiler_List.partition
-                              (fun decl ->
-                                 let uu___3 = name_of_eff_decl decl in
-                                 FStar_Compiler_List.mem uu___3
-                                   mandatory_members) eff_decls in
-                          match uu___2 with
-                          | (mandatory_members_decls, actions) ->
-                              let uu___3 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  mandatory_members_decls
-                                  (FStar_Compiler_List.fold_left
-                                     (fun uu___4 ->
-                                        fun decl ->
-                                          match uu___4 with
-                                          | (env2, out) ->
-                                              let uu___5 =
-                                                desugar_decl env2 decl in
-                                              (match uu___5 with
-                                               | (env3, ses) ->
-                                                   let uu___6 =
-                                                     let uu___7 =
-                                                       FStar_Compiler_List.hd
-                                                         ses in
-                                                     uu___7 :: out in
-                                                   (env3, uu___6)))
-                                     (env1, [])) in
-                              (match uu___3 with
-                               | (env2, decls) ->
-                                   let binders1 =
-                                     FStar_Syntax_Subst.close_binders binders in
-                                   let actions1 =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       actions
-                                       (FStar_Compiler_List.map
-                                          (fun d1 ->
-                                             match d1.FStar_Parser_AST.d with
-                                             | FStar_Parser_AST.Tycon
-                                                 (uu___4, uu___5,
-                                                  (FStar_Parser_AST.TyconAbbrev
-                                                  (name, action_params,
-                                                   uu___6,
-                                                   {
-                                                     FStar_Parser_AST.tm =
-                                                       FStar_Parser_AST.Construct
-                                                       (uu___7,
-                                                        (def, uu___8)::
-                                                        (cps_type, uu___9)::[]);
-                                                     FStar_Parser_AST.range =
-                                                       uu___10;
-                                                     FStar_Parser_AST.level =
-                                                       uu___11;_}))::[])
-                                                 when
-                                                 Prims.op_Negation for_free
-                                                 ->
-                                                 let uu___12 =
-                                                   desugar_binders env2
-                                                     action_params in
-                                                 (match uu___12 with
-                                                  | (env3, action_params1) ->
-                                                      let action_params2 =
-                                                        FStar_Syntax_Subst.close_binders
-                                                          action_params1 in
-                                                      let uu___13 =
-                                                        FStar_Syntax_DsEnv.qualify
-                                                          env3 name in
-                                                      let uu___14 =
-                                                        let uu___15 =
-                                                          desugar_term env3
-                                                            def in
-                                                        FStar_Syntax_Subst.close
-                                                          (FStar_Compiler_List.op_At
-                                                             binders1
-                                                             action_params2)
-                                                          uu___15 in
-                                                      let uu___15 =
-                                                        let uu___16 =
-                                                          desugar_typ env3
-                                                            cps_type in
-                                                        FStar_Syntax_Subst.close
-                                                          (FStar_Compiler_List.op_At
-                                                             binders1
-                                                             action_params2)
-                                                          uu___16 in
-                                                      {
-                                                        FStar_Syntax_Syntax.action_name
-                                                          = uu___13;
-                                                        FStar_Syntax_Syntax.action_unqualified_name
-                                                          = name;
-                                                        FStar_Syntax_Syntax.action_univs
-                                                          = [];
-                                                        FStar_Syntax_Syntax.action_params
-                                                          = action_params2;
-                                                        FStar_Syntax_Syntax.action_defn
-                                                          = uu___14;
-                                                        FStar_Syntax_Syntax.action_typ
-                                                          = uu___15
-                                                      })
-                                             | FStar_Parser_AST.Tycon
-                                                 (uu___4, uu___5,
-                                                  (FStar_Parser_AST.TyconAbbrev
-                                                  (name, action_params,
-                                                   uu___6, defn))::[])
-                                                 when for_free || is_layered
-                                                 ->
-                                                 let uu___7 =
-                                                   desugar_binders env2
-                                                     action_params in
-                                                 (match uu___7 with
-                                                  | (env3, action_params1) ->
-                                                      let action_params2 =
-                                                        FStar_Syntax_Subst.close_binders
-                                                          action_params1 in
-                                                      let uu___8 =
-                                                        FStar_Syntax_DsEnv.qualify
-                                                          env3 name in
-                                                      let uu___9 =
-                                                        let uu___10 =
-                                                          desugar_term env3
-                                                            defn in
-                                                        FStar_Syntax_Subst.close
-                                                          (FStar_Compiler_List.op_At
-                                                             binders1
-                                                             action_params2)
-                                                          uu___10 in
-                                                      {
-                                                        FStar_Syntax_Syntax.action_name
-                                                          = uu___8;
-                                                        FStar_Syntax_Syntax.action_unqualified_name
-                                                          = name;
-                                                        FStar_Syntax_Syntax.action_univs
-                                                          = [];
-                                                        FStar_Syntax_Syntax.action_params
-                                                          = action_params2;
-                                                        FStar_Syntax_Syntax.action_defn
-                                                          = uu___9;
-                                                        FStar_Syntax_Syntax.action_typ
-                                                          =
-                                                          FStar_Syntax_Syntax.tun
-                                                      })
-                                             | uu___4 ->
-                                                 FStar_Errors.raise_error
-                                                   (FStar_Errors.Fatal_MalformedActionDeclaration,
-                                                     "Malformed action declaration; if this is an \"effect for free\", just provide the direct-style declaration. If this is not an \"effect for free\", please provide a pair of the definition and its cps-type with arrows inserted in the right place (see examples).")
-                                                   d1.FStar_Parser_AST.drange)) in
-                                   let eff_t1 =
-                                     FStar_Syntax_Subst.close binders1 eff_t in
-                                   let lookup s =
-                                     let l =
-                                       let uu___4 =
-                                         FStar_Ident.mk_ident
-                                           (s, (d.FStar_Parser_AST.drange)) in
-                                       FStar_Syntax_DsEnv.qualify env2 uu___4 in
-                                     let uu___4 =
-                                       let uu___5 =
-                                         FStar_Syntax_DsEnv.fail_or env2
-                                           (FStar_Syntax_DsEnv.try_lookup_definition
-                                              env2) l in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         (FStar_Syntax_Subst.close binders1)
-                                         uu___5 in
-                                     ([], uu___4) in
-                                   let mname =
-                                     FStar_Syntax_DsEnv.qualify env0 eff_name in
-                                   let qualifiers =
-                                     FStar_Compiler_List.map
-                                       (trans_qual d.FStar_Parser_AST.drange
-                                          (FStar_Pervasives_Native.Some mname))
-                                       quals in
-                                   let dummy_tscheme =
-                                     ([], FStar_Syntax_Syntax.tun) in
-                                   let uu___4 =
-                                     if for_free
-                                     then
-                                       let uu___5 =
-                                         let uu___6 =
-                                           let uu___7 =
-                                             let uu___8 = lookup "repr" in
-                                             FStar_Pervasives_Native.Some
-                                               uu___8 in
-                                           let uu___8 =
-                                             let uu___9 = lookup "return" in
-                                             FStar_Pervasives_Native.Some
-                                               uu___9 in
-                                           let uu___9 =
-                                             let uu___10 = lookup "bind" in
-                                             FStar_Pervasives_Native.Some
-                                               uu___10 in
-                                           {
-                                             FStar_Syntax_Syntax.ret_wp =
-                                               dummy_tscheme;
-                                             FStar_Syntax_Syntax.bind_wp =
-                                               dummy_tscheme;
-                                             FStar_Syntax_Syntax.stronger =
-                                               dummy_tscheme;
-                                             FStar_Syntax_Syntax.if_then_else
-                                               = dummy_tscheme;
-                                             FStar_Syntax_Syntax.ite_wp =
-                                               dummy_tscheme;
-                                             FStar_Syntax_Syntax.close_wp =
-                                               dummy_tscheme;
-                                             FStar_Syntax_Syntax.trivial =
-                                               dummy_tscheme;
-                                             FStar_Syntax_Syntax.repr =
-                                               uu___7;
-                                             FStar_Syntax_Syntax.return_repr
-                                               = uu___8;
-                                             FStar_Syntax_Syntax.bind_repr =
-                                               uu___9
-                                           } in
-                                         FStar_Syntax_Syntax.DM4F_eff uu___6 in
-                                       ((FStar_Syntax_Syntax.WP_eff_sig
-                                           ([], eff_t1)), uu___5)
-                                     else
-                                       if is_layered
-                                       then
-                                         (let has_subcomp =
-                                            FStar_Compiler_List.existsb
-                                              (fun decl ->
-                                                 let uu___6 =
-                                                   name_of_eff_decl decl in
-                                                 uu___6 = "subcomp")
-                                              eff_decls in
-                                          let has_if_then_else =
-                                            FStar_Compiler_List.existsb
-                                              (fun decl ->
-                                                 let uu___6 =
-                                                   name_of_eff_decl decl in
-                                                 uu___6 = "if_then_else")
-                                              eff_decls in
-                                          let to_comb uu___6 =
-                                            match uu___6 with
-                                            | (us, t) ->
-                                                ((us, t), dummy_tscheme,
-                                                  FStar_Pervasives_Native.None) in
-                                          let uu___6 =
-                                            let uu___7 =
-                                              let uu___8 =
-                                                FStar_Syntax_Subst.compress
-                                                  eff_t1 in
-                                              uu___8.FStar_Syntax_Syntax.n in
-                                            match uu___7 with
-                                            | FStar_Syntax_Syntax.Tm_arrow
-                                                (bs, c) ->
-                                                let uu___8 = bs in
-                                                (match uu___8 with
-                                                 | a::bs1 ->
-                                                     let uu___9 =
-                                                       FStar_Compiler_List.fold_left
-                                                         (fun uu___10 ->
-                                                            fun b ->
-                                                              match uu___10
-                                                              with
-                                                              | (n,
-                                                                 allow_param,
-                                                                 bs2) ->
-                                                                  let b_attrs
-                                                                    =
-                                                                    b.FStar_Syntax_Syntax.binder_attrs in
-                                                                  let is_param
-                                                                    =
-                                                                    FStar_Syntax_Util.has_attribute
-                                                                    b_attrs
-                                                                    FStar_Parser_Const.effect_parameter_attr in
-                                                                  (if
-                                                                    is_param
-                                                                    &&
-                                                                    (Prims.op_Negation
-                                                                    allow_param)
-                                                                   then
-                                                                    FStar_Errors.raise_error
-                                                                    (FStar_Errors.Fatal_UnexpectedEffect,
-                                                                    "Effect parameters must all be upfront")
-                                                                    d.FStar_Parser_AST.drange
-                                                                   else ();
-                                                                   (let b_attrs1
-                                                                    =
-                                                                    FStar_Syntax_Util.remove_attr
-                                                                    FStar_Parser_Const.effect_parameter_attr
-                                                                    b_attrs in
-                                                                    ((if
-                                                                    is_param
-                                                                    then
-                                                                    n +
-                                                                    Prims.int_one
-                                                                    else n),
-                                                                    (allow_param
-                                                                    &&
-                                                                    is_param),
-                                                                    (FStar_Compiler_List.op_At
-                                                                    bs2
-                                                                    [
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_bv);
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_qual);
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    =
-                                                                    b_attrs1
-                                                                    }])))))
-                                                         (Prims.int_zero,
-                                                           true, []) bs1 in
-                                                     (match uu___9 with
-                                                      | (n, uu___10, bs2) ->
-                                                          ({
-                                                             FStar_Syntax_Syntax.n
-                                                               =
-                                                               (FStar_Syntax_Syntax.Tm_arrow
-                                                                  ((a ::
-                                                                    bs2), c));
-                                                             FStar_Syntax_Syntax.pos
-                                                               =
-                                                               (eff_t1.FStar_Syntax_Syntax.pos);
-                                                             FStar_Syntax_Syntax.vars
-                                                               =
-                                                               (eff_t1.FStar_Syntax_Syntax.vars);
-                                                             FStar_Syntax_Syntax.hash_code
-                                                               =
-                                                               (eff_t1.FStar_Syntax_Syntax.hash_code)
-                                                           }, n)))
-                                            | uu___8 ->
-                                                failwith
-                                                  "desugaring indexed effect: effect type not an arrow" in
-                                          match uu___6 with
-                                          | (eff_t2, num_effect_params) ->
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  let uu___9 =
-                                                    let uu___10 =
-                                                      lookup "repr" in
-                                                    (uu___10, dummy_tscheme) in
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      lookup "return" in
-                                                    (uu___11, dummy_tscheme) in
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      lookup "bind" in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      uu___12 to_comb in
-                                                  let uu___12 =
-                                                    if has_subcomp
-                                                    then
-                                                      let uu___13 =
-                                                        lookup "subcomp" in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___13 to_comb
-                                                    else
-                                                      (dummy_tscheme,
-                                                        dummy_tscheme,
-                                                        FStar_Pervasives_Native.None) in
-                                                  let uu___13 =
-                                                    if has_if_then_else
-                                                    then
-                                                      let uu___14 =
-                                                        lookup "if_then_else" in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___14 to_comb
-                                                    else
-                                                      (dummy_tscheme,
-                                                        dummy_tscheme,
-                                                        FStar_Pervasives_Native.None) in
-                                                  {
-                                                    FStar_Syntax_Syntax.l_repr
-                                                      = uu___9;
-                                                    FStar_Syntax_Syntax.l_return
-                                                      = uu___10;
-                                                    FStar_Syntax_Syntax.l_bind
-                                                      = uu___11;
-                                                    FStar_Syntax_Syntax.l_subcomp
-                                                      = uu___12;
-                                                    FStar_Syntax_Syntax.l_if_then_else
-                                                      = uu___13
-                                                  } in
-                                                FStar_Syntax_Syntax.Layered_eff
-                                                  uu___8 in
-                                              ((FStar_Syntax_Syntax.Layered_eff_sig
-                                                  (num_effect_params,
-                                                    ([], eff_t2))), uu___7))
-                                       else
-                                         (let rr =
-                                            FStar_Compiler_Util.for_some
-                                              (fun uu___7 ->
-                                                 match uu___7 with
-                                                 | FStar_Syntax_Syntax.Reifiable
-                                                     -> true
-                                                 | FStar_Syntax_Syntax.Reflectable
-                                                     uu___8 -> true
-                                                 | uu___8 -> false)
-                                              qualifiers in
-                                          let uu___7 =
-                                            let uu___8 =
-                                              let uu___9 = lookup "return_wp" in
-                                              let uu___10 = lookup "bind_wp" in
-                                              let uu___11 = lookup "stronger" in
-                                              let uu___12 =
-                                                lookup "if_then_else" in
-                                              let uu___13 = lookup "ite_wp" in
-                                              let uu___14 = lookup "close_wp" in
-                                              let uu___15 = lookup "trivial" in
-                                              let uu___16 =
-                                                if rr
-                                                then
-                                                  let uu___17 = lookup "repr" in
-                                                  FStar_Pervasives_Native.Some
-                                                    uu___17
-                                                else
-                                                  FStar_Pervasives_Native.None in
-                                              let uu___17 =
-                                                if rr
-                                                then
-                                                  let uu___18 =
-                                                    lookup "return" in
-                                                  FStar_Pervasives_Native.Some
-                                                    uu___18
-                                                else
-                                                  FStar_Pervasives_Native.None in
-                                              let uu___18 =
-                                                if rr
-                                                then
-                                                  let uu___19 = lookup "bind" in
-                                                  FStar_Pervasives_Native.Some
-                                                    uu___19
-                                                else
-                                                  FStar_Pervasives_Native.None in
-                                              {
-                                                FStar_Syntax_Syntax.ret_wp =
-                                                  uu___9;
-                                                FStar_Syntax_Syntax.bind_wp =
-                                                  uu___10;
-                                                FStar_Syntax_Syntax.stronger
-                                                  = uu___11;
-                                                FStar_Syntax_Syntax.if_then_else
-                                                  = uu___12;
-                                                FStar_Syntax_Syntax.ite_wp =
-                                                  uu___13;
-                                                FStar_Syntax_Syntax.close_wp
-                                                  = uu___14;
-                                                FStar_Syntax_Syntax.trivial =
-                                                  uu___15;
-                                                FStar_Syntax_Syntax.repr =
-                                                  uu___16;
-                                                FStar_Syntax_Syntax.return_repr
-                                                  = uu___17;
-                                                FStar_Syntax_Syntax.bind_repr
-                                                  = uu___18
-                                              } in
-                                            FStar_Syntax_Syntax.Primitive_eff
-                                              uu___8 in
-                                          ((FStar_Syntax_Syntax.WP_eff_sig
-                                              ([], eff_t1)), uu___7)) in
-                                   (match uu___4 with
-                                    | (eff_sig, combinators) ->
-                                        let sigel =
-                                          let uu___5 =
-                                            let uu___6 =
-                                              FStar_Compiler_List.map
-                                                (desugar_term env2) attrs in
-                                            {
-                                              FStar_Syntax_Syntax.mname =
-                                                mname;
-                                              FStar_Syntax_Syntax.cattributes
-                                                = [];
-                                              FStar_Syntax_Syntax.univs = [];
-                                              FStar_Syntax_Syntax.binders =
-                                                binders1;
-                                              FStar_Syntax_Syntax.signature =
-                                                eff_sig;
-                                              FStar_Syntax_Syntax.combinators
-                                                = combinators;
-                                              FStar_Syntax_Syntax.actions =
-                                                actions1;
-                                              FStar_Syntax_Syntax.eff_attrs =
-                                                uu___6
-                                            } in
-                                          FStar_Syntax_Syntax.Sig_new_effect
-                                            uu___5 in
-                                        let se =
-                                          {
-                                            FStar_Syntax_Syntax.sigel = sigel;
-                                            FStar_Syntax_Syntax.sigrng =
-                                              (d.FStar_Parser_AST.drange);
-                                            FStar_Syntax_Syntax.sigquals =
-                                              qualifiers;
-                                            FStar_Syntax_Syntax.sigmeta =
-                                              FStar_Syntax_Syntax.default_sigmeta;
-                                            FStar_Syntax_Syntax.sigattrs = [];
-                                            FStar_Syntax_Syntax.sigopts =
-                                              FStar_Pervasives_Native.None
-                                          } in
-                                        let env3 =
-                                          FStar_Syntax_DsEnv.push_sigelt env0
-                                            se in
-                                        let env4 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            actions1
-                                            (FStar_Compiler_List.fold_left
-                                               (fun env5 ->
-                                                  fun a ->
-                                                    let uu___5 =
-                                                      FStar_Syntax_Util.action_as_lb
-                                                        mname a
-                                                        (a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-                                                    FStar_Syntax_DsEnv.push_sigelt
-                                                      env5 uu___5) env3) in
-                                        let env5 =
-                                          push_reflect_effect env4 qualifiers
-                                            mname d.FStar_Parser_AST.drange in
-                                        (env5, [se])))))
-and (desugar_redefine_effect :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.decl ->
-      (FStar_Ident.lident FStar_Pervasives_Native.option ->
-         FStar_Parser_AST.qualifier -> FStar_Syntax_Syntax.qualifier)
-        ->
-        FStar_Parser_AST.qualifier Prims.list ->
-          FStar_Ident.ident ->
-            FStar_Parser_AST.binder Prims.list ->
-              FStar_Parser_AST.term ->
-                (FStar_Syntax_DsEnv.env * FStar_Syntax_Syntax.sigelt
-                  Prims.list))
-  =
-  fun env ->
-    fun d ->
-      fun trans_qual1 ->
-        fun quals ->
-          fun eff_name ->
-            fun eff_binders ->
-              fun defn ->
-                let env0 = env in
-                let env1 = FStar_Syntax_DsEnv.enter_monad_scope env eff_name in
-                let uu___ = desugar_binders env1 eff_binders in
-                match uu___ with
-                | (env2, binders) ->
-                    let uu___1 =
-                      let uu___2 = head_and_args defn in
-                      match uu___2 with
-                      | (head, args) ->
-                          let lid =
-                            match head.FStar_Parser_AST.tm with
-                            | FStar_Parser_AST.Name l -> l
-                            | uu___3 ->
-                                let uu___4 =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      let uu___7 =
-                                        FStar_Parser_AST.term_to_string head in
-                                      Prims.op_Hat uu___7 " not found" in
-                                    Prims.op_Hat "Effect " uu___6 in
-                                  (FStar_Errors.Fatal_EffectNotFound, uu___5) in
-                                FStar_Errors.raise_error uu___4
-                                  d.FStar_Parser_AST.drange in
-                          let ed =
-                            FStar_Syntax_DsEnv.fail_or env2
-                              (FStar_Syntax_DsEnv.try_lookup_effect_defn env2)
-                              lid in
-                          let uu___3 =
-                            match FStar_Compiler_List.rev args with
-                            | (last_arg, uu___4)::args_rev ->
-                                let uu___5 =
-                                  let uu___6 = unparen last_arg in
-                                  uu___6.FStar_Parser_AST.tm in
-                                (match uu___5 with
-                                 | FStar_Parser_AST.Attributes ts ->
-                                     (ts, (FStar_Compiler_List.rev args_rev))
-                                 | uu___6 -> ([], args))
-                            | uu___4 -> ([], args) in
-                          (match uu___3 with
-                           | (cattributes, args1) ->
-                               let uu___4 = desugar_args env2 args1 in
-                               let uu___5 =
-                                 desugar_attributes env2 cattributes in
-                               (lid, ed, uu___4, uu___5)) in
-                    (match uu___1 with
-                     | (ed_lid, ed, args, cattributes) ->
-                         let binders1 =
-                           FStar_Syntax_Subst.close_binders binders in
-                         (if
-                            (FStar_Compiler_List.length args) <>
-                              (FStar_Compiler_List.length
-                                 ed.FStar_Syntax_Syntax.binders)
-                          then
-                            FStar_Errors.raise_error
-                              (FStar_Errors.Fatal_ArgumentLengthMismatch,
-                                "Unexpected number of arguments to effect constructor")
-                              defn.FStar_Parser_AST.range
-                          else ();
-                          (let uu___3 =
-                             FStar_Syntax_Subst.open_term'
-                               ed.FStar_Syntax_Syntax.binders
-                               FStar_Syntax_Syntax.t_unit in
-                           match uu___3 with
-                           | (ed_binders, uu___4, ed_binders_opening) ->
-                               let sub' shift_n uu___5 =
-                                 match uu___5 with
-                                 | (us, x) ->
-                                     let x1 =
-                                       let uu___6 =
-                                         FStar_Syntax_Subst.shift_subst
-                                           (shift_n +
-                                              (FStar_Compiler_List.length us))
-                                           ed_binders_opening in
-                                       FStar_Syntax_Subst.subst uu___6 x in
-                                     let s =
-                                       FStar_Syntax_Util.subst_of_list
-                                         ed_binders args in
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Syntax_Subst.subst s x1 in
-                                       (us, uu___7) in
-                                     FStar_Syntax_Subst.close_tscheme
-                                       binders1 uu___6 in
-                               let sub = sub' Prims.int_zero in
-                               let mname =
-                                 FStar_Syntax_DsEnv.qualify env0 eff_name in
-                               let ed1 =
-                                 let uu___5 =
-                                   FStar_Syntax_Util.apply_eff_sig sub
-                                     ed.FStar_Syntax_Syntax.signature in
-                                 let uu___6 =
-                                   FStar_Syntax_Util.apply_eff_combinators
-                                     sub ed.FStar_Syntax_Syntax.combinators in
-                                 let uu___7 =
-                                   FStar_Compiler_List.map
-                                     (fun action ->
-                                        let nparam =
-                                          FStar_Compiler_List.length
-                                            action.FStar_Syntax_Syntax.action_params in
-                                        let uu___8 =
-                                          FStar_Syntax_DsEnv.qualify env2
-                                            action.FStar_Syntax_Syntax.action_unqualified_name in
-                                        let uu___9 =
-                                          let uu___10 =
-                                            sub' nparam
-                                              ([],
-                                                (action.FStar_Syntax_Syntax.action_defn)) in
-                                          FStar_Pervasives_Native.snd uu___10 in
-                                        let uu___10 =
-                                          let uu___11 =
-                                            sub' nparam
-                                              ([],
-                                                (action.FStar_Syntax_Syntax.action_typ)) in
-                                          FStar_Pervasives_Native.snd uu___11 in
-                                        {
-                                          FStar_Syntax_Syntax.action_name =
-                                            uu___8;
-                                          FStar_Syntax_Syntax.action_unqualified_name
-                                            =
-                                            (action.FStar_Syntax_Syntax.action_unqualified_name);
-                                          FStar_Syntax_Syntax.action_univs =
-                                            (action.FStar_Syntax_Syntax.action_univs);
-                                          FStar_Syntax_Syntax.action_params =
-                                            (action.FStar_Syntax_Syntax.action_params);
-                                          FStar_Syntax_Syntax.action_defn =
-                                            uu___9;
-                                          FStar_Syntax_Syntax.action_typ =
-                                            uu___10
-                                        }) ed.FStar_Syntax_Syntax.actions in
-                                 {
-                                   FStar_Syntax_Syntax.mname = mname;
-                                   FStar_Syntax_Syntax.cattributes =
-                                     cattributes;
-                                   FStar_Syntax_Syntax.univs =
-                                     (ed.FStar_Syntax_Syntax.univs);
-                                   FStar_Syntax_Syntax.binders = binders1;
-                                   FStar_Syntax_Syntax.signature = uu___5;
-                                   FStar_Syntax_Syntax.combinators = uu___6;
-                                   FStar_Syntax_Syntax.actions = uu___7;
-                                   FStar_Syntax_Syntax.eff_attrs =
-                                     (ed.FStar_Syntax_Syntax.eff_attrs)
-                                 } in
-                               let se =
-                                 let uu___5 =
-                                   let uu___6 =
-                                     trans_qual1
-                                       (FStar_Pervasives_Native.Some mname) in
-                                   FStar_Compiler_List.map uu___6 quals in
-                                 {
-                                   FStar_Syntax_Syntax.sigel =
-                                     (FStar_Syntax_Syntax.Sig_new_effect ed1);
-                                   FStar_Syntax_Syntax.sigrng =
-                                     (d.FStar_Parser_AST.drange);
-                                   FStar_Syntax_Syntax.sigquals = uu___5;
-                                   FStar_Syntax_Syntax.sigmeta =
-                                     FStar_Syntax_Syntax.default_sigmeta;
-                                   FStar_Syntax_Syntax.sigattrs = [];
-                                   FStar_Syntax_Syntax.sigopts =
-                                     FStar_Pervasives_Native.None
-                                 } in
-                               let monad_env = env2 in
-                               let env3 =
-                                 FStar_Syntax_DsEnv.push_sigelt env0 se in
-                               let env4 =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   ed1.FStar_Syntax_Syntax.actions
-                                   (FStar_Compiler_List.fold_left
-                                      (fun env5 ->
-                                         fun a ->
-                                           let uu___5 =
-                                             FStar_Syntax_Util.action_as_lb
-                                               mname a
-                                               (a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-                                           FStar_Syntax_DsEnv.push_sigelt
-                                             env5 uu___5) env3) in
-                               let env5 =
-                                 let uu___5 =
-                                   FStar_Compiler_Effect.op_Bar_Greater quals
-                                     (FStar_Compiler_List.contains
-                                        FStar_Parser_AST.Reflectable) in
-                                 if uu___5
-                                 then
-                                   let reflect_lid =
-                                     let uu___6 =
-                                       FStar_Ident.id_of_text "reflect" in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___6
-                                       (FStar_Syntax_DsEnv.qualify monad_env) in
-                                   let quals1 =
-                                     [FStar_Syntax_Syntax.Assumption;
-                                     FStar_Syntax_Syntax.Reflectable mname] in
-                                   let refl_decl =
-                                     {
-                                       FStar_Syntax_Syntax.sigel =
-                                         (FStar_Syntax_Syntax.Sig_declare_typ
-                                            (reflect_lid, [],
-                                              FStar_Syntax_Syntax.tun));
-                                       FStar_Syntax_Syntax.sigrng =
-                                         (d.FStar_Parser_AST.drange);
-                                       FStar_Syntax_Syntax.sigquals = quals1;
-                                       FStar_Syntax_Syntax.sigmeta =
-                                         FStar_Syntax_Syntax.default_sigmeta;
-                                       FStar_Syntax_Syntax.sigattrs = [];
-                                       FStar_Syntax_Syntax.sigopts =
-                                         FStar_Pervasives_Native.None
-                                     } in
-                                   FStar_Syntax_DsEnv.push_sigelt env4
-                                     refl_decl
-                                 else env4 in
-                               (env5, [se]))))
-and (desugar_decl_aux :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.decl -> (env_t * FStar_Syntax_Syntax.sigelts))
-  =
-  fun env ->
-    fun d ->
-      let no_fail_attrs ats =
-        FStar_Compiler_List.filter
-          (fun at ->
-             let uu___ = get_fail_attr1 false at in
-             FStar_Compiler_Option.isNone uu___) ats in
-      let env0 =
-        let uu___ = FStar_Syntax_DsEnv.snapshot env in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          FStar_Pervasives_Native.snd in
-      let attrs =
-        FStar_Compiler_List.map (desugar_term env) d.FStar_Parser_AST.attrs in
-      let uu___ =
-        let uu___1 = get_fail_attr false attrs in
-        match uu___1 with
-        | FStar_Pervasives_Native.Some (expected_errs, lax) ->
-            let d1 =
-              {
-                FStar_Parser_AST.d = (d.FStar_Parser_AST.d);
-                FStar_Parser_AST.drange = (d.FStar_Parser_AST.drange);
-                FStar_Parser_AST.quals = (d.FStar_Parser_AST.quals);
-                FStar_Parser_AST.attrs = []
-              } in
-            let uu___2 =
-              FStar_Errors.catch_errors
-                (fun uu___3 ->
-                   FStar_Options.with_saved_options
-                     (fun uu___4 -> desugar_decl_noattrs env d1)) in
-            (match uu___2 with
-             | (errs, r) ->
-                 (match (errs, r) with
-                  | ([], FStar_Pervasives_Native.Some (env1, ses)) ->
-                      let ses1 =
-                        FStar_Compiler_List.map
-                          (fun se ->
-                             let uu___3 = no_fail_attrs attrs in
-                             {
-                               FStar_Syntax_Syntax.sigel =
-                                 (se.FStar_Syntax_Syntax.sigel);
-                               FStar_Syntax_Syntax.sigrng =
-                                 (se.FStar_Syntax_Syntax.sigrng);
-                               FStar_Syntax_Syntax.sigquals =
-                                 (se.FStar_Syntax_Syntax.sigquals);
-                               FStar_Syntax_Syntax.sigmeta =
-                                 (se.FStar_Syntax_Syntax.sigmeta);
-                               FStar_Syntax_Syntax.sigattrs = uu___3;
-                               FStar_Syntax_Syntax.sigopts =
-                                 (se.FStar_Syntax_Syntax.sigopts)
-                             }) ses in
-                      let se =
-                        {
-                          FStar_Syntax_Syntax.sigel =
-                            (FStar_Syntax_Syntax.Sig_fail
-                               (expected_errs, lax, ses1));
-                          FStar_Syntax_Syntax.sigrng =
-                            (d1.FStar_Parser_AST.drange);
-                          FStar_Syntax_Syntax.sigquals = [];
-                          FStar_Syntax_Syntax.sigmeta =
-                            FStar_Syntax_Syntax.default_sigmeta;
-                          FStar_Syntax_Syntax.sigattrs = [];
-                          FStar_Syntax_Syntax.sigopts =
-                            FStar_Pervasives_Native.None
-                        } in
-                      (env0, [se])
-                  | (errs1, ropt) ->
-                      let errnos =
-                        FStar_Compiler_List.concatMap
-                          (fun i ->
-                             FStar_Common.list_of_option
-                               i.FStar_Errors.issue_number) errs1 in
-                      if expected_errs = []
-                      then (env0, [])
-                      else
-                        (let uu___4 =
-                           FStar_Errors.find_multiset_discrepancy
-                             expected_errs errnos in
-                         match uu___4 with
-                         | FStar_Pervasives_Native.None -> (env0, [])
-                         | FStar_Pervasives_Native.Some (e, n1, n2) ->
-                             (FStar_Compiler_List.iter
-                                FStar_Errors.print_issue errs1;
-                              (let uu___7 =
-                                 let uu___8 =
-                                   let uu___9 =
-                                     (FStar_Common.string_of_list ())
-                                       FStar_Compiler_Util.string_of_int
-                                       expected_errs in
-                                   let uu___10 =
-                                     (FStar_Common.string_of_list ())
-                                       FStar_Compiler_Util.string_of_int
-                                       errnos in
-                                   let uu___11 =
-                                     FStar_Compiler_Util.string_of_int e in
-                                   let uu___12 =
-                                     FStar_Compiler_Util.string_of_int n2 in
-                                   let uu___13 =
-                                     FStar_Compiler_Util.string_of_int n1 in
-                                   FStar_Compiler_Util.format5
-                                     "This top-level definition was expected to raise error codes %s, but it raised %s (at desugaring time). Error #%s was raised %s times, instead of %s."
-                                     uu___9 uu___10 uu___11 uu___12 uu___13 in
-                                 (FStar_Errors.Error_DidNotFail, uu___8) in
-                               FStar_Errors.log_issue
-                                 d1.FStar_Parser_AST.drange uu___7);
-                              (env0, [])))))
-        | FStar_Pervasives_Native.None -> desugar_decl_noattrs env d in
-      match uu___ with
-      | (env1, sigelts) ->
-          let rec val_attrs ses =
-            match ses with
-            | {
-                FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_let
-                  uu___1;
-                FStar_Syntax_Syntax.sigrng = uu___2;
-                FStar_Syntax_Syntax.sigquals = uu___3;
-                FStar_Syntax_Syntax.sigmeta = uu___4;
-                FStar_Syntax_Syntax.sigattrs = uu___5;
-                FStar_Syntax_Syntax.sigopts = uu___6;_}::[] ->
-                let uu___7 =
-                  let uu___8 = FStar_Compiler_List.hd sigelts in
-                  FStar_Syntax_Util.lids_of_sigelt uu___8 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                  (FStar_Compiler_List.collect
-                     (fun nm ->
-                        let uu___8 =
-                          FStar_Syntax_DsEnv.lookup_letbinding_quals_and_attrs
-                            env0 nm in
-                        FStar_Pervasives_Native.snd uu___8))
-            | {
-                FStar_Syntax_Syntax.sigel =
-                  FStar_Syntax_Syntax.Sig_inductive_typ uu___1;
-                FStar_Syntax_Syntax.sigrng = uu___2;
-                FStar_Syntax_Syntax.sigquals = uu___3;
-                FStar_Syntax_Syntax.sigmeta = uu___4;
-                FStar_Syntax_Syntax.sigattrs = uu___5;
-                FStar_Syntax_Syntax.sigopts = uu___6;_}::uu___7 ->
-                let uu___8 =
-                  let uu___9 = FStar_Compiler_List.hd sigelts in
-                  FStar_Syntax_Util.lids_of_sigelt uu___9 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___8
-                  (FStar_Compiler_List.collect
-                     (fun nm ->
-                        let uu___9 =
-                          FStar_Syntax_DsEnv.lookup_letbinding_quals_and_attrs
-                            env0 nm in
-                        FStar_Pervasives_Native.snd uu___9))
-            | {
-                FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_fail
-                  (_errs, _lax, ses1);
-                FStar_Syntax_Syntax.sigrng = uu___1;
-                FStar_Syntax_Syntax.sigquals = uu___2;
-                FStar_Syntax_Syntax.sigmeta = uu___3;
-                FStar_Syntax_Syntax.sigattrs = uu___4;
-                FStar_Syntax_Syntax.sigopts = uu___5;_}::[] ->
-                FStar_Compiler_List.collect (fun se -> val_attrs [se]) ses1
-            | uu___1 -> [] in
-          let attrs1 =
-            let uu___1 = val_attrs sigelts in
-            FStar_Compiler_List.op_At attrs uu___1 in
-          let uu___1 =
-            FStar_Compiler_List.map
-              (fun sigelt ->
-                 {
-                   FStar_Syntax_Syntax.sigel =
-                     (sigelt.FStar_Syntax_Syntax.sigel);
-                   FStar_Syntax_Syntax.sigrng =
-                     (sigelt.FStar_Syntax_Syntax.sigrng);
-                   FStar_Syntax_Syntax.sigquals =
-                     (sigelt.FStar_Syntax_Syntax.sigquals);
-                   FStar_Syntax_Syntax.sigmeta =
-                     (sigelt.FStar_Syntax_Syntax.sigmeta);
-                   FStar_Syntax_Syntax.sigattrs = attrs1;
-                   FStar_Syntax_Syntax.sigopts =
-                     (sigelt.FStar_Syntax_Syntax.sigopts)
-                 }) sigelts in
-          (env1, uu___1)
-and (desugar_decl :
-  env_t -> FStar_Parser_AST.decl -> (env_t * FStar_Syntax_Syntax.sigelts)) =
-  fun env ->
-    fun d ->
-      let uu___ = desugar_decl_aux env d in
-      match uu___ with
-      | (env1, ses) ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater ses
-              (FStar_Compiler_List.map generalize_annotated_univs) in
-          (env1, uu___1)
-and (desugar_decl_noattrs :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.decl -> (env_t * FStar_Syntax_Syntax.sigelts))
-  =
-  fun env ->
-    fun d ->
-      let trans_qual1 = trans_qual d.FStar_Parser_AST.drange in
-      match d.FStar_Parser_AST.d with
-      | FStar_Parser_AST.Pragma p ->
-          let p1 = trans_pragma p in
-          (FStar_Syntax_Util.process_pragma p1 d.FStar_Parser_AST.drange;
-           (let se =
-              {
-                FStar_Syntax_Syntax.sigel =
-                  (FStar_Syntax_Syntax.Sig_pragma p1);
-                FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-                FStar_Syntax_Syntax.sigquals = [];
-                FStar_Syntax_Syntax.sigmeta =
-                  FStar_Syntax_Syntax.default_sigmeta;
-                FStar_Syntax_Syntax.sigattrs = [];
-                FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-              } in
-            (env, [se])))
-      | FStar_Parser_AST.TopLevelModule id -> (env, [])
-      | FStar_Parser_AST.Open lid ->
-          let env1 = FStar_Syntax_DsEnv.push_namespace env lid in (env1, [])
-      | FStar_Parser_AST.Friend lid ->
-          let uu___ = FStar_Syntax_DsEnv.iface env in
-          if uu___
-          then
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_FriendInterface,
-                "'friend' declarations are not allowed in interfaces")
-              d.FStar_Parser_AST.drange
-          else
-            (let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_DsEnv.dep_graph env in
-                 let uu___5 = FStar_Syntax_DsEnv.current_module env in
-                 FStar_Parser_Dep.module_has_interface uu___4 uu___5 in
-               Prims.op_Negation uu___3 in
-             if uu___2
-             then
-               FStar_Errors.raise_error
-                 (FStar_Errors.Fatal_FriendInterface,
-                   "'friend' declarations are not allowed in modules that lack interfaces")
-                 d.FStar_Parser_AST.drange
-             else
-               (let uu___4 =
-                  let uu___5 =
-                    let uu___6 = FStar_Syntax_DsEnv.dep_graph env in
-                    FStar_Parser_Dep.module_has_interface uu___6 lid in
-                  Prims.op_Negation uu___5 in
-                if uu___4
-                then
-                  FStar_Errors.raise_error
-                    (FStar_Errors.Fatal_FriendInterface,
-                      "'friend' declarations cannot refer to modules that lack interfaces")
-                    d.FStar_Parser_AST.drange
-                else
-                  (let uu___6 =
-                     let uu___7 =
-                       let uu___8 = FStar_Syntax_DsEnv.dep_graph env in
-                       FStar_Parser_Dep.deps_has_implementation uu___8 lid in
-                     Prims.op_Negation uu___7 in
-                   if uu___6
-                   then
-                     FStar_Errors.raise_error
-                       (FStar_Errors.Fatal_FriendInterface,
-                         "'friend' module has not been loaded; recompute dependences (C-c C-r) if in interactive mode")
-                       d.FStar_Parser_AST.drange
-                   else (env, []))))
-      | FStar_Parser_AST.Include lid ->
-          let env1 = FStar_Syntax_DsEnv.push_include env lid in (env1, [])
-      | FStar_Parser_AST.ModuleAbbrev (x, l) ->
-          let uu___ = FStar_Syntax_DsEnv.push_module_abbrev env x l in
-          (uu___, [])
-      | FStar_Parser_AST.Tycon (is_effect, typeclass, tcs) ->
-          let quals = d.FStar_Parser_AST.quals in
-          let quals1 =
-            if is_effect
-            then FStar_Parser_AST.Effect_qual :: quals
-            else quals in
-          let quals2 =
-            if typeclass
-            then
-              match tcs with
-              | (FStar_Parser_AST.TyconRecord uu___)::[] ->
-                  FStar_Parser_AST.Noeq :: quals1
-              | uu___ ->
-                  FStar_Errors.raise_error
-                    (FStar_Errors.Error_BadClassDecl,
-                      "Ill-formed `class` declaration: definition must be a record type")
-                    d.FStar_Parser_AST.drange
-            else quals1 in
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map
-                (trans_qual1 FStar_Pervasives_Native.None) quals2 in
-            desugar_tycon env d uu___1 tcs in
-          (match uu___ with
-           | (env1, ses) ->
-               let mkclass lid =
-                 let r = FStar_Ident.range_of_lid lid in
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = tun_r r in
-                       FStar_Syntax_Syntax.new_bv
-                         (FStar_Pervasives_Native.Some r) uu___4 in
-                     FStar_Syntax_Syntax.mk_binder uu___3 in
-                   [uu___2] in
-                 let uu___2 =
-                   let uu___3 =
-                     FStar_Syntax_Syntax.tabbrev
-                       FStar_Parser_Const.mk_class_lid in
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 = FStar_Ident.string_of_lid lid in
-                         FStar_Syntax_Util.exp_string uu___7 in
-                       FStar_Syntax_Syntax.as_arg uu___6 in
-                     [uu___5] in
-                   FStar_Syntax_Util.mk_app uu___3 uu___4 in
-                 FStar_Syntax_Util.abs uu___1 uu___2
-                   FStar_Pervasives_Native.None in
-               let get_meths se =
-                 let rec get_fname quals3 =
-                   match quals3 with
-                   | (FStar_Syntax_Syntax.Projector (uu___1, id))::uu___2 ->
-                       FStar_Pervasives_Native.Some id
-                   | uu___1::quals4 -> get_fname quals4
-                   | [] -> FStar_Pervasives_Native.None in
-                 let uu___1 = get_fname se.FStar_Syntax_Syntax.sigquals in
-                 match uu___1 with
-                 | FStar_Pervasives_Native.None -> []
-                 | FStar_Pervasives_Native.Some id ->
-                     let uu___2 = FStar_Syntax_DsEnv.qualify env1 id in
-                     [uu___2] in
-               let formals =
-                 let bndl =
-                   FStar_Compiler_Util.try_find
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | {
-                            FStar_Syntax_Syntax.sigel =
-                              FStar_Syntax_Syntax.Sig_bundle uu___2;
-                            FStar_Syntax_Syntax.sigrng = uu___3;
-                            FStar_Syntax_Syntax.sigquals = uu___4;
-                            FStar_Syntax_Syntax.sigmeta = uu___5;
-                            FStar_Syntax_Syntax.sigattrs = uu___6;
-                            FStar_Syntax_Syntax.sigopts = uu___7;_} -> true
-                        | uu___2 -> false) ses in
-                 match bndl with
-                 | FStar_Pervasives_Native.None ->
-                     FStar_Pervasives_Native.None
-                 | FStar_Pervasives_Native.Some bndl1 ->
-                     (match bndl1.FStar_Syntax_Syntax.sigel with
-                      | FStar_Syntax_Syntax.Sig_bundle (ses1, uu___1) ->
-                          FStar_Compiler_Util.find_map ses1
-                            (fun se ->
-                               match se.FStar_Syntax_Syntax.sigel with
-                               | FStar_Syntax_Syntax.Sig_datacon
-                                   (_l, _u, t, uu___2, uu___3, uu___4) ->
-                                   let uu___5 =
-                                     FStar_Syntax_Util.arrow_formals t in
-                                   (match uu___5 with
-                                    | (formals1, uu___6) ->
-                                        FStar_Pervasives_Native.Some formals1)
-                               | uu___2 -> FStar_Pervasives_Native.None)
-                      | uu___1 -> FStar_Pervasives_Native.None) in
-               let rec splice_decl meths se =
-                 match se.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_bundle (ses1, uu___1) ->
-                     FStar_Compiler_List.concatMap (splice_decl meths) ses1
-                 | FStar_Syntax_Syntax.Sig_inductive_typ
-                     (lid, _univs, _binders, _num_uniform, ty, _mutuals,
-                      _datas)
-                     ->
-                     let formals1 =
-                       match formals with
-                       | FStar_Pervasives_Native.None -> []
-                       | FStar_Pervasives_Native.Some formals2 -> formals2 in
-                     let has_no_method_attr meth =
-                       let i = FStar_Ident.ident_of_lid meth in
-                       FStar_Compiler_Util.for_some
-                         (fun formal ->
-                            let uu___1 =
-                              FStar_Ident.ident_equals i
-                                (formal.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.ppname in
-                            if uu___1
-                            then
-                              FStar_Compiler_Util.for_some
-                                (fun attr ->
-                                   let uu___2 =
-                                     let uu___3 =
-                                       FStar_Syntax_Subst.compress attr in
-                                     uu___3.FStar_Syntax_Syntax.n in
-                                   match uu___2 with
-                                   | FStar_Syntax_Syntax.Tm_fvar fv ->
-                                       FStar_Syntax_Syntax.fv_eq_lid fv
-                                         FStar_Parser_Const.no_method_lid
-                                   | uu___3 -> false)
-                                formal.FStar_Syntax_Syntax.binder_attrs
-                            else false) formals1 in
-                     let meths1 =
-                       FStar_Compiler_List.filter
-                         (fun x ->
-                            let uu___1 = has_no_method_attr x in
-                            Prims.op_Negation uu___1) meths in
-                     let uu___1 =
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 = mkclass lid in (meths1, uu___4) in
-                         FStar_Syntax_Syntax.Sig_splice uu___3 in
-                       {
-                         FStar_Syntax_Syntax.sigel = uu___2;
-                         FStar_Syntax_Syntax.sigrng =
-                           (d.FStar_Parser_AST.drange);
-                         FStar_Syntax_Syntax.sigquals = [];
-                         FStar_Syntax_Syntax.sigmeta =
-                           FStar_Syntax_Syntax.default_sigmeta;
-                         FStar_Syntax_Syntax.sigattrs = [];
-                         FStar_Syntax_Syntax.sigopts =
-                           FStar_Pervasives_Native.None
-                       } in
-                     [uu___1]
-                 | uu___1 -> [] in
-               let uu___1 =
-                 if typeclass
-                 then
-                   let meths = FStar_Compiler_List.concatMap get_meths ses in
-                   let rec add_class_attr se =
-                     match se.FStar_Syntax_Syntax.sigel with
-                     | FStar_Syntax_Syntax.Sig_bundle (ses1, lids) ->
-                         let ses2 =
-                           FStar_Compiler_List.map add_class_attr ses1 in
-                         {
-                           FStar_Syntax_Syntax.sigel =
-                             (FStar_Syntax_Syntax.Sig_bundle (ses2, lids));
-                           FStar_Syntax_Syntax.sigrng =
-                             (se.FStar_Syntax_Syntax.sigrng);
-                           FStar_Syntax_Syntax.sigquals =
-                             (se.FStar_Syntax_Syntax.sigquals);
-                           FStar_Syntax_Syntax.sigmeta =
-                             (se.FStar_Syntax_Syntax.sigmeta);
-                           FStar_Syntax_Syntax.sigattrs =
-                             (se.FStar_Syntax_Syntax.sigattrs);
-                           FStar_Syntax_Syntax.sigopts =
-                             (se.FStar_Syntax_Syntax.sigopts)
-                         }
-                     | FStar_Syntax_Syntax.Sig_inductive_typ uu___2 ->
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Syntax_Syntax.fvar
-                               FStar_Parser_Const.tcclass_lid
-                               FStar_Syntax_Syntax.delta_constant
-                               FStar_Pervasives_Native.None in
-                           uu___4 :: (se.FStar_Syntax_Syntax.sigattrs) in
-                         {
-                           FStar_Syntax_Syntax.sigel =
-                             (se.FStar_Syntax_Syntax.sigel);
-                           FStar_Syntax_Syntax.sigrng =
-                             (se.FStar_Syntax_Syntax.sigrng);
-                           FStar_Syntax_Syntax.sigquals =
-                             (se.FStar_Syntax_Syntax.sigquals);
-                           FStar_Syntax_Syntax.sigmeta =
-                             (se.FStar_Syntax_Syntax.sigmeta);
-                           FStar_Syntax_Syntax.sigattrs = uu___3;
-                           FStar_Syntax_Syntax.sigopts =
-                             (se.FStar_Syntax_Syntax.sigopts)
-                         }
-                     | uu___2 -> se in
-                   let uu___2 = FStar_Compiler_List.map add_class_attr ses in
-                   let uu___3 =
-                     FStar_Compiler_List.concatMap (splice_decl meths) ses in
-                   (uu___2, uu___3)
-                 else (ses, []) in
-               (match uu___1 with
-                | (ses1, extra) ->
-                    let env2 =
-                      FStar_Compiler_List.fold_left
-                        FStar_Syntax_DsEnv.push_sigelt env1 extra in
-                    (env2, (FStar_Compiler_List.op_At ses1 extra))))
-      | FStar_Parser_AST.TopLevelLet (isrec, lets) ->
-          let quals = d.FStar_Parser_AST.quals in
-          let expand_toplevel_pattern =
-            (isrec = FStar_Parser_AST.NoLetQualifier) &&
-              (match lets with
-               | ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatOp uu___;
-                    FStar_Parser_AST.prange = uu___1;_},
-                  uu___2)::[] -> false
-               | ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatVar uu___;
-                    FStar_Parser_AST.prange = uu___1;_},
-                  uu___2)::[] -> false
-               | ({
-                    FStar_Parser_AST.pat = FStar_Parser_AST.PatAscribed
-                      ({ FStar_Parser_AST.pat = FStar_Parser_AST.PatOp uu___;
-                         FStar_Parser_AST.prange = uu___1;_},
-                       uu___2);
-                    FStar_Parser_AST.prange = uu___3;_},
-                  uu___4)::[] -> false
-               | ({
-                    FStar_Parser_AST.pat = FStar_Parser_AST.PatAscribed
-                      ({
-                         FStar_Parser_AST.pat = FStar_Parser_AST.PatVar uu___;
-                         FStar_Parser_AST.prange = uu___1;_},
-                       uu___2);
-                    FStar_Parser_AST.prange = uu___3;_},
-                  uu___4)::[] -> false
-               | (p, uu___)::[] ->
-                   let uu___1 = is_app_pattern p in Prims.op_Negation uu___1
-               | uu___ -> false) in
-          if Prims.op_Negation expand_toplevel_pattern
-          then
-            let lets1 =
-              FStar_Compiler_List.map
-                (fun x -> (FStar_Pervasives_Native.None, x)) lets in
-            let as_inner_let =
-              FStar_Parser_AST.mk_term
-                (FStar_Parser_AST.Let
-                   (isrec, lets1,
-                     (FStar_Parser_AST.mk_term
-                        (FStar_Parser_AST.Const FStar_Const.Const_unit)
-                        d.FStar_Parser_AST.drange FStar_Parser_AST.Expr)))
-                d.FStar_Parser_AST.drange FStar_Parser_AST.Expr in
-            let uu___ = desugar_term_maybe_top true env as_inner_let in
-            (match uu___ with
-             | (ds_lets, aq) ->
-                 (check_no_aq aq;
-                  (let uu___2 =
-                     let uu___3 =
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Syntax_Subst.compress ds_lets in
-                     uu___3.FStar_Syntax_Syntax.n in
-                   match uu___2 with
-                   | FStar_Syntax_Syntax.Tm_let (lbs, uu___3) ->
-                       let fvs =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           (FStar_Pervasives_Native.snd lbs)
-                           (FStar_Compiler_List.map
-                              (fun lb ->
-                                 FStar_Compiler_Util.right
-                                   lb.FStar_Syntax_Syntax.lbname)) in
-                       let uu___4 =
-                         FStar_Compiler_List.fold_right
-                           (fun fv ->
-                              fun uu___5 ->
-                                match uu___5 with
-                                | (qs, ats) ->
-                                    let uu___6 =
-                                      FStar_Syntax_DsEnv.lookup_letbinding_quals_and_attrs
-                                        env
-                                        (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                    (match uu___6 with
-                                     | (qs', ats') ->
-                                         ((FStar_Compiler_List.op_At qs' qs),
-                                           (FStar_Compiler_List.op_At ats'
-                                              ats)))) fvs ([], []) in
-                       (match uu___4 with
-                        | (val_quals, val_attrs) ->
-                            let quals1 =
-                              match quals with
-                              | uu___5::uu___6 ->
-                                  FStar_Compiler_List.map
-                                    (trans_qual1 FStar_Pervasives_Native.None)
-                                    quals
-                              | uu___5 -> val_quals in
-                            let quals2 =
-                              let uu___5 =
-                                FStar_Compiler_Effect.op_Bar_Greater lets1
-                                  (FStar_Compiler_Util.for_some
-                                     (fun uu___6 ->
-                                        match uu___6 with
-                                        | (uu___7, (uu___8, t)) ->
-                                            t.FStar_Parser_AST.level =
-                                              FStar_Parser_AST.Formula)) in
-                              if uu___5
-                              then FStar_Syntax_Syntax.Logic :: quals1
-                              else quals1 in
-                            let names =
-                              FStar_Compiler_Effect.op_Bar_Greater fvs
-                                (FStar_Compiler_List.map
-                                   (fun fv ->
-                                      (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)) in
-                            let attrs =
-                              FStar_Compiler_List.map (desugar_term env)
-                                d.FStar_Parser_AST.attrs in
-                            let s =
-                              {
-                                FStar_Syntax_Syntax.sigel =
-                                  (FStar_Syntax_Syntax.Sig_let (lbs, names));
-                                FStar_Syntax_Syntax.sigrng =
-                                  (d.FStar_Parser_AST.drange);
-                                FStar_Syntax_Syntax.sigquals = quals2;
-                                FStar_Syntax_Syntax.sigmeta =
-                                  FStar_Syntax_Syntax.default_sigmeta;
-                                FStar_Syntax_Syntax.sigattrs =
-                                  (FStar_Compiler_List.op_At val_attrs attrs);
-                                FStar_Syntax_Syntax.sigopts =
-                                  FStar_Pervasives_Native.None
-                              } in
-                            let env1 = FStar_Syntax_DsEnv.push_sigelt env s in
-                            (env1, [s]))
-                   | uu___3 ->
-                       failwith "Desugaring a let did not produce a let")))
-          else
-            (let uu___1 =
-               match lets with
-               | (pat, body)::[] -> (pat, body)
-               | uu___2 ->
-                   failwith
-                     "expand_toplevel_pattern should only allow single definition lets" in
-             match uu___1 with
-             | (pat, body) ->
-                 let fresh_toplevel_name =
-                   FStar_Ident.gen FStar_Compiler_Range.dummyRange in
-                 let fresh_pat =
-                   let var_pat =
-                     FStar_Parser_AST.mk_pattern
-                       (FStar_Parser_AST.PatVar
-                          (fresh_toplevel_name, FStar_Pervasives_Native.None,
-                            [])) FStar_Compiler_Range.dummyRange in
-                   match pat.FStar_Parser_AST.pat with
-                   | FStar_Parser_AST.PatAscribed (pat1, ty) ->
-                       {
-                         FStar_Parser_AST.pat =
-                           (FStar_Parser_AST.PatAscribed (var_pat, ty));
-                         FStar_Parser_AST.prange =
-                           (pat1.FStar_Parser_AST.prange)
-                       }
-                   | uu___2 -> var_pat in
-                 let main_let =
-                   let quals1 =
-                     if
-                       FStar_Compiler_List.mem FStar_Parser_AST.Private
-                         d.FStar_Parser_AST.quals
-                     then d.FStar_Parser_AST.quals
-                     else FStar_Parser_AST.Private ::
-                       (d.FStar_Parser_AST.quals) in
-                   desugar_decl env
-                     {
-                       FStar_Parser_AST.d =
-                         (FStar_Parser_AST.TopLevelLet
-                            (isrec, [(fresh_pat, body)]));
-                       FStar_Parser_AST.drange = (d.FStar_Parser_AST.drange);
-                       FStar_Parser_AST.quals = quals1;
-                       FStar_Parser_AST.attrs = (d.FStar_Parser_AST.attrs)
-                     } in
-                 let main =
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Ident.lid_of_ids [fresh_toplevel_name] in
-                     FStar_Parser_AST.Var uu___3 in
-                   FStar_Parser_AST.mk_term uu___2
-                     pat.FStar_Parser_AST.prange FStar_Parser_AST.Expr in
-                 let build_generic_projection uu___2 id_opt =
-                   match uu___2 with
-                   | (env1, ses) ->
-                       let uu___3 =
-                         match id_opt with
-                         | FStar_Pervasives_Native.Some id ->
-                             let lid = FStar_Ident.lid_of_ids [id] in
-                             let branch =
-                               let uu___4 = FStar_Ident.range_of_lid lid in
-                               FStar_Parser_AST.mk_term
-                                 (FStar_Parser_AST.Var lid) uu___4
-                                 FStar_Parser_AST.Expr in
-                             let bv_pat =
-                               let uu___4 = FStar_Ident.range_of_id id in
-                               FStar_Parser_AST.mk_pattern
-                                 (FStar_Parser_AST.PatVar
-                                    (id, FStar_Pervasives_Native.None, []))
-                                 uu___4 in
-                             (bv_pat, branch)
-                         | FStar_Pervasives_Native.None ->
-                             let id =
-                               FStar_Ident.gen
-                                 FStar_Compiler_Range.dummyRange in
-                             let branch =
-                               FStar_Parser_AST.mk_term
-                                 (FStar_Parser_AST.Const
-                                    FStar_Const.Const_unit)
-                                 FStar_Compiler_Range.dummyRange
-                                 FStar_Parser_AST.Expr in
-                             let bv_pat =
-                               let uu___4 = FStar_Ident.range_of_id id in
-                               FStar_Parser_AST.mk_pattern
-                                 (FStar_Parser_AST.PatVar
-                                    (id, FStar_Pervasives_Native.None, []))
-                                 uu___4 in
-                             let bv_pat1 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         FStar_Ident.range_of_id id in
-                                       unit_ty uu___8 in
-                                     (uu___7, FStar_Pervasives_Native.None) in
-                                   (bv_pat, uu___6) in
-                                 FStar_Parser_AST.PatAscribed uu___5 in
-                               let uu___5 = FStar_Ident.range_of_id id in
-                               FStar_Parser_AST.mk_pattern uu___4 uu___5 in
-                             (bv_pat1, branch) in
-                       (match uu___3 with
-                        | (bv_pat, branch) ->
-                            let body1 =
-                              FStar_Parser_AST.mk_term
-                                (FStar_Parser_AST.Match
-                                   (main, FStar_Pervasives_Native.None,
-                                     FStar_Pervasives_Native.None,
-                                     [(pat, FStar_Pervasives_Native.None,
-                                        branch)]))
-                                main.FStar_Parser_AST.range
-                                FStar_Parser_AST.Expr in
-                            let id_decl =
-                              FStar_Parser_AST.mk_decl
-                                (FStar_Parser_AST.TopLevelLet
-                                   (FStar_Parser_AST.NoLetQualifier,
-                                     [(bv_pat, body1)]))
-                                FStar_Compiler_Range.dummyRange [] in
-                            let id_decl1 =
-                              {
-                                FStar_Parser_AST.d =
-                                  (id_decl.FStar_Parser_AST.d);
-                                FStar_Parser_AST.drange =
-                                  (id_decl.FStar_Parser_AST.drange);
-                                FStar_Parser_AST.quals =
-                                  (d.FStar_Parser_AST.quals);
-                                FStar_Parser_AST.attrs =
-                                  (id_decl.FStar_Parser_AST.attrs)
-                              } in
-                            let uu___4 = desugar_decl env1 id_decl1 in
-                            (match uu___4 with
-                             | (env2, ses') ->
-                                 (env2, (FStar_Compiler_List.op_At ses ses')))) in
-                 let build_projection uu___2 id =
-                   match uu___2 with
-                   | (env1, ses) ->
-                       build_generic_projection (env1, ses)
-                         (FStar_Pervasives_Native.Some id) in
-                 let build_coverage_check uu___2 =
-                   match uu___2 with
-                   | (env1, ses) ->
-                       build_generic_projection (env1, ses)
-                         FStar_Pervasives_Native.None in
-                 let bvs =
-                   let uu___2 = gather_pattern_bound_vars pat in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___2
-                     FStar_Compiler_Util.set_elements in
-                 let uu___2 =
-                   (FStar_Compiler_List.isEmpty bvs) &&
-                     (let uu___3 = is_var_pattern pat in
-                      Prims.op_Negation uu___3) in
-                 if uu___2
-                 then build_coverage_check main_let
-                 else
-                   FStar_Compiler_List.fold_left build_projection main_let
-                     bvs)
-      | FStar_Parser_AST.Assume (id, t) ->
-          let f = desugar_formula env t in
-          let lid = FStar_Syntax_DsEnv.qualify env id in
-          (env,
-            [{
-               FStar_Syntax_Syntax.sigel =
-                 (FStar_Syntax_Syntax.Sig_assume (lid, [], f));
-               FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-               FStar_Syntax_Syntax.sigquals =
-                 [FStar_Syntax_Syntax.Assumption];
-               FStar_Syntax_Syntax.sigmeta =
-                 FStar_Syntax_Syntax.default_sigmeta;
-               FStar_Syntax_Syntax.sigattrs = [];
-               FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-             }])
-      | FStar_Parser_AST.Val (id, t) ->
-          let quals = d.FStar_Parser_AST.quals in
-          let t1 = let uu___ = close_fun env t in desugar_term env uu___ in
-          let quals1 =
-            let uu___ =
-              (FStar_Syntax_DsEnv.iface env) &&
-                (FStar_Syntax_DsEnv.admitted_iface env) in
-            if uu___ then FStar_Parser_AST.Assumption :: quals else quals in
-          let lid = FStar_Syntax_DsEnv.qualify env id in
-          let attrs =
-            FStar_Compiler_List.map (desugar_term env)
-              d.FStar_Parser_AST.attrs in
-          let se =
-            let uu___ =
-              FStar_Compiler_List.map
-                (trans_qual1 FStar_Pervasives_Native.None) quals1 in
-            {
-              FStar_Syntax_Syntax.sigel =
-                (FStar_Syntax_Syntax.Sig_declare_typ (lid, [], t1));
-              FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-              FStar_Syntax_Syntax.sigquals = uu___;
-              FStar_Syntax_Syntax.sigmeta =
-                FStar_Syntax_Syntax.default_sigmeta;
-              FStar_Syntax_Syntax.sigattrs = attrs;
-              FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-            } in
-          let env1 = FStar_Syntax_DsEnv.push_sigelt env se in (env1, [se])
-      | FStar_Parser_AST.Exception (id, t_opt) ->
-          let t =
-            match t_opt with
-            | FStar_Pervasives_Native.None ->
-                FStar_Syntax_DsEnv.fail_or env
-                  (FStar_Syntax_DsEnv.try_lookup_lid env)
-                  FStar_Parser_Const.exn_lid
-            | FStar_Pervasives_Native.Some term ->
-                let t1 = desugar_term env term in
-                let uu___ =
-                  let uu___1 = FStar_Syntax_Syntax.null_binder t1 in [uu___1] in
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Syntax_DsEnv.fail_or env
-                      (FStar_Syntax_DsEnv.try_lookup_lid env)
-                      FStar_Parser_Const.exn_lid in
-                  FStar_Compiler_Effect.op_Less_Bar
-                    FStar_Syntax_Syntax.mk_Total uu___2 in
-                FStar_Syntax_Util.arrow uu___ uu___1 in
-          let l = FStar_Syntax_DsEnv.qualify env id in
-          let qual = [FStar_Syntax_Syntax.ExceptionConstructor] in
-          let se =
-            {
-              FStar_Syntax_Syntax.sigel =
-                (FStar_Syntax_Syntax.Sig_datacon
-                   (l, [], t, FStar_Parser_Const.exn_lid, Prims.int_zero,
-                     [FStar_Parser_Const.exn_lid]));
-              FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-              FStar_Syntax_Syntax.sigquals = qual;
-              FStar_Syntax_Syntax.sigmeta =
-                FStar_Syntax_Syntax.default_sigmeta;
-              FStar_Syntax_Syntax.sigattrs = [];
-              FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-            } in
-          let se' =
-            {
-              FStar_Syntax_Syntax.sigel =
-                (FStar_Syntax_Syntax.Sig_bundle ([se], [l]));
-              FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-              FStar_Syntax_Syntax.sigquals = qual;
-              FStar_Syntax_Syntax.sigmeta =
-                FStar_Syntax_Syntax.default_sigmeta;
-              FStar_Syntax_Syntax.sigattrs = [];
-              FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-            } in
-          let env1 = FStar_Syntax_DsEnv.push_sigelt env se' in
-          let data_ops = mk_data_projector_names [] env1 se in
-          let discs = mk_data_discriminators [] env1 [l] in
-          let env2 =
-            FStar_Compiler_List.fold_left FStar_Syntax_DsEnv.push_sigelt env1
-              (FStar_Compiler_List.op_At discs data_ops) in
-          (env2, (FStar_Compiler_List.op_At (se' :: discs) data_ops))
-      | FStar_Parser_AST.NewEffect (FStar_Parser_AST.RedefineEffect
-          (eff_name, eff_binders, defn)) ->
-          let quals = d.FStar_Parser_AST.quals in
-          desugar_redefine_effect env d trans_qual1 quals eff_name
-            eff_binders defn
-      | FStar_Parser_AST.NewEffect (FStar_Parser_AST.DefineEffect
-          (eff_name, eff_binders, eff_typ, eff_decls)) ->
-          let quals = d.FStar_Parser_AST.quals in
-          let attrs = d.FStar_Parser_AST.attrs in
-          desugar_effect env d quals false eff_name eff_binders eff_typ
-            eff_decls attrs
-      | FStar_Parser_AST.LayeredEffect (FStar_Parser_AST.DefineEffect
-          (eff_name, eff_binders, eff_typ, eff_decls)) ->
-          let quals = d.FStar_Parser_AST.quals in
-          let attrs = d.FStar_Parser_AST.attrs in
-          desugar_effect env d quals true eff_name eff_binders eff_typ
-            eff_decls attrs
-      | FStar_Parser_AST.LayeredEffect (FStar_Parser_AST.RedefineEffect
-          uu___) ->
-          failwith
-            "Impossible: LayeredEffect (RedefineEffect _) (should not be parseable)"
-      | FStar_Parser_AST.SubEffect l ->
-          let src_ed =
-            lookup_effect_lid env l.FStar_Parser_AST.msource
-              d.FStar_Parser_AST.drange in
-          let dst_ed =
-            lookup_effect_lid env l.FStar_Parser_AST.mdest
-              d.FStar_Parser_AST.drange in
-          let uu___ =
-            let uu___1 =
-              (FStar_Syntax_Util.is_layered src_ed) ||
-                (FStar_Syntax_Util.is_layered dst_ed) in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then
-            let uu___1 =
-              match l.FStar_Parser_AST.lift_op with
-              | FStar_Parser_AST.NonReifiableLift t ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = desugar_term env t in ([], uu___4) in
-                    FStar_Pervasives_Native.Some uu___3 in
-                  (uu___2, FStar_Pervasives_Native.None)
-              | FStar_Parser_AST.ReifiableLift (wp, t) ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = desugar_term env wp in ([], uu___4) in
-                    FStar_Pervasives_Native.Some uu___3 in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = desugar_term env t in ([], uu___5) in
-                    FStar_Pervasives_Native.Some uu___4 in
-                  (uu___2, uu___3)
-              | FStar_Parser_AST.LiftForFree t ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = desugar_term env t in ([], uu___4) in
-                    FStar_Pervasives_Native.Some uu___3 in
-                  (FStar_Pervasives_Native.None, uu___2) in
-            (match uu___1 with
-             | (lift_wp, lift) ->
-                 let se =
-                   {
-                     FStar_Syntax_Syntax.sigel =
-                       (FStar_Syntax_Syntax.Sig_sub_effect
-                          {
-                            FStar_Syntax_Syntax.source =
-                              (src_ed.FStar_Syntax_Syntax.mname);
-                            FStar_Syntax_Syntax.target =
-                              (dst_ed.FStar_Syntax_Syntax.mname);
-                            FStar_Syntax_Syntax.lift_wp = lift_wp;
-                            FStar_Syntax_Syntax.lift = lift;
-                            FStar_Syntax_Syntax.kind =
-                              FStar_Pervasives_Native.None
-                          });
-                     FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-                     FStar_Syntax_Syntax.sigquals = [];
-                     FStar_Syntax_Syntax.sigmeta =
-                       FStar_Syntax_Syntax.default_sigmeta;
-                     FStar_Syntax_Syntax.sigattrs = [];
-                     FStar_Syntax_Syntax.sigopts =
-                       FStar_Pervasives_Native.None
-                   } in
-                 (env, [se]))
-          else
-            (match l.FStar_Parser_AST.lift_op with
-             | FStar_Parser_AST.NonReifiableLift t ->
-                 let sub_eff =
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = desugar_term env t in ([], uu___4) in
-                     FStar_Pervasives_Native.Some uu___3 in
-                   {
-                     FStar_Syntax_Syntax.source =
-                       (src_ed.FStar_Syntax_Syntax.mname);
-                     FStar_Syntax_Syntax.target =
-                       (dst_ed.FStar_Syntax_Syntax.mname);
-                     FStar_Syntax_Syntax.lift_wp =
-                       FStar_Pervasives_Native.None;
-                     FStar_Syntax_Syntax.lift = uu___2;
-                     FStar_Syntax_Syntax.kind = FStar_Pervasives_Native.None
-                   } in
-                 (env,
-                   [{
-                      FStar_Syntax_Syntax.sigel =
-                        (FStar_Syntax_Syntax.Sig_sub_effect sub_eff);
-                      FStar_Syntax_Syntax.sigrng =
-                        (d.FStar_Parser_AST.drange);
-                      FStar_Syntax_Syntax.sigquals = [];
-                      FStar_Syntax_Syntax.sigmeta =
-                        FStar_Syntax_Syntax.default_sigmeta;
-                      FStar_Syntax_Syntax.sigattrs = [];
-                      FStar_Syntax_Syntax.sigopts =
-                        FStar_Pervasives_Native.None
-                    }])
-             | uu___2 ->
-                 failwith
-                   "Impossible! unexpected lift_op for lift to a layered effect")
-      | FStar_Parser_AST.Polymonadic_bind (m_eff, n_eff, p_eff, bind) ->
-          let m = lookup_effect_lid env m_eff d.FStar_Parser_AST.drange in
-          let n = lookup_effect_lid env n_eff d.FStar_Parser_AST.drange in
-          let p = lookup_effect_lid env p_eff d.FStar_Parser_AST.drange in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = desugar_term env bind in ([], uu___5) in
-                  ((m.FStar_Syntax_Syntax.mname),
-                    (n.FStar_Syntax_Syntax.mname),
-                    (p.FStar_Syntax_Syntax.mname), uu___4,
-                    ([], FStar_Syntax_Syntax.tun),
-                    FStar_Pervasives_Native.None) in
-                FStar_Syntax_Syntax.Sig_polymonadic_bind uu___3 in
-              {
-                FStar_Syntax_Syntax.sigel = uu___2;
-                FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-                FStar_Syntax_Syntax.sigquals = [];
-                FStar_Syntax_Syntax.sigmeta =
-                  FStar_Syntax_Syntax.default_sigmeta;
-                FStar_Syntax_Syntax.sigattrs = [];
-                FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-              } in
-            [uu___1] in
-          (env, uu___)
-      | FStar_Parser_AST.Polymonadic_subcomp (m_eff, n_eff, subcomp) ->
-          let m = lookup_effect_lid env m_eff d.FStar_Parser_AST.drange in
-          let n = lookup_effect_lid env n_eff d.FStar_Parser_AST.drange in
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = desugar_term env subcomp in ([], uu___5) in
-                  ((m.FStar_Syntax_Syntax.mname),
-                    (n.FStar_Syntax_Syntax.mname), uu___4,
-                    ([], FStar_Syntax_Syntax.tun),
-                    FStar_Pervasives_Native.None) in
-                FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___3 in
-              {
-                FStar_Syntax_Syntax.sigel = uu___2;
-                FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-                FStar_Syntax_Syntax.sigquals = [];
-                FStar_Syntax_Syntax.sigmeta =
-                  FStar_Syntax_Syntax.default_sigmeta;
-                FStar_Syntax_Syntax.sigattrs = [];
-                FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-              } in
-            [uu___1] in
-          (env, uu___)
-      | FStar_Parser_AST.Splice (ids, t) ->
-          let t1 = desugar_term env t in
-          let se =
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_List.map (FStar_Syntax_DsEnv.qualify env)
-                    ids in
-                (uu___2, t1) in
-              FStar_Syntax_Syntax.Sig_splice uu___1 in
-            {
-              FStar_Syntax_Syntax.sigel = uu___;
-              FStar_Syntax_Syntax.sigrng = (d.FStar_Parser_AST.drange);
-              FStar_Syntax_Syntax.sigquals = [];
-              FStar_Syntax_Syntax.sigmeta =
-                FStar_Syntax_Syntax.default_sigmeta;
-              FStar_Syntax_Syntax.sigattrs = [];
-              FStar_Syntax_Syntax.sigopts = FStar_Pervasives_Native.None
-            } in
-          let env1 = FStar_Syntax_DsEnv.push_sigelt env se in (env1, [se])
-let (desugar_decls :
-  env_t ->
-    FStar_Parser_AST.decl Prims.list ->
-      (env_t * FStar_Syntax_Syntax.sigelt Prims.list))
-  =
-  fun env ->
-    fun decls ->
-      let uu___ =
-        FStar_Compiler_List.fold_left
-          (fun uu___1 ->
-             fun d ->
-               match uu___1 with
-               | (env1, sigelts) ->
-                   let uu___2 = desugar_decl env1 d in
-                   (match uu___2 with
-                    | (env2, se) ->
-                        (env2, (FStar_Compiler_List.op_At sigelts se))))
-          (env, []) decls in
-      match uu___ with | (env1, sigelts) -> (env1, sigelts)
-let (open_prims_all :
-  (FStar_Parser_AST.decoration Prims.list -> FStar_Parser_AST.decl)
-    Prims.list)
-  =
-  [FStar_Parser_AST.mk_decl
-     (FStar_Parser_AST.Open FStar_Parser_Const.prims_lid)
-     FStar_Compiler_Range.dummyRange;
-  FStar_Parser_AST.mk_decl (FStar_Parser_AST.Open FStar_Parser_Const.all_lid)
-    FStar_Compiler_Range.dummyRange]
-let (desugar_modul_common :
-  FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option ->
-    FStar_Syntax_DsEnv.env ->
-      FStar_Parser_AST.modul ->
-        (env_t * FStar_Syntax_Syntax.modul * Prims.bool))
-  =
-  fun curmod ->
-    fun env ->
-      fun m ->
-        let env1 =
-          match (curmod, m) with
-          | (FStar_Pervasives_Native.None, uu___) -> env
-          | (FStar_Pervasives_Native.Some
-             { FStar_Syntax_Syntax.name = prev_lid;
-               FStar_Syntax_Syntax.declarations = uu___;
-               FStar_Syntax_Syntax.is_interface = uu___1;_},
-             FStar_Parser_AST.Module (current_lid, uu___2)) when
-              (FStar_Ident.lid_equals prev_lid current_lid) &&
-                (FStar_Options.interactive ())
-              -> env
-          | (FStar_Pervasives_Native.Some prev_mod, uu___) ->
-              let uu___1 =
-                FStar_Syntax_DsEnv.finish_module_or_interface env prev_mod in
-              FStar_Pervasives_Native.fst uu___1 in
-        let uu___ =
-          match m with
-          | FStar_Parser_AST.Interface (mname, decls, admitted) ->
-              let uu___1 =
-                FStar_Syntax_DsEnv.prepare_module_or_interface true admitted
-                  env1 mname FStar_Syntax_DsEnv.default_mii in
-              (uu___1, mname, decls, true)
-          | FStar_Parser_AST.Module (mname, decls) ->
-              let uu___1 =
-                FStar_Syntax_DsEnv.prepare_module_or_interface false false
-                  env1 mname FStar_Syntax_DsEnv.default_mii in
-              (uu___1, mname, decls, false) in
-        match uu___ with
-        | ((env2, pop_when_done), mname, decls, intf) ->
-            let uu___1 = desugar_decls env2 decls in
-            (match uu___1 with
-             | (env3, sigelts) ->
-                 let modul =
-                   {
-                     FStar_Syntax_Syntax.name = mname;
-                     FStar_Syntax_Syntax.declarations = sigelts;
-                     FStar_Syntax_Syntax.is_interface = intf
-                   } in
-                 (env3, modul, pop_when_done))
-let (as_interface : FStar_Parser_AST.modul -> FStar_Parser_AST.modul) =
-  fun m ->
-    match m with
-    | FStar_Parser_AST.Module (mname, decls) ->
-        FStar_Parser_AST.Interface (mname, decls, true)
-    | i -> i
-let (desugar_partial_modul :
-  FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option ->
-    env_t -> FStar_Parser_AST.modul -> (env_t * FStar_Syntax_Syntax.modul))
-  =
-  fun curmod ->
-    fun env ->
-      fun m ->
-        let m1 =
-          let uu___ =
-            (FStar_Options.interactive ()) &&
-              (let uu___1 =
-                 let uu___2 =
-                   let uu___3 = FStar_Options.file_list () in
-                   FStar_Compiler_List.hd uu___3 in
-                 FStar_Compiler_Util.get_file_extension uu___2 in
-               FStar_Compiler_List.mem uu___1 ["fsti"; "fsi"]) in
-          if uu___ then as_interface m else m in
-        let uu___ = desugar_modul_common curmod env m1 in
-        match uu___ with
-        | (env1, modul, pop_when_done) ->
-            if pop_when_done
-            then let uu___1 = FStar_Syntax_DsEnv.pop () in (uu___1, modul)
-            else (env1, modul)
-let (desugar_modul :
-  FStar_Syntax_DsEnv.env ->
-    FStar_Parser_AST.modul -> (env_t * FStar_Syntax_Syntax.modul))
-  =
-  fun env ->
-    fun m ->
-      let uu___ = desugar_modul_common FStar_Pervasives_Native.None env m in
-      match uu___ with
-      | (env1, modul, pop_when_done) ->
-          let uu___1 =
-            FStar_Syntax_DsEnv.finish_module_or_interface env1 modul in
-          (match uu___1 with
-           | (env2, modul1) ->
-               ((let uu___3 =
-                   let uu___4 =
-                     FStar_Ident.string_of_lid
-                       modul1.FStar_Syntax_Syntax.name in
-                   FStar_Options.dump_module uu___4 in
-                 if uu___3
-                 then
-                   let uu___4 = FStar_Syntax_Print.modul_to_string modul1 in
-                   FStar_Compiler_Util.print1
-                     "Module after desugaring:\n%s\n" uu___4
-                 else ());
-                (let uu___3 =
-                   if pop_when_done
-                   then
-                     FStar_Syntax_DsEnv.export_interface
-                       modul1.FStar_Syntax_Syntax.name env2
-                   else env2 in
-                 (uu___3, modul1))))
-let with_options : 'a . (unit -> 'a) -> 'a =
-  fun f ->
-    FStar_Options.push ();
-    (let res = f () in
-     let light = FStar_Options.ml_ish () in
-     FStar_Options.pop ();
-     if light then FStar_Options.set_ml_ish () else ();
-     res)
-let (ast_modul_to_modul :
-  FStar_Parser_AST.modul ->
-    FStar_Syntax_Syntax.modul FStar_Syntax_DsEnv.withenv)
-  =
-  fun modul ->
-    fun env ->
-      with_options
-        (fun uu___ ->
-           let uu___1 = desugar_modul env modul in
-           match uu___1 with | (e, m) -> (m, e))
-let (decls_to_sigelts :
-  FStar_Parser_AST.decl Prims.list ->
-    FStar_Syntax_Syntax.sigelts FStar_Syntax_DsEnv.withenv)
-  =
-  fun decls ->
-    fun env ->
-      with_options
-        (fun uu___ ->
-           let uu___1 = desugar_decls env decls in
-           match uu___1 with | (env1, sigelts) -> (sigelts, env1))
-let (partial_ast_modul_to_modul :
-  FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option ->
-    FStar_Parser_AST.modul ->
-      FStar_Syntax_Syntax.modul FStar_Syntax_DsEnv.withenv)
-  =
-  fun modul ->
-    fun a_modul ->
-      fun env ->
-        with_options
-          (fun uu___ ->
-             let uu___1 = desugar_partial_modul modul env a_modul in
-             match uu___1 with | (env1, modul1) -> (modul1, env1))
-let (add_modul_to_env :
-  FStar_Syntax_Syntax.modul ->
-    FStar_Syntax_DsEnv.module_inclusion_info ->
-      (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) ->
-        unit FStar_Syntax_DsEnv.withenv)
-  =
-  fun m ->
-    fun mii ->
-      fun erase_univs ->
-        fun en ->
-          let erase_univs_ed ed =
-            let erase_binders bs =
-              match bs with
-              | [] -> []
-              | uu___ ->
-                  let t =
-                    let uu___1 =
-                      FStar_Syntax_Syntax.mk
-                        (FStar_Syntax_Syntax.Tm_abs
-                           (bs, FStar_Syntax_Syntax.t_unit,
-                             FStar_Pervasives_Native.None))
-                        FStar_Compiler_Range.dummyRange in
-                    erase_univs uu___1 in
-                  let uu___1 =
-                    let uu___2 = FStar_Syntax_Subst.compress t in
-                    uu___2.FStar_Syntax_Syntax.n in
-                  (match uu___1 with
-                   | FStar_Syntax_Syntax.Tm_abs (bs1, uu___2, uu___3) -> bs1
-                   | uu___2 -> failwith "Impossible") in
-            let uu___ =
-              let uu___1 = erase_binders ed.FStar_Syntax_Syntax.binders in
-              FStar_Syntax_Subst.open_term' uu___1 FStar_Syntax_Syntax.t_unit in
-            match uu___ with
-            | (binders, uu___1, binders_opening) ->
-                let erase_term t =
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Subst.subst binders_opening t in
-                    erase_univs uu___3 in
-                  FStar_Syntax_Subst.close binders uu___2 in
-                let erase_tscheme uu___2 =
-                  match uu___2 with
-                  | (us, t) ->
-                      let t1 =
-                        let uu___3 =
-                          FStar_Syntax_Subst.shift_subst
-                            (FStar_Compiler_List.length us) binders_opening in
-                        FStar_Syntax_Subst.subst uu___3 t in
-                      let uu___3 =
-                        let uu___4 = erase_univs t1 in
-                        FStar_Syntax_Subst.close binders uu___4 in
-                      ([], uu___3) in
-                let erase_action action =
-                  let opening =
-                    FStar_Syntax_Subst.shift_subst
-                      (FStar_Compiler_List.length
-                         action.FStar_Syntax_Syntax.action_univs)
-                      binders_opening in
-                  let erased_action_params =
-                    match action.FStar_Syntax_Syntax.action_params with
-                    | [] -> []
-                    | uu___2 ->
-                        let bs =
-                          let uu___3 =
-                            FStar_Syntax_Subst.subst_binders opening
-                              action.FStar_Syntax_Syntax.action_params in
-                          FStar_Compiler_Effect.op_Less_Bar erase_binders
-                            uu___3 in
-                        let t =
-                          FStar_Syntax_Syntax.mk
-                            (FStar_Syntax_Syntax.Tm_abs
-                               (bs, FStar_Syntax_Syntax.t_unit,
-                                 FStar_Pervasives_Native.None))
-                            FStar_Compiler_Range.dummyRange in
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 = FStar_Syntax_Subst.close binders t in
-                            FStar_Syntax_Subst.compress uu___5 in
-                          uu___4.FStar_Syntax_Syntax.n in
-                        (match uu___3 with
-                         | FStar_Syntax_Syntax.Tm_abs (bs1, uu___4, uu___5)
-                             -> bs1
-                         | uu___4 -> failwith "Impossible") in
-                  let erase_term1 t =
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Subst.subst opening t in
-                      erase_univs uu___3 in
-                    FStar_Syntax_Subst.close binders uu___2 in
-                  let uu___2 =
-                    erase_term1 action.FStar_Syntax_Syntax.action_defn in
-                  let uu___3 =
-                    erase_term1 action.FStar_Syntax_Syntax.action_typ in
-                  {
-                    FStar_Syntax_Syntax.action_name =
-                      (action.FStar_Syntax_Syntax.action_name);
-                    FStar_Syntax_Syntax.action_unqualified_name =
-                      (action.FStar_Syntax_Syntax.action_unqualified_name);
-                    FStar_Syntax_Syntax.action_univs = [];
-                    FStar_Syntax_Syntax.action_params = erased_action_params;
-                    FStar_Syntax_Syntax.action_defn = uu___2;
-                    FStar_Syntax_Syntax.action_typ = uu___3
-                  } in
-                let uu___2 = FStar_Syntax_Subst.close_binders binders in
-                let uu___3 =
-                  FStar_Syntax_Util.apply_eff_sig erase_tscheme
-                    ed.FStar_Syntax_Syntax.signature in
-                let uu___4 =
-                  FStar_Syntax_Util.apply_eff_combinators erase_tscheme
-                    ed.FStar_Syntax_Syntax.combinators in
-                let uu___5 =
-                  FStar_Compiler_List.map erase_action
-                    ed.FStar_Syntax_Syntax.actions in
-                {
-                  FStar_Syntax_Syntax.mname = (ed.FStar_Syntax_Syntax.mname);
-                  FStar_Syntax_Syntax.cattributes =
-                    (ed.FStar_Syntax_Syntax.cattributes);
-                  FStar_Syntax_Syntax.univs = [];
-                  FStar_Syntax_Syntax.binders = uu___2;
-                  FStar_Syntax_Syntax.signature = uu___3;
-                  FStar_Syntax_Syntax.combinators = uu___4;
-                  FStar_Syntax_Syntax.actions = uu___5;
-                  FStar_Syntax_Syntax.eff_attrs =
-                    (ed.FStar_Syntax_Syntax.eff_attrs)
-                } in
-          let push_sigelt env se =
-            match se.FStar_Syntax_Syntax.sigel with
-            | FStar_Syntax_Syntax.Sig_new_effect ed ->
-                let se' =
-                  let uu___ =
-                    let uu___1 = erase_univs_ed ed in
-                    FStar_Syntax_Syntax.Sig_new_effect uu___1 in
-                  {
-                    FStar_Syntax_Syntax.sigel = uu___;
-                    FStar_Syntax_Syntax.sigrng =
-                      (se.FStar_Syntax_Syntax.sigrng);
-                    FStar_Syntax_Syntax.sigquals =
-                      (se.FStar_Syntax_Syntax.sigquals);
-                    FStar_Syntax_Syntax.sigmeta =
-                      (se.FStar_Syntax_Syntax.sigmeta);
-                    FStar_Syntax_Syntax.sigattrs =
-                      (se.FStar_Syntax_Syntax.sigattrs);
-                    FStar_Syntax_Syntax.sigopts =
-                      (se.FStar_Syntax_Syntax.sigopts)
-                  } in
-                let env1 = FStar_Syntax_DsEnv.push_sigelt env se' in
-                push_reflect_effect env1 se.FStar_Syntax_Syntax.sigquals
-                  ed.FStar_Syntax_Syntax.mname se.FStar_Syntax_Syntax.sigrng
-            | uu___ -> FStar_Syntax_DsEnv.push_sigelt env se in
-          let uu___ =
-            FStar_Syntax_DsEnv.prepare_module_or_interface false false en
-              m.FStar_Syntax_Syntax.name mii in
-          match uu___ with
-          | (en1, pop_when_done) ->
-              let en2 =
-                let uu___1 =
-                  FStar_Syntax_DsEnv.set_current_module en1
-                    m.FStar_Syntax_Syntax.name in
-                FStar_Compiler_List.fold_left push_sigelt uu___1
-                  m.FStar_Syntax_Syntax.declarations in
-              let env = FStar_Syntax_DsEnv.finish en2 m in
-              let uu___1 =
-                if pop_when_done
-                then
-                  FStar_Syntax_DsEnv.export_interface
-                    m.FStar_Syntax_Syntax.name env
-                else env in
-              ((), uu___1)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Cfg.ml b/src/ocaml-output/FStar_TypeChecker_Cfg.ml
deleted file mode 100644
index 57e98e315d3..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Cfg.ml
+++ /dev/null
@@ -1,4244 +0,0 @@
-open Prims
-type fsteps =
-  {
-  beta: Prims.bool ;
-  iota: Prims.bool ;
-  zeta: Prims.bool ;
-  zeta_full: Prims.bool ;
-  weak: Prims.bool ;
-  hnf: Prims.bool ;
-  primops: Prims.bool ;
-  do_not_unfold_pure_lets: Prims.bool ;
-  unfold_until:
-    FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option ;
-  unfold_only: FStar_Ident.lid Prims.list FStar_Pervasives_Native.option ;
-  unfold_fully: FStar_Ident.lid Prims.list FStar_Pervasives_Native.option ;
-  unfold_attr: FStar_Ident.lid Prims.list FStar_Pervasives_Native.option ;
-  unfold_qual: Prims.string Prims.list FStar_Pervasives_Native.option ;
-  unfold_namespace: Prims.string Prims.list FStar_Pervasives_Native.option ;
-  unfold_tac: Prims.bool ;
-  pure_subterms_within_computations: Prims.bool ;
-  simplify: Prims.bool ;
-  erase_universes: Prims.bool ;
-  allow_unbound_universes: Prims.bool ;
-  reify_: Prims.bool ;
-  compress_uvars: Prims.bool ;
-  no_full_norm: Prims.bool ;
-  check_no_uvars: Prims.bool ;
-  unmeta: Prims.bool ;
-  unascribe: Prims.bool ;
-  in_full_norm_request: Prims.bool ;
-  weakly_reduce_scrutinee: Prims.bool ;
-  nbe_step: Prims.bool ;
-  for_extraction: Prims.bool ;
-  unrefine: Prims.bool }
-let (__proj__Mkfsteps__item__beta : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        beta
-let (__proj__Mkfsteps__item__iota : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        iota
-let (__proj__Mkfsteps__item__zeta : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        zeta
-let (__proj__Mkfsteps__item__zeta_full : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        zeta_full
-let (__proj__Mkfsteps__item__weak : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        weak
-let (__proj__Mkfsteps__item__hnf : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} -> hnf
-let (__proj__Mkfsteps__item__primops : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        primops
-let (__proj__Mkfsteps__item__do_not_unfold_pure_lets : fsteps -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        do_not_unfold_pure_lets
-let (__proj__Mkfsteps__item__unfold_until :
-  fsteps -> FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_until
-let (__proj__Mkfsteps__item__unfold_only :
-  fsteps -> FStar_Ident.lid Prims.list FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_only
-let (__proj__Mkfsteps__item__unfold_fully :
-  fsteps -> FStar_Ident.lid Prims.list FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_fully
-let (__proj__Mkfsteps__item__unfold_attr :
-  fsteps -> FStar_Ident.lid Prims.list FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_attr
-let (__proj__Mkfsteps__item__unfold_qual :
-  fsteps -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_qual
-let (__proj__Mkfsteps__item__unfold_namespace :
-  fsteps -> Prims.string Prims.list FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_namespace
-let (__proj__Mkfsteps__item__unfold_tac : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unfold_tac
-let (__proj__Mkfsteps__item__pure_subterms_within_computations :
-  fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        pure_subterms_within_computations
-let (__proj__Mkfsteps__item__simplify : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        simplify
-let (__proj__Mkfsteps__item__erase_universes : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        erase_universes
-let (__proj__Mkfsteps__item__allow_unbound_universes : fsteps -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        allow_unbound_universes
-let (__proj__Mkfsteps__item__reify_ : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        reify_
-let (__proj__Mkfsteps__item__compress_uvars : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        compress_uvars
-let (__proj__Mkfsteps__item__no_full_norm : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        no_full_norm
-let (__proj__Mkfsteps__item__check_no_uvars : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        check_no_uvars
-let (__proj__Mkfsteps__item__unmeta : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unmeta
-let (__proj__Mkfsteps__item__unascribe : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unascribe
-let (__proj__Mkfsteps__item__in_full_norm_request : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        in_full_norm_request
-let (__proj__Mkfsteps__item__weakly_reduce_scrutinee : fsteps -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        weakly_reduce_scrutinee
-let (__proj__Mkfsteps__item__nbe_step : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        nbe_step
-let (__proj__Mkfsteps__item__for_extraction : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        for_extraction
-let (__proj__Mkfsteps__item__unrefine : fsteps -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { beta; iota; zeta; zeta_full; weak; hnf; primops;
-        do_not_unfold_pure_lets; unfold_until; unfold_only; unfold_fully;
-        unfold_attr; unfold_qual; unfold_namespace; unfold_tac;
-        pure_subterms_within_computations; simplify; erase_universes;
-        allow_unbound_universes; reify_; compress_uvars; no_full_norm;
-        check_no_uvars; unmeta; unascribe; in_full_norm_request;
-        weakly_reduce_scrutinee; nbe_step; for_extraction; unrefine;_} ->
-        unrefine
-let (steps_to_string : fsteps -> Prims.string) =
-  fun f ->
-    let format_opt f1 o =
-      match o with
-      | FStar_Pervasives_Native.None -> "None"
-      | FStar_Pervasives_Native.Some x ->
-          let uu___ = let uu___1 = f1 x in FStar_String.op_Hat uu___1 ")" in
-          FStar_String.op_Hat "Some (" uu___ in
-    let b = FStar_Compiler_Util.string_of_bool in
-    let uu___ =
-      let uu___1 = FStar_Compiler_Effect.op_Bar_Greater f.beta b in
-      let uu___2 =
-        let uu___3 = FStar_Compiler_Effect.op_Bar_Greater f.iota b in
-        let uu___4 =
-          let uu___5 = FStar_Compiler_Effect.op_Bar_Greater f.zeta b in
-          let uu___6 =
-            let uu___7 = FStar_Compiler_Effect.op_Bar_Greater f.zeta_full b in
-            let uu___8 =
-              let uu___9 = FStar_Compiler_Effect.op_Bar_Greater f.weak b in
-              let uu___10 =
-                let uu___11 = FStar_Compiler_Effect.op_Bar_Greater f.hnf b in
-                let uu___12 =
-                  let uu___13 =
-                    FStar_Compiler_Effect.op_Bar_Greater f.primops b in
-                  let uu___14 =
-                    let uu___15 =
-                      FStar_Compiler_Effect.op_Bar_Greater
-                        f.do_not_unfold_pure_lets b in
-                    let uu___16 =
-                      let uu___17 =
-                        FStar_Compiler_Effect.op_Bar_Greater f.unfold_until
-                          (format_opt
-                             FStar_Syntax_Print.delta_depth_to_string) in
-                      let uu___18 =
-                        let uu___19 =
-                          FStar_Compiler_Effect.op_Bar_Greater f.unfold_only
-                            (format_opt
-                               (fun x ->
-                                  let uu___20 =
-                                    FStar_Compiler_List.map
-                                      FStar_Ident.string_of_lid x in
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    uu___20 (FStar_String.concat ", "))) in
-                        let uu___20 =
-                          let uu___21 =
-                            FStar_Compiler_Effect.op_Bar_Greater
-                              f.unfold_fully
-                              (format_opt
-                                 (fun x ->
-                                    let uu___22 =
-                                      FStar_Compiler_List.map
-                                        FStar_Ident.string_of_lid x in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___22 (FStar_String.concat ", "))) in
-                          let uu___22 =
-                            let uu___23 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                f.unfold_attr
-                                (format_opt
-                                   (fun x ->
-                                      let uu___24 =
-                                        FStar_Compiler_List.map
-                                          FStar_Ident.string_of_lid x in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___24 (FStar_String.concat ", "))) in
-                            let uu___24 =
-                              let uu___25 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  f.unfold_qual
-                                  (format_opt (FStar_String.concat ", ")) in
-                              let uu___26 =
-                                let uu___27 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    f.unfold_namespace
-                                    (format_opt (FStar_String.concat ", ")) in
-                                let uu___28 =
-                                  let uu___29 =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      f.unfold_tac b in
-                                  let uu___30 =
-                                    let uu___31 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        f.pure_subterms_within_computations b in
-                                    let uu___32 =
-                                      let uu___33 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          f.simplify b in
-                                      let uu___34 =
-                                        let uu___35 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            f.erase_universes b in
-                                        let uu___36 =
-                                          let uu___37 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              f.allow_unbound_universes b in
-                                          let uu___38 =
-                                            let uu___39 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                f.reify_ b in
-                                            let uu___40 =
-                                              let uu___41 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  f.compress_uvars b in
-                                              let uu___42 =
-                                                let uu___43 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    f.no_full_norm b in
-                                                let uu___44 =
-                                                  let uu___45 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      f.check_no_uvars b in
-                                                  let uu___46 =
-                                                    let uu___47 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        f.unmeta b in
-                                                    let uu___48 =
-                                                      let uu___49 =
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          f.unascribe b in
-                                                      let uu___50 =
-                                                        let uu___51 =
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            f.in_full_norm_request
-                                                            b in
-                                                        let uu___52 =
-                                                          let uu___53 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              f.weakly_reduce_scrutinee
-                                                              b in
-                                                          let uu___54 =
-                                                            let uu___55 =
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                f.for_extraction
-                                                                b in
-                                                            let uu___56 =
-                                                              let uu___57 =
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  f.unrefine
-                                                                  b in
-                                                              [uu___57] in
-                                                            uu___55 ::
-                                                              uu___56 in
-                                                          uu___53 :: uu___54 in
-                                                        uu___51 :: uu___52 in
-                                                      uu___49 :: uu___50 in
-                                                    uu___47 :: uu___48 in
-                                                  uu___45 :: uu___46 in
-                                                uu___43 :: uu___44 in
-                                              uu___41 :: uu___42 in
-                                            uu___39 :: uu___40 in
-                                          uu___37 :: uu___38 in
-                                        uu___35 :: uu___36 in
-                                      uu___33 :: uu___34 in
-                                    uu___31 :: uu___32 in
-                                  uu___29 :: uu___30 in
-                                uu___27 :: uu___28 in
-                              uu___25 :: uu___26 in
-                            uu___23 :: uu___24 in
-                          uu___21 :: uu___22 in
-                        uu___19 :: uu___20 in
-                      uu___17 :: uu___18 in
-                    uu___15 :: uu___16 in
-                  uu___13 :: uu___14 in
-                uu___11 :: uu___12 in
-              uu___9 :: uu___10 in
-            uu___7 :: uu___8 in
-          uu___5 :: uu___6 in
-        uu___3 :: uu___4 in
-      uu___1 :: uu___2 in
-    FStar_Compiler_Util.format
-      "{\nbeta = %s;\niota = %s;\nzeta = %s;\nzeta_full = %s;\nweak = %s;\nhnf  = %s;\nprimops = %s;\ndo_not_unfold_pure_lets = %s;\nunfold_until = %s;\nunfold_only = %s;\nunfold_fully = %s;\nunfold_attr = %s;\nunfold_qual = %s;\nunfold_namespace = %s;\n\\    \n    unfold_tac = %s;\npure_subterms_within_computations = %s;\nsimplify = %s;\nerase_universes = %s;\nallow_unbound_universes = %s;\nreify_ = %s;\ncompress_uvars = %s;\nno_full_norm = %s;\ncheck_no_uvars = %s;\nunmeta = %s;\nunascribe = %s;\nin_full_norm_request = %s;\nweakly_reduce_scrutinee = %s;\nfor_extraction = %s;\nunrefine = %s;\n}"
-      uu___
-let (default_steps : fsteps) =
-  {
-    beta = true;
-    iota = true;
-    zeta = true;
-    zeta_full = false;
-    weak = false;
-    hnf = false;
-    primops = false;
-    do_not_unfold_pure_lets = false;
-    unfold_until = FStar_Pervasives_Native.None;
-    unfold_only = FStar_Pervasives_Native.None;
-    unfold_fully = FStar_Pervasives_Native.None;
-    unfold_attr = FStar_Pervasives_Native.None;
-    unfold_qual = FStar_Pervasives_Native.None;
-    unfold_namespace = FStar_Pervasives_Native.None;
-    unfold_tac = false;
-    pure_subterms_within_computations = false;
-    simplify = false;
-    erase_universes = false;
-    allow_unbound_universes = false;
-    reify_ = false;
-    compress_uvars = false;
-    no_full_norm = false;
-    check_no_uvars = false;
-    unmeta = false;
-    unascribe = false;
-    in_full_norm_request = false;
-    weakly_reduce_scrutinee = true;
-    nbe_step = false;
-    for_extraction = false;
-    unrefine = false
-  }
-let (fstep_add_one : FStar_TypeChecker_Env.step -> fsteps -> fsteps) =
-  fun s ->
-    fun fs ->
-      match s with
-      | FStar_TypeChecker_Env.Beta ->
-          {
-            beta = true;
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Iota ->
-          {
-            beta = (fs.beta);
-            iota = true;
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Zeta ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = true;
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.ZetaFull ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = true;
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Exclude (FStar_TypeChecker_Env.Beta) ->
-          {
-            beta = false;
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Exclude (FStar_TypeChecker_Env.Iota) ->
-          {
-            beta = (fs.beta);
-            iota = false;
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Exclude (FStar_TypeChecker_Env.Zeta) ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = false;
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Exclude uu___ -> failwith "Bad exclude"
-      | FStar_TypeChecker_Env.Weak ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = true;
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.HNF ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = true;
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Primops ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = true;
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Eager_unfolding -> fs
-      | FStar_TypeChecker_Env.Inlining -> fs
-      | FStar_TypeChecker_Env.DoNotUnfoldPureLets ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = true;
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.UnfoldUntil d ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (FStar_Pervasives_Native.Some d);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.UnfoldOnly lids ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (FStar_Pervasives_Native.Some lids);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.UnfoldFully lids ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (FStar_Pervasives_Native.Some lids);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.UnfoldAttr lids ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (FStar_Pervasives_Native.Some lids);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.UnfoldQual strs ->
-          let fs1 =
-            {
-              beta = (fs.beta);
-              iota = (fs.iota);
-              zeta = (fs.zeta);
-              zeta_full = (fs.zeta_full);
-              weak = (fs.weak);
-              hnf = (fs.hnf);
-              primops = (fs.primops);
-              do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-              unfold_until = (fs.unfold_until);
-              unfold_only = (fs.unfold_only);
-              unfold_fully = (fs.unfold_fully);
-              unfold_attr = (fs.unfold_attr);
-              unfold_qual = (FStar_Pervasives_Native.Some strs);
-              unfold_namespace = (fs.unfold_namespace);
-              unfold_tac = (fs.unfold_tac);
-              pure_subterms_within_computations =
-                (fs.pure_subterms_within_computations);
-              simplify = (fs.simplify);
-              erase_universes = (fs.erase_universes);
-              allow_unbound_universes = (fs.allow_unbound_universes);
-              reify_ = (fs.reify_);
-              compress_uvars = (fs.compress_uvars);
-              no_full_norm = (fs.no_full_norm);
-              check_no_uvars = (fs.check_no_uvars);
-              unmeta = (fs.unmeta);
-              unascribe = (fs.unascribe);
-              in_full_norm_request = (fs.in_full_norm_request);
-              weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-              nbe_step = (fs.nbe_step);
-              for_extraction = (fs.for_extraction);
-              unrefine = (fs.unrefine)
-            } in
-          if
-            FStar_Compiler_List.contains "pure_subterms_within_computations"
-              strs
-          then
-            {
-              beta = (fs1.beta);
-              iota = (fs1.iota);
-              zeta = (fs1.zeta);
-              zeta_full = (fs1.zeta_full);
-              weak = (fs1.weak);
-              hnf = (fs1.hnf);
-              primops = (fs1.primops);
-              do_not_unfold_pure_lets = (fs1.do_not_unfold_pure_lets);
-              unfold_until = (fs1.unfold_until);
-              unfold_only = (fs1.unfold_only);
-              unfold_fully = (fs1.unfold_fully);
-              unfold_attr = (fs1.unfold_attr);
-              unfold_qual = (fs1.unfold_qual);
-              unfold_namespace = (fs1.unfold_namespace);
-              unfold_tac = (fs1.unfold_tac);
-              pure_subterms_within_computations = true;
-              simplify = (fs1.simplify);
-              erase_universes = (fs1.erase_universes);
-              allow_unbound_universes = (fs1.allow_unbound_universes);
-              reify_ = (fs1.reify_);
-              compress_uvars = (fs1.compress_uvars);
-              no_full_norm = (fs1.no_full_norm);
-              check_no_uvars = (fs1.check_no_uvars);
-              unmeta = (fs1.unmeta);
-              unascribe = (fs1.unascribe);
-              in_full_norm_request = (fs1.in_full_norm_request);
-              weakly_reduce_scrutinee = (fs1.weakly_reduce_scrutinee);
-              nbe_step = (fs1.nbe_step);
-              for_extraction = (fs1.for_extraction);
-              unrefine = (fs1.unrefine)
-            }
-          else fs1
-      | FStar_TypeChecker_Env.UnfoldNamespace strs ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (FStar_Pervasives_Native.Some strs);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.UnfoldTac ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = true;
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.PureSubtermsWithinComputations ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations = true;
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Simplify ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = true;
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.EraseUniverses ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = true;
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.AllowUnboundUniverses ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = true;
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Reify ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = true;
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.CompressUvars ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = true;
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.NoFullNorm ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = true;
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.CheckNoUvars ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = true;
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Unmeta ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = true;
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Unascribe ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = true;
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.NBE ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = true;
-            for_extraction = (fs.for_extraction);
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.ForExtraction ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = true;
-            unrefine = (fs.unrefine)
-          }
-      | FStar_TypeChecker_Env.Unrefine ->
-          {
-            beta = (fs.beta);
-            iota = (fs.iota);
-            zeta = (fs.zeta);
-            zeta_full = (fs.zeta_full);
-            weak = (fs.weak);
-            hnf = (fs.hnf);
-            primops = (fs.primops);
-            do_not_unfold_pure_lets = (fs.do_not_unfold_pure_lets);
-            unfold_until = (fs.unfold_until);
-            unfold_only = (fs.unfold_only);
-            unfold_fully = (fs.unfold_fully);
-            unfold_attr = (fs.unfold_attr);
-            unfold_qual = (fs.unfold_qual);
-            unfold_namespace = (fs.unfold_namespace);
-            unfold_tac = (fs.unfold_tac);
-            pure_subterms_within_computations =
-              (fs.pure_subterms_within_computations);
-            simplify = (fs.simplify);
-            erase_universes = (fs.erase_universes);
-            allow_unbound_universes = (fs.allow_unbound_universes);
-            reify_ = (fs.reify_);
-            compress_uvars = (fs.compress_uvars);
-            no_full_norm = (fs.no_full_norm);
-            check_no_uvars = (fs.check_no_uvars);
-            unmeta = (fs.unmeta);
-            unascribe = (fs.unascribe);
-            in_full_norm_request = (fs.in_full_norm_request);
-            weakly_reduce_scrutinee = (fs.weakly_reduce_scrutinee);
-            nbe_step = (fs.nbe_step);
-            for_extraction = (fs.for_extraction);
-            unrefine = true
-          }
-let (to_fsteps : FStar_TypeChecker_Env.step Prims.list -> fsteps) =
-  fun s -> FStar_Compiler_List.fold_right fstep_add_one s default_steps
-type psc =
-  {
-  psc_range: FStar_Compiler_Range.range ;
-  psc_subst: unit -> FStar_Syntax_Syntax.subst_t }
-let (__proj__Mkpsc__item__psc_range : psc -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with | { psc_range; psc_subst;_} -> psc_range
-let (__proj__Mkpsc__item__psc_subst :
-  psc -> unit -> FStar_Syntax_Syntax.subst_t) =
-  fun projectee ->
-    match projectee with | { psc_range; psc_subst;_} -> psc_subst
-let (null_psc : psc) =
-  {
-    psc_range = FStar_Compiler_Range.dummyRange;
-    psc_subst = (fun uu___ -> [])
-  }
-let (psc_range : psc -> FStar_Compiler_Range.range) =
-  fun psc1 -> psc1.psc_range
-let (psc_subst : psc -> FStar_Syntax_Syntax.subst_t) =
-  fun psc1 -> psc1.psc_subst ()
-type primitive_step =
-  {
-  name: FStar_Ident.lid ;
-  arity: Prims.int ;
-  univ_arity: Prims.int ;
-  auto_reflect: Prims.int FStar_Pervasives_Native.option ;
-  strong_reduction_ok: Prims.bool ;
-  requires_binder_substitution: Prims.bool ;
-  interpretation:
-    psc ->
-      FStar_Syntax_Embeddings.norm_cb ->
-        FStar_Syntax_Syntax.universes ->
-          FStar_Syntax_Syntax.args ->
-            FStar_Syntax_Syntax.term FStar_Pervasives_Native.option
-    ;
-  interpretation_nbe:
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      FStar_Syntax_Syntax.universes ->
-        FStar_TypeChecker_NBETerm.args ->
-          FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option
-    }
-let (__proj__Mkprimitive_step__item__name :
-  primitive_step -> FStar_Ident.lid) =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> name
-let (__proj__Mkprimitive_step__item__arity : primitive_step -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> arity
-let (__proj__Mkprimitive_step__item__univ_arity :
-  primitive_step -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> univ_arity
-let (__proj__Mkprimitive_step__item__auto_reflect :
-  primitive_step -> Prims.int FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> auto_reflect
-let (__proj__Mkprimitive_step__item__strong_reduction_ok :
-  primitive_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> strong_reduction_ok
-let (__proj__Mkprimitive_step__item__requires_binder_substitution :
-  primitive_step -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> requires_binder_substitution
-let (__proj__Mkprimitive_step__item__interpretation :
-  primitive_step ->
-    psc ->
-      FStar_Syntax_Embeddings.norm_cb ->
-        FStar_Syntax_Syntax.universes ->
-          FStar_Syntax_Syntax.args ->
-            FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> interpretation
-let (__proj__Mkprimitive_step__item__interpretation_nbe :
-  primitive_step ->
-    FStar_TypeChecker_NBETerm.nbe_cbs ->
-      FStar_Syntax_Syntax.universes ->
-        FStar_TypeChecker_NBETerm.args ->
-          FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { name; arity; univ_arity; auto_reflect; strong_reduction_ok;
-        requires_binder_substitution; interpretation; interpretation_nbe;_}
-        -> interpretation_nbe
-type debug_switches =
-  {
-  gen: Prims.bool ;
-  top: Prims.bool ;
-  cfg: Prims.bool ;
-  primop: Prims.bool ;
-  unfolding: Prims.bool ;
-  b380: Prims.bool ;
-  wpe: Prims.bool ;
-  norm_delayed: Prims.bool ;
-  print_normalized: Prims.bool ;
-  debug_nbe: Prims.bool ;
-  erase_erasable_args: Prims.bool }
-let (__proj__Mkdebug_switches__item__gen : debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> gen
-let (__proj__Mkdebug_switches__item__top : debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> top
-let (__proj__Mkdebug_switches__item__cfg : debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> cfg
-let (__proj__Mkdebug_switches__item__primop : debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> primop
-let (__proj__Mkdebug_switches__item__unfolding :
-  debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> unfolding
-let (__proj__Mkdebug_switches__item__b380 : debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> b380
-let (__proj__Mkdebug_switches__item__wpe : debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> wpe
-let (__proj__Mkdebug_switches__item__norm_delayed :
-  debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> norm_delayed
-let (__proj__Mkdebug_switches__item__print_normalized :
-  debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} ->
-        print_normalized
-let (__proj__Mkdebug_switches__item__debug_nbe :
-  debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} -> debug_nbe
-let (__proj__Mkdebug_switches__item__erase_erasable_args :
-  debug_switches -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { gen; top; cfg; primop; unfolding; b380; wpe; norm_delayed;
-        print_normalized; debug_nbe; erase_erasable_args;_} ->
-        erase_erasable_args
-type cfg =
-  {
-  steps: fsteps ;
-  tcenv: FStar_TypeChecker_Env.env ;
-  debug: debug_switches ;
-  delta_level: FStar_TypeChecker_Env.delta_level Prims.list ;
-  primitive_steps: primitive_step FStar_Compiler_Util.psmap ;
-  strong: Prims.bool ;
-  memoize_lazy: Prims.bool ;
-  normalize_pure_lets: Prims.bool ;
-  reifying: Prims.bool }
-let (__proj__Mkcfg__item__steps : cfg -> fsteps) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> steps
-let (__proj__Mkcfg__item__tcenv : cfg -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> tcenv
-let (__proj__Mkcfg__item__debug : cfg -> debug_switches) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> debug
-let (__proj__Mkcfg__item__delta_level :
-  cfg -> FStar_TypeChecker_Env.delta_level Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> delta_level
-let (__proj__Mkcfg__item__primitive_steps :
-  cfg -> primitive_step FStar_Compiler_Util.psmap) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> primitive_steps
-let (__proj__Mkcfg__item__strong : cfg -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> strong
-let (__proj__Mkcfg__item__memoize_lazy : cfg -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> memoize_lazy
-let (__proj__Mkcfg__item__normalize_pure_lets : cfg -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> normalize_pure_lets
-let (__proj__Mkcfg__item__reifying : cfg -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { steps; tcenv; debug; delta_level; primitive_steps; strong;
-        memoize_lazy; normalize_pure_lets; reifying;_} -> reifying
-let (no_debug_switches : debug_switches) =
-  {
-    gen = false;
-    top = false;
-    cfg = false;
-    primop = false;
-    unfolding = false;
-    b380 = false;
-    wpe = false;
-    norm_delayed = false;
-    print_normalized = false;
-    debug_nbe = false;
-    erase_erasable_args = false
-  }
-type prim_step_set = primitive_step FStar_Compiler_Util.psmap
-let (empty_prim_steps : unit -> prim_step_set) =
-  fun uu___ -> FStar_Compiler_Util.psmap_empty ()
-let (add_step :
-  primitive_step -> prim_step_set -> primitive_step FStar_Compiler_Util.psmap)
-  =
-  fun s ->
-    fun ss ->
-      let uu___ = FStar_Ident.string_of_lid s.name in
-      FStar_Compiler_Util.psmap_add ss uu___ s
-let (merge_steps : prim_step_set -> prim_step_set -> prim_step_set) =
-  fun s1 -> fun s2 -> FStar_Compiler_Util.psmap_merge s1 s2
-let (add_steps : prim_step_set -> primitive_step Prims.list -> prim_step_set)
-  = fun m -> fun l -> FStar_Compiler_List.fold_right add_step l m
-let (prim_from_list : primitive_step Prims.list -> prim_step_set) =
-  fun l -> let uu___ = empty_prim_steps () in add_steps uu___ l
-let (cfg_to_string : cfg -> Prims.string) =
-  fun cfg1 ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          let uu___3 = steps_to_string cfg1.steps in
-          FStar_Compiler_Util.format1 "  steps = %s" uu___3 in
-        [uu___2; "}"] in
-      "{" :: uu___1 in
-    FStar_String.concat "\n" uu___
-let (cfg_env : cfg -> FStar_TypeChecker_Env.env) = fun cfg1 -> cfg1.tcenv
-let (find_prim_step :
-  cfg ->
-    FStar_Syntax_Syntax.fv -> primitive_step FStar_Pervasives_Native.option)
-  =
-  fun cfg1 ->
-    fun fv ->
-      let uu___ =
-        FStar_Ident.string_of_lid
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      FStar_Compiler_Util.psmap_try_find cfg1.primitive_steps uu___
-let (is_prim_step : cfg -> FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun cfg1 ->
-    fun fv ->
-      let uu___ =
-        let uu___1 =
-          FStar_Ident.string_of_lid
-            (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-        FStar_Compiler_Util.psmap_try_find cfg1.primitive_steps uu___1 in
-      FStar_Compiler_Util.is_some uu___
-let (log : cfg -> (unit -> unit) -> unit) =
-  fun cfg1 -> fun f -> if (cfg1.debug).gen then f () else ()
-let (log_top : cfg -> (unit -> unit) -> unit) =
-  fun cfg1 -> fun f -> if (cfg1.debug).top then f () else ()
-let (log_cfg : cfg -> (unit -> unit) -> unit) =
-  fun cfg1 -> fun f -> if (cfg1.debug).cfg then f () else ()
-let (log_primops : cfg -> (unit -> unit) -> unit) =
-  fun cfg1 -> fun f -> if (cfg1.debug).primop then f () else ()
-let (log_unfolding : cfg -> (unit -> unit) -> unit) =
-  fun cfg1 -> fun f -> if (cfg1.debug).unfolding then f () else ()
-let (log_nbe : cfg -> (unit -> unit) -> unit) =
-  fun cfg1 -> fun f -> if (cfg1.debug).debug_nbe then f () else ()
-let embed_simple :
-  'a .
-    'a FStar_Syntax_Embeddings.embedding ->
-      FStar_Compiler_Range.range -> 'a -> FStar_Syntax_Syntax.term
-  =
-  fun emb ->
-    fun r ->
-      fun x ->
-        let uu___ = FStar_Syntax_Embeddings.embed emb x in
-        uu___ r FStar_Pervasives_Native.None
-          FStar_Syntax_Embeddings.id_norm_cb
-let try_unembed_simple :
-  'a .
-    'a FStar_Syntax_Embeddings.embedding ->
-      FStar_Syntax_Syntax.term -> 'a FStar_Pervasives_Native.option
-  =
-  fun emb ->
-    fun x ->
-      let uu___ = FStar_Syntax_Embeddings.unembed emb x in
-      uu___ false FStar_Syntax_Embeddings.id_norm_cb
-let (built_in_primitive_steps : primitive_step FStar_Compiler_Util.psmap) =
-  let arg_as_int a =
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (try_unembed_simple FStar_Syntax_Embeddings.e_int) in
-  let arg_as_bool a =
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (try_unembed_simple FStar_Syntax_Embeddings.e_bool) in
-  let arg_as_char a =
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (try_unembed_simple FStar_Syntax_Embeddings.e_char) in
-  let arg_as_string a =
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (try_unembed_simple FStar_Syntax_Embeddings.e_string) in
-  let arg_as_list e a1 =
-    let uu___ =
-      let uu___1 = FStar_Syntax_Embeddings.e_list e in
-      try_unembed_simple uu___1 in
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a1)
-      uu___ in
-  let arg_as_bounded_int uu___ =
-    match uu___ with
-    | (a, uu___1) ->
-        let uu___2 =
-          let uu___3 =
-            let uu___4 = FStar_Syntax_Subst.compress a in
-            uu___4.FStar_Syntax_Syntax.n in
-          match uu___3 with
-          | FStar_Syntax_Syntax.Tm_meta
-              (t, FStar_Syntax_Syntax.Meta_desugared m) ->
-              (t, (FStar_Pervasives_Native.Some m))
-          | uu___4 -> (a, FStar_Pervasives_Native.None) in
-        (match uu___2 with
-         | (a1, m) ->
-             let a2 = FStar_Syntax_Util.unmeta_safe a1 in
-             let uu___3 = FStar_Syntax_Util.head_and_args_full a2 in
-             (match uu___3 with
-              | (hd, args) ->
-                  let a3 = FStar_Syntax_Util.unlazy_emb a2 in
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Subst.compress hd in
-                      uu___6.FStar_Syntax_Syntax.n in
-                    (uu___5, args) in
-                  (match uu___4 with
-                   | (FStar_Syntax_Syntax.Tm_fvar fv1, (arg, uu___5)::[])
-                       when
-                       let uu___6 =
-                         FStar_Ident.string_of_lid
-                           (fv1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                       FStar_Compiler_Util.ends_with uu___6 "int_to_t" ->
-                       let arg1 = FStar_Syntax_Util.unlazy_emb arg in
-                       let uu___6 =
-                         let uu___7 = FStar_Syntax_Subst.compress arg1 in
-                         uu___7.FStar_Syntax_Syntax.n in
-                       (match uu___6 with
-                        | FStar_Syntax_Syntax.Tm_constant
-                            (FStar_Const.Const_int
-                            (i, FStar_Pervasives_Native.None)) ->
-                            let uu___7 =
-                              let uu___8 = FStar_BigInt.big_int_of_string i in
-                              (fv1, uu___8, m) in
-                            FStar_Pervasives_Native.Some uu___7
-                        | uu___7 -> FStar_Pervasives_Native.None)
-                   | uu___5 -> FStar_Pervasives_Native.None))) in
-  let lift_unary f aopts =
-    match aopts with
-    | (FStar_Pervasives_Native.Some a1)::[] ->
-        let uu___ = f a1 in FStar_Pervasives_Native.Some uu___
-    | uu___ -> FStar_Pervasives_Native.None in
-  let lift_binary f aopts =
-    match aopts with
-    | (FStar_Pervasives_Native.Some a0)::(FStar_Pervasives_Native.Some
-        a1)::[] -> let uu___ = f a0 a1 in FStar_Pervasives_Native.Some uu___
-    | uu___ -> FStar_Pervasives_Native.None in
-  let unary_op as_a f res norm_cb _univs args =
-    let uu___ = FStar_Compiler_List.map as_a args in
-    lift_unary (f res.psc_range) uu___ in
-  let binary_op as_a f res n _univs args =
-    let uu___ = FStar_Compiler_List.map as_a args in
-    lift_binary (f res.psc_range) uu___ in
-  let as_primitive_step is_strong uu___ =
-    match uu___ with
-    | (l, arity, u_arity, f, f_nbe) ->
-        {
-          name = l;
-          arity;
-          univ_arity = u_arity;
-          auto_reflect = FStar_Pervasives_Native.None;
-          strong_reduction_ok = is_strong;
-          requires_binder_substitution = false;
-          interpretation =
-            ((fun psc1 ->
-                fun cb -> fun univs -> fun args -> f psc1 cb univs args));
-          interpretation_nbe =
-            ((fun _cb -> fun univs -> fun args -> f_nbe univs args))
-        } in
-  let unary_int_op f =
-    unary_op arg_as_int
-      (fun r ->
-         fun x ->
-           let uu___ = f x in
-           embed_simple FStar_Syntax_Embeddings.e_int r uu___) in
-  let binary_int_op f =
-    binary_op arg_as_int
-      (fun r ->
-         fun x ->
-           fun y ->
-             let uu___ = f x y in
-             embed_simple FStar_Syntax_Embeddings.e_int r uu___) in
-  let unary_bool_op f =
-    unary_op arg_as_bool
-      (fun r ->
-         fun x ->
-           let uu___ = f x in
-           embed_simple FStar_Syntax_Embeddings.e_bool r uu___) in
-  let binary_bool_op f =
-    binary_op arg_as_bool
-      (fun r ->
-         fun x ->
-           fun y ->
-             let uu___ = f x y in
-             embed_simple FStar_Syntax_Embeddings.e_bool r uu___) in
-  let binary_string_op f =
-    binary_op arg_as_string
-      (fun r ->
-         fun x ->
-           fun y ->
-             let uu___ = f x y in
-             embed_simple FStar_Syntax_Embeddings.e_string r uu___) in
-  let mixed_binary_op as_a as_b embed_c f res _norm_cb universes args =
-    match args with
-    | a1::b1::[] ->
-        let uu___ =
-          let uu___1 = as_a a1 in let uu___2 = as_b b1 in (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some a2, FStar_Pervasives_Native.Some b2)
-             ->
-             let uu___1 = f res.psc_range universes a2 b2 in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some c1 ->
-                  let uu___2 = embed_c res.psc_range c1 in
-                  FStar_Pervasives_Native.Some uu___2
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let mixed_ternary_op as_a as_b as_c embed_d f res _norm_cb universes args =
-    match args with
-    | a1::b1::c1::[] ->
-        let uu___ =
-          let uu___1 = as_a a1 in
-          let uu___2 = as_b b1 in
-          let uu___3 = as_c c1 in (uu___1, uu___2, uu___3) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some a2, FStar_Pervasives_Native.Some b2,
-            FStar_Pervasives_Native.Some c2) ->
-             let uu___1 = f res.psc_range universes a2 b2 c2 in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some d1 ->
-                  let uu___2 = embed_d res.psc_range d1 in
-                  FStar_Pervasives_Native.Some uu___2
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let list_of_string' rng s =
-    let name l =
-      let uu___ =
-        let uu___1 =
-          FStar_Syntax_Syntax.lid_as_fv l FStar_Syntax_Syntax.delta_constant
-            FStar_Pervasives_Native.None in
-        FStar_Syntax_Syntax.Tm_fvar uu___1 in
-      FStar_Syntax_Syntax.mk uu___ rng in
-    let char_t = name FStar_Parser_Const.char_lid in
-    let charterm c =
-      FStar_Syntax_Syntax.mk
-        (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_char c)) rng in
-    let uu___ =
-      let uu___1 = FStar_String.list_of_string s in
-      FStar_Compiler_List.map charterm uu___1 in
-    FStar_Compiler_Effect.op_Less_Bar (FStar_Syntax_Util.mk_list char_t rng)
-      uu___ in
-  let string_of_list' rng l =
-    let s = FStar_String.string_of_list l in FStar_Syntax_Util.exp_string s in
-  let string_compare' rng s1 s2 =
-    let r = FStar_String.compare s1 s2 in
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.string_of_int r in
-      FStar_BigInt.big_int_of_string uu___1 in
-    embed_simple FStar_Syntax_Embeddings.e_int rng uu___ in
-  let string_concat' psc1 _n _us args =
-    match args with
-    | a1::a2::[] ->
-        let uu___ = arg_as_string a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some s1 ->
-             let uu___1 = arg_as_list FStar_Syntax_Embeddings.e_string a2 in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some s2 ->
-                  let r = FStar_String.concat s1 s2 in
-                  let uu___2 =
-                    embed_simple FStar_Syntax_Embeddings.e_string
-                      psc1.psc_range r in
-                  FStar_Pervasives_Native.Some uu___2
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let string_split' psc1 _norm_cb _us args =
-    match args with
-    | a1::a2::[] ->
-        let uu___ = arg_as_list FStar_Syntax_Embeddings.e_char a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some s1 ->
-             let uu___1 = arg_as_string a2 in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some s2 ->
-                  let r = FStar_String.split s1 s2 in
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Syntax_Embeddings.e_list
-                        FStar_Syntax_Embeddings.e_string in
-                    embed_simple uu___3 psc1.psc_range r in
-                  FStar_Pervasives_Native.Some uu___2
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let string_substring' psc1 _norm_cb _us args =
-    match args with
-    | a1::a2::a3::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string a1 in
-          let uu___2 = arg_as_int a2 in
-          let uu___3 = arg_as_int a3 in (uu___1, uu___2, uu___3) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some s1, FStar_Pervasives_Native.Some n1,
-            FStar_Pervasives_Native.Some n2) ->
-             let n11 = FStar_BigInt.to_int_fs n1 in
-             let n21 = FStar_BigInt.to_int_fs n2 in
-             (try
-                (fun uu___1 ->
-                   match () with
-                   | () ->
-                       let r = FStar_String.substring s1 n11 n21 in
-                       let uu___2 =
-                         embed_simple FStar_Syntax_Embeddings.e_string
-                           psc1.psc_range r in
-                       FStar_Pervasives_Native.Some uu___2) ()
-              with | uu___1 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let string_of_int rng i =
-    let uu___ = FStar_BigInt.string_of_big_int i in
-    embed_simple FStar_Syntax_Embeddings.e_string rng uu___ in
-  let string_of_bool rng b =
-    embed_simple FStar_Syntax_Embeddings.e_string rng
-      (if b then "true" else "false") in
-  let lowercase rng s =
-    embed_simple FStar_Syntax_Embeddings.e_string rng
-      (FStar_String.lowercase s) in
-  let uppercase rng s =
-    embed_simple FStar_Syntax_Embeddings.e_string rng
-      (FStar_String.uppercase s) in
-  let string_index psc1 _norm_cb _us args =
-    match args with
-    | a1::a2::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string a1 in
-          let uu___2 = arg_as_int a2 in (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some s, FStar_Pervasives_Native.Some i)
-             ->
-             (try
-                (fun uu___1 ->
-                   match () with
-                   | () ->
-                       let r = FStar_String.index s i in
-                       let uu___2 =
-                         embed_simple FStar_Syntax_Embeddings.e_char
-                           psc1.psc_range r in
-                       FStar_Pervasives_Native.Some uu___2) ()
-              with | uu___1 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let string_index_of psc1 _norm_cb _us args =
-    match args with
-    | a1::a2::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string a1 in
-          let uu___2 = arg_as_char a2 in (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some s, FStar_Pervasives_Native.Some c)
-             ->
-             (try
-                (fun uu___1 ->
-                   match () with
-                   | () ->
-                       let r = FStar_String.index_of s c in
-                       let uu___2 =
-                         embed_simple FStar_Syntax_Embeddings.e_int
-                           psc1.psc_range r in
-                       FStar_Pervasives_Native.Some uu___2) ()
-              with | uu___1 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let mk_range psc1 _norm_cb _us args =
-    match args with
-    | fn::from_line::from_col::to_line::to_col::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string fn in
-          let uu___2 = arg_as_int from_line in
-          let uu___3 = arg_as_int from_col in
-          let uu___4 = arg_as_int to_line in
-          let uu___5 = arg_as_int to_col in
-          (uu___1, uu___2, uu___3, uu___4, uu___5) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some fn1, FStar_Pervasives_Native.Some
-            from_l, FStar_Pervasives_Native.Some from_c,
-            FStar_Pervasives_Native.Some to_l, FStar_Pervasives_Native.Some
-            to_c) ->
-             let r =
-               let uu___1 =
-                 let uu___2 = FStar_BigInt.to_int_fs from_l in
-                 let uu___3 = FStar_BigInt.to_int_fs from_c in
-                 FStar_Compiler_Range.mk_pos uu___2 uu___3 in
-               let uu___2 =
-                 let uu___3 = FStar_BigInt.to_int_fs to_l in
-                 let uu___4 = FStar_BigInt.to_int_fs to_c in
-                 FStar_Compiler_Range.mk_pos uu___3 uu___4 in
-               FStar_Compiler_Range.mk_range fn1 uu___1 uu___2 in
-             let uu___1 =
-               embed_simple FStar_Syntax_Embeddings.e_range psc1.psc_range r in
-             FStar_Pervasives_Native.Some uu___1
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None in
-  let decidable_eq neg psc1 _norm_cb _us args =
-    let r = psc1.psc_range in
-    let tru =
-      FStar_Syntax_Syntax.mk
-        (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_bool true)) r in
-    let fal =
-      FStar_Syntax_Syntax.mk
-        (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_bool false)) r in
-    match args with
-    | (_typ, uu___)::(a1, uu___1)::(a2, uu___2)::[] ->
-        let uu___3 = FStar_Syntax_Util.eq_tm a1 a2 in
-        (match uu___3 with
-         | FStar_Syntax_Util.Equal ->
-             FStar_Pervasives_Native.Some (if neg then fal else tru)
-         | FStar_Syntax_Util.NotEqual ->
-             FStar_Pervasives_Native.Some (if neg then tru else fal)
-         | uu___4 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments" in
-  let prims_to_fstar_range_step psc1 _norm_cb _us args =
-    match args with
-    | (a1, uu___)::[] ->
-        let uu___1 = try_unembed_simple FStar_Syntax_Embeddings.e_range a1 in
-        (match uu___1 with
-         | FStar_Pervasives_Native.Some r ->
-             let uu___2 =
-               embed_simple FStar_Syntax_Embeddings.e_range psc1.psc_range r in
-             FStar_Pervasives_Native.Some uu___2
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments" in
-  let and_op psc1 _norm_cb _us args =
-    match args with
-    | (a1, FStar_Pervasives_Native.None)::(a2, FStar_Pervasives_Native.None)::[]
-        ->
-        let uu___ = try_unembed_simple FStar_Syntax_Embeddings.e_bool a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some (false) ->
-             let uu___1 =
-               embed_simple FStar_Syntax_Embeddings.e_bool psc1.psc_range
-                 false in
-             FStar_Pervasives_Native.Some uu___1
-         | FStar_Pervasives_Native.Some (true) ->
-             FStar_Pervasives_Native.Some a2
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments" in
-  let or_op psc1 _norm_cb _us args =
-    match args with
-    | (a1, FStar_Pervasives_Native.None)::(a2, FStar_Pervasives_Native.None)::[]
-        ->
-        let uu___ = try_unembed_simple FStar_Syntax_Embeddings.e_bool a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some (true) ->
-             let uu___1 =
-               embed_simple FStar_Syntax_Embeddings.e_bool psc1.psc_range
-                 true in
-             FStar_Pervasives_Native.Some uu___1
-         | FStar_Pervasives_Native.Some (false) ->
-             FStar_Pervasives_Native.Some a2
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments" in
-  let division_op psc1 _norm_cb _us args =
-    match args with
-    | (a1, FStar_Pervasives_Native.None)::(a2, FStar_Pervasives_Native.None)::[]
-        ->
-        let uu___ =
-          let uu___1 = try_unembed_simple FStar_Syntax_Embeddings.e_int a1 in
-          let uu___2 = try_unembed_simple FStar_Syntax_Embeddings.e_int a2 in
-          (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some m, FStar_Pervasives_Native.Some n)
-             ->
-             let uu___1 =
-               let uu___2 = FStar_BigInt.to_int_fs n in
-               uu___2 <> Prims.int_zero in
-             if uu___1
-             then
-               let uu___2 =
-                 let uu___3 = FStar_BigInt.div_big_int m n in
-                 embed_simple FStar_Syntax_Embeddings.e_int psc1.psc_range
-                   uu___3 in
-               FStar_Pervasives_Native.Some uu___2
-             else FStar_Pervasives_Native.None
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments" in
-  let bogus_cbs =
-    {
-      FStar_TypeChecker_NBETerm.iapp = (fun h -> fun _args -> h);
-      FStar_TypeChecker_NBETerm.translate =
-        (fun uu___ -> failwith "bogus_cbs translate")
-    } in
-  let int_as_bounded r int_to_t n =
-    let c = embed_simple FStar_Syntax_Embeddings.e_int r n in
-    let int_to_t1 = FStar_Syntax_Syntax.fv_to_tm int_to_t in
-    let uu___ = let uu___1 = FStar_Syntax_Syntax.as_arg c in [uu___1] in
-    FStar_Syntax_Syntax.mk_Tm_app int_to_t1 uu___ r in
-  let with_meta_ds r t m =
-    match m with
-    | FStar_Pervasives_Native.None -> t
-    | FStar_Pervasives_Native.Some m1 ->
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_meta
-             (t, (FStar_Syntax_Syntax.Meta_desugared m1))) r in
-  let basic_ops =
-    let uu___ =
-      let uu___1 =
-        FStar_TypeChecker_NBETerm.unary_int_op
-          (fun x -> FStar_BigInt.minus_big_int x) in
-      (FStar_Parser_Const.op_Minus, Prims.int_one, Prims.int_zero,
-        (unary_int_op (fun x -> FStar_BigInt.minus_big_int x)), uu___1) in
-    let uu___1 =
-      let uu___2 =
-        let uu___3 =
-          FStar_TypeChecker_NBETerm.binary_int_op
-            (fun x -> fun y -> FStar_BigInt.add_big_int x y) in
-        (FStar_Parser_Const.op_Addition, (Prims.of_int (2)), Prims.int_zero,
-          (binary_int_op (fun x -> fun y -> FStar_BigInt.add_big_int x y)),
-          uu___3) in
-      let uu___3 =
-        let uu___4 =
-          let uu___5 =
-            FStar_TypeChecker_NBETerm.binary_int_op
-              (fun x -> fun y -> FStar_BigInt.sub_big_int x y) in
-          (FStar_Parser_Const.op_Subtraction, (Prims.of_int (2)),
-            Prims.int_zero,
-            (binary_int_op (fun x -> fun y -> FStar_BigInt.sub_big_int x y)),
-            uu___5) in
-        let uu___5 =
-          let uu___6 =
-            let uu___7 =
-              FStar_TypeChecker_NBETerm.binary_int_op
-                (fun x -> fun y -> FStar_BigInt.mult_big_int x y) in
-            (FStar_Parser_Const.op_Multiply, (Prims.of_int (2)),
-              Prims.int_zero,
-              (binary_int_op
-                 (fun x -> fun y -> FStar_BigInt.mult_big_int x y)), uu___7) in
-          let uu___7 =
-            let uu___8 =
-              let uu___9 =
-                let uu___10 =
-                  FStar_TypeChecker_NBETerm.binary_op
-                    FStar_TypeChecker_NBETerm.arg_as_int
-                    (fun x ->
-                       fun y ->
-                         let uu___11 = FStar_BigInt.lt_big_int x y in
-                         FStar_TypeChecker_NBETerm.embed
-                           FStar_TypeChecker_NBETerm.e_bool bogus_cbs uu___11) in
-                (FStar_Parser_Const.op_LT, (Prims.of_int (2)),
-                  Prims.int_zero,
-                  (binary_op arg_as_int
-                     (fun r ->
-                        fun x ->
-                          fun y ->
-                            let uu___11 = FStar_BigInt.lt_big_int x y in
-                            embed_simple FStar_Syntax_Embeddings.e_bool r
-                              uu___11)), uu___10) in
-              let uu___10 =
-                let uu___11 =
-                  let uu___12 =
-                    FStar_TypeChecker_NBETerm.binary_op
-                      FStar_TypeChecker_NBETerm.arg_as_int
-                      (fun x ->
-                         fun y ->
-                           let uu___13 = FStar_BigInt.le_big_int x y in
-                           FStar_TypeChecker_NBETerm.embed
-                             FStar_TypeChecker_NBETerm.e_bool bogus_cbs
-                             uu___13) in
-                  (FStar_Parser_Const.op_LTE, (Prims.of_int (2)),
-                    Prims.int_zero,
-                    (binary_op arg_as_int
-                       (fun r ->
-                          fun x ->
-                            fun y ->
-                              let uu___13 = FStar_BigInt.le_big_int x y in
-                              embed_simple FStar_Syntax_Embeddings.e_bool r
-                                uu___13)), uu___12) in
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 =
-                      FStar_TypeChecker_NBETerm.binary_op
-                        FStar_TypeChecker_NBETerm.arg_as_int
-                        (fun x ->
-                           fun y ->
-                             let uu___15 = FStar_BigInt.gt_big_int x y in
-                             FStar_TypeChecker_NBETerm.embed
-                               FStar_TypeChecker_NBETerm.e_bool bogus_cbs
-                               uu___15) in
-                    (FStar_Parser_Const.op_GT, (Prims.of_int (2)),
-                      Prims.int_zero,
-                      (binary_op arg_as_int
-                         (fun r ->
-                            fun x ->
-                              fun y ->
-                                let uu___15 = FStar_BigInt.gt_big_int x y in
-                                embed_simple FStar_Syntax_Embeddings.e_bool r
-                                  uu___15)), uu___14) in
-                  let uu___14 =
-                    let uu___15 =
-                      let uu___16 =
-                        FStar_TypeChecker_NBETerm.binary_op
-                          FStar_TypeChecker_NBETerm.arg_as_int
-                          (fun x ->
-                             fun y ->
-                               let uu___17 = FStar_BigInt.ge_big_int x y in
-                               FStar_TypeChecker_NBETerm.embed
-                                 FStar_TypeChecker_NBETerm.e_bool bogus_cbs
-                                 uu___17) in
-                      (FStar_Parser_Const.op_GTE, (Prims.of_int (2)),
-                        Prims.int_zero,
-                        (binary_op arg_as_int
-                           (fun r ->
-                              fun x ->
-                                fun y ->
-                                  let uu___17 = FStar_BigInt.ge_big_int x y in
-                                  embed_simple FStar_Syntax_Embeddings.e_bool
-                                    r uu___17)), uu___16) in
-                    let uu___16 =
-                      let uu___17 =
-                        let uu___18 =
-                          FStar_TypeChecker_NBETerm.binary_int_op
-                            (fun x -> fun y -> FStar_BigInt.mod_big_int x y) in
-                        (FStar_Parser_Const.op_Modulus, (Prims.of_int (2)),
-                          Prims.int_zero,
-                          (binary_int_op
-                             (fun x -> fun y -> FStar_BigInt.mod_big_int x y)),
-                          uu___18) in
-                      let uu___18 =
-                        let uu___19 =
-                          let uu___20 =
-                            FStar_TypeChecker_NBETerm.unary_bool_op
-                              (fun x -> Prims.op_Negation x) in
-                          (FStar_Parser_Const.op_Negation, Prims.int_one,
-                            Prims.int_zero,
-                            (unary_bool_op (fun x -> Prims.op_Negation x)),
-                            uu___20) in
-                        let uu___20 =
-                          let uu___21 =
-                            let uu___22 =
-                              let uu___23 =
-                                let u32_int_to_t =
-                                  let uu___24 =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      ["FStar"; "UInt32"; "uint_to_t"]
-                                      FStar_Parser_Const.p2l in
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    uu___24
-                                    (fun l ->
-                                       FStar_Syntax_Syntax.lid_as_fv l
-                                         (FStar_Syntax_Syntax.Delta_constant_at_level
-                                            Prims.int_zero)
-                                         FStar_Pervasives_Native.None) in
-                                let uu___24 =
-                                  FStar_TypeChecker_NBETerm.unary_op
-                                    FStar_TypeChecker_NBETerm.arg_as_char
-                                    (fun c ->
-                                       let uu___25 =
-                                         let uu___26 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             c
-                                             FStar_Compiler_Util.int_of_char in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___26 FStar_BigInt.of_int_fs in
-                                       FStar_TypeChecker_NBETerm.int_as_bounded
-                                         u32_int_to_t uu___25) in
-                                (FStar_Parser_Const.char_u32_of_char,
-                                  Prims.int_one, Prims.int_zero,
-                                  (unary_op arg_as_char
-                                     (fun r ->
-                                        fun c ->
-                                          let uu___25 =
-                                            let uu___26 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                c
-                                                FStar_Compiler_Util.int_of_char in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___26 FStar_BigInt.of_int_fs in
-                                          int_as_bounded r u32_int_to_t
-                                            uu___25)), uu___24) in
-                              let uu___24 =
-                                let uu___25 =
-                                  let uu___26 =
-                                    FStar_TypeChecker_NBETerm.unary_op
-                                      FStar_TypeChecker_NBETerm.arg_as_int
-                                      FStar_TypeChecker_NBETerm.string_of_int in
-                                  (FStar_Parser_Const.string_of_int_lid,
-                                    Prims.int_one, Prims.int_zero,
-                                    (unary_op arg_as_int string_of_int),
-                                    uu___26) in
-                                let uu___26 =
-                                  let uu___27 =
-                                    let uu___28 =
-                                      FStar_TypeChecker_NBETerm.unary_op
-                                        FStar_TypeChecker_NBETerm.arg_as_bool
-                                        FStar_TypeChecker_NBETerm.string_of_bool in
-                                    (FStar_Parser_Const.string_of_bool_lid,
-                                      Prims.int_one, Prims.int_zero,
-                                      (unary_op arg_as_bool string_of_bool),
-                                      uu___28) in
-                                  let uu___28 =
-                                    let uu___29 =
-                                      let uu___30 =
-                                        FStar_TypeChecker_NBETerm.unary_op
-                                          FStar_TypeChecker_NBETerm.arg_as_string
-                                          FStar_TypeChecker_NBETerm.list_of_string' in
-                                      (FStar_Parser_Const.string_list_of_string_lid,
-                                        Prims.int_one, Prims.int_zero,
-                                        (unary_op arg_as_string
-                                           list_of_string'), uu___30) in
-                                    let uu___30 =
-                                      let uu___31 =
-                                        let uu___32 =
-                                          FStar_TypeChecker_NBETerm.unary_op
-                                            (FStar_TypeChecker_NBETerm.arg_as_list
-                                               FStar_TypeChecker_NBETerm.e_char)
-                                            FStar_TypeChecker_NBETerm.string_of_list' in
-                                        (FStar_Parser_Const.string_string_of_list_lid,
-                                          Prims.int_one, Prims.int_zero,
-                                          (unary_op
-                                             (arg_as_list
-                                                FStar_Syntax_Embeddings.e_char)
-                                             string_of_list'), uu___32) in
-                                      let uu___32 =
-                                        let uu___33 =
-                                          let uu___34 =
-                                            let uu___35 =
-                                              let uu___36 =
-                                                FStar_TypeChecker_NBETerm.binary_string_op
-                                                  (fun x ->
-                                                     fun y ->
-                                                       FStar_String.op_Hat x
-                                                         y) in
-                                              (FStar_Parser_Const.prims_strcat_lid,
-                                                (Prims.of_int (2)),
-                                                Prims.int_zero,
-                                                (binary_string_op
-                                                   (fun x ->
-                                                      fun y ->
-                                                        FStar_String.op_Hat x
-                                                          y)), uu___36) in
-                                            let uu___36 =
-                                              let uu___37 =
-                                                let uu___38 =
-                                                  let uu___39 =
-                                                    FStar_TypeChecker_NBETerm.binary_op
-                                                      FStar_TypeChecker_NBETerm.arg_as_string
-                                                      FStar_TypeChecker_NBETerm.string_compare' in
-                                                  (FStar_Parser_Const.string_compare_lid,
-                                                    (Prims.of_int (2)),
-                                                    Prims.int_zero,
-                                                    (binary_op arg_as_string
-                                                       string_compare'),
-                                                    uu___39) in
-                                                let uu___39 =
-                                                  let uu___40 =
-                                                    let uu___41 =
-                                                      FStar_TypeChecker_NBETerm.unary_op
-                                                        FStar_TypeChecker_NBETerm.arg_as_string
-                                                        FStar_TypeChecker_NBETerm.string_lowercase in
-                                                    (FStar_Parser_Const.string_lowercase_lid,
-                                                      Prims.int_one,
-                                                      Prims.int_zero,
-                                                      (unary_op arg_as_string
-                                                         lowercase), uu___41) in
-                                                  let uu___41 =
-                                                    let uu___42 =
-                                                      let uu___43 =
-                                                        FStar_TypeChecker_NBETerm.unary_op
-                                                          FStar_TypeChecker_NBETerm.arg_as_string
-                                                          FStar_TypeChecker_NBETerm.string_uppercase in
-                                                      (FStar_Parser_Const.string_uppercase_lid,
-                                                        Prims.int_one,
-                                                        Prims.int_zero,
-                                                        (unary_op
-                                                           arg_as_string
-                                                           uppercase),
-                                                        uu___43) in
-                                                    let uu___43 =
-                                                      let uu___44 =
-                                                        let uu___45 =
-                                                          let uu___46 =
-                                                            let uu___47 =
-                                                              let uu___48 =
-                                                                let uu___49 =
-                                                                  let uu___50
-                                                                    =
-                                                                    FStar_Parser_Const.p2l
-                                                                    ["Prims";
-                                                                    "mk_range"] in
-                                                                  (uu___50,
-                                                                    (Prims.of_int (5)),
-                                                                    Prims.int_zero,
-                                                                    mk_range,
-                                                                    (
-                                                                    fun
-                                                                    uu___51
-                                                                    ->
-                                                                    FStar_TypeChecker_NBETerm.mk_range)) in
-                                                                let uu___50 =
-                                                                  let uu___51
-                                                                    =
-                                                                    let uu___52
-                                                                    =
-                                                                    FStar_Parser_Const.p2l
-                                                                    ["FStar";
-                                                                    "Range";
-                                                                    "prims_to_fstar_range"] in
-                                                                    (uu___52,
-                                                                    Prims.int_one,
-                                                                    Prims.int_zero,
-                                                                    prims_to_fstar_range_step,
-                                                                    (fun
-                                                                    uu___53
-                                                                    ->
-                                                                    FStar_TypeChecker_NBETerm.prims_to_fstar_range_step)) in
-                                                                  [uu___51] in
-                                                                uu___49 ::
-                                                                  uu___50 in
-                                                              (FStar_Parser_Const.op_notEq,
-                                                                (Prims.of_int (3)),
-                                                                Prims.int_zero,
-                                                                (decidable_eq
-                                                                   true),
-                                                                (fun uu___49
-                                                                   ->
-                                                                   FStar_TypeChecker_NBETerm.decidable_eq
-                                                                    true))
-                                                                :: uu___48 in
-                                                            (FStar_Parser_Const.op_Eq,
-                                                              (Prims.of_int (3)),
-                                                              Prims.int_zero,
-                                                              (decidable_eq
-                                                                 false),
-                                                              (fun uu___48 ->
-                                                                 FStar_TypeChecker_NBETerm.decidable_eq
-                                                                   false))
-                                                              :: uu___47 in
-                                                          (FStar_Parser_Const.string_sub_lid,
-                                                            (Prims.of_int (3)),
-                                                            Prims.int_zero,
-                                                            string_substring',
-                                                            (fun uu___47 ->
-                                                               FStar_TypeChecker_NBETerm.string_substring'))
-                                                            :: uu___46 in
-                                                        (FStar_Parser_Const.string_index_of_lid,
-                                                          (Prims.of_int (2)),
-                                                          Prims.int_zero,
-                                                          string_index_of,
-                                                          (fun uu___46 ->
-                                                             FStar_TypeChecker_NBETerm.string_index_of))
-                                                          :: uu___45 in
-                                                      (FStar_Parser_Const.string_index_lid,
-                                                        (Prims.of_int (2)),
-                                                        Prims.int_zero,
-                                                        string_index,
-                                                        (fun uu___45 ->
-                                                           FStar_TypeChecker_NBETerm.string_index))
-                                                        :: uu___44 in
-                                                    uu___42 :: uu___43 in
-                                                  uu___40 :: uu___41 in
-                                                uu___38 :: uu___39 in
-                                              (FStar_Parser_Const.string_concat_lid,
-                                                (Prims.of_int (2)),
-                                                Prims.int_zero,
-                                                string_concat',
-                                                (fun uu___38 ->
-                                                   FStar_TypeChecker_NBETerm.string_concat'))
-                                                :: uu___37 in
-                                            uu___35 :: uu___36 in
-                                          (FStar_Parser_Const.string_split_lid,
-                                            (Prims.of_int (2)),
-                                            Prims.int_zero, string_split',
-                                            (fun uu___35 ->
-                                               FStar_TypeChecker_NBETerm.string_split'))
-                                            :: uu___34 in
-                                        (FStar_Parser_Const.string_make_lid,
-                                          (Prims.of_int (2)), Prims.int_zero,
-                                          (mixed_binary_op
-                                             (fun x -> arg_as_int x)
-                                             (fun x -> arg_as_char x)
-                                             (fun r ->
-                                                fun s ->
-                                                  embed_simple
-                                                    FStar_Syntax_Embeddings.e_string
-                                                    r s)
-                                             (fun r ->
-                                                fun _us ->
-                                                  fun x ->
-                                                    fun y ->
-                                                      let uu___34 =
-                                                        let uu___35 =
-                                                          FStar_BigInt.to_int_fs
-                                                            x in
-                                                        FStar_String.make
-                                                          uu___35 y in
-                                                      FStar_Pervasives_Native.Some
-                                                        uu___34)),
-                                          (FStar_TypeChecker_NBETerm.mixed_binary_op
-                                             FStar_TypeChecker_NBETerm.arg_as_int
-                                             FStar_TypeChecker_NBETerm.arg_as_char
-                                             (FStar_TypeChecker_NBETerm.embed
-                                                FStar_TypeChecker_NBETerm.e_string
-                                                bogus_cbs)
-                                             (fun _us ->
-                                                fun x ->
-                                                  fun y ->
-                                                    let uu___34 =
-                                                      let uu___35 =
-                                                        FStar_BigInt.to_int_fs
-                                                          x in
-                                                      FStar_String.make
-                                                        uu___35 y in
-                                                    FStar_Pervasives_Native.Some
-                                                      uu___34)))
-                                          :: uu___33 in
-                                      uu___31 :: uu___32 in
-                                    uu___29 :: uu___30 in
-                                  uu___27 :: uu___28 in
-                                uu___25 :: uu___26 in
-                              uu___23 :: uu___24 in
-                            (FStar_Parser_Const.op_Or, (Prims.of_int (2)),
-                              Prims.int_zero, or_op,
-                              (fun uu___23 -> FStar_TypeChecker_NBETerm.or_op))
-                              :: uu___22 in
-                          (FStar_Parser_Const.op_And, (Prims.of_int (2)),
-                            Prims.int_zero, and_op,
-                            (fun uu___22 -> FStar_TypeChecker_NBETerm.and_op))
-                            :: uu___21 in
-                        uu___19 :: uu___20 in
-                      uu___17 :: uu___18 in
-                    uu___15 :: uu___16 in
-                  uu___13 :: uu___14 in
-                uu___11 :: uu___12 in
-              uu___9 :: uu___10 in
-            (FStar_Parser_Const.op_Division, (Prims.of_int (2)),
-              Prims.int_zero, division_op,
-              (fun _us -> FStar_TypeChecker_NBETerm.division_op)) :: uu___8 in
-          uu___6 :: uu___7 in
-        uu___4 :: uu___5 in
-      uu___2 :: uu___3 in
-    uu___ :: uu___1 in
-  let weak_ops = [] in
-  let bounded_arith_ops =
-    let bounded_signed_int_types =
-      [("Int8", (Prims.of_int (8)));
-      ("Int16", (Prims.of_int (16)));
-      ("Int32", (Prims.of_int (32)));
-      ("Int64", (Prims.of_int (64)))] in
-    let bounded_unsigned_int_types =
-      [("UInt8", (Prims.of_int (8)));
-      ("UInt16", (Prims.of_int (16)));
-      ("UInt32", (Prims.of_int (32)));
-      ("UInt64", (Prims.of_int (64)));
-      ("UInt128", (Prims.of_int (128)));
-      ("SizeT", (Prims.of_int (64)))] in
-    let add_sub_mul_v_comparisons =
-      FStar_Compiler_Effect.op_Bar_Greater
-        (FStar_Compiler_List.op_At bounded_signed_int_types
-           bounded_unsigned_int_types)
-        (FStar_Compiler_List.collect
-           (fun uu___ ->
-              match uu___ with
-              | (m, uu___1) ->
-                  let uu___2 =
-                    let uu___3 = FStar_Parser_Const.p2l ["FStar"; m; "add"] in
-                    let uu___4 =
-                      FStar_TypeChecker_NBETerm.binary_op
-                        FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                        (fun uu___5 ->
-                           fun uu___6 ->
-                             match (uu___5, uu___6) with
-                             | ((int_to_t, x, m1), (uu___7, y, uu___8)) ->
-                                 let uu___9 =
-                                   let uu___10 = FStar_BigInt.add_big_int x y in
-                                   FStar_TypeChecker_NBETerm.int_as_bounded
-                                     int_to_t uu___10 in
-                                 FStar_TypeChecker_NBETerm.with_meta_ds
-                                   uu___9 m1) in
-                    (uu___3, (Prims.of_int (2)), Prims.int_zero,
-                      (binary_op arg_as_bounded_int
-                         (fun r ->
-                            fun uu___5 ->
-                              fun uu___6 ->
-                                match (uu___5, uu___6) with
-                                | ((int_to_t, x, m1), (uu___7, y, uu___8)) ->
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_BigInt.add_big_int x y in
-                                      int_as_bounded r int_to_t uu___10 in
-                                    with_meta_ds r uu___9 m1)), uu___4) in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = FStar_Parser_Const.p2l ["FStar"; m; "sub"] in
-                      let uu___6 =
-                        FStar_TypeChecker_NBETerm.binary_op
-                          FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                          (fun uu___7 ->
-                             fun uu___8 ->
-                               match (uu___7, uu___8) with
-                               | ((int_to_t, x, m1), (uu___9, y, uu___10)) ->
-                                   let uu___11 =
-                                     let uu___12 =
-                                       FStar_BigInt.sub_big_int x y in
-                                     FStar_TypeChecker_NBETerm.int_as_bounded
-                                       int_to_t uu___12 in
-                                   FStar_TypeChecker_NBETerm.with_meta_ds
-                                     uu___11 m1) in
-                      (uu___5, (Prims.of_int (2)), Prims.int_zero,
-                        (binary_op arg_as_bounded_int
-                           (fun r ->
-                              fun uu___7 ->
-                                fun uu___8 ->
-                                  match (uu___7, uu___8) with
-                                  | ((int_to_t, x, m1), (uu___9, y, uu___10))
-                                      ->
-                                      let uu___11 =
-                                        let uu___12 =
-                                          FStar_BigInt.sub_big_int x y in
-                                        int_as_bounded r int_to_t uu___12 in
-                                      with_meta_ds r uu___11 m1)), uu___6) in
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          FStar_Parser_Const.p2l ["FStar"; m; "mul"] in
-                        let uu___8 =
-                          FStar_TypeChecker_NBETerm.binary_op
-                            FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                            (fun uu___9 ->
-                               fun uu___10 ->
-                                 match (uu___9, uu___10) with
-                                 | ((int_to_t, x, m1), (uu___11, y, uu___12))
-                                     ->
-                                     let uu___13 =
-                                       let uu___14 =
-                                         FStar_BigInt.mult_big_int x y in
-                                       FStar_TypeChecker_NBETerm.int_as_bounded
-                                         int_to_t uu___14 in
-                                     FStar_TypeChecker_NBETerm.with_meta_ds
-                                       uu___13 m1) in
-                        (uu___7, (Prims.of_int (2)), Prims.int_zero,
-                          (binary_op arg_as_bounded_int
-                             (fun r ->
-                                fun uu___9 ->
-                                  fun uu___10 ->
-                                    match (uu___9, uu___10) with
-                                    | ((int_to_t, x, m1),
-                                       (uu___11, y, uu___12)) ->
-                                        let uu___13 =
-                                          let uu___14 =
-                                            FStar_BigInt.mult_big_int x y in
-                                          int_as_bounded r int_to_t uu___14 in
-                                        with_meta_ds r uu___13 m1)), uu___8) in
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            FStar_Parser_Const.p2l ["FStar"; m; "v"] in
-                          let uu___10 =
-                            FStar_TypeChecker_NBETerm.unary_op
-                              FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                              (fun uu___11 ->
-                                 match uu___11 with
-                                 | (int_to_t, x, m1) ->
-                                     let uu___12 =
-                                       FStar_TypeChecker_NBETerm.embed
-                                         FStar_TypeChecker_NBETerm.e_int
-                                         bogus_cbs x in
-                                     FStar_TypeChecker_NBETerm.with_meta_ds
-                                       uu___12 m1) in
-                          (uu___9, Prims.int_one, Prims.int_zero,
-                            (unary_op arg_as_bounded_int
-                               (fun r ->
-                                  fun uu___11 ->
-                                    match uu___11 with
-                                    | (int_to_t, x, m1) ->
-                                        let uu___12 =
-                                          embed_simple
-                                            FStar_Syntax_Embeddings.e_int r x in
-                                        with_meta_ds r uu___12 m1)), uu___10) in
-                        let uu___9 =
-                          let uu___10 =
-                            let uu___11 =
-                              FStar_Parser_Const.p2l ["FStar"; m; "gt"] in
-                            let uu___12 =
-                              FStar_TypeChecker_NBETerm.binary_op
-                                FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                (fun uu___13 ->
-                                   fun uu___14 ->
-                                     match (uu___13, uu___14) with
-                                     | ((int_to_t, x, m1),
-                                        (uu___15, y, uu___16)) ->
-                                         let uu___17 =
-                                           let uu___18 =
-                                             FStar_BigInt.gt_big_int x y in
-                                           FStar_TypeChecker_NBETerm.embed
-                                             FStar_TypeChecker_NBETerm.e_bool
-                                             bogus_cbs uu___18 in
-                                         FStar_TypeChecker_NBETerm.with_meta_ds
-                                           uu___17 m1) in
-                            (uu___11, (Prims.of_int (2)), Prims.int_zero,
-                              (binary_op arg_as_bounded_int
-                                 (fun r ->
-                                    fun uu___13 ->
-                                      fun uu___14 ->
-                                        match (uu___13, uu___14) with
-                                        | ((int_to_t, x, m1),
-                                           (uu___15, y, uu___16)) ->
-                                            let uu___17 =
-                                              let uu___18 =
-                                                FStar_BigInt.gt_big_int x y in
-                                              embed_simple
-                                                FStar_Syntax_Embeddings.e_bool
-                                                r uu___18 in
-                                            with_meta_ds r uu___17 m1)),
-                              uu___12) in
-                          let uu___11 =
-                            let uu___12 =
-                              let uu___13 =
-                                FStar_Parser_Const.p2l ["FStar"; m; "gte"] in
-                              let uu___14 =
-                                FStar_TypeChecker_NBETerm.binary_op
-                                  FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                  (fun uu___15 ->
-                                     fun uu___16 ->
-                                       match (uu___15, uu___16) with
-                                       | ((int_to_t, x, m1),
-                                          (uu___17, y, uu___18)) ->
-                                           let uu___19 =
-                                             let uu___20 =
-                                               FStar_BigInt.ge_big_int x y in
-                                             FStar_TypeChecker_NBETerm.embed
-                                               FStar_TypeChecker_NBETerm.e_bool
-                                               bogus_cbs uu___20 in
-                                           FStar_TypeChecker_NBETerm.with_meta_ds
-                                             uu___19 m1) in
-                              (uu___13, (Prims.of_int (2)), Prims.int_zero,
-                                (binary_op arg_as_bounded_int
-                                   (fun r ->
-                                      fun uu___15 ->
-                                        fun uu___16 ->
-                                          match (uu___15, uu___16) with
-                                          | ((int_to_t, x, m1),
-                                             (uu___17, y, uu___18)) ->
-                                              let uu___19 =
-                                                let uu___20 =
-                                                  FStar_BigInt.ge_big_int x y in
-                                                embed_simple
-                                                  FStar_Syntax_Embeddings.e_bool
-                                                  r uu___20 in
-                                              with_meta_ds r uu___19 m1)),
-                                uu___14) in
-                            let uu___13 =
-                              let uu___14 =
-                                let uu___15 =
-                                  FStar_Parser_Const.p2l ["FStar"; m; "lt"] in
-                                let uu___16 =
-                                  FStar_TypeChecker_NBETerm.binary_op
-                                    FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                    (fun uu___17 ->
-                                       fun uu___18 ->
-                                         match (uu___17, uu___18) with
-                                         | ((int_to_t, x, m1),
-                                            (uu___19, y, uu___20)) ->
-                                             let uu___21 =
-                                               let uu___22 =
-                                                 FStar_BigInt.lt_big_int x y in
-                                               FStar_TypeChecker_NBETerm.embed
-                                                 FStar_TypeChecker_NBETerm.e_bool
-                                                 bogus_cbs uu___22 in
-                                             FStar_TypeChecker_NBETerm.with_meta_ds
-                                               uu___21 m1) in
-                                (uu___15, (Prims.of_int (2)), Prims.int_zero,
-                                  (binary_op arg_as_bounded_int
-                                     (fun r ->
-                                        fun uu___17 ->
-                                          fun uu___18 ->
-                                            match (uu___17, uu___18) with
-                                            | ((int_to_t, x, m1),
-                                               (uu___19, y, uu___20)) ->
-                                                let uu___21 =
-                                                  let uu___22 =
-                                                    FStar_BigInt.lt_big_int x
-                                                      y in
-                                                  embed_simple
-                                                    FStar_Syntax_Embeddings.e_bool
-                                                    r uu___22 in
-                                                with_meta_ds r uu___21 m1)),
-                                  uu___16) in
-                              let uu___15 =
-                                let uu___16 =
-                                  let uu___17 =
-                                    FStar_Parser_Const.p2l
-                                      ["FStar"; m; "lte"] in
-                                  let uu___18 =
-                                    FStar_TypeChecker_NBETerm.binary_op
-                                      FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                      (fun uu___19 ->
-                                         fun uu___20 ->
-                                           match (uu___19, uu___20) with
-                                           | ((int_to_t, x, m1),
-                                              (uu___21, y, uu___22)) ->
-                                               let uu___23 =
-                                                 let uu___24 =
-                                                   FStar_BigInt.le_big_int x
-                                                     y in
-                                                 FStar_TypeChecker_NBETerm.embed
-                                                   FStar_TypeChecker_NBETerm.e_bool
-                                                   bogus_cbs uu___24 in
-                                               FStar_TypeChecker_NBETerm.with_meta_ds
-                                                 uu___23 m1) in
-                                  (uu___17, (Prims.of_int (2)),
-                                    Prims.int_zero,
-                                    (binary_op arg_as_bounded_int
-                                       (fun r ->
-                                          fun uu___19 ->
-                                            fun uu___20 ->
-                                              match (uu___19, uu___20) with
-                                              | ((int_to_t, x, m1),
-                                                 (uu___21, y, uu___22)) ->
-                                                  let uu___23 =
-                                                    let uu___24 =
-                                                      FStar_BigInt.le_big_int
-                                                        x y in
-                                                    embed_simple
-                                                      FStar_Syntax_Embeddings.e_bool
-                                                      r uu___24 in
-                                                  with_meta_ds r uu___23 m1)),
-                                    uu___18) in
-                                [uu___16] in
-                              uu___14 :: uu___15 in
-                            uu___12 :: uu___13 in
-                          uu___10 :: uu___11 in
-                        uu___8 :: uu___9 in
-                      uu___6 :: uu___7 in
-                    uu___4 :: uu___5 in
-                  uu___2 :: uu___3)) in
-    let unsigned_modulo_add_sub_mul_div_rem =
-      FStar_Compiler_Effect.op_Bar_Greater bounded_unsigned_int_types
-        (FStar_Compiler_List.collect
-           (fun uu___ ->
-              match uu___ with
-              | (m, sz) ->
-                  let modulus =
-                    let uu___1 = FStar_BigInt.of_int_fs sz in
-                    FStar_BigInt.shift_left_big_int FStar_BigInt.one uu___1 in
-                  let mod1 x = FStar_BigInt.mod_big_int x modulus in
-                  let uu___1 =
-                    if sz = (Prims.of_int (128))
-                    then []
-                    else
-                      (let uu___3 =
-                         let uu___4 =
-                           FStar_Parser_Const.p2l ["FStar"; m; "mul_mod"] in
-                         let uu___5 =
-                           FStar_TypeChecker_NBETerm.binary_op
-                             FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                             (fun uu___6 ->
-                                fun uu___7 ->
-                                  match (uu___6, uu___7) with
-                                  | ((int_to_t, x, m1), (uu___8, y, uu___9))
-                                      ->
-                                      let uu___10 =
-                                        let uu___11 =
-                                          let uu___12 =
-                                            FStar_BigInt.mult_big_int x y in
-                                          mod1 uu___12 in
-                                        FStar_TypeChecker_NBETerm.int_as_bounded
-                                          int_to_t uu___11 in
-                                      FStar_TypeChecker_NBETerm.with_meta_ds
-                                        uu___10 m1) in
-                         (uu___4, (Prims.of_int (2)), Prims.int_zero,
-                           (binary_op arg_as_bounded_int
-                              (fun r ->
-                                 fun uu___6 ->
-                                   fun uu___7 ->
-                                     match (uu___6, uu___7) with
-                                     | ((int_to_t, x, m1),
-                                        (uu___8, y, uu___9)) ->
-                                         let uu___10 =
-                                           let uu___11 =
-                                             let uu___12 =
-                                               FStar_BigInt.mult_big_int x y in
-                                             mod1 uu___12 in
-                                           int_as_bounded r int_to_t uu___11 in
-                                         with_meta_ds r uu___10 m1)), uu___5) in
-                       [uu___3]) in
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Parser_Const.p2l ["FStar"; m; "add_mod"] in
-                      let uu___5 =
-                        FStar_TypeChecker_NBETerm.binary_op
-                          FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                          (fun uu___6 ->
-                             fun uu___7 ->
-                               match (uu___6, uu___7) with
-                               | ((int_to_t, x, m1), (uu___8, y, uu___9)) ->
-                                   let uu___10 =
-                                     let uu___11 =
-                                       let uu___12 =
-                                         FStar_BigInt.add_big_int x y in
-                                       mod1 uu___12 in
-                                     FStar_TypeChecker_NBETerm.int_as_bounded
-                                       int_to_t uu___11 in
-                                   FStar_TypeChecker_NBETerm.with_meta_ds
-                                     uu___10 m1) in
-                      (uu___4, (Prims.of_int (2)), Prims.int_zero,
-                        (binary_op arg_as_bounded_int
-                           (fun r ->
-                              fun uu___6 ->
-                                fun uu___7 ->
-                                  match (uu___6, uu___7) with
-                                  | ((int_to_t, x, m1), (uu___8, y, uu___9))
-                                      ->
-                                      let uu___10 =
-                                        let uu___11 =
-                                          let uu___12 =
-                                            FStar_BigInt.add_big_int x y in
-                                          mod1 uu___12 in
-                                        int_as_bounded r int_to_t uu___11 in
-                                      with_meta_ds r uu___10 m1)), uu___5) in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Parser_Const.p2l ["FStar"; m; "sub_mod"] in
-                        let uu___7 =
-                          FStar_TypeChecker_NBETerm.binary_op
-                            FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                            (fun uu___8 ->
-                               fun uu___9 ->
-                                 match (uu___8, uu___9) with
-                                 | ((int_to_t, x, m1), (uu___10, y, uu___11))
-                                     ->
-                                     let uu___12 =
-                                       let uu___13 =
-                                         let uu___14 =
-                                           FStar_BigInt.sub_big_int x y in
-                                         mod1 uu___14 in
-                                       FStar_TypeChecker_NBETerm.int_as_bounded
-                                         int_to_t uu___13 in
-                                     FStar_TypeChecker_NBETerm.with_meta_ds
-                                       uu___12 m1) in
-                        (uu___6, (Prims.of_int (2)), Prims.int_zero,
-                          (binary_op arg_as_bounded_int
-                             (fun r ->
-                                fun uu___8 ->
-                                  fun uu___9 ->
-                                    match (uu___8, uu___9) with
-                                    | ((int_to_t, x, m1),
-                                       (uu___10, y, uu___11)) ->
-                                        let uu___12 =
-                                          let uu___13 =
-                                            let uu___14 =
-                                              FStar_BigInt.sub_big_int x y in
-                                            mod1 uu___14 in
-                                          int_as_bounded r int_to_t uu___13 in
-                                        with_meta_ds r uu___12 m1)), uu___7) in
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            FStar_Parser_Const.p2l ["FStar"; m; "div"] in
-                          let uu___9 =
-                            FStar_TypeChecker_NBETerm.binary_op
-                              FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                              (fun uu___10 ->
-                                 fun uu___11 ->
-                                   match (uu___10, uu___11) with
-                                   | ((int_to_t, x, m1),
-                                      (uu___12, y, uu___13)) ->
-                                       let uu___14 =
-                                         let uu___15 =
-                                           FStar_BigInt.div_big_int x y in
-                                         FStar_TypeChecker_NBETerm.int_as_bounded
-                                           int_to_t uu___15 in
-                                       FStar_TypeChecker_NBETerm.with_meta_ds
-                                         uu___14 m1) in
-                          (uu___8, (Prims.of_int (2)), Prims.int_zero,
-                            (binary_op arg_as_bounded_int
-                               (fun r ->
-                                  fun uu___10 ->
-                                    fun uu___11 ->
-                                      match (uu___10, uu___11) with
-                                      | ((int_to_t, x, m1),
-                                         (uu___12, y, uu___13)) ->
-                                          let uu___14 =
-                                            let uu___15 =
-                                              FStar_BigInt.div_big_int x y in
-                                            int_as_bounded r int_to_t uu___15 in
-                                          with_meta_ds r uu___14 m1)),
-                            uu___9) in
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 =
-                              FStar_Parser_Const.p2l ["FStar"; m; "rem"] in
-                            let uu___11 =
-                              FStar_TypeChecker_NBETerm.binary_op
-                                FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                (fun uu___12 ->
-                                   fun uu___13 ->
-                                     match (uu___12, uu___13) with
-                                     | ((int_to_t, x, m1),
-                                        (uu___14, y, uu___15)) ->
-                                         let uu___16 =
-                                           let uu___17 =
-                                             FStar_BigInt.mod_big_int x y in
-                                           FStar_TypeChecker_NBETerm.int_as_bounded
-                                             int_to_t uu___17 in
-                                         FStar_TypeChecker_NBETerm.with_meta_ds
-                                           uu___16 m1) in
-                            (uu___10, (Prims.of_int (2)), Prims.int_zero,
-                              (binary_op arg_as_bounded_int
-                                 (fun r ->
-                                    fun uu___12 ->
-                                      fun uu___13 ->
-                                        match (uu___12, uu___13) with
-                                        | ((int_to_t, x, m1),
-                                           (uu___14, y, uu___15)) ->
-                                            let uu___16 =
-                                              let uu___17 =
-                                                FStar_BigInt.mod_big_int x y in
-                                              int_as_bounded r int_to_t
-                                                uu___17 in
-                                            with_meta_ds r uu___16 m1)),
-                              uu___11) in
-                          [uu___9] in
-                        uu___7 :: uu___8 in
-                      uu___5 :: uu___6 in
-                    uu___3 :: uu___4 in
-                  FStar_Compiler_List.op_At uu___1 uu___2)) in
-    let mask m =
-      match m with
-      | "UInt8" -> FStar_BigInt.of_hex "ff"
-      | "UInt16" -> FStar_BigInt.of_hex "ffff"
-      | "UInt32" -> FStar_BigInt.of_hex "ffffffff"
-      | "UInt64" -> FStar_BigInt.of_hex "ffffffffffffffff"
-      | "UInt128" -> FStar_BigInt.of_hex "ffffffffffffffffffffffffffffffff"
-      | uu___ ->
-          let uu___1 =
-            FStar_Compiler_Util.format1
-              "Impossible: bad string on mask: %s\n" m in
-          failwith uu___1 in
-    let bitwise =
-      FStar_Compiler_Effect.op_Bar_Greater bounded_unsigned_int_types
-        (FStar_Compiler_List.collect
-           (fun uu___ ->
-              match uu___ with
-              | (m, uu___1) ->
-                  let uu___2 =
-                    let uu___3 = FStar_Parser_Const.p2l ["FStar"; m; "logor"] in
-                    let uu___4 =
-                      FStar_TypeChecker_NBETerm.binary_op
-                        FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                        (fun uu___5 ->
-                           fun uu___6 ->
-                             match (uu___5, uu___6) with
-                             | ((int_to_t, x, m1), (uu___7, y, uu___8)) ->
-                                 let uu___9 =
-                                   let uu___10 =
-                                     FStar_BigInt.logor_big_int x y in
-                                   FStar_TypeChecker_NBETerm.int_as_bounded
-                                     int_to_t uu___10 in
-                                 FStar_TypeChecker_NBETerm.with_meta_ds
-                                   uu___9 m1) in
-                    (uu___3, (Prims.of_int (2)), Prims.int_zero,
-                      (binary_op arg_as_bounded_int
-                         (fun r ->
-                            fun uu___5 ->
-                              fun uu___6 ->
-                                match (uu___5, uu___6) with
-                                | ((int_to_t, x, m1), (uu___7, y, uu___8)) ->
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_BigInt.logor_big_int x y in
-                                      int_as_bounded r int_to_t uu___10 in
-                                    with_meta_ds r uu___9 m1)), uu___4) in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_Parser_Const.p2l ["FStar"; m; "logand"] in
-                      let uu___6 =
-                        FStar_TypeChecker_NBETerm.binary_op
-                          FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                          (fun uu___7 ->
-                             fun uu___8 ->
-                               match (uu___7, uu___8) with
-                               | ((int_to_t, x, m1), (uu___9, y, uu___10)) ->
-                                   let uu___11 =
-                                     let uu___12 =
-                                       FStar_BigInt.logand_big_int x y in
-                                     FStar_TypeChecker_NBETerm.int_as_bounded
-                                       int_to_t uu___12 in
-                                   FStar_TypeChecker_NBETerm.with_meta_ds
-                                     uu___11 m1) in
-                      (uu___5, (Prims.of_int (2)), Prims.int_zero,
-                        (binary_op arg_as_bounded_int
-                           (fun r ->
-                              fun uu___7 ->
-                                fun uu___8 ->
-                                  match (uu___7, uu___8) with
-                                  | ((int_to_t, x, m1), (uu___9, y, uu___10))
-                                      ->
-                                      let uu___11 =
-                                        let uu___12 =
-                                          FStar_BigInt.logand_big_int x y in
-                                        int_as_bounded r int_to_t uu___12 in
-                                      with_meta_ds r uu___11 m1)), uu___6) in
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          FStar_Parser_Const.p2l ["FStar"; m; "logxor"] in
-                        let uu___8 =
-                          FStar_TypeChecker_NBETerm.binary_op
-                            FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                            (fun uu___9 ->
-                               fun uu___10 ->
-                                 match (uu___9, uu___10) with
-                                 | ((int_to_t, x, m1), (uu___11, y, uu___12))
-                                     ->
-                                     let uu___13 =
-                                       let uu___14 =
-                                         FStar_BigInt.logxor_big_int x y in
-                                       FStar_TypeChecker_NBETerm.int_as_bounded
-                                         int_to_t uu___14 in
-                                     FStar_TypeChecker_NBETerm.with_meta_ds
-                                       uu___13 m1) in
-                        (uu___7, (Prims.of_int (2)), Prims.int_zero,
-                          (binary_op arg_as_bounded_int
-                             (fun r ->
-                                fun uu___9 ->
-                                  fun uu___10 ->
-                                    match (uu___9, uu___10) with
-                                    | ((int_to_t, x, m1),
-                                       (uu___11, y, uu___12)) ->
-                                        let uu___13 =
-                                          let uu___14 =
-                                            FStar_BigInt.logxor_big_int x y in
-                                          int_as_bounded r int_to_t uu___14 in
-                                        with_meta_ds r uu___13 m1)), uu___8) in
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 =
-                            FStar_Parser_Const.p2l ["FStar"; m; "lognot"] in
-                          let uu___10 =
-                            FStar_TypeChecker_NBETerm.unary_op
-                              FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                              (fun uu___11 ->
-                                 match uu___11 with
-                                 | (int_to_t, x, d) ->
-                                     let uu___12 =
-                                       let uu___13 =
-                                         let uu___14 =
-                                           FStar_BigInt.lognot_big_int x in
-                                         let uu___15 = mask m in
-                                         FStar_BigInt.logand_big_int uu___14
-                                           uu___15 in
-                                       FStar_TypeChecker_NBETerm.int_as_bounded
-                                         int_to_t uu___13 in
-                                     FStar_TypeChecker_NBETerm.with_meta_ds
-                                       uu___12 d) in
-                          (uu___9, Prims.int_one, Prims.int_zero,
-                            (unary_op arg_as_bounded_int
-                               (fun r ->
-                                  fun uu___11 ->
-                                    match uu___11 with
-                                    | (int_to_t, x, d) ->
-                                        let uu___12 =
-                                          let uu___13 =
-                                            let uu___14 =
-                                              FStar_BigInt.lognot_big_int x in
-                                            let uu___15 = mask m in
-                                            FStar_BigInt.logand_big_int
-                                              uu___14 uu___15 in
-                                          int_as_bounded r int_to_t uu___13 in
-                                        with_meta_ds r uu___12 d)), uu___10) in
-                        let uu___9 =
-                          let uu___10 =
-                            let uu___11 =
-                              FStar_Parser_Const.p2l
-                                ["FStar"; m; "shift_left"] in
-                            let uu___12 =
-                              FStar_TypeChecker_NBETerm.binary_op
-                                FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                (fun uu___13 ->
-                                   fun uu___14 ->
-                                     match (uu___13, uu___14) with
-                                     | ((int_to_t, x, d),
-                                        (uu___15, y, uu___16)) ->
-                                         let uu___17 =
-                                           let uu___18 =
-                                             let uu___19 =
-                                               FStar_BigInt.shift_left_big_int
-                                                 x y in
-                                             let uu___20 = mask m in
-                                             FStar_BigInt.logand_big_int
-                                               uu___19 uu___20 in
-                                           FStar_TypeChecker_NBETerm.int_as_bounded
-                                             int_to_t uu___18 in
-                                         FStar_TypeChecker_NBETerm.with_meta_ds
-                                           uu___17 d) in
-                            (uu___11, (Prims.of_int (2)), Prims.int_zero,
-                              (binary_op arg_as_bounded_int
-                                 (fun r ->
-                                    fun uu___13 ->
-                                      fun uu___14 ->
-                                        match (uu___13, uu___14) with
-                                        | ((int_to_t, x, d),
-                                           (uu___15, y, uu___16)) ->
-                                            let uu___17 =
-                                              let uu___18 =
-                                                let uu___19 =
-                                                  FStar_BigInt.shift_left_big_int
-                                                    x y in
-                                                let uu___20 = mask m in
-                                                FStar_BigInt.logand_big_int
-                                                  uu___19 uu___20 in
-                                              int_as_bounded r int_to_t
-                                                uu___18 in
-                                            with_meta_ds r uu___17 d)),
-                              uu___12) in
-                          let uu___11 =
-                            let uu___12 =
-                              let uu___13 =
-                                FStar_Parser_Const.p2l
-                                  ["FStar"; m; "shift_right"] in
-                              let uu___14 =
-                                FStar_TypeChecker_NBETerm.binary_op
-                                  FStar_TypeChecker_NBETerm.arg_as_bounded_int
-                                  (fun uu___15 ->
-                                     fun uu___16 ->
-                                       match (uu___15, uu___16) with
-                                       | ((int_to_t, x, d),
-                                          (uu___17, y, uu___18)) ->
-                                           let uu___19 =
-                                             let uu___20 =
-                                               FStar_BigInt.shift_right_big_int
-                                                 x y in
-                                             FStar_TypeChecker_NBETerm.int_as_bounded
-                                               int_to_t uu___20 in
-                                           FStar_TypeChecker_NBETerm.with_meta_ds
-                                             uu___19 d) in
-                              (uu___13, (Prims.of_int (2)), Prims.int_zero,
-                                (binary_op arg_as_bounded_int
-                                   (fun r ->
-                                      fun uu___15 ->
-                                        fun uu___16 ->
-                                          match (uu___15, uu___16) with
-                                          | ((int_to_t, x, d),
-                                             (uu___17, y, uu___18)) ->
-                                              let uu___19 =
-                                                let uu___20 =
-                                                  FStar_BigInt.shift_right_big_int
-                                                    x y in
-                                                int_as_bounded r int_to_t
-                                                  uu___20 in
-                                              with_meta_ds r uu___19 d)),
-                                uu___14) in
-                            [uu___12] in
-                          uu___10 :: uu___11 in
-                        uu___8 :: uu___9 in
-                      uu___6 :: uu___7 in
-                    uu___4 :: uu___5 in
-                  uu___2 :: uu___3)) in
-    FStar_Compiler_List.op_At add_sub_mul_v_comparisons
-      (FStar_Compiler_List.op_At unsigned_modulo_add_sub_mul_div_rem bitwise) in
-  let reveal_hide =
-    (FStar_Parser_Const.reveal, (Prims.of_int (2)), Prims.int_one,
-      (mixed_binary_op (fun x -> FStar_Pervasives_Native.Some x)
-         (fun uu___ ->
-            match uu___ with
-            | (x, uu___1) ->
-                let uu___2 = FStar_Syntax_Util.head_and_args x in
-                (match uu___2 with
-                 | (head, args) ->
-                     let uu___3 =
-                       FStar_Syntax_Util.is_fvar FStar_Parser_Const.hide head in
-                     if uu___3
-                     then
-                       (match args with
-                        | _t::(body, uu___4)::[] ->
-                            FStar_Pervasives_Native.Some body
-                        | uu___4 -> FStar_Pervasives_Native.None)
-                     else FStar_Pervasives_Native.None))
-         (fun r -> fun body -> body)
-         (fun r ->
-            fun _us ->
-              fun _t -> fun body -> FStar_Pervasives_Native.Some body)),
-      (FStar_TypeChecker_NBETerm.mixed_binary_op
-         (fun x -> FStar_Pervasives_Native.Some x)
-         (fun uu___ ->
-            match uu___ with
-            | (x, uu___1) ->
-                let uu___2 = FStar_TypeChecker_NBETerm.nbe_t_of_t x in
-                (match uu___2 with
-                 | FStar_TypeChecker_NBETerm.FV
-                     (fv, uu___3, (_t, uu___4)::(body, uu___5)::[]) when
-                     FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.hide
-                     -> FStar_Pervasives_Native.Some body
-                 | uu___3 -> FStar_Pervasives_Native.None))
-         (fun body -> body)
-         (fun _us -> fun _t -> fun body -> FStar_Pervasives_Native.Some body))) in
-  let array_ops =
-    let of_list_op =
-      let emb_typ t =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              FStar_Parser_Const.immutable_array_t_lid
-              FStar_Ident.string_of_lid in
-          (uu___1, [t]) in
-        FStar_Syntax_Syntax.ET_app uu___ in
-      let un_lazy universes t l r =
-        let uu___ =
-          let uu___1 =
-            FStar_Syntax_Util.fvar_const
-              FStar_Parser_Const.immutable_array_of_list_lid in
-          FStar_Syntax_Syntax.mk_Tm_uinst uu___1 universes in
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Syntax.iarg t in
-          let uu___3 = let uu___4 = FStar_Syntax_Syntax.as_arg l in [uu___4] in
-          uu___2 :: uu___3 in
-        FStar_Syntax_Syntax.mk_Tm_app uu___ uu___1 r in
-      (FStar_Parser_Const.immutable_array_of_list_lid, (Prims.of_int (2)),
-        Prims.int_one,
-        (mixed_binary_op
-           (fun uu___ ->
-              match uu___ with
-              | (elt_t, uu___1) -> FStar_Pervasives_Native.Some elt_t)
-           (fun uu___ ->
-              match uu___ with
-              | (l, q) ->
-                  let uu___1 =
-                    arg_as_list FStar_Syntax_Embeddings.e_any (l, q) in
-                  (match uu___1 with
-                   | FStar_Pervasives_Native.Some lst ->
-                       FStar_Pervasives_Native.Some (l, lst)
-                   | uu___2 -> FStar_Pervasives_Native.None))
-           (fun r ->
-              fun uu___ ->
-                match uu___ with
-                | (universes, elt_t, (l, blob)) ->
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Syntax_Embeddings.emb_typ_of
-                                  FStar_Syntax_Embeddings.e_any in
-                              emb_typ uu___6 in
-                            let uu___6 =
-                              FStar_Thunk.mk
-                                (fun uu___7 -> un_lazy universes elt_t l r) in
-                            (uu___5, uu___6) in
-                          FStar_Syntax_Syntax.Lazy_embedding uu___4 in
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Syntax_Util.fvar_const
-                                FStar_Parser_Const.immutable_array_t_lid in
-                            FStar_Syntax_Syntax.mk_Tm_uinst uu___6 universes in
-                          let uu___6 =
-                            let uu___7 = FStar_Syntax_Syntax.as_arg elt_t in
-                            [uu___7] in
-                          FStar_Syntax_Syntax.mk_Tm_app uu___5 uu___6 r in
-                        {
-                          FStar_Syntax_Syntax.blob = blob;
-                          FStar_Syntax_Syntax.lkind = uu___3;
-                          FStar_Syntax_Syntax.ltyp = uu___4;
-                          FStar_Syntax_Syntax.rng = r
-                        } in
-                      FStar_Syntax_Syntax.Tm_lazy uu___2 in
-                    FStar_Syntax_Syntax.mk uu___1 r)
-           (fun r ->
-              fun universes ->
-                fun elt_t ->
-                  fun uu___ ->
-                    match uu___ with
-                    | (l, lst) ->
-                        let blob = FStar_ImmutableArray_Base.of_list lst in
-                        let uu___1 =
-                          let uu___2 =
-                            let uu___3 = FStar_Compiler_Dyn.mkdyn blob in
-                            (l, uu___3) in
-                          (universes, elt_t, uu___2) in
-                        FStar_Pervasives_Native.Some uu___1)),
-        (FStar_TypeChecker_NBETerm.mixed_binary_op
-           (fun uu___ ->
-              match uu___ with
-              | (elt_t, uu___1) -> FStar_Pervasives_Native.Some elt_t)
-           (fun uu___ ->
-              match uu___ with
-              | (l, q) ->
-                  let uu___1 =
-                    FStar_TypeChecker_NBETerm.arg_as_list
-                      FStar_TypeChecker_NBETerm.e_any (l, q) in
-                  (match uu___1 with
-                   | FStar_Pervasives_Native.None ->
-                       FStar_Pervasives_Native.None
-                   | FStar_Pervasives_Native.Some lst ->
-                       FStar_Pervasives_Native.Some (l, lst)))
-           (fun uu___ ->
-              match uu___ with
-              | (universes, elt_t, (l, blob)) ->
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Syntax_Embeddings.emb_typ_of
-                                FStar_Syntax_Embeddings.e_any in
-                            emb_typ uu___6 in
-                          (blob, uu___5) in
-                        FStar_Pervasives.Inr uu___4 in
-                      let uu___4 =
-                        FStar_Thunk.mk
-                          (fun uu___5 ->
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Syntax_Syntax.lid_as_fv
-                                     FStar_Parser_Const.immutable_array_of_list_lid
-                                     FStar_Syntax_Syntax.delta_constant
-                                     FStar_Pervasives_Native.None in
-                                 let uu___9 =
-                                   let uu___10 =
-                                     FStar_TypeChecker_NBETerm.as_arg l in
-                                   [uu___10] in
-                                 (uu___8, universes, uu___9) in
-                               FStar_TypeChecker_NBETerm.FV uu___7 in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               FStar_TypeChecker_NBETerm.mk_t uu___6) in
-                      (uu___3, uu___4) in
-                    FStar_TypeChecker_NBETerm.Lazy uu___2 in
-                  FStar_Compiler_Effect.op_Less_Bar
-                    FStar_TypeChecker_NBETerm.mk_t uu___1)
-           (fun universes ->
-              fun elt_t ->
-                fun uu___ ->
-                  match uu___ with
-                  | (l, lst) ->
-                      let blob = FStar_ImmutableArray_Base.of_list lst in
-                      let uu___1 =
-                        let uu___2 =
-                          let uu___3 = FStar_Compiler_Dyn.mkdyn blob in
-                          (l, uu___3) in
-                        (universes, elt_t, uu___2) in
-                      FStar_Pervasives_Native.Some uu___1))) in
-    let arg1_as_elt_t x =
-      FStar_Pervasives_Native.Some (FStar_Pervasives_Native.fst x) in
-    let arg2_as_blob x =
-      let uu___ =
-        let uu___1 =
-          FStar_Syntax_Subst.compress (FStar_Pervasives_Native.fst x) in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_lazy
-          { FStar_Syntax_Syntax.blob = blob;
-            FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_embedding
-              (FStar_Syntax_Syntax.ET_app (head, uu___1), uu___2);
-            FStar_Syntax_Syntax.ltyp = uu___3;
-            FStar_Syntax_Syntax.rng = uu___4;_}
-          when
-          let uu___5 =
-            FStar_Ident.string_of_lid
-              FStar_Parser_Const.immutable_array_t_lid in
-          head = uu___5 -> FStar_Pervasives_Native.Some blob
-      | uu___1 -> FStar_Pervasives_Native.None in
-    let arg2_as_blob_nbe x =
-      match (FStar_Pervasives_Native.fst x).FStar_TypeChecker_NBETerm.nbe_t
-      with
-      | FStar_TypeChecker_NBETerm.Lazy
-          (FStar_Pervasives.Inr
-           (blob, FStar_Syntax_Syntax.ET_app (head, uu___)), uu___1)
-          when
-          let uu___2 =
-            FStar_Ident.string_of_lid
-              FStar_Parser_Const.immutable_array_t_lid in
-          head = uu___2 -> FStar_Pervasives_Native.Some blob
-      | uu___ -> FStar_Pervasives_Native.None in
-    let length_op =
-      let embed_int r i = embed_simple FStar_Syntax_Embeddings.e_int r i in
-      let run_op blob =
-        let uu___ =
-          let uu___1 = FStar_Compiler_Dyn.undyn blob in
-          FStar_Compiler_Util.array_length uu___1 in
-        FStar_Pervasives_Native.Some uu___ in
-      (FStar_Parser_Const.immutable_array_length_lid, (Prims.of_int (2)),
-        Prims.int_one,
-        (mixed_binary_op arg1_as_elt_t arg2_as_blob embed_int
-           (fun _r -> fun _universes -> fun uu___ -> fun blob -> run_op blob)),
-        (FStar_TypeChecker_NBETerm.mixed_binary_op
-           (fun uu___ ->
-              match uu___ with
-              | (elt_t, uu___1) -> FStar_Pervasives_Native.Some elt_t)
-           arg2_as_blob_nbe
-           (fun i ->
-              FStar_TypeChecker_NBETerm.embed FStar_TypeChecker_NBETerm.e_int
-                bogus_cbs i)
-           (fun _universes -> fun uu___ -> fun blob -> run_op blob))) in
-    let index_op =
-      (FStar_Parser_Const.immutable_array_index_lid, (Prims.of_int (3)),
-        Prims.int_one,
-        (mixed_ternary_op arg1_as_elt_t arg2_as_blob arg_as_int
-           (fun r -> fun tm -> tm)
-           (fun r ->
-              fun _universes ->
-                fun _t ->
-                  fun blob ->
-                    fun i ->
-                      let uu___ =
-                        let uu___1 = FStar_Compiler_Dyn.undyn blob in
-                        FStar_Compiler_Util.array_index uu___1 i in
-                      FStar_Pervasives_Native.Some uu___)),
-        (FStar_TypeChecker_NBETerm.mixed_ternary_op
-           (fun uu___ ->
-              match uu___ with
-              | (elt_t, uu___1) -> FStar_Pervasives_Native.Some elt_t)
-           arg2_as_blob_nbe FStar_TypeChecker_NBETerm.arg_as_int
-           (fun tm -> tm)
-           (fun _universes ->
-              fun _t ->
-                fun blob ->
-                  fun i ->
-                    let uu___ =
-                      let uu___1 = FStar_Compiler_Dyn.undyn blob in
-                      FStar_Compiler_Util.array_index uu___1 i in
-                    FStar_Pervasives_Native.Some uu___))) in
-    [of_list_op; length_op; index_op] in
-  let strong_steps =
-    FStar_Compiler_List.map (as_primitive_step true)
-      (FStar_Compiler_List.op_At basic_ops
-         (FStar_Compiler_List.op_At bounded_arith_ops
-            (FStar_Compiler_List.op_At [reveal_hide] array_ops))) in
-  let weak_steps = FStar_Compiler_List.map (as_primitive_step false) weak_ops in
-  FStar_Compiler_Effect.op_Less_Bar prim_from_list
-    (FStar_Compiler_List.op_At strong_steps weak_steps)
-let (equality_ops : primitive_step FStar_Compiler_Util.psmap) =
-  let interp_prop_eq2 psc1 _norm_cb _univs args =
-    let r = psc1.psc_range in
-    match args with
-    | (_typ, uu___)::(a1, uu___1)::(a2, uu___2)::[] ->
-        let uu___3 = FStar_Syntax_Util.eq_tm a1 a2 in
-        (match uu___3 with
-         | FStar_Syntax_Util.Equal ->
-             FStar_Pervasives_Native.Some
-               {
-                 FStar_Syntax_Syntax.n =
-                   (FStar_Syntax_Util.t_true.FStar_Syntax_Syntax.n);
-                 FStar_Syntax_Syntax.pos = r;
-                 FStar_Syntax_Syntax.vars =
-                   (FStar_Syntax_Util.t_true.FStar_Syntax_Syntax.vars);
-                 FStar_Syntax_Syntax.hash_code =
-                   (FStar_Syntax_Util.t_true.FStar_Syntax_Syntax.hash_code)
-               }
-         | FStar_Syntax_Util.NotEqual ->
-             FStar_Pervasives_Native.Some
-               {
-                 FStar_Syntax_Syntax.n =
-                   (FStar_Syntax_Util.t_false.FStar_Syntax_Syntax.n);
-                 FStar_Syntax_Syntax.pos = r;
-                 FStar_Syntax_Syntax.vars =
-                   (FStar_Syntax_Util.t_false.FStar_Syntax_Syntax.vars);
-                 FStar_Syntax_Syntax.hash_code =
-                   (FStar_Syntax_Util.t_false.FStar_Syntax_Syntax.hash_code)
-               }
-         | uu___4 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments" in
-  let propositional_equality =
-    {
-      name = FStar_Parser_Const.eq2_lid;
-      arity = (Prims.of_int (3));
-      univ_arity = Prims.int_one;
-      auto_reflect = FStar_Pervasives_Native.None;
-      strong_reduction_ok = true;
-      requires_binder_substitution = false;
-      interpretation = interp_prop_eq2;
-      interpretation_nbe =
-        (fun _cb -> fun _univs -> FStar_TypeChecker_NBETerm.interp_prop_eq2)
-    } in
-  prim_from_list [propositional_equality]
-let (primop_time_map : Prims.int FStar_Compiler_Util.smap) =
-  FStar_Compiler_Util.smap_create (Prims.of_int (50))
-let (primop_time_reset : unit -> unit) =
-  fun uu___ -> FStar_Compiler_Util.smap_clear primop_time_map
-let (primop_time_count : Prims.string -> Prims.int -> unit) =
-  fun nm ->
-    fun ms ->
-      let uu___ = FStar_Compiler_Util.smap_try_find primop_time_map nm in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          FStar_Compiler_Util.smap_add primop_time_map nm ms
-      | FStar_Pervasives_Native.Some ms0 ->
-          FStar_Compiler_Util.smap_add primop_time_map nm (ms0 + ms)
-let (fixto : Prims.int -> Prims.string -> Prims.string) =
-  fun n ->
-    fun s ->
-      if (FStar_String.length s) < n
-      then
-        let uu___ = FStar_String.make (n - (FStar_String.length s)) 32 in
-        FStar_String.op_Hat uu___ s
-      else s
-let (primop_time_report : unit -> Prims.string) =
-  fun uu___ ->
-    let pairs =
-      FStar_Compiler_Util.smap_fold primop_time_map
-        (fun nm -> fun ms -> fun rest -> (nm, ms) :: rest) [] in
-    let pairs1 =
-      FStar_Compiler_Util.sort_with
-        (fun uu___1 ->
-           fun uu___2 ->
-             match (uu___1, uu___2) with
-             | ((uu___3, t1), (uu___4, t2)) -> t1 - t2) pairs in
-    FStar_Compiler_List.fold_right
-      (fun uu___1 ->
-         fun rest ->
-           match uu___1 with
-           | (nm, ms) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Compiler_Util.string_of_int ms in
-                   fixto (Prims.of_int (10)) uu___4 in
-                 FStar_Compiler_Util.format2 "%sms --- %s\n" uu___3 nm in
-               FStar_String.op_Hat uu___2 rest) pairs1 ""
-let (extendable_primops_dirty : Prims.bool FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref true
-type register_prim_step_t = primitive_step -> unit
-type retrieve_prim_step_t = unit -> prim_step_set
-let (mk_extendable_primop_set :
-  unit -> (register_prim_step_t * retrieve_prim_step_t)) =
-  fun uu___ ->
-    let steps =
-      let uu___1 = empty_prim_steps () in FStar_Compiler_Util.mk_ref uu___1 in
-    let register p =
-      FStar_Compiler_Effect.op_Colon_Equals extendable_primops_dirty true;
-      (let uu___2 =
-         let uu___3 = FStar_Compiler_Effect.op_Bang steps in
-         add_step p uu___3 in
-       FStar_Compiler_Effect.op_Colon_Equals steps uu___2) in
-    let retrieve uu___1 = FStar_Compiler_Effect.op_Bang steps in
-    (register, retrieve)
-let (plugins : (register_prim_step_t * retrieve_prim_step_t)) =
-  mk_extendable_primop_set ()
-let (extra_steps : (register_prim_step_t * retrieve_prim_step_t)) =
-  mk_extendable_primop_set ()
-let (register_plugin : primitive_step -> unit) =
-  fun p -> FStar_Pervasives_Native.fst plugins p
-let (retrieve_plugins : unit -> prim_step_set) =
-  fun uu___ ->
-    let uu___1 = FStar_Options.no_plugins () in
-    if uu___1
-    then empty_prim_steps ()
-    else FStar_Pervasives_Native.snd plugins ()
-let (register_extra_step : primitive_step -> unit) =
-  fun p -> FStar_Pervasives_Native.fst extra_steps p
-let (retrieve_extra_steps : unit -> prim_step_set) =
-  fun uu___ -> FStar_Pervasives_Native.snd extra_steps ()
-let (cached_steps : unit -> prim_step_set) =
-  let memo =
-    let uu___ = empty_prim_steps () in FStar_Compiler_Util.mk_ref uu___ in
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang extendable_primops_dirty in
-    if uu___1
-    then
-      let steps =
-        let uu___2 =
-          let uu___3 = retrieve_plugins () in
-          let uu___4 = retrieve_extra_steps () in merge_steps uu___3 uu___4 in
-        merge_steps built_in_primitive_steps uu___2 in
-      (FStar_Compiler_Effect.op_Colon_Equals memo steps;
-       FStar_Compiler_Effect.op_Colon_Equals extendable_primops_dirty false;
-       steps)
-    else FStar_Compiler_Effect.op_Bang memo
-let (add_nbe : fsteps -> fsteps) =
-  fun s ->
-    let uu___ = FStar_Options.use_nbe () in
-    if uu___
-    then
-      {
-        beta = (s.beta);
-        iota = (s.iota);
-        zeta = (s.zeta);
-        zeta_full = (s.zeta_full);
-        weak = (s.weak);
-        hnf = (s.hnf);
-        primops = (s.primops);
-        do_not_unfold_pure_lets = (s.do_not_unfold_pure_lets);
-        unfold_until = (s.unfold_until);
-        unfold_only = (s.unfold_only);
-        unfold_fully = (s.unfold_fully);
-        unfold_attr = (s.unfold_attr);
-        unfold_qual = (s.unfold_qual);
-        unfold_namespace = (s.unfold_namespace);
-        unfold_tac = (s.unfold_tac);
-        pure_subterms_within_computations =
-          (s.pure_subterms_within_computations);
-        simplify = (s.simplify);
-        erase_universes = (s.erase_universes);
-        allow_unbound_universes = (s.allow_unbound_universes);
-        reify_ = (s.reify_);
-        compress_uvars = (s.compress_uvars);
-        no_full_norm = (s.no_full_norm);
-        check_no_uvars = (s.check_no_uvars);
-        unmeta = (s.unmeta);
-        unascribe = (s.unascribe);
-        in_full_norm_request = (s.in_full_norm_request);
-        weakly_reduce_scrutinee = (s.weakly_reduce_scrutinee);
-        nbe_step = true;
-        for_extraction = (s.for_extraction);
-        unrefine = (s.unrefine)
-      }
-    else s
-let (config' :
-  primitive_step Prims.list ->
-    FStar_TypeChecker_Env.step Prims.list -> FStar_TypeChecker_Env.env -> cfg)
-  =
-  fun psteps ->
-    fun s ->
-      fun e ->
-        let d =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater s
-              (FStar_Compiler_List.collect
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | FStar_TypeChecker_Env.UnfoldUntil k ->
-                        [FStar_TypeChecker_Env.Unfold k]
-                    | FStar_TypeChecker_Env.Eager_unfolding ->
-                        [FStar_TypeChecker_Env.Eager_unfolding_only]
-                    | FStar_TypeChecker_Env.UnfoldQual l when
-                        FStar_Compiler_List.contains "unfold" l ->
-                        [FStar_TypeChecker_Env.Eager_unfolding_only]
-                    | FStar_TypeChecker_Env.Inlining ->
-                        [FStar_TypeChecker_Env.InliningDelta]
-                    | FStar_TypeChecker_Env.UnfoldQual l when
-                        FStar_Compiler_List.contains "inline_for_extraction"
-                          l
-                        -> [FStar_TypeChecker_Env.InliningDelta]
-                    | uu___2 -> [])) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Compiler_List.unique in
-        let d1 =
-          match d with | [] -> [FStar_TypeChecker_Env.NoDelta] | uu___ -> d in
-        let steps =
-          let uu___ = to_fsteps s in
-          FStar_Compiler_Effect.op_Bar_Greater uu___ add_nbe in
-        let psteps1 = let uu___ = cached_steps () in add_steps uu___ psteps in
-        let uu___ =
-          let uu___1 = FStar_Options.debug_any () in
-          if uu___1
-          then
-            let uu___2 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "Norm") in
-            let uu___3 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "NormTop") in
-            let uu___4 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "NormCfg") in
-            let uu___5 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "Primops") in
-            let uu___6 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "Unfolding") in
-            let uu___7 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "380") in
-            let uu___8 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "WPE") in
-            let uu___9 =
-              FStar_TypeChecker_Env.debug e
-                (FStar_Options.Other "NormDelayed") in
-            let uu___10 =
-              FStar_TypeChecker_Env.debug e
-                (FStar_Options.Other "print_normalized_terms") in
-            let uu___11 =
-              FStar_TypeChecker_Env.debug e (FStar_Options.Other "NBE") in
-            let uu___12 =
-              let b =
-                FStar_TypeChecker_Env.debug e
-                  (FStar_Options.Other "UNSOUND_EraseErasableArgs") in
-              if b
-              then
-                (let uu___14 = FStar_TypeChecker_Env.get_range e in
-                 FStar_Errors.log_issue uu___14
-                   (FStar_Errors.Warning_WarnOnUse,
-                     "The 'UNSOUND_EraseErasableArgs' setting is for debugging only; it is not sound"))
-              else ();
-              b in
-            {
-              gen = uu___2;
-              top = uu___3;
-              cfg = uu___4;
-              primop = uu___5;
-              unfolding = uu___6;
-              b380 = uu___7;
-              wpe = uu___8;
-              norm_delayed = uu___9;
-              print_normalized = uu___10;
-              debug_nbe = uu___11;
-              erase_erasable_args = uu___12
-            }
-          else no_debug_switches in
-        let uu___1 =
-          (Prims.op_Negation steps.pure_subterms_within_computations) ||
-            (FStar_Options.normalize_pure_terms_for_extraction ()) in
-        {
-          steps;
-          tcenv = e;
-          debug = uu___;
-          delta_level = d1;
-          primitive_steps = psteps1;
-          strong = false;
-          memoize_lazy = true;
-          normalize_pure_lets = uu___1;
-          reifying = false
-        }
-let (config :
-  FStar_TypeChecker_Env.step Prims.list -> FStar_TypeChecker_Env.env -> cfg)
-  = fun s -> fun e -> config' [] s e
-let (should_reduce_local_let :
-  cfg -> FStar_Syntax_Syntax.letbinding -> Prims.bool) =
-  fun cfg1 ->
-    fun lb ->
-      if (cfg1.steps).do_not_unfold_pure_lets
-      then false
-      else
-        (let uu___1 =
-           (cfg1.steps).pure_subterms_within_computations &&
-             (FStar_Syntax_Util.has_attribute lb.FStar_Syntax_Syntax.lbattrs
-                FStar_Parser_Const.inline_let_attr) in
-         if uu___1
-         then true
-         else
-           (let n =
-              FStar_TypeChecker_Env.norm_eff_name cfg1.tcenv
-                lb.FStar_Syntax_Syntax.lbeff in
-            let uu___3 =
-              (FStar_Syntax_Util.is_pure_effect n) &&
-                (cfg1.normalize_pure_lets ||
-                   (FStar_Syntax_Util.has_attribute
-                      lb.FStar_Syntax_Syntax.lbattrs
-                      FStar_Parser_Const.inline_let_attr)) in
-            if uu___3
-            then true
-            else
-              (FStar_Syntax_Util.is_ghost_effect n) &&
-                (Prims.op_Negation
-                   (cfg1.steps).pure_subterms_within_computations)))
-let (translate_norm_step :
-  FStar_Syntax_Embeddings.norm_step -> FStar_TypeChecker_Env.step Prims.list)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Embeddings.Zeta -> [FStar_TypeChecker_Env.Zeta]
-    | FStar_Syntax_Embeddings.ZetaFull -> [FStar_TypeChecker_Env.ZetaFull]
-    | FStar_Syntax_Embeddings.Iota -> [FStar_TypeChecker_Env.Iota]
-    | FStar_Syntax_Embeddings.Delta ->
-        [FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant]
-    | FStar_Syntax_Embeddings.Simpl -> [FStar_TypeChecker_Env.Simplify]
-    | FStar_Syntax_Embeddings.Weak -> [FStar_TypeChecker_Env.Weak]
-    | FStar_Syntax_Embeddings.HNF -> [FStar_TypeChecker_Env.HNF]
-    | FStar_Syntax_Embeddings.Primops -> [FStar_TypeChecker_Env.Primops]
-    | FStar_Syntax_Embeddings.Reify -> [FStar_TypeChecker_Env.Reify]
-    | FStar_Syntax_Embeddings.UnfoldOnly names ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_List.map FStar_Ident.lid_of_str names in
-            FStar_TypeChecker_Env.UnfoldOnly uu___3 in
-          [uu___2] in
-        (FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant)
-          :: uu___1
-    | FStar_Syntax_Embeddings.UnfoldFully names ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_List.map FStar_Ident.lid_of_str names in
-            FStar_TypeChecker_Env.UnfoldFully uu___3 in
-          [uu___2] in
-        (FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant)
-          :: uu___1
-    | FStar_Syntax_Embeddings.UnfoldAttr names ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Compiler_List.map FStar_Ident.lid_of_str names in
-            FStar_TypeChecker_Env.UnfoldAttr uu___3 in
-          [uu___2] in
-        (FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant)
-          :: uu___1
-    | FStar_Syntax_Embeddings.UnfoldQual names ->
-        [FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-        FStar_TypeChecker_Env.UnfoldQual names]
-    | FStar_Syntax_Embeddings.UnfoldNamespace names ->
-        [FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-        FStar_TypeChecker_Env.UnfoldNamespace names]
-    | FStar_Syntax_Embeddings.Unascribe -> [FStar_TypeChecker_Env.Unascribe]
-    | FStar_Syntax_Embeddings.NBE -> [FStar_TypeChecker_Env.NBE]
-    | FStar_Syntax_Embeddings.Unmeta -> [FStar_TypeChecker_Env.Unmeta]
-let (translate_norm_steps :
-  FStar_Syntax_Embeddings.norm_step Prims.list ->
-    FStar_TypeChecker_Env.step Prims.list)
-  =
-  fun s ->
-    let s1 = FStar_Compiler_List.concatMap translate_norm_step s in
-    let add_exclude s2 z =
-      let uu___ =
-        FStar_Compiler_Util.for_some (FStar_TypeChecker_Env.eq_step z) s2 in
-      if uu___ then s2 else (FStar_TypeChecker_Env.Exclude z) :: s2 in
-    let s2 = FStar_TypeChecker_Env.Beta :: s1 in
-    let s3 = add_exclude s2 FStar_TypeChecker_Env.Zeta in
-    let s4 = add_exclude s3 FStar_TypeChecker_Env.Iota in s4
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Common.ml b/src/ocaml-output/FStar_TypeChecker_Common.ml
deleted file mode 100644
index 277d1b15ccf..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Common.ml
+++ /dev/null
@@ -1,1769 +0,0 @@
-open Prims
-type rel =
-  | EQ 
-  | SUB 
-  | SUBINV 
-let (uu___is_EQ : rel -> Prims.bool) =
-  fun projectee -> match projectee with | EQ -> true | uu___ -> false
-let (uu___is_SUB : rel -> Prims.bool) =
-  fun projectee -> match projectee with | SUB -> true | uu___ -> false
-let (uu___is_SUBINV : rel -> Prims.bool) =
-  fun projectee -> match projectee with | SUBINV -> true | uu___ -> false
-type rank_t =
-  | Rigid_rigid 
-  | Flex_rigid_eq 
-  | Flex_flex_pattern_eq 
-  | Flex_rigid 
-  | Rigid_flex 
-  | Flex_flex 
-let (uu___is_Rigid_rigid : rank_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Rigid_rigid -> true | uu___ -> false
-let (uu___is_Flex_rigid_eq : rank_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Flex_rigid_eq -> true | uu___ -> false
-let (uu___is_Flex_flex_pattern_eq : rank_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Flex_flex_pattern_eq -> true | uu___ -> false
-let (uu___is_Flex_rigid : rank_t -> Prims.bool) =
-  fun projectee -> match projectee with | Flex_rigid -> true | uu___ -> false
-let (uu___is_Rigid_flex : rank_t -> Prims.bool) =
-  fun projectee -> match projectee with | Rigid_flex -> true | uu___ -> false
-let (uu___is_Flex_flex : rank_t -> Prims.bool) =
-  fun projectee -> match projectee with | Flex_flex -> true | uu___ -> false
-type 'a problem =
-  {
-  pid: Prims.int ;
-  lhs: 'a ;
-  relation: rel ;
-  rhs: 'a ;
-  element: FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ;
-  logical_guard: FStar_Syntax_Syntax.term ;
-  logical_guard_uvar: FStar_Syntax_Syntax.ctx_uvar ;
-  reason: Prims.string Prims.list ;
-  loc: FStar_Compiler_Range.range ;
-  rank: rank_t FStar_Pervasives_Native.option }
-let __proj__Mkproblem__item__pid : 'a . 'a problem -> Prims.int =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> pid
-let __proj__Mkproblem__item__lhs : 'a . 'a problem -> 'a =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> lhs
-let __proj__Mkproblem__item__relation : 'a . 'a problem -> rel =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> relation
-let __proj__Mkproblem__item__rhs : 'a . 'a problem -> 'a =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> rhs
-let __proj__Mkproblem__item__element :
-  'a . 'a problem -> FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> element
-let __proj__Mkproblem__item__logical_guard :
-  'a . 'a problem -> FStar_Syntax_Syntax.term =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> logical_guard
-let __proj__Mkproblem__item__logical_guard_uvar :
-  'a . 'a problem -> FStar_Syntax_Syntax.ctx_uvar =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> logical_guard_uvar
-let __proj__Mkproblem__item__reason :
-  'a . 'a problem -> Prims.string Prims.list =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> reason
-let __proj__Mkproblem__item__loc :
-  'a . 'a problem -> FStar_Compiler_Range.range =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> loc
-let __proj__Mkproblem__item__rank :
-  'a . 'a problem -> rank_t FStar_Pervasives_Native.option =
-  fun projectee ->
-    match projectee with
-    | { pid; lhs; relation; rhs; element; logical_guard; logical_guard_uvar;
-        reason; loc; rank;_} -> rank
-type prob =
-  | TProb of FStar_Syntax_Syntax.typ problem 
-  | CProb of FStar_Syntax_Syntax.comp problem 
-let (uu___is_TProb : prob -> Prims.bool) =
-  fun projectee -> match projectee with | TProb _0 -> true | uu___ -> false
-let (__proj__TProb__item___0 : prob -> FStar_Syntax_Syntax.typ problem) =
-  fun projectee -> match projectee with | TProb _0 -> _0
-let (uu___is_CProb : prob -> Prims.bool) =
-  fun projectee -> match projectee with | CProb _0 -> true | uu___ -> false
-let (__proj__CProb__item___0 : prob -> FStar_Syntax_Syntax.comp problem) =
-  fun projectee -> match projectee with | CProb _0 -> _0
-let (as_tprob : prob -> FStar_Syntax_Syntax.typ problem) =
-  fun uu___ ->
-    match uu___ with | TProb p -> p | uu___1 -> failwith "Expected a TProb"
-type probs = prob Prims.list
-type guard_formula =
-  | Trivial 
-  | NonTrivial of FStar_Syntax_Syntax.formula 
-let (uu___is_Trivial : guard_formula -> Prims.bool) =
-  fun projectee -> match projectee with | Trivial -> true | uu___ -> false
-let (uu___is_NonTrivial : guard_formula -> Prims.bool) =
-  fun projectee ->
-    match projectee with | NonTrivial _0 -> true | uu___ -> false
-let (__proj__NonTrivial__item___0 :
-  guard_formula -> FStar_Syntax_Syntax.formula) =
-  fun projectee -> match projectee with | NonTrivial _0 -> _0
-type deferred_reason =
-  | Deferred_univ_constraint 
-  | Deferred_occur_check_failed 
-  | Deferred_first_order_heuristic_failed 
-  | Deferred_flex 
-  | Deferred_free_names_check_failed 
-  | Deferred_not_a_pattern 
-  | Deferred_flex_flex_nonpattern 
-  | Deferred_delay_match_heuristic 
-  | Deferred_to_user_tac 
-let (uu___is_Deferred_univ_constraint : deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Deferred_univ_constraint -> true | uu___ -> false
-let (uu___is_Deferred_occur_check_failed : deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Deferred_occur_check_failed -> true
-    | uu___ -> false
-let (uu___is_Deferred_first_order_heuristic_failed :
-  deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Deferred_first_order_heuristic_failed -> true
-    | uu___ -> false
-let (uu___is_Deferred_flex : deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Deferred_flex -> true | uu___ -> false
-let (uu___is_Deferred_free_names_check_failed :
-  deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Deferred_free_names_check_failed -> true
-    | uu___ -> false
-let (uu___is_Deferred_not_a_pattern : deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Deferred_not_a_pattern -> true | uu___ -> false
-let (uu___is_Deferred_flex_flex_nonpattern : deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Deferred_flex_flex_nonpattern -> true
-    | uu___ -> false
-let (uu___is_Deferred_delay_match_heuristic : deferred_reason -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | Deferred_delay_match_heuristic -> true
-    | uu___ -> false
-let (uu___is_Deferred_to_user_tac : deferred_reason -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Deferred_to_user_tac -> true | uu___ -> false
-type deferred = (deferred_reason * Prims.string * prob) Prims.list
-type univ_ineq =
-  (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.universe)
-type identifier_info =
-  {
-  identifier:
-    (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either ;
-  identifier_ty: FStar_Syntax_Syntax.typ ;
-  identifier_range: FStar_Compiler_Range.range }
-let (__proj__Mkidentifier_info__item__identifier :
-  identifier_info ->
-    (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either)
-  =
-  fun projectee ->
-    match projectee with
-    | { identifier; identifier_ty; identifier_range;_} -> identifier
-let (__proj__Mkidentifier_info__item__identifier_ty :
-  identifier_info -> FStar_Syntax_Syntax.typ) =
-  fun projectee ->
-    match projectee with
-    | { identifier; identifier_ty; identifier_range;_} -> identifier_ty
-let (__proj__Mkidentifier_info__item__identifier_range :
-  identifier_info -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { identifier; identifier_ty; identifier_range;_} -> identifier_range
-type id_info_by_col = (Prims.int * identifier_info) Prims.list
-type col_info_by_row = id_info_by_col FStar_Compiler_Util.pimap
-type row_info_by_file = col_info_by_row FStar_Compiler_Util.psmap
-type id_info_table =
-  {
-  id_info_enabled: Prims.bool ;
-  id_info_db: row_info_by_file ;
-  id_info_buffer: identifier_info Prims.list }
-let (__proj__Mkid_info_table__item__id_info_enabled :
-  id_info_table -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { id_info_enabled; id_info_db; id_info_buffer;_} -> id_info_enabled
-let (__proj__Mkid_info_table__item__id_info_db :
-  id_info_table -> row_info_by_file) =
-  fun projectee ->
-    match projectee with
-    | { id_info_enabled; id_info_db; id_info_buffer;_} -> id_info_db
-let (__proj__Mkid_info_table__item__id_info_buffer :
-  id_info_table -> identifier_info Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { id_info_enabled; id_info_db; id_info_buffer;_} -> id_info_buffer
-let (mk_by_tactic :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun tac ->
-    fun f ->
-      let t_by_tactic =
-        let uu___ =
-          FStar_Syntax_Syntax.tabbrev FStar_Parser_Const.by_tactic_lid in
-        FStar_Syntax_Syntax.mk_Tm_uinst uu___ [FStar_Syntax_Syntax.U_zero] in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Syntax.as_arg tac in
-        let uu___2 = let uu___3 = FStar_Syntax_Syntax.as_arg f in [uu___3] in
-        uu___1 :: uu___2 in
-      FStar_Syntax_Syntax.mk_Tm_app t_by_tactic uu___
-        FStar_Compiler_Range.dummyRange
-let rec (delta_depth_greater_than :
-  FStar_Syntax_Syntax.delta_depth ->
-    FStar_Syntax_Syntax.delta_depth -> Prims.bool)
-  =
-  fun l ->
-    fun m ->
-      match (l, m) with
-      | (FStar_Syntax_Syntax.Delta_equational_at_level i,
-         FStar_Syntax_Syntax.Delta_equational_at_level j) -> i > j
-      | (FStar_Syntax_Syntax.Delta_constant_at_level i,
-         FStar_Syntax_Syntax.Delta_constant_at_level j) -> i > j
-      | (FStar_Syntax_Syntax.Delta_abstract d, uu___) ->
-          delta_depth_greater_than d m
-      | (uu___, FStar_Syntax_Syntax.Delta_abstract d) ->
-          delta_depth_greater_than l d
-      | (FStar_Syntax_Syntax.Delta_equational_at_level uu___, uu___1) -> true
-      | (uu___, FStar_Syntax_Syntax.Delta_equational_at_level uu___1) ->
-          false
-let rec (decr_delta_depth :
-  FStar_Syntax_Syntax.delta_depth ->
-    FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Delta_constant_at_level uu___1 when
-        uu___1 = Prims.int_zero -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Delta_equational_at_level uu___1 when
-        uu___1 = Prims.int_zero -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Delta_constant_at_level i ->
-        FStar_Pervasives_Native.Some
-          (FStar_Syntax_Syntax.Delta_constant_at_level (i - Prims.int_one))
-    | FStar_Syntax_Syntax.Delta_equational_at_level i ->
-        FStar_Pervasives_Native.Some
-          (FStar_Syntax_Syntax.Delta_equational_at_level (i - Prims.int_one))
-    | FStar_Syntax_Syntax.Delta_abstract d -> decr_delta_depth d
-let (insert_col_info :
-  Prims.int ->
-    identifier_info ->
-      (Prims.int * identifier_info) Prims.list ->
-        (Prims.int * identifier_info) Prims.list)
-  =
-  fun col ->
-    fun info ->
-      fun col_infos ->
-        let rec __insert aux rest =
-          match rest with
-          | [] -> (aux, [(col, info)])
-          | (c, i)::rest' ->
-              if col < c
-              then (aux, ((col, info) :: rest))
-              else __insert ((c, i) :: aux) rest' in
-        let uu___ = __insert [] col_infos in
-        match uu___ with
-        | (l, r) -> FStar_Compiler_List.op_At (FStar_Compiler_List.rev l) r
-let (find_nearest_preceding_col_info :
-  Prims.int ->
-    (Prims.int * identifier_info) Prims.list ->
-      identifier_info FStar_Pervasives_Native.option)
-  =
-  fun col ->
-    fun col_infos ->
-      let rec aux out uu___ =
-        match uu___ with
-        | [] -> out
-        | (c, i)::rest ->
-            if c > col
-            then out
-            else aux (FStar_Pervasives_Native.Some i) rest in
-      aux FStar_Pervasives_Native.None col_infos
-let (id_info_table_empty : id_info_table) =
-  let uu___ = FStar_Compiler_Util.psmap_empty () in
-  { id_info_enabled = false; id_info_db = uu___; id_info_buffer = [] }
-let (print_identifier_info : identifier_info -> Prims.string) =
-  fun info ->
-    let uu___ = FStar_Compiler_Range.string_of_range info.identifier_range in
-    let uu___1 =
-      match info.identifier with
-      | FStar_Pervasives.Inl x -> FStar_Syntax_Print.bv_to_string x
-      | FStar_Pervasives.Inr fv -> FStar_Syntax_Print.fv_to_string fv in
-    let uu___2 = FStar_Syntax_Print.term_to_string info.identifier_ty in
-    FStar_Compiler_Util.format3 "id info { %s, %s : %s}" uu___ uu___1 uu___2
-let (id_info__insert :
-  (FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ) ->
-    (Prims.int * identifier_info) Prims.list FStar_Compiler_Util.pimap
-      FStar_Compiler_Util.psmap ->
-      identifier_info ->
-        (Prims.int * identifier_info) Prims.list FStar_Compiler_Util.pimap
-          FStar_Compiler_Util.psmap)
-  =
-  fun ty_map ->
-    fun db ->
-      fun info ->
-        let range = info.identifier_range in
-        let use_range =
-          let uu___ = FStar_Compiler_Range.use_range range in
-          FStar_Compiler_Range.set_def_range range uu___ in
-        let id_ty =
-          match info.identifier with
-          | FStar_Pervasives.Inr uu___ -> info.identifier_ty
-          | FStar_Pervasives.Inl x -> ty_map info.identifier_ty in
-        let info1 =
-          {
-            identifier = (info.identifier);
-            identifier_ty = id_ty;
-            identifier_range = use_range
-          } in
-        let fn = FStar_Compiler_Range.file_of_range use_range in
-        let start = FStar_Compiler_Range.start_of_range use_range in
-        let uu___ =
-          let uu___1 = FStar_Compiler_Range.line_of_pos start in
-          let uu___2 = FStar_Compiler_Range.col_of_pos start in
-          (uu___1, uu___2) in
-        match uu___ with
-        | (row, col) ->
-            let rows =
-              let uu___1 = FStar_Compiler_Util.pimap_empty () in
-              FStar_Compiler_Util.psmap_find_default db fn uu___1 in
-            let cols = FStar_Compiler_Util.pimap_find_default rows row [] in
-            let uu___1 =
-              let uu___2 = insert_col_info col info1 cols in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                (FStar_Compiler_Util.pimap_add rows row) in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (FStar_Compiler_Util.psmap_add db fn)
-let (id_info_insert :
-  id_info_table ->
-    (FStar_Syntax_Syntax.bv, FStar_Syntax_Syntax.fv) FStar_Pervasives.either
-      ->
-      FStar_Syntax_Syntax.typ -> FStar_Compiler_Range.range -> id_info_table)
-  =
-  fun table ->
-    fun id ->
-      fun ty ->
-        fun range ->
-          let info =
-            { identifier = id; identifier_ty = ty; identifier_range = range } in
-          {
-            id_info_enabled = (table.id_info_enabled);
-            id_info_db = (table.id_info_db);
-            id_info_buffer = (info :: (table.id_info_buffer))
-          }
-let (id_info_insert_bv :
-  id_info_table ->
-    FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.typ -> id_info_table)
-  =
-  fun table ->
-    fun bv ->
-      fun ty ->
-        if table.id_info_enabled
-        then
-          let uu___ = FStar_Syntax_Syntax.range_of_bv bv in
-          id_info_insert table (FStar_Pervasives.Inl bv) ty uu___
-        else table
-let (id_info_insert_fv :
-  id_info_table ->
-    FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.typ -> id_info_table)
-  =
-  fun table ->
-    fun fv ->
-      fun ty ->
-        if table.id_info_enabled
-        then
-          let uu___ = FStar_Syntax_Syntax.range_of_fv fv in
-          id_info_insert table (FStar_Pervasives.Inr fv) ty uu___
-        else table
-let (id_info_toggle : id_info_table -> Prims.bool -> id_info_table) =
-  fun table ->
-    fun enabled ->
-      {
-        id_info_enabled = enabled;
-        id_info_db = (table.id_info_db);
-        id_info_buffer = (table.id_info_buffer)
-      }
-let (id_info_promote :
-  id_info_table ->
-    (FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ) -> id_info_table)
-  =
-  fun table ->
-    fun ty_map ->
-      let uu___ =
-        FStar_Compiler_List.fold_left (id_info__insert ty_map)
-          table.id_info_db table.id_info_buffer in
-      {
-        id_info_enabled = (table.id_info_enabled);
-        id_info_db = uu___;
-        id_info_buffer = []
-      }
-let (id_info_at_pos :
-  id_info_table ->
-    Prims.string ->
-      Prims.int ->
-        Prims.int -> identifier_info FStar_Pervasives_Native.option)
-  =
-  fun table ->
-    fun fn ->
-      fun row ->
-        fun col ->
-          let rows =
-            let uu___ = FStar_Compiler_Util.pimap_empty () in
-            FStar_Compiler_Util.psmap_find_default table.id_info_db fn uu___ in
-          let cols = FStar_Compiler_Util.pimap_find_default rows row [] in
-          let uu___ = find_nearest_preceding_col_info col cols in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some info ->
-              let last_col =
-                let uu___1 =
-                  FStar_Compiler_Range.end_of_range info.identifier_range in
-                FStar_Compiler_Range.col_of_pos uu___1 in
-              if col <= last_col
-              then FStar_Pervasives_Native.Some info
-              else FStar_Pervasives_Native.None
-let (check_uvar_ctx_invariant :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      Prims.bool ->
-        FStar_Syntax_Syntax.gamma -> FStar_Syntax_Syntax.binders -> unit)
-  =
-  fun reason ->
-    fun r ->
-      fun should_check ->
-        fun g ->
-          fun bs ->
-            let print_gamma gamma =
-              let uu___ =
-                FStar_Compiler_Effect.op_Bar_Greater gamma
-                  (FStar_Compiler_List.map
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | FStar_Syntax_Syntax.Binding_var x ->
-                            let uu___2 = FStar_Syntax_Print.bv_to_string x in
-                            Prims.op_Hat "Binding_var " uu___2
-                        | FStar_Syntax_Syntax.Binding_univ u ->
-                            let uu___2 = FStar_Ident.string_of_id u in
-                            Prims.op_Hat "Binding_univ " uu___2
-                        | FStar_Syntax_Syntax.Binding_lid (l, uu___2) ->
-                            let uu___3 = FStar_Ident.string_of_lid l in
-                            Prims.op_Hat "Binding_lid " uu___3)) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___
-                (FStar_String.concat "::\n") in
-            let fail uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Compiler_Range.string_of_range r in
-                let uu___3 = print_gamma g in
-                let uu___4 = FStar_Syntax_Print.binders_to_string ", " bs in
-                FStar_Compiler_Util.format5
-                  "Invariant violation: gamma and binders are out of sync\n\treason=%s, range=%s, should_check=%s\n\t\n                               gamma=%s\n\tbinders=%s\n"
-                  reason uu___2 (if should_check then "true" else "false")
-                  uu___3 uu___4 in
-              failwith uu___1 in
-            if Prims.op_Negation should_check
-            then ()
-            else
-              (let uu___1 =
-                 let uu___2 =
-                   FStar_Compiler_Util.prefix_until
-                     (fun uu___3 ->
-                        match uu___3 with
-                        | FStar_Syntax_Syntax.Binding_var uu___4 -> true
-                        | uu___4 -> false) g in
-                 (uu___2, bs) in
-               match uu___1 with
-               | (FStar_Pervasives_Native.None, []) -> ()
-               | (FStar_Pervasives_Native.Some (uu___2, hd, gamma_tail),
-                  uu___3::uu___4) ->
-                   let uu___5 = FStar_Compiler_Util.prefix bs in
-                   (match uu___5 with
-                    | (uu___6, x) ->
-                        (match hd with
-                         | FStar_Syntax_Syntax.Binding_var x' when
-                             FStar_Syntax_Syntax.bv_eq
-                               x.FStar_Syntax_Syntax.binder_bv x'
-                             -> ()
-                         | uu___7 -> fail ()))
-               | uu___2 -> fail ())
-type implicit =
-  {
-  imp_reason: Prims.string ;
-  imp_uvar: FStar_Syntax_Syntax.ctx_uvar ;
-  imp_tm: FStar_Syntax_Syntax.term ;
-  imp_range: FStar_Compiler_Range.range }
-let (__proj__Mkimplicit__item__imp_reason : implicit -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { imp_reason; imp_uvar; imp_tm; imp_range;_} -> imp_reason
-let (__proj__Mkimplicit__item__imp_uvar :
-  implicit -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun projectee ->
-    match projectee with
-    | { imp_reason; imp_uvar; imp_tm; imp_range;_} -> imp_uvar
-let (__proj__Mkimplicit__item__imp_tm : implicit -> FStar_Syntax_Syntax.term)
-  =
-  fun projectee ->
-    match projectee with
-    | { imp_reason; imp_uvar; imp_tm; imp_range;_} -> imp_tm
-let (__proj__Mkimplicit__item__imp_range :
-  implicit -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { imp_reason; imp_uvar; imp_tm; imp_range;_} -> imp_range
-type implicits = implicit Prims.list
-let (implicits_to_string : implicits -> Prims.string) =
-  fun imps ->
-    let imp_to_string i =
-      FStar_Syntax_Print.uvar_to_string
-        (i.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-    (FStar_Common.string_of_list ()) imp_to_string imps
-type guard_t =
-  {
-  guard_f: guard_formula ;
-  deferred_to_tac: deferred ;
-  deferred: deferred ;
-  univ_ineqs:
-    (FStar_Syntax_Syntax.universe Prims.list * univ_ineq Prims.list) ;
-  implicits: implicits }
-let (__proj__Mkguard_t__item__guard_f : guard_t -> guard_formula) =
-  fun projectee ->
-    match projectee with
-    | { guard_f; deferred_to_tac; deferred = deferred1; univ_ineqs;
-        implicits = implicits1;_} -> guard_f
-let (__proj__Mkguard_t__item__deferred_to_tac : guard_t -> deferred) =
-  fun projectee ->
-    match projectee with
-    | { guard_f; deferred_to_tac; deferred = deferred1; univ_ineqs;
-        implicits = implicits1;_} -> deferred_to_tac
-let (__proj__Mkguard_t__item__deferred : guard_t -> deferred) =
-  fun projectee ->
-    match projectee with
-    | { guard_f; deferred_to_tac; deferred = deferred1; univ_ineqs;
-        implicits = implicits1;_} -> deferred1
-let (__proj__Mkguard_t__item__univ_ineqs :
-  guard_t -> (FStar_Syntax_Syntax.universe Prims.list * univ_ineq Prims.list))
-  =
-  fun projectee ->
-    match projectee with
-    | { guard_f; deferred_to_tac; deferred = deferred1; univ_ineqs;
-        implicits = implicits1;_} -> univ_ineqs
-let (__proj__Mkguard_t__item__implicits : guard_t -> implicits) =
-  fun projectee ->
-    match projectee with
-    | { guard_f; deferred_to_tac; deferred = deferred1; univ_ineqs;
-        implicits = implicits1;_} -> implicits1
-let (trivial_guard : guard_t) =
-  {
-    guard_f = Trivial;
-    deferred_to_tac = [];
-    deferred = [];
-    univ_ineqs = ([], []);
-    implicits = []
-  }
-let (conj_guard_f : guard_formula -> guard_formula -> guard_formula) =
-  fun g1 ->
-    fun g2 ->
-      match (g1, g2) with
-      | (Trivial, g) -> g
-      | (g, Trivial) -> g
-      | (NonTrivial f1, NonTrivial f2) ->
-          let uu___ = FStar_Syntax_Util.mk_conj f1 f2 in NonTrivial uu___
-let rec (check_trivial : FStar_Syntax_Syntax.term -> guard_formula) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Util.unmeta t in
-      FStar_Syntax_Util.head_and_args uu___1 in
-    match uu___ with
-    | (hd, args) ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = FStar_Syntax_Util.unmeta hd in
-              FStar_Syntax_Util.un_uinst uu___4 in
-            uu___3.FStar_Syntax_Syntax.n in
-          (uu___2, args) in
-        (match uu___1 with
-         | (FStar_Syntax_Syntax.Tm_fvar tc, []) when
-             FStar_Syntax_Syntax.fv_eq_lid tc FStar_Parser_Const.true_lid ->
-             Trivial
-         | (FStar_Syntax_Syntax.Tm_fvar sq, (v, uu___2)::[]) when
-             (FStar_Syntax_Syntax.fv_eq_lid sq FStar_Parser_Const.squash_lid)
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid sq
-                  FStar_Parser_Const.auto_squash_lid)
-             ->
-             let uu___3 = check_trivial v in
-             (match uu___3 with | Trivial -> Trivial | uu___4 -> NonTrivial t)
-         | uu___2 -> NonTrivial t)
-let (imp_guard_f : guard_formula -> guard_formula -> guard_formula) =
-  fun g1 ->
-    fun g2 ->
-      match (g1, g2) with
-      | (Trivial, g) -> g
-      | (g, Trivial) -> Trivial
-      | (NonTrivial f1, NonTrivial f2) ->
-          let imp = FStar_Syntax_Util.mk_imp f1 f2 in check_trivial imp
-let (binop_guard :
-  (guard_formula -> guard_formula -> guard_formula) ->
-    guard_t -> guard_t -> guard_t)
-  =
-  fun f ->
-    fun g1 ->
-      fun g2 ->
-        let uu___ = f g1.guard_f g2.guard_f in
-        {
-          guard_f = uu___;
-          deferred_to_tac =
-            (FStar_Compiler_List.op_At g1.deferred_to_tac g2.deferred_to_tac);
-          deferred = (FStar_Compiler_List.op_At g1.deferred g2.deferred);
-          univ_ineqs =
-            ((FStar_Compiler_List.op_At
-                (FStar_Pervasives_Native.fst g1.univ_ineqs)
-                (FStar_Pervasives_Native.fst g2.univ_ineqs)),
-              (FStar_Compiler_List.op_At
-                 (FStar_Pervasives_Native.snd g1.univ_ineqs)
-                 (FStar_Pervasives_Native.snd g2.univ_ineqs)));
-          implicits = (FStar_Compiler_List.op_At g1.implicits g2.implicits)
-        }
-let (conj_guard : guard_t -> guard_t -> guard_t) =
-  fun g1 -> fun g2 -> binop_guard conj_guard_f g1 g2
-let (imp_guard : guard_t -> guard_t -> guard_t) =
-  fun g1 -> fun g2 -> binop_guard imp_guard_f g1 g2
-let (conj_guards : guard_t Prims.list -> guard_t) =
-  fun gs -> FStar_Compiler_List.fold_left conj_guard trivial_guard gs
-let (split_guard : guard_t -> (guard_t * guard_t)) =
-  fun g ->
-    ({
-       guard_f = Trivial;
-       deferred_to_tac = (g.deferred_to_tac);
-       deferred = (g.deferred);
-       univ_ineqs = (g.univ_ineqs);
-       implicits = (g.implicits)
-     },
-      {
-        guard_f = (g.guard_f);
-        deferred_to_tac = (trivial_guard.deferred_to_tac);
-        deferred = (trivial_guard.deferred);
-        univ_ineqs = (trivial_guard.univ_ineqs);
-        implicits = (trivial_guard.implicits)
-      })
-let (weaken_guard_formula : guard_t -> FStar_Syntax_Syntax.typ -> guard_t) =
-  fun g ->
-    fun fml ->
-      match g.guard_f with
-      | Trivial -> g
-      | NonTrivial f ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Util.mk_imp fml f in
-            check_trivial uu___1 in
-          {
-            guard_f = uu___;
-            deferred_to_tac = (g.deferred_to_tac);
-            deferred = (g.deferred);
-            univ_ineqs = (g.univ_ineqs);
-            implicits = (g.implicits)
-          }
-type lcomp =
-  {
-  eff_name: FStar_Ident.lident ;
-  res_typ: FStar_Syntax_Syntax.typ ;
-  cflags: FStar_Syntax_Syntax.cflag Prims.list ;
-  comp_thunk:
-    (unit -> (FStar_Syntax_Syntax.comp * guard_t), FStar_Syntax_Syntax.comp)
-      FStar_Pervasives.either FStar_Compiler_Effect.ref
-    }
-let (__proj__Mklcomp__item__eff_name : lcomp -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { eff_name; res_typ; cflags; comp_thunk;_} -> eff_name
-let (__proj__Mklcomp__item__res_typ : lcomp -> FStar_Syntax_Syntax.typ) =
-  fun projectee ->
-    match projectee with
-    | { eff_name; res_typ; cflags; comp_thunk;_} -> res_typ
-let (__proj__Mklcomp__item__cflags :
-  lcomp -> FStar_Syntax_Syntax.cflag Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { eff_name; res_typ; cflags; comp_thunk;_} -> cflags
-let (__proj__Mklcomp__item__comp_thunk :
-  lcomp ->
-    (unit -> (FStar_Syntax_Syntax.comp * guard_t), FStar_Syntax_Syntax.comp)
-      FStar_Pervasives.either FStar_Compiler_Effect.ref)
-  =
-  fun projectee ->
-    match projectee with
-    | { eff_name; res_typ; cflags; comp_thunk;_} -> comp_thunk
-let (mk_lcomp :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.cflag Prims.list ->
-        (unit -> (FStar_Syntax_Syntax.comp * guard_t)) -> lcomp)
-  =
-  fun eff_name ->
-    fun res_typ ->
-      fun cflags ->
-        fun comp_thunk ->
-          let uu___ =
-            FStar_Compiler_Util.mk_ref (FStar_Pervasives.Inl comp_thunk) in
-          { eff_name; res_typ; cflags; comp_thunk = uu___ }
-let (lcomp_comp : lcomp -> (FStar_Syntax_Syntax.comp * guard_t)) =
-  fun lc ->
-    let uu___ = FStar_Compiler_Effect.op_Bang lc.comp_thunk in
-    match uu___ with
-    | FStar_Pervasives.Inl thunk ->
-        let uu___1 = thunk () in
-        (match uu___1 with
-         | (c, g) ->
-             (FStar_Compiler_Effect.op_Colon_Equals lc.comp_thunk
-                (FStar_Pervasives.Inr c);
-              (c, g)))
-    | FStar_Pervasives.Inr c -> (c, trivial_guard)
-let (apply_lcomp :
-  (FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp) ->
-    (guard_t -> guard_t) -> lcomp -> lcomp)
-  =
-  fun fc ->
-    fun fg ->
-      fun lc ->
-        mk_lcomp lc.eff_name lc.res_typ lc.cflags
-          (fun uu___ ->
-             let uu___1 = lcomp_comp lc in
-             match uu___1 with
-             | (c, g) ->
-                 let uu___2 = fc c in let uu___3 = fg g in (uu___2, uu___3))
-let (lcomp_to_string : lcomp -> Prims.string) =
-  fun lc ->
-    let uu___ = FStar_Options.print_effect_args () in
-    if uu___
-    then
-      let uu___1 =
-        let uu___2 = FStar_Compiler_Effect.op_Bar_Greater lc lcomp_comp in
-        FStar_Compiler_Effect.op_Bar_Greater uu___2
-          FStar_Pervasives_Native.fst in
-      FStar_Syntax_Print.comp_to_string uu___1
-    else
-      (let uu___2 = FStar_Syntax_Print.lid_to_string lc.eff_name in
-       let uu___3 = FStar_Syntax_Print.term_to_string lc.res_typ in
-       FStar_Compiler_Util.format2 "%s %s" uu___2 uu___3)
-let (lcomp_set_flags :
-  lcomp -> FStar_Syntax_Syntax.cflag Prims.list -> lcomp) =
-  fun lc ->
-    fun fs ->
-      let comp_typ_set_flags c =
-        match c.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Total uu___ -> c
-        | FStar_Syntax_Syntax.GTotal uu___ -> c
-        | FStar_Syntax_Syntax.Comp ct ->
-            let ct1 =
-              {
-                FStar_Syntax_Syntax.comp_univs =
-                  (ct.FStar_Syntax_Syntax.comp_univs);
-                FStar_Syntax_Syntax.effect_name =
-                  (ct.FStar_Syntax_Syntax.effect_name);
-                FStar_Syntax_Syntax.result_typ =
-                  (ct.FStar_Syntax_Syntax.result_typ);
-                FStar_Syntax_Syntax.effect_args =
-                  (ct.FStar_Syntax_Syntax.effect_args);
-                FStar_Syntax_Syntax.flags = fs
-              } in
-            {
-              FStar_Syntax_Syntax.n = (FStar_Syntax_Syntax.Comp ct1);
-              FStar_Syntax_Syntax.pos = (c.FStar_Syntax_Syntax.pos);
-              FStar_Syntax_Syntax.vars = (c.FStar_Syntax_Syntax.vars);
-              FStar_Syntax_Syntax.hash_code =
-                (c.FStar_Syntax_Syntax.hash_code)
-            } in
-      mk_lcomp lc.eff_name lc.res_typ fs
-        (fun uu___ ->
-           let uu___1 = FStar_Compiler_Effect.op_Bar_Greater lc lcomp_comp in
-           FStar_Compiler_Effect.op_Bar_Greater uu___1
-             (fun uu___2 ->
-                match uu___2 with | (c, g) -> ((comp_typ_set_flags c), g)))
-let (is_total_lcomp : lcomp -> Prims.bool) =
-  fun c ->
-    (FStar_Ident.lid_equals c.eff_name FStar_Parser_Const.effect_Tot_lid) ||
-      (FStar_Compiler_Effect.op_Bar_Greater c.cflags
-         (FStar_Compiler_Util.for_some
-            (fun uu___ ->
-               match uu___ with
-               | FStar_Syntax_Syntax.TOTAL -> true
-               | FStar_Syntax_Syntax.RETURN -> true
-               | uu___1 -> false)))
-let (is_tot_or_gtot_lcomp : lcomp -> Prims.bool) =
-  fun c ->
-    ((FStar_Ident.lid_equals c.eff_name FStar_Parser_Const.effect_Tot_lid) ||
-       (FStar_Ident.lid_equals c.eff_name FStar_Parser_Const.effect_GTot_lid))
-      ||
-      (FStar_Compiler_Effect.op_Bar_Greater c.cflags
-         (FStar_Compiler_Util.for_some
-            (fun uu___ ->
-               match uu___ with
-               | FStar_Syntax_Syntax.TOTAL -> true
-               | FStar_Syntax_Syntax.RETURN -> true
-               | uu___1 -> false)))
-let (is_lcomp_partial_return : lcomp -> Prims.bool) =
-  fun c ->
-    FStar_Compiler_Effect.op_Bar_Greater c.cflags
-      (FStar_Compiler_Util.for_some
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.RETURN -> true
-            | FStar_Syntax_Syntax.PARTIAL_RETURN -> true
-            | uu___1 -> false))
-let (is_pure_lcomp : lcomp -> Prims.bool) =
-  fun lc ->
-    ((is_total_lcomp lc) || (FStar_Syntax_Util.is_pure_effect lc.eff_name))
-      ||
-      (FStar_Compiler_Effect.op_Bar_Greater lc.cflags
-         (FStar_Compiler_Util.for_some
-            (fun uu___ ->
-               match uu___ with
-               | FStar_Syntax_Syntax.LEMMA -> true
-               | uu___1 -> false)))
-let (is_pure_or_ghost_lcomp : lcomp -> Prims.bool) =
-  fun lc ->
-    (is_pure_lcomp lc) || (FStar_Syntax_Util.is_ghost_effect lc.eff_name)
-let (set_result_typ_lc : lcomp -> FStar_Syntax_Syntax.typ -> lcomp) =
-  fun lc ->
-    fun t ->
-      mk_lcomp lc.eff_name t lc.cflags
-        (fun uu___ ->
-           let uu___1 = FStar_Compiler_Effect.op_Bar_Greater lc lcomp_comp in
-           FStar_Compiler_Effect.op_Bar_Greater uu___1
-             (fun uu___2 ->
-                match uu___2 with
-                | (c, g) ->
-                    let uu___3 = FStar_Syntax_Util.set_result_typ c t in
-                    (uu___3, g)))
-let (residual_comp_of_lcomp : lcomp -> FStar_Syntax_Syntax.residual_comp) =
-  fun lc ->
-    {
-      FStar_Syntax_Syntax.residual_effect = (lc.eff_name);
-      FStar_Syntax_Syntax.residual_typ =
-        (FStar_Pervasives_Native.Some (lc.res_typ));
-      FStar_Syntax_Syntax.residual_flags = (lc.cflags)
-    }
-let (lcomp_of_comp_guard : FStar_Syntax_Syntax.comp -> guard_t -> lcomp) =
-  fun c0 ->
-    fun g ->
-      let uu___ =
-        match c0.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Total uu___1 ->
-            (FStar_Parser_Const.effect_Tot_lid, [FStar_Syntax_Syntax.TOTAL])
-        | FStar_Syntax_Syntax.GTotal uu___1 ->
-            (FStar_Parser_Const.effect_GTot_lid,
-              [FStar_Syntax_Syntax.SOMETRIVIAL])
-        | FStar_Syntax_Syntax.Comp c ->
-            ((c.FStar_Syntax_Syntax.effect_name),
-              (c.FStar_Syntax_Syntax.flags)) in
-      match uu___ with
-      | (eff_name, flags) ->
-          mk_lcomp eff_name (FStar_Syntax_Util.comp_result c0) flags
-            (fun uu___1 -> (c0, g))
-let (lcomp_of_comp : FStar_Syntax_Syntax.comp -> lcomp) =
-  fun c0 -> lcomp_of_comp_guard c0 trivial_guard
-let (simplify :
-  Prims.bool -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun debug ->
-    fun tm ->
-      let w t =
-        {
-          FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-          FStar_Syntax_Syntax.pos = (tm.FStar_Syntax_Syntax.pos);
-          FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-          FStar_Syntax_Syntax.hash_code = (t.FStar_Syntax_Syntax.hash_code)
-        } in
-      let simp_t t =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Util.unmeta t in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_fvar fv when
-            FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.true_lid ->
-            FStar_Pervasives_Native.Some true
-        | FStar_Syntax_Syntax.Tm_fvar fv when
-            FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.false_lid ->
-            FStar_Pervasives_Native.Some false
-        | uu___1 -> FStar_Pervasives_Native.None in
-      let rec args_are_binders args bs =
-        match (args, bs) with
-        | ((t, uu___)::args1, b::bs1) ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Subst.compress t in
-              uu___2.FStar_Syntax_Syntax.n in
-            (match uu___1 with
-             | FStar_Syntax_Syntax.Tm_name bv' ->
-                 (FStar_Syntax_Syntax.bv_eq b.FStar_Syntax_Syntax.binder_bv
-                    bv')
-                   && (args_are_binders args1 bs1)
-             | uu___2 -> false)
-        | ([], []) -> true
-        | (uu___, uu___1) -> false in
-      let is_applied bs t =
-        if debug
-        then
-          (let uu___1 = FStar_Syntax_Print.term_to_string t in
-           let uu___2 = FStar_Syntax_Print.tag_of_term t in
-           FStar_Compiler_Util.print2 "WPE> is_applied %s -- %s\n" uu___1
-             uu___2)
-        else ();
-        (let uu___1 = FStar_Syntax_Util.head_and_args_full t in
-         match uu___1 with
-         | (hd, args) ->
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Subst.compress hd in
-               uu___3.FStar_Syntax_Syntax.n in
-             (match uu___2 with
-              | FStar_Syntax_Syntax.Tm_name bv when args_are_binders args bs
-                  ->
-                  (if debug
-                   then
-                     (let uu___4 = FStar_Syntax_Print.term_to_string t in
-                      let uu___5 = FStar_Syntax_Print.bv_to_string bv in
-                      let uu___6 = FStar_Syntax_Print.term_to_string hd in
-                      FStar_Compiler_Util.print3
-                        "WPE> got it\n>>>>top = %s\n>>>>b = %s\n>>>>hd = %s\n"
-                        uu___4 uu___5 uu___6)
-                   else ();
-                   FStar_Pervasives_Native.Some bv)
-              | uu___3 -> FStar_Pervasives_Native.None)) in
-      let is_applied_maybe_squashed bs t =
-        if debug
-        then
-          (let uu___1 = FStar_Syntax_Print.term_to_string t in
-           let uu___2 = FStar_Syntax_Print.tag_of_term t in
-           FStar_Compiler_Util.print2
-             "WPE> is_applied_maybe_squashed %s -- %s\n" uu___1 uu___2)
-        else ();
-        (let uu___1 = FStar_Syntax_Util.is_squash t in
-         match uu___1 with
-         | FStar_Pervasives_Native.Some (uu___2, t') -> is_applied bs t'
-         | uu___2 ->
-             let uu___3 = FStar_Syntax_Util.is_auto_squash t in
-             (match uu___3 with
-              | FStar_Pervasives_Native.Some (uu___4, t') -> is_applied bs t'
-              | uu___4 -> is_applied bs t)) in
-      let is_const_match phi =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress phi in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_match (uu___1, uu___2, br::brs, uu___3) ->
-            let uu___4 = br in
-            (match uu___4 with
-             | (uu___5, uu___6, e) ->
-                 let r =
-                   let uu___7 = simp_t e in
-                   match uu___7 with
-                   | FStar_Pervasives_Native.None ->
-                       FStar_Pervasives_Native.None
-                   | FStar_Pervasives_Native.Some b ->
-                       let uu___8 =
-                         FStar_Compiler_List.for_all
-                           (fun uu___9 ->
-                              match uu___9 with
-                              | (uu___10, uu___11, e') ->
-                                  let uu___12 = simp_t e' in
-                                  uu___12 = (FStar_Pervasives_Native.Some b))
-                           brs in
-                       if uu___8
-                       then FStar_Pervasives_Native.Some b
-                       else FStar_Pervasives_Native.None in
-                 r)
-        | uu___1 -> FStar_Pervasives_Native.None in
-      let maybe_auto_squash t =
-        let uu___ = FStar_Syntax_Util.is_sub_singleton t in
-        if uu___
-        then t
-        else FStar_Syntax_Util.mk_auto_squash FStar_Syntax_Syntax.U_zero t in
-      let squashed_head_un_auto_squash_args t =
-        let maybe_un_auto_squash_arg uu___ =
-          match uu___ with
-          | (t1, q) ->
-              let uu___1 = FStar_Syntax_Util.is_auto_squash t1 in
-              (match uu___1 with
-               | FStar_Pervasives_Native.Some
-                   (FStar_Syntax_Syntax.U_zero, t2) -> (t2, q)
-               | uu___2 -> (t1, q)) in
-        let uu___ = FStar_Syntax_Util.head_and_args t in
-        match uu___ with
-        | (head, args) ->
-            let args1 = FStar_Compiler_List.map maybe_un_auto_squash_arg args in
-            FStar_Syntax_Syntax.mk_Tm_app head args1
-              t.FStar_Syntax_Syntax.pos in
-      let rec clearly_inhabited ty =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Util.unmeta ty in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_uinst (t, uu___1) -> clearly_inhabited t
-        | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-            clearly_inhabited (FStar_Syntax_Util.comp_result c)
-        | FStar_Syntax_Syntax.Tm_fvar fv ->
-            let l = FStar_Syntax_Syntax.lid_of_fv fv in
-            (((FStar_Ident.lid_equals l FStar_Parser_Const.int_lid) ||
-                (FStar_Ident.lid_equals l FStar_Parser_Const.bool_lid))
-               || (FStar_Ident.lid_equals l FStar_Parser_Const.string_lid))
-              || (FStar_Ident.lid_equals l FStar_Parser_Const.exn_lid)
-        | uu___1 -> false in
-      let simplify1 arg =
-        let uu___ = simp_t (FStar_Pervasives_Native.fst arg) in (uu___, arg) in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress tm in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uinst
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                  FStar_Syntax_Syntax.pos = uu___1;
-                  FStar_Syntax_Syntax.vars = uu___2;
-                  FStar_Syntax_Syntax.hash_code = uu___3;_},
-                uu___4);
-             FStar_Syntax_Syntax.pos = uu___5;
-             FStar_Syntax_Syntax.vars = uu___6;
-             FStar_Syntax_Syntax.hash_code = uu___7;_},
-           args)
-          ->
-          let uu___8 =
-            FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.and_lid in
-          if uu___8
-          then
-            let uu___9 =
-              FStar_Compiler_Effect.op_Bar_Greater args
-                (FStar_Compiler_List.map simplify1) in
-            (match uu___9 with
-             | (FStar_Pervasives_Native.Some (true), uu___10)::(uu___11,
-                                                                (arg,
-                                                                 uu___12))::[]
-                 -> maybe_auto_squash arg
-             | (uu___10, (arg, uu___11))::(FStar_Pervasives_Native.Some
-                                           (true), uu___12)::[]
-                 -> maybe_auto_squash arg
-             | (FStar_Pervasives_Native.Some (false), uu___10)::uu___11::[]
-                 -> w FStar_Syntax_Util.t_false
-             | uu___10::(FStar_Pervasives_Native.Some (false), uu___11)::[]
-                 -> w FStar_Syntax_Util.t_false
-             | uu___10 -> squashed_head_un_auto_squash_args tm)
-          else
-            (let uu___10 =
-               FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.or_lid in
-             if uu___10
-             then
-               let uu___11 =
-                 FStar_Compiler_Effect.op_Bar_Greater args
-                   (FStar_Compiler_List.map simplify1) in
-               match uu___11 with
-               | (FStar_Pervasives_Native.Some (true), uu___12)::uu___13::[]
-                   -> w FStar_Syntax_Util.t_true
-               | uu___12::(FStar_Pervasives_Native.Some (true), uu___13)::[]
-                   -> w FStar_Syntax_Util.t_true
-               | (FStar_Pervasives_Native.Some (false), uu___12)::(uu___13,
-                                                                   (arg,
-                                                                    uu___14))::[]
-                   -> maybe_auto_squash arg
-               | (uu___12, (arg, uu___13))::(FStar_Pervasives_Native.Some
-                                             (false), uu___14)::[]
-                   -> maybe_auto_squash arg
-               | uu___12 -> squashed_head_un_auto_squash_args tm
-             else
-               (let uu___12 =
-                  FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.imp_lid in
-                if uu___12
-                then
-                  let uu___13 =
-                    FStar_Compiler_Effect.op_Bar_Greater args
-                      (FStar_Compiler_List.map simplify1) in
-                  match uu___13 with
-                  | uu___14::(FStar_Pervasives_Native.Some (true), uu___15)::[]
-                      -> w FStar_Syntax_Util.t_true
-                  | (FStar_Pervasives_Native.Some (false), uu___14)::uu___15::[]
-                      -> w FStar_Syntax_Util.t_true
-                  | (FStar_Pervasives_Native.Some (true), uu___14)::(uu___15,
-                                                                    (arg,
-                                                                    uu___16))::[]
-                      -> maybe_auto_squash arg
-                  | (uu___14, (p, uu___15))::(uu___16, (q, uu___17))::[] ->
-                      let uu___18 = FStar_Syntax_Util.term_eq p q in
-                      (if uu___18
-                       then w FStar_Syntax_Util.t_true
-                       else squashed_head_un_auto_squash_args tm)
-                  | uu___14 -> squashed_head_un_auto_squash_args tm
-                else
-                  (let uu___14 =
-                     FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.iff_lid in
-                   if uu___14
-                   then
-                     let uu___15 =
-                       FStar_Compiler_Effect.op_Bar_Greater args
-                         (FStar_Compiler_List.map simplify1) in
-                     match uu___15 with
-                     | (FStar_Pervasives_Native.Some (true), uu___16)::
-                         (FStar_Pervasives_Native.Some (true), uu___17)::[]
-                         -> w FStar_Syntax_Util.t_true
-                     | (FStar_Pervasives_Native.Some (false), uu___16)::
-                         (FStar_Pervasives_Native.Some (false), uu___17)::[]
-                         -> w FStar_Syntax_Util.t_true
-                     | (FStar_Pervasives_Native.Some (true), uu___16)::
-                         (FStar_Pervasives_Native.Some (false), uu___17)::[]
-                         -> w FStar_Syntax_Util.t_false
-                     | (FStar_Pervasives_Native.Some (false), uu___16)::
-                         (FStar_Pervasives_Native.Some (true), uu___17)::[]
-                         -> w FStar_Syntax_Util.t_false
-                     | (uu___16, (arg, uu___17))::(FStar_Pervasives_Native.Some
-                                                   (true), uu___18)::[]
-                         -> maybe_auto_squash arg
-                     | (FStar_Pervasives_Native.Some (true), uu___16)::
-                         (uu___17, (arg, uu___18))::[] ->
-                         maybe_auto_squash arg
-                     | (uu___16, (arg, uu___17))::(FStar_Pervasives_Native.Some
-                                                   (false), uu___18)::[]
-                         ->
-                         let uu___19 = FStar_Syntax_Util.mk_neg arg in
-                         maybe_auto_squash uu___19
-                     | (FStar_Pervasives_Native.Some (false), uu___16)::
-                         (uu___17, (arg, uu___18))::[] ->
-                         let uu___19 = FStar_Syntax_Util.mk_neg arg in
-                         maybe_auto_squash uu___19
-                     | (uu___16, (p, uu___17))::(uu___18, (q, uu___19))::[]
-                         ->
-                         let uu___20 = FStar_Syntax_Util.term_eq p q in
-                         (if uu___20
-                          then w FStar_Syntax_Util.t_true
-                          else squashed_head_un_auto_squash_args tm)
-                     | uu___16 -> squashed_head_un_auto_squash_args tm
-                   else
-                     (let uu___16 =
-                        FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.not_lid in
-                      if uu___16
-                      then
-                        let uu___17 =
-                          FStar_Compiler_Effect.op_Bar_Greater args
-                            (FStar_Compiler_List.map simplify1) in
-                        match uu___17 with
-                        | (FStar_Pervasives_Native.Some (true), uu___18)::[]
-                            -> w FStar_Syntax_Util.t_false
-                        | (FStar_Pervasives_Native.Some (false), uu___18)::[]
-                            -> w FStar_Syntax_Util.t_true
-                        | uu___18 -> squashed_head_un_auto_squash_args tm
-                      else
-                        (let uu___18 =
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.forall_lid in
-                         if uu___18
-                         then
-                           match args with
-                           | (t, uu___19)::[] ->
-                               let uu___20 =
-                                 let uu___21 = FStar_Syntax_Subst.compress t in
-                                 uu___21.FStar_Syntax_Syntax.n in
-                               (match uu___20 with
-                                | FStar_Syntax_Syntax.Tm_abs
-                                    (uu___21::[], body, uu___22) ->
-                                    let uu___23 = simp_t body in
-                                    (match uu___23 with
-                                     | FStar_Pervasives_Native.Some (true) ->
-                                         w FStar_Syntax_Util.t_true
-                                     | uu___24 -> tm)
-                                | uu___21 -> tm)
-                           | (ty, FStar_Pervasives_Native.Some
-                              { FStar_Syntax_Syntax.aqual_implicit = true;
-                                FStar_Syntax_Syntax.aqual_attributes =
-                                  uu___19;_})::(t, uu___20)::[]
-                               ->
-                               let uu___21 =
-                                 let uu___22 = FStar_Syntax_Subst.compress t in
-                                 uu___22.FStar_Syntax_Syntax.n in
-                               (match uu___21 with
-                                | FStar_Syntax_Syntax.Tm_abs
-                                    (uu___22::[], body, uu___23) ->
-                                    let uu___24 = simp_t body in
-                                    (match uu___24 with
-                                     | FStar_Pervasives_Native.Some (true) ->
-                                         w FStar_Syntax_Util.t_true
-                                     | FStar_Pervasives_Native.Some (false)
-                                         when clearly_inhabited ty ->
-                                         w FStar_Syntax_Util.t_false
-                                     | uu___25 -> tm)
-                                | uu___22 -> tm)
-                           | uu___19 -> tm
-                         else
-                           (let uu___20 =
-                              FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.exists_lid in
-                            if uu___20
-                            then
-                              match args with
-                              | (t, uu___21)::[] ->
-                                  let uu___22 =
-                                    let uu___23 =
-                                      FStar_Syntax_Subst.compress t in
-                                    uu___23.FStar_Syntax_Syntax.n in
-                                  (match uu___22 with
-                                   | FStar_Syntax_Syntax.Tm_abs
-                                       (uu___23::[], body, uu___24) ->
-                                       let uu___25 = simp_t body in
-                                       (match uu___25 with
-                                        | FStar_Pervasives_Native.Some
-                                            (false) ->
-                                            w FStar_Syntax_Util.t_false
-                                        | uu___26 -> tm)
-                                   | uu___23 -> tm)
-                              | (ty, FStar_Pervasives_Native.Some
-                                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                                   FStar_Syntax_Syntax.aqual_attributes =
-                                     uu___21;_})::(t, uu___22)::[]
-                                  ->
-                                  let uu___23 =
-                                    let uu___24 =
-                                      FStar_Syntax_Subst.compress t in
-                                    uu___24.FStar_Syntax_Syntax.n in
-                                  (match uu___23 with
-                                   | FStar_Syntax_Syntax.Tm_abs
-                                       (uu___24::[], body, uu___25) ->
-                                       let uu___26 = simp_t body in
-                                       (match uu___26 with
-                                        | FStar_Pervasives_Native.Some
-                                            (false) ->
-                                            w FStar_Syntax_Util.t_false
-                                        | FStar_Pervasives_Native.Some (true)
-                                            when clearly_inhabited ty ->
-                                            w FStar_Syntax_Util.t_true
-                                        | uu___27 -> tm)
-                                   | uu___24 -> tm)
-                              | uu___21 -> tm
-                            else
-                              (let uu___22 =
-                                 FStar_Syntax_Syntax.fv_eq_lid fv
-                                   FStar_Parser_Const.b2t_lid in
-                               if uu___22
-                               then
-                                 match args with
-                                 | ({
-                                      FStar_Syntax_Syntax.n =
-                                        FStar_Syntax_Syntax.Tm_constant
-                                        (FStar_Const.Const_bool (true));
-                                      FStar_Syntax_Syntax.pos = uu___23;
-                                      FStar_Syntax_Syntax.vars = uu___24;
-                                      FStar_Syntax_Syntax.hash_code = uu___25;_},
-                                    uu___26)::[] ->
-                                     w FStar_Syntax_Util.t_true
-                                 | ({
-                                      FStar_Syntax_Syntax.n =
-                                        FStar_Syntax_Syntax.Tm_constant
-                                        (FStar_Const.Const_bool (false));
-                                      FStar_Syntax_Syntax.pos = uu___23;
-                                      FStar_Syntax_Syntax.vars = uu___24;
-                                      FStar_Syntax_Syntax.hash_code = uu___25;_},
-                                    uu___26)::[] ->
-                                     w FStar_Syntax_Util.t_false
-                                 | uu___23 -> tm
-                               else
-                                 (let uu___24 =
-                                    FStar_Syntax_Syntax.fv_eq_lid fv
-                                      FStar_Parser_Const.haseq_lid in
-                                  if uu___24
-                                  then
-                                    let t_has_eq_for_sure t =
-                                      let haseq_lids =
-                                        [FStar_Parser_Const.int_lid;
-                                        FStar_Parser_Const.bool_lid;
-                                        FStar_Parser_Const.unit_lid;
-                                        FStar_Parser_Const.string_lid] in
-                                      let uu___25 =
-                                        let uu___26 =
-                                          FStar_Syntax_Subst.compress t in
-                                        uu___26.FStar_Syntax_Syntax.n in
-                                      match uu___25 with
-                                      | FStar_Syntax_Syntax.Tm_fvar fv1 when
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            haseq_lids
-                                            (FStar_Compiler_List.existsb
-                                               (fun l ->
-                                                  FStar_Syntax_Syntax.fv_eq_lid
-                                                    fv1 l))
-                                          -> true
-                                      | uu___26 -> false in
-                                    (if
-                                       (FStar_Compiler_List.length args) =
-                                         Prims.int_one
-                                     then
-                                       let t =
-                                         let uu___25 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             args FStar_Compiler_List.hd in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___25
-                                           FStar_Pervasives_Native.fst in
-                                       let uu___25 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           t t_has_eq_for_sure in
-                                       (if uu___25
-                                        then w FStar_Syntax_Util.t_true
-                                        else
-                                          (let uu___27 =
-                                             let uu___28 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___28.FStar_Syntax_Syntax.n in
-                                           match uu___27 with
-                                           | FStar_Syntax_Syntax.Tm_refine
-                                               uu___28 ->
-                                               let t1 =
-                                                 FStar_Syntax_Util.unrefine t in
-                                               let uu___29 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   t1 t_has_eq_for_sure in
-                                               if uu___29
-                                               then
-                                                 w FStar_Syntax_Util.t_true
-                                               else
-                                                 (let haseq_tm =
-                                                    let uu___31 =
-                                                      let uu___32 =
-                                                        FStar_Syntax_Subst.compress
-                                                          tm in
-                                                      uu___32.FStar_Syntax_Syntax.n in
-                                                    match uu___31 with
-                                                    | FStar_Syntax_Syntax.Tm_app
-                                                        (hd, uu___32) -> hd
-                                                    | uu___32 ->
-                                                        failwith
-                                                          "Impossible! We have already checked that this is a Tm_app" in
-                                                  let uu___31 =
-                                                    let uu___32 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        t1
-                                                        FStar_Syntax_Syntax.as_arg in
-                                                    [uu___32] in
-                                                  FStar_Syntax_Util.mk_app
-                                                    haseq_tm uu___31)
-                                           | uu___28 -> tm))
-                                     else tm)
-                                  else
-                                    (let uu___26 =
-                                       FStar_Syntax_Syntax.fv_eq_lid fv
-                                         FStar_Parser_Const.eq2_lid in
-                                     if uu___26
-                                     then
-                                       match args with
-                                       | (_typ, uu___27)::(a1, uu___28)::
-                                           (a2, uu___29)::[] ->
-                                           let uu___30 =
-                                             FStar_Syntax_Util.eq_tm a1 a2 in
-                                           (match uu___30 with
-                                            | FStar_Syntax_Util.Equal ->
-                                                w FStar_Syntax_Util.t_true
-                                            | FStar_Syntax_Util.NotEqual ->
-                                                w FStar_Syntax_Util.t_false
-                                            | uu___31 -> tm)
-                                       | uu___27 -> tm
-                                     else
-                                       (let uu___28 =
-                                          FStar_Syntax_Util.is_auto_squash tm in
-                                        match uu___28 with
-                                        | FStar_Pervasives_Native.Some
-                                            (FStar_Syntax_Syntax.U_zero, t)
-                                            when
-                                            FStar_Syntax_Util.is_sub_singleton
-                                              t
-                                            -> t
-                                        | uu___29 -> tm))))))))))
-      | FStar_Syntax_Syntax.Tm_app
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           args)
-          ->
-          let uu___4 =
-            FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.and_lid in
-          if uu___4
-          then
-            let uu___5 =
-              FStar_Compiler_Effect.op_Bar_Greater args
-                (FStar_Compiler_List.map simplify1) in
-            (match uu___5 with
-             | (FStar_Pervasives_Native.Some (true), uu___6)::(uu___7,
-                                                               (arg, uu___8))::[]
-                 -> maybe_auto_squash arg
-             | (uu___6, (arg, uu___7))::(FStar_Pervasives_Native.Some (true),
-                                         uu___8)::[]
-                 -> maybe_auto_squash arg
-             | (FStar_Pervasives_Native.Some (false), uu___6)::uu___7::[] ->
-                 w FStar_Syntax_Util.t_false
-             | uu___6::(FStar_Pervasives_Native.Some (false), uu___7)::[] ->
-                 w FStar_Syntax_Util.t_false
-             | uu___6 -> squashed_head_un_auto_squash_args tm)
-          else
-            (let uu___6 =
-               FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.or_lid in
-             if uu___6
-             then
-               let uu___7 =
-                 FStar_Compiler_Effect.op_Bar_Greater args
-                   (FStar_Compiler_List.map simplify1) in
-               match uu___7 with
-               | (FStar_Pervasives_Native.Some (true), uu___8)::uu___9::[] ->
-                   w FStar_Syntax_Util.t_true
-               | uu___8::(FStar_Pervasives_Native.Some (true), uu___9)::[] ->
-                   w FStar_Syntax_Util.t_true
-               | (FStar_Pervasives_Native.Some (false), uu___8)::(uu___9,
-                                                                  (arg,
-                                                                   uu___10))::[]
-                   -> maybe_auto_squash arg
-               | (uu___8, (arg, uu___9))::(FStar_Pervasives_Native.Some
-                                           (false), uu___10)::[]
-                   -> maybe_auto_squash arg
-               | uu___8 -> squashed_head_un_auto_squash_args tm
-             else
-               (let uu___8 =
-                  FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.imp_lid in
-                if uu___8
-                then
-                  let uu___9 =
-                    FStar_Compiler_Effect.op_Bar_Greater args
-                      (FStar_Compiler_List.map simplify1) in
-                  match uu___9 with
-                  | uu___10::(FStar_Pervasives_Native.Some (true), uu___11)::[]
-                      -> w FStar_Syntax_Util.t_true
-                  | (FStar_Pervasives_Native.Some (false), uu___10)::uu___11::[]
-                      -> w FStar_Syntax_Util.t_true
-                  | (FStar_Pervasives_Native.Some (true), uu___10)::(uu___11,
-                                                                    (arg,
-                                                                    uu___12))::[]
-                      -> maybe_auto_squash arg
-                  | (uu___10, (p, uu___11))::(uu___12, (q, uu___13))::[] ->
-                      let uu___14 = FStar_Syntax_Util.term_eq p q in
-                      (if uu___14
-                       then w FStar_Syntax_Util.t_true
-                       else squashed_head_un_auto_squash_args tm)
-                  | uu___10 -> squashed_head_un_auto_squash_args tm
-                else
-                  (let uu___10 =
-                     FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.iff_lid in
-                   if uu___10
-                   then
-                     let uu___11 =
-                       FStar_Compiler_Effect.op_Bar_Greater args
-                         (FStar_Compiler_List.map simplify1) in
-                     match uu___11 with
-                     | (FStar_Pervasives_Native.Some (true), uu___12)::
-                         (FStar_Pervasives_Native.Some (true), uu___13)::[]
-                         -> w FStar_Syntax_Util.t_true
-                     | (FStar_Pervasives_Native.Some (false), uu___12)::
-                         (FStar_Pervasives_Native.Some (false), uu___13)::[]
-                         -> w FStar_Syntax_Util.t_true
-                     | (FStar_Pervasives_Native.Some (true), uu___12)::
-                         (FStar_Pervasives_Native.Some (false), uu___13)::[]
-                         -> w FStar_Syntax_Util.t_false
-                     | (FStar_Pervasives_Native.Some (false), uu___12)::
-                         (FStar_Pervasives_Native.Some (true), uu___13)::[]
-                         -> w FStar_Syntax_Util.t_false
-                     | (uu___12, (arg, uu___13))::(FStar_Pervasives_Native.Some
-                                                   (true), uu___14)::[]
-                         -> maybe_auto_squash arg
-                     | (FStar_Pervasives_Native.Some (true), uu___12)::
-                         (uu___13, (arg, uu___14))::[] ->
-                         maybe_auto_squash arg
-                     | (uu___12, (arg, uu___13))::(FStar_Pervasives_Native.Some
-                                                   (false), uu___14)::[]
-                         ->
-                         let uu___15 = FStar_Syntax_Util.mk_neg arg in
-                         maybe_auto_squash uu___15
-                     | (FStar_Pervasives_Native.Some (false), uu___12)::
-                         (uu___13, (arg, uu___14))::[] ->
-                         let uu___15 = FStar_Syntax_Util.mk_neg arg in
-                         maybe_auto_squash uu___15
-                     | (uu___12, (p, uu___13))::(uu___14, (q, uu___15))::[]
-                         ->
-                         let uu___16 = FStar_Syntax_Util.term_eq p q in
-                         (if uu___16
-                          then w FStar_Syntax_Util.t_true
-                          else squashed_head_un_auto_squash_args tm)
-                     | uu___12 -> squashed_head_un_auto_squash_args tm
-                   else
-                     (let uu___12 =
-                        FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.not_lid in
-                      if uu___12
-                      then
-                        let uu___13 =
-                          FStar_Compiler_Effect.op_Bar_Greater args
-                            (FStar_Compiler_List.map simplify1) in
-                        match uu___13 with
-                        | (FStar_Pervasives_Native.Some (true), uu___14)::[]
-                            -> w FStar_Syntax_Util.t_false
-                        | (FStar_Pervasives_Native.Some (false), uu___14)::[]
-                            -> w FStar_Syntax_Util.t_true
-                        | uu___14 -> squashed_head_un_auto_squash_args tm
-                      else
-                        (let uu___14 =
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.forall_lid in
-                         if uu___14
-                         then
-                           match args with
-                           | (t, uu___15)::[] ->
-                               let uu___16 =
-                                 let uu___17 = FStar_Syntax_Subst.compress t in
-                                 uu___17.FStar_Syntax_Syntax.n in
-                               (match uu___16 with
-                                | FStar_Syntax_Syntax.Tm_abs
-                                    (uu___17::[], body, uu___18) ->
-                                    let uu___19 = simp_t body in
-                                    (match uu___19 with
-                                     | FStar_Pervasives_Native.Some (true) ->
-                                         w FStar_Syntax_Util.t_true
-                                     | uu___20 -> tm)
-                                | uu___17 -> tm)
-                           | (ty, FStar_Pervasives_Native.Some
-                              { FStar_Syntax_Syntax.aqual_implicit = true;
-                                FStar_Syntax_Syntax.aqual_attributes =
-                                  uu___15;_})::(t, uu___16)::[]
-                               ->
-                               let uu___17 =
-                                 let uu___18 = FStar_Syntax_Subst.compress t in
-                                 uu___18.FStar_Syntax_Syntax.n in
-                               (match uu___17 with
-                                | FStar_Syntax_Syntax.Tm_abs
-                                    (uu___18::[], body, uu___19) ->
-                                    let uu___20 = simp_t body in
-                                    (match uu___20 with
-                                     | FStar_Pervasives_Native.Some (true) ->
-                                         w FStar_Syntax_Util.t_true
-                                     | FStar_Pervasives_Native.Some (false)
-                                         when clearly_inhabited ty ->
-                                         w FStar_Syntax_Util.t_false
-                                     | uu___21 -> tm)
-                                | uu___18 -> tm)
-                           | uu___15 -> tm
-                         else
-                           (let uu___16 =
-                              FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.exists_lid in
-                            if uu___16
-                            then
-                              match args with
-                              | (t, uu___17)::[] ->
-                                  let uu___18 =
-                                    let uu___19 =
-                                      FStar_Syntax_Subst.compress t in
-                                    uu___19.FStar_Syntax_Syntax.n in
-                                  (match uu___18 with
-                                   | FStar_Syntax_Syntax.Tm_abs
-                                       (uu___19::[], body, uu___20) ->
-                                       let uu___21 = simp_t body in
-                                       (match uu___21 with
-                                        | FStar_Pervasives_Native.Some
-                                            (false) ->
-                                            w FStar_Syntax_Util.t_false
-                                        | uu___22 -> tm)
-                                   | uu___19 -> tm)
-                              | (ty, FStar_Pervasives_Native.Some
-                                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                                   FStar_Syntax_Syntax.aqual_attributes =
-                                     uu___17;_})::(t, uu___18)::[]
-                                  ->
-                                  let uu___19 =
-                                    let uu___20 =
-                                      FStar_Syntax_Subst.compress t in
-                                    uu___20.FStar_Syntax_Syntax.n in
-                                  (match uu___19 with
-                                   | FStar_Syntax_Syntax.Tm_abs
-                                       (uu___20::[], body, uu___21) ->
-                                       let uu___22 = simp_t body in
-                                       (match uu___22 with
-                                        | FStar_Pervasives_Native.Some
-                                            (false) ->
-                                            w FStar_Syntax_Util.t_false
-                                        | FStar_Pervasives_Native.Some (true)
-                                            when clearly_inhabited ty ->
-                                            w FStar_Syntax_Util.t_true
-                                        | uu___23 -> tm)
-                                   | uu___20 -> tm)
-                              | uu___17 -> tm
-                            else
-                              (let uu___18 =
-                                 FStar_Syntax_Syntax.fv_eq_lid fv
-                                   FStar_Parser_Const.b2t_lid in
-                               if uu___18
-                               then
-                                 match args with
-                                 | ({
-                                      FStar_Syntax_Syntax.n =
-                                        FStar_Syntax_Syntax.Tm_constant
-                                        (FStar_Const.Const_bool (true));
-                                      FStar_Syntax_Syntax.pos = uu___19;
-                                      FStar_Syntax_Syntax.vars = uu___20;
-                                      FStar_Syntax_Syntax.hash_code = uu___21;_},
-                                    uu___22)::[] ->
-                                     w FStar_Syntax_Util.t_true
-                                 | ({
-                                      FStar_Syntax_Syntax.n =
-                                        FStar_Syntax_Syntax.Tm_constant
-                                        (FStar_Const.Const_bool (false));
-                                      FStar_Syntax_Syntax.pos = uu___19;
-                                      FStar_Syntax_Syntax.vars = uu___20;
-                                      FStar_Syntax_Syntax.hash_code = uu___21;_},
-                                    uu___22)::[] ->
-                                     w FStar_Syntax_Util.t_false
-                                 | uu___19 -> tm
-                               else
-                                 (let uu___20 =
-                                    FStar_Syntax_Syntax.fv_eq_lid fv
-                                      FStar_Parser_Const.haseq_lid in
-                                  if uu___20
-                                  then
-                                    let t_has_eq_for_sure t =
-                                      let haseq_lids =
-                                        [FStar_Parser_Const.int_lid;
-                                        FStar_Parser_Const.bool_lid;
-                                        FStar_Parser_Const.unit_lid;
-                                        FStar_Parser_Const.string_lid] in
-                                      let uu___21 =
-                                        let uu___22 =
-                                          FStar_Syntax_Subst.compress t in
-                                        uu___22.FStar_Syntax_Syntax.n in
-                                      match uu___21 with
-                                      | FStar_Syntax_Syntax.Tm_fvar fv1 when
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            haseq_lids
-                                            (FStar_Compiler_List.existsb
-                                               (fun l ->
-                                                  FStar_Syntax_Syntax.fv_eq_lid
-                                                    fv1 l))
-                                          -> true
-                                      | uu___22 -> false in
-                                    (if
-                                       (FStar_Compiler_List.length args) =
-                                         Prims.int_one
-                                     then
-                                       let t =
-                                         let uu___21 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             args FStar_Compiler_List.hd in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___21
-                                           FStar_Pervasives_Native.fst in
-                                       let uu___21 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           t t_has_eq_for_sure in
-                                       (if uu___21
-                                        then w FStar_Syntax_Util.t_true
-                                        else
-                                          (let uu___23 =
-                                             let uu___24 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___24.FStar_Syntax_Syntax.n in
-                                           match uu___23 with
-                                           | FStar_Syntax_Syntax.Tm_refine
-                                               uu___24 ->
-                                               let t1 =
-                                                 FStar_Syntax_Util.unrefine t in
-                                               let uu___25 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   t1 t_has_eq_for_sure in
-                                               if uu___25
-                                               then
-                                                 w FStar_Syntax_Util.t_true
-                                               else
-                                                 (let haseq_tm =
-                                                    let uu___27 =
-                                                      let uu___28 =
-                                                        FStar_Syntax_Subst.compress
-                                                          tm in
-                                                      uu___28.FStar_Syntax_Syntax.n in
-                                                    match uu___27 with
-                                                    | FStar_Syntax_Syntax.Tm_app
-                                                        (hd, uu___28) -> hd
-                                                    | uu___28 ->
-                                                        failwith
-                                                          "Impossible! We have already checked that this is a Tm_app" in
-                                                  let uu___27 =
-                                                    let uu___28 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        t1
-                                                        FStar_Syntax_Syntax.as_arg in
-                                                    [uu___28] in
-                                                  FStar_Syntax_Util.mk_app
-                                                    haseq_tm uu___27)
-                                           | uu___24 -> tm))
-                                     else tm)
-                                  else
-                                    (let uu___22 =
-                                       FStar_Syntax_Syntax.fv_eq_lid fv
-                                         FStar_Parser_Const.eq2_lid in
-                                     if uu___22
-                                     then
-                                       match args with
-                                       | (_typ, uu___23)::(a1, uu___24)::
-                                           (a2, uu___25)::[] ->
-                                           let uu___26 =
-                                             FStar_Syntax_Util.eq_tm a1 a2 in
-                                           (match uu___26 with
-                                            | FStar_Syntax_Util.Equal ->
-                                                w FStar_Syntax_Util.t_true
-                                            | FStar_Syntax_Util.NotEqual ->
-                                                w FStar_Syntax_Util.t_false
-                                            | uu___27 -> tm)
-                                       | uu___23 -> tm
-                                     else
-                                       (let uu___24 =
-                                          FStar_Syntax_Util.is_auto_squash tm in
-                                        match uu___24 with
-                                        | FStar_Pervasives_Native.Some
-                                            (FStar_Syntax_Syntax.U_zero, t)
-                                            when
-                                            FStar_Syntax_Util.is_sub_singleton
-                                              t
-                                            -> t
-                                        | uu___25 -> tm))))))))))
-      | FStar_Syntax_Syntax.Tm_refine (bv, t) ->
-          let uu___1 = simp_t t in
-          (match uu___1 with
-           | FStar_Pervasives_Native.Some (true) ->
-               bv.FStar_Syntax_Syntax.sort
-           | FStar_Pervasives_Native.Some (false) -> tm
-           | FStar_Pervasives_Native.None -> tm)
-      | FStar_Syntax_Syntax.Tm_match uu___1 ->
-          let uu___2 = is_const_match tm in
-          (match uu___2 with
-           | FStar_Pervasives_Native.Some (true) ->
-               w FStar_Syntax_Util.t_true
-           | FStar_Pervasives_Native.Some (false) ->
-               w FStar_Syntax_Util.t_false
-           | FStar_Pervasives_Native.None -> tm)
-      | uu___1 -> tm
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Core.ml b/src/ocaml-output/FStar_TypeChecker_Core.ml
deleted file mode 100644
index 9c42bb28c8a..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Core.ml
+++ /dev/null
@@ -1,4351 +0,0 @@
-open Prims
-let (goal_ctr : Prims.int FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref Prims.int_zero
-let (get_goal_ctr : unit -> Prims.int) =
-  fun uu___ -> FStar_Compiler_Effect.op_Bang goal_ctr
-let (incr_goal_ctr : unit -> Prims.int) =
-  fun uu___ ->
-    let v = FStar_Compiler_Effect.op_Bang goal_ctr in
-    FStar_Compiler_Effect.op_Colon_Equals goal_ctr (v + Prims.int_one);
-    v + Prims.int_one
-type guard_handler_t =
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.typ -> Prims.bool
-type env =
-  {
-  tcenv: FStar_TypeChecker_Env.env ;
-  allow_universe_instantiation: Prims.bool ;
-  max_binder_index: Prims.int ;
-  guard_handler: guard_handler_t FStar_Pervasives_Native.option ;
-  should_read_cache: Prims.bool }
-let (__proj__Mkenv__item__tcenv : env -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with
-    | { tcenv; allow_universe_instantiation; max_binder_index; guard_handler;
-        should_read_cache;_} -> tcenv
-let (__proj__Mkenv__item__allow_universe_instantiation : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { tcenv; allow_universe_instantiation; max_binder_index; guard_handler;
-        should_read_cache;_} -> allow_universe_instantiation
-let (__proj__Mkenv__item__max_binder_index : env -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { tcenv; allow_universe_instantiation; max_binder_index; guard_handler;
-        should_read_cache;_} -> max_binder_index
-let (__proj__Mkenv__item__guard_handler :
-  env -> guard_handler_t FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { tcenv; allow_universe_instantiation; max_binder_index; guard_handler;
-        should_read_cache;_} -> guard_handler
-let (__proj__Mkenv__item__should_read_cache : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { tcenv; allow_universe_instantiation; max_binder_index; guard_handler;
-        should_read_cache;_} -> should_read_cache
-let (push_binder : env -> FStar_Syntax_Syntax.binder -> env) =
-  fun g ->
-    fun b ->
-      if
-        (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.index <=
-          g.max_binder_index
-      then
-        failwith
-          "Assertion failed: unexpected shadowing in the core environment"
-      else
-        (let uu___1 = FStar_TypeChecker_Env.push_binders g.tcenv [b] in
-         {
-           tcenv = uu___1;
-           allow_universe_instantiation = (g.allow_universe_instantiation);
-           max_binder_index =
-             ((b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.index);
-           guard_handler = (g.guard_handler);
-           should_read_cache = (g.should_read_cache)
-         })
-let (push_binders : env -> FStar_Syntax_Syntax.binder Prims.list -> env) =
-  FStar_Compiler_List.fold_left push_binder
-let (fresh_binder :
-  env -> FStar_Syntax_Syntax.binder -> (env * FStar_Syntax_Syntax.binder)) =
-  fun g ->
-    fun old ->
-      let ctr = g.max_binder_index + Prims.int_one in
-      let bv =
-        let uu___ = old.FStar_Syntax_Syntax.binder_bv in
-        {
-          FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-          FStar_Syntax_Syntax.index = ctr;
-          FStar_Syntax_Syntax.sort = (uu___.FStar_Syntax_Syntax.sort)
-        } in
-      let b =
-        FStar_Syntax_Syntax.mk_binder_with_attrs bv
-          old.FStar_Syntax_Syntax.binder_qual
-          old.FStar_Syntax_Syntax.binder_attrs in
-      let uu___ = push_binder g b in (uu___, b)
-let (open_binders :
-  env ->
-    FStar_Syntax_Syntax.binders ->
-      (env * FStar_Syntax_Syntax.binder Prims.list *
-        FStar_Syntax_Syntax.subst_elt Prims.list))
-  =
-  fun g ->
-    fun bs ->
-      let uu___ =
-        FStar_Compiler_List.fold_left
-          (fun uu___1 ->
-             fun b ->
-               match uu___1 with
-               | (g1, bs1, subst) ->
-                   let bv =
-                     let uu___2 = b.FStar_Syntax_Syntax.binder_bv in
-                     let uu___3 =
-                       FStar_Syntax_Subst.subst subst
-                         (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                     {
-                       FStar_Syntax_Syntax.ppname =
-                         (uu___2.FStar_Syntax_Syntax.ppname);
-                       FStar_Syntax_Syntax.index =
-                         (uu___2.FStar_Syntax_Syntax.index);
-                       FStar_Syntax_Syntax.sort = uu___3
-                     } in
-                   let b1 =
-                     let uu___2 =
-                       FStar_Syntax_Subst.subst_bqual subst
-                         b.FStar_Syntax_Syntax.binder_qual in
-                     let uu___3 =
-                       FStar_Compiler_List.map
-                         (FStar_Syntax_Subst.subst subst)
-                         b.FStar_Syntax_Syntax.binder_attrs in
-                     {
-                       FStar_Syntax_Syntax.binder_bv = bv;
-                       FStar_Syntax_Syntax.binder_qual = uu___2;
-                       FStar_Syntax_Syntax.binder_attrs = uu___3
-                     } in
-                   let uu___2 = fresh_binder g1 b1 in
-                   (match uu___2 with
-                    | (g2, b') ->
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Syntax_Subst.shift_subst Prims.int_one
-                              subst in
-                          (FStar_Syntax_Syntax.DB
-                             (Prims.int_zero,
-                               (b'.FStar_Syntax_Syntax.binder_bv)))
-                            :: uu___4 in
-                        (g2, (b' :: bs1), uu___3))) (g, [], []) bs in
-      match uu___ with
-      | (g1, bs_rev, subst) -> (g1, (FStar_Compiler_List.rev bs_rev), subst)
-let (open_pat :
-  env ->
-    FStar_Syntax_Syntax.pat ->
-      (env * FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.subst_t))
-  =
-  fun g ->
-    fun p ->
-      let rec open_pat_aux g1 p1 sub =
-        match p1.FStar_Syntax_Syntax.v with
-        | FStar_Syntax_Syntax.Pat_constant uu___ -> (g1, p1, sub)
-        | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-            let uu___ =
-              FStar_Compiler_List.fold_left
-                (fun uu___1 ->
-                   fun uu___2 ->
-                     match (uu___1, uu___2) with
-                     | ((g2, pats1, sub1), (p2, imp)) ->
-                         let uu___3 = open_pat_aux g2 p2 sub1 in
-                         (match uu___3 with
-                          | (g3, p3, sub2) ->
-                              (g3, ((p3, imp) :: pats1), sub2)))
-                (g1, [], sub) pats in
-            (match uu___ with
-             | (g2, pats1, sub1) ->
-                 (g2,
-                   {
-                     FStar_Syntax_Syntax.v =
-                       (FStar_Syntax_Syntax.Pat_cons
-                          (fv, us_opt, (FStar_Compiler_List.rev pats1)));
-                     FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-                   }, sub1))
-        | FStar_Syntax_Syntax.Pat_var x ->
-            let bx =
-              let uu___ =
-                let uu___1 =
-                  FStar_Syntax_Subst.subst sub x.FStar_Syntax_Syntax.sort in
-                {
-                  FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-                  FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                  FStar_Syntax_Syntax.sort = uu___1
-                } in
-              FStar_Syntax_Syntax.mk_binder uu___ in
-            let uu___ = fresh_binder g1 bx in
-            (match uu___ with
-             | (g2, bx') ->
-                 let sub1 =
-                   let uu___1 =
-                     FStar_Syntax_Subst.shift_subst Prims.int_one sub in
-                   (FStar_Syntax_Syntax.DB
-                      (Prims.int_zero, (bx'.FStar_Syntax_Syntax.binder_bv)))
-                     :: uu___1 in
-                 (g2,
-                   {
-                     FStar_Syntax_Syntax.v =
-                       (FStar_Syntax_Syntax.Pat_var
-                          (bx'.FStar_Syntax_Syntax.binder_bv));
-                     FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-                   }, sub1))
-        | FStar_Syntax_Syntax.Pat_wild x ->
-            let bx =
-              let uu___ =
-                let uu___1 =
-                  FStar_Syntax_Subst.subst sub x.FStar_Syntax_Syntax.sort in
-                {
-                  FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-                  FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                  FStar_Syntax_Syntax.sort = uu___1
-                } in
-              FStar_Syntax_Syntax.mk_binder uu___ in
-            let uu___ = fresh_binder g1 bx in
-            (match uu___ with
-             | (g2, bx') ->
-                 let sub1 =
-                   let uu___1 =
-                     FStar_Syntax_Subst.shift_subst Prims.int_one sub in
-                   (FStar_Syntax_Syntax.DB
-                      (Prims.int_zero, (bx'.FStar_Syntax_Syntax.binder_bv)))
-                     :: uu___1 in
-                 (g2,
-                   {
-                     FStar_Syntax_Syntax.v =
-                       (FStar_Syntax_Syntax.Pat_wild
-                          (bx'.FStar_Syntax_Syntax.binder_bv));
-                     FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-                   }, sub1))
-        | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-            let eopt1 =
-              FStar_Compiler_Util.map_option (FStar_Syntax_Subst.subst sub)
-                eopt in
-            (g1,
-              {
-                FStar_Syntax_Syntax.v =
-                  (FStar_Syntax_Syntax.Pat_dot_term eopt1);
-                FStar_Syntax_Syntax.p = (p1.FStar_Syntax_Syntax.p)
-              }, sub) in
-      open_pat_aux g p []
-let (open_term :
-  env ->
-    FStar_Syntax_Syntax.binder ->
-      FStar_Syntax_Syntax.term ->
-        (env * FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.term))
-  =
-  fun g ->
-    fun b ->
-      fun t ->
-        let uu___ = fresh_binder g b in
-        match uu___ with
-        | (g1, b') ->
-            let t1 =
-              FStar_Syntax_Subst.subst
-                [FStar_Syntax_Syntax.DB
-                   (Prims.int_zero, (b'.FStar_Syntax_Syntax.binder_bv))] t in
-            (g1, b', t1)
-let (open_term_binders :
-  env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term ->
-        (env * FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.term))
-  =
-  fun g ->
-    fun bs ->
-      fun t ->
-        let uu___ = open_binders g bs in
-        match uu___ with
-        | (g1, bs1, subst) ->
-            let uu___1 = FStar_Syntax_Subst.subst subst t in
-            (g1, bs1, uu___1)
-let (open_comp :
-  env ->
-    FStar_Syntax_Syntax.binder ->
-      FStar_Syntax_Syntax.comp ->
-        (env * FStar_Syntax_Syntax.binder * FStar_Syntax_Syntax.comp))
-  =
-  fun g ->
-    fun b ->
-      fun c ->
-        let uu___ = fresh_binder g b in
-        match uu___ with
-        | (g1, bx) ->
-            let c1 =
-              FStar_Syntax_Subst.subst_comp
-                [FStar_Syntax_Syntax.DB
-                   (Prims.int_zero, (bx.FStar_Syntax_Syntax.binder_bv))] c in
-            (g1, bx, c1)
-let (open_comp_binders :
-  env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp ->
-        (env * FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp))
-  =
-  fun g ->
-    fun bs ->
-      fun c ->
-        let uu___ = open_binders g bs in
-        match uu___ with
-        | (g1, bs1, s) ->
-            let c1 = FStar_Syntax_Subst.subst_comp s c in (g1, bs1, c1)
-let (arrow_formals_comp :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (env * FStar_Syntax_Syntax.binder Prims.list *
-        FStar_Syntax_Syntax.comp))
-  =
-  fun g ->
-    fun c ->
-      let uu___ = FStar_Syntax_Util.arrow_formals_comp_ln c in
-      match uu___ with
-      | (bs, c1) ->
-          let uu___1 = open_binders g bs in
-          (match uu___1 with
-           | (g1, bs1, subst) ->
-               let uu___2 = FStar_Syntax_Subst.subst_comp subst c1 in
-               (g1, bs1, uu___2))
-let (open_branch :
-  env -> FStar_Syntax_Syntax.branch -> (env * FStar_Syntax_Syntax.branch)) =
-  fun g ->
-    fun br ->
-      let uu___ = br in
-      match uu___ with
-      | (p, wopt, e) ->
-          let uu___1 = open_pat g p in
-          (match uu___1 with
-           | (g1, p1, s) ->
-               let uu___2 =
-                 let uu___3 =
-                   FStar_Compiler_Util.map_option
-                     (FStar_Syntax_Subst.subst s) wopt in
-                 let uu___4 = FStar_Syntax_Subst.subst s e in
-                 (p1, uu___3, uu___4) in
-               (g1, uu___2))
-let (open_branches_eq_pat :
-  env ->
-    FStar_Syntax_Syntax.branch ->
-      FStar_Syntax_Syntax.branch ->
-        (env * (FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.term
-          FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term) *
-          (FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.term
-          FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term)))
-  =
-  fun g ->
-    fun br0 ->
-      fun br1 ->
-        let uu___ = br0 in
-        match uu___ with
-        | (p0, wopt0, e0) ->
-            let uu___1 = br1 in
-            (match uu___1 with
-             | (uu___2, wopt1, e1) ->
-                 let uu___3 = open_pat g p0 in
-                 (match uu___3 with
-                  | (g1, p01, s) ->
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_Compiler_Util.map_option
-                            (FStar_Syntax_Subst.subst s) wopt0 in
-                        let uu___6 = FStar_Syntax_Subst.subst s e0 in
-                        (p01, uu___5, uu___6) in
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Compiler_Util.map_option
-                            (FStar_Syntax_Subst.subst s) wopt1 in
-                        let uu___7 = FStar_Syntax_Subst.subst s e1 in
-                        (p01, uu___6, uu___7) in
-                      (g1, uu___4, uu___5)))
-type precondition = FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option
-type 'a success = ('a * precondition)
-type relation =
-  | EQUALITY 
-  | SUBTYPING of FStar_Syntax_Syntax.term FStar_Pervasives_Native.option 
-let (uu___is_EQUALITY : relation -> Prims.bool) =
-  fun projectee -> match projectee with | EQUALITY -> true | uu___ -> false
-let (uu___is_SUBTYPING : relation -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SUBTYPING _0 -> true | uu___ -> false
-let (__proj__SUBTYPING__item___0 :
-  relation -> FStar_Syntax_Syntax.term FStar_Pervasives_Native.option) =
-  fun projectee -> match projectee with | SUBTYPING _0 -> _0
-let (relation_to_string : relation -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | EQUALITY -> "=?="
-    | SUBTYPING (FStar_Pervasives_Native.None) -> "<:?"
-    | SUBTYPING (FStar_Pervasives_Native.Some tm) ->
-        let uu___1 = FStar_Syntax_Print.term_to_string tm in
-        FStar_Compiler_Util.format1 "( <:? %s)" uu___1
-type context_term =
-  | CtxTerm of FStar_Syntax_Syntax.term 
-  | CtxRel of FStar_Syntax_Syntax.term * relation * FStar_Syntax_Syntax.term 
-let (uu___is_CtxTerm : context_term -> Prims.bool) =
-  fun projectee -> match projectee with | CtxTerm _0 -> true | uu___ -> false
-let (__proj__CtxTerm__item___0 : context_term -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | CtxTerm _0 -> _0
-let (uu___is_CtxRel : context_term -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CtxRel (_0, _1, _2) -> true | uu___ -> false
-let (__proj__CtxRel__item___0 : context_term -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | CtxRel (_0, _1, _2) -> _0
-let (__proj__CtxRel__item___1 : context_term -> relation) =
-  fun projectee -> match projectee with | CtxRel (_0, _1, _2) -> _1
-let (__proj__CtxRel__item___2 : context_term -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | CtxRel (_0, _1, _2) -> _2
-let (context_term_to_string : context_term -> Prims.string) =
-  fun c ->
-    match c with
-    | CtxTerm term -> FStar_Syntax_Print.term_to_string term
-    | CtxRel (t0, r, t1) ->
-        let uu___ = FStar_Syntax_Print.term_to_string t0 in
-        let uu___1 = relation_to_string r in
-        let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-        FStar_Compiler_Util.format3 "%s %s %s" uu___ uu___1 uu___2
-type context =
-  {
-  no_guard: Prims.bool ;
-  error_context:
-    (Prims.string * context_term FStar_Pervasives_Native.option) Prims.list }
-let (__proj__Mkcontext__item__no_guard : context -> Prims.bool) =
-  fun projectee ->
-    match projectee with | { no_guard; error_context;_} -> no_guard
-let (__proj__Mkcontext__item__error_context :
-  context ->
-    (Prims.string * context_term FStar_Pervasives_Native.option) Prims.list)
-  =
-  fun projectee ->
-    match projectee with | { no_guard; error_context;_} -> error_context
-let (print_context : context -> Prims.string) =
-  fun ctx ->
-    let rec aux depth ctx1 =
-      match ctx1 with
-      | [] -> ""
-      | (msg, ctx_term)::tl ->
-          let hd =
-            let uu___ =
-              match ctx_term with
-              | FStar_Pervasives_Native.None -> ""
-              | FStar_Pervasives_Native.Some ctx_term1 ->
-                  context_term_to_string ctx_term1 in
-            FStar_Compiler_Util.format3 "%s %s (%s)\n" depth msg uu___ in
-          let tl1 = aux (Prims.op_Hat depth ">") tl in Prims.op_Hat hd tl1 in
-    aux "" (FStar_Compiler_List.rev ctx.error_context)
-type error = (context * Prims.string)
-let (print_error : error -> Prims.string) =
-  fun err ->
-    let uu___ = err in
-    match uu___ with
-    | (ctx, msg) ->
-        let uu___1 = print_context ctx in
-        FStar_Compiler_Util.format2 "%s%s" uu___1 msg
-let (print_error_short : error -> Prims.string) =
-  fun err -> FStar_Pervasives_Native.snd err
-type 'a result = context -> ('a success, error) FStar_Pervasives.either
-type effect_label =
-  | E_TOTAL 
-  | E_GHOST 
-let (uu___is_E_TOTAL : effect_label -> Prims.bool) =
-  fun projectee -> match projectee with | E_TOTAL -> true | uu___ -> false
-let (uu___is_E_GHOST : effect_label -> Prims.bool) =
-  fun projectee -> match projectee with | E_GHOST -> true | uu___ -> false
-type hash_entry =
-  {
-  he_term: FStar_Syntax_Syntax.term ;
-  he_gamma: FStar_Syntax_Syntax.binding Prims.list ;
-  he_res: (effect_label * FStar_Syntax_Syntax.typ) success }
-let (__proj__Mkhash_entry__item__he_term :
-  hash_entry -> FStar_Syntax_Syntax.term) =
-  fun projectee ->
-    match projectee with | { he_term; he_gamma; he_res;_} -> he_term
-let (__proj__Mkhash_entry__item__he_gamma :
-  hash_entry -> FStar_Syntax_Syntax.binding Prims.list) =
-  fun projectee ->
-    match projectee with | { he_term; he_gamma; he_res;_} -> he_gamma
-let (__proj__Mkhash_entry__item__he_res :
-  hash_entry -> (effect_label * FStar_Syntax_Syntax.typ) success) =
-  fun projectee ->
-    match projectee with | { he_term; he_gamma; he_res;_} -> he_res
-type tc_table = hash_entry FStar_Syntax_TermHashTable.hashtable
-let (equal_term_for_hash :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t1 ->
-    fun t2 ->
-      FStar_Profiling.profile
-        (fun uu___ -> FStar_Syntax_Hash.equal_term t1 t2)
-        FStar_Pervasives_Native.None
-        "FStar.TypeChecker.Core.equal_term_for_hash"
-let (equal_term :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t1 ->
-    fun t2 ->
-      FStar_Profiling.profile
-        (fun uu___ -> FStar_Syntax_Hash.equal_term t1 t2)
-        FStar_Pervasives_Native.None "FStar.TypeChecker.Core.equal_term"
-let (table : tc_table) =
-  FStar_Syntax_TermHashTable.create (Prims.parse_int "1048576")
-type cache_stats_t = {
-  hits: Prims.int ;
-  misses: Prims.int }
-let (__proj__Mkcache_stats_t__item__hits : cache_stats_t -> Prims.int) =
-  fun projectee -> match projectee with | { hits; misses;_} -> hits
-let (__proj__Mkcache_stats_t__item__misses : cache_stats_t -> Prims.int) =
-  fun projectee -> match projectee with | { hits; misses;_} -> misses
-let (cache_stats : cache_stats_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    { hits = Prims.int_zero; misses = Prims.int_zero }
-let (record_cache_hit : unit -> unit) =
-  fun uu___ ->
-    let cs = FStar_Compiler_Effect.op_Bang cache_stats in
-    FStar_Compiler_Effect.op_Colon_Equals cache_stats
-      { hits = (cs.hits + Prims.int_one); misses = (cs.misses) }
-let (record_cache_miss : unit -> unit) =
-  fun uu___ ->
-    let cs = FStar_Compiler_Effect.op_Bang cache_stats in
-    FStar_Compiler_Effect.op_Colon_Equals cache_stats
-      { hits = (cs.hits); misses = (cs.misses + Prims.int_one) }
-let (reset_cache_stats : unit -> unit) =
-  fun uu___ ->
-    FStar_Compiler_Effect.op_Colon_Equals cache_stats
-      { hits = Prims.int_zero; misses = Prims.int_zero }
-let (report_cache_stats : unit -> cache_stats_t) =
-  fun uu___ -> FStar_Compiler_Effect.op_Bang cache_stats
-let (clear_memo_table : unit -> unit) =
-  fun uu___ -> FStar_Syntax_TermHashTable.clear table
-let (insert :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (effect_label * FStar_Syntax_Syntax.typ) success -> unit)
-  =
-  fun g ->
-    fun e ->
-      fun res ->
-        let entry =
-          {
-            he_term = e;
-            he_gamma = ((g.tcenv).FStar_TypeChecker_Env.gamma);
-            he_res = res
-          } in
-        FStar_Syntax_TermHashTable.insert e entry table
-let return : 'a . 'a -> 'a result =
-  fun x ->
-    fun uu___ -> FStar_Pervasives.Inl (x, FStar_Pervasives_Native.None)
-let (and_pre :
-  precondition ->
-    precondition ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option)
-  =
-  fun p1 ->
-    fun p2 ->
-      match (p1, p2) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives_Native.None
-      | (FStar_Pervasives_Native.Some p, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives_Native.Some p
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some p) ->
-          FStar_Pervasives_Native.Some p
-      | (FStar_Pervasives_Native.Some p11, FStar_Pervasives_Native.Some p21)
-          ->
-          let uu___ = FStar_Syntax_Util.mk_conj p11 p21 in
-          FStar_Pervasives_Native.Some uu___
-let op_let_Bang : 'a 'b . 'a result -> ('a -> 'b result) -> 'b result =
-  fun x ->
-    fun y ->
-      fun ctx0 ->
-        let uu___ = x ctx0 in
-        match uu___ with
-        | FStar_Pervasives.Inl (x1, g1) ->
-            let uu___1 = let uu___2 = y x1 in uu___2 ctx0 in
-            (match uu___1 with
-             | FStar_Pervasives.Inl (y1, g2) ->
-                 let uu___2 = let uu___3 = and_pre g1 g2 in (y1, uu___3) in
-                 FStar_Pervasives.Inl uu___2
-             | err -> err)
-        | FStar_Pervasives.Inr err -> FStar_Pervasives.Inr err
-let op_and_Bang : 'a 'b . 'a result -> 'b result -> ('a * 'b) result =
-  fun x ->
-    fun y -> op_let_Bang x (fun v -> op_let_Bang y (fun u -> return (v, u)))
-let op_let_Question :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun x ->
-    fun f ->
-      match x with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some x1 -> f x1
-let fail : 'a . Prims.string -> 'a result =
-  fun msg -> fun ctx -> FStar_Pervasives.Inr (ctx, msg)
-let (dump_context : unit result) =
-  fun ctx ->
-    (let uu___1 = print_context ctx in
-     FStar_Compiler_Util.print_string uu___1);
-    (let uu___1 = return () in uu___1 ctx)
-let handle_with : 'a . 'a result -> (unit -> 'a result) -> 'a result =
-  fun x ->
-    fun h ->
-      fun ctx ->
-        let uu___ = x ctx in
-        match uu___ with
-        | FStar_Pervasives.Inr uu___1 -> let uu___2 = h () in uu___2 ctx
-        | res -> res
-let with_context :
-  'a .
-    Prims.string ->
-      context_term FStar_Pervasives_Native.option ->
-        (unit -> 'a result) -> 'a result
-  =
-  fun msg ->
-    fun t ->
-      fun x ->
-        fun ctx ->
-          let ctx1 =
-            {
-              no_guard = (ctx.no_guard);
-              error_context = ((msg, t) :: (ctx.error_context))
-            } in
-          let uu___ = x () in uu___ ctx1
-let (mk_type :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun u ->
-    FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-      FStar_Compiler_Range.dummyRange
-let (is_type :
-  env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.universe result) =
-  fun g ->
-    fun t ->
-      let aux t1 =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress t1 in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_type u -> return u
-        | uu___1 ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1 "Expected a type; got %s" uu___3 in
-            fail uu___2 in
-      with_context "is_type" (FStar_Pervasives_Native.Some (CtxTerm t))
-        (fun uu___ ->
-           let uu___1 = aux t in
-           handle_with uu___1
-             (fun uu___2 ->
-                let uu___3 =
-                  let uu___4 =
-                    FStar_TypeChecker_Normalize.unfold_whnf g.tcenv t in
-                  FStar_Syntax_Util.unrefine uu___4 in
-                aux uu___3))
-let rec (is_arrow :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.binder * effect_label * FStar_Syntax_Syntax.typ)
-        result)
-  =
-  fun g ->
-    fun t ->
-      let rec aux t1 =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress t1 in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_arrow (x::[], c) ->
-            let uu___1 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-            if uu___1
-            then
-              let uu___2 = open_comp g x c in
-              (match uu___2 with
-               | (g1, x1, c1) ->
-                   let eff =
-                     let uu___3 = FStar_Syntax_Util.is_total_comp c1 in
-                     if uu___3 then E_TOTAL else E_GHOST in
-                   return (x1, eff, (FStar_Syntax_Util.comp_result c1)))
-            else
-              (let e_tag =
-                 let uu___3 = c.FStar_Syntax_Syntax.n in
-                 match uu___3 with
-                 | FStar_Syntax_Syntax.Comp ct ->
-                     let uu___4 =
-                       (FStar_Ident.lid_equals
-                          ct.FStar_Syntax_Syntax.effect_name
-                          FStar_Parser_Const.effect_Pure_lid)
-                         ||
-                         (FStar_Ident.lid_equals
-                            ct.FStar_Syntax_Syntax.effect_name
-                            FStar_Parser_Const.effect_Lemma_lid) in
-                     if uu___4
-                     then FStar_Pervasives_Native.Some E_TOTAL
-                     else
-                       (let uu___6 =
-                          FStar_Ident.lid_equals
-                            ct.FStar_Syntax_Syntax.effect_name
-                            FStar_Parser_Const.effect_Ghost_lid in
-                        if uu___6
-                        then FStar_Pervasives_Native.Some E_GHOST
-                        else FStar_Pervasives_Native.None) in
-               match e_tag with
-               | FStar_Pervasives_Native.None ->
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Ident.string_of_lid
-                         (FStar_Syntax_Util.comp_effect_name c) in
-                     FStar_Compiler_Util.format1
-                       "Expected total or gtot arrow, got %s" uu___4 in
-                   fail uu___3
-               | FStar_Pervasives_Native.Some e_tag1 ->
-                   let uu___3 = arrow_formals_comp g t1 in
-                   (match uu___3 with
-                    | (g1, x1::[], c1) ->
-                        let uu___4 = FStar_Syntax_Util.comp_effect_args c1 in
-                        (match uu___4 with
-                         | (pre, uu___5)::(post, uu___6)::uu___7 ->
-                             let arg_typ =
-                               FStar_Syntax_Util.refine
-                                 x1.FStar_Syntax_Syntax.binder_bv pre in
-                             let res_typ =
-                               let r =
-                                 FStar_Syntax_Syntax.new_bv
-                                   FStar_Pervasives_Native.None
-                                   (FStar_Syntax_Util.comp_result c1) in
-                               let post1 =
-                                 let uu___8 =
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Syntax_Syntax.bv_to_name r in
-                                     (uu___10, FStar_Pervasives_Native.None) in
-                                   [uu___9] in
-                                 FStar_Syntax_Syntax.mk_Tm_app post uu___8
-                                   post.FStar_Syntax_Syntax.pos in
-                               FStar_Syntax_Util.refine r post1 in
-                             let xbv =
-                               let uu___8 = x1.FStar_Syntax_Syntax.binder_bv in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (uu___8.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (uu___8.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = arg_typ
-                               } in
-                             let x2 =
-                               {
-                                 FStar_Syntax_Syntax.binder_bv = xbv;
-                                 FStar_Syntax_Syntax.binder_qual =
-                                   (x1.FStar_Syntax_Syntax.binder_qual);
-                                 FStar_Syntax_Syntax.binder_attrs =
-                                   (x1.FStar_Syntax_Syntax.binder_attrs)
-                               } in
-                             return (x2, e_tag1, res_typ))))
-        | FStar_Syntax_Syntax.Tm_arrow (x::xs, c) ->
-            let t2 =
-              FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_arrow (xs, c))
-                t1.FStar_Syntax_Syntax.pos in
-            let uu___1 = open_term g x t2 in
-            (match uu___1 with | (g1, x1, t3) -> return (x1, E_TOTAL, t3))
-        | FStar_Syntax_Syntax.Tm_refine (x, uu___1) ->
-            is_arrow g x.FStar_Syntax_Syntax.sort
-        | FStar_Syntax_Syntax.Tm_meta (t2, uu___1) -> aux t2
-        | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___1, uu___2) -> aux t2
-        | uu___1 ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.tag_of_term t1 in
-              let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format2 "Expected an arrow, got (%s) %s"
-                uu___3 uu___4 in
-            fail uu___2 in
-      with_context "is_arrow" FStar_Pervasives_Native.None
-        (fun uu___ ->
-           let uu___1 = aux t in
-           handle_with uu___1
-             (fun uu___2 ->
-                let uu___3 =
-                  FStar_TypeChecker_Normalize.unfold_whnf g.tcenv t in
-                aux uu___3))
-let (check_arg_qual :
-  FStar_Syntax_Syntax.aqual -> FStar_Syntax_Syntax.bqual -> unit result) =
-  fun a ->
-    fun b ->
-      match b with
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit uu___) ->
-          (match a with
-           | FStar_Pervasives_Native.Some
-               { FStar_Syntax_Syntax.aqual_implicit = true;
-                 FStar_Syntax_Syntax.aqual_attributes = uu___1;_}
-               -> return ()
-           | uu___1 -> fail "missing arg qualifier implicit")
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta uu___) ->
-          (match a with
-           | FStar_Pervasives_Native.Some
-               { FStar_Syntax_Syntax.aqual_implicit = true;
-                 FStar_Syntax_Syntax.aqual_attributes = uu___1;_}
-               -> return ()
-           | uu___1 -> fail "missing arg qualifier implicit")
-      | uu___ ->
-          (match a with
-           | FStar_Pervasives_Native.Some
-               { FStar_Syntax_Syntax.aqual_implicit = true;
-                 FStar_Syntax_Syntax.aqual_attributes = uu___1;_}
-               -> fail "extra arg qualifier implicit"
-           | uu___1 -> return ())
-let (check_bqual :
-  FStar_Syntax_Syntax.bqual -> FStar_Syntax_Syntax.bqual -> unit result) =
-  fun b0 ->
-    fun b1 ->
-      match (b0, b1) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-          return ()
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit b01),
-         FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit b11)) ->
-          return ()
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality),
-         FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality)) ->
-          return ()
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t1),
-         FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t2)) ->
-          let uu___ = equal_term t1 t2 in
-          if uu___ then return () else fail "Binder qualifier mismatch"
-      | uu___ -> fail "Binder qualifier mismatch"
-let (check_aqual :
-  FStar_Syntax_Syntax.aqual -> FStar_Syntax_Syntax.aqual -> unit result) =
-  fun a0 ->
-    fun a1 ->
-      match (a0, a1) with
-      | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) ->
-          return ()
-      | (FStar_Pervasives_Native.Some
-         { FStar_Syntax_Syntax.aqual_implicit = b0;
-           FStar_Syntax_Syntax.aqual_attributes = uu___;_},
-         FStar_Pervasives_Native.Some
-         { FStar_Syntax_Syntax.aqual_implicit = b1;
-           FStar_Syntax_Syntax.aqual_attributes = uu___1;_})
-          -> if b0 = b1 then return () else fail "Unequal arg qualifiers"
-      | uu___ -> fail "Unequal arg qualifiers"
-let (mk_forall_l :
-  FStar_Syntax_Syntax.universes ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun us ->
-    fun xs ->
-      fun t ->
-        FStar_Compiler_List.fold_right2
-          (fun u ->
-             fun x ->
-               fun t1 ->
-                 FStar_Syntax_Util.mk_forall u
-                   x.FStar_Syntax_Syntax.binder_bv t1) us xs t
-let (close_guard :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.universes -> precondition -> precondition)
-  =
-  fun xs ->
-    fun us ->
-      fun g ->
-        match g with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some t ->
-            let uu___ = mk_forall_l us xs t in
-            FStar_Pervasives_Native.Some uu___
-let (close_guard_with_definition :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.term -> precondition -> precondition)
-  =
-  fun x ->
-    fun u ->
-      fun t ->
-        fun g ->
-          match g with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some t1 ->
-              let uu___ =
-                let t2 =
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Syntax_Syntax.bv_to_name
-                        x.FStar_Syntax_Syntax.binder_bv in
-                    FStar_Syntax_Util.mk_eq2 u
-                      (x.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                      uu___2 t1 in
-                  FStar_Syntax_Util.mk_imp uu___1 t1 in
-                FStar_Syntax_Util.mk_forall u x.FStar_Syntax_Syntax.binder_bv
-                  t2 in
-              FStar_Pervasives_Native.Some uu___
-let with_binders :
-  'a .
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.universes -> 'a result -> 'a result
-  =
-  fun xs ->
-    fun us ->
-      fun f ->
-        fun ctx ->
-          let uu___ = f ctx in
-          match uu___ with
-          | FStar_Pervasives.Inl (t, g) ->
-              let uu___1 = let uu___2 = close_guard xs us g in (t, uu___2) in
-              FStar_Pervasives.Inl uu___1
-          | err -> err
-let with_definition :
-  'a .
-    FStar_Syntax_Syntax.binder ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.term -> 'a result -> 'a result
-  =
-  fun x ->
-    fun u ->
-      fun t ->
-        fun f ->
-          fun ctx ->
-            let uu___ = f ctx in
-            match uu___ with
-            | FStar_Pervasives.Inl (a1, g) ->
-                let uu___1 =
-                  let uu___2 = close_guard_with_definition x u t g in
-                  (a1, uu___2) in
-                FStar_Pervasives.Inl uu___1
-            | err -> err
-let (guard : FStar_Syntax_Syntax.typ -> unit result) =
-  fun t ->
-    fun uu___ -> FStar_Pervasives.Inl ((), (FStar_Pervasives_Native.Some t))
-let (abs :
-  FStar_Syntax_Syntax.typ ->
-    (FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.term) ->
-      FStar_Syntax_Syntax.term)
-  =
-  fun a ->
-    fun f ->
-      let x = FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None a in
-      let xb = FStar_Syntax_Syntax.mk_binder x in
-      let uu___ = f xb in
-      FStar_Syntax_Util.abs [xb] uu___ FStar_Pervasives_Native.None
-let (weaken_subtyping_guard :
-  FStar_Syntax_Syntax.term -> precondition -> precondition) =
-  fun p ->
-    fun g ->
-      FStar_Compiler_Util.map_opt g (fun q -> FStar_Syntax_Util.mk_imp p q)
-let (strengthen_subtyping_guard :
-  FStar_Syntax_Syntax.term -> precondition -> precondition) =
-  fun p ->
-    fun g ->
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Util.map_opt g
-            (fun q -> FStar_Syntax_Util.mk_conj p q) in
-        FStar_Compiler_Util.dflt p uu___1 in
-      FStar_Pervasives_Native.Some uu___
-let weaken :
-  'a .
-    FStar_Syntax_Syntax.term ->
-      'a result -> context -> ('a success, error) FStar_Pervasives.either
-  =
-  fun p ->
-    fun g ->
-      fun ctx ->
-        let uu___ = g ctx in
-        match uu___ with
-        | FStar_Pervasives.Inl (x, q) ->
-            let uu___1 =
-              let uu___2 = weaken_subtyping_guard p q in (x, uu___2) in
-            FStar_Pervasives.Inl uu___1
-        | err -> err
-let weaken_with_guard_formula :
-  'a .
-    FStar_TypeChecker_Common.guard_formula ->
-      'a result -> context -> ('a success, error) FStar_Pervasives.either
-  =
-  fun p ->
-    fun g ->
-      match p with
-      | FStar_TypeChecker_Common.Trivial -> g
-      | FStar_TypeChecker_Common.NonTrivial p1 -> weaken p1 g
-let (push_hypothesis : env -> FStar_Syntax_Syntax.term -> env) =
-  fun g ->
-    fun h ->
-      let bv =
-        FStar_Syntax_Syntax.new_bv
-          (FStar_Pervasives_Native.Some (h.FStar_Syntax_Syntax.pos)) h in
-      let b = FStar_Syntax_Syntax.mk_binder bv in
-      let uu___ = fresh_binder g b in FStar_Pervasives_Native.fst uu___
-let strengthen :
-  'a .
-    FStar_Syntax_Syntax.term ->
-      'a result -> context -> ('a success, error) FStar_Pervasives.either
-  =
-  fun p ->
-    fun g ->
-      fun ctx ->
-        let uu___ = g ctx in
-        match uu___ with
-        | FStar_Pervasives.Inl (x, q) ->
-            let uu___1 =
-              let uu___2 = strengthen_subtyping_guard p q in (x, uu___2) in
-            FStar_Pervasives.Inl uu___1
-        | err -> err
-let no_guard : 'a . 'a result -> 'a result =
-  fun g ->
-    fun ctx ->
-      let uu___ = g { no_guard = true; error_context = (ctx.error_context) } in
-      match uu___ with
-      | FStar_Pervasives.Inl (x, FStar_Pervasives_Native.None) ->
-          FStar_Pervasives.Inl (x, FStar_Pervasives_Native.None)
-      | FStar_Pervasives.Inl (x, FStar_Pervasives_Native.Some g1) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string g1 in
-              FStar_Compiler_Util.format1 "Unexpected guard: %s" uu___3 in
-            fail uu___2 in
-          uu___1 ctx
-      | err -> err
-let (equatable : env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun g ->
-    fun t ->
-      let uu___ = FStar_Syntax_Util.head_and_args t in
-      match uu___ with
-      | (head, uu___1) ->
-          FStar_TypeChecker_Rel.may_relate_with_logical_guard g.tcenv true
-            head
-let (apply_predicate :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term)
-  =
-  fun x ->
-    fun p ->
-      fun e ->
-        FStar_Syntax_Subst.subst
-          [FStar_Syntax_Syntax.NT ((x.FStar_Syntax_Syntax.binder_bv), e)] p
-let (curry_arrow :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun x ->
-    fun xs ->
-      fun c ->
-        let tail =
-          FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_arrow (xs, c))
-            FStar_Compiler_Range.dummyRange in
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Syntax.mk_Total tail in ([x], uu___2) in
-          FStar_Syntax_Syntax.Tm_arrow uu___1 in
-        FStar_Syntax_Syntax.mk uu___ FStar_Compiler_Range.dummyRange
-let (curry_abs :
-  FStar_Syntax_Syntax.binder ->
-    FStar_Syntax_Syntax.binder ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-            FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun b0 ->
-    fun b1 ->
-      fun bs ->
-        fun body ->
-          fun ropt ->
-            let tail =
-              FStar_Syntax_Syntax.mk
-                (FStar_Syntax_Syntax.Tm_abs ((b1 :: bs), body, ropt))
-                body.FStar_Syntax_Syntax.pos in
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_abs
-                 ([b0], tail, FStar_Pervasives_Native.None))
-              body.FStar_Syntax_Syntax.pos
-let (is_gtot_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    (FStar_Syntax_Util.is_tot_or_gtot_comp c) &&
-      (let uu___ = FStar_Syntax_Util.is_total_comp c in
-       Prims.op_Negation uu___)
-let rec (context_included :
-  FStar_Syntax_Syntax.binding Prims.list ->
-    FStar_Syntax_Syntax.binding Prims.list -> Prims.bool)
-  =
-  fun g0 ->
-    fun g1 ->
-      let uu___ = FStar_Compiler_Util.physical_equality g0 g1 in
-      if uu___
-      then true
-      else
-        (match (g0, g1) with
-         | ([], uu___2) -> true
-         | (b0::g0', b1::g1') ->
-             (match (b0, b1) with
-              | (FStar_Syntax_Syntax.Binding_var x0,
-                 FStar_Syntax_Syntax.Binding_var x1) ->
-                  if
-                    x0.FStar_Syntax_Syntax.index =
-                      x1.FStar_Syntax_Syntax.index
-                  then
-                    (equal_term x0.FStar_Syntax_Syntax.sort
-                       x1.FStar_Syntax_Syntax.sort)
-                      && (context_included g0' g1')
-                  else context_included g0 g1'
-              | (FStar_Syntax_Syntax.Binding_lid uu___2,
-                 FStar_Syntax_Syntax.Binding_lid uu___3) -> true
-              | (FStar_Syntax_Syntax.Binding_univ uu___2,
-                 FStar_Syntax_Syntax.Binding_univ uu___3) -> true
-              | uu___2 -> false)
-         | uu___2 -> false)
-let (curry_application :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option) ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list ->
-        FStar_Compiler_Range.range ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun hd ->
-    fun arg ->
-      fun args ->
-        fun p ->
-          let head =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (hd, [arg])) p in
-          let t =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (head, args))
-              p in
-          t
-let (lookup :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (effect_label * FStar_Syntax_Syntax.typ) result)
-  =
-  fun g ->
-    fun e ->
-      let uu___ = FStar_Syntax_TermHashTable.lookup e table in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          (record_cache_miss (); fail "not in cache")
-      | FStar_Pervasives_Native.Some he ->
-          let uu___1 =
-            context_included he.he_gamma
-              (g.tcenv).FStar_TypeChecker_Env.gamma in
-          if uu___1
-          then
-            (record_cache_hit ();
-             (fun uu___3 -> FStar_Pervasives.Inl (he.he_res)))
-          else fail "not in cache"
-let (check_no_escape :
-  FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.term -> unit result) =
-  fun bs ->
-    fun t ->
-      let xs = FStar_Syntax_Free.names t in
-      let uu___ =
-        FStar_Compiler_Util.for_all
-          (fun b ->
-             let uu___1 =
-               FStar_Compiler_Util.set_mem b.FStar_Syntax_Syntax.binder_bv xs in
-             Prims.op_Negation uu___1) bs in
-      if uu___ then return () else fail "Name escapes its scope"
-let rec map :
-  'a 'b . ('a -> 'b result) -> 'a Prims.list -> 'b Prims.list result =
-  fun f ->
-    fun l ->
-      match l with
-      | [] -> return []
-      | hd::tl ->
-          let uu___ = f hd in
-          op_let_Bang uu___
-            (fun hd1 ->
-               let uu___1 = map f tl in
-               op_let_Bang uu___1 (fun tl1 -> return (hd1 :: tl1)))
-let mapi :
-  'a 'b .
-    (Prims.int -> 'a -> 'b result) -> 'a Prims.list -> 'b Prims.list result
-  =
-  fun f ->
-    fun l ->
-      let rec aux i l1 =
-        match l1 with
-        | [] -> return []
-        | hd::tl ->
-            let uu___ = f i hd in
-            op_let_Bang uu___
-              (fun hd1 ->
-                 let uu___1 = aux (i + Prims.int_one) tl in
-                 op_let_Bang uu___1 (fun tl1 -> return (hd1 :: tl1))) in
-      aux Prims.int_zero l
-let rec map2 :
-  'a 'b 'c .
-    ('a -> 'b -> 'c result) ->
-      'a Prims.list -> 'b Prims.list -> 'c Prims.list result
-  =
-  fun f ->
-    fun l1 ->
-      fun l2 ->
-        match (l1, l2) with
-        | ([], []) -> return []
-        | (hd1::tl1, hd2::tl2) ->
-            let uu___ = f hd1 hd2 in
-            op_let_Bang uu___
-              (fun hd ->
-                 let uu___1 = map2 f tl1 tl2 in
-                 op_let_Bang uu___1 (fun tl -> return (hd :: tl)))
-let rec fold :
-  'a 'b . ('a -> 'b -> 'a result) -> 'a -> 'b Prims.list -> 'a result =
-  fun f ->
-    fun x ->
-      fun l ->
-        match l with
-        | [] -> return x
-        | hd::tl ->
-            let uu___ = f x hd in op_let_Bang uu___ (fun x1 -> fold f x1 tl)
-let rec fold2 :
-  'a 'b 'c .
-    ('a -> 'b -> 'c -> 'a result) ->
-      'a -> 'b Prims.list -> 'c Prims.list -> 'a result
-  =
-  fun f ->
-    fun x ->
-      fun l1 ->
-        fun l2 ->
-          match (l1, l2) with
-          | ([], []) -> return x
-          | (hd1::tl1, hd2::tl2) ->
-              let uu___ = f x hd1 hd2 in
-              op_let_Bang uu___ (fun x1 -> fold2 f x1 tl1 tl2)
-let rec iter2 :
-  'a 'b .
-    'a Prims.list ->
-      'a Prims.list -> ('a -> 'a -> 'b -> 'b result) -> 'b -> 'b result
-  =
-  fun xs ->
-    fun ys ->
-      fun f ->
-        fun b1 ->
-          match (xs, ys) with
-          | ([], []) -> return b1
-          | (x::xs1, y::ys1) ->
-              let uu___ = f x y b1 in
-              op_let_Bang uu___ (fun b2 -> iter2 xs1 ys1 f b2)
-          | uu___ -> fail "Lists of differing length"
-let (non_informative : env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun g -> fun t -> FStar_TypeChecker_Normalize.non_info_norm g.tcenv t
-let (as_comp :
-  env -> (effect_label * FStar_Syntax_Syntax.typ) -> FStar_Syntax_Syntax.comp)
-  =
-  fun g ->
-    fun et ->
-      match et with
-      | (E_TOTAL, t) -> FStar_Syntax_Syntax.mk_Total t
-      | (E_GHOST, t) ->
-          let uu___ = non_informative g t in
-          if uu___
-          then FStar_Syntax_Syntax.mk_Total t
-          else FStar_Syntax_Syntax.mk_GTotal t
-let (comp_as_effect_label_and_type :
-  FStar_Syntax_Syntax.comp ->
-    (effect_label * FStar_Syntax_Syntax.typ) FStar_Pervasives_Native.option)
-  =
-  fun c ->
-    let uu___ = FStar_Syntax_Util.is_total_comp c in
-    if uu___
-    then
-      FStar_Pervasives_Native.Some
-        (E_TOTAL, (FStar_Syntax_Util.comp_result c))
-    else
-      (let uu___2 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-       if uu___2
-       then
-         FStar_Pervasives_Native.Some
-           (E_GHOST, (FStar_Syntax_Util.comp_result c))
-       else FStar_Pervasives_Native.None)
-let (join_eff : effect_label -> effect_label -> effect_label) =
-  fun e0 ->
-    fun e1 ->
-      match (e0, e1) with
-      | (E_GHOST, uu___) -> E_GHOST
-      | (uu___, E_GHOST) -> E_GHOST
-      | uu___ -> E_TOTAL
-let (join_eff_l : effect_label Prims.list -> effect_label) =
-  fun es -> FStar_List_Tot_Base.fold_right join_eff es E_TOTAL
-let (guard_not_allowed : Prims.bool result) =
-  fun ctx ->
-    FStar_Pervasives.Inl ((ctx.no_guard), FStar_Pervasives_Native.None)
-let (default_norm_steps : FStar_TypeChecker_Env.steps) =
-  [FStar_TypeChecker_Env.Primops;
-  FStar_TypeChecker_Env.Weak;
-  FStar_TypeChecker_Env.HNF;
-  FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-  FStar_TypeChecker_Env.Unascribe;
-  FStar_TypeChecker_Env.Eager_unfolding;
-  FStar_TypeChecker_Env.Iota;
-  FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta]
-let (debug : env -> (unit -> unit) -> unit) =
-  fun g ->
-    fun f ->
-      let uu___ =
-        FStar_TypeChecker_Env.debug g.tcenv (FStar_Options.Other "Core") in
-      if uu___ then f () else ()
-type side =
-  | Left 
-  | Right 
-  | Both 
-  | Neither 
-let (uu___is_Left : side -> Prims.bool) =
-  fun projectee -> match projectee with | Left -> true | uu___ -> false
-let (uu___is_Right : side -> Prims.bool) =
-  fun projectee -> match projectee with | Right -> true | uu___ -> false
-let (uu___is_Both : side -> Prims.bool) =
-  fun projectee -> match projectee with | Both -> true | uu___ -> false
-let (uu___is_Neither : side -> Prims.bool) =
-  fun projectee -> match projectee with | Neither -> true | uu___ -> false
-let (side_to_string : side -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Left -> "Left"
-    | Right -> "Right"
-    | Both -> "Both"
-    | Neither -> "Neither"
-let (boolean_negation_simp :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-      FStar_Pervasives_Native.option)
-  =
-  fun b ->
-    let uu___ =
-      FStar_Syntax_Hash.equal_term b FStar_Syntax_Util.exp_false_bool in
-    if uu___
-    then FStar_Pervasives_Native.None
-    else
-      (let uu___2 = FStar_Syntax_Util.mk_boolean_negation b in
-       FStar_Pervasives_Native.Some uu___2)
-let (combine_path_and_branch_condition :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-  =
-  fun path_condition ->
-    fun branch_condition ->
-      fun branch_equality ->
-        let this_path_condition =
-          let bc =
-            match branch_condition with
-            | FStar_Pervasives_Native.None -> branch_equality
-            | FStar_Pervasives_Native.Some bc1 ->
-                let uu___ =
-                  let uu___1 = FStar_Syntax_Util.b2t bc1 in
-                  [uu___1; branch_equality] in
-                FStar_Syntax_Util.mk_conj_l uu___ in
-          let uu___ = FStar_Syntax_Util.b2t path_condition in
-          FStar_Syntax_Util.mk_conj uu___ bc in
-        let next_path_condition =
-          match branch_condition with
-          | FStar_Pervasives_Native.None -> FStar_Syntax_Util.exp_false_bool
-          | FStar_Pervasives_Native.Some bc ->
-              let uu___ =
-                FStar_Syntax_Hash.equal_term path_condition
-                  FStar_Syntax_Util.exp_true_bool in
-              if uu___
-              then FStar_Syntax_Util.mk_boolean_negation bc
-              else
-                (let uu___2 = FStar_Syntax_Util.mk_boolean_negation bc in
-                 FStar_Syntax_Util.mk_and path_condition uu___2) in
-        (this_path_condition, next_path_condition)
-let rec (check_relation :
-  env ->
-    relation ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> unit result)
-  =
-  fun g ->
-    fun rel ->
-      fun t0 ->
-        fun t1 ->
-          let err uu___ =
-            match rel with
-            | EQUALITY ->
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Print.term_to_string t0 in
-                  let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-                  FStar_Compiler_Util.format2 "not equal terms: %s <> %s"
-                    uu___2 uu___3 in
-                fail uu___1
-            | uu___1 ->
-                let uu___2 =
-                  let uu___3 = FStar_Syntax_Print.term_to_string t0 in
-                  let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-                  FStar_Compiler_Util.format2 "%s is not a subtype of %s"
-                    uu___3 uu___4 in
-                fail uu___2 in
-          let rel_to_string rel1 =
-            match rel1 with | EQUALITY -> "=?=" | uu___ -> "<:?" in
-          (let uu___1 =
-             FStar_TypeChecker_Env.debug g.tcenv (FStar_Options.Other "Core") in
-           if uu___1
-           then
-             let uu___2 = FStar_Syntax_Print.tag_of_term t0 in
-             let uu___3 = FStar_Syntax_Print.term_to_string t0 in
-             let uu___4 = FStar_Syntax_Print.tag_of_term t1 in
-             let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-             FStar_Compiler_Util.print5 "check_relation (%s) %s %s (%s) %s\n"
-               uu___2 uu___3 (rel_to_string rel) uu___4 uu___5
-           else ());
-          op_let_Bang guard_not_allowed
-            (fun guard_not_ok ->
-               let guard_ok = Prims.op_Negation guard_not_ok in
-               let head_matches t01 t11 =
-                 let head0 = FStar_Syntax_Util.leftmost_head t01 in
-                 let head1 = FStar_Syntax_Util.leftmost_head t11 in
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Util.un_uinst head0 in
-                     uu___3.FStar_Syntax_Syntax.n in
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Util.un_uinst head1 in
-                     uu___4.FStar_Syntax_Syntax.n in
-                   (uu___2, uu___3) in
-                 match uu___1 with
-                 | (FStar_Syntax_Syntax.Tm_fvar fv0,
-                    FStar_Syntax_Syntax.Tm_fvar fv1) ->
-                     FStar_Syntax_Syntax.fv_eq fv0 fv1
-                 | (FStar_Syntax_Syntax.Tm_name x0,
-                    FStar_Syntax_Syntax.Tm_name x1) ->
-                     FStar_Syntax_Syntax.bv_eq x0 x1
-                 | (FStar_Syntax_Syntax.Tm_constant c0,
-                    FStar_Syntax_Syntax.Tm_constant c1) ->
-                     equal_term head0 head1
-                 | (FStar_Syntax_Syntax.Tm_type uu___2,
-                    FStar_Syntax_Syntax.Tm_type uu___3) -> true
-                 | (FStar_Syntax_Syntax.Tm_arrow uu___2,
-                    FStar_Syntax_Syntax.Tm_arrow uu___3) -> true
-                 | (FStar_Syntax_Syntax.Tm_match uu___2,
-                    FStar_Syntax_Syntax.Tm_match uu___3) -> true
-                 | uu___2 -> false in
-               let which_side_to_unfold t01 t11 =
-                 let rec delta_depth_of_head t =
-                   let head = FStar_Syntax_Util.leftmost_head t in
-                   let uu___1 =
-                     let uu___2 = FStar_Syntax_Util.un_uinst head in
-                     uu___2.FStar_Syntax_Syntax.n in
-                   match uu___1 with
-                   | FStar_Syntax_Syntax.Tm_fvar fv ->
-                       let uu___2 =
-                         FStar_TypeChecker_Env.delta_depth_of_fv g.tcenv fv in
-                       FStar_Pervasives_Native.Some uu___2
-                   | FStar_Syntax_Syntax.Tm_match
-                       (t2, uu___2, uu___3, uu___4) -> delta_depth_of_head t2
-                   | uu___2 -> FStar_Pervasives_Native.None in
-                 let dd0 = delta_depth_of_head t01 in
-                 let dd1 = delta_depth_of_head t11 in
-                 match (dd0, dd1) with
-                 | (FStar_Pervasives_Native.Some uu___1,
-                    FStar_Pervasives_Native.None) -> Left
-                 | (FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.Some uu___1) -> Right
-                 | (FStar_Pervasives_Native.Some dd01,
-                    FStar_Pervasives_Native.Some dd11) ->
-                     if dd01 = dd11
-                     then Both
-                     else
-                       (let uu___2 =
-                          FStar_TypeChecker_Common.delta_depth_greater_than
-                            dd01 dd11 in
-                        if uu___2 then Left else Right)
-                 | (FStar_Pervasives_Native.None,
-                    FStar_Pervasives_Native.None) -> Neither in
-               let maybe_unfold_side side1 t01 t11 =
-                 FStar_Profiling.profile
-                   (fun uu___1 ->
-                      match side1 with
-                      | Neither -> FStar_Pervasives_Native.None
-                      | Both ->
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_TypeChecker_Normalize.maybe_unfold_head
-                                g.tcenv t01 in
-                            let uu___4 =
-                              FStar_TypeChecker_Normalize.maybe_unfold_head
-                                g.tcenv t11 in
-                            (uu___3, uu___4) in
-                          (match uu___2 with
-                           | (FStar_Pervasives_Native.Some t02,
-                              FStar_Pervasives_Native.Some t12) ->
-                               FStar_Pervasives_Native.Some (t02, t12)
-                           | (FStar_Pervasives_Native.Some t02,
-                              FStar_Pervasives_Native.None) ->
-                               FStar_Pervasives_Native.Some (t02, t11)
-                           | (FStar_Pervasives_Native.None,
-                              FStar_Pervasives_Native.Some t12) ->
-                               FStar_Pervasives_Native.Some (t01, t12)
-                           | uu___3 -> FStar_Pervasives_Native.None)
-                      | Left ->
-                          let uu___2 =
-                            FStar_TypeChecker_Normalize.maybe_unfold_head
-                              g.tcenv t01 in
-                          (match uu___2 with
-                           | FStar_Pervasives_Native.Some t02 ->
-                               FStar_Pervasives_Native.Some (t02, t11)
-                           | uu___3 -> FStar_Pervasives_Native.None)
-                      | Right ->
-                          let uu___2 =
-                            FStar_TypeChecker_Normalize.maybe_unfold_head
-                              g.tcenv t11 in
-                          (match uu___2 with
-                           | FStar_Pervasives_Native.Some t12 ->
-                               FStar_Pervasives_Native.Some (t01, t12)
-                           | uu___3 -> FStar_Pervasives_Native.None))
-                   FStar_Pervasives_Native.None
-                   "FStar.TypeChecker.Core.maybe_unfold_side" in
-               let maybe_unfold t01 t11 =
-                 let uu___1 = which_side_to_unfold t01 t11 in
-                 maybe_unfold_side uu___1 t01 t11 in
-               let fallback t01 t11 =
-                 if guard_ok
-                 then
-                   let uu___1 = (equatable g t01) || (equatable g t11) in
-                   (if uu___1
-                    then
-                      let uu___2 = check' g t01 in
-                      op_let_Bang uu___2
-                        (fun uu___3 ->
-                           match uu___3 with
-                           | (uu___4, t_typ) ->
-                               let uu___5 = universe_of g t_typ in
-                               op_let_Bang uu___5
-                                 (fun u ->
-                                    let uu___6 =
-                                      FStar_Syntax_Util.mk_eq2 u t_typ t01
-                                        t11 in
-                                    guard uu___6))
-                    else err ())
-                 else err () in
-               let maybe_unfold_side_and_retry side1 t01 t11 =
-                 let uu___1 = maybe_unfold_side side1 t01 t11 in
-                 match uu___1 with
-                 | FStar_Pervasives_Native.None -> fallback t01 t11
-                 | FStar_Pervasives_Native.Some (t02, t12) ->
-                     check_relation g rel t02 t12 in
-               let maybe_unfold_and_retry t01 t11 =
-                 let uu___1 = which_side_to_unfold t01 t11 in
-                 maybe_unfold_side_and_retry uu___1 t01 t11 in
-               let beta_iota_reduce t =
-                 let t2 = FStar_Syntax_Subst.compress t in
-                 match t2.FStar_Syntax_Syntax.n with
-                 | FStar_Syntax_Syntax.Tm_app uu___1 ->
-                     let head = FStar_Syntax_Util.leftmost_head t2 in
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Subst.compress head in
-                       uu___3.FStar_Syntax_Syntax.n in
-                     (match uu___2 with
-                      | FStar_Syntax_Syntax.Tm_abs uu___3 ->
-                          FStar_TypeChecker_Normalize.normalize
-                            [FStar_TypeChecker_Env.Beta;
-                            FStar_TypeChecker_Env.Iota] g.tcenv t2
-                      | uu___3 -> t2)
-                 | FStar_Syntax_Syntax.Tm_let uu___1 ->
-                     FStar_TypeChecker_Normalize.normalize
-                       [FStar_TypeChecker_Env.Beta;
-                       FStar_TypeChecker_Env.Iota] g.tcenv t2
-                 | FStar_Syntax_Syntax.Tm_match uu___1 ->
-                     FStar_TypeChecker_Normalize.normalize
-                       [FStar_TypeChecker_Env.Beta;
-                       FStar_TypeChecker_Env.Iota] g.tcenv t2
-                 | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-                     FStar_Syntax_Util.flatten_refinement t2
-                 | uu___1 -> t2 in
-               let beta_iota_reduce1 t =
-                 FStar_Profiling.profile (fun uu___1 -> beta_iota_reduce t)
-                   FStar_Pervasives_Native.None
-                   "FStar.TypeChecker.Core.beta_iota_reduce" in
-               let t01 =
-                 let uu___1 = beta_iota_reduce1 t0 in
-                 FStar_Syntax_Subst.compress uu___1 in
-               let t11 =
-                 let uu___1 = beta_iota_reduce1 t1 in
-                 FStar_Syntax_Subst.compress uu___1 in
-               let check_relation1 g1 rel1 t02 t12 =
-                 with_context "check_relation"
-                   (FStar_Pervasives_Native.Some (CtxRel (t02, rel1, t12)))
-                   (fun uu___1 -> check_relation g1 rel1 t02 t12) in
-               let uu___1 = equal_term t01 t11 in
-               if uu___1
-               then return ()
-               else
-                 (match ((t01.FStar_Syntax_Syntax.n),
-                          (t11.FStar_Syntax_Syntax.n))
-                  with
-                  | (FStar_Syntax_Syntax.Tm_type u0,
-                     FStar_Syntax_Syntax.Tm_type u1) ->
-                      let uu___3 =
-                        FStar_TypeChecker_Rel.teq_nosmt_force g.tcenv t01 t11 in
-                      if uu___3 then return () else err ()
-                  | (FStar_Syntax_Syntax.Tm_meta
-                     (t02, FStar_Syntax_Syntax.Meta_pattern uu___3), uu___4)
-                      -> check_relation1 g rel t02 t11
-                  | (FStar_Syntax_Syntax.Tm_meta
-                     (t02, FStar_Syntax_Syntax.Meta_named uu___3), uu___4) ->
-                      check_relation1 g rel t02 t11
-                  | (FStar_Syntax_Syntax.Tm_meta
-                     (t02, FStar_Syntax_Syntax.Meta_labeled uu___3), uu___4)
-                      -> check_relation1 g rel t02 t11
-                  | (FStar_Syntax_Syntax.Tm_meta
-                     (t02, FStar_Syntax_Syntax.Meta_desugared uu___3),
-                     uu___4) -> check_relation1 g rel t02 t11
-                  | (FStar_Syntax_Syntax.Tm_ascribed (t02, uu___3, uu___4),
-                     uu___5) -> check_relation1 g rel t02 t11
-                  | (uu___3, FStar_Syntax_Syntax.Tm_meta
-                     (t12, FStar_Syntax_Syntax.Meta_pattern uu___4)) ->
-                      check_relation1 g rel t01 t12
-                  | (uu___3, FStar_Syntax_Syntax.Tm_meta
-                     (t12, FStar_Syntax_Syntax.Meta_named uu___4)) ->
-                      check_relation1 g rel t01 t12
-                  | (uu___3, FStar_Syntax_Syntax.Tm_meta
-                     (t12, FStar_Syntax_Syntax.Meta_labeled uu___4)) ->
-                      check_relation1 g rel t01 t12
-                  | (uu___3, FStar_Syntax_Syntax.Tm_meta
-                     (t12, FStar_Syntax_Syntax.Meta_desugared uu___4)) ->
-                      check_relation1 g rel t01 t12
-                  | (uu___3, FStar_Syntax_Syntax.Tm_ascribed
-                     (t12, uu___4, uu___5)) -> check_relation1 g rel t01 t12
-                  | (FStar_Syntax_Syntax.Tm_uinst (f0, us0),
-                     FStar_Syntax_Syntax.Tm_uinst (f1, us1)) ->
-                      let uu___3 = equal_term f0 f1 in
-                      if uu___3
-                      then
-                        let uu___4 =
-                          FStar_TypeChecker_Rel.teq_nosmt_force g.tcenv t01
-                            t11 in
-                        (if uu___4 then return () else err ())
-                      else maybe_unfold_and_retry t01 t11
-                  | (FStar_Syntax_Syntax.Tm_fvar uu___3,
-                     FStar_Syntax_Syntax.Tm_fvar uu___4) ->
-                      maybe_unfold_and_retry t01 t11
-                  | (FStar_Syntax_Syntax.Tm_refine (x0, f0),
-                     FStar_Syntax_Syntax.Tm_refine (x1, f1)) ->
-                      let uu___3 =
-                        head_matches x0.FStar_Syntax_Syntax.sort
-                          x1.FStar_Syntax_Syntax.sort in
-                      if uu___3
-                      then
-                        let uu___4 =
-                          check_relation1 g EQUALITY
-                            x0.FStar_Syntax_Syntax.sort
-                            x1.FStar_Syntax_Syntax.sort in
-                        op_let_Bang uu___4
-                          (fun uu___5 ->
-                             let uu___6 =
-                               universe_of g x0.FStar_Syntax_Syntax.sort in
-                             op_let_Bang uu___6
-                               (fun u ->
-                                  let uu___7 =
-                                    let uu___8 =
-                                      FStar_Syntax_Syntax.mk_binder x0 in
-                                    open_term g uu___8 f0 in
-                                  match uu___7 with
-                                  | (g1, b, f01) ->
-                                      let f11 =
-                                        FStar_Syntax_Subst.subst
-                                          [FStar_Syntax_Syntax.DB
-                                             (Prims.int_zero,
-                                               (b.FStar_Syntax_Syntax.binder_bv))]
-                                          f1 in
-                                      op_let_Bang guard_not_allowed
-                                        (fun uu___8 ->
-                                           if uu___8
-                                           then
-                                             let uu___9 =
-                                               check_relation1 g1 EQUALITY
-                                                 f01 f11 in
-                                             with_binders [b] [u] uu___9
-                                           else
-                                             (match rel with
-                                              | EQUALITY ->
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      check_relation1 g1
-                                                        EQUALITY f01 f11 in
-                                                    handle_with uu___11
-                                                      (fun uu___12 ->
-                                                         let uu___13 =
-                                                           FStar_Syntax_Util.mk_iff
-                                                             f01 f11 in
-                                                         guard uu___13) in
-                                                  with_binders [b] [u]
-                                                    uu___10
-                                              | SUBTYPING
-                                                  (FStar_Pervasives_Native.Some
-                                                  tm) ->
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      FStar_Syntax_Util.mk_imp
-                                                        f01 f11 in
-                                                    FStar_Syntax_Subst.subst
-                                                      [FStar_Syntax_Syntax.NT
-                                                         ((b.FStar_Syntax_Syntax.binder_bv),
-                                                           tm)] uu___11 in
-                                                  guard uu___10
-                                              | SUBTYPING
-                                                  (FStar_Pervasives_Native.None)
-                                                  ->
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      FStar_Syntax_Util.mk_imp
-                                                        f01 f11 in
-                                                    FStar_Syntax_Util.mk_forall
-                                                      u
-                                                      b.FStar_Syntax_Syntax.binder_bv
-                                                      uu___11 in
-                                                  guard uu___10))))
-                      else
-                        (let uu___5 =
-                           maybe_unfold x0.FStar_Syntax_Syntax.sort
-                             x1.FStar_Syntax_Syntax.sort in
-                         match uu___5 with
-                         | FStar_Pervasives_Native.None -> fallback t01 t11
-                         | FStar_Pervasives_Native.Some (t02, t12) ->
-                             let lhs =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_refine
-                                    ({
-                                       FStar_Syntax_Syntax.ppname =
-                                         (x0.FStar_Syntax_Syntax.ppname);
-                                       FStar_Syntax_Syntax.index =
-                                         (x0.FStar_Syntax_Syntax.index);
-                                       FStar_Syntax_Syntax.sort = t02
-                                     }, f0)) t02.FStar_Syntax_Syntax.pos in
-                             let rhs =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_refine
-                                    ({
-                                       FStar_Syntax_Syntax.ppname =
-                                         (x1.FStar_Syntax_Syntax.ppname);
-                                       FStar_Syntax_Syntax.index =
-                                         (x1.FStar_Syntax_Syntax.index);
-                                       FStar_Syntax_Syntax.sort = t12
-                                     }, f1)) t12.FStar_Syntax_Syntax.pos in
-                             let uu___6 =
-                               FStar_Syntax_Util.flatten_refinement lhs in
-                             let uu___7 =
-                               FStar_Syntax_Util.flatten_refinement rhs in
-                             check_relation1 g rel uu___6 uu___7)
-                  | (FStar_Syntax_Syntax.Tm_refine (x0, f0), uu___3) ->
-                      let uu___4 =
-                        head_matches x0.FStar_Syntax_Syntax.sort t11 in
-                      if uu___4
-                      then
-                        check_relation1 g rel x0.FStar_Syntax_Syntax.sort t11
-                      else
-                        (let uu___6 =
-                           maybe_unfold x0.FStar_Syntax_Syntax.sort t11 in
-                         match uu___6 with
-                         | FStar_Pervasives_Native.None -> fallback t01 t11
-                         | FStar_Pervasives_Native.Some (t02, t12) ->
-                             let lhs =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_refine
-                                    ({
-                                       FStar_Syntax_Syntax.ppname =
-                                         (x0.FStar_Syntax_Syntax.ppname);
-                                       FStar_Syntax_Syntax.index =
-                                         (x0.FStar_Syntax_Syntax.index);
-                                       FStar_Syntax_Syntax.sort = t02
-                                     }, f0)) t02.FStar_Syntax_Syntax.pos in
-                             let uu___7 =
-                               FStar_Syntax_Util.flatten_refinement lhs in
-                             check_relation1 g rel uu___7 t12)
-                  | (uu___3, FStar_Syntax_Syntax.Tm_refine (x1, f1)) ->
-                      let uu___4 =
-                        head_matches t01 x1.FStar_Syntax_Syntax.sort in
-                      if uu___4
-                      then
-                        let uu___5 =
-                          universe_of g x1.FStar_Syntax_Syntax.sort in
-                        op_let_Bang uu___5
-                          (fun u1 ->
-                             let uu___6 =
-                               check_relation1 g EQUALITY t01
-                                 x1.FStar_Syntax_Syntax.sort in
-                             op_let_Bang uu___6
-                               (fun uu___7 ->
-                                  let uu___8 =
-                                    let uu___9 =
-                                      FStar_Syntax_Syntax.mk_binder x1 in
-                                    open_term g uu___9 f1 in
-                                  match uu___8 with
-                                  | (g1, b1, f11) ->
-                                      op_let_Bang guard_not_allowed
-                                        (fun uu___9 ->
-                                           if uu___9
-                                           then
-                                             let uu___10 =
-                                               check_relation1 g1 EQUALITY
-                                                 FStar_Syntax_Util.t_true f11 in
-                                             with_binders [b1] [u1] uu___10
-                                           else
-                                             (match rel with
-                                              | EQUALITY ->
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      check_relation1 g1
-                                                        EQUALITY
-                                                        FStar_Syntax_Util.t_true
-                                                        f11 in
-                                                    handle_with uu___12
-                                                      (fun uu___13 ->
-                                                         guard f11) in
-                                                  with_binders [b1] [u1]
-                                                    uu___11
-                                              | SUBTYPING
-                                                  (FStar_Pervasives_Native.Some
-                                                  tm) ->
-                                                  let uu___11 =
-                                                    FStar_Syntax_Subst.subst
-                                                      [FStar_Syntax_Syntax.NT
-                                                         ((b1.FStar_Syntax_Syntax.binder_bv),
-                                                           tm)] f11 in
-                                                  guard uu___11
-                                              | SUBTYPING
-                                                  (FStar_Pervasives_Native.None)
-                                                  ->
-                                                  let uu___11 =
-                                                    FStar_Syntax_Util.mk_forall
-                                                      u1
-                                                      b1.FStar_Syntax_Syntax.binder_bv
-                                                      f11 in
-                                                  guard uu___11))))
-                      else
-                        (let uu___6 =
-                           maybe_unfold t01 x1.FStar_Syntax_Syntax.sort in
-                         match uu___6 with
-                         | FStar_Pervasives_Native.None -> fallback t01 t11
-                         | FStar_Pervasives_Native.Some (t02, t12) ->
-                             let rhs =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_refine
-                                    ({
-                                       FStar_Syntax_Syntax.ppname =
-                                         (x1.FStar_Syntax_Syntax.ppname);
-                                       FStar_Syntax_Syntax.index =
-                                         (x1.FStar_Syntax_Syntax.index);
-                                       FStar_Syntax_Syntax.sort = t12
-                                     }, f1)) t12.FStar_Syntax_Syntax.pos in
-                             let uu___7 =
-                               FStar_Syntax_Util.flatten_refinement rhs in
-                             check_relation1 g rel t02 uu___7)
-                  | (FStar_Syntax_Syntax.Tm_uinst uu___3, uu___4) ->
-                      let head_matches1 = head_matches t01 t11 in
-                      let uu___5 =
-                        FStar_Syntax_Util.leftmost_head_and_args t01 in
-                      (match uu___5 with
-                       | (head0, args0) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.leftmost_head_and_args t11 in
-                           (match uu___6 with
-                            | (head1, args1) ->
-                                if
-                                  Prims.op_Negation
-                                    (head_matches1 &&
-                                       ((FStar_Compiler_List.length args0) =
-                                          (FStar_Compiler_List.length args1)))
-                                then maybe_unfold_and_retry t01 t11
-                                else
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       check_relation1 g EQUALITY head0 head1 in
-                                     op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          check_relation_args g EQUALITY
-                                            args0 args1) in
-                                   handle_with uu___8
-                                     (fun uu___9 ->
-                                        maybe_unfold_side_and_retry Both t01
-                                          t11))))
-                  | (FStar_Syntax_Syntax.Tm_fvar uu___3, uu___4) ->
-                      let head_matches1 = head_matches t01 t11 in
-                      let uu___5 =
-                        FStar_Syntax_Util.leftmost_head_and_args t01 in
-                      (match uu___5 with
-                       | (head0, args0) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.leftmost_head_and_args t11 in
-                           (match uu___6 with
-                            | (head1, args1) ->
-                                if
-                                  Prims.op_Negation
-                                    (head_matches1 &&
-                                       ((FStar_Compiler_List.length args0) =
-                                          (FStar_Compiler_List.length args1)))
-                                then maybe_unfold_and_retry t01 t11
-                                else
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       check_relation1 g EQUALITY head0 head1 in
-                                     op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          check_relation_args g EQUALITY
-                                            args0 args1) in
-                                   handle_with uu___8
-                                     (fun uu___9 ->
-                                        maybe_unfold_side_and_retry Both t01
-                                          t11))))
-                  | (FStar_Syntax_Syntax.Tm_app uu___3, uu___4) ->
-                      let head_matches1 = head_matches t01 t11 in
-                      let uu___5 =
-                        FStar_Syntax_Util.leftmost_head_and_args t01 in
-                      (match uu___5 with
-                       | (head0, args0) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.leftmost_head_and_args t11 in
-                           (match uu___6 with
-                            | (head1, args1) ->
-                                if
-                                  Prims.op_Negation
-                                    (head_matches1 &&
-                                       ((FStar_Compiler_List.length args0) =
-                                          (FStar_Compiler_List.length args1)))
-                                then maybe_unfold_and_retry t01 t11
-                                else
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       check_relation1 g EQUALITY head0 head1 in
-                                     op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          check_relation_args g EQUALITY
-                                            args0 args1) in
-                                   handle_with uu___8
-                                     (fun uu___9 ->
-                                        maybe_unfold_side_and_retry Both t01
-                                          t11))))
-                  | (uu___3, FStar_Syntax_Syntax.Tm_uinst uu___4) ->
-                      let head_matches1 = head_matches t01 t11 in
-                      let uu___5 =
-                        FStar_Syntax_Util.leftmost_head_and_args t01 in
-                      (match uu___5 with
-                       | (head0, args0) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.leftmost_head_and_args t11 in
-                           (match uu___6 with
-                            | (head1, args1) ->
-                                if
-                                  Prims.op_Negation
-                                    (head_matches1 &&
-                                       ((FStar_Compiler_List.length args0) =
-                                          (FStar_Compiler_List.length args1)))
-                                then maybe_unfold_and_retry t01 t11
-                                else
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       check_relation1 g EQUALITY head0 head1 in
-                                     op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          check_relation_args g EQUALITY
-                                            args0 args1) in
-                                   handle_with uu___8
-                                     (fun uu___9 ->
-                                        maybe_unfold_side_and_retry Both t01
-                                          t11))))
-                  | (uu___3, FStar_Syntax_Syntax.Tm_fvar uu___4) ->
-                      let head_matches1 = head_matches t01 t11 in
-                      let uu___5 =
-                        FStar_Syntax_Util.leftmost_head_and_args t01 in
-                      (match uu___5 with
-                       | (head0, args0) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.leftmost_head_and_args t11 in
-                           (match uu___6 with
-                            | (head1, args1) ->
-                                if
-                                  Prims.op_Negation
-                                    (head_matches1 &&
-                                       ((FStar_Compiler_List.length args0) =
-                                          (FStar_Compiler_List.length args1)))
-                                then maybe_unfold_and_retry t01 t11
-                                else
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       check_relation1 g EQUALITY head0 head1 in
-                                     op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          check_relation_args g EQUALITY
-                                            args0 args1) in
-                                   handle_with uu___8
-                                     (fun uu___9 ->
-                                        maybe_unfold_side_and_retry Both t01
-                                          t11))))
-                  | (uu___3, FStar_Syntax_Syntax.Tm_app uu___4) ->
-                      let head_matches1 = head_matches t01 t11 in
-                      let uu___5 =
-                        FStar_Syntax_Util.leftmost_head_and_args t01 in
-                      (match uu___5 with
-                       | (head0, args0) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.leftmost_head_and_args t11 in
-                           (match uu___6 with
-                            | (head1, args1) ->
-                                if
-                                  Prims.op_Negation
-                                    (head_matches1 &&
-                                       ((FStar_Compiler_List.length args0) =
-                                          (FStar_Compiler_List.length args1)))
-                                then maybe_unfold_and_retry t01 t11
-                                else
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       check_relation1 g EQUALITY head0 head1 in
-                                     op_let_Bang uu___9
-                                       (fun uu___10 ->
-                                          check_relation_args g EQUALITY
-                                            args0 args1) in
-                                   handle_with uu___8
-                                     (fun uu___9 ->
-                                        maybe_unfold_side_and_retry Both t01
-                                          t11))))
-                  | (FStar_Syntax_Syntax.Tm_abs (b0::b1::bs, body, ropt),
-                     uu___3) ->
-                      let t02 = curry_abs b0 b1 bs body ropt in
-                      check_relation1 g rel t02 t11
-                  | (uu___3, FStar_Syntax_Syntax.Tm_abs
-                     (b0::b1::bs, body, ropt)) ->
-                      let t12 = curry_abs b0 b1 bs body ropt in
-                      check_relation1 g rel t01 t12
-                  | (FStar_Syntax_Syntax.Tm_abs (b0::[], body0, uu___3),
-                     FStar_Syntax_Syntax.Tm_abs (b1::[], body1, uu___4)) ->
-                      let uu___5 =
-                        check_relation1 g EQUALITY
-                          (b0.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                          (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                      op_let_Bang uu___5
-                        (fun uu___6 ->
-                           let uu___7 =
-                             check_bqual b0.FStar_Syntax_Syntax.binder_qual
-                               b1.FStar_Syntax_Syntax.binder_qual in
-                           op_let_Bang uu___7
-                             (fun uu___8 ->
-                                let uu___9 =
-                                  universe_of g
-                                    (b0.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                op_let_Bang uu___9
-                                  (fun u ->
-                                     let uu___10 = open_term g b0 body0 in
-                                     match uu___10 with
-                                     | (g1, b01, body01) ->
-                                         let body11 =
-                                           FStar_Syntax_Subst.subst
-                                             [FStar_Syntax_Syntax.DB
-                                                (Prims.int_zero,
-                                                  (b01.FStar_Syntax_Syntax.binder_bv))]
-                                             body1 in
-                                         let uu___11 =
-                                           check_relation1 g1 EQUALITY body01
-                                             body11 in
-                                         with_binders [b01] [u] uu___11)))
-                  | (FStar_Syntax_Syntax.Tm_arrow (x0::x1::xs, c0), uu___3)
-                      ->
-                      let uu___4 = curry_arrow x0 (x1 :: xs) c0 in
-                      check_relation1 g rel uu___4 t11
-                  | (uu___3, FStar_Syntax_Syntax.Tm_arrow (x0::x1::xs, c1))
-                      ->
-                      let uu___4 = curry_arrow x0 (x1 :: xs) c1 in
-                      check_relation1 g rel t01 uu___4
-                  | (FStar_Syntax_Syntax.Tm_arrow (x0::[], c0),
-                     FStar_Syntax_Syntax.Tm_arrow (x1::[], c1)) ->
-                      with_context "subtype arrow"
-                        FStar_Pervasives_Native.None
-                        (fun uu___3 ->
-                           let uu___4 =
-                             check_bqual x0.FStar_Syntax_Syntax.binder_qual
-                               x1.FStar_Syntax_Syntax.binder_qual in
-                           op_let_Bang uu___4
-                             (fun uu___5 ->
-                                let uu___6 =
-                                  universe_of g
-                                    (x1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                op_let_Bang uu___6
-                                  (fun u1 ->
-                                     let uu___7 = open_comp g x1 c1 in
-                                     match uu___7 with
-                                     | (g_x1, x11, c11) ->
-                                         let c01 =
-                                           FStar_Syntax_Subst.subst_comp
-                                             [FStar_Syntax_Syntax.DB
-                                                (Prims.int_zero,
-                                                  (x11.FStar_Syntax_Syntax.binder_bv))]
-                                             c0 in
-                                         let uu___8 =
-                                           let rel_arg =
-                                             match rel with
-                                             | EQUALITY -> EQUALITY
-                                             | uu___9 ->
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     FStar_Syntax_Syntax.bv_to_name
-                                                       x11.FStar_Syntax_Syntax.binder_bv in
-                                                   FStar_Pervasives_Native.Some
-                                                     uu___11 in
-                                                 SUBTYPING uu___10 in
-                                           let rel_comp =
-                                             match rel with
-                                             | EQUALITY -> EQUALITY
-                                             | SUBTYPING e ->
-                                                 let uu___9 =
-                                                   let uu___10 =
-                                                     FStar_Syntax_Util.is_pure_or_ghost_comp
-                                                       c01 in
-                                                   if uu___10
-                                                   then
-                                                     op_let_Question e
-                                                       (fun e1 ->
-                                                          let uu___11 =
-                                                            let uu___12 =
-                                                              let uu___13 =
-                                                                FStar_Syntax_Util.args_of_binders
-                                                                  [x11] in
-                                                              FStar_Pervasives_Native.snd
-                                                                uu___13 in
-                                                            FStar_Syntax_Syntax.mk_Tm_app
-                                                              e1 uu___12
-                                                              FStar_Compiler_Range.dummyRange in
-                                                          FStar_Pervasives_Native.Some
-                                                            uu___11)
-                                                   else
-                                                     FStar_Pervasives_Native.None in
-                                                 SUBTYPING uu___9 in
-                                           let uu___9 =
-                                             check_relation1 g rel
-                                               (x11.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                               (x0.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                           op_let_Bang uu___9
-                                             (fun uu___10 ->
-                                                with_context "check_subcomp"
-                                                  FStar_Pervasives_Native.None
-                                                  (fun uu___11 ->
-                                                     check_relation_comp g_x1
-                                                       rel_comp c01 c11)) in
-                                         with_binders [x11] [u1] uu___8)))
-                  | (FStar_Syntax_Syntax.Tm_match (e0, uu___3, brs0, uu___4),
-                     FStar_Syntax_Syntax.Tm_match (e1, uu___5, brs1, uu___6))
-                      ->
-                      let relate_branch br0 br1 uu___7 =
-                        match (br0, br1) with
-                        | ((p0, FStar_Pervasives_Native.None, body0),
-                           (p1, FStar_Pervasives_Native.None, body1)) ->
-                            let uu___8 =
-                              let uu___9 = FStar_Syntax_Syntax.eq_pat p0 p1 in
-                              Prims.op_Negation uu___9 in
-                            if uu___8
-                            then fail "patterns not equal"
-                            else
-                              (let uu___10 =
-                                 open_branches_eq_pat g
-                                   (p0, FStar_Pervasives_Native.None, body0)
-                                   (p1, FStar_Pervasives_Native.None, body1) in
-                               match uu___10 with
-                               | (g', (p01, uu___11, body01),
-                                  (p11, uu___12, body11)) ->
-                                   let uu___13 =
-                                     FStar_TypeChecker_PatternUtils.raw_pat_as_exp
-                                       g.tcenv p01 in
-                                   (match uu___13 with
-                                    | FStar_Pervasives_Native.Some
-                                        (uu___14, bvs0) ->
-                                        let bs0 =
-                                          FStar_Compiler_List.map
-                                            FStar_Syntax_Syntax.mk_binder
-                                            bvs0 in
-                                        let uu___15 = check_binders g bs0 in
-                                        op_let_Bang uu___15
-                                          (fun us ->
-                                             let uu___16 =
-                                               check_relation1 g' rel body01
-                                                 body11 in
-                                             with_binders bs0 us uu___16)
-                                    | uu___14 ->
-                                        fail
-                                          "raw_pat_as_exp failed in check_equality match rule"))
-                        | uu___8 ->
-                            fail "Core does not support branches with when" in
-                      let uu___7 =
-                        let uu___8 = check_relation1 g EQUALITY e0 e1 in
-                        op_let_Bang uu___8
-                          (fun uu___9 -> iter2 brs0 brs1 relate_branch ()) in
-                      handle_with uu___7 (fun uu___8 -> fallback t01 t11)
-                  | uu___3 -> fallback t01 t11))
-and (check_relation_args :
-  env ->
-    relation ->
-      FStar_Syntax_Syntax.args -> FStar_Syntax_Syntax.args -> unit result)
-  =
-  fun g ->
-    fun rel ->
-      fun a0 ->
-        fun a1 ->
-          if
-            (FStar_Compiler_List.length a0) = (FStar_Compiler_List.length a1)
-          then
-            iter2 a0 a1
-              (fun uu___ ->
-                 fun uu___1 ->
-                   fun uu___2 ->
-                     match (uu___, uu___1) with
-                     | ((t0, q0), (t1, q1)) ->
-                         let uu___3 = check_aqual q0 q1 in
-                         op_let_Bang uu___3
-                           (fun uu___4 -> check_relation g rel t0 t1)) ()
-          else fail "Unequal number of arguments"
-and (check_relation_comp :
-  env ->
-    relation ->
-      FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp -> unit result)
-  =
-  fun g ->
-    fun rel ->
-      fun c0 ->
-        fun c1 ->
-          let destruct_comp c =
-            let uu___ = FStar_Syntax_Util.is_total_comp c in
-            if uu___
-            then
-              FStar_Pervasives_Native.Some
-                (E_TOTAL, (FStar_Syntax_Util.comp_result c))
-            else
-              (let uu___2 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-               if uu___2
-               then
-                 FStar_Pervasives_Native.Some
-                   (E_GHOST, (FStar_Syntax_Util.comp_result c))
-               else FStar_Pervasives_Native.None) in
-          let uu___ =
-            let uu___1 = destruct_comp c0 in
-            let uu___2 = destruct_comp c1 in (uu___1, uu___2) in
-          match uu___ with
-          | (FStar_Pervasives_Native.None, uu___1) ->
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.eq_comp c0 c1 in
-                uu___3 = FStar_Syntax_Util.Equal in
-              if uu___2
-              then return ()
-              else
-                (let ct_eq res0 args0 res1 args1 =
-                   let uu___4 = check_relation g EQUALITY res0 res1 in
-                   op_let_Bang uu___4
-                     (fun uu___5 ->
-                        check_relation_args g EQUALITY args0 args1) in
-                 let uu___4 = FStar_Syntax_Util.comp_eff_name_res_and_args c0 in
-                 match uu___4 with
-                 | (eff0, res0, args0) ->
-                     let uu___5 =
-                       FStar_Syntax_Util.comp_eff_name_res_and_args c1 in
-                     (match uu___5 with
-                      | (eff1, res1, args1) ->
-                          let uu___6 = FStar_Ident.lid_equals eff0 eff1 in
-                          if uu___6
-                          then ct_eq res0 args0 res1 args1
-                          else
-                            (let ct0 =
-                               FStar_TypeChecker_Env.unfold_effect_abbrev
-                                 g.tcenv c0 in
-                             let ct1 =
-                               FStar_TypeChecker_Env.unfold_effect_abbrev
-                                 g.tcenv c1 in
-                             let uu___8 =
-                               FStar_Ident.lid_equals
-                                 ct0.FStar_Syntax_Syntax.effect_name
-                                 ct1.FStar_Syntax_Syntax.effect_name in
-                             if uu___8
-                             then
-                               ct_eq ct0.FStar_Syntax_Syntax.result_typ
-                                 ct0.FStar_Syntax_Syntax.effect_args
-                                 ct1.FStar_Syntax_Syntax.result_typ
-                                 ct1.FStar_Syntax_Syntax.effect_args
-                             else
-                               (let uu___10 =
-                                  let uu___11 =
-                                    FStar_Ident.string_of_lid
-                                      ct0.FStar_Syntax_Syntax.effect_name in
-                                  let uu___12 =
-                                    FStar_Ident.string_of_lid
-                                      ct1.FStar_Syntax_Syntax.effect_name in
-                                  FStar_Compiler_Util.format2
-                                    "Subcomp failed: Unequal computation types %s and %s"
-                                    uu___11 uu___12 in
-                                fail uu___10))))
-          | (uu___1, FStar_Pervasives_Native.None) ->
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.eq_comp c0 c1 in
-                uu___3 = FStar_Syntax_Util.Equal in
-              if uu___2
-              then return ()
-              else
-                (let ct_eq res0 args0 res1 args1 =
-                   let uu___4 = check_relation g EQUALITY res0 res1 in
-                   op_let_Bang uu___4
-                     (fun uu___5 ->
-                        check_relation_args g EQUALITY args0 args1) in
-                 let uu___4 = FStar_Syntax_Util.comp_eff_name_res_and_args c0 in
-                 match uu___4 with
-                 | (eff0, res0, args0) ->
-                     let uu___5 =
-                       FStar_Syntax_Util.comp_eff_name_res_and_args c1 in
-                     (match uu___5 with
-                      | (eff1, res1, args1) ->
-                          let uu___6 = FStar_Ident.lid_equals eff0 eff1 in
-                          if uu___6
-                          then ct_eq res0 args0 res1 args1
-                          else
-                            (let ct0 =
-                               FStar_TypeChecker_Env.unfold_effect_abbrev
-                                 g.tcenv c0 in
-                             let ct1 =
-                               FStar_TypeChecker_Env.unfold_effect_abbrev
-                                 g.tcenv c1 in
-                             let uu___8 =
-                               FStar_Ident.lid_equals
-                                 ct0.FStar_Syntax_Syntax.effect_name
-                                 ct1.FStar_Syntax_Syntax.effect_name in
-                             if uu___8
-                             then
-                               ct_eq ct0.FStar_Syntax_Syntax.result_typ
-                                 ct0.FStar_Syntax_Syntax.effect_args
-                                 ct1.FStar_Syntax_Syntax.result_typ
-                                 ct1.FStar_Syntax_Syntax.effect_args
-                             else
-                               (let uu___10 =
-                                  let uu___11 =
-                                    FStar_Ident.string_of_lid
-                                      ct0.FStar_Syntax_Syntax.effect_name in
-                                  let uu___12 =
-                                    FStar_Ident.string_of_lid
-                                      ct1.FStar_Syntax_Syntax.effect_name in
-                                  FStar_Compiler_Util.format2
-                                    "Subcomp failed: Unequal computation types %s and %s"
-                                    uu___11 uu___12 in
-                                fail uu___10))))
-          | (FStar_Pervasives_Native.Some (E_TOTAL, t0),
-             FStar_Pervasives_Native.Some (uu___1, t1)) ->
-              check_relation g rel t0 t1
-          | (FStar_Pervasives_Native.Some (E_GHOST, t0),
-             FStar_Pervasives_Native.Some (E_GHOST, t1)) ->
-              check_relation g rel t0 t1
-          | (FStar_Pervasives_Native.Some (E_GHOST, t0),
-             FStar_Pervasives_Native.Some (E_TOTAL, t1)) ->
-              let uu___1 = non_informative g t1 in
-              if uu___1
-              then check_relation g rel t0 t1
-              else fail "Expected a Total computation, but got Ghost"
-and (check_subtype :
-  env ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.typ ->
-          context -> (unit success, error) FStar_Pervasives.either)
-  =
-  fun g ->
-    fun e ->
-      fun t0 ->
-        fun t1 ->
-          fun ctx ->
-            FStar_Profiling.profile
-              (fun uu___ ->
-                 let rel = SUBTYPING e in
-                 let uu___1 =
-                   with_context
-                     (if ctx.no_guard
-                      then "check_subtype(no_guard)"
-                      else "check_subtype")
-                     (FStar_Pervasives_Native.Some (CtxRel (t0, rel, t1)))
-                     (fun uu___2 -> check_relation g rel t0 t1) in
-                 uu___1 ctx) FStar_Pervasives_Native.None
-              "FStar.TypeChecker.Core.check_subtype"
-and (memo_check :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (effect_label * FStar_Syntax_Syntax.typ) result)
-  =
-  fun g ->
-    fun e ->
-      let check_then_memo g1 e1 ctx =
-        let r = let uu___ = check' g1 e1 in uu___ ctx in
-        match r with
-        | FStar_Pervasives.Inl (res, FStar_Pervasives_Native.None) ->
-            (insert g1 e1 (res, FStar_Pervasives_Native.None); r)
-        | FStar_Pervasives.Inl (res, FStar_Pervasives_Native.Some guard1) ->
-            (match g1.guard_handler with
-             | FStar_Pervasives_Native.None ->
-                 (insert g1 e1 (res, (FStar_Pervasives_Native.Some guard1));
-                  r)
-             | FStar_Pervasives_Native.Some gh ->
-                 let uu___ = gh g1.tcenv guard1 in
-                 if uu___
-                 then
-                   let r1 = (res, FStar_Pervasives_Native.None) in
-                   (insert g1 e1 r1; FStar_Pervasives.Inl r1)
-                 else
-                   (let uu___2 = fail "guard handler failed" in uu___2 ctx))
-        | uu___ -> r in
-      fun ctx ->
-        if Prims.op_Negation g.should_read_cache
-        then check_then_memo g e ctx
-        else
-          (let uu___1 = let uu___2 = lookup g e in uu___2 ctx in
-           match uu___1 with
-           | FStar_Pervasives.Inr uu___2 -> check_then_memo g e ctx
-           | FStar_Pervasives.Inl (et, FStar_Pervasives_Native.None) ->
-               FStar_Pervasives.Inl (et, FStar_Pervasives_Native.None)
-           | FStar_Pervasives.Inl (et, FStar_Pervasives_Native.Some pre) ->
-               (match g.guard_handler with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Pervasives.Inl
-                      (et, (FStar_Pervasives_Native.Some pre))
-                | FStar_Pervasives_Native.Some uu___2 ->
-                    check_then_memo
-                      {
-                        tcenv = (g.tcenv);
-                        allow_universe_instantiation =
-                          (g.allow_universe_instantiation);
-                        max_binder_index = (g.max_binder_index);
-                        guard_handler = (g.guard_handler);
-                        should_read_cache = false
-                      } e ctx))
-and (check :
-  Prims.string ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        (effect_label * FStar_Syntax_Syntax.typ) result)
-  =
-  fun msg ->
-    fun g ->
-      fun e ->
-        with_context msg (FStar_Pervasives_Native.Some (CtxTerm e))
-          (fun uu___ -> memo_check g e)
-and (check' :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (effect_label * FStar_Syntax_Syntax.typ) result)
-  =
-  fun g ->
-    fun e ->
-      let e1 = FStar_Syntax_Subst.compress e in
-      match e1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_lazy
-          { FStar_Syntax_Syntax.blob = uu___;
-            FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_embedding
-              uu___1;
-            FStar_Syntax_Syntax.ltyp = uu___2;
-            FStar_Syntax_Syntax.rng = uu___3;_}
-          -> let uu___4 = FStar_Syntax_Util.unlazy e1 in check' g uu___4
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          return (E_TOTAL, (i.FStar_Syntax_Syntax.ltyp))
-      | FStar_Syntax_Syntax.Tm_meta (t, uu___) -> memo_check g t
-      | FStar_Syntax_Syntax.Tm_uvar (uv, s) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Util.ctx_uvar_typ uv in
-              FStar_Syntax_Subst.subst' s uu___2 in
-            (E_TOTAL, uu___1) in
-          return uu___
-      | FStar_Syntax_Syntax.Tm_name x ->
-          let uu___ = FStar_TypeChecker_Env.try_lookup_bv g.tcenv x in
-          (match uu___ with
-           | FStar_Pervasives_Native.None ->
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Print.bv_to_string x in
-                 FStar_Compiler_Util.format1 "Variable not found: %s" uu___2 in
-               fail uu___1
-           | FStar_Pervasives_Native.Some (t, uu___1) -> return (E_TOTAL, t))
-      | FStar_Syntax_Syntax.Tm_fvar f ->
-          let uu___ =
-            FStar_TypeChecker_Env.try_lookup_lid g.tcenv
-              (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___ with
-           | FStar_Pervasives_Native.Some (([], t), uu___1) ->
-               return (E_TOTAL, t)
-           | uu___1 -> fail "Missing universes instantiation")
-      | FStar_Syntax_Syntax.Tm_uinst
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar f;
-             FStar_Syntax_Syntax.pos = uu___;
-             FStar_Syntax_Syntax.vars = uu___1;
-             FStar_Syntax_Syntax.hash_code = uu___2;_},
-           us)
-          ->
-          let uu___3 =
-            FStar_TypeChecker_Env.try_lookup_and_inst_lid g.tcenv us
-              (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___3 with
-           | FStar_Pervasives_Native.None ->
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Ident.string_of_lid
-                     (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                 FStar_Compiler_Util.format1 "Top-level name not found: %s"
-                   uu___5 in
-               fail uu___4
-           | FStar_Pervasives_Native.Some (t, uu___4) -> return (E_TOTAL, t))
-      | FStar_Syntax_Syntax.Tm_constant c ->
-          (match c with
-           | FStar_Const.Const_range_of -> fail "Unhandled constant"
-           | FStar_Const.Const_set_range_of -> fail "Unhandled constant"
-           | FStar_Const.Const_reify -> fail "Unhandled constant"
-           | FStar_Const.Const_reflect uu___ -> fail "Unhandled constant"
-           | uu___ ->
-               let t =
-                 FStar_TypeChecker_TcTerm.tc_constant g.tcenv
-                   e1.FStar_Syntax_Syntax.pos c in
-               return (E_TOTAL, t))
-      | FStar_Syntax_Syntax.Tm_type u ->
-          let uu___ =
-            let uu___1 = mk_type (FStar_Syntax_Syntax.U_succ u) in
-            (E_TOTAL, uu___1) in
-          return uu___
-      | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-          let uu___ = check "refinement head" g x.FStar_Syntax_Syntax.sort in
-          op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (uu___2, t) ->
-                   let uu___3 = is_type g t in
-                   op_let_Bang uu___3
-                     (fun u ->
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.mk_binder x in
-                          open_term g uu___5 phi in
-                        match uu___4 with
-                        | (g', x1, phi1) ->
-                            let uu___5 =
-                              let uu___6 = check "refinement formula" g' phi1 in
-                              op_let_Bang uu___6
-                                (fun uu___7 ->
-                                   match uu___7 with
-                                   | (uu___8, t') ->
-                                       let uu___9 = is_type g' t' in
-                                       op_let_Bang uu___9
-                                         (fun uu___10 -> return (E_TOTAL, t))) in
-                            with_binders [x1] [u] uu___5))
-      | FStar_Syntax_Syntax.Tm_abs (xs, body, uu___) ->
-          let uu___1 = open_term_binders g xs body in
-          (match uu___1 with
-           | (g', xs1, body1) ->
-               let uu___2 =
-                 with_context "abs binders" FStar_Pervasives_Native.None
-                   (fun uu___3 -> check_binders g xs1) in
-               op_let_Bang uu___2
-                 (fun us ->
-                    let uu___3 =
-                      let uu___4 = check "abs body" g' body1 in
-                      op_let_Bang uu___4
-                        (fun t ->
-                           let uu___5 =
-                             let uu___6 =
-                               let uu___7 = as_comp g t in
-                               FStar_Syntax_Util.arrow xs1 uu___7 in
-                             (E_TOTAL, uu___6) in
-                           return uu___5) in
-                    with_binders xs1 us uu___3))
-      | FStar_Syntax_Syntax.Tm_arrow (xs, c) ->
-          let uu___ = open_comp_binders g xs c in
-          (match uu___ with
-           | (g', xs1, c1) ->
-               let uu___1 =
-                 with_context "arrow binders" FStar_Pervasives_Native.None
-                   (fun uu___2 -> check_binders g xs1) in
-               op_let_Bang uu___1
-                 (fun us ->
-                    let uu___2 =
-                      let uu___3 =
-                        with_context "arrow comp"
-                          FStar_Pervasives_Native.None
-                          (fun uu___4 -> check_comp g' c1) in
-                      op_let_Bang uu___3
-                        (fun u ->
-                           let uu___4 =
-                             let uu___5 =
-                               mk_type (FStar_Syntax_Syntax.U_max (u :: us)) in
-                             (E_TOTAL, uu___5) in
-                           return uu___4) in
-                    with_binders xs1 us uu___2))
-      | FStar_Syntax_Syntax.Tm_app
-          (hd,
-           (t1, FStar_Pervasives_Native.None)::(t2,
-                                                FStar_Pervasives_Native.None)::[])
-          when FStar_TypeChecker_Util.short_circuit_head hd ->
-          let uu___ = check "app head" g hd in
-          op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (eff_hd, t_hd) ->
-                   let uu___2 = is_arrow g t_hd in
-                   op_let_Bang uu___2
-                     (fun uu___3 ->
-                        match uu___3 with
-                        | (x, eff_arr1, s1) ->
-                            let uu___4 = check "app arg" g t1 in
-                            op_let_Bang uu___4
-                              (fun uu___5 ->
-                                 match uu___5 with
-                                 | (eff_arg1, t_t1) ->
-                                     let uu___6 =
-                                       with_context "operator arg1"
-                                         FStar_Pervasives_Native.None
-                                         (fun uu___7 ->
-                                            check_subtype g
-                                              (FStar_Pervasives_Native.Some
-                                                 t1) t_t1
-                                              (x.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort) in
-                                     op_let_Bang uu___6
-                                       (fun uu___7 ->
-                                          let s11 =
-                                            FStar_Syntax_Subst.subst
-                                              [FStar_Syntax_Syntax.NT
-                                                 ((x.FStar_Syntax_Syntax.binder_bv),
-                                                   t1)] s1 in
-                                          let uu___8 = is_arrow g s11 in
-                                          op_let_Bang uu___8
-                                            (fun uu___9 ->
-                                               match uu___9 with
-                                               | (y, eff_arr2, s2) ->
-                                                   let guard_formula =
-                                                     FStar_TypeChecker_Util.short_circuit
-                                                       hd
-                                                       [(t1,
-                                                          FStar_Pervasives_Native.None)] in
-                                                   let g' =
-                                                     match guard_formula with
-                                                     | FStar_TypeChecker_Common.Trivial
-                                                         -> g
-                                                     | FStar_TypeChecker_Common.NonTrivial
-                                                         gf ->
-                                                         push_hypothesis g gf in
-                                                   let uu___10 =
-                                                     let uu___11 =
-                                                       check "app arg" g' t2 in
-                                                     weaken_with_guard_formula
-                                                       guard_formula uu___11 in
-                                                   op_let_Bang uu___10
-                                                     (fun uu___11 ->
-                                                        match uu___11 with
-                                                        | (eff_arg2, t_t2) ->
-                                                            let uu___12 =
-                                                              with_context
-                                                                "operator arg2"
-                                                                FStar_Pervasives_Native.None
-                                                                (fun uu___13
-                                                                   ->
-                                                                   check_subtype
-                                                                    g'
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    t2) t_t2
-                                                                    (y.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort) in
-                                                            op_let_Bang
-                                                              uu___12
-                                                              (fun uu___13 ->
-                                                                 let uu___14
-                                                                   =
-                                                                   let uu___15
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    [
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    ((y.FStar_Syntax_Syntax.binder_bv),
-                                                                    t2)] s2 in
-                                                                   ((join_eff_l
-                                                                    [eff_hd;
-                                                                    eff_arr1;
-                                                                    eff_arr2;
-                                                                    eff_arg1;
-                                                                    eff_arg2]),
-                                                                    uu___15) in
-                                                                 return
-                                                                   uu___14)))))))
-      | FStar_Syntax_Syntax.Tm_app (hd, (arg, arg_qual)::[]) ->
-          let uu___ = check "app head" g hd in
-          op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (eff_hd, t) ->
-                   let uu___2 = is_arrow g t in
-                   op_let_Bang uu___2
-                     (fun uu___3 ->
-                        match uu___3 with
-                        | (x, eff_arr, t') ->
-                            let uu___4 = check "app arg" g arg in
-                            op_let_Bang uu___4
-                              (fun uu___5 ->
-                                 match uu___5 with
-                                 | (eff_arg, t_arg) ->
-                                     let uu___6 =
-                                       with_context "app subtyping"
-                                         FStar_Pervasives_Native.None
-                                         (fun uu___7 ->
-                                            check_subtype g
-                                              (FStar_Pervasives_Native.Some
-                                                 arg) t_arg
-                                              (x.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort) in
-                                     op_let_Bang uu___6
-                                       (fun uu___7 ->
-                                          let uu___8 =
-                                            with_context "app arg qual"
-                                              FStar_Pervasives_Native.None
-                                              (fun uu___9 ->
-                                                 check_arg_qual arg_qual
-                                                   x.FStar_Syntax_Syntax.binder_qual) in
-                                          op_let_Bang uu___8
-                                            (fun uu___9 ->
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_Syntax_Subst.subst
-                                                     [FStar_Syntax_Syntax.NT
-                                                        ((x.FStar_Syntax_Syntax.binder_bv),
-                                                          arg)] t' in
-                                                 ((join_eff eff_hd
-                                                     (join_eff eff_arr
-                                                        eff_arg)), uu___11) in
-                                               return uu___10)))))
-      | FStar_Syntax_Syntax.Tm_app (hd, arg::args) ->
-          let head =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (hd, [arg]))
-              e1.FStar_Syntax_Syntax.pos in
-          let t =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (head, args))
-              e1.FStar_Syntax_Syntax.pos in
-          memo_check g t
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (e2, (FStar_Pervasives.Inl t, uu___, eq), uu___1) ->
-          let uu___2 = check "ascription head" g e2 in
-          op_let_Bang uu___2
-            (fun uu___3 ->
-               match uu___3 with
-               | (eff, te) ->
-                   let uu___4 = check "ascription type" g t in
-                   op_let_Bang uu___4
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (uu___6, t') ->
-                            let uu___7 = is_type g t' in
-                            op_let_Bang uu___7
-                              (fun uu___8 ->
-                                 let uu___9 =
-                                   with_context "ascription subtyping"
-                                     FStar_Pervasives_Native.None
-                                     (fun uu___10 ->
-                                        check_subtype g
-                                          (FStar_Pervasives_Native.Some e2)
-                                          te t) in
-                                 op_let_Bang uu___9
-                                   (fun uu___10 -> return (eff, t)))))
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (e2, (FStar_Pervasives.Inr c, uu___, uu___1), uu___2) ->
-          let uu___3 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-          if uu___3
-          then
-            let uu___4 = check "ascription head" g e2 in
-            op_let_Bang uu___4
-              (fun uu___5 ->
-                 match uu___5 with
-                 | (eff, te) ->
-                     let uu___6 =
-                       with_context "ascription comp"
-                         FStar_Pervasives_Native.None
-                         (fun uu___7 -> check_comp g c) in
-                     op_let_Bang uu___6
-                       (fun uu___7 ->
-                          let c_e = as_comp g (eff, te) in
-                          let uu___8 =
-                            check_relation_comp g
-                              (SUBTYPING (FStar_Pervasives_Native.Some e2))
-                              c_e c in
-                          op_let_Bang uu___8
-                            (fun uu___9 ->
-                               let uu___10 = comp_as_effect_label_and_type c in
-                               match uu___10 with
-                               | FStar_Pervasives_Native.Some (eff1, t) ->
-                                   return (eff1, t))))
-          else
-            (let uu___5 =
-               let uu___6 = FStar_Syntax_Print.comp_to_string c in
-               FStar_Compiler_Util.format1
-                 "Effect ascriptions are not fully handled yet: %s" uu___6 in
-             fail uu___5)
-      | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-          let uu___ = lb.FStar_Syntax_Syntax.lbname in
-          (match uu___ with
-           | FStar_Pervasives.Inl x ->
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Syntax.mk_binder x in
-                 open_term g uu___2 body in
-               (match uu___1 with
-                | (g', x1, body1) ->
-                    let uu___2 =
-                      FStar_Ident.lid_equals lb.FStar_Syntax_Syntax.lbeff
-                        FStar_Parser_Const.effect_Tot_lid in
-                    if uu___2
-                    then
-                      let uu___3 =
-                        check "let definition" g lb.FStar_Syntax_Syntax.lbdef in
-                      op_let_Bang uu___3
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | (eff_def, tdef) ->
-                               let uu___5 =
-                                 check "let type" g
-                                   lb.FStar_Syntax_Syntax.lbtyp in
-                               op_let_Bang uu___5
-                                 (fun uu___6 ->
-                                    match uu___6 with
-                                    | (uu___7, ttyp) ->
-                                        let uu___8 = is_type g ttyp in
-                                        op_let_Bang uu___8
-                                          (fun u ->
-                                             let uu___9 =
-                                               with_context "let subtyping"
-                                                 FStar_Pervasives_Native.None
-                                                 (fun uu___10 ->
-                                                    check_subtype g
-                                                      (FStar_Pervasives_Native.Some
-                                                         (lb.FStar_Syntax_Syntax.lbdef))
-                                                      tdef ttyp) in
-                                             op_let_Bang uu___9
-                                               (fun uu___10 ->
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      check "let body" g'
-                                                        body1 in
-                                                    op_let_Bang uu___12
-                                                      (fun uu___13 ->
-                                                         match uu___13 with
-                                                         | (eff_body, t) ->
-                                                             let uu___14 =
-                                                               check_no_escape
-                                                                 [x1] t in
-                                                             op_let_Bang
-                                                               uu___14
-                                                               (fun uu___15
-                                                                  ->
-                                                                  return
-                                                                    ((join_eff
-                                                                    eff_def
-                                                                    eff_body),
-                                                                    t))) in
-                                                  with_definition x1 u
-                                                    lb.FStar_Syntax_Syntax.lbdef
-                                                    uu___11))))
-                    else fail "Let binding is effectful"))
-      | FStar_Syntax_Syntax.Tm_match
-          (sc, FStar_Pervasives_Native.None, branches, rc_opt) ->
-          let uu___ = check "scrutinee" g sc in
-          op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (eff_sc, t_sc) ->
-                   let uu___2 =
-                     with_context "universe_of"
-                       (FStar_Pervasives_Native.Some (CtxTerm t_sc))
-                       (fun uu___3 -> universe_of g t_sc) in
-                   op_let_Bang uu___2
-                     (fun u_sc ->
-                        let rec check_branches path_condition branch_typ_opt
-                          branches1 =
-                          match branches1 with
-                          | [] ->
-                              (match branch_typ_opt with
-                               | FStar_Pervasives_Native.None ->
-                                   fail
-                                     "could not compute a type for the match"
-                               | FStar_Pervasives_Native.Some et ->
-                                   let uu___3 =
-                                     boolean_negation_simp path_condition in
-                                   (match uu___3 with
-                                    | FStar_Pervasives_Native.None ->
-                                        return et
-                                    | FStar_Pervasives_Native.Some g1 ->
-                                        let uu___4 =
-                                          let uu___5 =
-                                            FStar_Syntax_Util.b2t g1 in
-                                          guard uu___5 in
-                                        op_let_Bang uu___4
-                                          (fun uu___5 -> return et)))
-                          | (p, FStar_Pervasives_Native.None, b)::rest ->
-                              let uu___3 =
-                                open_branch g
-                                  (p, FStar_Pervasives_Native.None, b) in
-                              (match uu___3 with
-                               | (uu___4, (p1, uu___5, b1)) ->
-                                   let uu___6 =
-                                     with_context "check_pat"
-                                       FStar_Pervasives_Native.None
-                                       (fun uu___7 -> check_pat g p1 t_sc) in
-                                   op_let_Bang uu___6
-                                     (fun uu___7 ->
-                                        match uu___7 with
-                                        | (bs, us) ->
-                                            let uu___8 =
-                                              pattern_branch_condition g sc
-                                                p1 in
-                                            op_let_Bang uu___8
-                                              (fun branch_condition ->
-                                                 let pat_sc_eq =
-                                                   let uu___9 =
-                                                     let uu___10 =
-                                                       let uu___11 =
-                                                         FStar_TypeChecker_PatternUtils.raw_pat_as_exp
-                                                           g.tcenv p1 in
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         uu___11
-                                                         FStar_Compiler_Util.must in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___10
-                                                       FStar_Pervasives_Native.fst in
-                                                   FStar_Syntax_Util.mk_eq2
-                                                     u_sc t_sc sc uu___9 in
-                                                 let uu___9 =
-                                                   combine_path_and_branch_condition
-                                                     path_condition
-                                                     branch_condition
-                                                     pat_sc_eq in
-                                                 match uu___9 with
-                                                 | (this_path_condition,
-                                                    next_path_condition) ->
-                                                     let g' =
-                                                       push_binders g bs in
-                                                     let g'1 =
-                                                       push_hypothesis g'
-                                                         this_path_condition in
-                                                     let uu___10 =
-                                                       let uu___11 =
-                                                         let uu___12 =
-                                                           let uu___13 =
-                                                             with_context
-                                                               "branch"
-                                                               (FStar_Pervasives_Native.Some
-                                                                  (CtxTerm b1))
-                                                               (fun uu___14
-                                                                  ->
-                                                                  check
-                                                                    "branch"
-                                                                    g'1 b1) in
-                                                           op_let_Bang
-                                                             uu___13
-                                                             (fun uu___14 ->
-                                                                match uu___14
-                                                                with
-                                                                | (eff_br,
-                                                                   tbr) ->
-                                                                    (
-                                                                    match branch_typ_opt
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    let uu___15
-                                                                    =
-                                                                    check_no_escape
-                                                                    bs tbr in
-                                                                    op_let_Bang
-                                                                    uu___15
-                                                                    (fun
-                                                                    uu___16
-                                                                    ->
-                                                                    return
-                                                                    (eff_br,
-                                                                    tbr))
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (acc_eff,
-                                                                    expect_tbr)
-                                                                    ->
-                                                                    let uu___15
-                                                                    =
-                                                                    with_context
-                                                                    "check_branch_subtype"
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    (CtxRel
-                                                                    (tbr,
-                                                                    (SUBTYPING
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    b1)),
-                                                                    expect_tbr)))
-                                                                    (fun
-                                                                    uu___16
-                                                                    ->
-                                                                    check_subtype
-                                                                    g'1
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    b1) tbr
-                                                                    expect_tbr) in
-                                                                    op_let_Bang
-                                                                    uu___15
-                                                                    (fun
-                                                                    uu___16
-                                                                    ->
-                                                                    return
-                                                                    ((join_eff
-                                                                    eff_br
-                                                                    acc_eff),
-                                                                    expect_tbr)))) in
-                                                         weaken
-                                                           this_path_condition
-                                                           uu___12 in
-                                                       with_binders bs us
-                                                         uu___11 in
-                                                     op_let_Bang uu___10
-                                                       (fun uu___11 ->
-                                                          match uu___11 with
-                                                          | (eff_br, tbr) ->
-                                                              (match 
-                                                                 p1.FStar_Syntax_Syntax.v
-                                                               with
-                                                               | FStar_Syntax_Syntax.Pat_var
-                                                                   uu___12 ->
-                                                                   (match rest
-                                                                    with
-                                                                    | 
-                                                                    uu___13::uu___14
-                                                                    ->
-                                                                    fail
-                                                                    "Redundant branches after wildcard"
-                                                                    | 
-                                                                    uu___13
-                                                                    ->
-                                                                    return
-                                                                    (eff_br,
-                                                                    tbr))
-                                                               | FStar_Syntax_Syntax.Pat_wild
-                                                                   uu___12 ->
-                                                                   (match rest
-                                                                    with
-                                                                    | 
-                                                                    uu___13::uu___14
-                                                                    ->
-                                                                    fail
-                                                                    "Redundant branches after wildcard"
-                                                                    | 
-                                                                    uu___13
-                                                                    ->
-                                                                    return
-                                                                    (eff_br,
-                                                                    tbr))
-                                                               | uu___12 ->
-                                                                   check_branches
-                                                                    next_path_condition
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    (eff_br,
-                                                                    tbr))
-                                                                    rest))))) in
-                        let uu___3 =
-                          match rc_opt with
-                          | FStar_Pervasives_Native.Some
-                              { FStar_Syntax_Syntax.residual_effect = uu___4;
-                                FStar_Syntax_Syntax.residual_typ =
-                                  FStar_Pervasives_Native.Some t;
-                                FStar_Syntax_Syntax.residual_flags = uu___5;_}
-                              ->
-                              let uu___6 =
-                                with_context "residual type"
-                                  (FStar_Pervasives_Native.Some (CtxTerm t))
-                                  (fun uu___7 -> universe_of g t) in
-                              op_let_Bang uu___6
-                                (fun uu___7 ->
-                                   return
-                                     (FStar_Pervasives_Native.Some
-                                        (E_TOTAL, t)))
-                          | uu___4 -> return FStar_Pervasives_Native.None in
-                        op_let_Bang uu___3
-                          (fun branch_typ_opt ->
-                             let uu___4 =
-                               let ctx =
-                                 match branch_typ_opt with
-                                 | FStar_Pervasives_Native.None ->
-                                     FStar_Pervasives_Native.None
-                                 | FStar_Pervasives_Native.Some (uu___5, t)
-                                     ->
-                                     FStar_Pervasives_Native.Some (CtxTerm t) in
-                               with_context "check_branches" ctx
-                                 (fun uu___5 ->
-                                    check_branches
-                                      FStar_Syntax_Util.exp_true_bool
-                                      branch_typ_opt branches) in
-                             op_let_Bang uu___4
-                               (fun uu___5 ->
-                                  match uu___5 with
-                                  | (eff_br, t_br) ->
-                                      return ((join_eff eff_sc eff_br), t_br)))))
-      | FStar_Syntax_Syntax.Tm_match
-          (sc, FStar_Pervasives_Native.Some
-           (as_x,
-            (FStar_Pervasives.Inl returns_ty, FStar_Pervasives_Native.None,
-             eq)),
-           branches, rc_opt)
-          ->
-          let uu___ = check "scrutinee" g sc in
-          op_let_Bang uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (eff_sc, t_sc) ->
-                   let uu___2 =
-                     with_context "universe_of"
-                       (FStar_Pervasives_Native.Some (CtxTerm t_sc))
-                       (fun uu___3 -> universe_of g t_sc) in
-                   op_let_Bang uu___2
-                     (fun u_sc ->
-                        let as_x1 =
-                          {
-                            FStar_Syntax_Syntax.binder_bv =
-                              (let uu___3 =
-                                 as_x.FStar_Syntax_Syntax.binder_bv in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (uu___3.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (uu___3.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = t_sc
-                               });
-                            FStar_Syntax_Syntax.binder_qual =
-                              (as_x.FStar_Syntax_Syntax.binder_qual);
-                            FStar_Syntax_Syntax.binder_attrs =
-                              (as_x.FStar_Syntax_Syntax.binder_attrs)
-                          } in
-                        let uu___3 = open_term g as_x1 returns_ty in
-                        match uu___3 with
-                        | (g_as_x, as_x2, returns_ty1) ->
-                            let uu___4 =
-                              check "return type" g_as_x returns_ty1 in
-                            op_let_Bang uu___4
-                              (fun uu___5 ->
-                                 match uu___5 with
-                                 | (_eff_t, returns_ty_t) ->
-                                     let uu___6 = is_type g_as_x returns_ty_t in
-                                     op_let_Bang uu___6
-                                       (fun _u_ty ->
-                                          let rec check_branches
-                                            path_condition branches1 acc_eff
-                                            =
-                                            match branches1 with
-                                            | [] ->
-                                                let uu___7 =
-                                                  boolean_negation_simp
-                                                    path_condition in
-                                                (match uu___7 with
-                                                 | FStar_Pervasives_Native.None
-                                                     -> return acc_eff
-                                                 | FStar_Pervasives_Native.Some
-                                                     g1 ->
-                                                     let uu___8 =
-                                                       let uu___9 =
-                                                         FStar_Syntax_Util.b2t
-                                                           g1 in
-                                                       guard uu___9 in
-                                                     op_let_Bang uu___8
-                                                       (fun uu___9 ->
-                                                          return acc_eff))
-                                            | (p,
-                                               FStar_Pervasives_Native.None,
-                                               b)::rest ->
-                                                let uu___7 =
-                                                  open_branch g
-                                                    (p,
-                                                      FStar_Pervasives_Native.None,
-                                                      b) in
-                                                (match uu___7 with
-                                                 | (uu___8, (p1, uu___9, b1))
-                                                     ->
-                                                     let uu___10 =
-                                                       with_context
-                                                         "check_pat"
-                                                         FStar_Pervasives_Native.None
-                                                         (fun uu___11 ->
-                                                            check_pat g p1
-                                                              t_sc) in
-                                                     op_let_Bang uu___10
-                                                       (fun uu___11 ->
-                                                          match uu___11 with
-                                                          | (bs, us) ->
-                                                              let uu___12 =
-                                                                pattern_branch_condition
-                                                                  g sc p1 in
-                                                              op_let_Bang
-                                                                uu___12
-                                                                (fun
-                                                                   branch_condition
-                                                                   ->
-                                                                   let pat_sc_eq
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_TypeChecker_PatternUtils.raw_pat_as_exp
-                                                                    g.tcenv
-                                                                    p1 in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___15
-                                                                    FStar_Compiler_Util.must in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___14
-                                                                    FStar_Pervasives_Native.fst in
-                                                                    FStar_Syntax_Util.mk_eq2
-                                                                    u_sc t_sc
-                                                                    sc
-                                                                    uu___13 in
-                                                                   let uu___13
-                                                                    =
-                                                                    combine_path_and_branch_condition
-                                                                    path_condition
-                                                                    branch_condition
-                                                                    pat_sc_eq in
-                                                                   match uu___13
-                                                                   with
-                                                                   | 
-                                                                   (this_path_condition,
-                                                                    next_path_condition)
-                                                                    ->
-                                                                    let g' =
-                                                                    push_binders
-                                                                    g bs in
-                                                                    let g'1 =
-                                                                    push_hypothesis
-                                                                    g'
-                                                                    this_path_condition in
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    check
-                                                                    "branch"
-                                                                    g'1 b1 in
-                                                                    op_let_Bang
-                                                                    uu___17
-                                                                    (fun
-                                                                    uu___18
-                                                                    ->
-                                                                    match uu___18
-                                                                    with
-                                                                    | 
-                                                                    (eff_br,
-                                                                    tbr) ->
-                                                                    let expect_tbr
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    [
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    ((as_x2.FStar_Syntax_Syntax.binder_bv),
-                                                                    e1)]
-                                                                    returns_ty1 in
-                                                                    let rel =
-                                                                    if eq
-                                                                    then
-                                                                    EQUALITY
-                                                                    else
-                                                                    SUBTYPING
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    b1) in
-                                                                    let uu___19
-                                                                    =
-                                                                    check_relation
-                                                                    g'1 rel
-                                                                    tbr
-                                                                    expect_tbr in
-                                                                    op_let_Bang
-                                                                    uu___19
-                                                                    (fun
-                                                                    uu___20
-                                                                    ->
-                                                                    return
-                                                                    ((join_eff
-                                                                    eff_br
-                                                                    acc_eff),
-                                                                    expect_tbr))) in
-                                                                    weaken
-                                                                    this_path_condition
-                                                                    uu___16 in
-                                                                    with_binders
-                                                                    bs us
-                                                                    uu___15 in
-                                                                    op_let_Bang
-                                                                    uu___14
-                                                                    (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    match uu___15
-                                                                    with
-                                                                    | 
-                                                                    (eff_br,
-                                                                    tbr) ->
-                                                                    (match 
-                                                                    p1.FStar_Syntax_Syntax.v
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Pat_var
-                                                                    uu___16
-                                                                    ->
-                                                                    (match rest
-                                                                    with
-                                                                    | 
-                                                                    uu___17::uu___18
-                                                                    ->
-                                                                    fail
-                                                                    "Redundant branches after wildcard"
-                                                                    | 
-                                                                    uu___17
-                                                                    ->
-                                                                    return
-                                                                    eff_br)
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Pat_wild
-                                                                    uu___16
-                                                                    ->
-                                                                    (match rest
-                                                                    with
-                                                                    | 
-                                                                    uu___17::uu___18
-                                                                    ->
-                                                                    fail
-                                                                    "Redundant branches after wildcard"
-                                                                    | 
-                                                                    uu___17
-                                                                    ->
-                                                                    return
-                                                                    eff_br)
-                                                                    | 
-                                                                    uu___16
-                                                                    ->
-                                                                    check_branches
-                                                                    next_path_condition
-                                                                    rest
-                                                                    eff_br))))) in
-                                          let uu___7 =
-                                            check_branches
-                                              FStar_Syntax_Util.exp_true_bool
-                                              branches E_TOTAL in
-                                          op_let_Bang uu___7
-                                            (fun eff ->
-                                               let ty =
-                                                 FStar_Syntax_Subst.subst
-                                                   [FStar_Syntax_Syntax.NT
-                                                      ((as_x2.FStar_Syntax_Syntax.binder_bv),
-                                                        sc)] returns_ty1 in
-                                               return (eff, ty))))))
-      | FStar_Syntax_Syntax.Tm_match uu___ ->
-          fail "Match with effect returns ascription, or tactic handler"
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.tag_of_term e1 in
-            FStar_Compiler_Util.format1 "Unexpected term: %s" uu___2 in
-          fail uu___1
-and (check_binders :
-  env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.universe Prims.list result)
-  =
-  fun g_initial ->
-    fun xs ->
-      let rec aux g xs1 =
-        match xs1 with
-        | [] -> return []
-        | x::xs2 ->
-            let uu___ =
-              check "binder sort" g
-                (x.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-            op_let_Bang uu___
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (uu___2, t) ->
-                     let uu___3 = is_type g t in
-                     op_let_Bang uu___3
-                       (fun u ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = push_binder g x in aux uu___6 xs2 in
-                            op_let_Bang uu___5 (fun us -> return (u :: us)) in
-                          with_binders [x] [u] uu___4)) in
-      aux g_initial xs
-and (check_comp :
-  env -> FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.universe result) =
-  fun g ->
-    fun c ->
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Total t ->
-          let uu___ =
-            check "(G)Tot comp result" g (FStar_Syntax_Util.comp_result c) in
-          op_let_Bang uu___
-            (fun uu___1 -> match uu___1 with | (uu___2, t1) -> is_type g t1)
-      | FStar_Syntax_Syntax.GTotal t ->
-          let uu___ =
-            check "(G)Tot comp result" g (FStar_Syntax_Util.comp_result c) in
-          op_let_Bang uu___
-            (fun uu___1 -> match uu___1 with | (uu___2, t1) -> is_type g t1)
-      | FStar_Syntax_Syntax.Comp ct ->
-          if
-            (FStar_Compiler_List.length ct.FStar_Syntax_Syntax.comp_univs) <>
-              Prims.int_one
-          then fail "Unexpected/missing universe instantitation in comp"
-          else
-            (let u = FStar_Compiler_List.hd ct.FStar_Syntax_Syntax.comp_univs in
-             let effect_app_tm =
-               let head =
-                 let uu___1 =
-                   FStar_Syntax_Syntax.fvar
-                     ct.FStar_Syntax_Syntax.effect_name
-                     FStar_Syntax_Syntax.delta_constant
-                     FStar_Pervasives_Native.None in
-                 FStar_Syntax_Syntax.mk_Tm_uinst uu___1 [u] in
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Syntax.as_arg
-                     ct.FStar_Syntax_Syntax.result_typ in
-                 uu___2 :: (ct.FStar_Syntax_Syntax.effect_args) in
-               FStar_Syntax_Syntax.mk_Tm_app head uu___1
-                 (ct.FStar_Syntax_Syntax.result_typ).FStar_Syntax_Syntax.pos in
-             let uu___1 = check "effectful comp" g effect_app_tm in
-             op_let_Bang uu___1
-               (fun uu___2 ->
-                  match uu___2 with
-                  | (uu___3, t) ->
-                      let uu___4 =
-                        with_context "comp fully applied"
-                          FStar_Pervasives_Native.None
-                          (fun uu___5 ->
-                             check_subtype g FStar_Pervasives_Native.None t
-                               FStar_Syntax_Syntax.teff) in
-                      op_let_Bang uu___4
-                        (fun uu___5 ->
-                           let c_lid =
-                             FStar_TypeChecker_Env.norm_eff_name g.tcenv
-                               ct.FStar_Syntax_Syntax.effect_name in
-                           let is_total =
-                             let uu___6 =
-                               FStar_TypeChecker_Env.lookup_effect_quals
-                                 g.tcenv c_lid in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___6
-                               (FStar_Compiler_List.existsb
-                                  (fun q ->
-                                     q = FStar_Syntax_Syntax.TotalEffect)) in
-                           if Prims.op_Negation is_total
-                           then return FStar_Syntax_Syntax.U_zero
-                           else
-                             (let uu___7 =
-                                FStar_Syntax_Util.is_pure_or_ghost_effect
-                                  c_lid in
-                              if uu___7
-                              then return u
-                              else
-                                (let uu___9 =
-                                   FStar_TypeChecker_Env.effect_repr 
-                                     g.tcenv c u in
-                                 match uu___9 with
-                                 | FStar_Pervasives_Native.None ->
-                                     let uu___10 =
-                                       let uu___11 =
-                                         FStar_Ident.string_of_lid
-                                           (FStar_Syntax_Util.comp_effect_name
-                                              c) in
-                                       let uu___12 =
-                                         FStar_Ident.string_of_lid c_lid in
-                                       FStar_Compiler_Util.format2
-                                         "Total effect %s (normalized to %s) does not have a representation"
-                                         uu___11 uu___12 in
-                                     fail uu___10
-                                 | FStar_Pervasives_Native.Some tm ->
-                                     universe_of g tm)))))
-and (universe_of :
-  env -> FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.universe result) =
-  fun g ->
-    fun t ->
-      let uu___ = check "universe of" g t in
-      op_let_Bang uu___
-        (fun uu___1 -> match uu___1 with | (uu___2, t1) -> is_type g t1)
-and (check_pat :
-  env ->
-    FStar_Syntax_Syntax.pat ->
-      FStar_Syntax_Syntax.typ ->
-        (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.universes) result)
-  =
-  fun g ->
-    fun p ->
-      fun t_sc ->
-        let unrefine_tsc t_sc1 =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater t_sc1
-              (FStar_TypeChecker_Normalize.normalize_refinement
-                 FStar_TypeChecker_Normalize.whnf_steps g.tcenv) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Syntax_Util.unrefine in
-        match p.FStar_Syntax_Syntax.v with
-        | FStar_Syntax_Syntax.Pat_constant c ->
-            let e =
-              match c with
-              | FStar_Const.Const_int (repr, FStar_Pervasives_Native.Some sw)
-                  ->
-                  FStar_ToSyntax_ToSyntax.desugar_machine_integer
-                    (g.tcenv).FStar_TypeChecker_Env.dsenv repr sw
-                    p.FStar_Syntax_Syntax.p
-              | uu___ ->
-                  FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_constant c)
-                    p.FStar_Syntax_Syntax.p in
-            let uu___ = check "pat_const" g e in
-            op_let_Bang uu___
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (uu___2, t_const) ->
-                     let uu___3 =
-                       let uu___4 = unrefine_tsc t_sc in
-                       check_subtype g (FStar_Pervasives_Native.Some e)
-                         t_const uu___4 in
-                     op_let_Bang uu___3 (fun uu___4 -> return ([], [])))
-        | FStar_Syntax_Syntax.Pat_var bv ->
-            let b =
-              FStar_Syntax_Syntax.mk_binder
-                {
-                  FStar_Syntax_Syntax.ppname =
-                    (bv.FStar_Syntax_Syntax.ppname);
-                  FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-                  FStar_Syntax_Syntax.sort = t_sc
-                } in
-            let uu___ =
-              with_context "check_pat_binder" FStar_Pervasives_Native.None
-                (fun uu___1 -> check_binders g [b]) in
-            op_let_Bang uu___
-              (fun uu___1 -> match uu___1 with | u::[] -> return ([b], [u]))
-        | FStar_Syntax_Syntax.Pat_wild bv ->
-            let b =
-              FStar_Syntax_Syntax.mk_binder
-                {
-                  FStar_Syntax_Syntax.ppname =
-                    (bv.FStar_Syntax_Syntax.ppname);
-                  FStar_Syntax_Syntax.index = (bv.FStar_Syntax_Syntax.index);
-                  FStar_Syntax_Syntax.sort = t_sc
-                } in
-            let uu___ =
-              with_context "check_pat_binder" FStar_Pervasives_Native.None
-                (fun uu___1 -> check_binders g [b]) in
-            op_let_Bang uu___
-              (fun uu___1 -> match uu___1 with | u::[] -> return ([b], [u]))
-        | FStar_Syntax_Syntax.Pat_cons (fv, usopt, pats) ->
-            let us =
-              if FStar_Compiler_Util.is_none usopt
-              then []
-              else
-                FStar_Compiler_Effect.op_Bar_Greater usopt
-                  FStar_Compiler_Util.must in
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Syntax.lid_of_fv fv in
-                FStar_TypeChecker_Env.lookup_and_inst_datacon g.tcenv us
-                  uu___2 in
-              FStar_Compiler_Effect.op_Bar_Greater uu___1
-                FStar_Syntax_Util.arrow_formals in
-            (match uu___ with
-             | (formals, t_pat) ->
-                 let uu___1 =
-                   let pats1 =
-                     FStar_Compiler_Effect.op_Bar_Greater pats
-                       (FStar_Compiler_List.map FStar_Pervasives_Native.fst) in
-                   let uu___2 =
-                     let uu___3 =
-                       FStar_Compiler_Effect.op_Bar_Greater pats1
-                         (FStar_Compiler_Util.prefix_until
-                            (fun p1 ->
-                               match p1.FStar_Syntax_Syntax.v with
-                               | FStar_Syntax_Syntax.Pat_dot_term uu___4 ->
-                                   false
-                               | uu___4 -> true)) in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___3
-                       (FStar_Compiler_Util.map_option
-                          (fun uu___4 ->
-                             match uu___4 with
-                             | (dot_pats, pat, rest_pats) ->
-                                 (dot_pats, (pat :: rest_pats)))) in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___2
-                     (FStar_Compiler_Util.dflt (pats1, [])) in
-                 (match uu___1 with
-                  | (dot_pats, rest_pats) ->
-                      let uu___2 =
-                        FStar_Compiler_List.splitAt
-                          (FStar_Compiler_List.length dot_pats) formals in
-                      (match uu___2 with
-                       | (dot_formals, rest_formals) ->
-                           let uu___3 =
-                             fold2
-                               (fun ss ->
-                                  fun uu___4 ->
-                                    fun p1 ->
-                                      match uu___4 with
-                                      | { FStar_Syntax_Syntax.binder_bv = f;
-                                          FStar_Syntax_Syntax.binder_qual =
-                                            uu___5;
-                                          FStar_Syntax_Syntax.binder_attrs =
-                                            uu___6;_}
-                                          ->
-                                          let expected_t =
-                                            FStar_Syntax_Subst.subst ss
-                                              f.FStar_Syntax_Syntax.sort in
-                                          let uu___7 =
-                                            match p1.FStar_Syntax_Syntax.v
-                                            with
-                                            | FStar_Syntax_Syntax.Pat_dot_term
-                                                (FStar_Pervasives_Native.Some
-                                                t) -> return t
-                                            | uu___8 ->
-                                                fail
-                                                  "check_pat in core has unset dot pattern" in
-                                          op_let_Bang uu___7
-                                            (fun pat_dot_t ->
-                                               let uu___8 =
-                                                 check "pat dot term" g
-                                                   pat_dot_t in
-                                               op_let_Bang uu___8
-                                                 (fun uu___9 ->
-                                                    match uu___9 with
-                                                    | (uu___10, p_t) ->
-                                                        op_let_Bang
-                                                          (check_subtype g
-                                                             (FStar_Pervasives_Native.Some
-                                                                pat_dot_t)
-                                                             p_t expected_t)
-                                                          (fun uu___11 ->
-                                                             return
-                                                               (FStar_List_Tot_Base.op_At
-                                                                  ss
-                                                                  [FStar_Syntax_Syntax.NT
-                                                                    (f,
-                                                                    pat_dot_t)])))))
-                               [] dot_formals dot_pats in
-                           op_let_Bang uu___3
-                             (fun ss ->
-                                let uu___4 =
-                                  fold2
-                                    (fun uu___5 ->
-                                       fun uu___6 ->
-                                         fun p1 ->
-                                           match (uu___5, uu___6) with
-                                           | ((g1, ss1, bs, us1),
-                                              {
-                                                FStar_Syntax_Syntax.binder_bv
-                                                  = f;
-                                                FStar_Syntax_Syntax.binder_qual
-                                                  = uu___7;
-                                                FStar_Syntax_Syntax.binder_attrs
-                                                  = uu___8;_})
-                                               ->
-                                               let expected_t =
-                                                 FStar_Syntax_Subst.subst ss1
-                                                   f.FStar_Syntax_Syntax.sort in
-                                               let uu___9 =
-                                                 let uu___10 =
-                                                   check_pat g1 p1 expected_t in
-                                                 with_binders bs us1 uu___10 in
-                                               op_let_Bang uu___9
-                                                 (fun uu___10 ->
-                                                    match uu___10 with
-                                                    | (bs_p, us_p) ->
-                                                        let p_e =
-                                                          let uu___11 =
-                                                            let uu___12 =
-                                                              FStar_TypeChecker_PatternUtils.raw_pat_as_exp
-                                                                g1.tcenv p1 in
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              uu___12
-                                                              FStar_Compiler_Util.must in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___11
-                                                            FStar_Pervasives_Native.fst in
-                                                        let uu___11 =
-                                                          let uu___12 =
-                                                            push_binders g1
-                                                              bs_p in
-                                                          (uu___12,
-                                                            (FStar_List_Tot_Base.op_At
-                                                               ss1
-                                                               [FStar_Syntax_Syntax.NT
-                                                                  (f, p_e)]),
-                                                            (FStar_List_Tot_Base.op_At
-                                                               bs bs_p),
-                                                            (FStar_List_Tot_Base.op_At
-                                                               us1 us_p)) in
-                                                        return uu___11))
-                                    (g, ss, [], []) rest_formals rest_pats in
-                                op_let_Bang uu___4
-                                  (fun uu___5 ->
-                                     match uu___5 with
-                                     | (uu___6, ss1, bs, us1) ->
-                                         let t_pat1 =
-                                           FStar_Syntax_Subst.subst ss1 t_pat in
-                                         let uu___7 =
-                                           let uu___8 =
-                                             let uu___9 = unrefine_tsc t_sc in
-                                             check_scrutinee_pattern_type_compatible
-                                               g uu___9 t_pat1 in
-                                           no_guard uu___8 in
-                                         op_let_Bang uu___7
-                                           (fun uu___8 -> return (bs, us1)))))))
-        | uu___ -> fail "check_pat called with a dot pattern"
-and (check_scrutinee_pattern_type_compatible :
-  env ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> precondition result)
-  =
-  fun g ->
-    fun t_sc ->
-      fun t_pat ->
-        let err s =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Print.term_to_string t_sc in
-            let uu___2 = FStar_Syntax_Print.term_to_string t_pat in
-            FStar_Compiler_Util.format3
-              "Scrutinee type %s and Pattern type %s are not compatible because %s"
-              uu___1 uu___2 s in
-          fail uu___ in
-        let uu___ = FStar_Syntax_Util.head_and_args t_sc in
-        match uu___ with
-        | (head_sc, args_sc) ->
-            let uu___1 = FStar_Syntax_Util.head_and_args t_pat in
-            (match uu___1 with
-             | (head_pat, args_pat) ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_Syntax_Subst.compress head_sc in
-                       uu___5.FStar_Syntax_Syntax.n in
-                     let uu___5 =
-                       let uu___6 = FStar_Syntax_Subst.compress head_pat in
-                       uu___6.FStar_Syntax_Syntax.n in
-                     (uu___4, uu___5) in
-                   match uu___3 with
-                   | (FStar_Syntax_Syntax.Tm_fvar fv_head,
-                      FStar_Syntax_Syntax.Tm_fvar fv_pat) when
-                       let uu___4 = FStar_Syntax_Syntax.lid_of_fv fv_head in
-                       let uu___5 = FStar_Syntax_Syntax.lid_of_fv fv_pat in
-                       FStar_Ident.lid_equals uu___4 uu___5 -> return fv_head
-                   | (FStar_Syntax_Syntax.Tm_uinst
-                      ({
-                         FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                           fv_head;
-                         FStar_Syntax_Syntax.pos = uu___4;
-                         FStar_Syntax_Syntax.vars = uu___5;
-                         FStar_Syntax_Syntax.hash_code = uu___6;_},
-                       us_head),
-                      FStar_Syntax_Syntax.Tm_uinst
-                      ({
-                         FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                           fv_pat;
-                         FStar_Syntax_Syntax.pos = uu___7;
-                         FStar_Syntax_Syntax.vars = uu___8;
-                         FStar_Syntax_Syntax.hash_code = uu___9;_},
-                       us_pat)) when
-                       let uu___10 = FStar_Syntax_Syntax.lid_of_fv fv_head in
-                       let uu___11 = FStar_Syntax_Syntax.lid_of_fv fv_pat in
-                       FStar_Ident.lid_equals uu___10 uu___11 ->
-                       let uu___10 =
-                         FStar_TypeChecker_Rel.teq_nosmt_force g.tcenv
-                           head_sc head_pat in
-                       if uu___10
-                       then return fv_head
-                       else err "Incompatible universe instantiations"
-                   | (uu___4, uu___5) ->
-                       let uu___6 =
-                         let uu___7 = FStar_Syntax_Print.tag_of_term head_sc in
-                         let uu___8 = FStar_Syntax_Print.tag_of_term head_pat in
-                         FStar_Compiler_Util.format2
-                           "Head constructors(%s and %s) not fvar" uu___7
-                           uu___8 in
-                       err uu___6 in
-                 op_let_Bang uu___2
-                   (fun t_fv ->
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.lid_of_fv t_fv in
-                          FStar_TypeChecker_Env.is_type_constructor g.tcenv
-                            uu___5 in
-                        if uu___4
-                        then return t_fv
-                        else
-                          (let uu___6 =
-                             let uu___7 =
-                               FStar_Syntax_Print.fv_to_string t_fv in
-                             FStar_Compiler_Util.format1
-                               "%s is not a type constructor" uu___7 in
-                           err uu___6) in
-                      op_let_Bang uu___3
-                        (fun uu___4 ->
-                           let uu___5 =
-                             if
-                               (FStar_Compiler_List.length args_sc) =
-                                 (FStar_Compiler_List.length args_pat)
-                             then return t_fv
-                             else
-                               (let uu___7 =
-                                  let uu___8 =
-                                    FStar_Compiler_Util.string_of_int
-                                      (FStar_Compiler_List.length args_sc) in
-                                  let uu___9 =
-                                    FStar_Compiler_Util.string_of_int
-                                      (FStar_Compiler_List.length args_pat) in
-                                  FStar_Compiler_Util.format2
-                                    "Number of arguments don't match (%s and %s)"
-                                    uu___8 uu___9 in
-                                err uu___7) in
-                           op_let_Bang uu___5
-                             (fun uu___6 ->
-                                let uu___7 =
-                                  let uu___8 =
-                                    let uu___9 =
-                                      FStar_Syntax_Syntax.lid_of_fv t_fv in
-                                    FStar_TypeChecker_Env.num_inductive_ty_params
-                                      g.tcenv uu___9 in
-                                  match uu___8 with
-                                  | FStar_Pervasives_Native.None ->
-                                      (args_sc, args_pat)
-                                  | FStar_Pervasives_Native.Some n ->
-                                      let uu___9 =
-                                        let uu___10 =
-                                          FStar_Compiler_Util.first_N n
-                                            args_sc in
-                                        FStar_Pervasives_Native.fst uu___10 in
-                                      let uu___10 =
-                                        let uu___11 =
-                                          FStar_Compiler_Util.first_N n
-                                            args_pat in
-                                        FStar_Pervasives_Native.fst uu___11 in
-                                      (uu___9, uu___10) in
-                                match uu___7 with
-                                | (params_sc, params_pat) ->
-                                    let uu___8 =
-                                      iter2 params_sc params_pat
-                                        (fun uu___9 ->
-                                           fun uu___10 ->
-                                             fun uu___11 ->
-                                               match (uu___9, uu___10) with
-                                               | ((t_sc1, uu___12),
-                                                  (t_pat1, uu___13)) ->
-                                                   check_relation g EQUALITY
-                                                     t_sc1 t_pat1) () in
-                                    op_let_Bang uu___8
-                                      (fun uu___9 ->
-                                         return FStar_Pervasives_Native.None)))))
-and (pattern_branch_condition :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.pat ->
-        FStar_Syntax_Syntax.term FStar_Pervasives_Native.option result)
-  =
-  fun g ->
-    fun scrutinee ->
-      fun pat ->
-        match pat.FStar_Syntax_Syntax.v with
-        | FStar_Syntax_Syntax.Pat_var uu___ ->
-            return FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Pat_wild uu___ ->
-            return FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Pat_constant c ->
-            let const_exp =
-              let uu___ =
-                FStar_TypeChecker_PatternUtils.raw_pat_as_exp g.tcenv pat in
-              match uu___ with
-              | FStar_Pervasives_Native.None -> failwith "Impossible"
-              | FStar_Pervasives_Native.Some (e, uu___1) -> e in
-            let uu___ = check "constant pattern" g const_exp in
-            op_let_Bang uu___
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (uu___2, t_const) ->
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Syntax_Util.mk_decidable_eq t_const scrutinee
-                           const_exp in
-                       FStar_Pervasives_Native.Some uu___4 in
-                     return uu___3)
-        | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, sub_pats) ->
-            let wild_pat pos =
-              let uu___ =
-                let uu___1 =
-                  FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                    FStar_Syntax_Syntax.tun in
-                FStar_Syntax_Syntax.Pat_wild uu___1 in
-              FStar_Syntax_Syntax.withinfo uu___ pos in
-            let mk_head_discriminator uu___ =
-              let pat1 =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Compiler_List.map
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | (s, b) ->
-                               let uu___5 = wild_pat s.FStar_Syntax_Syntax.p in
-                               (uu___5, b)) sub_pats in
-                    (fv, us_opt, uu___3) in
-                  FStar_Syntax_Syntax.Pat_cons uu___2 in
-                FStar_Syntax_Syntax.withinfo uu___1 pat.FStar_Syntax_Syntax.p in
-              let branch1 =
-                (pat1, FStar_Pervasives_Native.None,
-                  FStar_Syntax_Util.exp_true_bool) in
-              let branch2 =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                        FStar_Syntax_Syntax.tun in
-                    FStar_Syntax_Syntax.Pat_wild uu___3 in
-                  FStar_Syntax_Syntax.withinfo uu___2
-                    pat1.FStar_Syntax_Syntax.p in
-                (uu___1, FStar_Pervasives_Native.None,
-                  FStar_Syntax_Util.exp_false_bool) in
-              FStar_Syntax_Syntax.mk
-                (FStar_Syntax_Syntax.Tm_match
-                   (scrutinee, FStar_Pervasives_Native.None,
-                     [branch1; branch2], FStar_Pervasives_Native.None))
-                scrutinee.FStar_Syntax_Syntax.pos in
-            let mk_ith_projector i =
-              let uu___ =
-                let bv =
-                  FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                    FStar_Syntax_Syntax.tun in
-                let uu___1 =
-                  FStar_Syntax_Syntax.withinfo
-                    (FStar_Syntax_Syntax.Pat_var bv)
-                    scrutinee.FStar_Syntax_Syntax.pos in
-                (bv, uu___1) in
-              match uu___ with
-              | (ith_pat_var, ith_pat) ->
-                  let sub_pats1 =
-                    FStar_Compiler_List.mapi
-                      (fun j ->
-                         fun uu___1 ->
-                           match uu___1 with
-                           | (s, b) ->
-                               if i <> j
-                               then
-                                 let uu___2 =
-                                   wild_pat s.FStar_Syntax_Syntax.p in
-                                 (uu___2, b)
-                               else (ith_pat, b)) sub_pats in
-                  let pat1 =
-                    FStar_Syntax_Syntax.withinfo
-                      (FStar_Syntax_Syntax.Pat_cons (fv, us_opt, sub_pats1))
-                      pat.FStar_Syntax_Syntax.p in
-                  let branch = FStar_Syntax_Syntax.bv_to_name ith_pat_var in
-                  let eqn =
-                    FStar_Syntax_Subst.close_branch
-                      (pat1, FStar_Pervasives_Native.None, branch) in
-                  FStar_Syntax_Syntax.mk
-                    (FStar_Syntax_Syntax.Tm_match
-                       (scrutinee, FStar_Pervasives_Native.None, [eqn],
-                         FStar_Pervasives_Native.None))
-                    scrutinee.FStar_Syntax_Syntax.pos in
-            let discrimination =
-              let uu___ =
-                let uu___1 =
-                  FStar_TypeChecker_Env.typ_of_datacon g.tcenv
-                    (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                FStar_TypeChecker_Env.datacons_of_typ g.tcenv uu___1 in
-              match uu___ with
-              | (is_induc, datacons) ->
-                  if
-                    (Prims.op_Negation is_induc) ||
-                      ((FStar_Compiler_List.length datacons) > Prims.int_one)
-                  then
-                    let discriminator =
-                      FStar_Syntax_Util.mk_discriminator
-                        (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                    let uu___1 =
-                      FStar_TypeChecker_Env.try_lookup_lid g.tcenv
-                        discriminator in
-                    (match uu___1 with
-                     | FStar_Pervasives_Native.None ->
-                         FStar_Pervasives_Native.None
-                     | uu___2 ->
-                         let uu___3 = mk_head_discriminator () in
-                         FStar_Pervasives_Native.Some uu___3)
-                  else FStar_Pervasives_Native.None in
-            let uu___ =
-              mapi
-                (fun i ->
-                   fun uu___1 ->
-                     match uu___1 with
-                     | (pi, uu___2) ->
-                         (match pi.FStar_Syntax_Syntax.v with
-                          | FStar_Syntax_Syntax.Pat_dot_term uu___3 ->
-                              return FStar_Pervasives_Native.None
-                          | FStar_Syntax_Syntax.Pat_var uu___3 ->
-                              return FStar_Pervasives_Native.None
-                          | FStar_Syntax_Syntax.Pat_wild uu___3 ->
-                              return FStar_Pervasives_Native.None
-                          | uu___3 ->
-                              let scrutinee_sub_term = mk_ith_projector i in
-                              let uu___4 = mk_ith_projector i in
-                              pattern_branch_condition g uu___4 pi)) sub_pats in
-            op_let_Bang uu___
-              (fun sub_term_guards ->
-                 let guards =
-                   FStar_Compiler_List.collect
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | FStar_Pervasives_Native.None -> []
-                        | FStar_Pervasives_Native.Some t -> [t])
-                     (discrimination :: sub_term_guards) in
-                 match guards with
-                 | [] -> return FStar_Pervasives_Native.None
-                 | guards1 ->
-                     let uu___1 =
-                       let uu___2 = FStar_Syntax_Util.mk_and_l guards1 in
-                       FStar_Pervasives_Native.Some uu___2 in
-                     return uu___1)
-let (initial_env :
-  FStar_TypeChecker_Env.env ->
-    guard_handler_t FStar_Pervasives_Native.option -> env)
-  =
-  fun g ->
-    fun gh ->
-      let max_index =
-        FStar_Compiler_List.fold_left
-          (fun index ->
-             fun b ->
-               match b with
-               | FStar_Syntax_Syntax.Binding_var x ->
-                   if x.FStar_Syntax_Syntax.index > index
-                   then x.FStar_Syntax_Syntax.index
-                   else index
-               | uu___ -> index) Prims.int_zero g.FStar_TypeChecker_Env.gamma in
-      {
-        tcenv = g;
-        allow_universe_instantiation = false;
-        max_binder_index = max_index;
-        guard_handler = gh;
-        should_read_cache = true
-      }
-let (check_term_top :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option ->
-        Prims.bool ->
-          guard_handler_t FStar_Pervasives_Native.option ->
-            (effect_label * FStar_Syntax_Syntax.typ)
-              FStar_Pervasives_Native.option result)
-  =
-  fun g ->
-    fun e ->
-      fun topt ->
-        fun must_tot ->
-          fun gh ->
-            let g1 = initial_env g gh in
-            let uu___ = check "top" g1 e in
-            op_let_Bang uu___
-              (fun eff_te ->
-                 match topt with
-                 | FStar_Pervasives_Native.None ->
-                     return (FStar_Pervasives_Native.Some eff_te)
-                 | FStar_Pervasives_Native.Some t ->
-                     let target_comp =
-                       if
-                         must_tot ||
-                           ((FStar_Pervasives_Native.fst eff_te) = E_TOTAL)
-                       then FStar_Syntax_Syntax.mk_Total t
-                       else FStar_Syntax_Syntax.mk_GTotal t in
-                     let uu___1 =
-                       with_context "top-level subtyping"
-                         FStar_Pervasives_Native.None
-                         (fun uu___2 ->
-                            let uu___3 = as_comp g1 eff_te in
-                            check_relation_comp
-                              {
-                                tcenv = (g1.tcenv);
-                                allow_universe_instantiation = true;
-                                max_binder_index = (g1.max_binder_index);
-                                guard_handler = (g1.guard_handler);
-                                should_read_cache = (g1.should_read_cache)
-                              } (SUBTYPING (FStar_Pervasives_Native.Some e))
-                              uu___3 target_comp) in
-                     op_let_Bang uu___1
-                       (fun uu___2 -> return FStar_Pervasives_Native.None))
-let (simplify_steps : FStar_TypeChecker_Env.step Prims.list) =
-  [FStar_TypeChecker_Env.Beta;
-  FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-  FStar_TypeChecker_Env.UnfoldQual ["unfold"];
-  FStar_TypeChecker_Env.UnfoldOnly
-    [FStar_Parser_Const.pure_wp_monotonic_lid;
-    FStar_Parser_Const.pure_wp_monotonic0_lid];
-  FStar_TypeChecker_Env.Simplify;
-  FStar_TypeChecker_Env.Primops;
-  FStar_TypeChecker_Env.NoFullNorm]
-let (check_term_top_gh :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option ->
-        Prims.bool ->
-          guard_handler_t FStar_Pervasives_Native.option ->
-            (((effect_label * FStar_Syntax_Syntax.typ)
-               FStar_Pervasives_Native.option * precondition),
-              error) FStar_Pervasives.either)
-  =
-  fun g ->
-    fun e ->
-      fun topt ->
-        fun must_tot ->
-          fun gh ->
-            (let uu___1 =
-               FStar_TypeChecker_Env.debug g (FStar_Options.Other "CoreEq") in
-             if uu___1
-             then
-               let uu___2 =
-                 let uu___3 = get_goal_ctr () in
-                 FStar_Compiler_Util.string_of_int uu___3 in
-               FStar_Compiler_Util.print1 "(%s) Entering core ... \n" uu___2
-             else ());
-            (let uu___2 =
-               (FStar_TypeChecker_Env.debug g (FStar_Options.Other "Core"))
-                 ||
-                 (FStar_TypeChecker_Env.debug g
-                    (FStar_Options.Other "CoreTop")) in
-             if uu___2
-             then
-               let uu___3 =
-                 let uu___4 = get_goal_ctr () in
-                 FStar_Compiler_Util.string_of_int uu___4 in
-               let uu___4 = FStar_Syntax_Print.term_to_string e in
-               let uu___5 =
-                 match topt with
-                 | FStar_Pervasives_Native.None -> ""
-                 | FStar_Pervasives_Native.Some t ->
-                     FStar_Syntax_Print.term_to_string t in
-               FStar_Compiler_Util.print3
-                 "(%s) Entering core with %s <: %s\n" uu___3 uu___4 uu___5
-             else ());
-            FStar_Syntax_TermHashTable.reset_counters table;
-            reset_cache_stats ();
-            (let ctx =
-               {
-                 no_guard = false;
-                 error_context = [("Top", FStar_Pervasives_Native.None)]
-               } in
-             let res =
-               FStar_Profiling.profile
-                 (fun uu___4 ->
-                    let uu___5 =
-                      let uu___6 = check_term_top g e topt must_tot gh in
-                      uu___6 ctx in
-                    match uu___5 with
-                    | FStar_Pervasives.Inl (et, g1) ->
-                        FStar_Pervasives.Inl (et, g1)
-                    | FStar_Pervasives.Inr err -> FStar_Pervasives.Inr err)
-                 FStar_Pervasives_Native.None
-                 "FStar.TypeChecker.Core.check_term_top" in
-             let res1 =
-               match res with
-               | FStar_Pervasives.Inl
-                   (et, FStar_Pervasives_Native.Some guard0) ->
-                   let guard1 =
-                     FStar_TypeChecker_Normalize.normalize simplify_steps g
-                       guard0 in
-                   ((let uu___5 =
-                       ((FStar_TypeChecker_Env.debug g
-                           (FStar_Options.Other "CoreExit"))
-                          ||
-                          (FStar_TypeChecker_Env.debug g
-                             (FStar_Options.Other "Core")))
-                         ||
-                         (FStar_TypeChecker_Env.debug g
-                            (FStar_Options.Other "CoreTop")) in
-                     if uu___5
-                     then
-                       ((let uu___7 =
-                           let uu___8 = get_goal_ctr () in
-                           FStar_Compiler_Util.string_of_int uu___8 in
-                         let uu___8 =
-                           FStar_Syntax_Print.term_to_string guard0 in
-                         let uu___9 =
-                           FStar_Syntax_Print.term_to_string guard1 in
-                         FStar_Compiler_Util.print3
-                           "(%s) Exiting core: Simplified guard from {{%s}} to {{%s}}\n"
-                           uu___7 uu___8 uu___9);
-                        (let guard_names =
-                           let uu___7 = FStar_Syntax_Free.names guard1 in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___7
-                             FStar_Compiler_Util.set_elements in
-                         let uu___7 =
-                           FStar_Compiler_List.tryFind
-                             (fun bv ->
-                                FStar_Compiler_List.for_all
-                                  (fun binding_env ->
-                                     match binding_env with
-                                     | FStar_Syntax_Syntax.Binding_var bv_env
-                                         ->
-                                         let uu___8 =
-                                           FStar_Syntax_Syntax.bv_eq bv_env
-                                             bv in
-                                         Prims.op_Negation uu___8
-                                     | uu___8 -> true)
-                                  g.FStar_TypeChecker_Env.gamma) guard_names in
-                         match uu___7 with
-                         | FStar_Pervasives_Native.Some bv ->
-                             let uu___8 =
-                               let uu___9 = FStar_Syntax_Syntax.bv_to_name bv in
-                               FStar_Syntax_Print.term_to_string uu___9 in
-                             FStar_Compiler_Util.print1
-                               "WARNING: %s is free in the core generated guard\n"
-                               uu___8
-                         | uu___8 -> ()))
-                     else ());
-                    FStar_Pervasives.Inl
-                      (et, (FStar_Pervasives_Native.Some guard1)))
-               | FStar_Pervasives.Inl uu___4 ->
-                   ((let uu___6 =
-                       (FStar_TypeChecker_Env.debug g
-                          (FStar_Options.Other "Core"))
-                         ||
-                         (FStar_TypeChecker_Env.debug g
-                            (FStar_Options.Other "CoreTop")) in
-                     if uu___6
-                     then
-                       let uu___7 =
-                         let uu___8 = get_goal_ctr () in
-                         FStar_Compiler_Util.string_of_int uu___8 in
-                       FStar_Compiler_Util.print1 "(%s) Exiting core (ok)\n"
-                         uu___7
-                     else ());
-                    res)
-               | FStar_Pervasives.Inr uu___4 ->
-                   ((let uu___6 =
-                       (FStar_TypeChecker_Env.debug g
-                          (FStar_Options.Other "Core"))
-                         ||
-                         (FStar_TypeChecker_Env.debug g
-                            (FStar_Options.Other "CoreTop")) in
-                     if uu___6
-                     then
-                       let uu___7 =
-                         let uu___8 = get_goal_ctr () in
-                         FStar_Compiler_Util.string_of_int uu___8 in
-                       FStar_Compiler_Util.print1
-                         "(%s) Exiting core (failed)\n" uu___7
-                     else ());
-                    res) in
-             (let uu___5 =
-                FStar_TypeChecker_Env.debug g (FStar_Options.Other "CoreEq") in
-              if uu___5
-              then
-                (FStar_Syntax_TermHashTable.print_stats table;
-                 (let cs = report_cache_stats () in
-                  let uu___7 = FStar_Compiler_Util.string_of_int cs.hits in
-                  let uu___8 = FStar_Compiler_Util.string_of_int cs.misses in
-                  FStar_Compiler_Util.print2
-                    "Cache_stats { hits = %s; misses = %s }\n" uu___7 uu___8))
-              else ());
-             res1)
-let (check_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        Prims.bool ->
-          (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option, error)
-            FStar_Pervasives.either)
-  =
-  fun g ->
-    fun e ->
-      fun t ->
-        fun must_tot ->
-          let uu___ =
-            check_term_top_gh g e (FStar_Pervasives_Native.Some t) must_tot
-              FStar_Pervasives_Native.None in
-          match uu___ with
-          | FStar_Pervasives.Inl (uu___1, g1) -> FStar_Pervasives.Inl g1
-          | FStar_Pervasives.Inr err -> FStar_Pervasives.Inr err
-let (compute_term_type_handle_guards :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      Prims.bool ->
-        (FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.typ -> Prims.bool)
-          -> (FStar_Syntax_Syntax.typ, error) FStar_Pervasives.either)
-  =
-  fun g ->
-    fun e ->
-      fun must_tot ->
-        fun gh ->
-          let e1 = FStar_Syntax_Subst.deep_compress true e in
-          let uu___ =
-            check_term_top_gh g e1 FStar_Pervasives_Native.None must_tot
-              (FStar_Pervasives_Native.Some gh) in
-          match uu___ with
-          | FStar_Pervasives.Inl
-              (FStar_Pervasives_Native.Some (uu___1, t),
-               FStar_Pervasives_Native.None)
-              -> FStar_Pervasives.Inl t
-          | FStar_Pervasives.Inl (FStar_Pervasives_Native.None, uu___1) ->
-              failwith "Impossible: Success must return some effect and type"
-          | FStar_Pervasives.Inl
-              (uu___1, FStar_Pervasives_Native.Some uu___2) ->
-              failwith
-                "Impossible: All guards should have been handled already"
-          | FStar_Pervasives.Inr err -> FStar_Pervasives.Inr err
-let (open_binders_in_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.binders *
-          FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun bs ->
-      fun t ->
-        let g = initial_env env1 FStar_Pervasives_Native.None in
-        let uu___ = open_term_binders g bs t in
-        match uu___ with | (g', bs1, t1) -> ((g'.tcenv), bs1, t1)
-let (open_binders_in_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp ->
-        (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.binders *
-          FStar_Syntax_Syntax.comp))
-  =
-  fun env1 ->
-    fun bs ->
-      fun c ->
-        let g = initial_env env1 FStar_Pervasives_Native.None in
-        let uu___ = open_comp_binders g bs c in
-        match uu___ with | (g', bs1, c1) -> ((g'.tcenv), bs1, c1)
-let (check_term_equality :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option, error)
-          FStar_Pervasives.either)
-  =
-  fun g ->
-    fun t0 ->
-      fun t1 ->
-        let g1 = initial_env g FStar_Pervasives_Native.None in
-        let ctx =
-          {
-            no_guard = false;
-            error_context = [("Eq", FStar_Pervasives_Native.None)]
-          } in
-        let uu___ =
-          let uu___1 = check_relation g1 EQUALITY t0 t1 in uu___1 ctx in
-        match uu___ with
-        | FStar_Pervasives.Inl (uu___1, g2) -> FStar_Pervasives.Inl g2
-        | FStar_Pervasives.Inr err -> FStar_Pervasives.Inr err
-let (check_term_subtyping :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option, error)
-          FStar_Pervasives.either)
-  =
-  fun g ->
-    fun t0 ->
-      fun t1 ->
-        let g1 = initial_env g FStar_Pervasives_Native.None in
-        let ctx =
-          {
-            no_guard = false;
-            error_context = [("Subtyping", FStar_Pervasives_Native.None)]
-          } in
-        let uu___ =
-          let uu___1 =
-            check_relation g1 (SUBTYPING FStar_Pervasives_Native.None) t0 t1 in
-          uu___1 ctx in
-        match uu___ with
-        | FStar_Pervasives.Inl (uu___1, g2) -> FStar_Pervasives.Inl g2
-        | FStar_Pervasives.Inr err -> FStar_Pervasives.Inr err
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_DMFF.ml b/src/ocaml-output/FStar_TypeChecker_DMFF.ml
deleted file mode 100644
index e448bc530ef..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_DMFF.ml
+++ /dev/null
@@ -1,4740 +0,0 @@
-open Prims
-type env =
-  {
-  tcenv: FStar_TypeChecker_Env.env ;
-  subst: FStar_Syntax_Syntax.subst_elt Prims.list ;
-  tc_const: FStar_Const.sconst -> FStar_Syntax_Syntax.typ }
-let (__proj__Mkenv__item__tcenv : env -> FStar_TypeChecker_Env.env) =
-  fun projectee ->
-    match projectee with | { tcenv; subst; tc_const;_} -> tcenv
-let (__proj__Mkenv__item__subst :
-  env -> FStar_Syntax_Syntax.subst_elt Prims.list) =
-  fun projectee ->
-    match projectee with | { tcenv; subst; tc_const;_} -> subst
-let (__proj__Mkenv__item__tc_const :
-  env -> FStar_Const.sconst -> FStar_Syntax_Syntax.typ) =
-  fun projectee ->
-    match projectee with | { tcenv; subst; tc_const;_} -> tc_const
-let (empty :
-  FStar_TypeChecker_Env.env ->
-    (FStar_Const.sconst -> FStar_Syntax_Syntax.typ) -> env)
-  = fun env1 -> fun tc_const -> { tcenv = env1; subst = []; tc_const }
-let (gen_wps_for_free :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.bv ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.eff_decl ->
-            (FStar_Syntax_Syntax.sigelts * FStar_Syntax_Syntax.eff_decl))
-  =
-  fun env1 ->
-    fun binders ->
-      fun a ->
-        fun wp_a ->
-          fun ed ->
-            let wp_a1 =
-              FStar_TypeChecker_Normalize.normalize
-                [FStar_TypeChecker_Env.Beta;
-                FStar_TypeChecker_Env.EraseUniverses] env1 wp_a in
-            let a1 =
-              let uu___ =
-                FStar_TypeChecker_Normalize.normalize
-                  [FStar_TypeChecker_Env.EraseUniverses] env1
-                  a.FStar_Syntax_Syntax.sort in
-              {
-                FStar_Syntax_Syntax.ppname = (a.FStar_Syntax_Syntax.ppname);
-                FStar_Syntax_Syntax.index = (a.FStar_Syntax_Syntax.index);
-                FStar_Syntax_Syntax.sort = uu___
-              } in
-            let d s = FStar_Compiler_Util.print1 "\027[01;36m%s\027[00m\n" s in
-            (let uu___1 =
-               FStar_TypeChecker_Env.debug env1 (FStar_Options.Other "ED") in
-             if uu___1
-             then
-               (d "Elaborating extra WP combinators";
-                (let uu___3 = FStar_Syntax_Print.term_to_string wp_a1 in
-                 FStar_Compiler_Util.print1 "wp_a is: %s\n" uu___3))
-             else ());
-            (let rec collect_binders t =
-               let t1 = FStar_Syntax_Util.unascribe t in
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress t1 in
-                 uu___2.FStar_Syntax_Syntax.n in
-               match uu___1 with
-               | FStar_Syntax_Syntax.Tm_arrow (bs, comp) ->
-                   let rest =
-                     match comp.FStar_Syntax_Syntax.n with
-                     | FStar_Syntax_Syntax.Total t2 -> t2
-                     | uu___2 ->
-                         let uu___3 =
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_Syntax_Print.comp_to_string comp in
-                             FStar_Compiler_Util.format1
-                               "wp_a contains non-Tot arrow: %s" uu___5 in
-                           (FStar_Errors.Error_UnexpectedDM4FType, uu___4) in
-                         FStar_Errors.raise_error uu___3
-                           comp.FStar_Syntax_Syntax.pos in
-                   let uu___2 = collect_binders rest in
-                   FStar_Compiler_List.op_At bs uu___2
-               | FStar_Syntax_Syntax.Tm_type uu___2 -> []
-               | uu___2 ->
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                       FStar_Compiler_Util.format1
-                         "wp_a doesn't end in Type0, but rather in %s" uu___5 in
-                     (FStar_Errors.Error_UnexpectedDM4FType, uu___4) in
-                   FStar_Errors.raise_error uu___3 t1.FStar_Syntax_Syntax.pos in
-             let mk_lid name = FStar_Syntax_Util.dm4f_lid ed name in
-             let gamma =
-               let uu___1 = collect_binders wp_a1 in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 FStar_Syntax_Util.name_binders in
-             (let uu___2 =
-                FStar_TypeChecker_Env.debug env1 (FStar_Options.Other "ED") in
-              if uu___2
-              then
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Syntax_Print.binders_to_string ", " gamma in
-                  FStar_Compiler_Util.format1 "Gamma is %s\n" uu___4 in
-                d uu___3
-              else ());
-             (let unknown = FStar_Syntax_Syntax.tun in
-              let mk x =
-                FStar_Syntax_Syntax.mk x FStar_Compiler_Range.dummyRange in
-              let sigelts = FStar_Compiler_Util.mk_ref [] in
-              let register env2 lident def =
-                let uu___2 =
-                  FStar_TypeChecker_Util.mk_toplevel_definition env2 lident
-                    def in
-                match uu___2 with
-                | (sigelt, fv) ->
-                    let sigelt1 =
-                      {
-                        FStar_Syntax_Syntax.sigel =
-                          (sigelt.FStar_Syntax_Syntax.sigel);
-                        FStar_Syntax_Syntax.sigrng =
-                          (sigelt.FStar_Syntax_Syntax.sigrng);
-                        FStar_Syntax_Syntax.sigquals =
-                          (sigelt.FStar_Syntax_Syntax.sigquals);
-                        FStar_Syntax_Syntax.sigmeta =
-                          (let uu___3 = sigelt.FStar_Syntax_Syntax.sigmeta in
-                           {
-                             FStar_Syntax_Syntax.sigmeta_active =
-                               (uu___3.FStar_Syntax_Syntax.sigmeta_active);
-                             FStar_Syntax_Syntax.sigmeta_fact_db_ids =
-                               (uu___3.FStar_Syntax_Syntax.sigmeta_fact_db_ids);
-                             FStar_Syntax_Syntax.sigmeta_admit = true
-                           });
-                        FStar_Syntax_Syntax.sigattrs =
-                          (sigelt.FStar_Syntax_Syntax.sigattrs);
-                        FStar_Syntax_Syntax.sigopts =
-                          (sigelt.FStar_Syntax_Syntax.sigopts)
-                      } in
-                    ((let uu___4 =
-                        let uu___5 = FStar_Compiler_Effect.op_Bang sigelts in
-                        sigelt1 :: uu___5 in
-                      FStar_Compiler_Effect.op_Colon_Equals sigelts uu___4);
-                     fv) in
-              let binders_of_list =
-                FStar_Compiler_List.map
-                  (fun uu___2 ->
-                     match uu___2 with
-                     | (t, b) ->
-                         let uu___3 = FStar_Syntax_Syntax.as_bqual_implicit b in
-                         FStar_Syntax_Syntax.mk_binder_with_attrs t uu___3 []) in
-              let mk_all_implicit =
-                FStar_Compiler_List.map
-                  (fun t ->
-                     let uu___2 = FStar_Syntax_Syntax.as_bqual_implicit true in
-                     {
-                       FStar_Syntax_Syntax.binder_bv =
-                         (t.FStar_Syntax_Syntax.binder_bv);
-                       FStar_Syntax_Syntax.binder_qual = uu___2;
-                       FStar_Syntax_Syntax.binder_attrs =
-                         (t.FStar_Syntax_Syntax.binder_attrs)
-                     }) in
-              let args_of_binders =
-                FStar_Compiler_List.map
-                  (fun bv ->
-                     let uu___2 =
-                       FStar_Syntax_Syntax.bv_to_name
-                         bv.FStar_Syntax_Syntax.binder_bv in
-                     FStar_Syntax_Syntax.as_arg uu___2) in
-              let uu___2 =
-                let uu___3 =
-                  let mk1 f =
-                    let t =
-                      FStar_Syntax_Syntax.gen_bv "t"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let body =
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Syntax.bv_to_name t in
-                        f uu___5 in
-                      FStar_Syntax_Util.arrow gamma uu___4 in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = FStar_Syntax_Syntax.mk_binder a1 in
-                        let uu___7 =
-                          let uu___8 = FStar_Syntax_Syntax.mk_binder t in
-                          [uu___8] in
-                        uu___6 :: uu___7 in
-                      FStar_Compiler_List.op_At binders uu___5 in
-                    FStar_Syntax_Util.abs uu___4 body
-                      FStar_Pervasives_Native.None in
-                  let uu___4 = mk1 FStar_Syntax_Syntax.mk_Total in
-                  let uu___5 = mk1 FStar_Syntax_Syntax.mk_GTotal in
-                  (uu___4, uu___5) in
-                match uu___3 with
-                | (ctx_def, gctx_def) ->
-                    let ctx_lid = mk_lid "ctx" in
-                    let ctx_fv = register env1 ctx_lid ctx_def in
-                    let gctx_lid = mk_lid "gctx" in
-                    let gctx_fv = register env1 gctx_lid gctx_def in
-                    let mk_app fv t =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | { FStar_Syntax_Syntax.binder_bv = bv;
-                                       FStar_Syntax_Syntax.binder_qual =
-                                         uu___9;
-                                       FStar_Syntax_Syntax.binder_attrs =
-                                         uu___10;_}
-                                       ->
-                                       let uu___11 =
-                                         FStar_Syntax_Syntax.bv_to_name bv in
-                                       let uu___12 =
-                                         FStar_Syntax_Syntax.as_aqual_implicit
-                                           false in
-                                       (uu___11, uu___12)) binders in
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  FStar_Syntax_Syntax.bv_to_name a1 in
-                                let uu___11 =
-                                  FStar_Syntax_Syntax.as_aqual_implicit false in
-                                (uu___10, uu___11) in
-                              let uu___10 =
-                                let uu___11 =
-                                  let uu___12 =
-                                    FStar_Syntax_Syntax.as_aqual_implicit
-                                      false in
-                                  (t, uu___12) in
-                                [uu___11] in
-                              uu___9 :: uu___10 in
-                            FStar_Compiler_List.op_At uu___7 uu___8 in
-                          (fv, uu___6) in
-                        FStar_Syntax_Syntax.Tm_app uu___5 in
-                      mk uu___4 in
-                    (env1, (mk_app ctx_fv), (mk_app gctx_fv)) in
-              match uu___2 with
-              | (env2, mk_ctx, mk_gctx) ->
-                  let c_pure =
-                    let t =
-                      FStar_Syntax_Syntax.gen_bv "t"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let x =
-                      let uu___3 = FStar_Syntax_Syntax.bv_to_name t in
-                      FStar_Syntax_Syntax.gen_bv "x"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let ret =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t in
-                          mk_ctx uu___5 in
-                        FStar_Syntax_Util.residual_tot uu___4 in
-                      FStar_Pervasives_Native.Some uu___3 in
-                    let body =
-                      let uu___3 = FStar_Syntax_Syntax.bv_to_name x in
-                      FStar_Syntax_Util.abs gamma uu___3 ret in
-                    let uu___3 =
-                      let uu___4 = mk_all_implicit binders in
-                      let uu___5 =
-                        binders_of_list [(a1, true); (t, true); (x, false)] in
-                      FStar_Compiler_List.op_At uu___4 uu___5 in
-                    FStar_Syntax_Util.abs uu___3 body ret in
-                  let c_pure1 =
-                    let uu___3 = mk_lid "pure" in register env2 uu___3 c_pure in
-                  let c_app =
-                    let t1 =
-                      FStar_Syntax_Syntax.gen_bv "t1"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t2 =
-                      FStar_Syntax_Syntax.gen_bv "t2"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let l =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 =
-                                  FStar_Syntax_Syntax.bv_to_name t1 in
-                                FStar_Syntax_Syntax.new_bv
-                                  FStar_Pervasives_Native.None uu___8 in
-                              FStar_Syntax_Syntax.mk_binder uu___7 in
-                            [uu___6] in
-                          let uu___6 =
-                            let uu___7 = FStar_Syntax_Syntax.bv_to_name t2 in
-                            FStar_Syntax_Syntax.mk_GTotal uu___7 in
-                          FStar_Syntax_Util.arrow uu___5 uu___6 in
-                        mk_gctx uu___4 in
-                      FStar_Syntax_Syntax.gen_bv "l"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let r =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Syntax.bv_to_name t1 in
-                        mk_gctx uu___4 in
-                      FStar_Syntax_Syntax.gen_bv "r"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let ret =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t2 in
-                          mk_gctx uu___5 in
-                        FStar_Syntax_Util.residual_tot uu___4 in
-                      FStar_Pervasives_Native.Some uu___3 in
-                    let outer_body =
-                      let gamma_as_args = args_of_binders gamma in
-                      let inner_body =
-                        let uu___3 = FStar_Syntax_Syntax.bv_to_name l in
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 = FStar_Syntax_Syntax.bv_to_name r in
-                                FStar_Syntax_Util.mk_app uu___8 gamma_as_args in
-                              FStar_Syntax_Syntax.as_arg uu___7 in
-                            [uu___6] in
-                          FStar_Compiler_List.op_At gamma_as_args uu___5 in
-                        FStar_Syntax_Util.mk_app uu___3 uu___4 in
-                      FStar_Syntax_Util.abs gamma inner_body ret in
-                    let uu___3 =
-                      let uu___4 = mk_all_implicit binders in
-                      let uu___5 =
-                        binders_of_list
-                          [(a1, true);
-                          (t1, true);
-                          (t2, true);
-                          (l, false);
-                          (r, false)] in
-                      FStar_Compiler_List.op_At uu___4 uu___5 in
-                    FStar_Syntax_Util.abs uu___3 outer_body ret in
-                  let c_app1 =
-                    let uu___3 = mk_lid "app" in register env2 uu___3 c_app in
-                  let c_lift1 =
-                    let t1 =
-                      FStar_Syntax_Syntax.gen_bv "t1"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t2 =
-                      FStar_Syntax_Syntax.gen_bv "t2"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t_f =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t1 in
-                          FStar_Syntax_Syntax.null_binder uu___5 in
-                        [uu___4] in
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Syntax.bv_to_name t2 in
-                        FStar_Syntax_Syntax.mk_GTotal uu___5 in
-                      FStar_Syntax_Util.arrow uu___3 uu___4 in
-                    let f =
-                      FStar_Syntax_Syntax.gen_bv "f"
-                        FStar_Pervasives_Native.None t_f in
-                    let a11 =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Syntax.bv_to_name t1 in
-                        mk_gctx uu___4 in
-                      FStar_Syntax_Syntax.gen_bv "a1"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let ret =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t2 in
-                          mk_gctx uu___5 in
-                        FStar_Syntax_Util.residual_tot uu___4 in
-                      FStar_Pervasives_Native.Some uu___3 in
-                    let uu___3 =
-                      let uu___4 = mk_all_implicit binders in
-                      let uu___5 =
-                        binders_of_list
-                          [(a1, true);
-                          (t1, true);
-                          (t2, true);
-                          (f, false);
-                          (a11, false)] in
-                      FStar_Compiler_List.op_At uu___4 uu___5 in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  FStar_Syntax_Syntax.bv_to_name f in
-                                [uu___10] in
-                              FStar_Compiler_List.map
-                                FStar_Syntax_Syntax.as_arg uu___9 in
-                            FStar_Syntax_Util.mk_app c_pure1 uu___8 in
-                          let uu___8 =
-                            let uu___9 = FStar_Syntax_Syntax.bv_to_name a11 in
-                            [uu___9] in
-                          uu___7 :: uu___8 in
-                        FStar_Compiler_List.map FStar_Syntax_Syntax.as_arg
-                          uu___6 in
-                      FStar_Syntax_Util.mk_app c_app1 uu___5 in
-                    FStar_Syntax_Util.abs uu___3 uu___4 ret in
-                  let c_lift11 =
-                    let uu___3 = mk_lid "lift1" in
-                    register env2 uu___3 c_lift1 in
-                  let c_lift2 =
-                    let t1 =
-                      FStar_Syntax_Syntax.gen_bv "t1"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t2 =
-                      FStar_Syntax_Syntax.gen_bv "t2"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t3 =
-                      FStar_Syntax_Syntax.gen_bv "t3"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t_f =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t1 in
-                          FStar_Syntax_Syntax.null_binder uu___5 in
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 = FStar_Syntax_Syntax.bv_to_name t2 in
-                            FStar_Syntax_Syntax.null_binder uu___7 in
-                          [uu___6] in
-                        uu___4 :: uu___5 in
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Syntax.bv_to_name t3 in
-                        FStar_Syntax_Syntax.mk_GTotal uu___5 in
-                      FStar_Syntax_Util.arrow uu___3 uu___4 in
-                    let f =
-                      FStar_Syntax_Syntax.gen_bv "f"
-                        FStar_Pervasives_Native.None t_f in
-                    let a11 =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Syntax.bv_to_name t1 in
-                        mk_gctx uu___4 in
-                      FStar_Syntax_Syntax.gen_bv "a1"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let a2 =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Syntax.bv_to_name t2 in
-                        mk_gctx uu___4 in
-                      FStar_Syntax_Syntax.gen_bv "a2"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let ret =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t3 in
-                          mk_gctx uu___5 in
-                        FStar_Syntax_Util.residual_tot uu___4 in
-                      FStar_Pervasives_Native.Some uu___3 in
-                    let uu___3 =
-                      let uu___4 = mk_all_implicit binders in
-                      let uu___5 =
-                        binders_of_list
-                          [(a1, true);
-                          (t1, true);
-                          (t2, true);
-                          (t3, true);
-                          (f, false);
-                          (a11, false);
-                          (a2, false)] in
-                      FStar_Compiler_List.op_At uu___4 uu___5 in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    let uu___12 =
-                                      let uu___13 =
-                                        FStar_Syntax_Syntax.bv_to_name f in
-                                      [uu___13] in
-                                    FStar_Compiler_List.map
-                                      FStar_Syntax_Syntax.as_arg uu___12 in
-                                  FStar_Syntax_Util.mk_app c_pure1 uu___11 in
-                                let uu___11 =
-                                  let uu___12 =
-                                    FStar_Syntax_Syntax.bv_to_name a11 in
-                                  [uu___12] in
-                                uu___10 :: uu___11 in
-                              FStar_Compiler_List.map
-                                FStar_Syntax_Syntax.as_arg uu___9 in
-                            FStar_Syntax_Util.mk_app c_app1 uu___8 in
-                          let uu___8 =
-                            let uu___9 = FStar_Syntax_Syntax.bv_to_name a2 in
-                            [uu___9] in
-                          uu___7 :: uu___8 in
-                        FStar_Compiler_List.map FStar_Syntax_Syntax.as_arg
-                          uu___6 in
-                      FStar_Syntax_Util.mk_app c_app1 uu___5 in
-                    FStar_Syntax_Util.abs uu___3 uu___4 ret in
-                  let c_lift21 =
-                    let uu___3 = mk_lid "lift2" in
-                    register env2 uu___3 c_lift2 in
-                  let c_push =
-                    let t1 =
-                      FStar_Syntax_Syntax.gen_bv "t1"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t2 =
-                      FStar_Syntax_Syntax.gen_bv "t2"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t_f =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name t1 in
-                          FStar_Syntax_Syntax.null_binder uu___5 in
-                        [uu___4] in
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 = FStar_Syntax_Syntax.bv_to_name t2 in
-                          mk_gctx uu___6 in
-                        FStar_Syntax_Syntax.mk_Total uu___5 in
-                      FStar_Syntax_Util.arrow uu___3 uu___4 in
-                    let f =
-                      FStar_Syntax_Syntax.gen_bv "f"
-                        FStar_Pervasives_Native.None t_f in
-                    let ret =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 =
-                                  FStar_Syntax_Syntax.bv_to_name t1 in
-                                FStar_Syntax_Syntax.null_binder uu___8 in
-                              [uu___7] in
-                            let uu___7 =
-                              let uu___8 = FStar_Syntax_Syntax.bv_to_name t2 in
-                              FStar_Syntax_Syntax.mk_GTotal uu___8 in
-                            FStar_Syntax_Util.arrow uu___6 uu___7 in
-                          mk_ctx uu___5 in
-                        FStar_Syntax_Util.residual_tot uu___4 in
-                      FStar_Pervasives_Native.Some uu___3 in
-                    let e1 =
-                      let uu___3 = FStar_Syntax_Syntax.bv_to_name t1 in
-                      FStar_Syntax_Syntax.gen_bv "e1"
-                        FStar_Pervasives_Native.None uu___3 in
-                    let body =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.mk_binder e1 in
-                          [uu___5] in
-                        FStar_Compiler_List.op_At gamma uu___4 in
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Syntax.bv_to_name f in
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 = FStar_Syntax_Syntax.bv_to_name e1 in
-                            FStar_Syntax_Syntax.as_arg uu___8 in
-                          let uu___8 = args_of_binders gamma in uu___7 ::
-                            uu___8 in
-                        FStar_Syntax_Util.mk_app uu___5 uu___6 in
-                      FStar_Syntax_Util.abs uu___3 uu___4 ret in
-                    let uu___3 =
-                      let uu___4 = mk_all_implicit binders in
-                      let uu___5 =
-                        binders_of_list
-                          [(a1, true); (t1, true); (t2, true); (f, false)] in
-                      FStar_Compiler_List.op_At uu___4 uu___5 in
-                    FStar_Syntax_Util.abs uu___3 body ret in
-                  let c_push1 =
-                    let uu___3 = mk_lid "push" in register env2 uu___3 c_push in
-                  let ret_tot_wp_a =
-                    FStar_Pervasives_Native.Some
-                      (FStar_Syntax_Util.residual_tot wp_a1) in
-                  let mk_generic_app c =
-                    if (FStar_Compiler_List.length binders) > Prims.int_zero
-                    then
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = args_of_binders binders in (c, uu___5) in
-                        FStar_Syntax_Syntax.Tm_app uu___4 in
-                      mk uu___3
-                    else c in
-                  let wp_if_then_else =
-                    let result_comp =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.null_binder wp_a1 in
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Syntax_Syntax.null_binder wp_a1 in
-                            [uu___7] in
-                          uu___5 :: uu___6 in
-                        let uu___5 = FStar_Syntax_Syntax.mk_Total wp_a1 in
-                        FStar_Syntax_Util.arrow uu___4 uu___5 in
-                      FStar_Syntax_Syntax.mk_Total uu___3 in
-                    let c =
-                      FStar_Syntax_Syntax.gen_bv "c"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Syntax_Syntax.binders_of_list [a1; c] in
-                      FStar_Compiler_List.op_At binders uu___4 in
-                    let uu___4 =
-                      let l_ite =
-                        FStar_Syntax_Syntax.fvar FStar_Parser_Const.ite_lid
-                          (FStar_Syntax_Syntax.Delta_constant_at_level
-                             (Prims.of_int (2))) FStar_Pervasives_Native.None in
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_Syntax_Syntax.bv_to_name c in
-                                  FStar_Syntax_Syntax.as_arg uu___11 in
-                                [uu___10] in
-                              FStar_Syntax_Util.mk_app l_ite uu___9 in
-                            [uu___8] in
-                          FStar_Compiler_List.map FStar_Syntax_Syntax.as_arg
-                            uu___7 in
-                        FStar_Syntax_Util.mk_app c_lift21 uu___6 in
-                      FStar_Syntax_Util.ascribe uu___5
-                        ((FStar_Pervasives.Inr result_comp),
-                          FStar_Pervasives_Native.None, false) in
-                    let uu___5 =
-                      let uu___6 =
-                        FStar_Syntax_Util.residual_comp_of_comp result_comp in
-                      FStar_Pervasives_Native.Some uu___6 in
-                    FStar_Syntax_Util.abs uu___3 uu___4 uu___5 in
-                  let wp_if_then_else1 =
-                    let uu___3 = mk_lid "wp_if_then_else" in
-                    register env2 uu___3 wp_if_then_else in
-                  let wp_if_then_else2 = mk_generic_app wp_if_then_else1 in
-                  let wp_close =
-                    let b =
-                      FStar_Syntax_Syntax.gen_bv "b"
-                        FStar_Pervasives_Native.None FStar_Syntax_Util.ktype in
-                    let t_f =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name b in
-                          FStar_Syntax_Syntax.null_binder uu___5 in
-                        [uu___4] in
-                      let uu___4 = FStar_Syntax_Syntax.mk_Total wp_a1 in
-                      FStar_Syntax_Util.arrow uu___3 uu___4 in
-                    let f =
-                      FStar_Syntax_Syntax.gen_bv "f"
-                        FStar_Pervasives_Native.None t_f in
-                    let body =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Compiler_List.map
-                                FStar_Syntax_Syntax.as_arg
-                                [FStar_Syntax_Util.tforall] in
-                            FStar_Syntax_Util.mk_app c_pure1 uu___6 in
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 =
-                                    FStar_Syntax_Syntax.bv_to_name f in
-                                  [uu___10] in
-                                FStar_Compiler_List.map
-                                  FStar_Syntax_Syntax.as_arg uu___9 in
-                              FStar_Syntax_Util.mk_app c_push1 uu___8 in
-                            [uu___7] in
-                          uu___5 :: uu___6 in
-                        FStar_Compiler_List.map FStar_Syntax_Syntax.as_arg
-                          uu___4 in
-                      FStar_Syntax_Util.mk_app c_app1 uu___3 in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Syntax_Syntax.binders_of_list [a1; b; f] in
-                      FStar_Compiler_List.op_At binders uu___4 in
-                    FStar_Syntax_Util.abs uu___3 body ret_tot_wp_a in
-                  let wp_close1 =
-                    let uu___3 = mk_lid "wp_close" in
-                    register env2 uu___3 wp_close in
-                  let wp_close2 = mk_generic_app wp_close1 in
-                  let ret_tot_type =
-                    FStar_Pervasives_Native.Some
-                      (FStar_Syntax_Util.residual_tot FStar_Syntax_Util.ktype) in
-                  let ret_gtot_type =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_Syntax_Syntax.mk_GTotal
-                            FStar_Syntax_Util.ktype in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          FStar_TypeChecker_Common.lcomp_of_comp uu___5 in
-                      FStar_TypeChecker_Common.residual_comp_of_lcomp uu___4 in
-                    FStar_Pervasives_Native.Some uu___3 in
-                  let mk_forall x body =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 = FStar_Syntax_Syntax.mk_binder x in
-                                [uu___9] in
-                              FStar_Syntax_Util.abs uu___8 body ret_tot_type in
-                            FStar_Syntax_Syntax.as_arg uu___7 in
-                          [uu___6] in
-                        (FStar_Syntax_Util.tforall, uu___5) in
-                      FStar_Syntax_Syntax.Tm_app uu___4 in
-                    FStar_Syntax_Syntax.mk uu___3
-                      FStar_Compiler_Range.dummyRange in
-                  let rec is_discrete t =
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Subst.compress t in
-                      uu___4.FStar_Syntax_Syntax.n in
-                    match uu___3 with
-                    | FStar_Syntax_Syntax.Tm_type uu___4 -> false
-                    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                        (FStar_Compiler_List.for_all
-                           (fun uu___4 ->
-                              match uu___4 with
-                              | { FStar_Syntax_Syntax.binder_bv = b;
-                                  FStar_Syntax_Syntax.binder_qual = uu___5;
-                                  FStar_Syntax_Syntax.binder_attrs = uu___6;_}
-                                  -> is_discrete b.FStar_Syntax_Syntax.sort)
-                           bs)
-                          && (is_discrete (FStar_Syntax_Util.comp_result c))
-                    | uu___4 -> true in
-                  let rec is_monotonic t =
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Subst.compress t in
-                      uu___4.FStar_Syntax_Syntax.n in
-                    match uu___3 with
-                    | FStar_Syntax_Syntax.Tm_type uu___4 -> true
-                    | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                        (FStar_Compiler_List.for_all
-                           (fun uu___4 ->
-                              match uu___4 with
-                              | { FStar_Syntax_Syntax.binder_bv = b;
-                                  FStar_Syntax_Syntax.binder_qual = uu___5;
-                                  FStar_Syntax_Syntax.binder_attrs = uu___6;_}
-                                  -> is_discrete b.FStar_Syntax_Syntax.sort)
-                           bs)
-                          && (is_monotonic (FStar_Syntax_Util.comp_result c))
-                    | uu___4 -> is_discrete t in
-                  let rec mk_rel rel t x y =
-                    let mk_rel1 = mk_rel rel in
-                    let t1 =
-                      FStar_TypeChecker_Normalize.normalize
-                        [FStar_TypeChecker_Env.Beta;
-                        FStar_TypeChecker_Env.Eager_unfolding;
-                        FStar_TypeChecker_Env.UnfoldUntil
-                          FStar_Syntax_Syntax.delta_constant] env2 t in
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Subst.compress t1 in
-                      uu___4.FStar_Syntax_Syntax.n in
-                    match uu___3 with
-                    | FStar_Syntax_Syntax.Tm_type uu___4 -> rel x y
-                    | FStar_Syntax_Syntax.Tm_arrow
-                        (binder::[],
-                         {
-                           FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.GTotal
-                             b;
-                           FStar_Syntax_Syntax.pos = uu___4;
-                           FStar_Syntax_Syntax.vars = uu___5;
-                           FStar_Syntax_Syntax.hash_code = uu___6;_})
-                        ->
-                        let a2 =
-                          (binder.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                        let uu___7 = (is_monotonic a2) || (is_monotonic b) in
-                        if uu___7
-                        then
-                          let a11 =
-                            FStar_Syntax_Syntax.gen_bv "a1"
-                              FStar_Pervasives_Native.None a2 in
-                          let body =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_Syntax_Syntax.bv_to_name a11 in
-                                  FStar_Syntax_Syntax.as_arg uu___11 in
-                                [uu___10] in
-                              FStar_Syntax_Util.mk_app x uu___9 in
-                            let uu___9 =
-                              let uu___10 =
-                                let uu___11 =
-                                  let uu___12 =
-                                    FStar_Syntax_Syntax.bv_to_name a11 in
-                                  FStar_Syntax_Syntax.as_arg uu___12 in
-                                [uu___11] in
-                              FStar_Syntax_Util.mk_app y uu___10 in
-                            mk_rel1 b uu___8 uu___9 in
-                          mk_forall a11 body
-                        else
-                          (let a11 =
-                             FStar_Syntax_Syntax.gen_bv "a1"
-                               FStar_Pervasives_Native.None a2 in
-                           let a21 =
-                             FStar_Syntax_Syntax.gen_bv "a2"
-                               FStar_Pervasives_Native.None a2 in
-                           let body =
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_Syntax_Syntax.bv_to_name a11 in
-                               let uu___11 =
-                                 FStar_Syntax_Syntax.bv_to_name a21 in
-                               mk_rel1 a2 uu___10 uu___11 in
-                             let uu___10 =
-                               let uu___11 =
-                                 let uu___12 =
-                                   let uu___13 =
-                                     let uu___14 =
-                                       FStar_Syntax_Syntax.bv_to_name a11 in
-                                     FStar_Syntax_Syntax.as_arg uu___14 in
-                                   [uu___13] in
-                                 FStar_Syntax_Util.mk_app x uu___12 in
-                               let uu___12 =
-                                 let uu___13 =
-                                   let uu___14 =
-                                     let uu___15 =
-                                       FStar_Syntax_Syntax.bv_to_name a21 in
-                                     FStar_Syntax_Syntax.as_arg uu___15 in
-                                   [uu___14] in
-                                 FStar_Syntax_Util.mk_app y uu___13 in
-                               mk_rel1 b uu___11 uu___12 in
-                             FStar_Syntax_Util.mk_imp uu___9 uu___10 in
-                           let uu___9 = mk_forall a21 body in
-                           mk_forall a11 uu___9)
-                    | FStar_Syntax_Syntax.Tm_arrow
-                        (binder::[],
-                         {
-                           FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Total
-                             b;
-                           FStar_Syntax_Syntax.pos = uu___4;
-                           FStar_Syntax_Syntax.vars = uu___5;
-                           FStar_Syntax_Syntax.hash_code = uu___6;_})
-                        ->
-                        let a2 =
-                          (binder.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                        let uu___7 = (is_monotonic a2) || (is_monotonic b) in
-                        if uu___7
-                        then
-                          let a11 =
-                            FStar_Syntax_Syntax.gen_bv "a1"
-                              FStar_Pervasives_Native.None a2 in
-                          let body =
-                            let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_Syntax_Syntax.bv_to_name a11 in
-                                  FStar_Syntax_Syntax.as_arg uu___11 in
-                                [uu___10] in
-                              FStar_Syntax_Util.mk_app x uu___9 in
-                            let uu___9 =
-                              let uu___10 =
-                                let uu___11 =
-                                  let uu___12 =
-                                    FStar_Syntax_Syntax.bv_to_name a11 in
-                                  FStar_Syntax_Syntax.as_arg uu___12 in
-                                [uu___11] in
-                              FStar_Syntax_Util.mk_app y uu___10 in
-                            mk_rel1 b uu___8 uu___9 in
-                          mk_forall a11 body
-                        else
-                          (let a11 =
-                             FStar_Syntax_Syntax.gen_bv "a1"
-                               FStar_Pervasives_Native.None a2 in
-                           let a21 =
-                             FStar_Syntax_Syntax.gen_bv "a2"
-                               FStar_Pervasives_Native.None a2 in
-                           let body =
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_Syntax_Syntax.bv_to_name a11 in
-                               let uu___11 =
-                                 FStar_Syntax_Syntax.bv_to_name a21 in
-                               mk_rel1 a2 uu___10 uu___11 in
-                             let uu___10 =
-                               let uu___11 =
-                                 let uu___12 =
-                                   let uu___13 =
-                                     let uu___14 =
-                                       FStar_Syntax_Syntax.bv_to_name a11 in
-                                     FStar_Syntax_Syntax.as_arg uu___14 in
-                                   [uu___13] in
-                                 FStar_Syntax_Util.mk_app x uu___12 in
-                               let uu___12 =
-                                 let uu___13 =
-                                   let uu___14 =
-                                     let uu___15 =
-                                       FStar_Syntax_Syntax.bv_to_name a21 in
-                                     FStar_Syntax_Syntax.as_arg uu___15 in
-                                   [uu___14] in
-                                 FStar_Syntax_Util.mk_app y uu___13 in
-                               mk_rel1 b uu___11 uu___12 in
-                             FStar_Syntax_Util.mk_imp uu___9 uu___10 in
-                           let uu___9 = mk_forall a21 body in
-                           mk_forall a11 uu___9)
-                    | FStar_Syntax_Syntax.Tm_arrow (binder::binders1, comp)
-                        ->
-                        let t2 =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Util.arrow binders1 comp in
-                                FStar_Syntax_Syntax.mk_Total uu___7 in
-                              ([binder], uu___6) in
-                            FStar_Syntax_Syntax.Tm_arrow uu___5 in
-                          {
-                            FStar_Syntax_Syntax.n = uu___4;
-                            FStar_Syntax_Syntax.pos =
-                              (t1.FStar_Syntax_Syntax.pos);
-                            FStar_Syntax_Syntax.vars =
-                              (t1.FStar_Syntax_Syntax.vars);
-                            FStar_Syntax_Syntax.hash_code =
-                              (t1.FStar_Syntax_Syntax.hash_code)
-                          } in
-                        mk_rel1 t2 x y
-                    | FStar_Syntax_Syntax.Tm_arrow ([], uu___4) ->
-                        failwith "impossible: arrow with empty binders"
-                    | uu___4 -> FStar_Syntax_Util.mk_untyped_eq2 x y in
-                  let stronger =
-                    let wp1 =
-                      FStar_Syntax_Syntax.gen_bv "wp1"
-                        FStar_Pervasives_Native.None wp_a1 in
-                    let wp2 =
-                      FStar_Syntax_Syntax.gen_bv "wp2"
-                        FStar_Pervasives_Native.None wp_a1 in
-                    let rec mk_stronger t x y =
-                      let t1 =
-                        FStar_TypeChecker_Normalize.normalize
-                          [FStar_TypeChecker_Env.Beta;
-                          FStar_TypeChecker_Env.Eager_unfolding;
-                          FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant] env2 t in
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Subst.compress t1 in
-                        uu___4.FStar_Syntax_Syntax.n in
-                      match uu___3 with
-                      | FStar_Syntax_Syntax.Tm_type uu___4 ->
-                          FStar_Syntax_Util.mk_imp x y
-                      | FStar_Syntax_Syntax.Tm_app (head, args) when
-                          let uu___4 = FStar_Syntax_Subst.compress head in
-                          FStar_Syntax_Util.is_tuple_constructor uu___4 ->
-                          let project i tuple =
-                            let projector =
-                              let uu___4 =
-                                let uu___5 =
-                                  FStar_Parser_Const.mk_tuple_data_lid
-                                    (FStar_Compiler_List.length args)
-                                    FStar_Compiler_Range.dummyRange in
-                                FStar_TypeChecker_Env.lookup_projector env2
-                                  uu___5 i in
-                              FStar_Syntax_Syntax.fvar uu___4
-                                (FStar_Syntax_Syntax.Delta_constant_at_level
-                                   Prims.int_one)
-                                FStar_Pervasives_Native.None in
-                            FStar_Syntax_Util.mk_app projector
-                              [(tuple, FStar_Pervasives_Native.None)] in
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Compiler_List.mapi
-                                (fun i ->
-                                   fun uu___6 ->
-                                     match uu___6 with
-                                     | (t2, q) ->
-                                         let uu___7 = project i x in
-                                         let uu___8 = project i y in
-                                         mk_stronger t2 uu___7 uu___8) args in
-                            match uu___5 with
-                            | [] ->
-                                failwith
-                                  "Impossible: empty application when creating stronger relation in DM4F"
-                            | rel0::rels -> (rel0, rels) in
-                          (match uu___4 with
-                           | (rel0, rels) ->
-                               FStar_Compiler_List.fold_left
-                                 FStar_Syntax_Util.mk_conj rel0 rels)
-                      | FStar_Syntax_Syntax.Tm_arrow
-                          (binders1,
-                           {
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.GTotal b;
-                             FStar_Syntax_Syntax.pos = uu___4;
-                             FStar_Syntax_Syntax.vars = uu___5;
-                             FStar_Syntax_Syntax.hash_code = uu___6;_})
-                          ->
-                          let bvs =
-                            FStar_Compiler_List.mapi
-                              (fun i ->
-                                 fun uu___7 ->
-                                   match uu___7 with
-                                   | { FStar_Syntax_Syntax.binder_bv = bv;
-                                       FStar_Syntax_Syntax.binder_qual = q;
-                                       FStar_Syntax_Syntax.binder_attrs =
-                                         uu___8;_}
-                                       ->
-                                       let uu___9 =
-                                         let uu___10 =
-                                           FStar_Compiler_Util.string_of_int
-                                             i in
-                                         Prims.op_Hat "a" uu___10 in
-                                       FStar_Syntax_Syntax.gen_bv uu___9
-                                         FStar_Pervasives_Native.None
-                                         bv.FStar_Syntax_Syntax.sort)
-                              binders1 in
-                          let args =
-                            FStar_Compiler_List.map
-                              (fun ai ->
-                                 let uu___7 =
-                                   FStar_Syntax_Syntax.bv_to_name ai in
-                                 FStar_Syntax_Syntax.as_arg uu___7) bvs in
-                          let body =
-                            let uu___7 = FStar_Syntax_Util.mk_app x args in
-                            let uu___8 = FStar_Syntax_Util.mk_app y args in
-                            mk_stronger b uu___7 uu___8 in
-                          FStar_Compiler_List.fold_right
-                            (fun bv -> fun body1 -> mk_forall bv body1) bvs
-                            body
-                      | FStar_Syntax_Syntax.Tm_arrow
-                          (binders1,
-                           {
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.Total b;
-                             FStar_Syntax_Syntax.pos = uu___4;
-                             FStar_Syntax_Syntax.vars = uu___5;
-                             FStar_Syntax_Syntax.hash_code = uu___6;_})
-                          ->
-                          let bvs =
-                            FStar_Compiler_List.mapi
-                              (fun i ->
-                                 fun uu___7 ->
-                                   match uu___7 with
-                                   | { FStar_Syntax_Syntax.binder_bv = bv;
-                                       FStar_Syntax_Syntax.binder_qual = q;
-                                       FStar_Syntax_Syntax.binder_attrs =
-                                         uu___8;_}
-                                       ->
-                                       let uu___9 =
-                                         let uu___10 =
-                                           FStar_Compiler_Util.string_of_int
-                                             i in
-                                         Prims.op_Hat "a" uu___10 in
-                                       FStar_Syntax_Syntax.gen_bv uu___9
-                                         FStar_Pervasives_Native.None
-                                         bv.FStar_Syntax_Syntax.sort)
-                              binders1 in
-                          let args =
-                            FStar_Compiler_List.map
-                              (fun ai ->
-                                 let uu___7 =
-                                   FStar_Syntax_Syntax.bv_to_name ai in
-                                 FStar_Syntax_Syntax.as_arg uu___7) bvs in
-                          let body =
-                            let uu___7 = FStar_Syntax_Util.mk_app x args in
-                            let uu___8 = FStar_Syntax_Util.mk_app y args in
-                            mk_stronger b uu___7 uu___8 in
-                          FStar_Compiler_List.fold_right
-                            (fun bv -> fun body1 -> mk_forall bv body1) bvs
-                            body
-                      | uu___4 -> failwith "Not a DM elaborated type" in
-                    let body =
-                      let uu___3 = FStar_Syntax_Util.unascribe wp_a1 in
-                      let uu___4 = FStar_Syntax_Syntax.bv_to_name wp1 in
-                      let uu___5 = FStar_Syntax_Syntax.bv_to_name wp2 in
-                      mk_stronger uu___3 uu___4 uu___5 in
-                    let uu___3 =
-                      let uu___4 =
-                        binders_of_list
-                          [(a1, false); (wp1, false); (wp2, false)] in
-                      FStar_Compiler_List.op_At binders uu___4 in
-                    FStar_Syntax_Util.abs uu___3 body ret_tot_type in
-                  let stronger1 =
-                    let uu___3 = mk_lid "stronger" in
-                    register env2 uu___3 stronger in
-                  let stronger2 = mk_generic_app stronger1 in
-                  let ite_wp =
-                    let wp =
-                      FStar_Syntax_Syntax.gen_bv "wp"
-                        FStar_Pervasives_Native.None wp_a1 in
-                    let uu___3 = FStar_Compiler_Util.prefix gamma in
-                    match uu___3 with
-                    | (wp_args, post) ->
-                        let k =
-                          FStar_Syntax_Syntax.gen_bv "k"
-                            FStar_Pervasives_Native.None
-                            (post.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                        let equiv =
-                          let k_tm = FStar_Syntax_Syntax.bv_to_name k in
-                          let eq =
-                            let uu___4 =
-                              FStar_Syntax_Syntax.bv_to_name
-                                post.FStar_Syntax_Syntax.binder_bv in
-                            mk_rel FStar_Syntax_Util.mk_iff
-                              k.FStar_Syntax_Syntax.sort k_tm uu___4 in
-                          let uu___4 =
-                            FStar_Syntax_Util.destruct_typ_as_formula eq in
-                          match uu___4 with
-                          | FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Util.QAll (binders1, [], body))
-                              ->
-                              let k_app =
-                                let uu___5 = args_of_binders binders1 in
-                                FStar_Syntax_Util.mk_app k_tm uu___5 in
-                              let guard_free =
-                                let uu___5 =
-                                  FStar_Syntax_Syntax.lid_as_fv
-                                    FStar_Parser_Const.guard_free
-                                    FStar_Syntax_Syntax.delta_constant
-                                    FStar_Pervasives_Native.None in
-                                FStar_Syntax_Syntax.fv_to_tm uu___5 in
-                              let pat =
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Syntax_Syntax.as_arg k_app in
-                                  [uu___6] in
-                                FStar_Syntax_Util.mk_app guard_free uu___5 in
-                              let pattern_guarded_body =
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      let uu___8 =
-                                        let uu___9 =
-                                          FStar_Syntax_Syntax.binders_to_names
-                                            binders1 in
-                                        let uu___10 =
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_Syntax_Syntax.as_arg pat in
-                                            [uu___12] in
-                                          [uu___11] in
-                                        (uu___9, uu___10) in
-                                      FStar_Syntax_Syntax.Meta_pattern uu___8 in
-                                    (body, uu___7) in
-                                  FStar_Syntax_Syntax.Tm_meta uu___6 in
-                                mk uu___5 in
-                              FStar_Syntax_Util.close_forall_no_univs
-                                binders1 pattern_guarded_body
-                          | uu___5 ->
-                              failwith
-                                "Impossible: Expected the equivalence to be a quantified formula" in
-                        let body =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Syntax.bv_to_name wp in
-                                let uu___8 =
-                                  let uu___9 = args_of_binders wp_args in
-                                  let uu___10 =
-                                    let uu___11 =
-                                      let uu___12 =
-                                        FStar_Syntax_Syntax.bv_to_name k in
-                                      FStar_Syntax_Syntax.as_arg uu___12 in
-                                    [uu___11] in
-                                  FStar_Compiler_List.op_At uu___9 uu___10 in
-                                FStar_Syntax_Util.mk_app uu___7 uu___8 in
-                              FStar_Syntax_Util.mk_imp equiv uu___6 in
-                            FStar_Syntax_Util.mk_forall_no_univ k uu___5 in
-                          FStar_Syntax_Util.abs gamma uu___4 ret_gtot_type in
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_Syntax_Syntax.binders_of_list [a1; wp] in
-                          FStar_Compiler_List.op_At binders uu___5 in
-                        FStar_Syntax_Util.abs uu___4 body ret_gtot_type in
-                  let ite_wp1 =
-                    let uu___3 = mk_lid "ite_wp" in
-                    register env2 uu___3 ite_wp in
-                  let ite_wp2 = mk_generic_app ite_wp1 in
-                  let null_wp =
-                    let wp =
-                      FStar_Syntax_Syntax.gen_bv "wp"
-                        FStar_Pervasives_Native.None wp_a1 in
-                    let uu___3 = FStar_Compiler_Util.prefix gamma in
-                    match uu___3 with
-                    | (wp_args, post) ->
-                        let x =
-                          FStar_Syntax_Syntax.gen_bv "x"
-                            FStar_Pervasives_Native.None
-                            FStar_Syntax_Syntax.tun in
-                        let body =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                FStar_Syntax_Syntax.bv_to_name
-                                post.FStar_Syntax_Syntax.binder_bv in
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 = FStar_Syntax_Syntax.bv_to_name x in
-                                FStar_Syntax_Syntax.as_arg uu___8 in
-                              [uu___7] in
-                            FStar_Syntax_Util.mk_app uu___5 uu___6 in
-                          FStar_Syntax_Util.mk_forall_no_univ x uu___4 in
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Syntax_Syntax.binders_of_list [a1] in
-                            FStar_Compiler_List.op_At uu___6 gamma in
-                          FStar_Compiler_List.op_At binders uu___5 in
-                        FStar_Syntax_Util.abs uu___4 body ret_gtot_type in
-                  let null_wp1 =
-                    let uu___3 = mk_lid "null_wp" in
-                    register env2 uu___3 null_wp in
-                  let null_wp2 = mk_generic_app null_wp1 in
-                  let wp_trivial =
-                    let wp =
-                      FStar_Syntax_Syntax.gen_bv "wp"
-                        FStar_Pervasives_Native.None wp_a1 in
-                    let body =
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.bv_to_name a1 in
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 =
-                                    FStar_Syntax_Syntax.bv_to_name a1 in
-                                  FStar_Syntax_Syntax.as_arg uu___10 in
-                                [uu___9] in
-                              FStar_Syntax_Util.mk_app null_wp2 uu___8 in
-                            let uu___8 =
-                              let uu___9 = FStar_Syntax_Syntax.bv_to_name wp in
-                              [uu___9] in
-                            uu___7 :: uu___8 in
-                          uu___5 :: uu___6 in
-                        FStar_Compiler_List.map FStar_Syntax_Syntax.as_arg
-                          uu___4 in
-                      FStar_Syntax_Util.mk_app stronger2 uu___3 in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Syntax_Syntax.binders_of_list [a1; wp] in
-                      FStar_Compiler_List.op_At binders uu___4 in
-                    FStar_Syntax_Util.abs uu___3 body ret_tot_type in
-                  let wp_trivial1 =
-                    let uu___3 = mk_lid "wp_trivial" in
-                    register env2 uu___3 wp_trivial in
-                  let wp_trivial2 = mk_generic_app wp_trivial1 in
-                  ((let uu___4 =
-                      FStar_TypeChecker_Env.debug env2
-                        (FStar_Options.Other "ED") in
-                    if uu___4 then d "End Dijkstra monads for free" else ());
-                   (let c = FStar_Syntax_Subst.close binders in
-                    let ed_combs =
-                      match ed.FStar_Syntax_Syntax.combinators with
-                      | FStar_Syntax_Syntax.DM4F_eff combs ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = c stronger2 in ([], uu___6) in
-                            let uu___6 =
-                              let uu___7 = c wp_if_then_else2 in ([], uu___7) in
-                            let uu___7 =
-                              let uu___8 = c ite_wp2 in ([], uu___8) in
-                            let uu___8 =
-                              let uu___9 = c wp_close2 in ([], uu___9) in
-                            let uu___9 =
-                              let uu___10 = c wp_trivial2 in ([], uu___10) in
-                            {
-                              FStar_Syntax_Syntax.ret_wp =
-                                (combs.FStar_Syntax_Syntax.ret_wp);
-                              FStar_Syntax_Syntax.bind_wp =
-                                (combs.FStar_Syntax_Syntax.bind_wp);
-                              FStar_Syntax_Syntax.stronger = uu___5;
-                              FStar_Syntax_Syntax.if_then_else = uu___6;
-                              FStar_Syntax_Syntax.ite_wp = uu___7;
-                              FStar_Syntax_Syntax.close_wp = uu___8;
-                              FStar_Syntax_Syntax.trivial = uu___9;
-                              FStar_Syntax_Syntax.repr =
-                                (combs.FStar_Syntax_Syntax.repr);
-                              FStar_Syntax_Syntax.return_repr =
-                                (combs.FStar_Syntax_Syntax.return_repr);
-                              FStar_Syntax_Syntax.bind_repr =
-                                (combs.FStar_Syntax_Syntax.bind_repr)
-                            } in
-                          FStar_Syntax_Syntax.DM4F_eff uu___4
-                      | uu___4 ->
-                          failwith
-                            "Impossible! For a DM4F effect combinators must be in DM4f_eff" in
-                    let uu___4 =
-                      let uu___5 = FStar_Compiler_Effect.op_Bang sigelts in
-                      FStar_Compiler_List.rev uu___5 in
-                    (uu___4,
-                      {
-                        FStar_Syntax_Syntax.mname =
-                          (ed.FStar_Syntax_Syntax.mname);
-                        FStar_Syntax_Syntax.cattributes =
-                          (ed.FStar_Syntax_Syntax.cattributes);
-                        FStar_Syntax_Syntax.univs =
-                          (ed.FStar_Syntax_Syntax.univs);
-                        FStar_Syntax_Syntax.binders =
-                          (ed.FStar_Syntax_Syntax.binders);
-                        FStar_Syntax_Syntax.signature =
-                          (ed.FStar_Syntax_Syntax.signature);
-                        FStar_Syntax_Syntax.combinators = ed_combs;
-                        FStar_Syntax_Syntax.actions =
-                          (ed.FStar_Syntax_Syntax.actions);
-                        FStar_Syntax_Syntax.eff_attrs =
-                          (ed.FStar_Syntax_Syntax.eff_attrs)
-                      })))))
-type env_ = env
-let (get_env : env -> FStar_TypeChecker_Env.env) = fun env1 -> env1.tcenv
-let (set_env : env -> FStar_TypeChecker_Env.env -> env) =
-  fun dmff_env ->
-    fun env' ->
-      {
-        tcenv = env';
-        subst = (dmff_env.subst);
-        tc_const = (dmff_env.tc_const)
-      }
-type nm =
-  | N of FStar_Syntax_Syntax.typ 
-  | M of FStar_Syntax_Syntax.typ 
-let (uu___is_N : nm -> Prims.bool) =
-  fun projectee -> match projectee with | N _0 -> true | uu___ -> false
-let (__proj__N__item___0 : nm -> FStar_Syntax_Syntax.typ) =
-  fun projectee -> match projectee with | N _0 -> _0
-let (uu___is_M : nm -> Prims.bool) =
-  fun projectee -> match projectee with | M _0 -> true | uu___ -> false
-let (__proj__M__item___0 : nm -> FStar_Syntax_Syntax.typ) =
-  fun projectee -> match projectee with | M _0 -> _0
-type nm_ = nm
-let (nm_of_comp : FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> nm)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t -> N t
-    | FStar_Syntax_Syntax.Comp c1 when
-        FStar_Compiler_Effect.op_Bar_Greater c1.FStar_Syntax_Syntax.flags
-          (FStar_Compiler_Util.for_some
-             (fun uu___ ->
-                match uu___ with
-                | FStar_Syntax_Syntax.CPS -> true
-                | uu___1 -> false))
-        -> M (c1.FStar_Syntax_Syntax.result_typ)
-    | uu___ ->
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.comp_to_string c in
-            FStar_Compiler_Util.format1
-              "[nm_of_comp]: unexpected computation type %s" uu___3 in
-          (FStar_Errors.Error_UnexpectedDM4FType, uu___2) in
-        FStar_Errors.raise_error uu___1 c.FStar_Syntax_Syntax.pos
-let (string_of_nm : nm -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | N t ->
-        let uu___1 = FStar_Syntax_Print.term_to_string t in
-        FStar_Compiler_Util.format1 "N[%s]" uu___1
-    | M t ->
-        let uu___1 = FStar_Syntax_Print.term_to_string t in
-        FStar_Compiler_Util.format1 "M[%s]" uu___1
-let (is_monadic_arrow : FStar_Syntax_Syntax.term' -> nm) =
-  fun n ->
-    match n with
-    | FStar_Syntax_Syntax.Tm_arrow (uu___, c) -> nm_of_comp c
-    | uu___ -> failwith "unexpected_argument: [is_monadic_arrow]"
-let (is_monadic_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun c ->
-    let uu___ = nm_of_comp c in
-    match uu___ with | M uu___1 -> true | N uu___1 -> false
-exception Not_found 
-let (uu___is_Not_found : Prims.exn -> Prims.bool) =
-  fun projectee -> match projectee with | Not_found -> true | uu___ -> false
-let (double_star : FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ) =
-  fun typ ->
-    let star_once typ1 =
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None typ1 in
-          FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.mk_binder
-            uu___2 in
-        [uu___1] in
-      let uu___1 = FStar_Syntax_Syntax.mk_Total FStar_Syntax_Util.ktype0 in
-      FStar_Syntax_Util.arrow uu___ uu___1 in
-    let uu___ = FStar_Compiler_Effect.op_Bar_Greater typ star_once in
-    FStar_Compiler_Effect.op_Less_Bar star_once uu___
-let rec (mk_star_to_type :
-  (FStar_Syntax_Syntax.term' ->
-     FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-    ->
-    env ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun mk ->
-    fun env1 ->
-      fun a ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = star_type' env1 a in
-                  FStar_Syntax_Syntax.null_bv uu___5 in
-                let uu___5 = FStar_Syntax_Syntax.as_bqual_implicit false in
-                FStar_Syntax_Syntax.mk_binder_with_attrs uu___4 uu___5 [] in
-              [uu___3] in
-            let uu___3 =
-              FStar_Syntax_Syntax.mk_Total FStar_Syntax_Util.ktype0 in
-            (uu___2, uu___3) in
-          FStar_Syntax_Syntax.Tm_arrow uu___1 in
-        mk uu___
-and (star_type' :
-  env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun t ->
-      let mk x = FStar_Syntax_Syntax.mk x t.FStar_Syntax_Syntax.pos in
-      let mk_star_to_type1 = mk_star_to_type mk in
-      let t1 = FStar_Syntax_Subst.compress t in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_arrow (binders, uu___) ->
-          let binders1 =
-            FStar_Compiler_List.map
-              (fun b ->
-                 let uu___1 =
-                   let uu___2 = b.FStar_Syntax_Syntax.binder_bv in
-                   let uu___3 =
-                     star_type' env1
-                       (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                   {
-                     FStar_Syntax_Syntax.ppname =
-                       (uu___2.FStar_Syntax_Syntax.ppname);
-                     FStar_Syntax_Syntax.index =
-                       (uu___2.FStar_Syntax_Syntax.index);
-                     FStar_Syntax_Syntax.sort = uu___3
-                   } in
-                 {
-                   FStar_Syntax_Syntax.binder_bv = uu___1;
-                   FStar_Syntax_Syntax.binder_qual =
-                     (b.FStar_Syntax_Syntax.binder_qual);
-                   FStar_Syntax_Syntax.binder_attrs =
-                     (b.FStar_Syntax_Syntax.binder_attrs)
-                 }) binders in
-          (match t1.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_arrow
-               (uu___1,
-                { FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.GTotal hn;
-                  FStar_Syntax_Syntax.pos = uu___2;
-                  FStar_Syntax_Syntax.vars = uu___3;
-                  FStar_Syntax_Syntax.hash_code = uu___4;_})
-               ->
-               let uu___5 =
-                 let uu___6 =
-                   let uu___7 =
-                     let uu___8 = star_type' env1 hn in
-                     FStar_Syntax_Syntax.mk_GTotal uu___8 in
-                   (binders1, uu___7) in
-                 FStar_Syntax_Syntax.Tm_arrow uu___6 in
-               mk uu___5
-           | uu___1 ->
-               let uu___2 = is_monadic_arrow t1.FStar_Syntax_Syntax.n in
-               (match uu___2 with
-                | N hn ->
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 = star_type' env1 hn in
-                          FStar_Syntax_Syntax.mk_Total uu___6 in
-                        (binders1, uu___5) in
-                      FStar_Syntax_Syntax.Tm_arrow uu___4 in
-                    mk uu___3
-                | M a ->
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 = mk_star_to_type1 env1 a in
-                                FStar_Syntax_Syntax.null_bv uu___9 in
-                              let uu___9 =
-                                FStar_Syntax_Syntax.as_bqual_implicit false in
-                              FStar_Syntax_Syntax.mk_binder_with_attrs uu___8
-                                uu___9 [] in
-                            [uu___7] in
-                          FStar_Compiler_List.op_At binders1 uu___6 in
-                        let uu___6 =
-                          FStar_Syntax_Syntax.mk_Total
-                            FStar_Syntax_Util.ktype0 in
-                        (uu___5, uu___6) in
-                      FStar_Syntax_Syntax.Tm_arrow uu___4 in
-                    mk uu___3))
-      | FStar_Syntax_Syntax.Tm_app (head, args) ->
-          let debug t2 s =
-            let string_of_set f s1 =
-              let elts = FStar_Compiler_Util.set_elements s1 in
-              match elts with
-              | [] -> "{}"
-              | x::xs ->
-                  let strb = FStar_Compiler_Util.new_string_builder () in
-                  (FStar_Compiler_Util.string_builder_append strb "{";
-                   (let uu___2 = f x in
-                    FStar_Compiler_Util.string_builder_append strb uu___2);
-                   FStar_Compiler_List.iter
-                     (fun x1 ->
-                        FStar_Compiler_Util.string_builder_append strb ", ";
-                        (let uu___4 = f x1 in
-                         FStar_Compiler_Util.string_builder_append strb
-                           uu___4)) xs;
-                   FStar_Compiler_Util.string_builder_append strb "}";
-                   FStar_Compiler_Util.string_of_string_builder strb) in
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string t2 in
-                let uu___3 = string_of_set FStar_Syntax_Print.bv_to_string s in
-                FStar_Compiler_Util.format2
-                  "Dependency found in term %s : %s" uu___2 uu___3 in
-              (FStar_Errors.Warning_DependencyFound, uu___1) in
-            FStar_Errors.log_issue t2.FStar_Syntax_Syntax.pos uu___ in
-          let rec is_non_dependent_arrow ty n =
-            let uu___ =
-              let uu___1 = FStar_Syntax_Subst.compress ty in
-              uu___1.FStar_Syntax_Syntax.n in
-            match uu___ with
-            | FStar_Syntax_Syntax.Tm_arrow (binders, c) ->
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-                  Prims.op_Negation uu___2 in
-                if uu___1
-                then false
-                else
-                  (try
-                     (fun uu___3 ->
-                        match () with
-                        | () ->
-                            let non_dependent_or_raise s ty1 =
-                              let sinter =
-                                let uu___4 = FStar_Syntax_Free.names ty1 in
-                                FStar_Compiler_Util.set_intersect uu___4 s in
-                              let uu___4 =
-                                let uu___5 =
-                                  FStar_Compiler_Util.set_is_empty sinter in
-                                Prims.op_Negation uu___5 in
-                              if uu___4
-                              then
-                                (debug ty1 sinter;
-                                 FStar_Compiler_Effect.raise Not_found)
-                              else () in
-                            let uu___4 =
-                              FStar_Syntax_Subst.open_comp binders c in
-                            (match uu___4 with
-                             | (binders1, c1) ->
-                                 let s =
-                                   FStar_Compiler_List.fold_left
-                                     (fun s1 ->
-                                        fun uu___5 ->
-                                          match uu___5 with
-                                          | {
-                                              FStar_Syntax_Syntax.binder_bv =
-                                                bv;
-                                              FStar_Syntax_Syntax.binder_qual
-                                                = uu___6;
-                                              FStar_Syntax_Syntax.binder_attrs
-                                                = uu___7;_}
-                                              ->
-                                              (non_dependent_or_raise s1
-                                                 bv.FStar_Syntax_Syntax.sort;
-                                               FStar_Compiler_Util.set_add bv
-                                                 s1))
-                                     FStar_Syntax_Syntax.no_names binders1 in
-                                 let ct = FStar_Syntax_Util.comp_result c1 in
-                                 (non_dependent_or_raise s ct;
-                                  (let k =
-                                     n -
-                                       (FStar_Compiler_List.length binders1) in
-                                   if k > Prims.int_zero
-                                   then is_non_dependent_arrow ct k
-                                   else true)))) ()
-                   with | Not_found -> false)
-            | uu___1 ->
-                ((let uu___3 =
-                    let uu___4 =
-                      let uu___5 = FStar_Syntax_Print.term_to_string ty in
-                      FStar_Compiler_Util.format1
-                        "Not a dependent arrow : %s" uu___5 in
-                    (FStar_Errors.Warning_NotDependentArrow, uu___4) in
-                  FStar_Errors.log_issue ty.FStar_Syntax_Syntax.pos uu___3);
-                 false) in
-          let rec is_valid_application head1 =
-            let uu___ =
-              let uu___1 = FStar_Syntax_Subst.compress head1 in
-              uu___1.FStar_Syntax_Syntax.n in
-            match uu___ with
-            | FStar_Syntax_Syntax.Tm_fvar fv when
-                (((FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.option_lid)
-                    ||
-                    (FStar_Syntax_Syntax.fv_eq_lid fv
-                       FStar_Parser_Const.either_lid))
-                   ||
-                   (FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.eq2_lid))
-                  ||
-                  (let uu___1 = FStar_Syntax_Subst.compress head1 in
-                   FStar_Syntax_Util.is_tuple_constructor uu___1)
-                -> true
-            | FStar_Syntax_Syntax.Tm_fvar fv ->
-                let uu___1 =
-                  FStar_TypeChecker_Env.lookup_lid env1.tcenv
-                    (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                (match uu___1 with
-                 | ((uu___2, ty), uu___3) ->
-                     let uu___4 =
-                       is_non_dependent_arrow ty
-                         (FStar_Compiler_List.length args) in
-                     if uu___4
-                     then
-                       let res =
-                         FStar_TypeChecker_Normalize.normalize
-                           [FStar_TypeChecker_Env.EraseUniverses;
-                           FStar_TypeChecker_Env.Inlining;
-                           FStar_TypeChecker_Env.UnfoldUntil
-                             FStar_Syntax_Syntax.delta_constant] env1.tcenv
-                           t1 in
-                       let uu___5 =
-                         let uu___6 = FStar_Syntax_Subst.compress res in
-                         uu___6.FStar_Syntax_Syntax.n in
-                       (match uu___5 with
-                        | FStar_Syntax_Syntax.Tm_app uu___6 -> true
-                        | uu___6 ->
-                            ((let uu___8 =
-                                let uu___9 =
-                                  let uu___10 =
-                                    FStar_Syntax_Print.term_to_string head1 in
-                                  FStar_Compiler_Util.format1
-                                    "Got a term which might be a non-dependent user-defined data-type %s\n"
-                                    uu___10 in
-                                (FStar_Errors.Warning_NondependentUserDefinedDataType,
-                                  uu___9) in
-                              FStar_Errors.log_issue
-                                head1.FStar_Syntax_Syntax.pos uu___8);
-                             false))
-                     else false)
-            | FStar_Syntax_Syntax.Tm_bvar uu___1 -> true
-            | FStar_Syntax_Syntax.Tm_name uu___1 -> true
-            | FStar_Syntax_Syntax.Tm_uinst (t2, uu___1) ->
-                is_valid_application t2
-            | uu___1 -> false in
-          let uu___ = is_valid_application head in
-          if uu___
-          then
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_List.map
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | (t2, qual) ->
-                           let uu___5 = star_type' env1 t2 in (uu___5, qual))
-                    args in
-                (head, uu___3) in
-              FStar_Syntax_Syntax.Tm_app uu___2 in
-            mk uu___1
-          else
-            (let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-                 FStar_Compiler_Util.format1
-                   "For now, only [either], [option] and [eq2] are supported in the definition language (got: %s)"
-                   uu___4 in
-               (FStar_Errors.Fatal_WrongTerm, uu___3) in
-             FStar_Errors.raise_err uu___2)
-      | FStar_Syntax_Syntax.Tm_bvar uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_name uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_type uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_fvar uu___ -> t1
-      | FStar_Syntax_Syntax.Tm_abs (binders, repr, something) ->
-          let uu___ = FStar_Syntax_Subst.open_term binders repr in
-          (match uu___ with
-           | (binders1, repr1) ->
-               let env2 =
-                 let uu___1 =
-                   FStar_TypeChecker_Env.push_binders env1.tcenv binders1 in
-                 {
-                   tcenv = uu___1;
-                   subst = (env1.subst);
-                   tc_const = (env1.tc_const)
-                 } in
-               let repr2 = star_type' env2 repr1 in
-               FStar_Syntax_Util.abs binders1 repr2 something)
-      | FStar_Syntax_Syntax.Tm_refine (x, t2) when false ->
-          let x1 = FStar_Syntax_Syntax.freshen_bv x in
-          let sort = star_type' env1 x1.FStar_Syntax_Syntax.sort in
-          let subst = [FStar_Syntax_Syntax.DB (Prims.int_zero, x1)] in
-          let t3 = FStar_Syntax_Subst.subst subst t2 in
-          let t4 = star_type' env1 t3 in
-          let subst1 = [FStar_Syntax_Syntax.NM (x1, Prims.int_zero)] in
-          let t5 = FStar_Syntax_Subst.subst subst1 t4 in
-          mk
-            (FStar_Syntax_Syntax.Tm_refine
-               ({
-                  FStar_Syntax_Syntax.ppname =
-                    (x1.FStar_Syntax_Syntax.ppname);
-                  FStar_Syntax_Syntax.index = (x1.FStar_Syntax_Syntax.index);
-                  FStar_Syntax_Syntax.sort = sort
-                }, t5))
-      | FStar_Syntax_Syntax.Tm_meta (t2, m) ->
-          let uu___ =
-            let uu___1 = let uu___2 = star_type' env1 t2 in (uu___2, m) in
-            FStar_Syntax_Syntax.Tm_meta uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (e,
-           (FStar_Pervasives.Inl t2, FStar_Pervasives_Native.None, use_eq),
-           something)
-          ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = star_type' env1 e in
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = star_type' env1 t2 in
-                  FStar_Pervasives.Inl uu___5 in
-                (uu___4, FStar_Pervasives_Native.None, use_eq) in
-              (uu___2, uu___3, something) in
-            FStar_Syntax_Syntax.Tm_ascribed uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (e, (FStar_Pervasives.Inr c, FStar_Pervasives_Native.None, use_eq),
-           something)
-          ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = star_type' env1 e in
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    star_type' env1 (FStar_Syntax_Util.comp_result c) in
-                  FStar_Pervasives.Inl uu___5 in
-                (uu___4, FStar_Pervasives_Native.None, use_eq) in
-              (uu___2, uu___3, something) in
-            FStar_Syntax_Syntax.Tm_ascribed uu___1 in
-          mk uu___
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (uu___, (uu___1, FStar_Pervasives_Native.Some uu___2, uu___3),
-           uu___4)
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Ascriptions with tactics are outside of the definition language: %s"
-                uu___7 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___6) in
-          FStar_Errors.raise_err uu___5
-      | FStar_Syntax_Syntax.Tm_refine uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_refine is outside of the definition language: %s" uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_uinst uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_uinst is outside of the definition language: %s" uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_quoted uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_quoted is outside of the definition language: %s" uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_constant uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_constant is outside of the definition language: %s"
-                uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_match uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_match is outside of the definition language: %s" uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_let uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_let is outside of the definition language: %s" uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_uvar uu___ ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_uvar is outside of the definition language: %s" uu___3 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Syntax_Syntax.Tm_unknown ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.format1
-                "Tm_unknown is outside of the definition language: %s" uu___2 in
-            (FStar_Errors.Fatal_TermOutsideOfDefLanguage, uu___1) in
-          FStar_Errors.raise_err uu___
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___ = FStar_Syntax_Util.unfold_lazy i in
-          star_type' env1 uu___
-      | FStar_Syntax_Syntax.Tm_delayed uu___ -> failwith "impossible"
-let (is_monadic :
-  FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-    Prims.bool)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.None -> failwith "un-annotated lambda?!"
-    | FStar_Pervasives_Native.Some rc ->
-        FStar_Compiler_Effect.op_Bar_Greater
-          rc.FStar_Syntax_Syntax.residual_flags
-          (FStar_Compiler_Util.for_some
-             (fun uu___1 ->
-                match uu___1 with
-                | FStar_Syntax_Syntax.CPS -> true
-                | uu___2 -> false))
-let rec (is_C : FStar_Syntax_Syntax.typ -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_app (head, args) when
-        FStar_Syntax_Util.is_tuple_constructor head ->
-        let r =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_List.hd args in
-            FStar_Pervasives_Native.fst uu___2 in
-          is_C uu___1 in
-        if r
-        then
-          ((let uu___2 =
-              let uu___3 =
-                FStar_Compiler_List.for_all
-                  (fun uu___4 -> match uu___4 with | (h, uu___5) -> is_C h)
-                  args in
-              Prims.op_Negation uu___3 in
-            if uu___2
-            then
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Print.term_to_string t in
-                  FStar_Compiler_Util.format1 "Not a C-type (A * C): %s"
-                    uu___5 in
-                (FStar_Errors.Error_UnexpectedDM4FType, uu___4) in
-              FStar_Errors.raise_error uu___3 t.FStar_Syntax_Syntax.pos
-            else ());
-           true)
-        else
-          ((let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.for_all
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (h, uu___6) ->
-                         let uu___7 = is_C h in Prims.op_Negation uu___7)
-                  args in
-              Prims.op_Negation uu___4 in
-            if uu___3
-            then
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 = FStar_Syntax_Print.term_to_string t in
-                  FStar_Compiler_Util.format1 "Not a C-type (C * A): %s"
-                    uu___6 in
-                (FStar_Errors.Error_UnexpectedDM4FType, uu___5) in
-              FStar_Errors.raise_error uu___4 t.FStar_Syntax_Syntax.pos
-            else ());
-           false)
-    | FStar_Syntax_Syntax.Tm_arrow (binders, comp) ->
-        let uu___1 = nm_of_comp comp in
-        (match uu___1 with
-         | M t1 ->
-             ((let uu___3 = is_C t1 in
-               if uu___3
-               then
-                 let uu___4 =
-                   let uu___5 =
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.format1 "Not a C-type (C -> C): %s"
-                       uu___6 in
-                   (FStar_Errors.Error_UnexpectedDM4FType, uu___5) in
-                 FStar_Errors.raise_error uu___4 t1.FStar_Syntax_Syntax.pos
-               else ());
-              true)
-         | N t1 -> is_C t1)
-    | FStar_Syntax_Syntax.Tm_meta (t1, uu___1) -> is_C t1
-    | FStar_Syntax_Syntax.Tm_uinst (t1, uu___1) -> is_C t1
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, uu___1, uu___2) -> is_C t1
-    | uu___1 -> false
-let (mk_return :
-  env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun env1 ->
-    fun t ->
-      fun e ->
-        let mk x = FStar_Syntax_Syntax.mk x e.FStar_Syntax_Syntax.pos in
-        let p_type = mk_star_to_type mk env1 t in
-        let p =
-          FStar_Syntax_Syntax.gen_bv "p'" FStar_Pervasives_Native.None p_type in
-        let body =
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Syntax.bv_to_name p in
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Syntax.as_aqual_implicit false in
-                  (e, uu___5) in
-                [uu___4] in
-              (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Tm_app uu___1 in
-          mk uu___ in
-        let uu___ = let uu___1 = FStar_Syntax_Syntax.mk_binder p in [uu___1] in
-        FStar_Syntax_Util.abs uu___ body
-          (FStar_Pervasives_Native.Some
-             (FStar_Syntax_Util.residual_tot FStar_Syntax_Util.ktype0))
-let (is_unknown : FStar_Syntax_Syntax.term' -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_unknown -> true
-    | uu___1 -> false
-let rec (check :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      nm -> (nm * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun e ->
-      fun context_nm ->
-        let return_if uu___ =
-          match uu___ with
-          | (rec_nm, s_e, u_e) ->
-              let check1 t1 t2 =
-                let uu___1 =
-                  (Prims.op_Negation (is_unknown t2.FStar_Syntax_Syntax.n))
-                    &&
-                    (let uu___2 =
-                       let uu___3 =
-                         FStar_TypeChecker_Rel.teq env1.tcenv t1 t2 in
-                       FStar_TypeChecker_Env.is_trivial uu___3 in
-                     Prims.op_Negation uu___2) in
-                if uu___1
-                then
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Print.term_to_string e in
-                      let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                      let uu___6 = FStar_Syntax_Print.term_to_string t2 in
-                      FStar_Compiler_Util.format3
-                        "[check]: the expression [%s] has type [%s] but should have type [%s]"
-                        uu___4 uu___5 uu___6 in
-                    (FStar_Errors.Fatal_TypeMismatch, uu___3) in
-                  FStar_Errors.raise_err uu___2
-                else () in
-              (match (rec_nm, context_nm) with
-               | (N t1, N t2) -> (check1 t1 t2; (rec_nm, s_e, u_e))
-               | (M t1, M t2) -> (check1 t1 t2; (rec_nm, s_e, u_e))
-               | (N t1, M t2) ->
-                   (check1 t1 t2;
-                    (let uu___2 = mk_return env1 t1 s_e in
-                     ((M t1), uu___2, u_e)))
-               | (M t1, N t2) ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Print.term_to_string e in
-                       let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-                       let uu___5 = FStar_Syntax_Print.term_to_string t2 in
-                       FStar_Compiler_Util.format3
-                         "[check %s]: got an effectful computation [%s] in lieu of a pure computation [%s]"
-                         uu___3 uu___4 uu___5 in
-                     (FStar_Errors.Fatal_EffectfulAndPureComputationMismatch,
-                       uu___2) in
-                   FStar_Errors.raise_err uu___1) in
-        let ensure_m env2 e2 =
-          let strip_m uu___ =
-            match uu___ with
-            | (M t, s_e, u_e) -> (t, s_e, u_e)
-            | uu___1 -> failwith "impossible" in
-          match context_nm with
-          | N t ->
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Print.term_to_string t in
-                  Prims.op_Hat
-                    "let-bound monadic body has a non-monadic continuation or a branch of a match is monadic and the others aren't : "
-                    uu___2 in
-                (FStar_Errors.Fatal_LetBoundMonadicMismatch, uu___1) in
-              FStar_Errors.raise_error uu___ e2.FStar_Syntax_Syntax.pos
-          | M uu___ ->
-              let uu___1 = check env2 e2 context_nm in strip_m uu___1 in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress e in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_bvar uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_name uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_fvar uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_abs uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_constant uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_quoted uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_app uu___1 ->
-            let uu___2 = infer env1 e in return_if uu___2
-        | FStar_Syntax_Syntax.Tm_lazy i ->
-            let uu___1 = FStar_Syntax_Util.unfold_lazy i in
-            check env1 uu___1 context_nm
-        | FStar_Syntax_Syntax.Tm_let ((false, binding::[]), e2) ->
-            mk_let env1 binding e2
-              (fun env2 -> fun e21 -> check env2 e21 context_nm) ensure_m
-        | FStar_Syntax_Syntax.Tm_match (e0, uu___1, branches, uu___2) ->
-            mk_match env1 e0 branches
-              (fun env2 -> fun body -> check env2 body context_nm)
-        | FStar_Syntax_Syntax.Tm_meta (e1, uu___1) ->
-            check env1 e1 context_nm
-        | FStar_Syntax_Syntax.Tm_uinst (e1, uu___1) ->
-            check env1 e1 context_nm
-        | FStar_Syntax_Syntax.Tm_ascribed (e1, uu___1, uu___2) ->
-            check env1 e1 context_nm
-        | FStar_Syntax_Syntax.Tm_let uu___1 ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.format1 "[check]: Tm_let %s" uu___3 in
-            failwith uu___2
-        | FStar_Syntax_Syntax.Tm_type uu___1 ->
-            failwith "impossible (DM stratification)"
-        | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-            failwith "impossible (DM stratification)"
-        | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.format1 "[check]: Tm_refine %s" uu___3 in
-            failwith uu___2
-        | FStar_Syntax_Syntax.Tm_uvar uu___1 ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.format1 "[check]: Tm_uvar %s" uu___3 in
-            failwith uu___2
-        | FStar_Syntax_Syntax.Tm_delayed uu___1 ->
-            failwith "impossible (compressed)"
-        | FStar_Syntax_Syntax.Tm_unknown ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.format1 "[check]: Tm_unknown %s" uu___2 in
-            failwith uu___1
-and (infer :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (nm * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun e ->
-      let mk x = FStar_Syntax_Syntax.mk x e.FStar_Syntax_Syntax.pos in
-      let normalize =
-        FStar_TypeChecker_Normalize.normalize
-          [FStar_TypeChecker_Env.Beta;
-          FStar_TypeChecker_Env.Eager_unfolding;
-          FStar_TypeChecker_Env.UnfoldUntil
-            FStar_Syntax_Syntax.delta_constant;
-          FStar_TypeChecker_Env.EraseUniverses] env1.tcenv in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress e in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_bvar bv ->
-          failwith "I failed to open a binder... boo"
-      | FStar_Syntax_Syntax.Tm_name bv ->
-          ((N (bv.FStar_Syntax_Syntax.sort)), e, e)
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___1 = FStar_Syntax_Util.unfold_lazy i in infer env1 uu___1
-      | FStar_Syntax_Syntax.Tm_abs (binders, body, rc_opt) ->
-          let subst_rc_opt subst rc_opt1 =
-            match rc_opt1 with
-            | FStar_Pervasives_Native.Some
-                { FStar_Syntax_Syntax.residual_effect = uu___1;
-                  FStar_Syntax_Syntax.residual_typ =
-                    FStar_Pervasives_Native.None;
-                  FStar_Syntax_Syntax.residual_flags = uu___2;_}
-                -> rc_opt1
-            | FStar_Pervasives_Native.None -> rc_opt1
-            | FStar_Pervasives_Native.Some rc ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_Util.must
-                          rc.FStar_Syntax_Syntax.residual_typ in
-                      FStar_Syntax_Subst.subst subst uu___4 in
-                    FStar_Pervasives_Native.Some uu___3 in
-                  {
-                    FStar_Syntax_Syntax.residual_effect =
-                      (rc.FStar_Syntax_Syntax.residual_effect);
-                    FStar_Syntax_Syntax.residual_typ = uu___2;
-                    FStar_Syntax_Syntax.residual_flags =
-                      (rc.FStar_Syntax_Syntax.residual_flags)
-                  } in
-                FStar_Pervasives_Native.Some uu___1 in
-          let binders1 = FStar_Syntax_Subst.open_binders binders in
-          let subst = FStar_Syntax_Subst.opening_of_binders binders1 in
-          let body1 = FStar_Syntax_Subst.subst subst body in
-          let rc_opt1 = subst_rc_opt subst rc_opt in
-          let env2 =
-            let uu___1 =
-              FStar_TypeChecker_Env.push_binders env1.tcenv binders1 in
-            {
-              tcenv = uu___1;
-              subst = (env1.subst);
-              tc_const = (env1.tc_const)
-            } in
-          let s_binders =
-            FStar_Compiler_List.map
-              (fun b ->
-                 let sort =
-                   star_type' env2
-                     (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                 {
-                   FStar_Syntax_Syntax.binder_bv =
-                     (let uu___1 = b.FStar_Syntax_Syntax.binder_bv in
-                      {
-                        FStar_Syntax_Syntax.ppname =
-                          (uu___1.FStar_Syntax_Syntax.ppname);
-                        FStar_Syntax_Syntax.index =
-                          (uu___1.FStar_Syntax_Syntax.index);
-                        FStar_Syntax_Syntax.sort = sort
-                      });
-                   FStar_Syntax_Syntax.binder_qual =
-                     (b.FStar_Syntax_Syntax.binder_qual);
-                   FStar_Syntax_Syntax.binder_attrs =
-                     (b.FStar_Syntax_Syntax.binder_attrs)
-                 }) binders1 in
-          let uu___1 =
-            FStar_Compiler_List.fold_left
-              (fun uu___2 ->
-                 fun uu___3 ->
-                   match (uu___2, uu___3) with
-                   | ((env3, acc),
-                      { FStar_Syntax_Syntax.binder_bv = bv;
-                        FStar_Syntax_Syntax.binder_qual = uu___4;
-                        FStar_Syntax_Syntax.binder_attrs = uu___5;_})
-                       ->
-                       let c = bv.FStar_Syntax_Syntax.sort in
-                       let uu___6 = is_C c in
-                       if uu___6
-                       then
-                         let xw =
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_Ident.string_of_id
-                                 bv.FStar_Syntax_Syntax.ppname in
-                             Prims.op_Hat uu___8 "__w" in
-                           let uu___8 = star_type' env3 c in
-                           FStar_Syntax_Syntax.gen_bv uu___7
-                             FStar_Pervasives_Native.None uu___8 in
-                         let x =
-                           let uu___7 =
-                             let uu___8 = FStar_Syntax_Syntax.bv_to_name xw in
-                             trans_F_ env3 c uu___8 in
-                           {
-                             FStar_Syntax_Syntax.ppname =
-                               (bv.FStar_Syntax_Syntax.ppname);
-                             FStar_Syntax_Syntax.index =
-                               (bv.FStar_Syntax_Syntax.index);
-                             FStar_Syntax_Syntax.sort = uu___7
-                           } in
-                         let env4 =
-                           let uu___7 =
-                             let uu___8 =
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_Syntax_Syntax.bv_to_name xw in
-                                 (bv, uu___10) in
-                               FStar_Syntax_Syntax.NT uu___9 in
-                             uu___8 :: (env3.subst) in
-                           {
-                             tcenv = (env3.tcenv);
-                             subst = uu___7;
-                             tc_const = (env3.tc_const)
-                           } in
-                         let uu___7 =
-                           let uu___8 = FStar_Syntax_Syntax.mk_binder x in
-                           let uu___9 =
-                             let uu___10 = FStar_Syntax_Syntax.mk_binder xw in
-                             uu___10 :: acc in
-                           uu___8 :: uu___9 in
-                         (env4, uu___7)
-                       else
-                         (let x =
-                            let uu___8 =
-                              star_type' env3 bv.FStar_Syntax_Syntax.sort in
-                            {
-                              FStar_Syntax_Syntax.ppname =
-                                (bv.FStar_Syntax_Syntax.ppname);
-                              FStar_Syntax_Syntax.index =
-                                (bv.FStar_Syntax_Syntax.index);
-                              FStar_Syntax_Syntax.sort = uu___8
-                            } in
-                          let uu___8 =
-                            let uu___9 = FStar_Syntax_Syntax.mk_binder x in
-                            uu___9 :: acc in
-                          (env3, uu___8))) (env2, []) binders1 in
-          (match uu___1 with
-           | (env3, u_binders) ->
-               let u_binders1 = FStar_Compiler_List.rev u_binders in
-               let uu___2 =
-                 let check_what =
-                   let uu___3 = is_monadic rc_opt1 in
-                   if uu___3 then check_m else check_n in
-                 let uu___3 = check_what env3 body1 in
-                 match uu___3 with
-                 | (t, s_body, u_body) ->
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 = is_monadic rc_opt1 in
-                         if uu___6 then M t else N t in
-                       comp_of_nm uu___5 in
-                     (uu___4, s_body, u_body) in
-               (match uu___2 with
-                | (comp, s_body, u_body) ->
-                    let t = FStar_Syntax_Util.arrow binders1 comp in
-                    let s_rc_opt =
-                      match rc_opt1 with
-                      | FStar_Pervasives_Native.None ->
-                          FStar_Pervasives_Native.None
-                      | FStar_Pervasives_Native.Some rc ->
-                          (match rc.FStar_Syntax_Syntax.residual_typ with
-                           | FStar_Pervasives_Native.None ->
-                               let rc1 =
-                                 let uu___3 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     rc.FStar_Syntax_Syntax.residual_flags
-                                     (FStar_Compiler_Util.for_some
-                                        (fun uu___4 ->
-                                           match uu___4 with
-                                           | FStar_Syntax_Syntax.CPS -> true
-                                           | uu___5 -> false)) in
-                                 if uu___3
-                                 then
-                                   let uu___4 =
-                                     FStar_Compiler_List.filter
-                                       (fun uu___5 ->
-                                          match uu___5 with
-                                          | FStar_Syntax_Syntax.CPS -> false
-                                          | uu___6 -> true)
-                                       rc.FStar_Syntax_Syntax.residual_flags in
-                                   FStar_Syntax_Util.mk_residual_comp
-                                     FStar_Parser_Const.effect_Tot_lid
-                                     FStar_Pervasives_Native.None uu___4
-                                 else rc in
-                               FStar_Pervasives_Native.Some rc1
-                           | FStar_Pervasives_Native.Some rt ->
-                               let rt1 =
-                                 let uu___3 = get_env env3 in
-                                 FStar_TypeChecker_Normalize.normalize
-                                   [FStar_TypeChecker_Env.Beta;
-                                   FStar_TypeChecker_Env.Eager_unfolding;
-                                   FStar_TypeChecker_Env.UnfoldUntil
-                                     FStar_Syntax_Syntax.delta_constant;
-                                   FStar_TypeChecker_Env.EraseUniverses]
-                                   uu___3 rt in
-                               let uu___3 =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   rc.FStar_Syntax_Syntax.residual_flags
-                                   (FStar_Compiler_Util.for_some
-                                      (fun uu___4 ->
-                                         match uu___4 with
-                                         | FStar_Syntax_Syntax.CPS -> true
-                                         | uu___5 -> false)) in
-                               if uu___3
-                               then
-                                 let flags =
-                                   FStar_Compiler_List.filter
-                                     (fun uu___4 ->
-                                        match uu___4 with
-                                        | FStar_Syntax_Syntax.CPS -> false
-                                        | uu___5 -> true)
-                                     rc.FStar_Syntax_Syntax.residual_flags in
-                                 let uu___4 =
-                                   let uu___5 =
-                                     let uu___6 = double_star rt1 in
-                                     FStar_Pervasives_Native.Some uu___6 in
-                                   FStar_Syntax_Util.mk_residual_comp
-                                     FStar_Parser_Const.effect_Tot_lid uu___5
-                                     flags in
-                                 FStar_Pervasives_Native.Some uu___4
-                               else
-                                 (let uu___5 =
-                                    let uu___6 =
-                                      let uu___7 = star_type' env3 rt1 in
-                                      FStar_Pervasives_Native.Some uu___7 in
-                                    {
-                                      FStar_Syntax_Syntax.residual_effect =
-                                        (rc.FStar_Syntax_Syntax.residual_effect);
-                                      FStar_Syntax_Syntax.residual_typ =
-                                        uu___6;
-                                      FStar_Syntax_Syntax.residual_flags =
-                                        (rc.FStar_Syntax_Syntax.residual_flags)
-                                    } in
-                                  FStar_Pervasives_Native.Some uu___5)) in
-                    let uu___3 =
-                      let comp1 =
-                        let uu___4 = is_monadic rc_opt1 in
-                        let uu___5 =
-                          FStar_Syntax_Subst.subst env3.subst s_body in
-                        trans_G env3 (FStar_Syntax_Util.comp_result comp)
-                          uu___4 uu___5 in
-                      let uu___4 =
-                        FStar_Syntax_Util.ascribe u_body
-                          ((FStar_Pervasives.Inr comp1),
-                            FStar_Pervasives_Native.None, false) in
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Syntax_Util.residual_comp_of_comp comp1 in
-                        FStar_Pervasives_Native.Some uu___6 in
-                      (uu___4, uu___5) in
-                    (match uu___3 with
-                     | (u_body1, u_rc_opt) ->
-                         let s_body1 =
-                           FStar_Syntax_Subst.close s_binders s_body in
-                         let s_binders1 =
-                           FStar_Syntax_Subst.close_binders s_binders in
-                         let s_term =
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   FStar_Syntax_Subst.closing_of_binders
-                                     s_binders1 in
-                                 subst_rc_opt uu___7 s_rc_opt in
-                               (s_binders1, s_body1, uu___6) in
-                             FStar_Syntax_Syntax.Tm_abs uu___5 in
-                           mk uu___4 in
-                         let u_body2 =
-                           FStar_Syntax_Subst.close u_binders1 u_body1 in
-                         let u_binders2 =
-                           FStar_Syntax_Subst.close_binders u_binders1 in
-                         let u_term =
-                           let uu___4 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   FStar_Syntax_Subst.closing_of_binders
-                                     u_binders2 in
-                                 subst_rc_opt uu___7 u_rc_opt in
-                               (u_binders2, u_body2, uu___6) in
-                             FStar_Syntax_Syntax.Tm_abs uu___5 in
-                           mk uu___4 in
-                         ((N t), s_term, u_term))))
-      | FStar_Syntax_Syntax.Tm_fvar
-          {
-            FStar_Syntax_Syntax.fv_name =
-              { FStar_Syntax_Syntax.v = lid;
-                FStar_Syntax_Syntax.p = uu___1;_};
-            FStar_Syntax_Syntax.fv_delta = uu___2;
-            FStar_Syntax_Syntax.fv_qual = uu___3;_}
-          ->
-          let uu___4 =
-            let uu___5 = FStar_TypeChecker_Env.lookup_lid env1.tcenv lid in
-            FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.fst
-              uu___5 in
-          (match uu___4 with
-           | (uu___5, t) ->
-               let uu___6 = let uu___7 = normalize t in N uu___7 in
-               (uu___6, e, e))
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_range_of);
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           a::hd::rest)
-          ->
-          let rest1 = hd :: rest in
-          let uu___4 = FStar_Syntax_Util.head_and_args e in
-          (match uu___4 with
-           | (unary_op, uu___5) ->
-               let head = mk (FStar_Syntax_Syntax.Tm_app (unary_op, [a])) in
-               let t = mk (FStar_Syntax_Syntax.Tm_app (head, rest1)) in
-               infer env1 t)
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_set_range_of);
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           a1::a2::hd::rest)
-          ->
-          let rest1 = hd :: rest in
-          let uu___4 = FStar_Syntax_Util.head_and_args e in
-          (match uu___4 with
-           | (unary_op, uu___5) ->
-               let head =
-                 mk (FStar_Syntax_Syntax.Tm_app (unary_op, [a1; a2])) in
-               let t = mk (FStar_Syntax_Syntax.Tm_app (head, rest1)) in
-               infer env1 t)
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_range_of);
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           (a, FStar_Pervasives_Native.None)::[])
-          ->
-          let uu___4 = infer env1 a in
-          (match uu___4 with
-           | (t, s, u) ->
-               let uu___5 = FStar_Syntax_Util.head_and_args e in
-               (match uu___5 with
-                | (head, uu___6) ->
-                    let uu___7 =
-                      let uu___8 =
-                        FStar_Syntax_Syntax.tabbrev
-                          FStar_Parser_Const.range_lid in
-                      N uu___8 in
-                    let uu___8 =
-                      let uu___9 =
-                        let uu___10 =
-                          let uu___11 =
-                            let uu___12 = FStar_Syntax_Syntax.as_arg s in
-                            [uu___12] in
-                          (head, uu___11) in
-                        FStar_Syntax_Syntax.Tm_app uu___10 in
-                      mk uu___9 in
-                    let uu___9 =
-                      let uu___10 =
-                        let uu___11 =
-                          let uu___12 =
-                            let uu___13 = FStar_Syntax_Syntax.as_arg u in
-                            [uu___13] in
-                          (head, uu___12) in
-                        FStar_Syntax_Syntax.Tm_app uu___11 in
-                      mk uu___10 in
-                    (uu___7, uu___8, uu___9)))
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_set_range_of);
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           (a1, uu___4)::a2::[])
-          ->
-          let uu___5 = infer env1 a1 in
-          (match uu___5 with
-           | (t, s, u) ->
-               let uu___6 = FStar_Syntax_Util.head_and_args e in
-               (match uu___6 with
-                | (head, uu___7) ->
-                    let uu___8 =
-                      let uu___9 =
-                        let uu___10 =
-                          let uu___11 =
-                            let uu___12 = FStar_Syntax_Syntax.as_arg s in
-                            [uu___12; a2] in
-                          (head, uu___11) in
-                        FStar_Syntax_Syntax.Tm_app uu___10 in
-                      mk uu___9 in
-                    let uu___9 =
-                      let uu___10 =
-                        let uu___11 =
-                          let uu___12 =
-                            let uu___13 = FStar_Syntax_Syntax.as_arg u in
-                            [uu___13; a2] in
-                          (head, uu___12) in
-                        FStar_Syntax_Syntax.Tm_app uu___11 in
-                      mk uu___10 in
-                    (t, uu___8, uu___9)))
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_range_of);
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           uu___4)
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.format1 "DMFF: Ill-applied constant %s"
-                uu___7 in
-            (FStar_Errors.Fatal_IllAppliedConstant, uu___6) in
-          FStar_Errors.raise_error uu___5 e.FStar_Syntax_Syntax.pos
-      | FStar_Syntax_Syntax.Tm_app
-          ({
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_set_range_of);
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           uu___4)
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.format1 "DMFF: Ill-applied constant %s"
-                uu___7 in
-            (FStar_Errors.Fatal_IllAppliedConstant, uu___6) in
-          FStar_Errors.raise_error uu___5 e.FStar_Syntax_Syntax.pos
-      | FStar_Syntax_Syntax.Tm_app (head, args) ->
-          let uu___1 = check_n env1 head in
-          (match uu___1 with
-           | (t_head, s_head, u_head) ->
-               let is_arrow t =
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 match uu___2 with
-                 | FStar_Syntax_Syntax.Tm_arrow uu___3 -> true
-                 | uu___3 -> false in
-               let rec flatten t =
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 match uu___2 with
-                 | FStar_Syntax_Syntax.Tm_arrow
-                     (binders,
-                      { FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Total t1;
-                        FStar_Syntax_Syntax.pos = uu___3;
-                        FStar_Syntax_Syntax.vars = uu___4;
-                        FStar_Syntax_Syntax.hash_code = uu___5;_})
-                     when is_arrow t1 ->
-                     let uu___6 = flatten t1 in
-                     (match uu___6 with
-                      | (binders', comp) ->
-                          ((FStar_Compiler_List.op_At binders binders'),
-                            comp))
-                 | FStar_Syntax_Syntax.Tm_arrow (binders, comp) ->
-                     (binders, comp)
-                 | FStar_Syntax_Syntax.Tm_ascribed (e1, uu___3, uu___4) ->
-                     flatten e1
-                 | uu___3 ->
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Syntax_Print.term_to_string t_head in
-                         FStar_Compiler_Util.format1
-                           "%s: not a function type" uu___6 in
-                       (FStar_Errors.Fatal_NotFunctionType, uu___5) in
-                     FStar_Errors.raise_err uu___4 in
-               let uu___2 = flatten t_head in
-               (match uu___2 with
-                | (binders, comp) ->
-                    let n = FStar_Compiler_List.length binders in
-                    let n' = FStar_Compiler_List.length args in
-                    (if
-                       (FStar_Compiler_List.length binders) <
-                         (FStar_Compiler_List.length args)
-                     then
-                       (let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Compiler_Util.string_of_int n in
-                            let uu___7 =
-                              FStar_Compiler_Util.string_of_int (n' - n) in
-                            let uu___8 = FStar_Compiler_Util.string_of_int n in
-                            FStar_Compiler_Util.format3
-                              "The head of this application, after being applied to %s arguments, is an effectful computation (leaving %s arguments to be applied). Please let-bind the head applied to the %s first arguments."
-                              uu___6 uu___7 uu___8 in
-                          (FStar_Errors.Fatal_BinderAndArgsLengthMismatch,
-                            uu___5) in
-                        FStar_Errors.raise_err uu___4)
-                     else ();
-                     (let uu___4 = FStar_Syntax_Subst.open_comp binders comp in
-                      match uu___4 with
-                      | (binders1, comp1) ->
-                          let rec final_type subst uu___5 args1 =
-                            match uu___5 with
-                            | (binders2, comp2) ->
-                                (match (binders2, args1) with
-                                 | ([], []) ->
-                                     let uu___6 =
-                                       FStar_Syntax_Subst.subst_comp subst
-                                         comp2 in
-                                     nm_of_comp uu___6
-                                 | (binders3, []) ->
-                                     let uu___6 =
-                                       let uu___7 =
-                                         let uu___8 =
-                                           let uu___9 =
-                                             mk
-                                               (FStar_Syntax_Syntax.Tm_arrow
-                                                  (binders3, comp2)) in
-                                           FStar_Syntax_Subst.subst subst
-                                             uu___9 in
-                                         FStar_Syntax_Subst.compress uu___8 in
-                                       uu___7.FStar_Syntax_Syntax.n in
-                                     (match uu___6 with
-                                      | FStar_Syntax_Syntax.Tm_arrow
-                                          (binders4, comp3) ->
-                                          let uu___7 =
-                                            let uu___8 =
-                                              let uu___9 =
-                                                let uu___10 =
-                                                  FStar_Syntax_Subst.close_comp
-                                                    binders4 comp3 in
-                                                (binders4, uu___10) in
-                                              FStar_Syntax_Syntax.Tm_arrow
-                                                uu___9 in
-                                            mk uu___8 in
-                                          N uu___7
-                                      | uu___7 -> failwith "wat?")
-                                 | ([], uu___6::uu___7) ->
-                                     failwith "just checked that?!"
-                                 | ({ FStar_Syntax_Syntax.binder_bv = bv;
-                                      FStar_Syntax_Syntax.binder_qual =
-                                        uu___6;
-                                      FStar_Syntax_Syntax.binder_attrs =
-                                        uu___7;_}::binders3,
-                                    (arg, uu___8)::args2) ->
-                                     final_type
-                                       ((FStar_Syntax_Syntax.NT (bv, arg)) ::
-                                       subst) (binders3, comp2) args2) in
-                          let final_type1 =
-                            final_type [] (binders1, comp1) args in
-                          let uu___5 =
-                            FStar_Compiler_List.splitAt n' binders1 in
-                          (match uu___5 with
-                           | (binders2, uu___6) ->
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Compiler_List.map2
-                                     (fun uu___9 ->
-                                        fun uu___10 ->
-                                          match (uu___9, uu___10) with
-                                          | ({
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 = bv;
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 = uu___11;
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 = uu___12;_},
-                                             (arg, q)) ->
-                                              let uu___13 =
-                                                let uu___14 =
-                                                  FStar_Syntax_Subst.compress
-                                                    bv.FStar_Syntax_Syntax.sort in
-                                                uu___14.FStar_Syntax_Syntax.n in
-                                              (match uu___13 with
-                                               | FStar_Syntax_Syntax.Tm_type
-                                                   uu___14 ->
-                                                   let uu___15 =
-                                                     let uu___16 =
-                                                       star_type' env1 arg in
-                                                     (uu___16, q) in
-                                                   (uu___15, [(arg, q)])
-                                               | uu___14 ->
-                                                   let uu___15 =
-                                                     check_n env1 arg in
-                                                   (match uu___15 with
-                                                    | (uu___16, s_arg, u_arg)
-                                                        ->
-                                                        let uu___17 =
-                                                          let uu___18 =
-                                                            is_C
-                                                              bv.FStar_Syntax_Syntax.sort in
-                                                          if uu___18
-                                                          then
-                                                            let uu___19 =
-                                                              let uu___20 =
-                                                                FStar_Syntax_Subst.subst
-                                                                  env1.subst
-                                                                  s_arg in
-                                                              (uu___20, q) in
-                                                            [uu___19;
-                                                            (u_arg, q)]
-                                                          else [(u_arg, q)] in
-                                                        ((s_arg, q), uu___17))))
-                                     binders2 args in
-                                 FStar_Compiler_List.split uu___8 in
-                               (match uu___7 with
-                                | (s_args, u_args) ->
-                                    let u_args1 =
-                                      FStar_Compiler_List.flatten u_args in
-                                    let uu___8 =
-                                      mk
-                                        (FStar_Syntax_Syntax.Tm_app
-                                           (s_head, s_args)) in
-                                    let uu___9 =
-                                      mk
-                                        (FStar_Syntax_Syntax.Tm_app
-                                           (u_head, u_args1)) in
-                                    (final_type1, uu___8, uu___9)))))))
-      | FStar_Syntax_Syntax.Tm_let ((false, binding::[]), e2) ->
-          mk_let env1 binding e2 infer check_m
-      | FStar_Syntax_Syntax.Tm_match (e0, uu___1, branches, uu___2) ->
-          mk_match env1 e0 branches infer
-      | FStar_Syntax_Syntax.Tm_uinst (e1, uu___1) -> infer env1 e1
-      | FStar_Syntax_Syntax.Tm_meta (e1, uu___1) -> infer env1 e1
-      | FStar_Syntax_Syntax.Tm_ascribed (e1, uu___1, uu___2) -> infer env1 e1
-      | FStar_Syntax_Syntax.Tm_constant c ->
-          let uu___1 = let uu___2 = env1.tc_const c in N uu___2 in
-          (uu___1, e, e)
-      | FStar_Syntax_Syntax.Tm_quoted (tm, qt) ->
-          ((N FStar_Syntax_Syntax.t_term), e, e)
-      | FStar_Syntax_Syntax.Tm_let uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format1 "[infer]: Tm_let %s" uu___3 in
-          failwith uu___2
-      | FStar_Syntax_Syntax.Tm_type uu___1 ->
-          failwith "impossible (DM stratification)"
-      | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-          failwith "impossible (DM stratification)"
-      | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format1 "[infer]: Tm_refine %s" uu___3 in
-          failwith uu___2
-      | FStar_Syntax_Syntax.Tm_uvar uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format1 "[infer]: Tm_uvar %s" uu___3 in
-          failwith uu___2
-      | FStar_Syntax_Syntax.Tm_delayed uu___1 ->
-          failwith "impossible (compressed)"
-      | FStar_Syntax_Syntax.Tm_unknown ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format1 "[infer]: Tm_unknown %s" uu___2 in
-          failwith uu___1
-and (mk_match :
-  env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      (FStar_Syntax_Syntax.pat' FStar_Syntax_Syntax.withinfo_t *
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term'
-        FStar_Syntax_Syntax.syntax) Prims.list ->
-        (env ->
-           FStar_Syntax_Syntax.term ->
-             (nm * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-          -> (nm * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun e0 ->
-      fun branches ->
-        fun f ->
-          let mk x = FStar_Syntax_Syntax.mk x e0.FStar_Syntax_Syntax.pos in
-          let uu___ = check_n env1 e0 in
-          match uu___ with
-          | (uu___1, s_e0, u_e0) ->
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_List.map
-                    (fun b ->
-                       let uu___4 = FStar_Syntax_Subst.open_branch b in
-                       match uu___4 with
-                       | (pat, FStar_Pervasives_Native.None, body) ->
-                           let env2 =
-                             let uu___5 =
-                               let uu___6 = FStar_Syntax_Syntax.pat_bvs pat in
-                               FStar_Compiler_List.fold_left
-                                 FStar_TypeChecker_Env.push_bv env1.tcenv
-                                 uu___6 in
-                             {
-                               tcenv = uu___5;
-                               subst = (env1.subst);
-                               tc_const = (env1.tc_const)
-                             } in
-                           let uu___5 = f env2 body in
-                           (match uu___5 with
-                            | (nm1, s_body, u_body) ->
-                                (nm1,
-                                  (pat, FStar_Pervasives_Native.None,
-                                    (s_body, u_body, body))))
-                       | uu___5 ->
-                           FStar_Errors.raise_err
-                             (FStar_Errors.Fatal_WhenClauseNotSupported,
-                               "No when clauses in the definition language"))
-                    branches in
-                FStar_Compiler_List.split uu___3 in
-              (match uu___2 with
-               | (nms, branches1) ->
-                   let t1 =
-                     let uu___3 = FStar_Compiler_List.hd nms in
-                     match uu___3 with | M t11 -> t11 | N t11 -> t11 in
-                   let has_m =
-                     FStar_Compiler_List.existsb
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | M uu___4 -> true
-                          | uu___4 -> false) nms in
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_List.map2
-                         (fun nm1 ->
-                            fun uu___5 ->
-                              match uu___5 with
-                              | (pat, guard, (s_body, u_body, original_body))
-                                  ->
-                                  (match (nm1, has_m) with
-                                   | (N t2, false) ->
-                                       (nm1, (pat, guard, s_body),
-                                         (pat, guard, u_body))
-                                   | (M t2, true) ->
-                                       (nm1, (pat, guard, s_body),
-                                         (pat, guard, u_body))
-                                   | (N t2, true) ->
-                                       let uu___6 =
-                                         check env1 original_body (M t2) in
-                                       (match uu___6 with
-                                        | (uu___7, s_body1, u_body1) ->
-                                            ((M t2), (pat, guard, s_body1),
-                                              (pat, guard, u_body1)))
-                                   | (M uu___6, false) ->
-                                       failwith "impossible")) nms branches1 in
-                     FStar_Compiler_List.unzip3 uu___4 in
-                   (match uu___3 with
-                    | (nms1, s_branches, u_branches) ->
-                        if has_m
-                        then
-                          let p_type = mk_star_to_type mk env1 t1 in
-                          let p =
-                            FStar_Syntax_Syntax.gen_bv "p''"
-                              FStar_Pervasives_Native.None p_type in
-                          let s_branches1 =
-                            FStar_Compiler_List.map
-                              (fun uu___4 ->
-                                 match uu___4 with
-                                 | (pat, guard, s_body) ->
-                                     let s_body1 =
-                                       let uu___5 =
-                                         let uu___6 =
-                                           let uu___7 =
-                                             let uu___8 =
-                                               let uu___9 =
-                                                 FStar_Syntax_Syntax.bv_to_name
-                                                   p in
-                                               let uu___10 =
-                                                 FStar_Syntax_Syntax.as_aqual_implicit
-                                                   false in
-                                               (uu___9, uu___10) in
-                                             [uu___8] in
-                                           (s_body, uu___7) in
-                                         FStar_Syntax_Syntax.Tm_app uu___6 in
-                                       mk uu___5 in
-                                     (pat, guard, s_body1)) s_branches in
-                          let s_branches2 =
-                            FStar_Compiler_List.map
-                              FStar_Syntax_Subst.close_branch s_branches1 in
-                          let u_branches1 =
-                            FStar_Compiler_List.map
-                              FStar_Syntax_Subst.close_branch u_branches in
-                          let s_e =
-                            let uu___4 =
-                              let uu___5 = FStar_Syntax_Syntax.mk_binder p in
-                              [uu___5] in
-                            let uu___5 =
-                              mk
-                                (FStar_Syntax_Syntax.Tm_match
-                                   (s_e0, FStar_Pervasives_Native.None,
-                                     s_branches2,
-                                     FStar_Pervasives_Native.None)) in
-                            FStar_Syntax_Util.abs uu___4 uu___5
-                              (FStar_Pervasives_Native.Some
-                                 (FStar_Syntax_Util.residual_tot
-                                    FStar_Syntax_Util.ktype0)) in
-                          let t1_star =
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  FStar_Syntax_Syntax.new_bv
-                                    FStar_Pervasives_Native.None p_type in
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  FStar_Syntax_Syntax.mk_binder uu___6 in
-                              [uu___5] in
-                            let uu___5 =
-                              FStar_Syntax_Syntax.mk_Total
-                                FStar_Syntax_Util.ktype0 in
-                            FStar_Syntax_Util.arrow uu___4 uu___5 in
-                          let uu___4 =
-                            mk
-                              (FStar_Syntax_Syntax.Tm_ascribed
-                                 (s_e,
-                                   ((FStar_Pervasives.Inl t1_star),
-                                     FStar_Pervasives_Native.None, false),
-                                   FStar_Pervasives_Native.None)) in
-                          let uu___5 =
-                            mk
-                              (FStar_Syntax_Syntax.Tm_match
-                                 (u_e0, FStar_Pervasives_Native.None,
-                                   u_branches1, FStar_Pervasives_Native.None)) in
-                          ((M t1), uu___4, uu___5)
-                        else
-                          (let s_branches1 =
-                             FStar_Compiler_List.map
-                               FStar_Syntax_Subst.close_branch s_branches in
-                           let u_branches1 =
-                             FStar_Compiler_List.map
-                               FStar_Syntax_Subst.close_branch u_branches in
-                           let t1_star = t1 in
-                           let uu___5 =
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   mk
-                                     (FStar_Syntax_Syntax.Tm_match
-                                        (s_e0, FStar_Pervasives_Native.None,
-                                          s_branches1,
-                                          FStar_Pervasives_Native.None)) in
-                                 (uu___8,
-                                   ((FStar_Pervasives.Inl t1_star),
-                                     FStar_Pervasives_Native.None, false),
-                                   FStar_Pervasives_Native.None) in
-                               FStar_Syntax_Syntax.Tm_ascribed uu___7 in
-                             mk uu___6 in
-                           let uu___6 =
-                             mk
-                               (FStar_Syntax_Syntax.Tm_match
-                                  (u_e0, FStar_Pervasives_Native.None,
-                                    u_branches1,
-                                    FStar_Pervasives_Native.None)) in
-                           ((N t1), uu___5, uu___6))))
-and (mk_let :
-  env_ ->
-    FStar_Syntax_Syntax.letbinding ->
-      FStar_Syntax_Syntax.term ->
-        (env_ ->
-           FStar_Syntax_Syntax.term ->
-             (nm * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-          ->
-          (env_ ->
-             FStar_Syntax_Syntax.term ->
-               (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-                 FStar_Syntax_Syntax.term))
-            -> (nm * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun binding ->
-      fun e2 ->
-        fun proceed ->
-          fun ensure_m ->
-            let mk x = FStar_Syntax_Syntax.mk x e2.FStar_Syntax_Syntax.pos in
-            let e1 = binding.FStar_Syntax_Syntax.lbdef in
-            let x =
-              FStar_Compiler_Util.left binding.FStar_Syntax_Syntax.lbname in
-            let x_binders =
-              let uu___ = FStar_Syntax_Syntax.mk_binder x in [uu___] in
-            let uu___ = FStar_Syntax_Subst.open_term x_binders e2 in
-            match uu___ with
-            | (x_binders1, e21) ->
-                let uu___1 = infer env1 e1 in
-                (match uu___1 with
-                 | (N t1, s_e1, u_e1) ->
-                     let u_binding =
-                       let uu___2 = is_C t1 in
-                       if uu___2
-                       then
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Syntax_Subst.subst env1.subst s_e1 in
-                           trans_F_ env1 t1 uu___4 in
-                         {
-                           FStar_Syntax_Syntax.lbname =
-                             (binding.FStar_Syntax_Syntax.lbname);
-                           FStar_Syntax_Syntax.lbunivs =
-                             (binding.FStar_Syntax_Syntax.lbunivs);
-                           FStar_Syntax_Syntax.lbtyp = uu___3;
-                           FStar_Syntax_Syntax.lbeff =
-                             (binding.FStar_Syntax_Syntax.lbeff);
-                           FStar_Syntax_Syntax.lbdef =
-                             (binding.FStar_Syntax_Syntax.lbdef);
-                           FStar_Syntax_Syntax.lbattrs =
-                             (binding.FStar_Syntax_Syntax.lbattrs);
-                           FStar_Syntax_Syntax.lbpos =
-                             (binding.FStar_Syntax_Syntax.lbpos)
-                         }
-                       else binding in
-                     let env2 =
-                       let uu___2 =
-                         FStar_TypeChecker_Env.push_bv env1.tcenv
-                           {
-                             FStar_Syntax_Syntax.ppname =
-                               (x.FStar_Syntax_Syntax.ppname);
-                             FStar_Syntax_Syntax.index =
-                               (x.FStar_Syntax_Syntax.index);
-                             FStar_Syntax_Syntax.sort = t1
-                           } in
-                       {
-                         tcenv = uu___2;
-                         subst = (env1.subst);
-                         tc_const = (env1.tc_const)
-                       } in
-                     let uu___2 = proceed env2 e21 in
-                     (match uu___2 with
-                      | (nm_rec, s_e2, u_e2) ->
-                          let s_binding =
-                            let uu___3 =
-                              star_type' env2
-                                binding.FStar_Syntax_Syntax.lbtyp in
-                            {
-                              FStar_Syntax_Syntax.lbname =
-                                (binding.FStar_Syntax_Syntax.lbname);
-                              FStar_Syntax_Syntax.lbunivs =
-                                (binding.FStar_Syntax_Syntax.lbunivs);
-                              FStar_Syntax_Syntax.lbtyp = uu___3;
-                              FStar_Syntax_Syntax.lbeff =
-                                (binding.FStar_Syntax_Syntax.lbeff);
-                              FStar_Syntax_Syntax.lbdef =
-                                (binding.FStar_Syntax_Syntax.lbdef);
-                              FStar_Syntax_Syntax.lbattrs =
-                                (binding.FStar_Syntax_Syntax.lbattrs);
-                              FStar_Syntax_Syntax.lbpos =
-                                (binding.FStar_Syntax_Syntax.lbpos)
-                            } in
-                          let uu___3 =
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  FStar_Syntax_Subst.close x_binders1 s_e2 in
-                                ((false,
-                                   [{
-                                      FStar_Syntax_Syntax.lbname =
-                                        (s_binding.FStar_Syntax_Syntax.lbname);
-                                      FStar_Syntax_Syntax.lbunivs =
-                                        (s_binding.FStar_Syntax_Syntax.lbunivs);
-                                      FStar_Syntax_Syntax.lbtyp =
-                                        (s_binding.FStar_Syntax_Syntax.lbtyp);
-                                      FStar_Syntax_Syntax.lbeff =
-                                        (s_binding.FStar_Syntax_Syntax.lbeff);
-                                      FStar_Syntax_Syntax.lbdef = s_e1;
-                                      FStar_Syntax_Syntax.lbattrs =
-                                        (s_binding.FStar_Syntax_Syntax.lbattrs);
-                                      FStar_Syntax_Syntax.lbpos =
-                                        (s_binding.FStar_Syntax_Syntax.lbpos)
-                                    }]), uu___6) in
-                              FStar_Syntax_Syntax.Tm_let uu___5 in
-                            mk uu___4 in
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Subst.close x_binders1 u_e2 in
-                                ((false,
-                                   [{
-                                      FStar_Syntax_Syntax.lbname =
-                                        (u_binding.FStar_Syntax_Syntax.lbname);
-                                      FStar_Syntax_Syntax.lbunivs =
-                                        (u_binding.FStar_Syntax_Syntax.lbunivs);
-                                      FStar_Syntax_Syntax.lbtyp =
-                                        (u_binding.FStar_Syntax_Syntax.lbtyp);
-                                      FStar_Syntax_Syntax.lbeff =
-                                        (u_binding.FStar_Syntax_Syntax.lbeff);
-                                      FStar_Syntax_Syntax.lbdef = u_e1;
-                                      FStar_Syntax_Syntax.lbattrs =
-                                        (u_binding.FStar_Syntax_Syntax.lbattrs);
-                                      FStar_Syntax_Syntax.lbpos =
-                                        (u_binding.FStar_Syntax_Syntax.lbpos)
-                                    }]), uu___7) in
-                              FStar_Syntax_Syntax.Tm_let uu___6 in
-                            mk uu___5 in
-                          (nm_rec, uu___3, uu___4))
-                 | (M t1, s_e1, u_e1) ->
-                     let u_binding =
-                       {
-                         FStar_Syntax_Syntax.lbname =
-                           (binding.FStar_Syntax_Syntax.lbname);
-                         FStar_Syntax_Syntax.lbunivs =
-                           (binding.FStar_Syntax_Syntax.lbunivs);
-                         FStar_Syntax_Syntax.lbtyp = t1;
-                         FStar_Syntax_Syntax.lbeff =
-                           FStar_Parser_Const.effect_PURE_lid;
-                         FStar_Syntax_Syntax.lbdef =
-                           (binding.FStar_Syntax_Syntax.lbdef);
-                         FStar_Syntax_Syntax.lbattrs =
-                           (binding.FStar_Syntax_Syntax.lbattrs);
-                         FStar_Syntax_Syntax.lbpos =
-                           (binding.FStar_Syntax_Syntax.lbpos)
-                       } in
-                     let env2 =
-                       let uu___2 =
-                         FStar_TypeChecker_Env.push_bv env1.tcenv
-                           {
-                             FStar_Syntax_Syntax.ppname =
-                               (x.FStar_Syntax_Syntax.ppname);
-                             FStar_Syntax_Syntax.index =
-                               (x.FStar_Syntax_Syntax.index);
-                             FStar_Syntax_Syntax.sort = t1
-                           } in
-                       {
-                         tcenv = uu___2;
-                         subst = (env1.subst);
-                         tc_const = (env1.tc_const)
-                       } in
-                     let uu___2 = ensure_m env2 e21 in
-                     (match uu___2 with
-                      | (t2, s_e2, u_e2) ->
-                          let p_type = mk_star_to_type mk env2 t2 in
-                          let p =
-                            FStar_Syntax_Syntax.gen_bv "p''"
-                              FStar_Pervasives_Native.None p_type in
-                          let s_e21 =
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      FStar_Syntax_Syntax.bv_to_name p in
-                                    let uu___8 =
-                                      FStar_Syntax_Syntax.as_aqual_implicit
-                                        false in
-                                    (uu___7, uu___8) in
-                                  [uu___6] in
-                                (s_e2, uu___5) in
-                              FStar_Syntax_Syntax.Tm_app uu___4 in
-                            mk uu___3 in
-                          let s_e22 =
-                            FStar_Syntax_Util.abs x_binders1 s_e21
-                              (FStar_Pervasives_Native.Some
-                                 (FStar_Syntax_Util.residual_tot
-                                    FStar_Syntax_Util.ktype0)) in
-                          let body =
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      FStar_Syntax_Syntax.as_aqual_implicit
-                                        false in
-                                    (s_e22, uu___7) in
-                                  [uu___6] in
-                                (s_e1, uu___5) in
-                              FStar_Syntax_Syntax.Tm_app uu___4 in
-                            mk uu___3 in
-                          let uu___3 =
-                            let uu___4 =
-                              let uu___5 = FStar_Syntax_Syntax.mk_binder p in
-                              [uu___5] in
-                            FStar_Syntax_Util.abs uu___4 body
-                              (FStar_Pervasives_Native.Some
-                                 (FStar_Syntax_Util.residual_tot
-                                    FStar_Syntax_Util.ktype0)) in
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Syntax_Subst.close x_binders1 u_e2 in
-                                ((false,
-                                   [{
-                                      FStar_Syntax_Syntax.lbname =
-                                        (u_binding.FStar_Syntax_Syntax.lbname);
-                                      FStar_Syntax_Syntax.lbunivs =
-                                        (u_binding.FStar_Syntax_Syntax.lbunivs);
-                                      FStar_Syntax_Syntax.lbtyp =
-                                        (u_binding.FStar_Syntax_Syntax.lbtyp);
-                                      FStar_Syntax_Syntax.lbeff =
-                                        (u_binding.FStar_Syntax_Syntax.lbeff);
-                                      FStar_Syntax_Syntax.lbdef = u_e1;
-                                      FStar_Syntax_Syntax.lbattrs =
-                                        (u_binding.FStar_Syntax_Syntax.lbattrs);
-                                      FStar_Syntax_Syntax.lbpos =
-                                        (u_binding.FStar_Syntax_Syntax.lbpos)
-                                    }]), uu___7) in
-                              FStar_Syntax_Syntax.Tm_let uu___6 in
-                            mk uu___5 in
-                          ((M t2), uu___3, uu___4)))
-and (check_n :
-  env_ ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun e ->
-      let mn =
-        let uu___ =
-          FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-            e.FStar_Syntax_Syntax.pos in
-        N uu___ in
-      let uu___ = check env1 e mn in
-      match uu___ with
-      | (N t, s_e, u_e) -> (t, s_e, u_e)
-      | uu___1 -> failwith "[check_n]: impossible"
-and (check_m :
-  env_ ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.term))
-  =
-  fun env1 ->
-    fun e ->
-      let mn =
-        let uu___ =
-          FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-            e.FStar_Syntax_Syntax.pos in
-        M uu___ in
-      let uu___ = check env1 e mn in
-      match uu___ with
-      | (M t, s_e, u_e) -> (t, s_e, u_e)
-      | uu___1 -> failwith "[check_m]: impossible"
-and (comp_of_nm : nm_ -> FStar_Syntax_Syntax.comp) =
-  fun nm1 ->
-    match nm1 with | N t -> FStar_Syntax_Syntax.mk_Total t | M t -> mk_M t
-and (mk_M : FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.comp) =
-  fun t ->
-    FStar_Syntax_Syntax.mk_Comp
-      {
-        FStar_Syntax_Syntax.comp_univs = [FStar_Syntax_Syntax.U_unknown];
-        FStar_Syntax_Syntax.effect_name = FStar_Parser_Const.monadic_lid;
-        FStar_Syntax_Syntax.result_typ = t;
-        FStar_Syntax_Syntax.effect_args = [];
-        FStar_Syntax_Syntax.flags =
-          [FStar_Syntax_Syntax.CPS; FStar_Syntax_Syntax.TOTAL]
-      }
-and (type_of_comp :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  = fun t -> FStar_Syntax_Util.comp_result t
-and (trans_F_ :
-  env_ ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun c ->
-      fun wp ->
-        (let uu___1 = let uu___2 = is_C c in Prims.op_Negation uu___2 in
-         if uu___1
-         then
-           let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Syntax_Print.term_to_string c in
-               FStar_Compiler_Util.format1 "Not a DM4F C-type: %s" uu___4 in
-             (FStar_Errors.Error_UnexpectedDM4FType, uu___3) in
-           FStar_Errors.raise_error uu___2 c.FStar_Syntax_Syntax.pos
-         else ());
-        (let mk x = FStar_Syntax_Syntax.mk x c.FStar_Syntax_Syntax.pos in
-         let uu___1 =
-           let uu___2 = FStar_Syntax_Subst.compress c in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_app (head, args) ->
-             let uu___2 = FStar_Syntax_Util.head_and_args wp in
-             (match uu___2 with
-              | (wp_head, wp_args) ->
-                  ((let uu___4 =
-                      (Prims.op_Negation
-                         ((FStar_Compiler_List.length wp_args) =
-                            (FStar_Compiler_List.length args)))
-                        ||
-                        (let uu___5 =
-                           let uu___6 =
-                             FStar_Parser_Const.mk_tuple_data_lid
-                               (FStar_Compiler_List.length wp_args)
-                               FStar_Compiler_Range.dummyRange in
-                           FStar_Syntax_Util.is_constructor wp_head uu___6 in
-                         Prims.op_Negation uu___5) in
-                    if uu___4 then failwith "mismatch" else ());
-                   (let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Compiler_List.map2
-                            (fun uu___7 ->
-                               fun uu___8 ->
-                                 match (uu___7, uu___8) with
-                                 | ((arg, q), (wp_arg, q')) ->
-                                     let print_implicit q1 =
-                                       let uu___9 =
-                                         FStar_Syntax_Syntax.is_aqual_implicit
-                                           q1 in
-                                       if uu___9
-                                       then "implicit"
-                                       else "explicit" in
-                                     ((let uu___10 =
-                                         let uu___11 =
-                                           FStar_Syntax_Util.eq_aqual q q' in
-                                         uu___11 <> FStar_Syntax_Util.Equal in
-                                       if uu___10
-                                       then
-                                         let uu___11 =
-                                           let uu___12 =
-                                             let uu___13 = print_implicit q in
-                                             let uu___14 = print_implicit q' in
-                                             FStar_Compiler_Util.format2
-                                               "Incoherent implicit qualifiers %s %s\n"
-                                               uu___13 uu___14 in
-                                           (FStar_Errors.Warning_IncoherentImplicitQualifier,
-                                             uu___12) in
-                                         FStar_Errors.log_issue
-                                           head.FStar_Syntax_Syntax.pos
-                                           uu___11
-                                       else ());
-                                      (let uu___10 = trans_F_ env1 arg wp_arg in
-                                       (uu___10, q)))) args wp_args in
-                        (head, uu___6) in
-                      FStar_Syntax_Syntax.Tm_app uu___5 in
-                    mk uu___4)))
-         | FStar_Syntax_Syntax.Tm_arrow (binders, comp) ->
-             let binders1 = FStar_Syntax_Util.name_binders binders in
-             let uu___2 = FStar_Syntax_Subst.open_comp binders1 comp in
-             (match uu___2 with
-              | (binders_orig, comp1) ->
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_List.map
-                        (fun b ->
-                           let uu___5 =
-                             ((b.FStar_Syntax_Syntax.binder_bv),
-                               (b.FStar_Syntax_Syntax.binder_qual)) in
-                           match uu___5 with
-                           | (bv, q) ->
-                               let h = bv.FStar_Syntax_Syntax.sort in
-                               let uu___6 = is_C h in
-                               if uu___6
-                               then
-                                 let w' =
-                                   let uu___7 =
-                                     let uu___8 =
-                                       FStar_Ident.string_of_id
-                                         bv.FStar_Syntax_Syntax.ppname in
-                                     Prims.op_Hat uu___8 "__w'" in
-                                   let uu___8 = star_type' env1 h in
-                                   FStar_Syntax_Syntax.gen_bv uu___7
-                                     FStar_Pervasives_Native.None uu___8 in
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       let uu___10 =
-                                         let uu___11 =
-                                           let uu___12 =
-                                             FStar_Syntax_Syntax.bv_to_name
-                                               w' in
-                                           trans_F_ env1 h uu___12 in
-                                         FStar_Syntax_Syntax.null_bv uu___11 in
-                                       {
-                                         FStar_Syntax_Syntax.binder_bv =
-                                           uu___10;
-                                         FStar_Syntax_Syntax.binder_qual =
-                                           (b.FStar_Syntax_Syntax.binder_qual);
-                                         FStar_Syntax_Syntax.binder_attrs =
-                                           (b.FStar_Syntax_Syntax.binder_attrs)
-                                       } in
-                                     [uu___9] in
-                                   {
-                                     FStar_Syntax_Syntax.binder_bv = w';
-                                     FStar_Syntax_Syntax.binder_qual =
-                                       (b.FStar_Syntax_Syntax.binder_qual);
-                                     FStar_Syntax_Syntax.binder_attrs =
-                                       (b.FStar_Syntax_Syntax.binder_attrs)
-                                   } :: uu___8 in
-                                 (w', uu___7)
-                               else
-                                 (let x =
-                                    let uu___8 =
-                                      let uu___9 =
-                                        FStar_Ident.string_of_id
-                                          bv.FStar_Syntax_Syntax.ppname in
-                                      Prims.op_Hat uu___9 "__x" in
-                                    let uu___9 = star_type' env1 h in
-                                    FStar_Syntax_Syntax.gen_bv uu___8
-                                      FStar_Pervasives_Native.None uu___9 in
-                                  (x,
-                                    [{
-                                       FStar_Syntax_Syntax.binder_bv = x;
-                                       FStar_Syntax_Syntax.binder_qual =
-                                         (b.FStar_Syntax_Syntax.binder_qual);
-                                       FStar_Syntax_Syntax.binder_attrs =
-                                         (b.FStar_Syntax_Syntax.binder_attrs)
-                                     }]))) binders_orig in
-                    FStar_Compiler_List.split uu___4 in
-                  (match uu___3 with
-                   | (bvs, binders2) ->
-                       let binders3 = FStar_Compiler_List.flatten binders2 in
-                       let comp2 =
-                         let uu___4 =
-                           let uu___5 =
-                             FStar_Syntax_Syntax.binders_of_list bvs in
-                           FStar_Syntax_Util.rename_binders binders_orig
-                             uu___5 in
-                         FStar_Syntax_Subst.subst_comp uu___4 comp1 in
-                       let app =
-                         let uu___4 =
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Compiler_List.map
-                                 (fun bv ->
-                                    let uu___7 =
-                                      FStar_Syntax_Syntax.bv_to_name bv in
-                                    let uu___8 =
-                                      FStar_Syntax_Syntax.as_aqual_implicit
-                                        false in
-                                    (uu___7, uu___8)) bvs in
-                             (wp, uu___6) in
-                           FStar_Syntax_Syntax.Tm_app uu___5 in
-                         mk uu___4 in
-                       let comp3 =
-                         let uu___4 = type_of_comp comp2 in
-                         let uu___5 = is_monadic_comp comp2 in
-                         trans_G env1 uu___4 uu___5 app in
-                       FStar_Syntax_Util.arrow binders3 comp3))
-         | FStar_Syntax_Syntax.Tm_ascribed (e, uu___2, uu___3) ->
-             trans_F_ env1 e wp
-         | uu___2 -> failwith "impossible trans_F_")
-and (trans_G :
-  env_ ->
-    FStar_Syntax_Syntax.typ ->
-      Prims.bool -> FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.comp)
-  =
-  fun env1 ->
-    fun h ->
-      fun is_monadic1 ->
-        fun wp ->
-          if is_monadic1
-          then
-            let uu___ =
-              let uu___1 = star_type' env1 h in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Syntax.as_aqual_implicit false in
-                  (wp, uu___4) in
-                [uu___3] in
-              {
-                FStar_Syntax_Syntax.comp_univs =
-                  [FStar_Syntax_Syntax.U_unknown];
-                FStar_Syntax_Syntax.effect_name =
-                  FStar_Parser_Const.effect_PURE_lid;
-                FStar_Syntax_Syntax.result_typ = uu___1;
-                FStar_Syntax_Syntax.effect_args = uu___2;
-                FStar_Syntax_Syntax.flags = []
-              } in
-            FStar_Syntax_Syntax.mk_Comp uu___
-          else
-            (let uu___1 = trans_F_ env1 h wp in
-             FStar_Syntax_Syntax.mk_Total uu___1)
-let (n :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  FStar_TypeChecker_Normalize.normalize
-    [FStar_TypeChecker_Env.Beta;
-    FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-    FStar_TypeChecker_Env.DoNotUnfoldPureLets;
-    FStar_TypeChecker_Env.Eager_unfolding;
-    FStar_TypeChecker_Env.EraseUniverses]
-let (star_type : env -> FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ) =
-  fun env1 -> fun t -> let uu___ = n env1.tcenv t in star_type' env1 uu___
-let (star_expr :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.term))
-  = fun env1 -> fun t -> let uu___ = n env1.tcenv t in check_n env1 uu___
-let (trans_F :
-  env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun c ->
-      fun wp ->
-        let uu___ = n env1.tcenv c in
-        let uu___1 = n env1.tcenv wp in trans_F_ env1 uu___ uu___1
-let (recheck_debug :
-  Prims.string ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun s ->
-    fun env1 ->
-      fun t ->
-        (let uu___1 =
-           FStar_TypeChecker_Env.debug env1 (FStar_Options.Other "ED") in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.term_to_string t in
-           FStar_Compiler_Util.print2
-             "Term has been %s-transformed to:\n%s\n----------\n" s uu___2
-         else ());
-        (let uu___1 = FStar_TypeChecker_TcTerm.tc_term env1 t in
-         match uu___1 with
-         | (t', uu___2, uu___3) ->
-             ((let uu___5 =
-                 FStar_TypeChecker_Env.debug env1 (FStar_Options.Other "ED") in
-               if uu___5
-               then
-                 let uu___6 = FStar_Syntax_Print.term_to_string t' in
-                 FStar_Compiler_Util.print1
-                   "Re-checked; got:\n%s\n----------\n" uu___6
-               else ());
-              t'))
-let (cps_and_elaborate :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      (FStar_Syntax_Syntax.sigelt Prims.list * FStar_Syntax_Syntax.eff_decl *
-        FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option))
-  =
-  fun env1 ->
-    fun ed ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              ed.FStar_Syntax_Syntax.signature
-              FStar_Syntax_Util.effect_sig_ts in
-          FStar_Compiler_Effect.op_Bar_Greater uu___2
-            FStar_Pervasives_Native.snd in
-        FStar_Syntax_Subst.open_term ed.FStar_Syntax_Syntax.binders uu___1 in
-      match uu___ with
-      | (effect_binders_un, signature_un) ->
-          let uu___1 =
-            FStar_TypeChecker_TcTerm.tc_tparams env1 effect_binders_un in
-          (match uu___1 with
-           | (effect_binders, env2, uu___2) ->
-               let uu___3 =
-                 FStar_TypeChecker_TcTerm.tc_trivial_guard env2 signature_un in
-               (match uu___3 with
-                | (signature, uu___4) ->
-                    let raise_error uu___5 =
-                      match uu___5 with
-                      | (e, err_msg) ->
-                          FStar_Errors.raise_error (e, err_msg)
-                            signature.FStar_Syntax_Syntax.pos in
-                    let effect_binders1 =
-                      FStar_Compiler_List.map
-                        (fun b ->
-                           let uu___5 =
-                             let uu___6 = b.FStar_Syntax_Syntax.binder_bv in
-                             let uu___7 =
-                               FStar_TypeChecker_Normalize.normalize
-                                 [FStar_TypeChecker_Env.EraseUniverses] env2
-                                 (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                             {
-                               FStar_Syntax_Syntax.ppname =
-                                 (uu___6.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (uu___6.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = uu___7
-                             } in
-                           {
-                             FStar_Syntax_Syntax.binder_bv = uu___5;
-                             FStar_Syntax_Syntax.binder_qual =
-                               (b.FStar_Syntax_Syntax.binder_qual);
-                             FStar_Syntax_Syntax.binder_attrs =
-                               (b.FStar_Syntax_Syntax.binder_attrs)
-                           }) effect_binders in
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 = FStar_Syntax_Subst.compress signature_un in
-                        uu___7.FStar_Syntax_Syntax.n in
-                      match uu___6 with
-                      | FStar_Syntax_Syntax.Tm_arrow
-                          ({ FStar_Syntax_Syntax.binder_bv = a;
-                             FStar_Syntax_Syntax.binder_qual = uu___7;
-                             FStar_Syntax_Syntax.binder_attrs = uu___8;_}::[],
-                           effect_marker)
-                          -> (a, effect_marker)
-                      | uu___7 ->
-                          raise_error
-                            (FStar_Errors.Fatal_BadSignatureShape,
-                              "bad shape for effect-for-free signature") in
-                    (match uu___5 with
-                     | (a, effect_marker) ->
-                         let a1 =
-                           let uu___6 = FStar_Syntax_Syntax.is_null_bv a in
-                           if uu___6
-                           then
-                             let uu___7 =
-                               let uu___8 = FStar_Syntax_Syntax.range_of_bv a in
-                               FStar_Pervasives_Native.Some uu___8 in
-                             FStar_Syntax_Syntax.gen_bv "a" uu___7
-                               a.FStar_Syntax_Syntax.sort
-                           else a in
-                         let open_and_check env3 other_binders t =
-                           let subst =
-                             FStar_Syntax_Subst.opening_of_binders
-                               (FStar_Compiler_List.op_At effect_binders1
-                                  other_binders) in
-                           let t1 = FStar_Syntax_Subst.subst subst t in
-                           let uu___6 =
-                             FStar_TypeChecker_TcTerm.tc_term env3 t1 in
-                           match uu___6 with
-                           | (t2, comp, uu___7) -> (t2, comp) in
-                         let mk x =
-                           FStar_Syntax_Syntax.mk x
-                             signature.FStar_Syntax_Syntax.pos in
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_Compiler_Effect.op_Bar_Greater ed
-                                   FStar_Syntax_Util.get_eff_repr in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                 FStar_Compiler_Util.must in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___8
-                               FStar_Pervasives_Native.snd in
-                           open_and_check env2 [] uu___7 in
-                         (match uu___6 with
-                          | (repr, _comp) ->
-                              ((let uu___8 =
-                                  FStar_TypeChecker_Env.debug env2
-                                    (FStar_Options.Other "ED") in
-                                if uu___8
-                                then
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string repr in
-                                  FStar_Compiler_Util.print1
-                                    "Representation is: %s\n" uu___9
-                                else ());
-                               (let ed_range =
-                                  FStar_TypeChecker_Env.get_range env2 in
-                                let dmff_env =
-                                  empty env2
-                                    (FStar_TypeChecker_TcTerm.tc_constant
-                                       env2 FStar_Compiler_Range.dummyRange) in
-                                let wp_type = star_type dmff_env repr in
-                                let uu___8 = recheck_debug "*" env2 wp_type in
-                                let wp_a =
-                                  let uu___9 =
-                                    let uu___10 =
-                                      let uu___11 =
-                                        let uu___12 =
-                                          let uu___13 =
-                                            let uu___14 =
-                                              FStar_Syntax_Syntax.bv_to_name
-                                                a1 in
-                                            let uu___15 =
-                                              FStar_Syntax_Syntax.as_aqual_implicit
-                                                false in
-                                            (uu___14, uu___15) in
-                                          [uu___13] in
-                                        (wp_type, uu___12) in
-                                      FStar_Syntax_Syntax.Tm_app uu___11 in
-                                    mk uu___10 in
-                                  FStar_TypeChecker_Normalize.normalize
-                                    [FStar_TypeChecker_Env.Beta] env2 uu___9 in
-                                let effect_signature =
-                                  let binders =
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_Syntax_Syntax.as_bqual_implicit
-                                          false in
-                                      FStar_Syntax_Syntax.mk_binder_with_attrs
-                                        a1 uu___10 [] in
-                                    let uu___10 =
-                                      let uu___11 =
-                                        let uu___12 =
-                                          FStar_Syntax_Syntax.gen_bv
-                                            "dijkstra_wp"
-                                            FStar_Pervasives_Native.None wp_a in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___12
-                                          FStar_Syntax_Syntax.mk_binder in
-                                      [uu___11] in
-                                    uu___9 :: uu___10 in
-                                  let binders1 =
-                                    FStar_Syntax_Subst.close_binders binders in
-                                  mk
-                                    (FStar_Syntax_Syntax.Tm_arrow
-                                       (binders1, effect_marker)) in
-                                let uu___9 =
-                                  recheck_debug
-                                    "turned into the effect signature" env2
-                                    effect_signature in
-                                let sigelts = FStar_Compiler_Util.mk_ref [] in
-                                let mk_lid name =
-                                  FStar_Syntax_Util.dm4f_lid ed name in
-                                let elaborate_and_star dmff_env1
-                                  other_binders item =
-                                  let env3 = get_env dmff_env1 in
-                                  let uu___10 = item in
-                                  match uu___10 with
-                                  | (u_item, item1) ->
-                                      let uu___11 =
-                                        open_and_check env3 other_binders
-                                          item1 in
-                                      (match uu___11 with
-                                       | (item2, item_comp) ->
-                                           ((let uu___13 =
-                                               let uu___14 =
-                                                 FStar_TypeChecker_Common.is_total_lcomp
-                                                   item_comp in
-                                               Prims.op_Negation uu___14 in
-                                             if uu___13
-                                             then
-                                               let uu___14 =
-                                                 let uu___15 =
-                                                   let uu___16 =
-                                                     FStar_Syntax_Print.term_to_string
-                                                       item2 in
-                                                   let uu___17 =
-                                                     FStar_TypeChecker_Common.lcomp_to_string
-                                                       item_comp in
-                                                   FStar_Compiler_Util.format2
-                                                     "Computation for [%s] is not total : %s !"
-                                                     uu___16 uu___17 in
-                                                 (FStar_Errors.Fatal_ComputationNotTotal,
-                                                   uu___15) in
-                                               FStar_Errors.raise_err uu___14
-                                             else ());
-                                            (let uu___13 =
-                                               star_expr dmff_env1 item2 in
-                                             match uu___13 with
-                                             | (item_t, item_wp, item_elab)
-                                                 ->
-                                                 let uu___14 =
-                                                   recheck_debug "*" env3
-                                                     item_wp in
-                                                 let uu___15 =
-                                                   recheck_debug "_" env3
-                                                     item_elab in
-                                                 (dmff_env1, item_t, item_wp,
-                                                   item_elab)))) in
-                                let uu___10 =
-                                  let uu___11 =
-                                    let uu___12 =
-                                      FStar_Compiler_Effect.op_Bar_Greater ed
-                                        FStar_Syntax_Util.get_bind_repr in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___12 FStar_Compiler_Util.must in
-                                  elaborate_and_star dmff_env [] uu___11 in
-                                match uu___10 with
-                                | (dmff_env1, uu___11, bind_wp, bind_elab) ->
-                                    let uu___12 =
-                                      let uu___13 =
-                                        let uu___14 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            ed
-                                            FStar_Syntax_Util.get_return_repr in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___14 FStar_Compiler_Util.must in
-                                      elaborate_and_star dmff_env1 [] uu___13 in
-                                    (match uu___12 with
-                                     | (dmff_env2, uu___13, return_wp,
-                                        return_elab) ->
-                                         let rc_gtot =
-                                           {
-                                             FStar_Syntax_Syntax.residual_effect
-                                               =
-                                               FStar_Parser_Const.effect_GTot_lid;
-                                             FStar_Syntax_Syntax.residual_typ
-                                               = FStar_Pervasives_Native.None;
-                                             FStar_Syntax_Syntax.residual_flags
-                                               = []
-                                           } in
-                                         let lift_from_pure_wp =
-                                           let uu___14 =
-                                             let uu___15 =
-                                               FStar_Syntax_Subst.compress
-                                                 return_wp in
-                                             uu___15.FStar_Syntax_Syntax.n in
-                                           match uu___14 with
-                                           | FStar_Syntax_Syntax.Tm_abs
-                                               (b1::b2::bs, body, what) ->
-                                               let uu___15 =
-                                                 let uu___16 =
-                                                   let uu___17 =
-                                                     FStar_Syntax_Util.abs bs
-                                                       body
-                                                       FStar_Pervasives_Native.None in
-                                                   FStar_Syntax_Subst.open_term
-                                                     [b1; b2] uu___17 in
-                                                 match uu___16 with
-                                                 | (b11::b21::[], body1) ->
-                                                     (b11, b21, body1)
-                                                 | uu___17 ->
-                                                     failwith
-                                                       "Impossible : open_term not preserving binders arity" in
-                                               (match uu___15 with
-                                                | (b11, b21, body1) ->
-                                                    let env0 =
-                                                      let uu___16 =
-                                                        get_env dmff_env2 in
-                                                      FStar_TypeChecker_Env.push_binders
-                                                        uu___16 [b11; b21] in
-                                                    let wp_b1 =
-                                                      let raw_wp_b1 =
-                                                        let uu___16 =
-                                                          let uu___17 =
-                                                            let uu___18 =
-                                                              let uu___19 =
-                                                                let uu___20 =
-                                                                  FStar_Syntax_Syntax.bv_to_name
-                                                                    b11.FStar_Syntax_Syntax.binder_bv in
-                                                                let uu___21 =
-                                                                  FStar_Syntax_Syntax.as_aqual_implicit
-                                                                    false in
-                                                                (uu___20,
-                                                                  uu___21) in
-                                                              [uu___19] in
-                                                            (wp_type,
-                                                              uu___18) in
-                                                          FStar_Syntax_Syntax.Tm_app
-                                                            uu___17 in
-                                                        mk uu___16 in
-                                                      FStar_TypeChecker_Normalize.normalize
-                                                        [FStar_TypeChecker_Env.Beta]
-                                                        env0 raw_wp_b1 in
-                                                    let uu___16 =
-                                                      let uu___17 =
-                                                        let uu___18 =
-                                                          FStar_Syntax_Util.unascribe
-                                                            wp_b1 in
-                                                        FStar_TypeChecker_Normalize.eta_expand_with_type
-                                                          env0 body1 uu___18 in
-                                                      FStar_Compiler_Effect.op_Less_Bar
-                                                        FStar_Syntax_Util.abs_formals
-                                                        uu___17 in
-                                                    (match uu___16 with
-                                                     | (bs1, body2, what') ->
-                                                         let fail uu___17 =
-                                                           let error_msg =
-                                                             let uu___18 =
-                                                               FStar_Syntax_Print.term_to_string
-                                                                 body2 in
-                                                             let uu___19 =
-                                                               match what'
-                                                               with
-                                                               | FStar_Pervasives_Native.None
-                                                                   -> "None"
-                                                               | FStar_Pervasives_Native.Some
-                                                                   rc ->
-                                                                   FStar_Ident.string_of_lid
-                                                                    rc.FStar_Syntax_Syntax.residual_effect in
-                                                             FStar_Compiler_Util.format2
-                                                               "The body of return_wp (%s) should be of type Type0 but is of type %s"
-                                                               uu___18
-                                                               uu___19 in
-                                                           raise_error
-                                                             (FStar_Errors.Fatal_WrongBodyTypeForReturnWP,
-                                                               error_msg) in
-                                                         ((match what' with
-                                                           | FStar_Pervasives_Native.None
-                                                               -> fail ()
-                                                           | FStar_Pervasives_Native.Some
-                                                               rc ->
-                                                               ((let uu___19
-                                                                   =
-                                                                   let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Util.is_pure_effect
-                                                                    rc.FStar_Syntax_Syntax.residual_effect in
-                                                                   Prims.op_Negation
-                                                                    uu___20 in
-                                                                 if uu___19
-                                                                 then fail ()
-                                                                 else ());
-                                                                (let uu___19
-                                                                   =
-                                                                   FStar_Compiler_Util.map_opt
-                                                                    rc.FStar_Syntax_Syntax.residual_typ
-                                                                    (fun rt
-                                                                    ->
-                                                                    let g_opt
-                                                                    =
-                                                                    FStar_TypeChecker_Rel.try_teq
-                                                                    true env2
-                                                                    rt
-                                                                    FStar_Syntax_Util.ktype0 in
-                                                                    match g_opt
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    g' ->
-                                                                    FStar_TypeChecker_Rel.force_trivial_guard
-                                                                    env2 g'
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    fail ()) in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___19
-                                                                   (fun
-                                                                    uu___20
-                                                                    -> ()))));
-                                                          (let wp =
-                                                             let t2 =
-                                                               (b21.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                             let pure_wp_type
-                                                               =
-                                                               double_star t2 in
-                                                             FStar_Syntax_Syntax.gen_bv
-                                                               "wp"
-                                                               FStar_Pervasives_Native.None
-                                                               pure_wp_type in
-                                                           let body3 =
-                                                             let uu___18 =
-                                                               FStar_Syntax_Syntax.bv_to_name
-                                                                 wp in
-                                                             let uu___19 =
-                                                               let uu___20 =
-                                                                 let uu___21
-                                                                   =
-                                                                   FStar_Syntax_Util.abs
-                                                                    [b21]
-                                                                    body2
-                                                                    what' in
-                                                                 (uu___21,
-                                                                   FStar_Pervasives_Native.None) in
-                                                               [uu___20] in
-                                                             FStar_Syntax_Syntax.mk_Tm_app
-                                                               uu___18
-                                                               uu___19
-                                                               ed_range in
-                                                           let uu___18 =
-                                                             let uu___19 =
-                                                               let uu___20 =
-                                                                 FStar_Syntax_Syntax.mk_binder
-                                                                   wp in
-                                                               [uu___20] in
-                                                             b11 :: uu___19 in
-                                                           let uu___19 =
-                                                             FStar_Syntax_Util.abs
-                                                               bs1 body3 what in
-                                                           FStar_Syntax_Util.abs
-                                                             uu___18 uu___19
-                                                             (FStar_Pervasives_Native.Some
-                                                                rc_gtot)))))
-                                           | uu___15 ->
-                                               raise_error
-                                                 (FStar_Errors.Fatal_UnexpectedReturnShape,
-                                                   "unexpected shape for return") in
-                                         let return_wp1 =
-                                           let uu___14 =
-                                             let uu___15 =
-                                               FStar_Syntax_Subst.compress
-                                                 return_wp in
-                                             uu___15.FStar_Syntax_Syntax.n in
-                                           match uu___14 with
-                                           | FStar_Syntax_Syntax.Tm_abs
-                                               (b1::b2::bs, body, what) ->
-                                               let uu___15 =
-                                                 FStar_Syntax_Util.abs bs
-                                                   body what in
-                                               FStar_Syntax_Util.abs 
-                                                 [b1; b2] uu___15
-                                                 (FStar_Pervasives_Native.Some
-                                                    rc_gtot)
-                                           | uu___15 ->
-                                               raise_error
-                                                 (FStar_Errors.Fatal_UnexpectedReturnShape,
-                                                   "unexpected shape for return") in
-                                         let bind_wp1 =
-                                           let uu___14 =
-                                             let uu___15 =
-                                               FStar_Syntax_Subst.compress
-                                                 bind_wp in
-                                             uu___15.FStar_Syntax_Syntax.n in
-                                           match uu___14 with
-                                           | FStar_Syntax_Syntax.Tm_abs
-                                               (binders, body, what) ->
-                                               FStar_Syntax_Util.abs binders
-                                                 body what
-                                           | uu___15 ->
-                                               raise_error
-                                                 (FStar_Errors.Fatal_UnexpectedBindShape,
-                                                   "unexpected shape for bind") in
-                                         let apply_close t =
-                                           if
-                                             (FStar_Compiler_List.length
-                                                effect_binders1)
-                                               = Prims.int_zero
-                                           then t
-                                           else
-                                             (let uu___15 =
-                                                let uu___16 =
-                                                  let uu___17 =
-                                                    let uu___18 =
-                                                      let uu___19 =
-                                                        FStar_Syntax_Util.args_of_binders
-                                                          effect_binders1 in
-                                                      FStar_Pervasives_Native.snd
-                                                        uu___19 in
-                                                    (t, uu___18) in
-                                                  FStar_Syntax_Syntax.Tm_app
-                                                    uu___17 in
-                                                mk uu___16 in
-                                              FStar_Syntax_Subst.close
-                                                effect_binders1 uu___15) in
-                                         let rec apply_last f l =
-                                           match l with
-                                           | [] ->
-                                               failwith
-                                                 "impossible: empty path.."
-                                           | a2::[] ->
-                                               let uu___14 = f a2 in
-                                               [uu___14]
-                                           | x::xs ->
-                                               let uu___14 = apply_last f xs in
-                                               x :: uu___14 in
-                                         let register maybe_admit name item =
-                                           let maybe_admit1 = true in
-                                           let p =
-                                             FStar_Ident.path_of_lid
-                                               ed.FStar_Syntax_Syntax.mname in
-                                           let p' =
-                                             apply_last
-                                               (fun s ->
-                                                  Prims.op_Hat "__"
-                                                    (Prims.op_Hat s
-                                                       (Prims.op_Hat
-                                                          "_eff_override_"
-                                                          name))) p in
-                                           let l' =
-                                             FStar_Ident.lid_of_path p'
-                                               ed_range in
-                                           let uu___14 =
-                                             FStar_TypeChecker_Env.try_lookup_lid
-                                               env2 l' in
-                                           match uu___14 with
-                                           | FStar_Pervasives_Native.Some
-                                               (_us, _t) ->
-                                               ((let uu___16 =
-                                                   FStar_Options.debug_any () in
-                                                 if uu___16
-                                                 then
-                                                   let uu___17 =
-                                                     FStar_Ident.string_of_lid
-                                                       l' in
-                                                   FStar_Compiler_Util.print1
-                                                     "DM4F: Applying override %s\n"
-                                                     uu___17
-                                                 else ());
-                                                (let uu___16 =
-                                                   FStar_Syntax_Syntax.lid_as_fv
-                                                     l'
-                                                     FStar_Syntax_Syntax.delta_equational
-                                                     FStar_Pervasives_Native.None in
-                                                 FStar_Syntax_Syntax.fv_to_tm
-                                                   uu___16))
-                                           | FStar_Pervasives_Native.None ->
-                                               let uu___15 =
-                                                 let uu___16 = mk_lid name in
-                                                 let uu___17 =
-                                                   FStar_Syntax_Util.abs
-                                                     effect_binders1 item
-                                                     FStar_Pervasives_Native.None in
-                                                 FStar_TypeChecker_Util.mk_toplevel_definition
-                                                   env2 uu___16 uu___17 in
-                                               (match uu___15 with
-                                                | (sigelt, fv) ->
-                                                    let sigelt1 =
-                                                      if maybe_admit1
-                                                      then
-                                                        {
-                                                          FStar_Syntax_Syntax.sigel
-                                                            =
-                                                            (sigelt.FStar_Syntax_Syntax.sigel);
-                                                          FStar_Syntax_Syntax.sigrng
-                                                            =
-                                                            (sigelt.FStar_Syntax_Syntax.sigrng);
-                                                          FStar_Syntax_Syntax.sigquals
-                                                            =
-                                                            (sigelt.FStar_Syntax_Syntax.sigquals);
-                                                          FStar_Syntax_Syntax.sigmeta
-                                                            =
-                                                            (let uu___16 =
-                                                               sigelt.FStar_Syntax_Syntax.sigmeta in
-                                                             {
-                                                               FStar_Syntax_Syntax.sigmeta_active
-                                                                 =
-                                                                 (uu___16.FStar_Syntax_Syntax.sigmeta_active);
-                                                               FStar_Syntax_Syntax.sigmeta_fact_db_ids
-                                                                 =
-                                                                 (uu___16.FStar_Syntax_Syntax.sigmeta_fact_db_ids);
-                                                               FStar_Syntax_Syntax.sigmeta_admit
-                                                                 = true
-                                                             });
-                                                          FStar_Syntax_Syntax.sigattrs
-                                                            =
-                                                            (sigelt.FStar_Syntax_Syntax.sigattrs);
-                                                          FStar_Syntax_Syntax.sigopts
-                                                            =
-                                                            (sigelt.FStar_Syntax_Syntax.sigopts)
-                                                        }
-                                                      else sigelt in
-                                                    ((let uu___17 =
-                                                        let uu___18 =
-                                                          FStar_Compiler_Effect.op_Bang
-                                                            sigelts in
-                                                        sigelt1 :: uu___18 in
-                                                      FStar_Compiler_Effect.op_Colon_Equals
-                                                        sigelts uu___17);
-                                                     fv)) in
-                                         let register_admit = register true in
-                                         let register1 = register false in
-                                         let lift_from_pure_wp1 =
-                                           register1 "lift_from_pure"
-                                             lift_from_pure_wp in
-                                         let mk_sigelt se =
-                                           let uu___14 =
-                                             FStar_Syntax_Syntax.mk_sigelt se in
-                                           {
-                                             FStar_Syntax_Syntax.sigel =
-                                               (uu___14.FStar_Syntax_Syntax.sigel);
-                                             FStar_Syntax_Syntax.sigrng =
-                                               ed_range;
-                                             FStar_Syntax_Syntax.sigquals =
-                                               (uu___14.FStar_Syntax_Syntax.sigquals);
-                                             FStar_Syntax_Syntax.sigmeta =
-                                               (uu___14.FStar_Syntax_Syntax.sigmeta);
-                                             FStar_Syntax_Syntax.sigattrs =
-                                               (uu___14.FStar_Syntax_Syntax.sigattrs);
-                                             FStar_Syntax_Syntax.sigopts =
-                                               (uu___14.FStar_Syntax_Syntax.sigopts)
-                                           } in
-                                         let return_wp2 =
-                                           register1 "return_wp" return_wp1 in
-                                         let return_elab1 =
-                                           register_admit "return_elab"
-                                             return_elab in
-                                         let bind_wp2 =
-                                           register1 "bind_wp" bind_wp1 in
-                                         let bind_elab1 =
-                                           register_admit "bind_elab"
-                                             bind_elab in
-                                         let uu___14 =
-                                           FStar_Compiler_List.fold_left
-                                             (fun uu___15 ->
-                                                fun action ->
-                                                  match uu___15 with
-                                                  | (dmff_env3, actions) ->
-                                                      let params_un =
-                                                        FStar_Syntax_Subst.open_binders
-                                                          action.FStar_Syntax_Syntax.action_params in
-                                                      let uu___16 =
-                                                        let uu___17 =
-                                                          get_env dmff_env3 in
-                                                        FStar_TypeChecker_TcTerm.tc_tparams
-                                                          uu___17 params_un in
-                                                      (match uu___16 with
-                                                       | (action_params,
-                                                          env', uu___17) ->
-                                                           let action_params1
-                                                             =
-                                                             FStar_Compiler_List.map
-                                                               (fun b ->
-                                                                  let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    b.FStar_Syntax_Syntax.binder_bv in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_TypeChecker_Normalize.normalize
-                                                                    [FStar_TypeChecker_Env.EraseUniverses]
-                                                                    env'
-                                                                    (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.ppname
-                                                                    =
-                                                                    (uu___19.FStar_Syntax_Syntax.ppname);
-                                                                    FStar_Syntax_Syntax.index
-                                                                    =
-                                                                    (uu___19.FStar_Syntax_Syntax.index);
-                                                                    FStar_Syntax_Syntax.sort
-                                                                    = uu___20
-                                                                    } in
-                                                                  {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = uu___18;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_qual);
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_attrs)
-                                                                  })
-                                                               action_params in
-                                                           let dmff_env' =
-                                                             set_env
-                                                               dmff_env3 env' in
-                                                           let uu___18 =
-                                                             elaborate_and_star
-                                                               dmff_env'
-                                                               action_params1
-                                                               ((action.FStar_Syntax_Syntax.action_univs),
-                                                                 (action.FStar_Syntax_Syntax.action_defn)) in
-                                                           (match uu___18
-                                                            with
-                                                            | (dmff_env4,
-                                                               action_t,
-                                                               action_wp,
-                                                               action_elab)
-                                                                ->
-                                                                let name =
-                                                                  let uu___19
-                                                                    =
-                                                                    FStar_Ident.ident_of_lid
-                                                                    action.FStar_Syntax_Syntax.action_name in
-                                                                  FStar_Ident.string_of_id
-                                                                    uu___19 in
-                                                                let action_typ_with_wp
-                                                                  =
-                                                                  trans_F
-                                                                    dmff_env'
-                                                                    action_t
-                                                                    action_wp in
-                                                                let action_params2
-                                                                  =
-                                                                  FStar_Syntax_Subst.close_binders
-                                                                    action_params1 in
-                                                                let action_elab1
-                                                                  =
-                                                                  FStar_Syntax_Subst.close
-                                                                    action_params2
-                                                                    action_elab in
-                                                                let action_typ_with_wp1
-                                                                  =
-                                                                  FStar_Syntax_Subst.close
-                                                                    action_params2
-                                                                    action_typ_with_wp in
-                                                                let action_elab2
-                                                                  =
-                                                                  FStar_Syntax_Util.abs
-                                                                    action_params2
-                                                                    action_elab1
-                                                                    FStar_Pervasives_Native.None in
-                                                                let action_typ_with_wp2
-                                                                  =
-                                                                  match action_params2
-                                                                  with
-                                                                  | [] ->
-                                                                    action_typ_with_wp1
-                                                                  | uu___19
-                                                                    ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    action_typ_with_wp1 in
-                                                                    FStar_Syntax_Util.flat_arrow
-                                                                    action_params2
-                                                                    uu___20 in
-                                                                ((let uu___20
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env2)
-                                                                    (FStar_Options.Other
-                                                                    "ED") in
-                                                                  if uu___20
-                                                                  then
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Print.binders_to_string
-                                                                    ","
-                                                                    params_un in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Print.binders_to_string
-                                                                    ","
-                                                                    action_params2 in
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    action_typ_with_wp2 in
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    action_elab2 in
-                                                                    FStar_Compiler_Util.print4
-                                                                    "original action_params %s, end action_params %s, type %s, term %s\n"
-                                                                    uu___21
-                                                                    uu___22
-                                                                    uu___23
-                                                                    uu___24
-                                                                  else ());
-                                                                 (let action_elab3
-                                                                    =
-                                                                    register1
-                                                                    (Prims.op_Hat
-                                                                    name
-                                                                    "_elab")
-                                                                    action_elab2 in
-                                                                  let action_typ_with_wp3
-                                                                    =
-                                                                    register1
-                                                                    (Prims.op_Hat
-                                                                    name
-                                                                    "_complete_type")
-                                                                    action_typ_with_wp2 in
-                                                                  let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    apply_close
-                                                                    action_elab3 in
-                                                                    let uu___23
-                                                                    =
-                                                                    apply_close
-                                                                    action_typ_with_wp3 in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.action_name
-                                                                    =
-                                                                    (action.FStar_Syntax_Syntax.action_name);
-                                                                    FStar_Syntax_Syntax.action_unqualified_name
-                                                                    =
-                                                                    (action.FStar_Syntax_Syntax.action_unqualified_name);
-                                                                    FStar_Syntax_Syntax.action_univs
-                                                                    =
-                                                                    (action.FStar_Syntax_Syntax.action_univs);
-                                                                    FStar_Syntax_Syntax.action_params
-                                                                    = [];
-                                                                    FStar_Syntax_Syntax.action_defn
-                                                                    = uu___22;
-                                                                    FStar_Syntax_Syntax.action_typ
-                                                                    = uu___23
-                                                                    } in
-                                                                    uu___21
-                                                                    ::
-                                                                    actions in
-                                                                  (dmff_env4,
-                                                                    uu___20))))))
-                                             (dmff_env2, [])
-                                             ed.FStar_Syntax_Syntax.actions in
-                                         (match uu___14 with
-                                          | (dmff_env3, actions) ->
-                                              let actions1 =
-                                                FStar_Compiler_List.rev
-                                                  actions in
-                                              let repr1 =
-                                                let wp =
-                                                  FStar_Syntax_Syntax.gen_bv
-                                                    "wp_a"
-                                                    FStar_Pervasives_Native.None
-                                                    wp_a in
-                                                let binders =
-                                                  let uu___15 =
-                                                    FStar_Syntax_Syntax.mk_binder
-                                                      a1 in
-                                                  let uu___16 =
-                                                    let uu___17 =
-                                                      FStar_Syntax_Syntax.mk_binder
-                                                        wp in
-                                                    [uu___17] in
-                                                  uu___15 :: uu___16 in
-                                                let uu___15 =
-                                                  let uu___16 =
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        let uu___19 =
-                                                          let uu___20 =
-                                                            let uu___21 =
-                                                              FStar_Syntax_Syntax.bv_to_name
-                                                                a1 in
-                                                            let uu___22 =
-                                                              FStar_Syntax_Syntax.as_aqual_implicit
-                                                                false in
-                                                            (uu___21,
-                                                              uu___22) in
-                                                          [uu___20] in
-                                                        (repr, uu___19) in
-                                                      FStar_Syntax_Syntax.Tm_app
-                                                        uu___18 in
-                                                    mk uu___17 in
-                                                  let uu___17 =
-                                                    FStar_Syntax_Syntax.bv_to_name
-                                                      wp in
-                                                  trans_F dmff_env3 uu___16
-                                                    uu___17 in
-                                                FStar_Syntax_Util.abs binders
-                                                  uu___15
-                                                  FStar_Pervasives_Native.None in
-                                              let uu___15 =
-                                                recheck_debug "FC" env2 repr1 in
-                                              let repr2 =
-                                                register1 "repr" repr1 in
-                                              let uu___16 =
-                                                let uu___17 =
-                                                  let uu___18 =
-                                                    let uu___19 =
-                                                      FStar_Syntax_Subst.compress
-                                                        wp_type in
-                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                      FStar_Syntax_Util.unascribe
-                                                      uu___19 in
-                                                  uu___18.FStar_Syntax_Syntax.n in
-                                                match uu___17 with
-                                                | FStar_Syntax_Syntax.Tm_abs
-                                                    (type_param::effect_param,
-                                                     arrow, uu___18)
-                                                    ->
-                                                    let uu___19 =
-                                                      let uu___20 =
-                                                        FStar_Syntax_Subst.open_term
-                                                          (type_param ::
-                                                          effect_param) arrow in
-                                                      match uu___20 with
-                                                      | (b::bs, body) ->
-                                                          (b, bs, body)
-                                                      | uu___21 ->
-                                                          failwith
-                                                            "Impossible : open_term nt preserving binders arity" in
-                                                    (match uu___19 with
-                                                     | (type_param1,
-                                                        effect_param1,
-                                                        arrow1) ->
-                                                         let uu___20 =
-                                                           let uu___21 =
-                                                             let uu___22 =
-                                                               FStar_Syntax_Subst.compress
-                                                                 arrow1 in
-                                                             FStar_Compiler_Effect.op_Less_Bar
-                                                               FStar_Syntax_Util.unascribe
-                                                               uu___22 in
-                                                           uu___21.FStar_Syntax_Syntax.n in
-                                                         (match uu___20 with
-                                                          | FStar_Syntax_Syntax.Tm_arrow
-                                                              (wp_binders, c)
-                                                              ->
-                                                              let uu___21 =
-                                                                FStar_Syntax_Subst.open_comp
-                                                                  wp_binders
-                                                                  c in
-                                                              (match uu___21
-                                                               with
-                                                               | (wp_binders1,
-                                                                  c1) ->
-                                                                   let uu___22
-                                                                    =
-                                                                    FStar_Compiler_List.partition
-                                                                    (fun
-                                                                    uu___23
-                                                                    ->
-                                                                    match uu___23
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = bv;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___24;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___25;_}
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Free.names
-                                                                    bv.FStar_Syntax_Syntax.sort in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___27
-                                                                    (FStar_Compiler_Util.set_mem
-                                                                    type_param1.FStar_Syntax_Syntax.binder_bv) in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___26
-                                                                    Prims.op_Negation)
-                                                                    wp_binders1 in
-                                                                   (match uu___22
-                                                                    with
-                                                                    | 
-                                                                    (pre_args,
-                                                                    post_args)
-                                                                    ->
-                                                                    let post
-                                                                    =
-                                                                    match post_args
-                                                                    with
-                                                                    | 
-                                                                    post1::[]
-                                                                    -> post1
-                                                                    | 
-                                                                    [] ->
-                                                                    let err_msg
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    arrow1 in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "Impossible to generate DM effect: no post candidate %s (Type variable does not appear)"
-                                                                    uu___23 in
-                                                                    FStar_Errors.raise_err
-                                                                    (FStar_Errors.Fatal_ImpossibleToGenerateDMEffect,
-                                                                    err_msg)
-                                                                    | 
-                                                                    uu___23
-                                                                    ->
-                                                                    let err_msg
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    arrow1 in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "Impossible to generate DM effect: multiple post candidates %s"
-                                                                    uu___24 in
-                                                                    FStar_Errors.raise_err
-                                                                    (FStar_Errors.Fatal_ImpossibleToGenerateDMEffect,
-                                                                    err_msg) in
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Util.arrow
-                                                                    pre_args
-                                                                    c1 in
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Util.abs
-                                                                    (type_param1
-                                                                    ::
-                                                                    effect_param1)
-                                                                    (post.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                                    FStar_Pervasives_Native.None in
-                                                                    (uu___23,
-                                                                    uu___24)))
-                                                          | uu___21 ->
-                                                              let uu___22 =
-                                                                let uu___23 =
-                                                                  let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    arrow1 in
-                                                                  FStar_Compiler_Util.format1
-                                                                    "Impossible: pre/post arrow %s"
-                                                                    uu___24 in
-                                                                (FStar_Errors.Fatal_ImpossiblePrePostArrow,
-                                                                  uu___23) in
-                                                              raise_error
-                                                                uu___22))
-                                                | uu___18 ->
-                                                    let uu___19 =
-                                                      let uu___20 =
-                                                        let uu___21 =
-                                                          FStar_Syntax_Print.term_to_string
-                                                            wp_type in
-                                                        FStar_Compiler_Util.format1
-                                                          "Impossible: pre/post abs %s"
-                                                          uu___21 in
-                                                      (FStar_Errors.Fatal_ImpossiblePrePostAbs,
-                                                        uu___20) in
-                                                    raise_error uu___19 in
-                                              (match uu___16 with
-                                               | (pre, post) ->
-                                                   ((let uu___18 =
-                                                       register1 "pre" pre in
-                                                     ());
-                                                    (let uu___19 =
-                                                       register1 "post" post in
-                                                     ());
-                                                    (let uu___20 =
-                                                       register1 "wp" wp_type in
-                                                     ());
-                                                    (let ed_combs =
-                                                       match ed.FStar_Syntax_Syntax.combinators
-                                                       with
-                                                       | FStar_Syntax_Syntax.DM4F_eff
-                                                           combs ->
-                                                           let uu___20 =
-                                                             let uu___21 =
-                                                               let uu___22 =
-                                                                 apply_close
-                                                                   return_wp2 in
-                                                               ([], uu___22) in
-                                                             let uu___22 =
-                                                               let uu___23 =
-                                                                 apply_close
-                                                                   bind_wp2 in
-                                                               ([], uu___23) in
-                                                             let uu___23 =
-                                                               let uu___24 =
-                                                                 let uu___25
-                                                                   =
-                                                                   apply_close
-                                                                    repr2 in
-                                                                 ([],
-                                                                   uu___25) in
-                                                               FStar_Pervasives_Native.Some
-                                                                 uu___24 in
-                                                             let uu___24 =
-                                                               let uu___25 =
-                                                                 let uu___26
-                                                                   =
-                                                                   apply_close
-                                                                    return_elab1 in
-                                                                 ([],
-                                                                   uu___26) in
-                                                               FStar_Pervasives_Native.Some
-                                                                 uu___25 in
-                                                             let uu___25 =
-                                                               let uu___26 =
-                                                                 let uu___27
-                                                                   =
-                                                                   apply_close
-                                                                    bind_elab1 in
-                                                                 ([],
-                                                                   uu___27) in
-                                                               FStar_Pervasives_Native.Some
-                                                                 uu___26 in
-                                                             {
-                                                               FStar_Syntax_Syntax.ret_wp
-                                                                 = uu___21;
-                                                               FStar_Syntax_Syntax.bind_wp
-                                                                 = uu___22;
-                                                               FStar_Syntax_Syntax.stronger
-                                                                 =
-                                                                 (combs.FStar_Syntax_Syntax.stronger);
-                                                               FStar_Syntax_Syntax.if_then_else
-                                                                 =
-                                                                 (combs.FStar_Syntax_Syntax.if_then_else);
-                                                               FStar_Syntax_Syntax.ite_wp
-                                                                 =
-                                                                 (combs.FStar_Syntax_Syntax.ite_wp);
-                                                               FStar_Syntax_Syntax.close_wp
-                                                                 =
-                                                                 (combs.FStar_Syntax_Syntax.close_wp);
-                                                               FStar_Syntax_Syntax.trivial
-                                                                 =
-                                                                 (combs.FStar_Syntax_Syntax.trivial);
-                                                               FStar_Syntax_Syntax.repr
-                                                                 = uu___23;
-                                                               FStar_Syntax_Syntax.return_repr
-                                                                 = uu___24;
-                                                               FStar_Syntax_Syntax.bind_repr
-                                                                 = uu___25
-                                                             } in
-                                                           FStar_Syntax_Syntax.DM4F_eff
-                                                             uu___20
-                                                       | uu___20 ->
-                                                           failwith
-                                                             "Impossible! For a DM4F effect combinators must be in DM4f_eff" in
-                                                     let ed1 =
-                                                       let uu___20 =
-                                                         FStar_Syntax_Subst.close_binders
-                                                           effect_binders1 in
-                                                       let uu___21 =
-                                                         let uu___22 =
-                                                           let uu___23 =
-                                                             FStar_Syntax_Subst.close
-                                                               effect_binders1
-                                                               effect_signature in
-                                                           ([], uu___23) in
-                                                         FStar_Syntax_Syntax.WP_eff_sig
-                                                           uu___22 in
-                                                       {
-                                                         FStar_Syntax_Syntax.mname
-                                                           =
-                                                           (ed.FStar_Syntax_Syntax.mname);
-                                                         FStar_Syntax_Syntax.cattributes
-                                                           =
-                                                           (ed.FStar_Syntax_Syntax.cattributes);
-                                                         FStar_Syntax_Syntax.univs
-                                                           =
-                                                           (ed.FStar_Syntax_Syntax.univs);
-                                                         FStar_Syntax_Syntax.binders
-                                                           = uu___20;
-                                                         FStar_Syntax_Syntax.signature
-                                                           = uu___21;
-                                                         FStar_Syntax_Syntax.combinators
-                                                           = ed_combs;
-                                                         FStar_Syntax_Syntax.actions
-                                                           = actions1;
-                                                         FStar_Syntax_Syntax.eff_attrs
-                                                           =
-                                                           (ed.FStar_Syntax_Syntax.eff_attrs)
-                                                       } in
-                                                     let uu___20 =
-                                                       gen_wps_for_free env2
-                                                         effect_binders1 a1
-                                                         wp_a ed1 in
-                                                     match uu___20 with
-                                                     | (sigelts', ed2) ->
-                                                         ((let uu___22 =
-                                                             FStar_TypeChecker_Env.debug
-                                                               env2
-                                                               (FStar_Options.Other
-                                                                  "ED") in
-                                                           if uu___22
-                                                           then
-                                                             let uu___23 =
-                                                               FStar_Syntax_Print.eff_decl_to_string
-                                                                 true ed2 in
-                                                             FStar_Compiler_Util.print_string
-                                                               uu___23
-                                                           else ());
-                                                          (let lift_from_pure_opt
-                                                             =
-                                                             if
-                                                               (FStar_Compiler_List.length
-                                                                  effect_binders1)
-                                                                 =
-                                                                 Prims.int_zero
-                                                             then
-                                                               let lift_from_pure
-                                                                 =
-                                                                 let uu___22
-                                                                   =
-                                                                   let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    apply_close
-                                                                    lift_from_pure_wp1 in
-                                                                    ([],
-                                                                    uu___24) in
-                                                                   FStar_Pervasives_Native.Some
-                                                                    uu___23 in
-                                                                 {
-                                                                   FStar_Syntax_Syntax.source
-                                                                    =
-                                                                    FStar_Parser_Const.effect_PURE_lid;
-                                                                   FStar_Syntax_Syntax.target
-                                                                    =
-                                                                    (ed2.FStar_Syntax_Syntax.mname);
-                                                                   FStar_Syntax_Syntax.lift_wp
-                                                                    = uu___22;
-                                                                   FStar_Syntax_Syntax.lift
-                                                                    =
-                                                                    FStar_Pervasives_Native.None;
-                                                                   FStar_Syntax_Syntax.kind
-                                                                    =
-                                                                    FStar_Pervasives_Native.None
-                                                                 } in
-                                                               let uu___22 =
-                                                                 mk_sigelt
-                                                                   (FStar_Syntax_Syntax.Sig_sub_effect
-                                                                    lift_from_pure) in
-                                                               FStar_Pervasives_Native.Some
-                                                                 uu___22
-                                                             else
-                                                               FStar_Pervasives_Native.None in
-                                                           let uu___22 =
-                                                             let uu___23 =
-                                                               let uu___24 =
-                                                                 FStar_Compiler_Effect.op_Bang
-                                                                   sigelts in
-                                                               FStar_Compiler_List.rev
-                                                                 uu___24 in
-                                                             FStar_Compiler_List.op_At
-                                                               uu___23
-                                                               sigelts' in
-                                                           (uu___22, ed2,
-                                                             lift_from_pure_opt))))))))))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_DeferredImplicits.ml b/src/ocaml-output/FStar_TypeChecker_DeferredImplicits.ml
deleted file mode 100644
index 0619bef2ee5..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_DeferredImplicits.ml
+++ /dev/null
@@ -1,847 +0,0 @@
-open Prims
-let (is_flex : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args_full t in
-    match uu___ with
-    | (head, _args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress head in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_uvar uu___2 -> true
-         | uu___2 -> false)
-let (flex_uvar_head :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args_full t in
-    match uu___ with
-    | (head, _args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress head in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_uvar (u, uu___2) -> u
-         | uu___2 -> failwith "Not a flex-uvar")
-type goal_type =
-  | FlexRigid of (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.term) 
-  | FlexFlex of (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.ctx_uvar)
-  
-  | Can_be_split_into of (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term
-  * FStar_Syntax_Syntax.ctx_uvar) 
-  | Imp of FStar_Syntax_Syntax.ctx_uvar 
-let (uu___is_FlexRigid : goal_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FlexRigid _0 -> true | uu___ -> false
-let (__proj__FlexRigid__item___0 :
-  goal_type -> (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.term)) =
-  fun projectee -> match projectee with | FlexRigid _0 -> _0
-let (uu___is_FlexFlex : goal_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | FlexFlex _0 -> true | uu___ -> false
-let (__proj__FlexFlex__item___0 :
-  goal_type -> (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.ctx_uvar))
-  = fun projectee -> match projectee with | FlexFlex _0 -> _0
-let (uu___is_Can_be_split_into : goal_type -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Can_be_split_into _0 -> true | uu___ -> false
-let (__proj__Can_be_split_into__item___0 :
-  goal_type ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.ctx_uvar))
-  = fun projectee -> match projectee with | Can_be_split_into _0 -> _0
-let (uu___is_Imp : goal_type -> Prims.bool) =
-  fun projectee -> match projectee with | Imp _0 -> true | uu___ -> false
-let (__proj__Imp__item___0 : goal_type -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun projectee -> match projectee with | Imp _0 -> _0
-type goal_dep =
-  {
-  goal_dep_id: Prims.int ;
-  goal_type: goal_type ;
-  goal_imp: FStar_TypeChecker_Common.implicit ;
-  assignees: FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set ;
-  goal_dep_uvars: FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set ;
-  dependences: goal_dep Prims.list FStar_Compiler_Effect.ref ;
-  visited: Prims.int FStar_Compiler_Effect.ref }
-let (__proj__Mkgoal_dep__item__goal_dep_id : goal_dep -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> goal_dep_id
-let (__proj__Mkgoal_dep__item__goal_type : goal_dep -> goal_type) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> goal_type1
-let (__proj__Mkgoal_dep__item__goal_imp :
-  goal_dep -> FStar_TypeChecker_Common.implicit) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> goal_imp
-let (__proj__Mkgoal_dep__item__assignees :
-  goal_dep -> FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> assignees
-let (__proj__Mkgoal_dep__item__goal_dep_uvars :
-  goal_dep -> FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> goal_dep_uvars
-let (__proj__Mkgoal_dep__item__dependences :
-  goal_dep -> goal_dep Prims.list FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> dependences
-let (__proj__Mkgoal_dep__item__visited :
-  goal_dep -> Prims.int FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with
-    | { goal_dep_id; goal_type = goal_type1; goal_imp; assignees;
-        goal_dep_uvars; dependences; visited;_} -> visited
-type goal_deps = goal_dep Prims.list
-let (print_uvar_set :
-  FStar_Syntax_Syntax.ctx_uvar FStar_Compiler_Util.set -> Prims.string) =
-  fun s ->
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.set_elements s in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (FStar_Compiler_List.map
-           (fun u ->
-              let uu___2 =
-                let uu___3 =
-                  FStar_Syntax_Unionfind.uvar_id
-                    u.FStar_Syntax_Syntax.ctx_uvar_head in
-                FStar_Compiler_Effect.op_Less_Bar
-                  FStar_Compiler_Util.string_of_int uu___3 in
-              Prims.op_Hat "?" uu___2)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "; ")
-let (print_goal_dep : goal_dep -> Prims.string) =
-  fun gd ->
-    let uu___ = FStar_Compiler_Util.string_of_int gd.goal_dep_id in
-    let uu___1 = print_uvar_set gd.assignees in
-    let uu___2 =
-      let uu___3 =
-        let uu___4 = FStar_Compiler_Effect.op_Bang gd.dependences in
-        FStar_Compiler_List.map
-          (fun gd1 -> FStar_Compiler_Util.string_of_int gd1.goal_dep_id)
-          uu___4 in
-      FStar_Compiler_Effect.op_Bar_Greater uu___3 (FStar_String.concat "; ") in
-    let uu___3 =
-      FStar_Syntax_Print.ctx_uvar_to_string
-        (gd.goal_imp).FStar_TypeChecker_Common.imp_uvar in
-    FStar_Compiler_Util.format4
-      "%s:{assignees=[%s], dependences=[%s]}\n\t%s\n" uu___ uu___1 uu___2
-      uu___3
-let (find_user_tac_for_uvar :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.ctx_uvar ->
-      FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun u ->
-      let rec attr_list_elements e =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Util.unmeta e in
-          FStar_Syntax_Util.head_and_args uu___1 in
-        match uu___ with
-        | (head, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.un_uinst head in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.nil_lid
-                 -> FStar_Pervasives_Native.Some []
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                uu___2::(hd, uu___3)::(tl, uu___4)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid
-                 ->
-                 (match hd.FStar_Syntax_Syntax.n with
-                  | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_string
-                      (s, uu___5)) ->
-                      let uu___6 = attr_list_elements tl in
-                      (match uu___6 with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.None
-                       | FStar_Pervasives_Native.Some tl1 ->
-                           FStar_Pervasives_Native.Some (s :: tl1))
-                  | uu___5 -> FStar_Pervasives_Native.None)
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (hd, uu___2)::(tl, uu___3)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid
-                 ->
-                 (match hd.FStar_Syntax_Syntax.n with
-                  | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_string
-                      (s, uu___4)) ->
-                      let uu___5 = attr_list_elements tl in
-                      (match uu___5 with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.None
-                       | FStar_Pervasives_Native.Some tl1 ->
-                           FStar_Pervasives_Native.Some (s :: tl1))
-                  | uu___4 -> FStar_Pervasives_Native.None)
-             | uu___2 -> FStar_Pervasives_Native.None) in
-      let candidate_names candidates =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_List.collect FStar_Syntax_Util.lids_of_sigelt
-              candidates in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_Compiler_List.map FStar_Ident.string_of_lid) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ") in
-      match u.FStar_Syntax_Syntax.ctx_uvar_meta with
-      | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Ctx_uvar_meta_attr
-          a) ->
-          let hooks =
-            FStar_TypeChecker_Env.lookup_attr env
-              FStar_Parser_Const.resolve_implicits_attr_string in
-          let candidates =
-            FStar_Compiler_Effect.op_Bar_Greater hooks
-              (FStar_Compiler_List.filter
-                 (fun hook ->
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      hook.FStar_Syntax_Syntax.sigattrs
-                      (FStar_Compiler_Util.for_some
-                         (FStar_Syntax_Util.attr_eq a)))) in
-          let candidates1 =
-            FStar_Compiler_Util.remove_dups
-              (fun s0 ->
-                 fun s1 ->
-                   let l0 = FStar_Syntax_Util.lids_of_sigelt s0 in
-                   let l1 = FStar_Syntax_Util.lids_of_sigelt s1 in
-                   if
-                     (FStar_Compiler_List.length l0) =
-                       (FStar_Compiler_List.length l1)
-                   then
-                     FStar_Compiler_List.forall2
-                       (fun l01 -> fun l11 -> FStar_Ident.lid_equals l01 l11)
-                       l0 l1
-                   else false) candidates in
-          let is_overridden candidate =
-            let candidate_lids = FStar_Syntax_Util.lids_of_sigelt candidate in
-            FStar_Compiler_Effect.op_Bar_Greater candidates1
-              (FStar_Compiler_Util.for_some
-                 (fun other ->
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      other.FStar_Syntax_Syntax.sigattrs
-                      (FStar_Compiler_Util.for_some
-                         (fun attr ->
-                            let uu___ = FStar_Syntax_Util.head_and_args attr in
-                            match uu___ with
-                            | (head, args) ->
-                                let uu___1 =
-                                  let uu___2 =
-                                    let uu___3 =
-                                      FStar_Syntax_Util.un_uinst head in
-                                    uu___3.FStar_Syntax_Syntax.n in
-                                  (uu___2, args) in
-                                (match uu___1 with
-                                 | (FStar_Syntax_Syntax.Tm_fvar fv,
-                                    uu___2::(a', uu___3)::(overrides, uu___4)::[])
-                                     when
-                                     (FStar_Syntax_Syntax.fv_eq_lid fv
-                                        FStar_Parser_Const.override_resolve_implicits_handler_lid)
-                                       && (FStar_Syntax_Util.attr_eq a a')
-                                     ->
-                                     let uu___5 =
-                                       attr_list_elements overrides in
-                                     (match uu___5 with
-                                      | FStar_Pervasives_Native.None -> false
-                                      | FStar_Pervasives_Native.Some names ->
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            names
-                                            (FStar_Compiler_Util.for_some
-                                               (fun n ->
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    candidate_lids
-                                                    (FStar_Compiler_Util.for_some
-                                                       (fun l ->
-                                                          let uu___6 =
-                                                            FStar_Ident.string_of_lid
-                                                              l in
-                                                          uu___6 = n)))))
-                                 | (FStar_Syntax_Syntax.Tm_fvar fv,
-                                    (a', uu___2)::(overrides, uu___3)::[])
-                                     when
-                                     (FStar_Syntax_Syntax.fv_eq_lid fv
-                                        FStar_Parser_Const.override_resolve_implicits_handler_lid)
-                                       && (FStar_Syntax_Util.attr_eq a a')
-                                     ->
-                                     let uu___4 =
-                                       attr_list_elements overrides in
-                                     (match uu___4 with
-                                      | FStar_Pervasives_Native.None -> false
-                                      | FStar_Pervasives_Native.Some names ->
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            names
-                                            (FStar_Compiler_Util.for_some
-                                               (fun n ->
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    candidate_lids
-                                                    (FStar_Compiler_Util.for_some
-                                                       (fun l ->
-                                                          let uu___5 =
-                                                            FStar_Ident.string_of_lid
-                                                              l in
-                                                          uu___5 = n)))))
-                                 | uu___2 -> false))))) in
-          let candidates2 =
-            FStar_Compiler_Effect.op_Bar_Greater candidates1
-              (FStar_Compiler_List.filter
-                 (fun c ->
-                    let uu___ = is_overridden c in Prims.op_Negation uu___)) in
-          (match candidates2 with
-           | [] -> FStar_Pervasives_Native.None
-           | c::[] -> FStar_Pervasives_Native.Some c
-           | uu___ ->
-               let candidates3 = candidate_names candidates2 in
-               let attr = FStar_Syntax_Print.term_to_string a in
-               ((let uu___2 =
-                   let uu___3 =
-                     FStar_Compiler_Util.format2
-                       "Multiple resolve_implicits hooks are eligible for attribute %s; \nplease resolve the ambiguity by using the `override_resolve_implicits_handler` attribute to choose among these candidates {%s}"
-                       attr candidates3 in
-                   (FStar_Errors.Warning_AmbiguousResolveImplicitsHook,
-                     uu___3) in
-                 FStar_Errors.log_issue u.FStar_Syntax_Syntax.ctx_uvar_range
-                   uu___2);
-                FStar_Pervasives_Native.None))
-      | uu___ -> FStar_Pervasives_Native.None
-let (should_defer_uvar_to_user_tac :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.ctx_uvar -> Prims.bool) =
-  fun env ->
-    fun u ->
-      if Prims.op_Negation env.FStar_TypeChecker_Env.enable_defer_to_tac
-      then false
-      else
-        (let uu___1 = find_user_tac_for_uvar env u in
-         FStar_Compiler_Option.isSome uu___1)
-let solve_goals_with_tac :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      'uuuuu ->
-        FStar_TypeChecker_Common.implicits ->
-          FStar_Syntax_Syntax.sigelt -> unit
-  =
-  fun env ->
-    fun g ->
-      fun deferred_goals ->
-        fun tac ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.current_module env in
-              FStar_Ident.string_of_lid uu___2 in
-            FStar_Pervasives_Native.Some uu___1 in
-          FStar_Profiling.profile
-            (fun uu___1 ->
-               let resolve_tac =
-                 match tac.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_let (uu___2, lid::[]) ->
-                     let qn = FStar_TypeChecker_Env.lookup_qname env lid in
-                     let fv =
-                       FStar_Syntax_Syntax.lid_as_fv lid
-                         (FStar_Syntax_Syntax.Delta_constant_at_level
-                            Prims.int_zero) FStar_Pervasives_Native.None in
-                     let dd =
-                       let uu___3 =
-                         FStar_TypeChecker_Env.delta_depth_of_qninfo fv qn in
-                       match uu___3 with
-                       | FStar_Pervasives_Native.Some dd1 -> dd1
-                       | FStar_Pervasives_Native.None ->
-                           failwith "Expected a dd" in
-                     let term =
-                       let uu___3 =
-                         FStar_Syntax_Syntax.lid_as_fv lid dd
-                           FStar_Pervasives_Native.None in
-                       FStar_Syntax_Syntax.fv_to_tm uu___3 in
-                     term
-                 | uu___2 -> failwith "Resolve_tac not found" in
-               let env1 =
-                 {
-                   FStar_TypeChecker_Env.solver =
-                     (env.FStar_TypeChecker_Env.solver);
-                   FStar_TypeChecker_Env.range =
-                     (env.FStar_TypeChecker_Env.range);
-                   FStar_TypeChecker_Env.curmodule =
-                     (env.FStar_TypeChecker_Env.curmodule);
-                   FStar_TypeChecker_Env.gamma =
-                     (env.FStar_TypeChecker_Env.gamma);
-                   FStar_TypeChecker_Env.gamma_sig =
-                     (env.FStar_TypeChecker_Env.gamma_sig);
-                   FStar_TypeChecker_Env.gamma_cache =
-                     (env.FStar_TypeChecker_Env.gamma_cache);
-                   FStar_TypeChecker_Env.modules =
-                     (env.FStar_TypeChecker_Env.modules);
-                   FStar_TypeChecker_Env.expected_typ =
-                     (env.FStar_TypeChecker_Env.expected_typ);
-                   FStar_TypeChecker_Env.sigtab =
-                     (env.FStar_TypeChecker_Env.sigtab);
-                   FStar_TypeChecker_Env.attrtab =
-                     (env.FStar_TypeChecker_Env.attrtab);
-                   FStar_TypeChecker_Env.instantiate_imp =
-                     (env.FStar_TypeChecker_Env.instantiate_imp);
-                   FStar_TypeChecker_Env.effects =
-                     (env.FStar_TypeChecker_Env.effects);
-                   FStar_TypeChecker_Env.generalize =
-                     (env.FStar_TypeChecker_Env.generalize);
-                   FStar_TypeChecker_Env.letrecs =
-                     (env.FStar_TypeChecker_Env.letrecs);
-                   FStar_TypeChecker_Env.top_level =
-                     (env.FStar_TypeChecker_Env.top_level);
-                   FStar_TypeChecker_Env.check_uvars =
-                     (env.FStar_TypeChecker_Env.check_uvars);
-                   FStar_TypeChecker_Env.use_eq_strict =
-                     (env.FStar_TypeChecker_Env.use_eq_strict);
-                   FStar_TypeChecker_Env.is_iface =
-                     (env.FStar_TypeChecker_Env.is_iface);
-                   FStar_TypeChecker_Env.admit =
-                     (env.FStar_TypeChecker_Env.admit);
-                   FStar_TypeChecker_Env.lax =
-                     (env.FStar_TypeChecker_Env.lax);
-                   FStar_TypeChecker_Env.lax_universes =
-                     (env.FStar_TypeChecker_Env.lax_universes);
-                   FStar_TypeChecker_Env.phase1 =
-                     (env.FStar_TypeChecker_Env.phase1);
-                   FStar_TypeChecker_Env.failhard =
-                     (env.FStar_TypeChecker_Env.failhard);
-                   FStar_TypeChecker_Env.nosynth =
-                     (env.FStar_TypeChecker_Env.nosynth);
-                   FStar_TypeChecker_Env.uvar_subtyping =
-                     (env.FStar_TypeChecker_Env.uvar_subtyping);
-                   FStar_TypeChecker_Env.tc_term =
-                     (env.FStar_TypeChecker_Env.tc_term);
-                   FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                     (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                   FStar_TypeChecker_Env.universe_of =
-                     (env.FStar_TypeChecker_Env.universe_of);
-                   FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                     (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                   FStar_TypeChecker_Env.teq_nosmt_force =
-                     (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                   FStar_TypeChecker_Env.subtype_nosmt_force =
-                     (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                   FStar_TypeChecker_Env.qtbl_name_and_index =
-                     (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                   FStar_TypeChecker_Env.normalized_eff_names =
-                     (env.FStar_TypeChecker_Env.normalized_eff_names);
-                   FStar_TypeChecker_Env.fv_delta_depths =
-                     (env.FStar_TypeChecker_Env.fv_delta_depths);
-                   FStar_TypeChecker_Env.proof_ns =
-                     (env.FStar_TypeChecker_Env.proof_ns);
-                   FStar_TypeChecker_Env.synth_hook =
-                     (env.FStar_TypeChecker_Env.synth_hook);
-                   FStar_TypeChecker_Env.try_solve_implicits_hook =
-                     (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                   FStar_TypeChecker_Env.splice =
-                     (env.FStar_TypeChecker_Env.splice);
-                   FStar_TypeChecker_Env.mpreprocess =
-                     (env.FStar_TypeChecker_Env.mpreprocess);
-                   FStar_TypeChecker_Env.postprocess =
-                     (env.FStar_TypeChecker_Env.postprocess);
-                   FStar_TypeChecker_Env.identifier_info =
-                     (env.FStar_TypeChecker_Env.identifier_info);
-                   FStar_TypeChecker_Env.tc_hooks =
-                     (env.FStar_TypeChecker_Env.tc_hooks);
-                   FStar_TypeChecker_Env.dsenv =
-                     (env.FStar_TypeChecker_Env.dsenv);
-                   FStar_TypeChecker_Env.nbe =
-                     (env.FStar_TypeChecker_Env.nbe);
-                   FStar_TypeChecker_Env.strict_args_tab =
-                     (env.FStar_TypeChecker_Env.strict_args_tab);
-                   FStar_TypeChecker_Env.erasable_types_tab =
-                     (env.FStar_TypeChecker_Env.erasable_types_tab);
-                   FStar_TypeChecker_Env.enable_defer_to_tac = false;
-                   FStar_TypeChecker_Env.unif_allow_ref_guards =
-                     (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                   FStar_TypeChecker_Env.erase_erasable_args =
-                     (env.FStar_TypeChecker_Env.erase_erasable_args);
-                   FStar_TypeChecker_Env.core_check =
-                     (env.FStar_TypeChecker_Env.core_check)
-                 } in
-               env1.FStar_TypeChecker_Env.try_solve_implicits_hook env1
-                 resolve_tac deferred_goals) uu___
-            "FStar.TypeChecker.DeferredImplicits.solve_goals_with_tac"
-let (solve_deferred_to_tactic_goals :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      if Prims.op_Negation env.FStar_TypeChecker_Env.enable_defer_to_tac
-      then g
-      else
-        (let deferred = g.FStar_TypeChecker_Common.deferred_to_tac in
-         let prob_as_implicit uu___1 =
-           match uu___1 with
-           | (uu___2, reason, prob) ->
-               (match prob with
-                | FStar_TypeChecker_Common.TProb tp when
-                    tp.FStar_TypeChecker_Common.relation =
-                      FStar_TypeChecker_Common.EQ
-                    ->
-                    let uu___3 = FStar_TypeChecker_Env.clear_expected_typ env in
-                    (match uu___3 with
-                     | (env1, uu___4) ->
-                         let env2 =
-                           {
-                             FStar_TypeChecker_Env.solver =
-                               (env1.FStar_TypeChecker_Env.solver);
-                             FStar_TypeChecker_Env.range =
-                               (env1.FStar_TypeChecker_Env.range);
-                             FStar_TypeChecker_Env.curmodule =
-                               (env1.FStar_TypeChecker_Env.curmodule);
-                             FStar_TypeChecker_Env.gamma =
-                               ((tp.FStar_TypeChecker_Common.logical_guard_uvar).FStar_Syntax_Syntax.ctx_uvar_gamma);
-                             FStar_TypeChecker_Env.gamma_sig =
-                               (env1.FStar_TypeChecker_Env.gamma_sig);
-                             FStar_TypeChecker_Env.gamma_cache =
-                               (env1.FStar_TypeChecker_Env.gamma_cache);
-                             FStar_TypeChecker_Env.modules =
-                               (env1.FStar_TypeChecker_Env.modules);
-                             FStar_TypeChecker_Env.expected_typ =
-                               (env1.FStar_TypeChecker_Env.expected_typ);
-                             FStar_TypeChecker_Env.sigtab =
-                               (env1.FStar_TypeChecker_Env.sigtab);
-                             FStar_TypeChecker_Env.attrtab =
-                               (env1.FStar_TypeChecker_Env.attrtab);
-                             FStar_TypeChecker_Env.instantiate_imp =
-                               (env1.FStar_TypeChecker_Env.instantiate_imp);
-                             FStar_TypeChecker_Env.effects =
-                               (env1.FStar_TypeChecker_Env.effects);
-                             FStar_TypeChecker_Env.generalize =
-                               (env1.FStar_TypeChecker_Env.generalize);
-                             FStar_TypeChecker_Env.letrecs =
-                               (env1.FStar_TypeChecker_Env.letrecs);
-                             FStar_TypeChecker_Env.top_level =
-                               (env1.FStar_TypeChecker_Env.top_level);
-                             FStar_TypeChecker_Env.check_uvars =
-                               (env1.FStar_TypeChecker_Env.check_uvars);
-                             FStar_TypeChecker_Env.use_eq_strict =
-                               (env1.FStar_TypeChecker_Env.use_eq_strict);
-                             FStar_TypeChecker_Env.is_iface =
-                               (env1.FStar_TypeChecker_Env.is_iface);
-                             FStar_TypeChecker_Env.admit =
-                               (env1.FStar_TypeChecker_Env.admit);
-                             FStar_TypeChecker_Env.lax =
-                               (env1.FStar_TypeChecker_Env.lax);
-                             FStar_TypeChecker_Env.lax_universes =
-                               (env1.FStar_TypeChecker_Env.lax_universes);
-                             FStar_TypeChecker_Env.phase1 =
-                               (env1.FStar_TypeChecker_Env.phase1);
-                             FStar_TypeChecker_Env.failhard =
-                               (env1.FStar_TypeChecker_Env.failhard);
-                             FStar_TypeChecker_Env.nosynth =
-                               (env1.FStar_TypeChecker_Env.nosynth);
-                             FStar_TypeChecker_Env.uvar_subtyping =
-                               (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                             FStar_TypeChecker_Env.tc_term =
-                               (env1.FStar_TypeChecker_Env.tc_term);
-                             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                               (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.universe_of =
-                               (env1.FStar_TypeChecker_Env.universe_of);
-                             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                               =
-                               (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.teq_nosmt_force =
-                               (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                             FStar_TypeChecker_Env.subtype_nosmt_force =
-                               (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                             FStar_TypeChecker_Env.qtbl_name_and_index =
-                               (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                             FStar_TypeChecker_Env.normalized_eff_names =
-                               (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                             FStar_TypeChecker_Env.fv_delta_depths =
-                               (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                             FStar_TypeChecker_Env.proof_ns =
-                               (env1.FStar_TypeChecker_Env.proof_ns);
-                             FStar_TypeChecker_Env.synth_hook =
-                               (env1.FStar_TypeChecker_Env.synth_hook);
-                             FStar_TypeChecker_Env.try_solve_implicits_hook =
-                               (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                             FStar_TypeChecker_Env.splice =
-                               (env1.FStar_TypeChecker_Env.splice);
-                             FStar_TypeChecker_Env.mpreprocess =
-                               (env1.FStar_TypeChecker_Env.mpreprocess);
-                             FStar_TypeChecker_Env.postprocess =
-                               (env1.FStar_TypeChecker_Env.postprocess);
-                             FStar_TypeChecker_Env.identifier_info =
-                               (env1.FStar_TypeChecker_Env.identifier_info);
-                             FStar_TypeChecker_Env.tc_hooks =
-                               (env1.FStar_TypeChecker_Env.tc_hooks);
-                             FStar_TypeChecker_Env.dsenv =
-                               (env1.FStar_TypeChecker_Env.dsenv);
-                             FStar_TypeChecker_Env.nbe =
-                               (env1.FStar_TypeChecker_Env.nbe);
-                             FStar_TypeChecker_Env.strict_args_tab =
-                               (env1.FStar_TypeChecker_Env.strict_args_tab);
-                             FStar_TypeChecker_Env.erasable_types_tab =
-                               (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                             FStar_TypeChecker_Env.enable_defer_to_tac =
-                               (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                             FStar_TypeChecker_Env.unif_allow_ref_guards =
-                               (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                             FStar_TypeChecker_Env.erase_erasable_args =
-                               (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                             FStar_TypeChecker_Env.core_check =
-                               (env1.FStar_TypeChecker_Env.core_check)
-                           } in
-                         let env_lax =
-                           {
-                             FStar_TypeChecker_Env.solver =
-                               (env2.FStar_TypeChecker_Env.solver);
-                             FStar_TypeChecker_Env.range =
-                               (env2.FStar_TypeChecker_Env.range);
-                             FStar_TypeChecker_Env.curmodule =
-                               (env2.FStar_TypeChecker_Env.curmodule);
-                             FStar_TypeChecker_Env.gamma =
-                               (env2.FStar_TypeChecker_Env.gamma);
-                             FStar_TypeChecker_Env.gamma_sig =
-                               (env2.FStar_TypeChecker_Env.gamma_sig);
-                             FStar_TypeChecker_Env.gamma_cache =
-                               (env2.FStar_TypeChecker_Env.gamma_cache);
-                             FStar_TypeChecker_Env.modules =
-                               (env2.FStar_TypeChecker_Env.modules);
-                             FStar_TypeChecker_Env.expected_typ =
-                               (env2.FStar_TypeChecker_Env.expected_typ);
-                             FStar_TypeChecker_Env.sigtab =
-                               (env2.FStar_TypeChecker_Env.sigtab);
-                             FStar_TypeChecker_Env.attrtab =
-                               (env2.FStar_TypeChecker_Env.attrtab);
-                             FStar_TypeChecker_Env.instantiate_imp =
-                               (env2.FStar_TypeChecker_Env.instantiate_imp);
-                             FStar_TypeChecker_Env.effects =
-                               (env2.FStar_TypeChecker_Env.effects);
-                             FStar_TypeChecker_Env.generalize =
-                               (env2.FStar_TypeChecker_Env.generalize);
-                             FStar_TypeChecker_Env.letrecs =
-                               (env2.FStar_TypeChecker_Env.letrecs);
-                             FStar_TypeChecker_Env.top_level =
-                               (env2.FStar_TypeChecker_Env.top_level);
-                             FStar_TypeChecker_Env.check_uvars =
-                               (env2.FStar_TypeChecker_Env.check_uvars);
-                             FStar_TypeChecker_Env.use_eq_strict =
-                               (env2.FStar_TypeChecker_Env.use_eq_strict);
-                             FStar_TypeChecker_Env.is_iface =
-                               (env2.FStar_TypeChecker_Env.is_iface);
-                             FStar_TypeChecker_Env.admit =
-                               (env2.FStar_TypeChecker_Env.admit);
-                             FStar_TypeChecker_Env.lax = true;
-                             FStar_TypeChecker_Env.lax_universes =
-                               (env2.FStar_TypeChecker_Env.lax_universes);
-                             FStar_TypeChecker_Env.phase1 =
-                               (env2.FStar_TypeChecker_Env.phase1);
-                             FStar_TypeChecker_Env.failhard =
-                               (env2.FStar_TypeChecker_Env.failhard);
-                             FStar_TypeChecker_Env.nosynth =
-                               (env2.FStar_TypeChecker_Env.nosynth);
-                             FStar_TypeChecker_Env.uvar_subtyping =
-                               (env2.FStar_TypeChecker_Env.uvar_subtyping);
-                             FStar_TypeChecker_Env.tc_term =
-                               (env2.FStar_TypeChecker_Env.tc_term);
-                             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                               (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.universe_of =
-                               (env2.FStar_TypeChecker_Env.universe_of);
-                             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                               =
-                               (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.teq_nosmt_force =
-                               (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-                             FStar_TypeChecker_Env.subtype_nosmt_force =
-                               (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                             FStar_TypeChecker_Env.qtbl_name_and_index =
-                               (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                             FStar_TypeChecker_Env.normalized_eff_names =
-                               (env2.FStar_TypeChecker_Env.normalized_eff_names);
-                             FStar_TypeChecker_Env.fv_delta_depths =
-                               (env2.FStar_TypeChecker_Env.fv_delta_depths);
-                             FStar_TypeChecker_Env.proof_ns =
-                               (env2.FStar_TypeChecker_Env.proof_ns);
-                             FStar_TypeChecker_Env.synth_hook =
-                               (env2.FStar_TypeChecker_Env.synth_hook);
-                             FStar_TypeChecker_Env.try_solve_implicits_hook =
-                               (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                             FStar_TypeChecker_Env.splice =
-                               (env2.FStar_TypeChecker_Env.splice);
-                             FStar_TypeChecker_Env.mpreprocess =
-                               (env2.FStar_TypeChecker_Env.mpreprocess);
-                             FStar_TypeChecker_Env.postprocess =
-                               (env2.FStar_TypeChecker_Env.postprocess);
-                             FStar_TypeChecker_Env.identifier_info =
-                               (env2.FStar_TypeChecker_Env.identifier_info);
-                             FStar_TypeChecker_Env.tc_hooks =
-                               (env2.FStar_TypeChecker_Env.tc_hooks);
-                             FStar_TypeChecker_Env.dsenv =
-                               (env2.FStar_TypeChecker_Env.dsenv);
-                             FStar_TypeChecker_Env.nbe =
-                               (env2.FStar_TypeChecker_Env.nbe);
-                             FStar_TypeChecker_Env.strict_args_tab =
-                               (env2.FStar_TypeChecker_Env.strict_args_tab);
-                             FStar_TypeChecker_Env.erasable_types_tab =
-                               (env2.FStar_TypeChecker_Env.erasable_types_tab);
-                             FStar_TypeChecker_Env.enable_defer_to_tac =
-                               false;
-                             FStar_TypeChecker_Env.unif_allow_ref_guards =
-                               (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                             FStar_TypeChecker_Env.erase_erasable_args =
-                               (env2.FStar_TypeChecker_Env.erase_erasable_args);
-                             FStar_TypeChecker_Env.core_check =
-                               (env2.FStar_TypeChecker_Env.core_check)
-                           } in
-                         let uu___5 =
-                           let t =
-                             let uu___6 =
-                               is_flex tp.FStar_TypeChecker_Common.lhs in
-                             if uu___6
-                             then tp.FStar_TypeChecker_Common.lhs
-                             else tp.FStar_TypeChecker_Common.rhs in
-                           env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                             env_lax t true in
-                         (match uu___5 with
-                          | (uu___6, t_eq, uu___7) ->
-                              let goal_ty =
-                                let uu___8 =
-                                  env2.FStar_TypeChecker_Env.universe_of
-                                    env_lax t_eq in
-                                FStar_Syntax_Util.mk_eq2 uu___8 t_eq
-                                  tp.FStar_TypeChecker_Common.lhs
-                                  tp.FStar_TypeChecker_Common.rhs in
-                              let uu___8 =
-                                FStar_TypeChecker_Env.new_implicit_var_aux
-                                  reason
-                                  (tp.FStar_TypeChecker_Common.lhs).FStar_Syntax_Syntax.pos
-                                  env2 goal_ty FStar_Syntax_Syntax.Strict
-                                  FStar_Pervasives_Native.None in
-                              (match uu___8 with
-                               | (goal, ctx_uvar, uu___9) ->
-                                   let imp =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         FStar_Compiler_List.hd ctx_uvar in
-                                       FStar_Pervasives_Native.fst uu___11 in
-                                     {
-                                       FStar_TypeChecker_Common.imp_reason =
-                                         "";
-                                       FStar_TypeChecker_Common.imp_uvar =
-                                         uu___10;
-                                       FStar_TypeChecker_Common.imp_tm = goal;
-                                       FStar_TypeChecker_Common.imp_range =
-                                         ((tp.FStar_TypeChecker_Common.lhs).FStar_Syntax_Syntax.pos)
-                                     } in
-                                   let sigelt =
-                                     let uu___10 =
-                                       is_flex
-                                         tp.FStar_TypeChecker_Common.lhs in
-                                     if uu___10
-                                     then
-                                       let uu___11 =
-                                         let uu___12 =
-                                           flex_uvar_head
-                                             tp.FStar_TypeChecker_Common.lhs in
-                                         find_user_tac_for_uvar env2 uu___12 in
-                                       match uu___11 with
-                                       | FStar_Pervasives_Native.None ->
-                                           let uu___12 =
-                                             is_flex
-                                               tp.FStar_TypeChecker_Common.rhs in
-                                           (if uu___12
-                                            then
-                                              let uu___13 =
-                                                flex_uvar_head
-                                                  tp.FStar_TypeChecker_Common.rhs in
-                                              find_user_tac_for_uvar env2
-                                                uu___13
-                                            else FStar_Pervasives_Native.None)
-                                       | v -> v
-                                     else
-                                       (let uu___12 =
-                                          is_flex
-                                            tp.FStar_TypeChecker_Common.rhs in
-                                        if uu___12
-                                        then
-                                          let uu___13 =
-                                            flex_uvar_head
-                                              tp.FStar_TypeChecker_Common.rhs in
-                                          find_user_tac_for_uvar env2 uu___13
-                                        else FStar_Pervasives_Native.None) in
-                                   (match sigelt with
-                                    | FStar_Pervasives_Native.None ->
-                                        failwith
-                                          "Impossible: No tactic associated with deferred problem"
-                                    | FStar_Pervasives_Native.Some se ->
-                                        (imp, se)))))
-                | uu___3 -> failwith "Unexpected problem deferred to tactic") in
-         let eqs =
-           FStar_Compiler_List.map prob_as_implicit
-             g.FStar_TypeChecker_Common.deferred_to_tac in
-         let uu___1 =
-           FStar_Compiler_List.fold_right
-             (fun imp ->
-                fun uu___2 ->
-                  match uu___2 with
-                  | (more, imps) ->
-                      let uu___3 =
-                        FStar_Syntax_Unionfind.find
-                          (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-                      (match uu___3 with
-                       | FStar_Pervasives_Native.Some uu___4 ->
-                           (more, (imp :: imps))
-                       | FStar_Pervasives_Native.None ->
-                           let se =
-                             find_user_tac_for_uvar env
-                               imp.FStar_TypeChecker_Common.imp_uvar in
-                           (match se with
-                            | FStar_Pervasives_Native.None ->
-                                (more, (imp :: imps))
-                            | FStar_Pervasives_Native.Some se1 ->
-                                (((imp, se1) :: more), imps))))
-             g.FStar_TypeChecker_Common.implicits ([], []) in
-         match uu___1 with
-         | (more, imps) ->
-             let bucketize is =
-               let map = FStar_Compiler_Util.smap_create (Prims.of_int (17)) in
-               FStar_Compiler_List.iter
-                 (fun uu___3 ->
-                    match uu___3 with
-                    | (i, s) ->
-                        let uu___4 = FStar_Syntax_Util.lid_of_sigelt s in
-                        (match uu___4 with
-                         | FStar_Pervasives_Native.None ->
-                             failwith "Unexpected: tactic without a name"
-                         | FStar_Pervasives_Native.Some l ->
-                             let lstr = FStar_Ident.string_of_lid l in
-                             let uu___5 =
-                               FStar_Compiler_Util.smap_try_find map lstr in
-                             (match uu___5 with
-                              | FStar_Pervasives_Native.None ->
-                                  FStar_Compiler_Util.smap_add map lstr
-                                    ([i], s)
-                              | FStar_Pervasives_Native.Some (is1, s1) ->
-                                  (FStar_Compiler_Util.smap_remove map lstr;
-                                   FStar_Compiler_Util.smap_add map lstr
-                                     ((i :: is1), s1))))) is;
-               FStar_Compiler_Util.smap_fold map
-                 (fun uu___3 -> fun is1 -> fun out -> is1 :: out) [] in
-             let buckets = bucketize (FStar_Compiler_List.op_At eqs more) in
-             (FStar_Compiler_List.iter
-                (fun uu___3 ->
-                   match uu___3 with
-                   | (imps1, sigel) -> solve_goals_with_tac env g imps1 sigel)
-                buckets;
-              {
-                FStar_TypeChecker_Common.guard_f =
-                  (g.FStar_TypeChecker_Common.guard_f);
-                FStar_TypeChecker_Common.deferred_to_tac = [];
-                FStar_TypeChecker_Common.deferred =
-                  (g.FStar_TypeChecker_Common.deferred);
-                FStar_TypeChecker_Common.univ_ineqs =
-                  (g.FStar_TypeChecker_Common.univ_ineqs);
-                FStar_TypeChecker_Common.implicits = imps
-              }))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Env.ml b/src/ocaml-output/FStar_TypeChecker_Env.ml
deleted file mode 100644
index f099425cec7..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Env.ml
+++ /dev/null
@@ -1,6834 +0,0 @@
-open Prims
-type step =
-  | Beta 
-  | Iota 
-  | Zeta 
-  | ZetaFull 
-  | Exclude of step 
-  | Weak 
-  | HNF 
-  | Primops 
-  | Eager_unfolding 
-  | Inlining 
-  | DoNotUnfoldPureLets 
-  | UnfoldUntil of FStar_Syntax_Syntax.delta_depth 
-  | UnfoldOnly of FStar_Ident.lid Prims.list 
-  | UnfoldFully of FStar_Ident.lid Prims.list 
-  | UnfoldAttr of FStar_Ident.lid Prims.list 
-  | UnfoldQual of Prims.string Prims.list 
-  | UnfoldNamespace of Prims.string Prims.list 
-  | UnfoldTac 
-  | PureSubtermsWithinComputations 
-  | Simplify 
-  | EraseUniverses 
-  | AllowUnboundUniverses 
-  | Reify 
-  | CompressUvars 
-  | NoFullNorm 
-  | CheckNoUvars 
-  | Unmeta 
-  | Unascribe 
-  | NBE 
-  | ForExtraction 
-  | Unrefine 
-let (uu___is_Beta : step -> Prims.bool) =
-  fun projectee -> match projectee with | Beta -> true | uu___ -> false
-let (uu___is_Iota : step -> Prims.bool) =
-  fun projectee -> match projectee with | Iota -> true | uu___ -> false
-let (uu___is_Zeta : step -> Prims.bool) =
-  fun projectee -> match projectee with | Zeta -> true | uu___ -> false
-let (uu___is_ZetaFull : step -> Prims.bool) =
-  fun projectee -> match projectee with | ZetaFull -> true | uu___ -> false
-let (uu___is_Exclude : step -> Prims.bool) =
-  fun projectee -> match projectee with | Exclude _0 -> true | uu___ -> false
-let (__proj__Exclude__item___0 : step -> step) =
-  fun projectee -> match projectee with | Exclude _0 -> _0
-let (uu___is_Weak : step -> Prims.bool) =
-  fun projectee -> match projectee with | Weak -> true | uu___ -> false
-let (uu___is_HNF : step -> Prims.bool) =
-  fun projectee -> match projectee with | HNF -> true | uu___ -> false
-let (uu___is_Primops : step -> Prims.bool) =
-  fun projectee -> match projectee with | Primops -> true | uu___ -> false
-let (uu___is_Eager_unfolding : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Eager_unfolding -> true | uu___ -> false
-let (uu___is_Inlining : step -> Prims.bool) =
-  fun projectee -> match projectee with | Inlining -> true | uu___ -> false
-let (uu___is_DoNotUnfoldPureLets : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DoNotUnfoldPureLets -> true | uu___ -> false
-let (uu___is_UnfoldUntil : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldUntil _0 -> true | uu___ -> false
-let (__proj__UnfoldUntil__item___0 : step -> FStar_Syntax_Syntax.delta_depth)
-  = fun projectee -> match projectee with | UnfoldUntil _0 -> _0
-let (uu___is_UnfoldOnly : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldOnly _0 -> true | uu___ -> false
-let (__proj__UnfoldOnly__item___0 : step -> FStar_Ident.lid Prims.list) =
-  fun projectee -> match projectee with | UnfoldOnly _0 -> _0
-let (uu___is_UnfoldFully : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldFully _0 -> true | uu___ -> false
-let (__proj__UnfoldFully__item___0 : step -> FStar_Ident.lid Prims.list) =
-  fun projectee -> match projectee with | UnfoldFully _0 -> _0
-let (uu___is_UnfoldAttr : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldAttr _0 -> true | uu___ -> false
-let (__proj__UnfoldAttr__item___0 : step -> FStar_Ident.lid Prims.list) =
-  fun projectee -> match projectee with | UnfoldAttr _0 -> _0
-let (uu___is_UnfoldQual : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldQual _0 -> true | uu___ -> false
-let (__proj__UnfoldQual__item___0 : step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldQual _0 -> _0
-let (uu___is_UnfoldNamespace : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldNamespace _0 -> true | uu___ -> false
-let (__proj__UnfoldNamespace__item___0 : step -> Prims.string Prims.list) =
-  fun projectee -> match projectee with | UnfoldNamespace _0 -> _0
-let (uu___is_UnfoldTac : step -> Prims.bool) =
-  fun projectee -> match projectee with | UnfoldTac -> true | uu___ -> false
-let (uu___is_PureSubtermsWithinComputations : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | PureSubtermsWithinComputations -> true
-    | uu___ -> false
-let (uu___is_Simplify : step -> Prims.bool) =
-  fun projectee -> match projectee with | Simplify -> true | uu___ -> false
-let (uu___is_EraseUniverses : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | EraseUniverses -> true | uu___ -> false
-let (uu___is_AllowUnboundUniverses : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | AllowUnboundUniverses -> true | uu___ -> false
-let (uu___is_Reify : step -> Prims.bool) =
-  fun projectee -> match projectee with | Reify -> true | uu___ -> false
-let (uu___is_CompressUvars : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CompressUvars -> true | uu___ -> false
-let (uu___is_NoFullNorm : step -> Prims.bool) =
-  fun projectee -> match projectee with | NoFullNorm -> true | uu___ -> false
-let (uu___is_CheckNoUvars : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CheckNoUvars -> true | uu___ -> false
-let (uu___is_Unmeta : step -> Prims.bool) =
-  fun projectee -> match projectee with | Unmeta -> true | uu___ -> false
-let (uu___is_Unascribe : step -> Prims.bool) =
-  fun projectee -> match projectee with | Unascribe -> true | uu___ -> false
-let (uu___is_NBE : step -> Prims.bool) =
-  fun projectee -> match projectee with | NBE -> true | uu___ -> false
-let (uu___is_ForExtraction : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | ForExtraction -> true | uu___ -> false
-let (uu___is_Unrefine : step -> Prims.bool) =
-  fun projectee -> match projectee with | Unrefine -> true | uu___ -> false
-type steps = step Prims.list
-let rec (eq_step : step -> step -> Prims.bool) =
-  fun s1 ->
-    fun s2 ->
-      match (s1, s2) with
-      | (Beta, Beta) -> true
-      | (Iota, Iota) -> true
-      | (Zeta, Zeta) -> true
-      | (ZetaFull, ZetaFull) -> true
-      | (Weak, Weak) -> true
-      | (HNF, HNF) -> true
-      | (Primops, Primops) -> true
-      | (Eager_unfolding, Eager_unfolding) -> true
-      | (Inlining, Inlining) -> true
-      | (DoNotUnfoldPureLets, DoNotUnfoldPureLets) -> true
-      | (UnfoldTac, UnfoldTac) -> true
-      | (PureSubtermsWithinComputations, PureSubtermsWithinComputations) ->
-          true
-      | (Simplify, Simplify) -> true
-      | (EraseUniverses, EraseUniverses) -> true
-      | (AllowUnboundUniverses, AllowUnboundUniverses) -> true
-      | (Reify, Reify) -> true
-      | (CompressUvars, CompressUvars) -> true
-      | (NoFullNorm, NoFullNorm) -> true
-      | (CheckNoUvars, CheckNoUvars) -> true
-      | (Unmeta, Unmeta) -> true
-      | (Unascribe, Unascribe) -> true
-      | (NBE, NBE) -> true
-      | (Unrefine, Unrefine) -> true
-      | (Exclude s11, Exclude s21) -> eq_step s11 s21
-      | (UnfoldUntil s11, UnfoldUntil s21) -> s11 = s21
-      | (UnfoldOnly lids1, UnfoldOnly lids2) ->
-          ((FStar_Compiler_List.length lids1) =
-             (FStar_Compiler_List.length lids2))
-            &&
-            (FStar_Compiler_List.forall2 FStar_Ident.lid_equals lids1 lids2)
-      | (UnfoldFully lids1, UnfoldFully lids2) ->
-          ((FStar_Compiler_List.length lids1) =
-             (FStar_Compiler_List.length lids2))
-            &&
-            (FStar_Compiler_List.forall2 FStar_Ident.lid_equals lids1 lids2)
-      | (UnfoldAttr lids1, UnfoldAttr lids2) ->
-          ((FStar_Compiler_List.length lids1) =
-             (FStar_Compiler_List.length lids2))
-            &&
-            (FStar_Compiler_List.forall2 FStar_Ident.lid_equals lids1 lids2)
-      | (UnfoldQual strs1, UnfoldQual strs2) -> strs1 = strs2
-      | (UnfoldNamespace strs1, UnfoldNamespace strs2) -> strs1 = strs2
-      | uu___ -> false
-type sig_binding =
-  (FStar_Ident.lident Prims.list * FStar_Syntax_Syntax.sigelt)
-type delta_level =
-  | NoDelta 
-  | InliningDelta 
-  | Eager_unfolding_only 
-  | Unfold of FStar_Syntax_Syntax.delta_depth 
-let (uu___is_NoDelta : delta_level -> Prims.bool) =
-  fun projectee -> match projectee with | NoDelta -> true | uu___ -> false
-let (uu___is_InliningDelta : delta_level -> Prims.bool) =
-  fun projectee ->
-    match projectee with | InliningDelta -> true | uu___ -> false
-let (uu___is_Eager_unfolding_only : delta_level -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Eager_unfolding_only -> true | uu___ -> false
-let (uu___is_Unfold : delta_level -> Prims.bool) =
-  fun projectee -> match projectee with | Unfold _0 -> true | uu___ -> false
-let (__proj__Unfold__item___0 :
-  delta_level -> FStar_Syntax_Syntax.delta_depth) =
-  fun projectee -> match projectee with | Unfold _0 -> _0
-type name_prefix = FStar_Ident.path
-type proof_namespace = (name_prefix * Prims.bool) Prims.list
-type cached_elt =
-  (((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ),
-    (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.universes
-      FStar_Pervasives_Native.option))
-    FStar_Pervasives.either * FStar_Compiler_Range.range)
-type goal = FStar_Syntax_Syntax.term
-type must_tot = Prims.bool
-type mlift =
-  {
-  mlift_wp:
-    env ->
-      FStar_Syntax_Syntax.comp ->
-        (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Common.guard_t)
-    ;
-  mlift_term:
-    (FStar_Syntax_Syntax.universe ->
-       FStar_Syntax_Syntax.typ ->
-         FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-      FStar_Pervasives_Native.option
-    }
-and edge =
-  {
-  msource: FStar_Ident.lident ;
-  mtarget: FStar_Ident.lident ;
-  mlift: mlift ;
-  mpath: FStar_Ident.lident Prims.list }
-and effects =
-  {
-  decls:
-    (FStar_Syntax_Syntax.eff_decl * FStar_Syntax_Syntax.qualifier Prims.list)
-      Prims.list
-    ;
-  order: edge Prims.list ;
-  joins:
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Ident.lident * mlift *
-      mlift) Prims.list
-    ;
-  polymonadic_binds:
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Ident.lident *
-      (env ->
-         FStar_Syntax_Syntax.comp_typ ->
-           FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-             FStar_Syntax_Syntax.comp_typ ->
-               FStar_Syntax_Syntax.cflag Prims.list ->
-                 FStar_Compiler_Range.range ->
-                   (FStar_Syntax_Syntax.comp *
-                     FStar_TypeChecker_Common.guard_t)))
-      Prims.list
-    ;
-  polymonadic_subcomps:
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Syntax_Syntax.tscheme *
-      FStar_Syntax_Syntax.indexed_effect_combinator_kind) Prims.list
-    }
-and env =
-  {
-  solver: solver_t ;
-  range: FStar_Compiler_Range.range ;
-  curmodule: FStar_Ident.lident ;
-  gamma: FStar_Syntax_Syntax.binding Prims.list ;
-  gamma_sig: sig_binding Prims.list ;
-  gamma_cache: cached_elt FStar_Compiler_Util.smap ;
-  modules: FStar_Syntax_Syntax.modul Prims.list ;
-  expected_typ:
-    (FStar_Syntax_Syntax.typ * Prims.bool) FStar_Pervasives_Native.option ;
-  sigtab: FStar_Syntax_Syntax.sigelt FStar_Compiler_Util.smap ;
-  attrtab: FStar_Syntax_Syntax.sigelt Prims.list FStar_Compiler_Util.smap ;
-  instantiate_imp: Prims.bool ;
-  effects: effects ;
-  generalize: Prims.bool ;
-  letrecs:
-    (FStar_Syntax_Syntax.lbname * Prims.int * FStar_Syntax_Syntax.typ *
-      FStar_Syntax_Syntax.univ_names) Prims.list
-    ;
-  top_level: Prims.bool ;
-  check_uvars: Prims.bool ;
-  use_eq_strict: Prims.bool ;
-  is_iface: Prims.bool ;
-  admit: Prims.bool ;
-  lax: Prims.bool ;
-  lax_universes: Prims.bool ;
-  phase1: Prims.bool ;
-  failhard: Prims.bool ;
-  nosynth: Prims.bool ;
-  uvar_subtyping: Prims.bool ;
-  tc_term:
-    env ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-          FStar_TypeChecker_Common.guard_t)
-    ;
-  typeof_tot_or_gtot_term:
-    env ->
-      FStar_Syntax_Syntax.term ->
-        must_tot ->
-          (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.typ *
-            FStar_TypeChecker_Common.guard_t)
-    ;
-  universe_of:
-    env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.universe ;
-  typeof_well_typed_tot_or_gtot_term:
-    env ->
-      FStar_Syntax_Syntax.term ->
-        must_tot ->
-          (FStar_Syntax_Syntax.typ * FStar_TypeChecker_Common.guard_t)
-    ;
-  teq_nosmt_force:
-    env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool ;
-  subtype_nosmt_force:
-    env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool ;
-  qtbl_name_and_index:
-    (Prims.int FStar_Compiler_Util.smap * (FStar_Ident.lident * Prims.int)
-      FStar_Pervasives_Native.option)
-    ;
-  normalized_eff_names: FStar_Ident.lident FStar_Compiler_Util.smap ;
-  fv_delta_depths: FStar_Syntax_Syntax.delta_depth FStar_Compiler_Util.smap ;
-  proof_ns: proof_namespace ;
-  synth_hook:
-    env ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term
-    ;
-  try_solve_implicits_hook:
-    env ->
-      FStar_Syntax_Syntax.term -> FStar_TypeChecker_Common.implicits -> unit
-    ;
-  splice:
-    env ->
-      FStar_Compiler_Range.range ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.sigelt Prims.list
-    ;
-  mpreprocess:
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term
-    ;
-  postprocess:
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term
-    ;
-  identifier_info:
-    FStar_TypeChecker_Common.id_info_table FStar_Compiler_Effect.ref ;
-  tc_hooks: tcenv_hooks ;
-  dsenv: FStar_Syntax_DsEnv.env ;
-  nbe:
-    step Prims.list ->
-      env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term
-    ;
-  strict_args_tab:
-    Prims.int Prims.list FStar_Pervasives_Native.option
-      FStar_Compiler_Util.smap
-    ;
-  erasable_types_tab: Prims.bool FStar_Compiler_Util.smap ;
-  enable_defer_to_tac: Prims.bool ;
-  unif_allow_ref_guards: Prims.bool ;
-  erase_erasable_args: Prims.bool ;
-  core_check:
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.typ ->
-          Prims.bool ->
-            (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option,
-              Prims.bool -> Prims.string) FStar_Pervasives.either
-    }
-and solver_t =
-  {
-  init: env -> unit ;
-  push: Prims.string -> unit ;
-  pop: Prims.string -> unit ;
-  snapshot: Prims.string -> ((Prims.int * Prims.int * Prims.int) * unit) ;
-  rollback:
-    Prims.string ->
-      (Prims.int * Prims.int * Prims.int) FStar_Pervasives_Native.option ->
-        unit
-    ;
-  encode_sig: env -> FStar_Syntax_Syntax.sigelt -> unit ;
-  preprocess:
-    env -> goal -> (env * goal * FStar_Options.optionstate) Prims.list ;
-  spinoff_strictly_positive_goals:
-    (env -> goal -> (env * goal) Prims.list) FStar_Pervasives_Native.option ;
-  handle_smt_goal: env -> goal -> (env * goal) Prims.list ;
-  solve:
-    (unit -> Prims.string) FStar_Pervasives_Native.option ->
-      env -> goal -> unit
-    ;
-  finish: unit -> unit ;
-  refresh: unit -> unit }
-and tcenv_hooks =
-  {
-  tc_push_in_gamma_hook:
-    env ->
-      (FStar_Syntax_Syntax.binding, sig_binding) FStar_Pervasives.either ->
-        unit
-    }
-let (__proj__Mkmlift__item__mlift_wp :
-  mlift ->
-    env ->
-      FStar_Syntax_Syntax.comp ->
-        (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Common.guard_t))
-  =
-  fun projectee ->
-    match projectee with | { mlift_wp; mlift_term;_} -> mlift_wp
-let (__proj__Mkmlift__item__mlift_term :
-  mlift ->
-    (FStar_Syntax_Syntax.universe ->
-       FStar_Syntax_Syntax.typ ->
-         FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-      FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with | { mlift_wp; mlift_term;_} -> mlift_term
-let (__proj__Mkedge__item__msource : edge -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { msource; mtarget; mlift = mlift1; mpath;_} -> msource
-let (__proj__Mkedge__item__mtarget : edge -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { msource; mtarget; mlift = mlift1; mpath;_} -> mtarget
-let (__proj__Mkedge__item__mlift : edge -> mlift) =
-  fun projectee ->
-    match projectee with
-    | { msource; mtarget; mlift = mlift1; mpath;_} -> mlift1
-let (__proj__Mkedge__item__mpath : edge -> FStar_Ident.lident Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { msource; mtarget; mlift = mlift1; mpath;_} -> mpath
-let (__proj__Mkeffects__item__decls :
-  effects ->
-    (FStar_Syntax_Syntax.eff_decl * FStar_Syntax_Syntax.qualifier Prims.list)
-      Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { decls; order; joins; polymonadic_binds; polymonadic_subcomps;_} ->
-        decls
-let (__proj__Mkeffects__item__order : effects -> edge Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { decls; order; joins; polymonadic_binds; polymonadic_subcomps;_} ->
-        order
-let (__proj__Mkeffects__item__joins :
-  effects ->
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Ident.lident * mlift *
-      mlift) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { decls; order; joins; polymonadic_binds; polymonadic_subcomps;_} ->
-        joins
-let (__proj__Mkeffects__item__polymonadic_binds :
-  effects ->
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Ident.lident *
-      (env ->
-         FStar_Syntax_Syntax.comp_typ ->
-           FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-             FStar_Syntax_Syntax.comp_typ ->
-               FStar_Syntax_Syntax.cflag Prims.list ->
-                 FStar_Compiler_Range.range ->
-                   (FStar_Syntax_Syntax.comp *
-                     FStar_TypeChecker_Common.guard_t)))
-      Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { decls; order; joins; polymonadic_binds; polymonadic_subcomps;_} ->
-        polymonadic_binds
-let (__proj__Mkeffects__item__polymonadic_subcomps :
-  effects ->
-    (FStar_Ident.lident * FStar_Ident.lident * FStar_Syntax_Syntax.tscheme *
-      FStar_Syntax_Syntax.indexed_effect_combinator_kind) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { decls; order; joins; polymonadic_binds; polymonadic_subcomps;_} ->
-        polymonadic_subcomps
-let (__proj__Mkenv__item__solver : env -> solver_t) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> solver
-let (__proj__Mkenv__item__range : env -> FStar_Compiler_Range.range) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> range
-let (__proj__Mkenv__item__curmodule : env -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        curmodule
-let (__proj__Mkenv__item__gamma :
-  env -> FStar_Syntax_Syntax.binding Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> gamma
-let (__proj__Mkenv__item__gamma_sig : env -> sig_binding Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        gamma_sig
-let (__proj__Mkenv__item__gamma_cache :
-  env -> cached_elt FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        gamma_cache
-let (__proj__Mkenv__item__modules :
-  env -> FStar_Syntax_Syntax.modul Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> modules
-let (__proj__Mkenv__item__expected_typ :
-  env ->
-    (FStar_Syntax_Syntax.typ * Prims.bool) FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        expected_typ
-let (__proj__Mkenv__item__sigtab :
-  env -> FStar_Syntax_Syntax.sigelt FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> sigtab
-let (__proj__Mkenv__item__attrtab :
-  env -> FStar_Syntax_Syntax.sigelt Prims.list FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> attrtab
-let (__proj__Mkenv__item__instantiate_imp : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        instantiate_imp
-let (__proj__Mkenv__item__effects : env -> effects) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> effects1
-let (__proj__Mkenv__item__generalize : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        generalize
-let (__proj__Mkenv__item__letrecs :
-  env ->
-    (FStar_Syntax_Syntax.lbname * Prims.int * FStar_Syntax_Syntax.typ *
-      FStar_Syntax_Syntax.univ_names) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> letrecs
-let (__proj__Mkenv__item__top_level : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        top_level
-let (__proj__Mkenv__item__check_uvars : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        check_uvars
-let (__proj__Mkenv__item__use_eq_strict : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        use_eq_strict
-let (__proj__Mkenv__item__is_iface : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> is_iface
-let (__proj__Mkenv__item__admit : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> admit
-let (__proj__Mkenv__item__lax : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> lax
-let (__proj__Mkenv__item__lax_universes : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        lax_universes
-let (__proj__Mkenv__item__phase1 : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> phase1
-let (__proj__Mkenv__item__failhard : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> failhard
-let (__proj__Mkenv__item__nosynth : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> nosynth
-let (__proj__Mkenv__item__uvar_subtyping : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        uvar_subtyping
-let (__proj__Mkenv__item__tc_term :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-          FStar_TypeChecker_Common.guard_t))
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> tc_term
-let (__proj__Mkenv__item__typeof_tot_or_gtot_term :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        must_tot ->
-          (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.typ *
-            FStar_TypeChecker_Common.guard_t))
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        typeof_tot_or_gtot_term
-let (__proj__Mkenv__item__universe_of :
-  env -> env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.universe) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        universe_of
-let (__proj__Mkenv__item__typeof_well_typed_tot_or_gtot_term :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        must_tot ->
-          (FStar_Syntax_Syntax.typ * FStar_TypeChecker_Common.guard_t))
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        typeof_well_typed_tot_or_gtot_term
-let (__proj__Mkenv__item__teq_nosmt_force :
-  env ->
-    env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        teq_nosmt_force
-let (__proj__Mkenv__item__subtype_nosmt_force :
-  env ->
-    env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        subtype_nosmt_force
-let (__proj__Mkenv__item__qtbl_name_and_index :
-  env ->
-    (Prims.int FStar_Compiler_Util.smap * (FStar_Ident.lident * Prims.int)
-      FStar_Pervasives_Native.option))
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        qtbl_name_and_index
-let (__proj__Mkenv__item__normalized_eff_names :
-  env -> FStar_Ident.lident FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        normalized_eff_names
-let (__proj__Mkenv__item__fv_delta_depths :
-  env -> FStar_Syntax_Syntax.delta_depth FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        fv_delta_depths
-let (__proj__Mkenv__item__proof_ns : env -> proof_namespace) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> proof_ns
-let (__proj__Mkenv__item__synth_hook :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        synth_hook
-let (__proj__Mkenv__item__try_solve_implicits_hook :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term -> FStar_TypeChecker_Common.implicits -> unit)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        try_solve_implicits_hook
-let (__proj__Mkenv__item__splice :
-  env ->
-    env ->
-      FStar_Compiler_Range.range ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> splice
-let (__proj__Mkenv__item__mpreprocess :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        mpreprocess
-let (__proj__Mkenv__item__postprocess :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        postprocess
-let (__proj__Mkenv__item__identifier_info :
-  env -> FStar_TypeChecker_Common.id_info_table FStar_Compiler_Effect.ref) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        identifier_info
-let (__proj__Mkenv__item__tc_hooks : env -> tcenv_hooks) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> tc_hooks
-let (__proj__Mkenv__item__dsenv : env -> FStar_Syntax_DsEnv.env) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> dsenv
-let (__proj__Mkenv__item__nbe :
-  env ->
-    step Prims.list ->
-      env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} -> nbe
-let (__proj__Mkenv__item__strict_args_tab :
-  env ->
-    Prims.int Prims.list FStar_Pervasives_Native.option
-      FStar_Compiler_Util.smap)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        strict_args_tab
-let (__proj__Mkenv__item__erasable_types_tab :
-  env -> Prims.bool FStar_Compiler_Util.smap) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        erasable_types_tab
-let (__proj__Mkenv__item__enable_defer_to_tac : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        enable_defer_to_tac
-let (__proj__Mkenv__item__unif_allow_ref_guards : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        unif_allow_ref_guards
-let (__proj__Mkenv__item__erase_erasable_args : env -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        erase_erasable_args
-let (__proj__Mkenv__item__core_check :
-  env ->
-    env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.typ ->
-          Prims.bool ->
-            (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option,
-              Prims.bool -> Prims.string) FStar_Pervasives.either)
-  =
-  fun projectee ->
-    match projectee with
-    | { solver; range; curmodule; gamma; gamma_sig; gamma_cache; modules;
-        expected_typ; sigtab; attrtab; instantiate_imp; effects = effects1;
-        generalize; letrecs; top_level; check_uvars; use_eq_strict; is_iface;
-        admit; lax; lax_universes; phase1; failhard; nosynth; uvar_subtyping;
-        tc_term; typeof_tot_or_gtot_term; universe_of;
-        typeof_well_typed_tot_or_gtot_term; teq_nosmt_force;
-        subtype_nosmt_force; qtbl_name_and_index; normalized_eff_names;
-        fv_delta_depths; proof_ns; synth_hook; try_solve_implicits_hook;
-        splice; mpreprocess; postprocess; identifier_info; tc_hooks; 
-        dsenv; nbe; strict_args_tab; erasable_types_tab; enable_defer_to_tac;
-        unif_allow_ref_guards; erase_erasable_args; core_check;_} ->
-        core_check
-let (__proj__Mksolver_t__item__init : solver_t -> env -> unit) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> init
-let (__proj__Mksolver_t__item__push : solver_t -> Prims.string -> unit) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> push
-let (__proj__Mksolver_t__item__pop : solver_t -> Prims.string -> unit) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> pop
-let (__proj__Mksolver_t__item__snapshot :
-  solver_t -> Prims.string -> ((Prims.int * Prims.int * Prims.int) * unit)) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> snapshot
-let (__proj__Mksolver_t__item__rollback :
-  solver_t ->
-    Prims.string ->
-      (Prims.int * Prims.int * Prims.int) FStar_Pervasives_Native.option ->
-        unit)
-  =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> rollback
-let (__proj__Mksolver_t__item__encode_sig :
-  solver_t -> env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> encode_sig
-let (__proj__Mksolver_t__item__preprocess :
-  solver_t ->
-    env -> goal -> (env * goal * FStar_Options.optionstate) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> preprocess
-let (__proj__Mksolver_t__item__spinoff_strictly_positive_goals :
-  solver_t ->
-    (env -> goal -> (env * goal) Prims.list) FStar_Pervasives_Native.option)
-  =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> spinoff_strictly_positive_goals
-let (__proj__Mksolver_t__item__handle_smt_goal :
-  solver_t -> env -> goal -> (env * goal) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> handle_smt_goal
-let (__proj__Mksolver_t__item__solve :
-  solver_t ->
-    (unit -> Prims.string) FStar_Pervasives_Native.option ->
-      env -> goal -> unit)
-  =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> solve
-let (__proj__Mksolver_t__item__finish : solver_t -> unit -> unit) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> finish
-let (__proj__Mksolver_t__item__refresh : solver_t -> unit -> unit) =
-  fun projectee ->
-    match projectee with
-    | { init; push; pop; snapshot; rollback; encode_sig; preprocess;
-        spinoff_strictly_positive_goals; handle_smt_goal; solve; finish;
-        refresh;_} -> refresh
-let (__proj__Mktcenv_hooks__item__tc_push_in_gamma_hook :
-  tcenv_hooks ->
-    env ->
-      (FStar_Syntax_Syntax.binding, sig_binding) FStar_Pervasives.either ->
-        unit)
-  =
-  fun projectee ->
-    match projectee with
-    | { tc_push_in_gamma_hook;_} -> tc_push_in_gamma_hook
-type lift_comp_t =
-  env ->
-    FStar_Syntax_Syntax.comp ->
-      (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Common.guard_t)
-type polymonadic_bind_t =
-  env ->
-    FStar_Syntax_Syntax.comp_typ ->
-      FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.comp_typ ->
-          FStar_Syntax_Syntax.cflag Prims.list ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Common.guard_t)
-type solver_depth_t = (Prims.int * Prims.int * Prims.int)
-type core_check_t =
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        Prims.bool ->
-          (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option,
-            Prims.bool -> Prims.string) FStar_Pervasives.either
-type implicit = FStar_TypeChecker_Common.implicit
-type implicits = FStar_TypeChecker_Common.implicits
-type guard_t = FStar_TypeChecker_Common.guard_t
-type tcenv_depth_t = (Prims.int * Prims.int * solver_depth_t * Prims.int)
-type qninfo =
-  (((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ),
-    (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.universes
-      FStar_Pervasives_Native.option))
-    FStar_Pervasives.either * FStar_Compiler_Range.range)
-    FStar_Pervasives_Native.option
-let (preprocess :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun env1 -> fun tau -> fun tm -> env1.mpreprocess env1 tau tm
-let (postprocess :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 -> fun tau -> fun ty -> fun tm -> env1.postprocess env1 tau ty tm
-let (rename_gamma :
-  FStar_Syntax_Syntax.subst_t ->
-    FStar_Syntax_Syntax.gamma -> FStar_Syntax_Syntax.gamma)
-  =
-  fun subst ->
-    fun gamma ->
-      FStar_Compiler_Effect.op_Bar_Greater gamma
-        (FStar_Compiler_List.map
-           (fun uu___ ->
-              match uu___ with
-              | FStar_Syntax_Syntax.Binding_var x ->
-                  let y =
-                    let uu___1 = FStar_Syntax_Syntax.bv_to_name x in
-                    FStar_Syntax_Subst.subst subst uu___1 in
-                  let uu___1 =
-                    let uu___2 = FStar_Syntax_Subst.compress y in
-                    uu___2.FStar_Syntax_Syntax.n in
-                  (match uu___1 with
-                   | FStar_Syntax_Syntax.Tm_name y1 ->
-                       let uu___2 =
-                         let uu___3 =
-                           FStar_Syntax_Subst.subst subst
-                             x.FStar_Syntax_Syntax.sort in
-                         {
-                           FStar_Syntax_Syntax.ppname =
-                             (y1.FStar_Syntax_Syntax.ppname);
-                           FStar_Syntax_Syntax.index =
-                             (y1.FStar_Syntax_Syntax.index);
-                           FStar_Syntax_Syntax.sort = uu___3
-                         } in
-                       FStar_Syntax_Syntax.Binding_var uu___2
-                   | uu___2 -> failwith "Not a renaming")
-              | b -> b))
-let (rename_env : FStar_Syntax_Syntax.subst_t -> env -> env) =
-  fun subst ->
-    fun env1 ->
-      let uu___ = rename_gamma subst env1.gamma in
-      {
-        solver = (env1.solver);
-        range = (env1.range);
-        curmodule = (env1.curmodule);
-        gamma = uu___;
-        gamma_sig = (env1.gamma_sig);
-        gamma_cache = (env1.gamma_cache);
-        modules = (env1.modules);
-        expected_typ = (env1.expected_typ);
-        sigtab = (env1.sigtab);
-        attrtab = (env1.attrtab);
-        instantiate_imp = (env1.instantiate_imp);
-        effects = (env1.effects);
-        generalize = (env1.generalize);
-        letrecs = (env1.letrecs);
-        top_level = (env1.top_level);
-        check_uvars = (env1.check_uvars);
-        use_eq_strict = (env1.use_eq_strict);
-        is_iface = (env1.is_iface);
-        admit = (env1.admit);
-        lax = (env1.lax);
-        lax_universes = (env1.lax_universes);
-        phase1 = (env1.phase1);
-        failhard = (env1.failhard);
-        nosynth = (env1.nosynth);
-        uvar_subtyping = (env1.uvar_subtyping);
-        tc_term = (env1.tc_term);
-        typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-        universe_of = (env1.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (env1.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (env1.teq_nosmt_force);
-        subtype_nosmt_force = (env1.subtype_nosmt_force);
-        qtbl_name_and_index = (env1.qtbl_name_and_index);
-        normalized_eff_names = (env1.normalized_eff_names);
-        fv_delta_depths = (env1.fv_delta_depths);
-        proof_ns = (env1.proof_ns);
-        synth_hook = (env1.synth_hook);
-        try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-        splice = (env1.splice);
-        mpreprocess = (env1.mpreprocess);
-        postprocess = (env1.postprocess);
-        identifier_info = (env1.identifier_info);
-        tc_hooks = (env1.tc_hooks);
-        dsenv = (env1.dsenv);
-        nbe = (env1.nbe);
-        strict_args_tab = (env1.strict_args_tab);
-        erasable_types_tab = (env1.erasable_types_tab);
-        enable_defer_to_tac = (env1.enable_defer_to_tac);
-        unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-        erase_erasable_args = (env1.erase_erasable_args);
-        core_check = (env1.core_check)
-      }
-let (default_tc_hooks : tcenv_hooks) =
-  { tc_push_in_gamma_hook = (fun uu___ -> fun uu___1 -> ()) }
-let (tc_hooks : env -> tcenv_hooks) = fun env1 -> env1.tc_hooks
-let (set_tc_hooks : env -> tcenv_hooks -> env) =
-  fun env1 ->
-    fun hooks ->
-      {
-        solver = (env1.solver);
-        range = (env1.range);
-        curmodule = (env1.curmodule);
-        gamma = (env1.gamma);
-        gamma_sig = (env1.gamma_sig);
-        gamma_cache = (env1.gamma_cache);
-        modules = (env1.modules);
-        expected_typ = (env1.expected_typ);
-        sigtab = (env1.sigtab);
-        attrtab = (env1.attrtab);
-        instantiate_imp = (env1.instantiate_imp);
-        effects = (env1.effects);
-        generalize = (env1.generalize);
-        letrecs = (env1.letrecs);
-        top_level = (env1.top_level);
-        check_uvars = (env1.check_uvars);
-        use_eq_strict = (env1.use_eq_strict);
-        is_iface = (env1.is_iface);
-        admit = (env1.admit);
-        lax = (env1.lax);
-        lax_universes = (env1.lax_universes);
-        phase1 = (env1.phase1);
-        failhard = (env1.failhard);
-        nosynth = (env1.nosynth);
-        uvar_subtyping = (env1.uvar_subtyping);
-        tc_term = (env1.tc_term);
-        typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-        universe_of = (env1.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (env1.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (env1.teq_nosmt_force);
-        subtype_nosmt_force = (env1.subtype_nosmt_force);
-        qtbl_name_and_index = (env1.qtbl_name_and_index);
-        normalized_eff_names = (env1.normalized_eff_names);
-        fv_delta_depths = (env1.fv_delta_depths);
-        proof_ns = (env1.proof_ns);
-        synth_hook = (env1.synth_hook);
-        try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-        splice = (env1.splice);
-        mpreprocess = (env1.mpreprocess);
-        postprocess = (env1.postprocess);
-        identifier_info = (env1.identifier_info);
-        tc_hooks = hooks;
-        dsenv = (env1.dsenv);
-        nbe = (env1.nbe);
-        strict_args_tab = (env1.strict_args_tab);
-        erasable_types_tab = (env1.erasable_types_tab);
-        enable_defer_to_tac = (env1.enable_defer_to_tac);
-        unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-        erase_erasable_args = (env1.erase_erasable_args);
-        core_check = (env1.core_check)
-      }
-type env_t = env
-let (set_dep_graph : env -> FStar_Parser_Dep.deps -> env) =
-  fun e ->
-    fun g ->
-      let uu___ = FStar_Syntax_DsEnv.set_dep_graph e.dsenv g in
-      {
-        solver = (e.solver);
-        range = (e.range);
-        curmodule = (e.curmodule);
-        gamma = (e.gamma);
-        gamma_sig = (e.gamma_sig);
-        gamma_cache = (e.gamma_cache);
-        modules = (e.modules);
-        expected_typ = (e.expected_typ);
-        sigtab = (e.sigtab);
-        attrtab = (e.attrtab);
-        instantiate_imp = (e.instantiate_imp);
-        effects = (e.effects);
-        generalize = (e.generalize);
-        letrecs = (e.letrecs);
-        top_level = (e.top_level);
-        check_uvars = (e.check_uvars);
-        use_eq_strict = (e.use_eq_strict);
-        is_iface = (e.is_iface);
-        admit = (e.admit);
-        lax = (e.lax);
-        lax_universes = (e.lax_universes);
-        phase1 = (e.phase1);
-        failhard = (e.failhard);
-        nosynth = (e.nosynth);
-        uvar_subtyping = (e.uvar_subtyping);
-        tc_term = (e.tc_term);
-        typeof_tot_or_gtot_term = (e.typeof_tot_or_gtot_term);
-        universe_of = (e.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (e.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (e.teq_nosmt_force);
-        subtype_nosmt_force = (e.subtype_nosmt_force);
-        qtbl_name_and_index = (e.qtbl_name_and_index);
-        normalized_eff_names = (e.normalized_eff_names);
-        fv_delta_depths = (e.fv_delta_depths);
-        proof_ns = (e.proof_ns);
-        synth_hook = (e.synth_hook);
-        try_solve_implicits_hook = (e.try_solve_implicits_hook);
-        splice = (e.splice);
-        mpreprocess = (e.mpreprocess);
-        postprocess = (e.postprocess);
-        identifier_info = (e.identifier_info);
-        tc_hooks = (e.tc_hooks);
-        dsenv = uu___;
-        nbe = (e.nbe);
-        strict_args_tab = (e.strict_args_tab);
-        erasable_types_tab = (e.erasable_types_tab);
-        enable_defer_to_tac = (e.enable_defer_to_tac);
-        unif_allow_ref_guards = (e.unif_allow_ref_guards);
-        erase_erasable_args = (e.erase_erasable_args);
-        core_check = (e.core_check)
-      }
-let (dep_graph : env -> FStar_Parser_Dep.deps) =
-  fun e -> FStar_Syntax_DsEnv.dep_graph e.dsenv
-type sigtable = FStar_Syntax_Syntax.sigelt FStar_Compiler_Util.smap
-let (should_verify : env -> Prims.bool) =
-  fun env1 ->
-    ((Prims.op_Negation env1.lax) && (Prims.op_Negation env1.admit)) &&
-      (let uu___ = FStar_Ident.string_of_lid env1.curmodule in
-       FStar_Options.should_verify uu___)
-let (visible_at : delta_level -> FStar_Syntax_Syntax.qualifier -> Prims.bool)
-  =
-  fun d ->
-    fun q ->
-      match (d, q) with
-      | (NoDelta, uu___) -> true
-      | (Eager_unfolding_only,
-         FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen) -> true
-      | (Unfold uu___, FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen)
-          -> true
-      | (Unfold uu___, FStar_Syntax_Syntax.Visible_default) -> true
-      | (InliningDelta, FStar_Syntax_Syntax.Inline_for_extraction) -> true
-      | uu___ -> false
-let (default_table_size : Prims.int) = (Prims.of_int (200))
-let new_sigtab : 'uuuuu . unit -> 'uuuuu FStar_Compiler_Util.smap =
-  fun uu___ -> FStar_Compiler_Util.smap_create default_table_size
-let new_gamma_cache : 'uuuuu . unit -> 'uuuuu FStar_Compiler_Util.smap =
-  fun uu___ -> FStar_Compiler_Util.smap_create (Prims.of_int (100))
-let (initial_env :
-  FStar_Parser_Dep.deps ->
-    (env ->
-       FStar_Syntax_Syntax.term ->
-         (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-           guard_t))
-      ->
-      (env ->
-         FStar_Syntax_Syntax.term ->
-           must_tot ->
-             (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.typ * guard_t))
-        ->
-        (env ->
-           FStar_Syntax_Syntax.term ->
-             must_tot ->
-               FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option)
-          ->
-          (env -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.universe)
-            ->
-            (env ->
-               FStar_Syntax_Syntax.term ->
-                 FStar_Syntax_Syntax.term -> Prims.bool)
-              ->
-              (env ->
-                 FStar_Syntax_Syntax.term ->
-                   FStar_Syntax_Syntax.term -> Prims.bool)
-                ->
-                solver_t ->
-                  FStar_Ident.lident ->
-                    (step Prims.list ->
-                       env ->
-                         FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-                      -> core_check_t -> env)
-  =
-  fun deps ->
-    fun tc_term ->
-      fun typeof_tot_or_gtot_term ->
-        fun typeof_tot_or_gtot_term_fastpath ->
-          fun universe_of ->
-            fun teq_nosmt_force ->
-              fun subtype_nosmt_force ->
-                fun solver ->
-                  fun module_lid ->
-                    fun nbe ->
-                      fun core_check ->
-                        let uu___ = new_gamma_cache () in
-                        let uu___1 = new_sigtab () in
-                        let uu___2 = new_sigtab () in
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Compiler_Util.smap_create
-                              (Prims.of_int (10)) in
-                          (uu___4, FStar_Pervasives_Native.None) in
-                        let uu___4 =
-                          FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-                        let uu___5 =
-                          FStar_Compiler_Util.smap_create (Prims.of_int (50)) in
-                        let uu___6 = FStar_Options.using_facts_from () in
-                        let uu___7 =
-                          FStar_Compiler_Util.mk_ref
-                            FStar_TypeChecker_Common.id_info_table_empty in
-                        let uu___8 = FStar_Syntax_DsEnv.empty_env deps in
-                        let uu___9 =
-                          FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-                        let uu___10 =
-                          FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-                        {
-                          solver;
-                          range = FStar_Compiler_Range.dummyRange;
-                          curmodule = module_lid;
-                          gamma = [];
-                          gamma_sig = [];
-                          gamma_cache = uu___;
-                          modules = [];
-                          expected_typ = FStar_Pervasives_Native.None;
-                          sigtab = uu___1;
-                          attrtab = uu___2;
-                          instantiate_imp = true;
-                          effects =
-                            {
-                              decls = [];
-                              order = [];
-                              joins = [];
-                              polymonadic_binds = [];
-                              polymonadic_subcomps = []
-                            };
-                          generalize = true;
-                          letrecs = [];
-                          top_level = false;
-                          check_uvars = false;
-                          use_eq_strict = false;
-                          is_iface = false;
-                          admit = false;
-                          lax = false;
-                          lax_universes = false;
-                          phase1 = false;
-                          failhard = false;
-                          nosynth = false;
-                          uvar_subtyping = true;
-                          tc_term;
-                          typeof_tot_or_gtot_term;
-                          universe_of;
-                          typeof_well_typed_tot_or_gtot_term =
-                            (fun env1 ->
-                               fun t ->
-                                 fun must_tot1 ->
-                                   let uu___11 =
-                                     typeof_tot_or_gtot_term_fastpath env1 t
-                                       must_tot1 in
-                                   match uu___11 with
-                                   | FStar_Pervasives_Native.Some k ->
-                                       (k,
-                                         FStar_TypeChecker_Common.trivial_guard)
-                                   | FStar_Pervasives_Native.None ->
-                                       let uu___12 =
-                                         typeof_tot_or_gtot_term env1 t
-                                           must_tot1 in
-                                       (match uu___12 with
-                                        | (t', k, g) -> (k, g)));
-                          teq_nosmt_force;
-                          subtype_nosmt_force;
-                          qtbl_name_and_index = uu___3;
-                          normalized_eff_names = uu___4;
-                          fv_delta_depths = uu___5;
-                          proof_ns = uu___6;
-                          synth_hook =
-                            (fun e ->
-                               fun g ->
-                                 fun tau ->
-                                   failwith "no synthesizer available");
-                          try_solve_implicits_hook =
-                            (fun e ->
-                               fun tau ->
-                                 fun imps ->
-                                   failwith "no implicit hook available");
-                          splice =
-                            (fun e ->
-                               fun rng ->
-                                 fun tau -> failwith "no splicer available");
-                          mpreprocess =
-                            (fun e ->
-                               fun tau ->
-                                 fun tm ->
-                                   failwith "no preprocessor available");
-                          postprocess =
-                            (fun e ->
-                               fun tau ->
-                                 fun typ ->
-                                   fun tm ->
-                                     failwith "no postprocessor available");
-                          identifier_info = uu___7;
-                          tc_hooks = default_tc_hooks;
-                          dsenv = uu___8;
-                          nbe;
-                          strict_args_tab = uu___9;
-                          erasable_types_tab = uu___10;
-                          enable_defer_to_tac = true;
-                          unif_allow_ref_guards = false;
-                          erase_erasable_args = false;
-                          core_check
-                        }
-let (dsenv : env -> FStar_Syntax_DsEnv.env) = fun env1 -> env1.dsenv
-let (sigtab : env -> FStar_Syntax_Syntax.sigelt FStar_Compiler_Util.smap) =
-  fun env1 -> env1.sigtab
-let (attrtab :
-  env -> FStar_Syntax_Syntax.sigelt Prims.list FStar_Compiler_Util.smap) =
-  fun env1 -> env1.attrtab
-let (gamma_cache : env -> cached_elt FStar_Compiler_Util.smap) =
-  fun env1 -> env1.gamma_cache
-let (query_indices :
-  (FStar_Ident.lident * Prims.int) Prims.list Prims.list
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref [[]]
-let (push_query_indices : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang query_indices in
-    match uu___1 with
-    | [] -> failwith "Empty query indices!"
-    | uu___2 ->
-        let uu___3 =
-          let uu___4 =
-            let uu___5 = FStar_Compiler_Effect.op_Bang query_indices in
-            FStar_Compiler_List.hd uu___5 in
-          let uu___5 = FStar_Compiler_Effect.op_Bang query_indices in uu___4
-            :: uu___5 in
-        FStar_Compiler_Effect.op_Colon_Equals query_indices uu___3
-let (pop_query_indices : unit -> unit) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang query_indices in
-    match uu___1 with
-    | [] -> failwith "Empty query indices!"
-    | hd::tl -> FStar_Compiler_Effect.op_Colon_Equals query_indices tl
-let (snapshot_query_indices : unit -> (Prims.int * unit)) =
-  fun uu___ -> FStar_Common.snapshot push_query_indices query_indices ()
-let (rollback_query_indices :
-  Prims.int FStar_Pervasives_Native.option -> unit) =
-  fun depth -> FStar_Common.rollback pop_query_indices query_indices depth
-let (add_query_index : (FStar_Ident.lident * Prims.int) -> unit) =
-  fun uu___ ->
-    match uu___ with
-    | (l, n) ->
-        let uu___1 = FStar_Compiler_Effect.op_Bang query_indices in
-        (match uu___1 with
-         | hd::tl ->
-             FStar_Compiler_Effect.op_Colon_Equals query_indices (((l, n) ::
-               hd) :: tl)
-         | uu___2 -> failwith "Empty query indices")
-let (peek_query_indices :
-  unit -> (FStar_Ident.lident * Prims.int) Prims.list) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang query_indices in
-    FStar_Compiler_List.hd uu___1
-let (stack : env Prims.list FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref []
-let (push_stack : env -> env) =
-  fun env1 ->
-    (let uu___1 =
-       let uu___2 = FStar_Compiler_Effect.op_Bang stack in env1 :: uu___2 in
-     FStar_Compiler_Effect.op_Colon_Equals stack uu___1);
-    (let uu___1 = FStar_Compiler_Util.smap_copy (gamma_cache env1) in
-     let uu___2 = FStar_Compiler_Util.smap_copy (sigtab env1) in
-     let uu___3 = FStar_Compiler_Util.smap_copy (attrtab env1) in
-     let uu___4 =
-       let uu___5 =
-         let uu___6 =
-           FStar_Compiler_Effect.op_Bar_Greater env1.qtbl_name_and_index
-             FStar_Pervasives_Native.fst in
-         FStar_Compiler_Util.smap_copy uu___6 in
-       let uu___6 =
-         FStar_Compiler_Effect.op_Bar_Greater env1.qtbl_name_and_index
-           FStar_Pervasives_Native.snd in
-       (uu___5, uu___6) in
-     let uu___5 = FStar_Compiler_Util.smap_copy env1.normalized_eff_names in
-     let uu___6 = FStar_Compiler_Util.smap_copy env1.fv_delta_depths in
-     let uu___7 =
-       let uu___8 = FStar_Compiler_Effect.op_Bang env1.identifier_info in
-       FStar_Compiler_Util.mk_ref uu___8 in
-     let uu___8 = FStar_Compiler_Util.smap_copy env1.strict_args_tab in
-     let uu___9 = FStar_Compiler_Util.smap_copy env1.erasable_types_tab in
-     {
-       solver = (env1.solver);
-       range = (env1.range);
-       curmodule = (env1.curmodule);
-       gamma = (env1.gamma);
-       gamma_sig = (env1.gamma_sig);
-       gamma_cache = uu___1;
-       modules = (env1.modules);
-       expected_typ = (env1.expected_typ);
-       sigtab = uu___2;
-       attrtab = uu___3;
-       instantiate_imp = (env1.instantiate_imp);
-       effects = (env1.effects);
-       generalize = (env1.generalize);
-       letrecs = (env1.letrecs);
-       top_level = (env1.top_level);
-       check_uvars = (env1.check_uvars);
-       use_eq_strict = (env1.use_eq_strict);
-       is_iface = (env1.is_iface);
-       admit = (env1.admit);
-       lax = (env1.lax);
-       lax_universes = (env1.lax_universes);
-       phase1 = (env1.phase1);
-       failhard = (env1.failhard);
-       nosynth = (env1.nosynth);
-       uvar_subtyping = (env1.uvar_subtyping);
-       tc_term = (env1.tc_term);
-       typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-       universe_of = (env1.universe_of);
-       typeof_well_typed_tot_or_gtot_term =
-         (env1.typeof_well_typed_tot_or_gtot_term);
-       teq_nosmt_force = (env1.teq_nosmt_force);
-       subtype_nosmt_force = (env1.subtype_nosmt_force);
-       qtbl_name_and_index = uu___4;
-       normalized_eff_names = uu___5;
-       fv_delta_depths = uu___6;
-       proof_ns = (env1.proof_ns);
-       synth_hook = (env1.synth_hook);
-       try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-       splice = (env1.splice);
-       mpreprocess = (env1.mpreprocess);
-       postprocess = (env1.postprocess);
-       identifier_info = uu___7;
-       tc_hooks = (env1.tc_hooks);
-       dsenv = (env1.dsenv);
-       nbe = (env1.nbe);
-       strict_args_tab = uu___8;
-       erasable_types_tab = uu___9;
-       enable_defer_to_tac = (env1.enable_defer_to_tac);
-       unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-       erase_erasable_args = (env1.erase_erasable_args);
-       core_check = (env1.core_check)
-     })
-let (pop_stack : unit -> env) =
-  fun uu___ ->
-    let uu___1 = FStar_Compiler_Effect.op_Bang stack in
-    match uu___1 with
-    | env1::tl -> (FStar_Compiler_Effect.op_Colon_Equals stack tl; env1)
-    | uu___2 -> failwith "Impossible: Too many pops"
-let (snapshot_stack : env -> (Prims.int * env)) =
-  fun env1 -> FStar_Common.snapshot push_stack stack env1
-let (rollback_stack : Prims.int FStar_Pervasives_Native.option -> env) =
-  fun depth -> FStar_Common.rollback pop_stack stack depth
-let (snapshot : env -> Prims.string -> (tcenv_depth_t * env)) =
-  fun env1 ->
-    fun msg ->
-      FStar_Compiler_Util.atomically
-        (fun uu___ ->
-           let uu___1 = snapshot_stack env1 in
-           match uu___1 with
-           | (stack_depth, env2) ->
-               let uu___2 = snapshot_query_indices () in
-               (match uu___2 with
-                | (query_indices_depth, ()) ->
-                    let uu___3 = (env2.solver).snapshot msg in
-                    (match uu___3 with
-                     | (solver_depth, ()) ->
-                         let uu___4 = FStar_Syntax_DsEnv.snapshot env2.dsenv in
-                         (match uu___4 with
-                          | (dsenv_depth, dsenv1) ->
-                              ((stack_depth, query_indices_depth,
-                                 solver_depth, dsenv_depth),
-                                {
-                                  solver = (env2.solver);
-                                  range = (env2.range);
-                                  curmodule = (env2.curmodule);
-                                  gamma = (env2.gamma);
-                                  gamma_sig = (env2.gamma_sig);
-                                  gamma_cache = (env2.gamma_cache);
-                                  modules = (env2.modules);
-                                  expected_typ = (env2.expected_typ);
-                                  sigtab = (env2.sigtab);
-                                  attrtab = (env2.attrtab);
-                                  instantiate_imp = (env2.instantiate_imp);
-                                  effects = (env2.effects);
-                                  generalize = (env2.generalize);
-                                  letrecs = (env2.letrecs);
-                                  top_level = (env2.top_level);
-                                  check_uvars = (env2.check_uvars);
-                                  use_eq_strict = (env2.use_eq_strict);
-                                  is_iface = (env2.is_iface);
-                                  admit = (env2.admit);
-                                  lax = (env2.lax);
-                                  lax_universes = (env2.lax_universes);
-                                  phase1 = (env2.phase1);
-                                  failhard = (env2.failhard);
-                                  nosynth = (env2.nosynth);
-                                  uvar_subtyping = (env2.uvar_subtyping);
-                                  tc_term = (env2.tc_term);
-                                  typeof_tot_or_gtot_term =
-                                    (env2.typeof_tot_or_gtot_term);
-                                  universe_of = (env2.universe_of);
-                                  typeof_well_typed_tot_or_gtot_term =
-                                    (env2.typeof_well_typed_tot_or_gtot_term);
-                                  teq_nosmt_force = (env2.teq_nosmt_force);
-                                  subtype_nosmt_force =
-                                    (env2.subtype_nosmt_force);
-                                  qtbl_name_and_index =
-                                    (env2.qtbl_name_and_index);
-                                  normalized_eff_names =
-                                    (env2.normalized_eff_names);
-                                  fv_delta_depths = (env2.fv_delta_depths);
-                                  proof_ns = (env2.proof_ns);
-                                  synth_hook = (env2.synth_hook);
-                                  try_solve_implicits_hook =
-                                    (env2.try_solve_implicits_hook);
-                                  splice = (env2.splice);
-                                  mpreprocess = (env2.mpreprocess);
-                                  postprocess = (env2.postprocess);
-                                  identifier_info = (env2.identifier_info);
-                                  tc_hooks = (env2.tc_hooks);
-                                  dsenv = dsenv1;
-                                  nbe = (env2.nbe);
-                                  strict_args_tab = (env2.strict_args_tab);
-                                  erasable_types_tab =
-                                    (env2.erasable_types_tab);
-                                  enable_defer_to_tac =
-                                    (env2.enable_defer_to_tac);
-                                  unif_allow_ref_guards =
-                                    (env2.unif_allow_ref_guards);
-                                  erase_erasable_args =
-                                    (env2.erase_erasable_args);
-                                  core_check = (env2.core_check)
-                                })))))
-let (rollback :
-  solver_t ->
-    Prims.string -> tcenv_depth_t FStar_Pervasives_Native.option -> env)
-  =
-  fun solver ->
-    fun msg ->
-      fun depth ->
-        FStar_Compiler_Util.atomically
-          (fun uu___ ->
-             let uu___1 =
-               match depth with
-               | FStar_Pervasives_Native.Some (s1, s2, s3, s4) ->
-                   ((FStar_Pervasives_Native.Some s1),
-                     (FStar_Pervasives_Native.Some s2),
-                     (FStar_Pervasives_Native.Some s3),
-                     (FStar_Pervasives_Native.Some s4))
-               | FStar_Pervasives_Native.None ->
-                   (FStar_Pervasives_Native.None,
-                     FStar_Pervasives_Native.None,
-                     FStar_Pervasives_Native.None,
-                     FStar_Pervasives_Native.None) in
-             match uu___1 with
-             | (stack_depth, query_indices_depth, solver_depth, dsenv_depth)
-                 ->
-                 (solver.rollback msg solver_depth;
-                  (match () with
-                   | () ->
-                       (rollback_query_indices query_indices_depth;
-                        (match () with
-                         | () ->
-                             let tcenv = rollback_stack stack_depth in
-                             let dsenv1 =
-                               FStar_Syntax_DsEnv.rollback dsenv_depth in
-                             ((let uu___5 =
-                                 FStar_Compiler_Util.physical_equality
-                                   tcenv.dsenv dsenv1 in
-                               FStar_Common.runtime_assert uu___5
-                                 "Inconsistent stack state");
-                              tcenv))))))
-let (push : env -> Prims.string -> env) =
-  fun env1 ->
-    fun msg ->
-      let uu___ = snapshot env1 msg in FStar_Pervasives_Native.snd uu___
-let (pop : env -> Prims.string -> env) =
-  fun env1 ->
-    fun msg -> rollback env1.solver msg FStar_Pervasives_Native.None
-let (incr_query_index : env -> env) =
-  fun env1 ->
-    let qix = peek_query_indices () in
-    match env1.qtbl_name_and_index with
-    | (uu___, FStar_Pervasives_Native.None) -> env1
-    | (tbl, FStar_Pervasives_Native.Some (l, n)) ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater qix
-            (FStar_Compiler_List.tryFind
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (m, uu___2) -> FStar_Ident.lid_equals l m)) in
-        (match uu___ with
-         | FStar_Pervasives_Native.None ->
-             let next = n + Prims.int_one in
-             (add_query_index (l, next);
-              (let uu___3 = FStar_Ident.string_of_lid l in
-               FStar_Compiler_Util.smap_add tbl uu___3 next);
-              {
-                solver = (env1.solver);
-                range = (env1.range);
-                curmodule = (env1.curmodule);
-                gamma = (env1.gamma);
-                gamma_sig = (env1.gamma_sig);
-                gamma_cache = (env1.gamma_cache);
-                modules = (env1.modules);
-                expected_typ = (env1.expected_typ);
-                sigtab = (env1.sigtab);
-                attrtab = (env1.attrtab);
-                instantiate_imp = (env1.instantiate_imp);
-                effects = (env1.effects);
-                generalize = (env1.generalize);
-                letrecs = (env1.letrecs);
-                top_level = (env1.top_level);
-                check_uvars = (env1.check_uvars);
-                use_eq_strict = (env1.use_eq_strict);
-                is_iface = (env1.is_iface);
-                admit = (env1.admit);
-                lax = (env1.lax);
-                lax_universes = (env1.lax_universes);
-                phase1 = (env1.phase1);
-                failhard = (env1.failhard);
-                nosynth = (env1.nosynth);
-                uvar_subtyping = (env1.uvar_subtyping);
-                tc_term = (env1.tc_term);
-                typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-                universe_of = (env1.universe_of);
-                typeof_well_typed_tot_or_gtot_term =
-                  (env1.typeof_well_typed_tot_or_gtot_term);
-                teq_nosmt_force = (env1.teq_nosmt_force);
-                subtype_nosmt_force = (env1.subtype_nosmt_force);
-                qtbl_name_and_index =
-                  (tbl, (FStar_Pervasives_Native.Some (l, next)));
-                normalized_eff_names = (env1.normalized_eff_names);
-                fv_delta_depths = (env1.fv_delta_depths);
-                proof_ns = (env1.proof_ns);
-                synth_hook = (env1.synth_hook);
-                try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-                splice = (env1.splice);
-                mpreprocess = (env1.mpreprocess);
-                postprocess = (env1.postprocess);
-                identifier_info = (env1.identifier_info);
-                tc_hooks = (env1.tc_hooks);
-                dsenv = (env1.dsenv);
-                nbe = (env1.nbe);
-                strict_args_tab = (env1.strict_args_tab);
-                erasable_types_tab = (env1.erasable_types_tab);
-                enable_defer_to_tac = (env1.enable_defer_to_tac);
-                unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-                erase_erasable_args = (env1.erase_erasable_args);
-                core_check = (env1.core_check)
-              })
-         | FStar_Pervasives_Native.Some (uu___1, m) ->
-             let next = m + Prims.int_one in
-             (add_query_index (l, next);
-              (let uu___4 = FStar_Ident.string_of_lid l in
-               FStar_Compiler_Util.smap_add tbl uu___4 next);
-              {
-                solver = (env1.solver);
-                range = (env1.range);
-                curmodule = (env1.curmodule);
-                gamma = (env1.gamma);
-                gamma_sig = (env1.gamma_sig);
-                gamma_cache = (env1.gamma_cache);
-                modules = (env1.modules);
-                expected_typ = (env1.expected_typ);
-                sigtab = (env1.sigtab);
-                attrtab = (env1.attrtab);
-                instantiate_imp = (env1.instantiate_imp);
-                effects = (env1.effects);
-                generalize = (env1.generalize);
-                letrecs = (env1.letrecs);
-                top_level = (env1.top_level);
-                check_uvars = (env1.check_uvars);
-                use_eq_strict = (env1.use_eq_strict);
-                is_iface = (env1.is_iface);
-                admit = (env1.admit);
-                lax = (env1.lax);
-                lax_universes = (env1.lax_universes);
-                phase1 = (env1.phase1);
-                failhard = (env1.failhard);
-                nosynth = (env1.nosynth);
-                uvar_subtyping = (env1.uvar_subtyping);
-                tc_term = (env1.tc_term);
-                typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-                universe_of = (env1.universe_of);
-                typeof_well_typed_tot_or_gtot_term =
-                  (env1.typeof_well_typed_tot_or_gtot_term);
-                teq_nosmt_force = (env1.teq_nosmt_force);
-                subtype_nosmt_force = (env1.subtype_nosmt_force);
-                qtbl_name_and_index =
-                  (tbl, (FStar_Pervasives_Native.Some (l, next)));
-                normalized_eff_names = (env1.normalized_eff_names);
-                fv_delta_depths = (env1.fv_delta_depths);
-                proof_ns = (env1.proof_ns);
-                synth_hook = (env1.synth_hook);
-                try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-                splice = (env1.splice);
-                mpreprocess = (env1.mpreprocess);
-                postprocess = (env1.postprocess);
-                identifier_info = (env1.identifier_info);
-                tc_hooks = (env1.tc_hooks);
-                dsenv = (env1.dsenv);
-                nbe = (env1.nbe);
-                strict_args_tab = (env1.strict_args_tab);
-                erasable_types_tab = (env1.erasable_types_tab);
-                enable_defer_to_tac = (env1.enable_defer_to_tac);
-                unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-                erase_erasable_args = (env1.erase_erasable_args);
-                core_check = (env1.core_check)
-              }))
-let (debug : env -> FStar_Options.debug_level_t -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      let uu___ = FStar_Ident.string_of_lid env1.curmodule in
-      FStar_Options.debug_at_level uu___ l
-let (set_range : env -> FStar_Compiler_Range.range -> env) =
-  fun e ->
-    fun r ->
-      if r = FStar_Compiler_Range.dummyRange
-      then e
-      else
-        {
-          solver = (e.solver);
-          range = r;
-          curmodule = (e.curmodule);
-          gamma = (e.gamma);
-          gamma_sig = (e.gamma_sig);
-          gamma_cache = (e.gamma_cache);
-          modules = (e.modules);
-          expected_typ = (e.expected_typ);
-          sigtab = (e.sigtab);
-          attrtab = (e.attrtab);
-          instantiate_imp = (e.instantiate_imp);
-          effects = (e.effects);
-          generalize = (e.generalize);
-          letrecs = (e.letrecs);
-          top_level = (e.top_level);
-          check_uvars = (e.check_uvars);
-          use_eq_strict = (e.use_eq_strict);
-          is_iface = (e.is_iface);
-          admit = (e.admit);
-          lax = (e.lax);
-          lax_universes = (e.lax_universes);
-          phase1 = (e.phase1);
-          failhard = (e.failhard);
-          nosynth = (e.nosynth);
-          uvar_subtyping = (e.uvar_subtyping);
-          tc_term = (e.tc_term);
-          typeof_tot_or_gtot_term = (e.typeof_tot_or_gtot_term);
-          universe_of = (e.universe_of);
-          typeof_well_typed_tot_or_gtot_term =
-            (e.typeof_well_typed_tot_or_gtot_term);
-          teq_nosmt_force = (e.teq_nosmt_force);
-          subtype_nosmt_force = (e.subtype_nosmt_force);
-          qtbl_name_and_index = (e.qtbl_name_and_index);
-          normalized_eff_names = (e.normalized_eff_names);
-          fv_delta_depths = (e.fv_delta_depths);
-          proof_ns = (e.proof_ns);
-          synth_hook = (e.synth_hook);
-          try_solve_implicits_hook = (e.try_solve_implicits_hook);
-          splice = (e.splice);
-          mpreprocess = (e.mpreprocess);
-          postprocess = (e.postprocess);
-          identifier_info = (e.identifier_info);
-          tc_hooks = (e.tc_hooks);
-          dsenv = (e.dsenv);
-          nbe = (e.nbe);
-          strict_args_tab = (e.strict_args_tab);
-          erasable_types_tab = (e.erasable_types_tab);
-          enable_defer_to_tac = (e.enable_defer_to_tac);
-          unif_allow_ref_guards = (e.unif_allow_ref_guards);
-          erase_erasable_args = (e.erase_erasable_args);
-          core_check = (e.core_check)
-        }
-let (get_range : env -> FStar_Compiler_Range.range) = fun e -> e.range
-let (toggle_id_info : env -> Prims.bool -> unit) =
-  fun env1 ->
-    fun enabled ->
-      let uu___ =
-        let uu___1 = FStar_Compiler_Effect.op_Bang env1.identifier_info in
-        FStar_TypeChecker_Common.id_info_toggle uu___1 enabled in
-      FStar_Compiler_Effect.op_Colon_Equals env1.identifier_info uu___
-let (insert_bv_info :
-  env -> FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.typ -> unit) =
-  fun env1 ->
-    fun bv ->
-      fun ty ->
-        let uu___ =
-          let uu___1 = FStar_Compiler_Effect.op_Bang env1.identifier_info in
-          FStar_TypeChecker_Common.id_info_insert_bv uu___1 bv ty in
-        FStar_Compiler_Effect.op_Colon_Equals env1.identifier_info uu___
-let (insert_fv_info :
-  env -> FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.typ -> unit) =
-  fun env1 ->
-    fun fv ->
-      fun ty ->
-        let uu___ =
-          let uu___1 = FStar_Compiler_Effect.op_Bang env1.identifier_info in
-          FStar_TypeChecker_Common.id_info_insert_fv uu___1 fv ty in
-        FStar_Compiler_Effect.op_Colon_Equals env1.identifier_info uu___
-let (promote_id_info :
-  env -> (FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ) -> unit) =
-  fun env1 ->
-    fun ty_map ->
-      let uu___ =
-        let uu___1 = FStar_Compiler_Effect.op_Bang env1.identifier_info in
-        FStar_TypeChecker_Common.id_info_promote uu___1 ty_map in
-      FStar_Compiler_Effect.op_Colon_Equals env1.identifier_info uu___
-let (modules : env -> FStar_Syntax_Syntax.modul Prims.list) =
-  fun env1 -> env1.modules
-let (current_module : env -> FStar_Ident.lident) = fun env1 -> env1.curmodule
-let (set_current_module : env -> FStar_Ident.lident -> env) =
-  fun env1 ->
-    fun lid ->
-      {
-        solver = (env1.solver);
-        range = (env1.range);
-        curmodule = lid;
-        gamma = (env1.gamma);
-        gamma_sig = (env1.gamma_sig);
-        gamma_cache = (env1.gamma_cache);
-        modules = (env1.modules);
-        expected_typ = (env1.expected_typ);
-        sigtab = (env1.sigtab);
-        attrtab = (env1.attrtab);
-        instantiate_imp = (env1.instantiate_imp);
-        effects = (env1.effects);
-        generalize = (env1.generalize);
-        letrecs = (env1.letrecs);
-        top_level = (env1.top_level);
-        check_uvars = (env1.check_uvars);
-        use_eq_strict = (env1.use_eq_strict);
-        is_iface = (env1.is_iface);
-        admit = (env1.admit);
-        lax = (env1.lax);
-        lax_universes = (env1.lax_universes);
-        phase1 = (env1.phase1);
-        failhard = (env1.failhard);
-        nosynth = (env1.nosynth);
-        uvar_subtyping = (env1.uvar_subtyping);
-        tc_term = (env1.tc_term);
-        typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-        universe_of = (env1.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (env1.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (env1.teq_nosmt_force);
-        subtype_nosmt_force = (env1.subtype_nosmt_force);
-        qtbl_name_and_index = (env1.qtbl_name_and_index);
-        normalized_eff_names = (env1.normalized_eff_names);
-        fv_delta_depths = (env1.fv_delta_depths);
-        proof_ns = (env1.proof_ns);
-        synth_hook = (env1.synth_hook);
-        try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-        splice = (env1.splice);
-        mpreprocess = (env1.mpreprocess);
-        postprocess = (env1.postprocess);
-        identifier_info = (env1.identifier_info);
-        tc_hooks = (env1.tc_hooks);
-        dsenv = (env1.dsenv);
-        nbe = (env1.nbe);
-        strict_args_tab = (env1.strict_args_tab);
-        erasable_types_tab = (env1.erasable_types_tab);
-        enable_defer_to_tac = (env1.enable_defer_to_tac);
-        unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-        erase_erasable_args = (env1.erase_erasable_args);
-        core_check = (env1.core_check)
-      }
-let (has_interface : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      FStar_Compiler_Effect.op_Bar_Greater env1.modules
-        (FStar_Compiler_Util.for_some
-           (fun m ->
-              m.FStar_Syntax_Syntax.is_interface &&
-                (FStar_Ident.lid_equals m.FStar_Syntax_Syntax.name l)))
-let (find_in_sigtab :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = FStar_Ident.string_of_lid lid in
-      FStar_Compiler_Util.smap_try_find (sigtab env1) uu___
-let (name_not_found :
-  FStar_Ident.lid -> (FStar_Errors.raw_error * Prims.string)) =
-  fun l ->
-    let uu___ =
-      let uu___1 = FStar_Ident.string_of_lid l in
-      FStar_Compiler_Util.format1 "Name \"%s\" not found" uu___1 in
-    (FStar_Errors.Fatal_NameNotFound, uu___)
-let (variable_not_found :
-  FStar_Syntax_Syntax.bv -> (FStar_Errors.raw_error * Prims.string)) =
-  fun v ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Print.bv_to_string v in
-      FStar_Compiler_Util.format1 "Variable \"%s\" not found" uu___1 in
-    (FStar_Errors.Fatal_VariableNotFound, uu___)
-let (new_u_univ : unit -> FStar_Syntax_Syntax.universe) =
-  fun uu___ ->
-    let uu___1 =
-      FStar_Syntax_Unionfind.univ_fresh FStar_Compiler_Range.dummyRange in
-    FStar_Syntax_Syntax.U_unif uu___1
-let (mk_univ_subst :
-  FStar_Syntax_Syntax.univ_name Prims.list ->
-    FStar_Syntax_Syntax.universes -> FStar_Syntax_Syntax.subst_elt Prims.list)
-  =
-  fun formals ->
-    fun us ->
-      let n = (FStar_Compiler_List.length formals) - Prims.int_one in
-      FStar_Compiler_Effect.op_Bar_Greater us
-        (FStar_Compiler_List.mapi
-           (fun i -> fun u -> FStar_Syntax_Syntax.UN ((n - i), u)))
-let (inst_tscheme_with :
-  FStar_Syntax_Syntax.tscheme ->
-    FStar_Syntax_Syntax.universes ->
-      (FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.term))
-  =
-  fun ts ->
-    fun us ->
-      match (ts, us) with
-      | (([], t), []) -> ([], t)
-      | ((formals, t), uu___) ->
-          let vs = mk_univ_subst formals us in
-          let uu___1 = FStar_Syntax_Subst.subst vs t in (us, uu___1)
-let (inst_tscheme :
-  FStar_Syntax_Syntax.tscheme ->
-    (FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.term))
-  =
-  fun uu___ ->
-    match uu___ with
-    | ([], t) -> ([], t)
-    | (us, t) ->
-        let us' =
-          FStar_Compiler_Effect.op_Bar_Greater us
-            (FStar_Compiler_List.map (fun uu___1 -> new_u_univ ())) in
-        inst_tscheme_with (us, t) us'
-let (inst_tscheme_with_range :
-  FStar_Compiler_Range.range ->
-    FStar_Syntax_Syntax.tscheme ->
-      (FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.term))
-  =
-  fun r ->
-    fun t ->
-      let uu___ = inst_tscheme t in
-      match uu___ with
-      | (us, t1) ->
-          let uu___1 = FStar_Syntax_Subst.set_use_range r t1 in (us, uu___1)
-let (check_effect_is_not_a_template :
-  FStar_Syntax_Syntax.eff_decl -> FStar_Compiler_Range.range -> unit) =
-  fun ed ->
-    fun rng ->
-      if
-        ((FStar_Compiler_List.length ed.FStar_Syntax_Syntax.univs) <>
-           Prims.int_zero)
-          ||
-          ((FStar_Compiler_List.length ed.FStar_Syntax_Syntax.binders) <>
-             Prims.int_zero)
-      then
-        let msg =
-          let uu___ =
-            FStar_Syntax_Print.lid_to_string ed.FStar_Syntax_Syntax.mname in
-          let uu___1 =
-            FStar_Syntax_Print.binders_to_string ", "
-              ed.FStar_Syntax_Syntax.binders in
-          FStar_Compiler_Util.format2
-            "Effect template %s should be applied to arguments for its binders (%s) before it can be used at an effect position"
-            uu___ uu___1 in
-        FStar_Errors.raise_error
-          (FStar_Errors.Fatal_NotEnoughArgumentsForEffect, msg) rng
-      else ()
-let (inst_effect_fun_with :
-  FStar_Syntax_Syntax.universes ->
-    env ->
-      FStar_Syntax_Syntax.eff_decl ->
-        FStar_Syntax_Syntax.tscheme -> FStar_Syntax_Syntax.term)
-  =
-  fun insts ->
-    fun env1 ->
-      fun ed ->
-        fun uu___ ->
-          match uu___ with
-          | (us, t) ->
-              (check_effect_is_not_a_template ed env1.range;
-               if
-                 (FStar_Compiler_List.length insts) <>
-                   (FStar_Compiler_List.length us)
-               then
-                 (let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Compiler_Util.string_of_int
-                        (FStar_Compiler_List.length us) in
-                    let uu___5 =
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Compiler_Util.string_of_int
-                        (FStar_Compiler_List.length insts) in
-                    let uu___6 =
-                      FStar_Syntax_Print.lid_to_string
-                        ed.FStar_Syntax_Syntax.mname in
-                    let uu___7 = FStar_Syntax_Print.term_to_string t in
-                    FStar_Compiler_Util.format4
-                      "Expected %s instantiations; got %s; failed universe instantiation in effect %s\n\t%s\n"
-                      uu___4 uu___5 uu___6 uu___7 in
-                  failwith uu___3)
-               else ();
-               (let uu___3 = inst_tscheme_with (us, t) insts in
-                FStar_Pervasives_Native.snd uu___3))
-type tri =
-  | Yes 
-  | No 
-  | Maybe 
-let (uu___is_Yes : tri -> Prims.bool) =
-  fun projectee -> match projectee with | Yes -> true | uu___ -> false
-let (uu___is_No : tri -> Prims.bool) =
-  fun projectee -> match projectee with | No -> true | uu___ -> false
-let (uu___is_Maybe : tri -> Prims.bool) =
-  fun projectee -> match projectee with | Maybe -> true | uu___ -> false
-let (in_cur_mod : env -> FStar_Ident.lident -> tri) =
-  fun env1 ->
-    fun l ->
-      let cur = current_module env1 in
-      let uu___ =
-        let uu___1 = FStar_Ident.nsstr l in
-        let uu___2 = FStar_Ident.string_of_lid cur in uu___1 = uu___2 in
-      if uu___
-      then Yes
-      else
-        (let uu___2 =
-           let uu___3 = FStar_Ident.nsstr l in
-           let uu___4 = FStar_Ident.string_of_lid cur in
-           FStar_Compiler_Util.starts_with uu___3 uu___4 in
-         if uu___2
-         then
-           let lns =
-             let uu___3 = FStar_Ident.ns_of_lid l in
-             let uu___4 = let uu___5 = FStar_Ident.ident_of_lid l in [uu___5] in
-             FStar_Compiler_List.op_At uu___3 uu___4 in
-           let cur1 =
-             let uu___3 = FStar_Ident.ns_of_lid cur in
-             let uu___4 =
-               let uu___5 = FStar_Ident.ident_of_lid cur in [uu___5] in
-             FStar_Compiler_List.op_At uu___3 uu___4 in
-           let rec aux c l1 =
-             match (c, l1) with
-             | ([], uu___3) -> Maybe
-             | (uu___3, []) -> No
-             | (hd::tl, hd'::tl') when
-                 let uu___3 = FStar_Ident.string_of_id hd in
-                 let uu___4 = FStar_Ident.string_of_id hd' in uu___3 = uu___4
-                 -> aux tl tl'
-             | uu___3 -> No in
-           aux cur1 lns
-         else No)
-let (lookup_qname : env -> FStar_Ident.lident -> qninfo) =
-  fun env1 ->
-    fun lid ->
-      let cur_mod = in_cur_mod env1 lid in
-      let cache t =
-        (let uu___1 = FStar_Ident.string_of_lid lid in
-         FStar_Compiler_Util.smap_add (gamma_cache env1) uu___1 t);
-        FStar_Pervasives_Native.Some t in
-      let found =
-        if cur_mod <> No
-        then
-          let uu___ =
-            let uu___1 = FStar_Ident.string_of_lid lid in
-            FStar_Compiler_Util.smap_try_find (gamma_cache env1) uu___1 in
-          match uu___ with
-          | FStar_Pervasives_Native.None ->
-              let uu___1 =
-                FStar_Compiler_Util.find_map env1.gamma
-                  (fun uu___2 ->
-                     match uu___2 with
-                     | FStar_Syntax_Syntax.Binding_lid (l, (us_names, t))
-                         when FStar_Ident.lid_equals lid l ->
-                         let us =
-                           FStar_Compiler_List.map
-                             (fun uu___3 -> FStar_Syntax_Syntax.U_name uu___3)
-                             us_names in
-                         let uu___3 =
-                           let uu___4 = FStar_Ident.range_of_lid l in
-                           ((FStar_Pervasives.Inl (us, t)), uu___4) in
-                         FStar_Pervasives_Native.Some uu___3
-                     | uu___3 -> FStar_Pervasives_Native.None) in
-              FStar_Compiler_Util.catch_opt uu___1
-                (fun uu___2 ->
-                   FStar_Compiler_Util.find_map env1.gamma_sig
-                     (fun uu___3 ->
-                        match uu___3 with
-                        | (uu___4,
-                           {
-                             FStar_Syntax_Syntax.sigel =
-                               FStar_Syntax_Syntax.Sig_bundle (ses, uu___5);
-                             FStar_Syntax_Syntax.sigrng = uu___6;
-                             FStar_Syntax_Syntax.sigquals = uu___7;
-                             FStar_Syntax_Syntax.sigmeta = uu___8;
-                             FStar_Syntax_Syntax.sigattrs = uu___9;
-                             FStar_Syntax_Syntax.sigopts = uu___10;_})
-                            ->
-                            FStar_Compiler_Util.find_map ses
-                              (fun se ->
-                                 let uu___11 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     (FStar_Syntax_Util.lids_of_sigelt se)
-                                     (FStar_Compiler_Util.for_some
-                                        (FStar_Ident.lid_equals lid)) in
-                                 if uu___11
-                                 then
-                                   cache
-                                     ((FStar_Pervasives.Inr
-                                         (se, FStar_Pervasives_Native.None)),
-                                       (FStar_Syntax_Util.range_of_sigelt se))
-                                 else FStar_Pervasives_Native.None)
-                        | (lids, s) ->
-                            let maybe_cache t =
-                              match s.FStar_Syntax_Syntax.sigel with
-                              | FStar_Syntax_Syntax.Sig_declare_typ uu___4 ->
-                                  FStar_Pervasives_Native.Some t
-                              | uu___4 -> cache t in
-                            let uu___4 =
-                              FStar_Compiler_List.tryFind
-                                (FStar_Ident.lid_equals lid) lids in
-                            (match uu___4 with
-                             | FStar_Pervasives_Native.None ->
-                                 FStar_Pervasives_Native.None
-                             | FStar_Pervasives_Native.Some l ->
-                                 let uu___5 =
-                                   let uu___6 = FStar_Ident.range_of_lid l in
-                                   ((FStar_Pervasives.Inr
-                                       (s, FStar_Pervasives_Native.None)),
-                                     uu___6) in
-                                 maybe_cache uu___5)))
-          | se -> se
-        else FStar_Pervasives_Native.None in
-      if FStar_Compiler_Util.is_some found
-      then found
-      else
-        (let uu___1 = find_in_sigtab env1 lid in
-         match uu___1 with
-         | FStar_Pervasives_Native.Some se ->
-             FStar_Pervasives_Native.Some
-               ((FStar_Pervasives.Inr (se, FStar_Pervasives_Native.None)),
-                 (FStar_Syntax_Util.range_of_sigelt se))
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None)
-let (lookup_sigelt :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (FStar_Pervasives.Inl uu___1, rng) ->
-          FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (FStar_Pervasives.Inr (se, us), rng) ->
-          FStar_Pervasives_Native.Some se
-let (lookup_attr :
-  env -> Prims.string -> FStar_Syntax_Syntax.sigelt Prims.list) =
-  fun env1 ->
-    fun attr ->
-      let uu___ = FStar_Compiler_Util.smap_try_find (attrtab env1) attr in
-      match uu___ with
-      | FStar_Pervasives_Native.Some ses -> ses
-      | FStar_Pervasives_Native.None -> []
-let (add_se_to_attrtab : env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun env1 ->
-    fun se ->
-      let add_one env2 se1 attr =
-        let uu___ = let uu___1 = lookup_attr env2 attr in se1 :: uu___1 in
-        FStar_Compiler_Util.smap_add (attrtab env2) attr uu___ in
-      FStar_Compiler_List.iter
-        (fun attr ->
-           let uu___ =
-             let uu___1 = FStar_Syntax_Subst.compress attr in
-             uu___1.FStar_Syntax_Syntax.n in
-           match uu___ with
-           | FStar_Syntax_Syntax.Tm_fvar fv ->
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Syntax.lid_of_fv fv in
-                 FStar_Ident.string_of_lid uu___2 in
-               add_one env1 se uu___1
-           | uu___1 -> ()) se.FStar_Syntax_Syntax.sigattrs
-let rec (add_sigelt : env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun env1 ->
-    fun se ->
-      match se.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_bundle (ses, uu___) -> add_sigelts env1 ses
-      | uu___ ->
-          let lids = FStar_Syntax_Util.lids_of_sigelt se in
-          (FStar_Compiler_List.iter
-             (fun l ->
-                let uu___2 = FStar_Ident.string_of_lid l in
-                FStar_Compiler_Util.smap_add (sigtab env1) uu___2 se) lids;
-           add_se_to_attrtab env1 se)
-and (add_sigelts : env -> FStar_Syntax_Syntax.sigelt Prims.list -> unit) =
-  fun env1 ->
-    fun ses ->
-      FStar_Compiler_Effect.op_Bar_Greater ses
-        (FStar_Compiler_List.iter (add_sigelt env1))
-let (try_lookup_bv :
-  env ->
-    FStar_Syntax_Syntax.bv ->
-      (FStar_Syntax_Syntax.typ * FStar_Compiler_Range.range)
-        FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun bv ->
-      FStar_Compiler_Util.find_map env1.gamma
-        (fun uu___ ->
-           match uu___ with
-           | FStar_Syntax_Syntax.Binding_var id when
-               FStar_Syntax_Syntax.bv_eq id bv ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Ident.range_of_id id.FStar_Syntax_Syntax.ppname in
-                 ((id.FStar_Syntax_Syntax.sort), uu___2) in
-               FStar_Pervasives_Native.Some uu___1
-           | uu___1 -> FStar_Pervasives_Native.None)
-let (lookup_type_of_let :
-  FStar_Syntax_Syntax.universes FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.sigelt ->
-      FStar_Ident.lident ->
-        ((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.term) *
-          FStar_Compiler_Range.range) FStar_Pervasives_Native.option)
-  =
-  fun us_opt ->
-    fun se ->
-      fun lid ->
-        let inst_tscheme1 ts =
-          match us_opt with
-          | FStar_Pervasives_Native.None -> inst_tscheme ts
-          | FStar_Pervasives_Native.Some us -> inst_tscheme_with ts us in
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_let ((uu___, lb::[]), uu___1) ->
-            let uu___2 =
-              let uu___3 =
-                inst_tscheme1
-                  ((lb.FStar_Syntax_Syntax.lbunivs),
-                    (lb.FStar_Syntax_Syntax.lbtyp)) in
-              let uu___4 =
-                FStar_Syntax_Syntax.range_of_lbname
-                  lb.FStar_Syntax_Syntax.lbname in
-              (uu___3, uu___4) in
-            FStar_Pervasives_Native.Some uu___2
-        | FStar_Syntax_Syntax.Sig_let ((uu___, lbs), uu___1) ->
-            FStar_Compiler_Util.find_map lbs
-              (fun lb ->
-                 match lb.FStar_Syntax_Syntax.lbname with
-                 | FStar_Pervasives.Inl uu___2 -> failwith "impossible"
-                 | FStar_Pervasives.Inr fv ->
-                     let uu___2 = FStar_Syntax_Syntax.fv_eq_lid fv lid in
-                     if uu___2
-                     then
-                       let uu___3 =
-                         let uu___4 =
-                           inst_tscheme1
-                             ((lb.FStar_Syntax_Syntax.lbunivs),
-                               (lb.FStar_Syntax_Syntax.lbtyp)) in
-                         let uu___5 = FStar_Syntax_Syntax.range_of_fv fv in
-                         (uu___4, uu___5) in
-                       FStar_Pervasives_Native.Some uu___3
-                     else FStar_Pervasives_Native.None)
-        | uu___ -> FStar_Pervasives_Native.None
-let (effect_signature :
-  FStar_Syntax_Syntax.universes FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.sigelt ->
-      FStar_Compiler_Range.range ->
-        ((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ) *
-          FStar_Compiler_Range.range) FStar_Pervasives_Native.option)
-  =
-  fun us_opt ->
-    fun se ->
-      fun rng ->
-        let inst_ts us_opt1 ts =
-          match us_opt1 with
-          | FStar_Pervasives_Native.None -> inst_tscheme ts
-          | FStar_Pervasives_Native.Some us -> inst_tscheme_with ts us in
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_new_effect ne ->
-            let sig_ts =
-              FStar_Syntax_Util.effect_sig_ts
-                ne.FStar_Syntax_Syntax.signature in
-            (check_effect_is_not_a_template ne rng;
-             (match us_opt with
-              | FStar_Pervasives_Native.None -> ()
-              | FStar_Pervasives_Native.Some us ->
-                  if
-                    (FStar_Compiler_List.length us) <>
-                      (FStar_Compiler_List.length
-                         (FStar_Pervasives_Native.fst sig_ts))
-                  then
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Ident.string_of_lid
-                            ne.FStar_Syntax_Syntax.mname in
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Compiler_Util.string_of_int
-                                (FStar_Compiler_List.length
-                                   (FStar_Pervasives_Native.fst sig_ts)) in
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_Compiler_Util.string_of_int
-                                  (FStar_Compiler_List.length us) in
-                              Prims.op_Hat ", got " uu___9 in
-                            Prims.op_Hat uu___7 uu___8 in
-                          Prims.op_Hat ", expected " uu___6 in
-                        Prims.op_Hat uu___4 uu___5 in
-                      Prims.op_Hat
-                        "effect_signature: incorrect number of universes for the signature of "
-                        uu___3 in
-                    failwith uu___2
-                  else ());
-             (let uu___2 =
-                let uu___3 = inst_ts us_opt sig_ts in
-                (uu___3, (se.FStar_Syntax_Syntax.sigrng)) in
-              FStar_Pervasives_Native.Some uu___2))
-        | FStar_Syntax_Syntax.Sig_effect_abbrev
-            (lid, us, binders, uu___, uu___1) ->
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      FStar_Syntax_Syntax.mk_Total FStar_Syntax_Syntax.teff in
-                    FStar_Syntax_Util.arrow binders uu___6 in
-                  (us, uu___5) in
-                inst_ts us_opt uu___4 in
-              (uu___3, (se.FStar_Syntax_Syntax.sigrng)) in
-            FStar_Pervasives_Native.Some uu___2
-        | uu___ -> FStar_Pervasives_Native.None
-let (try_lookup_lid_aux :
-  FStar_Syntax_Syntax.universes FStar_Pervasives_Native.option ->
-    env ->
-      FStar_Ident.lident ->
-        ((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax) * FStar_Compiler_Range.range)
-          FStar_Pervasives_Native.option)
-  =
-  fun us_opt ->
-    fun env1 ->
-      fun lid ->
-        let inst_tscheme1 ts =
-          match us_opt with
-          | FStar_Pervasives_Native.None -> inst_tscheme ts
-          | FStar_Pervasives_Native.Some us -> inst_tscheme_with ts us in
-        let mapper uu___ =
-          match uu___ with
-          | (lr, rng) ->
-              (match lr with
-               | FStar_Pervasives.Inl t ->
-                   FStar_Pervasives_Native.Some (t, rng)
-               | FStar_Pervasives.Inr
-                   ({
-                      FStar_Syntax_Syntax.sigel =
-                        FStar_Syntax_Syntax.Sig_datacon
-                        (uu___1, uvs, t, uu___2, uu___3, uu___4);
-                      FStar_Syntax_Syntax.sigrng = uu___5;
-                      FStar_Syntax_Syntax.sigquals = uu___6;
-                      FStar_Syntax_Syntax.sigmeta = uu___7;
-                      FStar_Syntax_Syntax.sigattrs = uu___8;
-                      FStar_Syntax_Syntax.sigopts = uu___9;_},
-                    FStar_Pervasives_Native.None)
-                   ->
-                   let uu___10 =
-                     let uu___11 = inst_tscheme1 (uvs, t) in (uu___11, rng) in
-                   FStar_Pervasives_Native.Some uu___10
-               | FStar_Pervasives.Inr
-                   ({
-                      FStar_Syntax_Syntax.sigel =
-                        FStar_Syntax_Syntax.Sig_declare_typ (l, uvs, t);
-                      FStar_Syntax_Syntax.sigrng = uu___1;
-                      FStar_Syntax_Syntax.sigquals = qs;
-                      FStar_Syntax_Syntax.sigmeta = uu___2;
-                      FStar_Syntax_Syntax.sigattrs = uu___3;
-                      FStar_Syntax_Syntax.sigopts = uu___4;_},
-                    FStar_Pervasives_Native.None)
-                   ->
-                   let uu___5 =
-                     let uu___6 = in_cur_mod env1 l in uu___6 = Yes in
-                   if uu___5
-                   then
-                     let uu___6 =
-                       (FStar_Compiler_Effect.op_Bar_Greater qs
-                          (FStar_Compiler_List.contains
-                             FStar_Syntax_Syntax.Assumption))
-                         || env1.is_iface in
-                     (if uu___6
-                      then
-                        let uu___7 =
-                          let uu___8 = inst_tscheme1 (uvs, t) in
-                          (uu___8, rng) in
-                        FStar_Pervasives_Native.Some uu___7
-                      else FStar_Pervasives_Native.None)
-                   else
-                     (let uu___7 =
-                        let uu___8 = inst_tscheme1 (uvs, t) in (uu___8, rng) in
-                      FStar_Pervasives_Native.Some uu___7)
-               | FStar_Pervasives.Inr
-                   ({
-                      FStar_Syntax_Syntax.sigel =
-                        FStar_Syntax_Syntax.Sig_inductive_typ
-                        (lid1, uvs, tps, uu___1, k, uu___2, uu___3);
-                      FStar_Syntax_Syntax.sigrng = uu___4;
-                      FStar_Syntax_Syntax.sigquals = uu___5;
-                      FStar_Syntax_Syntax.sigmeta = uu___6;
-                      FStar_Syntax_Syntax.sigattrs = uu___7;
-                      FStar_Syntax_Syntax.sigopts = uu___8;_},
-                    FStar_Pervasives_Native.None)
-                   ->
-                   (match tps with
-                    | [] ->
-                        let uu___9 =
-                          let uu___10 = inst_tscheme1 (uvs, k) in
-                          (uu___10, rng) in
-                        FStar_Pervasives_Native.Some uu___9
-                    | uu___9 ->
-                        let uu___10 =
-                          let uu___11 =
-                            let uu___12 =
-                              let uu___13 =
-                                let uu___14 = FStar_Syntax_Syntax.mk_Total k in
-                                FStar_Syntax_Util.flat_arrow tps uu___14 in
-                              (uvs, uu___13) in
-                            inst_tscheme1 uu___12 in
-                          (uu___11, rng) in
-                        FStar_Pervasives_Native.Some uu___10)
-               | FStar_Pervasives.Inr
-                   ({
-                      FStar_Syntax_Syntax.sigel =
-                        FStar_Syntax_Syntax.Sig_inductive_typ
-                        (lid1, uvs, tps, uu___1, k, uu___2, uu___3);
-                      FStar_Syntax_Syntax.sigrng = uu___4;
-                      FStar_Syntax_Syntax.sigquals = uu___5;
-                      FStar_Syntax_Syntax.sigmeta = uu___6;
-                      FStar_Syntax_Syntax.sigattrs = uu___7;
-                      FStar_Syntax_Syntax.sigopts = uu___8;_},
-                    FStar_Pervasives_Native.Some us)
-                   ->
-                   (match tps with
-                    | [] ->
-                        let uu___9 =
-                          let uu___10 = inst_tscheme_with (uvs, k) us in
-                          (uu___10, rng) in
-                        FStar_Pervasives_Native.Some uu___9
-                    | uu___9 ->
-                        let uu___10 =
-                          let uu___11 =
-                            let uu___12 =
-                              let uu___13 =
-                                let uu___14 = FStar_Syntax_Syntax.mk_Total k in
-                                FStar_Syntax_Util.flat_arrow tps uu___14 in
-                              (uvs, uu___13) in
-                            inst_tscheme_with uu___12 us in
-                          (uu___11, rng) in
-                        FStar_Pervasives_Native.Some uu___10)
-               | FStar_Pervasives.Inr se ->
-                   let uu___1 =
-                     match se with
-                     | ({
-                          FStar_Syntax_Syntax.sigel =
-                            FStar_Syntax_Syntax.Sig_let uu___2;
-                          FStar_Syntax_Syntax.sigrng = uu___3;
-                          FStar_Syntax_Syntax.sigquals = uu___4;
-                          FStar_Syntax_Syntax.sigmeta = uu___5;
-                          FStar_Syntax_Syntax.sigattrs = uu___6;
-                          FStar_Syntax_Syntax.sigopts = uu___7;_},
-                        FStar_Pervasives_Native.None) ->
-                         lookup_type_of_let us_opt
-                           (FStar_Pervasives_Native.fst se) lid
-                     | uu___2 ->
-                         effect_signature us_opt
-                           (FStar_Pervasives_Native.fst se) env1.range in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___1
-                     (FStar_Compiler_Util.map_option
-                        (fun uu___2 ->
-                           match uu___2 with | (us_t, rng1) -> (us_t, rng1)))) in
-        let uu___ =
-          let uu___1 = lookup_qname env1 lid in
-          FStar_Compiler_Util.bind_opt uu___1 mapper in
-        match uu___ with
-        | FStar_Pervasives_Native.Some ((us, t), r) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Ident.range_of_lid lid in
-                  {
-                    FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-                    FStar_Syntax_Syntax.pos = uu___4;
-                    FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                    FStar_Syntax_Syntax.hash_code =
-                      (t.FStar_Syntax_Syntax.hash_code)
-                  } in
-                (us, uu___3) in
-              (uu___2, r) in
-            FStar_Pervasives_Native.Some uu___1
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (lid_exists : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      let uu___ = lookup_qname env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some uu___1 -> true
-let (lookup_bv :
-  env ->
-    FStar_Syntax_Syntax.bv ->
-      (FStar_Syntax_Syntax.typ * FStar_Compiler_Range.range))
-  =
-  fun env1 ->
-    fun bv ->
-      let bvr = FStar_Syntax_Syntax.range_of_bv bv in
-      let uu___ = try_lookup_bv env1 bv in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = variable_not_found bv in
-          FStar_Errors.raise_error uu___1 bvr
-      | FStar_Pervasives_Native.Some (t, r) ->
-          let uu___1 = FStar_Syntax_Subst.set_use_range bvr t in
-          let uu___2 =
-            let uu___3 = FStar_Compiler_Range.use_range bvr in
-            FStar_Compiler_Range.set_use_range r uu___3 in
-          (uu___1, uu___2)
-let (try_lookup_lid :
-  env ->
-    FStar_Ident.lident ->
-      ((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ) *
-        FStar_Compiler_Range.range) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ = try_lookup_lid_aux FStar_Pervasives_Native.None env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some ((us, t), r) ->
-          let use_range = FStar_Ident.range_of_lid l in
-          let r1 =
-            let uu___1 = FStar_Compiler_Range.use_range use_range in
-            FStar_Compiler_Range.set_use_range r uu___1 in
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Subst.set_use_range use_range t in
-              (us, uu___3) in
-            (uu___2, r1) in
-          FStar_Pervasives_Native.Some uu___1
-let (try_lookup_and_inst_lid :
-  env ->
-    FStar_Syntax_Syntax.universes ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.typ * FStar_Compiler_Range.range)
-          FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun us ->
-      fun l ->
-        let uu___ =
-          try_lookup_lid_aux (FStar_Pervasives_Native.Some us) env1 l in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some ((uu___1, t), r) ->
-            let use_range = FStar_Ident.range_of_lid l in
-            let r1 =
-              let uu___2 = FStar_Compiler_Range.use_range use_range in
-              FStar_Compiler_Range.set_use_range r uu___2 in
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Subst.set_use_range use_range t in
-              (uu___3, r1) in
-            FStar_Pervasives_Native.Some uu___2
-let (lookup_lid :
-  env ->
-    FStar_Ident.lident ->
-      ((FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ) *
-        FStar_Compiler_Range.range))
-  =
-  fun env1 ->
-    fun l ->
-      let uu___ = try_lookup_lid env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = name_not_found l in
-          let uu___2 = FStar_Ident.range_of_lid l in
-          FStar_Errors.raise_error uu___1 uu___2
-      | FStar_Pervasives_Native.Some v -> v
-let (lookup_univ : env -> FStar_Syntax_Syntax.univ_name -> Prims.bool) =
-  fun env1 ->
-    fun x ->
-      let uu___ =
-        FStar_Compiler_List.find
-          (fun uu___1 ->
-             match uu___1 with
-             | FStar_Syntax_Syntax.Binding_univ y ->
-                 let uu___2 = FStar_Ident.string_of_id x in
-                 let uu___3 = FStar_Ident.string_of_id y in uu___2 = uu___3
-             | uu___2 -> false) env1.gamma in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Compiler_Option.isSome
-let (try_lookup_val_decl :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.tscheme * FStar_Syntax_Syntax.qualifier
-        Prims.list) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_declare_typ
-                (uu___1, uvs, t);
-              FStar_Syntax_Syntax.sigrng = uu___2;
-              FStar_Syntax_Syntax.sigquals = q;
-              FStar_Syntax_Syntax.sigmeta = uu___3;
-              FStar_Syntax_Syntax.sigattrs = uu___4;
-              FStar_Syntax_Syntax.sigopts = uu___5;_},
-            FStar_Pervasives_Native.None),
-           uu___6)
-          ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 =
-                let uu___10 = FStar_Ident.range_of_lid lid in
-                FStar_Syntax_Subst.set_use_range uu___10 t in
-              (uvs, uu___9) in
-            (uu___8, q) in
-          FStar_Pervasives_Native.Some uu___7
-      | uu___1 -> FStar_Pervasives_Native.None
-let (lookup_val_decl :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ))
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_declare_typ
-                (uu___1, uvs, t);
-              FStar_Syntax_Syntax.sigrng = uu___2;
-              FStar_Syntax_Syntax.sigquals = uu___3;
-              FStar_Syntax_Syntax.sigmeta = uu___4;
-              FStar_Syntax_Syntax.sigattrs = uu___5;
-              FStar_Syntax_Syntax.sigopts = uu___6;_},
-            FStar_Pervasives_Native.None),
-           uu___7)
-          ->
-          let uu___8 = FStar_Ident.range_of_lid lid in
-          inst_tscheme_with_range uu___8 (uvs, t)
-      | uu___1 ->
-          let uu___2 = name_not_found lid in
-          let uu___3 = FStar_Ident.range_of_lid lid in
-          FStar_Errors.raise_error uu___2 uu___3
-let (lookup_datacon :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.universes * FStar_Syntax_Syntax.typ))
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-                (uu___1, uvs, t, uu___2, uu___3, uu___4);
-              FStar_Syntax_Syntax.sigrng = uu___5;
-              FStar_Syntax_Syntax.sigquals = uu___6;
-              FStar_Syntax_Syntax.sigmeta = uu___7;
-              FStar_Syntax_Syntax.sigattrs = uu___8;
-              FStar_Syntax_Syntax.sigopts = uu___9;_},
-            FStar_Pervasives_Native.None),
-           uu___10)
-          ->
-          let uu___11 = FStar_Ident.range_of_lid lid in
-          inst_tscheme_with_range uu___11 (uvs, t)
-      | uu___1 ->
-          let uu___2 = name_not_found lid in
-          let uu___3 = FStar_Ident.range_of_lid lid in
-          FStar_Errors.raise_error uu___2 uu___3
-let (lookup_and_inst_datacon :
-  env ->
-    FStar_Syntax_Syntax.universes ->
-      FStar_Ident.lident -> FStar_Syntax_Syntax.typ)
-  =
-  fun env1 ->
-    fun us ->
-      fun lid ->
-        let uu___ = lookup_qname env1 lid in
-        match uu___ with
-        | FStar_Pervasives_Native.Some
-            (FStar_Pervasives.Inr
-             ({
-                FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-                  (uu___1, uvs, t, uu___2, uu___3, uu___4);
-                FStar_Syntax_Syntax.sigrng = uu___5;
-                FStar_Syntax_Syntax.sigquals = uu___6;
-                FStar_Syntax_Syntax.sigmeta = uu___7;
-                FStar_Syntax_Syntax.sigattrs = uu___8;
-                FStar_Syntax_Syntax.sigopts = uu___9;_},
-              FStar_Pervasives_Native.None),
-             uu___10)
-            ->
-            let uu___11 = inst_tscheme_with (uvs, t) us in
-            FStar_Compiler_Effect.op_Bar_Greater uu___11
-              FStar_Pervasives_Native.snd
-        | uu___1 ->
-            let uu___2 = name_not_found lid in
-            let uu___3 = FStar_Ident.range_of_lid lid in
-            FStar_Errors.raise_error uu___2 uu___3
-let (datacons_of_typ :
-  env -> FStar_Ident.lident -> (Prims.bool * FStar_Ident.lident Prims.list))
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel =
-                FStar_Syntax_Syntax.Sig_inductive_typ
-                (uu___1, uu___2, uu___3, uu___4, uu___5, uu___6, dcs);
-              FStar_Syntax_Syntax.sigrng = uu___7;
-              FStar_Syntax_Syntax.sigquals = uu___8;
-              FStar_Syntax_Syntax.sigmeta = uu___9;
-              FStar_Syntax_Syntax.sigattrs = uu___10;
-              FStar_Syntax_Syntax.sigopts = uu___11;_},
-            uu___12),
-           uu___13)
-          -> (true, dcs)
-      | uu___1 -> (false, [])
-let (typ_of_datacon : env -> FStar_Ident.lident -> FStar_Ident.lident) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-                (uu___1, uu___2, uu___3, l, uu___4, uu___5);
-              FStar_Syntax_Syntax.sigrng = uu___6;
-              FStar_Syntax_Syntax.sigquals = uu___7;
-              FStar_Syntax_Syntax.sigmeta = uu___8;
-              FStar_Syntax_Syntax.sigattrs = uu___9;
-              FStar_Syntax_Syntax.sigopts = uu___10;_},
-            uu___11),
-           uu___12)
-          -> l
-      | uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.lid_to_string lid in
-            FStar_Compiler_Util.format1 "Not a datacon: %s" uu___3 in
-          failwith uu___2
-let (lookup_definition_qninfo_aux :
-  Prims.bool ->
-    delta_level Prims.list ->
-      FStar_Ident.lident ->
-        qninfo ->
-          (FStar_Syntax_Syntax.univ_name Prims.list *
-            FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-            FStar_Pervasives_Native.option)
-  =
-  fun rec_ok ->
-    fun delta_levels ->
-      fun lid ->
-        fun qninfo1 ->
-          let visible quals =
-            FStar_Compiler_Effect.op_Bar_Greater delta_levels
-              (FStar_Compiler_Util.for_some
-                 (fun dl ->
-                    FStar_Compiler_Effect.op_Bar_Greater quals
-                      (FStar_Compiler_Util.for_some (visible_at dl)))) in
-          match qninfo1 with
-          | FStar_Pervasives_Native.Some
-              (FStar_Pervasives.Inr (se, FStar_Pervasives_Native.None),
-               uu___)
-              ->
-              (match se.FStar_Syntax_Syntax.sigel with
-               | FStar_Syntax_Syntax.Sig_let ((is_rec, lbs), uu___1) when
-                   (visible se.FStar_Syntax_Syntax.sigquals) &&
-                     ((Prims.op_Negation is_rec) || rec_ok)
-                   ->
-                   FStar_Compiler_Util.find_map lbs
-                     (fun lb ->
-                        let fv =
-                          FStar_Compiler_Util.right
-                            lb.FStar_Syntax_Syntax.lbname in
-                        let uu___2 = FStar_Syntax_Syntax.fv_eq_lid fv lid in
-                        if uu___2
-                        then
-                          FStar_Pervasives_Native.Some
-                            ((lb.FStar_Syntax_Syntax.lbunivs),
-                              (lb.FStar_Syntax_Syntax.lbdef))
-                        else FStar_Pervasives_Native.None)
-               | uu___1 -> FStar_Pervasives_Native.None)
-          | uu___ -> FStar_Pervasives_Native.None
-let (lookup_definition_qninfo :
-  delta_level Prims.list ->
-    FStar_Ident.lident ->
-      qninfo ->
-        (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term)
-          FStar_Pervasives_Native.option)
-  =
-  fun delta_levels ->
-    fun lid ->
-      fun qninfo1 ->
-        lookup_definition_qninfo_aux true delta_levels lid qninfo1
-let (lookup_definition :
-  delta_level Prims.list ->
-    env ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term)
-          FStar_Pervasives_Native.option)
-  =
-  fun delta_levels ->
-    fun env1 ->
-      fun lid ->
-        let uu___ = lookup_qname env1 lid in
-        FStar_Compiler_Effect.op_Less_Bar
-          (lookup_definition_qninfo delta_levels lid) uu___
-let (lookup_nonrec_definition :
-  delta_level Prims.list ->
-    env ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term)
-          FStar_Pervasives_Native.option)
-  =
-  fun delta_levels ->
-    fun env1 ->
-      fun lid ->
-        let uu___ = lookup_qname env1 lid in
-        FStar_Compiler_Effect.op_Less_Bar
-          (lookup_definition_qninfo_aux false delta_levels lid) uu___
-let (delta_depth_of_qninfo_lid :
-  FStar_Ident.lident ->
-    qninfo -> FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option)
-  =
-  fun lid ->
-    fun qn ->
-      match qn with
-      | FStar_Pervasives_Native.None ->
-          FStar_Pervasives_Native.Some
-            (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_zero)
-      | FStar_Pervasives_Native.Some (FStar_Pervasives.Inl uu___, uu___1) ->
-          FStar_Pervasives_Native.Some
-            (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_zero)
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr (se, uu___), uu___1) ->
-          (match se.FStar_Syntax_Syntax.sigel with
-           | FStar_Syntax_Syntax.Sig_inductive_typ uu___2 ->
-               FStar_Pervasives_Native.Some
-                 (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_zero)
-           | FStar_Syntax_Syntax.Sig_bundle uu___2 ->
-               FStar_Pervasives_Native.Some
-                 (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_zero)
-           | FStar_Syntax_Syntax.Sig_datacon uu___2 ->
-               FStar_Pervasives_Native.Some
-                 (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_zero)
-           | FStar_Syntax_Syntax.Sig_declare_typ uu___2 ->
-               let uu___3 =
-                 FStar_Syntax_DsEnv.delta_depth_of_declaration lid
-                   se.FStar_Syntax_Syntax.sigquals in
-               FStar_Pervasives_Native.Some uu___3
-           | FStar_Syntax_Syntax.Sig_let ((uu___2, lbs), uu___3) ->
-               FStar_Compiler_Util.find_map lbs
-                 (fun lb ->
-                    let fv =
-                      FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-                    let uu___4 = FStar_Syntax_Syntax.fv_eq_lid fv lid in
-                    if uu___4
-                    then
-                      FStar_Pervasives_Native.Some
-                        (fv.FStar_Syntax_Syntax.fv_delta)
-                    else FStar_Pervasives_Native.None)
-           | FStar_Syntax_Syntax.Sig_fail uu___2 ->
-               failwith "impossible: delta_depth_of_qninfo"
-           | FStar_Syntax_Syntax.Sig_splice uu___2 ->
-               failwith "impossible: delta_depth_of_qninfo"
-           | FStar_Syntax_Syntax.Sig_assume uu___2 ->
-               FStar_Pervasives_Native.None
-           | FStar_Syntax_Syntax.Sig_new_effect uu___2 ->
-               FStar_Pervasives_Native.None
-           | FStar_Syntax_Syntax.Sig_sub_effect uu___2 ->
-               FStar_Pervasives_Native.None
-           | FStar_Syntax_Syntax.Sig_effect_abbrev uu___2 ->
-               FStar_Pervasives_Native.None
-           | FStar_Syntax_Syntax.Sig_pragma uu___2 ->
-               FStar_Pervasives_Native.None
-           | FStar_Syntax_Syntax.Sig_polymonadic_bind uu___2 ->
-               FStar_Pervasives_Native.None
-           | FStar_Syntax_Syntax.Sig_polymonadic_subcomp uu___2 ->
-               FStar_Pervasives_Native.None)
-let (delta_depth_of_qninfo :
-  FStar_Syntax_Syntax.fv ->
-    qninfo -> FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option)
-  =
-  fun fv ->
-    fun qn ->
-      let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      let uu___ = let uu___1 = FStar_Ident.nsstr lid in uu___1 = "Prims" in
-      if uu___
-      then FStar_Pervasives_Native.Some (fv.FStar_Syntax_Syntax.fv_delta)
-      else delta_depth_of_qninfo_lid lid qn
-let (delta_depth_of_fv :
-  env -> FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.delta_depth) =
-  fun env1 ->
-    fun fv ->
-      let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      let uu___ = let uu___1 = FStar_Ident.nsstr lid in uu___1 = "Prims" in
-      if uu___
-      then fv.FStar_Syntax_Syntax.fv_delta
-      else
-        (let uu___2 =
-           let uu___3 = FStar_Ident.string_of_lid lid in
-           FStar_Compiler_Effect.op_Bar_Greater uu___3
-             (FStar_Compiler_Util.smap_try_find env1.fv_delta_depths) in
-         FStar_Compiler_Effect.op_Bar_Greater uu___2
-           (fun d_opt ->
-              let uu___3 =
-                FStar_Compiler_Effect.op_Bar_Greater d_opt
-                  FStar_Compiler_Util.is_some in
-              if uu___3
-              then
-                FStar_Compiler_Effect.op_Bar_Greater d_opt
-                  FStar_Compiler_Util.must
-              else
-                (let uu___5 =
-                   let uu___6 =
-                     lookup_qname env1
-                       (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                   delta_depth_of_qninfo fv uu___6 in
-                 match uu___5 with
-                 | FStar_Pervasives_Native.None ->
-                     let uu___6 =
-                       let uu___7 = FStar_Syntax_Print.fv_to_string fv in
-                       FStar_Compiler_Util.format1
-                         "Delta depth not found for %s" uu___7 in
-                     failwith uu___6
-                 | FStar_Pervasives_Native.Some d ->
-                     ((let uu___7 =
-                         (d <> fv.FStar_Syntax_Syntax.fv_delta) &&
-                           (FStar_Options.debug_any ()) in
-                       if uu___7
-                       then
-                         let uu___8 = FStar_Syntax_Print.fv_to_string fv in
-                         let uu___9 =
-                           FStar_Syntax_Print.delta_depth_to_string
-                             fv.FStar_Syntax_Syntax.fv_delta in
-                         let uu___10 =
-                           FStar_Syntax_Print.delta_depth_to_string d in
-                         FStar_Compiler_Util.print3
-                           "WARNING WARNING WARNING fv=%s, delta_depth=%s, env.delta_depth=%s\n"
-                           uu___8 uu___9 uu___10
-                       else ());
-                      (let uu___8 = FStar_Ident.string_of_lid lid in
-                       FStar_Compiler_Util.smap_add env1.fv_delta_depths
-                         uu___8 d);
-                      d))))
-let (quals_of_qninfo :
-  qninfo ->
-    FStar_Syntax_Syntax.qualifier Prims.list FStar_Pervasives_Native.option)
-  =
-  fun qninfo1 ->
-    match qninfo1 with
-    | FStar_Pervasives_Native.Some (FStar_Pervasives.Inr (se, uu___), uu___1)
-        -> FStar_Pervasives_Native.Some (se.FStar_Syntax_Syntax.sigquals)
-    | uu___ -> FStar_Pervasives_Native.None
-let (attrs_of_qninfo :
-  qninfo ->
-    FStar_Syntax_Syntax.attribute Prims.list FStar_Pervasives_Native.option)
-  =
-  fun qninfo1 ->
-    match qninfo1 with
-    | FStar_Pervasives_Native.Some (FStar_Pervasives.Inr (se, uu___), uu___1)
-        -> FStar_Pervasives_Native.Some (se.FStar_Syntax_Syntax.sigattrs)
-    | uu___ -> FStar_Pervasives_Native.None
-let (lookup_attrs_of_lid :
-  env ->
-    FStar_Ident.lid ->
-      FStar_Syntax_Syntax.attribute Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      FStar_Compiler_Effect.op_Less_Bar attrs_of_qninfo uu___
-let (fv_exists_and_has_attr :
-  env -> FStar_Ident.lid -> FStar_Ident.lident -> (Prims.bool * Prims.bool))
-  =
-  fun env1 ->
-    fun fv_lid ->
-      fun attr_lid ->
-        let uu___ = lookup_attrs_of_lid env1 fv_lid in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> (false, false)
-        | FStar_Pervasives_Native.Some attrs ->
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater attrs
-                (FStar_Compiler_Util.for_some
-                   (fun tm ->
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Util.un_uinst tm in
-                        uu___3.FStar_Syntax_Syntax.n in
-                      match uu___2 with
-                      | FStar_Syntax_Syntax.Tm_fvar fv ->
-                          FStar_Syntax_Syntax.fv_eq_lid fv attr_lid
-                      | uu___3 -> false)) in
-            (true, uu___1)
-let (fv_with_lid_has_attr :
-  env -> FStar_Ident.lid -> FStar_Ident.lid -> Prims.bool) =
-  fun env1 ->
-    fun fv_lid ->
-      fun attr_lid ->
-        let uu___ = fv_exists_and_has_attr env1 fv_lid attr_lid in
-        FStar_Pervasives_Native.snd uu___
-let (fv_has_attr :
-  env -> FStar_Syntax_Syntax.fv -> FStar_Ident.lid -> Prims.bool) =
-  fun env1 ->
-    fun fv ->
-      fun attr_lid ->
-        fv_with_lid_has_attr env1
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v attr_lid
-let cache_in_fv_tab :
-  'a .
-    'a FStar_Compiler_Util.smap ->
-      FStar_Syntax_Syntax.fv -> (unit -> (Prims.bool * 'a)) -> 'a
-  =
-  fun tab ->
-    fun fv ->
-      fun f ->
-        let s =
-          let uu___ = FStar_Syntax_Syntax.lid_of_fv fv in
-          FStar_Ident.string_of_lid uu___ in
-        let uu___ = FStar_Compiler_Util.smap_try_find tab s in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            let uu___1 = f () in
-            (match uu___1 with
-             | (should_cache, res) ->
-                 (if should_cache
-                  then FStar_Compiler_Util.smap_add tab s res
-                  else ();
-                  res))
-        | FStar_Pervasives_Native.Some r -> r
-let (fv_has_erasable_attr : env -> FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun env1 ->
-    fun fv ->
-      let f uu___ =
-        let uu___1 =
-          fv_exists_and_has_attr env1
-            (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-            FStar_Parser_Const.erasable_attr in
-        match uu___1 with | (ex, erasable) -> (ex, erasable) in
-      cache_in_fv_tab env1.erasable_types_tab fv f
-let (fv_has_strict_args :
-  env ->
-    FStar_Syntax_Syntax.fv ->
-      Prims.int Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fv ->
-      let f uu___ =
-        let attrs =
-          let uu___1 = FStar_Syntax_Syntax.lid_of_fv fv in
-          lookup_attrs_of_lid env1 uu___1 in
-        match attrs with
-        | FStar_Pervasives_Native.None ->
-            (false, FStar_Pervasives_Native.None)
-        | FStar_Pervasives_Native.Some attrs1 ->
-            let res =
-              FStar_Compiler_Util.find_map attrs1
-                (fun x ->
-                   let uu___1 =
-                     FStar_ToSyntax_ToSyntax.parse_attr_with_list false x
-                       FStar_Parser_Const.strict_on_arguments_attr in
-                   FStar_Pervasives_Native.fst uu___1) in
-            (true, res) in
-      cache_in_fv_tab env1.strict_args_tab fv f
-let (try_lookup_effect_lid :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ftv ->
-      let uu___ = lookup_qname env1 ftv in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr (se, FStar_Pervasives_Native.None), uu___1)
-          ->
-          let uu___2 =
-            effect_signature FStar_Pervasives_Native.None se env1.range in
-          (match uu___2 with
-           | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-           | FStar_Pervasives_Native.Some ((uu___3, t), r) ->
-               let uu___4 =
-                 let uu___5 = FStar_Ident.range_of_lid ftv in
-                 FStar_Syntax_Subst.set_use_range uu___5 t in
-               FStar_Pervasives_Native.Some uu___4)
-      | uu___1 -> FStar_Pervasives_Native.None
-let (lookup_effect_lid :
-  env -> FStar_Ident.lident -> FStar_Syntax_Syntax.term) =
-  fun env1 ->
-    fun ftv ->
-      let uu___ = try_lookup_effect_lid env1 ftv in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = name_not_found ftv in
-          let uu___2 = FStar_Ident.range_of_lid ftv in
-          FStar_Errors.raise_error uu___1 uu___2
-      | FStar_Pervasives_Native.Some k -> k
-let (lookup_effect_abbrev :
-  env ->
-    FStar_Syntax_Syntax.universes ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp)
-          FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun univ_insts ->
-      fun lid0 ->
-        let uu___ = lookup_qname env1 lid0 in
-        match uu___ with
-        | FStar_Pervasives_Native.Some
-            (FStar_Pervasives.Inr
-             ({
-                FStar_Syntax_Syntax.sigel =
-                  FStar_Syntax_Syntax.Sig_effect_abbrev
-                  (lid, univs, binders, c, uu___1);
-                FStar_Syntax_Syntax.sigrng = uu___2;
-                FStar_Syntax_Syntax.sigquals = quals;
-                FStar_Syntax_Syntax.sigmeta = uu___3;
-                FStar_Syntax_Syntax.sigattrs = uu___4;
-                FStar_Syntax_Syntax.sigopts = uu___5;_},
-              FStar_Pervasives_Native.None),
-             uu___6)
-            ->
-            let lid1 =
-              let uu___7 =
-                let uu___8 = FStar_Ident.range_of_lid lid in
-                let uu___9 =
-                  let uu___10 = FStar_Ident.range_of_lid lid0 in
-                  FStar_Compiler_Range.use_range uu___10 in
-                FStar_Compiler_Range.set_use_range uu___8 uu___9 in
-              FStar_Ident.set_lid_range lid uu___7 in
-            let uu___7 =
-              FStar_Compiler_Effect.op_Bar_Greater quals
-                (FStar_Compiler_Util.for_some
-                   (fun uu___8 ->
-                      match uu___8 with
-                      | FStar_Syntax_Syntax.Irreducible -> true
-                      | uu___9 -> false)) in
-            if uu___7
-            then FStar_Pervasives_Native.None
-            else
-              (let insts =
-                 if
-                   (FStar_Compiler_List.length univ_insts) =
-                     (FStar_Compiler_List.length univs)
-                 then univ_insts
-                 else
-                   (let uu___10 =
-                      let uu___11 =
-                        let uu___12 = get_range env1 in
-                        FStar_Compiler_Range.string_of_range uu___12 in
-                      let uu___12 = FStar_Syntax_Print.lid_to_string lid1 in
-                      let uu___13 =
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          (FStar_Compiler_List.length univ_insts)
-                          FStar_Compiler_Util.string_of_int in
-                      FStar_Compiler_Util.format3
-                        "(%s) Unexpected instantiation of effect %s with %s universes"
-                        uu___11 uu___12 uu___13 in
-                    failwith uu___10) in
-               match (binders, univs) with
-               | ([], uu___9) ->
-                   failwith
-                     "Unexpected effect abbreviation with no arguments"
-               | (uu___9, uu___10::uu___11::uu___12) ->
-                   let uu___13 =
-                     let uu___14 = FStar_Syntax_Print.lid_to_string lid1 in
-                     let uu___15 =
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Compiler_Util.string_of_int
-                         (FStar_Compiler_List.length univs) in
-                     FStar_Compiler_Util.format2
-                       "Unexpected effect abbreviation %s; polymorphic in %s universes"
-                       uu___14 uu___15 in
-                   failwith uu___13
-               | uu___9 ->
-                   let uu___10 =
-                     let uu___11 =
-                       let uu___12 = FStar_Syntax_Util.arrow binders c in
-                       (univs, uu___12) in
-                     inst_tscheme_with uu___11 insts in
-                   (match uu___10 with
-                    | (uu___11, t) ->
-                        let t1 =
-                          let uu___12 = FStar_Ident.range_of_lid lid1 in
-                          FStar_Syntax_Subst.set_use_range uu___12 t in
-                        let uu___12 =
-                          let uu___13 = FStar_Syntax_Subst.compress t1 in
-                          uu___13.FStar_Syntax_Syntax.n in
-                        (match uu___12 with
-                         | FStar_Syntax_Syntax.Tm_arrow (binders1, c1) ->
-                             FStar_Pervasives_Native.Some (binders1, c1)
-                         | uu___13 -> failwith "Impossible")))
-        | uu___1 -> FStar_Pervasives_Native.None
-let (norm_eff_name : env -> FStar_Ident.lident -> FStar_Ident.lident) =
-  fun env1 ->
-    fun l ->
-      let rec find l1 =
-        let uu___ =
-          lookup_effect_abbrev env1 [FStar_Syntax_Syntax.U_unknown] l1 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some (uu___1, c) ->
-            let l2 = FStar_Syntax_Util.comp_effect_name c in
-            let uu___2 = find l2 in
-            (match uu___2 with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Pervasives_Native.Some l2
-             | FStar_Pervasives_Native.Some l' ->
-                 FStar_Pervasives_Native.Some l') in
-      let res =
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid l in
-          FStar_Compiler_Util.smap_try_find env1.normalized_eff_names uu___1 in
-        match uu___ with
-        | FStar_Pervasives_Native.Some l1 -> l1
-        | FStar_Pervasives_Native.None ->
-            let uu___1 = find l in
-            (match uu___1 with
-             | FStar_Pervasives_Native.None -> l
-             | FStar_Pervasives_Native.Some m ->
-                 ((let uu___3 = FStar_Ident.string_of_lid l in
-                   FStar_Compiler_Util.smap_add env1.normalized_eff_names
-                     uu___3 m);
-                  m)) in
-      let uu___ = FStar_Ident.range_of_lid l in
-      FStar_Ident.set_lid_range res uu___
-let (is_erasable_effect : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      let uu___ = FStar_Compiler_Effect.op_Bar_Greater l (norm_eff_name env1) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (fun l1 ->
-           (FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_GHOST_lid) ||
-             (let uu___1 =
-                FStar_Syntax_Syntax.lid_as_fv l1
-                  (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_zero)
-                  FStar_Pervasives_Native.None in
-              FStar_Compiler_Effect.op_Bar_Greater uu___1
-                (fv_has_erasable_attr env1)))
-let rec (non_informative : env -> FStar_Syntax_Syntax.typ -> Prims.bool) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Util.unrefine t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_type uu___1 -> true
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          (((FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.unit_lid) ||
-              (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.squash_lid))
-             ||
-             (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.erased_lid))
-            || (fv_has_erasable_attr env1 fv)
-      | FStar_Syntax_Syntax.Tm_app (head, uu___1) ->
-          non_informative env1 head
-      | FStar_Syntax_Syntax.Tm_uinst (t1, uu___1) -> non_informative env1 t1
-      | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-          ((FStar_Syntax_Util.is_pure_or_ghost_comp c) &&
-             (non_informative env1 (FStar_Syntax_Util.comp_result c)))
-            ||
-            (is_erasable_effect env1 (FStar_Syntax_Util.comp_effect_name c))
-      | uu___1 -> false
-let (num_effect_indices :
-  env -> FStar_Ident.lident -> FStar_Compiler_Range.range -> Prims.int) =
-  fun env1 ->
-    fun name ->
-      fun r ->
-        let sig_t =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater name
-              (lookup_effect_lid env1) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            FStar_Syntax_Subst.compress in
-        match sig_t.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_arrow (_a::bs, uu___) ->
-            FStar_Compiler_List.length bs
-        | uu___ ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Ident.string_of_lid name in
-                let uu___4 = FStar_Syntax_Print.term_to_string sig_t in
-                FStar_Compiler_Util.format2
-                  "Signature for %s not an arrow (%s)" uu___3 uu___4 in
-              (FStar_Errors.Fatal_UnexpectedSignatureForMonad, uu___2) in
-            FStar_Errors.raise_error uu___1 r
-let (lookup_effect_quals :
-  env -> FStar_Ident.lident -> FStar_Syntax_Syntax.qualifier Prims.list) =
-  fun env1 ->
-    fun l ->
-      let l1 = norm_eff_name env1 l in
-      let uu___ = lookup_qname env1 l1 in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_new_effect
-                uu___1;
-              FStar_Syntax_Syntax.sigrng = uu___2;
-              FStar_Syntax_Syntax.sigquals = q;
-              FStar_Syntax_Syntax.sigmeta = uu___3;
-              FStar_Syntax_Syntax.sigattrs = uu___4;
-              FStar_Syntax_Syntax.sigopts = uu___5;_},
-            uu___6),
-           uu___7)
-          -> q
-      | uu___1 -> []
-let (lookup_projector :
-  env -> FStar_Ident.lident -> Prims.int -> FStar_Ident.lident) =
-  fun env1 ->
-    fun lid ->
-      fun i ->
-        let fail uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Util.string_of_int i in
-            let uu___3 = FStar_Syntax_Print.lid_to_string lid in
-            FStar_Compiler_Util.format2
-              "Impossible: projecting field #%s from constructor %s is undefined"
-              uu___2 uu___3 in
-          failwith uu___1 in
-        let uu___ = lookup_datacon env1 lid in
-        match uu___ with
-        | (uu___1, t) ->
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Subst.compress t in
-              uu___3.FStar_Syntax_Syntax.n in
-            (match uu___2 with
-             | FStar_Syntax_Syntax.Tm_arrow (binders, uu___3) ->
-                 if
-                   (i < Prims.int_zero) ||
-                     (i >= (FStar_Compiler_List.length binders))
-                 then fail ()
-                 else
-                   (let b = FStar_Compiler_List.nth binders i in
-                    FStar_Syntax_Util.mk_field_projector_name lid
-                      b.FStar_Syntax_Syntax.binder_bv i)
-             | uu___3 -> fail ())
-let (is_projector : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      let uu___ = lookup_qname env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_declare_typ
-                (uu___1, uu___2, uu___3);
-              FStar_Syntax_Syntax.sigrng = uu___4;
-              FStar_Syntax_Syntax.sigquals = quals;
-              FStar_Syntax_Syntax.sigmeta = uu___5;
-              FStar_Syntax_Syntax.sigattrs = uu___6;
-              FStar_Syntax_Syntax.sigopts = uu___7;_},
-            uu___8),
-           uu___9)
-          ->
-          FStar_Compiler_Util.for_some
-            (fun uu___10 ->
-               match uu___10 with
-               | FStar_Syntax_Syntax.Projector uu___11 -> true
-               | uu___11 -> false) quals
-      | uu___1 -> false
-let (is_datacon : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-                (uu___1, uu___2, uu___3, uu___4, uu___5, uu___6);
-              FStar_Syntax_Syntax.sigrng = uu___7;
-              FStar_Syntax_Syntax.sigquals = uu___8;
-              FStar_Syntax_Syntax.sigmeta = uu___9;
-              FStar_Syntax_Syntax.sigattrs = uu___10;
-              FStar_Syntax_Syntax.sigopts = uu___11;_},
-            uu___12),
-           uu___13)
-          -> true
-      | uu___1 -> false
-let (is_record : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel =
-                FStar_Syntax_Syntax.Sig_inductive_typ uu___1;
-              FStar_Syntax_Syntax.sigrng = uu___2;
-              FStar_Syntax_Syntax.sigquals = quals;
-              FStar_Syntax_Syntax.sigmeta = uu___3;
-              FStar_Syntax_Syntax.sigattrs = uu___4;
-              FStar_Syntax_Syntax.sigopts = uu___5;_},
-            uu___6),
-           uu___7)
-          ->
-          FStar_Compiler_Util.for_some
-            (fun uu___8 ->
-               match uu___8 with
-               | FStar_Syntax_Syntax.RecordType uu___9 -> true
-               | FStar_Syntax_Syntax.RecordConstructor uu___9 -> true
-               | uu___9 -> false) quals
-      | uu___1 -> false
-let (qninfo_is_action : qninfo -> Prims.bool) =
-  fun qninfo1 ->
-    match qninfo1 with
-    | FStar_Pervasives_Native.Some
-        (FStar_Pervasives.Inr
-         ({
-            FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_let
-              (uu___, uu___1);
-            FStar_Syntax_Syntax.sigrng = uu___2;
-            FStar_Syntax_Syntax.sigquals = quals;
-            FStar_Syntax_Syntax.sigmeta = uu___3;
-            FStar_Syntax_Syntax.sigattrs = uu___4;
-            FStar_Syntax_Syntax.sigopts = uu___5;_},
-          uu___6),
-         uu___7)
-        ->
-        FStar_Compiler_Util.for_some
-          (fun uu___8 ->
-             match uu___8 with
-             | FStar_Syntax_Syntax.Action uu___9 -> true
-             | uu___9 -> false) quals
-    | uu___ -> false
-let (is_action : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      FStar_Compiler_Effect.op_Less_Bar qninfo_is_action uu___
-let (is_interpreted : env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  let interpreted_symbols =
-    [FStar_Parser_Const.op_Eq;
-    FStar_Parser_Const.op_notEq;
-    FStar_Parser_Const.op_LT;
-    FStar_Parser_Const.op_LTE;
-    FStar_Parser_Const.op_GT;
-    FStar_Parser_Const.op_GTE;
-    FStar_Parser_Const.op_Subtraction;
-    FStar_Parser_Const.op_Minus;
-    FStar_Parser_Const.op_Addition;
-    FStar_Parser_Const.op_Multiply;
-    FStar_Parser_Const.op_Division;
-    FStar_Parser_Const.op_Modulus;
-    FStar_Parser_Const.op_And;
-    FStar_Parser_Const.op_Or;
-    FStar_Parser_Const.op_Negation] in
-  fun env1 ->
-    fun head ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Util.un_uinst head in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          (match fv.FStar_Syntax_Syntax.fv_delta with
-           | FStar_Syntax_Syntax.Delta_equational_at_level uu___1 -> true
-           | uu___1 -> false) ||
-            (FStar_Compiler_Util.for_some
-               (FStar_Ident.lid_equals
-                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-               interpreted_symbols)
-      | uu___1 -> false
-let (is_irreducible : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      let uu___ = lookup_qname env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr (se, uu___1), uu___2) ->
-          FStar_Compiler_Util.for_some
-            (fun uu___3 ->
-               match uu___3 with
-               | FStar_Syntax_Syntax.Irreducible -> true
-               | uu___4 -> false) se.FStar_Syntax_Syntax.sigquals
-      | uu___1 -> false
-let (is_type_constructor : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      let mapper x =
-        match FStar_Pervasives_Native.fst x with
-        | FStar_Pervasives.Inl uu___ -> FStar_Pervasives_Native.Some false
-        | FStar_Pervasives.Inr (se, uu___) ->
-            (match se.FStar_Syntax_Syntax.sigel with
-             | FStar_Syntax_Syntax.Sig_declare_typ uu___1 ->
-                 FStar_Pervasives_Native.Some
-                   (FStar_Compiler_List.contains FStar_Syntax_Syntax.New
-                      se.FStar_Syntax_Syntax.sigquals)
-             | FStar_Syntax_Syntax.Sig_inductive_typ uu___1 ->
-                 FStar_Pervasives_Native.Some true
-             | uu___1 -> FStar_Pervasives_Native.Some false) in
-      let uu___ =
-        let uu___1 = lookup_qname env1 lid in
-        FStar_Compiler_Util.bind_opt uu___1 mapper in
-      match uu___ with
-      | FStar_Pervasives_Native.Some b -> b
-      | FStar_Pervasives_Native.None -> false
-let (num_inductive_ty_params :
-  env -> FStar_Ident.lident -> Prims.int FStar_Pervasives_Native.option) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel =
-                FStar_Syntax_Syntax.Sig_inductive_typ
-                (uu___1, uu___2, tps, uu___3, uu___4, uu___5, uu___6);
-              FStar_Syntax_Syntax.sigrng = uu___7;
-              FStar_Syntax_Syntax.sigquals = uu___8;
-              FStar_Syntax_Syntax.sigmeta = uu___9;
-              FStar_Syntax_Syntax.sigattrs = uu___10;
-              FStar_Syntax_Syntax.sigopts = uu___11;_},
-            uu___12),
-           uu___13)
-          -> FStar_Pervasives_Native.Some (FStar_Compiler_List.length tps)
-      | uu___1 -> FStar_Pervasives_Native.None
-let (num_inductive_uniform_ty_params :
-  env -> FStar_Ident.lident -> Prims.int FStar_Pervasives_Native.option) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = lookup_qname env1 lid in
-      match uu___ with
-      | FStar_Pervasives_Native.Some
-          (FStar_Pervasives.Inr
-           ({
-              FStar_Syntax_Syntax.sigel =
-                FStar_Syntax_Syntax.Sig_inductive_typ
-                (uu___1, uu___2, uu___3, num_uniform, uu___4, uu___5, uu___6);
-              FStar_Syntax_Syntax.sigrng = uu___7;
-              FStar_Syntax_Syntax.sigquals = uu___8;
-              FStar_Syntax_Syntax.sigmeta = uu___9;
-              FStar_Syntax_Syntax.sigattrs = uu___10;
-              FStar_Syntax_Syntax.sigopts = uu___11;_},
-            uu___12),
-           uu___13)
-          ->
-          (match num_uniform with
-           | FStar_Pervasives_Native.None ->
-               let uu___14 =
-                 let uu___15 =
-                   let uu___16 = FStar_Ident.string_of_lid lid in
-                   FStar_Compiler_Util.format1
-                     "Internal error: Inductive %s is not decorated with its uniform type parameters"
-                     uu___16 in
-                 (FStar_Errors.Fatal_UnexpectedInductivetype, uu___15) in
-               let uu___15 = FStar_Ident.range_of_lid lid in
-               FStar_Errors.raise_error uu___14 uu___15
-           | FStar_Pervasives_Native.Some n -> FStar_Pervasives_Native.Some n)
-      | uu___1 -> FStar_Pervasives_Native.None
-let (effect_decl_opt :
-  env ->
-    FStar_Ident.lident ->
-      (FStar_Syntax_Syntax.eff_decl * FStar_Syntax_Syntax.qualifier
-        Prims.list) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l ->
-      FStar_Compiler_Effect.op_Bar_Greater (env1.effects).decls
-        (FStar_Compiler_Util.find_opt
-           (fun uu___ ->
-              match uu___ with
-              | (d, uu___1) ->
-                  FStar_Ident.lid_equals d.FStar_Syntax_Syntax.mname l))
-let (get_effect_decl :
-  env -> FStar_Ident.lident -> FStar_Syntax_Syntax.eff_decl) =
-  fun env1 ->
-    fun l ->
-      let uu___ = effect_decl_opt env1 l in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = name_not_found l in
-          let uu___2 = FStar_Ident.range_of_lid l in
-          FStar_Errors.raise_error uu___1 uu___2
-      | FStar_Pervasives_Native.Some md -> FStar_Pervasives_Native.fst md
-let (get_lid_valued_effect_attr :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident FStar_Pervasives_Native.option ->
-          FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun eff_lid ->
-      fun attr_name_lid ->
-        fun default_if_attr_has_no_arg ->
-          let attr_args =
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater eff_lid
-                    (norm_eff_name env1) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___2
-                  (lookup_attrs_of_lid env1) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___1
-                (FStar_Compiler_Util.dflt []) in
-            FStar_Compiler_Effect.op_Bar_Greater uu___
-              (FStar_Syntax_Util.get_attribute attr_name_lid) in
-          match attr_args with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some args ->
-              if (FStar_Compiler_List.length args) = Prims.int_zero
-              then default_if_attr_has_no_arg
-              else
-                (let uu___1 =
-                   FStar_Compiler_Effect.op_Bar_Greater args
-                     FStar_Compiler_List.hd in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___1
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (t, uu___3) ->
-                          let uu___4 =
-                            let uu___5 = FStar_Syntax_Subst.compress t in
-                            uu___5.FStar_Syntax_Syntax.n in
-                          (match uu___4 with
-                           | FStar_Syntax_Syntax.Tm_constant
-                               (FStar_Const.Const_string (s, uu___5)) ->
-                               let uu___6 =
-                                 FStar_Compiler_Effect.op_Bar_Greater s
-                                   FStar_Ident.lid_of_str in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                 (fun uu___7 ->
-                                    FStar_Pervasives_Native.Some uu___7)
-                           | uu___5 ->
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Ident.string_of_lid eff_lid in
-                                   let uu___9 =
-                                     FStar_Syntax_Print.term_to_string t in
-                                   FStar_Compiler_Util.format2
-                                     "The argument for the effect attribute for %s is not a constant string, it is %s\n"
-                                     uu___8 uu___9 in
-                                 (FStar_Errors.Fatal_UnexpectedEffect,
-                                   uu___7) in
-                               FStar_Errors.raise_error uu___6
-                                 t.FStar_Syntax_Syntax.pos)))
-let (get_default_effect :
-  env ->
-    FStar_Ident.lident -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      get_lid_valued_effect_attr env1 lid
-        FStar_Parser_Const.default_effect_attr FStar_Pervasives_Native.None
-let (get_top_level_effect :
-  env ->
-    FStar_Ident.lident -> FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lid ->
-      get_lid_valued_effect_attr env1 lid
-        FStar_Parser_Const.top_level_effect_attr
-        (FStar_Pervasives_Native.Some lid)
-let (is_layered_effect : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun l ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater l (get_effect_decl env1) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Syntax_Util.is_layered
-let (identity_mlift : mlift) =
-  {
-    mlift_wp =
-      (fun uu___ -> fun c -> (c, FStar_TypeChecker_Common.trivial_guard));
-    mlift_term =
-      (FStar_Pervasives_Native.Some
-         (fun uu___ ->
-            fun uu___1 -> fun e -> FStar_Compiler_Util.return_all e))
-  }
-let (join_opt :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        (FStar_Ident.lident * mlift * mlift) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l1 ->
-      fun l2 ->
-        let uu___ = FStar_Ident.lid_equals l1 l2 in
-        if uu___
-        then
-          FStar_Pervasives_Native.Some (l1, identity_mlift, identity_mlift)
-        else
-          (let uu___2 =
-             ((FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_GTot_lid)
-                &&
-                (FStar_Ident.lid_equals l2 FStar_Parser_Const.effect_Tot_lid))
-               ||
-               ((FStar_Ident.lid_equals l2 FStar_Parser_Const.effect_GTot_lid)
-                  &&
-                  (FStar_Ident.lid_equals l1
-                     FStar_Parser_Const.effect_Tot_lid)) in
-           if uu___2
-           then
-             FStar_Pervasives_Native.Some
-               (FStar_Parser_Const.effect_GTot_lid, identity_mlift,
-                 identity_mlift)
-           else
-             (let uu___4 =
-                FStar_Compiler_Effect.op_Bar_Greater (env1.effects).joins
-                  (FStar_Compiler_Util.find_opt
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (m1, m2, uu___6, uu___7, uu___8) ->
-                            (FStar_Ident.lid_equals l1 m1) &&
-                              (FStar_Ident.lid_equals l2 m2))) in
-              match uu___4 with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some (uu___5, uu___6, m3, j1, j2) ->
-                  FStar_Pervasives_Native.Some (m3, j1, j2)))
-let (join :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident -> (FStar_Ident.lident * mlift * mlift))
-  =
-  fun env1 ->
-    fun l1 ->
-      fun l2 ->
-        let uu___ = join_opt env1 l1 l2 in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.lid_to_string l1 in
-                let uu___4 = FStar_Syntax_Print.lid_to_string l2 in
-                FStar_Compiler_Util.format2
-                  "Effects %s and %s cannot be composed" uu___3 uu___4 in
-              (FStar_Errors.Fatal_EffectsCannotBeComposed, uu___2) in
-            FStar_Errors.raise_error uu___1 env1.range
-        | FStar_Pervasives_Native.Some t -> t
-let (monad_leq :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident -> edge FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun l1 ->
-      fun l2 ->
-        let uu___ =
-          (FStar_Ident.lid_equals l1 l2) ||
-            ((FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_Tot_lid) &&
-               (FStar_Ident.lid_equals l2 FStar_Parser_Const.effect_GTot_lid)) in
-        if uu___
-        then
-          FStar_Pervasives_Native.Some
-            { msource = l1; mtarget = l2; mlift = identity_mlift; mpath = []
-            }
-        else
-          FStar_Compiler_Effect.op_Bar_Greater (env1.effects).order
-            (FStar_Compiler_Util.find_opt
-               (fun e ->
-                  (FStar_Ident.lid_equals l1 e.msource) &&
-                    (FStar_Ident.lid_equals l2 e.mtarget)))
-let wp_sig_aux :
-  'uuuuu .
-    (FStar_Syntax_Syntax.eff_decl * 'uuuuu) Prims.list ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax)
-  =
-  fun decls ->
-    fun m ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater decls
-          (FStar_Compiler_Util.find_opt
-             (fun uu___1 ->
-                match uu___1 with
-                | (d, uu___2) ->
-                    FStar_Ident.lid_equals d.FStar_Syntax_Syntax.mname m)) in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          let uu___1 =
-            let uu___2 = FStar_Ident.string_of_lid m in
-            FStar_Compiler_Util.format1
-              "Impossible: declaration for monad %s not found" uu___2 in
-          failwith uu___1
-      | FStar_Pervasives_Native.Some (md, _q) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                md.FStar_Syntax_Syntax.signature
-                FStar_Syntax_Util.effect_sig_ts in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 inst_tscheme in
-          (match uu___1 with
-           | (uu___2, s) ->
-               let s1 = FStar_Syntax_Subst.compress s in
-               (match ((md.FStar_Syntax_Syntax.binders),
-                        (s1.FStar_Syntax_Syntax.n))
-                with
-                | ([], FStar_Syntax_Syntax.Tm_arrow (b::wp_b::[], c)) when
-                    FStar_Syntax_Syntax.is_teff
-                      (FStar_Syntax_Util.comp_result c)
-                    ->
-                    ((b.FStar_Syntax_Syntax.binder_bv),
-                      ((wp_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort))
-                | uu___3 -> failwith "Impossible"))
-let (wp_signature :
-  env ->
-    FStar_Ident.lident -> (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term))
-  = fun env1 -> fun m -> wp_sig_aux (env1.effects).decls m
-let (bound_vars_of_bindings :
-  FStar_Syntax_Syntax.binding Prims.list -> FStar_Syntax_Syntax.bv Prims.list)
-  =
-  fun bs ->
-    FStar_Compiler_Effect.op_Bar_Greater bs
-      (FStar_Compiler_List.collect
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.Binding_var x -> [x]
-            | FStar_Syntax_Syntax.Binding_lid uu___1 -> []
-            | FStar_Syntax_Syntax.Binding_univ uu___1 -> []))
-let (binders_of_bindings :
-  FStar_Syntax_Syntax.binding Prims.list -> FStar_Syntax_Syntax.binders) =
-  fun bs ->
-    let uu___ =
-      let uu___1 = bound_vars_of_bindings bs in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Compiler_List.rev
-let (bound_vars : env -> FStar_Syntax_Syntax.bv Prims.list) =
-  fun env1 -> bound_vars_of_bindings env1.gamma
-let (all_binders : env -> FStar_Syntax_Syntax.binders) =
-  fun env1 -> binders_of_bindings env1.gamma
-let (def_check_vars_in_set :
-  FStar_Compiler_Range.range ->
-    Prims.string ->
-      FStar_Syntax_Syntax.bv FStar_Compiler_Util.set ->
-        FStar_Syntax_Syntax.term -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun vset ->
-        fun t ->
-          let uu___ = FStar_Options.defensive () in
-          if uu___
-          then
-            let s = FStar_Syntax_Free.names t in
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Compiler_Util.set_difference s vset in
-                FStar_Compiler_Effect.op_Less_Bar
-                  FStar_Compiler_Util.set_is_empty uu___3 in
-              Prims.op_Negation uu___2 in
-            (if uu___1
-             then
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Print.term_to_string t in
-                   let uu___5 =
-                     let uu___6 = FStar_Compiler_Util.set_elements s in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___6
-                       (FStar_Syntax_Print.bvs_to_string ",\n\t") in
-                   let uu___6 =
-                     let uu___7 = FStar_Compiler_Util.set_elements vset in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___7
-                       (FStar_Syntax_Print.bvs_to_string ",") in
-                   FStar_Compiler_Util.format4
-                     "Internal: term is not closed (%s).\nt = (%s)\nFVs = (%s)\nScope = (%s)\n"
-                     msg uu___4 uu___5 uu___6 in
-                 (FStar_Errors.Warning_Defensive, uu___3) in
-               FStar_Errors.log_issue rng uu___2
-             else ())
-          else ()
-let (def_check_closed_in :
-  FStar_Compiler_Range.range ->
-    Prims.string ->
-      FStar_Syntax_Syntax.bv Prims.list -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun l ->
-        fun t ->
-          let uu___ =
-            let uu___1 = FStar_Options.defensive () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then ()
-          else
-            (let uu___2 =
-               FStar_Compiler_Util.as_set l FStar_Syntax_Syntax.order_bv in
-             def_check_vars_in_set rng msg uu___2 t)
-let (def_check_closed_in_env :
-  FStar_Compiler_Range.range ->
-    Prims.string -> env -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun e ->
-        fun t ->
-          let uu___ =
-            let uu___1 = FStar_Options.defensive () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then ()
-          else
-            (let uu___2 = bound_vars e in
-             def_check_closed_in rng msg uu___2 t)
-let (def_check_comp_closed_in :
-  FStar_Compiler_Range.range ->
-    Prims.string ->
-      FStar_Syntax_Syntax.bv Prims.list -> FStar_Syntax_Syntax.comp -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun l ->
-        fun c ->
-          let uu___ =
-            let uu___1 = FStar_Options.defensive () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then ()
-          else
-            (match c.FStar_Syntax_Syntax.n with
-             | FStar_Syntax_Syntax.Total t ->
-                 def_check_closed_in rng (Prims.op_Hat msg ".typ") l t
-             | FStar_Syntax_Syntax.GTotal t ->
-                 def_check_closed_in rng (Prims.op_Hat msg ".typ") l t
-             | FStar_Syntax_Syntax.Comp ct ->
-                 (def_check_closed_in rng (Prims.op_Hat msg ".typ") l
-                    ct.FStar_Syntax_Syntax.result_typ;
-                  FStar_Compiler_List.iter
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | (a, uu___4) ->
-                           def_check_closed_in rng (Prims.op_Hat msg ".arg")
-                             l a) ct.FStar_Syntax_Syntax.effect_args))
-let (def_check_comp_closed_in_env :
-  FStar_Compiler_Range.range ->
-    Prims.string -> env -> FStar_Syntax_Syntax.comp -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun e ->
-        fun c ->
-          let uu___ =
-            let uu___1 = FStar_Options.defensive () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then ()
-          else
-            (match c.FStar_Syntax_Syntax.n with
-             | FStar_Syntax_Syntax.Total t ->
-                 def_check_closed_in_env rng (Prims.op_Hat msg ".typ") e t
-             | FStar_Syntax_Syntax.GTotal t ->
-                 def_check_closed_in_env rng (Prims.op_Hat msg ".typ") e t
-             | FStar_Syntax_Syntax.Comp ct ->
-                 (def_check_closed_in_env rng (Prims.op_Hat msg ".typ") e
-                    ct.FStar_Syntax_Syntax.result_typ;
-                  FStar_Compiler_List.iter
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | (a, uu___4) ->
-                           def_check_closed_in_env rng
-                             (Prims.op_Hat msg ".arg") e a)
-                    ct.FStar_Syntax_Syntax.effect_args))
-let (def_check_lcomp_closed_in :
-  FStar_Compiler_Range.range ->
-    Prims.string ->
-      FStar_Syntax_Syntax.bv Prims.list ->
-        FStar_TypeChecker_Common.lcomp -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun l ->
-        fun lc ->
-          let uu___ = FStar_Options.defensive () in
-          if uu___
-          then
-            let uu___1 = FStar_TypeChecker_Common.lcomp_comp lc in
-            match uu___1 with
-            | (c, uu___2) -> def_check_comp_closed_in rng msg l c
-          else ()
-let (def_check_lcomp_closed_in_env :
-  FStar_Compiler_Range.range ->
-    Prims.string -> env -> FStar_TypeChecker_Common.lcomp -> unit)
-  =
-  fun rng ->
-    fun msg ->
-      fun env1 ->
-        fun lc ->
-          let uu___ = FStar_Options.defensive () in
-          if uu___
-          then
-            let uu___1 = FStar_TypeChecker_Common.lcomp_comp lc in
-            match uu___1 with
-            | (c, uu___2) -> def_check_comp_closed_in_env rng msg env1 c
-          else ()
-let (def_check_guard_wf :
-  FStar_Compiler_Range.range -> Prims.string -> env -> guard_t -> unit) =
-  fun rng ->
-    fun msg ->
-      fun env1 ->
-        fun g ->
-          match g.FStar_TypeChecker_Common.guard_f with
-          | FStar_TypeChecker_Common.Trivial -> ()
-          | FStar_TypeChecker_Common.NonTrivial f ->
-              def_check_closed_in_env rng msg env1 f
-let (comp_to_comp_typ :
-  env -> FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp_typ) =
-  fun env1 ->
-    fun c ->
-      def_check_comp_closed_in_env c.FStar_Syntax_Syntax.pos
-        "comp_to_comp_typ" env1 c;
-      (match c.FStar_Syntax_Syntax.n with
-       | FStar_Syntax_Syntax.Comp ct -> ct
-       | uu___1 ->
-           let uu___2 =
-             match c.FStar_Syntax_Syntax.n with
-             | FStar_Syntax_Syntax.Total t ->
-                 (FStar_Parser_Const.effect_Tot_lid, t)
-             | FStar_Syntax_Syntax.GTotal t ->
-                 (FStar_Parser_Const.effect_GTot_lid, t) in
-           (match uu___2 with
-            | (effect_name, result_typ) ->
-                let uu___3 =
-                  let uu___4 = env1.universe_of env1 result_typ in [uu___4] in
-                {
-                  FStar_Syntax_Syntax.comp_univs = uu___3;
-                  FStar_Syntax_Syntax.effect_name = effect_name;
-                  FStar_Syntax_Syntax.result_typ = result_typ;
-                  FStar_Syntax_Syntax.effect_args = [];
-                  FStar_Syntax_Syntax.flags =
-                    (FStar_Syntax_Util.comp_flags c)
-                }))
-let (comp_set_flags :
-  env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.cflag Prims.list -> FStar_Syntax_Syntax.comp)
-  =
-  fun env1 ->
-    fun c ->
-      fun f ->
-        def_check_comp_closed_in_env c.FStar_Syntax_Syntax.pos
-          "comp_set_flags.IN" env1 c;
-        (let r =
-           let uu___1 =
-             let uu___2 =
-               let uu___3 = comp_to_comp_typ env1 c in
-               {
-                 FStar_Syntax_Syntax.comp_univs =
-                   (uu___3.FStar_Syntax_Syntax.comp_univs);
-                 FStar_Syntax_Syntax.effect_name =
-                   (uu___3.FStar_Syntax_Syntax.effect_name);
-                 FStar_Syntax_Syntax.result_typ =
-                   (uu___3.FStar_Syntax_Syntax.result_typ);
-                 FStar_Syntax_Syntax.effect_args =
-                   (uu___3.FStar_Syntax_Syntax.effect_args);
-                 FStar_Syntax_Syntax.flags = f
-               } in
-             FStar_Syntax_Syntax.Comp uu___2 in
-           {
-             FStar_Syntax_Syntax.n = uu___1;
-             FStar_Syntax_Syntax.pos = (c.FStar_Syntax_Syntax.pos);
-             FStar_Syntax_Syntax.vars = (c.FStar_Syntax_Syntax.vars);
-             FStar_Syntax_Syntax.hash_code =
-               (c.FStar_Syntax_Syntax.hash_code)
-           } in
-         def_check_comp_closed_in_env c.FStar_Syntax_Syntax.pos
-           "comp_set_flags.OUT" env1 r;
-         r)
-let rec (unfold_effect_abbrev :
-  env -> FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp_typ) =
-  fun env1 ->
-    fun comp ->
-      def_check_comp_closed_in_env comp.FStar_Syntax_Syntax.pos
-        "unfold_effect_abbrev" env1 comp;
-      (let c = comp_to_comp_typ env1 comp in
-       let uu___1 =
-         lookup_effect_abbrev env1 c.FStar_Syntax_Syntax.comp_univs
-           c.FStar_Syntax_Syntax.effect_name in
-       match uu___1 with
-       | FStar_Pervasives_Native.None -> c
-       | FStar_Pervasives_Native.Some (binders, cdef) ->
-           let uu___2 = FStar_Syntax_Subst.open_comp binders cdef in
-           (match uu___2 with
-            | (binders1, cdef1) ->
-                (if
-                   (FStar_Compiler_List.length binders1) <>
-                     ((FStar_Compiler_List.length
-                         c.FStar_Syntax_Syntax.effect_args)
-                        + Prims.int_one)
-                 then
-                   (let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Compiler_Util.string_of_int
-                            (FStar_Compiler_List.length binders1) in
-                        let uu___7 =
-                          FStar_Compiler_Util.string_of_int
-                            ((FStar_Compiler_List.length
-                                c.FStar_Syntax_Syntax.effect_args)
-                               + Prims.int_one) in
-                        let uu___8 =
-                          let uu___9 = FStar_Syntax_Syntax.mk_Comp c in
-                          FStar_Syntax_Print.comp_to_string uu___9 in
-                        FStar_Compiler_Util.format3
-                          "Effect constructor is not fully applied; expected %s args, got %s args, i.e., %s"
-                          uu___6 uu___7 uu___8 in
-                      (FStar_Errors.Fatal_ConstructorArgLengthMismatch,
-                        uu___5) in
-                    FStar_Errors.raise_error uu___4
-                      comp.FStar_Syntax_Syntax.pos)
-                 else ();
-                 (let inst =
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_Syntax_Syntax.as_arg
-                          c.FStar_Syntax_Syntax.result_typ in
-                      uu___5 :: (c.FStar_Syntax_Syntax.effect_args) in
-                    FStar_Compiler_List.map2
-                      (fun b ->
-                         fun uu___5 ->
-                           match uu___5 with
-                           | (t, uu___6) ->
-                               FStar_Syntax_Syntax.NT
-                                 ((b.FStar_Syntax_Syntax.binder_bv), t))
-                      binders1 uu___4 in
-                  let c1 = FStar_Syntax_Subst.subst_comp inst cdef1 in
-                  let c2 =
-                    let uu___4 =
-                      let uu___5 = comp_to_comp_typ env1 c1 in
-                      {
-                        FStar_Syntax_Syntax.comp_univs =
-                          (uu___5.FStar_Syntax_Syntax.comp_univs);
-                        FStar_Syntax_Syntax.effect_name =
-                          (uu___5.FStar_Syntax_Syntax.effect_name);
-                        FStar_Syntax_Syntax.result_typ =
-                          (uu___5.FStar_Syntax_Syntax.result_typ);
-                        FStar_Syntax_Syntax.effect_args =
-                          (uu___5.FStar_Syntax_Syntax.effect_args);
-                        FStar_Syntax_Syntax.flags =
-                          (c.FStar_Syntax_Syntax.flags)
-                      } in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___4
-                      FStar_Syntax_Syntax.mk_Comp in
-                  unfold_effect_abbrev env1 c2))))
-let effect_repr_aux :
-  'uuuuu .
-    'uuuuu ->
-      env ->
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.universe ->
-            FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-              FStar_Pervasives_Native.option
-  =
-  fun only_reifiable ->
-    fun env1 ->
-      fun c ->
-        fun u_res ->
-          let check_partial_application eff_name args =
-            let r = get_range env1 in
-            let uu___ =
-              let uu___1 = num_effect_indices env1 eff_name r in
-              ((FStar_Compiler_List.length args), uu___1) in
-            match uu___ with
-            | (given, expected) ->
-                if given = expected
-                then ()
-                else
-                  (let message =
-                     let uu___2 = FStar_Ident.string_of_lid eff_name in
-                     let uu___3 = FStar_Compiler_Util.string_of_int given in
-                     let uu___4 = FStar_Compiler_Util.string_of_int expected in
-                     FStar_Compiler_Util.format3
-                       "Not enough arguments for effect %s, This usually happens when you use a partially applied DM4F effect, like [TAC int] instead of [Tac int] (given:%s, expected:%s)."
-                       uu___2 uu___3 uu___4 in
-                   FStar_Errors.raise_error
-                     (FStar_Errors.Fatal_NotEnoughArgumentsForEffect,
-                       message) r) in
-          let effect_name =
-            norm_eff_name env1 (FStar_Syntax_Util.comp_effect_name c) in
-          let uu___ = effect_decl_opt env1 effect_name in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some (ed, uu___1) ->
-              let uu___2 =
-                FStar_Compiler_Effect.op_Bar_Greater ed
-                  FStar_Syntax_Util.get_eff_repr in
-              (match uu___2 with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-               | FStar_Pervasives_Native.Some ts ->
-                   let c1 = unfold_effect_abbrev env1 c in
-                   let res_typ = c1.FStar_Syntax_Syntax.result_typ in
-                   let repr = inst_effect_fun_with [u_res] env1 ed ts in
-                   (check_partial_application effect_name
-                      c1.FStar_Syntax_Syntax.effect_args;
-                    (let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_Compiler_Effect.op_Bar_Greater res_typ
-                                 FStar_Syntax_Syntax.as_arg in
-                             uu___8 :: (c1.FStar_Syntax_Syntax.effect_args) in
-                           (repr, uu___7) in
-                         FStar_Syntax_Syntax.Tm_app uu___6 in
-                       let uu___6 = get_range env1 in
-                       FStar_Syntax_Syntax.mk uu___5 uu___6 in
-                     FStar_Pervasives_Native.Some uu___4)))
-let (effect_repr :
-  env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  = fun env1 -> fun c -> fun u_res -> effect_repr_aux false env1 c u_res
-let (is_user_reifiable_effect : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun effect_lid ->
-      let effect_lid1 = norm_eff_name env1 effect_lid in
-      let quals = lookup_effect_quals env1 effect_lid1 in
-      FStar_Compiler_List.contains FStar_Syntax_Syntax.Reifiable quals
-let (is_user_reflectable_effect : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun effect_lid ->
-      let effect_lid1 = norm_eff_name env1 effect_lid in
-      let quals = lookup_effect_quals env1 effect_lid1 in
-      FStar_Compiler_Effect.op_Bar_Greater quals
-        (FStar_Compiler_List.existsb
-           (fun uu___ ->
-              match uu___ with
-              | FStar_Syntax_Syntax.Reflectable uu___1 -> true
-              | uu___1 -> false))
-let (is_total_effect : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun effect_lid ->
-      let effect_lid1 = norm_eff_name env1 effect_lid in
-      let quals = lookup_effect_quals env1 effect_lid1 in
-      FStar_Compiler_List.contains FStar_Syntax_Syntax.TotalEffect quals
-let (is_reifiable_effect : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun effect_lid ->
-      let effect_lid1 = norm_eff_name env1 effect_lid in
-      (is_user_reifiable_effect env1 effect_lid1) ||
-        (FStar_Ident.lid_equals effect_lid1 FStar_Parser_Const.effect_TAC_lid)
-let (is_reifiable_rc :
-  env -> FStar_Syntax_Syntax.residual_comp -> Prims.bool) =
-  fun env1 ->
-    fun c -> is_reifiable_effect env1 c.FStar_Syntax_Syntax.residual_effect
-let (is_reifiable_comp : env -> FStar_Syntax_Syntax.comp -> Prims.bool) =
-  fun env1 ->
-    fun c ->
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Comp ct ->
-          is_reifiable_effect env1 ct.FStar_Syntax_Syntax.effect_name
-      | uu___ -> false
-let (is_reifiable_function : env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) -> is_reifiable_comp env1 c
-      | uu___1 -> false
-let (reify_comp :
-  env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun c ->
-      fun u_c ->
-        let l = FStar_Syntax_Util.comp_effect_name c in
-        (let uu___1 =
-           let uu___2 = is_reifiable_effect env1 l in
-           Prims.op_Negation uu___2 in
-         if uu___1
-         then
-           let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Ident.string_of_lid l in
-               FStar_Compiler_Util.format1 "Effect %s cannot be reified"
-                 uu___4 in
-             (FStar_Errors.Fatal_EffectCannotBeReified, uu___3) in
-           let uu___3 = get_range env1 in
-           FStar_Errors.raise_error uu___2 uu___3
-         else ());
-        (let uu___1 = effect_repr_aux true env1 c u_c in
-         match uu___1 with
-         | FStar_Pervasives_Native.None ->
-             failwith "internal error: reifiable effect has no repr?"
-         | FStar_Pervasives_Native.Some tm -> tm)
-let (push_sigelt : env -> FStar_Syntax_Syntax.sigelt -> env) =
-  fun env1 ->
-    fun s ->
-      let sb = ((FStar_Syntax_Util.lids_of_sigelt s), s) in
-      let env2 =
-        {
-          solver = (env1.solver);
-          range = (env1.range);
-          curmodule = (env1.curmodule);
-          gamma = (env1.gamma);
-          gamma_sig = (sb :: (env1.gamma_sig));
-          gamma_cache = (env1.gamma_cache);
-          modules = (env1.modules);
-          expected_typ = (env1.expected_typ);
-          sigtab = (env1.sigtab);
-          attrtab = (env1.attrtab);
-          instantiate_imp = (env1.instantiate_imp);
-          effects = (env1.effects);
-          generalize = (env1.generalize);
-          letrecs = (env1.letrecs);
-          top_level = (env1.top_level);
-          check_uvars = (env1.check_uvars);
-          use_eq_strict = (env1.use_eq_strict);
-          is_iface = (env1.is_iface);
-          admit = (env1.admit);
-          lax = (env1.lax);
-          lax_universes = (env1.lax_universes);
-          phase1 = (env1.phase1);
-          failhard = (env1.failhard);
-          nosynth = (env1.nosynth);
-          uvar_subtyping = (env1.uvar_subtyping);
-          tc_term = (env1.tc_term);
-          typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-          universe_of = (env1.universe_of);
-          typeof_well_typed_tot_or_gtot_term =
-            (env1.typeof_well_typed_tot_or_gtot_term);
-          teq_nosmt_force = (env1.teq_nosmt_force);
-          subtype_nosmt_force = (env1.subtype_nosmt_force);
-          qtbl_name_and_index = (env1.qtbl_name_and_index);
-          normalized_eff_names = (env1.normalized_eff_names);
-          fv_delta_depths = (env1.fv_delta_depths);
-          proof_ns = (env1.proof_ns);
-          synth_hook = (env1.synth_hook);
-          try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-          splice = (env1.splice);
-          mpreprocess = (env1.mpreprocess);
-          postprocess = (env1.postprocess);
-          identifier_info = (env1.identifier_info);
-          tc_hooks = (env1.tc_hooks);
-          dsenv = (env1.dsenv);
-          nbe = (env1.nbe);
-          strict_args_tab = (env1.strict_args_tab);
-          erasable_types_tab = (env1.erasable_types_tab);
-          enable_defer_to_tac = (env1.enable_defer_to_tac);
-          unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-          erase_erasable_args = (env1.erase_erasable_args);
-          core_check = (env1.core_check)
-        } in
-      add_sigelt env2 s;
-      (env2.tc_hooks).tc_push_in_gamma_hook env2 (FStar_Pervasives.Inr sb);
-      env2
-let (push_new_effect :
-  env ->
-    (FStar_Syntax_Syntax.eff_decl * FStar_Syntax_Syntax.qualifier Prims.list)
-      -> env)
-  =
-  fun env1 ->
-    fun uu___ ->
-      match uu___ with
-      | (ed, quals) ->
-          let effects1 =
-            let uu___1 = env1.effects in
-            {
-              decls =
-                (FStar_Compiler_List.op_At (env1.effects).decls [(ed, quals)]);
-              order = (uu___1.order);
-              joins = (uu___1.joins);
-              polymonadic_binds = (uu___1.polymonadic_binds);
-              polymonadic_subcomps = (uu___1.polymonadic_subcomps)
-            } in
-          {
-            solver = (env1.solver);
-            range = (env1.range);
-            curmodule = (env1.curmodule);
-            gamma = (env1.gamma);
-            gamma_sig = (env1.gamma_sig);
-            gamma_cache = (env1.gamma_cache);
-            modules = (env1.modules);
-            expected_typ = (env1.expected_typ);
-            sigtab = (env1.sigtab);
-            attrtab = (env1.attrtab);
-            instantiate_imp = (env1.instantiate_imp);
-            effects = effects1;
-            generalize = (env1.generalize);
-            letrecs = (env1.letrecs);
-            top_level = (env1.top_level);
-            check_uvars = (env1.check_uvars);
-            use_eq_strict = (env1.use_eq_strict);
-            is_iface = (env1.is_iface);
-            admit = (env1.admit);
-            lax = (env1.lax);
-            lax_universes = (env1.lax_universes);
-            phase1 = (env1.phase1);
-            failhard = (env1.failhard);
-            nosynth = (env1.nosynth);
-            uvar_subtyping = (env1.uvar_subtyping);
-            tc_term = (env1.tc_term);
-            typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-            universe_of = (env1.universe_of);
-            typeof_well_typed_tot_or_gtot_term =
-              (env1.typeof_well_typed_tot_or_gtot_term);
-            teq_nosmt_force = (env1.teq_nosmt_force);
-            subtype_nosmt_force = (env1.subtype_nosmt_force);
-            qtbl_name_and_index = (env1.qtbl_name_and_index);
-            normalized_eff_names = (env1.normalized_eff_names);
-            fv_delta_depths = (env1.fv_delta_depths);
-            proof_ns = (env1.proof_ns);
-            synth_hook = (env1.synth_hook);
-            try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-            splice = (env1.splice);
-            mpreprocess = (env1.mpreprocess);
-            postprocess = (env1.postprocess);
-            identifier_info = (env1.identifier_info);
-            tc_hooks = (env1.tc_hooks);
-            dsenv = (env1.dsenv);
-            nbe = (env1.nbe);
-            strict_args_tab = (env1.strict_args_tab);
-            erasable_types_tab = (env1.erasable_types_tab);
-            enable_defer_to_tac = (env1.enable_defer_to_tac);
-            unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-            erase_erasable_args = (env1.erase_erasable_args);
-            core_check = (env1.core_check)
-          }
-let (exists_polymonadic_bind :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        (FStar_Ident.lident * polymonadic_bind_t)
-          FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun m ->
-      fun n ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater
-            (env1.effects).polymonadic_binds
-            (FStar_Compiler_Util.find_opt
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (m1, n1, uu___2, uu___3) ->
-                      (FStar_Ident.lid_equals m m1) &&
-                        (FStar_Ident.lid_equals n n1))) in
-        match uu___ with
-        | FStar_Pervasives_Native.Some (uu___1, uu___2, p, t) ->
-            FStar_Pervasives_Native.Some (p, t)
-        | uu___1 -> FStar_Pervasives_Native.None
-let (exists_polymonadic_subcomp :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.tscheme *
-          FStar_Syntax_Syntax.indexed_effect_combinator_kind)
-          FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun m ->
-      fun n ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater
-            (env1.effects).polymonadic_subcomps
-            (FStar_Compiler_Util.find_opt
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (m1, n1, uu___2, uu___3) ->
-                      (FStar_Ident.lid_equals m m1) &&
-                        (FStar_Ident.lid_equals n n1))) in
-        match uu___ with
-        | FStar_Pervasives_Native.Some (uu___1, uu___2, ts, k) ->
-            FStar_Pervasives_Native.Some (ts, k)
-        | uu___1 -> FStar_Pervasives_Native.None
-let (print_effects_graph : env -> Prims.string) =
-  fun env1 ->
-    let eff_name lid =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater lid FStar_Ident.ident_of_lid in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Ident.string_of_id in
-    let path_str path =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater path
-          (FStar_Compiler_List.map eff_name) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ";") in
-    let pbinds = FStar_Compiler_Util.smap_create (Prims.of_int (10)) in
-    let lifts = FStar_Compiler_Util.smap_create (Prims.of_int (20)) in
-    let psubcomps = FStar_Compiler_Util.smap_create (Prims.of_int (10)) in
-    FStar_Compiler_Effect.op_Bar_Greater (env1.effects).order
-      (FStar_Compiler_List.iter
-         (fun uu___1 ->
-            match uu___1 with
-            | { msource = src; mtarget = tgt; mlift = uu___2; mpath = path;_}
-                ->
-                let key = eff_name src in
-                let m =
-                  let uu___3 = FStar_Compiler_Util.smap_try_find lifts key in
-                  match uu___3 with
-                  | FStar_Pervasives_Native.None ->
-                      let m1 =
-                        FStar_Compiler_Util.smap_create (Prims.of_int (10)) in
-                      (FStar_Compiler_Util.smap_add lifts key m1; m1)
-                  | FStar_Pervasives_Native.Some m1 -> m1 in
-                let uu___3 =
-                  let uu___4 = eff_name tgt in
-                  FStar_Compiler_Util.smap_try_find m uu___4 in
-                (match uu___3 with
-                 | FStar_Pervasives_Native.Some uu___4 -> ()
-                 | FStar_Pervasives_Native.None ->
-                     let uu___4 = eff_name tgt in
-                     let uu___5 = path_str path in
-                     FStar_Compiler_Util.smap_add m uu___4 uu___5)));
-    FStar_Compiler_Effect.op_Bar_Greater (env1.effects).polymonadic_binds
-      (FStar_Compiler_List.iter
-         (fun uu___2 ->
-            match uu___2 with
-            | (m, n, p, uu___3) ->
-                let key =
-                  let uu___4 = eff_name m in
-                  let uu___5 = eff_name n in
-                  let uu___6 = eff_name p in
-                  FStar_Compiler_Util.format3 "%s, %s |> %s" uu___4 uu___5
-                    uu___6 in
-                FStar_Compiler_Util.smap_add pbinds key ""));
-    FStar_Compiler_Effect.op_Bar_Greater (env1.effects).polymonadic_subcomps
-      (FStar_Compiler_List.iter
-         (fun uu___3 ->
-            match uu___3 with
-            | (m, n, uu___4, uu___5) ->
-                let key =
-                  let uu___6 = eff_name m in
-                  let uu___7 = eff_name n in
-                  FStar_Compiler_Util.format2 "%s <: %s" uu___6 uu___7 in
-                FStar_Compiler_Util.smap_add psubcomps key ""));
-    (let uu___3 =
-       let uu___4 =
-         FStar_Compiler_Util.smap_fold lifts
-           (fun src ->
-              fun m ->
-                fun s ->
-                  FStar_Compiler_Util.smap_fold m
-                    (fun tgt ->
-                       fun path ->
-                         fun s1 ->
-                           let uu___5 =
-                             FStar_Compiler_Util.format3
-                               "%s -> %s [label=\"%s\"]" src tgt path in
-                           uu___5 :: s1) s) [] in
-       FStar_Compiler_Effect.op_Bar_Greater uu___4 (FStar_String.concat "\n") in
-     let uu___4 =
-       let uu___5 =
-         FStar_Compiler_Util.smap_fold pbinds
-           (fun k ->
-              fun uu___6 ->
-                fun s ->
-                  let uu___7 =
-                    FStar_Compiler_Util.format1
-                      "\"%s\" [shape=\"plaintext\"]" k in
-                  uu___7 :: s) [] in
-       FStar_Compiler_Effect.op_Bar_Greater uu___5 (FStar_String.concat "\n") in
-     let uu___5 =
-       let uu___6 =
-         FStar_Compiler_Util.smap_fold psubcomps
-           (fun k ->
-              fun uu___7 ->
-                fun s ->
-                  let uu___8 =
-                    FStar_Compiler_Util.format1
-                      "\"%s\" [shape=\"plaintext\"]" k in
-                  uu___8 :: s) [] in
-       FStar_Compiler_Effect.op_Bar_Greater uu___6 (FStar_String.concat "\n") in
-     FStar_Compiler_Util.format3
-       "digraph {\nlabel=\"Effects ordering\"\nsubgraph cluster_lifts {\nlabel = \"Lifts\"\n\n      %s\n}\nsubgraph cluster_polymonadic_binds {\nlabel = \"Polymonadic binds\"\n%s\n}\nsubgraph cluster_polymonadic_subcomps {\nlabel = \"Polymonadic subcomps\"\n%s\n}}\n"
-       uu___3 uu___4 uu___5)
-let (update_effect_lattice :
-  env -> FStar_Ident.lident -> FStar_Ident.lident -> mlift -> env) =
-  fun env1 ->
-    fun src ->
-      fun tgt ->
-        fun st_mlift ->
-          let compose_edges e1 e2 =
-            let composed_lift =
-              let mlift_wp env2 c =
-                let uu___ =
-                  FStar_Compiler_Effect.op_Bar_Greater c
-                    ((e1.mlift).mlift_wp env2) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___
-                  (fun uu___1 ->
-                     match uu___1 with
-                     | (c1, g1) ->
-                         let uu___2 =
-                           FStar_Compiler_Effect.op_Bar_Greater c1
-                             ((e2.mlift).mlift_wp env2) in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___2
-                           (fun uu___3 ->
-                              match uu___3 with
-                              | (c2, g2) ->
-                                  let uu___4 =
-                                    FStar_TypeChecker_Common.conj_guard g1 g2 in
-                                  (c2, uu___4))) in
-              let mlift_term =
-                match (((e1.mlift).mlift_term), ((e2.mlift).mlift_term)) with
-                | (FStar_Pervasives_Native.Some l1,
-                   FStar_Pervasives_Native.Some l2) ->
-                    FStar_Pervasives_Native.Some
-                      ((fun u ->
-                          fun t ->
-                            fun e -> let uu___ = l1 u t e in l2 u t uu___))
-                | uu___ -> FStar_Pervasives_Native.None in
-              { mlift_wp; mlift_term } in
-            {
-              msource = (e1.msource);
-              mtarget = (e2.mtarget);
-              mlift = composed_lift;
-              mpath =
-                (FStar_Compiler_List.op_At e1.mpath
-                   (FStar_Compiler_List.op_At [e1.mtarget] e2.mpath))
-            } in
-          let edge1 =
-            { msource = src; mtarget = tgt; mlift = st_mlift; mpath = [] } in
-          let id_edge l =
-            {
-              msource = src;
-              mtarget = tgt;
-              mlift = identity_mlift;
-              mpath = []
-            } in
-          let find_edge order uu___ =
-            match uu___ with
-            | (i, j) ->
-                let uu___1 = FStar_Ident.lid_equals i j in
-                if uu___1
-                then
-                  FStar_Compiler_Effect.op_Bar_Greater (id_edge i)
-                    (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-                else
-                  FStar_Compiler_Effect.op_Bar_Greater order
-                    (FStar_Compiler_Util.find_opt
-                       (fun e ->
-                          (FStar_Ident.lid_equals e.msource i) &&
-                            (FStar_Ident.lid_equals e.mtarget j))) in
-          let ms =
-            FStar_Compiler_Effect.op_Bar_Greater (env1.effects).decls
-              (FStar_Compiler_List.map
-                 (fun uu___ ->
-                    match uu___ with
-                    | (e, uu___1) -> e.FStar_Syntax_Syntax.mname)) in
-          let all_i_src =
-            FStar_Compiler_Effect.op_Bar_Greater ms
-              (FStar_Compiler_List.fold_left
-                 (fun edges ->
-                    fun i ->
-                      let uu___ = FStar_Ident.lid_equals i edge1.msource in
-                      if uu___
-                      then edges
-                      else
-                        (let uu___2 =
-                           find_edge (env1.effects).order
-                             (i, (edge1.msource)) in
-                         match uu___2 with
-                         | FStar_Pervasives_Native.Some e -> e :: edges
-                         | FStar_Pervasives_Native.None -> edges)) []) in
-          let all_tgt_j =
-            FStar_Compiler_Effect.op_Bar_Greater ms
-              (FStar_Compiler_List.fold_left
-                 (fun edges ->
-                    fun j ->
-                      let uu___ = FStar_Ident.lid_equals edge1.mtarget j in
-                      if uu___
-                      then edges
-                      else
-                        (let uu___2 =
-                           find_edge (env1.effects).order
-                             ((edge1.mtarget), j) in
-                         match uu___2 with
-                         | FStar_Pervasives_Native.Some e -> e :: edges
-                         | FStar_Pervasives_Native.None -> edges)) []) in
-          let check_cycle src1 tgt1 =
-            let uu___ = FStar_Ident.lid_equals src1 tgt1 in
-            if uu___
-            then
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = FStar_Ident.string_of_lid edge1.msource in
-                  let uu___4 = FStar_Ident.string_of_lid edge1.mtarget in
-                  let uu___5 = FStar_Ident.string_of_lid src1 in
-                  FStar_Compiler_Util.format3
-                    "Adding an edge %s~>%s induces a cycle %s" uu___3 uu___4
-                    uu___5 in
-                (FStar_Errors.Fatal_Effects_Ordering_Coherence, uu___2) in
-              FStar_Errors.raise_error uu___1 env1.range
-            else () in
-          let new_i_edge_target =
-            FStar_Compiler_List.fold_left
-              (fun edges ->
-                 fun i_src ->
-                   check_cycle i_src.msource edge1.mtarget;
-                   (let uu___1 = compose_edges i_src edge1 in uu___1 :: edges))
-              [] all_i_src in
-          let new_edge_source_j =
-            FStar_Compiler_List.fold_left
-              (fun edges ->
-                 fun tgt_j ->
-                   check_cycle edge1.msource tgt_j.mtarget;
-                   (let uu___1 = compose_edges edge1 tgt_j in uu___1 :: edges))
-              [] all_tgt_j in
-          let new_i_j =
-            FStar_Compiler_List.fold_left
-              (fun edges ->
-                 fun i_src ->
-                   FStar_Compiler_List.fold_left
-                     (fun edges1 ->
-                        fun tgt_j ->
-                          check_cycle i_src.msource tgt_j.mtarget;
-                          (let uu___1 =
-                             let uu___2 = compose_edges i_src edge1 in
-                             compose_edges uu___2 tgt_j in
-                           uu___1 :: edges1)) edges all_tgt_j) [] all_i_src in
-          let new_edges = edge1 ::
-            (FStar_Compiler_List.op_At new_i_edge_target
-               (FStar_Compiler_List.op_At new_edge_source_j new_i_j)) in
-          let order =
-            FStar_Compiler_List.op_At new_edges (env1.effects).order in
-          FStar_Compiler_Effect.op_Bar_Greater order
-            (FStar_Compiler_List.iter
-               (fun edge2 ->
-                  let uu___1 =
-                    (FStar_Ident.lid_equals edge2.msource
-                       FStar_Parser_Const.effect_DIV_lid)
-                      &&
-                      (let uu___2 = lookup_effect_quals env1 edge2.mtarget in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___2
-                         (FStar_Compiler_List.contains
-                            FStar_Syntax_Syntax.TotalEffect)) in
-                  if uu___1
-                  then
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = FStar_Ident.string_of_lid edge2.mtarget in
-                        FStar_Compiler_Util.format1
-                          "Divergent computations cannot be included in an effect %s marked 'total'"
-                          uu___4 in
-                      (FStar_Errors.Fatal_DivergentComputationCannotBeIncludedInTotal,
-                        uu___3) in
-                    let uu___3 = get_range env1 in
-                    FStar_Errors.raise_error uu___2 uu___3
-                  else ()));
-          (let joins =
-             let ubs = FStar_Compiler_Util.smap_create (Prims.of_int (10)) in
-             let add_ub i j k ik jk =
-               let key =
-                 let uu___1 = FStar_Ident.string_of_lid i in
-                 let uu___2 =
-                   let uu___3 = FStar_Ident.string_of_lid j in
-                   Prims.op_Hat ":" uu___3 in
-                 Prims.op_Hat uu___1 uu___2 in
-               let v =
-                 let uu___1 = FStar_Compiler_Util.smap_try_find ubs key in
-                 match uu___1 with
-                 | FStar_Pervasives_Native.Some ubs1 -> (i, j, k, ik, jk) ::
-                     ubs1
-                 | FStar_Pervasives_Native.None -> [(i, j, k, ik, jk)] in
-               FStar_Compiler_Util.smap_add ubs key v in
-             FStar_Compiler_Effect.op_Bar_Greater ms
-               (FStar_Compiler_List.iter
-                  (fun i ->
-                     FStar_Compiler_Effect.op_Bar_Greater ms
-                       (FStar_Compiler_List.iter
-                          (fun j ->
-                             let uu___2 = FStar_Ident.lid_equals i j in
-                             if uu___2
-                             then ()
-                             else
-                               FStar_Compiler_Effect.op_Bar_Greater ms
-                                 (FStar_Compiler_List.iter
-                                    (fun k ->
-                                       let uu___4 =
-                                         let uu___5 = find_edge order (i, k) in
-                                         let uu___6 = find_edge order (j, k) in
-                                         (uu___5, uu___6) in
-                                       match uu___4 with
-                                       | (FStar_Pervasives_Native.Some ik,
-                                          FStar_Pervasives_Native.Some jk) ->
-                                           add_ub i j k ik.mlift jk.mlift
-                                       | uu___5 -> ()))))));
-             FStar_Compiler_Util.smap_fold ubs
-               (fun s ->
-                  fun l ->
-                    fun joins1 ->
-                      let lubs =
-                        FStar_Compiler_List.filter
-                          (fun uu___2 ->
-                             match uu___2 with
-                             | (i, j, k, ik, jk) ->
-                                 FStar_Compiler_List.for_all
-                                   (fun uu___3 ->
-                                      match uu___3 with
-                                      | (uu___4, uu___5, k', uu___6, uu___7)
-                                          ->
-                                          let uu___8 =
-                                            find_edge order (k, k') in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___8
-                                            FStar_Compiler_Util.is_some) l) l in
-                      if (FStar_Compiler_List.length lubs) <> Prims.int_one
-                      then
-                        let uu___2 =
-                          let uu___3 =
-                            FStar_Compiler_Util.format1
-                              "Effects %s have incomparable upper bounds" s in
-                          (FStar_Errors.Fatal_Effects_Ordering_Coherence,
-                            uu___3) in
-                        FStar_Errors.raise_error uu___2 env1.range
-                      else FStar_Compiler_List.op_At lubs joins1) [] in
-           let effects1 =
-             let uu___1 = env1.effects in
-             {
-               decls = (uu___1.decls);
-               order;
-               joins;
-               polymonadic_binds = (uu___1.polymonadic_binds);
-               polymonadic_subcomps = (uu___1.polymonadic_subcomps)
-             } in
-           {
-             solver = (env1.solver);
-             range = (env1.range);
-             curmodule = (env1.curmodule);
-             gamma = (env1.gamma);
-             gamma_sig = (env1.gamma_sig);
-             gamma_cache = (env1.gamma_cache);
-             modules = (env1.modules);
-             expected_typ = (env1.expected_typ);
-             sigtab = (env1.sigtab);
-             attrtab = (env1.attrtab);
-             instantiate_imp = (env1.instantiate_imp);
-             effects = effects1;
-             generalize = (env1.generalize);
-             letrecs = (env1.letrecs);
-             top_level = (env1.top_level);
-             check_uvars = (env1.check_uvars);
-             use_eq_strict = (env1.use_eq_strict);
-             is_iface = (env1.is_iface);
-             admit = (env1.admit);
-             lax = (env1.lax);
-             lax_universes = (env1.lax_universes);
-             phase1 = (env1.phase1);
-             failhard = (env1.failhard);
-             nosynth = (env1.nosynth);
-             uvar_subtyping = (env1.uvar_subtyping);
-             tc_term = (env1.tc_term);
-             typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-             universe_of = (env1.universe_of);
-             typeof_well_typed_tot_or_gtot_term =
-               (env1.typeof_well_typed_tot_or_gtot_term);
-             teq_nosmt_force = (env1.teq_nosmt_force);
-             subtype_nosmt_force = (env1.subtype_nosmt_force);
-             qtbl_name_and_index = (env1.qtbl_name_and_index);
-             normalized_eff_names = (env1.normalized_eff_names);
-             fv_delta_depths = (env1.fv_delta_depths);
-             proof_ns = (env1.proof_ns);
-             synth_hook = (env1.synth_hook);
-             try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-             splice = (env1.splice);
-             mpreprocess = (env1.mpreprocess);
-             postprocess = (env1.postprocess);
-             identifier_info = (env1.identifier_info);
-             tc_hooks = (env1.tc_hooks);
-             dsenv = (env1.dsenv);
-             nbe = (env1.nbe);
-             strict_args_tab = (env1.strict_args_tab);
-             erasable_types_tab = (env1.erasable_types_tab);
-             enable_defer_to_tac = (env1.enable_defer_to_tac);
-             unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-             erase_erasable_args = (env1.erase_erasable_args);
-             core_check = (env1.core_check)
-           })
-let (add_polymonadic_bind :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident -> FStar_Ident.lident -> polymonadic_bind_t -> env)
-  =
-  fun env1 ->
-    fun m ->
-      fun n ->
-        fun p ->
-          fun ty ->
-            {
-              solver = (env1.solver);
-              range = (env1.range);
-              curmodule = (env1.curmodule);
-              gamma = (env1.gamma);
-              gamma_sig = (env1.gamma_sig);
-              gamma_cache = (env1.gamma_cache);
-              modules = (env1.modules);
-              expected_typ = (env1.expected_typ);
-              sigtab = (env1.sigtab);
-              attrtab = (env1.attrtab);
-              instantiate_imp = (env1.instantiate_imp);
-              effects =
-                (let uu___ = env1.effects in
-                 {
-                   decls = (uu___.decls);
-                   order = (uu___.order);
-                   joins = (uu___.joins);
-                   polymonadic_binds = ((m, n, p, ty) ::
-                     ((env1.effects).polymonadic_binds));
-                   polymonadic_subcomps = (uu___.polymonadic_subcomps)
-                 });
-              generalize = (env1.generalize);
-              letrecs = (env1.letrecs);
-              top_level = (env1.top_level);
-              check_uvars = (env1.check_uvars);
-              use_eq_strict = (env1.use_eq_strict);
-              is_iface = (env1.is_iface);
-              admit = (env1.admit);
-              lax = (env1.lax);
-              lax_universes = (env1.lax_universes);
-              phase1 = (env1.phase1);
-              failhard = (env1.failhard);
-              nosynth = (env1.nosynth);
-              uvar_subtyping = (env1.uvar_subtyping);
-              tc_term = (env1.tc_term);
-              typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-              universe_of = (env1.universe_of);
-              typeof_well_typed_tot_or_gtot_term =
-                (env1.typeof_well_typed_tot_or_gtot_term);
-              teq_nosmt_force = (env1.teq_nosmt_force);
-              subtype_nosmt_force = (env1.subtype_nosmt_force);
-              qtbl_name_and_index = (env1.qtbl_name_and_index);
-              normalized_eff_names = (env1.normalized_eff_names);
-              fv_delta_depths = (env1.fv_delta_depths);
-              proof_ns = (env1.proof_ns);
-              synth_hook = (env1.synth_hook);
-              try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-              splice = (env1.splice);
-              mpreprocess = (env1.mpreprocess);
-              postprocess = (env1.postprocess);
-              identifier_info = (env1.identifier_info);
-              tc_hooks = (env1.tc_hooks);
-              dsenv = (env1.dsenv);
-              nbe = (env1.nbe);
-              strict_args_tab = (env1.strict_args_tab);
-              erasable_types_tab = (env1.erasable_types_tab);
-              enable_defer_to_tac = (env1.enable_defer_to_tac);
-              unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-              erase_erasable_args = (env1.erase_erasable_args);
-              core_check = (env1.core_check)
-            }
-let (add_polymonadic_subcomp :
-  env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        (FStar_Syntax_Syntax.tscheme *
-          FStar_Syntax_Syntax.indexed_effect_combinator_kind) -> env)
-  =
-  fun env1 ->
-    fun m ->
-      fun n ->
-        fun uu___ ->
-          match uu___ with
-          | (ts, k) ->
-              {
-                solver = (env1.solver);
-                range = (env1.range);
-                curmodule = (env1.curmodule);
-                gamma = (env1.gamma);
-                gamma_sig = (env1.gamma_sig);
-                gamma_cache = (env1.gamma_cache);
-                modules = (env1.modules);
-                expected_typ = (env1.expected_typ);
-                sigtab = (env1.sigtab);
-                attrtab = (env1.attrtab);
-                instantiate_imp = (env1.instantiate_imp);
-                effects =
-                  (let uu___1 = env1.effects in
-                   {
-                     decls = (uu___1.decls);
-                     order = (uu___1.order);
-                     joins = (uu___1.joins);
-                     polymonadic_binds = (uu___1.polymonadic_binds);
-                     polymonadic_subcomps = ((m, n, ts, k) ::
-                       ((env1.effects).polymonadic_subcomps))
-                   });
-                generalize = (env1.generalize);
-                letrecs = (env1.letrecs);
-                top_level = (env1.top_level);
-                check_uvars = (env1.check_uvars);
-                use_eq_strict = (env1.use_eq_strict);
-                is_iface = (env1.is_iface);
-                admit = (env1.admit);
-                lax = (env1.lax);
-                lax_universes = (env1.lax_universes);
-                phase1 = (env1.phase1);
-                failhard = (env1.failhard);
-                nosynth = (env1.nosynth);
-                uvar_subtyping = (env1.uvar_subtyping);
-                tc_term = (env1.tc_term);
-                typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-                universe_of = (env1.universe_of);
-                typeof_well_typed_tot_or_gtot_term =
-                  (env1.typeof_well_typed_tot_or_gtot_term);
-                teq_nosmt_force = (env1.teq_nosmt_force);
-                subtype_nosmt_force = (env1.subtype_nosmt_force);
-                qtbl_name_and_index = (env1.qtbl_name_and_index);
-                normalized_eff_names = (env1.normalized_eff_names);
-                fv_delta_depths = (env1.fv_delta_depths);
-                proof_ns = (env1.proof_ns);
-                synth_hook = (env1.synth_hook);
-                try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-                splice = (env1.splice);
-                mpreprocess = (env1.mpreprocess);
-                postprocess = (env1.postprocess);
-                identifier_info = (env1.identifier_info);
-                tc_hooks = (env1.tc_hooks);
-                dsenv = (env1.dsenv);
-                nbe = (env1.nbe);
-                strict_args_tab = (env1.strict_args_tab);
-                erasable_types_tab = (env1.erasable_types_tab);
-                enable_defer_to_tac = (env1.enable_defer_to_tac);
-                unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-                erase_erasable_args = (env1.erase_erasable_args);
-                core_check = (env1.core_check)
-              }
-let (push_local_binding : env -> FStar_Syntax_Syntax.binding -> env) =
-  fun env1 ->
-    fun b ->
-      {
-        solver = (env1.solver);
-        range = (env1.range);
-        curmodule = (env1.curmodule);
-        gamma = (b :: (env1.gamma));
-        gamma_sig = (env1.gamma_sig);
-        gamma_cache = (env1.gamma_cache);
-        modules = (env1.modules);
-        expected_typ = (env1.expected_typ);
-        sigtab = (env1.sigtab);
-        attrtab = (env1.attrtab);
-        instantiate_imp = (env1.instantiate_imp);
-        effects = (env1.effects);
-        generalize = (env1.generalize);
-        letrecs = (env1.letrecs);
-        top_level = (env1.top_level);
-        check_uvars = (env1.check_uvars);
-        use_eq_strict = (env1.use_eq_strict);
-        is_iface = (env1.is_iface);
-        admit = (env1.admit);
-        lax = (env1.lax);
-        lax_universes = (env1.lax_universes);
-        phase1 = (env1.phase1);
-        failhard = (env1.failhard);
-        nosynth = (env1.nosynth);
-        uvar_subtyping = (env1.uvar_subtyping);
-        tc_term = (env1.tc_term);
-        typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-        universe_of = (env1.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (env1.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (env1.teq_nosmt_force);
-        subtype_nosmt_force = (env1.subtype_nosmt_force);
-        qtbl_name_and_index = (env1.qtbl_name_and_index);
-        normalized_eff_names = (env1.normalized_eff_names);
-        fv_delta_depths = (env1.fv_delta_depths);
-        proof_ns = (env1.proof_ns);
-        synth_hook = (env1.synth_hook);
-        try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-        splice = (env1.splice);
-        mpreprocess = (env1.mpreprocess);
-        postprocess = (env1.postprocess);
-        identifier_info = (env1.identifier_info);
-        tc_hooks = (env1.tc_hooks);
-        dsenv = (env1.dsenv);
-        nbe = (env1.nbe);
-        strict_args_tab = (env1.strict_args_tab);
-        erasable_types_tab = (env1.erasable_types_tab);
-        enable_defer_to_tac = (env1.enable_defer_to_tac);
-        unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-        erase_erasable_args = (env1.erase_erasable_args);
-        core_check = (env1.core_check)
-      }
-let (push_bv : env -> FStar_Syntax_Syntax.bv -> env) =
-  fun env1 ->
-    fun x -> push_local_binding env1 (FStar_Syntax_Syntax.Binding_var x)
-let (push_bvs : env -> FStar_Syntax_Syntax.bv Prims.list -> env) =
-  fun env1 ->
-    fun bvs ->
-      FStar_Compiler_List.fold_left (fun env2 -> fun bv -> push_bv env2 bv)
-        env1 bvs
-let (pop_bv :
-  env -> (FStar_Syntax_Syntax.bv * env) FStar_Pervasives_Native.option) =
-  fun env1 ->
-    match env1.gamma with
-    | (FStar_Syntax_Syntax.Binding_var x)::rest ->
-        FStar_Pervasives_Native.Some
-          (x,
-            {
-              solver = (env1.solver);
-              range = (env1.range);
-              curmodule = (env1.curmodule);
-              gamma = rest;
-              gamma_sig = (env1.gamma_sig);
-              gamma_cache = (env1.gamma_cache);
-              modules = (env1.modules);
-              expected_typ = (env1.expected_typ);
-              sigtab = (env1.sigtab);
-              attrtab = (env1.attrtab);
-              instantiate_imp = (env1.instantiate_imp);
-              effects = (env1.effects);
-              generalize = (env1.generalize);
-              letrecs = (env1.letrecs);
-              top_level = (env1.top_level);
-              check_uvars = (env1.check_uvars);
-              use_eq_strict = (env1.use_eq_strict);
-              is_iface = (env1.is_iface);
-              admit = (env1.admit);
-              lax = (env1.lax);
-              lax_universes = (env1.lax_universes);
-              phase1 = (env1.phase1);
-              failhard = (env1.failhard);
-              nosynth = (env1.nosynth);
-              uvar_subtyping = (env1.uvar_subtyping);
-              tc_term = (env1.tc_term);
-              typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-              universe_of = (env1.universe_of);
-              typeof_well_typed_tot_or_gtot_term =
-                (env1.typeof_well_typed_tot_or_gtot_term);
-              teq_nosmt_force = (env1.teq_nosmt_force);
-              subtype_nosmt_force = (env1.subtype_nosmt_force);
-              qtbl_name_and_index = (env1.qtbl_name_and_index);
-              normalized_eff_names = (env1.normalized_eff_names);
-              fv_delta_depths = (env1.fv_delta_depths);
-              proof_ns = (env1.proof_ns);
-              synth_hook = (env1.synth_hook);
-              try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-              splice = (env1.splice);
-              mpreprocess = (env1.mpreprocess);
-              postprocess = (env1.postprocess);
-              identifier_info = (env1.identifier_info);
-              tc_hooks = (env1.tc_hooks);
-              dsenv = (env1.dsenv);
-              nbe = (env1.nbe);
-              strict_args_tab = (env1.strict_args_tab);
-              erasable_types_tab = (env1.erasable_types_tab);
-              enable_defer_to_tac = (env1.enable_defer_to_tac);
-              unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-              erase_erasable_args = (env1.erase_erasable_args);
-              core_check = (env1.core_check)
-            })
-    | uu___ -> FStar_Pervasives_Native.None
-let (push_binders : env -> FStar_Syntax_Syntax.binders -> env) =
-  fun env1 ->
-    fun bs ->
-      FStar_Compiler_List.fold_left
-        (fun env2 -> fun b -> push_bv env2 b.FStar_Syntax_Syntax.binder_bv)
-        env1 bs
-let (binding_of_lb :
-  FStar_Syntax_Syntax.lbname ->
-    (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term'
-      FStar_Syntax_Syntax.syntax) -> FStar_Syntax_Syntax.binding)
-  =
-  fun x ->
-    fun t ->
-      match x with
-      | FStar_Pervasives.Inl x1 ->
-          let x2 =
-            {
-              FStar_Syntax_Syntax.ppname = (x1.FStar_Syntax_Syntax.ppname);
-              FStar_Syntax_Syntax.index = (x1.FStar_Syntax_Syntax.index);
-              FStar_Syntax_Syntax.sort = (FStar_Pervasives_Native.snd t)
-            } in
-          FStar_Syntax_Syntax.Binding_var x2
-      | FStar_Pervasives.Inr fv ->
-          FStar_Syntax_Syntax.Binding_lid
-            (((fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v), t)
-let (push_let_binding :
-  env -> FStar_Syntax_Syntax.lbname -> FStar_Syntax_Syntax.tscheme -> env) =
-  fun env1 ->
-    fun lb -> fun ts -> push_local_binding env1 (binding_of_lb lb ts)
-let (push_univ_vars : env -> FStar_Syntax_Syntax.univ_names -> env) =
-  fun env1 ->
-    fun xs ->
-      FStar_Compiler_List.fold_left
-        (fun env2 ->
-           fun x ->
-             push_local_binding env2 (FStar_Syntax_Syntax.Binding_univ x))
-        env1 xs
-let (open_universes_in :
-  env ->
-    FStar_Syntax_Syntax.univ_names ->
-      FStar_Syntax_Syntax.term Prims.list ->
-        (env * FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term
-          Prims.list))
-  =
-  fun env1 ->
-    fun uvs ->
-      fun terms ->
-        let uu___ = FStar_Syntax_Subst.univ_var_opening uvs in
-        match uu___ with
-        | (univ_subst, univ_vars) ->
-            let env' = push_univ_vars env1 univ_vars in
-            let uu___1 =
-              FStar_Compiler_List.map (FStar_Syntax_Subst.subst univ_subst)
-                terms in
-            (env', univ_vars, uu___1)
-let (set_expected_typ : env -> FStar_Syntax_Syntax.typ -> env) =
-  fun env1 ->
-    fun t ->
-      {
-        solver = (env1.solver);
-        range = (env1.range);
-        curmodule = (env1.curmodule);
-        gamma = (env1.gamma);
-        gamma_sig = (env1.gamma_sig);
-        gamma_cache = (env1.gamma_cache);
-        modules = (env1.modules);
-        expected_typ = (FStar_Pervasives_Native.Some (t, false));
-        sigtab = (env1.sigtab);
-        attrtab = (env1.attrtab);
-        instantiate_imp = (env1.instantiate_imp);
-        effects = (env1.effects);
-        generalize = (env1.generalize);
-        letrecs = (env1.letrecs);
-        top_level = (env1.top_level);
-        check_uvars = (env1.check_uvars);
-        use_eq_strict = (env1.use_eq_strict);
-        is_iface = (env1.is_iface);
-        admit = (env1.admit);
-        lax = (env1.lax);
-        lax_universes = (env1.lax_universes);
-        phase1 = (env1.phase1);
-        failhard = (env1.failhard);
-        nosynth = (env1.nosynth);
-        uvar_subtyping = (env1.uvar_subtyping);
-        tc_term = (env1.tc_term);
-        typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-        universe_of = (env1.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (env1.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (env1.teq_nosmt_force);
-        subtype_nosmt_force = (env1.subtype_nosmt_force);
-        qtbl_name_and_index = (env1.qtbl_name_and_index);
-        normalized_eff_names = (env1.normalized_eff_names);
-        fv_delta_depths = (env1.fv_delta_depths);
-        proof_ns = (env1.proof_ns);
-        synth_hook = (env1.synth_hook);
-        try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-        splice = (env1.splice);
-        mpreprocess = (env1.mpreprocess);
-        postprocess = (env1.postprocess);
-        identifier_info = (env1.identifier_info);
-        tc_hooks = (env1.tc_hooks);
-        dsenv = (env1.dsenv);
-        nbe = (env1.nbe);
-        strict_args_tab = (env1.strict_args_tab);
-        erasable_types_tab = (env1.erasable_types_tab);
-        enable_defer_to_tac = (env1.enable_defer_to_tac);
-        unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-        erase_erasable_args = (env1.erase_erasable_args);
-        core_check = (env1.core_check)
-      }
-let (set_expected_typ_maybe_eq :
-  env -> FStar_Syntax_Syntax.typ -> Prims.bool -> env) =
-  fun env1 ->
-    fun t ->
-      fun use_eq ->
-        {
-          solver = (env1.solver);
-          range = (env1.range);
-          curmodule = (env1.curmodule);
-          gamma = (env1.gamma);
-          gamma_sig = (env1.gamma_sig);
-          gamma_cache = (env1.gamma_cache);
-          modules = (env1.modules);
-          expected_typ = (FStar_Pervasives_Native.Some (t, use_eq));
-          sigtab = (env1.sigtab);
-          attrtab = (env1.attrtab);
-          instantiate_imp = (env1.instantiate_imp);
-          effects = (env1.effects);
-          generalize = (env1.generalize);
-          letrecs = (env1.letrecs);
-          top_level = (env1.top_level);
-          check_uvars = (env1.check_uvars);
-          use_eq_strict = (env1.use_eq_strict);
-          is_iface = (env1.is_iface);
-          admit = (env1.admit);
-          lax = (env1.lax);
-          lax_universes = (env1.lax_universes);
-          phase1 = (env1.phase1);
-          failhard = (env1.failhard);
-          nosynth = (env1.nosynth);
-          uvar_subtyping = (env1.uvar_subtyping);
-          tc_term = (env1.tc_term);
-          typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-          universe_of = (env1.universe_of);
-          typeof_well_typed_tot_or_gtot_term =
-            (env1.typeof_well_typed_tot_or_gtot_term);
-          teq_nosmt_force = (env1.teq_nosmt_force);
-          subtype_nosmt_force = (env1.subtype_nosmt_force);
-          qtbl_name_and_index = (env1.qtbl_name_and_index);
-          normalized_eff_names = (env1.normalized_eff_names);
-          fv_delta_depths = (env1.fv_delta_depths);
-          proof_ns = (env1.proof_ns);
-          synth_hook = (env1.synth_hook);
-          try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-          splice = (env1.splice);
-          mpreprocess = (env1.mpreprocess);
-          postprocess = (env1.postprocess);
-          identifier_info = (env1.identifier_info);
-          tc_hooks = (env1.tc_hooks);
-          dsenv = (env1.dsenv);
-          nbe = (env1.nbe);
-          strict_args_tab = (env1.strict_args_tab);
-          erasable_types_tab = (env1.erasable_types_tab);
-          enable_defer_to_tac = (env1.enable_defer_to_tac);
-          unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-          erase_erasable_args = (env1.erase_erasable_args);
-          core_check = (env1.core_check)
-        }
-let (expected_typ :
-  env ->
-    (FStar_Syntax_Syntax.typ * Prims.bool) FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    match env1.expected_typ with
-    | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-    | FStar_Pervasives_Native.Some t -> FStar_Pervasives_Native.Some t
-let (clear_expected_typ :
-  env ->
-    (env * (FStar_Syntax_Syntax.typ * Prims.bool)
-      FStar_Pervasives_Native.option))
-  =
-  fun env_ ->
-    let uu___ = expected_typ env_ in
-    ({
-       solver = (env_.solver);
-       range = (env_.range);
-       curmodule = (env_.curmodule);
-       gamma = (env_.gamma);
-       gamma_sig = (env_.gamma_sig);
-       gamma_cache = (env_.gamma_cache);
-       modules = (env_.modules);
-       expected_typ = FStar_Pervasives_Native.None;
-       sigtab = (env_.sigtab);
-       attrtab = (env_.attrtab);
-       instantiate_imp = (env_.instantiate_imp);
-       effects = (env_.effects);
-       generalize = (env_.generalize);
-       letrecs = (env_.letrecs);
-       top_level = (env_.top_level);
-       check_uvars = (env_.check_uvars);
-       use_eq_strict = (env_.use_eq_strict);
-       is_iface = (env_.is_iface);
-       admit = (env_.admit);
-       lax = (env_.lax);
-       lax_universes = (env_.lax_universes);
-       phase1 = (env_.phase1);
-       failhard = (env_.failhard);
-       nosynth = (env_.nosynth);
-       uvar_subtyping = (env_.uvar_subtyping);
-       tc_term = (env_.tc_term);
-       typeof_tot_or_gtot_term = (env_.typeof_tot_or_gtot_term);
-       universe_of = (env_.universe_of);
-       typeof_well_typed_tot_or_gtot_term =
-         (env_.typeof_well_typed_tot_or_gtot_term);
-       teq_nosmt_force = (env_.teq_nosmt_force);
-       subtype_nosmt_force = (env_.subtype_nosmt_force);
-       qtbl_name_and_index = (env_.qtbl_name_and_index);
-       normalized_eff_names = (env_.normalized_eff_names);
-       fv_delta_depths = (env_.fv_delta_depths);
-       proof_ns = (env_.proof_ns);
-       synth_hook = (env_.synth_hook);
-       try_solve_implicits_hook = (env_.try_solve_implicits_hook);
-       splice = (env_.splice);
-       mpreprocess = (env_.mpreprocess);
-       postprocess = (env_.postprocess);
-       identifier_info = (env_.identifier_info);
-       tc_hooks = (env_.tc_hooks);
-       dsenv = (env_.dsenv);
-       nbe = (env_.nbe);
-       strict_args_tab = (env_.strict_args_tab);
-       erasable_types_tab = (env_.erasable_types_tab);
-       enable_defer_to_tac = (env_.enable_defer_to_tac);
-       unif_allow_ref_guards = (env_.unif_allow_ref_guards);
-       erase_erasable_args = (env_.erase_erasable_args);
-       core_check = (env_.core_check)
-     }, uu___)
-let (finish_module : env -> FStar_Syntax_Syntax.modul -> env) =
-  let empty_lid =
-    let uu___ = let uu___1 = FStar_Ident.id_of_text "" in [uu___1] in
-    FStar_Ident.lid_of_ids uu___ in
-  fun env1 ->
-    fun m ->
-      let sigs =
-        let uu___ =
-          FStar_Ident.lid_equals m.FStar_Syntax_Syntax.name
-            FStar_Parser_Const.prims_lid in
-        if uu___
-        then
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater env1.gamma_sig
-              (FStar_Compiler_List.map FStar_Pervasives_Native.snd) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1 FStar_Compiler_List.rev
-        else m.FStar_Syntax_Syntax.declarations in
-      add_sigelts env1 sigs;
-      {
-        solver = (env1.solver);
-        range = (env1.range);
-        curmodule = empty_lid;
-        gamma = [];
-        gamma_sig = [];
-        gamma_cache = (env1.gamma_cache);
-        modules = (m :: (env1.modules));
-        expected_typ = (env1.expected_typ);
-        sigtab = (env1.sigtab);
-        attrtab = (env1.attrtab);
-        instantiate_imp = (env1.instantiate_imp);
-        effects = (env1.effects);
-        generalize = (env1.generalize);
-        letrecs = (env1.letrecs);
-        top_level = (env1.top_level);
-        check_uvars = (env1.check_uvars);
-        use_eq_strict = (env1.use_eq_strict);
-        is_iface = (env1.is_iface);
-        admit = (env1.admit);
-        lax = (env1.lax);
-        lax_universes = (env1.lax_universes);
-        phase1 = (env1.phase1);
-        failhard = (env1.failhard);
-        nosynth = (env1.nosynth);
-        uvar_subtyping = (env1.uvar_subtyping);
-        tc_term = (env1.tc_term);
-        typeof_tot_or_gtot_term = (env1.typeof_tot_or_gtot_term);
-        universe_of = (env1.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (env1.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (env1.teq_nosmt_force);
-        subtype_nosmt_force = (env1.subtype_nosmt_force);
-        qtbl_name_and_index = (env1.qtbl_name_and_index);
-        normalized_eff_names = (env1.normalized_eff_names);
-        fv_delta_depths = (env1.fv_delta_depths);
-        proof_ns = (env1.proof_ns);
-        synth_hook = (env1.synth_hook);
-        try_solve_implicits_hook = (env1.try_solve_implicits_hook);
-        splice = (env1.splice);
-        mpreprocess = (env1.mpreprocess);
-        postprocess = (env1.postprocess);
-        identifier_info = (env1.identifier_info);
-        tc_hooks = (env1.tc_hooks);
-        dsenv = (env1.dsenv);
-        nbe = (env1.nbe);
-        strict_args_tab = (env1.strict_args_tab);
-        erasable_types_tab = (env1.erasable_types_tab);
-        enable_defer_to_tac = (env1.enable_defer_to_tac);
-        unif_allow_ref_guards = (env1.unif_allow_ref_guards);
-        erase_erasable_args = (env1.erase_erasable_args);
-        core_check = (env1.core_check)
-      }
-let (uvars_in_env : env -> FStar_Syntax_Syntax.uvars) =
-  fun env1 ->
-    let no_uvs = FStar_Syntax_Free.new_uv_set () in
-    let ext out uvs = FStar_Compiler_Util.set_union out uvs in
-    let rec aux out g =
-      match g with
-      | [] -> out
-      | (FStar_Syntax_Syntax.Binding_univ uu___)::tl -> aux out tl
-      | (FStar_Syntax_Syntax.Binding_lid (uu___, (uu___1, t)))::tl ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Free.uvars t in ext out uu___3 in
-          aux uu___2 tl
-      | (FStar_Syntax_Syntax.Binding_var
-          { FStar_Syntax_Syntax.ppname = uu___;
-            FStar_Syntax_Syntax.index = uu___1;
-            FStar_Syntax_Syntax.sort = t;_})::tl
-          ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Free.uvars t in ext out uu___3 in
-          aux uu___2 tl in
-    aux no_uvs env1.gamma
-let (univ_vars :
-  env -> FStar_Syntax_Syntax.universe_uvar FStar_Compiler_Util.set) =
-  fun env1 ->
-    let no_univs = FStar_Syntax_Free.new_universe_uvar_set () in
-    let ext out uvs = FStar_Compiler_Util.set_union out uvs in
-    let rec aux out g =
-      match g with
-      | [] -> out
-      | (FStar_Syntax_Syntax.Binding_univ uu___)::tl -> aux out tl
-      | (FStar_Syntax_Syntax.Binding_lid (uu___, (uu___1, t)))::tl ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Free.univs t in ext out uu___3 in
-          aux uu___2 tl
-      | (FStar_Syntax_Syntax.Binding_var
-          { FStar_Syntax_Syntax.ppname = uu___;
-            FStar_Syntax_Syntax.index = uu___1;
-            FStar_Syntax_Syntax.sort = t;_})::tl
-          ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Free.univs t in ext out uu___3 in
-          aux uu___2 tl in
-    aux no_univs env1.gamma
-let (univnames :
-  env -> FStar_Syntax_Syntax.univ_name FStar_Compiler_Util.set) =
-  fun env1 ->
-    let no_univ_names = FStar_Syntax_Syntax.no_universe_names in
-    let ext out uvs = FStar_Compiler_Util.set_union out uvs in
-    let rec aux out g =
-      match g with
-      | [] -> out
-      | (FStar_Syntax_Syntax.Binding_univ uname)::tl ->
-          let uu___ = FStar_Compiler_Util.set_add uname out in aux uu___ tl
-      | (FStar_Syntax_Syntax.Binding_lid (uu___, (uu___1, t)))::tl ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Free.univnames t in ext out uu___3 in
-          aux uu___2 tl
-      | (FStar_Syntax_Syntax.Binding_var
-          { FStar_Syntax_Syntax.ppname = uu___;
-            FStar_Syntax_Syntax.index = uu___1;
-            FStar_Syntax_Syntax.sort = t;_})::tl
-          ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Free.univnames t in ext out uu___3 in
-          aux uu___2 tl in
-    aux no_univ_names env1.gamma
-let (print_gamma : FStar_Syntax_Syntax.gamma -> Prims.string) =
-  fun gamma ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater gamma
-        (FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with
-              | FStar_Syntax_Syntax.Binding_var x ->
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Print.bv_to_string x in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Syntax_Print.term_to_string
-                            x.FStar_Syntax_Syntax.sort in
-                        Prims.op_Hat uu___6 ")" in
-                      Prims.op_Hat ":" uu___5 in
-                    Prims.op_Hat uu___3 uu___4 in
-                  Prims.op_Hat "Binding_var (" uu___2
-              | FStar_Syntax_Syntax.Binding_univ u ->
-                  let uu___2 = FStar_Ident.string_of_id u in
-                  Prims.op_Hat "Binding_univ " uu___2
-              | FStar_Syntax_Syntax.Binding_lid (l, uu___2) ->
-                  let uu___3 = FStar_Ident.string_of_lid l in
-                  Prims.op_Hat "Binding_lid " uu___3)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "::\n")
-let (string_of_delta_level : delta_level -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | NoDelta -> "NoDelta"
-    | InliningDelta -> "Inlining"
-    | Eager_unfolding_only -> "Eager_unfolding_only"
-    | Unfold d ->
-        let uu___1 = FStar_Syntax_Print.delta_depth_to_string d in
-        Prims.op_Hat "Unfold " uu___1
-let (lidents : env -> FStar_Ident.lident Prims.list) =
-  fun env1 ->
-    let keys =
-      FStar_Compiler_List.collect FStar_Pervasives_Native.fst env1.gamma_sig in
-    FStar_Compiler_Util.smap_fold (sigtab env1)
-      (fun uu___ ->
-         fun v ->
-           fun keys1 ->
-             FStar_Compiler_List.op_At (FStar_Syntax_Util.lids_of_sigelt v)
-               keys1) keys
-let (should_enc_path : env -> Prims.string Prims.list -> Prims.bool) =
-  fun env1 ->
-    fun path ->
-      let rec str_i_prefix xs ys =
-        match (xs, ys) with
-        | ([], uu___) -> true
-        | (x::xs1, y::ys1) ->
-            ((FStar_String.lowercase x) = (FStar_String.lowercase y)) &&
-              (str_i_prefix xs1 ys1)
-        | (uu___, uu___1) -> false in
-      let uu___ =
-        FStar_Compiler_List.tryFind
-          (fun uu___1 ->
-             match uu___1 with | (p, uu___2) -> str_i_prefix p path)
-          env1.proof_ns in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> false
-      | FStar_Pervasives_Native.Some (uu___1, b) -> b
-let (should_enc_lid : env -> FStar_Ident.lident -> Prims.bool) =
-  fun env1 ->
-    fun lid ->
-      let uu___ = FStar_Ident.path_of_lid lid in should_enc_path env1 uu___
-let (cons_proof_ns : Prims.bool -> env -> name_prefix -> env) =
-  fun b ->
-    fun e ->
-      fun path ->
-        {
-          solver = (e.solver);
-          range = (e.range);
-          curmodule = (e.curmodule);
-          gamma = (e.gamma);
-          gamma_sig = (e.gamma_sig);
-          gamma_cache = (e.gamma_cache);
-          modules = (e.modules);
-          expected_typ = (e.expected_typ);
-          sigtab = (e.sigtab);
-          attrtab = (e.attrtab);
-          instantiate_imp = (e.instantiate_imp);
-          effects = (e.effects);
-          generalize = (e.generalize);
-          letrecs = (e.letrecs);
-          top_level = (e.top_level);
-          check_uvars = (e.check_uvars);
-          use_eq_strict = (e.use_eq_strict);
-          is_iface = (e.is_iface);
-          admit = (e.admit);
-          lax = (e.lax);
-          lax_universes = (e.lax_universes);
-          phase1 = (e.phase1);
-          failhard = (e.failhard);
-          nosynth = (e.nosynth);
-          uvar_subtyping = (e.uvar_subtyping);
-          tc_term = (e.tc_term);
-          typeof_tot_or_gtot_term = (e.typeof_tot_or_gtot_term);
-          universe_of = (e.universe_of);
-          typeof_well_typed_tot_or_gtot_term =
-            (e.typeof_well_typed_tot_or_gtot_term);
-          teq_nosmt_force = (e.teq_nosmt_force);
-          subtype_nosmt_force = (e.subtype_nosmt_force);
-          qtbl_name_and_index = (e.qtbl_name_and_index);
-          normalized_eff_names = (e.normalized_eff_names);
-          fv_delta_depths = (e.fv_delta_depths);
-          proof_ns = ((path, b) :: (e.proof_ns));
-          synth_hook = (e.synth_hook);
-          try_solve_implicits_hook = (e.try_solve_implicits_hook);
-          splice = (e.splice);
-          mpreprocess = (e.mpreprocess);
-          postprocess = (e.postprocess);
-          identifier_info = (e.identifier_info);
-          tc_hooks = (e.tc_hooks);
-          dsenv = (e.dsenv);
-          nbe = (e.nbe);
-          strict_args_tab = (e.strict_args_tab);
-          erasable_types_tab = (e.erasable_types_tab);
-          enable_defer_to_tac = (e.enable_defer_to_tac);
-          unif_allow_ref_guards = (e.unif_allow_ref_guards);
-          erase_erasable_args = (e.erase_erasable_args);
-          core_check = (e.core_check)
-        }
-let (add_proof_ns : env -> name_prefix -> env) =
-  fun e -> fun path -> cons_proof_ns true e path
-let (rem_proof_ns : env -> name_prefix -> env) =
-  fun e -> fun path -> cons_proof_ns false e path
-let (get_proof_ns : env -> proof_namespace) = fun e -> e.proof_ns
-let (set_proof_ns : proof_namespace -> env -> env) =
-  fun ns ->
-    fun e ->
-      {
-        solver = (e.solver);
-        range = (e.range);
-        curmodule = (e.curmodule);
-        gamma = (e.gamma);
-        gamma_sig = (e.gamma_sig);
-        gamma_cache = (e.gamma_cache);
-        modules = (e.modules);
-        expected_typ = (e.expected_typ);
-        sigtab = (e.sigtab);
-        attrtab = (e.attrtab);
-        instantiate_imp = (e.instantiate_imp);
-        effects = (e.effects);
-        generalize = (e.generalize);
-        letrecs = (e.letrecs);
-        top_level = (e.top_level);
-        check_uvars = (e.check_uvars);
-        use_eq_strict = (e.use_eq_strict);
-        is_iface = (e.is_iface);
-        admit = (e.admit);
-        lax = (e.lax);
-        lax_universes = (e.lax_universes);
-        phase1 = (e.phase1);
-        failhard = (e.failhard);
-        nosynth = (e.nosynth);
-        uvar_subtyping = (e.uvar_subtyping);
-        tc_term = (e.tc_term);
-        typeof_tot_or_gtot_term = (e.typeof_tot_or_gtot_term);
-        universe_of = (e.universe_of);
-        typeof_well_typed_tot_or_gtot_term =
-          (e.typeof_well_typed_tot_or_gtot_term);
-        teq_nosmt_force = (e.teq_nosmt_force);
-        subtype_nosmt_force = (e.subtype_nosmt_force);
-        qtbl_name_and_index = (e.qtbl_name_and_index);
-        normalized_eff_names = (e.normalized_eff_names);
-        fv_delta_depths = (e.fv_delta_depths);
-        proof_ns = ns;
-        synth_hook = (e.synth_hook);
-        try_solve_implicits_hook = (e.try_solve_implicits_hook);
-        splice = (e.splice);
-        mpreprocess = (e.mpreprocess);
-        postprocess = (e.postprocess);
-        identifier_info = (e.identifier_info);
-        tc_hooks = (e.tc_hooks);
-        dsenv = (e.dsenv);
-        nbe = (e.nbe);
-        strict_args_tab = (e.strict_args_tab);
-        erasable_types_tab = (e.erasable_types_tab);
-        enable_defer_to_tac = (e.enable_defer_to_tac);
-        unif_allow_ref_guards = (e.unif_allow_ref_guards);
-        erase_erasable_args = (e.erase_erasable_args);
-        core_check = (e.core_check)
-      }
-let (unbound_vars :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.bv FStar_Compiler_Util.set)
-  =
-  fun e ->
-    fun t ->
-      let uu___ = FStar_Syntax_Free.names t in
-      let uu___1 = bound_vars e in
-      FStar_Compiler_List.fold_left
-        (fun s -> fun bv -> FStar_Compiler_Util.set_remove bv s) uu___ uu___1
-let (closed : env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun e ->
-    fun t ->
-      let uu___ = unbound_vars e t in FStar_Compiler_Util.set_is_empty uu___
-let (closed' : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = FStar_Syntax_Free.names t in
-    FStar_Compiler_Util.set_is_empty uu___
-let (string_of_proof_ns : env -> Prims.string) =
-  fun env1 ->
-    let aux uu___ =
-      match uu___ with
-      | (p, b) ->
-          if (p = []) && b
-          then "*"
-          else
-            (let uu___2 = FStar_Ident.text_of_path p in
-             Prims.op_Hat (if b then "+" else "-") uu___2) in
-    let uu___ =
-      let uu___1 = FStar_Compiler_List.map aux env1.proof_ns in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1 FStar_Compiler_List.rev in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat " ")
-let (guard_of_guard_formula :
-  FStar_TypeChecker_Common.guard_formula -> guard_t) =
-  fun g ->
-    {
-      FStar_TypeChecker_Common.guard_f = g;
-      FStar_TypeChecker_Common.deferred_to_tac = [];
-      FStar_TypeChecker_Common.deferred = [];
-      FStar_TypeChecker_Common.univ_ineqs = ([], []);
-      FStar_TypeChecker_Common.implicits = []
-    }
-let (guard_form : guard_t -> FStar_TypeChecker_Common.guard_formula) =
-  fun g -> g.FStar_TypeChecker_Common.guard_f
-let (is_trivial : guard_t -> Prims.bool) =
-  fun g ->
-    match g with
-    | { FStar_TypeChecker_Common.guard_f = FStar_TypeChecker_Common.Trivial;
-        FStar_TypeChecker_Common.deferred_to_tac = uu___;
-        FStar_TypeChecker_Common.deferred = [];
-        FStar_TypeChecker_Common.univ_ineqs = ([], []);
-        FStar_TypeChecker_Common.implicits = i;_} ->
-        FStar_Compiler_Effect.op_Bar_Greater i
-          (FStar_Compiler_Util.for_all
-             (fun imp ->
-                (let uu___1 =
-                   FStar_Syntax_Util.ctx_uvar_should_check
-                     imp.FStar_TypeChecker_Common.imp_uvar in
-                 FStar_Syntax_Syntax.uu___is_Allow_unresolved uu___1) ||
-                  (let uu___1 =
-                     FStar_Syntax_Unionfind.find
-                       (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-                   match uu___1 with
-                   | FStar_Pervasives_Native.Some uu___2 -> true
-                   | FStar_Pervasives_Native.None -> false)))
-    | uu___ -> false
-let (is_trivial_guard_formula : guard_t -> Prims.bool) =
-  fun g ->
-    match g with
-    | { FStar_TypeChecker_Common.guard_f = FStar_TypeChecker_Common.Trivial;
-        FStar_TypeChecker_Common.deferred_to_tac = uu___;
-        FStar_TypeChecker_Common.deferred = uu___1;
-        FStar_TypeChecker_Common.univ_ineqs = uu___2;
-        FStar_TypeChecker_Common.implicits = uu___3;_} -> true
-    | uu___ -> false
-let (trivial_guard : guard_t) = FStar_TypeChecker_Common.trivial_guard
-let (abstract_guard_n :
-  FStar_Syntax_Syntax.binder Prims.list -> guard_t -> guard_t) =
-  fun bs ->
-    fun g ->
-      match g.FStar_TypeChecker_Common.guard_f with
-      | FStar_TypeChecker_Common.Trivial -> g
-      | FStar_TypeChecker_Common.NonTrivial f ->
-          let f' =
-            FStar_Syntax_Util.abs bs f
-              (FStar_Pervasives_Native.Some
-                 (FStar_Syntax_Util.residual_tot FStar_Syntax_Util.ktype0)) in
-          {
-            FStar_TypeChecker_Common.guard_f =
-              (FStar_TypeChecker_Common.NonTrivial f');
-            FStar_TypeChecker_Common.deferred_to_tac =
-              (g.FStar_TypeChecker_Common.deferred_to_tac);
-            FStar_TypeChecker_Common.deferred =
-              (g.FStar_TypeChecker_Common.deferred);
-            FStar_TypeChecker_Common.univ_ineqs =
-              (g.FStar_TypeChecker_Common.univ_ineqs);
-            FStar_TypeChecker_Common.implicits =
-              (g.FStar_TypeChecker_Common.implicits)
-          }
-let (abstract_guard : FStar_Syntax_Syntax.binder -> guard_t -> guard_t) =
-  fun b -> fun g -> abstract_guard_n [b] g
-let (too_early_in_prims : env -> Prims.bool) =
-  fun env1 ->
-    let uu___ = lid_exists env1 FStar_Parser_Const.effect_GTot_lid in
-    Prims.op_Negation uu___
-let (apply_guard : guard_t -> FStar_Syntax_Syntax.term -> guard_t) =
-  fun g ->
-    fun e ->
-      match g.FStar_TypeChecker_Common.guard_f with
-      | FStar_TypeChecker_Common.Trivial -> g
-      | FStar_TypeChecker_Common.NonTrivial f ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = FStar_Syntax_Syntax.as_arg e in [uu___5] in
-                  (f, uu___4) in
-                FStar_Syntax_Syntax.Tm_app uu___3 in
-              FStar_Syntax_Syntax.mk uu___2 f.FStar_Syntax_Syntax.pos in
-            FStar_Compiler_Effect.op_Less_Bar
-              (fun uu___2 -> FStar_TypeChecker_Common.NonTrivial uu___2)
-              uu___1 in
-          {
-            FStar_TypeChecker_Common.guard_f = uu___;
-            FStar_TypeChecker_Common.deferred_to_tac =
-              (g.FStar_TypeChecker_Common.deferred_to_tac);
-            FStar_TypeChecker_Common.deferred =
-              (g.FStar_TypeChecker_Common.deferred);
-            FStar_TypeChecker_Common.univ_ineqs =
-              (g.FStar_TypeChecker_Common.univ_ineqs);
-            FStar_TypeChecker_Common.implicits =
-              (g.FStar_TypeChecker_Common.implicits)
-          }
-let (map_guard :
-  guard_t ->
-    (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) -> guard_t)
-  =
-  fun g ->
-    fun map ->
-      match g.FStar_TypeChecker_Common.guard_f with
-      | FStar_TypeChecker_Common.Trivial -> g
-      | FStar_TypeChecker_Common.NonTrivial f ->
-          let uu___ =
-            let uu___1 = map f in FStar_TypeChecker_Common.NonTrivial uu___1 in
-          {
-            FStar_TypeChecker_Common.guard_f = uu___;
-            FStar_TypeChecker_Common.deferred_to_tac =
-              (g.FStar_TypeChecker_Common.deferred_to_tac);
-            FStar_TypeChecker_Common.deferred =
-              (g.FStar_TypeChecker_Common.deferred);
-            FStar_TypeChecker_Common.univ_ineqs =
-              (g.FStar_TypeChecker_Common.univ_ineqs);
-            FStar_TypeChecker_Common.implicits =
-              (g.FStar_TypeChecker_Common.implicits)
-          }
-let (always_map_guard :
-  guard_t ->
-    (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) -> guard_t)
-  =
-  fun g ->
-    fun map ->
-      match g.FStar_TypeChecker_Common.guard_f with
-      | FStar_TypeChecker_Common.Trivial ->
-          let uu___ =
-            let uu___1 = map FStar_Syntax_Util.t_true in
-            FStar_TypeChecker_Common.NonTrivial uu___1 in
-          {
-            FStar_TypeChecker_Common.guard_f = uu___;
-            FStar_TypeChecker_Common.deferred_to_tac =
-              (g.FStar_TypeChecker_Common.deferred_to_tac);
-            FStar_TypeChecker_Common.deferred =
-              (g.FStar_TypeChecker_Common.deferred);
-            FStar_TypeChecker_Common.univ_ineqs =
-              (g.FStar_TypeChecker_Common.univ_ineqs);
-            FStar_TypeChecker_Common.implicits =
-              (g.FStar_TypeChecker_Common.implicits)
-          }
-      | FStar_TypeChecker_Common.NonTrivial f ->
-          let uu___ =
-            let uu___1 = map f in FStar_TypeChecker_Common.NonTrivial uu___1 in
-          {
-            FStar_TypeChecker_Common.guard_f = uu___;
-            FStar_TypeChecker_Common.deferred_to_tac =
-              (g.FStar_TypeChecker_Common.deferred_to_tac);
-            FStar_TypeChecker_Common.deferred =
-              (g.FStar_TypeChecker_Common.deferred);
-            FStar_TypeChecker_Common.univ_ineqs =
-              (g.FStar_TypeChecker_Common.univ_ineqs);
-            FStar_TypeChecker_Common.implicits =
-              (g.FStar_TypeChecker_Common.implicits)
-          }
-let (trivial : FStar_TypeChecker_Common.guard_formula -> unit) =
-  fun t ->
-    match t with
-    | FStar_TypeChecker_Common.Trivial -> ()
-    | FStar_TypeChecker_Common.NonTrivial uu___ -> failwith "impossible"
-let (check_trivial :
-  FStar_Syntax_Syntax.term -> FStar_TypeChecker_Common.guard_formula) =
-  fun t -> FStar_TypeChecker_Common.check_trivial t
-let (conj_guard : guard_t -> guard_t -> guard_t) =
-  fun g1 -> fun g2 -> FStar_TypeChecker_Common.conj_guard g1 g2
-let (conj_guards : guard_t Prims.list -> guard_t) =
-  fun gs -> FStar_TypeChecker_Common.conj_guards gs
-let (imp_guard : guard_t -> guard_t -> guard_t) =
-  fun g1 -> fun g2 -> FStar_TypeChecker_Common.imp_guard g1 g2
-let (close_guard_univs :
-  FStar_Syntax_Syntax.universes ->
-    FStar_Syntax_Syntax.binders -> guard_t -> guard_t)
-  =
-  fun us ->
-    fun bs ->
-      fun g ->
-        match g.FStar_TypeChecker_Common.guard_f with
-        | FStar_TypeChecker_Common.Trivial -> g
-        | FStar_TypeChecker_Common.NonTrivial f ->
-            let f1 =
-              FStar_Compiler_List.fold_right2
-                (fun u ->
-                   fun b ->
-                     fun f2 ->
-                       let uu___ = FStar_Syntax_Syntax.is_null_binder b in
-                       if uu___
-                       then f2
-                       else
-                         FStar_Syntax_Util.mk_forall u
-                           b.FStar_Syntax_Syntax.binder_bv f2) us bs f in
-            {
-              FStar_TypeChecker_Common.guard_f =
-                (FStar_TypeChecker_Common.NonTrivial f1);
-              FStar_TypeChecker_Common.deferred_to_tac =
-                (g.FStar_TypeChecker_Common.deferred_to_tac);
-              FStar_TypeChecker_Common.deferred =
-                (g.FStar_TypeChecker_Common.deferred);
-              FStar_TypeChecker_Common.univ_ineqs =
-                (g.FStar_TypeChecker_Common.univ_ineqs);
-              FStar_TypeChecker_Common.implicits =
-                (g.FStar_TypeChecker_Common.implicits)
-            }
-let (close_forall :
-  env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun bs ->
-      fun f ->
-        FStar_Errors.with_ctx "While closing a formula"
-          (fun uu___ ->
-             (let uu___2 =
-                let uu___3 = FStar_Syntax_Syntax.mk_Total f in
-                FStar_Syntax_Util.arrow bs uu___3 in
-              def_check_closed_in_env f.FStar_Syntax_Syntax.pos
-                "close_forall" env1 uu___2);
-             (let bvs =
-                FStar_Compiler_List.map
-                  (fun b -> b.FStar_Syntax_Syntax.binder_bv) bs in
-              let env_full = push_bvs env1 bvs in
-              let uu___2 =
-                FStar_Compiler_List.fold_right
-                  (fun bv ->
-                     fun uu___3 ->
-                       match uu___3 with
-                       | (f1, e) ->
-                           let e' =
-                             let uu___4 =
-                               let uu___5 = pop_bv e in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                 FStar_Compiler_Util.must in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___4
-                               FStar_Pervasives_Native.snd in
-                           (def_check_closed_in_env
-                              FStar_Compiler_Range.dummyRange
-                              "close_forall.sort" e'
-                              bv.FStar_Syntax_Syntax.sort;
-                            (let f' =
-                               let uu___5 = FStar_Syntax_Syntax.is_null_bv bv in
-                               if uu___5
-                               then f1
-                               else
-                                 (let u =
-                                    e'.universe_of e'
-                                      bv.FStar_Syntax_Syntax.sort in
-                                  FStar_Syntax_Util.mk_forall u bv f1) in
-                             (f', e')))) bvs (f, env_full) in
-              match uu___2 with | (f', e) -> f'))
-let (close_guard : env -> FStar_Syntax_Syntax.binders -> guard_t -> guard_t)
-  =
-  fun env1 ->
-    fun binders ->
-      fun g ->
-        match g.FStar_TypeChecker_Common.guard_f with
-        | FStar_TypeChecker_Common.Trivial -> g
-        | FStar_TypeChecker_Common.NonTrivial f ->
-            let uu___ =
-              let uu___1 = close_forall env1 binders f in
-              FStar_TypeChecker_Common.NonTrivial uu___1 in
-            {
-              FStar_TypeChecker_Common.guard_f = uu___;
-              FStar_TypeChecker_Common.deferred_to_tac =
-                (g.FStar_TypeChecker_Common.deferred_to_tac);
-              FStar_TypeChecker_Common.deferred =
-                (g.FStar_TypeChecker_Common.deferred);
-              FStar_TypeChecker_Common.univ_ineqs =
-                (g.FStar_TypeChecker_Common.univ_ineqs);
-              FStar_TypeChecker_Common.implicits =
-                (g.FStar_TypeChecker_Common.implicits)
-            }
-let (new_tac_implicit_var :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      env ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.should_check_uvar ->
-            FStar_Syntax_Syntax.ctx_uvar Prims.list ->
-              FStar_Syntax_Syntax.ctx_uvar_meta_t
-                FStar_Pervasives_Native.option ->
-                (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.ctx_uvar *
-                  FStar_Compiler_Range.range) Prims.list * guard_t))
-  =
-  fun reason ->
-    fun r ->
-      fun env1 ->
-        fun k ->
-          fun should_check ->
-            fun uvar_typedness_deps ->
-              fun meta ->
-                let uu___ =
-                  FStar_Syntax_Util.destruct k
-                    FStar_Parser_Const.range_of_lid in
-                match uu___ with
-                | FStar_Pervasives_Native.Some (uu___1::(tm, uu___2)::[]) ->
-                    let t =
-                      FStar_Syntax_Syntax.mk
-                        (FStar_Syntax_Syntax.Tm_constant
-                           (FStar_Const.Const_range
-                              (tm.FStar_Syntax_Syntax.pos)))
-                        tm.FStar_Syntax_Syntax.pos in
-                    (t, [], trivial_guard)
-                | uu___1 ->
-                    let binders = all_binders env1 in
-                    let gamma = env1.gamma in
-                    let decoration =
-                      {
-                        FStar_Syntax_Syntax.uvar_decoration_typ = k;
-                        FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on
-                          = uvar_typedness_deps;
-                        FStar_Syntax_Syntax.uvar_decoration_should_check =
-                          should_check
-                      } in
-                    let ctx_uvar =
-                      let uu___2 = FStar_Syntax_Unionfind.fresh decoration r in
-                      {
-                        FStar_Syntax_Syntax.ctx_uvar_head = uu___2;
-                        FStar_Syntax_Syntax.ctx_uvar_gamma = gamma;
-                        FStar_Syntax_Syntax.ctx_uvar_binders = binders;
-                        FStar_Syntax_Syntax.ctx_uvar_reason = reason;
-                        FStar_Syntax_Syntax.ctx_uvar_range = r;
-                        FStar_Syntax_Syntax.ctx_uvar_meta = meta
-                      } in
-                    (FStar_TypeChecker_Common.check_uvar_ctx_invariant reason
-                       r true gamma binders;
-                     (let t =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_uvar
-                             (ctx_uvar, ([], FStar_Syntax_Syntax.NoUseRange)))
-                          r in
-                      let imp =
-                        {
-                          FStar_TypeChecker_Common.imp_reason = reason;
-                          FStar_TypeChecker_Common.imp_uvar = ctx_uvar;
-                          FStar_TypeChecker_Common.imp_tm = t;
-                          FStar_TypeChecker_Common.imp_range = r
-                        } in
-                      (let uu___4 =
-                         debug env1 (FStar_Options.Other "ImplicitTrace") in
-                       if uu___4
-                       then
-                         let uu___5 =
-                           FStar_Syntax_Print.uvar_to_string
-                             ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_head in
-                         FStar_Compiler_Util.print1
-                           "Just created uvar for implicit {%s}\n" uu___5
-                       else ());
-                      (let g =
-                         {
-                           FStar_TypeChecker_Common.guard_f =
-                             (trivial_guard.FStar_TypeChecker_Common.guard_f);
-                           FStar_TypeChecker_Common.deferred_to_tac =
-                             (trivial_guard.FStar_TypeChecker_Common.deferred_to_tac);
-                           FStar_TypeChecker_Common.deferred =
-                             (trivial_guard.FStar_TypeChecker_Common.deferred);
-                           FStar_TypeChecker_Common.univ_ineqs =
-                             (trivial_guard.FStar_TypeChecker_Common.univ_ineqs);
-                           FStar_TypeChecker_Common.implicits = [imp]
-                         } in
-                       (t, [(ctx_uvar, r)], g))))
-let (new_implicit_var_aux :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      env ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.should_check_uvar ->
-            FStar_Syntax_Syntax.ctx_uvar_meta_t
-              FStar_Pervasives_Native.option ->
-              (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.ctx_uvar *
-                FStar_Compiler_Range.range) Prims.list * guard_t))
-  =
-  fun reason ->
-    fun r ->
-      fun env1 ->
-        fun k ->
-          fun should_check ->
-            fun meta ->
-              new_tac_implicit_var reason r env1 k should_check [] meta
-let (uvars_for_binders :
-  env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.subst_t ->
-        (FStar_Syntax_Syntax.binder -> Prims.string) ->
-          FStar_Compiler_Range.range ->
-            (FStar_Syntax_Syntax.term Prims.list * guard_t))
-  =
-  fun env1 ->
-    fun bs ->
-      fun substs ->
-        fun reason ->
-          fun r ->
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater bs
-                (FStar_Compiler_List.fold_left
-                   (fun uu___1 ->
-                      fun b ->
-                        match uu___1 with
-                        | (substs1, uvars, g) ->
-                            let sort =
-                              FStar_Syntax_Subst.subst substs1
-                                (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                            let ctx_uvar_meta_t =
-                              match ((b.FStar_Syntax_Syntax.binder_qual),
-                                      (b.FStar_Syntax_Syntax.binder_attrs))
-                              with
-                              | (FStar_Pervasives_Native.Some
-                                 (FStar_Syntax_Syntax.Meta t), []) ->
-                                  let uu___2 =
-                                    let uu___3 =
-                                      let uu___4 =
-                                        FStar_Compiler_Dyn.mkdyn env1 in
-                                      (uu___4, t) in
-                                    FStar_Syntax_Syntax.Ctx_uvar_meta_tac
-                                      uu___3 in
-                                  FStar_Pervasives_Native.Some uu___2
-                              | (uu___2, t::uu___3) ->
-                                  FStar_Pervasives_Native.Some
-                                    (FStar_Syntax_Syntax.Ctx_uvar_meta_attr t)
-                              | uu___2 -> FStar_Pervasives_Native.None in
-                            let uu___2 =
-                              let uu___3 = reason b in
-                              let uu___4 =
-                                let uu___5 =
-                                  FStar_Options.compat_pre_typed_indexed_effects
-                                    () in
-                                if uu___5
-                                then
-                                  FStar_Syntax_Syntax.Allow_untyped
-                                    "indexed effect uvar in compat mode"
-                                else FStar_Syntax_Syntax.Strict in
-                              new_implicit_var_aux uu___3 r env1 sort uu___4
-                                ctx_uvar_meta_t in
-                            (match uu___2 with
-                             | (t, l_ctx_uvars, g_t) ->
-                                 ((let uu___4 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (debug env1)
-                                       (FStar_Options.Other
-                                          "LayeredEffectsEqns") in
-                                   if uu___4
-                                   then
-                                     FStar_Compiler_List.iter
-                                       (fun uu___5 ->
-                                          match uu___5 with
-                                          | (ctx_uvar, uu___6) ->
-                                              let uu___7 =
-                                                FStar_Syntax_Print.ctx_uvar_to_string
-                                                  ctx_uvar in
-                                              FStar_Compiler_Util.print1
-                                                "Layered Effect uvar : %s\n"
-                                                uu___7) l_ctx_uvars
-                                   else ());
-                                  (let uu___4 = conj_guards [g; g_t] in
-                                   ((FStar_Compiler_List.op_At substs1
-                                       [FStar_Syntax_Syntax.NT
-                                          ((b.FStar_Syntax_Syntax.binder_bv),
-                                            t)]),
-                                     (FStar_Compiler_List.op_At uvars [t]),
-                                     uu___4))))) (substs, [], trivial_guard)) in
-            FStar_Compiler_Effect.op_Bar_Greater uu___
-              (fun uu___1 ->
-                 match uu___1 with | (uu___2, uvars, g) -> (uvars, g))
-let (pure_precondition_for_trivial_post :
-  env ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Compiler_Range.range -> FStar_Syntax_Syntax.typ)
-  =
-  fun env1 ->
-    fun u ->
-      fun t ->
-        fun wp ->
-          fun r ->
-            let trivial_post =
-              let post_ts =
-                let uu___ =
-                  lookup_definition [NoDelta] env1
-                    FStar_Parser_Const.trivial_pure_post_lid in
-                FStar_Compiler_Effect.op_Bar_Greater uu___
-                  FStar_Compiler_Util.must in
-              let uu___ = inst_tscheme_with post_ts [u] in
-              match uu___ with
-              | (uu___1, post) ->
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Compiler_Effect.op_Bar_Greater t
-                        FStar_Syntax_Syntax.as_arg in
-                    [uu___3] in
-                  FStar_Syntax_Syntax.mk_Tm_app post uu___2 r in
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_Effect.op_Bar_Greater trivial_post
-                  FStar_Syntax_Syntax.as_arg in
-              [uu___1] in
-            FStar_Syntax_Syntax.mk_Tm_app wp uu___ r
-let (dummy_solver : solver_t) =
-  {
-    init = (fun uu___ -> ());
-    push = (fun uu___ -> ());
-    pop = (fun uu___ -> ());
-    snapshot =
-      (fun uu___ -> ((Prims.int_zero, Prims.int_zero, Prims.int_zero), ()));
-    rollback = (fun uu___ -> fun uu___1 -> ());
-    encode_sig = (fun uu___ -> fun uu___1 -> ());
-    preprocess =
-      (fun e ->
-         fun g ->
-           let uu___ = let uu___1 = FStar_Options.peek () in (e, g, uu___1) in
-           [uu___]);
-    spinoff_strictly_positive_goals = FStar_Pervasives_Native.None;
-    handle_smt_goal = (fun e -> fun g -> [(e, g)]);
-    solve = (fun uu___ -> fun uu___1 -> fun uu___2 -> ());
-    finish = (fun uu___ -> ());
-    refresh = (fun uu___ -> ())
-  }
-let (get_letrec_arity :
-  env ->
-    FStar_Syntax_Syntax.lbname -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun lbname ->
-      let compare_either f1 f2 e1 e2 =
-        match (e1, e2) with
-        | (FStar_Pervasives.Inl v1, FStar_Pervasives.Inl v2) -> f1 v1 v2
-        | (FStar_Pervasives.Inr v1, FStar_Pervasives.Inr v2) -> f2 v1 v2
-        | uu___ -> false in
-      let uu___ =
-        FStar_Compiler_Util.find_opt
-          (fun uu___1 ->
-             match uu___1 with
-             | (lbname', uu___2, uu___3, uu___4) ->
-                 compare_either FStar_Syntax_Syntax.bv_eq
-                   FStar_Syntax_Syntax.fv_eq lbname lbname') env1.letrecs in
-      match uu___ with
-      | FStar_Pervasives_Native.Some (uu___1, arity, uu___2, uu___3) ->
-          FStar_Pervasives_Native.Some arity
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (fvar_of_nonqual_lid :
-  env -> FStar_Ident.lident -> FStar_Syntax_Syntax.term) =
-  fun env1 ->
-    fun lid ->
-      let qn = lookup_qname env1 lid in
-      let dd =
-        let uu___ = delta_depth_of_qninfo_lid lid qn in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            failwith "Unexpected no delta_depth"
-        | FStar_Pervasives_Native.Some dd1 -> dd1 in
-      FStar_Syntax_Syntax.fvar lid dd FStar_Pervasives_Native.None
-let (split_smt_query :
-  env ->
-    FStar_Syntax_Syntax.term ->
-      (env * FStar_Syntax_Syntax.term) Prims.list
-        FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    fun q ->
-      match (e.solver).spinoff_strictly_positive_goals with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some p ->
-          let uu___ = p e q in FStar_Pervasives_Native.Some uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Err.ml b/src/ocaml-output/FStar_TypeChecker_Err.ml
deleted file mode 100644
index 6398c097893..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Err.ml
+++ /dev/null
@@ -1,603 +0,0 @@
-open Prims
-let (info_at_pos :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      Prims.int ->
-        Prims.int ->
-          ((Prims.string, FStar_Ident.lid) FStar_Pervasives.either *
-            FStar_Syntax_Syntax.typ * FStar_Compiler_Range.range)
-            FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun file ->
-      fun row ->
-        fun col ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bang
-                env.FStar_TypeChecker_Env.identifier_info in
-            FStar_TypeChecker_Common.id_info_at_pos uu___1 file row col in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-          | FStar_Pervasives_Native.Some info ->
-              (match info.FStar_TypeChecker_Common.identifier with
-               | FStar_Pervasives.Inl bv ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Print.nm_to_string bv in
-                       FStar_Pervasives.Inl uu___3 in
-                     let uu___3 = FStar_Syntax_Syntax.range_of_bv bv in
-                     (uu___2, (info.FStar_TypeChecker_Common.identifier_ty),
-                       uu___3) in
-                   FStar_Pervasives_Native.Some uu___1
-               | FStar_Pervasives.Inr fv ->
-                   let uu___1 =
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Syntax.lid_of_fv fv in
-                       FStar_Pervasives.Inr uu___3 in
-                     let uu___3 = FStar_Syntax_Syntax.range_of_fv fv in
-                     (uu___2, (info.FStar_TypeChecker_Common.identifier_ty),
-                       uu___3) in
-                   FStar_Pervasives_Native.Some uu___1)
-let print_discrepancy :
-  'a . ('a -> Prims.string) -> 'a -> 'a -> (Prims.string * Prims.string) =
-  fun f ->
-    fun x ->
-      fun y ->
-        let print uu___ =
-          let xs = f x in let ys = f y in (xs, ys, (xs <> ys)) in
-        let rec blist_leq l1 l2 =
-          match (l1, l2) with
-          | (h1::t1, h2::t2) ->
-              ((Prims.op_Negation h1) || h2) && (blist_leq t1 t2)
-          | ([], []) -> true
-          | uu___ -> failwith "print_discrepancy: bad lists" in
-        let rec succ l =
-          match l with
-          | (false)::t -> true :: t
-          | (true)::t -> let uu___ = succ t in false :: uu___
-          | [] -> failwith "" in
-        let full l = FStar_Compiler_List.for_all (fun b -> b) l in
-        let get_bool_option s =
-          let uu___ = FStar_Options.get_option s in
-          match uu___ with
-          | FStar_Options.Bool b -> b
-          | uu___1 -> failwith "print_discrepancy: impossible" in
-        let set_bool_option s b =
-          FStar_Options.set_option s (FStar_Options.Bool b) in
-        let get uu___ =
-          let pi = get_bool_option "print_implicits" in
-          let pu = get_bool_option "print_universes" in
-          let pea = get_bool_option "print_effect_args" in
-          let pf = get_bool_option "print_full_names" in [pi; pu; pea; pf] in
-        let set l =
-          match l with
-          | pi::pu::pea::pf::[] ->
-              (set_bool_option "print_implicits" pi;
-               set_bool_option "print_universes" pu;
-               set_bool_option "print_effect_args" pea;
-               set_bool_option "print_full_names " pf)
-          | uu___ -> failwith "impossible: print_discrepancy" in
-        let bas = get () in
-        let rec go cur =
-          match () with
-          | () when full cur ->
-              let uu___ = print () in
-              (match uu___ with | (xs, ys, uu___1) -> (xs, ys))
-          | () when let uu___ = blist_leq bas cur in Prims.op_Negation uu___
-              -> let uu___ = succ cur in go uu___
-          | () ->
-              (set cur;
-               (let uu___1 = print () in
-                match uu___1 with
-                | (xs, ys, true) -> (xs, ys)
-                | uu___2 -> let uu___3 = succ cur in go uu___3)) in
-        FStar_Options.with_saved_options (fun uu___ -> go bas)
-let (errors_smt_detail :
-  FStar_TypeChecker_Env.env ->
-    FStar_Errors.error Prims.list ->
-      (Prims.string, Prims.string) FStar_Pervasives.either ->
-        FStar_Errors.error Prims.list)
-  =
-  fun env ->
-    fun errs ->
-      fun smt_detail ->
-        let maybe_add_smt_detail msg =
-          match smt_detail with
-          | FStar_Pervasives.Inr d ->
-              Prims.op_Hat msg (Prims.op_Hat "\n\t" d)
-          | FStar_Pervasives.Inl d when
-              (FStar_Compiler_Util.trim_string d) <> "" ->
-              Prims.op_Hat msg (Prims.op_Hat "; " d)
-          | uu___ -> msg in
-        let errs1 =
-          FStar_Compiler_Effect.op_Bar_Greater errs
-            (FStar_Compiler_List.map
-               (fun uu___ ->
-                  match uu___ with
-                  | (e, msg, r, ctx) ->
-                      let uu___1 =
-                        if r = FStar_Compiler_Range.dummyRange
-                        then
-                          let uu___2 = FStar_TypeChecker_Env.get_range env in
-                          (e, msg, uu___2, ctx)
-                        else
-                          (let r' =
-                             let uu___3 = FStar_Compiler_Range.use_range r in
-                             FStar_Compiler_Range.set_def_range r uu___3 in
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Compiler_Range.file_of_range r' in
-                             let uu___5 =
-                               let uu___6 =
-                                 FStar_TypeChecker_Env.get_range env in
-                               FStar_Compiler_Range.file_of_range uu___6 in
-                             uu___4 <> uu___5 in
-                           if uu___3
-                           then
-                             let uu___4 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Compiler_Range.string_of_use_range
-                                       r in
-                                   let uu___8 =
-                                     let uu___9 =
-                                       let uu___10 =
-                                         let uu___11 =
-                                           FStar_Compiler_Range.use_range r in
-                                         let uu___12 =
-                                           FStar_Compiler_Range.def_range r in
-                                         uu___11 <> uu___12 in
-                                       if uu___10
-                                       then
-                                         let uu___11 =
-                                           let uu___12 =
-                                             FStar_Compiler_Range.string_of_def_range
-                                               r in
-                                           Prims.op_Hat uu___12 ")" in
-                                         Prims.op_Hat
-                                           "(Other related locations: "
-                                           uu___11
-                                       else "" in
-                                     Prims.op_Hat ")" uu___9 in
-                                   Prims.op_Hat uu___7 uu___8 in
-                                 Prims.op_Hat " (Also see: " uu___6 in
-                               Prims.op_Hat msg uu___5 in
-                             let uu___5 = FStar_TypeChecker_Env.get_range env in
-                             (e, uu___4, uu___5, ctx)
-                           else (e, msg, r, ctx)) in
-                      (match uu___1 with
-                       | (e1, msg1, r1, ctx1) ->
-                           (e1, (maybe_add_smt_detail msg1), r1, ctx1)))) in
-        errs1
-let (add_errors_smt_detail :
-  FStar_TypeChecker_Env.env ->
-    FStar_Errors.error Prims.list ->
-      (Prims.string, Prims.string) FStar_Pervasives.either -> unit)
-  =
-  fun env ->
-    fun errs ->
-      fun smt_detail ->
-        let uu___ = errors_smt_detail env errs smt_detail in
-        FStar_Errors.add_errors uu___
-let (add_errors :
-  FStar_TypeChecker_Env.env -> FStar_Errors.error Prims.list -> unit) =
-  fun env ->
-    fun errs -> add_errors_smt_detail env errs (FStar_Pervasives.Inl "")
-let (log_issue :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      (FStar_Errors.raw_error * Prims.string) -> unit)
-  =
-  fun env ->
-    fun r ->
-      fun uu___ ->
-        match uu___ with
-        | (e, m) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Errors.get_ctx () in (e, m, r, uu___3) in
-              [uu___2] in
-            add_errors env uu___1
-let (err_msg_type_strings :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> (Prims.string * Prims.string))
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        print_discrepancy (FStar_TypeChecker_Normalize.term_to_string env) t1
-          t2
-let (err_msg_comp_strings :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.comp -> (Prims.string * Prims.string))
-  =
-  fun env ->
-    fun c1 ->
-      fun c2 ->
-        print_discrepancy (FStar_TypeChecker_Normalize.comp_to_string env) c1
-          c2
-let (exhaustiveness_check : Prims.string) = "Patterns are incomplete"
-let (subtyping_failed :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ -> unit -> Prims.string)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        fun uu___ ->
-          let uu___1 = err_msg_type_strings env t1 t2 in
-          match uu___1 with
-          | (s1, s2) ->
-              FStar_Compiler_Util.format2
-                "Subtyping check failed; expected type %s; got type %s" s2 s1
-let (ill_kinded_type : Prims.string) = "Ill-kinded type"
-let (totality_check : Prims.string) = "This term may not terminate"
-let (unexpected_signature_for_monad :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun m ->
-      fun k ->
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid m in
-          let uu___2 = FStar_TypeChecker_Normalize.term_to_string env k in
-          FStar_Compiler_Util.format2
-            "Unexpected signature for monad \"%s\". Expected a signature of the form (a:Type -> WP a -> Effect); got %s"
-            uu___1 uu___2 in
-        (FStar_Errors.Fatal_UnexpectedSignatureForMonad, uu___)
-let (expected_a_term_of_type_t_got_a_function :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun msg ->
-      fun t ->
-        fun e ->
-          let uu___ =
-            let uu___1 = FStar_TypeChecker_Normalize.term_to_string env t in
-            let uu___2 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format3
-              "Expected a term of type \"%s\"; got a function \"%s\" (%s)"
-              uu___1 uu___2 msg in
-          (FStar_Errors.Fatal_ExpectTermGotFunction, uu___)
-let (unexpected_implicit_argument : (FStar_Errors.raw_error * Prims.string))
-  =
-  (FStar_Errors.Fatal_UnexpectedImplicitArgument,
-    "Unexpected instantiation of an implicit argument to a function that only expects explicit arguments")
-let (expected_expression_of_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun t1 ->
-      fun e ->
-        fun t2 ->
-          let uu___ = err_msg_type_strings env t1 t2 in
-          match uu___ with
-          | (s1, s2) ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string e in
-                FStar_Compiler_Util.format3
-                  "Expected expression of type \"%s\"; got expression \"%s\" of type \"%s\""
-                  s1 uu___2 s2 in
-              (FStar_Errors.Fatal_UnexpectedExpressionType, uu___1)
-let (expected_pattern_of_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun t1 ->
-      fun e ->
-        fun t2 ->
-          let uu___ = err_msg_type_strings env t1 t2 in
-          match uu___ with
-          | (s1, s2) ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string e in
-                FStar_Compiler_Util.format3
-                  "Expected pattern of type \"%s\"; got pattern \"%s\" of type \"%s\""
-                  s1 uu___2 s2 in
-              (FStar_Errors.Fatal_UnexpectedPattern, uu___1)
-let (basic_type_error :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun eopt ->
-      fun t1 ->
-        fun t2 ->
-          let uu___ = err_msg_type_strings env t1 t2 in
-          match uu___ with
-          | (s1, s2) ->
-              let msg =
-                match eopt with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Compiler_Util.format2
-                      "Expected type \"%s\"; got type \"%s\"" s1 s2
-                | FStar_Pervasives_Native.Some e ->
-                    let uu___1 =
-                      FStar_TypeChecker_Normalize.term_to_string env e in
-                    FStar_Compiler_Util.format3
-                      "Expected type \"%s\"; but \"%s\" has type \"%s\"" s1
-                      uu___1 s2 in
-              (FStar_Errors.Error_TypeError, msg)
-let (occurs_check : (FStar_Errors.raw_error * Prims.string)) =
-  (FStar_Errors.Fatal_PossibleInfiniteTyp,
-    "Possibly infinite typ (occurs check failed)")
-let constructor_fails_the_positivity_check :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Ident.lid -> (FStar_Errors.raw_error * Prims.string)
-  =
-  fun env ->
-    fun d ->
-      fun l ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.term_to_string d in
-          let uu___2 = FStar_Syntax_Print.lid_to_string l in
-          FStar_Compiler_Util.format2
-            "Constructor \"%s\" fails the strict positivity check; the constructed type \"%s\" occurs to the left of a pure function type"
-            uu___1 uu___2 in
-        (FStar_Errors.Fatal_ConstructorFailedCheck, uu___)
-let (inline_type_annotation_and_val_decl :
-  FStar_Ident.lid -> (FStar_Errors.raw_error * Prims.string)) =
-  fun l ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Print.lid_to_string l in
-      FStar_Compiler_Util.format1
-        "\"%s\" has a val declaration as well as an inlined type annotation; remove one"
-        uu___1 in
-    (FStar_Errors.Fatal_DuplicateTypeAnnotationAndValDecl, uu___)
-let (inferred_type_causes_variable_to_escape :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.bv -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun t ->
-      fun x ->
-        let uu___ =
-          let uu___1 = FStar_TypeChecker_Normalize.term_to_string env t in
-          let uu___2 = FStar_Syntax_Print.bv_to_string x in
-          FStar_Compiler_Util.format2
-            "Inferred type \"%s\" causes variable \"%s\" to escape its scope"
-            uu___1 uu___2 in
-        (FStar_Errors.Fatal_InferredTypeCauseVarEscape, uu___)
-let (expected_function_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_TypeChecker_Normalize.term_to_string env t in
-        FStar_Compiler_Util.format1
-          "Expected a function; got an expression of type \"%s\"" uu___1 in
-      (FStar_Errors.Fatal_FunctionTypeExpected, uu___)
-let (expected_poly_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun f ->
-      fun t ->
-        fun targ ->
-          let uu___ =
-            let uu___1 = FStar_Syntax_Print.term_to_string f in
-            let uu___2 = FStar_TypeChecker_Normalize.term_to_string env t in
-            let uu___3 = FStar_TypeChecker_Normalize.term_to_string env targ in
-            FStar_Compiler_Util.format3
-              "Expected a polymorphic function; got an expression \"%s\" of type \"%s\" applied to a type \"%s\""
-              uu___1 uu___2 uu___3 in
-          (FStar_Errors.Fatal_PolyTypeExpected, uu___)
-let (disjunctive_pattern_vars :
-  FStar_Syntax_Syntax.bv Prims.list ->
-    FStar_Syntax_Syntax.bv Prims.list ->
-      (FStar_Errors.raw_error * Prims.string))
-  =
-  fun v1 ->
-    fun v2 ->
-      let vars v =
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater v
-            (FStar_Compiler_List.map FStar_Syntax_Print.bv_to_string) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ") in
-      let uu___ =
-        let uu___1 = vars v1 in
-        let uu___2 = vars v2 in
-        FStar_Compiler_Util.format2
-          "Every alternative of an 'or' pattern must bind the same variables; here one branch binds (\"%s\") and another (\"%s\")"
-          uu___1 uu___2 in
-      (FStar_Errors.Fatal_DisjuctivePatternVarsMismatch, uu___)
-let (name_and_result :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    (Prims.string * FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax))
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total t -> ("Tot", t)
-    | FStar_Syntax_Syntax.GTotal t -> ("GTot", t)
-    | FStar_Syntax_Syntax.Comp ct ->
-        let uu___ =
-          FStar_Syntax_Print.lid_to_string ct.FStar_Syntax_Syntax.effect_name in
-        (uu___, (ct.FStar_Syntax_Syntax.result_typ))
-let computed_computation_type_does_not_match_annotation :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      'uuuuu ->
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-            (FStar_Errors.raw_error * Prims.string)
-  =
-  fun env ->
-    fun e ->
-      fun c ->
-        fun c' ->
-          let uu___ = name_and_result c in
-          match uu___ with
-          | (f1, r1) ->
-              let uu___1 = name_and_result c' in
-              (match uu___1 with
-               | (f2, r2) ->
-                   let uu___2 = err_msg_type_strings env r1 r2 in
-                   (match uu___2 with
-                    | (s1, s2) ->
-                        let uu___3 =
-                          FStar_Compiler_Util.format4
-                            "Computed type \"%s\" and effect \"%s\" is not compatible with the annotated type \"%s\" effect \"%s\""
-                            s1 f1 s2 f2 in
-                        (FStar_Errors.Fatal_ComputedTypeNotMatchAnnotation,
-                          uu___3)))
-let computed_computation_type_does_not_match_annotation_eq :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      'uuuuu ->
-        FStar_Syntax_Syntax.comp ->
-          FStar_Syntax_Syntax.comp -> (FStar_Errors.raw_error * Prims.string)
-  =
-  fun env ->
-    fun e ->
-      fun c ->
-        fun c' ->
-          let uu___ = err_msg_comp_strings env c c' in
-          match uu___ with
-          | (s1, s2) ->
-              let uu___1 =
-                FStar_Compiler_Util.format2
-                  "Computed type \"%s\" does not match annotated type \"%s\", and no subtyping was allowed"
-                  s1 s2 in
-              (FStar_Errors.Fatal_ComputedTypeNotMatchAnnotation, uu___1)
-let (unexpected_non_trivial_precondition_on_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun env ->
-    fun f ->
-      let uu___ =
-        let uu___1 = FStar_TypeChecker_Normalize.term_to_string env f in
-        FStar_Compiler_Util.format1
-          "Term has an unexpected non-trivial pre-condition: %s" uu___1 in
-      (FStar_Errors.Fatal_UnExpectedPreCondition, uu___)
-let (expected_pure_expression :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      Prims.string -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun e ->
-    fun c ->
-      fun reason ->
-        let msg = "Expected a pure expression" in
-        let msg1 =
-          if reason = ""
-          then msg
-          else FStar_Compiler_Util.format1 (Prims.op_Hat msg " (%s)") reason in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.term_to_string e in
-          let uu___2 =
-            let uu___3 = name_and_result c in
-            FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.fst
-              uu___3 in
-          FStar_Compiler_Util.format2
-            (Prims.op_Hat msg1
-               "; got an expression \"%s\" with effect \"%s\"") uu___1 uu___2 in
-        (FStar_Errors.Fatal_ExpectedPureExpression, uu___)
-let (expected_ghost_expression :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      Prims.string -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun e ->
-    fun c ->
-      fun reason ->
-        let msg = "Expected a ghost expression" in
-        let msg1 =
-          if reason = ""
-          then msg
-          else FStar_Compiler_Util.format1 (Prims.op_Hat msg " (%s)") reason in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.term_to_string e in
-          let uu___2 =
-            let uu___3 = name_and_result c in
-            FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.fst
-              uu___3 in
-          FStar_Compiler_Util.format2
-            (Prims.op_Hat msg1
-               "; got an expression \"%s\" with effect \"%s\"") uu___1 uu___2 in
-        (FStar_Errors.Fatal_ExpectedGhostExpression, uu___)
-let (expected_effect_1_got_effect_2 :
-  FStar_Ident.lident ->
-    FStar_Ident.lident -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun c1 ->
-    fun c2 ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Print.lid_to_string c1 in
-        let uu___2 = FStar_Syntax_Print.lid_to_string c2 in
-        FStar_Compiler_Util.format2
-          "Expected a computation with effect %s; but it has effect %s"
-          uu___1 uu___2 in
-      (FStar_Errors.Fatal_UnexpectedEffect, uu___)
-let (failed_to_prove_specification_of :
-  FStar_Syntax_Syntax.lbname ->
-    Prims.string Prims.list -> (FStar_Errors.raw_error * Prims.string))
-  =
-  fun l ->
-    fun lbls ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Print.lbname_to_string l in
-        let uu___2 =
-          FStar_Compiler_Effect.op_Bar_Greater lbls
-            (FStar_String.concat ", ") in
-        FStar_Compiler_Util.format2
-          "Failed to prove specification of %s; assertions at [%s] may fail"
-          uu___1 uu___2 in
-      (FStar_Errors.Error_TypeCheckerFailToProve, uu___)
-let (failed_to_prove_specification :
-  Prims.string Prims.list -> (FStar_Errors.raw_error * Prims.string)) =
-  fun lbls ->
-    let msg =
-      match lbls with
-      | [] ->
-          "An unknown assertion in the term at this location was not provable"
-      | uu___ ->
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater lbls
-              (FStar_String.concat "\n\t") in
-          FStar_Compiler_Util.format1
-            "The following problems were found:\n\t%s" uu___1 in
-    (FStar_Errors.Error_TypeCheckerFailToProve, msg)
-let (top_level_effect : (FStar_Errors.raw_error * Prims.string)) =
-  (FStar_Errors.Warning_TopLevelEffect,
-    "Top-level let-bindings must be total; this term may have effects")
-let (cardinality_constraint_violated :
-  FStar_Ident.lid ->
-    FStar_Syntax_Syntax.bv FStar_Syntax_Syntax.withinfo_t ->
-      (FStar_Errors.raw_error * Prims.string))
-  =
-  fun l ->
-    fun a ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Print.lid_to_string l in
-        let uu___2 = FStar_Syntax_Print.bv_to_string a.FStar_Syntax_Syntax.v in
-        FStar_Compiler_Util.format2
-          "Constructor %s violates the cardinality of Type at parameter '%s'; type arguments are not allowed"
-          uu___1 uu___2 in
-      (FStar_Errors.Fatal_CardinalityConstraintViolated, uu___)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Generalize.ml b/src/ocaml-output/FStar_TypeChecker_Generalize.ml
deleted file mode 100644
index 37a26e947f4..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Generalize.ml
+++ /dev/null
@@ -1,689 +0,0 @@
-open Prims
-let (string_of_univs :
-  FStar_Syntax_Syntax.universe_uvar FStar_Compiler_Util.set -> Prims.string)
-  =
-  fun univs ->
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.set_elements univs in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (FStar_Compiler_List.map
-           (fun u ->
-              let uu___2 = FStar_Syntax_Unionfind.univ_uvar_id u in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_Compiler_Util.string_of_int)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let (gen_univs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.universe_uvar FStar_Compiler_Util.set ->
-      FStar_Syntax_Syntax.univ_name Prims.list)
-  =
-  fun env ->
-    fun x ->
-      let uu___ = FStar_Compiler_Util.set_is_empty x in
-      if uu___
-      then []
-      else
-        (let s =
-           let uu___2 =
-             let uu___3 = FStar_TypeChecker_Env.univ_vars env in
-             FStar_Compiler_Util.set_difference x uu___3 in
-           FStar_Compiler_Effect.op_Bar_Greater uu___2
-             FStar_Compiler_Util.set_elements in
-         (let uu___3 =
-            FStar_Compiler_Effect.op_Less_Bar
-              (FStar_TypeChecker_Env.debug env) (FStar_Options.Other "Gen") in
-          if uu___3
-          then
-            let uu___4 =
-              let uu___5 = FStar_TypeChecker_Env.univ_vars env in
-              string_of_univs uu___5 in
-            FStar_Compiler_Util.print1 "univ_vars in env: %s\n" uu___4
-          else ());
-         (let r =
-            let uu___3 = FStar_TypeChecker_Env.get_range env in
-            FStar_Pervasives_Native.Some uu___3 in
-          let u_names =
-            FStar_Compiler_Effect.op_Bar_Greater s
-              (FStar_Compiler_List.map
-                 (fun u ->
-                    let u_name = FStar_Syntax_Syntax.new_univ_name r in
-                    (let uu___4 =
-                       FStar_Compiler_Effect.op_Less_Bar
-                         (FStar_TypeChecker_Env.debug env)
-                         (FStar_Options.Other "Gen") in
-                     if uu___4
-                     then
-                       let uu___5 =
-                         let uu___6 = FStar_Syntax_Unionfind.univ_uvar_id u in
-                         FStar_Compiler_Effect.op_Less_Bar
-                           FStar_Compiler_Util.string_of_int uu___6 in
-                       let uu___6 =
-                         FStar_Syntax_Print.univ_to_string
-                           (FStar_Syntax_Syntax.U_unif u) in
-                       let uu___7 =
-                         FStar_Syntax_Print.univ_to_string
-                           (FStar_Syntax_Syntax.U_name u_name) in
-                       FStar_Compiler_Util.print3 "Setting ?%s (%s) to %s\n"
-                         uu___5 uu___6 uu___7
-                     else ());
-                    FStar_Syntax_Unionfind.univ_change u
-                      (FStar_Syntax_Syntax.U_name u_name);
-                    u_name)) in
-          u_names))
-let (gather_free_univnames :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.univ_name FStar_Compiler_Util.set)
-  =
-  fun env ->
-    fun t ->
-      let ctx_univnames = FStar_TypeChecker_Env.univnames env in
-      let tm_univnames = FStar_Syntax_Free.univnames t in
-      let univnames =
-        FStar_Compiler_Util.set_difference tm_univnames ctx_univnames in
-      univnames
-let (check_universe_generalization :
-  FStar_Syntax_Syntax.univ_name Prims.list ->
-    FStar_Syntax_Syntax.univ_name Prims.list ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.univ_name Prims.list)
-  =
-  fun explicit_univ_names ->
-    fun generalized_univ_names ->
-      fun t ->
-        match (explicit_univ_names, generalized_univ_names) with
-        | ([], uu___) -> generalized_univ_names
-        | (uu___, []) -> explicit_univ_names
-        | uu___ ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.term_to_string t in
-                Prims.op_Hat
-                  "Generalized universe in a term containing explicit universe annotation : "
-                  uu___3 in
-              (FStar_Errors.Fatal_UnexpectedGeneralizedUniverse, uu___2) in
-            FStar_Errors.raise_error uu___1 t.FStar_Syntax_Syntax.pos
-let (generalize_universes :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun env ->
-    fun t0 ->
-      FStar_Errors.with_ctx "While generalizing universes"
-        (fun uu___ ->
-           let t =
-             FStar_TypeChecker_Normalize.normalize
-               [FStar_TypeChecker_Env.NoFullNorm;
-               FStar_TypeChecker_Env.Beta;
-               FStar_TypeChecker_Env.DoNotUnfoldPureLets] env t0 in
-           let univnames =
-             let uu___1 = gather_free_univnames env t in
-             FStar_Compiler_Util.set_elements uu___1 in
-           (let uu___2 =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env) (FStar_Options.Other "Gen") in
-            if uu___2
-            then
-              let uu___3 = FStar_Syntax_Print.term_to_string t in
-              let uu___4 = FStar_Syntax_Print.univ_names_to_string univnames in
-              FStar_Compiler_Util.print2
-                "generalizing universes in the term (post norm): %s with univnames: %s\n"
-                uu___3 uu___4
-            else ());
-           (let univs = FStar_Syntax_Free.univs t in
-            (let uu___3 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env)
-                 (FStar_Options.Other "Gen") in
-             if uu___3
-             then
-               let uu___4 = string_of_univs univs in
-               FStar_Compiler_Util.print1 "univs to gen : %s\n" uu___4
-             else ());
-            (let gen = gen_univs env univs in
-             (let uu___4 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug env)
-                  (FStar_Options.Other "Gen") in
-              if uu___4
-              then
-                let uu___5 = FStar_Syntax_Print.term_to_string t in
-                let uu___6 = FStar_Syntax_Print.univ_names_to_string gen in
-                FStar_Compiler_Util.print2
-                  "After generalization, t: %s and univs: %s\n" uu___5 uu___6
-              else ());
-             (let univs1 = check_universe_generalization univnames gen t0 in
-              let t1 =
-                FStar_TypeChecker_Normalize.reduce_uvar_solutions env t in
-              let ts = FStar_Syntax_Subst.close_univ_vars univs1 t1 in
-              (univs1, ts)))))
-let (gen :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.comp) Prims.list ->
-        (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.univ_name
-          Prims.list * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-          FStar_Syntax_Syntax.binder Prims.list) Prims.list
-          FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun is_rec ->
-      fun lecs ->
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Util.for_all
-              (fun uu___2 ->
-                 match uu___2 with
-                 | (uu___3, uu___4, c) ->
-                     FStar_Syntax_Util.is_pure_or_ghost_comp c) lecs in
-          FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___1 in
-        if uu___
-        then FStar_Pervasives_Native.None
-        else
-          (let norm c =
-             (let uu___3 =
-                FStar_TypeChecker_Env.debug env FStar_Options.Medium in
-              if uu___3
-              then
-                let uu___4 = FStar_Syntax_Print.comp_to_string c in
-                FStar_Compiler_Util.print1
-                  "Normalizing before generalizing:\n\t %s\n" uu___4
-              else ());
-             (let c1 =
-                FStar_TypeChecker_Normalize.normalize_comp
-                  [FStar_TypeChecker_Env.Beta;
-                  FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-                  FStar_TypeChecker_Env.NoFullNorm;
-                  FStar_TypeChecker_Env.DoNotUnfoldPureLets] env c in
-              (let uu___4 =
-                 FStar_TypeChecker_Env.debug env FStar_Options.Medium in
-               if uu___4
-               then
-                 let uu___5 = FStar_Syntax_Print.comp_to_string c1 in
-                 FStar_Compiler_Util.print1 "Normalized to:\n\t %s\n" uu___5
-               else ());
-              c1) in
-           let env_uvars = FStar_TypeChecker_Env.uvars_in_env env in
-           let gen_uvars uvs =
-             let uu___2 = FStar_Compiler_Util.set_difference uvs env_uvars in
-             FStar_Compiler_Effect.op_Bar_Greater uu___2
-               FStar_Compiler_Util.set_elements in
-           let univs_and_uvars_of_lec uu___2 =
-             match uu___2 with
-             | (lbname, e, c) ->
-                 let c1 = norm c in
-                 let t = FStar_Syntax_Util.comp_result c1 in
-                 let univs = FStar_Syntax_Free.univs t in
-                 let uvt = FStar_Syntax_Free.uvars t in
-                 ((let uu___4 =
-                     FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_TypeChecker_Env.debug env)
-                       (FStar_Options.Other "Gen") in
-                   if uu___4
-                   then
-                     let uu___5 =
-                       let uu___6 =
-                         let uu___7 = FStar_Compiler_Util.set_elements univs in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___7
-                           (FStar_Compiler_List.map
-                              (fun u ->
-                                 FStar_Syntax_Print.univ_to_string
-                                   (FStar_Syntax_Syntax.U_unif u))) in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___6
-                         (FStar_String.concat ", ") in
-                     let uu___6 =
-                       let uu___7 =
-                         let uu___8 = FStar_Compiler_Util.set_elements uvt in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___8
-                           (FStar_Compiler_List.map
-                              (fun u ->
-                                 let uu___9 =
-                                   FStar_Syntax_Print.uvar_to_string
-                                     u.FStar_Syntax_Syntax.ctx_uvar_head in
-                                 let uu___10 =
-                                   let uu___11 =
-                                     FStar_Syntax_Util.ctx_uvar_typ u in
-                                   FStar_Syntax_Print.term_to_string uu___11 in
-                                 FStar_Compiler_Util.format2 "(%s : %s)"
-                                   uu___9 uu___10)) in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___7
-                         (FStar_String.concat ", ") in
-                     FStar_Compiler_Util.print2
-                       "^^^^\n\tFree univs = %s\n\tFree uvt=%s\n" uu___5
-                       uu___6
-                   else ());
-                  (let univs1 =
-                     let uu___4 = FStar_Compiler_Util.set_elements uvt in
-                     FStar_Compiler_List.fold_left
-                       (fun univs2 ->
-                          fun uv ->
-                            let uu___5 =
-                              let uu___6 = FStar_Syntax_Util.ctx_uvar_typ uv in
-                              FStar_Syntax_Free.univs uu___6 in
-                            FStar_Compiler_Util.set_union univs2 uu___5)
-                       univs uu___4 in
-                   let uvs = gen_uvars uvt in
-                   (let uu___5 =
-                      FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_TypeChecker_Env.debug env)
-                        (FStar_Options.Other "Gen") in
-                    if uu___5
-                    then
-                      let uu___6 =
-                        let uu___7 =
-                          let uu___8 =
-                            FStar_Compiler_Util.set_elements univs1 in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___8
-                            (FStar_Compiler_List.map
-                               (fun u ->
-                                  FStar_Syntax_Print.univ_to_string
-                                    (FStar_Syntax_Syntax.U_unif u))) in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___7
-                          (FStar_String.concat ", ") in
-                      let uu___7 =
-                        let uu___8 =
-                          FStar_Compiler_Effect.op_Bar_Greater uvs
-                            (FStar_Compiler_List.map
-                               (fun u ->
-                                  let uu___9 =
-                                    FStar_Syntax_Print.uvar_to_string
-                                      u.FStar_Syntax_Syntax.ctx_uvar_head in
-                                  let uu___10 =
-                                    let uu___11 =
-                                      FStar_Syntax_Util.ctx_uvar_typ u in
-                                    FStar_TypeChecker_Normalize.term_to_string
-                                      env uu___11 in
-                                  FStar_Compiler_Util.format2 "(%s : %s)"
-                                    uu___9 uu___10)) in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___8
-                          (FStar_String.concat ", ") in
-                      FStar_Compiler_Util.print2
-                        "^^^^\n\tFree univs = %s\n\tgen_uvars =%s" uu___6
-                        uu___7
-                    else ());
-                   (univs1, uvs, (lbname, e, c1)))) in
-           let uu___2 =
-             let uu___3 = FStar_Compiler_List.hd lecs in
-             univs_and_uvars_of_lec uu___3 in
-           match uu___2 with
-           | (univs, uvs, lec_hd) ->
-               let force_univs_eq lec2 u1 u2 =
-                 let uu___3 =
-                   (FStar_Compiler_Util.set_is_subset_of u1 u2) &&
-                     (FStar_Compiler_Util.set_is_subset_of u2 u1) in
-                 if uu___3
-                 then ()
-                 else
-                   (let uu___5 = lec_hd in
-                    match uu___5 with
-                    | (lb1, uu___6, uu___7) ->
-                        let uu___8 = lec2 in
-                        (match uu___8 with
-                         | (lb2, uu___9, uu___10) ->
-                             let msg =
-                               let uu___11 =
-                                 FStar_Syntax_Print.lbname_to_string lb1 in
-                               let uu___12 =
-                                 FStar_Syntax_Print.lbname_to_string lb2 in
-                               FStar_Compiler_Util.format2
-                                 "Generalizing the types of these mutually recursive definitions requires an incompatible set of universes for %s and %s"
-                                 uu___11 uu___12 in
-                             let uu___11 =
-                               FStar_TypeChecker_Env.get_range env in
-                             FStar_Errors.raise_error
-                               (FStar_Errors.Fatal_IncompatibleSetOfUniverse,
-                                 msg) uu___11)) in
-               let force_uvars_eq lec2 u1 u2 =
-                 let uvars_subseteq u11 u21 =
-                   FStar_Compiler_Effect.op_Bar_Greater u11
-                     (FStar_Compiler_Util.for_all
-                        (fun u ->
-                           FStar_Compiler_Effect.op_Bar_Greater u21
-                             (FStar_Compiler_Util.for_some
-                                (fun u' ->
-                                   FStar_Syntax_Unionfind.equiv
-                                     u.FStar_Syntax_Syntax.ctx_uvar_head
-                                     u'.FStar_Syntax_Syntax.ctx_uvar_head)))) in
-                 let uu___3 =
-                   (uvars_subseteq u1 u2) && (uvars_subseteq u2 u1) in
-                 if uu___3
-                 then ()
-                 else
-                   (let uu___5 = lec_hd in
-                    match uu___5 with
-                    | (lb1, uu___6, uu___7) ->
-                        let uu___8 = lec2 in
-                        (match uu___8 with
-                         | (lb2, uu___9, uu___10) ->
-                             let msg =
-                               let uu___11 =
-                                 FStar_Syntax_Print.lbname_to_string lb1 in
-                               let uu___12 =
-                                 FStar_Syntax_Print.lbname_to_string lb2 in
-                               FStar_Compiler_Util.format2
-                                 "Generalizing the types of these mutually recursive definitions requires an incompatible number of types for %s and %s"
-                                 uu___11 uu___12 in
-                             let uu___11 =
-                               FStar_TypeChecker_Env.get_range env in
-                             FStar_Errors.raise_error
-                               (FStar_Errors.Fatal_IncompatibleNumberOfTypes,
-                                 msg) uu___11)) in
-               let lecs1 =
-                 let uu___3 = FStar_Compiler_List.tl lecs in
-                 FStar_Compiler_List.fold_right
-                   (fun this_lec ->
-                      fun lecs2 ->
-                        let uu___4 = univs_and_uvars_of_lec this_lec in
-                        match uu___4 with
-                        | (this_univs, this_uvs, this_lec1) ->
-                            (force_univs_eq this_lec1 univs this_univs;
-                             force_uvars_eq this_lec1 uvs this_uvs;
-                             this_lec1
-                             ::
-                             lecs2)) uu___3 [] in
-               let lecs2 = lec_hd :: lecs1 in
-               let gen_types uvs1 =
-                 let fail rng k =
-                   let uu___3 = lec_hd in
-                   match uu___3 with
-                   | (lbname, e, c) ->
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 = FStar_Syntax_Print.term_to_string k in
-                           let uu___7 =
-                             FStar_Syntax_Print.lbname_to_string lbname in
-                           let uu___8 =
-                             FStar_Syntax_Print.term_to_string
-                               (FStar_Syntax_Util.comp_result c) in
-                           FStar_Compiler_Util.format3
-                             "Failed to resolve implicit argument of type '%s' in the type of %s (%s)"
-                             uu___6 uu___7 uu___8 in
-                         (FStar_Errors.Fatal_FailToResolveImplicitArgument,
-                           uu___5) in
-                       FStar_Errors.raise_error uu___4 rng in
-                 FStar_Compiler_Effect.op_Bar_Greater uvs1
-                   (FStar_Compiler_List.map
-                      (fun u ->
-                         let uu___3 =
-                           FStar_Syntax_Unionfind.find
-                             u.FStar_Syntax_Syntax.ctx_uvar_head in
-                         match uu___3 with
-                         | FStar_Pervasives_Native.Some uu___4 ->
-                             failwith
-                               "Unexpected instantiation of mutually recursive uvar"
-                         | uu___4 ->
-                             let k =
-                               let uu___5 = FStar_Syntax_Util.ctx_uvar_typ u in
-                               FStar_TypeChecker_Normalize.normalize
-                                 [FStar_TypeChecker_Env.Beta;
-                                 FStar_TypeChecker_Env.Exclude
-                                   FStar_TypeChecker_Env.Zeta] env uu___5 in
-                             let uu___5 = FStar_Syntax_Util.arrow_formals k in
-                             (match uu___5 with
-                              | (bs, kres) ->
-                                  ((let uu___7 =
-                                      let uu___8 =
-                                        let uu___9 =
-                                          FStar_TypeChecker_Normalize.unfold_whnf
-                                            env kres in
-                                        FStar_Syntax_Util.unrefine uu___9 in
-                                      uu___8.FStar_Syntax_Syntax.n in
-                                    match uu___7 with
-                                    | FStar_Syntax_Syntax.Tm_type uu___8 ->
-                                        let free =
-                                          FStar_Syntax_Free.names kres in
-                                        let uu___9 =
-                                          let uu___10 =
-                                            FStar_Compiler_Util.set_is_empty
-                                              free in
-                                          Prims.op_Negation uu___10 in
-                                        if uu___9
-                                        then
-                                          fail
-                                            u.FStar_Syntax_Syntax.ctx_uvar_range
-                                            kres
-                                        else ()
-                                    | uu___8 ->
-                                        fail
-                                          u.FStar_Syntax_Syntax.ctx_uvar_range
-                                          kres);
-                                   (let a =
-                                      let uu___7 =
-                                        let uu___8 =
-                                          FStar_TypeChecker_Env.get_range env in
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (fun uu___9 ->
-                                             FStar_Pervasives_Native.Some
-                                               uu___9) uu___8 in
-                                      FStar_Syntax_Syntax.new_bv uu___7 kres in
-                                    let t =
-                                      match bs with
-                                      | [] ->
-                                          FStar_Syntax_Syntax.bv_to_name a
-                                      | uu___7 ->
-                                          let uu___8 =
-                                            FStar_Syntax_Syntax.bv_to_name a in
-                                          FStar_Syntax_Util.abs bs uu___8
-                                            (FStar_Pervasives_Native.Some
-                                               (FStar_Syntax_Util.residual_tot
-                                                  kres)) in
-                                    FStar_Syntax_Util.set_uvar
-                                      u.FStar_Syntax_Syntax.ctx_uvar_head t;
-                                    (let uu___8 =
-                                       FStar_Syntax_Syntax.as_bqual_implicit
-                                         true in
-                                     (a, uu___8))))))) in
-               let gen_univs1 = gen_univs env univs in
-               let gen_tvars = gen_types uvs in
-               let ecs =
-                 FStar_Compiler_Effect.op_Bar_Greater lecs2
-                   (FStar_Compiler_List.map
-                      (fun uu___3 ->
-                         match uu___3 with
-                         | (lbname, e, c) ->
-                             let uu___4 =
-                               match (gen_tvars, gen_univs1) with
-                               | ([], []) -> (e, c, [])
-                               | uu___5 ->
-                                   let uu___6 = (e, c) in
-                                   (match uu___6 with
-                                    | (e0, c0) ->
-                                        let c1 =
-                                          FStar_TypeChecker_Normalize.normalize_comp
-                                            [FStar_TypeChecker_Env.Beta;
-                                            FStar_TypeChecker_Env.DoNotUnfoldPureLets;
-                                            FStar_TypeChecker_Env.CompressUvars;
-                                            FStar_TypeChecker_Env.NoFullNorm;
-                                            FStar_TypeChecker_Env.Exclude
-                                              FStar_TypeChecker_Env.Zeta] env
-                                            c in
-                                        let e1 =
-                                          FStar_TypeChecker_Normalize.reduce_uvar_solutions
-                                            env e in
-                                        let e2 =
-                                          if is_rec
-                                          then
-                                            let tvar_args =
-                                              FStar_Compiler_List.map
-                                                (fun uu___7 ->
-                                                   match uu___7 with
-                                                   | (x, uu___8) ->
-                                                       let uu___9 =
-                                                         FStar_Syntax_Syntax.bv_to_name
-                                                           x in
-                                                       FStar_Syntax_Syntax.iarg
-                                                         uu___9) gen_tvars in
-                                            let instantiate_lbname_with_app
-                                              tm fv =
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  FStar_Compiler_Util.right
-                                                    lbname in
-                                                FStar_Syntax_Syntax.fv_eq fv
-                                                  uu___8 in
-                                              if uu___7
-                                              then
-                                                FStar_Syntax_Syntax.mk_Tm_app
-                                                  tm tvar_args
-                                                  tm.FStar_Syntax_Syntax.pos
-                                              else tm in
-                                            FStar_Syntax_InstFV.inst
-                                              instantiate_lbname_with_app e1
-                                          else e1 in
-                                        let tvars_bs =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            gen_tvars
-                                            (FStar_Compiler_List.map
-                                               (fun uu___7 ->
-                                                  match uu___7 with
-                                                  | (x, q) ->
-                                                      FStar_Syntax_Syntax.mk_binder_with_attrs
-                                                        x q [])) in
-                                        let t =
-                                          let uu___7 =
-                                            let uu___8 =
-                                              FStar_Syntax_Subst.compress
-                                                (FStar_Syntax_Util.comp_result
-                                                   c1) in
-                                            uu___8.FStar_Syntax_Syntax.n in
-                                          match uu___7 with
-                                          | FStar_Syntax_Syntax.Tm_arrow
-                                              (bs, cod) ->
-                                              let uu___8 =
-                                                FStar_Syntax_Subst.open_comp
-                                                  bs cod in
-                                              (match uu___8 with
-                                               | (bs1, cod1) ->
-                                                   FStar_Syntax_Util.arrow
-                                                     (FStar_Compiler_List.op_At
-                                                        tvars_bs bs1) cod1)
-                                          | uu___8 ->
-                                              FStar_Syntax_Util.arrow
-                                                tvars_bs c1 in
-                                        let e' =
-                                          let uu___7 =
-                                            let uu___8 =
-                                              FStar_Syntax_Util.residual_comp_of_comp
-                                                c1 in
-                                            FStar_Pervasives_Native.Some
-                                              uu___8 in
-                                          FStar_Syntax_Util.abs tvars_bs e2
-                                            uu___7 in
-                                        let uu___7 =
-                                          FStar_Syntax_Syntax.mk_Total t in
-                                        (e', uu___7, tvars_bs)) in
-                             (match uu___4 with
-                              | (e1, c1, gvs) ->
-                                  (lbname, gen_univs1, e1, c1, gvs)))) in
-               FStar_Pervasives_Native.Some ecs)
-let (generalize' :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.comp) Prims.list ->
-        (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.univ_names *
-          FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-          FStar_Syntax_Syntax.binder Prims.list) Prims.list)
-  =
-  fun env ->
-    fun is_rec ->
-      fun lecs ->
-        (let uu___2 =
-           FStar_Compiler_List.for_all
-             (fun uu___3 ->
-                match uu___3 with
-                | (l, uu___4, uu___5) -> FStar_Compiler_Util.is_right l) lecs in
-         ());
-        (let uu___2 = FStar_TypeChecker_Env.debug env FStar_Options.Low in
-         if uu___2
-         then
-           let uu___3 =
-             let uu___4 =
-               FStar_Compiler_List.map
-                 (fun uu___5 ->
-                    match uu___5 with
-                    | (lb, uu___6, uu___7) ->
-                        FStar_Syntax_Print.lbname_to_string lb) lecs in
-             FStar_Compiler_Effect.op_Bar_Greater uu___4
-               (FStar_String.concat ", ") in
-           FStar_Compiler_Util.print1 "Generalizing: %s\n" uu___3
-         else ());
-        (let univnames_lecs =
-           let empty =
-             FStar_Compiler_Util.as_set []
-               FStar_Syntax_Syntax.order_univ_name in
-           FStar_Compiler_List.fold_left
-             (fun out ->
-                fun uu___2 ->
-                  match uu___2 with
-                  | (l, t, c) ->
-                      let uu___3 = gather_free_univnames env t in
-                      FStar_Compiler_Util.set_union out uu___3) empty lecs in
-         let univnames_lecs1 =
-           FStar_Compiler_Util.set_elements univnames_lecs in
-         let generalized_lecs =
-           let uu___2 = gen env is_rec lecs in
-           match uu___2 with
-           | FStar_Pervasives_Native.None ->
-               FStar_Compiler_Effect.op_Bar_Greater lecs
-                 (FStar_Compiler_List.map
-                    (fun uu___3 ->
-                       match uu___3 with | (l, t, c) -> (l, [], t, c, [])))
-           | FStar_Pervasives_Native.Some luecs ->
-               ((let uu___4 =
-                   FStar_TypeChecker_Env.debug env FStar_Options.Medium in
-                 if uu___4
-                 then
-                   FStar_Compiler_Effect.op_Bar_Greater luecs
-                     (FStar_Compiler_List.iter
-                        (fun uu___5 ->
-                           match uu___5 with
-                           | (l, us, e, c, gvs) ->
-                               let uu___6 =
-                                 FStar_Compiler_Range.string_of_range
-                                   e.FStar_Syntax_Syntax.pos in
-                               let uu___7 =
-                                 FStar_Syntax_Print.lbname_to_string l in
-                               let uu___8 =
-                                 FStar_Syntax_Print.term_to_string
-                                   (FStar_Syntax_Util.comp_result c) in
-                               let uu___9 =
-                                 FStar_Syntax_Print.term_to_string e in
-                               let uu___10 =
-                                 FStar_Syntax_Print.binders_to_string ", "
-                                   gvs in
-                               FStar_Compiler_Util.print5
-                                 "(%s) Generalized %s at type %s\n%s\nVars = (%s)\n"
-                                 uu___6 uu___7 uu___8 uu___9 uu___10))
-                 else ());
-                luecs) in
-         FStar_Compiler_List.map
-           (fun uu___2 ->
-              match uu___2 with
-              | (l, generalized_univs, t, c, gvs) ->
-                  let uu___3 =
-                    check_universe_generalization univnames_lecs1
-                      generalized_univs t in
-                  (l, uu___3, t, c, gvs)) generalized_lecs)
-let (generalize :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.term *
-        FStar_Syntax_Syntax.comp) Prims.list ->
-        (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.univ_names *
-          FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-          FStar_Syntax_Syntax.binder Prims.list) Prims.list)
-  =
-  fun env ->
-    fun is_rec ->
-      fun lecs ->
-        FStar_Errors.with_ctx "While generalizing"
-          (fun uu___ ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 = FStar_TypeChecker_Env.current_module env in
-                 FStar_Ident.string_of_lid uu___3 in
-               FStar_Pervasives_Native.Some uu___2 in
-             FStar_Profiling.profile
-               (fun uu___2 -> generalize' env is_rec lecs) uu___1
-               "FStar.TypeChecker.Util.generalize")
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_NBE.ml b/src/ocaml-output/FStar_TypeChecker_NBE.ml
deleted file mode 100644
index fe6d7091c67..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_NBE.ml
+++ /dev/null
@@ -1,3365 +0,0 @@
-open Prims
-let (max : Prims.int -> Prims.int -> Prims.int) =
-  fun a -> fun b -> if a > b then a else b
-let map_rev : 'a 'b . ('a -> 'b) -> 'a Prims.list -> 'b Prims.list =
-  fun f ->
-    fun l ->
-      let rec aux l1 acc =
-        match l1 with
-        | [] -> acc
-        | x::xs ->
-            let uu___ = let uu___1 = f x in uu___1 :: acc in aux xs uu___ in
-      aux l []
-let map_rev_append :
-  'a 'b . ('a -> 'b) -> 'a Prims.list -> 'b Prims.list -> 'b Prims.list =
-  fun f ->
-    fun l1 ->
-      fun l2 ->
-        let rec aux l acc =
-          match l with
-          | [] -> l2
-          | x::xs ->
-              let uu___ = let uu___1 = f x in uu___1 :: acc in aux xs uu___ in
-        aux l1 l2
-let rec map_append :
-  'a 'b . ('a -> 'b) -> 'a Prims.list -> 'b Prims.list -> 'b Prims.list =
-  fun f ->
-    fun l1 ->
-      fun l2 ->
-        match l1 with
-        | [] -> l2
-        | x::xs ->
-            let uu___ = f x in
-            let uu___1 = map_append f xs l2 in uu___ :: uu___1
-let rec drop : 'a . ('a -> Prims.bool) -> 'a Prims.list -> 'a Prims.list =
-  fun p ->
-    fun l ->
-      match l with
-      | [] -> []
-      | x::xs -> let uu___ = p x in if uu___ then x :: xs else drop p xs
-let fmap_opt :
-  'a 'b .
-    ('a -> 'b) ->
-      'a FStar_Pervasives_Native.option -> 'b FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun x ->
-      FStar_Compiler_Util.bind_opt x
-        (fun x1 -> let uu___ = f x1 in FStar_Pervasives_Native.Some uu___)
-let drop_until : 'a . ('a -> Prims.bool) -> 'a Prims.list -> 'a Prims.list =
-  fun f ->
-    fun l ->
-      let rec aux l1 =
-        match l1 with
-        | [] -> []
-        | x::xs -> let uu___ = f x in if uu___ then l1 else aux xs in
-      aux l
-let (trim : Prims.bool Prims.list -> Prims.bool Prims.list) =
-  fun l ->
-    let uu___ = drop_until FStar_Pervasives.id (FStar_Compiler_List.rev l) in
-    FStar_Compiler_List.rev uu___
-let (implies : Prims.bool -> Prims.bool -> Prims.bool) =
-  fun b1 ->
-    fun b2 ->
-      match (b1, b2) with | (false, uu___) -> true | (true, b21) -> b21
-let (let_rec_arity :
-  FStar_Syntax_Syntax.letbinding -> (Prims.int * Prims.bool Prims.list)) =
-  fun b ->
-    let uu___ = FStar_Syntax_Util.let_rec_arity b in
-    match uu___ with
-    | (ar, maybe_lst) ->
-        (match maybe_lst with
-         | FStar_Pervasives_Native.None ->
-             let uu___1 = FStar_Common.tabulate ar (fun uu___2 -> true) in
-             (ar, uu___1)
-         | FStar_Pervasives_Native.Some lst -> (ar, lst))
-let (debug_term : FStar_Syntax_Syntax.term -> unit) =
-  fun t ->
-    let uu___ = FStar_Syntax_Print.term_to_string t in
-    FStar_Compiler_Util.print1 "%s\n" uu___
-let (debug_sigmap :
-  FStar_Syntax_Syntax.sigelt FStar_Compiler_Util.smap -> unit) =
-  fun m ->
-    FStar_Compiler_Util.smap_fold m
-      (fun k ->
-         fun v ->
-           fun u ->
-             let uu___ = FStar_Syntax_Print.sigelt_to_string_short v in
-             FStar_Compiler_Util.print2 "%s -> %%s\n" k uu___) ()
-type config =
-  {
-  core_cfg: FStar_TypeChecker_Cfg.cfg ;
-  fv_cache: FStar_TypeChecker_NBETerm.t FStar_Compiler_Util.smap }
-let (__proj__Mkconfig__item__core_cfg : config -> FStar_TypeChecker_Cfg.cfg)
-  =
-  fun projectee -> match projectee with | { core_cfg; fv_cache;_} -> core_cfg
-let (__proj__Mkconfig__item__fv_cache :
-  config -> FStar_TypeChecker_NBETerm.t FStar_Compiler_Util.smap) =
-  fun projectee -> match projectee with | { core_cfg; fv_cache;_} -> fv_cache
-let (new_config : FStar_TypeChecker_Cfg.cfg -> config) =
-  fun cfg ->
-    let uu___ = FStar_Compiler_Util.smap_create (Prims.of_int (51)) in
-    { core_cfg = cfg; fv_cache = uu___ }
-let (reifying_false : config -> config) =
-  fun cfg ->
-    if (cfg.core_cfg).FStar_TypeChecker_Cfg.reifying
-    then
-      new_config
-        (let uu___ = cfg.core_cfg in
-         {
-           FStar_TypeChecker_Cfg.steps = (uu___.FStar_TypeChecker_Cfg.steps);
-           FStar_TypeChecker_Cfg.tcenv = (uu___.FStar_TypeChecker_Cfg.tcenv);
-           FStar_TypeChecker_Cfg.debug = (uu___.FStar_TypeChecker_Cfg.debug);
-           FStar_TypeChecker_Cfg.delta_level =
-             (uu___.FStar_TypeChecker_Cfg.delta_level);
-           FStar_TypeChecker_Cfg.primitive_steps =
-             (uu___.FStar_TypeChecker_Cfg.primitive_steps);
-           FStar_TypeChecker_Cfg.strong =
-             (uu___.FStar_TypeChecker_Cfg.strong);
-           FStar_TypeChecker_Cfg.memoize_lazy =
-             (uu___.FStar_TypeChecker_Cfg.memoize_lazy);
-           FStar_TypeChecker_Cfg.normalize_pure_lets =
-             (uu___.FStar_TypeChecker_Cfg.normalize_pure_lets);
-           FStar_TypeChecker_Cfg.reifying = false
-         })
-    else cfg
-let (reifying_true : config -> config) =
-  fun cfg ->
-    if Prims.op_Negation (cfg.core_cfg).FStar_TypeChecker_Cfg.reifying
-    then
-      new_config
-        (let uu___ = cfg.core_cfg in
-         {
-           FStar_TypeChecker_Cfg.steps = (uu___.FStar_TypeChecker_Cfg.steps);
-           FStar_TypeChecker_Cfg.tcenv = (uu___.FStar_TypeChecker_Cfg.tcenv);
-           FStar_TypeChecker_Cfg.debug = (uu___.FStar_TypeChecker_Cfg.debug);
-           FStar_TypeChecker_Cfg.delta_level =
-             (uu___.FStar_TypeChecker_Cfg.delta_level);
-           FStar_TypeChecker_Cfg.primitive_steps =
-             (uu___.FStar_TypeChecker_Cfg.primitive_steps);
-           FStar_TypeChecker_Cfg.strong =
-             (uu___.FStar_TypeChecker_Cfg.strong);
-           FStar_TypeChecker_Cfg.memoize_lazy =
-             (uu___.FStar_TypeChecker_Cfg.memoize_lazy);
-           FStar_TypeChecker_Cfg.normalize_pure_lets =
-             (uu___.FStar_TypeChecker_Cfg.normalize_pure_lets);
-           FStar_TypeChecker_Cfg.reifying = true
-         })
-    else cfg
-let (zeta_false : config -> config) =
-  fun cfg ->
-    let cfg_core = cfg.core_cfg in
-    if (cfg_core.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta
-    then
-      let cfg_core' =
-        {
-          FStar_TypeChecker_Cfg.steps =
-            (let uu___ = cfg_core.FStar_TypeChecker_Cfg.steps in
-             {
-               FStar_TypeChecker_Cfg.beta =
-                 (uu___.FStar_TypeChecker_Cfg.beta);
-               FStar_TypeChecker_Cfg.iota =
-                 (uu___.FStar_TypeChecker_Cfg.iota);
-               FStar_TypeChecker_Cfg.zeta = false;
-               FStar_TypeChecker_Cfg.zeta_full =
-                 (uu___.FStar_TypeChecker_Cfg.zeta_full);
-               FStar_TypeChecker_Cfg.weak =
-                 (uu___.FStar_TypeChecker_Cfg.weak);
-               FStar_TypeChecker_Cfg.hnf = (uu___.FStar_TypeChecker_Cfg.hnf);
-               FStar_TypeChecker_Cfg.primops =
-                 (uu___.FStar_TypeChecker_Cfg.primops);
-               FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                 (uu___.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-               FStar_TypeChecker_Cfg.unfold_until =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_until);
-               FStar_TypeChecker_Cfg.unfold_only =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_only);
-               FStar_TypeChecker_Cfg.unfold_fully =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_fully);
-               FStar_TypeChecker_Cfg.unfold_attr =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_attr);
-               FStar_TypeChecker_Cfg.unfold_qual =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_qual);
-               FStar_TypeChecker_Cfg.unfold_namespace =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_namespace);
-               FStar_TypeChecker_Cfg.unfold_tac =
-                 (uu___.FStar_TypeChecker_Cfg.unfold_tac);
-               FStar_TypeChecker_Cfg.pure_subterms_within_computations =
-                 (uu___.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-               FStar_TypeChecker_Cfg.simplify =
-                 (uu___.FStar_TypeChecker_Cfg.simplify);
-               FStar_TypeChecker_Cfg.erase_universes =
-                 (uu___.FStar_TypeChecker_Cfg.erase_universes);
-               FStar_TypeChecker_Cfg.allow_unbound_universes =
-                 (uu___.FStar_TypeChecker_Cfg.allow_unbound_universes);
-               FStar_TypeChecker_Cfg.reify_ =
-                 (uu___.FStar_TypeChecker_Cfg.reify_);
-               FStar_TypeChecker_Cfg.compress_uvars =
-                 (uu___.FStar_TypeChecker_Cfg.compress_uvars);
-               FStar_TypeChecker_Cfg.no_full_norm =
-                 (uu___.FStar_TypeChecker_Cfg.no_full_norm);
-               FStar_TypeChecker_Cfg.check_no_uvars =
-                 (uu___.FStar_TypeChecker_Cfg.check_no_uvars);
-               FStar_TypeChecker_Cfg.unmeta =
-                 (uu___.FStar_TypeChecker_Cfg.unmeta);
-               FStar_TypeChecker_Cfg.unascribe =
-                 (uu___.FStar_TypeChecker_Cfg.unascribe);
-               FStar_TypeChecker_Cfg.in_full_norm_request =
-                 (uu___.FStar_TypeChecker_Cfg.in_full_norm_request);
-               FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                 (uu___.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-               FStar_TypeChecker_Cfg.nbe_step =
-                 (uu___.FStar_TypeChecker_Cfg.nbe_step);
-               FStar_TypeChecker_Cfg.for_extraction =
-                 (uu___.FStar_TypeChecker_Cfg.for_extraction);
-               FStar_TypeChecker_Cfg.unrefine =
-                 (uu___.FStar_TypeChecker_Cfg.unrefine)
-             });
-          FStar_TypeChecker_Cfg.tcenv =
-            (cfg_core.FStar_TypeChecker_Cfg.tcenv);
-          FStar_TypeChecker_Cfg.debug =
-            (cfg_core.FStar_TypeChecker_Cfg.debug);
-          FStar_TypeChecker_Cfg.delta_level =
-            (cfg_core.FStar_TypeChecker_Cfg.delta_level);
-          FStar_TypeChecker_Cfg.primitive_steps =
-            (cfg_core.FStar_TypeChecker_Cfg.primitive_steps);
-          FStar_TypeChecker_Cfg.strong =
-            (cfg_core.FStar_TypeChecker_Cfg.strong);
-          FStar_TypeChecker_Cfg.memoize_lazy =
-            (cfg_core.FStar_TypeChecker_Cfg.memoize_lazy);
-          FStar_TypeChecker_Cfg.normalize_pure_lets =
-            (cfg_core.FStar_TypeChecker_Cfg.normalize_pure_lets);
-          FStar_TypeChecker_Cfg.reifying =
-            (cfg_core.FStar_TypeChecker_Cfg.reifying)
-        } in
-      new_config cfg_core'
-    else cfg
-let (cache_add :
-  config -> FStar_Syntax_Syntax.fv -> FStar_TypeChecker_NBETerm.t -> unit) =
-  fun cfg ->
-    fun fv ->
-      fun v ->
-        let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-        let uu___ = FStar_Ident.string_of_lid lid in
-        FStar_Compiler_Util.smap_add cfg.fv_cache uu___ v
-let (try_in_cache :
-  config ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_TypeChecker_NBETerm.t FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun fv ->
-      let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      let uu___ = FStar_Ident.string_of_lid lid in
-      FStar_Compiler_Util.smap_try_find cfg.fv_cache uu___
-let (debug : config -> (unit -> unit) -> unit) =
-  fun cfg -> fun f -> FStar_TypeChecker_Cfg.log_nbe cfg.core_cfg f
-let rec (unlazy_unmeta :
-  FStar_TypeChecker_NBETerm.t -> FStar_TypeChecker_NBETerm.t) =
-  fun t ->
-    match t.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Lazy (uu___, t1) ->
-        let uu___1 = FStar_Thunk.force t1 in unlazy_unmeta uu___1
-    | FStar_TypeChecker_NBETerm.Meta (t0, m) ->
-        let uu___ = FStar_Thunk.force m in
-        (match uu___ with
-         | FStar_Syntax_Syntax.Meta_monadic (uu___1, uu___2) -> t
-         | FStar_Syntax_Syntax.Meta_monadic_lift (uu___1, uu___2, uu___3) ->
-             t
-         | uu___1 -> unlazy_unmeta t0)
-    | uu___ -> t
-let (pickBranch :
-  config ->
-    FStar_TypeChecker_NBETerm.t ->
-      FStar_Syntax_Syntax.branch Prims.list ->
-        (FStar_Syntax_Syntax.term * FStar_TypeChecker_NBETerm.t Prims.list)
-          FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun scrut ->
-      fun branches ->
-        let all_branches = branches in
-        let rec pickBranch_aux scrut1 branches1 branches0 =
-          let rec matches_pat scrutinee0 p =
-            debug cfg
-              (fun uu___1 ->
-                 let uu___2 =
-                   FStar_TypeChecker_NBETerm.t_to_string scrutinee0 in
-                 let uu___3 = FStar_Syntax_Print.pat_to_string p in
-                 FStar_Compiler_Util.print2 "matches_pat (%s, %s)\n" uu___2
-                   uu___3);
-            (let scrutinee = unlazy_unmeta scrutinee0 in
-             let r =
-               match p.FStar_Syntax_Syntax.v with
-               | FStar_Syntax_Syntax.Pat_var bv ->
-                   FStar_Pervasives.Inl [scrutinee0]
-               | FStar_Syntax_Syntax.Pat_wild bv ->
-                   FStar_Pervasives.Inl [scrutinee0]
-               | FStar_Syntax_Syntax.Pat_dot_term uu___1 ->
-                   FStar_Pervasives.Inl []
-               | FStar_Syntax_Syntax.Pat_constant s ->
-                   let matches_const c s1 =
-                     debug cfg
-                       (fun uu___2 ->
-                          let uu___3 =
-                            FStar_TypeChecker_NBETerm.t_to_string c in
-                          let uu___4 = FStar_Syntax_Print.const_to_string s1 in
-                          FStar_Compiler_Util.print2
-                            "Testing term %s against pattern %s\n" uu___3
-                            uu___4);
-                     (match c.FStar_TypeChecker_NBETerm.nbe_t with
-                      | FStar_TypeChecker_NBETerm.Constant
-                          (FStar_TypeChecker_NBETerm.Unit) ->
-                          s1 = FStar_Const.Const_unit
-                      | FStar_TypeChecker_NBETerm.Constant
-                          (FStar_TypeChecker_NBETerm.Bool b) ->
-                          (match s1 with
-                           | FStar_Const.Const_bool p1 -> b = p1
-                           | uu___2 -> false)
-                      | FStar_TypeChecker_NBETerm.Constant
-                          (FStar_TypeChecker_NBETerm.Int i) ->
-                          (match s1 with
-                           | FStar_Const.Const_int
-                               (p1, FStar_Pervasives_Native.None) ->
-                               let uu___2 = FStar_BigInt.big_int_of_string p1 in
-                               i = uu___2
-                           | uu___2 -> false)
-                      | FStar_TypeChecker_NBETerm.Constant
-                          (FStar_TypeChecker_NBETerm.String (st, uu___2)) ->
-                          (match s1 with
-                           | FStar_Const.Const_string (p1, uu___3) -> st = p1
-                           | uu___3 -> false)
-                      | FStar_TypeChecker_NBETerm.Constant
-                          (FStar_TypeChecker_NBETerm.Char c1) ->
-                          (match s1 with
-                           | FStar_Const.Const_char p1 -> c1 = p1
-                           | uu___2 -> false)
-                      | uu___2 -> false) in
-                   let uu___1 = matches_const scrutinee s in
-                   if uu___1
-                   then FStar_Pervasives.Inl []
-                   else FStar_Pervasives.Inr false
-               | FStar_Syntax_Syntax.Pat_cons (fv, _us_opt, arg_pats) ->
-                   let rec matches_args out a p1 =
-                     match (a, p1) with
-                     | ([], []) -> FStar_Pervasives.Inl out
-                     | ((t, uu___1)::rest_a, (p2, uu___2)::rest_p) ->
-                         let uu___3 = matches_pat t p2 in
-                         (match uu___3 with
-                          | FStar_Pervasives.Inl s ->
-                              matches_args (FStar_Compiler_List.op_At out s)
-                                rest_a rest_p
-                          | m -> m)
-                     | uu___1 -> FStar_Pervasives.Inr false in
-                   (match scrutinee.FStar_TypeChecker_NBETerm.nbe_t with
-                    | FStar_TypeChecker_NBETerm.Construct
-                        (fv', _us, args_rev) ->
-                        let uu___1 = FStar_Syntax_Syntax.fv_eq fv fv' in
-                        if uu___1
-                        then
-                          matches_args [] (FStar_Compiler_List.rev args_rev)
-                            arg_pats
-                        else FStar_Pervasives.Inr false
-                    | uu___1 -> FStar_Pervasives.Inr true) in
-             let res_to_string uu___1 =
-               match uu___1 with
-               | FStar_Pervasives.Inr b ->
-                   let uu___2 = FStar_Compiler_Util.string_of_bool b in
-                   Prims.op_Hat "Inr " uu___2
-               | FStar_Pervasives.Inl bs ->
-                   let uu___2 =
-                     FStar_Compiler_Util.string_of_int
-                       (FStar_Compiler_List.length bs) in
-                   Prims.op_Hat "Inl " uu___2 in
-             debug cfg
-               (fun uu___2 ->
-                  let uu___3 =
-                    FStar_TypeChecker_NBETerm.t_to_string scrutinee in
-                  let uu___4 = FStar_Syntax_Print.pat_to_string p in
-                  let uu___5 = res_to_string r in
-                  FStar_Compiler_Util.print3 "matches_pat (%s, %s) = %s\n"
-                    uu___3 uu___4 uu___5);
-             r) in
-          match branches1 with
-          | [] -> FStar_Pervasives_Native.None
-          | (p, _wopt, e)::branches2 ->
-              let uu___ = matches_pat scrut1 p in
-              (match uu___ with
-               | FStar_Pervasives.Inl matches ->
-                   (debug cfg
-                      (fun uu___2 ->
-                         let uu___3 = FStar_Syntax_Print.pat_to_string p in
-                         FStar_Compiler_Util.print1 "Pattern %s matches\n"
-                           uu___3);
-                    FStar_Pervasives_Native.Some (e, matches))
-               | FStar_Pervasives.Inr (false) ->
-                   pickBranch_aux scrut1 branches2 branches0
-               | FStar_Pervasives.Inr (true) -> FStar_Pervasives_Native.None) in
-        pickBranch_aux scrut branches branches
-let (should_reduce_recursive_definition :
-  FStar_TypeChecker_NBETerm.args ->
-    Prims.bool Prims.list ->
-      (Prims.bool * FStar_TypeChecker_NBETerm.args *
-        FStar_TypeChecker_NBETerm.args))
-  =
-  fun arguments ->
-    fun formals_in_decreases ->
-      let rec aux ts ar_list acc =
-        match (ts, ar_list) with
-        | (uu___, []) -> (true, acc, ts)
-        | ([], uu___::uu___1) -> (false, acc, [])
-        | (t::ts1, in_decreases_clause::bs) ->
-            let uu___ =
-              in_decreases_clause &&
-                (FStar_TypeChecker_NBETerm.isAccu
-                   (FStar_Pervasives_Native.fst t)) in
-            if uu___
-            then (false, (FStar_Compiler_List.rev_append ts1 acc), [])
-            else aux ts1 bs (t :: acc) in
-      aux arguments formals_in_decreases []
-let (find_sigelt_in_gamma :
-  config ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun env ->
-      fun lid ->
-        let mapper uu___ =
-          match uu___ with
-          | (lr, rng) ->
-              (match lr with
-               | FStar_Pervasives.Inr (elt, FStar_Pervasives_Native.None) ->
-                   FStar_Pervasives_Native.Some elt
-               | FStar_Pervasives.Inr (elt, FStar_Pervasives_Native.Some us)
-                   ->
-                   (debug cfg
-                      (fun uu___2 ->
-                         let uu___3 = FStar_Syntax_Print.univs_to_string us in
-                         FStar_Compiler_Util.print1
-                           "Universes in local declaration: %s\n" uu___3);
-                    FStar_Pervasives_Native.Some elt)
-               | uu___1 -> FStar_Pervasives_Native.None) in
-        let uu___ = FStar_TypeChecker_Env.lookup_qname env lid in
-        FStar_Compiler_Util.bind_opt uu___ mapper
-let (is_univ : FStar_TypeChecker_NBETerm.t -> Prims.bool) =
-  fun tm ->
-    match tm.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Univ uu___ -> true
-    | uu___ -> false
-let (un_univ : FStar_TypeChecker_NBETerm.t -> FStar_Syntax_Syntax.universe) =
-  fun tm ->
-    match tm.FStar_TypeChecker_NBETerm.nbe_t with
-    | FStar_TypeChecker_NBETerm.Univ u -> u
-    | uu___ ->
-        let uu___1 =
-          let uu___2 = FStar_TypeChecker_NBETerm.t_to_string tm in
-          Prims.op_Hat "Not a universe: " uu___2 in
-        failwith uu___1
-let (is_constr_fv : FStar_Syntax_Syntax.fv -> Prims.bool) =
-  fun fvar ->
-    fvar.FStar_Syntax_Syntax.fv_qual =
-      (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor)
-let (is_constr : FStar_TypeChecker_Env.qninfo -> Prims.bool) =
-  fun q ->
-    match q with
-    | FStar_Pervasives_Native.Some
-        (FStar_Pervasives.Inr
-         ({
-            FStar_Syntax_Syntax.sigel = FStar_Syntax_Syntax.Sig_datacon
-              (uu___, uu___1, uu___2, uu___3, uu___4, uu___5);
-            FStar_Syntax_Syntax.sigrng = uu___6;
-            FStar_Syntax_Syntax.sigquals = uu___7;
-            FStar_Syntax_Syntax.sigmeta = uu___8;
-            FStar_Syntax_Syntax.sigattrs = uu___9;
-            FStar_Syntax_Syntax.sigopts = uu___10;_},
-          uu___11),
-         uu___12)
-        -> true
-    | uu___ -> false
-let (translate_univ :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe)
-  =
-  fun cfg ->
-    fun bs ->
-      fun u ->
-        let rec aux u1 =
-          let u2 = FStar_Syntax_Subst.compress_univ u1 in
-          match u2 with
-          | FStar_Syntax_Syntax.U_bvar i ->
-              if i < (FStar_Compiler_List.length bs)
-              then let u' = FStar_Compiler_List.nth bs i in un_univ u'
-              else
-                if
-                  ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.allow_unbound_universes
-                then FStar_Syntax_Syntax.U_zero
-                else failwith "Universe index out of bounds"
-          | FStar_Syntax_Syntax.U_succ u3 ->
-              let uu___ = aux u3 in FStar_Syntax_Syntax.U_succ uu___
-          | FStar_Syntax_Syntax.U_max us ->
-              let uu___ = FStar_Compiler_List.map aux us in
-              FStar_Syntax_Syntax.U_max uu___
-          | FStar_Syntax_Syntax.U_unknown -> u2
-          | FStar_Syntax_Syntax.U_name uu___ -> u2
-          | FStar_Syntax_Syntax.U_unif uu___ -> u2
-          | FStar_Syntax_Syntax.U_zero -> u2 in
-        aux u
-let (find_let :
-  FStar_Syntax_Syntax.letbinding Prims.list ->
-    FStar_Syntax_Syntax.fv ->
-      FStar_Syntax_Syntax.letbinding FStar_Pervasives_Native.option)
-  =
-  fun lbs ->
-    fun fvar ->
-      FStar_Compiler_Util.find_map lbs
-        (fun lb ->
-           match lb.FStar_Syntax_Syntax.lbname with
-           | FStar_Pervasives.Inl uu___ -> failwith "find_let : impossible"
-           | FStar_Pervasives.Inr name ->
-               let uu___ = FStar_Syntax_Syntax.fv_eq name fvar in
-               if uu___
-               then FStar_Pervasives_Native.Some lb
-               else FStar_Pervasives_Native.None)
-let (mk_rt :
-  FStar_Compiler_Range.range ->
-    FStar_TypeChecker_NBETerm.t' -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun r ->
-    fun t ->
-      {
-        FStar_TypeChecker_NBETerm.nbe_t = t;
-        FStar_TypeChecker_NBETerm.nbe_r = r
-      }
-let (mk_t : FStar_TypeChecker_NBETerm.t' -> FStar_TypeChecker_NBETerm.t) =
-  fun t ->
-    {
-      FStar_TypeChecker_NBETerm.nbe_t = t;
-      FStar_TypeChecker_NBETerm.nbe_r = FStar_Compiler_Range.dummyRange
-    }
-let rec (translate :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.term -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun cfg ->
-    fun bs ->
-      fun e ->
-        let debug1 = debug cfg in
-        let mk_t1 t = mk_rt e.FStar_Syntax_Syntax.pos t in
-        debug1
-          (fun uu___1 ->
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Subst.compress e in
-               FStar_Syntax_Print.tag_of_term uu___3 in
-             let uu___3 =
-               let uu___4 = FStar_Syntax_Subst.compress e in
-               FStar_Syntax_Print.term_to_string uu___4 in
-             FStar_Compiler_Util.print2 "Term: %s - %s\n" uu___2 uu___3);
-        (let uu___1 =
-           let uu___2 = FStar_Syntax_Subst.compress e in
-           uu___2.FStar_Syntax_Syntax.n in
-         match uu___1 with
-         | FStar_Syntax_Syntax.Tm_delayed (uu___2, uu___3) ->
-             failwith "Tm_delayed: Impossible"
-         | FStar_Syntax_Syntax.Tm_unknown ->
-             mk_t1 FStar_TypeChecker_NBETerm.Unknown
-         | FStar_Syntax_Syntax.Tm_constant c ->
-             let uu___2 =
-               let uu___3 = translate_constant c in
-               FStar_TypeChecker_NBETerm.Constant uu___3 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2
-         | FStar_Syntax_Syntax.Tm_bvar db ->
-             if
-               db.FStar_Syntax_Syntax.index < (FStar_Compiler_List.length bs)
-             then
-               let t =
-                 FStar_Compiler_List.nth bs db.FStar_Syntax_Syntax.index in
-               (debug1
-                  (fun uu___3 ->
-                     let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Compiler_List.map
-                           FStar_TypeChecker_NBETerm.t_to_string bs in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___6
-                         (FStar_String.concat "; ") in
-                     FStar_Compiler_Util.print2
-                       "Resolved bvar to %s\n\tcontext is [%s]\n" uu___4
-                       uu___5);
-                t)
-             else failwith "de Bruijn index out of bounds"
-         | FStar_Syntax_Syntax.Tm_uinst (t, us) ->
-             (debug1
-                (fun uu___3 ->
-                   let uu___4 = FStar_Syntax_Print.term_to_string t in
-                   let uu___5 =
-                     let uu___6 =
-                       FStar_Compiler_List.map
-                         FStar_Syntax_Print.univ_to_string us in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___6
-                       (FStar_String.concat ", ") in
-                   FStar_Compiler_Util.print2 "Uinst term : %s\nUnivs : %s\n"
-                     uu___4 uu___5);
-              (let uu___3 = translate cfg bs t in
-               let uu___4 =
-                 FStar_Compiler_List.map
-                   (fun x ->
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 = translate_univ cfg bs x in
-                          FStar_TypeChecker_NBETerm.Univ uu___7 in
-                        FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___6 in
-                      FStar_TypeChecker_NBETerm.as_arg uu___5) us in
-               iapp cfg uu___3 uu___4))
-         | FStar_Syntax_Syntax.Tm_type u ->
-             let uu___2 =
-               let uu___3 = translate_univ cfg bs u in
-               FStar_TypeChecker_NBETerm.Type_t uu___3 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2
-         | FStar_Syntax_Syntax.Tm_arrow (xs, c) ->
-             let norm uu___2 =
-               let uu___3 =
-                 FStar_Compiler_List.fold_left
-                   (fun uu___4 ->
-                      fun b ->
-                        match uu___4 with
-                        | (ctx, binders_rev) ->
-                            let x = b.FStar_Syntax_Syntax.binder_bv in
-                            let t =
-                              let uu___5 =
-                                translate cfg ctx x.FStar_Syntax_Syntax.sort in
-                              readback cfg uu___5 in
-                            let x1 =
-                              let uu___5 = FStar_Syntax_Syntax.freshen_bv x in
-                              {
-                                FStar_Syntax_Syntax.ppname =
-                                  (uu___5.FStar_Syntax_Syntax.ppname);
-                                FStar_Syntax_Syntax.index =
-                                  (uu___5.FStar_Syntax_Syntax.index);
-                                FStar_Syntax_Syntax.sort = t
-                              } in
-                            let ctx1 =
-                              let uu___5 =
-                                FStar_TypeChecker_NBETerm.mkAccuVar x1 in
-                              uu___5 :: ctx in
-                            (ctx1,
-                              ({
-                                 FStar_Syntax_Syntax.binder_bv = x1;
-                                 FStar_Syntax_Syntax.binder_qual =
-                                   (b.FStar_Syntax_Syntax.binder_qual);
-                                 FStar_Syntax_Syntax.binder_attrs =
-                                   (b.FStar_Syntax_Syntax.binder_attrs)
-                               } :: binders_rev))) (bs, []) xs in
-               match uu___3 with
-               | (ctx, binders_rev) ->
-                   let c1 =
-                     let uu___4 = translate_comp cfg ctx c in
-                     readback_comp cfg uu___4 in
-                   FStar_Syntax_Util.arrow
-                     (FStar_Compiler_List.rev binders_rev) c1 in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Thunk.mk norm in
-                 FStar_Pervasives.Inl uu___4 in
-               FStar_TypeChecker_NBETerm.Arrow uu___3 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2
-         | FStar_Syntax_Syntax.Tm_refine (bv, tm) ->
-             if
-               ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                 ||
-                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unrefine
-             then translate cfg bs bv.FStar_Syntax_Syntax.sort
-             else
-               FStar_Compiler_Effect.op_Less_Bar mk_t1
-                 (FStar_TypeChecker_NBETerm.Refinement
-                    ((fun y -> translate cfg (y :: bs) tm),
-                      (fun uu___3 ->
-                         let uu___4 =
-                           translate cfg bs bv.FStar_Syntax_Syntax.sort in
-                         FStar_TypeChecker_NBETerm.as_arg uu___4)))
-         | FStar_Syntax_Syntax.Tm_ascribed (t, uu___2, uu___3) ->
-             translate cfg bs t
-         | FStar_Syntax_Syntax.Tm_uvar (u, (subst, set_use_range)) ->
-             let norm_uvar uu___2 =
-               let norm_subst_elt uu___3 =
-                 match uu___3 with
-                 | FStar_Syntax_Syntax.NT (x, t) ->
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 = translate cfg bs t in
-                         readback cfg uu___6 in
-                       (x, uu___5) in
-                     FStar_Syntax_Syntax.NT uu___4
-                 | FStar_Syntax_Syntax.NM (x, i) ->
-                     let x_i =
-                       FStar_Syntax_Syntax.bv_to_tm
-                         {
-                           FStar_Syntax_Syntax.ppname =
-                             (x.FStar_Syntax_Syntax.ppname);
-                           FStar_Syntax_Syntax.index = i;
-                           FStar_Syntax_Syntax.sort =
-                             (x.FStar_Syntax_Syntax.sort)
-                         } in
-                     let t =
-                       let uu___4 = translate cfg bs x_i in
-                       readback cfg uu___4 in
-                     (match t.FStar_Syntax_Syntax.n with
-                      | FStar_Syntax_Syntax.Tm_bvar x_j ->
-                          FStar_Syntax_Syntax.NM
-                            (x, (x_j.FStar_Syntax_Syntax.index))
-                      | uu___4 -> FStar_Syntax_Syntax.NT (x, t))
-                 | uu___4 ->
-                     failwith "Impossible: subst invariant of uvar nodes" in
-               let subst1 =
-                 FStar_Compiler_List.map
-                   (FStar_Compiler_List.map norm_subst_elt) subst in
-               {
-                 FStar_Syntax_Syntax.n =
-                   (FStar_Syntax_Syntax.Tm_uvar (u, (subst1, set_use_range)));
-                 FStar_Syntax_Syntax.pos = (e.FStar_Syntax_Syntax.pos);
-                 FStar_Syntax_Syntax.vars = (e.FStar_Syntax_Syntax.vars);
-                 FStar_Syntax_Syntax.hash_code =
-                   (e.FStar_Syntax_Syntax.hash_code)
-               } in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = FStar_Thunk.mk norm_uvar in
-                   FStar_TypeChecker_NBETerm.UVar uu___5 in
-                 (uu___4, []) in
-               FStar_TypeChecker_NBETerm.Accu uu___3 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2
-         | FStar_Syntax_Syntax.Tm_name x ->
-             FStar_TypeChecker_NBETerm.mkAccuVar x
-         | FStar_Syntax_Syntax.Tm_abs ([], uu___2, uu___3) ->
-             failwith "Impossible: abstraction with no binders"
-         | FStar_Syntax_Syntax.Tm_abs (xs, body, resc) ->
-             FStar_Compiler_Effect.op_Less_Bar mk_t1
-               (FStar_TypeChecker_NBETerm.Lam
-                  ((fun ys ->
-                      let uu___2 =
-                        let uu___3 =
-                          FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                            ys in
-                        FStar_Compiler_List.append uu___3 bs in
-                      translate cfg uu___2 body),
-                    (FStar_Pervasives.Inl (bs, xs, resc)),
-                    (FStar_Compiler_List.length xs)))
-         | FStar_Syntax_Syntax.Tm_fvar fvar ->
-             let uu___2 = try_in_cache cfg fvar in
-             (match uu___2 with
-              | FStar_Pervasives_Native.Some t -> t
-              | uu___3 ->
-                  let uu___4 =
-                    FStar_Syntax_Syntax.set_range_of_fv fvar
-                      e.FStar_Syntax_Syntax.pos in
-                  translate_fv cfg bs uu___4)
-         | FStar_Syntax_Syntax.Tm_app
-             ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                  (FStar_Const.Const_reify);
-                FStar_Syntax_Syntax.pos = uu___2;
-                FStar_Syntax_Syntax.vars = uu___3;
-                FStar_Syntax_Syntax.hash_code = uu___4;_},
-              arg::more::args)
-             ->
-             let uu___5 = FStar_Syntax_Util.head_and_args e in
-             (match uu___5 with
-              | (head, uu___6) ->
-                  let head1 =
-                    FStar_Syntax_Syntax.mk_Tm_app head [arg]
-                      e.FStar_Syntax_Syntax.pos in
-                  let uu___7 =
-                    FStar_Syntax_Syntax.mk_Tm_app head1 (more :: args)
-                      e.FStar_Syntax_Syntax.pos in
-                  translate cfg bs uu___7)
-         | FStar_Syntax_Syntax.Tm_app
-             ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                  (FStar_Const.Const_reflect uu___2);
-                FStar_Syntax_Syntax.pos = uu___3;
-                FStar_Syntax_Syntax.vars = uu___4;
-                FStar_Syntax_Syntax.hash_code = uu___5;_},
-              arg::more::args)
-             ->
-             let uu___6 = FStar_Syntax_Util.head_and_args e in
-             (match uu___6 with
-              | (head, uu___7) ->
-                  let head1 =
-                    FStar_Syntax_Syntax.mk_Tm_app head [arg]
-                      e.FStar_Syntax_Syntax.pos in
-                  let uu___8 =
-                    FStar_Syntax_Syntax.mk_Tm_app head1 (more :: args)
-                      e.FStar_Syntax_Syntax.pos in
-                  translate cfg bs uu___8)
-         | FStar_Syntax_Syntax.Tm_app
-             ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                  (FStar_Const.Const_reflect uu___2);
-                FStar_Syntax_Syntax.pos = uu___3;
-                FStar_Syntax_Syntax.vars = uu___4;
-                FStar_Syntax_Syntax.hash_code = uu___5;_},
-              arg::[])
-             when (cfg.core_cfg).FStar_TypeChecker_Cfg.reifying ->
-             let cfg1 = reifying_false cfg in
-             translate cfg1 bs (FStar_Pervasives_Native.fst arg)
-         | FStar_Syntax_Syntax.Tm_app
-             ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                  (FStar_Const.Const_reflect uu___2);
-                FStar_Syntax_Syntax.pos = uu___3;
-                FStar_Syntax_Syntax.vars = uu___4;
-                FStar_Syntax_Syntax.hash_code = uu___5;_},
-              arg::[])
-             ->
-             let uu___6 =
-               let uu___7 =
-                 translate cfg bs (FStar_Pervasives_Native.fst arg) in
-               FStar_TypeChecker_NBETerm.Reflect uu___7 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___6
-         | FStar_Syntax_Syntax.Tm_app
-             ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                  (FStar_Const.Const_reify);
-                FStar_Syntax_Syntax.pos = uu___2;
-                FStar_Syntax_Syntax.vars = uu___3;
-                FStar_Syntax_Syntax.hash_code = uu___4;_},
-              arg::[])
-             when
-             ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.reify_
-             ->
-             let cfg1 = reifying_true cfg in
-             translate cfg1 bs (FStar_Pervasives_Native.fst arg)
-         | FStar_Syntax_Syntax.Tm_app
-             ({
-                FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                  (FStar_Const.Const_reflect uu___2);
-                FStar_Syntax_Syntax.pos = uu___3;
-                FStar_Syntax_Syntax.vars = uu___4;
-                FStar_Syntax_Syntax.hash_code = uu___5;_},
-              arg::[])
-             ->
-             let uu___6 =
-               let uu___7 =
-                 translate cfg bs (FStar_Pervasives_Native.fst arg) in
-               FStar_TypeChecker_NBETerm.Reflect uu___7 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___6
-         | FStar_Syntax_Syntax.Tm_app
-             ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                FStar_Syntax_Syntax.pos = uu___2;
-                FStar_Syntax_Syntax.vars = uu___3;
-                FStar_Syntax_Syntax.hash_code = uu___4;_},
-              uu___5::[])
-             when
-             (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.assert_lid)
-               ||
-               (FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.assert_norm_lid)
-             ->
-             (debug1
-                (fun uu___7 ->
-                   FStar_Compiler_Util.print_string "Eliminated assertion\n");
-              mk_t1
-                (FStar_TypeChecker_NBETerm.Constant
-                   FStar_TypeChecker_NBETerm.Unit))
-         | FStar_Syntax_Syntax.Tm_app (head, args) when
-             ((let uu___2 = FStar_TypeChecker_Cfg.cfg_env cfg.core_cfg in
-               uu___2.FStar_TypeChecker_Env.erase_erasable_args) ||
-                ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction)
-               ||
-               ((cfg.core_cfg).FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.erase_erasable_args
-             ->
-             let uu___2 = translate cfg bs head in
-             let uu___3 =
-               FStar_Compiler_List.map
-                 (fun x ->
-                    let uu___4 =
-                      FStar_Syntax_Util.aqual_is_erasable
-                        (FStar_Pervasives_Native.snd x) in
-                    if uu___4
-                    then
-                      (debug1
-                         (fun uu___6 ->
-                            let uu___7 =
-                              FStar_Syntax_Print.term_to_string
-                                (FStar_Pervasives_Native.fst x) in
-                            FStar_Compiler_Util.print1 "Erasing %s\n" uu___7);
-                       ((mk_t1
-                           (FStar_TypeChecker_NBETerm.Constant
-                              FStar_TypeChecker_NBETerm.Unit)),
-                         (FStar_Pervasives_Native.snd x)))
-                    else
-                      (let uu___6 =
-                         translate cfg bs (FStar_Pervasives_Native.fst x) in
-                       (uu___6, (FStar_Pervasives_Native.snd x)))) args in
-             iapp cfg uu___2 uu___3
-         | FStar_Syntax_Syntax.Tm_app (head, args) ->
-             (debug1
-                (fun uu___3 ->
-                   let uu___4 = FStar_Syntax_Print.term_to_string head in
-                   let uu___5 = FStar_Syntax_Print.args_to_string args in
-                   FStar_Compiler_Util.print2 "Application: %s @ %s\n" uu___4
-                     uu___5);
-              (let uu___3 = translate cfg bs head in
-               let uu___4 =
-                 FStar_Compiler_List.map
-                   (fun x ->
-                      let uu___5 =
-                        translate cfg bs (FStar_Pervasives_Native.fst x) in
-                      (uu___5, (FStar_Pervasives_Native.snd x))) args in
-               iapp cfg uu___3 uu___4))
-         | FStar_Syntax_Syntax.Tm_match (scrut, ret_opt, branches, rc) ->
-             let make_returns uu___2 =
-               match ret_opt with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-               | FStar_Pervasives_Native.Some (b, asc) ->
-                   let uu___3 =
-                     let x =
-                       let uu___4 =
-                         let uu___5 =
-                           translate cfg bs
-                             (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                         readback cfg uu___5 in
-                       FStar_Syntax_Syntax.new_bv
-                         FStar_Pervasives_Native.None uu___4 in
-                     let uu___4 = FStar_Syntax_Syntax.mk_binder x in
-                     let uu___5 =
-                       let uu___6 = FStar_TypeChecker_NBETerm.mkAccuVar x in
-                       uu___6 :: bs in
-                     (uu___4, uu___5) in
-                   (match uu___3 with
-                    | (b1, bs1) ->
-                        let asc1 =
-                          match asc with
-                          | (FStar_Pervasives.Inl t, tacopt, use_eq) ->
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 = translate cfg bs1 t in
-                                  readback cfg uu___6 in
-                                FStar_Pervasives.Inl uu___5 in
-                              (uu___4, tacopt, use_eq)
-                          | (FStar_Pervasives.Inr c, tacopt, use_eq) ->
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 = translate_comp cfg bs1 c in
-                                  readback_comp cfg uu___6 in
-                                FStar_Pervasives.Inr uu___5 in
-                              (uu___4, tacopt, use_eq) in
-                        let asc2 =
-                          FStar_Syntax_Subst.close_ascription [b1] asc1 in
-                        let b2 =
-                          let uu___4 = FStar_Syntax_Subst.close_binders [b1] in
-                          FStar_Compiler_List.hd uu___4 in
-                        FStar_Pervasives_Native.Some (b2, asc2)) in
-             let make_rc uu___2 =
-               match rc with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-               | FStar_Pervasives_Native.Some rc1 ->
-                   let uu___3 =
-                     let uu___4 = translate_residual_comp cfg bs rc1 in
-                     readback_residual_comp cfg uu___4 in
-                   FStar_Pervasives_Native.Some uu___3 in
-             let make_branches uu___2 =
-               let cfg1 = zeta_false cfg in
-               let rec process_pattern bs1 p =
-                 let uu___3 =
-                   match p.FStar_Syntax_Syntax.v with
-                   | FStar_Syntax_Syntax.Pat_constant c ->
-                       (bs1, (FStar_Syntax_Syntax.Pat_constant c))
-                   | FStar_Syntax_Syntax.Pat_cons (fvar, us_opt, args) ->
-                       let uu___4 =
-                         FStar_Compiler_List.fold_left
-                           (fun uu___5 ->
-                              fun uu___6 ->
-                                match (uu___5, uu___6) with
-                                | ((bs2, args1), (arg, b)) ->
-                                    let uu___7 = process_pattern bs2 arg in
-                                    (match uu___7 with
-                                     | (bs', arg') ->
-                                         (bs', ((arg', b) :: args1))))
-                           (bs1, []) args in
-                       (match uu___4 with
-                        | (bs', args') ->
-                            let us_opt1 =
-                              match us_opt with
-                              | FStar_Pervasives_Native.None ->
-                                  FStar_Pervasives_Native.None
-                              | FStar_Pervasives_Native.Some us ->
-                                  let uu___5 =
-                                    FStar_Compiler_List.map
-                                      (translate_univ cfg1 bs1) us in
-                                  FStar_Pervasives_Native.Some uu___5 in
-                            (bs',
-                              (FStar_Syntax_Syntax.Pat_cons
-                                 (fvar, us_opt1,
-                                   (FStar_Compiler_List.rev args')))))
-                   | FStar_Syntax_Syntax.Pat_var bvar ->
-                       let x =
-                         let uu___4 =
-                           let uu___5 =
-                             translate cfg1 bs1 bvar.FStar_Syntax_Syntax.sort in
-                           readback cfg1 uu___5 in
-                         FStar_Syntax_Syntax.new_bv
-                           FStar_Pervasives_Native.None uu___4 in
-                       let uu___4 =
-                         let uu___5 = FStar_TypeChecker_NBETerm.mkAccuVar x in
-                         uu___5 :: bs1 in
-                       (uu___4, (FStar_Syntax_Syntax.Pat_var x))
-                   | FStar_Syntax_Syntax.Pat_wild bvar ->
-                       let x =
-                         let uu___4 =
-                           let uu___5 =
-                             translate cfg1 bs1 bvar.FStar_Syntax_Syntax.sort in
-                           readback cfg1 uu___5 in
-                         FStar_Syntax_Syntax.new_bv
-                           FStar_Pervasives_Native.None uu___4 in
-                       let uu___4 =
-                         let uu___5 = FStar_TypeChecker_NBETerm.mkAccuVar x in
-                         uu___5 :: bs1 in
-                       (uu___4, (FStar_Syntax_Syntax.Pat_wild x))
-                   | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-                       let uu___4 =
-                         let uu___5 =
-                           FStar_Compiler_Util.map_option
-                             (fun e1 ->
-                                let uu___6 = translate cfg1 bs1 e1 in
-                                readback cfg1 uu___6) eopt in
-                         FStar_Syntax_Syntax.Pat_dot_term uu___5 in
-                       (bs1, uu___4) in
-                 match uu___3 with
-                 | (bs2, p_new) ->
-                     (bs2,
-                       {
-                         FStar_Syntax_Syntax.v = p_new;
-                         FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                       }) in
-               FStar_Compiler_List.map
-                 (fun uu___3 ->
-                    match uu___3 with
-                    | (pat, when_clause, e1) ->
-                        let uu___4 = process_pattern bs pat in
-                        (match uu___4 with
-                         | (bs', pat') ->
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 = translate cfg1 bs' e1 in
-                                 readback cfg1 uu___7 in
-                               (pat', when_clause, uu___6) in
-                             FStar_Syntax_Util.branch uu___5)) branches in
-             let scrut1 = translate cfg bs scrut in
-             (debug1
-                (fun uu___3 ->
-                   let uu___4 =
-                     FStar_Compiler_Range.string_of_range
-                       e.FStar_Syntax_Syntax.pos in
-                   let uu___5 = FStar_Syntax_Print.term_to_string e in
-                   FStar_Compiler_Util.print2 "%s: Translating match %s\n"
-                     uu___4 uu___5);
-              (let scrut2 = unlazy_unmeta scrut1 in
-               match scrut2.FStar_TypeChecker_NBETerm.nbe_t with
-               | FStar_TypeChecker_NBETerm.Construct (c, us, args) ->
-                   (debug1
-                      (fun uu___4 ->
-                         let uu___5 =
-                           let uu___6 =
-                             FStar_Compiler_Effect.op_Bar_Greater args
-                               (FStar_Compiler_List.map
-                                  (fun uu___7 ->
-                                     match uu___7 with
-                                     | (x, q) ->
-                                         let uu___8 =
-                                           FStar_TypeChecker_NBETerm.t_to_string
-                                             x in
-                                         Prims.op_Hat
-                                           (if FStar_Compiler_Util.is_some q
-                                            then "#"
-                                            else "") uu___8)) in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___6
-                             (FStar_String.concat "; ") in
-                         FStar_Compiler_Util.print1 "Match args: %s\n" uu___5);
-                    (let uu___4 = pickBranch cfg scrut2 branches in
-                     match uu___4 with
-                     | FStar_Pervasives_Native.Some (branch, args1) ->
-                         let uu___5 =
-                           FStar_Compiler_List.fold_left
-                             (fun bs1 -> fun x -> x :: bs1) bs args1 in
-                         translate cfg uu___5 branch
-                     | FStar_Pervasives_Native.None ->
-                         FStar_TypeChecker_NBETerm.mkAccuMatch scrut2
-                           make_returns make_branches make_rc))
-               | FStar_TypeChecker_NBETerm.Constant c ->
-                   (debug1
-                      (fun uu___4 ->
-                         let uu___5 =
-                           FStar_TypeChecker_NBETerm.t_to_string scrut2 in
-                         FStar_Compiler_Util.print1 "Match constant : %s\n"
-                           uu___5);
-                    (let uu___4 = pickBranch cfg scrut2 branches in
-                     match uu___4 with
-                     | FStar_Pervasives_Native.Some (branch, []) ->
-                         translate cfg bs branch
-                     | FStar_Pervasives_Native.Some (branch, arg::[]) ->
-                         translate cfg (arg :: bs) branch
-                     | FStar_Pervasives_Native.None ->
-                         FStar_TypeChecker_NBETerm.mkAccuMatch scrut2
-                           make_returns make_branches make_rc
-                     | FStar_Pervasives_Native.Some (uu___5, hd::tl) ->
-                         failwith
-                           "Impossible: Matching on constants cannot bind more than one variable"))
-               | uu___3 ->
-                   FStar_TypeChecker_NBETerm.mkAccuMatch scrut2 make_returns
-                     make_branches make_rc))
-         | FStar_Syntax_Syntax.Tm_meta
-             (e1, FStar_Syntax_Syntax.Meta_monadic (m, t)) when
-             (cfg.core_cfg).FStar_TypeChecker_Cfg.reifying ->
-             translate_monadic (m, t) cfg bs e1
-         | FStar_Syntax_Syntax.Tm_meta
-             (e1, FStar_Syntax_Syntax.Meta_monadic_lift (m, m', t)) when
-             (cfg.core_cfg).FStar_TypeChecker_Cfg.reifying ->
-             translate_monadic_lift (m, m', t) cfg bs e1
-         | FStar_Syntax_Syntax.Tm_meta (e1, meta) ->
-             let norm_meta uu___2 =
-               let norm t =
-                 let uu___3 = translate cfg bs t in readback cfg uu___3 in
-               match meta with
-               | FStar_Syntax_Syntax.Meta_named uu___3 -> meta
-               | FStar_Syntax_Syntax.Meta_labeled uu___3 -> meta
-               | FStar_Syntax_Syntax.Meta_desugared uu___3 -> meta
-               | FStar_Syntax_Syntax.Meta_pattern (ts, args) ->
-                   let uu___3 =
-                     let uu___4 = FStar_Compiler_List.map norm ts in
-                     let uu___5 =
-                       FStar_Compiler_List.map
-                         (FStar_Compiler_List.map
-                            (fun uu___6 ->
-                               match uu___6 with
-                               | (t, a) -> let uu___7 = norm t in (uu___7, a)))
-                         args in
-                     (uu___4, uu___5) in
-                   FStar_Syntax_Syntax.Meta_pattern uu___3
-               | FStar_Syntax_Syntax.Meta_monadic (m, t) ->
-                   let uu___3 = let uu___4 = norm t in (m, uu___4) in
-                   FStar_Syntax_Syntax.Meta_monadic uu___3
-               | FStar_Syntax_Syntax.Meta_monadic_lift (m0, m1, t) ->
-                   let uu___3 = let uu___4 = norm t in (m0, m1, uu___4) in
-                   FStar_Syntax_Syntax.Meta_monadic_lift uu___3 in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = translate cfg bs e1 in
-                 let uu___5 = FStar_Thunk.mk norm_meta in (uu___4, uu___5) in
-               FStar_TypeChecker_NBETerm.Meta uu___3 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2
-         | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-             let uu___2 =
-               FStar_TypeChecker_Cfg.should_reduce_local_let cfg.core_cfg lb in
-             if uu___2
-             then
-               let uu___3 =
-                 (((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                    &&
-                    (FStar_Syntax_Util.is_unit lb.FStar_Syntax_Syntax.lbtyp))
-                   &&
-                   (FStar_Syntax_Util.is_pure_or_ghost_effect
-                      lb.FStar_Syntax_Syntax.lbeff) in
-               (if uu___3
-                then
-                  let bs1 =
-                    let uu___4 =
-                      let uu___5 =
-                        FStar_Syntax_Syntax.range_of_lbname
-                          lb.FStar_Syntax_Syntax.lbname in
-                      mk_rt uu___5
-                        (FStar_TypeChecker_NBETerm.Constant
-                           FStar_TypeChecker_NBETerm.Unit) in
-                    uu___4 :: bs in
-                  translate cfg bs1 body
-                else
-                  (let bs1 =
-                     let uu___5 = translate_letbinding cfg bs lb in uu___5 ::
-                       bs in
-                   translate cfg bs1 body))
-             else
-               (let def uu___4 =
-                  let uu___5 =
-                    (((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                       &&
-                       (FStar_Syntax_Util.is_unit
-                          lb.FStar_Syntax_Syntax.lbtyp))
-                      &&
-                      (FStar_Syntax_Util.is_pure_or_ghost_effect
-                         lb.FStar_Syntax_Syntax.lbeff) in
-                  if uu___5
-                  then
-                    FStar_Compiler_Effect.op_Less_Bar mk_t1
-                      (FStar_TypeChecker_NBETerm.Constant
-                         FStar_TypeChecker_NBETerm.Unit)
-                  else translate cfg bs lb.FStar_Syntax_Syntax.lbdef in
-                let typ uu___4 =
-                  translate cfg bs lb.FStar_Syntax_Syntax.lbtyp in
-                let name =
-                  let uu___4 =
-                    FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-                  FStar_Syntax_Syntax.freshen_bv uu___4 in
-                let bs1 =
-                  let uu___4 =
-                    let uu___5 = FStar_Syntax_Syntax.range_of_bv name in
-                    mk_rt uu___5
-                      (FStar_TypeChecker_NBETerm.Accu
-                         ((FStar_TypeChecker_NBETerm.Var name), [])) in
-                  uu___4 :: bs in
-                let body1 uu___4 = translate cfg bs1 body in
-                let uu___4 =
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 = FStar_Thunk.mk typ in
-                        let uu___9 = FStar_Thunk.mk def in
-                        let uu___10 = FStar_Thunk.mk body1 in
-                        (name, uu___8, uu___9, uu___10, lb) in
-                      FStar_TypeChecker_NBETerm.UnreducedLet uu___7 in
-                    (uu___6, []) in
-                  FStar_TypeChecker_NBETerm.Accu uu___5 in
-                FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___4)
-         | FStar_Syntax_Syntax.Tm_let ((_rec, lbs), body) ->
-             if
-               (Prims.op_Negation
-                  ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta)
-                 &&
-                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.pure_subterms_within_computations
-             then
-               let vars =
-                 FStar_Compiler_List.map
-                   (fun lb ->
-                      let uu___2 =
-                        FStar_Compiler_Util.left
-                          lb.FStar_Syntax_Syntax.lbname in
-                      FStar_Syntax_Syntax.freshen_bv uu___2) lbs in
-               let typs =
-                 FStar_Compiler_List.map
-                   (fun lb -> translate cfg bs lb.FStar_Syntax_Syntax.lbtyp)
-                   lbs in
-               let rec_bs =
-                 let uu___2 =
-                   FStar_Compiler_List.map
-                     (fun v ->
-                        let uu___3 =
-                          let uu___4 = FStar_Syntax_Syntax.range_of_bv v in
-                          mk_rt uu___4 in
-                        FStar_Compiler_Effect.op_Less_Bar uu___3
-                          (FStar_TypeChecker_NBETerm.Accu
-                             ((FStar_TypeChecker_NBETerm.Var v), []))) vars in
-                 FStar_Compiler_List.op_At uu___2 bs in
-               let defs =
-                 FStar_Compiler_List.map
-                   (fun lb ->
-                      translate cfg rec_bs lb.FStar_Syntax_Syntax.lbdef) lbs in
-               let body1 = translate cfg rec_bs body in
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Compiler_List.zip3 vars typs defs in
-                       (uu___6, body1, lbs) in
-                     FStar_TypeChecker_NBETerm.UnreducedLetRec uu___5 in
-                   (uu___4, []) in
-                 FStar_TypeChecker_NBETerm.Accu uu___3 in
-               FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2
-             else
-               (let uu___3 = make_rec_env lbs bs in translate cfg uu___3 body)
-         | FStar_Syntax_Syntax.Tm_quoted (qt, qi) ->
-             let close t =
-               let bvs =
-                 FStar_Compiler_List.map
-                   (fun uu___2 ->
-                      FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                        FStar_Syntax_Syntax.tun) bs in
-               let s1 =
-                 FStar_Compiler_List.mapi
-                   (fun i -> fun bv -> FStar_Syntax_Syntax.DB (i, bv)) bvs in
-               let s2 =
-                 let uu___2 = FStar_Compiler_List.zip bvs bs in
-                 FStar_Compiler_List.map
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (bv, t1) ->
-                          let uu___4 =
-                            let uu___5 = readback cfg t1 in (bv, uu___5) in
-                          FStar_Syntax_Syntax.NT uu___4) uu___2 in
-               let uu___2 = FStar_Syntax_Subst.subst s1 t in
-               FStar_Syntax_Subst.subst s2 uu___2 in
-             (match qi.FStar_Syntax_Syntax.qkind with
-              | FStar_Syntax_Syntax.Quote_dynamic ->
-                  let qt1 = close qt in
-                  FStar_Compiler_Effect.op_Less_Bar mk_t1
-                    (FStar_TypeChecker_NBETerm.Quote (qt1, qi))
-              | FStar_Syntax_Syntax.Quote_static ->
-                  let qi1 = FStar_Syntax_Syntax.on_antiquoted close qi in
-                  FStar_Compiler_Effect.op_Less_Bar mk_t1
-                    (FStar_TypeChecker_NBETerm.Quote (qt, qi1)))
-         | FStar_Syntax_Syntax.Tm_lazy li ->
-             let f uu___2 =
-               let t = FStar_Syntax_Util.unfold_lazy li in
-               debug1
-                 (fun uu___4 ->
-                    let uu___5 = FStar_Syntax_Print.term_to_string t in
-                    FStar_Compiler_Util.print1 ">> Unfolding Tm_lazy to %s\n"
-                      uu___5);
-               translate cfg bs t in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Thunk.mk f in
-                 ((FStar_Pervasives.Inl li), uu___4) in
-               FStar_TypeChecker_NBETerm.Lazy uu___3 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t1 uu___2)
-and (translate_comp :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.comp -> FStar_TypeChecker_NBETerm.comp)
-  =
-  fun cfg ->
-    fun bs ->
-      fun c ->
-        match c.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Total typ ->
-            let uu___ = translate cfg bs typ in
-            FStar_TypeChecker_NBETerm.Tot uu___
-        | FStar_Syntax_Syntax.GTotal typ ->
-            let uu___ = translate cfg bs typ in
-            FStar_TypeChecker_NBETerm.GTot uu___
-        | FStar_Syntax_Syntax.Comp ctyp ->
-            let uu___ = translate_comp_typ cfg bs ctyp in
-            FStar_TypeChecker_NBETerm.Comp uu___
-and (iapp :
-  config ->
-    FStar_TypeChecker_NBETerm.t ->
-      FStar_TypeChecker_NBETerm.args -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun cfg ->
-    fun f ->
-      fun args ->
-        let mk t = mk_rt f.FStar_TypeChecker_NBETerm.nbe_r t in
-        let uu___ =
-          let uu___1 = unlazy_unmeta f in
-          uu___1.FStar_TypeChecker_NBETerm.nbe_t in
-        match uu___ with
-        | FStar_TypeChecker_NBETerm.Lam (f1, binders, n) ->
-            let m = FStar_Compiler_List.length args in
-            if m < n
-            then
-              let arg_values_rev = FStar_Compiler_List.rev args in
-              let binders1 =
-                match binders with
-                | FStar_Pervasives.Inr raw_args ->
-                    let uu___1 = FStar_Compiler_List.splitAt m raw_args in
-                    (match uu___1 with
-                     | (uu___2, raw_args1) -> FStar_Pervasives.Inr raw_args1)
-                | FStar_Pervasives.Inl (ctx, xs, rc) ->
-                    let uu___1 = FStar_Compiler_List.splitAt m xs in
-                    (match uu___1 with
-                     | (uu___2, xs1) ->
-                         let ctx1 =
-                           let uu___3 =
-                             FStar_Compiler_List.map
-                               FStar_Pervasives_Native.fst arg_values_rev in
-                           FStar_Compiler_List.append uu___3 ctx in
-                         FStar_Pervasives.Inl (ctx1, xs1, rc)) in
-              FStar_Compiler_Effect.op_Less_Bar mk
-                (FStar_TypeChecker_NBETerm.Lam
-                   ((fun l ->
-                       f1 (FStar_Compiler_List.append l arg_values_rev)),
-                     binders1, (n - m)))
-            else
-              if m = n
-              then
-                (let arg_values_rev = FStar_Compiler_List.rev args in
-                 f1 arg_values_rev)
-              else
-                (let uu___3 = FStar_Compiler_List.splitAt n args in
-                 match uu___3 with
-                 | (args1, args') ->
-                     let uu___4 = f1 (FStar_Compiler_List.rev args1) in
-                     iapp cfg uu___4 args')
-        | FStar_TypeChecker_NBETerm.Accu (a, ts) ->
-            FStar_Compiler_Effect.op_Less_Bar mk
-              (FStar_TypeChecker_NBETerm.Accu
-                 (a, (FStar_Compiler_List.rev_append args ts)))
-        | FStar_TypeChecker_NBETerm.Construct (i, us, ts) ->
-            let rec aux args1 us1 ts1 =
-              match args1 with
-              | ({
-                   FStar_TypeChecker_NBETerm.nbe_t =
-                     FStar_TypeChecker_NBETerm.Univ u;
-                   FStar_TypeChecker_NBETerm.nbe_r = uu___1;_},
-                 uu___2)::args2 -> aux args2 (u :: us1) ts1
-              | a::args2 -> aux args2 us1 (a :: ts1)
-              | [] -> (us1, ts1) in
-            let uu___1 = aux args us ts in
-            (match uu___1 with
-             | (us', ts') ->
-                 FStar_Compiler_Effect.op_Less_Bar mk
-                   (FStar_TypeChecker_NBETerm.Construct (i, us', ts')))
-        | FStar_TypeChecker_NBETerm.FV (i, us, ts) ->
-            let rec aux args1 us1 ts1 =
-              match args1 with
-              | ({
-                   FStar_TypeChecker_NBETerm.nbe_t =
-                     FStar_TypeChecker_NBETerm.Univ u;
-                   FStar_TypeChecker_NBETerm.nbe_r = uu___1;_},
-                 uu___2)::args2 -> aux args2 (u :: us1) ts1
-              | a::args2 -> aux args2 us1 (a :: ts1)
-              | [] -> (us1, ts1) in
-            let uu___1 = aux args us ts in
-            (match uu___1 with
-             | (us', ts') ->
-                 FStar_Compiler_Effect.op_Less_Bar mk
-                   (FStar_TypeChecker_NBETerm.FV (i, us', ts')))
-        | FStar_TypeChecker_NBETerm.TopLevelLet (lb, arity, args_rev) ->
-            let args_rev1 = FStar_Compiler_List.rev_append args args_rev in
-            let n_args_rev = FStar_Compiler_List.length args_rev1 in
-            let n_univs =
-              FStar_Compiler_List.length lb.FStar_Syntax_Syntax.lbunivs in
-            (debug cfg
-               (fun uu___2 ->
-                  let uu___3 =
-                    FStar_Syntax_Print.lbname_to_string
-                      lb.FStar_Syntax_Syntax.lbname in
-                  let uu___4 = FStar_Compiler_Util.string_of_int arity in
-                  let uu___5 = FStar_Compiler_Util.string_of_int n_args_rev in
-                  FStar_Compiler_Util.print3
-                    "Reached iapp for %s with arity %s and n_args = %s\n"
-                    uu___3 uu___4 uu___5);
-             if n_args_rev >= arity
-             then
-               (let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Syntax_Util.unascribe
-                        lb.FStar_Syntax_Syntax.lbdef in
-                    uu___4.FStar_Syntax_Syntax.n in
-                  match uu___3 with
-                  | FStar_Syntax_Syntax.Tm_abs (bs, body, uu___4) ->
-                      (bs, body)
-                  | uu___4 -> ([], (lb.FStar_Syntax_Syntax.lbdef)) in
-                match uu___2 with
-                | (bs, body) ->
-                    if (n_univs + (FStar_Compiler_List.length bs)) = arity
-                    then
-                      let uu___3 =
-                        FStar_Compiler_Util.first_N (n_args_rev - arity)
-                          args_rev1 in
-                      (match uu___3 with
-                       | (extra, args_rev2) ->
-                           (debug cfg
-                              (fun uu___5 ->
-                                 let uu___6 =
-                                   FStar_Syntax_Print.lbname_to_string
-                                     lb.FStar_Syntax_Syntax.lbname in
-                                 let uu___7 =
-                                   FStar_Syntax_Print.term_to_string body in
-                                 let uu___8 =
-                                   let uu___9 =
-                                     FStar_Compiler_List.map
-                                       (fun uu___10 ->
-                                          match uu___10 with
-                                          | (x, uu___11) ->
-                                              FStar_TypeChecker_NBETerm.t_to_string
-                                                x) args_rev2 in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___9 (FStar_String.concat ", ") in
-                                 FStar_Compiler_Util.print3
-                                   "Reducing body of %s = %s,\n\twith args = %s\n"
-                                   uu___6 uu___7 uu___8);
-                            (let t =
-                               let uu___5 =
-                                 FStar_Compiler_List.map
-                                   FStar_Pervasives_Native.fst args_rev2 in
-                               translate cfg uu___5 body in
-                             match extra with
-                             | [] -> t
-                             | uu___5 ->
-                                 iapp cfg t (FStar_Compiler_List.rev extra))))
-                    else
-                      (let uu___4 =
-                         FStar_Compiler_Util.first_N (n_args_rev - n_univs)
-                           args_rev1 in
-                       match uu___4 with
-                       | (extra, univs) ->
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Compiler_List.map
-                                 FStar_Pervasives_Native.fst univs in
-                             translate cfg uu___6
-                               lb.FStar_Syntax_Syntax.lbdef in
-                           iapp cfg uu___5 (FStar_Compiler_List.rev extra)))
-             else
-               FStar_Compiler_Effect.op_Less_Bar mk
-                 (FStar_TypeChecker_NBETerm.TopLevelLet
-                    (lb, arity, args_rev1)))
-        | FStar_TypeChecker_NBETerm.TopLevelRec
-            (lb, arity, decreases_list, args') ->
-            let args1 = FStar_Compiler_List.append args' args in
-            if (FStar_Compiler_List.length args1) >= arity
-            then
-              let uu___1 =
-                should_reduce_recursive_definition args1 decreases_list in
-              (match uu___1 with
-               | (should_reduce, uu___2, uu___3) ->
-                   if Prims.op_Negation should_reduce
-                   then
-                     let fv =
-                       FStar_Compiler_Util.right
-                         lb.FStar_Syntax_Syntax.lbname in
-                     (debug cfg
-                        (fun uu___5 ->
-                           let uu___6 = FStar_Syntax_Print.fv_to_string fv in
-                           FStar_Compiler_Util.print1
-                             "Decided to not unfold recursive definition %s\n"
-                             uu___6);
-                      (let uu___5 =
-                         let uu___6 = FStar_Syntax_Syntax.range_of_fv fv in
-                         mk_rt uu___6
-                           (FStar_TypeChecker_NBETerm.FV (fv, [], [])) in
-                       iapp cfg uu___5 args1))
-                   else
-                     (debug cfg
-                        (fun uu___6 ->
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_Compiler_Util.right
-                                 lb.FStar_Syntax_Syntax.lbname in
-                             FStar_Syntax_Print.fv_to_string uu___8 in
-                           FStar_Compiler_Util.print1
-                             "Yes, Decided to unfold recursive definition %s\n"
-                             uu___7);
-                      (let uu___6 =
-                         FStar_Compiler_Util.first_N
-                           (FStar_Compiler_List.length
-                              lb.FStar_Syntax_Syntax.lbunivs) args1 in
-                       match uu___6 with
-                       | (univs, rest) ->
-                           let uu___7 =
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_Compiler_List.map
-                                   FStar_Pervasives_Native.fst univs in
-                               FStar_Compiler_List.rev uu___9 in
-                             translate cfg uu___8
-                               lb.FStar_Syntax_Syntax.lbdef in
-                           iapp cfg uu___7 rest)))
-            else
-              FStar_Compiler_Effect.op_Less_Bar mk
-                (FStar_TypeChecker_NBETerm.TopLevelRec
-                   (lb, arity, decreases_list, args1))
-        | FStar_TypeChecker_NBETerm.LocalLetRec
-            (i, lb, mutual_lbs, local_env, acc_args, remaining_arity,
-             decreases_list)
-            ->
-            if remaining_arity = Prims.int_zero
-            then
-              FStar_Compiler_Effect.op_Less_Bar mk
-                (FStar_TypeChecker_NBETerm.LocalLetRec
-                   (i, lb, mutual_lbs, local_env,
-                     (FStar_Compiler_List.op_At acc_args args),
-                     remaining_arity, decreases_list))
-            else
-              (let n_args = FStar_Compiler_List.length args in
-               if n_args < remaining_arity
-               then
-                 FStar_Compiler_Effect.op_Less_Bar mk
-                   (FStar_TypeChecker_NBETerm.LocalLetRec
-                      (i, lb, mutual_lbs, local_env,
-                        (FStar_Compiler_List.op_At acc_args args),
-                        (remaining_arity - n_args), decreases_list))
-               else
-                 (let args1 = FStar_Compiler_List.op_At acc_args args in
-                  let uu___3 =
-                    should_reduce_recursive_definition args1 decreases_list in
-                  match uu___3 with
-                  | (should_reduce, uu___4, uu___5) ->
-                      if Prims.op_Negation should_reduce
-                      then
-                        FStar_Compiler_Effect.op_Less_Bar mk
-                          (FStar_TypeChecker_NBETerm.LocalLetRec
-                             (i, lb, mutual_lbs, local_env, args1,
-                               Prims.int_zero, decreases_list))
-                      else
-                        (let env = make_rec_env mutual_lbs local_env in
-                         debug cfg
-                           (fun uu___8 ->
-                              (let uu___10 =
-                                 let uu___11 =
-                                   FStar_Compiler_List.map
-                                     FStar_TypeChecker_NBETerm.t_to_string
-                                     env in
-                                 FStar_String.concat ",\n\t " uu___11 in
-                               FStar_Compiler_Util.print1
-                                 "LocalLetRec Env = {\n\t%s\n}\n" uu___10);
-                              (let uu___10 =
-                                 let uu___11 =
-                                   FStar_Compiler_List.map
-                                     (fun uu___12 ->
-                                        match uu___12 with
-                                        | (t, uu___13) ->
-                                            FStar_TypeChecker_NBETerm.t_to_string
-                                              t) args1 in
-                                 FStar_String.concat ",\n\t " uu___11 in
-                               FStar_Compiler_Util.print1
-                                 "LocalLetRec Args = {\n\t%s\n}\n" uu___10));
-                         (let uu___8 =
-                            translate cfg env lb.FStar_Syntax_Syntax.lbdef in
-                          iapp cfg uu___8 args1))))
-        | FStar_TypeChecker_NBETerm.Constant
-            (FStar_TypeChecker_NBETerm.SConst (FStar_Const.Const_range_of))
-            ->
-            (match args with
-             | (a, uu___1)::[] ->
-                 mk_rt a.FStar_TypeChecker_NBETerm.nbe_r
-                   (FStar_TypeChecker_NBETerm.Constant
-                      (FStar_TypeChecker_NBETerm.Range
-                         (a.FStar_TypeChecker_NBETerm.nbe_r)))
-             | uu___1 ->
-                 let uu___2 =
-                   let uu___3 = FStar_TypeChecker_NBETerm.t_to_string f in
-                   Prims.op_Hat "NBE ill-typed application Const_range_of: "
-                     uu___3 in
-                 failwith uu___2)
-        | FStar_TypeChecker_NBETerm.Constant
-            (FStar_TypeChecker_NBETerm.SConst
-            (FStar_Const.Const_set_range_of)) ->
-            (match args with
-             | (t, uu___1)::({
-                               FStar_TypeChecker_NBETerm.nbe_t =
-                                 FStar_TypeChecker_NBETerm.Constant
-                                 (FStar_TypeChecker_NBETerm.Range r);
-                               FStar_TypeChecker_NBETerm.nbe_r = uu___2;_},
-                             uu___3)::[]
-                 ->
-                 {
-                   FStar_TypeChecker_NBETerm.nbe_t =
-                     (t.FStar_TypeChecker_NBETerm.nbe_t);
-                   FStar_TypeChecker_NBETerm.nbe_r = r
-                 }
-             | uu___1 ->
-                 let uu___2 =
-                   let uu___3 = FStar_TypeChecker_NBETerm.t_to_string f in
-                   Prims.op_Hat
-                     "NBE ill-typed application Const_set_range_of: " uu___3 in
-                 failwith uu___2)
-        | uu___1 ->
-            let uu___2 =
-              let uu___3 = FStar_TypeChecker_NBETerm.t_to_string f in
-              Prims.op_Hat "NBE ill-typed application: " uu___3 in
-            failwith uu___2
-and (translate_fv :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.fv -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun cfg ->
-    fun bs ->
-      fun fvar ->
-        let debug1 = debug cfg in
-        let qninfo =
-          let uu___ = FStar_TypeChecker_Cfg.cfg_env cfg.core_cfg in
-          let uu___1 = FStar_Syntax_Syntax.lid_of_fv fvar in
-          FStar_TypeChecker_Env.lookup_qname uu___ uu___1 in
-        let uu___ = (is_constr qninfo) || (is_constr_fv fvar) in
-        if uu___
-        then FStar_TypeChecker_NBETerm.mkConstruct fvar [] []
-        else
-          (let uu___2 =
-             FStar_TypeChecker_Normalize.should_unfold cfg.core_cfg
-               (fun uu___3 -> (cfg.core_cfg).FStar_TypeChecker_Cfg.reifying)
-               fvar qninfo in
-           match uu___2 with
-           | FStar_TypeChecker_Normalize.Should_unfold_fully ->
-               failwith "Not yet handled"
-           | FStar_TypeChecker_Normalize.Should_unfold_no ->
-               (debug1
-                  (fun uu___4 ->
-                     let uu___5 = FStar_Syntax_Print.fv_to_string fvar in
-                     FStar_Compiler_Util.print1
-                       "(1) Decided to not unfold %s\n" uu___5);
-                (let uu___4 =
-                   FStar_TypeChecker_Cfg.find_prim_step cfg.core_cfg fvar in
-                 match uu___4 with
-                 | FStar_Pervasives_Native.Some prim_step when
-                     prim_step.FStar_TypeChecker_Cfg.strong_reduction_ok ->
-                     let arity =
-                       prim_step.FStar_TypeChecker_Cfg.arity +
-                         prim_step.FStar_TypeChecker_Cfg.univ_arity in
-                     (debug1
-                        (fun uu___6 ->
-                           let uu___7 = FStar_Syntax_Print.fv_to_string fvar in
-                           FStar_Compiler_Util.print1 "Found a primop %s\n"
-                             uu___7);
-                      (let uu___6 =
-                         let uu___7 =
-                           let uu___8 =
-                             let f uu___9 =
-                               let uu___10 =
-                                 FStar_Syntax_Syntax.new_bv
-                                   FStar_Pervasives_Native.None
-                                   FStar_Syntax_Syntax.t_unit in
-                               FStar_Syntax_Syntax.mk_binder uu___10 in
-                             let uu___9 =
-                               let uu___10 = FStar_Common.tabulate arity f in
-                               ([], uu___10, FStar_Pervasives_Native.None) in
-                             FStar_Pervasives.Inl uu___9 in
-                           ((fun args_rev ->
-                               let args' = FStar_Compiler_List.rev args_rev in
-                               let callbacks =
-                                 {
-                                   FStar_TypeChecker_NBETerm.iapp =
-                                     (iapp cfg);
-                                   FStar_TypeChecker_NBETerm.translate =
-                                     (translate cfg bs)
-                                 } in
-                               debug1
-                                 (fun uu___10 ->
-                                    let uu___11 =
-                                      let uu___12 =
-                                        FStar_Compiler_List.map
-                                          (fun uu___13 ->
-                                             match uu___13 with
-                                             | (x, uu___14) ->
-                                                 FStar_TypeChecker_NBETerm.t_to_string
-                                                   x) args' in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___12 (FStar_String.concat "; ") in
-                                    FStar_Compiler_Util.print1
-                                      "Caling primop with args = [%s]\n"
-                                      uu___11);
-                               (let uu___10 =
-                                  FStar_Compiler_List.span
-                                    (fun uu___11 ->
-                                       match uu___11 with
-                                       | ({
-                                            FStar_TypeChecker_NBETerm.nbe_t =
-                                              FStar_TypeChecker_NBETerm.Univ
-                                              uu___12;
-                                            FStar_TypeChecker_NBETerm.nbe_r =
-                                              uu___13;_},
-                                          uu___14) -> true
-                                       | uu___12 -> false) args' in
-                                match uu___10 with
-                                | (univs, rest) ->
-                                    let univs1 =
-                                      FStar_Compiler_List.map
-                                        (fun uu___11 ->
-                                           match uu___11 with
-                                           | ({
-                                                FStar_TypeChecker_NBETerm.nbe_t
-                                                  =
-                                                  FStar_TypeChecker_NBETerm.Univ
-                                                  u;
-                                                FStar_TypeChecker_NBETerm.nbe_r
-                                                  = uu___12;_},
-                                              uu___13) -> u
-                                           | uu___12 -> failwith "Impossible")
-                                        univs in
-                                    let uu___11 =
-                                      prim_step.FStar_TypeChecker_Cfg.interpretation_nbe
-                                        callbacks univs1 rest in
-                                    (match uu___11 with
-                                     | FStar_Pervasives_Native.Some x ->
-                                         (debug1
-                                            (fun uu___13 ->
-                                               let uu___14 =
-                                                 FStar_Syntax_Print.fv_to_string
-                                                   fvar in
-                                               let uu___15 =
-                                                 FStar_TypeChecker_NBETerm.t_to_string
-                                                   x in
-                                               FStar_Compiler_Util.print2
-                                                 "Primitive operator %s returned %s\n"
-                                                 uu___14 uu___15);
-                                          x)
-                                     | FStar_Pervasives_Native.None ->
-                                         (debug1
-                                            (fun uu___13 ->
-                                               let uu___14 =
-                                                 FStar_Syntax_Print.fv_to_string
-                                                   fvar in
-                                               FStar_Compiler_Util.print1
-                                                 "Primitive operator %s failed\n"
-                                                 uu___14);
-                                          (let uu___13 =
-                                             FStar_TypeChecker_NBETerm.mkFV
-                                               fvar [] [] in
-                                           iapp cfg uu___13 args'))))),
-                             uu___8, arity) in
-                         FStar_TypeChecker_NBETerm.Lam uu___7 in
-                       FStar_Compiler_Effect.op_Less_Bar mk_t uu___6))
-                 | FStar_Pervasives_Native.Some uu___5 ->
-                     (debug1
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fvar in
-                           FStar_Compiler_Util.print1
-                             "(2) Decided to not unfold %s\n" uu___8);
-                      FStar_TypeChecker_NBETerm.mkFV fvar [] [])
-                 | uu___5 ->
-                     (debug1
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fvar in
-                           FStar_Compiler_Util.print1
-                             "(3) Decided to not unfold %s\n" uu___8);
-                      FStar_TypeChecker_NBETerm.mkFV fvar [] [])))
-           | FStar_TypeChecker_Normalize.Should_unfold_reify ->
-               let t =
-                 let is_qninfo_visible =
-                   let uu___3 =
-                     FStar_TypeChecker_Env.lookup_definition_qninfo
-                       (cfg.core_cfg).FStar_TypeChecker_Cfg.delta_level
-                       (fvar.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                       qninfo in
-                   FStar_Compiler_Option.isSome uu___3 in
-                 if is_qninfo_visible
-                 then
-                   match qninfo with
-                   | FStar_Pervasives_Native.Some
-                       (FStar_Pervasives.Inr
-                        ({
-                           FStar_Syntax_Syntax.sigel =
-                             FStar_Syntax_Syntax.Sig_let
-                             ((is_rec, lbs), names);
-                           FStar_Syntax_Syntax.sigrng = uu___3;
-                           FStar_Syntax_Syntax.sigquals = uu___4;
-                           FStar_Syntax_Syntax.sigmeta = uu___5;
-                           FStar_Syntax_Syntax.sigattrs = uu___6;
-                           FStar_Syntax_Syntax.sigopts = uu___7;_},
-                         _us_opt),
-                        _rng)
-                       ->
-                       (debug1
-                          (fun uu___9 ->
-                             let uu___10 =
-                               FStar_Syntax_Print.fv_to_string fvar in
-                             FStar_Compiler_Util.print1
-                               "(1) Decided to unfold %s\n" uu___10);
-                        (let lbm = find_let lbs fvar in
-                         match lbm with
-                         | FStar_Pervasives_Native.Some lb ->
-                             if
-                               is_rec &&
-                                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta
-                             then
-                               let uu___9 = let_rec_arity lb in
-                               (match uu___9 with
-                                | (ar, lst) ->
-                                    let uu___10 =
-                                      let uu___11 =
-                                        FStar_Syntax_Syntax.range_of_fv fvar in
-                                      mk_rt uu___11 in
-                                    FStar_Compiler_Effect.op_Less_Bar uu___10
-                                      (FStar_TypeChecker_NBETerm.TopLevelRec
-                                         (lb, ar, lst, [])))
-                             else translate_letbinding cfg bs lb
-                         | FStar_Pervasives_Native.None ->
-                             failwith "Could not find let binding"))
-                   | uu___3 ->
-                       (debug1
-                          (fun uu___5 ->
-                             let uu___6 =
-                               FStar_Syntax_Print.fv_to_string fvar in
-                             FStar_Compiler_Util.print1
-                               "(1) qninfo is None for (%s)\n" uu___6);
-                        FStar_TypeChecker_NBETerm.mkFV fvar [] [])
-                 else
-                   (debug1
-                      (fun uu___5 ->
-                         let uu___6 = FStar_Syntax_Print.fv_to_string fvar in
-                         FStar_Compiler_Util.print1
-                           "(1) qninfo is not visible at this level (%s)\n"
-                           uu___6);
-                    FStar_TypeChecker_NBETerm.mkFV fvar [] []) in
-               (cache_add cfg fvar t; t)
-           | FStar_TypeChecker_Normalize.Should_unfold_yes ->
-               let t =
-                 let is_qninfo_visible =
-                   let uu___3 =
-                     FStar_TypeChecker_Env.lookup_definition_qninfo
-                       (cfg.core_cfg).FStar_TypeChecker_Cfg.delta_level
-                       (fvar.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                       qninfo in
-                   FStar_Compiler_Option.isSome uu___3 in
-                 if is_qninfo_visible
-                 then
-                   match qninfo with
-                   | FStar_Pervasives_Native.Some
-                       (FStar_Pervasives.Inr
-                        ({
-                           FStar_Syntax_Syntax.sigel =
-                             FStar_Syntax_Syntax.Sig_let
-                             ((is_rec, lbs), names);
-                           FStar_Syntax_Syntax.sigrng = uu___3;
-                           FStar_Syntax_Syntax.sigquals = uu___4;
-                           FStar_Syntax_Syntax.sigmeta = uu___5;
-                           FStar_Syntax_Syntax.sigattrs = uu___6;
-                           FStar_Syntax_Syntax.sigopts = uu___7;_},
-                         _us_opt),
-                        _rng)
-                       ->
-                       (debug1
-                          (fun uu___9 ->
-                             let uu___10 =
-                               FStar_Syntax_Print.fv_to_string fvar in
-                             FStar_Compiler_Util.print1
-                               "(1) Decided to unfold %s\n" uu___10);
-                        (let lbm = find_let lbs fvar in
-                         match lbm with
-                         | FStar_Pervasives_Native.Some lb ->
-                             if
-                               is_rec &&
-                                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta
-                             then
-                               let uu___9 = let_rec_arity lb in
-                               (match uu___9 with
-                                | (ar, lst) ->
-                                    let uu___10 =
-                                      let uu___11 =
-                                        FStar_Syntax_Syntax.range_of_fv fvar in
-                                      mk_rt uu___11 in
-                                    FStar_Compiler_Effect.op_Less_Bar uu___10
-                                      (FStar_TypeChecker_NBETerm.TopLevelRec
-                                         (lb, ar, lst, [])))
-                             else translate_letbinding cfg bs lb
-                         | FStar_Pervasives_Native.None ->
-                             failwith "Could not find let binding"))
-                   | uu___3 ->
-                       (debug1
-                          (fun uu___5 ->
-                             let uu___6 =
-                               FStar_Syntax_Print.fv_to_string fvar in
-                             FStar_Compiler_Util.print1
-                               "(1) qninfo is None for (%s)\n" uu___6);
-                        FStar_TypeChecker_NBETerm.mkFV fvar [] [])
-                 else
-                   (debug1
-                      (fun uu___5 ->
-                         let uu___6 = FStar_Syntax_Print.fv_to_string fvar in
-                         FStar_Compiler_Util.print1
-                           "(1) qninfo is not visible at this level (%s)\n"
-                           uu___6);
-                    FStar_TypeChecker_NBETerm.mkFV fvar [] []) in
-               (cache_add cfg fvar t; t))
-and (translate_letbinding :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.letbinding -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun cfg ->
-    fun bs ->
-      fun lb ->
-        let debug1 = debug cfg in
-        let us = lb.FStar_Syntax_Syntax.lbunivs in
-        let uu___ =
-          FStar_Syntax_Util.arrow_formals lb.FStar_Syntax_Syntax.lbtyp in
-        match uu___ with
-        | (formals, uu___1) ->
-            let arity =
-              (FStar_Compiler_List.length us) +
-                (FStar_Compiler_List.length formals) in
-            if arity = Prims.int_zero
-            then translate cfg bs lb.FStar_Syntax_Syntax.lbdef
-            else
-              (let uu___3 =
-                 FStar_Compiler_Util.is_right lb.FStar_Syntax_Syntax.lbname in
-               if uu___3
-               then
-                 (debug1
-                    (fun uu___5 ->
-                       let uu___6 =
-                         FStar_Syntax_Print.lbname_to_string
-                           lb.FStar_Syntax_Syntax.lbname in
-                       let uu___7 = FStar_Compiler_Util.string_of_int arity in
-                       FStar_Compiler_Util.print2
-                         "Making TopLevelLet for %s with arity %s\n" uu___6
-                         uu___7);
-                  (let uu___5 =
-                     let uu___6 =
-                       FStar_Syntax_Syntax.range_of_lbname
-                         lb.FStar_Syntax_Syntax.lbname in
-                     mk_rt uu___6 in
-                   FStar_Compiler_Effect.op_Less_Bar uu___5
-                     (FStar_TypeChecker_NBETerm.TopLevelLet (lb, arity, []))))
-               else translate cfg bs lb.FStar_Syntax_Syntax.lbdef)
-and (mkRec :
-  Prims.int ->
-    FStar_Syntax_Syntax.letbinding ->
-      FStar_Syntax_Syntax.letbinding Prims.list ->
-        FStar_TypeChecker_NBETerm.t Prims.list -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun i ->
-    fun b ->
-      fun bs ->
-        fun env ->
-          let uu___ = let_rec_arity b in
-          match uu___ with
-          | (ar, ar_lst) ->
-              FStar_Compiler_Effect.op_Less_Bar mk_t
-                (FStar_TypeChecker_NBETerm.LocalLetRec
-                   (i, b, bs, env, [], ar, ar_lst))
-and (make_rec_env :
-  FStar_Syntax_Syntax.letbinding Prims.list ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_TypeChecker_NBETerm.t Prims.list)
-  =
-  fun all_lbs ->
-    fun all_outer_bs ->
-      let rec_bindings =
-        FStar_Compiler_List.mapi
-          (fun i -> fun lb -> mkRec i lb all_lbs all_outer_bs) all_lbs in
-      FStar_Compiler_List.rev_append rec_bindings all_outer_bs
-and (translate_constant :
-  FStar_Syntax_Syntax.sconst -> FStar_TypeChecker_NBETerm.constant) =
-  fun c ->
-    match c with
-    | FStar_Const.Const_unit -> FStar_TypeChecker_NBETerm.Unit
-    | FStar_Const.Const_bool b -> FStar_TypeChecker_NBETerm.Bool b
-    | FStar_Const.Const_int (s, FStar_Pervasives_Native.None) ->
-        let uu___ = FStar_BigInt.big_int_of_string s in
-        FStar_TypeChecker_NBETerm.Int uu___
-    | FStar_Const.Const_string (s, r) ->
-        FStar_TypeChecker_NBETerm.String (s, r)
-    | FStar_Const.Const_char c1 -> FStar_TypeChecker_NBETerm.Char c1
-    | FStar_Const.Const_range r -> FStar_TypeChecker_NBETerm.Range r
-    | uu___ -> FStar_TypeChecker_NBETerm.SConst c
-and (readback_comp :
-  config -> FStar_TypeChecker_NBETerm.comp -> FStar_Syntax_Syntax.comp) =
-  fun cfg ->
-    fun c ->
-      let c' =
-        match c with
-        | FStar_TypeChecker_NBETerm.Tot typ ->
-            let uu___ = readback cfg typ in FStar_Syntax_Syntax.Total uu___
-        | FStar_TypeChecker_NBETerm.GTot typ ->
-            let uu___ = readback cfg typ in FStar_Syntax_Syntax.GTotal uu___
-        | FStar_TypeChecker_NBETerm.Comp ctyp ->
-            let uu___ = readback_comp_typ cfg ctyp in
-            FStar_Syntax_Syntax.Comp uu___ in
-      FStar_Syntax_Syntax.mk c' FStar_Compiler_Range.dummyRange
-and (translate_comp_typ :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.comp_typ -> FStar_TypeChecker_NBETerm.comp_typ)
-  =
-  fun cfg ->
-    fun bs ->
-      fun c ->
-        let uu___ = c in
-        match uu___ with
-        | { FStar_Syntax_Syntax.comp_univs = comp_univs;
-            FStar_Syntax_Syntax.effect_name = effect_name;
-            FStar_Syntax_Syntax.result_typ = result_typ;
-            FStar_Syntax_Syntax.effect_args = effect_args;
-            FStar_Syntax_Syntax.flags = flags;_} ->
-            let uu___1 =
-              FStar_Compiler_List.map (translate_univ cfg bs) comp_univs in
-            let uu___2 = translate cfg bs result_typ in
-            let uu___3 =
-              FStar_Compiler_List.map
-                (fun x ->
-                   let uu___4 =
-                     translate cfg bs (FStar_Pervasives_Native.fst x) in
-                   (uu___4, (FStar_Pervasives_Native.snd x))) effect_args in
-            let uu___4 =
-              FStar_Compiler_List.map (translate_flag cfg bs) flags in
-            {
-              FStar_TypeChecker_NBETerm.comp_univs = uu___1;
-              FStar_TypeChecker_NBETerm.effect_name = effect_name;
-              FStar_TypeChecker_NBETerm.result_typ = uu___2;
-              FStar_TypeChecker_NBETerm.effect_args = uu___3;
-              FStar_TypeChecker_NBETerm.flags = uu___4
-            }
-and (readback_comp_typ :
-  config ->
-    FStar_TypeChecker_NBETerm.comp_typ -> FStar_Syntax_Syntax.comp_typ)
-  =
-  fun cfg ->
-    fun c ->
-      let uu___ = readback cfg c.FStar_TypeChecker_NBETerm.result_typ in
-      let uu___1 =
-        FStar_Compiler_List.map
-          (fun x ->
-             let uu___2 = readback cfg (FStar_Pervasives_Native.fst x) in
-             (uu___2, (FStar_Pervasives_Native.snd x)))
-          c.FStar_TypeChecker_NBETerm.effect_args in
-      let uu___2 =
-        FStar_Compiler_List.map (readback_flag cfg)
-          c.FStar_TypeChecker_NBETerm.flags in
-      {
-        FStar_Syntax_Syntax.comp_univs =
-          (c.FStar_TypeChecker_NBETerm.comp_univs);
-        FStar_Syntax_Syntax.effect_name =
-          (c.FStar_TypeChecker_NBETerm.effect_name);
-        FStar_Syntax_Syntax.result_typ = uu___;
-        FStar_Syntax_Syntax.effect_args = uu___1;
-        FStar_Syntax_Syntax.flags = uu___2
-      }
-and (translate_residual_comp :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.residual_comp ->
-        FStar_TypeChecker_NBETerm.residual_comp)
-  =
-  fun cfg ->
-    fun bs ->
-      fun c ->
-        let uu___ = c in
-        match uu___ with
-        | { FStar_Syntax_Syntax.residual_effect = residual_effect;
-            FStar_Syntax_Syntax.residual_typ = residual_typ;
-            FStar_Syntax_Syntax.residual_flags = residual_flags;_} ->
-            let uu___1 =
-              if
-                ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-              then FStar_Pervasives_Native.None
-              else
-                FStar_Compiler_Util.map_opt residual_typ (translate cfg bs) in
-            let uu___2 =
-              FStar_Compiler_List.map (translate_flag cfg bs) residual_flags in
-            {
-              FStar_TypeChecker_NBETerm.residual_effect = residual_effect;
-              FStar_TypeChecker_NBETerm.residual_typ = uu___1;
-              FStar_TypeChecker_NBETerm.residual_flags = uu___2
-            }
-and (readback_residual_comp :
-  config ->
-    FStar_TypeChecker_NBETerm.residual_comp ->
-      FStar_Syntax_Syntax.residual_comp)
-  =
-  fun cfg ->
-    fun c ->
-      let uu___ =
-        FStar_Compiler_Util.map_opt c.FStar_TypeChecker_NBETerm.residual_typ
-          (fun x ->
-             debug cfg
-               (fun uu___2 ->
-                  let uu___3 = FStar_TypeChecker_NBETerm.t_to_string x in
-                  FStar_Compiler_Util.print1 "Reading back residualtype %s\n"
-                    uu___3);
-             readback cfg x) in
-      let uu___1 =
-        FStar_Compiler_List.map (readback_flag cfg)
-          c.FStar_TypeChecker_NBETerm.residual_flags in
-      {
-        FStar_Syntax_Syntax.residual_effect =
-          (c.FStar_TypeChecker_NBETerm.residual_effect);
-        FStar_Syntax_Syntax.residual_typ = uu___;
-        FStar_Syntax_Syntax.residual_flags = uu___1
-      }
-and (translate_flag :
-  config ->
-    FStar_TypeChecker_NBETerm.t Prims.list ->
-      FStar_Syntax_Syntax.cflag -> FStar_TypeChecker_NBETerm.cflag)
-  =
-  fun cfg ->
-    fun bs ->
-      fun f ->
-        match f with
-        | FStar_Syntax_Syntax.TOTAL -> FStar_TypeChecker_NBETerm.TOTAL
-        | FStar_Syntax_Syntax.MLEFFECT -> FStar_TypeChecker_NBETerm.MLEFFECT
-        | FStar_Syntax_Syntax.RETURN -> FStar_TypeChecker_NBETerm.RETURN
-        | FStar_Syntax_Syntax.PARTIAL_RETURN ->
-            FStar_TypeChecker_NBETerm.PARTIAL_RETURN
-        | FStar_Syntax_Syntax.SOMETRIVIAL ->
-            FStar_TypeChecker_NBETerm.SOMETRIVIAL
-        | FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION ->
-            FStar_TypeChecker_NBETerm.TRIVIAL_POSTCONDITION
-        | FStar_Syntax_Syntax.SHOULD_NOT_INLINE ->
-            FStar_TypeChecker_NBETerm.SHOULD_NOT_INLINE
-        | FStar_Syntax_Syntax.LEMMA -> FStar_TypeChecker_NBETerm.LEMMA
-        | FStar_Syntax_Syntax.CPS -> FStar_TypeChecker_NBETerm.CPS
-        | FStar_Syntax_Syntax.DECREASES (FStar_Syntax_Syntax.Decreases_lex l)
-            ->
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater l
-                (FStar_Compiler_List.map (translate cfg bs)) in
-            FStar_TypeChecker_NBETerm.DECREASES_lex uu___
-        | FStar_Syntax_Syntax.DECREASES (FStar_Syntax_Syntax.Decreases_wf
-            (rel, e)) ->
-            let uu___ =
-              let uu___1 = translate cfg bs rel in
-              let uu___2 = translate cfg bs e in (uu___1, uu___2) in
-            FStar_TypeChecker_NBETerm.DECREASES_wf uu___
-and (readback_flag :
-  config -> FStar_TypeChecker_NBETerm.cflag -> FStar_Syntax_Syntax.cflag) =
-  fun cfg ->
-    fun f ->
-      match f with
-      | FStar_TypeChecker_NBETerm.TOTAL -> FStar_Syntax_Syntax.TOTAL
-      | FStar_TypeChecker_NBETerm.MLEFFECT -> FStar_Syntax_Syntax.MLEFFECT
-      | FStar_TypeChecker_NBETerm.RETURN -> FStar_Syntax_Syntax.RETURN
-      | FStar_TypeChecker_NBETerm.PARTIAL_RETURN ->
-          FStar_Syntax_Syntax.PARTIAL_RETURN
-      | FStar_TypeChecker_NBETerm.SOMETRIVIAL ->
-          FStar_Syntax_Syntax.SOMETRIVIAL
-      | FStar_TypeChecker_NBETerm.TRIVIAL_POSTCONDITION ->
-          FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION
-      | FStar_TypeChecker_NBETerm.SHOULD_NOT_INLINE ->
-          FStar_Syntax_Syntax.SHOULD_NOT_INLINE
-      | FStar_TypeChecker_NBETerm.LEMMA -> FStar_Syntax_Syntax.LEMMA
-      | FStar_TypeChecker_NBETerm.CPS -> FStar_Syntax_Syntax.CPS
-      | FStar_TypeChecker_NBETerm.DECREASES_lex l ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater l
-                (FStar_Compiler_List.map (readback cfg)) in
-            FStar_Syntax_Syntax.Decreases_lex uu___1 in
-          FStar_Syntax_Syntax.DECREASES uu___
-      | FStar_TypeChecker_NBETerm.DECREASES_wf (rel, e) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = readback cfg rel in
-              let uu___3 = readback cfg e in (uu___2, uu___3) in
-            FStar_Syntax_Syntax.Decreases_wf uu___1 in
-          FStar_Syntax_Syntax.DECREASES uu___
-and (translate_monadic :
-  (FStar_Syntax_Syntax.monad_name * FStar_Syntax_Syntax.term'
-    FStar_Syntax_Syntax.syntax) ->
-    config ->
-      FStar_TypeChecker_NBETerm.t Prims.list ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_TypeChecker_NBETerm.t)
-  =
-  fun uu___ ->
-    fun cfg ->
-      fun bs ->
-        fun e ->
-          match uu___ with
-          | (m, ty) ->
-              let e1 = FStar_Syntax_Util.unascribe e in
-              (match e1.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-                   let uu___1 =
-                     let uu___2 =
-                       FStar_TypeChecker_Env.norm_eff_name
-                         (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv m in
-                     FStar_TypeChecker_Env.effect_decl_opt
-                       (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv uu___2 in
-                   (match uu___1 with
-                    | FStar_Pervasives_Native.None ->
-                        let uu___2 =
-                          let uu___3 = FStar_Ident.string_of_lid m in
-                          FStar_Compiler_Util.format1
-                            "Effect declaration not found: %s" uu___3 in
-                        failwith uu___2
-                    | FStar_Pervasives_Native.Some (ed, q) ->
-                        let cfg' = reifying_false cfg in
-                        let body_lam =
-                          let body_rc =
-                            {
-                              FStar_Syntax_Syntax.residual_effect = m;
-                              FStar_Syntax_Syntax.residual_typ =
-                                (FStar_Pervasives_Native.Some ty);
-                              FStar_Syntax_Syntax.residual_flags = []
-                            } in
-                          let uu___2 =
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Compiler_Util.left
-                                      lb.FStar_Syntax_Syntax.lbname in
-                                  FStar_Syntax_Syntax.mk_binder uu___6 in
-                                [uu___5] in
-                              (uu___4, body,
-                                (FStar_Pervasives_Native.Some body_rc)) in
-                            FStar_Syntax_Syntax.Tm_abs uu___3 in
-                          FStar_Syntax_Syntax.mk uu___2
-                            body.FStar_Syntax_Syntax.pos in
-                        let maybe_range_arg =
-                          let uu___2 =
-                            FStar_Compiler_Util.for_some
-                              (FStar_Syntax_Util.attr_eq
-                                 FStar_Syntax_Util.dm4f_bind_range_attr)
-                              ed.FStar_Syntax_Syntax.eff_attrs in
-                          if uu___2
-                          then
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  FStar_TypeChecker_Cfg.embed_simple
-                                    FStar_Syntax_Embeddings.e_range
-                                    lb.FStar_Syntax_Syntax.lbpos
-                                    lb.FStar_Syntax_Syntax.lbpos in
-                                translate cfg [] uu___5 in
-                              (uu___4, FStar_Pervasives_Native.None) in
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  let uu___7 =
-                                    FStar_TypeChecker_Cfg.embed_simple
-                                      FStar_Syntax_Embeddings.e_range
-                                      body.FStar_Syntax_Syntax.pos
-                                      body.FStar_Syntax_Syntax.pos in
-                                  translate cfg [] uu___7 in
-                                (uu___6, FStar_Pervasives_Native.None) in
-                              [uu___5] in
-                            uu___3 :: uu___4
-                          else [] in
-                        let t =
-                          let uu___2 =
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      FStar_Compiler_Effect.op_Bar_Greater ed
-                                        FStar_Syntax_Util.get_bind_repr in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___7 FStar_Compiler_Util.must in
-                                  FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                    FStar_Pervasives_Native.snd in
-                                FStar_Syntax_Util.un_uinst uu___5 in
-                              translate cfg' [] uu___4 in
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  FStar_Compiler_Effect.op_Less_Bar mk_t
-                                    (FStar_TypeChecker_NBETerm.Univ
-                                       FStar_Syntax_Syntax.U_unknown) in
-                                (uu___6, FStar_Pervasives_Native.None) in
-                              let uu___6 =
-                                let uu___7 =
-                                  let uu___8 =
-                                    FStar_Compiler_Effect.op_Less_Bar mk_t
-                                      (FStar_TypeChecker_NBETerm.Univ
-                                         FStar_Syntax_Syntax.U_unknown) in
-                                  (uu___8, FStar_Pervasives_Native.None) in
-                                [uu___7] in
-                              uu___5 :: uu___6 in
-                            iapp cfg uu___3 uu___4 in
-                          let uu___3 =
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 =
-                                  translate cfg' bs
-                                    lb.FStar_Syntax_Syntax.lbtyp in
-                                (uu___6, FStar_Pervasives_Native.None) in
-                              let uu___6 =
-                                let uu___7 =
-                                  let uu___8 = translate cfg' bs ty in
-                                  (uu___8, FStar_Pervasives_Native.None) in
-                                [uu___7] in
-                              uu___5 :: uu___6 in
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 =
-                                  let uu___8 =
-                                    let uu___9 =
-                                      translate cfg bs
-                                        lb.FStar_Syntax_Syntax.lbdef in
-                                    (uu___9, FStar_Pervasives_Native.None) in
-                                  let uu___9 =
-                                    let uu___10 =
-                                      let uu___11 =
-                                        let uu___12 =
-                                          translate cfg bs body_lam in
-                                        (uu___12,
-                                          FStar_Pervasives_Native.None) in
-                                      [uu___11] in
-                                    ((mk_t FStar_TypeChecker_NBETerm.Unknown),
-                                      FStar_Pervasives_Native.None) ::
-                                      uu___10 in
-                                  uu___8 :: uu___9 in
-                                ((mk_t FStar_TypeChecker_NBETerm.Unknown),
-                                  FStar_Pervasives_Native.None) :: uu___7 in
-                              FStar_Compiler_List.op_At maybe_range_arg
-                                uu___6 in
-                            FStar_Compiler_List.op_At uu___4 uu___5 in
-                          iapp cfg uu___2 uu___3 in
-                        (debug cfg
-                           (fun uu___3 ->
-                              let uu___4 =
-                                FStar_TypeChecker_NBETerm.t_to_string t in
-                              FStar_Compiler_Util.print1
-                                "translate_monadic: %s\n" uu___4);
-                         t))
-               | FStar_Syntax_Syntax.Tm_app
-                   ({
-                      FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                        (FStar_Const.Const_reflect uu___1);
-                      FStar_Syntax_Syntax.pos = uu___2;
-                      FStar_Syntax_Syntax.vars = uu___3;
-                      FStar_Syntax_Syntax.hash_code = uu___4;_},
-                    (e2, uu___5)::[])
-                   ->
-                   let uu___6 = reifying_false cfg in translate uu___6 bs e2
-               | FStar_Syntax_Syntax.Tm_app (head, args) ->
-                   (debug cfg
-                      (fun uu___2 ->
-                         let uu___3 = FStar_Syntax_Print.term_to_string head in
-                         let uu___4 = FStar_Syntax_Print.args_to_string args in
-                         FStar_Compiler_Util.print2
-                           "translate_monadic app (%s) @ (%s)\n" uu___3
-                           uu___4);
-                    (let fallback1 uu___2 = translate cfg bs e1 in
-                     let fallback2 uu___2 =
-                       let uu___3 = reifying_false cfg in
-                       let uu___4 =
-                         FStar_Syntax_Syntax.mk
-                           (FStar_Syntax_Syntax.Tm_meta
-                              (e1,
-                                (FStar_Syntax_Syntax.Meta_monadic (m, ty))))
-                           e1.FStar_Syntax_Syntax.pos in
-                       translate uu___3 bs uu___4 in
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Util.un_uinst head in
-                       uu___3.FStar_Syntax_Syntax.n in
-                     match uu___2 with
-                     | FStar_Syntax_Syntax.Tm_fvar fv ->
-                         let lid = FStar_Syntax_Syntax.lid_of_fv fv in
-                         let qninfo =
-                           FStar_TypeChecker_Env.lookup_qname
-                             (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv lid in
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_TypeChecker_Env.is_action
-                               (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv lid in
-                           Prims.op_Negation uu___4 in
-                         if uu___3
-                         then fallback1 ()
-                         else
-                           (let uu___5 =
-                              let uu___6 =
-                                FStar_TypeChecker_Env.lookup_definition_qninfo
-                                  (cfg.core_cfg).FStar_TypeChecker_Cfg.delta_level
-                                  (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                  qninfo in
-                              FStar_Compiler_Option.isNone uu___6 in
-                            if uu___5
-                            then fallback2 ()
-                            else
-                              (let e2 =
-                                 let uu___7 = FStar_Syntax_Util.mk_reify head in
-                                 FStar_Syntax_Syntax.mk_Tm_app uu___7 args
-                                   e1.FStar_Syntax_Syntax.pos in
-                               let uu___7 = reifying_false cfg in
-                               translate uu___7 bs e2))
-                     | uu___3 -> fallback1 ()))
-               | FStar_Syntax_Syntax.Tm_match (sc, asc_opt, branches, lopt)
-                   ->
-                   let branches1 =
-                     FStar_Compiler_Effect.op_Bar_Greater branches
-                       (FStar_Compiler_List.map
-                          (fun uu___1 ->
-                             match uu___1 with
-                             | (pat, wopt, tm) ->
-                                 let uu___2 = FStar_Syntax_Util.mk_reify tm in
-                                 (pat, wopt, uu___2))) in
-                   let tm =
-                     FStar_Syntax_Syntax.mk
-                       (FStar_Syntax_Syntax.Tm_match
-                          (sc, asc_opt, branches1, lopt))
-                       e1.FStar_Syntax_Syntax.pos in
-                   let uu___1 = reifying_false cfg in translate uu___1 bs tm
-               | FStar_Syntax_Syntax.Tm_meta
-                   (t, FStar_Syntax_Syntax.Meta_monadic uu___1) ->
-                   translate_monadic (m, ty) cfg bs e1
-               | FStar_Syntax_Syntax.Tm_meta
-                   (t, FStar_Syntax_Syntax.Meta_monadic_lift
-                    (msrc, mtgt, ty'))
-                   -> translate_monadic_lift (msrc, mtgt, ty') cfg bs e1
-               | uu___1 ->
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Print.tag_of_term e1 in
-                     FStar_Compiler_Util.format1
-                       "Unexpected case in translate_monadic: %s" uu___3 in
-                   failwith uu___2)
-and (translate_monadic_lift :
-  (FStar_Syntax_Syntax.monad_name * FStar_Syntax_Syntax.monad_name *
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax) ->
-    config ->
-      FStar_TypeChecker_NBETerm.t Prims.list ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_TypeChecker_NBETerm.t)
-  =
-  fun uu___ ->
-    fun cfg ->
-      fun bs ->
-        fun e ->
-          match uu___ with
-          | (msrc, mtgt, ty) ->
-              let e1 = FStar_Syntax_Util.unascribe e in
-              let uu___1 =
-                (FStar_Syntax_Util.is_pure_effect msrc) ||
-                  (FStar_Syntax_Util.is_div_effect msrc) in
-              if uu___1
-              then
-                let ed =
-                  let uu___2 =
-                    FStar_TypeChecker_Env.norm_eff_name
-                      (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv mtgt in
-                  FStar_TypeChecker_Env.get_effect_decl
-                    (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv uu___2 in
-                let ret =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_Compiler_Effect.op_Bar_Greater ed
-                              FStar_Syntax_Util.get_return_repr in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___6
-                            FStar_Compiler_Util.must in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___5
-                          FStar_Pervasives_Native.snd in
-                      FStar_Syntax_Subst.compress uu___4 in
-                    uu___3.FStar_Syntax_Syntax.n in
-                  match uu___2 with
-                  | FStar_Syntax_Syntax.Tm_uinst (ret1, uu___3::[]) ->
-                      FStar_Syntax_Syntax.mk
-                        (FStar_Syntax_Syntax.Tm_uinst
-                           (ret1, [FStar_Syntax_Syntax.U_unknown]))
-                        e1.FStar_Syntax_Syntax.pos
-                  | uu___3 ->
-                      failwith "NYI: Reification of indexed effect (NBE)" in
-                let cfg' = reifying_false cfg in
-                let t =
-                  let uu___2 =
-                    let uu___3 = translate cfg' [] ret in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Compiler_Effect.op_Less_Bar mk_t
-                            (FStar_TypeChecker_NBETerm.Univ
-                               FStar_Syntax_Syntax.U_unknown) in
-                        (uu___6, FStar_Pervasives_Native.None) in
-                      [uu___5] in
-                    iapp cfg' uu___3 uu___4 in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = translate cfg' bs ty in
-                      (uu___5, FStar_Pervasives_Native.None) in
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 = translate cfg' bs e1 in
-                        (uu___7, FStar_Pervasives_Native.None) in
-                      [uu___6] in
-                    uu___4 :: uu___5 in
-                  iapp cfg' uu___2 uu___3 in
-                (debug cfg
-                   (fun uu___3 ->
-                      let uu___4 = FStar_TypeChecker_NBETerm.t_to_string t in
-                      FStar_Compiler_Util.print1
-                        "translate_monadic_lift(1): %s\n" uu___4);
-                 t)
-              else
-                (let uu___3 =
-                   FStar_TypeChecker_Env.monad_leq
-                     (cfg.core_cfg).FStar_TypeChecker_Cfg.tcenv msrc mtgt in
-                 match uu___3 with
-                 | FStar_Pervasives_Native.None ->
-                     let uu___4 =
-                       let uu___5 = FStar_Ident.string_of_lid msrc in
-                       let uu___6 = FStar_Ident.string_of_lid mtgt in
-                       FStar_Compiler_Util.format2
-                         "Impossible : trying to reify a lift between unrelated effects (%s and %s)"
-                         uu___5 uu___6 in
-                     failwith uu___4
-                 | FStar_Pervasives_Native.Some
-                     { FStar_TypeChecker_Env.msource = uu___4;
-                       FStar_TypeChecker_Env.mtarget = uu___5;
-                       FStar_TypeChecker_Env.mlift =
-                         { FStar_TypeChecker_Env.mlift_wp = uu___6;
-                           FStar_TypeChecker_Env.mlift_term =
-                             FStar_Pervasives_Native.None;_};
-                       FStar_TypeChecker_Env.mpath = uu___7;_}
-                     ->
-                     let uu___8 =
-                       let uu___9 = FStar_Ident.string_of_lid msrc in
-                       let uu___10 = FStar_Ident.string_of_lid mtgt in
-                       FStar_Compiler_Util.format2
-                         "Impossible : trying to reify a non-reifiable lift (from %s to %s)"
-                         uu___9 uu___10 in
-                     failwith uu___8
-                 | FStar_Pervasives_Native.Some
-                     { FStar_TypeChecker_Env.msource = uu___4;
-                       FStar_TypeChecker_Env.mtarget = uu___5;
-                       FStar_TypeChecker_Env.mlift =
-                         { FStar_TypeChecker_Env.mlift_wp = uu___6;
-                           FStar_TypeChecker_Env.mlift_term =
-                             FStar_Pervasives_Native.Some lift;_};
-                       FStar_TypeChecker_Env.mpath = uu___7;_}
-                     ->
-                     let lift_lam =
-                       let x =
-                         FStar_Syntax_Syntax.new_bv
-                           FStar_Pervasives_Native.None
-                           FStar_Syntax_Syntax.tun in
-                       let uu___8 =
-                         let uu___9 = FStar_Syntax_Syntax.mk_binder x in
-                         [uu___9] in
-                       let uu___9 =
-                         let uu___10 = FStar_Syntax_Syntax.bv_to_name x in
-                         lift FStar_Syntax_Syntax.U_unknown ty uu___10 in
-                       FStar_Syntax_Util.abs uu___8 uu___9
-                         FStar_Pervasives_Native.None in
-                     let cfg' = reifying_false cfg in
-                     let t =
-                       let uu___8 = translate cfg' [] lift_lam in
-                       let uu___9 =
-                         let uu___10 =
-                           let uu___11 = translate cfg bs e1 in
-                           (uu___11, FStar_Pervasives_Native.None) in
-                         [uu___10] in
-                       iapp cfg uu___8 uu___9 in
-                     (debug cfg
-                        (fun uu___9 ->
-                           let uu___10 =
-                             FStar_TypeChecker_NBETerm.t_to_string t in
-                           FStar_Compiler_Util.print1
-                             "translate_monadic_lift(2): %s\n" uu___10);
-                      t))
-and (readback :
-  config -> FStar_TypeChecker_NBETerm.t -> FStar_Syntax_Syntax.term) =
-  fun cfg ->
-    fun x ->
-      let debug1 = debug cfg in
-      let readback_args cfg1 args =
-        map_rev
-          (fun uu___ ->
-             match uu___ with
-             | (x1, q) -> let uu___1 = readback cfg1 x1 in (uu___1, q)) args in
-      let with_range t =
-        {
-          FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-          FStar_Syntax_Syntax.pos = (x.FStar_TypeChecker_NBETerm.nbe_r);
-          FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-          FStar_Syntax_Syntax.hash_code = (t.FStar_Syntax_Syntax.hash_code)
-        } in
-      let mk t = FStar_Syntax_Syntax.mk t x.FStar_TypeChecker_NBETerm.nbe_r in
-      debug1
-        (fun uu___1 ->
-           let uu___2 = FStar_TypeChecker_NBETerm.t_to_string x in
-           FStar_Compiler_Util.print1 "Readback: %s\n" uu___2);
-      (match x.FStar_TypeChecker_NBETerm.nbe_t with
-       | FStar_TypeChecker_NBETerm.Univ u ->
-           failwith "Readback of universes should not occur"
-       | FStar_TypeChecker_NBETerm.Unknown ->
-           FStar_Syntax_Syntax.mk FStar_Syntax_Syntax.Tm_unknown
-             x.FStar_TypeChecker_NBETerm.nbe_r
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.Unit)
-           -> with_range FStar_Syntax_Syntax.unit_const
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.Bool
-           (true)) -> with_range FStar_Syntax_Util.exp_true_bool
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.Bool
-           (false)) -> with_range FStar_Syntax_Util.exp_false_bool
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.Int i)
-           ->
-           let uu___1 =
-             let uu___2 = FStar_BigInt.string_of_big_int i in
-             FStar_Syntax_Util.exp_int uu___2 in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.String
-           (s, r)) ->
-           mk
-             (FStar_Syntax_Syntax.Tm_constant
-                (FStar_Const.Const_string (s, r)))
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.Char
-           c) ->
-           let uu___1 = FStar_Syntax_Util.exp_char c in with_range uu___1
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.Range
-           r) ->
-           FStar_TypeChecker_Cfg.embed_simple FStar_Syntax_Embeddings.e_range
-             x.FStar_TypeChecker_NBETerm.nbe_r r
-       | FStar_TypeChecker_NBETerm.Constant (FStar_TypeChecker_NBETerm.SConst
-           c) -> mk (FStar_Syntax_Syntax.Tm_constant c)
-       | FStar_TypeChecker_NBETerm.Meta (t, m) ->
-           let uu___1 =
-             let uu___2 =
-               let uu___3 = readback cfg t in
-               let uu___4 = FStar_Thunk.force m in (uu___3, uu___4) in
-             FStar_Syntax_Syntax.Tm_meta uu___2 in
-           mk uu___1
-       | FStar_TypeChecker_NBETerm.Type_t u ->
-           mk (FStar_Syntax_Syntax.Tm_type u)
-       | FStar_TypeChecker_NBETerm.Lam (f, binders, arity) ->
-           let uu___1 =
-             match binders with
-             | FStar_Pervasives.Inl (ctx, binders1, rc) ->
-                 let uu___2 =
-                   FStar_Compiler_List.fold_left
-                     (fun uu___3 ->
-                        fun b ->
-                          match uu___3 with
-                          | (ctx1, binders_rev, accus_rev) ->
-                              let x1 = b.FStar_Syntax_Syntax.binder_bv in
-                              let tnorm =
-                                let uu___4 =
-                                  translate cfg ctx1
-                                    x1.FStar_Syntax_Syntax.sort in
-                                readback cfg uu___4 in
-                              let x2 =
-                                let uu___4 =
-                                  FStar_Syntax_Syntax.freshen_bv x1 in
-                                {
-                                  FStar_Syntax_Syntax.ppname =
-                                    (uu___4.FStar_Syntax_Syntax.ppname);
-                                  FStar_Syntax_Syntax.index =
-                                    (uu___4.FStar_Syntax_Syntax.index);
-                                  FStar_Syntax_Syntax.sort = tnorm
-                                } in
-                              let ax = FStar_TypeChecker_NBETerm.mkAccuVar x2 in
-                              let ctx2 = ax :: ctx1 in
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Syntax_Util.aqual_of_binder b in
-                                  (ax, uu___6) in
-                                uu___5 :: accus_rev in
-                              (ctx2,
-                                ({
-                                   FStar_Syntax_Syntax.binder_bv = x2;
-                                   FStar_Syntax_Syntax.binder_qual =
-                                     (b.FStar_Syntax_Syntax.binder_qual);
-                                   FStar_Syntax_Syntax.binder_attrs =
-                                     (b.FStar_Syntax_Syntax.binder_attrs)
-                                 } :: binders_rev), uu___4)) (ctx, [], [])
-                     binders1 in
-                 (match uu___2 with
-                  | (ctx1, binders_rev, accus_rev) ->
-                      let rc1 =
-                        match rc with
-                        | FStar_Pervasives_Native.None ->
-                            FStar_Pervasives_Native.None
-                        | FStar_Pervasives_Native.Some rc2 ->
-                            let uu___3 =
-                              let uu___4 =
-                                translate_residual_comp cfg ctx1 rc2 in
-                              readback_residual_comp cfg uu___4 in
-                            FStar_Pervasives_Native.Some uu___3 in
-                      ((FStar_Compiler_List.rev binders_rev), accus_rev, rc1))
-             | FStar_Pervasives.Inr args ->
-                 let uu___2 =
-                   FStar_Compiler_List.fold_right
-                     (fun uu___3 ->
-                        fun uu___4 ->
-                          match (uu___3, uu___4) with
-                          | ((t, aq), (binders1, accus)) ->
-                              let uu___5 =
-                                FStar_Syntax_Util.bqual_and_attrs_of_aqual aq in
-                              (match uu___5 with
-                               | (bqual, battrs) ->
-                                   let x1 =
-                                     let uu___6 = readback cfg t in
-                                     FStar_Syntax_Syntax.new_bv
-                                       FStar_Pervasives_Native.None uu___6 in
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_Syntax_Syntax.mk_binder_with_attrs
-                                         x1 bqual battrs in
-                                     uu___7 :: binders1 in
-                                   let uu___7 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         FStar_TypeChecker_NBETerm.mkAccuVar
-                                           x1 in
-                                       (uu___9, aq) in
-                                     uu___8 :: accus in
-                                   (uu___6, uu___7))) args ([], []) in
-                 (match uu___2 with
-                  | (binders1, accus) ->
-                      (binders1, (FStar_Compiler_List.rev accus),
-                        FStar_Pervasives_Native.None)) in
-           (match uu___1 with
-            | (binders1, accus_rev, rc) ->
-                let body = let uu___2 = f accus_rev in readback cfg uu___2 in
-                let uu___2 = FStar_Syntax_Util.abs binders1 body rc in
-                with_range uu___2)
-       | FStar_TypeChecker_NBETerm.Refinement (f, targ) ->
-           if
-             ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-           then
-             let uu___1 =
-               let uu___2 = targ () in FStar_Pervasives_Native.fst uu___2 in
-             readback cfg uu___1
-           else
-             (let x1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = targ () in
-                    FStar_Pervasives_Native.fst uu___4 in
-                  readback cfg uu___3 in
-                FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                  uu___2 in
-              let body =
-                let uu___2 =
-                  let uu___3 = FStar_TypeChecker_NBETerm.mkAccuVar x1 in
-                  f uu___3 in
-                readback cfg uu___2 in
-              let refinement = FStar_Syntax_Util.refine x1 body in
-              let uu___2 =
-                if
-                  ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.simplify
-                then
-                  FStar_TypeChecker_Common.simplify
-                    ((cfg.core_cfg).FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                    refinement
-                else refinement in
-              with_range uu___2)
-       | FStar_TypeChecker_NBETerm.Reflect t ->
-           let tm = readback cfg t in
-           let uu___1 = FStar_Syntax_Util.mk_reflect tm in with_range uu___1
-       | FStar_TypeChecker_NBETerm.Arrow (FStar_Pervasives.Inl f) ->
-           let uu___1 = FStar_Thunk.force f in with_range uu___1
-       | FStar_TypeChecker_NBETerm.Arrow (FStar_Pervasives.Inr (args, c)) ->
-           let binders =
-             FStar_Compiler_List.map
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (t, q) ->
-                      let t1 = readback cfg t in
-                      let x1 =
-                        FStar_Syntax_Syntax.new_bv
-                          FStar_Pervasives_Native.None t1 in
-                      let uu___2 =
-                        FStar_Syntax_Util.bqual_and_attrs_of_aqual q in
-                      (match uu___2 with
-                       | (q1, attrs) ->
-                           FStar_Syntax_Syntax.mk_binder_with_attrs x1 q1 []))
-               args in
-           let c1 = readback_comp cfg c in
-           let uu___1 = FStar_Syntax_Util.arrow binders c1 in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Construct (fv, us, args) ->
-           let args1 =
-             map_rev
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (x1, q) -> let uu___2 = readback cfg x1 in (uu___2, q))
-               args in
-           let fv1 =
-             let uu___1 = FStar_Syntax_Syntax.range_of_fv fv in
-             FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv) uu___1 in
-           let app =
-             let uu___1 =
-               FStar_Syntax_Syntax.mk_Tm_uinst fv1
-                 (FStar_Compiler_List.rev us) in
-             FStar_Syntax_Util.mk_app uu___1 args1 in
-           with_range app
-       | FStar_TypeChecker_NBETerm.FV (fv, us, args) ->
-           let args1 =
-             map_rev
-               (fun uu___1 ->
-                  match uu___1 with
-                  | (x1, q) -> let uu___2 = readback cfg x1 in (uu___2, q))
-               args in
-           let fv1 =
-             FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv)
-               FStar_Compiler_Range.dummyRange in
-           let app =
-             let uu___1 =
-               FStar_Syntax_Syntax.mk_Tm_uinst fv1
-                 (FStar_Compiler_List.rev us) in
-             FStar_Syntax_Util.mk_app uu___1 args1 in
-           let uu___1 =
-             if
-               ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.simplify
-             then
-               FStar_TypeChecker_Common.simplify
-                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                 app
-             else app in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Accu
-           (FStar_TypeChecker_NBETerm.Var bv, []) ->
-           let uu___1 = FStar_Syntax_Syntax.bv_to_name bv in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Accu
-           (FStar_TypeChecker_NBETerm.Var bv, args) ->
-           let args1 = readback_args cfg args in
-           let app =
-             let uu___1 = FStar_Syntax_Syntax.bv_to_name bv in
-             FStar_Syntax_Util.mk_app uu___1 args1 in
-           let uu___1 =
-             if
-               ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.simplify
-             then
-               FStar_TypeChecker_Common.simplify
-                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                 app
-             else app in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Accu
-           (FStar_TypeChecker_NBETerm.Match
-            (scrut, make_returns, make_branches, make_rc), args)
-           ->
-           let args1 = readback_args cfg args in
-           let head =
-             let scrut_new = readback cfg scrut in
-             let returns_new = make_returns () in
-             let branches_new = make_branches () in
-             let rc_new = make_rc () in
-             FStar_Syntax_Syntax.mk
-               (FStar_Syntax_Syntax.Tm_match
-                  (scrut_new, returns_new, branches_new, rc_new))
-               scrut.FStar_TypeChecker_NBETerm.nbe_r in
-           let app = FStar_Syntax_Util.mk_app head args1 in
-           let uu___1 =
-             if
-               ((cfg.core_cfg).FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.simplify
-             then
-               FStar_TypeChecker_Common.simplify
-                 ((cfg.core_cfg).FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                 app
-             else app in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Accu
-           (FStar_TypeChecker_NBETerm.UnreducedLet
-            (var, typ, defn, body, lb), args)
-           ->
-           let typ1 =
-             let uu___1 = FStar_Thunk.force typ in readback cfg uu___1 in
-           let defn1 =
-             let uu___1 = FStar_Thunk.force defn in readback cfg uu___1 in
-           let body1 =
-             let uu___1 =
-               let uu___2 = FStar_Syntax_Syntax.mk_binder var in [uu___2] in
-             let uu___2 =
-               let uu___3 = FStar_Thunk.force body in readback cfg uu___3 in
-             FStar_Syntax_Subst.close uu___1 uu___2 in
-           let lbname =
-             let uu___1 =
-               let uu___2 =
-                 FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-               {
-                 FStar_Syntax_Syntax.ppname =
-                   (uu___2.FStar_Syntax_Syntax.ppname);
-                 FStar_Syntax_Syntax.index =
-                   (uu___2.FStar_Syntax_Syntax.index);
-                 FStar_Syntax_Syntax.sort = typ1
-               } in
-             FStar_Pervasives.Inl uu___1 in
-           let lb1 =
-             {
-               FStar_Syntax_Syntax.lbname = lbname;
-               FStar_Syntax_Syntax.lbunivs = (lb.FStar_Syntax_Syntax.lbunivs);
-               FStar_Syntax_Syntax.lbtyp = typ1;
-               FStar_Syntax_Syntax.lbeff = (lb.FStar_Syntax_Syntax.lbeff);
-               FStar_Syntax_Syntax.lbdef = defn1;
-               FStar_Syntax_Syntax.lbattrs = (lb.FStar_Syntax_Syntax.lbattrs);
-               FStar_Syntax_Syntax.lbpos = (lb.FStar_Syntax_Syntax.lbpos)
-             } in
-           let hd =
-             FStar_Syntax_Syntax.mk
-               (FStar_Syntax_Syntax.Tm_let ((false, [lb1]), body1))
-               FStar_Compiler_Range.dummyRange in
-           let args1 = readback_args cfg args in
-           let uu___1 = FStar_Syntax_Util.mk_app hd args1 in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.Accu
-           (FStar_TypeChecker_NBETerm.UnreducedLetRec
-            (vars_typs_defns, body, lbs), args)
-           ->
-           let lbs1 =
-             FStar_Compiler_List.map2
-               (fun uu___1 ->
-                  fun lb ->
-                    match uu___1 with
-                    | (v, t, d) ->
-                        let t1 = readback cfg t in
-                        let def = readback cfg d in
-                        let v1 =
-                          {
-                            FStar_Syntax_Syntax.ppname =
-                              (v.FStar_Syntax_Syntax.ppname);
-                            FStar_Syntax_Syntax.index =
-                              (v.FStar_Syntax_Syntax.index);
-                            FStar_Syntax_Syntax.sort = t1
-                          } in
-                        {
-                          FStar_Syntax_Syntax.lbname =
-                            (FStar_Pervasives.Inl v1);
-                          FStar_Syntax_Syntax.lbunivs =
-                            (lb.FStar_Syntax_Syntax.lbunivs);
-                          FStar_Syntax_Syntax.lbtyp = t1;
-                          FStar_Syntax_Syntax.lbeff =
-                            (lb.FStar_Syntax_Syntax.lbeff);
-                          FStar_Syntax_Syntax.lbdef = def;
-                          FStar_Syntax_Syntax.lbattrs =
-                            (lb.FStar_Syntax_Syntax.lbattrs);
-                          FStar_Syntax_Syntax.lbpos =
-                            (lb.FStar_Syntax_Syntax.lbpos)
-                        }) vars_typs_defns lbs in
-           let body1 = readback cfg body in
-           let uu___1 = FStar_Syntax_Subst.close_let_rec lbs1 body1 in
-           (match uu___1 with
-            | (lbs2, body2) ->
-                let hd =
-                  FStar_Syntax_Syntax.mk
-                    (FStar_Syntax_Syntax.Tm_let ((true, lbs2), body2))
-                    FStar_Compiler_Range.dummyRange in
-                let args1 = readback_args cfg args in
-                let uu___2 = FStar_Syntax_Util.mk_app hd args1 in
-                with_range uu___2)
-       | FStar_TypeChecker_NBETerm.Accu
-           (FStar_TypeChecker_NBETerm.UVar f, args) ->
-           let hd = FStar_Thunk.force f in
-           let args1 = readback_args cfg args in
-           let uu___1 = FStar_Syntax_Util.mk_app hd args1 in
-           with_range uu___1
-       | FStar_TypeChecker_NBETerm.TopLevelLet (lb, arity, args_rev) ->
-           let n_univs =
-             FStar_Compiler_List.length lb.FStar_Syntax_Syntax.lbunivs in
-           let n_args = FStar_Compiler_List.length args_rev in
-           let uu___1 =
-             FStar_Compiler_Util.first_N (n_args - n_univs) args_rev in
-           (match uu___1 with
-            | (args_rev1, univs) ->
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                        univs in
-                    translate cfg uu___4 lb.FStar_Syntax_Syntax.lbdef in
-                  iapp cfg uu___3 (FStar_Compiler_List.rev args_rev1) in
-                readback cfg uu___2)
-       | FStar_TypeChecker_NBETerm.TopLevelRec (lb, uu___1, uu___2, args) ->
-           let fv = FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-           let head =
-             FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv)
-               FStar_Compiler_Range.dummyRange in
-           let args1 =
-             FStar_Compiler_List.map
-               (fun uu___3 ->
-                  match uu___3 with
-                  | (t, q) -> let uu___4 = readback cfg t in (uu___4, q))
-               args in
-           let uu___3 = FStar_Syntax_Util.mk_app head args1 in
-           with_range uu___3
-       | FStar_TypeChecker_NBETerm.LocalLetRec
-           (i, uu___1, lbs, bs, args, _ar, _ar_lst) ->
-           let lbnames =
-             FStar_Compiler_List.map
-               (fun lb ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_Util.left
-                          lb.FStar_Syntax_Syntax.lbname in
-                      uu___4.FStar_Syntax_Syntax.ppname in
-                    FStar_Ident.string_of_id uu___3 in
-                  FStar_Syntax_Syntax.gen_bv uu___2
-                    FStar_Pervasives_Native.None lb.FStar_Syntax_Syntax.lbtyp)
-               lbs in
-           let let_rec_env =
-             let uu___2 =
-               FStar_Compiler_List.map
-                 (fun x1 ->
-                    let uu___3 = FStar_Syntax_Syntax.range_of_bv x1 in
-                    mk_rt uu___3
-                      (FStar_TypeChecker_NBETerm.Accu
-                         ((FStar_TypeChecker_NBETerm.Var x1), []))) lbnames in
-             FStar_Compiler_List.rev_append uu___2 bs in
-           let lbs1 =
-             FStar_Compiler_List.map2
-               (fun lb ->
-                  fun lbname ->
-                    let lbdef =
-                      let uu___2 =
-                        translate cfg let_rec_env
-                          lb.FStar_Syntax_Syntax.lbdef in
-                      readback cfg uu___2 in
-                    let lbtyp =
-                      let uu___2 =
-                        translate cfg bs lb.FStar_Syntax_Syntax.lbtyp in
-                      readback cfg uu___2 in
-                    {
-                      FStar_Syntax_Syntax.lbname =
-                        (FStar_Pervasives.Inl lbname);
-                      FStar_Syntax_Syntax.lbunivs =
-                        (lb.FStar_Syntax_Syntax.lbunivs);
-                      FStar_Syntax_Syntax.lbtyp = lbtyp;
-                      FStar_Syntax_Syntax.lbeff =
-                        (lb.FStar_Syntax_Syntax.lbeff);
-                      FStar_Syntax_Syntax.lbdef = lbdef;
-                      FStar_Syntax_Syntax.lbattrs =
-                        (lb.FStar_Syntax_Syntax.lbattrs);
-                      FStar_Syntax_Syntax.lbpos =
-                        (lb.FStar_Syntax_Syntax.lbpos)
-                    }) lbs lbnames in
-           let body =
-             let uu___2 = FStar_Compiler_List.nth lbnames i in
-             FStar_Syntax_Syntax.bv_to_name uu___2 in
-           let uu___2 = FStar_Syntax_Subst.close_let_rec lbs1 body in
-           (match uu___2 with
-            | (lbs2, body1) ->
-                let head =
-                  FStar_Syntax_Syntax.mk
-                    (FStar_Syntax_Syntax.Tm_let ((true, lbs2), body1))
-                    FStar_Compiler_Range.dummyRange in
-                let args1 =
-                  FStar_Compiler_List.map
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | (x1, q) ->
-                           let uu___4 = readback cfg x1 in (uu___4, q)) args in
-                let uu___3 = FStar_Syntax_Util.mk_app head args1 in
-                with_range uu___3)
-       | FStar_TypeChecker_NBETerm.Quote (qt, qi) ->
-           mk (FStar_Syntax_Syntax.Tm_quoted (qt, qi))
-       | FStar_TypeChecker_NBETerm.Lazy (FStar_Pervasives.Inl li, uu___1) ->
-           mk (FStar_Syntax_Syntax.Tm_lazy li)
-       | FStar_TypeChecker_NBETerm.Lazy (uu___1, thunk) ->
-           let uu___2 = FStar_Thunk.force thunk in readback cfg uu___2)
-type step =
-  | Primops 
-  | UnfoldUntil of FStar_Syntax_Syntax.delta_depth 
-  | UnfoldOnly of FStar_Ident.lid Prims.list 
-  | UnfoldAttr of FStar_Ident.lid Prims.list 
-  | UnfoldTac 
-  | Reify 
-let (uu___is_Primops : step -> Prims.bool) =
-  fun projectee -> match projectee with | Primops -> true | uu___ -> false
-let (uu___is_UnfoldUntil : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldUntil _0 -> true | uu___ -> false
-let (__proj__UnfoldUntil__item___0 : step -> FStar_Syntax_Syntax.delta_depth)
-  = fun projectee -> match projectee with | UnfoldUntil _0 -> _0
-let (uu___is_UnfoldOnly : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldOnly _0 -> true | uu___ -> false
-let (__proj__UnfoldOnly__item___0 : step -> FStar_Ident.lid Prims.list) =
-  fun projectee -> match projectee with | UnfoldOnly _0 -> _0
-let (uu___is_UnfoldAttr : step -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnfoldAttr _0 -> true | uu___ -> false
-let (__proj__UnfoldAttr__item___0 : step -> FStar_Ident.lid Prims.list) =
-  fun projectee -> match projectee with | UnfoldAttr _0 -> _0
-let (uu___is_UnfoldTac : step -> Prims.bool) =
-  fun projectee -> match projectee with | UnfoldTac -> true | uu___ -> false
-let (uu___is_Reify : step -> Prims.bool) =
-  fun projectee -> match projectee with | Reify -> true | uu___ -> false
-let (step_as_normalizer_step : step -> FStar_TypeChecker_Env.step) =
-  fun uu___ ->
-    match uu___ with
-    | Primops -> FStar_TypeChecker_Env.Primops
-    | UnfoldUntil d -> FStar_TypeChecker_Env.UnfoldUntil d
-    | UnfoldOnly lids -> FStar_TypeChecker_Env.UnfoldOnly lids
-    | UnfoldAttr lids -> FStar_TypeChecker_Env.UnfoldAttr lids
-    | UnfoldTac -> FStar_TypeChecker_Env.UnfoldTac
-    | Reify -> FStar_TypeChecker_Env.Reify
-let (reduce_application :
-  FStar_TypeChecker_Cfg.cfg ->
-    FStar_TypeChecker_NBETerm.t ->
-      FStar_TypeChecker_NBETerm.args -> FStar_TypeChecker_NBETerm.t)
-  =
-  fun cfg ->
-    fun t -> fun args -> let uu___ = new_config cfg in iapp uu___ t args
-let (normalize :
-  FStar_TypeChecker_Cfg.primitive_step Prims.list ->
-    FStar_TypeChecker_Env.step Prims.list ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun psteps ->
-    fun steps ->
-      fun env ->
-        fun e ->
-          let cfg = FStar_TypeChecker_Cfg.config' psteps steps env in
-          let cfg1 =
-            {
-              FStar_TypeChecker_Cfg.steps =
-                (let uu___ = cfg.FStar_TypeChecker_Cfg.steps in
-                 {
-                   FStar_TypeChecker_Cfg.beta =
-                     (uu___.FStar_TypeChecker_Cfg.beta);
-                   FStar_TypeChecker_Cfg.iota =
-                     (uu___.FStar_TypeChecker_Cfg.iota);
-                   FStar_TypeChecker_Cfg.zeta =
-                     (uu___.FStar_TypeChecker_Cfg.zeta);
-                   FStar_TypeChecker_Cfg.zeta_full =
-                     (uu___.FStar_TypeChecker_Cfg.zeta_full);
-                   FStar_TypeChecker_Cfg.weak =
-                     (uu___.FStar_TypeChecker_Cfg.weak);
-                   FStar_TypeChecker_Cfg.hnf =
-                     (uu___.FStar_TypeChecker_Cfg.hnf);
-                   FStar_TypeChecker_Cfg.primops =
-                     (uu___.FStar_TypeChecker_Cfg.primops);
-                   FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                     (uu___.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                   FStar_TypeChecker_Cfg.unfold_until =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_until);
-                   FStar_TypeChecker_Cfg.unfold_only =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_only);
-                   FStar_TypeChecker_Cfg.unfold_fully =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_fully);
-                   FStar_TypeChecker_Cfg.unfold_attr =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_attr);
-                   FStar_TypeChecker_Cfg.unfold_qual =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_qual);
-                   FStar_TypeChecker_Cfg.unfold_namespace =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_namespace);
-                   FStar_TypeChecker_Cfg.unfold_tac =
-                     (uu___.FStar_TypeChecker_Cfg.unfold_tac);
-                   FStar_TypeChecker_Cfg.pure_subterms_within_computations =
-                     (uu___.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                   FStar_TypeChecker_Cfg.simplify =
-                     (uu___.FStar_TypeChecker_Cfg.simplify);
-                   FStar_TypeChecker_Cfg.erase_universes =
-                     (uu___.FStar_TypeChecker_Cfg.erase_universes);
-                   FStar_TypeChecker_Cfg.allow_unbound_universes =
-                     (uu___.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                   FStar_TypeChecker_Cfg.reify_ = true;
-                   FStar_TypeChecker_Cfg.compress_uvars =
-                     (uu___.FStar_TypeChecker_Cfg.compress_uvars);
-                   FStar_TypeChecker_Cfg.no_full_norm =
-                     (uu___.FStar_TypeChecker_Cfg.no_full_norm);
-                   FStar_TypeChecker_Cfg.check_no_uvars =
-                     (uu___.FStar_TypeChecker_Cfg.check_no_uvars);
-                   FStar_TypeChecker_Cfg.unmeta =
-                     (uu___.FStar_TypeChecker_Cfg.unmeta);
-                   FStar_TypeChecker_Cfg.unascribe =
-                     (uu___.FStar_TypeChecker_Cfg.unascribe);
-                   FStar_TypeChecker_Cfg.in_full_norm_request =
-                     (uu___.FStar_TypeChecker_Cfg.in_full_norm_request);
-                   FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                     (uu___.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                   FStar_TypeChecker_Cfg.nbe_step =
-                     (uu___.FStar_TypeChecker_Cfg.nbe_step);
-                   FStar_TypeChecker_Cfg.for_extraction =
-                     (uu___.FStar_TypeChecker_Cfg.for_extraction);
-                   FStar_TypeChecker_Cfg.unrefine =
-                     (uu___.FStar_TypeChecker_Cfg.unrefine)
-                 });
-              FStar_TypeChecker_Cfg.tcenv = (cfg.FStar_TypeChecker_Cfg.tcenv);
-              FStar_TypeChecker_Cfg.debug = (cfg.FStar_TypeChecker_Cfg.debug);
-              FStar_TypeChecker_Cfg.delta_level =
-                (cfg.FStar_TypeChecker_Cfg.delta_level);
-              FStar_TypeChecker_Cfg.primitive_steps =
-                (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-              FStar_TypeChecker_Cfg.strong =
-                (cfg.FStar_TypeChecker_Cfg.strong);
-              FStar_TypeChecker_Cfg.memoize_lazy =
-                (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-              FStar_TypeChecker_Cfg.normalize_pure_lets =
-                (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-              FStar_TypeChecker_Cfg.reifying =
-                (cfg.FStar_TypeChecker_Cfg.reifying)
-            } in
-          (let uu___1 =
-             (FStar_TypeChecker_Env.debug env (FStar_Options.Other "NBETop"))
-               ||
-               (FStar_TypeChecker_Env.debug env (FStar_Options.Other "NBE")) in
-           if uu___1
-           then
-             let uu___2 = FStar_Syntax_Print.term_to_string e in
-             FStar_Compiler_Util.print1 "Calling NBE with (%s) {\n" uu___2
-           else ());
-          (let cfg2 = new_config cfg1 in
-           let r = let uu___1 = translate cfg2 [] e in readback cfg2 uu___1 in
-           (let uu___2 =
-              (FStar_TypeChecker_Env.debug env (FStar_Options.Other "NBETop"))
-                ||
-                (FStar_TypeChecker_Env.debug env (FStar_Options.Other "NBE")) in
-            if uu___2
-            then
-              let uu___3 = FStar_Syntax_Print.term_to_string r in
-              FStar_Compiler_Util.print1 "}\nNBE returned (%s)\n" uu___3
-            else ());
-           r)
-let (normalize_for_unit_test :
-  FStar_TypeChecker_Env.step Prims.list ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun steps ->
-    fun env ->
-      fun e ->
-        let cfg = FStar_TypeChecker_Cfg.config steps env in
-        let cfg1 =
-          {
-            FStar_TypeChecker_Cfg.steps =
-              (let uu___ = cfg.FStar_TypeChecker_Cfg.steps in
-               {
-                 FStar_TypeChecker_Cfg.beta =
-                   (uu___.FStar_TypeChecker_Cfg.beta);
-                 FStar_TypeChecker_Cfg.iota =
-                   (uu___.FStar_TypeChecker_Cfg.iota);
-                 FStar_TypeChecker_Cfg.zeta =
-                   (uu___.FStar_TypeChecker_Cfg.zeta);
-                 FStar_TypeChecker_Cfg.zeta_full =
-                   (uu___.FStar_TypeChecker_Cfg.zeta_full);
-                 FStar_TypeChecker_Cfg.weak =
-                   (uu___.FStar_TypeChecker_Cfg.weak);
-                 FStar_TypeChecker_Cfg.hnf =
-                   (uu___.FStar_TypeChecker_Cfg.hnf);
-                 FStar_TypeChecker_Cfg.primops =
-                   (uu___.FStar_TypeChecker_Cfg.primops);
-                 FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                   (uu___.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                 FStar_TypeChecker_Cfg.unfold_until =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_until);
-                 FStar_TypeChecker_Cfg.unfold_only =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_only);
-                 FStar_TypeChecker_Cfg.unfold_fully =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_fully);
-                 FStar_TypeChecker_Cfg.unfold_attr =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_attr);
-                 FStar_TypeChecker_Cfg.unfold_qual =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_qual);
-                 FStar_TypeChecker_Cfg.unfold_namespace =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_namespace);
-                 FStar_TypeChecker_Cfg.unfold_tac =
-                   (uu___.FStar_TypeChecker_Cfg.unfold_tac);
-                 FStar_TypeChecker_Cfg.pure_subterms_within_computations =
-                   (uu___.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                 FStar_TypeChecker_Cfg.simplify =
-                   (uu___.FStar_TypeChecker_Cfg.simplify);
-                 FStar_TypeChecker_Cfg.erase_universes =
-                   (uu___.FStar_TypeChecker_Cfg.erase_universes);
-                 FStar_TypeChecker_Cfg.allow_unbound_universes =
-                   (uu___.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                 FStar_TypeChecker_Cfg.reify_ = true;
-                 FStar_TypeChecker_Cfg.compress_uvars =
-                   (uu___.FStar_TypeChecker_Cfg.compress_uvars);
-                 FStar_TypeChecker_Cfg.no_full_norm =
-                   (uu___.FStar_TypeChecker_Cfg.no_full_norm);
-                 FStar_TypeChecker_Cfg.check_no_uvars =
-                   (uu___.FStar_TypeChecker_Cfg.check_no_uvars);
-                 FStar_TypeChecker_Cfg.unmeta =
-                   (uu___.FStar_TypeChecker_Cfg.unmeta);
-                 FStar_TypeChecker_Cfg.unascribe =
-                   (uu___.FStar_TypeChecker_Cfg.unascribe);
-                 FStar_TypeChecker_Cfg.in_full_norm_request =
-                   (uu___.FStar_TypeChecker_Cfg.in_full_norm_request);
-                 FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                   (uu___.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                 FStar_TypeChecker_Cfg.nbe_step =
-                   (uu___.FStar_TypeChecker_Cfg.nbe_step);
-                 FStar_TypeChecker_Cfg.for_extraction =
-                   (uu___.FStar_TypeChecker_Cfg.for_extraction);
-                 FStar_TypeChecker_Cfg.unrefine =
-                   (uu___.FStar_TypeChecker_Cfg.unrefine)
-               });
-            FStar_TypeChecker_Cfg.tcenv = (cfg.FStar_TypeChecker_Cfg.tcenv);
-            FStar_TypeChecker_Cfg.debug = (cfg.FStar_TypeChecker_Cfg.debug);
-            FStar_TypeChecker_Cfg.delta_level =
-              (cfg.FStar_TypeChecker_Cfg.delta_level);
-            FStar_TypeChecker_Cfg.primitive_steps =
-              (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-            FStar_TypeChecker_Cfg.strong = (cfg.FStar_TypeChecker_Cfg.strong);
-            FStar_TypeChecker_Cfg.memoize_lazy =
-              (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-            FStar_TypeChecker_Cfg.normalize_pure_lets =
-              (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-            FStar_TypeChecker_Cfg.reifying =
-              (cfg.FStar_TypeChecker_Cfg.reifying)
-          } in
-        let cfg2 = new_config cfg1 in
-        debug cfg2
-          (fun uu___1 ->
-             let uu___2 = FStar_Syntax_Print.term_to_string e in
-             FStar_Compiler_Util.print1 "Calling NBE with (%s) {\n" uu___2);
-        (let r = let uu___1 = translate cfg2 [] e in readback cfg2 uu___1 in
-         debug cfg2
-           (fun uu___2 ->
-              let uu___3 = FStar_Syntax_Print.term_to_string r in
-              FStar_Compiler_Util.print1 "}\nNBE returned (%s)\n" uu___3);
-         r)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_NBETerm.ml b/src/ocaml-output/FStar_TypeChecker_NBETerm.ml
deleted file mode 100644
index fe40147c534..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_NBETerm.ml
+++ /dev/null
@@ -1,2159 +0,0 @@
-open Prims
-type var = FStar_Syntax_Syntax.bv
-type sort = Prims.int
-type constant =
-  | Unit 
-  | Bool of Prims.bool 
-  | Int of FStar_BigInt.t 
-  | String of (Prims.string * FStar_Compiler_Range.range) 
-  | Char of FStar_Char.char 
-  | Range of FStar_Compiler_Range.range 
-  | SConst of FStar_Const.sconst 
-let (uu___is_Unit : constant -> Prims.bool) =
-  fun projectee -> match projectee with | Unit -> true | uu___ -> false
-let (uu___is_Bool : constant -> Prims.bool) =
-  fun projectee -> match projectee with | Bool _0 -> true | uu___ -> false
-let (__proj__Bool__item___0 : constant -> Prims.bool) =
-  fun projectee -> match projectee with | Bool _0 -> _0
-let (uu___is_Int : constant -> Prims.bool) =
-  fun projectee -> match projectee with | Int _0 -> true | uu___ -> false
-let (__proj__Int__item___0 : constant -> FStar_BigInt.t) =
-  fun projectee -> match projectee with | Int _0 -> _0
-let (uu___is_String : constant -> Prims.bool) =
-  fun projectee -> match projectee with | String _0 -> true | uu___ -> false
-let (__proj__String__item___0 :
-  constant -> (Prims.string * FStar_Compiler_Range.range)) =
-  fun projectee -> match projectee with | String _0 -> _0
-let (uu___is_Char : constant -> Prims.bool) =
-  fun projectee -> match projectee with | Char _0 -> true | uu___ -> false
-let (__proj__Char__item___0 : constant -> FStar_Char.char) =
-  fun projectee -> match projectee with | Char _0 -> _0
-let (uu___is_Range : constant -> Prims.bool) =
-  fun projectee -> match projectee with | Range _0 -> true | uu___ -> false
-let (__proj__Range__item___0 : constant -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | Range _0 -> _0
-let (uu___is_SConst : constant -> Prims.bool) =
-  fun projectee -> match projectee with | SConst _0 -> true | uu___ -> false
-let (__proj__SConst__item___0 : constant -> FStar_Const.sconst) =
-  fun projectee -> match projectee with | SConst _0 -> _0
-type atom =
-  | Var of var 
-  | Match of (t *
-  (unit ->
-     FStar_Syntax_Syntax.match_returns_ascription
-       FStar_Pervasives_Native.option)
-  * (unit -> FStar_Syntax_Syntax.branch Prims.list) *
-  (unit -> FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option))
-  
-  | UnreducedLet of (var * t FStar_Thunk.t * t FStar_Thunk.t * t
-  FStar_Thunk.t * FStar_Syntax_Syntax.letbinding) 
-  | UnreducedLetRec of ((var * t * t) Prims.list * t *
-  FStar_Syntax_Syntax.letbinding Prims.list) 
-  | UVar of FStar_Syntax_Syntax.term FStar_Thunk.t 
-and t' =
-  | Lam of (((t * FStar_Syntax_Syntax.aqual) Prims.list -> t) *
-  ((t Prims.list * FStar_Syntax_Syntax.binders *
-     FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option),
-  (t * FStar_Syntax_Syntax.aqual) Prims.list) FStar_Pervasives.either *
-  Prims.int) 
-  | Accu of (atom * (t * FStar_Syntax_Syntax.aqual) Prims.list) 
-  | Construct of (FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universe
-  Prims.list * (t * FStar_Syntax_Syntax.aqual) Prims.list) 
-  | FV of (FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universe Prims.list *
-  (t * FStar_Syntax_Syntax.aqual) Prims.list) 
-  | Constant of constant 
-  | Type_t of FStar_Syntax_Syntax.universe 
-  | Univ of FStar_Syntax_Syntax.universe 
-  | Unknown 
-  | Arrow of (FStar_Syntax_Syntax.term FStar_Thunk.t,
-  ((t * FStar_Syntax_Syntax.aqual) Prims.list * comp))
-  FStar_Pervasives.either 
-  | Refinement of ((t -> t) * (unit -> (t * FStar_Syntax_Syntax.aqual))) 
-  | Reflect of t 
-  | Quote of (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.quoteinfo) 
-  | Lazy of ((FStar_Syntax_Syntax.lazyinfo,
-  (FStar_Compiler_Dyn.dyn * FStar_Syntax_Syntax.emb_typ))
-  FStar_Pervasives.either * t FStar_Thunk.t) 
-  | Meta of (t * FStar_Syntax_Syntax.metadata FStar_Thunk.t) 
-  | TopLevelLet of (FStar_Syntax_Syntax.letbinding * Prims.int * (t *
-  FStar_Syntax_Syntax.aqual) Prims.list) 
-  | TopLevelRec of (FStar_Syntax_Syntax.letbinding * Prims.int * Prims.bool
-  Prims.list * (t * FStar_Syntax_Syntax.aqual) Prims.list) 
-  | LocalLetRec of (Prims.int * FStar_Syntax_Syntax.letbinding *
-  FStar_Syntax_Syntax.letbinding Prims.list * t Prims.list * (t *
-  FStar_Syntax_Syntax.aqual) Prims.list * Prims.int * Prims.bool Prims.list) 
-and t = {
-  nbe_t: t' ;
-  nbe_r: FStar_Compiler_Range.range }
-and comp =
-  | Tot of t 
-  | GTot of t 
-  | Comp of comp_typ 
-and comp_typ =
-  {
-  comp_univs: FStar_Syntax_Syntax.universes ;
-  effect_name: FStar_Ident.lident ;
-  result_typ: t ;
-  effect_args: (t * FStar_Syntax_Syntax.aqual) Prims.list ;
-  flags: cflag Prims.list }
-and residual_comp =
-  {
-  residual_effect: FStar_Ident.lident ;
-  residual_typ: t FStar_Pervasives_Native.option ;
-  residual_flags: cflag Prims.list }
-and cflag =
-  | TOTAL 
-  | MLEFFECT 
-  | RETURN 
-  | PARTIAL_RETURN 
-  | SOMETRIVIAL 
-  | TRIVIAL_POSTCONDITION 
-  | SHOULD_NOT_INLINE 
-  | LEMMA 
-  | CPS 
-  | DECREASES_lex of t Prims.list 
-  | DECREASES_wf of (t * t) 
-let (uu___is_Var : atom -> Prims.bool) =
-  fun projectee -> match projectee with | Var _0 -> true | uu___ -> false
-let (__proj__Var__item___0 : atom -> var) =
-  fun projectee -> match projectee with | Var _0 -> _0
-let (uu___is_Match : atom -> Prims.bool) =
-  fun projectee -> match projectee with | Match _0 -> true | uu___ -> false
-let (__proj__Match__item___0 :
-  atom ->
-    (t *
-      (unit ->
-         FStar_Syntax_Syntax.match_returns_ascription
-           FStar_Pervasives_Native.option)
-      * (unit -> FStar_Syntax_Syntax.branch Prims.list) *
-      (unit ->
-         FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option)))
-  = fun projectee -> match projectee with | Match _0 -> _0
-let (uu___is_UnreducedLet : atom -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnreducedLet _0 -> true | uu___ -> false
-let (__proj__UnreducedLet__item___0 :
-  atom ->
-    (var * t FStar_Thunk.t * t FStar_Thunk.t * t FStar_Thunk.t *
-      FStar_Syntax_Syntax.letbinding))
-  = fun projectee -> match projectee with | UnreducedLet _0 -> _0
-let (uu___is_UnreducedLetRec : atom -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnreducedLetRec _0 -> true | uu___ -> false
-let (__proj__UnreducedLetRec__item___0 :
-  atom ->
-    ((var * t * t) Prims.list * t * FStar_Syntax_Syntax.letbinding
-      Prims.list))
-  = fun projectee -> match projectee with | UnreducedLetRec _0 -> _0
-let (uu___is_UVar : atom -> Prims.bool) =
-  fun projectee -> match projectee with | UVar _0 -> true | uu___ -> false
-let (__proj__UVar__item___0 : atom -> FStar_Syntax_Syntax.term FStar_Thunk.t)
-  = fun projectee -> match projectee with | UVar _0 -> _0
-let (uu___is_Lam : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Lam _0 -> true | uu___ -> false
-let (__proj__Lam__item___0 :
-  t' ->
-    (((t * FStar_Syntax_Syntax.aqual) Prims.list -> t) *
-      ((t Prims.list * FStar_Syntax_Syntax.binders *
-         FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option),
-      (t * FStar_Syntax_Syntax.aqual) Prims.list) FStar_Pervasives.either *
-      Prims.int))
-  = fun projectee -> match projectee with | Lam _0 -> _0
-let (uu___is_Accu : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Accu _0 -> true | uu___ -> false
-let (__proj__Accu__item___0 :
-  t' -> (atom * (t * FStar_Syntax_Syntax.aqual) Prims.list)) =
-  fun projectee -> match projectee with | Accu _0 -> _0
-let (uu___is_Construct : t' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Construct _0 -> true | uu___ -> false
-let (__proj__Construct__item___0 :
-  t' ->
-    (FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universe Prims.list * (t *
-      FStar_Syntax_Syntax.aqual) Prims.list))
-  = fun projectee -> match projectee with | Construct _0 -> _0
-let (uu___is_FV : t' -> Prims.bool) =
-  fun projectee -> match projectee with | FV _0 -> true | uu___ -> false
-let (__proj__FV__item___0 :
-  t' ->
-    (FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universe Prims.list * (t *
-      FStar_Syntax_Syntax.aqual) Prims.list))
-  = fun projectee -> match projectee with | FV _0 -> _0
-let (uu___is_Constant : t' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Constant _0 -> true | uu___ -> false
-let (__proj__Constant__item___0 : t' -> constant) =
-  fun projectee -> match projectee with | Constant _0 -> _0
-let (uu___is_Type_t : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Type_t _0 -> true | uu___ -> false
-let (__proj__Type_t__item___0 : t' -> FStar_Syntax_Syntax.universe) =
-  fun projectee -> match projectee with | Type_t _0 -> _0
-let (uu___is_Univ : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Univ _0 -> true | uu___ -> false
-let (__proj__Univ__item___0 : t' -> FStar_Syntax_Syntax.universe) =
-  fun projectee -> match projectee with | Univ _0 -> _0
-let (uu___is_Unknown : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Unknown -> true | uu___ -> false
-let (uu___is_Arrow : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Arrow _0 -> true | uu___ -> false
-let (__proj__Arrow__item___0 :
-  t' ->
-    (FStar_Syntax_Syntax.term FStar_Thunk.t,
-      ((t * FStar_Syntax_Syntax.aqual) Prims.list * comp))
-      FStar_Pervasives.either)
-  = fun projectee -> match projectee with | Arrow _0 -> _0
-let (uu___is_Refinement : t' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Refinement _0 -> true | uu___ -> false
-let (__proj__Refinement__item___0 :
-  t' -> ((t -> t) * (unit -> (t * FStar_Syntax_Syntax.aqual)))) =
-  fun projectee -> match projectee with | Refinement _0 -> _0
-let (uu___is_Reflect : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Reflect _0 -> true | uu___ -> false
-let (__proj__Reflect__item___0 : t' -> t) =
-  fun projectee -> match projectee with | Reflect _0 -> _0
-let (uu___is_Quote : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Quote _0 -> true | uu___ -> false
-let (__proj__Quote__item___0 :
-  t' -> (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.quoteinfo)) =
-  fun projectee -> match projectee with | Quote _0 -> _0
-let (uu___is_Lazy : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Lazy _0 -> true | uu___ -> false
-let (__proj__Lazy__item___0 :
-  t' ->
-    ((FStar_Syntax_Syntax.lazyinfo,
-      (FStar_Compiler_Dyn.dyn * FStar_Syntax_Syntax.emb_typ))
-      FStar_Pervasives.either * t FStar_Thunk.t))
-  = fun projectee -> match projectee with | Lazy _0 -> _0
-let (uu___is_Meta : t' -> Prims.bool) =
-  fun projectee -> match projectee with | Meta _0 -> true | uu___ -> false
-let (__proj__Meta__item___0 :
-  t' -> (t * FStar_Syntax_Syntax.metadata FStar_Thunk.t)) =
-  fun projectee -> match projectee with | Meta _0 -> _0
-let (uu___is_TopLevelLet : t' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TopLevelLet _0 -> true | uu___ -> false
-let (__proj__TopLevelLet__item___0 :
-  t' ->
-    (FStar_Syntax_Syntax.letbinding * Prims.int * (t *
-      FStar_Syntax_Syntax.aqual) Prims.list))
-  = fun projectee -> match projectee with | TopLevelLet _0 -> _0
-let (uu___is_TopLevelRec : t' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TopLevelRec _0 -> true | uu___ -> false
-let (__proj__TopLevelRec__item___0 :
-  t' ->
-    (FStar_Syntax_Syntax.letbinding * Prims.int * Prims.bool Prims.list * (t
-      * FStar_Syntax_Syntax.aqual) Prims.list))
-  = fun projectee -> match projectee with | TopLevelRec _0 -> _0
-let (uu___is_LocalLetRec : t' -> Prims.bool) =
-  fun projectee ->
-    match projectee with | LocalLetRec _0 -> true | uu___ -> false
-let (__proj__LocalLetRec__item___0 :
-  t' ->
-    (Prims.int * FStar_Syntax_Syntax.letbinding *
-      FStar_Syntax_Syntax.letbinding Prims.list * t Prims.list * (t *
-      FStar_Syntax_Syntax.aqual) Prims.list * Prims.int * Prims.bool
-      Prims.list))
-  = fun projectee -> match projectee with | LocalLetRec _0 -> _0
-let (__proj__Mkt__item__nbe_t : t -> t') =
-  fun projectee -> match projectee with | { nbe_t; nbe_r;_} -> nbe_t
-let (__proj__Mkt__item__nbe_r : t -> FStar_Compiler_Range.range) =
-  fun projectee -> match projectee with | { nbe_t; nbe_r;_} -> nbe_r
-let (uu___is_Tot : comp -> Prims.bool) =
-  fun projectee -> match projectee with | Tot _0 -> true | uu___ -> false
-let (__proj__Tot__item___0 : comp -> t) =
-  fun projectee -> match projectee with | Tot _0 -> _0
-let (uu___is_GTot : comp -> Prims.bool) =
-  fun projectee -> match projectee with | GTot _0 -> true | uu___ -> false
-let (__proj__GTot__item___0 : comp -> t) =
-  fun projectee -> match projectee with | GTot _0 -> _0
-let (uu___is_Comp : comp -> Prims.bool) =
-  fun projectee -> match projectee with | Comp _0 -> true | uu___ -> false
-let (__proj__Comp__item___0 : comp -> comp_typ) =
-  fun projectee -> match projectee with | Comp _0 -> _0
-let (__proj__Mkcomp_typ__item__comp_univs :
-  comp_typ -> FStar_Syntax_Syntax.universes) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        comp_univs
-let (__proj__Mkcomp_typ__item__effect_name : comp_typ -> FStar_Ident.lident)
-  =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        effect_name
-let (__proj__Mkcomp_typ__item__result_typ : comp_typ -> t) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        result_typ
-let (__proj__Mkcomp_typ__item__effect_args :
-  comp_typ -> (t * FStar_Syntax_Syntax.aqual) Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} ->
-        effect_args
-let (__proj__Mkcomp_typ__item__flags : comp_typ -> cflag Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { comp_univs; effect_name; result_typ; effect_args; flags;_} -> flags
-let (__proj__Mkresidual_comp__item__residual_effect :
-  residual_comp -> FStar_Ident.lident) =
-  fun projectee ->
-    match projectee with
-    | { residual_effect; residual_typ; residual_flags;_} -> residual_effect
-let (__proj__Mkresidual_comp__item__residual_typ :
-  residual_comp -> t FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { residual_effect; residual_typ; residual_flags;_} -> residual_typ
-let (__proj__Mkresidual_comp__item__residual_flags :
-  residual_comp -> cflag Prims.list) =
-  fun projectee ->
-    match projectee with
-    | { residual_effect; residual_typ; residual_flags;_} -> residual_flags
-let (uu___is_TOTAL : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | TOTAL -> true | uu___ -> false
-let (uu___is_MLEFFECT : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | MLEFFECT -> true | uu___ -> false
-let (uu___is_RETURN : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | RETURN -> true | uu___ -> false
-let (uu___is_PARTIAL_RETURN : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | PARTIAL_RETURN -> true | uu___ -> false
-let (uu___is_SOMETRIVIAL : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SOMETRIVIAL -> true | uu___ -> false
-let (uu___is_TRIVIAL_POSTCONDITION : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | TRIVIAL_POSTCONDITION -> true | uu___ -> false
-let (uu___is_SHOULD_NOT_INLINE : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | SHOULD_NOT_INLINE -> true | uu___ -> false
-let (uu___is_LEMMA : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | LEMMA -> true | uu___ -> false
-let (uu___is_CPS : cflag -> Prims.bool) =
-  fun projectee -> match projectee with | CPS -> true | uu___ -> false
-let (uu___is_DECREASES_lex : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DECREASES_lex _0 -> true | uu___ -> false
-let (__proj__DECREASES_lex__item___0 : cflag -> t Prims.list) =
-  fun projectee -> match projectee with | DECREASES_lex _0 -> _0
-let (uu___is_DECREASES_wf : cflag -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DECREASES_wf _0 -> true | uu___ -> false
-let (__proj__DECREASES_wf__item___0 : cflag -> (t * t)) =
-  fun projectee -> match projectee with | DECREASES_wf _0 -> _0
-type arg = (t * FStar_Syntax_Syntax.aqual)
-type args = (t * FStar_Syntax_Syntax.aqual) Prims.list
-type head = t
-type annot = t FStar_Pervasives_Native.option
-type nbe_cbs =
-  {
-  iapp: t -> args -> t ;
-  translate: FStar_Syntax_Syntax.term -> t }
-let (__proj__Mknbe_cbs__item__iapp : nbe_cbs -> t -> args -> t) =
-  fun projectee -> match projectee with | { iapp; translate;_} -> iapp
-let (__proj__Mknbe_cbs__item__translate :
-  nbe_cbs -> FStar_Syntax_Syntax.term -> t) =
-  fun projectee -> match projectee with | { iapp; translate;_} -> translate
-type 'a embedding =
-  {
-  em: nbe_cbs -> 'a -> t ;
-  un: nbe_cbs -> t -> 'a FStar_Pervasives_Native.option ;
-  typ: t ;
-  emb_typ: FStar_Syntax_Syntax.emb_typ }
-let __proj__Mkembedding__item__em : 'a . 'a embedding -> nbe_cbs -> 'a -> t =
-  fun projectee -> match projectee with | { em; un; typ; emb_typ;_} -> em
-let __proj__Mkembedding__item__un :
-  'a . 'a embedding -> nbe_cbs -> t -> 'a FStar_Pervasives_Native.option =
-  fun projectee -> match projectee with | { em; un; typ; emb_typ;_} -> un
-let __proj__Mkembedding__item__typ : 'a . 'a embedding -> t =
-  fun projectee -> match projectee with | { em; un; typ; emb_typ;_} -> typ
-let __proj__Mkembedding__item__emb_typ :
-  'a . 'a embedding -> FStar_Syntax_Syntax.emb_typ =
-  fun projectee ->
-    match projectee with | { em; un; typ; emb_typ;_} -> emb_typ
-let (isAccu : t -> Prims.bool) =
-  fun trm -> match trm.nbe_t with | Accu uu___ -> true | uu___ -> false
-let (isNotAccu : t -> Prims.bool) =
-  fun x -> match x.nbe_t with | Accu (uu___, uu___1) -> false | uu___ -> true
-let (mk_rt : FStar_Compiler_Range.range -> t' -> t) =
-  fun r -> fun t1 -> { nbe_t = t1; nbe_r = r }
-let (mk_t : t' -> t) = fun t1 -> mk_rt FStar_Compiler_Range.dummyRange t1
-let (nbe_t_of_t : t -> t') = fun t1 -> t1.nbe_t
-let (mkConstruct :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.universe Prims.list -> args -> t)
-  =
-  fun i ->
-    fun us ->
-      fun ts ->
-        FStar_Compiler_Effect.op_Less_Bar mk_t (Construct (i, us, ts))
-let (mkFV :
-  FStar_Syntax_Syntax.fv ->
-    FStar_Syntax_Syntax.universe Prims.list -> args -> t)
-  =
-  fun i ->
-    fun us ->
-      fun ts ->
-        let uu___ = FStar_Syntax_Syntax.range_of_fv i in
-        mk_rt uu___ (FV (i, us, ts))
-let (mkAccuVar : var -> t) =
-  fun v ->
-    let uu___ = FStar_Syntax_Syntax.range_of_bv v in
-    mk_rt uu___ (Accu ((Var v), []))
-let (mkAccuMatch :
-  t ->
-    (unit ->
-       FStar_Syntax_Syntax.match_returns_ascription
-         FStar_Pervasives_Native.option)
-      ->
-      (unit -> FStar_Syntax_Syntax.branch Prims.list) ->
-        (unit ->
-           FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option)
-          -> t)
-  =
-  fun s ->
-    fun ret ->
-      fun bs ->
-        fun rc ->
-          FStar_Compiler_Effect.op_Less_Bar mk_t
-            (Accu ((Match (s, ret, bs, rc)), []))
-let (equal_if : Prims.bool -> FStar_Syntax_Util.eq_result) =
-  fun uu___ ->
-    if uu___ then FStar_Syntax_Util.Equal else FStar_Syntax_Util.Unknown
-let (equal_iff : Prims.bool -> FStar_Syntax_Util.eq_result) =
-  fun uu___ ->
-    if uu___ then FStar_Syntax_Util.Equal else FStar_Syntax_Util.NotEqual
-let (eq_inj :
-  FStar_Syntax_Util.eq_result ->
-    FStar_Syntax_Util.eq_result -> FStar_Syntax_Util.eq_result)
-  =
-  fun r1 ->
-    fun r2 ->
-      match (r1, r2) with
-      | (FStar_Syntax_Util.Equal, FStar_Syntax_Util.Equal) ->
-          FStar_Syntax_Util.Equal
-      | (FStar_Syntax_Util.NotEqual, uu___) -> FStar_Syntax_Util.NotEqual
-      | (uu___, FStar_Syntax_Util.NotEqual) -> FStar_Syntax_Util.NotEqual
-      | (FStar_Syntax_Util.Unknown, uu___) -> FStar_Syntax_Util.Unknown
-      | (uu___, FStar_Syntax_Util.Unknown) -> FStar_Syntax_Util.Unknown
-let (eq_and :
-  FStar_Syntax_Util.eq_result ->
-    (unit -> FStar_Syntax_Util.eq_result) -> FStar_Syntax_Util.eq_result)
-  =
-  fun f ->
-    fun g ->
-      match f with
-      | FStar_Syntax_Util.Equal -> g ()
-      | uu___ -> FStar_Syntax_Util.Unknown
-let (eq_constant : constant -> constant -> FStar_Syntax_Util.eq_result) =
-  fun c1 ->
-    fun c2 ->
-      match (c1, c2) with
-      | (Unit, Unit) -> FStar_Syntax_Util.Equal
-      | (Bool b1, Bool b2) -> equal_iff (b1 = b2)
-      | (Int i1, Int i2) -> equal_iff (i1 = i2)
-      | (String (s1, uu___), String (s2, uu___1)) -> equal_iff (s1 = s2)
-      | (Char c11, Char c21) -> equal_iff (c11 = c21)
-      | (Range r1, Range r2) -> FStar_Syntax_Util.Unknown
-      | (uu___, uu___1) -> FStar_Syntax_Util.NotEqual
-let rec (eq_t : t -> t -> FStar_Syntax_Util.eq_result) =
-  fun t1 ->
-    fun t2 ->
-      match ((t1.nbe_t), (t2.nbe_t)) with
-      | (Lam uu___, Lam uu___1) -> FStar_Syntax_Util.Unknown
-      | (Accu (a1, as1), Accu (a2, as2)) ->
-          let uu___ = eq_atom a1 a2 in
-          eq_and uu___ (fun uu___1 -> eq_args as1 as2)
-      | (Construct (v1, us1, args1), Construct (v2, us2, args2)) ->
-          let uu___ = FStar_Syntax_Syntax.fv_eq v1 v2 in
-          if uu___
-          then
-            (if
-               (FStar_Compiler_List.length args1) <>
-                 (FStar_Compiler_List.length args2)
-             then failwith "eq_t, different number of args on Construct"
-             else ();
-             (let uu___2 = FStar_Compiler_List.zip args1 args2 in
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_Compiler_List.fold_left
-                   (fun acc ->
-                      fun uu___3 ->
-                        match uu___3 with
-                        | ((a1, uu___4), (a2, uu___5)) ->
-                            let uu___6 = eq_t a1 a2 in eq_inj acc uu___6)
-                   FStar_Syntax_Util.Equal) uu___2))
-          else FStar_Syntax_Util.NotEqual
-      | (FV (v1, us1, args1), FV (v2, us2, args2)) ->
-          let uu___ = FStar_Syntax_Syntax.fv_eq v1 v2 in
-          if uu___
-          then
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Util.eq_univs_list us1 us2 in
-              equal_iff uu___2 in
-            eq_and uu___1 (fun uu___2 -> eq_args args1 args2)
-          else FStar_Syntax_Util.Unknown
-      | (Constant c1, Constant c2) -> eq_constant c1 c2
-      | (Type_t u1, Type_t u2) ->
-          let uu___ = FStar_Syntax_Util.eq_univs u1 u2 in equal_iff uu___
-      | (Univ u1, Univ u2) ->
-          let uu___ = FStar_Syntax_Util.eq_univs u1 u2 in equal_iff uu___
-      | (Refinement (r1, t11), Refinement (r2, t21)) ->
-          let x =
-            FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-              FStar_Syntax_Syntax.t_unit in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = t11 () in FStar_Pervasives_Native.fst uu___2 in
-            let uu___2 =
-              let uu___3 = t21 () in FStar_Pervasives_Native.fst uu___3 in
-            eq_t uu___1 uu___2 in
-          eq_and uu___
-            (fun uu___1 ->
-               let uu___2 = let uu___3 = mkAccuVar x in r1 uu___3 in
-               let uu___3 = let uu___4 = mkAccuVar x in r2 uu___4 in
-               eq_t uu___2 uu___3)
-      | (Unknown, Unknown) -> FStar_Syntax_Util.Equal
-      | (uu___, uu___1) -> FStar_Syntax_Util.Unknown
-and (eq_atom : atom -> atom -> FStar_Syntax_Util.eq_result) =
-  fun a1 ->
-    fun a2 ->
-      match (a1, a2) with
-      | (Var bv1, Var bv2) ->
-          let uu___ = FStar_Syntax_Syntax.bv_eq bv1 bv2 in equal_if uu___
-      | (uu___, uu___1) -> FStar_Syntax_Util.Unknown
-and (eq_arg : arg -> arg -> FStar_Syntax_Util.eq_result) =
-  fun a1 ->
-    fun a2 ->
-      eq_t (FStar_Pervasives_Native.fst a1) (FStar_Pervasives_Native.fst a2)
-and (eq_args : args -> args -> FStar_Syntax_Util.eq_result) =
-  fun as1 ->
-    fun as2 ->
-      match (as1, as2) with
-      | ([], []) -> FStar_Syntax_Util.Equal
-      | (x::xs, y::ys) ->
-          let uu___ = eq_arg x y in
-          eq_and uu___ (fun uu___1 -> eq_args xs ys)
-      | (uu___, uu___1) -> FStar_Syntax_Util.Unknown
-let (constant_to_string : constant -> Prims.string) =
-  fun c ->
-    match c with
-    | Unit -> "Unit"
-    | Bool b -> if b then "Bool true" else "Bool false"
-    | Int i -> FStar_BigInt.string_of_big_int i
-    | Char c1 ->
-        FStar_Compiler_Util.format1 "'%s'"
-          (FStar_Compiler_Util.string_of_char c1)
-    | String (s, uu___) -> FStar_Compiler_Util.format1 "\"%s\"" s
-    | Range r ->
-        let uu___ = FStar_Compiler_Range.string_of_range r in
-        FStar_Compiler_Util.format1 "Range %s" uu___
-    | SConst s -> FStar_Syntax_Print.const_to_string s
-let rec (t_to_string : t -> Prims.string) =
-  fun x ->
-    match x.nbe_t with
-    | Lam (b, uu___, arity) ->
-        let uu___1 = FStar_Compiler_Util.string_of_int arity in
-        FStar_Compiler_Util.format1 "Lam (_, %s args)" uu___1
-    | Accu (a, l) ->
-        let uu___ =
-          let uu___1 = atom_to_string a in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_List.map
-                    (fun x1 -> t_to_string (FStar_Pervasives_Native.fst x1))
-                    l in
-                FStar_String.concat "; " uu___5 in
-              FStar_String.op_Hat uu___4 ")" in
-            FStar_String.op_Hat ") (" uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "Accu (" uu___
-    | Construct (fv, us, l) ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.fv_to_string fv in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_List.map FStar_Syntax_Print.univ_to_string
-                    us in
-                FStar_String.concat "; " uu___5 in
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      FStar_Compiler_List.map
-                        (fun x1 ->
-                           t_to_string (FStar_Pervasives_Native.fst x1)) l in
-                    FStar_String.concat "; " uu___8 in
-                  FStar_String.op_Hat uu___7 "]" in
-                FStar_String.op_Hat "] [" uu___6 in
-              FStar_String.op_Hat uu___4 uu___5 in
-            FStar_String.op_Hat ") [" uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "Construct (" uu___
-    | FV (fv, us, l) ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.fv_to_string fv in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_List.map FStar_Syntax_Print.univ_to_string
-                    us in
-                FStar_String.concat "; " uu___5 in
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 =
-                      FStar_Compiler_List.map
-                        (fun x1 ->
-                           t_to_string (FStar_Pervasives_Native.fst x1)) l in
-                    FStar_String.concat "; " uu___8 in
-                  FStar_String.op_Hat uu___7 "]" in
-                FStar_String.op_Hat "] [" uu___6 in
-              FStar_String.op_Hat uu___4 uu___5 in
-            FStar_String.op_Hat ") [" uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "FV (" uu___
-    | Constant c -> constant_to_string c
-    | Univ u ->
-        let uu___ = FStar_Syntax_Print.univ_to_string u in
-        FStar_String.op_Hat "Universe " uu___
-    | Type_t u ->
-        let uu___ = FStar_Syntax_Print.univ_to_string u in
-        FStar_String.op_Hat "Type_t " uu___
-    | Arrow uu___ -> "Arrow"
-    | Refinement (f, t1) ->
-        let x1 =
-          FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-            FStar_Syntax_Syntax.t_unit in
-        let t2 = let uu___ = t1 () in FStar_Pervasives_Native.fst uu___ in
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.bv_to_string x1 in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = t_to_string t2 in
-              let uu___5 =
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 = let uu___9 = mkAccuVar x1 in f uu___9 in
-                    t_to_string uu___8 in
-                  FStar_String.op_Hat uu___7 "}" in
-                FStar_String.op_Hat "{" uu___6 in
-              FStar_String.op_Hat uu___4 uu___5 in
-            FStar_String.op_Hat ":" uu___3 in
-          FStar_String.op_Hat uu___1 uu___2 in
-        FStar_String.op_Hat "Refinement " uu___
-    | Unknown -> "Unknown"
-    | Reflect t1 ->
-        let uu___ = t_to_string t1 in FStar_String.op_Hat "Reflect " uu___
-    | Quote uu___ -> "Quote _"
-    | Lazy (FStar_Pervasives.Inl li, uu___) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Util.unfold_lazy li in
-          FStar_Syntax_Print.term_to_string uu___2 in
-        FStar_Compiler_Util.format1 "Lazy (Inl {%s})" uu___1
-    | Lazy (FStar_Pervasives.Inr (uu___, et), uu___1) ->
-        let uu___2 = FStar_Syntax_Print.emb_typ_to_string et in
-        FStar_Compiler_Util.format1 "Lazy (Inr (?, %s))" uu___2
-    | LocalLetRec (uu___, l, uu___1, uu___2, uu___3, uu___4, uu___5) ->
-        let uu___6 =
-          let uu___7 = FStar_Syntax_Print.lbs_to_string [] (true, [l]) in
-          FStar_String.op_Hat uu___7 ")" in
-        FStar_String.op_Hat "LocalLetRec (" uu___6
-    | TopLevelLet (lb, uu___, uu___1) ->
-        let uu___2 =
-          let uu___3 =
-            let uu___4 =
-              FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-            FStar_Syntax_Print.fv_to_string uu___4 in
-          FStar_String.op_Hat uu___3 ")" in
-        FStar_String.op_Hat "TopLevelLet (" uu___2
-    | TopLevelRec (lb, uu___, uu___1, uu___2) ->
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              FStar_Compiler_Util.right lb.FStar_Syntax_Syntax.lbname in
-            FStar_Syntax_Print.fv_to_string uu___5 in
-          FStar_String.op_Hat uu___4 ")" in
-        FStar_String.op_Hat "TopLevelRec (" uu___3
-    | Meta (t1, uu___) ->
-        let uu___1 = t_to_string t1 in FStar_String.op_Hat "Meta " uu___1
-and (atom_to_string : atom -> Prims.string) =
-  fun a ->
-    match a with
-    | Var v ->
-        let uu___ = FStar_Syntax_Print.bv_to_string v in
-        FStar_String.op_Hat "Var " uu___
-    | Match (t1, uu___, uu___1, uu___2) ->
-        let uu___3 = t_to_string t1 in FStar_String.op_Hat "Match " uu___3
-    | UnreducedLet (var1, typ, def, body, lb) ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Print.lbs_to_string [] (false, [lb]) in
-          FStar_String.op_Hat uu___1 " in ...)" in
-        FStar_String.op_Hat "UnreducedLet(" uu___
-    | UnreducedLetRec (uu___, body, lbs) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Print.lbs_to_string [] (true, lbs) in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = t_to_string body in FStar_String.op_Hat uu___5 ")" in
-            FStar_String.op_Hat " in " uu___4 in
-          FStar_String.op_Hat uu___2 uu___3 in
-        FStar_String.op_Hat "UnreducedLetRec(" uu___1
-    | UVar uu___ -> "UVar"
-let (arg_to_string : arg -> Prims.string) =
-  fun a ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater a FStar_Pervasives_Native.fst in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ t_to_string
-let (args_to_string : args -> Prims.string) =
-  fun args1 ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater args1
-        (FStar_Compiler_List.map arg_to_string) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat " ")
-let (iapp_cb : nbe_cbs -> t -> args -> t) =
-  fun cbs -> fun h -> fun a -> cbs.iapp h a
-let (translate_cb : nbe_cbs -> FStar_Syntax_Syntax.term -> t) =
-  fun cbs -> fun t1 -> cbs.translate t1
-let embed : 'a . 'a embedding -> nbe_cbs -> 'a -> t =
-  fun e -> fun cb -> fun x -> e.em cb x
-let unembed :
-  'a . 'a embedding -> nbe_cbs -> t -> 'a FStar_Pervasives_Native.option =
-  fun e -> fun cb -> fun trm -> e.un cb trm
-let type_of : 'a . 'a embedding -> t = fun e -> e.typ
-let mk_emb :
-  'a .
-    (nbe_cbs -> 'a -> t) ->
-      (nbe_cbs -> t -> 'a FStar_Pervasives_Native.option) ->
-        t -> FStar_Syntax_Syntax.emb_typ -> 'a embedding
-  = fun em -> fun un -> fun typ -> fun et -> { em; un; typ; emb_typ = et }
-let mk_emb' :
-  'uuuuu .
-    (nbe_cbs -> 'uuuuu -> t') ->
-      (nbe_cbs -> t' -> 'uuuuu FStar_Pervasives_Native.option) ->
-        t -> FStar_Syntax_Syntax.emb_typ -> 'uuuuu embedding
-  =
-  fun em ->
-    fun un ->
-      mk_emb
-        (fun cbs ->
-           fun t1 ->
-             let uu___ = em cbs t1 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t uu___)
-        (fun cbs -> fun t1 -> un cbs t1.nbe_t)
-let embed_as :
-  'a 'b .
-    'a embedding ->
-      ('a -> 'b) ->
-        ('b -> 'a) -> t FStar_Pervasives_Native.option -> 'b embedding
-  =
-  fun ea ->
-    fun ab ->
-      fun ba ->
-        fun ot ->
-          mk_emb (fun cbs -> fun x -> let uu___ = ba x in embed ea cbs uu___)
-            (fun cbs ->
-               fun t1 ->
-                 let uu___ = unembed ea cbs t1 in
-                 FStar_Compiler_Util.map_opt uu___ ab)
-            (match ot with
-             | FStar_Pervasives_Native.Some t1 -> t1
-             | FStar_Pervasives_Native.None -> ea.typ) ea.emb_typ
-let (lid_as_constr :
-  FStar_Ident.lident -> FStar_Syntax_Syntax.universe Prims.list -> args -> t)
-  =
-  fun l ->
-    fun us ->
-      fun args1 ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv l FStar_Syntax_Syntax.delta_constant
-            (FStar_Pervasives_Native.Some FStar_Syntax_Syntax.Data_ctor) in
-        mkConstruct uu___ us args1
-let (lid_as_typ :
-  FStar_Ident.lident -> FStar_Syntax_Syntax.universe Prims.list -> args -> t)
-  =
-  fun l ->
-    fun us ->
-      fun args1 ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv l FStar_Syntax_Syntax.delta_constant
-            FStar_Pervasives_Native.None in
-        mkFV uu___ us args1
-let (as_iarg : t -> arg) =
-  fun a ->
-    let uu___ = FStar_Syntax_Syntax.as_aqual_implicit true in (a, uu___)
-let (as_arg : t -> arg) = fun a -> (a, FStar_Pervasives_Native.None)
-let (make_arrow1 : t -> arg -> t) =
-  fun t1 ->
-    fun a ->
-      FStar_Compiler_Effect.op_Less_Bar mk_t
-        (Arrow (FStar_Pervasives.Inr ([a], (Tot t1))))
-let lazy_embed : 'a . FStar_Syntax_Syntax.emb_typ -> 'a -> (unit -> t) -> t =
-  fun et ->
-    fun x ->
-      fun f ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.emb_typ_to_string et in
-           FStar_Compiler_Util.print1 "Embedding\n\temb_typ=%s\n" uu___2
-         else ());
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Bang FStar_Options.eager_embedding in
-         if uu___1
-         then f ()
-         else
-           (let thunk = FStar_Thunk.mk f in
-            let li = let uu___3 = FStar_Compiler_Dyn.mkdyn x in (uu___3, et) in
-            FStar_Compiler_Effect.op_Less_Bar mk_t
-              (Lazy ((FStar_Pervasives.Inr li), thunk))))
-let lazy_unembed :
-  'uuuuu 'a .
-    'uuuuu ->
-      FStar_Syntax_Syntax.emb_typ ->
-        t ->
-          (t -> 'a FStar_Pervasives_Native.option) ->
-            'a FStar_Pervasives_Native.option
-  =
-  fun cb ->
-    fun et ->
-      fun x ->
-        fun f ->
-          match x.nbe_t with
-          | Lazy (FStar_Pervasives.Inl li, thunk) ->
-              let uu___ = FStar_Thunk.force thunk in f uu___
-          | Lazy (FStar_Pervasives.Inr (b, et'), thunk) ->
-              let uu___ =
-                (et <> et') ||
-                  (FStar_Compiler_Effect.op_Bang
-                     FStar_Options.eager_embedding) in
-              if uu___
-              then
-                let res = let uu___1 = FStar_Thunk.force thunk in f uu___1 in
-                ((let uu___2 =
-                    FStar_Compiler_Effect.op_Bang
-                      FStar_Options.debug_embedding in
-                  if uu___2
-                  then
-                    let uu___3 = FStar_Syntax_Print.emb_typ_to_string et in
-                    let uu___4 = FStar_Syntax_Print.emb_typ_to_string et' in
-                    FStar_Compiler_Util.print2
-                      "Unembed cancellation failed\n\t%s <> %s\n" uu___3
-                      uu___4
-                  else ());
-                 res)
-              else
-                (let a1 = FStar_Compiler_Dyn.undyn b in
-                 (let uu___3 =
-                    FStar_Compiler_Effect.op_Bang
-                      FStar_Options.debug_embedding in
-                  if uu___3
-                  then
-                    let uu___4 = FStar_Syntax_Print.emb_typ_to_string et in
-                    FStar_Compiler_Util.print1 "Unembed cancelled for %s\n"
-                      uu___4
-                  else ());
-                 FStar_Pervasives_Native.Some a1)
-          | uu___ ->
-              let aopt = f x in
-              ((let uu___2 =
-                  FStar_Compiler_Effect.op_Bang FStar_Options.debug_embedding in
-                if uu___2
-                then
-                  let uu___3 = FStar_Syntax_Print.emb_typ_to_string et in
-                  FStar_Compiler_Util.print1 "Unembedding:\n\temb_typ=%s\n"
-                    uu___3
-                else ());
-               aopt)
-let (mk_any_emb : t -> t embedding) =
-  fun ty ->
-    let em _cb a = a in
-    let un _cb t1 = FStar_Pervasives_Native.Some t1 in
-    mk_emb em un ty FStar_Syntax_Syntax.ET_abstract
-let (e_any : t embedding) =
-  let em _cb a = a in
-  let un _cb t1 = FStar_Pervasives_Native.Some t1 in
-  let uu___ = lid_as_typ FStar_Parser_Const.term_lid [] [] in
-  mk_emb em un uu___ FStar_Syntax_Syntax.ET_abstract
-let (e_unit : unit embedding) =
-  let em _cb a = Constant Unit in
-  let un _cb t1 = FStar_Pervasives_Native.Some () in
-  let uu___ = lid_as_typ FStar_Parser_Const.unit_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_unit in
-  mk_emb' em un uu___ uu___1
-let (e_bool : Prims.bool embedding) =
-  let em _cb a = Constant (Bool a) in
-  let un _cb t1 =
-    match t1 with
-    | Constant (Bool a) -> FStar_Pervasives_Native.Some a
-    | uu___ -> FStar_Pervasives_Native.None in
-  let uu___ = lid_as_typ FStar_Parser_Const.bool_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_unit in
-  mk_emb' em un uu___ uu___1
-let (e_char : FStar_Char.char embedding) =
-  let em _cb c = Constant (Char c) in
-  let un _cb c =
-    match c with
-    | Constant (Char a) -> FStar_Pervasives_Native.Some a
-    | uu___ -> FStar_Pervasives_Native.None in
-  let uu___ = lid_as_typ FStar_Parser_Const.char_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_char in
-  mk_emb' em un uu___ uu___1
-let (e_string : Prims.string embedding) =
-  let em _cb s = Constant (String (s, FStar_Compiler_Range.dummyRange)) in
-  let un _cb s =
-    match s with
-    | Constant (String (s1, uu___)) -> FStar_Pervasives_Native.Some s1
-    | uu___ -> FStar_Pervasives_Native.None in
-  let uu___ = lid_as_typ FStar_Parser_Const.string_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_string in
-  mk_emb' em un uu___ uu___1
-let (e_int : FStar_BigInt.t embedding) =
-  let em _cb c = Constant (Int c) in
-  let un _cb c =
-    match c with
-    | Constant (Int a) -> FStar_Pervasives_Native.Some a
-    | uu___ -> FStar_Pervasives_Native.None in
-  let uu___ = lid_as_typ FStar_Parser_Const.int_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_int in
-  mk_emb' em un uu___ uu___1
-let e_option :
-  'a . 'a embedding -> 'a FStar_Pervasives_Native.option embedding =
-  fun ea ->
-    let etyp =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.option_lid
-            FStar_Ident.string_of_lid in
-        (uu___1, [ea.emb_typ]) in
-      FStar_Syntax_Syntax.ET_app uu___ in
-    let em cb o =
-      lazy_embed etyp o
-        (fun uu___ ->
-           match o with
-           | FStar_Pervasives_Native.None ->
-               let uu___1 =
-                 let uu___2 = let uu___3 = type_of ea in as_iarg uu___3 in
-                 [uu___2] in
-               lid_as_constr FStar_Parser_Const.none_lid
-                 [FStar_Syntax_Syntax.U_zero] uu___1
-           | FStar_Pervasives_Native.Some x ->
-               let uu___1 =
-                 let uu___2 = let uu___3 = embed ea cb x in as_arg uu___3 in
-                 let uu___3 =
-                   let uu___4 = let uu___5 = type_of ea in as_iarg uu___5 in
-                   [uu___4] in
-                 uu___2 :: uu___3 in
-               lid_as_constr FStar_Parser_Const.some_lid
-                 [FStar_Syntax_Syntax.U_zero] uu___1) in
-    let un cb trm =
-      lazy_unembed cb etyp trm
-        (fun trm1 ->
-           match trm1.nbe_t with
-           | Construct (fvar, us, args1) when
-               FStar_Syntax_Syntax.fv_eq_lid fvar FStar_Parser_Const.none_lid
-               -> FStar_Pervasives_Native.Some FStar_Pervasives_Native.None
-           | Construct (fvar, us, (a1, uu___)::uu___1::[]) when
-               FStar_Syntax_Syntax.fv_eq_lid fvar FStar_Parser_Const.some_lid
-               ->
-               let uu___2 = unembed ea cb a1 in
-               FStar_Compiler_Util.bind_opt uu___2
-                 (fun a2 ->
-                    FStar_Pervasives_Native.Some
-                      (FStar_Pervasives_Native.Some a2))
-           | uu___ -> FStar_Pervasives_Native.None) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 = let uu___3 = type_of ea in as_arg uu___3 in [uu___2] in
-      lid_as_typ FStar_Parser_Const.option_lid [FStar_Syntax_Syntax.U_zero]
-        uu___1 in
-    mk_emb em un uu___ etyp
-let e_tuple2 : 'a 'b . 'a embedding -> 'b embedding -> ('a * 'b) embedding =
-  fun ea ->
-    fun eb ->
-      let etyp =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              FStar_Parser_Const.lid_tuple2 FStar_Ident.string_of_lid in
-          (uu___1, [ea.emb_typ; eb.emb_typ]) in
-        FStar_Syntax_Syntax.ET_app uu___ in
-      let em cb x =
-        lazy_embed etyp x
-          (fun uu___ ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 = embed eb cb (FStar_Pervasives_Native.snd x) in
-                 as_arg uu___3 in
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = embed ea cb (FStar_Pervasives_Native.fst x) in
-                   as_arg uu___5 in
-                 let uu___5 =
-                   let uu___6 = let uu___7 = type_of eb in as_iarg uu___7 in
-                   let uu___7 =
-                     let uu___8 = let uu___9 = type_of ea in as_iarg uu___9 in
-                     [uu___8] in
-                   uu___6 :: uu___7 in
-                 uu___4 :: uu___5 in
-               uu___2 :: uu___3 in
-             lid_as_constr FStar_Parser_Const.lid_Mktuple2
-               [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero]
-               uu___1) in
-      let un cb trm =
-        lazy_unembed cb etyp trm
-          (fun trm1 ->
-             match trm1.nbe_t with
-             | Construct
-                 (fvar, us, (b1, uu___)::(a1, uu___1)::uu___2::uu___3::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fvar
-                   FStar_Parser_Const.lid_Mktuple2
-                 ->
-                 let uu___4 = unembed ea cb a1 in
-                 FStar_Compiler_Util.bind_opt uu___4
-                   (fun a2 ->
-                      let uu___5 = unembed eb cb b1 in
-                      FStar_Compiler_Util.bind_opt uu___5
-                        (fun b2 -> FStar_Pervasives_Native.Some (a2, b2)))
-             | uu___ -> FStar_Pervasives_Native.None) in
-      let uu___ =
-        let uu___1 =
-          let uu___2 = let uu___3 = type_of eb in as_arg uu___3 in
-          let uu___3 =
-            let uu___4 = let uu___5 = type_of ea in as_arg uu___5 in [uu___4] in
-          uu___2 :: uu___3 in
-        lid_as_typ FStar_Parser_Const.lid_tuple2
-          [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero] uu___1 in
-      mk_emb em un uu___ etyp
-let e_tuple3 :
-  'a 'b 'c .
-    'a embedding -> 'b embedding -> 'c embedding -> ('a * 'b * 'c) embedding
-  =
-  fun ea ->
-    fun eb ->
-      fun ec ->
-        let etyp =
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                FStar_Parser_Const.lid_tuple3 FStar_Ident.string_of_lid in
-            (uu___1, [ea.emb_typ; eb.emb_typ; ec.emb_typ]) in
-          FStar_Syntax_Syntax.ET_app uu___ in
-        let em cb uu___ =
-          match uu___ with
-          | (x1, x2, x3) ->
-              lazy_embed etyp (x1, x2, x3)
-                (fun uu___1 ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 = embed ec cb x3 in as_arg uu___4 in
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 = embed eb cb x2 in as_arg uu___6 in
-                       let uu___6 =
-                         let uu___7 =
-                           let uu___8 = embed ea cb x1 in as_arg uu___8 in
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 = type_of ec in as_iarg uu___10 in
-                           let uu___10 =
-                             let uu___11 =
-                               let uu___12 = type_of eb in as_iarg uu___12 in
-                             let uu___12 =
-                               let uu___13 =
-                                 let uu___14 = type_of ea in as_iarg uu___14 in
-                               [uu___13] in
-                             uu___11 :: uu___12 in
-                           uu___9 :: uu___10 in
-                         uu___7 :: uu___8 in
-                       uu___5 :: uu___6 in
-                     uu___3 :: uu___4 in
-                   lid_as_constr FStar_Parser_Const.lid_Mktuple3
-                     [FStar_Syntax_Syntax.U_zero;
-                     FStar_Syntax_Syntax.U_zero;
-                     FStar_Syntax_Syntax.U_zero] uu___2) in
-        let un cb trm =
-          lazy_unembed cb etyp trm
-            (fun trm1 ->
-               match trm1.nbe_t with
-               | Construct
-                   (fvar, us,
-                    (c1, uu___)::(b1, uu___1)::(a1, uu___2)::uu___3::uu___4::[])
-                   when
-                   FStar_Syntax_Syntax.fv_eq_lid fvar
-                     FStar_Parser_Const.lid_Mktuple3
-                   ->
-                   let uu___5 = unembed ea cb a1 in
-                   FStar_Compiler_Util.bind_opt uu___5
-                     (fun a2 ->
-                        let uu___6 = unembed eb cb b1 in
-                        FStar_Compiler_Util.bind_opt uu___6
-                          (fun b2 ->
-                             let uu___7 = unembed ec cb c1 in
-                             FStar_Compiler_Util.bind_opt uu___7
-                               (fun c2 ->
-                                  FStar_Pervasives_Native.Some (a2, b2, c2))))
-               | uu___ -> FStar_Pervasives_Native.None) in
-        let uu___ =
-          let uu___1 =
-            let uu___2 = let uu___3 = type_of ec in as_arg uu___3 in
-            let uu___3 =
-              let uu___4 = let uu___5 = type_of eb in as_arg uu___5 in
-              let uu___5 =
-                let uu___6 = let uu___7 = type_of ea in as_arg uu___7 in
-                [uu___6] in
-              uu___4 :: uu___5 in
-            uu___2 :: uu___3 in
-          lid_as_typ FStar_Parser_Const.lid_tuple3
-            [FStar_Syntax_Syntax.U_zero;
-            FStar_Syntax_Syntax.U_zero;
-            FStar_Syntax_Syntax.U_zero] uu___1 in
-        mk_emb em un uu___ etyp
-let e_either :
-  'a 'b .
-    'a embedding ->
-      'b embedding -> ('a, 'b) FStar_Pervasives.either embedding
-  =
-  fun ea ->
-    fun eb ->
-      let etyp =
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              FStar_Parser_Const.either_lid FStar_Ident.string_of_lid in
-          (uu___1, [ea.emb_typ; eb.emb_typ]) in
-        FStar_Syntax_Syntax.ET_app uu___ in
-      let em cb s =
-        lazy_embed etyp s
-          (fun uu___ ->
-             match s with
-             | FStar_Pervasives.Inl a1 ->
-                 let uu___1 =
-                   let uu___2 = let uu___3 = embed ea cb a1 in as_arg uu___3 in
-                   let uu___3 =
-                     let uu___4 = let uu___5 = type_of eb in as_iarg uu___5 in
-                     let uu___5 =
-                       let uu___6 = let uu___7 = type_of ea in as_iarg uu___7 in
-                       [uu___6] in
-                     uu___4 :: uu___5 in
-                   uu___2 :: uu___3 in
-                 lid_as_constr FStar_Parser_Const.inl_lid
-                   [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero]
-                   uu___1
-             | FStar_Pervasives.Inr b1 ->
-                 let uu___1 =
-                   let uu___2 = let uu___3 = embed eb cb b1 in as_arg uu___3 in
-                   let uu___3 =
-                     let uu___4 = let uu___5 = type_of eb in as_iarg uu___5 in
-                     let uu___5 =
-                       let uu___6 = let uu___7 = type_of ea in as_iarg uu___7 in
-                       [uu___6] in
-                     uu___4 :: uu___5 in
-                   uu___2 :: uu___3 in
-                 lid_as_constr FStar_Parser_Const.inr_lid
-                   [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero]
-                   uu___1) in
-      let un cb trm =
-        lazy_unembed cb etyp trm
-          (fun trm1 ->
-             match trm1.nbe_t with
-             | Construct (fvar, us, (a1, uu___)::uu___1::uu___2::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fvar
-                   FStar_Parser_Const.inl_lid
-                 ->
-                 let uu___3 = unembed ea cb a1 in
-                 FStar_Compiler_Util.bind_opt uu___3
-                   (fun a2 ->
-                      FStar_Pervasives_Native.Some (FStar_Pervasives.Inl a2))
-             | Construct (fvar, us, (b1, uu___)::uu___1::uu___2::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fvar
-                   FStar_Parser_Const.inr_lid
-                 ->
-                 let uu___3 = unembed eb cb b1 in
-                 FStar_Compiler_Util.bind_opt uu___3
-                   (fun b2 ->
-                      FStar_Pervasives_Native.Some (FStar_Pervasives.Inr b2))
-             | uu___ -> FStar_Pervasives_Native.None) in
-      let uu___ =
-        let uu___1 =
-          let uu___2 = let uu___3 = type_of eb in as_arg uu___3 in
-          let uu___3 =
-            let uu___4 = let uu___5 = type_of ea in as_arg uu___5 in [uu___4] in
-          uu___2 :: uu___3 in
-        lid_as_typ FStar_Parser_Const.either_lid
-          [FStar_Syntax_Syntax.U_zero; FStar_Syntax_Syntax.U_zero] uu___1 in
-      mk_emb em un uu___ etyp
-let (e_range : FStar_Compiler_Range.range embedding) =
-  let em cb r = Constant (Range r) in
-  let un cb t1 =
-    match t1 with
-    | Constant (Range r) -> FStar_Pervasives_Native.Some r
-    | uu___ -> FStar_Pervasives_Native.None in
-  let uu___ = lid_as_typ FStar_Parser_Const.range_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_range in
-  mk_emb' em un uu___ uu___1
-let (e_vconfig : FStar_VConfig.vconfig embedding) =
-  let em cb r = failwith "e_vconfig NBE" in
-  let un cb t1 = failwith "e_vconfig NBE" in
-  let uu___ = lid_as_typ FStar_Parser_Const.vconfig_lid [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_vconfig in
-  mk_emb' em un uu___ uu___1
-let e_list : 'a . 'a embedding -> 'a Prims.list embedding =
-  fun ea ->
-    let etyp =
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater FStar_Parser_Const.list_lid
-            FStar_Ident.string_of_lid in
-        (uu___1, [ea.emb_typ]) in
-      FStar_Syntax_Syntax.ET_app uu___ in
-    let em cb l =
-      lazy_embed etyp l
-        (fun uu___ ->
-           let typ = let uu___1 = type_of ea in as_iarg uu___1 in
-           let nil =
-             lid_as_constr FStar_Parser_Const.nil_lid
-               [FStar_Syntax_Syntax.U_zero] [typ] in
-           let cons hd tl =
-             let uu___1 =
-               let uu___2 = as_arg tl in
-               let uu___3 =
-                 let uu___4 = let uu___5 = embed ea cb hd in as_arg uu___5 in
-                 [uu___4; typ] in
-               uu___2 :: uu___3 in
-             lid_as_constr FStar_Parser_Const.cons_lid
-               [FStar_Syntax_Syntax.U_zero] uu___1 in
-           FStar_Compiler_List.fold_right cons l nil) in
-    let rec un cb trm =
-      lazy_unembed cb etyp trm
-        (fun trm1 ->
-           match trm1.nbe_t with
-           | Construct (fv, uu___, uu___1) when
-               FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.nil_lid ->
-               FStar_Pervasives_Native.Some []
-           | Construct
-               (fv, uu___,
-                (tl, FStar_Pervasives_Native.None)::(hd,
-                                                     FStar_Pervasives_Native.None)::
-                (uu___1, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___2;_})::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid
-               ->
-               let uu___3 = unembed ea cb hd in
-               FStar_Compiler_Util.bind_opt uu___3
-                 (fun hd1 ->
-                    let uu___4 = un cb tl in
-                    FStar_Compiler_Util.bind_opt uu___4
-                      (fun tl1 -> FStar_Pervasives_Native.Some (hd1 :: tl1)))
-           | Construct
-               (fv, uu___,
-                (tl, FStar_Pervasives_Native.None)::(hd,
-                                                     FStar_Pervasives_Native.None)::[])
-               when
-               FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid
-               ->
-               let uu___1 = unembed ea cb hd in
-               FStar_Compiler_Util.bind_opt uu___1
-                 (fun hd1 ->
-                    let uu___2 = un cb tl in
-                    FStar_Compiler_Util.bind_opt uu___2
-                      (fun tl1 -> FStar_Pervasives_Native.Some (hd1 :: tl1)))
-           | uu___ -> FStar_Pervasives_Native.None) in
-    let uu___ =
-      let uu___1 =
-        let uu___2 = let uu___3 = type_of ea in as_arg uu___3 in [uu___2] in
-      lid_as_typ FStar_Parser_Const.list_lid [FStar_Syntax_Syntax.U_zero]
-        uu___1 in
-    mk_emb em un uu___ etyp
-let (e_string_list : Prims.string Prims.list embedding) = e_list e_string
-let e_arrow : 'a 'b . 'a embedding -> 'b embedding -> ('a -> 'b) embedding =
-  fun ea ->
-    fun eb ->
-      let etyp = FStar_Syntax_Syntax.ET_fun ((ea.emb_typ), (eb.emb_typ)) in
-      let em cb f =
-        lazy_embed etyp f
-          (fun uu___ ->
-             let uu___1 =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = let uu___6 = type_of eb in as_arg uu___6 in
-                     [uu___5] in
-                   FStar_Pervasives.Inr uu___4 in
-                 ((fun tas ->
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Compiler_Effect.op_Bar_Greater tas
-                             FStar_Compiler_List.hd in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___6
-                           FStar_Pervasives_Native.fst in
-                       unembed ea cb uu___5 in
-                     match uu___4 with
-                     | FStar_Pervasives_Native.Some a1 ->
-                         let uu___5 = f a1 in embed eb cb uu___5
-                     | FStar_Pervasives_Native.None ->
-                         failwith "cannot unembed function argument"),
-                   uu___3, Prims.int_one) in
-               Lam uu___2 in
-             FStar_Compiler_Effect.op_Less_Bar mk_t uu___1) in
-      let un cb lam =
-        let k lam1 =
-          FStar_Pervasives_Native.Some
-            (fun x ->
-               let uu___ =
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = let uu___4 = embed ea cb x in as_arg uu___4 in
-                     [uu___3] in
-                   cb.iapp lam1 uu___2 in
-                 unembed eb cb uu___1 in
-               match uu___ with
-               | FStar_Pervasives_Native.Some y -> y
-               | FStar_Pervasives_Native.None ->
-                   failwith "cannot unembed function result") in
-        lazy_unembed cb etyp lam k in
-      let uu___ =
-        let uu___1 = type_of ea in
-        let uu___2 = let uu___3 = type_of eb in as_iarg uu___3 in
-        make_arrow1 uu___1 uu___2 in
-      mk_emb em un uu___ etyp
-let (e_norm_step : FStar_Syntax_Embeddings.norm_step embedding) =
-  let em cb n =
-    match n with
-    | FStar_Syntax_Embeddings.Simpl ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_simpl
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Weak ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_weak
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.HNF ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_hnf
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Primops ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_primops
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Delta ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_delta
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Zeta ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_zeta
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Iota ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_iota
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Reify ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_reify
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.NBE ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_nbe
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.UnfoldOnly l ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_unfoldonly
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = let uu___4 = e_list e_string in embed uu___4 cb l in
-            as_arg uu___3 in
-          [uu___2] in
-        mkFV uu___ [] uu___1
-    | FStar_Syntax_Embeddings.UnfoldFully l ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_unfoldfully
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = let uu___4 = e_list e_string in embed uu___4 cb l in
-            as_arg uu___3 in
-          [uu___2] in
-        mkFV uu___ [] uu___1
-    | FStar_Syntax_Embeddings.UnfoldAttr l ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_unfoldattr
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = let uu___4 = e_list e_string in embed uu___4 cb l in
-            as_arg uu___3 in
-          [uu___2] in
-        mkFV uu___ [] uu___1
-    | FStar_Syntax_Embeddings.UnfoldQual l ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_unfoldqual
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = let uu___4 = e_list e_string in embed uu___4 cb l in
-            as_arg uu___3 in
-          [uu___2] in
-        mkFV uu___ [] uu___1
-    | FStar_Syntax_Embeddings.UnfoldNamespace l ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv
-            FStar_Parser_Const.steps_unfoldnamespace
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = let uu___4 = e_list e_string in embed uu___4 cb l in
-            as_arg uu___3 in
-          [uu___2] in
-        mkFV uu___ [] uu___1
-    | FStar_Syntax_Embeddings.ZetaFull ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_zeta_full
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] []
-    | FStar_Syntax_Embeddings.Unascribe ->
-        let uu___ =
-          FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.steps_unascribe
-            FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-        mkFV uu___ [] [] in
-  let un cb t0 =
-    match t0.nbe_t with
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_simpl ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Simpl
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_weak ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Weak
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_hnf ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.HNF
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_primops ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Primops
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_delta ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Delta
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_zeta ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Zeta
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_iota ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Iota
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_nbe ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.NBE
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_reify ->
-        FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Reify
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_zeta_full
-        -> FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.ZetaFull
-    | FV (fv, uu___, []) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_unascribe
-        -> FStar_Pervasives_Native.Some FStar_Syntax_Embeddings.Unascribe
-    | FV (fv, uu___, (l, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_unfoldonly
-        ->
-        let uu___2 = let uu___3 = e_list e_string in unembed uu___3 cb l in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ss ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Syntax_Embeddings.UnfoldOnly ss))
-    | FV (fv, uu___, (l, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_unfoldfully
-        ->
-        let uu___2 = let uu___3 = e_list e_string in unembed uu___3 cb l in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ss ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Syntax_Embeddings.UnfoldFully ss))
-    | FV (fv, uu___, (l, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_unfoldattr
-        ->
-        let uu___2 = let uu___3 = e_list e_string in unembed uu___3 cb l in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ss ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Syntax_Embeddings.UnfoldAttr ss))
-    | FV (fv, uu___, (l, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.steps_unfoldqual
-        ->
-        let uu___2 = let uu___3 = e_list e_string in unembed uu___3 cb l in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ss ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Syntax_Embeddings.UnfoldQual ss))
-    | FV (fv, uu___, (l, uu___1)::[]) when
-        FStar_Syntax_Syntax.fv_eq_lid fv
-          FStar_Parser_Const.steps_unfoldnamespace
-        ->
-        let uu___2 = let uu___3 = e_list e_string in unembed uu___3 cb l in
-        FStar_Compiler_Util.bind_opt uu___2
-          (fun ss ->
-             FStar_Compiler_Effect.op_Less_Bar
-               (fun uu___3 -> FStar_Pervasives_Native.Some uu___3)
-               (FStar_Syntax_Embeddings.UnfoldNamespace ss))
-    | uu___ ->
-        ((let uu___2 =
-            let uu___3 =
-              let uu___4 = t_to_string t0 in
-              FStar_Compiler_Util.format1 "Not an embedded norm_step: %s"
-                uu___4 in
-            (FStar_Errors.Warning_NotEmbedded, uu___3) in
-          FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___2);
-         FStar_Pervasives_Native.None) in
-  let uu___ =
-    let uu___1 =
-      FStar_Syntax_Syntax.lid_as_fv FStar_Parser_Const.norm_step_lid
-        FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-    mkFV uu___1 [] [] in
-  let uu___1 =
-    FStar_Syntax_Embeddings.emb_typ_of FStar_Syntax_Embeddings.e_norm_step in
-  mk_emb em un uu___ uu___1
-let (bogus_cbs : nbe_cbs) =
-  {
-    iapp = (fun h -> fun _args -> h);
-    translate = (fun uu___ -> failwith "bogus_cbs translate")
-  }
-let (arg_as_int : arg -> FStar_BigInt.t FStar_Pervasives_Native.option) =
-  fun a ->
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (unembed e_int bogus_cbs)
-let (arg_as_bool : arg -> Prims.bool FStar_Pervasives_Native.option) =
-  fun a ->
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (unembed e_bool bogus_cbs)
-let (arg_as_char : arg -> FStar_Char.char FStar_Pervasives_Native.option) =
-  fun a ->
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (unembed e_char bogus_cbs)
-let (arg_as_string : arg -> Prims.string FStar_Pervasives_Native.option) =
-  fun a ->
-    FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a)
-      (unembed e_string bogus_cbs)
-let arg_as_list :
-  'a . 'a embedding -> arg -> 'a Prims.list FStar_Pervasives_Native.option =
-  fun e ->
-    fun a1 ->
-      let uu___ = let uu___1 = e_list e in unembed uu___1 bogus_cbs in
-      FStar_Compiler_Effect.op_Bar_Greater (FStar_Pervasives_Native.fst a1)
-        uu___
-let (arg_as_bounded_int :
-  arg ->
-    (FStar_Syntax_Syntax.fv * FStar_BigInt.t *
-      FStar_Syntax_Syntax.meta_source_info FStar_Pervasives_Native.option)
-      FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (a, uu___1) ->
-        let uu___2 =
-          match a.nbe_t with
-          | Meta (t1, tm) ->
-              let uu___3 = FStar_Thunk.force tm in
-              (match uu___3 with
-               | FStar_Syntax_Syntax.Meta_desugared m ->
-                   (t1, (FStar_Pervasives_Native.Some m))
-               | uu___4 -> (a, FStar_Pervasives_Native.None))
-          | uu___3 -> (a, FStar_Pervasives_Native.None) in
-        (match uu___2 with
-         | (a1, m) ->
-             (match a1.nbe_t with
-              | FV
-                  (fv1, [],
-                   ({ nbe_t = Constant (Int i); nbe_r = uu___3;_}, uu___4)::[])
-                  when
-                  let uu___5 =
-                    FStar_Ident.string_of_lid
-                      (fv1.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                  FStar_Compiler_Util.ends_with uu___5 "int_to_t" ->
-                  FStar_Pervasives_Native.Some (fv1, i, m)
-              | uu___3 -> FStar_Pervasives_Native.None))
-let (int_as_bounded : FStar_Syntax_Syntax.fv -> FStar_BigInt.t -> t) =
-  fun int_to_t ->
-    fun n ->
-      let c = embed e_int bogus_cbs n in
-      let int_to_t1 args1 =
-        FStar_Compiler_Effect.op_Less_Bar mk_t (FV (int_to_t, [], args1)) in
-      let uu___ = let uu___1 = as_arg c in [uu___1] in int_to_t1 uu___
-let (with_meta_ds :
-  t ->
-    FStar_Syntax_Syntax.meta_source_info FStar_Pervasives_Native.option -> t)
-  =
-  fun t1 ->
-    fun m ->
-      match m with
-      | FStar_Pervasives_Native.None -> t1
-      | FStar_Pervasives_Native.Some m1 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 =
-                FStar_Thunk.mk
-                  (fun uu___3 -> FStar_Syntax_Syntax.Meta_desugared m1) in
-              (t1, uu___2) in
-            Meta uu___1 in
-          mk_t uu___
-let lift_unary :
-  'a 'b .
-    ('a -> 'b) ->
-      'a FStar_Pervasives_Native.option Prims.list ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun aopts ->
-      match aopts with
-      | (FStar_Pervasives_Native.Some a1)::[] ->
-          let uu___ = f a1 in FStar_Pervasives_Native.Some uu___
-      | uu___ -> FStar_Pervasives_Native.None
-let lift_binary :
-  'a 'b .
-    ('a -> 'a -> 'b) ->
-      'a FStar_Pervasives_Native.option Prims.list ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun aopts ->
-      match aopts with
-      | (FStar_Pervasives_Native.Some a0)::(FStar_Pervasives_Native.Some
-          a1)::[] ->
-          let uu___ = f a0 a1 in FStar_Pervasives_Native.Some uu___
-      | uu___ -> FStar_Pervasives_Native.None
-let unary_op :
-  'a .
-    (arg -> 'a FStar_Pervasives_Native.option) ->
-      ('a -> t) ->
-        FStar_Syntax_Syntax.universes ->
-          args -> t FStar_Pervasives_Native.option
-  =
-  fun as_a ->
-    fun f ->
-      fun us ->
-        fun args1 ->
-          let uu___ = FStar_Compiler_List.map as_a args1 in
-          lift_unary f uu___
-let binary_op :
-  'a .
-    (arg -> 'a FStar_Pervasives_Native.option) ->
-      ('a -> 'a -> t) ->
-        FStar_Syntax_Syntax.universes ->
-          args -> t FStar_Pervasives_Native.option
-  =
-  fun as_a ->
-    fun f ->
-      fun _us ->
-        fun args1 ->
-          let uu___ = FStar_Compiler_List.map as_a args1 in
-          lift_binary f uu___
-let (unary_int_op :
-  (FStar_BigInt.t -> FStar_BigInt.t) ->
-    FStar_Syntax_Syntax.universes -> args -> t FStar_Pervasives_Native.option)
-  =
-  fun f ->
-    unary_op arg_as_int
-      (fun x -> let uu___ = f x in embed e_int bogus_cbs uu___)
-let (binary_int_op :
-  (FStar_BigInt.t -> FStar_BigInt.t -> FStar_BigInt.t) ->
-    FStar_Syntax_Syntax.universes -> args -> t FStar_Pervasives_Native.option)
-  =
-  fun f ->
-    binary_op arg_as_int
-      (fun x -> fun y -> let uu___ = f x y in embed e_int bogus_cbs uu___)
-let (unary_bool_op :
-  (Prims.bool -> Prims.bool) ->
-    FStar_Syntax_Syntax.universes -> args -> t FStar_Pervasives_Native.option)
-  =
-  fun f ->
-    unary_op arg_as_bool
-      (fun x -> let uu___ = f x in embed e_bool bogus_cbs uu___)
-let (binary_bool_op :
-  (Prims.bool -> Prims.bool -> Prims.bool) ->
-    FStar_Syntax_Syntax.universes -> args -> t FStar_Pervasives_Native.option)
-  =
-  fun f ->
-    binary_op arg_as_bool
-      (fun x -> fun y -> let uu___ = f x y in embed e_bool bogus_cbs uu___)
-let (binary_string_op :
-  (Prims.string -> Prims.string -> Prims.string) ->
-    FStar_Syntax_Syntax.universes -> args -> t FStar_Pervasives_Native.option)
-  =
-  fun f ->
-    binary_op arg_as_string
-      (fun x -> fun y -> let uu___ = f x y in embed e_string bogus_cbs uu___)
-let mixed_binary_op :
-  'a 'b 'c .
-    (arg -> 'a FStar_Pervasives_Native.option) ->
-      (arg -> 'b FStar_Pervasives_Native.option) ->
-        ('c -> t) ->
-          (FStar_Syntax_Syntax.universes ->
-             'a -> 'b -> 'c FStar_Pervasives_Native.option)
-            ->
-            FStar_Syntax_Syntax.universes ->
-              args -> t FStar_Pervasives_Native.option
-  =
-  fun as_a ->
-    fun as_b ->
-      fun embed_c ->
-        fun f ->
-          fun us ->
-            fun args1 ->
-              match args1 with
-              | a1::b1::[] ->
-                  let uu___ =
-                    let uu___1 = as_a a1 in
-                    let uu___2 = as_b b1 in (uu___1, uu___2) in
-                  (match uu___ with
-                   | (FStar_Pervasives_Native.Some a2,
-                      FStar_Pervasives_Native.Some b2) ->
-                       let uu___1 = f us a2 b2 in
-                       (match uu___1 with
-                        | FStar_Pervasives_Native.Some c1 ->
-                            let uu___2 = embed_c c1 in
-                            FStar_Pervasives_Native.Some uu___2
-                        | uu___2 -> FStar_Pervasives_Native.None)
-                   | uu___1 -> FStar_Pervasives_Native.None)
-              | uu___ -> FStar_Pervasives_Native.None
-let mixed_ternary_op :
-  'a 'b 'c 'd .
-    (arg -> 'a FStar_Pervasives_Native.option) ->
-      (arg -> 'b FStar_Pervasives_Native.option) ->
-        (arg -> 'c FStar_Pervasives_Native.option) ->
-          ('d -> t) ->
-            (FStar_Syntax_Syntax.universes ->
-               'a -> 'b -> 'c -> 'd FStar_Pervasives_Native.option)
-              ->
-              FStar_Syntax_Syntax.universes ->
-                args -> t FStar_Pervasives_Native.option
-  =
-  fun as_a ->
-    fun as_b ->
-      fun as_c ->
-        fun embed_d ->
-          fun f ->
-            fun us ->
-              fun args1 ->
-                match args1 with
-                | a1::b1::c1::[] ->
-                    let uu___ =
-                      let uu___1 = as_a a1 in
-                      let uu___2 = as_b b1 in
-                      let uu___3 = as_c c1 in (uu___1, uu___2, uu___3) in
-                    (match uu___ with
-                     | (FStar_Pervasives_Native.Some a2,
-                        FStar_Pervasives_Native.Some b2,
-                        FStar_Pervasives_Native.Some c2) ->
-                         let uu___1 = f us a2 b2 c2 in
-                         (match uu___1 with
-                          | FStar_Pervasives_Native.Some d1 ->
-                              let uu___2 = embed_d d1 in
-                              FStar_Pervasives_Native.Some uu___2
-                          | uu___2 -> FStar_Pervasives_Native.None)
-                     | uu___1 -> FStar_Pervasives_Native.None)
-                | uu___ -> FStar_Pervasives_Native.None
-let (list_of_string' : Prims.string -> t) =
-  fun s ->
-    let uu___ = e_list e_char in
-    let uu___1 = FStar_String.list_of_string s in
-    embed uu___ bogus_cbs uu___1
-let (string_of_list' : FStar_Char.char Prims.list -> t) =
-  fun l ->
-    let s = FStar_String.string_of_list l in
-    FStar_Compiler_Effect.op_Less_Bar mk_t
-      (Constant (String (s, FStar_Compiler_Range.dummyRange)))
-let (string_compare' : Prims.string -> Prims.string -> t) =
-  fun s1 ->
-    fun s2 ->
-      let r = FStar_String.compare s1 s2 in
-      let uu___ =
-        let uu___1 = FStar_Compiler_Util.string_of_int r in
-        FStar_BigInt.big_int_of_string uu___1 in
-      embed e_int bogus_cbs uu___
-let (string_concat' : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ = arg_as_string a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some s1 ->
-             let uu___1 = arg_as_list e_string a2 in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some s2 ->
-                  let r = FStar_String.concat s1 s2 in
-                  let uu___2 = embed e_string bogus_cbs r in
-                  FStar_Pervasives_Native.Some uu___2
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_int : FStar_BigInt.t -> t) =
-  fun i ->
-    let uu___ = FStar_BigInt.string_of_big_int i in
-    embed e_string bogus_cbs uu___
-let (string_of_bool : Prims.bool -> t) =
-  fun b -> embed e_string bogus_cbs (if b then "true" else "false")
-let (string_lowercase : Prims.string -> t) =
-  fun s -> embed e_string bogus_cbs (FStar_String.lowercase s)
-let (string_uppercase : Prims.string -> t) =
-  fun s -> embed e_string bogus_cbs (FStar_String.lowercase s)
-let (decidable_eq : Prims.bool -> args -> t FStar_Pervasives_Native.option) =
-  fun neg ->
-    fun args1 ->
-      let tru = embed e_bool bogus_cbs true in
-      let fal = embed e_bool bogus_cbs false in
-      match args1 with
-      | (_typ, uu___)::(a1, uu___1)::(a2, uu___2)::[] ->
-          let uu___3 = eq_t a1 a2 in
-          (match uu___3 with
-           | FStar_Syntax_Util.Equal ->
-               FStar_Pervasives_Native.Some (if neg then fal else tru)
-           | FStar_Syntax_Util.NotEqual ->
-               FStar_Pervasives_Native.Some (if neg then tru else fal)
-           | uu___4 -> FStar_Pervasives_Native.None)
-      | uu___ -> failwith "Unexpected number of arguments"
-let (interp_prop_eq2 : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | (_u, uu___)::(_typ, uu___1)::(a1, uu___2)::(a2, uu___3)::[] ->
-        let uu___4 = eq_t a1 a2 in
-        (match uu___4 with
-         | FStar_Syntax_Util.Equal ->
-             let uu___5 = embed e_bool bogus_cbs true in
-             FStar_Pervasives_Native.Some uu___5
-         | FStar_Syntax_Util.NotEqual ->
-             let uu___5 = embed e_bool bogus_cbs false in
-             FStar_Pervasives_Native.Some uu___5
-         | FStar_Syntax_Util.Unknown -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments"
-let (dummy_interp :
-  FStar_Ident.lid -> args -> t FStar_Pervasives_Native.option) =
-  fun lid ->
-    fun args1 ->
-      let uu___ =
-        let uu___1 = FStar_Ident.string_of_lid lid in
-        FStar_String.op_Hat "No interpretation for " uu___1 in
-      failwith uu___
-let (prims_to_fstar_range_step : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | (a1, uu___)::[] ->
-        let uu___1 = unembed e_range bogus_cbs a1 in
-        (match uu___1 with
-         | FStar_Pervasives_Native.Some r ->
-             let uu___2 = embed e_range bogus_cbs r in
-             FStar_Pervasives_Native.Some uu___2
-         | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments"
-let (string_split' : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ = arg_as_list e_char a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some s1 ->
-             let uu___1 = arg_as_string a2 in
-             (match uu___1 with
-              | FStar_Pervasives_Native.Some s2 ->
-                  let r = FStar_String.split s1 s2 in
-                  let uu___2 =
-                    let uu___3 = e_list e_string in embed uu___3 bogus_cbs r in
-                  FStar_Pervasives_Native.Some uu___2
-              | uu___2 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_index : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string a1 in
-          let uu___2 = arg_as_int a2 in (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some s, FStar_Pervasives_Native.Some i)
-             ->
-             (try
-                (fun uu___1 ->
-                   match () with
-                   | () ->
-                       let r = FStar_String.index s i in
-                       let uu___2 = embed e_char bogus_cbs r in
-                       FStar_Pervasives_Native.Some uu___2) ()
-              with | uu___1 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_index_of : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string a1 in
-          let uu___2 = arg_as_char a2 in (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some s, FStar_Pervasives_Native.Some c)
-             ->
-             (try
-                (fun uu___1 ->
-                   match () with
-                   | () ->
-                       let r = FStar_String.index_of s c in
-                       let uu___2 = embed e_int bogus_cbs r in
-                       FStar_Pervasives_Native.Some uu___2) ()
-              with | uu___1 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_substring' : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::a3::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string a1 in
-          let uu___2 = arg_as_int a2 in
-          let uu___3 = arg_as_int a3 in (uu___1, uu___2, uu___3) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some s1, FStar_Pervasives_Native.Some n1,
-            FStar_Pervasives_Native.Some n2) ->
-             let n11 = FStar_BigInt.to_int_fs n1 in
-             let n21 = FStar_BigInt.to_int_fs n2 in
-             (try
-                (fun uu___1 ->
-                   match () with
-                   | () ->
-                       let r = FStar_String.substring s1 n11 n21 in
-                       let uu___2 = embed e_string bogus_cbs r in
-                       FStar_Pervasives_Native.Some uu___2) ()
-              with | uu___1 -> FStar_Pervasives_Native.None)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (mk_range : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | fn::from_line::from_col::to_line::to_col::[] ->
-        let uu___ =
-          let uu___1 = arg_as_string fn in
-          let uu___2 = arg_as_int from_line in
-          let uu___3 = arg_as_int from_col in
-          let uu___4 = arg_as_int to_line in
-          let uu___5 = arg_as_int to_col in
-          (uu___1, uu___2, uu___3, uu___4, uu___5) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some fn1, FStar_Pervasives_Native.Some
-            from_l, FStar_Pervasives_Native.Some from_c,
-            FStar_Pervasives_Native.Some to_l, FStar_Pervasives_Native.Some
-            to_c) ->
-             let r =
-               let uu___1 =
-                 let uu___2 = FStar_BigInt.to_int_fs from_l in
-                 let uu___3 = FStar_BigInt.to_int_fs from_c in
-                 FStar_Compiler_Range.mk_pos uu___2 uu___3 in
-               let uu___2 =
-                 let uu___3 = FStar_BigInt.to_int_fs to_l in
-                 let uu___4 = FStar_BigInt.to_int_fs to_c in
-                 FStar_Compiler_Range.mk_pos uu___3 uu___4 in
-               FStar_Compiler_Range.mk_range fn1 uu___1 uu___2 in
-             let uu___1 = embed e_range bogus_cbs r in
-             FStar_Pervasives_Native.Some uu___1
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> FStar_Pervasives_Native.None
-let (and_op : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ = arg_as_bool a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some (false) ->
-             let uu___1 = embed e_bool bogus_cbs false in
-             FStar_Pervasives_Native.Some uu___1
-         | FStar_Pervasives_Native.Some (true) ->
-             FStar_Pervasives_Native.Some (FStar_Pervasives_Native.fst a2)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments"
-let (or_op : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ = arg_as_bool a1 in
-        (match uu___ with
-         | FStar_Pervasives_Native.Some (true) ->
-             let uu___1 = embed e_bool bogus_cbs true in
-             FStar_Pervasives_Native.Some uu___1
-         | FStar_Pervasives_Native.Some (false) ->
-             FStar_Pervasives_Native.Some (FStar_Pervasives_Native.fst a2)
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments"
-let (division_op : args -> t FStar_Pervasives_Native.option) =
-  fun args1 ->
-    match args1 with
-    | a1::a2::[] ->
-        let uu___ =
-          let uu___1 = arg_as_int a1 in
-          let uu___2 = arg_as_int a2 in (uu___1, uu___2) in
-        (match uu___ with
-         | (FStar_Pervasives_Native.Some m, FStar_Pervasives_Native.Some n)
-             ->
-             let uu___1 =
-               let uu___2 = FStar_BigInt.to_int_fs n in
-               uu___2 <> Prims.int_zero in
-             if uu___1
-             then
-               let uu___2 =
-                 let uu___3 = FStar_BigInt.div_big_int m n in
-                 embed e_int bogus_cbs uu___3 in
-               FStar_Pervasives_Native.Some uu___2
-             else FStar_Pervasives_Native.None
-         | uu___1 -> FStar_Pervasives_Native.None)
-    | uu___ -> failwith "Unexpected number of arguments"
-let arrow_as_prim_step_1 :
-  'a 'b .
-    'a embedding ->
-      'b embedding ->
-        ('a -> 'b) ->
-          Prims.int ->
-            FStar_Ident.lid ->
-              nbe_cbs -> args -> t FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun eb ->
-      fun f ->
-        fun n_tvars ->
-          fun _fv_lid ->
-            fun cb ->
-              let f_wrapped args1 =
-                let uu___ = FStar_Compiler_List.splitAt n_tvars args1 in
-                match uu___ with
-                | (_tvar_args, rest_args) ->
-                    let uu___1 = FStar_Compiler_List.hd rest_args in
-                    (match uu___1 with
-                     | (x, uu___2) ->
-                         let uu___3 = unembed ea cb x in
-                         FStar_Compiler_Util.map_opt uu___3
-                           (fun x1 -> let uu___4 = f x1 in embed eb cb uu___4)) in
-              f_wrapped
-let arrow_as_prim_step_2 :
-  'a 'b 'c .
-    'a embedding ->
-      'b embedding ->
-        'c embedding ->
-          ('a -> 'b -> 'c) ->
-            Prims.int ->
-              FStar_Ident.lid ->
-                nbe_cbs -> args -> t FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun eb ->
-      fun ec ->
-        fun f ->
-          fun n_tvars ->
-            fun _fv_lid ->
-              fun cb ->
-                let f_wrapped args1 =
-                  let uu___ = FStar_Compiler_List.splitAt n_tvars args1 in
-                  match uu___ with
-                  | (_tvar_args, rest_args) ->
-                      let uu___1 = FStar_Compiler_List.hd rest_args in
-                      (match uu___1 with
-                       | (x, uu___2) ->
-                           let uu___3 =
-                             let uu___4 = FStar_Compiler_List.tl rest_args in
-                             FStar_Compiler_List.hd uu___4 in
-                           (match uu___3 with
-                            | (y, uu___4) ->
-                                let uu___5 = unembed ea cb x in
-                                FStar_Compiler_Util.bind_opt uu___5
-                                  (fun x1 ->
-                                     let uu___6 = unembed eb cb y in
-                                     FStar_Compiler_Util.bind_opt uu___6
-                                       (fun y1 ->
-                                          let uu___7 =
-                                            let uu___8 = f x1 y1 in
-                                            embed ec cb uu___8 in
-                                          FStar_Pervasives_Native.Some uu___7)))) in
-                f_wrapped
-let arrow_as_prim_step_3 :
-  'a 'b 'c 'd .
-    'a embedding ->
-      'b embedding ->
-        'c embedding ->
-          'd embedding ->
-            ('a -> 'b -> 'c -> 'd) ->
-              Prims.int ->
-                FStar_Ident.lid ->
-                  nbe_cbs -> args -> t FStar_Pervasives_Native.option
-  =
-  fun ea ->
-    fun eb ->
-      fun ec ->
-        fun ed ->
-          fun f ->
-            fun n_tvars ->
-              fun _fv_lid ->
-                fun cb ->
-                  let f_wrapped args1 =
-                    let uu___ = FStar_Compiler_List.splitAt n_tvars args1 in
-                    match uu___ with
-                    | (_tvar_args, rest_args) ->
-                        let uu___1 = FStar_Compiler_List.hd rest_args in
-                        (match uu___1 with
-                         | (x, uu___2) ->
-                             let uu___3 =
-                               let uu___4 = FStar_Compiler_List.tl rest_args in
-                               FStar_Compiler_List.hd uu___4 in
-                             (match uu___3 with
-                              | (y, uu___4) ->
-                                  let uu___5 =
-                                    let uu___6 =
-                                      let uu___7 =
-                                        FStar_Compiler_List.tl rest_args in
-                                      FStar_Compiler_List.tl uu___7 in
-                                    FStar_Compiler_List.hd uu___6 in
-                                  (match uu___5 with
-                                   | (z, uu___6) ->
-                                       let uu___7 = unembed ea cb x in
-                                       FStar_Compiler_Util.bind_opt uu___7
-                                         (fun x1 ->
-                                            let uu___8 = unembed eb cb y in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___8
-                                              (fun y1 ->
-                                                 let uu___9 = unembed ec cb z in
-                                                 FStar_Compiler_Util.bind_opt
-                                                   uu___9
-                                                   (fun z1 ->
-                                                      let uu___10 =
-                                                        let uu___11 =
-                                                          f x1 y1 z1 in
-                                                        embed ed cb uu___11 in
-                                                      FStar_Pervasives_Native.Some
-                                                        uu___10)))))) in
-                  f_wrapped
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Normalize.ml b/src/ocaml-output/FStar_TypeChecker_Normalize.ml
deleted file mode 100644
index fda8cf483cc..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Normalize.ml
+++ /dev/null
@@ -1,9313 +0,0 @@
-open Prims
-type should_unfold_res =
-  | Should_unfold_no 
-  | Should_unfold_yes 
-  | Should_unfold_fully 
-  | Should_unfold_reify 
-let (uu___is_Should_unfold_no : should_unfold_res -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Should_unfold_no -> true | uu___ -> false
-let (uu___is_Should_unfold_yes : should_unfold_res -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Should_unfold_yes -> true | uu___ -> false
-let (uu___is_Should_unfold_fully : should_unfold_res -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Should_unfold_fully -> true | uu___ -> false
-let (uu___is_Should_unfold_reify : should_unfold_res -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Should_unfold_reify -> true | uu___ -> false
-let (maybe_debug :
-  FStar_TypeChecker_Cfg.cfg ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_Compiler_Util.time)
-        FStar_Pervasives_Native.option -> unit)
-  =
-  fun cfg ->
-    fun t ->
-      fun dbg ->
-        if
-          (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.print_normalized
-        then
-          match dbg with
-          | FStar_Pervasives_Native.Some (tm, time_then) ->
-              let time_now = FStar_Compiler_Util.now () in
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Compiler_Util.time_diff time_then time_now in
-                  FStar_Pervasives_Native.snd uu___2 in
-                FStar_Compiler_Util.string_of_int uu___1 in
-              let uu___1 = FStar_Syntax_Print.term_to_string tm in
-              let uu___2 = FStar_TypeChecker_Cfg.cfg_to_string cfg in
-              let uu___3 = FStar_Syntax_Print.term_to_string t in
-              FStar_Compiler_Util.print4
-                "Normalizer result timing (%s ms){\nOn term {\n%s\n}\nwith steps {%s}\nresult is{\n\n%s\n}\n}\n"
-                uu___ uu___1 uu___2 uu___3
-          | uu___ -> ()
-        else ()
-let cases :
-  'uuuuu 'uuuuu1 .
-    ('uuuuu -> 'uuuuu1) ->
-      'uuuuu1 -> 'uuuuu FStar_Pervasives_Native.option -> 'uuuuu1
-  =
-  fun f ->
-    fun d ->
-      fun uu___ ->
-        match uu___ with
-        | FStar_Pervasives_Native.Some x -> f x
-        | FStar_Pervasives_Native.None -> d
-type closure =
-  | Clos of ((FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option *
-  closure) Prims.list * FStar_Syntax_Syntax.term *
-  ((FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-  Prims.list * FStar_Syntax_Syntax.term) FStar_Syntax_Syntax.memo *
-  Prims.bool) 
-  | Univ of FStar_Syntax_Syntax.universe 
-  | Dummy 
-let (uu___is_Clos : closure -> Prims.bool) =
-  fun projectee -> match projectee with | Clos _0 -> true | uu___ -> false
-let (__proj__Clos__item___0 :
-  closure ->
-    ((FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-      Prims.list * FStar_Syntax_Syntax.term * ((FStar_Syntax_Syntax.binder
-      FStar_Pervasives_Native.option * closure) Prims.list *
-      FStar_Syntax_Syntax.term) FStar_Syntax_Syntax.memo * Prims.bool))
-  = fun projectee -> match projectee with | Clos _0 -> _0
-let (uu___is_Univ : closure -> Prims.bool) =
-  fun projectee -> match projectee with | Univ _0 -> true | uu___ -> false
-let (__proj__Univ__item___0 : closure -> FStar_Syntax_Syntax.universe) =
-  fun projectee -> match projectee with | Univ _0 -> _0
-let (uu___is_Dummy : closure -> Prims.bool) =
-  fun projectee -> match projectee with | Dummy -> true | uu___ -> false
-type env =
-  (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-    Prims.list
-let (empty_env : env) = []
-let (dummy :
-  (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)) =
-  (FStar_Pervasives_Native.None, Dummy)
-type branches =
-  (FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.term
-    FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term) Prims.list
-type stack_elt =
-  | Arg of (closure * FStar_Syntax_Syntax.aqual * FStar_Compiler_Range.range)
-  
-  | UnivArgs of (FStar_Syntax_Syntax.universe Prims.list *
-  FStar_Compiler_Range.range) 
-  | MemoLazy of (env * FStar_Syntax_Syntax.term) FStar_Syntax_Syntax.memo 
-  | Match of (env * FStar_Syntax_Syntax.match_returns_ascription
-  FStar_Pervasives_Native.option * branches *
-  FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option *
-  FStar_TypeChecker_Cfg.cfg * FStar_Compiler_Range.range) 
-  | Abs of (env * FStar_Syntax_Syntax.binders * env *
-  FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option *
-  FStar_Compiler_Range.range) 
-  | App of (env * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual *
-  FStar_Compiler_Range.range) 
-  | CBVApp of (env * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual *
-  FStar_Compiler_Range.range) 
-  | Meta of (env * FStar_Syntax_Syntax.metadata * FStar_Compiler_Range.range)
-  
-  | Let of (env * FStar_Syntax_Syntax.binders *
-  FStar_Syntax_Syntax.letbinding * FStar_Compiler_Range.range) 
-  | Cfg of (FStar_TypeChecker_Cfg.cfg * (FStar_Syntax_Syntax.term *
-  FStar_Compiler_Util.time) FStar_Pervasives_Native.option) 
-let (uu___is_Arg : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | Arg _0 -> true | uu___ -> false
-let (__proj__Arg__item___0 :
-  stack_elt ->
-    (closure * FStar_Syntax_Syntax.aqual * FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | Arg _0 -> _0
-let (uu___is_UnivArgs : stack_elt -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UnivArgs _0 -> true | uu___ -> false
-let (__proj__UnivArgs__item___0 :
-  stack_elt ->
-    (FStar_Syntax_Syntax.universe Prims.list * FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | UnivArgs _0 -> _0
-let (uu___is_MemoLazy : stack_elt -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MemoLazy _0 -> true | uu___ -> false
-let (__proj__MemoLazy__item___0 :
-  stack_elt -> (env * FStar_Syntax_Syntax.term) FStar_Syntax_Syntax.memo) =
-  fun projectee -> match projectee with | MemoLazy _0 -> _0
-let (uu___is_Match : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | Match _0 -> true | uu___ -> false
-let (__proj__Match__item___0 :
-  stack_elt ->
-    (env * FStar_Syntax_Syntax.match_returns_ascription
-      FStar_Pervasives_Native.option * branches *
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option *
-      FStar_TypeChecker_Cfg.cfg * FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | Match _0 -> _0
-let (uu___is_Abs : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | Abs _0 -> true | uu___ -> false
-let (__proj__Abs__item___0 :
-  stack_elt ->
-    (env * FStar_Syntax_Syntax.binders * env *
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option *
-      FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | Abs _0 -> _0
-let (uu___is_App : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | App _0 -> true | uu___ -> false
-let (__proj__App__item___0 :
-  stack_elt ->
-    (env * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual *
-      FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | App _0 -> _0
-let (uu___is_CBVApp : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | CBVApp _0 -> true | uu___ -> false
-let (__proj__CBVApp__item___0 :
-  stack_elt ->
-    (env * FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual *
-      FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | CBVApp _0 -> _0
-let (uu___is_Meta : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | Meta _0 -> true | uu___ -> false
-let (__proj__Meta__item___0 :
-  stack_elt ->
-    (env * FStar_Syntax_Syntax.metadata * FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | Meta _0 -> _0
-let (uu___is_Let : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | Let _0 -> true | uu___ -> false
-let (__proj__Let__item___0 :
-  stack_elt ->
-    (env * FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.letbinding *
-      FStar_Compiler_Range.range))
-  = fun projectee -> match projectee with | Let _0 -> _0
-let (uu___is_Cfg : stack_elt -> Prims.bool) =
-  fun projectee -> match projectee with | Cfg _0 -> true | uu___ -> false
-let (__proj__Cfg__item___0 :
-  stack_elt ->
-    (FStar_TypeChecker_Cfg.cfg * (FStar_Syntax_Syntax.term *
-      FStar_Compiler_Util.time) FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | Cfg _0 -> _0
-type stack = stack_elt Prims.list
-let (head_of : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args_full t in
-    match uu___ with | (hd, uu___1) -> hd
-let set_memo :
-  'a . FStar_TypeChecker_Cfg.cfg -> 'a FStar_Syntax_Syntax.memo -> 'a -> unit
-  =
-  fun cfg ->
-    fun r ->
-      fun t ->
-        if cfg.FStar_TypeChecker_Cfg.memoize_lazy
-        then
-          let uu___ = FStar_Compiler_Effect.op_Bang r in
-          match uu___ with
-          | FStar_Pervasives_Native.Some uu___1 ->
-              failwith "Unexpected set_memo: thunk already evaluated"
-          | FStar_Pervasives_Native.None ->
-              FStar_Compiler_Effect.op_Colon_Equals r
-                (FStar_Pervasives_Native.Some t)
-        else ()
-let (closure_to_string : closure -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Clos (env1, t, uu___1, uu___2) ->
-        let uu___3 =
-          FStar_Compiler_Effect.op_Bar_Greater
-            (FStar_Compiler_List.length env1)
-            FStar_Compiler_Util.string_of_int in
-        let uu___4 = FStar_Syntax_Print.term_to_string t in
-        FStar_Compiler_Util.format2 "(env=%s elts; %s)" uu___3 uu___4
-    | Univ uu___1 -> "Univ"
-    | Dummy -> "dummy"
-let (env_to_string :
-  (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-    Prims.list -> Prims.string)
-  =
-  fun env1 ->
-    let uu___ =
-      FStar_Compiler_List.map
-        (fun uu___1 ->
-           match uu___1 with
-           | (bopt, c) ->
-               let uu___2 =
-                 match bopt with
-                 | FStar_Pervasives_Native.None -> "."
-                 | FStar_Pervasives_Native.Some x ->
-                     FStar_Syntax_Print.binder_to_string x in
-               let uu___3 = closure_to_string c in
-               FStar_Compiler_Util.format2 "(%s, %s)" uu___2 uu___3) env1 in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "; ")
-let (stack_elt_to_string : stack_elt -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Arg (c, uu___1, uu___2) ->
-        let uu___3 = closure_to_string c in
-        FStar_Compiler_Util.format1 "Closure %s" uu___3
-    | MemoLazy uu___1 -> "MemoLazy"
-    | Abs (uu___1, bs, uu___2, uu___3, uu___4) ->
-        let uu___5 =
-          FStar_Compiler_Effect.op_Less_Bar FStar_Compiler_Util.string_of_int
-            (FStar_Compiler_List.length bs) in
-        FStar_Compiler_Util.format1 "Abs %s" uu___5
-    | UnivArgs uu___1 -> "UnivArgs"
-    | Match uu___1 -> "Match"
-    | App (uu___1, t, uu___2, uu___3) ->
-        let uu___4 = FStar_Syntax_Print.term_to_string t in
-        FStar_Compiler_Util.format1 "App %s" uu___4
-    | CBVApp (uu___1, t, uu___2, uu___3) ->
-        let uu___4 = FStar_Syntax_Print.term_to_string t in
-        FStar_Compiler_Util.format1 "CBVApp %s" uu___4
-    | Meta (uu___1, m, uu___2) -> "Meta"
-    | Let uu___1 -> "Let"
-    | Cfg uu___1 -> "Cfg"
-let (stack_to_string : stack_elt Prims.list -> Prims.string) =
-  fun s ->
-    let uu___ = FStar_Compiler_List.map stack_elt_to_string s in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "; ")
-let is_empty : 'uuuuu . 'uuuuu Prims.list -> Prims.bool =
-  fun uu___ -> match uu___ with | [] -> true | uu___1 -> false
-let (lookup_bvar :
-  (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-    Prims.list -> FStar_Syntax_Syntax.bv -> closure)
-  =
-  fun env1 ->
-    fun x ->
-      try
-        (fun uu___ ->
-           match () with
-           | () ->
-               let uu___1 =
-                 FStar_Compiler_List.nth env1 x.FStar_Syntax_Syntax.index in
-               FStar_Pervasives_Native.snd uu___1) ()
-      with
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.db_to_string x in
-            let uu___3 = env_to_string env1 in
-            FStar_Compiler_Util.format2 "Failed to find %s\nEnv is %s\n"
-              uu___2 uu___3 in
-          failwith uu___1
-let (downgrade_ghost_effect_name :
-  FStar_Ident.lident -> FStar_Ident.lident FStar_Pervasives_Native.option) =
-  fun l ->
-    let uu___ = FStar_Ident.lid_equals l FStar_Parser_Const.effect_Ghost_lid in
-    if uu___
-    then FStar_Pervasives_Native.Some FStar_Parser_Const.effect_Pure_lid
-    else
-      (let uu___2 =
-         FStar_Ident.lid_equals l FStar_Parser_Const.effect_GTot_lid in
-       if uu___2
-       then FStar_Pervasives_Native.Some FStar_Parser_Const.effect_Tot_lid
-       else
-         (let uu___4 =
-            FStar_Ident.lid_equals l FStar_Parser_Const.effect_GHOST_lid in
-          if uu___4
-          then
-            FStar_Pervasives_Native.Some FStar_Parser_Const.effect_PURE_lid
-          else FStar_Pervasives_Native.None))
-let (norm_universe :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun u ->
-        let norm_univs_for_max us =
-          let us1 =
-            FStar_Compiler_Util.sort_with FStar_Syntax_Util.compare_univs us in
-          let uu___ =
-            FStar_Compiler_List.fold_left
-              (fun uu___1 ->
-                 fun u1 ->
-                   match uu___1 with
-                   | (cur_kernel, cur_max, out) ->
-                       let uu___2 = FStar_Syntax_Util.univ_kernel u1 in
-                       (match uu___2 with
-                        | (k_u, n) ->
-                            let uu___3 =
-                              FStar_Syntax_Util.eq_univs cur_kernel k_u in
-                            if uu___3
-                            then (cur_kernel, u1, out)
-                            else (k_u, u1, (cur_max :: out))))
-              (FStar_Syntax_Syntax.U_zero, FStar_Syntax_Syntax.U_zero, [])
-              us1 in
-          match uu___ with
-          | (uu___1, u1, out) -> FStar_Compiler_List.rev (u1 :: out) in
-        let rec aux u1 =
-          let u2 = FStar_Syntax_Subst.compress_univ u1 in
-          match u2 with
-          | FStar_Syntax_Syntax.U_bvar x ->
-              (try
-                 (fun uu___ ->
-                    match () with
-                    | () ->
-                        let uu___1 =
-                          let uu___2 = FStar_Compiler_List.nth env1 x in
-                          FStar_Pervasives_Native.snd uu___2 in
-                        (match uu___1 with
-                         | Univ u3 ->
-                             ((let uu___3 =
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (FStar_TypeChecker_Env.debug
-                                      cfg.FStar_TypeChecker_Cfg.tcenv)
-                                   (FStar_Options.Other "univ_norm") in
-                               if uu___3
-                               then
-                                 let uu___4 =
-                                   FStar_Syntax_Print.univ_to_string u3 in
-                                 FStar_Compiler_Util.print1
-                                   "Univ (in norm_universe): %s\n" uu___4
-                               else ());
-                              aux u3)
-                         | Dummy -> [u2]
-                         | uu___2 ->
-                             let uu___3 =
-                               let uu___4 =
-                                 FStar_Compiler_Util.string_of_int x in
-                               FStar_Compiler_Util.format1
-                                 "Impossible: universe variable u@%s bound to a term"
-                                 uu___4 in
-                             failwith uu___3)) ()
-               with
-               | uu___1 ->
-                   if
-                     (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.allow_unbound_universes
-                   then [FStar_Syntax_Syntax.U_unknown]
-                   else
-                     (let uu___3 =
-                        let uu___4 = FStar_Compiler_Util.string_of_int x in
-                        FStar_String.op_Hat "Universe variable not found: u@"
-                          uu___4 in
-                      failwith uu___3))
-          | FStar_Syntax_Syntax.U_unif uu___ when
-              (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.check_no_uvars
-              -> [FStar_Syntax_Syntax.U_zero]
-          | FStar_Syntax_Syntax.U_zero -> [u2]
-          | FStar_Syntax_Syntax.U_unif uu___ -> [u2]
-          | FStar_Syntax_Syntax.U_name uu___ -> [u2]
-          | FStar_Syntax_Syntax.U_unknown -> [u2]
-          | FStar_Syntax_Syntax.U_max [] -> [FStar_Syntax_Syntax.U_zero]
-          | FStar_Syntax_Syntax.U_max us ->
-              let us1 =
-                let uu___ = FStar_Compiler_List.collect aux us in
-                FStar_Compiler_Effect.op_Bar_Greater uu___ norm_univs_for_max in
-              (match us1 with
-               | u_k::hd::rest ->
-                   let rest1 = hd :: rest in
-                   let uu___ = FStar_Syntax_Util.univ_kernel u_k in
-                   (match uu___ with
-                    | (FStar_Syntax_Syntax.U_zero, n) ->
-                        let uu___1 =
-                          FStar_Compiler_Effect.op_Bar_Greater rest1
-                            (FStar_Compiler_List.for_all
-                               (fun u3 ->
-                                  let uu___2 =
-                                    FStar_Syntax_Util.univ_kernel u3 in
-                                  match uu___2 with | (uu___3, m) -> n <= m)) in
-                        if uu___1 then rest1 else us1
-                    | uu___1 -> us1)
-               | uu___ -> us1)
-          | FStar_Syntax_Syntax.U_succ u3 ->
-              let uu___ = aux u3 in
-              FStar_Compiler_List.map
-                (fun uu___1 -> FStar_Syntax_Syntax.U_succ uu___1) uu___ in
-        if
-          (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.erase_universes
-        then FStar_Syntax_Syntax.U_unknown
-        else
-          (let uu___1 = aux u in
-           match uu___1 with
-           | [] -> FStar_Syntax_Syntax.U_zero
-           | (FStar_Syntax_Syntax.U_zero)::[] -> FStar_Syntax_Syntax.U_zero
-           | (FStar_Syntax_Syntax.U_zero)::u1::[] -> u1
-           | (FStar_Syntax_Syntax.U_zero)::us -> FStar_Syntax_Syntax.U_max us
-           | u1::[] -> u1
-           | us -> FStar_Syntax_Syntax.U_max us)
-let rec (inline_closure_env :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      stack_elt Prims.list ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun t ->
-          FStar_TypeChecker_Cfg.log cfg
-            (fun uu___1 ->
-               let uu___2 = FStar_Syntax_Print.tag_of_term t in
-               let uu___3 = env_to_string env1 in
-               let uu___4 = FStar_Syntax_Print.term_to_string t in
-               FStar_Compiler_Util.print3
-                 ">>> %s (env=%s)\nClosure_as_term %s\n" uu___2 uu___3 uu___4);
-          (match env1 with
-           | [] when
-               FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.compress_uvars
-               -> rebuild_closure cfg env1 stack1 t
-           | uu___1 ->
-               (match t.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_delayed uu___2 ->
-                    let uu___3 = FStar_Syntax_Subst.compress t in
-                    inline_closure_env cfg env1 stack1 uu___3
-                | FStar_Syntax_Syntax.Tm_unknown ->
-                    rebuild_closure cfg env1 stack1 t
-                | FStar_Syntax_Syntax.Tm_constant uu___2 ->
-                    rebuild_closure cfg env1 stack1 t
-                | FStar_Syntax_Syntax.Tm_name uu___2 ->
-                    rebuild_closure cfg env1 stack1 t
-                | FStar_Syntax_Syntax.Tm_lazy uu___2 ->
-                    rebuild_closure cfg env1 stack1 t
-                | FStar_Syntax_Syntax.Tm_fvar uu___2 ->
-                    rebuild_closure cfg env1 stack1 t
-                | FStar_Syntax_Syntax.Tm_uvar (uv, s) ->
-                    if
-                      (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.check_no_uvars
-                    then
-                      let t1 = FStar_Syntax_Subst.compress t in
-                      (match t1.FStar_Syntax_Syntax.n with
-                       | FStar_Syntax_Syntax.Tm_uvar uu___2 ->
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Compiler_Range.string_of_range
-                                 t1.FStar_Syntax_Syntax.pos in
-                             let uu___5 =
-                               FStar_Syntax_Print.term_to_string t1 in
-                             FStar_Compiler_Util.format2
-                               "(%s): CheckNoUvars: Unexpected unification variable remains: %s"
-                               uu___4 uu___5 in
-                           failwith uu___3
-                       | uu___2 -> inline_closure_env cfg env1 stack1 t1)
-                    else
-                      (let s' =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           (FStar_Pervasives_Native.fst s)
-                           (FStar_Compiler_List.map
-                              (fun s1 ->
-                                 FStar_Compiler_Effect.op_Bar_Greater s1
-                                   (FStar_Compiler_List.map
-                                      (fun uu___3 ->
-                                         match uu___3 with
-                                         | FStar_Syntax_Syntax.NT (x, t1) ->
-                                             let uu___4 =
-                                               let uu___5 =
-                                                 inline_closure_env cfg env1
-                                                   [] t1 in
-                                               (x, uu___5) in
-                                             FStar_Syntax_Syntax.NT uu___4
-                                         | FStar_Syntax_Syntax.NM (x, i) ->
-                                             let x_i =
-                                               FStar_Syntax_Syntax.bv_to_tm
-                                                 {
-                                                   FStar_Syntax_Syntax.ppname
-                                                     =
-                                                     (x.FStar_Syntax_Syntax.ppname);
-                                                   FStar_Syntax_Syntax.index
-                                                     = i;
-                                                   FStar_Syntax_Syntax.sort =
-                                                     (x.FStar_Syntax_Syntax.sort)
-                                                 } in
-                                             let t1 =
-                                               inline_closure_env cfg env1 []
-                                                 x_i in
-                                             (match t1.FStar_Syntax_Syntax.n
-                                              with
-                                              | FStar_Syntax_Syntax.Tm_bvar
-                                                  x_j ->
-                                                  FStar_Syntax_Syntax.NM
-                                                    (x,
-                                                      (x_j.FStar_Syntax_Syntax.index))
-                                              | uu___4 ->
-                                                  FStar_Syntax_Syntax.NT
-                                                    (x, t1))
-                                         | uu___4 ->
-                                             failwith
-                                               "Impossible: subst invariant of uvar nodes")))) in
-                       let t1 =
-                         {
-                           FStar_Syntax_Syntax.n =
-                             (FStar_Syntax_Syntax.Tm_uvar
-                                (uv, (s', (FStar_Pervasives_Native.snd s))));
-                           FStar_Syntax_Syntax.pos =
-                             (t.FStar_Syntax_Syntax.pos);
-                           FStar_Syntax_Syntax.vars =
-                             (t.FStar_Syntax_Syntax.vars);
-                           FStar_Syntax_Syntax.hash_code =
-                             (t.FStar_Syntax_Syntax.hash_code)
-                         } in
-                       rebuild_closure cfg env1 stack1 t1)
-                | FStar_Syntax_Syntax.Tm_type u ->
-                    let t1 =
-                      let uu___2 =
-                        let uu___3 = norm_universe cfg env1 u in
-                        FStar_Syntax_Syntax.Tm_type uu___3 in
-                      FStar_Syntax_Syntax.mk uu___2 t.FStar_Syntax_Syntax.pos in
-                    rebuild_closure cfg env1 stack1 t1
-                | FStar_Syntax_Syntax.Tm_uinst (t', us) ->
-                    let t1 =
-                      let uu___2 =
-                        FStar_Compiler_List.map (norm_universe cfg env1) us in
-                      FStar_Syntax_Syntax.mk_Tm_uinst t' uu___2 in
-                    rebuild_closure cfg env1 stack1 t1
-                | FStar_Syntax_Syntax.Tm_bvar x ->
-                    let uu___2 = lookup_bvar env1 x in
-                    (match uu___2 with
-                     | Univ uu___3 ->
-                         failwith
-                           "Impossible: term variable is bound to a universe"
-                     | Dummy ->
-                         let x1 =
-                           {
-                             FStar_Syntax_Syntax.ppname =
-                               (x.FStar_Syntax_Syntax.ppname);
-                             FStar_Syntax_Syntax.index =
-                               (x.FStar_Syntax_Syntax.index);
-                             FStar_Syntax_Syntax.sort =
-                               FStar_Syntax_Syntax.tun
-                           } in
-                         let t1 =
-                           FStar_Syntax_Syntax.mk
-                             (FStar_Syntax_Syntax.Tm_bvar x1)
-                             t.FStar_Syntax_Syntax.pos in
-                         rebuild_closure cfg env1 stack1 t1
-                     | Clos (env2, t0, uu___3, uu___4) ->
-                         inline_closure_env cfg env2 stack1 t0)
-                | FStar_Syntax_Syntax.Tm_app (head, args) ->
-                    let stack2 =
-                      FStar_Compiler_Effect.op_Bar_Greater stack1
-                        (FStar_Compiler_List.fold_right
-                           (fun uu___2 ->
-                              fun stack3 ->
-                                match uu___2 with
-                                | (a, aq) ->
-                                    let uu___3 =
-                                      let uu___4 =
-                                        let uu___5 =
-                                          let uu___6 =
-                                            let uu___7 =
-                                              FStar_Compiler_Util.mk_ref
-                                                FStar_Pervasives_Native.None in
-                                            (env1, a, uu___7, false) in
-                                          Clos uu___6 in
-                                        (uu___5, aq,
-                                          (t.FStar_Syntax_Syntax.pos)) in
-                                      Arg uu___4 in
-                                    uu___3 :: stack3) args) in
-                    inline_closure_env cfg env1 stack2 head
-                | FStar_Syntax_Syntax.Tm_abs (bs, body, lopt) ->
-                    let env' =
-                      FStar_Compiler_Effect.op_Bar_Greater env1
-                        (FStar_Compiler_List.fold_right
-                           (fun _b ->
-                              fun env2 ->
-                                (FStar_Pervasives_Native.None, Dummy) :: env2)
-                           bs) in
-                    let stack2 =
-                      (Abs
-                         (env1, bs, env', lopt, (t.FStar_Syntax_Syntax.pos)))
-                      :: stack1 in
-                    inline_closure_env cfg env' stack2 body
-                | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                    let uu___2 = close_binders cfg env1 bs in
-                    (match uu___2 with
-                     | (bs1, env') ->
-                         let c1 = close_comp cfg env' c in
-                         let t1 =
-                           FStar_Syntax_Syntax.mk
-                             (FStar_Syntax_Syntax.Tm_arrow (bs1, c1))
-                             t.FStar_Syntax_Syntax.pos in
-                         rebuild_closure cfg env1 stack1 t1)
-                | FStar_Syntax_Syntax.Tm_refine (x, uu___2) when
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                      ||
-                      (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unrefine
-                    ->
-                    inline_closure_env cfg env1 stack1
-                      x.FStar_Syntax_Syntax.sort
-                | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Syntax.mk_binder x in
-                        [uu___4] in
-                      close_binders cfg env1 uu___3 in
-                    (match uu___2 with
-                     | (x1, env2) ->
-                         let phi1 = non_tail_inline_closure_env cfg env2 phi in
-                         let t1 =
-                           let uu___3 =
-                             let uu___4 =
-                               let uu___5 =
-                                 let uu___6 = FStar_Compiler_List.hd x1 in
-                                 uu___6.FStar_Syntax_Syntax.binder_bv in
-                               (uu___5, phi1) in
-                             FStar_Syntax_Syntax.Tm_refine uu___4 in
-                           FStar_Syntax_Syntax.mk uu___3
-                             t.FStar_Syntax_Syntax.pos in
-                         rebuild_closure cfg env2 stack1 t1)
-                | FStar_Syntax_Syntax.Tm_ascribed (t1, asc, lopt) ->
-                    let asc1 = close_ascription cfg env1 asc in
-                    let t2 =
-                      let uu___2 =
-                        let uu___3 =
-                          let uu___4 =
-                            non_tail_inline_closure_env cfg env1 t1 in
-                          (uu___4, asc1, lopt) in
-                        FStar_Syntax_Syntax.Tm_ascribed uu___3 in
-                      FStar_Syntax_Syntax.mk uu___2 t.FStar_Syntax_Syntax.pos in
-                    rebuild_closure cfg env1 stack1 t2
-                | FStar_Syntax_Syntax.Tm_quoted (t', qi) ->
-                    let t1 =
-                      match qi.FStar_Syntax_Syntax.qkind with
-                      | FStar_Syntax_Syntax.Quote_dynamic ->
-                          let uu___2 =
-                            let uu___3 =
-                              let uu___4 =
-                                non_tail_inline_closure_env cfg env1 t' in
-                              (uu___4, qi) in
-                            FStar_Syntax_Syntax.Tm_quoted uu___3 in
-                          FStar_Syntax_Syntax.mk uu___2
-                            t.FStar_Syntax_Syntax.pos
-                      | FStar_Syntax_Syntax.Quote_static ->
-                          let qi1 =
-                            FStar_Syntax_Syntax.on_antiquoted
-                              (non_tail_inline_closure_env cfg env1) qi in
-                          FStar_Syntax_Syntax.mk
-                            (FStar_Syntax_Syntax.Tm_quoted (t', qi1))
-                            t.FStar_Syntax_Syntax.pos in
-                    rebuild_closure cfg env1 stack1 t1
-                | FStar_Syntax_Syntax.Tm_meta (t', m) ->
-                    let stack2 =
-                      (Meta (env1, m, (t.FStar_Syntax_Syntax.pos))) :: stack1 in
-                    inline_closure_env cfg env1 stack2 t'
-                | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-                    let env0 = env1 in
-                    let env2 =
-                      FStar_Compiler_List.fold_left
-                        (fun env3 -> fun uu___2 -> dummy :: env3) env1
-                        lb.FStar_Syntax_Syntax.lbunivs in
-                    let typ =
-                      non_tail_inline_closure_env cfg env2
-                        lb.FStar_Syntax_Syntax.lbtyp in
-                    let def =
-                      non_tail_inline_closure_env cfg env2
-                        lb.FStar_Syntax_Syntax.lbdef in
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Syntax.is_top_level [lb] in
-                      if uu___3
-                      then ((lb.FStar_Syntax_Syntax.lbname), body)
-                      else
-                        (let x =
-                           FStar_Compiler_Util.left
-                             lb.FStar_Syntax_Syntax.lbname in
-                         let uu___5 =
-                           non_tail_inline_closure_env cfg (dummy :: env0)
-                             body in
-                         ((FStar_Pervasives.Inl
-                             {
-                               FStar_Syntax_Syntax.ppname =
-                                 (x.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (x.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = typ
-                             }), uu___5)) in
-                    (match uu___2 with
-                     | (nm, body1) ->
-                         let attrs =
-                           FStar_Compiler_List.map
-                             (non_tail_inline_closure_env cfg env0)
-                             lb.FStar_Syntax_Syntax.lbattrs in
-                         let lb1 =
-                           {
-                             FStar_Syntax_Syntax.lbname = nm;
-                             FStar_Syntax_Syntax.lbunivs =
-                               (lb.FStar_Syntax_Syntax.lbunivs);
-                             FStar_Syntax_Syntax.lbtyp = typ;
-                             FStar_Syntax_Syntax.lbeff =
-                               (lb.FStar_Syntax_Syntax.lbeff);
-                             FStar_Syntax_Syntax.lbdef = def;
-                             FStar_Syntax_Syntax.lbattrs = attrs;
-                             FStar_Syntax_Syntax.lbpos =
-                               (lb.FStar_Syntax_Syntax.lbpos)
-                           } in
-                         let t1 =
-                           FStar_Syntax_Syntax.mk
-                             (FStar_Syntax_Syntax.Tm_let
-                                ((false, [lb1]), body1))
-                             t.FStar_Syntax_Syntax.pos in
-                         rebuild_closure cfg env0 stack1 t1)
-                | FStar_Syntax_Syntax.Tm_let ((uu___2, lbs), body) ->
-                    let norm_one_lb env2 lb =
-                      let env_univs =
-                        FStar_Compiler_List.fold_right
-                          (fun uu___3 -> fun env3 -> dummy :: env3)
-                          lb.FStar_Syntax_Syntax.lbunivs env2 in
-                      let env3 =
-                        let uu___3 = FStar_Syntax_Syntax.is_top_level lbs in
-                        if uu___3
-                        then env_univs
-                        else
-                          FStar_Compiler_List.fold_right
-                            (fun uu___5 -> fun env4 -> dummy :: env4) lbs
-                            env_univs in
-                      let ty =
-                        non_tail_inline_closure_env cfg env_univs
-                          lb.FStar_Syntax_Syntax.lbtyp in
-                      let nm =
-                        let uu___3 = FStar_Syntax_Syntax.is_top_level lbs in
-                        if uu___3
-                        then lb.FStar_Syntax_Syntax.lbname
-                        else
-                          (let x =
-                             FStar_Compiler_Util.left
-                               lb.FStar_Syntax_Syntax.lbname in
-                           FStar_Pervasives.Inl
-                             {
-                               FStar_Syntax_Syntax.ppname =
-                                 (x.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (x.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = ty
-                             }) in
-                      let uu___3 =
-                        non_tail_inline_closure_env cfg env3
-                          lb.FStar_Syntax_Syntax.lbdef in
-                      {
-                        FStar_Syntax_Syntax.lbname = nm;
-                        FStar_Syntax_Syntax.lbunivs =
-                          (lb.FStar_Syntax_Syntax.lbunivs);
-                        FStar_Syntax_Syntax.lbtyp = ty;
-                        FStar_Syntax_Syntax.lbeff =
-                          (lb.FStar_Syntax_Syntax.lbeff);
-                        FStar_Syntax_Syntax.lbdef = uu___3;
-                        FStar_Syntax_Syntax.lbattrs =
-                          (lb.FStar_Syntax_Syntax.lbattrs);
-                        FStar_Syntax_Syntax.lbpos =
-                          (lb.FStar_Syntax_Syntax.lbpos)
-                      } in
-                    let lbs1 =
-                      FStar_Compiler_Effect.op_Bar_Greater lbs
-                        (FStar_Compiler_List.map (norm_one_lb env1)) in
-                    let body1 =
-                      let body_env =
-                        FStar_Compiler_List.fold_right
-                          (fun uu___3 -> fun env2 -> dummy :: env2) lbs1 env1 in
-                      non_tail_inline_closure_env cfg body_env body in
-                    let t1 =
-                      FStar_Syntax_Syntax.mk
-                        (FStar_Syntax_Syntax.Tm_let ((true, lbs1), body1))
-                        t.FStar_Syntax_Syntax.pos in
-                    rebuild_closure cfg env1 stack1 t1
-                | FStar_Syntax_Syntax.Tm_match
-                    (head, asc_opt, branches1, lopt) ->
-                    let stack2 =
-                      (Match
-                         (env1, asc_opt, branches1, lopt, cfg,
-                           (t.FStar_Syntax_Syntax.pos)))
-                      :: stack1 in
-                    inline_closure_env cfg env1 stack2 head))
-and (non_tail_inline_closure_env :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  = fun cfg -> fun env1 -> fun t -> inline_closure_env cfg env1 [] t
-and (rebuild_closure :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      stack_elt Prims.list ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun t ->
-          FStar_TypeChecker_Cfg.log cfg
-            (fun uu___1 ->
-               let uu___2 = FStar_Syntax_Print.tag_of_term t in
-               let uu___3 = env_to_string env1 in
-               let uu___4 = stack_to_string stack1 in
-               let uu___5 = FStar_Syntax_Print.term_to_string t in
-               FStar_Compiler_Util.print4
-                 ">>> %s (env=%s, stack=%s)\nRebuild closure_as_term %s\n"
-                 uu___2 uu___3 uu___4 uu___5);
-          (match stack1 with
-           | [] -> t
-           | (Arg (Clos (env_arg, tm, uu___1, uu___2), aq, r))::stack2 ->
-               let stack3 = (App (env1, t, aq, r)) :: stack2 in
-               inline_closure_env cfg env_arg stack3 tm
-           | (App (env2, head, aq, r))::stack2 ->
-               let t1 = FStar_Syntax_Syntax.extend_app head (t, aq) r in
-               rebuild_closure cfg env2 stack2 t1
-           | (CBVApp (env2, head, aq, r))::stack2 ->
-               let t1 = FStar_Syntax_Syntax.extend_app head (t, aq) r in
-               rebuild_closure cfg env2 stack2 t1
-           | (Abs (env', bs, env'', lopt, r))::stack2 ->
-               let uu___1 = close_binders cfg env' bs in
-               (match uu___1 with
-                | (bs1, uu___2) ->
-                    let lopt1 = close_lcomp_opt cfg env'' lopt in
-                    let uu___3 =
-                      let uu___4 = FStar_Syntax_Util.abs bs1 t lopt1 in
-                      {
-                        FStar_Syntax_Syntax.n =
-                          (uu___4.FStar_Syntax_Syntax.n);
-                        FStar_Syntax_Syntax.pos = r;
-                        FStar_Syntax_Syntax.vars =
-                          (uu___4.FStar_Syntax_Syntax.vars);
-                        FStar_Syntax_Syntax.hash_code =
-                          (uu___4.FStar_Syntax_Syntax.hash_code)
-                      } in
-                    rebuild_closure cfg env1 stack2 uu___3)
-           | (Match (env2, asc_opt, branches1, lopt, cfg1, r))::stack2 ->
-               let lopt1 = close_lcomp_opt cfg1 env2 lopt in
-               let close_one_branch env3 uu___1 =
-                 match uu___1 with
-                 | (pat, w_opt, tm) ->
-                     let rec norm_pat env4 p =
-                       match p.FStar_Syntax_Syntax.v with
-                       | FStar_Syntax_Syntax.Pat_constant uu___2 -> (p, env4)
-                       | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-                           let us_opt1 =
-                             if
-                               (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.erase_universes
-                             then FStar_Pervasives_Native.None
-                             else
-                               (match us_opt with
-                                | FStar_Pervasives_Native.None ->
-                                    FStar_Pervasives_Native.None
-                                | FStar_Pervasives_Native.Some us ->
-                                    let uu___3 =
-                                      FStar_Compiler_List.map
-                                        (norm_universe cfg1 env4) us in
-                                    FStar_Pervasives_Native.Some uu___3) in
-                           let uu___2 =
-                             FStar_Compiler_Effect.op_Bar_Greater pats
-                               (FStar_Compiler_List.fold_left
-                                  (fun uu___3 ->
-                                     fun uu___4 ->
-                                       match (uu___3, uu___4) with
-                                       | ((pats1, env5), (p1, b)) ->
-                                           let uu___5 = norm_pat env5 p1 in
-                                           (match uu___5 with
-                                            | (p2, env6) ->
-                                                (((p2, b) :: pats1), env6)))
-                                  ([], env4)) in
-                           (match uu___2 with
-                            | (pats1, env5) ->
-                                ({
-                                   FStar_Syntax_Syntax.v =
-                                     (FStar_Syntax_Syntax.Pat_cons
-                                        (fv, us_opt1,
-                                          (FStar_Compiler_List.rev pats1)));
-                                   FStar_Syntax_Syntax.p =
-                                     (p.FStar_Syntax_Syntax.p)
-                                 }, env5))
-                       | FStar_Syntax_Syntax.Pat_var x ->
-                           let x1 =
-                             let uu___2 =
-                               non_tail_inline_closure_env cfg1 env4
-                                 x.FStar_Syntax_Syntax.sort in
-                             {
-                               FStar_Syntax_Syntax.ppname =
-                                 (x.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (x.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = uu___2
-                             } in
-                           ({
-                              FStar_Syntax_Syntax.v =
-                                (FStar_Syntax_Syntax.Pat_var x1);
-                              FStar_Syntax_Syntax.p =
-                                (p.FStar_Syntax_Syntax.p)
-                            }, (dummy :: env4))
-                       | FStar_Syntax_Syntax.Pat_wild x ->
-                           let x1 =
-                             let uu___2 =
-                               non_tail_inline_closure_env cfg1 env4
-                                 x.FStar_Syntax_Syntax.sort in
-                             {
-                               FStar_Syntax_Syntax.ppname =
-                                 (x.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (x.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = uu___2
-                             } in
-                           ({
-                              FStar_Syntax_Syntax.v =
-                                (FStar_Syntax_Syntax.Pat_wild x1);
-                              FStar_Syntax_Syntax.p =
-                                (p.FStar_Syntax_Syntax.p)
-                            }, (dummy :: env4))
-                       | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-                           let eopt1 =
-                             FStar_Compiler_Util.map_option
-                               (non_tail_inline_closure_env cfg1 env4) eopt in
-                           ({
-                              FStar_Syntax_Syntax.v =
-                                (FStar_Syntax_Syntax.Pat_dot_term eopt1);
-                              FStar_Syntax_Syntax.p =
-                                (p.FStar_Syntax_Syntax.p)
-                            }, env4) in
-                     let uu___2 = norm_pat env3 pat in
-                     (match uu___2 with
-                      | (pat1, env4) ->
-                          let w_opt1 =
-                            match w_opt with
-                            | FStar_Pervasives_Native.None ->
-                                FStar_Pervasives_Native.None
-                            | FStar_Pervasives_Native.Some w ->
-                                let uu___3 =
-                                  non_tail_inline_closure_env cfg1 env4 w in
-                                FStar_Pervasives_Native.Some uu___3 in
-                          let tm1 = non_tail_inline_closure_env cfg1 env4 tm in
-                          (pat1, w_opt1, tm1)) in
-               let t1 =
-                 let uu___1 =
-                   let uu___2 =
-                     let uu___3 = close_match_returns cfg1 env2 asc_opt in
-                     let uu___4 =
-                       FStar_Compiler_Effect.op_Bar_Greater branches1
-                         (FStar_Compiler_List.map (close_one_branch env2)) in
-                     (t, uu___3, uu___4, lopt1) in
-                   FStar_Syntax_Syntax.Tm_match uu___2 in
-                 FStar_Syntax_Syntax.mk uu___1 t.FStar_Syntax_Syntax.pos in
-               rebuild_closure cfg1 env2 stack2 t1
-           | (Meta (env_m, m, r))::stack2 ->
-               let m1 =
-                 match m with
-                 | FStar_Syntax_Syntax.Meta_pattern (names, args) ->
-                     let uu___1 =
-                       let uu___2 =
-                         FStar_Compiler_Effect.op_Bar_Greater names
-                           (FStar_Compiler_List.map
-                              (non_tail_inline_closure_env cfg env_m)) in
-                       let uu___3 =
-                         FStar_Compiler_Effect.op_Bar_Greater args
-                           (FStar_Compiler_List.map
-                              (fun args1 ->
-                                 FStar_Compiler_Effect.op_Bar_Greater args1
-                                   (FStar_Compiler_List.map
-                                      (fun uu___4 ->
-                                         match uu___4 with
-                                         | (a, q) ->
-                                             let uu___5 =
-                                               non_tail_inline_closure_env
-                                                 cfg env_m a in
-                                             (uu___5, q))))) in
-                       (uu___2, uu___3) in
-                     FStar_Syntax_Syntax.Meta_pattern uu___1
-                 | FStar_Syntax_Syntax.Meta_monadic (m2, tbody) ->
-                     let uu___1 =
-                       let uu___2 =
-                         non_tail_inline_closure_env cfg env_m tbody in
-                       (m2, uu___2) in
-                     FStar_Syntax_Syntax.Meta_monadic uu___1
-                 | FStar_Syntax_Syntax.Meta_monadic_lift (m11, m2, tbody) ->
-                     let uu___1 =
-                       let uu___2 =
-                         non_tail_inline_closure_env cfg env_m tbody in
-                       (m11, m2, uu___2) in
-                     FStar_Syntax_Syntax.Meta_monadic_lift uu___1
-                 | uu___1 -> m in
-               let t1 =
-                 FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_meta (t, m1))
-                   r in
-               rebuild_closure cfg env1 stack2 t1
-           | uu___1 -> failwith "Impossible: unexpected stack element")
-and (close_match_returns :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.match_returns_ascription
-        FStar_Pervasives_Native.option ->
-        (FStar_Syntax_Syntax.binder *
-          ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-          FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-          Prims.bool)) FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun ret_opt ->
-        match ret_opt with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some (b, asc) ->
-            let uu___ = close_binders cfg env1 [b] in
-            (match uu___ with
-             | (bs, env2) ->
-                 let asc1 = close_ascription cfg env2 asc in
-                 let uu___1 =
-                   let uu___2 = FStar_Compiler_List.hd bs in (uu___2, asc1) in
-                 FStar_Pervasives_Native.Some uu___1)
-and (close_ascription :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-        FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-        FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-        Prims.bool) ->
-        ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-          FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-          Prims.bool))
-  =
-  fun cfg ->
-    fun env1 ->
-      fun uu___ ->
-        match uu___ with
-        | (annot, tacopt, use_eq) ->
-            let annot1 =
-              match annot with
-              | FStar_Pervasives.Inl t ->
-                  let uu___1 = non_tail_inline_closure_env cfg env1 t in
-                  FStar_Pervasives.Inl uu___1
-              | FStar_Pervasives.Inr c ->
-                  let uu___1 = close_comp cfg env1 c in
-                  FStar_Pervasives.Inr uu___1 in
-            let tacopt1 =
-              FStar_Compiler_Util.map_opt tacopt
-                (non_tail_inline_closure_env cfg env1) in
-            (annot1, tacopt1, use_eq)
-and (close_imp :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun imp ->
-        match imp with
-        | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-            let uu___ =
-              let uu___1 = inline_closure_env cfg env1 [] t in
-              FStar_Syntax_Syntax.Meta uu___1 in
-            FStar_Pervasives_Native.Some uu___
-        | i -> i
-and (close_binders :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.binder Prims.list ->
-        (FStar_Syntax_Syntax.binder Prims.list * env))
-  =
-  fun cfg ->
-    fun env1 ->
-      fun bs ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater bs
-            (FStar_Compiler_List.fold_left
-               (fun uu___1 ->
-                  fun uu___2 ->
-                    match (uu___1, uu___2) with
-                    | ((env2, out),
-                       { FStar_Syntax_Syntax.binder_bv = b;
-                         FStar_Syntax_Syntax.binder_qual = imp;
-                         FStar_Syntax_Syntax.binder_attrs = attrs;_})
-                        ->
-                        let b1 =
-                          let uu___3 =
-                            inline_closure_env cfg env2 []
-                              b.FStar_Syntax_Syntax.sort in
-                          {
-                            FStar_Syntax_Syntax.ppname =
-                              (b.FStar_Syntax_Syntax.ppname);
-                            FStar_Syntax_Syntax.index =
-                              (b.FStar_Syntax_Syntax.index);
-                            FStar_Syntax_Syntax.sort = uu___3
-                          } in
-                        let imp1 = close_imp cfg env2 imp in
-                        let attrs1 =
-                          FStar_Compiler_List.map
-                            (non_tail_inline_closure_env cfg env2) attrs in
-                        let env3 = dummy :: env2 in
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Syntax_Syntax.mk_binder_with_attrs b1 imp1
-                              attrs1 in
-                          uu___4 :: out in
-                        (env3, uu___3)) (env1, [])) in
-        match uu___ with
-        | (env2, bs1) -> ((FStar_Compiler_List.rev bs1), env2)
-and (close_comp :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun c ->
-        match env1 with
-        | [] when
-            FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation
-              (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.compress_uvars
-            -> c
-        | uu___ ->
-            (match c.FStar_Syntax_Syntax.n with
-             | FStar_Syntax_Syntax.Total t ->
-                 let uu___1 = inline_closure_env cfg env1 [] t in
-                 FStar_Syntax_Syntax.mk_Total uu___1
-             | FStar_Syntax_Syntax.GTotal t ->
-                 let uu___1 = inline_closure_env cfg env1 [] t in
-                 FStar_Syntax_Syntax.mk_GTotal uu___1
-             | FStar_Syntax_Syntax.Comp c1 ->
-                 let rt =
-                   inline_closure_env cfg env1 []
-                     c1.FStar_Syntax_Syntax.result_typ in
-                 let args =
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     c1.FStar_Syntax_Syntax.effect_args
-                     (FStar_Compiler_List.map
-                        (fun uu___1 ->
-                           match uu___1 with
-                           | (a, q) ->
-                               let uu___2 = inline_closure_env cfg env1 [] a in
-                               (uu___2, q))) in
-                 let flags =
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     c1.FStar_Syntax_Syntax.flags
-                     (FStar_Compiler_List.map
-                        (fun uu___1 ->
-                           match uu___1 with
-                           | FStar_Syntax_Syntax.DECREASES
-                               (FStar_Syntax_Syntax.Decreases_lex l) ->
-                               let uu___2 =
-                                 let uu___3 =
-                                   FStar_Compiler_Effect.op_Bar_Greater l
-                                     (FStar_Compiler_List.map
-                                        (inline_closure_env cfg env1 [])) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                   (fun uu___4 ->
-                                      FStar_Syntax_Syntax.Decreases_lex
-                                        uu___4) in
-                               FStar_Syntax_Syntax.DECREASES uu___2
-                           | FStar_Syntax_Syntax.DECREASES
-                               (FStar_Syntax_Syntax.Decreases_wf (rel, e)) ->
-                               let uu___2 =
-                                 let uu___3 =
-                                   let uu___4 =
-                                     inline_closure_env cfg env1 [] rel in
-                                   let uu___5 =
-                                     inline_closure_env cfg env1 [] e in
-                                   (uu___4, uu___5) in
-                                 FStar_Syntax_Syntax.Decreases_wf uu___3 in
-                               FStar_Syntax_Syntax.DECREASES uu___2
-                           | f -> f)) in
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Compiler_List.map (norm_universe cfg env1)
-                       c1.FStar_Syntax_Syntax.comp_univs in
-                   {
-                     FStar_Syntax_Syntax.comp_univs = uu___2;
-                     FStar_Syntax_Syntax.effect_name =
-                       (c1.FStar_Syntax_Syntax.effect_name);
-                     FStar_Syntax_Syntax.result_typ = rt;
-                     FStar_Syntax_Syntax.effect_args = args;
-                     FStar_Syntax_Syntax.flags = flags
-                   } in
-                 FStar_Syntax_Syntax.mk_Comp uu___1)
-and (close_lcomp_opt :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.residual_comp FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun lopt ->
-        match lopt with
-        | FStar_Pervasives_Native.Some rc ->
-            let flags =
-              FStar_Compiler_Effect.op_Bar_Greater
-                rc.FStar_Syntax_Syntax.residual_flags
-                (FStar_Compiler_List.filter
-                   (fun uu___ ->
-                      match uu___ with
-                      | FStar_Syntax_Syntax.DECREASES uu___1 -> false
-                      | uu___1 -> true)) in
-            let rc1 =
-              let uu___ =
-                FStar_Compiler_Util.map_opt
-                  rc.FStar_Syntax_Syntax.residual_typ
-                  (inline_closure_env cfg env1 []) in
-              {
-                FStar_Syntax_Syntax.residual_effect =
-                  (rc.FStar_Syntax_Syntax.residual_effect);
-                FStar_Syntax_Syntax.residual_typ = uu___;
-                FStar_Syntax_Syntax.residual_flags = flags
-              } in
-            FStar_Pervasives_Native.Some rc1
-        | uu___ -> lopt
-let (filter_out_lcomp_cflags :
-  FStar_Syntax_Syntax.cflag Prims.list ->
-    FStar_Syntax_Syntax.cflag Prims.list)
-  =
-  fun flags ->
-    FStar_Compiler_Effect.op_Bar_Greater flags
-      (FStar_Compiler_List.filter
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.DECREASES uu___1 -> false
-            | uu___1 -> true))
-let (closure_as_term :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  = fun cfg -> fun env1 -> fun t -> non_tail_inline_closure_env cfg env1 t
-let (unembed_binder_knot :
-  FStar_Syntax_Syntax.binder FStar_Syntax_Embeddings.embedding
-    FStar_Pervasives_Native.option FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (unembed_binder :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ = FStar_Compiler_Effect.op_Bang unembed_binder_knot in
-    match uu___ with
-    | FStar_Pervasives_Native.Some e ->
-        let uu___1 = FStar_Syntax_Embeddings.unembed e t in
-        uu___1 false FStar_Syntax_Embeddings.id_norm_cb
-    | FStar_Pervasives_Native.None ->
-        (FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos
-           (FStar_Errors.Warning_UnembedBinderKnot,
-             "unembed_binder_knot is unset!");
-         FStar_Pervasives_Native.None)
-let (mk_psc_subst :
-  FStar_TypeChecker_Cfg.cfg ->
-    (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-      Prims.list -> FStar_Syntax_Syntax.subst_elt Prims.list)
-  =
-  fun cfg ->
-    fun env1 ->
-      FStar_Compiler_List.fold_right
-        (fun uu___ ->
-           fun subst ->
-             match uu___ with
-             | (binder_opt, closure1) ->
-                 (match (binder_opt, closure1) with
-                  | (FStar_Pervasives_Native.Some b, Clos
-                     (env2, term, uu___1, uu___2)) ->
-                      let bv = b.FStar_Syntax_Syntax.binder_bv in
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Syntax_Util.is_constructed_typ
-                            bv.FStar_Syntax_Syntax.sort
-                            FStar_Parser_Const.binder_lid in
-                        Prims.op_Negation uu___4 in
-                      if uu___3
-                      then subst
-                      else
-                        (let term1 = closure_as_term cfg env2 term in
-                         let uu___5 = unembed_binder term1 in
-                         match uu___5 with
-                         | FStar_Pervasives_Native.None -> subst
-                         | FStar_Pervasives_Native.Some x ->
-                             let b1 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   FStar_Syntax_Subst.subst subst
-                                     (x.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                 {
-                                   FStar_Syntax_Syntax.ppname =
-                                     (bv.FStar_Syntax_Syntax.ppname);
-                                   FStar_Syntax_Syntax.index =
-                                     (bv.FStar_Syntax_Syntax.index);
-                                   FStar_Syntax_Syntax.sort = uu___7
-                                 } in
-                               FStar_Syntax_Syntax.freshen_bv uu___6 in
-                             let b_for_x =
-                               let uu___6 =
-                                 let uu___7 =
-                                   FStar_Syntax_Syntax.bv_to_name b1 in
-                                 ((x.FStar_Syntax_Syntax.binder_bv), uu___7) in
-                               FStar_Syntax_Syntax.NT uu___6 in
-                             let subst1 =
-                               FStar_Compiler_List.filter
-                                 (fun uu___6 ->
-                                    match uu___6 with
-                                    | FStar_Syntax_Syntax.NT
-                                        (uu___7,
-                                         {
-                                           FStar_Syntax_Syntax.n =
-                                             FStar_Syntax_Syntax.Tm_name b';
-                                           FStar_Syntax_Syntax.pos = uu___8;
-                                           FStar_Syntax_Syntax.vars = uu___9;
-                                           FStar_Syntax_Syntax.hash_code =
-                                             uu___10;_})
-                                        ->
-                                        let uu___11 =
-                                          FStar_Ident.ident_equals
-                                            b1.FStar_Syntax_Syntax.ppname
-                                            b'.FStar_Syntax_Syntax.ppname in
-                                        Prims.op_Negation uu___11
-                                    | uu___7 -> true) subst in
-                             b_for_x :: subst1)
-                  | uu___1 -> subst)) env1 []
-let (reduce_primops :
-  FStar_Syntax_Embeddings.norm_cb ->
-    FStar_TypeChecker_Cfg.cfg ->
-      (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-        Prims.list ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun norm_cb ->
-    fun cfg ->
-      fun env1 ->
-        fun tm ->
-          if
-            Prims.op_Negation
-              (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.primops
-          then tm
-          else
-            (let uu___1 = FStar_Syntax_Util.head_and_args tm in
-             match uu___1 with
-             | (head, args) ->
-                 let uu___2 =
-                   let head1 = FStar_Syntax_Subst.compress head in
-                   match head1.FStar_Syntax_Syntax.n with
-                   | FStar_Syntax_Syntax.Tm_uinst (fv, us) -> (fv, us)
-                   | uu___3 -> (head1, []) in
-                 (match uu___2 with
-                  | (head_term, universes) ->
-                      (match head_term.FStar_Syntax_Syntax.n with
-                       | FStar_Syntax_Syntax.Tm_fvar fv ->
-                           let uu___3 =
-                             FStar_TypeChecker_Cfg.find_prim_step cfg fv in
-                           (match uu___3 with
-                            | FStar_Pervasives_Native.Some prim_step when
-                                prim_step.FStar_TypeChecker_Cfg.strong_reduction_ok
-                                  ||
-                                  (Prims.op_Negation
-                                     cfg.FStar_TypeChecker_Cfg.strong)
-                                ->
-                                let l = FStar_Compiler_List.length args in
-                                if l < prim_step.FStar_TypeChecker_Cfg.arity
-                                then
-                                  (FStar_TypeChecker_Cfg.log_primops cfg
-                                     (fun uu___5 ->
-                                        let uu___6 =
-                                          FStar_Syntax_Print.lid_to_string
-                                            prim_step.FStar_TypeChecker_Cfg.name in
-                                        let uu___7 =
-                                          FStar_Compiler_Util.string_of_int l in
-                                        let uu___8 =
-                                          FStar_Compiler_Util.string_of_int
-                                            prim_step.FStar_TypeChecker_Cfg.arity in
-                                        FStar_Compiler_Util.print3
-                                          "primop: found partially applied %s (%s/%s args)\n"
-                                          uu___6 uu___7 uu___8);
-                                   tm)
-                                else
-                                  (let uu___5 =
-                                     if
-                                       l =
-                                         prim_step.FStar_TypeChecker_Cfg.arity
-                                     then (args, [])
-                                     else
-                                       FStar_Compiler_List.splitAt
-                                         prim_step.FStar_TypeChecker_Cfg.arity
-                                         args in
-                                   match uu___5 with
-                                   | (args_1, args_2) ->
-                                       (FStar_TypeChecker_Cfg.log_primops cfg
-                                          (fun uu___7 ->
-                                             let uu___8 =
-                                               FStar_Syntax_Print.term_to_string
-                                                 tm in
-                                             FStar_Compiler_Util.print1
-                                               "primop: trying to reduce <%s>\n"
-                                               uu___8);
-                                        (let psc =
-                                           {
-                                             FStar_TypeChecker_Cfg.psc_range
-                                               =
-                                               (head.FStar_Syntax_Syntax.pos);
-                                             FStar_TypeChecker_Cfg.psc_subst
-                                               =
-                                               (fun uu___7 ->
-                                                  if
-                                                    prim_step.FStar_TypeChecker_Cfg.requires_binder_substitution
-                                                  then mk_psc_subst cfg env1
-                                                  else [])
-                                           } in
-                                         let r =
-                                           prim_step.FStar_TypeChecker_Cfg.interpretation
-                                             psc norm_cb universes args_1 in
-                                         match r with
-                                         | FStar_Pervasives_Native.None ->
-                                             (FStar_TypeChecker_Cfg.log_primops
-                                                cfg
-                                                (fun uu___8 ->
-                                                   let uu___9 =
-                                                     FStar_Syntax_Print.term_to_string
-                                                       tm in
-                                                   FStar_Compiler_Util.print1
-                                                     "primop: <%s> did not reduce\n"
-                                                     uu___9);
-                                              tm)
-                                         | FStar_Pervasives_Native.Some
-                                             reduced ->
-                                             (FStar_TypeChecker_Cfg.log_primops
-                                                cfg
-                                                (fun uu___8 ->
-                                                   let uu___9 =
-                                                     FStar_Syntax_Print.term_to_string
-                                                       tm in
-                                                   let uu___10 =
-                                                     FStar_Syntax_Print.term_to_string
-                                                       reduced in
-                                                   FStar_Compiler_Util.print2
-                                                     "primop: <%s> reduced to  %s\n"
-                                                     uu___9 uu___10);
-                                              FStar_Syntax_Util.mk_app
-                                                reduced args_2))))
-                            | FStar_Pervasives_Native.Some uu___4 ->
-                                (FStar_TypeChecker_Cfg.log_primops cfg
-                                   (fun uu___6 ->
-                                      let uu___7 =
-                                        FStar_Syntax_Print.term_to_string tm in
-                                      FStar_Compiler_Util.print1
-                                        "primop: not reducing <%s> since we're doing strong reduction\n"
-                                        uu___7);
-                                 tm)
-                            | FStar_Pervasives_Native.None -> tm)
-                       | FStar_Syntax_Syntax.Tm_constant
-                           (FStar_Const.Const_range_of) when
-                           Prims.op_Negation cfg.FStar_TypeChecker_Cfg.strong
-                           ->
-                           (FStar_TypeChecker_Cfg.log_primops cfg
-                              (fun uu___4 ->
-                                 let uu___5 =
-                                   FStar_Syntax_Print.term_to_string tm in
-                                 FStar_Compiler_Util.print1
-                                   "primop: reducing <%s>\n" uu___5);
-                            (match args with
-                             | (a1, uu___4)::[] ->
-                                 FStar_TypeChecker_Cfg.embed_simple
-                                   FStar_Syntax_Embeddings.e_range
-                                   a1.FStar_Syntax_Syntax.pos
-                                   tm.FStar_Syntax_Syntax.pos
-                             | uu___4 -> tm))
-                       | FStar_Syntax_Syntax.Tm_constant
-                           (FStar_Const.Const_set_range_of) when
-                           Prims.op_Negation cfg.FStar_TypeChecker_Cfg.strong
-                           ->
-                           (FStar_TypeChecker_Cfg.log_primops cfg
-                              (fun uu___4 ->
-                                 let uu___5 =
-                                   FStar_Syntax_Print.term_to_string tm in
-                                 FStar_Compiler_Util.print1
-                                   "primop: reducing <%s>\n" uu___5);
-                            (match args with
-                             | (t, uu___4)::(r, uu___5)::[] ->
-                                 let uu___6 =
-                                   FStar_TypeChecker_Cfg.try_unembed_simple
-                                     FStar_Syntax_Embeddings.e_range r in
-                                 (match uu___6 with
-                                  | FStar_Pervasives_Native.Some rng ->
-                                      FStar_Syntax_Subst.set_use_range rng t
-                                  | FStar_Pervasives_Native.None -> tm)
-                             | uu___4 -> tm))
-                       | uu___3 -> tm)))
-let (reduce_equality :
-  FStar_Syntax_Embeddings.norm_cb ->
-    FStar_TypeChecker_Cfg.cfg ->
-      (FStar_Syntax_Syntax.binder FStar_Pervasives_Native.option * closure)
-        Prims.list ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun norm_cb ->
-    fun cfg ->
-      fun tm ->
-        reduce_primops norm_cb
-          {
-            FStar_TypeChecker_Cfg.steps =
-              {
-                FStar_TypeChecker_Cfg.beta =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.beta);
-                FStar_TypeChecker_Cfg.iota =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.iota);
-                FStar_TypeChecker_Cfg.zeta =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.zeta);
-                FStar_TypeChecker_Cfg.zeta_full =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.zeta_full);
-                FStar_TypeChecker_Cfg.weak =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.weak);
-                FStar_TypeChecker_Cfg.hnf =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.hnf);
-                FStar_TypeChecker_Cfg.primops = true;
-                FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                FStar_TypeChecker_Cfg.unfold_until =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_until);
-                FStar_TypeChecker_Cfg.unfold_only =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_only);
-                FStar_TypeChecker_Cfg.unfold_fully =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_fully);
-                FStar_TypeChecker_Cfg.unfold_attr =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_attr);
-                FStar_TypeChecker_Cfg.unfold_qual =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_qual);
-                FStar_TypeChecker_Cfg.unfold_namespace =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_namespace);
-                FStar_TypeChecker_Cfg.unfold_tac =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unfold_tac);
-                FStar_TypeChecker_Cfg.pure_subterms_within_computations =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                FStar_TypeChecker_Cfg.simplify =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.simplify);
-                FStar_TypeChecker_Cfg.erase_universes =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.erase_universes);
-                FStar_TypeChecker_Cfg.allow_unbound_universes =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                FStar_TypeChecker_Cfg.reify_ =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.reify_);
-                FStar_TypeChecker_Cfg.compress_uvars =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.compress_uvars);
-                FStar_TypeChecker_Cfg.no_full_norm =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.no_full_norm);
-                FStar_TypeChecker_Cfg.check_no_uvars =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.check_no_uvars);
-                FStar_TypeChecker_Cfg.unmeta =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unmeta);
-                FStar_TypeChecker_Cfg.unascribe =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unascribe);
-                FStar_TypeChecker_Cfg.in_full_norm_request =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.in_full_norm_request);
-                FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                FStar_TypeChecker_Cfg.nbe_step =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.nbe_step);
-                FStar_TypeChecker_Cfg.for_extraction =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.for_extraction);
-                FStar_TypeChecker_Cfg.unrefine =
-                  (FStar_TypeChecker_Cfg.default_steps.FStar_TypeChecker_Cfg.unrefine)
-              };
-            FStar_TypeChecker_Cfg.tcenv = (cfg.FStar_TypeChecker_Cfg.tcenv);
-            FStar_TypeChecker_Cfg.debug = (cfg.FStar_TypeChecker_Cfg.debug);
-            FStar_TypeChecker_Cfg.delta_level =
-              (cfg.FStar_TypeChecker_Cfg.delta_level);
-            FStar_TypeChecker_Cfg.primitive_steps =
-              FStar_TypeChecker_Cfg.equality_ops;
-            FStar_TypeChecker_Cfg.strong = (cfg.FStar_TypeChecker_Cfg.strong);
-            FStar_TypeChecker_Cfg.memoize_lazy =
-              (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-            FStar_TypeChecker_Cfg.normalize_pure_lets =
-              (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-            FStar_TypeChecker_Cfg.reifying =
-              (cfg.FStar_TypeChecker_Cfg.reifying)
-          } tm
-type norm_request_t =
-  | Norm_request_none 
-  | Norm_request_ready 
-  | Norm_request_requires_rejig 
-let (uu___is_Norm_request_none : norm_request_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Norm_request_none -> true | uu___ -> false
-let (uu___is_Norm_request_ready : norm_request_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Norm_request_ready -> true | uu___ -> false
-let (uu___is_Norm_request_requires_rejig : norm_request_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Norm_request_requires_rejig -> true
-    | uu___ -> false
-let (is_norm_request :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.args -> norm_request_t) =
-  fun hd ->
-    fun args ->
-      let aux min_args =
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater args
-            FStar_Compiler_List.length in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (fun n ->
-             if n < min_args
-             then Norm_request_none
-             else
-               if n = min_args
-               then Norm_request_ready
-               else Norm_request_requires_rejig) in
-      let uu___ =
-        let uu___1 = FStar_Syntax_Util.un_uinst hd in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.normalize_term
-          -> aux (Prims.of_int (2))
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.normalize ->
-          aux Prims.int_one
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.norm ->
-          aux (Prims.of_int (3))
-      | uu___1 -> Norm_request_none
-let (should_consider_norm_requests : FStar_TypeChecker_Cfg.cfg -> Prims.bool)
-  =
-  fun cfg ->
-    (Prims.op_Negation
-       (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.no_full_norm)
-      &&
-      (let uu___ =
-         FStar_Ident.lid_equals
-           (cfg.FStar_TypeChecker_Cfg.tcenv).FStar_TypeChecker_Env.curmodule
-           FStar_Parser_Const.prims_lid in
-       Prims.op_Negation uu___)
-let (rejig_norm_request :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.args -> FStar_Syntax_Syntax.term)
-  =
-  fun hd ->
-    fun args ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Util.un_uinst hd in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.normalize_term
-          ->
-          (match args with
-           | t1::t2::rest when
-               (FStar_Compiler_List.length rest) > Prims.int_zero ->
-               let uu___1 = FStar_Syntax_Util.mk_app hd [t1; t2] in
-               FStar_Syntax_Util.mk_app uu___1 rest
-           | uu___1 ->
-               failwith
-                 "Impossible! invalid rejig_norm_request for normalize_term")
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.normalize ->
-          (match args with
-           | t::rest when (FStar_Compiler_List.length rest) > Prims.int_zero
-               ->
-               let uu___1 = FStar_Syntax_Util.mk_app hd [t] in
-               FStar_Syntax_Util.mk_app uu___1 rest
-           | uu___1 ->
-               failwith
-                 "Impossible! invalid rejig_norm_request for normalize")
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.norm ->
-          (match args with
-           | t1::t2::t3::rest when
-               (FStar_Compiler_List.length rest) > Prims.int_zero ->
-               let uu___1 = FStar_Syntax_Util.mk_app hd [t1; t2; t3] in
-               FStar_Syntax_Util.mk_app uu___1 rest
-           | uu___1 ->
-               failwith "Impossible! invalid rejig_norm_request for norm")
-      | uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string hd in
-            FStar_String.op_Hat
-              "Impossible! invalid rejig_norm_request for: %s" uu___3 in
-          failwith uu___2
-let (is_nbe_request : FStar_TypeChecker_Env.step Prims.list -> Prims.bool) =
-  fun s ->
-    FStar_Compiler_Util.for_some
-      (FStar_TypeChecker_Env.eq_step FStar_TypeChecker_Env.NBE) s
-let get_norm_request :
-  'uuuuu .
-    FStar_TypeChecker_Cfg.cfg ->
-      (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) ->
-        (FStar_Syntax_Syntax.term * 'uuuuu) Prims.list ->
-          (FStar_TypeChecker_Env.step Prims.list * FStar_Syntax_Syntax.term)
-            FStar_Pervasives_Native.option
-  =
-  fun cfg ->
-    fun full_norm ->
-      fun args ->
-        let parse_steps s =
-          let uu___ =
-            let uu___1 =
-              FStar_Syntax_Embeddings.e_list
-                FStar_Syntax_Embeddings.e_norm_step in
-            FStar_TypeChecker_Cfg.try_unembed_simple uu___1 s in
-          match uu___ with
-          | FStar_Pervasives_Native.Some steps ->
-              let uu___1 = FStar_TypeChecker_Cfg.translate_norm_steps steps in
-              FStar_Pervasives_Native.Some uu___1
-          | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None in
-        let inherited_steps =
-          FStar_Compiler_List.op_At
-            (if
-               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.erase_universes
-             then [FStar_TypeChecker_Env.EraseUniverses]
-             else [])
-            (FStar_Compiler_List.op_At
-               (if
-                  (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.allow_unbound_universes
-                then [FStar_TypeChecker_Env.AllowUnboundUniverses]
-                else [])
-               (if
-                  (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.nbe_step
-                then [FStar_TypeChecker_Env.NBE]
-                else [])) in
-        match args with
-        | uu___::(tm, uu___1)::[] ->
-            let s =
-              [FStar_TypeChecker_Env.Beta;
-              FStar_TypeChecker_Env.Zeta;
-              FStar_TypeChecker_Env.Iota;
-              FStar_TypeChecker_Env.Primops;
-              FStar_TypeChecker_Env.UnfoldUntil
-                FStar_Syntax_Syntax.delta_constant;
-              FStar_TypeChecker_Env.Reify] in
-            FStar_Pervasives_Native.Some
-              ((FStar_Compiler_List.op_At inherited_steps s), tm)
-        | (tm, uu___)::[] ->
-            let s =
-              [FStar_TypeChecker_Env.Beta;
-              FStar_TypeChecker_Env.Zeta;
-              FStar_TypeChecker_Env.Iota;
-              FStar_TypeChecker_Env.Primops;
-              FStar_TypeChecker_Env.UnfoldUntil
-                FStar_Syntax_Syntax.delta_constant;
-              FStar_TypeChecker_Env.Reify] in
-            FStar_Pervasives_Native.Some
-              ((FStar_Compiler_List.op_At inherited_steps s), tm)
-        | (steps, uu___)::uu___1::(tm, uu___2)::[] ->
-            let uu___3 = let uu___4 = full_norm steps in parse_steps uu___4 in
-            (match uu___3 with
-             | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-             | FStar_Pervasives_Native.Some s ->
-                 FStar_Pervasives_Native.Some
-                   ((FStar_Compiler_List.op_At inherited_steps s), tm))
-        | uu___ -> FStar_Pervasives_Native.None
-let (nbe_eval :
-  FStar_TypeChecker_Cfg.cfg ->
-    FStar_TypeChecker_Env.steps ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun s ->
-      fun tm ->
-        let delta_level =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater s
-              (FStar_Compiler_Util.for_some
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | FStar_TypeChecker_Env.UnfoldUntil uu___2 -> true
-                    | FStar_TypeChecker_Env.UnfoldOnly uu___2 -> true
-                    | FStar_TypeChecker_Env.UnfoldFully uu___2 -> true
-                    | uu___2 -> false)) in
-          if uu___
-          then
-            [FStar_TypeChecker_Env.Unfold FStar_Syntax_Syntax.delta_constant]
-          else [FStar_TypeChecker_Env.NoDelta] in
-        FStar_TypeChecker_Cfg.log_nbe cfg
-          (fun uu___1 ->
-             let uu___2 = FStar_Syntax_Print.term_to_string tm in
-             FStar_Compiler_Util.print1 "Invoking NBE with  %s\n" uu___2);
-        (let tm_norm =
-           let uu___1 = FStar_TypeChecker_Cfg.cfg_env cfg in
-           uu___1.FStar_TypeChecker_Env.nbe s cfg.FStar_TypeChecker_Cfg.tcenv
-             tm in
-         FStar_TypeChecker_Cfg.log_nbe cfg
-           (fun uu___2 ->
-              let uu___3 = FStar_Syntax_Print.term_to_string tm_norm in
-              FStar_Compiler_Util.print1 "Result of NBE is  %s\n" uu___3);
-         tm_norm)
-let firstn :
-  'uuuuu .
-    Prims.int -> 'uuuuu Prims.list -> ('uuuuu Prims.list * 'uuuuu Prims.list)
-  =
-  fun k ->
-    fun l ->
-      if (FStar_Compiler_List.length l) < k
-      then (l, [])
-      else FStar_Compiler_Util.first_N k l
-let (should_reify :
-  FStar_TypeChecker_Cfg.cfg -> stack_elt Prims.list -> Prims.bool) =
-  fun cfg ->
-    fun stack1 ->
-      let rec drop_irrel uu___ =
-        match uu___ with
-        | (MemoLazy uu___1)::s -> drop_irrel s
-        | (UnivArgs uu___1)::s -> drop_irrel s
-        | s -> s in
-      let uu___ = drop_irrel stack1 in
-      match uu___ with
-      | (App
-          (uu___1,
-           {
-             FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-               (FStar_Const.Const_reify);
-             FStar_Syntax_Syntax.pos = uu___2;
-             FStar_Syntax_Syntax.vars = uu___3;
-             FStar_Syntax_Syntax.hash_code = uu___4;_},
-           uu___5, uu___6))::uu___7
-          -> (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.reify_
-      | uu___1 -> false
-let rec (maybe_weakly_reduced :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax -> Prims.bool) =
-  fun tm ->
-    let aux_comp c =
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.GTotal t -> maybe_weakly_reduced t
-      | FStar_Syntax_Syntax.Total t -> maybe_weakly_reduced t
-      | FStar_Syntax_Syntax.Comp ct ->
-          (maybe_weakly_reduced ct.FStar_Syntax_Syntax.result_typ) ||
-            (FStar_Compiler_Util.for_some
-               (fun uu___ ->
-                  match uu___ with | (a, uu___1) -> maybe_weakly_reduced a)
-               ct.FStar_Syntax_Syntax.effect_args) in
-    let t = FStar_Syntax_Subst.compress tm in
-    match t.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Tm_delayed uu___ -> failwith "Impossible"
-    | FStar_Syntax_Syntax.Tm_name uu___ -> false
-    | FStar_Syntax_Syntax.Tm_uvar uu___ -> false
-    | FStar_Syntax_Syntax.Tm_type uu___ -> false
-    | FStar_Syntax_Syntax.Tm_bvar uu___ -> false
-    | FStar_Syntax_Syntax.Tm_fvar uu___ -> false
-    | FStar_Syntax_Syntax.Tm_constant uu___ -> false
-    | FStar_Syntax_Syntax.Tm_lazy uu___ -> false
-    | FStar_Syntax_Syntax.Tm_unknown -> false
-    | FStar_Syntax_Syntax.Tm_uinst uu___ -> false
-    | FStar_Syntax_Syntax.Tm_quoted uu___ -> false
-    | FStar_Syntax_Syntax.Tm_let uu___ -> true
-    | FStar_Syntax_Syntax.Tm_abs uu___ -> true
-    | FStar_Syntax_Syntax.Tm_arrow uu___ -> true
-    | FStar_Syntax_Syntax.Tm_refine uu___ -> true
-    | FStar_Syntax_Syntax.Tm_match uu___ -> true
-    | FStar_Syntax_Syntax.Tm_app (t1, args) ->
-        (maybe_weakly_reduced t1) ||
-          (FStar_Compiler_Effect.op_Bar_Greater args
-             (FStar_Compiler_Util.for_some
-                (fun uu___ ->
-                   match uu___ with | (a, uu___1) -> maybe_weakly_reduced a)))
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, asc, uu___) ->
-        (maybe_weakly_reduced t1) ||
-          (let uu___1 = asc in
-           (match uu___1 with
-            | (asc_tc, asc_tac, uu___2) ->
-                (match asc_tc with
-                 | FStar_Pervasives.Inl t2 -> maybe_weakly_reduced t2
-                 | FStar_Pervasives.Inr c2 -> aux_comp c2) ||
-                  ((match asc_tac with
-                    | FStar_Pervasives_Native.None -> false
-                    | FStar_Pervasives_Native.Some tac ->
-                        maybe_weakly_reduced tac))))
-    | FStar_Syntax_Syntax.Tm_meta (t1, m) ->
-        (maybe_weakly_reduced t1) ||
-          ((match m with
-            | FStar_Syntax_Syntax.Meta_pattern (uu___, args) ->
-                FStar_Compiler_Util.for_some
-                  (FStar_Compiler_Util.for_some
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | (a, uu___2) -> maybe_weakly_reduced a)) args
-            | FStar_Syntax_Syntax.Meta_monadic_lift (uu___, uu___1, t') ->
-                maybe_weakly_reduced t'
-            | FStar_Syntax_Syntax.Meta_monadic (uu___, t') ->
-                maybe_weakly_reduced t'
-            | FStar_Syntax_Syntax.Meta_labeled uu___ -> false
-            | FStar_Syntax_Syntax.Meta_desugared uu___ -> false
-            | FStar_Syntax_Syntax.Meta_named uu___ -> false))
-let (plugin_unfold_warn_ctr : Prims.int FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref Prims.int_zero
-let (should_unfold :
-  FStar_TypeChecker_Cfg.cfg ->
-    (FStar_TypeChecker_Cfg.cfg -> Prims.bool) ->
-      FStar_Syntax_Syntax.fv ->
-        FStar_TypeChecker_Env.qninfo -> should_unfold_res)
-  =
-  fun cfg ->
-    fun should_reify1 ->
-      fun fv ->
-        fun qninfo ->
-          let attrs =
-            let uu___ = FStar_TypeChecker_Env.attrs_of_qninfo qninfo in
-            match uu___ with
-            | FStar_Pervasives_Native.None -> []
-            | FStar_Pervasives_Native.Some ats -> ats in
-          let quals =
-            let uu___ = FStar_TypeChecker_Env.quals_of_qninfo qninfo in
-            match uu___ with
-            | FStar_Pervasives_Native.None -> []
-            | FStar_Pervasives_Native.Some quals1 -> quals1 in
-          let yes = (true, false, false) in
-          let no = (false, false, false) in
-          let fully = (true, true, false) in
-          let reif = (true, false, true) in
-          let yesno b = if b then yes else no in
-          let fullyno b = if b then fully else no in
-          let comb_or l =
-            FStar_Compiler_List.fold_right
-              (fun uu___ ->
-                 fun uu___1 ->
-                   match (uu___, uu___1) with
-                   | ((a, b, c), (x, y, z)) -> ((a || x), (b || y), (c || z)))
-              l (false, false, false) in
-          let string_of_res uu___ =
-            match uu___ with
-            | (x, y, z) ->
-                let uu___1 = FStar_Compiler_Util.string_of_bool x in
-                let uu___2 = FStar_Compiler_Util.string_of_bool y in
-                let uu___3 = FStar_Compiler_Util.string_of_bool z in
-                FStar_Compiler_Util.format3 "(%s,%s,%s)" uu___1 uu___2 uu___3 in
-          let default_unfolding uu___ =
-            FStar_TypeChecker_Cfg.log_unfolding cfg
-              (fun uu___2 ->
-                 let uu___3 = FStar_Syntax_Print.fv_to_string fv in
-                 let uu___4 =
-                   FStar_Syntax_Print.delta_depth_to_string
-                     fv.FStar_Syntax_Syntax.fv_delta in
-                 let uu___5 =
-                   (FStar_Common.string_of_list ())
-                     FStar_TypeChecker_Env.string_of_delta_level
-                     cfg.FStar_TypeChecker_Cfg.delta_level in
-                 FStar_Compiler_Util.print3
-                   "should_unfold: Reached a %s with delta_depth = %s\n >> Our delta_level is %s\n"
-                   uu___3 uu___4 uu___5);
-            (let uu___2 =
-               FStar_Compiler_Effect.op_Bar_Greater
-                 cfg.FStar_TypeChecker_Cfg.delta_level
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | FStar_TypeChecker_Env.NoDelta -> false
-                       | FStar_TypeChecker_Env.InliningDelta -> true
-                       | FStar_TypeChecker_Env.Eager_unfolding_only -> true
-                       | FStar_TypeChecker_Env.Unfold l ->
-                           let uu___4 =
-                             FStar_TypeChecker_Env.delta_depth_of_fv
-                               cfg.FStar_TypeChecker_Cfg.tcenv fv in
-                           FStar_TypeChecker_Common.delta_depth_greater_than
-                             uu___4 l)) in
-             FStar_Compiler_Effect.op_Less_Bar yesno uu___2) in
-          let res =
-            if FStar_TypeChecker_Env.qninfo_is_action qninfo
-            then
-              let b = should_reify1 cfg in
-              (FStar_TypeChecker_Cfg.log_unfolding cfg
-                 (fun uu___1 ->
-                    let uu___2 = FStar_Syntax_Print.fv_to_string fv in
-                    let uu___3 = FStar_Compiler_Util.string_of_bool b in
-                    FStar_Compiler_Util.print2
-                      "should_unfold: For DM4F action %s, should_reify = %s\n"
-                      uu___2 uu___3);
-               if b then reif else no)
-            else
-              if
-                (let uu___ = FStar_TypeChecker_Cfg.find_prim_step cfg fv in
-                 FStar_Compiler_Option.isSome uu___)
-              then
-                (FStar_TypeChecker_Cfg.log_unfolding cfg
-                   (fun uu___1 ->
-                      FStar_Compiler_Util.print_string
-                        " >> It's a primop, not unfolding\n");
-                 no)
-              else
-                (match (qninfo,
-                         ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_only),
-                         ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_fully),
-                         ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_attr),
-                         ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_qual),
-                         ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_namespace))
-                 with
-                 | (FStar_Pervasives_Native.Some
-                    (FStar_Pervasives.Inr
-                     ({
-                        FStar_Syntax_Syntax.sigel =
-                          FStar_Syntax_Syntax.Sig_let
-                          ((is_rec, uu___), uu___1);
-                        FStar_Syntax_Syntax.sigrng = uu___2;
-                        FStar_Syntax_Syntax.sigquals = qs;
-                        FStar_Syntax_Syntax.sigmeta = uu___3;
-                        FStar_Syntax_Syntax.sigattrs = uu___4;
-                        FStar_Syntax_Syntax.sigopts = uu___5;_},
-                      uu___6),
-                     uu___7),
-                    uu___8, uu___9, uu___10, uu___11, uu___12) when
-                     FStar_Compiler_List.contains
-                       FStar_Syntax_Syntax.HasMaskedEffect qs
-                     ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___14 ->
-                           FStar_Compiler_Util.print_string
-                             " >> HasMaskedEffect, not unfolding\n");
-                      no)
-                 | (uu___, uu___1, uu___2, uu___3, uu___4, uu___5) when
-                     (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_tac
-                       &&
-                       (FStar_Compiler_Util.for_some
-                          (FStar_Syntax_Util.attr_eq
-                             FStar_Syntax_Util.tac_opaque_attr) attrs)
-                     ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___7 ->
-                           FStar_Compiler_Util.print_string
-                             " >> tac_opaque, not unfolding\n");
-                      no)
-                 | (FStar_Pervasives_Native.Some
-                    (FStar_Pervasives.Inr
-                     ({
-                        FStar_Syntax_Syntax.sigel =
-                          FStar_Syntax_Syntax.Sig_let
-                          ((is_rec, uu___), uu___1);
-                        FStar_Syntax_Syntax.sigrng = uu___2;
-                        FStar_Syntax_Syntax.sigquals = qs;
-                        FStar_Syntax_Syntax.sigmeta = uu___3;
-                        FStar_Syntax_Syntax.sigattrs = uu___4;
-                        FStar_Syntax_Syntax.sigopts = uu___5;_},
-                      uu___6),
-                     uu___7),
-                    uu___8, uu___9, uu___10, uu___11, uu___12) when
-                     (is_rec &&
-                        (Prims.op_Negation
-                           (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta))
-                       &&
-                       (Prims.op_Negation
-                          (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta_full)
-                     ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___14 ->
-                           FStar_Compiler_Util.print_string
-                             " >> It's a recursive definition but we're not doing Zeta, not unfolding\n");
-                      no)
-                 | (uu___, FStar_Pervasives_Native.Some uu___1, uu___2,
-                    uu___3, uu___4, uu___5) ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fv in
-                           FStar_Compiler_Util.print1
-                             "should_unfold: Reached a %s with selective unfolding\n"
-                             uu___8);
-                      (let meets_some_criterion =
-                         let uu___7 =
-                           let uu___8 =
-                             if
-                               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                             then
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_TypeChecker_Env.lookup_definition_qninfo
-                                     [FStar_TypeChecker_Env.Eager_unfolding_only;
-                                     FStar_TypeChecker_Env.InliningDelta]
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                     qninfo in
-                                 FStar_Compiler_Option.isSome uu___10 in
-                               FStar_Compiler_Effect.op_Less_Bar yesno uu___9
-                             else no in
-                           let uu___9 =
-                             let uu___10 =
-                               match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_only
-                               with
-                               | FStar_Pervasives_Native.None -> no
-                               | FStar_Pervasives_Native.Some lids ->
-                                   let uu___11 =
-                                     FStar_Compiler_Util.for_some
-                                       (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                       lids in
-                                   FStar_Compiler_Effect.op_Less_Bar yesno
-                                     uu___11 in
-                             let uu___11 =
-                               let uu___12 =
-                                 match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_attr
-                                 with
-                                 | FStar_Pervasives_Native.None -> no
-                                 | FStar_Pervasives_Native.Some lids ->
-                                     let uu___13 =
-                                       FStar_Compiler_Util.for_some
-                                         (fun at ->
-                                            FStar_Compiler_Util.for_some
-                                              (fun lid ->
-                                                 FStar_Syntax_Util.is_fvar
-                                                   lid at) lids) attrs in
-                                     FStar_Compiler_Effect.op_Less_Bar yesno
-                                       uu___13 in
-                               let uu___13 =
-                                 let uu___14 =
-                                   match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_fully
-                                   with
-                                   | FStar_Pervasives_Native.None -> no
-                                   | FStar_Pervasives_Native.Some lids ->
-                                       let uu___15 =
-                                         FStar_Compiler_Util.for_some
-                                           (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                           lids in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         fullyno uu___15 in
-                                 let uu___15 =
-                                   let uu___16 =
-                                     match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_qual
-                                     with
-                                     | FStar_Pervasives_Native.None -> no
-                                     | FStar_Pervasives_Native.Some qs ->
-                                         let uu___17 =
-                                           FStar_Compiler_Util.for_some
-                                             (fun q ->
-                                                FStar_Compiler_Util.for_some
-                                                  (fun qual ->
-                                                     let uu___18 =
-                                                       FStar_Syntax_Print.qual_to_string
-                                                         qual in
-                                                     uu___18 = q) quals) qs in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           yesno uu___17 in
-                                   let uu___17 =
-                                     let uu___18 =
-                                       match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_namespace
-                                       with
-                                       | FStar_Pervasives_Native.None -> no
-                                       | FStar_Pervasives_Native.Some
-                                           namespaces ->
-                                           let uu___19 =
-                                             FStar_Compiler_Util.for_some
-                                               (fun ns ->
-                                                  let uu___20 =
-                                                    let uu___21 =
-                                                      FStar_Syntax_Syntax.lid_of_fv
-                                                        fv in
-                                                    FStar_Ident.nsstr uu___21 in
-                                                  FStar_Compiler_Util.starts_with
-                                                    uu___20 ns) namespaces in
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             yesno uu___19 in
-                                     [uu___18] in
-                                   uu___16 :: uu___17 in
-                                 uu___14 :: uu___15 in
-                               uu___12 :: uu___13 in
-                             uu___10 :: uu___11 in
-                           uu___8 :: uu___9 in
-                         comb_or uu___7 in
-                       meets_some_criterion))
-                 | (uu___, uu___1, FStar_Pervasives_Native.Some uu___2,
-                    uu___3, uu___4, uu___5) ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fv in
-                           FStar_Compiler_Util.print1
-                             "should_unfold: Reached a %s with selective unfolding\n"
-                             uu___8);
-                      (let meets_some_criterion =
-                         let uu___7 =
-                           let uu___8 =
-                             if
-                               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                             then
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_TypeChecker_Env.lookup_definition_qninfo
-                                     [FStar_TypeChecker_Env.Eager_unfolding_only;
-                                     FStar_TypeChecker_Env.InliningDelta]
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                     qninfo in
-                                 FStar_Compiler_Option.isSome uu___10 in
-                               FStar_Compiler_Effect.op_Less_Bar yesno uu___9
-                             else no in
-                           let uu___9 =
-                             let uu___10 =
-                               match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_only
-                               with
-                               | FStar_Pervasives_Native.None -> no
-                               | FStar_Pervasives_Native.Some lids ->
-                                   let uu___11 =
-                                     FStar_Compiler_Util.for_some
-                                       (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                       lids in
-                                   FStar_Compiler_Effect.op_Less_Bar yesno
-                                     uu___11 in
-                             let uu___11 =
-                               let uu___12 =
-                                 match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_attr
-                                 with
-                                 | FStar_Pervasives_Native.None -> no
-                                 | FStar_Pervasives_Native.Some lids ->
-                                     let uu___13 =
-                                       FStar_Compiler_Util.for_some
-                                         (fun at ->
-                                            FStar_Compiler_Util.for_some
-                                              (fun lid ->
-                                                 FStar_Syntax_Util.is_fvar
-                                                   lid at) lids) attrs in
-                                     FStar_Compiler_Effect.op_Less_Bar yesno
-                                       uu___13 in
-                               let uu___13 =
-                                 let uu___14 =
-                                   match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_fully
-                                   with
-                                   | FStar_Pervasives_Native.None -> no
-                                   | FStar_Pervasives_Native.Some lids ->
-                                       let uu___15 =
-                                         FStar_Compiler_Util.for_some
-                                           (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                           lids in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         fullyno uu___15 in
-                                 let uu___15 =
-                                   let uu___16 =
-                                     match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_qual
-                                     with
-                                     | FStar_Pervasives_Native.None -> no
-                                     | FStar_Pervasives_Native.Some qs ->
-                                         let uu___17 =
-                                           FStar_Compiler_Util.for_some
-                                             (fun q ->
-                                                FStar_Compiler_Util.for_some
-                                                  (fun qual ->
-                                                     let uu___18 =
-                                                       FStar_Syntax_Print.qual_to_string
-                                                         qual in
-                                                     uu___18 = q) quals) qs in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           yesno uu___17 in
-                                   let uu___17 =
-                                     let uu___18 =
-                                       match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_namespace
-                                       with
-                                       | FStar_Pervasives_Native.None -> no
-                                       | FStar_Pervasives_Native.Some
-                                           namespaces ->
-                                           let uu___19 =
-                                             FStar_Compiler_Util.for_some
-                                               (fun ns ->
-                                                  let uu___20 =
-                                                    let uu___21 =
-                                                      FStar_Syntax_Syntax.lid_of_fv
-                                                        fv in
-                                                    FStar_Ident.nsstr uu___21 in
-                                                  FStar_Compiler_Util.starts_with
-                                                    uu___20 ns) namespaces in
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             yesno uu___19 in
-                                     [uu___18] in
-                                   uu___16 :: uu___17 in
-                                 uu___14 :: uu___15 in
-                               uu___12 :: uu___13 in
-                             uu___10 :: uu___11 in
-                           uu___8 :: uu___9 in
-                         comb_or uu___7 in
-                       meets_some_criterion))
-                 | (uu___, uu___1, uu___2, FStar_Pervasives_Native.Some
-                    uu___3, uu___4, uu___5) ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fv in
-                           FStar_Compiler_Util.print1
-                             "should_unfold: Reached a %s with selective unfolding\n"
-                             uu___8);
-                      (let meets_some_criterion =
-                         let uu___7 =
-                           let uu___8 =
-                             if
-                               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                             then
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_TypeChecker_Env.lookup_definition_qninfo
-                                     [FStar_TypeChecker_Env.Eager_unfolding_only;
-                                     FStar_TypeChecker_Env.InliningDelta]
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                     qninfo in
-                                 FStar_Compiler_Option.isSome uu___10 in
-                               FStar_Compiler_Effect.op_Less_Bar yesno uu___9
-                             else no in
-                           let uu___9 =
-                             let uu___10 =
-                               match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_only
-                               with
-                               | FStar_Pervasives_Native.None -> no
-                               | FStar_Pervasives_Native.Some lids ->
-                                   let uu___11 =
-                                     FStar_Compiler_Util.for_some
-                                       (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                       lids in
-                                   FStar_Compiler_Effect.op_Less_Bar yesno
-                                     uu___11 in
-                             let uu___11 =
-                               let uu___12 =
-                                 match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_attr
-                                 with
-                                 | FStar_Pervasives_Native.None -> no
-                                 | FStar_Pervasives_Native.Some lids ->
-                                     let uu___13 =
-                                       FStar_Compiler_Util.for_some
-                                         (fun at ->
-                                            FStar_Compiler_Util.for_some
-                                              (fun lid ->
-                                                 FStar_Syntax_Util.is_fvar
-                                                   lid at) lids) attrs in
-                                     FStar_Compiler_Effect.op_Less_Bar yesno
-                                       uu___13 in
-                               let uu___13 =
-                                 let uu___14 =
-                                   match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_fully
-                                   with
-                                   | FStar_Pervasives_Native.None -> no
-                                   | FStar_Pervasives_Native.Some lids ->
-                                       let uu___15 =
-                                         FStar_Compiler_Util.for_some
-                                           (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                           lids in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         fullyno uu___15 in
-                                 let uu___15 =
-                                   let uu___16 =
-                                     match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_qual
-                                     with
-                                     | FStar_Pervasives_Native.None -> no
-                                     | FStar_Pervasives_Native.Some qs ->
-                                         let uu___17 =
-                                           FStar_Compiler_Util.for_some
-                                             (fun q ->
-                                                FStar_Compiler_Util.for_some
-                                                  (fun qual ->
-                                                     let uu___18 =
-                                                       FStar_Syntax_Print.qual_to_string
-                                                         qual in
-                                                     uu___18 = q) quals) qs in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           yesno uu___17 in
-                                   let uu___17 =
-                                     let uu___18 =
-                                       match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_namespace
-                                       with
-                                       | FStar_Pervasives_Native.None -> no
-                                       | FStar_Pervasives_Native.Some
-                                           namespaces ->
-                                           let uu___19 =
-                                             FStar_Compiler_Util.for_some
-                                               (fun ns ->
-                                                  let uu___20 =
-                                                    let uu___21 =
-                                                      FStar_Syntax_Syntax.lid_of_fv
-                                                        fv in
-                                                    FStar_Ident.nsstr uu___21 in
-                                                  FStar_Compiler_Util.starts_with
-                                                    uu___20 ns) namespaces in
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             yesno uu___19 in
-                                     [uu___18] in
-                                   uu___16 :: uu___17 in
-                                 uu___14 :: uu___15 in
-                               uu___12 :: uu___13 in
-                             uu___10 :: uu___11 in
-                           uu___8 :: uu___9 in
-                         comb_or uu___7 in
-                       meets_some_criterion))
-                 | (uu___, uu___1, uu___2, uu___3,
-                    FStar_Pervasives_Native.Some uu___4, uu___5) ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fv in
-                           FStar_Compiler_Util.print1
-                             "should_unfold: Reached a %s with selective unfolding\n"
-                             uu___8);
-                      (let meets_some_criterion =
-                         let uu___7 =
-                           let uu___8 =
-                             if
-                               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                             then
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_TypeChecker_Env.lookup_definition_qninfo
-                                     [FStar_TypeChecker_Env.Eager_unfolding_only;
-                                     FStar_TypeChecker_Env.InliningDelta]
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                     qninfo in
-                                 FStar_Compiler_Option.isSome uu___10 in
-                               FStar_Compiler_Effect.op_Less_Bar yesno uu___9
-                             else no in
-                           let uu___9 =
-                             let uu___10 =
-                               match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_only
-                               with
-                               | FStar_Pervasives_Native.None -> no
-                               | FStar_Pervasives_Native.Some lids ->
-                                   let uu___11 =
-                                     FStar_Compiler_Util.for_some
-                                       (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                       lids in
-                                   FStar_Compiler_Effect.op_Less_Bar yesno
-                                     uu___11 in
-                             let uu___11 =
-                               let uu___12 =
-                                 match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_attr
-                                 with
-                                 | FStar_Pervasives_Native.None -> no
-                                 | FStar_Pervasives_Native.Some lids ->
-                                     let uu___13 =
-                                       FStar_Compiler_Util.for_some
-                                         (fun at ->
-                                            FStar_Compiler_Util.for_some
-                                              (fun lid ->
-                                                 FStar_Syntax_Util.is_fvar
-                                                   lid at) lids) attrs in
-                                     FStar_Compiler_Effect.op_Less_Bar yesno
-                                       uu___13 in
-                               let uu___13 =
-                                 let uu___14 =
-                                   match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_fully
-                                   with
-                                   | FStar_Pervasives_Native.None -> no
-                                   | FStar_Pervasives_Native.Some lids ->
-                                       let uu___15 =
-                                         FStar_Compiler_Util.for_some
-                                           (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                           lids in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         fullyno uu___15 in
-                                 let uu___15 =
-                                   let uu___16 =
-                                     match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_qual
-                                     with
-                                     | FStar_Pervasives_Native.None -> no
-                                     | FStar_Pervasives_Native.Some qs ->
-                                         let uu___17 =
-                                           FStar_Compiler_Util.for_some
-                                             (fun q ->
-                                                FStar_Compiler_Util.for_some
-                                                  (fun qual ->
-                                                     let uu___18 =
-                                                       FStar_Syntax_Print.qual_to_string
-                                                         qual in
-                                                     uu___18 = q) quals) qs in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           yesno uu___17 in
-                                   let uu___17 =
-                                     let uu___18 =
-                                       match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_namespace
-                                       with
-                                       | FStar_Pervasives_Native.None -> no
-                                       | FStar_Pervasives_Native.Some
-                                           namespaces ->
-                                           let uu___19 =
-                                             FStar_Compiler_Util.for_some
-                                               (fun ns ->
-                                                  let uu___20 =
-                                                    let uu___21 =
-                                                      FStar_Syntax_Syntax.lid_of_fv
-                                                        fv in
-                                                    FStar_Ident.nsstr uu___21 in
-                                                  FStar_Compiler_Util.starts_with
-                                                    uu___20 ns) namespaces in
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             yesno uu___19 in
-                                     [uu___18] in
-                                   uu___16 :: uu___17 in
-                                 uu___14 :: uu___15 in
-                               uu___12 :: uu___13 in
-                             uu___10 :: uu___11 in
-                           uu___8 :: uu___9 in
-                         comb_or uu___7 in
-                       meets_some_criterion))
-                 | (uu___, uu___1, uu___2, uu___3, uu___4,
-                    FStar_Pervasives_Native.Some uu___5) ->
-                     (FStar_TypeChecker_Cfg.log_unfolding cfg
-                        (fun uu___7 ->
-                           let uu___8 = FStar_Syntax_Print.fv_to_string fv in
-                           FStar_Compiler_Util.print1
-                             "should_unfold: Reached a %s with selective unfolding\n"
-                             uu___8);
-                      (let meets_some_criterion =
-                         let uu___7 =
-                           let uu___8 =
-                             if
-                               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                             then
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_TypeChecker_Env.lookup_definition_qninfo
-                                     [FStar_TypeChecker_Env.Eager_unfolding_only;
-                                     FStar_TypeChecker_Env.InliningDelta]
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                     qninfo in
-                                 FStar_Compiler_Option.isSome uu___10 in
-                               FStar_Compiler_Effect.op_Less_Bar yesno uu___9
-                             else no in
-                           let uu___9 =
-                             let uu___10 =
-                               match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_only
-                               with
-                               | FStar_Pervasives_Native.None -> no
-                               | FStar_Pervasives_Native.Some lids ->
-                                   let uu___11 =
-                                     FStar_Compiler_Util.for_some
-                                       (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                       lids in
-                                   FStar_Compiler_Effect.op_Less_Bar yesno
-                                     uu___11 in
-                             let uu___11 =
-                               let uu___12 =
-                                 match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_attr
-                                 with
-                                 | FStar_Pervasives_Native.None -> no
-                                 | FStar_Pervasives_Native.Some lids ->
-                                     let uu___13 =
-                                       FStar_Compiler_Util.for_some
-                                         (fun at ->
-                                            FStar_Compiler_Util.for_some
-                                              (fun lid ->
-                                                 FStar_Syntax_Util.is_fvar
-                                                   lid at) lids) attrs in
-                                     FStar_Compiler_Effect.op_Less_Bar yesno
-                                       uu___13 in
-                               let uu___13 =
-                                 let uu___14 =
-                                   match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_fully
-                                   with
-                                   | FStar_Pervasives_Native.None -> no
-                                   | FStar_Pervasives_Native.Some lids ->
-                                       let uu___15 =
-                                         FStar_Compiler_Util.for_some
-                                           (FStar_Syntax_Syntax.fv_eq_lid fv)
-                                           lids in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         fullyno uu___15 in
-                                 let uu___15 =
-                                   let uu___16 =
-                                     match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_qual
-                                     with
-                                     | FStar_Pervasives_Native.None -> no
-                                     | FStar_Pervasives_Native.Some qs ->
-                                         let uu___17 =
-                                           FStar_Compiler_Util.for_some
-                                             (fun q ->
-                                                FStar_Compiler_Util.for_some
-                                                  (fun qual ->
-                                                     let uu___18 =
-                                                       FStar_Syntax_Print.qual_to_string
-                                                         qual in
-                                                     uu___18 = q) quals) qs in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           yesno uu___17 in
-                                   let uu___17 =
-                                     let uu___18 =
-                                       match (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_namespace
-                                       with
-                                       | FStar_Pervasives_Native.None -> no
-                                       | FStar_Pervasives_Native.Some
-                                           namespaces ->
-                                           let uu___19 =
-                                             FStar_Compiler_Util.for_some
-                                               (fun ns ->
-                                                  let uu___20 =
-                                                    let uu___21 =
-                                                      FStar_Syntax_Syntax.lid_of_fv
-                                                        fv in
-                                                    FStar_Ident.nsstr uu___21 in
-                                                  FStar_Compiler_Util.starts_with
-                                                    uu___20 ns) namespaces in
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             yesno uu___19 in
-                                     [uu___18] in
-                                   uu___16 :: uu___17 in
-                                 uu___14 :: uu___15 in
-                               uu___12 :: uu___13 in
-                             uu___10 :: uu___11 in
-                           uu___8 :: uu___9 in
-                         comb_or uu___7 in
-                       meets_some_criterion))
-                 | uu___ -> default_unfolding ()) in
-          FStar_TypeChecker_Cfg.log_unfolding cfg
-            (fun uu___1 ->
-               let uu___2 = FStar_Syntax_Print.fv_to_string fv in
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Syntax.range_of_fv fv in
-                 FStar_Compiler_Range.string_of_range uu___4 in
-               let uu___4 = string_of_res res in
-               FStar_Compiler_Util.print3
-                 "should_unfold: For %s (%s), unfolding res = %s\n" uu___2
-                 uu___3 uu___4);
-          (let r =
-             match res with
-             | (false, uu___1, uu___2) -> Should_unfold_no
-             | (true, false, false) -> Should_unfold_yes
-             | (true, true, false) -> Should_unfold_fully
-             | (true, false, true) -> Should_unfold_reify
-             | uu___1 ->
-                 let uu___2 =
-                   let uu___3 = string_of_res res in
-                   FStar_Compiler_Util.format1
-                     "Unexpected unfolding result: %s" uu___3 in
-                 FStar_Compiler_Effect.op_Less_Bar failwith uu___2 in
-           (let uu___2 =
-              (((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_tac
-                  && (r <> Should_unfold_no))
-                 &&
-                 (FStar_Compiler_Util.for_some
-                    (FStar_Syntax_Util.is_fvar FStar_Parser_Const.plugin_attr)
-                    attrs))
-                &&
-                (let uu___3 =
-                   FStar_Compiler_Effect.op_Bang plugin_unfold_warn_ctr in
-                 uu___3 > Prims.int_zero) in
-            if uu___2
-            then
-              let msg =
-                let uu___3 = FStar_Syntax_Print.fv_to_string fv in
-                FStar_Compiler_Util.format1
-                  "Unfolding name which is marked as a plugin: %s" uu___3 in
-              (FStar_Errors.log_issue
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.p
-                 (FStar_Errors.Warning_UnfoldPlugin, msg);
-               (let uu___4 =
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Bang plugin_unfold_warn_ctr in
-                  uu___5 - Prims.int_one in
-                FStar_Compiler_Effect.op_Colon_Equals plugin_unfold_warn_ctr
-                  uu___4))
-            else ());
-           r)
-let decide_unfolding :
-  'uuuuu .
-    FStar_TypeChecker_Cfg.cfg ->
-      stack_elt Prims.list ->
-        'uuuuu ->
-          FStar_Syntax_Syntax.fv ->
-            FStar_TypeChecker_Env.qninfo ->
-              (FStar_TypeChecker_Cfg.cfg * stack_elt Prims.list)
-                FStar_Pervasives_Native.option
-  =
-  fun cfg ->
-    fun stack1 ->
-      fun rng ->
-        fun fv ->
-          fun qninfo ->
-            let res =
-              should_unfold cfg (fun cfg1 -> should_reify cfg1 stack1) fv
-                qninfo in
-            match res with
-            | Should_unfold_no -> FStar_Pervasives_Native.None
-            | Should_unfold_yes -> FStar_Pervasives_Native.Some (cfg, stack1)
-            | Should_unfold_fully ->
-                let cfg' =
-                  {
-                    FStar_TypeChecker_Cfg.steps =
-                      (let uu___ = cfg.FStar_TypeChecker_Cfg.steps in
-                       {
-                         FStar_TypeChecker_Cfg.beta =
-                           (uu___.FStar_TypeChecker_Cfg.beta);
-                         FStar_TypeChecker_Cfg.iota =
-                           (uu___.FStar_TypeChecker_Cfg.iota);
-                         FStar_TypeChecker_Cfg.zeta =
-                           (uu___.FStar_TypeChecker_Cfg.zeta);
-                         FStar_TypeChecker_Cfg.zeta_full =
-                           (uu___.FStar_TypeChecker_Cfg.zeta_full);
-                         FStar_TypeChecker_Cfg.weak =
-                           (uu___.FStar_TypeChecker_Cfg.weak);
-                         FStar_TypeChecker_Cfg.hnf =
-                           (uu___.FStar_TypeChecker_Cfg.hnf);
-                         FStar_TypeChecker_Cfg.primops =
-                           (uu___.FStar_TypeChecker_Cfg.primops);
-                         FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                           (uu___.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                         FStar_TypeChecker_Cfg.unfold_until =
-                           (FStar_Pervasives_Native.Some
-                              FStar_Syntax_Syntax.delta_constant);
-                         FStar_TypeChecker_Cfg.unfold_only =
-                           FStar_Pervasives_Native.None;
-                         FStar_TypeChecker_Cfg.unfold_fully =
-                           FStar_Pervasives_Native.None;
-                         FStar_TypeChecker_Cfg.unfold_attr =
-                           FStar_Pervasives_Native.None;
-                         FStar_TypeChecker_Cfg.unfold_qual =
-                           FStar_Pervasives_Native.None;
-                         FStar_TypeChecker_Cfg.unfold_namespace =
-                           FStar_Pervasives_Native.None;
-                         FStar_TypeChecker_Cfg.unfold_tac =
-                           (uu___.FStar_TypeChecker_Cfg.unfold_tac);
-                         FStar_TypeChecker_Cfg.pure_subterms_within_computations
-                           =
-                           (uu___.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                         FStar_TypeChecker_Cfg.simplify =
-                           (uu___.FStar_TypeChecker_Cfg.simplify);
-                         FStar_TypeChecker_Cfg.erase_universes =
-                           (uu___.FStar_TypeChecker_Cfg.erase_universes);
-                         FStar_TypeChecker_Cfg.allow_unbound_universes =
-                           (uu___.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                         FStar_TypeChecker_Cfg.reify_ =
-                           (uu___.FStar_TypeChecker_Cfg.reify_);
-                         FStar_TypeChecker_Cfg.compress_uvars =
-                           (uu___.FStar_TypeChecker_Cfg.compress_uvars);
-                         FStar_TypeChecker_Cfg.no_full_norm =
-                           (uu___.FStar_TypeChecker_Cfg.no_full_norm);
-                         FStar_TypeChecker_Cfg.check_no_uvars =
-                           (uu___.FStar_TypeChecker_Cfg.check_no_uvars);
-                         FStar_TypeChecker_Cfg.unmeta =
-                           (uu___.FStar_TypeChecker_Cfg.unmeta);
-                         FStar_TypeChecker_Cfg.unascribe =
-                           (uu___.FStar_TypeChecker_Cfg.unascribe);
-                         FStar_TypeChecker_Cfg.in_full_norm_request =
-                           (uu___.FStar_TypeChecker_Cfg.in_full_norm_request);
-                         FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                           (uu___.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                         FStar_TypeChecker_Cfg.nbe_step =
-                           (uu___.FStar_TypeChecker_Cfg.nbe_step);
-                         FStar_TypeChecker_Cfg.for_extraction =
-                           (uu___.FStar_TypeChecker_Cfg.for_extraction);
-                         FStar_TypeChecker_Cfg.unrefine =
-                           (uu___.FStar_TypeChecker_Cfg.unrefine)
-                       });
-                    FStar_TypeChecker_Cfg.tcenv =
-                      (cfg.FStar_TypeChecker_Cfg.tcenv);
-                    FStar_TypeChecker_Cfg.debug =
-                      (cfg.FStar_TypeChecker_Cfg.debug);
-                    FStar_TypeChecker_Cfg.delta_level =
-                      (cfg.FStar_TypeChecker_Cfg.delta_level);
-                    FStar_TypeChecker_Cfg.primitive_steps =
-                      (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                    FStar_TypeChecker_Cfg.strong =
-                      (cfg.FStar_TypeChecker_Cfg.strong);
-                    FStar_TypeChecker_Cfg.memoize_lazy =
-                      (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                    FStar_TypeChecker_Cfg.normalize_pure_lets =
-                      (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                    FStar_TypeChecker_Cfg.reifying =
-                      (cfg.FStar_TypeChecker_Cfg.reifying)
-                  } in
-                let stack' =
-                  match stack1 with
-                  | (UnivArgs (us, r))::stack'1 -> (UnivArgs (us, r)) ::
-                      (Cfg (cfg, FStar_Pervasives_Native.None)) :: stack'1
-                  | stack'1 -> (Cfg (cfg, FStar_Pervasives_Native.None)) ::
-                      stack'1 in
-                FStar_Pervasives_Native.Some (cfg', stack')
-            | Should_unfold_reify ->
-                let rec push e s =
-                  match s with
-                  | [] -> [e]
-                  | (UnivArgs (us, r))::t ->
-                      let uu___ = push e t in (UnivArgs (us, r)) :: uu___
-                  | h::t -> e :: h :: t in
-                let ref =
-                  let uu___ =
-                    let uu___1 =
-                      let uu___2 = FStar_Syntax_Syntax.lid_of_fv fv in
-                      FStar_Const.Const_reflect uu___2 in
-                    FStar_Syntax_Syntax.Tm_constant uu___1 in
-                  FStar_Syntax_Syntax.mk uu___
-                    FStar_Compiler_Range.dummyRange in
-                let stack2 =
-                  push
-                    (App
-                       (empty_env, ref, FStar_Pervasives_Native.None,
-                         FStar_Compiler_Range.dummyRange)) stack1 in
-                FStar_Pervasives_Native.Some (cfg, stack2)
-let (on_domain_lids : FStar_Ident.lident Prims.list) =
-  [FStar_Parser_Const.fext_on_domain_lid;
-  FStar_Parser_Const.fext_on_dom_lid;
-  FStar_Parser_Const.fext_on_domain_g_lid;
-  FStar_Parser_Const.fext_on_dom_g_lid]
-let (is_fext_on_domain :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let is_on_dom fv =
-      FStar_Compiler_Effect.op_Bar_Greater on_domain_lids
-        (FStar_Compiler_List.existsb
-           (fun l -> FStar_Syntax_Syntax.fv_eq_lid fv l)) in
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Util.un_uinst hd in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_fvar fv when
-             (is_on_dom fv) &&
-               ((FStar_Compiler_List.length args) = (Prims.of_int (3)))
-             ->
-             let f =
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Compiler_Effect.op_Bar_Greater args
-                       FStar_Compiler_List.tl in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___4
-                     FStar_Compiler_List.tl in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                   FStar_Compiler_List.hd in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                 FStar_Pervasives_Native.fst in
-             FStar_Pervasives_Native.Some f
-         | uu___2 -> FStar_Pervasives_Native.None)
-    | uu___1 -> FStar_Pervasives_Native.None
-let (is_partial_primop_app :
-  FStar_TypeChecker_Cfg.cfg -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun cfg ->
-    fun t ->
-      let uu___ = FStar_Syntax_Util.head_and_args t in
-      match uu___ with
-      | (hd, args) ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Util.un_uinst hd in
-            uu___2.FStar_Syntax_Syntax.n in
-          (match uu___1 with
-           | FStar_Syntax_Syntax.Tm_fvar fv ->
-               let uu___2 = FStar_TypeChecker_Cfg.find_prim_step cfg fv in
-               (match uu___2 with
-                | FStar_Pervasives_Native.Some prim_step ->
-                    prim_step.FStar_TypeChecker_Cfg.arity >
-                      (FStar_Compiler_List.length args)
-                | FStar_Pervasives_Native.None -> false)
-           | uu___2 -> false)
-let (maybe_drop_rc_typ :
-  FStar_TypeChecker_Cfg.cfg ->
-    FStar_Syntax_Syntax.residual_comp -> FStar_Syntax_Syntax.residual_comp)
-  =
-  fun cfg ->
-    fun rc ->
-      if
-        (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-      then
-        {
-          FStar_Syntax_Syntax.residual_effect =
-            (rc.FStar_Syntax_Syntax.residual_effect);
-          FStar_Syntax_Syntax.residual_typ = FStar_Pervasives_Native.None;
-          FStar_Syntax_Syntax.residual_flags =
-            (rc.FStar_Syntax_Syntax.residual_flags)
-        }
-      else rc
-let rec (norm :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> stack -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun t ->
-          let rec collapse_metas st =
-            match st with
-            | (Meta
-                (uu___, FStar_Syntax_Syntax.Meta_monadic uu___1, uu___2))::(Meta
-                (e, FStar_Syntax_Syntax.Meta_monadic m, r))::st' ->
-                collapse_metas
-                  ((Meta (e, (FStar_Syntax_Syntax.Meta_monadic m), r)) ::
-                  st')
-            | uu___ -> st in
-          let stack2 = collapse_metas stack1 in
-          let t1 =
-            if
-              (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.norm_delayed
-            then
-              (match t.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_delayed uu___1 ->
-                   let uu___2 = FStar_Syntax_Print.term_to_string t in
-                   FStar_Compiler_Util.print1 "NORM delayed: %s\n" uu___2
-               | uu___1 -> ())
-            else ();
-            FStar_Syntax_Subst.compress t in
-          FStar_TypeChecker_Cfg.log cfg
-            (fun uu___1 ->
-               let uu___2 = FStar_Syntax_Print.tag_of_term t1 in
-               let uu___3 =
-                 FStar_Compiler_Util.string_of_bool
-                   (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.no_full_norm in
-               let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-               let uu___5 =
-                 FStar_Compiler_Util.string_of_int
-                   (FStar_Compiler_List.length env1) in
-               let uu___6 =
-                 let uu___7 =
-                   let uu___8 = firstn (Prims.of_int (4)) stack2 in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     FStar_Pervasives_Native.fst uu___8 in
-                 stack_to_string uu___7 in
-               FStar_Compiler_Util.print5
-                 ">>> %s (no_full_norm=%s)\nNorm %s with %s env elements; top of the stack = %s\n"
-                 uu___2 uu___3 uu___4 uu___5 uu___6);
-          FStar_TypeChecker_Cfg.log_cfg cfg
-            (fun uu___2 ->
-               let uu___3 = FStar_TypeChecker_Cfg.cfg_to_string cfg in
-               FStar_Compiler_Util.print1 ">>> cfg = %s\n" uu___3);
-          (match t1.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_unknown ->
-               rebuild cfg empty_env stack2 t1
-           | FStar_Syntax_Syntax.Tm_constant uu___2 ->
-               rebuild cfg empty_env stack2 t1
-           | FStar_Syntax_Syntax.Tm_name uu___2 ->
-               rebuild cfg empty_env stack2 t1
-           | FStar_Syntax_Syntax.Tm_lazy uu___2 ->
-               rebuild cfg empty_env stack2 t1
-           | FStar_Syntax_Syntax.Tm_fvar
-               { FStar_Syntax_Syntax.fv_name = uu___2;
-                 FStar_Syntax_Syntax.fv_delta = uu___3;
-                 FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-                   (FStar_Syntax_Syntax.Data_ctor);_}
-               ->
-               (FStar_TypeChecker_Cfg.log_unfolding cfg
-                  (fun uu___5 ->
-                     let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.print1 ">>> Tm_fvar case 0 for %s\n"
-                       uu___6);
-                rebuild cfg empty_env stack2 t1)
-           | FStar_Syntax_Syntax.Tm_fvar
-               { FStar_Syntax_Syntax.fv_name = uu___2;
-                 FStar_Syntax_Syntax.fv_delta = uu___3;
-                 FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-                   (FStar_Syntax_Syntax.Record_ctor uu___4);_}
-               ->
-               (FStar_TypeChecker_Cfg.log_unfolding cfg
-                  (fun uu___6 ->
-                     let uu___7 = FStar_Syntax_Print.term_to_string t1 in
-                     FStar_Compiler_Util.print1 ">>> Tm_fvar case 0 for %s\n"
-                       uu___7);
-                rebuild cfg empty_env stack2 t1)
-           | FStar_Syntax_Syntax.Tm_fvar fv ->
-               let lid = FStar_Syntax_Syntax.lid_of_fv fv in
-               let qninfo =
-                 FStar_TypeChecker_Env.lookup_qname
-                   cfg.FStar_TypeChecker_Cfg.tcenv lid in
-               let uu___2 =
-                 FStar_TypeChecker_Env.delta_depth_of_qninfo fv qninfo in
-               (match uu___2 with
-                | FStar_Pervasives_Native.Some
-                    (FStar_Syntax_Syntax.Delta_constant_at_level uu___3) when
-                    uu___3 = Prims.int_zero ->
-                    (FStar_TypeChecker_Cfg.log_unfolding cfg
-                       (fun uu___5 ->
-                          let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                          FStar_Compiler_Util.print1
-                            ">>> Tm_fvar case 1 for %s\n" uu___6);
-                     rebuild cfg empty_env stack2 t1)
-                | uu___3 ->
-                    let uu___4 =
-                      decide_unfolding cfg stack2 t1.FStar_Syntax_Syntax.pos
-                        fv qninfo in
-                    (match uu___4 with
-                     | FStar_Pervasives_Native.Some (cfg1, stack3) ->
-                         do_unfold_fv cfg1 stack3 t1 qninfo fv
-                     | FStar_Pervasives_Native.None ->
-                         rebuild cfg empty_env stack2 t1))
-           | FStar_Syntax_Syntax.Tm_quoted (qt, qi) ->
-               let qi1 =
-                 FStar_Syntax_Syntax.on_antiquoted (norm cfg env1 []) qi in
-               let t2 =
-                 FStar_Syntax_Syntax.mk
-                   (FStar_Syntax_Syntax.Tm_quoted (qt, qi1))
-                   t1.FStar_Syntax_Syntax.pos in
-               let uu___2 = closure_as_term cfg env1 t2 in
-               rebuild cfg env1 stack2 uu___2
-           | FStar_Syntax_Syntax.Tm_app (hd, args) when
-               (should_consider_norm_requests cfg) &&
-                 (let uu___2 = is_norm_request hd args in
-                  uu___2 = Norm_request_requires_rejig)
-               ->
-               (if
-                  (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.print_normalized
-                then
-                  FStar_Compiler_Util.print_string
-                    "Rejigging norm request ... \n"
-                else ();
-                (let uu___3 = rejig_norm_request hd args in
-                 norm cfg env1 stack2 uu___3))
-           | FStar_Syntax_Syntax.Tm_app (hd, args) when
-               (should_consider_norm_requests cfg) &&
-                 (let uu___2 = is_norm_request hd args in
-                  uu___2 = Norm_request_ready)
-               ->
-               (if
-                  (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.print_normalized
-                then
-                  (let uu___3 = FStar_Syntax_Print.term_to_string hd in
-                   let uu___4 = FStar_Syntax_Print.args_to_string args in
-                   FStar_Compiler_Util.print2
-                     "Potential norm request with hd = %s and args = %s ... \n"
-                     uu___3 uu___4)
-                else ();
-                (let cfg' =
-                   {
-                     FStar_TypeChecker_Cfg.steps =
-                       (let uu___3 = cfg.FStar_TypeChecker_Cfg.steps in
-                        {
-                          FStar_TypeChecker_Cfg.beta =
-                            (uu___3.FStar_TypeChecker_Cfg.beta);
-                          FStar_TypeChecker_Cfg.iota =
-                            (uu___3.FStar_TypeChecker_Cfg.iota);
-                          FStar_TypeChecker_Cfg.zeta =
-                            (uu___3.FStar_TypeChecker_Cfg.zeta);
-                          FStar_TypeChecker_Cfg.zeta_full =
-                            (uu___3.FStar_TypeChecker_Cfg.zeta_full);
-                          FStar_TypeChecker_Cfg.weak =
-                            (uu___3.FStar_TypeChecker_Cfg.weak);
-                          FStar_TypeChecker_Cfg.hnf =
-                            (uu___3.FStar_TypeChecker_Cfg.hnf);
-                          FStar_TypeChecker_Cfg.primops =
-                            (uu___3.FStar_TypeChecker_Cfg.primops);
-                          FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                            false;
-                          FStar_TypeChecker_Cfg.unfold_until =
-                            (uu___3.FStar_TypeChecker_Cfg.unfold_until);
-                          FStar_TypeChecker_Cfg.unfold_only =
-                            FStar_Pervasives_Native.None;
-                          FStar_TypeChecker_Cfg.unfold_fully =
-                            FStar_Pervasives_Native.None;
-                          FStar_TypeChecker_Cfg.unfold_attr =
-                            (uu___3.FStar_TypeChecker_Cfg.unfold_attr);
-                          FStar_TypeChecker_Cfg.unfold_qual =
-                            (uu___3.FStar_TypeChecker_Cfg.unfold_qual);
-                          FStar_TypeChecker_Cfg.unfold_namespace =
-                            (uu___3.FStar_TypeChecker_Cfg.unfold_namespace);
-                          FStar_TypeChecker_Cfg.unfold_tac =
-                            (uu___3.FStar_TypeChecker_Cfg.unfold_tac);
-                          FStar_TypeChecker_Cfg.pure_subterms_within_computations
-                            =
-                            (uu___3.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                          FStar_TypeChecker_Cfg.simplify =
-                            (uu___3.FStar_TypeChecker_Cfg.simplify);
-                          FStar_TypeChecker_Cfg.erase_universes =
-                            (uu___3.FStar_TypeChecker_Cfg.erase_universes);
-                          FStar_TypeChecker_Cfg.allow_unbound_universes =
-                            (uu___3.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                          FStar_TypeChecker_Cfg.reify_ =
-                            (uu___3.FStar_TypeChecker_Cfg.reify_);
-                          FStar_TypeChecker_Cfg.compress_uvars =
-                            (uu___3.FStar_TypeChecker_Cfg.compress_uvars);
-                          FStar_TypeChecker_Cfg.no_full_norm =
-                            (uu___3.FStar_TypeChecker_Cfg.no_full_norm);
-                          FStar_TypeChecker_Cfg.check_no_uvars =
-                            (uu___3.FStar_TypeChecker_Cfg.check_no_uvars);
-                          FStar_TypeChecker_Cfg.unmeta =
-                            (uu___3.FStar_TypeChecker_Cfg.unmeta);
-                          FStar_TypeChecker_Cfg.unascribe =
-                            (uu___3.FStar_TypeChecker_Cfg.unascribe);
-                          FStar_TypeChecker_Cfg.in_full_norm_request =
-                            (uu___3.FStar_TypeChecker_Cfg.in_full_norm_request);
-                          FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                            (uu___3.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                          FStar_TypeChecker_Cfg.nbe_step =
-                            (uu___3.FStar_TypeChecker_Cfg.nbe_step);
-                          FStar_TypeChecker_Cfg.for_extraction =
-                            (uu___3.FStar_TypeChecker_Cfg.for_extraction);
-                          FStar_TypeChecker_Cfg.unrefine =
-                            (uu___3.FStar_TypeChecker_Cfg.unrefine)
-                        });
-                     FStar_TypeChecker_Cfg.tcenv =
-                       (cfg.FStar_TypeChecker_Cfg.tcenv);
-                     FStar_TypeChecker_Cfg.debug =
-                       (cfg.FStar_TypeChecker_Cfg.debug);
-                     FStar_TypeChecker_Cfg.delta_level =
-                       [FStar_TypeChecker_Env.Unfold
-                          FStar_Syntax_Syntax.delta_constant];
-                     FStar_TypeChecker_Cfg.primitive_steps =
-                       (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                     FStar_TypeChecker_Cfg.strong =
-                       (cfg.FStar_TypeChecker_Cfg.strong);
-                     FStar_TypeChecker_Cfg.memoize_lazy =
-                       (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                     FStar_TypeChecker_Cfg.normalize_pure_lets = true;
-                     FStar_TypeChecker_Cfg.reifying =
-                       (cfg.FStar_TypeChecker_Cfg.reifying)
-                   } in
-                 let uu___3 = get_norm_request cfg (norm cfg' env1 []) args in
-                 match uu___3 with
-                 | FStar_Pervasives_Native.None ->
-                     (if
-                        (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.print_normalized
-                      then
-                        FStar_Compiler_Util.print_string
-                          "Norm request None ... \n"
-                      else ();
-                      (let stack3 =
-                         FStar_Compiler_Effect.op_Bar_Greater stack2
-                           (FStar_Compiler_List.fold_right
-                              (fun uu___5 ->
-                                 fun stack4 ->
-                                   match uu___5 with
-                                   | (a, aq) ->
-                                       let uu___6 =
-                                         let uu___7 =
-                                           let uu___8 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 FStar_Compiler_Util.mk_ref
-                                                   FStar_Pervasives_Native.None in
-                                               (env1, a, uu___10, false) in
-                                             Clos uu___9 in
-                                           (uu___8, aq,
-                                             (t1.FStar_Syntax_Syntax.pos)) in
-                                         Arg uu___7 in
-                                       uu___6 :: stack4) args) in
-                       FStar_TypeChecker_Cfg.log cfg
-                         (fun uu___6 ->
-                            let uu___7 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                FStar_Compiler_Util.string_of_int
-                                (FStar_Compiler_List.length args) in
-                            FStar_Compiler_Util.print1
-                              "\tPushed %s arguments\n" uu___7);
-                       norm cfg env1 stack3 hd))
-                 | FStar_Pervasives_Native.Some (s, tm) when is_nbe_request s
-                     ->
-                     let tm' = closure_as_term cfg env1 tm in
-                     let start = FStar_Compiler_Util.now () in
-                     let tm_norm = nbe_eval cfg s tm' in
-                     let fin = FStar_Compiler_Util.now () in
-                     (if
-                        (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.print_normalized
-                      then
-                        (let cfg'1 =
-                           FStar_TypeChecker_Cfg.config' [] s
-                             cfg.FStar_TypeChecker_Cfg.tcenv in
-                         let uu___5 =
-                           let uu___6 =
-                             let uu___7 =
-                               FStar_Compiler_Util.time_diff start fin in
-                             FStar_Pervasives_Native.snd uu___7 in
-                           FStar_Compiler_Util.string_of_int uu___6 in
-                         let uu___6 = FStar_Syntax_Print.term_to_string tm' in
-                         let uu___7 =
-                           FStar_TypeChecker_Cfg.cfg_to_string cfg'1 in
-                         let uu___8 =
-                           FStar_Syntax_Print.term_to_string tm_norm in
-                         FStar_Compiler_Util.print4
-                           "NBE result timing (%s ms){\nOn term {\n%s\n}\nwith steps {%s}\nresult is{\n\n%s\n}\n}\n"
-                           uu___5 uu___6 uu___7 uu___8)
-                      else ();
-                      rebuild cfg env1 stack2 tm_norm)
-                 | FStar_Pervasives_Native.Some (s, tm) ->
-                     let delta_level =
-                       let uu___4 =
-                         FStar_Compiler_Effect.op_Bar_Greater s
-                           (FStar_Compiler_Util.for_some
-                              (fun uu___5 ->
-                                 match uu___5 with
-                                 | FStar_TypeChecker_Env.UnfoldUntil uu___6
-                                     -> true
-                                 | FStar_TypeChecker_Env.UnfoldOnly uu___6 ->
-                                     true
-                                 | FStar_TypeChecker_Env.UnfoldFully uu___6
-                                     -> true
-                                 | uu___6 -> false)) in
-                       if uu___4
-                       then
-                         [FStar_TypeChecker_Env.Unfold
-                            FStar_Syntax_Syntax.delta_constant]
-                       else
-                         if
-                           (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                         then
-                           [FStar_TypeChecker_Env.Eager_unfolding_only;
-                           FStar_TypeChecker_Env.InliningDelta]
-                         else [FStar_TypeChecker_Env.NoDelta] in
-                     let cfg'1 =
-                       let uu___4 =
-                         let uu___5 = FStar_TypeChecker_Cfg.to_fsteps s in
-                         {
-                           FStar_TypeChecker_Cfg.beta =
-                             (uu___5.FStar_TypeChecker_Cfg.beta);
-                           FStar_TypeChecker_Cfg.iota =
-                             (uu___5.FStar_TypeChecker_Cfg.iota);
-                           FStar_TypeChecker_Cfg.zeta =
-                             (uu___5.FStar_TypeChecker_Cfg.zeta);
-                           FStar_TypeChecker_Cfg.zeta_full =
-                             (uu___5.FStar_TypeChecker_Cfg.zeta_full);
-                           FStar_TypeChecker_Cfg.weak =
-                             (uu___5.FStar_TypeChecker_Cfg.weak);
-                           FStar_TypeChecker_Cfg.hnf =
-                             (uu___5.FStar_TypeChecker_Cfg.hnf);
-                           FStar_TypeChecker_Cfg.primops =
-                             (uu___5.FStar_TypeChecker_Cfg.primops);
-                           FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                             (uu___5.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                           FStar_TypeChecker_Cfg.unfold_until =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_until);
-                           FStar_TypeChecker_Cfg.unfold_only =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_only);
-                           FStar_TypeChecker_Cfg.unfold_fully =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_fully);
-                           FStar_TypeChecker_Cfg.unfold_attr =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_attr);
-                           FStar_TypeChecker_Cfg.unfold_qual =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_qual);
-                           FStar_TypeChecker_Cfg.unfold_namespace =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_namespace);
-                           FStar_TypeChecker_Cfg.unfold_tac =
-                             (uu___5.FStar_TypeChecker_Cfg.unfold_tac);
-                           FStar_TypeChecker_Cfg.pure_subterms_within_computations
-                             =
-                             (uu___5.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                           FStar_TypeChecker_Cfg.simplify =
-                             (uu___5.FStar_TypeChecker_Cfg.simplify);
-                           FStar_TypeChecker_Cfg.erase_universes =
-                             (uu___5.FStar_TypeChecker_Cfg.erase_universes);
-                           FStar_TypeChecker_Cfg.allow_unbound_universes =
-                             (uu___5.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                           FStar_TypeChecker_Cfg.reify_ =
-                             (uu___5.FStar_TypeChecker_Cfg.reify_);
-                           FStar_TypeChecker_Cfg.compress_uvars =
-                             (uu___5.FStar_TypeChecker_Cfg.compress_uvars);
-                           FStar_TypeChecker_Cfg.no_full_norm =
-                             (uu___5.FStar_TypeChecker_Cfg.no_full_norm);
-                           FStar_TypeChecker_Cfg.check_no_uvars =
-                             (uu___5.FStar_TypeChecker_Cfg.check_no_uvars);
-                           FStar_TypeChecker_Cfg.unmeta =
-                             (uu___5.FStar_TypeChecker_Cfg.unmeta);
-                           FStar_TypeChecker_Cfg.unascribe =
-                             (uu___5.FStar_TypeChecker_Cfg.unascribe);
-                           FStar_TypeChecker_Cfg.in_full_norm_request = true;
-                           FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                             (uu___5.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                           FStar_TypeChecker_Cfg.nbe_step =
-                             (uu___5.FStar_TypeChecker_Cfg.nbe_step);
-                           FStar_TypeChecker_Cfg.for_extraction =
-                             ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction);
-                           FStar_TypeChecker_Cfg.unrefine =
-                             (uu___5.FStar_TypeChecker_Cfg.unrefine)
-                         } in
-                       {
-                         FStar_TypeChecker_Cfg.steps = uu___4;
-                         FStar_TypeChecker_Cfg.tcenv =
-                           (cfg.FStar_TypeChecker_Cfg.tcenv);
-                         FStar_TypeChecker_Cfg.debug =
-                           (cfg.FStar_TypeChecker_Cfg.debug);
-                         FStar_TypeChecker_Cfg.delta_level = delta_level;
-                         FStar_TypeChecker_Cfg.primitive_steps =
-                           (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                         FStar_TypeChecker_Cfg.strong =
-                           (cfg.FStar_TypeChecker_Cfg.strong);
-                         FStar_TypeChecker_Cfg.memoize_lazy =
-                           (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                         FStar_TypeChecker_Cfg.normalize_pure_lets = true;
-                         FStar_TypeChecker_Cfg.reifying =
-                           (cfg.FStar_TypeChecker_Cfg.reifying)
-                       } in
-                     let stack' =
-                       let debug =
-                         if
-                           (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.print_normalized
-                         then
-                           let uu___4 =
-                             let uu___5 = FStar_Compiler_Util.now () in
-                             (tm, uu___5) in
-                           FStar_Pervasives_Native.Some uu___4
-                         else FStar_Pervasives_Native.None in
-                       (Cfg (cfg, debug)) :: stack2 in
-                     norm cfg'1 env1 stack' tm))
-           | FStar_Syntax_Syntax.Tm_type u ->
-               let u1 = norm_universe cfg env1 u in
-               let uu___2 =
-                 FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u1)
-                   t1.FStar_Syntax_Syntax.pos in
-               rebuild cfg env1 stack2 uu___2
-           | FStar_Syntax_Syntax.Tm_uinst (t', us) ->
-               if
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.erase_universes
-               then norm cfg env1 stack2 t'
-               else
-                 (let us1 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_List.map (norm_universe cfg env1) us in
-                      (uu___4, (t1.FStar_Syntax_Syntax.pos)) in
-                    UnivArgs uu___3 in
-                  let stack3 = us1 :: stack2 in norm cfg env1 stack3 t')
-           | FStar_Syntax_Syntax.Tm_bvar x ->
-               let uu___2 = lookup_bvar env1 x in
-               (match uu___2 with
-                | Univ uu___3 ->
-                    failwith
-                      "Impossible: term variable is bound to a universe"
-                | Dummy -> failwith "Term variable not found"
-                | Clos (env2, t0, r, fix) ->
-                    if
-                      ((Prims.op_Negation fix) ||
-                         (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta)
-                        ||
-                        (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta_full
-                    then
-                      let uu___3 = FStar_Compiler_Effect.op_Bang r in
-                      (match uu___3 with
-                       | FStar_Pervasives_Native.Some (env3, t') ->
-                           (FStar_TypeChecker_Cfg.log cfg
-                              (fun uu___5 ->
-                                 let uu___6 =
-                                   FStar_Syntax_Print.term_to_string t1 in
-                                 let uu___7 =
-                                   FStar_Syntax_Print.term_to_string t' in
-                                 FStar_Compiler_Util.print2
-                                   "Lazy hit: %s cached to %s\n" uu___6
-                                   uu___7);
-                            (let uu___5 = maybe_weakly_reduced t' in
-                             if uu___5
-                             then
-                               match stack2 with
-                               | [] when
-                                   (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak
-                                     ||
-                                     (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.compress_uvars
-                                   -> rebuild cfg env3 stack2 t'
-                               | uu___6 -> norm cfg env3 stack2 t'
-                             else rebuild cfg env3 stack2 t'))
-                       | FStar_Pervasives_Native.None ->
-                           norm cfg env2 ((MemoLazy r) :: stack2) t0)
-                    else norm cfg env2 stack2 t0)
-           | FStar_Syntax_Syntax.Tm_abs (bs, body, lopt) ->
-               let rec maybe_strip_meta_divs stack3 =
-                 match stack3 with
-                 | [] -> FStar_Pervasives_Native.None
-                 | (Meta
-                     (uu___2, FStar_Syntax_Syntax.Meta_monadic (m, uu___3),
-                      uu___4))::tl
-                     when
-                     FStar_Ident.lid_equals m
-                       FStar_Parser_Const.effect_DIV_lid
-                     -> maybe_strip_meta_divs tl
-                 | (Meta
-                     (uu___2, FStar_Syntax_Syntax.Meta_monadic_lift
-                      (src, tgt, uu___3), uu___4))::tl
-                     when
-                     (FStar_Ident.lid_equals src
-                        FStar_Parser_Const.effect_PURE_lid)
-                       &&
-                       (FStar_Ident.lid_equals tgt
-                          FStar_Parser_Const.effect_DIV_lid)
-                     -> maybe_strip_meta_divs tl
-                 | (Arg uu___2)::uu___3 ->
-                     FStar_Pervasives_Native.Some stack3
-                 | uu___2 -> FStar_Pervasives_Native.None in
-               let fallback uu___2 =
-                 if
-                   (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak
-                 then
-                   let t2 = closure_as_term cfg env1 t1 in
-                   rebuild cfg env1 stack2 t2
-                 else
-                   (let uu___4 = FStar_Syntax_Subst.open_term' bs body in
-                    match uu___4 with
-                    | (bs1, body1, opening) ->
-                        let env' =
-                          FStar_Compiler_Effect.op_Bar_Greater bs1
-                            (FStar_Compiler_List.fold_left
-                               (fun env2 -> fun uu___5 -> dummy :: env2) env1) in
-                        let lopt1 =
-                          let uu___5 =
-                            FStar_Compiler_Effect.op_Bar_Greater lopt
-                              (FStar_Compiler_Util.map_option
-                                 (maybe_drop_rc_typ cfg)) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            (FStar_Compiler_Util.map_option
-                               (fun rc ->
-                                  let uu___6 =
-                                    FStar_Compiler_Util.map_option
-                                      (FStar_Syntax_Subst.subst opening)
-                                      rc.FStar_Syntax_Syntax.residual_typ in
-                                  {
-                                    FStar_Syntax_Syntax.residual_effect =
-                                      (rc.FStar_Syntax_Syntax.residual_effect);
-                                    FStar_Syntax_Syntax.residual_typ = uu___6;
-                                    FStar_Syntax_Syntax.residual_flags =
-                                      (rc.FStar_Syntax_Syntax.residual_flags)
-                                  })) in
-                        (FStar_TypeChecker_Cfg.log cfg
-                           (fun uu___6 ->
-                              let uu___7 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  FStar_Compiler_Util.string_of_int
-                                  (FStar_Compiler_List.length bs1) in
-                              FStar_Compiler_Util.print1
-                                "\tShifted %s dummies\n" uu___7);
-                         (let stack3 =
-                            (Cfg (cfg, FStar_Pervasives_Native.None)) ::
-                            stack2 in
-                          let cfg1 =
-                            {
-                              FStar_TypeChecker_Cfg.steps =
-                                (cfg.FStar_TypeChecker_Cfg.steps);
-                              FStar_TypeChecker_Cfg.tcenv =
-                                (cfg.FStar_TypeChecker_Cfg.tcenv);
-                              FStar_TypeChecker_Cfg.debug =
-                                (cfg.FStar_TypeChecker_Cfg.debug);
-                              FStar_TypeChecker_Cfg.delta_level =
-                                (cfg.FStar_TypeChecker_Cfg.delta_level);
-                              FStar_TypeChecker_Cfg.primitive_steps =
-                                (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                              FStar_TypeChecker_Cfg.strong = true;
-                              FStar_TypeChecker_Cfg.memoize_lazy =
-                                (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                              FStar_TypeChecker_Cfg.normalize_pure_lets =
-                                (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                              FStar_TypeChecker_Cfg.reifying =
-                                (cfg.FStar_TypeChecker_Cfg.reifying)
-                            } in
-                          norm cfg1 env'
-                            ((Abs
-                                (env1, bs1, env', lopt1,
-                                  (t1.FStar_Syntax_Syntax.pos))) :: stack3)
-                            body1))) in
-               (match stack2 with
-                | (UnivArgs uu___2)::uu___3 ->
-                    failwith
-                      "Ill-typed term: universes cannot be applied to term abstraction"
-                | (Arg (c, uu___2, uu___3))::stack_rest ->
-                    (match c with
-                     | Univ uu___4 ->
-                         norm cfg ((FStar_Pervasives_Native.None, c) :: env1)
-                           stack_rest t1
-                     | uu___4 ->
-                         (match bs with
-                          | [] -> failwith "Impossible"
-                          | b::[] ->
-                              (FStar_TypeChecker_Cfg.log cfg
-                                 (fun uu___6 ->
-                                    let uu___7 = closure_to_string c in
-                                    FStar_Compiler_Util.print1
-                                      "\tShifted %s\n" uu___7);
-                               norm cfg
-                                 (((FStar_Pervasives_Native.Some b), c) ::
-                                 env1) stack_rest body)
-                          | b::tl ->
-                              (FStar_TypeChecker_Cfg.log cfg
-                                 (fun uu___6 ->
-                                    let uu___7 = closure_to_string c in
-                                    FStar_Compiler_Util.print1
-                                      "\tShifted %s\n" uu___7);
-                               (let body1 =
-                                  FStar_Syntax_Syntax.mk
-                                    (FStar_Syntax_Syntax.Tm_abs
-                                       (tl, body, lopt))
-                                    t1.FStar_Syntax_Syntax.pos in
-                                norm cfg
-                                  (((FStar_Pervasives_Native.Some b), c) ::
-                                  env1) stack_rest body1))))
-                | (MemoLazy r)::stack3 ->
-                    (set_memo cfg r (env1, t1);
-                     FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___4 ->
-                          let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                          FStar_Compiler_Util.print1 "\tSet memo %s\n" uu___5);
-                     norm cfg env1 stack3 t1)
-                | (Meta uu___2)::uu___3 ->
-                    let uu___4 = maybe_strip_meta_divs stack2 in
-                    (match uu___4 with
-                     | FStar_Pervasives_Native.None -> fallback ()
-                     | FStar_Pervasives_Native.Some stack3 ->
-                         norm cfg env1 stack3 t1)
-                | (Cfg uu___2)::uu___3 -> fallback ()
-                | (Match uu___2)::uu___3 -> fallback ()
-                | (Let uu___2)::uu___3 -> fallback ()
-                | (App uu___2)::uu___3 -> fallback ()
-                | (CBVApp uu___2)::uu___3 -> fallback ()
-                | (Abs uu___2)::uu___3 -> fallback ()
-                | [] -> fallback ())
-           | FStar_Syntax_Syntax.Tm_app (head, args) ->
-               let strict_args =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_Effect.op_Bar_Greater head
-                         FStar_Syntax_Util.unascribe in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___4
-                       FStar_Syntax_Util.un_uinst in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 match uu___2 with
-                 | FStar_Syntax_Syntax.Tm_fvar fv ->
-                     FStar_TypeChecker_Env.fv_has_strict_args
-                       cfg.FStar_TypeChecker_Cfg.tcenv fv
-                 | uu___3 -> FStar_Pervasives_Native.None in
-               (match strict_args with
-                | FStar_Pervasives_Native.None ->
-                    let stack3 =
-                      FStar_Compiler_List.fold_right
-                        (fun uu___2 ->
-                           fun stack4 ->
-                             match uu___2 with
-                             | (a, aq) ->
-                                 let a1 =
-                                   let uu___3 =
-                                     (((let uu___4 =
-                                          FStar_TypeChecker_Cfg.cfg_env cfg in
-                                        uu___4.FStar_TypeChecker_Env.erase_erasable_args)
-                                         ||
-                                         (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction)
-                                        ||
-                                        (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.erase_erasable_args)
-                                       &&
-                                       (FStar_Syntax_Util.aqual_is_erasable
-                                          aq) in
-                                   if uu___3
-                                   then FStar_Syntax_Util.exp_unit
-                                   else a in
-                                 let env2 =
-                                   let uu___3 =
-                                     let uu___4 =
-                                       FStar_Syntax_Subst.compress a1 in
-                                     uu___4.FStar_Syntax_Syntax.n in
-                                   match uu___3 with
-                                   | FStar_Syntax_Syntax.Tm_name uu___4 ->
-                                       empty_env
-                                   | FStar_Syntax_Syntax.Tm_constant uu___4
-                                       -> empty_env
-                                   | FStar_Syntax_Syntax.Tm_lazy uu___4 ->
-                                       empty_env
-                                   | FStar_Syntax_Syntax.Tm_fvar uu___4 ->
-                                       empty_env
-                                   | uu___4 -> env1 in
-                                 let uu___3 =
-                                   let uu___4 =
-                                     let uu___5 =
-                                       let uu___6 =
-                                         let uu___7 =
-                                           FStar_Compiler_Util.mk_ref
-                                             FStar_Pervasives_Native.None in
-                                         (env2, a1, uu___7, false) in
-                                       Clos uu___6 in
-                                     (uu___5, aq,
-                                       (t1.FStar_Syntax_Syntax.pos)) in
-                                   Arg uu___4 in
-                                 uu___3 :: stack4) args stack2 in
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___3 ->
-                          let uu___4 =
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_Compiler_Util.string_of_int
-                              (FStar_Compiler_List.length args) in
-                          FStar_Compiler_Util.print1
-                            "\tPushed %s arguments\n" uu___4);
-                     norm cfg env1 stack3 head)
-                | FStar_Pervasives_Native.Some strict_args1 ->
-                    let norm_args =
-                      FStar_Compiler_Effect.op_Bar_Greater args
-                        (FStar_Compiler_List.map
-                           (fun uu___2 ->
-                              match uu___2 with
-                              | (a, i) ->
-                                  let uu___3 = norm cfg env1 [] a in
-                                  (uu___3, i))) in
-                    let norm_args_len = FStar_Compiler_List.length norm_args in
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bar_Greater strict_args1
-                        (FStar_Compiler_List.for_all
-                           (fun i ->
-                              if i >= norm_args_len
-                              then false
-                              else
-                                (let uu___4 =
-                                   FStar_Compiler_List.nth norm_args i in
-                                 match uu___4 with
-                                 | (arg_i, uu___5) ->
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           arg_i
-                                           FStar_Syntax_Util.unmeta_safe in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___7
-                                         FStar_Syntax_Util.head_and_args in
-                                     (match uu___6 with
-                                      | (head1, uu___7) ->
-                                          let uu___8 =
-                                            let uu___9 =
-                                              FStar_Syntax_Util.un_uinst
-                                                head1 in
-                                            uu___9.FStar_Syntax_Syntax.n in
-                                          (match uu___8 with
-                                           | FStar_Syntax_Syntax.Tm_constant
-                                               uu___9 -> true
-                                           | FStar_Syntax_Syntax.Tm_fvar fv
-                                               ->
-                                               let uu___9 =
-                                                 FStar_Syntax_Syntax.lid_of_fv
-                                                   fv in
-                                               FStar_TypeChecker_Env.is_datacon
-                                                 cfg.FStar_TypeChecker_Cfg.tcenv
-                                                 uu___9
-                                           | uu___9 -> false))))) in
-                    if uu___2
-                    then
-                      let stack3 =
-                        FStar_Compiler_Effect.op_Bar_Greater stack2
-                          (FStar_Compiler_List.fold_right
-                             (fun uu___3 ->
-                                fun stack4 ->
-                                  match uu___3 with
-                                  | (a, aq) ->
-                                      let uu___4 =
-                                        let uu___5 =
-                                          let uu___6 =
-                                            let uu___7 =
-                                              let uu___8 =
-                                                FStar_Compiler_Util.mk_ref
-                                                  (FStar_Pervasives_Native.Some
-                                                     ([], a)) in
-                                              (env1, a, uu___8, false) in
-                                            Clos uu___7 in
-                                          (uu___6, aq,
-                                            (t1.FStar_Syntax_Syntax.pos)) in
-                                        Arg uu___5 in
-                                      uu___4 :: stack4) norm_args) in
-                      (FStar_TypeChecker_Cfg.log cfg
-                         (fun uu___4 ->
-                            let uu___5 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                FStar_Compiler_Util.string_of_int
-                                (FStar_Compiler_List.length args) in
-                            FStar_Compiler_Util.print1
-                              "\tPushed %s arguments\n" uu___5);
-                       norm cfg env1 stack3 head)
-                    else
-                      (let head1 = closure_as_term cfg env1 head in
-                       let term =
-                         FStar_Syntax_Syntax.mk_Tm_app head1 norm_args
-                           t1.FStar_Syntax_Syntax.pos in
-                       rebuild cfg env1 stack2 term))
-           | FStar_Syntax_Syntax.Tm_refine (x, uu___2) when
-               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                 ||
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unrefine
-               -> norm cfg env1 stack2 x.FStar_Syntax_Syntax.sort
-           | FStar_Syntax_Syntax.Tm_refine (x, f) ->
-               if
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak
-               then
-                 (match (env1, stack2) with
-                  | ([], []) ->
-                      let t_x = norm cfg env1 [] x.FStar_Syntax_Syntax.sort in
-                      let t2 =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_refine
-                             ({
-                                FStar_Syntax_Syntax.ppname =
-                                  (x.FStar_Syntax_Syntax.ppname);
-                                FStar_Syntax_Syntax.index =
-                                  (x.FStar_Syntax_Syntax.index);
-                                FStar_Syntax_Syntax.sort = t_x
-                              }, f)) t1.FStar_Syntax_Syntax.pos in
-                      rebuild cfg env1 stack2 t2
-                  | uu___2 ->
-                      let uu___3 = closure_as_term cfg env1 t1 in
-                      rebuild cfg env1 stack2 uu___3)
-               else
-                 (let t_x = norm cfg env1 [] x.FStar_Syntax_Syntax.sort in
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___5] in
-                    FStar_Syntax_Subst.open_term uu___4 f in
-                  match uu___3 with
-                  | (closing, f1) ->
-                      let f2 = norm cfg (dummy :: env1) [] f1 in
-                      let t2 =
-                        let uu___4 =
-                          let uu___5 =
-                            let uu___6 = FStar_Syntax_Subst.close closing f2 in
-                            ({
-                               FStar_Syntax_Syntax.ppname =
-                                 (x.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (x.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = t_x
-                             }, uu___6) in
-                          FStar_Syntax_Syntax.Tm_refine uu___5 in
-                        FStar_Syntax_Syntax.mk uu___4
-                          t1.FStar_Syntax_Syntax.pos in
-                      rebuild cfg env1 stack2 t2)
-           | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-               if
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak
-               then
-                 let uu___2 = closure_as_term cfg env1 t1 in
-                 rebuild cfg env1 stack2 uu___2
-               else
-                 (let uu___3 = FStar_Syntax_Subst.open_comp bs c in
-                  match uu___3 with
-                  | (bs1, c1) ->
-                      let c2 =
-                        let uu___4 =
-                          FStar_Compiler_Effect.op_Bar_Greater bs1
-                            (FStar_Compiler_List.fold_left
-                               (fun env2 -> fun uu___5 -> dummy :: env2) env1) in
-                        norm_comp cfg uu___4 c1 in
-                      let t2 =
-                        let uu___4 = norm_binders cfg env1 bs1 in
-                        FStar_Syntax_Util.arrow uu___4 c2 in
-                      rebuild cfg env1 stack2 t2)
-           | FStar_Syntax_Syntax.Tm_ascribed (t11, uu___2, l) when
-               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unascribe
-               -> norm cfg env1 stack2 t11
-           | FStar_Syntax_Syntax.Tm_ascribed (t11, asc, l) ->
-               (match stack2 with
-                | (Match uu___2)::uu___3 when
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.beta
-                    ->
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___5 ->
-                          FStar_Compiler_Util.print_string
-                            "+++ Dropping ascription \n");
-                     norm cfg env1 stack2 t11)
-                | (Arg uu___2)::uu___3 when
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.beta
-                    ->
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___5 ->
-                          FStar_Compiler_Util.print_string
-                            "+++ Dropping ascription \n");
-                     norm cfg env1 stack2 t11)
-                | (App
-                    (uu___2,
-                     {
-                       FStar_Syntax_Syntax.n =
-                         FStar_Syntax_Syntax.Tm_constant
-                         (FStar_Const.Const_reify);
-                       FStar_Syntax_Syntax.pos = uu___3;
-                       FStar_Syntax_Syntax.vars = uu___4;
-                       FStar_Syntax_Syntax.hash_code = uu___5;_},
-                     uu___6, uu___7))::uu___8
-                    when
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.beta
-                    ->
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___10 ->
-                          FStar_Compiler_Util.print_string
-                            "+++ Dropping ascription \n");
-                     norm cfg env1 stack2 t11)
-                | (MemoLazy uu___2)::uu___3 when
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.beta
-                    ->
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___5 ->
-                          FStar_Compiler_Util.print_string
-                            "+++ Dropping ascription \n");
-                     norm cfg env1 stack2 t11)
-                | uu___2 ->
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___4 ->
-                          FStar_Compiler_Util.print_string
-                            "+++ Keeping ascription \n");
-                     (let t12 = norm cfg env1 [] t11 in
-                      FStar_TypeChecker_Cfg.log cfg
-                        (fun uu___5 ->
-                           FStar_Compiler_Util.print_string
-                             "+++ Normalizing ascription \n");
-                      (let asc1 = norm_ascription cfg env1 asc in
-                       match stack2 with
-                       | (Cfg (cfg', dbg))::stack3 ->
-                           (maybe_debug cfg t12 dbg;
-                            (let t2 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Syntax_Util.unascribe t12 in
-                                   (uu___8, asc1, l) in
-                                 FStar_Syntax_Syntax.Tm_ascribed uu___7 in
-                               FStar_Syntax_Syntax.mk uu___6
-                                 t1.FStar_Syntax_Syntax.pos in
-                             norm cfg' env1 stack3 t2))
-                       | uu___5 ->
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 let uu___9 = FStar_Syntax_Util.unascribe t12 in
-                                 (uu___9, asc1, l) in
-                               FStar_Syntax_Syntax.Tm_ascribed uu___8 in
-                             FStar_Syntax_Syntax.mk uu___7
-                               t1.FStar_Syntax_Syntax.pos in
-                           rebuild cfg env1 stack2 uu___6))))
-           | FStar_Syntax_Syntax.Tm_match (head, asc_opt, branches1, lopt) ->
-               let lopt1 =
-                 FStar_Compiler_Util.map_option (maybe_drop_rc_typ cfg) lopt in
-               let stack3 =
-                 (Match
-                    (env1, asc_opt, branches1, lopt1, cfg,
-                      (t1.FStar_Syntax_Syntax.pos)))
-                 :: stack2 in
-               if
-                 ((cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.iota
-                    &&
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weakly_reduce_scrutinee)
-                   &&
-                   (Prims.op_Negation
-                      (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak)
-               then
-                 let cfg' =
-                   {
-                     FStar_TypeChecker_Cfg.steps =
-                       (let uu___2 = cfg.FStar_TypeChecker_Cfg.steps in
-                        {
-                          FStar_TypeChecker_Cfg.beta =
-                            (uu___2.FStar_TypeChecker_Cfg.beta);
-                          FStar_TypeChecker_Cfg.iota =
-                            (uu___2.FStar_TypeChecker_Cfg.iota);
-                          FStar_TypeChecker_Cfg.zeta =
-                            (uu___2.FStar_TypeChecker_Cfg.zeta);
-                          FStar_TypeChecker_Cfg.zeta_full =
-                            (uu___2.FStar_TypeChecker_Cfg.zeta_full);
-                          FStar_TypeChecker_Cfg.weak = true;
-                          FStar_TypeChecker_Cfg.hnf =
-                            (uu___2.FStar_TypeChecker_Cfg.hnf);
-                          FStar_TypeChecker_Cfg.primops =
-                            (uu___2.FStar_TypeChecker_Cfg.primops);
-                          FStar_TypeChecker_Cfg.do_not_unfold_pure_lets =
-                            (uu___2.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                          FStar_TypeChecker_Cfg.unfold_until =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_until);
-                          FStar_TypeChecker_Cfg.unfold_only =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_only);
-                          FStar_TypeChecker_Cfg.unfold_fully =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_fully);
-                          FStar_TypeChecker_Cfg.unfold_attr =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_attr);
-                          FStar_TypeChecker_Cfg.unfold_qual =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_qual);
-                          FStar_TypeChecker_Cfg.unfold_namespace =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_namespace);
-                          FStar_TypeChecker_Cfg.unfold_tac =
-                            (uu___2.FStar_TypeChecker_Cfg.unfold_tac);
-                          FStar_TypeChecker_Cfg.pure_subterms_within_computations
-                            =
-                            (uu___2.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                          FStar_TypeChecker_Cfg.simplify =
-                            (uu___2.FStar_TypeChecker_Cfg.simplify);
-                          FStar_TypeChecker_Cfg.erase_universes =
-                            (uu___2.FStar_TypeChecker_Cfg.erase_universes);
-                          FStar_TypeChecker_Cfg.allow_unbound_universes =
-                            (uu___2.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                          FStar_TypeChecker_Cfg.reify_ =
-                            (uu___2.FStar_TypeChecker_Cfg.reify_);
-                          FStar_TypeChecker_Cfg.compress_uvars =
-                            (uu___2.FStar_TypeChecker_Cfg.compress_uvars);
-                          FStar_TypeChecker_Cfg.no_full_norm =
-                            (uu___2.FStar_TypeChecker_Cfg.no_full_norm);
-                          FStar_TypeChecker_Cfg.check_no_uvars =
-                            (uu___2.FStar_TypeChecker_Cfg.check_no_uvars);
-                          FStar_TypeChecker_Cfg.unmeta =
-                            (uu___2.FStar_TypeChecker_Cfg.unmeta);
-                          FStar_TypeChecker_Cfg.unascribe =
-                            (uu___2.FStar_TypeChecker_Cfg.unascribe);
-                          FStar_TypeChecker_Cfg.in_full_norm_request =
-                            (uu___2.FStar_TypeChecker_Cfg.in_full_norm_request);
-                          FStar_TypeChecker_Cfg.weakly_reduce_scrutinee =
-                            (uu___2.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                          FStar_TypeChecker_Cfg.nbe_step =
-                            (uu___2.FStar_TypeChecker_Cfg.nbe_step);
-                          FStar_TypeChecker_Cfg.for_extraction =
-                            (uu___2.FStar_TypeChecker_Cfg.for_extraction);
-                          FStar_TypeChecker_Cfg.unrefine =
-                            (uu___2.FStar_TypeChecker_Cfg.unrefine)
-                        });
-                     FStar_TypeChecker_Cfg.tcenv =
-                       (cfg.FStar_TypeChecker_Cfg.tcenv);
-                     FStar_TypeChecker_Cfg.debug =
-                       (cfg.FStar_TypeChecker_Cfg.debug);
-                     FStar_TypeChecker_Cfg.delta_level =
-                       (cfg.FStar_TypeChecker_Cfg.delta_level);
-                     FStar_TypeChecker_Cfg.primitive_steps =
-                       (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                     FStar_TypeChecker_Cfg.strong =
-                       (cfg.FStar_TypeChecker_Cfg.strong);
-                     FStar_TypeChecker_Cfg.memoize_lazy =
-                       (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                     FStar_TypeChecker_Cfg.normalize_pure_lets =
-                       (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                     FStar_TypeChecker_Cfg.reifying =
-                       (cfg.FStar_TypeChecker_Cfg.reifying)
-                   } in
-                 norm cfg' env1 ((Cfg (cfg, FStar_Pervasives_Native.None)) ::
-                   stack3) head
-               else norm cfg env1 stack3 head
-           | FStar_Syntax_Syntax.Tm_let ((b, lbs), lbody) when
-               (FStar_Syntax_Syntax.is_top_level lbs) &&
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.compress_uvars
-               ->
-               let lbs1 =
-                 FStar_Compiler_Effect.op_Bar_Greater lbs
-                   (FStar_Compiler_List.map
-                      (fun lb ->
-                         let uu___2 =
-                           FStar_Syntax_Subst.univ_var_opening
-                             lb.FStar_Syntax_Syntax.lbunivs in
-                         match uu___2 with
-                         | (openings, lbunivs) ->
-                             let cfg1 =
-                               let uu___3 =
-                                 FStar_TypeChecker_Env.push_univ_vars
-                                   cfg.FStar_TypeChecker_Cfg.tcenv lbunivs in
-                               {
-                                 FStar_TypeChecker_Cfg.steps =
-                                   (cfg.FStar_TypeChecker_Cfg.steps);
-                                 FStar_TypeChecker_Cfg.tcenv = uu___3;
-                                 FStar_TypeChecker_Cfg.debug =
-                                   (cfg.FStar_TypeChecker_Cfg.debug);
-                                 FStar_TypeChecker_Cfg.delta_level =
-                                   (cfg.FStar_TypeChecker_Cfg.delta_level);
-                                 FStar_TypeChecker_Cfg.primitive_steps =
-                                   (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                                 FStar_TypeChecker_Cfg.strong =
-                                   (cfg.FStar_TypeChecker_Cfg.strong);
-                                 FStar_TypeChecker_Cfg.memoize_lazy =
-                                   (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                                 FStar_TypeChecker_Cfg.normalize_pure_lets =
-                                   (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                                 FStar_TypeChecker_Cfg.reifying =
-                                   (cfg.FStar_TypeChecker_Cfg.reifying)
-                               } in
-                             let norm1 t2 =
-                               let uu___3 =
-                                 let uu___4 =
-                                   FStar_Syntax_Subst.subst openings t2 in
-                                 norm cfg1 env1 [] uu___4 in
-                               FStar_Syntax_Subst.close_univ_vars lbunivs
-                                 uu___3 in
-                             let lbtyp = norm1 lb.FStar_Syntax_Syntax.lbtyp in
-                             let lbdef = norm1 lb.FStar_Syntax_Syntax.lbdef in
-                             {
-                               FStar_Syntax_Syntax.lbname =
-                                 (lb.FStar_Syntax_Syntax.lbname);
-                               FStar_Syntax_Syntax.lbunivs = lbunivs;
-                               FStar_Syntax_Syntax.lbtyp = lbtyp;
-                               FStar_Syntax_Syntax.lbeff =
-                                 (lb.FStar_Syntax_Syntax.lbeff);
-                               FStar_Syntax_Syntax.lbdef = lbdef;
-                               FStar_Syntax_Syntax.lbattrs =
-                                 (lb.FStar_Syntax_Syntax.lbattrs);
-                               FStar_Syntax_Syntax.lbpos =
-                                 (lb.FStar_Syntax_Syntax.lbpos)
-                             })) in
-               let uu___2 =
-                 FStar_Syntax_Syntax.mk
-                   (FStar_Syntax_Syntax.Tm_let ((b, lbs1), lbody))
-                   t1.FStar_Syntax_Syntax.pos in
-               rebuild cfg env1 stack2 uu___2
-           | FStar_Syntax_Syntax.Tm_let
-               ((uu___2,
-                 { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr uu___3;
-                   FStar_Syntax_Syntax.lbunivs = uu___4;
-                   FStar_Syntax_Syntax.lbtyp = uu___5;
-                   FStar_Syntax_Syntax.lbeff = uu___6;
-                   FStar_Syntax_Syntax.lbdef = uu___7;
-                   FStar_Syntax_Syntax.lbattrs = uu___8;
-                   FStar_Syntax_Syntax.lbpos = uu___9;_}::uu___10),
-                uu___11)
-               -> rebuild cfg env1 stack2 t1
-           | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-               let uu___2 =
-                 FStar_TypeChecker_Cfg.should_reduce_local_let cfg lb in
-               if uu___2
-               then
-                 let binder =
-                   let uu___3 =
-                     FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-                   FStar_Syntax_Syntax.mk_binder uu___3 in
-                 let def =
-                   FStar_Syntax_Util.unmeta_lift lb.FStar_Syntax_Syntax.lbdef in
-                 let env2 =
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Compiler_Util.mk_ref
-                             FStar_Pervasives_Native.None in
-                         (env1, def, uu___6, false) in
-                       Clos uu___5 in
-                     ((FStar_Pervasives_Native.Some binder), uu___4) in
-                   uu___3 :: env1 in
-                 (FStar_TypeChecker_Cfg.log cfg
-                    (fun uu___4 ->
-                       FStar_Compiler_Util.print_string
-                         "+++ Reducing Tm_let\n");
-                  norm cfg env2 stack2 body)
-               else
-                 (let uu___4 =
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.reify_
-                      &&
-                      (let uu___5 =
-                         FStar_TypeChecker_Env.norm_eff_name
-                           cfg.FStar_TypeChecker_Cfg.tcenv
-                           lb.FStar_Syntax_Syntax.lbeff in
-                       FStar_Syntax_Util.is_div_effect uu___5) in
-                  if uu___4
-                  then
-                    let ffun =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  lb.FStar_Syntax_Syntax.lbname
-                                  FStar_Compiler_Util.left in
-                              FStar_Syntax_Syntax.mk_binder uu___9 in
-                            [uu___8] in
-                          (uu___7, body, FStar_Pervasives_Native.None) in
-                        FStar_Syntax_Syntax.Tm_abs uu___6 in
-                      FStar_Syntax_Syntax.mk uu___5
-                        t1.FStar_Syntax_Syntax.pos in
-                    let stack3 =
-                      (CBVApp
-                         (env1, ffun, FStar_Pervasives_Native.None,
-                           (t1.FStar_Syntax_Syntax.pos)))
-                      :: stack2 in
-                    (FStar_TypeChecker_Cfg.log cfg
-                       (fun uu___6 ->
-                          FStar_Compiler_Util.print_string
-                            "+++ Evaluating DIV Tm_let\n");
-                     norm cfg env1 stack3 lb.FStar_Syntax_Syntax.lbdef)
-                  else
-                    if
-                      (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak
-                    then
-                      (FStar_TypeChecker_Cfg.log cfg
-                         (fun uu___7 ->
-                            FStar_Compiler_Util.print_string
-                              "+++ Not touching Tm_let\n");
-                       (let uu___7 = closure_as_term cfg env1 t1 in
-                        rebuild cfg env1 stack2 uu___7))
-                    else
-                      (let uu___7 =
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 lb.FStar_Syntax_Syntax.lbname
-                                 FStar_Compiler_Util.left in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___10
-                               FStar_Syntax_Syntax.mk_binder in
-                           [uu___9] in
-                         FStar_Syntax_Subst.open_term uu___8 body in
-                       match uu___7 with
-                       | (bs, body1) ->
-                           (FStar_TypeChecker_Cfg.log cfg
-                              (fun uu___9 ->
-                                 FStar_Compiler_Util.print_string
-                                   "+++ Normalizing Tm_let -- type");
-                            (let ty =
-                               norm cfg env1 [] lb.FStar_Syntax_Syntax.lbtyp in
-                             let lbname =
-                               let x =
-                                 let uu___9 = FStar_Compiler_List.hd bs in
-                                 uu___9.FStar_Syntax_Syntax.binder_bv in
-                               FStar_Pervasives.Inl
-                                 {
-                                   FStar_Syntax_Syntax.ppname =
-                                     (x.FStar_Syntax_Syntax.ppname);
-                                   FStar_Syntax_Syntax.index =
-                                     (x.FStar_Syntax_Syntax.index);
-                                   FStar_Syntax_Syntax.sort = ty
-                                 } in
-                             FStar_TypeChecker_Cfg.log cfg
-                               (fun uu___10 ->
-                                  FStar_Compiler_Util.print_string
-                                    "+++ Normalizing Tm_let -- definiens\n");
-                             (let lb1 =
-                                let uu___10 =
-                                  norm cfg env1 []
-                                    lb.FStar_Syntax_Syntax.lbdef in
-                                let uu___11 =
-                                  FStar_Compiler_List.map (norm cfg env1 [])
-                                    lb.FStar_Syntax_Syntax.lbattrs in
-                                {
-                                  FStar_Syntax_Syntax.lbname = lbname;
-                                  FStar_Syntax_Syntax.lbunivs =
-                                    (lb.FStar_Syntax_Syntax.lbunivs);
-                                  FStar_Syntax_Syntax.lbtyp = ty;
-                                  FStar_Syntax_Syntax.lbeff =
-                                    (lb.FStar_Syntax_Syntax.lbeff);
-                                  FStar_Syntax_Syntax.lbdef = uu___10;
-                                  FStar_Syntax_Syntax.lbattrs = uu___11;
-                                  FStar_Syntax_Syntax.lbpos =
-                                    (lb.FStar_Syntax_Syntax.lbpos)
-                                } in
-                              let env' =
-                                FStar_Compiler_Effect.op_Bar_Greater bs
-                                  (FStar_Compiler_List.fold_left
-                                     (fun env2 ->
-                                        fun uu___10 -> dummy :: env2) env1) in
-                              let stack3 =
-                                (Cfg (cfg, FStar_Pervasives_Native.None)) ::
-                                stack2 in
-                              let cfg1 =
-                                {
-                                  FStar_TypeChecker_Cfg.steps =
-                                    (cfg.FStar_TypeChecker_Cfg.steps);
-                                  FStar_TypeChecker_Cfg.tcenv =
-                                    (cfg.FStar_TypeChecker_Cfg.tcenv);
-                                  FStar_TypeChecker_Cfg.debug =
-                                    (cfg.FStar_TypeChecker_Cfg.debug);
-                                  FStar_TypeChecker_Cfg.delta_level =
-                                    (cfg.FStar_TypeChecker_Cfg.delta_level);
-                                  FStar_TypeChecker_Cfg.primitive_steps =
-                                    (cfg.FStar_TypeChecker_Cfg.primitive_steps);
-                                  FStar_TypeChecker_Cfg.strong = true;
-                                  FStar_TypeChecker_Cfg.memoize_lazy =
-                                    (cfg.FStar_TypeChecker_Cfg.memoize_lazy);
-                                  FStar_TypeChecker_Cfg.normalize_pure_lets =
-                                    (cfg.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                                  FStar_TypeChecker_Cfg.reifying =
-                                    (cfg.FStar_TypeChecker_Cfg.reifying)
-                                } in
-                              FStar_TypeChecker_Cfg.log cfg1
-                                (fun uu___11 ->
-                                   FStar_Compiler_Util.print_string
-                                     "+++ Normalizing Tm_let -- body\n");
-                              norm cfg1 env'
-                                ((Let
-                                    (env1, bs, lb1,
-                                      (t1.FStar_Syntax_Syntax.pos))) ::
-                                stack3) body1)))))
-           | FStar_Syntax_Syntax.Tm_let ((true, lbs), body) when
-               (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.compress_uvars
-                 ||
-                 (((Prims.op_Negation
-                      (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta)
-                     &&
-                     (Prims.op_Negation
-                        (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta_full))
-                    &&
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.pure_subterms_within_computations)
-               ->
-               let uu___2 = FStar_Syntax_Subst.open_let_rec lbs body in
-               (match uu___2 with
-                | (lbs1, body1) ->
-                    let lbs2 =
-                      FStar_Compiler_List.map
-                        (fun lb ->
-                           let ty =
-                             norm cfg env1 [] lb.FStar_Syntax_Syntax.lbtyp in
-                           let lbname =
-                             let uu___3 =
-                               let uu___4 =
-                                 FStar_Compiler_Util.left
-                                   lb.FStar_Syntax_Syntax.lbname in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (uu___4.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (uu___4.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = ty
-                               } in
-                             FStar_Pervasives.Inl uu___3 in
-                           let uu___3 =
-                             FStar_Syntax_Util.abs_formals
-                               lb.FStar_Syntax_Syntax.lbdef in
-                           match uu___3 with
-                           | (xs, def_body, lopt) ->
-                               let xs1 = norm_binders cfg env1 xs in
-                               let env2 =
-                                 let uu___4 =
-                                   FStar_Compiler_List.map
-                                     (fun uu___5 -> dummy) xs1 in
-                                 let uu___5 =
-                                   let uu___6 =
-                                     FStar_Compiler_List.map
-                                       (fun uu___7 -> dummy) lbs1 in
-                                   FStar_Compiler_List.op_At uu___6 env1 in
-                                 FStar_Compiler_List.op_At uu___4 uu___5 in
-                               let def_body1 = norm cfg env2 [] def_body in
-                               let lopt1 =
-                                 match lopt with
-                                 | FStar_Pervasives_Native.Some rc ->
-                                     let uu___4 =
-                                       let uu___5 =
-                                         FStar_Compiler_Util.map_opt
-                                           rc.FStar_Syntax_Syntax.residual_typ
-                                           (norm cfg env2 []) in
-                                       {
-                                         FStar_Syntax_Syntax.residual_effect
-                                           =
-                                           (rc.FStar_Syntax_Syntax.residual_effect);
-                                         FStar_Syntax_Syntax.residual_typ =
-                                           uu___5;
-                                         FStar_Syntax_Syntax.residual_flags =
-                                           (rc.FStar_Syntax_Syntax.residual_flags)
-                                       } in
-                                     FStar_Pervasives_Native.Some uu___4
-                                 | uu___4 -> lopt in
-                               let def =
-                                 FStar_Syntax_Util.abs xs1 def_body1 lopt1 in
-                               {
-                                 FStar_Syntax_Syntax.lbname = lbname;
-                                 FStar_Syntax_Syntax.lbunivs =
-                                   (lb.FStar_Syntax_Syntax.lbunivs);
-                                 FStar_Syntax_Syntax.lbtyp = ty;
-                                 FStar_Syntax_Syntax.lbeff =
-                                   (lb.FStar_Syntax_Syntax.lbeff);
-                                 FStar_Syntax_Syntax.lbdef = def;
-                                 FStar_Syntax_Syntax.lbattrs =
-                                   (lb.FStar_Syntax_Syntax.lbattrs);
-                                 FStar_Syntax_Syntax.lbpos =
-                                   (lb.FStar_Syntax_Syntax.lbpos)
-                               }) lbs1 in
-                    let env' =
-                      let uu___3 =
-                        FStar_Compiler_List.map (fun uu___4 -> dummy) lbs2 in
-                      FStar_Compiler_List.op_At uu___3 env1 in
-                    let body2 = norm cfg env' [] body1 in
-                    let uu___3 = FStar_Syntax_Subst.close_let_rec lbs2 body2 in
-                    (match uu___3 with
-                     | (lbs3, body3) ->
-                         let t2 =
-                           {
-                             FStar_Syntax_Syntax.n =
-                               (FStar_Syntax_Syntax.Tm_let
-                                  ((true, lbs3), body3));
-                             FStar_Syntax_Syntax.pos =
-                               (t1.FStar_Syntax_Syntax.pos);
-                             FStar_Syntax_Syntax.vars =
-                               (t1.FStar_Syntax_Syntax.vars);
-                             FStar_Syntax_Syntax.hash_code =
-                               (t1.FStar_Syntax_Syntax.hash_code)
-                           } in
-                         rebuild cfg env1 stack2 t2))
-           | FStar_Syntax_Syntax.Tm_let (lbs, body) when
-               (Prims.op_Negation
-                  (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta)
-                 &&
-                 (Prims.op_Negation
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta_full)
-               ->
-               let uu___2 = closure_as_term cfg env1 t1 in
-               rebuild cfg env1 stack2 uu___2
-           | FStar_Syntax_Syntax.Tm_let (lbs, body) ->
-               let uu___2 =
-                 FStar_Compiler_List.fold_right
-                   (fun lb ->
-                      fun uu___3 ->
-                        match uu___3 with
-                        | (rec_env, memos, i) ->
-                            let bv =
-                              let uu___4 =
-                                FStar_Compiler_Util.left
-                                  lb.FStar_Syntax_Syntax.lbname in
-                              {
-                                FStar_Syntax_Syntax.ppname =
-                                  (uu___4.FStar_Syntax_Syntax.ppname);
-                                FStar_Syntax_Syntax.index = i;
-                                FStar_Syntax_Syntax.sort =
-                                  (uu___4.FStar_Syntax_Syntax.sort)
-                              } in
-                            let f_i = FStar_Syntax_Syntax.bv_to_tm bv in
-                            let fix_f_i =
-                              FStar_Syntax_Syntax.mk
-                                (FStar_Syntax_Syntax.Tm_let (lbs, f_i))
-                                t1.FStar_Syntax_Syntax.pos in
-                            let memo =
-                              FStar_Compiler_Util.mk_ref
-                                FStar_Pervasives_Native.None in
-                            let rec_env1 =
-                              (FStar_Pervasives_Native.None,
-                                (Clos (env1, fix_f_i, memo, true)))
-                              :: rec_env in
-                            (rec_env1, (memo :: memos), (i + Prims.int_one)))
-                   (FStar_Pervasives_Native.snd lbs)
-                   (env1, [], Prims.int_zero) in
-               (match uu___2 with
-                | (rec_env, memos, uu___3) ->
-                    let uu___4 =
-                      FStar_Compiler_List.map2
-                        (fun lb ->
-                           fun memo ->
-                             FStar_Compiler_Effect.op_Colon_Equals memo
-                               (FStar_Pervasives_Native.Some
-                                  (rec_env, (lb.FStar_Syntax_Syntax.lbdef))))
-                        (FStar_Pervasives_Native.snd lbs) memos in
-                    let body_env =
-                      FStar_Compiler_List.fold_right
-                        (fun lb ->
-                           fun env2 ->
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Compiler_Util.mk_ref
-                                       FStar_Pervasives_Native.None in
-                                   (rec_env, (lb.FStar_Syntax_Syntax.lbdef),
-                                     uu___8, false) in
-                                 Clos uu___7 in
-                               (FStar_Pervasives_Native.None, uu___6) in
-                             uu___5 :: env2)
-                        (FStar_Pervasives_Native.snd lbs) env1 in
-                    norm cfg body_env stack2 body)
-           | FStar_Syntax_Syntax.Tm_meta (head, m) ->
-               (FStar_TypeChecker_Cfg.log cfg
-                  (fun uu___3 ->
-                     let uu___4 = FStar_Syntax_Print.metadata_to_string m in
-                     FStar_Compiler_Util.print1 ">> metadata = %s\n" uu___4);
-                (match m with
-                 | FStar_Syntax_Syntax.Meta_monadic (m_from, ty) ->
-                     if
-                       (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                     then
-                       let uu___3 =
-                         (FStar_TypeChecker_Env.is_erasable_effect
-                            cfg.FStar_TypeChecker_Cfg.tcenv m_from)
-                           ||
-                           ((FStar_Syntax_Util.is_pure_effect m_from) &&
-                              (FStar_TypeChecker_Env.non_informative
-                                 cfg.FStar_TypeChecker_Cfg.tcenv ty)) in
-                       (if uu___3
-                        then
-                          let uu___4 =
-                            FStar_Syntax_Syntax.mk
-                              (FStar_Syntax_Syntax.Tm_meta
-                                 (FStar_Syntax_Util.exp_unit, m))
-                              t1.FStar_Syntax_Syntax.pos in
-                          rebuild cfg env1 stack2 uu___4
-                        else
-                          reduce_impure_comp cfg env1 stack2 head
-                            (FStar_Pervasives.Inl m_from) ty)
-                     else
-                       reduce_impure_comp cfg env1 stack2 head
-                         (FStar_Pervasives.Inl m_from) ty
-                 | FStar_Syntax_Syntax.Meta_monadic_lift (m_from, m_to, ty)
-                     ->
-                     if
-                       (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                     then
-                       let uu___3 =
-                         ((FStar_TypeChecker_Env.is_erasable_effect
-                             cfg.FStar_TypeChecker_Cfg.tcenv m_from)
-                            ||
-                            (FStar_TypeChecker_Env.is_erasable_effect
-                               cfg.FStar_TypeChecker_Cfg.tcenv m_to))
-                           ||
-                           ((FStar_Syntax_Util.is_pure_effect m_from) &&
-                              (FStar_TypeChecker_Env.non_informative
-                                 cfg.FStar_TypeChecker_Cfg.tcenv ty)) in
-                       (if uu___3
-                        then
-                          let uu___4 =
-                            FStar_Syntax_Syntax.mk
-                              (FStar_Syntax_Syntax.Tm_meta
-                                 (FStar_Syntax_Util.exp_unit, m))
-                              t1.FStar_Syntax_Syntax.pos in
-                          rebuild cfg env1 stack2 uu___4
-                        else
-                          reduce_impure_comp cfg env1 stack2 head
-                            (FStar_Pervasives.Inr (m_from, m_to)) ty)
-                     else
-                       reduce_impure_comp cfg env1 stack2 head
-                         (FStar_Pervasives.Inr (m_from, m_to)) ty
-                 | uu___3 ->
-                     if
-                       (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unmeta
-                     then norm cfg env1 stack2 head
-                     else
-                       (match stack2 with
-                        | uu___5::uu___6 ->
-                            (match m with
-                             | FStar_Syntax_Syntax.Meta_labeled
-                                 (l, r, uu___7) ->
-                                 norm cfg env1 ((Meta (env1, m, r)) ::
-                                   stack2) head
-                             | FStar_Syntax_Syntax.Meta_pattern (names, args)
-                                 ->
-                                 let args1 = norm_pattern_args cfg env1 args in
-                                 let names1 =
-                                   FStar_Compiler_Effect.op_Bar_Greater names
-                                     (FStar_Compiler_List.map
-                                        (norm cfg env1 [])) in
-                                 norm cfg env1
-                                   ((Meta
-                                       (env1,
-                                         (FStar_Syntax_Syntax.Meta_pattern
-                                            (names1, args1)),
-                                         (t1.FStar_Syntax_Syntax.pos))) ::
-                                   stack2) head
-                             | FStar_Syntax_Syntax.Meta_desugared
-                                 (FStar_Syntax_Syntax.Machine_integer
-                                 (uu___7, uu___8)) ->
-                                 norm cfg env1
-                                   ((Meta
-                                       (env1, m,
-                                         (t1.FStar_Syntax_Syntax.pos))) ::
-                                   stack2) head
-                             | uu___7 -> norm cfg env1 stack2 head)
-                        | [] ->
-                            let head1 = norm cfg env1 [] head in
-                            let m1 =
-                              match m with
-                              | FStar_Syntax_Syntax.Meta_pattern
-                                  (names, args) ->
-                                  let names1 =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      names
-                                      (FStar_Compiler_List.map
-                                         (norm cfg env1 [])) in
-                                  let uu___5 =
-                                    let uu___6 =
-                                      norm_pattern_args cfg env1 args in
-                                    (names1, uu___6) in
-                                  FStar_Syntax_Syntax.Meta_pattern uu___5
-                              | uu___5 -> m in
-                            let t2 =
-                              FStar_Syntax_Syntax.mk
-                                (FStar_Syntax_Syntax.Tm_meta (head1, m1))
-                                t1.FStar_Syntax_Syntax.pos in
-                            rebuild cfg env1 stack2 t2)))
-           | FStar_Syntax_Syntax.Tm_delayed uu___2 ->
-               failwith "impossible: Tm_delayed on norm"
-           | FStar_Syntax_Syntax.Tm_uvar uu___2 ->
-               if
-                 (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.check_no_uvars
-               then
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Compiler_Range.string_of_range
-                       t1.FStar_Syntax_Syntax.pos in
-                   let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                   FStar_Compiler_Util.format2
-                     "(%s) CheckNoUvars: Unexpected unification variable remains: %s"
-                     uu___4 uu___5 in
-                 failwith uu___3
-               else
-                 (let uu___4 = inline_closure_env cfg env1 [] t1 in
-                  rebuild cfg env1 stack2 uu___4))
-and (do_unfold_fv :
-  FStar_TypeChecker_Cfg.cfg ->
-    stack_elt Prims.list ->
-      FStar_Syntax_Syntax.term ->
-        FStar_TypeChecker_Env.qninfo ->
-          FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun stack1 ->
-      fun t0 ->
-        fun qninfo ->
-          fun f ->
-            let uu___ =
-              FStar_TypeChecker_Env.lookup_definition_qninfo
-                cfg.FStar_TypeChecker_Cfg.delta_level
-                (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v qninfo in
-            match uu___ with
-            | FStar_Pervasives_Native.None ->
-                (FStar_TypeChecker_Cfg.log_unfolding cfg
-                   (fun uu___2 ->
-                      let uu___3 = FStar_Syntax_Print.fv_to_string f in
-                      FStar_Compiler_Util.print1
-                        " >> Tm_fvar case 2 for %s\n" uu___3);
-                 rebuild cfg empty_env stack1 t0)
-            | FStar_Pervasives_Native.Some (us, t) ->
-                (FStar_TypeChecker_Cfg.log_unfolding cfg
-                   (fun uu___2 ->
-                      let uu___3 = FStar_Syntax_Print.term_to_string t0 in
-                      let uu___4 = FStar_Syntax_Print.term_to_string t in
-                      FStar_Compiler_Util.print2 " >> Unfolded %s to %s\n"
-                        uu___3 uu___4);
-                 (let t1 =
-                    if
-                      (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.unfold_until
-                        =
-                        (FStar_Pervasives_Native.Some
-                           FStar_Syntax_Syntax.delta_constant)
-                    then t
-                    else
-                      FStar_Syntax_Subst.set_use_range
-                        t0.FStar_Syntax_Syntax.pos t in
-                  let n = FStar_Compiler_List.length us in
-                  if n > Prims.int_zero
-                  then
-                    match stack1 with
-                    | (UnivArgs (us', uu___2))::stack2 ->
-                        ((let uu___4 =
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_TypeChecker_Env.debug
-                                 cfg.FStar_TypeChecker_Cfg.tcenv)
-                              (FStar_Options.Other "univ_norm") in
-                          if uu___4
-                          then
-                            FStar_Compiler_List.iter
-                              (fun x ->
-                                 let uu___5 =
-                                   FStar_Syntax_Print.univ_to_string x in
-                                 FStar_Compiler_Util.print1
-                                   "Univ (normalizer) %s\n" uu___5) us'
-                          else ());
-                         (let env1 =
-                            FStar_Compiler_Effect.op_Bar_Greater us'
-                              (FStar_Compiler_List.fold_left
-                                 (fun env2 ->
-                                    fun u ->
-                                      (FStar_Pervasives_Native.None,
-                                        (Univ u))
-                                      :: env2) empty_env) in
-                          norm cfg env1 stack2 t1))
-                    | uu___2 when
-                        (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.erase_universes
-                          ||
-                          (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.allow_unbound_universes
-                        -> norm cfg empty_env stack1 t1
-                    | uu___2 ->
-                        let uu___3 =
-                          let uu___4 =
-                            FStar_Syntax_Print.lid_to_string
-                              (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                          FStar_Compiler_Util.format1
-                            "Impossible: missing universe instantiation on %s"
-                            uu___4 in
-                        failwith uu___3
-                  else norm cfg empty_env stack1 t1))
-and (reduce_impure_comp :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      stack_elt Prims.list ->
-        FStar_Syntax_Syntax.term ->
-          (FStar_Syntax_Syntax.monad_name,
-            (FStar_Syntax_Syntax.monad_name * FStar_Syntax_Syntax.monad_name))
-            FStar_Pervasives.either ->
-            FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun head ->
-          fun m ->
-            fun t ->
-              let t1 = norm cfg env1 [] t in
-              let metadata =
-                match m with
-                | FStar_Pervasives.Inl m1 ->
-                    FStar_Syntax_Syntax.Meta_monadic (m1, t1)
-                | FStar_Pervasives.Inr (m1, m') ->
-                    FStar_Syntax_Syntax.Meta_monadic_lift (m1, m', t1) in
-              norm cfg env1
-                ((Meta (env1, metadata, (head.FStar_Syntax_Syntax.pos))) ::
-                stack1) head
-and (do_reify_monadic :
-  (unit -> FStar_Syntax_Syntax.term) ->
-    FStar_TypeChecker_Cfg.cfg ->
-      env ->
-        stack_elt Prims.list ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Syntax_Syntax.monad_name ->
-              FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  =
-  fun fallback ->
-    fun cfg ->
-      fun env1 ->
-        fun stack1 ->
-          fun top ->
-            fun m ->
-              fun t ->
-                (match stack1 with
-                 | (App
-                     (uu___1,
-                      {
-                        FStar_Syntax_Syntax.n =
-                          FStar_Syntax_Syntax.Tm_constant
-                          (FStar_Const.Const_reify);
-                        FStar_Syntax_Syntax.pos = uu___2;
-                        FStar_Syntax_Syntax.vars = uu___3;
-                        FStar_Syntax_Syntax.hash_code = uu___4;_},
-                      uu___5, uu___6))::uu___7
-                     -> ()
-                 | uu___1 ->
-                     let uu___2 =
-                       let uu___3 = stack_to_string stack1 in
-                       FStar_Compiler_Util.format1
-                         "INTERNAL ERROR: do_reify_monadic: bad stack: %s"
-                         uu___3 in
-                     failwith uu___2);
-                (let top0 = top in
-                 let top1 = FStar_Syntax_Util.unascribe top in
-                 FStar_TypeChecker_Cfg.log cfg
-                   (fun uu___2 ->
-                      let uu___3 = FStar_Syntax_Print.tag_of_term top1 in
-                      let uu___4 = FStar_Syntax_Print.term_to_string top1 in
-                      FStar_Compiler_Util.print2 "Reifying: (%s) %s\n" uu___3
-                        uu___4);
-                 (let top2 = FStar_Syntax_Util.unmeta_safe top1 in
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Subst.compress top2 in
-                    uu___3.FStar_Syntax_Syntax.n in
-                  match uu___2 with
-                  | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), body) ->
-                      let eff_name =
-                        FStar_TypeChecker_Env.norm_eff_name
-                          cfg.FStar_TypeChecker_Cfg.tcenv m in
-                      let ed =
-                        FStar_TypeChecker_Env.get_effect_decl
-                          cfg.FStar_TypeChecker_Cfg.tcenv eff_name in
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Compiler_Effect.op_Bar_Greater ed
-                            FStar_Syntax_Util.get_eff_repr in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___4
-                          FStar_Compiler_Util.must in
-                      (match uu___3 with
-                       | (uu___4, repr) ->
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Compiler_Effect.op_Bar_Greater ed
-                                 FStar_Syntax_Util.get_bind_repr in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___6
-                               FStar_Compiler_Util.must in
-                           (match uu___5 with
-                            | (uu___6, bind_repr) ->
-                                (match lb.FStar_Syntax_Syntax.lbname with
-                                 | FStar_Pervasives.Inr uu___7 ->
-                                     failwith
-                                       "Cannot reify a top-level let binding"
-                                 | FStar_Pervasives.Inl x ->
-                                     let is_return e =
-                                       let uu___7 =
-                                         let uu___8 =
-                                           FStar_Syntax_Subst.compress e in
-                                         uu___8.FStar_Syntax_Syntax.n in
-                                       match uu___7 with
-                                       | FStar_Syntax_Syntax.Tm_meta
-                                           (e1,
-                                            FStar_Syntax_Syntax.Meta_monadic
-                                            (uu___8, uu___9))
-                                           ->
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_Syntax_Subst.compress e1 in
-                                             uu___11.FStar_Syntax_Syntax.n in
-                                           (match uu___10 with
-                                            | FStar_Syntax_Syntax.Tm_meta
-                                                (e2,
-                                                 FStar_Syntax_Syntax.Meta_monadic_lift
-                                                 (uu___11, msrc, uu___12))
-                                                when
-                                                FStar_Syntax_Util.is_pure_effect
-                                                  msrc
-                                                ->
-                                                let uu___13 =
-                                                  FStar_Syntax_Subst.compress
-                                                    e2 in
-                                                FStar_Pervasives_Native.Some
-                                                  uu___13
-                                            | uu___11 ->
-                                                FStar_Pervasives_Native.None)
-                                       | uu___8 ->
-                                           FStar_Pervasives_Native.None in
-                                     let uu___7 =
-                                       is_return lb.FStar_Syntax_Syntax.lbdef in
-                                     (match uu___7 with
-                                      | FStar_Pervasives_Native.Some e ->
-                                          let lb1 =
-                                            {
-                                              FStar_Syntax_Syntax.lbname =
-                                                (lb.FStar_Syntax_Syntax.lbname);
-                                              FStar_Syntax_Syntax.lbunivs =
-                                                (lb.FStar_Syntax_Syntax.lbunivs);
-                                              FStar_Syntax_Syntax.lbtyp =
-                                                (lb.FStar_Syntax_Syntax.lbtyp);
-                                              FStar_Syntax_Syntax.lbeff =
-                                                FStar_Parser_Const.effect_PURE_lid;
-                                              FStar_Syntax_Syntax.lbdef = e;
-                                              FStar_Syntax_Syntax.lbattrs =
-                                                (lb.FStar_Syntax_Syntax.lbattrs);
-                                              FStar_Syntax_Syntax.lbpos =
-                                                (lb.FStar_Syntax_Syntax.lbpos)
-                                            } in
-                                          let uu___8 =
-                                            FStar_Compiler_List.tl stack1 in
-                                          let uu___9 =
-                                            let uu___10 =
-                                              let uu___11 =
-                                                let uu___12 =
-                                                  FStar_Syntax_Util.mk_reify
-                                                    body in
-                                                ((false, [lb1]), uu___12) in
-                                              FStar_Syntax_Syntax.Tm_let
-                                                uu___11 in
-                                            FStar_Syntax_Syntax.mk uu___10
-                                              top2.FStar_Syntax_Syntax.pos in
-                                          norm cfg env1 uu___8 uu___9
-                                      | FStar_Pervasives_Native.None ->
-                                          let uu___8 =
-                                            let uu___9 = is_return body in
-                                            match uu___9 with
-                                            | FStar_Pervasives_Native.Some
-                                                {
-                                                  FStar_Syntax_Syntax.n =
-                                                    FStar_Syntax_Syntax.Tm_bvar
-                                                    y;
-                                                  FStar_Syntax_Syntax.pos =
-                                                    uu___10;
-                                                  FStar_Syntax_Syntax.vars =
-                                                    uu___11;
-                                                  FStar_Syntax_Syntax.hash_code
-                                                    = uu___12;_}
-                                                ->
-                                                FStar_Syntax_Syntax.bv_eq x y
-                                            | uu___10 -> false in
-                                          if uu___8
-                                          then
-                                            norm cfg env1 stack1
-                                              lb.FStar_Syntax_Syntax.lbdef
-                                          else
-                                            (let rng =
-                                               top2.FStar_Syntax_Syntax.pos in
-                                             let head =
-                                               FStar_Compiler_Effect.op_Less_Bar
-                                                 FStar_Syntax_Util.mk_reify
-                                                 lb.FStar_Syntax_Syntax.lbdef in
-                                             let body1 =
-                                               FStar_Compiler_Effect.op_Less_Bar
-                                                 FStar_Syntax_Util.mk_reify
-                                                 body in
-                                             let body_rc =
-                                               {
-                                                 FStar_Syntax_Syntax.residual_effect
-                                                   = m;
-                                                 FStar_Syntax_Syntax.residual_typ
-                                                   =
-                                                   (FStar_Pervasives_Native.Some
-                                                      t);
-                                                 FStar_Syntax_Syntax.residual_flags
-                                                   = []
-                                               } in
-                                             let body2 =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   let uu___12 =
-                                                     let uu___13 =
-                                                       FStar_Syntax_Syntax.mk_binder
-                                                         x in
-                                                     [uu___13] in
-                                                   (uu___12, body1,
-                                                     (FStar_Pervasives_Native.Some
-                                                        body_rc)) in
-                                                 FStar_Syntax_Syntax.Tm_abs
-                                                   uu___11 in
-                                               FStar_Syntax_Syntax.mk uu___10
-                                                 body1.FStar_Syntax_Syntax.pos in
-                                             let close =
-                                               closure_as_term cfg env1 in
-                                             let bind_inst =
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   FStar_Syntax_Subst.compress
-                                                     bind_repr in
-                                                 uu___11.FStar_Syntax_Syntax.n in
-                                               match uu___10 with
-                                               | FStar_Syntax_Syntax.Tm_uinst
-                                                   (bind,
-                                                    uu___11::uu___12::[])
-                                                   ->
-                                                   let uu___13 =
-                                                     let uu___14 =
-                                                       let uu___15 =
-                                                         let uu___16 =
-                                                           let uu___17 =
-                                                             close
-                                                               lb.FStar_Syntax_Syntax.lbtyp in
-                                                           (cfg.FStar_TypeChecker_Cfg.tcenv).FStar_TypeChecker_Env.universe_of
-                                                             cfg.FStar_TypeChecker_Cfg.tcenv
-                                                             uu___17 in
-                                                         let uu___17 =
-                                                           let uu___18 =
-                                                             let uu___19 =
-                                                               close t in
-                                                             (cfg.FStar_TypeChecker_Cfg.tcenv).FStar_TypeChecker_Env.universe_of
-                                                               cfg.FStar_TypeChecker_Cfg.tcenv
-                                                               uu___19 in
-                                                           [uu___18] in
-                                                         uu___16 :: uu___17 in
-                                                       (bind, uu___15) in
-                                                     FStar_Syntax_Syntax.Tm_uinst
-                                                       uu___14 in
-                                                   FStar_Syntax_Syntax.mk
-                                                     uu___13 rng
-                                               | uu___11 ->
-                                                   failwith
-                                                     "NIY : Reification of indexed effects" in
-                                             let bind_inst_args f_arg =
-                                               let uu___10 =
-                                                 FStar_Syntax_Util.is_layered
-                                                   ed in
-                                               if uu___10
-                                               then
-                                                 let bind_has_range_args =
-                                                   FStar_Syntax_Util.has_attribute
-                                                     ed.FStar_Syntax_Syntax.eff_attrs
-                                                     FStar_Parser_Const.bind_has_range_args_attr in
-                                                 let num_fixed_binders =
-                                                   if bind_has_range_args
-                                                   then (Prims.of_int (4))
-                                                   else (Prims.of_int (2)) in
-                                                 let unit_args =
-                                                   let uu___11 =
-                                                     let uu___12 =
-                                                       let uu___13 =
-                                                         let uu___14 =
-                                                           let uu___15 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               ed
-                                                               FStar_Syntax_Util.get_bind_vc_combinator in
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uu___15
-                                                             FStar_Pervasives_Native.fst in
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           uu___14
-                                                           FStar_Pervasives_Native.snd in
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         uu___13
-                                                         FStar_Syntax_Subst.compress in
-                                                     uu___12.FStar_Syntax_Syntax.n in
-                                                   match uu___11 with
-                                                   | FStar_Syntax_Syntax.Tm_arrow
-                                                       (uu___12::uu___13::bs,
-                                                        uu___14)
-                                                       when
-                                                       (FStar_Compiler_List.length
-                                                          bs)
-                                                         >= num_fixed_binders
-                                                       ->
-                                                       let uu___15 =
-                                                         let uu___16 =
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             bs
-                                                             (FStar_Compiler_List.splitAt
-                                                                ((FStar_Compiler_List.length
-                                                                    bs)
-                                                                   -
-                                                                   num_fixed_binders)) in
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           uu___16
-                                                           FStar_Pervasives_Native.fst in
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         uu___15
-                                                         (FStar_Compiler_List.map
-                                                            (fun uu___16 ->
-                                                               FStar_Syntax_Syntax.as_arg
-                                                                 FStar_Syntax_Syntax.unit_const))
-                                                   | uu___12 ->
-                                                       let uu___13 =
-                                                         let uu___14 =
-                                                           let uu___15 =
-                                                             FStar_Ident.string_of_lid
-                                                               ed.FStar_Syntax_Syntax.mname in
-                                                           let uu___16 =
-                                                             FStar_Compiler_Util.string_of_int
-                                                               num_fixed_binders in
-                                                           let uu___17 =
-                                                             let uu___18 =
-                                                               let uu___19 =
-                                                                 let uu___20
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    ed
-                                                                    FStar_Syntax_Util.get_bind_vc_combinator in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___20
-                                                                   FStar_Pervasives_Native.fst in
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 uu___19
-                                                                 FStar_Pervasives_Native.snd in
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               uu___18
-                                                               FStar_Syntax_Print.term_to_string in
-                                                           FStar_Compiler_Util.format3
-                                                             "bind_wp for layered effect %s is not an arrow with >= %s arguments (%s)"
-                                                             uu___15 uu___16
-                                                             uu___17 in
-                                                         (FStar_Errors.Fatal_UnexpectedEffect,
-                                                           uu___14) in
-                                                       FStar_Errors.raise_error
-                                                         uu___13 rng in
-                                                 let range_args =
-                                                   if bind_has_range_args
-                                                   then
-                                                     let uu___11 =
-                                                       let uu___12 =
-                                                         FStar_TypeChecker_Cfg.embed_simple
-                                                           FStar_Syntax_Embeddings.e_range
-                                                           lb.FStar_Syntax_Syntax.lbpos
-                                                           lb.FStar_Syntax_Syntax.lbpos in
-                                                       FStar_Syntax_Syntax.as_arg
-                                                         uu___12 in
-                                                     let uu___12 =
-                                                       let uu___13 =
-                                                         let uu___14 =
-                                                           FStar_TypeChecker_Cfg.embed_simple
-                                                             FStar_Syntax_Embeddings.e_range
-                                                             body2.FStar_Syntax_Syntax.pos
-                                                             body2.FStar_Syntax_Syntax.pos in
-                                                         FStar_Syntax_Syntax.as_arg
-                                                           uu___14 in
-                                                       [uu___13] in
-                                                     uu___11 :: uu___12
-                                                   else [] in
-                                                 let uu___11 =
-                                                   FStar_Syntax_Syntax.as_arg
-                                                     lb.FStar_Syntax_Syntax.lbtyp in
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     FStar_Syntax_Syntax.as_arg
-                                                       t in
-                                                   let uu___14 =
-                                                     let uu___15 =
-                                                       let uu___16 =
-                                                         let uu___17 =
-                                                           FStar_Syntax_Syntax.as_arg
-                                                             f_arg in
-                                                         let uu___18 =
-                                                           let uu___19 =
-                                                             FStar_Syntax_Syntax.as_arg
-                                                               body2 in
-                                                           [uu___19] in
-                                                         uu___17 :: uu___18 in
-                                                       FStar_Compiler_List.op_At
-                                                         range_args uu___16 in
-                                                     FStar_Compiler_List.op_At
-                                                       unit_args uu___15 in
-                                                   uu___13 :: uu___14 in
-                                                 uu___11 :: uu___12
-                                               else
-                                                 (let maybe_range_arg =
-                                                    let uu___12 =
-                                                      FStar_Compiler_Util.for_some
-                                                        (FStar_Syntax_Util.attr_eq
-                                                           FStar_Syntax_Util.dm4f_bind_range_attr)
-                                                        ed.FStar_Syntax_Syntax.eff_attrs in
-                                                    if uu___12
-                                                    then
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          FStar_TypeChecker_Cfg.embed_simple
-                                                            FStar_Syntax_Embeddings.e_range
-                                                            lb.FStar_Syntax_Syntax.lbpos
-                                                            lb.FStar_Syntax_Syntax.lbpos in
-                                                        FStar_Syntax_Syntax.as_arg
-                                                          uu___14 in
-                                                      let uu___14 =
-                                                        let uu___15 =
-                                                          let uu___16 =
-                                                            FStar_TypeChecker_Cfg.embed_simple
-                                                              FStar_Syntax_Embeddings.e_range
-                                                              body2.FStar_Syntax_Syntax.pos
-                                                              body2.FStar_Syntax_Syntax.pos in
-                                                          FStar_Syntax_Syntax.as_arg
-                                                            uu___16 in
-                                                        [uu___15] in
-                                                      uu___13 :: uu___14
-                                                    else [] in
-                                                  let uu___12 =
-                                                    let uu___13 =
-                                                      FStar_Syntax_Syntax.as_arg
-                                                        lb.FStar_Syntax_Syntax.lbtyp in
-                                                    let uu___14 =
-                                                      let uu___15 =
-                                                        FStar_Syntax_Syntax.as_arg
-                                                          t in
-                                                      [uu___15] in
-                                                    uu___13 :: uu___14 in
-                                                  let uu___13 =
-                                                    let uu___14 =
-                                                      let uu___15 =
-                                                        FStar_Syntax_Syntax.as_arg
-                                                          FStar_Syntax_Syntax.tun in
-                                                      let uu___16 =
-                                                        let uu___17 =
-                                                          FStar_Syntax_Syntax.as_arg
-                                                            f_arg in
-                                                        let uu___18 =
-                                                          let uu___19 =
-                                                            FStar_Syntax_Syntax.as_arg
-                                                              FStar_Syntax_Syntax.tun in
-                                                          let uu___20 =
-                                                            let uu___21 =
-                                                              FStar_Syntax_Syntax.as_arg
-                                                                body2 in
-                                                            [uu___21] in
-                                                          uu___19 :: uu___20 in
-                                                        uu___17 :: uu___18 in
-                                                      uu___15 :: uu___16 in
-                                                    FStar_Compiler_List.op_At
-                                                      maybe_range_arg uu___14 in
-                                                  FStar_Compiler_List.op_At
-                                                    uu___12 uu___13) in
-                                             let reified =
-                                               let is_total_effect =
-                                                 FStar_TypeChecker_Env.is_total_effect
-                                                   cfg.FStar_TypeChecker_Cfg.tcenv
-                                                   eff_name in
-                                               if is_total_effect
-                                               then
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     let uu___12 =
-                                                       bind_inst_args head in
-                                                     (bind_inst, uu___12) in
-                                                   FStar_Syntax_Syntax.Tm_app
-                                                     uu___11 in
-                                                 FStar_Syntax_Syntax.mk
-                                                   uu___10 rng
-                                               else
-                                                 (let uu___11 =
-                                                    let bv =
-                                                      FStar_Syntax_Syntax.new_bv
-                                                        FStar_Pervasives_Native.None
-                                                        x.FStar_Syntax_Syntax.sort in
-                                                    let lb1 =
-                                                      let uu___12 =
-                                                        let uu___13 =
-                                                          let uu___14 =
-                                                            FStar_Syntax_Syntax.as_arg
-                                                              x.FStar_Syntax_Syntax.sort in
-                                                          [uu___14] in
-                                                        FStar_Syntax_Util.mk_app
-                                                          repr uu___13 in
-                                                      {
-                                                        FStar_Syntax_Syntax.lbname
-                                                          =
-                                                          (FStar_Pervasives.Inl
-                                                             bv);
-                                                        FStar_Syntax_Syntax.lbunivs
-                                                          = [];
-                                                        FStar_Syntax_Syntax.lbtyp
-                                                          = uu___12;
-                                                        FStar_Syntax_Syntax.lbeff
-                                                          =
-                                                          (if is_total_effect
-                                                           then
-                                                             FStar_Parser_Const.effect_Tot_lid
-                                                           else
-                                                             FStar_Parser_Const.effect_Dv_lid);
-                                                        FStar_Syntax_Syntax.lbdef
-                                                          = head;
-                                                        FStar_Syntax_Syntax.lbattrs
-                                                          = [];
-                                                        FStar_Syntax_Syntax.lbpos
-                                                          =
-                                                          (head.FStar_Syntax_Syntax.pos)
-                                                      } in
-                                                    let uu___12 =
-                                                      FStar_Syntax_Syntax.bv_to_name
-                                                        bv in
-                                                    (lb1, bv, uu___12) in
-                                                  match uu___11 with
-                                                  | (lb_head, head_bv, head1)
-                                                      ->
-                                                      let uu___12 =
-                                                        let uu___13 =
-                                                          let uu___14 =
-                                                            let uu___15 =
-                                                              let uu___16 =
-                                                                let uu___17 =
-                                                                  FStar_Syntax_Syntax.mk_binder
-                                                                    head_bv in
-                                                                [uu___17] in
-                                                              FStar_Syntax_Subst.close
-                                                                uu___16 in
-                                                            let uu___16 =
-                                                              let uu___17 =
-                                                                let uu___18 =
-                                                                  let uu___19
-                                                                    =
-                                                                    bind_inst_args
-                                                                    head1 in
-                                                                  (bind_inst,
-                                                                    uu___19) in
-                                                                FStar_Syntax_Syntax.Tm_app
-                                                                  uu___18 in
-                                                              FStar_Syntax_Syntax.mk
-                                                                uu___17 rng in
-                                                            FStar_Compiler_Effect.op_Less_Bar
-                                                              uu___15 uu___16 in
-                                                          ((false, [lb_head]),
-                                                            uu___14) in
-                                                        FStar_Syntax_Syntax.Tm_let
-                                                          uu___13 in
-                                                      FStar_Syntax_Syntax.mk
-                                                        uu___12 rng) in
-                                             FStar_TypeChecker_Cfg.log cfg
-                                               (fun uu___11 ->
-                                                  let uu___12 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      top0 in
-                                                  let uu___13 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      reified in
-                                                  FStar_Compiler_Util.print2
-                                                    "Reified (1) <%s> to %s\n"
-                                                    uu___12 uu___13);
-                                             (let uu___11 =
-                                                FStar_Compiler_List.tl stack1 in
-                                              norm cfg env1 uu___11 reified))))))
-                  | FStar_Syntax_Syntax.Tm_app (head, args) ->
-                      ((let uu___4 = FStar_Options.defensive () in
-                        if uu___4
-                        then
-                          let is_arg_impure uu___5 =
-                            match uu___5 with
-                            | (e, q) ->
-                                let uu___6 =
-                                  let uu___7 = FStar_Syntax_Subst.compress e in
-                                  uu___7.FStar_Syntax_Syntax.n in
-                                (match uu___6 with
-                                 | FStar_Syntax_Syntax.Tm_meta
-                                     (e0,
-                                      FStar_Syntax_Syntax.Meta_monadic_lift
-                                      (m1, m2, t'))
-                                     ->
-                                     let uu___7 =
-                                       FStar_Syntax_Util.is_pure_effect m1 in
-                                     Prims.op_Negation uu___7
-                                 | uu___7 -> false) in
-                          let uu___5 =
-                            let uu___6 =
-                              let uu___7 = FStar_Syntax_Syntax.as_arg head in
-                              uu___7 :: args in
-                            FStar_Compiler_Util.for_some is_arg_impure uu___6 in
-                          (if uu___5
-                           then
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Syntax_Print.term_to_string top2 in
-                                 FStar_Compiler_Util.format1
-                                   "Incompatibility between typechecker and normalizer; this monadic application contains impure terms %s\n"
-                                   uu___8 in
-                               (FStar_Errors.Warning_Defensive, uu___7) in
-                             FStar_Errors.log_issue
-                               top2.FStar_Syntax_Syntax.pos uu___6
-                           else ())
-                        else ());
-                       (let fallback1 uu___4 =
-                          FStar_TypeChecker_Cfg.log cfg
-                            (fun uu___6 ->
-                               let uu___7 =
-                                 FStar_Syntax_Print.term_to_string top0 in
-                               FStar_Compiler_Util.print2
-                                 "Reified (2) <%s> to %s\n" uu___7 "");
-                          (let uu___6 = FStar_Compiler_List.tl stack1 in
-                           let uu___7 = FStar_Syntax_Util.mk_reify top2 in
-                           norm cfg env1 uu___6 uu___7) in
-                        let fallback2 uu___4 =
-                          FStar_TypeChecker_Cfg.log cfg
-                            (fun uu___6 ->
-                               let uu___7 =
-                                 FStar_Syntax_Print.term_to_string top0 in
-                               FStar_Compiler_Util.print2
-                                 "Reified (3) <%s> to %s\n" uu___7 "");
-                          (let uu___6 = FStar_Compiler_List.tl stack1 in
-                           let uu___7 =
-                             FStar_Syntax_Syntax.mk
-                               (FStar_Syntax_Syntax.Tm_meta
-                                  (top2,
-                                    (FStar_Syntax_Syntax.Meta_monadic (m, t))))
-                               top0.FStar_Syntax_Syntax.pos in
-                           norm cfg env1 uu___6 uu___7) in
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Util.un_uinst head in
-                          uu___5.FStar_Syntax_Syntax.n in
-                        match uu___4 with
-                        | FStar_Syntax_Syntax.Tm_fvar fv ->
-                            let lid = FStar_Syntax_Syntax.lid_of_fv fv in
-                            let qninfo =
-                              FStar_TypeChecker_Env.lookup_qname
-                                cfg.FStar_TypeChecker_Cfg.tcenv lid in
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_TypeChecker_Env.is_action
-                                  cfg.FStar_TypeChecker_Cfg.tcenv lid in
-                              Prims.op_Negation uu___6 in
-                            if uu___5
-                            then fallback1 ()
-                            else
-                              (let uu___7 =
-                                 let uu___8 =
-                                   FStar_TypeChecker_Env.lookup_definition_qninfo
-                                     cfg.FStar_TypeChecker_Cfg.delta_level
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                     qninfo in
-                                 FStar_Compiler_Option.isNone uu___8 in
-                               if uu___7
-                               then fallback2 ()
-                               else
-                                 (let t1 =
-                                    let uu___9 =
-                                      FStar_Syntax_Util.mk_reify head in
-                                    FStar_Syntax_Syntax.mk_Tm_app uu___9 args
-                                      t.FStar_Syntax_Syntax.pos in
-                                  let uu___9 = FStar_Compiler_List.tl stack1 in
-                                  norm cfg env1 uu___9 t1))
-                        | uu___5 -> fallback1 ()))
-                  | FStar_Syntax_Syntax.Tm_meta
-                      (e, FStar_Syntax_Syntax.Meta_monadic uu___3) ->
-                      do_reify_monadic fallback cfg env1 stack1 e m t
-                  | FStar_Syntax_Syntax.Tm_meta
-                      (e, FStar_Syntax_Syntax.Meta_monadic_lift
-                       (msrc, mtgt, t'))
-                      ->
-                      let lifted =
-                        let uu___3 = closure_as_term cfg env1 t' in
-                        reify_lift cfg e msrc mtgt uu___3 in
-                      (FStar_TypeChecker_Cfg.log cfg
-                         (fun uu___4 ->
-                            let uu___5 =
-                              FStar_Syntax_Print.term_to_string lifted in
-                            FStar_Compiler_Util.print1
-                              "Reified lift to (2): %s\n" uu___5);
-                       (let uu___4 = FStar_Compiler_List.tl stack1 in
-                        norm cfg env1 uu___4 lifted))
-                  | FStar_Syntax_Syntax.Tm_match
-                      (e, asc_opt, branches1, lopt) ->
-                      let branches2 =
-                        FStar_Compiler_Effect.op_Bar_Greater branches1
-                          (FStar_Compiler_List.map
-                             (fun uu___3 ->
-                                match uu___3 with
-                                | (pat, wopt, tm) ->
-                                    let uu___4 =
-                                      FStar_Syntax_Util.mk_reify tm in
-                                    (pat, wopt, uu___4))) in
-                      let tm =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_match
-                             (e, asc_opt, branches2, lopt))
-                          top2.FStar_Syntax_Syntax.pos in
-                      let uu___3 = FStar_Compiler_List.tl stack1 in
-                      norm cfg env1 uu___3 tm
-                  | uu___3 -> fallback ()))
-and (reify_lift :
-  FStar_TypeChecker_Cfg.cfg ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.monad_name ->
-        FStar_Syntax_Syntax.monad_name ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-            FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun e ->
-      fun msrc ->
-        fun mtgt ->
-          fun t ->
-            let env1 = cfg.FStar_TypeChecker_Cfg.tcenv in
-            FStar_TypeChecker_Cfg.log cfg
-              (fun uu___1 ->
-                 let uu___2 = FStar_Ident.string_of_lid msrc in
-                 let uu___3 = FStar_Ident.string_of_lid mtgt in
-                 let uu___4 = FStar_Syntax_Print.term_to_string e in
-                 FStar_Compiler_Util.print3 "Reifying lift %s -> %s: %s\n"
-                   uu___2 uu___3 uu___4);
-            (let uu___1 =
-               ((FStar_Syntax_Util.is_pure_effect msrc) ||
-                  (FStar_Syntax_Util.is_div_effect msrc))
-                 &&
-                 (let uu___2 =
-                    FStar_Compiler_Effect.op_Bar_Greater mtgt
-                      (FStar_TypeChecker_Env.is_layered_effect env1) in
-                  Prims.op_Negation uu___2) in
-             if uu___1
-             then
-               let ed =
-                 let uu___2 =
-                   FStar_TypeChecker_Env.norm_eff_name
-                     cfg.FStar_TypeChecker_Cfg.tcenv mtgt in
-                 FStar_TypeChecker_Env.get_effect_decl env1 uu___2 in
-               let uu___2 =
-                 let uu___3 =
-                   FStar_Compiler_Effect.op_Bar_Greater ed
-                     FStar_Syntax_Util.get_eff_repr in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                   FStar_Compiler_Util.must in
-               match uu___2 with
-               | (uu___3, repr) ->
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Compiler_Effect.op_Bar_Greater ed
-                         FStar_Syntax_Util.get_return_repr in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___5
-                       FStar_Compiler_Util.must in
-                   (match uu___4 with
-                    | (uu___5, return_repr) ->
-                        let return_inst =
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Syntax_Subst.compress return_repr in
-                            uu___7.FStar_Syntax_Syntax.n in
-                          match uu___6 with
-                          | FStar_Syntax_Syntax.Tm_uinst
-                              (return_tm, uu___7::[]) ->
-                              let uu___8 =
-                                let uu___9 =
-                                  let uu___10 =
-                                    let uu___11 =
-                                      env1.FStar_TypeChecker_Env.universe_of
-                                        env1 t in
-                                    [uu___11] in
-                                  (return_tm, uu___10) in
-                                FStar_Syntax_Syntax.Tm_uinst uu___9 in
-                              FStar_Syntax_Syntax.mk uu___8
-                                e.FStar_Syntax_Syntax.pos
-                          | uu___7 ->
-                              failwith "NIY : Reification of indexed effects" in
-                        let uu___6 =
-                          let bv =
-                            FStar_Syntax_Syntax.new_bv
-                              FStar_Pervasives_Native.None t in
-                          let lb =
-                            let uu___7 =
-                              let uu___8 =
-                                let uu___9 = FStar_Syntax_Syntax.as_arg t in
-                                [uu___9] in
-                              FStar_Syntax_Util.mk_app repr uu___8 in
-                            {
-                              FStar_Syntax_Syntax.lbname =
-                                (FStar_Pervasives.Inl bv);
-                              FStar_Syntax_Syntax.lbunivs = [];
-                              FStar_Syntax_Syntax.lbtyp = uu___7;
-                              FStar_Syntax_Syntax.lbeff = msrc;
-                              FStar_Syntax_Syntax.lbdef = e;
-                              FStar_Syntax_Syntax.lbattrs = [];
-                              FStar_Syntax_Syntax.lbpos =
-                                (e.FStar_Syntax_Syntax.pos)
-                            } in
-                          let uu___7 = FStar_Syntax_Syntax.bv_to_name bv in
-                          (lb, bv, uu___7) in
-                        (match uu___6 with
-                         | (lb_e, e_bv, e1) ->
-                             let uu___7 =
-                               let uu___8 =
-                                 let uu___9 =
-                                   let uu___10 =
-                                     let uu___11 =
-                                       let uu___12 =
-                                         FStar_Syntax_Syntax.mk_binder e_bv in
-                                       [uu___12] in
-                                     FStar_Syntax_Subst.close uu___11 in
-                                   let uu___11 =
-                                     let uu___12 =
-                                       let uu___13 =
-                                         let uu___14 =
-                                           let uu___15 =
-                                             FStar_Syntax_Syntax.as_arg t in
-                                           let uu___16 =
-                                             let uu___17 =
-                                               FStar_Syntax_Syntax.as_arg e1 in
-                                             [uu___17] in
-                                           uu___15 :: uu___16 in
-                                         (return_inst, uu___14) in
-                                       FStar_Syntax_Syntax.Tm_app uu___13 in
-                                     FStar_Syntax_Syntax.mk uu___12
-                                       e1.FStar_Syntax_Syntax.pos in
-                                   FStar_Compiler_Effect.op_Less_Bar uu___10
-                                     uu___11 in
-                                 ((false, [lb_e]), uu___9) in
-                               FStar_Syntax_Syntax.Tm_let uu___8 in
-                             FStar_Syntax_Syntax.mk uu___7
-                               e1.FStar_Syntax_Syntax.pos))
-             else
-               (let uu___3 = FStar_TypeChecker_Env.monad_leq env1 msrc mtgt in
-                match uu___3 with
-                | FStar_Pervasives_Native.None ->
-                    let uu___4 =
-                      let uu___5 = FStar_Ident.string_of_lid msrc in
-                      let uu___6 = FStar_Ident.string_of_lid mtgt in
-                      FStar_Compiler_Util.format2
-                        "Impossible : trying to reify a lift between unrelated effects (%s and %s)"
-                        uu___5 uu___6 in
-                    failwith uu___4
-                | FStar_Pervasives_Native.Some
-                    { FStar_TypeChecker_Env.msource = uu___4;
-                      FStar_TypeChecker_Env.mtarget = uu___5;
-                      FStar_TypeChecker_Env.mlift =
-                        { FStar_TypeChecker_Env.mlift_wp = uu___6;
-                          FStar_TypeChecker_Env.mlift_term =
-                            FStar_Pervasives_Native.None;_};
-                      FStar_TypeChecker_Env.mpath = uu___7;_}
-                    ->
-                    let uu___8 =
-                      let uu___9 = FStar_Ident.string_of_lid msrc in
-                      let uu___10 = FStar_Ident.string_of_lid mtgt in
-                      FStar_Compiler_Util.format2
-                        "Impossible : trying to reify a non-reifiable lift (from %s to %s)"
-                        uu___9 uu___10 in
-                    failwith uu___8
-                | FStar_Pervasives_Native.Some
-                    { FStar_TypeChecker_Env.msource = uu___4;
-                      FStar_TypeChecker_Env.mtarget = uu___5;
-                      FStar_TypeChecker_Env.mlift =
-                        { FStar_TypeChecker_Env.mlift_wp = uu___6;
-                          FStar_TypeChecker_Env.mlift_term =
-                            FStar_Pervasives_Native.Some lift;_};
-                      FStar_TypeChecker_Env.mpath = uu___7;_}
-                    ->
-                    let e1 =
-                      let uu___8 =
-                        FStar_TypeChecker_Env.is_reifiable_effect env1 msrc in
-                      if uu___8
-                      then FStar_Syntax_Util.mk_reify e
-                      else
-                        (let uu___10 =
-                           let uu___11 =
-                             let uu___12 =
-                               let uu___13 =
-                                 FStar_Syntax_Syntax.null_binder
-                                   FStar_Syntax_Syntax.t_unit in
-                               [uu___13] in
-                             (uu___12, e,
-                               (FStar_Pervasives_Native.Some
-                                  {
-                                    FStar_Syntax_Syntax.residual_effect =
-                                      msrc;
-                                    FStar_Syntax_Syntax.residual_typ =
-                                      (FStar_Pervasives_Native.Some t);
-                                    FStar_Syntax_Syntax.residual_flags = []
-                                  })) in
-                           FStar_Syntax_Syntax.Tm_abs uu___11 in
-                         FStar_Syntax_Syntax.mk uu___10
-                           e.FStar_Syntax_Syntax.pos) in
-                    let uu___8 =
-                      env1.FStar_TypeChecker_Env.universe_of env1 t in
-                    lift uu___8 t e1))
-and (norm_pattern_args :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list Prims.list ->
-        (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-          FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-          Prims.list Prims.list)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun args ->
-        FStar_Compiler_Effect.op_Bar_Greater args
-          (FStar_Compiler_List.map
-             (FStar_Compiler_List.map
-                (fun uu___ ->
-                   match uu___ with
-                   | (a, imp) ->
-                       let uu___1 = norm cfg env1 [] a in (uu___1, imp))))
-and (norm_comp :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun comp ->
-        FStar_TypeChecker_Cfg.log cfg
-          (fun uu___1 ->
-             let uu___2 = FStar_Syntax_Print.comp_to_string comp in
-             let uu___3 =
-               FStar_Compiler_Util.string_of_int
-                 (FStar_Compiler_List.length env1) in
-             FStar_Compiler_Util.print2
-               ">>> %s\nNormComp with with %s env elements\n" uu___2 uu___3);
-        (match comp.FStar_Syntax_Syntax.n with
-         | FStar_Syntax_Syntax.Total t ->
-             let t1 = norm cfg env1 [] t in
-             let uu___1 = FStar_Syntax_Syntax.mk_Total t1 in
-             {
-               FStar_Syntax_Syntax.n = (uu___1.FStar_Syntax_Syntax.n);
-               FStar_Syntax_Syntax.pos = (comp.FStar_Syntax_Syntax.pos);
-               FStar_Syntax_Syntax.vars = (uu___1.FStar_Syntax_Syntax.vars);
-               FStar_Syntax_Syntax.hash_code =
-                 (uu___1.FStar_Syntax_Syntax.hash_code)
-             }
-         | FStar_Syntax_Syntax.GTotal t ->
-             let t1 = norm cfg env1 [] t in
-             let uu___1 = FStar_Syntax_Syntax.mk_GTotal t1 in
-             {
-               FStar_Syntax_Syntax.n = (uu___1.FStar_Syntax_Syntax.n);
-               FStar_Syntax_Syntax.pos = (comp.FStar_Syntax_Syntax.pos);
-               FStar_Syntax_Syntax.vars = (uu___1.FStar_Syntax_Syntax.vars);
-               FStar_Syntax_Syntax.hash_code =
-                 (uu___1.FStar_Syntax_Syntax.hash_code)
-             }
-         | FStar_Syntax_Syntax.Comp ct ->
-             let effect_args =
-               FStar_Compiler_Effect.op_Bar_Greater
-                 ct.FStar_Syntax_Syntax.effect_args
-                 (if
-                    (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction
-                  then
-                    FStar_Compiler_List.map
-                      (fun uu___1 ->
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           FStar_Syntax_Syntax.unit_const
-                           FStar_Syntax_Syntax.as_arg)
-                  else
-                    FStar_Compiler_List.mapi
-                      (fun idx ->
-                         fun uu___2 ->
-                           match uu___2 with
-                           | (a, i) ->
-                               let uu___3 = norm cfg env1 [] a in (uu___3, i))) in
-             let flags =
-               FStar_Compiler_Effect.op_Bar_Greater
-                 ct.FStar_Syntax_Syntax.flags
-                 (FStar_Compiler_List.map
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | FStar_Syntax_Syntax.DECREASES
-                           (FStar_Syntax_Syntax.Decreases_lex l) ->
-                           let uu___2 =
-                             let uu___3 =
-                               FStar_Compiler_Effect.op_Bar_Greater l
-                                 (FStar_Compiler_List.map (norm cfg env1 [])) in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___3
-                               (fun uu___4 ->
-                                  FStar_Syntax_Syntax.Decreases_lex uu___4) in
-                           FStar_Syntax_Syntax.DECREASES uu___2
-                       | FStar_Syntax_Syntax.DECREASES
-                           (FStar_Syntax_Syntax.Decreases_wf (rel, e)) ->
-                           let uu___2 =
-                             let uu___3 =
-                               let uu___4 = norm cfg env1 [] rel in
-                               let uu___5 = norm cfg env1 [] e in
-                               (uu___4, uu___5) in
-                             FStar_Syntax_Syntax.Decreases_wf uu___3 in
-                           FStar_Syntax_Syntax.DECREASES uu___2
-                       | f -> f)) in
-             let comp_univs =
-               FStar_Compiler_List.map (norm_universe cfg env1)
-                 ct.FStar_Syntax_Syntax.comp_univs in
-             let result_typ =
-               norm cfg env1 [] ct.FStar_Syntax_Syntax.result_typ in
-             let uu___1 =
-               FStar_Syntax_Syntax.mk_Comp
-                 {
-                   FStar_Syntax_Syntax.comp_univs = comp_univs;
-                   FStar_Syntax_Syntax.effect_name =
-                     (ct.FStar_Syntax_Syntax.effect_name);
-                   FStar_Syntax_Syntax.result_typ = result_typ;
-                   FStar_Syntax_Syntax.effect_args = effect_args;
-                   FStar_Syntax_Syntax.flags = flags
-                 } in
-             {
-               FStar_Syntax_Syntax.n = (uu___1.FStar_Syntax_Syntax.n);
-               FStar_Syntax_Syntax.pos = (comp.FStar_Syntax_Syntax.pos);
-               FStar_Syntax_Syntax.vars = (uu___1.FStar_Syntax_Syntax.vars);
-               FStar_Syntax_Syntax.hash_code =
-                 (uu___1.FStar_Syntax_Syntax.hash_code)
-             })
-and (norm_binder :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> FStar_Syntax_Syntax.binder -> FStar_Syntax_Syntax.binder)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun b ->
-        let x =
-          let uu___ = b.FStar_Syntax_Syntax.binder_bv in
-          let uu___1 =
-            norm cfg env1 []
-              (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-          {
-            FStar_Syntax_Syntax.ppname = (uu___.FStar_Syntax_Syntax.ppname);
-            FStar_Syntax_Syntax.index = (uu___.FStar_Syntax_Syntax.index);
-            FStar_Syntax_Syntax.sort = uu___1
-          } in
-        let imp =
-          match b.FStar_Syntax_Syntax.binder_qual with
-          | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta t) ->
-              let uu___ =
-                let uu___1 = closure_as_term cfg env1 t in
-                FStar_Syntax_Syntax.Meta uu___1 in
-              FStar_Pervasives_Native.Some uu___
-          | i -> i in
-        let attrs =
-          FStar_Compiler_List.map (norm cfg env1 [])
-            b.FStar_Syntax_Syntax.binder_attrs in
-        FStar_Syntax_Syntax.mk_binder_with_attrs x imp attrs
-and (norm_binders :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun bs ->
-        let uu___ =
-          FStar_Compiler_List.fold_left
-            (fun uu___1 ->
-               fun b ->
-                 match uu___1 with
-                 | (nbs', env2) ->
-                     let b1 = norm_binder cfg env2 b in
-                     ((b1 :: nbs'), (dummy :: env2))) ([], env1) bs in
-        match uu___ with | (nbs, uu___1) -> FStar_Compiler_List.rev nbs
-and (maybe_simplify :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> stack -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun tm ->
-          let tm' = maybe_simplify_aux cfg env1 stack1 tm in
-          if (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.b380
-          then
-            (let uu___1 = FStar_Syntax_Print.term_to_string tm in
-             let uu___2 = FStar_Syntax_Print.term_to_string tm' in
-             FStar_Compiler_Util.print3 "%sSimplified\n\t%s to\n\t%s\n"
-               (if
-                  (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.simplify
-                then ""
-                else "NOT ") uu___1 uu___2)
-          else ();
-          tm'
-and (norm_cb : FStar_TypeChecker_Cfg.cfg -> FStar_Syntax_Embeddings.norm_cb)
-  =
-  fun cfg ->
-    fun uu___ ->
-      match uu___ with
-      | FStar_Pervasives.Inr x -> norm cfg [] [] x
-      | FStar_Pervasives.Inl l ->
-          let uu___1 =
-            FStar_Syntax_DsEnv.try_lookup_lid
-              (cfg.FStar_TypeChecker_Cfg.tcenv).FStar_TypeChecker_Env.dsenv l in
-          (match uu___1 with
-           | FStar_Pervasives_Native.Some t -> t
-           | FStar_Pervasives_Native.None ->
-               let uu___2 =
-                 FStar_Syntax_Syntax.lid_as_fv l
-                   FStar_Syntax_Syntax.delta_constant
-                   FStar_Pervasives_Native.None in
-               FStar_Syntax_Syntax.fv_to_tm uu___2)
-and (maybe_simplify_aux :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> stack -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun tm ->
-          let tm1 =
-            let uu___ = norm_cb cfg in reduce_primops uu___ cfg env1 tm in
-          let uu___ =
-            FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation
-              (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.simplify in
-          if uu___
-          then tm1
-          else
-            (let w t =
-               {
-                 FStar_Syntax_Syntax.n = (t.FStar_Syntax_Syntax.n);
-                 FStar_Syntax_Syntax.pos = (tm1.FStar_Syntax_Syntax.pos);
-                 FStar_Syntax_Syntax.vars = (t.FStar_Syntax_Syntax.vars);
-                 FStar_Syntax_Syntax.hash_code =
-                   (t.FStar_Syntax_Syntax.hash_code)
-               } in
-             let simp_t t =
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Util.unmeta t in
-                 uu___3.FStar_Syntax_Syntax.n in
-               match uu___2 with
-               | FStar_Syntax_Syntax.Tm_fvar fv when
-                   FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.true_lid
-                   -> FStar_Pervasives_Native.Some true
-               | FStar_Syntax_Syntax.Tm_fvar fv when
-                   FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.false_lid
-                   -> FStar_Pervasives_Native.Some false
-               | uu___3 -> FStar_Pervasives_Native.None in
-             let rec args_are_binders args bs =
-               match (args, bs) with
-               | ((t, uu___2)::args1, b::bs1) ->
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Subst.compress t in
-                     uu___4.FStar_Syntax_Syntax.n in
-                   (match uu___3 with
-                    | FStar_Syntax_Syntax.Tm_name bv' ->
-                        (FStar_Syntax_Syntax.bv_eq
-                           b.FStar_Syntax_Syntax.binder_bv bv')
-                          && (args_are_binders args1 bs1)
-                    | uu___4 -> false)
-               | ([], []) -> true
-               | (uu___2, uu___3) -> false in
-             let is_applied bs t =
-               if (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-               then
-                 (let uu___3 = FStar_Syntax_Print.term_to_string t in
-                  let uu___4 = FStar_Syntax_Print.tag_of_term t in
-                  FStar_Compiler_Util.print2 "WPE> is_applied %s -- %s\n"
-                    uu___3 uu___4)
-               else ();
-               (let uu___3 = FStar_Syntax_Util.head_and_args_full t in
-                match uu___3 with
-                | (hd, args) ->
-                    let uu___4 =
-                      let uu___5 = FStar_Syntax_Subst.compress hd in
-                      uu___5.FStar_Syntax_Syntax.n in
-                    (match uu___4 with
-                     | FStar_Syntax_Syntax.Tm_name bv when
-                         args_are_binders args bs ->
-                         (if
-                            (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                          then
-                            (let uu___6 = FStar_Syntax_Print.term_to_string t in
-                             let uu___7 = FStar_Syntax_Print.bv_to_string bv in
-                             let uu___8 =
-                               FStar_Syntax_Print.term_to_string hd in
-                             FStar_Compiler_Util.print3
-                               "WPE> got it\n>>>>top = %s\n>>>>b = %s\n>>>>hd = %s\n"
-                               uu___6 uu___7 uu___8)
-                          else ();
-                          FStar_Pervasives_Native.Some bv)
-                     | uu___5 -> FStar_Pervasives_Native.None)) in
-             let is_applied_maybe_squashed bs t =
-               if (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-               then
-                 (let uu___3 = FStar_Syntax_Print.term_to_string t in
-                  let uu___4 = FStar_Syntax_Print.tag_of_term t in
-                  FStar_Compiler_Util.print2
-                    "WPE> is_applied_maybe_squashed %s -- %s\n" uu___3 uu___4)
-               else ();
-               (let uu___3 = FStar_Syntax_Util.is_squash t in
-                match uu___3 with
-                | FStar_Pervasives_Native.Some (uu___4, t') ->
-                    is_applied bs t'
-                | uu___4 ->
-                    let uu___5 = FStar_Syntax_Util.is_auto_squash t in
-                    (match uu___5 with
-                     | FStar_Pervasives_Native.Some (uu___6, t') ->
-                         is_applied bs t'
-                     | uu___6 -> is_applied bs t)) in
-             let is_quantified_const bv phi =
-               let uu___2 = FStar_Syntax_Util.destruct_typ_as_formula phi in
-               match uu___2 with
-               | FStar_Pervasives_Native.Some (FStar_Syntax_Util.BaseConn
-                   (lid, (p, uu___3)::(q, uu___4)::[])) when
-                   FStar_Ident.lid_equals lid FStar_Parser_Const.imp_lid ->
-                   (if
-                      (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                    then
-                      (let uu___6 = FStar_Syntax_Print.term_to_string p in
-                       let uu___7 = FStar_Syntax_Print.term_to_string q in
-                       FStar_Compiler_Util.print2 "WPE> p = (%s); q = (%s)\n"
-                         uu___6 uu___7)
-                    else ();
-                    (let uu___6 = FStar_Syntax_Util.destruct_typ_as_formula p in
-                     match uu___6 with
-                     | FStar_Pervasives_Native.None ->
-                         let uu___7 =
-                           let uu___8 = FStar_Syntax_Subst.compress p in
-                           uu___8.FStar_Syntax_Syntax.n in
-                         (match uu___7 with
-                          | FStar_Syntax_Syntax.Tm_bvar bv' when
-                              FStar_Syntax_Syntax.bv_eq bv bv' ->
-                              (if
-                                 (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                               then
-                                 FStar_Compiler_Util.print_string
-                                   "WPE> Case 1\n"
-                               else ();
-                               (let uu___9 =
-                                  FStar_Syntax_Subst.subst
-                                    [FStar_Syntax_Syntax.NT
-                                       (bv, FStar_Syntax_Util.t_true)] q in
-                                FStar_Pervasives_Native.Some uu___9))
-                          | uu___8 -> FStar_Pervasives_Native.None)
-                     | FStar_Pervasives_Native.Some
-                         (FStar_Syntax_Util.BaseConn
-                         (lid1, (p1, uu___7)::[])) when
-                         FStar_Ident.lid_equals lid1
-                           FStar_Parser_Const.not_lid
-                         ->
-                         let uu___8 =
-                           let uu___9 = FStar_Syntax_Subst.compress p1 in
-                           uu___9.FStar_Syntax_Syntax.n in
-                         (match uu___8 with
-                          | FStar_Syntax_Syntax.Tm_bvar bv' when
-                              FStar_Syntax_Syntax.bv_eq bv bv' ->
-                              (if
-                                 (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                               then
-                                 FStar_Compiler_Util.print_string
-                                   "WPE> Case 2\n"
-                               else ();
-                               (let uu___10 =
-                                  FStar_Syntax_Subst.subst
-                                    [FStar_Syntax_Syntax.NT
-                                       (bv, FStar_Syntax_Util.t_false)] q in
-                                FStar_Pervasives_Native.Some uu___10))
-                          | uu___9 -> FStar_Pervasives_Native.None)
-                     | FStar_Pervasives_Native.Some (FStar_Syntax_Util.QAll
-                         (bs, pats, phi1)) ->
-                         let uu___7 =
-                           FStar_Syntax_Util.destruct_typ_as_formula phi1 in
-                         (match uu___7 with
-                          | FStar_Pervasives_Native.None ->
-                              let uu___8 = is_applied_maybe_squashed bs phi1 in
-                              (match uu___8 with
-                               | FStar_Pervasives_Native.Some bv' when
-                                   FStar_Syntax_Syntax.bv_eq bv bv' ->
-                                   (if
-                                      (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                                    then
-                                      FStar_Compiler_Util.print_string
-                                        "WPE> Case 3\n"
-                                    else ();
-                                    (let ftrue =
-                                       FStar_Syntax_Util.abs bs
-                                         FStar_Syntax_Util.t_true
-                                         (FStar_Pervasives_Native.Some
-                                            (FStar_Syntax_Util.residual_tot
-                                               FStar_Syntax_Util.ktype0)) in
-                                     let uu___10 =
-                                       FStar_Syntax_Subst.subst
-                                         [FStar_Syntax_Syntax.NT (bv, ftrue)]
-                                         q in
-                                     FStar_Pervasives_Native.Some uu___10))
-                               | uu___9 -> FStar_Pervasives_Native.None)
-                          | FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Util.BaseConn
-                              (lid1, (p1, uu___8)::[])) when
-                              FStar_Ident.lid_equals lid1
-                                FStar_Parser_Const.not_lid
-                              ->
-                              let uu___9 = is_applied_maybe_squashed bs p1 in
-                              (match uu___9 with
-                               | FStar_Pervasives_Native.Some bv' when
-                                   FStar_Syntax_Syntax.bv_eq bv bv' ->
-                                   (if
-                                      (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                                    then
-                                      FStar_Compiler_Util.print_string
-                                        "WPE> Case 4\n"
-                                    else ();
-                                    (let ffalse =
-                                       FStar_Syntax_Util.abs bs
-                                         FStar_Syntax_Util.t_false
-                                         (FStar_Pervasives_Native.Some
-                                            (FStar_Syntax_Util.residual_tot
-                                               FStar_Syntax_Util.ktype0)) in
-                                     let uu___11 =
-                                       FStar_Syntax_Subst.subst
-                                         [FStar_Syntax_Syntax.NT (bv, ffalse)]
-                                         q in
-                                     FStar_Pervasives_Native.Some uu___11))
-                               | uu___10 -> FStar_Pervasives_Native.None)
-                          | uu___8 -> FStar_Pervasives_Native.None)
-                     | uu___7 -> FStar_Pervasives_Native.None))
-               | uu___3 -> FStar_Pervasives_Native.None in
-             let is_forall_const phi =
-               let uu___2 = FStar_Syntax_Util.destruct_typ_as_formula phi in
-               match uu___2 with
-               | FStar_Pervasives_Native.Some (FStar_Syntax_Util.QAll
-                   (b::[], uu___3, phi')) ->
-                   (if
-                      (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                    then
-                      (let uu___5 =
-                         FStar_Syntax_Print.bv_to_string
-                           b.FStar_Syntax_Syntax.binder_bv in
-                       let uu___6 = FStar_Syntax_Print.term_to_string phi' in
-                       FStar_Compiler_Util.print2 "WPE> QAll [%s] %s\n"
-                         uu___5 uu___6)
-                    else ();
-                    is_quantified_const b.FStar_Syntax_Syntax.binder_bv phi')
-               | uu___3 -> FStar_Pervasives_Native.None in
-             let is_const_match phi =
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Subst.compress phi in
-                 uu___3.FStar_Syntax_Syntax.n in
-               match uu___2 with
-               | FStar_Syntax_Syntax.Tm_match
-                   (uu___3, uu___4, br::brs, uu___5) ->
-                   let uu___6 = br in
-                   (match uu___6 with
-                    | (uu___7, uu___8, e) ->
-                        let r =
-                          let uu___9 = simp_t e in
-                          match uu___9 with
-                          | FStar_Pervasives_Native.None ->
-                              FStar_Pervasives_Native.None
-                          | FStar_Pervasives_Native.Some b ->
-                              let uu___10 =
-                                FStar_Compiler_List.for_all
-                                  (fun uu___11 ->
-                                     match uu___11 with
-                                     | (uu___12, uu___13, e') ->
-                                         let uu___14 = simp_t e' in
-                                         uu___14 =
-                                           (FStar_Pervasives_Native.Some b))
-                                  brs in
-                              if uu___10
-                              then FStar_Pervasives_Native.Some b
-                              else FStar_Pervasives_Native.None in
-                        r)
-               | uu___3 -> FStar_Pervasives_Native.None in
-             let maybe_auto_squash t =
-               let uu___2 = FStar_Syntax_Util.is_sub_singleton t in
-               if uu___2
-               then t
-               else
-                 FStar_Syntax_Util.mk_auto_squash FStar_Syntax_Syntax.U_zero
-                   t in
-             let squashed_head_un_auto_squash_args t =
-               let maybe_un_auto_squash_arg uu___2 =
-                 match uu___2 with
-                 | (t1, q) ->
-                     let uu___3 = FStar_Syntax_Util.is_auto_squash t1 in
-                     (match uu___3 with
-                      | FStar_Pervasives_Native.Some
-                          (FStar_Syntax_Syntax.U_zero, t2) -> (t2, q)
-                      | uu___4 -> (t1, q)) in
-               let uu___2 = FStar_Syntax_Util.head_and_args t in
-               match uu___2 with
-               | (head, args) ->
-                   let args1 =
-                     FStar_Compiler_List.map maybe_un_auto_squash_arg args in
-                   FStar_Syntax_Syntax.mk_Tm_app head args1
-                     t.FStar_Syntax_Syntax.pos in
-             let rec clearly_inhabited ty =
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Util.unmeta ty in
-                 uu___3.FStar_Syntax_Syntax.n in
-               match uu___2 with
-               | FStar_Syntax_Syntax.Tm_uinst (t, uu___3) ->
-                   clearly_inhabited t
-               | FStar_Syntax_Syntax.Tm_arrow (uu___3, c) ->
-                   clearly_inhabited (FStar_Syntax_Util.comp_result c)
-               | FStar_Syntax_Syntax.Tm_fvar fv ->
-                   let l = FStar_Syntax_Syntax.lid_of_fv fv in
-                   (((FStar_Ident.lid_equals l FStar_Parser_Const.int_lid) ||
-                       (FStar_Ident.lid_equals l FStar_Parser_Const.bool_lid))
-                      ||
-                      (FStar_Ident.lid_equals l FStar_Parser_Const.string_lid))
-                     || (FStar_Ident.lid_equals l FStar_Parser_Const.exn_lid)
-               | uu___3 -> false in
-             let simplify arg =
-               let uu___2 = simp_t (FStar_Pervasives_Native.fst arg) in
-               (uu___2, arg) in
-             let uu___2 = is_forall_const tm1 in
-             match uu___2 with
-             | FStar_Pervasives_Native.Some tm' ->
-                 (if
-                    (cfg.FStar_TypeChecker_Cfg.debug).FStar_TypeChecker_Cfg.wpe
-                  then
-                    (let uu___4 = FStar_Syntax_Print.term_to_string tm1 in
-                     let uu___5 = FStar_Syntax_Print.term_to_string tm' in
-                     FStar_Compiler_Util.print2 "WPE> %s ~> %s\n" uu___4
-                       uu___5)
-                  else ();
-                  (let uu___4 = norm cfg env1 [] tm' in
-                   maybe_simplify_aux cfg env1 stack1 uu___4))
-             | FStar_Pervasives_Native.None ->
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Subst.compress tm1 in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 (match uu___3 with
-                  | FStar_Syntax_Syntax.Tm_app
-                      ({
-                         FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uinst
-                           ({
-                              FStar_Syntax_Syntax.n =
-                                FStar_Syntax_Syntax.Tm_fvar fv;
-                              FStar_Syntax_Syntax.pos = uu___4;
-                              FStar_Syntax_Syntax.vars = uu___5;
-                              FStar_Syntax_Syntax.hash_code = uu___6;_},
-                            uu___7);
-                         FStar_Syntax_Syntax.pos = uu___8;
-                         FStar_Syntax_Syntax.vars = uu___9;
-                         FStar_Syntax_Syntax.hash_code = uu___10;_},
-                       args)
-                      ->
-                      let uu___11 =
-                        FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.and_lid in
-                      if uu___11
-                      then
-                        let uu___12 =
-                          FStar_Compiler_Effect.op_Bar_Greater args
-                            (FStar_Compiler_List.map simplify) in
-                        (match uu___12 with
-                         | (FStar_Pervasives_Native.Some (true), uu___13)::
-                             (uu___14, (arg, uu___15))::[] ->
-                             maybe_auto_squash arg
-                         | (uu___13, (arg, uu___14))::(FStar_Pervasives_Native.Some
-                                                       (true), uu___15)::[]
-                             -> maybe_auto_squash arg
-                         | (FStar_Pervasives_Native.Some (false), uu___13)::uu___14::[]
-                             -> w FStar_Syntax_Util.t_false
-                         | uu___13::(FStar_Pervasives_Native.Some (false),
-                                     uu___14)::[]
-                             -> w FStar_Syntax_Util.t_false
-                         | uu___13 -> squashed_head_un_auto_squash_args tm1)
-                      else
-                        (let uu___13 =
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.or_lid in
-                         if uu___13
-                         then
-                           let uu___14 =
-                             FStar_Compiler_Effect.op_Bar_Greater args
-                               (FStar_Compiler_List.map simplify) in
-                           match uu___14 with
-                           | (FStar_Pervasives_Native.Some (true), uu___15)::uu___16::[]
-                               -> w FStar_Syntax_Util.t_true
-                           | uu___15::(FStar_Pervasives_Native.Some (true),
-                                       uu___16)::[]
-                               -> w FStar_Syntax_Util.t_true
-                           | (FStar_Pervasives_Native.Some (false), uu___15)::
-                               (uu___16, (arg, uu___17))::[] ->
-                               maybe_auto_squash arg
-                           | (uu___15, (arg, uu___16))::(FStar_Pervasives_Native.Some
-                                                         (false), uu___17)::[]
-                               -> maybe_auto_squash arg
-                           | uu___15 -> squashed_head_un_auto_squash_args tm1
-                         else
-                           (let uu___15 =
-                              FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.imp_lid in
-                            if uu___15
-                            then
-                              let uu___16 =
-                                FStar_Compiler_Effect.op_Bar_Greater args
-                                  (FStar_Compiler_List.map simplify) in
-                              match uu___16 with
-                              | uu___17::(FStar_Pervasives_Native.Some
-                                          (true), uu___18)::[]
-                                  -> w FStar_Syntax_Util.t_true
-                              | (FStar_Pervasives_Native.Some (false),
-                                 uu___17)::uu___18::[] ->
-                                  w FStar_Syntax_Util.t_true
-                              | (FStar_Pervasives_Native.Some (true),
-                                 uu___17)::(uu___18, (arg, uu___19))::[] ->
-                                  maybe_auto_squash arg
-                              | (uu___17, (p, uu___18))::(uu___19,
-                                                          (q, uu___20))::[]
-                                  ->
-                                  let uu___21 = FStar_Syntax_Util.term_eq p q in
-                                  (if uu___21
-                                   then w FStar_Syntax_Util.t_true
-                                   else squashed_head_un_auto_squash_args tm1)
-                              | uu___17 ->
-                                  squashed_head_un_auto_squash_args tm1
-                            else
-                              (let uu___17 =
-                                 FStar_Syntax_Syntax.fv_eq_lid fv
-                                   FStar_Parser_Const.iff_lid in
-                               if uu___17
-                               then
-                                 let uu___18 =
-                                   FStar_Compiler_Effect.op_Bar_Greater args
-                                     (FStar_Compiler_List.map simplify) in
-                                 match uu___18 with
-                                 | (FStar_Pervasives_Native.Some (true),
-                                    uu___19)::(FStar_Pervasives_Native.Some
-                                               (true), uu___20)::[]
-                                     -> w FStar_Syntax_Util.t_true
-                                 | (FStar_Pervasives_Native.Some (false),
-                                    uu___19)::(FStar_Pervasives_Native.Some
-                                               (false), uu___20)::[]
-                                     -> w FStar_Syntax_Util.t_true
-                                 | (FStar_Pervasives_Native.Some (true),
-                                    uu___19)::(FStar_Pervasives_Native.Some
-                                               (false), uu___20)::[]
-                                     -> w FStar_Syntax_Util.t_false
-                                 | (FStar_Pervasives_Native.Some (false),
-                                    uu___19)::(FStar_Pervasives_Native.Some
-                                               (true), uu___20)::[]
-                                     -> w FStar_Syntax_Util.t_false
-                                 | (uu___19, (arg, uu___20))::(FStar_Pervasives_Native.Some
-                                                               (true),
-                                                               uu___21)::[]
-                                     -> maybe_auto_squash arg
-                                 | (FStar_Pervasives_Native.Some (true),
-                                    uu___19)::(uu___20, (arg, uu___21))::[]
-                                     -> maybe_auto_squash arg
-                                 | (uu___19, (arg, uu___20))::(FStar_Pervasives_Native.Some
-                                                               (false),
-                                                               uu___21)::[]
-                                     ->
-                                     let uu___22 =
-                                       FStar_Syntax_Util.mk_neg arg in
-                                     maybe_auto_squash uu___22
-                                 | (FStar_Pervasives_Native.Some (false),
-                                    uu___19)::(uu___20, (arg, uu___21))::[]
-                                     ->
-                                     let uu___22 =
-                                       FStar_Syntax_Util.mk_neg arg in
-                                     maybe_auto_squash uu___22
-                                 | (uu___19, (p, uu___20))::(uu___21,
-                                                             (q, uu___22))::[]
-                                     ->
-                                     let uu___23 =
-                                       FStar_Syntax_Util.term_eq p q in
-                                     (if uu___23
-                                      then w FStar_Syntax_Util.t_true
-                                      else
-                                        squashed_head_un_auto_squash_args tm1)
-                                 | uu___19 ->
-                                     squashed_head_un_auto_squash_args tm1
-                               else
-                                 (let uu___19 =
-                                    FStar_Syntax_Syntax.fv_eq_lid fv
-                                      FStar_Parser_Const.not_lid in
-                                  if uu___19
-                                  then
-                                    let uu___20 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        args
-                                        (FStar_Compiler_List.map simplify) in
-                                    match uu___20 with
-                                    | (FStar_Pervasives_Native.Some (true),
-                                       uu___21)::[] ->
-                                        w FStar_Syntax_Util.t_false
-                                    | (FStar_Pervasives_Native.Some (false),
-                                       uu___21)::[] ->
-                                        w FStar_Syntax_Util.t_true
-                                    | uu___21 ->
-                                        squashed_head_un_auto_squash_args tm1
-                                  else
-                                    (let uu___21 =
-                                       FStar_Syntax_Syntax.fv_eq_lid fv
-                                         FStar_Parser_Const.forall_lid in
-                                     if uu___21
-                                     then
-                                       match args with
-                                       | (t, uu___22)::[] ->
-                                           let uu___23 =
-                                             let uu___24 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___24.FStar_Syntax_Syntax.n in
-                                           (match uu___23 with
-                                            | FStar_Syntax_Syntax.Tm_abs
-                                                (uu___24::[], body, uu___25)
-                                                ->
-                                                let uu___26 = simp_t body in
-                                                (match uu___26 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (true) ->
-                                                     w
-                                                       FStar_Syntax_Util.t_true
-                                                 | uu___27 -> tm1)
-                                            | uu___24 -> tm1)
-                                       | (ty, FStar_Pervasives_Native.Some
-                                          {
-                                            FStar_Syntax_Syntax.aqual_implicit
-                                              = true;
-                                            FStar_Syntax_Syntax.aqual_attributes
-                                              = uu___22;_})::(t, uu___23)::[]
-                                           ->
-                                           let uu___24 =
-                                             let uu___25 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___25.FStar_Syntax_Syntax.n in
-                                           (match uu___24 with
-                                            | FStar_Syntax_Syntax.Tm_abs
-                                                (uu___25::[], body, uu___26)
-                                                ->
-                                                let uu___27 = simp_t body in
-                                                (match uu___27 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (true) ->
-                                                     w
-                                                       FStar_Syntax_Util.t_true
-                                                 | FStar_Pervasives_Native.Some
-                                                     (false) when
-                                                     clearly_inhabited ty ->
-                                                     w
-                                                       FStar_Syntax_Util.t_false
-                                                 | uu___28 -> tm1)
-                                            | uu___25 -> tm1)
-                                       | uu___22 -> tm1
-                                     else
-                                       (let uu___23 =
-                                          FStar_Syntax_Syntax.fv_eq_lid fv
-                                            FStar_Parser_Const.exists_lid in
-                                        if uu___23
-                                        then
-                                          match args with
-                                          | (t, uu___24)::[] ->
-                                              let uu___25 =
-                                                let uu___26 =
-                                                  FStar_Syntax_Subst.compress
-                                                    t in
-                                                uu___26.FStar_Syntax_Syntax.n in
-                                              (match uu___25 with
-                                               | FStar_Syntax_Syntax.Tm_abs
-                                                   (uu___26::[], body,
-                                                    uu___27)
-                                                   ->
-                                                   let uu___28 = simp_t body in
-                                                   (match uu___28 with
-                                                    | FStar_Pervasives_Native.Some
-                                                        (false) ->
-                                                        w
-                                                          FStar_Syntax_Util.t_false
-                                                    | uu___29 -> tm1)
-                                               | uu___26 -> tm1)
-                                          | (ty, FStar_Pervasives_Native.Some
-                                             {
-                                               FStar_Syntax_Syntax.aqual_implicit
-                                                 = true;
-                                               FStar_Syntax_Syntax.aqual_attributes
-                                                 = uu___24;_})::(t, uu___25)::[]
-                                              ->
-                                              let uu___26 =
-                                                let uu___27 =
-                                                  FStar_Syntax_Subst.compress
-                                                    t in
-                                                uu___27.FStar_Syntax_Syntax.n in
-                                              (match uu___26 with
-                                               | FStar_Syntax_Syntax.Tm_abs
-                                                   (uu___27::[], body,
-                                                    uu___28)
-                                                   ->
-                                                   let uu___29 = simp_t body in
-                                                   (match uu___29 with
-                                                    | FStar_Pervasives_Native.Some
-                                                        (false) ->
-                                                        w
-                                                          FStar_Syntax_Util.t_false
-                                                    | FStar_Pervasives_Native.Some
-                                                        (true) when
-                                                        clearly_inhabited ty
-                                                        ->
-                                                        w
-                                                          FStar_Syntax_Util.t_true
-                                                    | uu___30 -> tm1)
-                                               | uu___27 -> tm1)
-                                          | uu___24 -> tm1
-                                        else
-                                          (let uu___25 =
-                                             FStar_Syntax_Syntax.fv_eq_lid fv
-                                               FStar_Parser_Const.b2t_lid in
-                                           if uu___25
-                                           then
-                                             match args with
-                                             | ({
-                                                  FStar_Syntax_Syntax.n =
-                                                    FStar_Syntax_Syntax.Tm_constant
-                                                    (FStar_Const.Const_bool
-                                                    (true));
-                                                  FStar_Syntax_Syntax.pos =
-                                                    uu___26;
-                                                  FStar_Syntax_Syntax.vars =
-                                                    uu___27;
-                                                  FStar_Syntax_Syntax.hash_code
-                                                    = uu___28;_},
-                                                uu___29)::[] ->
-                                                 w FStar_Syntax_Util.t_true
-                                             | ({
-                                                  FStar_Syntax_Syntax.n =
-                                                    FStar_Syntax_Syntax.Tm_constant
-                                                    (FStar_Const.Const_bool
-                                                    (false));
-                                                  FStar_Syntax_Syntax.pos =
-                                                    uu___26;
-                                                  FStar_Syntax_Syntax.vars =
-                                                    uu___27;
-                                                  FStar_Syntax_Syntax.hash_code
-                                                    = uu___28;_},
-                                                uu___29)::[] ->
-                                                 w FStar_Syntax_Util.t_false
-                                             | uu___26 -> tm1
-                                           else
-                                             (let uu___27 =
-                                                FStar_Syntax_Syntax.fv_eq_lid
-                                                  fv
-                                                  FStar_Parser_Const.haseq_lid in
-                                              if uu___27
-                                              then
-                                                let t_has_eq_for_sure t =
-                                                  let haseq_lids =
-                                                    [FStar_Parser_Const.int_lid;
-                                                    FStar_Parser_Const.bool_lid;
-                                                    FStar_Parser_Const.unit_lid;
-                                                    FStar_Parser_Const.string_lid] in
-                                                  let uu___28 =
-                                                    let uu___29 =
-                                                      FStar_Syntax_Subst.compress
-                                                        t in
-                                                    uu___29.FStar_Syntax_Syntax.n in
-                                                  match uu___28 with
-                                                  | FStar_Syntax_Syntax.Tm_fvar
-                                                      fv1 when
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        haseq_lids
-                                                        (FStar_Compiler_List.existsb
-                                                           (fun l ->
-                                                              FStar_Syntax_Syntax.fv_eq_lid
-                                                                fv1 l))
-                                                      -> true
-                                                  | uu___29 -> false in
-                                                (if
-                                                   (FStar_Compiler_List.length
-                                                      args)
-                                                     = Prims.int_one
-                                                 then
-                                                   let t =
-                                                     let uu___28 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         args
-                                                         FStar_Compiler_List.hd in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___28
-                                                       FStar_Pervasives_Native.fst in
-                                                   let uu___28 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       t t_has_eq_for_sure in
-                                                   (if uu___28
-                                                    then
-                                                      w
-                                                        FStar_Syntax_Util.t_true
-                                                    else
-                                                      (let uu___30 =
-                                                         let uu___31 =
-                                                           FStar_Syntax_Subst.compress
-                                                             t in
-                                                         uu___31.FStar_Syntax_Syntax.n in
-                                                       match uu___30 with
-                                                       | FStar_Syntax_Syntax.Tm_refine
-                                                           uu___31 ->
-                                                           let t1 =
-                                                             FStar_Syntax_Util.unrefine
-                                                               t in
-                                                           let uu___32 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               t1
-                                                               t_has_eq_for_sure in
-                                                           if uu___32
-                                                           then
-                                                             w
-                                                               FStar_Syntax_Util.t_true
-                                                           else
-                                                             (let haseq_tm =
-                                                                let uu___34 =
-                                                                  let uu___35
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    tm1 in
-                                                                  uu___35.FStar_Syntax_Syntax.n in
-                                                                match uu___34
-                                                                with
-                                                                | FStar_Syntax_Syntax.Tm_app
-                                                                    (hd,
-                                                                    uu___35)
-                                                                    -> hd
-                                                                | uu___35 ->
-                                                                    failwith
-                                                                    "Impossible! We have already checked that this is a Tm_app" in
-                                                              let uu___34 =
-                                                                let uu___35 =
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    t1
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                [uu___35] in
-                                                              FStar_Syntax_Util.mk_app
-                                                                haseq_tm
-                                                                uu___34)
-                                                       | uu___31 -> tm1))
-                                                 else tm1)
-                                              else
-                                                (let uu___29 =
-                                                   FStar_Syntax_Util.is_auto_squash
-                                                     tm1 in
-                                                 match uu___29 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (FStar_Syntax_Syntax.U_zero,
-                                                      t)
-                                                     when
-                                                     FStar_Syntax_Util.is_sub_singleton
-                                                       t
-                                                     -> t
-                                                 | uu___30 ->
-                                                     let uu___31 =
-                                                       norm_cb cfg in
-                                                     reduce_equality uu___31
-                                                       cfg env1 tm1)))))))))
-                  | FStar_Syntax_Syntax.Tm_app
-                      ({
-                         FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                           fv;
-                         FStar_Syntax_Syntax.pos = uu___4;
-                         FStar_Syntax_Syntax.vars = uu___5;
-                         FStar_Syntax_Syntax.hash_code = uu___6;_},
-                       args)
-                      ->
-                      let uu___7 =
-                        FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.and_lid in
-                      if uu___7
-                      then
-                        let uu___8 =
-                          FStar_Compiler_Effect.op_Bar_Greater args
-                            (FStar_Compiler_List.map simplify) in
-                        (match uu___8 with
-                         | (FStar_Pervasives_Native.Some (true), uu___9)::
-                             (uu___10, (arg, uu___11))::[] ->
-                             maybe_auto_squash arg
-                         | (uu___9, (arg, uu___10))::(FStar_Pervasives_Native.Some
-                                                      (true), uu___11)::[]
-                             -> maybe_auto_squash arg
-                         | (FStar_Pervasives_Native.Some (false), uu___9)::uu___10::[]
-                             -> w FStar_Syntax_Util.t_false
-                         | uu___9::(FStar_Pervasives_Native.Some (false),
-                                    uu___10)::[]
-                             -> w FStar_Syntax_Util.t_false
-                         | uu___9 -> squashed_head_un_auto_squash_args tm1)
-                      else
-                        (let uu___9 =
-                           FStar_Syntax_Syntax.fv_eq_lid fv
-                             FStar_Parser_Const.or_lid in
-                         if uu___9
-                         then
-                           let uu___10 =
-                             FStar_Compiler_Effect.op_Bar_Greater args
-                               (FStar_Compiler_List.map simplify) in
-                           match uu___10 with
-                           | (FStar_Pervasives_Native.Some (true), uu___11)::uu___12::[]
-                               -> w FStar_Syntax_Util.t_true
-                           | uu___11::(FStar_Pervasives_Native.Some (true),
-                                       uu___12)::[]
-                               -> w FStar_Syntax_Util.t_true
-                           | (FStar_Pervasives_Native.Some (false), uu___11)::
-                               (uu___12, (arg, uu___13))::[] ->
-                               maybe_auto_squash arg
-                           | (uu___11, (arg, uu___12))::(FStar_Pervasives_Native.Some
-                                                         (false), uu___13)::[]
-                               -> maybe_auto_squash arg
-                           | uu___11 -> squashed_head_un_auto_squash_args tm1
-                         else
-                           (let uu___11 =
-                              FStar_Syntax_Syntax.fv_eq_lid fv
-                                FStar_Parser_Const.imp_lid in
-                            if uu___11
-                            then
-                              let uu___12 =
-                                FStar_Compiler_Effect.op_Bar_Greater args
-                                  (FStar_Compiler_List.map simplify) in
-                              match uu___12 with
-                              | uu___13::(FStar_Pervasives_Native.Some
-                                          (true), uu___14)::[]
-                                  -> w FStar_Syntax_Util.t_true
-                              | (FStar_Pervasives_Native.Some (false),
-                                 uu___13)::uu___14::[] ->
-                                  w FStar_Syntax_Util.t_true
-                              | (FStar_Pervasives_Native.Some (true),
-                                 uu___13)::(uu___14, (arg, uu___15))::[] ->
-                                  maybe_auto_squash arg
-                              | (uu___13, (p, uu___14))::(uu___15,
-                                                          (q, uu___16))::[]
-                                  ->
-                                  let uu___17 = FStar_Syntax_Util.term_eq p q in
-                                  (if uu___17
-                                   then w FStar_Syntax_Util.t_true
-                                   else squashed_head_un_auto_squash_args tm1)
-                              | uu___13 ->
-                                  squashed_head_un_auto_squash_args tm1
-                            else
-                              (let uu___13 =
-                                 FStar_Syntax_Syntax.fv_eq_lid fv
-                                   FStar_Parser_Const.iff_lid in
-                               if uu___13
-                               then
-                                 let uu___14 =
-                                   FStar_Compiler_Effect.op_Bar_Greater args
-                                     (FStar_Compiler_List.map simplify) in
-                                 match uu___14 with
-                                 | (FStar_Pervasives_Native.Some (true),
-                                    uu___15)::(FStar_Pervasives_Native.Some
-                                               (true), uu___16)::[]
-                                     -> w FStar_Syntax_Util.t_true
-                                 | (FStar_Pervasives_Native.Some (false),
-                                    uu___15)::(FStar_Pervasives_Native.Some
-                                               (false), uu___16)::[]
-                                     -> w FStar_Syntax_Util.t_true
-                                 | (FStar_Pervasives_Native.Some (true),
-                                    uu___15)::(FStar_Pervasives_Native.Some
-                                               (false), uu___16)::[]
-                                     -> w FStar_Syntax_Util.t_false
-                                 | (FStar_Pervasives_Native.Some (false),
-                                    uu___15)::(FStar_Pervasives_Native.Some
-                                               (true), uu___16)::[]
-                                     -> w FStar_Syntax_Util.t_false
-                                 | (uu___15, (arg, uu___16))::(FStar_Pervasives_Native.Some
-                                                               (true),
-                                                               uu___17)::[]
-                                     -> maybe_auto_squash arg
-                                 | (FStar_Pervasives_Native.Some (true),
-                                    uu___15)::(uu___16, (arg, uu___17))::[]
-                                     -> maybe_auto_squash arg
-                                 | (uu___15, (arg, uu___16))::(FStar_Pervasives_Native.Some
-                                                               (false),
-                                                               uu___17)::[]
-                                     ->
-                                     let uu___18 =
-                                       FStar_Syntax_Util.mk_neg arg in
-                                     maybe_auto_squash uu___18
-                                 | (FStar_Pervasives_Native.Some (false),
-                                    uu___15)::(uu___16, (arg, uu___17))::[]
-                                     ->
-                                     let uu___18 =
-                                       FStar_Syntax_Util.mk_neg arg in
-                                     maybe_auto_squash uu___18
-                                 | (uu___15, (p, uu___16))::(uu___17,
-                                                             (q, uu___18))::[]
-                                     ->
-                                     let uu___19 =
-                                       FStar_Syntax_Util.term_eq p q in
-                                     (if uu___19
-                                      then w FStar_Syntax_Util.t_true
-                                      else
-                                        squashed_head_un_auto_squash_args tm1)
-                                 | uu___15 ->
-                                     squashed_head_un_auto_squash_args tm1
-                               else
-                                 (let uu___15 =
-                                    FStar_Syntax_Syntax.fv_eq_lid fv
-                                      FStar_Parser_Const.not_lid in
-                                  if uu___15
-                                  then
-                                    let uu___16 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        args
-                                        (FStar_Compiler_List.map simplify) in
-                                    match uu___16 with
-                                    | (FStar_Pervasives_Native.Some (true),
-                                       uu___17)::[] ->
-                                        w FStar_Syntax_Util.t_false
-                                    | (FStar_Pervasives_Native.Some (false),
-                                       uu___17)::[] ->
-                                        w FStar_Syntax_Util.t_true
-                                    | uu___17 ->
-                                        squashed_head_un_auto_squash_args tm1
-                                  else
-                                    (let uu___17 =
-                                       FStar_Syntax_Syntax.fv_eq_lid fv
-                                         FStar_Parser_Const.forall_lid in
-                                     if uu___17
-                                     then
-                                       match args with
-                                       | (t, uu___18)::[] ->
-                                           let uu___19 =
-                                             let uu___20 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___20.FStar_Syntax_Syntax.n in
-                                           (match uu___19 with
-                                            | FStar_Syntax_Syntax.Tm_abs
-                                                (uu___20::[], body, uu___21)
-                                                ->
-                                                let uu___22 = simp_t body in
-                                                (match uu___22 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (true) ->
-                                                     w
-                                                       FStar_Syntax_Util.t_true
-                                                 | uu___23 -> tm1)
-                                            | uu___20 -> tm1)
-                                       | (ty, FStar_Pervasives_Native.Some
-                                          {
-                                            FStar_Syntax_Syntax.aqual_implicit
-                                              = true;
-                                            FStar_Syntax_Syntax.aqual_attributes
-                                              = uu___18;_})::(t, uu___19)::[]
-                                           ->
-                                           let uu___20 =
-                                             let uu___21 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___21.FStar_Syntax_Syntax.n in
-                                           (match uu___20 with
-                                            | FStar_Syntax_Syntax.Tm_abs
-                                                (uu___21::[], body, uu___22)
-                                                ->
-                                                let uu___23 = simp_t body in
-                                                (match uu___23 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (true) ->
-                                                     w
-                                                       FStar_Syntax_Util.t_true
-                                                 | FStar_Pervasives_Native.Some
-                                                     (false) when
-                                                     clearly_inhabited ty ->
-                                                     w
-                                                       FStar_Syntax_Util.t_false
-                                                 | uu___24 -> tm1)
-                                            | uu___21 -> tm1)
-                                       | uu___18 -> tm1
-                                     else
-                                       (let uu___19 =
-                                          FStar_Syntax_Syntax.fv_eq_lid fv
-                                            FStar_Parser_Const.exists_lid in
-                                        if uu___19
-                                        then
-                                          match args with
-                                          | (t, uu___20)::[] ->
-                                              let uu___21 =
-                                                let uu___22 =
-                                                  FStar_Syntax_Subst.compress
-                                                    t in
-                                                uu___22.FStar_Syntax_Syntax.n in
-                                              (match uu___21 with
-                                               | FStar_Syntax_Syntax.Tm_abs
-                                                   (uu___22::[], body,
-                                                    uu___23)
-                                                   ->
-                                                   let uu___24 = simp_t body in
-                                                   (match uu___24 with
-                                                    | FStar_Pervasives_Native.Some
-                                                        (false) ->
-                                                        w
-                                                          FStar_Syntax_Util.t_false
-                                                    | uu___25 -> tm1)
-                                               | uu___22 -> tm1)
-                                          | (ty, FStar_Pervasives_Native.Some
-                                             {
-                                               FStar_Syntax_Syntax.aqual_implicit
-                                                 = true;
-                                               FStar_Syntax_Syntax.aqual_attributes
-                                                 = uu___20;_})::(t, uu___21)::[]
-                                              ->
-                                              let uu___22 =
-                                                let uu___23 =
-                                                  FStar_Syntax_Subst.compress
-                                                    t in
-                                                uu___23.FStar_Syntax_Syntax.n in
-                                              (match uu___22 with
-                                               | FStar_Syntax_Syntax.Tm_abs
-                                                   (uu___23::[], body,
-                                                    uu___24)
-                                                   ->
-                                                   let uu___25 = simp_t body in
-                                                   (match uu___25 with
-                                                    | FStar_Pervasives_Native.Some
-                                                        (false) ->
-                                                        w
-                                                          FStar_Syntax_Util.t_false
-                                                    | FStar_Pervasives_Native.Some
-                                                        (true) when
-                                                        clearly_inhabited ty
-                                                        ->
-                                                        w
-                                                          FStar_Syntax_Util.t_true
-                                                    | uu___26 -> tm1)
-                                               | uu___23 -> tm1)
-                                          | uu___20 -> tm1
-                                        else
-                                          (let uu___21 =
-                                             FStar_Syntax_Syntax.fv_eq_lid fv
-                                               FStar_Parser_Const.b2t_lid in
-                                           if uu___21
-                                           then
-                                             match args with
-                                             | ({
-                                                  FStar_Syntax_Syntax.n =
-                                                    FStar_Syntax_Syntax.Tm_constant
-                                                    (FStar_Const.Const_bool
-                                                    (true));
-                                                  FStar_Syntax_Syntax.pos =
-                                                    uu___22;
-                                                  FStar_Syntax_Syntax.vars =
-                                                    uu___23;
-                                                  FStar_Syntax_Syntax.hash_code
-                                                    = uu___24;_},
-                                                uu___25)::[] ->
-                                                 w FStar_Syntax_Util.t_true
-                                             | ({
-                                                  FStar_Syntax_Syntax.n =
-                                                    FStar_Syntax_Syntax.Tm_constant
-                                                    (FStar_Const.Const_bool
-                                                    (false));
-                                                  FStar_Syntax_Syntax.pos =
-                                                    uu___22;
-                                                  FStar_Syntax_Syntax.vars =
-                                                    uu___23;
-                                                  FStar_Syntax_Syntax.hash_code
-                                                    = uu___24;_},
-                                                uu___25)::[] ->
-                                                 w FStar_Syntax_Util.t_false
-                                             | uu___22 -> tm1
-                                           else
-                                             (let uu___23 =
-                                                FStar_Syntax_Syntax.fv_eq_lid
-                                                  fv
-                                                  FStar_Parser_Const.haseq_lid in
-                                              if uu___23
-                                              then
-                                                let t_has_eq_for_sure t =
-                                                  let haseq_lids =
-                                                    [FStar_Parser_Const.int_lid;
-                                                    FStar_Parser_Const.bool_lid;
-                                                    FStar_Parser_Const.unit_lid;
-                                                    FStar_Parser_Const.string_lid] in
-                                                  let uu___24 =
-                                                    let uu___25 =
-                                                      FStar_Syntax_Subst.compress
-                                                        t in
-                                                    uu___25.FStar_Syntax_Syntax.n in
-                                                  match uu___24 with
-                                                  | FStar_Syntax_Syntax.Tm_fvar
-                                                      fv1 when
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        haseq_lids
-                                                        (FStar_Compiler_List.existsb
-                                                           (fun l ->
-                                                              FStar_Syntax_Syntax.fv_eq_lid
-                                                                fv1 l))
-                                                      -> true
-                                                  | uu___25 -> false in
-                                                (if
-                                                   (FStar_Compiler_List.length
-                                                      args)
-                                                     = Prims.int_one
-                                                 then
-                                                   let t =
-                                                     let uu___24 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         args
-                                                         FStar_Compiler_List.hd in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___24
-                                                       FStar_Pervasives_Native.fst in
-                                                   let uu___24 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       t t_has_eq_for_sure in
-                                                   (if uu___24
-                                                    then
-                                                      w
-                                                        FStar_Syntax_Util.t_true
-                                                    else
-                                                      (let uu___26 =
-                                                         let uu___27 =
-                                                           FStar_Syntax_Subst.compress
-                                                             t in
-                                                         uu___27.FStar_Syntax_Syntax.n in
-                                                       match uu___26 with
-                                                       | FStar_Syntax_Syntax.Tm_refine
-                                                           uu___27 ->
-                                                           let t1 =
-                                                             FStar_Syntax_Util.unrefine
-                                                               t in
-                                                           let uu___28 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               t1
-                                                               t_has_eq_for_sure in
-                                                           if uu___28
-                                                           then
-                                                             w
-                                                               FStar_Syntax_Util.t_true
-                                                           else
-                                                             (let haseq_tm =
-                                                                let uu___30 =
-                                                                  let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    tm1 in
-                                                                  uu___31.FStar_Syntax_Syntax.n in
-                                                                match uu___30
-                                                                with
-                                                                | FStar_Syntax_Syntax.Tm_app
-                                                                    (hd,
-                                                                    uu___31)
-                                                                    -> hd
-                                                                | uu___31 ->
-                                                                    failwith
-                                                                    "Impossible! We have already checked that this is a Tm_app" in
-                                                              let uu___30 =
-                                                                let uu___31 =
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    t1
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                [uu___31] in
-                                                              FStar_Syntax_Util.mk_app
-                                                                haseq_tm
-                                                                uu___30)
-                                                       | uu___27 -> tm1))
-                                                 else tm1)
-                                              else
-                                                (let uu___25 =
-                                                   FStar_Syntax_Util.is_auto_squash
-                                                     tm1 in
-                                                 match uu___25 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (FStar_Syntax_Syntax.U_zero,
-                                                      t)
-                                                     when
-                                                     FStar_Syntax_Util.is_sub_singleton
-                                                       t
-                                                     -> t
-                                                 | uu___26 ->
-                                                     let uu___27 =
-                                                       norm_cb cfg in
-                                                     reduce_equality uu___27
-                                                       cfg env1 tm1)))))))))
-                  | FStar_Syntax_Syntax.Tm_refine (bv, t) ->
-                      let uu___4 = simp_t t in
-                      (match uu___4 with
-                       | FStar_Pervasives_Native.Some (true) ->
-                           bv.FStar_Syntax_Syntax.sort
-                       | FStar_Pervasives_Native.Some (false) -> tm1
-                       | FStar_Pervasives_Native.None -> tm1)
-                  | FStar_Syntax_Syntax.Tm_match uu___4 ->
-                      let uu___5 = is_const_match tm1 in
-                      (match uu___5 with
-                       | FStar_Pervasives_Native.Some (true) ->
-                           w FStar_Syntax_Util.t_true
-                       | FStar_Pervasives_Native.Some (false) ->
-                           w FStar_Syntax_Util.t_false
-                       | FStar_Pervasives_Native.None -> tm1)
-                  | uu___4 -> tm1))
-and (rebuild :
-  FStar_TypeChecker_Cfg.cfg ->
-    env -> stack -> FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun stack1 ->
-        fun t ->
-          FStar_TypeChecker_Cfg.log cfg
-            (fun uu___1 ->
-               (let uu___3 = FStar_Syntax_Print.tag_of_term t in
-                let uu___4 = FStar_Syntax_Print.term_to_string t in
-                let uu___5 =
-                  FStar_Compiler_Util.string_of_int
-                    (FStar_Compiler_List.length env1) in
-                let uu___6 =
-                  let uu___7 =
-                    let uu___8 = firstn (Prims.of_int (4)) stack1 in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      FStar_Pervasives_Native.fst uu___8 in
-                  stack_to_string uu___7 in
-                FStar_Compiler_Util.print4
-                  ">>> %s\nRebuild %s with %s env elements and top of the stack %s \n"
-                  uu___3 uu___4 uu___5 uu___6);
-               (let uu___3 =
-                  FStar_TypeChecker_Env.debug cfg.FStar_TypeChecker_Cfg.tcenv
-                    (FStar_Options.Other "NormRebuild") in
-                if uu___3
-                then
-                  let uu___4 = FStar_Syntax_Util.unbound_variables t in
-                  match uu___4 with
-                  | [] -> ()
-                  | bvs ->
-                      ((let uu___6 = FStar_Syntax_Print.tag_of_term t in
-                        let uu___7 = FStar_Syntax_Print.term_to_string t in
-                        let uu___8 =
-                          let uu___9 =
-                            FStar_Compiler_Effect.op_Bar_Greater bvs
-                              (FStar_Compiler_List.map
-                                 FStar_Syntax_Print.bv_to_string) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___9
-                            (FStar_String.concat ", ") in
-                        FStar_Compiler_Util.print3
-                          "!!! Rebuild (%s) %s, free vars=%s\n" uu___6 uu___7
-                          uu___8);
-                       failwith "DIE!")
-                else ()));
-          (let f_opt = is_fext_on_domain t in
-           let uu___1 =
-             (FStar_Compiler_Effect.op_Bar_Greater f_opt
-                FStar_Compiler_Util.is_some)
-               &&
-               (match stack1 with
-                | (Arg uu___2)::uu___3 -> true
-                | uu___2 -> false) in
-           if uu___1
-           then
-             let uu___2 =
-               FStar_Compiler_Effect.op_Bar_Greater f_opt
-                 FStar_Compiler_Util.must in
-             FStar_Compiler_Effect.op_Bar_Greater uu___2
-               (norm cfg env1 stack1)
-           else
-             (let t1 = maybe_simplify cfg env1 stack1 t in
-              match stack1 with
-              | [] -> t1
-              | (Cfg (cfg', dbg))::stack2 ->
-                  (maybe_debug cfg t1 dbg; rebuild cfg' env1 stack2 t1)
-              | (Meta (uu___3, m, r))::stack2 ->
-                  let t2 =
-                    match m with
-                    | FStar_Syntax_Syntax.Meta_monadic uu___4 ->
-                        let uu___5 =
-                          let uu___6 = FStar_Syntax_Subst.compress t1 in
-                          uu___6.FStar_Syntax_Syntax.n in
-                        (match uu___5 with
-                         | FStar_Syntax_Syntax.Tm_meta
-                             (t', FStar_Syntax_Syntax.Meta_monadic uu___6) ->
-                             FStar_Syntax_Syntax.mk
-                               (FStar_Syntax_Syntax.Tm_meta (t', m)) r
-                         | uu___6 ->
-                             FStar_Syntax_Syntax.mk
-                               (FStar_Syntax_Syntax.Tm_meta (t1, m)) r)
-                    | uu___4 ->
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_meta (t1, m)) r in
-                  rebuild cfg env1 stack2 t2
-              | (MemoLazy r)::stack2 ->
-                  (set_memo cfg r (env1, t1);
-                   FStar_TypeChecker_Cfg.log cfg
-                     (fun uu___5 ->
-                        let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                        FStar_Compiler_Util.print1 "\tSet memo %s\n" uu___6);
-                   rebuild cfg env1 stack2 t1)
-              | (Let (env', bs, lb, r))::stack2 ->
-                  let body = FStar_Syntax_Subst.close bs t1 in
-                  let t2 =
-                    FStar_Syntax_Syntax.mk
-                      (FStar_Syntax_Syntax.Tm_let ((false, [lb]), body)) r in
-                  rebuild cfg env' stack2 t2
-              | (Abs (env', bs, env'', lopt, r))::stack2 ->
-                  let bs1 = norm_binders cfg env' bs in
-                  let lopt1 =
-                    FStar_Compiler_Util.map_option
-                      (norm_residual_comp cfg env'') lopt in
-                  let uu___3 =
-                    let uu___4 = FStar_Syntax_Util.abs bs1 t1 lopt1 in
-                    {
-                      FStar_Syntax_Syntax.n = (uu___4.FStar_Syntax_Syntax.n);
-                      FStar_Syntax_Syntax.pos = r;
-                      FStar_Syntax_Syntax.vars =
-                        (uu___4.FStar_Syntax_Syntax.vars);
-                      FStar_Syntax_Syntax.hash_code =
-                        (uu___4.FStar_Syntax_Syntax.hash_code)
-                    } in
-                  rebuild cfg env1 stack2 uu___3
-              | (Arg (Univ uu___3, uu___4, uu___5))::uu___6 ->
-                  failwith "Impossible"
-              | (Arg (Dummy, uu___3, uu___4))::uu___5 ->
-                  failwith "Impossible"
-              | (UnivArgs (us, r))::stack2 ->
-                  let t2 = FStar_Syntax_Syntax.mk_Tm_uinst t1 us in
-                  rebuild cfg env1 stack2 t2
-              | (Arg (Clos (env_arg, tm, uu___3, uu___4), aq, r))::stack2
-                  when
-                  let uu___5 = head_of t1 in
-                  FStar_Syntax_Util.is_fstar_tactics_by_tactic uu___5 ->
-                  let t2 =
-                    let uu___5 =
-                      let uu___6 = closure_as_term cfg env_arg tm in
-                      (uu___6, aq) in
-                    FStar_Syntax_Syntax.extend_app t1 uu___5 r in
-                  rebuild cfg env1 stack2 t2
-              | (Arg (Clos (env_arg, tm, m, uu___3), aq, r))::stack2 ->
-                  (FStar_TypeChecker_Cfg.log cfg
-                     (fun uu___5 ->
-                        let uu___6 = FStar_Syntax_Print.term_to_string tm in
-                        FStar_Compiler_Util.print1 "Rebuilding with arg %s\n"
-                          uu___6);
-                   if
-                     Prims.op_Negation
-                       (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.iota
-                   then
-                     (let uu___5 =
-                        (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.hnf
-                          &&
-                          (let uu___6 = is_partial_primop_app cfg t1 in
-                           Prims.op_Negation uu___6) in
-                      if uu___5
-                      then
-                        let arg = closure_as_term cfg env_arg tm in
-                        let t2 =
-                          FStar_Syntax_Syntax.extend_app t1 (arg, aq) r in
-                        rebuild cfg env_arg stack2 t2
-                      else
-                        (let stack3 = (App (env1, t1, aq, r)) :: stack2 in
-                         norm cfg env_arg stack3 tm))
-                   else
-                     (let uu___6 = FStar_Compiler_Effect.op_Bang m in
-                      match uu___6 with
-                      | FStar_Pervasives_Native.None ->
-                          let uu___7 =
-                            (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.hnf
-                              &&
-                              (let uu___8 = is_partial_primop_app cfg t1 in
-                               Prims.op_Negation uu___8) in
-                          if uu___7
-                          then
-                            let arg = closure_as_term cfg env_arg tm in
-                            let t2 =
-                              FStar_Syntax_Syntax.extend_app t1 (arg, aq) r in
-                            rebuild cfg env_arg stack2 t2
-                          else
-                            (let stack3 = (MemoLazy m) ::
-                               (App (env1, t1, aq, r)) :: stack2 in
-                             norm cfg env_arg stack3 tm)
-                      | FStar_Pervasives_Native.Some (uu___7, a) ->
-                          let t2 =
-                            FStar_Syntax_Syntax.extend_app t1 (a, aq) r in
-                          rebuild cfg env_arg stack2 t2))
-              | (App (env2, head, aq, r))::stack' when
-                  should_reify cfg stack1 ->
-                  let t0 = t1 in
-                  let fallback msg uu___3 =
-                    FStar_TypeChecker_Cfg.log cfg
-                      (fun uu___5 ->
-                         let uu___6 = FStar_Syntax_Print.term_to_string t1 in
-                         FStar_Compiler_Util.print2 "Not reifying%s: %s\n"
-                           msg uu___6);
-                    (let t2 = FStar_Syntax_Syntax.extend_app head (t1, aq) r in
-                     rebuild cfg env2 stack' t2) in
-                  let is_non_tac_layered_effect m =
-                    let norm_m =
-                      FStar_Compiler_Effect.op_Bar_Greater m
-                        (FStar_TypeChecker_Env.norm_eff_name
-                           cfg.FStar_TypeChecker_Cfg.tcenv) in
-                    (let uu___3 =
-                       FStar_Ident.lid_equals norm_m
-                         FStar_Parser_Const.effect_TAC_lid in
-                     Prims.op_Negation uu___3) &&
-                      (FStar_Compiler_Effect.op_Bar_Greater norm_m
-                         (FStar_TypeChecker_Env.is_layered_effect
-                            cfg.FStar_TypeChecker_Cfg.tcenv)) in
-                  let uu___3 =
-                    let uu___4 = FStar_Syntax_Subst.compress t1 in
-                    uu___4.FStar_Syntax_Syntax.n in
-                  (match uu___3 with
-                   | FStar_Syntax_Syntax.Tm_meta
-                       (uu___4, FStar_Syntax_Syntax.Meta_monadic (m, uu___5))
-                       when
-                       (FStar_Compiler_Effect.op_Bar_Greater m
-                          is_non_tac_layered_effect)
-                         &&
-                         (Prims.op_Negation
-                            (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction)
-                       ->
-                       let uu___6 =
-                         let uu___7 = FStar_Ident.string_of_lid m in
-                         FStar_Compiler_Util.format1
-                           "Meta_monadic for a non-TAC layered effect %s in non-extraction mode"
-                           uu___7 in
-                       fallback uu___6 ()
-                   | FStar_Syntax_Syntax.Tm_meta
-                       (uu___4, FStar_Syntax_Syntax.Meta_monadic_lift
-                        (msrc, mtgt, uu___5))
-                       when
-                       ((is_non_tac_layered_effect msrc) ||
-                          (is_non_tac_layered_effect mtgt))
-                         &&
-                         (Prims.op_Negation
-                            (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.for_extraction)
-                       ->
-                       let uu___6 =
-                         let uu___7 = FStar_Ident.string_of_lid msrc in
-                         let uu___8 = FStar_Ident.string_of_lid mtgt in
-                         FStar_Compiler_Util.format2
-                           "Meta_monadic_lift for a non-TAC layered effect %s ~> %s in non extraction mode"
-                           uu___7 uu___8 in
-                       fallback uu___6 ()
-                   | FStar_Syntax_Syntax.Tm_meta
-                       (t2, FStar_Syntax_Syntax.Meta_monadic (m, ty)) ->
-                       do_reify_monadic (fallback " (1)") cfg env2 stack1 t2
-                         m ty
-                   | FStar_Syntax_Syntax.Tm_meta
-                       (t2, FStar_Syntax_Syntax.Meta_monadic_lift
-                        (msrc, mtgt, ty))
-                       ->
-                       let lifted =
-                         let uu___4 = closure_as_term cfg env2 ty in
-                         reify_lift cfg t2 msrc mtgt uu___4 in
-                       (FStar_TypeChecker_Cfg.log cfg
-                          (fun uu___5 ->
-                             let uu___6 =
-                               FStar_Syntax_Print.term_to_string lifted in
-                             FStar_Compiler_Util.print1
-                               "Reified lift to (1): %s\n" uu___6);
-                        (let uu___5 = FStar_Compiler_List.tl stack1 in
-                         norm cfg env2 uu___5 lifted))
-                   | FStar_Syntax_Syntax.Tm_app
-                       ({
-                          FStar_Syntax_Syntax.n =
-                            FStar_Syntax_Syntax.Tm_constant
-                            (FStar_Const.Const_reflect uu___4);
-                          FStar_Syntax_Syntax.pos = uu___5;
-                          FStar_Syntax_Syntax.vars = uu___6;
-                          FStar_Syntax_Syntax.hash_code = uu___7;_},
-                        (e, uu___8)::[])
-                       -> norm cfg env2 stack' e
-                   | FStar_Syntax_Syntax.Tm_app uu___4 when
-                       (cfg.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.primops
-                       ->
-                       let uu___5 = FStar_Syntax_Util.head_and_args t1 in
-                       (match uu___5 with
-                        | (hd, args) ->
-                            let uu___6 =
-                              let uu___7 = FStar_Syntax_Util.un_uinst hd in
-                              uu___7.FStar_Syntax_Syntax.n in
-                            (match uu___6 with
-                             | FStar_Syntax_Syntax.Tm_fvar fv ->
-                                 let uu___7 =
-                                   FStar_TypeChecker_Cfg.find_prim_step cfg
-                                     fv in
-                                 (match uu___7 with
-                                  | FStar_Pervasives_Native.Some
-                                      { FStar_TypeChecker_Cfg.name = uu___8;
-                                        FStar_TypeChecker_Cfg.arity = uu___9;
-                                        FStar_TypeChecker_Cfg.univ_arity =
-                                          uu___10;
-                                        FStar_TypeChecker_Cfg.auto_reflect =
-                                          FStar_Pervasives_Native.Some n;
-                                        FStar_TypeChecker_Cfg.strong_reduction_ok
-                                          = uu___11;
-                                        FStar_TypeChecker_Cfg.requires_binder_substitution
-                                          = uu___12;
-                                        FStar_TypeChecker_Cfg.interpretation
-                                          = uu___13;
-                                        FStar_TypeChecker_Cfg.interpretation_nbe
-                                          = uu___14;_}
-                                      when
-                                      (FStar_Compiler_List.length args) = n
-                                      -> norm cfg env2 stack' t1
-                                  | uu___8 -> fallback " (3)" ())
-                             | uu___7 -> fallback " (4)" ()))
-                   | uu___4 -> fallback " (2)" ())
-              | (App (env2, head, aq, r))::stack2 ->
-                  let t2 = FStar_Syntax_Syntax.extend_app head (t1, aq) r in
-                  rebuild cfg env2 stack2 t2
-              | (CBVApp (env', head, aq, r))::stack2 ->
-                  let uu___3 =
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              FStar_Compiler_Util.mk_ref
-                                FStar_Pervasives_Native.None in
-                            (env1, t1, uu___8, false) in
-                          Clos uu___7 in
-                        (uu___6, aq, (t1.FStar_Syntax_Syntax.pos)) in
-                      Arg uu___5 in
-                    uu___4 :: stack2 in
-                  norm cfg env' uu___3 head
-              | (Match (env', asc_opt, branches1, lopt, cfg1, r))::stack2 ->
-                  let lopt1 =
-                    FStar_Compiler_Util.map_option
-                      (norm_residual_comp cfg1 env') lopt in
-                  (FStar_TypeChecker_Cfg.log cfg1
-                     (fun uu___4 ->
-                        let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                        FStar_Compiler_Util.print1
-                          "Rebuilding with match, scrutinee is %s ...\n"
-                          uu___5);
-                   (let scrutinee_env = env1 in
-                    let env2 = env' in
-                    let scrutinee = t1 in
-                    let norm_and_rebuild_match uu___4 =
-                      FStar_TypeChecker_Cfg.log cfg1
-                        (fun uu___6 ->
-                           let uu___7 =
-                             FStar_Syntax_Print.term_to_string scrutinee in
-                           let uu___8 =
-                             let uu___9 =
-                               FStar_Compiler_Effect.op_Bar_Greater branches1
-                                 (FStar_Compiler_List.map
-                                    (fun uu___10 ->
-                                       match uu___10 with
-                                       | (p, uu___11, uu___12) ->
-                                           FStar_Syntax_Print.pat_to_string p)) in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___9
-                               (FStar_String.concat "\n\t") in
-                           FStar_Compiler_Util.print2
-                             "match is irreducible: scrutinee=%s\nbranches=%s\n"
-                             uu___7 uu___8);
-                      (let whnf =
-                         (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak
-                           ||
-                           (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.hnf in
-                       let cfg_exclude_zeta =
-                         if
-                           (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.zeta_full
-                         then cfg1
-                         else
-                           (let new_delta =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                cfg1.FStar_TypeChecker_Cfg.delta_level
-                                (FStar_Compiler_List.filter
-                                   (fun uu___7 ->
-                                      match uu___7 with
-                                      | FStar_TypeChecker_Env.InliningDelta
-                                          -> true
-                                      | FStar_TypeChecker_Env.Eager_unfolding_only
-                                          -> true
-                                      | uu___8 -> false)) in
-                            let steps =
-                              let uu___7 = cfg1.FStar_TypeChecker_Cfg.steps in
-                              {
-                                FStar_TypeChecker_Cfg.beta =
-                                  (uu___7.FStar_TypeChecker_Cfg.beta);
-                                FStar_TypeChecker_Cfg.iota =
-                                  (uu___7.FStar_TypeChecker_Cfg.iota);
-                                FStar_TypeChecker_Cfg.zeta = false;
-                                FStar_TypeChecker_Cfg.zeta_full =
-                                  (uu___7.FStar_TypeChecker_Cfg.zeta_full);
-                                FStar_TypeChecker_Cfg.weak =
-                                  (uu___7.FStar_TypeChecker_Cfg.weak);
-                                FStar_TypeChecker_Cfg.hnf =
-                                  (uu___7.FStar_TypeChecker_Cfg.hnf);
-                                FStar_TypeChecker_Cfg.primops =
-                                  (uu___7.FStar_TypeChecker_Cfg.primops);
-                                FStar_TypeChecker_Cfg.do_not_unfold_pure_lets
-                                  =
-                                  (uu___7.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                                FStar_TypeChecker_Cfg.unfold_until =
-                                  FStar_Pervasives_Native.None;
-                                FStar_TypeChecker_Cfg.unfold_only =
-                                  FStar_Pervasives_Native.None;
-                                FStar_TypeChecker_Cfg.unfold_fully =
-                                  (uu___7.FStar_TypeChecker_Cfg.unfold_fully);
-                                FStar_TypeChecker_Cfg.unfold_attr =
-                                  FStar_Pervasives_Native.None;
-                                FStar_TypeChecker_Cfg.unfold_qual =
-                                  FStar_Pervasives_Native.None;
-                                FStar_TypeChecker_Cfg.unfold_namespace =
-                                  FStar_Pervasives_Native.None;
-                                FStar_TypeChecker_Cfg.unfold_tac = false;
-                                FStar_TypeChecker_Cfg.pure_subterms_within_computations
-                                  =
-                                  (uu___7.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                                FStar_TypeChecker_Cfg.simplify =
-                                  (uu___7.FStar_TypeChecker_Cfg.simplify);
-                                FStar_TypeChecker_Cfg.erase_universes =
-                                  (uu___7.FStar_TypeChecker_Cfg.erase_universes);
-                                FStar_TypeChecker_Cfg.allow_unbound_universes
-                                  =
-                                  (uu___7.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                                FStar_TypeChecker_Cfg.reify_ =
-                                  (uu___7.FStar_TypeChecker_Cfg.reify_);
-                                FStar_TypeChecker_Cfg.compress_uvars =
-                                  (uu___7.FStar_TypeChecker_Cfg.compress_uvars);
-                                FStar_TypeChecker_Cfg.no_full_norm =
-                                  (uu___7.FStar_TypeChecker_Cfg.no_full_norm);
-                                FStar_TypeChecker_Cfg.check_no_uvars =
-                                  (uu___7.FStar_TypeChecker_Cfg.check_no_uvars);
-                                FStar_TypeChecker_Cfg.unmeta =
-                                  (uu___7.FStar_TypeChecker_Cfg.unmeta);
-                                FStar_TypeChecker_Cfg.unascribe =
-                                  (uu___7.FStar_TypeChecker_Cfg.unascribe);
-                                FStar_TypeChecker_Cfg.in_full_norm_request =
-                                  (uu___7.FStar_TypeChecker_Cfg.in_full_norm_request);
-                                FStar_TypeChecker_Cfg.weakly_reduce_scrutinee
-                                  =
-                                  (uu___7.FStar_TypeChecker_Cfg.weakly_reduce_scrutinee);
-                                FStar_TypeChecker_Cfg.nbe_step =
-                                  (uu___7.FStar_TypeChecker_Cfg.nbe_step);
-                                FStar_TypeChecker_Cfg.for_extraction =
-                                  (uu___7.FStar_TypeChecker_Cfg.for_extraction);
-                                FStar_TypeChecker_Cfg.unrefine =
-                                  (uu___7.FStar_TypeChecker_Cfg.unrefine)
-                              } in
-                            {
-                              FStar_TypeChecker_Cfg.steps = steps;
-                              FStar_TypeChecker_Cfg.tcenv =
-                                (cfg1.FStar_TypeChecker_Cfg.tcenv);
-                              FStar_TypeChecker_Cfg.debug =
-                                (cfg1.FStar_TypeChecker_Cfg.debug);
-                              FStar_TypeChecker_Cfg.delta_level = new_delta;
-                              FStar_TypeChecker_Cfg.primitive_steps =
-                                (cfg1.FStar_TypeChecker_Cfg.primitive_steps);
-                              FStar_TypeChecker_Cfg.strong = true;
-                              FStar_TypeChecker_Cfg.memoize_lazy =
-                                (cfg1.FStar_TypeChecker_Cfg.memoize_lazy);
-                              FStar_TypeChecker_Cfg.normalize_pure_lets =
-                                (cfg1.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                              FStar_TypeChecker_Cfg.reifying =
-                                (cfg1.FStar_TypeChecker_Cfg.reifying)
-                            }) in
-                       let norm_or_whnf env3 t2 =
-                         if whnf
-                         then closure_as_term cfg_exclude_zeta env3 t2
-                         else norm cfg_exclude_zeta env3 [] t2 in
-                       let rec norm_pat env3 p =
-                         match p.FStar_Syntax_Syntax.v with
-                         | FStar_Syntax_Syntax.Pat_constant uu___6 ->
-                             (p, env3)
-                         | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-                             let us_opt1 =
-                               if
-                                 (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.erase_universes
-                               then FStar_Pervasives_Native.None
-                               else
-                                 (match us_opt with
-                                  | FStar_Pervasives_Native.None ->
-                                      FStar_Pervasives_Native.None
-                                  | FStar_Pervasives_Native.Some us ->
-                                      let uu___7 =
-                                        FStar_Compiler_List.map
-                                          (norm_universe cfg1 env3) us in
-                                      FStar_Pervasives_Native.Some uu___7) in
-                             let uu___6 =
-                               FStar_Compiler_Effect.op_Bar_Greater pats
-                                 (FStar_Compiler_List.fold_left
-                                    (fun uu___7 ->
-                                       fun uu___8 ->
-                                         match (uu___7, uu___8) with
-                                         | ((pats1, env4), (p1, b)) ->
-                                             let uu___9 = norm_pat env4 p1 in
-                                             (match uu___9 with
-                                              | (p2, env5) ->
-                                                  (((p2, b) :: pats1), env5)))
-                                    ([], env3)) in
-                             (match uu___6 with
-                              | (pats1, env4) ->
-                                  ({
-                                     FStar_Syntax_Syntax.v =
-                                       (FStar_Syntax_Syntax.Pat_cons
-                                          (fv, us_opt1,
-                                            (FStar_Compiler_List.rev pats1)));
-                                     FStar_Syntax_Syntax.p =
-                                       (p.FStar_Syntax_Syntax.p)
-                                   }, env4))
-                         | FStar_Syntax_Syntax.Pat_var x ->
-                             let x1 =
-                               let uu___6 =
-                                 norm_or_whnf env3 x.FStar_Syntax_Syntax.sort in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (x.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (x.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = uu___6
-                               } in
-                             ({
-                                FStar_Syntax_Syntax.v =
-                                  (FStar_Syntax_Syntax.Pat_var x1);
-                                FStar_Syntax_Syntax.p =
-                                  (p.FStar_Syntax_Syntax.p)
-                              }, (dummy :: env3))
-                         | FStar_Syntax_Syntax.Pat_wild x ->
-                             let x1 =
-                               let uu___6 =
-                                 norm_or_whnf env3 x.FStar_Syntax_Syntax.sort in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (x.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (x.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = uu___6
-                               } in
-                             ({
-                                FStar_Syntax_Syntax.v =
-                                  (FStar_Syntax_Syntax.Pat_wild x1);
-                                FStar_Syntax_Syntax.p =
-                                  (p.FStar_Syntax_Syntax.p)
-                              }, (dummy :: env3))
-                         | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-                             let eopt1 =
-                               FStar_Compiler_Util.map_option
-                                 (norm_or_whnf env3) eopt in
-                             ({
-                                FStar_Syntax_Syntax.v =
-                                  (FStar_Syntax_Syntax.Pat_dot_term eopt1);
-                                FStar_Syntax_Syntax.p =
-                                  (p.FStar_Syntax_Syntax.p)
-                              }, env3) in
-                       let norm_branches uu___6 =
-                         match env2 with
-                         | [] when whnf -> branches1
-                         | uu___7 ->
-                             FStar_Compiler_Effect.op_Bar_Greater branches1
-                               (FStar_Compiler_List.map
-                                  (fun branch ->
-                                     let uu___8 =
-                                       FStar_Syntax_Subst.open_branch branch in
-                                     match uu___8 with
-                                     | (p, wopt, e) ->
-                                         let uu___9 = norm_pat env2 p in
-                                         (match uu___9 with
-                                          | (p1, env3) ->
-                                              let wopt1 =
-                                                match wopt with
-                                                | FStar_Pervasives_Native.None
-                                                    ->
-                                                    FStar_Pervasives_Native.None
-                                                | FStar_Pervasives_Native.Some
-                                                    w ->
-                                                    let uu___10 =
-                                                      norm_or_whnf env3 w in
-                                                    FStar_Pervasives_Native.Some
-                                                      uu___10 in
-                                              let e1 = norm_or_whnf env3 e in
-                                              FStar_Syntax_Util.branch
-                                                (p1, wopt1, e1)))) in
-                       let maybe_commute_matches uu___6 =
-                         let can_commute =
-                           match branches1 with
-                           | ({
-                                FStar_Syntax_Syntax.v =
-                                  FStar_Syntax_Syntax.Pat_cons
-                                  (fv, uu___7, uu___8);
-                                FStar_Syntax_Syntax.p = uu___9;_},
-                              uu___10, uu___11)::uu___12 ->
-                               FStar_TypeChecker_Env.fv_has_attr
-                                 cfg1.FStar_TypeChecker_Cfg.tcenv fv
-                                 FStar_Parser_Const.commute_nested_matches_lid
-                           | uu___7 -> false in
-                         let uu___7 =
-                           let uu___8 = FStar_Syntax_Util.unascribe scrutinee in
-                           uu___8.FStar_Syntax_Syntax.n in
-                         match uu___7 with
-                         | FStar_Syntax_Syntax.Tm_match
-                             (sc0, asc_opt0, branches0, lopt0) when
-                             can_commute ->
-                             let reduce_branch b =
-                               let stack3 =
-                                 [Match
-                                    (env', asc_opt, branches1, lopt1, cfg1,
-                                      r)] in
-                               let uu___8 = FStar_Syntax_Subst.open_branch b in
-                               match uu___8 with
-                               | (p, wopt, e) ->
-                                   let uu___9 = norm_pat scrutinee_env p in
-                                   (match uu___9 with
-                                    | (p1, branch_env) ->
-                                        let wopt1 =
-                                          match wopt with
-                                          | FStar_Pervasives_Native.None ->
-                                              FStar_Pervasives_Native.None
-                                          | FStar_Pervasives_Native.Some w ->
-                                              let uu___10 =
-                                                norm_or_whnf branch_env w in
-                                              FStar_Pervasives_Native.Some
-                                                uu___10 in
-                                        let e1 =
-                                          norm cfg1 branch_env stack3 e in
-                                        FStar_Syntax_Util.branch
-                                          (p1, wopt1, e1)) in
-                             let branches01 =
-                               FStar_Compiler_List.map reduce_branch
-                                 branches0 in
-                             let uu___8 =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_match
-                                    (sc0, asc_opt0, branches01, lopt0)) r in
-                             rebuild cfg1 env2 stack2 uu___8
-                         | uu___8 ->
-                             let scrutinee1 =
-                               let uu___9 =
-                                 ((((cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.iota
-                                      &&
-                                      (Prims.op_Negation
-                                         (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weak))
-                                     &&
-                                     (Prims.op_Negation
-                                        (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.compress_uvars))
-                                    &&
-                                    (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.weakly_reduce_scrutinee)
-                                   && (maybe_weakly_reduced scrutinee) in
-                               if uu___9
-                               then
-                                 norm
-                                   {
-                                     FStar_TypeChecker_Cfg.steps =
-                                       (let uu___10 =
-                                          cfg1.FStar_TypeChecker_Cfg.steps in
-                                        {
-                                          FStar_TypeChecker_Cfg.beta =
-                                            (uu___10.FStar_TypeChecker_Cfg.beta);
-                                          FStar_TypeChecker_Cfg.iota =
-                                            (uu___10.FStar_TypeChecker_Cfg.iota);
-                                          FStar_TypeChecker_Cfg.zeta =
-                                            (uu___10.FStar_TypeChecker_Cfg.zeta);
-                                          FStar_TypeChecker_Cfg.zeta_full =
-                                            (uu___10.FStar_TypeChecker_Cfg.zeta_full);
-                                          FStar_TypeChecker_Cfg.weak =
-                                            (uu___10.FStar_TypeChecker_Cfg.weak);
-                                          FStar_TypeChecker_Cfg.hnf =
-                                            (uu___10.FStar_TypeChecker_Cfg.hnf);
-                                          FStar_TypeChecker_Cfg.primops =
-                                            (uu___10.FStar_TypeChecker_Cfg.primops);
-                                          FStar_TypeChecker_Cfg.do_not_unfold_pure_lets
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.do_not_unfold_pure_lets);
-                                          FStar_TypeChecker_Cfg.unfold_until
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_until);
-                                          FStar_TypeChecker_Cfg.unfold_only =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_only);
-                                          FStar_TypeChecker_Cfg.unfold_fully
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_fully);
-                                          FStar_TypeChecker_Cfg.unfold_attr =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_attr);
-                                          FStar_TypeChecker_Cfg.unfold_qual =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_qual);
-                                          FStar_TypeChecker_Cfg.unfold_namespace
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_namespace);
-                                          FStar_TypeChecker_Cfg.unfold_tac =
-                                            (uu___10.FStar_TypeChecker_Cfg.unfold_tac);
-                                          FStar_TypeChecker_Cfg.pure_subterms_within_computations
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.pure_subterms_within_computations);
-                                          FStar_TypeChecker_Cfg.simplify =
-                                            (uu___10.FStar_TypeChecker_Cfg.simplify);
-                                          FStar_TypeChecker_Cfg.erase_universes
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.erase_universes);
-                                          FStar_TypeChecker_Cfg.allow_unbound_universes
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.allow_unbound_universes);
-                                          FStar_TypeChecker_Cfg.reify_ =
-                                            (uu___10.FStar_TypeChecker_Cfg.reify_);
-                                          FStar_TypeChecker_Cfg.compress_uvars
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.compress_uvars);
-                                          FStar_TypeChecker_Cfg.no_full_norm
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.no_full_norm);
-                                          FStar_TypeChecker_Cfg.check_no_uvars
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.check_no_uvars);
-                                          FStar_TypeChecker_Cfg.unmeta =
-                                            (uu___10.FStar_TypeChecker_Cfg.unmeta);
-                                          FStar_TypeChecker_Cfg.unascribe =
-                                            (uu___10.FStar_TypeChecker_Cfg.unascribe);
-                                          FStar_TypeChecker_Cfg.in_full_norm_request
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.in_full_norm_request);
-                                          FStar_TypeChecker_Cfg.weakly_reduce_scrutinee
-                                            = false;
-                                          FStar_TypeChecker_Cfg.nbe_step =
-                                            (uu___10.FStar_TypeChecker_Cfg.nbe_step);
-                                          FStar_TypeChecker_Cfg.for_extraction
-                                            =
-                                            (uu___10.FStar_TypeChecker_Cfg.for_extraction);
-                                          FStar_TypeChecker_Cfg.unrefine =
-                                            (uu___10.FStar_TypeChecker_Cfg.unrefine)
-                                        });
-                                     FStar_TypeChecker_Cfg.tcenv =
-                                       (cfg1.FStar_TypeChecker_Cfg.tcenv);
-                                     FStar_TypeChecker_Cfg.debug =
-                                       (cfg1.FStar_TypeChecker_Cfg.debug);
-                                     FStar_TypeChecker_Cfg.delta_level =
-                                       (cfg1.FStar_TypeChecker_Cfg.delta_level);
-                                     FStar_TypeChecker_Cfg.primitive_steps =
-                                       (cfg1.FStar_TypeChecker_Cfg.primitive_steps);
-                                     FStar_TypeChecker_Cfg.strong =
-                                       (cfg1.FStar_TypeChecker_Cfg.strong);
-                                     FStar_TypeChecker_Cfg.memoize_lazy =
-                                       (cfg1.FStar_TypeChecker_Cfg.memoize_lazy);
-                                     FStar_TypeChecker_Cfg.normalize_pure_lets
-                                       =
-                                       (cfg1.FStar_TypeChecker_Cfg.normalize_pure_lets);
-                                     FStar_TypeChecker_Cfg.reifying =
-                                       (cfg1.FStar_TypeChecker_Cfg.reifying)
-                                   } scrutinee_env [] scrutinee
-                               else scrutinee in
-                             let asc_opt1 =
-                               norm_match_returns cfg1 env2 asc_opt in
-                             let branches2 = norm_branches () in
-                             let uu___9 =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_match
-                                    (scrutinee1, asc_opt1, branches2, lopt1))
-                                 r in
-                             rebuild cfg1 env2 stack2 uu___9 in
-                       maybe_commute_matches ()) in
-                    let rec is_cons head =
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Subst.compress head in
-                        uu___5.FStar_Syntax_Syntax.n in
-                      match uu___4 with
-                      | FStar_Syntax_Syntax.Tm_uinst (h, uu___5) -> is_cons h
-                      | FStar_Syntax_Syntax.Tm_constant uu___5 -> true
-                      | FStar_Syntax_Syntax.Tm_fvar
-                          { FStar_Syntax_Syntax.fv_name = uu___5;
-                            FStar_Syntax_Syntax.fv_delta = uu___6;
-                            FStar_Syntax_Syntax.fv_qual =
-                              FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Data_ctor);_}
-                          -> true
-                      | FStar_Syntax_Syntax.Tm_fvar
-                          { FStar_Syntax_Syntax.fv_name = uu___5;
-                            FStar_Syntax_Syntax.fv_delta = uu___6;
-                            FStar_Syntax_Syntax.fv_qual =
-                              FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Record_ctor uu___7);_}
-                          -> true
-                      | uu___5 -> false in
-                    let guard_when_clause wopt b rest =
-                      match wopt with
-                      | FStar_Pervasives_Native.None -> b
-                      | FStar_Pervasives_Native.Some w ->
-                          let then_branch = b in
-                          let else_branch =
-                            FStar_Syntax_Syntax.mk
-                              (FStar_Syntax_Syntax.Tm_match
-                                 (scrutinee, asc_opt, rest, lopt1)) r in
-                          FStar_Syntax_Util.if_then_else w then_branch
-                            else_branch in
-                    let rec matches_pat scrutinee_orig p =
-                      let scrutinee1 =
-                        FStar_Syntax_Util.unmeta scrutinee_orig in
-                      let scrutinee2 = FStar_Syntax_Util.unlazy scrutinee1 in
-                      let uu___4 = FStar_Syntax_Util.head_and_args scrutinee2 in
-                      match uu___4 with
-                      | (head, args) ->
-                          (match p.FStar_Syntax_Syntax.v with
-                           | FStar_Syntax_Syntax.Pat_var bv ->
-                               FStar_Pervasives.Inl [(bv, scrutinee_orig)]
-                           | FStar_Syntax_Syntax.Pat_wild bv ->
-                               FStar_Pervasives.Inl [(bv, scrutinee_orig)]
-                           | FStar_Syntax_Syntax.Pat_dot_term uu___5 ->
-                               FStar_Pervasives.Inl []
-                           | FStar_Syntax_Syntax.Pat_constant s ->
-                               (match scrutinee2.FStar_Syntax_Syntax.n with
-                                | FStar_Syntax_Syntax.Tm_constant s' when
-                                    FStar_Const.eq_const s s' ->
-                                    FStar_Pervasives.Inl []
-                                | uu___5 ->
-                                    let uu___6 =
-                                      let uu___7 = is_cons head in
-                                      Prims.op_Negation uu___7 in
-                                    FStar_Pervasives.Inr uu___6)
-                           | FStar_Syntax_Syntax.Pat_cons
-                               (fv, uu___5, arg_pats) ->
-                               let uu___6 =
-                                 let uu___7 = FStar_Syntax_Util.un_uinst head in
-                                 uu___7.FStar_Syntax_Syntax.n in
-                               (match uu___6 with
-                                | FStar_Syntax_Syntax.Tm_fvar fv' when
-                                    FStar_Syntax_Syntax.fv_eq fv fv' ->
-                                    matches_args [] args arg_pats
-                                | uu___7 ->
-                                    let uu___8 =
-                                      let uu___9 = is_cons head in
-                                      Prims.op_Negation uu___9 in
-                                    FStar_Pervasives.Inr uu___8))
-                    and matches_args out a p =
-                      match (a, p) with
-                      | ([], []) -> FStar_Pervasives.Inl out
-                      | ((t2, uu___4)::rest_a, (p1, uu___5)::rest_p) ->
-                          let uu___6 = matches_pat t2 p1 in
-                          (match uu___6 with
-                           | FStar_Pervasives.Inl s ->
-                               matches_args (FStar_Compiler_List.op_At out s)
-                                 rest_a rest_p
-                           | m -> m)
-                      | uu___4 -> FStar_Pervasives.Inr false in
-                    let rec matches scrutinee1 p =
-                      match p with
-                      | [] -> norm_and_rebuild_match ()
-                      | (p1, wopt, b)::rest ->
-                          let uu___4 = matches_pat scrutinee1 p1 in
-                          (match uu___4 with
-                           | FStar_Pervasives.Inr (false) ->
-                               matches scrutinee1 rest
-                           | FStar_Pervasives.Inr (true) ->
-                               norm_and_rebuild_match ()
-                           | FStar_Pervasives.Inl s ->
-                               (FStar_TypeChecker_Cfg.log cfg1
-                                  (fun uu___6 ->
-                                     let uu___7 =
-                                       FStar_Syntax_Print.pat_to_string p1 in
-                                     let uu___8 =
-                                       let uu___9 =
-                                         FStar_Compiler_List.map
-                                           (fun uu___10 ->
-                                              match uu___10 with
-                                              | (uu___11, t2) ->
-                                                  FStar_Syntax_Print.term_to_string
-                                                    t2) s in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___9 (FStar_String.concat "; ") in
-                                     FStar_Compiler_Util.print2
-                                       "Matches pattern %s with subst = %s\n"
-                                       uu___7 uu___8);
-                                (let env0 = env2 in
-                                 let env3 =
-                                   FStar_Compiler_List.fold_left
-                                     (fun env4 ->
-                                        fun uu___6 ->
-                                          match uu___6 with
-                                          | (bv, t2) ->
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  let uu___9 =
-                                                    FStar_Syntax_Syntax.mk_binder
-                                                      bv in
-                                                  FStar_Pervasives_Native.Some
-                                                    uu___9 in
-                                                let uu___9 =
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      FStar_Compiler_Util.mk_ref
-                                                        (if
-                                                           (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.hnf
-                                                         then
-                                                           FStar_Pervasives_Native.None
-                                                         else
-                                                           FStar_Pervasives_Native.Some
-                                                             ([], t2)) in
-                                                    ([], t2, uu___11, false) in
-                                                  Clos uu___10 in
-                                                (uu___8, uu___9) in
-                                              uu___7 :: env4) env2 s in
-                                 let uu___6 = guard_when_clause wopt b rest in
-                                 norm cfg1 env3 stack2 uu___6))) in
-                    if
-                      (cfg1.FStar_TypeChecker_Cfg.steps).FStar_TypeChecker_Cfg.iota
-                    then matches scrutinee branches1
-                    else norm_and_rebuild_match ()))))
-and (norm_match_returns :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.match_returns_ascription
-        FStar_Pervasives_Native.option ->
-        (FStar_Syntax_Syntax.binder *
-          ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-          FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-          Prims.bool)) FStar_Pervasives_Native.option)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun ret_opt ->
-        match ret_opt with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some (b, asc) ->
-            let b1 = norm_binder cfg env1 b in
-            let uu___ = FStar_Syntax_Subst.open_ascription [b1] asc in
-            (match uu___ with
-             | (subst, asc1) ->
-                 let asc2 = norm_ascription cfg (dummy :: env1) asc1 in
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_Syntax_Subst.close_ascription subst asc2 in
-                   (b1, uu___2) in
-                 FStar_Pervasives_Native.Some uu___1)
-and (norm_ascription :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-        FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-        FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-        Prims.bool) ->
-        ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-          FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-          FStar_Pervasives.either * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax FStar_Pervasives_Native.option *
-          Prims.bool))
-  =
-  fun cfg ->
-    fun env1 ->
-      fun uu___ ->
-        match uu___ with
-        | (tc, tacopt, use_eq) ->
-            let uu___1 =
-              match tc with
-              | FStar_Pervasives.Inl t ->
-                  let uu___2 = norm cfg env1 [] t in
-                  FStar_Pervasives.Inl uu___2
-              | FStar_Pervasives.Inr c ->
-                  let uu___2 = norm_comp cfg env1 c in
-                  FStar_Pervasives.Inr uu___2 in
-            let uu___2 =
-              FStar_Compiler_Util.map_opt tacopt (norm cfg env1 []) in
-            (uu___1, uu___2, use_eq)
-and (norm_residual_comp :
-  FStar_TypeChecker_Cfg.cfg ->
-    env ->
-      FStar_Syntax_Syntax.residual_comp -> FStar_Syntax_Syntax.residual_comp)
-  =
-  fun cfg ->
-    fun env1 ->
-      fun rc ->
-        let uu___ =
-          FStar_Compiler_Util.map_option (closure_as_term cfg env1)
-            rc.FStar_Syntax_Syntax.residual_typ in
-        {
-          FStar_Syntax_Syntax.residual_effect =
-            (rc.FStar_Syntax_Syntax.residual_effect);
-          FStar_Syntax_Syntax.residual_typ = uu___;
-          FStar_Syntax_Syntax.residual_flags =
-            (rc.FStar_Syntax_Syntax.residual_flags)
-        }
-let (reflection_env_hook :
-  FStar_TypeChecker_Env.env FStar_Pervasives_Native.option
-    FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (normalize_with_primitive_steps :
-  FStar_TypeChecker_Cfg.primitive_step Prims.list ->
-    FStar_TypeChecker_Env.steps ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun ps ->
-    fun s ->
-      fun e ->
-        fun t ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.current_module e in
-              FStar_Ident.string_of_lid uu___2 in
-            FStar_Pervasives_Native.Some uu___1 in
-          FStar_Profiling.profile
-            (fun uu___1 ->
-               let c = FStar_TypeChecker_Cfg.config' ps s e in
-               FStar_Compiler_Effect.op_Colon_Equals reflection_env_hook
-                 (FStar_Pervasives_Native.Some e);
-               FStar_Compiler_Effect.op_Colon_Equals plugin_unfold_warn_ctr
-                 (Prims.of_int (10));
-               FStar_TypeChecker_Cfg.log_cfg c
-                 (fun uu___5 ->
-                    let uu___6 = FStar_TypeChecker_Cfg.cfg_to_string c in
-                    FStar_Compiler_Util.print1 "Cfg = %s\n" uu___6);
-               (let uu___5 = is_nbe_request s in
-                if uu___5
-                then
-                  (FStar_TypeChecker_Cfg.log_top c
-                     (fun uu___7 ->
-                        let uu___8 = FStar_Syntax_Print.term_to_string t in
-                        FStar_Compiler_Util.print1
-                          "Starting NBE for (%s) {\n" uu___8);
-                   FStar_TypeChecker_Cfg.log_top c
-                     (fun uu___8 ->
-                        let uu___9 = FStar_TypeChecker_Cfg.cfg_to_string c in
-                        FStar_Compiler_Util.print1 ">>> cfg = %s\n" uu___9);
-                   (let uu___8 =
-                      FStar_Errors.with_ctx
-                        "While normalizing a term via NBE"
-                        (fun uu___9 ->
-                           FStar_Compiler_Util.record_time
-                             (fun uu___10 -> nbe_eval c s t)) in
-                    match uu___8 with
-                    | (r, ms) ->
-                        (FStar_TypeChecker_Cfg.log_top c
-                           (fun uu___10 ->
-                              let uu___11 =
-                                FStar_Syntax_Print.term_to_string r in
-                              let uu___12 =
-                                FStar_Compiler_Util.string_of_int ms in
-                              FStar_Compiler_Util.print2
-                                "}\nNormalization result = (%s) in %s ms\n"
-                                uu___11 uu___12);
-                         r)))
-                else
-                  (FStar_TypeChecker_Cfg.log_top c
-                     (fun uu___8 ->
-                        let uu___9 = FStar_Syntax_Print.term_to_string t in
-                        FStar_Compiler_Util.print1
-                          "Starting normalizer for (%s) {\n" uu___9);
-                   FStar_TypeChecker_Cfg.log_top c
-                     (fun uu___9 ->
-                        let uu___10 = FStar_TypeChecker_Cfg.cfg_to_string c in
-                        FStar_Compiler_Util.print1 ">>> cfg = %s\n" uu___10);
-                   (let uu___9 =
-                      FStar_Errors.with_ctx "While normalizing a term"
-                        (fun uu___10 ->
-                           FStar_Compiler_Util.record_time
-                             (fun uu___11 -> norm c [] [] t)) in
-                    match uu___9 with
-                    | (r, ms) ->
-                        (FStar_TypeChecker_Cfg.log_top c
-                           (fun uu___11 ->
-                              let uu___12 =
-                                FStar_Syntax_Print.term_to_string r in
-                              let uu___13 =
-                                FStar_Compiler_Util.string_of_int ms in
-                              FStar_Compiler_Util.print2
-                                "}\nNormalization result = (%s) in %s ms\n"
-                                uu___12 uu___13);
-                         r))))) uu___
-            "FStar.TypeChecker.Normalize.normalize_with_primitive_steps"
-let (normalize :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun s ->
-    fun e ->
-      fun t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module e in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 -> normalize_with_primitive_steps [] s e t) uu___
-          "FStar.TypeChecker.Normalize.normalize"
-let (normalize_comp :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  =
-  fun s ->
-    fun e ->
-      fun c ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module e in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 ->
-             let cfg = FStar_TypeChecker_Cfg.config s e in
-             FStar_Compiler_Effect.op_Colon_Equals reflection_env_hook
-               (FStar_Pervasives_Native.Some e);
-             FStar_Compiler_Effect.op_Colon_Equals plugin_unfold_warn_ctr
-               (Prims.of_int (10));
-             FStar_TypeChecker_Cfg.log_top cfg
-               (fun uu___5 ->
-                  let uu___6 = FStar_Syntax_Print.comp_to_string c in
-                  FStar_Compiler_Util.print1
-                    "Starting normalizer for computation (%s) {\n" uu___6);
-             FStar_TypeChecker_Cfg.log_top cfg
-               (fun uu___6 ->
-                  let uu___7 = FStar_TypeChecker_Cfg.cfg_to_string cfg in
-                  FStar_Compiler_Util.print1 ">>> cfg = %s\n" uu___7);
-             (let uu___6 =
-                FStar_Errors.with_ctx "While normalizing a computation type"
-                  (fun uu___7 ->
-                     FStar_Compiler_Util.record_time
-                       (fun uu___8 -> norm_comp cfg [] c)) in
-              match uu___6 with
-              | (c1, ms) ->
-                  (FStar_TypeChecker_Cfg.log_top cfg
-                     (fun uu___8 ->
-                        let uu___9 = FStar_Syntax_Print.comp_to_string c1 in
-                        let uu___10 = FStar_Compiler_Util.string_of_int ms in
-                        FStar_Compiler_Util.print2
-                          "}\nNormalization result = (%s) in %s ms\n" uu___9
-                          uu___10);
-                   c1))) uu___ "FStar.TypeChecker.Normalize.normalize_comp"
-let (normalize_universe :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe)
-  =
-  fun env1 ->
-    fun u ->
-      let uu___ = FStar_TypeChecker_Cfg.config [] env1 in
-      norm_universe uu___ [] u
-let (non_info_norm :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env1 ->
-    fun t ->
-      let steps =
-        [FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-        FStar_TypeChecker_Env.AllowUnboundUniverses;
-        FStar_TypeChecker_Env.EraseUniverses;
-        FStar_TypeChecker_Env.HNF;
-        FStar_TypeChecker_Env.Unascribe;
-        FStar_TypeChecker_Env.ForExtraction] in
-      let uu___ = normalize steps env1 t in
-      FStar_TypeChecker_Env.non_informative env1 uu___
-let (maybe_promote_t :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool -> FStar_Syntax_Syntax.term -> Prims.bool)
-  =
-  fun env1 ->
-    fun non_informative_only ->
-      fun t ->
-        (Prims.op_Negation non_informative_only) || (non_info_norm env1 t)
-let (ghost_to_pure_aux :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  =
-  fun env1 ->
-    fun non_informative_only ->
-      fun c ->
-        match c.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Total uu___ -> c
-        | FStar_Syntax_Syntax.GTotal t ->
-            let uu___ = maybe_promote_t env1 non_informative_only t in
-            if uu___
-            then
-              {
-                FStar_Syntax_Syntax.n = (FStar_Syntax_Syntax.Total t);
-                FStar_Syntax_Syntax.pos = (c.FStar_Syntax_Syntax.pos);
-                FStar_Syntax_Syntax.vars = (c.FStar_Syntax_Syntax.vars);
-                FStar_Syntax_Syntax.hash_code =
-                  (c.FStar_Syntax_Syntax.hash_code)
-              }
-            else c
-        | FStar_Syntax_Syntax.Comp ct ->
-            let l =
-              FStar_TypeChecker_Env.norm_eff_name env1
-                ct.FStar_Syntax_Syntax.effect_name in
-            let uu___ =
-              (FStar_Syntax_Util.is_ghost_effect l) &&
-                (maybe_promote_t env1 non_informative_only
-                   ct.FStar_Syntax_Syntax.result_typ) in
-            if uu___
-            then
-              let ct1 =
-                let uu___1 =
-                  downgrade_ghost_effect_name
-                    ct.FStar_Syntax_Syntax.effect_name in
-                match uu___1 with
-                | FStar_Pervasives_Native.Some pure_eff ->
-                    let flags =
-                      let uu___2 =
-                        FStar_Ident.lid_equals pure_eff
-                          FStar_Parser_Const.effect_Tot_lid in
-                      if uu___2
-                      then FStar_Syntax_Syntax.TOTAL ::
-                        (ct.FStar_Syntax_Syntax.flags)
-                      else ct.FStar_Syntax_Syntax.flags in
-                    {
-                      FStar_Syntax_Syntax.comp_univs =
-                        (ct.FStar_Syntax_Syntax.comp_univs);
-                      FStar_Syntax_Syntax.effect_name = pure_eff;
-                      FStar_Syntax_Syntax.result_typ =
-                        (ct.FStar_Syntax_Syntax.result_typ);
-                      FStar_Syntax_Syntax.effect_args =
-                        (ct.FStar_Syntax_Syntax.effect_args);
-                      FStar_Syntax_Syntax.flags = flags
-                    }
-                | FStar_Pervasives_Native.None ->
-                    let ct2 =
-                      FStar_TypeChecker_Env.unfold_effect_abbrev env1 c in
-                    {
-                      FStar_Syntax_Syntax.comp_univs =
-                        (ct2.FStar_Syntax_Syntax.comp_univs);
-                      FStar_Syntax_Syntax.effect_name =
-                        FStar_Parser_Const.effect_PURE_lid;
-                      FStar_Syntax_Syntax.result_typ =
-                        (ct2.FStar_Syntax_Syntax.result_typ);
-                      FStar_Syntax_Syntax.effect_args =
-                        (ct2.FStar_Syntax_Syntax.effect_args);
-                      FStar_Syntax_Syntax.flags =
-                        (ct2.FStar_Syntax_Syntax.flags)
-                    } in
-              {
-                FStar_Syntax_Syntax.n = (FStar_Syntax_Syntax.Comp ct1);
-                FStar_Syntax_Syntax.pos = (c.FStar_Syntax_Syntax.pos);
-                FStar_Syntax_Syntax.vars = (c.FStar_Syntax_Syntax.vars);
-                FStar_Syntax_Syntax.hash_code =
-                  (c.FStar_Syntax_Syntax.hash_code)
-              }
-            else c
-        | uu___ -> c
-let (ghost_to_pure_lcomp_aux :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env1 ->
-    fun non_informative_only ->
-      fun lc ->
-        let uu___ =
-          (FStar_Syntax_Util.is_ghost_effect
-             lc.FStar_TypeChecker_Common.eff_name)
-            &&
-            (maybe_promote_t env1 non_informative_only
-               lc.FStar_TypeChecker_Common.res_typ) in
-        if uu___
-        then
-          let uu___1 =
-            downgrade_ghost_effect_name lc.FStar_TypeChecker_Common.eff_name in
-          match uu___1 with
-          | FStar_Pervasives_Native.Some pure_eff ->
-              let uu___2 =
-                FStar_TypeChecker_Common.apply_lcomp
-                  (ghost_to_pure_aux env1 non_informative_only) (fun g -> g)
-                  lc in
-              {
-                FStar_TypeChecker_Common.eff_name = pure_eff;
-                FStar_TypeChecker_Common.res_typ =
-                  (uu___2.FStar_TypeChecker_Common.res_typ);
-                FStar_TypeChecker_Common.cflags =
-                  (uu___2.FStar_TypeChecker_Common.cflags);
-                FStar_TypeChecker_Common.comp_thunk =
-                  (uu___2.FStar_TypeChecker_Common.comp_thunk)
-              }
-          | FStar_Pervasives_Native.None -> lc
-        else lc
-let (maybe_ghost_to_pure :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  = fun env1 -> fun c -> ghost_to_pure_aux env1 true c
-let (maybe_ghost_to_pure_lcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  = fun env1 -> fun lc -> ghost_to_pure_lcomp_aux env1 true lc
-let (ghost_to_pure :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-  = fun env1 -> fun c -> ghost_to_pure_aux env1 false c
-let (ghost_to_pure_lcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  = fun env1 -> fun lc -> ghost_to_pure_lcomp_aux env1 false lc
-let (ghost_to_pure2 :
-  FStar_TypeChecker_Env.env ->
-    (FStar_Syntax_Syntax.comp * FStar_Syntax_Syntax.comp) ->
-      (FStar_Syntax_Syntax.comp * FStar_Syntax_Syntax.comp))
-  =
-  fun env1 ->
-    fun uu___ ->
-      match uu___ with
-      | (c1, c2) ->
-          let uu___1 =
-            let uu___2 = maybe_ghost_to_pure env1 c1 in
-            let uu___3 = maybe_ghost_to_pure env1 c2 in (uu___2, uu___3) in
-          (match uu___1 with
-           | (c11, c21) ->
-               let c1_eff =
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater c11
-                     FStar_Syntax_Util.comp_effect_name in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___2
-                   (FStar_TypeChecker_Env.norm_eff_name env1) in
-               let c2_eff =
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater c21
-                     FStar_Syntax_Util.comp_effect_name in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___2
-                   (FStar_TypeChecker_Env.norm_eff_name env1) in
-               let uu___2 = FStar_Ident.lid_equals c1_eff c2_eff in
-               if uu___2
-               then (c11, c21)
-               else
-                 (let c1_erasable =
-                    FStar_TypeChecker_Env.is_erasable_effect env1 c1_eff in
-                  let c2_erasable =
-                    FStar_TypeChecker_Env.is_erasable_effect env1 c2_eff in
-                  let uu___4 =
-                    c1_erasable &&
-                      (FStar_Ident.lid_equals c2_eff
-                         FStar_Parser_Const.effect_GHOST_lid) in
-                  if uu___4
-                  then let uu___5 = ghost_to_pure env1 c21 in (c11, uu___5)
-                  else
-                    (let uu___6 =
-                       c2_erasable &&
-                         (FStar_Ident.lid_equals c1_eff
-                            FStar_Parser_Const.effect_GHOST_lid) in
-                     if uu___6
-                     then
-                       let uu___7 = ghost_to_pure env1 c11 in (uu___7, c21)
-                     else (c11, c21))))
-let (ghost_to_pure_lcomp2 :
-  FStar_TypeChecker_Env.env ->
-    (FStar_TypeChecker_Common.lcomp * FStar_TypeChecker_Common.lcomp) ->
-      (FStar_TypeChecker_Common.lcomp * FStar_TypeChecker_Common.lcomp))
-  =
-  fun env1 ->
-    fun uu___ ->
-      match uu___ with
-      | (lc1, lc2) ->
-          let uu___1 =
-            let uu___2 = maybe_ghost_to_pure_lcomp env1 lc1 in
-            let uu___3 = maybe_ghost_to_pure_lcomp env1 lc2 in
-            (uu___2, uu___3) in
-          (match uu___1 with
-           | (lc11, lc21) ->
-               let lc1_eff =
-                 FStar_TypeChecker_Env.norm_eff_name env1
-                   lc11.FStar_TypeChecker_Common.eff_name in
-               let lc2_eff =
-                 FStar_TypeChecker_Env.norm_eff_name env1
-                   lc21.FStar_TypeChecker_Common.eff_name in
-               let uu___2 = FStar_Ident.lid_equals lc1_eff lc2_eff in
-               if uu___2
-               then (lc11, lc21)
-               else
-                 (let lc1_erasable =
-                    FStar_TypeChecker_Env.is_erasable_effect env1 lc1_eff in
-                  let lc2_erasable =
-                    FStar_TypeChecker_Env.is_erasable_effect env1 lc2_eff in
-                  let uu___4 =
-                    lc1_erasable &&
-                      (FStar_Ident.lid_equals lc2_eff
-                         FStar_Parser_Const.effect_GHOST_lid) in
-                  if uu___4
-                  then
-                    let uu___5 = ghost_to_pure_lcomp env1 lc21 in
-                    (lc11, uu___5)
-                  else
-                    (let uu___6 =
-                       lc2_erasable &&
-                         (FStar_Ident.lid_equals lc1_eff
-                            FStar_Parser_Const.effect_GHOST_lid) in
-                     if uu___6
-                     then
-                       let uu___7 = ghost_to_pure_lcomp env1 lc11 in
-                       (uu___7, lc21)
-                     else (lc11, lc21))))
-let (term_to_string :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.string) =
-  fun env1 ->
-    fun t ->
-      let t1 =
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 normalize [FStar_TypeChecker_Env.AllowUnboundUniverses] env1
-                   t) ()
-        with
-        | uu___ ->
-            ((let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Compiler_Util.message_of_exn uu___ in
-                  FStar_Compiler_Util.format1
-                    "Normalization failed with error %s\n" uu___4 in
-                (FStar_Errors.Warning_NormalizationFailure, uu___3) in
-              FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___2);
-             t) in
-      FStar_Syntax_Print.term_to_string' env1.FStar_TypeChecker_Env.dsenv t1
-let (comp_to_string :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.comp -> Prims.string) =
-  fun env1 ->
-    fun c ->
-      let c1 =
-        try
-          (fun uu___ ->
-             match () with
-             | () ->
-                 let uu___1 =
-                   FStar_TypeChecker_Cfg.config
-                     [FStar_TypeChecker_Env.AllowUnboundUniverses] env1 in
-                 norm_comp uu___1 [] c) ()
-        with
-        | uu___ ->
-            ((let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Compiler_Util.message_of_exn uu___ in
-                  FStar_Compiler_Util.format1
-                    "Normalization failed with error %s\n" uu___4 in
-                (FStar_Errors.Warning_NormalizationFailure, uu___3) in
-              FStar_Errors.log_issue c.FStar_Syntax_Syntax.pos uu___2);
-             c) in
-      FStar_Syntax_Print.comp_to_string' env1.FStar_TypeChecker_Env.dsenv c1
-let (normalize_refinement :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun steps ->
-    fun env1 ->
-      fun t0 ->
-        let t =
-          normalize
-            (FStar_Compiler_List.op_At steps [FStar_TypeChecker_Env.Beta])
-            env1 t0 in
-        FStar_Syntax_Util.flatten_refinement t
-let (whnf_steps : FStar_TypeChecker_Env.step Prims.list) =
-  [FStar_TypeChecker_Env.Primops;
-  FStar_TypeChecker_Env.Weak;
-  FStar_TypeChecker_Env.HNF;
-  FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant;
-  FStar_TypeChecker_Env.Beta]
-let (unfold_whnf' :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun steps ->
-    fun env1 ->
-      fun t -> normalize (FStar_Compiler_List.op_At steps whnf_steps) env1 t
-let (unfold_whnf :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun env1 -> fun t -> unfold_whnf' [] env1 t
-let (reduce_or_remove_uvar_solutions :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun remove ->
-    fun env1 ->
-      fun t ->
-        normalize
-          (FStar_Compiler_List.op_At
-             (if remove then [FStar_TypeChecker_Env.CheckNoUvars] else [])
-             [FStar_TypeChecker_Env.Beta;
-             FStar_TypeChecker_Env.DoNotUnfoldPureLets;
-             FStar_TypeChecker_Env.CompressUvars;
-             FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-             FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Iota;
-             FStar_TypeChecker_Env.NoFullNorm]) env1 t
-let (reduce_uvar_solutions :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun env1 -> fun t -> reduce_or_remove_uvar_solutions false env1 t
-let (remove_uvar_solutions :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  = fun env1 -> fun t -> reduce_or_remove_uvar_solutions true env1 t
-let (eta_expand_with_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun e ->
-      fun t_e ->
-        let uu___ = FStar_Syntax_Util.arrow_formals_comp t_e in
-        match uu___ with
-        | (formals, c) ->
-            (match formals with
-             | [] -> e
-             | uu___1 ->
-                 let uu___2 = FStar_Syntax_Util.abs_formals e in
-                 (match uu___2 with
-                  | (actuals, uu___3, uu___4) ->
-                      if
-                        (FStar_Compiler_List.length actuals) =
-                          (FStar_Compiler_List.length formals)
-                      then e
-                      else
-                        (let uu___6 =
-                           FStar_Compiler_Effect.op_Bar_Greater formals
-                             FStar_Syntax_Util.args_of_binders in
-                         match uu___6 with
-                         | (binders, args) ->
-                             let uu___7 =
-                               FStar_Syntax_Syntax.mk_Tm_app e args
-                                 e.FStar_Syntax_Syntax.pos in
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_Syntax_Util.residual_comp_of_comp c in
-                               FStar_Pervasives_Native.Some uu___9 in
-                             FStar_Syntax_Util.abs binders uu___7 uu___8)))
-let (eta_expand :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun t ->
-      match t.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_name x ->
-          eta_expand_with_type env1 t x.FStar_Syntax_Syntax.sort
-      | uu___ ->
-          let uu___1 = FStar_Syntax_Util.head_and_args t in
-          (match uu___1 with
-           | (head, args) ->
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Subst.compress head in
-                 uu___3.FStar_Syntax_Syntax.n in
-               (match uu___2 with
-                | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Util.ctx_uvar_typ u in
-                        FStar_Syntax_Subst.subst' s uu___5 in
-                      FStar_Syntax_Util.arrow_formals uu___4 in
-                    (match uu___3 with
-                     | (formals, _tres) ->
-                         if
-                           (FStar_Compiler_List.length formals) =
-                             (FStar_Compiler_List.length args)
-                         then t
-                         else
-                           (let uu___5 =
-                              env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                {
-                                  FStar_TypeChecker_Env.solver =
-                                    (env1.FStar_TypeChecker_Env.solver);
-                                  FStar_TypeChecker_Env.range =
-                                    (env1.FStar_TypeChecker_Env.range);
-                                  FStar_TypeChecker_Env.curmodule =
-                                    (env1.FStar_TypeChecker_Env.curmodule);
-                                  FStar_TypeChecker_Env.gamma =
-                                    (env1.FStar_TypeChecker_Env.gamma);
-                                  FStar_TypeChecker_Env.gamma_sig =
-                                    (env1.FStar_TypeChecker_Env.gamma_sig);
-                                  FStar_TypeChecker_Env.gamma_cache =
-                                    (env1.FStar_TypeChecker_Env.gamma_cache);
-                                  FStar_TypeChecker_Env.modules =
-                                    (env1.FStar_TypeChecker_Env.modules);
-                                  FStar_TypeChecker_Env.expected_typ =
-                                    FStar_Pervasives_Native.None;
-                                  FStar_TypeChecker_Env.sigtab =
-                                    (env1.FStar_TypeChecker_Env.sigtab);
-                                  FStar_TypeChecker_Env.attrtab =
-                                    (env1.FStar_TypeChecker_Env.attrtab);
-                                  FStar_TypeChecker_Env.instantiate_imp =
-                                    (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                  FStar_TypeChecker_Env.effects =
-                                    (env1.FStar_TypeChecker_Env.effects);
-                                  FStar_TypeChecker_Env.generalize =
-                                    (env1.FStar_TypeChecker_Env.generalize);
-                                  FStar_TypeChecker_Env.letrecs =
-                                    (env1.FStar_TypeChecker_Env.letrecs);
-                                  FStar_TypeChecker_Env.top_level =
-                                    (env1.FStar_TypeChecker_Env.top_level);
-                                  FStar_TypeChecker_Env.check_uvars =
-                                    (env1.FStar_TypeChecker_Env.check_uvars);
-                                  FStar_TypeChecker_Env.use_eq_strict =
-                                    (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                  FStar_TypeChecker_Env.is_iface =
-                                    (env1.FStar_TypeChecker_Env.is_iface);
-                                  FStar_TypeChecker_Env.admit =
-                                    (env1.FStar_TypeChecker_Env.admit);
-                                  FStar_TypeChecker_Env.lax = true;
-                                  FStar_TypeChecker_Env.lax_universes =
-                                    (env1.FStar_TypeChecker_Env.lax_universes);
-                                  FStar_TypeChecker_Env.phase1 =
-                                    (env1.FStar_TypeChecker_Env.phase1);
-                                  FStar_TypeChecker_Env.failhard =
-                                    (env1.FStar_TypeChecker_Env.failhard);
-                                  FStar_TypeChecker_Env.nosynth =
-                                    (env1.FStar_TypeChecker_Env.nosynth);
-                                  FStar_TypeChecker_Env.uvar_subtyping =
-                                    (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                  FStar_TypeChecker_Env.tc_term =
-                                    (env1.FStar_TypeChecker_Env.tc_term);
-                                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                    =
-                                    (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.universe_of =
-                                    (env1.FStar_TypeChecker_Env.universe_of);
-                                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                    =
-                                    (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.teq_nosmt_force =
-                                    (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                                    (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                                    (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                  FStar_TypeChecker_Env.normalized_eff_names
-                                    =
-                                    (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                  FStar_TypeChecker_Env.fv_delta_depths =
-                                    (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                  FStar_TypeChecker_Env.proof_ns =
-                                    (env1.FStar_TypeChecker_Env.proof_ns);
-                                  FStar_TypeChecker_Env.synth_hook =
-                                    (env1.FStar_TypeChecker_Env.synth_hook);
-                                  FStar_TypeChecker_Env.try_solve_implicits_hook
-                                    =
-                                    (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                  FStar_TypeChecker_Env.splice =
-                                    (env1.FStar_TypeChecker_Env.splice);
-                                  FStar_TypeChecker_Env.mpreprocess =
-                                    (env1.FStar_TypeChecker_Env.mpreprocess);
-                                  FStar_TypeChecker_Env.postprocess =
-                                    (env1.FStar_TypeChecker_Env.postprocess);
-                                  FStar_TypeChecker_Env.identifier_info =
-                                    (env1.FStar_TypeChecker_Env.identifier_info);
-                                  FStar_TypeChecker_Env.tc_hooks =
-                                    (env1.FStar_TypeChecker_Env.tc_hooks);
-                                  FStar_TypeChecker_Env.dsenv =
-                                    (env1.FStar_TypeChecker_Env.dsenv);
-                                  FStar_TypeChecker_Env.nbe =
-                                    (env1.FStar_TypeChecker_Env.nbe);
-                                  FStar_TypeChecker_Env.strict_args_tab =
-                                    (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                  FStar_TypeChecker_Env.erasable_types_tab =
-                                    (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                                    (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                  FStar_TypeChecker_Env.unif_allow_ref_guards
-                                    =
-                                    (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                  FStar_TypeChecker_Env.erase_erasable_args =
-                                    (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                  FStar_TypeChecker_Env.core_check =
-                                    (env1.FStar_TypeChecker_Env.core_check)
-                                } t true in
-                            match uu___5 with
-                            | (uu___6, ty, uu___7) ->
-                                eta_expand_with_type env1 t ty))
-                | uu___3 ->
-                    let uu___4 =
-                      env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                        {
-                          FStar_TypeChecker_Env.solver =
-                            (env1.FStar_TypeChecker_Env.solver);
-                          FStar_TypeChecker_Env.range =
-                            (env1.FStar_TypeChecker_Env.range);
-                          FStar_TypeChecker_Env.curmodule =
-                            (env1.FStar_TypeChecker_Env.curmodule);
-                          FStar_TypeChecker_Env.gamma =
-                            (env1.FStar_TypeChecker_Env.gamma);
-                          FStar_TypeChecker_Env.gamma_sig =
-                            (env1.FStar_TypeChecker_Env.gamma_sig);
-                          FStar_TypeChecker_Env.gamma_cache =
-                            (env1.FStar_TypeChecker_Env.gamma_cache);
-                          FStar_TypeChecker_Env.modules =
-                            (env1.FStar_TypeChecker_Env.modules);
-                          FStar_TypeChecker_Env.expected_typ =
-                            FStar_Pervasives_Native.None;
-                          FStar_TypeChecker_Env.sigtab =
-                            (env1.FStar_TypeChecker_Env.sigtab);
-                          FStar_TypeChecker_Env.attrtab =
-                            (env1.FStar_TypeChecker_Env.attrtab);
-                          FStar_TypeChecker_Env.instantiate_imp =
-                            (env1.FStar_TypeChecker_Env.instantiate_imp);
-                          FStar_TypeChecker_Env.effects =
-                            (env1.FStar_TypeChecker_Env.effects);
-                          FStar_TypeChecker_Env.generalize =
-                            (env1.FStar_TypeChecker_Env.generalize);
-                          FStar_TypeChecker_Env.letrecs =
-                            (env1.FStar_TypeChecker_Env.letrecs);
-                          FStar_TypeChecker_Env.top_level =
-                            (env1.FStar_TypeChecker_Env.top_level);
-                          FStar_TypeChecker_Env.check_uvars =
-                            (env1.FStar_TypeChecker_Env.check_uvars);
-                          FStar_TypeChecker_Env.use_eq_strict =
-                            (env1.FStar_TypeChecker_Env.use_eq_strict);
-                          FStar_TypeChecker_Env.is_iface =
-                            (env1.FStar_TypeChecker_Env.is_iface);
-                          FStar_TypeChecker_Env.admit =
-                            (env1.FStar_TypeChecker_Env.admit);
-                          FStar_TypeChecker_Env.lax = true;
-                          FStar_TypeChecker_Env.lax_universes =
-                            (env1.FStar_TypeChecker_Env.lax_universes);
-                          FStar_TypeChecker_Env.phase1 =
-                            (env1.FStar_TypeChecker_Env.phase1);
-                          FStar_TypeChecker_Env.failhard =
-                            (env1.FStar_TypeChecker_Env.failhard);
-                          FStar_TypeChecker_Env.nosynth =
-                            (env1.FStar_TypeChecker_Env.nosynth);
-                          FStar_TypeChecker_Env.uvar_subtyping =
-                            (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                          FStar_TypeChecker_Env.tc_term =
-                            (env1.FStar_TypeChecker_Env.tc_term);
-                          FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                            (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                          FStar_TypeChecker_Env.universe_of =
-                            (env1.FStar_TypeChecker_Env.universe_of);
-                          FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                            =
-                            (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                          FStar_TypeChecker_Env.teq_nosmt_force =
-                            (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                          FStar_TypeChecker_Env.subtype_nosmt_force =
-                            (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                          FStar_TypeChecker_Env.qtbl_name_and_index =
-                            (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                          FStar_TypeChecker_Env.normalized_eff_names =
-                            (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                          FStar_TypeChecker_Env.fv_delta_depths =
-                            (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                          FStar_TypeChecker_Env.proof_ns =
-                            (env1.FStar_TypeChecker_Env.proof_ns);
-                          FStar_TypeChecker_Env.synth_hook =
-                            (env1.FStar_TypeChecker_Env.synth_hook);
-                          FStar_TypeChecker_Env.try_solve_implicits_hook =
-                            (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                          FStar_TypeChecker_Env.splice =
-                            (env1.FStar_TypeChecker_Env.splice);
-                          FStar_TypeChecker_Env.mpreprocess =
-                            (env1.FStar_TypeChecker_Env.mpreprocess);
-                          FStar_TypeChecker_Env.postprocess =
-                            (env1.FStar_TypeChecker_Env.postprocess);
-                          FStar_TypeChecker_Env.identifier_info =
-                            (env1.FStar_TypeChecker_Env.identifier_info);
-                          FStar_TypeChecker_Env.tc_hooks =
-                            (env1.FStar_TypeChecker_Env.tc_hooks);
-                          FStar_TypeChecker_Env.dsenv =
-                            (env1.FStar_TypeChecker_Env.dsenv);
-                          FStar_TypeChecker_Env.nbe =
-                            (env1.FStar_TypeChecker_Env.nbe);
-                          FStar_TypeChecker_Env.strict_args_tab =
-                            (env1.FStar_TypeChecker_Env.strict_args_tab);
-                          FStar_TypeChecker_Env.erasable_types_tab =
-                            (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                          FStar_TypeChecker_Env.enable_defer_to_tac =
-                            (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                          FStar_TypeChecker_Env.unif_allow_ref_guards =
-                            (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                          FStar_TypeChecker_Env.erase_erasable_args =
-                            (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                          FStar_TypeChecker_Env.core_check =
-                            (env1.FStar_TypeChecker_Env.core_check)
-                        } t true in
-                    (match uu___4 with
-                     | (uu___5, ty, uu___6) -> eta_expand_with_type env1 t ty)))
-let (elim_uvars_aux_tc :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.univ_names ->
-      FStar_Syntax_Syntax.binders ->
-        (FStar_Syntax_Syntax.typ, FStar_Syntax_Syntax.comp)
-          FStar_Pervasives.either ->
-          (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.binder
-            Prims.list *
-            (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax,
-            FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax)
-            FStar_Pervasives.either))
-  =
-  fun env1 ->
-    fun univ_names ->
-      fun binders ->
-        fun tc ->
-          let t =
-            match (binders, tc) with
-            | ([], FStar_Pervasives.Inl t1) -> t1
-            | ([], FStar_Pervasives.Inr c) ->
-                failwith "Impossible: empty bindes with a comp"
-            | (uu___, FStar_Pervasives.Inr c) ->
-                FStar_Syntax_Syntax.mk
-                  (FStar_Syntax_Syntax.Tm_arrow (binders, c))
-                  c.FStar_Syntax_Syntax.pos
-            | (uu___, FStar_Pervasives.Inl t1) ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Syntax.mk_Total t1 in
-                    (binders, uu___3) in
-                  FStar_Syntax_Syntax.Tm_arrow uu___2 in
-                FStar_Syntax_Syntax.mk uu___1 t1.FStar_Syntax_Syntax.pos in
-          let uu___ = FStar_Syntax_Subst.open_univ_vars univ_names t in
-          match uu___ with
-          | (univ_names1, t1) ->
-              let t2 = remove_uvar_solutions env1 t1 in
-              let t3 = FStar_Syntax_Subst.close_univ_vars univ_names1 t2 in
-              let t4 = FStar_Syntax_Subst.deep_compress false t3 in
-              let uu___1 =
-                match binders with
-                | [] -> ([], (FStar_Pervasives.Inl t4))
-                | uu___2 ->
-                    let uu___3 =
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Subst.compress t4 in
-                        uu___5.FStar_Syntax_Syntax.n in
-                      (uu___4, tc) in
-                    (match uu___3 with
-                     | (FStar_Syntax_Syntax.Tm_arrow (binders1, c),
-                        FStar_Pervasives.Inr uu___4) ->
-                         (binders1, (FStar_Pervasives.Inr c))
-                     | (FStar_Syntax_Syntax.Tm_arrow (binders1, c),
-                        FStar_Pervasives.Inl uu___4) ->
-                         (binders1,
-                           (FStar_Pervasives.Inl
-                              (FStar_Syntax_Util.comp_result c)))
-                     | (uu___4, FStar_Pervasives.Inl uu___5) ->
-                         ([], (FStar_Pervasives.Inl t4))
-                     | uu___4 -> failwith "Impossible") in
-              (match uu___1 with
-               | (binders1, tc1) -> (univ_names1, binders1, tc1))
-let (elim_uvars_aux_t :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.univ_names ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.typ ->
-          (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.binder
-            Prims.list * FStar_Syntax_Syntax.term'
-            FStar_Syntax_Syntax.syntax))
-  =
-  fun env1 ->
-    fun univ_names ->
-      fun binders ->
-        fun t ->
-          let uu___ =
-            elim_uvars_aux_tc env1 univ_names binders
-              (FStar_Pervasives.Inl t) in
-          match uu___ with
-          | (univ_names1, binders1, tc) ->
-              let uu___1 = FStar_Compiler_Util.left tc in
-              (univ_names1, binders1, uu___1)
-let (elim_uvars_aux_c :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.univ_names ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.comp ->
-          (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.binder
-            Prims.list * FStar_Syntax_Syntax.comp'
-            FStar_Syntax_Syntax.syntax))
-  =
-  fun env1 ->
-    fun univ_names ->
-      fun binders ->
-        fun c ->
-          let uu___ =
-            elim_uvars_aux_tc env1 univ_names binders
-              (FStar_Pervasives.Inr c) in
-          match uu___ with
-          | (univ_names1, binders1, tc) ->
-              let uu___1 = FStar_Compiler_Util.right tc in
-              (univ_names1, binders1, uu___1)
-let rec (elim_uvars :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun env1 ->
-    fun s ->
-      let sigattrs =
-        let uu___ =
-          FStar_Compiler_List.map (elim_uvars_aux_t env1 [] [])
-            s.FStar_Syntax_Syntax.sigattrs in
-        FStar_Compiler_Effect.op_Less_Bar
-          (FStar_Compiler_List.map
-             FStar_Pervasives_Native.__proj__Mktuple3__item___3) uu___ in
-      let s1 =
-        {
-          FStar_Syntax_Syntax.sigel = (s.FStar_Syntax_Syntax.sigel);
-          FStar_Syntax_Syntax.sigrng = (s.FStar_Syntax_Syntax.sigrng);
-          FStar_Syntax_Syntax.sigquals = (s.FStar_Syntax_Syntax.sigquals);
-          FStar_Syntax_Syntax.sigmeta = (s.FStar_Syntax_Syntax.sigmeta);
-          FStar_Syntax_Syntax.sigattrs = sigattrs;
-          FStar_Syntax_Syntax.sigopts = (s.FStar_Syntax_Syntax.sigopts)
-        } in
-      match s1.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_inductive_typ
-          (lid, univ_names, binders, num_uniform, typ, lids, lids') ->
-          let uu___ = elim_uvars_aux_t env1 univ_names binders typ in
-          (match uu___ with
-           | (univ_names1, binders1, typ1) ->
-               {
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_inductive_typ
-                      (lid, univ_names1, binders1, num_uniform, typ1, lids,
-                        lids'));
-                 FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-                 FStar_Syntax_Syntax.sigquals =
-                   (s1.FStar_Syntax_Syntax.sigquals);
-                 FStar_Syntax_Syntax.sigmeta =
-                   (s1.FStar_Syntax_Syntax.sigmeta);
-                 FStar_Syntax_Syntax.sigattrs =
-                   (s1.FStar_Syntax_Syntax.sigattrs);
-                 FStar_Syntax_Syntax.sigopts =
-                   (s1.FStar_Syntax_Syntax.sigopts)
-               })
-      | FStar_Syntax_Syntax.Sig_bundle (sigs, lids) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Compiler_List.map (elim_uvars env1) sigs in
-              (uu___2, lids) in
-            FStar_Syntax_Syntax.Sig_bundle uu___1 in
-          {
-            FStar_Syntax_Syntax.sigel = uu___;
-            FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-            FStar_Syntax_Syntax.sigquals = (s1.FStar_Syntax_Syntax.sigquals);
-            FStar_Syntax_Syntax.sigmeta = (s1.FStar_Syntax_Syntax.sigmeta);
-            FStar_Syntax_Syntax.sigattrs = (s1.FStar_Syntax_Syntax.sigattrs);
-            FStar_Syntax_Syntax.sigopts = (s1.FStar_Syntax_Syntax.sigopts)
-          }
-      | FStar_Syntax_Syntax.Sig_datacon
-          (lid, univ_names, typ, lident, i, lids) ->
-          let uu___ = elim_uvars_aux_t env1 univ_names [] typ in
-          (match uu___ with
-           | (univ_names1, uu___1, typ1) ->
-               {
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_datacon
-                      (lid, univ_names1, typ1, lident, i, lids));
-                 FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-                 FStar_Syntax_Syntax.sigquals =
-                   (s1.FStar_Syntax_Syntax.sigquals);
-                 FStar_Syntax_Syntax.sigmeta =
-                   (s1.FStar_Syntax_Syntax.sigmeta);
-                 FStar_Syntax_Syntax.sigattrs =
-                   (s1.FStar_Syntax_Syntax.sigattrs);
-                 FStar_Syntax_Syntax.sigopts =
-                   (s1.FStar_Syntax_Syntax.sigopts)
-               })
-      | FStar_Syntax_Syntax.Sig_declare_typ (lid, univ_names, typ) ->
-          let uu___ = elim_uvars_aux_t env1 univ_names [] typ in
-          (match uu___ with
-           | (univ_names1, uu___1, typ1) ->
-               {
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_declare_typ
-                      (lid, univ_names1, typ1));
-                 FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-                 FStar_Syntax_Syntax.sigquals =
-                   (s1.FStar_Syntax_Syntax.sigquals);
-                 FStar_Syntax_Syntax.sigmeta =
-                   (s1.FStar_Syntax_Syntax.sigmeta);
-                 FStar_Syntax_Syntax.sigattrs =
-                   (s1.FStar_Syntax_Syntax.sigattrs);
-                 FStar_Syntax_Syntax.sigopts =
-                   (s1.FStar_Syntax_Syntax.sigopts)
-               })
-      | FStar_Syntax_Syntax.Sig_let ((b, lbs), lids) ->
-          let lbs1 =
-            FStar_Compiler_Effect.op_Bar_Greater lbs
-              (FStar_Compiler_List.map
-                 (fun lb ->
-                    let uu___ =
-                      FStar_Syntax_Subst.univ_var_opening
-                        lb.FStar_Syntax_Syntax.lbunivs in
-                    match uu___ with
-                    | (opening, lbunivs) ->
-                        let elim t =
-                          let uu___1 =
-                            let uu___2 =
-                              let uu___3 = FStar_Syntax_Subst.subst opening t in
-                              remove_uvar_solutions env1 uu___3 in
-                            FStar_Syntax_Subst.close_univ_vars lbunivs uu___2 in
-                          FStar_Syntax_Subst.deep_compress false uu___1 in
-                        let lbtyp = elim lb.FStar_Syntax_Syntax.lbtyp in
-                        let lbdef = elim lb.FStar_Syntax_Syntax.lbdef in
-                        {
-                          FStar_Syntax_Syntax.lbname =
-                            (lb.FStar_Syntax_Syntax.lbname);
-                          FStar_Syntax_Syntax.lbunivs = lbunivs;
-                          FStar_Syntax_Syntax.lbtyp = lbtyp;
-                          FStar_Syntax_Syntax.lbeff =
-                            (lb.FStar_Syntax_Syntax.lbeff);
-                          FStar_Syntax_Syntax.lbdef = lbdef;
-                          FStar_Syntax_Syntax.lbattrs =
-                            (lb.FStar_Syntax_Syntax.lbattrs);
-                          FStar_Syntax_Syntax.lbpos =
-                            (lb.FStar_Syntax_Syntax.lbpos)
-                        })) in
-          {
-            FStar_Syntax_Syntax.sigel =
-              (FStar_Syntax_Syntax.Sig_let ((b, lbs1), lids));
-            FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-            FStar_Syntax_Syntax.sigquals = (s1.FStar_Syntax_Syntax.sigquals);
-            FStar_Syntax_Syntax.sigmeta = (s1.FStar_Syntax_Syntax.sigmeta);
-            FStar_Syntax_Syntax.sigattrs = (s1.FStar_Syntax_Syntax.sigattrs);
-            FStar_Syntax_Syntax.sigopts = (s1.FStar_Syntax_Syntax.sigopts)
-          }
-      | FStar_Syntax_Syntax.Sig_assume (l, us, t) ->
-          let uu___ = elim_uvars_aux_t env1 us [] t in
-          (match uu___ with
-           | (us1, uu___1, t1) ->
-               {
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_assume (l, us1, t1));
-                 FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-                 FStar_Syntax_Syntax.sigquals =
-                   (s1.FStar_Syntax_Syntax.sigquals);
-                 FStar_Syntax_Syntax.sigmeta =
-                   (s1.FStar_Syntax_Syntax.sigmeta);
-                 FStar_Syntax_Syntax.sigattrs =
-                   (s1.FStar_Syntax_Syntax.sigattrs);
-                 FStar_Syntax_Syntax.sigopts =
-                   (s1.FStar_Syntax_Syntax.sigopts)
-               })
-      | FStar_Syntax_Syntax.Sig_new_effect ed ->
-          let uu___ =
-            elim_uvars_aux_t env1 ed.FStar_Syntax_Syntax.univs
-              ed.FStar_Syntax_Syntax.binders FStar_Syntax_Syntax.t_unit in
-          (match uu___ with
-           | (univs, binders, uu___1) ->
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Subst.univ_var_opening univs in
-                 match uu___3 with
-                 | (univs_opening, univs1) ->
-                     let uu___4 = FStar_Syntax_Subst.univ_var_closing univs1 in
-                     (univs_opening, uu___4) in
-               (match uu___2 with
-                | (univs_opening, univs_closing) ->
-                    let uu___3 =
-                      let binders1 = FStar_Syntax_Subst.open_binders binders in
-                      let uu___4 =
-                        FStar_Syntax_Subst.opening_of_binders binders1 in
-                      let uu___5 =
-                        FStar_Syntax_Subst.closing_of_binders binders1 in
-                      (uu___4, uu___5) in
-                    (match uu___3 with
-                     | (b_opening, b_closing) ->
-                         let n = FStar_Compiler_List.length univs in
-                         let n_binders = FStar_Compiler_List.length binders in
-                         let elim_tscheme uu___4 =
-                           match uu___4 with
-                           | (us, t) ->
-                               let n_us = FStar_Compiler_List.length us in
-                               let uu___5 =
-                                 FStar_Syntax_Subst.open_univ_vars us t in
-                               (match uu___5 with
-                                | (us1, t1) ->
-                                    let uu___6 =
-                                      let uu___7 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          b_opening
-                                          (FStar_Syntax_Subst.shift_subst
-                                             n_us) in
-                                      let uu___8 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          b_closing
-                                          (FStar_Syntax_Subst.shift_subst
-                                             n_us) in
-                                      (uu___7, uu___8) in
-                                    (match uu___6 with
-                                     | (b_opening1, b_closing1) ->
-                                         let uu___7 =
-                                           let uu___8 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               univs_opening
-                                               (FStar_Syntax_Subst.shift_subst
-                                                  (n_us + n_binders)) in
-                                           let uu___9 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               univs_closing
-                                               (FStar_Syntax_Subst.shift_subst
-                                                  (n_us + n_binders)) in
-                                           (uu___8, uu___9) in
-                                         (match uu___7 with
-                                          | (univs_opening1, univs_closing1)
-                                              ->
-                                              let t2 =
-                                                let uu___8 =
-                                                  FStar_Syntax_Subst.subst
-                                                    b_opening1 t1 in
-                                                FStar_Syntax_Subst.subst
-                                                  univs_opening1 uu___8 in
-                                              let uu___8 =
-                                                elim_uvars_aux_t env1 [] []
-                                                  t2 in
-                                              (match uu___8 with
-                                               | (uu___9, uu___10, t3) ->
-                                                   let t4 =
-                                                     let uu___11 =
-                                                       let uu___12 =
-                                                         FStar_Syntax_Subst.close_univ_vars
-                                                           us1 t3 in
-                                                       FStar_Syntax_Subst.subst
-                                                         b_closing1 uu___12 in
-                                                     FStar_Syntax_Subst.subst
-                                                       univs_closing1 uu___11 in
-                                                   (us1, t4))))) in
-                         let elim_term t =
-                           let uu___4 = elim_uvars_aux_t env1 univs binders t in
-                           match uu___4 with | (uu___5, uu___6, t1) -> t1 in
-                         let elim_action a =
-                           let action_typ_templ =
-                             let body =
-                               FStar_Syntax_Syntax.mk
-                                 (FStar_Syntax_Syntax.Tm_ascribed
-                                    ((a.FStar_Syntax_Syntax.action_defn),
-                                      ((FStar_Pervasives.Inl
-                                          (a.FStar_Syntax_Syntax.action_typ)),
-                                        FStar_Pervasives_Native.None, false),
-                                      FStar_Pervasives_Native.None))
-                                 (a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-                             match a.FStar_Syntax_Syntax.action_params with
-                             | [] -> body
-                             | uu___4 ->
-                                 FStar_Syntax_Syntax.mk
-                                   (FStar_Syntax_Syntax.Tm_abs
-                                      ((a.FStar_Syntax_Syntax.action_params),
-                                        body, FStar_Pervasives_Native.None))
-                                   (a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-                           let destruct_action_body body =
-                             let uu___4 =
-                               let uu___5 = FStar_Syntax_Subst.compress body in
-                               uu___5.FStar_Syntax_Syntax.n in
-                             match uu___4 with
-                             | FStar_Syntax_Syntax.Tm_ascribed
-                                 (defn,
-                                  (FStar_Pervasives.Inl typ,
-                                   FStar_Pervasives_Native.None, uu___5),
-                                  FStar_Pervasives_Native.None)
-                                 -> (defn, typ)
-                             | uu___5 -> failwith "Impossible" in
-                           let destruct_action_typ_templ t =
-                             let uu___4 =
-                               let uu___5 = FStar_Syntax_Subst.compress t in
-                               uu___5.FStar_Syntax_Syntax.n in
-                             match uu___4 with
-                             | FStar_Syntax_Syntax.Tm_abs
-                                 (pars, body, uu___5) ->
-                                 let uu___6 = destruct_action_body body in
-                                 (match uu___6 with
-                                  | (defn, typ) -> (pars, defn, typ))
-                             | uu___5 ->
-                                 let uu___6 = destruct_action_body t in
-                                 (match uu___6 with
-                                  | (defn, typ) -> ([], defn, typ)) in
-                           let uu___4 =
-                             elim_tscheme
-                               ((a.FStar_Syntax_Syntax.action_univs),
-                                 action_typ_templ) in
-                           match uu___4 with
-                           | (action_univs, t) ->
-                               let uu___5 = destruct_action_typ_templ t in
-                               (match uu___5 with
-                                | (action_params, action_defn, action_typ) ->
-                                    let a' =
-                                      {
-                                        FStar_Syntax_Syntax.action_name =
-                                          (a.FStar_Syntax_Syntax.action_name);
-                                        FStar_Syntax_Syntax.action_unqualified_name
-                                          =
-                                          (a.FStar_Syntax_Syntax.action_unqualified_name);
-                                        FStar_Syntax_Syntax.action_univs =
-                                          action_univs;
-                                        FStar_Syntax_Syntax.action_params =
-                                          action_params;
-                                        FStar_Syntax_Syntax.action_defn =
-                                          action_defn;
-                                        FStar_Syntax_Syntax.action_typ =
-                                          action_typ
-                                      } in
-                                    a') in
-                         let ed1 =
-                           let uu___4 =
-                             FStar_Syntax_Util.apply_eff_sig elim_tscheme
-                               ed.FStar_Syntax_Syntax.signature in
-                           let uu___5 =
-                             FStar_Syntax_Util.apply_eff_combinators
-                               elim_tscheme
-                               ed.FStar_Syntax_Syntax.combinators in
-                           let uu___6 =
-                             FStar_Compiler_List.map elim_action
-                               ed.FStar_Syntax_Syntax.actions in
-                           {
-                             FStar_Syntax_Syntax.mname =
-                               (ed.FStar_Syntax_Syntax.mname);
-                             FStar_Syntax_Syntax.cattributes =
-                               (ed.FStar_Syntax_Syntax.cattributes);
-                             FStar_Syntax_Syntax.univs = univs;
-                             FStar_Syntax_Syntax.binders = binders;
-                             FStar_Syntax_Syntax.signature = uu___4;
-                             FStar_Syntax_Syntax.combinators = uu___5;
-                             FStar_Syntax_Syntax.actions = uu___6;
-                             FStar_Syntax_Syntax.eff_attrs =
-                               (ed.FStar_Syntax_Syntax.eff_attrs)
-                           } in
-                         {
-                           FStar_Syntax_Syntax.sigel =
-                             (FStar_Syntax_Syntax.Sig_new_effect ed1);
-                           FStar_Syntax_Syntax.sigrng =
-                             (s1.FStar_Syntax_Syntax.sigrng);
-                           FStar_Syntax_Syntax.sigquals =
-                             (s1.FStar_Syntax_Syntax.sigquals);
-                           FStar_Syntax_Syntax.sigmeta =
-                             (s1.FStar_Syntax_Syntax.sigmeta);
-                           FStar_Syntax_Syntax.sigattrs =
-                             (s1.FStar_Syntax_Syntax.sigattrs);
-                           FStar_Syntax_Syntax.sigopts =
-                             (s1.FStar_Syntax_Syntax.sigopts)
-                         })))
-      | FStar_Syntax_Syntax.Sig_sub_effect sub_eff ->
-          let elim_tscheme_opt uu___ =
-            match uu___ with
-            | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-            | FStar_Pervasives_Native.Some (us, t) ->
-                let uu___1 = elim_uvars_aux_t env1 us [] t in
-                (match uu___1 with
-                 | (us1, uu___2, t1) ->
-                     FStar_Pervasives_Native.Some (us1, t1)) in
-          let sub_eff1 =
-            let uu___ = elim_tscheme_opt sub_eff.FStar_Syntax_Syntax.lift_wp in
-            let uu___1 = elim_tscheme_opt sub_eff.FStar_Syntax_Syntax.lift in
-            {
-              FStar_Syntax_Syntax.source =
-                (sub_eff.FStar_Syntax_Syntax.source);
-              FStar_Syntax_Syntax.target =
-                (sub_eff.FStar_Syntax_Syntax.target);
-              FStar_Syntax_Syntax.lift_wp = uu___;
-              FStar_Syntax_Syntax.lift = uu___1;
-              FStar_Syntax_Syntax.kind = (sub_eff.FStar_Syntax_Syntax.kind)
-            } in
-          {
-            FStar_Syntax_Syntax.sigel =
-              (FStar_Syntax_Syntax.Sig_sub_effect sub_eff1);
-            FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-            FStar_Syntax_Syntax.sigquals = (s1.FStar_Syntax_Syntax.sigquals);
-            FStar_Syntax_Syntax.sigmeta = (s1.FStar_Syntax_Syntax.sigmeta);
-            FStar_Syntax_Syntax.sigattrs = (s1.FStar_Syntax_Syntax.sigattrs);
-            FStar_Syntax_Syntax.sigopts = (s1.FStar_Syntax_Syntax.sigopts)
-          }
-      | FStar_Syntax_Syntax.Sig_effect_abbrev
-          (lid, univ_names, binders, comp, flags) ->
-          let uu___ = elim_uvars_aux_c env1 univ_names binders comp in
-          (match uu___ with
-           | (univ_names1, binders1, comp1) ->
-               {
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_effect_abbrev
-                      (lid, univ_names1, binders1, comp1, flags));
-                 FStar_Syntax_Syntax.sigrng = (s1.FStar_Syntax_Syntax.sigrng);
-                 FStar_Syntax_Syntax.sigquals =
-                   (s1.FStar_Syntax_Syntax.sigquals);
-                 FStar_Syntax_Syntax.sigmeta =
-                   (s1.FStar_Syntax_Syntax.sigmeta);
-                 FStar_Syntax_Syntax.sigattrs =
-                   (s1.FStar_Syntax_Syntax.sigattrs);
-                 FStar_Syntax_Syntax.sigopts =
-                   (s1.FStar_Syntax_Syntax.sigopts)
-               })
-      | FStar_Syntax_Syntax.Sig_pragma uu___ -> s1
-      | FStar_Syntax_Syntax.Sig_fail uu___ -> s1
-      | FStar_Syntax_Syntax.Sig_splice uu___ -> s1
-      | FStar_Syntax_Syntax.Sig_polymonadic_bind
-          (m, n, p, (us_t, t), (us_ty, ty), k) ->
-          let uu___ = elim_uvars_aux_t env1 us_t [] t in
-          (match uu___ with
-           | (us_t1, uu___1, t1) ->
-               let uu___2 = elim_uvars_aux_t env1 us_ty [] ty in
-               (match uu___2 with
-                | (us_ty1, uu___3, ty1) ->
-                    {
-                      FStar_Syntax_Syntax.sigel =
-                        (FStar_Syntax_Syntax.Sig_polymonadic_bind
-                           (m, n, p, (us_t1, t1), (us_ty1, ty1), k));
-                      FStar_Syntax_Syntax.sigrng =
-                        (s1.FStar_Syntax_Syntax.sigrng);
-                      FStar_Syntax_Syntax.sigquals =
-                        (s1.FStar_Syntax_Syntax.sigquals);
-                      FStar_Syntax_Syntax.sigmeta =
-                        (s1.FStar_Syntax_Syntax.sigmeta);
-                      FStar_Syntax_Syntax.sigattrs =
-                        (s1.FStar_Syntax_Syntax.sigattrs);
-                      FStar_Syntax_Syntax.sigopts =
-                        (s1.FStar_Syntax_Syntax.sigopts)
-                    }))
-      | FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-          (m, n, (us_t, t), (us_ty, ty), k) ->
-          let uu___ = elim_uvars_aux_t env1 us_t [] t in
-          (match uu___ with
-           | (us_t1, uu___1, t1) ->
-               let uu___2 = elim_uvars_aux_t env1 us_ty [] ty in
-               (match uu___2 with
-                | (us_ty1, uu___3, ty1) ->
-                    {
-                      FStar_Syntax_Syntax.sigel =
-                        (FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-                           (m, n, (us_t1, t1), (us_ty1, ty1), k));
-                      FStar_Syntax_Syntax.sigrng =
-                        (s1.FStar_Syntax_Syntax.sigrng);
-                      FStar_Syntax_Syntax.sigquals =
-                        (s1.FStar_Syntax_Syntax.sigquals);
-                      FStar_Syntax_Syntax.sigmeta =
-                        (s1.FStar_Syntax_Syntax.sigmeta);
-                      FStar_Syntax_Syntax.sigattrs =
-                        (s1.FStar_Syntax_Syntax.sigattrs);
-                      FStar_Syntax_Syntax.sigopts =
-                        (s1.FStar_Syntax_Syntax.sigopts)
-                    }))
-let (erase_universes :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env1 ->
-    fun t ->
-      normalize
-        [FStar_TypeChecker_Env.EraseUniverses;
-        FStar_TypeChecker_Env.AllowUnboundUniverses] env1 t
-let (unfold_head_once :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun t ->
-      let aux f us args =
-        let uu___ =
-          FStar_TypeChecker_Env.lookup_nonrec_definition
-            [FStar_TypeChecker_Env.Unfold FStar_Syntax_Syntax.delta_constant]
-            env1 (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some head_def_ts ->
-            let uu___1 =
-              FStar_TypeChecker_Env.inst_tscheme_with head_def_ts us in
-            (match uu___1 with
-             | (uu___2, head_def) ->
-                 let t' =
-                   FStar_Syntax_Syntax.mk_Tm_app head_def args
-                     t.FStar_Syntax_Syntax.pos in
-                 let t'1 =
-                   normalize
-                     [FStar_TypeChecker_Env.Beta; FStar_TypeChecker_Env.Iota]
-                     env1 t' in
-                 FStar_Pervasives_Native.Some t'1) in
-      let uu___ = FStar_Syntax_Util.head_and_args t in
-      match uu___ with
-      | (head, args) ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Subst.compress head in
-            uu___2.FStar_Syntax_Syntax.n in
-          (match uu___1 with
-           | FStar_Syntax_Syntax.Tm_fvar fv -> aux fv [] args
-           | FStar_Syntax_Syntax.Tm_uinst
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-                  FStar_Syntax_Syntax.pos = uu___2;
-                  FStar_Syntax_Syntax.vars = uu___3;
-                  FStar_Syntax_Syntax.hash_code = uu___4;_},
-                us)
-               -> aux fv us args
-           | uu___2 -> FStar_Pervasives_Native.None)
-let (get_n_binders :
-  FStar_TypeChecker_Env.env ->
-    Prims.int ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.binder Prims.list * FStar_Syntax_Syntax.comp))
-  =
-  fun env1 ->
-    fun n ->
-      fun t ->
-        let rec aux retry n1 t1 =
-          let uu___ = FStar_Syntax_Util.arrow_formals_comp t1 in
-          match uu___ with
-          | (bs, c) ->
-              let len = FStar_Compiler_List.length bs in
-              (match (bs, c) with
-               | ([], uu___1) when retry ->
-                   let uu___2 = unfold_whnf env1 t1 in aux false n1 uu___2
-               | ([], uu___1) when Prims.op_Negation retry -> (bs, c)
-               | (bs1, c1) when len = n1 -> (bs1, c1)
-               | (bs1, c1) when len > n1 ->
-                   let uu___1 = FStar_Compiler_List.splitAt n1 bs1 in
-                   (match uu___1 with
-                    | (bs_l, bs_r) ->
-                        let uu___2 =
-                          let uu___3 = FStar_Syntax_Util.arrow bs_r c1 in
-                          FStar_Syntax_Syntax.mk_Total uu___3 in
-                        (bs_l, uu___2))
-               | (bs1, c1) when
-                   ((len < n1) && (FStar_Syntax_Util.is_total_comp c1)) &&
-                     (let uu___1 = FStar_Syntax_Util.has_decreases c1 in
-                      Prims.op_Negation uu___1)
-                   ->
-                   let uu___1 =
-                     aux true (n1 - len) (FStar_Syntax_Util.comp_result c1) in
-                   (match uu___1 with
-                    | (bs', c') -> ((FStar_Compiler_List.op_At bs1 bs'), c'))
-               | (bs1, c1) -> (bs1, c1)) in
-        aux true n t
-let (maybe_unfold_head_fv :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun head ->
-      let fv_us_opt =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress head in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_uinst
-            ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-               FStar_Syntax_Syntax.pos = uu___1;
-               FStar_Syntax_Syntax.vars = uu___2;
-               FStar_Syntax_Syntax.hash_code = uu___3;_},
-             us)
-            -> FStar_Pervasives_Native.Some (fv, us)
-        | FStar_Syntax_Syntax.Tm_fvar fv ->
-            FStar_Pervasives_Native.Some (fv, [])
-        | uu___1 ->
-            failwith
-              "Impossible: maybe_unfold_head_fv is called with a non fvar/uinst" in
-      match fv_us_opt with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some (fv, us) ->
-          let uu___ =
-            FStar_TypeChecker_Env.lookup_nonrec_definition
-              [FStar_TypeChecker_Env.Unfold
-                 FStar_Syntax_Syntax.delta_constant] env1
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___ with
-           | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-           | FStar_Pervasives_Native.Some (us_formals, defn) ->
-               let subst = FStar_TypeChecker_Env.mk_univ_subst us_formals us in
-               let uu___1 = FStar_Syntax_Subst.subst subst defn in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 (fun uu___2 -> FStar_Pervasives_Native.Some uu___2))
-let rec (maybe_unfold_aux :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_match (t0, ret_opt, brs, rc_opt) ->
-          let uu___1 = maybe_unfold_aux env1 t0 in
-          FStar_Compiler_Util.map_option
-            (fun t01 ->
-               FStar_Syntax_Syntax.mk
-                 (FStar_Syntax_Syntax.Tm_match (t01, ret_opt, brs, rc_opt))
-                 t.FStar_Syntax_Syntax.pos) uu___1
-      | FStar_Syntax_Syntax.Tm_fvar uu___1 -> maybe_unfold_head_fv env1 t
-      | FStar_Syntax_Syntax.Tm_uinst uu___1 -> maybe_unfold_head_fv env1 t
-      | uu___1 ->
-          let uu___2 = FStar_Syntax_Util.leftmost_head_and_args t in
-          (match uu___2 with
-           | (head, args) ->
-               let uu___3 = maybe_unfold_aux env1 head in
-               (match uu___3 with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Pervasives_Native.None
-                | FStar_Pervasives_Native.Some head1 ->
-                    let uu___4 =
-                      FStar_Syntax_Syntax.mk_Tm_app head1 args
-                        t.FStar_Syntax_Syntax.pos in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___4
-                      (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)))
-let (maybe_unfold_head :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun t ->
-      let uu___ = maybe_unfold_aux env1 t in
-      FStar_Compiler_Util.map_option
-        (normalize
-           [FStar_TypeChecker_Env.Beta;
-           FStar_TypeChecker_Env.Iota;
-           FStar_TypeChecker_Env.Weak;
-           FStar_TypeChecker_Env.HNF] env1) uu___
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_PatternUtils.ml b/src/ocaml-output/FStar_TypeChecker_PatternUtils.ml
deleted file mode 100644
index 15d7054caa4..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_PatternUtils.ml
+++ /dev/null
@@ -1,478 +0,0 @@
-open Prims
-type lcomp_with_binder =
-  (FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option *
-    FStar_TypeChecker_Common.lcomp)
-let rec (elaborate_pat :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.pat -> FStar_Syntax_Syntax.pat)
-  =
-  fun env ->
-    fun p ->
-      let maybe_dot inaccessible a r =
-        if inaccessible
-        then
-          FStar_Syntax_Syntax.withinfo
-            (FStar_Syntax_Syntax.Pat_dot_term FStar_Pervasives_Native.None) r
-        else FStar_Syntax_Syntax.withinfo (FStar_Syntax_Syntax.Pat_var a) r in
-      match p.FStar_Syntax_Syntax.v with
-      | FStar_Syntax_Syntax.Pat_cons
-          ({ FStar_Syntax_Syntax.fv_name = uu___;
-             FStar_Syntax_Syntax.fv_delta = uu___1;
-             FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-               (FStar_Syntax_Syntax.Unresolved_constructor uu___2);_},
-           uu___3, uu___4)
-          -> p
-      | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-          let pats1 =
-            FStar_Compiler_List.map
-              (fun uu___ ->
-                 match uu___ with
-                 | (p1, imp) ->
-                     let uu___1 = elaborate_pat env p1 in (uu___1, imp)) pats in
-          let uu___ =
-            FStar_TypeChecker_Env.lookup_datacon env
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___ with
-           | (uu___1, t) ->
-               let uu___2 = FStar_Syntax_Util.arrow_formals t in
-               (match uu___2 with
-                | (f, uu___3) ->
-                    let rec aux formals pats2 =
-                      match (formals, pats2) with
-                      | ([], []) -> []
-                      | ([], uu___4::uu___5) ->
-                          let uu___6 =
-                            FStar_Ident.range_of_lid
-                              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                          FStar_Errors.raise_error
-                            (FStar_Errors.Fatal_TooManyPatternArguments,
-                              "Too many pattern arguments") uu___6
-                      | (uu___4::uu___5, []) ->
-                          FStar_Compiler_Effect.op_Bar_Greater formals
-                            (FStar_Compiler_List.map
-                               (fun fml ->
-                                  let uu___6 =
-                                    ((fml.FStar_Syntax_Syntax.binder_bv),
-                                      (fml.FStar_Syntax_Syntax.binder_qual)) in
-                                  match uu___6 with
-                                  | (t1, imp) ->
-                                      (match imp with
-                                       | FStar_Pervasives_Native.Some
-                                           (FStar_Syntax_Syntax.Implicit
-                                           inaccessible) ->
-                                           let a =
-                                             let uu___7 =
-                                               let uu___8 =
-                                                 FStar_Syntax_Syntax.range_of_bv
-                                                   t1 in
-                                               FStar_Pervasives_Native.Some
-                                                 uu___8 in
-                                             FStar_Syntax_Syntax.new_bv
-                                               uu___7 FStar_Syntax_Syntax.tun in
-                                           let r =
-                                             FStar_Ident.range_of_lid
-                                               (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                           let uu___7 =
-                                             maybe_dot inaccessible a r in
-                                           (uu___7, true)
-                                       | uu___7 ->
-                                           let uu___8 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 FStar_Syntax_Print.pat_to_string
-                                                   p in
-                                               FStar_Compiler_Util.format1
-                                                 "Insufficient pattern arguments (%s)"
-                                                 uu___10 in
-                                             (FStar_Errors.Fatal_InsufficientPatternArguments,
-                                               uu___9) in
-                                           let uu___9 =
-                                             FStar_Ident.range_of_lid
-                                               (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                           FStar_Errors.raise_error uu___8
-                                             uu___9)))
-                      | (f1::formals', (p1, p_imp)::pats') ->
-                          (match ((f1.FStar_Syntax_Syntax.binder_bv),
-                                   (f1.FStar_Syntax_Syntax.binder_qual))
-                           with
-                           | (uu___4, FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Implicit inaccessible))
-                               when inaccessible && p_imp ->
-                               (match p1.FStar_Syntax_Syntax.v with
-                                | FStar_Syntax_Syntax.Pat_dot_term uu___5 ->
-                                    let uu___6 = aux formals' pats' in
-                                    (p1, true) :: uu___6
-                                | FStar_Syntax_Syntax.Pat_wild uu___5 ->
-                                    let a =
-                                      FStar_Syntax_Syntax.new_bv
-                                        (FStar_Pervasives_Native.Some
-                                           (p1.FStar_Syntax_Syntax.p))
-                                        FStar_Syntax_Syntax.tun in
-                                    let p2 =
-                                      let uu___6 =
-                                        FStar_Ident.range_of_lid
-                                          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                      maybe_dot inaccessible a uu___6 in
-                                    let uu___6 = aux formals' pats' in
-                                    (p2, true) :: uu___6
-                                | uu___5 ->
-                                    let uu___6 =
-                                      let uu___7 =
-                                        let uu___8 =
-                                          FStar_Syntax_Print.pat_to_string p1 in
-                                        FStar_Compiler_Util.format1
-                                          "This pattern (%s) binds an inaccesible argument; use a wildcard ('_') pattern"
-                                          uu___8 in
-                                      (FStar_Errors.Fatal_InsufficientPatternArguments,
-                                        uu___7) in
-                                    FStar_Errors.raise_error uu___6
-                                      p1.FStar_Syntax_Syntax.p)
-                           | (uu___4, FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Implicit uu___5)) when
-                               p_imp ->
-                               let uu___6 = aux formals' pats' in (p1, true)
-                                 :: uu___6
-                           | (uu___4, FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Implicit inaccessible)) ->
-                               let a =
-                                 FStar_Syntax_Syntax.new_bv
-                                   (FStar_Pervasives_Native.Some
-                                      (p1.FStar_Syntax_Syntax.p))
-                                   FStar_Syntax_Syntax.tun in
-                               let p2 =
-                                 let uu___5 =
-                                   FStar_Ident.range_of_lid
-                                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                 maybe_dot inaccessible a uu___5 in
-                               let uu___5 = aux formals' pats2 in (p2, true)
-                                 :: uu___5
-                           | (uu___4, imp) ->
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Syntax_Syntax.is_bqual_implicit imp in
-                                 (p1, uu___6) in
-                               let uu___6 = aux formals' pats' in uu___5 ::
-                                 uu___6) in
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = aux f pats1 in (fv, us_opt, uu___6) in
-                      FStar_Syntax_Syntax.Pat_cons uu___5 in
-                    {
-                      FStar_Syntax_Syntax.v = uu___4;
-                      FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                    }))
-      | uu___ -> p
-exception Raw_pat_cannot_be_translated 
-let (uu___is_Raw_pat_cannot_be_translated : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Raw_pat_cannot_be_translated -> true
-    | uu___ -> false
-let (raw_pat_as_exp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.pat ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.bv Prims.list)
-        FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun p ->
-      let rec aux bs p1 =
-        match p1.FStar_Syntax_Syntax.v with
-        | FStar_Syntax_Syntax.Pat_constant c ->
-            let e =
-              match c with
-              | FStar_Const.Const_int (repr, FStar_Pervasives_Native.Some sw)
-                  ->
-                  FStar_ToSyntax_ToSyntax.desugar_machine_integer
-                    env.FStar_TypeChecker_Env.dsenv repr sw
-                    p1.FStar_Syntax_Syntax.p
-              | uu___ ->
-                  FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_constant c)
-                    p1.FStar_Syntax_Syntax.p in
-            (e, bs)
-        | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-            (match eopt with
-             | FStar_Pervasives_Native.None ->
-                 FStar_Compiler_Effect.raise Raw_pat_cannot_be_translated
-             | FStar_Pervasives_Native.Some e ->
-                 let uu___ = FStar_Syntax_Subst.compress e in (uu___, bs))
-        | FStar_Syntax_Syntax.Pat_wild x ->
-            let uu___ =
-              FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_name x)
-                p1.FStar_Syntax_Syntax.p in
-            (uu___, (x :: bs))
-        | FStar_Syntax_Syntax.Pat_var x ->
-            let uu___ =
-              FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_name x)
-                p1.FStar_Syntax_Syntax.p in
-            (uu___, (x :: bs))
-        | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-            let uu___ =
-              FStar_Compiler_List.fold_right
-                (fun uu___1 ->
-                   fun uu___2 ->
-                     match (uu___1, uu___2) with
-                     | ((p2, i), (args, bs1)) ->
-                         let uu___3 = aux bs1 p2 in
-                         (match uu___3 with
-                          | (ep, bs2) ->
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    FStar_Syntax_Syntax.as_aqual_implicit i in
-                                  (ep, uu___6) in
-                                uu___5 :: args in
-                              (uu___4, bs2))) pats ([], bs) in
-            (match uu___ with
-             | (args, bs1) ->
-                 let hd = FStar_Syntax_Syntax.fv_to_tm fv in
-                 let hd1 =
-                   match us_opt with
-                   | FStar_Pervasives_Native.None -> hd
-                   | FStar_Pervasives_Native.Some us ->
-                       FStar_Syntax_Syntax.mk_Tm_uinst hd us in
-                 let e =
-                   FStar_Syntax_Syntax.mk_Tm_app hd1 args
-                     p1.FStar_Syntax_Syntax.p in
-                 (e, bs1)) in
-      try
-        (fun uu___ ->
-           match () with
-           | () ->
-               let uu___1 = aux [] p in FStar_Pervasives_Native.Some uu___1)
-          ()
-      with | Raw_pat_cannot_be_translated -> FStar_Pervasives_Native.None
-let (pat_as_exp :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.pat ->
-          (FStar_Syntax_Syntax.bv Prims.list * FStar_Syntax_Syntax.term *
-            FStar_TypeChecker_Common.guard_t * FStar_Syntax_Syntax.pat))
-  =
-  fun introduce_bv_uvars ->
-    fun inst_pat_cons_univs ->
-      fun env ->
-        fun p ->
-          let intro_bv env1 x =
-            if Prims.op_Negation introduce_bv_uvars
-            then
-              ({
-                 FStar_Syntax_Syntax.ppname = (x.FStar_Syntax_Syntax.ppname);
-                 FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                 FStar_Syntax_Syntax.sort = FStar_Syntax_Syntax.tun
-               }, FStar_TypeChecker_Env.trivial_guard, env1)
-            else
-              (let uu___1 = FStar_Syntax_Util.type_u () in
-               match uu___1 with
-               | (t, uu___2) ->
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Syntax.range_of_bv x in
-                     FStar_TypeChecker_Env.new_implicit_var_aux
-                       "pattern bv type" uu___4 env1 t
-                       (FStar_Syntax_Syntax.Allow_untyped "pattern bv type")
-                       FStar_Pervasives_Native.None in
-                   (match uu___3 with
-                    | (t_x, uu___4, guard) ->
-                        let x1 =
-                          {
-                            FStar_Syntax_Syntax.ppname =
-                              (x.FStar_Syntax_Syntax.ppname);
-                            FStar_Syntax_Syntax.index =
-                              (x.FStar_Syntax_Syntax.index);
-                            FStar_Syntax_Syntax.sort = t_x
-                          } in
-                        let uu___5 = FStar_TypeChecker_Env.push_bv env1 x1 in
-                        (x1, guard, uu___5))) in
-          let rec pat_as_arg_with_env env1 p1 =
-            match p1.FStar_Syntax_Syntax.v with
-            | FStar_Syntax_Syntax.Pat_constant c ->
-                let e =
-                  match c with
-                  | FStar_Const.Const_int
-                      (repr, FStar_Pervasives_Native.Some sw) ->
-                      FStar_ToSyntax_ToSyntax.desugar_machine_integer
-                        env1.FStar_TypeChecker_Env.dsenv repr sw
-                        p1.FStar_Syntax_Syntax.p
-                  | uu___ ->
-                      FStar_Syntax_Syntax.mk
-                        (FStar_Syntax_Syntax.Tm_constant c)
-                        p1.FStar_Syntax_Syntax.p in
-                ([], [], [], env1, e, FStar_TypeChecker_Common.trivial_guard,
-                  p1)
-            | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-                (match eopt with
-                 | FStar_Pervasives_Native.None ->
-                     ((let uu___1 =
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (FStar_TypeChecker_Env.debug env1)
-                           (FStar_Options.Other "Patterns") in
-                       if uu___1
-                       then
-                         (if
-                            Prims.op_Negation
-                              env1.FStar_TypeChecker_Env.phase1
-                          then
-                            let uu___2 = FStar_Syntax_Print.pat_to_string p1 in
-                            FStar_Compiler_Util.print1
-                              "Found a non-instantiated dot pattern in phase2 (%s)\n"
-                              uu___2
-                          else ())
-                       else ());
-                      (let uu___1 = FStar_Syntax_Util.type_u () in
-                       match uu___1 with
-                       | (k, uu___2) ->
-                           let uu___3 =
-                             FStar_TypeChecker_Env.new_implicit_var_aux
-                               "pat_dot_term type" p1.FStar_Syntax_Syntax.p
-                               env1 k
-                               (FStar_Syntax_Syntax.Allow_ghost
-                                  "pat dot term type")
-                               FStar_Pervasives_Native.None in
-                           (match uu___3 with
-                            | (t, uu___4, g) ->
-                                let uu___5 =
-                                  FStar_TypeChecker_Env.new_implicit_var_aux
-                                    "pat_dot_term" p1.FStar_Syntax_Syntax.p
-                                    env1 t
-                                    (FStar_Syntax_Syntax.Allow_ghost
-                                       "pat dot term")
-                                    FStar_Pervasives_Native.None in
-                                (match uu___5 with
-                                 | (e, uu___6, g') ->
-                                     let p2 =
-                                       {
-                                         FStar_Syntax_Syntax.v =
-                                           (FStar_Syntax_Syntax.Pat_dot_term
-                                              (FStar_Pervasives_Native.Some e));
-                                         FStar_Syntax_Syntax.p =
-                                           (p1.FStar_Syntax_Syntax.p)
-                                       } in
-                                     let uu___7 =
-                                       FStar_TypeChecker_Common.conj_guard g
-                                         g' in
-                                     ([], [], [], env1, e, uu___7, p2)))))
-                 | FStar_Pervasives_Native.Some e ->
-                     ([], [], [], env1, e,
-                       FStar_TypeChecker_Env.trivial_guard, p1))
-            | FStar_Syntax_Syntax.Pat_wild x ->
-                let uu___ = intro_bv env1 x in
-                (match uu___ with
-                 | (x1, g, env2) ->
-                     let e =
-                       FStar_Syntax_Syntax.mk
-                         (FStar_Syntax_Syntax.Tm_name x1)
-                         p1.FStar_Syntax_Syntax.p in
-                     ([x1], [], [x1], env2, e, g, p1))
-            | FStar_Syntax_Syntax.Pat_var x ->
-                let uu___ = intro_bv env1 x in
-                (match uu___ with
-                 | (x1, g, env2) ->
-                     let e =
-                       FStar_Syntax_Syntax.mk
-                         (FStar_Syntax_Syntax.Tm_name x1)
-                         p1.FStar_Syntax_Syntax.p in
-                     ([x1], [x1], [], env2, e, g, p1))
-            | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-                let uu___ =
-                  FStar_Compiler_Effect.op_Bar_Greater pats
-                    (FStar_Compiler_List.fold_left
-                       (fun uu___1 ->
-                          fun uu___2 ->
-                            match (uu___1, uu___2) with
-                            | ((b, a, w, env2, args, guard, pats1),
-                               (p2, imp)) ->
-                                let uu___3 = pat_as_arg_with_env env2 p2 in
-                                (match uu___3 with
-                                 | (b', a', w', env3, te, guard', pat) ->
-                                     let arg =
-                                       if imp
-                                       then FStar_Syntax_Syntax.iarg te
-                                       else FStar_Syntax_Syntax.as_arg te in
-                                     let uu___4 =
-                                       FStar_TypeChecker_Common.conj_guard
-                                         guard guard' in
-                                     ((b' :: b), (a' :: a), (w' :: w), env3,
-                                       (arg :: args), uu___4, ((pat, imp) ::
-                                       pats1))))
-                       ([], [], [], env1, [],
-                         FStar_TypeChecker_Common.trivial_guard, [])) in
-                (match uu___ with
-                 | (b, a, w, env2, args, guard, pats1) ->
-                     let inst_head hd us_opt1 =
-                       match us_opt1 with
-                       | FStar_Pervasives_Native.None -> hd
-                       | FStar_Pervasives_Native.Some us ->
-                           FStar_Syntax_Syntax.mk_Tm_uinst hd us in
-                     let uu___1 =
-                       let hd = FStar_Syntax_Syntax.fv_to_tm fv in
-                       if
-                         (Prims.op_Negation inst_pat_cons_univs) ||
-                           (FStar_Pervasives_Native.uu___is_Some us_opt)
-                       then
-                         let uu___2 = inst_head hd us_opt in (uu___2, us_opt)
-                       else
-                         (let uu___3 =
-                            let uu___4 = FStar_Syntax_Syntax.lid_of_fv fv in
-                            FStar_TypeChecker_Env.lookup_datacon env2 uu___4 in
-                          match uu___3 with
-                          | (us, uu___4) ->
-                              if
-                                (FStar_Compiler_List.length us) =
-                                  Prims.int_zero
-                              then (hd, (FStar_Pervasives_Native.Some []))
-                              else
-                                (let uu___6 =
-                                   FStar_Syntax_Syntax.mk_Tm_uinst hd us in
-                                 (uu___6, (FStar_Pervasives_Native.Some us)))) in
-                     (match uu___1 with
-                      | (hd, us_opt1) ->
-                          let e =
-                            let uu___2 =
-                              FStar_Compiler_Effect.op_Bar_Greater args
-                                FStar_Compiler_List.rev in
-                            FStar_Syntax_Syntax.mk_Tm_app hd uu___2
-                              p1.FStar_Syntax_Syntax.p in
-                          let uu___2 =
-                            FStar_Compiler_Effect.op_Bar_Greater
-                              (FStar_Compiler_List.rev b)
-                              FStar_Compiler_List.flatten in
-                          let uu___3 =
-                            FStar_Compiler_Effect.op_Bar_Greater
-                              (FStar_Compiler_List.rev a)
-                              FStar_Compiler_List.flatten in
-                          let uu___4 =
-                            FStar_Compiler_Effect.op_Bar_Greater
-                              (FStar_Compiler_List.rev w)
-                              FStar_Compiler_List.flatten in
-                          (uu___2, uu___3, uu___4, env2, e, guard,
-                            {
-                              FStar_Syntax_Syntax.v =
-                                (FStar_Syntax_Syntax.Pat_cons
-                                   (fv, us_opt1,
-                                     (FStar_Compiler_List.rev pats1)));
-                              FStar_Syntax_Syntax.p =
-                                (p1.FStar_Syntax_Syntax.p)
-                            }))) in
-          let one_pat env1 p1 =
-            let p2 = elaborate_pat env1 p1 in
-            let uu___ = pat_as_arg_with_env env1 p2 in
-            match uu___ with
-            | (b, a, w, env2, arg, guard, p3) ->
-                let uu___1 =
-                  FStar_Compiler_Effect.op_Bar_Greater b
-                    (FStar_Compiler_Util.find_dup FStar_Syntax_Syntax.bv_eq) in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.Some x ->
-                     let m = FStar_Syntax_Print.bv_to_string x in
-                     let err =
-                       let uu___2 =
-                         FStar_Compiler_Util.format1
-                           "The pattern variable \"%s\" was used more than once"
-                           m in
-                       (FStar_Errors.Fatal_NonLinearPatternVars, uu___2) in
-                     FStar_Errors.raise_error err p3.FStar_Syntax_Syntax.p
-                 | uu___2 -> (b, a, w, arg, guard, p3)) in
-          let uu___ = one_pat env p in
-          match uu___ with
-          | (b, uu___1, uu___2, tm, guard, p1) -> (b, tm, guard, p1)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Positivity.ml b/src/ocaml-output/FStar_TypeChecker_Positivity.ml
deleted file mode 100644
index 8d03dd65d56..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Positivity.ml
+++ /dev/null
@@ -1,1422 +0,0 @@
-open Prims
-let (string_of_lids : FStar_Ident.lident Prims.list -> Prims.string) =
-  fun lids ->
-    let uu___ = FStar_Compiler_List.map FStar_Ident.string_of_lid lids in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let (debug_positivity :
-  FStar_TypeChecker_Env.env_t -> (unit -> Prims.string) -> unit) =
-  fun env ->
-    fun msg ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Less_Bar (FStar_TypeChecker_Env.debug env)
-          (FStar_Options.Other "Positivity") in
-      if uu___
-      then
-        let uu___1 =
-          let uu___2 = let uu___3 = msg () in Prims.op_Hat uu___3 "\n" in
-          Prims.op_Hat "Positivity::" uu___2 in
-        FStar_Compiler_Util.print_string uu___1
-      else ()
-let (normalize :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      FStar_TypeChecker_Normalize.normalize
-        [FStar_TypeChecker_Env.Beta;
-        FStar_TypeChecker_Env.HNF;
-        FStar_TypeChecker_Env.Weak;
-        FStar_TypeChecker_Env.Iota;
-        FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-        FStar_TypeChecker_Env.UnfoldUntil FStar_Syntax_Syntax.delta_constant]
-        env t
-let (apply_constr_arrow :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.arg Prims.list -> FStar_Syntax_Syntax.term)
-  =
-  fun dlid ->
-    fun dt ->
-      fun all_params ->
-        let rec aux t args =
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Subst.compress t in
-              uu___2.FStar_Syntax_Syntax.n in
-            (uu___1, args) in
-          match uu___ with
-          | (uu___1, []) -> FStar_Syntax_Util.canon_arrow t
-          | (FStar_Syntax_Syntax.Tm_arrow (b::bs, c), a::args1) ->
-              let tail =
-                match bs with
-                | [] -> FStar_Syntax_Util.comp_result c
-                | uu___1 ->
-                    FStar_Syntax_Syntax.mk
-                      (FStar_Syntax_Syntax.Tm_arrow (bs, c))
-                      t.FStar_Syntax_Syntax.pos in
-              let uu___1 = FStar_Syntax_Subst.open_term_1 b tail in
-              (match uu___1 with
-               | (b1, tail1) ->
-                   let tail2 =
-                     FStar_Syntax_Subst.subst
-                       [FStar_Syntax_Syntax.NT
-                          ((b1.FStar_Syntax_Syntax.binder_bv),
-                            (FStar_Pervasives_Native.fst a))] tail1 in
-                   aux tail2 args1)
-          | uu___1 ->
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Print.args_to_string all_params in
-                  let uu___5 = FStar_Ident.string_of_lid dlid in
-                  let uu___6 = FStar_Syntax_Print.term_to_string dt in
-                  FStar_Compiler_Util.format3
-                    "Unexpected application of type parameters %s to a data constructor %s : %s"
-                    uu___4 uu___5 uu___6 in
-                (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                  uu___3) in
-              let uu___3 = FStar_Ident.range_of_lid dlid in
-              FStar_Errors.raise_error uu___2 uu___3 in
-        aux dt all_params
-let (ty_occurs_in :
-  FStar_Ident.lident -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun ty_lid ->
-    fun t ->
-      let uu___ = FStar_Syntax_Free.fvars t in
-      FStar_Compiler_Util.set_mem ty_lid uu___
-let rec (term_as_fv_or_name :
-  FStar_Syntax_Syntax.term ->
-    ((FStar_Syntax_Syntax.fv * FStar_Syntax_Syntax.universes),
-      FStar_Syntax_Syntax.bv) FStar_Pervasives.either
-      FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_name x ->
-        FStar_Pervasives_Native.Some (FStar_Pervasives.Inr x)
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        FStar_Pervasives_Native.Some (FStar_Pervasives.Inl (fv, []))
-    | FStar_Syntax_Syntax.Tm_uinst (t1, us) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress t1 in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_fvar fv ->
-             FStar_Pervasives_Native.Some (FStar_Pervasives.Inl (fv, us))
-         | uu___2 ->
-             failwith "term_as_fv_or_name: impossible non fvar in uinst")
-    | FStar_Syntax_Syntax.Tm_ascribed (t1, uu___1, uu___2) ->
-        term_as_fv_or_name t1
-    | uu___1 -> FStar_Pervasives_Native.None
-let (open_sig_inductive_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_TypeChecker_Env.env * (FStar_Ident.lident *
-        FStar_Syntax_Syntax.univ_name Prims.list *
-        FStar_Syntax_Syntax.binders)))
-  =
-  fun env ->
-    fun se ->
-      match se.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_inductive_typ
-          (lid, ty_us, ty_params, _num_uniform, uu___, uu___1, uu___2) ->
-          let uu___3 = FStar_Syntax_Subst.univ_var_opening ty_us in
-          (match uu___3 with
-           | (ty_usubst, ty_us1) ->
-               let env1 = FStar_TypeChecker_Env.push_univ_vars env ty_us1 in
-               let ty_params1 =
-                 FStar_Syntax_Subst.subst_binders ty_usubst ty_params in
-               let ty_params2 = FStar_Syntax_Subst.open_binders ty_params1 in
-               let env2 = FStar_TypeChecker_Env.push_binders env1 ty_params2 in
-               (env2, (lid, ty_us1, ty_params2)))
-      | uu___ -> failwith "Impossible!"
-let rec min_l :
-  'a . Prims.int -> 'a Prims.list -> ('a -> Prims.int) -> Prims.int =
-  fun def ->
-    fun l ->
-      fun f ->
-        match l with
-        | [] -> def
-        | hd::tl ->
-            let uu___ = f hd in
-            let uu___1 = min_l def tl f in Prims.min uu___ uu___1
-let (max_uniformly_recursive_parameters :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Syntax_Syntax.bv Prims.list ->
-        FStar_Syntax_Syntax.term -> Prims.int)
-  =
-  fun env ->
-    fun mutuals ->
-      fun params ->
-        fun ty ->
-          let max_matching_prefix longer shorter f =
-            let rec aux n ls ms =
-              match (ls, ms) with
-              | (uu___, []) -> FStar_Pervasives_Native.Some n
-              | (l::ls1, m::ms1) ->
-                  let uu___ = f l m in
-                  if uu___
-                  then aux (n + Prims.int_one) ls1 ms1
-                  else FStar_Pervasives_Native.Some n
-              | uu___ -> FStar_Pervasives_Native.None in
-            aux Prims.int_zero longer shorter in
-          let ty1 = normalize env ty in
-          let n_params = FStar_Compiler_List.length params in
-          let compare_name_bv x y =
-            let uu___ =
-              let uu___1 =
-                FStar_Syntax_Subst.compress (FStar_Pervasives_Native.fst x) in
-              uu___1.FStar_Syntax_Syntax.n in
-            match uu___ with
-            | FStar_Syntax_Syntax.Tm_name x1 ->
-                FStar_Syntax_Syntax.bv_eq x1 y
-            | uu___1 -> false in
-          let min_l1 f l = min_l n_params f l in
-          let params_to_string uu___ =
-            let uu___1 =
-              FStar_Compiler_List.map FStar_Syntax_Print.bv_to_string params in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (FStar_String.concat ", ") in
-          debug_positivity env
-            (fun uu___1 ->
-               let uu___2 = params_to_string () in
-               let uu___3 = FStar_Syntax_Print.term_to_string ty1 in
-               FStar_Compiler_Util.format2
-                 "max_uniformly_recursive_parameters? params=%s in %s" uu___2
-                 uu___3);
-          (let rec aux ty2 =
-             debug_positivity env
-               (fun uu___2 ->
-                  let uu___3 = FStar_Syntax_Print.term_to_string ty2 in
-                  FStar_Compiler_Util.format1
-                    "max_uniformly_recursive_parameters.aux? %s" uu___3);
-             (let uu___2 =
-                FStar_Compiler_List.for_all
-                  (fun mutual ->
-                     let uu___3 = ty_occurs_in mutual ty2 in
-                     Prims.op_Negation uu___3) mutuals in
-              if uu___2
-              then n_params
-              else
-                (let uu___4 =
-                   let uu___5 = FStar_Syntax_Subst.compress ty2 in
-                   uu___5.FStar_Syntax_Syntax.n in
-                 match uu___4 with
-                 | FStar_Syntax_Syntax.Tm_name uu___5 -> n_params
-                 | FStar_Syntax_Syntax.Tm_fvar uu___5 -> n_params
-                 | FStar_Syntax_Syntax.Tm_uinst uu___5 -> n_params
-                 | FStar_Syntax_Syntax.Tm_type uu___5 -> n_params
-                 | FStar_Syntax_Syntax.Tm_constant uu___5 -> n_params
-                 | FStar_Syntax_Syntax.Tm_refine (x, f) ->
-                     let uu___5 = aux x.FStar_Syntax_Syntax.sort in
-                     let uu___6 =
-                       let uu___7 =
-                         let uu___8 =
-                           let uu___9 = FStar_Syntax_Syntax.mk_binder x in
-                           [uu___9] in
-                         FStar_Syntax_Subst.open_term uu___8 f in
-                       match uu___7 with | (uu___8, f1) -> aux f1 in
-                     Prims.min uu___5 uu___6
-                 | FStar_Syntax_Syntax.Tm_app uu___5 ->
-                     let uu___6 = FStar_Syntax_Util.head_and_args ty2 in
-                     (match uu___6 with
-                      | (head, args) ->
-                          let uu___7 =
-                            let uu___8 = FStar_Syntax_Util.un_uinst head in
-                            uu___8.FStar_Syntax_Syntax.n in
-                          (match uu___7 with
-                           | FStar_Syntax_Syntax.Tm_fvar fv ->
-                               let uu___8 =
-                                 FStar_Compiler_List.existsML
-                                   (FStar_Syntax_Syntax.fv_eq_lid fv) mutuals in
-                               if uu___8
-                               then
-                                 (debug_positivity env
-                                    (fun uu___10 ->
-                                       let uu___11 = params_to_string () in
-                                       let uu___12 =
-                                         FStar_Syntax_Print.args_to_string
-                                           args in
-                                       FStar_Compiler_Util.format2
-                                         "Searching for max matching prefix of params=%s in args=%s"
-                                         uu___11 uu___12);
-                                  (let uu___10 =
-                                     max_matching_prefix args params
-                                       compare_name_bv in
-                                   match uu___10 with
-                                   | FStar_Pervasives_Native.None ->
-                                       Prims.int_zero
-                                   | FStar_Pervasives_Native.Some n -> n))
-                               else
-                                 min_l1 args
-                                   (fun uu___10 ->
-                                      match uu___10 with
-                                      | (arg, uu___11) -> aux arg)
-                           | uu___8 ->
-                               let uu___9 = aux head in
-                               let uu___10 =
-                                 min_l1 args
-                                   (fun uu___11 ->
-                                      match uu___11 with
-                                      | (arg, uu___12) -> aux arg) in
-                               Prims.min uu___9 uu___10))
-                 | FStar_Syntax_Syntax.Tm_abs uu___5 ->
-                     let uu___6 = FStar_Syntax_Util.abs_formals ty2 in
-                     (match uu___6 with
-                      | (bs, body, uu___7) ->
-                          let uu___8 =
-                            min_l1 bs
-                              (fun b ->
-                                 aux
-                                   (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort) in
-                          let uu___9 = aux body in Prims.min uu___8 uu___9)
-                 | FStar_Syntax_Syntax.Tm_arrow uu___5 ->
-                     let uu___6 = FStar_Syntax_Util.arrow_formals ty2 in
-                     (match uu___6 with
-                      | (bs, r) ->
-                          let uu___7 =
-                            min_l1 bs
-                              (fun b ->
-                                 aux
-                                   (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort) in
-                          let uu___8 = aux r in Prims.min uu___7 uu___8)
-                 | FStar_Syntax_Syntax.Tm_match
-                     (scrutinee, uu___5, branches, uu___6) ->
-                     let uu___7 = aux scrutinee in
-                     let uu___8 =
-                       min_l1 branches
-                         (fun uu___9 ->
-                            match uu___9 with
-                            | (p, uu___10, t) ->
-                                let bs =
-                                  let uu___11 = FStar_Syntax_Syntax.pat_bvs p in
-                                  FStar_Compiler_List.map
-                                    FStar_Syntax_Syntax.mk_binder uu___11 in
-                                let uu___11 =
-                                  FStar_Syntax_Subst.open_term bs t in
-                                (match uu___11 with | (bs1, t1) -> aux t1)) in
-                     Prims.min uu___7 uu___8
-                 | FStar_Syntax_Syntax.Tm_meta (t, uu___5) -> aux t
-                 | FStar_Syntax_Syntax.Tm_ascribed (t, uu___5, uu___6) ->
-                     aux t
-                 | uu___5 -> Prims.int_zero)) in
-           let res = aux ty1 in
-           debug_positivity env
-             (fun uu___2 ->
-                let uu___3 = params_to_string () in
-                let uu___4 = FStar_Syntax_Print.term_to_string ty1 in
-                FStar_Compiler_Util.format3
-                  "result: max_uniformly_recursive_parameters(params=%s in %s) = %s"
-                  uu___3 uu___4 (Prims.string_of_int res));
-           res)
-let (mark_uniform_type_parameters :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun env ->
-    fun sig1 ->
-      let mark_tycon_parameters tc datas =
-        let uu___ = tc.FStar_Syntax_Syntax.sigel in
-        match uu___ with
-        | FStar_Syntax_Syntax.Sig_inductive_typ
-            (tc_lid, us, ty_param_binders, _num_uniform, t, mutuals,
-             data_lids)
-            ->
-            let uu___1 = open_sig_inductive_typ env tc in
-            (match uu___1 with
-             | (env1, (tc_lid1, us1, ty_params)) ->
-                 let uu___2 = FStar_Syntax_Util.args_of_binders ty_params in
-                 (match uu___2 with
-                  | (uu___3, ty_param_args) ->
-                      let datacon_fields =
-                        FStar_Compiler_List.filter_map
-                          (fun data ->
-                             match data.FStar_Syntax_Syntax.sigel with
-                             | FStar_Syntax_Syntax.Sig_datacon
-                                 (d_lid, d_us, dt, tc_lid', uu___4, uu___5)
-                                 ->
-                                 let uu___6 =
-                                   FStar_Ident.lid_equals tc_lid1 tc_lid' in
-                                 if uu___6
-                                 then
-                                   let dt1 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         FStar_Compiler_List.map
-                                           (fun uu___9 ->
-                                              FStar_Syntax_Syntax.U_name
-                                                uu___9) us1 in
-                                       FStar_TypeChecker_Env.mk_univ_subst
-                                         d_us uu___8 in
-                                     FStar_Syntax_Subst.subst uu___7 dt in
-                                   let uu___7 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         apply_constr_arrow d_lid dt1
-                                           ty_param_args in
-                                       FStar_Syntax_Util.arrow_formals uu___9 in
-                                     FStar_Pervasives_Native.fst uu___8 in
-                                   FStar_Pervasives_Native.Some uu___7
-                                 else FStar_Pervasives_Native.None
-                             | uu___4 -> FStar_Pervasives_Native.None) datas in
-                      let ty_param_bvs =
-                        FStar_Compiler_List.map
-                          (fun b -> b.FStar_Syntax_Syntax.binder_bv)
-                          ty_params in
-                      let n_params = FStar_Compiler_List.length ty_params in
-                      let min_l1 f l = min_l n_params f l in
-                      let max_uniform_prefix =
-                        min_l1 datacon_fields
-                          (fun fields_of_one_datacon ->
-                             min_l1 fields_of_one_datacon
-                               (fun field ->
-                                  max_uniformly_recursive_parameters env1
-                                    mutuals ty_param_bvs
-                                    (field.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)) in
-                      (if max_uniform_prefix < n_params
-                       then
-                         (let uu___5 =
-                            FStar_Compiler_List.splitAt max_uniform_prefix
-                              ty_param_binders in
-                          match uu___5 with
-                          | (uu___6, non_uniform_params) ->
-                              FStar_Compiler_List.iter
-                                (fun param ->
-                                   let uu___7 =
-                                     FStar_Syntax_Util.has_attribute
-                                       param.FStar_Syntax_Syntax.binder_attrs
-                                       FStar_Parser_Const.binder_strictly_positive_attr in
-                                   if uu___7
-                                   then
-                                     let uu___8 =
-                                       let uu___9 =
-                                         let uu___10 =
-                                           FStar_Syntax_Print.binder_to_string
-                                             param in
-                                         FStar_Compiler_Util.format1
-                                           "Binder %s is marked strictly positive, but it is not uniformly recursive"
-                                           uu___10 in
-                                       (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                                         uu___9) in
-                                     let uu___9 =
-                                       FStar_Syntax_Syntax.range_of_bv
-                                         param.FStar_Syntax_Syntax.binder_bv in
-                                     FStar_Errors.raise_error uu___8 uu___9
-                                   else ()) non_uniform_params)
-                       else ();
-                       (let sigel =
-                          FStar_Syntax_Syntax.Sig_inductive_typ
-                            (tc_lid1, us1, ty_param_binders,
-                              (FStar_Pervasives_Native.Some
-                                 max_uniform_prefix), t, mutuals, data_lids) in
-                        {
-                          FStar_Syntax_Syntax.sigel = sigel;
-                          FStar_Syntax_Syntax.sigrng =
-                            (tc.FStar_Syntax_Syntax.sigrng);
-                          FStar_Syntax_Syntax.sigquals =
-                            (tc.FStar_Syntax_Syntax.sigquals);
-                          FStar_Syntax_Syntax.sigmeta =
-                            (tc.FStar_Syntax_Syntax.sigmeta);
-                          FStar_Syntax_Syntax.sigattrs =
-                            (tc.FStar_Syntax_Syntax.sigattrs);
-                          FStar_Syntax_Syntax.sigopts =
-                            (tc.FStar_Syntax_Syntax.sigopts)
-                        })))) in
-      match sig1.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_bundle (ses, lids) ->
-          let uu___ =
-            FStar_Compiler_List.partition
-              (fun se ->
-                 FStar_Syntax_Syntax.uu___is_Sig_inductive_typ
-                   se.FStar_Syntax_Syntax.sigel) ses in
-          (match uu___ with
-           | (tcs, datas) ->
-               let tcs1 =
-                 FStar_Compiler_List.map
-                   (fun tc -> mark_tycon_parameters tc datas) tcs in
-               {
-                 FStar_Syntax_Syntax.sigel =
-                   (FStar_Syntax_Syntax.Sig_bundle
-                      ((FStar_List_Tot_Base.op_At tcs1 datas), lids));
-                 FStar_Syntax_Syntax.sigrng =
-                   (sig1.FStar_Syntax_Syntax.sigrng);
-                 FStar_Syntax_Syntax.sigquals =
-                   (sig1.FStar_Syntax_Syntax.sigquals);
-                 FStar_Syntax_Syntax.sigmeta =
-                   (sig1.FStar_Syntax_Syntax.sigmeta);
-                 FStar_Syntax_Syntax.sigattrs =
-                   (sig1.FStar_Syntax_Syntax.sigattrs);
-                 FStar_Syntax_Syntax.sigopts =
-                   (sig1.FStar_Syntax_Syntax.sigopts)
-               })
-      | uu___ -> sig1
-let (may_be_an_arity :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun env ->
-    fun t ->
-      let t1 = normalize env t in
-      let rec aux t2 =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress t2 in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_name uu___1 -> false
-        | FStar_Syntax_Syntax.Tm_constant uu___1 -> false
-        | FStar_Syntax_Syntax.Tm_abs uu___1 -> false
-        | FStar_Syntax_Syntax.Tm_lazy uu___1 -> false
-        | FStar_Syntax_Syntax.Tm_quoted uu___1 -> false
-        | FStar_Syntax_Syntax.Tm_fvar uu___1 ->
-            let uu___2 = FStar_Syntax_Util.head_and_args t2 in
-            (match uu___2 with
-             | (head, args) ->
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Util.un_uinst head in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 (match uu___3 with
-                  | FStar_Syntax_Syntax.Tm_fvar fv ->
-                      let uu___4 =
-                        FStar_TypeChecker_Env.lookup_sigelt env
-                          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                      (match uu___4 with
-                       | FStar_Pervasives_Native.None -> true
-                       | FStar_Pervasives_Native.Some se ->
-                           (match se.FStar_Syntax_Syntax.sigel with
-                            | FStar_Syntax_Syntax.Sig_let uu___5 -> true
-                            | uu___5 -> false))
-                  | uu___4 -> true))
-        | FStar_Syntax_Syntax.Tm_uinst uu___1 ->
-            let uu___2 = FStar_Syntax_Util.head_and_args t2 in
-            (match uu___2 with
-             | (head, args) ->
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Util.un_uinst head in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 (match uu___3 with
-                  | FStar_Syntax_Syntax.Tm_fvar fv ->
-                      let uu___4 =
-                        FStar_TypeChecker_Env.lookup_sigelt env
-                          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                      (match uu___4 with
-                       | FStar_Pervasives_Native.None -> true
-                       | FStar_Pervasives_Native.Some se ->
-                           (match se.FStar_Syntax_Syntax.sigel with
-                            | FStar_Syntax_Syntax.Sig_let uu___5 -> true
-                            | uu___5 -> false))
-                  | uu___4 -> true))
-        | FStar_Syntax_Syntax.Tm_app uu___1 ->
-            let uu___2 = FStar_Syntax_Util.head_and_args t2 in
-            (match uu___2 with
-             | (head, args) ->
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Util.un_uinst head in
-                   uu___4.FStar_Syntax_Syntax.n in
-                 (match uu___3 with
-                  | FStar_Syntax_Syntax.Tm_fvar fv ->
-                      let uu___4 =
-                        FStar_TypeChecker_Env.lookup_sigelt env
-                          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                      (match uu___4 with
-                       | FStar_Pervasives_Native.None -> true
-                       | FStar_Pervasives_Native.Some se ->
-                           (match se.FStar_Syntax_Syntax.sigel with
-                            | FStar_Syntax_Syntax.Sig_let uu___5 -> true
-                            | uu___5 -> false))
-                  | uu___4 -> true))
-        | FStar_Syntax_Syntax.Tm_type uu___1 -> true
-        | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-            let uu___2 = FStar_Syntax_Util.arrow_formals t2 in
-            (match uu___2 with | (uu___3, t3) -> aux t3)
-        | FStar_Syntax_Syntax.Tm_refine (x, uu___1) ->
-            aux x.FStar_Syntax_Syntax.sort
-        | FStar_Syntax_Syntax.Tm_match (uu___1, uu___2, branches, uu___3) ->
-            FStar_Compiler_List.existsML
-              (fun uu___4 ->
-                 match uu___4 with
-                 | (p, uu___5, t3) ->
-                     let bs =
-                       let uu___6 = FStar_Syntax_Syntax.pat_bvs p in
-                       FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder
-                         uu___6 in
-                     let uu___6 = FStar_Syntax_Subst.open_term bs t3 in
-                     (match uu___6 with | (bs1, t4) -> aux t4)) branches
-        | FStar_Syntax_Syntax.Tm_meta (t3, uu___1) -> aux t3
-        | FStar_Syntax_Syntax.Tm_ascribed (t3, uu___1, uu___2) -> aux t3
-        | FStar_Syntax_Syntax.Tm_uvar uu___1 -> true
-        | FStar_Syntax_Syntax.Tm_let uu___1 -> true
-        | FStar_Syntax_Syntax.Tm_delayed uu___1 -> failwith "Impossible"
-        | FStar_Syntax_Syntax.Tm_bvar uu___1 -> failwith "Impossible"
-        | FStar_Syntax_Syntax.Tm_unknown -> failwith "Impossible" in
-      aux t1
-let (check_no_index_occurrences_in_arities :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident Prims.list -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun env ->
-    fun mutuals ->
-      fun t ->
-        debug_positivity env
-          (fun uu___1 ->
-             let uu___2 = string_of_lids mutuals in
-             let uu___3 = FStar_Syntax_Print.term_to_string t in
-             FStar_Compiler_Util.format2
-               "check_no_index_occurrences of (mutuals %s) in arities of %s"
-               uu___2 uu___3);
-        (let no_occurrence_in_index fv mutuals1 index =
-           let fext_on_domain_index_sub_term index1 =
-             let uu___1 = FStar_Syntax_Util.head_and_args index1 in
-             match uu___1 with
-             | (head, args) ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Util.un_uinst head in
-                     uu___4.FStar_Syntax_Syntax.n in
-                   (uu___3, args) in
-                 (match uu___2 with
-                  | (FStar_Syntax_Syntax.Tm_fvar fv1,
-                     _td::_tr::(f, uu___3)::[]) ->
-                      let uu___4 =
-                        (FStar_Syntax_Syntax.fv_eq_lid fv1
-                           FStar_Parser_Const.fext_on_domain_lid)
-                          ||
-                          (FStar_Syntax_Syntax.fv_eq_lid fv1
-                             FStar_Parser_Const.fext_on_domain_g_lid) in
-                      if uu___4 then f else index1
-                  | uu___3 -> index1) in
-           let uu___1 = index in
-           match uu___1 with
-           | (index1, uu___2) ->
-               FStar_Compiler_List.iter
-                 (fun mutual ->
-                    let uu___3 =
-                      let uu___4 = fext_on_domain_index_sub_term index1 in
-                      ty_occurs_in mutual uu___4 in
-                    if uu___3
-                    then
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 = FStar_Ident.string_of_lid mutual in
-                          let uu___7 =
-                            FStar_Syntax_Print.term_to_string index1 in
-                          let uu___8 = FStar_Ident.string_of_lid fv in
-                          FStar_Compiler_Util.format3
-                            "Type %s is not strictly positive since it instantiates a non-uniformly recursive parameter or index %s of %s"
-                            uu___6 uu___7 uu___8 in
-                        (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                          uu___5) in
-                      FStar_Errors.raise_error uu___4
-                        index1.FStar_Syntax_Syntax.pos
-                    else ()) mutuals1 in
-         let no_occurrence_in_indexes fv mutuals1 indexes =
-           FStar_Compiler_List.iter (no_occurrence_in_index fv mutuals1)
-             indexes in
-         let uu___1 = FStar_Syntax_Util.head_and_args t in
-         match uu___1 with
-         | (head, args) ->
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Util.un_uinst head in
-               uu___3.FStar_Syntax_Syntax.n in
-             (match uu___2 with
-              | FStar_Syntax_Syntax.Tm_fvar fv ->
-                  let uu___3 =
-                    FStar_TypeChecker_Env.num_inductive_uniform_ty_params env
-                      (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                  (match uu___3 with
-                   | FStar_Pervasives_Native.None -> ()
-                   | FStar_Pervasives_Native.Some n ->
-                       if (FStar_Compiler_List.length args) <= n
-                       then ()
-                       else
-                         (let uu___5 =
-                            FStar_TypeChecker_Env.try_lookup_lid env
-                              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                          match uu___5 with
-                          | FStar_Pervasives_Native.None ->
-                              no_occurrence_in_indexes
-                                (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                mutuals args
-                          | FStar_Pervasives_Native.Some
-                              ((_us, i_typ), uu___6) ->
-                              (debug_positivity env
-                                 (fun uu___8 ->
-                                    let uu___9 =
-                                      FStar_Syntax_Print.term_to_string t in
-                                    FStar_Compiler_Util.format2
-                                      "Checking arity indexes of %s (num uniform params = %s)"
-                                      uu___9 (Prims.string_of_int n));
-                               (let uu___8 =
-                                  FStar_Compiler_List.splitAt n args in
-                                match uu___8 with
-                                | (params, indices) ->
-                                    let inst_i_typ =
-                                      apply_constr_arrow
-                                        (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                        i_typ params in
-                                    let uu___9 =
-                                      FStar_Syntax_Util.arrow_formals
-                                        inst_i_typ in
-                                    (match uu___9 with
-                                     | (formals, _sort) ->
-                                         let rec aux subst formals1 indices1
-                                           =
-                                           match (formals1, indices1) with
-                                           | (uu___10, []) -> ()
-                                           | (f::formals2, i::indices2) ->
-                                               let f_t =
-                                                 FStar_Syntax_Subst.subst
-                                                   subst
-                                                   (f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                               ((let uu___11 =
-                                                   may_be_an_arity env f_t in
-                                                 if uu___11
-                                                 then
-                                                   (debug_positivity env
-                                                      (fun uu___13 ->
-                                                         let uu___14 =
-                                                           FStar_Syntax_Print.term_to_string
-                                                             (FStar_Pervasives_Native.fst
-                                                                i) in
-                                                         let uu___15 =
-                                                           FStar_Syntax_Print.term_to_string
-                                                             f_t in
-                                                         FStar_Compiler_Util.format2
-                                                           "Checking %s : %s (arity)"
-                                                           uu___14 uu___15);
-                                                    no_occurrence_in_index
-                                                      (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                                      mutuals i)
-                                                 else
-                                                   debug_positivity env
-                                                     (fun uu___13 ->
-                                                        let uu___14 =
-                                                          FStar_Syntax_Print.term_to_string
-                                                            (FStar_Pervasives_Native.fst
-                                                               i) in
-                                                        let uu___15 =
-                                                          FStar_Syntax_Print.term_to_string
-                                                            f_t in
-                                                        FStar_Compiler_Util.format2
-                                                          "Skipping %s : %s (non-arity)"
-                                                          uu___14 uu___15));
-                                                (let subst1 =
-                                                   (FStar_Syntax_Syntax.NT
-                                                      ((f.FStar_Syntax_Syntax.binder_bv),
-                                                        (FStar_Pervasives_Native.fst
-                                                           i)))
-                                                   :: subst in
-                                                 aux subst1 formals2 indices2))
-                                           | ([], uu___10) ->
-                                               no_occurrence_in_indexes
-                                                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                                 mutuals indices1 in
-                                         aux [] formals indices)))))
-              | uu___3 -> ()))
-type unfolded_memo_elt =
-  (FStar_Ident.lident * FStar_Syntax_Syntax.args * Prims.int) Prims.list
-type unfolded_memo_t = unfolded_memo_elt FStar_Compiler_Effect.ref
-let (already_unfolded :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.args ->
-      unfolded_memo_t -> FStar_TypeChecker_Env.env_t -> Prims.bool)
-  =
-  fun ilid ->
-    fun args ->
-      fun unfolded ->
-        fun env ->
-          let uu___ = FStar_Compiler_Effect.op_Bang unfolded in
-          FStar_Compiler_List.existsML
-            (fun uu___1 ->
-               match uu___1 with
-               | (lid, l, n) ->
-                   ((FStar_Ident.lid_equals lid ilid) &&
-                      ((FStar_Compiler_List.length args) >= n))
-                     &&
-                     (let args1 =
-                        let uu___2 = FStar_Compiler_List.splitAt n args in
-                        FStar_Pervasives_Native.fst uu___2 in
-                      FStar_Compiler_List.fold_left2
-                        (fun b ->
-                           fun a ->
-                             fun a' ->
-                               b &&
-                                 (FStar_TypeChecker_Rel.teq_nosmt_force env
-                                    (FStar_Pervasives_Native.fst a)
-                                    (FStar_Pervasives_Native.fst a'))) true
-                        args1 l)) uu___
-let rec (ty_strictly_positive_in_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Syntax_Syntax.term -> unfolded_memo_t -> Prims.bool)
-  =
-  fun env ->
-    fun mutuals ->
-      fun in_type ->
-        fun unfolded ->
-          let in_type1 = normalize env in_type in
-          debug_positivity env
-            (fun uu___1 ->
-               let uu___2 = string_of_lids mutuals in
-               let uu___3 = FStar_Syntax_Print.term_to_string in_type1 in
-               FStar_Compiler_Util.format2
-                 "Checking strict positivity of {%s} in type, after normalization %s "
-                 uu___2 uu___3);
-          (let uu___1 =
-             FStar_Compiler_List.for_all
-               (fun mutual ->
-                  let uu___2 = ty_occurs_in mutual in_type1 in
-                  Prims.op_Negation uu___2) mutuals in
-           if uu___1
-           then true
-           else
-             (debug_positivity env
-                (fun uu___4 -> "ty does occur in this type");
-              (let uu___4 =
-                 let uu___5 = FStar_Syntax_Subst.compress in_type1 in
-                 uu___5.FStar_Syntax_Syntax.n in
-               match uu___4 with
-               | FStar_Syntax_Syntax.Tm_fvar uu___5 ->
-                   (debug_positivity env
-                      (fun uu___7 ->
-                         "Checking strict positivity in an fvar/Tm_uinst/Tm_type, return true");
-                    true)
-               | FStar_Syntax_Syntax.Tm_uinst uu___5 ->
-                   (debug_positivity env
-                      (fun uu___7 ->
-                         "Checking strict positivity in an fvar/Tm_uinst/Tm_type, return true");
-                    true)
-               | FStar_Syntax_Syntax.Tm_type uu___5 ->
-                   (debug_positivity env
-                      (fun uu___7 ->
-                         "Checking strict positivity in an fvar/Tm_uinst/Tm_type, return true");
-                    true)
-               | FStar_Syntax_Syntax.Tm_ascribed (t, uu___5, uu___6) ->
-                   ty_strictly_positive_in_type env mutuals t unfolded
-               | FStar_Syntax_Syntax.Tm_meta (t, uu___5) ->
-                   ty_strictly_positive_in_type env mutuals t unfolded
-               | FStar_Syntax_Syntax.Tm_app (t, args) ->
-                   let fv_or_name_opt = term_as_fv_or_name t in
-                   (match fv_or_name_opt with
-                    | FStar_Pervasives_Native.None ->
-                        (debug_positivity env
-                           (fun uu___6 ->
-                              let uu___7 = string_of_lids mutuals in
-                              let uu___8 =
-                                FStar_Syntax_Print.term_to_string t in
-                              FStar_Compiler_Util.format2
-                                "Failed to check positivity of %s in a term with head %s"
-                                uu___7 uu___8);
-                         false)
-                    | FStar_Pervasives_Native.Some (FStar_Pervasives.Inr x)
-                        ->
-                        let uu___5 = FStar_TypeChecker_Env.lookup_bv env x in
-                        (match uu___5 with
-                         | (head_ty, _pos) ->
-                             (debug_positivity env
-                                (fun uu___7 ->
-                                   let uu___8 =
-                                     FStar_Syntax_Print.term_to_string
-                                       in_type1 in
-                                   let uu___9 =
-                                     FStar_Syntax_Print.nm_to_string x in
-                                   let uu___10 =
-                                     FStar_Syntax_Print.term_to_string
-                                       head_ty in
-                                   FStar_Compiler_Util.format3
-                                     "Tm_app, head bv, in_type=%s, head_bv=%s, head_ty=%s"
-                                     uu___8 uu___9 uu___10);
-                              ty_strictly_positive_in_args env mutuals
-                                head_ty args unfolded))
-                    | FStar_Pervasives_Native.Some (FStar_Pervasives.Inl
-                        (fv, us)) ->
-                        let uu___5 =
-                          FStar_Compiler_List.existsML
-                            (FStar_Ident.lid_equals
-                               (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-                            mutuals in
-                        if uu___5
-                        then
-                          (debug_positivity env
-                             (fun uu___7 ->
-                                let uu___8 =
-                                  FStar_Ident.string_of_lid
-                                    (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                FStar_Compiler_Util.format1
-                                  "Checking strict positivity in the Tm_app node where head lid is %s itself, checking that ty does not occur in the arguments"
-                                  uu___8);
-                           FStar_Compiler_List.for_all
-                             (fun ty_lid ->
-                                FStar_Compiler_List.for_all
-                                  (fun uu___7 ->
-                                     match uu___7 with
-                                     | (t1, uu___8) ->
-                                         let uu___9 = ty_occurs_in ty_lid t1 in
-                                         Prims.op_Negation uu___9) args)
-                             mutuals)
-                        else
-                          (debug_positivity env
-                             (fun uu___8 ->
-                                let uu___9 = string_of_lids mutuals in
-                                FStar_Compiler_Util.format1
-                                  "Checking strict positivity in the Tm_app node, head lid is not in %s, so checking nested positivity"
-                                  uu___9);
-                           ty_strictly_positive_in_arguments_to_fvar env
-                             mutuals in_type1
-                             (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                             us args unfolded))
-               | FStar_Syntax_Syntax.Tm_arrow (uu___5, c) ->
-                   (debug_positivity env
-                      (fun uu___7 -> "Checking strict positivity in Tm_arrow");
-                    (let check_comp =
-                       (FStar_Syntax_Util.is_pure_or_ghost_comp c) ||
-                         (let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_Compiler_Effect.op_Bar_Greater c
-                                  FStar_Syntax_Util.comp_effect_name in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                (FStar_TypeChecker_Env.norm_eff_name env) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___8
-                              (FStar_TypeChecker_Env.lookup_effect_quals env) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___7
-                            (FStar_Compiler_List.contains
-                               FStar_Syntax_Syntax.TotalEffect)) in
-                     if Prims.op_Negation check_comp
-                     then
-                       (debug_positivity env
-                          (fun uu___8 ->
-                             "Checking strict positivity , the arrow is impure, so return true");
-                        true)
-                     else
-                       (debug_positivity env
-                          (fun uu___9 ->
-                             "Checking strict positivity for an arrow, checking that ty does not occur in the binders, and that it is strictly positive in the return type");
-                        (let uu___9 =
-                           FStar_Syntax_Util.arrow_formals_comp in_type1 in
-                         match uu___9 with
-                         | (sbs, c1) ->
-                             let return_type =
-                               FStar_Syntax_Util.comp_result c1 in
-                             let ty_lid_not_to_left_of_arrow =
-                               FStar_Compiler_List.for_all
-                                 (fun ty_lid ->
-                                    FStar_Compiler_List.for_all
-                                      (fun uu___10 ->
-                                         match uu___10 with
-                                         | {
-                                             FStar_Syntax_Syntax.binder_bv =
-                                               b;
-                                             FStar_Syntax_Syntax.binder_qual
-                                               = uu___11;
-                                             FStar_Syntax_Syntax.binder_attrs
-                                               = uu___12;_}
-                                             ->
-                                             let uu___13 =
-                                               ty_occurs_in ty_lid
-                                                 b.FStar_Syntax_Syntax.sort in
-                                             Prims.op_Negation uu___13) sbs)
-                                 mutuals in
-                             if ty_lid_not_to_left_of_arrow
-                             then
-                               let uu___10 =
-                                 FStar_TypeChecker_Env.push_binders env sbs in
-                               ty_strictly_positive_in_type uu___10 mutuals
-                                 return_type unfolded
-                             else false))))
-               | FStar_Syntax_Syntax.Tm_refine (bv, f) ->
-                   (debug_positivity env
-                      (fun uu___6 ->
-                         "Checking strict positivity in an Tm_refine, recur in the bv sort)");
-                    (let uu___6 =
-                       let uu___7 =
-                         let uu___8 = FStar_Syntax_Syntax.mk_binder bv in
-                         [uu___8] in
-                       FStar_Syntax_Subst.open_term uu___7 f in
-                     match uu___6 with
-                     | (b::[], f1) ->
-                         let uu___7 =
-                           ty_strictly_positive_in_type env mutuals
-                             (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                             unfolded in
-                         if uu___7
-                         then
-                           let env1 =
-                             FStar_TypeChecker_Env.push_binders env [b] in
-                           ty_strictly_positive_in_type env1 mutuals f1
-                             unfolded
-                         else false))
-               | FStar_Syntax_Syntax.Tm_match
-                   (scrutinee, uu___5, branches, uu___6) ->
-                   (debug_positivity env
-                      (fun uu___8 ->
-                         "Checking strict positivity in an Tm_match, recur in the branches)");
-                    (let uu___8 =
-                       FStar_Compiler_List.existsML
-                         (fun mutual -> ty_occurs_in mutual scrutinee)
-                         mutuals in
-                     if uu___8
-                     then false
-                     else
-                       FStar_Compiler_List.for_all
-                         (fun uu___10 ->
-                            match uu___10 with
-                            | (p, uu___11, t) ->
-                                let bs =
-                                  let uu___12 = FStar_Syntax_Syntax.pat_bvs p in
-                                  FStar_Compiler_List.map
-                                    FStar_Syntax_Syntax.mk_binder uu___12 in
-                                let uu___12 =
-                                  FStar_Syntax_Subst.open_term bs t in
-                                (match uu___12 with
-                                 | (bs1, t1) ->
-                                     let uu___13 =
-                                       FStar_TypeChecker_Env.push_binders env
-                                         bs1 in
-                                     ty_strictly_positive_in_type uu___13
-                                       mutuals t1 unfolded)) branches))
-               | FStar_Syntax_Syntax.Tm_abs uu___5 ->
-                   let uu___6 = FStar_Syntax_Util.abs_formals in_type1 in
-                   (match uu___6 with
-                    | (bs, body, uu___7) ->
-                        let rec aux env1 bs1 =
-                          match bs1 with
-                          | [] ->
-                              ty_strictly_positive_in_type env1 mutuals body
-                                unfolded
-                          | b::bs2 ->
-                              let uu___8 =
-                                ty_strictly_positive_in_type env1 mutuals
-                                  (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                  unfolded in
-                              if uu___8
-                              then
-                                let env2 =
-                                  FStar_TypeChecker_Env.push_binders env1 [b] in
-                                aux env2 bs2
-                              else false in
-                        aux env bs)
-               | uu___5 ->
-                   (debug_positivity env
-                      (fun uu___7 ->
-                         let uu___8 = FStar_Syntax_Print.tag_of_term in_type1 in
-                         let uu___9 =
-                           FStar_Syntax_Print.term_to_string in_type1 in
-                         FStar_Compiler_Util.format2
-                           "Checking strict positivity, unexpected tag: %s and term %s"
-                           uu___8 uu___9);
-                    false))))
-and (ty_strictly_positive_in_args :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.args -> unfolded_memo_t -> Prims.bool)
-  =
-  fun env ->
-    fun mutuals ->
-      fun head_t ->
-        fun args ->
-          fun unfolded ->
-            let uu___ = FStar_Syntax_Util.arrow_formals head_t in
-            match uu___ with
-            | (bs, uu___1) ->
-                let rec aux bs1 args1 =
-                  match (bs1, args1) with
-                  | (uu___2, []) -> true
-                  | ([], uu___2) ->
-                      FStar_Compiler_List.for_all
-                        (fun ty_lid ->
-                           FStar_Compiler_List.for_all
-                             (fun uu___3 ->
-                                match uu___3 with
-                                | (arg, uu___4) ->
-                                    let uu___5 = ty_occurs_in ty_lid arg in
-                                    Prims.op_Negation uu___5) args1) mutuals
-                  | (b::bs2, (arg, uu___2)::args2) ->
-                      (debug_positivity env
-                         (fun uu___4 ->
-                            let uu___5 = string_of_lids mutuals in
-                            let uu___6 =
-                              FStar_Syntax_Print.term_to_string arg in
-                            let uu___7 =
-                              FStar_Syntax_Print.binder_to_string b in
-                            FStar_Compiler_Util.format3
-                              "Checking positivity of %s in argument %s and binder %s"
-                              uu___5 uu___6 uu___7);
-                       (let this_occurrence_ok =
-                          (FStar_Compiler_List.for_all
-                             (fun ty_lid ->
-                                let uu___4 = ty_occurs_in ty_lid arg in
-                                Prims.op_Negation uu___4) mutuals)
-                            ||
-                            ((FStar_Syntax_Util.has_attribute
-                                b.FStar_Syntax_Syntax.binder_attrs
-                                FStar_Parser_Const.binder_strictly_positive_attr)
-                               &&
-                               (ty_strictly_positive_in_type env mutuals arg
-                                  unfolded)) in
-                        if Prims.op_Negation this_occurrence_ok
-                        then
-                          (debug_positivity env
-                             (fun uu___5 ->
-                                let uu___6 = string_of_lids mutuals in
-                                let uu___7 =
-                                  FStar_Syntax_Print.term_to_string arg in
-                                let uu___8 =
-                                  FStar_Syntax_Print.binder_to_string b in
-                                FStar_Compiler_Util.format3
-                                  "Failed checking positivity of %s in argument %s and binder %s"
-                                  uu___6 uu___7 uu___8);
-                           false)
-                        else aux bs2 args2)) in
-                aux bs args
-and (ty_strictly_positive_in_arguments_to_fvar :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.universes ->
-            FStar_Syntax_Syntax.args -> unfolded_memo_t -> Prims.bool)
-  =
-  fun env ->
-    fun mutuals ->
-      fun t ->
-        fun fv ->
-          fun us ->
-            fun args ->
-              fun unfolded ->
-                debug_positivity env
-                  (fun uu___1 ->
-                     let uu___2 = string_of_lids mutuals in
-                     let uu___3 = FStar_Ident.string_of_lid fv in
-                     let uu___4 = FStar_Syntax_Print.args_to_string args in
-                     let uu___5 = FStar_Syntax_Print.term_to_string t in
-                     FStar_Compiler_Util.format4
-                       "Checking positivity of %s in application of fv %s to %s (t=%s)"
-                       uu___2 uu___3 uu___4 uu___5);
-                (let fv_ty =
-                   let uu___1 = FStar_TypeChecker_Env.try_lookup_lid env fv in
-                   match uu___1 with
-                   | FStar_Pervasives_Native.Some ((uu___2, fv_ty1), uu___3)
-                       -> fv_ty1
-                   | uu___2 ->
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 = FStar_Ident.string_of_lid fv in
-                           FStar_Compiler_Util.format1
-                             "Type of %s not found when checking positivity"
-                             uu___5 in
-                         (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                           uu___4) in
-                       let uu___4 = FStar_Ident.range_of_lid fv in
-                       FStar_Errors.raise_error uu___3 uu___4 in
-                 let uu___1 = FStar_TypeChecker_Env.datacons_of_typ env fv in
-                 match uu___1 with
-                 | (b, idatas) ->
-                     if Prims.op_Negation b
-                     then
-                       ty_strictly_positive_in_args env mutuals fv_ty args
-                         unfolded
-                     else
-                       (check_no_index_occurrences_in_arities env mutuals t;
-                        (let ilid = fv in
-                         let num_uniform_params =
-                           let uu___4 =
-                             FStar_TypeChecker_Env.num_inductive_uniform_ty_params
-                               env ilid in
-                           match uu___4 with
-                           | FStar_Pervasives_Native.None ->
-                               failwith "Unexpected type"
-                           | FStar_Pervasives_Native.Some n -> n in
-                         let uu___4 =
-                           FStar_Compiler_List.splitAt num_uniform_params
-                             args in
-                         match uu___4 with
-                         | (params, _rest) ->
-                             let uu___5 =
-                               already_unfolded ilid args unfolded env in
-                             if uu___5
-                             then
-                               (debug_positivity env
-                                  (fun uu___7 ->
-                                     "Checking nested positivity, we have already unfolded this inductive with these args");
-                                true)
-                             else
-                               (debug_positivity env
-                                  (fun uu___8 ->
-                                     let uu___9 =
-                                       FStar_Ident.string_of_lid ilid in
-                                     let uu___10 =
-                                       FStar_Syntax_Print.args_to_string
-                                         params in
-                                     FStar_Compiler_Util.format3
-                                       "Checking positivity in datacon, number of type parameters is %s, adding %s %s to the memo table"
-                                       (Prims.string_of_int
-                                          num_uniform_params) uu___9 uu___10);
-                                (let uu___9 =
-                                   let uu___10 =
-                                     FStar_Compiler_Effect.op_Bang unfolded in
-                                   FStar_List_Tot_Base.op_At uu___10
-                                     [(ilid, params, num_uniform_params)] in
-                                 FStar_Compiler_Effect.op_Colon_Equals
-                                   unfolded uu___9);
-                                FStar_Compiler_List.for_all
-                                  (fun d ->
-                                     ty_strictly_positive_in_datacon_of_applied_inductive
-                                       env mutuals d ilid us args
-                                       num_uniform_params unfolded) idatas))))
-and (ty_strictly_positive_in_datacon_of_applied_inductive :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.universes ->
-            FStar_Syntax_Syntax.args ->
-              Prims.int -> unfolded_memo_t -> Prims.bool)
-  =
-  fun env ->
-    fun mutuals ->
-      fun dlid ->
-        fun ilid ->
-          fun us ->
-            fun args ->
-              fun num_ibs ->
-                fun unfolded ->
-                  debug_positivity env
-                    (fun uu___1 ->
-                       let uu___2 = string_of_lids mutuals in
-                       let uu___3 = FStar_Ident.string_of_lid dlid in
-                       let uu___4 = FStar_Ident.string_of_lid ilid in
-                       FStar_Compiler_Util.format3
-                         "Checking positivity of %s in data constructor %s : %s"
-                         uu___2 uu___3 uu___4);
-                  (let dt =
-                     let uu___1 =
-                       FStar_TypeChecker_Env.try_lookup_and_inst_lid env us
-                         dlid in
-                     match uu___1 with
-                     | FStar_Pervasives_Native.Some (t, uu___2) -> t
-                     | FStar_Pervasives_Native.None ->
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 = FStar_Ident.string_of_lid dlid in
-                             FStar_Compiler_Util.format1
-                               "Data constructor %s not found when checking positivity"
-                               uu___4 in
-                           (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                             uu___3) in
-                         let uu___3 = FStar_Ident.range_of_lid dlid in
-                         FStar_Errors.raise_error uu___2 uu___3 in
-                   debug_positivity env
-                     (fun uu___2 ->
-                        let uu___3 = FStar_Syntax_Print.term_to_string dt in
-                        let uu___4 = FStar_Syntax_Print.args_to_string args in
-                        FStar_Compiler_Util.format3
-                          "Checking positivity in the data constructor type: %s\n\tnum_ibs=%s, args=%s,"
-                          uu___3 (Prims.string_of_int num_ibs) uu___4);
-                   (let uu___2 = FStar_Compiler_List.splitAt num_ibs args in
-                    match uu___2 with
-                    | (args1, rest) ->
-                        let applied_dt = apply_constr_arrow dlid dt args1 in
-                        (debug_positivity env
-                           (fun uu___4 ->
-                              let uu___5 = FStar_Ident.string_of_lid dlid in
-                              let uu___6 =
-                                FStar_Syntax_Print.args_to_string args1 in
-                              let uu___7 =
-                                FStar_Syntax_Print.term_to_string applied_dt in
-                              FStar_Compiler_Util.format3
-                                "Applied data constructor type: %s %s : %s"
-                                uu___5 uu___6 uu___7);
-                         (let uu___4 =
-                            FStar_Syntax_Util.arrow_formals applied_dt in
-                          match uu___4 with
-                          | (fields, t) ->
-                              (check_no_index_occurrences_in_arities env
-                                 mutuals t;
-                               (let rec strictly_positive_in_all_fields env1
-                                  fields1 =
-                                  match fields1 with
-                                  | [] -> true
-                                  | f::fields2 ->
-                                      (debug_positivity env1
-                                         (fun uu___7 ->
-                                            let uu___8 =
-                                              FStar_Syntax_Print.bv_to_string
-                                                f.FStar_Syntax_Syntax.binder_bv in
-                                            let uu___9 =
-                                              FStar_Syntax_Print.term_to_string
-                                                (f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                            FStar_Compiler_Util.format2
-                                              "Checking field %s : %s for indexes and positivity"
-                                              uu___8 uu___9);
-                                       check_no_index_occurrences_in_arities
-                                         env1 mutuals
-                                         (f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort;
-                                       (let uu___8 =
-                                          ty_strictly_positive_in_type env1
-                                            mutuals
-                                            (f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                            unfolded in
-                                        if uu___8
-                                        then
-                                          let env2 =
-                                            FStar_TypeChecker_Env.push_binders
-                                              env1 [f] in
-                                          strictly_positive_in_all_fields
-                                            env2 fields2
-                                        else false)) in
-                                strictly_positive_in_all_fields env fields))))))
-let (name_strictly_positive_in_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.bv -> FStar_Syntax_Syntax.term -> Prims.bool)
-  =
-  fun env ->
-    fun bv ->
-      fun t ->
-        let fv_lid =
-          let uu___ =
-            let uu___1 =
-              FStar_Ident.string_of_id bv.FStar_Syntax_Syntax.ppname in
-            FStar_Ident.lid_of_str uu___1 in
-          let uu___1 = FStar_Syntax_Syntax.range_of_bv bv in
-          FStar_Ident.set_lid_range uu___ uu___1 in
-        let fv = FStar_Syntax_Syntax.tconst fv_lid in
-        let t1 = FStar_Syntax_Subst.subst [FStar_Syntax_Syntax.NT (bv, fv)] t in
-        let uu___ = FStar_Compiler_Util.mk_ref [] in
-        ty_strictly_positive_in_type env [fv_lid] t1 uu___
-let (ty_strictly_positive_in_datacon_decl :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.binders ->
-          FStar_Syntax_Syntax.universes -> unfolded_memo_t -> Prims.bool)
-  =
-  fun env ->
-    fun mutuals ->
-      fun dlid ->
-        fun ty_bs ->
-          fun us ->
-            fun unfolded ->
-              let dt =
-                let uu___ =
-                  FStar_TypeChecker_Env.try_lookup_and_inst_lid env us dlid in
-                match uu___ with
-                | FStar_Pervasives_Native.Some (t, uu___1) -> t
-                | FStar_Pervasives_Native.None ->
-                    let uu___1 =
-                      let uu___2 =
-                        let uu___3 = FStar_Ident.string_of_lid dlid in
-                        FStar_Compiler_Util.format1
-                          "Error looking up data constructor %s when checking positivity"
-                          uu___3 in
-                      (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                        uu___2) in
-                    let uu___2 = FStar_Ident.range_of_lid dlid in
-                    FStar_Errors.raise_error uu___1 uu___2 in
-              debug_positivity env
-                (fun uu___1 ->
-                   let uu___2 = FStar_Syntax_Print.term_to_string dt in
-                   Prims.op_Hat "Checking data constructor type: " uu___2);
-              (let uu___1 = FStar_Syntax_Util.args_of_binders ty_bs in
-               match uu___1 with
-               | (ty_bs1, args) ->
-                   let dt1 = apply_constr_arrow dlid dt args in
-                   let uu___2 = FStar_Syntax_Util.arrow_formals dt1 in
-                   (match uu___2 with
-                    | (fields, return_type) ->
-                        (check_no_index_occurrences_in_arities env mutuals
-                           return_type;
-                         (let check_annotated_binders_are_strictly_positive_in_field
-                            f =
-                            let incorrectly_annotated_binder =
-                              FStar_Compiler_List.tryFind
-                                (fun b ->
-                                   let uu___4 =
-                                     FStar_Syntax_Util.has_attribute
-                                       b.FStar_Syntax_Syntax.binder_attrs
-                                       FStar_Parser_Const.binder_strictly_positive_attr in
-                                   if uu___4
-                                   then
-                                     let uu___5 =
-                                       name_strictly_positive_in_type env
-                                         b.FStar_Syntax_Syntax.binder_bv
-                                         (f.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                     Prims.op_Negation uu___5
-                                   else false) ty_bs1 in
-                            match incorrectly_annotated_binder with
-                            | FStar_Pervasives_Native.None -> ()
-                            | FStar_Pervasives_Native.Some b ->
-                                let uu___4 =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      FStar_Syntax_Print.binder_to_string b in
-                                    FStar_Compiler_Util.format1
-                                      "Binder %s is marked strictly positive, but its use in the definition is not"
-                                      uu___6 in
-                                  (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                                    uu___5) in
-                                let uu___5 =
-                                  FStar_Syntax_Syntax.range_of_bv
-                                    b.FStar_Syntax_Syntax.binder_bv in
-                                FStar_Errors.raise_error uu___4 uu___5 in
-                          let rec check_all_fields env1 fields1 =
-                            match fields1 with
-                            | [] -> true
-                            | field::fields2 ->
-                                (check_annotated_binders_are_strictly_positive_in_field
-                                   field;
-                                 (let uu___5 =
-                                    let uu___6 =
-                                      ty_strictly_positive_in_type env1
-                                        mutuals
-                                        (field.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                        unfolded in
-                                    Prims.op_Negation uu___6 in
-                                  if uu___5
-                                  then false
-                                  else
-                                    (let env2 =
-                                       FStar_TypeChecker_Env.push_binders
-                                         env1 [field] in
-                                     check_all_fields env2 fields2))) in
-                          check_all_fields env fields))))
-let (check_strict_positivity :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident Prims.list -> FStar_Syntax_Syntax.sigelt -> Prims.bool)
-  =
-  fun env ->
-    fun mutuals ->
-      fun ty ->
-        let unfolded_inductives = FStar_Compiler_Util.mk_ref [] in
-        let uu___ = open_sig_inductive_typ env ty in
-        match uu___ with
-        | (env1, (ty_lid, ty_us, ty_params)) ->
-            let mutuals1 =
-              FStar_Compiler_List.filter
-                (fun m ->
-                   let uu___1 = FStar_TypeChecker_Env.is_datacon env1 m in
-                   Prims.op_Negation uu___1) mutuals in
-            let mutuals2 =
-              let uu___1 =
-                FStar_Compiler_List.existsML (FStar_Ident.lid_equals ty_lid)
-                  mutuals1 in
-              if uu___1 then mutuals1 else ty_lid :: mutuals1 in
-            let datacons =
-              let uu___1 = FStar_TypeChecker_Env.datacons_of_typ env1 ty_lid in
-              FStar_Pervasives_Native.snd uu___1 in
-            let us =
-              FStar_Compiler_List.map
-                (fun uu___1 -> FStar_Syntax_Syntax.U_name uu___1) ty_us in
-            FStar_Compiler_List.for_all
-              (fun d ->
-                 ty_strictly_positive_in_datacon_decl env1 mutuals2 d
-                   ty_params us unfolded_inductives) datacons
-let (check_exn_strict_positivity :
-  FStar_TypeChecker_Env.env -> FStar_Ident.lident -> Prims.bool) =
-  fun env ->
-    fun data_ctor_lid ->
-      let unfolded_inductives = FStar_Compiler_Util.mk_ref [] in
-      ty_strictly_positive_in_datacon_decl env [FStar_Parser_Const.exn_lid]
-        data_ctor_lid [] [] unfolded_inductives
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Rel.ml b/src/ocaml-output/FStar_TypeChecker_Rel.ml
deleted file mode 100644
index 63263f98ffe..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Rel.ml
+++ /dev/null
@@ -1,14921 +0,0 @@
-open Prims
-type match_result =
-  | MisMatch of (FStar_Syntax_Syntax.delta_depth
-  FStar_Pervasives_Native.option * FStar_Syntax_Syntax.delta_depth
-  FStar_Pervasives_Native.option) 
-  | HeadMatch of Prims.bool 
-  | FullMatch 
-let (uu___is_MisMatch : match_result -> Prims.bool) =
-  fun projectee ->
-    match projectee with | MisMatch _0 -> true | uu___ -> false
-let (__proj__MisMatch__item___0 :
-  match_result ->
-    (FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option *
-      FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option))
-  = fun projectee -> match projectee with | MisMatch _0 -> _0
-let (uu___is_HeadMatch : match_result -> Prims.bool) =
-  fun projectee ->
-    match projectee with | HeadMatch _0 -> true | uu___ -> false
-let (__proj__HeadMatch__item___0 : match_result -> Prims.bool) =
-  fun projectee -> match projectee with | HeadMatch _0 -> _0
-let (uu___is_FullMatch : match_result -> Prims.bool) =
-  fun projectee -> match projectee with | FullMatch -> true | uu___ -> false
-type implicit_checking_status =
-  | Implicit_unresolved 
-  | Implicit_checking_defers_univ_constraint 
-  | Implicit_has_typing_guard of (FStar_Syntax_Syntax.term *
-  FStar_Syntax_Syntax.typ) 
-let (uu___is_Implicit_unresolved : implicit_checking_status -> Prims.bool) =
-  fun projectee ->
-    match projectee with | Implicit_unresolved -> true | uu___ -> false
-let (uu___is_Implicit_checking_defers_univ_constraint :
-  implicit_checking_status -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Implicit_checking_defers_univ_constraint -> true
-    | uu___ -> false
-let (uu___is_Implicit_has_typing_guard :
-  implicit_checking_status -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | Implicit_has_typing_guard _0 -> true
-    | uu___ -> false
-let (__proj__Implicit_has_typing_guard__item___0 :
-  implicit_checking_status ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.typ))
-  =
-  fun projectee -> match projectee with | Implicit_has_typing_guard _0 -> _0
-type tagged_implicits =
-  (FStar_TypeChecker_Common.implicit * implicit_checking_status) Prims.list
-let (is_base_type :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.typ -> Prims.bool) =
-  fun env ->
-    fun typ ->
-      let t = FStar_TypeChecker_Normalize.unfold_whnf env typ in
-      let uu___ = FStar_Syntax_Util.head_and_args t in
-      match uu___ with
-      | (head, args) ->
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Util.un_uinst head in
-              FStar_Syntax_Util.unascribe uu___3 in
-            uu___2.FStar_Syntax_Syntax.n in
-          (match uu___1 with
-           | FStar_Syntax_Syntax.Tm_name uu___2 -> true
-           | FStar_Syntax_Syntax.Tm_fvar uu___2 -> true
-           | FStar_Syntax_Syntax.Tm_type uu___2 -> true
-           | uu___2 -> false)
-let (print_ctx_uvar : FStar_Syntax_Syntax.ctx_uvar -> Prims.string) =
-  fun ctx_uvar -> FStar_Syntax_Print.ctx_uvar_to_string ctx_uvar
-let (binders_as_bv_set :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.bv FStar_Compiler_Util.set)
-  =
-  fun bs ->
-    let uu___ =
-      FStar_Compiler_List.map (fun b -> b.FStar_Syntax_Syntax.binder_bv) bs in
-    FStar_Compiler_Util.as_set uu___ FStar_Syntax_Syntax.order_bv
-type lstring = Prims.string FStar_Thunk.t
-let (mklstr : (unit -> Prims.string) -> Prims.string FStar_Thunk.thunk) =
-  fun f ->
-    let uf = FStar_Syntax_Unionfind.get () in
-    FStar_Thunk.mk
-      (fun uu___ ->
-         let tx = FStar_Syntax_Unionfind.new_transaction () in
-         FStar_Syntax_Unionfind.set uf;
-         (let r = f () in FStar_Syntax_Unionfind.rollback tx; r))
-type uvi =
-  | TERM of (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.term) 
-  | UNIV of (FStar_Syntax_Syntax.universe_uvar *
-  FStar_Syntax_Syntax.universe) 
-let (uu___is_TERM : uvi -> Prims.bool) =
-  fun projectee -> match projectee with | TERM _0 -> true | uu___ -> false
-let (__proj__TERM__item___0 :
-  uvi -> (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.term)) =
-  fun projectee -> match projectee with | TERM _0 -> _0
-let (uu___is_UNIV : uvi -> Prims.bool) =
-  fun projectee -> match projectee with | UNIV _0 -> true | uu___ -> false
-let (__proj__UNIV__item___0 :
-  uvi -> (FStar_Syntax_Syntax.universe_uvar * FStar_Syntax_Syntax.universe))
-  = fun projectee -> match projectee with | UNIV _0 -> _0
-type defer_ok_t =
-  | NoDefer 
-  | DeferAny 
-  | DeferFlexFlexOnly 
-let (uu___is_NoDefer : defer_ok_t -> Prims.bool) =
-  fun projectee -> match projectee with | NoDefer -> true | uu___ -> false
-let (uu___is_DeferAny : defer_ok_t -> Prims.bool) =
-  fun projectee -> match projectee with | DeferAny -> true | uu___ -> false
-let (uu___is_DeferFlexFlexOnly : defer_ok_t -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DeferFlexFlexOnly -> true | uu___ -> false
-let (string_of_defer_ok : defer_ok_t -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | NoDefer -> "NoDefer"
-    | DeferAny -> "DeferAny"
-    | DeferFlexFlexOnly -> "DeferFlexFlexOnly"
-type worklist =
-  {
-  attempting: FStar_TypeChecker_Common.probs ;
-  wl_deferred:
-    (Prims.int * FStar_TypeChecker_Common.deferred_reason * lstring *
-      FStar_TypeChecker_Common.prob) Prims.list
-    ;
-  wl_deferred_to_tac:
-    (Prims.int * FStar_TypeChecker_Common.deferred_reason * lstring *
-      FStar_TypeChecker_Common.prob) Prims.list
-    ;
-  ctr: Prims.int ;
-  defer_ok: defer_ok_t ;
-  smt_ok: Prims.bool ;
-  umax_heuristic_ok: Prims.bool ;
-  tcenv: FStar_TypeChecker_Env.env ;
-  wl_implicits: FStar_TypeChecker_Common.implicits ;
-  repr_subcomp_allowed: Prims.bool }
-let (__proj__Mkworklist__item__attempting :
-  worklist -> FStar_TypeChecker_Common.probs) =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        attempting
-let (__proj__Mkworklist__item__wl_deferred :
-  worklist ->
-    (Prims.int * FStar_TypeChecker_Common.deferred_reason * lstring *
-      FStar_TypeChecker_Common.prob) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        wl_deferred
-let (__proj__Mkworklist__item__wl_deferred_to_tac :
-  worklist ->
-    (Prims.int * FStar_TypeChecker_Common.deferred_reason * lstring *
-      FStar_TypeChecker_Common.prob) Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        wl_deferred_to_tac
-let (__proj__Mkworklist__item__ctr : worklist -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        ctr
-let (__proj__Mkworklist__item__defer_ok : worklist -> defer_ok_t) =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        defer_ok
-let (__proj__Mkworklist__item__smt_ok : worklist -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        smt_ok
-let (__proj__Mkworklist__item__umax_heuristic_ok : worklist -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        umax_heuristic_ok
-let (__proj__Mkworklist__item__tcenv : worklist -> FStar_TypeChecker_Env.env)
-  =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        tcenv
-let (__proj__Mkworklist__item__wl_implicits :
-  worklist -> FStar_TypeChecker_Common.implicits) =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        wl_implicits
-let (__proj__Mkworklist__item__repr_subcomp_allowed : worklist -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { attempting; wl_deferred; wl_deferred_to_tac; ctr; defer_ok; smt_ok;
-        umax_heuristic_ok; tcenv; wl_implicits; repr_subcomp_allowed;_} ->
-        repr_subcomp_allowed
-let (debug : worklist -> FStar_Options.debug_level_t -> Prims.bool) =
-  fun wl -> fun lvl -> FStar_TypeChecker_Env.debug wl.tcenv lvl
-let (as_deferred :
-  (Prims.int * FStar_TypeChecker_Common.deferred_reason * lstring *
-    FStar_TypeChecker_Common.prob) Prims.list ->
-    FStar_TypeChecker_Common.deferred)
-  =
-  fun wl_def ->
-    FStar_Compiler_List.map
-      (fun uu___ ->
-         match uu___ with
-         | (uu___1, reason, m, p) ->
-             let uu___2 = FStar_Thunk.force m in (reason, uu___2, p)) wl_def
-let (as_wl_deferred :
-  worklist ->
-    FStar_TypeChecker_Common.deferred ->
-      (Prims.int * FStar_TypeChecker_Common.deferred_reason * lstring *
-        FStar_TypeChecker_Common.prob) Prims.list)
-  =
-  fun wl ->
-    fun d ->
-      FStar_Compiler_List.map
-        (fun uu___ ->
-           match uu___ with
-           | (reason, m, p) ->
-               let uu___1 = FStar_Thunk.mkv m in
-               ((wl.ctr), reason, uu___1, p)) d
-let (new_uvar :
-  Prims.string ->
-    worklist ->
-      FStar_Compiler_Range.range ->
-        FStar_Syntax_Syntax.binding Prims.list ->
-          FStar_Syntax_Syntax.binder Prims.list ->
-            FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-              FStar_Syntax_Syntax.should_check_uvar ->
-                FStar_Syntax_Syntax.ctx_uvar_meta_t
-                  FStar_Pervasives_Native.option ->
-                  (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.term *
-                    worklist))
-  =
-  fun reason ->
-    fun wl ->
-      fun r ->
-        fun gamma ->
-          fun binders ->
-            fun k ->
-              fun should_check ->
-                fun meta ->
-                  let decoration =
-                    {
-                      FStar_Syntax_Syntax.uvar_decoration_typ = k;
-                      FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on
-                        = [];
-                      FStar_Syntax_Syntax.uvar_decoration_should_check =
-                        should_check
-                    } in
-                  let ctx_uvar =
-                    let uu___ = FStar_Syntax_Unionfind.fresh decoration r in
-                    {
-                      FStar_Syntax_Syntax.ctx_uvar_head = uu___;
-                      FStar_Syntax_Syntax.ctx_uvar_gamma = gamma;
-                      FStar_Syntax_Syntax.ctx_uvar_binders = binders;
-                      FStar_Syntax_Syntax.ctx_uvar_reason = reason;
-                      FStar_Syntax_Syntax.ctx_uvar_range = r;
-                      FStar_Syntax_Syntax.ctx_uvar_meta = meta
-                    } in
-                  FStar_TypeChecker_Common.check_uvar_ctx_invariant reason r
-                    true gamma binders;
-                  (let t =
-                     FStar_Syntax_Syntax.mk
-                       (FStar_Syntax_Syntax.Tm_uvar
-                          (ctx_uvar, ([], FStar_Syntax_Syntax.NoUseRange))) r in
-                   let imp =
-                     {
-                       FStar_TypeChecker_Common.imp_reason = reason;
-                       FStar_TypeChecker_Common.imp_uvar = ctx_uvar;
-                       FStar_TypeChecker_Common.imp_tm = t;
-                       FStar_TypeChecker_Common.imp_range = r
-                     } in
-                   (let uu___2 =
-                      debug wl (FStar_Options.Other "ImplicitTrace") in
-                    if uu___2
-                    then
-                      let uu___3 =
-                        FStar_Syntax_Print.uvar_to_string
-                          ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_head in
-                      FStar_Compiler_Util.print1
-                        "Just created uvar (Rel) {%s}\n" uu___3
-                    else ());
-                   (ctx_uvar, t,
-                     {
-                       attempting = (wl.attempting);
-                       wl_deferred = (wl.wl_deferred);
-                       wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-                       ctr = (wl.ctr);
-                       defer_ok = (wl.defer_ok);
-                       smt_ok = (wl.smt_ok);
-                       umax_heuristic_ok = (wl.umax_heuristic_ok);
-                       tcenv = (wl.tcenv);
-                       wl_implicits = (imp :: (wl.wl_implicits));
-                       repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-                     }))
-let (copy_uvar :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        worklist ->
-          (FStar_Syntax_Syntax.ctx_uvar * FStar_Syntax_Syntax.term *
-            worklist))
-  =
-  fun u ->
-    fun bs ->
-      fun t ->
-        fun wl ->
-          let env =
-            let uu___ = wl.tcenv in
-            {
-              FStar_TypeChecker_Env.solver =
-                (uu___.FStar_TypeChecker_Env.solver);
-              FStar_TypeChecker_Env.range =
-                (uu___.FStar_TypeChecker_Env.range);
-              FStar_TypeChecker_Env.curmodule =
-                (uu___.FStar_TypeChecker_Env.curmodule);
-              FStar_TypeChecker_Env.gamma =
-                (u.FStar_Syntax_Syntax.ctx_uvar_gamma);
-              FStar_TypeChecker_Env.gamma_sig =
-                (uu___.FStar_TypeChecker_Env.gamma_sig);
-              FStar_TypeChecker_Env.gamma_cache =
-                (uu___.FStar_TypeChecker_Env.gamma_cache);
-              FStar_TypeChecker_Env.modules =
-                (uu___.FStar_TypeChecker_Env.modules);
-              FStar_TypeChecker_Env.expected_typ =
-                (uu___.FStar_TypeChecker_Env.expected_typ);
-              FStar_TypeChecker_Env.sigtab =
-                (uu___.FStar_TypeChecker_Env.sigtab);
-              FStar_TypeChecker_Env.attrtab =
-                (uu___.FStar_TypeChecker_Env.attrtab);
-              FStar_TypeChecker_Env.instantiate_imp =
-                (uu___.FStar_TypeChecker_Env.instantiate_imp);
-              FStar_TypeChecker_Env.effects =
-                (uu___.FStar_TypeChecker_Env.effects);
-              FStar_TypeChecker_Env.generalize =
-                (uu___.FStar_TypeChecker_Env.generalize);
-              FStar_TypeChecker_Env.letrecs =
-                (uu___.FStar_TypeChecker_Env.letrecs);
-              FStar_TypeChecker_Env.top_level =
-                (uu___.FStar_TypeChecker_Env.top_level);
-              FStar_TypeChecker_Env.check_uvars =
-                (uu___.FStar_TypeChecker_Env.check_uvars);
-              FStar_TypeChecker_Env.use_eq_strict =
-                (uu___.FStar_TypeChecker_Env.use_eq_strict);
-              FStar_TypeChecker_Env.is_iface =
-                (uu___.FStar_TypeChecker_Env.is_iface);
-              FStar_TypeChecker_Env.admit =
-                (uu___.FStar_TypeChecker_Env.admit);
-              FStar_TypeChecker_Env.lax = (uu___.FStar_TypeChecker_Env.lax);
-              FStar_TypeChecker_Env.lax_universes =
-                (uu___.FStar_TypeChecker_Env.lax_universes);
-              FStar_TypeChecker_Env.phase1 =
-                (uu___.FStar_TypeChecker_Env.phase1);
-              FStar_TypeChecker_Env.failhard =
-                (uu___.FStar_TypeChecker_Env.failhard);
-              FStar_TypeChecker_Env.nosynth =
-                (uu___.FStar_TypeChecker_Env.nosynth);
-              FStar_TypeChecker_Env.uvar_subtyping =
-                (uu___.FStar_TypeChecker_Env.uvar_subtyping);
-              FStar_TypeChecker_Env.tc_term =
-                (uu___.FStar_TypeChecker_Env.tc_term);
-              FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                (uu___.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-              FStar_TypeChecker_Env.universe_of =
-                (uu___.FStar_TypeChecker_Env.universe_of);
-              FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                (uu___.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-              FStar_TypeChecker_Env.teq_nosmt_force =
-                (uu___.FStar_TypeChecker_Env.teq_nosmt_force);
-              FStar_TypeChecker_Env.subtype_nosmt_force =
-                (uu___.FStar_TypeChecker_Env.subtype_nosmt_force);
-              FStar_TypeChecker_Env.qtbl_name_and_index =
-                (uu___.FStar_TypeChecker_Env.qtbl_name_and_index);
-              FStar_TypeChecker_Env.normalized_eff_names =
-                (uu___.FStar_TypeChecker_Env.normalized_eff_names);
-              FStar_TypeChecker_Env.fv_delta_depths =
-                (uu___.FStar_TypeChecker_Env.fv_delta_depths);
-              FStar_TypeChecker_Env.proof_ns =
-                (uu___.FStar_TypeChecker_Env.proof_ns);
-              FStar_TypeChecker_Env.synth_hook =
-                (uu___.FStar_TypeChecker_Env.synth_hook);
-              FStar_TypeChecker_Env.try_solve_implicits_hook =
-                (uu___.FStar_TypeChecker_Env.try_solve_implicits_hook);
-              FStar_TypeChecker_Env.splice =
-                (uu___.FStar_TypeChecker_Env.splice);
-              FStar_TypeChecker_Env.mpreprocess =
-                (uu___.FStar_TypeChecker_Env.mpreprocess);
-              FStar_TypeChecker_Env.postprocess =
-                (uu___.FStar_TypeChecker_Env.postprocess);
-              FStar_TypeChecker_Env.identifier_info =
-                (uu___.FStar_TypeChecker_Env.identifier_info);
-              FStar_TypeChecker_Env.tc_hooks =
-                (uu___.FStar_TypeChecker_Env.tc_hooks);
-              FStar_TypeChecker_Env.dsenv =
-                (uu___.FStar_TypeChecker_Env.dsenv);
-              FStar_TypeChecker_Env.nbe = (uu___.FStar_TypeChecker_Env.nbe);
-              FStar_TypeChecker_Env.strict_args_tab =
-                (uu___.FStar_TypeChecker_Env.strict_args_tab);
-              FStar_TypeChecker_Env.erasable_types_tab =
-                (uu___.FStar_TypeChecker_Env.erasable_types_tab);
-              FStar_TypeChecker_Env.enable_defer_to_tac =
-                (uu___.FStar_TypeChecker_Env.enable_defer_to_tac);
-              FStar_TypeChecker_Env.unif_allow_ref_guards =
-                (uu___.FStar_TypeChecker_Env.unif_allow_ref_guards);
-              FStar_TypeChecker_Env.erase_erasable_args =
-                (uu___.FStar_TypeChecker_Env.erase_erasable_args);
-              FStar_TypeChecker_Env.core_check =
-                (uu___.FStar_TypeChecker_Env.core_check)
-            } in
-          let env1 = FStar_TypeChecker_Env.push_binders env bs in
-          let uu___ = FStar_TypeChecker_Env.all_binders env1 in
-          let uu___1 = FStar_Syntax_Util.ctx_uvar_should_check u in
-          new_uvar
-            (Prims.op_Hat "copy:" u.FStar_Syntax_Syntax.ctx_uvar_reason) wl
-            u.FStar_Syntax_Syntax.ctx_uvar_range
-            env1.FStar_TypeChecker_Env.gamma uu___ t uu___1
-            u.FStar_Syntax_Syntax.ctx_uvar_meta
-type solution =
-  | Success of (FStar_TypeChecker_Common.deferred *
-  FStar_TypeChecker_Common.deferred * FStar_TypeChecker_Common.implicits) 
-  | Failed of (FStar_TypeChecker_Common.prob * lstring) 
-let (uu___is_Success : solution -> Prims.bool) =
-  fun projectee -> match projectee with | Success _0 -> true | uu___ -> false
-let (__proj__Success__item___0 :
-  solution ->
-    (FStar_TypeChecker_Common.deferred * FStar_TypeChecker_Common.deferred *
-      FStar_TypeChecker_Common.implicits))
-  = fun projectee -> match projectee with | Success _0 -> _0
-let (uu___is_Failed : solution -> Prims.bool) =
-  fun projectee -> match projectee with | Failed _0 -> true | uu___ -> false
-let (__proj__Failed__item___0 :
-  solution -> (FStar_TypeChecker_Common.prob * lstring)) =
-  fun projectee -> match projectee with | Failed _0 -> _0
-let (extend_wl :
-  worklist ->
-    FStar_TypeChecker_Common.deferred ->
-      FStar_TypeChecker_Common.deferred ->
-        FStar_TypeChecker_Common.implicits -> worklist)
-  =
-  fun wl ->
-    fun defers ->
-      fun defer_to_tac ->
-        fun imps ->
-          let uu___ =
-            let uu___1 = as_wl_deferred wl defers in
-            FStar_Compiler_List.op_At wl.wl_deferred uu___1 in
-          let uu___1 =
-            let uu___2 = as_wl_deferred wl defer_to_tac in
-            FStar_Compiler_List.op_At wl.wl_deferred_to_tac uu___2 in
-          {
-            attempting = (wl.attempting);
-            wl_deferred = uu___;
-            wl_deferred_to_tac = uu___1;
-            ctr = (wl.ctr);
-            defer_ok = (wl.defer_ok);
-            smt_ok = (wl.smt_ok);
-            umax_heuristic_ok = (wl.umax_heuristic_ok);
-            tcenv = (wl.tcenv);
-            wl_implicits = (FStar_Compiler_List.op_At wl.wl_implicits imps);
-            repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-          }
-type variance =
-  | COVARIANT 
-  | CONTRAVARIANT 
-  | INVARIANT 
-let (uu___is_COVARIANT : variance -> Prims.bool) =
-  fun projectee -> match projectee with | COVARIANT -> true | uu___ -> false
-let (uu___is_CONTRAVARIANT : variance -> Prims.bool) =
-  fun projectee ->
-    match projectee with | CONTRAVARIANT -> true | uu___ -> false
-let (uu___is_INVARIANT : variance -> Prims.bool) =
-  fun projectee -> match projectee with | INVARIANT -> true | uu___ -> false
-type tprob = FStar_Syntax_Syntax.typ FStar_TypeChecker_Common.problem
-type cprob = FStar_Syntax_Syntax.comp FStar_TypeChecker_Common.problem
-type 'a problem_t = 'a FStar_TypeChecker_Common.problem
-let (invert_rel :
-  FStar_TypeChecker_Common.rel -> FStar_TypeChecker_Common.rel) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.EQ -> FStar_TypeChecker_Common.EQ
-    | FStar_TypeChecker_Common.SUB -> FStar_TypeChecker_Common.SUBINV
-    | FStar_TypeChecker_Common.SUBINV -> FStar_TypeChecker_Common.SUB
-let invert :
-  'uuuuu .
-    'uuuuu FStar_TypeChecker_Common.problem ->
-      'uuuuu FStar_TypeChecker_Common.problem
-  =
-  fun p ->
-    {
-      FStar_TypeChecker_Common.pid = (p.FStar_TypeChecker_Common.pid);
-      FStar_TypeChecker_Common.lhs = (p.FStar_TypeChecker_Common.rhs);
-      FStar_TypeChecker_Common.relation =
-        (invert_rel p.FStar_TypeChecker_Common.relation);
-      FStar_TypeChecker_Common.rhs = (p.FStar_TypeChecker_Common.lhs);
-      FStar_TypeChecker_Common.element = (p.FStar_TypeChecker_Common.element);
-      FStar_TypeChecker_Common.logical_guard =
-        (p.FStar_TypeChecker_Common.logical_guard);
-      FStar_TypeChecker_Common.logical_guard_uvar =
-        (p.FStar_TypeChecker_Common.logical_guard_uvar);
-      FStar_TypeChecker_Common.reason = (p.FStar_TypeChecker_Common.reason);
-      FStar_TypeChecker_Common.loc = (p.FStar_TypeChecker_Common.loc);
-      FStar_TypeChecker_Common.rank = (p.FStar_TypeChecker_Common.rank)
-    }
-let maybe_invert :
-  'uuuuu .
-    'uuuuu FStar_TypeChecker_Common.problem ->
-      'uuuuu FStar_TypeChecker_Common.problem
-  =
-  fun p ->
-    if p.FStar_TypeChecker_Common.relation = FStar_TypeChecker_Common.SUBINV
-    then invert p
-    else p
-let (maybe_invert_p :
-  FStar_TypeChecker_Common.prob -> FStar_TypeChecker_Common.prob) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p ->
-        FStar_Compiler_Effect.op_Bar_Greater (maybe_invert p)
-          (fun uu___1 -> FStar_TypeChecker_Common.TProb uu___1)
-    | FStar_TypeChecker_Common.CProb p ->
-        FStar_Compiler_Effect.op_Bar_Greater (maybe_invert p)
-          (fun uu___1 -> FStar_TypeChecker_Common.CProb uu___1)
-let (make_prob_eq :
-  FStar_TypeChecker_Common.prob -> FStar_TypeChecker_Common.prob) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p ->
-        FStar_TypeChecker_Common.TProb
-          {
-            FStar_TypeChecker_Common.pid = (p.FStar_TypeChecker_Common.pid);
-            FStar_TypeChecker_Common.lhs = (p.FStar_TypeChecker_Common.lhs);
-            FStar_TypeChecker_Common.relation = FStar_TypeChecker_Common.EQ;
-            FStar_TypeChecker_Common.rhs = (p.FStar_TypeChecker_Common.rhs);
-            FStar_TypeChecker_Common.element =
-              (p.FStar_TypeChecker_Common.element);
-            FStar_TypeChecker_Common.logical_guard =
-              (p.FStar_TypeChecker_Common.logical_guard);
-            FStar_TypeChecker_Common.logical_guard_uvar =
-              (p.FStar_TypeChecker_Common.logical_guard_uvar);
-            FStar_TypeChecker_Common.reason =
-              (p.FStar_TypeChecker_Common.reason);
-            FStar_TypeChecker_Common.loc = (p.FStar_TypeChecker_Common.loc);
-            FStar_TypeChecker_Common.rank = (p.FStar_TypeChecker_Common.rank)
-          }
-    | FStar_TypeChecker_Common.CProb p ->
-        FStar_TypeChecker_Common.CProb
-          {
-            FStar_TypeChecker_Common.pid = (p.FStar_TypeChecker_Common.pid);
-            FStar_TypeChecker_Common.lhs = (p.FStar_TypeChecker_Common.lhs);
-            FStar_TypeChecker_Common.relation = FStar_TypeChecker_Common.EQ;
-            FStar_TypeChecker_Common.rhs = (p.FStar_TypeChecker_Common.rhs);
-            FStar_TypeChecker_Common.element =
-              (p.FStar_TypeChecker_Common.element);
-            FStar_TypeChecker_Common.logical_guard =
-              (p.FStar_TypeChecker_Common.logical_guard);
-            FStar_TypeChecker_Common.logical_guard_uvar =
-              (p.FStar_TypeChecker_Common.logical_guard_uvar);
-            FStar_TypeChecker_Common.reason =
-              (p.FStar_TypeChecker_Common.reason);
-            FStar_TypeChecker_Common.loc = (p.FStar_TypeChecker_Common.loc);
-            FStar_TypeChecker_Common.rank = (p.FStar_TypeChecker_Common.rank)
-          }
-let (vary_rel :
-  FStar_TypeChecker_Common.rel -> variance -> FStar_TypeChecker_Common.rel) =
-  fun rel ->
-    fun uu___ ->
-      match uu___ with
-      | INVARIANT -> FStar_TypeChecker_Common.EQ
-      | CONTRAVARIANT -> invert_rel rel
-      | COVARIANT -> rel
-let (p_pid : FStar_TypeChecker_Common.prob -> Prims.int) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p -> p.FStar_TypeChecker_Common.pid
-    | FStar_TypeChecker_Common.CProb p -> p.FStar_TypeChecker_Common.pid
-let (p_rel : FStar_TypeChecker_Common.prob -> FStar_TypeChecker_Common.rel) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p -> p.FStar_TypeChecker_Common.relation
-    | FStar_TypeChecker_Common.CProb p -> p.FStar_TypeChecker_Common.relation
-let (p_reason : FStar_TypeChecker_Common.prob -> Prims.string Prims.list) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p -> p.FStar_TypeChecker_Common.reason
-    | FStar_TypeChecker_Common.CProb p -> p.FStar_TypeChecker_Common.reason
-let (p_loc : FStar_TypeChecker_Common.prob -> FStar_Compiler_Range.range) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p -> p.FStar_TypeChecker_Common.loc
-    | FStar_TypeChecker_Common.CProb p -> p.FStar_TypeChecker_Common.loc
-let (p_element :
-  FStar_TypeChecker_Common.prob ->
-    FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p -> p.FStar_TypeChecker_Common.element
-    | FStar_TypeChecker_Common.CProb p -> p.FStar_TypeChecker_Common.element
-let (p_guard : FStar_TypeChecker_Common.prob -> FStar_Syntax_Syntax.term) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p ->
-        p.FStar_TypeChecker_Common.logical_guard
-    | FStar_TypeChecker_Common.CProb p ->
-        p.FStar_TypeChecker_Common.logical_guard
-let (p_scope :
-  FStar_TypeChecker_Common.prob -> FStar_Syntax_Syntax.binder Prims.list) =
-  fun prob ->
-    let r =
-      match prob with
-      | FStar_TypeChecker_Common.TProb p ->
-          let uu___ =
-            match p_element prob with
-            | FStar_Pervasives_Native.None -> []
-            | FStar_Pervasives_Native.Some x ->
-                let uu___1 = FStar_Syntax_Syntax.mk_binder x in [uu___1] in
-          FStar_Compiler_List.op_At
-            (p.FStar_TypeChecker_Common.logical_guard_uvar).FStar_Syntax_Syntax.ctx_uvar_binders
-            uu___
-      | FStar_TypeChecker_Common.CProb p ->
-          let uu___ =
-            match p_element prob with
-            | FStar_Pervasives_Native.None -> []
-            | FStar_Pervasives_Native.Some x ->
-                let uu___1 = FStar_Syntax_Syntax.mk_binder x in [uu___1] in
-          FStar_Compiler_List.op_At
-            (p.FStar_TypeChecker_Common.logical_guard_uvar).FStar_Syntax_Syntax.ctx_uvar_binders
-            uu___ in
-    r
-let (p_guard_uvar :
-  FStar_TypeChecker_Common.prob -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p ->
-        p.FStar_TypeChecker_Common.logical_guard_uvar
-    | FStar_TypeChecker_Common.CProb p ->
-        p.FStar_TypeChecker_Common.logical_guard_uvar
-let (p_env :
-  worklist -> FStar_TypeChecker_Common.prob -> FStar_TypeChecker_Env.env) =
-  fun wl ->
-    fun prob ->
-      let uu___ = wl.tcenv in
-      {
-        FStar_TypeChecker_Env.solver = (uu___.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (uu___.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (uu___.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma =
-          ((p_guard_uvar prob).FStar_Syntax_Syntax.ctx_uvar_gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (uu___.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (uu___.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (uu___.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (uu___.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (uu___.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (uu___.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (uu___.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (uu___.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (uu___.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (uu___.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (uu___.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (uu___.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (uu___.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (uu___.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (uu___.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (uu___.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (uu___.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (uu___.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (uu___.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (uu___.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (uu___.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (uu___.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (uu___.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (uu___.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (uu___.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (uu___.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (uu___.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (uu___.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (uu___.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (uu___.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (uu___.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (uu___.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (uu___.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (uu___.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (uu___.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (uu___.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (uu___.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (uu___.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (uu___.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (uu___.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (uu___.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (uu___.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (uu___.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (uu___.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (uu___.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (uu___.FStar_TypeChecker_Env.core_check)
-      }
-let (def_scope_wf :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.binder Prims.list -> unit)
-  =
-  fun msg ->
-    fun rng ->
-      fun r ->
-        let uu___ =
-          let uu___1 = FStar_Options.defensive () in Prims.op_Negation uu___1 in
-        if uu___
-        then ()
-        else
-          (let rec aux prev next =
-             match next with
-             | [] -> ()
-             | { FStar_Syntax_Syntax.binder_bv = bv;
-                 FStar_Syntax_Syntax.binder_qual = uu___2;
-                 FStar_Syntax_Syntax.binder_attrs = uu___3;_}::bs ->
-                 (FStar_TypeChecker_Env.def_check_closed_in rng msg prev
-                    bv.FStar_Syntax_Syntax.sort;
-                  aux (FStar_Compiler_List.op_At prev [bv]) bs) in
-           aux [] r)
-let (def_check_scoped :
-  Prims.string ->
-    FStar_TypeChecker_Common.prob -> FStar_Syntax_Syntax.term -> unit)
-  =
-  fun msg ->
-    fun prob ->
-      fun phi ->
-        let uu___ =
-          let uu___1 = FStar_Options.defensive () in Prims.op_Negation uu___1 in
-        if uu___
-        then ()
-        else
-          (let uu___2 =
-             let uu___3 = p_scope prob in
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_Compiler_List.map
-                  (fun b -> b.FStar_Syntax_Syntax.binder_bv)) uu___3 in
-           FStar_TypeChecker_Env.def_check_closed_in (p_loc prob) msg uu___2
-             phi)
-let (def_check_scoped_comp :
-  Prims.string ->
-    FStar_TypeChecker_Common.prob ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun msg ->
-    fun prob ->
-      fun comp ->
-        let uu___ =
-          let uu___1 = FStar_Options.defensive () in Prims.op_Negation uu___1 in
-        if uu___
-        then ()
-        else
-          (let uu___2 = FStar_Syntax_Util.arrow [] comp in
-           def_check_scoped msg prob uu___2)
-let (def_check_prob : Prims.string -> FStar_TypeChecker_Common.prob -> unit)
-  =
-  fun msg ->
-    fun prob ->
-      let uu___ =
-        let uu___1 = FStar_Options.defensive () in Prims.op_Negation uu___1 in
-      if uu___
-      then ()
-      else
-        (let msgf m =
-           let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Compiler_Util.string_of_int (p_pid prob) in
-               Prims.op_Hat uu___4 (Prims.op_Hat "." m) in
-             Prims.op_Hat "." uu___3 in
-           Prims.op_Hat msg uu___2 in
-         (let uu___3 = msgf "scope" in
-          let uu___4 = p_scope prob in
-          def_scope_wf uu___3 (p_loc prob) uu___4);
-         (let uu___4 = msgf "guard" in
-          def_check_scoped uu___4 prob (p_guard prob));
-         (match prob with
-          | FStar_TypeChecker_Common.TProb p ->
-              ((let uu___5 = msgf "lhs" in
-                def_check_scoped uu___5 prob p.FStar_TypeChecker_Common.lhs);
-               (let uu___5 = msgf "rhs" in
-                def_check_scoped uu___5 prob p.FStar_TypeChecker_Common.rhs))
-          | FStar_TypeChecker_Common.CProb p ->
-              ((let uu___5 = msgf "lhs" in
-                def_check_scoped_comp uu___5 prob
-                  p.FStar_TypeChecker_Common.lhs);
-               (let uu___5 = msgf "rhs" in
-                def_check_scoped_comp uu___5 prob
-                  p.FStar_TypeChecker_Common.rhs))))
-let (rel_to_string : FStar_TypeChecker_Common.rel -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.EQ -> "="
-    | FStar_TypeChecker_Common.SUB -> "<:"
-    | FStar_TypeChecker_Common.SUBINV -> ":>"
-let (term_to_string : FStar_Syntax_Syntax.term -> Prims.string) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        (match head.FStar_Syntax_Syntax.n with
-         | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-             let uu___1 = FStar_Syntax_Print.ctx_uvar_to_string u in
-             let uu___2 =
-               match FStar_Pervasives_Native.fst s with
-               | [] -> ""
-               | s1 ->
-                   let uu___3 =
-                     let uu___4 = FStar_Compiler_List.hd s1 in
-                     FStar_Syntax_Print.subst_to_string uu___4 in
-                   FStar_Compiler_Util.format1 "@<%s>" uu___3 in
-             let uu___3 = FStar_Syntax_Print.args_to_string args in
-             FStar_Compiler_Util.format3 "%s%s %s" uu___1 uu___2 uu___3
-         | uu___1 -> FStar_Syntax_Print.term_to_string t)
-let (prob_to_string :
-  FStar_TypeChecker_Env.env -> FStar_TypeChecker_Common.prob -> Prims.string)
-  =
-  fun env ->
-    fun prob ->
-      match prob with
-      | FStar_TypeChecker_Common.TProb p ->
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Util.string_of_int
-                p.FStar_TypeChecker_Common.pid in
-            let uu___2 =
-              let uu___3 = term_to_string p.FStar_TypeChecker_Common.lhs in
-              let uu___4 =
-                let uu___5 =
-                  let uu___6 = term_to_string p.FStar_TypeChecker_Common.rhs in
-                  [uu___6] in
-                (rel_to_string p.FStar_TypeChecker_Common.relation) :: uu___5 in
-              uu___3 :: uu___4 in
-            uu___1 :: uu___2 in
-          FStar_Compiler_Util.format "\n%s:\t%s \n\t\t%s\n\t%s\n" uu___
-      | FStar_TypeChecker_Common.CProb p ->
-          let uu___ =
-            FStar_Compiler_Util.string_of_int p.FStar_TypeChecker_Common.pid in
-          let uu___1 =
-            FStar_TypeChecker_Normalize.comp_to_string env
-              p.FStar_TypeChecker_Common.lhs in
-          let uu___2 =
-            FStar_TypeChecker_Normalize.comp_to_string env
-              p.FStar_TypeChecker_Common.rhs in
-          FStar_Compiler_Util.format4 "\n%s:\t%s \n\t\t%s\n\t%s" uu___ uu___1
-            (rel_to_string p.FStar_TypeChecker_Common.relation) uu___2
-let (prob_to_string' :
-  worklist -> FStar_TypeChecker_Common.prob -> Prims.string) =
-  fun wl -> fun prob -> let env = p_env wl prob in prob_to_string env prob
-let (uvi_to_string : FStar_TypeChecker_Env.env -> uvi -> Prims.string) =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | UNIV (u, t) ->
-          let x =
-            let uu___1 = FStar_Options.hide_uvar_nums () in
-            if uu___1
-            then "?"
-            else
-              (let uu___3 = FStar_Syntax_Unionfind.univ_uvar_id u in
-               FStar_Compiler_Effect.op_Bar_Greater uu___3
-                 FStar_Compiler_Util.string_of_int) in
-          let uu___1 = FStar_Syntax_Print.univ_to_string t in
-          FStar_Compiler_Util.format2 "UNIV %s <- %s" x uu___1
-      | TERM (u, t) ->
-          let x =
-            let uu___1 = FStar_Options.hide_uvar_nums () in
-            if uu___1
-            then "?"
-            else
-              (let uu___3 =
-                 FStar_Syntax_Unionfind.uvar_id
-                   u.FStar_Syntax_Syntax.ctx_uvar_head in
-               FStar_Compiler_Effect.op_Bar_Greater uu___3
-                 FStar_Compiler_Util.string_of_int) in
-          let uu___1 = FStar_TypeChecker_Normalize.term_to_string env t in
-          FStar_Compiler_Util.format2 "TERM %s <- %s" x uu___1
-let (uvis_to_string :
-  FStar_TypeChecker_Env.env -> uvi Prims.list -> Prims.string) =
-  fun env ->
-    fun uvis -> (FStar_Common.string_of_list ()) (uvi_to_string env) uvis
-let (names_to_string :
-  FStar_Syntax_Syntax.bv FStar_Compiler_Util.set -> Prims.string) =
-  fun nms ->
-    let uu___ =
-      let uu___1 = FStar_Compiler_Util.set_elements nms in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (FStar_Compiler_List.map FStar_Syntax_Print.bv_to_string) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let args_to_string :
-  'uuuuu . (FStar_Syntax_Syntax.term * 'uuuuu) Prims.list -> Prims.string =
-  fun args ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater args
-        (FStar_Compiler_List.map
-           (fun uu___1 ->
-              match uu___1 with
-              | (x, uu___2) -> FStar_Syntax_Print.term_to_string x)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat " ")
-let (empty_worklist : FStar_TypeChecker_Env.env -> worklist) =
-  fun env ->
-    {
-      attempting = [];
-      wl_deferred = [];
-      wl_deferred_to_tac = [];
-      ctr = Prims.int_zero;
-      defer_ok = DeferAny;
-      smt_ok = true;
-      umax_heuristic_ok = true;
-      tcenv = env;
-      wl_implicits = [];
-      repr_subcomp_allowed = false
-    }
-let (giveup :
-  worklist -> lstring -> FStar_TypeChecker_Common.prob -> solution) =
-  fun wl ->
-    fun reason ->
-      fun prob ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar (debug wl)
-             (FStar_Options.Other "Rel") in
-         if uu___1
-         then
-           let uu___2 = FStar_Thunk.force reason in
-           let uu___3 = prob_to_string' wl prob in
-           FStar_Compiler_Util.print2 "Failed %s:\n%s\n" uu___2 uu___3
-         else ());
-        Failed (prob, reason)
-let (giveup_lit :
-  worklist -> Prims.string -> FStar_TypeChecker_Common.prob -> solution) =
-  fun wl ->
-    fun reason ->
-      fun prob ->
-        let uu___ = mklstr (fun uu___1 -> reason) in giveup wl uu___ prob
-let (singleton :
-  worklist -> FStar_TypeChecker_Common.prob -> Prims.bool -> worklist) =
-  fun wl ->
-    fun prob ->
-      fun smt_ok ->
-        {
-          attempting = [prob];
-          wl_deferred = (wl.wl_deferred);
-          wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-          ctr = (wl.ctr);
-          defer_ok = (wl.defer_ok);
-          smt_ok;
-          umax_heuristic_ok = (wl.umax_heuristic_ok);
-          tcenv = (wl.tcenv);
-          wl_implicits = (wl.wl_implicits);
-          repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-        }
-let wl_of_guard :
-  'uuuuu 'uuuuu1 .
-    FStar_TypeChecker_Env.env ->
-      ('uuuuu * 'uuuuu1 * FStar_TypeChecker_Common.prob) Prims.list ->
-        worklist
-  =
-  fun env ->
-    fun g ->
-      let uu___ = empty_worklist env in
-      let uu___1 =
-        FStar_Compiler_List.map
-          (fun uu___2 -> match uu___2 with | (uu___3, uu___4, p) -> p) g in
-      {
-        attempting = uu___1;
-        wl_deferred = (uu___.wl_deferred);
-        wl_deferred_to_tac = (uu___.wl_deferred_to_tac);
-        ctr = (uu___.ctr);
-        defer_ok = (uu___.defer_ok);
-        smt_ok = (uu___.smt_ok);
-        umax_heuristic_ok = (uu___.umax_heuristic_ok);
-        tcenv = (uu___.tcenv);
-        wl_implicits = (uu___.wl_implicits);
-        repr_subcomp_allowed = (uu___.repr_subcomp_allowed)
-      }
-let (defer :
-  FStar_TypeChecker_Common.deferred_reason ->
-    lstring -> FStar_TypeChecker_Common.prob -> worklist -> worklist)
-  =
-  fun reason ->
-    fun msg ->
-      fun prob ->
-        fun wl ->
-          {
-            attempting = (wl.attempting);
-            wl_deferred = (((wl.ctr), reason, msg, prob) :: (wl.wl_deferred));
-            wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-            ctr = (wl.ctr);
-            defer_ok = (wl.defer_ok);
-            smt_ok = (wl.smt_ok);
-            umax_heuristic_ok = (wl.umax_heuristic_ok);
-            tcenv = (wl.tcenv);
-            wl_implicits = (wl.wl_implicits);
-            repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-          }
-let (defer_lit :
-  FStar_TypeChecker_Common.deferred_reason ->
-    Prims.string -> FStar_TypeChecker_Common.prob -> worklist -> worklist)
-  =
-  fun reason ->
-    fun msg ->
-      fun prob ->
-        fun wl ->
-          let uu___ = FStar_Thunk.mkv msg in defer reason uu___ prob wl
-let (attempt :
-  FStar_TypeChecker_Common.prob Prims.list -> worklist -> worklist) =
-  fun probs ->
-    fun wl ->
-      FStar_Compiler_List.iter (def_check_prob "attempt") probs;
-      {
-        attempting = (FStar_Compiler_List.op_At probs wl.attempting);
-        wl_deferred = (wl.wl_deferred);
-        wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-        ctr = (wl.ctr);
-        defer_ok = (wl.defer_ok);
-        smt_ok = (wl.smt_ok);
-        umax_heuristic_ok = (wl.umax_heuristic_ok);
-        tcenv = (wl.tcenv);
-        wl_implicits = (wl.wl_implicits);
-        repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-      }
-let (mk_eq2 :
-  worklist ->
-    FStar_TypeChecker_Common.prob ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          (FStar_Syntax_Syntax.term * worklist))
-  =
-  fun wl ->
-    fun prob ->
-      fun t1 ->
-        fun t2 ->
-          let env = p_env wl prob in
-          FStar_TypeChecker_Env.def_check_closed_in_env
-            t1.FStar_Syntax_Syntax.pos "mk_eq2.t1" env t1;
-          FStar_TypeChecker_Env.def_check_closed_in_env
-            t2.FStar_Syntax_Syntax.pos "mk_eq2.t2" env t2;
-          (let uu___2 =
-             env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term env
-               t1 false in
-           match uu___2 with
-           | (tt, uu___3) ->
-               let u = env.FStar_TypeChecker_Env.universe_of env tt in
-               let uu___4 = FStar_Syntax_Util.mk_eq2 u tt t1 t2 in
-               (uu___4, wl))
-let (p_invert :
-  FStar_TypeChecker_Common.prob -> FStar_TypeChecker_Common.prob) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.TProb p ->
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___1 -> FStar_TypeChecker_Common.TProb uu___1) (invert p)
-    | FStar_TypeChecker_Common.CProb p ->
-        FStar_Compiler_Effect.op_Less_Bar
-          (fun uu___1 -> FStar_TypeChecker_Common.CProb uu___1) (invert p)
-let (is_top_level_prob : FStar_TypeChecker_Common.prob -> Prims.bool) =
-  fun p ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater (p_reason p)
-        FStar_Compiler_List.length in
-    uu___ = Prims.int_one
-let (next_pid : unit -> Prims.int) =
-  let ctr = FStar_Compiler_Util.mk_ref Prims.int_zero in
-  fun uu___ ->
-    FStar_Compiler_Util.incr ctr; FStar_Compiler_Effect.op_Bang ctr
-let mk_problem :
-  'uuuuu .
-    worklist ->
-      FStar_Syntax_Syntax.binder Prims.list ->
-        FStar_TypeChecker_Common.prob ->
-          'uuuuu ->
-            FStar_TypeChecker_Common.rel ->
-              'uuuuu ->
-                FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                  Prims.string ->
-                    ('uuuuu FStar_TypeChecker_Common.problem * worklist)
-  =
-  fun wl ->
-    fun scope ->
-      fun orig ->
-        fun lhs ->
-          fun rel ->
-            fun rhs ->
-              fun elt ->
-                fun reason ->
-                  let scope1 =
-                    match elt with
-                    | FStar_Pervasives_Native.None -> scope
-                    | FStar_Pervasives_Native.Some x ->
-                        let uu___ =
-                          let uu___1 = FStar_Syntax_Syntax.mk_binder x in
-                          [uu___1] in
-                        FStar_Compiler_List.op_At scope uu___ in
-                  let bs =
-                    FStar_Compiler_List.op_At
-                      (p_guard_uvar orig).FStar_Syntax_Syntax.ctx_uvar_binders
-                      scope1 in
-                  let gamma =
-                    let uu___ =
-                      let uu___1 =
-                        FStar_Compiler_List.map
-                          (fun b ->
-                             FStar_Syntax_Syntax.Binding_var
-                               (b.FStar_Syntax_Syntax.binder_bv)) scope1 in
-                      FStar_Compiler_List.rev uu___1 in
-                    FStar_Compiler_List.op_At uu___
-                      (p_guard_uvar orig).FStar_Syntax_Syntax.ctx_uvar_gamma in
-                  let uu___ =
-                    new_uvar
-                      (Prims.op_Hat "mk_problem: logical guard for " reason)
-                      wl FStar_Compiler_Range.dummyRange gamma bs
-                      FStar_Syntax_Util.ktype0
-                      (FStar_Syntax_Syntax.Allow_untyped "logical guard")
-                      FStar_Pervasives_Native.None in
-                  match uu___ with
-                  | (ctx_uvar, lg, wl1) ->
-                      let prob =
-                        let uu___1 = next_pid () in
-                        {
-                          FStar_TypeChecker_Common.pid = uu___1;
-                          FStar_TypeChecker_Common.lhs = lhs;
-                          FStar_TypeChecker_Common.relation = rel;
-                          FStar_TypeChecker_Common.rhs = rhs;
-                          FStar_TypeChecker_Common.element = elt;
-                          FStar_TypeChecker_Common.logical_guard = lg;
-                          FStar_TypeChecker_Common.logical_guard_uvar =
-                            ctx_uvar;
-                          FStar_TypeChecker_Common.reason = (reason ::
-                            (p_reason orig));
-                          FStar_TypeChecker_Common.loc = (p_loc orig);
-                          FStar_TypeChecker_Common.rank =
-                            FStar_Pervasives_Native.None
-                        } in
-                      (prob, wl1)
-let (mk_t_problem :
-  worklist ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      FStar_TypeChecker_Common.prob ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_TypeChecker_Common.rel ->
-            FStar_Syntax_Syntax.typ ->
-              FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                Prims.string -> (FStar_TypeChecker_Common.prob * worklist))
-  =
-  fun wl ->
-    fun scope ->
-      fun orig ->
-        fun lhs ->
-          fun rel ->
-            fun rhs ->
-              fun elt ->
-                fun reason ->
-                  def_check_prob (Prims.op_Hat reason ".mk_t.arg") orig;
-                  (let uu___1 =
-                     mk_problem wl scope orig lhs rel rhs elt reason in
-                   match uu___1 with
-                   | (p, wl1) ->
-                       (def_check_prob (Prims.op_Hat reason ".mk_t")
-                          (FStar_TypeChecker_Common.TProb p);
-                        ((FStar_TypeChecker_Common.TProb p), wl1)))
-let (mk_c_problem :
-  worklist ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      FStar_TypeChecker_Common.prob ->
-        FStar_Syntax_Syntax.comp ->
-          FStar_TypeChecker_Common.rel ->
-            FStar_Syntax_Syntax.comp ->
-              FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                Prims.string -> (FStar_TypeChecker_Common.prob * worklist))
-  =
-  fun wl ->
-    fun scope ->
-      fun orig ->
-        fun lhs ->
-          fun rel ->
-            fun rhs ->
-              fun elt ->
-                fun reason ->
-                  def_check_prob (Prims.op_Hat reason ".mk_c.arg") orig;
-                  (let uu___1 =
-                     mk_problem wl scope orig lhs rel rhs elt reason in
-                   match uu___1 with
-                   | (p, wl1) ->
-                       (def_check_prob (Prims.op_Hat reason ".mk_c")
-                          (FStar_TypeChecker_Common.CProb p);
-                        ((FStar_TypeChecker_Common.CProb p), wl1)))
-let new_problem :
-  'uuuuu .
-    worklist ->
-      FStar_TypeChecker_Env.env ->
-        'uuuuu ->
-          FStar_TypeChecker_Common.rel ->
-            'uuuuu ->
-              FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                FStar_Compiler_Range.range ->
-                  Prims.string ->
-                    ('uuuuu FStar_TypeChecker_Common.problem * worklist)
-  =
-  fun wl ->
-    fun env ->
-      fun lhs ->
-        fun rel ->
-          fun rhs ->
-            fun subject ->
-              fun loc ->
-                fun reason ->
-                  let lg_ty =
-                    match subject with
-                    | FStar_Pervasives_Native.None ->
-                        FStar_Syntax_Util.ktype0
-                    | FStar_Pervasives_Native.Some x ->
-                        let bs =
-                          let uu___ = FStar_Syntax_Syntax.mk_binder x in
-                          [uu___] in
-                        let uu___ =
-                          FStar_Syntax_Syntax.mk_Total
-                            FStar_Syntax_Util.ktype0 in
-                        FStar_Syntax_Util.arrow bs uu___ in
-                  let uu___ =
-                    let uu___1 = FStar_TypeChecker_Env.all_binders env in
-                    new_uvar
-                      (Prims.op_Hat "new_problem: logical guard for " reason)
-                      {
-                        attempting = (wl.attempting);
-                        wl_deferred = (wl.wl_deferred);
-                        wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-                        ctr = (wl.ctr);
-                        defer_ok = (wl.defer_ok);
-                        smt_ok = (wl.smt_ok);
-                        umax_heuristic_ok = (wl.umax_heuristic_ok);
-                        tcenv = env;
-                        wl_implicits = (wl.wl_implicits);
-                        repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-                      } loc env.FStar_TypeChecker_Env.gamma uu___1 lg_ty
-                      (FStar_Syntax_Syntax.Allow_untyped "logical guard")
-                      FStar_Pervasives_Native.None in
-                  match uu___ with
-                  | (ctx_uvar, lg, wl1) ->
-                      let lg1 =
-                        match subject with
-                        | FStar_Pervasives_Native.None -> lg
-                        | FStar_Pervasives_Native.Some x ->
-                            let uu___1 =
-                              let uu___2 =
-                                let uu___3 = FStar_Syntax_Syntax.bv_to_name x in
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  FStar_Syntax_Syntax.as_arg uu___3 in
-                              [uu___2] in
-                            FStar_Syntax_Syntax.mk_Tm_app lg uu___1 loc in
-                      let prob =
-                        let uu___1 = next_pid () in
-                        {
-                          FStar_TypeChecker_Common.pid = uu___1;
-                          FStar_TypeChecker_Common.lhs = lhs;
-                          FStar_TypeChecker_Common.relation = rel;
-                          FStar_TypeChecker_Common.rhs = rhs;
-                          FStar_TypeChecker_Common.element = subject;
-                          FStar_TypeChecker_Common.logical_guard = lg1;
-                          FStar_TypeChecker_Common.logical_guard_uvar =
-                            ctx_uvar;
-                          FStar_TypeChecker_Common.reason = [reason];
-                          FStar_TypeChecker_Common.loc = loc;
-                          FStar_TypeChecker_Common.rank =
-                            FStar_Pervasives_Native.None
-                        } in
-                      (prob, wl1)
-let (problem_using_guard :
-  FStar_TypeChecker_Common.prob ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_TypeChecker_Common.rel ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-            Prims.string ->
-              FStar_Syntax_Syntax.typ FStar_TypeChecker_Common.problem)
-  =
-  fun orig ->
-    fun lhs ->
-      fun rel ->
-        fun rhs ->
-          fun elt ->
-            fun reason ->
-              let p =
-                let uu___ = next_pid () in
-                {
-                  FStar_TypeChecker_Common.pid = uu___;
-                  FStar_TypeChecker_Common.lhs = lhs;
-                  FStar_TypeChecker_Common.relation = rel;
-                  FStar_TypeChecker_Common.rhs = rhs;
-                  FStar_TypeChecker_Common.element = elt;
-                  FStar_TypeChecker_Common.logical_guard = (p_guard orig);
-                  FStar_TypeChecker_Common.logical_guard_uvar =
-                    (p_guard_uvar orig);
-                  FStar_TypeChecker_Common.reason = (reason ::
-                    (p_reason orig));
-                  FStar_TypeChecker_Common.loc = (p_loc orig);
-                  FStar_TypeChecker_Common.rank =
-                    FStar_Pervasives_Native.None
-                } in
-              def_check_prob reason (FStar_TypeChecker_Common.TProb p); p
-let (guard_on_element :
-  worklist ->
-    FStar_Syntax_Syntax.typ FStar_TypeChecker_Common.problem ->
-      FStar_Syntax_Syntax.bv ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.term)
-  =
-  fun wl ->
-    fun problem ->
-      fun x ->
-        fun phi ->
-          match problem.FStar_TypeChecker_Common.element with
-          | FStar_Pervasives_Native.None ->
-              let tcenv = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-              let u =
-                tcenv.FStar_TypeChecker_Env.universe_of tcenv
-                  x.FStar_Syntax_Syntax.sort in
-              FStar_Syntax_Util.mk_forall u x phi
-          | FStar_Pervasives_Native.Some e ->
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Syntax.bv_to_name e in
-                    (x, uu___3) in
-                  FStar_Syntax_Syntax.NT uu___2 in
-                [uu___1] in
-              FStar_Syntax_Subst.subst uu___ phi
-let (explain :
-  worklist -> FStar_TypeChecker_Common.prob -> lstring -> Prims.string) =
-  fun wl ->
-    fun d ->
-      fun s ->
-        let uu___ =
-          (FStar_Compiler_Effect.op_Less_Bar (debug wl)
-             (FStar_Options.Other "ExplainRel"))
-            ||
-            (FStar_Compiler_Effect.op_Less_Bar (debug wl)
-               (FStar_Options.Other "Rel")) in
-        if uu___
-        then
-          let uu___1 =
-            FStar_Compiler_Effect.op_Less_Bar
-              FStar_Compiler_Range.string_of_range (p_loc d) in
-          let uu___2 = prob_to_string' wl d in
-          let uu___3 =
-            FStar_Compiler_Effect.op_Bar_Greater (p_reason d)
-              (FStar_String.concat "\n\t>") in
-          let uu___4 = FStar_Thunk.force s in
-          FStar_Compiler_Util.format4
-            "(%s) Failed to solve the sub-problem\n%s\nWhich arose because:\n\t%s\nFailed because:%s\n"
-            uu___1 uu___2 uu___3 uu___4
-        else
-          (let d1 = maybe_invert_p d in
-           let rel =
-             match p_rel d1 with
-             | FStar_TypeChecker_Common.EQ -> "equal to"
-             | FStar_TypeChecker_Common.SUB -> "a subtype of"
-             | uu___2 -> failwith "impossible" in
-           let uu___2 =
-             match d1 with
-             | FStar_TypeChecker_Common.TProb tp ->
-                 FStar_TypeChecker_Err.print_discrepancy
-                   (FStar_TypeChecker_Normalize.term_to_string (p_env wl d1))
-                   tp.FStar_TypeChecker_Common.lhs
-                   tp.FStar_TypeChecker_Common.rhs
-             | FStar_TypeChecker_Common.CProb cp ->
-                 FStar_TypeChecker_Err.print_discrepancy
-                   (FStar_TypeChecker_Normalize.comp_to_string (p_env wl d1))
-                   cp.FStar_TypeChecker_Common.lhs
-                   cp.FStar_TypeChecker_Common.rhs in
-           match uu___2 with
-           | (lhs, rhs) ->
-               FStar_Compiler_Util.format3
-                 "%s is not %s the expected type %s" lhs rel rhs)
-let set_uvar :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Syntax_Syntax.ctx_uvar ->
-        FStar_Syntax_Syntax.should_check_uvar FStar_Pervasives_Native.option
-          -> FStar_Syntax_Syntax.term -> unit
-  =
-  fun env ->
-    fun u ->
-      fun should_check_opt ->
-        fun t ->
-          (match should_check_opt with
-           | FStar_Pervasives_Native.None -> ()
-           | FStar_Pervasives_Native.Some should_check ->
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Syntax_Unionfind.find_decoration
-                     u.FStar_Syntax_Syntax.ctx_uvar_head in
-                 {
-                   FStar_Syntax_Syntax.uvar_decoration_typ =
-                     (uu___2.FStar_Syntax_Syntax.uvar_decoration_typ);
-                   FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on =
-                     (uu___2.FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on);
-                   FStar_Syntax_Syntax.uvar_decoration_should_check =
-                     should_check
-                 } in
-               FStar_Syntax_Unionfind.change_decoration
-                 u.FStar_Syntax_Syntax.ctx_uvar_head uu___1);
-          FStar_Syntax_Util.set_uvar u.FStar_Syntax_Syntax.ctx_uvar_head t
-let commit : 'uuuuu . 'uuuuu -> uvi Prims.list -> unit =
-  fun env ->
-    fun uvis ->
-      FStar_Compiler_Effect.op_Bar_Greater uvis
-        (FStar_Compiler_List.iter
-           (fun uu___ ->
-              match uu___ with
-              | UNIV (u, t) ->
-                  (match t with
-                   | FStar_Syntax_Syntax.U_unif u' ->
-                       FStar_Syntax_Unionfind.univ_union u u'
-                   | uu___1 -> FStar_Syntax_Unionfind.univ_change u t)
-              | TERM (u, t) ->
-                  ((let uu___2 =
-                      FStar_Compiler_List.map
-                        (fun b -> b.FStar_Syntax_Syntax.binder_bv)
-                        u.FStar_Syntax_Syntax.ctx_uvar_binders in
-                    FStar_TypeChecker_Env.def_check_closed_in
-                      t.FStar_Syntax_Syntax.pos "commit" uu___2 t);
-                   set_uvar env u FStar_Pervasives_Native.None t)))
-let (find_term_uvar :
-  FStar_Syntax_Syntax.uvar ->
-    uvi Prims.list -> FStar_Syntax_Syntax.term FStar_Pervasives_Native.option)
-  =
-  fun uv ->
-    fun s ->
-      FStar_Compiler_Util.find_map s
-        (fun uu___ ->
-           match uu___ with
-           | UNIV uu___1 -> FStar_Pervasives_Native.None
-           | TERM (u, t) ->
-               let uu___1 =
-                 FStar_Syntax_Unionfind.equiv uv
-                   u.FStar_Syntax_Syntax.ctx_uvar_head in
-               if uu___1
-               then FStar_Pervasives_Native.Some t
-               else FStar_Pervasives_Native.None)
-let (find_univ_uvar :
-  FStar_Syntax_Syntax.universe_uvar ->
-    uvi Prims.list ->
-      FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option)
-  =
-  fun u ->
-    fun s ->
-      FStar_Compiler_Util.find_map s
-        (fun uu___ ->
-           match uu___ with
-           | UNIV (u', t) ->
-               let uu___1 = FStar_Syntax_Unionfind.univ_equiv u u' in
-               if uu___1
-               then FStar_Pervasives_Native.Some t
-               else FStar_Pervasives_Native.None
-           | uu___1 -> FStar_Pervasives_Native.None)
-let (sn' :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      let uu___ =
-        let uu___1 =
-          FStar_TypeChecker_Normalize.normalize
-            [FStar_TypeChecker_Env.Beta; FStar_TypeChecker_Env.Reify] env t in
-        FStar_Syntax_Subst.compress uu___1 in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Syntax_Util.unlazy_emb
-let (sn :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_TypeChecker_Env.current_module env in
-          FStar_Ident.string_of_lid uu___2 in
-        FStar_Pervasives_Native.Some uu___1 in
-      FStar_Profiling.profile (fun uu___1 -> sn' env t) uu___
-        "FStar.TypeChecker.Rel.sn"
-let (norm_with_steps :
-  Prims.string ->
-    FStar_TypeChecker_Env.steps ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun profiling_tag ->
-    fun steps ->
-      fun env ->
-        fun t ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.current_module env in
-              FStar_Ident.string_of_lid uu___2 in
-            FStar_Pervasives_Native.Some uu___1 in
-          FStar_Profiling.profile
-            (fun uu___1 -> FStar_TypeChecker_Normalize.normalize steps env t)
-            uu___ profiling_tag
-let (should_strongly_reduce : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        FStar_Compiler_Effect.op_Bar_Greater t FStar_Syntax_Util.unascribe in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        FStar_Syntax_Util.head_and_args in
-    match uu___ with
-    | (h, uu___1) ->
-        let uu___2 =
-          let uu___3 = FStar_Syntax_Subst.compress h in
-          uu___3.FStar_Syntax_Syntax.n in
-        (match uu___2 with
-         | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify) -> true
-         | uu___3 -> false)
-let (whnf :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      let norm steps t1 =
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater t1
-                FStar_Syntax_Util.unmeta in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (FStar_TypeChecker_Normalize.normalize steps env) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Syntax_Subst.compress in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          FStar_Syntax_Util.unlazy_emb in
-      let uu___ =
-        let uu___1 =
-          let uu___2 = FStar_TypeChecker_Env.current_module env in
-          FStar_Ident.string_of_lid uu___2 in
-        FStar_Pervasives_Native.Some uu___1 in
-      FStar_Profiling.profile
-        (fun uu___1 ->
-           let uu___2 = should_strongly_reduce t in
-           if uu___2
-           then
-             norm
-               [FStar_TypeChecker_Env.Beta;
-               FStar_TypeChecker_Env.Reify;
-               FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-               FStar_TypeChecker_Env.UnfoldUntil
-                 FStar_Syntax_Syntax.delta_constant] t
-           else
-             (let uu___4 = FStar_Syntax_Util.unmeta t in
-              norm
-                [FStar_TypeChecker_Env.Beta;
-                FStar_TypeChecker_Env.Reify;
-                FStar_TypeChecker_Env.Weak;
-                FStar_TypeChecker_Env.HNF] uu___4)) uu___
-        "FStar.TypeChecker.Rel.whnf"
-let norm_arg :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      (FStar_Syntax_Syntax.term * 'uuuuu) ->
-        (FStar_Syntax_Syntax.term * 'uuuuu)
-  =
-  fun env ->
-    fun t ->
-      let uu___ = sn env (FStar_Pervasives_Native.fst t) in
-      (uu___, (FStar_Pervasives_Native.snd t))
-let (sn_binders :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binder Prims.list)
-  =
-  fun env ->
-    fun binders ->
-      FStar_Compiler_Effect.op_Bar_Greater binders
-        (FStar_Compiler_List.map
-           (fun b ->
-              let uu___ =
-                let uu___1 = b.FStar_Syntax_Syntax.binder_bv in
-                let uu___2 =
-                  sn env
-                    (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                {
-                  FStar_Syntax_Syntax.ppname =
-                    (uu___1.FStar_Syntax_Syntax.ppname);
-                  FStar_Syntax_Syntax.index =
-                    (uu___1.FStar_Syntax_Syntax.index);
-                  FStar_Syntax_Syntax.sort = uu___2
-                } in
-              {
-                FStar_Syntax_Syntax.binder_bv = uu___;
-                FStar_Syntax_Syntax.binder_qual =
-                  (b.FStar_Syntax_Syntax.binder_qual);
-                FStar_Syntax_Syntax.binder_attrs =
-                  (b.FStar_Syntax_Syntax.binder_attrs)
-              }))
-let (norm_univ :
-  worklist -> FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe) =
-  fun wl ->
-    fun u ->
-      let rec aux u1 =
-        let u2 = FStar_Syntax_Subst.compress_univ u1 in
-        match u2 with
-        | FStar_Syntax_Syntax.U_succ u3 ->
-            let uu___ = aux u3 in FStar_Syntax_Syntax.U_succ uu___
-        | FStar_Syntax_Syntax.U_max us ->
-            let uu___ = FStar_Compiler_List.map aux us in
-            FStar_Syntax_Syntax.U_max uu___
-        | uu___ -> u2 in
-      let uu___ = aux u in
-      FStar_TypeChecker_Normalize.normalize_universe wl.tcenv uu___
-let (normalize_refinement :
-  FStar_TypeChecker_Env.steps ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  =
-  fun steps ->
-    fun env ->
-      fun t0 ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module env in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 ->
-             FStar_TypeChecker_Normalize.normalize_refinement steps env t0)
-          uu___ "FStar.TypeChecker.Rel.normalize_refinement"
-let (base_and_refinement_maybe_delta :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.bv *
-          FStar_Syntax_Syntax.term) FStar_Pervasives_Native.option))
-  =
-  fun should_delta ->
-    fun env ->
-      fun t1 ->
-        let norm_refinement env1 t =
-          let steps =
-            if should_delta
-            then
-              [FStar_TypeChecker_Env.Weak;
-              FStar_TypeChecker_Env.HNF;
-              FStar_TypeChecker_Env.UnfoldUntil
-                FStar_Syntax_Syntax.delta_constant]
-            else [FStar_TypeChecker_Env.Weak; FStar_TypeChecker_Env.HNF] in
-          normalize_refinement steps env1 t in
-        let rec aux norm t11 =
-          let t12 = FStar_Syntax_Util.unmeta t11 in
-          match t12.FStar_Syntax_Syntax.n with
-          | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-              if norm
-              then
-                ((x.FStar_Syntax_Syntax.sort),
-                  (FStar_Pervasives_Native.Some (x, phi)))
-              else
-                (let uu___1 = norm_refinement env t12 in
-                 match uu___1 with
-                 | {
-                     FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_refine
-                       (x1, phi1);
-                     FStar_Syntax_Syntax.pos = uu___2;
-                     FStar_Syntax_Syntax.vars = uu___3;
-                     FStar_Syntax_Syntax.hash_code = uu___4;_} ->
-                     ((x1.FStar_Syntax_Syntax.sort),
-                       (FStar_Pervasives_Native.Some (x1, phi1)))
-                 | tt ->
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Print.term_to_string tt in
-                       let uu___4 = FStar_Syntax_Print.tag_of_term tt in
-                       FStar_Compiler_Util.format2
-                         "impossible: Got %s ... %s\n" uu___3 uu___4 in
-                     failwith uu___2)
-          | FStar_Syntax_Syntax.Tm_lazy i ->
-              let uu___ = FStar_Syntax_Util.unfold_lazy i in aux norm uu___
-          | FStar_Syntax_Syntax.Tm_uinst uu___ ->
-              if norm
-              then (t12, FStar_Pervasives_Native.None)
-              else
-                (let t1' = norm_refinement env t12 in
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t1' in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 match uu___2 with
-                 | FStar_Syntax_Syntax.Tm_refine uu___3 -> aux true t1'
-                 | uu___3 -> (t12, FStar_Pervasives_Native.None))
-          | FStar_Syntax_Syntax.Tm_fvar uu___ ->
-              if norm
-              then (t12, FStar_Pervasives_Native.None)
-              else
-                (let t1' = norm_refinement env t12 in
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t1' in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 match uu___2 with
-                 | FStar_Syntax_Syntax.Tm_refine uu___3 -> aux true t1'
-                 | uu___3 -> (t12, FStar_Pervasives_Native.None))
-          | FStar_Syntax_Syntax.Tm_app uu___ ->
-              if norm
-              then (t12, FStar_Pervasives_Native.None)
-              else
-                (let t1' = norm_refinement env t12 in
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t1' in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 match uu___2 with
-                 | FStar_Syntax_Syntax.Tm_refine uu___3 -> aux true t1'
-                 | uu___3 -> (t12, FStar_Pervasives_Native.None))
-          | FStar_Syntax_Syntax.Tm_type uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_constant uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_name uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_bvar uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_arrow uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_abs uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_quoted uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_uvar uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_let uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_match uu___ ->
-              (t12, FStar_Pervasives_Native.None)
-          | FStar_Syntax_Syntax.Tm_meta uu___ ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string t12 in
-                let uu___3 = FStar_Syntax_Print.tag_of_term t12 in
-                FStar_Compiler_Util.format2
-                  "impossible (outer): Got %s ... %s\n" uu___2 uu___3 in
-              failwith uu___1
-          | FStar_Syntax_Syntax.Tm_ascribed uu___ ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string t12 in
-                let uu___3 = FStar_Syntax_Print.tag_of_term t12 in
-                FStar_Compiler_Util.format2
-                  "impossible (outer): Got %s ... %s\n" uu___2 uu___3 in
-              failwith uu___1
-          | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.term_to_string t12 in
-                let uu___3 = FStar_Syntax_Print.tag_of_term t12 in
-                FStar_Compiler_Util.format2
-                  "impossible (outer): Got %s ... %s\n" uu___2 uu___3 in
-              failwith uu___1
-          | FStar_Syntax_Syntax.Tm_unknown ->
-              let uu___ =
-                let uu___1 = FStar_Syntax_Print.term_to_string t12 in
-                let uu___2 = FStar_Syntax_Print.tag_of_term t12 in
-                FStar_Compiler_Util.format2
-                  "impossible (outer): Got %s ... %s\n" uu___1 uu___2 in
-              failwith uu___ in
-        let uu___ = whnf env t1 in aux false uu___
-let (base_and_refinement :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.bv *
-        FStar_Syntax_Syntax.term) FStar_Pervasives_Native.option))
-  = fun env -> fun t -> base_and_refinement_maybe_delta false env t
-let (unrefine :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun env ->
-    fun t ->
-      let uu___ = base_and_refinement env t in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Pervasives_Native.fst
-let (trivial_refinement :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term))
-  =
-  fun t ->
-    let uu___ = FStar_Syntax_Syntax.null_bv t in
-    (uu___, FStar_Syntax_Util.t_true)
-let (as_refinement :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term))
-  =
-  fun delta ->
-    fun env ->
-      fun t ->
-        let uu___ = base_and_refinement_maybe_delta delta env t in
-        match uu___ with
-        | (t_base, refinement) ->
-            (match refinement with
-             | FStar_Pervasives_Native.None -> trivial_refinement t_base
-             | FStar_Pervasives_Native.Some (x, phi) -> (x, phi))
-let (force_refinement :
-  (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-    (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term)
-    FStar_Pervasives_Native.option) -> FStar_Syntax_Syntax.term)
-  =
-  fun uu___ ->
-    match uu___ with
-    | (t_base, refopt) ->
-        let uu___1 =
-          match refopt with
-          | FStar_Pervasives_Native.Some (y, phi) -> (y, phi)
-          | FStar_Pervasives_Native.None -> trivial_refinement t_base in
-        (match uu___1 with
-         | (y, phi) ->
-             FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_refine (y, phi))
-               t_base.FStar_Syntax_Syntax.pos)
-let (wl_to_string : worklist -> Prims.string) =
-  fun wl ->
-    let probs_to_string ps =
-      let uu___ = FStar_Compiler_List.map (prob_to_string' wl) ps in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat "\n\t") in
-    let uu___ = probs_to_string wl.attempting in
-    let uu___1 =
-      let uu___2 =
-        FStar_Compiler_List.map
-          (fun uu___3 -> match uu___3 with | (uu___4, uu___5, uu___6, x) -> x)
-          wl.wl_deferred in
-      probs_to_string uu___2 in
-    FStar_Compiler_Util.format2
-      "{ attempting = [ %s ];\ndeferred = [ %s ] }\n" uu___ uu___1
-type flex_t =
-  | Flex of (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.ctx_uvar *
-  FStar_Syntax_Syntax.args) 
-let (uu___is_Flex : flex_t -> Prims.bool) = fun projectee -> true
-let (__proj__Flex__item___0 :
-  flex_t ->
-    (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.ctx_uvar *
-      FStar_Syntax_Syntax.args))
-  = fun projectee -> match projectee with | Flex _0 -> _0
-let (flex_reason : flex_t -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Flex (uu___1, u, uu___2) -> u.FStar_Syntax_Syntax.ctx_uvar_reason
-let (flex_uvar : flex_t -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun uu___ -> match uu___ with | Flex (uu___1, u, uu___2) -> u
-let (flex_uvar_has_meta_tac : FStar_Syntax_Syntax.ctx_uvar -> Prims.bool) =
-  fun u ->
-    match u.FStar_Syntax_Syntax.ctx_uvar_meta with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Ctx_uvar_meta_tac
-        uu___) -> true
-    | uu___ -> false
-let (flex_t_to_string : flex_t -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | Flex (uu___1, c, args) ->
-        let uu___2 = print_ctx_uvar c in
-        let uu___3 = FStar_Syntax_Print.args_to_string args in
-        FStar_Compiler_Util.format2 "%s [%s]" uu___2 uu___3
-let (is_flex : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, _args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress head in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_uvar uu___2 -> true
-         | uu___2 -> false)
-let (flex_uvar_head :
-  FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.ctx_uvar) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, _args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress head in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_uvar (u, uu___2) -> u
-         | uu___2 -> failwith "Not a flex-uvar")
-let (ensure_no_uvar_subst :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      worklist -> (FStar_Syntax_Syntax.term * worklist))
-  =
-  fun env ->
-    fun t0 ->
-      fun wl ->
-        let bv_not_affected_by s x =
-          let t_x = FStar_Syntax_Syntax.bv_to_name x in
-          let t_x' = FStar_Syntax_Subst.subst' s t_x in
-          let uu___ =
-            let uu___1 = FStar_Syntax_Subst.compress t_x' in
-            uu___1.FStar_Syntax_Syntax.n in
-          match uu___ with
-          | FStar_Syntax_Syntax.Tm_name y -> FStar_Syntax_Syntax.bv_eq x y
-          | uu___1 -> false in
-        let binding_not_affected_by s b =
-          match b with
-          | FStar_Syntax_Syntax.Binding_var x -> bv_not_affected_by s x
-          | uu___ -> true in
-        let uu___ = FStar_Syntax_Util.head_and_args t0 in
-        match uu___ with
-        | (head, args) ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Subst.compress head in
-              uu___2.FStar_Syntax_Syntax.n in
-            (match uu___1 with
-             | FStar_Syntax_Syntax.Tm_uvar (uv, ([], uu___2)) -> (t0, wl)
-             | FStar_Syntax_Syntax.Tm_uvar (uv, uu___2) when
-                 FStar_Compiler_List.isEmpty
-                   uv.FStar_Syntax_Syntax.ctx_uvar_binders
-                 -> (t0, wl)
-             | FStar_Syntax_Syntax.Tm_uvar (uv, s) ->
-                 let uu___2 =
-                   FStar_Common.max_suffix (binding_not_affected_by s)
-                     uv.FStar_Syntax_Syntax.ctx_uvar_gamma in
-                 (match uu___2 with
-                  | (gamma_aff, new_gamma) ->
-                      (match gamma_aff with
-                       | [] -> (t0, wl)
-                       | uu___3 ->
-                           let dom_binders =
-                             FStar_TypeChecker_Env.binders_of_bindings
-                               gamma_aff in
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_TypeChecker_Env.binders_of_bindings
-                                 new_gamma in
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Syntax_Util.ctx_uvar_typ uv in
-                                 FStar_Syntax_Syntax.mk_Total uu___8 in
-                               FStar_Syntax_Util.arrow dom_binders uu___7 in
-                             let uu___7 =
-                               FStar_Syntax_Util.ctx_uvar_should_check uv in
-                             new_uvar
-                               (Prims.op_Hat
-                                  uv.FStar_Syntax_Syntax.ctx_uvar_reason
-                                  "; force delayed") wl
-                               t0.FStar_Syntax_Syntax.pos new_gamma uu___5
-                               uu___6 uu___7
-                               uv.FStar_Syntax_Syntax.ctx_uvar_meta in
-                           (match uu___4 with
-                            | (v, t_v, wl1) ->
-                                let args_sol =
-                                  FStar_Compiler_List.map
-                                    FStar_Syntax_Util.arg_of_non_null_binder
-                                    dom_binders in
-                                let sol =
-                                  FStar_Syntax_Syntax.mk_Tm_app t_v args_sol
-                                    t0.FStar_Syntax_Syntax.pos in
-                                ((let uu___6 =
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      (FStar_TypeChecker_Env.debug env)
-                                      (FStar_Options.Other "Rel") in
-                                  if uu___6
-                                  then
-                                    let uu___7 =
-                                      FStar_Syntax_Print.ctx_uvar_to_string
-                                        uv in
-                                    let uu___8 =
-                                      FStar_Syntax_Print.term_to_string sol in
-                                    FStar_Compiler_Util.print2
-                                      "ensure_no_uvar_subst solving %s with %s\n"
-                                      uu___7 uu___8
-                                  else ());
-                                 set_uvar env uv
-                                   (FStar_Pervasives_Native.Some
-                                      FStar_Syntax_Syntax.Already_checked)
-                                   sol;
-                                 (let args_sol_s =
-                                    FStar_Compiler_List.map
-                                      (fun uu___7 ->
-                                         match uu___7 with
-                                         | (a, i) ->
-                                             let uu___8 =
-                                               FStar_Syntax_Subst.subst' s a in
-                                             (uu___8, i)) args_sol in
-                                  let t =
-                                    FStar_Syntax_Syntax.mk_Tm_app t_v
-                                      (FStar_Compiler_List.op_At args_sol_s
-                                         args) t0.FStar_Syntax_Syntax.pos in
-                                  (t, wl1))))))
-             | uu___2 ->
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Print.tag_of_term t0 in
-                   let uu___5 = FStar_Syntax_Print.tag_of_term head in
-                   let uu___6 =
-                     let uu___7 = FStar_Syntax_Subst.compress head in
-                     FStar_Syntax_Print.tag_of_term uu___7 in
-                   FStar_Compiler_Util.format3
-                     "ensure_no_uvar_subst: expected a uvar at the head (%s-%s-%s)"
-                     uu___4 uu___5 uu___6 in
-                 failwith uu___3)
-let (no_free_uvars : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    (let uu___ = FStar_Syntax_Free.uvars t in
-     FStar_Compiler_Util.set_is_empty uu___) &&
-      (let uu___ = FStar_Syntax_Free.univs t in
-       FStar_Compiler_Util.set_is_empty uu___)
-let rec (may_relate_with_logical_guard :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool -> FStar_Syntax_Syntax.typ -> Prims.bool)
-  =
-  fun env ->
-    fun is_eq ->
-      fun head ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress head in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_name uu___1 -> true
-        | FStar_Syntax_Syntax.Tm_match uu___1 -> true
-        | FStar_Syntax_Syntax.Tm_fvar fv ->
-            let uu___1 = FStar_TypeChecker_Env.delta_depth_of_fv env fv in
-            (match uu___1 with
-             | FStar_Syntax_Syntax.Delta_equational_at_level uu___2 -> true
-             | FStar_Syntax_Syntax.Delta_abstract uu___2 -> is_eq
-             | uu___2 -> false)
-        | FStar_Syntax_Syntax.Tm_ascribed (t, uu___1, uu___2) ->
-            may_relate_with_logical_guard env is_eq t
-        | FStar_Syntax_Syntax.Tm_uinst (t, uu___1) ->
-            may_relate_with_logical_guard env is_eq t
-        | FStar_Syntax_Syntax.Tm_meta (t, uu___1) ->
-            may_relate_with_logical_guard env is_eq t
-        | uu___1 -> false
-let (may_relate :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.rel -> FStar_Syntax_Syntax.typ -> Prims.bool)
-  =
-  fun env ->
-    fun prel ->
-      fun head ->
-        may_relate_with_logical_guard env
-          (FStar_TypeChecker_Common.uu___is_EQ prel) head
-let (destruct_flex_t' : FStar_Syntax_Syntax.term -> flex_t) =
-  fun t ->
-    let uu___ = FStar_Syntax_Util.head_and_args t in
-    match uu___ with
-    | (head, args) ->
-        let uu___1 =
-          let uu___2 = FStar_Syntax_Subst.compress head in
-          uu___2.FStar_Syntax_Syntax.n in
-        (match uu___1 with
-         | FStar_Syntax_Syntax.Tm_uvar (uv, s) -> Flex (t, uv, args)
-         | uu___2 -> failwith "Not a flex-uvar")
-let (destruct_flex_t :
-  FStar_Syntax_Syntax.term -> worklist -> (flex_t * worklist)) =
-  fun t ->
-    fun wl ->
-      let uu___ = ensure_no_uvar_subst wl.tcenv t wl in
-      match uu___ with
-      | (t1, wl1) -> let uu___1 = destruct_flex_t' t1 in (uu___1, wl1)
-let (u_abs :
-  FStar_Syntax_Syntax.typ ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun k ->
-    fun ys ->
-      fun t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Subst.compress k in
-            uu___2.FStar_Syntax_Syntax.n in
-          match uu___1 with
-          | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-              if
-                (FStar_Compiler_List.length bs) =
-                  (FStar_Compiler_List.length ys)
-              then
-                let uu___2 = FStar_Syntax_Subst.open_comp bs c in
-                ((ys, t), uu___2)
-              else
-                (let uu___3 = FStar_Syntax_Util.abs_formals t in
-                 match uu___3 with
-                 | (ys', t1, uu___4) ->
-                     let uu___5 = FStar_Syntax_Util.arrow_formals_comp k in
-                     (((FStar_Compiler_List.op_At ys ys'), t1), uu___5))
-          | uu___2 ->
-              let uu___3 =
-                let uu___4 = FStar_Syntax_Syntax.mk_Total k in ([], uu___4) in
-              ((ys, t), uu___3) in
-        match uu___ with
-        | ((ys1, t1), (xs, c)) ->
-            if
-              (FStar_Compiler_List.length xs) <>
-                (FStar_Compiler_List.length ys1)
-            then
-              FStar_Syntax_Util.abs ys1 t1
-                (FStar_Pervasives_Native.Some
-                   (FStar_Syntax_Util.mk_residual_comp
-                      FStar_Parser_Const.effect_Tot_lid
-                      FStar_Pervasives_Native.None []))
-            else
-              (let c1 =
-                 let uu___2 = FStar_Syntax_Util.rename_binders xs ys1 in
-                 FStar_Syntax_Subst.subst_comp uu___2 c in
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Util.residual_comp_of_comp c1 in
-                 FStar_Pervasives_Native.Some uu___3 in
-               FStar_Syntax_Util.abs ys1 t1 uu___2)
-let (solve_prob' :
-  Prims.bool ->
-    FStar_TypeChecker_Common.prob ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax
-        FStar_Pervasives_Native.option ->
-        uvi Prims.list -> worklist -> worklist)
-  =
-  fun resolve_ok ->
-    fun prob ->
-      fun logical_guard ->
-        fun uvis ->
-          fun wl ->
-            def_check_prob "solve_prob'" prob;
-            (let phi =
-               match logical_guard with
-               | FStar_Pervasives_Native.None -> FStar_Syntax_Util.t_true
-               | FStar_Pervasives_Native.Some phi1 -> phi1 in
-             let assign_solution xs uv phi1 =
-               (let uu___2 =
-                  FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                    (FStar_Options.Other "Rel") in
-                if uu___2
-                then
-                  let uu___3 = FStar_Compiler_Util.string_of_int (p_pid prob) in
-                  let uu___4 = print_ctx_uvar uv in
-                  let uu___5 = FStar_Syntax_Print.term_to_string phi1 in
-                  FStar_Compiler_Util.print3
-                    "Solving %s (%s) with formula %s\n" uu___3 uu___4 uu___5
-                else ());
-               (let phi2 =
-                  FStar_Syntax_Util.abs xs phi1
-                    (FStar_Pervasives_Native.Some
-                       (FStar_Syntax_Util.residual_tot
-                          FStar_Syntax_Util.ktype0)) in
-                (let uu___3 =
-                   let uu___4 =
-                     FStar_Compiler_Util.string_of_int (p_pid prob) in
-                   Prims.op_Hat "solve_prob'.sol." uu___4 in
-                 let uu___4 =
-                   let uu___5 = p_scope prob in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_Compiler_List.map
-                        (fun b -> b.FStar_Syntax_Syntax.binder_bv)) uu___5 in
-                 FStar_TypeChecker_Env.def_check_closed_in (p_loc prob)
-                   uu___3 uu___4 phi2);
-                set_uvar wl.tcenv uv FStar_Pervasives_Native.None phi2) in
-             let uv = p_guard_uvar prob in
-             let fail uu___1 =
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Print.ctx_uvar_to_string uv in
-                 let uu___4 =
-                   FStar_Syntax_Print.term_to_string (p_guard prob) in
-                 FStar_Compiler_Util.format2
-                   "Impossible: this instance %s has already been assigned a solution\n%s\n"
-                   uu___3 uu___4 in
-               failwith uu___2 in
-             let args_as_binders args =
-               FStar_Compiler_Effect.op_Bar_Greater args
-                 (FStar_Compiler_List.collect
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | (a, i) ->
-                           let uu___2 =
-                             let uu___3 = FStar_Syntax_Subst.compress a in
-                             uu___3.FStar_Syntax_Syntax.n in
-                           (match uu___2 with
-                            | FStar_Syntax_Syntax.Tm_name x ->
-                                let uu___3 =
-                                  FStar_Syntax_Util.bqual_and_attrs_of_aqual
-                                    i in
-                                (match uu___3 with
-                                 | (q, attrs) ->
-                                     let uu___4 =
-                                       FStar_Syntax_Syntax.mk_binder_with_attrs
-                                         x q attrs in
-                                     [uu___4])
-                            | uu___3 -> (fail (); [])))) in
-             let wl1 =
-               let g = whnf wl.tcenv (p_guard prob) in
-               let uu___1 =
-                 let uu___2 = is_flex g in Prims.op_Negation uu___2 in
-               if uu___1
-               then (if resolve_ok then wl else (fail (); wl))
-               else
-                 (let uu___3 = destruct_flex_t g wl in
-                  match uu___3 with
-                  | (Flex (uu___4, uv1, args), wl2) ->
-                      ((let uu___6 = args_as_binders args in
-                        assign_solution uu___6 uv1 phi);
-                       wl2)) in
-             commit wl1.tcenv uvis;
-             {
-               attempting = (wl1.attempting);
-               wl_deferred = (wl1.wl_deferred);
-               wl_deferred_to_tac = (wl1.wl_deferred_to_tac);
-               ctr = (wl1.ctr + Prims.int_one);
-               defer_ok = (wl1.defer_ok);
-               smt_ok = (wl1.smt_ok);
-               umax_heuristic_ok = (wl1.umax_heuristic_ok);
-               tcenv = (wl1.tcenv);
-               wl_implicits = (wl1.wl_implicits);
-               repr_subcomp_allowed = (wl1.repr_subcomp_allowed)
-             })
-let (extend_universe_solution :
-  Prims.int -> uvi Prims.list -> worklist -> worklist) =
-  fun pid ->
-    fun sol ->
-      fun wl ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar (debug wl)
-             (FStar_Options.Other "Rel") in
-         if uu___1
-         then
-           let uu___2 = FStar_Compiler_Util.string_of_int pid in
-           let uu___3 = uvis_to_string wl.tcenv sol in
-           FStar_Compiler_Util.print2 "Solving %s: with [%s]\n" uu___2 uu___3
-         else ());
-        commit wl.tcenv sol;
-        {
-          attempting = (wl.attempting);
-          wl_deferred = (wl.wl_deferred);
-          wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-          ctr = (wl.ctr + Prims.int_one);
-          defer_ok = (wl.defer_ok);
-          smt_ok = (wl.smt_ok);
-          umax_heuristic_ok = (wl.umax_heuristic_ok);
-          tcenv = (wl.tcenv);
-          wl_implicits = (wl.wl_implicits);
-          repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-        }
-let (solve_prob :
-  FStar_TypeChecker_Common.prob ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-      uvi Prims.list -> worklist -> worklist)
-  =
-  fun prob ->
-    fun logical_guard ->
-      fun uvis ->
-        fun wl ->
-          def_check_prob "solve_prob.prob" prob;
-          FStar_Compiler_Util.iter_opt logical_guard
-            (def_check_scoped "solve_prob.guard" prob);
-          (let uu___3 =
-             FStar_Compiler_Effect.op_Less_Bar (debug wl)
-               (FStar_Options.Other "Rel") in
-           if uu___3
-           then
-             let uu___4 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 FStar_Compiler_Util.string_of_int (p_pid prob) in
-             let uu___5 = uvis_to_string wl.tcenv uvis in
-             FStar_Compiler_Util.print2 "Solving %s: with %s\n" uu___4 uu___5
-           else ());
-          solve_prob' false prob logical_guard uvis wl
-let (occurs :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.ctx_uvar Prims.list * Prims.bool))
-  =
-  fun uk ->
-    fun t ->
-      let uvars =
-        let uu___ = FStar_Syntax_Free.uvars t in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          FStar_Compiler_Util.set_elements in
-      let occurs1 =
-        FStar_Compiler_Effect.op_Bar_Greater uvars
-          (FStar_Compiler_Util.for_some
-             (fun uv ->
-                FStar_Syntax_Unionfind.equiv
-                  uv.FStar_Syntax_Syntax.ctx_uvar_head
-                  uk.FStar_Syntax_Syntax.ctx_uvar_head)) in
-      (uvars, occurs1)
-let (occurs_check :
-  FStar_Syntax_Syntax.ctx_uvar ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.ctx_uvar Prims.list * Prims.bool * Prims.string
-        FStar_Pervasives_Native.option))
-  =
-  fun uk ->
-    fun t ->
-      let uu___ = occurs uk t in
-      match uu___ with
-      | (uvars, occurs1) ->
-          let msg =
-            if Prims.op_Negation occurs1
-            then FStar_Pervasives_Native.None
-            else
-              (let uu___2 =
-                 let uu___3 =
-                   FStar_Syntax_Print.uvar_to_string
-                     uk.FStar_Syntax_Syntax.ctx_uvar_head in
-                 let uu___4 = FStar_Syntax_Print.term_to_string t in
-                 FStar_Compiler_Util.format2
-                   "occurs-check failed (%s occurs in %s)" uu___3 uu___4 in
-               FStar_Pervasives_Native.Some uu___2) in
-          (uvars, (Prims.op_Negation occurs1), msg)
-let (occurs_full :
-  FStar_Syntax_Syntax.ctx_uvar -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun uk ->
-    fun t ->
-      let uvars =
-        let uu___ = FStar_Syntax_Free.uvars_full t in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          FStar_Compiler_Util.set_elements in
-      let occurs1 =
-        FStar_Compiler_Effect.op_Bar_Greater uvars
-          (FStar_Compiler_Util.for_some
-             (fun uv ->
-                FStar_Syntax_Unionfind.equiv
-                  uv.FStar_Syntax_Syntax.ctx_uvar_head
-                  uk.FStar_Syntax_Syntax.ctx_uvar_head)) in
-      occurs1
-let rec (maximal_prefix :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.binders ->
-      (FStar_Syntax_Syntax.binders * (FStar_Syntax_Syntax.binders *
-        FStar_Syntax_Syntax.binders)))
-  =
-  fun bs ->
-    fun bs' ->
-      match (bs, bs') with
-      | (binder1::bs_tail,
-         { FStar_Syntax_Syntax.binder_bv = b';
-           FStar_Syntax_Syntax.binder_qual = i';
-           FStar_Syntax_Syntax.binder_attrs = uu___;_}::bs'_tail)
-          ->
-          let uu___1 =
-            FStar_Syntax_Syntax.bv_eq binder1.FStar_Syntax_Syntax.binder_bv
-              b' in
-          if uu___1
-          then
-            let uu___2 = maximal_prefix bs_tail bs'_tail in
-            (match uu___2 with | (pfx, rest) -> ((binder1 :: pfx), rest))
-          else ([], (bs, bs'))
-      | uu___ -> ([], (bs, bs'))
-let (extend_gamma :
-  FStar_Syntax_Syntax.gamma ->
-    FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binding Prims.list)
-  =
-  fun g ->
-    fun bs ->
-      FStar_Compiler_List.fold_left
-        (fun g1 ->
-           fun uu___ ->
-             match uu___ with
-             | { FStar_Syntax_Syntax.binder_bv = x;
-                 FStar_Syntax_Syntax.binder_qual = uu___1;
-                 FStar_Syntax_Syntax.binder_attrs = uu___2;_} ->
-                 (FStar_Syntax_Syntax.Binding_var x) :: g1) g bs
-let (gamma_until :
-  FStar_Syntax_Syntax.gamma ->
-    FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binding Prims.list)
-  =
-  fun g ->
-    fun bs ->
-      let uu___ = FStar_Compiler_List.last_opt bs in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> []
-      | FStar_Pervasives_Native.Some
-          { FStar_Syntax_Syntax.binder_bv = x;
-            FStar_Syntax_Syntax.binder_qual = uu___1;
-            FStar_Syntax_Syntax.binder_attrs = uu___2;_}
-          ->
-          let uu___3 =
-            FStar_Compiler_Util.prefix_until
-              (fun uu___4 ->
-                 match uu___4 with
-                 | FStar_Syntax_Syntax.Binding_var x' ->
-                     FStar_Syntax_Syntax.bv_eq x x'
-                 | uu___5 -> false) g in
-          (match uu___3 with
-           | FStar_Pervasives_Native.None -> []
-           | FStar_Pervasives_Native.Some (uu___4, bx, rest) -> bx :: rest)
-let restrict_ctx :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Syntax_Syntax.ctx_uvar ->
-        FStar_Syntax_Syntax.binders ->
-          FStar_Syntax_Syntax.ctx_uvar -> worklist -> worklist
-  =
-  fun env ->
-    fun tgt ->
-      fun bs ->
-        fun src ->
-          fun wl ->
-            let uu___ =
-              maximal_prefix tgt.FStar_Syntax_Syntax.ctx_uvar_binders
-                src.FStar_Syntax_Syntax.ctx_uvar_binders in
-            match uu___ with
-            | (pfx, uu___1) ->
-                let g =
-                  gamma_until src.FStar_Syntax_Syntax.ctx_uvar_gamma pfx in
-                let aux t f =
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Syntax_Print.uvar_to_string
-                          src.FStar_Syntax_Syntax.ctx_uvar_head in
-                      Prims.op_Hat "restricted " uu___4 in
-                    let uu___4 = FStar_Syntax_Util.ctx_uvar_should_check src in
-                    new_uvar uu___3 wl src.FStar_Syntax_Syntax.ctx_uvar_range
-                      g pfx t uu___4 src.FStar_Syntax_Syntax.ctx_uvar_meta in
-                  match uu___2 with
-                  | (uu___3, src', wl1) ->
-                      ((let uu___5 = f src' in
-                        set_uvar env src
-                          (FStar_Pervasives_Native.Some
-                             FStar_Syntax_Syntax.Already_checked) uu___5);
-                       wl1) in
-                let bs1 =
-                  FStar_Compiler_Effect.op_Bar_Greater bs
-                    (FStar_Compiler_List.filter
-                       (fun uu___2 ->
-                          match uu___2 with
-                          | { FStar_Syntax_Syntax.binder_bv = bv1;
-                              FStar_Syntax_Syntax.binder_qual = uu___3;
-                              FStar_Syntax_Syntax.binder_attrs = uu___4;_} ->
-                              (FStar_Compiler_Effect.op_Bar_Greater
-                                 src.FStar_Syntax_Syntax.ctx_uvar_binders
-                                 (FStar_Compiler_List.existsb
-                                    (fun uu___5 ->
-                                       match uu___5 with
-                                       | {
-                                           FStar_Syntax_Syntax.binder_bv =
-                                             bv2;
-                                           FStar_Syntax_Syntax.binder_qual =
-                                             uu___6;
-                                           FStar_Syntax_Syntax.binder_attrs =
-                                             uu___7;_}
-                                           ->
-                                           FStar_Syntax_Syntax.bv_eq bv1 bv2)))
-                                &&
-                                (let uu___5 =
-                                   FStar_Compiler_Effect.op_Bar_Greater pfx
-                                     (FStar_Compiler_List.existsb
-                                        (fun uu___6 ->
-                                           match uu___6 with
-                                           | {
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 = bv2;
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 = uu___7;
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 = uu___8;_}
-                                               ->
-                                               FStar_Syntax_Syntax.bv_eq bv1
-                                                 bv2)) in
-                                 Prims.op_Negation uu___5))) in
-                if (FStar_Compiler_List.length bs1) = Prims.int_zero
-                then
-                  let uu___2 = FStar_Syntax_Util.ctx_uvar_typ src in
-                  aux uu___2 (fun src' -> src')
-                else
-                  (let uu___3 =
-                     let t = FStar_Syntax_Util.ctx_uvar_typ src in
-                     let uu___4 =
-                       FStar_Compiler_Effect.op_Bar_Greater t
-                         FStar_Syntax_Syntax.mk_Total in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___4
-                       (FStar_Syntax_Util.arrow bs1) in
-                   aux uu___3
-                     (fun src' ->
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_Compiler_Effect.op_Bar_Greater bs1
-                              FStar_Syntax_Syntax.binders_to_names in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            (FStar_Compiler_List.map
-                               FStar_Syntax_Syntax.as_arg) in
-                        FStar_Syntax_Syntax.mk_Tm_app src' uu___4
-                          src.FStar_Syntax_Syntax.ctx_uvar_range))
-let restrict_all_uvars :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Syntax_Syntax.ctx_uvar ->
-        FStar_Syntax_Syntax.binders ->
-          FStar_Syntax_Syntax.ctx_uvar Prims.list -> worklist -> worklist
-  =
-  fun env ->
-    fun tgt ->
-      fun bs ->
-        fun sources ->
-          fun wl ->
-            match bs with
-            | [] ->
-                let ctx_tgt =
-                  binders_as_bv_set tgt.FStar_Syntax_Syntax.ctx_uvar_binders in
-                FStar_Compiler_List.fold_right
-                  (fun src ->
-                     fun wl1 ->
-                       let ctx_src =
-                         binders_as_bv_set
-                           src.FStar_Syntax_Syntax.ctx_uvar_binders in
-                       let uu___ =
-                         FStar_Compiler_Util.set_is_subset_of ctx_src ctx_tgt in
-                       if uu___ then wl1 else restrict_ctx env tgt [] src wl1)
-                  sources wl
-            | uu___ ->
-                FStar_Compiler_List.fold_right (restrict_ctx env tgt bs)
-                  sources wl
-let (intersect_binders :
-  FStar_Syntax_Syntax.gamma ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders)
-  =
-  fun g ->
-    fun v1 ->
-      fun v2 ->
-        let as_set v =
-          FStar_Compiler_Effect.op_Bar_Greater v
-            (FStar_Compiler_List.fold_left
-               (fun out ->
-                  fun x ->
-                    FStar_Compiler_Util.set_add
-                      x.FStar_Syntax_Syntax.binder_bv out)
-               FStar_Syntax_Syntax.no_names) in
-        let v1_set = as_set v1 in
-        let ctx_binders =
-          FStar_Compiler_List.fold_left
-            (fun out ->
-               fun b ->
-                 match b with
-                 | FStar_Syntax_Syntax.Binding_var x ->
-                     FStar_Compiler_Util.set_add x out
-                 | uu___ -> out) FStar_Syntax_Syntax.no_names g in
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater v2
-            (FStar_Compiler_List.fold_left
-               (fun uu___1 ->
-                  fun b ->
-                    match uu___1 with
-                    | (isect, isect_set) ->
-                        let uu___2 =
-                          ((b.FStar_Syntax_Syntax.binder_bv),
-                            (b.FStar_Syntax_Syntax.binder_qual)) in
-                        (match uu___2 with
-                         | (x, imp) ->
-                             let uu___3 =
-                               let uu___4 =
-                                 FStar_Compiler_Util.set_mem x v1_set in
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 Prims.op_Negation uu___4 in
-                             if uu___3
-                             then (isect, isect_set)
-                             else
-                               (let fvs =
-                                  FStar_Syntax_Free.names
-                                    x.FStar_Syntax_Syntax.sort in
-                                let uu___5 =
-                                  FStar_Compiler_Util.set_is_subset_of fvs
-                                    isect_set in
-                                if uu___5
-                                then
-                                  let uu___6 =
-                                    FStar_Compiler_Util.set_add x isect_set in
-                                  ((b :: isect), uu___6)
-                                else (isect, isect_set)))) ([], ctx_binders)) in
-        match uu___ with | (isect, uu___1) -> FStar_Compiler_List.rev isect
-let (binders_eq :
-  FStar_Syntax_Syntax.binder Prims.list ->
-    FStar_Syntax_Syntax.binder Prims.list -> Prims.bool)
-  =
-  fun v1 ->
-    fun v2 ->
-      ((FStar_Compiler_List.length v1) = (FStar_Compiler_List.length v2)) &&
-        (FStar_Compiler_List.forall2
-           (fun uu___ ->
-              fun uu___1 ->
-                match (uu___, uu___1) with
-                | ({ FStar_Syntax_Syntax.binder_bv = a;
-                     FStar_Syntax_Syntax.binder_qual = uu___2;
-                     FStar_Syntax_Syntax.binder_attrs = uu___3;_},
-                   { FStar_Syntax_Syntax.binder_bv = b;
-                     FStar_Syntax_Syntax.binder_qual = uu___4;
-                     FStar_Syntax_Syntax.binder_attrs = uu___5;_})
-                    -> FStar_Syntax_Syntax.bv_eq a b) v1 v2)
-let (name_exists_in_binders :
-  FStar_Syntax_Syntax.bv ->
-    FStar_Syntax_Syntax.binder Prims.list -> Prims.bool)
-  =
-  fun x ->
-    fun bs ->
-      FStar_Compiler_Util.for_some
-        (fun uu___ ->
-           match uu___ with
-           | { FStar_Syntax_Syntax.binder_bv = y;
-               FStar_Syntax_Syntax.binder_qual = uu___1;
-               FStar_Syntax_Syntax.binder_attrs = uu___2;_} ->
-               FStar_Syntax_Syntax.bv_eq x y) bs
-let (pat_vars :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binder Prims.list ->
-      (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.aqual) Prims.list ->
-        FStar_Syntax_Syntax.binders FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun ctx ->
-      fun args ->
-        let rec aux seen args1 =
-          match args1 with
-          | [] -> FStar_Pervasives_Native.Some (FStar_Compiler_List.rev seen)
-          | (arg, i)::args2 ->
-              let hd = sn env arg in
-              (match hd.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_name a ->
-                   let uu___ =
-                     (name_exists_in_binders a seen) ||
-                       (name_exists_in_binders a ctx) in
-                   if uu___
-                   then FStar_Pervasives_Native.None
-                   else
-                     (let uu___2 =
-                        FStar_Syntax_Util.bqual_and_attrs_of_aqual i in
-                      match uu___2 with
-                      | (bq, attrs) ->
-                          let uu___3 =
-                            let uu___4 =
-                              FStar_Syntax_Syntax.mk_binder_with_attrs a bq
-                                attrs in
-                            uu___4 :: seen in
-                          aux uu___3 args2)
-               | uu___ -> FStar_Pervasives_Native.None) in
-        aux [] args
-let (string_of_match_result : match_result -> Prims.string) =
-  fun uu___ ->
-    match uu___ with
-    | MisMatch (d1, d2) ->
-        let uu___1 =
-          let uu___2 =
-            FStar_Common.string_of_option
-              FStar_Syntax_Print.delta_depth_to_string d1 in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                FStar_Common.string_of_option
-                  FStar_Syntax_Print.delta_depth_to_string d2 in
-              Prims.op_Hat uu___5 ")" in
-            Prims.op_Hat ") (" uu___4 in
-          Prims.op_Hat uu___2 uu___3 in
-        Prims.op_Hat "MisMatch (" uu___1
-    | HeadMatch u ->
-        let uu___1 = FStar_Compiler_Util.string_of_bool u in
-        Prims.op_Hat "HeadMatch " uu___1
-    | FullMatch -> "FullMatch"
-let (head_match : match_result -> match_result) =
-  fun uu___ ->
-    match uu___ with
-    | MisMatch (i, j) -> MisMatch (i, j)
-    | HeadMatch (true) -> HeadMatch true
-    | uu___1 -> HeadMatch false
-let (fv_delta_depth :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.fv -> FStar_Syntax_Syntax.delta_depth)
-  =
-  fun env ->
-    fun fv ->
-      let d = FStar_TypeChecker_Env.delta_depth_of_fv env fv in
-      match d with
-      | FStar_Syntax_Syntax.Delta_abstract d1 ->
-          let uu___ =
-            (let uu___1 =
-               FStar_Ident.string_of_lid env.FStar_TypeChecker_Env.curmodule in
-             let uu___2 =
-               FStar_Ident.nsstr
-                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-             uu___1 = uu___2) &&
-              (Prims.op_Negation env.FStar_TypeChecker_Env.is_iface) in
-          if uu___ then d1 else FStar_Syntax_Syntax.delta_constant
-      | FStar_Syntax_Syntax.Delta_constant_at_level i when i > Prims.int_zero
-          ->
-          let uu___ =
-            FStar_TypeChecker_Env.lookup_definition
-              [FStar_TypeChecker_Env.Unfold
-                 FStar_Syntax_Syntax.delta_constant] env
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___ with
-           | FStar_Pervasives_Native.None ->
-               FStar_Syntax_Syntax.delta_constant
-           | uu___1 -> d)
-      | d1 -> d1
-let rec (delta_depth_of_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.delta_depth FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t ->
-      let t1 = FStar_Syntax_Util.unmeta t in
-      match t1.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_meta uu___ ->
-          failwith "Impossible (delta depth of term)"
-      | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-          failwith "Impossible (delta depth of term)"
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___ = FStar_Syntax_Util.unfold_lazy i in
-          delta_depth_of_term env uu___
-      | FStar_Syntax_Syntax.Tm_unknown -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_bvar uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_name uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_uvar uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_let uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_match uu___ -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_uinst (t2, uu___) ->
-          delta_depth_of_term env t2
-      | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___, uu___1) ->
-          delta_depth_of_term env t2
-      | FStar_Syntax_Syntax.Tm_app (t2, uu___) -> delta_depth_of_term env t2
-      | FStar_Syntax_Syntax.Tm_refine
-          ({ FStar_Syntax_Syntax.ppname = uu___;
-             FStar_Syntax_Syntax.index = uu___1;
-             FStar_Syntax_Syntax.sort = t2;_},
-           uu___2)
-          -> delta_depth_of_term env t2
-      | FStar_Syntax_Syntax.Tm_constant uu___ ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.delta_constant
-      | FStar_Syntax_Syntax.Tm_type uu___ ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.delta_constant
-      | FStar_Syntax_Syntax.Tm_arrow uu___ ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.delta_constant
-      | FStar_Syntax_Syntax.Tm_quoted uu___ ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.delta_constant
-      | FStar_Syntax_Syntax.Tm_abs uu___ ->
-          FStar_Pervasives_Native.Some FStar_Syntax_Syntax.delta_constant
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let uu___ = fv_delta_depth env fv in
-          FStar_Pervasives_Native.Some uu___
-let (universe_has_max :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.universe -> Prims.bool) =
-  fun env ->
-    fun u ->
-      let u1 = FStar_TypeChecker_Normalize.normalize_universe env u in
-      match u1 with
-      | FStar_Syntax_Syntax.U_max uu___ -> true
-      | uu___ -> false
-let rec (head_matches :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term -> match_result)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        let t11 = FStar_Syntax_Util.unmeta t1 in
-        let t21 = FStar_Syntax_Util.unmeta t2 in
-        match ((t11.FStar_Syntax_Syntax.n), (t21.FStar_Syntax_Syntax.n)) with
-        | (FStar_Syntax_Syntax.Tm_lazy
-           { FStar_Syntax_Syntax.blob = uu___;
-             FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_embedding
-               uu___1;
-             FStar_Syntax_Syntax.ltyp = uu___2;
-             FStar_Syntax_Syntax.rng = uu___3;_},
-           uu___4) ->
-            let uu___5 = FStar_Syntax_Util.unlazy t11 in
-            head_matches env uu___5 t21
-        | (uu___, FStar_Syntax_Syntax.Tm_lazy
-           { FStar_Syntax_Syntax.blob = uu___1;
-             FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_embedding
-               uu___2;
-             FStar_Syntax_Syntax.ltyp = uu___3;
-             FStar_Syntax_Syntax.rng = uu___4;_})
-            ->
-            let uu___5 = FStar_Syntax_Util.unlazy t21 in
-            head_matches env t11 uu___5
-        | (FStar_Syntax_Syntax.Tm_name x, FStar_Syntax_Syntax.Tm_name y) ->
-            let uu___ = FStar_Syntax_Syntax.bv_eq x y in
-            if uu___
-            then FullMatch
-            else
-              MisMatch
-                (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None)
-        | (FStar_Syntax_Syntax.Tm_fvar f, FStar_Syntax_Syntax.Tm_fvar g) ->
-            let uu___ = FStar_Syntax_Syntax.fv_eq f g in
-            if uu___
-            then FullMatch
-            else
-              (let uu___2 =
-                 let uu___3 =
-                   let uu___4 = fv_delta_depth env f in
-                   FStar_Pervasives_Native.Some uu___4 in
-                 let uu___4 =
-                   let uu___5 = fv_delta_depth env g in
-                   FStar_Pervasives_Native.Some uu___5 in
-                 (uu___3, uu___4) in
-               MisMatch uu___2)
-        | (FStar_Syntax_Syntax.Tm_uinst (f, uu___),
-           FStar_Syntax_Syntax.Tm_uinst (g, uu___1)) ->
-            let uu___2 = head_matches env f g in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify),
-           FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify)) ->
-            FullMatch
-        | (FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify), uu___)
-            -> HeadMatch true
-        | (uu___, FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify))
-            -> HeadMatch true
-        | (FStar_Syntax_Syntax.Tm_constant c, FStar_Syntax_Syntax.Tm_constant
-           d) ->
-            let uu___ = FStar_Const.eq_const c d in
-            if uu___
-            then FullMatch
-            else
-              MisMatch
-                (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None)
-        | (FStar_Syntax_Syntax.Tm_uvar (uv, uu___),
-           FStar_Syntax_Syntax.Tm_uvar (uv', uu___1)) ->
-            let uu___2 =
-              FStar_Syntax_Unionfind.equiv
-                uv.FStar_Syntax_Syntax.ctx_uvar_head
-                uv'.FStar_Syntax_Syntax.ctx_uvar_head in
-            if uu___2
-            then FullMatch
-            else
-              MisMatch
-                (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None)
-        | (FStar_Syntax_Syntax.Tm_refine (x, uu___),
-           FStar_Syntax_Syntax.Tm_refine (y, uu___1)) ->
-            let uu___2 =
-              head_matches env x.FStar_Syntax_Syntax.sort
-                y.FStar_Syntax_Syntax.sort in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (FStar_Syntax_Syntax.Tm_refine (x, uu___), uu___1) ->
-            let uu___2 = head_matches env x.FStar_Syntax_Syntax.sort t21 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (uu___, FStar_Syntax_Syntax.Tm_refine (x, uu___1)) ->
-            let uu___2 = head_matches env t11 x.FStar_Syntax_Syntax.sort in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (FStar_Syntax_Syntax.Tm_type uu___, FStar_Syntax_Syntax.Tm_type
-           uu___1) -> HeadMatch false
-        | (FStar_Syntax_Syntax.Tm_arrow uu___, FStar_Syntax_Syntax.Tm_arrow
-           uu___1) -> HeadMatch false
-        | (FStar_Syntax_Syntax.Tm_app (head, uu___),
-           FStar_Syntax_Syntax.Tm_app (head', uu___1)) ->
-            let uu___2 = head_matches env head head' in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (FStar_Syntax_Syntax.Tm_app (head, uu___), uu___1) ->
-            let uu___2 = head_matches env head t21 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (uu___, FStar_Syntax_Syntax.Tm_app (head, uu___1)) ->
-            let uu___2 = head_matches env t11 head in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2 head_match
-        | (FStar_Syntax_Syntax.Tm_let uu___, FStar_Syntax_Syntax.Tm_let
-           uu___1) -> HeadMatch true
-        | (FStar_Syntax_Syntax.Tm_match uu___, FStar_Syntax_Syntax.Tm_match
-           uu___1) -> HeadMatch true
-        | (FStar_Syntax_Syntax.Tm_abs uu___, FStar_Syntax_Syntax.Tm_abs
-           uu___1) -> HeadMatch true
-        | uu___ ->
-            let uu___1 =
-              let uu___2 = delta_depth_of_term env t11 in
-              let uu___3 = delta_depth_of_term env t21 in (uu___2, uu___3) in
-            MisMatch uu___1
-let (head_matches_delta :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.typ ->
-          (match_result * (FStar_Syntax_Syntax.typ * FStar_Syntax_Syntax.typ)
-            FStar_Pervasives_Native.option))
-  =
-  fun env ->
-    fun smt_ok ->
-      fun t1 ->
-        fun t2 ->
-          let maybe_inline t =
-            let head =
-              let uu___ = unrefine env t in FStar_Syntax_Util.head_of uu___ in
-            (let uu___1 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env)
-                 (FStar_Options.Other "RelDelta") in
-             if uu___1
-             then
-               let uu___2 = FStar_Syntax_Print.term_to_string t in
-               let uu___3 = FStar_Syntax_Print.term_to_string head in
-               FStar_Compiler_Util.print2 "Head of %s is %s\n" uu___2 uu___3
-             else ());
-            (let uu___1 =
-               let uu___2 = FStar_Syntax_Util.un_uinst head in
-               uu___2.FStar_Syntax_Syntax.n in
-             match uu___1 with
-             | FStar_Syntax_Syntax.Tm_fvar fv ->
-                 let uu___2 =
-                   FStar_TypeChecker_Env.lookup_definition
-                     [FStar_TypeChecker_Env.Unfold
-                        FStar_Syntax_Syntax.delta_constant;
-                     FStar_TypeChecker_Env.Eager_unfolding_only] env
-                     (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                 (match uu___2 with
-                  | FStar_Pervasives_Native.None ->
-                      ((let uu___4 =
-                          FStar_Compiler_Effect.op_Less_Bar
-                            (FStar_TypeChecker_Env.debug env)
-                            (FStar_Options.Other "RelDelta") in
-                        if uu___4
-                        then
-                          let uu___5 = FStar_Syntax_Print.term_to_string head in
-                          FStar_Compiler_Util.print1
-                            "No definition found for %s\n" uu___5
-                        else ());
-                       FStar_Pervasives_Native.None)
-                  | FStar_Pervasives_Native.Some uu___3 ->
-                      let basic_steps =
-                        [FStar_TypeChecker_Env.UnfoldUntil
-                           FStar_Syntax_Syntax.delta_constant;
-                        FStar_TypeChecker_Env.Weak;
-                        FStar_TypeChecker_Env.HNF;
-                        FStar_TypeChecker_Env.Primops;
-                        FStar_TypeChecker_Env.Beta;
-                        FStar_TypeChecker_Env.Eager_unfolding;
-                        FStar_TypeChecker_Env.Iota] in
-                      let steps =
-                        if smt_ok
-                        then basic_steps
-                        else
-                          (FStar_TypeChecker_Env.Exclude
-                             FStar_TypeChecker_Env.Zeta)
-                          :: basic_steps in
-                      let t' =
-                        norm_with_steps
-                          "FStar.TypeChecker.Rel.norm_with_steps.1" steps env
-                          t in
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Util.eq_tm t t' in
-                        uu___5 = FStar_Syntax_Util.Equal in
-                      if uu___4
-                      then FStar_Pervasives_Native.None
-                      else
-                        ((let uu___7 =
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_TypeChecker_Env.debug env)
-                              (FStar_Options.Other "RelDelta") in
-                          if uu___7
-                          then
-                            let uu___8 = FStar_Syntax_Print.term_to_string t in
-                            let uu___9 = FStar_Syntax_Print.term_to_string t' in
-                            FStar_Compiler_Util.print2 "Inlined %s to %s\n"
-                              uu___8 uu___9
-                          else ());
-                         FStar_Pervasives_Native.Some t'))
-             | uu___2 -> FStar_Pervasives_Native.None) in
-          let success d r t11 t21 =
-            (r,
-              (if d > Prims.int_zero
-               then FStar_Pervasives_Native.Some (t11, t21)
-               else FStar_Pervasives_Native.None)) in
-          let fail d r t11 t21 =
-            (r,
-              (if d > Prims.int_zero
-               then FStar_Pervasives_Native.Some (t11, t21)
-               else FStar_Pervasives_Native.None)) in
-          let made_progress t t' =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Util.head_and_args t in
-                FStar_Compiler_Effect.op_Bar_Greater uu___2
-                  FStar_Pervasives_Native.fst in
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.head_and_args t' in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Pervasives_Native.fst in
-              (uu___1, uu___2) in
-            match uu___ with
-            | (head, head') ->
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Util.eq_tm head head' in
-                  uu___2 = FStar_Syntax_Util.Equal in
-                Prims.op_Negation uu___1 in
-          let rec aux retry n_delta t11 t21 =
-            let r = head_matches env t11 t21 in
-            (let uu___1 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env)
-                 (FStar_Options.Other "RelDelta") in
-             if uu___1
-             then
-               let uu___2 = FStar_Syntax_Print.term_to_string t11 in
-               let uu___3 = FStar_Syntax_Print.term_to_string t21 in
-               let uu___4 = string_of_match_result r in
-               FStar_Compiler_Util.print3 "head_matches (%s, %s) = %s\n"
-                 uu___2 uu___3 uu___4
-             else ());
-            (let reduce_one_and_try_again d1 d2 =
-               let d1_greater_than_d2 =
-                 FStar_TypeChecker_Common.delta_depth_greater_than d1 d2 in
-               let uu___1 =
-                 if d1_greater_than_d2
-                 then
-                   let t1' =
-                     normalize_refinement
-                       [FStar_TypeChecker_Env.UnfoldUntil d2;
-                       FStar_TypeChecker_Env.Weak;
-                       FStar_TypeChecker_Env.HNF] env t11 in
-                   let uu___2 = made_progress t11 t1' in (t1', t21, uu___2)
-                 else
-                   (let t2' =
-                      normalize_refinement
-                        [FStar_TypeChecker_Env.UnfoldUntil d1;
-                        FStar_TypeChecker_Env.Weak;
-                        FStar_TypeChecker_Env.HNF] env t21 in
-                    let uu___3 = made_progress t21 t2' in (t11, t2', uu___3)) in
-               match uu___1 with
-               | (t12, t22, made_progress1) ->
-                   if made_progress1
-                   then aux retry (n_delta + Prims.int_one) t12 t22
-                   else fail n_delta r t12 t22 in
-             let reduce_both_and_try_again d r1 =
-               let uu___1 = FStar_TypeChecker_Common.decr_delta_depth d in
-               match uu___1 with
-               | FStar_Pervasives_Native.None -> fail n_delta r1 t11 t21
-               | FStar_Pervasives_Native.Some d1 ->
-                   let t1' =
-                     normalize_refinement
-                       [FStar_TypeChecker_Env.UnfoldUntil d1;
-                       FStar_TypeChecker_Env.Weak;
-                       FStar_TypeChecker_Env.HNF] env t11 in
-                   let t2' =
-                     normalize_refinement
-                       [FStar_TypeChecker_Env.UnfoldUntil d1;
-                       FStar_TypeChecker_Env.Weak;
-                       FStar_TypeChecker_Env.HNF] env t21 in
-                   let uu___2 =
-                     (made_progress t11 t1') && (made_progress t21 t2') in
-                   if uu___2
-                   then aux retry (n_delta + Prims.int_one) t1' t2'
-                   else fail n_delta r1 t11 t21 in
-             match r with
-             | MisMatch
-                 (FStar_Pervasives_Native.Some
-                  (FStar_Syntax_Syntax.Delta_equational_at_level i),
-                  FStar_Pervasives_Native.Some
-                  (FStar_Syntax_Syntax.Delta_equational_at_level j))
-                 when
-                 ((i > Prims.int_zero) || (j > Prims.int_zero)) && (i <> j)
-                 ->
-                 reduce_one_and_try_again
-                   (FStar_Syntax_Syntax.Delta_equational_at_level i)
-                   (FStar_Syntax_Syntax.Delta_equational_at_level j)
-             | MisMatch
-                 (FStar_Pervasives_Native.Some
-                  (FStar_Syntax_Syntax.Delta_equational_at_level uu___1),
-                  uu___2)
-                 ->
-                 if Prims.op_Negation retry
-                 then fail n_delta r t11 t21
-                 else
-                   (let uu___4 =
-                      let uu___5 = maybe_inline t11 in
-                      let uu___6 = maybe_inline t21 in (uu___5, uu___6) in
-                    match uu___4 with
-                    | (FStar_Pervasives_Native.None,
-                       FStar_Pervasives_Native.None) ->
-                        fail n_delta r t11 t21
-                    | (FStar_Pervasives_Native.Some t12,
-                       FStar_Pervasives_Native.None) ->
-                        aux false (n_delta + Prims.int_one) t12 t21
-                    | (FStar_Pervasives_Native.None,
-                       FStar_Pervasives_Native.Some t22) ->
-                        aux false (n_delta + Prims.int_one) t11 t22
-                    | (FStar_Pervasives_Native.Some t12,
-                       FStar_Pervasives_Native.Some t22) ->
-                        aux false (n_delta + Prims.int_one) t12 t22)
-             | MisMatch
-                 (uu___1, FStar_Pervasives_Native.Some
-                  (FStar_Syntax_Syntax.Delta_equational_at_level uu___2))
-                 ->
-                 if Prims.op_Negation retry
-                 then fail n_delta r t11 t21
-                 else
-                   (let uu___4 =
-                      let uu___5 = maybe_inline t11 in
-                      let uu___6 = maybe_inline t21 in (uu___5, uu___6) in
-                    match uu___4 with
-                    | (FStar_Pervasives_Native.None,
-                       FStar_Pervasives_Native.None) ->
-                        fail n_delta r t11 t21
-                    | (FStar_Pervasives_Native.Some t12,
-                       FStar_Pervasives_Native.None) ->
-                        aux false (n_delta + Prims.int_one) t12 t21
-                    | (FStar_Pervasives_Native.None,
-                       FStar_Pervasives_Native.Some t22) ->
-                        aux false (n_delta + Prims.int_one) t11 t22
-                    | (FStar_Pervasives_Native.Some t12,
-                       FStar_Pervasives_Native.Some t22) ->
-                        aux false (n_delta + Prims.int_one) t12 t22)
-             | MisMatch
-                 (FStar_Pervasives_Native.Some d1,
-                  FStar_Pervasives_Native.Some d2)
-                 when d1 = d2 -> reduce_both_and_try_again d1 r
-             | MisMatch
-                 (FStar_Pervasives_Native.Some d1,
-                  FStar_Pervasives_Native.Some d2)
-                 -> reduce_one_and_try_again d1 d2
-             | MisMatch uu___1 -> fail n_delta r t11 t21
-             | uu___1 -> success n_delta r t11 t21) in
-          let r = aux true Prims.int_zero t1 t2 in
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_TypeChecker_Env.debug env)
-               (FStar_Options.Other "RelDelta") in
-           if uu___1
-           then
-             let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-             let uu___3 = FStar_Syntax_Print.term_to_string t2 in
-             let uu___4 =
-               string_of_match_result (FStar_Pervasives_Native.fst r) in
-             let uu___5 =
-               if
-                 FStar_Compiler_Option.isNone (FStar_Pervasives_Native.snd r)
-               then "None"
-               else
-                 (let uu___7 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      (FStar_Pervasives_Native.snd r)
-                      FStar_Compiler_Util.must in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___7
-                    (fun uu___8 ->
-                       match uu___8 with
-                       | (t11, t21) ->
-                           let uu___9 = FStar_Syntax_Print.term_to_string t11 in
-                           let uu___10 =
-                             let uu___11 =
-                               FStar_Syntax_Print.term_to_string t21 in
-                             Prims.op_Hat "; " uu___11 in
-                           Prims.op_Hat uu___9 uu___10)) in
-             FStar_Compiler_Util.print4
-               "head_matches_delta (%s, %s) = %s (%s)\n" uu___2 uu___3 uu___4
-               uu___5
-           else ());
-          r
-let (kind_type :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Compiler_Range.range -> FStar_Syntax_Syntax.typ)
-  =
-  fun binders ->
-    fun r ->
-      let uu___ = FStar_Syntax_Util.type_u () in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ FStar_Pervasives_Native.fst
-let (rank_t_num : FStar_TypeChecker_Common.rank_t -> Prims.int) =
-  fun uu___ ->
-    match uu___ with
-    | FStar_TypeChecker_Common.Rigid_rigid -> Prims.int_zero
-    | FStar_TypeChecker_Common.Flex_rigid_eq -> Prims.int_one
-    | FStar_TypeChecker_Common.Flex_flex_pattern_eq -> (Prims.of_int (2))
-    | FStar_TypeChecker_Common.Flex_rigid -> (Prims.of_int (3))
-    | FStar_TypeChecker_Common.Rigid_flex -> (Prims.of_int (4))
-    | FStar_TypeChecker_Common.Flex_flex -> (Prims.of_int (5))
-let (rank_leq :
-  FStar_TypeChecker_Common.rank_t ->
-    FStar_TypeChecker_Common.rank_t -> Prims.bool)
-  = fun r1 -> fun r2 -> (rank_t_num r1) <= (rank_t_num r2)
-let (rank_less_than :
-  FStar_TypeChecker_Common.rank_t ->
-    FStar_TypeChecker_Common.rank_t -> Prims.bool)
-  = fun r1 -> fun r2 -> (r1 <> r2) && ((rank_t_num r1) <= (rank_t_num r2))
-let (compress_tprob :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term FStar_TypeChecker_Common.problem ->
-      FStar_Syntax_Syntax.term FStar_TypeChecker_Common.problem)
-  =
-  fun tcenv ->
-    fun p ->
-      let uu___ = whnf tcenv p.FStar_TypeChecker_Common.lhs in
-      let uu___1 = whnf tcenv p.FStar_TypeChecker_Common.rhs in
-      {
-        FStar_TypeChecker_Common.pid = (p.FStar_TypeChecker_Common.pid);
-        FStar_TypeChecker_Common.lhs = uu___;
-        FStar_TypeChecker_Common.relation =
-          (p.FStar_TypeChecker_Common.relation);
-        FStar_TypeChecker_Common.rhs = uu___1;
-        FStar_TypeChecker_Common.element =
-          (p.FStar_TypeChecker_Common.element);
-        FStar_TypeChecker_Common.logical_guard =
-          (p.FStar_TypeChecker_Common.logical_guard);
-        FStar_TypeChecker_Common.logical_guard_uvar =
-          (p.FStar_TypeChecker_Common.logical_guard_uvar);
-        FStar_TypeChecker_Common.reason = (p.FStar_TypeChecker_Common.reason);
-        FStar_TypeChecker_Common.loc = (p.FStar_TypeChecker_Common.loc);
-        FStar_TypeChecker_Common.rank = (p.FStar_TypeChecker_Common.rank)
-      }
-let (compress_prob :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.prob -> FStar_TypeChecker_Common.prob)
-  =
-  fun tcenv ->
-    fun p ->
-      match p with
-      | FStar_TypeChecker_Common.TProb p1 ->
-          let uu___ = compress_tprob tcenv p1 in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            (fun uu___1 -> FStar_TypeChecker_Common.TProb uu___1)
-      | FStar_TypeChecker_Common.CProb uu___ -> p
-let (rank :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.prob ->
-      (FStar_TypeChecker_Common.rank_t * FStar_TypeChecker_Common.prob))
-  =
-  fun tcenv ->
-    fun pr ->
-      let prob =
-        let uu___ = compress_prob tcenv pr in
-        FStar_Compiler_Effect.op_Bar_Greater uu___ maybe_invert_p in
-      match prob with
-      | FStar_TypeChecker_Common.TProb tp ->
-          let uu___ =
-            FStar_Syntax_Util.head_and_args tp.FStar_TypeChecker_Common.lhs in
-          (match uu___ with
-           | (lh, lhs_args) ->
-               let uu___1 =
-                 FStar_Syntax_Util.head_and_args
-                   tp.FStar_TypeChecker_Common.rhs in
-               (match uu___1 with
-                | (rh, rhs_args) ->
-                    let uu___2 =
-                      match ((lh.FStar_Syntax_Syntax.n),
-                              (rh.FStar_Syntax_Syntax.n))
-                      with
-                      | (FStar_Syntax_Syntax.Tm_uvar uu___3,
-                         FStar_Syntax_Syntax.Tm_uvar uu___4) ->
-                          (match (lhs_args, rhs_args) with
-                           | ([], []) when
-                               tp.FStar_TypeChecker_Common.relation =
-                                 FStar_TypeChecker_Common.EQ
-                               ->
-                               (FStar_TypeChecker_Common.Flex_flex_pattern_eq,
-                                 tp)
-                           | uu___5 ->
-                               (FStar_TypeChecker_Common.Flex_flex, tp))
-                      | (FStar_Syntax_Syntax.Tm_uvar uu___3, uu___4) when
-                          tp.FStar_TypeChecker_Common.relation =
-                            FStar_TypeChecker_Common.EQ
-                          -> (FStar_TypeChecker_Common.Flex_rigid_eq, tp)
-                      | (uu___3, FStar_Syntax_Syntax.Tm_uvar uu___4) when
-                          tp.FStar_TypeChecker_Common.relation =
-                            FStar_TypeChecker_Common.EQ
-                          -> (FStar_TypeChecker_Common.Flex_rigid_eq, tp)
-                      | (FStar_Syntax_Syntax.Tm_uvar uu___3,
-                         FStar_Syntax_Syntax.Tm_arrow uu___4) ->
-                          (FStar_TypeChecker_Common.Flex_rigid_eq,
-                            {
-                              FStar_TypeChecker_Common.pid =
-                                (tp.FStar_TypeChecker_Common.pid);
-                              FStar_TypeChecker_Common.lhs =
-                                (tp.FStar_TypeChecker_Common.lhs);
-                              FStar_TypeChecker_Common.relation =
-                                FStar_TypeChecker_Common.EQ;
-                              FStar_TypeChecker_Common.rhs =
-                                (tp.FStar_TypeChecker_Common.rhs);
-                              FStar_TypeChecker_Common.element =
-                                (tp.FStar_TypeChecker_Common.element);
-                              FStar_TypeChecker_Common.logical_guard =
-                                (tp.FStar_TypeChecker_Common.logical_guard);
-                              FStar_TypeChecker_Common.logical_guard_uvar =
-                                (tp.FStar_TypeChecker_Common.logical_guard_uvar);
-                              FStar_TypeChecker_Common.reason =
-                                (tp.FStar_TypeChecker_Common.reason);
-                              FStar_TypeChecker_Common.loc =
-                                (tp.FStar_TypeChecker_Common.loc);
-                              FStar_TypeChecker_Common.rank =
-                                (tp.FStar_TypeChecker_Common.rank)
-                            })
-                      | (FStar_Syntax_Syntax.Tm_uvar uu___3,
-                         FStar_Syntax_Syntax.Tm_type uu___4) ->
-                          (FStar_TypeChecker_Common.Flex_rigid_eq,
-                            {
-                              FStar_TypeChecker_Common.pid =
-                                (tp.FStar_TypeChecker_Common.pid);
-                              FStar_TypeChecker_Common.lhs =
-                                (tp.FStar_TypeChecker_Common.lhs);
-                              FStar_TypeChecker_Common.relation =
-                                FStar_TypeChecker_Common.EQ;
-                              FStar_TypeChecker_Common.rhs =
-                                (tp.FStar_TypeChecker_Common.rhs);
-                              FStar_TypeChecker_Common.element =
-                                (tp.FStar_TypeChecker_Common.element);
-                              FStar_TypeChecker_Common.logical_guard =
-                                (tp.FStar_TypeChecker_Common.logical_guard);
-                              FStar_TypeChecker_Common.logical_guard_uvar =
-                                (tp.FStar_TypeChecker_Common.logical_guard_uvar);
-                              FStar_TypeChecker_Common.reason =
-                                (tp.FStar_TypeChecker_Common.reason);
-                              FStar_TypeChecker_Common.loc =
-                                (tp.FStar_TypeChecker_Common.loc);
-                              FStar_TypeChecker_Common.rank =
-                                (tp.FStar_TypeChecker_Common.rank)
-                            })
-                      | (FStar_Syntax_Syntax.Tm_type uu___3,
-                         FStar_Syntax_Syntax.Tm_uvar uu___4) ->
-                          (FStar_TypeChecker_Common.Flex_rigid_eq,
-                            {
-                              FStar_TypeChecker_Common.pid =
-                                (tp.FStar_TypeChecker_Common.pid);
-                              FStar_TypeChecker_Common.lhs =
-                                (tp.FStar_TypeChecker_Common.lhs);
-                              FStar_TypeChecker_Common.relation =
-                                FStar_TypeChecker_Common.EQ;
-                              FStar_TypeChecker_Common.rhs =
-                                (tp.FStar_TypeChecker_Common.rhs);
-                              FStar_TypeChecker_Common.element =
-                                (tp.FStar_TypeChecker_Common.element);
-                              FStar_TypeChecker_Common.logical_guard =
-                                (tp.FStar_TypeChecker_Common.logical_guard);
-                              FStar_TypeChecker_Common.logical_guard_uvar =
-                                (tp.FStar_TypeChecker_Common.logical_guard_uvar);
-                              FStar_TypeChecker_Common.reason =
-                                (tp.FStar_TypeChecker_Common.reason);
-                              FStar_TypeChecker_Common.loc =
-                                (tp.FStar_TypeChecker_Common.loc);
-                              FStar_TypeChecker_Common.rank =
-                                (tp.FStar_TypeChecker_Common.rank)
-                            })
-                      | (uu___3, FStar_Syntax_Syntax.Tm_uvar uu___4) ->
-                          (FStar_TypeChecker_Common.Rigid_flex, tp)
-                      | (FStar_Syntax_Syntax.Tm_uvar uu___3, uu___4) ->
-                          (FStar_TypeChecker_Common.Flex_rigid, tp)
-                      | (uu___3, FStar_Syntax_Syntax.Tm_uvar uu___4) ->
-                          (FStar_TypeChecker_Common.Rigid_flex, tp)
-                      | (uu___3, uu___4) ->
-                          (FStar_TypeChecker_Common.Rigid_rigid, tp) in
-                    (match uu___2 with
-                     | (rank1, tp1) ->
-                         let uu___3 =
-                           FStar_Compiler_Effect.op_Bar_Greater
-                             {
-                               FStar_TypeChecker_Common.pid =
-                                 (tp1.FStar_TypeChecker_Common.pid);
-                               FStar_TypeChecker_Common.lhs =
-                                 (tp1.FStar_TypeChecker_Common.lhs);
-                               FStar_TypeChecker_Common.relation =
-                                 (tp1.FStar_TypeChecker_Common.relation);
-                               FStar_TypeChecker_Common.rhs =
-                                 (tp1.FStar_TypeChecker_Common.rhs);
-                               FStar_TypeChecker_Common.element =
-                                 (tp1.FStar_TypeChecker_Common.element);
-                               FStar_TypeChecker_Common.logical_guard =
-                                 (tp1.FStar_TypeChecker_Common.logical_guard);
-                               FStar_TypeChecker_Common.logical_guard_uvar =
-                                 (tp1.FStar_TypeChecker_Common.logical_guard_uvar);
-                               FStar_TypeChecker_Common.reason =
-                                 (tp1.FStar_TypeChecker_Common.reason);
-                               FStar_TypeChecker_Common.loc =
-                                 (tp1.FStar_TypeChecker_Common.loc);
-                               FStar_TypeChecker_Common.rank =
-                                 (FStar_Pervasives_Native.Some rank1)
-                             }
-                             (fun uu___4 ->
-                                FStar_TypeChecker_Common.TProb uu___4) in
-                         (rank1, uu___3))))
-      | FStar_TypeChecker_Common.CProb cp ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater
-              {
-                FStar_TypeChecker_Common.pid =
-                  (cp.FStar_TypeChecker_Common.pid);
-                FStar_TypeChecker_Common.lhs =
-                  (cp.FStar_TypeChecker_Common.lhs);
-                FStar_TypeChecker_Common.relation =
-                  (cp.FStar_TypeChecker_Common.relation);
-                FStar_TypeChecker_Common.rhs =
-                  (cp.FStar_TypeChecker_Common.rhs);
-                FStar_TypeChecker_Common.element =
-                  (cp.FStar_TypeChecker_Common.element);
-                FStar_TypeChecker_Common.logical_guard =
-                  (cp.FStar_TypeChecker_Common.logical_guard);
-                FStar_TypeChecker_Common.logical_guard_uvar =
-                  (cp.FStar_TypeChecker_Common.logical_guard_uvar);
-                FStar_TypeChecker_Common.reason =
-                  (cp.FStar_TypeChecker_Common.reason);
-                FStar_TypeChecker_Common.loc =
-                  (cp.FStar_TypeChecker_Common.loc);
-                FStar_TypeChecker_Common.rank =
-                  (FStar_Pervasives_Native.Some
-                     FStar_TypeChecker_Common.Rigid_rigid)
-              } (fun uu___1 -> FStar_TypeChecker_Common.CProb uu___1) in
-          (FStar_TypeChecker_Common.Rigid_rigid, uu___)
-let (next_prob :
-  worklist ->
-    (FStar_TypeChecker_Common.prob * FStar_TypeChecker_Common.prob Prims.list
-      * FStar_TypeChecker_Common.rank_t) FStar_Pervasives_Native.option)
-  =
-  fun wl ->
-    let rec aux uu___ probs =
-      match uu___ with
-      | (min_rank, min, out) ->
-          (match probs with
-           | [] ->
-               (match (min, min_rank) with
-                | (FStar_Pervasives_Native.Some p,
-                   FStar_Pervasives_Native.Some r) ->
-                    FStar_Pervasives_Native.Some (p, out, r)
-                | uu___1 -> FStar_Pervasives_Native.None)
-           | hd::tl ->
-               let uu___1 = rank wl.tcenv hd in
-               (match uu___1 with
-                | (rank1, hd1) ->
-                    if rank_leq rank1 FStar_TypeChecker_Common.Flex_rigid_eq
-                    then
-                      (match min with
-                       | FStar_Pervasives_Native.None ->
-                           FStar_Pervasives_Native.Some
-                             (hd1, (FStar_Compiler_List.op_At out tl), rank1)
-                       | FStar_Pervasives_Native.Some m ->
-                           FStar_Pervasives_Native.Some
-                             (hd1, (FStar_Compiler_List.op_At out (m :: tl)),
-                               rank1))
-                    else
-                      (let uu___3 =
-                         (min_rank = FStar_Pervasives_Native.None) ||
-                           (let uu___4 = FStar_Compiler_Option.get min_rank in
-                            rank_less_than rank1 uu___4) in
-                       if uu___3
-                       then
-                         match min with
-                         | FStar_Pervasives_Native.None ->
-                             aux
-                               ((FStar_Pervasives_Native.Some rank1),
-                                 (FStar_Pervasives_Native.Some hd1), out) tl
-                         | FStar_Pervasives_Native.Some m ->
-                             aux
-                               ((FStar_Pervasives_Native.Some rank1),
-                                 (FStar_Pervasives_Native.Some hd1), (m ::
-                                 out)) tl
-                       else aux (min_rank, min, (hd1 :: out)) tl))) in
-    aux (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None, [])
-      wl.attempting
-let (flex_prob_closing :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_TypeChecker_Common.prob -> Prims.bool)
-  =
-  fun tcenv ->
-    fun bs ->
-      fun p ->
-        let flex_will_be_closed t =
-          let uu___ = FStar_Syntax_Util.head_and_args t in
-          match uu___ with
-          | (hd, uu___1) ->
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Subst.compress hd in
-                uu___3.FStar_Syntax_Syntax.n in
-              (match uu___2 with
-               | FStar_Syntax_Syntax.Tm_uvar (u, uu___3) ->
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     u.FStar_Syntax_Syntax.ctx_uvar_binders
-                     (FStar_Compiler_Util.for_some
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | { FStar_Syntax_Syntax.binder_bv = y;
-                               FStar_Syntax_Syntax.binder_qual = uu___5;
-                               FStar_Syntax_Syntax.binder_attrs = uu___6;_}
-                               ->
-                               FStar_Compiler_Effect.op_Bar_Greater bs
-                                 (FStar_Compiler_Util.for_some
-                                    (fun uu___7 ->
-                                       match uu___7 with
-                                       | { FStar_Syntax_Syntax.binder_bv = x;
-                                           FStar_Syntax_Syntax.binder_qual =
-                                             uu___8;
-                                           FStar_Syntax_Syntax.binder_attrs =
-                                             uu___9;_}
-                                           -> FStar_Syntax_Syntax.bv_eq x y))))
-               | uu___3 -> false) in
-        let uu___ = rank tcenv p in
-        match uu___ with
-        | (r, p1) ->
-            (match p1 with
-             | FStar_TypeChecker_Common.CProb uu___1 -> true
-             | FStar_TypeChecker_Common.TProb p2 ->
-                 (match r with
-                  | FStar_TypeChecker_Common.Rigid_rigid -> true
-                  | FStar_TypeChecker_Common.Flex_rigid_eq -> true
-                  | FStar_TypeChecker_Common.Flex_flex_pattern_eq -> true
-                  | FStar_TypeChecker_Common.Flex_rigid ->
-                      flex_will_be_closed p2.FStar_TypeChecker_Common.lhs
-                  | FStar_TypeChecker_Common.Rigid_flex ->
-                      flex_will_be_closed p2.FStar_TypeChecker_Common.rhs
-                  | FStar_TypeChecker_Common.Flex_flex ->
-                      (p2.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ)
-                        &&
-                        ((flex_will_be_closed p2.FStar_TypeChecker_Common.lhs)
-                           ||
-                           (flex_will_be_closed
-                              p2.FStar_TypeChecker_Common.rhs))))
-type univ_eq_sol =
-  | UDeferred of worklist 
-  | USolved of worklist 
-  | UFailed of lstring 
-let (uu___is_UDeferred : univ_eq_sol -> Prims.bool) =
-  fun projectee ->
-    match projectee with | UDeferred _0 -> true | uu___ -> false
-let (__proj__UDeferred__item___0 : univ_eq_sol -> worklist) =
-  fun projectee -> match projectee with | UDeferred _0 -> _0
-let (uu___is_USolved : univ_eq_sol -> Prims.bool) =
-  fun projectee -> match projectee with | USolved _0 -> true | uu___ -> false
-let (__proj__USolved__item___0 : univ_eq_sol -> worklist) =
-  fun projectee -> match projectee with | USolved _0 -> _0
-let (uu___is_UFailed : univ_eq_sol -> Prims.bool) =
-  fun projectee -> match projectee with | UFailed _0 -> true | uu___ -> false
-let (__proj__UFailed__item___0 : univ_eq_sol -> lstring) =
-  fun projectee -> match projectee with | UFailed _0 -> _0
-let (ufailed_simple : Prims.string -> univ_eq_sol) =
-  fun s -> let uu___ = FStar_Thunk.mkv s in UFailed uu___
-let (ufailed_thunk : (unit -> Prims.string) -> univ_eq_sol) =
-  fun s -> let uu___ = mklstr s in UFailed uu___
-let rec (really_solve_universe_eq :
-  Prims.int ->
-    worklist ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.universe -> univ_eq_sol)
-  =
-  fun pid_orig ->
-    fun wl ->
-      fun u1 ->
-        fun u2 ->
-          let u11 =
-            FStar_TypeChecker_Normalize.normalize_universe wl.tcenv u1 in
-          let u21 =
-            FStar_TypeChecker_Normalize.normalize_universe wl.tcenv u2 in
-          let rec occurs_univ v1 u =
-            match u with
-            | FStar_Syntax_Syntax.U_max us ->
-                FStar_Compiler_Effect.op_Bar_Greater us
-                  (FStar_Compiler_Util.for_some
-                     (fun u3 ->
-                        let uu___ = FStar_Syntax_Util.univ_kernel u3 in
-                        match uu___ with
-                        | (k, uu___1) ->
-                            (match k with
-                             | FStar_Syntax_Syntax.U_unif v2 ->
-                                 FStar_Syntax_Unionfind.univ_equiv v1 v2
-                             | uu___2 -> false)))
-            | uu___ -> occurs_univ v1 (FStar_Syntax_Syntax.U_max [u]) in
-          let rec filter_out_common_univs u12 u22 =
-            let common_elts =
-              FStar_Compiler_Effect.op_Bar_Greater u12
-                (FStar_Compiler_List.fold_left
-                   (fun uvs ->
-                      fun uv1 ->
-                        let uu___ =
-                          FStar_Compiler_Effect.op_Bar_Greater u22
-                            (FStar_Compiler_List.existsML
-                               (fun uv2 -> FStar_Syntax_Util.eq_univs uv1 uv2)) in
-                        if uu___ then uv1 :: uvs else uvs) []) in
-            let filter =
-              FStar_Compiler_List.filter
-                (fun u ->
-                   let uu___ =
-                     FStar_Compiler_Effect.op_Bar_Greater common_elts
-                       (FStar_Compiler_List.existsML
-                          (fun u' -> FStar_Syntax_Util.eq_univs u u')) in
-                   Prims.op_Negation uu___) in
-            let uu___ = filter u12 in
-            let uu___1 = filter u22 in (uu___, uu___1) in
-          let try_umax_components u12 u22 msg =
-            if Prims.op_Negation wl.umax_heuristic_ok
-            then ufailed_simple "Unable to unify universe terms with umax"
-            else
-              (match (u12, u22) with
-               | (FStar_Syntax_Syntax.U_max us1, FStar_Syntax_Syntax.U_max
-                  us2) ->
-                   let uu___1 = filter_out_common_univs us1 us2 in
-                   (match uu___1 with
-                    | (us11, us21) ->
-                        if
-                          (FStar_Compiler_List.length us11) =
-                            (FStar_Compiler_List.length us21)
-                        then
-                          let rec aux wl1 us12 us22 =
-                            match (us12, us22) with
-                            | (u13::us13, u23::us23) ->
-                                let uu___2 =
-                                  really_solve_universe_eq pid_orig wl1 u13
-                                    u23 in
-                                (match uu___2 with
-                                 | USolved wl2 -> aux wl2 us13 us23
-                                 | failed -> failed)
-                            | uu___2 -> USolved wl1 in
-                          aux wl us11 us21
-                        else
-                          ufailed_thunk
-                            (fun uu___3 ->
-                               let uu___4 =
-                                 FStar_Syntax_Print.univ_to_string u12 in
-                               let uu___5 =
-                                 FStar_Syntax_Print.univ_to_string u22 in
-                               FStar_Compiler_Util.format2
-                                 "Unable to unify universes: %s and %s"
-                                 uu___4 uu___5))
-               | (FStar_Syntax_Syntax.U_max us, u') ->
-                   let rec aux wl1 us1 =
-                     match us1 with
-                     | [] -> USolved wl1
-                     | u::us2 ->
-                         let uu___1 =
-                           really_solve_universe_eq pid_orig wl1 u u' in
-                         (match uu___1 with
-                          | USolved wl2 -> aux wl2 us2
-                          | failed -> failed) in
-                   aux wl us
-               | (u', FStar_Syntax_Syntax.U_max us) ->
-                   let rec aux wl1 us1 =
-                     match us1 with
-                     | [] -> USolved wl1
-                     | u::us2 ->
-                         let uu___1 =
-                           really_solve_universe_eq pid_orig wl1 u u' in
-                         (match uu___1 with
-                          | USolved wl2 -> aux wl2 us2
-                          | failed -> failed) in
-                   aux wl us
-               | uu___1 ->
-                   ufailed_thunk
-                     (fun uu___2 ->
-                        let uu___3 = FStar_Syntax_Print.univ_to_string u12 in
-                        let uu___4 = FStar_Syntax_Print.univ_to_string u22 in
-                        FStar_Compiler_Util.format3
-                          "Unable to unify universes: %s and %s (%s)" uu___3
-                          uu___4 msg)) in
-          match (u11, u21) with
-          | (FStar_Syntax_Syntax.U_bvar uu___, uu___1) ->
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.univ_to_string u11 in
-                let uu___4 = FStar_Syntax_Print.univ_to_string u21 in
-                FStar_Compiler_Util.format2
-                  "Impossible: found an de Bruijn universe variable or unknown universe: %s, %s"
-                  uu___3 uu___4 in
-              failwith uu___2
-          | (FStar_Syntax_Syntax.U_unknown, uu___) ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.univ_to_string u11 in
-                let uu___3 = FStar_Syntax_Print.univ_to_string u21 in
-                FStar_Compiler_Util.format2
-                  "Impossible: found an de Bruijn universe variable or unknown universe: %s, %s"
-                  uu___2 uu___3 in
-              failwith uu___1
-          | (uu___, FStar_Syntax_Syntax.U_bvar uu___1) ->
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.univ_to_string u11 in
-                let uu___4 = FStar_Syntax_Print.univ_to_string u21 in
-                FStar_Compiler_Util.format2
-                  "Impossible: found an de Bruijn universe variable or unknown universe: %s, %s"
-                  uu___3 uu___4 in
-              failwith uu___2
-          | (uu___, FStar_Syntax_Syntax.U_unknown) ->
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.univ_to_string u11 in
-                let uu___3 = FStar_Syntax_Print.univ_to_string u21 in
-                FStar_Compiler_Util.format2
-                  "Impossible: found an de Bruijn universe variable or unknown universe: %s, %s"
-                  uu___2 uu___3 in
-              failwith uu___1
-          | (FStar_Syntax_Syntax.U_name x, FStar_Syntax_Syntax.U_name y) ->
-              let uu___ =
-                let uu___1 = FStar_Ident.string_of_id x in
-                let uu___2 = FStar_Ident.string_of_id y in uu___1 = uu___2 in
-              if uu___
-              then USolved wl
-              else ufailed_simple "Incompatible universes"
-          | (FStar_Syntax_Syntax.U_zero, FStar_Syntax_Syntax.U_zero) ->
-              USolved wl
-          | (FStar_Syntax_Syntax.U_succ u12, FStar_Syntax_Syntax.U_succ u22)
-              -> really_solve_universe_eq pid_orig wl u12 u22
-          | (FStar_Syntax_Syntax.U_unif v1, FStar_Syntax_Syntax.U_unif v2) ->
-              let uu___ = FStar_Syntax_Unionfind.univ_equiv v1 v2 in
-              if uu___
-              then USolved wl
-              else
-                (let wl1 =
-                   extend_universe_solution pid_orig [UNIV (v1, u21)] wl in
-                 USolved wl1)
-          | (FStar_Syntax_Syntax.U_unif v1, u) ->
-              let u3 = norm_univ wl u in
-              let uu___ = occurs_univ v1 u3 in
-              if uu___
-              then
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Syntax_Print.univ_to_string
-                      (FStar_Syntax_Syntax.U_unif v1) in
-                  let uu___3 = FStar_Syntax_Print.univ_to_string u3 in
-                  FStar_Compiler_Util.format2
-                    "Failed occurs check: %s occurs in %s" uu___2 uu___3 in
-                try_umax_components u11 u21 uu___1
-              else
-                (let uu___2 =
-                   extend_universe_solution pid_orig [UNIV (v1, u3)] wl in
-                 USolved uu___2)
-          | (u, FStar_Syntax_Syntax.U_unif v1) ->
-              let u3 = norm_univ wl u in
-              let uu___ = occurs_univ v1 u3 in
-              if uu___
-              then
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Syntax_Print.univ_to_string
-                      (FStar_Syntax_Syntax.U_unif v1) in
-                  let uu___3 = FStar_Syntax_Print.univ_to_string u3 in
-                  FStar_Compiler_Util.format2
-                    "Failed occurs check: %s occurs in %s" uu___2 uu___3 in
-                try_umax_components u11 u21 uu___1
-              else
-                (let uu___2 =
-                   extend_universe_solution pid_orig [UNIV (v1, u3)] wl in
-                 USolved uu___2)
-          | (FStar_Syntax_Syntax.U_max uu___, uu___1) ->
-              if wl.defer_ok = DeferAny
-              then UDeferred wl
-              else
-                (let u12 = norm_univ wl u11 in
-                 let u22 = norm_univ wl u21 in
-                 let uu___3 = FStar_Syntax_Util.eq_univs u12 u22 in
-                 if uu___3
-                 then USolved wl
-                 else try_umax_components u12 u22 "")
-          | (uu___, FStar_Syntax_Syntax.U_max uu___1) ->
-              if wl.defer_ok = DeferAny
-              then UDeferred wl
-              else
-                (let u12 = norm_univ wl u11 in
-                 let u22 = norm_univ wl u21 in
-                 let uu___3 = FStar_Syntax_Util.eq_univs u12 u22 in
-                 if uu___3
-                 then USolved wl
-                 else try_umax_components u12 u22 "")
-          | (FStar_Syntax_Syntax.U_succ uu___, FStar_Syntax_Syntax.U_zero) ->
-              ufailed_simple "Incompatible universes"
-          | (FStar_Syntax_Syntax.U_succ uu___, FStar_Syntax_Syntax.U_name
-             uu___1) -> ufailed_simple "Incompatible universes"
-          | (FStar_Syntax_Syntax.U_zero, FStar_Syntax_Syntax.U_succ uu___) ->
-              ufailed_simple "Incompatible universes"
-          | (FStar_Syntax_Syntax.U_zero, FStar_Syntax_Syntax.U_name uu___) ->
-              ufailed_simple "Incompatible universes"
-          | (FStar_Syntax_Syntax.U_name uu___, FStar_Syntax_Syntax.U_succ
-             uu___1) -> ufailed_simple "Incompatible universes"
-          | (FStar_Syntax_Syntax.U_name uu___, FStar_Syntax_Syntax.U_zero) ->
-              ufailed_simple "Incompatible universes"
-let (solve_universe_eq :
-  Prims.int ->
-    worklist ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.universe -> univ_eq_sol)
-  =
-  fun orig ->
-    fun wl ->
-      fun u1 ->
-        fun u2 ->
-          if (wl.tcenv).FStar_TypeChecker_Env.lax_universes
-          then USolved wl
-          else really_solve_universe_eq orig wl u1 u2
-let match_num_binders :
-  'a 'b .
-    ('a Prims.list * ('a Prims.list -> 'b)) ->
-      ('a Prims.list * ('a Prims.list -> 'b)) ->
-        (('a Prims.list * 'b) * ('a Prims.list * 'b))
-  =
-  fun bc1 ->
-    fun bc2 ->
-      let uu___ = bc1 in
-      match uu___ with
-      | (bs1, mk_cod1) ->
-          let uu___1 = bc2 in
-          (match uu___1 with
-           | (bs2, mk_cod2) ->
-               let rec aux bs11 bs21 =
-                 match (bs11, bs21) with
-                 | (x::xs, y::ys) ->
-                     let uu___2 = aux xs ys in
-                     (match uu___2 with
-                      | ((xs1, xr), (ys1, yr)) ->
-                          (((x :: xs1), xr), ((y :: ys1), yr)))
-                 | (xs, ys) ->
-                     let uu___2 = let uu___3 = mk_cod1 xs in ([], uu___3) in
-                     let uu___3 = let uu___4 = mk_cod2 ys in ([], uu___4) in
-                     (uu___2, uu___3) in
-               aux bs1 bs2)
-let (guard_of_prob :
-  worklist ->
-    tprob ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.term -> (FStar_Syntax_Syntax.term * worklist))
-  =
-  fun wl ->
-    fun problem ->
-      fun t1 ->
-        fun t2 ->
-          def_check_prob "guard_of_prob"
-            (FStar_TypeChecker_Common.TProb problem);
-          (let env = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-           let has_type_guard t11 t21 =
-             match problem.FStar_TypeChecker_Common.element with
-             | FStar_Pervasives_Native.Some t ->
-                 let uu___1 = FStar_Syntax_Syntax.bv_to_name t in
-                 FStar_Syntax_Util.mk_has_type t11 uu___1 t21
-             | FStar_Pervasives_Native.None ->
-                 let x =
-                   FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None
-                     t11 in
-                 (FStar_TypeChecker_Env.def_check_closed_in_env
-                    t11.FStar_Syntax_Syntax.pos "guard_of_prob.universe_of"
-                    env t11;
-                  (let u_x = env.FStar_TypeChecker_Env.universe_of env t11 in
-                   let uu___2 =
-                     let uu___3 = FStar_Syntax_Syntax.bv_to_name x in
-                     FStar_Syntax_Util.mk_has_type t11 uu___3 t21 in
-                   FStar_Syntax_Util.mk_forall u_x x uu___2)) in
-           match problem.FStar_TypeChecker_Common.relation with
-           | FStar_TypeChecker_Common.EQ ->
-               mk_eq2 wl (FStar_TypeChecker_Common.TProb problem) t1 t2
-           | FStar_TypeChecker_Common.SUB ->
-               let uu___1 = has_type_guard t1 t2 in (uu___1, wl)
-           | FStar_TypeChecker_Common.SUBINV ->
-               let uu___1 = has_type_guard t2 t1 in (uu___1, wl))
-let (is_flex_pat : flex_t -> Prims.bool) =
-  fun uu___ ->
-    match uu___ with | Flex (uu___1, uu___2, []) -> true | uu___1 -> false
-let (should_defer_flex_to_user_tac : worklist -> flex_t -> Prims.bool) =
-  fun wl ->
-    fun f ->
-      let uu___ = f in
-      match uu___ with
-      | Flex (uu___1, u, uu___2) ->
-          let b =
-            FStar_TypeChecker_DeferredImplicits.should_defer_uvar_to_user_tac
-              wl.tcenv u in
-          ((let uu___4 =
-              FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                (FStar_Options.Other "ResolveImplicitsHook") in
-            if uu___4
-            then
-              let uu___5 = FStar_Syntax_Print.ctx_uvar_to_string_no_reason u in
-              let uu___6 = FStar_Compiler_Util.string_of_bool b in
-              let uu___7 =
-                FStar_Compiler_Util.string_of_bool
-                  (wl.tcenv).FStar_TypeChecker_Env.enable_defer_to_tac in
-              FStar_Compiler_Util.print3
-                "Rel.should_defer_flex_to_user_tac for %s returning %s (env.enable_defer_to_tac: %s)\n"
-                uu___5 uu___6 uu___7
-            else ());
-           b)
-let (quasi_pattern :
-  FStar_TypeChecker_Env.env ->
-    flex_t ->
-      (FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.typ)
-        FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun f ->
-      let uu___ = f in
-      match uu___ with
-      | Flex (uu___1, ctx_uvar, args) ->
-          let t_hd = FStar_Syntax_Util.ctx_uvar_typ ctx_uvar in
-          let ctx = ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_binders in
-          let name_exists_in x bs =
-            FStar_Compiler_Util.for_some
-              (fun uu___2 ->
-                 match uu___2 with
-                 | { FStar_Syntax_Syntax.binder_bv = y;
-                     FStar_Syntax_Syntax.binder_qual = uu___3;
-                     FStar_Syntax_Syntax.binder_attrs = uu___4;_} ->
-                     FStar_Syntax_Syntax.bv_eq x y) bs in
-          let rec aux pat_binders formals t_res args1 =
-            match (formals, args1) with
-            | ([], []) ->
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = FStar_Syntax_Syntax.mk_Total t_res in
-                    FStar_Syntax_Util.arrow formals uu___4 in
-                  ((FStar_Compiler_List.rev pat_binders), uu___3) in
-                FStar_Pervasives_Native.Some uu___2
-            | (uu___2, []) ->
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 = FStar_Syntax_Syntax.mk_Total t_res in
-                    FStar_Syntax_Util.arrow formals uu___5 in
-                  ((FStar_Compiler_List.rev pat_binders), uu___4) in
-                FStar_Pervasives_Native.Some uu___3
-            | (fml::formals1, (a, a_imp)::args2) ->
-                let uu___2 =
-                  ((fml.FStar_Syntax_Syntax.binder_bv),
-                    (fml.FStar_Syntax_Syntax.binder_qual)) in
-                (match uu___2 with
-                 | (formal, formal_imp) ->
-                     let uu___3 =
-                       let uu___4 = FStar_Syntax_Subst.compress a in
-                       uu___4.FStar_Syntax_Syntax.n in
-                     (match uu___3 with
-                      | FStar_Syntax_Syntax.Tm_name x ->
-                          let uu___4 =
-                            (name_exists_in x ctx) ||
-                              (name_exists_in x pat_binders) in
-                          if uu___4
-                          then aux (fml :: pat_binders) formals1 t_res args2
-                          else
-                            (let x1 =
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (x.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (x.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort =
-                                   (formal.FStar_Syntax_Syntax.sort)
-                               } in
-                             let subst =
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Syntax_Syntax.bv_to_name x1 in
-                                   (formal, uu___8) in
-                                 FStar_Syntax_Syntax.NT uu___7 in
-                               [uu___6] in
-                             let formals2 =
-                               FStar_Syntax_Subst.subst_binders subst
-                                 formals1 in
-                             let t_res1 =
-                               FStar_Syntax_Subst.subst subst t_res in
-                             let uu___6 =
-                               FStar_Syntax_Util.bqual_and_attrs_of_aqual
-                                 a_imp in
-                             match uu___6 with
-                             | (q, uu___7) ->
-                                 let uu___8 =
-                                   let uu___9 =
-                                     FStar_Syntax_Syntax.mk_binder_with_attrs
-                                       {
-                                         FStar_Syntax_Syntax.ppname =
-                                           (x1.FStar_Syntax_Syntax.ppname);
-                                         FStar_Syntax_Syntax.index =
-                                           (x1.FStar_Syntax_Syntax.index);
-                                         FStar_Syntax_Syntax.sort =
-                                           (formal.FStar_Syntax_Syntax.sort)
-                                       } q
-                                       fml.FStar_Syntax_Syntax.binder_attrs in
-                                   uu___9 :: pat_binders in
-                                 aux uu___8 formals2 t_res1 args2)
-                      | uu___4 ->
-                          aux (fml :: pat_binders) formals1 t_res args2))
-            | ([], args2) ->
-                let uu___2 =
-                  let uu___3 =
-                    FStar_TypeChecker_Normalize.unfold_whnf env t_res in
-                  FStar_Syntax_Util.arrow_formals uu___3 in
-                (match uu___2 with
-                 | (more_formals, t_res1) ->
-                     (match more_formals with
-                      | [] -> FStar_Pervasives_Native.None
-                      | uu___3 -> aux pat_binders more_formals t_res1 args2)) in
-          (match args with
-           | [] -> FStar_Pervasives_Native.Some ([], t_hd)
-           | uu___2 ->
-               let uu___3 = FStar_Syntax_Util.arrow_formals t_hd in
-               (match uu___3 with
-                | (formals, t_res) -> aux [] formals t_res args))
-let (run_meta_arg_tac :
-  FStar_Syntax_Syntax.ctx_uvar -> FStar_Syntax_Syntax.term) =
-  fun ctx_u ->
-    match ctx_u.FStar_Syntax_Syntax.ctx_uvar_meta with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Ctx_uvar_meta_tac
-        (env_dyn, tau)) ->
-        let env = FStar_Compiler_Dyn.undyn env_dyn in
-        ((let uu___1 =
-            FStar_TypeChecker_Env.debug env (FStar_Options.Other "Tac") in
-          if uu___1
-          then
-            let uu___2 = FStar_Syntax_Print.ctx_uvar_to_string ctx_u in
-            FStar_Compiler_Util.print1 "Running tactic for meta-arg %s\n"
-              uu___2
-          else ());
-         FStar_Errors.with_ctx "Running tactic for meta-arg"
-           (fun uu___1 ->
-              let uu___2 = FStar_Syntax_Util.ctx_uvar_typ ctx_u in
-              env.FStar_TypeChecker_Env.synth_hook env uu___2 tau))
-    | uu___ ->
-        failwith
-          "run_meta_arg_tac must have been called with a uvar that has a meta tac"
-let (simplify_guard :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      match g.FStar_TypeChecker_Common.guard_f with
-      | FStar_TypeChecker_Common.Trivial -> g
-      | FStar_TypeChecker_Common.NonTrivial f ->
-          ((let uu___1 =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env)
-                (FStar_Options.Other "Simplification") in
-            if uu___1
-            then
-              let uu___2 = FStar_Syntax_Print.term_to_string f in
-              FStar_Compiler_Util.print1 "Simplifying guard %s\n" uu___2
-            else ());
-           (let f1 =
-              norm_with_steps "FStar.TypeChecker.Rel.norm_with_steps.6"
-                [FStar_TypeChecker_Env.Beta;
-                FStar_TypeChecker_Env.Eager_unfolding;
-                FStar_TypeChecker_Env.Simplify;
-                FStar_TypeChecker_Env.Primops;
-                FStar_TypeChecker_Env.NoFullNorm] env f in
-            (let uu___2 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env)
-                 (FStar_Options.Other "Simplification") in
-             if uu___2
-             then
-               let uu___3 = FStar_Syntax_Print.term_to_string f1 in
-               FStar_Compiler_Util.print1 "Simplified guard to %s\n" uu___3
-             else ());
-            (let f2 =
-               let g1 = FStar_Syntax_Util.unmeta f1 in
-               let g2 =
-                 let uu___2 = FStar_Syntax_Util.un_squash g1 in
-                 match uu___2 with
-                 | FStar_Pervasives_Native.Some g' ->
-                     FStar_Syntax_Util.unmeta g'
-                 | uu___3 -> g1 in
-               match g2.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_fvar fv when
-                   FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.true_lid
-                   -> FStar_TypeChecker_Common.Trivial
-               | uu___2 -> FStar_TypeChecker_Common.NonTrivial f1 in
-             {
-               FStar_TypeChecker_Common.guard_f = f2;
-               FStar_TypeChecker_Common.deferred_to_tac =
-                 (g.FStar_TypeChecker_Common.deferred_to_tac);
-               FStar_TypeChecker_Common.deferred =
-                 (g.FStar_TypeChecker_Common.deferred);
-               FStar_TypeChecker_Common.univ_ineqs =
-                 (g.FStar_TypeChecker_Common.univ_ineqs);
-               FStar_TypeChecker_Common.implicits =
-                 (g.FStar_TypeChecker_Common.implicits)
-             })))
-let (apply_substitutive_indexed_subcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.indexed_effect_combinator_kind ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.comp ->
-          FStar_Syntax_Syntax.comp_typ ->
-            FStar_Syntax_Syntax.comp_typ ->
-              (worklist ->
-                 FStar_Syntax_Syntax.term ->
-                   FStar_TypeChecker_Common.rel ->
-                     FStar_Syntax_Syntax.term ->
-                       Prims.string ->
-                         (FStar_TypeChecker_Common.prob * worklist))
-                ->
-                Prims.int ->
-                  worklist ->
-                    Prims.string ->
-                      FStar_Compiler_Range.range ->
-                        (FStar_Syntax_Syntax.typ *
-                          FStar_TypeChecker_Common.prob Prims.list *
-                          worklist))
-  =
-  fun env ->
-    fun k ->
-      fun bs ->
-        fun subcomp_c ->
-          fun ct1 ->
-            fun ct2 ->
-              fun sub_prob ->
-                fun num_effect_params ->
-                  fun wl ->
-                    fun subcomp_name ->
-                      fun r1 ->
-                        let debug1 =
-                          FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                            (FStar_Options.Other "LayeredEffectsApp") in
-                        let uu___ =
-                          let uu___1 = bs in
-                          match uu___1 with
-                          | a_b::bs1 ->
-                              (bs1,
-                                [FStar_Syntax_Syntax.NT
-                                   ((a_b.FStar_Syntax_Syntax.binder_bv),
-                                     (ct2.FStar_Syntax_Syntax.result_typ))]) in
-                        match uu___ with
-                        | (bs1, subst) ->
-                            let uu___1 =
-                              if num_effect_params = Prims.int_zero
-                              then
-                                (bs1, subst,
-                                  (ct1.FStar_Syntax_Syntax.effect_args),
-                                  (ct2.FStar_Syntax_Syntax.effect_args), [],
-                                  wl)
-                              else
-                                (let split l =
-                                   FStar_Compiler_List.splitAt
-                                     num_effect_params l in
-                                 let uu___3 = split bs1 in
-                                 match uu___3 with
-                                 | (eff_params_bs, bs2) ->
-                                     let uu___4 =
-                                       split
-                                         ct1.FStar_Syntax_Syntax.effect_args in
-                                     (match uu___4 with
-                                      | (param_args1, args1) ->
-                                          let uu___5 =
-                                            split
-                                              ct2.FStar_Syntax_Syntax.effect_args in
-                                          (match uu___5 with
-                                           | (param_args2, args2) ->
-                                               let uu___6 =
-                                                 FStar_Compiler_List.fold_left2
-                                                   (fun uu___7 ->
-                                                      fun uu___8 ->
-                                                        fun uu___9 ->
-                                                          match (uu___7,
-                                                                  uu___8,
-                                                                  uu___9)
-                                                          with
-                                                          | ((ps, wl1),
-                                                             (t1, uu___10),
-                                                             (t2, uu___11))
-                                                              ->
-                                                              let uu___12 =
-                                                                sub_prob wl1
-                                                                  t1
-                                                                  FStar_TypeChecker_Common.EQ
-                                                                  t2
-                                                                  "effect params subcomp" in
-                                                              (match uu___12
-                                                               with
-                                                               | (p, wl2) ->
-                                                                   ((FStar_Compiler_List.op_At
-                                                                    ps [p]),
-                                                                    wl2)))
-                                                   ([], wl) param_args1
-                                                   param_args2 in
-                                               (match uu___6 with
-                                                | (probs, wl1) ->
-                                                    let param_subst =
-                                                      FStar_Compiler_List.map2
-                                                        (fun b ->
-                                                           fun uu___7 ->
-                                                             match uu___7
-                                                             with
-                                                             | (arg, uu___8)
-                                                                 ->
-                                                                 FStar_Syntax_Syntax.NT
-                                                                   ((b.FStar_Syntax_Syntax.binder_bv),
-                                                                    arg))
-                                                        eff_params_bs
-                                                        param_args1 in
-                                                    (bs2,
-                                                      (FStar_Compiler_List.op_At
-                                                         subst param_subst),
-                                                      args1, args2, probs,
-                                                      wl1))))) in
-                            (match uu___1 with
-                             | (bs2, subst1, args1, args2,
-                                eff_params_sub_probs, wl1) ->
-                                 let uu___2 =
-                                   let uu___3 =
-                                     FStar_Compiler_List.splitAt
-                                       (FStar_Compiler_List.length args1) bs2 in
-                                   match uu___3 with
-                                   | (f_bs, bs3) ->
-                                       let f_substs =
-                                         FStar_Compiler_List.map2
-                                           (fun f_b ->
-                                              fun uu___4 ->
-                                                match uu___4 with
-                                                | (arg, uu___5) ->
-                                                    FStar_Syntax_Syntax.NT
-                                                      ((f_b.FStar_Syntax_Syntax.binder_bv),
-                                                        arg)) f_bs args1 in
-                                       (bs3,
-                                         (FStar_Compiler_List.op_At subst1
-                                            f_substs)) in
-                                 (match uu___2 with
-                                  | (bs3, subst2) ->
-                                      let uu___3 =
-                                        if
-                                          FStar_Syntax_Syntax.uu___is_Substitutive_combinator
-                                            k
-                                        then
-                                          let uu___4 =
-                                            FStar_Compiler_List.splitAt
-                                              (FStar_Compiler_List.length
-                                                 args2) bs3 in
-                                          match uu___4 with
-                                          | (g_bs, bs4) ->
-                                              let g_substs =
-                                                FStar_Compiler_List.map2
-                                                  (fun g_b ->
-                                                     fun uu___5 ->
-                                                       match uu___5 with
-                                                       | (arg, uu___6) ->
-                                                           FStar_Syntax_Syntax.NT
-                                                             ((g_b.FStar_Syntax_Syntax.binder_bv),
-                                                               arg)) g_bs
-                                                  args2 in
-                                              (bs4,
-                                                (FStar_Compiler_List.op_At
-                                                   subst2 g_substs), [], wl1)
-                                        else
-                                          if
-                                            FStar_Syntax_Syntax.uu___is_Substitutive_invariant_combinator
-                                              k
-                                          then
-                                            (let uu___5 =
-                                               FStar_Compiler_List.fold_left2
-                                                 (fun uu___6 ->
-                                                    fun uu___7 ->
-                                                      fun uu___8 ->
-                                                        match (uu___6,
-                                                                uu___7,
-                                                                uu___8)
-                                                        with
-                                                        | ((ps, wl2),
-                                                           (t1, uu___9),
-                                                           (t2, uu___10)) ->
-                                                            let uu___11 =
-                                                              sub_prob wl2 t1
-                                                                FStar_TypeChecker_Common.EQ
-                                                                t2
-                                                                "substitutive inv subcomp args" in
-                                                            (match uu___11
-                                                             with
-                                                             | (p, wl3) ->
-                                                                 ((FStar_Compiler_List.op_At
-                                                                    ps 
-                                                                    [p]),
-                                                                   wl3)))
-                                                 ([], wl1) args1 args2 in
-                                             match uu___5 with
-                                             | (probs, wl2) ->
-                                                 (bs3, subst2, probs, wl2))
-                                          else
-                                            failwith
-                                              "Impossible (rel.apply_substitutive_indexed_subcomp unexpected k" in
-                                      (match uu___3 with
-                                       | (bs4, subst3, f_g_args_eq_sub_probs,
-                                          wl2) ->
-                                           let bs5 =
-                                             let uu___4 =
-                                               FStar_Compiler_List.splitAt
-                                                 ((FStar_Compiler_List.length
-                                                     bs4)
-                                                    - Prims.int_one) bs4 in
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               uu___4
-                                               FStar_Pervasives_Native.fst in
-                                           let uu___4 =
-                                             FStar_Compiler_List.fold_left
-                                               (fun uu___5 ->
-                                                  fun b ->
-                                                    match uu___5 with
-                                                    | (ss, wl3) ->
-                                                        let uu___6 =
-                                                          FStar_TypeChecker_Env.uvars_for_binders
-                                                            env [b] ss
-                                                            (fun b1 ->
-                                                               if debug1
-                                                               then
-                                                                 let uu___7 =
-                                                                   FStar_Syntax_Print.binder_to_string
-                                                                    b1 in
-                                                                 let uu___8 =
-                                                                   FStar_Compiler_Range.string_of_range
-                                                                    r1 in
-                                                                 FStar_Compiler_Util.format3
-                                                                   "implicit var for additional binder %s in subcomp %s at %s"
-                                                                   uu___7
-                                                                   subcomp_name
-                                                                   uu___8
-                                                               else
-                                                                 "apply_substitutive_indexed_subcomp")
-                                                            r1 in
-                                                        (match uu___6 with
-                                                         | (uv_t::[], g) ->
-                                                             ((FStar_Compiler_List.op_At
-                                                                 ss
-                                                                 [FStar_Syntax_Syntax.NT
-                                                                    ((b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uv_t)]),
-                                                               {
-                                                                 attempting =
-                                                                   (wl3.attempting);
-                                                                 wl_deferred
-                                                                   =
-                                                                   (wl3.wl_deferred);
-                                                                 wl_deferred_to_tac
-                                                                   =
-                                                                   (wl3.wl_deferred_to_tac);
-                                                                 ctr =
-                                                                   (wl3.ctr);
-                                                                 defer_ok =
-                                                                   (wl3.defer_ok);
-                                                                 smt_ok =
-                                                                   (wl3.smt_ok);
-                                                                 umax_heuristic_ok
-                                                                   =
-                                                                   (wl3.umax_heuristic_ok);
-                                                                 tcenv =
-                                                                   (wl3.tcenv);
-                                                                 wl_implicits
-                                                                   =
-                                                                   (FStar_Compiler_List.op_At
-                                                                    g.FStar_TypeChecker_Common.implicits
-                                                                    wl3.wl_implicits);
-                                                                 repr_subcomp_allowed
-                                                                   =
-                                                                   (wl3.repr_subcomp_allowed)
-                                                               })))
-                                               (subst3, wl2) bs5 in
-                                           (match uu___4 with
-                                            | (subst4, wl3) ->
-                                                let subcomp_ct =
-                                                  let uu___5 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      subcomp_c
-                                                      (FStar_Syntax_Subst.subst_comp
-                                                         subst4) in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___5
-                                                    (FStar_TypeChecker_Env.comp_to_comp_typ
-                                                       env) in
-                                                let fml =
-                                                  let uu___5 =
-                                                    let uu___6 =
-                                                      FStar_Compiler_List.hd
-                                                        subcomp_ct.FStar_Syntax_Syntax.comp_univs in
-                                                    let uu___7 =
-                                                      let uu___8 =
-                                                        FStar_Compiler_List.hd
-                                                          subcomp_ct.FStar_Syntax_Syntax.effect_args in
-                                                      FStar_Pervasives_Native.fst
-                                                        uu___8 in
-                                                    (uu___6, uu___7) in
-                                                  match uu___5 with
-                                                  | (u, wp) ->
-                                                      FStar_TypeChecker_Env.pure_precondition_for_trivial_post
-                                                        env u
-                                                        subcomp_ct.FStar_Syntax_Syntax.result_typ
-                                                        wp
-                                                        FStar_Compiler_Range.dummyRange in
-                                                (fml,
-                                                  (FStar_Compiler_List.op_At
-                                                     eff_params_sub_probs
-                                                     f_g_args_eq_sub_probs),
-                                                  wl3)))))
-let (apply_ad_hoc_indexed_subcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_Syntax_Syntax.comp_typ ->
-          FStar_Syntax_Syntax.comp_typ ->
-            (worklist ->
-               FStar_Syntax_Syntax.term ->
-                 FStar_TypeChecker_Common.rel ->
-                   FStar_Syntax_Syntax.term ->
-                     Prims.string ->
-                       (FStar_TypeChecker_Common.prob * worklist))
-              ->
-              worklist ->
-                Prims.string ->
-                  FStar_Compiler_Range.range ->
-                    (FStar_Syntax_Syntax.typ * FStar_TypeChecker_Common.prob
-                      Prims.list * worklist))
-  =
-  fun env ->
-    fun bs ->
-      fun subcomp_c ->
-        fun ct1 ->
-          fun ct2 ->
-            fun sub_prob ->
-              fun wl ->
-                fun subcomp_name ->
-                  fun r1 ->
-                    let dbg =
-                      FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                        (FStar_Options.Other "LayeredEffectsApp") in
-                    let stronger_t_shape_error s =
-                      let uu___ =
-                        FStar_Ident.string_of_lid
-                          ct2.FStar_Syntax_Syntax.effect_name in
-                      FStar_Compiler_Util.format2
-                        "Unexpected shape of stronger for %s, reason: %s"
-                        uu___ s in
-                    let uu___ =
-                      if
-                        (FStar_Compiler_List.length bs) >= (Prims.of_int (2))
-                      then
-                        let uu___1 = bs in
-                        match uu___1 with
-                        | a_b::bs1 ->
-                            let uu___2 =
-                              let uu___3 =
-                                FStar_Compiler_Effect.op_Bar_Greater bs1
-                                  (FStar_Compiler_List.splitAt
-                                     ((FStar_Compiler_List.length bs1) -
-                                        Prims.int_one)) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                (fun uu___4 ->
-                                   match uu___4 with
-                                   | (l1, l2) ->
-                                       let uu___5 = FStar_Compiler_List.hd l2 in
-                                       (l1, uu___5)) in
-                            (match uu___2 with
-                             | (rest_bs, f_b) -> (a_b, rest_bs, f_b))
-                      else
-                        (let uu___2 =
-                           let uu___3 =
-                             stronger_t_shape_error
-                               "not an arrow or not enough binders" in
-                           (FStar_Errors.Fatal_UnexpectedExpressionType,
-                             uu___3) in
-                         FStar_Errors.raise_error uu___2 r1) in
-                    match uu___ with
-                    | (a_b, rest_bs, f_b) ->
-                        let uu___1 =
-                          FStar_TypeChecker_Env.uvars_for_binders env rest_bs
-                            [FStar_Syntax_Syntax.NT
-                               ((a_b.FStar_Syntax_Syntax.binder_bv),
-                                 (ct2.FStar_Syntax_Syntax.result_typ))]
-                            (fun b ->
-                               if dbg
-                               then
-                                 let uu___2 =
-                                   FStar_Syntax_Print.binder_to_string b in
-                                 let uu___3 =
-                                   FStar_Compiler_Range.string_of_range r1 in
-                                 FStar_Compiler_Util.format3
-                                   "implicit for binder %s in subcomp %s at %s"
-                                   uu___2 subcomp_name uu___3
-                               else "apply_ad_hoc_indexed_subcomp") r1 in
-                        (match uu___1 with
-                         | (rest_bs_uvars, g_uvars) ->
-                             let wl1 =
-                               {
-                                 attempting = (wl.attempting);
-                                 wl_deferred = (wl.wl_deferred);
-                                 wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-                                 ctr = (wl.ctr);
-                                 defer_ok = (wl.defer_ok);
-                                 smt_ok = (wl.smt_ok);
-                                 umax_heuristic_ok = (wl.umax_heuristic_ok);
-                                 tcenv = (wl.tcenv);
-                                 wl_implicits =
-                                   (FStar_Compiler_List.op_At
-                                      g_uvars.FStar_TypeChecker_Common.implicits
-                                      wl.wl_implicits);
-                                 repr_subcomp_allowed =
-                                   (wl.repr_subcomp_allowed)
-                               } in
-                             let substs =
-                               FStar_Compiler_List.map2
-                                 (fun b ->
-                                    fun t ->
-                                      FStar_Syntax_Syntax.NT
-                                        ((b.FStar_Syntax_Syntax.binder_bv),
-                                          t)) (a_b :: rest_bs)
-                                 ((ct2.FStar_Syntax_Syntax.result_typ) ::
-                                 rest_bs_uvars) in
-                             let uu___2 =
-                               let f_sort_is =
-                                 let uu___3 =
-                                   let uu___4 =
-                                     FStar_TypeChecker_Env.is_layered_effect
-                                       env
-                                       ct1.FStar_Syntax_Syntax.effect_name in
-                                   let uu___5 =
-                                     stronger_t_shape_error
-                                       "type of f is not a repr type" in
-                                   FStar_Syntax_Util.effect_indices_from_repr
-                                     (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                     uu___4 r1 uu___5 in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                   (FStar_Compiler_List.map
-                                      (FStar_Syntax_Subst.subst substs)) in
-                               let uu___3 =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   ct1.FStar_Syntax_Syntax.effect_args
-                                   (FStar_Compiler_List.map
-                                      FStar_Pervasives_Native.fst) in
-                               FStar_Compiler_List.fold_left2
-                                 (fun uu___4 ->
-                                    fun f_sort_i ->
-                                      fun c1_i ->
-                                        match uu___4 with
-                                        | (ps, wl2) ->
-                                            ((let uu___6 =
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  (debug wl2)
-                                                  (FStar_Options.Other
-                                                     "LayeredEffectsEqns") in
-                                              if uu___6
-                                              then
-                                                let uu___7 =
-                                                  FStar_Syntax_Print.term_to_string
-                                                    f_sort_i in
-                                                let uu___8 =
-                                                  FStar_Syntax_Print.term_to_string
-                                                    c1_i in
-                                                FStar_Compiler_Util.print3
-                                                  "Layered Effects (%s) %s = %s\n"
-                                                  subcomp_name uu___7 uu___8
-                                              else ());
-                                             (let uu___6 =
-                                                sub_prob wl2 f_sort_i
-                                                  FStar_TypeChecker_Common.EQ
-                                                  c1_i "indices of c1" in
-                                              match uu___6 with
-                                              | (p, wl3) ->
-                                                  ((FStar_Compiler_List.op_At
-                                                      ps [p]), wl3))))
-                                 ([], wl1) f_sort_is uu___3 in
-                             (match uu___2 with
-                              | (f_sub_probs, wl2) ->
-                                  let subcomp_ct =
-                                    let uu___3 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        subcomp_c
-                                        (FStar_Syntax_Subst.subst_comp substs) in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___3
-                                      (FStar_TypeChecker_Env.comp_to_comp_typ
-                                         env) in
-                                  let uu___3 =
-                                    let g_sort_is =
-                                      let uu___4 =
-                                        FStar_TypeChecker_Env.is_layered_effect
-                                          env
-                                          ct2.FStar_Syntax_Syntax.effect_name in
-                                      let uu___5 =
-                                        stronger_t_shape_error
-                                          "subcomp return type is not a repr" in
-                                      FStar_Syntax_Util.effect_indices_from_repr
-                                        subcomp_ct.FStar_Syntax_Syntax.result_typ
-                                        uu___4 r1 uu___5 in
-                                    let uu___4 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        ct2.FStar_Syntax_Syntax.effect_args
-                                        (FStar_Compiler_List.map
-                                           FStar_Pervasives_Native.fst) in
-                                    FStar_Compiler_List.fold_left2
-                                      (fun uu___5 ->
-                                         fun g_sort_i ->
-                                           fun c2_i ->
-                                             match uu___5 with
-                                             | (ps, wl3) ->
-                                                 ((let uu___7 =
-                                                     FStar_Compiler_Effect.op_Less_Bar
-                                                       (debug wl3)
-                                                       (FStar_Options.Other
-                                                          "LayeredEffectsEqns") in
-                                                   if uu___7
-                                                   then
-                                                     let uu___8 =
-                                                       FStar_Syntax_Print.term_to_string
-                                                         g_sort_i in
-                                                     let uu___9 =
-                                                       FStar_Syntax_Print.term_to_string
-                                                         c2_i in
-                                                     FStar_Compiler_Util.print3
-                                                       "Layered Effects (%s) %s = %s\n"
-                                                       subcomp_name uu___8
-                                                       uu___9
-                                                   else ());
-                                                  (let uu___7 =
-                                                     sub_prob wl3 g_sort_i
-                                                       FStar_TypeChecker_Common.EQ
-                                                       c2_i "indices of c2" in
-                                                   match uu___7 with
-                                                   | (p, wl4) ->
-                                                       ((FStar_Compiler_List.op_At
-                                                           ps [p]), wl4))))
-                                      ([], wl2) g_sort_is uu___4 in
-                                  (match uu___3 with
-                                   | (g_sub_probs, wl3) ->
-                                       let fml =
-                                         let uu___4 =
-                                           let uu___5 =
-                                             FStar_Compiler_List.hd
-                                               subcomp_ct.FStar_Syntax_Syntax.comp_univs in
-                                           let uu___6 =
-                                             let uu___7 =
-                                               FStar_Compiler_List.hd
-                                                 subcomp_ct.FStar_Syntax_Syntax.effect_args in
-                                             FStar_Pervasives_Native.fst
-                                               uu___7 in
-                                           (uu___5, uu___6) in
-                                         match uu___4 with
-                                         | (u, wp) ->
-                                             FStar_TypeChecker_Env.pure_precondition_for_trivial_post
-                                               env u
-                                               subcomp_ct.FStar_Syntax_Syntax.result_typ
-                                               wp
-                                               FStar_Compiler_Range.dummyRange in
-                                       (fml,
-                                         (FStar_Compiler_List.op_At
-                                            f_sub_probs g_sub_probs), wl3))))
-let rec (solve : worklist -> solution) =
-  fun probs ->
-    (let uu___1 =
-       FStar_Compiler_Effect.op_Less_Bar (debug probs)
-         (FStar_Options.Other "Rel") in
-     if uu___1
-     then
-       let uu___2 = wl_to_string probs in
-       FStar_Compiler_Util.print1 "solve:\n\t%s\n" uu___2
-     else ());
-    (let uu___2 =
-       FStar_Compiler_Effect.op_Less_Bar (debug probs)
-         (FStar_Options.Other "ImplicitTrace") in
-     if uu___2
-     then
-       let uu___3 =
-         FStar_TypeChecker_Common.implicits_to_string probs.wl_implicits in
-       FStar_Compiler_Util.print1 "solve: wl_implicits = %s\n" uu___3
-     else ());
-    (let uu___2 = next_prob probs in
-     match uu___2 with
-     | FStar_Pervasives_Native.Some (hd, tl, rank1) ->
-         let probs1 =
-           {
-             attempting = tl;
-             wl_deferred = (probs.wl_deferred);
-             wl_deferred_to_tac = (probs.wl_deferred_to_tac);
-             ctr = (probs.ctr);
-             defer_ok = (probs.defer_ok);
-             smt_ok = (probs.smt_ok);
-             umax_heuristic_ok = (probs.umax_heuristic_ok);
-             tcenv = (probs.tcenv);
-             wl_implicits = (probs.wl_implicits);
-             repr_subcomp_allowed = (probs.repr_subcomp_allowed)
-           } in
-         (def_check_prob "solve,hd" hd;
-          (match hd with
-           | FStar_TypeChecker_Common.CProb cp ->
-               solve_c (maybe_invert cp) probs1
-           | FStar_TypeChecker_Common.TProb tp ->
-               let uu___4 =
-                 FStar_Compiler_Util.physical_equality
-                   tp.FStar_TypeChecker_Common.lhs
-                   tp.FStar_TypeChecker_Common.rhs in
-               if uu___4
-               then
-                 let uu___5 =
-                   solve_prob hd FStar_Pervasives_Native.None [] probs1 in
-                 solve uu___5
-               else
-                 if
-                   (rank1 = FStar_TypeChecker_Common.Rigid_rigid) ||
-                     ((tp.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ)
-                        && (rank1 <> FStar_TypeChecker_Common.Flex_flex))
-                 then solve_t' tp probs1
-                 else
-                   if probs1.defer_ok = DeferAny
-                   then
-                     maybe_defer_to_user_tac tp
-                       "deferring flex_rigid or flex_flex subtyping" probs1
-                   else
-                     if rank1 = FStar_TypeChecker_Common.Flex_flex
-                     then
-                       solve_t'
-                         {
-                           FStar_TypeChecker_Common.pid =
-                             (tp.FStar_TypeChecker_Common.pid);
-                           FStar_TypeChecker_Common.lhs =
-                             (tp.FStar_TypeChecker_Common.lhs);
-                           FStar_TypeChecker_Common.relation =
-                             FStar_TypeChecker_Common.EQ;
-                           FStar_TypeChecker_Common.rhs =
-                             (tp.FStar_TypeChecker_Common.rhs);
-                           FStar_TypeChecker_Common.element =
-                             (tp.FStar_TypeChecker_Common.element);
-                           FStar_TypeChecker_Common.logical_guard =
-                             (tp.FStar_TypeChecker_Common.logical_guard);
-                           FStar_TypeChecker_Common.logical_guard_uvar =
-                             (tp.FStar_TypeChecker_Common.logical_guard_uvar);
-                           FStar_TypeChecker_Common.reason =
-                             (tp.FStar_TypeChecker_Common.reason);
-                           FStar_TypeChecker_Common.loc =
-                             (tp.FStar_TypeChecker_Common.loc);
-                           FStar_TypeChecker_Common.rank =
-                             (tp.FStar_TypeChecker_Common.rank)
-                         } probs1
-                     else
-                       solve_rigid_flex_or_flex_rigid_subtyping rank1 tp
-                         probs1))
-     | FStar_Pervasives_Native.None ->
-         (match probs.wl_deferred with
-          | [] ->
-              let uu___3 =
-                let uu___4 = as_deferred probs.wl_deferred_to_tac in
-                ([], uu___4, (probs.wl_implicits)) in
-              Success uu___3
-          | uu___3 ->
-              let uu___4 =
-                FStar_Compiler_Effect.op_Bar_Greater probs.wl_deferred
-                  (FStar_Compiler_List.partition
-                     (fun uu___5 ->
-                        match uu___5 with
-                        | (c, uu___6, uu___7, uu___8) -> c < probs.ctr)) in
-              (match uu___4 with
-               | (attempt1, rest) ->
-                   (match attempt1 with
-                    | [] ->
-                        let uu___5 =
-                          let uu___6 = as_deferred probs.wl_deferred in
-                          let uu___7 = as_deferred probs.wl_deferred_to_tac in
-                          (uu___6, uu___7, (probs.wl_implicits)) in
-                        Success uu___5
-                    | uu___5 ->
-                        let uu___6 =
-                          let uu___7 =
-                            FStar_Compiler_Effect.op_Bar_Greater attempt1
-                              (FStar_Compiler_List.map
-                                 (fun uu___8 ->
-                                    match uu___8 with
-                                    | (uu___9, uu___10, uu___11, y) -> y)) in
-                          {
-                            attempting = uu___7;
-                            wl_deferred = rest;
-                            wl_deferred_to_tac = (probs.wl_deferred_to_tac);
-                            ctr = (probs.ctr);
-                            defer_ok = (probs.defer_ok);
-                            smt_ok = (probs.smt_ok);
-                            umax_heuristic_ok = (probs.umax_heuristic_ok);
-                            tcenv = (probs.tcenv);
-                            wl_implicits = (probs.wl_implicits);
-                            repr_subcomp_allowed =
-                              (probs.repr_subcomp_allowed)
-                          } in
-                        solve uu___6))))
-and (solve_one_universe_eq :
-  FStar_TypeChecker_Common.prob ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.universe -> worklist -> solution)
-  =
-  fun orig ->
-    fun u1 ->
-      fun u2 ->
-        fun wl ->
-          let uu___ = solve_universe_eq (p_pid orig) wl u1 u2 in
-          match uu___ with
-          | USolved wl1 ->
-              let uu___1 =
-                solve_prob orig FStar_Pervasives_Native.None [] wl1 in
-              solve uu___1
-          | UFailed msg -> giveup wl msg orig
-          | UDeferred wl1 ->
-              let uu___1 =
-                defer_lit FStar_TypeChecker_Common.Deferred_univ_constraint
-                  "" orig wl1 in
-              solve uu___1
-and (solve_maybe_uinsts :
-  FStar_TypeChecker_Common.prob ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> worklist -> univ_eq_sol)
-  =
-  fun orig ->
-    fun t1 ->
-      fun t2 ->
-        fun wl ->
-          let rec aux wl1 us1 us2 =
-            match (us1, us2) with
-            | ([], []) -> USolved wl1
-            | (u1::us11, u2::us21) ->
-                let uu___ = solve_universe_eq (p_pid orig) wl1 u1 u2 in
-                (match uu___ with
-                 | USolved wl2 -> aux wl2 us11 us21
-                 | failed_or_deferred -> failed_or_deferred)
-            | uu___ -> ufailed_simple "Unequal number of universes" in
-          let env = p_env wl orig in
-          FStar_TypeChecker_Env.def_check_closed_in_env
-            t1.FStar_Syntax_Syntax.pos "solve_maybe_uinsts.whnf1" env t1;
-          FStar_TypeChecker_Env.def_check_closed_in_env
-            t2.FStar_Syntax_Syntax.pos "solve_maybe_uinsts.whnf2" env t2;
-          (let t11 = whnf env t1 in
-           let t21 = whnf env t2 in
-           match ((t11.FStar_Syntax_Syntax.n), (t21.FStar_Syntax_Syntax.n))
-           with
-           | (FStar_Syntax_Syntax.Tm_uinst
-              ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar f;
-                 FStar_Syntax_Syntax.pos = uu___2;
-                 FStar_Syntax_Syntax.vars = uu___3;
-                 FStar_Syntax_Syntax.hash_code = uu___4;_},
-               us1),
-              FStar_Syntax_Syntax.Tm_uinst
-              ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar g;
-                 FStar_Syntax_Syntax.pos = uu___5;
-                 FStar_Syntax_Syntax.vars = uu___6;
-                 FStar_Syntax_Syntax.hash_code = uu___7;_},
-               us2)) ->
-               let b = FStar_Syntax_Syntax.fv_eq f g in aux wl us1 us2
-           | (FStar_Syntax_Syntax.Tm_uinst uu___2, uu___3) ->
-               failwith "Impossible: expect head symbols to match"
-           | (uu___2, FStar_Syntax_Syntax.Tm_uinst uu___3) ->
-               failwith "Impossible: expect head symbols to match"
-           | uu___2 -> USolved wl)
-and (giveup_or_defer :
-  FStar_TypeChecker_Common.prob ->
-    worklist ->
-      FStar_TypeChecker_Common.deferred_reason -> lstring -> solution)
-  =
-  fun orig ->
-    fun wl ->
-      fun reason ->
-        fun msg ->
-          if wl.defer_ok = DeferAny
-          then
-            ((let uu___1 =
-                FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                  (FStar_Options.Other "Rel") in
-              if uu___1
-              then
-                let uu___2 = prob_to_string wl.tcenv orig in
-                let uu___3 = FStar_Thunk.force msg in
-                FStar_Compiler_Util.print2
-                  "\n\t\tDeferring %s\n\t\tBecause %s\n" uu___2 uu___3
-              else ());
-             solve (defer reason msg orig wl))
-          else giveup wl msg orig
-and (giveup_or_defer_flex_flex :
-  FStar_TypeChecker_Common.prob ->
-    worklist ->
-      FStar_TypeChecker_Common.deferred_reason -> lstring -> solution)
-  =
-  fun orig ->
-    fun wl ->
-      fun reason ->
-        fun msg ->
-          if wl.defer_ok <> NoDefer
-          then
-            ((let uu___1 =
-                FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                  (FStar_Options.Other "Rel") in
-              if uu___1
-              then
-                let uu___2 = prob_to_string wl.tcenv orig in
-                let uu___3 = FStar_Thunk.force msg in
-                FStar_Compiler_Util.print2
-                  "\n\t\tDeferring %s\n\t\tBecause %s\n" uu___2 uu___3
-              else ());
-             solve (defer reason msg orig wl))
-          else giveup wl msg orig
-and (defer_to_user_tac :
-  FStar_TypeChecker_Common.prob -> Prims.string -> worklist -> solution) =
-  fun orig ->
-    fun reason ->
-      fun wl ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar (debug wl)
-             (FStar_Options.Other "Rel") in
-         if uu___1
-         then
-           let uu___2 = prob_to_string wl.tcenv orig in
-           FStar_Compiler_Util.print1 "\n\t\tDeferring %s to a tactic\n"
-             uu___2
-         else ());
-        (let wl1 = solve_prob orig FStar_Pervasives_Native.None [] wl in
-         let wl2 =
-           let uu___1 =
-             let uu___2 =
-               let uu___3 = FStar_Thunk.mkv reason in
-               ((wl1.ctr), FStar_TypeChecker_Common.Deferred_to_user_tac,
-                 uu___3, orig) in
-             uu___2 :: (wl1.wl_deferred_to_tac) in
-           {
-             attempting = (wl1.attempting);
-             wl_deferred = (wl1.wl_deferred);
-             wl_deferred_to_tac = uu___1;
-             ctr = (wl1.ctr);
-             defer_ok = (wl1.defer_ok);
-             smt_ok = (wl1.smt_ok);
-             umax_heuristic_ok = (wl1.umax_heuristic_ok);
-             tcenv = (wl1.tcenv);
-             wl_implicits = (wl1.wl_implicits);
-             repr_subcomp_allowed = (wl1.repr_subcomp_allowed)
-           } in
-         solve wl2)
-and (maybe_defer_to_user_tac :
-  FStar_Syntax_Syntax.typ FStar_TypeChecker_Common.problem ->
-    Prims.string -> worklist -> solution)
-  =
-  fun prob ->
-    fun reason ->
-      fun wl ->
-        match prob.FStar_TypeChecker_Common.relation with
-        | FStar_TypeChecker_Common.EQ ->
-            let should_defer_tac t =
-              let uu___ = FStar_Syntax_Util.head_and_args t in
-              match uu___ with
-              | (head, uu___1) ->
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Subst.compress head in
-                    uu___3.FStar_Syntax_Syntax.n in
-                  (match uu___2 with
-                   | FStar_Syntax_Syntax.Tm_uvar (uv, uu___3) ->
-                       let uu___4 =
-                         FStar_TypeChecker_DeferredImplicits.should_defer_uvar_to_user_tac
-                           wl.tcenv uv in
-                       (uu___4, (uv.FStar_Syntax_Syntax.ctx_uvar_reason))
-                   | uu___3 -> (false, "")) in
-            let uu___ = should_defer_tac prob.FStar_TypeChecker_Common.lhs in
-            (match uu___ with
-             | (l1, r1) ->
-                 let uu___1 =
-                   should_defer_tac prob.FStar_TypeChecker_Common.rhs in
-                 (match uu___1 with
-                  | (l2, r2) ->
-                      if l1 || l2
-                      then
-                        defer_to_user_tac
-                          (FStar_TypeChecker_Common.TProb prob)
-                          (Prims.op_Hat r1 (Prims.op_Hat ", " r2)) wl
-                      else
-                        (let uu___3 =
-                           defer_lit FStar_TypeChecker_Common.Deferred_flex
-                             reason (FStar_TypeChecker_Common.TProb prob) wl in
-                         solve uu___3)))
-        | uu___ ->
-            let uu___1 =
-              defer_lit FStar_TypeChecker_Common.Deferred_flex reason
-                (FStar_TypeChecker_Common.TProb prob) wl in
-            solve uu___1
-and (solve_rigid_flex_or_flex_rigid_subtyping :
-  FStar_TypeChecker_Common.rank_t -> tprob -> worklist -> solution) =
-  fun rank1 ->
-    fun tp ->
-      fun wl ->
-        def_check_prob "solve_rigid_flex_or_flex_rigid_subtyping"
-          (FStar_TypeChecker_Common.TProb tp);
-        (let flip = rank1 = FStar_TypeChecker_Common.Flex_rigid in
-         let meet_or_join op ts wl1 =
-           let eq_prob t1 t2 wl2 =
-             let uu___1 =
-               new_problem wl2
-                 (p_env wl2 (FStar_TypeChecker_Common.TProb tp)) t1
-                 FStar_TypeChecker_Common.EQ t2 FStar_Pervasives_Native.None
-                 t1.FStar_Syntax_Syntax.pos "join/meet refinements" in
-             match uu___1 with
-             | (p, wl3) ->
-                 (def_check_prob "meet_or_join"
-                    (FStar_TypeChecker_Common.TProb p);
-                  ((FStar_TypeChecker_Common.TProb p), wl3)) in
-           let pairwise t1 t2 wl2 =
-             (let uu___2 =
-                FStar_Compiler_Effect.op_Less_Bar (debug wl2)
-                  (FStar_Options.Other "Rel") in
-              if uu___2
-              then
-                let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-                let uu___4 = FStar_Syntax_Print.term_to_string t2 in
-                FStar_Compiler_Util.print2
-                  "[meet/join]: pairwise: %s and %s\n" uu___3 uu___4
-              else ());
-             (let uu___2 =
-                head_matches_delta
-                  (p_env wl2 (FStar_TypeChecker_Common.TProb tp)) wl2.smt_ok
-                  t1 t2 in
-              match uu___2 with
-              | (mr, ts1) ->
-                  (match mr with
-                   | HeadMatch (true) ->
-                       let uu___3 = eq_prob t1 t2 wl2 in
-                       (match uu___3 with | (p, wl3) -> (t1, [p], wl3))
-                   | MisMatch uu___3 ->
-                       let uu___4 = eq_prob t1 t2 wl2 in
-                       (match uu___4 with | (p, wl3) -> (t1, [p], wl3))
-                   | FullMatch ->
-                       (match ts1 with
-                        | FStar_Pervasives_Native.None -> (t1, [], wl2)
-                        | FStar_Pervasives_Native.Some (t11, t21) ->
-                            (t11, [], wl2))
-                   | HeadMatch (false) ->
-                       let uu___3 =
-                         match ts1 with
-                         | FStar_Pervasives_Native.Some (t11, t21) ->
-                             let uu___4 = FStar_Syntax_Subst.compress t11 in
-                             let uu___5 = FStar_Syntax_Subst.compress t21 in
-                             (uu___4, uu___5)
-                         | FStar_Pervasives_Native.None ->
-                             let uu___4 = FStar_Syntax_Subst.compress t1 in
-                             let uu___5 = FStar_Syntax_Subst.compress t2 in
-                             (uu___4, uu___5) in
-                       (match uu___3 with
-                        | (t11, t21) ->
-                            let try_eq t12 t22 wl3 =
-                              let uu___4 =
-                                FStar_Syntax_Util.head_and_args t12 in
-                              match uu___4 with
-                              | (t1_hd, t1_args) ->
-                                  let uu___5 =
-                                    FStar_Syntax_Util.head_and_args t22 in
-                                  (match uu___5 with
-                                   | (t2_hd, t2_args) ->
-                                       if
-                                         (FStar_Compiler_List.length t1_args)
-                                           <>
-                                           (FStar_Compiler_List.length
-                                              t2_args)
-                                       then FStar_Pervasives_Native.None
-                                       else
-                                         (let uu___7 =
-                                            let uu___8 =
-                                              let uu___9 =
-                                                FStar_Syntax_Syntax.as_arg
-                                                  t1_hd in
-                                              uu___9 :: t1_args in
-                                            let uu___9 =
-                                              let uu___10 =
-                                                FStar_Syntax_Syntax.as_arg
-                                                  t2_hd in
-                                              uu___10 :: t2_args in
-                                            FStar_Compiler_List.fold_left2
-                                              (fun uu___10 ->
-                                                 fun uu___11 ->
-                                                   fun uu___12 ->
-                                                     match (uu___10, uu___11,
-                                                             uu___12)
-                                                     with
-                                                     | ((probs, wl4),
-                                                        (a1, uu___13),
-                                                        (a2, uu___14)) ->
-                                                         let uu___15 =
-                                                           eq_prob a1 a2 wl4 in
-                                                         (match uu___15 with
-                                                          | (p, wl5) ->
-                                                              ((p :: probs),
-                                                                wl5)))
-                                              ([], wl3) uu___8 uu___9 in
-                                          match uu___7 with
-                                          | (probs, wl4) ->
-                                              let wl' =
-                                                {
-                                                  attempting = probs;
-                                                  wl_deferred = [];
-                                                  wl_deferred_to_tac =
-                                                    (wl4.wl_deferred_to_tac);
-                                                  ctr = (wl4.ctr);
-                                                  defer_ok = NoDefer;
-                                                  smt_ok = false;
-                                                  umax_heuristic_ok =
-                                                    (wl4.umax_heuristic_ok);
-                                                  tcenv = (wl4.tcenv);
-                                                  wl_implicits = [];
-                                                  repr_subcomp_allowed =
-                                                    (wl4.repr_subcomp_allowed)
-                                                } in
-                                              let tx =
-                                                FStar_Syntax_Unionfind.new_transaction
-                                                  () in
-                                              let uu___8 = solve wl' in
-                                              (match uu___8 with
-                                               | Success
-                                                   (uu___9, defer_to_tac,
-                                                    imps)
-                                                   ->
-                                                   (FStar_Syntax_Unionfind.commit
-                                                      tx;
-                                                    (let uu___11 =
-                                                       extend_wl wl4 []
-                                                         defer_to_tac imps in
-                                                     FStar_Pervasives_Native.Some
-                                                       uu___11))
-                                               | Failed uu___9 ->
-                                                   (FStar_Syntax_Unionfind.rollback
-                                                      tx;
-                                                    FStar_Pervasives_Native.None)))) in
-                            let combine t12 t22 wl3 =
-                              let env =
-                                p_env wl3 (FStar_TypeChecker_Common.TProb tp) in
-                              let uu___4 =
-                                base_and_refinement_maybe_delta false env t12 in
-                              match uu___4 with
-                              | (t1_base, p1_opt) ->
-                                  let uu___5 =
-                                    base_and_refinement_maybe_delta false env
-                                      t22 in
-                                  (match uu___5 with
-                                   | (t2_base, p2_opt) ->
-                                       let apply_op env1 op1 phi1 phi2 =
-                                         let squash phi =
-                                           let uu___6 =
-                                             env1.FStar_TypeChecker_Env.universe_of
-                                               env1 phi in
-                                           match uu___6 with
-                                           | FStar_Syntax_Syntax.U_zero ->
-                                               phi
-                                           | u ->
-                                               FStar_Syntax_Util.mk_squash u
-                                                 phi in
-                                         let uu___6 = squash phi1 in
-                                         let uu___7 = squash phi2 in
-                                         op1 uu___6 uu___7 in
-                                       let combine_refinements t_base p1_opt1
-                                         p2_opt1 =
-                                         let refine x t =
-                                           let uu___6 =
-                                             FStar_Syntax_Util.is_t_true t in
-                                           if uu___6
-                                           then x.FStar_Syntax_Syntax.sort
-                                           else FStar_Syntax_Util.refine x t in
-                                         match (p1_opt1, p2_opt1) with
-                                         | (FStar_Pervasives_Native.Some
-                                            (x, phi1),
-                                            FStar_Pervasives_Native.Some
-                                            (y, phi2)) ->
-                                             let x1 =
-                                               FStar_Syntax_Syntax.freshen_bv
-                                                 x in
-                                             let subst =
-                                               [FStar_Syntax_Syntax.DB
-                                                  (Prims.int_zero, x1)] in
-                                             let phi11 =
-                                               FStar_Syntax_Subst.subst subst
-                                                 phi1 in
-                                             let phi21 =
-                                               FStar_Syntax_Subst.subst subst
-                                                 phi2 in
-                                             let env_x =
-                                               FStar_TypeChecker_Env.push_bv
-                                                 env x1 in
-                                             let uu___6 =
-                                               apply_op env_x op phi11 phi21 in
-                                             refine x1 uu___6
-                                         | (FStar_Pervasives_Native.None,
-                                            FStar_Pervasives_Native.Some
-                                            (x, phi)) ->
-                                             let x1 =
-                                               FStar_Syntax_Syntax.freshen_bv
-                                                 x in
-                                             let subst =
-                                               [FStar_Syntax_Syntax.DB
-                                                  (Prims.int_zero, x1)] in
-                                             let phi1 =
-                                               FStar_Syntax_Subst.subst subst
-                                                 phi in
-                                             let env_x =
-                                               FStar_TypeChecker_Env.push_bv
-                                                 env x1 in
-                                             let uu___6 =
-                                               apply_op env_x op
-                                                 FStar_Syntax_Util.t_true
-                                                 phi1 in
-                                             refine x1 uu___6
-                                         | (FStar_Pervasives_Native.Some
-                                            (x, phi),
-                                            FStar_Pervasives_Native.None) ->
-                                             let x1 =
-                                               FStar_Syntax_Syntax.freshen_bv
-                                                 x in
-                                             let subst =
-                                               [FStar_Syntax_Syntax.DB
-                                                  (Prims.int_zero, x1)] in
-                                             let phi1 =
-                                               FStar_Syntax_Subst.subst subst
-                                                 phi in
-                                             let env_x =
-                                               FStar_TypeChecker_Env.push_bv
-                                                 env x1 in
-                                             let uu___6 =
-                                               apply_op env_x op
-                                                 FStar_Syntax_Util.t_true
-                                                 phi1 in
-                                             refine x1 uu___6
-                                         | uu___6 -> t_base in
-                                       let uu___6 =
-                                         try_eq t1_base t2_base wl3 in
-                                       (match uu___6 with
-                                        | FStar_Pervasives_Native.Some wl4 ->
-                                            let uu___7 =
-                                              combine_refinements t1_base
-                                                p1_opt p2_opt in
-                                            (uu___7, [], wl4)
-                                        | FStar_Pervasives_Native.None ->
-                                            let uu___7 =
-                                              base_and_refinement_maybe_delta
-                                                true env t12 in
-                                            (match uu___7 with
-                                             | (t1_base1, p1_opt1) ->
-                                                 let uu___8 =
-                                                   base_and_refinement_maybe_delta
-                                                     true env t22 in
-                                                 (match uu___8 with
-                                                  | (t2_base1, p2_opt1) ->
-                                                      let uu___9 =
-                                                        eq_prob t1_base1
-                                                          t2_base1 wl3 in
-                                                      (match uu___9 with
-                                                       | (p, wl4) ->
-                                                           let t =
-                                                             combine_refinements
-                                                               t1_base1
-                                                               p1_opt1
-                                                               p2_opt1 in
-                                                           (t, [p], wl4)))))) in
-                            let uu___4 = combine t11 t21 wl2 in
-                            (match uu___4 with
-                             | (t12, ps, wl3) ->
-                                 ((let uu___6 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (debug wl3)
-                                       (FStar_Options.Other "Rel") in
-                                   if uu___6
-                                   then
-                                     let uu___7 =
-                                       FStar_Syntax_Print.term_to_string t12 in
-                                     FStar_Compiler_Util.print1
-                                       "pairwise fallback2 succeeded: %s"
-                                       uu___7
-                                   else ());
-                                  (t12, ps, wl3)))))) in
-           let rec aux uu___1 ts1 =
-             match uu___1 with
-             | (out, probs, wl2) ->
-                 (match ts1 with
-                  | [] -> (out, probs, wl2)
-                  | t::ts2 ->
-                      let uu___2 = pairwise out t wl2 in
-                      (match uu___2 with
-                       | (out1, probs', wl3) ->
-                           aux
-                             (out1, (FStar_Compiler_List.op_At probs probs'),
-                               wl3) ts2)) in
-           let uu___1 =
-             let uu___2 = FStar_Compiler_List.hd ts in (uu___2, [], wl1) in
-           let uu___2 = FStar_Compiler_List.tl ts in aux uu___1 uu___2 in
-         let uu___1 =
-           if flip
-           then
-             ((tp.FStar_TypeChecker_Common.lhs),
-               (tp.FStar_TypeChecker_Common.rhs))
-           else
-             ((tp.FStar_TypeChecker_Common.rhs),
-               (tp.FStar_TypeChecker_Common.lhs)) in
-         match uu___1 with
-         | (this_flex, this_rigid) ->
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Subst.compress this_rigid in
-               uu___3.FStar_Syntax_Syntax.n in
-             (match uu___2 with
-              | FStar_Syntax_Syntax.Tm_arrow (_bs, comp) ->
-                  let uu___3 = FStar_Syntax_Util.is_tot_or_gtot_comp comp in
-                  if uu___3
-                  then
-                    let uu___4 = destruct_flex_t this_flex wl in
-                    (match uu___4 with
-                     | (flex, wl1) ->
-                         let uu___5 = quasi_pattern wl1.tcenv flex in
-                         (match uu___5 with
-                          | FStar_Pervasives_Native.None ->
-                              giveup_lit wl1
-                                "flex-arrow subtyping, not a quasi pattern"
-                                (FStar_TypeChecker_Common.TProb tp)
-                          | FStar_Pervasives_Native.Some (flex_bs, flex_t1)
-                              ->
-                              ((let uu___7 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (debug wl1) (FStar_Options.Other "Rel") in
-                                if uu___7
-                                then
-                                  let uu___8 =
-                                    FStar_Compiler_Util.string_of_int
-                                      tp.FStar_TypeChecker_Common.pid in
-                                  FStar_Compiler_Util.print1
-                                    "Trying to solve by imitating arrow:%s\n"
-                                    uu___8
-                                else ());
-                               imitate_arrow
-                                 (FStar_TypeChecker_Common.TProb tp) wl1 flex
-                                 flex_bs flex_t1
-                                 tp.FStar_TypeChecker_Common.relation
-                                 this_rigid)))
-                  else
-                    (let uu___5 =
-                       attempt
-                         [FStar_TypeChecker_Common.TProb
-                            {
-                              FStar_TypeChecker_Common.pid =
-                                (tp.FStar_TypeChecker_Common.pid);
-                              FStar_TypeChecker_Common.lhs =
-                                (tp.FStar_TypeChecker_Common.lhs);
-                              FStar_TypeChecker_Common.relation =
-                                FStar_TypeChecker_Common.EQ;
-                              FStar_TypeChecker_Common.rhs =
-                                (tp.FStar_TypeChecker_Common.rhs);
-                              FStar_TypeChecker_Common.element =
-                                (tp.FStar_TypeChecker_Common.element);
-                              FStar_TypeChecker_Common.logical_guard =
-                                (tp.FStar_TypeChecker_Common.logical_guard);
-                              FStar_TypeChecker_Common.logical_guard_uvar =
-                                (tp.FStar_TypeChecker_Common.logical_guard_uvar);
-                              FStar_TypeChecker_Common.reason =
-                                (tp.FStar_TypeChecker_Common.reason);
-                              FStar_TypeChecker_Common.loc =
-                                (tp.FStar_TypeChecker_Common.loc);
-                              FStar_TypeChecker_Common.rank =
-                                (tp.FStar_TypeChecker_Common.rank)
-                            }] wl in
-                     solve uu___5)
-              | uu___3 ->
-                  ((let uu___5 =
-                      FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                        (FStar_Options.Other "Rel") in
-                    if uu___5
-                    then
-                      let uu___6 =
-                        FStar_Compiler_Util.string_of_int
-                          tp.FStar_TypeChecker_Common.pid in
-                      FStar_Compiler_Util.print1
-                        "Trying to solve by meeting refinements:%s\n" uu___6
-                    else ());
-                   (let uu___5 = FStar_Syntax_Util.head_and_args this_flex in
-                    match uu___5 with
-                    | (u, _args) ->
-                        let env =
-                          p_env wl (FStar_TypeChecker_Common.TProb tp) in
-                        let uu___6 =
-                          let uu___7 = FStar_Syntax_Subst.compress u in
-                          uu___7.FStar_Syntax_Syntax.n in
-                        (match uu___6 with
-                         | FStar_Syntax_Syntax.Tm_uvar (ctx_uvar, _subst) ->
-                             let equiv t =
-                               let uu___7 = FStar_Syntax_Util.head_and_args t in
-                               match uu___7 with
-                               | (u', uu___8) ->
-                                   let uu___9 =
-                                     let uu___10 = whnf env u' in
-                                     uu___10.FStar_Syntax_Syntax.n in
-                                   (match uu___9 with
-                                    | FStar_Syntax_Syntax.Tm_uvar
-                                        (ctx_uvar', _subst') ->
-                                        FStar_Syntax_Unionfind.equiv
-                                          ctx_uvar.FStar_Syntax_Syntax.ctx_uvar_head
-                                          ctx_uvar'.FStar_Syntax_Syntax.ctx_uvar_head
-                                    | uu___10 -> false) in
-                             let uu___7 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 wl.attempting
-                                 (FStar_Compiler_List.partition
-                                    (fun uu___8 ->
-                                       match uu___8 with
-                                       | FStar_TypeChecker_Common.TProb tp1
-                                           ->
-                                           let tp2 = maybe_invert tp1 in
-                                           (match tp2.FStar_TypeChecker_Common.rank
-                                            with
-                                            | FStar_Pervasives_Native.Some
-                                                rank' when rank1 = rank' ->
-                                                if flip
-                                                then
-                                                  equiv
-                                                    tp2.FStar_TypeChecker_Common.lhs
-                                                else
-                                                  equiv
-                                                    tp2.FStar_TypeChecker_Common.rhs
-                                            | uu___9 -> false)
-                                       | uu___9 -> false)) in
-                             (match uu___7 with
-                              | (bounds_probs, rest) ->
-                                  let bounds_typs =
-                                    let uu___8 = whnf env this_rigid in
-                                    let uu___9 =
-                                      FStar_Compiler_List.collect
-                                        (fun uu___10 ->
-                                           match uu___10 with
-                                           | FStar_TypeChecker_Common.TProb p
-                                               ->
-                                               let uu___11 =
-                                                 if flip
-                                                 then
-                                                   whnf env
-                                                     (maybe_invert p).FStar_TypeChecker_Common.rhs
-                                                 else
-                                                   whnf env
-                                                     (maybe_invert p).FStar_TypeChecker_Common.lhs in
-                                               [uu___11]
-                                           | uu___11 -> []) bounds_probs in
-                                    uu___8 :: uu___9 in
-                                  let uu___8 =
-                                    meet_or_join
-                                      (if flip
-                                       then FStar_Syntax_Util.mk_conj_simp
-                                       else FStar_Syntax_Util.mk_disj_simp)
-                                      bounds_typs wl in
-                                  (match uu___8 with
-                                   | (bound, sub_probs, wl1) ->
-                                       let uu___9 =
-                                         let flex_u =
-                                           flex_uvar_head this_flex in
-                                         let bound1 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_Syntax_Subst.compress
-                                                 bound in
-                                             uu___11.FStar_Syntax_Syntax.n in
-                                           match uu___10 with
-                                           | FStar_Syntax_Syntax.Tm_refine
-                                               (x, phi) when
-                                               (tp.FStar_TypeChecker_Common.relation
-                                                  =
-                                                  FStar_TypeChecker_Common.SUB)
-                                                 &&
-                                                 (let uu___11 =
-                                                    occurs flex_u
-                                                      x.FStar_Syntax_Syntax.sort in
-                                                  FStar_Pervasives_Native.snd
-                                                    uu___11)
-                                               -> x.FStar_Syntax_Syntax.sort
-                                           | uu___11 -> bound in
-                                         let uu___10 =
-                                           new_problem wl1
-                                             (p_env wl1
-                                                (FStar_TypeChecker_Common.TProb
-                                                   tp)) bound1
-                                             FStar_TypeChecker_Common.EQ
-                                             this_flex
-                                             FStar_Pervasives_Native.None
-                                             tp.FStar_TypeChecker_Common.loc
-                                             (if flip
-                                              then "joining refinements"
-                                              else "meeting refinements") in
-                                         (bound1, uu___10) in
-                                       (match uu___9 with
-                                        | (bound_typ, (eq_prob, wl')) ->
-                                            (def_check_prob "meet_or_join2"
-                                               (FStar_TypeChecker_Common.TProb
-                                                  eq_prob);
-                                             (let uu___12 =
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  (debug wl1)
-                                                  (FStar_Options.Other "Rel") in
-                                              if uu___12
-                                              then
-                                                let wl'1 =
-                                                  {
-                                                    attempting =
-                                                      ((FStar_TypeChecker_Common.TProb
-                                                          eq_prob) ::
-                                                      sub_probs);
-                                                    wl_deferred =
-                                                      (wl1.wl_deferred);
-                                                    wl_deferred_to_tac =
-                                                      (wl1.wl_deferred_to_tac);
-                                                    ctr = (wl1.ctr);
-                                                    defer_ok = (wl1.defer_ok);
-                                                    smt_ok = (wl1.smt_ok);
-                                                    umax_heuristic_ok =
-                                                      (wl1.umax_heuristic_ok);
-                                                    tcenv = (wl1.tcenv);
-                                                    wl_implicits =
-                                                      (wl1.wl_implicits);
-                                                    repr_subcomp_allowed =
-                                                      (wl1.repr_subcomp_allowed)
-                                                  } in
-                                                let uu___13 =
-                                                  wl_to_string wl'1 in
-                                                FStar_Compiler_Util.print1
-                                                  "After meet/join refinements: %s\n"
-                                                  uu___13
-                                              else ());
-                                             (let tx =
-                                                FStar_Syntax_Unionfind.new_transaction
-                                                  () in
-                                              let uu___12 =
-                                                solve_t eq_prob
-                                                  {
-                                                    attempting = sub_probs;
-                                                    wl_deferred = [];
-                                                    wl_deferred_to_tac =
-                                                      (wl'.wl_deferred_to_tac);
-                                                    ctr = (wl'.ctr);
-                                                    defer_ok = NoDefer;
-                                                    smt_ok = (wl'.smt_ok);
-                                                    umax_heuristic_ok =
-                                                      (wl'.umax_heuristic_ok);
-                                                    tcenv = (wl'.tcenv);
-                                                    wl_implicits = [];
-                                                    repr_subcomp_allowed =
-                                                      (wl'.repr_subcomp_allowed)
-                                                  } in
-                                              match uu___12 with
-                                              | Success
-                                                  (uu___13, defer_to_tac,
-                                                   imps)
-                                                  ->
-                                                  let wl2 =
-                                                    {
-                                                      attempting = rest;
-                                                      wl_deferred =
-                                                        (wl'.wl_deferred);
-                                                      wl_deferred_to_tac =
-                                                        (wl'.wl_deferred_to_tac);
-                                                      ctr = (wl'.ctr);
-                                                      defer_ok =
-                                                        (wl'.defer_ok);
-                                                      smt_ok = (wl'.smt_ok);
-                                                      umax_heuristic_ok =
-                                                        (wl'.umax_heuristic_ok);
-                                                      tcenv = (wl'.tcenv);
-                                                      wl_implicits =
-                                                        (wl'.wl_implicits);
-                                                      repr_subcomp_allowed =
-                                                        (wl'.repr_subcomp_allowed)
-                                                    } in
-                                                  let wl3 =
-                                                    extend_wl wl2 []
-                                                      defer_to_tac imps in
-                                                  let g =
-                                                    FStar_Compiler_List.fold_left
-                                                      (fun g1 ->
-                                                         fun p ->
-                                                           FStar_Syntax_Util.mk_conj
-                                                             g1 (p_guard p))
-                                                      eq_prob.FStar_TypeChecker_Common.logical_guard
-                                                      sub_probs in
-                                                  let wl4 =
-                                                    solve_prob' false
-                                                      (FStar_TypeChecker_Common.TProb
-                                                         tp)
-                                                      (FStar_Pervasives_Native.Some
-                                                         g) [] wl3 in
-                                                  let uu___14 =
-                                                    FStar_Compiler_List.fold_left
-                                                      (fun wl5 ->
-                                                         fun p ->
-                                                           solve_prob' true p
-                                                             FStar_Pervasives_Native.None
-                                                             [] wl5) wl4
-                                                      bounds_probs in
-                                                  (FStar_Syntax_Unionfind.commit
-                                                     tx;
-                                                   solve wl4)
-                                              | Failed (p, msg) ->
-                                                  ((let uu___14 =
-                                                      FStar_Compiler_Effect.op_Less_Bar
-                                                        (debug wl1)
-                                                        (FStar_Options.Other
-                                                           "Rel") in
-                                                    if uu___14
-                                                    then
-                                                      let uu___15 =
-                                                        let uu___16 =
-                                                          FStar_Compiler_List.map
-                                                            (prob_to_string
-                                                               env)
-                                                            ((FStar_TypeChecker_Common.TProb
-                                                                eq_prob) ::
-                                                            sub_probs) in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___16
-                                                          (FStar_String.concat
-                                                             "\n") in
-                                                      FStar_Compiler_Util.print1
-                                                        "meet/join attempted and failed to solve problems:\n%s\n"
-                                                        uu___15
-                                                    else ());
-                                                   (let uu___14 =
-                                                      let uu___15 =
-                                                        base_and_refinement
-                                                          env bound_typ in
-                                                      (rank1, uu___15) in
-                                                    match uu___14 with
-                                                    | (FStar_TypeChecker_Common.Rigid_flex,
-                                                       (t_base,
-                                                        FStar_Pervasives_Native.Some
-                                                        uu___15)) ->
-                                                        (FStar_Syntax_Unionfind.rollback
-                                                           tx;
-                                                         (let uu___17 =
-                                                            new_problem wl1
-                                                              (p_env wl1
-                                                                 (FStar_TypeChecker_Common.TProb
-                                                                    tp))
-                                                              t_base
-                                                              FStar_TypeChecker_Common.EQ
-                                                              this_flex
-                                                              FStar_Pervasives_Native.None
-                                                              tp.FStar_TypeChecker_Common.loc
-                                                              "widened subtyping" in
-                                                          match uu___17 with
-                                                          | (eq_prob1, wl2)
-                                                              ->
-                                                              (def_check_prob
-                                                                 "meet_or_join3"
-                                                                 (FStar_TypeChecker_Common.TProb
-                                                                    eq_prob1);
-                                                               (let wl3 =
-                                                                  solve_prob'
-                                                                    false
-                                                                    (
-                                                                    FStar_TypeChecker_Common.TProb
-                                                                    tp)
-                                                                    (
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (p_guard
-                                                                    (FStar_TypeChecker_Common.TProb
-                                                                    eq_prob1)))
-                                                                    [] wl2 in
-                                                                let uu___19 =
-                                                                  attempt
-                                                                    [
-                                                                    FStar_TypeChecker_Common.TProb
-                                                                    eq_prob1]
-                                                                    wl3 in
-                                                                solve uu___19))))
-                                                    | (FStar_TypeChecker_Common.Flex_rigid,
-                                                       (t_base,
-                                                        FStar_Pervasives_Native.Some
-                                                        (x, phi))) ->
-                                                        (FStar_Syntax_Unionfind.rollback
-                                                           tx;
-                                                         (let uu___16 =
-                                                            new_problem wl1
-                                                              env t_base
-                                                              FStar_TypeChecker_Common.EQ
-                                                              this_flex
-                                                              FStar_Pervasives_Native.None
-                                                              tp.FStar_TypeChecker_Common.loc
-                                                              "widened subtyping" in
-                                                          match uu___16 with
-                                                          | (eq_prob1, wl2)
-                                                              ->
-                                                              (def_check_prob
-                                                                 "meet_or_join4"
-                                                                 (FStar_TypeChecker_Common.TProb
-                                                                    eq_prob1);
-                                                               (let phi1 =
-                                                                  guard_on_element
-                                                                    wl2 tp x
-                                                                    phi in
-                                                                let wl3 =
-                                                                  let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Syntax_Util.mk_conj
-                                                                    phi1
-                                                                    (p_guard
-                                                                    (FStar_TypeChecker_Common.TProb
-                                                                    eq_prob1)) in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___19 in
-                                                                  solve_prob'
-                                                                    false
-                                                                    (
-                                                                    FStar_TypeChecker_Common.TProb
-                                                                    tp)
-                                                                    uu___18
-                                                                    [] wl2 in
-                                                                let uu___18 =
-                                                                  attempt
-                                                                    [
-                                                                    FStar_TypeChecker_Common.TProb
-                                                                    eq_prob1]
-                                                                    wl3 in
-                                                                solve uu___18))))
-                                                    | uu___15 ->
-                                                        let uu___16 =
-                                                          FStar_Thunk.map
-                                                            (fun s ->
-                                                               Prims.op_Hat
-                                                                 "failed to solve the sub-problems: "
-                                                                 s) msg in
-                                                        giveup wl1 uu___16 p)))))))
-                         | uu___7 when flip ->
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_Compiler_Util.string_of_int
-                                   (rank_t_num rank1) in
-                               let uu___10 =
-                                 prob_to_string env
-                                   (FStar_TypeChecker_Common.TProb tp) in
-                               FStar_Compiler_Util.format2
-                                 "Impossible: (rank=%s) Not a flex-rigid: %s"
-                                 uu___9 uu___10 in
-                             failwith uu___8
-                         | uu___7 ->
-                             let uu___8 =
-                               let uu___9 =
-                                 FStar_Compiler_Util.string_of_int
-                                   (rank_t_num rank1) in
-                               let uu___10 =
-                                 prob_to_string env
-                                   (FStar_TypeChecker_Common.TProb tp) in
-                               FStar_Compiler_Util.format2
-                                 "Impossible: (rank=%s) Not a rigid-flex: %s"
-                                 uu___9 uu___10 in
-                             failwith uu___8)))))
-and (imitate_arrow :
-  FStar_TypeChecker_Common.prob ->
-    worklist ->
-      flex_t ->
-        FStar_Syntax_Syntax.binders ->
-          FStar_Syntax_Syntax.term ->
-            FStar_TypeChecker_Common.rel ->
-              FStar_Syntax_Syntax.term -> solution)
-  =
-  fun orig ->
-    fun wl ->
-      fun lhs ->
-        fun bs_lhs ->
-          fun t_res_lhs ->
-            fun rel ->
-              fun arrow ->
-                let bs_lhs_args =
-                  FStar_Compiler_List.map
-                    (fun uu___ ->
-                       match uu___ with
-                       | { FStar_Syntax_Syntax.binder_bv = x;
-                           FStar_Syntax_Syntax.binder_qual = i;
-                           FStar_Syntax_Syntax.binder_attrs = uu___1;_} ->
-                           let uu___2 = FStar_Syntax_Syntax.bv_to_name x in
-                           (uu___2, i)) bs_lhs in
-                let uu___ = lhs in
-                match uu___ with
-                | Flex (uu___1, u_lhs, uu___2) ->
-                    let imitate_comp bs bs_terms c wl1 =
-                      let imitate_tot_or_gtot t f wl2 =
-                        let uu___3 = FStar_Syntax_Util.type_u () in
-                        match uu___3 with
-                        | (k, uu___4) ->
-                            let uu___5 =
-                              copy_uvar u_lhs
-                                (FStar_Compiler_List.op_At bs_lhs bs) k wl2 in
-                            (match uu___5 with
-                             | (uu___6, u, wl3) ->
-                                 let uu___7 = f u in (uu___7, wl3)) in
-                      match c.FStar_Syntax_Syntax.n with
-                      | FStar_Syntax_Syntax.Total t ->
-                          imitate_tot_or_gtot t FStar_Syntax_Syntax.mk_Total
-                            wl1
-                      | FStar_Syntax_Syntax.GTotal t ->
-                          imitate_tot_or_gtot t FStar_Syntax_Syntax.mk_GTotal
-                            wl1
-                      | FStar_Syntax_Syntax.Comp ct ->
-                          let uu___3 =
-                            let uu___4 =
-                              let uu___5 =
-                                FStar_Syntax_Syntax.as_arg
-                                  ct.FStar_Syntax_Syntax.result_typ in
-                              uu___5 :: (ct.FStar_Syntax_Syntax.effect_args) in
-                            FStar_Compiler_List.fold_right
-                              (fun uu___5 ->
-                                 fun uu___6 ->
-                                   match (uu___5, uu___6) with
-                                   | ((a, i), (out_args, wl2)) ->
-                                       let uu___7 =
-                                         let uu___8 =
-                                           let uu___9 =
-                                             FStar_Syntax_Util.type_u () in
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             FStar_Pervasives_Native.fst
-                                             uu___9 in
-                                         copy_uvar u_lhs [] uu___8 wl2 in
-                                       (match uu___7 with
-                                        | (uu___8, t_a, wl3) ->
-                                            let uu___9 =
-                                              copy_uvar u_lhs bs t_a wl3 in
-                                            (match uu___9 with
-                                             | (uu___10, a', wl4) ->
-                                                 (((a', i) :: out_args), wl4))))
-                              uu___4 ([], wl1) in
-                          (match uu___3 with
-                           | (out_args, wl2) ->
-                               let nodec flags =
-                                 FStar_Compiler_List.filter
-                                   (fun uu___4 ->
-                                      match uu___4 with
-                                      | FStar_Syntax_Syntax.DECREASES uu___5
-                                          -> false
-                                      | uu___5 -> true) flags in
-                               let ct' =
-                                 let uu___4 =
-                                   let uu___5 =
-                                     FStar_Compiler_List.hd out_args in
-                                   FStar_Pervasives_Native.fst uu___5 in
-                                 let uu___5 = FStar_Compiler_List.tl out_args in
-                                 let uu___6 =
-                                   nodec ct.FStar_Syntax_Syntax.flags in
-                                 {
-                                   FStar_Syntax_Syntax.comp_univs =
-                                     (ct.FStar_Syntax_Syntax.comp_univs);
-                                   FStar_Syntax_Syntax.effect_name =
-                                     (ct.FStar_Syntax_Syntax.effect_name);
-                                   FStar_Syntax_Syntax.result_typ = uu___4;
-                                   FStar_Syntax_Syntax.effect_args = uu___5;
-                                   FStar_Syntax_Syntax.flags = uu___6
-                                 } in
-                               ({
-                                  FStar_Syntax_Syntax.n =
-                                    (FStar_Syntax_Syntax.Comp ct');
-                                  FStar_Syntax_Syntax.pos =
-                                    (c.FStar_Syntax_Syntax.pos);
-                                  FStar_Syntax_Syntax.vars =
-                                    (c.FStar_Syntax_Syntax.vars);
-                                  FStar_Syntax_Syntax.hash_code =
-                                    (c.FStar_Syntax_Syntax.hash_code)
-                                }, wl2)) in
-                    let uu___3 = FStar_Syntax_Util.arrow_formals_comp arrow in
-                    (match uu___3 with
-                     | (formals, c) ->
-                         let rec aux bs bs_terms formals1 wl1 =
-                           match formals1 with
-                           | [] ->
-                               let uu___4 = imitate_comp bs bs_terms c wl1 in
-                               (match uu___4 with
-                                | (c', wl2) ->
-                                    let lhs' = FStar_Syntax_Util.arrow bs c' in
-                                    let sol =
-                                      let uu___5 =
-                                        let uu___6 =
-                                          FStar_Syntax_Util.abs bs_lhs lhs'
-                                            (FStar_Pervasives_Native.Some
-                                               (FStar_Syntax_Util.residual_tot
-                                                  t_res_lhs)) in
-                                        (u_lhs, uu___6) in
-                                      TERM uu___5 in
-                                    let uu___5 =
-                                      mk_t_problem wl2 [] orig lhs' rel arrow
-                                        FStar_Pervasives_Native.None
-                                        "arrow imitation" in
-                                    (match uu___5 with
-                                     | (sub_prob, wl3) ->
-                                         let uu___6 =
-                                           let uu___7 =
-                                             solve_prob orig
-                                               FStar_Pervasives_Native.None
-                                               [sol] wl3 in
-                                           attempt [sub_prob] uu___7 in
-                                         solve uu___6))
-                           | { FStar_Syntax_Syntax.binder_bv = x;
-                               FStar_Syntax_Syntax.binder_qual = imp;
-                               FStar_Syntax_Syntax.binder_attrs = attrs;_}::formals2
-                               ->
-                               let uu___4 =
-                                 let uu___5 =
-                                   let uu___6 = FStar_Syntax_Util.type_u () in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___6 FStar_Pervasives_Native.fst in
-                                 copy_uvar u_lhs
-                                   (FStar_Compiler_List.op_At bs_lhs bs)
-                                   uu___5 wl1 in
-                               (match uu___4 with
-                                | (_ctx_u_x, u_x, wl2) ->
-                                    let y =
-                                      let uu___5 =
-                                        let uu___6 =
-                                          FStar_Syntax_Syntax.range_of_bv x in
-                                        FStar_Pervasives_Native.Some uu___6 in
-                                      FStar_Syntax_Syntax.new_bv uu___5 u_x in
-                                    let b =
-                                      FStar_Syntax_Syntax.mk_binder_with_attrs
-                                        y imp attrs in
-                                    let uu___5 =
-                                      let uu___6 =
-                                        let uu___7 =
-                                          FStar_Syntax_Util.arg_of_non_null_binder
-                                            b in
-                                        [uu___7] in
-                                      FStar_Compiler_List.op_At bs_terms
-                                        uu___6 in
-                                    aux (FStar_Compiler_List.op_At bs [b])
-                                      uu___5 formals2 wl2) in
-                         let uu___4 = occurs_check u_lhs arrow in
-                         (match uu___4 with
-                          | (uu___5, occurs_ok, msg) ->
-                              if Prims.op_Negation occurs_ok
-                              then
-                                let uu___6 =
-                                  mklstr
-                                    (fun uu___7 ->
-                                       let uu___8 =
-                                         FStar_Compiler_Option.get msg in
-                                       Prims.op_Hat "occurs-check failed: "
-                                         uu___8) in
-                                giveup_or_defer orig wl
-                                  FStar_TypeChecker_Common.Deferred_occur_check_failed
-                                  uu___6
-                              else aux [] [] formals wl))
-and (solve_binders :
-  FStar_Syntax_Syntax.binders ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_TypeChecker_Common.prob ->
-        worklist ->
-          (worklist ->
-             FStar_Syntax_Syntax.binders ->
-               FStar_Syntax_Syntax.subst_elt Prims.list ->
-                 (FStar_TypeChecker_Common.prob * worklist))
-            -> solution)
-  =
-  fun bs1 ->
-    fun bs2 ->
-      fun orig ->
-        fun wl ->
-          fun rhs ->
-            (let uu___1 =
-               FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                 (FStar_Options.Other "Rel") in
-             if uu___1
-             then
-               let uu___2 = FStar_Syntax_Print.binders_to_string ", " bs1 in
-               let uu___3 = FStar_Syntax_Print.binders_to_string ", " bs2 in
-               FStar_Compiler_Util.print3 "solve_binders\n\t%s\n%s\n\t%s\n"
-                 uu___2 (rel_to_string (p_rel orig)) uu___3
-             else ());
-            (let eq_bqual a1 a2 =
-               match (a1, a2) with
-               | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit
-                  b1), FStar_Pervasives_Native.Some
-                  (FStar_Syntax_Syntax.Implicit b2)) ->
-                   FStar_Syntax_Util.Equal
-               | uu___1 -> FStar_Syntax_Util.eq_bqual a1 a2 in
-             let rec aux wl1 scope subst xs ys =
-               match (xs, ys) with
-               | ([], []) ->
-                   let uu___1 = rhs wl1 scope subst in
-                   (match uu___1 with
-                    | (rhs_prob, wl2) ->
-                        ((let uu___3 =
-                            FStar_Compiler_Effect.op_Less_Bar (debug wl2)
-                              (FStar_Options.Other "Rel") in
-                          if uu___3
-                          then
-                            let uu___4 =
-                              prob_to_string (p_env wl2 rhs_prob) rhs_prob in
-                            FStar_Compiler_Util.print1 "rhs_prob = %s\n"
-                              uu___4
-                          else ());
-                         (let formula = p_guard rhs_prob in
-                          ((FStar_Pervasives.Inl ([rhs_prob], formula)), wl2))))
-               | (x::xs1, y::ys1) when
-                   let uu___1 =
-                     eq_bqual x.FStar_Syntax_Syntax.binder_qual
-                       y.FStar_Syntax_Syntax.binder_qual in
-                   uu___1 = FStar_Syntax_Util.Equal ->
-                   let uu___1 =
-                     ((x.FStar_Syntax_Syntax.binder_bv),
-                       (x.FStar_Syntax_Syntax.binder_qual)) in
-                   (match uu___1 with
-                    | (hd1, imp) ->
-                        let uu___2 =
-                          ((y.FStar_Syntax_Syntax.binder_bv),
-                            (y.FStar_Syntax_Syntax.binder_qual)) in
-                        (match uu___2 with
-                         | (hd2, imp') ->
-                             let hd11 =
-                               let uu___3 =
-                                 FStar_Syntax_Subst.subst subst
-                                   hd1.FStar_Syntax_Syntax.sort in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (hd1.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (hd1.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = uu___3
-                               } in
-                             let hd21 =
-                               let uu___3 =
-                                 FStar_Syntax_Subst.subst subst
-                                   hd2.FStar_Syntax_Syntax.sort in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (hd2.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (hd2.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = uu___3
-                               } in
-                             let uu___3 =
-                               let uu___4 =
-                                 FStar_Compiler_Effect.op_Less_Bar invert_rel
-                                   (p_rel orig) in
-                               mk_t_problem wl1 scope orig
-                                 hd11.FStar_Syntax_Syntax.sort uu___4
-                                 hd21.FStar_Syntax_Syntax.sort
-                                 FStar_Pervasives_Native.None
-                                 "Formal parameter" in
-                             (match uu___3 with
-                              | (prob, wl2) ->
-                                  let hd12 =
-                                    FStar_Syntax_Syntax.freshen_bv hd11 in
-                                  let subst1 =
-                                    let uu___4 =
-                                      FStar_Syntax_Subst.shift_subst
-                                        Prims.int_one subst in
-                                    (FStar_Syntax_Syntax.DB
-                                       (Prims.int_zero, hd12))
-                                      :: uu___4 in
-                                  let uu___4 =
-                                    aux wl2
-                                      (FStar_Compiler_List.op_At scope
-                                         [{
-                                            FStar_Syntax_Syntax.binder_bv =
-                                              hd12;
-                                            FStar_Syntax_Syntax.binder_qual =
-                                              (x.FStar_Syntax_Syntax.binder_qual);
-                                            FStar_Syntax_Syntax.binder_attrs
-                                              =
-                                              (x.FStar_Syntax_Syntax.binder_attrs)
-                                          }]) subst1 xs1 ys1 in
-                                  (match uu___4 with
-                                   | (FStar_Pervasives.Inl (sub_probs, phi),
-                                      wl3) ->
-                                       let phi1 =
-                                         let uu___5 =
-                                           FStar_TypeChecker_Env.close_forall
-                                             (p_env wl3 prob)
-                                             [{
-                                                FStar_Syntax_Syntax.binder_bv
-                                                  = hd12;
-                                                FStar_Syntax_Syntax.binder_qual
-                                                  =
-                                                  (x.FStar_Syntax_Syntax.binder_qual);
-                                                FStar_Syntax_Syntax.binder_attrs
-                                                  =
-                                                  (x.FStar_Syntax_Syntax.binder_attrs)
-                                              }] phi in
-                                         FStar_Syntax_Util.mk_conj
-                                           (p_guard prob) uu___5 in
-                                       ((let uu___6 =
-                                           FStar_Compiler_Effect.op_Less_Bar
-                                             (debug wl3)
-                                             (FStar_Options.Other "Rel") in
-                                         if uu___6
-                                         then
-                                           let uu___7 =
-                                             FStar_Syntax_Print.term_to_string
-                                               phi1 in
-                                           let uu___8 =
-                                             FStar_Syntax_Print.bv_to_string
-                                               hd12 in
-                                           FStar_Compiler_Util.print2
-                                             "Formula is %s\n\thd1=%s\n"
-                                             uu___7 uu___8
-                                         else ());
-                                        ((FStar_Pervasives.Inl
-                                            ((prob :: sub_probs), phi1)),
-                                          wl3))
-                                   | fail -> fail))))
-               | uu___1 ->
-                   ((FStar_Pervasives.Inr
-                       "arity or argument-qualifier mismatch"), wl1) in
-             let uu___1 = aux wl [] [] bs1 bs2 in
-             match uu___1 with
-             | (FStar_Pervasives.Inr msg, wl1) -> giveup_lit wl1 msg orig
-             | (FStar_Pervasives.Inl (sub_probs, phi), wl1) ->
-                 let wl2 =
-                   solve_prob orig (FStar_Pervasives_Native.Some phi) [] wl1 in
-                 let uu___2 = attempt sub_probs wl2 in solve uu___2)
-and (try_solve_without_smt_or_else :
-  worklist ->
-    (worklist -> solution) ->
-      (worklist -> (FStar_TypeChecker_Common.prob * lstring) -> solution) ->
-        solution)
-  =
-  fun wl ->
-    fun try_solve ->
-      fun else_solve ->
-        let wl' =
-          {
-            attempting = [];
-            wl_deferred = [];
-            wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-            ctr = (wl.ctr);
-            defer_ok = NoDefer;
-            smt_ok = false;
-            umax_heuristic_ok = false;
-            tcenv = (wl.tcenv);
-            wl_implicits = [];
-            repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-          } in
-        let tx = FStar_Syntax_Unionfind.new_transaction () in
-        let uu___ = try_solve wl' in
-        match uu___ with
-        | Success (uu___1, defer_to_tac, imps) ->
-            (FStar_Syntax_Unionfind.commit tx;
-             (let wl1 = extend_wl wl [] defer_to_tac imps in solve wl1))
-        | Failed (p, s) ->
-            (FStar_Syntax_Unionfind.rollback tx; else_solve wl (p, s))
-and (try_solve_then_or_else :
-  worklist ->
-    (worklist -> solution) ->
-      (worklist -> solution) -> (worklist -> solution) -> solution)
-  =
-  fun wl ->
-    fun try_solve ->
-      fun then_solve ->
-        fun else_solve ->
-          let empty_wl =
-            {
-              attempting = [];
-              wl_deferred = [];
-              wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-              ctr = (wl.ctr);
-              defer_ok = NoDefer;
-              smt_ok = (wl.smt_ok);
-              umax_heuristic_ok = (wl.umax_heuristic_ok);
-              tcenv = (wl.tcenv);
-              wl_implicits = [];
-              repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-            } in
-          let tx = FStar_Syntax_Unionfind.new_transaction () in
-          let uu___ = try_solve empty_wl in
-          match uu___ with
-          | Success (uu___1, defer_to_tac, imps) ->
-              (FStar_Syntax_Unionfind.commit tx;
-               (let wl1 = extend_wl wl [] defer_to_tac imps in then_solve wl1))
-          | Failed (p, s) ->
-              (FStar_Syntax_Unionfind.rollback tx; else_solve wl)
-and (try_solve_probs_without_smt :
-  worklist ->
-    (worklist -> (FStar_TypeChecker_Common.probs * worklist)) ->
-      (worklist, lstring) FStar_Pervasives.either)
-  =
-  fun wl ->
-    fun probs ->
-      let uu___ = probs wl in
-      match uu___ with
-      | (probs1, wl') ->
-          let wl'1 =
-            {
-              attempting = probs1;
-              wl_deferred = [];
-              wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-              ctr = (wl.ctr);
-              defer_ok = NoDefer;
-              smt_ok = false;
-              umax_heuristic_ok = false;
-              tcenv = (wl.tcenv);
-              wl_implicits = [];
-              repr_subcomp_allowed = (wl.repr_subcomp_allowed)
-            } in
-          let uu___1 = solve wl'1 in
-          (match uu___1 with
-           | Success (uu___2, defer_to_tac, imps) ->
-               let wl1 = extend_wl wl [] defer_to_tac imps in
-               FStar_Pervasives.Inl wl1
-           | Failed (uu___2, ls) -> FStar_Pervasives.Inr ls)
-and (solve_t : tprob -> worklist -> solution) =
-  fun problem ->
-    fun wl ->
-      def_check_prob "solve_t" (FStar_TypeChecker_Common.TProb problem);
-      (let uu___1 = compress_tprob wl.tcenv problem in solve_t' uu___1 wl)
-and (solve_t_flex_rigid_eq :
-  FStar_TypeChecker_Common.prob ->
-    worklist -> flex_t -> FStar_Syntax_Syntax.term -> solution)
-  =
-  fun orig ->
-    fun wl ->
-      fun lhs ->
-        fun rhs ->
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar (debug wl)
-               (FStar_Options.Other "Rel") in
-           if uu___1
-           then FStar_Compiler_Util.print_string "solve_t_flex_rigid_eq\n"
-           else ());
-          (let uu___1 = should_defer_flex_to_user_tac wl lhs in
-           if uu___1
-           then defer_to_user_tac orig (flex_reason lhs) wl
-           else
-             (let mk_solution env lhs1 bs rhs1 =
-                let bs_orig = bs in
-                let rhs_orig = rhs1 in
-                let uu___3 = lhs1 in
-                match uu___3 with
-                | Flex (uu___4, ctx_u, args) ->
-                    let uu___5 =
-                      let bv_not_free_in_arg x arg =
-                        let uu___6 =
-                          let uu___7 =
-                            FStar_Syntax_Free.names
-                              (FStar_Pervasives_Native.fst arg) in
-                          FStar_Compiler_Util.set_mem x uu___7 in
-                        Prims.op_Negation uu___6 in
-                      let bv_not_free_in_args x args1 =
-                        FStar_Compiler_Util.for_all (bv_not_free_in_arg x)
-                          args1 in
-                      let binder_matches_aqual b aq =
-                        match ((b.FStar_Syntax_Syntax.binder_qual), aq) with
-                        | (FStar_Pervasives_Native.None,
-                           FStar_Pervasives_Native.None) -> true
-                        | (FStar_Pervasives_Native.Some
-                           (FStar_Syntax_Syntax.Implicit uu___6),
-                           FStar_Pervasives_Native.Some a) ->
-                            a.FStar_Syntax_Syntax.aqual_implicit &&
-                              (FStar_Syntax_Util.eqlist
-                                 (fun x ->
-                                    fun y ->
-                                      let uu___7 =
-                                        FStar_Syntax_Util.eq_tm x y in
-                                      uu___7 = FStar_Syntax_Util.Equal)
-                                 b.FStar_Syntax_Syntax.binder_attrs
-                                 a.FStar_Syntax_Syntax.aqual_attributes)
-                        | uu___6 -> false in
-                      let rec remove_matching_prefix lhs_binders rhs_args =
-                        match (lhs_binders, rhs_args) with
-                        | ([], uu___6) -> (lhs_binders, rhs_args)
-                        | (uu___6, []) -> (lhs_binders, rhs_args)
-                        | (b::lhs_tl, (t, aq)::rhs_tl) ->
-                            let uu___6 =
-                              let uu___7 = FStar_Syntax_Subst.compress t in
-                              uu___7.FStar_Syntax_Syntax.n in
-                            (match uu___6 with
-                             | FStar_Syntax_Syntax.Tm_name x when
-                                 ((FStar_Syntax_Syntax.bv_eq
-                                     b.FStar_Syntax_Syntax.binder_bv x)
-                                    && (binder_matches_aqual b aq))
-                                   &&
-                                   (bv_not_free_in_args
-                                      b.FStar_Syntax_Syntax.binder_bv rhs_tl)
-                                 -> remove_matching_prefix lhs_tl rhs_tl
-                             | uu___7 -> (lhs_binders, rhs_args)) in
-                      let uu___6 = FStar_Syntax_Util.head_and_args rhs1 in
-                      match uu___6 with
-                      | (rhs_hd, rhs_args) ->
-                          let uu___7 =
-                            let uu___8 =
-                              remove_matching_prefix
-                                (FStar_Compiler_List.rev bs_orig)
-                                (FStar_Compiler_List.rev rhs_args) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___8
-                              (fun uu___9 ->
-                                 match uu___9 with
-                                 | (bs_rev, args_rev) ->
-                                     ((FStar_Compiler_List.rev bs_rev),
-                                       (FStar_Compiler_List.rev args_rev))) in
-                          (match uu___7 with
-                           | (bs1, rhs_args1) ->
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.mk_Tm_app rhs_hd
-                                   rhs_args1 rhs1.FStar_Syntax_Syntax.pos in
-                               (bs1, uu___8)) in
-                    (match uu___5 with
-                     | (bs1, rhs2) ->
-                         let sol =
-                           match bs1 with
-                           | [] -> rhs2
-                           | uu___6 ->
-                               let uu___7 =
-                                 FStar_Syntax_Util.ctx_uvar_typ ctx_u in
-                               let uu___8 = sn_binders env bs1 in
-                               u_abs uu___7 uu___8 rhs2 in
-                         [TERM (ctx_u, sol)]) in
-              let try_quasi_pattern orig1 env wl1 lhs1 rhs1 =
-                (let uu___4 =
-                   FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                     (FStar_Options.Other "Rel") in
-                 if uu___4
-                 then FStar_Compiler_Util.print_string "try_quasi_pattern\n"
-                 else ());
-                (let uu___4 = quasi_pattern env lhs1 in
-                 match uu___4 with
-                 | FStar_Pervasives_Native.None ->
-                     ((FStar_Pervasives.Inl "Not a quasi-pattern"), wl1)
-                 | FStar_Pervasives_Native.Some (bs, uu___5) ->
-                     let uu___6 = lhs1 in
-                     (match uu___6 with
-                      | Flex (t_lhs, ctx_u, args) ->
-                          let uu___7 = occurs_check ctx_u rhs1 in
-                          (match uu___7 with
-                           | (uvars, occurs_ok, msg) ->
-                               if Prims.op_Negation occurs_ok
-                               then
-                                 let uu___8 =
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Compiler_Option.get msg in
-                                     Prims.op_Hat
-                                       "quasi-pattern, occurs-check failed: "
-                                       uu___10 in
-                                   FStar_Pervasives.Inl uu___9 in
-                                 (uu___8, wl1)
-                               else
-                                 (let fvs_lhs =
-                                    binders_as_bv_set
-                                      (FStar_Compiler_List.op_At
-                                         ctx_u.FStar_Syntax_Syntax.ctx_uvar_binders
-                                         bs) in
-                                  let fvs_rhs = FStar_Syntax_Free.names rhs1 in
-                                  let uu___9 =
-                                    let uu___10 =
-                                      FStar_Compiler_Util.set_is_subset_of
-                                        fvs_rhs fvs_lhs in
-                                    Prims.op_Negation uu___10 in
-                                  if uu___9
-                                  then
-                                    ((FStar_Pervasives.Inl
-                                        "quasi-pattern, free names on the RHS are not included in the LHS"),
-                                      wl1)
-                                  else
-                                    (let uu___11 =
-                                       let uu___12 =
-                                         mk_solution env lhs1 bs rhs1 in
-                                       FStar_Pervasives.Inr uu___12 in
-                                     let uu___12 =
-                                       restrict_all_uvars env ctx_u [] uvars
-                                         wl1 in
-                                     (uu___11, uu___12)))))) in
-              let imitate_app orig1 env wl1 lhs1 bs_lhs t_res_lhs rhs1 =
-                let uu___3 = FStar_Syntax_Util.head_and_args rhs1 in
-                match uu___3 with
-                | (rhs_hd, args) ->
-                    let uu___4 = FStar_Compiler_Util.prefix args in
-                    (match uu___4 with
-                     | (args_rhs, last_arg_rhs) ->
-                         let rhs' =
-                           FStar_Syntax_Syntax.mk_Tm_app rhs_hd args_rhs
-                             rhs1.FStar_Syntax_Syntax.pos in
-                         let uu___5 = lhs1 in
-                         (match uu___5 with
-                          | Flex (t_lhs, u_lhs, _lhs_args) ->
-                              let uu___6 =
-                                let uu___7 =
-                                  let env1 = p_env wl1 orig1 in
-                                  env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                    {
-                                      FStar_TypeChecker_Env.solver =
-                                        (env1.FStar_TypeChecker_Env.solver);
-                                      FStar_TypeChecker_Env.range =
-                                        (env1.FStar_TypeChecker_Env.range);
-                                      FStar_TypeChecker_Env.curmodule =
-                                        (env1.FStar_TypeChecker_Env.curmodule);
-                                      FStar_TypeChecker_Env.gamma =
-                                        (env1.FStar_TypeChecker_Env.gamma);
-                                      FStar_TypeChecker_Env.gamma_sig =
-                                        (env1.FStar_TypeChecker_Env.gamma_sig);
-                                      FStar_TypeChecker_Env.gamma_cache =
-                                        (env1.FStar_TypeChecker_Env.gamma_cache);
-                                      FStar_TypeChecker_Env.modules =
-                                        (env1.FStar_TypeChecker_Env.modules);
-                                      FStar_TypeChecker_Env.expected_typ =
-                                        FStar_Pervasives_Native.None;
-                                      FStar_TypeChecker_Env.sigtab =
-                                        (env1.FStar_TypeChecker_Env.sigtab);
-                                      FStar_TypeChecker_Env.attrtab =
-                                        (env1.FStar_TypeChecker_Env.attrtab);
-                                      FStar_TypeChecker_Env.instantiate_imp =
-                                        (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                      FStar_TypeChecker_Env.effects =
-                                        (env1.FStar_TypeChecker_Env.effects);
-                                      FStar_TypeChecker_Env.generalize =
-                                        (env1.FStar_TypeChecker_Env.generalize);
-                                      FStar_TypeChecker_Env.letrecs =
-                                        (env1.FStar_TypeChecker_Env.letrecs);
-                                      FStar_TypeChecker_Env.top_level =
-                                        (env1.FStar_TypeChecker_Env.top_level);
-                                      FStar_TypeChecker_Env.check_uvars =
-                                        (env1.FStar_TypeChecker_Env.check_uvars);
-                                      FStar_TypeChecker_Env.use_eq_strict =
-                                        (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                      FStar_TypeChecker_Env.is_iface =
-                                        (env1.FStar_TypeChecker_Env.is_iface);
-                                      FStar_TypeChecker_Env.admit =
-                                        (env1.FStar_TypeChecker_Env.admit);
-                                      FStar_TypeChecker_Env.lax = true;
-                                      FStar_TypeChecker_Env.lax_universes =
-                                        (env1.FStar_TypeChecker_Env.lax_universes);
-                                      FStar_TypeChecker_Env.phase1 =
-                                        (env1.FStar_TypeChecker_Env.phase1);
-                                      FStar_TypeChecker_Env.failhard =
-                                        (env1.FStar_TypeChecker_Env.failhard);
-                                      FStar_TypeChecker_Env.nosynth =
-                                        (env1.FStar_TypeChecker_Env.nosynth);
-                                      FStar_TypeChecker_Env.uvar_subtyping =
-                                        (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                      FStar_TypeChecker_Env.tc_term =
-                                        (env1.FStar_TypeChecker_Env.tc_term);
-                                      FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                        =
-                                        (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                      FStar_TypeChecker_Env.universe_of =
-                                        (env1.FStar_TypeChecker_Env.universe_of);
-                                      FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                        =
-                                        (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                      FStar_TypeChecker_Env.teq_nosmt_force =
-                                        (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                      FStar_TypeChecker_Env.subtype_nosmt_force
-                                        =
-                                        (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                      FStar_TypeChecker_Env.qtbl_name_and_index
-                                        =
-                                        (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                      FStar_TypeChecker_Env.normalized_eff_names
-                                        =
-                                        (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                      FStar_TypeChecker_Env.fv_delta_depths =
-                                        (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                      FStar_TypeChecker_Env.proof_ns =
-                                        (env1.FStar_TypeChecker_Env.proof_ns);
-                                      FStar_TypeChecker_Env.synth_hook =
-                                        (env1.FStar_TypeChecker_Env.synth_hook);
-                                      FStar_TypeChecker_Env.try_solve_implicits_hook
-                                        =
-                                        (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                      FStar_TypeChecker_Env.splice =
-                                        (env1.FStar_TypeChecker_Env.splice);
-                                      FStar_TypeChecker_Env.mpreprocess =
-                                        (env1.FStar_TypeChecker_Env.mpreprocess);
-                                      FStar_TypeChecker_Env.postprocess =
-                                        (env1.FStar_TypeChecker_Env.postprocess);
-                                      FStar_TypeChecker_Env.identifier_info =
-                                        (env1.FStar_TypeChecker_Env.identifier_info);
-                                      FStar_TypeChecker_Env.tc_hooks =
-                                        (env1.FStar_TypeChecker_Env.tc_hooks);
-                                      FStar_TypeChecker_Env.dsenv =
-                                        (env1.FStar_TypeChecker_Env.dsenv);
-                                      FStar_TypeChecker_Env.nbe =
-                                        (env1.FStar_TypeChecker_Env.nbe);
-                                      FStar_TypeChecker_Env.strict_args_tab =
-                                        (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                      FStar_TypeChecker_Env.erasable_types_tab
-                                        =
-                                        (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                      FStar_TypeChecker_Env.enable_defer_to_tac
-                                        =
-                                        (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                      FStar_TypeChecker_Env.unif_allow_ref_guards
-                                        =
-                                        (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                      FStar_TypeChecker_Env.erase_erasable_args
-                                        =
-                                        (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                      FStar_TypeChecker_Env.core_check =
-                                        (env1.FStar_TypeChecker_Env.core_check)
-                                    }
-                                    (FStar_Pervasives_Native.fst last_arg_rhs)
-                                    false in
-                                match uu___7 with
-                                | (t_last_arg, uu___8) ->
-                                    let uu___9 =
-                                      let b =
-                                        FStar_Syntax_Syntax.null_binder
-                                          t_last_arg in
-                                      let uu___10 =
-                                        let uu___11 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            t_res_lhs
-                                            FStar_Syntax_Syntax.mk_Total in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___11
-                                          (FStar_Syntax_Util.arrow [b]) in
-                                      copy_uvar u_lhs
-                                        (FStar_Compiler_List.op_At bs_lhs [b])
-                                        uu___10 wl1 in
-                                    (match uu___9 with
-                                     | (uu___10, lhs', wl2) ->
-                                         let uu___11 =
-                                           copy_uvar u_lhs bs_lhs t_last_arg
-                                             wl2 in
-                                         (match uu___11 with
-                                          | (uu___12, lhs'_last_arg, wl3) ->
-                                              (lhs', lhs'_last_arg, wl3))) in
-                              (match uu___6 with
-                               | (lhs', lhs'_last_arg, wl2) ->
-                                   let sol =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Syntax_Syntax.mk_Tm_app
-                                               lhs'
-                                               [(lhs'_last_arg,
-                                                  (FStar_Pervasives_Native.snd
-                                                     last_arg_rhs))]
-                                               t_lhs.FStar_Syntax_Syntax.pos in
-                                           FStar_Syntax_Util.abs bs_lhs
-                                             uu___10
-                                             (FStar_Pervasives_Native.Some
-                                                (FStar_Syntax_Util.residual_tot
-                                                   t_res_lhs)) in
-                                         (u_lhs, uu___9) in
-                                       TERM uu___8 in
-                                     [uu___7] in
-                                   let uu___7 =
-                                     let uu___8 =
-                                       mk_t_problem wl2 [] orig1 lhs'
-                                         FStar_TypeChecker_Common.EQ rhs'
-                                         FStar_Pervasives_Native.None
-                                         "first-order lhs" in
-                                     match uu___8 with
-                                     | (p1, wl3) ->
-                                         let uu___9 =
-                                           mk_t_problem wl3 [] orig1
-                                             lhs'_last_arg
-                                             FStar_TypeChecker_Common.EQ
-                                             (FStar_Pervasives_Native.fst
-                                                last_arg_rhs)
-                                             FStar_Pervasives_Native.None
-                                             "first-order rhs" in
-                                         (match uu___9 with
-                                          | (p2, wl4) -> ([p1; p2], wl4)) in
-                                   (match uu___7 with
-                                    | (sub_probs, wl3) ->
-                                        let uu___8 =
-                                          let uu___9 =
-                                            solve_prob orig1
-                                              FStar_Pervasives_Native.None
-                                              sol wl3 in
-                                          attempt sub_probs uu___9 in
-                                        solve uu___8)))) in
-              let imitate orig1 env wl1 lhs1 rhs1 =
-                (let uu___4 =
-                   FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                     (FStar_Options.Other "Rel") in
-                 if uu___4
-                 then FStar_Compiler_Util.print_string "imitate\n"
-                 else ());
-                (let is_app rhs2 =
-                   let uu___4 = FStar_Syntax_Util.head_and_args rhs2 in
-                   match uu___4 with
-                   | (uu___5, args) ->
-                       (match args with | [] -> false | uu___6 -> true) in
-                 let is_arrow rhs2 =
-                   let uu___4 =
-                     let uu___5 = FStar_Syntax_Subst.compress rhs2 in
-                     uu___5.FStar_Syntax_Syntax.n in
-                   match uu___4 with
-                   | FStar_Syntax_Syntax.Tm_arrow uu___5 -> true
-                   | uu___5 -> false in
-                 let uu___4 = quasi_pattern env lhs1 in
-                 match uu___4 with
-                 | FStar_Pervasives_Native.None ->
-                     let msg =
-                       mklstr
-                         (fun uu___5 ->
-                            let uu___6 = prob_to_string env orig1 in
-                            FStar_Compiler_Util.format1
-                              "imitate heuristic cannot solve %s; lhs not a quasi-pattern"
-                              uu___6) in
-                     giveup_or_defer orig1 wl1
-                       FStar_TypeChecker_Common.Deferred_first_order_heuristic_failed
-                       msg
-                 | FStar_Pervasives_Native.Some (bs_lhs, t_res_lhs) ->
-                     let uu___5 = is_app rhs1 in
-                     if uu___5
-                     then
-                       imitate_app orig1 env wl1 lhs1 bs_lhs t_res_lhs rhs1
-                     else
-                       (let uu___7 = is_arrow rhs1 in
-                        if uu___7
-                        then
-                          imitate_arrow orig1 wl1 lhs1 bs_lhs t_res_lhs
-                            FStar_TypeChecker_Common.EQ rhs1
-                        else
-                          (let msg =
-                             mklstr
-                               (fun uu___9 ->
-                                  let uu___10 = prob_to_string env orig1 in
-                                  FStar_Compiler_Util.format1
-                                    "imitate heuristic cannot solve %s; rhs not an app or arrow"
-                                    uu___10) in
-                           giveup_or_defer orig1 wl1
-                             FStar_TypeChecker_Common.Deferred_first_order_heuristic_failed
-                             msg))) in
-              let try_first_order orig1 env wl1 lhs1 rhs1 =
-                let inapplicable msg lstring_opt =
-                  (let uu___4 =
-                     FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                       (FStar_Options.Other "Rel") in
-                   if uu___4
-                   then
-                     let extra_msg =
-                       match lstring_opt with
-                       | FStar_Pervasives_Native.None -> ""
-                       | FStar_Pervasives_Native.Some l ->
-                           FStar_Thunk.force l in
-                     FStar_Compiler_Util.print2
-                       "try_first_order failed because: %s\n%s\n" msg
-                       extra_msg
-                   else ());
-                  FStar_Pervasives.Inl "first_order doesn't apply" in
-                (let uu___4 =
-                   FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                     (FStar_Options.Other "Rel") in
-                 if uu___4
-                 then
-                   let uu___5 = flex_t_to_string lhs1 in
-                   let uu___6 = FStar_Syntax_Print.term_to_string rhs1 in
-                   FStar_Compiler_Util.print2
-                     "try_first_order\n\tlhs=%s\n\trhs=%s\n" uu___5 uu___6
-                 else ());
-                (let uu___4 = lhs1 in
-                 match uu___4 with
-                 | Flex (_t1, ctx_uv, args_lhs) ->
-                     let n_args_lhs = FStar_Compiler_List.length args_lhs in
-                     let uu___5 = FStar_Syntax_Util.head_and_args rhs1 in
-                     (match uu___5 with
-                      | (head, args_rhs) ->
-                          let n_args_rhs =
-                            FStar_Compiler_List.length args_rhs in
-                          if n_args_lhs > n_args_rhs
-                          then
-                            inapplicable "not enough args"
-                              FStar_Pervasives_Native.None
-                          else
-                            (let i = n_args_rhs - n_args_lhs in
-                             let uu___7 =
-                               FStar_Compiler_List.splitAt i args_rhs in
-                             match uu___7 with
-                             | (prefix, args_rhs1) ->
-                                 let head1 =
-                                   FStar_Syntax_Syntax.mk_Tm_app head prefix
-                                     head.FStar_Syntax_Syntax.pos in
-                                 let uu___8 = occurs_check ctx_uv head1 in
-                                 (match uu___8 with
-                                  | (uvars_head, occurs_ok, uu___9) ->
-                                      if Prims.op_Negation occurs_ok
-                                      then
-                                        inapplicable "occurs check failed"
-                                          FStar_Pervasives_Native.None
-                                      else
-                                        (let uu___11 =
-                                           let uu___12 =
-                                             let uu___13 =
-                                               FStar_Syntax_Free.names head1 in
-                                             let uu___14 =
-                                               binders_as_bv_set
-                                                 ctx_uv.FStar_Syntax_Syntax.ctx_uvar_binders in
-                                             FStar_Compiler_Util.set_is_subset_of
-                                               uu___13 uu___14 in
-                                           Prims.op_Negation uu___12 in
-                                         if uu___11
-                                         then
-                                           inapplicable
-                                             "free name inclusion failed"
-                                             FStar_Pervasives_Native.None
-                                         else
-                                           (let uu___13 =
-                                              env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                {
-                                                  FStar_TypeChecker_Env.solver
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.solver);
-                                                  FStar_TypeChecker_Env.range
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.range);
-                                                  FStar_TypeChecker_Env.curmodule
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.curmodule);
-                                                  FStar_TypeChecker_Env.gamma
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.gamma);
-                                                  FStar_TypeChecker_Env.gamma_sig
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.gamma_sig);
-                                                  FStar_TypeChecker_Env.gamma_cache
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.gamma_cache);
-                                                  FStar_TypeChecker_Env.modules
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.modules);
-                                                  FStar_TypeChecker_Env.expected_typ
-                                                    =
-                                                    FStar_Pervasives_Native.None;
-                                                  FStar_TypeChecker_Env.sigtab
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.sigtab);
-                                                  FStar_TypeChecker_Env.attrtab
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.attrtab);
-                                                  FStar_TypeChecker_Env.instantiate_imp
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.instantiate_imp);
-                                                  FStar_TypeChecker_Env.effects
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.effects);
-                                                  FStar_TypeChecker_Env.generalize
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.generalize);
-                                                  FStar_TypeChecker_Env.letrecs
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.letrecs);
-                                                  FStar_TypeChecker_Env.top_level
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.top_level);
-                                                  FStar_TypeChecker_Env.check_uvars
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.check_uvars);
-                                                  FStar_TypeChecker_Env.use_eq_strict
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.use_eq_strict);
-                                                  FStar_TypeChecker_Env.is_iface
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.is_iface);
-                                                  FStar_TypeChecker_Env.admit
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.admit);
-                                                  FStar_TypeChecker_Env.lax =
-                                                    true;
-                                                  FStar_TypeChecker_Env.lax_universes
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.lax_universes);
-                                                  FStar_TypeChecker_Env.phase1
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.phase1);
-                                                  FStar_TypeChecker_Env.failhard
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.failhard);
-                                                  FStar_TypeChecker_Env.nosynth
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.nosynth);
-                                                  FStar_TypeChecker_Env.uvar_subtyping
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                                  FStar_TypeChecker_Env.tc_term
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.tc_term);
-                                                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                  FStar_TypeChecker_Env.universe_of
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.universe_of);
-                                                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                  FStar_TypeChecker_Env.teq_nosmt_force
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                  FStar_TypeChecker_Env.subtype_nosmt_force
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                  FStar_TypeChecker_Env.qtbl_name_and_index
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                  FStar_TypeChecker_Env.normalized_eff_names
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                                  FStar_TypeChecker_Env.fv_delta_depths
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                                  FStar_TypeChecker_Env.proof_ns
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.proof_ns);
-                                                  FStar_TypeChecker_Env.synth_hook
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.synth_hook);
-                                                  FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                  FStar_TypeChecker_Env.splice
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.splice);
-                                                  FStar_TypeChecker_Env.mpreprocess
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.mpreprocess);
-                                                  FStar_TypeChecker_Env.postprocess
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.postprocess);
-                                                  FStar_TypeChecker_Env.identifier_info
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.identifier_info);
-                                                  FStar_TypeChecker_Env.tc_hooks
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.tc_hooks);
-                                                  FStar_TypeChecker_Env.dsenv
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.dsenv);
-                                                  FStar_TypeChecker_Env.nbe =
-                                                    (env.FStar_TypeChecker_Env.nbe);
-                                                  FStar_TypeChecker_Env.strict_args_tab
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.strict_args_tab);
-                                                  FStar_TypeChecker_Env.erasable_types_tab
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                                  FStar_TypeChecker_Env.enable_defer_to_tac
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                  FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                  FStar_TypeChecker_Env.erase_erasable_args
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                                  FStar_TypeChecker_Env.core_check
-                                                    =
-                                                    (env.FStar_TypeChecker_Env.core_check)
-                                                } head1 false in
-                                            match uu___13 with
-                                            | (t_head, uu___14) ->
-                                                let tx =
-                                                  FStar_Syntax_Unionfind.new_transaction
-                                                    () in
-                                                let solve_sub_probs_if_head_types_equal
-                                                  head_uvars_to_restrict wl2
-                                                  =
-                                                  let sol =
-                                                    [TERM (ctx_uv, head1)] in
-                                                  let wl3 =
-                                                    restrict_all_uvars env
-                                                      ctx_uv []
-                                                      head_uvars_to_restrict
-                                                      wl2 in
-                                                  let wl4 =
-                                                    solve_prob orig1
-                                                      FStar_Pervasives_Native.None
-                                                      sol wl3 in
-                                                  let uu___15 =
-                                                    FStar_Compiler_List.fold_left2
-                                                      (fun uu___16 ->
-                                                         fun uu___17 ->
-                                                           fun uu___18 ->
-                                                             match (uu___16,
-                                                                    uu___17,
-                                                                    uu___18)
-                                                             with
-                                                             | ((probs, wl5),
-                                                                (arg_lhs,
-                                                                 uu___19),
-                                                                (arg_rhs,
-                                                                 uu___20)) ->
-                                                                 let uu___21
-                                                                   =
-                                                                   mk_t_problem
-                                                                    wl5 []
-                                                                    orig1
-                                                                    arg_lhs
-                                                                    FStar_TypeChecker_Common.EQ
-                                                                    arg_rhs
-                                                                    FStar_Pervasives_Native.None
-                                                                    "first-order arg" in
-                                                                 (match uu___21
-                                                                  with
-                                                                  | (p, wl6)
-                                                                    ->
-                                                                    ((p ::
-                                                                    probs),
-                                                                    wl6)))
-                                                      ([], wl4) args_lhs
-                                                      args_rhs1 in
-                                                  match uu___15 with
-                                                  | (sub_probs, wl5) ->
-                                                      let wl' =
-                                                        {
-                                                          attempting =
-                                                            sub_probs;
-                                                          wl_deferred = [];
-                                                          wl_deferred_to_tac
-                                                            =
-                                                            (wl5.wl_deferred_to_tac);
-                                                          ctr = (wl5.ctr);
-                                                          defer_ok = NoDefer;
-                                                          smt_ok = false;
-                                                          umax_heuristic_ok =
-                                                            (wl5.umax_heuristic_ok);
-                                                          tcenv = (wl5.tcenv);
-                                                          wl_implicits = [];
-                                                          repr_subcomp_allowed
-                                                            =
-                                                            (wl5.repr_subcomp_allowed)
-                                                        } in
-                                                      let uu___16 = solve wl' in
-                                                      (match uu___16 with
-                                                       | Success
-                                                           (uu___17,
-                                                            defer_to_tac,
-                                                            imps)
-                                                           ->
-                                                           let wl6 =
-                                                             extend_wl wl5 []
-                                                               defer_to_tac
-                                                               imps in
-                                                           (FStar_Syntax_Unionfind.commit
-                                                              tx;
-                                                            FStar_Pervasives.Inr
-                                                              wl6)
-                                                       | Failed
-                                                           (uu___17,
-                                                            lstring1)
-                                                           ->
-                                                           (FStar_Syntax_Unionfind.rollback
-                                                              tx;
-                                                            inapplicable
-                                                              "Subprobs failed: "
-                                                              (FStar_Pervasives_Native.Some
-                                                                 lstring1))) in
-                                                let uu___15 =
-                                                  let uu___16 =
-                                                    let uu___17 =
-                                                      FStar_Syntax_Util.ctx_uvar_typ
-                                                        ctx_uv in
-                                                    FStar_Syntax_Util.eq_tm
-                                                      t_head uu___17 in
-                                                  uu___16 =
-                                                    FStar_Syntax_Util.Equal in
-                                                if uu___15
-                                                then
-                                                  solve_sub_probs_if_head_types_equal
-                                                    uvars_head wl1
-                                                else
-                                                  ((let uu___18 =
-                                                      debug wl1
-                                                        (FStar_Options.Other
-                                                           "Rel") in
-                                                    if uu___18
-                                                    then
-                                                      let uu___19 =
-                                                        let uu___20 =
-                                                          FStar_Syntax_Util.ctx_uvar_typ
-                                                            ctx_uv in
-                                                        FStar_Syntax_Print.term_to_string
-                                                          uu___20 in
-                                                      let uu___20 =
-                                                        FStar_Syntax_Print.term_to_string
-                                                          t_head in
-                                                      FStar_Compiler_Util.print2
-                                                        "first-order: head type mismatch:\n\tlhs=%s\n\trhs=%s\n"
-                                                        uu___19 uu___20
-                                                    else ());
-                                                   (let typ_equality_prob wl2
-                                                      =
-                                                      let uu___18 =
-                                                        let uu___19 =
-                                                          FStar_Syntax_Util.ctx_uvar_typ
-                                                            ctx_uv in
-                                                        mk_t_problem wl2 []
-                                                          orig1 uu___19
-                                                          FStar_TypeChecker_Common.EQ
-                                                          t_head
-                                                          FStar_Pervasives_Native.None
-                                                          "first-order head type" in
-                                                      match uu___18 with
-                                                      | (p, wl3) ->
-                                                          ([p], wl3) in
-                                                    let uu___18 =
-                                                      try_solve_probs_without_smt
-                                                        wl1 typ_equality_prob in
-                                                    match uu___18 with
-                                                    | FStar_Pervasives.Inl
-                                                        wl2 ->
-                                                        let uu___19 =
-                                                          let uu___20 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              head1
-                                                              FStar_Syntax_Free.uvars in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___20
-                                                            FStar_Compiler_Util.set_elements in
-                                                        solve_sub_probs_if_head_types_equal
-                                                          uu___19 wl2
-                                                    | FStar_Pervasives.Inr
-                                                        msg ->
-                                                        (FStar_Syntax_Unionfind.rollback
-                                                           tx;
-                                                         inapplicable
-                                                           "first-order: head type mismatch"
-                                                           (FStar_Pervasives_Native.Some
-                                                              msg)))))))))) in
-              match p_rel orig with
-              | FStar_TypeChecker_Common.SUB ->
-                  if wl.defer_ok = DeferAny
-                  then
-                    let uu___3 = FStar_Thunk.mkv "flex-rigid subtyping" in
-                    giveup_or_defer orig wl
-                      FStar_TypeChecker_Common.Deferred_flex uu___3
-                  else solve_t_flex_rigid_eq (make_prob_eq orig) wl lhs rhs
-              | FStar_TypeChecker_Common.SUBINV ->
-                  if wl.defer_ok = DeferAny
-                  then
-                    let uu___3 = FStar_Thunk.mkv "flex-rigid subtyping" in
-                    giveup_or_defer orig wl
-                      FStar_TypeChecker_Common.Deferred_flex uu___3
-                  else solve_t_flex_rigid_eq (make_prob_eq orig) wl lhs rhs
-              | FStar_TypeChecker_Common.EQ ->
-                  let uu___3 = lhs in
-                  (match uu___3 with
-                   | Flex (_t1, ctx_uv, args_lhs) ->
-                       let env = p_env wl orig in
-                       let uu___4 =
-                         pat_vars env
-                           ctx_uv.FStar_Syntax_Syntax.ctx_uvar_binders
-                           args_lhs in
-                       (match uu___4 with
-                        | FStar_Pervasives_Native.Some lhs_binders ->
-                            ((let uu___6 =
-                                FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                                  (FStar_Options.Other "Rel") in
-                              if uu___6
-                              then
-                                FStar_Compiler_Util.print_string
-                                  "it's a pattern\n"
-                              else ());
-                             (let rhs1 = sn env rhs in
-                              let names_to_string1 fvs =
-                                let uu___6 =
-                                  let uu___7 =
-                                    FStar_Compiler_Util.set_elements fvs in
-                                  FStar_Compiler_List.map
-                                    FStar_Syntax_Print.bv_to_string uu___7 in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                  (FStar_String.concat ", ") in
-                              let fvs1 =
-                                binders_as_bv_set
-                                  (FStar_Compiler_List.op_At
-                                     ctx_uv.FStar_Syntax_Syntax.ctx_uvar_binders
-                                     lhs_binders) in
-                              let fvs2 = FStar_Syntax_Free.names rhs1 in
-                              let uu___6 = occurs_check ctx_uv rhs1 in
-                              match uu___6 with
-                              | (uvars, occurs_ok, msg) ->
-                                  if Prims.op_Negation occurs_ok
-                                  then
-                                    let uu___7 =
-                                      let uu___8 =
-                                        let uu___9 =
-                                          FStar_Compiler_Option.get msg in
-                                        Prims.op_Hat "occurs-check failed: "
-                                          uu___9 in
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        FStar_Thunk.mkv uu___8 in
-                                    giveup_or_defer orig wl
-                                      FStar_TypeChecker_Common.Deferred_occur_check_failed
-                                      uu___7
-                                  else
-                                    (let uu___8 =
-                                       FStar_Compiler_Util.set_is_subset_of
-                                         fvs2 fvs1 in
-                                     if uu___8
-                                     then
-                                       let sol =
-                                         mk_solution env lhs lhs_binders rhs1 in
-                                       let wl1 =
-                                         restrict_all_uvars env ctx_uv
-                                           lhs_binders uvars wl in
-                                       let uu___9 =
-                                         solve_prob orig
-                                           FStar_Pervasives_Native.None sol
-                                           wl1 in
-                                       solve uu___9
-                                     else
-                                       if wl.defer_ok = DeferAny
-                                       then
-                                         (let msg1 =
-                                            mklstr
-                                              (fun uu___10 ->
-                                                 let uu___11 =
-                                                   names_to_string1 fvs2 in
-                                                 let uu___12 =
-                                                   names_to_string1 fvs1 in
-                                                 let uu___13 =
-                                                   FStar_Syntax_Print.binders_to_string
-                                                     ", "
-                                                     (FStar_Compiler_List.op_At
-                                                        ctx_uv.FStar_Syntax_Syntax.ctx_uvar_binders
-                                                        lhs_binders) in
-                                                 FStar_Compiler_Util.format3
-                                                   "free names in the RHS {%s} are out of scope for the LHS: {%s}, {%s}"
-                                                   uu___11 uu___12 uu___13) in
-                                          giveup_or_defer orig wl
-                                            FStar_TypeChecker_Common.Deferred_free_names_check_failed
-                                            msg1)
-                                       else imitate orig env wl lhs rhs1)))
-                        | uu___5 ->
-                            if wl.defer_ok = DeferAny
-                            then
-                              let uu___6 = FStar_Thunk.mkv "Not a pattern" in
-                              giveup_or_defer orig wl
-                                FStar_TypeChecker_Common.Deferred_not_a_pattern
-                                uu___6
-                            else
-                              (let uu___7 =
-                                 try_first_order orig env wl lhs rhs in
-                               match uu___7 with
-                               | FStar_Pervasives.Inr wl1 -> solve wl1
-                               | uu___8 ->
-                                   let uu___9 =
-                                     try_quasi_pattern orig env wl lhs rhs in
-                                   (match uu___9 with
-                                    | (FStar_Pervasives.Inr sol, wl1) ->
-                                        let uu___10 =
-                                          solve_prob orig
-                                            FStar_Pervasives_Native.None sol
-                                            wl1 in
-                                        solve uu___10
-                                    | (FStar_Pervasives.Inl msg, uu___10) ->
-                                        imitate orig env wl lhs rhs))))))
-and (solve_t_flex_flex :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.prob -> worklist -> flex_t -> flex_t -> solution)
-  =
-  fun env ->
-    fun orig ->
-      fun wl ->
-        fun lhs ->
-          fun rhs ->
-            let should_run_meta_arg_tac flex =
-              let uv = flex_uvar flex in
-              (flex_uvar_has_meta_tac uv) &&
-                (let uu___ =
-                   let uu___1 = FStar_Syntax_Util.ctx_uvar_typ uv in
-                   FStar_Syntax_Free.uvars uu___1 in
-                 FStar_Compiler_Util.set_is_empty uu___) in
-            let run_meta_arg_tac_and_try_again flex =
-              let uv = flex_uvar flex in
-              let t = run_meta_arg_tac uv in
-              (let uu___1 =
-                 FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                   (FStar_Options.Other "Rel") in
-               if uu___1
-               then
-                 let uu___2 = FStar_Syntax_Print.ctx_uvar_to_string uv in
-                 let uu___3 = FStar_Syntax_Print.term_to_string t in
-                 FStar_Compiler_Util.print2
-                   "solve_t_flex_flex: solving meta arg uvar %s with %s\n"
-                   uu___2 uu___3
-               else ());
-              set_uvar env uv FStar_Pervasives_Native.None t;
-              (let uu___2 = attempt [orig] wl in solve uu___2) in
-            match p_rel orig with
-            | FStar_TypeChecker_Common.SUB ->
-                if wl.defer_ok = DeferAny
-                then
-                  let uu___ = FStar_Thunk.mkv "flex-flex subtyping" in
-                  giveup_or_defer_flex_flex orig wl
-                    FStar_TypeChecker_Common.Deferred_flex uu___
-                else solve_t_flex_flex env (make_prob_eq orig) wl lhs rhs
-            | FStar_TypeChecker_Common.SUBINV ->
-                if wl.defer_ok = DeferAny
-                then
-                  let uu___ = FStar_Thunk.mkv "flex-flex subtyping" in
-                  giveup_or_defer_flex_flex orig wl
-                    FStar_TypeChecker_Common.Deferred_flex uu___
-                else solve_t_flex_flex env (make_prob_eq orig) wl lhs rhs
-            | FStar_TypeChecker_Common.EQ ->
-                let uu___ =
-                  (should_defer_flex_to_user_tac wl lhs) ||
-                    (should_defer_flex_to_user_tac wl rhs) in
-                if uu___
-                then
-                  defer_to_user_tac orig
-                    (Prims.op_Hat (flex_reason lhs)
-                       (Prims.op_Hat ", " (flex_reason rhs))) wl
-                else
-                  if
-                    ((wl.defer_ok = DeferAny) ||
-                       (wl.defer_ok = DeferFlexFlexOnly))
-                      &&
-                      ((Prims.op_Negation (is_flex_pat lhs)) ||
-                         (Prims.op_Negation (is_flex_pat rhs)))
-                  then
-                    (let uu___2 = FStar_Thunk.mkv "flex-flex non-pattern" in
-                     giveup_or_defer_flex_flex orig wl
-                       FStar_TypeChecker_Common.Deferred_flex_flex_nonpattern
-                       uu___2)
-                  else
-                    (let uu___3 = should_run_meta_arg_tac lhs in
-                     if uu___3
-                     then run_meta_arg_tac_and_try_again lhs
-                     else
-                       (let uu___5 = should_run_meta_arg_tac rhs in
-                        if uu___5
-                        then run_meta_arg_tac_and_try_again rhs
-                        else
-                          (let uu___7 =
-                             let uu___8 = quasi_pattern env lhs in
-                             let uu___9 = quasi_pattern env rhs in
-                             (uu___8, uu___9) in
-                           match uu___7 with
-                           | (FStar_Pervasives_Native.Some
-                              (binders_lhs, t_res_lhs),
-                              FStar_Pervasives_Native.Some
-                              (binders_rhs, t_res_rhs)) ->
-                               let uu___8 = lhs in
-                               (match uu___8 with
-                                | Flex
-                                    ({ FStar_Syntax_Syntax.n = uu___9;
-                                       FStar_Syntax_Syntax.pos = range;
-                                       FStar_Syntax_Syntax.vars = uu___10;
-                                       FStar_Syntax_Syntax.hash_code =
-                                         uu___11;_},
-                                     u_lhs, uu___12)
-                                    ->
-                                    let uu___13 = rhs in
-                                    (match uu___13 with
-                                     | Flex (uu___14, u_rhs, uu___15) ->
-                                         let uu___16 =
-                                           (FStar_Syntax_Unionfind.equiv
-                                              u_lhs.FStar_Syntax_Syntax.ctx_uvar_head
-                                              u_rhs.FStar_Syntax_Syntax.ctx_uvar_head)
-                                             &&
-                                             (binders_eq binders_lhs
-                                                binders_rhs) in
-                                         if uu___16
-                                         then
-                                           let uu___17 =
-                                             solve_prob orig
-                                               FStar_Pervasives_Native.None
-                                               [] wl in
-                                           solve uu___17
-                                         else
-                                           (let uu___18 =
-                                              maximal_prefix
-                                                u_lhs.FStar_Syntax_Syntax.ctx_uvar_binders
-                                                u_rhs.FStar_Syntax_Syntax.ctx_uvar_binders in
-                                            match uu___18 with
-                                            | (ctx_w, (ctx_l, ctx_r)) ->
-                                                let gamma_w =
-                                                  gamma_until
-                                                    u_lhs.FStar_Syntax_Syntax.ctx_uvar_gamma
-                                                    ctx_w in
-                                                let zs =
-                                                  intersect_binders gamma_w
-                                                    (FStar_Compiler_List.op_At
-                                                       ctx_l binders_lhs)
-                                                    (FStar_Compiler_List.op_At
-                                                       ctx_r binders_rhs) in
-                                                let new_uvar_typ =
-                                                  let uu___19 =
-                                                    FStar_Syntax_Syntax.mk_Total
-                                                      t_res_lhs in
-                                                  FStar_Syntax_Util.arrow zs
-                                                    uu___19 in
-                                                let uu___19 =
-                                                  (let uu___20 =
-                                                     occurs u_lhs
-                                                       new_uvar_typ in
-                                                   FStar_Pervasives_Native.snd
-                                                     uu___20)
-                                                    ||
-                                                    ((let uu___20 =
-                                                        FStar_Syntax_Unionfind.equiv
-                                                          u_lhs.FStar_Syntax_Syntax.ctx_uvar_head
-                                                          u_rhs.FStar_Syntax_Syntax.ctx_uvar_head in
-                                                      Prims.op_Negation
-                                                        uu___20)
-                                                       &&
-                                                       (let uu___20 =
-                                                          occurs u_rhs
-                                                            new_uvar_typ in
-                                                        FStar_Pervasives_Native.snd
-                                                          uu___20)) in
-                                                if uu___19
-                                                then
-                                                  let uu___20 =
-                                                    let uu___21 =
-                                                      FStar_Compiler_Util.format1
-                                                        "flex-flex: occurs\n defer_ok=%s\n"
-                                                        (string_of_defer_ok
-                                                           wl.defer_ok) in
-                                                    FStar_Thunk.mkv uu___21 in
-                                                  giveup_or_defer_flex_flex
-                                                    orig wl
-                                                    FStar_TypeChecker_Common.Deferred_flex_flex_nonpattern
-                                                    uu___20
-                                                else
-                                                  ((let uu___22 =
-                                                      FStar_Compiler_Effect.op_Less_Bar
-                                                        (debug wl)
-                                                        (FStar_Options.Other
-                                                           "Rel") in
-                                                    if uu___22
-                                                    then
-                                                      let uu___23 =
-                                                        FStar_Compiler_Util.stack_dump
-                                                          () in
-                                                      FStar_Compiler_Util.print1
-                                                        "flex-flex quasi: %s\n"
-                                                        uu___23
-                                                    else ());
-                                                   (let uu___22 =
-                                                      let uu___23 =
-                                                        let uu___24 =
-                                                          FStar_Syntax_Util.ctx_uvar_should_check
-                                                            u_lhs in
-                                                        let uu___25 =
-                                                          FStar_Syntax_Util.ctx_uvar_should_check
-                                                            u_rhs in
-                                                        (uu___24, uu___25) in
-                                                      match uu___23 with
-                                                      | (FStar_Syntax_Syntax.Allow_untyped
-                                                         r,
-                                                         FStar_Syntax_Syntax.Allow_untyped
-                                                         uu___24) ->
-                                                          ((FStar_Syntax_Syntax.Allow_untyped
-                                                              r), false)
-                                                      | (FStar_Syntax_Syntax.Allow_ghost
-                                                         r, uu___24) ->
-                                                          ((FStar_Syntax_Syntax.Allow_ghost
-                                                              r), true)
-                                                      | (uu___24,
-                                                         FStar_Syntax_Syntax.Allow_ghost
-                                                         r) ->
-                                                          ((FStar_Syntax_Syntax.Allow_ghost
-                                                              r), true)
-                                                      | uu___24 ->
-                                                          (FStar_Syntax_Syntax.Strict,
-                                                            false) in
-                                                    match uu___22 with
-                                                    | (new_uvar_should_check,
-                                                       is_ghost) ->
-                                                        let uu___23 =
-                                                          new_uvar
-                                                            (Prims.op_Hat
-                                                               "flex-flex quasi:"
-                                                               (Prims.op_Hat
-                                                                  "\tlhs="
-                                                                  (Prims.op_Hat
-                                                                    u_lhs.FStar_Syntax_Syntax.ctx_uvar_reason
-                                                                    (Prims.op_Hat
-                                                                    "\trhs="
-                                                                    u_rhs.FStar_Syntax_Syntax.ctx_uvar_reason))))
-                                                            wl range gamma_w
-                                                            ctx_w
-                                                            new_uvar_typ
-                                                            new_uvar_should_check
-                                                            FStar_Pervasives_Native.None in
-                                                        (match uu___23 with
-                                                         | (uu___24, w, wl1)
-                                                             ->
-                                                             let w_app =
-                                                               let uu___25 =
-                                                                 FStar_Compiler_List.map
-                                                                   (fun
-                                                                    uu___26
-                                                                    ->
-                                                                    match uu___26
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = z;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___27;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___28;_}
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    z in
-                                                                    FStar_Syntax_Syntax.as_arg
-                                                                    uu___29)
-                                                                   zs in
-                                                               FStar_Syntax_Syntax.mk_Tm_app
-                                                                 w uu___25
-                                                                 w.FStar_Syntax_Syntax.pos in
-                                                             ((let uu___26 =
-                                                                 FStar_Compiler_Effect.op_Less_Bar
-                                                                   (debug wl1)
-                                                                   (FStar_Options.Other
-                                                                    "Rel") in
-                                                               if uu___26
-                                                               then
-                                                                 let uu___27
-                                                                   =
-                                                                   let uu___28
-                                                                    =
-                                                                    flex_t_to_string
-                                                                    lhs in
-                                                                   let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    flex_t_to_string
-                                                                    rhs in
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    term_to_string
-                                                                    w in
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_Syntax_Print.binders_to_string
-                                                                    ", "
-                                                                    (FStar_Compiler_List.op_At
-                                                                    ctx_l
-                                                                    binders_lhs) in
-                                                                    let uu___35
-                                                                    =
-                                                                    let uu___36
-                                                                    =
-                                                                    FStar_Syntax_Print.binders_to_string
-                                                                    ", "
-                                                                    (FStar_Compiler_List.op_At
-                                                                    ctx_r
-                                                                    binders_rhs) in
-                                                                    let uu___37
-                                                                    =
-                                                                    let uu___38
-                                                                    =
-                                                                    FStar_Syntax_Print.binders_to_string
-                                                                    ", " zs in
-                                                                    [uu___38] in
-                                                                    uu___36
-                                                                    ::
-                                                                    uu___37 in
-                                                                    uu___34
-                                                                    ::
-                                                                    uu___35 in
-                                                                    uu___32
-                                                                    ::
-                                                                    uu___33 in
-                                                                    uu___30
-                                                                    ::
-                                                                    uu___31 in
-                                                                   uu___28 ::
-                                                                    uu___29 in
-                                                                 FStar_Compiler_Util.print
-                                                                   "flex-flex quasi:\n\tlhs=%s\n\trhs=%s\n\tsol=%s\n\tctx_l@binders_lhs=%s\n\tctx_r@binders_rhs=%s\n\tzs=%s\n"
-                                                                   uu___27
-                                                               else ());
-                                                              (let rc =
-                                                                 if is_ghost
-                                                                 then
-                                                                   FStar_Syntax_Util.residual_gtot
-                                                                    t_res_lhs
-                                                                 else
-                                                                   FStar_Syntax_Util.residual_tot
-                                                                    t_res_lhs in
-                                                               let s1_sol =
-                                                                 FStar_Syntax_Util.abs
-                                                                   binders_lhs
-                                                                   w_app
-                                                                   (FStar_Pervasives_Native.Some
-                                                                    rc) in
-                                                               let s1 =
-                                                                 TERM
-                                                                   (u_lhs,
-                                                                    s1_sol) in
-                                                               let uu___26 =
-                                                                 FStar_Syntax_Unionfind.equiv
-                                                                   u_lhs.FStar_Syntax_Syntax.ctx_uvar_head
-                                                                   u_rhs.FStar_Syntax_Syntax.ctx_uvar_head in
-                                                               if uu___26
-                                                               then
-                                                                 let uu___27
-                                                                   =
-                                                                   solve_prob
-                                                                    orig
-                                                                    FStar_Pervasives_Native.None
-                                                                    [s1] wl1 in
-                                                                 solve
-                                                                   uu___27
-                                                               else
-                                                                 (let s2_sol
-                                                                    =
-                                                                    FStar_Syntax_Util.abs
-                                                                    binders_rhs
-                                                                    w_app
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    rc) in
-                                                                  let s2 =
-                                                                    TERM
-                                                                    (u_rhs,
-                                                                    s2_sol) in
-                                                                  let uu___28
-                                                                    =
-                                                                    solve_prob
-                                                                    orig
-                                                                    FStar_Pervasives_Native.None
-                                                                    [s1; s2]
-                                                                    wl1 in
-                                                                  solve
-                                                                    uu___28)))))))))
-                           | uu___8 ->
-                               let uu___9 =
-                                 FStar_Thunk.mkv "flex-flex: non-patterns" in
-                               giveup_or_defer orig wl
-                                 FStar_TypeChecker_Common.Deferred_flex_flex_nonpattern
-                                 uu___9)))
-and (solve_t' : tprob -> worklist -> solution) =
-  fun problem ->
-    fun wl ->
-      def_check_prob "solve_t'.1" (FStar_TypeChecker_Common.TProb problem);
-      (let giveup_or_defer1 orig msg = giveup_or_defer orig wl msg in
-       let rigid_heads_match need_unif torig wl1 t1 t2 =
-         let orig = FStar_TypeChecker_Common.TProb torig in
-         let env = p_env wl1 orig in
-         (let uu___2 =
-            FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-              (FStar_Options.Other "Rel") in
-          if uu___2
-          then
-            let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-            let uu___4 = FStar_Syntax_Print.tag_of_term t1 in
-            let uu___5 = FStar_Syntax_Print.term_to_string t2 in
-            let uu___6 = FStar_Syntax_Print.tag_of_term t2 in
-            FStar_Compiler_Util.print5 "Heads %s: %s (%s) and %s (%s)\n"
-              (if need_unif then "need unification" else "match") uu___3
-              uu___4 uu___5 uu___6
-          else ());
-         (let uu___2 = FStar_Syntax_Util.head_and_args t1 in
-          match uu___2 with
-          | (head1, args1) ->
-              let uu___3 = FStar_Syntax_Util.head_and_args t2 in
-              (match uu___3 with
-               | (head2, args2) ->
-                   let need_unif1 =
-                     match (((head1.FStar_Syntax_Syntax.n), args1),
-                             ((head2.FStar_Syntax_Syntax.n), args2))
-                     with
-                     | ((FStar_Syntax_Syntax.Tm_uinst (uu___4, us1),
-                         uu___5::uu___6),
-                        (FStar_Syntax_Syntax.Tm_uinst (uu___7, us2),
-                         uu___8::uu___9)) ->
-                         let uu___10 =
-                           (FStar_Compiler_List.for_all
-                              (fun u ->
-                                 let uu___11 = universe_has_max env u in
-                                 Prims.op_Negation uu___11) us1)
-                             &&
-                             (FStar_Compiler_List.for_all
-                                (fun u ->
-                                   let uu___11 = universe_has_max env u in
-                                   Prims.op_Negation uu___11) us2) in
-                         if uu___10 then need_unif else true
-                     | uu___4 -> need_unif in
-                   let solve_head_then wl2 k =
-                     if need_unif1
-                     then k true wl2
-                     else
-                       (let uu___5 = solve_maybe_uinsts orig head1 head2 wl2 in
-                        match uu___5 with
-                        | USolved wl3 -> k true wl3
-                        | UFailed msg -> giveup wl2 msg orig
-                        | UDeferred wl3 ->
-                            let uu___6 =
-                              defer_lit
-                                FStar_TypeChecker_Common.Deferred_univ_constraint
-                                "universe constraints" orig wl3 in
-                            k false uu___6) in
-                   let nargs = FStar_Compiler_List.length args1 in
-                   if nargs <> (FStar_Compiler_List.length args2)
-                   then
-                     let uu___4 =
-                       mklstr
-                         (fun uu___5 ->
-                            let uu___6 =
-                              FStar_Syntax_Print.term_to_string head1 in
-                            let uu___7 = args_to_string args1 in
-                            let uu___8 =
-                              FStar_Syntax_Print.term_to_string head2 in
-                            let uu___9 = args_to_string args2 in
-                            FStar_Compiler_Util.format4
-                              "unequal number of arguments: %s[%s] and %s[%s]"
-                              uu___6 uu___7 uu___8 uu___9) in
-                     giveup wl1 uu___4 orig
-                   else
-                     (let uu___5 =
-                        (nargs = Prims.int_zero) ||
-                          (let uu___6 = FStar_Syntax_Util.eq_args args1 args2 in
-                           uu___6 = FStar_Syntax_Util.Equal) in
-                      if uu___5
-                      then
-                        (if need_unif1
-                         then
-                           solve_t
-                             {
-                               FStar_TypeChecker_Common.pid =
-                                 (problem.FStar_TypeChecker_Common.pid);
-                               FStar_TypeChecker_Common.lhs = head1;
-                               FStar_TypeChecker_Common.relation =
-                                 (problem.FStar_TypeChecker_Common.relation);
-                               FStar_TypeChecker_Common.rhs = head2;
-                               FStar_TypeChecker_Common.element =
-                                 (problem.FStar_TypeChecker_Common.element);
-                               FStar_TypeChecker_Common.logical_guard =
-                                 (problem.FStar_TypeChecker_Common.logical_guard);
-                               FStar_TypeChecker_Common.logical_guard_uvar =
-                                 (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                               FStar_TypeChecker_Common.reason =
-                                 (problem.FStar_TypeChecker_Common.reason);
-                               FStar_TypeChecker_Common.loc =
-                                 (problem.FStar_TypeChecker_Common.loc);
-                               FStar_TypeChecker_Common.rank =
-                                 (problem.FStar_TypeChecker_Common.rank)
-                             } wl1
-                         else
-                           solve_head_then wl1
-                             (fun ok ->
-                                fun wl2 ->
-                                  if ok
-                                  then
-                                    let uu___7 =
-                                      solve_prob orig
-                                        FStar_Pervasives_Native.None [] wl2 in
-                                    solve uu___7
-                                  else solve wl2))
-                      else
-                        (let uu___7 = base_and_refinement env t1 in
-                         match uu___7 with
-                         | (base1, refinement1) ->
-                             let uu___8 = base_and_refinement env t2 in
-                             (match uu___8 with
-                              | (base2, refinement2) ->
-                                  (match (refinement1, refinement2) with
-                                   | (FStar_Pervasives_Native.None,
-                                      FStar_Pervasives_Native.None) ->
-                                       let mk_sub_probs wl2 =
-                                         let argp =
-                                           if need_unif1
-                                           then
-                                             FStar_Compiler_List.zip
-                                               ((head1,
-                                                  FStar_Pervasives_Native.None)
-                                               :: args1)
-                                               ((head2,
-                                                  FStar_Pervasives_Native.None)
-                                               :: args2)
-                                           else
-                                             FStar_Compiler_List.zip args1
-                                               args2 in
-                                         let uu___9 =
-                                           FStar_Compiler_List.fold_right
-                                             (fun uu___10 ->
-                                                fun uu___11 ->
-                                                  match (uu___10, uu___11)
-                                                  with
-                                                  | (((a1, uu___12),
-                                                      (a2, uu___13)),
-                                                     (probs, wl3)) ->
-                                                      let uu___14 =
-                                                        mk_problem wl3 []
-                                                          orig a1
-                                                          FStar_TypeChecker_Common.EQ
-                                                          a2
-                                                          FStar_Pervasives_Native.None
-                                                          "index" in
-                                                      (match uu___14 with
-                                                       | (prob', wl4) ->
-                                                           (((FStar_TypeChecker_Common.TProb
-                                                                prob') ::
-                                                             probs), wl4)))
-                                             argp ([], wl2) in
-                                         match uu___9 with
-                                         | (subprobs, wl3) ->
-                                             ((let uu___11 =
-                                                 FStar_Compiler_Effect.op_Less_Bar
-                                                   (debug wl3)
-                                                   (FStar_Options.Other "Rel") in
-                                               if uu___11
-                                               then
-                                                 let uu___12 =
-                                                   FStar_Compiler_Util.string_of_bool
-                                                     wl3.smt_ok in
-                                                 let uu___13 =
-                                                   (FStar_Common.string_of_list
-                                                      ())
-                                                     (prob_to_string env)
-                                                     subprobs in
-                                                 FStar_Compiler_Util.print2
-                                                   "Adding subproblems for arguments (smtok=%s): %s"
-                                                   uu___12 uu___13
-                                               else ());
-                                              (let uu___12 =
-                                                 FStar_Options.defensive () in
-                                               if uu___12
-                                               then
-                                                 FStar_Compiler_List.iter
-                                                   (def_check_prob
-                                                      "solve_t' subprobs")
-                                                   subprobs
-                                               else ());
-                                              (subprobs, wl3)) in
-                                       let solve_sub_probs env1 wl2 =
-                                         solve_head_then wl2
-                                           (fun ok ->
-                                              fun wl3 ->
-                                                if Prims.op_Negation ok
-                                                then solve wl3
-                                                else
-                                                  (let uu___10 =
-                                                     mk_sub_probs wl3 in
-                                                   match uu___10 with
-                                                   | (subprobs, wl4) ->
-                                                       let formula =
-                                                         let uu___11 =
-                                                           FStar_Compiler_List.map
-                                                             (fun p ->
-                                                                p_guard p)
-                                                             subprobs in
-                                                         FStar_Syntax_Util.mk_conj_l
-                                                           uu___11 in
-                                                       let wl5 =
-                                                         solve_prob orig
-                                                           (FStar_Pervasives_Native.Some
-                                                              formula) [] wl4 in
-                                                       let uu___11 =
-                                                         attempt subprobs wl5 in
-                                                       solve uu___11)) in
-                                       let solve_sub_probs_no_smt wl2 =
-                                         solve_head_then wl2
-                                           (fun ok ->
-                                              fun wl3 ->
-                                                let uu___10 =
-                                                  mk_sub_probs wl3 in
-                                                match uu___10 with
-                                                | (subprobs, wl4) ->
-                                                    let formula =
-                                                      let uu___11 =
-                                                        FStar_Compiler_List.map
-                                                          (fun p -> p_guard p)
-                                                          subprobs in
-                                                      FStar_Syntax_Util.mk_conj_l
-                                                        uu___11 in
-                                                    let wl5 =
-                                                      solve_prob orig
-                                                        (FStar_Pervasives_Native.Some
-                                                           formula) [] wl4 in
-                                                    let uu___11 =
-                                                      attempt subprobs wl5 in
-                                                    solve uu___11) in
-                                       let unfold_and_retry d wl2 uu___9 =
-                                         match uu___9 with
-                                         | (prob, reason) ->
-                                             ((let uu___11 =
-                                                 FStar_Compiler_Effect.op_Less_Bar
-                                                   (debug wl2)
-                                                   (FStar_Options.Other "Rel") in
-                                               if uu___11
-                                               then
-                                                 let uu___12 =
-                                                   prob_to_string env orig in
-                                                 let uu___13 =
-                                                   FStar_Thunk.force reason in
-                                                 FStar_Compiler_Util.print2
-                                                   "Failed to solve %s because a sub-problem is not solvable without SMT because %s"
-                                                   uu___12 uu___13
-                                               else ());
-                                              (let env1 = p_env wl2 prob in
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_TypeChecker_Normalize.unfold_head_once
-                                                     env1 t1 in
-                                                 let uu___13 =
-                                                   FStar_TypeChecker_Normalize.unfold_head_once
-                                                     env1 t2 in
-                                                 (uu___12, uu___13) in
-                                               match uu___11 with
-                                               | (FStar_Pervasives_Native.Some
-                                                  t1',
-                                                  FStar_Pervasives_Native.Some
-                                                  t2') ->
-                                                   let uu___12 =
-                                                     FStar_Syntax_Util.head_and_args
-                                                       t1' in
-                                                   (match uu___12 with
-                                                    | (head1', uu___13) ->
-                                                        let uu___14 =
-                                                          FStar_Syntax_Util.head_and_args
-                                                            t2' in
-                                                        (match uu___14 with
-                                                         | (head2', uu___15)
-                                                             ->
-                                                             let uu___16 =
-                                                               let uu___17 =
-                                                                 FStar_Syntax_Util.eq_tm
-                                                                   head1'
-                                                                   head1 in
-                                                               let uu___18 =
-                                                                 FStar_Syntax_Util.eq_tm
-                                                                   head2'
-                                                                   head2 in
-                                                               (uu___17,
-                                                                 uu___18) in
-                                                             (match uu___16
-                                                              with
-                                                              | (FStar_Syntax_Util.Equal,
-                                                                 FStar_Syntax_Util.Equal)
-                                                                  ->
-                                                                  ((let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (debug
-                                                                    wl2)
-                                                                    (FStar_Options.Other
-                                                                    "Rel") in
-                                                                    if
-                                                                    uu___18
-                                                                    then
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t1 in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t1' in
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t2 in
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t2' in
-                                                                    FStar_Compiler_Util.print4
-                                                                    "Unfolding didn't make progress ... got %s ~> %s;\nand %s ~> %s\n"
-                                                                    uu___19
-                                                                    uu___20
-                                                                    uu___21
-                                                                    uu___22
-                                                                    else ());
-                                                                   solve_sub_probs
-                                                                    env1 wl2)
-                                                              | uu___17 ->
-                                                                  let torig'
-                                                                    =
-                                                                    {
-                                                                    FStar_TypeChecker_Common.pid
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.pid);
-                                                                    FStar_TypeChecker_Common.lhs
-                                                                    = t1';
-                                                                    FStar_TypeChecker_Common.relation
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.relation);
-                                                                    FStar_TypeChecker_Common.rhs
-                                                                    = t2';
-                                                                    FStar_TypeChecker_Common.element
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.element);
-                                                                    FStar_TypeChecker_Common.logical_guard
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.logical_guard);
-                                                                    FStar_TypeChecker_Common.logical_guard_uvar
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.logical_guard_uvar);
-                                                                    FStar_TypeChecker_Common.reason
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.reason);
-                                                                    FStar_TypeChecker_Common.loc
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.loc);
-                                                                    FStar_TypeChecker_Common.rank
-                                                                    =
-                                                                    (torig.FStar_TypeChecker_Common.rank)
-                                                                    } in
-                                                                  ((let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (debug
-                                                                    wl2)
-                                                                    (FStar_Options.Other
-                                                                    "Rel") in
-                                                                    if
-                                                                    uu___19
-                                                                    then
-                                                                    let uu___20
-                                                                    =
-                                                                    prob_to_string
-                                                                    env1
-                                                                    (FStar_TypeChecker_Common.TProb
-                                                                    torig') in
-                                                                    FStar_Compiler_Util.print1
-                                                                    "Unfolded and now trying %s\n"
-                                                                    uu___20
-                                                                    else ());
-                                                                   solve_t
-                                                                    torig'
-                                                                    wl2))))
-                                               | uu___12 ->
-                                                   solve_sub_probs env1 wl2)) in
-                                       let d =
-                                         let uu___9 =
-                                           delta_depth_of_term env head1 in
-                                         match uu___9 with
-                                         | FStar_Pervasives_Native.None ->
-                                             FStar_Pervasives_Native.None
-                                         | FStar_Pervasives_Native.Some d1 ->
-                                             FStar_TypeChecker_Common.decr_delta_depth
-                                               d1 in
-                                       let treat_as_injective =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Syntax_Util.un_uinst head1 in
-                                           uu___10.FStar_Syntax_Syntax.n in
-                                         match uu___9 with
-                                         | FStar_Syntax_Syntax.Tm_fvar fv ->
-                                             FStar_TypeChecker_Env.fv_has_attr
-                                               env fv
-                                               FStar_Parser_Const.unifier_hint_injective_lid
-                                         | uu___10 -> false in
-                                       (match d with
-                                        | FStar_Pervasives_Native.Some d1
-                                            when
-                                            wl1.smt_ok &&
-                                              (Prims.op_Negation
-                                                 treat_as_injective)
-                                            ->
-                                            try_solve_without_smt_or_else wl1
-                                              solve_sub_probs_no_smt
-                                              (unfold_and_retry d1)
-                                        | uu___9 -> solve_sub_probs env wl1)
-                                   | uu___9 ->
-                                       let lhs =
-                                         force_refinement
-                                           (base1, refinement1) in
-                                       let rhs =
-                                         force_refinement
-                                           (base2, refinement2) in
-                                       solve_t'
-                                         {
-                                           FStar_TypeChecker_Common.pid =
-                                             (problem.FStar_TypeChecker_Common.pid);
-                                           FStar_TypeChecker_Common.lhs = lhs;
-                                           FStar_TypeChecker_Common.relation
-                                             =
-                                             (problem.FStar_TypeChecker_Common.relation);
-                                           FStar_TypeChecker_Common.rhs = rhs;
-                                           FStar_TypeChecker_Common.element =
-                                             (problem.FStar_TypeChecker_Common.element);
-                                           FStar_TypeChecker_Common.logical_guard
-                                             =
-                                             (problem.FStar_TypeChecker_Common.logical_guard);
-                                           FStar_TypeChecker_Common.logical_guard_uvar
-                                             =
-                                             (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                                           FStar_TypeChecker_Common.reason =
-                                             (problem.FStar_TypeChecker_Common.reason);
-                                           FStar_TypeChecker_Common.loc =
-                                             (problem.FStar_TypeChecker_Common.loc);
-                                           FStar_TypeChecker_Common.rank =
-                                             (problem.FStar_TypeChecker_Common.rank)
-                                         } wl1)))))) in
-       let try_match_heuristic orig wl1 s1 s2 t1t2_opt =
-         let env = p_env wl1 orig in
-         let try_solve_branch scrutinee p =
-           let uu___1 = destruct_flex_t scrutinee wl1 in
-           match uu___1 with
-           | (Flex (_t, uv, _args), wl2) ->
-               let uu___2 =
-                 FStar_TypeChecker_PatternUtils.pat_as_exp true true env p in
-               (match uu___2 with
-                | (xs, pat_term, g_pat_as_exp, uu___3) ->
-                    let uu___4 =
-                      FStar_Compiler_List.fold_left
-                        (fun uu___5 ->
-                           fun x ->
-                             match uu___5 with
-                             | (subst, wl3) ->
-                                 let t_x =
-                                   FStar_Syntax_Subst.subst subst
-                                     x.FStar_Syntax_Syntax.sort in
-                                 let uu___6 = copy_uvar uv [] t_x wl3 in
-                                 (match uu___6 with
-                                  | (uu___7, u, wl4) ->
-                                      let subst1 =
-                                        (FStar_Syntax_Syntax.NT (x, u)) ::
-                                        subst in
-                                      (subst1, wl4))) ([], wl2) xs in
-                    (match uu___4 with
-                     | (subst, wl3) ->
-                         let pat_term1 =
-                           FStar_Syntax_Subst.subst subst pat_term in
-                         let uu___5 =
-                           let must_tot = false in
-                           let scrutinee_t =
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                     env scrutinee must_tot in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___8
-                                   FStar_Pervasives_Native.fst in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                 (FStar_TypeChecker_Normalize.normalize_refinement
-                                    FStar_TypeChecker_Normalize.whnf_steps
-                                    env) in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___6
-                               FStar_Syntax_Util.unrefine in
-                           (let uu___7 =
-                              FStar_Compiler_Effect.op_Less_Bar (debug wl3)
-                                (FStar_Options.Other "Rel") in
-                            if uu___7
-                            then
-                              let uu___8 =
-                                FStar_Syntax_Print.term_to_string pat_term1 in
-                              FStar_Compiler_Util.print1
-                                "Match heuristic, typechecking the pattern term: %s {\n\n"
-                                uu___8
-                            else ());
-                           (let uu___7 =
-                              let uu___8 =
-                                FStar_TypeChecker_Env.set_expected_typ env
-                                  scrutinee_t in
-                              env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                uu___8 pat_term1 must_tot in
-                            match uu___7 with
-                            | (pat_term2, pat_term_t, g_pat_term) ->
-                                ((let uu___9 =
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      (debug wl3) (FStar_Options.Other "Rel") in
-                                  if uu___9
-                                  then
-                                    let uu___10 =
-                                      FStar_Syntax_Print.term_to_string
-                                        pat_term2 in
-                                    let uu___11 =
-                                      FStar_Syntax_Print.term_to_string
-                                        pat_term_t in
-                                    FStar_Compiler_Util.print2
-                                      "} Match heuristic, typechecked pattern term to %s and type %s\n"
-                                      uu___10 uu___11
-                                  else ());
-                                 (pat_term2, g_pat_term))) in
-                         (match uu___5 with
-                          | (pat_term2, g_pat_term) ->
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    g_pat_term (simplify_guard env) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                  FStar_TypeChecker_Env.is_trivial_guard_formula in
-                              if uu___6
-                              then
-                                let uu___7 =
-                                  new_problem wl3 env scrutinee
-                                    FStar_TypeChecker_Common.EQ pat_term2
-                                    FStar_Pervasives_Native.None
-                                    scrutinee.FStar_Syntax_Syntax.pos
-                                    "match heuristic" in
-                                (match uu___7 with
-                                 | (prob, wl4) ->
-                                     let wl' =
-                                       extend_wl
-                                         {
-                                           attempting =
-                                             [FStar_TypeChecker_Common.TProb
-                                                prob];
-                                           wl_deferred = [];
-                                           wl_deferred_to_tac =
-                                             (wl4.wl_deferred_to_tac);
-                                           ctr = (wl4.ctr);
-                                           defer_ok = NoDefer;
-                                           smt_ok = false;
-                                           umax_heuristic_ok =
-                                             (wl4.umax_heuristic_ok);
-                                           tcenv = (wl4.tcenv);
-                                           wl_implicits = [];
-                                           repr_subcomp_allowed =
-                                             (wl4.repr_subcomp_allowed)
-                                         }
-                                         g_pat_term.FStar_TypeChecker_Common.deferred
-                                         g_pat_term.FStar_TypeChecker_Common.deferred_to_tac
-                                         [] in
-                                     let tx =
-                                       FStar_Syntax_Unionfind.new_transaction
-                                         () in
-                                     let uu___8 = solve wl' in
-                                     (match uu___8 with
-                                      | Success (uu___9, defer_to_tac, imps)
-                                          ->
-                                          let wl'1 =
-                                            {
-                                              attempting = [orig];
-                                              wl_deferred = (wl'.wl_deferred);
-                                              wl_deferred_to_tac =
-                                                (wl'.wl_deferred_to_tac);
-                                              ctr = (wl'.ctr);
-                                              defer_ok = (wl'.defer_ok);
-                                              smt_ok = (wl'.smt_ok);
-                                              umax_heuristic_ok =
-                                                (wl'.umax_heuristic_ok);
-                                              tcenv = (wl'.tcenv);
-                                              wl_implicits =
-                                                (wl'.wl_implicits);
-                                              repr_subcomp_allowed =
-                                                (wl'.repr_subcomp_allowed)
-                                            } in
-                                          let uu___10 = solve wl'1 in
-                                          (match uu___10 with
-                                           | Success
-                                               (uu___11, defer_to_tac',
-                                                imps')
-                                               ->
-                                               (FStar_Syntax_Unionfind.commit
-                                                  tx;
-                                                (let uu___13 =
-                                                   extend_wl wl4 []
-                                                     (FStar_Compiler_List.op_At
-                                                        defer_to_tac
-                                                        defer_to_tac')
-                                                     (FStar_Compiler_List.op_At
-                                                        imps
-                                                        (FStar_Compiler_List.op_At
-                                                           imps'
-                                                           (FStar_Compiler_List.op_At
-                                                              g_pat_as_exp.FStar_TypeChecker_Common.implicits
-                                                              g_pat_term.FStar_TypeChecker_Common.implicits))) in
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___13))
-                                           | Failed uu___11 ->
-                                               (FStar_Syntax_Unionfind.rollback
-                                                  tx;
-                                                FStar_Pervasives_Native.None))
-                                      | uu___9 ->
-                                          (FStar_Syntax_Unionfind.rollback tx;
-                                           FStar_Pervasives_Native.None)))
-                              else FStar_Pervasives_Native.None))) in
-         match t1t2_opt with
-         | FStar_Pervasives_Native.None ->
-             FStar_Pervasives.Inr FStar_Pervasives_Native.None
-         | FStar_Pervasives_Native.Some (t1, t2) ->
-             ((let uu___2 =
-                 FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                   (FStar_Options.Other "Rel") in
-               if uu___2
-               then
-                 let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-                 let uu___4 = FStar_Syntax_Print.term_to_string t2 in
-                 FStar_Compiler_Util.print2
-                   "Trying match heuristic for %s vs. %s\n" uu___3 uu___4
-               else ());
-              (let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Util.unmeta t1 in (s1, uu___4) in
-                 let uu___4 =
-                   let uu___5 = FStar_Syntax_Util.unmeta t2 in (s2, uu___5) in
-                 (uu___3, uu___4) in
-               match uu___2 with
-               | ((uu___3,
-                   {
-                     FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_match
-                       (scrutinee, uu___4, branches, uu___5);
-                     FStar_Syntax_Syntax.pos = uu___6;
-                     FStar_Syntax_Syntax.vars = uu___7;
-                     FStar_Syntax_Syntax.hash_code = uu___8;_}),
-                  (s, t)) ->
-                   let uu___9 =
-                     let uu___10 = is_flex scrutinee in
-                     Prims.op_Negation uu___10 in
-                   if uu___9
-                   then
-                     ((let uu___11 =
-                         FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                           (FStar_Options.Other "Rel") in
-                       if uu___11
-                       then
-                         let uu___12 =
-                           FStar_Syntax_Print.term_to_string scrutinee in
-                         FStar_Compiler_Util.print1
-                           "match head %s is not a flex term\n" uu___12
-                       else ());
-                      FStar_Pervasives.Inr FStar_Pervasives_Native.None)
-                   else
-                     if wl1.defer_ok = DeferAny
-                     then
-                       ((let uu___12 =
-                           FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                             (FStar_Options.Other "Rel") in
-                         if uu___12
-                         then
-                           FStar_Compiler_Util.print_string
-                             "Deferring ... \n"
-                         else ());
-                        FStar_Pervasives.Inl "defer")
-                     else
-                       ((let uu___13 =
-                           FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                             (FStar_Options.Other "Rel") in
-                         if uu___13
-                         then
-                           let uu___14 =
-                             FStar_Syntax_Print.term_to_string scrutinee in
-                           let uu___15 = FStar_Syntax_Print.term_to_string t in
-                           FStar_Compiler_Util.print2
-                             "Heuristic applicable with scrutinee %s and other side = %s\n"
-                             uu___14 uu___15
-                         else ());
-                        (let pat_discriminates uu___13 =
-                           match uu___13 with
-                           | ({
-                                FStar_Syntax_Syntax.v =
-                                  FStar_Syntax_Syntax.Pat_constant uu___14;
-                                FStar_Syntax_Syntax.p = uu___15;_},
-                              FStar_Pervasives_Native.None, uu___16) -> true
-                           | ({
-                                FStar_Syntax_Syntax.v =
-                                  FStar_Syntax_Syntax.Pat_cons uu___14;
-                                FStar_Syntax_Syntax.p = uu___15;_},
-                              FStar_Pervasives_Native.None, uu___16) -> true
-                           | uu___14 -> false in
-                         let head_matching_branch =
-                           FStar_Compiler_Effect.op_Bar_Greater branches
-                             (FStar_Compiler_Util.try_find
-                                (fun b ->
-                                   if pat_discriminates b
-                                   then
-                                     let uu___13 =
-                                       FStar_Syntax_Subst.open_branch b in
-                                     match uu___13 with
-                                     | (uu___14, uu___15, t') ->
-                                         let uu___16 =
-                                           head_matches_delta
-                                             (p_env wl1 orig) wl1.smt_ok s t' in
-                                         (match uu___16 with
-                                          | (FullMatch, uu___17) -> true
-                                          | (HeadMatch uu___17, uu___18) ->
-                                              true
-                                          | uu___17 -> false)
-                                   else false)) in
-                         match head_matching_branch with
-                         | FStar_Pervasives_Native.None ->
-                             ((let uu___14 =
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (debug wl1) (FStar_Options.Other "Rel") in
-                               if uu___14
-                               then
-                                 FStar_Compiler_Util.print_string
-                                   "No head_matching branch\n"
-                               else ());
-                              (let try_branches =
-                                 let uu___14 =
-                                   FStar_Compiler_Util.prefix_until
-                                     (fun b ->
-                                        Prims.op_Negation
-                                          (pat_discriminates b)) branches in
-                                 match uu___14 with
-                                 | FStar_Pervasives_Native.Some
-                                     (branches1, uu___15, uu___16) ->
-                                     branches1
-                                 | uu___15 -> branches in
-                               let uu___14 =
-                                 FStar_Compiler_Util.find_map try_branches
-                                   (fun b ->
-                                      let uu___15 =
-                                        FStar_Syntax_Subst.open_branch b in
-                                      match uu___15 with
-                                      | (p, uu___16, uu___17) ->
-                                          try_solve_branch scrutinee p) in
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (fun uu___15 -> FStar_Pervasives.Inr uu___15)
-                                 uu___14))
-                         | FStar_Pervasives_Native.Some b ->
-                             let uu___13 = FStar_Syntax_Subst.open_branch b in
-                             (match uu___13 with
-                              | (p, uu___14, e) ->
-                                  ((let uu___16 =
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        (debug wl1)
-                                        (FStar_Options.Other "Rel") in
-                                    if uu___16
-                                    then
-                                      let uu___17 =
-                                        FStar_Syntax_Print.pat_to_string p in
-                                      let uu___18 =
-                                        FStar_Syntax_Print.term_to_string e in
-                                      FStar_Compiler_Util.print2
-                                        "Found head matching branch %s -> %s\n"
-                                        uu___17 uu___18
-                                    else ());
-                                   (let uu___16 =
-                                      try_solve_branch scrutinee p in
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      (fun uu___17 ->
-                                         FStar_Pervasives.Inr uu___17)
-                                      uu___16)))))
-               | ((s, t),
-                  (uu___3,
-                   {
-                     FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_match
-                       (scrutinee, uu___4, branches, uu___5);
-                     FStar_Syntax_Syntax.pos = uu___6;
-                     FStar_Syntax_Syntax.vars = uu___7;
-                     FStar_Syntax_Syntax.hash_code = uu___8;_}))
-                   ->
-                   let uu___9 =
-                     let uu___10 = is_flex scrutinee in
-                     Prims.op_Negation uu___10 in
-                   if uu___9
-                   then
-                     ((let uu___11 =
-                         FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                           (FStar_Options.Other "Rel") in
-                       if uu___11
-                       then
-                         let uu___12 =
-                           FStar_Syntax_Print.term_to_string scrutinee in
-                         FStar_Compiler_Util.print1
-                           "match head %s is not a flex term\n" uu___12
-                       else ());
-                      FStar_Pervasives.Inr FStar_Pervasives_Native.None)
-                   else
-                     if wl1.defer_ok = DeferAny
-                     then
-                       ((let uu___12 =
-                           FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                             (FStar_Options.Other "Rel") in
-                         if uu___12
-                         then
-                           FStar_Compiler_Util.print_string
-                             "Deferring ... \n"
-                         else ());
-                        FStar_Pervasives.Inl "defer")
-                     else
-                       ((let uu___13 =
-                           FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                             (FStar_Options.Other "Rel") in
-                         if uu___13
-                         then
-                           let uu___14 =
-                             FStar_Syntax_Print.term_to_string scrutinee in
-                           let uu___15 = FStar_Syntax_Print.term_to_string t in
-                           FStar_Compiler_Util.print2
-                             "Heuristic applicable with scrutinee %s and other side = %s\n"
-                             uu___14 uu___15
-                         else ());
-                        (let pat_discriminates uu___13 =
-                           match uu___13 with
-                           | ({
-                                FStar_Syntax_Syntax.v =
-                                  FStar_Syntax_Syntax.Pat_constant uu___14;
-                                FStar_Syntax_Syntax.p = uu___15;_},
-                              FStar_Pervasives_Native.None, uu___16) -> true
-                           | ({
-                                FStar_Syntax_Syntax.v =
-                                  FStar_Syntax_Syntax.Pat_cons uu___14;
-                                FStar_Syntax_Syntax.p = uu___15;_},
-                              FStar_Pervasives_Native.None, uu___16) -> true
-                           | uu___14 -> false in
-                         let head_matching_branch =
-                           FStar_Compiler_Effect.op_Bar_Greater branches
-                             (FStar_Compiler_Util.try_find
-                                (fun b ->
-                                   if pat_discriminates b
-                                   then
-                                     let uu___13 =
-                                       FStar_Syntax_Subst.open_branch b in
-                                     match uu___13 with
-                                     | (uu___14, uu___15, t') ->
-                                         let uu___16 =
-                                           head_matches_delta
-                                             (p_env wl1 orig) wl1.smt_ok s t' in
-                                         (match uu___16 with
-                                          | (FullMatch, uu___17) -> true
-                                          | (HeadMatch uu___17, uu___18) ->
-                                              true
-                                          | uu___17 -> false)
-                                   else false)) in
-                         match head_matching_branch with
-                         | FStar_Pervasives_Native.None ->
-                             ((let uu___14 =
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (debug wl1) (FStar_Options.Other "Rel") in
-                               if uu___14
-                               then
-                                 FStar_Compiler_Util.print_string
-                                   "No head_matching branch\n"
-                               else ());
-                              (let try_branches =
-                                 let uu___14 =
-                                   FStar_Compiler_Util.prefix_until
-                                     (fun b ->
-                                        Prims.op_Negation
-                                          (pat_discriminates b)) branches in
-                                 match uu___14 with
-                                 | FStar_Pervasives_Native.Some
-                                     (branches1, uu___15, uu___16) ->
-                                     branches1
-                                 | uu___15 -> branches in
-                               let uu___14 =
-                                 FStar_Compiler_Util.find_map try_branches
-                                   (fun b ->
-                                      let uu___15 =
-                                        FStar_Syntax_Subst.open_branch b in
-                                      match uu___15 with
-                                      | (p, uu___16, uu___17) ->
-                                          try_solve_branch scrutinee p) in
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (fun uu___15 -> FStar_Pervasives.Inr uu___15)
-                                 uu___14))
-                         | FStar_Pervasives_Native.Some b ->
-                             let uu___13 = FStar_Syntax_Subst.open_branch b in
-                             (match uu___13 with
-                              | (p, uu___14, e) ->
-                                  ((let uu___16 =
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        (debug wl1)
-                                        (FStar_Options.Other "Rel") in
-                                    if uu___16
-                                    then
-                                      let uu___17 =
-                                        FStar_Syntax_Print.pat_to_string p in
-                                      let uu___18 =
-                                        FStar_Syntax_Print.term_to_string e in
-                                      FStar_Compiler_Util.print2
-                                        "Found head matching branch %s -> %s\n"
-                                        uu___17 uu___18
-                                    else ());
-                                   (let uu___16 =
-                                      try_solve_branch scrutinee p in
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      (fun uu___17 ->
-                                         FStar_Pervasives.Inr uu___17)
-                                      uu___16)))))
-               | uu___3 ->
-                   ((let uu___5 =
-                       FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-                         (FStar_Options.Other "Rel") in
-                     if uu___5
-                     then
-                       let uu___6 = FStar_Syntax_Print.tag_of_term t1 in
-                       let uu___7 = FStar_Syntax_Print.tag_of_term t2 in
-                       FStar_Compiler_Util.print2
-                         "Heuristic not applicable: tag lhs=%s, rhs=%s\n"
-                         uu___6 uu___7
-                     else ());
-                    FStar_Pervasives.Inr FStar_Pervasives_Native.None))) in
-       let rigid_rigid_delta torig wl1 head1 head2 t1 t2 =
-         let orig = FStar_TypeChecker_Common.TProb torig in
-         (let uu___2 =
-            FStar_Compiler_Effect.op_Less_Bar (debug wl1)
-              (FStar_Options.Other "RelDelta") in
-          if uu___2
-          then
-            let uu___3 = FStar_Syntax_Print.tag_of_term t1 in
-            let uu___4 = FStar_Syntax_Print.tag_of_term t2 in
-            let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-            let uu___6 = FStar_Syntax_Print.term_to_string t2 in
-            FStar_Compiler_Util.print4
-              "rigid_rigid_delta of %s-%s (%s, %s)\n" uu___3 uu___4 uu___5
-              uu___6
-          else ());
-         (let uu___2 = head_matches_delta (p_env wl1 orig) wl1.smt_ok t1 t2 in
-          match uu___2 with
-          | (m, o) ->
-              (match (m, o) with
-               | (MisMatch uu___3, uu___4) ->
-                   let try_reveal_hide t11 t21 =
-                     let payload_of_hide_reveal h args =
-                       match ((h.FStar_Syntax_Syntax.n), args) with
-                       | (FStar_Syntax_Syntax.Tm_uinst (uu___5, u::[]),
-                          (ty, FStar_Pervasives_Native.Some
-                           { FStar_Syntax_Syntax.aqual_implicit = true;
-                             FStar_Syntax_Syntax.aqual_attributes = uu___6;_})::
-                          (t, uu___7)::[]) when is_flex t ->
-                           FStar_Pervasives_Native.Some (u, ty, t)
-                       | uu___5 -> FStar_Pervasives_Native.None in
-                     let is_reveal_or_hide t =
-                       let uu___5 = FStar_Syntax_Util.head_and_args t in
-                       match uu___5 with
-                       | (h, args) ->
-                           let uu___6 =
-                             FStar_Syntax_Util.is_fvar
-                               FStar_Parser_Const.reveal h in
-                           if uu___6
-                           then
-                             (match payload_of_hide_reveal h args with
-                              | FStar_Pervasives_Native.None ->
-                                  FStar_Pervasives_Native.None
-                              | FStar_Pervasives_Native.Some t3 ->
-                                  FStar_Pervasives_Native.Some
-                                    (FStar_Pervasives.Inl t3))
-                           else
-                             (let uu___8 =
-                                FStar_Syntax_Util.is_fvar
-                                  FStar_Parser_Const.hide h in
-                              if uu___8
-                              then
-                                match payload_of_hide_reveal h args with
-                                | FStar_Pervasives_Native.None ->
-                                    FStar_Pervasives_Native.None
-                                | FStar_Pervasives_Native.Some t3 ->
-                                    FStar_Pervasives_Native.Some
-                                      (FStar_Pervasives.Inr t3)
-                              else FStar_Pervasives_Native.None) in
-                     let mk_fv_app lid u args r =
-                       let fv =
-                         FStar_TypeChecker_Env.fvar_of_nonqual_lid wl1.tcenv
-                           lid in
-                       let head = FStar_Syntax_Syntax.mk_Tm_uinst fv [u] in
-                       FStar_Syntax_Syntax.mk_Tm_app head args r in
-                     let uu___5 =
-                       let uu___6 = is_reveal_or_hide t11 in
-                       let uu___7 = is_reveal_or_hide t21 in (uu___6, uu___7) in
-                     match uu___5 with
-                     | (FStar_Pervasives_Native.None,
-                        FStar_Pervasives_Native.None) ->
-                         FStar_Pervasives_Native.None
-                     | (FStar_Pervasives_Native.Some (FStar_Pervasives.Inl
-                        uu___6), FStar_Pervasives_Native.Some
-                        (FStar_Pervasives.Inl uu___7)) ->
-                         FStar_Pervasives_Native.None
-                     | (FStar_Pervasives_Native.Some (FStar_Pervasives.Inr
-                        uu___6), FStar_Pervasives_Native.Some
-                        (FStar_Pervasives.Inr uu___7)) ->
-                         FStar_Pervasives_Native.None
-                     | (FStar_Pervasives_Native.Some (FStar_Pervasives.Inl
-                        uu___6), FStar_Pervasives_Native.Some
-                        (FStar_Pervasives.Inr uu___7)) ->
-                         FStar_Pervasives_Native.None
-                     | (FStar_Pervasives_Native.Some (FStar_Pervasives.Inr
-                        uu___6), FStar_Pervasives_Native.Some
-                        (FStar_Pervasives.Inl uu___7)) ->
-                         FStar_Pervasives_Native.None
-                     | (FStar_Pervasives_Native.Some (FStar_Pervasives.Inl
-                        (u, ty, lhs)), FStar_Pervasives_Native.None) ->
-                         let rhs =
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.as_aqual_implicit true in
-                               (ty, uu___8) in
-                             [uu___7; (t21, FStar_Pervasives_Native.None)] in
-                           mk_fv_app FStar_Parser_Const.hide u uu___6
-                             t21.FStar_Syntax_Syntax.pos in
-                         FStar_Pervasives_Native.Some (lhs, rhs)
-                     | (FStar_Pervasives_Native.None,
-                        FStar_Pervasives_Native.Some (FStar_Pervasives.Inl
-                        (u, ty, rhs))) ->
-                         let lhs =
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.as_aqual_implicit true in
-                               (ty, uu___8) in
-                             [uu___7; (t11, FStar_Pervasives_Native.None)] in
-                           mk_fv_app FStar_Parser_Const.hide u uu___6
-                             t11.FStar_Syntax_Syntax.pos in
-                         FStar_Pervasives_Native.Some (lhs, rhs)
-                     | (FStar_Pervasives_Native.Some (FStar_Pervasives.Inr
-                        (u, ty, lhs)), FStar_Pervasives_Native.None) ->
-                         let rhs =
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.as_aqual_implicit true in
-                               (ty, uu___8) in
-                             [uu___7; (t21, FStar_Pervasives_Native.None)] in
-                           mk_fv_app FStar_Parser_Const.reveal u uu___6
-                             t21.FStar_Syntax_Syntax.pos in
-                         FStar_Pervasives_Native.Some (lhs, rhs)
-                     | (FStar_Pervasives_Native.None,
-                        FStar_Pervasives_Native.Some (FStar_Pervasives.Inr
-                        (u, ty, rhs))) ->
-                         let lhs =
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.as_aqual_implicit true in
-                               (ty, uu___8) in
-                             [uu___7; (t11, FStar_Pervasives_Native.None)] in
-                           mk_fv_app FStar_Parser_Const.reveal u uu___6
-                             t11.FStar_Syntax_Syntax.pos in
-                         FStar_Pervasives_Native.Some (lhs, rhs) in
-                   let uu___5 = try_match_heuristic orig wl1 t1 t2 o in
-                   (match uu___5 with
-                    | FStar_Pervasives.Inl _defer_ok ->
-                        let uu___6 =
-                          FStar_Thunk.mkv "delaying match heuristic" in
-                        giveup_or_defer1 orig
-                          FStar_TypeChecker_Common.Deferred_delay_match_heuristic
-                          uu___6
-                    | FStar_Pervasives.Inr (FStar_Pervasives_Native.Some wl2)
-                        -> solve wl2
-                    | FStar_Pervasives.Inr (FStar_Pervasives_Native.None) ->
-                        let uu___6 = try_reveal_hide t1 t2 in
-                        (match uu___6 with
-                         | FStar_Pervasives_Native.Some (t1', t2') ->
-                             solve_t
-                               {
-                                 FStar_TypeChecker_Common.pid =
-                                   (problem.FStar_TypeChecker_Common.pid);
-                                 FStar_TypeChecker_Common.lhs = t1';
-                                 FStar_TypeChecker_Common.relation =
-                                   (problem.FStar_TypeChecker_Common.relation);
-                                 FStar_TypeChecker_Common.rhs = t2';
-                                 FStar_TypeChecker_Common.element =
-                                   (problem.FStar_TypeChecker_Common.element);
-                                 FStar_TypeChecker_Common.logical_guard =
-                                   (problem.FStar_TypeChecker_Common.logical_guard);
-                                 FStar_TypeChecker_Common.logical_guard_uvar
-                                   =
-                                   (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                                 FStar_TypeChecker_Common.reason =
-                                   (problem.FStar_TypeChecker_Common.reason);
-                                 FStar_TypeChecker_Common.loc =
-                                   (problem.FStar_TypeChecker_Common.loc);
-                                 FStar_TypeChecker_Common.rank =
-                                   (problem.FStar_TypeChecker_Common.rank)
-                               } wl1
-                         | FStar_Pervasives_Native.None ->
-                             let uu___7 =
-                               ((may_relate wl1.tcenv
-                                   problem.FStar_TypeChecker_Common.relation
-                                   head1)
-                                  ||
-                                  (may_relate wl1.tcenv
-                                     problem.FStar_TypeChecker_Common.relation
-                                     head2))
-                                 && wl1.smt_ok in
-                             if uu___7
-                             then
-                               let uu___8 = guard_of_prob wl1 problem t1 t2 in
-                               (match uu___8 with
-                                | (guard, wl2) ->
-                                    let uu___9 =
-                                      solve_prob orig
-                                        (FStar_Pervasives_Native.Some guard)
-                                        [] wl2 in
-                                    solve uu___9)
-                             else
-                               (let uu___9 =
-                                  mklstr
-                                    (fun uu___10 ->
-                                       let uu___11 =
-                                         FStar_Syntax_Print.term_to_string
-                                           head1 in
-                                       let uu___12 =
-                                         let uu___13 =
-                                           let uu___14 =
-                                             delta_depth_of_term wl1.tcenv
-                                               head1 in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___14
-                                             (fun x ->
-                                                let uu___15 =
-                                                  FStar_Syntax_Print.delta_depth_to_string
-                                                    x in
-                                                FStar_Pervasives_Native.Some
-                                                  uu___15) in
-                                         FStar_Compiler_Util.dflt "" uu___13 in
-                                       let uu___13 =
-                                         FStar_Syntax_Print.term_to_string
-                                           head2 in
-                                       let uu___14 =
-                                         let uu___15 =
-                                           let uu___16 =
-                                             delta_depth_of_term wl1.tcenv
-                                               head2 in
-                                           FStar_Compiler_Util.bind_opt
-                                             uu___16
-                                             (fun x ->
-                                                let uu___17 =
-                                                  FStar_Syntax_Print.delta_depth_to_string
-                                                    x in
-                                                FStar_Pervasives_Native.Some
-                                                  uu___17) in
-                                         FStar_Compiler_Util.dflt "" uu___15 in
-                                       FStar_Compiler_Util.format4
-                                         "head mismatch (%s (%s) vs %s (%s))"
-                                         uu___11 uu___12 uu___13 uu___14) in
-                                giveup wl1 uu___9 orig)))
-               | (HeadMatch (true), uu___3) when
-                   problem.FStar_TypeChecker_Common.relation <>
-                     FStar_TypeChecker_Common.EQ
-                   ->
-                   if wl1.smt_ok
-                   then
-                     let uu___4 = guard_of_prob wl1 problem t1 t2 in
-                     (match uu___4 with
-                      | (guard, wl2) ->
-                          let uu___5 =
-                            solve_prob orig
-                              (FStar_Pervasives_Native.Some guard) [] wl2 in
-                          solve uu___5)
-                   else
-                     (let uu___5 =
-                        mklstr
-                          (fun uu___6 ->
-                             let uu___7 =
-                               FStar_Syntax_Print.term_to_string t1 in
-                             let uu___8 =
-                               FStar_Syntax_Print.term_to_string t2 in
-                             FStar_Compiler_Util.format2
-                               "head mismatch for subtyping (%s vs %s)"
-                               uu___7 uu___8) in
-                      giveup wl1 uu___5 orig)
-               | (uu___3, FStar_Pervasives_Native.Some (t11, t21)) ->
-                   solve_t
-                     {
-                       FStar_TypeChecker_Common.pid =
-                         (problem.FStar_TypeChecker_Common.pid);
-                       FStar_TypeChecker_Common.lhs = t11;
-                       FStar_TypeChecker_Common.relation =
-                         (problem.FStar_TypeChecker_Common.relation);
-                       FStar_TypeChecker_Common.rhs = t21;
-                       FStar_TypeChecker_Common.element =
-                         (problem.FStar_TypeChecker_Common.element);
-                       FStar_TypeChecker_Common.logical_guard =
-                         (problem.FStar_TypeChecker_Common.logical_guard);
-                       FStar_TypeChecker_Common.logical_guard_uvar =
-                         (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                       FStar_TypeChecker_Common.reason =
-                         (problem.FStar_TypeChecker_Common.reason);
-                       FStar_TypeChecker_Common.loc =
-                         (problem.FStar_TypeChecker_Common.loc);
-                       FStar_TypeChecker_Common.rank =
-                         (problem.FStar_TypeChecker_Common.rank)
-                     } wl1
-               | (HeadMatch need_unif, FStar_Pervasives_Native.None) ->
-                   rigid_heads_match need_unif torig wl1 t1 t2
-               | (FullMatch, FStar_Pervasives_Native.None) ->
-                   rigid_heads_match false torig wl1 t1 t2)) in
-       let orig = FStar_TypeChecker_Common.TProb problem in
-       def_check_prob "solve_t'.2" orig;
-       (let uu___2 =
-          FStar_Compiler_Util.physical_equality
-            problem.FStar_TypeChecker_Common.lhs
-            problem.FStar_TypeChecker_Common.rhs in
-        if uu___2
-        then
-          let uu___3 = solve_prob orig FStar_Pervasives_Native.None [] wl in
-          solve uu___3
-        else
-          (let t1 = problem.FStar_TypeChecker_Common.lhs in
-           let t2 = problem.FStar_TypeChecker_Common.rhs in
-           (let uu___5 =
-              let uu___6 = p_scope orig in
-              FStar_Compiler_List.map
-                (fun b -> b.FStar_Syntax_Syntax.binder_bv) uu___6 in
-            FStar_TypeChecker_Env.def_check_closed_in (p_loc orig) "ref.t1"
-              uu___5 t1);
-           (let uu___6 =
-              let uu___7 = p_scope orig in
-              FStar_Compiler_List.map
-                (fun b -> b.FStar_Syntax_Syntax.binder_bv) uu___7 in
-            FStar_TypeChecker_Env.def_check_closed_in (p_loc orig) "ref.t2"
-              uu___6 t2);
-           (let uu___7 = debug wl (FStar_Options.Other "Rel") in
-            if uu___7
-            then
-              let uu___8 =
-                FStar_Compiler_Util.string_of_int
-                  problem.FStar_TypeChecker_Common.pid in
-              let uu___9 =
-                let uu___10 = FStar_Syntax_Print.tag_of_term t1 in
-                let uu___11 =
-                  let uu___12 = FStar_Syntax_Print.term_to_string t1 in
-                  Prims.op_Hat "::" uu___12 in
-                Prims.op_Hat uu___10 uu___11 in
-              let uu___10 =
-                let uu___11 = FStar_Syntax_Print.tag_of_term t2 in
-                let uu___12 =
-                  let uu___13 = FStar_Syntax_Print.term_to_string t2 in
-                  Prims.op_Hat "::" uu___13 in
-                Prims.op_Hat uu___11 uu___12 in
-              FStar_Compiler_Util.print4
-                "Attempting %s (%s vs %s); rel = (%s)\n" uu___8 uu___9
-                uu___10
-                (rel_to_string problem.FStar_TypeChecker_Common.relation)
-            else ());
-           (match ((t1.FStar_Syntax_Syntax.n), (t2.FStar_Syntax_Syntax.n))
-            with
-            | (FStar_Syntax_Syntax.Tm_delayed uu___7, uu___8) ->
-                failwith "Impossible: terms were not compressed"
-            | (uu___7, FStar_Syntax_Syntax.Tm_delayed uu___8) ->
-                failwith "Impossible: terms were not compressed"
-            | (FStar_Syntax_Syntax.Tm_ascribed uu___7, uu___8) ->
-                let uu___9 =
-                  let uu___10 = FStar_Syntax_Util.unascribe t1 in
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs = uu___10;
-                    FStar_TypeChecker_Common.relation =
-                      (problem.FStar_TypeChecker_Common.relation);
-                    FStar_TypeChecker_Common.rhs =
-                      (problem.FStar_TypeChecker_Common.rhs);
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } in
-                solve_t' uu___9 wl
-            | (FStar_Syntax_Syntax.Tm_meta uu___7, uu___8) ->
-                let uu___9 =
-                  let uu___10 = FStar_Syntax_Util.unmeta t1 in
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs = uu___10;
-                    FStar_TypeChecker_Common.relation =
-                      (problem.FStar_TypeChecker_Common.relation);
-                    FStar_TypeChecker_Common.rhs =
-                      (problem.FStar_TypeChecker_Common.rhs);
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } in
-                solve_t' uu___9 wl
-            | (uu___7, FStar_Syntax_Syntax.Tm_ascribed uu___8) ->
-                let uu___9 =
-                  let uu___10 = FStar_Syntax_Util.unascribe t2 in
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs =
-                      (problem.FStar_TypeChecker_Common.lhs);
-                    FStar_TypeChecker_Common.relation =
-                      (problem.FStar_TypeChecker_Common.relation);
-                    FStar_TypeChecker_Common.rhs = uu___10;
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } in
-                solve_t' uu___9 wl
-            | (uu___7, FStar_Syntax_Syntax.Tm_meta uu___8) ->
-                let uu___9 =
-                  let uu___10 = FStar_Syntax_Util.unmeta t2 in
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs =
-                      (problem.FStar_TypeChecker_Common.lhs);
-                    FStar_TypeChecker_Common.relation =
-                      (problem.FStar_TypeChecker_Common.relation);
-                    FStar_TypeChecker_Common.rhs = uu___10;
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } in
-                solve_t' uu___9 wl
-            | (FStar_Syntax_Syntax.Tm_quoted (t11, uu___7),
-               FStar_Syntax_Syntax.Tm_quoted (t21, uu___8)) ->
-                let uu___9 =
-                  solve_prob orig FStar_Pervasives_Native.None [] wl in
-                solve uu___9
-            | (FStar_Syntax_Syntax.Tm_bvar uu___7, uu___8) ->
-                failwith
-                  "Only locally nameless! We should never see a de Bruijn variable"
-            | (uu___7, FStar_Syntax_Syntax.Tm_bvar uu___8) ->
-                failwith
-                  "Only locally nameless! We should never see a de Bruijn variable"
-            | (FStar_Syntax_Syntax.Tm_type u1, FStar_Syntax_Syntax.Tm_type
-               u2) -> solve_one_universe_eq orig u1 u2 wl
-            | (FStar_Syntax_Syntax.Tm_arrow (bs1, c1),
-               FStar_Syntax_Syntax.Tm_arrow (bs2, c2)) ->
-                let mk_c c uu___7 =
-                  match uu___7 with
-                  | [] -> c
-                  | bs ->
-                      let uu___8 =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_arrow (bs, c))
-                          c.FStar_Syntax_Syntax.pos in
-                      FStar_Syntax_Syntax.mk_Total uu___8 in
-                let uu___7 =
-                  match_num_binders (bs1, (mk_c c1)) (bs2, (mk_c c2)) in
-                (match uu___7 with
-                 | ((bs11, c11), (bs21, c21)) ->
-                     solve_binders bs11 bs21 orig wl
-                       (fun wl1 ->
-                          fun scope ->
-                            fun subst ->
-                              let c12 =
-                                FStar_Syntax_Subst.subst_comp subst c11 in
-                              let c22 =
-                                FStar_Syntax_Subst.subst_comp subst c21 in
-                              let rel =
-                                let uu___8 =
-                                  FStar_Options.use_eq_at_higher_order () in
-                                if uu___8
-                                then FStar_TypeChecker_Common.EQ
-                                else
-                                  problem.FStar_TypeChecker_Common.relation in
-                              mk_c_problem wl1 scope orig c12 rel c22
-                                FStar_Pervasives_Native.None
-                                "function co-domain"))
-            | (FStar_Syntax_Syntax.Tm_abs (bs1, tbody1, lopt1),
-               FStar_Syntax_Syntax.Tm_abs (bs2, tbody2, lopt2)) ->
-                let mk_t t l uu___7 =
-                  match uu___7 with
-                  | [] -> t
-                  | bs ->
-                      FStar_Syntax_Syntax.mk
-                        (FStar_Syntax_Syntax.Tm_abs (bs, t, l))
-                        t.FStar_Syntax_Syntax.pos in
-                let uu___7 =
-                  match_num_binders (bs1, (mk_t tbody1 lopt1))
-                    (bs2, (mk_t tbody2 lopt2)) in
-                (match uu___7 with
-                 | ((bs11, tbody11), (bs21, tbody21)) ->
-                     solve_binders bs11 bs21 orig wl
-                       (fun wl1 ->
-                          fun scope ->
-                            fun subst ->
-                              let uu___8 =
-                                FStar_Syntax_Subst.subst subst tbody11 in
-                              let uu___9 =
-                                FStar_Syntax_Subst.subst subst tbody21 in
-                              mk_t_problem wl1 scope orig uu___8
-                                problem.FStar_TypeChecker_Common.relation
-                                uu___9 FStar_Pervasives_Native.None
-                                "lambda co-domain"))
-            | (FStar_Syntax_Syntax.Tm_refine (x1, phi1),
-               FStar_Syntax_Syntax.Tm_refine (x2, phi2)) ->
-                let env = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-                let uu___7 =
-                  let uu___8 =
-                    head_matches_delta env wl.smt_ok
-                      x1.FStar_Syntax_Syntax.sort x2.FStar_Syntax_Syntax.sort in
-                  match uu___8 with
-                  | (FullMatch, FStar_Pervasives_Native.Some (t11, t21)) ->
-                      ({
-                         FStar_Syntax_Syntax.ppname =
-                           (x1.FStar_Syntax_Syntax.ppname);
-                         FStar_Syntax_Syntax.index =
-                           (x1.FStar_Syntax_Syntax.index);
-                         FStar_Syntax_Syntax.sort = t11
-                       },
-                        {
-                          FStar_Syntax_Syntax.ppname =
-                            (x2.FStar_Syntax_Syntax.ppname);
-                          FStar_Syntax_Syntax.index =
-                            (x2.FStar_Syntax_Syntax.index);
-                          FStar_Syntax_Syntax.sort = t21
-                        })
-                  | (HeadMatch uu___9, FStar_Pervasives_Native.Some
-                     (t11, t21)) ->
-                      ({
-                         FStar_Syntax_Syntax.ppname =
-                           (x1.FStar_Syntax_Syntax.ppname);
-                         FStar_Syntax_Syntax.index =
-                           (x1.FStar_Syntax_Syntax.index);
-                         FStar_Syntax_Syntax.sort = t11
-                       },
-                        {
-                          FStar_Syntax_Syntax.ppname =
-                            (x2.FStar_Syntax_Syntax.ppname);
-                          FStar_Syntax_Syntax.index =
-                            (x2.FStar_Syntax_Syntax.index);
-                          FStar_Syntax_Syntax.sort = t21
-                        })
-                  | uu___9 -> (x1, x2) in
-                (match uu___7 with
-                 | (x11, x21) ->
-                     let t11 = FStar_Syntax_Util.refine x11 phi1 in
-                     let t21 = FStar_Syntax_Util.refine x21 phi2 in
-                     let uu___8 = as_refinement false env t11 in
-                     (match uu___8 with
-                      | (x12, phi11) ->
-                          let uu___9 = as_refinement false env t21 in
-                          (match uu___9 with
-                           | (x22, phi21) ->
-                               ((let uu___11 =
-                                   debug wl (FStar_Options.Other "Rel") in
-                                 if uu___11
-                                 then
-                                   ((let uu___13 =
-                                       FStar_Syntax_Print.bv_to_string x12 in
-                                     let uu___14 =
-                                       FStar_Syntax_Print.term_to_string
-                                         x12.FStar_Syntax_Syntax.sort in
-                                     let uu___15 =
-                                       FStar_Syntax_Print.term_to_string
-                                         phi11 in
-                                     FStar_Compiler_Util.print3
-                                       "ref1 = (%s):(%s){%s}\n" uu___13
-                                       uu___14 uu___15);
-                                    (let uu___13 =
-                                       FStar_Syntax_Print.bv_to_string x22 in
-                                     let uu___14 =
-                                       FStar_Syntax_Print.term_to_string
-                                         x22.FStar_Syntax_Syntax.sort in
-                                     let uu___15 =
-                                       FStar_Syntax_Print.term_to_string
-                                         phi21 in
-                                     FStar_Compiler_Util.print3
-                                       "ref2 = (%s):(%s){%s}\n" uu___13
-                                       uu___14 uu___15))
-                                 else ());
-                                (let uu___11 =
-                                   mk_t_problem wl [] orig
-                                     x12.FStar_Syntax_Syntax.sort
-                                     problem.FStar_TypeChecker_Common.relation
-                                     x22.FStar_Syntax_Syntax.sort
-                                     problem.FStar_TypeChecker_Common.element
-                                     "refinement base type" in
-                                 match uu___11 with
-                                 | (base_prob, wl1) ->
-                                     let x13 =
-                                       FStar_Syntax_Syntax.freshen_bv x12 in
-                                     let subst =
-                                       [FStar_Syntax_Syntax.DB
-                                          (Prims.int_zero, x13)] in
-                                     let phi12 =
-                                       FStar_Syntax_Subst.subst subst phi11 in
-                                     let phi22 =
-                                       FStar_Syntax_Subst.subst subst phi21 in
-                                     let mk_imp imp phi13 phi23 =
-                                       let uu___12 = imp phi13 phi23 in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___12
-                                         (guard_on_element wl1 problem x13) in
-                                     let fallback uu___12 =
-                                       let impl =
-                                         if
-                                           problem.FStar_TypeChecker_Common.relation
-                                             = FStar_TypeChecker_Common.EQ
-                                         then
-                                           mk_imp FStar_Syntax_Util.mk_iff
-                                             phi12 phi22
-                                         else
-                                           mk_imp FStar_Syntax_Util.mk_imp
-                                             phi12 phi22 in
-                                       let guard =
-                                         FStar_Syntax_Util.mk_conj
-                                           (p_guard base_prob) impl in
-                                       (let uu___14 =
-                                          let uu___15 = p_scope orig in
-                                          FStar_Compiler_List.map
-                                            (fun b ->
-                                               b.FStar_Syntax_Syntax.binder_bv)
-                                            uu___15 in
-                                        FStar_TypeChecker_Env.def_check_closed_in
-                                          (p_loc orig) "ref.1" uu___14
-                                          (p_guard base_prob));
-                                       (let uu___15 =
-                                          let uu___16 = p_scope orig in
-                                          FStar_Compiler_List.map
-                                            (fun b ->
-                                               b.FStar_Syntax_Syntax.binder_bv)
-                                            uu___16 in
-                                        FStar_TypeChecker_Env.def_check_closed_in
-                                          (p_loc orig) "ref.2" uu___15 impl);
-                                       (let wl2 =
-                                          solve_prob orig
-                                            (FStar_Pervasives_Native.Some
-                                               guard) [] wl1 in
-                                        let uu___15 = attempt [base_prob] wl2 in
-                                        solve uu___15) in
-                                     let has_uvars =
-                                       (let uu___12 =
-                                          let uu___13 =
-                                            FStar_Syntax_Free.uvars phi12 in
-                                          FStar_Compiler_Util.set_is_empty
-                                            uu___13 in
-                                        Prims.op_Negation uu___12) ||
-                                         (let uu___12 =
-                                            let uu___13 =
-                                              FStar_Syntax_Free.uvars phi22 in
-                                            FStar_Compiler_Util.set_is_empty
-                                              uu___13 in
-                                          Prims.op_Negation uu___12) in
-                                     if
-                                       (problem.FStar_TypeChecker_Common.relation
-                                          = FStar_TypeChecker_Common.EQ)
-                                         ||
-                                         ((Prims.op_Negation
-                                             env.FStar_TypeChecker_Env.uvar_subtyping)
-                                            && has_uvars)
-                                     then
-                                       let uu___12 =
-                                         let uu___13 =
-                                           let uu___14 =
-                                             FStar_Syntax_Syntax.mk_binder
-                                               x13 in
-                                           [uu___14] in
-                                         mk_t_problem wl1 uu___13 orig phi12
-                                           FStar_TypeChecker_Common.EQ phi22
-                                           FStar_Pervasives_Native.None
-                                           "refinement formula" in
-                                       (match uu___12 with
-                                        | (ref_prob, wl2) ->
-                                            let tx =
-                                              FStar_Syntax_Unionfind.new_transaction
-                                                () in
-                                            let uu___13 =
-                                              solve
-                                                {
-                                                  attempting = [ref_prob];
-                                                  wl_deferred = [];
-                                                  wl_deferred_to_tac =
-                                                    (wl2.wl_deferred_to_tac);
-                                                  ctr = (wl2.ctr);
-                                                  defer_ok = NoDefer;
-                                                  smt_ok = (wl2.smt_ok);
-                                                  umax_heuristic_ok =
-                                                    (wl2.umax_heuristic_ok);
-                                                  tcenv = (wl2.tcenv);
-                                                  wl_implicits = [];
-                                                  repr_subcomp_allowed =
-                                                    (wl2.repr_subcomp_allowed)
-                                                } in
-                                            (match uu___13 with
-                                             | Failed (prob, msg) ->
-                                                 (FStar_Syntax_Unionfind.rollback
-                                                    tx;
-                                                  if
-                                                    (((Prims.op_Negation
-                                                         env.FStar_TypeChecker_Env.uvar_subtyping)
-                                                        && has_uvars)
-                                                       ||
-                                                       (Prims.op_Negation
-                                                          wl2.smt_ok))
-                                                      &&
-                                                      (Prims.op_Negation
-                                                         env.FStar_TypeChecker_Env.unif_allow_ref_guards)
-                                                  then giveup wl2 msg prob
-                                                  else fallback ())
-                                             | Success
-                                                 (uu___14, defer_to_tac,
-                                                  imps)
-                                                 ->
-                                                 (FStar_Syntax_Unionfind.commit
-                                                    tx;
-                                                  (let guard =
-                                                     let uu___16 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         (p_guard ref_prob)
-                                                         (guard_on_element
-                                                            wl2 problem x13) in
-                                                     FStar_Syntax_Util.mk_conj
-                                                       (p_guard base_prob)
-                                                       uu___16 in
-                                                   let wl3 =
-                                                     solve_prob orig
-                                                       (FStar_Pervasives_Native.Some
-                                                          guard) [] wl2 in
-                                                   let wl4 =
-                                                     {
-                                                       attempting =
-                                                         (wl3.attempting);
-                                                       wl_deferred =
-                                                         (wl3.wl_deferred);
-                                                       wl_deferred_to_tac =
-                                                         (wl3.wl_deferred_to_tac);
-                                                       ctr =
-                                                         (wl3.ctr +
-                                                            Prims.int_one);
-                                                       defer_ok =
-                                                         (wl3.defer_ok);
-                                                       smt_ok = (wl3.smt_ok);
-                                                       umax_heuristic_ok =
-                                                         (wl3.umax_heuristic_ok);
-                                                       tcenv = (wl3.tcenv);
-                                                       wl_implicits =
-                                                         (wl3.wl_implicits);
-                                                       repr_subcomp_allowed =
-                                                         (wl3.repr_subcomp_allowed)
-                                                     } in
-                                                   let wl5 =
-                                                     extend_wl wl4 []
-                                                       defer_to_tac imps in
-                                                   let uu___16 =
-                                                     attempt [base_prob] wl5 in
-                                                   solve uu___16))))
-                                     else fallback ())))))
-            | (FStar_Syntax_Syntax.Tm_uvar uu___7,
-               FStar_Syntax_Syntax.Tm_uvar uu___8) ->
-                let env = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-                let uu___9 = ensure_no_uvar_subst env t1 wl in
-                (match uu___9 with
-                 | (t11, wl1) ->
-                     let t21 = FStar_Syntax_Util.canon_app t2 in
-                     let uu___10 = ensure_no_uvar_subst env t21 wl1 in
-                     (match uu___10 with
-                      | (t22, wl2) ->
-                          let f1 = destruct_flex_t' t11 in
-                          let f2 = destruct_flex_t' t22 in
-                          solve_t_flex_flex env orig wl2 f1 f2))
-            | (FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___7;
-                  FStar_Syntax_Syntax.pos = uu___8;
-                  FStar_Syntax_Syntax.vars = uu___9;
-                  FStar_Syntax_Syntax.hash_code = uu___10;_},
-                uu___11),
-               FStar_Syntax_Syntax.Tm_uvar uu___12) ->
-                let env = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-                let uu___13 = ensure_no_uvar_subst env t1 wl in
-                (match uu___13 with
-                 | (t11, wl1) ->
-                     let t21 = FStar_Syntax_Util.canon_app t2 in
-                     let uu___14 = ensure_no_uvar_subst env t21 wl1 in
-                     (match uu___14 with
-                      | (t22, wl2) ->
-                          let f1 = destruct_flex_t' t11 in
-                          let f2 = destruct_flex_t' t22 in
-                          solve_t_flex_flex env orig wl2 f1 f2))
-            | (FStar_Syntax_Syntax.Tm_uvar uu___7, FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___8;
-                  FStar_Syntax_Syntax.pos = uu___9;
-                  FStar_Syntax_Syntax.vars = uu___10;
-                  FStar_Syntax_Syntax.hash_code = uu___11;_},
-                uu___12)) ->
-                let env = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-                let uu___13 = ensure_no_uvar_subst env t1 wl in
-                (match uu___13 with
-                 | (t11, wl1) ->
-                     let t21 = FStar_Syntax_Util.canon_app t2 in
-                     let uu___14 = ensure_no_uvar_subst env t21 wl1 in
-                     (match uu___14 with
-                      | (t22, wl2) ->
-                          let f1 = destruct_flex_t' t11 in
-                          let f2 = destruct_flex_t' t22 in
-                          solve_t_flex_flex env orig wl2 f1 f2))
-            | (FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___7;
-                  FStar_Syntax_Syntax.pos = uu___8;
-                  FStar_Syntax_Syntax.vars = uu___9;
-                  FStar_Syntax_Syntax.hash_code = uu___10;_},
-                uu___11),
-               FStar_Syntax_Syntax.Tm_app
-               ({
-                  FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___12;
-                  FStar_Syntax_Syntax.pos = uu___13;
-                  FStar_Syntax_Syntax.vars = uu___14;
-                  FStar_Syntax_Syntax.hash_code = uu___15;_},
-                uu___16)) ->
-                let env = p_env wl (FStar_TypeChecker_Common.TProb problem) in
-                let uu___17 = ensure_no_uvar_subst env t1 wl in
-                (match uu___17 with
-                 | (t11, wl1) ->
-                     let t21 = FStar_Syntax_Util.canon_app t2 in
-                     let uu___18 = ensure_no_uvar_subst env t21 wl1 in
-                     (match uu___18 with
-                      | (t22, wl2) ->
-                          let f1 = destruct_flex_t' t11 in
-                          let f2 = destruct_flex_t' t22 in
-                          solve_t_flex_flex env orig wl2 f1 f2))
-            | (FStar_Syntax_Syntax.Tm_uvar uu___7, uu___8) when
-                problem.FStar_TypeChecker_Common.relation =
-                  FStar_TypeChecker_Common.EQ
-                ->
-                let uu___9 = destruct_flex_t t1 wl in
-                (match uu___9 with
-                 | (f1, wl1) -> solve_t_flex_rigid_eq orig wl1 f1 t2)
-            | (FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___7;
-                  FStar_Syntax_Syntax.pos = uu___8;
-                  FStar_Syntax_Syntax.vars = uu___9;
-                  FStar_Syntax_Syntax.hash_code = uu___10;_},
-                uu___11),
-               uu___12) when
-                problem.FStar_TypeChecker_Common.relation =
-                  FStar_TypeChecker_Common.EQ
-                ->
-                let uu___13 = destruct_flex_t t1 wl in
-                (match uu___13 with
-                 | (f1, wl1) -> solve_t_flex_rigid_eq orig wl1 f1 t2)
-            | (uu___7, FStar_Syntax_Syntax.Tm_uvar uu___8) when
-                problem.FStar_TypeChecker_Common.relation =
-                  FStar_TypeChecker_Common.EQ
-                -> solve_t' (invert problem) wl
-            | (uu___7, FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___8;
-                  FStar_Syntax_Syntax.pos = uu___9;
-                  FStar_Syntax_Syntax.vars = uu___10;
-                  FStar_Syntax_Syntax.hash_code = uu___11;_},
-                uu___12)) when
-                problem.FStar_TypeChecker_Common.relation =
-                  FStar_TypeChecker_Common.EQ
-                -> solve_t' (invert problem) wl
-            | (FStar_Syntax_Syntax.Tm_uvar uu___7,
-               FStar_Syntax_Syntax.Tm_arrow uu___8) ->
-                solve_t'
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs =
-                      (problem.FStar_TypeChecker_Common.lhs);
-                    FStar_TypeChecker_Common.relation =
-                      FStar_TypeChecker_Common.EQ;
-                    FStar_TypeChecker_Common.rhs =
-                      (problem.FStar_TypeChecker_Common.rhs);
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } wl
-            | (FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___7;
-                  FStar_Syntax_Syntax.pos = uu___8;
-                  FStar_Syntax_Syntax.vars = uu___9;
-                  FStar_Syntax_Syntax.hash_code = uu___10;_},
-                uu___11),
-               FStar_Syntax_Syntax.Tm_arrow uu___12) ->
-                solve_t'
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs =
-                      (problem.FStar_TypeChecker_Common.lhs);
-                    FStar_TypeChecker_Common.relation =
-                      FStar_TypeChecker_Common.EQ;
-                    FStar_TypeChecker_Common.rhs =
-                      (problem.FStar_TypeChecker_Common.rhs);
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } wl
-            | (uu___7, FStar_Syntax_Syntax.Tm_uvar uu___8) ->
-                let uu___9 =
-                  attempt [FStar_TypeChecker_Common.TProb problem] wl in
-                solve uu___9
-            | (uu___7, FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___8;
-                  FStar_Syntax_Syntax.pos = uu___9;
-                  FStar_Syntax_Syntax.vars = uu___10;
-                  FStar_Syntax_Syntax.hash_code = uu___11;_},
-                uu___12)) ->
-                let uu___13 =
-                  attempt [FStar_TypeChecker_Common.TProb problem] wl in
-                solve uu___13
-            | (FStar_Syntax_Syntax.Tm_uvar uu___7, uu___8) ->
-                let uu___9 =
-                  attempt [FStar_TypeChecker_Common.TProb problem] wl in
-                solve uu___9
-            | (FStar_Syntax_Syntax.Tm_app
-               ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar uu___7;
-                  FStar_Syntax_Syntax.pos = uu___8;
-                  FStar_Syntax_Syntax.vars = uu___9;
-                  FStar_Syntax_Syntax.hash_code = uu___10;_},
-                uu___11),
-               uu___12) ->
-                let uu___13 =
-                  attempt [FStar_TypeChecker_Common.TProb problem] wl in
-                solve uu___13
-            | (FStar_Syntax_Syntax.Tm_abs uu___7, uu___8) ->
-                let is_abs t =
-                  match t.FStar_Syntax_Syntax.n with
-                  | FStar_Syntax_Syntax.Tm_abs uu___9 ->
-                      FStar_Pervasives.Inl t
-                  | uu___9 -> FStar_Pervasives.Inr t in
-                let env = p_env wl orig in
-                (match ((is_abs t1), (is_abs t2)) with
-                 | (FStar_Pervasives.Inl t_abs, FStar_Pervasives.Inr not_abs)
-                     ->
-                     let uu___9 =
-                       (is_flex not_abs) &&
-                         ((p_rel orig) = FStar_TypeChecker_Common.EQ) in
-                     if uu___9
-                     then
-                       let uu___10 = destruct_flex_t not_abs wl in
-                       (match uu___10 with
-                        | (flex, wl1) ->
-                            solve_t_flex_rigid_eq orig wl1 flex t_abs)
-                     else
-                       (let uu___11 =
-                          head_matches_delta env wl.smt_ok not_abs t_abs in
-                        match uu___11 with
-                        | (HeadMatch uu___12, FStar_Pervasives_Native.Some
-                           (not_abs', uu___13)) ->
-                            solve_t
-                              {
-                                FStar_TypeChecker_Common.pid =
-                                  (problem.FStar_TypeChecker_Common.pid);
-                                FStar_TypeChecker_Common.lhs = not_abs';
-                                FStar_TypeChecker_Common.relation =
-                                  (problem.FStar_TypeChecker_Common.relation);
-                                FStar_TypeChecker_Common.rhs = t_abs;
-                                FStar_TypeChecker_Common.element =
-                                  (problem.FStar_TypeChecker_Common.element);
-                                FStar_TypeChecker_Common.logical_guard =
-                                  (problem.FStar_TypeChecker_Common.logical_guard);
-                                FStar_TypeChecker_Common.logical_guard_uvar =
-                                  (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                                FStar_TypeChecker_Common.reason =
-                                  (problem.FStar_TypeChecker_Common.reason);
-                                FStar_TypeChecker_Common.loc =
-                                  (problem.FStar_TypeChecker_Common.loc);
-                                FStar_TypeChecker_Common.rank =
-                                  (problem.FStar_TypeChecker_Common.rank)
-                              } wl
-                        | uu___12 ->
-                            let uu___13 =
-                              FStar_Syntax_Util.head_and_args not_abs in
-                            (match uu___13 with
-                             | (head, uu___14) ->
-                                 let uu___15 =
-                                   wl.smt_ok &&
-                                     (may_relate wl.tcenv (p_rel orig) head) in
-                                 if uu___15
-                                 then
-                                   let uu___16 = mk_eq2 wl orig t_abs not_abs in
-                                   (match uu___16 with
-                                    | (g, wl1) ->
-                                        let uu___17 =
-                                          solve_prob orig
-                                            (FStar_Pervasives_Native.Some g)
-                                            [] wl1 in
-                                        solve uu___17)
-                                 else
-                                   (let uu___17 =
-                                      FStar_Thunk.mkv
-                                        "head tag mismatch: RHS is an abstraction" in
-                                    giveup wl uu___17 orig)))
-                 | (FStar_Pervasives.Inr not_abs, FStar_Pervasives.Inl t_abs)
-                     ->
-                     let uu___9 =
-                       (is_flex not_abs) &&
-                         ((p_rel orig) = FStar_TypeChecker_Common.EQ) in
-                     if uu___9
-                     then
-                       let uu___10 = destruct_flex_t not_abs wl in
-                       (match uu___10 with
-                        | (flex, wl1) ->
-                            solve_t_flex_rigid_eq orig wl1 flex t_abs)
-                     else
-                       (let uu___11 =
-                          head_matches_delta env wl.smt_ok not_abs t_abs in
-                        match uu___11 with
-                        | (HeadMatch uu___12, FStar_Pervasives_Native.Some
-                           (not_abs', uu___13)) ->
-                            solve_t
-                              {
-                                FStar_TypeChecker_Common.pid =
-                                  (problem.FStar_TypeChecker_Common.pid);
-                                FStar_TypeChecker_Common.lhs = not_abs';
-                                FStar_TypeChecker_Common.relation =
-                                  (problem.FStar_TypeChecker_Common.relation);
-                                FStar_TypeChecker_Common.rhs = t_abs;
-                                FStar_TypeChecker_Common.element =
-                                  (problem.FStar_TypeChecker_Common.element);
-                                FStar_TypeChecker_Common.logical_guard =
-                                  (problem.FStar_TypeChecker_Common.logical_guard);
-                                FStar_TypeChecker_Common.logical_guard_uvar =
-                                  (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                                FStar_TypeChecker_Common.reason =
-                                  (problem.FStar_TypeChecker_Common.reason);
-                                FStar_TypeChecker_Common.loc =
-                                  (problem.FStar_TypeChecker_Common.loc);
-                                FStar_TypeChecker_Common.rank =
-                                  (problem.FStar_TypeChecker_Common.rank)
-                              } wl
-                        | uu___12 ->
-                            let uu___13 =
-                              FStar_Syntax_Util.head_and_args not_abs in
-                            (match uu___13 with
-                             | (head, uu___14) ->
-                                 let uu___15 =
-                                   wl.smt_ok &&
-                                     (may_relate wl.tcenv (p_rel orig) head) in
-                                 if uu___15
-                                 then
-                                   let uu___16 = mk_eq2 wl orig t_abs not_abs in
-                                   (match uu___16 with
-                                    | (g, wl1) ->
-                                        let uu___17 =
-                                          solve_prob orig
-                                            (FStar_Pervasives_Native.Some g)
-                                            [] wl1 in
-                                        solve uu___17)
-                                 else
-                                   (let uu___17 =
-                                      FStar_Thunk.mkv
-                                        "head tag mismatch: RHS is an abstraction" in
-                                    giveup wl uu___17 orig)))
-                 | uu___9 ->
-                     failwith
-                       "Impossible: at least one side is an abstraction")
-            | (uu___7, FStar_Syntax_Syntax.Tm_abs uu___8) ->
-                let is_abs t =
-                  match t.FStar_Syntax_Syntax.n with
-                  | FStar_Syntax_Syntax.Tm_abs uu___9 ->
-                      FStar_Pervasives.Inl t
-                  | uu___9 -> FStar_Pervasives.Inr t in
-                let env = p_env wl orig in
-                (match ((is_abs t1), (is_abs t2)) with
-                 | (FStar_Pervasives.Inl t_abs, FStar_Pervasives.Inr not_abs)
-                     ->
-                     let uu___9 =
-                       (is_flex not_abs) &&
-                         ((p_rel orig) = FStar_TypeChecker_Common.EQ) in
-                     if uu___9
-                     then
-                       let uu___10 = destruct_flex_t not_abs wl in
-                       (match uu___10 with
-                        | (flex, wl1) ->
-                            solve_t_flex_rigid_eq orig wl1 flex t_abs)
-                     else
-                       (let uu___11 =
-                          head_matches_delta env wl.smt_ok not_abs t_abs in
-                        match uu___11 with
-                        | (HeadMatch uu___12, FStar_Pervasives_Native.Some
-                           (not_abs', uu___13)) ->
-                            solve_t
-                              {
-                                FStar_TypeChecker_Common.pid =
-                                  (problem.FStar_TypeChecker_Common.pid);
-                                FStar_TypeChecker_Common.lhs = not_abs';
-                                FStar_TypeChecker_Common.relation =
-                                  (problem.FStar_TypeChecker_Common.relation);
-                                FStar_TypeChecker_Common.rhs = t_abs;
-                                FStar_TypeChecker_Common.element =
-                                  (problem.FStar_TypeChecker_Common.element);
-                                FStar_TypeChecker_Common.logical_guard =
-                                  (problem.FStar_TypeChecker_Common.logical_guard);
-                                FStar_TypeChecker_Common.logical_guard_uvar =
-                                  (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                                FStar_TypeChecker_Common.reason =
-                                  (problem.FStar_TypeChecker_Common.reason);
-                                FStar_TypeChecker_Common.loc =
-                                  (problem.FStar_TypeChecker_Common.loc);
-                                FStar_TypeChecker_Common.rank =
-                                  (problem.FStar_TypeChecker_Common.rank)
-                              } wl
-                        | uu___12 ->
-                            let uu___13 =
-                              FStar_Syntax_Util.head_and_args not_abs in
-                            (match uu___13 with
-                             | (head, uu___14) ->
-                                 let uu___15 =
-                                   wl.smt_ok &&
-                                     (may_relate wl.tcenv (p_rel orig) head) in
-                                 if uu___15
-                                 then
-                                   let uu___16 = mk_eq2 wl orig t_abs not_abs in
-                                   (match uu___16 with
-                                    | (g, wl1) ->
-                                        let uu___17 =
-                                          solve_prob orig
-                                            (FStar_Pervasives_Native.Some g)
-                                            [] wl1 in
-                                        solve uu___17)
-                                 else
-                                   (let uu___17 =
-                                      FStar_Thunk.mkv
-                                        "head tag mismatch: RHS is an abstraction" in
-                                    giveup wl uu___17 orig)))
-                 | (FStar_Pervasives.Inr not_abs, FStar_Pervasives.Inl t_abs)
-                     ->
-                     let uu___9 =
-                       (is_flex not_abs) &&
-                         ((p_rel orig) = FStar_TypeChecker_Common.EQ) in
-                     if uu___9
-                     then
-                       let uu___10 = destruct_flex_t not_abs wl in
-                       (match uu___10 with
-                        | (flex, wl1) ->
-                            solve_t_flex_rigid_eq orig wl1 flex t_abs)
-                     else
-                       (let uu___11 =
-                          head_matches_delta env wl.smt_ok not_abs t_abs in
-                        match uu___11 with
-                        | (HeadMatch uu___12, FStar_Pervasives_Native.Some
-                           (not_abs', uu___13)) ->
-                            solve_t
-                              {
-                                FStar_TypeChecker_Common.pid =
-                                  (problem.FStar_TypeChecker_Common.pid);
-                                FStar_TypeChecker_Common.lhs = not_abs';
-                                FStar_TypeChecker_Common.relation =
-                                  (problem.FStar_TypeChecker_Common.relation);
-                                FStar_TypeChecker_Common.rhs = t_abs;
-                                FStar_TypeChecker_Common.element =
-                                  (problem.FStar_TypeChecker_Common.element);
-                                FStar_TypeChecker_Common.logical_guard =
-                                  (problem.FStar_TypeChecker_Common.logical_guard);
-                                FStar_TypeChecker_Common.logical_guard_uvar =
-                                  (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                                FStar_TypeChecker_Common.reason =
-                                  (problem.FStar_TypeChecker_Common.reason);
-                                FStar_TypeChecker_Common.loc =
-                                  (problem.FStar_TypeChecker_Common.loc);
-                                FStar_TypeChecker_Common.rank =
-                                  (problem.FStar_TypeChecker_Common.rank)
-                              } wl
-                        | uu___12 ->
-                            let uu___13 =
-                              FStar_Syntax_Util.head_and_args not_abs in
-                            (match uu___13 with
-                             | (head, uu___14) ->
-                                 let uu___15 =
-                                   wl.smt_ok &&
-                                     (may_relate wl.tcenv (p_rel orig) head) in
-                                 if uu___15
-                                 then
-                                   let uu___16 = mk_eq2 wl orig t_abs not_abs in
-                                   (match uu___16 with
-                                    | (g, wl1) ->
-                                        let uu___17 =
-                                          solve_prob orig
-                                            (FStar_Pervasives_Native.Some g)
-                                            [] wl1 in
-                                        solve uu___17)
-                                 else
-                                   (let uu___17 =
-                                      FStar_Thunk.mkv
-                                        "head tag mismatch: RHS is an abstraction" in
-                                    giveup wl uu___17 orig)))
-                 | uu___9 ->
-                     failwith
-                       "Impossible: at least one side is an abstraction")
-            | (FStar_Syntax_Syntax.Tm_refine uu___7, uu___8) ->
-                let t21 =
-                  let uu___9 = base_and_refinement (p_env wl orig) t2 in
-                  FStar_Compiler_Effect.op_Less_Bar force_refinement uu___9 in
-                solve_t'
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs =
-                      (problem.FStar_TypeChecker_Common.lhs);
-                    FStar_TypeChecker_Common.relation =
-                      (problem.FStar_TypeChecker_Common.relation);
-                    FStar_TypeChecker_Common.rhs = t21;
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } wl
-            | (uu___7, FStar_Syntax_Syntax.Tm_refine uu___8) ->
-                let t11 =
-                  let uu___9 = base_and_refinement (p_env wl orig) t1 in
-                  FStar_Compiler_Effect.op_Less_Bar force_refinement uu___9 in
-                solve_t'
-                  {
-                    FStar_TypeChecker_Common.pid =
-                      (problem.FStar_TypeChecker_Common.pid);
-                    FStar_TypeChecker_Common.lhs = t11;
-                    FStar_TypeChecker_Common.relation =
-                      (problem.FStar_TypeChecker_Common.relation);
-                    FStar_TypeChecker_Common.rhs =
-                      (problem.FStar_TypeChecker_Common.rhs);
-                    FStar_TypeChecker_Common.element =
-                      (problem.FStar_TypeChecker_Common.element);
-                    FStar_TypeChecker_Common.logical_guard =
-                      (problem.FStar_TypeChecker_Common.logical_guard);
-                    FStar_TypeChecker_Common.logical_guard_uvar =
-                      (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                    FStar_TypeChecker_Common.reason =
-                      (problem.FStar_TypeChecker_Common.reason);
-                    FStar_TypeChecker_Common.loc =
-                      (problem.FStar_TypeChecker_Common.loc);
-                    FStar_TypeChecker_Common.rank =
-                      (problem.FStar_TypeChecker_Common.rank)
-                  } wl
-            | (FStar_Syntax_Syntax.Tm_match (s1, uu___7, brs1, uu___8),
-               FStar_Syntax_Syntax.Tm_match (s2, uu___9, brs2, uu___10)) ->
-                let by_smt uu___11 =
-                  let uu___12 = guard_of_prob wl problem t1 t2 in
-                  match uu___12 with
-                  | (guard, wl1) ->
-                      let uu___13 =
-                        solve_prob orig (FStar_Pervasives_Native.Some guard)
-                          [] wl1 in
-                      solve uu___13 in
-                let rec solve_branches wl1 brs11 brs21 =
-                  match (brs11, brs21) with
-                  | (br1::rs1, br2::rs2) ->
-                      let uu___11 = br1 in
-                      (match uu___11 with
-                       | (p1, w1, uu___12) ->
-                           let uu___13 = br2 in
-                           (match uu___13 with
-                            | (p2, w2, uu___14) ->
-                                let uu___15 =
-                                  let uu___16 =
-                                    FStar_Syntax_Syntax.eq_pat p1 p2 in
-                                  Prims.op_Negation uu___16 in
-                                if uu___15
-                                then FStar_Pervasives_Native.None
-                                else
-                                  (let uu___17 =
-                                     FStar_Syntax_Subst.open_branch' br1 in
-                                   match uu___17 with
-                                   | ((p11, w11, e1), s) ->
-                                       let uu___18 = br2 in
-                                       (match uu___18 with
-                                        | (p21, w21, e2) ->
-                                            let w22 =
-                                              FStar_Compiler_Util.map_opt w21
-                                                (FStar_Syntax_Subst.subst s) in
-                                            let e21 =
-                                              FStar_Syntax_Subst.subst s e2 in
-                                            let scope =
-                                              let uu___19 =
-                                                FStar_Syntax_Syntax.pat_bvs
-                                                  p11 in
-                                              FStar_Compiler_Effect.op_Less_Bar
-                                                (FStar_Compiler_List.map
-                                                   FStar_Syntax_Syntax.mk_binder)
-                                                uu___19 in
-                                            let uu___19 =
-                                              match (w11, w22) with
-                                              | (FStar_Pervasives_Native.Some
-                                                 uu___20,
-                                                 FStar_Pervasives_Native.None)
-                                                  ->
-                                                  FStar_Pervasives_Native.None
-                                              | (FStar_Pervasives_Native.None,
-                                                 FStar_Pervasives_Native.Some
-                                                 uu___20) ->
-                                                  FStar_Pervasives_Native.None
-                                              | (FStar_Pervasives_Native.None,
-                                                 FStar_Pervasives_Native.None)
-                                                  ->
-                                                  FStar_Pervasives_Native.Some
-                                                    ([], wl1)
-                                              | (FStar_Pervasives_Native.Some
-                                                 w12,
-                                                 FStar_Pervasives_Native.Some
-                                                 w23) ->
-                                                  let uu___20 =
-                                                    mk_t_problem wl1 scope
-                                                      orig w12
-                                                      FStar_TypeChecker_Common.EQ
-                                                      w23
-                                                      FStar_Pervasives_Native.None
-                                                      "when clause" in
-                                                  (match uu___20 with
-                                                   | (p, wl2) ->
-                                                       FStar_Pervasives_Native.Some
-                                                         ([(scope, p)], wl2)) in
-                                            FStar_Compiler_Util.bind_opt
-                                              uu___19
-                                              (fun uu___20 ->
-                                                 match uu___20 with
-                                                 | (wprobs, wl2) ->
-                                                     let uu___21 =
-                                                       mk_t_problem wl2 scope
-                                                         orig e1
-                                                         FStar_TypeChecker_Common.EQ
-                                                         e21
-                                                         FStar_Pervasives_Native.None
-                                                         "branch body" in
-                                                     (match uu___21 with
-                                                      | (prob, wl3) ->
-                                                          ((let uu___23 =
-                                                              FStar_Compiler_Effect.op_Less_Bar
-                                                                (debug wl3)
-                                                                (FStar_Options.Other
-                                                                   "Rel") in
-                                                            if uu___23
-                                                            then
-                                                              let uu___24 =
-                                                                prob_to_string'
-                                                                  wl3 prob in
-                                                              let uu___25 =
-                                                                FStar_Syntax_Print.binders_to_string
-                                                                  ", " scope in
-                                                              FStar_Compiler_Util.print2
-                                                                "Created problem for branches %s with scope %s\n"
-                                                                uu___24
-                                                                uu___25
-                                                            else ());
-                                                           (let uu___23 =
-                                                              solve_branches
-                                                                wl3 rs1 rs2 in
-                                                            FStar_Compiler_Util.bind_opt
-                                                              uu___23
-                                                              (fun uu___24 ->
-                                                                 match uu___24
-                                                                 with
-                                                                 | (r, wl4)
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (((scope,
-                                                                    prob) ::
-                                                                    (FStar_Compiler_List.op_At
-                                                                    wprobs r)),
-                                                                    wl4))))))))))
-                  | ([], []) -> FStar_Pervasives_Native.Some ([], wl1)
-                  | uu___11 -> FStar_Pervasives_Native.None in
-                let uu___11 = solve_branches wl brs1 brs2 in
-                (match uu___11 with
-                 | FStar_Pervasives_Native.None ->
-                     if wl.smt_ok
-                     then by_smt ()
-                     else
-                       (let uu___13 =
-                          FStar_Thunk.mkv "Tm_match branches don't match" in
-                        giveup wl uu___13 orig)
-                 | FStar_Pervasives_Native.Some (sub_probs, wl1) ->
-                     let uu___12 =
-                       mk_t_problem wl1 [] orig s1
-                         FStar_TypeChecker_Common.EQ s2
-                         FStar_Pervasives_Native.None "match scrutinee" in
-                     (match uu___12 with
-                      | (sc_prob, wl2) ->
-                          let sub_probs1 = ([], sc_prob) :: sub_probs in
-                          let formula =
-                            let uu___13 =
-                              FStar_Compiler_List.map
-                                (fun uu___14 ->
-                                   match uu___14 with
-                                   | (scope, p) ->
-                                       FStar_TypeChecker_Env.close_forall
-                                         wl2.tcenv scope (p_guard p))
-                                sub_probs1 in
-                            FStar_Syntax_Util.mk_conj_l uu___13 in
-                          let tx = FStar_Syntax_Unionfind.new_transaction () in
-                          let wl3 =
-                            solve_prob orig
-                              (FStar_Pervasives_Native.Some formula) [] wl2 in
-                          let uu___13 =
-                            let uu___14 =
-                              let uu___15 =
-                                FStar_Compiler_List.map
-                                  FStar_Pervasives_Native.snd sub_probs1 in
-                              attempt uu___15
-                                {
-                                  attempting = (wl3.attempting);
-                                  wl_deferred = (wl3.wl_deferred);
-                                  wl_deferred_to_tac =
-                                    (wl3.wl_deferred_to_tac);
-                                  ctr = (wl3.ctr);
-                                  defer_ok = (wl3.defer_ok);
-                                  smt_ok = false;
-                                  umax_heuristic_ok = (wl3.umax_heuristic_ok);
-                                  tcenv = (wl3.tcenv);
-                                  wl_implicits = (wl3.wl_implicits);
-                                  repr_subcomp_allowed =
-                                    (wl3.repr_subcomp_allowed)
-                                } in
-                            solve uu___14 in
-                          (match uu___13 with
-                           | Success (ds, ds', imp) ->
-                               (FStar_Syntax_Unionfind.commit tx;
-                                Success (ds, ds', imp))
-                           | Failed uu___14 ->
-                               (FStar_Syntax_Unionfind.rollback tx;
-                                if wl3.smt_ok
-                                then by_smt ()
-                                else
-                                  (let uu___17 =
-                                     FStar_Thunk.mkv
-                                       "Could not unify matches without SMT" in
-                                   giveup wl3 uu___17 orig)))))
-            | (FStar_Syntax_Syntax.Tm_match uu___7, uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (FStar_Syntax_Syntax.Tm_uinst uu___7, uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (FStar_Syntax_Syntax.Tm_name uu___7, uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (FStar_Syntax_Syntax.Tm_constant uu___7, uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (FStar_Syntax_Syntax.Tm_fvar uu___7, uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (FStar_Syntax_Syntax.Tm_app uu___7, uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (uu___7, FStar_Syntax_Syntax.Tm_match uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (uu___7, FStar_Syntax_Syntax.Tm_uinst uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (uu___7, FStar_Syntax_Syntax.Tm_name uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (uu___7, FStar_Syntax_Syntax.Tm_constant uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (uu___7, FStar_Syntax_Syntax.Tm_fvar uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (uu___7, FStar_Syntax_Syntax.Tm_app uu___8) ->
-                let head1 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t1 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                let head2 =
-                  let uu___9 = FStar_Syntax_Util.head_and_args t2 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___9
-                    FStar_Pervasives_Native.fst in
-                ((let uu___10 = debug wl (FStar_Options.Other "Rel") in
-                  if uu___10
-                  then
-                    let uu___11 =
-                      let uu___12 =
-                        FStar_Compiler_Util.string_of_int
-                          problem.FStar_TypeChecker_Common.pid in
-                      let uu___13 =
-                        let uu___14 =
-                          FStar_Compiler_Util.string_of_bool wl.smt_ok in
-                        let uu___15 =
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string head1 in
-                          let uu___17 =
-                            let uu___18 =
-                              let uu___19 =
-                                FStar_TypeChecker_Env.is_interpreted 
-                                  wl.tcenv head1 in
-                              FStar_Compiler_Util.string_of_bool uu___19 in
-                            let uu___19 =
-                              let uu___20 =
-                                let uu___21 = no_free_uvars t1 in
-                                FStar_Compiler_Util.string_of_bool uu___21 in
-                              let uu___21 =
-                                let uu___22 =
-                                  FStar_Syntax_Print.term_to_string head2 in
-                                let uu___23 =
-                                  let uu___24 =
-                                    let uu___25 =
-                                      FStar_TypeChecker_Env.is_interpreted
-                                        wl.tcenv head2 in
-                                    FStar_Compiler_Util.string_of_bool
-                                      uu___25 in
-                                  let uu___25 =
-                                    let uu___26 =
-                                      let uu___27 = no_free_uvars t2 in
-                                      FStar_Compiler_Util.string_of_bool
-                                        uu___27 in
-                                    [uu___26] in
-                                  uu___24 :: uu___25 in
-                                uu___22 :: uu___23 in
-                              uu___20 :: uu___21 in
-                            uu___18 :: uu___19 in
-                          uu___16 :: uu___17 in
-                        uu___14 :: uu___15 in
-                      uu___12 :: uu___13 in
-                    FStar_Compiler_Util.print
-                      ">> (%s) (smtok=%s)\n>>> head1 = %s [interpreted=%s; no_free_uvars=%s]\n>>> head2 = %s [interpreted=%s;no_free_uvars=%s]\n"
-                      uu___11
-                  else ());
-                 (let equal t11 t21 =
-                    (let uu___10 = FStar_Syntax_Util.eq_tm t11 t21 in
-                     uu___10 = FStar_Syntax_Util.Equal) ||
-                      (let steps =
-                         [FStar_TypeChecker_Env.UnfoldUntil
-                            FStar_Syntax_Syntax.delta_constant;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.Beta;
-                         FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Iota] in
-                       let env = p_env wl orig in
-                       let t12 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.2" steps
-                           env t11 in
-                       let t22 =
-                         norm_with_steps
-                           "FStar.TypeChecker.Rel.norm_with_steps.3" steps
-                           env t21 in
-                       let uu___10 = FStar_Syntax_Util.eq_tm t12 t22 in
-                       uu___10 = FStar_Syntax_Util.Equal) in
-                  let uu___10 =
-                    ((FStar_TypeChecker_Env.is_interpreted wl.tcenv head1) ||
-                       (FStar_TypeChecker_Env.is_interpreted wl.tcenv head2))
-                      &&
-                      (problem.FStar_TypeChecker_Common.relation =
-                         FStar_TypeChecker_Common.EQ) in
-                  if uu___10
-                  then
-                    let solve_with_smt uu___11 =
-                      let uu___12 =
-                        let uu___13 = equal t1 t2 in
-                        if uu___13
-                        then (FStar_Pervasives_Native.None, wl)
-                        else
-                          (let uu___15 = mk_eq2 wl orig t1 t2 in
-                           match uu___15 with
-                           | (g, wl1) ->
-                               ((FStar_Pervasives_Native.Some g), wl1)) in
-                      match uu___12 with
-                      | (guard, wl1) ->
-                          let uu___13 = solve_prob orig guard [] wl1 in
-                          solve uu___13 in
-                    let uu___11 = (no_free_uvars t1) && (no_free_uvars t2) in
-                    (if uu___11
-                     then
-                       let uu___12 =
-                         (Prims.op_Negation wl.smt_ok) ||
-                           (FStar_Options.ml_ish ()) in
-                       (if uu___12
-                        then
-                          let uu___13 = equal t1 t2 in
-                          (if uu___13
-                           then
-                             let uu___14 =
-                               solve_prob orig FStar_Pervasives_Native.None
-                                 [] wl in
-                             solve uu___14
-                           else
-                             rigid_rigid_delta problem wl head1 head2 t1 t2)
-                        else solve_with_smt ())
-                     else
-                       (let uu___13 =
-                          (Prims.op_Negation wl.smt_ok) ||
-                            (FStar_Options.ml_ish ()) in
-                        if uu___13
-                        then rigid_rigid_delta problem wl head1 head2 t1 t2
-                        else
-                          try_solve_then_or_else wl
-                            (fun wl_empty ->
-                               rigid_rigid_delta problem wl_empty head1 head2
-                                 t1 t2) (fun wl1 -> solve wl1)
-                            (fun uu___15 -> solve_with_smt ())))
-                  else rigid_rigid_delta problem wl head1 head2 t1 t2))
-            | (FStar_Syntax_Syntax.Tm_let uu___7, FStar_Syntax_Syntax.Tm_let
-               uu___8) ->
-                let uu___9 = FStar_Syntax_Util.term_eq t1 t2 in
-                if uu___9
-                then
-                  let uu___10 =
-                    solve_prob orig FStar_Pervasives_Native.None [] wl in
-                  solve uu___10
-                else
-                  (let uu___11 = FStar_Thunk.mkv "Tm_let mismatch" in
-                   giveup wl uu___11 orig)
-            | (FStar_Syntax_Syntax.Tm_let uu___7, uu___8) ->
-                let uu___9 =
-                  let uu___10 =
-                    let uu___11 = FStar_Syntax_Print.tag_of_term t1 in
-                    let uu___12 = FStar_Syntax_Print.tag_of_term t2 in
-                    let uu___13 = FStar_Syntax_Print.term_to_string t1 in
-                    let uu___14 = FStar_Syntax_Print.term_to_string t2 in
-                    FStar_Compiler_Util.format4
-                      "Internal error: unexpected flex-flex of %s and %s\n>>> (%s) -- (%s)"
-                      uu___11 uu___12 uu___13 uu___14 in
-                  (FStar_Errors.Fatal_UnificationNotWellFormed, uu___10) in
-                FStar_Errors.raise_error uu___9 t1.FStar_Syntax_Syntax.pos
-            | (uu___7, FStar_Syntax_Syntax.Tm_let uu___8) ->
-                let uu___9 =
-                  let uu___10 =
-                    let uu___11 = FStar_Syntax_Print.tag_of_term t1 in
-                    let uu___12 = FStar_Syntax_Print.tag_of_term t2 in
-                    let uu___13 = FStar_Syntax_Print.term_to_string t1 in
-                    let uu___14 = FStar_Syntax_Print.term_to_string t2 in
-                    FStar_Compiler_Util.format4
-                      "Internal error: unexpected flex-flex of %s and %s\n>>> (%s) -- (%s)"
-                      uu___11 uu___12 uu___13 uu___14 in
-                  (FStar_Errors.Fatal_UnificationNotWellFormed, uu___10) in
-                FStar_Errors.raise_error uu___9 t1.FStar_Syntax_Syntax.pos
-            | uu___7 ->
-                let uu___8 = FStar_Thunk.mkv "head tag mismatch" in
-                giveup wl uu___8 orig))))
-and (solve_c :
-  FStar_Syntax_Syntax.comp FStar_TypeChecker_Common.problem ->
-    worklist -> solution)
-  =
-  fun problem ->
-    fun wl ->
-      let c1 = problem.FStar_TypeChecker_Common.lhs in
-      let c2 = problem.FStar_TypeChecker_Common.rhs in
-      let orig = FStar_TypeChecker_Common.CProb problem in
-      let env = p_env wl orig in
-      let sub_prob wl1 t1 rel t2 reason =
-        mk_t_problem wl1 [] orig t1 rel t2 FStar_Pervasives_Native.None
-          reason in
-      let solve_eq c1_comp c2_comp g_lift =
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar (debug wl)
-             (FStar_Options.Other "EQ") in
-         if uu___1
-         then
-           let uu___2 =
-             let uu___3 = FStar_Syntax_Syntax.mk_Comp c1_comp in
-             FStar_Syntax_Print.comp_to_string uu___3 in
-           let uu___3 =
-             let uu___4 = FStar_Syntax_Syntax.mk_Comp c2_comp in
-             FStar_Syntax_Print.comp_to_string uu___4 in
-           FStar_Compiler_Util.print2
-             "solve_c is using an equality constraint (%s vs %s)\n" uu___2
-             uu___3
-         else ());
-        (let uu___1 =
-           let uu___2 =
-             FStar_Ident.lid_equals c1_comp.FStar_Syntax_Syntax.effect_name
-               c2_comp.FStar_Syntax_Syntax.effect_name in
-           Prims.op_Negation uu___2 in
-         if uu___1
-         then
-           let uu___2 =
-             mklstr
-               (fun uu___3 ->
-                  let uu___4 =
-                    FStar_Syntax_Print.lid_to_string
-                      c1_comp.FStar_Syntax_Syntax.effect_name in
-                  let uu___5 =
-                    FStar_Syntax_Print.lid_to_string
-                      c2_comp.FStar_Syntax_Syntax.effect_name in
-                  FStar_Compiler_Util.format2
-                    "incompatible effects: %s <> %s" uu___4 uu___5) in
-           giveup wl uu___2 orig
-         else
-           if
-             (FStar_Compiler_List.length
-                c1_comp.FStar_Syntax_Syntax.effect_args)
-               <>
-               (FStar_Compiler_List.length
-                  c2_comp.FStar_Syntax_Syntax.effect_args)
-           then
-             (let uu___3 =
-                mklstr
-                  (fun uu___4 ->
-                     let uu___5 =
-                       FStar_Syntax_Print.args_to_string
-                         c1_comp.FStar_Syntax_Syntax.effect_args in
-                     let uu___6 =
-                       FStar_Syntax_Print.args_to_string
-                         c2_comp.FStar_Syntax_Syntax.effect_args in
-                     FStar_Compiler_Util.format2
-                       "incompatible effect arguments: %s <> %s" uu___5
-                       uu___6) in
-              giveup wl uu___3 orig)
-           else
-             (let uu___4 =
-                FStar_Compiler_List.fold_left2
-                  (fun uu___5 ->
-                     fun u1 ->
-                       fun u2 ->
-                         match uu___5 with
-                         | (univ_sub_probs, wl1) ->
-                             let uu___6 =
-                               let uu___7 =
-                                 FStar_Syntax_Syntax.mk
-                                   (FStar_Syntax_Syntax.Tm_type u1)
-                                   FStar_Compiler_Range.dummyRange in
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.mk
-                                   (FStar_Syntax_Syntax.Tm_type u2)
-                                   FStar_Compiler_Range.dummyRange in
-                               sub_prob wl1 uu___7
-                                 FStar_TypeChecker_Common.EQ uu___8
-                                 "effect universes" in
-                             (match uu___6 with
-                              | (p, wl2) ->
-                                  ((FStar_Compiler_List.op_At univ_sub_probs
-                                      [p]), wl2))) ([], wl)
-                  c1_comp.FStar_Syntax_Syntax.comp_univs
-                  c2_comp.FStar_Syntax_Syntax.comp_univs in
-              match uu___4 with
-              | (univ_sub_probs, wl1) ->
-                  let uu___5 =
-                    sub_prob wl1 c1_comp.FStar_Syntax_Syntax.result_typ
-                      FStar_TypeChecker_Common.EQ
-                      c2_comp.FStar_Syntax_Syntax.result_typ
-                      "effect ret type" in
-                  (match uu___5 with
-                   | (ret_sub_prob, wl2) ->
-                       let uu___6 =
-                         FStar_Compiler_List.fold_right2
-                           (fun uu___7 ->
-                              fun uu___8 ->
-                                fun uu___9 ->
-                                  match (uu___7, uu___8, uu___9) with
-                                  | ((a1, uu___10), (a2, uu___11),
-                                     (arg_sub_probs, wl3)) ->
-                                      let uu___12 =
-                                        sub_prob wl3 a1
-                                          FStar_TypeChecker_Common.EQ a2
-                                          "effect arg" in
-                                      (match uu___12 with
-                                       | (p, wl4) ->
-                                           ((p :: arg_sub_probs), wl4)))
-                           c1_comp.FStar_Syntax_Syntax.effect_args
-                           c2_comp.FStar_Syntax_Syntax.effect_args ([], wl2) in
-                       (match uu___6 with
-                        | (arg_sub_probs, wl3) ->
-                            let sub_probs =
-                              let uu___7 =
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      g_lift.FStar_TypeChecker_Common.deferred
-                                      (FStar_Compiler_List.map
-                                         (fun uu___10 ->
-                                            match uu___10 with
-                                            | (uu___11, uu___12, p) -> p)) in
-                                  FStar_Compiler_List.op_At arg_sub_probs
-                                    uu___9 in
-                                FStar_Compiler_List.op_At [ret_sub_prob]
-                                  uu___8 in
-                              FStar_Compiler_List.op_At univ_sub_probs uu___7 in
-                            let guard =
-                              let guard1 =
-                                let uu___7 =
-                                  FStar_Compiler_List.map p_guard sub_probs in
-                                FStar_Syntax_Util.mk_conj_l uu___7 in
-                              match g_lift.FStar_TypeChecker_Common.guard_f
-                              with
-                              | FStar_TypeChecker_Common.Trivial -> guard1
-                              | FStar_TypeChecker_Common.NonTrivial f ->
-                                  FStar_Syntax_Util.mk_conj guard1 f in
-                            let wl4 =
-                              {
-                                attempting = (wl3.attempting);
-                                wl_deferred = (wl3.wl_deferred);
-                                wl_deferred_to_tac = (wl3.wl_deferred_to_tac);
-                                ctr = (wl3.ctr);
-                                defer_ok = (wl3.defer_ok);
-                                smt_ok = (wl3.smt_ok);
-                                umax_heuristic_ok = (wl3.umax_heuristic_ok);
-                                tcenv = (wl3.tcenv);
-                                wl_implicits =
-                                  (FStar_Compiler_List.op_At
-                                     g_lift.FStar_TypeChecker_Common.implicits
-                                     wl3.wl_implicits);
-                                repr_subcomp_allowed =
-                                  (wl3.repr_subcomp_allowed)
-                              } in
-                            let wl5 =
-                              solve_prob orig
-                                (FStar_Pervasives_Native.Some guard) [] wl4 in
-                            let uu___7 = attempt sub_probs wl5 in
-                            solve uu___7)))) in
-      let should_fail_since_repr_subcomp_not_allowed repr_subcomp_allowed c11
-        c21 =
-        let uu___ =
-          let uu___1 = FStar_TypeChecker_Env.norm_eff_name wl.tcenv c11 in
-          let uu___2 = FStar_TypeChecker_Env.norm_eff_name wl.tcenv c21 in
-          (uu___1, uu___2) in
-        match uu___ with
-        | (c12, c22) ->
-            ((Prims.op_Negation wl.repr_subcomp_allowed) &&
-               (let uu___1 = FStar_Ident.lid_equals c12 c22 in
-                Prims.op_Negation uu___1))
-              && (FStar_TypeChecker_Env.is_reifiable_effect wl.tcenv c22) in
-      let solve_layered_sub c11 c21 =
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar (debug wl)
-             (FStar_Options.Other "LayeredEffectsApp") in
-         if uu___1
-         then
-           let uu___2 =
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater c11
-                 FStar_Syntax_Syntax.mk_Comp in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               FStar_Syntax_Print.comp_to_string in
-           let uu___3 =
-             let uu___4 =
-               FStar_Compiler_Effect.op_Bar_Greater c21
-                 FStar_Syntax_Syntax.mk_Comp in
-             FStar_Compiler_Effect.op_Bar_Greater uu___4
-               FStar_Syntax_Print.comp_to_string in
-           FStar_Compiler_Util.print2
-             "solve_layered_sub c1: %s and c2: %s {\n" uu___2 uu___3
-         else ());
-        if
-          problem.FStar_TypeChecker_Common.relation =
-            FStar_TypeChecker_Common.EQ
-        then solve_eq c11 c21 FStar_TypeChecker_Env.trivial_guard
-        else
-          (let r = FStar_TypeChecker_Env.get_range wl.tcenv in
-           let uu___2 =
-             should_fail_since_repr_subcomp_not_allowed
-               wl.repr_subcomp_allowed c11.FStar_Syntax_Syntax.effect_name
-               c21.FStar_Syntax_Syntax.effect_name in
-           if uu___2
-           then
-             let uu___3 =
-               mklstr
-                 (fun uu___4 ->
-                    let uu___5 =
-                      FStar_Ident.string_of_lid
-                        c11.FStar_Syntax_Syntax.effect_name in
-                    let uu___6 =
-                      FStar_Ident.string_of_lid
-                        c21.FStar_Syntax_Syntax.effect_name in
-                    FStar_Compiler_Util.format2
-                      "Cannot lift from %s to %s, it needs a lift\n" uu___5
-                      uu___6) in
-             giveup wl uu___3 orig
-           else
-             (let subcomp_name =
-                let uu___4 =
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      c11.FStar_Syntax_Syntax.effect_name
-                      FStar_Ident.ident_of_lid in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___5
-                    FStar_Ident.string_of_id in
-                let uu___5 =
-                  let uu___6 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      c21.FStar_Syntax_Syntax.effect_name
-                      FStar_Ident.ident_of_lid in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___6
-                    FStar_Ident.string_of_id in
-                FStar_Compiler_Util.format2 "%s <: %s" uu___4 uu___5 in
-              let lift_c1 edge =
-                let uu___4 =
-                  let uu___5 =
-                    FStar_Compiler_Effect.op_Bar_Greater c11
-                      FStar_Syntax_Syntax.mk_Comp in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___5
-                    ((edge.FStar_TypeChecker_Env.mlift).FStar_TypeChecker_Env.mlift_wp
-                       env) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (c, g) ->
-                         let uu___6 =
-                           FStar_TypeChecker_Env.comp_to_comp_typ env c in
-                         (uu___6, g)) in
-              let uu___4 =
-                let uu___5 =
-                  FStar_TypeChecker_Env.exists_polymonadic_subcomp env
-                    c11.FStar_Syntax_Syntax.effect_name
-                    c21.FStar_Syntax_Syntax.effect_name in
-                match uu___5 with
-                | FStar_Pervasives_Native.None ->
-                    let uu___6 =
-                      FStar_TypeChecker_Env.monad_leq env
-                        c11.FStar_Syntax_Syntax.effect_name
-                        c21.FStar_Syntax_Syntax.effect_name in
-                    (match uu___6 with
-                     | FStar_Pervasives_Native.None ->
-                         (c11, FStar_TypeChecker_Env.trivial_guard,
-                           FStar_Pervasives_Native.None,
-                           FStar_Syntax_Syntax.Ad_hoc_combinator,
-                           Prims.int_zero, false)
-                     | FStar_Pervasives_Native.Some edge ->
-                         let uu___7 = lift_c1 edge in
-                         (match uu___7 with
-                          | (c12, g_lift) ->
-                              let ed2 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  c21.FStar_Syntax_Syntax.effect_name
-                                  (FStar_TypeChecker_Env.get_effect_decl env) in
-                              let uu___8 =
-                                let uu___9 =
-                                  FStar_Compiler_Effect.op_Bar_Greater ed2
-                                    FStar_Syntax_Util.get_stronger_vc_combinator in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                  (fun uu___10 ->
-                                     match uu___10 with
-                                     | (ts, kopt) ->
-                                         let uu___11 =
-                                           let uu___12 =
-                                             let uu___13 =
-                                               FStar_TypeChecker_Env.inst_tscheme_with
-                                                 ts
-                                                 c21.FStar_Syntax_Syntax.comp_univs in
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               uu___13
-                                               FStar_Pervasives_Native.snd in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___12
-                                             (fun uu___13 ->
-                                                FStar_Pervasives_Native.Some
-                                                  uu___13) in
-                                         let uu___12 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             kopt FStar_Compiler_Util.must in
-                                         (uu___11, uu___12)) in
-                              (match uu___8 with
-                               | (tsopt, k) ->
-                                   let num_eff_params =
-                                     match ed2.FStar_Syntax_Syntax.signature
-                                     with
-                                     | FStar_Syntax_Syntax.Layered_eff_sig
-                                         (n, uu___9) -> n
-                                     | uu___9 ->
-                                         failwith
-                                           "Impossible (expected indexed effect subcomp)" in
-                                   (c12, g_lift, tsopt, k, num_eff_params,
-                                     false))))
-                | FStar_Pervasives_Native.Some (t, kind) ->
-                    let uu___6 =
-                      let uu___7 =
-                        let uu___8 =
-                          FStar_TypeChecker_Env.inst_tscheme_with t
-                            c21.FStar_Syntax_Syntax.comp_univs in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___8
-                          FStar_Pervasives_Native.snd in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___7
-                        (fun uu___8 -> FStar_Pervasives_Native.Some uu___8) in
-                    (c11, FStar_TypeChecker_Env.trivial_guard, uu___6, kind,
-                      Prims.int_zero, true) in
-              match uu___4 with
-              | (c12, g_lift, stronger_t_opt, kind, num_eff_params,
-                 is_polymonadic) ->
-                  if FStar_Compiler_Util.is_none stronger_t_opt
-                  then
-                    let uu___5 =
-                      mklstr
-                        (fun uu___6 ->
-                           let uu___7 =
-                             FStar_Syntax_Print.lid_to_string
-                               c12.FStar_Syntax_Syntax.effect_name in
-                           let uu___8 =
-                             FStar_Syntax_Print.lid_to_string
-                               c21.FStar_Syntax_Syntax.effect_name in
-                           FStar_Compiler_Util.format2
-                             "incompatible monad ordering: %s </: %s" uu___7
-                             uu___8) in
-                    giveup wl uu___5 orig
-                  else
-                    (let stronger_t =
-                       FStar_Compiler_Effect.op_Bar_Greater stronger_t_opt
-                         FStar_Compiler_Util.must in
-                     let wl1 =
-                       extend_wl wl g_lift.FStar_TypeChecker_Common.deferred
-                         g_lift.FStar_TypeChecker_Common.deferred_to_tac
-                         g_lift.FStar_TypeChecker_Common.implicits in
-                     (let uu___7 =
-                        ((is_polymonadic &&
-                            (FStar_TypeChecker_Env.is_erasable_effect env
-                               c12.FStar_Syntax_Syntax.effect_name))
-                           &&
-                           (let uu___8 =
-                              FStar_TypeChecker_Env.is_erasable_effect env
-                                c21.FStar_Syntax_Syntax.effect_name in
-                            Prims.op_Negation uu___8))
-                          &&
-                          (let uu___8 =
-                             FStar_TypeChecker_Normalize.non_info_norm env
-                               c12.FStar_Syntax_Syntax.result_typ in
-                           Prims.op_Negation uu___8) in
-                      if uu___7
-                      then
-                        let uu___8 =
-                          let uu___9 =
-                            let uu___10 =
-                              FStar_Ident.string_of_lid
-                                c12.FStar_Syntax_Syntax.effect_name in
-                            let uu___11 =
-                              FStar_Ident.string_of_lid
-                                c21.FStar_Syntax_Syntax.effect_name in
-                            let uu___12 =
-                              FStar_Syntax_Print.term_to_string
-                                c12.FStar_Syntax_Syntax.result_typ in
-                            FStar_Compiler_Util.format3
-                              "Cannot lift erasable expression from %s ~> %s since its type %s is informative"
-                              uu___10 uu___11 uu___12 in
-                          (FStar_Errors.Error_TypeError, uu___9) in
-                        FStar_Errors.raise_error uu___8 r
-                      else ());
-                     (let uu___7 =
-                        if is_polymonadic
-                        then ([], wl1)
-                        else
-                          (let rec is_uvar t =
-                             let uu___9 =
-                               let uu___10 = FStar_Syntax_Subst.compress t in
-                               uu___10.FStar_Syntax_Syntax.n in
-                             match uu___9 with
-                             | FStar_Syntax_Syntax.Tm_uvar (uv, uu___10) ->
-                                 let uu___11 =
-                                   FStar_TypeChecker_DeferredImplicits.should_defer_uvar_to_user_tac
-                                     env uv in
-                                 Prims.op_Negation uu___11
-                             | FStar_Syntax_Syntax.Tm_uinst (t1, uu___10) ->
-                                 is_uvar t1
-                             | FStar_Syntax_Syntax.Tm_app (t1, uu___10) ->
-                                 is_uvar t1
-                             | uu___10 -> false in
-                           FStar_Compiler_List.fold_right2
-                             (fun uu___9 ->
-                                fun uu___10 ->
-                                  fun uu___11 ->
-                                    match (uu___9, uu___10, uu___11) with
-                                    | ((a1, uu___12), (a2, uu___13),
-                                       (is_sub_probs, wl2)) ->
-                                        let uu___14 = is_uvar a1 in
-                                        if uu___14
-                                        then
-                                          ((let uu___16 =
-                                              FStar_Compiler_Effect.op_Less_Bar
-                                                (debug wl2)
-                                                (FStar_Options.Other
-                                                   "LayeredEffectsEqns") in
-                                            if uu___16
-                                            then
-                                              let uu___17 =
-                                                FStar_Syntax_Print.term_to_string
-                                                  a1 in
-                                              let uu___18 =
-                                                FStar_Syntax_Print.term_to_string
-                                                  a2 in
-                                              FStar_Compiler_Util.print2
-                                                "Layered Effects teq (rel c1 index uvar) %s = %s\n"
-                                                uu___17 uu___18
-                                            else ());
-                                           (let uu___16 =
-                                              sub_prob wl2 a1
-                                                FStar_TypeChecker_Common.EQ
-                                                a2 "l.h.s. effect index uvar" in
-                                            match uu___16 with
-                                            | (p, wl3) ->
-                                                ((p :: is_sub_probs), wl3)))
-                                        else (is_sub_probs, wl2))
-                             c12.FStar_Syntax_Syntax.effect_args
-                             c21.FStar_Syntax_Syntax.effect_args ([], wl1)) in
-                      match uu___7 with
-                      | (is_sub_probs, wl2) ->
-                          let uu___8 =
-                            sub_prob wl2 c12.FStar_Syntax_Syntax.result_typ
-                              problem.FStar_TypeChecker_Common.relation
-                              c21.FStar_Syntax_Syntax.result_typ
-                              "result type" in
-                          (match uu___8 with
-                           | (ret_sub_prob, wl3) ->
-                               let uu___9 =
-                                 FStar_Syntax_Util.arrow_formals_comp
-                                   stronger_t in
-                               (match uu___9 with
-                                | (bs, subcomp_c) ->
-                                    let uu___10 =
-                                      if
-                                        kind =
-                                          FStar_Syntax_Syntax.Ad_hoc_combinator
-                                      then
-                                        apply_ad_hoc_indexed_subcomp env bs
-                                          subcomp_c c12 c21 sub_prob wl3
-                                          subcomp_name r
-                                      else
-                                        apply_substitutive_indexed_subcomp
-                                          env kind bs subcomp_c c12 c21
-                                          sub_prob num_eff_params wl3
-                                          subcomp_name r in
-                                    (match uu___10 with
-                                     | (fml, sub_probs, wl4) ->
-                                         let sub_probs1 = ret_sub_prob ::
-                                           (FStar_Compiler_List.op_At
-                                              is_sub_probs sub_probs) in
-                                         let guard =
-                                           let guard1 =
-                                             let uu___11 =
-                                               FStar_Compiler_List.map
-                                                 p_guard sub_probs1 in
-                                             FStar_Syntax_Util.mk_conj_l
-                                               uu___11 in
-                                           let guard2 =
-                                             match g_lift.FStar_TypeChecker_Common.guard_f
-                                             with
-                                             | FStar_TypeChecker_Common.Trivial
-                                                 -> guard1
-                                             | FStar_TypeChecker_Common.NonTrivial
-                                                 f ->
-                                                 FStar_Syntax_Util.mk_conj
-                                                   guard1 f in
-                                           FStar_Syntax_Util.mk_conj guard2
-                                             fml in
-                                         let wl5 =
-                                           solve_prob orig
-                                             (FStar_Pervasives_Native.Some
-                                                guard) [] wl4 in
-                                         ((let uu___12 =
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               (debug wl5)
-                                               (FStar_Options.Other
-                                                  "LayeredEffectsApp") in
-                                           if uu___12
-                                           then
-                                             FStar_Compiler_Util.print_string
-                                               "}\n"
-                                           else ());
-                                          (let uu___12 =
-                                             attempt sub_probs1 wl5 in
-                                           solve uu___12))))))))) in
-      let solve_sub c11 edge c21 =
-        if
-          problem.FStar_TypeChecker_Common.relation <>
-            FStar_TypeChecker_Common.SUB
-        then failwith "impossible: solve_sub"
-        else ();
-        (let r = FStar_TypeChecker_Env.get_range env in
-         let lift_c1 uu___1 =
-           let univs =
-             match c11.FStar_Syntax_Syntax.comp_univs with
-             | [] ->
-                 let uu___2 =
-                   env.FStar_TypeChecker_Env.universe_of env
-                     c11.FStar_Syntax_Syntax.result_typ in
-                 [uu___2]
-             | x -> x in
-           let c12 =
-             {
-               FStar_Syntax_Syntax.comp_univs = univs;
-               FStar_Syntax_Syntax.effect_name =
-                 (c11.FStar_Syntax_Syntax.effect_name);
-               FStar_Syntax_Syntax.result_typ =
-                 (c11.FStar_Syntax_Syntax.result_typ);
-               FStar_Syntax_Syntax.effect_args =
-                 (c11.FStar_Syntax_Syntax.effect_args);
-               FStar_Syntax_Syntax.flags = (c11.FStar_Syntax_Syntax.flags)
-             } in
-           let uu___2 =
-             let uu___3 =
-               FStar_Compiler_Effect.op_Bar_Greater
-                 {
-                   FStar_Syntax_Syntax.comp_univs = univs;
-                   FStar_Syntax_Syntax.effect_name =
-                     (c12.FStar_Syntax_Syntax.effect_name);
-                   FStar_Syntax_Syntax.result_typ =
-                     (c12.FStar_Syntax_Syntax.result_typ);
-                   FStar_Syntax_Syntax.effect_args =
-                     (c12.FStar_Syntax_Syntax.effect_args);
-                   FStar_Syntax_Syntax.flags =
-                     (c12.FStar_Syntax_Syntax.flags)
-                 } FStar_Syntax_Syntax.mk_Comp in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               ((edge.FStar_TypeChecker_Env.mlift).FStar_TypeChecker_Env.mlift_wp
-                  env) in
-           FStar_Compiler_Effect.op_Bar_Greater uu___2
-             (fun uu___3 ->
-                match uu___3 with
-                | (c, g) ->
-                    let uu___4 =
-                      let uu___5 = FStar_TypeChecker_Env.is_trivial g in
-                      Prims.op_Negation uu___5 in
-                    if uu___4
-                    then
-                      let uu___5 =
-                        let uu___6 =
-                          let uu___7 =
-                            FStar_Ident.string_of_lid
-                              c12.FStar_Syntax_Syntax.effect_name in
-                          let uu___8 =
-                            FStar_Ident.string_of_lid
-                              c21.FStar_Syntax_Syntax.effect_name in
-                          FStar_Compiler_Util.format2
-                            "Lift between wp-effects (%s~>%s) should not have returned a non-trivial guard"
-                            uu___7 uu___8 in
-                        (FStar_Errors.Fatal_UnexpectedEffect, uu___6) in
-                      FStar_Errors.raise_error uu___5 r
-                    else FStar_TypeChecker_Env.comp_to_comp_typ env c) in
-         let uu___1 =
-           should_fail_since_repr_subcomp_not_allowed wl.repr_subcomp_allowed
-             c11.FStar_Syntax_Syntax.effect_name
-             c21.FStar_Syntax_Syntax.effect_name in
-         if uu___1
-         then
-           let uu___2 =
-             mklstr
-               (fun uu___3 ->
-                  let uu___4 =
-                    FStar_Ident.string_of_lid
-                      c11.FStar_Syntax_Syntax.effect_name in
-                  let uu___5 =
-                    FStar_Ident.string_of_lid
-                      c21.FStar_Syntax_Syntax.effect_name in
-                  FStar_Compiler_Util.format2
-                    "Cannot lift from %s to %s, it needs a lift\n" uu___4
-                    uu___5) in
-           giveup wl uu___2 orig
-         else
-           (let is_null_wp_2 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                c21.FStar_Syntax_Syntax.flags
-                (FStar_Compiler_Util.for_some
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | FStar_Syntax_Syntax.TOTAL -> true
-                      | FStar_Syntax_Syntax.MLEFFECT -> true
-                      | FStar_Syntax_Syntax.SOMETRIVIAL -> true
-                      | uu___4 -> false)) in
-            let uu___3 =
-              match ((c11.FStar_Syntax_Syntax.effect_args),
-                      (c21.FStar_Syntax_Syntax.effect_args))
-              with
-              | ((wp1, uu___4)::uu___5, (wp2, uu___6)::uu___7) -> (wp1, wp2)
-              | uu___4 ->
-                  let uu___5 =
-                    let uu___6 =
-                      let uu___7 =
-                        FStar_Syntax_Print.lid_to_string
-                          c11.FStar_Syntax_Syntax.effect_name in
-                      let uu___8 =
-                        FStar_Syntax_Print.lid_to_string
-                          c21.FStar_Syntax_Syntax.effect_name in
-                      FStar_Compiler_Util.format2
-                        "Got effects %s and %s, expected normalized effects"
-                        uu___7 uu___8 in
-                    (FStar_Errors.Fatal_ExpectNormalizedEffect, uu___6) in
-                  FStar_Errors.raise_error uu___5
-                    env.FStar_TypeChecker_Env.range in
-            match uu___3 with
-            | (wpc1, wpc2) ->
-                let uu___4 = FStar_Compiler_Util.physical_equality wpc1 wpc2 in
-                if uu___4
-                then
-                  let uu___5 =
-                    problem_using_guard orig
-                      c11.FStar_Syntax_Syntax.result_typ
-                      problem.FStar_TypeChecker_Common.relation
-                      c21.FStar_Syntax_Syntax.result_typ
-                      FStar_Pervasives_Native.None "result type" in
-                  solve_t uu___5 wl
-                else
-                  (let uu___6 =
-                     let uu___7 =
-                       FStar_TypeChecker_Env.effect_decl_opt env
-                         c21.FStar_Syntax_Syntax.effect_name in
-                     FStar_Compiler_Util.must uu___7 in
-                   match uu___6 with
-                   | (c2_decl, qualifiers) ->
-                       let uu___7 =
-                         FStar_Compiler_Effect.op_Bar_Greater qualifiers
-                           (FStar_Compiler_List.contains
-                              FStar_Syntax_Syntax.Reifiable) in
-                       if uu___7
-                       then
-                         let c1_repr =
-                           let uu___8 =
-                             let uu___9 =
-                               let uu___10 = lift_c1 () in
-                               FStar_Syntax_Syntax.mk_Comp uu___10 in
-                             let uu___10 =
-                               env.FStar_TypeChecker_Env.universe_of env
-                                 c11.FStar_Syntax_Syntax.result_typ in
-                             FStar_TypeChecker_Env.reify_comp env uu___9
-                               uu___10 in
-                           norm_with_steps
-                             "FStar.TypeChecker.Rel.norm_with_steps.4"
-                             [FStar_TypeChecker_Env.UnfoldUntil
-                                FStar_Syntax_Syntax.delta_constant;
-                             FStar_TypeChecker_Env.Weak;
-                             FStar_TypeChecker_Env.HNF] env uu___8 in
-                         let c2_repr =
-                           let uu___8 =
-                             let uu___9 = FStar_Syntax_Syntax.mk_Comp c21 in
-                             let uu___10 =
-                               env.FStar_TypeChecker_Env.universe_of env
-                                 c21.FStar_Syntax_Syntax.result_typ in
-                             FStar_TypeChecker_Env.reify_comp env uu___9
-                               uu___10 in
-                           norm_with_steps
-                             "FStar.TypeChecker.Rel.norm_with_steps.5"
-                             [FStar_TypeChecker_Env.UnfoldUntil
-                                FStar_Syntax_Syntax.delta_constant;
-                             FStar_TypeChecker_Env.Weak;
-                             FStar_TypeChecker_Env.HNF] env uu___8 in
-                         let uu___8 =
-                           let uu___9 =
-                             let uu___10 =
-                               FStar_Syntax_Print.term_to_string c1_repr in
-                             let uu___11 =
-                               FStar_Syntax_Print.term_to_string c2_repr in
-                             FStar_Compiler_Util.format2
-                               "sub effect repr: %s <: %s" uu___10 uu___11 in
-                           sub_prob wl c1_repr
-                             problem.FStar_TypeChecker_Common.relation
-                             c2_repr uu___9 in
-                         (match uu___8 with
-                          | (prob, wl1) ->
-                              let wl2 =
-                                solve_prob orig
-                                  (FStar_Pervasives_Native.Some
-                                     (p_guard prob)) [] wl1 in
-                              let uu___9 = attempt [prob] wl2 in solve uu___9)
-                       else
-                         (let g =
-                            if env.FStar_TypeChecker_Env.lax
-                            then FStar_Syntax_Util.t_true
-                            else
-                              (let wpc1_2 =
-                                 let uu___10 = lift_c1 () in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___10
-                                   (fun ct ->
-                                      FStar_Compiler_List.hd
-                                        ct.FStar_Syntax_Syntax.effect_args) in
-                               if is_null_wp_2
-                               then
-                                 ((let uu___11 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (debug wl) (FStar_Options.Other "Rel") in
-                                   if uu___11
-                                   then
-                                     FStar_Compiler_Util.print_string
-                                       "Using trivial wp ... \n"
-                                   else ());
-                                  (let c1_univ =
-                                     env.FStar_TypeChecker_Env.universe_of
-                                       env c11.FStar_Syntax_Syntax.result_typ in
-                                   let trivial =
-                                     let uu___11 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         c2_decl
-                                         FStar_Syntax_Util.get_wp_trivial_combinator in
-                                     match uu___11 with
-                                     | FStar_Pervasives_Native.None ->
-                                         failwith
-                                           "Rel doesn't yet handle undefined trivial combinator in an effect"
-                                     | FStar_Pervasives_Native.Some t -> t in
-                                   let uu___11 =
-                                     let uu___12 =
-                                       let uu___13 =
-                                         FStar_TypeChecker_Env.inst_effect_fun_with
-                                           [c1_univ] env c2_decl trivial in
-                                       let uu___14 =
-                                         let uu___15 =
-                                           FStar_Syntax_Syntax.as_arg
-                                             c11.FStar_Syntax_Syntax.result_typ in
-                                         [uu___15; wpc1_2] in
-                                       (uu___13, uu___14) in
-                                     FStar_Syntax_Syntax.Tm_app uu___12 in
-                                   FStar_Syntax_Syntax.mk uu___11 r))
-                               else
-                                 (let c2_univ =
-                                    env.FStar_TypeChecker_Env.universe_of env
-                                      c21.FStar_Syntax_Syntax.result_typ in
-                                  let stronger =
-                                    let uu___11 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        c2_decl
-                                        FStar_Syntax_Util.get_stronger_vc_combinator in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___11 FStar_Pervasives_Native.fst in
-                                  let uu___11 =
-                                    let uu___12 =
-                                      let uu___13 =
-                                        FStar_TypeChecker_Env.inst_effect_fun_with
-                                          [c2_univ] env c2_decl stronger in
-                                      let uu___14 =
-                                        let uu___15 =
-                                          FStar_Syntax_Syntax.as_arg
-                                            c21.FStar_Syntax_Syntax.result_typ in
-                                        let uu___16 =
-                                          let uu___17 =
-                                            FStar_Syntax_Syntax.as_arg wpc2 in
-                                          [uu___17; wpc1_2] in
-                                        uu___15 :: uu___16 in
-                                      (uu___13, uu___14) in
-                                    FStar_Syntax_Syntax.Tm_app uu___12 in
-                                  FStar_Syntax_Syntax.mk uu___11 r)) in
-                          (let uu___10 =
-                             FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                               (FStar_Options.Other "Rel") in
-                           if uu___10
-                           then
-                             let uu___11 =
-                               let uu___12 =
-                                 FStar_TypeChecker_Normalize.normalize
-                                   [FStar_TypeChecker_Env.Iota;
-                                   FStar_TypeChecker_Env.Eager_unfolding;
-                                   FStar_TypeChecker_Env.Primops;
-                                   FStar_TypeChecker_Env.Simplify] env g in
-                               FStar_Syntax_Print.term_to_string uu___12 in
-                             FStar_Compiler_Util.print1
-                               "WP guard (simplifed) is (%s)\n" uu___11
-                           else ());
-                          (let uu___10 =
-                             sub_prob wl c11.FStar_Syntax_Syntax.result_typ
-                               problem.FStar_TypeChecker_Common.relation
-                               c21.FStar_Syntax_Syntax.result_typ
-                               "result type" in
-                           match uu___10 with
-                           | (base_prob, wl1) ->
-                               let wl2 =
-                                 let uu___11 =
-                                   let uu___12 =
-                                     FStar_Syntax_Util.mk_conj
-                                       (p_guard base_prob) g in
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (fun uu___13 ->
-                                        FStar_Pervasives_Native.Some uu___13)
-                                     uu___12 in
-                                 solve_prob orig uu___11 [] wl1 in
-                               let uu___11 = attempt [base_prob] wl2 in
-                               solve uu___11))))) in
-      let uu___ = FStar_Compiler_Util.physical_equality c1 c2 in
-      if uu___
-      then
-        let uu___1 = solve_prob orig FStar_Pervasives_Native.None [] wl in
-        solve uu___1
-      else
-        ((let uu___3 =
-            FStar_Compiler_Effect.op_Less_Bar (debug wl)
-              (FStar_Options.Other "Rel") in
-          if uu___3
-          then
-            let uu___4 = FStar_Syntax_Print.comp_to_string c1 in
-            let uu___5 = FStar_Syntax_Print.comp_to_string c2 in
-            FStar_Compiler_Util.print3 "solve_c %s %s %s\n" uu___4
-              (rel_to_string problem.FStar_TypeChecker_Common.relation)
-              uu___5
-          else ());
-         (let uu___3 =
-            let uu___4 =
-              let uu___5 =
-                let uu___6 =
-                  FStar_Compiler_Effect.op_Bar_Greater c1
-                    FStar_Syntax_Util.comp_effect_name in
-                FStar_Compiler_Effect.op_Bar_Greater uu___6
-                  (FStar_TypeChecker_Env.norm_eff_name env) in
-              let uu___6 =
-                let uu___7 =
-                  FStar_Compiler_Effect.op_Bar_Greater c2
-                    FStar_Syntax_Util.comp_effect_name in
-                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                  (FStar_TypeChecker_Env.norm_eff_name env) in
-              (uu___5, uu___6) in
-            match uu___4 with
-            | (eff1, eff2) ->
-                let uu___5 = FStar_Ident.lid_equals eff1 eff2 in
-                if uu___5
-                then (c1, c2)
-                else FStar_TypeChecker_Normalize.ghost_to_pure2 env (c1, c2) in
-          match uu___3 with
-          | (c11, c21) ->
-              (match ((c11.FStar_Syntax_Syntax.n),
-                       (c21.FStar_Syntax_Syntax.n))
-               with
-               | (FStar_Syntax_Syntax.GTotal t1, FStar_Syntax_Syntax.Total
-                  t2) when FStar_TypeChecker_Env.non_informative env t2 ->
-                   let uu___4 =
-                     problem_using_guard orig t1
-                       problem.FStar_TypeChecker_Common.relation t2
-                       FStar_Pervasives_Native.None "result type" in
-                   solve_t uu___4 wl
-               | (FStar_Syntax_Syntax.GTotal uu___4,
-                  FStar_Syntax_Syntax.Total uu___5) ->
-                   let uu___6 =
-                     FStar_Thunk.mkv
-                       "incompatible monad ordering: GTot </: Tot" in
-                   giveup wl uu___6 orig
-               | (FStar_Syntax_Syntax.Total t1, FStar_Syntax_Syntax.Total t2)
-                   ->
-                   let uu___4 =
-                     problem_using_guard orig t1
-                       problem.FStar_TypeChecker_Common.relation t2
-                       FStar_Pervasives_Native.None "result type" in
-                   solve_t uu___4 wl
-               | (FStar_Syntax_Syntax.GTotal t1, FStar_Syntax_Syntax.GTotal
-                  t2) ->
-                   let uu___4 =
-                     problem_using_guard orig t1
-                       problem.FStar_TypeChecker_Common.relation t2
-                       FStar_Pervasives_Native.None "result type" in
-                   solve_t uu___4 wl
-               | (FStar_Syntax_Syntax.Total t1, FStar_Syntax_Syntax.GTotal
-                  t2) when
-                   problem.FStar_TypeChecker_Common.relation =
-                     FStar_TypeChecker_Common.SUB
-                   ->
-                   let uu___4 =
-                     problem_using_guard orig t1
-                       problem.FStar_TypeChecker_Common.relation t2
-                       FStar_Pervasives_Native.None "result type" in
-                   solve_t uu___4 wl
-               | (FStar_Syntax_Syntax.Total t1, FStar_Syntax_Syntax.GTotal
-                  t2) ->
-                   let uu___4 = FStar_Thunk.mkv "GTot =/= Tot" in
-                   giveup wl uu___4 orig
-               | (FStar_Syntax_Syntax.GTotal uu___4, FStar_Syntax_Syntax.Comp
-                  uu___5) ->
-                   let uu___6 =
-                     let uu___7 =
-                       let uu___8 =
-                         FStar_TypeChecker_Env.comp_to_comp_typ env c11 in
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Syntax_Syntax.mk_Comp uu___8 in
-                     {
-                       FStar_TypeChecker_Common.pid =
-                         (problem.FStar_TypeChecker_Common.pid);
-                       FStar_TypeChecker_Common.lhs = uu___7;
-                       FStar_TypeChecker_Common.relation =
-                         (problem.FStar_TypeChecker_Common.relation);
-                       FStar_TypeChecker_Common.rhs =
-                         (problem.FStar_TypeChecker_Common.rhs);
-                       FStar_TypeChecker_Common.element =
-                         (problem.FStar_TypeChecker_Common.element);
-                       FStar_TypeChecker_Common.logical_guard =
-                         (problem.FStar_TypeChecker_Common.logical_guard);
-                       FStar_TypeChecker_Common.logical_guard_uvar =
-                         (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                       FStar_TypeChecker_Common.reason =
-                         (problem.FStar_TypeChecker_Common.reason);
-                       FStar_TypeChecker_Common.loc =
-                         (problem.FStar_TypeChecker_Common.loc);
-                       FStar_TypeChecker_Common.rank =
-                         (problem.FStar_TypeChecker_Common.rank)
-                     } in
-                   solve_c uu___6 wl
-               | (FStar_Syntax_Syntax.Total uu___4, FStar_Syntax_Syntax.Comp
-                  uu___5) ->
-                   let uu___6 =
-                     let uu___7 =
-                       let uu___8 =
-                         FStar_TypeChecker_Env.comp_to_comp_typ env c11 in
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Syntax_Syntax.mk_Comp uu___8 in
-                     {
-                       FStar_TypeChecker_Common.pid =
-                         (problem.FStar_TypeChecker_Common.pid);
-                       FStar_TypeChecker_Common.lhs = uu___7;
-                       FStar_TypeChecker_Common.relation =
-                         (problem.FStar_TypeChecker_Common.relation);
-                       FStar_TypeChecker_Common.rhs =
-                         (problem.FStar_TypeChecker_Common.rhs);
-                       FStar_TypeChecker_Common.element =
-                         (problem.FStar_TypeChecker_Common.element);
-                       FStar_TypeChecker_Common.logical_guard =
-                         (problem.FStar_TypeChecker_Common.logical_guard);
-                       FStar_TypeChecker_Common.logical_guard_uvar =
-                         (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                       FStar_TypeChecker_Common.reason =
-                         (problem.FStar_TypeChecker_Common.reason);
-                       FStar_TypeChecker_Common.loc =
-                         (problem.FStar_TypeChecker_Common.loc);
-                       FStar_TypeChecker_Common.rank =
-                         (problem.FStar_TypeChecker_Common.rank)
-                     } in
-                   solve_c uu___6 wl
-               | (FStar_Syntax_Syntax.Comp uu___4, FStar_Syntax_Syntax.GTotal
-                  uu___5) ->
-                   let uu___6 =
-                     let uu___7 =
-                       let uu___8 =
-                         FStar_TypeChecker_Env.comp_to_comp_typ env c21 in
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Syntax_Syntax.mk_Comp uu___8 in
-                     {
-                       FStar_TypeChecker_Common.pid =
-                         (problem.FStar_TypeChecker_Common.pid);
-                       FStar_TypeChecker_Common.lhs =
-                         (problem.FStar_TypeChecker_Common.lhs);
-                       FStar_TypeChecker_Common.relation =
-                         (problem.FStar_TypeChecker_Common.relation);
-                       FStar_TypeChecker_Common.rhs = uu___7;
-                       FStar_TypeChecker_Common.element =
-                         (problem.FStar_TypeChecker_Common.element);
-                       FStar_TypeChecker_Common.logical_guard =
-                         (problem.FStar_TypeChecker_Common.logical_guard);
-                       FStar_TypeChecker_Common.logical_guard_uvar =
-                         (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                       FStar_TypeChecker_Common.reason =
-                         (problem.FStar_TypeChecker_Common.reason);
-                       FStar_TypeChecker_Common.loc =
-                         (problem.FStar_TypeChecker_Common.loc);
-                       FStar_TypeChecker_Common.rank =
-                         (problem.FStar_TypeChecker_Common.rank)
-                     } in
-                   solve_c uu___6 wl
-               | (FStar_Syntax_Syntax.Comp uu___4, FStar_Syntax_Syntax.Total
-                  uu___5) ->
-                   let uu___6 =
-                     let uu___7 =
-                       let uu___8 =
-                         FStar_TypeChecker_Env.comp_to_comp_typ env c21 in
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Syntax_Syntax.mk_Comp uu___8 in
-                     {
-                       FStar_TypeChecker_Common.pid =
-                         (problem.FStar_TypeChecker_Common.pid);
-                       FStar_TypeChecker_Common.lhs =
-                         (problem.FStar_TypeChecker_Common.lhs);
-                       FStar_TypeChecker_Common.relation =
-                         (problem.FStar_TypeChecker_Common.relation);
-                       FStar_TypeChecker_Common.rhs = uu___7;
-                       FStar_TypeChecker_Common.element =
-                         (problem.FStar_TypeChecker_Common.element);
-                       FStar_TypeChecker_Common.logical_guard =
-                         (problem.FStar_TypeChecker_Common.logical_guard);
-                       FStar_TypeChecker_Common.logical_guard_uvar =
-                         (problem.FStar_TypeChecker_Common.logical_guard_uvar);
-                       FStar_TypeChecker_Common.reason =
-                         (problem.FStar_TypeChecker_Common.reason);
-                       FStar_TypeChecker_Common.loc =
-                         (problem.FStar_TypeChecker_Common.loc);
-                       FStar_TypeChecker_Common.rank =
-                         (problem.FStar_TypeChecker_Common.rank)
-                     } in
-                   solve_c uu___6 wl
-               | (FStar_Syntax_Syntax.Comp uu___4, FStar_Syntax_Syntax.Comp
-                  uu___5) ->
-                   let uu___6 =
-                     (((FStar_Syntax_Util.is_ml_comp c11) &&
-                         (FStar_Syntax_Util.is_ml_comp c21))
-                        ||
-                        ((FStar_Syntax_Util.is_total_comp c11) &&
-                           (FStar_Syntax_Util.is_total_comp c21)))
-                       ||
-                       (((FStar_Syntax_Util.is_total_comp c11) &&
-                           (FStar_Syntax_Util.is_ml_comp c21))
-                          &&
-                          (problem.FStar_TypeChecker_Common.relation =
-                             FStar_TypeChecker_Common.SUB)) in
-                   if uu___6
-                   then
-                     let uu___7 =
-                       problem_using_guard orig
-                         (FStar_Syntax_Util.comp_result c11)
-                         problem.FStar_TypeChecker_Common.relation
-                         (FStar_Syntax_Util.comp_result c21)
-                         FStar_Pervasives_Native.None "result type" in
-                     solve_t uu___7 wl
-                   else
-                     (let c1_comp =
-                        FStar_TypeChecker_Env.comp_to_comp_typ env c11 in
-                      let c2_comp =
-                        FStar_TypeChecker_Env.comp_to_comp_typ env c21 in
-                      if
-                        problem.FStar_TypeChecker_Common.relation =
-                          FStar_TypeChecker_Common.EQ
-                      then
-                        let uu___8 =
-                          let uu___9 =
-                            FStar_Ident.lid_equals
-                              c1_comp.FStar_Syntax_Syntax.effect_name
-                              c2_comp.FStar_Syntax_Syntax.effect_name in
-                          if uu___9
-                          then (c1_comp, c2_comp)
-                          else
-                            (let uu___11 =
-                               FStar_TypeChecker_Env.unfold_effect_abbrev env
-                                 c11 in
-                             let uu___12 =
-                               FStar_TypeChecker_Env.unfold_effect_abbrev env
-                                 c21 in
-                             (uu___11, uu___12)) in
-                        match uu___8 with
-                        | (c1_comp1, c2_comp1) ->
-                            solve_eq c1_comp1 c2_comp1
-                              FStar_TypeChecker_Env.trivial_guard
-                      else
-                        (let c12 =
-                           FStar_TypeChecker_Env.unfold_effect_abbrev env c11 in
-                         let c22 =
-                           FStar_TypeChecker_Env.unfold_effect_abbrev env c21 in
-                         (let uu___10 =
-                            FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                              (FStar_Options.Other "Rel") in
-                          if uu___10
-                          then
-                            let uu___11 =
-                              FStar_Ident.string_of_lid
-                                c12.FStar_Syntax_Syntax.effect_name in
-                            let uu___12 =
-                              FStar_Ident.string_of_lid
-                                c22.FStar_Syntax_Syntax.effect_name in
-                            FStar_Compiler_Util.print2
-                              "solve_c for %s and %s\n" uu___11 uu___12
-                          else ());
-                         (let uu___10 =
-                            FStar_TypeChecker_Env.is_layered_effect env
-                              c22.FStar_Syntax_Syntax.effect_name in
-                          if uu___10
-                          then solve_layered_sub c12 c22
-                          else
-                            (let uu___12 =
-                               FStar_TypeChecker_Env.monad_leq env
-                                 c12.FStar_Syntax_Syntax.effect_name
-                                 c22.FStar_Syntax_Syntax.effect_name in
-                             match uu___12 with
-                             | FStar_Pervasives_Native.None ->
-                                 let uu___13 =
-                                   mklstr
-                                     (fun uu___14 ->
-                                        let uu___15 =
-                                          FStar_Syntax_Print.lid_to_string
-                                            c12.FStar_Syntax_Syntax.effect_name in
-                                        let uu___16 =
-                                          FStar_Syntax_Print.lid_to_string
-                                            c22.FStar_Syntax_Syntax.effect_name in
-                                        FStar_Compiler_Util.format2
-                                          "incompatible monad ordering: %s </: %s"
-                                          uu___15 uu___16) in
-                                 giveup wl uu___13 orig
-                             | FStar_Pervasives_Native.Some edge ->
-                                 solve_sub c12 edge c22)))))))
-let (print_pending_implicits :
-  FStar_TypeChecker_Common.guard_t -> Prims.string) =
-  fun g ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater
-        g.FStar_TypeChecker_Common.implicits
-        (FStar_Compiler_List.map
-           (fun i ->
-              FStar_Syntax_Print.ctx_uvar_to_string
-                i.FStar_TypeChecker_Common.imp_uvar)) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ")
-let (ineqs_to_string :
-  (FStar_Syntax_Syntax.universe Prims.list * (FStar_Syntax_Syntax.universe *
-    FStar_Syntax_Syntax.universe) Prims.list) -> Prims.string)
-  =
-  fun ineqs ->
-    let vars =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Pervasives_Native.fst ineqs)
-          (FStar_Compiler_List.map FStar_Syntax_Print.univ_to_string) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ") in
-    let ineqs1 =
-      let uu___ =
-        FStar_Compiler_Effect.op_Bar_Greater
-          (FStar_Pervasives_Native.snd ineqs)
-          (FStar_Compiler_List.map
-             (fun uu___1 ->
-                match uu___1 with
-                | (u1, u2) ->
-                    let uu___2 = FStar_Syntax_Print.univ_to_string u1 in
-                    let uu___3 = FStar_Syntax_Print.univ_to_string u2 in
-                    FStar_Compiler_Util.format2 "%s < %s" uu___2 uu___3)) in
-      FStar_Compiler_Effect.op_Bar_Greater uu___ (FStar_String.concat ", ") in
-    FStar_Compiler_Util.format2 "Solving for {%s}; inequalities are {%s}"
-      vars ineqs1
-let (guard_to_string :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> Prims.string)
-  =
-  fun env ->
-    fun g ->
-      match ((g.FStar_TypeChecker_Common.guard_f),
-              (g.FStar_TypeChecker_Common.deferred),
-              (g.FStar_TypeChecker_Common.univ_ineqs))
-      with
-      | (FStar_TypeChecker_Common.Trivial, [], (uu___, [])) when
-          let uu___1 = FStar_Options.print_implicits () in
-          Prims.op_Negation uu___1 -> "{}"
-      | uu___ ->
-          let form =
-            match g.FStar_TypeChecker_Common.guard_f with
-            | FStar_TypeChecker_Common.Trivial -> "trivial"
-            | FStar_TypeChecker_Common.NonTrivial f ->
-                let uu___1 =
-                  ((FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_TypeChecker_Env.debug env)
-                      (FStar_Options.Other "Rel"))
-                     ||
-                     (FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_TypeChecker_Env.debug env)
-                        FStar_Options.Extreme))
-                    || (FStar_Options.print_implicits ()) in
-                if uu___1
-                then FStar_TypeChecker_Normalize.term_to_string env f
-                else "non-trivial" in
-          let carry defs =
-            let uu___1 =
-              FStar_Compiler_List.map
-                (fun uu___2 ->
-                   match uu___2 with
-                   | (uu___3, msg, x) ->
-                       let uu___4 =
-                         let uu___5 = prob_to_string env x in
-                         Prims.op_Hat ": " uu___5 in
-                       Prims.op_Hat msg uu___4) defs in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (FStar_String.concat ",\n") in
-          let imps = print_pending_implicits g in
-          let uu___1 = carry g.FStar_TypeChecker_Common.deferred in
-          let uu___2 = carry g.FStar_TypeChecker_Common.deferred_to_tac in
-          let uu___3 = ineqs_to_string g.FStar_TypeChecker_Common.univ_ineqs in
-          FStar_Compiler_Util.format5
-            "\n\t{guard_f=%s;\n\t deferred={\n%s};\n\t deferred_to_tac={\n%s};\n\t univ_ineqs={%s};\n\t implicits={%s}}\n"
-            form uu___1 uu___2 uu___3 imps
-let (new_t_problem :
-  worklist ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_TypeChecker_Common.rel ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-            FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-              FStar_Compiler_Range.range ->
-                (FStar_TypeChecker_Common.prob * worklist))
-  =
-  fun wl ->
-    fun env ->
-      fun lhs ->
-        fun rel ->
-          fun rhs ->
-            fun elt ->
-              fun loc ->
-                let reason =
-                  let uu___ =
-                    (FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                       (FStar_Options.Other "ExplainRel"))
-                      ||
-                      (FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                         (FStar_Options.Other "Rel")) in
-                  if uu___
-                  then
-                    let uu___1 =
-                      FStar_TypeChecker_Normalize.term_to_string env lhs in
-                    let uu___2 =
-                      FStar_TypeChecker_Normalize.term_to_string env rhs in
-                    FStar_Compiler_Util.format3 "Top-level:\n%s\n\t%s\n%s"
-                      uu___1 (rel_to_string rel) uu___2
-                  else "TOP" in
-                let uu___ = new_problem wl env lhs rel rhs elt loc reason in
-                match uu___ with
-                | (p, wl1) ->
-                    (def_check_prob (Prims.op_Hat "new_t_problem." reason)
-                       (FStar_TypeChecker_Common.TProb p);
-                     ((FStar_TypeChecker_Common.TProb p), wl1))
-let (new_t_prob :
-  worklist ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_TypeChecker_Common.rel ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-            (FStar_TypeChecker_Common.prob * FStar_Syntax_Syntax.bv *
-              worklist))
-  =
-  fun wl ->
-    fun env ->
-      fun t1 ->
-        fun rel ->
-          fun t2 ->
-            let x =
-              let uu___ =
-                let uu___1 = FStar_TypeChecker_Env.get_range env in
-                FStar_Compiler_Effect.op_Less_Bar
-                  (fun uu___2 -> FStar_Pervasives_Native.Some uu___2) uu___1 in
-              FStar_Syntax_Syntax.new_bv uu___ t1 in
-            let uu___ =
-              let uu___1 = FStar_TypeChecker_Env.get_range env in
-              new_t_problem wl env t1 rel t2 (FStar_Pervasives_Native.Some x)
-                uu___1 in
-            match uu___ with | (p, wl1) -> (p, x, wl1)
-let (solve_and_commit :
-  worklist ->
-    ((FStar_TypeChecker_Common.prob * lstring) ->
-       (FStar_TypeChecker_Common.deferred * FStar_TypeChecker_Common.deferred
-         * FStar_TypeChecker_Common.implicits) FStar_Pervasives_Native.option)
-      ->
-      (FStar_TypeChecker_Common.deferred * FStar_TypeChecker_Common.deferred
-        * FStar_TypeChecker_Common.implicits) FStar_Pervasives_Native.option)
-  =
-  fun wl ->
-    fun err ->
-      let tx = FStar_Syntax_Unionfind.new_transaction () in
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Less_Bar (debug wl)
-           (FStar_Options.Other "RelBench") in
-       if uu___1
-       then
-         let uu___2 =
-           (FStar_Common.string_of_list ())
-             (fun p -> FStar_Compiler_Util.string_of_int (p_pid p))
-             wl.attempting in
-         FStar_Compiler_Util.print1 "solving problems %s {\n" uu___2
-       else ());
-      (let uu___1 = FStar_Compiler_Util.record_time (fun uu___2 -> solve wl) in
-       match uu___1 with
-       | (sol, ms) ->
-           ((let uu___3 =
-               FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                 (FStar_Options.Other "RelBench") in
-             if uu___3
-             then
-               let uu___4 = FStar_Compiler_Util.string_of_int ms in
-               FStar_Compiler_Util.print1 "} solved in %s ms\n" uu___4
-             else ());
-            (match sol with
-             | Success (deferred, defer_to_tac, implicits) ->
-                 let uu___3 =
-                   FStar_Compiler_Util.record_time
-                     (fun uu___4 -> FStar_Syntax_Unionfind.commit tx) in
-                 (match uu___3 with
-                  | ((), ms1) ->
-                      ((let uu___5 =
-                          FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                            (FStar_Options.Other "RelBench") in
-                        if uu___5
-                        then
-                          let uu___6 = FStar_Compiler_Util.string_of_int ms1 in
-                          FStar_Compiler_Util.print1 "committed in %s ms\n"
-                            uu___6
-                        else ());
-                       FStar_Pervasives_Native.Some
-                         (deferred, defer_to_tac, implicits)))
-             | Failed (d, s) ->
-                 ((let uu___4 =
-                     (FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                        (FStar_Options.Other "ExplainRel"))
-                       ||
-                       (FStar_Compiler_Effect.op_Less_Bar (debug wl)
-                          (FStar_Options.Other "Rel")) in
-                   if uu___4
-                   then
-                     let uu___5 = explain wl d s in
-                     FStar_Compiler_Effect.op_Less_Bar
-                       FStar_Compiler_Util.print_string uu___5
-                   else ());
-                  (let result = err (d, s) in
-                   FStar_Syntax_Unionfind.rollback tx; result)))))
-let (with_guard :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.prob ->
-      (FStar_TypeChecker_Common.deferred * FStar_TypeChecker_Common.deferred
-        * FStar_TypeChecker_Common.implicits) FStar_Pervasives_Native.option
-        -> FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun prob ->
-      fun dopt ->
-        match dopt with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some (deferred, defer_to_tac, implicits) ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater (p_guard prob)
-                    (fun uu___3 -> FStar_TypeChecker_Common.NonTrivial uu___3) in
-                {
-                  FStar_TypeChecker_Common.guard_f = uu___2;
-                  FStar_TypeChecker_Common.deferred_to_tac = defer_to_tac;
-                  FStar_TypeChecker_Common.deferred = deferred;
-                  FStar_TypeChecker_Common.univ_ineqs = ([], []);
-                  FStar_TypeChecker_Common.implicits = implicits
-                } in
-              simplify_guard env uu___1 in
-            FStar_Compiler_Effect.op_Less_Bar
-              (fun uu___1 -> FStar_Pervasives_Native.Some uu___1) uu___
-let (try_teq :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun smt_ok ->
-    fun env ->
-      fun t1 ->
-        fun t2 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.current_module env in
-              FStar_Ident.string_of_lid uu___2 in
-            FStar_Pervasives_Native.Some uu___1 in
-          FStar_Profiling.profile
-            (fun uu___1 ->
-               (let uu___3 =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env)
-                    (FStar_Options.Other "Rel") in
-                if uu___3
-                then
-                  let uu___4 = FStar_Syntax_Print.term_to_string t1 in
-                  let uu___5 = FStar_Syntax_Print.term_to_string t2 in
-                  let uu___6 =
-                    FStar_TypeChecker_Env.print_gamma
-                      env.FStar_TypeChecker_Env.gamma in
-                  FStar_Compiler_Util.print3 "try_teq of %s and %s in %s {\n"
-                    uu___4 uu___5 uu___6
-                else ());
-               (let uu___3 =
-                  let uu___4 = FStar_TypeChecker_Env.get_range env in
-                  new_t_problem (empty_worklist env) env t1
-                    FStar_TypeChecker_Common.EQ t2
-                    FStar_Pervasives_Native.None uu___4 in
-                match uu___3 with
-                | (prob, wl) ->
-                    let g =
-                      let uu___4 =
-                        solve_and_commit (singleton wl prob smt_ok)
-                          (fun uu___5 -> FStar_Pervasives_Native.None) in
-                      FStar_Compiler_Effect.op_Less_Bar (with_guard env prob)
-                        uu___4 in
-                    ((let uu___5 =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_TypeChecker_Env.debug env)
-                          (FStar_Options.Other "Rel") in
-                      if uu___5
-                      then
-                        let uu___6 =
-                          FStar_Common.string_of_option (guard_to_string env)
-                            g in
-                        FStar_Compiler_Util.print1 "} res = %s\n" uu___6
-                      else ());
-                     g))) uu___ "FStar.TypeChecker.Rel.try_teq"
-let (teq :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ = try_teq true env t1 t2 in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            ((let uu___2 = FStar_TypeChecker_Env.get_range env in
-              let uu___3 =
-                FStar_TypeChecker_Err.basic_type_error env
-                  FStar_Pervasives_Native.None t2 t1 in
-              FStar_Errors.log_issue uu___2 uu___3);
-             FStar_TypeChecker_Common.trivial_guard)
-        | FStar_Pervasives_Native.Some g ->
-            ((let uu___2 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug env)
-                  (FStar_Options.Other "Rel") in
-              if uu___2
-              then
-                let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-                let uu___4 = FStar_Syntax_Print.term_to_string t2 in
-                let uu___5 = guard_to_string env g in
-                FStar_Compiler_Util.print3
-                  "teq of %s and %s succeeded with guard %s\n" uu___3 uu___4
-                  uu___5
-              else ());
-             g)
-let (get_teq_predicate :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar
-             (FStar_TypeChecker_Env.debug env) (FStar_Options.Other "Rel") in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-           let uu___3 = FStar_Syntax_Print.term_to_string t2 in
-           FStar_Compiler_Util.print2 "get_teq_predicate of %s and %s {\n"
-             uu___2 uu___3
-         else ());
-        (let uu___1 =
-           new_t_prob (empty_worklist env) env t1 FStar_TypeChecker_Common.EQ
-             t2 in
-         match uu___1 with
-         | (prob, x, wl) ->
-             let g =
-               let uu___2 =
-                 solve_and_commit (singleton wl prob true)
-                   (fun uu___3 -> FStar_Pervasives_Native.None) in
-               FStar_Compiler_Effect.op_Less_Bar (with_guard env prob) uu___2 in
-             ((let uu___3 =
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (FStar_TypeChecker_Env.debug env)
-                   (FStar_Options.Other "Rel") in
-               if uu___3
-               then
-                 let uu___4 =
-                   FStar_Common.string_of_option (guard_to_string env) g in
-                 FStar_Compiler_Util.print1 "} res teq predicate = %s\n"
-                   uu___4
-               else ());
-              (match g with
-               | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-               | FStar_Pervasives_Native.Some g1 ->
-                   let uu___3 =
-                     let uu___4 = FStar_Syntax_Syntax.mk_binder x in
-                     FStar_TypeChecker_Env.abstract_guard uu___4 g1 in
-                   FStar_Pervasives_Native.Some uu___3)))
-let (subtype_fail :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> unit)
-  =
-  fun env ->
-    fun e ->
-      fun t1 ->
-        fun t2 ->
-          let uu___ = FStar_TypeChecker_Env.get_range env in
-          let uu___1 =
-            FStar_TypeChecker_Err.basic_type_error env
-              (FStar_Pervasives_Native.Some e) t2 t1 in
-          FStar_Errors.log_issue uu___ uu___1
-let (sub_or_eq_comp :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_Syntax_Syntax.comp ->
-          FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun use_eq ->
-      fun c1 ->
-        fun c2 ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.current_module env in
-              FStar_Ident.string_of_lid uu___2 in
-            FStar_Pervasives_Native.Some uu___1 in
-          FStar_Profiling.profile
-            (fun uu___1 ->
-               let rel =
-                 if use_eq
-                 then FStar_TypeChecker_Common.EQ
-                 else FStar_TypeChecker_Common.SUB in
-               (let uu___3 =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env)
-                    (FStar_Options.Other "Rel") in
-                if uu___3
-                then
-                  let uu___4 = FStar_Syntax_Print.comp_to_string c1 in
-                  let uu___5 = FStar_Syntax_Print.comp_to_string c2 in
-                  FStar_Compiler_Util.print3
-                    "sub_comp of %s --and-- %s --with-- %s\n" uu___4 uu___5
-                    (if rel = FStar_TypeChecker_Common.EQ
-                     then "EQ"
-                     else "SUB")
-                else ());
-               (let uu___3 =
-                  let uu___4 = FStar_TypeChecker_Env.get_range env in
-                  new_problem (empty_worklist env) env c1 rel c2
-                    FStar_Pervasives_Native.None uu___4 "sub_comp" in
-                match uu___3 with
-                | (prob, wl) ->
-                    let wl1 =
-                      {
-                        attempting = (wl.attempting);
-                        wl_deferred = (wl.wl_deferred);
-                        wl_deferred_to_tac = (wl.wl_deferred_to_tac);
-                        ctr = (wl.ctr);
-                        defer_ok = (wl.defer_ok);
-                        smt_ok = (wl.smt_ok);
-                        umax_heuristic_ok = (wl.umax_heuristic_ok);
-                        tcenv = (wl.tcenv);
-                        wl_implicits = (wl.wl_implicits);
-                        repr_subcomp_allowed = true
-                      } in
-                    let prob1 = FStar_TypeChecker_Common.CProb prob in
-                    (def_check_prob "sub_comp" prob1;
-                     (let uu___5 =
-                        FStar_Compiler_Util.record_time
-                          (fun uu___6 ->
-                             let uu___7 =
-                               solve_and_commit (singleton wl1 prob1 true)
-                                 (fun uu___8 -> FStar_Pervasives_Native.None) in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               (with_guard env prob1) uu___7) in
-                      match uu___5 with
-                      | (r, ms) ->
-                          ((let uu___7 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug env)
-                                (FStar_Options.Other "RelBench") in
-                            if uu___7
-                            then
-                              let uu___8 =
-                                FStar_Syntax_Print.comp_to_string c1 in
-                              let uu___9 =
-                                FStar_Syntax_Print.comp_to_string c2 in
-                              let uu___10 =
-                                FStar_Compiler_Util.string_of_int ms in
-                              FStar_Compiler_Util.print4
-                                "sub_comp of %s --and-- %s --with-- %s --- solved in %s ms\n"
-                                uu___8 uu___9
-                                (if rel = FStar_TypeChecker_Common.EQ
-                                 then "EQ"
-                                 else "SUB") uu___10
-                            else ());
-                           r))))) uu___ "FStar.TypeChecker.Rel.sub_comp"
-let (sub_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun c1 ->
-      fun c2 ->
-        FStar_Errors.with_ctx "While trying to subtype computation types"
-          (fun uu___ ->
-             FStar_TypeChecker_Env.def_check_comp_closed_in_env
-               c1.FStar_Syntax_Syntax.pos "sub_comp c1" env c1;
-             FStar_TypeChecker_Env.def_check_comp_closed_in_env
-               c2.FStar_Syntax_Syntax.pos "sub_comp c2" env c2;
-             sub_or_eq_comp env false c1 c2)
-let (eq_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun c1 ->
-      fun c2 ->
-        FStar_Errors.with_ctx "While trying to equate computation types"
-          (fun uu___ ->
-             FStar_TypeChecker_Env.def_check_comp_closed_in_env
-               c1.FStar_Syntax_Syntax.pos "sub_comp c1" env c1;
-             FStar_TypeChecker_Env.def_check_comp_closed_in_env
-               c2.FStar_Syntax_Syntax.pos "sub_comp c2" env c2;
-             sub_or_eq_comp env true c1 c2)
-let (solve_universe_inequalities' :
-  FStar_Syntax_Unionfind.tx ->
-    FStar_TypeChecker_Env.env ->
-      (FStar_Syntax_Syntax.universe Prims.list *
-        (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.universe)
-        Prims.list) -> unit)
-  =
-  fun tx ->
-    fun env ->
-      fun uu___ ->
-        match uu___ with
-        | (variables, ineqs) ->
-            let fail u1 u2 =
-              FStar_Syntax_Unionfind.rollback tx;
-              (let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Print.univ_to_string u1 in
-                   let uu___5 = FStar_Syntax_Print.univ_to_string u2 in
-                   FStar_Compiler_Util.format2
-                     "Universe %s and %s are incompatible" uu___4 uu___5 in
-                 (FStar_Errors.Fatal_IncompatibleUniverse, uu___3) in
-               let uu___3 = FStar_TypeChecker_Env.get_range env in
-               FStar_Errors.raise_error uu___2 uu___3) in
-            let equiv v v' =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Subst.compress_univ v in
-                let uu___3 = FStar_Syntax_Subst.compress_univ v' in
-                (uu___2, uu___3) in
-              match uu___1 with
-              | (FStar_Syntax_Syntax.U_unif v0, FStar_Syntax_Syntax.U_unif
-                 v0') -> FStar_Syntax_Unionfind.univ_equiv v0 v0'
-              | uu___2 -> false in
-            let sols =
-              FStar_Compiler_Effect.op_Bar_Greater variables
-                (FStar_Compiler_List.collect
-                   (fun v ->
-                      let uu___1 = FStar_Syntax_Subst.compress_univ v in
-                      match uu___1 with
-                      | FStar_Syntax_Syntax.U_unif uu___2 ->
-                          let lower_bounds_of_v =
-                            FStar_Compiler_Effect.op_Bar_Greater ineqs
-                              (FStar_Compiler_List.collect
-                                 (fun uu___3 ->
-                                    match uu___3 with
-                                    | (u, v') ->
-                                        let uu___4 = equiv v v' in
-                                        if uu___4
-                                        then
-                                          let uu___5 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              variables
-                                              (FStar_Compiler_Util.for_some
-                                                 (equiv u)) in
-                                          (if uu___5 then [] else [u])
-                                        else [])) in
-                          let lb =
-                            FStar_TypeChecker_Normalize.normalize_universe
-                              env
-                              (FStar_Syntax_Syntax.U_max lower_bounds_of_v) in
-                          [(lb, v)]
-                      | uu___2 -> [])) in
-            let uu___1 =
-              let wl =
-                let uu___2 = empty_worklist env in
-                {
-                  attempting = (uu___2.attempting);
-                  wl_deferred = (uu___2.wl_deferred);
-                  wl_deferred_to_tac = (uu___2.wl_deferred_to_tac);
-                  ctr = (uu___2.ctr);
-                  defer_ok = NoDefer;
-                  smt_ok = (uu___2.smt_ok);
-                  umax_heuristic_ok = (uu___2.umax_heuristic_ok);
-                  tcenv = (uu___2.tcenv);
-                  wl_implicits = (uu___2.wl_implicits);
-                  repr_subcomp_allowed = (uu___2.repr_subcomp_allowed)
-                } in
-              FStar_Compiler_Effect.op_Bar_Greater sols
-                (FStar_Compiler_List.map
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (lb, v) ->
-                          let uu___3 =
-                            solve_universe_eq (~- Prims.int_one) wl lb v in
-                          (match uu___3 with
-                           | USolved wl1 -> ()
-                           | uu___4 -> fail lb v))) in
-            let rec check_ineq uu___2 =
-              match uu___2 with
-              | (u, v) ->
-                  let u1 =
-                    FStar_TypeChecker_Normalize.normalize_universe env u in
-                  let v1 =
-                    FStar_TypeChecker_Normalize.normalize_universe env v in
-                  (match (u1, v1) with
-                   | (FStar_Syntax_Syntax.U_zero, uu___3) -> true
-                   | (FStar_Syntax_Syntax.U_succ u0,
-                      FStar_Syntax_Syntax.U_succ v0) -> check_ineq (u0, v0)
-                   | (FStar_Syntax_Syntax.U_name u0,
-                      FStar_Syntax_Syntax.U_name v0) ->
-                       FStar_Ident.ident_equals u0 v0
-                   | (FStar_Syntax_Syntax.U_unif u0,
-                      FStar_Syntax_Syntax.U_unif v0) ->
-                       FStar_Syntax_Unionfind.univ_equiv u0 v0
-                   | (FStar_Syntax_Syntax.U_name uu___3,
-                      FStar_Syntax_Syntax.U_succ v0) -> check_ineq (u1, v0)
-                   | (FStar_Syntax_Syntax.U_unif uu___3,
-                      FStar_Syntax_Syntax.U_succ v0) -> check_ineq (u1, v0)
-                   | (FStar_Syntax_Syntax.U_max us, uu___3) ->
-                       FStar_Compiler_Effect.op_Bar_Greater us
-                         (FStar_Compiler_Util.for_all
-                            (fun u2 -> check_ineq (u2, v1)))
-                   | (uu___3, FStar_Syntax_Syntax.U_max vs) ->
-                       FStar_Compiler_Effect.op_Bar_Greater vs
-                         (FStar_Compiler_Util.for_some
-                            (fun v2 -> check_ineq (u1, v2)))
-                   | uu___3 -> false) in
-            let uu___2 =
-              FStar_Compiler_Effect.op_Bar_Greater ineqs
-                (FStar_Compiler_Util.for_all
-                   (fun uu___3 ->
-                      match uu___3 with
-                      | (u, v) ->
-                          let uu___4 = check_ineq (u, v) in
-                          if uu___4
-                          then true
-                          else
-                            ((let uu___7 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env)
-                                  (FStar_Options.Other "GenUniverses") in
-                              if uu___7
-                              then
-                                let uu___8 =
-                                  FStar_Syntax_Print.univ_to_string u in
-                                let uu___9 =
-                                  FStar_Syntax_Print.univ_to_string v in
-                                FStar_Compiler_Util.print2 "%s </= %s" uu___8
-                                  uu___9
-                              else ());
-                             false))) in
-            if uu___2
-            then ()
-            else
-              ((let uu___5 =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env)
-                    (FStar_Options.Other "GenUniverses") in
-                if uu___5
-                then
-                  ((let uu___7 = ineqs_to_string (variables, ineqs) in
-                    FStar_Compiler_Util.print1
-                      "Partially solved inequality constraints are: %s\n"
-                      uu___7);
-                   FStar_Syntax_Unionfind.rollback tx;
-                   (let uu___8 = ineqs_to_string (variables, ineqs) in
-                    FStar_Compiler_Util.print1
-                      "Original solved inequality constraints are: %s\n"
-                      uu___8))
-                else ());
-               (let uu___5 = FStar_TypeChecker_Env.get_range env in
-                FStar_Errors.raise_error
-                  (FStar_Errors.Fatal_FailToSolveUniverseInEquality,
-                    "Failed to solve universe inequalities for inductives")
-                  uu___5))
-let (solve_universe_inequalities :
-  FStar_TypeChecker_Env.env ->
-    (FStar_Syntax_Syntax.universe Prims.list * (FStar_Syntax_Syntax.universe
-      * FStar_Syntax_Syntax.universe) Prims.list) -> unit)
-  =
-  fun env ->
-    fun ineqs ->
-      let tx = FStar_Syntax_Unionfind.new_transaction () in
-      solve_universe_inequalities' tx env ineqs;
-      FStar_Syntax_Unionfind.commit tx
-let (try_solve_deferred_constraints :
-  defer_ok_t ->
-    Prims.bool ->
-      Prims.bool ->
-        FStar_TypeChecker_Env.env ->
-          FStar_TypeChecker_Common.guard_t ->
-            FStar_TypeChecker_Common.guard_t)
-  =
-  fun defer_ok ->
-    fun smt_ok ->
-      fun deferred_to_tac_ok ->
-        fun env ->
-          fun g ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_TypeChecker_Env.current_module env in
-                FStar_Ident.string_of_lid uu___2 in
-              FStar_Pervasives_Native.Some uu___1 in
-            FStar_Profiling.profile
-              (fun uu___1 ->
-                 let wl =
-                   let uu___2 =
-                     wl_of_guard env g.FStar_TypeChecker_Common.deferred in
-                   {
-                     attempting = (uu___2.attempting);
-                     wl_deferred = (uu___2.wl_deferred);
-                     wl_deferred_to_tac = (uu___2.wl_deferred_to_tac);
-                     ctr = (uu___2.ctr);
-                     defer_ok;
-                     smt_ok;
-                     umax_heuristic_ok = (uu___2.umax_heuristic_ok);
-                     tcenv = (uu___2.tcenv);
-                     wl_implicits = (uu___2.wl_implicits);
-                     repr_subcomp_allowed = (uu___2.repr_subcomp_allowed)
-                   } in
-                 let fail uu___2 =
-                   match uu___2 with
-                   | (d, s) ->
-                       let msg = explain wl d s in
-                       FStar_Errors.raise_error
-                         (FStar_Errors.Fatal_ErrorInSolveDeferredConstraints,
-                           msg) (p_loc d) in
-                 (let uu___3 =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_TypeChecker_Env.debug env)
-                      (FStar_Options.Other "Rel") in
-                  if uu___3
-                  then
-                    let uu___4 =
-                      FStar_Compiler_Util.string_of_bool deferred_to_tac_ok in
-                    let uu___5 = wl_to_string wl in
-                    let uu___6 =
-                      FStar_Compiler_Util.string_of_int
-                        (FStar_Compiler_List.length
-                           g.FStar_TypeChecker_Common.implicits) in
-                    FStar_Compiler_Util.print4
-                      "Trying to solve carried problems (defer_ok=%s) (deferred_to_tac_ok=%s): begin\n\t%s\nend\n and %s implicits\n"
-                      (string_of_defer_ok defer_ok) uu___4 uu___5 uu___6
-                  else ());
-                 (let g1 =
-                    let uu___3 = solve_and_commit wl fail in
-                    match uu___3 with
-                    | FStar_Pervasives_Native.Some
-                        (uu___4::uu___5, uu___6, uu___7) when
-                        defer_ok = NoDefer ->
-                        failwith
-                          "Impossible: Unexpected deferred constraints remain"
-                    | FStar_Pervasives_Native.Some
-                        (deferred, defer_to_tac, imps) ->
-                        {
-                          FStar_TypeChecker_Common.guard_f =
-                            (g.FStar_TypeChecker_Common.guard_f);
-                          FStar_TypeChecker_Common.deferred_to_tac =
-                            (FStar_Compiler_List.op_At
-                               g.FStar_TypeChecker_Common.deferred_to_tac
-                               defer_to_tac);
-                          FStar_TypeChecker_Common.deferred = deferred;
-                          FStar_TypeChecker_Common.univ_ineqs =
-                            (g.FStar_TypeChecker_Common.univ_ineqs);
-                          FStar_TypeChecker_Common.implicits =
-                            (FStar_Compiler_List.op_At
-                               g.FStar_TypeChecker_Common.implicits imps)
-                        }
-                    | uu___4 ->
-                        failwith
-                          "Impossible: should have raised a failure already" in
-                  solve_universe_inequalities env
-                    g1.FStar_TypeChecker_Common.univ_ineqs;
-                  (let g2 =
-                     if deferred_to_tac_ok
-                     then
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 =
-                             FStar_TypeChecker_Env.current_module env in
-                           FStar_Ident.string_of_lid uu___6 in
-                         FStar_Pervasives_Native.Some uu___5 in
-                       FStar_Profiling.profile
-                         (fun uu___5 ->
-                            FStar_TypeChecker_DeferredImplicits.solve_deferred_to_tactic_goals
-                              env g1) uu___4
-                         "FStar.TypeChecker.Rel.solve_deferred_to_tactic_goals"
-                     else g1 in
-                   (let uu___5 =
-                      FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_TypeChecker_Env.debug env)
-                        (FStar_Options.Other "ResolveImplicitsHook") in
-                    if uu___5
-                    then
-                      let uu___6 = guard_to_string env g2 in
-                      let uu___7 =
-                        FStar_Compiler_Util.string_of_int
-                          (FStar_Compiler_List.length
-                             g2.FStar_TypeChecker_Common.implicits) in
-                      FStar_Compiler_Util.print2
-                        "ResolveImplicitsHook: Solved deferred to tactic goals, remaining guard is\n%s (and %s implicits)\n"
-                        uu___6 uu___7
-                    else ());
-                   {
-                     FStar_TypeChecker_Common.guard_f =
-                       (g2.FStar_TypeChecker_Common.guard_f);
-                     FStar_TypeChecker_Common.deferred_to_tac =
-                       (g2.FStar_TypeChecker_Common.deferred_to_tac);
-                     FStar_TypeChecker_Common.deferred =
-                       (g2.FStar_TypeChecker_Common.deferred);
-                     FStar_TypeChecker_Common.univ_ineqs = ([], []);
-                     FStar_TypeChecker_Common.implicits =
-                       (g2.FStar_TypeChecker_Common.implicits)
-                   }))) uu___
-              "FStar.TypeChecker.Rel.try_solve_deferred_constraints"
-let (solve_deferred_constraints :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      let defer_ok = NoDefer in
-      let smt_ok = true in
-      let deferred_to_tac_ok = true in
-      try_solve_deferred_constraints defer_ok smt_ok deferred_to_tac_ok env g
-let (solve_non_tactic_deferred_constraints :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun maybe_defer_flex_flex ->
-    fun env ->
-      fun g ->
-        let defer_ok =
-          if maybe_defer_flex_flex then DeferFlexFlexOnly else NoDefer in
-        let smt_ok = true in
-        let deferred_to_tac_ok = false in
-        try_solve_deferred_constraints defer_ok smt_ok deferred_to_tac_ok env
-          g
-let (discharge_guard' :
-  (unit -> Prims.string) FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.env ->
-      FStar_TypeChecker_Common.guard_t ->
-        Prims.bool ->
-          FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun use_env_range_msg ->
-    fun env ->
-      fun g ->
-        fun use_smt ->
-          let debug1 =
-            ((FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env) (FStar_Options.Other "Rel"))
-               ||
-               (FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug env)
-                  (FStar_Options.Other "SMTQuery")))
-              ||
-              (FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env)
-                 (FStar_Options.Other "Tac")) in
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_TypeChecker_Env.debug env)
-               (FStar_Options.Other "ResolveImplicitsHook") in
-           if uu___1
-           then
-             let uu___2 = guard_to_string env g in
-             FStar_Compiler_Util.print1
-               "///////////////////ResolveImplicitsHook: discharge_guard'\nguard = %s\n"
-               uu___2
-           else ());
-          (let g1 =
-             let defer_ok = NoDefer in
-             let deferred_to_tac_ok = true in
-             try_solve_deferred_constraints defer_ok use_smt
-               deferred_to_tac_ok env g in
-           let ret_g =
-             {
-               FStar_TypeChecker_Common.guard_f =
-                 FStar_TypeChecker_Common.Trivial;
-               FStar_TypeChecker_Common.deferred_to_tac =
-                 (g1.FStar_TypeChecker_Common.deferred_to_tac);
-               FStar_TypeChecker_Common.deferred =
-                 (g1.FStar_TypeChecker_Common.deferred);
-               FStar_TypeChecker_Common.univ_ineqs =
-                 (g1.FStar_TypeChecker_Common.univ_ineqs);
-               FStar_TypeChecker_Common.implicits =
-                 (g1.FStar_TypeChecker_Common.implicits)
-             } in
-           let uu___1 =
-             let uu___2 = FStar_TypeChecker_Env.should_verify env in
-             Prims.op_Negation uu___2 in
-           if uu___1
-           then FStar_Pervasives_Native.Some ret_g
-           else
-             (match g1.FStar_TypeChecker_Common.guard_f with
-              | FStar_TypeChecker_Common.Trivial ->
-                  FStar_Pervasives_Native.Some ret_g
-              | FStar_TypeChecker_Common.NonTrivial vc ->
-                  (if debug1
-                   then
-                     (let uu___4 = FStar_TypeChecker_Env.get_range env in
-                      let uu___5 =
-                        let uu___6 = FStar_Syntax_Print.term_to_string vc in
-                        FStar_Compiler_Util.format1
-                          "Before normalization VC=\n%s\n" uu___6 in
-                      FStar_Errors.diag uu___4 uu___5)
-                   else ();
-                   (let vc1 =
-                      let uu___4 =
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_TypeChecker_Env.current_module env in
-                          FStar_Ident.string_of_lid uu___6 in
-                        FStar_Pervasives_Native.Some uu___5 in
-                      FStar_Profiling.profile
-                        (fun uu___5 ->
-                           FStar_TypeChecker_Normalize.normalize
-                             [FStar_TypeChecker_Env.Eager_unfolding;
-                             FStar_TypeChecker_Env.Simplify;
-                             FStar_TypeChecker_Env.Primops] env vc) uu___4
-                        "FStar.TypeChecker.Rel.vc_normalization" in
-                    if debug1
-                    then
-                      (let uu___5 = FStar_TypeChecker_Env.get_range env in
-                       let uu___6 =
-                         let uu___7 = FStar_Syntax_Print.term_to_string vc1 in
-                         FStar_Compiler_Util.format1
-                           "After normalization VC=\n%s\n" uu___7 in
-                       FStar_Errors.diag uu___5 uu___6)
-                    else ();
-                    (let uu___6 = FStar_TypeChecker_Env.get_range env in
-                     FStar_TypeChecker_Env.def_check_closed_in_env uu___6
-                       "discharge_guard'" env vc1);
-                    (let uu___6 = FStar_TypeChecker_Common.check_trivial vc1 in
-                     match uu___6 with
-                     | FStar_TypeChecker_Common.Trivial ->
-                         FStar_Pervasives_Native.Some ret_g
-                     | FStar_TypeChecker_Common.NonTrivial vc2 ->
-                         if Prims.op_Negation use_smt
-                         then
-                           (if debug1
-                            then
-                              (let uu___8 =
-                                 FStar_TypeChecker_Env.get_range env in
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_Syntax_Print.term_to_string vc2 in
-                                 FStar_Compiler_Util.format1
-                                   "Cannot solve without SMT : %s\n" uu___10 in
-                               FStar_Errors.diag uu___8 uu___9)
-                            else ();
-                            FStar_Pervasives_Native.None)
-                         else
-                           (if debug1
-                            then
-                              (let uu___10 =
-                                 FStar_TypeChecker_Env.get_range env in
-                               let uu___11 =
-                                 let uu___12 =
-                                   FStar_Syntax_Print.term_to_string vc2 in
-                                 FStar_Compiler_Util.format1
-                                   "Checking VC=\n%s\n" uu___12 in
-                               FStar_Errors.diag uu___10 uu___11)
-                            else ();
-                            (let vcs =
-                               let uu___10 = FStar_Options.use_tactics () in
-                               if uu___10
-                               then
-                                 FStar_Options.with_saved_options
-                                   (fun uu___11 ->
-                                      (let uu___13 =
-                                         FStar_Options.set_options
-                                           "--no_tactics" in
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         (fun uu___14 -> ()) uu___13);
-                                      (let vcs1 =
-                                         (env.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.preprocess
-                                           env vc2 in
-                                       (let uu___14 =
-                                          FStar_Options.profile_enabled
-                                            FStar_Pervasives_Native.None
-                                            "FStar.TypeChecker" in
-                                        if uu___14
-                                        then
-                                          let uu___15 =
-                                            FStar_Compiler_Util.string_of_int
-                                              (FStar_Compiler_List.length
-                                                 vcs1) in
-                                          FStar_Compiler_Util.print1
-                                            "Tactic preprocessing produced %s goals\n"
-                                            uu___15
-                                        else ());
-                                       (let vcs2 =
-                                          FStar_Compiler_List.map
-                                            (fun uu___14 ->
-                                               match uu___14 with
-                                               | (env1, goal, opts) ->
-                                                   let uu___15 =
-                                                     norm_with_steps
-                                                       "FStar.TypeChecker.Rel.norm_with_steps.7"
-                                                       [FStar_TypeChecker_Env.Simplify;
-                                                       FStar_TypeChecker_Env.Primops]
-                                                       env1 goal in
-                                                   (env1, uu___15, opts))
-                                            vcs1 in
-                                        let vcs3 =
-                                          FStar_Compiler_List.map
-                                            (fun uu___14 ->
-                                               match uu___14 with
-                                               | (env1, goal, opts) ->
-                                                   let uu___15 =
-                                                     (env1.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.handle_smt_goal
-                                                       env1 goal in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___15
-                                                     (FStar_Compiler_List.map
-                                                        (fun uu___16 ->
-                                                           match uu___16 with
-                                                           | (env2, goal1) ->
-                                                               (env2, goal1,
-                                                                 opts))))
-                                            vcs2 in
-                                        FStar_Compiler_List.flatten vcs3)))
-                               else
-                                 (let uu___12 =
-                                    let uu___13 = FStar_Options.peek () in
-                                    (env, vc2, uu___13) in
-                                  [uu___12]) in
-                             let vcs1 =
-                               let uu___10 = FStar_Options.split_queries () in
-                               if uu___10
-                               then
-                                 FStar_Compiler_Effect.op_Bar_Greater vcs
-                                   (FStar_Compiler_List.collect
-                                      (fun uu___11 ->
-                                         match uu___11 with
-                                         | (env1, goal, opts) ->
-                                             let uu___12 =
-                                               FStar_TypeChecker_Env.split_smt_query
-                                                 env1 goal in
-                                             (match uu___12 with
-                                              | FStar_Pervasives_Native.None
-                                                  -> [(env1, goal, opts)]
-                                              | FStar_Pervasives_Native.Some
-                                                  goals ->
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    goals
-                                                    (FStar_Compiler_List.map
-                                                       (fun uu___13 ->
-                                                          match uu___13 with
-                                                          | (env2, goal1) ->
-                                                              (env2, goal1,
-                                                                opts))))))
-                               else vcs in
-                             FStar_Compiler_Effect.op_Bar_Greater vcs1
-                               (FStar_Compiler_List.iter
-                                  (fun uu___10 ->
-                                     match uu___10 with
-                                     | (env1, goal, opts) ->
-                                         let uu___11 =
-                                           FStar_TypeChecker_Common.check_trivial
-                                             goal in
-                                         (match uu___11 with
-                                          | FStar_TypeChecker_Common.Trivial
-                                              ->
-                                              if debug1
-                                              then
-                                                FStar_Compiler_Util.print_string
-                                                  "Goal completely solved by tactic\n"
-                                              else ()
-                                          | FStar_TypeChecker_Common.NonTrivial
-                                              goal1 ->
-                                              (FStar_Options.push ();
-                                               FStar_Options.set opts;
-                                               if debug1
-                                               then
-                                                 (let uu___15 =
-                                                    FStar_TypeChecker_Env.get_range
-                                                      env1 in
-                                                  let uu___16 =
-                                                    let uu___17 =
-                                                      FStar_Syntax_Print.term_to_string
-                                                        goal1 in
-                                                    let uu___18 =
-                                                      FStar_TypeChecker_Env.string_of_proof_ns
-                                                        env1 in
-                                                    FStar_Compiler_Util.format2
-                                                      "Trying to solve:\n> %s\nWith proof_ns:\n %s\n"
-                                                      uu___17 uu___18 in
-                                                  FStar_Errors.diag uu___15
-                                                    uu___16)
-                                               else ();
-                                               if debug1
-                                               then
-                                                 (let uu___16 =
-                                                    FStar_TypeChecker_Env.get_range
-                                                      env1 in
-                                                  let uu___17 =
-                                                    let uu___18 =
-                                                      FStar_Syntax_Print.term_to_string
-                                                        goal1 in
-                                                    FStar_Compiler_Util.format1
-                                                      "Before calling solver VC=\n%s\n"
-                                                      uu___18 in
-                                                  FStar_Errors.diag uu___16
-                                                    uu___17)
-                                               else ();
-                                               (env1.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.solve
-                                                 use_env_range_msg env1 goal1;
-                                               FStar_Options.pop ())))));
-                            FStar_Pervasives_Native.Some ret_g))))))
-let (discharge_guard_no_smt :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      let uu___ = discharge_guard' FStar_Pervasives_Native.None env g false in
-      match uu___ with
-      | FStar_Pervasives_Native.Some g1 -> g1
-      | FStar_Pervasives_Native.None ->
-          let uu___1 = FStar_TypeChecker_Env.get_range env in
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_ExpectTrivialPreCondition,
-              "Expected a trivial pre-condition") uu___1
-let (discharge_guard :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      let uu___ = discharge_guard' FStar_Pervasives_Native.None env g true in
-      match uu___ with
-      | FStar_Pervasives_Native.Some g1 -> g1
-      | FStar_Pervasives_Native.None ->
-          failwith
-            "Impossible, with use_smt = true, discharge_guard' should never have returned None"
-let (teq_nosmt :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ = try_teq false env t1 t2 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-        | FStar_Pervasives_Native.Some g ->
-            discharge_guard' FStar_Pervasives_Native.None env g false
-let (subtype_nosmt :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar
-             (FStar_TypeChecker_Env.debug env) (FStar_Options.Other "Rel") in
-         if uu___1
-         then
-           let uu___2 = FStar_TypeChecker_Normalize.term_to_string env t1 in
-           let uu___3 = FStar_TypeChecker_Normalize.term_to_string env t2 in
-           FStar_Compiler_Util.print2 "try_subtype_no_smt of %s and %s\n"
-             uu___2 uu___3
-         else ());
-        (let uu___1 =
-           new_t_prob (empty_worklist env) env t1
-             FStar_TypeChecker_Common.SUB t2 in
-         match uu___1 with
-         | (prob, x, wl) ->
-             let g =
-               let uu___2 =
-                 solve_and_commit (singleton wl prob false)
-                   (fun uu___3 -> FStar_Pervasives_Native.None) in
-               FStar_Compiler_Effect.op_Less_Bar (with_guard env prob) uu___2 in
-             (match g with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some g1 ->
-                  let g2 =
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___3] in
-                    FStar_TypeChecker_Env.close_guard env uu___2 g1 in
-                  discharge_guard' FStar_Pervasives_Native.None env g2 false))
-let (check_subtyping :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        (FStar_Syntax_Syntax.bv * FStar_TypeChecker_Common.guard_t)
-          FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_TypeChecker_Env.current_module env in
-            FStar_Ident.string_of_lid uu___2 in
-          FStar_Pervasives_Native.Some uu___1 in
-        FStar_Profiling.profile
-          (fun uu___1 ->
-             (let uu___3 =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug env)
-                  (FStar_Options.Other "Rel") in
-              if uu___3
-              then
-                let uu___4 =
-                  FStar_TypeChecker_Normalize.term_to_string env t1 in
-                let uu___5 =
-                  FStar_TypeChecker_Normalize.term_to_string env t2 in
-                FStar_Compiler_Util.print2 "check_subtyping of %s and %s\n"
-                  uu___4 uu___5
-              else ());
-             (let uu___3 =
-                new_t_prob (empty_worklist env) env t1
-                  FStar_TypeChecker_Common.SUB t2 in
-              match uu___3 with
-              | (prob, x, wl) ->
-                  let g =
-                    let uu___4 =
-                      solve_and_commit (singleton wl prob true)
-                        (fun uu___5 -> FStar_Pervasives_Native.None) in
-                    FStar_Compiler_Effect.op_Less_Bar (with_guard env prob)
-                      uu___4 in
-                  ((let uu___5 =
-                      (FStar_Compiler_Effect.op_Less_Bar
-                         (FStar_TypeChecker_Env.debug env)
-                         (FStar_Options.Other "Rel"))
-                        && (FStar_Compiler_Util.is_some g) in
-                    if uu___5
-                    then
-                      let uu___6 =
-                        FStar_TypeChecker_Normalize.term_to_string env t1 in
-                      let uu___7 =
-                        FStar_TypeChecker_Normalize.term_to_string env t2 in
-                      let uu___8 =
-                        let uu___9 = FStar_Compiler_Util.must g in
-                        guard_to_string env uu___9 in
-                      FStar_Compiler_Util.print3
-                        "check_subtyping succeeded: %s <: %s\n\tguard is %s\n"
-                        uu___6 uu___7 uu___8
-                    else ());
-                   (match g with
-                    | FStar_Pervasives_Native.None ->
-                        FStar_Pervasives_Native.None
-                    | FStar_Pervasives_Native.Some g1 ->
-                        FStar_Pervasives_Native.Some (x, g1))))) uu___
-          "FStar.TypeChecker.Rel.check_subtyping"
-let (get_subtyping_predicate :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        FStar_Errors.with_ctx "While trying to get a subtyping predicate"
-          (fun uu___ ->
-             FStar_TypeChecker_Env.def_check_closed_in_env
-               t1.FStar_Syntax_Syntax.pos "get_subtyping_predicate.1" env t1;
-             FStar_TypeChecker_Env.def_check_closed_in_env
-               t2.FStar_Syntax_Syntax.pos "get_subtyping_predicate.2" env t2;
-             (let uu___3 = check_subtyping env t1 t2 in
-              match uu___3 with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some (x, g) ->
-                  let uu___4 =
-                    let uu___5 = FStar_Syntax_Syntax.mk_binder x in
-                    FStar_TypeChecker_Env.abstract_guard uu___5 g in
-                  FStar_Pervasives_Native.Some uu___4))
-let (get_subtyping_prop :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_TypeChecker_Common.guard_t FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        FStar_Errors.with_ctx "While trying to get a subtyping proposition"
-          (fun uu___ ->
-             FStar_TypeChecker_Env.def_check_closed_in_env
-               t1.FStar_Syntax_Syntax.pos "get_subtyping_prop.1" env t1;
-             FStar_TypeChecker_Env.def_check_closed_in_env
-               t2.FStar_Syntax_Syntax.pos "get_subtyping_prop.2" env t2;
-             (let uu___3 = check_subtyping env t1 t2 in
-              match uu___3 with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some (x, g) ->
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Syntax.mk_binder x in
-                      [uu___6] in
-                    FStar_TypeChecker_Env.close_guard env uu___5 g in
-                  FStar_Pervasives_Native.Some uu___4))
-let (try_solve_single_valued_implicits :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_TypeChecker_Env.implicits ->
-        (FStar_TypeChecker_Env.implicits * Prims.bool))
-  =
-  fun env ->
-    fun is_tac ->
-      fun imps ->
-        if is_tac
-        then (imps, false)
-        else
-          (let imp_value imp =
-             let uu___1 =
-               ((imp.FStar_TypeChecker_Common.imp_uvar),
-                 (imp.FStar_TypeChecker_Common.imp_range)) in
-             match uu___1 with
-             | (ctx_u, r) ->
-                 let t_norm =
-                   let uu___2 = FStar_Syntax_Util.ctx_uvar_typ ctx_u in
-                   FStar_TypeChecker_Normalize.normalize
-                     FStar_TypeChecker_Normalize.whnf_steps env uu___2 in
-                 let uu___2 =
-                   let uu___3 = FStar_Syntax_Subst.compress t_norm in
-                   uu___3.FStar_Syntax_Syntax.n in
-                 (match uu___2 with
-                  | FStar_Syntax_Syntax.Tm_fvar fv when
-                      FStar_Syntax_Syntax.fv_eq_lid fv
-                        FStar_Parser_Const.unit_lid
-                      ->
-                      let uu___3 =
-                        FStar_Compiler_Effect.op_Bar_Greater r
-                          FStar_Syntax_Syntax.unit_const_with_range in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___3
-                        (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                  | FStar_Syntax_Syntax.Tm_refine (b, uu___3) when
-                      FStar_Syntax_Util.is_unit b.FStar_Syntax_Syntax.sort ->
-                      let uu___4 =
-                        FStar_Compiler_Effect.op_Bar_Greater r
-                          FStar_Syntax_Syntax.unit_const_with_range in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___4
-                        (fun uu___5 -> FStar_Pervasives_Native.Some uu___5)
-                  | uu___3 -> FStar_Pervasives_Native.None) in
-           let b =
-             FStar_Compiler_List.fold_left
-               (fun b1 ->
-                  fun imp ->
-                    let uu___1 =
-                      (let uu___2 =
-                         FStar_Syntax_Unionfind.find
-                           (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___2
-                         FStar_Compiler_Util.is_none)
-                        &&
-                        (let uu___2 =
-                           FStar_Syntax_Util.ctx_uvar_should_check
-                             imp.FStar_TypeChecker_Common.imp_uvar in
-                         uu___2 = FStar_Syntax_Syntax.Strict) in
-                    if uu___1
-                    then
-                      let uu___2 = imp_value imp in
-                      match uu___2 with
-                      | FStar_Pervasives_Native.Some tm ->
-                          (commit env
-                             [TERM
-                                ((imp.FStar_TypeChecker_Common.imp_uvar), tm)];
-                           true)
-                      | FStar_Pervasives_Native.None -> b1
-                    else b1) false imps in
-           (imps, b))
-let (check_implicit_solution_and_discharge_guard :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.implicit ->
-      Prims.bool ->
-        Prims.bool ->
-          FStar_TypeChecker_Env.implicits FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun imp ->
-      fun is_tac ->
-        fun force_univ_constraints ->
-          let uu___ = imp in
-          match uu___ with
-          | { FStar_TypeChecker_Common.imp_reason = imp_reason;
-              FStar_TypeChecker_Common.imp_uvar = imp_uvar;
-              FStar_TypeChecker_Common.imp_tm = imp_tm;
-              FStar_TypeChecker_Common.imp_range = imp_range;_} ->
-              let uvar_ty = FStar_Syntax_Util.ctx_uvar_typ imp_uvar in
-              let uvar_should_check =
-                FStar_Syntax_Util.ctx_uvar_should_check imp_uvar in
-              ((let uu___2 =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env)
-                    (FStar_Options.Other "Rel") in
-                if uu___2
-                then
-                  let uu___3 =
-                    FStar_Syntax_Print.uvar_to_string
-                      imp_uvar.FStar_Syntax_Syntax.ctx_uvar_head in
-                  let uu___4 = FStar_Syntax_Print.term_to_string imp_tm in
-                  let uu___5 = FStar_Syntax_Print.term_to_string uvar_ty in
-                  let uu___6 = FStar_Compiler_Range.string_of_range imp_range in
-                  FStar_Compiler_Util.print5
-                    "Checking uvar %s resolved to %s at type %s, introduce for %s at %s\n"
-                    uu___3 uu___4 uu___5 imp_reason uu___6
-                else ());
-               (let env1 =
-                  let uu___2 =
-                    FStar_Compiler_Effect.op_Bar_Greater
-                      {
-                        FStar_TypeChecker_Env.solver =
-                          (env.FStar_TypeChecker_Env.solver);
-                        FStar_TypeChecker_Env.range =
-                          (env.FStar_TypeChecker_Env.range);
-                        FStar_TypeChecker_Env.curmodule =
-                          (env.FStar_TypeChecker_Env.curmodule);
-                        FStar_TypeChecker_Env.gamma =
-                          (imp_uvar.FStar_Syntax_Syntax.ctx_uvar_gamma);
-                        FStar_TypeChecker_Env.gamma_sig =
-                          (env.FStar_TypeChecker_Env.gamma_sig);
-                        FStar_TypeChecker_Env.gamma_cache =
-                          (env.FStar_TypeChecker_Env.gamma_cache);
-                        FStar_TypeChecker_Env.modules =
-                          (env.FStar_TypeChecker_Env.modules);
-                        FStar_TypeChecker_Env.expected_typ =
-                          (env.FStar_TypeChecker_Env.expected_typ);
-                        FStar_TypeChecker_Env.sigtab =
-                          (env.FStar_TypeChecker_Env.sigtab);
-                        FStar_TypeChecker_Env.attrtab =
-                          (env.FStar_TypeChecker_Env.attrtab);
-                        FStar_TypeChecker_Env.instantiate_imp =
-                          (env.FStar_TypeChecker_Env.instantiate_imp);
-                        FStar_TypeChecker_Env.effects =
-                          (env.FStar_TypeChecker_Env.effects);
-                        FStar_TypeChecker_Env.generalize =
-                          (env.FStar_TypeChecker_Env.generalize);
-                        FStar_TypeChecker_Env.letrecs =
-                          (env.FStar_TypeChecker_Env.letrecs);
-                        FStar_TypeChecker_Env.top_level =
-                          (env.FStar_TypeChecker_Env.top_level);
-                        FStar_TypeChecker_Env.check_uvars =
-                          (env.FStar_TypeChecker_Env.check_uvars);
-                        FStar_TypeChecker_Env.use_eq_strict =
-                          (env.FStar_TypeChecker_Env.use_eq_strict);
-                        FStar_TypeChecker_Env.is_iface =
-                          (env.FStar_TypeChecker_Env.is_iface);
-                        FStar_TypeChecker_Env.admit =
-                          (env.FStar_TypeChecker_Env.admit);
-                        FStar_TypeChecker_Env.lax =
-                          (env.FStar_TypeChecker_Env.lax);
-                        FStar_TypeChecker_Env.lax_universes =
-                          (env.FStar_TypeChecker_Env.lax_universes);
-                        FStar_TypeChecker_Env.phase1 =
-                          (env.FStar_TypeChecker_Env.phase1);
-                        FStar_TypeChecker_Env.failhard =
-                          (env.FStar_TypeChecker_Env.failhard);
-                        FStar_TypeChecker_Env.nosynth =
-                          (env.FStar_TypeChecker_Env.nosynth);
-                        FStar_TypeChecker_Env.uvar_subtyping =
-                          (env.FStar_TypeChecker_Env.uvar_subtyping);
-                        FStar_TypeChecker_Env.tc_term =
-                          (env.FStar_TypeChecker_Env.tc_term);
-                        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                          (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                        FStar_TypeChecker_Env.universe_of =
-                          (env.FStar_TypeChecker_Env.universe_of);
-                        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                          =
-                          (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                        FStar_TypeChecker_Env.teq_nosmt_force =
-                          (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                        FStar_TypeChecker_Env.subtype_nosmt_force =
-                          (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                        FStar_TypeChecker_Env.qtbl_name_and_index =
-                          (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                        FStar_TypeChecker_Env.normalized_eff_names =
-                          (env.FStar_TypeChecker_Env.normalized_eff_names);
-                        FStar_TypeChecker_Env.fv_delta_depths =
-                          (env.FStar_TypeChecker_Env.fv_delta_depths);
-                        FStar_TypeChecker_Env.proof_ns =
-                          (env.FStar_TypeChecker_Env.proof_ns);
-                        FStar_TypeChecker_Env.synth_hook =
-                          (env.FStar_TypeChecker_Env.synth_hook);
-                        FStar_TypeChecker_Env.try_solve_implicits_hook =
-                          (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                        FStar_TypeChecker_Env.splice =
-                          (env.FStar_TypeChecker_Env.splice);
-                        FStar_TypeChecker_Env.mpreprocess =
-                          (env.FStar_TypeChecker_Env.mpreprocess);
-                        FStar_TypeChecker_Env.postprocess =
-                          (env.FStar_TypeChecker_Env.postprocess);
-                        FStar_TypeChecker_Env.identifier_info =
-                          (env.FStar_TypeChecker_Env.identifier_info);
-                        FStar_TypeChecker_Env.tc_hooks =
-                          (env.FStar_TypeChecker_Env.tc_hooks);
-                        FStar_TypeChecker_Env.dsenv =
-                          (env.FStar_TypeChecker_Env.dsenv);
-                        FStar_TypeChecker_Env.nbe =
-                          (env.FStar_TypeChecker_Env.nbe);
-                        FStar_TypeChecker_Env.strict_args_tab =
-                          (env.FStar_TypeChecker_Env.strict_args_tab);
-                        FStar_TypeChecker_Env.erasable_types_tab =
-                          (env.FStar_TypeChecker_Env.erasable_types_tab);
-                        FStar_TypeChecker_Env.enable_defer_to_tac =
-                          (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                        FStar_TypeChecker_Env.unif_allow_ref_guards =
-                          (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                        FStar_TypeChecker_Env.erase_erasable_args =
-                          (env.FStar_TypeChecker_Env.erase_erasable_args);
-                        FStar_TypeChecker_Env.core_check =
-                          (env.FStar_TypeChecker_Env.core_check)
-                      } FStar_TypeChecker_Env.clear_expected_typ in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___2
-                    FStar_Pervasives_Native.fst in
-                let g =
-                  FStar_Errors.with_ctx "While checking implicit solution"
-                    (fun uu___2 ->
-                       let skip_core =
-                         ((env1.FStar_TypeChecker_Env.phase1 ||
-                             env1.FStar_TypeChecker_Env.lax)
-                            ||
-                            (FStar_Syntax_Syntax.uu___is_Allow_untyped
-                               uvar_should_check))
-                           ||
-                           (FStar_Syntax_Syntax.uu___is_Already_checked
-                              uvar_should_check) in
-                       let must_tot =
-                         Prims.op_Negation
-                           ((env1.FStar_TypeChecker_Env.phase1 ||
-                               env1.FStar_TypeChecker_Env.lax)
-                              ||
-                              (FStar_Syntax_Syntax.uu___is_Allow_ghost
-                                 uvar_should_check)) in
-                       if skip_core
-                       then
-                         (if is_tac
-                          then FStar_TypeChecker_Env.trivial_guard
-                          else
-                            (let imp_tm1 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   FStar_Syntax_Subst.compress imp_tm in
-                                 uu___5.FStar_Syntax_Syntax.n in
-                               match uu___4 with
-                               | FStar_Syntax_Syntax.Tm_abs
-                                   (bs, body, FStar_Pervasives_Native.Some
-                                    rc)
-                                   ->
-                                   {
-                                     FStar_Syntax_Syntax.n =
-                                       (FStar_Syntax_Syntax.Tm_abs
-                                          (bs, body,
-                                            (FStar_Pervasives_Native.Some
-                                               {
-                                                 FStar_Syntax_Syntax.residual_effect
-                                                   =
-                                                   (rc.FStar_Syntax_Syntax.residual_effect);
-                                                 FStar_Syntax_Syntax.residual_typ
-                                                   =
-                                                   FStar_Pervasives_Native.None;
-                                                 FStar_Syntax_Syntax.residual_flags
-                                                   =
-                                                   (rc.FStar_Syntax_Syntax.residual_flags)
-                                               })));
-                                     FStar_Syntax_Syntax.pos =
-                                       (imp_tm.FStar_Syntax_Syntax.pos);
-                                     FStar_Syntax_Syntax.vars =
-                                       (imp_tm.FStar_Syntax_Syntax.vars);
-                                     FStar_Syntax_Syntax.hash_code =
-                                       (imp_tm.FStar_Syntax_Syntax.hash_code)
-                                   }
-                               | uu___5 -> imp_tm in
-                             let uu___4 =
-                               env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                 env1 imp_tm1 must_tot in
-                             match uu___4 with
-                             | (k', g1) ->
-                                 let uu___5 =
-                                   get_subtyping_predicate env1 k' uvar_ty in
-                                 (match uu___5 with
-                                  | FStar_Pervasives_Native.None ->
-                                      let uu___6 =
-                                        FStar_TypeChecker_Err.expected_expression_of_type
-                                          env1 uvar_ty imp_tm1 k' in
-                                      FStar_Errors.raise_error uu___6
-                                        imp_tm1.FStar_Syntax_Syntax.pos
-                                  | FStar_Pervasives_Native.Some f ->
-                                      let uu___6 =
-                                        let uu___7 =
-                                          FStar_TypeChecker_Env.apply_guard f
-                                            imp_tm1 in
-                                        FStar_TypeChecker_Env.conj_guard
-                                          uu___7 g1 in
-                                      {
-                                        FStar_TypeChecker_Common.guard_f =
-                                          FStar_TypeChecker_Common.Trivial;
-                                        FStar_TypeChecker_Common.deferred_to_tac
-                                          =
-                                          (uu___6.FStar_TypeChecker_Common.deferred_to_tac);
-                                        FStar_TypeChecker_Common.deferred =
-                                          (uu___6.FStar_TypeChecker_Common.deferred);
-                                        FStar_TypeChecker_Common.univ_ineqs =
-                                          (uu___6.FStar_TypeChecker_Common.univ_ineqs);
-                                        FStar_TypeChecker_Common.implicits =
-                                          (uu___6.FStar_TypeChecker_Common.implicits)
-                                      })))
-                       else
-                         (let uu___4 =
-                            env1.FStar_TypeChecker_Env.core_check env1 imp_tm
-                              uvar_ty must_tot in
-                          match uu___4 with
-                          | FStar_Pervasives.Inl
-                              (FStar_Pervasives_Native.None) ->
-                              FStar_TypeChecker_Common.trivial_guard
-                          | FStar_Pervasives.Inl
-                              (FStar_Pervasives_Native.Some g1) ->
-                              {
-                                FStar_TypeChecker_Common.guard_f =
-                                  (FStar_TypeChecker_Common.NonTrivial g1);
-                                FStar_TypeChecker_Common.deferred_to_tac =
-                                  (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.deferred_to_tac);
-                                FStar_TypeChecker_Common.deferred =
-                                  (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.deferred);
-                                FStar_TypeChecker_Common.univ_ineqs =
-                                  (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.univ_ineqs);
-                                FStar_TypeChecker_Common.implicits =
-                                  (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.implicits)
-                              }
-                          | FStar_Pervasives.Inr print_err ->
-                              let uu___5 =
-                                let uu___6 =
-                                  let uu___7 =
-                                    FStar_Syntax_Print.ctx_uvar_to_string
-                                      imp_uvar in
-                                  let uu___8 =
-                                    FStar_Compiler_Util.string_of_bool is_tac in
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string imp_tm in
-                                  let uu___10 =
-                                    FStar_Syntax_Print.term_to_string uvar_ty in
-                                  FStar_Compiler_Util.format5
-                                    "Core checking failed for implicit %s (is_tac: %s) (reason: %s) (%s <: %s)"
-                                    uu___7 uu___8 imp_reason uu___9 uu___10 in
-                                (FStar_Errors.Fatal_FailToResolveImplicitArgument,
-                                  uu___6) in
-                              FStar_Errors.raise_error uu___5 imp_range)) in
-                let uu___2 =
-                  (Prims.op_Negation force_univ_constraints) &&
-                    (FStar_Compiler_List.existsb
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | (reason, uu___4, uu___5) ->
-                              reason =
-                                FStar_TypeChecker_Common.Deferred_univ_constraint)
-                       g.FStar_TypeChecker_Common.deferred) in
-                if uu___2
-                then FStar_Pervasives_Native.None
-                else
-                  (let g' =
-                     let uu___4 =
-                       discharge_guard'
-                         (FStar_Pervasives_Native.Some
-                            (fun uu___5 ->
-                               let uu___6 =
-                                 FStar_Syntax_Print.term_to_string imp_tm in
-                               let uu___7 =
-                                 FStar_Compiler_Range.string_of_range
-                                   imp_range in
-                               let uu___8 =
-                                 FStar_Compiler_Range.string_of_range
-                                   imp_tm.FStar_Syntax_Syntax.pos in
-                               FStar_Compiler_Util.format4
-                                 "%s (Introduced at %s for %s resolved at %s)"
-                                 uu___6 uu___7 imp_reason uu___8)) env1 g
-                         true in
-                     match uu___4 with
-                     | FStar_Pervasives_Native.Some g1 -> g1
-                     | FStar_Pervasives_Native.None ->
-                         failwith
-                           "Impossible, with use_smt = true, discharge_guard' must return Some" in
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     g'.FStar_TypeChecker_Common.implicits
-                     (fun uu___4 -> FStar_Pervasives_Native.Some uu___4))))
-let rec (unresolved : FStar_Syntax_Syntax.ctx_uvar -> Prims.bool) =
-  fun ctx_u ->
-    let uu___ =
-      FStar_Syntax_Unionfind.find ctx_u.FStar_Syntax_Syntax.ctx_uvar_head in
-    match uu___ with
-    | FStar_Pervasives_Native.Some r ->
-        (match ctx_u.FStar_Syntax_Syntax.ctx_uvar_meta with
-         | FStar_Pervasives_Native.None -> false
-         | FStar_Pervasives_Native.Some uu___1 ->
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Subst.compress r in
-               uu___3.FStar_Syntax_Syntax.n in
-             (match uu___2 with
-              | FStar_Syntax_Syntax.Tm_uvar (ctx_u', uu___3) ->
-                  unresolved ctx_u'
-              | uu___3 -> false))
-    | FStar_Pervasives_Native.None -> true
-let (pick_a_univ_deffered_implicit :
-  tagged_implicits ->
-    (FStar_TypeChecker_Env.implicit FStar_Pervasives_Native.option *
-      tagged_implicits))
-  =
-  fun out ->
-    let uu___ =
-      FStar_Compiler_List.partition
-        (fun uu___1 ->
-           match uu___1 with
-           | (uu___2, status) ->
-               status = Implicit_checking_defers_univ_constraint) out in
-    match uu___ with
-    | (imps_with_deferred_univs, rest) ->
-        (match imps_with_deferred_univs with
-         | [] -> (FStar_Pervasives_Native.None, out)
-         | hd::tl ->
-             let uu___1 =
-               let uu___2 =
-                 FStar_Compiler_Effect.op_Bar_Greater hd
-                   FStar_Pervasives_Native.fst in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                 (fun uu___3 -> FStar_Pervasives_Native.Some uu___3) in
-             (uu___1, (FStar_Compiler_List.op_At tl rest)))
-let (is_tac_implicit_resolved :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.implicit -> Prims.bool)
-  =
-  fun env ->
-    fun i ->
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater
-            i.FStar_TypeChecker_Common.imp_tm FStar_Syntax_Free.uvars in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1
-          FStar_Compiler_Util.set_elements in
-      FStar_Compiler_Effect.op_Bar_Greater uu___
-        (FStar_Compiler_List.for_all
-           (fun uv ->
-              let uu___1 = FStar_Syntax_Util.ctx_uvar_should_check uv in
-              FStar_Syntax_Syntax.uu___is_Allow_unresolved uu___1))
-let (resolve_implicits' :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      Prims.bool ->
-        FStar_TypeChecker_Env.implicits ->
-          (FStar_TypeChecker_Common.implicit * implicit_checking_status)
-            Prims.list)
-  =
-  fun env ->
-    fun is_tac ->
-      fun is_gen ->
-        fun implicits ->
-          let rec until_fixpoint acc implicits1 =
-            let uu___ = acc in
-            match uu___ with
-            | (out, changed) ->
-                (match implicits1 with
-                 | [] ->
-                     if Prims.op_Negation changed
-                     then
-                       let uu___1 =
-                         let uu___2 =
-                           FStar_Compiler_List.map
-                             FStar_Pervasives_Native.fst out in
-                         try_solve_single_valued_implicits env is_tac uu___2 in
-                       (match uu___1 with
-                        | (imps, changed1) ->
-                            if changed1
-                            then until_fixpoint ([], false) imps
-                            else
-                              (let uu___3 = pick_a_univ_deffered_implicit out in
-                               match uu___3 with
-                               | (imp_opt, rest) ->
-                                   (match imp_opt with
-                                    | FStar_Pervasives_Native.None -> rest
-                                    | FStar_Pervasives_Native.Some imp ->
-                                        let force_univ_constraints = true in
-                                        let imps1 =
-                                          let uu___4 =
-                                            check_implicit_solution_and_discharge_guard
-                                              env imp is_tac
-                                              force_univ_constraints in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___4 FStar_Compiler_Util.must in
-                                        let uu___4 =
-                                          let uu___5 =
-                                            FStar_Compiler_List.map
-                                              FStar_Pervasives_Native.fst
-                                              rest in
-                                          FStar_Compiler_List.op_At imps1
-                                            uu___5 in
-                                        until_fixpoint ([], false) uu___4)))
-                     else
-                       (let uu___2 =
-                          FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                            out in
-                        until_fixpoint ([], false) uu___2)
-                 | hd::tl ->
-                     let uu___1 = hd in
-                     (match uu___1 with
-                      | { FStar_TypeChecker_Common.imp_reason = reason;
-                          FStar_TypeChecker_Common.imp_uvar = ctx_u;
-                          FStar_TypeChecker_Common.imp_tm = tm;
-                          FStar_TypeChecker_Common.imp_range = r;_} ->
-                          let uu___2 =
-                            FStar_Syntax_Unionfind.find_decoration
-                              ctx_u.FStar_Syntax_Syntax.ctx_uvar_head in
-                          (match uu___2 with
-                           | {
-                               FStar_Syntax_Syntax.uvar_decoration_typ =
-                                 uvar_decoration_typ;
-                               FStar_Syntax_Syntax.uvar_decoration_typedness_depends_on
-                                 = uu___3;
-                               FStar_Syntax_Syntax.uvar_decoration_should_check
-                                 = uvar_decoration_should_check;_}
-                               ->
-                               ((let uu___5 =
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env)
-                                     (FStar_Options.Other "Rel") in
-                                 if uu___5
-                                 then
-                                   let uu___6 =
-                                     FStar_Syntax_Print.term_to_string tm in
-                                   let uu___7 =
-                                     FStar_Syntax_Print.ctx_uvar_to_string
-                                       ctx_u in
-                                   let uu___8 =
-                                     FStar_Compiler_Util.string_of_bool
-                                       is_tac in
-                                   FStar_Compiler_Util.print3
-                                     "resolve_implicits' loop, imp_tm = %s and ctx_u = %s, is_tac: %s\n"
-                                     uu___6 uu___7 uu___8
-                                 else ());
-                                if
-                                  FStar_Syntax_Syntax.uu___is_Allow_unresolved
-                                    uvar_decoration_should_check
-                                then until_fixpoint (out, true) tl
-                                else
-                                  (let uu___6 = unresolved ctx_u in
-                                   if uu___6
-                                   then
-                                     (if flex_uvar_has_meta_tac ctx_u
-                                      then
-                                        let t = run_meta_arg_tac ctx_u in
-                                        let extra =
-                                          let uu___7 = teq_nosmt env t tm in
-                                          match uu___7 with
-                                          | FStar_Pervasives_Native.None ->
-                                              failwith
-                                                "resolve_implicits: unifying with an unresolved uvar failed?"
-                                          | FStar_Pervasives_Native.Some g ->
-                                              g.FStar_TypeChecker_Common.implicits in
-                                        until_fixpoint (out, true)
-                                          (FStar_Compiler_List.op_At extra tl)
-                                      else
-                                        until_fixpoint
-                                          (((hd, Implicit_unresolved) ::
-                                            out), changed) tl)
-                                   else
-                                     if
-                                       ((FStar_Syntax_Syntax.uu___is_Allow_untyped
-                                           uvar_decoration_should_check)
-                                          ||
-                                          (FStar_Syntax_Syntax.uu___is_Already_checked
-                                             uvar_decoration_should_check))
-                                         || is_gen
-                                     then until_fixpoint (out, true) tl
-                                     else
-                                       (let env1 =
-                                          {
-                                            FStar_TypeChecker_Env.solver =
-                                              (env.FStar_TypeChecker_Env.solver);
-                                            FStar_TypeChecker_Env.range =
-                                              (env.FStar_TypeChecker_Env.range);
-                                            FStar_TypeChecker_Env.curmodule =
-                                              (env.FStar_TypeChecker_Env.curmodule);
-                                            FStar_TypeChecker_Env.gamma =
-                                              (ctx_u.FStar_Syntax_Syntax.ctx_uvar_gamma);
-                                            FStar_TypeChecker_Env.gamma_sig =
-                                              (env.FStar_TypeChecker_Env.gamma_sig);
-                                            FStar_TypeChecker_Env.gamma_cache
-                                              =
-                                              (env.FStar_TypeChecker_Env.gamma_cache);
-                                            FStar_TypeChecker_Env.modules =
-                                              (env.FStar_TypeChecker_Env.modules);
-                                            FStar_TypeChecker_Env.expected_typ
-                                              =
-                                              (env.FStar_TypeChecker_Env.expected_typ);
-                                            FStar_TypeChecker_Env.sigtab =
-                                              (env.FStar_TypeChecker_Env.sigtab);
-                                            FStar_TypeChecker_Env.attrtab =
-                                              (env.FStar_TypeChecker_Env.attrtab);
-                                            FStar_TypeChecker_Env.instantiate_imp
-                                              =
-                                              (env.FStar_TypeChecker_Env.instantiate_imp);
-                                            FStar_TypeChecker_Env.effects =
-                                              (env.FStar_TypeChecker_Env.effects);
-                                            FStar_TypeChecker_Env.generalize
-                                              =
-                                              (env.FStar_TypeChecker_Env.generalize);
-                                            FStar_TypeChecker_Env.letrecs =
-                                              (env.FStar_TypeChecker_Env.letrecs);
-                                            FStar_TypeChecker_Env.top_level =
-                                              (env.FStar_TypeChecker_Env.top_level);
-                                            FStar_TypeChecker_Env.check_uvars
-                                              =
-                                              (env.FStar_TypeChecker_Env.check_uvars);
-                                            FStar_TypeChecker_Env.use_eq_strict
-                                              =
-                                              (env.FStar_TypeChecker_Env.use_eq_strict);
-                                            FStar_TypeChecker_Env.is_iface =
-                                              (env.FStar_TypeChecker_Env.is_iface);
-                                            FStar_TypeChecker_Env.admit =
-                                              (env.FStar_TypeChecker_Env.admit);
-                                            FStar_TypeChecker_Env.lax =
-                                              (env.FStar_TypeChecker_Env.lax);
-                                            FStar_TypeChecker_Env.lax_universes
-                                              =
-                                              (env.FStar_TypeChecker_Env.lax_universes);
-                                            FStar_TypeChecker_Env.phase1 =
-                                              (env.FStar_TypeChecker_Env.phase1);
-                                            FStar_TypeChecker_Env.failhard =
-                                              (env.FStar_TypeChecker_Env.failhard);
-                                            FStar_TypeChecker_Env.nosynth =
-                                              (env.FStar_TypeChecker_Env.nosynth);
-                                            FStar_TypeChecker_Env.uvar_subtyping
-                                              =
-                                              (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                            FStar_TypeChecker_Env.tc_term =
-                                              (env.FStar_TypeChecker_Env.tc_term);
-                                            FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                              =
-                                              (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                            FStar_TypeChecker_Env.universe_of
-                                              =
-                                              (env.FStar_TypeChecker_Env.universe_of);
-                                            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                              =
-                                              (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                            FStar_TypeChecker_Env.teq_nosmt_force
-                                              =
-                                              (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                            FStar_TypeChecker_Env.subtype_nosmt_force
-                                              =
-                                              (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                            FStar_TypeChecker_Env.qtbl_name_and_index
-                                              =
-                                              (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                            FStar_TypeChecker_Env.normalized_eff_names
-                                              =
-                                              (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                            FStar_TypeChecker_Env.fv_delta_depths
-                                              =
-                                              (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                            FStar_TypeChecker_Env.proof_ns =
-                                              (env.FStar_TypeChecker_Env.proof_ns);
-                                            FStar_TypeChecker_Env.synth_hook
-                                              =
-                                              (env.FStar_TypeChecker_Env.synth_hook);
-                                            FStar_TypeChecker_Env.try_solve_implicits_hook
-                                              =
-                                              (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                            FStar_TypeChecker_Env.splice =
-                                              (env.FStar_TypeChecker_Env.splice);
-                                            FStar_TypeChecker_Env.mpreprocess
-                                              =
-                                              (env.FStar_TypeChecker_Env.mpreprocess);
-                                            FStar_TypeChecker_Env.postprocess
-                                              =
-                                              (env.FStar_TypeChecker_Env.postprocess);
-                                            FStar_TypeChecker_Env.identifier_info
-                                              =
-                                              (env.FStar_TypeChecker_Env.identifier_info);
-                                            FStar_TypeChecker_Env.tc_hooks =
-                                              (env.FStar_TypeChecker_Env.tc_hooks);
-                                            FStar_TypeChecker_Env.dsenv =
-                                              (env.FStar_TypeChecker_Env.dsenv);
-                                            FStar_TypeChecker_Env.nbe =
-                                              (env.FStar_TypeChecker_Env.nbe);
-                                            FStar_TypeChecker_Env.strict_args_tab
-                                              =
-                                              (env.FStar_TypeChecker_Env.strict_args_tab);
-                                            FStar_TypeChecker_Env.erasable_types_tab
-                                              =
-                                              (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                            FStar_TypeChecker_Env.enable_defer_to_tac
-                                              =
-                                              (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                            FStar_TypeChecker_Env.unif_allow_ref_guards
-                                              =
-                                              (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                            FStar_TypeChecker_Env.erase_erasable_args
-                                              =
-                                              (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                            FStar_TypeChecker_Env.core_check
-                                              =
-                                              (env.FStar_TypeChecker_Env.core_check)
-                                          } in
-                                        let tm1 =
-                                          norm_with_steps
-                                            "FStar.TypeChecker.Rel.norm_with_steps.8"
-                                            [FStar_TypeChecker_Env.Beta] env1
-                                            tm in
-                                        let hd1 =
-                                          {
-                                            FStar_TypeChecker_Common.imp_reason
-                                              =
-                                              (hd.FStar_TypeChecker_Common.imp_reason);
-                                            FStar_TypeChecker_Common.imp_uvar
-                                              =
-                                              (hd.FStar_TypeChecker_Common.imp_uvar);
-                                            FStar_TypeChecker_Common.imp_tm =
-                                              tm1;
-                                            FStar_TypeChecker_Common.imp_range
-                                              =
-                                              (hd.FStar_TypeChecker_Common.imp_range)
-                                          } in
-                                        if is_tac
-                                        then
-                                          ((let uu___10 =
-                                              is_tac_implicit_resolved env1
-                                                hd1 in
-                                            if uu___10
-                                            then
-                                              let force_univ_constraints =
-                                                true in
-                                              let res =
-                                                check_implicit_solution_and_discharge_guard
-                                                  env1 hd1 is_tac
-                                                  force_univ_constraints in
-                                              (if
-                                                 res <>
-                                                   (FStar_Pervasives_Native.Some
-                                                      [])
-                                               then
-                                                 failwith
-                                                   "Impossible: check_implicit_solution_and_discharge_guard for tac must return Some []"
-                                               else ())
-                                            else ());
-                                           until_fixpoint (out, true) tl)
-                                        else
-                                          (let force_univ_constraints = false in
-                                           let imps_opt =
-                                             check_implicit_solution_and_discharge_guard
-                                               env1 hd1 is_tac
-                                               force_univ_constraints in
-                                           match imps_opt with
-                                           | FStar_Pervasives_Native.None ->
-                                               until_fixpoint
-                                                 (((hd1,
-                                                     Implicit_checking_defers_univ_constraint)
-                                                   :: out), changed) tl
-                                           | FStar_Pervasives_Native.Some
-                                               imps ->
-                                               let uu___10 =
-                                                 let uu___11 =
-                                                   let uu___12 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       imps
-                                                       (FStar_Compiler_List.map
-                                                          (fun i ->
-                                                             (i,
-                                                               Implicit_unresolved))) in
-                                                   FStar_Compiler_List.op_At
-                                                     uu___12 out in
-                                                 (uu___11, true) in
-                                               until_fixpoint uu___10 tl))))))) in
-          until_fixpoint ([], false) implicits
-let (resolve_implicits :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Less_Bar (FStar_TypeChecker_Env.debug env)
-           (FStar_Options.Other "ResolveImplicitsHook") in
-       if uu___1
-       then
-         let uu___2 = guard_to_string env g in
-         FStar_Compiler_Util.print1
-           "//////////////////////////ResolveImplicitsHook: resolve_implicits begin////////////\nguard = %s {\n"
-           uu___2
-       else ());
-      (let tagged_implicits1 =
-         resolve_implicits' env false false
-           g.FStar_TypeChecker_Common.implicits in
-       (let uu___2 =
-          FStar_Compiler_Effect.op_Less_Bar (FStar_TypeChecker_Env.debug env)
-            (FStar_Options.Other "ResolveImplicitsHook") in
-        if uu___2
-        then
-          FStar_Compiler_Util.print_string
-            "//////////////////////////ResolveImplicitsHook: resolve_implicits end////////////\n}\n"
-        else ());
-       (let uu___2 =
-          FStar_Compiler_List.map FStar_Pervasives_Native.fst
-            tagged_implicits1 in
-        {
-          FStar_TypeChecker_Common.guard_f =
-            (g.FStar_TypeChecker_Common.guard_f);
-          FStar_TypeChecker_Common.deferred_to_tac =
-            (g.FStar_TypeChecker_Common.deferred_to_tac);
-          FStar_TypeChecker_Common.deferred =
-            (g.FStar_TypeChecker_Common.deferred);
-          FStar_TypeChecker_Common.univ_ineqs =
-            (g.FStar_TypeChecker_Common.univ_ineqs);
-          FStar_TypeChecker_Common.implicits = uu___2
-        }))
-let (resolve_generalization_implicits :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun g ->
-      let tagged_implicits1 =
-        resolve_implicits' env false true
-          g.FStar_TypeChecker_Common.implicits in
-      let uu___ =
-        FStar_Compiler_List.map FStar_Pervasives_Native.fst tagged_implicits1 in
-      {
-        FStar_TypeChecker_Common.guard_f =
-          (g.FStar_TypeChecker_Common.guard_f);
-        FStar_TypeChecker_Common.deferred_to_tac =
-          (g.FStar_TypeChecker_Common.deferred_to_tac);
-        FStar_TypeChecker_Common.deferred =
-          (g.FStar_TypeChecker_Common.deferred);
-        FStar_TypeChecker_Common.univ_ineqs =
-          (g.FStar_TypeChecker_Common.univ_ineqs);
-        FStar_TypeChecker_Common.implicits = uu___
-      }
-let (resolve_implicits_tac :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.guard_t -> tagged_implicits)
-  =
-  fun env ->
-    fun g ->
-      resolve_implicits' env true false g.FStar_TypeChecker_Common.implicits
-let (force_trivial_guard :
-  FStar_TypeChecker_Env.env -> FStar_TypeChecker_Common.guard_t -> unit) =
-  fun env ->
-    fun g ->
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Less_Bar (FStar_TypeChecker_Env.debug env)
-           (FStar_Options.Other "ResolveImplicitsHook") in
-       if uu___1
-       then
-         let uu___2 = guard_to_string env g in
-         FStar_Compiler_Util.print1
-           "//////////////////////////ResolveImplicitsHook: force_trivial_guard////////////\nguard = %s\n"
-           uu___2
-       else ());
-      (let g1 = solve_deferred_constraints env g in
-       let g2 = resolve_implicits env g1 in
-       match g2.FStar_TypeChecker_Common.implicits with
-       | [] ->
-           let uu___1 = discharge_guard env g2 in
-           FStar_Compiler_Effect.op_Less_Bar (fun uu___2 -> ()) uu___1
-       | imp::uu___1 ->
-           let uu___2 =
-             let uu___3 =
-               let uu___4 =
-                 FStar_Syntax_Print.uvar_to_string
-                   (imp.FStar_TypeChecker_Common.imp_uvar).FStar_Syntax_Syntax.ctx_uvar_head in
-               let uu___5 =
-                 let uu___6 =
-                   FStar_Syntax_Util.ctx_uvar_typ
-                     imp.FStar_TypeChecker_Common.imp_uvar in
-                 FStar_TypeChecker_Normalize.term_to_string env uu___6 in
-               FStar_Compiler_Util.format3
-                 "Failed to resolve implicit argument %s of type %s introduced for %s"
-                 uu___4 uu___5 imp.FStar_TypeChecker_Common.imp_reason in
-             (FStar_Errors.Fatal_FailToResolveImplicitArgument, uu___3) in
-           FStar_Errors.raise_error uu___2
-             imp.FStar_TypeChecker_Common.imp_range)
-let (subtype_nosmt_force :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> Prims.bool)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ = subtype_nosmt env t1 t2 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> false
-        | FStar_Pervasives_Native.Some g -> (force_trivial_guard env g; true)
-let (teq_force :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> unit)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 -> let uu___ = teq env t1 t2 in force_trivial_guard env uu___
-let (teq_nosmt_force :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> Prims.bool)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        let uu___ = teq_nosmt env t1 t2 in
-        match uu___ with
-        | FStar_Pervasives_Native.None -> false
-        | FStar_Pervasives_Native.Some g -> (force_trivial_guard env g; true)
-let (layered_effect_teq :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.typ ->
-        Prims.string FStar_Pervasives_Native.option ->
-          FStar_TypeChecker_Common.guard_t)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        fun reason ->
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_TypeChecker_Env.debug env)
-               (FStar_Options.Other "LayeredEffectsEqns") in
-           if uu___1
-           then
-             let uu___2 =
-               let uu___3 =
-                 FStar_Compiler_Effect.op_Bar_Greater reason
-                   FStar_Compiler_Util.is_none in
-               if uu___3
-               then "_"
-               else
-                 FStar_Compiler_Effect.op_Bar_Greater reason
-                   FStar_Compiler_Util.must in
-             let uu___3 = FStar_Syntax_Print.term_to_string t1 in
-             let uu___4 = FStar_Syntax_Print.term_to_string t2 in
-             FStar_Compiler_Util.print3 "Layered Effect (%s) %s = %s\n"
-               uu___2 uu___3 uu___4
-           else ());
-          teq env t1 t2
-let (universe_inequality :
-  FStar_Syntax_Syntax.universe ->
-    FStar_Syntax_Syntax.universe -> FStar_TypeChecker_Common.guard_t)
-  =
-  fun u1 ->
-    fun u2 ->
-      {
-        FStar_TypeChecker_Common.guard_f =
-          (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.guard_f);
-        FStar_TypeChecker_Common.deferred_to_tac =
-          (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.deferred_to_tac);
-        FStar_TypeChecker_Common.deferred =
-          (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.deferred);
-        FStar_TypeChecker_Common.univ_ineqs = ([], [(u1, u2)]);
-        FStar_TypeChecker_Common.implicits =
-          (FStar_TypeChecker_Common.trivial_guard.FStar_TypeChecker_Common.implicits)
-      }
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Tc.ml b/src/ocaml-output/FStar_TypeChecker_Tc.ml
deleted file mode 100644
index c7c4d42bf96..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Tc.ml
+++ /dev/null
@@ -1,5050 +0,0 @@
-open Prims
-let (set_hint_correlator :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt -> FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun se ->
-      let tbl =
-        FStar_Compiler_Effect.op_Bar_Greater
-          env.FStar_TypeChecker_Env.qtbl_name_and_index
-          FStar_Pervasives_Native.fst in
-      let get_n lid =
-        let n_opt =
-          let uu___ = FStar_Ident.string_of_lid lid in
-          FStar_Compiler_Util.smap_try_find tbl uu___ in
-        if FStar_Compiler_Util.is_some n_opt
-        then
-          FStar_Compiler_Effect.op_Bar_Greater n_opt FStar_Compiler_Util.must
-        else Prims.int_zero in
-      let uu___ = FStar_Options.reuse_hint_for () in
-      match uu___ with
-      | FStar_Pervasives_Native.Some l ->
-          let lid =
-            let uu___1 = FStar_TypeChecker_Env.current_module env in
-            FStar_Ident.lid_add_suffix uu___1 l in
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = let uu___4 = get_n lid in (lid, uu___4) in
-              FStar_Pervasives_Native.Some uu___3 in
-            (tbl, uu___2) in
-          {
-            FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-            FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-            FStar_TypeChecker_Env.curmodule =
-              (env.FStar_TypeChecker_Env.curmodule);
-            FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-            FStar_TypeChecker_Env.gamma_sig =
-              (env.FStar_TypeChecker_Env.gamma_sig);
-            FStar_TypeChecker_Env.gamma_cache =
-              (env.FStar_TypeChecker_Env.gamma_cache);
-            FStar_TypeChecker_Env.modules =
-              (env.FStar_TypeChecker_Env.modules);
-            FStar_TypeChecker_Env.expected_typ =
-              (env.FStar_TypeChecker_Env.expected_typ);
-            FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-            FStar_TypeChecker_Env.attrtab =
-              (env.FStar_TypeChecker_Env.attrtab);
-            FStar_TypeChecker_Env.instantiate_imp =
-              (env.FStar_TypeChecker_Env.instantiate_imp);
-            FStar_TypeChecker_Env.effects =
-              (env.FStar_TypeChecker_Env.effects);
-            FStar_TypeChecker_Env.generalize =
-              (env.FStar_TypeChecker_Env.generalize);
-            FStar_TypeChecker_Env.letrecs =
-              (env.FStar_TypeChecker_Env.letrecs);
-            FStar_TypeChecker_Env.top_level =
-              (env.FStar_TypeChecker_Env.top_level);
-            FStar_TypeChecker_Env.check_uvars =
-              (env.FStar_TypeChecker_Env.check_uvars);
-            FStar_TypeChecker_Env.use_eq_strict =
-              (env.FStar_TypeChecker_Env.use_eq_strict);
-            FStar_TypeChecker_Env.is_iface =
-              (env.FStar_TypeChecker_Env.is_iface);
-            FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-            FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-            FStar_TypeChecker_Env.lax_universes =
-              (env.FStar_TypeChecker_Env.lax_universes);
-            FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-            FStar_TypeChecker_Env.failhard =
-              (env.FStar_TypeChecker_Env.failhard);
-            FStar_TypeChecker_Env.nosynth =
-              (env.FStar_TypeChecker_Env.nosynth);
-            FStar_TypeChecker_Env.uvar_subtyping =
-              (env.FStar_TypeChecker_Env.uvar_subtyping);
-            FStar_TypeChecker_Env.tc_term =
-              (env.FStar_TypeChecker_Env.tc_term);
-            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-              (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-            FStar_TypeChecker_Env.universe_of =
-              (env.FStar_TypeChecker_Env.universe_of);
-            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-              (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-            FStar_TypeChecker_Env.teq_nosmt_force =
-              (env.FStar_TypeChecker_Env.teq_nosmt_force);
-            FStar_TypeChecker_Env.subtype_nosmt_force =
-              (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-            FStar_TypeChecker_Env.qtbl_name_and_index = uu___1;
-            FStar_TypeChecker_Env.normalized_eff_names =
-              (env.FStar_TypeChecker_Env.normalized_eff_names);
-            FStar_TypeChecker_Env.fv_delta_depths =
-              (env.FStar_TypeChecker_Env.fv_delta_depths);
-            FStar_TypeChecker_Env.proof_ns =
-              (env.FStar_TypeChecker_Env.proof_ns);
-            FStar_TypeChecker_Env.synth_hook =
-              (env.FStar_TypeChecker_Env.synth_hook);
-            FStar_TypeChecker_Env.try_solve_implicits_hook =
-              (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-            FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-            FStar_TypeChecker_Env.mpreprocess =
-              (env.FStar_TypeChecker_Env.mpreprocess);
-            FStar_TypeChecker_Env.postprocess =
-              (env.FStar_TypeChecker_Env.postprocess);
-            FStar_TypeChecker_Env.identifier_info =
-              (env.FStar_TypeChecker_Env.identifier_info);
-            FStar_TypeChecker_Env.tc_hooks =
-              (env.FStar_TypeChecker_Env.tc_hooks);
-            FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-            FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-            FStar_TypeChecker_Env.strict_args_tab =
-              (env.FStar_TypeChecker_Env.strict_args_tab);
-            FStar_TypeChecker_Env.erasable_types_tab =
-              (env.FStar_TypeChecker_Env.erasable_types_tab);
-            FStar_TypeChecker_Env.enable_defer_to_tac =
-              (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-            FStar_TypeChecker_Env.unif_allow_ref_guards =
-              (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-            FStar_TypeChecker_Env.erase_erasable_args =
-              (env.FStar_TypeChecker_Env.erase_erasable_args);
-            FStar_TypeChecker_Env.core_check =
-              (env.FStar_TypeChecker_Env.core_check)
-          }
-      | FStar_Pervasives_Native.None ->
-          let lids = FStar_Syntax_Util.lids_of_sigelt se in
-          let lid =
-            match lids with
-            | [] ->
-                let uu___1 = FStar_TypeChecker_Env.current_module env in
-                let uu___2 =
-                  let uu___3 = FStar_Ident.next_id () in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___3
-                    FStar_Compiler_Util.string_of_int in
-                FStar_Ident.lid_add_suffix uu___1 uu___2
-            | l::uu___1 -> l in
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = let uu___4 = get_n lid in (lid, uu___4) in
-              FStar_Pervasives_Native.Some uu___3 in
-            (tbl, uu___2) in
-          {
-            FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-            FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-            FStar_TypeChecker_Env.curmodule =
-              (env.FStar_TypeChecker_Env.curmodule);
-            FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-            FStar_TypeChecker_Env.gamma_sig =
-              (env.FStar_TypeChecker_Env.gamma_sig);
-            FStar_TypeChecker_Env.gamma_cache =
-              (env.FStar_TypeChecker_Env.gamma_cache);
-            FStar_TypeChecker_Env.modules =
-              (env.FStar_TypeChecker_Env.modules);
-            FStar_TypeChecker_Env.expected_typ =
-              (env.FStar_TypeChecker_Env.expected_typ);
-            FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-            FStar_TypeChecker_Env.attrtab =
-              (env.FStar_TypeChecker_Env.attrtab);
-            FStar_TypeChecker_Env.instantiate_imp =
-              (env.FStar_TypeChecker_Env.instantiate_imp);
-            FStar_TypeChecker_Env.effects =
-              (env.FStar_TypeChecker_Env.effects);
-            FStar_TypeChecker_Env.generalize =
-              (env.FStar_TypeChecker_Env.generalize);
-            FStar_TypeChecker_Env.letrecs =
-              (env.FStar_TypeChecker_Env.letrecs);
-            FStar_TypeChecker_Env.top_level =
-              (env.FStar_TypeChecker_Env.top_level);
-            FStar_TypeChecker_Env.check_uvars =
-              (env.FStar_TypeChecker_Env.check_uvars);
-            FStar_TypeChecker_Env.use_eq_strict =
-              (env.FStar_TypeChecker_Env.use_eq_strict);
-            FStar_TypeChecker_Env.is_iface =
-              (env.FStar_TypeChecker_Env.is_iface);
-            FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-            FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-            FStar_TypeChecker_Env.lax_universes =
-              (env.FStar_TypeChecker_Env.lax_universes);
-            FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-            FStar_TypeChecker_Env.failhard =
-              (env.FStar_TypeChecker_Env.failhard);
-            FStar_TypeChecker_Env.nosynth =
-              (env.FStar_TypeChecker_Env.nosynth);
-            FStar_TypeChecker_Env.uvar_subtyping =
-              (env.FStar_TypeChecker_Env.uvar_subtyping);
-            FStar_TypeChecker_Env.tc_term =
-              (env.FStar_TypeChecker_Env.tc_term);
-            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-              (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-            FStar_TypeChecker_Env.universe_of =
-              (env.FStar_TypeChecker_Env.universe_of);
-            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-              (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-            FStar_TypeChecker_Env.teq_nosmt_force =
-              (env.FStar_TypeChecker_Env.teq_nosmt_force);
-            FStar_TypeChecker_Env.subtype_nosmt_force =
-              (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-            FStar_TypeChecker_Env.qtbl_name_and_index = uu___1;
-            FStar_TypeChecker_Env.normalized_eff_names =
-              (env.FStar_TypeChecker_Env.normalized_eff_names);
-            FStar_TypeChecker_Env.fv_delta_depths =
-              (env.FStar_TypeChecker_Env.fv_delta_depths);
-            FStar_TypeChecker_Env.proof_ns =
-              (env.FStar_TypeChecker_Env.proof_ns);
-            FStar_TypeChecker_Env.synth_hook =
-              (env.FStar_TypeChecker_Env.synth_hook);
-            FStar_TypeChecker_Env.try_solve_implicits_hook =
-              (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-            FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-            FStar_TypeChecker_Env.mpreprocess =
-              (env.FStar_TypeChecker_Env.mpreprocess);
-            FStar_TypeChecker_Env.postprocess =
-              (env.FStar_TypeChecker_Env.postprocess);
-            FStar_TypeChecker_Env.identifier_info =
-              (env.FStar_TypeChecker_Env.identifier_info);
-            FStar_TypeChecker_Env.tc_hooks =
-              (env.FStar_TypeChecker_Env.tc_hooks);
-            FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-            FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-            FStar_TypeChecker_Env.strict_args_tab =
-              (env.FStar_TypeChecker_Env.strict_args_tab);
-            FStar_TypeChecker_Env.erasable_types_tab =
-              (env.FStar_TypeChecker_Env.erasable_types_tab);
-            FStar_TypeChecker_Env.enable_defer_to_tac =
-              (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-            FStar_TypeChecker_Env.unif_allow_ref_guards =
-              (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-            FStar_TypeChecker_Env.erase_erasable_args =
-              (env.FStar_TypeChecker_Env.erase_erasable_args);
-            FStar_TypeChecker_Env.core_check =
-              (env.FStar_TypeChecker_Env.core_check)
-          }
-let (log : FStar_TypeChecker_Env.env -> Prims.bool) =
-  fun env ->
-    (FStar_Options.log_types ()) &&
-      (let uu___ =
-         let uu___1 = FStar_TypeChecker_Env.current_module env in
-         FStar_Ident.lid_equals FStar_Parser_Const.prims_lid uu___1 in
-       Prims.op_Negation uu___)
-let (tc_type_common :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.tscheme ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Compiler_Range.range -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun env ->
-    fun uu___ ->
-      fun expected_typ ->
-        fun r ->
-          match uu___ with
-          | (uvs, t) ->
-              let uu___1 = FStar_Syntax_Subst.open_univ_vars uvs t in
-              (match uu___1 with
-               | (uvs1, t1) ->
-                   let env1 = FStar_TypeChecker_Env.push_univ_vars env uvs1 in
-                   let t2 =
-                     FStar_TypeChecker_TcTerm.tc_check_trivial_guard env1 t1
-                       expected_typ in
-                   if uvs1 = []
-                   then
-                     let uu___2 =
-                       FStar_TypeChecker_Generalize.generalize_universes env1
-                         t2 in
-                     (match uu___2 with
-                      | (uvs2, t3) ->
-                          (FStar_TypeChecker_Util.check_uvars r t3;
-                           (uvs2, t3)))
-                   else
-                     (let uu___3 =
-                        let uu___4 =
-                          FStar_Compiler_Effect.op_Bar_Greater t2
-                            (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                               env1) in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___4
-                          (FStar_Syntax_Subst.close_univ_vars uvs1) in
-                      (uvs1, uu___3)))
-let (tc_declare_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.tscheme ->
-      FStar_Compiler_Range.range -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun env ->
-    fun ts ->
-      fun r ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Util.type_u () in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Pervasives_Native.fst in
-        tc_type_common env ts uu___ r
-let (tc_assume :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.tscheme ->
-      FStar_Compiler_Range.range -> FStar_Syntax_Syntax.tscheme)
-  =
-  fun env ->
-    fun ts ->
-      fun r ->
-        let uu___ =
-          let uu___1 = FStar_Syntax_Util.type_u () in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Pervasives_Native.fst in
-        tc_type_common env ts uu___ r
-let (tc_decl_attributes :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt)
-  =
-  fun env ->
-    fun se ->
-      let uu___ =
-        let uu___1 =
-          FStar_TypeChecker_Env.lid_exists env
-            FStar_Parser_Const.attr_substitute_lid in
-        if uu___1
-        then ([], (se.FStar_Syntax_Syntax.sigattrs))
-        else
-          FStar_Compiler_List.partition
-            ((=) FStar_Syntax_Util.attr_substitute)
-            se.FStar_Syntax_Syntax.sigattrs in
-      match uu___ with
-      | (blacklisted_attrs, other_attrs) ->
-          let uu___1 =
-            let uu___2 =
-              FStar_TypeChecker_TcTerm.tc_attributes env other_attrs in
-            FStar_Compiler_List.op_At blacklisted_attrs uu___2 in
-          {
-            FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-            FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-            FStar_Syntax_Syntax.sigquals = (se.FStar_Syntax_Syntax.sigquals);
-            FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-            FStar_Syntax_Syntax.sigattrs = uu___1;
-            FStar_Syntax_Syntax.sigopts = (se.FStar_Syntax_Syntax.sigopts)
-          }
-let (tc_inductive' :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.attribute Prims.list ->
-          FStar_Ident.lident Prims.list ->
-            (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.sigelt
-              Prims.list))
-  =
-  fun env ->
-    fun ses ->
-      fun quals ->
-        fun attrs ->
-          fun lids ->
-            (let uu___1 = FStar_TypeChecker_Env.debug env FStar_Options.Low in
-             if uu___1
-             then
-               let uu___2 =
-                 (FStar_Common.string_of_list ())
-                   FStar_Syntax_Print.sigelt_to_string ses in
-               FStar_Compiler_Util.print1 ">>>>>>>>>>>>>>tc_inductive %s\n"
-                 uu___2
-             else ());
-            (let ses1 = FStar_Compiler_List.map (tc_decl_attributes env) ses in
-             let uu___1 =
-               FStar_TypeChecker_TcInductive.check_inductive_well_typedness
-                 env ses1 quals lids in
-             match uu___1 with
-             | (sig_bndle, tcs, datas) ->
-                 let sig_bndle1 =
-                   FStar_TypeChecker_Positivity.mark_uniform_type_parameters
-                     env sig_bndle in
-                 let attrs' =
-                   FStar_Syntax_Util.remove_attr
-                     FStar_Parser_Const.erasable_attr attrs in
-                 let data_ops_ses =
-                   let uu___2 =
-                     FStar_Compiler_List.map
-                       (FStar_TypeChecker_TcInductive.mk_data_operations
-                          quals attrs' env tcs) datas in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___2
-                     FStar_Compiler_List.flatten in
-                 ((let uu___3 =
-                     (FStar_Options.no_positivity ()) ||
-                       (let uu___4 = FStar_TypeChecker_Env.should_verify env in
-                        Prims.op_Negation uu___4) in
-                   if uu___3
-                   then ()
-                   else
-                     (let env1 =
-                        FStar_TypeChecker_Env.push_sigelt env sig_bndle1 in
-                      FStar_Compiler_List.iter
-                        (fun ty ->
-                           let b =
-                             FStar_TypeChecker_Positivity.check_strict_positivity
-                               env1 lids ty in
-                           if Prims.op_Negation b
-                           then
-                             let uu___6 =
-                               match ty.FStar_Syntax_Syntax.sigel with
-                               | FStar_Syntax_Syntax.Sig_inductive_typ
-                                   (lid, uu___7, uu___8, uu___9, uu___10,
-                                    uu___11, uu___12)
-                                   -> (lid, (ty.FStar_Syntax_Syntax.sigrng))
-                               | uu___7 -> failwith "Impossible!" in
-                             match uu___6 with
-                             | (lid, r) ->
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       let uu___10 =
-                                         FStar_Ident.string_of_lid lid in
-                                       Prims.op_Hat uu___10
-                                         " does not satisfy the strict positivity condition" in
-                                     Prims.op_Hat "Inductive type " uu___9 in
-                                   (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                                     uu___8) in
-                                 FStar_Errors.log_issue r uu___7
-                           else ()) tcs;
-                      FStar_Compiler_List.iter
-                        (fun d ->
-                           let uu___6 =
-                             match d.FStar_Syntax_Syntax.sigel with
-                             | FStar_Syntax_Syntax.Sig_datacon
-                                 (data_lid, uu___7, uu___8, ty_lid, uu___9,
-                                  uu___10)
-                                 -> (data_lid, ty_lid)
-                             | uu___7 -> failwith "Impossible" in
-                           match uu___6 with
-                           | (data_lid, ty_lid) ->
-                               let uu___7 =
-                                 (FStar_Ident.lid_equals ty_lid
-                                    FStar_Parser_Const.exn_lid)
-                                   &&
-                                   (let uu___8 =
-                                      FStar_TypeChecker_Positivity.check_exn_strict_positivity
-                                        env1 data_lid in
-                                    Prims.op_Negation uu___8) in
-                               if uu___7
-                               then
-                                 let uu___8 =
-                                   let uu___9 =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         FStar_Ident.string_of_lid data_lid in
-                                       Prims.op_Hat uu___11
-                                         " does not satisfy the positivity condition" in
-                                     Prims.op_Hat "Exception " uu___10 in
-                                   (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                                     uu___9) in
-                                 FStar_Errors.log_issue
-                                   d.FStar_Syntax_Syntax.sigrng uu___8
-                               else ()) datas));
-                  (let skip_haseq =
-                     let skip_prims_type uu___3 =
-                       let lid =
-                         let ty = FStar_Compiler_List.hd tcs in
-                         match ty.FStar_Syntax_Syntax.sigel with
-                         | FStar_Syntax_Syntax.Sig_inductive_typ
-                             (lid1, uu___4, uu___5, uu___6, uu___7, uu___8,
-                              uu___9)
-                             -> lid1
-                         | uu___4 -> failwith "Impossible" in
-                       FStar_Compiler_List.existsb
-                         (fun s ->
-                            let uu___4 =
-                              let uu___5 = FStar_Ident.ident_of_lid lid in
-                              FStar_Ident.string_of_id uu___5 in
-                            s = uu___4)
-                         FStar_TypeChecker_TcInductive.early_prims_inductives in
-                     let is_noeq =
-                       FStar_Compiler_List.existsb
-                         (fun q -> q = FStar_Syntax_Syntax.Noeq) quals in
-                     let is_erasable uu___3 =
-                       let uu___4 =
-                         let uu___5 = FStar_Compiler_List.hd tcs in
-                         uu___5.FStar_Syntax_Syntax.sigattrs in
-                       FStar_Syntax_Util.has_attribute uu___4
-                         FStar_Parser_Const.erasable_attr in
-                     ((((FStar_Compiler_List.length tcs) = Prims.int_zero) ||
-                         ((FStar_Ident.lid_equals
-                             env.FStar_TypeChecker_Env.curmodule
-                             FStar_Parser_Const.prims_lid)
-                            && (skip_prims_type ())))
-                        || is_noeq)
-                       || (is_erasable ()) in
-                   let res =
-                     if skip_haseq
-                     then (sig_bndle1, data_ops_ses)
-                     else
-                       (let is_unopteq =
-                          FStar_Compiler_List.existsb
-                            (fun q -> q = FStar_Syntax_Syntax.Unopteq) quals in
-                        let ses2 =
-                          if is_unopteq
-                          then
-                            FStar_TypeChecker_TcInductive.unoptimized_haseq_scheme
-                              sig_bndle1 tcs datas env
-                          else
-                            FStar_TypeChecker_TcInductive.optimized_haseq_scheme
-                              sig_bndle1 tcs datas env in
-                        (sig_bndle1,
-                          (FStar_Compiler_List.op_At ses2 data_ops_ses))) in
-                   res)))
-let (tc_inductive :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.attribute Prims.list ->
-          FStar_Ident.lident Prims.list ->
-            (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.sigelt
-              Prims.list))
-  =
-  fun env ->
-    fun ses ->
-      fun quals ->
-        fun attrs ->
-          fun lids ->
-            let env1 = FStar_TypeChecker_Env.push env "tc_inductive" in
-            let pop uu___ =
-              let uu___1 = FStar_TypeChecker_Env.pop env1 "tc_inductive" in
-              () in
-            let uu___ = FStar_Options.trace_error () in
-            if uu___
-            then
-              let r = tc_inductive' env1 ses quals attrs lids in (pop (); r)
-            else
-              (try
-                 (fun uu___2 ->
-                    match () with
-                    | () ->
-                        let uu___3 = tc_inductive' env1 ses quals attrs lids in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___3
-                          (fun r -> pop (); r)) ()
-               with | uu___2 -> (pop (); FStar_Compiler_Effect.raise uu___2))
-let (check_must_erase_attribute :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun env ->
-    fun se ->
-      match se.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_let (lbs, l) ->
-          let uu___ =
-            let uu___1 = FStar_Options.ide () in Prims.op_Negation uu___1 in
-          if uu___
-          then
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.dsenv env in
-              let uu___3 = FStar_TypeChecker_Env.current_module env in
-              FStar_Syntax_DsEnv.iface_decls uu___2 uu___3 in
-            (match uu___1 with
-             | FStar_Pervasives_Native.None -> ()
-             | FStar_Pervasives_Native.Some iface_decls ->
-                 FStar_Compiler_Effect.op_Bar_Greater
-                   (FStar_Pervasives_Native.snd lbs)
-                   (FStar_Compiler_List.iter
-                      (fun lb ->
-                         let lbname =
-                           FStar_Compiler_Util.right
-                             lb.FStar_Syntax_Syntax.lbname in
-                         let has_iface_val =
-                           let uu___2 =
-                             let uu___3 =
-                               let uu___4 =
-                                 FStar_Ident.ident_of_lid
-                                   (lbname.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                               FStar_Parser_AST.decl_is_val uu___4 in
-                             FStar_Compiler_Util.for_some uu___3 in
-                           FStar_Compiler_Effect.op_Bar_Greater iface_decls
-                             uu___2 in
-                         if has_iface_val
-                         then
-                           let must_erase =
-                             FStar_TypeChecker_Util.must_erase_for_extraction
-                               env lb.FStar_Syntax_Syntax.lbdef in
-                           let has_attr =
-                             FStar_TypeChecker_Env.fv_has_attr env lbname
-                               FStar_Parser_Const.must_erase_for_extraction_attr in
-                           (if must_erase && (Prims.op_Negation has_attr)
-                            then
-                              let uu___2 =
-                                FStar_Syntax_Syntax.range_of_fv lbname in
-                              let uu___3 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    FStar_Syntax_Print.fv_to_string lbname in
-                                  let uu___6 =
-                                    FStar_Syntax_Print.fv_to_string lbname in
-                                  FStar_Compiler_Util.format2
-                                    "Values of type `%s` will be erased during extraction, but its interface hides this fact. Add the `must_erase_for_extraction` attribute to the `val %s` declaration for this symbol in the interface"
-                                    uu___5 uu___6 in
-                                (FStar_Errors.Error_MustEraseMissing, uu___4) in
-                              FStar_Errors.log_issue uu___2 uu___3
-                            else
-                              if has_attr && (Prims.op_Negation must_erase)
-                              then
-                                (let uu___3 =
-                                   FStar_Syntax_Syntax.range_of_fv lbname in
-                                 let uu___4 =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       FStar_Syntax_Print.fv_to_string lbname in
-                                     FStar_Compiler_Util.format1
-                                       "Values of type `%s` cannot be erased during extraction, but the `must_erase_for_extraction` attribute claims that it can. Please remove the attribute."
-                                       uu___6 in
-                                   (FStar_Errors.Error_MustEraseMissing,
-                                     uu___5) in
-                                 FStar_Errors.log_issue uu___3 uu___4)
-                              else ())
-                         else ())))
-          else ()
-      | uu___ -> ()
-let (check_typeclass_instance_attribute :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun env ->
-    fun se ->
-      let is_tc_instance =
-        FStar_Compiler_Effect.op_Bar_Greater se.FStar_Syntax_Syntax.sigattrs
-          (FStar_Compiler_Util.for_some
-             (fun t ->
-                match t.FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_fvar fv ->
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.tcinstance_lid
-                | uu___ -> false)) in
-      if Prims.op_Negation is_tc_instance
-      then ()
-      else
-        (match se.FStar_Syntax_Syntax.sigel with
-         | FStar_Syntax_Syntax.Sig_let ((false, lb::[]), uu___1) ->
-             let uu___2 =
-               FStar_Syntax_Util.arrow_formals_comp
-                 lb.FStar_Syntax_Syntax.lbtyp in
-             (match uu___2 with
-              | (uu___3, res) ->
-                  let uu___4 = FStar_Syntax_Util.is_total_comp res in
-                  if uu___4
-                  then
-                    let t = FStar_Syntax_Util.comp_result res in
-                    let uu___5 = FStar_Syntax_Util.head_and_args t in
-                    (match uu___5 with
-                     | (head, uu___6) ->
-                         let err uu___7 =
-                           let uu___8 =
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_Syntax_Print.term_to_string t in
-                               FStar_Compiler_Util.format1
-                                 "Instances must define instances of `class` types. Type %s is not a class"
-                                 uu___10 in
-                             (FStar_Errors.Error_UnexpectedTypeclassInstance,
-                               uu___9) in
-                           FStar_Errors.log_issue
-                             (FStar_Syntax_Util.range_of_sigelt se) uu___8 in
-                         let uu___7 =
-                           let uu___8 = FStar_Syntax_Util.un_uinst head in
-                           uu___8.FStar_Syntax_Syntax.n in
-                         (match uu___7 with
-                          | FStar_Syntax_Syntax.Tm_fvar fv ->
-                              let uu___8 =
-                                let uu___9 =
-                                  FStar_TypeChecker_Env.fv_has_attr env fv
-                                    FStar_Parser_Const.tcclass_lid in
-                                Prims.op_Negation uu___9 in
-                              if uu___8 then err () else ()
-                          | uu___8 -> err ()))
-                  else
-                    (let uu___6 =
-                       let uu___7 =
-                         let uu___8 =
-                           FStar_Ident.string_of_lid
-                             (FStar_Syntax_Util.comp_effect_name res) in
-                         FStar_Compiler_Util.format1
-                           "Instances are expected to be total. This instance has effect %s"
-                           uu___8 in
-                       (FStar_Errors.Error_UnexpectedTypeclassInstance,
-                         uu___7) in
-                     FStar_Errors.log_issue
-                       (FStar_Syntax_Util.range_of_sigelt se) uu___6))
-         | uu___1 ->
-             FStar_Errors.log_issue (FStar_Syntax_Util.range_of_sigelt se)
-               (FStar_Errors.Error_UnexpectedTypeclassInstance,
-                 "An `instance` is expected to be a non-recursive definition whose type is an instance of a `class`"))
-let proc_check_with :
-  'a . FStar_Syntax_Syntax.attribute Prims.list -> (unit -> 'a) -> 'a =
-  fun attrs ->
-    fun kont ->
-      let uu___ =
-        FStar_Syntax_Util.get_attribute FStar_Parser_Const.check_with_lid
-          attrs in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> kont ()
-      | FStar_Pervasives_Native.Some ((a1, FStar_Pervasives_Native.None)::[])
-          ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Syntax_Embeddings.unembed
-                FStar_Syntax_Embeddings.e_vconfig a1 in
-            uu___2 true FStar_Syntax_Embeddings.id_norm_cb in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None -> failwith "nah"
-           | FStar_Pervasives_Native.Some vcfg ->
-               FStar_Options.with_saved_options
-                 (fun uu___2 -> FStar_Options.set_vconfig vcfg; kont ())
-           | uu___2 -> failwith "ill-formed `check_with`")
-let (handle_postprocess_with_attr :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.attribute Prims.list ->
-      (FStar_Syntax_Syntax.attribute Prims.list * FStar_Syntax_Syntax.term
-        FStar_Pervasives_Native.option))
-  =
-  fun env ->
-    fun ats ->
-      let uu___ =
-        FStar_Syntax_Util.extract_attr' FStar_Parser_Const.postprocess_with
-          ats in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> (ats, FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some
-          (ats1, (tau, FStar_Pervasives_Native.None)::[]) ->
-          (ats1, (FStar_Pervasives_Native.Some tau))
-      | FStar_Pervasives_Native.Some (ats1, args) ->
-          ((let uu___2 = FStar_TypeChecker_Env.get_range env in
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Ident.string_of_lid
-                    FStar_Parser_Const.postprocess_with in
-                FStar_Compiler_Util.format1 "Ill-formed application of `%s`"
-                  uu___5 in
-              (FStar_Errors.Warning_UnrecognizedAttribute, uu___4) in
-            FStar_Errors.log_issue uu___2 uu___3);
-           (ats1, FStar_Pervasives_Native.None))
-let (store_sigopts :
-  FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt) =
-  fun se ->
-    let uu___ =
-      let uu___1 = FStar_Options.get_vconfig () in
-      FStar_Pervasives_Native.Some uu___1 in
-    {
-      FStar_Syntax_Syntax.sigel = (se.FStar_Syntax_Syntax.sigel);
-      FStar_Syntax_Syntax.sigrng = (se.FStar_Syntax_Syntax.sigrng);
-      FStar_Syntax_Syntax.sigquals = (se.FStar_Syntax_Syntax.sigquals);
-      FStar_Syntax_Syntax.sigmeta = (se.FStar_Syntax_Syntax.sigmeta);
-      FStar_Syntax_Syntax.sigattrs = (se.FStar_Syntax_Syntax.sigattrs);
-      FStar_Syntax_Syntax.sigopts = uu___
-    }
-let (tc_decls_knot :
-  (FStar_TypeChecker_Env.env ->
-     FStar_Syntax_Syntax.sigelt Prims.list ->
-       (FStar_Syntax_Syntax.sigelt Prims.list * FStar_TypeChecker_Env.env))
-    FStar_Pervasives_Native.option FStar_Compiler_Effect.ref)
-  = FStar_Compiler_Util.mk_ref FStar_Pervasives_Native.None
-let (do_two_phases : FStar_TypeChecker_Env.env -> Prims.bool) =
-  fun env -> FStar_TypeChecker_Env.should_verify env
-let run_phase1 : 'a . (unit -> 'a) -> 'a =
-  fun f ->
-    FStar_TypeChecker_Core.clear_memo_table ();
-    (let r = f () in FStar_TypeChecker_Core.clear_memo_table (); r)
-let (tc_sig_let :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.sigelt ->
-        (Prims.bool * FStar_Syntax_Syntax.letbinding Prims.list) ->
-          FStar_Ident.lident Prims.list ->
-            (FStar_Syntax_Syntax.sigelt Prims.list *
-              FStar_Syntax_Syntax.sigelt Prims.list *
-              FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun r ->
-      fun se ->
-        fun lbs ->
-          fun lids ->
-            let env0 = env in
-            let env1 = FStar_TypeChecker_Env.set_range env r in
-            let check_quals_eq l qopt val_q =
-              match qopt with
-              | FStar_Pervasives_Native.None ->
-                  FStar_Pervasives_Native.Some val_q
-              | FStar_Pervasives_Native.Some q' ->
-                  let drop_logic_and_irreducible =
-                    FStar_Compiler_List.filter
-                      (fun x ->
-                         Prims.op_Negation
-                           ((x = FStar_Syntax_Syntax.Logic) ||
-                              (x = FStar_Syntax_Syntax.Irreducible))) in
-                  let uu___ =
-                    let uu___1 =
-                      let uu___2 = drop_logic_and_irreducible val_q in
-                      let uu___3 = drop_logic_and_irreducible q' in
-                      (uu___2, uu___3) in
-                    match uu___1 with
-                    | (val_q1, q'1) ->
-                        ((FStar_Compiler_List.length val_q1) =
-                           (FStar_Compiler_List.length q'1))
-                          &&
-                          (FStar_Compiler_List.forall2
-                             FStar_Syntax_Util.qualifier_equal val_q1 q'1) in
-                  if uu___
-                  then FStar_Pervasives_Native.Some q'
-                  else
-                    (let uu___2 =
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Print.lid_to_string l in
-                         let uu___5 =
-                           FStar_Syntax_Print.quals_to_string val_q in
-                         let uu___6 = FStar_Syntax_Print.quals_to_string q' in
-                         FStar_Compiler_Util.format3
-                           "Inconsistent qualifier annotations on %s; Expected {%s}, got {%s}"
-                           uu___4 uu___5 uu___6 in
-                       (FStar_Errors.Fatal_InconsistentQualifierAnnotation,
-                         uu___3) in
-                     FStar_Errors.raise_error uu___2 r) in
-            let rename_parameters lb =
-              let rename_in_typ def typ =
-                let typ1 = FStar_Syntax_Subst.compress typ in
-                let def_bs =
-                  let uu___ =
-                    let uu___1 = FStar_Syntax_Subst.compress def in
-                    uu___1.FStar_Syntax_Syntax.n in
-                  match uu___ with
-                  | FStar_Syntax_Syntax.Tm_abs (binders, uu___1, uu___2) ->
-                      binders
-                  | uu___1 -> [] in
-                match typ1 with
-                | {
-                    FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_arrow
-                      (val_bs, c);
-                    FStar_Syntax_Syntax.pos = r1;
-                    FStar_Syntax_Syntax.vars = uu___;
-                    FStar_Syntax_Syntax.hash_code = uu___1;_} ->
-                    let has_auto_name bv =
-                      let uu___2 =
-                        FStar_Ident.string_of_id
-                          bv.FStar_Syntax_Syntax.ppname in
-                      FStar_Compiler_Util.starts_with uu___2
-                        FStar_Ident.reserved_prefix in
-                    let rec rename_binders def_bs1 val_bs1 =
-                      match (def_bs1, val_bs1) with
-                      | ([], uu___2) -> val_bs1
-                      | (uu___2, []) -> val_bs1
-                      | ({ FStar_Syntax_Syntax.binder_bv = body_bv;
-                           FStar_Syntax_Syntax.binder_qual = uu___2;
-                           FStar_Syntax_Syntax.binder_attrs = uu___3;_}::bt,
-                         val_b::vt) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = has_auto_name body_bv in
-                              let uu___7 =
-                                has_auto_name
-                                  val_b.FStar_Syntax_Syntax.binder_bv in
-                              (uu___6, uu___7) in
-                            match uu___5 with
-                            | (true, uu___6) -> val_b
-                            | (false, true) ->
-                                let uu___6 =
-                                  let uu___7 =
-                                    val_b.FStar_Syntax_Syntax.binder_bv in
-                                  let uu___8 =
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_Ident.string_of_id
-                                          body_bv.FStar_Syntax_Syntax.ppname in
-                                      let uu___11 =
-                                        FStar_Ident.range_of_id
-                                          (val_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.ppname in
-                                      (uu___10, uu___11) in
-                                    FStar_Ident.mk_ident uu___9 in
-                                  {
-                                    FStar_Syntax_Syntax.ppname = uu___8;
-                                    FStar_Syntax_Syntax.index =
-                                      (uu___7.FStar_Syntax_Syntax.index);
-                                    FStar_Syntax_Syntax.sort =
-                                      (uu___7.FStar_Syntax_Syntax.sort)
-                                  } in
-                                {
-                                  FStar_Syntax_Syntax.binder_bv = uu___6;
-                                  FStar_Syntax_Syntax.binder_qual =
-                                    (val_b.FStar_Syntax_Syntax.binder_qual);
-                                  FStar_Syntax_Syntax.binder_attrs =
-                                    (val_b.FStar_Syntax_Syntax.binder_attrs)
-                                }
-                            | (false, false) -> val_b in
-                          let uu___5 = rename_binders bt vt in uu___4 ::
-                            uu___5 in
-                    let uu___2 =
-                      let uu___3 =
-                        let uu___4 = rename_binders def_bs val_bs in
-                        (uu___4, c) in
-                      FStar_Syntax_Syntax.Tm_arrow uu___3 in
-                    FStar_Syntax_Syntax.mk uu___2 r1
-                | uu___ -> typ1 in
-              let uu___ =
-                rename_in_typ lb.FStar_Syntax_Syntax.lbdef
-                  lb.FStar_Syntax_Syntax.lbtyp in
-              {
-                FStar_Syntax_Syntax.lbname = (lb.FStar_Syntax_Syntax.lbname);
-                FStar_Syntax_Syntax.lbunivs =
-                  (lb.FStar_Syntax_Syntax.lbunivs);
-                FStar_Syntax_Syntax.lbtyp = uu___;
-                FStar_Syntax_Syntax.lbeff = (lb.FStar_Syntax_Syntax.lbeff);
-                FStar_Syntax_Syntax.lbdef = (lb.FStar_Syntax_Syntax.lbdef);
-                FStar_Syntax_Syntax.lbattrs =
-                  (lb.FStar_Syntax_Syntax.lbattrs);
-                FStar_Syntax_Syntax.lbpos = (lb.FStar_Syntax_Syntax.lbpos)
-              } in
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater
-                (FStar_Pervasives_Native.snd lbs)
-                (FStar_Compiler_List.fold_left
-                   (fun uu___1 ->
-                      fun lb ->
-                        match uu___1 with
-                        | (gen, lbs1, quals_opt) ->
-                            let lbname =
-                              FStar_Compiler_Util.right
-                                lb.FStar_Syntax_Syntax.lbname in
-                            let uu___2 =
-                              let uu___3 =
-                                FStar_TypeChecker_Env.try_lookup_val_decl
-                                  env1
-                                  (lbname.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                              match uu___3 with
-                              | FStar_Pervasives_Native.None ->
-                                  (gen, lb, quals_opt)
-                              | FStar_Pervasives_Native.Some
-                                  ((uvs, tval), quals) ->
-                                  let quals_opt1 =
-                                    check_quals_eq
-                                      (lbname.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                      quals_opt quals in
-                                  let def =
-                                    match (lb.FStar_Syntax_Syntax.lbtyp).FStar_Syntax_Syntax.n
-                                    with
-                                    | FStar_Syntax_Syntax.Tm_unknown ->
-                                        lb.FStar_Syntax_Syntax.lbdef
-                                    | uu___4 ->
-                                        FStar_Syntax_Syntax.mk
-                                          (FStar_Syntax_Syntax.Tm_ascribed
-                                             ((lb.FStar_Syntax_Syntax.lbdef),
-                                               ((FStar_Pervasives.Inl
-                                                   (lb.FStar_Syntax_Syntax.lbtyp)),
-                                                 FStar_Pervasives_Native.None,
-                                                 false),
-                                               FStar_Pervasives_Native.None))
-                                          (lb.FStar_Syntax_Syntax.lbdef).FStar_Syntax_Syntax.pos in
-                                  (if
-                                     (lb.FStar_Syntax_Syntax.lbunivs <> [])
-                                       &&
-                                       ((FStar_Compiler_List.length
-                                           lb.FStar_Syntax_Syntax.lbunivs)
-                                          <> (FStar_Compiler_List.length uvs))
-                                   then
-                                     FStar_Errors.raise_error
-                                       (FStar_Errors.Fatal_IncoherentInlineUniverse,
-                                         "Inline universes are incoherent with annotation from val declaration")
-                                       r
-                                   else ();
-                                   (let uu___5 =
-                                      let uu___6 =
-                                        let uu___7 =
-                                          FStar_Parser_Const.effect_ALL_lid
-                                            () in
-                                        ((FStar_Pervasives.Inr lbname), uvs,
-                                          uu___7, tval, def, [],
-                                          (lb.FStar_Syntax_Syntax.lbpos)) in
-                                      FStar_Syntax_Syntax.mk_lb uu___6 in
-                                    (false, uu___5, quals_opt1))) in
-                            (match uu___2 with
-                             | (gen1, lb1, quals_opt1) ->
-                                 (gen1, (lb1 :: lbs1), quals_opt1)))
-                   (true, [],
-                     (if se.FStar_Syntax_Syntax.sigquals = []
-                      then FStar_Pervasives_Native.None
-                      else
-                        FStar_Pervasives_Native.Some
-                          (se.FStar_Syntax_Syntax.sigquals)))) in
-            match uu___ with
-            | (should_generalize, lbs', quals_opt) ->
-                (FStar_Syntax_Util.check_mutual_universes lbs';
-                 (let quals =
-                    match quals_opt with
-                    | FStar_Pervasives_Native.None ->
-                        [FStar_Syntax_Syntax.Visible_default]
-                    | FStar_Pervasives_Native.Some q ->
-                        let uu___2 =
-                          FStar_Compiler_Effect.op_Bar_Greater q
-                            (FStar_Compiler_Util.for_some
-                               (fun uu___3 ->
-                                  match uu___3 with
-                                  | FStar_Syntax_Syntax.Irreducible -> true
-                                  | FStar_Syntax_Syntax.Visible_default ->
-                                      true
-                                  | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen
-                                      -> true
-                                  | uu___4 -> false)) in
-                        if uu___2
-                        then q
-                        else FStar_Syntax_Syntax.Visible_default :: q in
-                  let lbs'1 = FStar_Compiler_List.rev lbs' in
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Syntax_Util.extract_attr'
-                        FStar_Parser_Const.preprocess_with
-                        se.FStar_Syntax_Syntax.sigattrs in
-                    match uu___3 with
-                    | FStar_Pervasives_Native.None ->
-                        ((se.FStar_Syntax_Syntax.sigattrs),
-                          FStar_Pervasives_Native.None)
-                    | FStar_Pervasives_Native.Some
-                        (ats, (tau, FStar_Pervasives_Native.None)::[]) ->
-                        (ats, (FStar_Pervasives_Native.Some tau))
-                    | FStar_Pervasives_Native.Some (ats, args) ->
-                        (FStar_Errors.log_issue r
-                           (FStar_Errors.Warning_UnrecognizedAttribute,
-                             "Ill-formed application of `preprocess_with`");
-                         ((se.FStar_Syntax_Syntax.sigattrs),
-                           FStar_Pervasives_Native.None)) in
-                  match uu___2 with
-                  | (attrs, pre_tau) ->
-                      let se1 =
-                        {
-                          FStar_Syntax_Syntax.sigel =
-                            (se.FStar_Syntax_Syntax.sigel);
-                          FStar_Syntax_Syntax.sigrng =
-                            (se.FStar_Syntax_Syntax.sigrng);
-                          FStar_Syntax_Syntax.sigquals =
-                            (se.FStar_Syntax_Syntax.sigquals);
-                          FStar_Syntax_Syntax.sigmeta =
-                            (se.FStar_Syntax_Syntax.sigmeta);
-                          FStar_Syntax_Syntax.sigattrs = attrs;
-                          FStar_Syntax_Syntax.sigopts =
-                            (se.FStar_Syntax_Syntax.sigopts)
-                        } in
-                      let preprocess_lb tau lb =
-                        let lbdef =
-                          FStar_TypeChecker_Env.preprocess env1 tau
-                            lb.FStar_Syntax_Syntax.lbdef in
-                        (let uu___4 =
-                           FStar_Compiler_Effect.op_Less_Bar
-                             (FStar_TypeChecker_Env.debug env1)
-                             (FStar_Options.Other "TwoPhases") in
-                         if uu___4
-                         then
-                           let uu___5 =
-                             FStar_Syntax_Print.term_to_string lbdef in
-                           FStar_Compiler_Util.print1
-                             "lb preprocessed into: %s\n" uu___5
-                         else ());
-                        {
-                          FStar_Syntax_Syntax.lbname =
-                            (lb.FStar_Syntax_Syntax.lbname);
-                          FStar_Syntax_Syntax.lbunivs =
-                            (lb.FStar_Syntax_Syntax.lbunivs);
-                          FStar_Syntax_Syntax.lbtyp =
-                            (lb.FStar_Syntax_Syntax.lbtyp);
-                          FStar_Syntax_Syntax.lbeff =
-                            (lb.FStar_Syntax_Syntax.lbeff);
-                          FStar_Syntax_Syntax.lbdef = lbdef;
-                          FStar_Syntax_Syntax.lbattrs =
-                            (lb.FStar_Syntax_Syntax.lbattrs);
-                          FStar_Syntax_Syntax.lbpos =
-                            (lb.FStar_Syntax_Syntax.lbpos)
-                        } in
-                      let lbs'2 =
-                        match pre_tau with
-                        | FStar_Pervasives_Native.Some tau ->
-                            FStar_Compiler_List.map (preprocess_lb tau) lbs'1
-                        | FStar_Pervasives_Native.None -> lbs'1 in
-                      let e =
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Syntax_Syntax.mk
-                                (FStar_Syntax_Syntax.Tm_constant
-                                   FStar_Const.Const_unit) r in
-                            (((FStar_Pervasives_Native.fst lbs), lbs'2),
-                              uu___5) in
-                          FStar_Syntax_Syntax.Tm_let uu___4 in
-                        FStar_Syntax_Syntax.mk uu___3 r in
-                      let env' =
-                        {
-                          FStar_TypeChecker_Env.solver =
-                            (env1.FStar_TypeChecker_Env.solver);
-                          FStar_TypeChecker_Env.range =
-                            (env1.FStar_TypeChecker_Env.range);
-                          FStar_TypeChecker_Env.curmodule =
-                            (env1.FStar_TypeChecker_Env.curmodule);
-                          FStar_TypeChecker_Env.gamma =
-                            (env1.FStar_TypeChecker_Env.gamma);
-                          FStar_TypeChecker_Env.gamma_sig =
-                            (env1.FStar_TypeChecker_Env.gamma_sig);
-                          FStar_TypeChecker_Env.gamma_cache =
-                            (env1.FStar_TypeChecker_Env.gamma_cache);
-                          FStar_TypeChecker_Env.modules =
-                            (env1.FStar_TypeChecker_Env.modules);
-                          FStar_TypeChecker_Env.expected_typ =
-                            (env1.FStar_TypeChecker_Env.expected_typ);
-                          FStar_TypeChecker_Env.sigtab =
-                            (env1.FStar_TypeChecker_Env.sigtab);
-                          FStar_TypeChecker_Env.attrtab =
-                            (env1.FStar_TypeChecker_Env.attrtab);
-                          FStar_TypeChecker_Env.instantiate_imp =
-                            (env1.FStar_TypeChecker_Env.instantiate_imp);
-                          FStar_TypeChecker_Env.effects =
-                            (env1.FStar_TypeChecker_Env.effects);
-                          FStar_TypeChecker_Env.generalize =
-                            should_generalize;
-                          FStar_TypeChecker_Env.letrecs =
-                            (env1.FStar_TypeChecker_Env.letrecs);
-                          FStar_TypeChecker_Env.top_level = true;
-                          FStar_TypeChecker_Env.check_uvars =
-                            (env1.FStar_TypeChecker_Env.check_uvars);
-                          FStar_TypeChecker_Env.use_eq_strict =
-                            (env1.FStar_TypeChecker_Env.use_eq_strict);
-                          FStar_TypeChecker_Env.is_iface =
-                            (env1.FStar_TypeChecker_Env.is_iface);
-                          FStar_TypeChecker_Env.admit =
-                            (env1.FStar_TypeChecker_Env.admit);
-                          FStar_TypeChecker_Env.lax =
-                            (env1.FStar_TypeChecker_Env.lax);
-                          FStar_TypeChecker_Env.lax_universes =
-                            (env1.FStar_TypeChecker_Env.lax_universes);
-                          FStar_TypeChecker_Env.phase1 =
-                            (env1.FStar_TypeChecker_Env.phase1);
-                          FStar_TypeChecker_Env.failhard =
-                            (env1.FStar_TypeChecker_Env.failhard);
-                          FStar_TypeChecker_Env.nosynth =
-                            (env1.FStar_TypeChecker_Env.nosynth);
-                          FStar_TypeChecker_Env.uvar_subtyping =
-                            (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                          FStar_TypeChecker_Env.tc_term =
-                            (env1.FStar_TypeChecker_Env.tc_term);
-                          FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                            (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                          FStar_TypeChecker_Env.universe_of =
-                            (env1.FStar_TypeChecker_Env.universe_of);
-                          FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                            =
-                            (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                          FStar_TypeChecker_Env.teq_nosmt_force =
-                            (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                          FStar_TypeChecker_Env.subtype_nosmt_force =
-                            (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                          FStar_TypeChecker_Env.qtbl_name_and_index =
-                            (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                          FStar_TypeChecker_Env.normalized_eff_names =
-                            (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                          FStar_TypeChecker_Env.fv_delta_depths =
-                            (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                          FStar_TypeChecker_Env.proof_ns =
-                            (env1.FStar_TypeChecker_Env.proof_ns);
-                          FStar_TypeChecker_Env.synth_hook =
-                            (env1.FStar_TypeChecker_Env.synth_hook);
-                          FStar_TypeChecker_Env.try_solve_implicits_hook =
-                            (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                          FStar_TypeChecker_Env.splice =
-                            (env1.FStar_TypeChecker_Env.splice);
-                          FStar_TypeChecker_Env.mpreprocess =
-                            (env1.FStar_TypeChecker_Env.mpreprocess);
-                          FStar_TypeChecker_Env.postprocess =
-                            (env1.FStar_TypeChecker_Env.postprocess);
-                          FStar_TypeChecker_Env.identifier_info =
-                            (env1.FStar_TypeChecker_Env.identifier_info);
-                          FStar_TypeChecker_Env.tc_hooks =
-                            (env1.FStar_TypeChecker_Env.tc_hooks);
-                          FStar_TypeChecker_Env.dsenv =
-                            (env1.FStar_TypeChecker_Env.dsenv);
-                          FStar_TypeChecker_Env.nbe =
-                            (env1.FStar_TypeChecker_Env.nbe);
-                          FStar_TypeChecker_Env.strict_args_tab =
-                            (env1.FStar_TypeChecker_Env.strict_args_tab);
-                          FStar_TypeChecker_Env.erasable_types_tab =
-                            (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                          FStar_TypeChecker_Env.enable_defer_to_tac =
-                            (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                          FStar_TypeChecker_Env.unif_allow_ref_guards =
-                            (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                          FStar_TypeChecker_Env.erase_erasable_args =
-                            (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                          FStar_TypeChecker_Env.core_check =
-                            (env1.FStar_TypeChecker_Env.core_check)
-                        } in
-                      let e1 =
-                        let uu___3 = do_two_phases env' in
-                        if uu___3
-                        then
-                          run_phase1
-                            (fun uu___4 ->
-                               let drop_lbtyp e_lax =
-                                 let uu___5 =
-                                   let uu___6 =
-                                     FStar_Syntax_Subst.compress e_lax in
-                                   uu___6.FStar_Syntax_Syntax.n in
-                                 match uu___5 with
-                                 | FStar_Syntax_Syntax.Tm_let
-                                     ((false, lb::[]), e2) ->
-                                     let lb_unannotated =
-                                       let uu___6 =
-                                         let uu___7 =
-                                           FStar_Syntax_Subst.compress e in
-                                         uu___7.FStar_Syntax_Syntax.n in
-                                       match uu___6 with
-                                       | FStar_Syntax_Syntax.Tm_let
-                                           ((uu___7, lb1::[]), uu___8) ->
-                                           let uu___9 =
-                                             let uu___10 =
-                                               FStar_Syntax_Subst.compress
-                                                 lb1.FStar_Syntax_Syntax.lbtyp in
-                                             uu___10.FStar_Syntax_Syntax.n in
-                                           (match uu___9 with
-                                            | FStar_Syntax_Syntax.Tm_unknown
-                                                -> true
-                                            | uu___10 -> false)
-                                       | uu___7 ->
-                                           failwith
-                                             "Impossible: first phase lb and second phase lb differ in structure!" in
-                                     if lb_unannotated
-                                     then
-                                       {
-                                         FStar_Syntax_Syntax.n =
-                                           (FStar_Syntax_Syntax.Tm_let
-                                              ((false,
-                                                 [{
-                                                    FStar_Syntax_Syntax.lbname
-                                                      =
-                                                      (lb.FStar_Syntax_Syntax.lbname);
-                                                    FStar_Syntax_Syntax.lbunivs
-                                                      =
-                                                      (lb.FStar_Syntax_Syntax.lbunivs);
-                                                    FStar_Syntax_Syntax.lbtyp
-                                                      =
-                                                      FStar_Syntax_Syntax.tun;
-                                                    FStar_Syntax_Syntax.lbeff
-                                                      =
-                                                      (lb.FStar_Syntax_Syntax.lbeff);
-                                                    FStar_Syntax_Syntax.lbdef
-                                                      =
-                                                      (lb.FStar_Syntax_Syntax.lbdef);
-                                                    FStar_Syntax_Syntax.lbattrs
-                                                      =
-                                                      (lb.FStar_Syntax_Syntax.lbattrs);
-                                                    FStar_Syntax_Syntax.lbpos
-                                                      =
-                                                      (lb.FStar_Syntax_Syntax.lbpos)
-                                                  }]), e2));
-                                         FStar_Syntax_Syntax.pos =
-                                           (e_lax.FStar_Syntax_Syntax.pos);
-                                         FStar_Syntax_Syntax.vars =
-                                           (e_lax.FStar_Syntax_Syntax.vars);
-                                         FStar_Syntax_Syntax.hash_code =
-                                           (e_lax.FStar_Syntax_Syntax.hash_code)
-                                       }
-                                     else e_lax
-                                 | FStar_Syntax_Syntax.Tm_let
-                                     ((true, lbs1), uu___6) ->
-                                     (FStar_Syntax_Util.check_mutual_universes
-                                        lbs1;
-                                      e_lax) in
-                               let e2 =
-                                 let uu___5 =
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_TypeChecker_Env.current_module
-                                         env1 in
-                                     FStar_Ident.string_of_lid uu___7 in
-                                   FStar_Pervasives_Native.Some uu___6 in
-                                 FStar_Profiling.profile
-                                   (fun uu___6 ->
-                                      let uu___7 =
-                                        FStar_TypeChecker_TcTerm.tc_maybe_toplevel_term
-                                          {
-                                            FStar_TypeChecker_Env.solver =
-                                              (env'.FStar_TypeChecker_Env.solver);
-                                            FStar_TypeChecker_Env.range =
-                                              (env'.FStar_TypeChecker_Env.range);
-                                            FStar_TypeChecker_Env.curmodule =
-                                              (env'.FStar_TypeChecker_Env.curmodule);
-                                            FStar_TypeChecker_Env.gamma =
-                                              (env'.FStar_TypeChecker_Env.gamma);
-                                            FStar_TypeChecker_Env.gamma_sig =
-                                              (env'.FStar_TypeChecker_Env.gamma_sig);
-                                            FStar_TypeChecker_Env.gamma_cache
-                                              =
-                                              (env'.FStar_TypeChecker_Env.gamma_cache);
-                                            FStar_TypeChecker_Env.modules =
-                                              (env'.FStar_TypeChecker_Env.modules);
-                                            FStar_TypeChecker_Env.expected_typ
-                                              =
-                                              (env'.FStar_TypeChecker_Env.expected_typ);
-                                            FStar_TypeChecker_Env.sigtab =
-                                              (env'.FStar_TypeChecker_Env.sigtab);
-                                            FStar_TypeChecker_Env.attrtab =
-                                              (env'.FStar_TypeChecker_Env.attrtab);
-                                            FStar_TypeChecker_Env.instantiate_imp
-                                              =
-                                              (env'.FStar_TypeChecker_Env.instantiate_imp);
-                                            FStar_TypeChecker_Env.effects =
-                                              (env'.FStar_TypeChecker_Env.effects);
-                                            FStar_TypeChecker_Env.generalize
-                                              =
-                                              (env'.FStar_TypeChecker_Env.generalize);
-                                            FStar_TypeChecker_Env.letrecs =
-                                              (env'.FStar_TypeChecker_Env.letrecs);
-                                            FStar_TypeChecker_Env.top_level =
-                                              (env'.FStar_TypeChecker_Env.top_level);
-                                            FStar_TypeChecker_Env.check_uvars
-                                              =
-                                              (env'.FStar_TypeChecker_Env.check_uvars);
-                                            FStar_TypeChecker_Env.use_eq_strict
-                                              =
-                                              (env'.FStar_TypeChecker_Env.use_eq_strict);
-                                            FStar_TypeChecker_Env.is_iface =
-                                              (env'.FStar_TypeChecker_Env.is_iface);
-                                            FStar_TypeChecker_Env.admit =
-                                              (env'.FStar_TypeChecker_Env.admit);
-                                            FStar_TypeChecker_Env.lax = true;
-                                            FStar_TypeChecker_Env.lax_universes
-                                              =
-                                              (env'.FStar_TypeChecker_Env.lax_universes);
-                                            FStar_TypeChecker_Env.phase1 =
-                                              true;
-                                            FStar_TypeChecker_Env.failhard =
-                                              (env'.FStar_TypeChecker_Env.failhard);
-                                            FStar_TypeChecker_Env.nosynth =
-                                              (env'.FStar_TypeChecker_Env.nosynth);
-                                            FStar_TypeChecker_Env.uvar_subtyping
-                                              =
-                                              (env'.FStar_TypeChecker_Env.uvar_subtyping);
-                                            FStar_TypeChecker_Env.tc_term =
-                                              (env'.FStar_TypeChecker_Env.tc_term);
-                                            FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                              =
-                                              (env'.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                            FStar_TypeChecker_Env.universe_of
-                                              =
-                                              (env'.FStar_TypeChecker_Env.universe_of);
-                                            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                              =
-                                              (env'.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                            FStar_TypeChecker_Env.teq_nosmt_force
-                                              =
-                                              (env'.FStar_TypeChecker_Env.teq_nosmt_force);
-                                            FStar_TypeChecker_Env.subtype_nosmt_force
-                                              =
-                                              (env'.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                            FStar_TypeChecker_Env.qtbl_name_and_index
-                                              =
-                                              (env'.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                            FStar_TypeChecker_Env.normalized_eff_names
-                                              =
-                                              (env'.FStar_TypeChecker_Env.normalized_eff_names);
-                                            FStar_TypeChecker_Env.fv_delta_depths
-                                              =
-                                              (env'.FStar_TypeChecker_Env.fv_delta_depths);
-                                            FStar_TypeChecker_Env.proof_ns =
-                                              (env'.FStar_TypeChecker_Env.proof_ns);
-                                            FStar_TypeChecker_Env.synth_hook
-                                              =
-                                              (env'.FStar_TypeChecker_Env.synth_hook);
-                                            FStar_TypeChecker_Env.try_solve_implicits_hook
-                                              =
-                                              (env'.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                            FStar_TypeChecker_Env.splice =
-                                              (env'.FStar_TypeChecker_Env.splice);
-                                            FStar_TypeChecker_Env.mpreprocess
-                                              =
-                                              (env'.FStar_TypeChecker_Env.mpreprocess);
-                                            FStar_TypeChecker_Env.postprocess
-                                              =
-                                              (env'.FStar_TypeChecker_Env.postprocess);
-                                            FStar_TypeChecker_Env.identifier_info
-                                              =
-                                              (env'.FStar_TypeChecker_Env.identifier_info);
-                                            FStar_TypeChecker_Env.tc_hooks =
-                                              (env'.FStar_TypeChecker_Env.tc_hooks);
-                                            FStar_TypeChecker_Env.dsenv =
-                                              (env'.FStar_TypeChecker_Env.dsenv);
-                                            FStar_TypeChecker_Env.nbe =
-                                              (env'.FStar_TypeChecker_Env.nbe);
-                                            FStar_TypeChecker_Env.strict_args_tab
-                                              =
-                                              (env'.FStar_TypeChecker_Env.strict_args_tab);
-                                            FStar_TypeChecker_Env.erasable_types_tab
-                                              =
-                                              (env'.FStar_TypeChecker_Env.erasable_types_tab);
-                                            FStar_TypeChecker_Env.enable_defer_to_tac
-                                              =
-                                              (env'.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                            FStar_TypeChecker_Env.unif_allow_ref_guards
-                                              =
-                                              (env'.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                            FStar_TypeChecker_Env.erase_erasable_args
-                                              =
-                                              (env'.FStar_TypeChecker_Env.erase_erasable_args);
-                                            FStar_TypeChecker_Env.core_check
-                                              =
-                                              (env'.FStar_TypeChecker_Env.core_check)
-                                          } e in
-                                      match uu___7 with
-                                      | (e3, uu___8, uu___9) -> e3) uu___5
-                                   "FStar.TypeChecker.Tc.tc_sig_let-tc-phase1" in
-                               (let uu___6 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env1)
-                                    (FStar_Options.Other "TwoPhases") in
-                                if uu___6
-                                then
-                                  let uu___7 =
-                                    FStar_Syntax_Print.term_to_string e2 in
-                                  FStar_Compiler_Util.print1
-                                    "Let binding after phase 1, before removing uvars: %s\n"
-                                    uu___7
-                                else ());
-                               (let e3 =
-                                  let uu___6 =
-                                    FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                      env' e2 in
-                                  FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                    drop_lbtyp in
-                                (let uu___7 =
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env1)
-                                     (FStar_Options.Other "TwoPhases") in
-                                 if uu___7
-                                 then
-                                   let uu___8 =
-                                     FStar_Syntax_Print.term_to_string e3 in
-                                   FStar_Compiler_Util.print1
-                                     "Let binding after phase 1, uvars removed: %s\n"
-                                     uu___8
-                                 else ());
-                                e3))
-                        else e in
-                      let uu___3 =
-                        handle_postprocess_with_attr env1
-                          se1.FStar_Syntax_Syntax.sigattrs in
-                      (match uu___3 with
-                       | (attrs1, post_tau) ->
-                           let se2 =
-                             {
-                               FStar_Syntax_Syntax.sigel =
-                                 (se1.FStar_Syntax_Syntax.sigel);
-                               FStar_Syntax_Syntax.sigrng =
-                                 (se1.FStar_Syntax_Syntax.sigrng);
-                               FStar_Syntax_Syntax.sigquals =
-                                 (se1.FStar_Syntax_Syntax.sigquals);
-                               FStar_Syntax_Syntax.sigmeta =
-                                 (se1.FStar_Syntax_Syntax.sigmeta);
-                               FStar_Syntax_Syntax.sigattrs = attrs1;
-                               FStar_Syntax_Syntax.sigopts =
-                                 (se1.FStar_Syntax_Syntax.sigopts)
-                             } in
-                           let postprocess_lb tau lb =
-                             let uu___4 =
-                               FStar_Syntax_Subst.univ_var_opening
-                                 lb.FStar_Syntax_Syntax.lbunivs in
-                             match uu___4 with
-                             | (s, univnames) ->
-                                 let lbdef =
-                                   FStar_Syntax_Subst.subst s
-                                     lb.FStar_Syntax_Syntax.lbdef in
-                                 let lbtyp =
-                                   FStar_Syntax_Subst.subst s
-                                     lb.FStar_Syntax_Syntax.lbtyp in
-                                 let env2 =
-                                   FStar_TypeChecker_Env.push_univ_vars env1
-                                     univnames in
-                                 let lbdef1 =
-                                   FStar_TypeChecker_Env.postprocess env2 tau
-                                     lbtyp lbdef in
-                                 let lbdef2 =
-                                   FStar_Syntax_Subst.close_univ_vars
-                                     univnames lbdef1 in
-                                 {
-                                   FStar_Syntax_Syntax.lbname =
-                                     (lb.FStar_Syntax_Syntax.lbname);
-                                   FStar_Syntax_Syntax.lbunivs =
-                                     (lb.FStar_Syntax_Syntax.lbunivs);
-                                   FStar_Syntax_Syntax.lbtyp =
-                                     (lb.FStar_Syntax_Syntax.lbtyp);
-                                   FStar_Syntax_Syntax.lbeff =
-                                     (lb.FStar_Syntax_Syntax.lbeff);
-                                   FStar_Syntax_Syntax.lbdef = lbdef2;
-                                   FStar_Syntax_Syntax.lbattrs =
-                                     (lb.FStar_Syntax_Syntax.lbattrs);
-                                   FStar_Syntax_Syntax.lbpos =
-                                     (lb.FStar_Syntax_Syntax.lbpos)
-                                 } in
-                           let r1 =
-                             let should_generalize1 =
-                               let uu___4 = do_two_phases env' in
-                               Prims.op_Negation uu___4 in
-                             let uu___4 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_TypeChecker_Env.current_module env1 in
-                                 FStar_Ident.string_of_lid uu___6 in
-                               FStar_Pervasives_Native.Some uu___5 in
-                             FStar_Profiling.profile
-                               (fun uu___5 ->
-                                  FStar_TypeChecker_TcTerm.tc_maybe_toplevel_term
-                                    {
-                                      FStar_TypeChecker_Env.solver =
-                                        (env'.FStar_TypeChecker_Env.solver);
-                                      FStar_TypeChecker_Env.range =
-                                        (env'.FStar_TypeChecker_Env.range);
-                                      FStar_TypeChecker_Env.curmodule =
-                                        (env'.FStar_TypeChecker_Env.curmodule);
-                                      FStar_TypeChecker_Env.gamma =
-                                        (env'.FStar_TypeChecker_Env.gamma);
-                                      FStar_TypeChecker_Env.gamma_sig =
-                                        (env'.FStar_TypeChecker_Env.gamma_sig);
-                                      FStar_TypeChecker_Env.gamma_cache =
-                                        (env'.FStar_TypeChecker_Env.gamma_cache);
-                                      FStar_TypeChecker_Env.modules =
-                                        (env'.FStar_TypeChecker_Env.modules);
-                                      FStar_TypeChecker_Env.expected_typ =
-                                        (env'.FStar_TypeChecker_Env.expected_typ);
-                                      FStar_TypeChecker_Env.sigtab =
-                                        (env'.FStar_TypeChecker_Env.sigtab);
-                                      FStar_TypeChecker_Env.attrtab =
-                                        (env'.FStar_TypeChecker_Env.attrtab);
-                                      FStar_TypeChecker_Env.instantiate_imp =
-                                        (env'.FStar_TypeChecker_Env.instantiate_imp);
-                                      FStar_TypeChecker_Env.effects =
-                                        (env'.FStar_TypeChecker_Env.effects);
-                                      FStar_TypeChecker_Env.generalize =
-                                        should_generalize1;
-                                      FStar_TypeChecker_Env.letrecs =
-                                        (env'.FStar_TypeChecker_Env.letrecs);
-                                      FStar_TypeChecker_Env.top_level =
-                                        (env'.FStar_TypeChecker_Env.top_level);
-                                      FStar_TypeChecker_Env.check_uvars =
-                                        (env'.FStar_TypeChecker_Env.check_uvars);
-                                      FStar_TypeChecker_Env.use_eq_strict =
-                                        (env'.FStar_TypeChecker_Env.use_eq_strict);
-                                      FStar_TypeChecker_Env.is_iface =
-                                        (env'.FStar_TypeChecker_Env.is_iface);
-                                      FStar_TypeChecker_Env.admit =
-                                        (env'.FStar_TypeChecker_Env.admit);
-                                      FStar_TypeChecker_Env.lax =
-                                        (env'.FStar_TypeChecker_Env.lax);
-                                      FStar_TypeChecker_Env.lax_universes =
-                                        (env'.FStar_TypeChecker_Env.lax_universes);
-                                      FStar_TypeChecker_Env.phase1 =
-                                        (env'.FStar_TypeChecker_Env.phase1);
-                                      FStar_TypeChecker_Env.failhard =
-                                        (env'.FStar_TypeChecker_Env.failhard);
-                                      FStar_TypeChecker_Env.nosynth =
-                                        (env'.FStar_TypeChecker_Env.nosynth);
-                                      FStar_TypeChecker_Env.uvar_subtyping =
-                                        (env'.FStar_TypeChecker_Env.uvar_subtyping);
-                                      FStar_TypeChecker_Env.tc_term =
-                                        (env'.FStar_TypeChecker_Env.tc_term);
-                                      FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                        =
-                                        (env'.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                      FStar_TypeChecker_Env.universe_of =
-                                        (env'.FStar_TypeChecker_Env.universe_of);
-                                      FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                        =
-                                        (env'.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                      FStar_TypeChecker_Env.teq_nosmt_force =
-                                        (env'.FStar_TypeChecker_Env.teq_nosmt_force);
-                                      FStar_TypeChecker_Env.subtype_nosmt_force
-                                        =
-                                        (env'.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                      FStar_TypeChecker_Env.qtbl_name_and_index
-                                        =
-                                        (env'.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                      FStar_TypeChecker_Env.normalized_eff_names
-                                        =
-                                        (env'.FStar_TypeChecker_Env.normalized_eff_names);
-                                      FStar_TypeChecker_Env.fv_delta_depths =
-                                        (env'.FStar_TypeChecker_Env.fv_delta_depths);
-                                      FStar_TypeChecker_Env.proof_ns =
-                                        (env'.FStar_TypeChecker_Env.proof_ns);
-                                      FStar_TypeChecker_Env.synth_hook =
-                                        (env'.FStar_TypeChecker_Env.synth_hook);
-                                      FStar_TypeChecker_Env.try_solve_implicits_hook
-                                        =
-                                        (env'.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                      FStar_TypeChecker_Env.splice =
-                                        (env'.FStar_TypeChecker_Env.splice);
-                                      FStar_TypeChecker_Env.mpreprocess =
-                                        (env'.FStar_TypeChecker_Env.mpreprocess);
-                                      FStar_TypeChecker_Env.postprocess =
-                                        (env'.FStar_TypeChecker_Env.postprocess);
-                                      FStar_TypeChecker_Env.identifier_info =
-                                        (env'.FStar_TypeChecker_Env.identifier_info);
-                                      FStar_TypeChecker_Env.tc_hooks =
-                                        (env'.FStar_TypeChecker_Env.tc_hooks);
-                                      FStar_TypeChecker_Env.dsenv =
-                                        (env'.FStar_TypeChecker_Env.dsenv);
-                                      FStar_TypeChecker_Env.nbe =
-                                        (env'.FStar_TypeChecker_Env.nbe);
-                                      FStar_TypeChecker_Env.strict_args_tab =
-                                        (env'.FStar_TypeChecker_Env.strict_args_tab);
-                                      FStar_TypeChecker_Env.erasable_types_tab
-                                        =
-                                        (env'.FStar_TypeChecker_Env.erasable_types_tab);
-                                      FStar_TypeChecker_Env.enable_defer_to_tac
-                                        =
-                                        (env'.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                      FStar_TypeChecker_Env.unif_allow_ref_guards
-                                        =
-                                        (env'.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                      FStar_TypeChecker_Env.erase_erasable_args
-                                        =
-                                        (env'.FStar_TypeChecker_Env.erase_erasable_args);
-                                      FStar_TypeChecker_Env.core_check =
-                                        (env'.FStar_TypeChecker_Env.core_check)
-                                    } e1) uu___4
-                               "FStar.TypeChecker.Tc.tc_sig_let-tc-phase2" in
-                           let uu___4 =
-                             match r1 with
-                             | ({
-                                  FStar_Syntax_Syntax.n =
-                                    FStar_Syntax_Syntax.Tm_let (lbs1, e2);
-                                  FStar_Syntax_Syntax.pos = uu___5;
-                                  FStar_Syntax_Syntax.vars = uu___6;
-                                  FStar_Syntax_Syntax.hash_code = uu___7;_},
-                                uu___8, g) when
-                                 FStar_TypeChecker_Env.is_trivial g ->
-                                 (FStar_Syntax_Util.check_mutual_universes
-                                    (FStar_Pervasives_Native.snd lbs1);
-                                  (let lbs2 =
-                                     let uu___10 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         (FStar_Pervasives_Native.snd lbs1)
-                                         (FStar_Compiler_List.map
-                                            rename_parameters) in
-                                     ((FStar_Pervasives_Native.fst lbs1),
-                                       uu___10) in
-                                   let lbs3 =
-                                     let uu___10 =
-                                       match post_tau with
-                                       | FStar_Pervasives_Native.Some tau ->
-                                           FStar_Compiler_List.map
-                                             (postprocess_lb tau)
-                                             (FStar_Pervasives_Native.snd
-                                                lbs2)
-                                       | FStar_Pervasives_Native.None ->
-                                           FStar_Pervasives_Native.snd lbs2 in
-                                     ((FStar_Pervasives_Native.fst lbs2),
-                                       uu___10) in
-                                   let quals1 =
-                                     match e2.FStar_Syntax_Syntax.n with
-                                     | FStar_Syntax_Syntax.Tm_meta
-                                         (uu___10,
-                                          FStar_Syntax_Syntax.Meta_desugared
-                                          (FStar_Syntax_Syntax.Masked_effect))
-                                         ->
-                                         FStar_Syntax_Syntax.HasMaskedEffect
-                                         :: quals
-                                     | uu___10 -> quals in
-                                   ({
-                                      FStar_Syntax_Syntax.sigel =
-                                        (FStar_Syntax_Syntax.Sig_let
-                                           (lbs3, lids));
-                                      FStar_Syntax_Syntax.sigrng =
-                                        (se2.FStar_Syntax_Syntax.sigrng);
-                                      FStar_Syntax_Syntax.sigquals = quals1;
-                                      FStar_Syntax_Syntax.sigmeta =
-                                        (se2.FStar_Syntax_Syntax.sigmeta);
-                                      FStar_Syntax_Syntax.sigattrs =
-                                        (se2.FStar_Syntax_Syntax.sigattrs);
-                                      FStar_Syntax_Syntax.sigopts =
-                                        (se2.FStar_Syntax_Syntax.sigopts)
-                                    }, lbs3)))
-                             | uu___5 ->
-                                 failwith
-                                   "impossible (typechecking should preserve Tm_let)" in
-                           (match uu___4 with
-                            | (se3, lbs1) ->
-                                ((let uu___6 =
-                                    FStar_Syntax_Util.has_attribute
-                                      se3.FStar_Syntax_Syntax.sigattrs
-                                      FStar_Parser_Const.no_subtping_attr_lid in
-                                  if uu___6
-                                  then
-                                    let env'1 =
-                                      {
-                                        FStar_TypeChecker_Env.solver =
-                                          (env'.FStar_TypeChecker_Env.solver);
-                                        FStar_TypeChecker_Env.range =
-                                          (env'.FStar_TypeChecker_Env.range);
-                                        FStar_TypeChecker_Env.curmodule =
-                                          (env'.FStar_TypeChecker_Env.curmodule);
-                                        FStar_TypeChecker_Env.gamma =
-                                          (env'.FStar_TypeChecker_Env.gamma);
-                                        FStar_TypeChecker_Env.gamma_sig =
-                                          (env'.FStar_TypeChecker_Env.gamma_sig);
-                                        FStar_TypeChecker_Env.gamma_cache =
-                                          (env'.FStar_TypeChecker_Env.gamma_cache);
-                                        FStar_TypeChecker_Env.modules =
-                                          (env'.FStar_TypeChecker_Env.modules);
-                                        FStar_TypeChecker_Env.expected_typ =
-                                          (env'.FStar_TypeChecker_Env.expected_typ);
-                                        FStar_TypeChecker_Env.sigtab =
-                                          (env'.FStar_TypeChecker_Env.sigtab);
-                                        FStar_TypeChecker_Env.attrtab =
-                                          (env'.FStar_TypeChecker_Env.attrtab);
-                                        FStar_TypeChecker_Env.instantiate_imp
-                                          =
-                                          (env'.FStar_TypeChecker_Env.instantiate_imp);
-                                        FStar_TypeChecker_Env.effects =
-                                          (env'.FStar_TypeChecker_Env.effects);
-                                        FStar_TypeChecker_Env.generalize =
-                                          (env'.FStar_TypeChecker_Env.generalize);
-                                        FStar_TypeChecker_Env.letrecs =
-                                          (env'.FStar_TypeChecker_Env.letrecs);
-                                        FStar_TypeChecker_Env.top_level =
-                                          (env'.FStar_TypeChecker_Env.top_level);
-                                        FStar_TypeChecker_Env.check_uvars =
-                                          (env'.FStar_TypeChecker_Env.check_uvars);
-                                        FStar_TypeChecker_Env.use_eq_strict =
-                                          true;
-                                        FStar_TypeChecker_Env.is_iface =
-                                          (env'.FStar_TypeChecker_Env.is_iface);
-                                        FStar_TypeChecker_Env.admit =
-                                          (env'.FStar_TypeChecker_Env.admit);
-                                        FStar_TypeChecker_Env.lax =
-                                          (env'.FStar_TypeChecker_Env.lax);
-                                        FStar_TypeChecker_Env.lax_universes =
-                                          (env'.FStar_TypeChecker_Env.lax_universes);
-                                        FStar_TypeChecker_Env.phase1 =
-                                          (env'.FStar_TypeChecker_Env.phase1);
-                                        FStar_TypeChecker_Env.failhard =
-                                          (env'.FStar_TypeChecker_Env.failhard);
-                                        FStar_TypeChecker_Env.nosynth =
-                                          (env'.FStar_TypeChecker_Env.nosynth);
-                                        FStar_TypeChecker_Env.uvar_subtyping
-                                          =
-                                          (env'.FStar_TypeChecker_Env.uvar_subtyping);
-                                        FStar_TypeChecker_Env.tc_term =
-                                          (env'.FStar_TypeChecker_Env.tc_term);
-                                        FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                          =
-                                          (env'.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                        FStar_TypeChecker_Env.universe_of =
-                                          (env'.FStar_TypeChecker_Env.universe_of);
-                                        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                          =
-                                          (env'.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                        FStar_TypeChecker_Env.teq_nosmt_force
-                                          =
-                                          (env'.FStar_TypeChecker_Env.teq_nosmt_force);
-                                        FStar_TypeChecker_Env.subtype_nosmt_force
-                                          =
-                                          (env'.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                        FStar_TypeChecker_Env.qtbl_name_and_index
-                                          =
-                                          (env'.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                        FStar_TypeChecker_Env.normalized_eff_names
-                                          =
-                                          (env'.FStar_TypeChecker_Env.normalized_eff_names);
-                                        FStar_TypeChecker_Env.fv_delta_depths
-                                          =
-                                          (env'.FStar_TypeChecker_Env.fv_delta_depths);
-                                        FStar_TypeChecker_Env.proof_ns =
-                                          (env'.FStar_TypeChecker_Env.proof_ns);
-                                        FStar_TypeChecker_Env.synth_hook =
-                                          (env'.FStar_TypeChecker_Env.synth_hook);
-                                        FStar_TypeChecker_Env.try_solve_implicits_hook
-                                          =
-                                          (env'.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                        FStar_TypeChecker_Env.splice =
-                                          (env'.FStar_TypeChecker_Env.splice);
-                                        FStar_TypeChecker_Env.mpreprocess =
-                                          (env'.FStar_TypeChecker_Env.mpreprocess);
-                                        FStar_TypeChecker_Env.postprocess =
-                                          (env'.FStar_TypeChecker_Env.postprocess);
-                                        FStar_TypeChecker_Env.identifier_info
-                                          =
-                                          (env'.FStar_TypeChecker_Env.identifier_info);
-                                        FStar_TypeChecker_Env.tc_hooks =
-                                          (env'.FStar_TypeChecker_Env.tc_hooks);
-                                        FStar_TypeChecker_Env.dsenv =
-                                          (env'.FStar_TypeChecker_Env.dsenv);
-                                        FStar_TypeChecker_Env.nbe =
-                                          (env'.FStar_TypeChecker_Env.nbe);
-                                        FStar_TypeChecker_Env.strict_args_tab
-                                          =
-                                          (env'.FStar_TypeChecker_Env.strict_args_tab);
-                                        FStar_TypeChecker_Env.erasable_types_tab
-                                          =
-                                          (env'.FStar_TypeChecker_Env.erasable_types_tab);
-                                        FStar_TypeChecker_Env.enable_defer_to_tac
-                                          =
-                                          (env'.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                        FStar_TypeChecker_Env.unif_allow_ref_guards
-                                          =
-                                          (env'.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                        FStar_TypeChecker_Env.erase_erasable_args
-                                          =
-                                          (env'.FStar_TypeChecker_Env.erase_erasable_args);
-                                        FStar_TypeChecker_Env.core_check =
-                                          (env'.FStar_TypeChecker_Env.core_check)
-                                      } in
-                                    let err s pos =
-                                      FStar_Errors.raise_error
-                                        (FStar_Errors.Fatal_InconsistentQualifierAnnotation,
-                                          s) pos in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      (FStar_Pervasives_Native.snd lbs1)
-                                      (FStar_Compiler_List.iter
-                                         (fun lb ->
-                                            let uu___7 =
-                                              let uu___8 =
-                                                FStar_Syntax_Util.is_lemma
-                                                  lb.FStar_Syntax_Syntax.lbtyp in
-                                              Prims.op_Negation uu___8 in
-                                            if uu___7
-                                            then
-                                              err
-                                                "no_subtype annotation on a non-lemma"
-                                                lb.FStar_Syntax_Syntax.lbpos
-                                            else
-                                              (let lid_opt =
-                                                 let uu___9 =
-                                                   let uu___10 =
-                                                     FStar_Syntax_Free.fvars
-                                                       lb.FStar_Syntax_Syntax.lbtyp in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___10
-                                                     FStar_Compiler_Util.set_elements in
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   uu___9
-                                                   (FStar_Compiler_List.tryFind
-                                                      (fun lid ->
-                                                         let uu___10 =
-                                                           (let uu___11 =
-                                                              let uu___12 =
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  lid
-                                                                  FStar_Ident.path_of_lid in
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                uu___12
-                                                                FStar_Compiler_List.hd in
-                                                            uu___11 = "Prims")
-                                                             ||
-                                                             (FStar_Ident.lid_equals
-                                                                lid
-                                                                FStar_Parser_Const.pattern_lid) in
-                                                         Prims.op_Negation
-                                                           uu___10)) in
-                                               let uu___9 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   lid_opt
-                                                   FStar_Compiler_Util.is_some in
-                                               if uu___9
-                                               then
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     let uu___12 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         lid_opt
-                                                         FStar_Compiler_Util.must in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___12
-                                                       FStar_Ident.string_of_lid in
-                                                   FStar_Compiler_Util.format1
-                                                     "%s is not allowed in no_subtyping lemmas (only prims symbols)"
-                                                     uu___11 in
-                                                 err uu___10
-                                                   lb.FStar_Syntax_Syntax.lbpos
-                                               else
-                                                 (let uu___11 =
-                                                    FStar_Syntax_Util.type_u
-                                                      () in
-                                                  match uu___11 with
-                                                  | (t, uu___12) ->
-                                                      let uu___13 =
-                                                        FStar_Syntax_Subst.open_univ_vars
-                                                          lb.FStar_Syntax_Syntax.lbunivs
-                                                          lb.FStar_Syntax_Syntax.lbtyp in
-                                                      (match uu___13 with
-                                                       | (uvs, lbtyp) ->
-                                                           let uu___14 =
-                                                             let uu___15 =
-                                                               FStar_TypeChecker_Env.push_univ_vars
-                                                                 env'1 uvs in
-                                                             FStar_TypeChecker_TcTerm.tc_check_tot_or_gtot_term
-                                                               uu___15 lbtyp
-                                                               t
-                                                               "checking no_subtype annotation" in
-                                                           (match uu___14
-                                                            with
-                                                            | (uu___15,
-                                                               uu___16, g) ->
-                                                                FStar_TypeChecker_Rel.force_trivial_guard
-                                                                  env'1 g))))))
-                                  else ());
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   (FStar_Pervasives_Native.snd lbs1)
-                                   (FStar_Compiler_List.iter
-                                      (fun lb ->
-                                         let fv =
-                                           FStar_Compiler_Util.right
-                                             lb.FStar_Syntax_Syntax.lbname in
-                                         FStar_TypeChecker_Env.insert_fv_info
-                                           env1 fv
-                                           lb.FStar_Syntax_Syntax.lbtyp));
-                                 (let uu___8 = log env1 in
-                                  if uu___8
-                                  then
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          (FStar_Pervasives_Native.snd lbs1)
-                                          (FStar_Compiler_List.map
-                                             (fun lb ->
-                                                let should_log =
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          FStar_Compiler_Util.right
-                                                            lb.FStar_Syntax_Syntax.lbname in
-                                                        uu___14.FStar_Syntax_Syntax.fv_name in
-                                                      uu___13.FStar_Syntax_Syntax.v in
-                                                    FStar_TypeChecker_Env.try_lookup_val_decl
-                                                      env1 uu___12 in
-                                                  match uu___11 with
-                                                  | FStar_Pervasives_Native.None
-                                                      -> true
-                                                  | uu___12 -> false in
-                                                if should_log
-                                                then
-                                                  let uu___11 =
-                                                    FStar_Syntax_Print.lbname_to_string
-                                                      lb.FStar_Syntax_Syntax.lbname in
-                                                  let uu___12 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      lb.FStar_Syntax_Syntax.lbtyp in
-                                                  FStar_Compiler_Util.format2
-                                                    "let %s : %s" uu___11
-                                                    uu___12
-                                                else "")) in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___10 (FStar_String.concat "\n") in
-                                    FStar_Compiler_Util.print1 "%s\n" uu___9
-                                  else ());
-                                 check_must_erase_attribute env0 se3;
-                                 check_typeclass_instance_attribute env0 se3;
-                                 ([se3], [], env0))))))
-let (tc_decl' :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_Syntax_Syntax.sigelt Prims.list * FStar_Syntax_Syntax.sigelt
-        Prims.list * FStar_TypeChecker_Env.env))
-  =
-  fun env0 ->
-    fun se ->
-      let env = env0 in
-      let se1 =
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_fail uu___ -> se
-        | uu___ -> tc_decl_attributes env se in
-      FStar_TypeChecker_Util.check_sigelt_quals env se1;
-      proc_check_with se1.FStar_Syntax_Syntax.sigattrs
-        (fun uu___1 ->
-           let r = se1.FStar_Syntax_Syntax.sigrng in
-           let se2 =
-             let uu___2 = FStar_Options.record_options () in
-             if uu___2 then store_sigopts se1 else se1 in
-           match se2.FStar_Syntax_Syntax.sigel with
-           | FStar_Syntax_Syntax.Sig_inductive_typ uu___2 ->
-               failwith "Impossible bare data-constructor"
-           | FStar_Syntax_Syntax.Sig_datacon uu___2 ->
-               failwith "Impossible bare data-constructor"
-           | FStar_Syntax_Syntax.Sig_fail (uu___2, false, uu___3) when
-               (let uu___4 = FStar_TypeChecker_Env.should_verify env in
-                Prims.op_Negation uu___4) ||
-                 (FStar_Options.admit_smt_queries ())
-               -> ([], [], env)
-           | FStar_Syntax_Syntax.Sig_fail (expected_errors, lax, ses) ->
-               let env' =
-                 if lax
-                 then
-                   {
-                     FStar_TypeChecker_Env.solver =
-                       (env.FStar_TypeChecker_Env.solver);
-                     FStar_TypeChecker_Env.range =
-                       (env.FStar_TypeChecker_Env.range);
-                     FStar_TypeChecker_Env.curmodule =
-                       (env.FStar_TypeChecker_Env.curmodule);
-                     FStar_TypeChecker_Env.gamma =
-                       (env.FStar_TypeChecker_Env.gamma);
-                     FStar_TypeChecker_Env.gamma_sig =
-                       (env.FStar_TypeChecker_Env.gamma_sig);
-                     FStar_TypeChecker_Env.gamma_cache =
-                       (env.FStar_TypeChecker_Env.gamma_cache);
-                     FStar_TypeChecker_Env.modules =
-                       (env.FStar_TypeChecker_Env.modules);
-                     FStar_TypeChecker_Env.expected_typ =
-                       (env.FStar_TypeChecker_Env.expected_typ);
-                     FStar_TypeChecker_Env.sigtab =
-                       (env.FStar_TypeChecker_Env.sigtab);
-                     FStar_TypeChecker_Env.attrtab =
-                       (env.FStar_TypeChecker_Env.attrtab);
-                     FStar_TypeChecker_Env.instantiate_imp =
-                       (env.FStar_TypeChecker_Env.instantiate_imp);
-                     FStar_TypeChecker_Env.effects =
-                       (env.FStar_TypeChecker_Env.effects);
-                     FStar_TypeChecker_Env.generalize =
-                       (env.FStar_TypeChecker_Env.generalize);
-                     FStar_TypeChecker_Env.letrecs =
-                       (env.FStar_TypeChecker_Env.letrecs);
-                     FStar_TypeChecker_Env.top_level =
-                       (env.FStar_TypeChecker_Env.top_level);
-                     FStar_TypeChecker_Env.check_uvars =
-                       (env.FStar_TypeChecker_Env.check_uvars);
-                     FStar_TypeChecker_Env.use_eq_strict =
-                       (env.FStar_TypeChecker_Env.use_eq_strict);
-                     FStar_TypeChecker_Env.is_iface =
-                       (env.FStar_TypeChecker_Env.is_iface);
-                     FStar_TypeChecker_Env.admit =
-                       (env.FStar_TypeChecker_Env.admit);
-                     FStar_TypeChecker_Env.lax = true;
-                     FStar_TypeChecker_Env.lax_universes =
-                       (env.FStar_TypeChecker_Env.lax_universes);
-                     FStar_TypeChecker_Env.phase1 =
-                       (env.FStar_TypeChecker_Env.phase1);
-                     FStar_TypeChecker_Env.failhard =
-                       (env.FStar_TypeChecker_Env.failhard);
-                     FStar_TypeChecker_Env.nosynth =
-                       (env.FStar_TypeChecker_Env.nosynth);
-                     FStar_TypeChecker_Env.uvar_subtyping =
-                       (env.FStar_TypeChecker_Env.uvar_subtyping);
-                     FStar_TypeChecker_Env.tc_term =
-                       (env.FStar_TypeChecker_Env.tc_term);
-                     FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                       (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                     FStar_TypeChecker_Env.universe_of =
-                       (env.FStar_TypeChecker_Env.universe_of);
-                     FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                       =
-                       (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                     FStar_TypeChecker_Env.teq_nosmt_force =
-                       (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                     FStar_TypeChecker_Env.subtype_nosmt_force =
-                       (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                     FStar_TypeChecker_Env.qtbl_name_and_index =
-                       (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                     FStar_TypeChecker_Env.normalized_eff_names =
-                       (env.FStar_TypeChecker_Env.normalized_eff_names);
-                     FStar_TypeChecker_Env.fv_delta_depths =
-                       (env.FStar_TypeChecker_Env.fv_delta_depths);
-                     FStar_TypeChecker_Env.proof_ns =
-                       (env.FStar_TypeChecker_Env.proof_ns);
-                     FStar_TypeChecker_Env.synth_hook =
-                       (env.FStar_TypeChecker_Env.synth_hook);
-                     FStar_TypeChecker_Env.try_solve_implicits_hook =
-                       (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                     FStar_TypeChecker_Env.splice =
-                       (env.FStar_TypeChecker_Env.splice);
-                     FStar_TypeChecker_Env.mpreprocess =
-                       (env.FStar_TypeChecker_Env.mpreprocess);
-                     FStar_TypeChecker_Env.postprocess =
-                       (env.FStar_TypeChecker_Env.postprocess);
-                     FStar_TypeChecker_Env.identifier_info =
-                       (env.FStar_TypeChecker_Env.identifier_info);
-                     FStar_TypeChecker_Env.tc_hooks =
-                       (env.FStar_TypeChecker_Env.tc_hooks);
-                     FStar_TypeChecker_Env.dsenv =
-                       (env.FStar_TypeChecker_Env.dsenv);
-                     FStar_TypeChecker_Env.nbe =
-                       (env.FStar_TypeChecker_Env.nbe);
-                     FStar_TypeChecker_Env.strict_args_tab =
-                       (env.FStar_TypeChecker_Env.strict_args_tab);
-                     FStar_TypeChecker_Env.erasable_types_tab =
-                       (env.FStar_TypeChecker_Env.erasable_types_tab);
-                     FStar_TypeChecker_Env.enable_defer_to_tac =
-                       (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                     FStar_TypeChecker_Env.unif_allow_ref_guards =
-                       (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                     FStar_TypeChecker_Env.erase_erasable_args =
-                       (env.FStar_TypeChecker_Env.erase_erasable_args);
-                     FStar_TypeChecker_Env.core_check =
-                       (env.FStar_TypeChecker_Env.core_check)
-                   }
-                 else env in
-               let env'1 = FStar_TypeChecker_Env.push env' "expect_failure" in
-               ((let uu___3 =
-                   FStar_TypeChecker_Env.debug env FStar_Options.Low in
-                 if uu___3
-                 then
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Compiler_List.map
-                         FStar_Compiler_Util.string_of_int expected_errors in
-                     FStar_Compiler_Effect.op_Less_Bar
-                       (FStar_String.concat "; ") uu___5 in
-                   FStar_Compiler_Util.print1 ">> Expecting errors: [%s]\n"
-                     uu___4
-                 else ());
-                (let uu___3 =
-                   FStar_Errors.catch_errors
-                     (fun uu___4 ->
-                        FStar_Options.with_saved_options
-                          (fun uu___5 ->
-                             let uu___6 =
-                               let uu___7 =
-                                 FStar_Compiler_Effect.op_Bang tc_decls_knot in
-                               FStar_Compiler_Util.must uu___7 in
-                             uu___6 env'1 ses)) in
-                 match uu___3 with
-                 | (errs, uu___4) ->
-                     ((let uu___6 =
-                         (FStar_Options.print_expected_failures ()) ||
-                           (FStar_TypeChecker_Env.debug env FStar_Options.Low) in
-                       if uu___6
-                       then
-                         (FStar_Compiler_Util.print_string
-                            ">> Got issues: [\n";
-                          FStar_Compiler_List.iter FStar_Errors.print_issue
-                            errs;
-                          FStar_Compiler_Util.print_string ">>]\n")
-                       else ());
-                      (let uu___6 =
-                         FStar_TypeChecker_Env.pop env'1 "expect_failure" in
-                       let actual_errors =
-                         FStar_Compiler_List.concatMap
-                           (fun i ->
-                              FStar_Common.list_of_option
-                                i.FStar_Errors.issue_number) errs in
-                       (match errs with
-                        | [] ->
-                            (FStar_Compiler_List.iter
-                               FStar_Errors.print_issue errs;
-                             FStar_Errors.log_issue
-                               se2.FStar_Syntax_Syntax.sigrng
-                               (FStar_Errors.Error_DidNotFail,
-                                 "This top-level definition was expected to fail, but it succeeded"))
-                        | uu___8 ->
-                            if expected_errors <> []
-                            then
-                              let uu___9 =
-                                FStar_Errors.find_multiset_discrepancy
-                                  expected_errors actual_errors in
-                              (match uu___9 with
-                               | FStar_Pervasives_Native.None -> ()
-                               | FStar_Pervasives_Native.Some (e, n1, n2) ->
-                                   (FStar_Compiler_List.iter
-                                      FStar_Errors.print_issue errs;
-                                    (let uu___11 =
-                                       let uu___12 =
-                                         let uu___13 =
-                                           (FStar_Common.string_of_list ())
-                                             FStar_Compiler_Util.string_of_int
-                                             expected_errors in
-                                         let uu___14 =
-                                           (FStar_Common.string_of_list ())
-                                             FStar_Compiler_Util.string_of_int
-                                             actual_errors in
-                                         let uu___15 =
-                                           FStar_Compiler_Util.string_of_int
-                                             e in
-                                         let uu___16 =
-                                           FStar_Compiler_Util.string_of_int
-                                             n2 in
-                                         let uu___17 =
-                                           FStar_Compiler_Util.string_of_int
-                                             n1 in
-                                         FStar_Compiler_Util.format5
-                                           "This top-level definition was expected to raise error codes %s, but it raised %s. Error #%s was raised %s times, instead of %s."
-                                           uu___13 uu___14 uu___15 uu___16
-                                           uu___17 in
-                                       (FStar_Errors.Error_DidNotFail,
-                                         uu___12) in
-                                     FStar_Errors.log_issue
-                                       se2.FStar_Syntax_Syntax.sigrng uu___11)))
-                            else ());
-                       ([], [], env)))))
-           | FStar_Syntax_Syntax.Sig_bundle (ses, lids) ->
-               let env1 = FStar_TypeChecker_Env.set_range env r in
-               let ses1 =
-                 let uu___2 = do_two_phases env1 in
-                 if uu___2
-                 then
-                   run_phase1
-                     (fun uu___3 ->
-                        let ses2 =
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                tc_inductive
-                                  {
-                                    FStar_TypeChecker_Env.solver =
-                                      (env1.FStar_TypeChecker_Env.solver);
-                                    FStar_TypeChecker_Env.range =
-                                      (env1.FStar_TypeChecker_Env.range);
-                                    FStar_TypeChecker_Env.curmodule =
-                                      (env1.FStar_TypeChecker_Env.curmodule);
-                                    FStar_TypeChecker_Env.gamma =
-                                      (env1.FStar_TypeChecker_Env.gamma);
-                                    FStar_TypeChecker_Env.gamma_sig =
-                                      (env1.FStar_TypeChecker_Env.gamma_sig);
-                                    FStar_TypeChecker_Env.gamma_cache =
-                                      (env1.FStar_TypeChecker_Env.gamma_cache);
-                                    FStar_TypeChecker_Env.modules =
-                                      (env1.FStar_TypeChecker_Env.modules);
-                                    FStar_TypeChecker_Env.expected_typ =
-                                      (env1.FStar_TypeChecker_Env.expected_typ);
-                                    FStar_TypeChecker_Env.sigtab =
-                                      (env1.FStar_TypeChecker_Env.sigtab);
-                                    FStar_TypeChecker_Env.attrtab =
-                                      (env1.FStar_TypeChecker_Env.attrtab);
-                                    FStar_TypeChecker_Env.instantiate_imp =
-                                      (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                    FStar_TypeChecker_Env.effects =
-                                      (env1.FStar_TypeChecker_Env.effects);
-                                    FStar_TypeChecker_Env.generalize =
-                                      (env1.FStar_TypeChecker_Env.generalize);
-                                    FStar_TypeChecker_Env.letrecs =
-                                      (env1.FStar_TypeChecker_Env.letrecs);
-                                    FStar_TypeChecker_Env.top_level =
-                                      (env1.FStar_TypeChecker_Env.top_level);
-                                    FStar_TypeChecker_Env.check_uvars =
-                                      (env1.FStar_TypeChecker_Env.check_uvars);
-                                    FStar_TypeChecker_Env.use_eq_strict =
-                                      (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                    FStar_TypeChecker_Env.is_iface =
-                                      (env1.FStar_TypeChecker_Env.is_iface);
-                                    FStar_TypeChecker_Env.admit =
-                                      (env1.FStar_TypeChecker_Env.admit);
-                                    FStar_TypeChecker_Env.lax = true;
-                                    FStar_TypeChecker_Env.lax_universes =
-                                      (env1.FStar_TypeChecker_Env.lax_universes);
-                                    FStar_TypeChecker_Env.phase1 = true;
-                                    FStar_TypeChecker_Env.failhard =
-                                      (env1.FStar_TypeChecker_Env.failhard);
-                                    FStar_TypeChecker_Env.nosynth =
-                                      (env1.FStar_TypeChecker_Env.nosynth);
-                                    FStar_TypeChecker_Env.uvar_subtyping =
-                                      (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                    FStar_TypeChecker_Env.tc_term =
-                                      (env1.FStar_TypeChecker_Env.tc_term);
-                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                      =
-                                      (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.universe_of =
-                                      (env1.FStar_TypeChecker_Env.universe_of);
-                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                      =
-                                      (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.teq_nosmt_force =
-                                      (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                      =
-                                      (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                      =
-                                      (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                    FStar_TypeChecker_Env.normalized_eff_names
-                                      =
-                                      (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                    FStar_TypeChecker_Env.fv_delta_depths =
-                                      (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                    FStar_TypeChecker_Env.proof_ns =
-                                      (env1.FStar_TypeChecker_Env.proof_ns);
-                                    FStar_TypeChecker_Env.synth_hook =
-                                      (env1.FStar_TypeChecker_Env.synth_hook);
-                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                      =
-                                      (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                    FStar_TypeChecker_Env.splice =
-                                      (env1.FStar_TypeChecker_Env.splice);
-                                    FStar_TypeChecker_Env.mpreprocess =
-                                      (env1.FStar_TypeChecker_Env.mpreprocess);
-                                    FStar_TypeChecker_Env.postprocess =
-                                      (env1.FStar_TypeChecker_Env.postprocess);
-                                    FStar_TypeChecker_Env.identifier_info =
-                                      (env1.FStar_TypeChecker_Env.identifier_info);
-                                    FStar_TypeChecker_Env.tc_hooks =
-                                      (env1.FStar_TypeChecker_Env.tc_hooks);
-                                    FStar_TypeChecker_Env.dsenv =
-                                      (env1.FStar_TypeChecker_Env.dsenv);
-                                    FStar_TypeChecker_Env.nbe =
-                                      (env1.FStar_TypeChecker_Env.nbe);
-                                    FStar_TypeChecker_Env.strict_args_tab =
-                                      (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                    FStar_TypeChecker_Env.erasable_types_tab
-                                      =
-                                      (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                      =
-                                      (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                      =
-                                      (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                    FStar_TypeChecker_Env.erase_erasable_args
-                                      =
-                                      (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                    FStar_TypeChecker_Env.core_check =
-                                      (env1.FStar_TypeChecker_Env.core_check)
-                                  } ses se2.FStar_Syntax_Syntax.sigquals
-                                  se2.FStar_Syntax_Syntax.sigattrs lids in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                FStar_Pervasives_Native.fst in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___5
-                              (FStar_TypeChecker_Normalize.elim_uvars env1) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___4
-                            FStar_Syntax_Util.ses_of_sigbundle in
-                        (let uu___5 =
-                           FStar_Compiler_Effect.op_Less_Bar
-                             (FStar_TypeChecker_Env.debug env1)
-                             (FStar_Options.Other "TwoPhases") in
-                         if uu___5
-                         then
-                           let uu___6 =
-                             FStar_Syntax_Print.sigelt_to_string
-                               {
-                                 FStar_Syntax_Syntax.sigel =
-                                   (FStar_Syntax_Syntax.Sig_bundle
-                                      (ses2, lids));
-                                 FStar_Syntax_Syntax.sigrng =
-                                   (se2.FStar_Syntax_Syntax.sigrng);
-                                 FStar_Syntax_Syntax.sigquals =
-                                   (se2.FStar_Syntax_Syntax.sigquals);
-                                 FStar_Syntax_Syntax.sigmeta =
-                                   (se2.FStar_Syntax_Syntax.sigmeta);
-                                 FStar_Syntax_Syntax.sigattrs =
-                                   (se2.FStar_Syntax_Syntax.sigattrs);
-                                 FStar_Syntax_Syntax.sigopts =
-                                   (se2.FStar_Syntax_Syntax.sigopts)
-                               } in
-                           FStar_Compiler_Util.print1
-                             "Inductive after phase 1: %s\n" uu___6
-                         else ());
-                        ses2)
-                 else ses in
-               let uu___2 =
-                 tc_inductive env1 ses1 se2.FStar_Syntax_Syntax.sigquals
-                   se2.FStar_Syntax_Syntax.sigattrs lids in
-               (match uu___2 with
-                | (sigbndle, projectors_ses) ->
-                    let sigbndle1 =
-                      {
-                        FStar_Syntax_Syntax.sigel =
-                          (sigbndle.FStar_Syntax_Syntax.sigel);
-                        FStar_Syntax_Syntax.sigrng =
-                          (sigbndle.FStar_Syntax_Syntax.sigrng);
-                        FStar_Syntax_Syntax.sigquals =
-                          (sigbndle.FStar_Syntax_Syntax.sigquals);
-                        FStar_Syntax_Syntax.sigmeta =
-                          (sigbndle.FStar_Syntax_Syntax.sigmeta);
-                        FStar_Syntax_Syntax.sigattrs =
-                          (se2.FStar_Syntax_Syntax.sigattrs);
-                        FStar_Syntax_Syntax.sigopts =
-                          (sigbndle.FStar_Syntax_Syntax.sigopts)
-                      } in
-                    ([sigbndle1], projectors_ses, env0))
-           | FStar_Syntax_Syntax.Sig_pragma p ->
-               (FStar_Syntax_Util.process_pragma p r; ([se2], [], env0))
-           | FStar_Syntax_Syntax.Sig_new_effect ne ->
-               let is_unelaborated_dm4f =
-                 match ne.FStar_Syntax_Syntax.combinators with
-                 | FStar_Syntax_Syntax.DM4F_eff combs ->
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Compiler_Effect.op_Bar_Greater
-                           combs.FStar_Syntax_Syntax.ret_wp
-                           FStar_Pervasives_Native.snd in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___3
-                         FStar_Syntax_Subst.compress in
-                     (match uu___2 with
-                      | {
-                          FStar_Syntax_Syntax.n =
-                            FStar_Syntax_Syntax.Tm_unknown;
-                          FStar_Syntax_Syntax.pos = uu___3;
-                          FStar_Syntax_Syntax.vars = uu___4;
-                          FStar_Syntax_Syntax.hash_code = uu___5;_} -> true
-                      | uu___3 -> false)
-                 | uu___2 -> false in
-               if is_unelaborated_dm4f
-               then
-                 let env1 = FStar_TypeChecker_Env.set_range env r in
-                 let uu___2 =
-                   FStar_TypeChecker_TcEffect.dmff_cps_and_elaborate env1 ne in
-                 (match uu___2 with
-                  | (ses, ne1, lift_from_pure_opt) ->
-                      let effect_and_lift_ses =
-                        match lift_from_pure_opt with
-                        | FStar_Pervasives_Native.Some lift ->
-                            [{
-                               FStar_Syntax_Syntax.sigel =
-                                 (FStar_Syntax_Syntax.Sig_new_effect ne1);
-                               FStar_Syntax_Syntax.sigrng =
-                                 (se2.FStar_Syntax_Syntax.sigrng);
-                               FStar_Syntax_Syntax.sigquals =
-                                 (se2.FStar_Syntax_Syntax.sigquals);
-                               FStar_Syntax_Syntax.sigmeta =
-                                 (se2.FStar_Syntax_Syntax.sigmeta);
-                               FStar_Syntax_Syntax.sigattrs =
-                                 (se2.FStar_Syntax_Syntax.sigattrs);
-                               FStar_Syntax_Syntax.sigopts =
-                                 (se2.FStar_Syntax_Syntax.sigopts)
-                             };
-                            lift]
-                        | FStar_Pervasives_Native.None ->
-                            [{
-                               FStar_Syntax_Syntax.sigel =
-                                 (FStar_Syntax_Syntax.Sig_new_effect ne1);
-                               FStar_Syntax_Syntax.sigrng =
-                                 (se2.FStar_Syntax_Syntax.sigrng);
-                               FStar_Syntax_Syntax.sigquals =
-                                 (se2.FStar_Syntax_Syntax.sigquals);
-                               FStar_Syntax_Syntax.sigmeta =
-                                 (se2.FStar_Syntax_Syntax.sigmeta);
-                               FStar_Syntax_Syntax.sigattrs =
-                                 (se2.FStar_Syntax_Syntax.sigattrs);
-                               FStar_Syntax_Syntax.sigopts =
-                                 (se2.FStar_Syntax_Syntax.sigopts)
-                             }] in
-                      let effect_and_lift_ses1 =
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          effect_and_lift_ses
-                          (FStar_Compiler_List.map
-                             (fun sigelt ->
-                                {
-                                  FStar_Syntax_Syntax.sigel =
-                                    (sigelt.FStar_Syntax_Syntax.sigel);
-                                  FStar_Syntax_Syntax.sigrng =
-                                    (sigelt.FStar_Syntax_Syntax.sigrng);
-                                  FStar_Syntax_Syntax.sigquals =
-                                    (sigelt.FStar_Syntax_Syntax.sigquals);
-                                  FStar_Syntax_Syntax.sigmeta =
-                                    (let uu___3 =
-                                       sigelt.FStar_Syntax_Syntax.sigmeta in
-                                     {
-                                       FStar_Syntax_Syntax.sigmeta_active =
-                                         (uu___3.FStar_Syntax_Syntax.sigmeta_active);
-                                       FStar_Syntax_Syntax.sigmeta_fact_db_ids
-                                         =
-                                         (uu___3.FStar_Syntax_Syntax.sigmeta_fact_db_ids);
-                                       FStar_Syntax_Syntax.sigmeta_admit =
-                                         true
-                                     });
-                                  FStar_Syntax_Syntax.sigattrs =
-                                    (sigelt.FStar_Syntax_Syntax.sigattrs);
-                                  FStar_Syntax_Syntax.sigopts =
-                                    (sigelt.FStar_Syntax_Syntax.sigopts)
-                                })) in
-                      ([],
-                        (FStar_Compiler_List.op_At ses effect_and_lift_ses1),
-                        env0))
-               else
-                 (let ne1 =
-                    let uu___3 = do_two_phases env in
-                    if uu___3
-                    then
-                      run_phase1
-                        (fun uu___4 ->
-                           let ne2 =
-                             let uu___5 =
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_TypeChecker_TcEffect.tc_eff_decl
-                                       {
-                                         FStar_TypeChecker_Env.solver =
-                                           (env.FStar_TypeChecker_Env.solver);
-                                         FStar_TypeChecker_Env.range =
-                                           (env.FStar_TypeChecker_Env.range);
-                                         FStar_TypeChecker_Env.curmodule =
-                                           (env.FStar_TypeChecker_Env.curmodule);
-                                         FStar_TypeChecker_Env.gamma =
-                                           (env.FStar_TypeChecker_Env.gamma);
-                                         FStar_TypeChecker_Env.gamma_sig =
-                                           (env.FStar_TypeChecker_Env.gamma_sig);
-                                         FStar_TypeChecker_Env.gamma_cache =
-                                           (env.FStar_TypeChecker_Env.gamma_cache);
-                                         FStar_TypeChecker_Env.modules =
-                                           (env.FStar_TypeChecker_Env.modules);
-                                         FStar_TypeChecker_Env.expected_typ =
-                                           (env.FStar_TypeChecker_Env.expected_typ);
-                                         FStar_TypeChecker_Env.sigtab =
-                                           (env.FStar_TypeChecker_Env.sigtab);
-                                         FStar_TypeChecker_Env.attrtab =
-                                           (env.FStar_TypeChecker_Env.attrtab);
-                                         FStar_TypeChecker_Env.instantiate_imp
-                                           =
-                                           (env.FStar_TypeChecker_Env.instantiate_imp);
-                                         FStar_TypeChecker_Env.effects =
-                                           (env.FStar_TypeChecker_Env.effects);
-                                         FStar_TypeChecker_Env.generalize =
-                                           (env.FStar_TypeChecker_Env.generalize);
-                                         FStar_TypeChecker_Env.letrecs =
-                                           (env.FStar_TypeChecker_Env.letrecs);
-                                         FStar_TypeChecker_Env.top_level =
-                                           (env.FStar_TypeChecker_Env.top_level);
-                                         FStar_TypeChecker_Env.check_uvars =
-                                           (env.FStar_TypeChecker_Env.check_uvars);
-                                         FStar_TypeChecker_Env.use_eq_strict
-                                           =
-                                           (env.FStar_TypeChecker_Env.use_eq_strict);
-                                         FStar_TypeChecker_Env.is_iface =
-                                           (env.FStar_TypeChecker_Env.is_iface);
-                                         FStar_TypeChecker_Env.admit =
-                                           (env.FStar_TypeChecker_Env.admit);
-                                         FStar_TypeChecker_Env.lax = true;
-                                         FStar_TypeChecker_Env.lax_universes
-                                           =
-                                           (env.FStar_TypeChecker_Env.lax_universes);
-                                         FStar_TypeChecker_Env.phase1 = true;
-                                         FStar_TypeChecker_Env.failhard =
-                                           (env.FStar_TypeChecker_Env.failhard);
-                                         FStar_TypeChecker_Env.nosynth =
-                                           (env.FStar_TypeChecker_Env.nosynth);
-                                         FStar_TypeChecker_Env.uvar_subtyping
-                                           =
-                                           (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                         FStar_TypeChecker_Env.tc_term =
-                                           (env.FStar_TypeChecker_Env.tc_term);
-                                         FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                           =
-                                           (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                         FStar_TypeChecker_Env.universe_of =
-                                           (env.FStar_TypeChecker_Env.universe_of);
-                                         FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                           =
-                                           (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                         FStar_TypeChecker_Env.teq_nosmt_force
-                                           =
-                                           (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                         FStar_TypeChecker_Env.subtype_nosmt_force
-                                           =
-                                           (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                         FStar_TypeChecker_Env.qtbl_name_and_index
-                                           =
-                                           (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                         FStar_TypeChecker_Env.normalized_eff_names
-                                           =
-                                           (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                         FStar_TypeChecker_Env.fv_delta_depths
-                                           =
-                                           (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                         FStar_TypeChecker_Env.proof_ns =
-                                           (env.FStar_TypeChecker_Env.proof_ns);
-                                         FStar_TypeChecker_Env.synth_hook =
-                                           (env.FStar_TypeChecker_Env.synth_hook);
-                                         FStar_TypeChecker_Env.try_solve_implicits_hook
-                                           =
-                                           (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                         FStar_TypeChecker_Env.splice =
-                                           (env.FStar_TypeChecker_Env.splice);
-                                         FStar_TypeChecker_Env.mpreprocess =
-                                           (env.FStar_TypeChecker_Env.mpreprocess);
-                                         FStar_TypeChecker_Env.postprocess =
-                                           (env.FStar_TypeChecker_Env.postprocess);
-                                         FStar_TypeChecker_Env.identifier_info
-                                           =
-                                           (env.FStar_TypeChecker_Env.identifier_info);
-                                         FStar_TypeChecker_Env.tc_hooks =
-                                           (env.FStar_TypeChecker_Env.tc_hooks);
-                                         FStar_TypeChecker_Env.dsenv =
-                                           (env.FStar_TypeChecker_Env.dsenv);
-                                         FStar_TypeChecker_Env.nbe =
-                                           (env.FStar_TypeChecker_Env.nbe);
-                                         FStar_TypeChecker_Env.strict_args_tab
-                                           =
-                                           (env.FStar_TypeChecker_Env.strict_args_tab);
-                                         FStar_TypeChecker_Env.erasable_types_tab
-                                           =
-                                           (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                         FStar_TypeChecker_Env.enable_defer_to_tac
-                                           =
-                                           (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                         FStar_TypeChecker_Env.unif_allow_ref_guards
-                                           =
-                                           (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                         FStar_TypeChecker_Env.erase_erasable_args
-                                           =
-                                           (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                         FStar_TypeChecker_Env.core_check =
-                                           (env.FStar_TypeChecker_Env.core_check)
-                                       } ne se2.FStar_Syntax_Syntax.sigquals
-                                       se2.FStar_Syntax_Syntax.sigattrs in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___8 FStar_Pervasives_Native.fst in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                   (fun ne3 ->
-                                      {
-                                        FStar_Syntax_Syntax.sigel =
-                                          (FStar_Syntax_Syntax.Sig_new_effect
-                                             ne3);
-                                        FStar_Syntax_Syntax.sigrng =
-                                          (se2.FStar_Syntax_Syntax.sigrng);
-                                        FStar_Syntax_Syntax.sigquals =
-                                          (se2.FStar_Syntax_Syntax.sigquals);
-                                        FStar_Syntax_Syntax.sigmeta =
-                                          (se2.FStar_Syntax_Syntax.sigmeta);
-                                        FStar_Syntax_Syntax.sigattrs =
-                                          (se2.FStar_Syntax_Syntax.sigattrs);
-                                        FStar_Syntax_Syntax.sigopts =
-                                          (se2.FStar_Syntax_Syntax.sigopts)
-                                      }) in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                 (FStar_TypeChecker_Normalize.elim_uvars env) in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___5
-                               FStar_Syntax_Util.eff_decl_of_new_effect in
-                           (let uu___6 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug env)
-                                (FStar_Options.Other "TwoPhases") in
-                            if uu___6
-                            then
-                              let uu___7 =
-                                FStar_Syntax_Print.sigelt_to_string
-                                  {
-                                    FStar_Syntax_Syntax.sigel =
-                                      (FStar_Syntax_Syntax.Sig_new_effect ne2);
-                                    FStar_Syntax_Syntax.sigrng =
-                                      (se2.FStar_Syntax_Syntax.sigrng);
-                                    FStar_Syntax_Syntax.sigquals =
-                                      (se2.FStar_Syntax_Syntax.sigquals);
-                                    FStar_Syntax_Syntax.sigmeta =
-                                      (se2.FStar_Syntax_Syntax.sigmeta);
-                                    FStar_Syntax_Syntax.sigattrs =
-                                      (se2.FStar_Syntax_Syntax.sigattrs);
-                                    FStar_Syntax_Syntax.sigopts =
-                                      (se2.FStar_Syntax_Syntax.sigopts)
-                                  } in
-                              FStar_Compiler_Util.print1
-                                "Effect decl after phase 1: %s\n" uu___7
-                            else ());
-                           ne2)
-                    else ne in
-                  let uu___3 =
-                    FStar_TypeChecker_TcEffect.tc_eff_decl env ne1
-                      se2.FStar_Syntax_Syntax.sigquals
-                      se2.FStar_Syntax_Syntax.sigattrs in
-                  match uu___3 with
-                  | (ne2, ses) ->
-                      let se3 =
-                        {
-                          FStar_Syntax_Syntax.sigel =
-                            (FStar_Syntax_Syntax.Sig_new_effect ne2);
-                          FStar_Syntax_Syntax.sigrng =
-                            (se2.FStar_Syntax_Syntax.sigrng);
-                          FStar_Syntax_Syntax.sigquals =
-                            (se2.FStar_Syntax_Syntax.sigquals);
-                          FStar_Syntax_Syntax.sigmeta =
-                            (se2.FStar_Syntax_Syntax.sigmeta);
-                          FStar_Syntax_Syntax.sigattrs =
-                            (se2.FStar_Syntax_Syntax.sigattrs);
-                          FStar_Syntax_Syntax.sigopts =
-                            (se2.FStar_Syntax_Syntax.sigopts)
-                        } in
-                      ([se3], ses, env0))
-           | FStar_Syntax_Syntax.Sig_sub_effect sub ->
-               let sub1 = FStar_TypeChecker_TcEffect.tc_lift env sub r in
-               let se3 =
-                 {
-                   FStar_Syntax_Syntax.sigel =
-                     (FStar_Syntax_Syntax.Sig_sub_effect sub1);
-                   FStar_Syntax_Syntax.sigrng =
-                     (se2.FStar_Syntax_Syntax.sigrng);
-                   FStar_Syntax_Syntax.sigquals =
-                     (se2.FStar_Syntax_Syntax.sigquals);
-                   FStar_Syntax_Syntax.sigmeta =
-                     (se2.FStar_Syntax_Syntax.sigmeta);
-                   FStar_Syntax_Syntax.sigattrs =
-                     (se2.FStar_Syntax_Syntax.sigattrs);
-                   FStar_Syntax_Syntax.sigopts =
-                     (se2.FStar_Syntax_Syntax.sigopts)
-                 } in
-               ([se3], [], env)
-           | FStar_Syntax_Syntax.Sig_effect_abbrev (lid, uvs, tps, c, flags)
-               ->
-               let uu___2 =
-                 let uu___3 = do_two_phases env in
-                 if uu___3
-                 then
-                   run_phase1
-                     (fun uu___4 ->
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_TypeChecker_TcEffect.tc_effect_abbrev
-                                {
-                                  FStar_TypeChecker_Env.solver =
-                                    (env.FStar_TypeChecker_Env.solver);
-                                  FStar_TypeChecker_Env.range =
-                                    (env.FStar_TypeChecker_Env.range);
-                                  FStar_TypeChecker_Env.curmodule =
-                                    (env.FStar_TypeChecker_Env.curmodule);
-                                  FStar_TypeChecker_Env.gamma =
-                                    (env.FStar_TypeChecker_Env.gamma);
-                                  FStar_TypeChecker_Env.gamma_sig =
-                                    (env.FStar_TypeChecker_Env.gamma_sig);
-                                  FStar_TypeChecker_Env.gamma_cache =
-                                    (env.FStar_TypeChecker_Env.gamma_cache);
-                                  FStar_TypeChecker_Env.modules =
-                                    (env.FStar_TypeChecker_Env.modules);
-                                  FStar_TypeChecker_Env.expected_typ =
-                                    (env.FStar_TypeChecker_Env.expected_typ);
-                                  FStar_TypeChecker_Env.sigtab =
-                                    (env.FStar_TypeChecker_Env.sigtab);
-                                  FStar_TypeChecker_Env.attrtab =
-                                    (env.FStar_TypeChecker_Env.attrtab);
-                                  FStar_TypeChecker_Env.instantiate_imp =
-                                    (env.FStar_TypeChecker_Env.instantiate_imp);
-                                  FStar_TypeChecker_Env.effects =
-                                    (env.FStar_TypeChecker_Env.effects);
-                                  FStar_TypeChecker_Env.generalize =
-                                    (env.FStar_TypeChecker_Env.generalize);
-                                  FStar_TypeChecker_Env.letrecs =
-                                    (env.FStar_TypeChecker_Env.letrecs);
-                                  FStar_TypeChecker_Env.top_level =
-                                    (env.FStar_TypeChecker_Env.top_level);
-                                  FStar_TypeChecker_Env.check_uvars =
-                                    (env.FStar_TypeChecker_Env.check_uvars);
-                                  FStar_TypeChecker_Env.use_eq_strict =
-                                    (env.FStar_TypeChecker_Env.use_eq_strict);
-                                  FStar_TypeChecker_Env.is_iface =
-                                    (env.FStar_TypeChecker_Env.is_iface);
-                                  FStar_TypeChecker_Env.admit =
-                                    (env.FStar_TypeChecker_Env.admit);
-                                  FStar_TypeChecker_Env.lax = true;
-                                  FStar_TypeChecker_Env.lax_universes =
-                                    (env.FStar_TypeChecker_Env.lax_universes);
-                                  FStar_TypeChecker_Env.phase1 = true;
-                                  FStar_TypeChecker_Env.failhard =
-                                    (env.FStar_TypeChecker_Env.failhard);
-                                  FStar_TypeChecker_Env.nosynth =
-                                    (env.FStar_TypeChecker_Env.nosynth);
-                                  FStar_TypeChecker_Env.uvar_subtyping =
-                                    (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                  FStar_TypeChecker_Env.tc_term =
-                                    (env.FStar_TypeChecker_Env.tc_term);
-                                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                    =
-                                    (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.universe_of =
-                                    (env.FStar_TypeChecker_Env.universe_of);
-                                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                    =
-                                    (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.teq_nosmt_force =
-                                    (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                                    (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                                    (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                  FStar_TypeChecker_Env.normalized_eff_names
-                                    =
-                                    (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                  FStar_TypeChecker_Env.fv_delta_depths =
-                                    (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                  FStar_TypeChecker_Env.proof_ns =
-                                    (env.FStar_TypeChecker_Env.proof_ns);
-                                  FStar_TypeChecker_Env.synth_hook =
-                                    (env.FStar_TypeChecker_Env.synth_hook);
-                                  FStar_TypeChecker_Env.try_solve_implicits_hook
-                                    =
-                                    (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                  FStar_TypeChecker_Env.splice =
-                                    (env.FStar_TypeChecker_Env.splice);
-                                  FStar_TypeChecker_Env.mpreprocess =
-                                    (env.FStar_TypeChecker_Env.mpreprocess);
-                                  FStar_TypeChecker_Env.postprocess =
-                                    (env.FStar_TypeChecker_Env.postprocess);
-                                  FStar_TypeChecker_Env.identifier_info =
-                                    (env.FStar_TypeChecker_Env.identifier_info);
-                                  FStar_TypeChecker_Env.tc_hooks =
-                                    (env.FStar_TypeChecker_Env.tc_hooks);
-                                  FStar_TypeChecker_Env.dsenv =
-                                    (env.FStar_TypeChecker_Env.dsenv);
-                                  FStar_TypeChecker_Env.nbe =
-                                    (env.FStar_TypeChecker_Env.nbe);
-                                  FStar_TypeChecker_Env.strict_args_tab =
-                                    (env.FStar_TypeChecker_Env.strict_args_tab);
-                                  FStar_TypeChecker_Env.erasable_types_tab =
-                                    (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                                    (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                  FStar_TypeChecker_Env.unif_allow_ref_guards
-                                    =
-                                    (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                  FStar_TypeChecker_Env.erase_erasable_args =
-                                    (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                  FStar_TypeChecker_Env.core_check =
-                                    (env.FStar_TypeChecker_Env.core_check)
-                                } (lid, uvs, tps, c) r in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___7
-                              (fun uu___8 ->
-                                 match uu___8 with
-                                 | (lid1, uvs1, tps1, c1) ->
-                                     {
-                                       FStar_Syntax_Syntax.sigel =
-                                         (FStar_Syntax_Syntax.Sig_effect_abbrev
-                                            (lid1, uvs1, tps1, c1, flags));
-                                       FStar_Syntax_Syntax.sigrng =
-                                         (se2.FStar_Syntax_Syntax.sigrng);
-                                       FStar_Syntax_Syntax.sigquals =
-                                         (se2.FStar_Syntax_Syntax.sigquals);
-                                       FStar_Syntax_Syntax.sigmeta =
-                                         (se2.FStar_Syntax_Syntax.sigmeta);
-                                       FStar_Syntax_Syntax.sigattrs =
-                                         (se2.FStar_Syntax_Syntax.sigattrs);
-                                       FStar_Syntax_Syntax.sigopts =
-                                         (se2.FStar_Syntax_Syntax.sigopts)
-                                     }) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___6
-                            (FStar_TypeChecker_Normalize.elim_uvars env) in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___5
-                          (fun se3 ->
-                             match se3.FStar_Syntax_Syntax.sigel with
-                             | FStar_Syntax_Syntax.Sig_effect_abbrev
-                                 (lid1, uvs1, tps1, c1, uu___6) ->
-                                 (lid1, uvs1, tps1, c1)
-                             | uu___6 ->
-                                 failwith
-                                   "Did not expect Sig_effect_abbrev to not be one after phase 1"))
-                 else (lid, uvs, tps, c) in
-               (match uu___2 with
-                | (lid1, uvs1, tps1, c1) ->
-                    let uu___3 =
-                      FStar_TypeChecker_TcEffect.tc_effect_abbrev env
-                        (lid1, uvs1, tps1, c1) r in
-                    (match uu___3 with
-                     | (lid2, uvs2, tps2, c2) ->
-                         let se3 =
-                           {
-                             FStar_Syntax_Syntax.sigel =
-                               (FStar_Syntax_Syntax.Sig_effect_abbrev
-                                  (lid2, uvs2, tps2, c2, flags));
-                             FStar_Syntax_Syntax.sigrng =
-                               (se2.FStar_Syntax_Syntax.sigrng);
-                             FStar_Syntax_Syntax.sigquals =
-                               (se2.FStar_Syntax_Syntax.sigquals);
-                             FStar_Syntax_Syntax.sigmeta =
-                               (se2.FStar_Syntax_Syntax.sigmeta);
-                             FStar_Syntax_Syntax.sigattrs =
-                               (se2.FStar_Syntax_Syntax.sigattrs);
-                             FStar_Syntax_Syntax.sigopts =
-                               (se2.FStar_Syntax_Syntax.sigopts)
-                           } in
-                         ([se3], [], env0)))
-           | FStar_Syntax_Syntax.Sig_declare_typ (uu___2, uu___3, uu___4)
-               when
-               FStar_Compiler_Effect.op_Bar_Greater
-                 se2.FStar_Syntax_Syntax.sigquals
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___5 ->
-                       match uu___5 with
-                       | FStar_Syntax_Syntax.OnlyName -> true
-                       | uu___6 -> false))
-               -> ([], [], env0)
-           | FStar_Syntax_Syntax.Sig_let (uu___2, uu___3) when
-               FStar_Compiler_Effect.op_Bar_Greater
-                 se2.FStar_Syntax_Syntax.sigquals
-                 (FStar_Compiler_Util.for_some
-                    (fun uu___4 ->
-                       match uu___4 with
-                       | FStar_Syntax_Syntax.OnlyName -> true
-                       | uu___5 -> false))
-               -> ([], [], env0)
-           | FStar_Syntax_Syntax.Sig_declare_typ (lid, uvs, t) ->
-               let env1 = FStar_TypeChecker_Env.set_range env r in
-               ((let uu___3 = FStar_TypeChecker_Env.lid_exists env1 lid in
-                 if uu___3
-                 then
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Ident.string_of_lid lid in
-                       FStar_Compiler_Util.format1
-                         "Top-level declaration %s for a name that is already used in this module; top-level declarations must be unique in their module"
-                         uu___6 in
-                     (FStar_Errors.Fatal_AlreadyDefinedTopLevelDeclaration,
-                       uu___5) in
-                   FStar_Errors.raise_error uu___4 r
-                 else ());
-                (let uu___3 =
-                   let uu___4 = do_two_phases env1 in
-                   if uu___4
-                   then
-                     run_phase1
-                       (fun uu___5 ->
-                          let uu___6 =
-                            tc_declare_typ
-                              {
-                                FStar_TypeChecker_Env.solver =
-                                  (env1.FStar_TypeChecker_Env.solver);
-                                FStar_TypeChecker_Env.range =
-                                  (env1.FStar_TypeChecker_Env.range);
-                                FStar_TypeChecker_Env.curmodule =
-                                  (env1.FStar_TypeChecker_Env.curmodule);
-                                FStar_TypeChecker_Env.gamma =
-                                  (env1.FStar_TypeChecker_Env.gamma);
-                                FStar_TypeChecker_Env.gamma_sig =
-                                  (env1.FStar_TypeChecker_Env.gamma_sig);
-                                FStar_TypeChecker_Env.gamma_cache =
-                                  (env1.FStar_TypeChecker_Env.gamma_cache);
-                                FStar_TypeChecker_Env.modules =
-                                  (env1.FStar_TypeChecker_Env.modules);
-                                FStar_TypeChecker_Env.expected_typ =
-                                  (env1.FStar_TypeChecker_Env.expected_typ);
-                                FStar_TypeChecker_Env.sigtab =
-                                  (env1.FStar_TypeChecker_Env.sigtab);
-                                FStar_TypeChecker_Env.attrtab =
-                                  (env1.FStar_TypeChecker_Env.attrtab);
-                                FStar_TypeChecker_Env.instantiate_imp =
-                                  (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                FStar_TypeChecker_Env.effects =
-                                  (env1.FStar_TypeChecker_Env.effects);
-                                FStar_TypeChecker_Env.generalize =
-                                  (env1.FStar_TypeChecker_Env.generalize);
-                                FStar_TypeChecker_Env.letrecs =
-                                  (env1.FStar_TypeChecker_Env.letrecs);
-                                FStar_TypeChecker_Env.top_level =
-                                  (env1.FStar_TypeChecker_Env.top_level);
-                                FStar_TypeChecker_Env.check_uvars =
-                                  (env1.FStar_TypeChecker_Env.check_uvars);
-                                FStar_TypeChecker_Env.use_eq_strict =
-                                  (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                FStar_TypeChecker_Env.is_iface =
-                                  (env1.FStar_TypeChecker_Env.is_iface);
-                                FStar_TypeChecker_Env.admit =
-                                  (env1.FStar_TypeChecker_Env.admit);
-                                FStar_TypeChecker_Env.lax = true;
-                                FStar_TypeChecker_Env.lax_universes =
-                                  (env1.FStar_TypeChecker_Env.lax_universes);
-                                FStar_TypeChecker_Env.phase1 = true;
-                                FStar_TypeChecker_Env.failhard =
-                                  (env1.FStar_TypeChecker_Env.failhard);
-                                FStar_TypeChecker_Env.nosynth =
-                                  (env1.FStar_TypeChecker_Env.nosynth);
-                                FStar_TypeChecker_Env.uvar_subtyping =
-                                  (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                FStar_TypeChecker_Env.tc_term =
-                                  (env1.FStar_TypeChecker_Env.tc_term);
-                                FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                  =
-                                  (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                FStar_TypeChecker_Env.universe_of =
-                                  (env1.FStar_TypeChecker_Env.universe_of);
-                                FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                  =
-                                  (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                FStar_TypeChecker_Env.teq_nosmt_force =
-                                  (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                FStar_TypeChecker_Env.subtype_nosmt_force =
-                                  (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                FStar_TypeChecker_Env.qtbl_name_and_index =
-                                  (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                FStar_TypeChecker_Env.normalized_eff_names =
-                                  (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                FStar_TypeChecker_Env.fv_delta_depths =
-                                  (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                FStar_TypeChecker_Env.proof_ns =
-                                  (env1.FStar_TypeChecker_Env.proof_ns);
-                                FStar_TypeChecker_Env.synth_hook =
-                                  (env1.FStar_TypeChecker_Env.synth_hook);
-                                FStar_TypeChecker_Env.try_solve_implicits_hook
-                                  =
-                                  (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                FStar_TypeChecker_Env.splice =
-                                  (env1.FStar_TypeChecker_Env.splice);
-                                FStar_TypeChecker_Env.mpreprocess =
-                                  (env1.FStar_TypeChecker_Env.mpreprocess);
-                                FStar_TypeChecker_Env.postprocess =
-                                  (env1.FStar_TypeChecker_Env.postprocess);
-                                FStar_TypeChecker_Env.identifier_info =
-                                  (env1.FStar_TypeChecker_Env.identifier_info);
-                                FStar_TypeChecker_Env.tc_hooks =
-                                  (env1.FStar_TypeChecker_Env.tc_hooks);
-                                FStar_TypeChecker_Env.dsenv =
-                                  (env1.FStar_TypeChecker_Env.dsenv);
-                                FStar_TypeChecker_Env.nbe =
-                                  (env1.FStar_TypeChecker_Env.nbe);
-                                FStar_TypeChecker_Env.strict_args_tab =
-                                  (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                FStar_TypeChecker_Env.erasable_types_tab =
-                                  (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                FStar_TypeChecker_Env.enable_defer_to_tac =
-                                  (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                FStar_TypeChecker_Env.unif_allow_ref_guards =
-                                  (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                FStar_TypeChecker_Env.erase_erasable_args =
-                                  (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                FStar_TypeChecker_Env.core_check =
-                                  (env1.FStar_TypeChecker_Env.core_check)
-                              } (uvs, t) se2.FStar_Syntax_Syntax.sigrng in
-                          match uu___6 with
-                          | (uvs1, t1) ->
-                              ((let uu___8 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env1)
-                                    (FStar_Options.Other "TwoPhases") in
-                                if uu___8
-                                then
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string t1 in
-                                  let uu___10 =
-                                    FStar_Syntax_Print.univ_names_to_string
-                                      uvs1 in
-                                  FStar_Compiler_Util.print2
-                                    "Val declaration after phase 1: %s and uvs: %s\n"
-                                    uu___9 uu___10
-                                else ());
-                               (uvs1, t1)))
-                   else (uvs, t) in
-                 match uu___3 with
-                 | (uvs1, t1) ->
-                     let uu___4 =
-                       tc_declare_typ env1 (uvs1, t1)
-                         se2.FStar_Syntax_Syntax.sigrng in
-                     (match uu___4 with
-                      | (uvs2, t2) ->
-                          ([{
-                              FStar_Syntax_Syntax.sigel =
-                                (FStar_Syntax_Syntax.Sig_declare_typ
-                                   (lid, uvs2, t2));
-                              FStar_Syntax_Syntax.sigrng =
-                                (se2.FStar_Syntax_Syntax.sigrng);
-                              FStar_Syntax_Syntax.sigquals =
-                                (se2.FStar_Syntax_Syntax.sigquals);
-                              FStar_Syntax_Syntax.sigmeta =
-                                (se2.FStar_Syntax_Syntax.sigmeta);
-                              FStar_Syntax_Syntax.sigattrs =
-                                (se2.FStar_Syntax_Syntax.sigattrs);
-                              FStar_Syntax_Syntax.sigopts =
-                                (se2.FStar_Syntax_Syntax.sigopts)
-                            }], [], env0))))
-           | FStar_Syntax_Syntax.Sig_assume (lid, uvs, t) ->
-               (if
-                  Prims.op_Negation
-                    (FStar_Compiler_List.contains
-                       FStar_Syntax_Syntax.InternalAssumption
-                       se2.FStar_Syntax_Syntax.sigquals)
-                then
-                  (let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_Syntax_Print.lid_to_string lid in
-                       FStar_Compiler_Util.format1
-                         "Admitting a top-level assumption %s" uu___5 in
-                     (FStar_Errors.Warning_WarnOnUse, uu___4) in
-                   FStar_Errors.log_issue r uu___3)
-                else ();
-                (let env1 = FStar_TypeChecker_Env.set_range env r in
-                 let uu___3 =
-                   let uu___4 = do_two_phases env1 in
-                   if uu___4
-                   then
-                     run_phase1
-                       (fun uu___5 ->
-                          let uu___6 =
-                            tc_assume
-                              {
-                                FStar_TypeChecker_Env.solver =
-                                  (env1.FStar_TypeChecker_Env.solver);
-                                FStar_TypeChecker_Env.range =
-                                  (env1.FStar_TypeChecker_Env.range);
-                                FStar_TypeChecker_Env.curmodule =
-                                  (env1.FStar_TypeChecker_Env.curmodule);
-                                FStar_TypeChecker_Env.gamma =
-                                  (env1.FStar_TypeChecker_Env.gamma);
-                                FStar_TypeChecker_Env.gamma_sig =
-                                  (env1.FStar_TypeChecker_Env.gamma_sig);
-                                FStar_TypeChecker_Env.gamma_cache =
-                                  (env1.FStar_TypeChecker_Env.gamma_cache);
-                                FStar_TypeChecker_Env.modules =
-                                  (env1.FStar_TypeChecker_Env.modules);
-                                FStar_TypeChecker_Env.expected_typ =
-                                  (env1.FStar_TypeChecker_Env.expected_typ);
-                                FStar_TypeChecker_Env.sigtab =
-                                  (env1.FStar_TypeChecker_Env.sigtab);
-                                FStar_TypeChecker_Env.attrtab =
-                                  (env1.FStar_TypeChecker_Env.attrtab);
-                                FStar_TypeChecker_Env.instantiate_imp =
-                                  (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                FStar_TypeChecker_Env.effects =
-                                  (env1.FStar_TypeChecker_Env.effects);
-                                FStar_TypeChecker_Env.generalize =
-                                  (env1.FStar_TypeChecker_Env.generalize);
-                                FStar_TypeChecker_Env.letrecs =
-                                  (env1.FStar_TypeChecker_Env.letrecs);
-                                FStar_TypeChecker_Env.top_level =
-                                  (env1.FStar_TypeChecker_Env.top_level);
-                                FStar_TypeChecker_Env.check_uvars =
-                                  (env1.FStar_TypeChecker_Env.check_uvars);
-                                FStar_TypeChecker_Env.use_eq_strict =
-                                  (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                FStar_TypeChecker_Env.is_iface =
-                                  (env1.FStar_TypeChecker_Env.is_iface);
-                                FStar_TypeChecker_Env.admit =
-                                  (env1.FStar_TypeChecker_Env.admit);
-                                FStar_TypeChecker_Env.lax = true;
-                                FStar_TypeChecker_Env.lax_universes =
-                                  (env1.FStar_TypeChecker_Env.lax_universes);
-                                FStar_TypeChecker_Env.phase1 = true;
-                                FStar_TypeChecker_Env.failhard =
-                                  (env1.FStar_TypeChecker_Env.failhard);
-                                FStar_TypeChecker_Env.nosynth =
-                                  (env1.FStar_TypeChecker_Env.nosynth);
-                                FStar_TypeChecker_Env.uvar_subtyping =
-                                  (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                FStar_TypeChecker_Env.tc_term =
-                                  (env1.FStar_TypeChecker_Env.tc_term);
-                                FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                  =
-                                  (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                FStar_TypeChecker_Env.universe_of =
-                                  (env1.FStar_TypeChecker_Env.universe_of);
-                                FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                  =
-                                  (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                FStar_TypeChecker_Env.teq_nosmt_force =
-                                  (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                FStar_TypeChecker_Env.subtype_nosmt_force =
-                                  (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                FStar_TypeChecker_Env.qtbl_name_and_index =
-                                  (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                FStar_TypeChecker_Env.normalized_eff_names =
-                                  (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                FStar_TypeChecker_Env.fv_delta_depths =
-                                  (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                FStar_TypeChecker_Env.proof_ns =
-                                  (env1.FStar_TypeChecker_Env.proof_ns);
-                                FStar_TypeChecker_Env.synth_hook =
-                                  (env1.FStar_TypeChecker_Env.synth_hook);
-                                FStar_TypeChecker_Env.try_solve_implicits_hook
-                                  =
-                                  (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                FStar_TypeChecker_Env.splice =
-                                  (env1.FStar_TypeChecker_Env.splice);
-                                FStar_TypeChecker_Env.mpreprocess =
-                                  (env1.FStar_TypeChecker_Env.mpreprocess);
-                                FStar_TypeChecker_Env.postprocess =
-                                  (env1.FStar_TypeChecker_Env.postprocess);
-                                FStar_TypeChecker_Env.identifier_info =
-                                  (env1.FStar_TypeChecker_Env.identifier_info);
-                                FStar_TypeChecker_Env.tc_hooks =
-                                  (env1.FStar_TypeChecker_Env.tc_hooks);
-                                FStar_TypeChecker_Env.dsenv =
-                                  (env1.FStar_TypeChecker_Env.dsenv);
-                                FStar_TypeChecker_Env.nbe =
-                                  (env1.FStar_TypeChecker_Env.nbe);
-                                FStar_TypeChecker_Env.strict_args_tab =
-                                  (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                FStar_TypeChecker_Env.erasable_types_tab =
-                                  (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                FStar_TypeChecker_Env.enable_defer_to_tac =
-                                  (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                FStar_TypeChecker_Env.unif_allow_ref_guards =
-                                  (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                FStar_TypeChecker_Env.erase_erasable_args =
-                                  (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                FStar_TypeChecker_Env.core_check =
-                                  (env1.FStar_TypeChecker_Env.core_check)
-                              } (uvs, t) se2.FStar_Syntax_Syntax.sigrng in
-                          match uu___6 with
-                          | (uvs1, t1) ->
-                              ((let uu___8 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env1)
-                                    (FStar_Options.Other "TwoPhases") in
-                                if uu___8
-                                then
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string t1 in
-                                  let uu___10 =
-                                    FStar_Syntax_Print.univ_names_to_string
-                                      uvs1 in
-                                  FStar_Compiler_Util.print2
-                                    "Assume after phase 1: %s and uvs: %s\n"
-                                    uu___9 uu___10
-                                else ());
-                               (uvs1, t1)))
-                   else (uvs, t) in
-                 match uu___3 with
-                 | (uvs1, t1) ->
-                     let uu___4 =
-                       tc_assume env1 (uvs1, t1)
-                         se2.FStar_Syntax_Syntax.sigrng in
-                     (match uu___4 with
-                      | (uvs2, t2) ->
-                          ([{
-                              FStar_Syntax_Syntax.sigel =
-                                (FStar_Syntax_Syntax.Sig_assume
-                                   (lid, uvs2, t2));
-                              FStar_Syntax_Syntax.sigrng =
-                                (se2.FStar_Syntax_Syntax.sigrng);
-                              FStar_Syntax_Syntax.sigquals =
-                                (se2.FStar_Syntax_Syntax.sigquals);
-                              FStar_Syntax_Syntax.sigmeta =
-                                (se2.FStar_Syntax_Syntax.sigmeta);
-                              FStar_Syntax_Syntax.sigattrs =
-                                (se2.FStar_Syntax_Syntax.sigattrs);
-                              FStar_Syntax_Syntax.sigopts =
-                                (se2.FStar_Syntax_Syntax.sigopts)
-                            }], [], env0))))
-           | FStar_Syntax_Syntax.Sig_splice (lids, t) ->
-               ((let uu___3 = FStar_Options.debug_any () in
-                 if uu___3
-                 then
-                   let uu___4 =
-                     FStar_Ident.string_of_lid
-                       env.FStar_TypeChecker_Env.curmodule in
-                   let uu___5 = FStar_Syntax_Print.term_to_string t in
-                   FStar_Compiler_Util.print2 "%s: Found splice of (%s)\n"
-                     uu___4 uu___5
-                 else ());
-                (let uu___3 =
-                   FStar_TypeChecker_TcTerm.tc_tactic
-                     FStar_Syntax_Syntax.t_unit FStar_Syntax_Syntax.t_decls
-                     env t in
-                 match uu___3 with
-                 | (t1, uu___4, g) ->
-                     (FStar_TypeChecker_Rel.force_trivial_guard env g;
-                      (let ses =
-                         env.FStar_TypeChecker_Env.splice env
-                           se2.FStar_Syntax_Syntax.sigrng t1 in
-                       let lids' =
-                         FStar_Compiler_List.collect
-                           FStar_Syntax_Util.lids_of_sigelt ses in
-                       FStar_Compiler_List.iter
-                         (fun lid ->
-                            let uu___7 =
-                              FStar_Compiler_List.tryFind
-                                (FStar_Ident.lid_equals lid) lids' in
-                            match uu___7 with
-                            | FStar_Pervasives_Native.None when
-                                Prims.op_Negation
-                                  env.FStar_TypeChecker_Env.nosynth
-                                ->
-                                let uu___8 =
-                                  let uu___9 =
-                                    let uu___10 =
-                                      FStar_Ident.string_of_lid lid in
-                                    let uu___11 =
-                                      let uu___12 =
-                                        FStar_Compiler_List.map
-                                          FStar_Ident.string_of_lid lids' in
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        (FStar_String.concat ", ") uu___12 in
-                                    FStar_Compiler_Util.format2
-                                      "Splice declared the name %s but it was not defined.\nThose defined were: %s"
-                                      uu___10 uu___11 in
-                                  (FStar_Errors.Fatal_SplicedUndef, uu___9) in
-                                FStar_Errors.raise_error uu___8 r
-                            | uu___8 -> ()) lids;
-                       (let dsenv =
-                          FStar_Compiler_List.fold_left
-                            FStar_Syntax_DsEnv.push_sigelt_force
-                            env.FStar_TypeChecker_Env.dsenv ses in
-                        let env1 =
-                          {
-                            FStar_TypeChecker_Env.solver =
-                              (env.FStar_TypeChecker_Env.solver);
-                            FStar_TypeChecker_Env.range =
-                              (env.FStar_TypeChecker_Env.range);
-                            FStar_TypeChecker_Env.curmodule =
-                              (env.FStar_TypeChecker_Env.curmodule);
-                            FStar_TypeChecker_Env.gamma =
-                              (env.FStar_TypeChecker_Env.gamma);
-                            FStar_TypeChecker_Env.gamma_sig =
-                              (env.FStar_TypeChecker_Env.gamma_sig);
-                            FStar_TypeChecker_Env.gamma_cache =
-                              (env.FStar_TypeChecker_Env.gamma_cache);
-                            FStar_TypeChecker_Env.modules =
-                              (env.FStar_TypeChecker_Env.modules);
-                            FStar_TypeChecker_Env.expected_typ =
-                              (env.FStar_TypeChecker_Env.expected_typ);
-                            FStar_TypeChecker_Env.sigtab =
-                              (env.FStar_TypeChecker_Env.sigtab);
-                            FStar_TypeChecker_Env.attrtab =
-                              (env.FStar_TypeChecker_Env.attrtab);
-                            FStar_TypeChecker_Env.instantiate_imp =
-                              (env.FStar_TypeChecker_Env.instantiate_imp);
-                            FStar_TypeChecker_Env.effects =
-                              (env.FStar_TypeChecker_Env.effects);
-                            FStar_TypeChecker_Env.generalize =
-                              (env.FStar_TypeChecker_Env.generalize);
-                            FStar_TypeChecker_Env.letrecs =
-                              (env.FStar_TypeChecker_Env.letrecs);
-                            FStar_TypeChecker_Env.top_level =
-                              (env.FStar_TypeChecker_Env.top_level);
-                            FStar_TypeChecker_Env.check_uvars =
-                              (env.FStar_TypeChecker_Env.check_uvars);
-                            FStar_TypeChecker_Env.use_eq_strict =
-                              (env.FStar_TypeChecker_Env.use_eq_strict);
-                            FStar_TypeChecker_Env.is_iface =
-                              (env.FStar_TypeChecker_Env.is_iface);
-                            FStar_TypeChecker_Env.admit =
-                              (env.FStar_TypeChecker_Env.admit);
-                            FStar_TypeChecker_Env.lax =
-                              (env.FStar_TypeChecker_Env.lax);
-                            FStar_TypeChecker_Env.lax_universes =
-                              (env.FStar_TypeChecker_Env.lax_universes);
-                            FStar_TypeChecker_Env.phase1 =
-                              (env.FStar_TypeChecker_Env.phase1);
-                            FStar_TypeChecker_Env.failhard =
-                              (env.FStar_TypeChecker_Env.failhard);
-                            FStar_TypeChecker_Env.nosynth =
-                              (env.FStar_TypeChecker_Env.nosynth);
-                            FStar_TypeChecker_Env.uvar_subtyping =
-                              (env.FStar_TypeChecker_Env.uvar_subtyping);
-                            FStar_TypeChecker_Env.tc_term =
-                              (env.FStar_TypeChecker_Env.tc_term);
-                            FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                              (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                            FStar_TypeChecker_Env.universe_of =
-                              (env.FStar_TypeChecker_Env.universe_of);
-                            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                              =
-                              (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                            FStar_TypeChecker_Env.teq_nosmt_force =
-                              (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                            FStar_TypeChecker_Env.subtype_nosmt_force =
-                              (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                            FStar_TypeChecker_Env.qtbl_name_and_index =
-                              (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                            FStar_TypeChecker_Env.normalized_eff_names =
-                              (env.FStar_TypeChecker_Env.normalized_eff_names);
-                            FStar_TypeChecker_Env.fv_delta_depths =
-                              (env.FStar_TypeChecker_Env.fv_delta_depths);
-                            FStar_TypeChecker_Env.proof_ns =
-                              (env.FStar_TypeChecker_Env.proof_ns);
-                            FStar_TypeChecker_Env.synth_hook =
-                              (env.FStar_TypeChecker_Env.synth_hook);
-                            FStar_TypeChecker_Env.try_solve_implicits_hook =
-                              (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                            FStar_TypeChecker_Env.splice =
-                              (env.FStar_TypeChecker_Env.splice);
-                            FStar_TypeChecker_Env.mpreprocess =
-                              (env.FStar_TypeChecker_Env.mpreprocess);
-                            FStar_TypeChecker_Env.postprocess =
-                              (env.FStar_TypeChecker_Env.postprocess);
-                            FStar_TypeChecker_Env.identifier_info =
-                              (env.FStar_TypeChecker_Env.identifier_info);
-                            FStar_TypeChecker_Env.tc_hooks =
-                              (env.FStar_TypeChecker_Env.tc_hooks);
-                            FStar_TypeChecker_Env.dsenv = dsenv;
-                            FStar_TypeChecker_Env.nbe =
-                              (env.FStar_TypeChecker_Env.nbe);
-                            FStar_TypeChecker_Env.strict_args_tab =
-                              (env.FStar_TypeChecker_Env.strict_args_tab);
-                            FStar_TypeChecker_Env.erasable_types_tab =
-                              (env.FStar_TypeChecker_Env.erasable_types_tab);
-                            FStar_TypeChecker_Env.enable_defer_to_tac =
-                              (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                            FStar_TypeChecker_Env.unif_allow_ref_guards =
-                              (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                            FStar_TypeChecker_Env.erase_erasable_args =
-                              (env.FStar_TypeChecker_Env.erase_erasable_args);
-                            FStar_TypeChecker_Env.core_check =
-                              (env.FStar_TypeChecker_Env.core_check)
-                          } in
-                        (let uu___8 =
-                           FStar_TypeChecker_Env.debug env1 FStar_Options.Low in
-                         if uu___8
-                         then
-                           let uu___9 =
-                             let uu___10 =
-                               FStar_Compiler_List.map
-                                 FStar_Syntax_Print.sigelt_to_string ses in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               (FStar_String.concat "\n") uu___10 in
-                           FStar_Compiler_Util.print1
-                             "Splice returned sigelts {\n%s\n}\n" uu___9
-                         else ());
-                        ([], ses, env1))))))
-           | FStar_Syntax_Syntax.Sig_let (lbs, lids) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_TypeChecker_Env.current_module env in
-                   FStar_Ident.string_of_lid uu___4 in
-                 FStar_Pervasives_Native.Some uu___3 in
-               FStar_Profiling.profile
-                 (fun uu___3 -> tc_sig_let env r se2 lbs lids) uu___2
-                 "FStar.TypeChecker.Tc.tc_sig_let"
-           | FStar_Syntax_Syntax.Sig_polymonadic_bind
-               (m, n, p, t, uu___2, uu___3) ->
-               let t1 =
-                 let uu___4 = do_two_phases env in
-                 if uu___4
-                 then
-                   run_phase1
-                     (fun uu___5 ->
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_TypeChecker_TcEffect.tc_polymonadic_bind
-                                  {
-                                    FStar_TypeChecker_Env.solver =
-                                      (env.FStar_TypeChecker_Env.solver);
-                                    FStar_TypeChecker_Env.range =
-                                      (env.FStar_TypeChecker_Env.range);
-                                    FStar_TypeChecker_Env.curmodule =
-                                      (env.FStar_TypeChecker_Env.curmodule);
-                                    FStar_TypeChecker_Env.gamma =
-                                      (env.FStar_TypeChecker_Env.gamma);
-                                    FStar_TypeChecker_Env.gamma_sig =
-                                      (env.FStar_TypeChecker_Env.gamma_sig);
-                                    FStar_TypeChecker_Env.gamma_cache =
-                                      (env.FStar_TypeChecker_Env.gamma_cache);
-                                    FStar_TypeChecker_Env.modules =
-                                      (env.FStar_TypeChecker_Env.modules);
-                                    FStar_TypeChecker_Env.expected_typ =
-                                      (env.FStar_TypeChecker_Env.expected_typ);
-                                    FStar_TypeChecker_Env.sigtab =
-                                      (env.FStar_TypeChecker_Env.sigtab);
-                                    FStar_TypeChecker_Env.attrtab =
-                                      (env.FStar_TypeChecker_Env.attrtab);
-                                    FStar_TypeChecker_Env.instantiate_imp =
-                                      (env.FStar_TypeChecker_Env.instantiate_imp);
-                                    FStar_TypeChecker_Env.effects =
-                                      (env.FStar_TypeChecker_Env.effects);
-                                    FStar_TypeChecker_Env.generalize =
-                                      (env.FStar_TypeChecker_Env.generalize);
-                                    FStar_TypeChecker_Env.letrecs =
-                                      (env.FStar_TypeChecker_Env.letrecs);
-                                    FStar_TypeChecker_Env.top_level =
-                                      (env.FStar_TypeChecker_Env.top_level);
-                                    FStar_TypeChecker_Env.check_uvars =
-                                      (env.FStar_TypeChecker_Env.check_uvars);
-                                    FStar_TypeChecker_Env.use_eq_strict =
-                                      (env.FStar_TypeChecker_Env.use_eq_strict);
-                                    FStar_TypeChecker_Env.is_iface =
-                                      (env.FStar_TypeChecker_Env.is_iface);
-                                    FStar_TypeChecker_Env.admit =
-                                      (env.FStar_TypeChecker_Env.admit);
-                                    FStar_TypeChecker_Env.lax = true;
-                                    FStar_TypeChecker_Env.lax_universes =
-                                      (env.FStar_TypeChecker_Env.lax_universes);
-                                    FStar_TypeChecker_Env.phase1 = true;
-                                    FStar_TypeChecker_Env.failhard =
-                                      (env.FStar_TypeChecker_Env.failhard);
-                                    FStar_TypeChecker_Env.nosynth =
-                                      (env.FStar_TypeChecker_Env.nosynth);
-                                    FStar_TypeChecker_Env.uvar_subtyping =
-                                      (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                    FStar_TypeChecker_Env.tc_term =
-                                      (env.FStar_TypeChecker_Env.tc_term);
-                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                      =
-                                      (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.universe_of =
-                                      (env.FStar_TypeChecker_Env.universe_of);
-                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                      =
-                                      (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.teq_nosmt_force =
-                                      (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                      =
-                                      (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                      =
-                                      (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                    FStar_TypeChecker_Env.normalized_eff_names
-                                      =
-                                      (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                    FStar_TypeChecker_Env.fv_delta_depths =
-                                      (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                    FStar_TypeChecker_Env.proof_ns =
-                                      (env.FStar_TypeChecker_Env.proof_ns);
-                                    FStar_TypeChecker_Env.synth_hook =
-                                      (env.FStar_TypeChecker_Env.synth_hook);
-                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                      =
-                                      (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                    FStar_TypeChecker_Env.splice =
-                                      (env.FStar_TypeChecker_Env.splice);
-                                    FStar_TypeChecker_Env.mpreprocess =
-                                      (env.FStar_TypeChecker_Env.mpreprocess);
-                                    FStar_TypeChecker_Env.postprocess =
-                                      (env.FStar_TypeChecker_Env.postprocess);
-                                    FStar_TypeChecker_Env.identifier_info =
-                                      (env.FStar_TypeChecker_Env.identifier_info);
-                                    FStar_TypeChecker_Env.tc_hooks =
-                                      (env.FStar_TypeChecker_Env.tc_hooks);
-                                    FStar_TypeChecker_Env.dsenv =
-                                      (env.FStar_TypeChecker_Env.dsenv);
-                                    FStar_TypeChecker_Env.nbe =
-                                      (env.FStar_TypeChecker_Env.nbe);
-                                    FStar_TypeChecker_Env.strict_args_tab =
-                                      (env.FStar_TypeChecker_Env.strict_args_tab);
-                                    FStar_TypeChecker_Env.erasable_types_tab
-                                      =
-                                      (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                      =
-                                      (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                      =
-                                      (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                    FStar_TypeChecker_Env.erase_erasable_args
-                                      =
-                                      (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                    FStar_TypeChecker_Env.core_check =
-                                      (env.FStar_TypeChecker_Env.core_check)
-                                  } m n p t in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                (fun uu___10 ->
-                                   match uu___10 with
-                                   | (t2, ty, uu___11) ->
-                                       {
-                                         FStar_Syntax_Syntax.sigel =
-                                           (FStar_Syntax_Syntax.Sig_polymonadic_bind
-                                              (m, n, p, t2, ty,
-                                                FStar_Pervasives_Native.None));
-                                         FStar_Syntax_Syntax.sigrng =
-                                           (se2.FStar_Syntax_Syntax.sigrng);
-                                         FStar_Syntax_Syntax.sigquals =
-                                           (se2.FStar_Syntax_Syntax.sigquals);
-                                         FStar_Syntax_Syntax.sigmeta =
-                                           (se2.FStar_Syntax_Syntax.sigmeta);
-                                         FStar_Syntax_Syntax.sigattrs =
-                                           (se2.FStar_Syntax_Syntax.sigattrs);
-                                         FStar_Syntax_Syntax.sigopts =
-                                           (se2.FStar_Syntax_Syntax.sigopts)
-                                       }) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___8
-                              (FStar_TypeChecker_Normalize.elim_uvars env) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___7
-                            (fun se3 ->
-                               match se3.FStar_Syntax_Syntax.sigel with
-                               | FStar_Syntax_Syntax.Sig_polymonadic_bind
-                                   (uu___8, uu___9, uu___10, t2, ty, uu___11)
-                                   -> (t2, ty)
-                               | uu___8 ->
-                                   failwith
-                                     "Impossible! tc for Sig_polymonadic_bind must be a Sig_polymonadic_bind") in
-                        match uu___6 with
-                        | (t2, ty) ->
-                            ((let uu___8 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env)
-                                  (FStar_Options.Other "TwoPhases") in
-                              if uu___8
-                              then
-                                let uu___9 =
-                                  FStar_Syntax_Print.sigelt_to_string
-                                    {
-                                      FStar_Syntax_Syntax.sigel =
-                                        (FStar_Syntax_Syntax.Sig_polymonadic_bind
-                                           (m, n, p, t2, ty,
-                                             FStar_Pervasives_Native.None));
-                                      FStar_Syntax_Syntax.sigrng =
-                                        (se2.FStar_Syntax_Syntax.sigrng);
-                                      FStar_Syntax_Syntax.sigquals =
-                                        (se2.FStar_Syntax_Syntax.sigquals);
-                                      FStar_Syntax_Syntax.sigmeta =
-                                        (se2.FStar_Syntax_Syntax.sigmeta);
-                                      FStar_Syntax_Syntax.sigattrs =
-                                        (se2.FStar_Syntax_Syntax.sigattrs);
-                                      FStar_Syntax_Syntax.sigopts =
-                                        (se2.FStar_Syntax_Syntax.sigopts)
-                                    } in
-                                FStar_Compiler_Util.print1
-                                  "Polymonadic bind after phase 1: %s\n"
-                                  uu___9
-                              else ());
-                             t2))
-                 else t in
-               let uu___4 =
-                 FStar_TypeChecker_TcEffect.tc_polymonadic_bind env m n p t1 in
-               (match uu___4 with
-                | (t2, ty, k) ->
-                    let se3 =
-                      {
-                        FStar_Syntax_Syntax.sigel =
-                          (FStar_Syntax_Syntax.Sig_polymonadic_bind
-                             (m, n, p, t2, ty,
-                               (FStar_Pervasives_Native.Some k)));
-                        FStar_Syntax_Syntax.sigrng =
-                          (se2.FStar_Syntax_Syntax.sigrng);
-                        FStar_Syntax_Syntax.sigquals =
-                          (se2.FStar_Syntax_Syntax.sigquals);
-                        FStar_Syntax_Syntax.sigmeta =
-                          (se2.FStar_Syntax_Syntax.sigmeta);
-                        FStar_Syntax_Syntax.sigattrs =
-                          (se2.FStar_Syntax_Syntax.sigattrs);
-                        FStar_Syntax_Syntax.sigopts =
-                          (se2.FStar_Syntax_Syntax.sigopts)
-                      } in
-                    ([se3], [], env0))
-           | FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-               (m, n, t, uu___2, uu___3) ->
-               let t1 =
-                 let uu___4 = do_two_phases env in
-                 if uu___4
-                 then
-                   run_phase1
-                     (fun uu___5 ->
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_TypeChecker_TcEffect.tc_polymonadic_subcomp
-                                  {
-                                    FStar_TypeChecker_Env.solver =
-                                      (env.FStar_TypeChecker_Env.solver);
-                                    FStar_TypeChecker_Env.range =
-                                      (env.FStar_TypeChecker_Env.range);
-                                    FStar_TypeChecker_Env.curmodule =
-                                      (env.FStar_TypeChecker_Env.curmodule);
-                                    FStar_TypeChecker_Env.gamma =
-                                      (env.FStar_TypeChecker_Env.gamma);
-                                    FStar_TypeChecker_Env.gamma_sig =
-                                      (env.FStar_TypeChecker_Env.gamma_sig);
-                                    FStar_TypeChecker_Env.gamma_cache =
-                                      (env.FStar_TypeChecker_Env.gamma_cache);
-                                    FStar_TypeChecker_Env.modules =
-                                      (env.FStar_TypeChecker_Env.modules);
-                                    FStar_TypeChecker_Env.expected_typ =
-                                      (env.FStar_TypeChecker_Env.expected_typ);
-                                    FStar_TypeChecker_Env.sigtab =
-                                      (env.FStar_TypeChecker_Env.sigtab);
-                                    FStar_TypeChecker_Env.attrtab =
-                                      (env.FStar_TypeChecker_Env.attrtab);
-                                    FStar_TypeChecker_Env.instantiate_imp =
-                                      (env.FStar_TypeChecker_Env.instantiate_imp);
-                                    FStar_TypeChecker_Env.effects =
-                                      (env.FStar_TypeChecker_Env.effects);
-                                    FStar_TypeChecker_Env.generalize =
-                                      (env.FStar_TypeChecker_Env.generalize);
-                                    FStar_TypeChecker_Env.letrecs =
-                                      (env.FStar_TypeChecker_Env.letrecs);
-                                    FStar_TypeChecker_Env.top_level =
-                                      (env.FStar_TypeChecker_Env.top_level);
-                                    FStar_TypeChecker_Env.check_uvars =
-                                      (env.FStar_TypeChecker_Env.check_uvars);
-                                    FStar_TypeChecker_Env.use_eq_strict =
-                                      (env.FStar_TypeChecker_Env.use_eq_strict);
-                                    FStar_TypeChecker_Env.is_iface =
-                                      (env.FStar_TypeChecker_Env.is_iface);
-                                    FStar_TypeChecker_Env.admit =
-                                      (env.FStar_TypeChecker_Env.admit);
-                                    FStar_TypeChecker_Env.lax = true;
-                                    FStar_TypeChecker_Env.lax_universes =
-                                      (env.FStar_TypeChecker_Env.lax_universes);
-                                    FStar_TypeChecker_Env.phase1 = true;
-                                    FStar_TypeChecker_Env.failhard =
-                                      (env.FStar_TypeChecker_Env.failhard);
-                                    FStar_TypeChecker_Env.nosynth =
-                                      (env.FStar_TypeChecker_Env.nosynth);
-                                    FStar_TypeChecker_Env.uvar_subtyping =
-                                      (env.FStar_TypeChecker_Env.uvar_subtyping);
-                                    FStar_TypeChecker_Env.tc_term =
-                                      (env.FStar_TypeChecker_Env.tc_term);
-                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                      =
-                                      (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.universe_of =
-                                      (env.FStar_TypeChecker_Env.universe_of);
-                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                      =
-                                      (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                    FStar_TypeChecker_Env.teq_nosmt_force =
-                                      (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                      =
-                                      (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                      =
-                                      (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                    FStar_TypeChecker_Env.normalized_eff_names
-                                      =
-                                      (env.FStar_TypeChecker_Env.normalized_eff_names);
-                                    FStar_TypeChecker_Env.fv_delta_depths =
-                                      (env.FStar_TypeChecker_Env.fv_delta_depths);
-                                    FStar_TypeChecker_Env.proof_ns =
-                                      (env.FStar_TypeChecker_Env.proof_ns);
-                                    FStar_TypeChecker_Env.synth_hook =
-                                      (env.FStar_TypeChecker_Env.synth_hook);
-                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                      =
-                                      (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                    FStar_TypeChecker_Env.splice =
-                                      (env.FStar_TypeChecker_Env.splice);
-                                    FStar_TypeChecker_Env.mpreprocess =
-                                      (env.FStar_TypeChecker_Env.mpreprocess);
-                                    FStar_TypeChecker_Env.postprocess =
-                                      (env.FStar_TypeChecker_Env.postprocess);
-                                    FStar_TypeChecker_Env.identifier_info =
-                                      (env.FStar_TypeChecker_Env.identifier_info);
-                                    FStar_TypeChecker_Env.tc_hooks =
-                                      (env.FStar_TypeChecker_Env.tc_hooks);
-                                    FStar_TypeChecker_Env.dsenv =
-                                      (env.FStar_TypeChecker_Env.dsenv);
-                                    FStar_TypeChecker_Env.nbe =
-                                      (env.FStar_TypeChecker_Env.nbe);
-                                    FStar_TypeChecker_Env.strict_args_tab =
-                                      (env.FStar_TypeChecker_Env.strict_args_tab);
-                                    FStar_TypeChecker_Env.erasable_types_tab
-                                      =
-                                      (env.FStar_TypeChecker_Env.erasable_types_tab);
-                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                      =
-                                      (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                      =
-                                      (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                    FStar_TypeChecker_Env.erase_erasable_args
-                                      =
-                                      (env.FStar_TypeChecker_Env.erase_erasable_args);
-                                    FStar_TypeChecker_Env.core_check =
-                                      (env.FStar_TypeChecker_Env.core_check)
-                                  } m n t in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                (fun uu___10 ->
-                                   match uu___10 with
-                                   | (t2, ty, uu___11) ->
-                                       {
-                                         FStar_Syntax_Syntax.sigel =
-                                           (FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-                                              (m, n, t2, ty,
-                                                FStar_Pervasives_Native.None));
-                                         FStar_Syntax_Syntax.sigrng =
-                                           (se2.FStar_Syntax_Syntax.sigrng);
-                                         FStar_Syntax_Syntax.sigquals =
-                                           (se2.FStar_Syntax_Syntax.sigquals);
-                                         FStar_Syntax_Syntax.sigmeta =
-                                           (se2.FStar_Syntax_Syntax.sigmeta);
-                                         FStar_Syntax_Syntax.sigattrs =
-                                           (se2.FStar_Syntax_Syntax.sigattrs);
-                                         FStar_Syntax_Syntax.sigopts =
-                                           (se2.FStar_Syntax_Syntax.sigopts)
-                                       }) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___8
-                              (FStar_TypeChecker_Normalize.elim_uvars env) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___7
-                            (fun se3 ->
-                               match se3.FStar_Syntax_Syntax.sigel with
-                               | FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-                                   (uu___8, uu___9, t2, ty, uu___10) ->
-                                   (t2, ty)
-                               | uu___8 ->
-                                   failwith
-                                     "Impossible! tc for Sig_polymonadic_subcomp must be a Sig_polymonadic_subcomp") in
-                        match uu___6 with
-                        | (t2, ty) ->
-                            ((let uu___8 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env)
-                                  (FStar_Options.Other "TwoPhases") in
-                              if uu___8
-                              then
-                                let uu___9 =
-                                  FStar_Syntax_Print.sigelt_to_string
-                                    {
-                                      FStar_Syntax_Syntax.sigel =
-                                        (FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-                                           (m, n, t2, ty,
-                                             FStar_Pervasives_Native.None));
-                                      FStar_Syntax_Syntax.sigrng =
-                                        (se2.FStar_Syntax_Syntax.sigrng);
-                                      FStar_Syntax_Syntax.sigquals =
-                                        (se2.FStar_Syntax_Syntax.sigquals);
-                                      FStar_Syntax_Syntax.sigmeta =
-                                        (se2.FStar_Syntax_Syntax.sigmeta);
-                                      FStar_Syntax_Syntax.sigattrs =
-                                        (se2.FStar_Syntax_Syntax.sigattrs);
-                                      FStar_Syntax_Syntax.sigopts =
-                                        (se2.FStar_Syntax_Syntax.sigopts)
-                                    } in
-                                FStar_Compiler_Util.print1
-                                  "Polymonadic subcomp after phase 1: %s\n"
-                                  uu___9
-                              else ());
-                             t2))
-                 else t in
-               let uu___4 =
-                 FStar_TypeChecker_TcEffect.tc_polymonadic_subcomp env m n t1 in
-               (match uu___4 with
-                | (t2, ty, k) ->
-                    let se3 =
-                      {
-                        FStar_Syntax_Syntax.sigel =
-                          (FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-                             (m, n, t2, ty, (FStar_Pervasives_Native.Some k)));
-                        FStar_Syntax_Syntax.sigrng =
-                          (se2.FStar_Syntax_Syntax.sigrng);
-                        FStar_Syntax_Syntax.sigquals =
-                          (se2.FStar_Syntax_Syntax.sigquals);
-                        FStar_Syntax_Syntax.sigmeta =
-                          (se2.FStar_Syntax_Syntax.sigmeta);
-                        FStar_Syntax_Syntax.sigattrs =
-                          (se2.FStar_Syntax_Syntax.sigattrs);
-                        FStar_Syntax_Syntax.sigopts =
-                          (se2.FStar_Syntax_Syntax.sigopts)
-                      } in
-                    ([se3], [], env0)))
-let (tc_decl :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_Syntax_Syntax.sigelt Prims.list * FStar_Syntax_Syntax.sigelt
-        Prims.list * FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun se ->
-      let env1 = set_hint_correlator env se in
-      (let uu___1 =
-         let uu___2 =
-           FStar_Ident.string_of_lid env1.FStar_TypeChecker_Env.curmodule in
-         FStar_Options.debug_module uu___2 in
-       if uu___1
-       then
-         let uu___2 =
-           let uu___3 =
-             FStar_Compiler_Effect.op_Bar_Greater
-               (FStar_Syntax_Util.lids_of_sigelt se)
-               (FStar_Compiler_List.map FStar_Ident.string_of_lid) in
-           FStar_Compiler_Effect.op_Bar_Greater uu___3
-             (FStar_String.concat ", ") in
-         FStar_Compiler_Util.print1 "Processing %s\n" uu___2
-       else ());
-      (let uu___2 = FStar_TypeChecker_Env.debug env1 FStar_Options.Low in
-       if uu___2
-       then
-         let uu___3 = FStar_Syntax_Print.sigelt_to_string se in
-         FStar_Compiler_Util.print1 ">>>>>>>>>>>>>>tc_decl %s\n" uu___3
-       else ());
-      if (se.FStar_Syntax_Syntax.sigmeta).FStar_Syntax_Syntax.sigmeta_admit
-      then
-        (let old = FStar_Options.admit_smt_queries () in
-         FStar_Options.set_admit_smt_queries true;
-         (let result = tc_decl' env1 se in
-          FStar_Options.set_admit_smt_queries old; result))
-      else tc_decl' env1 se
-let (add_sigelt_to_env :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt -> Prims.bool -> FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun se ->
-      fun from_cache ->
-        (let uu___1 = FStar_TypeChecker_Env.debug env FStar_Options.Low in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.sigelt_to_string se in
-           let uu___3 = FStar_Compiler_Util.string_of_bool from_cache in
-           FStar_Compiler_Util.print2
-             ">>>>>>>>>>>>>>Adding top-level decl to environment: %s (from_cache:%s)\n"
-             uu___2 uu___3
-         else ());
-        (match se.FStar_Syntax_Syntax.sigel with
-         | FStar_Syntax_Syntax.Sig_inductive_typ uu___1 ->
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Print.sigelt_to_string se in
-                 FStar_Compiler_Util.format1
-                   "add_sigelt_to_env: unexpected bare type/data constructor: %s"
-                   uu___4 in
-               (FStar_Errors.Fatal_UnexpectedInductivetype, uu___3) in
-             FStar_Errors.raise_error uu___2 se.FStar_Syntax_Syntax.sigrng
-         | FStar_Syntax_Syntax.Sig_datacon uu___1 ->
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Print.sigelt_to_string se in
-                 FStar_Compiler_Util.format1
-                   "add_sigelt_to_env: unexpected bare type/data constructor: %s"
-                   uu___4 in
-               (FStar_Errors.Fatal_UnexpectedInductivetype, uu___3) in
-             FStar_Errors.raise_error uu___2 se.FStar_Syntax_Syntax.sigrng
-         | FStar_Syntax_Syntax.Sig_declare_typ (uu___1, uu___2, uu___3) when
-             FStar_Compiler_Effect.op_Bar_Greater
-               se.FStar_Syntax_Syntax.sigquals
-               (FStar_Compiler_Util.for_some
-                  (fun uu___4 ->
-                     match uu___4 with
-                     | FStar_Syntax_Syntax.OnlyName -> true
-                     | uu___5 -> false))
-             -> env
-         | FStar_Syntax_Syntax.Sig_let (uu___1, uu___2) when
-             FStar_Compiler_Effect.op_Bar_Greater
-               se.FStar_Syntax_Syntax.sigquals
-               (FStar_Compiler_Util.for_some
-                  (fun uu___3 ->
-                     match uu___3 with
-                     | FStar_Syntax_Syntax.OnlyName -> true
-                     | uu___4 -> false))
-             -> env
-         | uu___1 ->
-             let env1 = FStar_TypeChecker_Env.push_sigelt env se in
-             (match se.FStar_Syntax_Syntax.sigel with
-              | FStar_Syntax_Syntax.Sig_pragma
-                  (FStar_Syntax_Syntax.PushOptions uu___2) ->
-                  if from_cache
-                  then env1
-                  else
-                    (let uu___4 = FStar_Options.using_facts_from () in
-                     {
-                       FStar_TypeChecker_Env.solver =
-                         (env1.FStar_TypeChecker_Env.solver);
-                       FStar_TypeChecker_Env.range =
-                         (env1.FStar_TypeChecker_Env.range);
-                       FStar_TypeChecker_Env.curmodule =
-                         (env1.FStar_TypeChecker_Env.curmodule);
-                       FStar_TypeChecker_Env.gamma =
-                         (env1.FStar_TypeChecker_Env.gamma);
-                       FStar_TypeChecker_Env.gamma_sig =
-                         (env1.FStar_TypeChecker_Env.gamma_sig);
-                       FStar_TypeChecker_Env.gamma_cache =
-                         (env1.FStar_TypeChecker_Env.gamma_cache);
-                       FStar_TypeChecker_Env.modules =
-                         (env1.FStar_TypeChecker_Env.modules);
-                       FStar_TypeChecker_Env.expected_typ =
-                         (env1.FStar_TypeChecker_Env.expected_typ);
-                       FStar_TypeChecker_Env.sigtab =
-                         (env1.FStar_TypeChecker_Env.sigtab);
-                       FStar_TypeChecker_Env.attrtab =
-                         (env1.FStar_TypeChecker_Env.attrtab);
-                       FStar_TypeChecker_Env.instantiate_imp =
-                         (env1.FStar_TypeChecker_Env.instantiate_imp);
-                       FStar_TypeChecker_Env.effects =
-                         (env1.FStar_TypeChecker_Env.effects);
-                       FStar_TypeChecker_Env.generalize =
-                         (env1.FStar_TypeChecker_Env.generalize);
-                       FStar_TypeChecker_Env.letrecs =
-                         (env1.FStar_TypeChecker_Env.letrecs);
-                       FStar_TypeChecker_Env.top_level =
-                         (env1.FStar_TypeChecker_Env.top_level);
-                       FStar_TypeChecker_Env.check_uvars =
-                         (env1.FStar_TypeChecker_Env.check_uvars);
-                       FStar_TypeChecker_Env.use_eq_strict =
-                         (env1.FStar_TypeChecker_Env.use_eq_strict);
-                       FStar_TypeChecker_Env.is_iface =
-                         (env1.FStar_TypeChecker_Env.is_iface);
-                       FStar_TypeChecker_Env.admit =
-                         (env1.FStar_TypeChecker_Env.admit);
-                       FStar_TypeChecker_Env.lax =
-                         (env1.FStar_TypeChecker_Env.lax);
-                       FStar_TypeChecker_Env.lax_universes =
-                         (env1.FStar_TypeChecker_Env.lax_universes);
-                       FStar_TypeChecker_Env.phase1 =
-                         (env1.FStar_TypeChecker_Env.phase1);
-                       FStar_TypeChecker_Env.failhard =
-                         (env1.FStar_TypeChecker_Env.failhard);
-                       FStar_TypeChecker_Env.nosynth =
-                         (env1.FStar_TypeChecker_Env.nosynth);
-                       FStar_TypeChecker_Env.uvar_subtyping =
-                         (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                       FStar_TypeChecker_Env.tc_term =
-                         (env1.FStar_TypeChecker_Env.tc_term);
-                       FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                         (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.universe_of =
-                         (env1.FStar_TypeChecker_Env.universe_of);
-                       FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                         =
-                         (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.teq_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                       FStar_TypeChecker_Env.subtype_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                       FStar_TypeChecker_Env.qtbl_name_and_index =
-                         (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                       FStar_TypeChecker_Env.normalized_eff_names =
-                         (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                       FStar_TypeChecker_Env.fv_delta_depths =
-                         (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                       FStar_TypeChecker_Env.proof_ns = uu___4;
-                       FStar_TypeChecker_Env.synth_hook =
-                         (env1.FStar_TypeChecker_Env.synth_hook);
-                       FStar_TypeChecker_Env.try_solve_implicits_hook =
-                         (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                       FStar_TypeChecker_Env.splice =
-                         (env1.FStar_TypeChecker_Env.splice);
-                       FStar_TypeChecker_Env.mpreprocess =
-                         (env1.FStar_TypeChecker_Env.mpreprocess);
-                       FStar_TypeChecker_Env.postprocess =
-                         (env1.FStar_TypeChecker_Env.postprocess);
-                       FStar_TypeChecker_Env.identifier_info =
-                         (env1.FStar_TypeChecker_Env.identifier_info);
-                       FStar_TypeChecker_Env.tc_hooks =
-                         (env1.FStar_TypeChecker_Env.tc_hooks);
-                       FStar_TypeChecker_Env.dsenv =
-                         (env1.FStar_TypeChecker_Env.dsenv);
-                       FStar_TypeChecker_Env.nbe =
-                         (env1.FStar_TypeChecker_Env.nbe);
-                       FStar_TypeChecker_Env.strict_args_tab =
-                         (env1.FStar_TypeChecker_Env.strict_args_tab);
-                       FStar_TypeChecker_Env.erasable_types_tab =
-                         (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                       FStar_TypeChecker_Env.enable_defer_to_tac =
-                         (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                       FStar_TypeChecker_Env.unif_allow_ref_guards =
-                         (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                       FStar_TypeChecker_Env.erase_erasable_args =
-                         (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                       FStar_TypeChecker_Env.core_check =
-                         (env1.FStar_TypeChecker_Env.core_check)
-                     })
-              | FStar_Syntax_Syntax.Sig_pragma
-                  (FStar_Syntax_Syntax.PopOptions) ->
-                  if from_cache
-                  then env1
-                  else
-                    (let uu___3 = FStar_Options.using_facts_from () in
-                     {
-                       FStar_TypeChecker_Env.solver =
-                         (env1.FStar_TypeChecker_Env.solver);
-                       FStar_TypeChecker_Env.range =
-                         (env1.FStar_TypeChecker_Env.range);
-                       FStar_TypeChecker_Env.curmodule =
-                         (env1.FStar_TypeChecker_Env.curmodule);
-                       FStar_TypeChecker_Env.gamma =
-                         (env1.FStar_TypeChecker_Env.gamma);
-                       FStar_TypeChecker_Env.gamma_sig =
-                         (env1.FStar_TypeChecker_Env.gamma_sig);
-                       FStar_TypeChecker_Env.gamma_cache =
-                         (env1.FStar_TypeChecker_Env.gamma_cache);
-                       FStar_TypeChecker_Env.modules =
-                         (env1.FStar_TypeChecker_Env.modules);
-                       FStar_TypeChecker_Env.expected_typ =
-                         (env1.FStar_TypeChecker_Env.expected_typ);
-                       FStar_TypeChecker_Env.sigtab =
-                         (env1.FStar_TypeChecker_Env.sigtab);
-                       FStar_TypeChecker_Env.attrtab =
-                         (env1.FStar_TypeChecker_Env.attrtab);
-                       FStar_TypeChecker_Env.instantiate_imp =
-                         (env1.FStar_TypeChecker_Env.instantiate_imp);
-                       FStar_TypeChecker_Env.effects =
-                         (env1.FStar_TypeChecker_Env.effects);
-                       FStar_TypeChecker_Env.generalize =
-                         (env1.FStar_TypeChecker_Env.generalize);
-                       FStar_TypeChecker_Env.letrecs =
-                         (env1.FStar_TypeChecker_Env.letrecs);
-                       FStar_TypeChecker_Env.top_level =
-                         (env1.FStar_TypeChecker_Env.top_level);
-                       FStar_TypeChecker_Env.check_uvars =
-                         (env1.FStar_TypeChecker_Env.check_uvars);
-                       FStar_TypeChecker_Env.use_eq_strict =
-                         (env1.FStar_TypeChecker_Env.use_eq_strict);
-                       FStar_TypeChecker_Env.is_iface =
-                         (env1.FStar_TypeChecker_Env.is_iface);
-                       FStar_TypeChecker_Env.admit =
-                         (env1.FStar_TypeChecker_Env.admit);
-                       FStar_TypeChecker_Env.lax =
-                         (env1.FStar_TypeChecker_Env.lax);
-                       FStar_TypeChecker_Env.lax_universes =
-                         (env1.FStar_TypeChecker_Env.lax_universes);
-                       FStar_TypeChecker_Env.phase1 =
-                         (env1.FStar_TypeChecker_Env.phase1);
-                       FStar_TypeChecker_Env.failhard =
-                         (env1.FStar_TypeChecker_Env.failhard);
-                       FStar_TypeChecker_Env.nosynth =
-                         (env1.FStar_TypeChecker_Env.nosynth);
-                       FStar_TypeChecker_Env.uvar_subtyping =
-                         (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                       FStar_TypeChecker_Env.tc_term =
-                         (env1.FStar_TypeChecker_Env.tc_term);
-                       FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                         (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.universe_of =
-                         (env1.FStar_TypeChecker_Env.universe_of);
-                       FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                         =
-                         (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.teq_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                       FStar_TypeChecker_Env.subtype_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                       FStar_TypeChecker_Env.qtbl_name_and_index =
-                         (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                       FStar_TypeChecker_Env.normalized_eff_names =
-                         (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                       FStar_TypeChecker_Env.fv_delta_depths =
-                         (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                       FStar_TypeChecker_Env.proof_ns = uu___3;
-                       FStar_TypeChecker_Env.synth_hook =
-                         (env1.FStar_TypeChecker_Env.synth_hook);
-                       FStar_TypeChecker_Env.try_solve_implicits_hook =
-                         (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                       FStar_TypeChecker_Env.splice =
-                         (env1.FStar_TypeChecker_Env.splice);
-                       FStar_TypeChecker_Env.mpreprocess =
-                         (env1.FStar_TypeChecker_Env.mpreprocess);
-                       FStar_TypeChecker_Env.postprocess =
-                         (env1.FStar_TypeChecker_Env.postprocess);
-                       FStar_TypeChecker_Env.identifier_info =
-                         (env1.FStar_TypeChecker_Env.identifier_info);
-                       FStar_TypeChecker_Env.tc_hooks =
-                         (env1.FStar_TypeChecker_Env.tc_hooks);
-                       FStar_TypeChecker_Env.dsenv =
-                         (env1.FStar_TypeChecker_Env.dsenv);
-                       FStar_TypeChecker_Env.nbe =
-                         (env1.FStar_TypeChecker_Env.nbe);
-                       FStar_TypeChecker_Env.strict_args_tab =
-                         (env1.FStar_TypeChecker_Env.strict_args_tab);
-                       FStar_TypeChecker_Env.erasable_types_tab =
-                         (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                       FStar_TypeChecker_Env.enable_defer_to_tac =
-                         (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                       FStar_TypeChecker_Env.unif_allow_ref_guards =
-                         (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                       FStar_TypeChecker_Env.erase_erasable_args =
-                         (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                       FStar_TypeChecker_Env.core_check =
-                         (env1.FStar_TypeChecker_Env.core_check)
-                     })
-              | FStar_Syntax_Syntax.Sig_pragma
-                  (FStar_Syntax_Syntax.SetOptions uu___2) ->
-                  if from_cache
-                  then env1
-                  else
-                    (let uu___4 = FStar_Options.using_facts_from () in
-                     {
-                       FStar_TypeChecker_Env.solver =
-                         (env1.FStar_TypeChecker_Env.solver);
-                       FStar_TypeChecker_Env.range =
-                         (env1.FStar_TypeChecker_Env.range);
-                       FStar_TypeChecker_Env.curmodule =
-                         (env1.FStar_TypeChecker_Env.curmodule);
-                       FStar_TypeChecker_Env.gamma =
-                         (env1.FStar_TypeChecker_Env.gamma);
-                       FStar_TypeChecker_Env.gamma_sig =
-                         (env1.FStar_TypeChecker_Env.gamma_sig);
-                       FStar_TypeChecker_Env.gamma_cache =
-                         (env1.FStar_TypeChecker_Env.gamma_cache);
-                       FStar_TypeChecker_Env.modules =
-                         (env1.FStar_TypeChecker_Env.modules);
-                       FStar_TypeChecker_Env.expected_typ =
-                         (env1.FStar_TypeChecker_Env.expected_typ);
-                       FStar_TypeChecker_Env.sigtab =
-                         (env1.FStar_TypeChecker_Env.sigtab);
-                       FStar_TypeChecker_Env.attrtab =
-                         (env1.FStar_TypeChecker_Env.attrtab);
-                       FStar_TypeChecker_Env.instantiate_imp =
-                         (env1.FStar_TypeChecker_Env.instantiate_imp);
-                       FStar_TypeChecker_Env.effects =
-                         (env1.FStar_TypeChecker_Env.effects);
-                       FStar_TypeChecker_Env.generalize =
-                         (env1.FStar_TypeChecker_Env.generalize);
-                       FStar_TypeChecker_Env.letrecs =
-                         (env1.FStar_TypeChecker_Env.letrecs);
-                       FStar_TypeChecker_Env.top_level =
-                         (env1.FStar_TypeChecker_Env.top_level);
-                       FStar_TypeChecker_Env.check_uvars =
-                         (env1.FStar_TypeChecker_Env.check_uvars);
-                       FStar_TypeChecker_Env.use_eq_strict =
-                         (env1.FStar_TypeChecker_Env.use_eq_strict);
-                       FStar_TypeChecker_Env.is_iface =
-                         (env1.FStar_TypeChecker_Env.is_iface);
-                       FStar_TypeChecker_Env.admit =
-                         (env1.FStar_TypeChecker_Env.admit);
-                       FStar_TypeChecker_Env.lax =
-                         (env1.FStar_TypeChecker_Env.lax);
-                       FStar_TypeChecker_Env.lax_universes =
-                         (env1.FStar_TypeChecker_Env.lax_universes);
-                       FStar_TypeChecker_Env.phase1 =
-                         (env1.FStar_TypeChecker_Env.phase1);
-                       FStar_TypeChecker_Env.failhard =
-                         (env1.FStar_TypeChecker_Env.failhard);
-                       FStar_TypeChecker_Env.nosynth =
-                         (env1.FStar_TypeChecker_Env.nosynth);
-                       FStar_TypeChecker_Env.uvar_subtyping =
-                         (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                       FStar_TypeChecker_Env.tc_term =
-                         (env1.FStar_TypeChecker_Env.tc_term);
-                       FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                         (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.universe_of =
-                         (env1.FStar_TypeChecker_Env.universe_of);
-                       FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                         =
-                         (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.teq_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                       FStar_TypeChecker_Env.subtype_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                       FStar_TypeChecker_Env.qtbl_name_and_index =
-                         (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                       FStar_TypeChecker_Env.normalized_eff_names =
-                         (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                       FStar_TypeChecker_Env.fv_delta_depths =
-                         (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                       FStar_TypeChecker_Env.proof_ns = uu___4;
-                       FStar_TypeChecker_Env.synth_hook =
-                         (env1.FStar_TypeChecker_Env.synth_hook);
-                       FStar_TypeChecker_Env.try_solve_implicits_hook =
-                         (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                       FStar_TypeChecker_Env.splice =
-                         (env1.FStar_TypeChecker_Env.splice);
-                       FStar_TypeChecker_Env.mpreprocess =
-                         (env1.FStar_TypeChecker_Env.mpreprocess);
-                       FStar_TypeChecker_Env.postprocess =
-                         (env1.FStar_TypeChecker_Env.postprocess);
-                       FStar_TypeChecker_Env.identifier_info =
-                         (env1.FStar_TypeChecker_Env.identifier_info);
-                       FStar_TypeChecker_Env.tc_hooks =
-                         (env1.FStar_TypeChecker_Env.tc_hooks);
-                       FStar_TypeChecker_Env.dsenv =
-                         (env1.FStar_TypeChecker_Env.dsenv);
-                       FStar_TypeChecker_Env.nbe =
-                         (env1.FStar_TypeChecker_Env.nbe);
-                       FStar_TypeChecker_Env.strict_args_tab =
-                         (env1.FStar_TypeChecker_Env.strict_args_tab);
-                       FStar_TypeChecker_Env.erasable_types_tab =
-                         (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                       FStar_TypeChecker_Env.enable_defer_to_tac =
-                         (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                       FStar_TypeChecker_Env.unif_allow_ref_guards =
-                         (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                       FStar_TypeChecker_Env.erase_erasable_args =
-                         (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                       FStar_TypeChecker_Env.core_check =
-                         (env1.FStar_TypeChecker_Env.core_check)
-                     })
-              | FStar_Syntax_Syntax.Sig_pragma
-                  (FStar_Syntax_Syntax.ResetOptions uu___2) ->
-                  if from_cache
-                  then env1
-                  else
-                    (let uu___4 = FStar_Options.using_facts_from () in
-                     {
-                       FStar_TypeChecker_Env.solver =
-                         (env1.FStar_TypeChecker_Env.solver);
-                       FStar_TypeChecker_Env.range =
-                         (env1.FStar_TypeChecker_Env.range);
-                       FStar_TypeChecker_Env.curmodule =
-                         (env1.FStar_TypeChecker_Env.curmodule);
-                       FStar_TypeChecker_Env.gamma =
-                         (env1.FStar_TypeChecker_Env.gamma);
-                       FStar_TypeChecker_Env.gamma_sig =
-                         (env1.FStar_TypeChecker_Env.gamma_sig);
-                       FStar_TypeChecker_Env.gamma_cache =
-                         (env1.FStar_TypeChecker_Env.gamma_cache);
-                       FStar_TypeChecker_Env.modules =
-                         (env1.FStar_TypeChecker_Env.modules);
-                       FStar_TypeChecker_Env.expected_typ =
-                         (env1.FStar_TypeChecker_Env.expected_typ);
-                       FStar_TypeChecker_Env.sigtab =
-                         (env1.FStar_TypeChecker_Env.sigtab);
-                       FStar_TypeChecker_Env.attrtab =
-                         (env1.FStar_TypeChecker_Env.attrtab);
-                       FStar_TypeChecker_Env.instantiate_imp =
-                         (env1.FStar_TypeChecker_Env.instantiate_imp);
-                       FStar_TypeChecker_Env.effects =
-                         (env1.FStar_TypeChecker_Env.effects);
-                       FStar_TypeChecker_Env.generalize =
-                         (env1.FStar_TypeChecker_Env.generalize);
-                       FStar_TypeChecker_Env.letrecs =
-                         (env1.FStar_TypeChecker_Env.letrecs);
-                       FStar_TypeChecker_Env.top_level =
-                         (env1.FStar_TypeChecker_Env.top_level);
-                       FStar_TypeChecker_Env.check_uvars =
-                         (env1.FStar_TypeChecker_Env.check_uvars);
-                       FStar_TypeChecker_Env.use_eq_strict =
-                         (env1.FStar_TypeChecker_Env.use_eq_strict);
-                       FStar_TypeChecker_Env.is_iface =
-                         (env1.FStar_TypeChecker_Env.is_iface);
-                       FStar_TypeChecker_Env.admit =
-                         (env1.FStar_TypeChecker_Env.admit);
-                       FStar_TypeChecker_Env.lax =
-                         (env1.FStar_TypeChecker_Env.lax);
-                       FStar_TypeChecker_Env.lax_universes =
-                         (env1.FStar_TypeChecker_Env.lax_universes);
-                       FStar_TypeChecker_Env.phase1 =
-                         (env1.FStar_TypeChecker_Env.phase1);
-                       FStar_TypeChecker_Env.failhard =
-                         (env1.FStar_TypeChecker_Env.failhard);
-                       FStar_TypeChecker_Env.nosynth =
-                         (env1.FStar_TypeChecker_Env.nosynth);
-                       FStar_TypeChecker_Env.uvar_subtyping =
-                         (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                       FStar_TypeChecker_Env.tc_term =
-                         (env1.FStar_TypeChecker_Env.tc_term);
-                       FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                         (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.universe_of =
-                         (env1.FStar_TypeChecker_Env.universe_of);
-                       FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                         =
-                         (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                       FStar_TypeChecker_Env.teq_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                       FStar_TypeChecker_Env.subtype_nosmt_force =
-                         (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                       FStar_TypeChecker_Env.qtbl_name_and_index =
-                         (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                       FStar_TypeChecker_Env.normalized_eff_names =
-                         (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                       FStar_TypeChecker_Env.fv_delta_depths =
-                         (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                       FStar_TypeChecker_Env.proof_ns = uu___4;
-                       FStar_TypeChecker_Env.synth_hook =
-                         (env1.FStar_TypeChecker_Env.synth_hook);
-                       FStar_TypeChecker_Env.try_solve_implicits_hook =
-                         (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                       FStar_TypeChecker_Env.splice =
-                         (env1.FStar_TypeChecker_Env.splice);
-                       FStar_TypeChecker_Env.mpreprocess =
-                         (env1.FStar_TypeChecker_Env.mpreprocess);
-                       FStar_TypeChecker_Env.postprocess =
-                         (env1.FStar_TypeChecker_Env.postprocess);
-                       FStar_TypeChecker_Env.identifier_info =
-                         (env1.FStar_TypeChecker_Env.identifier_info);
-                       FStar_TypeChecker_Env.tc_hooks =
-                         (env1.FStar_TypeChecker_Env.tc_hooks);
-                       FStar_TypeChecker_Env.dsenv =
-                         (env1.FStar_TypeChecker_Env.dsenv);
-                       FStar_TypeChecker_Env.nbe =
-                         (env1.FStar_TypeChecker_Env.nbe);
-                       FStar_TypeChecker_Env.strict_args_tab =
-                         (env1.FStar_TypeChecker_Env.strict_args_tab);
-                       FStar_TypeChecker_Env.erasable_types_tab =
-                         (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                       FStar_TypeChecker_Env.enable_defer_to_tac =
-                         (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                       FStar_TypeChecker_Env.unif_allow_ref_guards =
-                         (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                       FStar_TypeChecker_Env.erase_erasable_args =
-                         (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                       FStar_TypeChecker_Env.core_check =
-                         (env1.FStar_TypeChecker_Env.core_check)
-                     })
-              | FStar_Syntax_Syntax.Sig_pragma
-                  (FStar_Syntax_Syntax.RestartSolver) ->
-                  if from_cache || env1.FStar_TypeChecker_Env.nosynth
-                  then env1
-                  else
-                    ((env1.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.refresh
-                       ();
-                     env1)
-              | FStar_Syntax_Syntax.Sig_pragma
-                  (FStar_Syntax_Syntax.PrintEffectsGraph) ->
-                  ((let uu___3 =
-                      FStar_TypeChecker_Env.print_effects_graph env1 in
-                    FStar_Compiler_Util.write_file "effects.graph" uu___3);
-                   env1)
-              | FStar_Syntax_Syntax.Sig_new_effect ne ->
-                  let env2 =
-                    FStar_TypeChecker_Env.push_new_effect env1
-                      (ne, (se.FStar_Syntax_Syntax.sigquals)) in
-                  FStar_Compiler_Effect.op_Bar_Greater
-                    ne.FStar_Syntax_Syntax.actions
-                    (FStar_Compiler_List.fold_left
-                       (fun env3 ->
-                          fun a ->
-                            let uu___2 =
-                              FStar_Syntax_Util.action_as_lb
-                                ne.FStar_Syntax_Syntax.mname a
-                                (a.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-                            FStar_TypeChecker_Env.push_sigelt env3 uu___2)
-                       env2)
-              | FStar_Syntax_Syntax.Sig_sub_effect sub ->
-                  FStar_TypeChecker_Util.update_env_sub_eff env1 sub
-                    se.FStar_Syntax_Syntax.sigrng
-              | FStar_Syntax_Syntax.Sig_polymonadic_bind
-                  (m, n, p, uu___2, ty, k) ->
-                  let uu___3 =
-                    FStar_Compiler_Effect.op_Bar_Greater k
-                      FStar_Compiler_Util.must in
-                  FStar_TypeChecker_Util.update_env_polymonadic_bind env1 m n
-                    p ty uu___3
-              | FStar_Syntax_Syntax.Sig_polymonadic_subcomp
-                  (m, n, uu___2, ty, k) ->
-                  let uu___3 =
-                    let uu___4 =
-                      FStar_Compiler_Effect.op_Bar_Greater k
-                        FStar_Compiler_Util.must in
-                    (ty, uu___4) in
-                  FStar_TypeChecker_Env.add_polymonadic_subcomp env1 m n
-                    uu___3
-              | uu___2 -> env1))
-let (tc_decls :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      (FStar_Syntax_Syntax.sigelt Prims.list * FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun ses ->
-      let rec process_one_decl uu___ se =
-        match uu___ with
-        | (ses1, env1) ->
-            let uu___1 =
-              env1.FStar_TypeChecker_Env.nosynth &&
-                (FStar_Options.debug_any ()) in
-            if uu___1
-            then ((ses1, env1), [])
-            else
-              ((let uu___4 =
-                  FStar_TypeChecker_Env.debug env1 FStar_Options.Low in
-                if uu___4
-                then
-                  let uu___5 = FStar_Syntax_Print.tag_of_sigelt se in
-                  let uu___6 = FStar_Syntax_Print.sigelt_to_string se in
-                  FStar_Compiler_Util.print2
-                    ">>>>>>>>>>>>>>Checking top-level %s decl %s\n" uu___5
-                    uu___6
-                else ());
-               (let uu___5 = FStar_Options.ide_id_info_off () in
-                if uu___5
-                then FStar_TypeChecker_Env.toggle_id_info env1 false
-                else ());
-               (let uu___6 =
-                  FStar_TypeChecker_Env.debug env1
-                    (FStar_Options.Other "IdInfoOn") in
-                if uu___6
-                then FStar_TypeChecker_Env.toggle_id_info env1 true
-                else ());
-               (let uu___6 =
-                  let uu___7 =
-                    let uu___8 = FStar_Syntax_Print.sigelt_to_string_short se in
-                    FStar_Compiler_Util.format1
-                      "While typechecking the top-level declaration `%s`"
-                      uu___8 in
-                  FStar_Errors.with_ctx uu___7
-                    (fun uu___8 -> tc_decl env1 se) in
-                match uu___6 with
-                | (ses', ses_elaborated, env2) ->
-                    let ses'1 =
-                      FStar_Compiler_Effect.op_Bar_Greater ses'
-                        (FStar_Compiler_List.map
-                           (fun se1 ->
-                              (let uu___8 =
-                                 FStar_TypeChecker_Env.debug env2
-                                   (FStar_Options.Other "UF") in
-                               if uu___8
-                               then
-                                 let uu___9 =
-                                   FStar_Syntax_Print.sigelt_to_string se1 in
-                                 FStar_Compiler_Util.print1
-                                   "About to elim vars from %s\n" uu___9
-                               else ());
-                              FStar_TypeChecker_Normalize.elim_uvars env2 se1)) in
-                    let ses_elaborated1 =
-                      FStar_Compiler_Effect.op_Bar_Greater ses_elaborated
-                        (FStar_Compiler_List.map
-                           (fun se1 ->
-                              (let uu___8 =
-                                 FStar_TypeChecker_Env.debug env2
-                                   (FStar_Options.Other "UF") in
-                               if uu___8
-                               then
-                                 let uu___9 =
-                                   FStar_Syntax_Print.sigelt_to_string se1 in
-                                 FStar_Compiler_Util.print1
-                                   "About to elim vars from (elaborated) %s\n"
-                                   uu___9
-                               else ());
-                              FStar_TypeChecker_Normalize.elim_uvars env2 se1)) in
-                    ((let uu___8 =
-                        let uu___9 =
-                          let uu___10 =
-                            FStar_TypeChecker_Env.current_module env2 in
-                          FStar_Ident.string_of_lid uu___10 in
-                        FStar_Pervasives_Native.Some uu___9 in
-                      FStar_Profiling.profile
-                        (fun uu___9 ->
-                           FStar_TypeChecker_Env.promote_id_info env2
-                             (fun t ->
-                                (let uu___11 =
-                                   FStar_TypeChecker_Env.debug env2
-                                     (FStar_Options.Other "UF") in
-                                 if uu___11
-                                 then
-                                   let uu___12 =
-                                     FStar_Syntax_Print.term_to_string t in
-                                   FStar_Compiler_Util.print1
-                                     "check uvars %s\n" uu___12
-                                 else ());
-                                FStar_TypeChecker_Normalize.normalize
-                                  [FStar_TypeChecker_Env.AllowUnboundUniverses;
-                                  FStar_TypeChecker_Env.CheckNoUvars;
-                                  FStar_TypeChecker_Env.Beta;
-                                  FStar_TypeChecker_Env.DoNotUnfoldPureLets;
-                                  FStar_TypeChecker_Env.CompressUvars;
-                                  FStar_TypeChecker_Env.Exclude
-                                    FStar_TypeChecker_Env.Zeta;
-                                  FStar_TypeChecker_Env.Exclude
-                                    FStar_TypeChecker_Env.Iota;
-                                  FStar_TypeChecker_Env.NoFullNorm] env2 t))
-                        uu___8 "FStar.TypeChecker.Tc.chec_uvars");
-                     (let env3 =
-                        FStar_Compiler_Effect.op_Bar_Greater ses'1
-                          (FStar_Compiler_List.fold_left
-                             (fun env4 ->
-                                fun se1 -> add_sigelt_to_env env4 se1 false)
-                             env2) in
-                      FStar_Syntax_Unionfind.reset ();
-                      (let uu___10 =
-                         (FStar_Options.log_types ()) ||
-                           (FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_TypeChecker_Env.debug env3)
-                              (FStar_Options.Other "LogTypes")) in
-                       if uu___10
-                       then
-                         let uu___11 =
-                           FStar_Compiler_List.fold_left
-                             (fun s ->
-                                fun se1 ->
-                                  let uu___12 =
-                                    let uu___13 =
-                                      FStar_Syntax_Print.sigelt_to_string se1 in
-                                    Prims.op_Hat uu___13 "\n" in
-                                  Prims.op_Hat s uu___12) "" ses'1 in
-                         FStar_Compiler_Util.print1 "Checked: %s\n" uu___11
-                       else ());
-                      (let uu___11 =
-                         let uu___12 =
-                           let uu___13 =
-                             FStar_TypeChecker_Env.current_module env3 in
-                           FStar_Ident.string_of_lid uu___13 in
-                         FStar_Pervasives_Native.Some uu___12 in
-                       FStar_Profiling.profile
-                         (fun uu___12 ->
-                            FStar_Compiler_List.iter
-                              (fun se1 ->
-                                 (env3.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.encode_sig
-                                   env3 se1) ses'1) uu___11
-                         "FStar.TypeChecker.Tc.encode_sig");
-                      (((FStar_Compiler_List.rev_append ses'1 ses1), env3),
-                        ses_elaborated1))))) in
-      let process_one_decl_timed acc se =
-        FStar_TypeChecker_Core.clear_memo_table ();
-        (let uu___1 = acc in
-         match uu___1 with
-         | (uu___2, env1) ->
-             let r =
-               let uu___3 =
-                 let uu___4 =
-                   let uu___5 = FStar_TypeChecker_Env.current_module env1 in
-                   FStar_Ident.string_of_lid uu___5 in
-                 FStar_Pervasives_Native.Some uu___4 in
-               FStar_Profiling.profile
-                 (fun uu___4 -> process_one_decl acc se) uu___3
-                 "FStar.TypeChecker.Tc.process_one_decl" in
-             ((let uu___4 =
-                 (FStar_Options.profile_group_by_decls ()) ||
-                   (FStar_Options.timing ()) in
-               if uu___4
-               then
-                 let tag =
-                   match FStar_Syntax_Util.lids_of_sigelt se with
-                   | hd::uu___5 -> FStar_Ident.string_of_lid hd
-                   | uu___5 ->
-                       FStar_Compiler_Range.string_of_range
-                         (FStar_Syntax_Util.range_of_sigelt se) in
-                 FStar_Profiling.report_and_clear tag
-               else ());
-              r)) in
-      let uu___ =
-        FStar_Syntax_Unionfind.with_uf_enabled
-          (fun uu___1 ->
-             FStar_Compiler_Util.fold_flatten process_one_decl_timed
-               ([], env) ses) in
-      match uu___ with
-      | (ses1, env1) -> ((FStar_Compiler_List.rev_append ses1 []), env1)
-let (uu___926 : unit) =
-  FStar_Compiler_Effect.op_Colon_Equals tc_decls_knot
-    (FStar_Pervasives_Native.Some tc_decls)
-let (snapshot_context :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      ((Prims.int * Prims.int * FStar_TypeChecker_Env.solver_depth_t *
-        Prims.int) * FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun msg ->
-      FStar_Compiler_Util.atomically
-        (fun uu___ -> FStar_TypeChecker_Env.snapshot env msg)
-let (rollback_context :
-  FStar_TypeChecker_Env.solver_t ->
-    Prims.string ->
-      (Prims.int * Prims.int * FStar_TypeChecker_Env.solver_depth_t *
-        Prims.int) FStar_Pervasives_Native.option ->
-        FStar_TypeChecker_Env.env)
-  =
-  fun solver ->
-    fun msg ->
-      fun depth ->
-        FStar_Compiler_Util.atomically
-          (fun uu___ ->
-             let env = FStar_TypeChecker_Env.rollback solver msg depth in env)
-let (push_context :
-  FStar_TypeChecker_Env.env -> Prims.string -> FStar_TypeChecker_Env.env) =
-  fun env ->
-    fun msg ->
-      let uu___ = snapshot_context env msg in
-      FStar_Pervasives_Native.snd uu___
-let (pop_context :
-  FStar_TypeChecker_Env.env -> Prims.string -> FStar_TypeChecker_Env.env) =
-  fun env ->
-    fun msg ->
-      rollback_context env.FStar_TypeChecker_Env.solver msg
-        FStar_Pervasives_Native.None
-let (tc_partial_modul :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul ->
-      (FStar_Syntax_Syntax.modul * FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun modul ->
-      let verify =
-        let uu___ = FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-        FStar_Options.should_verify uu___ in
-      let action = if verify then "verifying" else "lax-checking" in
-      let label =
-        if modul.FStar_Syntax_Syntax.is_interface
-        then "interface"
-        else "implementation" in
-      (let uu___1 = FStar_Options.debug_any () in
-       if uu___1
-       then
-         let uu___2 =
-           FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-         FStar_Compiler_Util.print3 "Now %s %s of %s\n" action label uu___2
-       else ());
-      (let name =
-         let uu___1 =
-           FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-         FStar_Compiler_Util.format2 "%s %s"
-           (if modul.FStar_Syntax_Syntax.is_interface
-            then "interface"
-            else "module") uu___1 in
-       let env1 =
-         {
-           FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-           FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-           FStar_TypeChecker_Env.curmodule =
-             (env.FStar_TypeChecker_Env.curmodule);
-           FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-           FStar_TypeChecker_Env.gamma_sig =
-             (env.FStar_TypeChecker_Env.gamma_sig);
-           FStar_TypeChecker_Env.gamma_cache =
-             (env.FStar_TypeChecker_Env.gamma_cache);
-           FStar_TypeChecker_Env.modules =
-             (env.FStar_TypeChecker_Env.modules);
-           FStar_TypeChecker_Env.expected_typ =
-             (env.FStar_TypeChecker_Env.expected_typ);
-           FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-           FStar_TypeChecker_Env.attrtab =
-             (env.FStar_TypeChecker_Env.attrtab);
-           FStar_TypeChecker_Env.instantiate_imp =
-             (env.FStar_TypeChecker_Env.instantiate_imp);
-           FStar_TypeChecker_Env.effects =
-             (env.FStar_TypeChecker_Env.effects);
-           FStar_TypeChecker_Env.generalize =
-             (env.FStar_TypeChecker_Env.generalize);
-           FStar_TypeChecker_Env.letrecs =
-             (env.FStar_TypeChecker_Env.letrecs);
-           FStar_TypeChecker_Env.top_level =
-             (env.FStar_TypeChecker_Env.top_level);
-           FStar_TypeChecker_Env.check_uvars =
-             (env.FStar_TypeChecker_Env.check_uvars);
-           FStar_TypeChecker_Env.use_eq_strict =
-             (env.FStar_TypeChecker_Env.use_eq_strict);
-           FStar_TypeChecker_Env.is_iface =
-             (modul.FStar_Syntax_Syntax.is_interface);
-           FStar_TypeChecker_Env.admit = (Prims.op_Negation verify);
-           FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-           FStar_TypeChecker_Env.lax_universes =
-             (env.FStar_TypeChecker_Env.lax_universes);
-           FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-           FStar_TypeChecker_Env.failhard =
-             (env.FStar_TypeChecker_Env.failhard);
-           FStar_TypeChecker_Env.nosynth =
-             (env.FStar_TypeChecker_Env.nosynth);
-           FStar_TypeChecker_Env.uvar_subtyping =
-             (env.FStar_TypeChecker_Env.uvar_subtyping);
-           FStar_TypeChecker_Env.tc_term =
-             (env.FStar_TypeChecker_Env.tc_term);
-           FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-             (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-           FStar_TypeChecker_Env.universe_of =
-             (env.FStar_TypeChecker_Env.universe_of);
-           FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-             (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-           FStar_TypeChecker_Env.teq_nosmt_force =
-             (env.FStar_TypeChecker_Env.teq_nosmt_force);
-           FStar_TypeChecker_Env.subtype_nosmt_force =
-             (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-           FStar_TypeChecker_Env.qtbl_name_and_index =
-             (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-           FStar_TypeChecker_Env.normalized_eff_names =
-             (env.FStar_TypeChecker_Env.normalized_eff_names);
-           FStar_TypeChecker_Env.fv_delta_depths =
-             (env.FStar_TypeChecker_Env.fv_delta_depths);
-           FStar_TypeChecker_Env.proof_ns =
-             (env.FStar_TypeChecker_Env.proof_ns);
-           FStar_TypeChecker_Env.synth_hook =
-             (env.FStar_TypeChecker_Env.synth_hook);
-           FStar_TypeChecker_Env.try_solve_implicits_hook =
-             (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-           FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-           FStar_TypeChecker_Env.mpreprocess =
-             (env.FStar_TypeChecker_Env.mpreprocess);
-           FStar_TypeChecker_Env.postprocess =
-             (env.FStar_TypeChecker_Env.postprocess);
-           FStar_TypeChecker_Env.identifier_info =
-             (env.FStar_TypeChecker_Env.identifier_info);
-           FStar_TypeChecker_Env.tc_hooks =
-             (env.FStar_TypeChecker_Env.tc_hooks);
-           FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-           FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-           FStar_TypeChecker_Env.strict_args_tab =
-             (env.FStar_TypeChecker_Env.strict_args_tab);
-           FStar_TypeChecker_Env.erasable_types_tab =
-             (env.FStar_TypeChecker_Env.erasable_types_tab);
-           FStar_TypeChecker_Env.enable_defer_to_tac =
-             (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-           FStar_TypeChecker_Env.unif_allow_ref_guards =
-             (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-           FStar_TypeChecker_Env.erase_erasable_args =
-             (env.FStar_TypeChecker_Env.erase_erasable_args);
-           FStar_TypeChecker_Env.core_check =
-             (env.FStar_TypeChecker_Env.core_check)
-         } in
-       let env2 =
-         FStar_TypeChecker_Env.set_current_module env1
-           modul.FStar_Syntax_Syntax.name in
-       let uu___1 =
-         let uu___2 =
-           let uu___3 =
-             FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-           FStar_Options.should_check uu___3 in
-         Prims.op_Negation uu___2 in
-       let uu___2 =
-         let uu___3 =
-           FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-         FStar_Compiler_Util.format2 "While loading dependency %s%s" uu___3
-           (if modul.FStar_Syntax_Syntax.is_interface
-            then " (interface)"
-            else "") in
-       FStar_Errors.with_ctx_if uu___1 uu___2
-         (fun uu___3 ->
-            let uu___4 = tc_decls env2 modul.FStar_Syntax_Syntax.declarations in
-            match uu___4 with
-            | (ses, env3) ->
-                ({
-                   FStar_Syntax_Syntax.name =
-                     (modul.FStar_Syntax_Syntax.name);
-                   FStar_Syntax_Syntax.declarations = ses;
-                   FStar_Syntax_Syntax.is_interface =
-                     (modul.FStar_Syntax_Syntax.is_interface)
-                 }, env3)))
-let (tc_more_partial_modul :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul ->
-      FStar_Syntax_Syntax.sigelt Prims.list ->
-        (FStar_Syntax_Syntax.modul * FStar_Syntax_Syntax.sigelt Prims.list *
-          FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun modul ->
-      fun decls ->
-        let uu___ = tc_decls env decls in
-        match uu___ with
-        | (ses, env1) ->
-            let modul1 =
-              {
-                FStar_Syntax_Syntax.name = (modul.FStar_Syntax_Syntax.name);
-                FStar_Syntax_Syntax.declarations =
-                  (FStar_Compiler_List.op_At
-                     modul.FStar_Syntax_Syntax.declarations ses);
-                FStar_Syntax_Syntax.is_interface =
-                  (modul.FStar_Syntax_Syntax.is_interface)
-              } in
-            (modul1, ses, env1)
-let (finish_partial_modul :
-  Prims.bool ->
-    Prims.bool ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.modul ->
-          (FStar_Syntax_Syntax.modul * FStar_TypeChecker_Env.env))
-  =
-  fun loading_from_cache ->
-    fun iface_exists ->
-      fun en ->
-        fun m ->
-          let env = FStar_TypeChecker_Env.finish_module en m in
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Bar_Greater
-               env.FStar_TypeChecker_Env.qtbl_name_and_index
-               FStar_Pervasives_Native.fst in
-           FStar_Compiler_Effect.op_Bar_Greater uu___1
-             FStar_Compiler_Util.smap_clear);
-          (let uu___2 =
-             let uu___3 =
-               let uu___4 =
-                 FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-               Prims.op_Hat "Ending modul " uu___4 in
-             pop_context env uu___3 in
-           FStar_Compiler_Effect.op_Bar_Greater uu___2 (fun uu___3 -> ()));
-          (m, env)
-let (tc_modul :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul ->
-      Prims.bool -> (FStar_Syntax_Syntax.modul * FStar_TypeChecker_Env.env))
-  =
-  fun env0 ->
-    fun m ->
-      fun iface_exists ->
-        let msg =
-          let uu___ = FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-          Prims.op_Hat "Internals for " uu___ in
-        let env01 = push_context env0 msg in
-        let uu___ = tc_partial_modul env01 m in
-        match uu___ with
-        | (modul, env) -> finish_partial_modul false iface_exists env modul
-let (load_checked_module :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul -> FStar_TypeChecker_Env.env)
-  =
-  fun en ->
-    fun m ->
-      let env =
-        FStar_TypeChecker_Env.set_current_module en
-          m.FStar_Syntax_Syntax.name in
-      let env1 =
-        let uu___ =
-          let uu___1 = FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-          Prims.op_Hat "Internals for " uu___1 in
-        push_context env uu___ in
-      let env2 =
-        FStar_Compiler_List.fold_left
-          (fun env3 ->
-             fun se ->
-               let env4 = add_sigelt_to_env env3 se true in
-               let lids = FStar_Syntax_Util.lids_of_sigelt se in
-               FStar_Compiler_Effect.op_Bar_Greater lids
-                 (FStar_Compiler_List.iter
-                    (fun lid ->
-                       let uu___1 =
-                         FStar_TypeChecker_Env.lookup_sigelt env4 lid in
-                       ()));
-               env4) env1 m.FStar_Syntax_Syntax.declarations in
-      let uu___ = finish_partial_modul true true env2 m in
-      match uu___ with | (uu___1, env3) -> env3
-let (check_module :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.modul ->
-      Prims.bool -> (FStar_Syntax_Syntax.modul * FStar_TypeChecker_Env.env))
-  =
-  fun env ->
-    fun m ->
-      fun b ->
-        (let uu___1 = FStar_Options.debug_any () in
-         if uu___1
-         then
-           let uu___2 =
-             FStar_Syntax_Print.lid_to_string m.FStar_Syntax_Syntax.name in
-           FStar_Compiler_Util.print2 "Checking %s: %s\n"
-             (if m.FStar_Syntax_Syntax.is_interface
-              then "i'face"
-              else "module") uu___2
-         else ());
-        (let uu___2 =
-           let uu___3 = FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-           FStar_Options.dump_module uu___3 in
-         if uu___2
-         then
-           let uu___3 = FStar_Syntax_Print.modul_to_string m in
-           FStar_Compiler_Util.print1 "Module before type checking:\n%s\n"
-             uu___3
-         else ());
-        (let env1 =
-           let uu___2 =
-             let uu___3 =
-               let uu___4 =
-                 FStar_Ident.string_of_lid m.FStar_Syntax_Syntax.name in
-               FStar_Options.should_verify uu___4 in
-             Prims.op_Negation uu___3 in
-           {
-             FStar_TypeChecker_Env.solver =
-               (env.FStar_TypeChecker_Env.solver);
-             FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-             FStar_TypeChecker_Env.curmodule =
-               (env.FStar_TypeChecker_Env.curmodule);
-             FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-             FStar_TypeChecker_Env.gamma_sig =
-               (env.FStar_TypeChecker_Env.gamma_sig);
-             FStar_TypeChecker_Env.gamma_cache =
-               (env.FStar_TypeChecker_Env.gamma_cache);
-             FStar_TypeChecker_Env.modules =
-               (env.FStar_TypeChecker_Env.modules);
-             FStar_TypeChecker_Env.expected_typ =
-               (env.FStar_TypeChecker_Env.expected_typ);
-             FStar_TypeChecker_Env.sigtab =
-               (env.FStar_TypeChecker_Env.sigtab);
-             FStar_TypeChecker_Env.attrtab =
-               (env.FStar_TypeChecker_Env.attrtab);
-             FStar_TypeChecker_Env.instantiate_imp =
-               (env.FStar_TypeChecker_Env.instantiate_imp);
-             FStar_TypeChecker_Env.effects =
-               (env.FStar_TypeChecker_Env.effects);
-             FStar_TypeChecker_Env.generalize =
-               (env.FStar_TypeChecker_Env.generalize);
-             FStar_TypeChecker_Env.letrecs =
-               (env.FStar_TypeChecker_Env.letrecs);
-             FStar_TypeChecker_Env.top_level =
-               (env.FStar_TypeChecker_Env.top_level);
-             FStar_TypeChecker_Env.check_uvars =
-               (env.FStar_TypeChecker_Env.check_uvars);
-             FStar_TypeChecker_Env.use_eq_strict =
-               (env.FStar_TypeChecker_Env.use_eq_strict);
-             FStar_TypeChecker_Env.is_iface =
-               (env.FStar_TypeChecker_Env.is_iface);
-             FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-             FStar_TypeChecker_Env.lax = uu___2;
-             FStar_TypeChecker_Env.lax_universes =
-               (env.FStar_TypeChecker_Env.lax_universes);
-             FStar_TypeChecker_Env.phase1 =
-               (env.FStar_TypeChecker_Env.phase1);
-             FStar_TypeChecker_Env.failhard =
-               (env.FStar_TypeChecker_Env.failhard);
-             FStar_TypeChecker_Env.nosynth =
-               (env.FStar_TypeChecker_Env.nosynth);
-             FStar_TypeChecker_Env.uvar_subtyping =
-               (env.FStar_TypeChecker_Env.uvar_subtyping);
-             FStar_TypeChecker_Env.tc_term =
-               (env.FStar_TypeChecker_Env.tc_term);
-             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-               (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-             FStar_TypeChecker_Env.universe_of =
-               (env.FStar_TypeChecker_Env.universe_of);
-             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-               (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-             FStar_TypeChecker_Env.teq_nosmt_force =
-               (env.FStar_TypeChecker_Env.teq_nosmt_force);
-             FStar_TypeChecker_Env.subtype_nosmt_force =
-               (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-             FStar_TypeChecker_Env.qtbl_name_and_index =
-               (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-             FStar_TypeChecker_Env.normalized_eff_names =
-               (env.FStar_TypeChecker_Env.normalized_eff_names);
-             FStar_TypeChecker_Env.fv_delta_depths =
-               (env.FStar_TypeChecker_Env.fv_delta_depths);
-             FStar_TypeChecker_Env.proof_ns =
-               (env.FStar_TypeChecker_Env.proof_ns);
-             FStar_TypeChecker_Env.synth_hook =
-               (env.FStar_TypeChecker_Env.synth_hook);
-             FStar_TypeChecker_Env.try_solve_implicits_hook =
-               (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-             FStar_TypeChecker_Env.splice =
-               (env.FStar_TypeChecker_Env.splice);
-             FStar_TypeChecker_Env.mpreprocess =
-               (env.FStar_TypeChecker_Env.mpreprocess);
-             FStar_TypeChecker_Env.postprocess =
-               (env.FStar_TypeChecker_Env.postprocess);
-             FStar_TypeChecker_Env.identifier_info =
-               (env.FStar_TypeChecker_Env.identifier_info);
-             FStar_TypeChecker_Env.tc_hooks =
-               (env.FStar_TypeChecker_Env.tc_hooks);
-             FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-             FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-             FStar_TypeChecker_Env.strict_args_tab =
-               (env.FStar_TypeChecker_Env.strict_args_tab);
-             FStar_TypeChecker_Env.erasable_types_tab =
-               (env.FStar_TypeChecker_Env.erasable_types_tab);
-             FStar_TypeChecker_Env.enable_defer_to_tac =
-               (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-             FStar_TypeChecker_Env.unif_allow_ref_guards =
-               (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-             FStar_TypeChecker_Env.erase_erasable_args =
-               (env.FStar_TypeChecker_Env.erase_erasable_args);
-             FStar_TypeChecker_Env.core_check =
-               (env.FStar_TypeChecker_Env.core_check)
-           } in
-         let uu___2 = tc_modul env1 m b in
-         match uu___2 with
-         | (m1, env2) ->
-             ((let uu___4 =
-                 let uu___5 =
-                   FStar_Ident.string_of_lid m1.FStar_Syntax_Syntax.name in
-                 FStar_Options.dump_module uu___5 in
-               if uu___4
-               then
-                 let uu___5 = FStar_Syntax_Print.modul_to_string m1 in
-                 FStar_Compiler_Util.print1
-                   "Module after type checking:\n%s\n" uu___5
-               else ());
-              (let uu___5 =
-                 (let uu___6 =
-                    FStar_Ident.string_of_lid m1.FStar_Syntax_Syntax.name in
-                  FStar_Options.dump_module uu___6) &&
-                   (let uu___6 =
-                      FStar_Ident.string_of_lid m1.FStar_Syntax_Syntax.name in
-                    FStar_Options.debug_at_level uu___6
-                      (FStar_Options.Other "Normalize")) in
-               if uu___5
-               then
-                 let normalize_toplevel_lets se =
-                   match se.FStar_Syntax_Syntax.sigel with
-                   | FStar_Syntax_Syntax.Sig_let ((b1, lbs), ids) ->
-                       let n =
-                         FStar_TypeChecker_Normalize.normalize
-                           [FStar_TypeChecker_Env.Beta;
-                           FStar_TypeChecker_Env.Eager_unfolding;
-                           FStar_TypeChecker_Env.Reify;
-                           FStar_TypeChecker_Env.Inlining;
-                           FStar_TypeChecker_Env.Primops;
-                           FStar_TypeChecker_Env.UnfoldUntil
-                             FStar_Syntax_Syntax.delta_constant;
-                           FStar_TypeChecker_Env.AllowUnboundUniverses] in
-                       let update lb =
-                         let uu___6 =
-                           FStar_Syntax_Subst.open_univ_vars
-                             lb.FStar_Syntax_Syntax.lbunivs
-                             lb.FStar_Syntax_Syntax.lbdef in
-                         match uu___6 with
-                         | (univnames, e) ->
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_TypeChecker_Env.push_univ_vars env2
-                                   univnames in
-                               n uu___8 e in
-                             {
-                               FStar_Syntax_Syntax.lbname =
-                                 (lb.FStar_Syntax_Syntax.lbname);
-                               FStar_Syntax_Syntax.lbunivs =
-                                 (lb.FStar_Syntax_Syntax.lbunivs);
-                               FStar_Syntax_Syntax.lbtyp =
-                                 (lb.FStar_Syntax_Syntax.lbtyp);
-                               FStar_Syntax_Syntax.lbeff =
-                                 (lb.FStar_Syntax_Syntax.lbeff);
-                               FStar_Syntax_Syntax.lbdef = uu___7;
-                               FStar_Syntax_Syntax.lbattrs =
-                                 (lb.FStar_Syntax_Syntax.lbattrs);
-                               FStar_Syntax_Syntax.lbpos =
-                                 (lb.FStar_Syntax_Syntax.lbpos)
-                             } in
-                       let uu___6 =
-                         let uu___7 =
-                           let uu___8 =
-                             let uu___9 = FStar_Compiler_List.map update lbs in
-                             (b1, uu___9) in
-                           (uu___8, ids) in
-                         FStar_Syntax_Syntax.Sig_let uu___7 in
-                       {
-                         FStar_Syntax_Syntax.sigel = uu___6;
-                         FStar_Syntax_Syntax.sigrng =
-                           (se.FStar_Syntax_Syntax.sigrng);
-                         FStar_Syntax_Syntax.sigquals =
-                           (se.FStar_Syntax_Syntax.sigquals);
-                         FStar_Syntax_Syntax.sigmeta =
-                           (se.FStar_Syntax_Syntax.sigmeta);
-                         FStar_Syntax_Syntax.sigattrs =
-                           (se.FStar_Syntax_Syntax.sigattrs);
-                         FStar_Syntax_Syntax.sigopts =
-                           (se.FStar_Syntax_Syntax.sigopts)
-                       }
-                   | uu___6 -> se in
-                 let normalized_module =
-                   let uu___6 =
-                     FStar_Compiler_List.map normalize_toplevel_lets
-                       m1.FStar_Syntax_Syntax.declarations in
-                   {
-                     FStar_Syntax_Syntax.name = (m1.FStar_Syntax_Syntax.name);
-                     FStar_Syntax_Syntax.declarations = uu___6;
-                     FStar_Syntax_Syntax.is_interface =
-                       (m1.FStar_Syntax_Syntax.is_interface)
-                   } in
-                 let uu___6 =
-                   FStar_Syntax_Print.modul_to_string normalized_module in
-                 FStar_Compiler_Util.print1 "%s\n" uu___6
-               else ());
-              (m1, env2)))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_TcEffect.ml b/src/ocaml-output/FStar_TypeChecker_TcEffect.ml
deleted file mode 100644
index c9ad11000f6..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_TcEffect.ml
+++ /dev/null
@@ -1,9639 +0,0 @@
-open Prims
-let (dmff_cps_and_elaborate :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      (FStar_Syntax_Syntax.sigelt Prims.list * FStar_Syntax_Syntax.eff_decl *
-        FStar_Syntax_Syntax.sigelt FStar_Pervasives_Native.option))
-  = fun env -> fun ed -> FStar_TypeChecker_DMFF.cps_and_elaborate env ed
-let (check_and_gen :
-  FStar_TypeChecker_Env.env ->
-    Prims.string ->
-      Prims.string ->
-        Prims.int ->
-          (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term) ->
-            (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.term *
-              FStar_Syntax_Syntax.typ))
-  =
-  fun env ->
-    fun eff_name ->
-      fun comb ->
-        fun n ->
-          fun uu___ ->
-            match uu___ with
-            | (us, t) ->
-                let uu___1 = FStar_Syntax_Subst.open_univ_vars us t in
-                (match uu___1 with
-                 | (us1, t1) ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_TypeChecker_Env.push_univ_vars env us1 in
-                         FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term uu___4
-                           t1 in
-                       match uu___3 with
-                       | (t2, lc, g) ->
-                           (FStar_TypeChecker_Rel.force_trivial_guard env g;
-                            (t2, (lc.FStar_TypeChecker_Common.res_typ))) in
-                     (match uu___2 with
-                      | (t2, ty) ->
-                          let uu___3 =
-                            FStar_TypeChecker_Generalize.generalize_universes
-                              env t2 in
-                          (match uu___3 with
-                           | (g_us, t3) ->
-                               let ty1 =
-                                 FStar_Syntax_Subst.close_univ_vars g_us ty in
-                               (if (FStar_Compiler_List.length g_us) <> n
-                                then
-                                  (let error =
-                                     let uu___4 =
-                                       FStar_Compiler_Util.string_of_int n in
-                                     let uu___5 =
-                                       let uu___6 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           g_us FStar_Compiler_List.length in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___6
-                                         FStar_Compiler_Util.string_of_int in
-                                     let uu___6 =
-                                       FStar_Syntax_Print.tscheme_to_string
-                                         (g_us, t3) in
-                                     FStar_Compiler_Util.format5
-                                       "Expected %s:%s to be universe-polymorphic in %s universes, but found %s (tscheme: %s)"
-                                       eff_name comb uu___4 uu___5 uu___6 in
-                                   FStar_Errors.raise_error
-                                     (FStar_Errors.Fatal_MismatchUniversePolymorphic,
-                                       error) t3.FStar_Syntax_Syntax.pos;
-                                   (match us1 with
-                                    | [] -> ()
-                                    | uu___5 ->
-                                        let uu___6 =
-                                          ((FStar_Compiler_List.length us1) =
-                                             (FStar_Compiler_List.length g_us))
-                                            &&
-                                            (FStar_Compiler_List.forall2
-                                               (fun u1 ->
-                                                  fun u2 ->
-                                                    let uu___7 =
-                                                      FStar_Syntax_Syntax.order_univ_name
-                                                        u1 u2 in
-                                                    uu___7 = Prims.int_zero)
-                                               us1 g_us) in
-                                        if uu___6
-                                        then ()
-                                        else
-                                          (let uu___8 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 FStar_Syntax_Print.univ_names_to_string
-                                                   us1 in
-                                               let uu___11 =
-                                                 FStar_Syntax_Print.univ_names_to_string
-                                                   g_us in
-                                               FStar_Compiler_Util.format4
-                                                 "Expected and generalized universes in the declaration for %s:%s are different, input: %s, but after gen: %s"
-                                                 eff_name comb uu___10
-                                                 uu___11 in
-                                             (FStar_Errors.Fatal_UnexpectedNumberOfUniverse,
-                                               uu___9) in
-                                           FStar_Errors.raise_error uu___8
-                                             t3.FStar_Syntax_Syntax.pos)))
-                                else ();
-                                (g_us, t3, ty1)))))
-let (pure_wp_uvar :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      Prims.string ->
-        FStar_Compiler_Range.range ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.guard_t))
-  =
-  fun env ->
-    fun t ->
-      fun reason ->
-        fun r ->
-          let pure_wp_t =
-            let pure_wp_ts =
-              let uu___ =
-                FStar_TypeChecker_Env.lookup_definition
-                  [FStar_TypeChecker_Env.NoDelta] env
-                  FStar_Parser_Const.pure_wp_lid in
-              FStar_Compiler_Effect.op_Bar_Greater uu___
-                FStar_Compiler_Util.must in
-            let uu___ = FStar_TypeChecker_Env.inst_tscheme pure_wp_ts in
-            match uu___ with
-            | (uu___1, pure_wp_t1) ->
-                let uu___2 =
-                  let uu___3 =
-                    FStar_Compiler_Effect.op_Bar_Greater t
-                      FStar_Syntax_Syntax.as_arg in
-                  [uu___3] in
-                FStar_Syntax_Syntax.mk_Tm_app pure_wp_t1 uu___2 r in
-          let uu___ =
-            FStar_TypeChecker_Env.new_implicit_var_aux reason r env pure_wp_t
-              FStar_Syntax_Syntax.Strict FStar_Pervasives_Native.None in
-          match uu___ with
-          | (pure_wp_uvar1, uu___1, guard_wp) -> (pure_wp_uvar1, guard_wp)
-let op_let_Question :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun f ->
-    fun g ->
-      match f with
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-      | FStar_Pervasives_Native.Some x -> g x
-let (mteq :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ -> Prims.bool)
-  =
-  fun env ->
-    fun t1 ->
-      fun t2 ->
-        try
-          (fun uu___ ->
-             match () with
-             | () -> FStar_TypeChecker_Rel.teq_nosmt_force env t1 t2) ()
-        with | uu___ -> false
-let (eq_binders :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.indexed_effect_binder_kind Prims.list
-          FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun bs1 ->
-      fun bs2 ->
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_List.fold_left2
-              (fun uu___2 ->
-                 fun b1 ->
-                   fun b2 ->
-                     match uu___2 with
-                     | (b, ss) ->
-                         let uu___3 =
-                           b &&
-                             (let uu___4 =
-                                FStar_Syntax_Subst.subst ss
-                                  (b1.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                              mteq env uu___4
-                                (b2.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort) in
-                         let uu___4 =
-                           let uu___5 =
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     b2.FStar_Syntax_Syntax.binder_bv
-                                     FStar_Syntax_Syntax.bv_to_name in
-                                 ((b1.FStar_Syntax_Syntax.binder_bv), uu___8) in
-                               FStar_Syntax_Syntax.NT uu___7 in
-                             [uu___6] in
-                           FStar_Compiler_List.op_At ss uu___5 in
-                         (uu___3, uu___4)) (true, []) bs1 bs2 in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Pervasives_Native.fst in
-        if uu___
-        then
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater bs1
-              (FStar_Compiler_List.map
-                 (fun uu___2 -> FStar_Syntax_Syntax.Substitutive_binder)) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        else FStar_Pervasives_Native.None
-let (log_ad_hoc_combinator_warning :
-  Prims.string -> FStar_Compiler_Range.range -> unit) =
-  fun comb_name ->
-    fun r ->
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Util.format1
-            "Combinator %s is not a substitutive indexed effect combinator, it is better to make it one if possible for better performance and ease of use"
-            comb_name in
-        (FStar_Errors.Warning_Adhoc_IndexedEffect_Combinator, uu___1) in
-      FStar_Errors.log_issue r uu___
-let (bind_combinator_kind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.tscheme ->
-            FStar_Syntax_Syntax.tscheme ->
-              FStar_Syntax_Syntax.tscheme ->
-                FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-                  FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option
-                    ->
-                    FStar_Syntax_Syntax.tscheme
-                      FStar_Pervasives_Native.option ->
-                      FStar_Syntax_Syntax.univ_names ->
-                        FStar_Syntax_Syntax.typ ->
-                          Prims.int ->
-                            Prims.bool ->
-                              FStar_Syntax_Syntax.indexed_effect_binder_kind
-                                Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun m_eff_name ->
-      fun n_eff_name ->
-        fun p_eff_name ->
-          fun m_sig_ts ->
-            fun n_sig_ts ->
-              fun p_sig_ts ->
-                fun m_repr_ts ->
-                  fun n_repr_ts ->
-                    fun p_repr_ts ->
-                      fun bind_us ->
-                        fun k ->
-                          fun num_effect_params ->
-                            fun has_range_binders ->
-                              let debug s =
-                                let uu___ =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env)
-                                    (FStar_Options.Other "LayeredEffectsTc") in
-                                if uu___
-                                then FStar_Compiler_Util.print1 "%s\n" s
-                                else () in
-                              (let uu___1 =
-                                 let uu___2 =
-                                   FStar_Compiler_Util.string_of_int
-                                     num_effect_params in
-                                 FStar_Compiler_Util.format1
-                                   "Checking bind combinator kind with %s effect parameters"
-                                   uu___2 in
-                               debug uu___1);
-                              (let uu___1 = bind_us in
-                               match uu___1 with
-                               | u_a::u_b::[] ->
-                                   let uu___2 =
-                                     let uu___3 =
-                                       FStar_Compiler_Effect.op_Bar_Greater k
-                                         FStar_Syntax_Util.arrow_formals in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___3 FStar_Pervasives_Native.fst in
-                                   (match uu___2 with
-                                    | a_b::b_b::rest_bs ->
-                                        let uu___3 =
-                                          if
-                                            num_effect_params =
-                                              Prims.int_zero
-                                          then
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              ([], [], rest_bs)
-                                              (fun uu___4 ->
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___4)
-                                          else
-                                            (let uu___5 =
-                                               FStar_TypeChecker_Env.inst_tscheme_with
-                                                 m_sig_ts
-                                                 [FStar_Syntax_Syntax.U_name
-                                                    u_a] in
-                                             match uu___5 with
-                                             | (uu___6, sig1) ->
-                                                 let sig_bs =
-                                                   let uu___7 =
-                                                     let uu___8 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         sig1
-                                                         FStar_Syntax_Util.arrow_formals in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___8
-                                                       FStar_Pervasives_Native.fst in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___7
-                                                     FStar_Compiler_List.tl in
-                                                 let uu___7 =
-                                                   if
-                                                     (FStar_Compiler_List.length
-                                                        sig_bs)
-                                                       < num_effect_params
-                                                   then
-                                                     FStar_Pervasives_Native.None
-                                                   else
-                                                     (let uu___9 =
-                                                        let uu___10 =
-                                                          FStar_Compiler_List.splitAt
-                                                            num_effect_params
-                                                            sig_bs in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___10
-                                                          FStar_Pervasives_Native.fst in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___9
-                                                        (fun uu___10 ->
-                                                           FStar_Pervasives_Native.Some
-                                                             uu___10)) in
-                                                 op_let_Question uu___7
-                                                   (fun sig_eff_params_bs ->
-                                                      let uu___8 =
-                                                        if
-                                                          (FStar_Compiler_List.length
-                                                             rest_bs)
-                                                            <
-                                                            num_effect_params
-                                                        then
-                                                          FStar_Pervasives_Native.None
-                                                        else
-                                                          (let uu___10 =
-                                                             FStar_Compiler_List.splitAt
-                                                               num_effect_params
-                                                               rest_bs in
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uu___10
-                                                             (fun uu___11 ->
-                                                                FStar_Pervasives_Native.Some
-                                                                  uu___11)) in
-                                                      op_let_Question uu___8
-                                                        (fun uu___9 ->
-                                                           match uu___9 with
-                                                           | (eff_params_bs,
-                                                              rest_bs1) ->
-                                                               let uu___10 =
-                                                                 eq_binders
-                                                                   env
-                                                                   sig_eff_params_bs
-                                                                   eff_params_bs in
-                                                               op_let_Question
-                                                                 uu___10
-                                                                 (fun
-                                                                    eff_params_bs_kinds
-                                                                    ->
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (eff_params_bs,
-                                                                    eff_params_bs_kinds,
-                                                                    rest_bs1)
-                                                                    (fun
-                                                                    uu___11
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___11))))) in
-                                        op_let_Question uu___3
-                                          (fun uu___4 ->
-                                             match uu___4 with
-                                             | (eff_params_bs,
-                                                eff_params_bs_kinds,
-                                                rest_bs1) ->
-                                                 let uu___5 =
-                                                   let f_sig_bs =
-                                                     let uu___6 =
-                                                       FStar_TypeChecker_Env.inst_tscheme_with
-                                                         m_sig_ts
-                                                         [FStar_Syntax_Syntax.U_name
-                                                            u_a] in
-                                                     match uu___6 with
-                                                     | (uu___7, sig1) ->
-                                                         let uu___8 =
-                                                           let uu___9 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               sig1
-                                                               FStar_Syntax_Util.arrow_formals in
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uu___9
-                                                             FStar_Pervasives_Native.fst in
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           uu___8
-                                                           (fun uu___9 ->
-                                                              match uu___9
-                                                              with
-                                                              | a::bs ->
-                                                                  let uu___10
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    num_effect_params
-                                                                    bs in
-                                                                  (match uu___10
-                                                                   with
-                                                                   | 
-                                                                   (sig_bs,
-                                                                    bs1) ->
-                                                                    let ss =
-                                                                    let uu___11
-                                                                    =
-                                                                    let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((a.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___14) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___13 in
-                                                                    [uu___12] in
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun ss1
-                                                                    ->
-                                                                    fun sig_b
-                                                                    ->
-                                                                    fun b ->
-                                                                    let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___15) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___14 in
-                                                                    [uu___13] in
-                                                                    FStar_Compiler_List.op_At
-                                                                    ss1
-                                                                    uu___12)
-                                                                    uu___11
-                                                                    sig_bs
-                                                                    eff_params_bs in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (FStar_Syntax_Subst.subst_binders
-                                                                    ss))) in
-                                                   let uu___6 =
-                                                     if
-                                                       (FStar_Compiler_List.length
-                                                          rest_bs1)
-                                                         <
-                                                         (FStar_Compiler_List.length
-                                                            f_sig_bs)
-                                                     then
-                                                       FStar_Pervasives_Native.None
-                                                     else
-                                                       (let uu___8 =
-                                                          FStar_Compiler_List.splitAt
-                                                            (FStar_Compiler_List.length
-                                                               f_sig_bs)
-                                                            rest_bs1 in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___8
-                                                          (fun uu___9 ->
-                                                             FStar_Pervasives_Native.Some
-                                                               uu___9)) in
-                                                   op_let_Question uu___6
-                                                     (fun uu___7 ->
-                                                        match uu___7 with
-                                                        | (f_bs, rest_bs2) ->
-                                                            let uu___8 =
-                                                              eq_binders env
-                                                                f_sig_bs f_bs in
-                                                            op_let_Question
-                                                              uu___8
-                                                              (fun f_bs_kinds
-                                                                 ->
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   (f_bs,
-                                                                    f_bs_kinds,
-                                                                    rest_bs2)
-                                                                   (fun
-                                                                    uu___9 ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___9))) in
-                                                 op_let_Question uu___5
-                                                   (fun uu___6 ->
-                                                      match uu___6 with
-                                                      | (f_bs, f_bs_kinds,
-                                                         rest_bs2) ->
-                                                          let uu___7 =
-                                                            let g_sig_bs =
-                                                              let uu___8 =
-                                                                FStar_TypeChecker_Env.inst_tscheme_with
-                                                                  n_sig_ts
-                                                                  [FStar_Syntax_Syntax.U_name
-                                                                    u_b] in
-                                                              match uu___8
-                                                              with
-                                                              | (uu___9,
-                                                                 sig1) ->
-                                                                  let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    sig1
-                                                                    FStar_Syntax_Util.arrow_formals in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___11
-                                                                    FStar_Pervasives_Native.fst in
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___10
-                                                                    (
-                                                                    fun
-                                                                    uu___11
-                                                                    ->
-                                                                    match uu___11
-                                                                    with
-                                                                    | 
-                                                                    b::bs ->
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    num_effect_params
-                                                                    bs in
-                                                                    (match uu___12
-                                                                    with
-                                                                    | 
-                                                                    (sig_bs,
-                                                                    bs1) ->
-                                                                    let ss =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___16) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___15 in
-                                                                    [uu___14] in
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun ss1
-                                                                    ->
-                                                                    fun sig_b
-                                                                    ->
-                                                                    fun b1 ->
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b1.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___17) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___16 in
-                                                                    [uu___15] in
-                                                                    FStar_Compiler_List.op_At
-                                                                    ss1
-                                                                    uu___14)
-                                                                    uu___13
-                                                                    sig_bs
-                                                                    eff_params_bs in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (FStar_Syntax_Subst.subst_binders
-                                                                    ss))) in
-                                                            let uu___8 =
-                                                              if
-                                                                (FStar_Compiler_List.length
-                                                                   rest_bs2)
-                                                                  <
-                                                                  (FStar_Compiler_List.length
-                                                                    g_sig_bs)
-                                                              then
-                                                                FStar_Pervasives_Native.None
-                                                              else
-                                                                (let uu___10
-                                                                   =
-                                                                   FStar_Compiler_List.splitAt
-                                                                    (FStar_Compiler_List.length
-                                                                    g_sig_bs)
-                                                                    rest_bs2 in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___10
-                                                                   (fun
-                                                                    uu___11
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___11)) in
-                                                            op_let_Question
-                                                              uu___8
-                                                              (fun uu___9 ->
-                                                                 match uu___9
-                                                                 with
-                                                                 | (g_bs,
-                                                                    rest_bs3)
-                                                                    ->
-                                                                    let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    fun
-                                                                    g_sig_b
-                                                                    ->
-                                                                    fun g_b
-                                                                    ->
-                                                                    match uu___12
-                                                                    with
-                                                                    | 
-                                                                    (l, ss)
-                                                                    ->
-                                                                    let g_sig_b_sort
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    ss
-                                                                    (g_sig_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    let g_sig_b_arrow_t
-                                                                    =
-                                                                    let x_bv
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Syntax_Syntax.gen_bv
-                                                                    "x"
-                                                                    FStar_Pervasives_Native.None
-                                                                    uu___13 in
-                                                                    let ss1 =
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    match uu___14
-                                                                    with
-                                                                    | 
-                                                                    (bv, k1)
-                                                                    ->
-                                                                    if
-                                                                    k1 =
-                                                                    FStar_Syntax_Syntax.Substitutive_binder
-                                                                    then
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    bv in
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    x_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___21
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    [uu___20] in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    uu___18
-                                                                    uu___19
-                                                                    FStar_Compiler_Range.dummyRange in
-                                                                    (bv,
-                                                                    uu___17) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___16 in
-                                                                    [uu___15]
-                                                                    else [])
-                                                                    l in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    FStar_Compiler_List.flatten in
-                                                                    let g_sig_b_sort1
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    ss1
-                                                                    g_sig_b_sort in
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    x_bv in
-                                                                    [uu___14] in
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    g_sig_b_sort1 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___13
-                                                                    uu___14 in
-                                                                    let g_b_kind
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_Syntax_Util.eq_tm
-                                                                    g_sig_b_arrow_t
-                                                                    (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    uu___14 =
-                                                                    FStar_Syntax_Util.Equal in
-                                                                    if
-                                                                    uu___13
-                                                                    then
-                                                                    FStar_Syntax_Syntax.Substitutive_binder
-                                                                    else
-                                                                    (let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Util.eq_tm
-                                                                    g_sig_b_sort
-                                                                    (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    uu___16 =
-                                                                    FStar_Syntax_Util.Equal in
-                                                                    if
-                                                                    uu___15
-                                                                    then
-                                                                    FStar_Syntax_Syntax.BindCont_no_abstraction_binder
-                                                                    else
-                                                                    FStar_Syntax_Syntax.Ad_hoc_binder) in
-                                                                    let ss1 =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    g_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((g_sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___16) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___15 in
-                                                                    [uu___14] in
-                                                                    FStar_Compiler_List.op_At
-                                                                    ss
-                                                                    uu___13 in
-                                                                    ((FStar_Compiler_List.op_At
-                                                                    l
-                                                                    [
-                                                                    ((g_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    g_b_kind)]),
-                                                                    ss1))
-                                                                    ([], [])
-                                                                    g_sig_bs
-                                                                    g_bs in
-                                                                    match uu___11
-                                                                    with
-                                                                    | 
-                                                                    (g_bs_kinds,
-                                                                    uu___12)
-                                                                    ->
-                                                                    let g_bs_kinds1
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    FStar_Pervasives_Native.snd
-                                                                    g_bs_kinds in
-                                                                    if
-                                                                    FStar_Compiler_List.contains
-                                                                    FStar_Syntax_Syntax.Ad_hoc_binder
-                                                                    g_bs_kinds1
-                                                                    then
-                                                                    FStar_Pervasives_Native.None
-                                                                    else
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    g_bs_kinds1
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___14) in
-                                                                    op_let_Question
-                                                                    uu___10
-                                                                    (fun
-                                                                    g_bs_kinds
-                                                                    ->
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (g_bs,
-                                                                    g_bs_kinds,
-                                                                    rest_bs3)
-                                                                    (fun
-                                                                    uu___11
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___11))) in
-                                                          op_let_Question
-                                                            uu___7
-                                                            (fun uu___8 ->
-                                                               match uu___8
-                                                               with
-                                                               | (g_bs,
-                                                                  g_bs_kinds,
-                                                                  rest_bs3)
-                                                                   ->
-                                                                   let uu___9
-                                                                    =
-                                                                    if
-                                                                    has_range_binders
-                                                                    then
-                                                                    FStar_Compiler_List.splitAt
-                                                                    (Prims.of_int (2))
-                                                                    rest_bs3
-                                                                    else
-                                                                    ([],
-                                                                    rest_bs3) in
-                                                                   (match uu___9
-                                                                    with
-                                                                    | 
-                                                                    (range_bs,
-                                                                    rest_bs4)
-                                                                    ->
-                                                                    let uu___10
-                                                                    = uu___9 in
-                                                                    let uu___11
-                                                                    =
-                                                                    if
-                                                                    (FStar_Compiler_List.length
-                                                                    rest_bs4)
-                                                                    >=
-                                                                    (Prims.of_int (2))
-                                                                    then
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    ((FStar_Compiler_List.length
-                                                                    rest_bs4)
-                                                                    -
-                                                                    (Prims.of_int (2)))
-                                                                    rest_bs4 in
-                                                                    match uu___12
-                                                                    with
-                                                                    | 
-                                                                    (rest_bs5,
-                                                                    f_b::g_b::[])
-                                                                    ->
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (rest_bs5,
-                                                                    f_b, g_b)
-                                                                    (fun
-                                                                    uu___13
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___13)
-                                                                    else
-                                                                    FStar_Pervasives_Native.None in
-                                                                    op_let_Question
-                                                                    uu___11
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    match uu___12
-                                                                    with
-                                                                    | 
-                                                                    (rest_bs5,
-                                                                    f_b, g_b)
-                                                                    ->
-                                                                    let uu___13
-                                                                    =
-                                                                    let repr_app_bs
-                                                                    =
-                                                                    FStar_Compiler_List.op_At
-                                                                    eff_params_bs
-                                                                    f_bs in
-                                                                    let expected_f_b_sort
-                                                                    =
-                                                                    match m_repr_ts
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    repr_ts
-                                                                    ->
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_TypeChecker_Env.inst_tscheme_with
-                                                                    repr_ts
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u_a] in
-                                                                    (match uu___14
-                                                                    with
-                                                                    | 
-                                                                    (uu___15,
-                                                                    t) ->
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___18
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___19
-                                                                    ->
-                                                                    match uu___19
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___20;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___21;_}
-                                                                    ->
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___22
-                                                                    FStar_Syntax_Syntax.as_arg)
-                                                                    repr_app_bs in
-                                                                    uu___17
-                                                                    ::
-                                                                    uu___18 in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    t uu___16
-                                                                    FStar_Compiler_Range.dummyRange)
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Syntax_Syntax.null_binder
-                                                                    FStar_Syntax_Syntax.t_unit in
-                                                                    [uu___15] in
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    repr_app_bs
-                                                                    (FStar_Compiler_List.map
-                                                                    (fun b ->
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___19
-                                                                    FStar_Syntax_Syntax.as_arg)) in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.comp_univs
-                                                                    =
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u_a];
-                                                                    FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    m_eff_name;
-                                                                    FStar_Syntax_Syntax.result_typ
-                                                                    = uu___17;
-                                                                    FStar_Syntax_Syntax.effect_args
-                                                                    = uu___18;
-                                                                    FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                    } in
-                                                                    FStar_Syntax_Syntax.mk_Comp
-                                                                    uu___16 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___14
-                                                                    uu___15 in
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Syntax_Util.eq_tm
-                                                                    (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                                    expected_f_b_sort in
-                                                                    uu___15 =
-                                                                    FStar_Syntax_Util.Equal in
-                                                                    if
-                                                                    uu___14
-                                                                    then
-                                                                    FStar_Pervasives_Native.Some
-                                                                    ()
-                                                                    else
-                                                                    FStar_Pervasives_Native.None in
-                                                                    op_let_Question
-                                                                    uu___13
-                                                                    (fun
-                                                                    _f_b_ok_
-                                                                    ->
-                                                                    let uu___14
-                                                                    =
-                                                                    let expected_g_b_sort
-                                                                    =
-                                                                    let x_bv
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Syntax_Syntax.gen_bv
-                                                                    "x"
-                                                                    FStar_Pervasives_Native.None
-                                                                    uu___15 in
-                                                                    let eff_params_args
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    match uu___15
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___16;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___17;_}
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___18
-                                                                    FStar_Syntax_Syntax.as_arg)
-                                                                    eff_params_bs in
-                                                                    let g_bs_args
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Compiler_List.map2
-                                                                    (fun
-                                                                    uu___16
-                                                                    ->
-                                                                    fun kind
-                                                                    ->
-                                                                    match uu___16
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___17;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___18;_}
-                                                                    ->
-                                                                    if
-                                                                    kind =
-                                                                    FStar_Syntax_Syntax.Substitutive_binder
-                                                                    then
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    x_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___22
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    [uu___21] in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    uu___19
-                                                                    uu___20
-                                                                    FStar_Compiler_Range.dummyRange
-                                                                    else
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name)
-                                                                    g_bs
-                                                                    g_bs_kinds in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___15
-                                                                    (FStar_Compiler_List.map
-                                                                    FStar_Syntax_Syntax.as_arg) in
-                                                                    let repr_args
-                                                                    =
-                                                                    FStar_Compiler_List.op_At
-                                                                    eff_params_args
-                                                                    g_bs_args in
-                                                                    match n_repr_ts
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    repr_ts
-                                                                    ->
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_TypeChecker_Env.inst_tscheme_with
-                                                                    repr_ts
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u_b] in
-                                                                    (match uu___15
-                                                                    with
-                                                                    | 
-                                                                    (uu___16,
-                                                                    repr_hd)
-                                                                    ->
-                                                                    let repr_app
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___19
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    uu___18
-                                                                    ::
-                                                                    repr_args in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    repr_hd
-                                                                    uu___17
-                                                                    FStar_Compiler_Range.dummyRange in
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    x_bv
-                                                                    FStar_Syntax_Syntax.mk_binder in
-                                                                    [uu___18] in
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    repr_app in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___17
-                                                                    uu___18)
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    let thunk_t
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Syntax.null_binder
-                                                                    FStar_Syntax_Syntax.t_unit in
-                                                                    [uu___16] in
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.comp_univs
-                                                                    =
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u_b];
-                                                                    FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    n_eff_name;
-                                                                    FStar_Syntax_Syntax.result_typ
-                                                                    = uu___18;
-                                                                    FStar_Syntax_Syntax.effect_args
-                                                                    =
-                                                                    repr_args;
-                                                                    FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                    } in
-                                                                    FStar_Syntax_Syntax.mk_Comp
-                                                                    uu___17 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___15
-                                                                    uu___16 in
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    x_bv
-                                                                    FStar_Syntax_Syntax.mk_binder in
-                                                                    [uu___16] in
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    thunk_t in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___15
-                                                                    uu___16 in
-                                                                    let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Syntax_Util.eq_tm
-                                                                    (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                                    expected_g_b_sort in
-                                                                    uu___16 =
-                                                                    FStar_Syntax_Util.Equal in
-                                                                    if
-                                                                    uu___15
-                                                                    then
-                                                                    FStar_Pervasives_Native.Some
-                                                                    ()
-                                                                    else
-                                                                    FStar_Pervasives_Native.None in
-                                                                    op_let_Question
-                                                                    uu___14
-                                                                    (fun
-                                                                    _g_b_ok
-                                                                    ->
-                                                                    let range_kinds
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Range_binder)
-                                                                    range_bs in
-                                                                    let rest_kinds
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Ad_hoc_binder)
-                                                                    rest_bs5 in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    (FStar_Compiler_List.op_At
-                                                                    [FStar_Syntax_Syntax.Type_binder;
-                                                                    FStar_Syntax_Syntax.Type_binder]
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    f_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    g_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    range_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    rest_kinds
-                                                                    [FStar_Syntax_Syntax.Repr_binder;
-                                                                    FStar_Syntax_Syntax.Repr_binder])))))))))))))))
-let (validate_indexed_effect_bind_shape :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.tscheme ->
-            FStar_Syntax_Syntax.tscheme ->
-              FStar_Syntax_Syntax.tscheme ->
-                FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-                  FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option
-                    ->
-                    FStar_Syntax_Syntax.tscheme
-                      FStar_Pervasives_Native.option ->
-                      FStar_Syntax_Syntax.univ_names ->
-                        FStar_Syntax_Syntax.typ ->
-                          FStar_Compiler_Range.range ->
-                            Prims.int ->
-                              Prims.bool ->
-                                (FStar_Syntax_Syntax.typ *
-                                  FStar_Syntax_Syntax.indexed_effect_combinator_kind))
-  =
-  fun env ->
-    fun m_eff_name ->
-      fun n_eff_name ->
-        fun p_eff_name ->
-          fun m_sig_ts ->
-            fun n_sig_ts ->
-              fun p_sig_ts ->
-                fun m_repr_ts ->
-                  fun n_repr_ts ->
-                    fun p_repr_ts ->
-                      fun bind_us ->
-                        fun bind_t ->
-                          fun r ->
-                            fun num_effect_params ->
-                              fun has_range_binders ->
-                                let bind_name =
-                                  let uu___ =
-                                    FStar_Ident.string_of_lid m_eff_name in
-                                  let uu___1 =
-                                    FStar_Ident.string_of_lid n_eff_name in
-                                  let uu___2 =
-                                    FStar_Ident.string_of_lid p_eff_name in
-                                  FStar_Compiler_Util.format3
-                                    "(%s , %s) |> %s" uu___ uu___1 uu___2 in
-                                let uu___ = bind_us in
-                                match uu___ with
-                                | u_a::u_b::[] ->
-                                    let a_b =
-                                      let uu___1 =
-                                        let uu___2 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            (FStar_Syntax_Syntax.U_name u_a)
-                                            FStar_Syntax_Util.type_with_u in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___2
-                                          (FStar_Syntax_Syntax.gen_bv "a"
-                                             FStar_Pervasives_Native.None) in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___1 FStar_Syntax_Syntax.mk_binder in
-                                    let b_b =
-                                      let uu___1 =
-                                        let uu___2 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            (FStar_Syntax_Syntax.U_name u_b)
-                                            FStar_Syntax_Util.type_with_u in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___2
-                                          (FStar_Syntax_Syntax.gen_bv "b"
-                                             FStar_Pervasives_Native.None) in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___1 FStar_Syntax_Syntax.mk_binder in
-                                    let rest_bs =
-                                      let uu___1 =
-                                        let uu___2 =
-                                          FStar_Syntax_Subst.compress bind_t in
-                                        uu___2.FStar_Syntax_Syntax.n in
-                                      match uu___1 with
-                                      | FStar_Syntax_Syntax.Tm_arrow
-                                          (bs, uu___2) when
-                                          (FStar_Compiler_List.length bs) >=
-                                            (Prims.of_int (4))
-                                          ->
-                                          let uu___3 =
-                                            FStar_Syntax_Subst.open_binders
-                                              bs in
-                                          (match uu___3 with
-                                           | {
-                                               FStar_Syntax_Syntax.binder_bv
-                                                 = a;
-                                               FStar_Syntax_Syntax.binder_qual
-                                                 = uu___4;
-                                               FStar_Syntax_Syntax.binder_attrs
-                                                 = uu___5;_}::{
-                                                                FStar_Syntax_Syntax.binder_bv
-                                                                  = b;
-                                                                FStar_Syntax_Syntax.binder_qual
-                                                                  = uu___6;
-                                                                FStar_Syntax_Syntax.binder_attrs
-                                                                  = uu___7;_}::bs1
-                                               ->
-                                               let uu___8 =
-                                                 let uu___9 =
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     bs1
-                                                     (FStar_Compiler_List.splitAt
-                                                        ((FStar_Compiler_List.length
-                                                            bs1)
-                                                           -
-                                                           (Prims.of_int (2)))) in
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   uu___9
-                                                   FStar_Pervasives_Native.fst in
-                                               let uu___9 =
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     let uu___12 =
-                                                       let uu___13 =
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           a_b.FStar_Syntax_Syntax.binder_bv
-                                                           FStar_Syntax_Syntax.bv_to_name in
-                                                       (a, uu___13) in
-                                                     FStar_Syntax_Syntax.NT
-                                                       uu___12 in
-                                                   let uu___12 =
-                                                     let uu___13 =
-                                                       let uu___14 =
-                                                         let uu___15 =
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             b_b.FStar_Syntax_Syntax.binder_bv
-                                                             FStar_Syntax_Syntax.bv_to_name in
-                                                         (b, uu___15) in
-                                                       FStar_Syntax_Syntax.NT
-                                                         uu___14 in
-                                                     [uu___13] in
-                                                   uu___11 :: uu___12 in
-                                                 FStar_Syntax_Subst.subst_binders
-                                                   uu___10 in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___8 uu___9)
-                                      | uu___2 ->
-                                          let uu___3 =
-                                            let uu___4 =
-                                              let uu___5 =
-                                                FStar_Syntax_Print.term_to_string
-                                                  bind_t in
-                                              FStar_Compiler_Util.format2
-                                                "Type of %s is not an arrow with >= 4 binders (%s)"
-                                                bind_name uu___5 in
-                                            (FStar_Errors.Fatal_UnexpectedEffect,
-                                              uu___4) in
-                                          FStar_Errors.raise_error uu___3 r in
-                                    let uu___1 =
-                                      if has_range_binders
-                                      then
-                                        (if
-                                           (FStar_Compiler_List.length
-                                              rest_bs)
-                                             >= (Prims.of_int (2))
-                                         then
-                                           FStar_Compiler_List.splitAt
-                                             ((FStar_Compiler_List.length
-                                                 rest_bs)
-                                                - (Prims.of_int (2))) rest_bs
-                                         else
-                                           (let uu___3 =
-                                              let uu___4 =
-                                                let uu___5 =
-                                                  FStar_Syntax_Print.term_to_string
-                                                    bind_t in
-                                                FStar_Compiler_Util.format2
-                                                  "Type of %s is not an arrow with >= 6 binders (%s)"
-                                                  bind_name uu___5 in
-                                              (FStar_Errors.Fatal_UnexpectedEffect,
-                                                uu___4) in
-                                            FStar_Errors.raise_error uu___3 r))
-                                      else (rest_bs, []) in
-                                    (match uu___1 with
-                                     | (rest_bs1, range_bs) ->
-                                         let uu___2 =
-                                           let uu___3 =
-                                             let uu___4 =
-                                               FStar_TypeChecker_Env.push_binders
-                                                 env (a_b :: b_b :: rest_bs1) in
-                                             let uu___5 =
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 a_b.FStar_Syntax_Syntax.binder_bv
-                                                 FStar_Syntax_Syntax.bv_to_name in
-                                             FStar_TypeChecker_Util.fresh_effect_repr
-                                               uu___4 r m_eff_name m_sig_ts
-                                               m_repr_ts
-                                               (FStar_Syntax_Syntax.U_name
-                                                  u_a) uu___5 in
-                                           match uu___3 with
-                                           | (repr, g) ->
-                                               let uu___4 =
-                                                 let uu___5 =
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     repr
-                                                     (FStar_Syntax_Syntax.gen_bv
-                                                        "f"
-                                                        FStar_Pervasives_Native.None) in
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   uu___5
-                                                   FStar_Syntax_Syntax.mk_binder in
-                                               (uu___4, g) in
-                                         (match uu___2 with
-                                          | (f, guard_f) ->
-                                              let uu___3 =
-                                                let x_a =
-                                                  let uu___4 =
-                                                    let uu___5 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        a_b.FStar_Syntax_Syntax.binder_bv
-                                                        FStar_Syntax_Syntax.bv_to_name in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      uu___5
-                                                      (FStar_Syntax_Syntax.gen_bv
-                                                         "x"
-                                                         FStar_Pervasives_Native.None) in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___4
-                                                    FStar_Syntax_Syntax.mk_binder in
-                                                let uu___4 =
-                                                  let uu___5 =
-                                                    FStar_TypeChecker_Env.push_binders
-                                                      env
-                                                      (FStar_Compiler_List.op_At
-                                                         (a_b :: b_b ::
-                                                         rest_bs1) [x_a]) in
-                                                  let uu___6 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      b_b.FStar_Syntax_Syntax.binder_bv
-                                                      FStar_Syntax_Syntax.bv_to_name in
-                                                  FStar_TypeChecker_Util.fresh_effect_repr
-                                                    uu___5 r n_eff_name
-                                                    n_sig_ts n_repr_ts
-                                                    (FStar_Syntax_Syntax.U_name
-                                                       u_b) uu___6 in
-                                                match uu___4 with
-                                                | (repr, g) ->
-                                                    let uu___5 =
-                                                      let uu___6 =
-                                                        let uu___7 =
-                                                          let uu___8 =
-                                                            FStar_Syntax_Syntax.mk_Total
-                                                              repr in
-                                                          FStar_Syntax_Util.arrow
-                                                            [x_a] uu___8 in
-                                                        FStar_Syntax_Syntax.gen_bv
-                                                          "g"
-                                                          FStar_Pervasives_Native.None
-                                                          uu___7 in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___6
-                                                        FStar_Syntax_Syntax.mk_binder in
-                                                    (uu___5, g) in
-                                              (match uu___3 with
-                                               | (g, guard_g) ->
-                                                   let uu___4 =
-                                                     let uu___5 =
-                                                       FStar_TypeChecker_Env.push_binders
-                                                         env (a_b :: b_b ::
-                                                         rest_bs1) in
-                                                     let uu___6 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         b_b.FStar_Syntax_Syntax.binder_bv
-                                                         FStar_Syntax_Syntax.bv_to_name in
-                                                     FStar_TypeChecker_Util.fresh_effect_repr
-                                                       uu___5 r p_eff_name
-                                                       p_sig_ts p_repr_ts
-                                                       (FStar_Syntax_Syntax.U_name
-                                                          u_b) uu___6 in
-                                                   (match uu___4 with
-                                                    | (return_repr,
-                                                       guard_return_repr) ->
-                                                        let uu___5 =
-                                                          let uu___6 =
-                                                            FStar_TypeChecker_Env.push_binders
-                                                              env (a_b :: b_b
-                                                              :: rest_bs1) in
-                                                          let uu___7 =
-                                                            FStar_Compiler_Util.format1
-                                                              "implicit for pure_wp in checking bind %s"
-                                                              bind_name in
-                                                          pure_wp_uvar uu___6
-                                                            return_repr
-                                                            uu___7 r in
-                                                        (match uu___5 with
-                                                         | (pure_wp_uvar1,
-                                                            g_pure_wp_uvar)
-                                                             ->
-                                                             let k =
-                                                               let uu___6 =
-                                                                 let uu___7 =
-                                                                   let uu___8
-                                                                    =
-                                                                    let uu___9
-                                                                    =
-                                                                    FStar_TypeChecker_Env.new_u_univ
-                                                                    () in
-                                                                    [uu___9] in
-                                                                   let uu___9
-                                                                    =
-                                                                    let uu___10
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    pure_wp_uvar1
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    [uu___10] in
-                                                                   {
-                                                                    FStar_Syntax_Syntax.comp_univs
-                                                                    = uu___8;
-                                                                    FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    FStar_Parser_Const.effect_PURE_lid;
-                                                                    FStar_Syntax_Syntax.result_typ
-                                                                    =
-                                                                    return_repr;
-                                                                    FStar_Syntax_Syntax.effect_args
-                                                                    = uu___9;
-                                                                    FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                   } in
-                                                                 FStar_Syntax_Syntax.mk_Comp
-                                                                   uu___7 in
-                                                               FStar_Syntax_Util.arrow
-                                                                 (a_b :: b_b
-                                                                 ::
-                                                                 (FStar_Compiler_List.op_At
-                                                                    rest_bs1
-                                                                    (
-                                                                    FStar_Compiler_List.op_At
-                                                                    range_bs
-                                                                    [f; g])))
-                                                                 uu___6 in
-                                                             let guard_eq =
-                                                               let uu___6 =
-                                                                 FStar_TypeChecker_Rel.teq_nosmt
-                                                                   env k
-                                                                   bind_t in
-                                                               match uu___6
-                                                               with
-                                                               | FStar_Pervasives_Native.None
-                                                                   ->
-                                                                   let uu___7
-                                                                    =
-                                                                    let uu___8
-                                                                    =
-                                                                    let uu___9
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    bind_t in
-                                                                    FStar_Compiler_Util.format2
-                                                                    "Unexpected type of %s (%s)\n"
-                                                                    bind_name
-                                                                    uu___9 in
-                                                                    (FStar_Errors.Fatal_UnexpectedEffect,
-                                                                    uu___8) in
-                                                                   FStar_Errors.raise_error
-                                                                    uu___7 r
-                                                               | FStar_Pervasives_Native.Some
-                                                                   g1 -> g1 in
-                                                             ((let uu___7 =
-                                                                 FStar_TypeChecker_Env.conj_guards
-                                                                   [guard_f;
-                                                                   guard_g;
-                                                                   guard_return_repr;
-                                                                   g_pure_wp_uvar;
-                                                                   guard_eq] in
-                                                               FStar_TypeChecker_Rel.force_trivial_guard
-                                                                 env uu___7);
-                                                              (let k1 =
-                                                                 let uu___7 =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    k
-                                                                    (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                                                    env) in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___7
-                                                                   FStar_Syntax_Subst.compress in
-                                                               let lopt =
-                                                                 bind_combinator_kind
-                                                                   env
-                                                                   m_eff_name
-                                                                   n_eff_name
-                                                                   p_eff_name
-                                                                   m_sig_ts
-                                                                   n_sig_ts
-                                                                   p_sig_ts
-                                                                   m_repr_ts
-                                                                   n_repr_ts
-                                                                   p_repr_ts
-                                                                   bind_us k1
-                                                                   num_effect_params
-                                                                   has_range_binders in
-                                                               let kind =
-                                                                 match lopt
-                                                                 with
-                                                                 | FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    (log_ad_hoc_combinator_warning
-                                                                    bind_name
-                                                                    r;
-                                                                    FStar_Syntax_Syntax.Ad_hoc_combinator)
-                                                                 | FStar_Pervasives_Native.Some
-                                                                    l ->
-                                                                    FStar_Syntax_Syntax.Substitutive_combinator
-                                                                    l in
-                                                               (let uu___8 =
-                                                                  FStar_Compiler_Effect.op_Less_Bar
-                                                                    (
-                                                                    FStar_TypeChecker_Env.debug
-                                                                    env)
-                                                                    (
-                                                                    FStar_Options.Other
-                                                                    "LayeredEffectsTc") in
-                                                                if uu___8
-                                                                then
-                                                                  let uu___9
-                                                                    =
-                                                                    FStar_Syntax_Print.indexed_effect_combinator_kind_to_string
-                                                                    kind in
-                                                                  FStar_Compiler_Util.print2
-                                                                    "Bind %s has %s kind\n"
-                                                                    bind_name
-                                                                    uu___9
-                                                                else ());
-                                                               (k1, kind))))))))
-let (subcomp_combinator_kind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.tscheme ->
-          FStar_Syntax_Syntax.tscheme ->
-            FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-              FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-                FStar_Syntax_Syntax.univ_name ->
-                  FStar_Syntax_Syntax.typ ->
-                    Prims.int ->
-                      FStar_Syntax_Syntax.indexed_effect_combinator_kind
-                        FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun m_eff_name ->
-      fun n_eff_name ->
-        fun m_sig_ts ->
-          fun n_sig_ts ->
-            fun m_repr_ts ->
-              fun n_repr_ts ->
-                fun u ->
-                  fun k ->
-                    fun num_effect_params ->
-                      let uu___ =
-                        FStar_Compiler_Effect.op_Bar_Greater k
-                          FStar_Syntax_Util.arrow_formals_comp in
-                      match uu___ with
-                      | (a_b::rest_bs, k_c) ->
-                          let uu___1 =
-                            if num_effect_params = Prims.int_zero
-                            then
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                ([], [], rest_bs)
-                                (fun uu___2 ->
-                                   FStar_Pervasives_Native.Some uu___2)
-                            else
-                              (let uu___3 =
-                                 FStar_TypeChecker_Env.inst_tscheme_with
-                                   m_sig_ts [FStar_Syntax_Syntax.U_name u] in
-                               match uu___3 with
-                               | (uu___4, sig1) ->
-                                   let uu___5 =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       sig1 FStar_Syntax_Util.arrow_formals in
-                                   (match uu___5 with
-                                    | (uu___6::sig_bs, uu___7) ->
-                                        let sig_effect_params_bs =
-                                          let uu___8 =
-                                            FStar_Compiler_List.splitAt
-                                              num_effect_params sig_bs in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___8
-                                            FStar_Pervasives_Native.fst in
-                                        let uu___8 =
-                                          FStar_Compiler_List.splitAt
-                                            num_effect_params rest_bs in
-                                        (match uu___8 with
-                                         | (eff_params_bs, rest_bs1) ->
-                                             let uu___9 =
-                                               eq_binders env
-                                                 sig_effect_params_bs
-                                                 eff_params_bs in
-                                             op_let_Question uu___9
-                                               (fun eff_params_bs_kinds ->
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    (eff_params_bs,
-                                                      eff_params_bs_kinds,
-                                                      rest_bs1)
-                                                    (fun uu___10 ->
-                                                       FStar_Pervasives_Native.Some
-                                                         uu___10))))) in
-                          op_let_Question uu___1
-                            (fun uu___2 ->
-                               match uu___2 with
-                               | (eff_params_bs, eff_params_bs_kinds,
-                                  rest_bs1) ->
-                                   let uu___3 =
-                                     let f_sig_bs =
-                                       let uu___4 =
-                                         FStar_TypeChecker_Env.inst_tscheme_with
-                                           m_sig_ts
-                                           [FStar_Syntax_Syntax.U_name u] in
-                                       match uu___4 with
-                                       | (uu___5, sig1) ->
-                                           let uu___6 =
-                                             let uu___7 =
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 sig1
-                                                 FStar_Syntax_Util.arrow_formals in
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               uu___7
-                                               FStar_Pervasives_Native.fst in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___6
-                                             (fun uu___7 ->
-                                                match uu___7 with
-                                                | a::bs ->
-                                                    let uu___8 =
-                                                      FStar_Compiler_List.splitAt
-                                                        num_effect_params bs in
-                                                    (match uu___8 with
-                                                     | (sig_bs, bs1) ->
-                                                         let ss =
-                                                           let uu___9 =
-                                                             let uu___10 =
-                                                               let uu___11 =
-                                                                 let uu___12
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                 ((a.FStar_Syntax_Syntax.binder_bv),
-                                                                   uu___12) in
-                                                               FStar_Syntax_Syntax.NT
-                                                                 uu___11 in
-                                                             [uu___10] in
-                                                           FStar_Compiler_List.fold_left2
-                                                             (fun ss1 ->
-                                                                fun sig_b ->
-                                                                  fun b ->
-                                                                    let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___13) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___12 in
-                                                                    [uu___11] in
-                                                                    FStar_Compiler_List.op_At
-                                                                    ss1
-                                                                    uu___10)
-                                                             uu___9 sig_bs
-                                                             eff_params_bs in
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           bs1
-                                                           (FStar_Syntax_Subst.subst_binders
-                                                              ss))) in
-                                     let uu___4 =
-                                       if
-                                         (FStar_Compiler_List.length rest_bs1)
-                                           <
-                                           (FStar_Compiler_List.length
-                                              f_sig_bs)
-                                       then FStar_Pervasives_Native.None
-                                       else
-                                         (let uu___6 =
-                                            FStar_Compiler_List.splitAt
-                                              (FStar_Compiler_List.length
-                                                 f_sig_bs) rest_bs1 in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___6
-                                            (fun uu___7 ->
-                                               FStar_Pervasives_Native.Some
-                                                 uu___7)) in
-                                     op_let_Question uu___4
-                                       (fun uu___5 ->
-                                          match uu___5 with
-                                          | (f_bs, rest_bs2) ->
-                                              let uu___6 =
-                                                eq_binders env f_sig_bs f_bs in
-                                              op_let_Question uu___6
-                                                (fun f_bs_kinds ->
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     (f_bs, f_bs_kinds,
-                                                       rest_bs2)
-                                                     (fun uu___7 ->
-                                                        FStar_Pervasives_Native.Some
-                                                          uu___7))) in
-                                   op_let_Question uu___3
-                                     (fun uu___4 ->
-                                        match uu___4 with
-                                        | (f_bs, f_bs_kinds, rest_bs2) ->
-                                            let uu___5 =
-                                              if
-                                                (FStar_Compiler_List.length
-                                                   rest_bs2)
-                                                  >= Prims.int_one
-                                              then
-                                                let uu___6 =
-                                                  FStar_Compiler_List.splitAt
-                                                    ((FStar_Compiler_List.length
-                                                        rest_bs2)
-                                                       - Prims.int_one)
-                                                    rest_bs2 in
-                                                match uu___6 with
-                                                | (rest_bs3, f_b::[]) ->
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      (rest_bs3, f_b)
-                                                      (fun uu___7 ->
-                                                         FStar_Pervasives_Native.Some
-                                                           uu___7)
-                                              else
-                                                FStar_Pervasives_Native.None in
-                                            op_let_Question uu___5
-                                              (fun uu___6 ->
-                                                 match uu___6 with
-                                                 | (rest_bs3, f_b) ->
-                                                     let uu___7 =
-                                                       let expected_f_b_sort
-                                                         =
-                                                         match m_repr_ts with
-                                                         | FStar_Pervasives_Native.Some
-                                                             repr_ts ->
-                                                             let uu___8 =
-                                                               FStar_TypeChecker_Env.inst_tscheme_with
-                                                                 repr_ts
-                                                                 [FStar_Syntax_Syntax.U_name
-                                                                    u] in
-                                                             (match uu___8
-                                                              with
-                                                              | (uu___9, t)
-                                                                  ->
-                                                                  let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___12
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___13
-                                                                    ->
-                                                                    match uu___13
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___14;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___15;_}
-                                                                    ->
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___16
-                                                                    FStar_Syntax_Syntax.as_arg)
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs
-                                                                    f_bs) in
-                                                                    uu___11
-                                                                    ::
-                                                                    uu___12 in
-                                                                  FStar_Syntax_Syntax.mk_Tm_app
-                                                                    t uu___10
-                                                                    FStar_Compiler_Range.dummyRange)
-                                                         | FStar_Pervasives_Native.None
-                                                             ->
-                                                             let uu___8 =
-                                                               let uu___9 =
-                                                                 FStar_Syntax_Syntax.null_binder
-                                                                   FStar_Syntax_Syntax.t_unit in
-                                                               [uu___9] in
-                                                             let uu___9 =
-                                                               let uu___10 =
-                                                                 let uu___11
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                 let uu___12
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs
-                                                                    f_bs)
-                                                                    (FStar_Compiler_List.map
-                                                                    (fun b ->
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    FStar_Syntax_Syntax.as_arg)) in
-                                                                 {
-                                                                   FStar_Syntax_Syntax.comp_univs
-                                                                    =
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u];
-                                                                   FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    m_eff_name;
-                                                                   FStar_Syntax_Syntax.result_typ
-                                                                    = uu___11;
-                                                                   FStar_Syntax_Syntax.effect_args
-                                                                    = uu___12;
-                                                                   FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                 } in
-                                                               FStar_Syntax_Syntax.mk_Comp
-                                                                 uu___10 in
-                                                             FStar_Syntax_Util.arrow
-                                                               uu___8 uu___9 in
-                                                       let uu___8 =
-                                                         let uu___9 =
-                                                           FStar_Syntax_Util.eq_tm
-                                                             (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                             expected_f_b_sort in
-                                                         uu___9 =
-                                                           FStar_Syntax_Util.Equal in
-                                                       if uu___8
-                                                       then
-                                                         FStar_Pervasives_Native.Some
-                                                           ()
-                                                       else
-                                                         FStar_Pervasives_Native.None in
-                                                     op_let_Question uu___7
-                                                       (fun _f_b_ok_ ->
-                                                          let check_ret_t
-                                                            f_or_g_bs =
-                                                            let expected_t =
-                                                              match n_repr_ts
-                                                              with
-                                                              | FStar_Pervasives_Native.Some
-                                                                  repr_ts ->
-                                                                  let uu___8
-                                                                    =
-                                                                    FStar_TypeChecker_Env.inst_tscheme_with
-                                                                    repr_ts
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u] in
-                                                                  (match uu___8
-                                                                   with
-                                                                   | 
-                                                                   (uu___9,
-                                                                    t) ->
-                                                                    let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___12
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___13
-                                                                    ->
-                                                                    match uu___13
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___14;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___15;_}
-                                                                    ->
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___16
-                                                                    FStar_Syntax_Syntax.as_arg)
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs
-                                                                    f_or_g_bs) in
-                                                                    uu___11
-                                                                    ::
-                                                                    uu___12 in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    t uu___10
-                                                                    FStar_Compiler_Range.dummyRange)
-                                                              | FStar_Pervasives_Native.None
-                                                                  ->
-                                                                  let uu___8
-                                                                    =
-                                                                    let uu___9
-                                                                    =
-                                                                    FStar_Syntax_Syntax.null_binder
-                                                                    FStar_Syntax_Syntax.t_unit in
-                                                                    [uu___9] in
-                                                                  let uu___9
-                                                                    =
-                                                                    let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs
-                                                                    f_or_g_bs)
-                                                                    (FStar_Compiler_List.map
-                                                                    (fun b ->
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    FStar_Syntax_Syntax.as_arg)) in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.comp_univs
-                                                                    =
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u];
-                                                                    FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    n_eff_name;
-                                                                    FStar_Syntax_Syntax.result_typ
-                                                                    = uu___11;
-                                                                    FStar_Syntax_Syntax.effect_args
-                                                                    = uu___12;
-                                                                    FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                    } in
-                                                                    FStar_Syntax_Syntax.mk_Comp
-                                                                    uu___10 in
-                                                                  FStar_Syntax_Util.arrow
-                                                                    uu___8
-                                                                    uu___9 in
-                                                            let uu___8 =
-                                                              let uu___9 =
-                                                                FStar_Syntax_Util.eq_tm
-                                                                  (FStar_Syntax_Util.comp_result
-                                                                    k_c)
-                                                                  expected_t in
-                                                              uu___9 =
-                                                                FStar_Syntax_Util.Equal in
-                                                            if uu___8
-                                                            then
-                                                              FStar_Pervasives_Native.Some
-                                                                ()
-                                                            else
-                                                              FStar_Pervasives_Native.None in
-                                                          let uu___8 =
-                                                            let uu___9 =
-                                                              check_ret_t
-                                                                f_bs in
-                                                            FStar_Pervasives_Native.uu___is_Some
-                                                              uu___9 in
-                                                          if uu___8
-                                                          then
-                                                            FStar_Pervasives_Native.Some
-                                                              FStar_Syntax_Syntax.Substitutive_invariant_combinator
-                                                          else
-                                                            (let uu___10 =
-                                                               let g_sig_bs =
-                                                                 let uu___11
-                                                                   =
-                                                                   FStar_TypeChecker_Env.inst_tscheme_with
-                                                                    n_sig_ts
-                                                                    [
-                                                                    FStar_Syntax_Syntax.U_name
-                                                                    u] in
-                                                                 match uu___11
-                                                                 with
-                                                                 | (uu___12,
-                                                                    sig1) ->
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    sig1
-                                                                    FStar_Syntax_Util.arrow_formals in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___14
-                                                                    FStar_Pervasives_Native.fst in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    match uu___14
-                                                                    with
-                                                                    | 
-                                                                    a::bs ->
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    num_effect_params
-                                                                    bs in
-                                                                    (match uu___15
-                                                                    with
-                                                                    | 
-                                                                    (sig_bs,
-                                                                    bs1) ->
-                                                                    let ss =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((a.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___19) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___18 in
-                                                                    [uu___17] in
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun ss1
-                                                                    ->
-                                                                    fun sig_b
-                                                                    ->
-                                                                    fun b ->
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___20) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___19 in
-                                                                    [uu___18] in
-                                                                    FStar_Compiler_List.op_At
-                                                                    ss1
-                                                                    uu___17)
-                                                                    uu___16
-                                                                    sig_bs
-                                                                    eff_params_bs in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (FStar_Syntax_Subst.subst_binders
-                                                                    ss))) in
-                                                               let uu___11 =
-                                                                 if
-                                                                   (FStar_Compiler_List.length
-                                                                    rest_bs3)
-                                                                    <
-                                                                    (FStar_Compiler_List.length
-                                                                    g_sig_bs)
-                                                                 then
-                                                                   FStar_Pervasives_Native.None
-                                                                 else
-                                                                   (let uu___13
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    (FStar_Compiler_List.length
-                                                                    g_sig_bs)
-                                                                    rest_bs3 in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___14)) in
-                                                               op_let_Question
-                                                                 uu___11
-                                                                 (fun uu___12
-                                                                    ->
-                                                                    match uu___12
-                                                                    with
-                                                                    | 
-                                                                    (g_bs,
-                                                                    rest_bs4)
-                                                                    ->
-                                                                    let uu___13
-                                                                    =
-                                                                    eq_binders
-                                                                    env
-                                                                    g_sig_bs
-                                                                    g_bs in
-                                                                    op_let_Question
-                                                                    uu___13
-                                                                    (fun
-                                                                    g_bs_kinds
-                                                                    ->
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (g_bs,
-                                                                    g_bs_kinds,
-                                                                    rest_bs4)
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___14))) in
-                                                             op_let_Question
-                                                               uu___10
-                                                               (fun uu___11
-                                                                  ->
-                                                                  match uu___11
-                                                                  with
-                                                                  | (g_bs,
-                                                                    g_bs_kinds,
-                                                                    rest_bs4)
-                                                                    ->
-                                                                    let uu___12
-                                                                    =
-                                                                    check_ret_t
-                                                                    g_bs in
-                                                                    op_let_Question
-                                                                    uu___12
-                                                                    (fun
-                                                                    _ret_t_ok_
-                                                                    ->
-                                                                    let rest_kinds
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___13
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Ad_hoc_binder)
-                                                                    rest_bs4 in
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Compiler_List.op_At
-                                                                    [FStar_Syntax_Syntax.Type_binder]
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    f_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    g_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    rest_kinds
-                                                                    [FStar_Syntax_Syntax.Repr_binder])))))
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Substitutive_combinator
-                                                                    uu___14) in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___13)))))))
-let (validate_indexed_effect_subcomp_shape :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.tscheme ->
-          FStar_Syntax_Syntax.tscheme ->
-            FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-              FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-                FStar_Syntax_Syntax.univ_name ->
-                  FStar_Syntax_Syntax.typ ->
-                    Prims.int ->
-                      FStar_Compiler_Range.range ->
-                        (FStar_Syntax_Syntax.typ *
-                          FStar_Syntax_Syntax.indexed_effect_combinator_kind))
-  =
-  fun env ->
-    fun m_eff_name ->
-      fun n_eff_name ->
-        fun m_sig_ts ->
-          fun n_sig_ts ->
-            fun m_repr_ts ->
-              fun n_repr_ts ->
-                fun u ->
-                  fun subcomp_t ->
-                    fun num_effect_params ->
-                      fun r ->
-                        let subcomp_name =
-                          let uu___ = FStar_Ident.string_of_lid m_eff_name in
-                          let uu___1 = FStar_Ident.string_of_lid n_eff_name in
-                          FStar_Compiler_Util.format2 "%s <: %s" uu___ uu___1 in
-                        let a_b =
-                          let uu___ =
-                            let uu___1 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                (FStar_Syntax_Syntax.U_name u)
-                                FStar_Syntax_Util.type_with_u in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___1
-                              (FStar_Syntax_Syntax.gen_bv "a"
-                                 FStar_Pervasives_Native.None) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___
-                            FStar_Syntax_Syntax.mk_binder in
-                        let rest_bs =
-                          let uu___ =
-                            let uu___1 =
-                              FStar_Syntax_Subst.compress subcomp_t in
-                            uu___1.FStar_Syntax_Syntax.n in
-                          match uu___ with
-                          | FStar_Syntax_Syntax.Tm_arrow (bs, uu___1) when
-                              (FStar_Compiler_List.length bs) >=
-                                (Prims.of_int (2))
-                              ->
-                              let uu___2 = FStar_Syntax_Subst.open_binders bs in
-                              (match uu___2 with
-                               | { FStar_Syntax_Syntax.binder_bv = a;
-                                   FStar_Syntax_Syntax.binder_qual = uu___3;
-                                   FStar_Syntax_Syntax.binder_attrs = uu___4;_}::bs1
-                                   ->
-                                   let uu___5 =
-                                     let uu___6 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         bs1
-                                         (FStar_Compiler_List.splitAt
-                                            ((FStar_Compiler_List.length bs1)
-                                               - Prims.int_one)) in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___6 FStar_Pervasives_Native.fst in
-                                   let uu___6 =
-                                     let uu___7 =
-                                       let uu___8 =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Syntax_Syntax.bv_to_name
-                                               a_b.FStar_Syntax_Syntax.binder_bv in
-                                           (a, uu___10) in
-                                         FStar_Syntax_Syntax.NT uu___9 in
-                                       [uu___8] in
-                                     FStar_Syntax_Subst.subst_binders uu___7 in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___5 uu___6)
-                          | uu___1 ->
-                              let uu___2 =
-                                let uu___3 =
-                                  let uu___4 =
-                                    FStar_Syntax_Print.term_to_string
-                                      subcomp_t in
-                                  FStar_Compiler_Util.format2
-                                    "Type of %s is not an arrow with >= 2 binders (%s)"
-                                    subcomp_name uu___4 in
-                                (FStar_Errors.Fatal_UnexpectedEffect, uu___3) in
-                              FStar_Errors.raise_error uu___2 r in
-                        let uu___ =
-                          let uu___1 =
-                            let uu___2 =
-                              FStar_TypeChecker_Env.push_binders env (a_b ::
-                                rest_bs) in
-                            let uu___3 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                a_b.FStar_Syntax_Syntax.binder_bv
-                                FStar_Syntax_Syntax.bv_to_name in
-                            FStar_TypeChecker_Util.fresh_effect_repr uu___2 r
-                              m_eff_name m_sig_ts m_repr_ts
-                              (FStar_Syntax_Syntax.U_name u) uu___3 in
-                          match uu___1 with
-                          | (repr, g) ->
-                              let uu___2 =
-                                let uu___3 =
-                                  FStar_Compiler_Effect.op_Bar_Greater repr
-                                    (FStar_Syntax_Syntax.gen_bv "f"
-                                       FStar_Pervasives_Native.None) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                  FStar_Syntax_Syntax.mk_binder in
-                              (uu___2, g) in
-                        match uu___ with
-                        | (f, guard_f) ->
-                            let uu___1 =
-                              let uu___2 =
-                                FStar_TypeChecker_Env.push_binders env (a_b
-                                  :: rest_bs) in
-                              let uu___3 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  a_b.FStar_Syntax_Syntax.binder_bv
-                                  FStar_Syntax_Syntax.bv_to_name in
-                              FStar_TypeChecker_Util.fresh_effect_repr uu___2
-                                r n_eff_name n_sig_ts n_repr_ts
-                                (FStar_Syntax_Syntax.U_name u) uu___3 in
-                            (match uu___1 with
-                             | (ret_t, guard_ret_t) ->
-                                 let uu___2 =
-                                   let uu___3 =
-                                     FStar_TypeChecker_Env.push_binders env
-                                       (a_b :: rest_bs) in
-                                   let uu___4 =
-                                     FStar_Compiler_Util.format1
-                                       "implicit for pure_wp in checking %s"
-                                       subcomp_name in
-                                   pure_wp_uvar uu___3 ret_t uu___4 r in
-                                 (match uu___2 with
-                                  | (pure_wp_uvar1, guard_wp) ->
-                                      let c =
-                                        let uu___3 =
-                                          let uu___4 =
-                                            let uu___5 =
-                                              FStar_TypeChecker_Env.new_u_univ
-                                                () in
-                                            [uu___5] in
-                                          let uu___5 =
-                                            let uu___6 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                pure_wp_uvar1
-                                                FStar_Syntax_Syntax.as_arg in
-                                            [uu___6] in
-                                          {
-                                            FStar_Syntax_Syntax.comp_univs =
-                                              uu___4;
-                                            FStar_Syntax_Syntax.effect_name =
-                                              FStar_Parser_Const.effect_PURE_lid;
-                                            FStar_Syntax_Syntax.result_typ =
-                                              ret_t;
-                                            FStar_Syntax_Syntax.effect_args =
-                                              uu___5;
-                                            FStar_Syntax_Syntax.flags = []
-                                          } in
-                                        FStar_Syntax_Syntax.mk_Comp uu___3 in
-                                      let k =
-                                        FStar_Syntax_Util.arrow
-                                          (FStar_Compiler_List.op_At (a_b ::
-                                             rest_bs) [f]) c in
-                                      ((let uu___4 =
-                                          FStar_Compiler_Effect.op_Less_Bar
-                                            (FStar_TypeChecker_Env.debug env)
-                                            (FStar_Options.Other
-                                               "LayeredEffectsTc") in
-                                        if uu___4
-                                        then
-                                          let uu___5 =
-                                            FStar_Syntax_Print.term_to_string
-                                              k in
-                                          FStar_Compiler_Util.print1
-                                            "Expected type of subcomp before unification: %s\n"
-                                            uu___5
-                                        else ());
-                                       (let guard_eq =
-                                          let uu___4 =
-                                            FStar_TypeChecker_Rel.teq_nosmt
-                                              env subcomp_t k in
-                                          match uu___4 with
-                                          | FStar_Pervasives_Native.None ->
-                                              let uu___5 =
-                                                let uu___6 =
-                                                  let uu___7 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      subcomp_t in
-                                                  FStar_Compiler_Util.format2
-                                                    "Unexpected type of %s (%s)\n"
-                                                    subcomp_name uu___7 in
-                                                (FStar_Errors.Fatal_UnexpectedEffect,
-                                                  uu___6) in
-                                              FStar_Errors.raise_error uu___5
-                                                r
-                                          | FStar_Pervasives_Native.Some g ->
-                                              g in
-                                        (let uu___5 =
-                                           FStar_TypeChecker_Env.conj_guards
-                                             [guard_f;
-                                             guard_ret_t;
-                                             guard_wp;
-                                             guard_eq] in
-                                         FStar_TypeChecker_Rel.force_trivial_guard
-                                           env uu___5);
-                                        (let k1 =
-                                           let uu___5 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               k
-                                               (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                                  env) in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___5
-                                             FStar_Syntax_Subst.compress in
-                                         let kopt =
-                                           subcomp_combinator_kind env
-                                             m_eff_name n_eff_name m_sig_ts
-                                             n_sig_ts m_repr_ts n_repr_ts u
-                                             k1 num_effect_params in
-                                         let kind =
-                                           match kopt with
-                                           | FStar_Pervasives_Native.None ->
-                                               (log_ad_hoc_combinator_warning
-                                                  subcomp_name r;
-                                                FStar_Syntax_Syntax.Ad_hoc_combinator)
-                                           | FStar_Pervasives_Native.Some k2
-                                               -> k2 in
-                                         (let uu___6 =
-                                            FStar_Compiler_Effect.op_Less_Bar
-                                              (FStar_TypeChecker_Env.debug
-                                                 env)
-                                              (FStar_Options.Other
-                                                 "LayeredEffectsTc") in
-                                          if uu___6
-                                          then
-                                            let uu___7 =
-                                              FStar_Syntax_Print.indexed_effect_combinator_kind_to_string
-                                                kind in
-                                            FStar_Compiler_Util.print2
-                                              "Subcomp %s has %s kind\n"
-                                              subcomp_name uu___7
-                                          else ());
-                                         (k1, kind))))))
-let (ite_combinator_kind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.tscheme ->
-        FStar_Syntax_Syntax.tscheme ->
-          FStar_Syntax_Syntax.univ_name ->
-            FStar_Syntax_Syntax.term ->
-              Prims.int ->
-                FStar_Syntax_Syntax.indexed_effect_combinator_kind
-                  FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun eff_name ->
-      fun sig_ts ->
-        fun repr_ts ->
-          fun u ->
-            fun tm ->
-              fun num_effect_params ->
-                let uu___ = FStar_Syntax_Util.abs_formals tm in
-                match uu___ with
-                | (a_b::rest_bs, uu___1, uu___2) ->
-                    let uu___3 =
-                      if num_effect_params = Prims.int_zero
-                      then
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          ([], [], rest_bs)
-                          (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)
-                      else
-                        (let uu___5 =
-                           FStar_TypeChecker_Env.inst_tscheme_with sig_ts
-                             [FStar_Syntax_Syntax.U_name u] in
-                         match uu___5 with
-                         | (uu___6, sig1) ->
-                             let uu___7 =
-                               FStar_Compiler_Effect.op_Bar_Greater sig1
-                                 FStar_Syntax_Util.arrow_formals in
-                             (match uu___7 with
-                              | (uu___8::sig_bs, uu___9) ->
-                                  let sig_effect_params_bs =
-                                    let uu___10 =
-                                      FStar_Compiler_List.splitAt
-                                        num_effect_params sig_bs in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___10 FStar_Pervasives_Native.fst in
-                                  let uu___10 =
-                                    FStar_Compiler_List.splitAt
-                                      num_effect_params rest_bs in
-                                  (match uu___10 with
-                                   | (eff_params_bs, rest_bs1) ->
-                                       let uu___11 =
-                                         eq_binders env sig_effect_params_bs
-                                           eff_params_bs in
-                                       op_let_Question uu___11
-                                         (fun eff_params_bs_kinds ->
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              (eff_params_bs,
-                                                eff_params_bs_kinds,
-                                                rest_bs1)
-                                              (fun uu___12 ->
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___12))))) in
-                    op_let_Question uu___3
-                      (fun uu___4 ->
-                         match uu___4 with
-                         | (eff_params_bs, eff_params_bs_kinds, rest_bs1) ->
-                             let uu___5 =
-                               let f_sig_bs =
-                                 let uu___6 =
-                                   FStar_TypeChecker_Env.inst_tscheme_with
-                                     sig_ts [FStar_Syntax_Syntax.U_name u] in
-                                 match uu___6 with
-                                 | (uu___7, sig1) ->
-                                     let uu___8 =
-                                       let uu___9 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           sig1
-                                           FStar_Syntax_Util.arrow_formals in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___9 FStar_Pervasives_Native.fst in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___8
-                                       (fun uu___9 ->
-                                          match uu___9 with
-                                          | a::bs ->
-                                              let uu___10 =
-                                                FStar_Compiler_List.splitAt
-                                                  num_effect_params bs in
-                                              (match uu___10 with
-                                               | (sig_bs, bs1) ->
-                                                   let ss =
-                                                     let uu___11 =
-                                                       let uu___12 =
-                                                         let uu___13 =
-                                                           let uu___14 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               a_b.FStar_Syntax_Syntax.binder_bv
-                                                               FStar_Syntax_Syntax.bv_to_name in
-                                                           ((a.FStar_Syntax_Syntax.binder_bv),
-                                                             uu___14) in
-                                                         FStar_Syntax_Syntax.NT
-                                                           uu___13 in
-                                                       [uu___12] in
-                                                     FStar_Compiler_List.fold_left2
-                                                       (fun ss1 ->
-                                                          fun sig_b ->
-                                                            fun b ->
-                                                              let uu___12 =
-                                                                let uu___13 =
-                                                                  let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___15) in
-                                                                  FStar_Syntax_Syntax.NT
-                                                                    uu___14 in
-                                                                [uu___13] in
-                                                              FStar_Compiler_List.op_At
-                                                                ss1 uu___12)
-                                                       uu___11 sig_bs
-                                                       eff_params_bs in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     bs1
-                                                     (FStar_Syntax_Subst.subst_binders
-                                                        ss))) in
-                               let uu___6 =
-                                 if
-                                   (FStar_Compiler_List.length rest_bs1) <
-                                     (FStar_Compiler_List.length f_sig_bs)
-                                 then FStar_Pervasives_Native.None
-                                 else
-                                   (let uu___8 =
-                                      FStar_Compiler_List.splitAt
-                                        (FStar_Compiler_List.length f_sig_bs)
-                                        rest_bs1 in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___8
-                                      (fun uu___9 ->
-                                         FStar_Pervasives_Native.Some uu___9)) in
-                               op_let_Question uu___6
-                                 (fun uu___7 ->
-                                    match uu___7 with
-                                    | (f_bs, rest_bs2) ->
-                                        let uu___8 =
-                                          eq_binders env f_sig_bs f_bs in
-                                        op_let_Question uu___8
-                                          (fun f_bs_kinds ->
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               (f_bs, f_bs_kinds, rest_bs2)
-                                               (fun uu___9 ->
-                                                  FStar_Pervasives_Native.Some
-                                                    uu___9))) in
-                             op_let_Question uu___5
-                               (fun uu___6 ->
-                                  match uu___6 with
-                                  | (f_bs, f_bs_kinds, rest_bs2) ->
-                                      let uu___7 =
-                                        if
-                                          (FStar_Compiler_List.length
-                                             rest_bs2)
-                                            >= (Prims.of_int (3))
-                                        then
-                                          let uu___8 =
-                                            FStar_Compiler_List.splitAt
-                                              ((FStar_Compiler_List.length
-                                                  rest_bs2)
-                                                 - (Prims.of_int (3)))
-                                              rest_bs2 in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___8
-                                            (fun uu___9 ->
-                                               FStar_Pervasives_Native.Some
-                                                 uu___9)
-                                        else FStar_Pervasives_Native.None in
-                                      op_let_Question uu___7
-                                        (fun uu___8 ->
-                                           match uu___8 with
-                                           | (rest_bs3, f_b::g_b::p_b::[]) ->
-                                               let uu___9 =
-                                                 let expected_f_b_sort =
-                                                   let uu___10 =
-                                                     FStar_TypeChecker_Env.inst_tscheme_with
-                                                       repr_ts
-                                                       [FStar_Syntax_Syntax.U_name
-                                                          u] in
-                                                   match uu___10 with
-                                                   | (uu___11, t) ->
-                                                       let uu___12 =
-                                                         let uu___13 =
-                                                           let uu___14 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               a_b.FStar_Syntax_Syntax.binder_bv
-                                                               FStar_Syntax_Syntax.bv_to_name in
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uu___14
-                                                             FStar_Syntax_Syntax.as_arg in
-                                                         let uu___14 =
-                                                           FStar_Compiler_List.map
-                                                             (fun uu___15 ->
-                                                                match uu___15
-                                                                with
-                                                                | {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___16;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___17;_}
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___18
-                                                                    FStar_Syntax_Syntax.as_arg)
-                                                             (FStar_Compiler_List.op_At
-                                                                eff_params_bs
-                                                                f_bs) in
-                                                         uu___13 :: uu___14 in
-                                                       FStar_Syntax_Syntax.mk_Tm_app
-                                                         t uu___12
-                                                         FStar_Compiler_Range.dummyRange in
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     FStar_Syntax_Util.eq_tm
-                                                       (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                       expected_f_b_sort in
-                                                   uu___11 =
-                                                     FStar_Syntax_Util.Equal in
-                                                 if uu___10
-                                                 then
-                                                   FStar_Pervasives_Native.Some
-                                                     ()
-                                                 else
-                                                   FStar_Pervasives_Native.None in
-                                               op_let_Question uu___9
-                                                 (fun _f_b_ok_ ->
-                                                    let check_g_b f_or_g_bs =
-                                                      let expected_g_b_sort =
-                                                        let uu___10 =
-                                                          FStar_TypeChecker_Env.inst_tscheme_with
-                                                            repr_ts
-                                                            [FStar_Syntax_Syntax.U_name
-                                                               u] in
-                                                        match uu___10 with
-                                                        | (uu___11, t) ->
-                                                            let uu___12 =
-                                                              let uu___13 =
-                                                                let uu___14 =
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  uu___14
-                                                                  FStar_Syntax_Syntax.as_arg in
-                                                              let uu___14 =
-                                                                FStar_Compiler_List.map
-                                                                  (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    match uu___15
-                                                                    with
-                                                                    | 
-                                                                    {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = b;
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___16;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___17;_}
-                                                                    ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___18
-                                                                    FStar_Syntax_Syntax.as_arg)
-                                                                  (FStar_Compiler_List.op_At
-                                                                    eff_params_bs
-                                                                    f_or_g_bs) in
-                                                              uu___13 ::
-                                                                uu___14 in
-                                                            FStar_Syntax_Syntax.mk_Tm_app
-                                                              t uu___12
-                                                              FStar_Compiler_Range.dummyRange in
-                                                      let uu___10 =
-                                                        let uu___11 =
-                                                          FStar_Syntax_Util.eq_tm
-                                                            (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                            expected_g_b_sort in
-                                                        uu___11 =
-                                                          FStar_Syntax_Util.Equal in
-                                                      if uu___10
-                                                      then
-                                                        FStar_Pervasives_Native.Some
-                                                          ()
-                                                      else
-                                                        FStar_Pervasives_Native.None in
-                                                    let uu___10 =
-                                                      let uu___11 =
-                                                        check_g_b f_bs in
-                                                      FStar_Pervasives_Native.uu___is_Some
-                                                        uu___11 in
-                                                    if uu___10
-                                                    then
-                                                      FStar_Pervasives_Native.Some
-                                                        FStar_Syntax_Syntax.Substitutive_invariant_combinator
-                                                    else
-                                                      (let uu___12 =
-                                                         let g_sig_bs =
-                                                           let uu___13 =
-                                                             FStar_TypeChecker_Env.inst_tscheme_with
-                                                               sig_ts
-                                                               [FStar_Syntax_Syntax.U_name
-                                                                  u] in
-                                                           match uu___13 with
-                                                           | (uu___14, sig1)
-                                                               ->
-                                                               let uu___15 =
-                                                                 let uu___16
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    sig1
-                                                                    FStar_Syntax_Util.arrow_formals in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___16
-                                                                   FStar_Pervasives_Native.fst in
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 uu___15
-                                                                 (fun uu___16
-                                                                    ->
-                                                                    match uu___16
-                                                                    with
-                                                                    | 
-                                                                    a::bs ->
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    num_effect_params
-                                                                    bs in
-                                                                    (match uu___17
-                                                                    with
-                                                                    | 
-                                                                    (sig_bs,
-                                                                    bs1) ->
-                                                                    let ss =
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((a.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___21) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___20 in
-                                                                    [uu___19] in
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun ss1
-                                                                    ->
-                                                                    fun sig_b
-                                                                    ->
-                                                                    fun b ->
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    b.FStar_Syntax_Syntax.binder_bv
-                                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                                    ((sig_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___22) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___21 in
-                                                                    [uu___20] in
-                                                                    FStar_Compiler_List.op_At
-                                                                    ss1
-                                                                    uu___19)
-                                                                    uu___18
-                                                                    sig_bs
-                                                                    eff_params_bs in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (FStar_Syntax_Subst.subst_binders
-                                                                    ss))) in
-                                                         let uu___13 =
-                                                           if
-                                                             (FStar_Compiler_List.length
-                                                                rest_bs3)
-                                                               <
-                                                               (FStar_Compiler_List.length
-                                                                  g_sig_bs)
-                                                           then
-                                                             FStar_Pervasives_Native.None
-                                                           else
-                                                             (let uu___15 =
-                                                                FStar_Compiler_List.splitAt
-                                                                  (FStar_Compiler_List.length
-                                                                    g_sig_bs)
-                                                                  rest_bs3 in
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                uu___15
-                                                                (fun uu___16
-                                                                   ->
-                                                                   FStar_Pervasives_Native.Some
-                                                                    uu___16)) in
-                                                         op_let_Question
-                                                           uu___13
-                                                           (fun uu___14 ->
-                                                              match uu___14
-                                                              with
-                                                              | (g_bs,
-                                                                 rest_bs4) ->
-                                                                  let uu___15
-                                                                    =
-                                                                    eq_binders
-                                                                    env
-                                                                    g_sig_bs
-                                                                    g_bs in
-                                                                  op_let_Question
-                                                                    uu___15
-                                                                    (
-                                                                    fun
-                                                                    g_bs_kinds
-                                                                    ->
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (g_bs,
-                                                                    g_bs_kinds,
-                                                                    rest_bs4)
-                                                                    (fun
-                                                                    uu___16
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___16))) in
-                                                       op_let_Question
-                                                         uu___12
-                                                         (fun uu___13 ->
-                                                            match uu___13
-                                                            with
-                                                            | (g_bs,
-                                                               g_bs_kinds,
-                                                               rest_bs4) ->
-                                                                let uu___14 =
-                                                                  check_g_b
-                                                                    g_bs in
-                                                                op_let_Question
-                                                                  uu___14
-                                                                  (fun
-                                                                    _g_b_ok_
-                                                                    ->
-                                                                    let rest_kinds
-                                                                    =
-                                                                    FStar_Compiler_List.map
-                                                                    (fun
-                                                                    uu___15
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Ad_hoc_binder)
-                                                                    rest_bs4 in
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Compiler_List.op_At
-                                                                    [FStar_Syntax_Syntax.Type_binder]
-                                                                    (FStar_Compiler_List.op_At
-                                                                    eff_params_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    f_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    g_bs_kinds
-                                                                    (FStar_Compiler_List.op_At
-                                                                    rest_kinds
-                                                                    [FStar_Syntax_Syntax.Repr_binder;
-                                                                    FStar_Syntax_Syntax.Repr_binder;
-                                                                    FStar_Syntax_Syntax.Substitutive_binder])))))
-                                                                    (fun
-                                                                    uu___16
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Substitutive_combinator
-                                                                    uu___16) in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___15)))))))
-let (validate_indexed_effect_ite_shape :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.tscheme ->
-        FStar_Syntax_Syntax.tscheme ->
-          FStar_Syntax_Syntax.univ_name ->
-            FStar_Syntax_Syntax.typ ->
-              FStar_Syntax_Syntax.term ->
-                Prims.int ->
-                  FStar_Compiler_Range.range ->
-                    (FStar_Syntax_Syntax.term *
-                      FStar_Syntax_Syntax.indexed_effect_combinator_kind))
-  =
-  fun env ->
-    fun eff_name ->
-      fun sig_ts ->
-        fun repr_ts ->
-          fun u ->
-            fun ite_ty ->
-              fun ite_tm ->
-                fun num_effect_params ->
-                  fun r ->
-                    let ite_name =
-                      let uu___ = FStar_Ident.string_of_lid eff_name in
-                      FStar_Compiler_Util.format1 "ite_%s" uu___ in
-                    let a_b =
-                      let uu___ =
-                        let uu___1 =
-                          let uu___2 =
-                            FStar_Compiler_Effect.op_Bar_Greater u
-                              (fun uu___3 ->
-                                 FStar_Syntax_Syntax.U_name uu___3) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___2
-                            FStar_Syntax_Util.type_with_u in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___1
-                          (FStar_Syntax_Syntax.gen_bv "a"
-                             FStar_Pervasives_Native.None) in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___
-                        FStar_Syntax_Syntax.mk_binder in
-                    let rest_bs =
-                      let uu___ =
-                        let uu___1 = FStar_Syntax_Subst.compress ite_ty in
-                        uu___1.FStar_Syntax_Syntax.n in
-                      match uu___ with
-                      | FStar_Syntax_Syntax.Tm_arrow (bs, uu___1) when
-                          (FStar_Compiler_List.length bs) >=
-                            (Prims.of_int (4))
-                          ->
-                          let uu___2 = FStar_Syntax_Subst.open_binders bs in
-                          (match uu___2 with
-                           | { FStar_Syntax_Syntax.binder_bv = a;
-                               FStar_Syntax_Syntax.binder_qual = uu___3;
-                               FStar_Syntax_Syntax.binder_attrs = uu___4;_}::bs1
-                               ->
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Compiler_Effect.op_Bar_Greater bs1
-                                     (FStar_Compiler_List.splitAt
-                                        ((FStar_Compiler_List.length bs1) -
-                                           (Prims.of_int (3)))) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                   FStar_Pervasives_Native.fst in
-                               let uu___6 =
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       let uu___10 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           a_b.FStar_Syntax_Syntax.binder_bv
-                                           FStar_Syntax_Syntax.bv_to_name in
-                                       (a, uu___10) in
-                                     FStar_Syntax_Syntax.NT uu___9 in
-                                   [uu___8] in
-                                 FStar_Syntax_Subst.subst_binders uu___7 in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                 uu___6)
-                      | uu___1 ->
-                          let uu___2 =
-                            let uu___3 =
-                              let uu___4 =
-                                FStar_Syntax_Print.term_to_string ite_ty in
-                              FStar_Compiler_Util.format2
-                                "Type of %s is not an arrow with >= 4 binders (%s)"
-                                ite_name uu___4 in
-                            (FStar_Errors.Fatal_UnexpectedEffect, uu___3) in
-                          FStar_Errors.raise_error uu___2 r in
-                    let uu___ =
-                      let uu___1 =
-                        let uu___2 =
-                          FStar_TypeChecker_Env.push_binders env (a_b ::
-                            rest_bs) in
-                        let uu___3 =
-                          FStar_Compiler_Effect.op_Bar_Greater
-                            a_b.FStar_Syntax_Syntax.binder_bv
-                            FStar_Syntax_Syntax.bv_to_name in
-                        FStar_TypeChecker_Util.fresh_effect_repr uu___2 r
-                          eff_name sig_ts
-                          (FStar_Pervasives_Native.Some repr_ts)
-                          (FStar_Syntax_Syntax.U_name u) uu___3 in
-                      match uu___1 with
-                      | (repr, g) ->
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_Compiler_Effect.op_Bar_Greater repr
-                                (FStar_Syntax_Syntax.gen_bv "f"
-                                   FStar_Pervasives_Native.None) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___3
-                              FStar_Syntax_Syntax.mk_binder in
-                          (uu___2, g) in
-                    match uu___ with
-                    | (f, guard_f) ->
-                        let uu___1 =
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_TypeChecker_Env.push_binders env (a_b ::
-                                rest_bs) in
-                            let uu___4 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                a_b.FStar_Syntax_Syntax.binder_bv
-                                FStar_Syntax_Syntax.bv_to_name in
-                            FStar_TypeChecker_Util.fresh_effect_repr uu___3 r
-                              eff_name sig_ts
-                              (FStar_Pervasives_Native.Some repr_ts)
-                              (FStar_Syntax_Syntax.U_name u) uu___4 in
-                          match uu___2 with
-                          | (repr, g) ->
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Compiler_Effect.op_Bar_Greater repr
-                                    (FStar_Syntax_Syntax.gen_bv "g"
-                                       FStar_Pervasives_Native.None) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                                  FStar_Syntax_Syntax.mk_binder in
-                              (uu___3, g) in
-                        (match uu___1 with
-                         | (g, guard_g) ->
-                             let p =
-                               let uu___2 =
-                                 FStar_Syntax_Syntax.gen_bv "p"
-                                   FStar_Pervasives_Native.None
-                                   FStar_Syntax_Util.t_bool in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                                 FStar_Syntax_Syntax.mk_binder in
-                             let uu___2 =
-                               let uu___3 =
-                                 FStar_TypeChecker_Env.push_binders env
-                                   (FStar_Compiler_List.op_At (a_b ::
-                                      rest_bs) [p]) in
-                               let uu___4 =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   a_b.FStar_Syntax_Syntax.binder_bv
-                                   FStar_Syntax_Syntax.bv_to_name in
-                               FStar_TypeChecker_Util.fresh_effect_repr
-                                 uu___3 r eff_name sig_ts
-                                 (FStar_Pervasives_Native.Some repr_ts)
-                                 (FStar_Syntax_Syntax.U_name u) uu___4 in
-                             (match uu___2 with
-                              | (body_tm, guard_body) ->
-                                  let k =
-                                    FStar_Syntax_Util.abs
-                                      (FStar_Compiler_List.op_At (a_b ::
-                                         rest_bs) [f; g; p]) body_tm
-                                      FStar_Pervasives_Native.None in
-                                  let guard_eq =
-                                    let uu___3 =
-                                      FStar_TypeChecker_Rel.teq_nosmt env
-                                        ite_tm k in
-                                    match uu___3 with
-                                    | FStar_Pervasives_Native.None ->
-                                        let uu___4 =
-                                          let uu___5 =
-                                            let uu___6 =
-                                              FStar_Syntax_Print.term_to_string
-                                                ite_tm in
-                                            FStar_Compiler_Util.format2
-                                              "Unexpected term for %s (%s)\n"
-                                              ite_name uu___6 in
-                                          (FStar_Errors.Fatal_UnexpectedEffect,
-                                            uu___5) in
-                                        FStar_Errors.raise_error uu___4 r
-                                    | FStar_Pervasives_Native.Some g1 -> g1 in
-                                  ((let uu___4 =
-                                      FStar_TypeChecker_Env.conj_guards
-                                        [guard_f;
-                                        guard_g;
-                                        guard_body;
-                                        guard_eq] in
-                                    FStar_TypeChecker_Rel.force_trivial_guard
-                                      env uu___4);
-                                   (let k1 =
-                                      let uu___4 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          k
-                                          (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                             env) in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___4 FStar_Syntax_Subst.compress in
-                                    let kopt =
-                                      ite_combinator_kind env eff_name sig_ts
-                                        repr_ts u k1 num_effect_params in
-                                    let kind =
-                                      match kopt with
-                                      | FStar_Pervasives_Native.None ->
-                                          (log_ad_hoc_combinator_warning
-                                             ite_name r;
-                                           FStar_Syntax_Syntax.Ad_hoc_combinator)
-                                      | FStar_Pervasives_Native.Some k2 -> k2 in
-                                    (let uu___5 =
-                                       FStar_Compiler_Effect.op_Less_Bar
-                                         (FStar_TypeChecker_Env.debug env)
-                                         (FStar_Options.Other
-                                            "LayeredEffectsTc") in
-                                     if uu___5
-                                     then
-                                       let uu___6 =
-                                         FStar_Syntax_Print.indexed_effect_combinator_kind_to_string
-                                           kind in
-                                       FStar_Compiler_Util.print2
-                                         "Ite %s has %s kind\n" ite_name
-                                         uu___6
-                                     else ());
-                                    (k1, kind)))))
-let (lift_combinator_kind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.tscheme ->
-        FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-          FStar_Syntax_Syntax.univ_name ->
-            FStar_Syntax_Syntax.typ ->
-              FStar_Syntax_Syntax.indexed_effect_binder_kind Prims.list
-                FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun m_eff_name ->
-      fun m_sig_ts ->
-        fun m_repr_ts ->
-          fun u ->
-            fun k ->
-              let uu___ = FStar_Syntax_Util.arrow_formals k in
-              match uu___ with
-              | (a_b::rest_bs, uu___1) ->
-                  let uu___2 =
-                    let f_sig_bs =
-                      let uu___3 =
-                        FStar_TypeChecker_Env.inst_tscheme_with m_sig_ts
-                          [FStar_Syntax_Syntax.U_name u] in
-                      match uu___3 with
-                      | (uu___4, sig1) ->
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_Compiler_Effect.op_Bar_Greater sig1
-                                FStar_Syntax_Util.arrow_formals in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___6
-                              FStar_Pervasives_Native.fst in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___5
-                            (fun uu___6 ->
-                               match uu___6 with
-                               | a::bs ->
-                                   let uu___7 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         let uu___10 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             a_b.FStar_Syntax_Syntax.binder_bv
-                                             FStar_Syntax_Syntax.bv_to_name in
-                                         ((a.FStar_Syntax_Syntax.binder_bv),
-                                           uu___10) in
-                                       FStar_Syntax_Syntax.NT uu___9 in
-                                     [uu___8] in
-                                   FStar_Syntax_Subst.subst_binders uu___7 bs) in
-                    let uu___3 =
-                      if
-                        (FStar_Compiler_List.length rest_bs) <
-                          (FStar_Compiler_List.length f_sig_bs)
-                      then FStar_Pervasives_Native.None
-                      else
-                        (let uu___5 =
-                           FStar_Compiler_List.splitAt
-                             (FStar_Compiler_List.length f_sig_bs) rest_bs in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___5
-                           (fun uu___6 -> FStar_Pervasives_Native.Some uu___6)) in
-                    op_let_Question uu___3
-                      (fun uu___4 ->
-                         match uu___4 with
-                         | (f_bs, rest_bs1) ->
-                             let uu___5 = eq_binders env f_sig_bs f_bs in
-                             op_let_Question uu___5
-                               (fun f_bs_kinds ->
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    (f_bs, f_bs_kinds, rest_bs1)
-                                    (fun uu___6 ->
-                                       FStar_Pervasives_Native.Some uu___6))) in
-                  op_let_Question uu___2
-                    (fun uu___3 ->
-                       match uu___3 with
-                       | (f_bs, f_bs_kinds, rest_bs1) ->
-                           let uu___4 =
-                             if
-                               (FStar_Compiler_List.length rest_bs1) >=
-                                 Prims.int_one
-                             then
-                               let uu___5 =
-                                 FStar_Compiler_List.splitAt
-                                   ((FStar_Compiler_List.length rest_bs1) -
-                                      Prims.int_one) rest_bs1 in
-                               match uu___5 with
-                               | (rest_bs2, f_b::[]) ->
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     (rest_bs2, f_b)
-                                     (fun uu___6 ->
-                                        FStar_Pervasives_Native.Some uu___6)
-                             else FStar_Pervasives_Native.None in
-                           op_let_Question uu___4
-                             (fun uu___5 ->
-                                match uu___5 with
-                                | (rest_bs2, f_b) ->
-                                    let uu___6 =
-                                      let expected_f_b_sort =
-                                        match m_repr_ts with
-                                        | FStar_Pervasives_Native.Some
-                                            repr_ts ->
-                                            let uu___7 =
-                                              FStar_TypeChecker_Env.inst_tscheme_with
-                                                repr_ts
-                                                [FStar_Syntax_Syntax.U_name u] in
-                                            (match uu___7 with
-                                             | (uu___8, t) ->
-                                                 let uu___9 =
-                                                   let uu___10 =
-                                                     let uu___11 =
-                                                       FStar_Compiler_Effect.op_Bar_Greater
-                                                         a_b.FStar_Syntax_Syntax.binder_bv
-                                                         FStar_Syntax_Syntax.bv_to_name in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___11
-                                                       FStar_Syntax_Syntax.as_arg in
-                                                   let uu___11 =
-                                                     FStar_Compiler_List.map
-                                                       (fun uu___12 ->
-                                                          match uu___12 with
-                                                          | {
-                                                              FStar_Syntax_Syntax.binder_bv
-                                                                = b;
-                                                              FStar_Syntax_Syntax.binder_qual
-                                                                = uu___13;
-                                                              FStar_Syntax_Syntax.binder_attrs
-                                                                = uu___14;_}
-                                                              ->
-                                                              let uu___15 =
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  b
-                                                                  FStar_Syntax_Syntax.bv_to_name in
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                uu___15
-                                                                FStar_Syntax_Syntax.as_arg)
-                                                       f_bs in
-                                                   uu___10 :: uu___11 in
-                                                 FStar_Syntax_Syntax.mk_Tm_app
-                                                   t uu___9
-                                                   FStar_Compiler_Range.dummyRange)
-                                        | FStar_Pervasives_Native.None ->
-                                            let uu___7 =
-                                              let uu___8 =
-                                                FStar_Syntax_Syntax.null_binder
-                                                  FStar_Syntax_Syntax.t_unit in
-                                              [uu___8] in
-                                            let uu___8 =
-                                              let uu___9 =
-                                                let uu___10 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    a_b.FStar_Syntax_Syntax.binder_bv
-                                                    FStar_Syntax_Syntax.bv_to_name in
-                                                let uu___11 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    f_bs
-                                                    (FStar_Compiler_List.map
-                                                       (fun b ->
-                                                          let uu___12 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              b.FStar_Syntax_Syntax.binder_bv
-                                                              FStar_Syntax_Syntax.bv_to_name in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___12
-                                                            FStar_Syntax_Syntax.as_arg)) in
-                                                {
-                                                  FStar_Syntax_Syntax.comp_univs
-                                                    =
-                                                    [FStar_Syntax_Syntax.U_name
-                                                       u];
-                                                  FStar_Syntax_Syntax.effect_name
-                                                    = m_eff_name;
-                                                  FStar_Syntax_Syntax.result_typ
-                                                    = uu___10;
-                                                  FStar_Syntax_Syntax.effect_args
-                                                    = uu___11;
-                                                  FStar_Syntax_Syntax.flags =
-                                                    []
-                                                } in
-                                              FStar_Syntax_Syntax.mk_Comp
-                                                uu___9 in
-                                            FStar_Syntax_Util.arrow uu___7
-                                              uu___8 in
-                                      let uu___7 =
-                                        let uu___8 =
-                                          FStar_Syntax_Util.eq_tm
-                                            (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                            expected_f_b_sort in
-                                        uu___8 = FStar_Syntax_Util.Equal in
-                                      if uu___7
-                                      then FStar_Pervasives_Native.Some ()
-                                      else FStar_Pervasives_Native.None in
-                                    op_let_Question uu___6
-                                      (fun _f_b_ok_ ->
-                                         let rest_kinds =
-                                           FStar_Compiler_List.map
-                                             (fun uu___7 ->
-                                                FStar_Syntax_Syntax.Ad_hoc_binder)
-                                             rest_bs2 in
-                                         FStar_Pervasives_Native.Some
-                                           (FStar_Compiler_List.op_At
-                                              [FStar_Syntax_Syntax.Type_binder]
-                                              (FStar_Compiler_List.op_At
-                                                 f_bs_kinds
-                                                 (FStar_Compiler_List.op_At
-                                                    rest_kinds
-                                                    [FStar_Syntax_Syntax.Repr_binder]))))))
-let (validate_indexed_effect_lift_shape :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.univ_name ->
-          FStar_Syntax_Syntax.typ ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.typ *
-                FStar_Syntax_Syntax.indexed_effect_combinator_kind))
-  =
-  fun env ->
-    fun m_eff_name ->
-      fun n_eff_name ->
-        fun u ->
-          fun lift_t ->
-            fun r ->
-              let lift_name =
-                let uu___ = FStar_Ident.string_of_lid m_eff_name in
-                let uu___1 = FStar_Ident.string_of_lid n_eff_name in
-                FStar_Compiler_Util.format2 "%s ~> %s" uu___ uu___1 in
-              let lift_t_shape_error s =
-                FStar_Compiler_Util.format2
-                  "Unexpected shape of lift %s, reason:%s" lift_name s in
-              let uu___ =
-                let uu___1 =
-                  FStar_TypeChecker_Env.get_effect_decl env m_eff_name in
-                let uu___2 =
-                  FStar_TypeChecker_Env.get_effect_decl env n_eff_name in
-                (uu___1, uu___2) in
-              match uu___ with
-              | (m_ed, n_ed) ->
-                  let a_b =
-                    let uu___1 =
-                      let uu___2 =
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          (FStar_Syntax_Syntax.U_name u)
-                          FStar_Syntax_Util.type_with_u in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___2
-                        (FStar_Syntax_Syntax.gen_bv "a"
-                           FStar_Pervasives_Native.None) in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___1
-                      FStar_Syntax_Syntax.mk_binder in
-                  let uu___1 =
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Subst.compress lift_t in
-                      uu___3.FStar_Syntax_Syntax.n in
-                    match uu___2 with
-                    | FStar_Syntax_Syntax.Tm_arrow (bs, c) when
-                        (FStar_Compiler_List.length bs) >= (Prims.of_int (2))
-                        ->
-                        let uu___3 = FStar_Syntax_Subst.open_binders bs in
-                        (match uu___3 with
-                         | { FStar_Syntax_Syntax.binder_bv = a;
-                             FStar_Syntax_Syntax.binder_qual = uu___4;
-                             FStar_Syntax_Syntax.binder_attrs = uu___5;_}::bs1
-                             ->
-                             let uu___6 =
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Compiler_Effect.op_Bar_Greater bs1
-                                     (FStar_Compiler_List.splitAt
-                                        ((FStar_Compiler_List.length bs1) -
-                                           Prims.int_one)) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___8
-                                   FStar_Pervasives_Native.fst in
-                               let uu___8 =
-                                 let uu___9 =
-                                   let uu___10 =
-                                     let uu___11 =
-                                       let uu___12 =
-                                         FStar_Syntax_Syntax.bv_to_name
-                                           a_b.FStar_Syntax_Syntax.binder_bv in
-                                       (a, uu___12) in
-                                     FStar_Syntax_Syntax.NT uu___11 in
-                                   [uu___10] in
-                                 FStar_Syntax_Subst.subst_binders uu___9 in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                 uu___8 in
-                             let uu___7 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 (FStar_Syntax_Util.comp_effect_name c)
-                                 (FStar_TypeChecker_Env.norm_eff_name env) in
-                             (uu___6, uu___7))
-                    | uu___3 ->
-                        let uu___4 =
-                          let uu___5 =
-                            lift_t_shape_error
-                              "either not an arrow, or not enough binders" in
-                          (FStar_Errors.Fatal_UnexpectedExpressionType,
-                            uu___5) in
-                        FStar_Errors.raise_error uu___4 r in
-                  (match uu___1 with
-                   | (rest_bs, lift_eff) ->
-                       ((let uu___3 =
-                           let uu___4 =
-                             (FStar_Ident.lid_equals lift_eff
-                                FStar_Parser_Const.effect_PURE_lid)
-                               ||
-                               ((FStar_Ident.lid_equals lift_eff
-                                   FStar_Parser_Const.effect_GHOST_lid)
-                                  &&
-                                  (FStar_TypeChecker_Env.is_erasable_effect
-                                     env m_eff_name)) in
-                           Prims.op_Negation uu___4 in
-                         if uu___3
-                         then
-                           let uu___4 =
-                             let uu___5 =
-                               lift_t_shape_error
-                                 "the lift combinator has an unexpected effect: it must either be PURE or if the source effect is erasable then may be GHOST" in
-                             (FStar_Errors.Fatal_UnexpectedExpressionType,
-                               uu___5) in
-                           FStar_Errors.raise_error uu___4 r
-                         else ());
-                        (let uu___3 =
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_TypeChecker_Env.push_binders env (a_b ::
-                                 rest_bs) in
-                             let uu___6 =
-                               FStar_Syntax_Util.effect_sig_ts
-                                 m_ed.FStar_Syntax_Syntax.signature in
-                             let uu___7 = FStar_Syntax_Util.get_eff_repr m_ed in
-                             let uu___8 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 a_b.FStar_Syntax_Syntax.binder_bv
-                                 FStar_Syntax_Syntax.bv_to_name in
-                             FStar_TypeChecker_Util.fresh_effect_repr uu___5
-                               r m_eff_name uu___6 uu___7
-                               (FStar_Syntax_Syntax.U_name u) uu___8 in
-                           match uu___4 with
-                           | (repr, g) ->
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Compiler_Effect.op_Bar_Greater repr
-                                     (FStar_Syntax_Syntax.gen_bv "f"
-                                        FStar_Pervasives_Native.None) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                   FStar_Syntax_Syntax.mk_binder in
-                               (uu___5, g) in
-                         match uu___3 with
-                         | (f, guard_f) ->
-                             let uu___4 =
-                               let uu___5 =
-                                 FStar_TypeChecker_Env.push_binders env (a_b
-                                   :: rest_bs) in
-                               let uu___6 =
-                                 FStar_Syntax_Util.effect_sig_ts
-                                   n_ed.FStar_Syntax_Syntax.signature in
-                               let uu___7 =
-                                 FStar_Syntax_Util.get_eff_repr n_ed in
-                               let uu___8 =
-                                 FStar_Compiler_Effect.op_Bar_Greater
-                                   a_b.FStar_Syntax_Syntax.binder_bv
-                                   FStar_Syntax_Syntax.bv_to_name in
-                               FStar_TypeChecker_Util.fresh_effect_repr
-                                 uu___5 r n_eff_name uu___6 uu___7
-                                 (FStar_Syntax_Syntax.U_name u) uu___8 in
-                             (match uu___4 with
-                              | (ret_t, guard_ret_t) ->
-                                  let uu___5 =
-                                    let uu___6 =
-                                      FStar_TypeChecker_Env.push_binders env
-                                        (a_b :: rest_bs) in
-                                    let uu___7 =
-                                      FStar_Compiler_Util.format1
-                                        "implicit for pure_wp in typechecking lift %s"
-                                        lift_name in
-                                    pure_wp_uvar uu___6 ret_t uu___7 r in
-                                  (match uu___5 with
-                                   | (pure_wp_uvar1, guard_wp) ->
-                                       let c =
-                                         let uu___6 =
-                                           let uu___7 =
-                                             let uu___8 =
-                                               FStar_TypeChecker_Env.new_u_univ
-                                                 () in
-                                             [uu___8] in
-                                           let uu___8 =
-                                             let uu___9 =
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 pure_wp_uvar1
-                                                 FStar_Syntax_Syntax.as_arg in
-                                             [uu___9] in
-                                           {
-                                             FStar_Syntax_Syntax.comp_univs =
-                                               uu___7;
-                                             FStar_Syntax_Syntax.effect_name
-                                               = lift_eff;
-                                             FStar_Syntax_Syntax.result_typ =
-                                               ret_t;
-                                             FStar_Syntax_Syntax.effect_args
-                                               = uu___8;
-                                             FStar_Syntax_Syntax.flags = []
-                                           } in
-                                         FStar_Syntax_Syntax.mk_Comp uu___6 in
-                                       let k =
-                                         FStar_Syntax_Util.arrow
-                                           (FStar_Compiler_List.op_At (a_b ::
-                                              rest_bs) [f]) c in
-                                       let guard_eq =
-                                         let uu___6 =
-                                           FStar_TypeChecker_Rel.teq_nosmt
-                                             env lift_t k in
-                                         match uu___6 with
-                                         | FStar_Pervasives_Native.None ->
-                                             let uu___7 =
-                                               let uu___8 =
-                                                 let uu___9 =
-                                                   FStar_Syntax_Print.term_to_string
-                                                     lift_t in
-                                                 FStar_Compiler_Util.format2
-                                                   "Unexpected type of %s (%s)\n"
-                                                   lift_name uu___9 in
-                                               (FStar_Errors.Fatal_UnexpectedEffect,
-                                                 uu___8) in
-                                             FStar_Errors.raise_error uu___7
-                                               r
-                                         | FStar_Pervasives_Native.Some g ->
-                                             g in
-                                       ((let uu___7 =
-                                           FStar_TypeChecker_Env.conj_guards
-                                             [guard_f;
-                                             guard_ret_t;
-                                             guard_wp;
-                                             guard_eq] in
-                                         FStar_TypeChecker_Rel.force_trivial_guard
-                                           env uu___7);
-                                        (let k1 =
-                                           let uu___7 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               k
-                                               (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                                  env) in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___7
-                                             FStar_Syntax_Subst.compress in
-                                         let lopt =
-                                           let uu___7 =
-                                             FStar_Syntax_Util.effect_sig_ts
-                                               m_ed.FStar_Syntax_Syntax.signature in
-                                           let uu___8 =
-                                             FStar_Syntax_Util.get_eff_repr
-                                               m_ed in
-                                           lift_combinator_kind env
-                                             m_eff_name uu___7 uu___8 u k1 in
-                                         let kind =
-                                           match lopt with
-                                           | FStar_Pervasives_Native.None ->
-                                               (log_ad_hoc_combinator_warning
-                                                  lift_name r;
-                                                FStar_Syntax_Syntax.Ad_hoc_combinator)
-                                           | FStar_Pervasives_Native.Some l
-                                               ->
-                                               FStar_Syntax_Syntax.Substitutive_combinator
-                                                 l in
-                                         (let uu___8 =
-                                            FStar_Compiler_Effect.op_Less_Bar
-                                              (FStar_TypeChecker_Env.debug
-                                                 env)
-                                              (FStar_Options.Other
-                                                 "LayeredEffectsTc") in
-                                          if uu___8
-                                          then
-                                            let uu___9 =
-                                              FStar_Syntax_Print.indexed_effect_combinator_kind_to_string
-                                                kind in
-                                            FStar_Compiler_Util.print2
-                                              "Lift %s has %s kind\n"
-                                              lift_name uu___9
-                                          else ());
-                                         (k1, kind))))))))
-let (tc_layered_eff_decl :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.attribute Prims.list ->
-          (FStar_Syntax_Syntax.eff_decl * FStar_Syntax_Syntax.sigelt
-            Prims.list))
-  =
-  fun env0 ->
-    fun ed ->
-      fun quals ->
-        fun attrs ->
-          let uu___ =
-            let uu___1 =
-              FStar_Ident.string_of_lid ed.FStar_Syntax_Syntax.mname in
-            FStar_Compiler_Util.format1
-              "While checking layered effect definition `%s`" uu___1 in
-          FStar_Errors.with_ctx uu___
-            (fun uu___1 ->
-               (let uu___3 =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env0)
-                    (FStar_Options.Other "LayeredEffectsTc") in
-                if uu___3
-                then
-                  let uu___4 = FStar_Syntax_Print.eff_decl_to_string false ed in
-                  FStar_Compiler_Util.print1
-                    "Typechecking layered effect: \n\t%s\n" uu___4
-                else ());
-               if
-                 ((FStar_Compiler_List.length ed.FStar_Syntax_Syntax.univs)
-                    <> Prims.int_zero)
-                   ||
-                   ((FStar_Compiler_List.length
-                       ed.FStar_Syntax_Syntax.binders)
-                      <> Prims.int_zero)
-               then
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 =
-                        let uu___7 =
-                          FStar_Ident.string_of_lid
-                            ed.FStar_Syntax_Syntax.mname in
-                        Prims.op_Hat uu___7 ")" in
-                      Prims.op_Hat
-                        "Binders are not supported for layered effects ("
-                        uu___6 in
-                    (FStar_Errors.Fatal_UnexpectedEffect, uu___5) in
-                  let uu___5 =
-                    FStar_Ident.range_of_lid ed.FStar_Syntax_Syntax.mname in
-                  FStar_Errors.raise_error uu___4 uu___5)
-               else ();
-               (let log_combinator s uu___4 =
-                  match uu___4 with
-                  | (us, t, ty) ->
-                      let uu___5 =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_TypeChecker_Env.debug env0)
-                          (FStar_Options.Other "LayeredEffectsTc") in
-                      if uu___5
-                      then
-                        let uu___6 =
-                          FStar_Ident.string_of_lid
-                            ed.FStar_Syntax_Syntax.mname in
-                        let uu___7 =
-                          FStar_Syntax_Print.tscheme_to_string (us, t) in
-                        let uu___8 =
-                          FStar_Syntax_Print.tscheme_to_string (us, ty) in
-                        FStar_Compiler_Util.print4
-                          "Typechecked %s:%s = %s:%s\n" uu___6 s uu___7
-                          uu___8
-                      else () in
-                let fresh_a_and_u_a a =
-                  let uu___4 = FStar_Syntax_Util.type_u () in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    (fun uu___5 ->
-                       match uu___5 with
-                       | (t, u) ->
-                           let uu___6 =
-                             let uu___7 =
-                               FStar_Syntax_Syntax.gen_bv a
-                                 FStar_Pervasives_Native.None t in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___7
-                               FStar_Syntax_Syntax.mk_binder in
-                           (uu___6, u)) in
-                let fresh_x_a x a =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Syntax_Syntax.bv_to_name
-                        a.FStar_Syntax_Syntax.binder_bv in
-                    FStar_Syntax_Syntax.gen_bv x FStar_Pervasives_Native.None
-                      uu___5 in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___4
-                    FStar_Syntax_Syntax.mk_binder in
-                let check_and_gen1 =
-                  let uu___4 =
-                    FStar_Ident.string_of_lid ed.FStar_Syntax_Syntax.mname in
-                  check_and_gen env0 uu___4 in
-                let uu___4 =
-                  let uu___5 =
-                    match ed.FStar_Syntax_Syntax.signature with
-                    | FStar_Syntax_Syntax.Layered_eff_sig (n, ts) -> (n, ts)
-                    | uu___6 ->
-                        failwith
-                          "Impossible (tc_layered_eff_decl with a wp effect sig" in
-                  match uu___5 with
-                  | (n, sig_ts) ->
-                      let r =
-                        (FStar_Pervasives_Native.snd sig_ts).FStar_Syntax_Syntax.pos in
-                      let uu___6 =
-                        check_and_gen1 "signature" Prims.int_one sig_ts in
-                      (match uu___6 with
-                       | (sig_us, sig_t, sig_ty) ->
-                           let uu___7 =
-                             FStar_Syntax_Subst.open_univ_vars sig_us sig_t in
-                           (match uu___7 with
-                            | (us, t) ->
-                                let env =
-                                  FStar_TypeChecker_Env.push_univ_vars env0
-                                    us in
-                                let uu___8 = fresh_a_and_u_a "a" in
-                                (match uu___8 with
-                                 | (a, u) ->
-                                     let rest_bs =
-                                       let uu___9 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           a.FStar_Syntax_Syntax.binder_bv
-                                           FStar_Syntax_Syntax.bv_to_name in
-                                       FStar_TypeChecker_Util.layered_effect_indices_as_binders
-                                         env r ed.FStar_Syntax_Syntax.mname
-                                         (sig_us, sig_t) u uu___9 in
-                                     let bs = a :: rest_bs in
-                                     let k =
-                                       let uu___9 =
-                                         FStar_Syntax_Syntax.mk_Total
-                                           FStar_Syntax_Syntax.teff in
-                                       FStar_Syntax_Util.arrow bs uu___9 in
-                                     let g_eq =
-                                       FStar_TypeChecker_Rel.teq env t k in
-                                     (FStar_TypeChecker_Rel.force_trivial_guard
-                                        env g_eq;
-                                      (let uu___10 =
-                                         let uu___11 =
-                                           let uu___12 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               k
-                                               (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                                  env) in
-                                           FStar_Syntax_Subst.close_univ_vars
-                                             us uu___12 in
-                                         (sig_us, uu___11, sig_ty) in
-                                       (n, uu___10)))))) in
-                match uu___4 with
-                | (num_effect_params, signature) ->
-                    (log_combinator "signature" signature;
-                     (let repr =
-                        let repr_ts =
-                          let uu___6 =
-                            FStar_Compiler_Effect.op_Bar_Greater ed
-                              FStar_Syntax_Util.get_eff_repr in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___6
-                            FStar_Compiler_Util.must in
-                        let r =
-                          (FStar_Pervasives_Native.snd repr_ts).FStar_Syntax_Syntax.pos in
-                        let uu___6 =
-                          check_and_gen1 "repr" Prims.int_one repr_ts in
-                        match uu___6 with
-                        | (repr_us, repr_t, repr_ty) ->
-                            let uu___7 =
-                              FStar_Syntax_Subst.open_univ_vars repr_us
-                                repr_ty in
-                            (match uu___7 with
-                             | (us, ty) ->
-                                 let env =
-                                   FStar_TypeChecker_Env.push_univ_vars env0
-                                     us in
-                                 let uu___8 = fresh_a_and_u_a "a" in
-                                 (match uu___8 with
-                                  | (a, u) ->
-                                      let rest_bs =
-                                        let signature_ts =
-                                          let uu___9 = signature in
-                                          match uu___9 with
-                                          | (us1, t, uu___10) -> (us1, t) in
-                                        let uu___9 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            a.FStar_Syntax_Syntax.binder_bv
-                                            FStar_Syntax_Syntax.bv_to_name in
-                                        FStar_TypeChecker_Util.layered_effect_indices_as_binders
-                                          env r ed.FStar_Syntax_Syntax.mname
-                                          signature_ts u uu___9 in
-                                      let bs = a :: rest_bs in
-                                      let k =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            FStar_Syntax_Util.type_u () in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___10
-                                            (fun uu___11 ->
-                                               match uu___11 with
-                                               | (t, u1) ->
-                                                   FStar_Syntax_Syntax.mk_Total
-                                                     t) in
-                                        FStar_Syntax_Util.arrow bs uu___9 in
-                                      let g =
-                                        FStar_TypeChecker_Rel.teq env ty k in
-                                      (FStar_TypeChecker_Rel.force_trivial_guard
-                                         env g;
-                                       (let uu___10 =
-                                          let uu___11 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              k
-                                              (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                                 env) in
-                                          FStar_Syntax_Subst.close_univ_vars
-                                            us uu___11 in
-                                        (repr_us, repr_t, uu___10))))) in
-                      log_combinator "repr" repr;
-                      (let fresh_repr r env u a_tm =
-                         let signature_ts =
-                           let uu___7 = signature in
-                           match uu___7 with | (us, t, uu___8) -> (us, t) in
-                         let repr_ts =
-                           let uu___7 = repr in
-                           match uu___7 with | (us, t, uu___8) -> (us, t) in
-                         FStar_TypeChecker_Util.fresh_effect_repr env r
-                           ed.FStar_Syntax_Syntax.mname signature_ts
-                           (FStar_Pervasives_Native.Some repr_ts) u a_tm in
-                       let not_an_arrow_error comb n t r =
-                         let uu___7 =
-                           let uu___8 =
-                             let uu___9 =
-                               FStar_Ident.string_of_lid
-                                 ed.FStar_Syntax_Syntax.mname in
-                             let uu___10 =
-                               FStar_Compiler_Util.string_of_int n in
-                             let uu___11 = FStar_Syntax_Print.tag_of_term t in
-                             let uu___12 =
-                               FStar_Syntax_Print.term_to_string t in
-                             FStar_Compiler_Util.format5
-                               "Type of %s:%s is not an arrow with >= %s binders (%s::%s)"
-                               uu___9 comb uu___10 uu___11 uu___12 in
-                           (FStar_Errors.Fatal_UnexpectedEffect, uu___8) in
-                         FStar_Errors.raise_error uu___7 r in
-                       let return_repr =
-                         let return_repr_ts =
-                           let uu___7 =
-                             FStar_Compiler_Effect.op_Bar_Greater ed
-                               FStar_Syntax_Util.get_return_repr in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___7
-                             FStar_Compiler_Util.must in
-                         let r =
-                           (FStar_Pervasives_Native.snd return_repr_ts).FStar_Syntax_Syntax.pos in
-                         let uu___7 =
-                           check_and_gen1 "return_repr" Prims.int_one
-                             return_repr_ts in
-                         match uu___7 with
-                         | (ret_us, ret_t, ret_ty) ->
-                             let uu___8 =
-                               FStar_Syntax_Subst.open_univ_vars ret_us
-                                 ret_ty in
-                             (match uu___8 with
-                              | (us, ty) ->
-                                  let env =
-                                    FStar_TypeChecker_Env.push_univ_vars env0
-                                      us in
-                                  let uu___9 = fresh_a_and_u_a "a" in
-                                  (match uu___9 with
-                                   | (a, u_a) ->
-                                       let x_a = fresh_x_a "x" a in
-                                       let rest_bs =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             FStar_Syntax_Subst.compress ty in
-                                           uu___11.FStar_Syntax_Syntax.n in
-                                         match uu___10 with
-                                         | FStar_Syntax_Syntax.Tm_arrow
-                                             (bs, uu___11) when
-                                             (FStar_Compiler_List.length bs)
-                                               >= (Prims.of_int (2))
-                                             ->
-                                             let uu___12 =
-                                               FStar_Syntax_Subst.open_binders
-                                                 bs in
-                                             (match uu___12 with
-                                              | {
-                                                  FStar_Syntax_Syntax.binder_bv
-                                                    = a';
-                                                  FStar_Syntax_Syntax.binder_qual
-                                                    = uu___13;
-                                                  FStar_Syntax_Syntax.binder_attrs
-                                                    = uu___14;_}::{
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    = x';
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___15;
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___16;_}::bs1
-                                                  ->
-                                                  let uu___17 =
-                                                    let uu___18 =
-                                                      let uu___19 =
-                                                        let uu___20 =
-                                                          let uu___21 =
-                                                            let uu___22 =
-                                                              FStar_Syntax_Syntax.bv_to_name
-                                                                a.FStar_Syntax_Syntax.binder_bv in
-                                                            (a', uu___22) in
-                                                          FStar_Syntax_Syntax.NT
-                                                            uu___21 in
-                                                        [uu___20] in
-                                                      FStar_Syntax_Subst.subst_binders
-                                                        uu___19 in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      bs1 uu___18 in
-                                                  let uu___18 =
-                                                    let uu___19 =
-                                                      let uu___20 =
-                                                        let uu___21 =
-                                                          let uu___22 =
-                                                            FStar_Syntax_Syntax.bv_to_name
-                                                              x_a.FStar_Syntax_Syntax.binder_bv in
-                                                          (x', uu___22) in
-                                                        FStar_Syntax_Syntax.NT
-                                                          uu___21 in
-                                                      [uu___20] in
-                                                    FStar_Syntax_Subst.subst_binders
-                                                      uu___19 in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___17 uu___18)
-                                         | uu___11 ->
-                                             not_an_arrow_error "return"
-                                               (Prims.of_int (2)) ty r in
-                                       let bs = a :: x_a :: rest_bs in
-                                       let uu___10 =
-                                         let uu___11 =
-                                           FStar_TypeChecker_Env.push_binders
-                                             env bs in
-                                         let uu___12 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             a.FStar_Syntax_Syntax.binder_bv
-                                             FStar_Syntax_Syntax.bv_to_name in
-                                         fresh_repr r uu___11 u_a uu___12 in
-                                       (match uu___10 with
-                                        | (repr1, g) ->
-                                            let k =
-                                              let uu___11 =
-                                                FStar_Syntax_Syntax.mk_Total
-                                                  repr1 in
-                                              FStar_Syntax_Util.arrow bs
-                                                uu___11 in
-                                            let g_eq =
-                                              FStar_TypeChecker_Rel.teq env
-                                                ty k in
-                                            ((let uu___12 =
-                                                FStar_TypeChecker_Env.conj_guard
-                                                  g g_eq in
-                                              FStar_TypeChecker_Rel.force_trivial_guard
-                                                env uu___12);
-                                             (let k1 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  k
-                                                  (FStar_TypeChecker_Normalize.remove_uvar_solutions
-                                                     env) in
-                                              let uu___12 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  k1
-                                                  (FStar_Syntax_Subst.close_univ_vars
-                                                     us) in
-                                              (ret_us, ret_t, uu___12)))))) in
-                       log_combinator "return_repr" return_repr;
-                       (let uu___8 =
-                          let bind_repr_ts =
-                            let uu___9 =
-                              FStar_Compiler_Effect.op_Bar_Greater ed
-                                FStar_Syntax_Util.get_bind_repr in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___9
-                              FStar_Compiler_Util.must in
-                          let r =
-                            (FStar_Pervasives_Native.snd bind_repr_ts).FStar_Syntax_Syntax.pos in
-                          let uu___9 =
-                            check_and_gen1 "bind_repr" (Prims.of_int (2))
-                              bind_repr_ts in
-                          match uu___9 with
-                          | (bind_us, bind_t, bind_ty) ->
-                              let uu___10 =
-                                FStar_Syntax_Subst.open_univ_vars bind_us
-                                  bind_ty in
-                              (match uu___10 with
-                               | (us, ty) ->
-                                   let env =
-                                     FStar_TypeChecker_Env.push_univ_vars
-                                       env0 us in
-                                   let uu___11 =
-                                     let sig_ts =
-                                       let uu___12 = signature in
-                                       match uu___12 with
-                                       | (us1, t, uu___13) -> (us1, t) in
-                                     let repr_ts =
-                                       let uu___12 = repr in
-                                       match uu___12 with
-                                       | (us1, t, uu___13) -> (us1, t) in
-                                     let uu___12 =
-                                       FStar_Syntax_Util.has_attribute
-                                         ed.FStar_Syntax_Syntax.eff_attrs
-                                         FStar_Parser_Const.bind_has_range_args_attr in
-                                     validate_indexed_effect_bind_shape env
-                                       ed.FStar_Syntax_Syntax.mname
-                                       ed.FStar_Syntax_Syntax.mname
-                                       ed.FStar_Syntax_Syntax.mname sig_ts
-                                       sig_ts sig_ts
-                                       (FStar_Pervasives_Native.Some repr_ts)
-                                       (FStar_Pervasives_Native.Some repr_ts)
-                                       (FStar_Pervasives_Native.Some repr_ts)
-                                       us ty r num_effect_params uu___12 in
-                                   (match uu___11 with
-                                    | (k, kind) ->
-                                        let uu___12 =
-                                          let uu___13 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              k
-                                              (FStar_Syntax_Subst.close_univ_vars
-                                                 bind_us) in
-                                          (bind_us, bind_t, uu___13) in
-                                        (uu___12, kind))) in
-                        match uu___8 with
-                        | (bind_repr, bind_kind) ->
-                            (log_combinator "bind_repr" bind_repr;
-                             (let uu___10 =
-                                let stronger_repr =
-                                  let ts =
-                                    let uu___11 =
-                                      FStar_Compiler_Effect.op_Bar_Greater ed
-                                        FStar_Syntax_Util.get_stronger_repr in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___11 FStar_Compiler_Util.must in
-                                  let uu___11 =
-                                    let uu___12 =
-                                      let uu___13 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          ts FStar_Pervasives_Native.snd in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___13 FStar_Syntax_Subst.compress in
-                                    uu___12.FStar_Syntax_Syntax.n in
-                                  match uu___11 with
-                                  | FStar_Syntax_Syntax.Tm_unknown ->
-                                      let signature_ts =
-                                        let uu___12 = signature in
-                                        match uu___12 with
-                                        | (us, t, uu___13) -> (us, t) in
-                                      let uu___12 =
-                                        FStar_TypeChecker_Env.inst_tscheme_with
-                                          signature_ts
-                                          [FStar_Syntax_Syntax.U_unknown] in
-                                      (match uu___12 with
-                                       | (uu___13, signature_t) ->
-                                           let uu___14 =
-                                             let uu___15 =
-                                               FStar_Syntax_Subst.compress
-                                                 signature_t in
-                                             uu___15.FStar_Syntax_Syntax.n in
-                                           (match uu___14 with
-                                            | FStar_Syntax_Syntax.Tm_arrow
-                                                (bs, uu___15) ->
-                                                let bs1 =
-                                                  FStar_Syntax_Subst.open_binders
-                                                    bs in
-                                                let repr_t =
-                                                  let repr_ts =
-                                                    let uu___16 = repr in
-                                                    match uu___16 with
-                                                    | (us, t, uu___17) ->
-                                                        (us, t) in
-                                                  let uu___16 =
-                                                    FStar_TypeChecker_Env.inst_tscheme_with
-                                                      repr_ts
-                                                      [FStar_Syntax_Syntax.U_unknown] in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___16
-                                                    FStar_Pervasives_Native.snd in
-                                                let repr_t_applied =
-                                                  let uu___16 =
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        let uu___19 =
-                                                          let uu___20 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              bs1
-                                                              (FStar_Compiler_List.map
-                                                                 (fun b ->
-                                                                    b.FStar_Syntax_Syntax.binder_bv)) in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___20
-                                                            (FStar_Compiler_List.map
-                                                               FStar_Syntax_Syntax.bv_to_name) in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___19
-                                                          (FStar_Compiler_List.map
-                                                             FStar_Syntax_Syntax.as_arg) in
-                                                      (repr_t, uu___18) in
-                                                    FStar_Syntax_Syntax.Tm_app
-                                                      uu___17 in
-                                                  let uu___17 =
-                                                    FStar_Ident.range_of_lid
-                                                      ed.FStar_Syntax_Syntax.mname in
-                                                  FStar_Syntax_Syntax.mk
-                                                    uu___16 uu___17 in
-                                                let f_b =
-                                                  FStar_Syntax_Syntax.null_binder
-                                                    repr_t_applied in
-                                                let uu___16 =
-                                                  let uu___17 =
-                                                    let uu___18 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        f_b.FStar_Syntax_Syntax.binder_bv
-                                                        FStar_Syntax_Syntax.bv_to_name in
-                                                    FStar_Syntax_Util.abs
-                                                      (FStar_Compiler_List.op_At
-                                                         bs1 [f_b]) uu___18
-                                                      FStar_Pervasives_Native.None in
-                                                  let uu___18 =
-                                                    FStar_Ident.range_of_lid
-                                                      ed.FStar_Syntax_Syntax.mname in
-                                                  {
-                                                    FStar_Syntax_Syntax.n =
-                                                      (uu___17.FStar_Syntax_Syntax.n);
-                                                    FStar_Syntax_Syntax.pos =
-                                                      uu___18;
-                                                    FStar_Syntax_Syntax.vars
-                                                      =
-                                                      (uu___17.FStar_Syntax_Syntax.vars);
-                                                    FStar_Syntax_Syntax.hash_code
-                                                      =
-                                                      (uu___17.FStar_Syntax_Syntax.hash_code)
-                                                  } in
-                                                ([], uu___16)
-                                            | uu___15 ->
-                                                failwith "Impossible!"))
-                                  | uu___12 -> ts in
-                                let r =
-                                  (FStar_Pervasives_Native.snd stronger_repr).FStar_Syntax_Syntax.pos in
-                                let uu___11 =
-                                  check_and_gen1 "stronger_repr"
-                                    Prims.int_one stronger_repr in
-                                match uu___11 with
-                                | (stronger_us, stronger_t, stronger_ty) ->
-                                    ((let uu___13 =
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (FStar_TypeChecker_Env.debug env0)
-                                          (FStar_Options.Other
-                                             "LayeredEffectsTc") in
-                                      if uu___13
-                                      then
-                                        let uu___14 =
-                                          FStar_Syntax_Print.tscheme_to_string
-                                            (stronger_us, stronger_t) in
-                                        let uu___15 =
-                                          FStar_Syntax_Print.tscheme_to_string
-                                            (stronger_us, stronger_ty) in
-                                        FStar_Compiler_Util.print2
-                                          "stronger combinator typechecked with term: %s and type: %s\n"
-                                          uu___14 uu___15
-                                      else ());
-                                     (let uu___13 =
-                                        FStar_Syntax_Subst.open_univ_vars
-                                          stronger_us stronger_ty in
-                                      match uu___13 with
-                                      | (us, ty) ->
-                                          let env =
-                                            FStar_TypeChecker_Env.push_univ_vars
-                                              env0 us in
-                                          let uu___14 =
-                                            let sig_ts =
-                                              let uu___15 = signature in
-                                              match uu___15 with
-                                              | (us1, t, uu___16) -> (us1, t) in
-                                            let repr_ts =
-                                              let uu___15 = repr in
-                                              match uu___15 with
-                                              | (us1, t, uu___16) -> (us1, t) in
-                                            let uu___15 =
-                                              FStar_Compiler_List.hd us in
-                                            validate_indexed_effect_subcomp_shape
-                                              env
-                                              ed.FStar_Syntax_Syntax.mname
-                                              ed.FStar_Syntax_Syntax.mname
-                                              sig_ts sig_ts
-                                              (FStar_Pervasives_Native.Some
-                                                 repr_ts)
-                                              (FStar_Pervasives_Native.Some
-                                                 repr_ts) uu___15 ty
-                                              num_effect_params r in
-                                          (match uu___14 with
-                                           | (k, kind) ->
-                                               let uu___15 =
-                                                 let uu___16 =
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     k
-                                                     (FStar_Syntax_Subst.close_univ_vars
-                                                        stronger_us) in
-                                                 (stronger_us, stronger_t,
-                                                   uu___16) in
-                                               (uu___15, kind)))) in
-                              match uu___10 with
-                              | (stronger_repr, subcomp_kind) ->
-                                  (log_combinator "stronger_repr"
-                                     stronger_repr;
-                                   (let uu___12 =
-                                      let if_then_else_ts =
-                                        let ts =
-                                          let uu___13 =
-                                            let uu___14 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                ed
-                                                FStar_Syntax_Util.get_layered_if_then_else_combinator in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___14
-                                              FStar_Compiler_Util.must in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___13
-                                            FStar_Pervasives_Native.fst in
-                                        let uu___13 =
-                                          let uu___14 =
-                                            let uu___15 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                ts
-                                                FStar_Pervasives_Native.snd in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___15
-                                              FStar_Syntax_Subst.compress in
-                                          uu___14.FStar_Syntax_Syntax.n in
-                                        match uu___13 with
-                                        | FStar_Syntax_Syntax.Tm_unknown ->
-                                            let signature_ts =
-                                              let uu___14 = signature in
-                                              match uu___14 with
-                                              | (us, t, uu___15) -> (us, t) in
-                                            let uu___14 =
-                                              FStar_TypeChecker_Env.inst_tscheme_with
-                                                signature_ts
-                                                [FStar_Syntax_Syntax.U_unknown] in
-                                            (match uu___14 with
-                                             | (uu___15, signature_t) ->
-                                                 let uu___16 =
-                                                   let uu___17 =
-                                                     FStar_Syntax_Subst.compress
-                                                       signature_t in
-                                                   uu___17.FStar_Syntax_Syntax.n in
-                                                 (match uu___16 with
-                                                  | FStar_Syntax_Syntax.Tm_arrow
-                                                      (bs, uu___17) ->
-                                                      let bs1 =
-                                                        FStar_Syntax_Subst.open_binders
-                                                          bs in
-                                                      let repr_t =
-                                                        let repr_ts =
-                                                          let uu___18 = repr in
-                                                          match uu___18 with
-                                                          | (us, t, uu___19)
-                                                              -> (us, t) in
-                                                        let uu___18 =
-                                                          FStar_TypeChecker_Env.inst_tscheme_with
-                                                            repr_ts
-                                                            [FStar_Syntax_Syntax.U_unknown] in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___18
-                                                          FStar_Pervasives_Native.snd in
-                                                      let repr_t_applied =
-                                                        let uu___18 =
-                                                          let uu___19 =
-                                                            let uu___20 =
-                                                              let uu___21 =
-                                                                let uu___22 =
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (
-                                                                    FStar_Compiler_List.map
-                                                                    (fun b ->
-                                                                    b.FStar_Syntax_Syntax.binder_bv)) in
-                                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                                  uu___22
-                                                                  (FStar_Compiler_List.map
-                                                                    FStar_Syntax_Syntax.bv_to_name) in
-                                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                                uu___21
-                                                                (FStar_Compiler_List.map
-                                                                   FStar_Syntax_Syntax.as_arg) in
-                                                            (repr_t, uu___20) in
-                                                          FStar_Syntax_Syntax.Tm_app
-                                                            uu___19 in
-                                                        let uu___19 =
-                                                          FStar_Ident.range_of_lid
-                                                            ed.FStar_Syntax_Syntax.mname in
-                                                        FStar_Syntax_Syntax.mk
-                                                          uu___18 uu___19 in
-                                                      let f_b =
-                                                        FStar_Syntax_Syntax.null_binder
-                                                          repr_t_applied in
-                                                      let g_b =
-                                                        FStar_Syntax_Syntax.null_binder
-                                                          repr_t_applied in
-                                                      let b_b =
-                                                        FStar_Syntax_Syntax.null_binder
-                                                          FStar_Syntax_Util.t_bool in
-                                                      let uu___18 =
-                                                        let uu___19 =
-                                                          FStar_Syntax_Util.abs
-                                                            (FStar_Compiler_List.op_At
-                                                               bs1
-                                                               [f_b;
-                                                               g_b;
-                                                               b_b])
-                                                            repr_t_applied
-                                                            FStar_Pervasives_Native.None in
-                                                        let uu___20 =
-                                                          FStar_Ident.range_of_lid
-                                                            ed.FStar_Syntax_Syntax.mname in
-                                                        {
-                                                          FStar_Syntax_Syntax.n
-                                                            =
-                                                            (uu___19.FStar_Syntax_Syntax.n);
-                                                          FStar_Syntax_Syntax.pos
-                                                            = uu___20;
-                                                          FStar_Syntax_Syntax.vars
-                                                            =
-                                                            (uu___19.FStar_Syntax_Syntax.vars);
-                                                          FStar_Syntax_Syntax.hash_code
-                                                            =
-                                                            (uu___19.FStar_Syntax_Syntax.hash_code)
-                                                        } in
-                                                      ([], uu___18)
-                                                  | uu___17 ->
-                                                      failwith "Impossible!"))
-                                        | uu___14 -> ts in
-                                      let r =
-                                        (FStar_Pervasives_Native.snd
-                                           if_then_else_ts).FStar_Syntax_Syntax.pos in
-                                      let uu___13 =
-                                        check_and_gen1 "if_then_else"
-                                          Prims.int_one if_then_else_ts in
-                                      match uu___13 with
-                                      | (if_then_else_us, if_then_else_t,
-                                         if_then_else_ty) ->
-                                          let uu___14 =
-                                            FStar_Syntax_Subst.open_univ_vars
-                                              if_then_else_us if_then_else_t in
-                                          (match uu___14 with
-                                           | (us, t) ->
-                                               let uu___15 =
-                                                 FStar_Syntax_Subst.open_univ_vars
-                                                   if_then_else_us
-                                                   if_then_else_ty in
-                                               (match uu___15 with
-                                                | (uu___16, ty) ->
-                                                    let env =
-                                                      FStar_TypeChecker_Env.push_univ_vars
-                                                        env0 us in
-                                                    let uu___17 =
-                                                      let sig_ts =
-                                                        let uu___18 =
-                                                          signature in
-                                                        match uu___18 with
-                                                        | (us1, t1, uu___19)
-                                                            -> (us1, t1) in
-                                                      let repr_ts =
-                                                        let uu___18 = repr in
-                                                        match uu___18 with
-                                                        | (us1, t1, uu___19)
-                                                            -> (us1, t1) in
-                                                      let uu___18 =
-                                                        FStar_Compiler_List.hd
-                                                          us in
-                                                      validate_indexed_effect_ite_shape
-                                                        env
-                                                        ed.FStar_Syntax_Syntax.mname
-                                                        sig_ts repr_ts
-                                                        uu___18 ty t
-                                                        num_effect_params r in
-                                                    (match uu___17 with
-                                                     | (k, kind) ->
-                                                         let uu___18 =
-                                                           let uu___19 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               k
-                                                               (FStar_Syntax_Subst.close_univ_vars
-                                                                  if_then_else_us) in
-                                                           (if_then_else_us,
-                                                             uu___19,
-                                                             if_then_else_ty) in
-                                                         (uu___18, kind)))) in
-                                    match uu___12 with
-                                    | (if_then_else, ite_kind) ->
-                                        (log_combinator "if_then_else"
-                                           if_then_else;
-                                         FStar_Errors.with_ctx
-                                           "While checking if-then-else soundness"
-                                           (fun uu___14 ->
-                                              let r =
-                                                let uu___15 =
-                                                  let uu___16 =
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          ed
-                                                          FStar_Syntax_Util.get_layered_if_then_else_combinator in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___18
-                                                        FStar_Compiler_Util.must in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      uu___17
-                                                      FStar_Pervasives_Native.fst in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___16
-                                                    FStar_Pervasives_Native.snd in
-                                                uu___15.FStar_Syntax_Syntax.pos in
-                                              let uu___15 = if_then_else in
-                                              match uu___15 with
-                                              | (ite_us, ite_t, uu___16) ->
-                                                  let uu___17 =
-                                                    FStar_Syntax_Subst.open_univ_vars
-                                                      ite_us ite_t in
-                                                  (match uu___17 with
-                                                   | (us, ite_t1) ->
-                                                       let uu___18 =
-                                                         let uu___19 =
-                                                           let uu___20 =
-                                                             FStar_Syntax_Subst.compress
-                                                               ite_t1 in
-                                                           uu___20.FStar_Syntax_Syntax.n in
-                                                         match uu___19 with
-                                                         | FStar_Syntax_Syntax.Tm_abs
-                                                             (bs, uu___20,
-                                                              uu___21)
-                                                             ->
-                                                             let bs1 =
-                                                               FStar_Syntax_Subst.open_binders
-                                                                 bs in
-                                                             let uu___22 =
-                                                               let uu___23 =
-                                                                 let uu___24
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (FStar_Compiler_List.splitAt
-                                                                    ((FStar_Compiler_List.length
-                                                                    bs1) -
-                                                                    (Prims.of_int (3)))) in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___24
-                                                                   FStar_Pervasives_Native.snd in
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 uu___23
-                                                                 (fun l ->
-                                                                    let uu___24
-                                                                    = l in
-                                                                    match uu___24
-                                                                    with
-                                                                    | 
-                                                                    f::g::p::[]
-                                                                    ->
-                                                                    (f, g, p)) in
-                                                             (match uu___22
-                                                              with
-                                                              | (f_b, g_b,
-                                                                 p_b) ->
-                                                                  let env =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_TypeChecker_Env.push_univ_vars
-                                                                    env0 us in
-                                                                    FStar_TypeChecker_Env.push_binders
-                                                                    uu___23
-                                                                    bs1 in
-                                                                  let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    (FStar_Compiler_List.map
-                                                                    (fun b ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    b.FStar_Syntax_Syntax.binder_bv in
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Util.aqual_of_binder
-                                                                    b in
-                                                                    (uu___26,
-                                                                    uu___27))) in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    ite_t1
-                                                                    uu___25 r in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___24
-                                                                    (FStar_TypeChecker_Normalize.normalize
-                                                                    [FStar_TypeChecker_Env.Beta]
-                                                                    env) in
-                                                                  let uu___24
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bs1
-                                                                    FStar_Compiler_List.hd in
-                                                                  let uu___25
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    p_b.FStar_Syntax_Syntax.binder_bv in
-                                                                  (env,
-                                                                    uu___23,
-                                                                    uu___24,
-                                                                    f_b, g_b,
-                                                                    uu___25))
-                                                         | uu___20 ->
-                                                             failwith
-                                                               "Impossible! ite_t must have been an abstraction with at least 3 binders" in
-                                                       (match uu___18 with
-                                                        | (env,
-                                                           ite_t_applied,
-                                                           a_b, f_b, g_b,
-                                                           p_t) ->
-                                                            let uu___19 =
-                                                              let uu___20 =
-                                                                stronger_repr in
-                                                              match uu___20
-                                                              with
-                                                              | (uu___21,
-                                                                 uu___22,
-                                                                 subcomp_ty)
-                                                                  ->
-                                                                  let uu___23
-                                                                    =
-                                                                    FStar_Syntax_Subst.open_univ_vars
-                                                                    us
-                                                                    subcomp_ty in
-                                                                  (match uu___23
-                                                                   with
-                                                                   | 
-                                                                   (uu___24,
-                                                                    subcomp_ty1)
-                                                                    ->
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    subcomp_ty1 in
-                                                                    uu___26.FStar_Syntax_Syntax.n in
-                                                                    (match uu___25
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_arrow
-                                                                    (bs, c)
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Subst.open_comp
-                                                                    bs c in
-                                                                    (match uu___26
-                                                                    with
-                                                                    | 
-                                                                    (bs1, c1)
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Compiler_List.hd
-                                                                    bs1 in
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Compiler_List.tl
-                                                                    bs1 in
-                                                                    (uu___28,
-                                                                    uu___29) in
-                                                                    (match uu___27
-                                                                    with
-                                                                    | 
-                                                                    (a_b1,
-                                                                    rest_bs)
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    rest_bs
-                                                                    (FStar_Compiler_List.splitAt
-                                                                    ((FStar_Compiler_List.length
-                                                                    rest_bs)
-                                                                    -
-                                                                    Prims.int_one)) in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___29
-                                                                    (fun
-                                                                    uu___30
-                                                                    ->
-                                                                    match uu___30
-                                                                    with
-                                                                    | 
-                                                                    (l1, l2)
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Compiler_List.hd
-                                                                    l2 in
-                                                                    (l1,
-                                                                    uu___31)) in
-                                                                    (match uu___28
-                                                                    with
-                                                                    | 
-                                                                    (rest_bs1,
-                                                                    f_b1) ->
-                                                                    (a_b1,
-                                                                    rest_bs1,
-                                                                    f_b1, c1))))
-                                                                    | 
-                                                                    uu___26
-                                                                    ->
-                                                                    failwith
-                                                                    "Impossible! subcomp_ty must have been an arrow with at lease 1 binder")) in
-                                                            (match uu___19
-                                                             with
-                                                             | (subcomp_a_b,
-                                                                subcomp_bs,
-                                                                subcomp_f_b,
-                                                                subcomp_c) ->
-                                                                 let check_branch
-                                                                   env1
-                                                                   ite_f_or_g_sort
-                                                                   attr_opt =
-                                                                   let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    a_b.FStar_Syntax_Syntax.binder_bv in
-                                                                    ((subcomp_a_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uu___26) in
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    uu___25 in
-                                                                    [uu___24] in
-                                                                    (uu___23,
-                                                                    [],
-                                                                    FStar_TypeChecker_Env.trivial_guard) in
-                                                                    FStar_Compiler_List.fold_left
-                                                                    (fun
-                                                                    uu___23
-                                                                    ->
-                                                                    fun b ->
-                                                                    match uu___23
-                                                                    with
-                                                                    | 
-                                                                    (subst,
-                                                                    uvars, g)
-                                                                    ->
-                                                                    let sort
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    subst
-                                                                    (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    let uu___24
-                                                                    =
-                                                                    let ctx_uvar_meta
-                                                                    =
-                                                                    FStar_Compiler_Util.map_option
-                                                                    (fun
-                                                                    uu___25
-                                                                    ->
-                                                                    FStar_Syntax_Syntax.Ctx_uvar_meta_attr
-                                                                    uu___25)
-                                                                    attr_opt in
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Print.binder_to_string
-                                                                    b in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "uvar for subcomp %s binder when checking ite soundness"
-                                                                    uu___26 in
-                                                                    FStar_TypeChecker_Env.new_implicit_var_aux
-                                                                    uu___25 r
-                                                                    env1 sort
-                                                                    FStar_Syntax_Syntax.Strict
-                                                                    ctx_uvar_meta in
-                                                                    (match uu___24
-                                                                    with
-                                                                    | 
-                                                                    (t,
-                                                                    uu___25,
-                                                                    g_t) ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_Common.conj_guard
-                                                                    g g_t in
-                                                                    ((FStar_Compiler_List.op_At
-                                                                    subst
-                                                                    [
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    ((b.FStar_Syntax_Syntax.binder_bv),
-                                                                    t)]),
-                                                                    (FStar_Compiler_List.op_At
-                                                                    uvars 
-                                                                    [t]),
-                                                                    uu___26)))
-                                                                    uu___22 in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    subcomp_bs
-                                                                    uu___21 in
-                                                                   match uu___20
-                                                                   with
-                                                                   | 
-                                                                   (subst,
-                                                                    uvars,
-                                                                    g_uvars)
-                                                                    ->
-                                                                    let subcomp_f_sort
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    subst
-                                                                    (subcomp_f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                                                    let c =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst_comp
-                                                                    subst
-                                                                    subcomp_c in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___21
-                                                                    (FStar_TypeChecker_Env.unfold_effect_abbrev
-                                                                    env1) in
-                                                                    let g_f_or_g
-                                                                    =
-                                                                    FStar_TypeChecker_Rel.layered_effect_teq
-                                                                    env1
-                                                                    subcomp_f_sort
-                                                                    ite_f_or_g_sort
-                                                                    FStar_Pervasives_Native.None in
-                                                                    let g_c =
-                                                                    FStar_TypeChecker_Rel.layered_effect_teq
-                                                                    env1
-                                                                    c.FStar_Syntax_Syntax.result_typ
-                                                                    ite_t_applied
-                                                                    FStar_Pervasives_Native.None in
-                                                                    let fml =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Compiler_List.hd
-                                                                    c.FStar_Syntax_Syntax.comp_univs in
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    c.FStar_Syntax_Syntax.effect_args
-                                                                    FStar_Compiler_List.hd in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___23
-                                                                    FStar_Pervasives_Native.fst in
-                                                                    FStar_TypeChecker_Env.pure_precondition_for_trivial_post
-                                                                    env1
-                                                                    uu___21
-                                                                    c.FStar_Syntax_Syntax.result_typ
-                                                                    uu___22 r in
-                                                                    let g_precondition
-                                                                    =
-                                                                    match attr_opt
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    fml
-                                                                    (fun
-                                                                    uu___22
-                                                                    ->
-                                                                    FStar_TypeChecker_Common.NonTrivial
-                                                                    uu___22) in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___21
-                                                                    FStar_TypeChecker_Env.guard_of_guard_formula
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    attr ->
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Util.mk_squash
-                                                                    FStar_Syntax_Syntax.U_zero
-                                                                    fml in
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    (FStar_Syntax_Syntax.Ctx_uvar_meta_attr
-                                                                    attr)
-                                                                    (fun
-                                                                    uu___24
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24) in
-                                                                    FStar_TypeChecker_Env.new_implicit_var_aux
-                                                                    "tc_layered_effect_decl.g_precondition"
-                                                                    r env1
-                                                                    uu___22
-                                                                    FStar_Syntax_Syntax.Strict
-                                                                    uu___23 in
-                                                                    (match uu___21
-                                                                    with
-                                                                    | 
-                                                                    (uu___22,
-                                                                    uu___23,
-                                                                    g) -> g) in
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guards
-                                                                    [g_uvars;
-                                                                    g_f_or_g;
-                                                                    g_c;
-                                                                    g_precondition] in
-                                                                    FStar_TypeChecker_Rel.force_trivial_guard
-                                                                    env1
-                                                                    uu___21 in
-                                                                 let ite_soundness_tac_attr
-                                                                   =
-                                                                   let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Util.get_attribute
-                                                                    FStar_Parser_Const.ite_soundness_by_attr
-                                                                    attrs in
-                                                                   match uu___20
-                                                                   with
-                                                                   | 
-                                                                   FStar_Pervasives_Native.Some
-                                                                    ((t,
-                                                                    uu___21)::uu___22)
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    t
-                                                                   | 
-                                                                   uu___21 ->
-                                                                    FStar_Pervasives_Native.None in
-                                                                 ((let env1 =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    p_t
-                                                                    FStar_Syntax_Util.b2t in
-                                                                    FStar_Syntax_Util.mk_squash
-                                                                    FStar_Syntax_Syntax.U_zero
-                                                                    uu___22 in
-                                                                    FStar_Syntax_Syntax.new_bv
-                                                                    FStar_Pervasives_Native.None
-                                                                    uu___21 in
-                                                                    FStar_TypeChecker_Env.push_bv
-                                                                    env
-                                                                    uu___20 in
-                                                                   check_branch
-                                                                    env1
-                                                                    (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                                    ite_soundness_tac_attr);
-                                                                  (let not_p
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Syntax.lid_as_fv
-                                                                    FStar_Parser_Const.not_lid
-                                                                    FStar_Syntax_Syntax.delta_constant
-                                                                    FStar_Pervasives_Native.None in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___21
-                                                                    FStar_Syntax_Syntax.fv_to_tm in
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    p_t
-                                                                    FStar_Syntax_Util.b2t in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___23
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    [uu___22] in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    uu___20
-                                                                    uu___21 r in
-                                                                   let env1 =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Syntax.new_bv
-                                                                    FStar_Pervasives_Native.None
-                                                                    not_p in
-                                                                    FStar_TypeChecker_Env.push_bv
-                                                                    env
-                                                                    uu___20 in
-                                                                   check_branch
-                                                                    env1
-                                                                    (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                                                    ite_soundness_tac_attr))))));
-                                         (let tc_action env act =
-                                            let env01 = env in
-                                            let r =
-                                              (act.FStar_Syntax_Syntax.action_defn).FStar_Syntax_Syntax.pos in
-                                            if
-                                              (FStar_Compiler_List.length
-                                                 act.FStar_Syntax_Syntax.action_params)
-                                                <> Prims.int_zero
-                                            then
-                                              (let uu___15 =
-                                                 let uu___16 =
-                                                   let uu___17 =
-                                                     FStar_Ident.string_of_lid
-                                                       ed.FStar_Syntax_Syntax.mname in
-                                                   let uu___18 =
-                                                     FStar_Ident.string_of_lid
-                                                       act.FStar_Syntax_Syntax.action_name in
-                                                   let uu___19 =
-                                                     FStar_Syntax_Print.binders_to_string
-                                                       "; "
-                                                       act.FStar_Syntax_Syntax.action_params in
-                                                   FStar_Compiler_Util.format3
-                                                     "Action %s:%s has non-empty action params (%s)"
-                                                     uu___17 uu___18 uu___19 in
-                                                 (FStar_Errors.Fatal_MalformedActionDeclaration,
-                                                   uu___16) in
-                                               FStar_Errors.raise_error
-                                                 uu___15 r)
-                                            else ();
-                                            (let uu___15 =
-                                               let uu___16 =
-                                                 FStar_Syntax_Subst.univ_var_opening
-                                                   act.FStar_Syntax_Syntax.action_univs in
-                                               match uu___16 with
-                                               | (usubst, us) ->
-                                                   let uu___17 =
-                                                     FStar_TypeChecker_Env.push_univ_vars
-                                                       env us in
-                                                   let uu___18 =
-                                                     let uu___19 =
-                                                       FStar_Syntax_Subst.subst
-                                                         usubst
-                                                         act.FStar_Syntax_Syntax.action_defn in
-                                                     let uu___20 =
-                                                       FStar_Syntax_Subst.subst
-                                                         usubst
-                                                         act.FStar_Syntax_Syntax.action_typ in
-                                                     {
-                                                       FStar_Syntax_Syntax.action_name
-                                                         =
-                                                         (act.FStar_Syntax_Syntax.action_name);
-                                                       FStar_Syntax_Syntax.action_unqualified_name
-                                                         =
-                                                         (act.FStar_Syntax_Syntax.action_unqualified_name);
-                                                       FStar_Syntax_Syntax.action_univs
-                                                         = us;
-                                                       FStar_Syntax_Syntax.action_params
-                                                         =
-                                                         (act.FStar_Syntax_Syntax.action_params);
-                                                       FStar_Syntax_Syntax.action_defn
-                                                         = uu___19;
-                                                       FStar_Syntax_Syntax.action_typ
-                                                         = uu___20
-                                                     } in
-                                                   (uu___17, uu___18) in
-                                             match uu___15 with
-                                             | (env1, act1) ->
-                                                 let act_typ =
-                                                   let uu___16 =
-                                                     let uu___17 =
-                                                       FStar_Syntax_Subst.compress
-                                                         act1.FStar_Syntax_Syntax.action_typ in
-                                                     uu___17.FStar_Syntax_Syntax.n in
-                                                   match uu___16 with
-                                                   | FStar_Syntax_Syntax.Tm_arrow
-                                                       (bs, c) ->
-                                                       let ct =
-                                                         FStar_TypeChecker_Env.comp_to_comp_typ
-                                                           env1 c in
-                                                       let uu___17 =
-                                                         FStar_Ident.lid_equals
-                                                           ct.FStar_Syntax_Syntax.effect_name
-                                                           ed.FStar_Syntax_Syntax.mname in
-                                                       if uu___17
-                                                       then
-                                                         let repr_ts =
-                                                           let uu___18 = repr in
-                                                           match uu___18 with
-                                                           | (us, t, uu___19)
-                                                               -> (us, t) in
-                                                         let repr1 =
-                                                           let uu___18 =
-                                                             FStar_TypeChecker_Env.inst_tscheme_with
-                                                               repr_ts
-                                                               ct.FStar_Syntax_Syntax.comp_univs in
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uu___18
-                                                             FStar_Pervasives_Native.snd in
-                                                         let repr2 =
-                                                           let uu___18 =
-                                                             let uu___19 =
-                                                               FStar_Syntax_Syntax.as_arg
-                                                                 ct.FStar_Syntax_Syntax.result_typ in
-                                                             uu___19 ::
-                                                               (ct.FStar_Syntax_Syntax.effect_args) in
-                                                           FStar_Syntax_Syntax.mk_Tm_app
-                                                             repr1 uu___18 r in
-                                                         let c1 =
-                                                           FStar_Syntax_Syntax.mk_Total
-                                                             repr2 in
-                                                         FStar_Syntax_Util.arrow
-                                                           bs c1
-                                                       else
-                                                         act1.FStar_Syntax_Syntax.action_typ
-                                                   | uu___17 ->
-                                                       act1.FStar_Syntax_Syntax.action_typ in
-                                                 let uu___16 =
-                                                   FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                     env1 act_typ in
-                                                 (match uu___16 with
-                                                  | (act_typ1, uu___17, g_t)
-                                                      ->
-                                                      let uu___18 =
-                                                        let uu___19 =
-                                                          let uu___20 =
-                                                            FStar_TypeChecker_Env.set_expected_typ
-                                                              env1 act_typ1 in
-                                                          {
-                                                            FStar_TypeChecker_Env.solver
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.solver);
-                                                            FStar_TypeChecker_Env.range
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.range);
-                                                            FStar_TypeChecker_Env.curmodule
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.curmodule);
-                                                            FStar_TypeChecker_Env.gamma
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.gamma);
-                                                            FStar_TypeChecker_Env.gamma_sig
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.gamma_sig);
-                                                            FStar_TypeChecker_Env.gamma_cache
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.gamma_cache);
-                                                            FStar_TypeChecker_Env.modules
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.modules);
-                                                            FStar_TypeChecker_Env.expected_typ
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.expected_typ);
-                                                            FStar_TypeChecker_Env.sigtab
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.sigtab);
-                                                            FStar_TypeChecker_Env.attrtab
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.attrtab);
-                                                            FStar_TypeChecker_Env.instantiate_imp
-                                                              = false;
-                                                            FStar_TypeChecker_Env.effects
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.effects);
-                                                            FStar_TypeChecker_Env.generalize
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.generalize);
-                                                            FStar_TypeChecker_Env.letrecs
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.letrecs);
-                                                            FStar_TypeChecker_Env.top_level
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.top_level);
-                                                            FStar_TypeChecker_Env.check_uvars
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.check_uvars);
-                                                            FStar_TypeChecker_Env.use_eq_strict
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.use_eq_strict);
-                                                            FStar_TypeChecker_Env.is_iface
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.is_iface);
-                                                            FStar_TypeChecker_Env.admit
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.admit);
-                                                            FStar_TypeChecker_Env.lax
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.lax);
-                                                            FStar_TypeChecker_Env.lax_universes
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.lax_universes);
-                                                            FStar_TypeChecker_Env.phase1
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.phase1);
-                                                            FStar_TypeChecker_Env.failhard
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.failhard);
-                                                            FStar_TypeChecker_Env.nosynth
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.nosynth);
-                                                            FStar_TypeChecker_Env.uvar_subtyping
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.uvar_subtyping);
-                                                            FStar_TypeChecker_Env.tc_term
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.tc_term);
-                                                            FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                            FStar_TypeChecker_Env.universe_of
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.universe_of);
-                                                            FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                            FStar_TypeChecker_Env.teq_nosmt_force
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                            FStar_TypeChecker_Env.subtype_nosmt_force
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                            FStar_TypeChecker_Env.qtbl_name_and_index
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                            FStar_TypeChecker_Env.normalized_eff_names
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.normalized_eff_names);
-                                                            FStar_TypeChecker_Env.fv_delta_depths
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.fv_delta_depths);
-                                                            FStar_TypeChecker_Env.proof_ns
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.proof_ns);
-                                                            FStar_TypeChecker_Env.synth_hook
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.synth_hook);
-                                                            FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                            FStar_TypeChecker_Env.splice
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.splice);
-                                                            FStar_TypeChecker_Env.mpreprocess
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.mpreprocess);
-                                                            FStar_TypeChecker_Env.postprocess
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.postprocess);
-                                                            FStar_TypeChecker_Env.identifier_info
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.identifier_info);
-                                                            FStar_TypeChecker_Env.tc_hooks
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.tc_hooks);
-                                                            FStar_TypeChecker_Env.dsenv
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.dsenv);
-                                                            FStar_TypeChecker_Env.nbe
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.nbe);
-                                                            FStar_TypeChecker_Env.strict_args_tab
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.strict_args_tab);
-                                                            FStar_TypeChecker_Env.erasable_types_tab
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.erasable_types_tab);
-                                                            FStar_TypeChecker_Env.enable_defer_to_tac
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                            FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                            FStar_TypeChecker_Env.erase_erasable_args
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.erase_erasable_args);
-                                                            FStar_TypeChecker_Env.core_check
-                                                              =
-                                                              (uu___20.FStar_TypeChecker_Env.core_check)
-                                                          } in
-                                                        FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                          uu___19
-                                                          act1.FStar_Syntax_Syntax.action_defn in
-                                                      (match uu___18 with
-                                                       | (act_defn, uu___19,
-                                                          g_d) ->
-                                                           ((let uu___21 =
-                                                               FStar_Compiler_Effect.op_Less_Bar
-                                                                 (FStar_TypeChecker_Env.debug
-                                                                    env1)
-                                                                 (FStar_Options.Other
-                                                                    "LayeredEffectsTc") in
-                                                             if uu___21
-                                                             then
-                                                               let uu___22 =
-                                                                 FStar_Syntax_Print.term_to_string
-                                                                   act_defn in
-                                                               let uu___23 =
-                                                                 FStar_Syntax_Print.term_to_string
-                                                                   act_typ1 in
-                                                               FStar_Compiler_Util.print2
-                                                                 "Typechecked action definition: %s and action type: %s\n"
-                                                                 uu___22
-                                                                 uu___23
-                                                             else ());
-                                                            (let uu___21 =
-                                                               let act_typ2 =
-                                                                 FStar_TypeChecker_Normalize.normalize
-                                                                   [FStar_TypeChecker_Env.Beta]
-                                                                   env1
-                                                                   act_typ1 in
-                                                               let uu___22 =
-                                                                 let uu___23
-                                                                   =
-                                                                   FStar_Syntax_Subst.compress
-                                                                    act_typ2 in
-                                                                 uu___23.FStar_Syntax_Syntax.n in
-                                                               match uu___22
-                                                               with
-                                                               | FStar_Syntax_Syntax.Tm_arrow
-                                                                   (bs,
-                                                                    uu___23)
-                                                                   ->
-                                                                   let bs1 =
-                                                                    FStar_Syntax_Subst.open_binders
-                                                                    bs in
-                                                                   let env2 =
-                                                                    FStar_TypeChecker_Env.push_binders
-                                                                    env1 bs1 in
-                                                                   let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Util.type_u
-                                                                    () in
-                                                                   (match uu___24
-                                                                    with
-                                                                    | 
-                                                                    (t, u) ->
-                                                                    let reason
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    ed.FStar_Syntax_Syntax.mname in
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    act1.FStar_Syntax_Syntax.action_name in
-                                                                    FStar_Compiler_Util.format2
-                                                                    "implicit for return type of action %s:%s"
-                                                                    uu___25
-                                                                    uu___26 in
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_TypeChecker_Util.new_implicit_var
-                                                                    reason r
-                                                                    env2 t in
-                                                                    (match uu___25
-                                                                    with
-                                                                    | 
-                                                                    (a_tm,
-                                                                    uu___26,
-                                                                    g_tm) ->
-                                                                    let uu___27
-                                                                    =
-                                                                    fresh_repr
-                                                                    r env2 u
-                                                                    a_tm in
-                                                                    (match uu___27
-                                                                    with
-                                                                    | 
-                                                                    (repr1,
-                                                                    g) ->
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    repr1 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    bs1
-                                                                    uu___29 in
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guard
-                                                                    g g_tm in
-                                                                    (uu___28,
-                                                                    uu___29))))
-                                                               | uu___23 ->
-                                                                   let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    ed.FStar_Syntax_Syntax.mname in
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    act1.FStar_Syntax_Syntax.action_name in
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    act_typ2 in
-                                                                    FStar_Compiler_Util.format3
-                                                                    "Unexpected non-function type for action %s:%s (%s)"
-                                                                    uu___26
-                                                                    uu___27
-                                                                    uu___28 in
-                                                                    (FStar_Errors.Fatal_ActionMustHaveFunctionType,
-                                                                    uu___25) in
-                                                                   FStar_Errors.raise_error
-                                                                    uu___24 r in
-                                                             match uu___21
-                                                             with
-                                                             | (k, g_k) ->
-                                                                 ((let uu___23
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env1)
-                                                                    (FStar_Options.Other
-                                                                    "LayeredEffectsTc") in
-                                                                   if uu___23
-                                                                   then
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    k in
-                                                                    FStar_Compiler_Util.print1
-                                                                    "Expected action type: %s\n"
-                                                                    uu___24
-                                                                   else ());
-                                                                  (let g =
-                                                                    FStar_TypeChecker_Rel.teq
-                                                                    env1
-                                                                    act_typ1
-                                                                    k in
-                                                                   FStar_Compiler_List.iter
-                                                                    (FStar_TypeChecker_Rel.force_trivial_guard
-                                                                    env1)
-                                                                    [g_t;
-                                                                    g_d;
-                                                                    g_k;
-                                                                    g];
-                                                                   (let uu___25
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env1)
-                                                                    (FStar_Options.Other
-                                                                    "LayeredEffectsTc") in
-                                                                    if
-                                                                    uu___25
-                                                                    then
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    k in
-                                                                    FStar_Compiler_Util.print1
-                                                                    "Expected action type after unification: %s\n"
-                                                                    uu___26
-                                                                    else ());
-                                                                   (let act_typ2
-                                                                    =
-                                                                    let err_msg
-                                                                    t =
-                                                                    let uu___25
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    ed.FStar_Syntax_Syntax.mname in
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    act1.FStar_Syntax_Syntax.action_name in
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t in
-                                                                    FStar_Compiler_Util.format3
-                                                                    "Unexpected (k-)type of action %s:%s, expected bs -> repr<u> i_1 ... i_n, found: %s"
-                                                                    uu___25
-                                                                    uu___26
-                                                                    uu___27 in
-                                                                    let repr_args
-                                                                    t =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    t in
-                                                                    uu___26.FStar_Syntax_Syntax.n in
-                                                                    match uu___25
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_app
-                                                                    (head,
-                                                                    a::is) ->
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    head in
-                                                                    uu___27.FStar_Syntax_Syntax.n in
-                                                                    (match uu___26
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_uinst
-                                                                    (uu___27,
-                                                                    us) ->
-                                                                    (us,
-                                                                    (FStar_Pervasives_Native.fst
-                                                                    a), is)
-                                                                    | 
-                                                                    uu___27
-                                                                    ->
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    err_msg t in
-                                                                    (FStar_Errors.Fatal_ActionMustHaveFunctionType,
-                                                                    uu___29) in
-                                                                    FStar_Errors.raise_error
-                                                                    uu___28 r)
-                                                                    | 
-                                                                    uu___26
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    err_msg t in
-                                                                    (FStar_Errors.Fatal_ActionMustHaveFunctionType,
-                                                                    uu___28) in
-                                                                    FStar_Errors.raise_error
-                                                                    uu___27 r in
-                                                                    let k1 =
-                                                                    FStar_TypeChecker_Normalize.normalize
-                                                                    [FStar_TypeChecker_Env.Beta]
-                                                                    env1 k in
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    k1 in
-                                                                    uu___26.FStar_Syntax_Syntax.n in
-                                                                    match uu___25
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_arrow
-                                                                    (bs, c)
-                                                                    ->
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Subst.open_comp
-                                                                    bs c in
-                                                                    (match uu___26
-                                                                    with
-                                                                    | 
-                                                                    (bs1, c1)
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    repr_args
-                                                                    (FStar_Syntax_Util.comp_result
-                                                                    c1) in
-                                                                    (match uu___27
-                                                                    with
-                                                                    | 
-                                                                    (us, a,
-                                                                    is) ->
-                                                                    let ct =
-                                                                    {
-                                                                    FStar_Syntax_Syntax.comp_univs
-                                                                    = us;
-                                                                    FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    (ed.FStar_Syntax_Syntax.mname);
-                                                                    FStar_Syntax_Syntax.result_typ
-                                                                    = a;
-                                                                    FStar_Syntax_Syntax.effect_args
-                                                                    = is;
-                                                                    FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                    } in
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Comp
-                                                                    ct in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    bs1
-                                                                    uu___28))
-                                                                    | 
-                                                                    uu___26
-                                                                    ->
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    err_msg
-                                                                    k1 in
-                                                                    (FStar_Errors.Fatal_ActionMustHaveFunctionType,
-                                                                    uu___28) in
-                                                                    FStar_Errors.raise_error
-                                                                    uu___27 r in
-                                                                    (
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env1)
-                                                                    (FStar_Options.Other
-                                                                    "LayeredEffectsTc") in
-                                                                    if
-                                                                    uu___26
-                                                                    then
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    act_typ2 in
-                                                                    FStar_Compiler_Util.print1
-                                                                    "Action type after injecting it into the monad: %s\n"
-                                                                    uu___27
-                                                                    else ());
-                                                                    (
-                                                                    let act2
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_TypeChecker_Generalize.generalize_universes
-                                                                    env1
-                                                                    act_defn in
-                                                                    match uu___26
-                                                                    with
-                                                                    | 
-                                                                    (us,
-                                                                    act_defn1)
-                                                                    ->
-                                                                    if
-                                                                    act1.FStar_Syntax_Syntax.action_univs
-                                                                    = []
-                                                                    then
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Subst.close_univ_vars
-                                                                    us
-                                                                    act_typ2 in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.action_name
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_name);
-                                                                    FStar_Syntax_Syntax.action_unqualified_name
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_unqualified_name);
-                                                                    FStar_Syntax_Syntax.action_univs
-                                                                    = us;
-                                                                    FStar_Syntax_Syntax.action_params
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_params);
-                                                                    FStar_Syntax_Syntax.action_defn
-                                                                    =
-                                                                    act_defn1;
-                                                                    FStar_Syntax_Syntax.action_typ
-                                                                    = uu___27
-                                                                    }
-                                                                    else
-                                                                    (let uu___28
-                                                                    =
-                                                                    ((FStar_Compiler_List.length
-                                                                    us) =
-                                                                    (FStar_Compiler_List.length
-                                                                    act1.FStar_Syntax_Syntax.action_univs))
-                                                                    &&
-                                                                    (FStar_Compiler_List.forall2
-                                                                    (fun u1
-                                                                    ->
-                                                                    fun u2 ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Syntax.order_univ_name
-                                                                    u1 u2 in
-                                                                    uu___29 =
-                                                                    Prims.int_zero)
-                                                                    us
-                                                                    act1.FStar_Syntax_Syntax.action_univs) in
-                                                                    if
-                                                                    uu___28
-                                                                    then
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Subst.close_univ_vars
-                                                                    act1.FStar_Syntax_Syntax.action_univs
-                                                                    act_typ2 in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.action_name
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_name);
-                                                                    FStar_Syntax_Syntax.action_unqualified_name
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_unqualified_name);
-                                                                    FStar_Syntax_Syntax.action_univs
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_univs);
-                                                                    FStar_Syntax_Syntax.action_params
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_params);
-                                                                    FStar_Syntax_Syntax.action_defn
-                                                                    =
-                                                                    act_defn1;
-                                                                    FStar_Syntax_Syntax.action_typ
-                                                                    = uu___29
-                                                                    }
-                                                                    else
-                                                                    (let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    ed.FStar_Syntax_Syntax.mname in
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    act1.FStar_Syntax_Syntax.action_name in
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_Syntax_Print.univ_names_to_string
-                                                                    us in
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_Syntax_Print.univ_names_to_string
-                                                                    act1.FStar_Syntax_Syntax.action_univs in
-                                                                    FStar_Compiler_Util.format4
-                                                                    "Expected and generalized universes in the declaration for %s:%s are different, input: %s, but after gen: %s"
-                                                                    uu___32
-                                                                    uu___33
-                                                                    uu___34
-                                                                    uu___35 in
-                                                                    (FStar_Errors.Fatal_UnexpectedNumberOfUniverse,
-                                                                    uu___31) in
-                                                                    FStar_Errors.raise_error
-                                                                    uu___30 r)) in
-                                                                    act2))))))))) in
-                                          let reify_sigelt =
-                                            if
-                                              FStar_Compiler_List.contains
-                                                FStar_Syntax_Syntax.Reifiable
-                                                quals
-                                            then
-                                              let env = env0 in
-                                              let r =
-                                                FStar_Ident.range_of_lid
-                                                  ed.FStar_Syntax_Syntax.mname in
-                                              let uu___14 =
-                                                fresh_a_and_u_a "a" in
-                                              match uu___14 with
-                                              | (a, u_a) ->
-                                                  let rest_bs =
-                                                    let signature_ts =
-                                                      let uu___15 = signature in
-                                                      match uu___15 with
-                                                      | (us, t, uu___16) ->
-                                                          (us, t) in
-                                                    let uu___15 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        a.FStar_Syntax_Syntax.binder_bv
-                                                        FStar_Syntax_Syntax.bv_to_name in
-                                                    FStar_TypeChecker_Util.layered_effect_indices_as_binders
-                                                      env r
-                                                      ed.FStar_Syntax_Syntax.mname
-                                                      signature_ts u_a
-                                                      uu___15 in
-                                                  let f_binder =
-                                                    let thunked_t =
-                                                      let uu___15 =
-                                                        let uu___16 =
-                                                          let uu___17 =
-                                                            FStar_Syntax_Syntax.null_bv
-                                                              FStar_Syntax_Syntax.t_unit in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___17
-                                                            FStar_Syntax_Syntax.mk_binder in
-                                                        [uu___16] in
-                                                      let uu___16 =
-                                                        let uu___17 =
-                                                          let uu___18 =
-                                                            FStar_Syntax_Syntax.bv_to_name
-                                                              a.FStar_Syntax_Syntax.binder_bv in
-                                                          let uu___19 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              rest_bs
-                                                              (FStar_Compiler_List.map
-                                                                 (fun b ->
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    b.FStar_Syntax_Syntax.binder_bv in
-                                                                    FStar_Syntax_Syntax.as_arg
-                                                                    uu___20)) in
-                                                          {
-                                                            FStar_Syntax_Syntax.comp_univs
-                                                              = [];
-                                                            FStar_Syntax_Syntax.effect_name
-                                                              =
-                                                              (ed.FStar_Syntax_Syntax.mname);
-                                                            FStar_Syntax_Syntax.result_typ
-                                                              = uu___18;
-                                                            FStar_Syntax_Syntax.effect_args
-                                                              = uu___19;
-                                                            FStar_Syntax_Syntax.flags
-                                                              = []
-                                                          } in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___17
-                                                          FStar_Syntax_Syntax.mk_Comp in
-                                                      FStar_Syntax_Util.arrow
-                                                        uu___15 uu___16 in
-                                                    let uu___15 =
-                                                      FStar_Syntax_Syntax.null_bv
-                                                        thunked_t in
-                                                    FStar_Syntax_Syntax.mk_binder_with_attrs
-                                                      uu___15
-                                                      (FStar_Pervasives_Native.Some
-                                                         FStar_Syntax_Syntax.Equality)
-                                                      [] in
-                                                  let bs = a :: rest_bs in
-                                                  let applied_repr =
-                                                    let repr_ts =
-                                                      let uu___15 = repr in
-                                                      match uu___15 with
-                                                      | (us, t, uu___16) ->
-                                                          (us, t) in
-                                                    let repr1 =
-                                                      let uu___15 =
-                                                        FStar_TypeChecker_Env.inst_tscheme_with
-                                                          repr_ts [u_a] in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___15
-                                                        FStar_Pervasives_Native.snd in
-                                                    let uu___15 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        bs
-                                                        (FStar_Compiler_List.map
-                                                           (fun b ->
-                                                              let uu___16 =
-                                                                FStar_Syntax_Syntax.bv_to_name
-                                                                  b.FStar_Syntax_Syntax.binder_bv in
-                                                              let uu___17 =
-                                                                FStar_Syntax_Util.aqual_of_binder
-                                                                  b in
-                                                              (uu___16,
-                                                                uu___17))) in
-                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                      repr1 uu___15 r in
-                                                  let reify_val_t =
-                                                    let bs1 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        bs
-                                                        (FStar_Compiler_List.map
-                                                           (fun b ->
-                                                              {
-                                                                FStar_Syntax_Syntax.binder_bv
-                                                                  =
-                                                                  (b.FStar_Syntax_Syntax.binder_bv);
-                                                                FStar_Syntax_Syntax.binder_qual
-                                                                  =
-                                                                  (FStar_Pervasives_Native.Some
-                                                                    (FStar_Syntax_Syntax.Implicit
-                                                                    false));
-                                                                FStar_Syntax_Syntax.binder_attrs
-                                                                  = []
-                                                              })) in
-                                                    let uu___15 =
-                                                      if
-                                                        FStar_Compiler_List.contains
-                                                          FStar_Syntax_Syntax.TotalEffect
-                                                          quals
-                                                      then
-                                                        FStar_Syntax_Syntax.mk_Total
-                                                          applied_repr
-                                                      else
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          {
-                                                            FStar_Syntax_Syntax.comp_univs
-                                                              = [];
-                                                            FStar_Syntax_Syntax.effect_name
-                                                              =
-                                                              FStar_Parser_Const.effect_Dv_lid;
-                                                            FStar_Syntax_Syntax.result_typ
-                                                              = applied_repr;
-                                                            FStar_Syntax_Syntax.effect_args
-                                                              = [];
-                                                            FStar_Syntax_Syntax.flags
-                                                              = []
-                                                          }
-                                                          FStar_Syntax_Syntax.mk_Comp in
-                                                    FStar_Syntax_Util.arrow
-                                                      (FStar_Compiler_List.op_At
-                                                         bs1 [f_binder])
-                                                      uu___15 in
-                                                  let uu___15 =
-                                                    FStar_TypeChecker_Generalize.generalize_universes
-                                                      env reify_val_t in
-                                                  (match uu___15 with
-                                                   | (us, reify_val_t1) ->
-                                                       let sig_assume_reify =
-                                                         let lid =
-                                                           FStar_Parser_Const.layered_effect_reify_val_lid
-                                                             ed.FStar_Syntax_Syntax.mname
-                                                             r in
-                                                         {
-                                                           FStar_Syntax_Syntax.sigel
-                                                             =
-                                                             (FStar_Syntax_Syntax.Sig_declare_typ
-                                                                (lid, us,
-                                                                  reify_val_t1));
-                                                           FStar_Syntax_Syntax.sigrng
-                                                             = r;
-                                                           FStar_Syntax_Syntax.sigquals
-                                                             =
-                                                             [FStar_Syntax_Syntax.Assumption];
-                                                           FStar_Syntax_Syntax.sigmeta
-                                                             =
-                                                             FStar_Syntax_Syntax.default_sigmeta;
-                                                           FStar_Syntax_Syntax.sigattrs
-                                                             = [];
-                                                           FStar_Syntax_Syntax.sigopts
-                                                             =
-                                                             FStar_Pervasives_Native.None
-                                                         } in
-                                                       ((let uu___17 =
-                                                           let uu___18 =
-                                                             let uu___19 =
-                                                               FStar_Ident.string_of_lid
-                                                                 ed.FStar_Syntax_Syntax.mname in
-                                                             FStar_Compiler_Util.format1
-                                                               "Reification of indexed effects (%s here) is supported only as a type coercion to the underlying representation type (no support for smt-based reasoning or extraction)"
-                                                               uu___19 in
-                                                           (FStar_Errors.Warning_BleedingEdge_Feature,
-                                                             uu___18) in
-                                                         FStar_Errors.log_issue
-                                                           r uu___17);
-                                                        [sig_assume_reify]))
-                                            else [] in
-                                          let tschemes_of uu___14 k =
-                                            match uu___14 with
-                                            | (us, t, ty) ->
-                                                ((us, t), (us, ty), k) in
-                                          let tschemes_of2 uu___14 =
-                                            match uu___14 with
-                                            | (us, t, ty) ->
-                                                ((us, t), (us, ty)) in
-                                          let combinators =
-                                            FStar_Syntax_Syntax.Layered_eff
-                                              {
-                                                FStar_Syntax_Syntax.l_repr =
-                                                  (tschemes_of2 repr);
-                                                FStar_Syntax_Syntax.l_return
-                                                  =
-                                                  (tschemes_of2 return_repr);
-                                                FStar_Syntax_Syntax.l_bind =
-                                                  (tschemes_of bind_repr
-                                                     (FStar_Pervasives_Native.Some
-                                                        bind_kind));
-                                                FStar_Syntax_Syntax.l_subcomp
-                                                  =
-                                                  (tschemes_of stronger_repr
-                                                     (FStar_Pervasives_Native.Some
-                                                        subcomp_kind));
-                                                FStar_Syntax_Syntax.l_if_then_else
-                                                  =
-                                                  (tschemes_of if_then_else
-                                                     (FStar_Pervasives_Native.Some
-                                                        ite_kind))
-                                              } in
-                                          let uu___14 =
-                                            let uu___15 =
-                                              FStar_Compiler_List.map
-                                                (tc_action env0)
-                                                ed.FStar_Syntax_Syntax.actions in
-                                            {
-                                              FStar_Syntax_Syntax.mname =
-                                                (ed.FStar_Syntax_Syntax.mname);
-                                              FStar_Syntax_Syntax.cattributes
-                                                =
-                                                (ed.FStar_Syntax_Syntax.cattributes);
-                                              FStar_Syntax_Syntax.univs =
-                                                (ed.FStar_Syntax_Syntax.univs);
-                                              FStar_Syntax_Syntax.binders =
-                                                (ed.FStar_Syntax_Syntax.binders);
-                                              FStar_Syntax_Syntax.signature =
-                                                (FStar_Syntax_Syntax.Layered_eff_sig
-                                                   (num_effect_params,
-                                                     (let uu___16 = signature in
-                                                      match uu___16 with
-                                                      | (us, t, uu___17) ->
-                                                          (us, t))));
-                                              FStar_Syntax_Syntax.combinators
-                                                = combinators;
-                                              FStar_Syntax_Syntax.actions =
-                                                uu___15;
-                                              FStar_Syntax_Syntax.eff_attrs =
-                                                (ed.FStar_Syntax_Syntax.eff_attrs)
-                                            } in
-                                          (uu___14, reify_sigelt)))))))))))))
-let (tc_non_layered_eff_decl :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.attribute Prims.list ->
-          FStar_Syntax_Syntax.eff_decl)
-  =
-  fun env0 ->
-    fun ed ->
-      fun _quals ->
-        fun _attrs ->
-          let uu___ =
-            let uu___1 =
-              FStar_Ident.string_of_lid ed.FStar_Syntax_Syntax.mname in
-            FStar_Compiler_Util.format1
-              "While checking effect definition `%s`" uu___1 in
-          FStar_Errors.with_ctx uu___
-            (fun uu___1 ->
-               (let uu___3 =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env0)
-                    (FStar_Options.Other "ED") in
-                if uu___3
-                then
-                  let uu___4 = FStar_Syntax_Print.eff_decl_to_string false ed in
-                  FStar_Compiler_Util.print1
-                    "Typechecking eff_decl: \n\t%s\n" uu___4
-                else ());
-               (let uu___3 =
-                  let uu___4 =
-                    FStar_Syntax_Subst.univ_var_opening
-                      ed.FStar_Syntax_Syntax.univs in
-                  match uu___4 with
-                  | (ed_univs_subst, ed_univs) ->
-                      let bs =
-                        let uu___5 =
-                          FStar_Syntax_Subst.subst_binders ed_univs_subst
-                            ed.FStar_Syntax_Syntax.binders in
-                        FStar_Syntax_Subst.open_binders uu___5 in
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_TypeChecker_Env.push_univ_vars env0 ed_univs in
-                        FStar_TypeChecker_TcTerm.tc_tparams uu___6 bs in
-                      (match uu___5 with
-                       | (bs1, uu___6, uu___7) ->
-                           let uu___8 =
-                             let tmp_t =
-                               let uu___9 =
-                                 FStar_Syntax_Syntax.mk_Total
-                                   FStar_Syntax_Syntax.t_unit in
-                               FStar_Syntax_Util.arrow bs1 uu___9 in
-                             let uu___9 =
-                               FStar_TypeChecker_Generalize.generalize_universes
-                                 env0 tmp_t in
-                             match uu___9 with
-                             | (us, tmp_t1) ->
-                                 let uu___10 =
-                                   let uu___11 =
-                                     let uu___12 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         tmp_t1
-                                         FStar_Syntax_Util.arrow_formals in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___12 FStar_Pervasives_Native.fst in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___11 FStar_Syntax_Subst.close_binders in
-                                 (us, uu___10) in
-                           (match uu___8 with
-                            | (us, bs2) ->
-                                (match ed_univs with
-                                 | [] -> (us, bs2)
-                                 | uu___9 ->
-                                     let uu___10 =
-                                       ((FStar_Compiler_List.length ed_univs)
-                                          = (FStar_Compiler_List.length us))
-                                         &&
-                                         (FStar_Compiler_List.forall2
-                                            (fun u1 ->
-                                               fun u2 ->
-                                                 let uu___11 =
-                                                   FStar_Syntax_Syntax.order_univ_name
-                                                     u1 u2 in
-                                                 uu___11 = Prims.int_zero)
-                                            ed_univs us) in
-                                     if uu___10
-                                     then (us, bs2)
-                                     else
-                                       (let uu___12 =
-                                          let uu___13 =
-                                            let uu___14 =
-                                              FStar_Ident.string_of_lid
-                                                ed.FStar_Syntax_Syntax.mname in
-                                            let uu___15 =
-                                              FStar_Compiler_Util.string_of_int
-                                                (FStar_Compiler_List.length
-                                                   ed_univs) in
-                                            let uu___16 =
-                                              FStar_Compiler_Util.string_of_int
-                                                (FStar_Compiler_List.length
-                                                   us) in
-                                            FStar_Compiler_Util.format3
-                                              "Expected and generalized universes in effect declaration for %s are different, expected: %s, but found %s"
-                                              uu___14 uu___15 uu___16 in
-                                          (FStar_Errors.Fatal_UnexpectedNumberOfUniverse,
-                                            uu___13) in
-                                        let uu___13 =
-                                          FStar_Ident.range_of_lid
-                                            ed.FStar_Syntax_Syntax.mname in
-                                        FStar_Errors.raise_error uu___12
-                                          uu___13)))) in
-                match uu___3 with
-                | (us, bs) ->
-                    let ed1 =
-                      {
-                        FStar_Syntax_Syntax.mname =
-                          (ed.FStar_Syntax_Syntax.mname);
-                        FStar_Syntax_Syntax.cattributes =
-                          (ed.FStar_Syntax_Syntax.cattributes);
-                        FStar_Syntax_Syntax.univs = us;
-                        FStar_Syntax_Syntax.binders = bs;
-                        FStar_Syntax_Syntax.signature =
-                          (ed.FStar_Syntax_Syntax.signature);
-                        FStar_Syntax_Syntax.combinators =
-                          (ed.FStar_Syntax_Syntax.combinators);
-                        FStar_Syntax_Syntax.actions =
-                          (ed.FStar_Syntax_Syntax.actions);
-                        FStar_Syntax_Syntax.eff_attrs =
-                          (ed.FStar_Syntax_Syntax.eff_attrs)
-                      } in
-                    let uu___4 = FStar_Syntax_Subst.univ_var_opening us in
-                    (match uu___4 with
-                     | (ed_univs_subst, ed_univs) ->
-                         let uu___5 =
-                           let uu___6 =
-                             FStar_Syntax_Subst.subst_binders ed_univs_subst
-                               bs in
-                           FStar_Syntax_Subst.open_binders' uu___6 in
-                         (match uu___5 with
-                          | (ed_bs, ed_bs_subst) ->
-                              let ed2 =
-                                let op uu___6 =
-                                  match uu___6 with
-                                  | (us1, t) ->
-                                      let t1 =
-                                        let uu___7 =
-                                          FStar_Syntax_Subst.shift_subst
-                                            ((FStar_Compiler_List.length
-                                                ed_bs)
-                                               +
-                                               (FStar_Compiler_List.length
-                                                  us1)) ed_univs_subst in
-                                        FStar_Syntax_Subst.subst uu___7 t in
-                                      let uu___7 =
-                                        let uu___8 =
-                                          FStar_Syntax_Subst.shift_subst
-                                            (FStar_Compiler_List.length us1)
-                                            ed_bs_subst in
-                                        FStar_Syntax_Subst.subst uu___8 t1 in
-                                      (us1, uu___7) in
-                                let uu___6 =
-                                  FStar_Syntax_Util.apply_eff_sig op
-                                    ed1.FStar_Syntax_Syntax.signature in
-                                let uu___7 =
-                                  FStar_Syntax_Util.apply_eff_combinators op
-                                    ed1.FStar_Syntax_Syntax.combinators in
-                                let uu___8 =
-                                  FStar_Compiler_List.map
-                                    (fun a ->
-                                       let uu___9 =
-                                         let uu___10 =
-                                           op
-                                             ((a.FStar_Syntax_Syntax.action_univs),
-                                               (a.FStar_Syntax_Syntax.action_defn)) in
-                                         FStar_Pervasives_Native.snd uu___10 in
-                                       let uu___10 =
-                                         let uu___11 =
-                                           op
-                                             ((a.FStar_Syntax_Syntax.action_univs),
-                                               (a.FStar_Syntax_Syntax.action_typ)) in
-                                         FStar_Pervasives_Native.snd uu___11 in
-                                       {
-                                         FStar_Syntax_Syntax.action_name =
-                                           (a.FStar_Syntax_Syntax.action_name);
-                                         FStar_Syntax_Syntax.action_unqualified_name
-                                           =
-                                           (a.FStar_Syntax_Syntax.action_unqualified_name);
-                                         FStar_Syntax_Syntax.action_univs =
-                                           (a.FStar_Syntax_Syntax.action_univs);
-                                         FStar_Syntax_Syntax.action_params =
-                                           (a.FStar_Syntax_Syntax.action_params);
-                                         FStar_Syntax_Syntax.action_defn =
-                                           uu___9;
-                                         FStar_Syntax_Syntax.action_typ =
-                                           uu___10
-                                       }) ed1.FStar_Syntax_Syntax.actions in
-                                {
-                                  FStar_Syntax_Syntax.mname =
-                                    (ed1.FStar_Syntax_Syntax.mname);
-                                  FStar_Syntax_Syntax.cattributes =
-                                    (ed1.FStar_Syntax_Syntax.cattributes);
-                                  FStar_Syntax_Syntax.univs =
-                                    (ed1.FStar_Syntax_Syntax.univs);
-                                  FStar_Syntax_Syntax.binders =
-                                    (ed1.FStar_Syntax_Syntax.binders);
-                                  FStar_Syntax_Syntax.signature = uu___6;
-                                  FStar_Syntax_Syntax.combinators = uu___7;
-                                  FStar_Syntax_Syntax.actions = uu___8;
-                                  FStar_Syntax_Syntax.eff_attrs =
-                                    (ed1.FStar_Syntax_Syntax.eff_attrs)
-                                } in
-                              ((let uu___7 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env0)
-                                    (FStar_Options.Other "ED") in
-                                if uu___7
-                                then
-                                  let uu___8 =
-                                    FStar_Syntax_Print.eff_decl_to_string
-                                      false ed2 in
-                                  FStar_Compiler_Util.print1
-                                    "After typechecking binders eff_decl: \n\t%s\n"
-                                    uu___8
-                                else ());
-                               (let env =
-                                  let uu___7 =
-                                    FStar_TypeChecker_Env.push_univ_vars env0
-                                      ed_univs in
-                                  FStar_TypeChecker_Env.push_binders uu___7
-                                    ed_bs in
-                                let check_and_gen' comb n env_opt uu___7 k =
-                                  match uu___7 with
-                                  | (us1, t) ->
-                                      let env1 =
-                                        if
-                                          FStar_Compiler_Util.is_some env_opt
-                                        then
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            env_opt FStar_Compiler_Util.must
-                                        else env in
-                                      let uu___8 =
-                                        FStar_Syntax_Subst.open_univ_vars us1
-                                          t in
-                                      (match uu___8 with
-                                       | (us2, t1) ->
-                                           let t2 =
-                                             match k with
-                                             | FStar_Pervasives_Native.Some
-                                                 k1 ->
-                                                 let uu___9 =
-                                                   FStar_TypeChecker_Env.push_univ_vars
-                                                     env1 us2 in
-                                                 FStar_TypeChecker_TcTerm.tc_check_trivial_guard
-                                                   uu___9 t1 k1
-                                             | FStar_Pervasives_Native.None
-                                                 ->
-                                                 let uu___9 =
-                                                   let uu___10 =
-                                                     FStar_TypeChecker_Env.push_univ_vars
-                                                       env1 us2 in
-                                                   FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                     uu___10 t1 in
-                                                 (match uu___9 with
-                                                  | (t3, uu___10, g) ->
-                                                      (FStar_TypeChecker_Rel.force_trivial_guard
-                                                         env1 g;
-                                                       t3)) in
-                                           let uu___9 =
-                                             FStar_TypeChecker_Generalize.generalize_universes
-                                               env1 t2 in
-                                           (match uu___9 with
-                                            | (g_us, t3) ->
-                                                (if
-                                                   (FStar_Compiler_List.length
-                                                      g_us)
-                                                     <> n
-                                                 then
-                                                   (let error =
-                                                      let uu___11 =
-                                                        FStar_Ident.string_of_lid
-                                                          ed2.FStar_Syntax_Syntax.mname in
-                                                      let uu___12 =
-                                                        FStar_Compiler_Util.string_of_int
-                                                          n in
-                                                      let uu___13 =
-                                                        let uu___14 =
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            g_us
-                                                            FStar_Compiler_List.length in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___14
-                                                          FStar_Compiler_Util.string_of_int in
-                                                      FStar_Compiler_Util.format4
-                                                        "Expected %s:%s to be universe-polymorphic in %s universes, found %s"
-                                                        uu___11 comb uu___12
-                                                        uu___13 in
-                                                    FStar_Errors.raise_error
-                                                      (FStar_Errors.Fatal_MismatchUniversePolymorphic,
-                                                        error)
-                                                      t3.FStar_Syntax_Syntax.pos)
-                                                 else ();
-                                                 (match us2 with
-                                                  | [] -> (g_us, t3)
-                                                  | uu___11 ->
-                                                      let uu___12 =
-                                                        ((FStar_Compiler_List.length
-                                                            us2)
-                                                           =
-                                                           (FStar_Compiler_List.length
-                                                              g_us))
-                                                          &&
-                                                          (FStar_Compiler_List.forall2
-                                                             (fun u1 ->
-                                                                fun u2 ->
-                                                                  let uu___13
-                                                                    =
-                                                                    FStar_Syntax_Syntax.order_univ_name
-                                                                    u1 u2 in
-                                                                  uu___13 =
-                                                                    Prims.int_zero)
-                                                             us2 g_us) in
-                                                      if uu___12
-                                                      then (g_us, t3)
-                                                      else
-                                                        (let uu___14 =
-                                                           let uu___15 =
-                                                             let uu___16 =
-                                                               FStar_Ident.string_of_lid
-                                                                 ed2.FStar_Syntax_Syntax.mname in
-                                                             let uu___17 =
-                                                               FStar_Compiler_Util.string_of_int
-                                                                 (FStar_Compiler_List.length
-                                                                    us2) in
-                                                             let uu___18 =
-                                                               FStar_Compiler_Util.string_of_int
-                                                                 (FStar_Compiler_List.length
-                                                                    g_us) in
-                                                             FStar_Compiler_Util.format4
-                                                               "Expected and generalized universes in the declaration for %s:%s are different, expected: %s, but found %s"
-                                                               uu___16 comb
-                                                               uu___17
-                                                               uu___18 in
-                                                           (FStar_Errors.Fatal_UnexpectedNumberOfUniverse,
-                                                             uu___15) in
-                                                         FStar_Errors.raise_error
-                                                           uu___14
-                                                           t3.FStar_Syntax_Syntax.pos))))) in
-                                let signature =
-                                  let uu___7 =
-                                    FStar_Syntax_Util.effect_sig_ts
-                                      ed2.FStar_Syntax_Syntax.signature in
-                                  check_and_gen' "signature" Prims.int_one
-                                    FStar_Pervasives_Native.None uu___7
-                                    FStar_Pervasives_Native.None in
-                                (let uu___8 =
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env0)
-                                     (FStar_Options.Other "ED") in
-                                 if uu___8
-                                 then
-                                   let uu___9 =
-                                     FStar_Syntax_Print.tscheme_to_string
-                                       signature in
-                                   FStar_Compiler_Util.print1
-                                     "Typechecked signature: %s\n" uu___9
-                                 else ());
-                                (let fresh_a_and_wp uu___8 =
-                                   let fail t =
-                                     let uu___9 =
-                                       FStar_TypeChecker_Err.unexpected_signature_for_monad
-                                         env ed2.FStar_Syntax_Syntax.mname t in
-                                     let uu___10 =
-                                       let uu___11 =
-                                         let uu___12 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             ed2.FStar_Syntax_Syntax.signature
-                                             FStar_Syntax_Util.effect_sig_ts in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___12
-                                           FStar_Pervasives_Native.snd in
-                                       uu___11.FStar_Syntax_Syntax.pos in
-                                     FStar_Errors.raise_error uu___9 uu___10 in
-                                   let uu___9 =
-                                     FStar_TypeChecker_Env.inst_tscheme
-                                       signature in
-                                   match uu___9 with
-                                   | (uu___10, signature1) ->
-                                       let uu___11 =
-                                         let uu___12 =
-                                           FStar_Syntax_Subst.compress
-                                             signature1 in
-                                         uu___12.FStar_Syntax_Syntax.n in
-                                       (match uu___11 with
-                                        | FStar_Syntax_Syntax.Tm_arrow
-                                            (bs1, uu___12) ->
-                                            let bs2 =
-                                              FStar_Syntax_Subst.open_binders
-                                                bs1 in
-                                            (match bs2 with
-                                             | {
-                                                 FStar_Syntax_Syntax.binder_bv
-                                                   = a;
-                                                 FStar_Syntax_Syntax.binder_qual
-                                                   = uu___13;
-                                                 FStar_Syntax_Syntax.binder_attrs
-                                                   = uu___14;_}::{
-                                                                   FStar_Syntax_Syntax.binder_bv
-                                                                    = wp;
-                                                                   FStar_Syntax_Syntax.binder_qual
-                                                                    = uu___15;
-                                                                   FStar_Syntax_Syntax.binder_attrs
-                                                                    = uu___16;_}::[]
-                                                 ->
-                                                 (a,
-                                                   (wp.FStar_Syntax_Syntax.sort))
-                                             | uu___13 -> fail signature1)
-                                        | uu___12 -> fail signature1) in
-                                 let log_combinator s ts =
-                                   let uu___8 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (FStar_TypeChecker_Env.debug env)
-                                       (FStar_Options.Other "ED") in
-                                   if uu___8
-                                   then
-                                     let uu___9 =
-                                       FStar_Ident.string_of_lid
-                                         ed2.FStar_Syntax_Syntax.mname in
-                                     let uu___10 =
-                                       FStar_Syntax_Print.tscheme_to_string
-                                         ts in
-                                     FStar_Compiler_Util.print3
-                                       "Typechecked %s:%s = %s\n" uu___9 s
-                                       uu___10
-                                   else () in
-                                 let ret_wp =
-                                   let uu___8 = fresh_a_and_wp () in
-                                   match uu___8 with
-                                   | (a, wp_sort) ->
-                                       let k =
-                                         let uu___9 =
-                                           let uu___10 =
-                                             FStar_Syntax_Syntax.mk_binder a in
-                                           let uu___11 =
-                                             let uu___12 =
-                                               let uu___13 =
-                                                 FStar_Syntax_Syntax.bv_to_name
-                                                   a in
-                                               FStar_Syntax_Syntax.null_binder
-                                                 uu___13 in
-                                             [uu___12] in
-                                           uu___10 :: uu___11 in
-                                         let uu___10 =
-                                           FStar_Syntax_Syntax.mk_GTotal
-                                             wp_sort in
-                                         FStar_Syntax_Util.arrow uu___9
-                                           uu___10 in
-                                       let uu___9 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           ed2
-                                           FStar_Syntax_Util.get_return_vc_combinator in
-                                       check_and_gen' "ret_wp" Prims.int_one
-                                         FStar_Pervasives_Native.None uu___9
-                                         (FStar_Pervasives_Native.Some k) in
-                                 log_combinator "ret_wp" ret_wp;
-                                 (let bind_wp =
-                                    let uu___9 = fresh_a_and_wp () in
-                                    match uu___9 with
-                                    | (a, wp_sort_a) ->
-                                        let uu___10 = fresh_a_and_wp () in
-                                        (match uu___10 with
-                                         | (b, wp_sort_b) ->
-                                             let wp_sort_a_b =
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     FStar_Syntax_Syntax.bv_to_name
-                                                       a in
-                                                   FStar_Syntax_Syntax.null_binder
-                                                     uu___13 in
-                                                 [uu___12] in
-                                               let uu___12 =
-                                                 FStar_Syntax_Syntax.mk_Total
-                                                   wp_sort_b in
-                                               FStar_Syntax_Util.arrow
-                                                 uu___11 uu___12 in
-                                             let k =
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Syntax_Syntax.mk_binder
-                                                     a in
-                                                 let uu___13 =
-                                                   let uu___14 =
-                                                     FStar_Syntax_Syntax.mk_binder
-                                                       b in
-                                                   let uu___15 =
-                                                     let uu___16 =
-                                                       FStar_Syntax_Syntax.null_binder
-                                                         wp_sort_a in
-                                                     let uu___17 =
-                                                       let uu___18 =
-                                                         FStar_Syntax_Syntax.null_binder
-                                                           wp_sort_a_b in
-                                                       [uu___18] in
-                                                     uu___16 :: uu___17 in
-                                                   uu___14 :: uu___15 in
-                                                 uu___12 :: uu___13 in
-                                               let uu___12 =
-                                                 FStar_Syntax_Syntax.mk_Total
-                                                   wp_sort_b in
-                                               FStar_Syntax_Util.arrow
-                                                 uu___11 uu___12 in
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   ed2
-                                                   FStar_Syntax_Util.get_bind_vc_combinator in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___12
-                                                 FStar_Pervasives_Native.fst in
-                                             check_and_gen' "bind_wp"
-                                               (Prims.of_int (2))
-                                               FStar_Pervasives_Native.None
-                                               uu___11
-                                               (FStar_Pervasives_Native.Some
-                                                  k)) in
-                                  log_combinator "bind_wp" bind_wp;
-                                  (let stronger =
-                                     let uu___10 = fresh_a_and_wp () in
-                                     match uu___10 with
-                                     | (a, wp_sort_a) ->
-                                         let uu___11 =
-                                           FStar_Syntax_Util.type_u () in
-                                         (match uu___11 with
-                                          | (t, uu___12) ->
-                                              let k =
-                                                let uu___13 =
-                                                  let uu___14 =
-                                                    FStar_Syntax_Syntax.mk_binder
-                                                      a in
-                                                  let uu___15 =
-                                                    let uu___16 =
-                                                      FStar_Syntax_Syntax.null_binder
-                                                        wp_sort_a in
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        FStar_Syntax_Syntax.null_binder
-                                                          wp_sort_a in
-                                                      [uu___18] in
-                                                    uu___16 :: uu___17 in
-                                                  uu___14 :: uu___15 in
-                                                let uu___14 =
-                                                  FStar_Syntax_Syntax.mk_Total
-                                                    t in
-                                                FStar_Syntax_Util.arrow
-                                                  uu___13 uu___14 in
-                                              let uu___13 =
-                                                let uu___14 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    ed2
-                                                    FStar_Syntax_Util.get_stronger_vc_combinator in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___14
-                                                  FStar_Pervasives_Native.fst in
-                                              check_and_gen' "stronger"
-                                                Prims.int_one
-                                                FStar_Pervasives_Native.None
-                                                uu___13
-                                                (FStar_Pervasives_Native.Some
-                                                   k)) in
-                                   log_combinator "stronger" stronger;
-                                   (let if_then_else =
-                                      let uu___11 = fresh_a_and_wp () in
-                                      match uu___11 with
-                                      | (a, wp_sort_a) ->
-                                          let p =
-                                            let uu___12 =
-                                              let uu___13 =
-                                                FStar_Ident.range_of_lid
-                                                  ed2.FStar_Syntax_Syntax.mname in
-                                              FStar_Pervasives_Native.Some
-                                                uu___13 in
-                                            let uu___13 =
-                                              let uu___14 =
-                                                FStar_Syntax_Util.type_u () in
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                uu___14
-                                                FStar_Pervasives_Native.fst in
-                                            FStar_Syntax_Syntax.new_bv
-                                              uu___12 uu___13 in
-                                          let k =
-                                            let uu___12 =
-                                              let uu___13 =
-                                                FStar_Syntax_Syntax.mk_binder
-                                                  a in
-                                              let uu___14 =
-                                                let uu___15 =
-                                                  FStar_Syntax_Syntax.mk_binder
-                                                    p in
-                                                let uu___16 =
-                                                  let uu___17 =
-                                                    FStar_Syntax_Syntax.null_binder
-                                                      wp_sort_a in
-                                                  let uu___18 =
-                                                    let uu___19 =
-                                                      FStar_Syntax_Syntax.null_binder
-                                                        wp_sort_a in
-                                                    [uu___19] in
-                                                  uu___17 :: uu___18 in
-                                                uu___15 :: uu___16 in
-                                              uu___13 :: uu___14 in
-                                            let uu___13 =
-                                              FStar_Syntax_Syntax.mk_Total
-                                                wp_sort_a in
-                                            FStar_Syntax_Util.arrow uu___12
-                                              uu___13 in
-                                          let uu___12 =
-                                            let uu___13 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                ed2
-                                                FStar_Syntax_Util.get_wp_if_then_else_combinator in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___13
-                                              FStar_Compiler_Util.must in
-                                          check_and_gen' "if_then_else"
-                                            Prims.int_one
-                                            FStar_Pervasives_Native.None
-                                            uu___12
-                                            (FStar_Pervasives_Native.Some k) in
-                                    log_combinator "if_then_else"
-                                      if_then_else;
-                                    (let ite_wp =
-                                       let uu___12 = fresh_a_and_wp () in
-                                       match uu___12 with
-                                       | (a, wp_sort_a) ->
-                                           let k =
-                                             let uu___13 =
-                                               let uu___14 =
-                                                 FStar_Syntax_Syntax.mk_binder
-                                                   a in
-                                               let uu___15 =
-                                                 let uu___16 =
-                                                   FStar_Syntax_Syntax.null_binder
-                                                     wp_sort_a in
-                                                 [uu___16] in
-                                               uu___14 :: uu___15 in
-                                             let uu___14 =
-                                               FStar_Syntax_Syntax.mk_Total
-                                                 wp_sort_a in
-                                             FStar_Syntax_Util.arrow uu___13
-                                               uu___14 in
-                                           let uu___13 =
-                                             let uu___14 =
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 ed2
-                                                 FStar_Syntax_Util.get_wp_ite_combinator in
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               uu___14
-                                               FStar_Compiler_Util.must in
-                                           check_and_gen' "ite_wp"
-                                             Prims.int_one
-                                             FStar_Pervasives_Native.None
-                                             uu___13
-                                             (FStar_Pervasives_Native.Some k) in
-                                     log_combinator "ite_wp" ite_wp;
-                                     (let close_wp =
-                                        let uu___13 = fresh_a_and_wp () in
-                                        match uu___13 with
-                                        | (a, wp_sort_a) ->
-                                            let b =
-                                              let uu___14 =
-                                                let uu___15 =
-                                                  FStar_Ident.range_of_lid
-                                                    ed2.FStar_Syntax_Syntax.mname in
-                                                FStar_Pervasives_Native.Some
-                                                  uu___15 in
-                                              let uu___15 =
-                                                let uu___16 =
-                                                  FStar_Syntax_Util.type_u () in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___16
-                                                  FStar_Pervasives_Native.fst in
-                                              FStar_Syntax_Syntax.new_bv
-                                                uu___14 uu___15 in
-                                            let wp_sort_b_a =
-                                              let uu___14 =
-                                                let uu___15 =
-                                                  let uu___16 =
-                                                    FStar_Syntax_Syntax.bv_to_name
-                                                      b in
-                                                  FStar_Syntax_Syntax.null_binder
-                                                    uu___16 in
-                                                [uu___15] in
-                                              let uu___15 =
-                                                FStar_Syntax_Syntax.mk_Total
-                                                  wp_sort_a in
-                                              FStar_Syntax_Util.arrow uu___14
-                                                uu___15 in
-                                            let k =
-                                              let uu___14 =
-                                                let uu___15 =
-                                                  FStar_Syntax_Syntax.mk_binder
-                                                    a in
-                                                let uu___16 =
-                                                  let uu___17 =
-                                                    FStar_Syntax_Syntax.mk_binder
-                                                      b in
-                                                  let uu___18 =
-                                                    let uu___19 =
-                                                      FStar_Syntax_Syntax.null_binder
-                                                        wp_sort_b_a in
-                                                    [uu___19] in
-                                                  uu___17 :: uu___18 in
-                                                uu___15 :: uu___16 in
-                                              let uu___15 =
-                                                FStar_Syntax_Syntax.mk_Total
-                                                  wp_sort_a in
-                                              FStar_Syntax_Util.arrow uu___14
-                                                uu___15 in
-                                            let uu___14 =
-                                              let uu___15 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  ed2
-                                                  FStar_Syntax_Util.get_wp_close_combinator in
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                uu___15
-                                                FStar_Compiler_Util.must in
-                                            check_and_gen' "close_wp"
-                                              (Prims.of_int (2))
-                                              FStar_Pervasives_Native.None
-                                              uu___14
-                                              (FStar_Pervasives_Native.Some k) in
-                                      log_combinator "close_wp" close_wp;
-                                      (let trivial =
-                                         let uu___14 = fresh_a_and_wp () in
-                                         match uu___14 with
-                                         | (a, wp_sort_a) ->
-                                             let uu___15 =
-                                               FStar_Syntax_Util.type_u () in
-                                             (match uu___15 with
-                                              | (t, uu___16) ->
-                                                  let k =
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        FStar_Syntax_Syntax.mk_binder
-                                                          a in
-                                                      let uu___19 =
-                                                        let uu___20 =
-                                                          FStar_Syntax_Syntax.null_binder
-                                                            wp_sort_a in
-                                                        [uu___20] in
-                                                      uu___18 :: uu___19 in
-                                                    let uu___18 =
-                                                      FStar_Syntax_Syntax.mk_GTotal
-                                                        t in
-                                                    FStar_Syntax_Util.arrow
-                                                      uu___17 uu___18 in
-                                                  let trivial1 =
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          ed2
-                                                          FStar_Syntax_Util.get_wp_trivial_combinator in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___18
-                                                        FStar_Compiler_Util.must in
-                                                    check_and_gen' "trivial"
-                                                      Prims.int_one
-                                                      FStar_Pervasives_Native.None
-                                                      uu___17
-                                                      (FStar_Pervasives_Native.Some
-                                                         k) in
-                                                  (log_combinator "trivial"
-                                                     trivial1;
-                                                   trivial1)) in
-                                       let uu___14 =
-                                         let uu___15 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             ed2
-                                             FStar_Syntax_Util.get_eff_repr in
-                                         match uu___15 with
-                                         | FStar_Pervasives_Native.None ->
-                                             (FStar_Pervasives_Native.None,
-                                               FStar_Pervasives_Native.None,
-                                               FStar_Pervasives_Native.None,
-                                               (ed2.FStar_Syntax_Syntax.actions))
-                                         | uu___16 ->
-                                             let repr =
-                                               let uu___17 =
-                                                 fresh_a_and_wp () in
-                                               match uu___17 with
-                                               | (a, wp_sort_a) ->
-                                                   let uu___18 =
-                                                     FStar_Syntax_Util.type_u
-                                                       () in
-                                                   (match uu___18 with
-                                                    | (t, uu___19) ->
-                                                        let k =
-                                                          let uu___20 =
-                                                            let uu___21 =
-                                                              FStar_Syntax_Syntax.mk_binder
-                                                                a in
-                                                            let uu___22 =
-                                                              let uu___23 =
-                                                                FStar_Syntax_Syntax.null_binder
-                                                                  wp_sort_a in
-                                                              [uu___23] in
-                                                            uu___21 ::
-                                                              uu___22 in
-                                                          let uu___21 =
-                                                            FStar_Syntax_Syntax.mk_GTotal
-                                                              t in
-                                                          FStar_Syntax_Util.arrow
-                                                            uu___20 uu___21 in
-                                                        let uu___20 =
-                                                          let uu___21 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              ed2
-                                                              FStar_Syntax_Util.get_eff_repr in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___21
-                                                            FStar_Compiler_Util.must in
-                                                        check_and_gen' "repr"
-                                                          Prims.int_one
-                                                          FStar_Pervasives_Native.None
-                                                          uu___20
-                                                          (FStar_Pervasives_Native.Some
-                                                             k)) in
-                                             (log_combinator "repr" repr;
-                                              (let mk_repr' t wp =
-                                                 let uu___18 =
-                                                   FStar_TypeChecker_Env.inst_tscheme
-                                                     repr in
-                                                 match uu___18 with
-                                                 | (uu___19, repr1) ->
-                                                     let repr2 =
-                                                       FStar_TypeChecker_Normalize.normalize
-                                                         [FStar_TypeChecker_Env.EraseUniverses;
-                                                         FStar_TypeChecker_Env.AllowUnboundUniverses]
-                                                         env repr1 in
-                                                     let uu___20 =
-                                                       let uu___21 =
-                                                         let uu___22 =
-                                                           let uu___23 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               t
-                                                               FStar_Syntax_Syntax.as_arg in
-                                                           let uu___24 =
-                                                             let uu___25 =
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 wp
-                                                                 FStar_Syntax_Syntax.as_arg in
-                                                             [uu___25] in
-                                                           uu___23 :: uu___24 in
-                                                         (repr2, uu___22) in
-                                                       FStar_Syntax_Syntax.Tm_app
-                                                         uu___21 in
-                                                     FStar_Syntax_Syntax.mk
-                                                       uu___20
-                                                       FStar_Compiler_Range.dummyRange in
-                                               let mk_repr a wp =
-                                                 let uu___18 =
-                                                   FStar_Syntax_Syntax.bv_to_name
-                                                     a in
-                                                 mk_repr' uu___18 wp in
-                                               let destruct_repr t =
-                                                 let uu___18 =
-                                                   let uu___19 =
-                                                     FStar_Syntax_Subst.compress
-                                                       t in
-                                                   uu___19.FStar_Syntax_Syntax.n in
-                                                 match uu___18 with
-                                                 | FStar_Syntax_Syntax.Tm_app
-                                                     (uu___19,
-                                                      (t1, uu___20)::
-                                                      (wp, uu___21)::[])
-                                                     -> (t1, wp)
-                                                 | uu___19 ->
-                                                     failwith
-                                                       "Unexpected repr type" in
-                                               let return_repr =
-                                                 let return_repr_ts =
-                                                   let uu___18 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       ed2
-                                                       FStar_Syntax_Util.get_return_repr in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___18
-                                                     FStar_Compiler_Util.must in
-                                                 let uu___18 =
-                                                   fresh_a_and_wp () in
-                                                 match uu___18 with
-                                                 | (a, uu___19) ->
-                                                     let x_a =
-                                                       let uu___20 =
-                                                         FStar_Syntax_Syntax.bv_to_name
-                                                           a in
-                                                       FStar_Syntax_Syntax.gen_bv
-                                                         "x_a"
-                                                         FStar_Pervasives_Native.None
-                                                         uu___20 in
-                                                     let res =
-                                                       let wp =
-                                                         let uu___20 =
-                                                           let uu___21 =
-                                                             FStar_TypeChecker_Env.inst_tscheme
-                                                               ret_wp in
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             uu___21
-                                                             FStar_Pervasives_Native.snd in
-                                                         let uu___21 =
-                                                           let uu___22 =
-                                                             let uu___23 =
-                                                               FStar_Syntax_Syntax.bv_to_name
-                                                                 a in
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               uu___23
-                                                               FStar_Syntax_Syntax.as_arg in
-                                                           let uu___23 =
-                                                             let uu___24 =
-                                                               let uu___25 =
-                                                                 FStar_Syntax_Syntax.bv_to_name
-                                                                   x_a in
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 uu___25
-                                                                 FStar_Syntax_Syntax.as_arg in
-                                                             [uu___24] in
-                                                           uu___22 :: uu___23 in
-                                                         FStar_Syntax_Syntax.mk_Tm_app
-                                                           uu___20 uu___21
-                                                           FStar_Compiler_Range.dummyRange in
-                                                       mk_repr a wp in
-                                                     let k =
-                                                       let uu___20 =
-                                                         let uu___21 =
-                                                           FStar_Syntax_Syntax.mk_binder
-                                                             a in
-                                                         let uu___22 =
-                                                           let uu___23 =
-                                                             FStar_Syntax_Syntax.mk_binder
-                                                               x_a in
-                                                           [uu___23] in
-                                                         uu___21 :: uu___22 in
-                                                       let uu___21 =
-                                                         FStar_Syntax_Syntax.mk_Total
-                                                           res in
-                                                       FStar_Syntax_Util.arrow
-                                                         uu___20 uu___21 in
-                                                     let uu___20 =
-                                                       FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                         env k in
-                                                     (match uu___20 with
-                                                      | (k1, uu___21,
-                                                         uu___22) ->
-                                                          let env1 =
-                                                            let uu___23 =
-                                                              FStar_TypeChecker_Env.set_range
-                                                                env
-                                                                (FStar_Pervasives_Native.snd
-                                                                   return_repr_ts).FStar_Syntax_Syntax.pos in
-                                                            FStar_Pervasives_Native.Some
-                                                              uu___23 in
-                                                          check_and_gen'
-                                                            "return_repr"
-                                                            Prims.int_one
-                                                            env1
-                                                            return_repr_ts
-                                                            (FStar_Pervasives_Native.Some
-                                                               k1)) in
-                                               log_combinator "return_repr"
-                                                 return_repr;
-                                               (let bind_repr =
-                                                  let bind_repr_ts =
-                                                    let uu___19 =
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        ed2
-                                                        FStar_Syntax_Util.get_bind_repr in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      uu___19
-                                                      FStar_Compiler_Util.must in
-                                                  let uu___19 =
-                                                    fresh_a_and_wp () in
-                                                  match uu___19 with
-                                                  | (a, wp_sort_a) ->
-                                                      let uu___20 =
-                                                        fresh_a_and_wp () in
-                                                      (match uu___20 with
-                                                       | (b, wp_sort_b) ->
-                                                           let wp_sort_a_b =
-                                                             let uu___21 =
-                                                               let uu___22 =
-                                                                 let uu___23
-                                                                   =
-                                                                   FStar_Syntax_Syntax.bv_to_name
-                                                                    a in
-                                                                 FStar_Syntax_Syntax.null_binder
-                                                                   uu___23 in
-                                                               [uu___22] in
-                                                             let uu___22 =
-                                                               FStar_Syntax_Syntax.mk_Total
-                                                                 wp_sort_b in
-                                                             FStar_Syntax_Util.arrow
-                                                               uu___21
-                                                               uu___22 in
-                                                           let wp_f =
-                                                             FStar_Syntax_Syntax.gen_bv
-                                                               "wp_f"
-                                                               FStar_Pervasives_Native.None
-                                                               wp_sort_a in
-                                                           let wp_g =
-                                                             FStar_Syntax_Syntax.gen_bv
-                                                               "wp_g"
-                                                               FStar_Pervasives_Native.None
-                                                               wp_sort_a_b in
-                                                           let x_a =
-                                                             let uu___21 =
-                                                               FStar_Syntax_Syntax.bv_to_name
-                                                                 a in
-                                                             FStar_Syntax_Syntax.gen_bv
-                                                               "x_a"
-                                                               FStar_Pervasives_Native.None
-                                                               uu___21 in
-                                                           let wp_g_x =
-                                                             let uu___21 =
-                                                               FStar_Syntax_Syntax.bv_to_name
-                                                                 wp_g in
-                                                             let uu___22 =
-                                                               let uu___23 =
-                                                                 let uu___24
-                                                                   =
-                                                                   FStar_Syntax_Syntax.bv_to_name
-                                                                    x_a in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___24
-                                                                   FStar_Syntax_Syntax.as_arg in
-                                                               [uu___23] in
-                                                             FStar_Syntax_Syntax.mk_Tm_app
-                                                               uu___21
-                                                               uu___22
-                                                               FStar_Compiler_Range.dummyRange in
-                                                           let res =
-                                                             let wp =
-                                                               let uu___21 =
-                                                                 let uu___22
-                                                                   =
-                                                                   FStar_TypeChecker_Env.inst_tscheme
-                                                                    bind_wp in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___22
-                                                                   FStar_Pervasives_Native.snd in
-                                                               let uu___22 =
-                                                                 let uu___23
-                                                                   =
-                                                                   let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    a in
-                                                                   let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    b in
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    wp_f in
-                                                                    let uu___29
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    wp_g in
-                                                                    [uu___30] in
-                                                                    uu___28
-                                                                    ::
-                                                                    uu___29 in
-                                                                    uu___26
-                                                                    ::
-                                                                    uu___27 in
-                                                                   uu___24 ::
-                                                                    uu___25 in
-                                                                 FStar_Compiler_List.map
-                                                                   FStar_Syntax_Syntax.as_arg
-                                                                   uu___23 in
-                                                               FStar_Syntax_Syntax.mk_Tm_app
-                                                                 uu___21
-                                                                 uu___22
-                                                                 FStar_Compiler_Range.dummyRange in
-                                                             mk_repr b wp in
-                                                           let maybe_range_arg
-                                                             =
-                                                             let uu___21 =
-                                                               FStar_Compiler_Util.for_some
-                                                                 (FStar_Syntax_Util.attr_eq
-                                                                    FStar_Syntax_Util.dm4f_bind_range_attr)
-                                                                 ed2.FStar_Syntax_Syntax.eff_attrs in
-                                                             if uu___21
-                                                             then
-                                                               let uu___22 =
-                                                                 FStar_Syntax_Syntax.null_binder
-                                                                   FStar_Syntax_Syntax.t_range in
-                                                               let uu___23 =
-                                                                 let uu___24
-                                                                   =
-                                                                   FStar_Syntax_Syntax.null_binder
-                                                                    FStar_Syntax_Syntax.t_range in
-                                                                 [uu___24] in
-                                                               uu___22 ::
-                                                                 uu___23
-                                                             else [] in
-                                                           let k =
-                                                             let uu___21 =
-                                                               let uu___22 =
-                                                                 let uu___23
-                                                                   =
-                                                                   FStar_Syntax_Syntax.mk_binder
-                                                                    a in
-                                                                 let uu___24
-                                                                   =
-                                                                   let uu___25
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    b in
-                                                                   [uu___25] in
-                                                                 uu___23 ::
-                                                                   uu___24 in
-                                                               let uu___23 =
-                                                                 let uu___24
-                                                                   =
-                                                                   let uu___25
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    wp_f in
-                                                                   let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    wp_f in
-                                                                    mk_repr a
-                                                                    uu___29 in
-                                                                    FStar_Syntax_Syntax.null_binder
-                                                                    uu___28 in
-                                                                    let uu___28
-                                                                    =
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    wp_g in
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    x_a in
-                                                                    [uu___34] in
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    mk_repr b
-                                                                    wp_g_x in
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    uu___35 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    uu___33
-                                                                    uu___34 in
-                                                                    FStar_Syntax_Syntax.null_binder
-                                                                    uu___32 in
-                                                                    [uu___31] in
-                                                                    uu___29
-                                                                    ::
-                                                                    uu___30 in
-                                                                    uu___27
-                                                                    ::
-                                                                    uu___28 in
-                                                                   uu___25 ::
-                                                                    uu___26 in
-                                                                 FStar_Compiler_List.op_At
-                                                                   maybe_range_arg
-                                                                   uu___24 in
-                                                               FStar_Compiler_List.op_At
-                                                                 uu___22
-                                                                 uu___23 in
-                                                             let uu___22 =
-                                                               FStar_Syntax_Syntax.mk_Total
-                                                                 res in
-                                                             FStar_Syntax_Util.arrow
-                                                               uu___21
-                                                               uu___22 in
-                                                           let uu___21 =
-                                                             FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                               env k in
-                                                           (match uu___21
-                                                            with
-                                                            | (k1, uu___22,
-                                                               uu___23) ->
-                                                                let env1 =
-                                                                  FStar_TypeChecker_Env.set_range
-                                                                    env
-                                                                    (FStar_Pervasives_Native.snd
-                                                                    bind_repr_ts).FStar_Syntax_Syntax.pos in
-                                                                let env2 =
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    {
-                                                                    FStar_TypeChecker_Env.solver
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.solver);
-                                                                    FStar_TypeChecker_Env.range
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.range);
-                                                                    FStar_TypeChecker_Env.curmodule
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.curmodule);
-                                                                    FStar_TypeChecker_Env.gamma
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma);
-                                                                    FStar_TypeChecker_Env.gamma_sig
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma_sig);
-                                                                    FStar_TypeChecker_Env.gamma_cache
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma_cache);
-                                                                    FStar_TypeChecker_Env.modules
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.modules);
-                                                                    FStar_TypeChecker_Env.expected_typ
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.expected_typ);
-                                                                    FStar_TypeChecker_Env.sigtab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.sigtab);
-                                                                    FStar_TypeChecker_Env.attrtab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.attrtab);
-                                                                    FStar_TypeChecker_Env.instantiate_imp
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                                                    FStar_TypeChecker_Env.effects
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.effects);
-                                                                    FStar_TypeChecker_Env.generalize
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.generalize);
-                                                                    FStar_TypeChecker_Env.letrecs
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.letrecs);
-                                                                    FStar_TypeChecker_Env.top_level
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.top_level);
-                                                                    FStar_TypeChecker_Env.check_uvars
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.check_uvars);
-                                                                    FStar_TypeChecker_Env.use_eq_strict
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                                                    FStar_TypeChecker_Env.is_iface
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.is_iface);
-                                                                    FStar_TypeChecker_Env.admit
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.admit);
-                                                                    FStar_TypeChecker_Env.lax
-                                                                    = true;
-                                                                    FStar_TypeChecker_Env.lax_universes
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.lax_universes);
-                                                                    FStar_TypeChecker_Env.phase1
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.phase1);
-                                                                    FStar_TypeChecker_Env.failhard
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.failhard);
-                                                                    FStar_TypeChecker_Env.nosynth
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.nosynth);
-                                                                    FStar_TypeChecker_Env.uvar_subtyping
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                                                    FStar_TypeChecker_Env.tc_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.tc_term);
-                                                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.universe_of
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.universe_of);
-                                                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.teq_nosmt_force
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                                    FStar_TypeChecker_Env.normalized_eff_names
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                                                    FStar_TypeChecker_Env.fv_delta_depths
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                                                    FStar_TypeChecker_Env.proof_ns
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.proof_ns);
-                                                                    FStar_TypeChecker_Env.synth_hook
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.synth_hook);
-                                                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                                    FStar_TypeChecker_Env.splice
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.splice);
-                                                                    FStar_TypeChecker_Env.mpreprocess
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.mpreprocess);
-                                                                    FStar_TypeChecker_Env.postprocess
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.postprocess);
-                                                                    FStar_TypeChecker_Env.identifier_info
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.identifier_info);
-                                                                    FStar_TypeChecker_Env.tc_hooks
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.tc_hooks);
-                                                                    FStar_TypeChecker_Env.dsenv
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.dsenv);
-                                                                    FStar_TypeChecker_Env.nbe
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.nbe);
-                                                                    FStar_TypeChecker_Env.strict_args_tab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                                                    FStar_TypeChecker_Env.erasable_types_tab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                                    FStar_TypeChecker_Env.erase_erasable_args
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                                                    FStar_TypeChecker_Env.core_check
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.core_check)
-                                                                    }
-                                                                    (
-                                                                    fun
-                                                                    uu___24
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___24) in
-                                                                check_and_gen'
-                                                                  "bind_repr"
-                                                                  (Prims.of_int (2))
-                                                                  env2
-                                                                  bind_repr_ts
-                                                                  (FStar_Pervasives_Native.Some
-                                                                    k1))) in
-                                                log_combinator "bind_repr"
-                                                  bind_repr;
-                                                (let actions =
-                                                   let check_action act =
-                                                     if
-                                                       (FStar_Compiler_List.length
-                                                          act.FStar_Syntax_Syntax.action_params)
-                                                         <> Prims.int_zero
-                                                     then
-                                                       failwith
-                                                         "tc_eff_decl: expected action_params to be empty"
-                                                     else ();
-                                                     (let uu___21 =
-                                                        if
-                                                          act.FStar_Syntax_Syntax.action_univs
-                                                            = []
-                                                        then (env, act)
-                                                        else
-                                                          (let uu___23 =
-                                                             FStar_Syntax_Subst.univ_var_opening
-                                                               act.FStar_Syntax_Syntax.action_univs in
-                                                           match uu___23 with
-                                                           | (usubst, uvs) ->
-                                                               let uu___24 =
-                                                                 FStar_TypeChecker_Env.push_univ_vars
-                                                                   env uvs in
-                                                               let uu___25 =
-                                                                 let uu___26
-                                                                   =
-                                                                   FStar_Syntax_Subst.subst
-                                                                    usubst
-                                                                    act.FStar_Syntax_Syntax.action_defn in
-                                                                 let uu___27
-                                                                   =
-                                                                   FStar_Syntax_Subst.subst
-                                                                    usubst
-                                                                    act.FStar_Syntax_Syntax.action_typ in
-                                                                 {
-                                                                   FStar_Syntax_Syntax.action_name
-                                                                    =
-                                                                    (act.FStar_Syntax_Syntax.action_name);
-                                                                   FStar_Syntax_Syntax.action_unqualified_name
-                                                                    =
-                                                                    (act.FStar_Syntax_Syntax.action_unqualified_name);
-                                                                   FStar_Syntax_Syntax.action_univs
-                                                                    = uvs;
-                                                                   FStar_Syntax_Syntax.action_params
-                                                                    =
-                                                                    (act.FStar_Syntax_Syntax.action_params);
-                                                                   FStar_Syntax_Syntax.action_defn
-                                                                    = uu___26;
-                                                                   FStar_Syntax_Syntax.action_typ
-                                                                    = uu___27
-                                                                 } in
-                                                               (uu___24,
-                                                                 uu___25)) in
-                                                      match uu___21 with
-                                                      | (env1, act1) ->
-                                                          let act_typ =
-                                                            let uu___22 =
-                                                              let uu___23 =
-                                                                FStar_Syntax_Subst.compress
-                                                                  act1.FStar_Syntax_Syntax.action_typ in
-                                                              uu___23.FStar_Syntax_Syntax.n in
-                                                            match uu___22
-                                                            with
-                                                            | FStar_Syntax_Syntax.Tm_arrow
-                                                                (bs1, c) ->
-                                                                let c1 =
-                                                                  FStar_TypeChecker_Env.comp_to_comp_typ
-                                                                    env1 c in
-                                                                let uu___23 =
-                                                                  FStar_Ident.lid_equals
-                                                                    c1.FStar_Syntax_Syntax.effect_name
-                                                                    ed2.FStar_Syntax_Syntax.mname in
-                                                                if uu___23
-                                                                then
-                                                                  let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    let uu___27
-                                                                    =
-                                                                    FStar_Compiler_List.hd
-                                                                    c1.FStar_Syntax_Syntax.effect_args in
-                                                                    FStar_Pervasives_Native.fst
-                                                                    uu___27 in
-                                                                    mk_repr'
-                                                                    c1.FStar_Syntax_Syntax.result_typ
-                                                                    uu___26 in
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    uu___25 in
-                                                                  FStar_Syntax_Util.arrow
-                                                                    bs1
-                                                                    uu___24
-                                                                else
-                                                                  act1.FStar_Syntax_Syntax.action_typ
-                                                            | uu___23 ->
-                                                                act1.FStar_Syntax_Syntax.action_typ in
-                                                          let uu___22 =
-                                                            FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                              env1 act_typ in
-                                                          (match uu___22 with
-                                                           | (act_typ1,
-                                                              uu___23, g_t)
-                                                               ->
-                                                               let env' =
-                                                                 let uu___24
-                                                                   =
-                                                                   FStar_TypeChecker_Env.set_expected_typ
-                                                                    env1
-                                                                    act_typ1 in
-                                                                 {
-                                                                   FStar_TypeChecker_Env.solver
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.solver);
-                                                                   FStar_TypeChecker_Env.range
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.range);
-                                                                   FStar_TypeChecker_Env.curmodule
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.curmodule);
-                                                                   FStar_TypeChecker_Env.gamma
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.gamma);
-                                                                   FStar_TypeChecker_Env.gamma_sig
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.gamma_sig);
-                                                                   FStar_TypeChecker_Env.gamma_cache
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.gamma_cache);
-                                                                   FStar_TypeChecker_Env.modules
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.modules);
-                                                                   FStar_TypeChecker_Env.expected_typ
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.expected_typ);
-                                                                   FStar_TypeChecker_Env.sigtab
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.sigtab);
-                                                                   FStar_TypeChecker_Env.attrtab
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.attrtab);
-                                                                   FStar_TypeChecker_Env.instantiate_imp
-                                                                    = false;
-                                                                   FStar_TypeChecker_Env.effects
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.effects);
-                                                                   FStar_TypeChecker_Env.generalize
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.generalize);
-                                                                   FStar_TypeChecker_Env.letrecs
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.letrecs);
-                                                                   FStar_TypeChecker_Env.top_level
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.top_level);
-                                                                   FStar_TypeChecker_Env.check_uvars
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.check_uvars);
-                                                                   FStar_TypeChecker_Env.use_eq_strict
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.use_eq_strict);
-                                                                   FStar_TypeChecker_Env.is_iface
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.is_iface);
-                                                                   FStar_TypeChecker_Env.admit
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.admit);
-                                                                   FStar_TypeChecker_Env.lax
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.lax);
-                                                                   FStar_TypeChecker_Env.lax_universes
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.lax_universes);
-                                                                   FStar_TypeChecker_Env.phase1
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.phase1);
-                                                                   FStar_TypeChecker_Env.failhard
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.failhard);
-                                                                   FStar_TypeChecker_Env.nosynth
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.nosynth);
-                                                                   FStar_TypeChecker_Env.uvar_subtyping
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.uvar_subtyping);
-                                                                   FStar_TypeChecker_Env.tc_term
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.tc_term);
-                                                                   FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                                   FStar_TypeChecker_Env.universe_of
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.universe_of);
-                                                                   FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                                   FStar_TypeChecker_Env.teq_nosmt_force
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                                   FStar_TypeChecker_Env.subtype_nosmt_force
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                                   FStar_TypeChecker_Env.qtbl_name_and_index
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                                   FStar_TypeChecker_Env.normalized_eff_names
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.normalized_eff_names);
-                                                                   FStar_TypeChecker_Env.fv_delta_depths
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.fv_delta_depths);
-                                                                   FStar_TypeChecker_Env.proof_ns
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.proof_ns);
-                                                                   FStar_TypeChecker_Env.synth_hook
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.synth_hook);
-                                                                   FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                                   FStar_TypeChecker_Env.splice
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.splice);
-                                                                   FStar_TypeChecker_Env.mpreprocess
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.mpreprocess);
-                                                                   FStar_TypeChecker_Env.postprocess
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.postprocess);
-                                                                   FStar_TypeChecker_Env.identifier_info
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.identifier_info);
-                                                                   FStar_TypeChecker_Env.tc_hooks
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.tc_hooks);
-                                                                   FStar_TypeChecker_Env.dsenv
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.dsenv);
-                                                                   FStar_TypeChecker_Env.nbe
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.nbe);
-                                                                   FStar_TypeChecker_Env.strict_args_tab
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.strict_args_tab);
-                                                                   FStar_TypeChecker_Env.erasable_types_tab
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.erasable_types_tab);
-                                                                   FStar_TypeChecker_Env.enable_defer_to_tac
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                                   FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                                   FStar_TypeChecker_Env.erase_erasable_args
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.erase_erasable_args);
-                                                                   FStar_TypeChecker_Env.core_check
-                                                                    =
-                                                                    (uu___24.FStar_TypeChecker_Env.core_check)
-                                                                 } in
-                                                               ((let uu___25
-                                                                   =
-                                                                   FStar_TypeChecker_Env.debug
-                                                                    env1
-                                                                    (FStar_Options.Other
-                                                                    "ED") in
-                                                                 if uu___25
-                                                                 then
-                                                                   let uu___26
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    act1.FStar_Syntax_Syntax.action_name in
-                                                                   let uu___27
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    act1.FStar_Syntax_Syntax.action_defn in
-                                                                   let uu___28
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    act_typ1 in
-                                                                   FStar_Compiler_Util.print3
-                                                                    "Checking action %s:\n[definition]: %s\n[cps'd type]: %s\n"
-                                                                    uu___26
-                                                                    uu___27
-                                                                    uu___28
-                                                                 else ());
-                                                                (let uu___25
-                                                                   =
-                                                                   FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                                    env'
-                                                                    act1.FStar_Syntax_Syntax.action_defn in
-                                                                 match uu___25
-                                                                 with
-                                                                 | (act_defn,
-                                                                    uu___26,
-                                                                    g_a) ->
-                                                                    ((
-                                                                    let uu___28
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guards
-                                                                    [g_a;
-                                                                    g_t] in
-                                                                    FStar_TypeChecker_Rel.force_trivial_guard
-                                                                    env1
-                                                                    uu___28);
-                                                                    (let act_defn1
-                                                                    =
-                                                                    FStar_TypeChecker_Normalize.normalize
-                                                                    [
-                                                                    FStar_TypeChecker_Env.UnfoldUntil
-                                                                    FStar_Syntax_Syntax.delta_constant]
-                                                                    env1
-                                                                    act_defn in
-                                                                    let act_typ2
-                                                                    =
-                                                                    FStar_TypeChecker_Normalize.normalize
-                                                                    [
-                                                                    FStar_TypeChecker_Env.UnfoldUntil
-                                                                    FStar_Syntax_Syntax.delta_constant;
-                                                                    FStar_TypeChecker_Env.Eager_unfolding;
-                                                                    FStar_TypeChecker_Env.Beta]
-                                                                    env1
-                                                                    act_typ1 in
-                                                                    let uu___28
-                                                                    =
-                                                                    let act_typ3
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    act_typ2 in
-                                                                    match 
-                                                                    act_typ3.FStar_Syntax_Syntax.n
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_arrow
-                                                                    (bs1, c)
-                                                                    ->
-                                                                    let uu___29
-                                                                    =
-                                                                    FStar_Syntax_Subst.open_comp
-                                                                    bs1 c in
-                                                                    (match uu___29
-                                                                    with
-                                                                    | 
-                                                                    (bs2,
-                                                                    uu___30)
-                                                                    ->
-                                                                    let res =
-                                                                    mk_repr'
-                                                                    FStar_Syntax_Syntax.tun
-                                                                    FStar_Syntax_Syntax.tun in
-                                                                    let k =
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Total
-                                                                    res in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    bs2
-                                                                    uu___31 in
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                                                    env1 k in
-                                                                    (match uu___31
-                                                                    with
-                                                                    | 
-                                                                    (k1,
-                                                                    uu___32,
-                                                                    g) ->
-                                                                    (k1, g)))
-                                                                    | 
-                                                                    uu___29
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    act_typ3 in
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Syntax_Print.tag_of_term
-                                                                    act_typ3 in
-                                                                    FStar_Compiler_Util.format2
-                                                                    "Actions must have function types (not: %s, a.k.a. %s)"
-                                                                    uu___32
-                                                                    uu___33 in
-                                                                    (FStar_Errors.Fatal_ActionMustHaveFunctionType,
-                                                                    uu___31) in
-                                                                    FStar_Errors.raise_error
-                                                                    uu___30
-                                                                    act_defn1.FStar_Syntax_Syntax.pos in
-                                                                    match uu___28
-                                                                    with
-                                                                    | 
-                                                                    (expected_k,
-                                                                    g_k) ->
-                                                                    ((
-                                                                    let g =
-                                                                    FStar_TypeChecker_Rel.teq
-                                                                    env1
-                                                                    act_typ2
-                                                                    expected_k in
-                                                                    let g1 =
-                                                                    FStar_TypeChecker_Env.conj_guard
-                                                                    g g_k in
-                                                                    match 
-                                                                    g1.FStar_TypeChecker_Common.guard_f
-                                                                    with
-                                                                    | 
-                                                                    FStar_TypeChecker_Common.NonTrivial
-                                                                    uu___30
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    let uu___32
-                                                                    =
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    act_typ2 in
-                                                                    FStar_Compiler_Util.format1
-                                                                    "Unexpected non trivial guard formula when checking action type shape (%s)"
-                                                                    uu___33 in
-                                                                    (FStar_Errors.Fatal_ActionMustHaveFunctionType,
-                                                                    uu___32) in
-                                                                    FStar_Errors.raise_error
-                                                                    uu___31
-                                                                    act_defn1.FStar_Syntax_Syntax.pos
-                                                                    | 
-                                                                    FStar_TypeChecker_Common.Trivial
-                                                                    ->
-                                                                    let uu___30
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guards
-                                                                    [g_k; g1] in
-                                                                    FStar_TypeChecker_Rel.force_trivial_guard
-                                                                    {
-                                                                    FStar_TypeChecker_Env.solver
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.solver);
-                                                                    FStar_TypeChecker_Env.range
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.range);
-                                                                    FStar_TypeChecker_Env.curmodule
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.curmodule);
-                                                                    FStar_TypeChecker_Env.gamma
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma);
-                                                                    FStar_TypeChecker_Env.gamma_sig
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma_sig);
-                                                                    FStar_TypeChecker_Env.gamma_cache
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.gamma_cache);
-                                                                    FStar_TypeChecker_Env.modules
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.modules);
-                                                                    FStar_TypeChecker_Env.expected_typ
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.expected_typ);
-                                                                    FStar_TypeChecker_Env.sigtab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.sigtab);
-                                                                    FStar_TypeChecker_Env.attrtab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.attrtab);
-                                                                    FStar_TypeChecker_Env.instantiate_imp
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.instantiate_imp);
-                                                                    FStar_TypeChecker_Env.effects
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.effects);
-                                                                    FStar_TypeChecker_Env.generalize
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.generalize);
-                                                                    FStar_TypeChecker_Env.letrecs
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.letrecs);
-                                                                    FStar_TypeChecker_Env.top_level
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.top_level);
-                                                                    FStar_TypeChecker_Env.check_uvars
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.check_uvars);
-                                                                    FStar_TypeChecker_Env.use_eq_strict
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.use_eq_strict);
-                                                                    FStar_TypeChecker_Env.is_iface
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.is_iface);
-                                                                    FStar_TypeChecker_Env.admit
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.admit);
-                                                                    FStar_TypeChecker_Env.lax
-                                                                    = true;
-                                                                    FStar_TypeChecker_Env.lax_universes
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.lax_universes);
-                                                                    FStar_TypeChecker_Env.phase1
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.phase1);
-                                                                    FStar_TypeChecker_Env.failhard
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.failhard);
-                                                                    FStar_TypeChecker_Env.nosynth
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.nosynth);
-                                                                    FStar_TypeChecker_Env.uvar_subtyping
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.uvar_subtyping);
-                                                                    FStar_TypeChecker_Env.tc_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.tc_term);
-                                                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.universe_of
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.universe_of);
-                                                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.teq_nosmt_force
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                                    FStar_TypeChecker_Env.normalized_eff_names
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.normalized_eff_names);
-                                                                    FStar_TypeChecker_Env.fv_delta_depths
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.fv_delta_depths);
-                                                                    FStar_TypeChecker_Env.proof_ns
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.proof_ns);
-                                                                    FStar_TypeChecker_Env.synth_hook
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.synth_hook);
-                                                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                                    FStar_TypeChecker_Env.splice
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.splice);
-                                                                    FStar_TypeChecker_Env.mpreprocess
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.mpreprocess);
-                                                                    FStar_TypeChecker_Env.postprocess
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.postprocess);
-                                                                    FStar_TypeChecker_Env.identifier_info
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.identifier_info);
-                                                                    FStar_TypeChecker_Env.tc_hooks
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.tc_hooks);
-                                                                    FStar_TypeChecker_Env.dsenv
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.dsenv);
-                                                                    FStar_TypeChecker_Env.nbe
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.nbe);
-                                                                    FStar_TypeChecker_Env.strict_args_tab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.strict_args_tab);
-                                                                    FStar_TypeChecker_Env.erasable_types_tab
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.erasable_types_tab);
-                                                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                                    FStar_TypeChecker_Env.erase_erasable_args
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.erase_erasable_args);
-                                                                    FStar_TypeChecker_Env.core_check
-                                                                    =
-                                                                    (env1.FStar_TypeChecker_Env.core_check)
-                                                                    } uu___30);
-                                                                    (let act_typ3
-                                                                    =
-                                                                    let uu___30
-                                                                    =
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Subst.compress
-                                                                    expected_k in
-                                                                    uu___31.FStar_Syntax_Syntax.n in
-                                                                    match uu___30
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_arrow
-                                                                    (bs1, c)
-                                                                    ->
-                                                                    let uu___31
-                                                                    =
-                                                                    FStar_Syntax_Subst.open_comp
-                                                                    bs1 c in
-                                                                    (match uu___31
-                                                                    with
-                                                                    | 
-                                                                    (bs2, c1)
-                                                                    ->
-                                                                    let uu___32
-                                                                    =
-                                                                    destruct_repr
-                                                                    (FStar_Syntax_Util.comp_result
-                                                                    c1) in
-                                                                    (match uu___32
-                                                                    with
-                                                                    | 
-                                                                    (a, wp)
-                                                                    ->
-                                                                    let c2 =
-                                                                    let uu___33
-                                                                    =
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_TypeChecker_Env.push_binders
-                                                                    env1 bs2 in
-                                                                    env1.FStar_TypeChecker_Env.universe_of
-                                                                    uu___35 a in
-                                                                    [uu___34] in
-                                                                    let uu___34
-                                                                    =
-                                                                    let uu___35
-                                                                    =
-                                                                    FStar_Syntax_Syntax.as_arg
-                                                                    wp in
-                                                                    [uu___35] in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.comp_univs
-                                                                    = uu___33;
-                                                                    FStar_Syntax_Syntax.effect_name
-                                                                    =
-                                                                    (ed2.FStar_Syntax_Syntax.mname);
-                                                                    FStar_Syntax_Syntax.result_typ
-                                                                    = a;
-                                                                    FStar_Syntax_Syntax.effect_args
-                                                                    = uu___34;
-                                                                    FStar_Syntax_Syntax.flags
-                                                                    = []
-                                                                    } in
-                                                                    let uu___33
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_Comp
-                                                                    c2 in
-                                                                    FStar_Syntax_Util.arrow
-                                                                    bs2
-                                                                    uu___33))
-                                                                    | 
-                                                                    uu___31
-                                                                    ->
-                                                                    failwith
-                                                                    "Impossible (expected_k is an arrow)" in
-                                                                    let uu___30
-                                                                    =
-                                                                    if
-                                                                    act1.FStar_Syntax_Syntax.action_univs
-                                                                    = []
-                                                                    then
-                                                                    FStar_TypeChecker_Generalize.generalize_universes
-                                                                    env1
-                                                                    act_defn1
-                                                                    else
-                                                                    (let uu___32
-                                                                    =
-                                                                    FStar_Syntax_Subst.close_univ_vars
-                                                                    act1.FStar_Syntax_Syntax.action_univs
-                                                                    act_defn1 in
-                                                                    ((act1.FStar_Syntax_Syntax.action_univs),
-                                                                    uu___32)) in
-                                                                    match uu___30
-                                                                    with
-                                                                    | 
-                                                                    (univs,
-                                                                    act_defn2)
-                                                                    ->
-                                                                    let act_typ4
-                                                                    =
-                                                                    FStar_TypeChecker_Normalize.normalize
-                                                                    [FStar_TypeChecker_Env.Beta]
-                                                                    env1
-                                                                    act_typ3 in
-                                                                    let act_typ5
-                                                                    =
-                                                                    FStar_Syntax_Subst.close_univ_vars
-                                                                    univs
-                                                                    act_typ4 in
-                                                                    {
-                                                                    FStar_Syntax_Syntax.action_name
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_name);
-                                                                    FStar_Syntax_Syntax.action_unqualified_name
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_unqualified_name);
-                                                                    FStar_Syntax_Syntax.action_univs
-                                                                    = univs;
-                                                                    FStar_Syntax_Syntax.action_params
-                                                                    =
-                                                                    (act1.FStar_Syntax_Syntax.action_params);
-                                                                    FStar_Syntax_Syntax.action_defn
-                                                                    =
-                                                                    act_defn2;
-                                                                    FStar_Syntax_Syntax.action_typ
-                                                                    =
-                                                                    act_typ5
-                                                                    })))))))) in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     ed2.FStar_Syntax_Syntax.actions
-                                                     (FStar_Compiler_List.map
-                                                        check_action) in
-                                                 ((FStar_Pervasives_Native.Some
-                                                     repr),
-                                                   (FStar_Pervasives_Native.Some
-                                                      return_repr),
-                                                   (FStar_Pervasives_Native.Some
-                                                      bind_repr), actions))))) in
-                                       match uu___14 with
-                                       | (repr, return_repr, bind_repr,
-                                          actions) ->
-                                           let cl ts =
-                                             let ts1 =
-                                               FStar_Syntax_Subst.close_tscheme
-                                                 ed_bs ts in
-                                             let ed_univs_closing =
-                                               FStar_Syntax_Subst.univ_var_closing
-                                                 ed_univs in
-                                             let uu___15 =
-                                               FStar_Syntax_Subst.shift_subst
-                                                 (FStar_Compiler_List.length
-                                                    ed_bs) ed_univs_closing in
-                                             FStar_Syntax_Subst.subst_tscheme
-                                               uu___15 ts1 in
-                                           let combinators =
-                                             {
-                                               FStar_Syntax_Syntax.ret_wp =
-                                                 ret_wp;
-                                               FStar_Syntax_Syntax.bind_wp =
-                                                 bind_wp;
-                                               FStar_Syntax_Syntax.stronger =
-                                                 stronger;
-                                               FStar_Syntax_Syntax.if_then_else
-                                                 = if_then_else;
-                                               FStar_Syntax_Syntax.ite_wp =
-                                                 ite_wp;
-                                               FStar_Syntax_Syntax.close_wp =
-                                                 close_wp;
-                                               FStar_Syntax_Syntax.trivial =
-                                                 trivial;
-                                               FStar_Syntax_Syntax.repr =
-                                                 repr;
-                                               FStar_Syntax_Syntax.return_repr
-                                                 = return_repr;
-                                               FStar_Syntax_Syntax.bind_repr
-                                                 = bind_repr
-                                             } in
-                                           let combinators1 =
-                                             FStar_Syntax_Util.apply_wp_eff_combinators
-                                               cl combinators in
-                                           let combinators2 =
-                                             match ed2.FStar_Syntax_Syntax.combinators
-                                             with
-                                             | FStar_Syntax_Syntax.Primitive_eff
-                                                 uu___15 ->
-                                                 FStar_Syntax_Syntax.Primitive_eff
-                                                   combinators1
-                                             | FStar_Syntax_Syntax.DM4F_eff
-                                                 uu___15 ->
-                                                 FStar_Syntax_Syntax.DM4F_eff
-                                                   combinators1
-                                             | uu___15 ->
-                                                 failwith
-                                                   "Impossible! tc_eff_decl on a layered effect is not expected" in
-                                           let ed3 =
-                                             let uu___15 =
-                                               let uu___16 = cl signature in
-                                               FStar_Syntax_Syntax.WP_eff_sig
-                                                 uu___16 in
-                                             let uu___16 =
-                                               FStar_Compiler_List.map
-                                                 (fun a ->
-                                                    let uu___17 =
-                                                      let uu___18 =
-                                                        cl
-                                                          ((a.FStar_Syntax_Syntax.action_univs),
-                                                            (a.FStar_Syntax_Syntax.action_defn)) in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___18
-                                                        FStar_Pervasives_Native.snd in
-                                                    let uu___18 =
-                                                      let uu___19 =
-                                                        cl
-                                                          ((a.FStar_Syntax_Syntax.action_univs),
-                                                            (a.FStar_Syntax_Syntax.action_typ)) in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___19
-                                                        FStar_Pervasives_Native.snd in
-                                                    {
-                                                      FStar_Syntax_Syntax.action_name
-                                                        =
-                                                        (a.FStar_Syntax_Syntax.action_name);
-                                                      FStar_Syntax_Syntax.action_unqualified_name
-                                                        =
-                                                        (a.FStar_Syntax_Syntax.action_unqualified_name);
-                                                      FStar_Syntax_Syntax.action_univs
-                                                        =
-                                                        (a.FStar_Syntax_Syntax.action_univs);
-                                                      FStar_Syntax_Syntax.action_params
-                                                        =
-                                                        (a.FStar_Syntax_Syntax.action_params);
-                                                      FStar_Syntax_Syntax.action_defn
-                                                        = uu___17;
-                                                      FStar_Syntax_Syntax.action_typ
-                                                        = uu___18
-                                                    }) actions in
-                                             {
-                                               FStar_Syntax_Syntax.mname =
-                                                 (ed2.FStar_Syntax_Syntax.mname);
-                                               FStar_Syntax_Syntax.cattributes
-                                                 =
-                                                 (ed2.FStar_Syntax_Syntax.cattributes);
-                                               FStar_Syntax_Syntax.univs =
-                                                 (ed2.FStar_Syntax_Syntax.univs);
-                                               FStar_Syntax_Syntax.binders =
-                                                 (ed2.FStar_Syntax_Syntax.binders);
-                                               FStar_Syntax_Syntax.signature
-                                                 = uu___15;
-                                               FStar_Syntax_Syntax.combinators
-                                                 = combinators2;
-                                               FStar_Syntax_Syntax.actions =
-                                                 uu___16;
-                                               FStar_Syntax_Syntax.eff_attrs
-                                                 =
-                                                 (ed2.FStar_Syntax_Syntax.eff_attrs)
-                                             } in
-                                           ((let uu___16 =
-                                               FStar_Compiler_Effect.op_Less_Bar
-                                                 (FStar_TypeChecker_Env.debug
-                                                    env)
-                                                 (FStar_Options.Other "ED") in
-                                             if uu___16
-                                             then
-                                               let uu___17 =
-                                                 FStar_Syntax_Print.eff_decl_to_string
-                                                   false ed3 in
-                                               FStar_Compiler_Util.print1
-                                                 "Typechecked effect declaration:\n\t%s\n"
-                                                 uu___17
-                                             else ());
-                                            ed3))))))))))))))
-let (tc_eff_decl :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Syntax_Syntax.attribute Prims.list ->
-          (FStar_Syntax_Syntax.eff_decl * FStar_Syntax_Syntax.sigelt
-            Prims.list))
-  =
-  fun env ->
-    fun ed ->
-      fun quals ->
-        fun attrs ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater ed
-              FStar_Syntax_Util.is_layered in
-          if uu___
-          then tc_layered_eff_decl env ed quals attrs
-          else
-            (let uu___2 = tc_non_layered_eff_decl env ed quals attrs in
-             (uu___2, []))
-let (monad_signature :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.bv * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax))
-  =
-  fun env ->
-    fun m ->
-      fun s ->
-        let fail uu___ =
-          let uu___1 =
-            FStar_TypeChecker_Err.unexpected_signature_for_monad env m s in
-          let uu___2 = FStar_Ident.range_of_lid m in
-          FStar_Errors.raise_error uu___1 uu___2 in
-        let s1 = FStar_Syntax_Subst.compress s in
-        match s1.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-            let bs1 = FStar_Syntax_Subst.open_binders bs in
-            (match bs1 with
-             | { FStar_Syntax_Syntax.binder_bv = a;
-                 FStar_Syntax_Syntax.binder_qual = uu___;
-                 FStar_Syntax_Syntax.binder_attrs = uu___1;_}::{
-                                                                 FStar_Syntax_Syntax.binder_bv
-                                                                   = wp;
-                                                                 FStar_Syntax_Syntax.binder_qual
-                                                                   = uu___2;
-                                                                 FStar_Syntax_Syntax.binder_attrs
-                                                                   = uu___3;_}::[]
-                 -> (a, (wp.FStar_Syntax_Syntax.sort))
-             | uu___ -> fail ())
-        | uu___ -> fail ()
-let (tc_layered_lift :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sub_eff -> FStar_Syntax_Syntax.sub_eff)
-  =
-  fun env0 ->
-    fun sub ->
-      (let uu___1 =
-         FStar_Compiler_Effect.op_Less_Bar (FStar_TypeChecker_Env.debug env0)
-           (FStar_Options.Other "LayeredEffectsTc") in
-       if uu___1
-       then
-         let uu___2 = FStar_Syntax_Print.sub_eff_to_string sub in
-         FStar_Compiler_Util.print1 "Typechecking sub_effect: %s\n" uu___2
-       else ());
-      (let lift_ts =
-         FStar_Compiler_Effect.op_Bar_Greater sub.FStar_Syntax_Syntax.lift
-           FStar_Compiler_Util.must in
-       let r =
-         let uu___1 =
-           FStar_Compiler_Effect.op_Bar_Greater lift_ts
-             FStar_Pervasives_Native.snd in
-         uu___1.FStar_Syntax_Syntax.pos in
-       let uu___1 = check_and_gen env0 "" "lift" Prims.int_one lift_ts in
-       match uu___1 with
-       | (us, lift, lift_ty) ->
-           ((let uu___3 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env0)
-                 (FStar_Options.Other "LayeredEffectsTc") in
-             if uu___3
-             then
-               let uu___4 = FStar_Syntax_Print.tscheme_to_string (us, lift) in
-               let uu___5 =
-                 FStar_Syntax_Print.tscheme_to_string (us, lift_ty) in
-               FStar_Compiler_Util.print2
-                 "Typechecked lift: %s and lift_ty: %s\n" uu___4 uu___5
-             else ());
-            (let uu___3 = FStar_Syntax_Subst.open_univ_vars us lift_ty in
-             match uu___3 with
-             | (us1, lift_ty1) ->
-                 let env = FStar_TypeChecker_Env.push_univ_vars env0 us1 in
-                 let uu___4 =
-                   let uu___5 = FStar_Compiler_List.hd us1 in
-                   validate_indexed_effect_lift_shape env
-                     sub.FStar_Syntax_Syntax.source
-                     sub.FStar_Syntax_Syntax.target uu___5 lift_ty1 r in
-                 (match uu___4 with
-                  | (k, kind) ->
-                      let sub1 =
-                        let uu___5 =
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Compiler_Effect.op_Bar_Greater k
-                                (FStar_Syntax_Subst.close_univ_vars us1) in
-                            (us1, uu___7) in
-                          FStar_Pervasives_Native.Some uu___6 in
-                        {
-                          FStar_Syntax_Syntax.source =
-                            (sub.FStar_Syntax_Syntax.source);
-                          FStar_Syntax_Syntax.target =
-                            (sub.FStar_Syntax_Syntax.target);
-                          FStar_Syntax_Syntax.lift_wp = uu___5;
-                          FStar_Syntax_Syntax.lift =
-                            (FStar_Pervasives_Native.Some (us1, lift));
-                          FStar_Syntax_Syntax.kind =
-                            (FStar_Pervasives_Native.Some kind)
-                        } in
-                      ((let uu___6 =
-                          FStar_Compiler_Effect.op_Less_Bar
-                            (FStar_TypeChecker_Env.debug env0)
-                            (FStar_Options.Other "LayeredEffectsTc") in
-                        if uu___6
-                        then
-                          let uu___7 =
-                            FStar_Syntax_Print.sub_eff_to_string sub1 in
-                          FStar_Compiler_Util.print1 "Final sub_effect: %s\n"
-                            uu___7
-                        else ());
-                       sub1)))))
-let (check_lift_for_erasable_effects :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident -> FStar_Compiler_Range.range -> unit)
-  =
-  fun env ->
-    fun m1 ->
-      fun m2 ->
-        fun r ->
-          let err reason =
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Ident.string_of_lid m1 in
-                let uu___3 = FStar_Ident.string_of_lid m2 in
-                FStar_Compiler_Util.format3
-                  "Error defining a lift/subcomp %s ~> %s: %s" uu___2 uu___3
-                  reason in
-              (FStar_Errors.Fatal_UnexpectedEffect, uu___1) in
-            FStar_Errors.raise_error uu___ r in
-          let m11 = FStar_TypeChecker_Env.norm_eff_name env m1 in
-          let uu___ =
-            FStar_Ident.lid_equals m11 FStar_Parser_Const.effect_GHOST_lid in
-          if uu___
-          then err "user-defined lifts from GHOST effect are not allowed"
-          else
-            (let m1_erasable =
-               FStar_TypeChecker_Env.is_erasable_effect env m11 in
-             let m2_erasable =
-               FStar_TypeChecker_Env.is_erasable_effect env m2 in
-             let uu___2 =
-               (m2_erasable && (Prims.op_Negation m1_erasable)) &&
-                 (let uu___3 =
-                    FStar_Ident.lid_equals m11
-                      FStar_Parser_Const.effect_PURE_lid in
-                  Prims.op_Negation uu___3) in
-             if uu___2
-             then
-               err
-                 "cannot lift a non-erasable effect to an erasable effect unless the non-erasable effect is PURE"
-             else ())
-let (tc_lift :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sub_eff ->
-      FStar_Compiler_Range.range -> FStar_Syntax_Syntax.sub_eff)
-  =
-  fun env ->
-    fun sub ->
-      fun r ->
-        (let uu___1 =
-           FStar_Ident.lid_equals sub.FStar_Syntax_Syntax.source
-             sub.FStar_Syntax_Syntax.target in
-         if uu___1
-         then
-           let uu___2 =
-             let uu___3 =
-               let uu___4 =
-                 FStar_Ident.string_of_lid sub.FStar_Syntax_Syntax.source in
-               FStar_Compiler_Util.format1
-                 "Cannot define a lift with same source and target (%s)"
-                 uu___4 in
-             (FStar_Errors.Fatal_UnexpectedEffect, uu___3) in
-           FStar_Errors.raise_error uu___2 r
-         else ());
-        (let check_and_gen1 env1 t k =
-           let uu___1 =
-             FStar_TypeChecker_TcTerm.tc_check_trivial_guard env1 t k in
-           FStar_TypeChecker_Generalize.generalize_universes env1 uu___1 in
-         check_lift_for_erasable_effects env sub.FStar_Syntax_Syntax.source
-           sub.FStar_Syntax_Syntax.target r;
-         (let ed_src =
-            FStar_TypeChecker_Env.get_effect_decl env
-              sub.FStar_Syntax_Syntax.source in
-          let ed_tgt =
-            FStar_TypeChecker_Env.get_effect_decl env
-              sub.FStar_Syntax_Syntax.target in
-          let uu___2 =
-            (FStar_Compiler_Effect.op_Bar_Greater ed_src
-               FStar_Syntax_Util.is_layered)
-              ||
-              (FStar_Compiler_Effect.op_Bar_Greater ed_tgt
-                 FStar_Syntax_Util.is_layered) in
-          if uu___2
-          then
-            let uu___3 = FStar_TypeChecker_Env.set_range env r in
-            tc_layered_lift uu___3 sub
-          else
-            (let uu___4 =
-               let uu___5 =
-                 FStar_TypeChecker_Env.lookup_effect_lid env
-                   sub.FStar_Syntax_Syntax.source in
-               monad_signature env sub.FStar_Syntax_Syntax.source uu___5 in
-             match uu___4 with
-             | (a, wp_a_src) ->
-                 let uu___5 =
-                   let uu___6 =
-                     FStar_TypeChecker_Env.lookup_effect_lid env
-                       sub.FStar_Syntax_Syntax.target in
-                   monad_signature env sub.FStar_Syntax_Syntax.target uu___6 in
-                 (match uu___5 with
-                  | (b, wp_b_tgt) ->
-                      let wp_a_tgt =
-                        let uu___6 =
-                          let uu___7 =
-                            let uu___8 =
-                              let uu___9 = FStar_Syntax_Syntax.bv_to_name a in
-                              (b, uu___9) in
-                            FStar_Syntax_Syntax.NT uu___8 in
-                          [uu___7] in
-                        FStar_Syntax_Subst.subst uu___6 wp_b_tgt in
-                      let expected_k =
-                        let uu___6 =
-                          let uu___7 = FStar_Syntax_Syntax.mk_binder a in
-                          let uu___8 =
-                            let uu___9 =
-                              FStar_Syntax_Syntax.null_binder wp_a_src in
-                            [uu___9] in
-                          uu___7 :: uu___8 in
-                        let uu___7 = FStar_Syntax_Syntax.mk_Total wp_a_tgt in
-                        FStar_Syntax_Util.arrow uu___6 uu___7 in
-                      let repr_type eff_name a1 wp =
-                        (let uu___7 =
-                           let uu___8 =
-                             FStar_TypeChecker_Env.is_reifiable_effect env
-                               eff_name in
-                           Prims.op_Negation uu___8 in
-                         if uu___7
-                         then
-                           let uu___8 =
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_Ident.string_of_lid eff_name in
-                               FStar_Compiler_Util.format1
-                                 "Effect %s cannot be reified" uu___10 in
-                             (FStar_Errors.Fatal_EffectCannotBeReified,
-                               uu___9) in
-                           let uu___9 = FStar_TypeChecker_Env.get_range env in
-                           FStar_Errors.raise_error uu___8 uu___9
-                         else ());
-                        (let uu___7 =
-                           FStar_TypeChecker_Env.effect_decl_opt env eff_name in
-                         match uu___7 with
-                         | FStar_Pervasives_Native.None ->
-                             failwith
-                               "internal error: reifiable effect has no decl?"
-                         | FStar_Pervasives_Native.Some (ed, qualifiers) ->
-                             let repr =
-                               let uu___8 =
-                                 let uu___9 =
-                                   FStar_Compiler_Effect.op_Bar_Greater ed
-                                     FStar_Syntax_Util.get_eff_repr in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                   FStar_Compiler_Util.must in
-                               FStar_TypeChecker_Env.inst_effect_fun_with
-                                 [FStar_Syntax_Syntax.U_unknown] env ed
-                                 uu___8 in
-                             let uu___8 =
-                               let uu___9 =
-                                 let uu___10 =
-                                   let uu___11 =
-                                     FStar_Syntax_Syntax.as_arg a1 in
-                                   let uu___12 =
-                                     let uu___13 =
-                                       FStar_Syntax_Syntax.as_arg wp in
-                                     [uu___13] in
-                                   uu___11 :: uu___12 in
-                                 (repr, uu___10) in
-                               FStar_Syntax_Syntax.Tm_app uu___9 in
-                             let uu___9 = FStar_TypeChecker_Env.get_range env in
-                             FStar_Syntax_Syntax.mk uu___8 uu___9) in
-                      let uu___6 =
-                        match ((sub.FStar_Syntax_Syntax.lift),
-                                (sub.FStar_Syntax_Syntax.lift_wp))
-                        with
-                        | (FStar_Pervasives_Native.None,
-                           FStar_Pervasives_Native.None) ->
-                            failwith "Impossible (parser)"
-                        | (lift, FStar_Pervasives_Native.Some (uvs, lift_wp))
-                            ->
-                            let uu___7 =
-                              if
-                                (FStar_Compiler_List.length uvs) >
-                                  Prims.int_zero
-                              then
-                                let uu___8 =
-                                  FStar_Syntax_Subst.univ_var_opening uvs in
-                                match uu___8 with
-                                | (usubst, uvs1) ->
-                                    let uu___9 =
-                                      FStar_TypeChecker_Env.push_univ_vars
-                                        env uvs1 in
-                                    let uu___10 =
-                                      FStar_Syntax_Subst.subst usubst lift_wp in
-                                    (uu___9, uu___10)
-                              else (env, lift_wp) in
-                            (match uu___7 with
-                             | (env1, lift_wp1) ->
-                                 let lift_wp2 =
-                                   if
-                                     (FStar_Compiler_List.length uvs) =
-                                       Prims.int_zero
-                                   then
-                                     check_and_gen1 env1 lift_wp1 expected_k
-                                   else
-                                     (let lift_wp3 =
-                                        FStar_TypeChecker_TcTerm.tc_check_trivial_guard
-                                          env1 lift_wp1 expected_k in
-                                      let uu___9 =
-                                        FStar_Syntax_Subst.close_univ_vars
-                                          uvs lift_wp3 in
-                                      (uvs, uu___9)) in
-                                 (lift, lift_wp2))
-                        | (FStar_Pervasives_Native.Some (what, lift),
-                           FStar_Pervasives_Native.None) ->
-                            let uu___7 =
-                              if
-                                (FStar_Compiler_List.length what) >
-                                  Prims.int_zero
-                              then
-                                let uu___8 =
-                                  FStar_Syntax_Subst.univ_var_opening what in
-                                match uu___8 with
-                                | (usubst, uvs) ->
-                                    let uu___9 =
-                                      FStar_Syntax_Subst.subst usubst lift in
-                                    (uvs, uu___9)
-                              else ([], lift) in
-                            (match uu___7 with
-                             | (uvs, lift1) ->
-                                 ((let uu___9 =
-                                     FStar_TypeChecker_Env.debug env
-                                       (FStar_Options.Other "ED") in
-                                   if uu___9
-                                   then
-                                     let uu___10 =
-                                       FStar_Syntax_Print.term_to_string
-                                         lift1 in
-                                     FStar_Compiler_Util.print1
-                                       "Lift for free : %s\n" uu___10
-                                   else ());
-                                  (let dmff_env =
-                                     FStar_TypeChecker_DMFF.empty env
-                                       (FStar_TypeChecker_TcTerm.tc_constant
-                                          env FStar_Compiler_Range.dummyRange) in
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_TypeChecker_Env.push_univ_vars
-                                         env uvs in
-                                     FStar_TypeChecker_TcTerm.tc_term uu___10
-                                       lift1 in
-                                   match uu___9 with
-                                   | (lift2, comp, uu___10) ->
-                                       let uu___11 =
-                                         FStar_TypeChecker_DMFF.star_expr
-                                           dmff_env lift2 in
-                                       (match uu___11 with
-                                        | (uu___12, lift_wp, lift_elab) ->
-                                            let lift_wp1 =
-                                              FStar_TypeChecker_DMFF.recheck_debug
-                                                "lift-wp" env lift_wp in
-                                            let lift_elab1 =
-                                              FStar_TypeChecker_DMFF.recheck_debug
-                                                "lift-elab" env lift_elab in
-                                            if
-                                              (FStar_Compiler_List.length uvs)
-                                                = Prims.int_zero
-                                            then
-                                              let uu___13 =
-                                                let uu___14 =
-                                                  FStar_TypeChecker_Generalize.generalize_universes
-                                                    env lift_elab1 in
-                                                FStar_Pervasives_Native.Some
-                                                  uu___14 in
-                                              let uu___14 =
-                                                FStar_TypeChecker_Generalize.generalize_universes
-                                                  env lift_wp1 in
-                                              (uu___13, uu___14)
-                                            else
-                                              (let uu___14 =
-                                                 let uu___15 =
-                                                   let uu___16 =
-                                                     FStar_Syntax_Subst.close_univ_vars
-                                                       uvs lift_elab1 in
-                                                   (uvs, uu___16) in
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___15 in
-                                               let uu___15 =
-                                                 let uu___16 =
-                                                   FStar_Syntax_Subst.close_univ_vars
-                                                     uvs lift_wp1 in
-                                                 (uvs, uu___16) in
-                                               (uu___14, uu___15)))))) in
-                      (match uu___6 with
-                       | (lift, lift_wp) ->
-                           let env1 =
-                             {
-                               FStar_TypeChecker_Env.solver =
-                                 (env.FStar_TypeChecker_Env.solver);
-                               FStar_TypeChecker_Env.range =
-                                 (env.FStar_TypeChecker_Env.range);
-                               FStar_TypeChecker_Env.curmodule =
-                                 (env.FStar_TypeChecker_Env.curmodule);
-                               FStar_TypeChecker_Env.gamma =
-                                 (env.FStar_TypeChecker_Env.gamma);
-                               FStar_TypeChecker_Env.gamma_sig =
-                                 (env.FStar_TypeChecker_Env.gamma_sig);
-                               FStar_TypeChecker_Env.gamma_cache =
-                                 (env.FStar_TypeChecker_Env.gamma_cache);
-                               FStar_TypeChecker_Env.modules =
-                                 (env.FStar_TypeChecker_Env.modules);
-                               FStar_TypeChecker_Env.expected_typ =
-                                 (env.FStar_TypeChecker_Env.expected_typ);
-                               FStar_TypeChecker_Env.sigtab =
-                                 (env.FStar_TypeChecker_Env.sigtab);
-                               FStar_TypeChecker_Env.attrtab =
-                                 (env.FStar_TypeChecker_Env.attrtab);
-                               FStar_TypeChecker_Env.instantiate_imp =
-                                 (env.FStar_TypeChecker_Env.instantiate_imp);
-                               FStar_TypeChecker_Env.effects =
-                                 (env.FStar_TypeChecker_Env.effects);
-                               FStar_TypeChecker_Env.generalize =
-                                 (env.FStar_TypeChecker_Env.generalize);
-                               FStar_TypeChecker_Env.letrecs =
-                                 (env.FStar_TypeChecker_Env.letrecs);
-                               FStar_TypeChecker_Env.top_level =
-                                 (env.FStar_TypeChecker_Env.top_level);
-                               FStar_TypeChecker_Env.check_uvars =
-                                 (env.FStar_TypeChecker_Env.check_uvars);
-                               FStar_TypeChecker_Env.use_eq_strict =
-                                 (env.FStar_TypeChecker_Env.use_eq_strict);
-                               FStar_TypeChecker_Env.is_iface =
-                                 (env.FStar_TypeChecker_Env.is_iface);
-                               FStar_TypeChecker_Env.admit =
-                                 (env.FStar_TypeChecker_Env.admit);
-                               FStar_TypeChecker_Env.lax = true;
-                               FStar_TypeChecker_Env.lax_universes =
-                                 (env.FStar_TypeChecker_Env.lax_universes);
-                               FStar_TypeChecker_Env.phase1 =
-                                 (env.FStar_TypeChecker_Env.phase1);
-                               FStar_TypeChecker_Env.failhard =
-                                 (env.FStar_TypeChecker_Env.failhard);
-                               FStar_TypeChecker_Env.nosynth =
-                                 (env.FStar_TypeChecker_Env.nosynth);
-                               FStar_TypeChecker_Env.uvar_subtyping =
-                                 (env.FStar_TypeChecker_Env.uvar_subtyping);
-                               FStar_TypeChecker_Env.tc_term =
-                                 (env.FStar_TypeChecker_Env.tc_term);
-                               FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                 =
-                                 (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                               FStar_TypeChecker_Env.universe_of =
-                                 (env.FStar_TypeChecker_Env.universe_of);
-                               FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                 =
-                                 (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                               FStar_TypeChecker_Env.teq_nosmt_force =
-                                 (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                               FStar_TypeChecker_Env.subtype_nosmt_force =
-                                 (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                               FStar_TypeChecker_Env.qtbl_name_and_index =
-                                 (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                               FStar_TypeChecker_Env.normalized_eff_names =
-                                 (env.FStar_TypeChecker_Env.normalized_eff_names);
-                               FStar_TypeChecker_Env.fv_delta_depths =
-                                 (env.FStar_TypeChecker_Env.fv_delta_depths);
-                               FStar_TypeChecker_Env.proof_ns =
-                                 (env.FStar_TypeChecker_Env.proof_ns);
-                               FStar_TypeChecker_Env.synth_hook =
-                                 (env.FStar_TypeChecker_Env.synth_hook);
-                               FStar_TypeChecker_Env.try_solve_implicits_hook
-                                 =
-                                 (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                               FStar_TypeChecker_Env.splice =
-                                 (env.FStar_TypeChecker_Env.splice);
-                               FStar_TypeChecker_Env.mpreprocess =
-                                 (env.FStar_TypeChecker_Env.mpreprocess);
-                               FStar_TypeChecker_Env.postprocess =
-                                 (env.FStar_TypeChecker_Env.postprocess);
-                               FStar_TypeChecker_Env.identifier_info =
-                                 (env.FStar_TypeChecker_Env.identifier_info);
-                               FStar_TypeChecker_Env.tc_hooks =
-                                 (env.FStar_TypeChecker_Env.tc_hooks);
-                               FStar_TypeChecker_Env.dsenv =
-                                 (env.FStar_TypeChecker_Env.dsenv);
-                               FStar_TypeChecker_Env.nbe =
-                                 (env.FStar_TypeChecker_Env.nbe);
-                               FStar_TypeChecker_Env.strict_args_tab =
-                                 (env.FStar_TypeChecker_Env.strict_args_tab);
-                               FStar_TypeChecker_Env.erasable_types_tab =
-                                 (env.FStar_TypeChecker_Env.erasable_types_tab);
-                               FStar_TypeChecker_Env.enable_defer_to_tac =
-                                 (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                               FStar_TypeChecker_Env.unif_allow_ref_guards =
-                                 (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                               FStar_TypeChecker_Env.erase_erasable_args =
-                                 (env.FStar_TypeChecker_Env.erase_erasable_args);
-                               FStar_TypeChecker_Env.core_check =
-                                 (env.FStar_TypeChecker_Env.core_check)
-                             } in
-                           let lift1 =
-                             match lift with
-                             | FStar_Pervasives_Native.None ->
-                                 FStar_Pervasives_Native.None
-                             | FStar_Pervasives_Native.Some (uvs, lift2) ->
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Syntax_Subst.univ_var_opening uvs in
-                                   match uu___8 with
-                                   | (usubst, uvs1) ->
-                                       let uu___9 =
-                                         FStar_TypeChecker_Env.push_univ_vars
-                                           env1 uvs1 in
-                                       let uu___10 =
-                                         FStar_Syntax_Subst.subst usubst
-                                           lift2 in
-                                       (uu___9, uu___10) in
-                                 (match uu___7 with
-                                  | (env2, lift3) ->
-                                      let uu___8 =
-                                        let uu___9 =
-                                          FStar_TypeChecker_Env.lookup_effect_lid
-                                            env2
-                                            sub.FStar_Syntax_Syntax.source in
-                                        monad_signature env2
-                                          sub.FStar_Syntax_Syntax.source
-                                          uu___9 in
-                                      (match uu___8 with
-                                       | (a1, wp_a_src1) ->
-                                           let wp_a =
-                                             FStar_Syntax_Syntax.new_bv
-                                               FStar_Pervasives_Native.None
-                                               wp_a_src1 in
-                                           let a_typ =
-                                             FStar_Syntax_Syntax.bv_to_name
-                                               a1 in
-                                           let wp_a_typ =
-                                             FStar_Syntax_Syntax.bv_to_name
-                                               wp_a in
-                                           let repr_f =
-                                             repr_type
-                                               sub.FStar_Syntax_Syntax.source
-                                               a_typ wp_a_typ in
-                                           let repr_result =
-                                             let lift_wp1 =
-                                               FStar_TypeChecker_Normalize.normalize
-                                                 [FStar_TypeChecker_Env.EraseUniverses;
-                                                 FStar_TypeChecker_Env.AllowUnboundUniverses]
-                                                 env2
-                                                 (FStar_Pervasives_Native.snd
-                                                    lift_wp) in
-                                             let lift_wp_a =
-                                               let uu___9 =
-                                                 let uu___10 =
-                                                   let uu___11 =
-                                                     let uu___12 =
-                                                       FStar_Syntax_Syntax.as_arg
-                                                         a_typ in
-                                                     let uu___13 =
-                                                       let uu___14 =
-                                                         FStar_Syntax_Syntax.as_arg
-                                                           wp_a_typ in
-                                                       [uu___14] in
-                                                     uu___12 :: uu___13 in
-                                                   (lift_wp1, uu___11) in
-                                                 FStar_Syntax_Syntax.Tm_app
-                                                   uu___10 in
-                                               let uu___10 =
-                                                 FStar_TypeChecker_Env.get_range
-                                                   env2 in
-                                               FStar_Syntax_Syntax.mk uu___9
-                                                 uu___10 in
-                                             repr_type
-                                               sub.FStar_Syntax_Syntax.target
-                                               a_typ lift_wp_a in
-                                           let expected_k1 =
-                                             let uu___9 =
-                                               let uu___10 =
-                                                 FStar_Syntax_Syntax.mk_binder
-                                                   a1 in
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Syntax_Syntax.mk_binder
-                                                     wp_a in
-                                                 let uu___13 =
-                                                   let uu___14 =
-                                                     FStar_Syntax_Syntax.null_binder
-                                                       repr_f in
-                                                   [uu___14] in
-                                                 uu___12 :: uu___13 in
-                                               uu___10 :: uu___11 in
-                                             let uu___10 =
-                                               FStar_Syntax_Syntax.mk_Total
-                                                 repr_result in
-                                             FStar_Syntax_Util.arrow uu___9
-                                               uu___10 in
-                                           let uu___9 =
-                                             FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                               env2 expected_k1 in
-                                           (match uu___9 with
-                                            | (expected_k2, uu___10, uu___11)
-                                                ->
-                                                let lift4 =
-                                                  if
-                                                    (FStar_Compiler_List.length
-                                                       uvs)
-                                                      = Prims.int_zero
-                                                  then
-                                                    check_and_gen1 env2 lift3
-                                                      expected_k2
-                                                  else
-                                                    (let lift5 =
-                                                       FStar_TypeChecker_TcTerm.tc_check_trivial_guard
-                                                         env2 lift3
-                                                         expected_k2 in
-                                                     let uu___13 =
-                                                       FStar_Syntax_Subst.close_univ_vars
-                                                         uvs lift5 in
-                                                     (uvs, uu___13)) in
-                                                FStar_Pervasives_Native.Some
-                                                  lift4))) in
-                           ((let uu___8 =
-                               let uu___9 =
-                                 let uu___10 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     lift_wp FStar_Pervasives_Native.fst in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___10
-                                   FStar_Compiler_List.length in
-                               uu___9 <> Prims.int_one in
-                             if uu___8
-                             then
-                               let uu___9 =
-                                 let uu___10 =
-                                   let uu___11 =
-                                     FStar_Syntax_Print.lid_to_string
-                                       sub.FStar_Syntax_Syntax.source in
-                                   let uu___12 =
-                                     FStar_Syntax_Print.lid_to_string
-                                       sub.FStar_Syntax_Syntax.target in
-                                   let uu___13 =
-                                     let uu___14 =
-                                       let uu___15 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           lift_wp
-                                           FStar_Pervasives_Native.fst in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___15 FStar_Compiler_List.length in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___14
-                                       FStar_Compiler_Util.string_of_int in
-                                   FStar_Compiler_Util.format3
-                                     "Sub effect wp must be polymorphic in exactly 1 universe; %s ~> %s has %s universes"
-                                     uu___11 uu___12 uu___13 in
-                                 (FStar_Errors.Fatal_TooManyUniverse,
-                                   uu___10) in
-                               FStar_Errors.raise_error uu___9 r
-                             else ());
-                            (let uu___9 =
-                               (FStar_Compiler_Util.is_some lift1) &&
-                                 (let uu___10 =
-                                    let uu___11 =
-                                      let uu___12 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          lift1 FStar_Compiler_Util.must in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___12 FStar_Pervasives_Native.fst in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___11 FStar_Compiler_List.length in
-                                  uu___10 <> Prims.int_one) in
-                             if uu___9
-                             then
-                               let uu___10 =
-                                 let uu___11 =
-                                   let uu___12 =
-                                     FStar_Syntax_Print.lid_to_string
-                                       sub.FStar_Syntax_Syntax.source in
-                                   let uu___13 =
-                                     FStar_Syntax_Print.lid_to_string
-                                       sub.FStar_Syntax_Syntax.target in
-                                   let uu___14 =
-                                     let uu___15 =
-                                       let uu___16 =
-                                         let uu___17 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             lift1 FStar_Compiler_Util.must in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___17
-                                           FStar_Pervasives_Native.fst in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___16 FStar_Compiler_List.length in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___15
-                                       FStar_Compiler_Util.string_of_int in
-                                   FStar_Compiler_Util.format3
-                                     "Sub effect lift must be polymorphic in exactly 1 universe; %s ~> %s has %s universes"
-                                     uu___12 uu___13 uu___14 in
-                                 (FStar_Errors.Fatal_TooManyUniverse,
-                                   uu___11) in
-                               FStar_Errors.raise_error uu___10 r
-                             else ());
-                            {
-                              FStar_Syntax_Syntax.source =
-                                (sub.FStar_Syntax_Syntax.source);
-                              FStar_Syntax_Syntax.target =
-                                (sub.FStar_Syntax_Syntax.target);
-                              FStar_Syntax_Syntax.lift_wp =
-                                (FStar_Pervasives_Native.Some lift_wp);
-                              FStar_Syntax_Syntax.lift = lift1;
-                              FStar_Syntax_Syntax.kind =
-                                (sub.FStar_Syntax_Syntax.kind)
-                            }))))))
-let (tc_effect_abbrev :
-  FStar_TypeChecker_Env.env ->
-    (FStar_Ident.lident * FStar_Syntax_Syntax.univ_names *
-      FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp) ->
-      FStar_Compiler_Range.range ->
-        (FStar_Ident.lident * FStar_Syntax_Syntax.univ_names *
-          FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.comp))
-  =
-  fun env ->
-    fun uu___ ->
-      fun r ->
-        match uu___ with
-        | (lid, uvs, tps, c) ->
-            let env0 = env in
-            let uu___1 =
-              if (FStar_Compiler_List.length uvs) = Prims.int_zero
-              then (env, uvs, tps, c)
-              else
-                (let uu___3 = FStar_Syntax_Subst.univ_var_opening uvs in
-                 match uu___3 with
-                 | (usubst, uvs1) ->
-                     let tps1 = FStar_Syntax_Subst.subst_binders usubst tps in
-                     let c1 =
-                       let uu___4 =
-                         FStar_Syntax_Subst.shift_subst
-                           (FStar_Compiler_List.length tps1) usubst in
-                       FStar_Syntax_Subst.subst_comp uu___4 c in
-                     let uu___4 =
-                       FStar_TypeChecker_Env.push_univ_vars env uvs1 in
-                     (uu___4, uvs1, tps1, c1)) in
-            (match uu___1 with
-             | (env1, uvs1, tps1, c1) ->
-                 let env2 = FStar_TypeChecker_Env.set_range env1 r in
-                 let uu___2 = FStar_Syntax_Subst.open_comp tps1 c1 in
-                 (match uu___2 with
-                  | (tps2, c2) ->
-                      let uu___3 =
-                        FStar_TypeChecker_TcTerm.tc_tparams env2 tps2 in
-                      (match uu___3 with
-                       | (tps3, env3, us) ->
-                           let uu___4 =
-                             FStar_TypeChecker_TcTerm.tc_comp env3 c2 in
-                           (match uu___4 with
-                            | (c3, u, g) ->
-                                let is_default_effect =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      FStar_Compiler_Effect.op_Bar_Greater c3
-                                        FStar_Syntax_Util.comp_effect_name in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___6
-                                      (FStar_TypeChecker_Env.get_default_effect
-                                         env3) in
-                                  match uu___5 with
-                                  | FStar_Pervasives_Native.None -> false
-                                  | FStar_Pervasives_Native.Some l ->
-                                      FStar_Ident.lid_equals l lid in
-                                (FStar_TypeChecker_Rel.force_trivial_guard
-                                   env3 g;
-                                 (let expected_result_typ =
-                                    match tps3 with
-                                    | { FStar_Syntax_Syntax.binder_bv = x;
-                                        FStar_Syntax_Syntax.binder_qual =
-                                          uu___7;
-                                        FStar_Syntax_Syntax.binder_attrs =
-                                          uu___8;_}::tl
-                                        ->
-                                        (if
-                                           is_default_effect &&
-                                             (Prims.op_Negation (tl = []))
-                                         then
-                                           (let uu___10 =
-                                              let uu___11 =
-                                                let uu___12 =
-                                                  FStar_Ident.string_of_lid
-                                                    lid in
-                                                let uu___13 =
-                                                  let uu___14 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      c3
-                                                      FStar_Syntax_Util.comp_effect_name in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___14
-                                                    FStar_Ident.string_of_lid in
-                                                FStar_Compiler_Util.format2
-                                                  "Effect %s is marked as a default effect for %s, but it has more than one arguments"
-                                                  uu___12 uu___13 in
-                                              (FStar_Errors.Fatal_UnexpectedEffect,
-                                                uu___11) in
-                                            FStar_Errors.raise_error uu___10
-                                              r)
-                                         else ();
-                                         FStar_Syntax_Syntax.bv_to_name x)
-                                    | uu___7 ->
-                                        FStar_Errors.raise_error
-                                          (FStar_Errors.Fatal_NotEnoughArgumentsForEffect,
-                                            "Effect abbreviations must bind at least the result type")
-                                          r in
-                                  let def_result_typ =
-                                    FStar_Syntax_Util.comp_result c3 in
-                                  let uu___7 =
-                                    let uu___8 =
-                                      FStar_TypeChecker_Rel.teq_nosmt_force
-                                        env3 expected_result_typ
-                                        def_result_typ in
-                                    Prims.op_Negation uu___8 in
-                                  if uu___7
-                                  then
-                                    let uu___8 =
-                                      let uu___9 =
-                                        let uu___10 =
-                                          FStar_Syntax_Print.term_to_string
-                                            expected_result_typ in
-                                        let uu___11 =
-                                          FStar_Syntax_Print.term_to_string
-                                            def_result_typ in
-                                        FStar_Compiler_Util.format2
-                                          "Result type of effect abbreviation `%s` does not match the result type of its definition `%s`"
-                                          uu___10 uu___11 in
-                                      (FStar_Errors.Fatal_EffectAbbreviationResultTypeMismatch,
-                                        uu___9) in
-                                    FStar_Errors.raise_error uu___8 r
-                                  else ());
-                                 (let tps4 =
-                                    FStar_Syntax_Subst.close_binders tps3 in
-                                  let c4 =
-                                    FStar_Syntax_Subst.close_comp tps4 c3 in
-                                  let uu___7 =
-                                    let uu___8 =
-                                      FStar_Syntax_Syntax.mk
-                                        (FStar_Syntax_Syntax.Tm_arrow
-                                           (tps4, c4)) r in
-                                    FStar_TypeChecker_Generalize.generalize_universes
-                                      env0 uu___8 in
-                                  match uu___7 with
-                                  | (uvs2, t) ->
-                                      let uu___8 =
-                                        let uu___9 =
-                                          let uu___10 =
-                                            let uu___11 =
-                                              FStar_Syntax_Subst.compress t in
-                                            uu___11.FStar_Syntax_Syntax.n in
-                                          (tps4, uu___10) in
-                                        match uu___9 with
-                                        | ([], FStar_Syntax_Syntax.Tm_arrow
-                                           (uu___10, c5)) -> ([], c5)
-                                        | (uu___10,
-                                           FStar_Syntax_Syntax.Tm_arrow
-                                           (tps5, c5)) -> (tps5, c5)
-                                        | uu___10 ->
-                                            failwith
-                                              "Impossible (t is an arrow)" in
-                                      (match uu___8 with
-                                       | (tps5, c5) ->
-                                           (if
-                                              (FStar_Compiler_List.length
-                                                 uvs2)
-                                                <> Prims.int_one
-                                            then
-                                              (let uu___10 =
-                                                 FStar_Syntax_Subst.open_univ_vars
-                                                   uvs2 t in
-                                               match uu___10 with
-                                               | (uu___11, t1) ->
-                                                   let uu___12 =
-                                                     let uu___13 =
-                                                       let uu___14 =
-                                                         FStar_Syntax_Print.lid_to_string
-                                                           lid in
-                                                       let uu___15 =
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           (FStar_Compiler_List.length
-                                                              uvs2)
-                                                           FStar_Compiler_Util.string_of_int in
-                                                       let uu___16 =
-                                                         FStar_Syntax_Print.term_to_string
-                                                           t1 in
-                                                       FStar_Compiler_Util.format3
-                                                         "Effect abbreviations must be polymorphic in exactly 1 universe; %s has %s universes (%s)"
-                                                         uu___14 uu___15
-                                                         uu___16 in
-                                                     (FStar_Errors.Fatal_TooManyUniverse,
-                                                       uu___13) in
-                                                   FStar_Errors.raise_error
-                                                     uu___12 r)
-                                            else ();
-                                            (lid, uvs2, tps5, c5)))))))))
-let (check_polymonadic_bind_for_erasable_effects :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident -> FStar_Compiler_Range.range -> unit)
-  =
-  fun env ->
-    fun m ->
-      fun n ->
-        fun p ->
-          fun r ->
-            let err reason =
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Ident.string_of_lid m in
-                  let uu___3 = FStar_Ident.string_of_lid n in
-                  let uu___4 = FStar_Ident.string_of_lid p in
-                  FStar_Compiler_Util.format4
-                    "Error definition polymonadic bind (%s, %s) |> %s: %s"
-                    uu___2 uu___3 uu___4 reason in
-                (FStar_Errors.Fatal_UnexpectedEffect, uu___1) in
-              FStar_Errors.raise_error uu___ r in
-            let m1 = FStar_TypeChecker_Env.norm_eff_name env m in
-            let n1 = FStar_TypeChecker_Env.norm_eff_name env n in
-            let uu___ =
-              (FStar_Ident.lid_equals m1 FStar_Parser_Const.effect_GHOST_lid)
-                ||
-                (FStar_Ident.lid_equals n1
-                   FStar_Parser_Const.effect_GHOST_lid) in
-            if uu___
-            then
-              err
-                "GHOST computations are not allowed to be composed using user-defined polymonadic binds"
-            else
-              (let m_erasable =
-                 FStar_TypeChecker_Env.is_erasable_effect env m1 in
-               let n_erasable =
-                 FStar_TypeChecker_Env.is_erasable_effect env n1 in
-               let p_erasable =
-                 FStar_TypeChecker_Env.is_erasable_effect env p in
-               if p_erasable
-               then
-                 let uu___2 =
-                   (Prims.op_Negation m_erasable) &&
-                     (let uu___3 =
-                        FStar_Ident.lid_equals m1
-                          FStar_Parser_Const.effect_PURE_lid in
-                      Prims.op_Negation uu___3) in
-                 (if uu___2
-                  then
-                    let uu___3 =
-                      let uu___4 = FStar_Ident.string_of_lid m1 in
-                      FStar_Compiler_Util.format1
-                        "target effect is erasable but %s is neither erasable nor PURE"
-                        uu___4 in
-                    err uu___3
-                  else
-                    (let uu___4 =
-                       (Prims.op_Negation n_erasable) &&
-                         (let uu___5 =
-                            FStar_Ident.lid_equals n1
-                              FStar_Parser_Const.effect_PURE_lid in
-                          Prims.op_Negation uu___5) in
-                     if uu___4
-                     then
-                       let uu___5 =
-                         let uu___6 = FStar_Ident.string_of_lid n1 in
-                         FStar_Compiler_Util.format1
-                           "target effect is erasable but %s is neither erasable nor PURE"
-                           uu___6 in
-                       err uu___5
-                     else ()))
-               else ())
-let (tc_polymonadic_bind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.tscheme ->
-            (FStar_Syntax_Syntax.tscheme * FStar_Syntax_Syntax.tscheme *
-              FStar_Syntax_Syntax.indexed_effect_combinator_kind))
-  =
-  fun env ->
-    fun m ->
-      fun n ->
-        fun p ->
-          fun ts ->
-            let eff_name =
-              let uu___ =
-                let uu___1 =
-                  FStar_Compiler_Effect.op_Bar_Greater m
-                    FStar_Ident.ident_of_lid in
-                FStar_Compiler_Effect.op_Bar_Greater uu___1
-                  FStar_Ident.string_of_id in
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater n
-                    FStar_Ident.ident_of_lid in
-                FStar_Compiler_Effect.op_Bar_Greater uu___2
-                  FStar_Ident.string_of_id in
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_Effect.op_Bar_Greater p
-                    FStar_Ident.ident_of_lid in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Ident.string_of_id in
-              FStar_Compiler_Util.format3 "(%s, %s) |> %s)" uu___ uu___1
-                uu___2 in
-            let r = (FStar_Pervasives_Native.snd ts).FStar_Syntax_Syntax.pos in
-            check_polymonadic_bind_for_erasable_effects env m n p r;
-            (let uu___1 =
-               check_and_gen env eff_name "polymonadic_bind"
-                 (Prims.of_int (2)) ts in
-             match uu___1 with
-             | (us, t, ty) ->
-                 let uu___2 = FStar_Syntax_Subst.open_univ_vars us ty in
-                 (match uu___2 with
-                  | (us1, ty1) ->
-                      let env1 = FStar_TypeChecker_Env.push_univ_vars env us1 in
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_TypeChecker_Env.get_effect_decl env1 m in
-                        let uu___5 =
-                          FStar_TypeChecker_Env.get_effect_decl env1 n in
-                        let uu___6 =
-                          FStar_TypeChecker_Env.get_effect_decl env1 p in
-                        (uu___4, uu___5, uu___6) in
-                      (match uu___3 with
-                       | (m_ed, n_ed, p_ed) ->
-                           let uu___4 =
-                             let uu___5 =
-                               FStar_Syntax_Util.effect_sig_ts
-                                 m_ed.FStar_Syntax_Syntax.signature in
-                             let uu___6 =
-                               FStar_Syntax_Util.effect_sig_ts
-                                 n_ed.FStar_Syntax_Syntax.signature in
-                             let uu___7 =
-                               FStar_Syntax_Util.effect_sig_ts
-                                 p_ed.FStar_Syntax_Syntax.signature in
-                             let uu___8 = FStar_Syntax_Util.get_eff_repr m_ed in
-                             let uu___9 = FStar_Syntax_Util.get_eff_repr n_ed in
-                             let uu___10 =
-                               FStar_Syntax_Util.get_eff_repr p_ed in
-                             let uu___11 =
-                               FStar_TypeChecker_Env.get_range env1 in
-                             validate_indexed_effect_bind_shape env1 m n p
-                               uu___5 uu___6 uu___7 uu___8 uu___9 uu___10 us1
-                               ty1 uu___11 Prims.int_zero false in
-                           (match uu___4 with
-                            | (k, kind) ->
-                                ((let uu___6 =
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      (FStar_TypeChecker_Env.debug env1)
-                                      FStar_Options.Extreme in
-                                  if uu___6
-                                  then
-                                    let uu___7 =
-                                      FStar_Syntax_Print.tscheme_to_string
-                                        (us1, t) in
-                                    let uu___8 =
-                                      FStar_Syntax_Print.tscheme_to_string
-                                        (us1, k) in
-                                    FStar_Compiler_Util.print3
-                                      "Polymonadic bind %s after typechecking (%s::%s)\n"
-                                      eff_name uu___7 uu___8
-                                  else ());
-                                 (let uu___7 =
-                                    let uu___8 =
-                                      FStar_Compiler_Util.format1
-                                        "Polymonadic binds (%s in this case) is an experimental feature;it is subject to some redesign in the future. Please keep us informed (on github etc.) about how you are using it"
-                                        eff_name in
-                                    (FStar_Errors.Warning_BleedingEdge_Feature,
-                                      uu___8) in
-                                  FStar_Errors.log_issue r uu___7);
-                                 (let uu___7 =
-                                    let uu___8 =
-                                      FStar_Compiler_Effect.op_Bar_Greater k
-                                        (FStar_Syntax_Subst.close_univ_vars
-                                           us1) in
-                                    (us1, uu___8) in
-                                  ((us1, t), uu___7, kind)))))))
-let (tc_polymonadic_subcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.tscheme ->
-          (FStar_Syntax_Syntax.tscheme * FStar_Syntax_Syntax.tscheme *
-            FStar_Syntax_Syntax.indexed_effect_combinator_kind))
-  =
-  fun env0 ->
-    fun m ->
-      fun n ->
-        fun ts ->
-          let r = (FStar_Pervasives_Native.snd ts).FStar_Syntax_Syntax.pos in
-          check_lift_for_erasable_effects env0 m n r;
-          (let combinator_name =
-             let uu___1 =
-               let uu___2 =
-                 FStar_Compiler_Effect.op_Bar_Greater m
-                   FStar_Ident.ident_of_lid in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                 FStar_Ident.string_of_id in
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Compiler_Effect.op_Bar_Greater n
-                     FStar_Ident.ident_of_lid in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___4
-                   FStar_Ident.string_of_id in
-               Prims.op_Hat " <: " uu___3 in
-             Prims.op_Hat uu___1 uu___2 in
-           let uu___1 =
-             check_and_gen env0 combinator_name "polymonadic_subcomp"
-               Prims.int_one ts in
-           match uu___1 with
-           | (us, t, ty) ->
-               let uu___2 = FStar_Syntax_Subst.open_univ_vars us ty in
-               (match uu___2 with
-                | (us1, ty1) ->
-                    let env = FStar_TypeChecker_Env.push_univ_vars env0 us1 in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_TypeChecker_Env.get_effect_decl env m in
-                      let uu___5 =
-                        FStar_TypeChecker_Env.get_effect_decl env n in
-                      (uu___4, uu___5) in
-                    (match uu___3 with
-                     | (m_ed, n_ed) ->
-                         let uu___4 =
-                           let uu___5 =
-                             FStar_Syntax_Util.effect_sig_ts
-                               m_ed.FStar_Syntax_Syntax.signature in
-                           let uu___6 =
-                             FStar_Syntax_Util.effect_sig_ts
-                               n_ed.FStar_Syntax_Syntax.signature in
-                           let uu___7 = FStar_Syntax_Util.get_eff_repr m_ed in
-                           let uu___8 = FStar_Syntax_Util.get_eff_repr n_ed in
-                           let uu___9 = FStar_Compiler_List.hd us1 in
-                           let uu___10 = FStar_TypeChecker_Env.get_range env in
-                           validate_indexed_effect_subcomp_shape env m n
-                             uu___5 uu___6 uu___7 uu___8 uu___9 ty1
-                             Prims.int_zero uu___10 in
-                         (match uu___4 with
-                          | (k, kind) ->
-                              ((let uu___6 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env)
-                                    FStar_Options.Extreme in
-                                if uu___6
-                                then
-                                  let uu___7 =
-                                    FStar_Syntax_Print.tscheme_to_string
-                                      (us1, t) in
-                                  let uu___8 =
-                                    FStar_Syntax_Print.tscheme_to_string
-                                      (us1, k) in
-                                  FStar_Compiler_Util.print3
-                                    "Polymonadic subcomp %s after typechecking (%s::%s)\n"
-                                    combinator_name uu___7 uu___8
-                                else ());
-                               (let uu___7 =
-                                  let uu___8 =
-                                    FStar_Compiler_Util.format1
-                                      "Polymonadic subcomp (%s in this case) is an experimental feature;it is subject to some redesign in the future. Please keep us informed (on github etc.) about how you are using it"
-                                      combinator_name in
-                                  (FStar_Errors.Warning_BleedingEdge_Feature,
-                                    uu___8) in
-                                FStar_Errors.log_issue r uu___7);
-                               (let uu___7 =
-                                  let uu___8 =
-                                    FStar_Compiler_Effect.op_Bar_Greater k
-                                      (FStar_Syntax_Subst.close_univ_vars us1) in
-                                  (us1, uu___8) in
-                                ((us1, t), uu___7, kind)))))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_TcInductive.ml b/src/ocaml-output/FStar_TypeChecker_TcInductive.ml
deleted file mode 100644
index f852362fcba..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_TcInductive.ml
+++ /dev/null
@@ -1,2949 +0,0 @@
-open Prims
-let (unfold_whnf :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  FStar_TypeChecker_Normalize.unfold_whnf'
-    [FStar_TypeChecker_Env.AllowUnboundUniverses]
-let (tc_tycon :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Syntax_Syntax.sigelt ->
-      (FStar_TypeChecker_Env.env_t * FStar_Syntax_Syntax.sigelt *
-        FStar_Syntax_Syntax.universe * FStar_TypeChecker_Common.guard_t))
-  =
-  fun env ->
-    fun s ->
-      match s.FStar_Syntax_Syntax.sigel with
-      | FStar_Syntax_Syntax.Sig_inductive_typ
-          (tc, uvs, tps, n_uniform, k, mutuals, data) ->
-          let env0 = env in
-          let uu___ = FStar_Syntax_Subst.univ_var_opening uvs in
-          (match uu___ with
-           | (usubst, uvs1) ->
-               let uu___1 =
-                 let uu___2 = FStar_TypeChecker_Env.push_univ_vars env uvs1 in
-                 let uu___3 = FStar_Syntax_Subst.subst_binders usubst tps in
-                 let uu___4 =
-                   let uu___5 =
-                     FStar_Syntax_Subst.shift_subst
-                       (FStar_Compiler_List.length tps) usubst in
-                   FStar_Syntax_Subst.subst uu___5 k in
-                 (uu___2, uu___3, uu___4) in
-               (match uu___1 with
-                | (env1, tps1, k1) ->
-                    let uu___2 = FStar_Syntax_Subst.open_term tps1 k1 in
-                    (match uu___2 with
-                     | (tps2, k2) ->
-                         let uu___3 =
-                           FStar_TypeChecker_TcTerm.tc_binders env1 tps2 in
-                         (match uu___3 with
-                          | (tps3, env_tps, guard_params, us) ->
-                              let uu___4 =
-                                let uu___5 =
-                                  FStar_TypeChecker_TcTerm.tc_tot_or_gtot_term
-                                    env_tps k2 in
-                                match uu___5 with
-                                | (k3, uu___6, g) ->
-                                    let k4 =
-                                      FStar_TypeChecker_Normalize.normalize
-                                        [FStar_TypeChecker_Env.Exclude
-                                           FStar_TypeChecker_Env.Iota;
-                                        FStar_TypeChecker_Env.Exclude
-                                          FStar_TypeChecker_Env.Zeta;
-                                        FStar_TypeChecker_Env.Eager_unfolding;
-                                        FStar_TypeChecker_Env.NoFullNorm;
-                                        FStar_TypeChecker_Env.Exclude
-                                          FStar_TypeChecker_Env.Beta] env_tps
-                                        k3 in
-                                    let uu___7 =
-                                      FStar_Syntax_Util.arrow_formals k4 in
-                                    let uu___8 =
-                                      let uu___9 =
-                                        FStar_TypeChecker_Env.conj_guard
-                                          guard_params g in
-                                      FStar_TypeChecker_Rel.discharge_guard
-                                        env_tps uu___9 in
-                                    (uu___7, uu___8) in
-                              (match uu___4 with
-                               | ((indices, t), guard) ->
-                                   let k3 =
-                                     let uu___5 =
-                                       FStar_Syntax_Syntax.mk_Total t in
-                                     FStar_Syntax_Util.arrow indices uu___5 in
-                                   let uu___5 = FStar_Syntax_Util.type_u () in
-                                   (match uu___5 with
-                                    | (t_type, u) ->
-                                        let valid_type =
-                                          ((FStar_Syntax_Util.is_eqtype_no_unrefine
-                                              t)
-                                             &&
-                                             (let uu___6 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  s.FStar_Syntax_Syntax.sigquals
-                                                  (FStar_Compiler_List.contains
-                                                     FStar_Syntax_Syntax.Unopteq) in
-                                              Prims.op_Negation uu___6))
-                                            ||
-                                            (FStar_TypeChecker_Rel.teq_nosmt_force
-                                               env1 t t_type) in
-                                        (if Prims.op_Negation valid_type
-                                         then
-                                           (let uu___7 =
-                                              let uu___8 =
-                                                let uu___9 =
-                                                  FStar_Syntax_Print.term_to_string
-                                                    t in
-                                                let uu___10 =
-                                                  FStar_Ident.string_of_lid
-                                                    tc in
-                                                FStar_Compiler_Util.format2
-                                                  "Type annotation %s for inductive %s is not Type or eqtype, or it is eqtype but contains unopteq qualifier"
-                                                  uu___9 uu___10 in
-                                              (FStar_Errors.Error_InductiveAnnotNotAType,
-                                                uu___8) in
-                                            FStar_Errors.raise_error uu___7
-                                              s.FStar_Syntax_Syntax.sigrng)
-                                         else ();
-                                         (let usubst1 =
-                                            FStar_Syntax_Subst.univ_var_closing
-                                              uvs1 in
-                                          let guard1 =
-                                            FStar_TypeChecker_Util.close_guard_implicits
-                                              env1 false tps3 guard in
-                                          let t_tc =
-                                            let uu___7 =
-                                              let uu___8 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  tps3
-                                                  (FStar_Syntax_Subst.subst_binders
-                                                     usubst1) in
-                                              let uu___9 =
-                                                let uu___10 =
-                                                  let uu___11 =
-                                                    FStar_Syntax_Subst.shift_subst
-                                                      (FStar_Compiler_List.length
-                                                         tps3) usubst1 in
-                                                  FStar_Syntax_Subst.subst_binders
-                                                    uu___11 in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  indices uu___10 in
-                                              FStar_Compiler_List.op_At
-                                                uu___8 uu___9 in
-                                            let uu___8 =
-                                              let uu___9 =
-                                                let uu___10 =
-                                                  let uu___11 =
-                                                    FStar_Syntax_Subst.shift_subst
-                                                      ((FStar_Compiler_List.length
-                                                          tps3)
-                                                         +
-                                                         (FStar_Compiler_List.length
-                                                            indices)) usubst1 in
-                                                  FStar_Syntax_Subst.subst
-                                                    uu___11 in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  t uu___10 in
-                                              FStar_Syntax_Syntax.mk_Total
-                                                uu___9 in
-                                            FStar_Syntax_Util.arrow uu___7
-                                              uu___8 in
-                                          let tps4 =
-                                            FStar_Syntax_Subst.close_binders
-                                              tps3 in
-                                          let k4 =
-                                            FStar_Syntax_Subst.close tps4 k3 in
-                                          let uu___7 =
-                                            let uu___8 =
-                                              FStar_Syntax_Subst.subst_binders
-                                                usubst1 tps4 in
-                                            let uu___9 =
-                                              let uu___10 =
-                                                FStar_Syntax_Subst.shift_subst
-                                                  (FStar_Compiler_List.length
-                                                     tps4) usubst1 in
-                                              FStar_Syntax_Subst.subst
-                                                uu___10 k4 in
-                                            (uu___8, uu___9) in
-                                          match uu___7 with
-                                          | (tps5, k5) ->
-                                              let fv_tc =
-                                                FStar_Syntax_Syntax.lid_as_fv
-                                                  tc
-                                                  FStar_Syntax_Syntax.delta_constant
-                                                  FStar_Pervasives_Native.None in
-                                              let uu___8 =
-                                                FStar_Syntax_Subst.open_univ_vars
-                                                  uvs1 t_tc in
-                                              (match uu___8 with
-                                               | (uvs2, t_tc1) ->
-                                                   let uu___9 =
-                                                     FStar_TypeChecker_Env.push_let_binding
-                                                       env0
-                                                       (FStar_Pervasives.Inr
-                                                          fv_tc)
-                                                       (uvs2, t_tc1) in
-                                                   (uu___9,
-                                                     {
-                                                       FStar_Syntax_Syntax.sigel
-                                                         =
-                                                         (FStar_Syntax_Syntax.Sig_inductive_typ
-                                                            (tc, uvs2, tps5,
-                                                              n_uniform, k5,
-                                                              mutuals, data));
-                                                       FStar_Syntax_Syntax.sigrng
-                                                         =
-                                                         (s.FStar_Syntax_Syntax.sigrng);
-                                                       FStar_Syntax_Syntax.sigquals
-                                                         =
-                                                         (s.FStar_Syntax_Syntax.sigquals);
-                                                       FStar_Syntax_Syntax.sigmeta
-                                                         =
-                                                         (s.FStar_Syntax_Syntax.sigmeta);
-                                                       FStar_Syntax_Syntax.sigattrs
-                                                         =
-                                                         (s.FStar_Syntax_Syntax.sigattrs);
-                                                       FStar_Syntax_Syntax.sigopts
-                                                         =
-                                                         (s.FStar_Syntax_Syntax.sigopts)
-                                                     }, u, guard1))))))))))
-      | uu___ -> failwith "impossible"
-let (tc_data :
-  FStar_TypeChecker_Env.env_t ->
-    (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.universe) Prims.list ->
-      FStar_Syntax_Syntax.sigelt ->
-        (FStar_Syntax_Syntax.sigelt * FStar_TypeChecker_Common.guard_t))
-  =
-  fun env ->
-    fun tcs ->
-      fun se ->
-        match se.FStar_Syntax_Syntax.sigel with
-        | FStar_Syntax_Syntax.Sig_datacon
-            (c, _uvs, t, tc_lid, ntps, mutual_tcs) ->
-            let uu___ = FStar_Syntax_Subst.univ_var_opening _uvs in
-            (match uu___ with
-             | (usubst, _uvs1) ->
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_TypeChecker_Env.push_univ_vars env _uvs1 in
-                   let uu___3 = FStar_Syntax_Subst.subst usubst t in
-                   (uu___2, uu___3) in
-                 (match uu___1 with
-                  | (env1, t1) ->
-                      let uu___2 =
-                        let tps_u_opt =
-                          FStar_Compiler_Util.find_map tcs
-                            (fun uu___3 ->
-                               match uu___3 with
-                               | (se1, u_tc) ->
-                                   let uu___4 =
-                                     let uu___5 =
-                                       let uu___6 =
-                                         FStar_Syntax_Util.lid_of_sigelt se1 in
-                                       FStar_Compiler_Util.must uu___6 in
-                                     FStar_Ident.lid_equals tc_lid uu___5 in
-                                   if uu___4
-                                   then
-                                     (match se1.FStar_Syntax_Syntax.sigel
-                                      with
-                                      | FStar_Syntax_Syntax.Sig_inductive_typ
-                                          (uu___5, uu___6, tps, uu___7,
-                                           uu___8, uu___9, uu___10)
-                                          ->
-                                          let tps1 =
-                                            let uu___11 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                tps
-                                                (FStar_Syntax_Subst.subst_binders
-                                                   usubst) in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___11
-                                              (FStar_Compiler_List.map
-                                                 (fun x ->
-                                                    {
-                                                      FStar_Syntax_Syntax.binder_bv
-                                                        =
-                                                        (x.FStar_Syntax_Syntax.binder_bv);
-                                                      FStar_Syntax_Syntax.binder_qual
-                                                        =
-                                                        (FStar_Pervasives_Native.Some
-                                                           FStar_Syntax_Syntax.imp_tag);
-                                                      FStar_Syntax_Syntax.binder_attrs
-                                                        =
-                                                        (x.FStar_Syntax_Syntax.binder_attrs)
-                                                    })) in
-                                          let tps2 =
-                                            FStar_Syntax_Subst.open_binders
-                                              tps1 in
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_TypeChecker_Env.push_binders
-                                                env1 tps2 in
-                                            (uu___12, tps2, u_tc) in
-                                          FStar_Pervasives_Native.Some
-                                            uu___11
-                                      | uu___5 -> failwith "Impossible")
-                                   else FStar_Pervasives_Native.None) in
-                        match tps_u_opt with
-                        | FStar_Pervasives_Native.Some x -> x
-                        | FStar_Pervasives_Native.None ->
-                            let uu___3 =
-                              FStar_Ident.lid_equals tc_lid
-                                FStar_Parser_Const.exn_lid in
-                            if uu___3
-                            then (env1, [], FStar_Syntax_Syntax.U_zero)
-                            else
-                              FStar_Errors.raise_error
-                                (FStar_Errors.Fatal_UnexpectedDataConstructor,
-                                  "Unexpected data constructor")
-                                se.FStar_Syntax_Syntax.sigrng in
-                      (match uu___2 with
-                       | (env2, tps, u_tc) ->
-                           let uu___3 =
-                             let t2 =
-                               FStar_TypeChecker_Normalize.normalize
-                                 (FStar_Compiler_List.op_At
-                                    FStar_TypeChecker_Normalize.whnf_steps
-                                    [FStar_TypeChecker_Env.AllowUnboundUniverses])
-                                 env2 t1 in
-                             let uu___4 =
-                               let uu___5 = FStar_Syntax_Subst.compress t2 in
-                               uu___5.FStar_Syntax_Syntax.n in
-                             match uu___4 with
-                             | FStar_Syntax_Syntax.Tm_arrow (bs, res) ->
-                                 let uu___5 =
-                                   FStar_Compiler_Util.first_N ntps bs in
-                                 (match uu___5 with
-                                  | (uu___6, bs') ->
-                                      let t3 =
-                                        FStar_Syntax_Syntax.mk
-                                          (FStar_Syntax_Syntax.Tm_arrow
-                                             (bs', res))
-                                          t2.FStar_Syntax_Syntax.pos in
-                                      let subst =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          tps
-                                          (FStar_Compiler_List.mapi
-                                             (fun i ->
-                                                fun uu___7 ->
-                                                  match uu___7 with
-                                                  | {
-                                                      FStar_Syntax_Syntax.binder_bv
-                                                        = x;
-                                                      FStar_Syntax_Syntax.binder_qual
-                                                        = uu___8;
-                                                      FStar_Syntax_Syntax.binder_attrs
-                                                        = uu___9;_}
-                                                      ->
-                                                      FStar_Syntax_Syntax.DB
-                                                        ((ntps -
-                                                            (Prims.int_one +
-                                                               i)), x))) in
-                                      let uu___7 =
-                                        let uu___8 =
-                                          FStar_Syntax_Subst.subst subst t3 in
-                                        FStar_Syntax_Util.arrow_formals_comp
-                                          uu___8 in
-                                      (match uu___7 with
-                                       | (bs1, c1) ->
-                                           let uu___8 =
-                                             (FStar_Options.ml_ish ()) ||
-                                               (FStar_Syntax_Util.is_total_comp
-                                                  c1) in
-                                           if uu___8
-                                           then
-                                             (bs1,
-                                               (FStar_Syntax_Util.comp_result
-                                                  c1))
-                                           else
-                                             (let uu___10 =
-                                                FStar_Ident.range_of_lid
-                                                  (FStar_Syntax_Util.comp_effect_name
-                                                     c1) in
-                                              FStar_Errors.raise_error
-                                                (FStar_Errors.Fatal_UnexpectedConstructorType,
-                                                  "Constructors cannot have effects")
-                                                uu___10)))
-                             | uu___5 -> ([], t2) in
-                           (match uu___3 with
-                            | (arguments, result) ->
-                                ((let uu___5 =
-                                    FStar_TypeChecker_Env.debug env2
-                                      FStar_Options.Low in
-                                  if uu___5
-                                  then
-                                    let uu___6 =
-                                      FStar_Syntax_Print.lid_to_string c in
-                                    let uu___7 =
-                                      FStar_Syntax_Print.binders_to_string
-                                        "->" arguments in
-                                    let uu___8 =
-                                      FStar_Syntax_Print.term_to_string
-                                        result in
-                                    FStar_Compiler_Util.print3
-                                      "Checking datacon  %s : %s -> %s \n"
-                                      uu___6 uu___7 uu___8
-                                  else ());
-                                 (let uu___5 =
-                                    FStar_TypeChecker_TcTerm.tc_tparams env2
-                                      arguments in
-                                  match uu___5 with
-                                  | (arguments1, env', us) ->
-                                      let type_u_tc =
-                                        FStar_Syntax_Syntax.mk
-                                          (FStar_Syntax_Syntax.Tm_type u_tc)
-                                          result.FStar_Syntax_Syntax.pos in
-                                      let env'1 =
-                                        FStar_TypeChecker_Env.set_expected_typ
-                                          env' type_u_tc in
-                                      let uu___6 =
-                                        FStar_TypeChecker_TcTerm.tc_trivial_guard
-                                          env'1 result in
-                                      (match uu___6 with
-                                       | (result1, res_lcomp) ->
-                                           let uu___7 =
-                                             FStar_Syntax_Util.head_and_args_full
-                                               result1 in
-                                           (match uu___7 with
-                                            | (head, args) ->
-                                                let g_uvs =
-                                                  let uu___8 =
-                                                    let uu___9 =
-                                                      FStar_Syntax_Subst.compress
-                                                        head in
-                                                    uu___9.FStar_Syntax_Syntax.n in
-                                                  match uu___8 with
-                                                  | FStar_Syntax_Syntax.Tm_uinst
-                                                      ({
-                                                         FStar_Syntax_Syntax.n
-                                                           =
-                                                           FStar_Syntax_Syntax.Tm_fvar
-                                                           fv;
-                                                         FStar_Syntax_Syntax.pos
-                                                           = uu___9;
-                                                         FStar_Syntax_Syntax.vars
-                                                           = uu___10;
-                                                         FStar_Syntax_Syntax.hash_code
-                                                           = uu___11;_},
-                                                       tuvs)
-                                                      when
-                                                      FStar_Syntax_Syntax.fv_eq_lid
-                                                        fv tc_lid
-                                                      ->
-                                                      if
-                                                        (FStar_Compiler_List.length
-                                                           _uvs1)
-                                                          =
-                                                          (FStar_Compiler_List.length
-                                                             tuvs)
-                                                      then
-                                                        FStar_Compiler_List.fold_left2
-                                                          (fun g ->
-                                                             fun u1 ->
-                                                               fun u2 ->
-                                                                 let uu___12
-                                                                   =
-                                                                   let uu___13
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk
-                                                                    (FStar_Syntax_Syntax.Tm_type
-                                                                    u1)
-                                                                    FStar_Compiler_Range.dummyRange in
-                                                                   let uu___14
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk
-                                                                    (FStar_Syntax_Syntax.Tm_type
-                                                                    (FStar_Syntax_Syntax.U_name
-                                                                    u2))
-                                                                    FStar_Compiler_Range.dummyRange in
-                                                                   FStar_TypeChecker_Rel.teq
-                                                                    env'1
-                                                                    uu___13
-                                                                    uu___14 in
-                                                                 FStar_TypeChecker_Env.conj_guard
-                                                                   g uu___12)
-                                                          FStar_TypeChecker_Env.trivial_guard
-                                                          tuvs _uvs1
-                                                      else
-                                                        FStar_Errors.raise_error
-                                                          (FStar_Errors.Fatal_UnexpectedConstructorType,
-                                                            "Length of annotated universes does not match inferred universes")
-                                                          se.FStar_Syntax_Syntax.sigrng
-                                                  | FStar_Syntax_Syntax.Tm_fvar
-                                                      fv when
-                                                      FStar_Syntax_Syntax.fv_eq_lid
-                                                        fv tc_lid
-                                                      ->
-                                                      FStar_TypeChecker_Env.trivial_guard
-                                                  | uu___9 ->
-                                                      let uu___10 =
-                                                        let uu___11 =
-                                                          let uu___12 =
-                                                            FStar_Syntax_Print.lid_to_string
-                                                              tc_lid in
-                                                          let uu___13 =
-                                                            FStar_Syntax_Print.term_to_string
-                                                              head in
-                                                          FStar_Compiler_Util.format2
-                                                            "Expected a constructor of type %s; got %s"
-                                                            uu___12 uu___13 in
-                                                        (FStar_Errors.Fatal_UnexpectedConstructorType,
-                                                          uu___11) in
-                                                      FStar_Errors.raise_error
-                                                        uu___10
-                                                        se.FStar_Syntax_Syntax.sigrng in
-                                                let g =
-                                                  FStar_Compiler_List.fold_left2
-                                                    (fun g1 ->
-                                                       fun uu___8 ->
-                                                         fun u_x ->
-                                                           match uu___8 with
-                                                           | {
-                                                               FStar_Syntax_Syntax.binder_bv
-                                                                 = x;
-                                                               FStar_Syntax_Syntax.binder_qual
-                                                                 = uu___9;
-                                                               FStar_Syntax_Syntax.binder_attrs
-                                                                 = uu___10;_}
-                                                               ->
-                                                               let uu___11 =
-                                                                 FStar_TypeChecker_Rel.universe_inequality
-                                                                   u_x u_tc in
-                                                               FStar_TypeChecker_Env.conj_guard
-                                                                 g1 uu___11)
-                                                    g_uvs arguments1 us in
-                                                (FStar_Errors.stop_if_err ();
-                                                 (let p_args =
-                                                    let uu___9 =
-                                                      FStar_Compiler_Util.first_N
-                                                        (FStar_Compiler_List.length
-                                                           tps) args in
-                                                    FStar_Pervasives_Native.fst
-                                                      uu___9 in
-                                                  FStar_Compiler_List.iter2
-                                                    (fun uu___10 ->
-                                                       fun uu___11 ->
-                                                         match (uu___10,
-                                                                 uu___11)
-                                                         with
-                                                         | ({
-                                                              FStar_Syntax_Syntax.binder_bv
-                                                                = bv;
-                                                              FStar_Syntax_Syntax.binder_qual
-                                                                = uu___12;
-                                                              FStar_Syntax_Syntax.binder_attrs
-                                                                = uu___13;_},
-                                                            (t2, uu___14)) ->
-                                                             let uu___15 =
-                                                               let uu___16 =
-                                                                 FStar_Syntax_Subst.compress
-                                                                   t2 in
-                                                               uu___16.FStar_Syntax_Syntax.n in
-                                                             (match uu___15
-                                                              with
-                                                              | FStar_Syntax_Syntax.Tm_name
-                                                                  bv' when
-                                                                  FStar_Syntax_Syntax.bv_eq
-                                                                    bv bv'
-                                                                  -> ()
-                                                              | uu___16 ->
-                                                                  let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Syntax_Print.bv_to_string
-                                                                    bv in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t2 in
-                                                                    FStar_Compiler_Util.format2
-                                                                    "This parameter is not constant: expected %s, got %s"
-                                                                    uu___19
-                                                                    uu___20 in
-                                                                    (FStar_Errors.Error_BadInductiveParam,
-                                                                    uu___18) in
-                                                                  FStar_Errors.raise_error
-                                                                    uu___17
-                                                                    t2.FStar_Syntax_Syntax.pos))
-                                                    tps p_args;
-                                                  (let ty =
-                                                     let uu___10 =
-                                                       unfold_whnf env2
-                                                         res_lcomp.FStar_TypeChecker_Common.res_typ in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___10
-                                                       FStar_Syntax_Util.unrefine in
-                                                   (let uu___11 =
-                                                      let uu___12 =
-                                                        FStar_Syntax_Subst.compress
-                                                          ty in
-                                                      uu___12.FStar_Syntax_Syntax.n in
-                                                    match uu___11 with
-                                                    | FStar_Syntax_Syntax.Tm_type
-                                                        uu___12 -> ()
-                                                    | uu___12 ->
-                                                        let uu___13 =
-                                                          let uu___14 =
-                                                            let uu___15 =
-                                                              FStar_Syntax_Print.term_to_string
-                                                                result1 in
-                                                            let uu___16 =
-                                                              FStar_Syntax_Print.term_to_string
-                                                                ty in
-                                                            FStar_Compiler_Util.format2
-                                                              "The type of %s is %s, but since this is the result type of a constructor its type should be Type"
-                                                              uu___15 uu___16 in
-                                                          (FStar_Errors.Fatal_WrongResultTypeAfterConstrutor,
-                                                            uu___14) in
-                                                        FStar_Errors.raise_error
-                                                          uu___13
-                                                          se.FStar_Syntax_Syntax.sigrng);
-                                                   (let t2 =
-                                                      let uu___11 =
-                                                        let uu___12 =
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            tps
-                                                            (FStar_Compiler_List.map
-                                                               (fun b ->
-                                                                  {
-                                                                    FStar_Syntax_Syntax.binder_bv
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_bv);
-                                                                    FStar_Syntax_Syntax.binder_qual
-                                                                    =
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    (FStar_Syntax_Syntax.Implicit
-                                                                    true));
-                                                                    FStar_Syntax_Syntax.binder_attrs
-                                                                    =
-                                                                    (b.FStar_Syntax_Syntax.binder_attrs)
-                                                                  })) in
-                                                        FStar_Compiler_List.op_At
-                                                          uu___12 arguments1 in
-                                                      let uu___12 =
-                                                        FStar_Syntax_Syntax.mk_Total
-                                                          result1 in
-                                                      FStar_Syntax_Util.arrow
-                                                        uu___11 uu___12 in
-                                                    let t3 =
-                                                      FStar_Syntax_Subst.close_univ_vars
-                                                        _uvs1 t2 in
-                                                    ({
-                                                       FStar_Syntax_Syntax.sigel
-                                                         =
-                                                         (FStar_Syntax_Syntax.Sig_datacon
-                                                            (c, _uvs1, t3,
-                                                              tc_lid, ntps,
-                                                              mutual_tcs));
-                                                       FStar_Syntax_Syntax.sigrng
-                                                         =
-                                                         (se.FStar_Syntax_Syntax.sigrng);
-                                                       FStar_Syntax_Syntax.sigquals
-                                                         =
-                                                         (se.FStar_Syntax_Syntax.sigquals);
-                                                       FStar_Syntax_Syntax.sigmeta
-                                                         =
-                                                         (se.FStar_Syntax_Syntax.sigmeta);
-                                                       FStar_Syntax_Syntax.sigattrs
-                                                         =
-                                                         (se.FStar_Syntax_Syntax.sigattrs);
-                                                       FStar_Syntax_Syntax.sigopts
-                                                         =
-                                                         (se.FStar_Syntax_Syntax.sigopts)
-                                                     }, g)))))))))))))
-        | uu___ -> failwith "impossible"
-let (generalize_and_inst_within :
-  FStar_TypeChecker_Env.env_t ->
-    (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.universe) Prims.list ->
-      FStar_Syntax_Syntax.sigelt Prims.list ->
-        (FStar_Syntax_Syntax.sigelt Prims.list * FStar_Syntax_Syntax.sigelt
-          Prims.list))
-  =
-  fun env ->
-    fun tcs ->
-      fun datas ->
-        let binders =
-          FStar_Compiler_Effect.op_Bar_Greater tcs
-            (FStar_Compiler_List.map
-               (fun uu___ ->
-                  match uu___ with
-                  | (se, uu___1) ->
-                      (match se.FStar_Syntax_Syntax.sigel with
-                       | FStar_Syntax_Syntax.Sig_inductive_typ
-                           (uu___2, uu___3, tps, uu___4, k, uu___5, uu___6)
-                           ->
-                           let uu___7 =
-                             let uu___8 = FStar_Syntax_Syntax.mk_Total k in
-                             FStar_Compiler_Effect.op_Less_Bar
-                               (FStar_Syntax_Util.arrow tps) uu___8 in
-                           FStar_Syntax_Syntax.null_binder uu___7
-                       | uu___2 -> failwith "Impossible"))) in
-        let binders' =
-          FStar_Compiler_Effect.op_Bar_Greater datas
-            (FStar_Compiler_List.map
-               (fun se ->
-                  match se.FStar_Syntax_Syntax.sigel with
-                  | FStar_Syntax_Syntax.Sig_datacon
-                      (uu___, uu___1, t, uu___2, uu___3, uu___4) ->
-                      FStar_Syntax_Syntax.null_binder t
-                  | uu___ -> failwith "Impossible")) in
-        let t =
-          let uu___ = FStar_Syntax_Syntax.mk_Total FStar_Syntax_Syntax.t_unit in
-          FStar_Syntax_Util.arrow
-            (FStar_Compiler_List.op_At binders binders') uu___ in
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar
-             (FStar_TypeChecker_Env.debug env)
-             (FStar_Options.Other "GenUniverses") in
-         if uu___1
-         then
-           let uu___2 = FStar_TypeChecker_Normalize.term_to_string env t in
-           FStar_Compiler_Util.print1
-             "@@@@@@Trying to generalize universes in %s\n" uu___2
-         else ());
-        (let uu___1 = FStar_TypeChecker_Generalize.generalize_universes env t in
-         match uu___1 with
-         | (uvs, t1) ->
-             ((let uu___3 =
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (FStar_TypeChecker_Env.debug env)
-                   (FStar_Options.Other "GenUniverses") in
-               if uu___3
-               then
-                 let uu___4 =
-                   let uu___5 =
-                     FStar_Compiler_Effect.op_Bar_Greater uvs
-                       (FStar_Compiler_List.map
-                          (fun u -> FStar_Ident.string_of_id u)) in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___5
-                     (FStar_String.concat ", ") in
-                 let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                 FStar_Compiler_Util.print2 "@@@@@@Generalized to (%s, %s)\n"
-                   uu___4 uu___5
-               else ());
-              (let uu___3 = FStar_Syntax_Subst.open_univ_vars uvs t1 in
-               match uu___3 with
-               | (uvs1, t2) ->
-                   let uu___4 = FStar_Syntax_Util.arrow_formals t2 in
-                   (match uu___4 with
-                    | (args, uu___5) ->
-                        let uu___6 =
-                          FStar_Compiler_Util.first_N
-                            (FStar_Compiler_List.length binders) args in
-                        (match uu___6 with
-                         | (tc_types, data_types) ->
-                             let tcs1 =
-                               FStar_Compiler_List.map2
-                                 (fun uu___7 ->
-                                    fun uu___8 ->
-                                      match (uu___7, uu___8) with
-                                      | ({ FStar_Syntax_Syntax.binder_bv = x;
-                                           FStar_Syntax_Syntax.binder_qual =
-                                             uu___9;
-                                           FStar_Syntax_Syntax.binder_attrs =
-                                             uu___10;_},
-                                         (se, uu___11)) ->
-                                          (match se.FStar_Syntax_Syntax.sigel
-                                           with
-                                           | FStar_Syntax_Syntax.Sig_inductive_typ
-                                               (tc, uu___12, tps,
-                                                num_uniform, uu___13,
-                                                mutuals, datas1)
-                                               ->
-                                               let ty =
-                                                 FStar_Syntax_Subst.close_univ_vars
-                                                   uvs1
-                                                   x.FStar_Syntax_Syntax.sort in
-                                               let uu___14 =
-                                                 let uu___15 =
-                                                   let uu___16 =
-                                                     FStar_Syntax_Subst.compress
-                                                       ty in
-                                                   uu___16.FStar_Syntax_Syntax.n in
-                                                 match uu___15 with
-                                                 | FStar_Syntax_Syntax.Tm_arrow
-                                                     (binders1, c) ->
-                                                     let uu___16 =
-                                                       FStar_Compiler_Util.first_N
-                                                         (FStar_Compiler_List.length
-                                                            tps) binders1 in
-                                                     (match uu___16 with
-                                                      | (tps1, rest) ->
-                                                          let t3 =
-                                                            match rest with
-                                                            | [] ->
-                                                                FStar_Syntax_Util.comp_result
-                                                                  c
-                                                            | uu___17 ->
-                                                                FStar_Syntax_Syntax.mk
-                                                                  (FStar_Syntax_Syntax.Tm_arrow
-                                                                    (rest, c))
-                                                                  (x.FStar_Syntax_Syntax.sort).FStar_Syntax_Syntax.pos in
-                                                          (tps1, t3))
-                                                 | uu___16 -> ([], ty) in
-                                               (match uu___14 with
-                                                | (tps1, t3) ->
-                                                    {
-                                                      FStar_Syntax_Syntax.sigel
-                                                        =
-                                                        (FStar_Syntax_Syntax.Sig_inductive_typ
-                                                           (tc, uvs1, tps1,
-                                                             num_uniform, t3,
-                                                             mutuals, datas1));
-                                                      FStar_Syntax_Syntax.sigrng
-                                                        =
-                                                        (se.FStar_Syntax_Syntax.sigrng);
-                                                      FStar_Syntax_Syntax.sigquals
-                                                        =
-                                                        (se.FStar_Syntax_Syntax.sigquals);
-                                                      FStar_Syntax_Syntax.sigmeta
-                                                        =
-                                                        (se.FStar_Syntax_Syntax.sigmeta);
-                                                      FStar_Syntax_Syntax.sigattrs
-                                                        =
-                                                        (se.FStar_Syntax_Syntax.sigattrs);
-                                                      FStar_Syntax_Syntax.sigopts
-                                                        =
-                                                        (se.FStar_Syntax_Syntax.sigopts)
-                                                    })
-                                           | uu___12 -> failwith "Impossible"))
-                                 tc_types tcs in
-                             let datas1 =
-                               match uvs1 with
-                               | [] -> datas
-                               | uu___7 ->
-                                   let uvs_universes =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uvs1
-                                       (FStar_Compiler_List.map
-                                          (fun uu___8 ->
-                                             FStar_Syntax_Syntax.U_name
-                                               uu___8)) in
-                                   let tc_insts =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       tcs1
-                                       (FStar_Compiler_List.map
-                                          (fun uu___8 ->
-                                             match uu___8 with
-                                             | {
-                                                 FStar_Syntax_Syntax.sigel =
-                                                   FStar_Syntax_Syntax.Sig_inductive_typ
-                                                   (tc, uu___9, uu___10,
-                                                    uu___11, uu___12,
-                                                    uu___13, uu___14);
-                                                 FStar_Syntax_Syntax.sigrng =
-                                                   uu___15;
-                                                 FStar_Syntax_Syntax.sigquals
-                                                   = uu___16;
-                                                 FStar_Syntax_Syntax.sigmeta
-                                                   = uu___17;
-                                                 FStar_Syntax_Syntax.sigattrs
-                                                   = uu___18;
-                                                 FStar_Syntax_Syntax.sigopts
-                                                   = uu___19;_}
-                                                 -> (tc, uvs_universes)
-                                             | uu___9 ->
-                                                 failwith "Impossible")) in
-                                   FStar_Compiler_List.map2
-                                     (fun uu___8 ->
-                                        fun d ->
-                                          match uu___8 with
-                                          | {
-                                              FStar_Syntax_Syntax.binder_bv =
-                                                t3;
-                                              FStar_Syntax_Syntax.binder_qual
-                                                = uu___9;
-                                              FStar_Syntax_Syntax.binder_attrs
-                                                = uu___10;_}
-                                              ->
-                                              (match d.FStar_Syntax_Syntax.sigel
-                                               with
-                                               | FStar_Syntax_Syntax.Sig_datacon
-                                                   (l, uu___11, uu___12, tc,
-                                                    ntps, mutuals)
-                                                   ->
-                                                   let ty =
-                                                     let uu___13 =
-                                                       FStar_Syntax_InstFV.instantiate
-                                                         tc_insts
-                                                         t3.FStar_Syntax_Syntax.sort in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___13
-                                                       (FStar_Syntax_Subst.close_univ_vars
-                                                          uvs1) in
-                                                   {
-                                                     FStar_Syntax_Syntax.sigel
-                                                       =
-                                                       (FStar_Syntax_Syntax.Sig_datacon
-                                                          (l, uvs1, ty, tc,
-                                                            ntps, mutuals));
-                                                     FStar_Syntax_Syntax.sigrng
-                                                       =
-                                                       (d.FStar_Syntax_Syntax.sigrng);
-                                                     FStar_Syntax_Syntax.sigquals
-                                                       =
-                                                       (d.FStar_Syntax_Syntax.sigquals);
-                                                     FStar_Syntax_Syntax.sigmeta
-                                                       =
-                                                       (d.FStar_Syntax_Syntax.sigmeta);
-                                                     FStar_Syntax_Syntax.sigattrs
-                                                       =
-                                                       (d.FStar_Syntax_Syntax.sigattrs);
-                                                     FStar_Syntax_Syntax.sigopts
-                                                       =
-                                                       (d.FStar_Syntax_Syntax.sigopts)
-                                                   }
-                                               | uu___11 ->
-                                                   failwith "Impossible"))
-                                     data_types datas in
-                             (tcs1, datas1))))))
-let (datacon_typ : FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.term) =
-  fun data ->
-    match data.FStar_Syntax_Syntax.sigel with
-    | FStar_Syntax_Syntax.Sig_datacon
-        (uu___, uu___1, t, uu___2, uu___3, uu___4) -> t
-    | uu___ -> failwith "Impossible!"
-let (haseq_suffix : Prims.string) = "__uu___haseq"
-let (is_haseq_lid : FStar_Ident.lid -> Prims.bool) =
-  fun lid ->
-    let str = FStar_Ident.string_of_lid lid in
-    let len = FStar_String.length str in
-    let haseq_suffix_len = FStar_String.length haseq_suffix in
-    (len > haseq_suffix_len) &&
-      (let uu___ =
-         let uu___1 =
-           FStar_String.substring str (len - haseq_suffix_len)
-             haseq_suffix_len in
-         FStar_String.compare uu___1 haseq_suffix in
-       uu___ = Prims.int_zero)
-let (get_haseq_axiom_lid : FStar_Ident.lid -> FStar_Ident.lid) =
-  fun lid ->
-    let uu___ =
-      let uu___1 = FStar_Ident.ns_of_lid lid in
-      let uu___2 =
-        let uu___3 =
-          let uu___4 =
-            let uu___5 =
-              let uu___6 = FStar_Ident.ident_of_lid lid in
-              FStar_Ident.string_of_id uu___6 in
-            Prims.op_Hat uu___5 haseq_suffix in
-          FStar_Ident.id_of_text uu___4 in
-        [uu___3] in
-      FStar_Compiler_List.op_At uu___1 uu___2 in
-    FStar_Ident.lid_of_ids uu___
-let (get_optimized_haseq_axiom :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sigelt ->
-      FStar_Syntax_Syntax.subst_elt Prims.list ->
-        FStar_Syntax_Syntax.univ_names ->
-          (FStar_Ident.lident * FStar_Syntax_Syntax.term *
-            FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.binders *
-            FStar_Syntax_Syntax.term))
-  =
-  fun en ->
-    fun ty ->
-      fun usubst ->
-        fun us ->
-          let uu___ =
-            match ty.FStar_Syntax_Syntax.sigel with
-            | FStar_Syntax_Syntax.Sig_inductive_typ
-                (lid, uu___1, bs, uu___2, t, uu___3, uu___4) -> (lid, bs, t)
-            | uu___1 -> failwith "Impossible!" in
-          match uu___ with
-          | (lid, bs, t) ->
-              let bs1 = FStar_Syntax_Subst.subst_binders usubst bs in
-              let t1 =
-                let uu___1 =
-                  FStar_Syntax_Subst.shift_subst
-                    (FStar_Compiler_List.length bs1) usubst in
-                FStar_Syntax_Subst.subst uu___1 t in
-              let uu___1 = FStar_Syntax_Subst.open_term bs1 t1 in
-              (match uu___1 with
-               | (bs2, t2) ->
-                   let ibs =
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Subst.compress t2 in
-                       uu___3.FStar_Syntax_Syntax.n in
-                     match uu___2 with
-                     | FStar_Syntax_Syntax.Tm_arrow (ibs1, uu___3) -> ibs1
-                     | uu___3 -> [] in
-                   let ibs1 = FStar_Syntax_Subst.open_binders ibs in
-                   let ind =
-                     let uu___2 =
-                       FStar_Syntax_Syntax.fvar lid
-                         FStar_Syntax_Syntax.delta_constant
-                         FStar_Pervasives_Native.None in
-                     let uu___3 =
-                       FStar_Compiler_List.map
-                         (fun u -> FStar_Syntax_Syntax.U_name u) us in
-                     FStar_Syntax_Syntax.mk_Tm_uinst uu___2 uu___3 in
-                   let ind1 =
-                     let uu___2 =
-                       FStar_Compiler_List.map
-                         FStar_Syntax_Util.arg_of_non_null_binder bs2 in
-                     FStar_Syntax_Syntax.mk_Tm_app ind uu___2
-                       FStar_Compiler_Range.dummyRange in
-                   let ind2 =
-                     let uu___2 =
-                       FStar_Compiler_List.map
-                         FStar_Syntax_Util.arg_of_non_null_binder ibs1 in
-                     FStar_Syntax_Syntax.mk_Tm_app ind1 uu___2
-                       FStar_Compiler_Range.dummyRange in
-                   let haseq_ind =
-                     let uu___2 =
-                       let uu___3 = FStar_Syntax_Syntax.as_arg ind2 in
-                       [uu___3] in
-                     FStar_Syntax_Syntax.mk_Tm_app FStar_Syntax_Util.t_haseq
-                       uu___2 FStar_Compiler_Range.dummyRange in
-                   let bs' =
-                     FStar_Compiler_List.filter
-                       (fun b ->
-                          let uu___2 =
-                            let uu___3 = FStar_Syntax_Util.type_u () in
-                            FStar_Pervasives_Native.fst uu___3 in
-                          FStar_TypeChecker_Rel.subtype_nosmt_force en
-                            (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                            uu___2) bs2 in
-                   let haseq_bs =
-                     FStar_Compiler_List.fold_left
-                       (fun t3 ->
-                          fun b ->
-                            let uu___2 =
-                              let uu___3 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    FStar_Syntax_Syntax.bv_to_name
-                                      b.FStar_Syntax_Syntax.binder_bv in
-                                  FStar_Syntax_Syntax.as_arg uu___5 in
-                                [uu___4] in
-                              FStar_Syntax_Syntax.mk_Tm_app
-                                FStar_Syntax_Util.t_haseq uu___3
-                                FStar_Compiler_Range.dummyRange in
-                            FStar_Syntax_Util.mk_conj t3 uu___2)
-                       FStar_Syntax_Util.t_true bs' in
-                   let fml = FStar_Syntax_Util.mk_imp haseq_bs haseq_ind in
-                   let fml1 =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 =
-                           let uu___5 =
-                             let uu___6 =
-                               FStar_Syntax_Syntax.binders_to_names ibs1 in
-                             let uu___7 =
-                               let uu___8 =
-                                 let uu___9 =
-                                   FStar_Syntax_Syntax.as_arg haseq_ind in
-                                 [uu___9] in
-                               [uu___8] in
-                             (uu___6, uu___7) in
-                           FStar_Syntax_Syntax.Meta_pattern uu___5 in
-                         (fml, uu___4) in
-                       FStar_Syntax_Syntax.Tm_meta uu___3 in
-                     {
-                       FStar_Syntax_Syntax.n = uu___2;
-                       FStar_Syntax_Syntax.pos =
-                         (fml.FStar_Syntax_Syntax.pos);
-                       FStar_Syntax_Syntax.vars =
-                         (fml.FStar_Syntax_Syntax.vars);
-                       FStar_Syntax_Syntax.hash_code =
-                         (fml.FStar_Syntax_Syntax.hash_code)
-                     } in
-                   let fml2 =
-                     FStar_Compiler_List.fold_right
-                       (fun b ->
-                          fun t3 ->
-                            let uu___2 =
-                              let uu___3 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      FStar_Syntax_Syntax.mk_binder
-                                        b.FStar_Syntax_Syntax.binder_bv in
-                                    [uu___6] in
-                                  let uu___6 =
-                                    FStar_Syntax_Subst.close [b] t3 in
-                                  FStar_Syntax_Util.abs uu___5 uu___6
-                                    FStar_Pervasives_Native.None in
-                                FStar_Syntax_Syntax.as_arg uu___4 in
-                              [uu___3] in
-                            FStar_Syntax_Syntax.mk_Tm_app
-                              FStar_Syntax_Util.tforall uu___2
-                              FStar_Compiler_Range.dummyRange) ibs1 fml1 in
-                   let fml3 =
-                     FStar_Compiler_List.fold_right
-                       (fun b ->
-                          fun t3 ->
-                            let uu___2 =
-                              let uu___3 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    let uu___6 =
-                                      FStar_Syntax_Syntax.mk_binder
-                                        b.FStar_Syntax_Syntax.binder_bv in
-                                    [uu___6] in
-                                  let uu___6 =
-                                    FStar_Syntax_Subst.close [b] t3 in
-                                  FStar_Syntax_Util.abs uu___5 uu___6
-                                    FStar_Pervasives_Native.None in
-                                FStar_Syntax_Syntax.as_arg uu___4 in
-                              [uu___3] in
-                            FStar_Syntax_Syntax.mk_Tm_app
-                              FStar_Syntax_Util.tforall uu___2
-                              FStar_Compiler_Range.dummyRange) bs2 fml2 in
-                   let axiom_lid = get_haseq_axiom_lid lid in
-                   (axiom_lid, fml3, bs2, ibs1, haseq_bs))
-let (optimized_haseq_soundness_for_data :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.sigelt ->
-      FStar_Syntax_Syntax.subst_elt Prims.list ->
-        FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.term)
-  =
-  fun ty_lid ->
-    fun data ->
-      fun usubst ->
-        fun bs ->
-          let dt = datacon_typ data in
-          let dt1 = FStar_Syntax_Subst.subst usubst dt in
-          let uu___ =
-            let uu___1 = FStar_Syntax_Subst.compress dt1 in
-            uu___1.FStar_Syntax_Syntax.n in
-          match uu___ with
-          | FStar_Syntax_Syntax.Tm_arrow (dbs, uu___1) ->
-              let dbs1 =
-                let uu___2 =
-                  FStar_Compiler_List.splitAt (FStar_Compiler_List.length bs)
-                    dbs in
-                FStar_Pervasives_Native.snd uu___2 in
-              let dbs2 =
-                let uu___2 = FStar_Syntax_Subst.opening_of_binders bs in
-                FStar_Syntax_Subst.subst_binders uu___2 dbs1 in
-              let dbs3 = FStar_Syntax_Subst.open_binders dbs2 in
-              let cond =
-                FStar_Compiler_List.fold_left
-                  (fun t ->
-                     fun b ->
-                       let haseq_b =
-                         let uu___2 =
-                           let uu___3 =
-                             FStar_Syntax_Syntax.as_arg
-                               (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                           [uu___3] in
-                         FStar_Syntax_Syntax.mk_Tm_app
-                           FStar_Syntax_Util.t_haseq uu___2
-                           FStar_Compiler_Range.dummyRange in
-                       let sort_range =
-                         ((b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort).FStar_Syntax_Syntax.pos in
-                       let haseq_b1 =
-                         let uu___2 =
-                           let uu___3 = FStar_Ident.string_of_lid ty_lid in
-                           FStar_Compiler_Util.format1
-                             "Failed to prove that the type '%s' supports decidable equality because of this argument; add either the 'noeq' or 'unopteq' qualifier"
-                             uu___3 in
-                         FStar_TypeChecker_Util.label uu___2 sort_range
-                           haseq_b in
-                       FStar_Syntax_Util.mk_conj t haseq_b1)
-                  FStar_Syntax_Util.t_true dbs3 in
-              FStar_Compiler_List.fold_right
-                (fun b ->
-                   fun t ->
-                     let uu___2 =
-                       let uu___3 =
-                         FStar_Syntax_Syntax.iarg
-                           (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                       let uu___4 =
-                         let uu___5 =
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Syntax_Syntax.mk_binder
-                                   b.FStar_Syntax_Syntax.binder_bv in
-                               [uu___8] in
-                             let uu___8 = FStar_Syntax_Subst.close [b] t in
-                             FStar_Syntax_Util.abs uu___7 uu___8
-                               FStar_Pervasives_Native.None in
-                           FStar_Syntax_Syntax.as_arg uu___6 in
-                         [uu___5] in
-                       uu___3 :: uu___4 in
-                     FStar_Syntax_Syntax.mk_Tm_app FStar_Syntax_Util.tforall
-                       uu___2 FStar_Compiler_Range.dummyRange) dbs3 cond
-          | uu___1 -> FStar_Syntax_Util.t_true
-let (optimized_haseq_ty :
-  FStar_Syntax_Syntax.sigelts ->
-    FStar_Syntax_Syntax.subst_elt Prims.list ->
-      FStar_Syntax_Syntax.univ_name Prims.list ->
-        ((FStar_Ident.lident * FStar_Syntax_Syntax.term) Prims.list *
-          FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax * FStar_Syntax_Syntax.term'
-          FStar_Syntax_Syntax.syntax) ->
-          FStar_Syntax_Syntax.sigelt ->
-            ((FStar_Ident.lident * FStar_Syntax_Syntax.term) Prims.list *
-              FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.term'
-              FStar_Syntax_Syntax.syntax * FStar_Syntax_Syntax.term'
-              FStar_Syntax_Syntax.syntax))
-  =
-  fun all_datas_in_the_bundle ->
-    fun usubst ->
-      fun us ->
-        fun acc ->
-          fun ty ->
-            let lid =
-              match ty.FStar_Syntax_Syntax.sigel with
-              | FStar_Syntax_Syntax.Sig_inductive_typ
-                  (lid1, uu___, uu___1, uu___2, uu___3, uu___4, uu___5) ->
-                  lid1
-              | uu___ -> failwith "Impossible!" in
-            let uu___ = acc in
-            match uu___ with
-            | (uu___1, en, uu___2, uu___3) ->
-                let uu___4 = get_optimized_haseq_axiom en ty usubst us in
-                (match uu___4 with
-                 | (axiom_lid, fml, bs, ibs, haseq_bs) ->
-                     let guard = FStar_Syntax_Util.mk_conj haseq_bs fml in
-                     let uu___5 = acc in
-                     (match uu___5 with
-                      | (l_axioms, env, guard', cond') ->
-                          let env1 =
-                            FStar_TypeChecker_Env.push_binders env bs in
-                          let env2 =
-                            FStar_TypeChecker_Env.push_binders env1 ibs in
-                          let t_datas =
-                            FStar_Compiler_List.filter
-                              (fun s ->
-                                 match s.FStar_Syntax_Syntax.sigel with
-                                 | FStar_Syntax_Syntax.Sig_datacon
-                                     (uu___6, uu___7, uu___8, t_lid, uu___9,
-                                      uu___10)
-                                     -> t_lid = lid
-                                 | uu___6 -> failwith "Impossible")
-                              all_datas_in_the_bundle in
-                          let cond =
-                            FStar_Compiler_List.fold_left
-                              (fun acc1 ->
-                                 fun d ->
-                                   let uu___6 =
-                                     optimized_haseq_soundness_for_data lid d
-                                       usubst bs in
-                                   FStar_Syntax_Util.mk_conj acc1 uu___6)
-                              FStar_Syntax_Util.t_true t_datas in
-                          let uu___6 = FStar_Syntax_Util.mk_conj guard' guard in
-                          let uu___7 = FStar_Syntax_Util.mk_conj cond' cond in
-                          ((FStar_Compiler_List.op_At l_axioms
-                              [(axiom_lid, fml)]), env2, uu___6, uu___7)))
-let (optimized_haseq_scheme :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.sigelt Prims.list ->
-        FStar_TypeChecker_Env.env_t -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun sig_bndle ->
-    fun tcs ->
-      fun datas ->
-        fun env0 ->
-          let uu___ =
-            let ty = FStar_Compiler_List.hd tcs in
-            match ty.FStar_Syntax_Syntax.sigel with
-            | FStar_Syntax_Syntax.Sig_inductive_typ
-                (uu___1, us, uu___2, uu___3, t, uu___4, uu___5) -> (us, t)
-            | uu___1 -> failwith "Impossible!" in
-          match uu___ with
-          | (us, t) ->
-              let uu___1 = FStar_Syntax_Subst.univ_var_opening us in
-              (match uu___1 with
-               | (usubst, us1) ->
-                   let env = FStar_TypeChecker_Env.push_sigelt env0 sig_bndle in
-                   ((env.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.push
-                      "haseq";
-                    (env.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.encode_sig
-                      env sig_bndle;
-                    (let env1 = FStar_TypeChecker_Env.push_univ_vars env us1 in
-                     let uu___4 =
-                       FStar_Compiler_List.fold_left
-                         (optimized_haseq_ty datas usubst us1)
-                         ([], env1, FStar_Syntax_Util.t_true,
-                           FStar_Syntax_Util.t_true) tcs in
-                     match uu___4 with
-                     | (axioms, env2, guard, cond) ->
-                         let phi =
-                           let uu___5 = FStar_Syntax_Util.arrow_formals t in
-                           match uu___5 with
-                           | (uu___6, t1) ->
-                               let uu___7 =
-                                 FStar_Syntax_Util.is_eqtype_no_unrefine t1 in
-                               if uu___7
-                               then cond
-                               else FStar_Syntax_Util.mk_imp guard cond in
-                         let uu___5 =
-                           FStar_TypeChecker_TcTerm.tc_trivial_guard env2 phi in
-                         (match uu___5 with
-                          | (phi1, uu___6) ->
-                              ((let uu___8 =
-                                  FStar_TypeChecker_Env.should_verify env2 in
-                                if uu___8
-                                then
-                                  let uu___9 =
-                                    FStar_TypeChecker_Env.guard_of_guard_formula
-                                      (FStar_TypeChecker_Common.NonTrivial
-                                         phi1) in
-                                  FStar_TypeChecker_Rel.force_trivial_guard
-                                    env2 uu___9
-                                else ());
-                               (let ses =
-                                  FStar_Compiler_List.fold_left
-                                    (fun l ->
-                                       fun uu___8 ->
-                                         match uu___8 with
-                                         | (lid, fml) ->
-                                             let fml1 =
-                                               FStar_Syntax_Subst.close_univ_vars
-                                                 us1 fml in
-                                             FStar_Compiler_List.op_At l
-                                               [{
-                                                  FStar_Syntax_Syntax.sigel =
-                                                    (FStar_Syntax_Syntax.Sig_assume
-                                                       (lid, us1, fml1));
-                                                  FStar_Syntax_Syntax.sigrng
-                                                    =
-                                                    FStar_Compiler_Range.dummyRange;
-                                                  FStar_Syntax_Syntax.sigquals
-                                                    =
-                                                    [FStar_Syntax_Syntax.InternalAssumption];
-                                                  FStar_Syntax_Syntax.sigmeta
-                                                    =
-                                                    FStar_Syntax_Syntax.default_sigmeta;
-                                                  FStar_Syntax_Syntax.sigattrs
-                                                    = [];
-                                                  FStar_Syntax_Syntax.sigopts
-                                                    =
-                                                    FStar_Pervasives_Native.None
-                                                }]) [] axioms in
-                                (env2.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.pop
-                                  "haseq";
-                                ses))))))
-let (unoptimized_haseq_data :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Ident.lident Prims.list ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Syntax_Syntax.sigelt ->
-              FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun usubst ->
-    fun bs ->
-      fun haseq_ind ->
-        fun mutuals ->
-          fun acc ->
-            fun data ->
-              let rec is_mutual t =
-                let uu___ =
-                  let uu___1 = FStar_Syntax_Subst.compress t in
-                  uu___1.FStar_Syntax_Syntax.n in
-                match uu___ with
-                | FStar_Syntax_Syntax.Tm_fvar fv ->
-                    FStar_Compiler_List.existsb
-                      (fun lid ->
-                         FStar_Ident.lid_equals lid
-                           (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v)
-                      mutuals
-                | FStar_Syntax_Syntax.Tm_uinst (t', uu___1) -> is_mutual t'
-                | FStar_Syntax_Syntax.Tm_refine (bv, t') ->
-                    is_mutual bv.FStar_Syntax_Syntax.sort
-                | FStar_Syntax_Syntax.Tm_app (t', args) ->
-                    let uu___1 = is_mutual t' in
-                    if uu___1
-                    then true
-                    else
-                      (let uu___3 =
-                         FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                           args in
-                       exists_mutual uu___3)
-                | FStar_Syntax_Syntax.Tm_meta (t', uu___1) -> is_mutual t'
-                | uu___1 -> false
-              and exists_mutual uu___ =
-                match uu___ with
-                | [] -> false
-                | hd::tl -> (is_mutual hd) || (exists_mutual tl) in
-              let dt = datacon_typ data in
-              let dt1 = FStar_Syntax_Subst.subst usubst dt in
-              let uu___ =
-                let uu___1 = FStar_Syntax_Subst.compress dt1 in
-                uu___1.FStar_Syntax_Syntax.n in
-              match uu___ with
-              | FStar_Syntax_Syntax.Tm_arrow (dbs, uu___1) ->
-                  let dbs1 =
-                    let uu___2 =
-                      FStar_Compiler_List.splitAt
-                        (FStar_Compiler_List.length bs) dbs in
-                    FStar_Pervasives_Native.snd uu___2 in
-                  let dbs2 =
-                    let uu___2 = FStar_Syntax_Subst.opening_of_binders bs in
-                    FStar_Syntax_Subst.subst_binders uu___2 dbs1 in
-                  let dbs3 = FStar_Syntax_Subst.open_binders dbs2 in
-                  let cond =
-                    FStar_Compiler_List.fold_left
-                      (fun t ->
-                         fun b ->
-                           let sort =
-                             (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                           let haseq_sort =
-                             let uu___2 =
-                               let uu___3 =
-                                 FStar_Syntax_Syntax.as_arg
-                                   (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                               [uu___3] in
-                             FStar_Syntax_Syntax.mk_Tm_app
-                               FStar_Syntax_Util.t_haseq uu___2
-                               FStar_Compiler_Range.dummyRange in
-                           let haseq_sort1 =
-                             let uu___2 = is_mutual sort in
-                             if uu___2
-                             then
-                               FStar_Syntax_Util.mk_imp haseq_ind haseq_sort
-                             else haseq_sort in
-                           FStar_Syntax_Util.mk_conj t haseq_sort1)
-                      FStar_Syntax_Util.t_true dbs3 in
-                  let cond1 =
-                    FStar_Compiler_List.fold_right
-                      (fun b ->
-                         fun t ->
-                           let uu___2 =
-                             let uu___3 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   let uu___6 =
-                                     FStar_Syntax_Syntax.mk_binder
-                                       b.FStar_Syntax_Syntax.binder_bv in
-                                   [uu___6] in
-                                 let uu___6 = FStar_Syntax_Subst.close [b] t in
-                                 FStar_Syntax_Util.abs uu___5 uu___6
-                                   FStar_Pervasives_Native.None in
-                               FStar_Syntax_Syntax.as_arg uu___4 in
-                             [uu___3] in
-                           FStar_Syntax_Syntax.mk_Tm_app
-                             FStar_Syntax_Util.tforall uu___2
-                             FStar_Compiler_Range.dummyRange) dbs3 cond in
-                  FStar_Syntax_Util.mk_conj acc cond1
-              | uu___1 -> acc
-let (unoptimized_haseq_ty :
-  FStar_Syntax_Syntax.sigelt Prims.list ->
-    FStar_Ident.lident Prims.list ->
-      FStar_Syntax_Syntax.subst_elt Prims.list ->
-        FStar_Syntax_Syntax.univ_name Prims.list ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Syntax_Syntax.sigelt ->
-              FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun all_datas_in_the_bundle ->
-    fun mutuals ->
-      fun usubst ->
-        fun us ->
-          fun acc ->
-            fun ty ->
-              let uu___ =
-                match ty.FStar_Syntax_Syntax.sigel with
-                | FStar_Syntax_Syntax.Sig_inductive_typ
-                    (lid, uu___1, bs, uu___2, t, uu___3, d_lids) ->
-                    (lid, bs, t, d_lids)
-                | uu___1 -> failwith "Impossible!" in
-              match uu___ with
-              | (lid, bs, t, d_lids) ->
-                  let bs1 = FStar_Syntax_Subst.subst_binders usubst bs in
-                  let t1 =
-                    let uu___1 =
-                      FStar_Syntax_Subst.shift_subst
-                        (FStar_Compiler_List.length bs1) usubst in
-                    FStar_Syntax_Subst.subst uu___1 t in
-                  let uu___1 = FStar_Syntax_Subst.open_term bs1 t1 in
-                  (match uu___1 with
-                   | (bs2, t2) ->
-                       let ibs =
-                         let uu___2 =
-                           let uu___3 = FStar_Syntax_Subst.compress t2 in
-                           uu___3.FStar_Syntax_Syntax.n in
-                         match uu___2 with
-                         | FStar_Syntax_Syntax.Tm_arrow (ibs1, uu___3) ->
-                             ibs1
-                         | uu___3 -> [] in
-                       let ibs1 = FStar_Syntax_Subst.open_binders ibs in
-                       let ind =
-                         let uu___2 =
-                           FStar_Syntax_Syntax.fvar lid
-                             FStar_Syntax_Syntax.delta_constant
-                             FStar_Pervasives_Native.None in
-                         let uu___3 =
-                           FStar_Compiler_List.map
-                             (fun u -> FStar_Syntax_Syntax.U_name u) us in
-                         FStar_Syntax_Syntax.mk_Tm_uinst uu___2 uu___3 in
-                       let ind1 =
-                         let uu___2 =
-                           FStar_Compiler_List.map
-                             FStar_Syntax_Util.arg_of_non_null_binder bs2 in
-                         FStar_Syntax_Syntax.mk_Tm_app ind uu___2
-                           FStar_Compiler_Range.dummyRange in
-                       let ind2 =
-                         let uu___2 =
-                           FStar_Compiler_List.map
-                             FStar_Syntax_Util.arg_of_non_null_binder ibs1 in
-                         FStar_Syntax_Syntax.mk_Tm_app ind1 uu___2
-                           FStar_Compiler_Range.dummyRange in
-                       let haseq_ind =
-                         let uu___2 =
-                           let uu___3 = FStar_Syntax_Syntax.as_arg ind2 in
-                           [uu___3] in
-                         FStar_Syntax_Syntax.mk_Tm_app
-                           FStar_Syntax_Util.t_haseq uu___2
-                           FStar_Compiler_Range.dummyRange in
-                       let t_datas =
-                         FStar_Compiler_List.filter
-                           (fun s ->
-                              match s.FStar_Syntax_Syntax.sigel with
-                              | FStar_Syntax_Syntax.Sig_datacon
-                                  (uu___2, uu___3, uu___4, t_lid, uu___5,
-                                   uu___6)
-                                  -> t_lid = lid
-                              | uu___2 -> failwith "Impossible")
-                           all_datas_in_the_bundle in
-                       let data_cond =
-                         FStar_Compiler_List.fold_left
-                           (unoptimized_haseq_data usubst bs2 haseq_ind
-                              mutuals) FStar_Syntax_Util.t_true t_datas in
-                       let fml = FStar_Syntax_Util.mk_imp data_cond haseq_ind in
-                       let fml1 =
-                         let uu___2 =
-                           let uu___3 =
-                             let uu___4 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Syntax_Syntax.binders_to_names ibs1 in
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 =
-                                       FStar_Syntax_Syntax.as_arg haseq_ind in
-                                     [uu___9] in
-                                   [uu___8] in
-                                 (uu___6, uu___7) in
-                               FStar_Syntax_Syntax.Meta_pattern uu___5 in
-                             (fml, uu___4) in
-                           FStar_Syntax_Syntax.Tm_meta uu___3 in
-                         {
-                           FStar_Syntax_Syntax.n = uu___2;
-                           FStar_Syntax_Syntax.pos =
-                             (fml.FStar_Syntax_Syntax.pos);
-                           FStar_Syntax_Syntax.vars =
-                             (fml.FStar_Syntax_Syntax.vars);
-                           FStar_Syntax_Syntax.hash_code =
-                             (fml.FStar_Syntax_Syntax.hash_code)
-                         } in
-                       let fml2 =
-                         FStar_Compiler_List.fold_right
-                           (fun b ->
-                              fun t3 ->
-                                let uu___2 =
-                                  let uu___3 =
-                                    let uu___4 =
-                                      let uu___5 =
-                                        let uu___6 =
-                                          FStar_Syntax_Syntax.mk_binder
-                                            b.FStar_Syntax_Syntax.binder_bv in
-                                        [uu___6] in
-                                      let uu___6 =
-                                        FStar_Syntax_Subst.close [b] t3 in
-                                      FStar_Syntax_Util.abs uu___5 uu___6
-                                        FStar_Pervasives_Native.None in
-                                    FStar_Syntax_Syntax.as_arg uu___4 in
-                                  [uu___3] in
-                                FStar_Syntax_Syntax.mk_Tm_app
-                                  FStar_Syntax_Util.tforall uu___2
-                                  FStar_Compiler_Range.dummyRange) ibs1 fml1 in
-                       let fml3 =
-                         FStar_Compiler_List.fold_right
-                           (fun b ->
-                              fun t3 ->
-                                let uu___2 =
-                                  let uu___3 =
-                                    let uu___4 =
-                                      let uu___5 =
-                                        let uu___6 =
-                                          FStar_Syntax_Syntax.mk_binder
-                                            b.FStar_Syntax_Syntax.binder_bv in
-                                        [uu___6] in
-                                      let uu___6 =
-                                        FStar_Syntax_Subst.close [b] t3 in
-                                      FStar_Syntax_Util.abs uu___5 uu___6
-                                        FStar_Pervasives_Native.None in
-                                    FStar_Syntax_Syntax.as_arg uu___4 in
-                                  [uu___3] in
-                                FStar_Syntax_Syntax.mk_Tm_app
-                                  FStar_Syntax_Util.tforall uu___2
-                                  FStar_Compiler_Range.dummyRange) bs2 fml2 in
-                       FStar_Syntax_Util.mk_conj acc fml3)
-let (unoptimized_haseq_scheme :
-  FStar_Syntax_Syntax.sigelt ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.sigelt Prims.list ->
-        FStar_TypeChecker_Env.env_t -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun sig_bndle ->
-    fun tcs ->
-      fun datas ->
-        fun env0 ->
-          let mutuals =
-            FStar_Compiler_List.map
-              (fun ty ->
-                 match ty.FStar_Syntax_Syntax.sigel with
-                 | FStar_Syntax_Syntax.Sig_inductive_typ
-                     (lid, uu___, uu___1, uu___2, uu___3, uu___4, uu___5) ->
-                     lid
-                 | uu___ -> failwith "Impossible!") tcs in
-          let uu___ =
-            let ty = FStar_Compiler_List.hd tcs in
-            match ty.FStar_Syntax_Syntax.sigel with
-            | FStar_Syntax_Syntax.Sig_inductive_typ
-                (lid, us, uu___1, uu___2, uu___3, uu___4, uu___5) ->
-                (lid, us)
-            | uu___1 -> failwith "Impossible!" in
-          match uu___ with
-          | (lid, us) ->
-              let uu___1 = FStar_Syntax_Subst.univ_var_opening us in
-              (match uu___1 with
-               | (usubst, us1) ->
-                   let fml =
-                     FStar_Compiler_List.fold_left
-                       (unoptimized_haseq_ty datas mutuals usubst us1)
-                       FStar_Syntax_Util.t_true tcs in
-                   let se =
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = get_haseq_axiom_lid lid in
-                         (uu___4, us1, fml) in
-                       FStar_Syntax_Syntax.Sig_assume uu___3 in
-                     {
-                       FStar_Syntax_Syntax.sigel = uu___2;
-                       FStar_Syntax_Syntax.sigrng =
-                         FStar_Compiler_Range.dummyRange;
-                       FStar_Syntax_Syntax.sigquals =
-                         [FStar_Syntax_Syntax.InternalAssumption];
-                       FStar_Syntax_Syntax.sigmeta =
-                         FStar_Syntax_Syntax.default_sigmeta;
-                       FStar_Syntax_Syntax.sigattrs = [];
-                       FStar_Syntax_Syntax.sigopts =
-                         FStar_Pervasives_Native.None
-                     } in
-                   [se])
-let (check_inductive_well_typedness :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Syntax_Syntax.sigelt Prims.list ->
-      FStar_Syntax_Syntax.qualifier Prims.list ->
-        FStar_Ident.lident Prims.list ->
-          (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.sigelt Prims.list
-            * FStar_Syntax_Syntax.sigelt Prims.list))
-  =
-  fun env ->
-    fun ses ->
-      fun quals ->
-        fun lids ->
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater ses
-              (FStar_Compiler_List.partition
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | {
-                        FStar_Syntax_Syntax.sigel =
-                          FStar_Syntax_Syntax.Sig_inductive_typ uu___2;
-                        FStar_Syntax_Syntax.sigrng = uu___3;
-                        FStar_Syntax_Syntax.sigquals = uu___4;
-                        FStar_Syntax_Syntax.sigmeta = uu___5;
-                        FStar_Syntax_Syntax.sigattrs = uu___6;
-                        FStar_Syntax_Syntax.sigopts = uu___7;_} -> true
-                    | uu___2 -> false)) in
-          match uu___ with
-          | (tys, datas) ->
-              ((let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater datas
-                    (FStar_Compiler_Util.for_some
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | {
-                              FStar_Syntax_Syntax.sigel =
-                                FStar_Syntax_Syntax.Sig_datacon uu___4;
-                              FStar_Syntax_Syntax.sigrng = uu___5;
-                              FStar_Syntax_Syntax.sigquals = uu___6;
-                              FStar_Syntax_Syntax.sigmeta = uu___7;
-                              FStar_Syntax_Syntax.sigattrs = uu___8;
-                              FStar_Syntax_Syntax.sigopts = uu___9;_} ->
-                              false
-                          | uu___4 -> true)) in
-                if uu___2
-                then
-                  let uu___3 = FStar_TypeChecker_Env.get_range env in
-                  FStar_Errors.raise_error
-                    (FStar_Errors.Fatal_NonInductiveInMutuallyDefinedType,
-                      "Mutually defined type contains a non-inductive element")
-                    uu___3
-                else ());
-               (let univs =
-                  if (FStar_Compiler_List.length tys) = Prims.int_zero
-                  then []
-                  else
-                    (let uu___3 =
-                       let uu___4 = FStar_Compiler_List.hd tys in
-                       uu___4.FStar_Syntax_Syntax.sigel in
-                     match uu___3 with
-                     | FStar_Syntax_Syntax.Sig_inductive_typ
-                         (uu___4, uvs, uu___5, uu___6, uu___7, uu___8,
-                          uu___9)
-                         -> uvs
-                     | uu___4 -> failwith "Impossible, can't happen!") in
-                let env0 = env in
-                let uu___2 =
-                  FStar_Compiler_List.fold_right
-                    (fun tc ->
-                       fun uu___3 ->
-                         match uu___3 with
-                         | (env1, all_tcs, g) ->
-                             let uu___4 = tc_tycon env1 tc in
-                             (match uu___4 with
-                              | (env2, tc1, tc_u, guard) ->
-                                  let g' =
-                                    FStar_TypeChecker_Rel.universe_inequality
-                                      FStar_Syntax_Syntax.U_zero tc_u in
-                                  ((let uu___6 =
-                                      FStar_TypeChecker_Env.debug env2
-                                        FStar_Options.Low in
-                                    if uu___6
-                                    then
-                                      let uu___7 =
-                                        FStar_Syntax_Print.sigelt_to_string
-                                          tc1 in
-                                      FStar_Compiler_Util.print1
-                                        "Checked inductive: %s\n" uu___7
-                                    else ());
-                                   (let uu___6 =
-                                      let uu___7 =
-                                        FStar_TypeChecker_Env.conj_guard
-                                          guard g' in
-                                      FStar_TypeChecker_Env.conj_guard g
-                                        uu___7 in
-                                    (env2, ((tc1, tc_u) :: all_tcs), uu___6)))))
-                    tys (env, [], FStar_TypeChecker_Env.trivial_guard) in
-                match uu___2 with
-                | (env1, tcs, g) ->
-                    let uu___3 =
-                      FStar_Compiler_List.fold_right
-                        (fun se ->
-                           fun uu___4 ->
-                             match uu___4 with
-                             | (datas1, g1) ->
-                                 let uu___5 =
-                                   let uu___6 = tc_data env1 tcs in uu___6 se in
-                                 (match uu___5 with
-                                  | (data, g') ->
-                                      let uu___6 =
-                                        FStar_TypeChecker_Env.conj_guard g1
-                                          g' in
-                                      ((data :: datas1), uu___6))) datas
-                        ([], g) in
-                    (match uu___3 with
-                     | (datas1, g1) ->
-                         let uu___4 =
-                           let tc_universe_vars =
-                             FStar_Compiler_List.map
-                               FStar_Pervasives_Native.snd tcs in
-                           let g2 =
-                             {
-                               FStar_TypeChecker_Common.guard_f =
-                                 (g1.FStar_TypeChecker_Common.guard_f);
-                               FStar_TypeChecker_Common.deferred_to_tac =
-                                 (g1.FStar_TypeChecker_Common.deferred_to_tac);
-                               FStar_TypeChecker_Common.deferred =
-                                 (g1.FStar_TypeChecker_Common.deferred);
-                               FStar_TypeChecker_Common.univ_ineqs =
-                                 (tc_universe_vars,
-                                   (FStar_Pervasives_Native.snd
-                                      g1.FStar_TypeChecker_Common.univ_ineqs));
-                               FStar_TypeChecker_Common.implicits =
-                                 (g1.FStar_TypeChecker_Common.implicits)
-                             } in
-                           (let uu___6 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug env0)
-                                (FStar_Options.Other "GenUniverses") in
-                            if uu___6
-                            then
-                              let uu___7 =
-                                FStar_TypeChecker_Rel.guard_to_string env1 g2 in
-                              FStar_Compiler_Util.print1
-                                "@@@@@@Guard before (possible) generalization: %s\n"
-                                uu___7
-                            else ());
-                           FStar_TypeChecker_Rel.force_trivial_guard env0 g2;
-                           if
-                             (FStar_Compiler_List.length univs) =
-                               Prims.int_zero
-                           then generalize_and_inst_within env0 tcs datas1
-                           else
-                             (let uu___8 =
-                                FStar_Compiler_List.map
-                                  FStar_Pervasives_Native.fst tcs in
-                              (uu___8, datas1)) in
-                         (match uu___4 with
-                          | (tcs1, datas2) ->
-                              let tcs2 =
-                                FStar_Compiler_Effect.op_Bar_Greater tcs1
-                                  (FStar_Compiler_List.map
-                                     (fun se ->
-                                        match se.FStar_Syntax_Syntax.sigel
-                                        with
-                                        | FStar_Syntax_Syntax.Sig_inductive_typ
-                                            (l, univs1, binders, num_uniform,
-                                             typ, ts, ds)
-                                            ->
-                                            let fail expected inferred =
-                                              let uu___5 =
-                                                let uu___6 =
-                                                  let uu___7 =
-                                                    FStar_Syntax_Print.tscheme_to_string
-                                                      expected in
-                                                  let uu___8 =
-                                                    FStar_Syntax_Print.tscheme_to_string
-                                                      inferred in
-                                                  FStar_Compiler_Util.format2
-                                                    "Expected an inductive with type %s; got %s"
-                                                    uu___7 uu___8 in
-                                                (FStar_Errors.Fatal_UnexpectedInductivetype,
-                                                  uu___6) in
-                                              FStar_Errors.raise_error uu___5
-                                                se.FStar_Syntax_Syntax.sigrng in
-                                            let copy_binder_attrs_from_val
-                                              binders1 expected =
-                                              let expected_attrs =
-                                                let uu___5 =
-                                                  let uu___6 =
-                                                    FStar_TypeChecker_Normalize.get_n_binders
-                                                      env1
-                                                      (FStar_Compiler_List.length
-                                                         binders1) expected in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___6
-                                                    FStar_Pervasives_Native.fst in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___5
-                                                  (FStar_Compiler_List.map
-                                                     (fun uu___6 ->
-                                                        match uu___6 with
-                                                        | {
-                                                            FStar_Syntax_Syntax.binder_bv
-                                                              = uu___7;
-                                                            FStar_Syntax_Syntax.binder_qual
-                                                              = uu___8;
-                                                            FStar_Syntax_Syntax.binder_attrs
-                                                              = attrs;_}
-                                                            -> attrs)) in
-                                              if
-                                                (FStar_Compiler_List.length
-                                                   expected_attrs)
-                                                  <>
-                                                  (FStar_Compiler_List.length
-                                                     binders1)
-                                              then
-                                                let uu___5 =
-                                                  let uu___6 =
-                                                    let uu___7 =
-                                                      let uu___8 =
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          binders1
-                                                          FStar_Compiler_List.length in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___8
-                                                        FStar_Compiler_Util.string_of_int in
-                                                    let uu___8 =
-                                                      FStar_Syntax_Print.term_to_string
-                                                        expected in
-                                                    FStar_Compiler_Util.format2
-                                                      "Could not get %s type parameters from val type %s"
-                                                      uu___7 uu___8 in
-                                                  (FStar_Errors.Fatal_UnexpectedInductivetype,
-                                                    uu___6) in
-                                                FStar_Errors.raise_error
-                                                  uu___5
-                                                  se.FStar_Syntax_Syntax.sigrng
-                                              else
-                                                FStar_Compiler_List.map2
-                                                  (fun ex_attrs ->
-                                                     fun b ->
-                                                       {
-                                                         FStar_Syntax_Syntax.binder_bv
-                                                           =
-                                                           (b.FStar_Syntax_Syntax.binder_bv);
-                                                         FStar_Syntax_Syntax.binder_qual
-                                                           =
-                                                           (b.FStar_Syntax_Syntax.binder_qual);
-                                                         FStar_Syntax_Syntax.binder_attrs
-                                                           =
-                                                           (FStar_Compiler_List.op_At
-                                                              b.FStar_Syntax_Syntax.binder_attrs
-                                                              ex_attrs)
-                                                       }) expected_attrs
-                                                  binders1 in
-                                            let uu___5 =
-                                              FStar_TypeChecker_Env.try_lookup_val_decl
-                                                env0 l in
-                                            (match uu___5 with
-                                             | FStar_Pervasives_Native.None
-                                                 -> se
-                                             | FStar_Pervasives_Native.Some
-                                                 (expected_typ, uu___6) ->
-                                                 let inferred_typ =
-                                                   let body =
-                                                     match binders with
-                                                     | [] -> typ
-                                                     | uu___7 ->
-                                                         let uu___8 =
-                                                           let uu___9 =
-                                                             let uu___10 =
-                                                               FStar_Syntax_Syntax.mk_Total
-                                                                 typ in
-                                                             (binders,
-                                                               uu___10) in
-                                                           FStar_Syntax_Syntax.Tm_arrow
-                                                             uu___9 in
-                                                         FStar_Syntax_Syntax.mk
-                                                           uu___8
-                                                           se.FStar_Syntax_Syntax.sigrng in
-                                                   (univs1, body) in
-                                                 if
-                                                   (FStar_Compiler_List.length
-                                                      univs1)
-                                                     =
-                                                     (FStar_Compiler_List.length
-                                                        (FStar_Pervasives_Native.fst
-                                                           expected_typ))
-                                                 then
-                                                   let uu___7 =
-                                                     FStar_Syntax_Subst.open_univ_vars
-                                                       univs1
-                                                       (FStar_Pervasives_Native.snd
-                                                          inferred_typ) in
-                                                   (match uu___7 with
-                                                    | (uu___8, inferred) ->
-                                                        let uu___9 =
-                                                          FStar_Syntax_Subst.open_univ_vars
-                                                            univs1
-                                                            (FStar_Pervasives_Native.snd
-                                                               expected_typ) in
-                                                        (match uu___9 with
-                                                         | (uu___10,
-                                                            expected) ->
-                                                             let uu___11 =
-                                                               FStar_TypeChecker_Rel.teq_nosmt_force
-                                                                 env0
-                                                                 inferred
-                                                                 expected in
-                                                             if uu___11
-                                                             then
-                                                               let binders1 =
-                                                                 copy_binder_attrs_from_val
-                                                                   binders
-                                                                   expected in
-                                                               {
-                                                                 FStar_Syntax_Syntax.sigel
-                                                                   =
-                                                                   (FStar_Syntax_Syntax.Sig_inductive_typ
-                                                                    (l,
-                                                                    univs1,
-                                                                    binders1,
-                                                                    num_uniform,
-                                                                    typ, ts,
-                                                                    ds));
-                                                                 FStar_Syntax_Syntax.sigrng
-                                                                   =
-                                                                   (se.FStar_Syntax_Syntax.sigrng);
-                                                                 FStar_Syntax_Syntax.sigquals
-                                                                   =
-                                                                   (se.FStar_Syntax_Syntax.sigquals);
-                                                                 FStar_Syntax_Syntax.sigmeta
-                                                                   =
-                                                                   (se.FStar_Syntax_Syntax.sigmeta);
-                                                                 FStar_Syntax_Syntax.sigattrs
-                                                                   =
-                                                                   (se.FStar_Syntax_Syntax.sigattrs);
-                                                                 FStar_Syntax_Syntax.sigopts
-                                                                   =
-                                                                   (se.FStar_Syntax_Syntax.sigopts)
-                                                               }
-                                                             else
-                                                               fail
-                                                                 expected_typ
-                                                                 inferred_typ))
-                                                 else
-                                                   fail expected_typ
-                                                     inferred_typ)
-                                        | uu___5 -> se)) in
-                              let sig_bndle =
-                                let uu___5 =
-                                  FStar_TypeChecker_Env.get_range env0 in
-                                let uu___6 =
-                                  FStar_Compiler_List.collect
-                                    (fun s -> s.FStar_Syntax_Syntax.sigattrs)
-                                    ses in
-                                {
-                                  FStar_Syntax_Syntax.sigel =
-                                    (FStar_Syntax_Syntax.Sig_bundle
-                                       ((FStar_Compiler_List.op_At tcs2
-                                           datas2), lids));
-                                  FStar_Syntax_Syntax.sigrng = uu___5;
-                                  FStar_Syntax_Syntax.sigquals = quals;
-                                  FStar_Syntax_Syntax.sigmeta =
-                                    FStar_Syntax_Syntax.default_sigmeta;
-                                  FStar_Syntax_Syntax.sigattrs = uu___6;
-                                  FStar_Syntax_Syntax.sigopts =
-                                    FStar_Pervasives_Native.None
-                                } in
-                              (sig_bndle, tcs2, datas2)))))
-let (early_prims_inductives : Prims.string Prims.list) =
-  ["empty"; "trivial"; "equals"; "pair"; "sum"]
-let (mk_discriminator_and_indexed_projectors :
-  FStar_Syntax_Syntax.qualifier Prims.list ->
-    FStar_Syntax_Syntax.attribute Prims.list ->
-      FStar_Syntax_Syntax.fv_qual ->
-        Prims.bool ->
-          FStar_TypeChecker_Env.env ->
-            FStar_Ident.lident ->
-              FStar_Ident.lident ->
-                FStar_Syntax_Syntax.univ_names ->
-                  FStar_Syntax_Syntax.binders ->
-                    FStar_Syntax_Syntax.binders ->
-                      FStar_Syntax_Syntax.binders ->
-                        Prims.bool -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun iquals ->
-    fun attrs ->
-      fun fvq ->
-        fun refine_domain ->
-          fun env ->
-            fun tc ->
-              fun lid ->
-                fun uvs ->
-                  fun inductive_tps ->
-                    fun indices ->
-                      fun fields ->
-                        fun erasable ->
-                          let p = FStar_Ident.range_of_lid lid in
-                          let pos q = FStar_Syntax_Syntax.withinfo q p in
-                          let projectee ptyp =
-                            FStar_Syntax_Syntax.gen_bv "projectee"
-                              (FStar_Pervasives_Native.Some p) ptyp in
-                          let inst_univs =
-                            FStar_Compiler_List.map
-                              (fun u -> FStar_Syntax_Syntax.U_name u) uvs in
-                          let tps = inductive_tps in
-                          let arg_typ =
-                            let inst_tc =
-                              let uu___ =
-                                let uu___1 =
-                                  let uu___2 =
-                                    let uu___3 =
-                                      FStar_Syntax_Syntax.lid_as_fv tc
-                                        FStar_Syntax_Syntax.delta_constant
-                                        FStar_Pervasives_Native.None in
-                                    FStar_Syntax_Syntax.fv_to_tm uu___3 in
-                                  (uu___2, inst_univs) in
-                                FStar_Syntax_Syntax.Tm_uinst uu___1 in
-                              FStar_Syntax_Syntax.mk uu___ p in
-                            let args =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                (FStar_Compiler_List.op_At tps indices)
-                                (FStar_Compiler_List.map
-                                   FStar_Syntax_Util.arg_of_non_null_binder) in
-                            FStar_Syntax_Syntax.mk_Tm_app inst_tc args p in
-                          let unrefined_arg_binder =
-                            let uu___ = projectee arg_typ in
-                            FStar_Syntax_Syntax.mk_binder uu___ in
-                          let arg_binder =
-                            if Prims.op_Negation refine_domain
-                            then unrefined_arg_binder
-                            else
-                              (let disc_name =
-                                 FStar_Syntax_Util.mk_discriminator lid in
-                               let x =
-                                 FStar_Syntax_Syntax.new_bv
-                                   (FStar_Pervasives_Native.Some p) arg_typ in
-                               let sort =
-                                 let disc_fvar =
-                                   let uu___1 =
-                                     FStar_Ident.set_lid_range disc_name p in
-                                   FStar_Syntax_Syntax.fvar uu___1
-                                     (FStar_Syntax_Syntax.Delta_equational_at_level
-                                        Prims.int_one)
-                                     FStar_Pervasives_Native.None in
-                                 let uu___1 =
-                                   let uu___2 =
-                                     let uu___3 =
-                                       FStar_Syntax_Syntax.mk_Tm_uinst
-                                         disc_fvar inst_univs in
-                                     let uu___4 =
-                                       let uu___5 =
-                                         let uu___6 =
-                                           FStar_Syntax_Syntax.bv_to_name x in
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           FStar_Syntax_Syntax.as_arg uu___6 in
-                                       [uu___5] in
-                                     FStar_Syntax_Syntax.mk_Tm_app uu___3
-                                       uu___4 p in
-                                   FStar_Syntax_Util.b2t uu___2 in
-                                 FStar_Syntax_Util.refine x uu___1 in
-                               let uu___1 =
-                                 let uu___2 = projectee arg_typ in
-                                 {
-                                   FStar_Syntax_Syntax.ppname =
-                                     (uu___2.FStar_Syntax_Syntax.ppname);
-                                   FStar_Syntax_Syntax.index =
-                                     (uu___2.FStar_Syntax_Syntax.index);
-                                   FStar_Syntax_Syntax.sort = sort
-                                 } in
-                               FStar_Syntax_Syntax.mk_binder uu___1) in
-                          let ntps = FStar_Compiler_List.length tps in
-                          let all_params =
-                            let uu___ =
-                              FStar_Compiler_List.map
-                                (fun b ->
-                                   {
-                                     FStar_Syntax_Syntax.binder_bv =
-                                       (b.FStar_Syntax_Syntax.binder_bv);
-                                     FStar_Syntax_Syntax.binder_qual =
-                                       (FStar_Pervasives_Native.Some
-                                          FStar_Syntax_Syntax.imp_tag);
-                                     FStar_Syntax_Syntax.binder_attrs =
-                                       (b.FStar_Syntax_Syntax.binder_attrs)
-                                   }) tps in
-                            FStar_Compiler_List.op_At uu___ fields in
-                          let imp_binders =
-                            FStar_Compiler_Effect.op_Bar_Greater
-                              (FStar_Compiler_List.op_At tps indices)
-                              (FStar_Compiler_List.map
-                                 (fun b ->
-                                    {
-                                      FStar_Syntax_Syntax.binder_bv =
-                                        (b.FStar_Syntax_Syntax.binder_bv);
-                                      FStar_Syntax_Syntax.binder_qual =
-                                        (FStar_Pervasives_Native.Some
-                                           FStar_Syntax_Syntax.imp_tag);
-                                      FStar_Syntax_Syntax.binder_attrs =
-                                        (b.FStar_Syntax_Syntax.binder_attrs)
-                                    })) in
-                          let early_prims_inductive =
-                            (let uu___ =
-                               FStar_TypeChecker_Env.current_module env in
-                             FStar_Ident.lid_equals
-                               FStar_Parser_Const.prims_lid uu___)
-                              &&
-                              (FStar_Compiler_List.existsb
-                                 (fun s ->
-                                    let uu___ =
-                                      let uu___1 =
-                                        FStar_Ident.ident_of_lid tc in
-                                      FStar_Ident.string_of_id uu___1 in
-                                    s = uu___) early_prims_inductives) in
-                          let discriminator_ses =
-                            if fvq <> FStar_Syntax_Syntax.Data_ctor
-                            then []
-                            else
-                              (let discriminator_name =
-                                 FStar_Syntax_Util.mk_discriminator lid in
-                               let no_decl = false in
-                               let only_decl =
-                                 early_prims_inductive ||
-                                   (FStar_Syntax_Util.has_attribute attrs
-                                      FStar_Parser_Const.no_auto_projectors_attr) in
-                               let quals =
-                                 let uu___1 =
-                                   FStar_Compiler_List.filter
-                                     (fun uu___2 ->
-                                        match uu___2 with
-                                        | FStar_Syntax_Syntax.Inline_for_extraction
-                                            -> true
-                                        | FStar_Syntax_Syntax.NoExtract ->
-                                            true
-                                        | FStar_Syntax_Syntax.Private -> true
-                                        | uu___3 -> false) iquals in
-                                 FStar_Compiler_List.op_At
-                                   ((FStar_Syntax_Syntax.Discriminator lid)
-                                   ::
-                                   (if only_decl
-                                    then
-                                      [FStar_Syntax_Syntax.Logic;
-                                      FStar_Syntax_Syntax.Assumption]
-                                    else [])) uu___1 in
-                               let binders =
-                                 FStar_Compiler_List.op_At imp_binders
-                                   [unrefined_arg_binder] in
-                               let t =
-                                 let bool_typ =
-                                   if erasable
-                                   then
-                                     FStar_Syntax_Syntax.mk_GTotal
-                                       FStar_Syntax_Util.t_bool
-                                   else
-                                     FStar_Syntax_Syntax.mk_Total
-                                       FStar_Syntax_Util.t_bool in
-                                 let uu___1 =
-                                   FStar_Syntax_Util.arrow binders bool_typ in
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (FStar_Syntax_Subst.close_univ_vars uvs)
-                                   uu___1 in
-                               let decl =
-                                 let uu___1 =
-                                   FStar_Ident.range_of_lid
-                                     discriminator_name in
-                                 {
-                                   FStar_Syntax_Syntax.sigel =
-                                     (FStar_Syntax_Syntax.Sig_declare_typ
-                                        (discriminator_name, uvs, t));
-                                   FStar_Syntax_Syntax.sigrng = uu___1;
-                                   FStar_Syntax_Syntax.sigquals = quals;
-                                   FStar_Syntax_Syntax.sigmeta =
-                                     FStar_Syntax_Syntax.default_sigmeta;
-                                   FStar_Syntax_Syntax.sigattrs = attrs;
-                                   FStar_Syntax_Syntax.sigopts =
-                                     FStar_Pervasives_Native.None
-                                 } in
-                               (let uu___2 =
-                                  FStar_TypeChecker_Env.debug env
-                                    (FStar_Options.Other "LogTypes") in
-                                if uu___2
-                                then
-                                  let uu___3 =
-                                    FStar_Syntax_Print.sigelt_to_string decl in
-                                  FStar_Compiler_Util.print1
-                                    "Declaration of a discriminator %s\n"
-                                    uu___3
-                                else ());
-                               if only_decl
-                               then [decl]
-                               else
-                                 (let body =
-                                    if Prims.op_Negation refine_domain
-                                    then FStar_Syntax_Util.exp_true_bool
-                                    else
-                                      (let arg_pats =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           all_params
-                                           (FStar_Compiler_List.mapi
-                                              (fun j ->
-                                                 fun uu___4 ->
-                                                   match uu___4 with
-                                                   | {
-                                                       FStar_Syntax_Syntax.binder_bv
-                                                         = x;
-                                                       FStar_Syntax_Syntax.binder_qual
-                                                         = imp;
-                                                       FStar_Syntax_Syntax.binder_attrs
-                                                         = uu___5;_}
-                                                       ->
-                                                       let b =
-                                                         FStar_Syntax_Syntax.is_bqual_implicit
-                                                           imp in
-                                                       if b && (j < ntps)
-                                                       then
-                                                         let uu___6 =
-                                                           pos
-                                                             (FStar_Syntax_Syntax.Pat_dot_term
-                                                                FStar_Pervasives_Native.None) in
-                                                         (uu___6, b)
-                                                       else
-                                                         (let uu___7 =
-                                                            let uu___8 =
-                                                              let uu___9 =
-                                                                let uu___10 =
-                                                                  FStar_Ident.string_of_id
-                                                                    x.FStar_Syntax_Syntax.ppname in
-                                                                FStar_Syntax_Syntax.gen_bv
-                                                                  uu___10
-                                                                  FStar_Pervasives_Native.None
-                                                                  FStar_Syntax_Syntax.tun in
-                                                              FStar_Syntax_Syntax.Pat_wild
-                                                                uu___9 in
-                                                            pos uu___8 in
-                                                          (uu___7, b)))) in
-                                       let pat_true =
-                                         let uu___4 =
-                                           let uu___5 =
-                                             let uu___6 =
-                                               let uu___7 =
-                                                 FStar_Syntax_Syntax.lid_as_fv
-                                                   lid
-                                                   FStar_Syntax_Syntax.delta_constant
-                                                   (FStar_Pervasives_Native.Some
-                                                      fvq) in
-                                               (uu___7,
-                                                 FStar_Pervasives_Native.None,
-                                                 arg_pats) in
-                                             FStar_Syntax_Syntax.Pat_cons
-                                               uu___6 in
-                                           pos uu___5 in
-                                         (uu___4,
-                                           FStar_Pervasives_Native.None,
-                                           FStar_Syntax_Util.exp_true_bool) in
-                                       let pat_false =
-                                         let uu___4 =
-                                           let uu___5 =
-                                             let uu___6 =
-                                               FStar_Syntax_Syntax.new_bv
-                                                 FStar_Pervasives_Native.None
-                                                 FStar_Syntax_Syntax.tun in
-                                             FStar_Syntax_Syntax.Pat_wild
-                                               uu___6 in
-                                           pos uu___5 in
-                                         (uu___4,
-                                           FStar_Pervasives_Native.None,
-                                           FStar_Syntax_Util.exp_false_bool) in
-                                       let arg_exp =
-                                         FStar_Syntax_Syntax.bv_to_name
-                                           unrefined_arg_binder.FStar_Syntax_Syntax.binder_bv in
-                                       let uu___4 =
-                                         let uu___5 =
-                                           let uu___6 =
-                                             let uu___7 =
-                                               FStar_Syntax_Util.branch
-                                                 pat_true in
-                                             let uu___8 =
-                                               let uu___9 =
-                                                 FStar_Syntax_Util.branch
-                                                   pat_false in
-                                               [uu___9] in
-                                             uu___7 :: uu___8 in
-                                           (arg_exp,
-                                             FStar_Pervasives_Native.None,
-                                             uu___6,
-                                             FStar_Pervasives_Native.None) in
-                                         FStar_Syntax_Syntax.Tm_match uu___5 in
-                                       FStar_Syntax_Syntax.mk uu___4 p) in
-                                  let dd =
-                                    FStar_Syntax_Syntax.Delta_equational_at_level
-                                      Prims.int_one in
-                                  let imp =
-                                    FStar_Syntax_Util.abs binders body
-                                      FStar_Pervasives_Native.None in
-                                  let lbtyp =
-                                    if no_decl
-                                    then t
-                                    else FStar_Syntax_Syntax.tun in
-                                  let lb =
-                                    let uu___3 =
-                                      let uu___4 =
-                                        FStar_Syntax_Syntax.lid_as_fv
-                                          discriminator_name dd
-                                          FStar_Pervasives_Native.None in
-                                      FStar_Pervasives.Inr uu___4 in
-                                    let uu___4 =
-                                      FStar_Syntax_Subst.close_univ_vars uvs
-                                        imp in
-                                    FStar_Syntax_Util.mk_letbinding uu___3
-                                      uvs lbtyp
-                                      FStar_Parser_Const.effect_Tot_lid
-                                      uu___4 []
-                                      FStar_Compiler_Range.dummyRange in
-                                  let impl =
-                                    let uu___3 =
-                                      let uu___4 =
-                                        let uu___5 =
-                                          let uu___6 =
-                                            let uu___7 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                lb.FStar_Syntax_Syntax.lbname
-                                                FStar_Compiler_Util.right in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___7
-                                              (fun fv ->
-                                                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v) in
-                                          [uu___6] in
-                                        ((false, [lb]), uu___5) in
-                                      FStar_Syntax_Syntax.Sig_let uu___4 in
-                                    {
-                                      FStar_Syntax_Syntax.sigel = uu___3;
-                                      FStar_Syntax_Syntax.sigrng = p;
-                                      FStar_Syntax_Syntax.sigquals = quals;
-                                      FStar_Syntax_Syntax.sigmeta =
-                                        FStar_Syntax_Syntax.default_sigmeta;
-                                      FStar_Syntax_Syntax.sigattrs = attrs;
-                                      FStar_Syntax_Syntax.sigopts =
-                                        FStar_Pervasives_Native.None
-                                    } in
-                                  (let uu___4 =
-                                     FStar_TypeChecker_Env.debug env
-                                       (FStar_Options.Other "LogTypes") in
-                                   if uu___4
-                                   then
-                                     let uu___5 =
-                                       FStar_Syntax_Print.sigelt_to_string
-                                         impl in
-                                     FStar_Compiler_Util.print1
-                                       "Implementation of a discriminator %s\n"
-                                       uu___5
-                                   else ());
-                                  [decl; impl])) in
-                          let arg_exp =
-                            FStar_Syntax_Syntax.bv_to_name
-                              arg_binder.FStar_Syntax_Syntax.binder_bv in
-                          let binders =
-                            FStar_Compiler_List.op_At imp_binders
-                              [arg_binder] in
-                          let arg =
-                            FStar_Syntax_Util.arg_of_non_null_binder
-                              arg_binder in
-                          let subst =
-                            FStar_Compiler_Effect.op_Bar_Greater fields
-                              (FStar_Compiler_List.mapi
-                                 (fun i ->
-                                    fun uu___ ->
-                                      match uu___ with
-                                      | { FStar_Syntax_Syntax.binder_bv = a;
-                                          FStar_Syntax_Syntax.binder_qual =
-                                            uu___1;
-                                          FStar_Syntax_Syntax.binder_attrs =
-                                            uu___2;_}
-                                          ->
-                                          let field_name =
-                                            FStar_Syntax_Util.mk_field_projector_name
-                                              lid a i in
-                                          let field_proj_tm =
-                                            let uu___3 =
-                                              let uu___4 =
-                                                FStar_Syntax_Syntax.lid_as_fv
-                                                  field_name
-                                                  (FStar_Syntax_Syntax.Delta_equational_at_level
-                                                     Prims.int_one)
-                                                  FStar_Pervasives_Native.None in
-                                              FStar_Syntax_Syntax.fv_to_tm
-                                                uu___4 in
-                                            FStar_Syntax_Syntax.mk_Tm_uinst
-                                              uu___3 inst_univs in
-                                          let proj =
-                                            FStar_Syntax_Syntax.mk_Tm_app
-                                              field_proj_tm [arg] p in
-                                          FStar_Syntax_Syntax.NT (a, proj))) in
-                          let projectors_ses =
-                            let uu___ =
-                              FStar_Compiler_Effect.op_Bar_Greater fields
-                                (FStar_Compiler_List.mapi
-                                   (fun i ->
-                                      fun uu___1 ->
-                                        match uu___1 with
-                                        | {
-                                            FStar_Syntax_Syntax.binder_bv = x;
-                                            FStar_Syntax_Syntax.binder_qual =
-                                              uu___2;
-                                            FStar_Syntax_Syntax.binder_attrs
-                                              = uu___3;_}
-                                            ->
-                                            let p1 =
-                                              FStar_Syntax_Syntax.range_of_bv
-                                                x in
-                                            let field_name =
-                                              FStar_Syntax_Util.mk_field_projector_name
-                                                lid x i in
-                                            let result_comp =
-                                              let t =
-                                                FStar_Syntax_Subst.subst
-                                                  subst
-                                                  x.FStar_Syntax_Syntax.sort in
-                                              if erasable
-                                              then
-                                                FStar_Syntax_Syntax.mk_GTotal
-                                                  t
-                                              else
-                                                FStar_Syntax_Syntax.mk_Total
-                                                  t in
-                                            let t =
-                                              let uu___4 =
-                                                FStar_Syntax_Util.arrow
-                                                  binders result_comp in
-                                              FStar_Compiler_Effect.op_Less_Bar
-                                                (FStar_Syntax_Subst.close_univ_vars
-                                                   uvs) uu___4 in
-                                            let only_decl =
-                                              early_prims_inductive ||
-                                                (FStar_Syntax_Util.has_attribute
-                                                   attrs
-                                                   FStar_Parser_Const.no_auto_projectors_attr) in
-                                            let no_decl = false in
-                                            let quals q =
-                                              if only_decl
-                                              then
-                                                FStar_Syntax_Syntax.Assumption
-                                                :: q
-                                              else q in
-                                            let quals1 =
-                                              let iquals1 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  iquals
-                                                  (FStar_Compiler_List.filter
-                                                     (fun uu___4 ->
-                                                        match uu___4 with
-                                                        | FStar_Syntax_Syntax.Inline_for_extraction
-                                                            -> true
-                                                        | FStar_Syntax_Syntax.NoExtract
-                                                            -> true
-                                                        | FStar_Syntax_Syntax.Private
-                                                            -> true
-                                                        | uu___5 -> false)) in
-                                              quals
-                                                ((FStar_Syntax_Syntax.Projector
-                                                    (lid,
-                                                      (x.FStar_Syntax_Syntax.ppname)))
-                                                :: iquals1) in
-                                            let attrs1 =
-                                              FStar_Compiler_List.op_At
-                                                (if only_decl
-                                                 then []
-                                                 else
-                                                   [FStar_Syntax_Util.attr_substitute])
-                                                attrs in
-                                            let decl =
-                                              let uu___4 =
-                                                FStar_Ident.range_of_lid
-                                                  field_name in
-                                              {
-                                                FStar_Syntax_Syntax.sigel =
-                                                  (FStar_Syntax_Syntax.Sig_declare_typ
-                                                     (field_name, uvs, t));
-                                                FStar_Syntax_Syntax.sigrng =
-                                                  uu___4;
-                                                FStar_Syntax_Syntax.sigquals
-                                                  = quals1;
-                                                FStar_Syntax_Syntax.sigmeta =
-                                                  FStar_Syntax_Syntax.default_sigmeta;
-                                                FStar_Syntax_Syntax.sigattrs
-                                                  = attrs1;
-                                                FStar_Syntax_Syntax.sigopts =
-                                                  FStar_Pervasives_Native.None
-                                              } in
-                                            ((let uu___5 =
-                                                FStar_TypeChecker_Env.debug
-                                                  env
-                                                  (FStar_Options.Other
-                                                     "LogTypes") in
-                                              if uu___5
-                                              then
-                                                let uu___6 =
-                                                  FStar_Syntax_Print.sigelt_to_string
-                                                    decl in
-                                                FStar_Compiler_Util.print1
-                                                  "Declaration of a projector %s\n"
-                                                  uu___6
-                                              else ());
-                                             if only_decl
-                                             then [decl]
-                                             else
-                                               (let projection =
-                                                  let uu___6 =
-                                                    FStar_Ident.string_of_id
-                                                      x.FStar_Syntax_Syntax.ppname in
-                                                  FStar_Syntax_Syntax.gen_bv
-                                                    uu___6
-                                                    FStar_Pervasives_Native.None
-                                                    FStar_Syntax_Syntax.tun in
-                                                let arg_pats =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    all_params
-                                                    (FStar_Compiler_List.mapi
-                                                       (fun j ->
-                                                          fun uu___6 ->
-                                                            match uu___6 with
-                                                            | {
-                                                                FStar_Syntax_Syntax.binder_bv
-                                                                  = x1;
-                                                                FStar_Syntax_Syntax.binder_qual
-                                                                  = imp;
-                                                                FStar_Syntax_Syntax.binder_attrs
-                                                                  = uu___7;_}
-                                                                ->
-                                                                let b =
-                                                                  FStar_Syntax_Syntax.is_bqual_implicit
-                                                                    imp in
-                                                                if
-                                                                  (i + ntps)
-                                                                    = j
-                                                                then
-                                                                  let uu___8
-                                                                    =
-                                                                    pos
-                                                                    (FStar_Syntax_Syntax.Pat_var
-                                                                    projection) in
-                                                                  (uu___8, b)
-                                                                else
-                                                                  if
-                                                                    b &&
-                                                                    (j < ntps)
-                                                                  then
-                                                                    (
-                                                                    let uu___9
-                                                                    =
-                                                                    pos
-                                                                    (FStar_Syntax_Syntax.Pat_dot_term
-                                                                    FStar_Pervasives_Native.None) in
-                                                                    (uu___9,
-                                                                    b))
-                                                                  else
-                                                                    (
-                                                                    let uu___10
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Ident.string_of_id
-                                                                    x1.FStar_Syntax_Syntax.ppname in
-                                                                    FStar_Syntax_Syntax.gen_bv
-                                                                    uu___13
-                                                                    FStar_Pervasives_Native.None
-                                                                    FStar_Syntax_Syntax.tun in
-                                                                    FStar_Syntax_Syntax.Pat_wild
-                                                                    uu___12 in
-                                                                    pos
-                                                                    uu___11 in
-                                                                    (uu___10,
-                                                                    b)))) in
-                                                let pat =
-                                                  let uu___6 =
-                                                    let uu___7 =
-                                                      let uu___8 =
-                                                        let uu___9 =
-                                                          FStar_Syntax_Syntax.lid_as_fv
-                                                            lid
-                                                            FStar_Syntax_Syntax.delta_constant
-                                                            (FStar_Pervasives_Native.Some
-                                                               fvq) in
-                                                        (uu___9,
-                                                          FStar_Pervasives_Native.None,
-                                                          arg_pats) in
-                                                      FStar_Syntax_Syntax.Pat_cons
-                                                        uu___8 in
-                                                    pos uu___7 in
-                                                  let uu___7 =
-                                                    FStar_Syntax_Syntax.bv_to_name
-                                                      projection in
-                                                  (uu___6,
-                                                    FStar_Pervasives_Native.None,
-                                                    uu___7) in
-                                                let body =
-                                                  let return_bv =
-                                                    FStar_Syntax_Syntax.gen_bv
-                                                      "proj_ret"
-                                                      (FStar_Pervasives_Native.Some
-                                                         p1)
-                                                      FStar_Syntax_Syntax.tun in
-                                                  let result_typ =
-                                                    let uu___6 =
-                                                      let uu___7 =
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          result_comp
-                                                          FStar_Syntax_Util.comp_result in
-                                                      let uu___8 =
-                                                        let uu___9 =
-                                                          let uu___10 =
-                                                            let uu___11 =
-                                                              let uu___12 =
-                                                                FStar_Syntax_Syntax.bv_to_name
-                                                                  return_bv in
-                                                              ((arg_binder.FStar_Syntax_Syntax.binder_bv),
-                                                                uu___12) in
-                                                            FStar_Syntax_Syntax.NT
-                                                              uu___11 in
-                                                          [uu___10] in
-                                                        FStar_Syntax_Subst.subst
-                                                          uu___9 in
-                                                      FStar_Compiler_Effect.op_Bar_Greater
-                                                        uu___7 uu___8 in
-                                                    let uu___7 =
-                                                      let uu___8 =
-                                                        let uu___9 =
-                                                          FStar_Syntax_Syntax.mk_binder
-                                                            return_bv in
-                                                        [uu___9] in
-                                                      FStar_Syntax_Subst.close
-                                                        uu___8 in
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      uu___6 uu___7 in
-                                                  let return_binder =
-                                                    let uu___6 =
-                                                      let uu___7 =
-                                                        let uu___8 =
-                                                          FStar_Syntax_Syntax.mk_binder
-                                                            return_bv in
-                                                        [uu___8] in
-                                                      FStar_Syntax_Subst.close_binders
-                                                        uu___7 in
-                                                    FStar_Compiler_List.hd
-                                                      uu___6 in
-                                                  let returns_annotation =
-                                                    let use_eq = true in
-                                                    FStar_Pervasives_Native.Some
-                                                      (return_binder,
-                                                        ((FStar_Pervasives.Inl
-                                                            result_typ),
-                                                          FStar_Pervasives_Native.None,
-                                                          use_eq)) in
-                                                  let uu___6 =
-                                                    let uu___7 =
-                                                      let uu___8 =
-                                                        let uu___9 =
-                                                          FStar_Syntax_Util.branch
-                                                            pat in
-                                                        [uu___9] in
-                                                      (arg_exp,
-                                                        returns_annotation,
-                                                        uu___8,
-                                                        FStar_Pervasives_Native.None) in
-                                                    FStar_Syntax_Syntax.Tm_match
-                                                      uu___7 in
-                                                  FStar_Syntax_Syntax.mk
-                                                    uu___6 p1 in
-                                                let imp =
-                                                  FStar_Syntax_Util.abs
-                                                    binders body
-                                                    FStar_Pervasives_Native.None in
-                                                let dd =
-                                                  FStar_Syntax_Syntax.Delta_equational_at_level
-                                                    Prims.int_one in
-                                                let lbtyp =
-                                                  if no_decl
-                                                  then t
-                                                  else
-                                                    FStar_Syntax_Syntax.tun in
-                                                let lb =
-                                                  let uu___6 =
-                                                    let uu___7 =
-                                                      FStar_Syntax_Syntax.lid_as_fv
-                                                        field_name dd
-                                                        FStar_Pervasives_Native.None in
-                                                    FStar_Pervasives.Inr
-                                                      uu___7 in
-                                                  let uu___7 =
-                                                    FStar_Syntax_Subst.close_univ_vars
-                                                      uvs imp in
-                                                  {
-                                                    FStar_Syntax_Syntax.lbname
-                                                      = uu___6;
-                                                    FStar_Syntax_Syntax.lbunivs
-                                                      = uvs;
-                                                    FStar_Syntax_Syntax.lbtyp
-                                                      = lbtyp;
-                                                    FStar_Syntax_Syntax.lbeff
-                                                      =
-                                                      FStar_Parser_Const.effect_Tot_lid;
-                                                    FStar_Syntax_Syntax.lbdef
-                                                      = uu___7;
-                                                    FStar_Syntax_Syntax.lbattrs
-                                                      = [];
-                                                    FStar_Syntax_Syntax.lbpos
-                                                      =
-                                                      FStar_Compiler_Range.dummyRange
-                                                  } in
-                                                let impl =
-                                                  let uu___6 =
-                                                    let uu___7 =
-                                                      let uu___8 =
-                                                        let uu___9 =
-                                                          let uu___10 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              lb.FStar_Syntax_Syntax.lbname
-                                                              FStar_Compiler_Util.right in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___10
-                                                            (fun fv ->
-                                                               (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v) in
-                                                        [uu___9] in
-                                                      ((false, [lb]), uu___8) in
-                                                    FStar_Syntax_Syntax.Sig_let
-                                                      uu___7 in
-                                                  {
-                                                    FStar_Syntax_Syntax.sigel
-                                                      = uu___6;
-                                                    FStar_Syntax_Syntax.sigrng
-                                                      = p1;
-                                                    FStar_Syntax_Syntax.sigquals
-                                                      = quals1;
-                                                    FStar_Syntax_Syntax.sigmeta
-                                                      =
-                                                      FStar_Syntax_Syntax.default_sigmeta;
-                                                    FStar_Syntax_Syntax.sigattrs
-                                                      = attrs1;
-                                                    FStar_Syntax_Syntax.sigopts
-                                                      =
-                                                      FStar_Pervasives_Native.None
-                                                  } in
-                                                (let uu___7 =
-                                                   FStar_TypeChecker_Env.debug
-                                                     env
-                                                     (FStar_Options.Other
-                                                        "LogTypes") in
-                                                 if uu___7
-                                                 then
-                                                   let uu___8 =
-                                                     FStar_Syntax_Print.sigelt_to_string
-                                                       impl in
-                                                   FStar_Compiler_Util.print1
-                                                     "Implementation of a projector %s\n"
-                                                     uu___8
-                                                 else ());
-                                                if no_decl
-                                                then [impl]
-                                                else [decl; impl])))) in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___
-                              FStar_Compiler_List.flatten in
-                          FStar_Compiler_List.op_At discriminator_ses
-                            projectors_ses
-let (mk_data_operations :
-  FStar_Syntax_Syntax.qualifier Prims.list ->
-    FStar_Syntax_Syntax.attribute Prims.list ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.sigelt Prims.list ->
-          FStar_Syntax_Syntax.sigelt -> FStar_Syntax_Syntax.sigelt Prims.list)
-  =
-  fun iquals ->
-    fun attrs ->
-      fun env ->
-        fun tcs ->
-          fun se ->
-            match se.FStar_Syntax_Syntax.sigel with
-            | FStar_Syntax_Syntax.Sig_datacon
-                (constr_lid, uvs, t, typ_lid, n_typars, uu___) ->
-                let uu___1 = FStar_Syntax_Subst.univ_var_opening uvs in
-                (match uu___1 with
-                 | (univ_opening, uvs1) ->
-                     let t1 = FStar_Syntax_Subst.subst univ_opening t in
-                     let uu___2 = FStar_Syntax_Util.arrow_formals t1 in
-                     (match uu___2 with
-                      | (formals, uu___3) ->
-                          let uu___4 =
-                            let tps_opt =
-                              FStar_Compiler_Util.find_map tcs
-                                (fun se1 ->
-                                   let uu___5 =
-                                     let uu___6 =
-                                       let uu___7 =
-                                         FStar_Syntax_Util.lid_of_sigelt se1 in
-                                       FStar_Compiler_Util.must uu___7 in
-                                     FStar_Ident.lid_equals typ_lid uu___6 in
-                                   if uu___5
-                                   then
-                                     match se1.FStar_Syntax_Syntax.sigel with
-                                     | FStar_Syntax_Syntax.Sig_inductive_typ
-                                         (uu___6, uvs', tps, uu___7, typ0,
-                                          uu___8, constrs)
-                                         ->
-                                         FStar_Pervasives_Native.Some
-                                           (tps, typ0,
-                                             ((FStar_Compiler_List.length
-                                                 constrs)
-                                                > Prims.int_one))
-                                     | uu___6 -> failwith "Impossible"
-                                   else FStar_Pervasives_Native.None) in
-                            match tps_opt with
-                            | FStar_Pervasives_Native.Some x -> x
-                            | FStar_Pervasives_Native.None ->
-                                let uu___5 =
-                                  FStar_Ident.lid_equals typ_lid
-                                    FStar_Parser_Const.exn_lid in
-                                if uu___5
-                                then ([], FStar_Syntax_Util.ktype0, true)
-                                else
-                                  FStar_Errors.raise_error
-                                    (FStar_Errors.Fatal_UnexpectedDataConstructor,
-                                      "Unexpected data constructor")
-                                    se.FStar_Syntax_Syntax.sigrng in
-                          (match uu___4 with
-                           | (inductive_tps, typ0, should_refine) ->
-                               let inductive_tps1 =
-                                 FStar_Syntax_Subst.subst_binders
-                                   univ_opening inductive_tps in
-                               let typ01 =
-                                 let uu___5 =
-                                   FStar_Syntax_Subst.shift_subst
-                                     (FStar_Compiler_List.length
-                                        inductive_tps1) univ_opening in
-                                 FStar_Syntax_Subst.subst uu___5 typ0 in
-                               let uu___5 =
-                                 FStar_Syntax_Util.arrow_formals typ01 in
-                               (match uu___5 with
-                                | (indices, uu___6) ->
-                                    let refine_domain =
-                                      let uu___7 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          se.FStar_Syntax_Syntax.sigquals
-                                          (FStar_Compiler_Util.for_some
-                                             (fun uu___8 ->
-                                                match uu___8 with
-                                                | FStar_Syntax_Syntax.RecordConstructor
-                                                    uu___9 -> true
-                                                | uu___9 -> false)) in
-                                      if uu___7 then false else should_refine in
-                                    let fv_qual =
-                                      let filter_records uu___7 =
-                                        match uu___7 with
-                                        | FStar_Syntax_Syntax.RecordConstructor
-                                            (uu___8, fns) ->
-                                            FStar_Pervasives_Native.Some
-                                              (FStar_Syntax_Syntax.Record_ctor
-                                                 (typ_lid, fns))
-                                        | uu___8 ->
-                                            FStar_Pervasives_Native.None in
-                                      let uu___7 =
-                                        FStar_Compiler_Util.find_map
-                                          se.FStar_Syntax_Syntax.sigquals
-                                          filter_records in
-                                      match uu___7 with
-                                      | FStar_Pervasives_Native.None ->
-                                          FStar_Syntax_Syntax.Data_ctor
-                                      | FStar_Pervasives_Native.Some q -> q in
-                                    let fields =
-                                      let uu___7 =
-                                        FStar_Compiler_Util.first_N n_typars
-                                          formals in
-                                      match uu___7 with
-                                      | (imp_tps, fields1) ->
-                                          let rename =
-                                            FStar_Compiler_List.map2
-                                              (fun uu___8 ->
-                                                 fun uu___9 ->
-                                                   match (uu___8, uu___9)
-                                                   with
-                                                   | ({
-                                                        FStar_Syntax_Syntax.binder_bv
-                                                          = x;
-                                                        FStar_Syntax_Syntax.binder_qual
-                                                          = uu___10;
-                                                        FStar_Syntax_Syntax.binder_attrs
-                                                          = uu___11;_},
-                                                      {
-                                                        FStar_Syntax_Syntax.binder_bv
-                                                          = x';
-                                                        FStar_Syntax_Syntax.binder_qual
-                                                          = uu___12;
-                                                        FStar_Syntax_Syntax.binder_attrs
-                                                          = uu___13;_})
-                                                       ->
-                                                       let uu___14 =
-                                                         let uu___15 =
-                                                           FStar_Syntax_Syntax.bv_to_name
-                                                             x' in
-                                                         (x, uu___15) in
-                                                       FStar_Syntax_Syntax.NT
-                                                         uu___14) imp_tps
-                                              inductive_tps1 in
-                                          FStar_Syntax_Subst.subst_binders
-                                            rename fields1 in
-                                    let erasable =
-                                      FStar_Syntax_Util.has_attribute
-                                        se.FStar_Syntax_Syntax.sigattrs
-                                        FStar_Parser_Const.erasable_attr in
-                                    mk_discriminator_and_indexed_projectors
-                                      iquals attrs fv_qual refine_domain env
-                                      typ_lid constr_lid uvs1 inductive_tps1
-                                      indices fields erasable))))
-            | uu___ -> []
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_TcTerm.ml b/src/ocaml-output/FStar_TypeChecker_TcTerm.ml
deleted file mode 100644
index de3299eac68..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_TcTerm.ml
+++ /dev/null
@@ -1,13030 +0,0 @@
-open Prims
-let (instantiate_both :
-  FStar_TypeChecker_Env.env -> FStar_TypeChecker_Env.env) =
-  fun env ->
-    {
-      FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-      FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-      FStar_TypeChecker_Env.curmodule = (env.FStar_TypeChecker_Env.curmodule);
-      FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-      FStar_TypeChecker_Env.gamma_sig = (env.FStar_TypeChecker_Env.gamma_sig);
-      FStar_TypeChecker_Env.gamma_cache =
-        (env.FStar_TypeChecker_Env.gamma_cache);
-      FStar_TypeChecker_Env.modules = (env.FStar_TypeChecker_Env.modules);
-      FStar_TypeChecker_Env.expected_typ =
-        (env.FStar_TypeChecker_Env.expected_typ);
-      FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-      FStar_TypeChecker_Env.attrtab = (env.FStar_TypeChecker_Env.attrtab);
-      FStar_TypeChecker_Env.instantiate_imp = true;
-      FStar_TypeChecker_Env.effects = (env.FStar_TypeChecker_Env.effects);
-      FStar_TypeChecker_Env.generalize =
-        (env.FStar_TypeChecker_Env.generalize);
-      FStar_TypeChecker_Env.letrecs = (env.FStar_TypeChecker_Env.letrecs);
-      FStar_TypeChecker_Env.top_level = (env.FStar_TypeChecker_Env.top_level);
-      FStar_TypeChecker_Env.check_uvars =
-        (env.FStar_TypeChecker_Env.check_uvars);
-      FStar_TypeChecker_Env.use_eq_strict =
-        (env.FStar_TypeChecker_Env.use_eq_strict);
-      FStar_TypeChecker_Env.is_iface = (env.FStar_TypeChecker_Env.is_iface);
-      FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-      FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-      FStar_TypeChecker_Env.lax_universes =
-        (env.FStar_TypeChecker_Env.lax_universes);
-      FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-      FStar_TypeChecker_Env.failhard = (env.FStar_TypeChecker_Env.failhard);
-      FStar_TypeChecker_Env.nosynth = (env.FStar_TypeChecker_Env.nosynth);
-      FStar_TypeChecker_Env.uvar_subtyping =
-        (env.FStar_TypeChecker_Env.uvar_subtyping);
-      FStar_TypeChecker_Env.tc_term = (env.FStar_TypeChecker_Env.tc_term);
-      FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-        (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-      FStar_TypeChecker_Env.universe_of =
-        (env.FStar_TypeChecker_Env.universe_of);
-      FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-        (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-      FStar_TypeChecker_Env.teq_nosmt_force =
-        (env.FStar_TypeChecker_Env.teq_nosmt_force);
-      FStar_TypeChecker_Env.subtype_nosmt_force =
-        (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-      FStar_TypeChecker_Env.qtbl_name_and_index =
-        (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-      FStar_TypeChecker_Env.normalized_eff_names =
-        (env.FStar_TypeChecker_Env.normalized_eff_names);
-      FStar_TypeChecker_Env.fv_delta_depths =
-        (env.FStar_TypeChecker_Env.fv_delta_depths);
-      FStar_TypeChecker_Env.proof_ns = (env.FStar_TypeChecker_Env.proof_ns);
-      FStar_TypeChecker_Env.synth_hook =
-        (env.FStar_TypeChecker_Env.synth_hook);
-      FStar_TypeChecker_Env.try_solve_implicits_hook =
-        (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-      FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-      FStar_TypeChecker_Env.mpreprocess =
-        (env.FStar_TypeChecker_Env.mpreprocess);
-      FStar_TypeChecker_Env.postprocess =
-        (env.FStar_TypeChecker_Env.postprocess);
-      FStar_TypeChecker_Env.identifier_info =
-        (env.FStar_TypeChecker_Env.identifier_info);
-      FStar_TypeChecker_Env.tc_hooks = (env.FStar_TypeChecker_Env.tc_hooks);
-      FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-      FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-      FStar_TypeChecker_Env.strict_args_tab =
-        (env.FStar_TypeChecker_Env.strict_args_tab);
-      FStar_TypeChecker_Env.erasable_types_tab =
-        (env.FStar_TypeChecker_Env.erasable_types_tab);
-      FStar_TypeChecker_Env.enable_defer_to_tac =
-        (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-      FStar_TypeChecker_Env.unif_allow_ref_guards =
-        (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-      FStar_TypeChecker_Env.erase_erasable_args =
-        (env.FStar_TypeChecker_Env.erase_erasable_args);
-      FStar_TypeChecker_Env.core_check =
-        (env.FStar_TypeChecker_Env.core_check)
-    }
-let (no_inst : FStar_TypeChecker_Env.env -> FStar_TypeChecker_Env.env) =
-  fun env ->
-    {
-      FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-      FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-      FStar_TypeChecker_Env.curmodule = (env.FStar_TypeChecker_Env.curmodule);
-      FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-      FStar_TypeChecker_Env.gamma_sig = (env.FStar_TypeChecker_Env.gamma_sig);
-      FStar_TypeChecker_Env.gamma_cache =
-        (env.FStar_TypeChecker_Env.gamma_cache);
-      FStar_TypeChecker_Env.modules = (env.FStar_TypeChecker_Env.modules);
-      FStar_TypeChecker_Env.expected_typ =
-        (env.FStar_TypeChecker_Env.expected_typ);
-      FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-      FStar_TypeChecker_Env.attrtab = (env.FStar_TypeChecker_Env.attrtab);
-      FStar_TypeChecker_Env.instantiate_imp = false;
-      FStar_TypeChecker_Env.effects = (env.FStar_TypeChecker_Env.effects);
-      FStar_TypeChecker_Env.generalize =
-        (env.FStar_TypeChecker_Env.generalize);
-      FStar_TypeChecker_Env.letrecs = (env.FStar_TypeChecker_Env.letrecs);
-      FStar_TypeChecker_Env.top_level = (env.FStar_TypeChecker_Env.top_level);
-      FStar_TypeChecker_Env.check_uvars =
-        (env.FStar_TypeChecker_Env.check_uvars);
-      FStar_TypeChecker_Env.use_eq_strict =
-        (env.FStar_TypeChecker_Env.use_eq_strict);
-      FStar_TypeChecker_Env.is_iface = (env.FStar_TypeChecker_Env.is_iface);
-      FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-      FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-      FStar_TypeChecker_Env.lax_universes =
-        (env.FStar_TypeChecker_Env.lax_universes);
-      FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-      FStar_TypeChecker_Env.failhard = (env.FStar_TypeChecker_Env.failhard);
-      FStar_TypeChecker_Env.nosynth = (env.FStar_TypeChecker_Env.nosynth);
-      FStar_TypeChecker_Env.uvar_subtyping =
-        (env.FStar_TypeChecker_Env.uvar_subtyping);
-      FStar_TypeChecker_Env.tc_term = (env.FStar_TypeChecker_Env.tc_term);
-      FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-        (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-      FStar_TypeChecker_Env.universe_of =
-        (env.FStar_TypeChecker_Env.universe_of);
-      FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-        (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-      FStar_TypeChecker_Env.teq_nosmt_force =
-        (env.FStar_TypeChecker_Env.teq_nosmt_force);
-      FStar_TypeChecker_Env.subtype_nosmt_force =
-        (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-      FStar_TypeChecker_Env.qtbl_name_and_index =
-        (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-      FStar_TypeChecker_Env.normalized_eff_names =
-        (env.FStar_TypeChecker_Env.normalized_eff_names);
-      FStar_TypeChecker_Env.fv_delta_depths =
-        (env.FStar_TypeChecker_Env.fv_delta_depths);
-      FStar_TypeChecker_Env.proof_ns = (env.FStar_TypeChecker_Env.proof_ns);
-      FStar_TypeChecker_Env.synth_hook =
-        (env.FStar_TypeChecker_Env.synth_hook);
-      FStar_TypeChecker_Env.try_solve_implicits_hook =
-        (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-      FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-      FStar_TypeChecker_Env.mpreprocess =
-        (env.FStar_TypeChecker_Env.mpreprocess);
-      FStar_TypeChecker_Env.postprocess =
-        (env.FStar_TypeChecker_Env.postprocess);
-      FStar_TypeChecker_Env.identifier_info =
-        (env.FStar_TypeChecker_Env.identifier_info);
-      FStar_TypeChecker_Env.tc_hooks = (env.FStar_TypeChecker_Env.tc_hooks);
-      FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-      FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-      FStar_TypeChecker_Env.strict_args_tab =
-        (env.FStar_TypeChecker_Env.strict_args_tab);
-      FStar_TypeChecker_Env.erasable_types_tab =
-        (env.FStar_TypeChecker_Env.erasable_types_tab);
-      FStar_TypeChecker_Env.enable_defer_to_tac =
-        (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-      FStar_TypeChecker_Env.unif_allow_ref_guards =
-        (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-      FStar_TypeChecker_Env.erase_erasable_args =
-        (env.FStar_TypeChecker_Env.erase_erasable_args);
-      FStar_TypeChecker_Env.core_check =
-        (env.FStar_TypeChecker_Env.core_check)
-    }
-let (is_eq :
-  FStar_Syntax_Syntax.binder_qualifier FStar_Pervasives_Native.option ->
-    Prims.bool)
-  =
-  fun uu___ ->
-    match uu___ with
-    | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Equality) -> true
-    | uu___1 -> false
-let steps : 'uuuuu . 'uuuuu -> FStar_TypeChecker_Env.step Prims.list =
-  fun env ->
-    [FStar_TypeChecker_Env.Beta;
-    FStar_TypeChecker_Env.Eager_unfolding;
-    FStar_TypeChecker_Env.NoFullNorm]
-let (norm :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env -> fun t -> FStar_TypeChecker_Normalize.normalize (steps env) env t
-let (norm_c :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  =
-  fun env ->
-    fun c -> FStar_TypeChecker_Normalize.normalize_comp (steps env) env c
-let (check_no_escape :
-  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.bv Prims.list ->
-        FStar_Syntax_Syntax.term ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Env.guard_t))
-  =
-  fun head_opt ->
-    fun env ->
-      fun fvs ->
-        fun kt ->
-          let rec aux try_norm t =
-            match fvs with
-            | [] -> (t, FStar_TypeChecker_Env.trivial_guard)
-            | uu___ ->
-                let t1 = if try_norm then norm env t else t in
-                let fvs' = FStar_Syntax_Free.names t1 in
-                let uu___1 =
-                  FStar_Compiler_List.tryFind
-                    (fun x -> FStar_Compiler_Util.set_mem x fvs') fvs in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.None ->
-                     (t1, FStar_TypeChecker_Env.trivial_guard)
-                 | FStar_Pervasives_Native.Some x ->
-                     if Prims.op_Negation try_norm
-                     then aux true t1
-                     else
-                       (let fail uu___3 =
-                          let msg =
-                            match head_opt with
-                            | FStar_Pervasives_Native.None ->
-                                let uu___4 =
-                                  FStar_Syntax_Print.bv_to_string x in
-                                FStar_Compiler_Util.format1
-                                  "Bound variables '%s' escapes; add a type annotation"
-                                  uu___4
-                            | FStar_Pervasives_Native.Some head ->
-                                let uu___4 =
-                                  FStar_Syntax_Print.bv_to_string x in
-                                let uu___5 =
-                                  FStar_TypeChecker_Normalize.term_to_string
-                                    env head in
-                                FStar_Compiler_Util.format2
-                                  "Bound variables '%s' in the type of '%s' escape because of impure applications; add explicit let-bindings"
-                                  uu___4 uu___5 in
-                          let uu___4 = FStar_TypeChecker_Env.get_range env in
-                          FStar_Errors.raise_error
-                            (FStar_Errors.Fatal_EscapedBoundVar, msg) uu___4 in
-                        let uu___3 =
-                          let uu___4 = FStar_TypeChecker_Env.get_range env in
-                          let uu___5 =
-                            let uu___6 = FStar_Syntax_Util.type_u () in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_Pervasives_Native.fst uu___6 in
-                          FStar_TypeChecker_Util.new_implicit_var "no escape"
-                            uu___4 env uu___5 in
-                        match uu___3 with
-                        | (s, uu___4, g0) ->
-                            let uu___5 =
-                              FStar_TypeChecker_Rel.try_teq true env t1 s in
-                            (match uu___5 with
-                             | FStar_Pervasives_Native.Some g ->
-                                 let g1 =
-                                   let uu___6 =
-                                     FStar_TypeChecker_Env.conj_guard g g0 in
-                                   FStar_TypeChecker_Rel.solve_deferred_constraints
-                                     env uu___6 in
-                                 (s, g1)
-                             | uu___6 -> fail ()))) in
-          aux false kt
-let (check_expected_aqual_for_binder :
-  FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option ->
-    FStar_Syntax_Syntax.binder ->
-      FStar_Compiler_Range.range ->
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-  =
-  fun aq ->
-    fun b ->
-      fun pos ->
-        let expected_aq = FStar_Syntax_Util.aqual_of_binder b in
-        match (aq, expected_aq) with
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.None) -> aq
-        | (FStar_Pervasives_Native.None, FStar_Pervasives_Native.Some eaq) ->
-            if eaq.FStar_Syntax_Syntax.aqual_implicit
-            then
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_InconsistentImplicitQualifier,
-                  "Inconsistent implicit qualifiers (expected implicit annotation on the argument)")
-                pos
-            else expected_aq
-        | (FStar_Pervasives_Native.Some aq1, FStar_Pervasives_Native.None) ->
-            FStar_Errors.raise_error
-              (FStar_Errors.Fatal_InconsistentImplicitQualifier,
-                "Inconsistent implicit qualifiers (did not expect argument aquals)")
-              pos
-        | (FStar_Pervasives_Native.Some aq1, FStar_Pervasives_Native.Some
-           eaq) ->
-            if
-              aq1.FStar_Syntax_Syntax.aqual_implicit <>
-                eaq.FStar_Syntax_Syntax.aqual_implicit
-            then
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_InconsistentImplicitQualifier,
-                  "Inconsistent implicit qualifiers (mismatch)") pos
-            else expected_aq
-let (check_erasable_binder_attributes :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax Prims.list ->
-      FStar_Syntax_Syntax.typ -> unit)
-  =
-  fun env ->
-    fun attrs ->
-      fun binder_ty ->
-        FStar_Compiler_List.iter
-          (fun attr ->
-             let uu___ =
-               (FStar_Syntax_Util.is_fvar FStar_Parser_Const.erasable_attr
-                  attr)
-                 &&
-                 (let uu___1 =
-                    FStar_TypeChecker_Normalize.non_info_norm env binder_ty in
-                  Prims.op_Negation uu___1) in
-             if uu___
-             then
-               FStar_Errors.raise_error
-                 (FStar_Errors.Fatal_QulifierListNotPermitted,
-                   "Incompatible attributes:an erasable attribute on a binder must bind a name at an non-informative type")
-                 attr.FStar_Syntax_Syntax.pos
-             else ()) attrs
-let (push_binding :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binder -> FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun b ->
-      FStar_TypeChecker_Env.push_bv env b.FStar_Syntax_Syntax.binder_bv
-let (maybe_extend_subst :
-  FStar_Syntax_Syntax.subst_elt Prims.list ->
-    FStar_Syntax_Syntax.binder ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.subst_t)
-  =
-  fun s ->
-    fun b ->
-      fun v ->
-        let uu___ = FStar_Syntax_Syntax.is_null_binder b in
-        if uu___
-        then s
-        else (FStar_Syntax_Syntax.NT ((b.FStar_Syntax_Syntax.binder_bv), v))
-          :: s
-let (set_lcomp_result :
-  FStar_TypeChecker_Common.lcomp ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_TypeChecker_Common.lcomp)
-  =
-  fun lc ->
-    fun t ->
-      FStar_TypeChecker_Common.apply_lcomp
-        (fun c -> FStar_Syntax_Util.set_result_typ c t) (fun g -> g)
-        {
-          FStar_TypeChecker_Common.eff_name =
-            (lc.FStar_TypeChecker_Common.eff_name);
-          FStar_TypeChecker_Common.res_typ = t;
-          FStar_TypeChecker_Common.cflags =
-            (lc.FStar_TypeChecker_Common.cflags);
-          FStar_TypeChecker_Common.comp_thunk =
-            (lc.FStar_TypeChecker_Common.comp_thunk)
-        }
-let (memo_tk :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  = fun e -> fun t -> e
-let (maybe_warn_on_use :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.fv -> unit) =
-  fun env ->
-    fun fv ->
-      let uu___ =
-        FStar_TypeChecker_Env.lookup_attrs_of_lid env
-          (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-      match uu___ with
-      | FStar_Pervasives_Native.None -> ()
-      | FStar_Pervasives_Native.Some attrs ->
-          FStar_Compiler_Effect.op_Bar_Greater attrs
-            (FStar_Compiler_List.iter
-               (fun a ->
-                  let uu___1 = FStar_Syntax_Util.head_and_args a in
-                  match uu___1 with
-                  | (head, args) ->
-                      let msg_arg m =
-                        match args with
-                        | ({
-                             FStar_Syntax_Syntax.n =
-                               FStar_Syntax_Syntax.Tm_constant
-                               (FStar_Const.Const_string (s, uu___2));
-                             FStar_Syntax_Syntax.pos = uu___3;
-                             FStar_Syntax_Syntax.vars = uu___4;
-                             FStar_Syntax_Syntax.hash_code = uu___5;_},
-                           uu___6)::[] ->
-                            Prims.op_Hat m (Prims.op_Hat ": " s)
-                        | uu___2 -> m in
-                      (match head.FStar_Syntax_Syntax.n with
-                       | FStar_Syntax_Syntax.Tm_fvar attr_fv when
-                           FStar_Ident.lid_equals
-                             (attr_fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                             FStar_Parser_Const.warn_on_use_attr
-                           ->
-                           let m =
-                             let uu___2 =
-                               FStar_Ident.string_of_lid
-                                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                             FStar_Compiler_Util.format1
-                               "Every use of %s triggers a warning" uu___2 in
-                           let uu___2 =
-                             FStar_Ident.range_of_lid
-                               (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                           FStar_Errors.log_issue uu___2
-                             (FStar_Errors.Warning_WarnOnUse, (msg_arg m))
-                       | FStar_Syntax_Syntax.Tm_fvar attr_fv when
-                           FStar_Ident.lid_equals
-                             (attr_fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                             FStar_Parser_Const.deprecated_attr
-                           ->
-                           let m =
-                             let uu___2 =
-                               FStar_Ident.string_of_lid
-                                 (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                             FStar_Compiler_Util.format1 "%s is deprecated"
-                               uu___2 in
-                           let uu___2 =
-                             FStar_Ident.range_of_lid
-                               (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                           FStar_Errors.log_issue uu___2
-                             (FStar_Errors.Warning_DeprecatedDefinition,
-                               (msg_arg m))
-                       | uu___2 -> ())))
-let (value_check_expected_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.typ, FStar_TypeChecker_Common.lcomp)
-        FStar_Pervasives.either ->
-        FStar_TypeChecker_Env.guard_t ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun tlc ->
-        fun guard ->
-          FStar_TypeChecker_Env.def_check_guard_wf e.FStar_Syntax_Syntax.pos
-            "value_check_expected_typ" env guard;
-          (let lc =
-             match tlc with
-             | FStar_Pervasives.Inl t ->
-                 let uu___1 = FStar_Syntax_Syntax.mk_Total t in
-                 FStar_Compiler_Effect.op_Less_Bar
-                   FStar_TypeChecker_Common.lcomp_of_comp uu___1
-             | FStar_Pervasives.Inr lc1 -> lc1 in
-           let t = lc.FStar_TypeChecker_Common.res_typ in
-           let uu___1 =
-             let uu___2 = FStar_TypeChecker_Env.expected_typ env in
-             match uu___2 with
-             | FStar_Pervasives_Native.None -> ((memo_tk e t), lc, guard)
-             | FStar_Pervasives_Native.Some (t', use_eq) ->
-                 let uu___3 =
-                   FStar_TypeChecker_Util.check_has_type_maybe_coerce env e
-                     lc t' use_eq in
-                 (match uu___3 with
-                  | (e1, lc1, g) ->
-                      ((let uu___5 =
-                          FStar_TypeChecker_Env.debug env
-                            FStar_Options.Medium in
-                        if uu___5
-                        then
-                          let uu___6 =
-                            FStar_TypeChecker_Common.lcomp_to_string lc1 in
-                          let uu___7 = FStar_Syntax_Print.term_to_string t' in
-                          let uu___8 =
-                            FStar_TypeChecker_Rel.guard_to_string env g in
-                          let uu___9 =
-                            FStar_TypeChecker_Rel.guard_to_string env guard in
-                          FStar_Compiler_Util.print4
-                            "value_check_expected_typ: type is %s<:%s \tguard is %s, %s\n"
-                            uu___6 uu___7 uu___8 uu___9
-                        else ());
-                       (let t1 = lc1.FStar_TypeChecker_Common.res_typ in
-                        let g1 = FStar_TypeChecker_Env.conj_guard g guard in
-                        let msg =
-                          let uu___5 =
-                            FStar_TypeChecker_Env.is_trivial_guard_formula g1 in
-                          if uu___5
-                          then FStar_Pervasives_Native.None
-                          else
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (fun uu___7 ->
-                                 FStar_Pervasives_Native.Some uu___7)
-                              (FStar_TypeChecker_Err.subtyping_failed env t1
-                                 t') in
-                        let uu___5 =
-                          FStar_TypeChecker_Util.strengthen_precondition msg
-                            env e1 lc1 g1 in
-                        match uu___5 with
-                        | (lc2, g2) ->
-                            let uu___6 = set_lcomp_result lc2 t' in
-                            ((memo_tk e1 t'), uu___6, g2)))) in
-           match uu___1 with | (e1, lc1, g) -> (e1, lc1, g))
-let (comp_check_expected_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp ->
-        (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-          FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        let uu___ = FStar_TypeChecker_Env.expected_typ env in
-        match uu___ with
-        | FStar_Pervasives_Native.None ->
-            (e, lc, FStar_TypeChecker_Env.trivial_guard)
-        | FStar_Pervasives_Native.Some (t, use_eq) ->
-            let uu___1 = FStar_TypeChecker_Util.maybe_coerce_lc env e lc t in
-            (match uu___1 with
-             | (e1, lc1, g_c) ->
-                 let uu___2 =
-                   FStar_TypeChecker_Util.weaken_result_typ env e1 lc1 t
-                     use_eq in
-                 (match uu___2 with
-                  | (e2, lc2, g) ->
-                      let uu___3 = FStar_TypeChecker_Env.conj_guard g g_c in
-                      (e2, lc2, uu___3)))
-let (check_expected_effect :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.comp FStar_Pervasives_Native.option ->
-        (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp) ->
-          (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun use_eq ->
-      fun copt ->
-        fun ec ->
-          let uu___ = ec in
-          match uu___ with
-          | (e, c) ->
-              let tot_or_gtot c1 =
-                let uu___1 = FStar_Syntax_Util.is_pure_comp c1 in
-                if uu___1
-                then
-                  FStar_Syntax_Syntax.mk_Total
-                    (FStar_Syntax_Util.comp_result c1)
-                else
-                  (let uu___3 = FStar_Syntax_Util.is_pure_or_ghost_comp c1 in
-                   if uu___3
-                   then
-                     FStar_Syntax_Syntax.mk_GTotal
-                       (FStar_Syntax_Util.comp_result c1)
-                   else failwith "Impossible: Expected pure_or_ghost comp") in
-              let uu___1 =
-                let ct = FStar_Syntax_Util.comp_result c in
-                match copt with
-                | FStar_Pervasives_Native.Some uu___2 ->
-                    (copt, c, FStar_Pervasives_Native.None)
-                | FStar_Pervasives_Native.None ->
-                    let uu___2 =
-                      ((FStar_Options.ml_ish ()) &&
-                         (let uu___3 = FStar_Parser_Const.effect_ALL_lid () in
-                          FStar_Ident.lid_equals uu___3
-                            (FStar_Syntax_Util.comp_effect_name c)))
-                        ||
-                        (((FStar_Options.ml_ish ()) &&
-                            env.FStar_TypeChecker_Env.lax)
-                           &&
-                           (let uu___3 =
-                              FStar_Syntax_Util.is_pure_or_ghost_comp c in
-                            Prims.op_Negation uu___3)) in
-                    if uu___2
-                    then
-                      let uu___3 =
-                        let uu___4 =
-                          FStar_Syntax_Util.ml_comp ct
-                            e.FStar_Syntax_Syntax.pos in
-                        FStar_Pervasives_Native.Some uu___4 in
-                      (uu___3, c, FStar_Pervasives_Native.None)
-                    else
-                      (let uu___4 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-                       if uu___4
-                       then
-                         let uu___5 = tot_or_gtot c in
-                         (FStar_Pervasives_Native.None, uu___5,
-                           FStar_Pervasives_Native.None)
-                       else
-                         (let uu___6 =
-                            FStar_Syntax_Util.is_pure_or_ghost_comp c in
-                          if uu___6
-                          then
-                            let uu___7 =
-                              let uu___8 = tot_or_gtot c in
-                              FStar_Pervasives_Native.Some uu___8 in
-                            (uu___7, c, FStar_Pervasives_Native.None)
-                          else
-                            (let norm_eff_name =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 (FStar_Syntax_Util.comp_effect_name c)
-                                 (FStar_TypeChecker_Env.norm_eff_name env) in
-                             let uu___8 =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 norm_eff_name
-                                 (FStar_TypeChecker_Env.is_layered_effect env) in
-                             if uu___8
-                             then
-                               let def_eff_opt =
-                                 FStar_TypeChecker_Env.get_default_effect env
-                                   norm_eff_name in
-                               match def_eff_opt with
-                               | FStar_Pervasives_Native.None ->
-                                   let uu___9 =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         let uu___12 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             c
-                                             FStar_Syntax_Util.comp_effect_name in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___12 FStar_Ident.string_of_lid in
-                                       let uu___12 =
-                                         FStar_Compiler_Range.string_of_range
-                                           e.FStar_Syntax_Syntax.pos in
-                                       FStar_Compiler_Util.format2
-                                         "Missing annotation for a layered effect (%s) computation at %s"
-                                         uu___11 uu___12 in
-                                     (FStar_Errors.Error_LayeredMissingAnnot,
-                                       uu___10) in
-                                   FStar_Errors.raise_error uu___9
-                                     e.FStar_Syntax_Syntax.pos
-                               | FStar_Pervasives_Native.Some def_eff ->
-                                   let uu___9 =
-                                     match c.FStar_Syntax_Syntax.n with
-                                     | FStar_Syntax_Syntax.Comp
-                                         {
-                                           FStar_Syntax_Syntax.comp_univs =
-                                             comp_univs;
-                                           FStar_Syntax_Syntax.effect_name =
-                                             uu___10;
-                                           FStar_Syntax_Syntax.result_typ =
-                                             result_ty;
-                                           FStar_Syntax_Syntax.effect_args =
-                                             uu___11;
-                                           FStar_Syntax_Syntax.flags =
-                                             uu___12;_}
-                                         -> (comp_univs, result_ty)
-                                     | uu___10 -> failwith "Impossible!" in
-                                   (match uu___9 with
-                                    | (comp_univs, result_ty) ->
-                                        let expected_c =
-                                          {
-                                            FStar_Syntax_Syntax.comp_univs =
-                                              comp_univs;
-                                            FStar_Syntax_Syntax.effect_name =
-                                              def_eff;
-                                            FStar_Syntax_Syntax.result_typ =
-                                              result_ty;
-                                            FStar_Syntax_Syntax.effect_args =
-                                              [];
-                                            FStar_Syntax_Syntax.flags = []
-                                          } in
-                                        let uu___10 =
-                                          let uu___11 =
-                                            FStar_Syntax_Syntax.mk_Comp
-                                              expected_c in
-                                          FStar_Pervasives_Native.Some
-                                            uu___11 in
-                                        (uu___10, c,
-                                          FStar_Pervasives_Native.None))
-                             else
-                               (let uu___10 =
-                                  FStar_Options.trivial_pre_for_unannotated_effectful_fns
-                                    () in
-                                if uu___10
-                                then
-                                  let uu___11 =
-                                    let uu___12 =
-                                      FStar_TypeChecker_Util.check_trivial_precondition_wp
-                                        env c in
-                                    match uu___12 with
-                                    | (uu___13, uu___14, g) ->
-                                        FStar_Pervasives_Native.Some g in
-                                  (FStar_Pervasives_Native.None, c, uu___11)
-                                else
-                                  (FStar_Pervasives_Native.None, c,
-                                    FStar_Pervasives_Native.None))))) in
-              (match uu___1 with
-               | (expected_c_opt, c1, gopt) ->
-                   let c2 = norm_c env c1 in
-                   (match expected_c_opt with
-                    | FStar_Pervasives_Native.None ->
-                        (e, c2,
-                          ((match gopt with
-                            | FStar_Pervasives_Native.None ->
-                                FStar_TypeChecker_Env.trivial_guard
-                            | FStar_Pervasives_Native.Some g -> g)))
-                    | FStar_Pervasives_Native.Some expected_c ->
-                        ((match gopt with
-                          | FStar_Pervasives_Native.None -> ()
-                          | FStar_Pervasives_Native.Some uu___3 ->
-                              failwith
-                                "Impossible! check_expected_effect, gopt should have been None");
-                         (let c3 =
-                            let uu___3 =
-                              FStar_TypeChecker_Common.lcomp_of_comp c2 in
-                            FStar_TypeChecker_Util.maybe_assume_result_eq_pure_term
-                              env e uu___3 in
-                          let uu___3 = FStar_TypeChecker_Common.lcomp_comp c3 in
-                          match uu___3 with
-                          | (c4, g_c) ->
-                              ((let uu___5 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env)
-                                    FStar_Options.Medium in
-                                if uu___5
-                                then
-                                  let uu___6 =
-                                    FStar_Syntax_Print.term_to_string e in
-                                  let uu___7 =
-                                    FStar_Syntax_Print.comp_to_string c4 in
-                                  let uu___8 =
-                                    FStar_Syntax_Print.comp_to_string
-                                      expected_c in
-                                  let uu___9 =
-                                    FStar_Compiler_Util.string_of_bool use_eq in
-                                  FStar_Compiler_Util.print4
-                                    "In check_expected_effect, asking rel to solve the problem on e=(%s) and c=(%s), expected_c=(%s), and use_eq=%s\n"
-                                    uu___6 uu___7 uu___8 uu___9
-                                else ());
-                               (let uu___5 =
-                                  FStar_TypeChecker_Util.check_comp env
-                                    use_eq e c4 expected_c in
-                                match uu___5 with
-                                | (e1, uu___6, g) ->
-                                    let g1 =
-                                      let uu___7 =
-                                        FStar_TypeChecker_Env.get_range env in
-                                      FStar_TypeChecker_Util.label_guard
-                                        uu___7
-                                        "could not prove post-condition" g in
-                                    ((let uu___8 =
-                                        FStar_TypeChecker_Env.debug env
-                                          FStar_Options.Medium in
-                                      if uu___8
-                                      then
-                                        let uu___9 =
-                                          FStar_Compiler_Range.string_of_range
-                                            e1.FStar_Syntax_Syntax.pos in
-                                        let uu___10 =
-                                          FStar_TypeChecker_Rel.guard_to_string
-                                            env g1 in
-                                        FStar_Compiler_Util.print2
-                                          "(%s) DONE check_expected_effect;\n\tguard is: %s\n"
-                                          uu___9 uu___10
-                                      else ());
-                                     (let e2 =
-                                        FStar_TypeChecker_Util.maybe_lift env
-                                          e1
-                                          (FStar_Syntax_Util.comp_effect_name
-                                             c4)
-                                          (FStar_Syntax_Util.comp_effect_name
-                                             expected_c)
-                                          (FStar_Syntax_Util.comp_result c4) in
-                                      let uu___8 =
-                                        FStar_TypeChecker_Env.conj_guard g_c
-                                          g1 in
-                                      (e2, expected_c, uu___8)))))))))
-let no_logical_guard :
-  'uuuuu 'uuuuu1 .
-    FStar_TypeChecker_Env.env ->
-      ('uuuuu * 'uuuuu1 * FStar_TypeChecker_Env.guard_t) ->
-        ('uuuuu * 'uuuuu1 * FStar_TypeChecker_Env.guard_t)
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | (te, kt, f) ->
-          let uu___1 = FStar_TypeChecker_Env.guard_form f in
-          (match uu___1 with
-           | FStar_TypeChecker_Common.Trivial -> (te, kt, f)
-           | FStar_TypeChecker_Common.NonTrivial f1 ->
-               let uu___2 =
-                 FStar_TypeChecker_Err.unexpected_non_trivial_precondition_on_term
-                   env f1 in
-               let uu___3 = FStar_TypeChecker_Env.get_range env in
-               FStar_Errors.raise_error uu___2 uu___3)
-let (print_expected_ty_str : FStar_TypeChecker_Env.env -> Prims.string) =
-  fun env ->
-    let uu___ = FStar_TypeChecker_Env.expected_typ env in
-    match uu___ with
-    | FStar_Pervasives_Native.None -> "Expected type is None"
-    | FStar_Pervasives_Native.Some (t, use_eq) ->
-        let uu___1 = FStar_Syntax_Print.term_to_string t in
-        let uu___2 = FStar_Compiler_Util.string_of_bool use_eq in
-        FStar_Compiler_Util.format2 "Expected type is (%s, use_eq = %s)"
-          uu___1 uu___2
-let (print_expected_ty : FStar_TypeChecker_Env.env -> unit) =
-  fun env ->
-    let uu___ = print_expected_ty_str env in
-    FStar_Compiler_Util.print1 "%s\n" uu___
-let rec (get_pat_vars' :
-  FStar_Syntax_Syntax.bv Prims.list ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.bv FStar_Compiler_Util.set)
-  =
-  fun all ->
-    fun andlist ->
-      fun pats ->
-        let pats1 = FStar_Syntax_Util.unmeta pats in
-        let uu___ = FStar_Syntax_Util.head_and_args pats1 in
-        match uu___ with
-        | (head, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.un_uinst head in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.nil_lid
-                 ->
-                 if andlist
-                 then
-                   FStar_Compiler_Util.as_set all
-                     FStar_Syntax_Syntax.order_bv
-                 else
-                   FStar_Compiler_Util.new_set FStar_Syntax_Syntax.order_bv
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (uu___2, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::
-                (hd, FStar_Pervasives_Native.None)::(tl,
-                                                     FStar_Pervasives_Native.None)::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid
-                 ->
-                 let hdvs = get_pat_vars' all false hd in
-                 let tlvs = get_pat_vars' all andlist tl in
-                 if andlist
-                 then FStar_Compiler_Util.set_intersect hdvs tlvs
-                 else FStar_Compiler_Util.set_union hdvs tlvs
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (uu___2, FStar_Pervasives_Native.Some
-                 { FStar_Syntax_Syntax.aqual_implicit = true;
-                   FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::
-                (pat, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.smtpat_lid
-                 -> FStar_Syntax_Free.names pat
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (subpats, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.smtpatOr_lid
-                 -> get_pat_vars' all true subpats
-             | uu___2 ->
-                 FStar_Compiler_Util.new_set FStar_Syntax_Syntax.order_bv)
-let (get_pat_vars :
-  FStar_Syntax_Syntax.bv Prims.list ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.bv FStar_Compiler_Util.set)
-  = fun all -> fun pats -> get_pat_vars' all false pats
-let (check_pat_fvs :
-  FStar_Compiler_Range.range ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.binder Prims.list -> unit)
-  =
-  fun rng ->
-    fun env ->
-      fun pats ->
-        fun bs ->
-          let pat_vars =
-            let uu___ =
-              FStar_Compiler_List.map
-                (fun b -> b.FStar_Syntax_Syntax.binder_bv) bs in
-            let uu___1 =
-              FStar_TypeChecker_Normalize.normalize
-                [FStar_TypeChecker_Env.Beta] env pats in
-            get_pat_vars uu___ uu___1 in
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater bs
-              (FStar_Compiler_Util.find_opt
-                 (fun uu___1 ->
-                    match uu___1 with
-                    | { FStar_Syntax_Syntax.binder_bv = b;
-                        FStar_Syntax_Syntax.binder_qual = uu___2;
-                        FStar_Syntax_Syntax.binder_attrs = uu___3;_} ->
-                        let uu___4 = FStar_Compiler_Util.set_mem b pat_vars in
-                        Prims.op_Negation uu___4)) in
-          match uu___ with
-          | FStar_Pervasives_Native.None -> ()
-          | FStar_Pervasives_Native.Some
-              { FStar_Syntax_Syntax.binder_bv = x;
-                FStar_Syntax_Syntax.binder_qual = uu___1;
-                FStar_Syntax_Syntax.binder_attrs = uu___2;_}
-              ->
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = FStar_Syntax_Print.bv_to_string x in
-                  FStar_Compiler_Util.format1
-                    "Pattern misses at least one bound variable: %s" uu___5 in
-                (FStar_Errors.Warning_SMTPatternIllFormed, uu___4) in
-              FStar_Errors.log_issue rng uu___3
-let (check_no_smt_theory_symbols :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> unit) =
-  fun en ->
-    fun t ->
-      let rec pat_terms t1 =
-        let t2 = FStar_Syntax_Util.unmeta t1 in
-        let uu___ = FStar_Syntax_Util.head_and_args t2 in
-        match uu___ with
-        | (head, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Util.un_uinst head in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.nil_lid
-                 -> []
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                uu___2::(hd, uu___3)::(tl, uu___4)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.cons_lid
-                 ->
-                 let uu___5 = pat_terms hd in
-                 let uu___6 = pat_terms tl in
-                 FStar_Compiler_List.op_At uu___5 uu___6
-             | (FStar_Syntax_Syntax.Tm_fvar fv, uu___2::(pat, uu___3)::[])
-                 when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.smtpat_lid
-                 -> [pat]
-             | (FStar_Syntax_Syntax.Tm_fvar fv,
-                (subpats, FStar_Pervasives_Native.None)::[]) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv
-                   FStar_Parser_Const.smtpatOr_lid
-                 -> pat_terms subpats
-             | uu___2 -> []) in
-      let rec aux t1 =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress t1 in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_bvar uu___1 -> []
-        | FStar_Syntax_Syntax.Tm_name uu___1 -> []
-        | FStar_Syntax_Syntax.Tm_constant uu___1 -> []
-        | FStar_Syntax_Syntax.Tm_type uu___1 -> []
-        | FStar_Syntax_Syntax.Tm_uvar uu___1 -> []
-        | FStar_Syntax_Syntax.Tm_lazy uu___1 -> []
-        | FStar_Syntax_Syntax.Tm_unknown -> []
-        | FStar_Syntax_Syntax.Tm_abs uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_arrow uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_refine uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_match uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_let uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_delayed uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_quoted uu___1 -> [t1]
-        | FStar_Syntax_Syntax.Tm_fvar fv ->
-            let uu___1 =
-              FStar_TypeChecker_Env.fv_has_attr en fv
-                FStar_Parser_Const.smt_theory_symbol_attr_lid in
-            if uu___1 then [t1] else []
-        | FStar_Syntax_Syntax.Tm_app (t2, args) ->
-            let uu___1 = aux t2 in
-            FStar_Compiler_List.fold_left
-              (fun acc ->
-                 fun uu___2 ->
-                   match uu___2 with
-                   | (t3, uu___3) ->
-                       let uu___4 = aux t3 in
-                       FStar_Compiler_List.op_At acc uu___4) uu___1 args
-        | FStar_Syntax_Syntax.Tm_ascribed (t2, uu___1, uu___2) -> aux t2
-        | FStar_Syntax_Syntax.Tm_uinst (t2, uu___1) -> aux t2
-        | FStar_Syntax_Syntax.Tm_meta (t2, uu___1) -> aux t2 in
-      let tlist =
-        let uu___ = FStar_Compiler_Effect.op_Bar_Greater t pat_terms in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (FStar_Compiler_List.collect aux) in
-      if (FStar_Compiler_List.length tlist) = Prims.int_zero
-      then ()
-      else
-        (let msg =
-           FStar_Compiler_List.fold_left
-             (fun s ->
-                fun t1 ->
-                  let uu___1 =
-                    let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-                    Prims.op_Hat " " uu___2 in
-                  Prims.op_Hat s uu___1) "" tlist in
-         let uu___1 =
-           let uu___2 =
-             FStar_Compiler_Util.format1
-               "Pattern uses these theory symbols or terms that should not be in an smt pattern: %s"
-               msg in
-           (FStar_Errors.Warning_SMTPatternIllFormed, uu___2) in
-         FStar_Errors.log_issue t.FStar_Syntax_Syntax.pos uu___1)
-let (check_smt_pat :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.binder Prims.list ->
-        FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax -> unit)
-  =
-  fun env ->
-    fun t ->
-      fun bs ->
-        fun c ->
-          let uu___ = FStar_Syntax_Util.is_smt_lemma t in
-          if uu___
-          then
-            match c.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Comp
-                { FStar_Syntax_Syntax.comp_univs = uu___1;
-                  FStar_Syntax_Syntax.effect_name = uu___2;
-                  FStar_Syntax_Syntax.result_typ = uu___3;
-                  FStar_Syntax_Syntax.effect_args =
-                    _pre::_post::(pats, uu___4)::[];
-                  FStar_Syntax_Syntax.flags = uu___5;_}
-                ->
-                (check_pat_fvs t.FStar_Syntax_Syntax.pos env pats bs;
-                 check_no_smt_theory_symbols env pats)
-            | uu___1 -> failwith "Impossible"
-          else ()
-let (guard_letrecs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-        (FStar_Syntax_Syntax.lbname * FStar_Syntax_Syntax.typ *
-          FStar_Syntax_Syntax.univ_names) Prims.list)
-  =
-  fun env ->
-    fun actuals ->
-      fun expected_c ->
-        match env.FStar_TypeChecker_Env.letrecs with
-        | [] -> []
-        | letrecs ->
-            let r = FStar_TypeChecker_Env.get_range env in
-            let env1 =
-              {
-                FStar_TypeChecker_Env.solver =
-                  (env.FStar_TypeChecker_Env.solver);
-                FStar_TypeChecker_Env.range =
-                  (env.FStar_TypeChecker_Env.range);
-                FStar_TypeChecker_Env.curmodule =
-                  (env.FStar_TypeChecker_Env.curmodule);
-                FStar_TypeChecker_Env.gamma =
-                  (env.FStar_TypeChecker_Env.gamma);
-                FStar_TypeChecker_Env.gamma_sig =
-                  (env.FStar_TypeChecker_Env.gamma_sig);
-                FStar_TypeChecker_Env.gamma_cache =
-                  (env.FStar_TypeChecker_Env.gamma_cache);
-                FStar_TypeChecker_Env.modules =
-                  (env.FStar_TypeChecker_Env.modules);
-                FStar_TypeChecker_Env.expected_typ =
-                  (env.FStar_TypeChecker_Env.expected_typ);
-                FStar_TypeChecker_Env.sigtab =
-                  (env.FStar_TypeChecker_Env.sigtab);
-                FStar_TypeChecker_Env.attrtab =
-                  (env.FStar_TypeChecker_Env.attrtab);
-                FStar_TypeChecker_Env.instantiate_imp =
-                  (env.FStar_TypeChecker_Env.instantiate_imp);
-                FStar_TypeChecker_Env.effects =
-                  (env.FStar_TypeChecker_Env.effects);
-                FStar_TypeChecker_Env.generalize =
-                  (env.FStar_TypeChecker_Env.generalize);
-                FStar_TypeChecker_Env.letrecs = [];
-                FStar_TypeChecker_Env.top_level =
-                  (env.FStar_TypeChecker_Env.top_level);
-                FStar_TypeChecker_Env.check_uvars =
-                  (env.FStar_TypeChecker_Env.check_uvars);
-                FStar_TypeChecker_Env.use_eq_strict =
-                  (env.FStar_TypeChecker_Env.use_eq_strict);
-                FStar_TypeChecker_Env.is_iface =
-                  (env.FStar_TypeChecker_Env.is_iface);
-                FStar_TypeChecker_Env.admit =
-                  (env.FStar_TypeChecker_Env.admit);
-                FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-                FStar_TypeChecker_Env.lax_universes =
-                  (env.FStar_TypeChecker_Env.lax_universes);
-                FStar_TypeChecker_Env.phase1 =
-                  (env.FStar_TypeChecker_Env.phase1);
-                FStar_TypeChecker_Env.failhard =
-                  (env.FStar_TypeChecker_Env.failhard);
-                FStar_TypeChecker_Env.nosynth =
-                  (env.FStar_TypeChecker_Env.nosynth);
-                FStar_TypeChecker_Env.uvar_subtyping =
-                  (env.FStar_TypeChecker_Env.uvar_subtyping);
-                FStar_TypeChecker_Env.tc_term =
-                  (env.FStar_TypeChecker_Env.tc_term);
-                FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                  (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                FStar_TypeChecker_Env.universe_of =
-                  (env.FStar_TypeChecker_Env.universe_of);
-                FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                  (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                FStar_TypeChecker_Env.teq_nosmt_force =
-                  (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                FStar_TypeChecker_Env.subtype_nosmt_force =
-                  (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                FStar_TypeChecker_Env.qtbl_name_and_index =
-                  (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                FStar_TypeChecker_Env.normalized_eff_names =
-                  (env.FStar_TypeChecker_Env.normalized_eff_names);
-                FStar_TypeChecker_Env.fv_delta_depths =
-                  (env.FStar_TypeChecker_Env.fv_delta_depths);
-                FStar_TypeChecker_Env.proof_ns =
-                  (env.FStar_TypeChecker_Env.proof_ns);
-                FStar_TypeChecker_Env.synth_hook =
-                  (env.FStar_TypeChecker_Env.synth_hook);
-                FStar_TypeChecker_Env.try_solve_implicits_hook =
-                  (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                FStar_TypeChecker_Env.splice =
-                  (env.FStar_TypeChecker_Env.splice);
-                FStar_TypeChecker_Env.mpreprocess =
-                  (env.FStar_TypeChecker_Env.mpreprocess);
-                FStar_TypeChecker_Env.postprocess =
-                  (env.FStar_TypeChecker_Env.postprocess);
-                FStar_TypeChecker_Env.identifier_info =
-                  (env.FStar_TypeChecker_Env.identifier_info);
-                FStar_TypeChecker_Env.tc_hooks =
-                  (env.FStar_TypeChecker_Env.tc_hooks);
-                FStar_TypeChecker_Env.dsenv =
-                  (env.FStar_TypeChecker_Env.dsenv);
-                FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-                FStar_TypeChecker_Env.strict_args_tab =
-                  (env.FStar_TypeChecker_Env.strict_args_tab);
-                FStar_TypeChecker_Env.erasable_types_tab =
-                  (env.FStar_TypeChecker_Env.erasable_types_tab);
-                FStar_TypeChecker_Env.enable_defer_to_tac =
-                  (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                FStar_TypeChecker_Env.unif_allow_ref_guards =
-                  (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                FStar_TypeChecker_Env.erase_erasable_args =
-                  (env.FStar_TypeChecker_Env.erase_erasable_args);
-                FStar_TypeChecker_Env.core_check =
-                  (env.FStar_TypeChecker_Env.core_check)
-              } in
-            let decreases_clause bs c =
-              (let uu___1 =
-                 FStar_TypeChecker_Env.debug env1 FStar_Options.Low in
-               if uu___1
-               then
-                 let uu___2 = FStar_Syntax_Print.binders_to_string ", " bs in
-                 let uu___3 = FStar_Syntax_Print.comp_to_string c in
-                 FStar_Compiler_Util.print2
-                   "Building a decreases clause over (%s) and %s\n" uu___2
-                   uu___3
-               else ());
-              (let filter_types_and_functions bs1 =
-                 let uu___1 =
-                   FStar_Compiler_List.fold_left
-                     (fun uu___2 ->
-                        fun binder ->
-                          match uu___2 with
-                          | (out, env2) ->
-                              let b = binder.FStar_Syntax_Syntax.binder_bv in
-                              let t =
-                                let uu___3 =
-                                  FStar_Syntax_Util.unrefine
-                                    b.FStar_Syntax_Syntax.sort in
-                                FStar_TypeChecker_Normalize.unfold_whnf env2
-                                  uu___3 in
-                              let env3 =
-                                FStar_TypeChecker_Env.push_binders env2
-                                  [binder] in
-                              (match t.FStar_Syntax_Syntax.n with
-                               | FStar_Syntax_Syntax.Tm_type uu___3 ->
-                                   (out, env3)
-                               | FStar_Syntax_Syntax.Tm_arrow uu___3 ->
-                                   (out, env3)
-                               | uu___3 ->
-                                   let arg = FStar_Syntax_Syntax.bv_to_name b in
-                                   let arg1 =
-                                     let uu___4 =
-                                       FStar_Syntax_Util.is_erased_head t in
-                                     match uu___4 with
-                                     | FStar_Pervasives_Native.Some (u, ty)
-                                         ->
-                                         FStar_Syntax_Util.apply_reveal u ty
-                                           arg
-                                     | uu___5 -> arg in
-                                   ((arg1 :: out), env3))) ([], env1) bs1 in
-                 match uu___1 with
-                 | (out_rev, env2) -> FStar_Compiler_List.rev out_rev in
-               let cflags = FStar_Syntax_Util.comp_flags c in
-               let uu___1 =
-                 FStar_Compiler_Effect.op_Bar_Greater cflags
-                   (FStar_Compiler_List.tryFind
-                      (fun uu___2 ->
-                         match uu___2 with
-                         | FStar_Syntax_Syntax.DECREASES uu___3 -> true
-                         | uu___3 -> false)) in
-               match uu___1 with
-               | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.DECREASES
-                   d) -> d
-               | uu___2 ->
-                   let uu___3 =
-                     FStar_Compiler_Effect.op_Bar_Greater bs
-                       filter_types_and_functions in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___3
-                     (fun uu___4 -> FStar_Syntax_Syntax.Decreases_lex uu___4)) in
-            let precedes_t =
-              FStar_TypeChecker_Util.fvar_const env1
-                FStar_Parser_Const.precedes_lid in
-            let rec mk_precedes_lex env2 l l_prev =
-              let rec aux l1 l_prev1 =
-                let type_of should_warn e1 e2 =
-                  let t1 =
-                    let uu___ =
-                      let uu___1 =
-                        env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                          env2 e1 false in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___1
-                        FStar_Pervasives_Native.fst in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___
-                      FStar_Syntax_Util.unrefine in
-                  let t2 =
-                    let uu___ =
-                      let uu___1 =
-                        env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                          env2 e2 false in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___1
-                        FStar_Pervasives_Native.fst in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___
-                      FStar_Syntax_Util.unrefine in
-                  let rec warn t11 t21 =
-                    let uu___ =
-                      let uu___1 = FStar_Syntax_Util.eq_tm t11 t21 in
-                      uu___1 = FStar_Syntax_Util.Equal in
-                    if uu___
-                    then false
-                    else
-                      (let uu___2 =
-                         let uu___3 =
-                           let uu___4 = FStar_Syntax_Subst.compress t11 in
-                           uu___4.FStar_Syntax_Syntax.n in
-                         let uu___4 =
-                           let uu___5 = FStar_Syntax_Subst.compress t21 in
-                           uu___5.FStar_Syntax_Syntax.n in
-                         (uu___3, uu___4) in
-                       match uu___2 with
-                       | (FStar_Syntax_Syntax.Tm_uinst (t12, uu___3),
-                          FStar_Syntax_Syntax.Tm_uinst (t22, uu___4)) ->
-                           warn t12 t22
-                       | (FStar_Syntax_Syntax.Tm_name uu___3,
-                          FStar_Syntax_Syntax.Tm_name uu___4) -> false
-                       | (FStar_Syntax_Syntax.Tm_app (h1, args1),
-                          FStar_Syntax_Syntax.Tm_app (h2, args2)) ->
-                           ((warn h1 h2) ||
-                              ((FStar_Compiler_List.length args1) <>
-                                 (FStar_Compiler_List.length args2)))
-                             ||
-                             (let uu___3 =
-                                FStar_Compiler_List.zip args1 args2 in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                (FStar_Compiler_List.existsML
-                                   (fun uu___4 ->
-                                      match uu___4 with
-                                      | ((a1, uu___5), (a2, uu___6)) ->
-                                          warn a1 a2)))
-                       | (FStar_Syntax_Syntax.Tm_refine (t12, phi1),
-                          FStar_Syntax_Syntax.Tm_refine (t22, phi2)) ->
-                           (warn t12.FStar_Syntax_Syntax.sort
-                              t22.FStar_Syntax_Syntax.sort)
-                             || (warn phi1 phi2)
-                       | (FStar_Syntax_Syntax.Tm_uvar uu___3, uu___4) ->
-                           false
-                       | (uu___3, FStar_Syntax_Syntax.Tm_uvar uu___4) ->
-                           false
-                       | (uu___3, uu___4) -> true) in
-                  (let uu___1 = should_warn && (warn t1 t2) in
-                   if uu___1
-                   then
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Subst.compress t1 in
-                         uu___4.FStar_Syntax_Syntax.n in
-                       let uu___4 =
-                         let uu___5 = FStar_Syntax_Subst.compress t2 in
-                         uu___5.FStar_Syntax_Syntax.n in
-                       (uu___3, uu___4) in
-                     match uu___2 with
-                     | (FStar_Syntax_Syntax.Tm_name uu___3,
-                        FStar_Syntax_Syntax.Tm_name uu___4) -> ()
-                     | (uu___3, uu___4) ->
-                         let uu___5 =
-                           let uu___6 =
-                             let uu___7 =
-                               FStar_Syntax_Print.term_to_string e1 in
-                             let uu___8 =
-                               FStar_Compiler_Range.string_of_range
-                                 e1.FStar_Syntax_Syntax.pos in
-                             let uu___9 =
-                               FStar_Syntax_Print.term_to_string t1 in
-                             let uu___10 =
-                               FStar_Syntax_Print.term_to_string e2 in
-                             let uu___11 =
-                               FStar_Compiler_Range.string_of_range
-                                 e2.FStar_Syntax_Syntax.pos in
-                             let uu___12 =
-                               FStar_Syntax_Print.term_to_string t2 in
-                             FStar_Compiler_Util.format6
-                               "SMT may not be able to prove the types of %s at %s (%s) and %s at %s (%s) to be equal, if the proof fails, try annotating these with the same type"
-                               uu___7 uu___8 uu___9 uu___10 uu___11 uu___12 in
-                           (FStar_Errors.Warning_Defensive, uu___6) in
-                         FStar_Errors.log_issue e1.FStar_Syntax_Syntax.pos
-                           uu___5
-                   else ());
-                  (t1, t2) in
-                match (l1, l_prev1) with
-                | ([], []) ->
-                    let uu___ =
-                      let uu___1 =
-                        FStar_Syntax_Syntax.as_arg
-                          FStar_Syntax_Syntax.unit_const in
-                      let uu___2 =
-                        let uu___3 =
-                          FStar_Syntax_Syntax.as_arg
-                            FStar_Syntax_Syntax.unit_const in
-                        [uu___3] in
-                      uu___1 :: uu___2 in
-                    FStar_Syntax_Syntax.mk_Tm_app precedes_t uu___ r
-                | (x::[], x_prev::[]) ->
-                    let uu___ = type_of false x x_prev in
-                    (match uu___ with
-                     | (t_x, t_x_prev) ->
-                         let uu___1 =
-                           let uu___2 = FStar_Syntax_Syntax.iarg t_x in
-                           let uu___3 =
-                             let uu___4 = FStar_Syntax_Syntax.iarg t_x_prev in
-                             let uu___5 =
-                               let uu___6 = FStar_Syntax_Syntax.as_arg x in
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_Syntax_Syntax.as_arg x_prev in
-                                 [uu___8] in
-                               uu___6 :: uu___7 in
-                             uu___4 :: uu___5 in
-                           uu___2 :: uu___3 in
-                         FStar_Syntax_Syntax.mk_Tm_app precedes_t uu___1 r)
-                | (x::tl, x_prev::tl_prev) ->
-                    let uu___ = type_of true x x_prev in
-                    (match uu___ with
-                     | (t_x, t_x_prev) ->
-                         let tm_precedes =
-                           let uu___1 =
-                             let uu___2 = FStar_Syntax_Syntax.iarg t_x in
-                             let uu___3 =
-                               let uu___4 = FStar_Syntax_Syntax.iarg t_x_prev in
-                               let uu___5 =
-                                 let uu___6 = FStar_Syntax_Syntax.as_arg x in
-                                 let uu___7 =
-                                   let uu___8 =
-                                     FStar_Syntax_Syntax.as_arg x_prev in
-                                   [uu___8] in
-                                 uu___6 :: uu___7 in
-                               uu___4 :: uu___5 in
-                             uu___2 :: uu___3 in
-                           FStar_Syntax_Syntax.mk_Tm_app precedes_t uu___1 r in
-                         let eq3_x_x_prev =
-                           FStar_Syntax_Util.mk_eq3_no_univ t_x t_x_prev x
-                             x_prev in
-                         let uu___1 =
-                           let uu___2 = aux tl tl_prev in
-                           FStar_Syntax_Util.mk_conj eq3_x_x_prev uu___2 in
-                         FStar_Syntax_Util.mk_disj tm_precedes uu___1) in
-              let uu___ =
-                let uu___1 =
-                  ((FStar_Compiler_List.length l),
-                    (FStar_Compiler_List.length l_prev)) in
-                match uu___1 with
-                | (n, n_prev) ->
-                    if n = n_prev
-                    then (l, l_prev)
-                    else
-                      if n < n_prev
-                      then
-                        (let uu___3 =
-                           let uu___4 =
-                             FStar_Compiler_Effect.op_Bar_Greater l_prev
-                               (FStar_Compiler_List.splitAt n) in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___4
-                             FStar_Pervasives_Native.fst in
-                         (l, uu___3))
-                      else
-                        (let uu___4 =
-                           let uu___5 =
-                             FStar_Compiler_Effect.op_Bar_Greater l
-                               (FStar_Compiler_List.splitAt n_prev) in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___5
-                             FStar_Pervasives_Native.fst in
-                         (uu___4, l_prev)) in
-              match uu___ with | (l1, l_prev1) -> aux l1 l_prev1 in
-            let mk_precedes env2 d d_prev =
-              match (d, d_prev) with
-              | (FStar_Syntax_Syntax.Decreases_lex l,
-                 FStar_Syntax_Syntax.Decreases_lex l_prev) ->
-                  mk_precedes_lex env2 l l_prev
-              | (FStar_Syntax_Syntax.Decreases_wf (rel, e),
-                 FStar_Syntax_Syntax.Decreases_wf (rel_prev, e_prev)) ->
-                  let rel_guard =
-                    let uu___ =
-                      let uu___1 = FStar_Syntax_Syntax.as_arg e in
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Syntax.as_arg e_prev in
-                        [uu___3] in
-                      uu___1 :: uu___2 in
-                    FStar_Syntax_Syntax.mk_Tm_app rel uu___ r in
-                  let uu___ =
-                    let uu___1 = FStar_Syntax_Util.eq_tm rel rel_prev in
-                    uu___1 = FStar_Syntax_Util.Equal in
-                  if uu___
-                  then rel_guard
-                  else
-                    (let uu___2 =
-                       FStar_Errors.with_ctx
-                         "Typechecking decreases well-founded relation"
-                         (fun uu___3 ->
-                            env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                              env2 rel false) in
-                     match uu___2 with
-                     | (t_rel, uu___3) ->
-                         let uu___4 =
-                           FStar_Errors.with_ctx
-                             "Typechecking previous decreases well-founded relation"
-                             (fun uu___5 ->
-                                env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                  env2 rel_prev false) in
-                         (match uu___4 with
-                          | (t_rel_prev, uu___5) ->
-                              let eq_guard =
-                                FStar_Syntax_Util.mk_eq3_no_univ t_rel
-                                  t_rel_prev rel rel_prev in
-                              FStar_Syntax_Util.mk_conj eq_guard rel_guard))
-              | (uu___, uu___1) ->
-                  FStar_Errors.raise_error
-                    (FStar_Errors.Fatal_UnexpectedTerm,
-                      "Cannot build termination VC with a well-founded relation and lex ordering")
-                    r in
-            let previous_dec = decreases_clause actuals expected_c in
-            let guard_one_letrec uu___ =
-              match uu___ with
-              | (l, arity, t, u_names) ->
-                  let uu___1 =
-                    FStar_TypeChecker_Normalize.get_n_binders env1 arity t in
-                  (match uu___1 with
-                   | (formals, c) ->
-                       (if arity > (FStar_Compiler_List.length formals)
-                        then
-                          failwith
-                            "impossible: bad formals arity, guard_one_letrec"
-                        else ();
-                        (let formals1 =
-                           FStar_Compiler_Effect.op_Bar_Greater formals
-                             (FStar_Compiler_List.map
-                                (fun b ->
-                                   let uu___3 =
-                                     FStar_Syntax_Syntax.is_null_bv
-                                       b.FStar_Syntax_Syntax.binder_bv in
-                                   if uu___3
-                                   then
-                                     let uu___4 =
-                                       let uu___5 =
-                                         let uu___6 =
-                                           FStar_Syntax_Syntax.range_of_bv
-                                             b.FStar_Syntax_Syntax.binder_bv in
-                                         FStar_Pervasives_Native.Some uu___6 in
-                                       FStar_Syntax_Syntax.new_bv uu___5
-                                         (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                     {
-                                       FStar_Syntax_Syntax.binder_bv = uu___4;
-                                       FStar_Syntax_Syntax.binder_qual =
-                                         (b.FStar_Syntax_Syntax.binder_qual);
-                                       FStar_Syntax_Syntax.binder_attrs =
-                                         (b.FStar_Syntax_Syntax.binder_attrs)
-                                     }
-                                   else b)) in
-                         let dec = decreases_clause formals1 c in
-                         let precedes =
-                           let env2 =
-                             FStar_TypeChecker_Env.push_binders env1 formals1 in
-                           mk_precedes env2 dec previous_dec in
-                         let precedes1 =
-                           FStar_TypeChecker_Util.label
-                             "Could not prove termination of this recursive call"
-                             r precedes in
-                         let uu___3 = FStar_Compiler_Util.prefix formals1 in
-                         match uu___3 with
-                         | (bs,
-                            { FStar_Syntax_Syntax.binder_bv = last;
-                              FStar_Syntax_Syntax.binder_qual = imp;
-                              FStar_Syntax_Syntax.binder_attrs = uu___4;_})
-                             ->
-                             let last1 =
-                               let uu___5 =
-                                 FStar_Syntax_Util.refine last precedes1 in
-                               {
-                                 FStar_Syntax_Syntax.ppname =
-                                   (last.FStar_Syntax_Syntax.ppname);
-                                 FStar_Syntax_Syntax.index =
-                                   (last.FStar_Syntax_Syntax.index);
-                                 FStar_Syntax_Syntax.sort = uu___5
-                               } in
-                             let refined_formals =
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Syntax_Syntax.mk_binder_with_attrs
-                                     last1 imp [] in
-                                 [uu___6] in
-                               FStar_Compiler_List.op_At bs uu___5 in
-                             let t' =
-                               FStar_Syntax_Util.arrow refined_formals c in
-                             ((let uu___6 =
-                                 FStar_TypeChecker_Env.debug env1
-                                   FStar_Options.Medium in
-                               if uu___6
-                               then
-                                 let uu___7 =
-                                   FStar_Syntax_Print.lbname_to_string l in
-                                 let uu___8 =
-                                   FStar_Syntax_Print.term_to_string t in
-                                 let uu___9 =
-                                   FStar_Syntax_Print.term_to_string t' in
-                                 FStar_Compiler_Util.print3
-                                   "Refined let rec %s\n\tfrom type %s\n\tto type %s\n"
-                                   uu___7 uu___8 uu___9
-                               else ());
-                              (l, t', u_names))))) in
-            FStar_Compiler_Effect.op_Bar_Greater letrecs
-              (FStar_Compiler_List.map guard_one_letrec)
-let (wrap_guard_with_tactic_opt :
-  FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.guard_t -> FStar_TypeChecker_Env.guard_t)
-  =
-  fun topt ->
-    fun g ->
-      match topt with
-      | FStar_Pervasives_Native.None -> g
-      | FStar_Pervasives_Native.Some tactic ->
-          FStar_TypeChecker_Env.always_map_guard g
-            (fun g1 ->
-               let uu___ =
-                 FStar_Syntax_Util.mk_squash FStar_Syntax_Syntax.U_zero g1 in
-               FStar_TypeChecker_Common.mk_by_tactic tactic uu___)
-let (is_comp_ascribed_reflect :
-  FStar_Syntax_Syntax.term ->
-    (FStar_Ident.lident * FStar_Syntax_Syntax.term *
-      FStar_Syntax_Syntax.aqual) FStar_Pervasives_Native.option)
-  =
-  fun e ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress e in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_ascribed
-        (e1, (FStar_Pervasives.Inr uu___1, uu___2, uu___3), uu___4) ->
-        let uu___5 =
-          let uu___6 = FStar_Syntax_Subst.compress e1 in
-          uu___6.FStar_Syntax_Syntax.n in
-        (match uu___5 with
-         | FStar_Syntax_Syntax.Tm_app (head, args) when
-             (FStar_Compiler_List.length args) = Prims.int_one ->
-             let uu___6 =
-               let uu___7 = FStar_Syntax_Subst.compress head in
-               uu___7.FStar_Syntax_Syntax.n in
-             (match uu___6 with
-              | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reflect l)
-                  ->
-                  let uu___7 =
-                    let uu___8 =
-                      FStar_Compiler_Effect.op_Bar_Greater args
-                        FStar_Compiler_List.hd in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___8
-                      (fun uu___9 ->
-                         match uu___9 with | (e2, aqual) -> (l, e2, aqual)) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___7
-                    (fun uu___8 -> FStar_Pervasives_Native.Some uu___8)
-              | uu___7 -> FStar_Pervasives_Native.None)
-         | uu___6 -> FStar_Pervasives_Native.None)
-    | uu___1 -> FStar_Pervasives_Native.None
-let rec (tc_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      FStar_TypeChecker_Env.def_check_closed_in_env e.FStar_Syntax_Syntax.pos
-        "tc_term.entry" env e;
-      (let uu___2 = FStar_TypeChecker_Env.debug env FStar_Options.Medium in
-       if uu___2
-       then
-         let uu___3 =
-           let uu___4 = FStar_TypeChecker_Env.get_range env in
-           FStar_Compiler_Effect.op_Less_Bar
-             FStar_Compiler_Range.string_of_range uu___4 in
-         let uu___4 =
-           FStar_Compiler_Util.string_of_bool
-             env.FStar_TypeChecker_Env.phase1 in
-         let uu___5 = FStar_Syntax_Print.term_to_string e in
-         let uu___6 =
-           let uu___7 = FStar_Syntax_Subst.compress e in
-           FStar_Syntax_Print.tag_of_term uu___7 in
-         let uu___7 = print_expected_ty_str env in
-         FStar_Compiler_Util.print5
-           "(%s) Starting tc_term (phase1=%s) of %s (%s), %s {\n" uu___3
-           uu___4 uu___5 uu___6 uu___7
-       else ());
-      (let uu___2 =
-         FStar_Compiler_Util.record_time
-           (fun uu___3 ->
-              tc_maybe_toplevel_term
-                {
-                  FStar_TypeChecker_Env.solver =
-                    (env.FStar_TypeChecker_Env.solver);
-                  FStar_TypeChecker_Env.range =
-                    (env.FStar_TypeChecker_Env.range);
-                  FStar_TypeChecker_Env.curmodule =
-                    (env.FStar_TypeChecker_Env.curmodule);
-                  FStar_TypeChecker_Env.gamma =
-                    (env.FStar_TypeChecker_Env.gamma);
-                  FStar_TypeChecker_Env.gamma_sig =
-                    (env.FStar_TypeChecker_Env.gamma_sig);
-                  FStar_TypeChecker_Env.gamma_cache =
-                    (env.FStar_TypeChecker_Env.gamma_cache);
-                  FStar_TypeChecker_Env.modules =
-                    (env.FStar_TypeChecker_Env.modules);
-                  FStar_TypeChecker_Env.expected_typ =
-                    (env.FStar_TypeChecker_Env.expected_typ);
-                  FStar_TypeChecker_Env.sigtab =
-                    (env.FStar_TypeChecker_Env.sigtab);
-                  FStar_TypeChecker_Env.attrtab =
-                    (env.FStar_TypeChecker_Env.attrtab);
-                  FStar_TypeChecker_Env.instantiate_imp =
-                    (env.FStar_TypeChecker_Env.instantiate_imp);
-                  FStar_TypeChecker_Env.effects =
-                    (env.FStar_TypeChecker_Env.effects);
-                  FStar_TypeChecker_Env.generalize =
-                    (env.FStar_TypeChecker_Env.generalize);
-                  FStar_TypeChecker_Env.letrecs =
-                    (env.FStar_TypeChecker_Env.letrecs);
-                  FStar_TypeChecker_Env.top_level = false;
-                  FStar_TypeChecker_Env.check_uvars =
-                    (env.FStar_TypeChecker_Env.check_uvars);
-                  FStar_TypeChecker_Env.use_eq_strict =
-                    (env.FStar_TypeChecker_Env.use_eq_strict);
-                  FStar_TypeChecker_Env.is_iface =
-                    (env.FStar_TypeChecker_Env.is_iface);
-                  FStar_TypeChecker_Env.admit =
-                    (env.FStar_TypeChecker_Env.admit);
-                  FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-                  FStar_TypeChecker_Env.lax_universes =
-                    (env.FStar_TypeChecker_Env.lax_universes);
-                  FStar_TypeChecker_Env.phase1 =
-                    (env.FStar_TypeChecker_Env.phase1);
-                  FStar_TypeChecker_Env.failhard =
-                    (env.FStar_TypeChecker_Env.failhard);
-                  FStar_TypeChecker_Env.nosynth =
-                    (env.FStar_TypeChecker_Env.nosynth);
-                  FStar_TypeChecker_Env.uvar_subtyping =
-                    (env.FStar_TypeChecker_Env.uvar_subtyping);
-                  FStar_TypeChecker_Env.tc_term =
-                    (env.FStar_TypeChecker_Env.tc_term);
-                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                    (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                  FStar_TypeChecker_Env.universe_of =
-                    (env.FStar_TypeChecker_Env.universe_of);
-                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                    (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                  FStar_TypeChecker_Env.teq_nosmt_force =
-                    (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                    (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                    (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                  FStar_TypeChecker_Env.normalized_eff_names =
-                    (env.FStar_TypeChecker_Env.normalized_eff_names);
-                  FStar_TypeChecker_Env.fv_delta_depths =
-                    (env.FStar_TypeChecker_Env.fv_delta_depths);
-                  FStar_TypeChecker_Env.proof_ns =
-                    (env.FStar_TypeChecker_Env.proof_ns);
-                  FStar_TypeChecker_Env.synth_hook =
-                    (env.FStar_TypeChecker_Env.synth_hook);
-                  FStar_TypeChecker_Env.try_solve_implicits_hook =
-                    (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                  FStar_TypeChecker_Env.splice =
-                    (env.FStar_TypeChecker_Env.splice);
-                  FStar_TypeChecker_Env.mpreprocess =
-                    (env.FStar_TypeChecker_Env.mpreprocess);
-                  FStar_TypeChecker_Env.postprocess =
-                    (env.FStar_TypeChecker_Env.postprocess);
-                  FStar_TypeChecker_Env.identifier_info =
-                    (env.FStar_TypeChecker_Env.identifier_info);
-                  FStar_TypeChecker_Env.tc_hooks =
-                    (env.FStar_TypeChecker_Env.tc_hooks);
-                  FStar_TypeChecker_Env.dsenv =
-                    (env.FStar_TypeChecker_Env.dsenv);
-                  FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-                  FStar_TypeChecker_Env.strict_args_tab =
-                    (env.FStar_TypeChecker_Env.strict_args_tab);
-                  FStar_TypeChecker_Env.erasable_types_tab =
-                    (env.FStar_TypeChecker_Env.erasable_types_tab);
-                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                    (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                  FStar_TypeChecker_Env.unif_allow_ref_guards =
-                    (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                  FStar_TypeChecker_Env.erase_erasable_args =
-                    (env.FStar_TypeChecker_Env.erase_erasable_args);
-                  FStar_TypeChecker_Env.core_check =
-                    (env.FStar_TypeChecker_Env.core_check)
-                } e) in
-       match uu___2 with
-       | (r, ms) ->
-           ((let uu___4 =
-               FStar_TypeChecker_Env.debug env FStar_Options.Medium in
-             if uu___4
-             then
-               ((let uu___6 =
-                   let uu___7 = FStar_TypeChecker_Env.get_range env in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     FStar_Compiler_Range.string_of_range uu___7 in
-                 let uu___7 = FStar_Syntax_Print.term_to_string e in
-                 let uu___8 =
-                   let uu___9 = FStar_Syntax_Subst.compress e in
-                   FStar_Syntax_Print.tag_of_term uu___9 in
-                 let uu___9 = FStar_Compiler_Util.string_of_int ms in
-                 FStar_Compiler_Util.print4
-                   "(%s) } tc_term of %s (%s) took %sms\n" uu___6 uu___7
-                   uu___8 uu___9);
-                (let uu___6 = r in
-                 match uu___6 with
-                 | (e1, lc, uu___7) ->
-                     let uu___8 =
-                       let uu___9 = FStar_TypeChecker_Env.get_range env in
-                       FStar_Compiler_Effect.op_Less_Bar
-                         FStar_Compiler_Range.string_of_range uu___9 in
-                     let uu___9 = FStar_Syntax_Print.term_to_string e1 in
-                     let uu___10 =
-                       FStar_TypeChecker_Common.lcomp_to_string lc in
-                     let uu___11 =
-                       let uu___12 = FStar_Syntax_Subst.compress e1 in
-                       FStar_Syntax_Print.tag_of_term uu___12 in
-                     FStar_Compiler_Util.print4
-                       "(%s) Result is: (%s:%s) (%s)\n" uu___8 uu___9 uu___10
-                       uu___11))
-             else ());
-            r))
-and (tc_maybe_toplevel_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      let env1 =
-        if e.FStar_Syntax_Syntax.pos = FStar_Compiler_Range.dummyRange
-        then env
-        else FStar_TypeChecker_Env.set_range env e.FStar_Syntax_Syntax.pos in
-      FStar_TypeChecker_Env.def_check_closed_in_env e.FStar_Syntax_Syntax.pos
-        "tc_maybe_toplevel_term.entry" env1 e;
-      (let top = FStar_Syntax_Subst.compress e in
-       (let uu___2 = FStar_TypeChecker_Env.debug env1 FStar_Options.Medium in
-        if uu___2
-        then
-          let uu___3 =
-            let uu___4 = FStar_TypeChecker_Env.get_range env1 in
-            FStar_Compiler_Effect.op_Less_Bar
-              FStar_Compiler_Range.string_of_range uu___4 in
-          let uu___4 = FStar_Syntax_Print.tag_of_term top in
-          let uu___5 = FStar_Syntax_Print.term_to_string top in
-          FStar_Compiler_Util.print3 "Typechecking %s (%s): %s\n" uu___3
-            uu___4 uu___5
-        else ());
-       (match top.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_delayed uu___2 -> failwith "Impossible"
-        | FStar_Syntax_Syntax.Tm_uinst uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_uvar uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_bvar uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_name uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_fvar uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_constant uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_abs uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_arrow uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_refine uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_type uu___2 -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_unknown -> tc_value env1 e
-        | FStar_Syntax_Syntax.Tm_quoted (qt, qi) ->
-            let projl uu___2 =
-              match uu___2 with
-              | FStar_Pervasives.Inl x -> x
-              | FStar_Pervasives.Inr uu___3 -> failwith "projl fail" in
-            let non_trivial_antiquotes qi1 =
-              let is_name t =
-                let uu___2 =
-                  let uu___3 = FStar_Syntax_Subst.compress t in
-                  uu___3.FStar_Syntax_Syntax.n in
-                match uu___2 with
-                | FStar_Syntax_Syntax.Tm_name uu___3 -> true
-                | uu___3 -> false in
-              FStar_Compiler_Util.for_some
-                (fun uu___2 ->
-                   match uu___2 with
-                   | (uu___3, t) ->
-                       let uu___4 = is_name t in Prims.op_Negation uu___4)
-                qi1.FStar_Syntax_Syntax.antiquotes in
-            (match qi.FStar_Syntax_Syntax.qkind with
-             | FStar_Syntax_Syntax.Quote_static when
-                 non_trivial_antiquotes qi ->
-                 let e0 = e in
-                 let newbvs =
-                   FStar_Compiler_List.map
-                     (fun uu___2 ->
-                        FStar_Syntax_Syntax.new_bv
-                          FStar_Pervasives_Native.None
-                          FStar_Syntax_Syntax.t_term)
-                     qi.FStar_Syntax_Syntax.antiquotes in
-                 let z =
-                   FStar_Compiler_List.zip qi.FStar_Syntax_Syntax.antiquotes
-                     newbvs in
-                 let lbs =
-                   FStar_Compiler_List.map
-                     (fun uu___2 ->
-                        match uu___2 with
-                        | ((bv, t), bv') ->
-                            FStar_Syntax_Util.close_univs_and_mk_letbinding
-                              FStar_Pervasives_Native.None
-                              (FStar_Pervasives.Inl bv') []
-                              FStar_Syntax_Syntax.t_term
-                              FStar_Parser_Const.effect_Tot_lid t []
-                              t.FStar_Syntax_Syntax.pos) z in
-                 let qi1 =
-                   let uu___2 =
-                     FStar_Compiler_List.map
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | ((bv, uu___4), bv') ->
-                              let uu___5 = FStar_Syntax_Syntax.bv_to_name bv' in
-                              (bv, uu___5)) z in
-                   {
-                     FStar_Syntax_Syntax.qkind =
-                       (qi.FStar_Syntax_Syntax.qkind);
-                     FStar_Syntax_Syntax.antiquotes = uu___2
-                   } in
-                 let nq =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_quoted (qt, qi1))
-                     top.FStar_Syntax_Syntax.pos in
-                 let e1 =
-                   FStar_Compiler_List.fold_left
-                     (fun t ->
-                        fun lb ->
-                          let uu___2 =
-                            let uu___3 =
-                              let uu___4 =
-                                let uu___5 =
-                                  let uu___6 =
-                                    let uu___7 =
-                                      projl lb.FStar_Syntax_Syntax.lbname in
-                                    FStar_Syntax_Syntax.mk_binder uu___7 in
-                                  [uu___6] in
-                                FStar_Syntax_Subst.close uu___5 t in
-                              ((false, [lb]), uu___4) in
-                            FStar_Syntax_Syntax.Tm_let uu___3 in
-                          FStar_Syntax_Syntax.mk uu___2
-                            top.FStar_Syntax_Syntax.pos) nq lbs in
-                 tc_maybe_toplevel_term env1 e1
-             | FStar_Syntax_Syntax.Quote_static ->
-                 let aqs = qi.FStar_Syntax_Syntax.antiquotes in
-                 let env_tm =
-                   FStar_TypeChecker_Env.set_expected_typ env1
-                     FStar_Syntax_Syntax.t_term in
-                 let uu___2 =
-                   FStar_Compiler_List.fold_right
-                     (fun uu___3 ->
-                        fun uu___4 ->
-                          match (uu___3, uu___4) with
-                          | ((bv, tm), (aqs_rev, guard)) ->
-                              let uu___5 = tc_term env_tm tm in
-                              (match uu___5 with
-                               | (tm1, uu___6, g) ->
-                                   let uu___7 =
-                                     FStar_TypeChecker_Env.conj_guard g guard in
-                                   (((bv, tm1) :: aqs_rev), uu___7))) aqs
-                     ([], FStar_TypeChecker_Env.trivial_guard) in
-                 (match uu___2 with
-                  | (aqs_rev, guard) ->
-                      let qi1 =
-                        {
-                          FStar_Syntax_Syntax.qkind =
-                            (qi.FStar_Syntax_Syntax.qkind);
-                          FStar_Syntax_Syntax.antiquotes =
-                            (FStar_Compiler_List.rev aqs_rev)
-                        } in
-                      let tm =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_quoted (qt, qi1))
-                          top.FStar_Syntax_Syntax.pos in
-                      value_check_expected_typ env1 tm
-                        (FStar_Pervasives.Inl FStar_Syntax_Syntax.t_term)
-                        guard)
-             | FStar_Syntax_Syntax.Quote_dynamic ->
-                 let c =
-                   FStar_Syntax_Syntax.mk_Tac FStar_Syntax_Syntax.t_term in
-                 let uu___2 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-                 (match uu___2 with
-                  | (env', uu___3) ->
-                      let env'1 =
-                        {
-                          FStar_TypeChecker_Env.solver =
-                            (env'.FStar_TypeChecker_Env.solver);
-                          FStar_TypeChecker_Env.range =
-                            (env'.FStar_TypeChecker_Env.range);
-                          FStar_TypeChecker_Env.curmodule =
-                            (env'.FStar_TypeChecker_Env.curmodule);
-                          FStar_TypeChecker_Env.gamma =
-                            (env'.FStar_TypeChecker_Env.gamma);
-                          FStar_TypeChecker_Env.gamma_sig =
-                            (env'.FStar_TypeChecker_Env.gamma_sig);
-                          FStar_TypeChecker_Env.gamma_cache =
-                            (env'.FStar_TypeChecker_Env.gamma_cache);
-                          FStar_TypeChecker_Env.modules =
-                            (env'.FStar_TypeChecker_Env.modules);
-                          FStar_TypeChecker_Env.expected_typ =
-                            (env'.FStar_TypeChecker_Env.expected_typ);
-                          FStar_TypeChecker_Env.sigtab =
-                            (env'.FStar_TypeChecker_Env.sigtab);
-                          FStar_TypeChecker_Env.attrtab =
-                            (env'.FStar_TypeChecker_Env.attrtab);
-                          FStar_TypeChecker_Env.instantiate_imp =
-                            (env'.FStar_TypeChecker_Env.instantiate_imp);
-                          FStar_TypeChecker_Env.effects =
-                            (env'.FStar_TypeChecker_Env.effects);
-                          FStar_TypeChecker_Env.generalize =
-                            (env'.FStar_TypeChecker_Env.generalize);
-                          FStar_TypeChecker_Env.letrecs =
-                            (env'.FStar_TypeChecker_Env.letrecs);
-                          FStar_TypeChecker_Env.top_level =
-                            (env'.FStar_TypeChecker_Env.top_level);
-                          FStar_TypeChecker_Env.check_uvars =
-                            (env'.FStar_TypeChecker_Env.check_uvars);
-                          FStar_TypeChecker_Env.use_eq_strict =
-                            (env'.FStar_TypeChecker_Env.use_eq_strict);
-                          FStar_TypeChecker_Env.is_iface =
-                            (env'.FStar_TypeChecker_Env.is_iface);
-                          FStar_TypeChecker_Env.admit =
-                            (env'.FStar_TypeChecker_Env.admit);
-                          FStar_TypeChecker_Env.lax = true;
-                          FStar_TypeChecker_Env.lax_universes =
-                            (env'.FStar_TypeChecker_Env.lax_universes);
-                          FStar_TypeChecker_Env.phase1 =
-                            (env'.FStar_TypeChecker_Env.phase1);
-                          FStar_TypeChecker_Env.failhard =
-                            (env'.FStar_TypeChecker_Env.failhard);
-                          FStar_TypeChecker_Env.nosynth =
-                            (env'.FStar_TypeChecker_Env.nosynth);
-                          FStar_TypeChecker_Env.uvar_subtyping =
-                            (env'.FStar_TypeChecker_Env.uvar_subtyping);
-                          FStar_TypeChecker_Env.tc_term =
-                            (env'.FStar_TypeChecker_Env.tc_term);
-                          FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                            (env'.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                          FStar_TypeChecker_Env.universe_of =
-                            (env'.FStar_TypeChecker_Env.universe_of);
-                          FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                            =
-                            (env'.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                          FStar_TypeChecker_Env.teq_nosmt_force =
-                            (env'.FStar_TypeChecker_Env.teq_nosmt_force);
-                          FStar_TypeChecker_Env.subtype_nosmt_force =
-                            (env'.FStar_TypeChecker_Env.subtype_nosmt_force);
-                          FStar_TypeChecker_Env.qtbl_name_and_index =
-                            (env'.FStar_TypeChecker_Env.qtbl_name_and_index);
-                          FStar_TypeChecker_Env.normalized_eff_names =
-                            (env'.FStar_TypeChecker_Env.normalized_eff_names);
-                          FStar_TypeChecker_Env.fv_delta_depths =
-                            (env'.FStar_TypeChecker_Env.fv_delta_depths);
-                          FStar_TypeChecker_Env.proof_ns =
-                            (env'.FStar_TypeChecker_Env.proof_ns);
-                          FStar_TypeChecker_Env.synth_hook =
-                            (env'.FStar_TypeChecker_Env.synth_hook);
-                          FStar_TypeChecker_Env.try_solve_implicits_hook =
-                            (env'.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                          FStar_TypeChecker_Env.splice =
-                            (env'.FStar_TypeChecker_Env.splice);
-                          FStar_TypeChecker_Env.mpreprocess =
-                            (env'.FStar_TypeChecker_Env.mpreprocess);
-                          FStar_TypeChecker_Env.postprocess =
-                            (env'.FStar_TypeChecker_Env.postprocess);
-                          FStar_TypeChecker_Env.identifier_info =
-                            (env'.FStar_TypeChecker_Env.identifier_info);
-                          FStar_TypeChecker_Env.tc_hooks =
-                            (env'.FStar_TypeChecker_Env.tc_hooks);
-                          FStar_TypeChecker_Env.dsenv =
-                            (env'.FStar_TypeChecker_Env.dsenv);
-                          FStar_TypeChecker_Env.nbe =
-                            (env'.FStar_TypeChecker_Env.nbe);
-                          FStar_TypeChecker_Env.strict_args_tab =
-                            (env'.FStar_TypeChecker_Env.strict_args_tab);
-                          FStar_TypeChecker_Env.erasable_types_tab =
-                            (env'.FStar_TypeChecker_Env.erasable_types_tab);
-                          FStar_TypeChecker_Env.enable_defer_to_tac =
-                            (env'.FStar_TypeChecker_Env.enable_defer_to_tac);
-                          FStar_TypeChecker_Env.unif_allow_ref_guards =
-                            (env'.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                          FStar_TypeChecker_Env.erase_erasable_args =
-                            (env'.FStar_TypeChecker_Env.erase_erasable_args);
-                          FStar_TypeChecker_Env.core_check =
-                            (env'.FStar_TypeChecker_Env.core_check)
-                        } in
-                      let uu___4 = tc_term env'1 qt in
-                      (match uu___4 with
-                       | (qt1, uu___5, g) ->
-                           let g0 =
-                             {
-                               FStar_TypeChecker_Common.guard_f =
-                                 FStar_TypeChecker_Common.Trivial;
-                               FStar_TypeChecker_Common.deferred_to_tac =
-                                 (g.FStar_TypeChecker_Common.deferred_to_tac);
-                               FStar_TypeChecker_Common.deferred =
-                                 (g.FStar_TypeChecker_Common.deferred);
-                               FStar_TypeChecker_Common.univ_ineqs =
-                                 (g.FStar_TypeChecker_Common.univ_ineqs);
-                               FStar_TypeChecker_Common.implicits =
-                                 (g.FStar_TypeChecker_Common.implicits)
-                             } in
-                           let g01 =
-                             FStar_TypeChecker_Rel.resolve_implicits env'1 g0 in
-                           let t =
-                             FStar_Syntax_Syntax.mk
-                               (FStar_Syntax_Syntax.Tm_quoted (qt1, qi))
-                               top.FStar_Syntax_Syntax.pos in
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_TypeChecker_Common.lcomp_of_comp c in
-                               FStar_Pervasives.Inr uu___8 in
-                             value_check_expected_typ env1 t uu___7
-                               FStar_TypeChecker_Env.trivial_guard in
-                           (match uu___6 with
-                            | (t1, lc, g1) ->
-                                let t2 =
-                                  FStar_Syntax_Syntax.mk
-                                    (FStar_Syntax_Syntax.Tm_meta
-                                       (t1,
-                                         (FStar_Syntax_Syntax.Meta_monadic_lift
-                                            (FStar_Parser_Const.effect_PURE_lid,
-                                              FStar_Parser_Const.effect_TAC_lid,
-                                              FStar_Syntax_Syntax.t_term))))
-                                    t1.FStar_Syntax_Syntax.pos in
-                                let uu___7 =
-                                  FStar_TypeChecker_Env.conj_guard g01 g1 in
-                                (t2, lc, uu___7)))))
-        | FStar_Syntax_Syntax.Tm_lazy
-            { FStar_Syntax_Syntax.blob = uu___2;
-              FStar_Syntax_Syntax.lkind = FStar_Syntax_Syntax.Lazy_embedding
-                uu___3;
-              FStar_Syntax_Syntax.ltyp = uu___4;
-              FStar_Syntax_Syntax.rng = uu___5;_}
-            ->
-            let uu___6 = FStar_Syntax_Util.unlazy top in tc_term env1 uu___6
-        | FStar_Syntax_Syntax.Tm_lazy i ->
-            value_check_expected_typ env1 top
-              (FStar_Pervasives.Inl (i.FStar_Syntax_Syntax.ltyp))
-              FStar_TypeChecker_Env.trivial_guard
-        | FStar_Syntax_Syntax.Tm_meta
-            (e1, FStar_Syntax_Syntax.Meta_desugared
-             (FStar_Syntax_Syntax.Meta_smt_pat))
-            ->
-            let uu___2 = tc_tot_or_gtot_term env1 e1 in
-            (match uu___2 with
-             | (e2, c, g) ->
-                 let g1 =
-                   {
-                     FStar_TypeChecker_Common.guard_f =
-                       FStar_TypeChecker_Common.Trivial;
-                     FStar_TypeChecker_Common.deferred_to_tac =
-                       (g.FStar_TypeChecker_Common.deferred_to_tac);
-                     FStar_TypeChecker_Common.deferred =
-                       (g.FStar_TypeChecker_Common.deferred);
-                     FStar_TypeChecker_Common.univ_ineqs =
-                       (g.FStar_TypeChecker_Common.univ_ineqs);
-                     FStar_TypeChecker_Common.implicits =
-                       (g.FStar_TypeChecker_Common.implicits)
-                   } in
-                 let uu___3 =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_meta
-                        (e2,
-                          (FStar_Syntax_Syntax.Meta_desugared
-                             FStar_Syntax_Syntax.Meta_smt_pat)))
-                     top.FStar_Syntax_Syntax.pos in
-                 (uu___3, c, g1))
-        | FStar_Syntax_Syntax.Tm_meta
-            (e1, FStar_Syntax_Syntax.Meta_pattern (names, pats)) ->
-            let uu___2 = FStar_Syntax_Util.type_u () in
-            (match uu___2 with
-             | (t, u) ->
-                 let uu___3 = tc_check_tot_or_gtot_term env1 e1 t "" in
-                 (match uu___3 with
-                  | (e2, c, g) ->
-                      let uu___4 =
-                        let uu___5 =
-                          FStar_TypeChecker_Env.clear_expected_typ env1 in
-                        match uu___5 with
-                        | (env2, uu___6) -> tc_smt_pats env2 pats in
-                      (match uu___4 with
-                       | (pats1, g') ->
-                           let g'1 =
-                             {
-                               FStar_TypeChecker_Common.guard_f =
-                                 FStar_TypeChecker_Common.Trivial;
-                               FStar_TypeChecker_Common.deferred_to_tac =
-                                 (g'.FStar_TypeChecker_Common.deferred_to_tac);
-                               FStar_TypeChecker_Common.deferred =
-                                 (g'.FStar_TypeChecker_Common.deferred);
-                               FStar_TypeChecker_Common.univ_ineqs =
-                                 (g'.FStar_TypeChecker_Common.univ_ineqs);
-                               FStar_TypeChecker_Common.implicits =
-                                 (g'.FStar_TypeChecker_Common.implicits)
-                             } in
-                           let uu___5 =
-                             FStar_Syntax_Syntax.mk
-                               (FStar_Syntax_Syntax.Tm_meta
-                                  (e2,
-                                    (FStar_Syntax_Syntax.Meta_pattern
-                                       (names, pats1))))
-                               top.FStar_Syntax_Syntax.pos in
-                           let uu___6 =
-                             FStar_TypeChecker_Env.conj_guard g g'1 in
-                           (uu___5, c, uu___6))))
-        | FStar_Syntax_Syntax.Tm_meta
-            (e1, FStar_Syntax_Syntax.Meta_desugared
-             (FStar_Syntax_Syntax.Sequence))
-            ->
-            let uu___2 = tc_term env1 e1 in
-            (match uu___2 with
-             | (e2, c, g) ->
-                 let e3 =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_meta
-                        (e2,
-                          (FStar_Syntax_Syntax.Meta_desugared
-                             FStar_Syntax_Syntax.Sequence)))
-                     top.FStar_Syntax_Syntax.pos in
-                 (e3, c, g))
-        | FStar_Syntax_Syntax.Tm_meta
-            (e1, FStar_Syntax_Syntax.Meta_monadic uu___2) -> tc_term env1 e1
-        | FStar_Syntax_Syntax.Tm_meta
-            (e1, FStar_Syntax_Syntax.Meta_monadic_lift uu___2) ->
-            tc_term env1 e1
-        | FStar_Syntax_Syntax.Tm_meta (e1, m) ->
-            let uu___2 = tc_term env1 e1 in
-            (match uu___2 with
-             | (e2, c, g) ->
-                 let e3 =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_meta (e2, m))
-                     top.FStar_Syntax_Syntax.pos in
-                 (e3, c, g))
-        | FStar_Syntax_Syntax.Tm_ascribed
-            (e1, (asc, FStar_Pervasives_Native.Some tac, use_eq), labopt) ->
-            let uu___2 =
-              tc_tactic FStar_Syntax_Syntax.t_unit FStar_Syntax_Syntax.t_unit
-                env1 tac in
-            (match uu___2 with
-             | (tac1, uu___3, g_tac) ->
-                 let t' =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_ascribed
-                        (e1, (asc, FStar_Pervasives_Native.None, use_eq),
-                          labopt)) top.FStar_Syntax_Syntax.pos in
-                 let uu___4 = tc_term env1 t' in
-                 (match uu___4 with
-                  | (t'1, c, g) ->
-                      let t'2 =
-                        let uu___5 =
-                          let uu___6 = FStar_Syntax_Subst.compress t'1 in
-                          uu___6.FStar_Syntax_Syntax.n in
-                        match uu___5 with
-                        | FStar_Syntax_Syntax.Tm_ascribed
-                            (e2,
-                             (asc1, FStar_Pervasives_Native.None, _use_eq),
-                             labopt1)
-                            ->
-                            FStar_Syntax_Syntax.mk
-                              (FStar_Syntax_Syntax.Tm_ascribed
-                                 (e2,
-                                   (asc1,
-                                     (FStar_Pervasives_Native.Some tac1),
-                                     use_eq), labopt1))
-                              t'1.FStar_Syntax_Syntax.pos
-                        | uu___6 -> failwith "impossible" in
-                      let g1 =
-                        wrap_guard_with_tactic_opt
-                          (FStar_Pervasives_Native.Some tac1) g in
-                      let uu___5 = FStar_TypeChecker_Env.conj_guard g1 g_tac in
-                      (t'2, c, uu___5)))
-        | FStar_Syntax_Syntax.Tm_ascribed
-            (uu___2,
-             (FStar_Pervasives.Inr expected_c, FStar_Pervasives_Native.None,
-              use_eq),
-             uu___3)
-            when
-            let uu___4 =
-              FStar_Compiler_Effect.op_Bar_Greater top
-                is_comp_ascribed_reflect in
-            FStar_Compiler_Effect.op_Bar_Greater uu___4
-              FStar_Compiler_Util.is_some
-            ->
-            let uu___4 =
-              let uu___5 =
-                FStar_Compiler_Effect.op_Bar_Greater top
-                  is_comp_ascribed_reflect in
-              FStar_Compiler_Effect.op_Bar_Greater uu___5
-                FStar_Compiler_Util.must in
-            (match uu___4 with
-             | (effect_lid, e1, aqual) ->
-                 let uu___5 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-                 (match uu___5 with
-                  | (env0, uu___6) ->
-                      let uu___7 = tc_comp env0 expected_c in
-                      (match uu___7 with
-                       | (expected_c1, uu___8, g_c) ->
-                           let expected_ct =
-                             FStar_TypeChecker_Env.unfold_effect_abbrev env0
-                               expected_c1 in
-                           ((let uu___10 =
-                               let uu___11 =
-                                 FStar_Ident.lid_equals effect_lid
-                                   expected_ct.FStar_Syntax_Syntax.effect_name in
-                               Prims.op_Negation uu___11 in
-                             if uu___10
-                             then
-                               let uu___11 =
-                                 let uu___12 =
-                                   let uu___13 =
-                                     FStar_Ident.string_of_lid effect_lid in
-                                   let uu___14 =
-                                     FStar_Ident.string_of_lid
-                                       expected_ct.FStar_Syntax_Syntax.effect_name in
-                                   FStar_Compiler_Util.format2
-                                     "The effect on reflect %s does not match with the annotation %s\n"
-                                     uu___13 uu___14 in
-                                 (FStar_Errors.Fatal_UnexpectedEffect,
-                                   uu___12) in
-                               FStar_Errors.raise_error uu___11
-                                 top.FStar_Syntax_Syntax.pos
-                             else ());
-                            (let uu___11 =
-                               let uu___12 =
-                                 FStar_TypeChecker_Env.is_user_reflectable_effect
-                                   env1 effect_lid in
-                               Prims.op_Negation uu___12 in
-                             if uu___11
-                             then
-                               let uu___12 =
-                                 let uu___13 =
-                                   let uu___14 =
-                                     FStar_Ident.string_of_lid effect_lid in
-                                   FStar_Compiler_Util.format1
-                                     "Effect %s cannot be reflected" uu___14 in
-                                 (FStar_Errors.Fatal_EffectCannotBeReified,
-                                   uu___13) in
-                               FStar_Errors.raise_error uu___12
-                                 top.FStar_Syntax_Syntax.pos
-                             else ());
-                            (let u_c =
-                               FStar_Compiler_Effect.op_Bar_Greater
-                                 expected_ct.FStar_Syntax_Syntax.comp_univs
-                                 FStar_Compiler_List.hd in
-                             let repr =
-                               let uu___11 =
-                                 let uu___12 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     expected_ct FStar_Syntax_Syntax.mk_Comp in
-                                 FStar_TypeChecker_Env.effect_repr env0
-                                   uu___12 u_c in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___11
-                                 FStar_Compiler_Util.must in
-                             let e2 =
-                               let uu___11 =
-                                 let uu___12 =
-                                   let uu___13 =
-                                     let uu___14 =
-                                       let uu___15 =
-                                         FStar_Syntax_Syntax.mk_Total repr in
-                                       FStar_Pervasives.Inr uu___15 in
-                                     (uu___14, FStar_Pervasives_Native.None,
-                                       use_eq) in
-                                   (e1, uu___13,
-                                     FStar_Pervasives_Native.None) in
-                                 FStar_Syntax_Syntax.Tm_ascribed uu___12 in
-                               FStar_Syntax_Syntax.mk uu___11
-                                 e1.FStar_Syntax_Syntax.pos in
-                             (let uu___12 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env0)
-                                  FStar_Options.Extreme in
-                              if uu___12
-                              then
-                                let uu___13 =
-                                  FStar_Syntax_Print.term_to_string e2 in
-                                FStar_Compiler_Util.print1
-                                  "Typechecking ascribed reflect, inner ascribed term: %s\n"
-                                  uu___13
-                              else ());
-                             (let uu___12 = tc_tot_or_gtot_term env0 e2 in
-                              match uu___12 with
-                              | (e3, uu___13, g_e) ->
-                                  let e4 = FStar_Syntax_Util.unascribe e3 in
-                                  ((let uu___15 =
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        (FStar_TypeChecker_Env.debug env0)
-                                        FStar_Options.Extreme in
-                                    if uu___15
-                                    then
-                                      let uu___16 =
-                                        FStar_Syntax_Print.term_to_string e4 in
-                                      let uu___17 =
-                                        FStar_TypeChecker_Rel.guard_to_string
-                                          env0 g_e in
-                                      FStar_Compiler_Util.print2
-                                        "Typechecking ascribed reflect, after typechecking inner ascribed term: %s and guard: %s\n"
-                                        uu___16 uu___17
-                                    else ());
-                                   (let top1 =
-                                      let r = top.FStar_Syntax_Syntax.pos in
-                                      let tm =
-                                        FStar_Syntax_Syntax.mk
-                                          (FStar_Syntax_Syntax.Tm_constant
-                                             (FStar_Const.Const_reflect
-                                                effect_lid)) r in
-                                      let tm1 =
-                                        FStar_Syntax_Syntax.mk
-                                          (FStar_Syntax_Syntax.Tm_app
-                                             (tm, [(e4, aqual)])) r in
-                                      let uu___15 =
-                                        let uu___16 =
-                                          let uu___17 =
-                                            let uu___18 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                expected_c1
-                                                FStar_Syntax_Util.comp_effect_name in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___18
-                                              (fun uu___19 ->
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___19) in
-                                          (tm1,
-                                            ((FStar_Pervasives.Inr
-                                                expected_c1),
-                                              FStar_Pervasives_Native.None,
-                                              use_eq), uu___17) in
-                                        FStar_Syntax_Syntax.Tm_ascribed
-                                          uu___16 in
-                                      FStar_Syntax_Syntax.mk uu___15 r in
-                                    let uu___15 =
-                                      let uu___16 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          expected_c1
-                                          FStar_TypeChecker_Common.lcomp_of_comp in
-                                      comp_check_expected_typ env1 top1
-                                        uu___16 in
-                                    match uu___15 with
-                                    | (top2, c, g_env) ->
-                                        let uu___16 =
-                                          FStar_TypeChecker_Env.conj_guards
-                                            [g_c; g_e; g_env] in
-                                        (top2, c, uu___16)))))))))
-        | FStar_Syntax_Syntax.Tm_ascribed
-            (e1,
-             (FStar_Pervasives.Inr expected_c, FStar_Pervasives_Native.None,
-              use_eq),
-             uu___2)
-            ->
-            let uu___3 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-            (match uu___3 with
-             | (env0, uu___4) ->
-                 let uu___5 = tc_comp env0 expected_c in
-                 (match uu___5 with
-                  | (expected_c1, uu___6, g) ->
-                      let uu___7 =
-                        let uu___8 =
-                          FStar_Compiler_Effect.op_Bar_Greater
-                            (FStar_Syntax_Util.comp_result expected_c1)
-                            (fun t ->
-                               FStar_TypeChecker_Env.set_expected_typ_maybe_eq
-                                 env0 t use_eq) in
-                        tc_term uu___8 e1 in
-                      (match uu___7 with
-                       | (e2, c', g') ->
-                           let uu___8 =
-                             let uu___9 =
-                               FStar_TypeChecker_Common.lcomp_comp c' in
-                             match uu___9 with
-                             | (c'1, g_c') ->
-                                 let uu___10 =
-                                   check_expected_effect env0 use_eq
-                                     (FStar_Pervasives_Native.Some
-                                        expected_c1) (e2, c'1) in
-                                 (match uu___10 with
-                                  | (e3, expected_c2, g'') ->
-                                      let uu___11 =
-                                        FStar_TypeChecker_Env.conj_guard g_c'
-                                          g'' in
-                                      (e3, expected_c2, uu___11)) in
-                           (match uu___8 with
-                            | (e3, expected_c2, g'') ->
-                                let e4 =
-                                  FStar_Syntax_Syntax.mk
-                                    (FStar_Syntax_Syntax.Tm_ascribed
-                                       (e3,
-                                         ((FStar_Pervasives.Inr expected_c2),
-                                           FStar_Pervasives_Native.None,
-                                           use_eq),
-                                         (FStar_Pervasives_Native.Some
-                                            (FStar_Syntax_Util.comp_effect_name
-                                               expected_c2))))
-                                    top.FStar_Syntax_Syntax.pos in
-                                let lc =
-                                  FStar_TypeChecker_Common.lcomp_of_comp
-                                    expected_c2 in
-                                let f =
-                                  let uu___9 =
-                                    FStar_TypeChecker_Env.conj_guard g' g'' in
-                                  FStar_TypeChecker_Env.conj_guard g uu___9 in
-                                let uu___9 =
-                                  comp_check_expected_typ env1 e4 lc in
-                                (match uu___9 with
-                                 | (e5, c, f2) ->
-                                     let uu___10 =
-                                       FStar_TypeChecker_Env.conj_guard f f2 in
-                                     (e5, c, uu___10))))))
-        | FStar_Syntax_Syntax.Tm_ascribed
-            (e1,
-             (FStar_Pervasives.Inl t, FStar_Pervasives_Native.None, use_eq),
-             uu___2)
-            ->
-            let uu___3 = FStar_Syntax_Util.type_u () in
-            (match uu___3 with
-             | (k, u) ->
-                 let uu___4 = tc_check_tot_or_gtot_term env1 t k "" in
-                 (match uu___4 with
-                  | (t1, uu___5, f) ->
-                      let uu___6 =
-                        let uu___7 =
-                          FStar_TypeChecker_Env.set_expected_typ_maybe_eq
-                            env1 t1 use_eq in
-                        tc_term uu___7 e1 in
-                      (match uu___6 with
-                       | (e2, c, g) ->
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_TypeChecker_Env.set_range env1
-                                 t1.FStar_Syntax_Syntax.pos in
-                             FStar_TypeChecker_Util.strengthen_precondition
-                               (FStar_Pervasives_Native.Some
-                                  (fun uu___9 ->
-                                     FStar_Compiler_Util.return_all
-                                       FStar_TypeChecker_Err.ill_kinded_type))
-                               uu___8 e2 c f in
-                           (match uu___7 with
-                            | (c1, f1) ->
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Syntax_Syntax.mk
-                                      (FStar_Syntax_Syntax.Tm_ascribed
-                                         (e2,
-                                           ((FStar_Pervasives.Inl t1),
-                                             FStar_Pervasives_Native.None,
-                                             use_eq),
-                                           (FStar_Pervasives_Native.Some
-                                              (c1.FStar_TypeChecker_Common.eff_name))))
-                                      top.FStar_Syntax_Syntax.pos in
-                                  comp_check_expected_typ env1 uu___9 c1 in
-                                (match uu___8 with
-                                 | (e3, c2, f2) ->
-                                     let uu___9 =
-                                       let uu___10 =
-                                         FStar_TypeChecker_Env.conj_guard g
-                                           f2 in
-                                       FStar_TypeChecker_Env.conj_guard f1
-                                         uu___10 in
-                                     (e3, c2, uu___9))))))
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_range_of);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             a::hd::rest)
-            ->
-            let rest1 = hd :: rest in
-            let uu___5 = FStar_Syntax_Util.head_and_args top in
-            (match uu___5 with
-             | (unary_op, uu___6) ->
-                 let head =
-                   let uu___7 =
-                     FStar_Compiler_Range.union_ranges
-                       unary_op.FStar_Syntax_Syntax.pos
-                       (FStar_Pervasives_Native.fst a).FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (unary_op, [a])) uu___7 in
-                 let t =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (head, rest1))
-                     top.FStar_Syntax_Syntax.pos in
-                 tc_term env1 t)
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_reify);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             a::hd::rest)
-            ->
-            let rest1 = hd :: rest in
-            let uu___5 = FStar_Syntax_Util.head_and_args top in
-            (match uu___5 with
-             | (unary_op, uu___6) ->
-                 let head =
-                   let uu___7 =
-                     FStar_Compiler_Range.union_ranges
-                       unary_op.FStar_Syntax_Syntax.pos
-                       (FStar_Pervasives_Native.fst a).FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (unary_op, [a])) uu___7 in
-                 let t =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (head, rest1))
-                     top.FStar_Syntax_Syntax.pos in
-                 tc_term env1 t)
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_reflect uu___2);
-               FStar_Syntax_Syntax.pos = uu___3;
-               FStar_Syntax_Syntax.vars = uu___4;
-               FStar_Syntax_Syntax.hash_code = uu___5;_},
-             a::hd::rest)
-            ->
-            let rest1 = hd :: rest in
-            let uu___6 = FStar_Syntax_Util.head_and_args top in
-            (match uu___6 with
-             | (unary_op, uu___7) ->
-                 let head =
-                   let uu___8 =
-                     FStar_Compiler_Range.union_ranges
-                       unary_op.FStar_Syntax_Syntax.pos
-                       (FStar_Pervasives_Native.fst a).FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (unary_op, [a])) uu___8 in
-                 let t =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (head, rest1))
-                     top.FStar_Syntax_Syntax.pos in
-                 tc_term env1 t)
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_set_range_of);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             a1::a2::hd::rest)
-            ->
-            let rest1 = hd :: rest in
-            let uu___5 = FStar_Syntax_Util.head_and_args top in
-            (match uu___5 with
-             | (unary_op, uu___6) ->
-                 let head =
-                   let uu___7 =
-                     FStar_Compiler_Range.union_ranges
-                       unary_op.FStar_Syntax_Syntax.pos
-                       (FStar_Pervasives_Native.fst a1).FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (unary_op, [a1; a2])) uu___7 in
-                 let t =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (head, rest1))
-                     top.FStar_Syntax_Syntax.pos in
-                 tc_term env1 t)
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_range_of);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             (e1, FStar_Pervasives_Native.None)::[])
-            ->
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-                FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.fst
-                  uu___7 in
-              tc_term uu___6 e1 in
-            (match uu___5 with
-             | (e2, c, g) ->
-                 let uu___6 = FStar_Syntax_Util.head_and_args top in
-                 (match uu___6 with
-                  | (head, uu___7) ->
-                      let uu___8 =
-                        FStar_Syntax_Syntax.mk
-                          (FStar_Syntax_Syntax.Tm_app
-                             (head, [(e2, FStar_Pervasives_Native.None)]))
-                          top.FStar_Syntax_Syntax.pos in
-                      let uu___9 =
-                        let uu___10 =
-                          let uu___11 =
-                            FStar_Syntax_Syntax.tabbrev
-                              FStar_Parser_Const.range_lid in
-                          FStar_Syntax_Syntax.mk_Total uu___11 in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          FStar_TypeChecker_Common.lcomp_of_comp uu___10 in
-                      (uu___8, uu___9, g)))
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_set_range_of);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             (t, FStar_Pervasives_Native.None)::(r,
-                                                 FStar_Pervasives_Native.None)::[])
-            ->
-            let uu___5 = FStar_Syntax_Util.head_and_args top in
-            (match uu___5 with
-             | (head, uu___6) ->
-                 let env' =
-                   let uu___7 =
-                     FStar_Syntax_Syntax.tabbrev FStar_Parser_Const.range_lid in
-                   FStar_TypeChecker_Env.set_expected_typ env1 uu___7 in
-                 let uu___7 = tc_term env' r in
-                 (match uu___7 with
-                  | (er, uu___8, gr) ->
-                      let uu___9 = tc_term env1 t in
-                      (match uu___9 with
-                       | (t1, tt, gt) ->
-                           let g = FStar_TypeChecker_Env.conj_guard gr gt in
-                           let uu___10 =
-                             let uu___11 =
-                               let uu___12 = FStar_Syntax_Syntax.as_arg t1 in
-                               let uu___13 =
-                                 let uu___14 = FStar_Syntax_Syntax.as_arg r in
-                                 [uu___14] in
-                               uu___12 :: uu___13 in
-                             FStar_Syntax_Syntax.mk_Tm_app head uu___11
-                               top.FStar_Syntax_Syntax.pos in
-                           (uu___10, tt, g))))
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_range_of);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             uu___5)
-            ->
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = FStar_Syntax_Print.term_to_string top in
-                FStar_Compiler_Util.format1 "Ill-applied constant %s" uu___8 in
-              (FStar_Errors.Fatal_IllAppliedConstant, uu___7) in
-            FStar_Errors.raise_error uu___6 e.FStar_Syntax_Syntax.pos
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_set_range_of);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             uu___5)
-            ->
-            let uu___6 =
-              let uu___7 =
-                let uu___8 = FStar_Syntax_Print.term_to_string top in
-                FStar_Compiler_Util.format1 "Ill-applied constant %s" uu___8 in
-              (FStar_Errors.Fatal_IllAppliedConstant, uu___7) in
-            FStar_Errors.raise_error uu___6 e.FStar_Syntax_Syntax.pos
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_reify);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             (e1, aqual)::[])
-            ->
-            (if FStar_Compiler_Option.isSome aqual
-             then
-               FStar_Errors.log_issue e1.FStar_Syntax_Syntax.pos
-                 (FStar_Errors.Warning_IrrelevantQualifierOnArgumentToReify,
-                   "Qualifier on argument to reify is irrelevant and will be ignored")
-             else ();
-             (let uu___6 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-              match uu___6 with
-              | (env0, uu___7) ->
-                  let uu___8 = tc_term env0 e1 in
-                  (match uu___8 with
-                   | (e2, c, g) ->
-                       let uu___9 = FStar_Syntax_Util.head_and_args top in
-                       (match uu___9 with
-                        | (reify_op, uu___10) ->
-                            let uu___11 =
-                              let uu___12 =
-                                FStar_TypeChecker_Common.lcomp_comp c in
-                              match uu___12 with
-                              | (c1, g_c) ->
-                                  let uu___13 =
-                                    FStar_TypeChecker_Env.unfold_effect_abbrev
-                                      env1 c1 in
-                                  (uu___13, g_c) in
-                            (match uu___11 with
-                             | (c1, g_c) ->
-                                 ((let uu___13 =
-                                     let uu___14 =
-                                       FStar_TypeChecker_Env.is_user_reifiable_effect
-                                         env1
-                                         c1.FStar_Syntax_Syntax.effect_name in
-                                     Prims.op_Negation uu___14 in
-                                   if uu___13
-                                   then
-                                     let uu___14 =
-                                       let uu___15 =
-                                         let uu___16 =
-                                           FStar_Ident.string_of_lid
-                                             c1.FStar_Syntax_Syntax.effect_name in
-                                         FStar_Compiler_Util.format1
-                                           "Effect %s cannot be reified"
-                                           uu___16 in
-                                       (FStar_Errors.Fatal_EffectCannotBeReified,
-                                         uu___15) in
-                                     FStar_Errors.raise_error uu___14
-                                       e2.FStar_Syntax_Syntax.pos
-                                   else ());
-                                  (let u_c =
-                                     FStar_Compiler_List.hd
-                                       c1.FStar_Syntax_Syntax.comp_univs in
-                                   let e3 =
-                                     let uu___13 =
-                                       (FStar_TypeChecker_Env.is_layered_effect
-                                          env1
-                                          c1.FStar_Syntax_Syntax.effect_name)
-                                         &&
-                                         (Prims.op_Negation
-                                            env1.FStar_TypeChecker_Env.phase1) in
-                                     if uu___13
-                                     then
-                                       let reify_val_tm =
-                                         let uu___14 =
-                                           let uu___15 =
-                                             FStar_Parser_Const.layered_effect_reify_val_lid
-                                               c1.FStar_Syntax_Syntax.effect_name
-                                               e2.FStar_Syntax_Syntax.pos in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___15
-                                             FStar_Syntax_Syntax.tconst in
-                                         FStar_Syntax_Syntax.mk_Tm_uinst
-                                           uu___14 [u_c] in
-                                       let thunked_e =
-                                         let uu___14 =
-                                           let uu___15 =
-                                             let uu___16 =
-                                               let uu___17 =
-                                                 let uu___18 =
-                                                   FStar_Syntax_Syntax.null_bv
-                                                     FStar_Syntax_Syntax.t_unit in
-                                                 FStar_Syntax_Syntax.mk_binder
-                                                   uu___18 in
-                                               [uu___17] in
-                                             (uu___16, e2,
-                                               (FStar_Pervasives_Native.Some
-                                                  {
-                                                    FStar_Syntax_Syntax.residual_effect
-                                                      =
-                                                      (c1.FStar_Syntax_Syntax.effect_name);
-                                                    FStar_Syntax_Syntax.residual_typ
-                                                      =
-                                                      FStar_Pervasives_Native.None;
-                                                    FStar_Syntax_Syntax.residual_flags
-                                                      = []
-                                                  })) in
-                                           FStar_Syntax_Syntax.Tm_abs uu___15 in
-                                         FStar_Syntax_Syntax.mk uu___14
-                                           e2.FStar_Syntax_Syntax.pos in
-                                       let implicit_args =
-                                         let a_arg =
-                                           FStar_Syntax_Syntax.iarg
-                                             c1.FStar_Syntax_Syntax.result_typ in
-                                         let indices_args =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             c1.FStar_Syntax_Syntax.effect_args
-                                             (FStar_Compiler_List.map
-                                                (fun uu___14 ->
-                                                   match uu___14 with
-                                                   | (t, uu___15) ->
-                                                       FStar_Syntax_Syntax.iarg
-                                                         t)) in
-                                         a_arg :: indices_args in
-                                       let uu___14 =
-                                         let uu___15 =
-                                           let uu___16 =
-                                             FStar_Syntax_Syntax.as_arg
-                                               thunked_e in
-                                           [uu___16] in
-                                         FStar_Compiler_List.op_At
-                                           implicit_args uu___15 in
-                                       FStar_Syntax_Syntax.mk_Tm_app
-                                         reify_val_tm uu___14
-                                         e2.FStar_Syntax_Syntax.pos
-                                     else
-                                       FStar_Syntax_Syntax.mk
-                                         (FStar_Syntax_Syntax.Tm_app
-                                            (reify_op, [(e2, aqual)]))
-                                         top.FStar_Syntax_Syntax.pos in
-                                   let repr =
-                                     let uu___13 =
-                                       FStar_Syntax_Syntax.mk_Comp c1 in
-                                     FStar_TypeChecker_Env.reify_comp env1
-                                       uu___13 u_c in
-                                   let c2 =
-                                     let uu___13 =
-                                       FStar_TypeChecker_Env.is_total_effect
-                                         env1
-                                         c1.FStar_Syntax_Syntax.effect_name in
-                                     if uu___13
-                                     then
-                                       let uu___14 =
-                                         FStar_Syntax_Syntax.mk_Total repr in
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         uu___14
-                                         FStar_TypeChecker_Common.lcomp_of_comp
-                                     else
-                                       (let ct =
-                                          {
-                                            FStar_Syntax_Syntax.comp_univs =
-                                              [u_c];
-                                            FStar_Syntax_Syntax.effect_name =
-                                              FStar_Parser_Const.effect_Dv_lid;
-                                            FStar_Syntax_Syntax.result_typ =
-                                              repr;
-                                            FStar_Syntax_Syntax.effect_args =
-                                              [];
-                                            FStar_Syntax_Syntax.flags = []
-                                          } in
-                                        let uu___15 =
-                                          FStar_Syntax_Syntax.mk_Comp ct in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___15
-                                          FStar_TypeChecker_Common.lcomp_of_comp) in
-                                   let uu___13 =
-                                     comp_check_expected_typ env1 e3 c2 in
-                                   match uu___13 with
-                                   | (e4, c3, g') ->
-                                       let uu___14 =
-                                         let uu___15 =
-                                           FStar_TypeChecker_Env.conj_guard
-                                             g_c g' in
-                                         FStar_TypeChecker_Env.conj_guard g
-                                           uu___15 in
-                                       (e4, c3, uu___14))))))))
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_reflect l);
-               FStar_Syntax_Syntax.pos = uu___2;
-               FStar_Syntax_Syntax.vars = uu___3;
-               FStar_Syntax_Syntax.hash_code = uu___4;_},
-             (e1, aqual)::[])
-            ->
-            (if FStar_Compiler_Option.isSome aqual
-             then
-               FStar_Errors.log_issue e1.FStar_Syntax_Syntax.pos
-                 (FStar_Errors.Warning_IrrelevantQualifierOnArgumentToReflect,
-                   "Qualifier on argument to reflect is irrelevant and will be ignored")
-             else ();
-             (let uu___7 =
-                let uu___8 =
-                  FStar_TypeChecker_Env.is_user_reflectable_effect env1 l in
-                Prims.op_Negation uu___8 in
-              if uu___7
-              then
-                let uu___8 =
-                  let uu___9 =
-                    let uu___10 = FStar_Ident.string_of_lid l in
-                    FStar_Compiler_Util.format1
-                      "Effect %s cannot be reflected" uu___10 in
-                  (FStar_Errors.Fatal_EffectCannotBeReified, uu___9) in
-                FStar_Errors.raise_error uu___8 e1.FStar_Syntax_Syntax.pos
-              else ());
-             (let uu___7 = FStar_Syntax_Util.head_and_args top in
-              match uu___7 with
-              | (reflect_op, uu___8) ->
-                  let uu___9 = FStar_TypeChecker_Env.effect_decl_opt env1 l in
-                  (match uu___9 with
-                   | FStar_Pervasives_Native.None ->
-                       let uu___10 =
-                         let uu___11 =
-                           let uu___12 = FStar_Ident.string_of_lid l in
-                           FStar_Compiler_Util.format1
-                             "Effect %s not found (for reflect)" uu___12 in
-                         (FStar_Errors.Fatal_EffectNotFound, uu___11) in
-                       FStar_Errors.raise_error uu___10
-                         e1.FStar_Syntax_Syntax.pos
-                   | FStar_Pervasives_Native.Some (ed, qualifiers) ->
-                       let uu___10 =
-                         FStar_TypeChecker_Env.clear_expected_typ env1 in
-                       (match uu___10 with
-                        | (env_no_ex, uu___11) ->
-                            let uu___12 =
-                              let uu___13 = tc_tot_or_gtot_term env_no_ex e1 in
-                              match uu___13 with
-                              | (e2, c, g) ->
-                                  ((let uu___15 =
-                                      let uu___16 =
-                                        FStar_TypeChecker_Common.is_total_lcomp
-                                          c in
-                                      FStar_Compiler_Effect.op_Less_Bar
-                                        Prims.op_Negation uu___16 in
-                                    if uu___15
-                                    then
-                                      FStar_Errors.log_issue
-                                        e2.FStar_Syntax_Syntax.pos
-                                        (FStar_Errors.Error_UnexpectedGTotComputation,
-                                          "Expected Tot, got a GTot computation")
-                                    else ());
-                                   (e2, c, g)) in
-                            (match uu___12 with
-                             | (e2, c_e, g_e) ->
-                                 let uu___13 =
-                                   let uu___14 = FStar_Syntax_Util.type_u () in
-                                   match uu___14 with
-                                   | (a, u_a) ->
-                                       let uu___15 =
-                                         FStar_TypeChecker_Util.new_implicit_var
-                                           "tc_term reflect"
-                                           e2.FStar_Syntax_Syntax.pos
-                                           env_no_ex a in
-                                       (match uu___15 with
-                                        | (a_uvar, uu___16, g_a) ->
-                                            let uu___17 =
-                                              FStar_TypeChecker_Util.fresh_effect_repr_en
-                                                env_no_ex
-                                                e2.FStar_Syntax_Syntax.pos l
-                                                u_a a_uvar in
-                                            (uu___17, u_a, a_uvar, g_a)) in
-                                 (match uu___13 with
-                                  | ((expected_repr_typ, g_repr), u_a, a,
-                                     g_a) ->
-                                      let g_eq =
-                                        FStar_TypeChecker_Rel.teq env_no_ex
-                                          c_e.FStar_TypeChecker_Common.res_typ
-                                          expected_repr_typ in
-                                      let eff_args =
-                                        let uu___14 =
-                                          let uu___15 =
-                                            FStar_Syntax_Subst.compress
-                                              expected_repr_typ in
-                                          uu___15.FStar_Syntax_Syntax.n in
-                                        match uu___14 with
-                                        | FStar_Syntax_Syntax.Tm_app
-                                            (uu___15, uu___16::args) -> args
-                                        | uu___15 ->
-                                            let uu___16 =
-                                              let uu___17 =
-                                                let uu___18 =
-                                                  FStar_Ident.string_of_lid l in
-                                                let uu___19 =
-                                                  FStar_Syntax_Print.tag_of_term
-                                                    expected_repr_typ in
-                                                let uu___20 =
-                                                  FStar_Syntax_Print.term_to_string
-                                                    expected_repr_typ in
-                                                FStar_Compiler_Util.format3
-                                                  "Expected repr type for %s is not an application node (%s:%s)"
-                                                  uu___18 uu___19 uu___20 in
-                                              (FStar_Errors.Fatal_UnexpectedEffect,
-                                                uu___17) in
-                                            FStar_Errors.raise_error uu___16
-                                              top.FStar_Syntax_Syntax.pos in
-                                      let c =
-                                        let uu___14 =
-                                          FStar_Syntax_Syntax.mk_Comp
-                                            {
-                                              FStar_Syntax_Syntax.comp_univs
-                                                = [u_a];
-                                              FStar_Syntax_Syntax.effect_name
-                                                =
-                                                (ed.FStar_Syntax_Syntax.mname);
-                                              FStar_Syntax_Syntax.result_typ
-                                                = a;
-                                              FStar_Syntax_Syntax.effect_args
-                                                = eff_args;
-                                              FStar_Syntax_Syntax.flags = []
-                                            } in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___14
-                                          FStar_TypeChecker_Common.lcomp_of_comp in
-                                      let e3 =
-                                        FStar_Syntax_Syntax.mk
-                                          (FStar_Syntax_Syntax.Tm_app
-                                             (reflect_op, [(e2, aqual)]))
-                                          top.FStar_Syntax_Syntax.pos in
-                                      let uu___14 =
-                                        comp_check_expected_typ env1 e3 c in
-                                      (match uu___14 with
-                                       | (e4, c1, g') ->
-                                           let e5 =
-                                             FStar_Syntax_Syntax.mk
-                                               (FStar_Syntax_Syntax.Tm_meta
-                                                  (e4,
-                                                    (FStar_Syntax_Syntax.Meta_monadic
-                                                       ((c1.FStar_TypeChecker_Common.eff_name),
-                                                         (c1.FStar_TypeChecker_Common.res_typ)))))
-                                               e4.FStar_Syntax_Syntax.pos in
-                                           let uu___15 =
-                                             FStar_TypeChecker_Env.conj_guards
-                                               [g_e; g_repr; g_a; g_eq; g'] in
-                                           (e5, c1, uu___15))))))))
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                 { FStar_Syntax_Syntax.fv_name = uu___2;
-                   FStar_Syntax_Syntax.fv_delta = uu___3;
-                   FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-                     (FStar_Syntax_Syntax.Unresolved_constructor uc);_};
-               FStar_Syntax_Syntax.pos = uu___4;
-               FStar_Syntax_Syntax.vars = uu___5;
-               FStar_Syntax_Syntax.hash_code = uu___6;_},
-             args)
-            ->
-            let uu___7 =
-              let uu___8 =
-                if uc.FStar_Syntax_Syntax.uc_base_term
-                then
-                  match args with
-                  | (b, uu___9)::rest ->
-                      ((FStar_Pervasives_Native.Some b), rest)
-                  | uu___9 -> failwith "Impossible"
-                else (FStar_Pervasives_Native.None, args) in
-              match uu___8 with
-              | (base_term, fields) ->
-                  let uu___9 =
-                    let uu___10 =
-                      FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                        fields in
-                    FStar_Compiler_List.zip uc.FStar_Syntax_Syntax.uc_fields
-                      uu___10 in
-                  (base_term, uu___9) in
-            (match uu___7 with
-             | (base_term, uc_fields) ->
-                 let uu___8 =
-                   let uu___9 = FStar_TypeChecker_Env.expected_typ env1 in
-                   match uu___9 with
-                   | FStar_Pervasives_Native.Some (t, uu___10) ->
-                       let uu___11 =
-                         FStar_TypeChecker_Util.find_record_or_dc_from_typ
-                           env1 (FStar_Pervasives_Native.Some t) uc
-                           top.FStar_Syntax_Syntax.pos in
-                       (uu___11,
-                         (FStar_Pervasives_Native.Some
-                            (FStar_Pervasives.Inl t)))
-                   | FStar_Pervasives_Native.None ->
-                       (match base_term with
-                        | FStar_Pervasives_Native.Some e1 ->
-                            let uu___10 = tc_term env1 e1 in
-                            (match uu___10 with
-                             | (uu___11, lc, uu___12) ->
-                                 let uu___13 =
-                                   FStar_TypeChecker_Util.find_record_or_dc_from_typ
-                                     env1
-                                     (FStar_Pervasives_Native.Some
-                                        (lc.FStar_TypeChecker_Common.res_typ))
-                                     uc top.FStar_Syntax_Syntax.pos in
-                                 (uu___13,
-                                   (FStar_Pervasives_Native.Some
-                                      (FStar_Pervasives.Inr
-                                         (lc.FStar_TypeChecker_Common.res_typ)))))
-                        | FStar_Pervasives_Native.None ->
-                            let uu___10 =
-                              FStar_TypeChecker_Util.find_record_or_dc_from_typ
-                                env1 FStar_Pervasives_Native.None uc
-                                top.FStar_Syntax_Syntax.pos in
-                            (uu___10, FStar_Pervasives_Native.None)) in
-                 (match uu___8 with
-                  | ((rdc, constrname, constructor), topt) ->
-                      let rdc1 = rdc in
-                      let constructor1 =
-                        FStar_Syntax_Syntax.fv_to_tm constructor in
-                      let mk_field_projector i x =
-                        let projname =
-                          FStar_Syntax_Util.mk_field_projector_name_from_ident
-                            constrname i in
-                        let qual =
-                          if rdc1.FStar_Syntax_DsEnv.is_record
-                          then
-                            FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Record_projector
-                                 (constrname, i))
-                          else FStar_Pervasives_Native.None in
-                        let candidate =
-                          let uu___9 =
-                            FStar_Ident.set_lid_range projname
-                              x.FStar_Syntax_Syntax.pos in
-                          FStar_Syntax_Syntax.fvar uu___9
-                            (FStar_Syntax_Syntax.Delta_equational_at_level
-                               Prims.int_one) qual in
-                        FStar_Syntax_Syntax.mk_Tm_app candidate
-                          [(x, FStar_Pervasives_Native.None)]
-                          x.FStar_Syntax_Syntax.pos in
-                      let fields =
-                        FStar_TypeChecker_Util.make_record_fields_in_order
-                          env1 uc topt rdc1 uc_fields
-                          (fun field_name ->
-                             match base_term with
-                             | FStar_Pervasives_Native.Some x ->
-                                 let uu___9 = mk_field_projector field_name x in
-                                 FStar_Pervasives_Native.Some uu___9
-                             | uu___9 -> FStar_Pervasives_Native.None)
-                          top.FStar_Syntax_Syntax.pos in
-                      let args1 =
-                        FStar_Compiler_List.map
-                          (fun x -> (x, FStar_Pervasives_Native.None)) fields in
-                      let term =
-                        FStar_Syntax_Syntax.mk_Tm_app constructor1 args1
-                          top.FStar_Syntax_Syntax.pos in
-                      tc_term env1 term))
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                 {
-                   FStar_Syntax_Syntax.fv_name =
-                     { FStar_Syntax_Syntax.v = field_name;
-                       FStar_Syntax_Syntax.p = uu___2;_};
-                   FStar_Syntax_Syntax.fv_delta = uu___3;
-                   FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-                     (FStar_Syntax_Syntax.Unresolved_projector candidate);_};
-               FStar_Syntax_Syntax.pos = uu___4;
-               FStar_Syntax_Syntax.vars = uu___5;
-               FStar_Syntax_Syntax.hash_code = uu___6;_},
-             (e1, FStar_Pervasives_Native.None)::rest)
-            ->
-            let proceed_with choice =
-              match choice with
-              | FStar_Pervasives_Native.None ->
-                  let uu___7 =
-                    let uu___8 =
-                      let uu___9 = FStar_Ident.string_of_lid field_name in
-                      FStar_Compiler_Util.format1
-                        "Field name %s could not be resolved" uu___9 in
-                    (FStar_Errors.Fatal_IdentifierNotFound, uu___8) in
-                  let uu___8 = FStar_Ident.range_of_lid field_name in
-                  FStar_Errors.raise_error uu___7 uu___8
-              | FStar_Pervasives_Native.Some choice1 ->
-                  let f = FStar_Syntax_Syntax.fv_to_tm choice1 in
-                  let term =
-                    FStar_Syntax_Syntax.mk_Tm_app f
-                      ((e1, FStar_Pervasives_Native.None) :: rest)
-                      top.FStar_Syntax_Syntax.pos in
-                  tc_term env1 term in
-            let uu___7 =
-              let uu___8 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-              match uu___8 with | (env2, uu___9) -> tc_term env2 e1 in
-            (match uu___7 with
-             | (uu___8, lc, uu___9) ->
-                 let t0 =
-                   FStar_TypeChecker_Normalize.unfold_whnf'
-                     [FStar_TypeChecker_Env.Unascribe;
-                     FStar_TypeChecker_Env.Unmeta;
-                     FStar_TypeChecker_Env.Unrefine] env1
-                     lc.FStar_TypeChecker_Common.res_typ in
-                 let uu___10 = FStar_Syntax_Util.head_and_args t0 in
-                 (match uu___10 with
-                  | (thead, uu___11) ->
-                      ((let uu___13 =
-                          FStar_Compiler_Effect.op_Less_Bar
-                            (FStar_TypeChecker_Env.debug env1)
-                            (FStar_Options.Other "RFD") in
-                        if uu___13
-                        then
-                          let uu___14 =
-                            FStar_Syntax_Print.term_to_string
-                              lc.FStar_TypeChecker_Common.res_typ in
-                          let uu___15 = FStar_Syntax_Print.term_to_string t0 in
-                          let uu___16 =
-                            FStar_Syntax_Print.term_to_string thead in
-                          FStar_Compiler_Util.print3
-                            "Got lc.res_typ=%s; t0 = %s; thead = %s\n"
-                            uu___14 uu___15 uu___16
-                        else ());
-                       (let uu___13 =
-                          let uu___14 =
-                            let uu___15 = FStar_Syntax_Util.un_uinst thead in
-                            FStar_Syntax_Subst.compress uu___15 in
-                          uu___14.FStar_Syntax_Syntax.n in
-                        match uu___13 with
-                        | FStar_Syntax_Syntax.Tm_fvar type_name ->
-                            let uu___14 =
-                              FStar_TypeChecker_Util.try_lookup_record_type
-                                env1
-                                (type_name.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                            (match uu___14 with
-                             | FStar_Pervasives_Native.None ->
-                                 proceed_with candidate
-                             | FStar_Pervasives_Native.Some rdc ->
-                                 let i =
-                                   FStar_Compiler_List.tryFind
-                                     (fun uu___15 ->
-                                        match uu___15 with
-                                        | (i1, uu___16) ->
-                                            FStar_TypeChecker_Util.field_name_matches
-                                              field_name rdc i1)
-                                     rdc.FStar_Syntax_DsEnv.fields in
-                                 (match i with
-                                  | FStar_Pervasives_Native.None ->
-                                      proceed_with candidate
-                                  | FStar_Pervasives_Native.Some
-                                      (i1, uu___15) ->
-                                      let constrname =
-                                        let uu___16 =
-                                          let uu___17 =
-                                            FStar_Ident.ns_of_lid
-                                              rdc.FStar_Syntax_DsEnv.typename in
-                                          FStar_Compiler_List.op_At uu___17
-                                            [rdc.FStar_Syntax_DsEnv.constrname] in
-                                        FStar_Ident.lid_of_ids uu___16 in
-                                      let projname =
-                                        FStar_Syntax_Util.mk_field_projector_name_from_ident
-                                          constrname i1 in
-                                      let qual =
-                                        if rdc.FStar_Syntax_DsEnv.is_record
-                                        then
-                                          FStar_Pervasives_Native.Some
-                                            (FStar_Syntax_Syntax.Record_projector
-                                               (constrname, i1))
-                                        else FStar_Pervasives_Native.None in
-                                      let choice =
-                                        let uu___16 =
-                                          let uu___17 =
-                                            FStar_Ident.range_of_lid
-                                              field_name in
-                                          FStar_Ident.set_lid_range projname
-                                            uu___17 in
-                                        FStar_Syntax_Syntax.lid_as_fv uu___16
-                                          (FStar_Syntax_Syntax.Delta_equational_at_level
-                                             Prims.int_one) qual in
-                                      proceed_with
-                                        (FStar_Pervasives_Native.Some choice)))
-                        | uu___14 -> proceed_with candidate))))
-        | FStar_Syntax_Syntax.Tm_app
-            (head, (tau, FStar_Pervasives_Native.None)::[]) when
-            (FStar_Syntax_Util.is_synth_by_tactic head) &&
-              (Prims.op_Negation env1.FStar_TypeChecker_Env.phase1)
-            ->
-            let uu___2 = FStar_Syntax_Util.head_and_args top in
-            (match uu___2 with
-             | (head1, args) ->
-                 tc_synth head1 env1 args top.FStar_Syntax_Syntax.pos)
-        | FStar_Syntax_Syntax.Tm_app
-            (head,
-             (uu___2, FStar_Pervasives_Native.Some
-              { FStar_Syntax_Syntax.aqual_implicit = true;
-                FStar_Syntax_Syntax.aqual_attributes = uu___3;_})::(tau,
-                                                                    FStar_Pervasives_Native.None)::[])
-            when
-            (FStar_Syntax_Util.is_synth_by_tactic head) &&
-              (Prims.op_Negation env1.FStar_TypeChecker_Env.phase1)
-            ->
-            let uu___4 = FStar_Syntax_Util.head_and_args top in
-            (match uu___4 with
-             | (head1, args) ->
-                 tc_synth head1 env1 args top.FStar_Syntax_Syntax.pos)
-        | FStar_Syntax_Syntax.Tm_app (head, args) when
-            (FStar_Syntax_Util.is_synth_by_tactic head) &&
-              (Prims.op_Negation env1.FStar_TypeChecker_Env.phase1)
-            ->
-            let uu___2 =
-              match args with
-              | (tau, FStar_Pervasives_Native.None)::rest ->
-                  ([(tau, FStar_Pervasives_Native.None)], rest)
-              | (a, FStar_Pervasives_Native.Some aq)::(tau,
-                                                       FStar_Pervasives_Native.None)::rest
-                  when aq.FStar_Syntax_Syntax.aqual_implicit ->
-                  ([(a, (FStar_Pervasives_Native.Some aq));
-                   (tau, FStar_Pervasives_Native.None)], rest)
-              | uu___3 ->
-                  FStar_Errors.raise_error
-                    (FStar_Errors.Fatal_SynthByTacticError,
-                      "synth_by_tactic: bad application")
-                    top.FStar_Syntax_Syntax.pos in
-            (match uu___2 with
-             | (args1, args2) ->
-                 let t1 = FStar_Syntax_Util.mk_app head args1 in
-                 let t2 = FStar_Syntax_Util.mk_app t1 args2 in
-                 tc_term env1 t2)
-        | FStar_Syntax_Syntax.Tm_app (head, args) ->
-            let env0 = env1 in
-            let env2 =
-              let uu___2 =
-                let uu___3 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Pervasives_Native.fst in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2 instantiate_both in
-            ((let uu___3 =
-                FStar_TypeChecker_Env.debug env2 FStar_Options.High in
-              if uu___3
-              then
-                let uu___4 =
-                  FStar_Compiler_Range.string_of_range
-                    top.FStar_Syntax_Syntax.pos in
-                let uu___5 = FStar_Syntax_Print.term_to_string top in
-                let uu___6 = print_expected_ty_str env0 in
-                FStar_Compiler_Util.print3 "(%s) Checking app %s, %s\n"
-                  uu___4 uu___5 uu___6
-              else ());
-             (let uu___3 = tc_term (no_inst env2) head in
-              match uu___3 with
-              | (head1, chead, g_head) ->
-                  let uu___4 =
-                    let uu___5 = FStar_TypeChecker_Common.lcomp_comp chead in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___5
-                      (fun uu___6 ->
-                         match uu___6 with
-                         | (c, g) ->
-                             let uu___7 =
-                               FStar_TypeChecker_Env.conj_guard g_head g in
-                             (c, uu___7)) in
-                  (match uu___4 with
-                   | (chead1, g_head1) ->
-                       let uu___5 =
-                         let uu___6 =
-                           ((Prims.op_Negation env2.FStar_TypeChecker_Env.lax)
-                              &&
-                              (let uu___7 = FStar_Options.lax () in
-                               Prims.op_Negation uu___7))
-                             &&
-                             (FStar_TypeChecker_Util.short_circuit_head head1) in
-                         if uu___6
-                         then
-                           let uu___7 =
-                             let uu___8 =
-                               FStar_TypeChecker_Env.expected_typ env0 in
-                             check_short_circuit_args env2 head1 chead1
-                               g_head1 args uu___8 in
-                           match uu___7 with | (e1, c, g) -> (e1, c, g)
-                         else
-                           (let uu___8 =
-                              FStar_TypeChecker_Env.expected_typ env0 in
-                            check_application_args env2 head1 chead1 g_head1
-                              args uu___8) in
-                       (match uu___5 with
-                        | (e1, c, g) ->
-                            let uu___6 =
-                              let uu___7 =
-                                (FStar_TypeChecker_Common.is_tot_or_gtot_lcomp
-                                   c)
-                                  ||
-                                  (env2.FStar_TypeChecker_Env.phase1 &&
-                                     (FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                        c)) in
-                              if uu___7
-                              then
-                                let uu___8 =
-                                  FStar_TypeChecker_Util.maybe_instantiate
-                                    env0 e1
-                                    c.FStar_TypeChecker_Common.res_typ in
-                                match uu___8 with
-                                | (e2, res_typ, implicits) ->
-                                    let uu___9 =
-                                      FStar_TypeChecker_Common.set_result_typ_lc
-                                        c res_typ in
-                                    (e2, uu___9, implicits)
-                              else
-                                (e1, c, FStar_TypeChecker_Env.trivial_guard) in
-                            (match uu___6 with
-                             | (e2, c1, implicits) ->
-                                 ((let uu___8 =
-                                     FStar_TypeChecker_Env.debug env2
-                                       FStar_Options.Extreme in
-                                   if uu___8
-                                   then
-                                     let uu___9 =
-                                       FStar_TypeChecker_Rel.print_pending_implicits
-                                         g in
-                                     FStar_Compiler_Util.print1
-                                       "Introduced {%s} implicits in application\n"
-                                       uu___9
-                                   else ());
-                                  (let uu___8 =
-                                     comp_check_expected_typ env0 e2 c1 in
-                                   match uu___8 with
-                                   | (e3, c2, g') ->
-                                       let gres =
-                                         FStar_TypeChecker_Env.conj_guard g
-                                           g' in
-                                       let gres1 =
-                                         FStar_TypeChecker_Env.conj_guard
-                                           gres implicits in
-                                       ((let uu___10 =
-                                           FStar_TypeChecker_Env.debug env2
-                                             FStar_Options.Extreme in
-                                         if uu___10
-                                         then
-                                           let uu___11 =
-                                             FStar_Syntax_Print.term_to_string
-                                               e3 in
-                                           let uu___12 =
-                                             FStar_TypeChecker_Rel.guard_to_string
-                                               env2 gres1 in
-                                           FStar_Compiler_Util.print2
-                                             "Guard from application node %s is %s\n"
-                                             uu___11 uu___12
-                                         else ());
-                                        (e3, c2, gres1)))))))))
-        | FStar_Syntax_Syntax.Tm_match uu___2 -> tc_match env1 top
-        | FStar_Syntax_Syntax.Tm_let
-            ((false,
-              { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr uu___2;
-                FStar_Syntax_Syntax.lbunivs = uu___3;
-                FStar_Syntax_Syntax.lbtyp = uu___4;
-                FStar_Syntax_Syntax.lbeff = uu___5;
-                FStar_Syntax_Syntax.lbdef = uu___6;
-                FStar_Syntax_Syntax.lbattrs = uu___7;
-                FStar_Syntax_Syntax.lbpos = uu___8;_}::[]),
-             uu___9)
-            -> check_top_level_let env1 top
-        | FStar_Syntax_Syntax.Tm_let ((false, uu___2), uu___3) ->
-            check_inner_let env1 top
-        | FStar_Syntax_Syntax.Tm_let
-            ((true,
-              { FStar_Syntax_Syntax.lbname = FStar_Pervasives.Inr uu___2;
-                FStar_Syntax_Syntax.lbunivs = uu___3;
-                FStar_Syntax_Syntax.lbtyp = uu___4;
-                FStar_Syntax_Syntax.lbeff = uu___5;
-                FStar_Syntax_Syntax.lbdef = uu___6;
-                FStar_Syntax_Syntax.lbattrs = uu___7;
-                FStar_Syntax_Syntax.lbpos = uu___8;_}::uu___9),
-             uu___10)
-            -> check_top_level_let_rec env1 top
-        | FStar_Syntax_Syntax.Tm_let ((true, uu___2), uu___3) ->
-            check_inner_let_rec env1 top))
-and (tc_match :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun top ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress top in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_match (e1, ret_opt, eqns, uu___1) ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 =
-                  FStar_Compiler_Effect.op_Bar_Greater env
-                    FStar_TypeChecker_Env.clear_expected_typ in
-                FStar_Compiler_Effect.op_Bar_Greater uu___5
-                  FStar_Pervasives_Native.fst in
-              FStar_Compiler_Effect.op_Bar_Greater uu___4 instantiate_both in
-            tc_term uu___3 e1 in
-          (match uu___2 with
-           | (e11, c1, g1) ->
-               let uu___3 =
-                 let uu___4 = FStar_TypeChecker_Util.coerce_views env e11 c1 in
-                 match uu___4 with
-                 | FStar_Pervasives_Native.Some (e12, c11) -> (e12, c11)
-                 | FStar_Pervasives_Native.None -> (e11, c1) in
-               (match uu___3 with
-                | (e12, c11) ->
-                    let uu___4 =
-                      match ret_opt with
-                      | FStar_Pervasives_Native.None ->
-                          let uu___5 = FStar_TypeChecker_Env.expected_typ env in
-                          (match uu___5 with
-                           | FStar_Pervasives_Native.Some uu___6 ->
-                               (env, FStar_Pervasives_Native.None, g1)
-                           | FStar_Pervasives_Native.None ->
-                               let uu___6 = FStar_Syntax_Util.type_u () in
-                               (match uu___6 with
-                                | (k, uu___7) ->
-                                    let uu___8 =
-                                      FStar_TypeChecker_Util.new_implicit_var
-                                        "match result"
-                                        e12.FStar_Syntax_Syntax.pos env k in
-                                    (match uu___8 with
-                                     | (res_t, uu___9, g) ->
-                                         let uu___10 =
-                                           FStar_TypeChecker_Env.set_expected_typ
-                                             env res_t in
-                                         let uu___11 =
-                                           FStar_TypeChecker_Env.conj_guard
-                                             g1 g in
-                                         (uu___10,
-                                           FStar_Pervasives_Native.None,
-                                           uu___11))))
-                      | FStar_Pervasives_Native.Some (b, asc) ->
-                          ((let uu___6 =
-                              let uu___7 =
-                                FStar_TypeChecker_Util.is_pure_or_ghost_effect
-                                  env c11.FStar_TypeChecker_Common.eff_name in
-                              Prims.op_Negation uu___7 in
-                            if uu___6
-                            then
-                              let uu___7 =
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Syntax_Print.term_to_string e12 in
-                                  let uu___10 =
-                                    FStar_Ident.string_of_lid
-                                      c11.FStar_TypeChecker_Common.eff_name in
-                                  FStar_Compiler_Util.format2
-                                    "For a match with returns annotation, the scrutinee should be pure/ghost, found %s with effect %s"
-                                    uu___9 uu___10 in
-                                (FStar_Errors.Fatal_UnexpectedEffect, uu___8) in
-                              FStar_Errors.raise_error uu___7
-                                e12.FStar_Syntax_Syntax.pos
-                            else ());
-                           (let uu___6 =
-                              FStar_TypeChecker_Env.clear_expected_typ env in
-                            match uu___6 with
-                            | (env1, uu___7) ->
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Syntax_Subst.open_ascription 
-                                      [b] asc in
-                                  match uu___9 with
-                                  | (bs, asc1) ->
-                                      let b1 = FStar_Compiler_List.hd bs in
-                                      ({
-                                         FStar_Syntax_Syntax.binder_bv =
-                                           (let uu___10 =
-                                              b1.FStar_Syntax_Syntax.binder_bv in
-                                            {
-                                              FStar_Syntax_Syntax.ppname =
-                                                (uu___10.FStar_Syntax_Syntax.ppname);
-                                              FStar_Syntax_Syntax.index =
-                                                (uu___10.FStar_Syntax_Syntax.index);
-                                              FStar_Syntax_Syntax.sort =
-                                                (c11.FStar_TypeChecker_Common.res_typ)
-                                            });
-                                         FStar_Syntax_Syntax.binder_qual =
-                                           (b1.FStar_Syntax_Syntax.binder_qual);
-                                         FStar_Syntax_Syntax.binder_attrs =
-                                           (b1.FStar_Syntax_Syntax.binder_attrs)
-                                       }, asc1) in
-                                (match uu___8 with
-                                 | (b1, asc1) ->
-                                     let env_asc =
-                                       FStar_TypeChecker_Env.push_binders
-                                         env1 [b1] in
-                                     let uu___9 =
-                                       match asc1 with
-                                       | (FStar_Pervasives.Inl t,
-                                          FStar_Pervasives_Native.None,
-                                          use_eq) ->
-                                           let uu___10 =
-                                             FStar_Syntax_Util.type_u () in
-                                           (match uu___10 with
-                                            | (k, uu___11) ->
-                                                let uu___12 =
-                                                  tc_check_tot_or_gtot_term
-                                                    env_asc t k "" in
-                                                (match uu___12 with
-                                                 | (t1, uu___13, g) ->
-                                                     (((FStar_Pervasives.Inl
-                                                          t1),
-                                                        FStar_Pervasives_Native.None,
-                                                        use_eq), g)))
-                                       | (FStar_Pervasives.Inr c,
-                                          FStar_Pervasives_Native.None,
-                                          use_eq) ->
-                                           let uu___10 = tc_comp env_asc c in
-                                           (match uu___10 with
-                                            | (c2, uu___11, g) ->
-                                                (((FStar_Pervasives.Inr c2),
-                                                   FStar_Pervasives_Native.None,
-                                                   use_eq), g))
-                                       | uu___10 ->
-                                           let uu___11 =
-                                             FStar_TypeChecker_Env.get_range
-                                               env1 in
-                                           FStar_Errors.raise_error
-                                             (FStar_Errors.Fatal_UnexpectedTerm,
-                                               "Tactic is not yet supported with match returns")
-                                             uu___11 in
-                                     (match uu___9 with
-                                      | (asc2, g_asc) ->
-                                          let uu___10 =
-                                            let uu___11 =
-                                              FStar_TypeChecker_Env.close_guard
-                                                env_asc [b1] g_asc in
-                                            FStar_TypeChecker_Env.conj_guard
-                                              g1 uu___11 in
-                                          (env1,
-                                            (FStar_Pervasives_Native.Some
-                                               (b1, asc2)), uu___10))))) in
-                    (match uu___4 with
-                     | (env_branches, ret_opt1, g11) ->
-                         let guard_x =
-                           FStar_Syntax_Syntax.new_bv
-                             (FStar_Pervasives_Native.Some
-                                (e12.FStar_Syntax_Syntax.pos))
-                             c11.FStar_TypeChecker_Common.res_typ in
-                         let t_eqns =
-                           FStar_Compiler_Effect.op_Bar_Greater eqns
-                             (FStar_Compiler_List.map
-                                (tc_eqn guard_x env_branches ret_opt1)) in
-                         let uu___5 =
-                           match ret_opt1 with
-                           | FStar_Pervasives_Native.Some
-                               (b, (FStar_Pervasives.Inr c, uu___6, uu___7))
-                               ->
-                               let c2 =
-                                 FStar_Syntax_Subst.subst_comp
-                                   [FStar_Syntax_Syntax.NT
-                                      ((b.FStar_Syntax_Syntax.binder_bv),
-                                        e12)] c in
-                               let uu___8 =
-                                 let uu___9 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     t_eqns
-                                     (FStar_Compiler_List.map
-                                        (fun uu___10 ->
-                                           match uu___10 with
-                                           | (uu___11, f, uu___12, uu___13,
-                                              uu___14, g, b1) -> (f, g, b1))) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                   FStar_Compiler_List.unzip3 in
-                               (match uu___8 with
-                                | (fmls, gs, erasables) ->
-                                    let uu___9 =
-                                      FStar_TypeChecker_Util.get_neg_branch_conds
-                                        fmls in
-                                    (match uu___9 with
-                                     | (neg_conds, exhaustiveness_cond) ->
-                                         let g =
-                                           let uu___10 =
-                                             FStar_Compiler_List.map2
-                                               FStar_TypeChecker_Common.weaken_guard_formula
-                                               gs neg_conds in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___10
-                                             FStar_TypeChecker_Env.conj_guards in
-                                         let g_exhaustiveness =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               let uu___12 =
-                                                 FStar_Syntax_Util.mk_imp
-                                                   exhaustiveness_cond
-                                                   FStar_Syntax_Util.t_false in
-                                               let uu___13 =
-                                                 let uu___14 =
-                                                   FStar_TypeChecker_Env.get_range
-                                                     env in
-                                                 FStar_TypeChecker_Util.label
-                                                   FStar_TypeChecker_Err.exhaustiveness_check
-                                                   uu___14 in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___12 uu___13 in
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               uu___11
-                                               (fun uu___12 ->
-                                                  FStar_TypeChecker_Common.NonTrivial
-                                                    uu___12) in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___10
-                                             FStar_TypeChecker_Env.guard_of_guard_formula in
-                                         let g2 =
-                                           FStar_TypeChecker_Env.conj_guard g
-                                             g_exhaustiveness in
-                                         let g3 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               env.FStar_TypeChecker_Env.universe_of
-                                                 env
-                                                 c11.FStar_TypeChecker_Common.res_typ in
-                                             let uu___12 =
-                                               FStar_Syntax_Syntax.bv_to_name
-                                                 guard_x in
-                                             FStar_Syntax_Util.mk_eq2 uu___11
-                                               c11.FStar_TypeChecker_Common.res_typ
-                                               uu___12 e12 in
-                                           FStar_TypeChecker_Common.weaken_guard_formula
-                                             g2 uu___10 in
-                                         let g4 =
-                                           let uu___10 =
-                                             let uu___11 =
-                                               FStar_Syntax_Syntax.mk_binder
-                                                 guard_x in
-                                             [uu___11] in
-                                           FStar_TypeChecker_Env.close_guard
-                                             env uu___10 g3 in
-                                         let uu___10 =
-                                           FStar_TypeChecker_Common.lcomp_of_comp
-                                             c2 in
-                                         let uu___11 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             erasables
-                                             (FStar_Compiler_List.fold_left
-                                                (fun acc ->
-                                                   fun b1 -> acc || b1) false) in
-                                         (uu___10, g4, uu___11)))
-                           | uu___6 ->
-                               let uu___7 =
-                                 FStar_Compiler_List.fold_right
-                                   (fun uu___8 ->
-                                      fun uu___9 ->
-                                        match (uu___8, uu___9) with
-                                        | ((branch, f, eff_label, cflags, c,
-                                            g, erasable_branch),
-                                           (caccum, gaccum, erasable)) ->
-                                            let uu___10 =
-                                              let uu___11 =
-                                                let uu___12 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    cflags
-                                                    FStar_Compiler_Util.must in
-                                                let uu___13 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    c
-                                                    FStar_Compiler_Util.must in
-                                                (f, eff_label, uu___12,
-                                                  uu___13) in
-                                              uu___11 :: caccum in
-                                            let uu___11 =
-                                              FStar_TypeChecker_Env.conj_guard
-                                                g gaccum in
-                                            (uu___10, uu___11,
-                                              (erasable || erasable_branch)))
-                                   t_eqns
-                                   ([], FStar_TypeChecker_Env.trivial_guard,
-                                     false) in
-                               (match uu___7 with
-                                | (cases, g, erasable) ->
-                                    (match ret_opt1 with
-                                     | FStar_Pervasives_Native.None ->
-                                         let res_t =
-                                           let uu___8 =
-                                             let uu___9 =
-                                               FStar_TypeChecker_Env.expected_typ
-                                                 env_branches in
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               uu___9
-                                               FStar_Compiler_Util.must in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___8
-                                             FStar_Pervasives_Native.fst in
-                                         let uu___8 =
-                                           FStar_TypeChecker_Util.bind_cases
-                                             env res_t cases guard_x in
-                                         (uu___8, g, erasable)
-                                     | FStar_Pervasives_Native.Some
-                                         (b,
-                                          (FStar_Pervasives.Inl t, uu___8,
-                                           uu___9))
-                                         ->
-                                         let t1 =
-                                           FStar_Syntax_Subst.subst
-                                             [FStar_Syntax_Syntax.NT
-                                                ((b.FStar_Syntax_Syntax.binder_bv),
-                                                  e12)] t in
-                                         let cases1 =
-                                           FStar_Compiler_List.map
-                                             (fun uu___10 ->
-                                                match uu___10 with
-                                                | (f, eff_label, cflags, c)
-                                                    ->
-                                                    (f, eff_label, cflags,
-                                                      ((fun b1 ->
-                                                          let uu___11 = c b1 in
-                                                          FStar_TypeChecker_Common.set_result_typ_lc
-                                                            uu___11 t1))))
-                                             cases in
-                                         let uu___10 =
-                                           FStar_TypeChecker_Util.bind_cases
-                                             env t1 cases1 guard_x in
-                                         (uu___10, g, erasable))) in
-                         (match uu___5 with
-                          | (c_branches, g_branches, erasable) ->
-                              let cres =
-                                FStar_TypeChecker_Util.bind
-                                  e12.FStar_Syntax_Syntax.pos env
-                                  (FStar_Pervasives_Native.Some e12) c11
-                                  ((FStar_Pervasives_Native.Some guard_x),
-                                    c_branches) in
-                              let cres1 =
-                                if erasable
-                                then
-                                  let e = FStar_Syntax_Util.exp_true_bool in
-                                  let c =
-                                    FStar_Syntax_Syntax.mk_GTotal
-                                      FStar_Syntax_Util.t_bool in
-                                  let uu___6 =
-                                    FStar_TypeChecker_Common.lcomp_of_comp c in
-                                  FStar_TypeChecker_Util.bind
-                                    e.FStar_Syntax_Syntax.pos env
-                                    (FStar_Pervasives_Native.Some e) uu___6
-                                    (FStar_Pervasives_Native.None, cres)
-                                else cres in
-                              let e =
-                                let ret_opt2 =
-                                  match ret_opt1 with
-                                  | FStar_Pervasives_Native.None ->
-                                      FStar_Pervasives_Native.None
-                                  | FStar_Pervasives_Native.Some (b, asc) ->
-                                      let asc1 =
-                                        FStar_Syntax_Subst.close_ascription
-                                          [b] asc in
-                                      let b1 =
-                                        let uu___6 =
-                                          FStar_Syntax_Subst.close_binders
-                                            [b] in
-                                        FStar_Compiler_List.hd uu___6 in
-                                      let b2 =
-                                        {
-                                          FStar_Syntax_Syntax.binder_bv =
-                                            (let uu___6 =
-                                               b1.FStar_Syntax_Syntax.binder_bv in
-                                             {
-                                               FStar_Syntax_Syntax.ppname =
-                                                 (uu___6.FStar_Syntax_Syntax.ppname);
-                                               FStar_Syntax_Syntax.index =
-                                                 (uu___6.FStar_Syntax_Syntax.index);
-                                               FStar_Syntax_Syntax.sort =
-                                                 FStar_Syntax_Syntax.tun
-                                             });
-                                          FStar_Syntax_Syntax.binder_qual =
-                                            (b1.FStar_Syntax_Syntax.binder_qual);
-                                          FStar_Syntax_Syntax.binder_attrs =
-                                            (b1.FStar_Syntax_Syntax.binder_attrs)
-                                        } in
-                                      FStar_Pervasives_Native.Some (b2, asc1) in
-                                let mk_match scrutinee =
-                                  let branches =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      t_eqns
-                                      (FStar_Compiler_List.map
-                                         (fun uu___6 ->
-                                            match uu___6 with
-                                            | ((pat, wopt, br), uu___7,
-                                               eff_label, uu___8, uu___9,
-                                               uu___10, uu___11) ->
-                                                let uu___12 =
-                                                  FStar_TypeChecker_Util.maybe_lift
-                                                    env br eff_label
-                                                    cres1.FStar_TypeChecker_Common.eff_name
-                                                    cres1.FStar_TypeChecker_Common.res_typ in
-                                                (pat, wopt, uu___12))) in
-                                  let e2 =
-                                    let rc =
-                                      {
-                                        FStar_Syntax_Syntax.residual_effect =
-                                          (cres1.FStar_TypeChecker_Common.eff_name);
-                                        FStar_Syntax_Syntax.residual_typ =
-                                          (FStar_Pervasives_Native.Some
-                                             (cres1.FStar_TypeChecker_Common.res_typ));
-                                        FStar_Syntax_Syntax.residual_flags =
-                                          (cres1.FStar_TypeChecker_Common.cflags)
-                                      } in
-                                    FStar_Syntax_Syntax.mk
-                                      (FStar_Syntax_Syntax.Tm_match
-                                         (scrutinee, ret_opt2, branches,
-                                           (FStar_Pervasives_Native.Some rc)))
-                                      top.FStar_Syntax_Syntax.pos in
-                                  let e3 =
-                                    FStar_TypeChecker_Util.maybe_monadic env
-                                      e2
-                                      cres1.FStar_TypeChecker_Common.eff_name
-                                      cres1.FStar_TypeChecker_Common.res_typ in
-                                  match ret_opt2 with
-                                  | FStar_Pervasives_Native.None ->
-                                      FStar_Syntax_Syntax.mk
-                                        (FStar_Syntax_Syntax.Tm_ascribed
-                                           (e3,
-                                             ((FStar_Pervasives.Inl
-                                                 (cres1.FStar_TypeChecker_Common.res_typ)),
-                                               FStar_Pervasives_Native.None,
-                                               false),
-                                             (FStar_Pervasives_Native.Some
-                                                (cres1.FStar_TypeChecker_Common.eff_name))))
-                                        e3.FStar_Syntax_Syntax.pos
-                                  | uu___6 -> e3 in
-                                let uu___6 =
-                                  FStar_TypeChecker_Util.is_pure_or_ghost_effect
-                                    env c11.FStar_TypeChecker_Common.eff_name in
-                                if uu___6
-                                then mk_match e12
-                                else
-                                  (let e_match =
-                                     let uu___8 =
-                                       FStar_Syntax_Syntax.bv_to_name guard_x in
-                                     mk_match uu___8 in
-                                   let lb =
-                                     let uu___8 =
-                                       FStar_TypeChecker_Env.norm_eff_name
-                                         env
-                                         c11.FStar_TypeChecker_Common.eff_name in
-                                     FStar_Syntax_Util.mk_letbinding
-                                       (FStar_Pervasives.Inl guard_x) []
-                                       c11.FStar_TypeChecker_Common.res_typ
-                                       uu___8 e12 []
-                                       e12.FStar_Syntax_Syntax.pos in
-                                   let e2 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             let uu___12 =
-                                               FStar_Syntax_Syntax.mk_binder
-                                                 guard_x in
-                                             [uu___12] in
-                                           FStar_Syntax_Subst.close uu___11
-                                             e_match in
-                                         ((false, [lb]), uu___10) in
-                                       FStar_Syntax_Syntax.Tm_let uu___9 in
-                                     FStar_Syntax_Syntax.mk uu___8
-                                       top.FStar_Syntax_Syntax.pos in
-                                   FStar_TypeChecker_Util.maybe_monadic env
-                                     e2
-                                     cres1.FStar_TypeChecker_Common.eff_name
-                                     cres1.FStar_TypeChecker_Common.res_typ) in
-                              let uu___6 =
-                                match ret_opt1 with
-                                | FStar_Pervasives_Native.None ->
-                                    (e, cres1,
-                                      FStar_TypeChecker_Env.trivial_guard)
-                                | uu___7 ->
-                                    comp_check_expected_typ env e cres1 in
-                              (match uu___6 with
-                               | (e2, cres2, g_expected_type) ->
-                                   ((let uu___8 =
-                                       FStar_TypeChecker_Env.debug env
-                                         FStar_Options.Extreme in
-                                     if uu___8
-                                     then
-                                       let uu___9 =
-                                         FStar_Compiler_Range.string_of_range
-                                           top.FStar_Syntax_Syntax.pos in
-                                       let uu___10 =
-                                         FStar_TypeChecker_Common.lcomp_to_string
-                                           cres2 in
-                                       FStar_Compiler_Util.print2
-                                         "(%s) Typechecked Tm_match, comp type = %s\n"
-                                         uu___9 uu___10
-                                     else ());
-                                    (let uu___8 =
-                                       FStar_TypeChecker_Env.conj_guards
-                                         [g11; g_branches; g_expected_type] in
-                                     (e2, cres2, uu___8))))))))
-      | uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.tag_of_term top in
-            FStar_Compiler_Util.format1 "tc_match called on %s\n" uu___3 in
-          failwith uu___2
-and (tc_synth :
-  FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-    FStar_TypeChecker_Env.env ->
-      (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list ->
-        FStar_Compiler_Range.range ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun head ->
-    fun env ->
-      fun args ->
-        fun rng ->
-          let uu___ =
-            match args with
-            | (tau, FStar_Pervasives_Native.None)::[] ->
-                (tau, FStar_Pervasives_Native.None)
-            | (a, FStar_Pervasives_Native.Some
-               { FStar_Syntax_Syntax.aqual_implicit = true;
-                 FStar_Syntax_Syntax.aqual_attributes = uu___1;_})::(tau,
-                                                                    FStar_Pervasives_Native.None)::[]
-                -> (tau, (FStar_Pervasives_Native.Some a))
-            | uu___1 ->
-                FStar_Errors.raise_error
-                  (FStar_Errors.Fatal_SynthByTacticError,
-                    "synth_by_tactic: bad application") rng in
-          match uu___ with
-          | (tau, atyp) ->
-              let typ =
-                match atyp with
-                | FStar_Pervasives_Native.Some t -> t
-                | FStar_Pervasives_Native.None ->
-                    let uu___1 = FStar_TypeChecker_Env.expected_typ env in
-                    (match uu___1 with
-                     | FStar_Pervasives_Native.Some (t, use_eq) ->
-                         (if use_eq
-                          then
-                            (let uu___3 =
-                               let uu___4 =
-                                 let uu___5 =
-                                   FStar_Syntax_Print.term_to_string t in
-                                 FStar_Compiler_Util.format1
-                                   "Equality ascription in synth (%s) is not yet supported, please use subtyping"
-                                   uu___5 in
-                               (FStar_Errors.Fatal_NotSupported, uu___4) in
-                             FStar_Errors.raise_error uu___3
-                               t.FStar_Syntax_Syntax.pos)
-                          else ();
-                          t)
-                     | FStar_Pervasives_Native.None ->
-                         let uu___2 = FStar_TypeChecker_Env.get_range env in
-                         FStar_Errors.raise_error
-                           (FStar_Errors.Fatal_SynthByTacticError,
-                             "synth_by_tactic: need a type annotation when no expected type is present")
-                           uu___2) in
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 =
-                    let uu___4 = FStar_Syntax_Util.type_u () in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      FStar_Pervasives_Native.fst uu___4 in
-                  FStar_TypeChecker_Env.set_expected_typ env uu___3 in
-                tc_term uu___2 typ in
-              (match uu___1 with
-               | (typ1, uu___2, g1) ->
-                   (FStar_TypeChecker_Rel.force_trivial_guard env g1;
-                    (let uu___4 =
-                       tc_tactic FStar_Syntax_Syntax.t_unit
-                         FStar_Syntax_Syntax.t_unit env tau in
-                     match uu___4 with
-                     | (tau1, uu___5, g2) ->
-                         (FStar_TypeChecker_Rel.force_trivial_guard env g2;
-                          (let t =
-                             env.FStar_TypeChecker_Env.synth_hook env typ1
-                               {
-                                 FStar_Syntax_Syntax.n =
-                                   (tau1.FStar_Syntax_Syntax.n);
-                                 FStar_Syntax_Syntax.pos = rng;
-                                 FStar_Syntax_Syntax.vars =
-                                   (tau1.FStar_Syntax_Syntax.vars);
-                                 FStar_Syntax_Syntax.hash_code =
-                                   (tau1.FStar_Syntax_Syntax.hash_code)
-                               } in
-                           (let uu___8 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug env)
-                                (FStar_Options.Other "Tac") in
-                            if uu___8
-                            then
-                              let uu___9 =
-                                FStar_Syntax_Print.term_to_string t in
-                              FStar_Compiler_Util.print1 "Got %s\n" uu___9
-                            else ());
-                           FStar_TypeChecker_Util.check_uvars
-                             tau1.FStar_Syntax_Syntax.pos t;
-                           (let uu___9 =
-                              let uu___10 = FStar_Syntax_Syntax.mk_Total typ1 in
-                              FStar_Compiler_Effect.op_Less_Bar
-                                FStar_TypeChecker_Common.lcomp_of_comp
-                                uu___10 in
-                            (t, uu___9, FStar_TypeChecker_Env.trivial_guard)))))))
-and (tc_tactic :
-  FStar_Syntax_Syntax.typ ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.term ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun a ->
-    fun b ->
-      fun env ->
-        fun tau ->
-          let env1 =
-            {
-              FStar_TypeChecker_Env.solver =
-                (env.FStar_TypeChecker_Env.solver);
-              FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-              FStar_TypeChecker_Env.curmodule =
-                (env.FStar_TypeChecker_Env.curmodule);
-              FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-              FStar_TypeChecker_Env.gamma_sig =
-                (env.FStar_TypeChecker_Env.gamma_sig);
-              FStar_TypeChecker_Env.gamma_cache =
-                (env.FStar_TypeChecker_Env.gamma_cache);
-              FStar_TypeChecker_Env.modules =
-                (env.FStar_TypeChecker_Env.modules);
-              FStar_TypeChecker_Env.expected_typ =
-                (env.FStar_TypeChecker_Env.expected_typ);
-              FStar_TypeChecker_Env.sigtab =
-                (env.FStar_TypeChecker_Env.sigtab);
-              FStar_TypeChecker_Env.attrtab =
-                (env.FStar_TypeChecker_Env.attrtab);
-              FStar_TypeChecker_Env.instantiate_imp =
-                (env.FStar_TypeChecker_Env.instantiate_imp);
-              FStar_TypeChecker_Env.effects =
-                (env.FStar_TypeChecker_Env.effects);
-              FStar_TypeChecker_Env.generalize =
-                (env.FStar_TypeChecker_Env.generalize);
-              FStar_TypeChecker_Env.letrecs =
-                (env.FStar_TypeChecker_Env.letrecs);
-              FStar_TypeChecker_Env.top_level =
-                (env.FStar_TypeChecker_Env.top_level);
-              FStar_TypeChecker_Env.check_uvars =
-                (env.FStar_TypeChecker_Env.check_uvars);
-              FStar_TypeChecker_Env.use_eq_strict =
-                (env.FStar_TypeChecker_Env.use_eq_strict);
-              FStar_TypeChecker_Env.is_iface =
-                (env.FStar_TypeChecker_Env.is_iface);
-              FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-              FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-              FStar_TypeChecker_Env.lax_universes =
-                (env.FStar_TypeChecker_Env.lax_universes);
-              FStar_TypeChecker_Env.phase1 =
-                (env.FStar_TypeChecker_Env.phase1);
-              FStar_TypeChecker_Env.failhard = true;
-              FStar_TypeChecker_Env.nosynth =
-                (env.FStar_TypeChecker_Env.nosynth);
-              FStar_TypeChecker_Env.uvar_subtyping =
-                (env.FStar_TypeChecker_Env.uvar_subtyping);
-              FStar_TypeChecker_Env.tc_term =
-                (env.FStar_TypeChecker_Env.tc_term);
-              FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-              FStar_TypeChecker_Env.universe_of =
-                (env.FStar_TypeChecker_Env.universe_of);
-              FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-              FStar_TypeChecker_Env.teq_nosmt_force =
-                (env.FStar_TypeChecker_Env.teq_nosmt_force);
-              FStar_TypeChecker_Env.subtype_nosmt_force =
-                (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-              FStar_TypeChecker_Env.qtbl_name_and_index =
-                (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-              FStar_TypeChecker_Env.normalized_eff_names =
-                (env.FStar_TypeChecker_Env.normalized_eff_names);
-              FStar_TypeChecker_Env.fv_delta_depths =
-                (env.FStar_TypeChecker_Env.fv_delta_depths);
-              FStar_TypeChecker_Env.proof_ns =
-                (env.FStar_TypeChecker_Env.proof_ns);
-              FStar_TypeChecker_Env.synth_hook =
-                (env.FStar_TypeChecker_Env.synth_hook);
-              FStar_TypeChecker_Env.try_solve_implicits_hook =
-                (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-              FStar_TypeChecker_Env.splice =
-                (env.FStar_TypeChecker_Env.splice);
-              FStar_TypeChecker_Env.mpreprocess =
-                (env.FStar_TypeChecker_Env.mpreprocess);
-              FStar_TypeChecker_Env.postprocess =
-                (env.FStar_TypeChecker_Env.postprocess);
-              FStar_TypeChecker_Env.identifier_info =
-                (env.FStar_TypeChecker_Env.identifier_info);
-              FStar_TypeChecker_Env.tc_hooks =
-                (env.FStar_TypeChecker_Env.tc_hooks);
-              FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-              FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-              FStar_TypeChecker_Env.strict_args_tab =
-                (env.FStar_TypeChecker_Env.strict_args_tab);
-              FStar_TypeChecker_Env.erasable_types_tab =
-                (env.FStar_TypeChecker_Env.erasable_types_tab);
-              FStar_TypeChecker_Env.enable_defer_to_tac =
-                (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-              FStar_TypeChecker_Env.unif_allow_ref_guards =
-                (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-              FStar_TypeChecker_Env.erase_erasable_args =
-                (env.FStar_TypeChecker_Env.erase_erasable_args);
-              FStar_TypeChecker_Env.core_check =
-                (env.FStar_TypeChecker_Env.core_check)
-            } in
-          let uu___ = FStar_Syntax_Syntax.t_tac_of a b in
-          tc_check_tot_or_gtot_term env1 tau uu___ ""
-and (check_instantiated_fvar :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.var ->
-      FStar_Syntax_Syntax.fv_qual FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.typ ->
-            (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun v ->
-      fun q ->
-        fun e ->
-          fun t0 ->
-            let is_data_ctor uu___ =
-              match uu___ with
-              | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Data_ctor)
-                  -> true
-              | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Record_ctor
-                  uu___1) -> true
-              | uu___1 -> false in
-            (let uu___1 =
-               (is_data_ctor q) &&
-                 (let uu___2 =
-                    FStar_TypeChecker_Env.is_datacon env
-                      v.FStar_Syntax_Syntax.v in
-                  Prims.op_Negation uu___2) in
-             if uu___1
-             then
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 =
-                     FStar_Ident.string_of_lid v.FStar_Syntax_Syntax.v in
-                   FStar_Compiler_Util.format1
-                     "Expected a data constructor; got %s" uu___4 in
-                 (FStar_Errors.Fatal_MissingDataConstructor, uu___3) in
-               let uu___3 = FStar_TypeChecker_Env.get_range env in
-               FStar_Errors.raise_error uu___2 uu___3
-             else ());
-            (let t = FStar_Syntax_Util.remove_inacc t0 in
-             let uu___1 = FStar_TypeChecker_Util.maybe_instantiate env e t in
-             match uu___1 with
-             | (e1, t1, implicits) ->
-                 let tc =
-                   let uu___2 = FStar_TypeChecker_Env.should_verify env in
-                   if uu___2
-                   then FStar_Pervasives.Inl t1
-                   else
-                     (let uu___4 =
-                        let uu___5 = FStar_Syntax_Syntax.mk_Total t1 in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          FStar_TypeChecker_Common.lcomp_of_comp uu___5 in
-                      FStar_Pervasives.Inr uu___4) in
-                 value_check_expected_typ env e1 tc implicits)
-and (tc_value :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      let env1 =
-        FStar_TypeChecker_Env.set_range env e.FStar_Syntax_Syntax.pos in
-      let top = FStar_Syntax_Subst.compress e in
-      match top.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_bvar x ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string top in
-              FStar_Compiler_Util.format1
-                "Violation of locally nameless convention: %s" uu___2 in
-            (FStar_Errors.Error_IllScopedTerm, uu___1) in
-          FStar_Errors.raise_error uu___ top.FStar_Syntax_Syntax.pos
-      | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Util.ctx_uvar_typ u in
-              FStar_Syntax_Subst.subst' s uu___2 in
-            FStar_Pervasives.Inl uu___1 in
-          value_check_expected_typ env1 e uu___
-            FStar_TypeChecker_Env.trivial_guard
-      | FStar_Syntax_Syntax.Tm_unknown ->
-          let r = FStar_TypeChecker_Env.get_range env1 in
-          let uu___ =
-            let uu___1 = FStar_TypeChecker_Env.expected_typ env1 in
-            match uu___1 with
-            | FStar_Pervasives_Native.None ->
-                let uu___2 = FStar_Syntax_Util.type_u () in
-                (match uu___2 with
-                 | (k, u) ->
-                     FStar_TypeChecker_Util.new_implicit_var
-                       "type of user-provided implicit term" r env1 k)
-            | FStar_Pervasives_Native.Some (t, use_eq) ->
-                (if use_eq
-                 then
-                   (let uu___3 =
-                      let uu___4 =
-                        let uu___5 = FStar_Syntax_Print.term_to_string t in
-                        FStar_Compiler_Util.format1
-                          "Equality ascription as an expected type for unk (:%s) is not yet supported, please use subtyping"
-                          uu___5 in
-                      (FStar_Errors.Fatal_NotSupported, uu___4) in
-                    FStar_Errors.raise_error uu___3 e.FStar_Syntax_Syntax.pos)
-                 else ();
-                 (t, [], FStar_TypeChecker_Env.trivial_guard)) in
-          (match uu___ with
-           | (t, uu___1, g0) ->
-               let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Compiler_Range.string_of_range r in
-                   Prims.op_Hat "user-provided implicit term at " uu___4 in
-                 FStar_TypeChecker_Util.new_implicit_var uu___3 r env1 t in
-               (match uu___2 with
-                | (e1, uu___3, g1) ->
-                    let uu___4 =
-                      let uu___5 = FStar_Syntax_Syntax.mk_Total t in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___5
-                        FStar_TypeChecker_Common.lcomp_of_comp in
-                    let uu___5 = FStar_TypeChecker_Env.conj_guard g0 g1 in
-                    (e1, uu___4, uu___5)))
-      | FStar_Syntax_Syntax.Tm_name x ->
-          let uu___ = FStar_TypeChecker_Env.lookup_bv env1 x in
-          (match uu___ with
-           | (t, rng) ->
-               let x1 =
-                 FStar_Syntax_Syntax.set_range_of_bv
-                   {
-                     FStar_Syntax_Syntax.ppname =
-                       (x.FStar_Syntax_Syntax.ppname);
-                     FStar_Syntax_Syntax.index =
-                       (x.FStar_Syntax_Syntax.index);
-                     FStar_Syntax_Syntax.sort = t
-                   } rng in
-               (FStar_TypeChecker_Env.insert_bv_info env1 x1 t;
-                (let e1 = FStar_Syntax_Syntax.bv_to_name x1 in
-                 let uu___2 =
-                   FStar_TypeChecker_Util.maybe_instantiate env1 e1 t in
-                 match uu___2 with
-                 | (e2, t1, implicits) ->
-                     let tc =
-                       let uu___3 = FStar_TypeChecker_Env.should_verify env1 in
-                       if uu___3
-                       then FStar_Pervasives.Inl t1
-                       else
-                         (let uu___5 =
-                            let uu___6 = FStar_Syntax_Syntax.mk_Total t1 in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              FStar_TypeChecker_Common.lcomp_of_comp uu___6 in
-                          FStar_Pervasives.Inr uu___5) in
-                     value_check_expected_typ env1 e2 tc implicits)))
-      | FStar_Syntax_Syntax.Tm_uinst
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___;
-             FStar_Syntax_Syntax.vars = uu___1;
-             FStar_Syntax_Syntax.hash_code = uu___2;_},
-           uu___3)
-          when
-          (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.synth_lid) &&
-            (Prims.op_Negation env1.FStar_TypeChecker_Env.phase1)
-          ->
-          let uu___4 = FStar_TypeChecker_Env.get_range env1 in
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_BadlyInstantiatedSynthByTactic,
-              "Badly instantiated synth_by_tactic") uu___4
-      | FStar_Syntax_Syntax.Tm_fvar fv when
-          (FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.synth_lid) &&
-            (Prims.op_Negation env1.FStar_TypeChecker_Env.phase1)
-          ->
-          let uu___ = FStar_TypeChecker_Env.get_range env1 in
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_BadlyInstantiatedSynthByTactic,
-              "Badly instantiated synth_by_tactic") uu___
-      | FStar_Syntax_Syntax.Tm_uinst
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___;
-             FStar_Syntax_Syntax.vars = uu___1;
-             FStar_Syntax_Syntax.hash_code = uu___2;_},
-           us)
-          ->
-          let us1 = FStar_Compiler_List.map (tc_universe env1) us in
-          let uu___3 =
-            FStar_TypeChecker_Env.lookup_lid env1
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___3 with
-           | ((us', t), range) ->
-               let fv1 = FStar_Syntax_Syntax.set_range_of_fv fv range in
-               (maybe_warn_on_use env1 fv1;
-                if
-                  (FStar_Compiler_List.length us1) <>
-                    (FStar_Compiler_List.length us')
-                then
-                  (let uu___6 =
-                     let uu___7 =
-                       let uu___8 = FStar_Syntax_Print.fv_to_string fv1 in
-                       let uu___9 =
-                         FStar_Compiler_Util.string_of_int
-                           (FStar_Compiler_List.length us1) in
-                       let uu___10 =
-                         FStar_Compiler_Util.string_of_int
-                           (FStar_Compiler_List.length us') in
-                       FStar_Compiler_Util.format3
-                         "Unexpected number of universe instantiations for \"%s\" (%s vs %s)"
-                         uu___8 uu___9 uu___10 in
-                     (FStar_Errors.Fatal_UnexpectedNumberOfUniverse, uu___7) in
-                   let uu___7 = FStar_TypeChecker_Env.get_range env1 in
-                   FStar_Errors.raise_error uu___6 uu___7)
-                else ();
-                FStar_Compiler_List.iter2
-                  (fun ul ->
-                     fun ur ->
-                       match (ul, ur) with
-                       | (FStar_Syntax_Syntax.U_unif u'', uu___7) ->
-                           FStar_Syntax_Unionfind.univ_change u'' ur
-                       | (FStar_Syntax_Syntax.U_name n1,
-                          FStar_Syntax_Syntax.U_name n2) when
-                           FStar_Ident.ident_equals n1 n2 -> ()
-                       | uu___7 ->
-                           let uu___8 =
-                             let uu___9 =
-                               let uu___10 =
-                                 FStar_Syntax_Print.fv_to_string fv1 in
-                               let uu___11 =
-                                 FStar_Syntax_Print.univ_to_string ul in
-                               let uu___12 =
-                                 FStar_Syntax_Print.univ_to_string ur in
-                               FStar_Compiler_Util.format3
-                                 "Incompatible universe application for %s, expected %s got %s\n"
-                                 uu___10 uu___11 uu___12 in
-                             (FStar_Errors.Fatal_IncompatibleUniverse,
-                               uu___9) in
-                           let uu___9 = FStar_TypeChecker_Env.get_range env1 in
-                           FStar_Errors.raise_error uu___8 uu___9) us' us1;
-                FStar_TypeChecker_Env.insert_fv_info env1 fv1 t;
-                (let e1 =
-                   let uu___8 =
-                     FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv1)
-                       e.FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk_Tm_uinst uu___8 us1 in
-                 check_instantiated_fvar env1 fv1.FStar_Syntax_Syntax.fv_name
-                   fv1.FStar_Syntax_Syntax.fv_qual e1 t)))
-      | FStar_Syntax_Syntax.Tm_uinst (uu___, us) ->
-          let uu___1 = FStar_TypeChecker_Env.get_range env1 in
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_UnexpectedNumberOfUniverse,
-              "Universe applications are only allowed on top-level identifiers")
-            uu___1
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let uu___ =
-            FStar_TypeChecker_Env.lookup_lid env1
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___ with
-           | ((us, t), range) ->
-               let fv1 = FStar_Syntax_Syntax.set_range_of_fv fv range in
-               (maybe_warn_on_use env1 fv1;
-                (let uu___3 =
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_TypeChecker_Env.debug env1)
-                     (FStar_Options.Other "Range") in
-                 if uu___3
-                 then
-                   let uu___4 =
-                     let uu___5 = FStar_Syntax_Syntax.lid_of_fv fv1 in
-                     FStar_Syntax_Print.lid_to_string uu___5 in
-                   let uu___5 =
-                     FStar_Compiler_Range.string_of_range
-                       e.FStar_Syntax_Syntax.pos in
-                   let uu___6 = FStar_Compiler_Range.string_of_range range in
-                   let uu___7 =
-                     FStar_Compiler_Range.string_of_use_range range in
-                   let uu___8 = FStar_Syntax_Print.term_to_string t in
-                   FStar_Compiler_Util.print5
-                     "Lookup up fvar %s at location %s (lid range = defined at %s, used at %s); got universes type %s\n"
-                     uu___4 uu___5 uu___6 uu___7 uu___8
-                 else ());
-                FStar_TypeChecker_Env.insert_fv_info env1 fv1 t;
-                (let e1 =
-                   let uu___4 =
-                     FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv1)
-                       e.FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk_Tm_uinst uu___4 us in
-                 check_instantiated_fvar env1 fv1.FStar_Syntax_Syntax.fv_name
-                   fv1.FStar_Syntax_Syntax.fv_qual e1 t)))
-      | FStar_Syntax_Syntax.Tm_constant c ->
-          let t = tc_constant env1 top.FStar_Syntax_Syntax.pos c in
-          let e1 =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_constant c)
-              e.FStar_Syntax_Syntax.pos in
-          value_check_expected_typ env1 e1 (FStar_Pervasives.Inl t)
-            FStar_TypeChecker_Env.trivial_guard
-      | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-          let uu___ = FStar_Syntax_Subst.open_comp bs c in
-          (match uu___ with
-           | (bs1, c1) ->
-               let env0 = env1 in
-               let uu___1 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-               (match uu___1 with
-                | (env2, uu___2) ->
-                    let uu___3 = tc_binders env2 bs1 in
-                    (match uu___3 with
-                     | (bs2, env3, g, us) ->
-                         let uu___4 = tc_comp env3 c1 in
-                         (match uu___4 with
-                          | (c2, uc, f) ->
-                              let e1 =
-                                let uu___5 = FStar_Syntax_Util.arrow bs2 c2 in
-                                {
-                                  FStar_Syntax_Syntax.n =
-                                    (uu___5.FStar_Syntax_Syntax.n);
-                                  FStar_Syntax_Syntax.pos =
-                                    (top.FStar_Syntax_Syntax.pos);
-                                  FStar_Syntax_Syntax.vars =
-                                    (uu___5.FStar_Syntax_Syntax.vars);
-                                  FStar_Syntax_Syntax.hash_code =
-                                    (uu___5.FStar_Syntax_Syntax.hash_code)
-                                } in
-                              (check_smt_pat env3 e1 bs2 c2;
-                               (let u = FStar_Syntax_Syntax.U_max (uc :: us) in
-                                let t =
-                                  FStar_Syntax_Syntax.mk
-                                    (FStar_Syntax_Syntax.Tm_type u)
-                                    top.FStar_Syntax_Syntax.pos in
-                                let g1 =
-                                  let uu___6 =
-                                    FStar_TypeChecker_Env.close_guard_univs
-                                      us bs2 f in
-                                  FStar_TypeChecker_Env.conj_guard g uu___6 in
-                                let g2 =
-                                  FStar_TypeChecker_Util.close_guard_implicits
-                                    env3 false bs2 g1 in
-                                value_check_expected_typ env0 e1
-                                  (FStar_Pervasives.Inl t) g2))))))
-      | FStar_Syntax_Syntax.Tm_type u ->
-          let u1 = tc_universe env1 u in
-          let t =
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_type (FStar_Syntax_Syntax.U_succ u1))
-              top.FStar_Syntax_Syntax.pos in
-          let e1 =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u1)
-              top.FStar_Syntax_Syntax.pos in
-          value_check_expected_typ env1 e1 (FStar_Pervasives.Inl t)
-            FStar_TypeChecker_Env.trivial_guard
-      | FStar_Syntax_Syntax.Tm_refine (x, phi) ->
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Syntax.mk_binder x in [uu___2] in
-            FStar_Syntax_Subst.open_term uu___1 phi in
-          (match uu___ with
-           | (x1, phi1) ->
-               let env0 = env1 in
-               let uu___1 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-               (match uu___1 with
-                | (env2, uu___2) ->
-                    let uu___3 =
-                      let uu___4 = FStar_Compiler_List.hd x1 in
-                      tc_binder env2 uu___4 in
-                    (match uu___3 with
-                     | (x2, env3, f1, u) ->
-                         ((let uu___5 =
-                             FStar_TypeChecker_Env.debug env3
-                               FStar_Options.High in
-                           if uu___5
-                           then
-                             let uu___6 =
-                               FStar_Compiler_Range.string_of_range
-                                 top.FStar_Syntax_Syntax.pos in
-                             let uu___7 =
-                               FStar_Syntax_Print.term_to_string phi1 in
-                             let uu___8 =
-                               FStar_Syntax_Print.bv_to_string
-                                 x2.FStar_Syntax_Syntax.binder_bv in
-                             FStar_Compiler_Util.print3
-                               "(%s) Checking refinement formula %s; binder is %s\n"
-                               uu___6 uu___7 uu___8
-                           else ());
-                          (let uu___5 = FStar_Syntax_Util.type_u () in
-                           match uu___5 with
-                           | (t_phi, uu___6) ->
-                               let uu___7 =
-                                 tc_check_tot_or_gtot_term env3 phi1 t_phi
-                                   "refinement formula must be pure or ghost" in
-                               (match uu___7 with
-                                | (phi2, uu___8, f2) ->
-                                    let e1 =
-                                      let uu___9 =
-                                        FStar_Syntax_Util.refine
-                                          x2.FStar_Syntax_Syntax.binder_bv
-                                          phi2 in
-                                      {
-                                        FStar_Syntax_Syntax.n =
-                                          (uu___9.FStar_Syntax_Syntax.n);
-                                        FStar_Syntax_Syntax.pos =
-                                          (top.FStar_Syntax_Syntax.pos);
-                                        FStar_Syntax_Syntax.vars =
-                                          (uu___9.FStar_Syntax_Syntax.vars);
-                                        FStar_Syntax_Syntax.hash_code =
-                                          (uu___9.FStar_Syntax_Syntax.hash_code)
-                                      } in
-                                    let t =
-                                      FStar_Syntax_Syntax.mk
-                                        (FStar_Syntax_Syntax.Tm_type u)
-                                        top.FStar_Syntax_Syntax.pos in
-                                    let g =
-                                      let uu___9 =
-                                        FStar_TypeChecker_Env.close_guard_univs
-                                          [u] [x2] f2 in
-                                      FStar_TypeChecker_Env.conj_guard f1
-                                        uu___9 in
-                                    let g1 =
-                                      FStar_TypeChecker_Util.close_guard_implicits
-                                        env3 false [x2] g in
-                                    value_check_expected_typ env0 e1
-                                      (FStar_Pervasives.Inl t) g1))))))
-      | FStar_Syntax_Syntax.Tm_abs (bs, body, uu___) ->
-          let bs1 = FStar_TypeChecker_Util.maybe_add_implicit_binders env1 bs in
-          ((let uu___2 =
-              FStar_TypeChecker_Env.debug env1 FStar_Options.Medium in
-            if uu___2
-            then
-              let uu___3 =
-                FStar_Syntax_Print.term_to_string
-                  {
-                    FStar_Syntax_Syntax.n =
-                      (FStar_Syntax_Syntax.Tm_abs
-                         (bs1, body, FStar_Pervasives_Native.None));
-                    FStar_Syntax_Syntax.pos = (top.FStar_Syntax_Syntax.pos);
-                    FStar_Syntax_Syntax.vars = (top.FStar_Syntax_Syntax.vars);
-                    FStar_Syntax_Syntax.hash_code =
-                      (top.FStar_Syntax_Syntax.hash_code)
-                  } in
-              FStar_Compiler_Util.print1 "Abstraction is: %s\n" uu___3
-            else ());
-           (let uu___2 = FStar_Syntax_Subst.open_term bs1 body in
-            match uu___2 with | (bs2, body1) -> tc_abs env1 top bs2 body1))
-      | uu___ ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.term_to_string top in
-            let uu___3 = FStar_Syntax_Print.tag_of_term top in
-            FStar_Compiler_Util.format2 "Unexpected value: %s (%s)" uu___2
-              uu___3 in
-          failwith uu___1
-and (tc_constant :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Const.sconst -> FStar_Syntax_Syntax.typ)
-  =
-  fun env ->
-    fun r ->
-      fun c ->
-        let res =
-          match c with
-          | FStar_Const.Const_unit -> FStar_Syntax_Syntax.t_unit
-          | FStar_Const.Const_bool uu___ -> FStar_Syntax_Util.t_bool
-          | FStar_Const.Const_int (uu___, FStar_Pervasives_Native.None) ->
-              FStar_Syntax_Syntax.t_int
-          | FStar_Const.Const_int (uu___, FStar_Pervasives_Native.Some msize)
-              ->
-              FStar_Syntax_Syntax.tconst
-                (match msize with
-                 | (FStar_Const.Signed, FStar_Const.Int8) ->
-                     FStar_Parser_Const.int8_lid
-                 | (FStar_Const.Signed, FStar_Const.Int16) ->
-                     FStar_Parser_Const.int16_lid
-                 | (FStar_Const.Signed, FStar_Const.Int32) ->
-                     FStar_Parser_Const.int32_lid
-                 | (FStar_Const.Signed, FStar_Const.Int64) ->
-                     FStar_Parser_Const.int64_lid
-                 | (FStar_Const.Unsigned, FStar_Const.Int8) ->
-                     FStar_Parser_Const.uint8_lid
-                 | (FStar_Const.Unsigned, FStar_Const.Int16) ->
-                     FStar_Parser_Const.uint16_lid
-                 | (FStar_Const.Unsigned, FStar_Const.Int32) ->
-                     FStar_Parser_Const.uint32_lid
-                 | (FStar_Const.Unsigned, FStar_Const.Int64) ->
-                     FStar_Parser_Const.uint64_lid)
-          | FStar_Const.Const_string uu___ -> FStar_Syntax_Syntax.t_string
-          | FStar_Const.Const_real uu___ -> FStar_Syntax_Syntax.t_real
-          | FStar_Const.Const_char uu___ ->
-              let uu___1 =
-                FStar_Syntax_DsEnv.try_lookup_lid
-                  env.FStar_TypeChecker_Env.dsenv FStar_Parser_Const.char_lid in
-              FStar_Compiler_Effect.op_Bar_Greater uu___1
-                FStar_Compiler_Util.must
-          | FStar_Const.Const_effect -> FStar_Syntax_Util.ktype0
-          | FStar_Const.Const_range uu___ -> FStar_Syntax_Syntax.t_range
-          | FStar_Const.Const_range_of ->
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Parser_Const.const_to_string c in
-                  FStar_Compiler_Util.format1
-                    "Ill-typed %s: this constant must be fully applied"
-                    uu___2 in
-                (FStar_Errors.Fatal_IllTyped, uu___1) in
-              FStar_Errors.raise_error uu___ r
-          | FStar_Const.Const_set_range_of ->
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Parser_Const.const_to_string c in
-                  FStar_Compiler_Util.format1
-                    "Ill-typed %s: this constant must be fully applied"
-                    uu___2 in
-                (FStar_Errors.Fatal_IllTyped, uu___1) in
-              FStar_Errors.raise_error uu___ r
-          | FStar_Const.Const_reify ->
-              let uu___ =
-                let uu___1 =
-                  let uu___2 = FStar_Parser_Const.const_to_string c in
-                  FStar_Compiler_Util.format1
-                    "Ill-typed %s: this constant must be fully applied"
-                    uu___2 in
-                (FStar_Errors.Fatal_IllTyped, uu___1) in
-              FStar_Errors.raise_error uu___ r
-          | FStar_Const.Const_reflect uu___ ->
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = FStar_Parser_Const.const_to_string c in
-                  FStar_Compiler_Util.format1
-                    "Ill-typed %s: this constant must be fully applied"
-                    uu___3 in
-                (FStar_Errors.Fatal_IllTyped, uu___2) in
-              FStar_Errors.raise_error uu___1 r
-          | uu___ ->
-              FStar_Errors.raise_error
-                (FStar_Errors.Fatal_UnsupportedConstant,
-                  "Unsupported constant") r in
-        FStar_Syntax_Subst.set_use_range r res
-and (tc_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      (FStar_Syntax_Syntax.comp * FStar_Syntax_Syntax.universe *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c ->
-      let c0 = c in
-      match c.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Total t ->
-          let uu___ = FStar_Syntax_Util.type_u () in
-          (match uu___ with
-           | (k, u) ->
-               let uu___1 = tc_check_tot_or_gtot_term env t k "" in
-               (match uu___1 with
-                | (t1, uu___2, g) ->
-                    let uu___3 = FStar_Syntax_Syntax.mk_Total t1 in
-                    (uu___3, u, g)))
-      | FStar_Syntax_Syntax.GTotal t ->
-          let uu___ = FStar_Syntax_Util.type_u () in
-          (match uu___ with
-           | (k, u) ->
-               let uu___1 = tc_check_tot_or_gtot_term env t k "" in
-               (match uu___1 with
-                | (t1, uu___2, g) ->
-                    let uu___3 = FStar_Syntax_Syntax.mk_GTotal t1 in
-                    (uu___3, u, g)))
-      | FStar_Syntax_Syntax.Comp c1 ->
-          let head =
-            FStar_Syntax_Syntax.fvar c1.FStar_Syntax_Syntax.effect_name
-              FStar_Syntax_Syntax.delta_constant FStar_Pervasives_Native.None in
-          let head1 =
-            match c1.FStar_Syntax_Syntax.comp_univs with
-            | [] -> head
-            | us ->
-                FStar_Syntax_Syntax.mk
-                  (FStar_Syntax_Syntax.Tm_uinst (head, us))
-                  c0.FStar_Syntax_Syntax.pos in
-          let tc =
-            let uu___ =
-              let uu___1 =
-                FStar_Syntax_Syntax.as_arg c1.FStar_Syntax_Syntax.result_typ in
-              uu___1 :: (c1.FStar_Syntax_Syntax.effect_args) in
-            FStar_Syntax_Syntax.mk_Tm_app head1 uu___
-              (c1.FStar_Syntax_Syntax.result_typ).FStar_Syntax_Syntax.pos in
-          let uu___ =
-            tc_check_tot_or_gtot_term
-              {
-                FStar_TypeChecker_Env.solver =
-                  (env.FStar_TypeChecker_Env.solver);
-                FStar_TypeChecker_Env.range =
-                  (env.FStar_TypeChecker_Env.range);
-                FStar_TypeChecker_Env.curmodule =
-                  (env.FStar_TypeChecker_Env.curmodule);
-                FStar_TypeChecker_Env.gamma =
-                  (env.FStar_TypeChecker_Env.gamma);
-                FStar_TypeChecker_Env.gamma_sig =
-                  (env.FStar_TypeChecker_Env.gamma_sig);
-                FStar_TypeChecker_Env.gamma_cache =
-                  (env.FStar_TypeChecker_Env.gamma_cache);
-                FStar_TypeChecker_Env.modules =
-                  (env.FStar_TypeChecker_Env.modules);
-                FStar_TypeChecker_Env.expected_typ =
-                  (env.FStar_TypeChecker_Env.expected_typ);
-                FStar_TypeChecker_Env.sigtab =
-                  (env.FStar_TypeChecker_Env.sigtab);
-                FStar_TypeChecker_Env.attrtab =
-                  (env.FStar_TypeChecker_Env.attrtab);
-                FStar_TypeChecker_Env.instantiate_imp =
-                  (env.FStar_TypeChecker_Env.instantiate_imp);
-                FStar_TypeChecker_Env.effects =
-                  (env.FStar_TypeChecker_Env.effects);
-                FStar_TypeChecker_Env.generalize =
-                  (env.FStar_TypeChecker_Env.generalize);
-                FStar_TypeChecker_Env.letrecs =
-                  (env.FStar_TypeChecker_Env.letrecs);
-                FStar_TypeChecker_Env.top_level =
-                  (env.FStar_TypeChecker_Env.top_level);
-                FStar_TypeChecker_Env.check_uvars =
-                  (env.FStar_TypeChecker_Env.check_uvars);
-                FStar_TypeChecker_Env.use_eq_strict =
-                  (env.FStar_TypeChecker_Env.use_eq_strict);
-                FStar_TypeChecker_Env.is_iface =
-                  (env.FStar_TypeChecker_Env.is_iface);
-                FStar_TypeChecker_Env.admit =
-                  (env.FStar_TypeChecker_Env.admit);
-                FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-                FStar_TypeChecker_Env.lax_universes =
-                  (env.FStar_TypeChecker_Env.lax_universes);
-                FStar_TypeChecker_Env.phase1 =
-                  (env.FStar_TypeChecker_Env.phase1);
-                FStar_TypeChecker_Env.failhard = true;
-                FStar_TypeChecker_Env.nosynth =
-                  (env.FStar_TypeChecker_Env.nosynth);
-                FStar_TypeChecker_Env.uvar_subtyping =
-                  (env.FStar_TypeChecker_Env.uvar_subtyping);
-                FStar_TypeChecker_Env.tc_term =
-                  (env.FStar_TypeChecker_Env.tc_term);
-                FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                  (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                FStar_TypeChecker_Env.universe_of =
-                  (env.FStar_TypeChecker_Env.universe_of);
-                FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                  (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                FStar_TypeChecker_Env.teq_nosmt_force =
-                  (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                FStar_TypeChecker_Env.subtype_nosmt_force =
-                  (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                FStar_TypeChecker_Env.qtbl_name_and_index =
-                  (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                FStar_TypeChecker_Env.normalized_eff_names =
-                  (env.FStar_TypeChecker_Env.normalized_eff_names);
-                FStar_TypeChecker_Env.fv_delta_depths =
-                  (env.FStar_TypeChecker_Env.fv_delta_depths);
-                FStar_TypeChecker_Env.proof_ns =
-                  (env.FStar_TypeChecker_Env.proof_ns);
-                FStar_TypeChecker_Env.synth_hook =
-                  (env.FStar_TypeChecker_Env.synth_hook);
-                FStar_TypeChecker_Env.try_solve_implicits_hook =
-                  (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                FStar_TypeChecker_Env.splice =
-                  (env.FStar_TypeChecker_Env.splice);
-                FStar_TypeChecker_Env.mpreprocess =
-                  (env.FStar_TypeChecker_Env.mpreprocess);
-                FStar_TypeChecker_Env.postprocess =
-                  (env.FStar_TypeChecker_Env.postprocess);
-                FStar_TypeChecker_Env.identifier_info =
-                  (env.FStar_TypeChecker_Env.identifier_info);
-                FStar_TypeChecker_Env.tc_hooks =
-                  (env.FStar_TypeChecker_Env.tc_hooks);
-                FStar_TypeChecker_Env.dsenv =
-                  (env.FStar_TypeChecker_Env.dsenv);
-                FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-                FStar_TypeChecker_Env.strict_args_tab =
-                  (env.FStar_TypeChecker_Env.strict_args_tab);
-                FStar_TypeChecker_Env.erasable_types_tab =
-                  (env.FStar_TypeChecker_Env.erasable_types_tab);
-                FStar_TypeChecker_Env.enable_defer_to_tac =
-                  (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                FStar_TypeChecker_Env.unif_allow_ref_guards =
-                  (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                FStar_TypeChecker_Env.erase_erasable_args =
-                  (env.FStar_TypeChecker_Env.erase_erasable_args);
-                FStar_TypeChecker_Env.core_check =
-                  (env.FStar_TypeChecker_Env.core_check)
-              } tc FStar_Syntax_Syntax.teff "" in
-          (match uu___ with
-           | (tc1, uu___1, f) ->
-               let uu___2 = FStar_Syntax_Util.head_and_args tc1 in
-               (match uu___2 with
-                | (head2, args) ->
-                    let comp_univs =
-                      let uu___3 =
-                        let uu___4 = FStar_Syntax_Subst.compress head2 in
-                        uu___4.FStar_Syntax_Syntax.n in
-                      match uu___3 with
-                      | FStar_Syntax_Syntax.Tm_uinst (uu___4, us) -> us
-                      | uu___4 -> [] in
-                    let uu___3 = FStar_Syntax_Util.head_and_args tc1 in
-                    (match uu___3 with
-                     | (uu___4, args1) ->
-                         let uu___5 =
-                           let uu___6 = FStar_Compiler_List.hd args1 in
-                           let uu___7 = FStar_Compiler_List.tl args1 in
-                           (uu___6, uu___7) in
-                         (match uu___5 with
-                          | (res, args2) ->
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    c1.FStar_Syntax_Syntax.flags
-                                    (FStar_Compiler_List.map
-                                       (fun uu___8 ->
-                                          match uu___8 with
-                                          | FStar_Syntax_Syntax.DECREASES
-                                              (FStar_Syntax_Syntax.Decreases_lex
-                                              l) ->
-                                              let uu___9 =
-                                                FStar_TypeChecker_Env.clear_expected_typ
-                                                  env in
-                                              (match uu___9 with
-                                               | (env1, uu___10) ->
-                                                   let uu___11 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       l
-                                                       (FStar_Compiler_List.fold_left
-                                                          (fun uu___12 ->
-                                                             fun e ->
-                                                               match uu___12
-                                                               with
-                                                               | (l1, g) ->
-                                                                   let uu___13
-                                                                    =
-                                                                    tc_tot_or_gtot_term
-                                                                    env1 e in
-                                                                   (match uu___13
-                                                                    with
-                                                                    | 
-                                                                    (e1,
-                                                                    uu___14,
-                                                                    g_e) ->
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guard
-                                                                    g g_e in
-                                                                    ((FStar_Compiler_List.op_At
-                                                                    l1 [e1]),
-                                                                    uu___15)))
-                                                          ([],
-                                                            FStar_TypeChecker_Env.trivial_guard)) in
-                                                   (match uu___11 with
-                                                    | (l1, g) ->
-                                                        ((FStar_Syntax_Syntax.DECREASES
-                                                            (FStar_Syntax_Syntax.Decreases_lex
-                                                               l1)), g)))
-                                          | FStar_Syntax_Syntax.DECREASES
-                                              (FStar_Syntax_Syntax.Decreases_wf
-                                              (rel, e)) ->
-                                              let uu___9 =
-                                                FStar_TypeChecker_Env.clear_expected_typ
-                                                  env in
-                                              (match uu___9 with
-                                               | (env1, uu___10) ->
-                                                   let uu___11 =
-                                                     FStar_Syntax_Util.type_u
-                                                       () in
-                                                   (match uu___11 with
-                                                    | (t, u_t) ->
-                                                        let u_r =
-                                                          FStar_TypeChecker_Env.new_u_univ
-                                                            () in
-                                                        let uu___12 =
-                                                          FStar_TypeChecker_Util.new_implicit_var
-                                                            "implicit for type of the well-founded relation in decreases clause"
-                                                            rel.FStar_Syntax_Syntax.pos
-                                                            env1 t in
-                                                        (match uu___12 with
-                                                         | (a, uu___13, g_a)
-                                                             ->
-                                                             let wf_t =
-                                                               let uu___14 =
-                                                                 let uu___15
-                                                                   =
-                                                                   FStar_TypeChecker_Env.fvar_of_nonqual_lid
-                                                                    env1
-                                                                    FStar_Parser_Const.well_founded_relation_lid in
-                                                                 FStar_Syntax_Syntax.mk_Tm_uinst
-                                                                   uu___15
-                                                                   [u_t; u_r] in
-                                                               let uu___15 =
-                                                                 let uu___16
-                                                                   =
-                                                                   FStar_Syntax_Syntax.as_arg
-                                                                    a in
-                                                                 [uu___16] in
-                                                               FStar_Syntax_Syntax.mk_Tm_app
-                                                                 uu___14
-                                                                 uu___15
-                                                                 rel.FStar_Syntax_Syntax.pos in
-                                                             let uu___14 =
-                                                               let uu___15 =
-                                                                 FStar_TypeChecker_Env.set_expected_typ
-                                                                   env1 wf_t in
-                                                               tc_tot_or_gtot_term
-                                                                 uu___15 rel in
-                                                             (match uu___14
-                                                              with
-                                                              | (rel1,
-                                                                 uu___15,
-                                                                 g_rel) ->
-                                                                  let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_Env.set_expected_typ
-                                                                    env1 a in
-                                                                    tc_tot_or_gtot_term
-                                                                    uu___17 e in
-                                                                  (match uu___16
-                                                                   with
-                                                                   | 
-                                                                   (e1,
-                                                                    uu___17,
-                                                                    g_e) ->
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guards
-                                                                    [g_a;
-                                                                    g_rel;
-                                                                    g_e] in
-                                                                    ((FStar_Syntax_Syntax.DECREASES
-                                                                    (FStar_Syntax_Syntax.Decreases_wf
-                                                                    (rel1,
-                                                                    e1))),
-                                                                    uu___18))))))
-                                          | f1 ->
-                                              (f1,
-                                                FStar_TypeChecker_Env.trivial_guard))) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                  FStar_Compiler_List.unzip in
-                              (match uu___6 with
-                               | (flags, guards) ->
-                                   let u =
-                                     env.FStar_TypeChecker_Env.universe_of
-                                       env (FStar_Pervasives_Native.fst res) in
-                                   let c2 =
-                                     FStar_Syntax_Syntax.mk_Comp
-                                       {
-                                         FStar_Syntax_Syntax.comp_univs =
-                                           comp_univs;
-                                         FStar_Syntax_Syntax.effect_name =
-                                           (c1.FStar_Syntax_Syntax.effect_name);
-                                         FStar_Syntax_Syntax.result_typ =
-                                           (FStar_Pervasives_Native.fst res);
-                                         FStar_Syntax_Syntax.effect_args =
-                                           args2;
-                                         FStar_Syntax_Syntax.flags = flags
-                                       } in
-                                   let u_c =
-                                     FStar_Compiler_Effect.op_Bar_Greater c2
-                                       (FStar_TypeChecker_Util.universe_of_comp
-                                          env u) in
-                                   let uu___7 =
-                                     FStar_Compiler_List.fold_left
-                                       FStar_TypeChecker_Env.conj_guard f
-                                       guards in
-                                   (c2, u_c, uu___7))))))
-and (tc_universe :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.universe -> FStar_Syntax_Syntax.universe)
-  =
-  fun env ->
-    fun u ->
-      let rec aux u1 =
-        let u2 = FStar_Syntax_Subst.compress_univ u1 in
-        match u2 with
-        | FStar_Syntax_Syntax.U_bvar uu___ ->
-            failwith "Impossible: locally nameless"
-        | FStar_Syntax_Syntax.U_unknown -> failwith "Unknown universe"
-        | FStar_Syntax_Syntax.U_unif uu___ -> u2
-        | FStar_Syntax_Syntax.U_zero -> u2
-        | FStar_Syntax_Syntax.U_succ u3 ->
-            let uu___ = aux u3 in FStar_Syntax_Syntax.U_succ uu___
-        | FStar_Syntax_Syntax.U_max us ->
-            let uu___ = FStar_Compiler_List.map aux us in
-            FStar_Syntax_Syntax.U_max uu___
-        | FStar_Syntax_Syntax.U_name x ->
-            let uu___ = FStar_TypeChecker_Env.lookup_univ env x in
-            if uu___
-            then u2
-            else
-              (let uu___2 =
-                 let uu___3 =
-                   let uu___4 = FStar_Syntax_Print.univ_to_string u2 in
-                   Prims.op_Hat uu___4 " not found" in
-                 Prims.op_Hat "Universe variable " uu___3 in
-               failwith uu___2) in
-      if env.FStar_TypeChecker_Env.lax_universes
-      then FStar_Syntax_Syntax.U_zero
-      else
-        (match u with
-         | FStar_Syntax_Syntax.U_unknown ->
-             let uu___1 = FStar_Syntax_Util.type_u () in
-             FStar_Compiler_Effect.op_Bar_Greater uu___1
-               FStar_Pervasives_Native.snd
-         | uu___1 -> aux u)
-and (tc_abs_expected_function_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      (FStar_Syntax_Syntax.typ * Prims.bool) FStar_Pervasives_Native.option
-        ->
-        FStar_Syntax_Syntax.term ->
-          (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option *
-            FStar_Syntax_Syntax.binders * FStar_Syntax_Syntax.binders *
-            FStar_Syntax_Syntax.comp FStar_Pervasives_Native.option *
-            FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.term *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun bs ->
-      fun t0 ->
-        fun body ->
-          match t0 with
-          | FStar_Pervasives_Native.None ->
-              ((match env.FStar_TypeChecker_Env.letrecs with
-                | [] -> ()
-                | uu___1 ->
-                    failwith
-                      "Impossible: Can't have a let rec annotation but no expected type");
-               (let uu___1 = tc_binders env bs in
-                match uu___1 with
-                | (bs1, envbody, g_env, uu___2) ->
-                    (FStar_Pervasives_Native.None, bs1, [],
-                      FStar_Pervasives_Native.None, envbody, body, g_env)))
-          | FStar_Pervasives_Native.Some (t, use_eq) ->
-              let t1 = FStar_Syntax_Subst.compress t in
-              let rec as_function_typ norm1 t2 =
-                let uu___ =
-                  let uu___1 = FStar_Syntax_Subst.compress t2 in
-                  uu___1.FStar_Syntax_Syntax.n in
-                match uu___ with
-                | FStar_Syntax_Syntax.Tm_uvar uu___1 ->
-                    ((match env.FStar_TypeChecker_Env.letrecs with
-                      | [] -> ()
-                      | uu___3 -> failwith "Impossible");
-                     (let uu___3 = tc_binders env bs in
-                      match uu___3 with
-                      | (bs1, envbody, g_env, uu___4) ->
-                          let uu___5 =
-                            FStar_TypeChecker_Env.clear_expected_typ envbody in
-                          (match uu___5 with
-                           | (envbody1, uu___6) ->
-                               ((FStar_Pervasives_Native.Some t2), bs1, [],
-                                 FStar_Pervasives_Native.None, envbody1,
-                                 body, g_env))))
-                | FStar_Syntax_Syntax.Tm_app
-                    ({
-                       FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar
-                         uu___1;
-                       FStar_Syntax_Syntax.pos = uu___2;
-                       FStar_Syntax_Syntax.vars = uu___3;
-                       FStar_Syntax_Syntax.hash_code = uu___4;_},
-                     uu___5)
-                    ->
-                    ((match env.FStar_TypeChecker_Env.letrecs with
-                      | [] -> ()
-                      | uu___7 -> failwith "Impossible");
-                     (let uu___7 = tc_binders env bs in
-                      match uu___7 with
-                      | (bs1, envbody, g_env, uu___8) ->
-                          let uu___9 =
-                            FStar_TypeChecker_Env.clear_expected_typ envbody in
-                          (match uu___9 with
-                           | (envbody1, uu___10) ->
-                               ((FStar_Pervasives_Native.Some t2), bs1, [],
-                                 FStar_Pervasives_Native.None, envbody1,
-                                 body, g_env))))
-                | FStar_Syntax_Syntax.Tm_refine (b, uu___1) ->
-                    let uu___2 =
-                      as_function_typ norm1 b.FStar_Syntax_Syntax.sort in
-                    (match uu___2 with
-                     | (uu___3, bs1, bs', copt, env_body, body1, g_env) ->
-                         ((FStar_Pervasives_Native.Some t2), bs1, bs', copt,
-                           env_body, body1, g_env))
-                | FStar_Syntax_Syntax.Tm_arrow (bs_expected, c_expected) ->
-                    let uu___1 =
-                      FStar_Syntax_Subst.open_comp bs_expected c_expected in
-                    (match uu___1 with
-                     | (bs_expected1, c_expected1) ->
-                         let check_actuals_against_formals env1 bs1
-                           bs_expected2 body1 =
-                           let rec handle_more uu___2 c_expected2 body2 =
-                             match uu___2 with
-                             | (env_bs, bs2, more, guard_env, subst) ->
-                                 (match more with
-                                  | FStar_Pervasives_Native.None ->
-                                      let uu___3 =
-                                        FStar_Syntax_Subst.subst_comp subst
-                                          c_expected2 in
-                                      (env_bs, bs2, guard_env, uu___3, body2)
-                                  | FStar_Pervasives_Native.Some
-                                      (FStar_Pervasives.Inr more_bs_expected)
-                                      ->
-                                      let c =
-                                        let uu___3 =
-                                          FStar_Syntax_Util.arrow
-                                            more_bs_expected c_expected2 in
-                                        FStar_Syntax_Syntax.mk_Total uu___3 in
-                                      let uu___3 =
-                                        FStar_Syntax_Subst.subst_comp subst c in
-                                      (env_bs, bs2, guard_env, uu___3, body2)
-                                  | FStar_Pervasives_Native.Some
-                                      (FStar_Pervasives.Inl more_bs) ->
-                                      let c =
-                                        FStar_Syntax_Subst.subst_comp subst
-                                          c_expected2 in
-                                      let uu___3 =
-                                        (FStar_Options.ml_ish ()) ||
-                                          (FStar_Syntax_Util.is_named_tot c) in
-                                      if uu___3
-                                      then
-                                        let t3 =
-                                          FStar_TypeChecker_Normalize.unfold_whnf
-                                            env_bs
-                                            (FStar_Syntax_Util.comp_result c) in
-                                        (match t3.FStar_Syntax_Syntax.n with
-                                         | FStar_Syntax_Syntax.Tm_arrow
-                                             (bs_expected3, c_expected3) ->
-                                             let uu___4 =
-                                               FStar_Syntax_Subst.open_comp
-                                                 bs_expected3 c_expected3 in
-                                             (match uu___4 with
-                                              | (bs_expected4, c_expected4)
-                                                  ->
-                                                  let uu___5 =
-                                                    tc_abs_check_binders
-                                                      env_bs more_bs
-                                                      bs_expected4 use_eq in
-                                                  (match uu___5 with
-                                                   | (env_bs_bs', bs', more1,
-                                                      guard'_env_bs, subst1)
-                                                       ->
-                                                       let guard'_env =
-                                                         FStar_TypeChecker_Env.close_guard
-                                                           env_bs bs2
-                                                           guard'_env_bs in
-                                                       let uu___6 =
-                                                         let uu___7 =
-                                                           FStar_TypeChecker_Env.conj_guard
-                                                             guard_env
-                                                             guard'_env in
-                                                         (env_bs_bs',
-                                                           (FStar_Compiler_List.op_At
-                                                              bs2 bs'),
-                                                           more1, uu___7,
-                                                           subst1) in
-                                                       handle_more uu___6
-                                                         c_expected4 body2))
-                                         | uu___4 ->
-                                             let body3 =
-                                               FStar_Syntax_Util.abs more_bs
-                                                 body2
-                                                 FStar_Pervasives_Native.None in
-                                             (env_bs, bs2, guard_env, c,
-                                               body3))
-                                      else
-                                        (let body3 =
-                                           FStar_Syntax_Util.abs more_bs
-                                             body2
-                                             FStar_Pervasives_Native.None in
-                                         (env_bs, bs2, guard_env, c, body3))) in
-                           let uu___2 =
-                             tc_abs_check_binders env1 bs1 bs_expected2
-                               use_eq in
-                           handle_more uu___2 c_expected1 body1 in
-                         let mk_letrec_env envbody bs1 c =
-                           let letrecs = guard_letrecs envbody bs1 c in
-                           let envbody1 =
-                             {
-                               FStar_TypeChecker_Env.solver =
-                                 (envbody.FStar_TypeChecker_Env.solver);
-                               FStar_TypeChecker_Env.range =
-                                 (envbody.FStar_TypeChecker_Env.range);
-                               FStar_TypeChecker_Env.curmodule =
-                                 (envbody.FStar_TypeChecker_Env.curmodule);
-                               FStar_TypeChecker_Env.gamma =
-                                 (envbody.FStar_TypeChecker_Env.gamma);
-                               FStar_TypeChecker_Env.gamma_sig =
-                                 (envbody.FStar_TypeChecker_Env.gamma_sig);
-                               FStar_TypeChecker_Env.gamma_cache =
-                                 (envbody.FStar_TypeChecker_Env.gamma_cache);
-                               FStar_TypeChecker_Env.modules =
-                                 (envbody.FStar_TypeChecker_Env.modules);
-                               FStar_TypeChecker_Env.expected_typ =
-                                 (envbody.FStar_TypeChecker_Env.expected_typ);
-                               FStar_TypeChecker_Env.sigtab =
-                                 (envbody.FStar_TypeChecker_Env.sigtab);
-                               FStar_TypeChecker_Env.attrtab =
-                                 (envbody.FStar_TypeChecker_Env.attrtab);
-                               FStar_TypeChecker_Env.instantiate_imp =
-                                 (envbody.FStar_TypeChecker_Env.instantiate_imp);
-                               FStar_TypeChecker_Env.effects =
-                                 (envbody.FStar_TypeChecker_Env.effects);
-                               FStar_TypeChecker_Env.generalize =
-                                 (envbody.FStar_TypeChecker_Env.generalize);
-                               FStar_TypeChecker_Env.letrecs = [];
-                               FStar_TypeChecker_Env.top_level =
-                                 (envbody.FStar_TypeChecker_Env.top_level);
-                               FStar_TypeChecker_Env.check_uvars =
-                                 (envbody.FStar_TypeChecker_Env.check_uvars);
-                               FStar_TypeChecker_Env.use_eq_strict =
-                                 (envbody.FStar_TypeChecker_Env.use_eq_strict);
-                               FStar_TypeChecker_Env.is_iface =
-                                 (envbody.FStar_TypeChecker_Env.is_iface);
-                               FStar_TypeChecker_Env.admit =
-                                 (envbody.FStar_TypeChecker_Env.admit);
-                               FStar_TypeChecker_Env.lax =
-                                 (envbody.FStar_TypeChecker_Env.lax);
-                               FStar_TypeChecker_Env.lax_universes =
-                                 (envbody.FStar_TypeChecker_Env.lax_universes);
-                               FStar_TypeChecker_Env.phase1 =
-                                 (envbody.FStar_TypeChecker_Env.phase1);
-                               FStar_TypeChecker_Env.failhard =
-                                 (envbody.FStar_TypeChecker_Env.failhard);
-                               FStar_TypeChecker_Env.nosynth =
-                                 (envbody.FStar_TypeChecker_Env.nosynth);
-                               FStar_TypeChecker_Env.uvar_subtyping =
-                                 (envbody.FStar_TypeChecker_Env.uvar_subtyping);
-                               FStar_TypeChecker_Env.tc_term =
-                                 (envbody.FStar_TypeChecker_Env.tc_term);
-                               FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                 =
-                                 (envbody.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                               FStar_TypeChecker_Env.universe_of =
-                                 (envbody.FStar_TypeChecker_Env.universe_of);
-                               FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                 =
-                                 (envbody.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                               FStar_TypeChecker_Env.teq_nosmt_force =
-                                 (envbody.FStar_TypeChecker_Env.teq_nosmt_force);
-                               FStar_TypeChecker_Env.subtype_nosmt_force =
-                                 (envbody.FStar_TypeChecker_Env.subtype_nosmt_force);
-                               FStar_TypeChecker_Env.qtbl_name_and_index =
-                                 (envbody.FStar_TypeChecker_Env.qtbl_name_and_index);
-                               FStar_TypeChecker_Env.normalized_eff_names =
-                                 (envbody.FStar_TypeChecker_Env.normalized_eff_names);
-                               FStar_TypeChecker_Env.fv_delta_depths =
-                                 (envbody.FStar_TypeChecker_Env.fv_delta_depths);
-                               FStar_TypeChecker_Env.proof_ns =
-                                 (envbody.FStar_TypeChecker_Env.proof_ns);
-                               FStar_TypeChecker_Env.synth_hook =
-                                 (envbody.FStar_TypeChecker_Env.synth_hook);
-                               FStar_TypeChecker_Env.try_solve_implicits_hook
-                                 =
-                                 (envbody.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                               FStar_TypeChecker_Env.splice =
-                                 (envbody.FStar_TypeChecker_Env.splice);
-                               FStar_TypeChecker_Env.mpreprocess =
-                                 (envbody.FStar_TypeChecker_Env.mpreprocess);
-                               FStar_TypeChecker_Env.postprocess =
-                                 (envbody.FStar_TypeChecker_Env.postprocess);
-                               FStar_TypeChecker_Env.identifier_info =
-                                 (envbody.FStar_TypeChecker_Env.identifier_info);
-                               FStar_TypeChecker_Env.tc_hooks =
-                                 (envbody.FStar_TypeChecker_Env.tc_hooks);
-                               FStar_TypeChecker_Env.dsenv =
-                                 (envbody.FStar_TypeChecker_Env.dsenv);
-                               FStar_TypeChecker_Env.nbe =
-                                 (envbody.FStar_TypeChecker_Env.nbe);
-                               FStar_TypeChecker_Env.strict_args_tab =
-                                 (envbody.FStar_TypeChecker_Env.strict_args_tab);
-                               FStar_TypeChecker_Env.erasable_types_tab =
-                                 (envbody.FStar_TypeChecker_Env.erasable_types_tab);
-                               FStar_TypeChecker_Env.enable_defer_to_tac =
-                                 (envbody.FStar_TypeChecker_Env.enable_defer_to_tac);
-                               FStar_TypeChecker_Env.unif_allow_ref_guards =
-                                 (envbody.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                               FStar_TypeChecker_Env.erase_erasable_args =
-                                 (envbody.FStar_TypeChecker_Env.erase_erasable_args);
-                               FStar_TypeChecker_Env.core_check =
-                                 (envbody.FStar_TypeChecker_Env.core_check)
-                             } in
-                           let uu___2 =
-                             FStar_Compiler_Effect.op_Bar_Greater letrecs
-                               (FStar_Compiler_List.fold_left
-                                  (fun uu___3 ->
-                                     fun uu___4 ->
-                                       match (uu___3, uu___4) with
-                                       | ((env1, letrec_binders, g),
-                                          (l, t3, u_names)) ->
-                                           let uu___5 =
-                                             let uu___6 =
-                                               let uu___7 =
-                                                 FStar_TypeChecker_Env.clear_expected_typ
-                                                   env1 in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___7
-                                                 FStar_Pervasives_Native.fst in
-                                             tc_term uu___6 t3 in
-                                           (match uu___5 with
-                                            | (t4, uu___6, g') ->
-                                                let env2 =
-                                                  FStar_TypeChecker_Env.push_let_binding
-                                                    env1 l (u_names, t4) in
-                                                let lb =
-                                                  match l with
-                                                  | FStar_Pervasives.Inl x ->
-                                                      let uu___7 =
-                                                        FStar_Syntax_Syntax.mk_binder
-                                                          {
-                                                            FStar_Syntax_Syntax.ppname
-                                                              =
-                                                              (x.FStar_Syntax_Syntax.ppname);
-                                                            FStar_Syntax_Syntax.index
-                                                              =
-                                                              (x.FStar_Syntax_Syntax.index);
-                                                            FStar_Syntax_Syntax.sort
-                                                              = t4
-                                                          } in
-                                                      uu___7 ::
-                                                        letrec_binders
-                                                  | uu___7 -> letrec_binders in
-                                                let uu___7 =
-                                                  FStar_TypeChecker_Env.conj_guard
-                                                    g g' in
-                                                (env2, lb, uu___7)))
-                                  (envbody1, [],
-                                    FStar_TypeChecker_Env.trivial_guard)) in
-                           match uu___2 with
-                           | (envbody2, letrec_binders, g) ->
-                               let uu___3 =
-                                 FStar_TypeChecker_Env.close_guard envbody2
-                                   bs1 g in
-                               (envbody2, letrec_binders, uu___3) in
-                         let envbody =
-                           {
-                             FStar_TypeChecker_Env.solver =
-                               (env.FStar_TypeChecker_Env.solver);
-                             FStar_TypeChecker_Env.range =
-                               (env.FStar_TypeChecker_Env.range);
-                             FStar_TypeChecker_Env.curmodule =
-                               (env.FStar_TypeChecker_Env.curmodule);
-                             FStar_TypeChecker_Env.gamma =
-                               (env.FStar_TypeChecker_Env.gamma);
-                             FStar_TypeChecker_Env.gamma_sig =
-                               (env.FStar_TypeChecker_Env.gamma_sig);
-                             FStar_TypeChecker_Env.gamma_cache =
-                               (env.FStar_TypeChecker_Env.gamma_cache);
-                             FStar_TypeChecker_Env.modules =
-                               (env.FStar_TypeChecker_Env.modules);
-                             FStar_TypeChecker_Env.expected_typ =
-                               (env.FStar_TypeChecker_Env.expected_typ);
-                             FStar_TypeChecker_Env.sigtab =
-                               (env.FStar_TypeChecker_Env.sigtab);
-                             FStar_TypeChecker_Env.attrtab =
-                               (env.FStar_TypeChecker_Env.attrtab);
-                             FStar_TypeChecker_Env.instantiate_imp =
-                               (env.FStar_TypeChecker_Env.instantiate_imp);
-                             FStar_TypeChecker_Env.effects =
-                               (env.FStar_TypeChecker_Env.effects);
-                             FStar_TypeChecker_Env.generalize =
-                               (env.FStar_TypeChecker_Env.generalize);
-                             FStar_TypeChecker_Env.letrecs = [];
-                             FStar_TypeChecker_Env.top_level =
-                               (env.FStar_TypeChecker_Env.top_level);
-                             FStar_TypeChecker_Env.check_uvars =
-                               (env.FStar_TypeChecker_Env.check_uvars);
-                             FStar_TypeChecker_Env.use_eq_strict =
-                               (env.FStar_TypeChecker_Env.use_eq_strict);
-                             FStar_TypeChecker_Env.is_iface =
-                               (env.FStar_TypeChecker_Env.is_iface);
-                             FStar_TypeChecker_Env.admit =
-                               (env.FStar_TypeChecker_Env.admit);
-                             FStar_TypeChecker_Env.lax =
-                               (env.FStar_TypeChecker_Env.lax);
-                             FStar_TypeChecker_Env.lax_universes =
-                               (env.FStar_TypeChecker_Env.lax_universes);
-                             FStar_TypeChecker_Env.phase1 =
-                               (env.FStar_TypeChecker_Env.phase1);
-                             FStar_TypeChecker_Env.failhard =
-                               (env.FStar_TypeChecker_Env.failhard);
-                             FStar_TypeChecker_Env.nosynth =
-                               (env.FStar_TypeChecker_Env.nosynth);
-                             FStar_TypeChecker_Env.uvar_subtyping =
-                               (env.FStar_TypeChecker_Env.uvar_subtyping);
-                             FStar_TypeChecker_Env.tc_term =
-                               (env.FStar_TypeChecker_Env.tc_term);
-                             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                               (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.universe_of =
-                               (env.FStar_TypeChecker_Env.universe_of);
-                             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                               =
-                               (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                             FStar_TypeChecker_Env.teq_nosmt_force =
-                               (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                             FStar_TypeChecker_Env.subtype_nosmt_force =
-                               (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                             FStar_TypeChecker_Env.qtbl_name_and_index =
-                               (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                             FStar_TypeChecker_Env.normalized_eff_names =
-                               (env.FStar_TypeChecker_Env.normalized_eff_names);
-                             FStar_TypeChecker_Env.fv_delta_depths =
-                               (env.FStar_TypeChecker_Env.fv_delta_depths);
-                             FStar_TypeChecker_Env.proof_ns =
-                               (env.FStar_TypeChecker_Env.proof_ns);
-                             FStar_TypeChecker_Env.synth_hook =
-                               (env.FStar_TypeChecker_Env.synth_hook);
-                             FStar_TypeChecker_Env.try_solve_implicits_hook =
-                               (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                             FStar_TypeChecker_Env.splice =
-                               (env.FStar_TypeChecker_Env.splice);
-                             FStar_TypeChecker_Env.mpreprocess =
-                               (env.FStar_TypeChecker_Env.mpreprocess);
-                             FStar_TypeChecker_Env.postprocess =
-                               (env.FStar_TypeChecker_Env.postprocess);
-                             FStar_TypeChecker_Env.identifier_info =
-                               (env.FStar_TypeChecker_Env.identifier_info);
-                             FStar_TypeChecker_Env.tc_hooks =
-                               (env.FStar_TypeChecker_Env.tc_hooks);
-                             FStar_TypeChecker_Env.dsenv =
-                               (env.FStar_TypeChecker_Env.dsenv);
-                             FStar_TypeChecker_Env.nbe =
-                               (env.FStar_TypeChecker_Env.nbe);
-                             FStar_TypeChecker_Env.strict_args_tab =
-                               (env.FStar_TypeChecker_Env.strict_args_tab);
-                             FStar_TypeChecker_Env.erasable_types_tab =
-                               (env.FStar_TypeChecker_Env.erasable_types_tab);
-                             FStar_TypeChecker_Env.enable_defer_to_tac =
-                               (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                             FStar_TypeChecker_Env.unif_allow_ref_guards =
-                               (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                             FStar_TypeChecker_Env.erase_erasable_args =
-                               (env.FStar_TypeChecker_Env.erase_erasable_args);
-                             FStar_TypeChecker_Env.core_check =
-                               (env.FStar_TypeChecker_Env.core_check)
-                           } in
-                         let uu___2 =
-                           check_actuals_against_formals envbody bs
-                             bs_expected1 body in
-                         (match uu___2 with
-                          | (envbody1, bs1, g_env, c, body1) ->
-                              let envbody2 =
-                                {
-                                  FStar_TypeChecker_Env.solver =
-                                    (envbody1.FStar_TypeChecker_Env.solver);
-                                  FStar_TypeChecker_Env.range =
-                                    (envbody1.FStar_TypeChecker_Env.range);
-                                  FStar_TypeChecker_Env.curmodule =
-                                    (envbody1.FStar_TypeChecker_Env.curmodule);
-                                  FStar_TypeChecker_Env.gamma =
-                                    (envbody1.FStar_TypeChecker_Env.gamma);
-                                  FStar_TypeChecker_Env.gamma_sig =
-                                    (envbody1.FStar_TypeChecker_Env.gamma_sig);
-                                  FStar_TypeChecker_Env.gamma_cache =
-                                    (envbody1.FStar_TypeChecker_Env.gamma_cache);
-                                  FStar_TypeChecker_Env.modules =
-                                    (envbody1.FStar_TypeChecker_Env.modules);
-                                  FStar_TypeChecker_Env.expected_typ =
-                                    (envbody1.FStar_TypeChecker_Env.expected_typ);
-                                  FStar_TypeChecker_Env.sigtab =
-                                    (envbody1.FStar_TypeChecker_Env.sigtab);
-                                  FStar_TypeChecker_Env.attrtab =
-                                    (envbody1.FStar_TypeChecker_Env.attrtab);
-                                  FStar_TypeChecker_Env.instantiate_imp =
-                                    (envbody1.FStar_TypeChecker_Env.instantiate_imp);
-                                  FStar_TypeChecker_Env.effects =
-                                    (envbody1.FStar_TypeChecker_Env.effects);
-                                  FStar_TypeChecker_Env.generalize =
-                                    (envbody1.FStar_TypeChecker_Env.generalize);
-                                  FStar_TypeChecker_Env.letrecs =
-                                    (env.FStar_TypeChecker_Env.letrecs);
-                                  FStar_TypeChecker_Env.top_level =
-                                    (envbody1.FStar_TypeChecker_Env.top_level);
-                                  FStar_TypeChecker_Env.check_uvars =
-                                    (envbody1.FStar_TypeChecker_Env.check_uvars);
-                                  FStar_TypeChecker_Env.use_eq_strict =
-                                    (envbody1.FStar_TypeChecker_Env.use_eq_strict);
-                                  FStar_TypeChecker_Env.is_iface =
-                                    (envbody1.FStar_TypeChecker_Env.is_iface);
-                                  FStar_TypeChecker_Env.admit =
-                                    (envbody1.FStar_TypeChecker_Env.admit);
-                                  FStar_TypeChecker_Env.lax =
-                                    (envbody1.FStar_TypeChecker_Env.lax);
-                                  FStar_TypeChecker_Env.lax_universes =
-                                    (envbody1.FStar_TypeChecker_Env.lax_universes);
-                                  FStar_TypeChecker_Env.phase1 =
-                                    (envbody1.FStar_TypeChecker_Env.phase1);
-                                  FStar_TypeChecker_Env.failhard =
-                                    (envbody1.FStar_TypeChecker_Env.failhard);
-                                  FStar_TypeChecker_Env.nosynth =
-                                    (envbody1.FStar_TypeChecker_Env.nosynth);
-                                  FStar_TypeChecker_Env.uvar_subtyping =
-                                    (envbody1.FStar_TypeChecker_Env.uvar_subtyping);
-                                  FStar_TypeChecker_Env.tc_term =
-                                    (envbody1.FStar_TypeChecker_Env.tc_term);
-                                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                    =
-                                    (envbody1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.universe_of =
-                                    (envbody1.FStar_TypeChecker_Env.universe_of);
-                                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                    =
-                                    (envbody1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.teq_nosmt_force =
-                                    (envbody1.FStar_TypeChecker_Env.teq_nosmt_force);
-                                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                                    (envbody1.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                                    (envbody1.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                  FStar_TypeChecker_Env.normalized_eff_names
-                                    =
-                                    (envbody1.FStar_TypeChecker_Env.normalized_eff_names);
-                                  FStar_TypeChecker_Env.fv_delta_depths =
-                                    (envbody1.FStar_TypeChecker_Env.fv_delta_depths);
-                                  FStar_TypeChecker_Env.proof_ns =
-                                    (envbody1.FStar_TypeChecker_Env.proof_ns);
-                                  FStar_TypeChecker_Env.synth_hook =
-                                    (envbody1.FStar_TypeChecker_Env.synth_hook);
-                                  FStar_TypeChecker_Env.try_solve_implicits_hook
-                                    =
-                                    (envbody1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                  FStar_TypeChecker_Env.splice =
-                                    (envbody1.FStar_TypeChecker_Env.splice);
-                                  FStar_TypeChecker_Env.mpreprocess =
-                                    (envbody1.FStar_TypeChecker_Env.mpreprocess);
-                                  FStar_TypeChecker_Env.postprocess =
-                                    (envbody1.FStar_TypeChecker_Env.postprocess);
-                                  FStar_TypeChecker_Env.identifier_info =
-                                    (envbody1.FStar_TypeChecker_Env.identifier_info);
-                                  FStar_TypeChecker_Env.tc_hooks =
-                                    (envbody1.FStar_TypeChecker_Env.tc_hooks);
-                                  FStar_TypeChecker_Env.dsenv =
-                                    (envbody1.FStar_TypeChecker_Env.dsenv);
-                                  FStar_TypeChecker_Env.nbe =
-                                    (envbody1.FStar_TypeChecker_Env.nbe);
-                                  FStar_TypeChecker_Env.strict_args_tab =
-                                    (envbody1.FStar_TypeChecker_Env.strict_args_tab);
-                                  FStar_TypeChecker_Env.erasable_types_tab =
-                                    (envbody1.FStar_TypeChecker_Env.erasable_types_tab);
-                                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                                    (envbody1.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                  FStar_TypeChecker_Env.unif_allow_ref_guards
-                                    =
-                                    (envbody1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                  FStar_TypeChecker_Env.erase_erasable_args =
-                                    (envbody1.FStar_TypeChecker_Env.erase_erasable_args);
-                                  FStar_TypeChecker_Env.core_check =
-                                    (envbody1.FStar_TypeChecker_Env.core_check)
-                                } in
-                              let uu___3 = mk_letrec_env envbody2 bs1 c in
-                              (match uu___3 with
-                               | (envbody3, letrecs, g_annots) ->
-                                   let envbody4 =
-                                     FStar_TypeChecker_Env.set_expected_typ_maybe_eq
-                                       envbody3
-                                       (FStar_Syntax_Util.comp_result c)
-                                       use_eq in
-                                   let uu___4 =
-                                     FStar_TypeChecker_Env.conj_guard g_env
-                                       g_annots in
-                                   ((FStar_Pervasives_Native.Some t2), bs1,
-                                     letrecs,
-                                     (FStar_Pervasives_Native.Some c),
-                                     envbody4, body1, uu___4))))
-                | uu___1 ->
-                    if Prims.op_Negation norm1
-                    then
-                      let uu___2 =
-                        let uu___3 =
-                          FStar_Compiler_Effect.op_Bar_Greater t2
-                            (FStar_TypeChecker_Normalize.unfold_whnf env) in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___3
-                          FStar_Syntax_Util.unascribe in
-                      as_function_typ true uu___2
-                    else
-                      (let uu___3 =
-                         tc_abs_expected_function_typ env bs
-                           FStar_Pervasives_Native.None body in
-                       match uu___3 with
-                       | (uu___4, bs1, uu___5, c_opt, envbody, body1, g_env)
-                           ->
-                           ((FStar_Pervasives_Native.Some t2), bs1, [],
-                             c_opt, envbody, body1, g_env)) in
-              as_function_typ false t1
-and (tc_abs_check_binders :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.binders ->
-        Prims.bool ->
-          (FStar_TypeChecker_Env.env * FStar_Syntax_Syntax.binders *
-            (FStar_Syntax_Syntax.binders, FStar_Syntax_Syntax.binders)
-            FStar_Pervasives.either FStar_Pervasives_Native.option *
-            FStar_TypeChecker_Env.guard_t * FStar_Syntax_Syntax.subst_t))
-  =
-  fun env ->
-    fun bs ->
-      fun bs_expected ->
-        fun use_eq ->
-          let rec aux uu___ bs1 bs_expected1 =
-            match uu___ with
-            | (env1, subst) ->
-                (match (bs1, bs_expected1) with
-                 | ([], []) ->
-                     (env1, [], FStar_Pervasives_Native.None,
-                       FStar_TypeChecker_Env.trivial_guard, subst)
-                 | ({ FStar_Syntax_Syntax.binder_bv = uu___1;
-                      FStar_Syntax_Syntax.binder_qual =
-                        FStar_Pervasives_Native.None;
-                      FStar_Syntax_Syntax.binder_attrs = uu___2;_}::uu___3,
-                    { FStar_Syntax_Syntax.binder_bv = hd_e;
-                      FStar_Syntax_Syntax.binder_qual = q;
-                      FStar_Syntax_Syntax.binder_attrs = attrs;_}::uu___4)
-                     when FStar_Syntax_Syntax.is_bqual_implicit_or_meta q ->
-                     let bv =
-                       let uu___5 =
-                         let uu___6 =
-                           FStar_Ident.range_of_id
-                             hd_e.FStar_Syntax_Syntax.ppname in
-                         FStar_Pervasives_Native.Some uu___6 in
-                       let uu___6 =
-                         FStar_Syntax_Subst.subst subst
-                           hd_e.FStar_Syntax_Syntax.sort in
-                       FStar_Syntax_Syntax.new_bv uu___5 uu___6 in
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Syntax_Syntax.mk_binder_with_attrs bv q attrs in
-                       uu___6 :: bs1 in
-                     aux (env1, subst) uu___5 bs_expected1
-                 | ({ FStar_Syntax_Syntax.binder_bv = hd;
-                      FStar_Syntax_Syntax.binder_qual = imp;
-                      FStar_Syntax_Syntax.binder_attrs = attrs;_}::bs2,
-                    { FStar_Syntax_Syntax.binder_bv = hd_expected;
-                      FStar_Syntax_Syntax.binder_qual = imp';
-                      FStar_Syntax_Syntax.binder_attrs = attrs';_}::bs_expected2)
-                     ->
-                     ((let special q1 q2 =
-                         match (q1, q2) with
-                         | (FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Meta uu___2),
-                            FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Meta uu___3)) -> true
-                         | (FStar_Pervasives_Native.None,
-                            FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Equality)) -> true
-                         | (FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Implicit uu___2),
-                            FStar_Pervasives_Native.Some
-                            (FStar_Syntax_Syntax.Meta uu___3)) -> true
-                         | uu___2 -> false in
-                       let uu___2 =
-                         (Prims.op_Negation (special imp imp')) &&
-                           (let uu___3 = FStar_Syntax_Util.eq_bqual imp imp' in
-                            uu___3 <> FStar_Syntax_Util.Equal) in
-                       if uu___2
-                       then
-                         let uu___3 =
-                           let uu___4 =
-                             let uu___5 = FStar_Syntax_Print.bv_to_string hd in
-                             FStar_Compiler_Util.format1
-                               "Inconsistent implicit argument annotation on argument %s"
-                               uu___5 in
-                           (FStar_Errors.Fatal_InconsistentImplicitArgumentAnnotation,
-                             uu___4) in
-                         let uu___4 = FStar_Syntax_Syntax.range_of_bv hd in
-                         FStar_Errors.raise_error uu___3 uu___4
-                       else ());
-                      (let expected_t =
-                         FStar_Syntax_Subst.subst subst
-                           hd_expected.FStar_Syntax_Syntax.sort in
-                       let uu___2 =
-                         let uu___3 =
-                           let uu___4 =
-                             FStar_Syntax_Util.unmeta
-                               hd.FStar_Syntax_Syntax.sort in
-                           uu___4.FStar_Syntax_Syntax.n in
-                         match uu___3 with
-                         | FStar_Syntax_Syntax.Tm_unknown ->
-                             (expected_t,
-                               FStar_TypeChecker_Env.trivial_guard)
-                         | uu___4 ->
-                             ((let uu___6 =
-                                 FStar_TypeChecker_Env.debug env1
-                                   FStar_Options.High in
-                               if uu___6
-                               then
-                                 let uu___7 =
-                                   FStar_Syntax_Print.bv_to_string hd in
-                                 FStar_Compiler_Util.print1
-                                   "Checking binder %s\n" uu___7
-                               else ());
-                              (let uu___6 =
-                                 tc_tot_or_gtot_term env1
-                                   hd.FStar_Syntax_Syntax.sort in
-                               match uu___6 with
-                               | (t, uu___7, g1_env) ->
-                                   let g2_env =
-                                     let label_guard g =
-                                       FStar_TypeChecker_Util.label_guard
-                                         (hd.FStar_Syntax_Syntax.sort).FStar_Syntax_Syntax.pos
-                                         "Type annotation on parameter incompatible with the expected type"
-                                         g in
-                                     let uu___8 =
-                                       FStar_TypeChecker_Rel.teq_nosmt env1 t
-                                         expected_t in
-                                     match uu___8 with
-                                     | FStar_Pervasives_Native.Some g ->
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           g
-                                           (FStar_TypeChecker_Rel.resolve_implicits
-                                              env1)
-                                     | FStar_Pervasives_Native.None ->
-                                         if use_eq
-                                         then
-                                           let uu___9 =
-                                             FStar_TypeChecker_Rel.teq env1 t
-                                               expected_t in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___9 label_guard
-                                         else
-                                           (let uu___10 =
-                                              FStar_TypeChecker_Rel.get_subtyping_prop
-                                                env1 expected_t t in
-                                            match uu___10 with
-                                            | FStar_Pervasives_Native.None ->
-                                                let uu___11 =
-                                                  FStar_TypeChecker_Err.basic_type_error
-                                                    env1
-                                                    FStar_Pervasives_Native.None
-                                                    expected_t t in
-                                                let uu___12 =
-                                                  FStar_TypeChecker_Env.get_range
-                                                    env1 in
-                                                FStar_Errors.raise_error
-                                                  uu___11 uu___12
-                                            | FStar_Pervasives_Native.Some
-                                                g_env -> label_guard g_env) in
-                                   let uu___8 =
-                                     FStar_TypeChecker_Env.conj_guard g1_env
-                                       g2_env in
-                                   (t, uu___8))) in
-                       match uu___2 with
-                       | (t, g_env) ->
-                           let hd1 =
-                             {
-                               FStar_Syntax_Syntax.ppname =
-                                 (hd.FStar_Syntax_Syntax.ppname);
-                               FStar_Syntax_Syntax.index =
-                                 (hd.FStar_Syntax_Syntax.index);
-                               FStar_Syntax_Syntax.sort = t
-                             } in
-                           let combine_attrs attrs1 attrs'1 =
-                             let diff =
-                               FStar_Compiler_List.filter
-                                 (fun attr' ->
-                                    let uu___3 =
-                                      FStar_Compiler_List.existsb
-                                        (fun attr ->
-                                           let uu___4 =
-                                             FStar_Syntax_Util.eq_tm attr
-                                               attr' in
-                                           uu___4 = FStar_Syntax_Util.Equal)
-                                        attrs1 in
-                                    Prims.op_Negation uu___3) attrs'1 in
-                             FStar_Compiler_List.op_At attrs1 diff in
-                           let b =
-                             let uu___3 = combine_attrs attrs attrs' in
-                             {
-                               FStar_Syntax_Syntax.binder_bv = hd1;
-                               FStar_Syntax_Syntax.binder_qual = imp;
-                               FStar_Syntax_Syntax.binder_attrs = uu___3
-                             } in
-                           (check_erasable_binder_attributes env1
-                              b.FStar_Syntax_Syntax.binder_attrs t;
-                            (let b_expected =
-                               {
-                                 FStar_Syntax_Syntax.binder_bv = hd_expected;
-                                 FStar_Syntax_Syntax.binder_qual = imp';
-                                 FStar_Syntax_Syntax.binder_attrs = attrs'
-                               } in
-                             let env_b = push_binding env1 b in
-                             let subst1 =
-                               let uu___4 =
-                                 FStar_Syntax_Syntax.bv_to_name hd1 in
-                               maybe_extend_subst subst b_expected uu___4 in
-                             let uu___4 =
-                               aux (env_b, subst1) bs2 bs_expected2 in
-                             match uu___4 with
-                             | (env_bs, bs3, rest, g'_env_b, subst2) ->
-                                 let g'_env =
-                                   FStar_TypeChecker_Env.close_guard env_bs
-                                     [b] g'_env_b in
-                                 let uu___5 =
-                                   FStar_TypeChecker_Env.conj_guard g_env
-                                     g'_env in
-                                 (env_bs, (b :: bs3), rest, uu___5, subst2)))))
-                 | (rest, []) ->
-                     (env1, [],
-                       (FStar_Pervasives_Native.Some
-                          (FStar_Pervasives.Inl rest)),
-                       FStar_TypeChecker_Env.trivial_guard, subst)
-                 | ([], rest) ->
-                     (env1, [],
-                       (FStar_Pervasives_Native.Some
-                          (FStar_Pervasives.Inr rest)),
-                       FStar_TypeChecker_Env.trivial_guard, subst)) in
-          aux (env, []) bs bs_expected
-and (tc_abs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.term ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun top ->
-      fun bs ->
-        fun body ->
-          let fail msg t =
-            let uu___ =
-              FStar_TypeChecker_Err.expected_a_term_of_type_t_got_a_function
-                env msg t top in
-            FStar_Errors.raise_error uu___ top.FStar_Syntax_Syntax.pos in
-          let env0 = env in
-          let uu___ = FStar_TypeChecker_Env.clear_expected_typ env in
-          match uu___ with
-          | (env1, topt) ->
-              ((let uu___2 =
-                  FStar_TypeChecker_Env.debug env1 FStar_Options.High in
-                if uu___2
-                then
-                  let uu___3 =
-                    match topt with
-                    | FStar_Pervasives_Native.None -> "None"
-                    | FStar_Pervasives_Native.Some (t, use_eq) ->
-                        let uu___4 = FStar_Syntax_Print.term_to_string t in
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_Compiler_Util.string_of_bool use_eq in
-                          Prims.op_Hat ", use_eq = " uu___6 in
-                        Prims.op_Hat uu___4 uu___5 in
-                  FStar_Compiler_Util.print2
-                    "!!!!!!!!!!!!!!!Expected type is (%s), top_level=%s\n"
-                    uu___3
-                    (if env1.FStar_TypeChecker_Env.top_level
-                     then "true"
-                     else "false")
-                else ());
-               (let uu___2 = tc_abs_expected_function_typ env1 bs topt body in
-                match uu___2 with
-                | (tfun_opt, bs1, letrec_binders, c_opt, envbody, body1,
-                   g_env) ->
-                    ((let uu___4 =
-                        FStar_TypeChecker_Env.debug env1
-                          FStar_Options.Extreme in
-                      if uu___4
-                      then
-                        let uu___5 =
-                          match tfun_opt with
-                          | FStar_Pervasives_Native.None -> "None"
-                          | FStar_Pervasives_Native.Some t ->
-                              FStar_Syntax_Print.term_to_string t in
-                        let uu___6 =
-                          match c_opt with
-                          | FStar_Pervasives_Native.None -> "None"
-                          | FStar_Pervasives_Native.Some t ->
-                              FStar_Syntax_Print.comp_to_string t in
-                        let uu___7 =
-                          let uu___8 =
-                            FStar_TypeChecker_Env.expected_typ envbody in
-                          match uu___8 with
-                          | FStar_Pervasives_Native.None -> "None"
-                          | FStar_Pervasives_Native.Some (t, use_eq) ->
-                              let uu___9 =
-                                FStar_Syntax_Print.term_to_string t in
-                              let uu___10 =
-                                let uu___11 =
-                                  FStar_Compiler_Util.string_of_bool use_eq in
-                                Prims.op_Hat ", use_eq = " uu___11 in
-                              Prims.op_Hat uu___9 uu___10 in
-                        FStar_Compiler_Util.print3
-                          "After expected_function_typ, tfun_opt: %s, c_opt: %s, and expected type in envbody: %s\n"
-                          uu___5 uu___6 uu___7
-                      else ());
-                     (let uu___5 =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_TypeChecker_Env.debug env1)
-                          (FStar_Options.Other "NYC") in
-                      if uu___5
-                      then
-                        let uu___6 =
-                          FStar_Syntax_Print.binders_to_string ", " bs1 in
-                        let uu___7 =
-                          FStar_TypeChecker_Rel.guard_to_string env1 g_env in
-                        FStar_Compiler_Util.print2
-                          "!!!!!!!!!!!!!!!Guard for function with binders %s is %s\n"
-                          uu___6 uu___7
-                      else ());
-                     (let envbody1 =
-                        FStar_TypeChecker_Env.set_range envbody
-                          body1.FStar_Syntax_Syntax.pos in
-                      let uu___5 =
-                        let uu___6 =
-                          let use_eq_opt =
-                            match topt with
-                            | FStar_Pervasives_Native.Some (uu___7, use_eq)
-                                ->
-                                FStar_Compiler_Effect.op_Bar_Greater use_eq
-                                  (fun uu___8 ->
-                                     FStar_Pervasives_Native.Some uu___8)
-                            | uu___7 -> FStar_Pervasives_Native.None in
-                          let uu___7 =
-                            (FStar_Compiler_Effect.op_Bar_Greater c_opt
-                               FStar_Compiler_Util.is_some)
-                              &&
-                              (let uu___8 =
-                                 let uu___9 =
-                                   FStar_Syntax_Subst.compress body1 in
-                                 uu___9.FStar_Syntax_Syntax.n in
-                               match uu___8 with
-                               | FStar_Syntax_Syntax.Tm_app (head, args) when
-                                   (FStar_Compiler_List.length args) =
-                                     Prims.int_one
-                                   ->
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Syntax_Subst.compress head in
-                                     uu___10.FStar_Syntax_Syntax.n in
-                                   (match uu___9 with
-                                    | FStar_Syntax_Syntax.Tm_constant
-                                        (FStar_Const.Const_reflect uu___10)
-                                        -> true
-                                    | uu___10 -> false)
-                               | uu___9 -> false) in
-                          if uu___7
-                          then
-                            let uu___8 =
-                              let uu___9 =
-                                FStar_TypeChecker_Env.clear_expected_typ
-                                  envbody1 in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                FStar_Pervasives_Native.fst in
-                            let uu___9 =
-                              let uu___10 =
-                                let uu___11 =
-                                  let uu___12 =
-                                    let uu___13 =
-                                      let uu___14 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          c_opt FStar_Compiler_Util.must in
-                                      FStar_Pervasives.Inr uu___14 in
-                                    let uu___14 =
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        use_eq_opt FStar_Compiler_Util.must in
-                                    (uu___13, FStar_Pervasives_Native.None,
-                                      uu___14) in
-                                  (body1, uu___12,
-                                    FStar_Pervasives_Native.None) in
-                                FStar_Syntax_Syntax.Tm_ascribed uu___11 in
-                              FStar_Syntax_Syntax.mk uu___10
-                                FStar_Compiler_Range.dummyRange in
-                            (uu___8, uu___9, (FStar_Pervasives.Inr ()))
-                          else
-                            (let uu___9 =
-                               let uu___10 =
-                                 let uu___11 =
-                                   let uu___12 =
-                                     FStar_Syntax_Subst.compress body1 in
-                                   uu___12.FStar_Syntax_Syntax.n in
-                                 (c_opt, uu___11) in
-                               match uu___10 with
-                               | (FStar_Pervasives_Native.None,
-                                  FStar_Syntax_Syntax.Tm_ascribed
-                                  (uu___11,
-                                   (FStar_Pervasives.Inr expected_c, uu___12,
-                                    uu___13),
-                                   uu___14)) -> FStar_Pervasives.Inr ()
-                               | uu___11 ->
-                                   FStar_Pervasives.Inl
-                                     (FStar_Compiler_Util.dflt false
-                                        use_eq_opt) in
-                             (envbody1, body1, uu___9)) in
-                        match uu___6 with
-                        | (envbody2, body2, should_check_expected_effect) ->
-                            let uu___7 =
-                              tc_term
-                                {
-                                  FStar_TypeChecker_Env.solver =
-                                    (envbody2.FStar_TypeChecker_Env.solver);
-                                  FStar_TypeChecker_Env.range =
-                                    (envbody2.FStar_TypeChecker_Env.range);
-                                  FStar_TypeChecker_Env.curmodule =
-                                    (envbody2.FStar_TypeChecker_Env.curmodule);
-                                  FStar_TypeChecker_Env.gamma =
-                                    (envbody2.FStar_TypeChecker_Env.gamma);
-                                  FStar_TypeChecker_Env.gamma_sig =
-                                    (envbody2.FStar_TypeChecker_Env.gamma_sig);
-                                  FStar_TypeChecker_Env.gamma_cache =
-                                    (envbody2.FStar_TypeChecker_Env.gamma_cache);
-                                  FStar_TypeChecker_Env.modules =
-                                    (envbody2.FStar_TypeChecker_Env.modules);
-                                  FStar_TypeChecker_Env.expected_typ =
-                                    (envbody2.FStar_TypeChecker_Env.expected_typ);
-                                  FStar_TypeChecker_Env.sigtab =
-                                    (envbody2.FStar_TypeChecker_Env.sigtab);
-                                  FStar_TypeChecker_Env.attrtab =
-                                    (envbody2.FStar_TypeChecker_Env.attrtab);
-                                  FStar_TypeChecker_Env.instantiate_imp =
-                                    (envbody2.FStar_TypeChecker_Env.instantiate_imp);
-                                  FStar_TypeChecker_Env.effects =
-                                    (envbody2.FStar_TypeChecker_Env.effects);
-                                  FStar_TypeChecker_Env.generalize =
-                                    (envbody2.FStar_TypeChecker_Env.generalize);
-                                  FStar_TypeChecker_Env.letrecs =
-                                    (envbody2.FStar_TypeChecker_Env.letrecs);
-                                  FStar_TypeChecker_Env.top_level = false;
-                                  FStar_TypeChecker_Env.check_uvars =
-                                    (envbody2.FStar_TypeChecker_Env.check_uvars);
-                                  FStar_TypeChecker_Env.use_eq_strict =
-                                    (envbody2.FStar_TypeChecker_Env.use_eq_strict);
-                                  FStar_TypeChecker_Env.is_iface =
-                                    (envbody2.FStar_TypeChecker_Env.is_iface);
-                                  FStar_TypeChecker_Env.admit =
-                                    (envbody2.FStar_TypeChecker_Env.admit);
-                                  FStar_TypeChecker_Env.lax =
-                                    (envbody2.FStar_TypeChecker_Env.lax);
-                                  FStar_TypeChecker_Env.lax_universes =
-                                    (envbody2.FStar_TypeChecker_Env.lax_universes);
-                                  FStar_TypeChecker_Env.phase1 =
-                                    (envbody2.FStar_TypeChecker_Env.phase1);
-                                  FStar_TypeChecker_Env.failhard =
-                                    (envbody2.FStar_TypeChecker_Env.failhard);
-                                  FStar_TypeChecker_Env.nosynth =
-                                    (envbody2.FStar_TypeChecker_Env.nosynth);
-                                  FStar_TypeChecker_Env.uvar_subtyping =
-                                    (envbody2.FStar_TypeChecker_Env.uvar_subtyping);
-                                  FStar_TypeChecker_Env.tc_term =
-                                    (envbody2.FStar_TypeChecker_Env.tc_term);
-                                  FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                    =
-                                    (envbody2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.universe_of =
-                                    (envbody2.FStar_TypeChecker_Env.universe_of);
-                                  FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                    =
-                                    (envbody2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                  FStar_TypeChecker_Env.teq_nosmt_force =
-                                    (envbody2.FStar_TypeChecker_Env.teq_nosmt_force);
-                                  FStar_TypeChecker_Env.subtype_nosmt_force =
-                                    (envbody2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                  FStar_TypeChecker_Env.qtbl_name_and_index =
-                                    (envbody2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                  FStar_TypeChecker_Env.normalized_eff_names
-                                    =
-                                    (envbody2.FStar_TypeChecker_Env.normalized_eff_names);
-                                  FStar_TypeChecker_Env.fv_delta_depths =
-                                    (envbody2.FStar_TypeChecker_Env.fv_delta_depths);
-                                  FStar_TypeChecker_Env.proof_ns =
-                                    (envbody2.FStar_TypeChecker_Env.proof_ns);
-                                  FStar_TypeChecker_Env.synth_hook =
-                                    (envbody2.FStar_TypeChecker_Env.synth_hook);
-                                  FStar_TypeChecker_Env.try_solve_implicits_hook
-                                    =
-                                    (envbody2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                  FStar_TypeChecker_Env.splice =
-                                    (envbody2.FStar_TypeChecker_Env.splice);
-                                  FStar_TypeChecker_Env.mpreprocess =
-                                    (envbody2.FStar_TypeChecker_Env.mpreprocess);
-                                  FStar_TypeChecker_Env.postprocess =
-                                    (envbody2.FStar_TypeChecker_Env.postprocess);
-                                  FStar_TypeChecker_Env.identifier_info =
-                                    (envbody2.FStar_TypeChecker_Env.identifier_info);
-                                  FStar_TypeChecker_Env.tc_hooks =
-                                    (envbody2.FStar_TypeChecker_Env.tc_hooks);
-                                  FStar_TypeChecker_Env.dsenv =
-                                    (envbody2.FStar_TypeChecker_Env.dsenv);
-                                  FStar_TypeChecker_Env.nbe =
-                                    (envbody2.FStar_TypeChecker_Env.nbe);
-                                  FStar_TypeChecker_Env.strict_args_tab =
-                                    (envbody2.FStar_TypeChecker_Env.strict_args_tab);
-                                  FStar_TypeChecker_Env.erasable_types_tab =
-                                    (envbody2.FStar_TypeChecker_Env.erasable_types_tab);
-                                  FStar_TypeChecker_Env.enable_defer_to_tac =
-                                    (envbody2.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                  FStar_TypeChecker_Env.unif_allow_ref_guards
-                                    =
-                                    (envbody2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                  FStar_TypeChecker_Env.erase_erasable_args =
-                                    (envbody2.FStar_TypeChecker_Env.erase_erasable_args);
-                                  FStar_TypeChecker_Env.core_check =
-                                    (envbody2.FStar_TypeChecker_Env.core_check)
-                                } body2 in
-                            (match uu___7 with
-                             | (body3, cbody, guard_body) ->
-                                 let guard_body1 =
-                                   FStar_TypeChecker_Rel.solve_non_tactic_deferred_constraints
-                                     true envbody2 guard_body in
-                                 (match should_check_expected_effect with
-                                  | FStar_Pervasives.Inl use_eq ->
-                                      let uu___8 =
-                                        FStar_TypeChecker_Common.lcomp_comp
-                                          cbody in
-                                      (match uu___8 with
-                                       | (cbody1, g_lc) ->
-                                           let uu___9 =
-                                             check_expected_effect envbody2
-                                               use_eq c_opt (body3, cbody1) in
-                                           (match uu___9 with
-                                            | (body4, cbody2, guard) ->
-                                                let uu___10 =
-                                                  let uu___11 =
-                                                    FStar_TypeChecker_Env.conj_guard
-                                                      g_lc guard in
-                                                  FStar_TypeChecker_Env.conj_guard
-                                                    guard_body1 uu___11 in
-                                                (body4, cbody2, uu___10)))
-                                  | FStar_Pervasives.Inr uu___8 ->
-                                      let uu___9 =
-                                        FStar_TypeChecker_Common.lcomp_comp
-                                          cbody in
-                                      (match uu___9 with
-                                       | (cbody1, g_lc) ->
-                                           let uu___10 =
-                                             FStar_TypeChecker_Env.conj_guard
-                                               guard_body1 g_lc in
-                                           (body3, cbody1, uu___10)))) in
-                      match uu___5 with
-                      | (body2, cbody, guard_body) ->
-                          ((let uu___7 =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug env1)
-                                FStar_Options.Extreme in
-                            if uu___7
-                            then
-                              let uu___8 =
-                                FStar_TypeChecker_Rel.guard_to_string env1
-                                  guard_body in
-                              FStar_Compiler_Util.print1
-                                "tc_abs: guard_body: %s\n" uu___8
-                            else ());
-                           (let guard =
-                              let uu___7 =
-                                env1.FStar_TypeChecker_Env.top_level ||
-                                  (let uu___8 =
-                                     let uu___9 =
-                                       FStar_Ident.string_of_lid
-                                         env1.FStar_TypeChecker_Env.curmodule in
-                                     FStar_Options.should_verify uu___9 in
-                                   Prims.op_Negation uu___8) in
-                              if uu___7
-                              then
-                                (if
-                                   env1.FStar_TypeChecker_Env.lax ||
-                                     env1.FStar_TypeChecker_Env.phase1
-                                 then
-                                   let uu___8 =
-                                     FStar_TypeChecker_Rel.discharge_guard
-                                       env1 g_env in
-                                   let uu___9 =
-                                     FStar_TypeChecker_Rel.discharge_guard
-                                       envbody1 guard_body in
-                                   FStar_TypeChecker_Env.conj_guard uu___8
-                                     uu___9
-                                 else
-                                   (let uu___9 =
-                                      FStar_TypeChecker_Common.split_guard
-                                        g_env in
-                                    match uu___9 with
-                                    | (g_env1, g_env_logical) ->
-                                        let uu___10 =
-                                          FStar_TypeChecker_Common.split_guard
-                                            guard_body in
-                                        (match uu___10 with
-                                         | (guard_body1, guard_body_logical)
-                                             ->
-                                             ((let uu___12 =
-                                                 FStar_TypeChecker_Env.conj_guard
-                                                   g_env1 guard_body1 in
-                                               FStar_TypeChecker_Rel.force_trivial_guard
-                                                 env1 uu___12);
-                                              FStar_TypeChecker_Rel.force_trivial_guard
-                                                env1 g_env_logical;
-                                              FStar_TypeChecker_Rel.force_trivial_guard
-                                                envbody1 guard_body_logical;
-                                              FStar_TypeChecker_Env.trivial_guard))))
-                              else
-                                (let guard1 =
-                                   let uu___9 =
-                                     FStar_TypeChecker_Env.close_guard
-                                       envbody1
-                                       (FStar_Compiler_List.op_At bs1
-                                          letrec_binders) guard_body in
-                                   FStar_TypeChecker_Env.conj_guard g_env
-                                     uu___9 in
-                                 guard1) in
-                            let guard1 =
-                              FStar_TypeChecker_Util.close_guard_implicits
-                                env1 false bs1 guard in
-                            let tfun_computed =
-                              FStar_Syntax_Util.arrow bs1 cbody in
-                            let e =
-                              let uu___7 =
-                                let uu___8 =
-                                  FStar_Syntax_Util.residual_comp_of_comp
-                                    (FStar_Compiler_Util.dflt cbody c_opt) in
-                                FStar_Pervasives_Native.Some uu___8 in
-                              FStar_Syntax_Util.abs bs1 body2 uu___7 in
-                            (let env2 =
-                               FStar_TypeChecker_Env.push_binders env1 bs1 in
-                             FStar_Compiler_List.iter
-                               (fun b ->
-                                  let uu___8 =
-                                    (FStar_Syntax_Util.has_attribute
-                                       b.FStar_Syntax_Syntax.binder_attrs
-                                       FStar_Parser_Const.binder_strictly_positive_attr)
-                                      &&
-                                      (let uu___9 =
-                                         FStar_Options.no_positivity () in
-                                       Prims.op_Negation uu___9) in
-                                  if uu___8
-                                  then
-                                    let r =
-                                      FStar_TypeChecker_Positivity.name_strictly_positive_in_type
-                                        env2 b.FStar_Syntax_Syntax.binder_bv
-                                        body2 in
-                                    (if Prims.op_Negation r
-                                     then
-                                       let uu___9 =
-                                         let uu___10 =
-                                           let uu___11 =
-                                             FStar_Syntax_Print.binder_to_string
-                                               b in
-                                           FStar_Compiler_Util.format1
-                                             "Binder %s is marked strictly positive, but its use in the definition is not"
-                                             uu___11 in
-                                         (FStar_Errors.Error_InductiveTypeNotSatisfyPositivityCondition,
-                                           uu___10) in
-                                       let uu___10 =
-                                         FStar_Syntax_Syntax.range_of_bv
-                                           b.FStar_Syntax_Syntax.binder_bv in
-                                       FStar_Errors.raise_error uu___9
-                                         uu___10
-                                     else ())
-                                  else ()) bs1);
-                            (let uu___8 =
-                               match tfun_opt with
-                               | FStar_Pervasives_Native.Some t ->
-                                   let t1 = FStar_Syntax_Subst.compress t in
-                                   let uu___9 =
-                                     match topt with
-                                     | FStar_Pervasives_Native.Some
-                                         (t2, use_eq) -> (t2, use_eq)
-                                     | FStar_Pervasives_Native.None ->
-                                         failwith
-                                           "Impossible! tc_abs: if tfun_computed is Some, expected topt to also be Some" in
-                                   (match uu___9 with
-                                    | (t_annot, use_eq) ->
-                                        (match t1.FStar_Syntax_Syntax.n with
-                                         | FStar_Syntax_Syntax.Tm_arrow
-                                             uu___10 -> (e, t_annot, guard1)
-                                         | uu___10 ->
-                                             let lc =
-                                               let uu___11 =
-                                                 FStar_Syntax_Syntax.mk_Total
-                                                   tfun_computed in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___11
-                                                 FStar_TypeChecker_Common.lcomp_of_comp in
-                                             let uu___11 =
-                                               FStar_TypeChecker_Util.check_has_type_maybe_coerce
-                                                 env1 e lc t1 use_eq in
-                                             (match uu___11 with
-                                              | (e1, uu___12, guard') ->
-                                                  let guard'1 =
-                                                    let uu___13 =
-                                                      FStar_TypeChecker_Err.subtyping_failed
-                                                        env1
-                                                        lc.FStar_TypeChecker_Common.res_typ
-                                                        t1 () in
-                                                    FStar_TypeChecker_Util.label_guard
-                                                      e1.FStar_Syntax_Syntax.pos
-                                                      uu___13 guard' in
-                                                  let uu___13 =
-                                                    FStar_TypeChecker_Env.conj_guard
-                                                      guard1 guard'1 in
-                                                  (e1, t_annot, uu___13))))
-                               | FStar_Pervasives_Native.None ->
-                                   (e, tfun_computed, guard1) in
-                             match uu___8 with
-                             | (e1, tfun, guard2) ->
-                                 let c = FStar_Syntax_Syntax.mk_Total tfun in
-                                 let uu___9 =
-                                   let uu___10 =
-                                     FStar_TypeChecker_Common.lcomp_of_comp c in
-                                   FStar_TypeChecker_Util.strengthen_precondition
-                                     FStar_Pervasives_Native.None env1 e1
-                                     uu___10 guard2 in
-                                 (match uu___9 with | (c1, g) -> (e1, c1, g)))))))))
-and (check_application_args :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_TypeChecker_Env.guard_t ->
-          (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-            FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-            Prims.list ->
-            (FStar_Syntax_Syntax.typ * Prims.bool)
-              FStar_Pervasives_Native.option ->
-              (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-                FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun head ->
-      fun chead ->
-        fun ghead ->
-          fun args ->
-            fun expected_topt ->
-              let n_args = FStar_Compiler_List.length args in
-              let r = FStar_TypeChecker_Env.get_range env in
-              let thead = FStar_Syntax_Util.comp_result chead in
-              (let uu___1 =
-                 FStar_TypeChecker_Env.debug env FStar_Options.High in
-               if uu___1
-               then
-                 let uu___2 =
-                   FStar_Compiler_Range.string_of_range
-                     head.FStar_Syntax_Syntax.pos in
-                 let uu___3 = FStar_Syntax_Print.term_to_string thead in
-                 FStar_Compiler_Util.print2 "(%s) Type of head is %s\n"
-                   uu___2 uu___3
-               else ());
-              (let monadic_application uu___1 subst arg_comps_rev
-                 arg_rets_rev guard fvs bs =
-                 match uu___1 with
-                 | (head1, chead1, ghead1, cres) ->
-                     let uu___2 =
-                       match bs with
-                       | [] ->
-                           let uu___3 =
-                             FStar_TypeChecker_Env.conj_guard ghead1 guard in
-                           (cres, uu___3)
-                       | uu___3 ->
-                           let g =
-                             let uu___4 =
-                               FStar_TypeChecker_Env.conj_guard ghead1 guard in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___4
-                               (FStar_TypeChecker_Rel.solve_deferred_constraints
-                                  env) in
-                           let uu___4 =
-                             let uu___5 = FStar_Syntax_Util.arrow bs cres in
-                             FStar_Syntax_Syntax.mk_Total uu___5 in
-                           (uu___4, g) in
-                     (match uu___2 with
-                      | (cres1, guard1) ->
-                          let uu___3 =
-                            check_no_escape
-                              (FStar_Pervasives_Native.Some head1) env fvs
-                              (FStar_Syntax_Util.comp_result cres1) in
-                          (match uu___3 with
-                           | (rt, g0) ->
-                               let uu___4 =
-                                 let uu___5 =
-                                   FStar_Syntax_Util.set_result_typ cres1 rt in
-                                 let uu___6 =
-                                   FStar_TypeChecker_Env.conj_guard g0 guard1 in
-                                 (uu___5, uu___6) in
-                               (match uu___4 with
-                                | (cres2, guard2) ->
-                                    ((let uu___6 =
-                                        FStar_TypeChecker_Env.debug env
-                                          FStar_Options.Medium in
-                                      if uu___6
-                                      then
-                                        let uu___7 =
-                                          FStar_Syntax_Print.comp_to_string
-                                            cres2 in
-                                        FStar_Compiler_Util.print1
-                                          "\t Type of result cres is %s\n"
-                                          uu___7
-                                      else ());
-                                     (let uu___6 =
-                                        let uu___7 =
-                                          let uu___8 =
-                                            FStar_Syntax_Subst.subst_comp
-                                              subst chead1 in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___8
-                                            FStar_TypeChecker_Common.lcomp_of_comp in
-                                        let uu___8 =
-                                          let uu___9 =
-                                            FStar_Syntax_Subst.subst_comp
-                                              subst cres2 in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___9
-                                            FStar_TypeChecker_Common.lcomp_of_comp in
-                                        (uu___7, uu___8) in
-                                      match uu___6 with
-                                      | (chead2, cres3) ->
-                                          let uu___7 =
-                                            let head_is_pure_and_some_arg_is_effectful
-                                              =
-                                              (FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                 chead2)
-                                                &&
-                                                (FStar_Compiler_Util.for_some
-                                                   (fun uu___8 ->
-                                                      match uu___8 with
-                                                      | (uu___9, uu___10, lc)
-                                                          ->
-                                                          (let uu___11 =
-                                                             FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                               lc in
-                                                           Prims.op_Negation
-                                                             uu___11)
-                                                            ||
-                                                            (FStar_TypeChecker_Util.should_not_inline_lc
-                                                               lc))
-                                                   arg_comps_rev) in
-                                            let term =
-                                              FStar_Syntax_Syntax.mk_Tm_app
-                                                head1
-                                                (FStar_Compiler_List.rev
-                                                   arg_rets_rev)
-                                                head1.FStar_Syntax_Syntax.pos in
-                                            let uu___8 =
-                                              (FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                 cres3)
-                                                &&
-                                                head_is_pure_and_some_arg_is_effectful in
-                                            if uu___8
-                                            then
-                                              ((let uu___10 =
-                                                  FStar_TypeChecker_Env.debug
-                                                    env FStar_Options.Extreme in
-                                                if uu___10
-                                                then
-                                                  let uu___11 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      term in
-                                                  FStar_Compiler_Util.print1
-                                                    "(a) Monadic app: Return inserted in monadic application: %s\n"
-                                                    uu___11
-                                                else ());
-                                               (let uu___10 =
-                                                  FStar_TypeChecker_Util.maybe_assume_result_eq_pure_term
-                                                    env term cres3 in
-                                                (uu___10, true)))
-                                            else
-                                              ((let uu___11 =
-                                                  FStar_TypeChecker_Env.debug
-                                                    env FStar_Options.Extreme in
-                                                if uu___11
-                                                then
-                                                  let uu___12 =
-                                                    FStar_Syntax_Print.term_to_string
-                                                      term in
-                                                  FStar_Compiler_Util.print1
-                                                    "(a) Monadic app: No return inserted in monadic application: %s\n"
-                                                    uu___12
-                                                else ());
-                                               (cres3, false)) in
-                                          (match uu___7 with
-                                           | (cres4, inserted_return_in_cres)
-                                               ->
-                                               let comp =
-                                                 let arg_rets_names_opt =
-                                                   let uu___8 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       arg_rets_rev
-                                                       FStar_Compiler_List.rev in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___8
-                                                     (FStar_Compiler_List.map
-                                                        (fun uu___9 ->
-                                                           match uu___9 with
-                                                           | (t, uu___10) ->
-                                                               let uu___11 =
-                                                                 let uu___12
-                                                                   =
-                                                                   FStar_Syntax_Subst.compress
-                                                                    t in
-                                                                 uu___12.FStar_Syntax_Syntax.n in
-                                                               (match uu___11
-                                                                with
-                                                                | FStar_Syntax_Syntax.Tm_name
-                                                                    bv ->
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    bv
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___12)
-                                                                | uu___12 ->
-                                                                    FStar_Pervasives_Native.None))) in
-                                                 let push_option_names_to_env
-                                                   =
-                                                   FStar_Compiler_List.fold_left
-                                                     (fun env1 ->
-                                                        fun name_opt ->
-                                                          let uu___8 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              name_opt
-                                                              (FStar_Compiler_Util.map_option
-                                                                 (FStar_TypeChecker_Env.push_bv
-                                                                    env1)) in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___8
-                                                            (FStar_Compiler_Util.dflt
-                                                               env1)) in
-                                                 let uu___8 =
-                                                   FStar_Compiler_List.fold_left
-                                                     (fun uu___9 ->
-                                                        fun uu___10 ->
-                                                          match (uu___9,
-                                                                  uu___10)
-                                                          with
-                                                          | ((i, out_c),
-                                                             ((e, q), x, c))
-                                                              ->
-                                                              ((let uu___12 =
-                                                                  FStar_TypeChecker_Env.debug
-                                                                    env
-                                                                    FStar_Options.Extreme in
-                                                                if uu___12
-                                                                then
-                                                                  let uu___13
-                                                                    =
-                                                                    match x
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    -> "_"
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    x1 ->
-                                                                    FStar_Syntax_Print.bv_to_string
-                                                                    x1 in
-                                                                  let uu___14
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    e in
-                                                                  let uu___15
-                                                                    =
-                                                                    FStar_TypeChecker_Common.lcomp_to_string
-                                                                    c in
-                                                                  FStar_Compiler_Util.print3
-                                                                    "(b) Monadic app: Binding argument %s : %s of type (%s)\n"
-                                                                    uu___13
-                                                                    uu___14
-                                                                    uu___15
-                                                                else ());
-                                                               (let env1 =
-                                                                  if
-                                                                    inserted_return_in_cres
-                                                                  then
-                                                                    let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_List.splitAt
-                                                                    ((FStar_Compiler_List.length
-                                                                    arg_rets_names_opt)
-                                                                    - i)
-                                                                    arg_rets_names_opt in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    FStar_Pervasives_Native.fst in
-                                                                    push_option_names_to_env
-                                                                    env
-                                                                    uu___12
-                                                                  else env in
-                                                                let uu___12 =
-                                                                  FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                                    c in
-                                                                if uu___12
-                                                                then
-                                                                  let uu___13
-                                                                    =
-                                                                    FStar_TypeChecker_Util.bind
-                                                                    e.FStar_Syntax_Syntax.pos
-                                                                    env1
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    e) c
-                                                                    (x,
-                                                                    out_c) in
-                                                                  ((i +
-                                                                    Prims.int_one),
-                                                                    uu___13)
-                                                                else
-                                                                  (let uu___14
-                                                                    =
-                                                                    FStar_TypeChecker_Util.bind
-                                                                    e.FStar_Syntax_Syntax.pos
-                                                                    env1
-                                                                    FStar_Pervasives_Native.None
-                                                                    c
-                                                                    (x,
-                                                                    out_c) in
-                                                                   ((i +
-                                                                    Prims.int_one),
-                                                                    uu___14)))))
-                                                     (Prims.int_one, cres4)
-                                                     arg_comps_rev in
-                                                 match uu___8 with
-                                                 | (uu___9, comp1) ->
-                                                     let env1 =
-                                                       push_option_names_to_env
-                                                         env
-                                                         arg_rets_names_opt in
-                                                     ((let uu___11 =
-                                                         FStar_TypeChecker_Env.debug
-                                                           env1
-                                                           FStar_Options.Extreme in
-                                                       if uu___11
-                                                       then
-                                                         let uu___12 =
-                                                           FStar_Syntax_Print.term_to_string
-                                                             head1 in
-                                                         let uu___13 =
-                                                           FStar_TypeChecker_Common.lcomp_to_string
-                                                             chead2 in
-                                                         FStar_Compiler_Util.print2
-                                                           "(c) Monadic app: Binding head %s, chead: %s\n"
-                                                           uu___12 uu___13
-                                                       else ());
-                                                      (let uu___11 =
-                                                         FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                           chead2 in
-                                                       if uu___11
-                                                       then
-                                                         FStar_TypeChecker_Util.bind
-                                                           head1.FStar_Syntax_Syntax.pos
-                                                           env1
-                                                           (FStar_Pervasives_Native.Some
-                                                              head1) chead2
-                                                           (FStar_Pervasives_Native.None,
-                                                             comp1)
-                                                       else
-                                                         FStar_TypeChecker_Util.bind
-                                                           head1.FStar_Syntax_Syntax.pos
-                                                           env1
-                                                           FStar_Pervasives_Native.None
-                                                           chead2
-                                                           (FStar_Pervasives_Native.None,
-                                                             comp1))) in
-                                               let shortcuts_evaluation_order
-                                                 =
-                                                 let uu___8 =
-                                                   let uu___9 =
-                                                     FStar_Syntax_Subst.compress
-                                                       head1 in
-                                                   uu___9.FStar_Syntax_Syntax.n in
-                                                 match uu___8 with
-                                                 | FStar_Syntax_Syntax.Tm_fvar
-                                                     fv ->
-                                                     (FStar_Syntax_Syntax.fv_eq_lid
-                                                        fv
-                                                        FStar_Parser_Const.op_And)
-                                                       ||
-                                                       (FStar_Syntax_Syntax.fv_eq_lid
-                                                          fv
-                                                          FStar_Parser_Const.op_Or)
-                                                 | uu___9 -> false in
-                                               let app =
-                                                 if
-                                                   shortcuts_evaluation_order
-                                                 then
-                                                   let args1 =
-                                                     FStar_Compiler_List.fold_left
-                                                       (fun args2 ->
-                                                          fun uu___8 ->
-                                                            match uu___8 with
-                                                            | (arg, uu___9,
-                                                               uu___10) ->
-                                                                arg :: args2)
-                                                       [] arg_comps_rev in
-                                                   let app1 =
-                                                     FStar_Syntax_Syntax.mk_Tm_app
-                                                       head1 args1 r in
-                                                   let app2 =
-                                                     FStar_TypeChecker_Util.maybe_lift
-                                                       env app1
-                                                       cres4.FStar_TypeChecker_Common.eff_name
-                                                       comp.FStar_TypeChecker_Common.eff_name
-                                                       comp.FStar_TypeChecker_Common.res_typ in
-                                                   FStar_TypeChecker_Util.maybe_monadic
-                                                     env app2
-                                                     comp.FStar_TypeChecker_Common.eff_name
-                                                     comp.FStar_TypeChecker_Common.res_typ
-                                                 else
-                                                   (let uu___9 =
-                                                      let map_fun uu___10 =
-                                                        match uu___10 with
-                                                        | ((e, q), uu___11,
-                                                           c) ->
-                                                            ((let uu___13 =
-                                                                FStar_TypeChecker_Env.debug
-                                                                  env
-                                                                  FStar_Options.Extreme in
-                                                              if uu___13
-                                                              then
-                                                                let uu___14 =
-                                                                  FStar_Syntax_Print.term_to_string
-                                                                    e in
-                                                                let uu___15 =
-                                                                  FStar_TypeChecker_Common.lcomp_to_string
-                                                                    c in
-                                                                FStar_Compiler_Util.print2
-                                                                  "For arg e=(%s) c=(%s)... "
-                                                                  uu___14
-                                                                  uu___15
-                                                              else ());
-                                                             (let uu___13 =
-                                                                FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                                  c in
-                                                              if uu___13
-                                                              then
-                                                                ((let uu___15
-                                                                    =
-                                                                    FStar_TypeChecker_Env.debug
-                                                                    env
-                                                                    FStar_Options.Extreme in
-                                                                  if uu___15
-                                                                  then
-                                                                    FStar_Compiler_Util.print_string
-                                                                    "... not lifting\n"
-                                                                  else ());
-                                                                 (FStar_Pervasives_Native.None,
-                                                                   (e, q)))
-                                                              else
-                                                                (let warn_effectful_args
-                                                                   =
-                                                                   (FStar_TypeChecker_Util.must_erase_for_extraction
-                                                                    env
-                                                                    chead2.FStar_TypeChecker_Common.res_typ)
-                                                                    &&
-                                                                    (let uu___15
-                                                                    =
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Syntax_Util.un_uinst
-                                                                    head1 in
-                                                                    uu___17.FStar_Syntax_Syntax.n in
-                                                                    match uu___16
-                                                                    with
-                                                                    | 
-                                                                    FStar_Syntax_Syntax.Tm_fvar
-                                                                    fv ->
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Parser_Const.psconst
-                                                                    "ignore" in
-                                                                    FStar_Syntax_Syntax.fv_eq_lid
-                                                                    fv
-                                                                    uu___17
-                                                                    | 
-                                                                    uu___17
-                                                                    -> true in
-                                                                    Prims.op_Negation
-                                                                    uu___15) in
-                                                                 if
-                                                                   warn_effectful_args
-                                                                 then
-                                                                   (let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    e in
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    c.FStar_TypeChecker_Common.eff_name in
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    head1 in
-                                                                    FStar_Compiler_Util.format3
-                                                                    "Effectful argument %s (%s) to erased function %s, consider let binding it"
-                                                                    uu___18
-                                                                    uu___19
-                                                                    uu___20 in
-                                                                    (FStar_Errors.Warning_EffectfulArgumentToErasedFunction,
-                                                                    uu___17) in
-                                                                    FStar_Errors.log_issue
-                                                                    e.FStar_Syntax_Syntax.pos
-                                                                    uu___16)
-                                                                 else ();
-                                                                 (let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_Env.debug
-                                                                    env
-                                                                    FStar_Options.Extreme in
-                                                                  if uu___17
-                                                                  then
-                                                                    FStar_Compiler_Util.print_string
-                                                                    "... lifting!\n"
-                                                                  else ());
-                                                                 (let x =
-                                                                    FStar_Syntax_Syntax.new_bv
-                                                                    FStar_Pervasives_Native.None
-                                                                    c.FStar_TypeChecker_Common.res_typ in
-                                                                  let e1 =
-                                                                    FStar_TypeChecker_Util.maybe_lift
-                                                                    env e
-                                                                    c.FStar_TypeChecker_Common.eff_name
-                                                                    comp.FStar_TypeChecker_Common.eff_name
-                                                                    c.FStar_TypeChecker_Common.res_typ in
-                                                                  let uu___17
-                                                                    =
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Syntax_Syntax.bv_to_name
-                                                                    x in
-                                                                    (uu___18,
-                                                                    q) in
-                                                                  ((FStar_Pervasives_Native.Some
-                                                                    (x,
-                                                                    (c.FStar_TypeChecker_Common.eff_name),
-                                                                    (c.FStar_TypeChecker_Common.res_typ),
-                                                                    e1)),
-                                                                    uu___17))))) in
-                                                      let uu___10 =
-                                                        let uu___11 =
-                                                          let uu___12 =
-                                                            let uu___13 =
-                                                              let uu___14 =
-                                                                FStar_Syntax_Syntax.as_arg
-                                                                  head1 in
-                                                              (uu___14,
-                                                                FStar_Pervasives_Native.None,
-                                                                chead2) in
-                                                            uu___13 ::
-                                                              arg_comps_rev in
-                                                          FStar_Compiler_List.map
-                                                            map_fun uu___12 in
-                                                        FStar_Compiler_Effect.op_Less_Bar
-                                                          FStar_Compiler_List.split
-                                                          uu___11 in
-                                                      match uu___10 with
-                                                      | (lifted_args,
-                                                         reverse_args) ->
-                                                          let uu___11 =
-                                                            let uu___12 =
-                                                              FStar_Compiler_List.hd
-                                                                reverse_args in
-                                                            FStar_Pervasives_Native.fst
-                                                              uu___12 in
-                                                          let uu___12 =
-                                                            let uu___13 =
-                                                              FStar_Compiler_List.tl
-                                                                reverse_args in
-                                                            FStar_Compiler_List.rev
-                                                              uu___13 in
-                                                          (lifted_args,
-                                                            uu___11, uu___12) in
-                                                    match uu___9 with
-                                                    | (lifted_args, head2,
-                                                       args1) ->
-                                                        let app1 =
-                                                          FStar_Syntax_Syntax.mk_Tm_app
-                                                            head2 args1 r in
-                                                        let app2 =
-                                                          FStar_TypeChecker_Util.maybe_lift
-                                                            env app1
-                                                            cres4.FStar_TypeChecker_Common.eff_name
-                                                            comp.FStar_TypeChecker_Common.eff_name
-                                                            comp.FStar_TypeChecker_Common.res_typ in
-                                                        let app3 =
-                                                          FStar_TypeChecker_Util.maybe_monadic
-                                                            env app2
-                                                            comp.FStar_TypeChecker_Common.eff_name
-                                                            comp.FStar_TypeChecker_Common.res_typ in
-                                                        let bind_lifted_args
-                                                          e uu___10 =
-                                                          match uu___10 with
-                                                          | FStar_Pervasives_Native.None
-                                                              -> e
-                                                          | FStar_Pervasives_Native.Some
-                                                              (x, m, t, e1)
-                                                              ->
-                                                              let lb =
-                                                                FStar_Syntax_Util.mk_letbinding
-                                                                  (FStar_Pervasives.Inl
-                                                                    x) [] t m
-                                                                  e1 []
-                                                                  e1.FStar_Syntax_Syntax.pos in
-                                                              let letbinding
-                                                                =
-                                                                let uu___11 =
-                                                                  let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    let uu___14
-                                                                    =
-                                                                    let uu___15
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    x in
-                                                                    [uu___15] in
-                                                                    FStar_Syntax_Subst.close
-                                                                    uu___14 e in
-                                                                    ((false,
-                                                                    [lb]),
-                                                                    uu___13) in
-                                                                  FStar_Syntax_Syntax.Tm_let
-                                                                    uu___12 in
-                                                                FStar_Syntax_Syntax.mk
-                                                                  uu___11
-                                                                  e.FStar_Syntax_Syntax.pos in
-                                                              FStar_Syntax_Syntax.mk
-                                                                (FStar_Syntax_Syntax.Tm_meta
-                                                                   (letbinding,
-                                                                    (FStar_Syntax_Syntax.Meta_monadic
-                                                                    (m,
-                                                                    (comp.FStar_TypeChecker_Common.res_typ)))))
-                                                                e.FStar_Syntax_Syntax.pos in
-                                                        FStar_Compiler_List.fold_left
-                                                          bind_lifted_args
-                                                          app3 lifted_args) in
-                                               let uu___8 =
-                                                 FStar_TypeChecker_Util.strengthen_precondition
-                                                   FStar_Pervasives_Native.None
-                                                   env app comp guard2 in
-                                               (match uu___8 with
-                                                | (comp1, g) ->
-                                                    ((let uu___10 =
-                                                        FStar_TypeChecker_Env.debug
-                                                          env
-                                                          FStar_Options.Extreme in
-                                                      if uu___10
-                                                      then
-                                                        let uu___11 =
-                                                          FStar_Syntax_Print.term_to_string
-                                                            app in
-                                                        let uu___12 =
-                                                          FStar_TypeChecker_Common.lcomp_to_string
-                                                            comp1 in
-                                                        FStar_Compiler_Util.print2
-                                                          "(d) Monadic app: type of app\n\t(%s)\n\t: %s\n"
-                                                          uu___11 uu___12
-                                                      else ());
-                                                     (app, comp1, g))))))))) in
-               let rec tc_args head_info uu___1 bs args1 =
-                 match uu___1 with
-                 | (subst, outargs, arg_rets, g, fvs) ->
-                     (match (bs, args1) with
-                      | ({ FStar_Syntax_Syntax.binder_bv = x;
-                           FStar_Syntax_Syntax.binder_qual =
-                             FStar_Pervasives_Native.Some
-                             (FStar_Syntax_Syntax.Implicit uu___2);
-                           FStar_Syntax_Syntax.binder_attrs = [];_}::rest,
-                         (uu___3, FStar_Pervasives_Native.None)::uu___4) ->
-                          let t =
-                            FStar_Syntax_Subst.subst subst
-                              x.FStar_Syntax_Syntax.sort in
-                          let uu___5 =
-                            check_no_escape
-                              (FStar_Pervasives_Native.Some head) env fvs t in
-                          (match uu___5 with
-                           | (t1, g_ex) ->
-                               let r1 =
-                                 match outargs with
-                                 | [] -> head.FStar_Syntax_Syntax.pos
-                                 | ((t2, uu___6), uu___7, uu___8)::uu___9 ->
-                                     let uu___10 =
-                                       FStar_Compiler_Range.def_range
-                                         head.FStar_Syntax_Syntax.pos in
-                                     let uu___11 =
-                                       let uu___12 =
-                                         FStar_Compiler_Range.use_range
-                                           head.FStar_Syntax_Syntax.pos in
-                                       let uu___13 =
-                                         FStar_Compiler_Range.use_range
-                                           t2.FStar_Syntax_Syntax.pos in
-                                       FStar_Compiler_Range.union_rng uu___12
-                                         uu___13 in
-                                     FStar_Compiler_Range.range_of_rng
-                                       uu___10 uu___11 in
-                               let uu___6 =
-                                 FStar_TypeChecker_Util.new_implicit_var
-                                   "Instantiating implicit argument in application"
-                                   r1 env t1 in
-                               (match uu___6 with
-                                | (varg, uu___7, implicits) ->
-                                    let subst1 =
-                                      (FStar_Syntax_Syntax.NT (x, varg)) ::
-                                      subst in
-                                    let arg =
-                                      let uu___8 =
-                                        FStar_Syntax_Syntax.as_aqual_implicit
-                                          true in
-                                      (varg, uu___8) in
-                                    let guard =
-                                      FStar_Compiler_List.fold_right
-                                        FStar_TypeChecker_Env.conj_guard
-                                        [g_ex; g] implicits in
-                                    let uu___8 =
-                                      let uu___9 =
-                                        let uu___10 =
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_Syntax_Syntax.mk_Total t1 in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___12
-                                              FStar_TypeChecker_Common.lcomp_of_comp in
-                                          (arg, FStar_Pervasives_Native.None,
-                                            uu___11) in
-                                        uu___10 :: outargs in
-                                      (subst1, uu___9, (arg :: arg_rets),
-                                        guard, fvs) in
-                                    tc_args head_info uu___8 rest args1))
-                      | ({ FStar_Syntax_Syntax.binder_bv = x;
-                           FStar_Syntax_Syntax.binder_qual = qual;
-                           FStar_Syntax_Syntax.binder_attrs = attrs;_}::rest,
-                         (uu___2, FStar_Pervasives_Native.None)::uu___3) when
-                          FStar_TypeChecker_Util.maybe_implicit_with_meta_or_attr
-                            qual attrs
-                          ->
-                          let uu___4 =
-                            match (qual, attrs) with
-                            | (FStar_Pervasives_Native.Some
-                               (FStar_Syntax_Syntax.Meta tau), uu___5) ->
-                                let tau1 = FStar_Syntax_Subst.subst subst tau in
-                                let uu___6 =
-                                  tc_tactic FStar_Syntax_Syntax.t_unit
-                                    FStar_Syntax_Syntax.t_unit env tau1 in
-                                (match uu___6 with
-                                 | (tau2, uu___7, g_tau) ->
-                                     let uu___8 =
-                                       let uu___9 =
-                                         let uu___10 =
-                                           FStar_Compiler_Dyn.mkdyn env in
-                                         (uu___10, tau2) in
-                                       FStar_Syntax_Syntax.Ctx_uvar_meta_tac
-                                         uu___9 in
-                                     (uu___8, g_tau))
-                            | (FStar_Pervasives_Native.Some
-                               (FStar_Syntax_Syntax.Implicit uu___5),
-                               attr::uu___6) ->
-                                let attr1 =
-                                  FStar_Syntax_Subst.subst subst attr in
-                                let uu___7 = tc_tot_or_gtot_term env attr1 in
-                                (match uu___7 with
-                                 | (attr2, uu___8, g_attr) ->
-                                     ((FStar_Syntax_Syntax.Ctx_uvar_meta_attr
-                                         attr2), g_attr))
-                            | uu___5 ->
-                                failwith "Impossible, match is under a guard" in
-                          (match uu___4 with
-                           | (ctx_uvar_meta, g_tau_or_attr) ->
-                               let t =
-                                 FStar_Syntax_Subst.subst subst
-                                   x.FStar_Syntax_Syntax.sort in
-                               let uu___5 =
-                                 check_no_escape
-                                   (FStar_Pervasives_Native.Some head) env
-                                   fvs t in
-                               (match uu___5 with
-                                | (t1, g_ex) ->
-                                    let r1 =
-                                      match outargs with
-                                      | [] -> head.FStar_Syntax_Syntax.pos
-                                      | ((t2, uu___6), uu___7, uu___8)::uu___9
-                                          ->
-                                          let uu___10 =
-                                            FStar_Compiler_Range.def_range
-                                              head.FStar_Syntax_Syntax.pos in
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_Compiler_Range.use_range
-                                                head.FStar_Syntax_Syntax.pos in
-                                            let uu___13 =
-                                              FStar_Compiler_Range.use_range
-                                                t2.FStar_Syntax_Syntax.pos in
-                                            FStar_Compiler_Range.union_rng
-                                              uu___12 uu___13 in
-                                          FStar_Compiler_Range.range_of_rng
-                                            uu___10 uu___11 in
-                                    let uu___6 =
-                                      FStar_TypeChecker_Env.new_implicit_var_aux
-                                        "Instantiating meta argument in application"
-                                        r1 env t1 FStar_Syntax_Syntax.Strict
-                                        (FStar_Pervasives_Native.Some
-                                           ctx_uvar_meta) in
-                                    (match uu___6 with
-                                     | (varg, uu___7, implicits) ->
-                                         let subst1 =
-                                           (FStar_Syntax_Syntax.NT (x, varg))
-                                           :: subst in
-                                         let aq =
-                                           let uu___8 =
-                                             FStar_Compiler_List.hd bs in
-                                           FStar_Syntax_Util.aqual_of_binder
-                                             uu___8 in
-                                         let arg = (varg, aq) in
-                                         let guard =
-                                           FStar_Compiler_List.fold_right
-                                             FStar_TypeChecker_Env.conj_guard
-                                             [g_ex; g; g_tau_or_attr]
-                                             implicits in
-                                         let uu___8 =
-                                           let uu___9 =
-                                             let uu___10 =
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Syntax_Syntax.mk_Total
-                                                     t1 in
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   uu___12
-                                                   FStar_TypeChecker_Common.lcomp_of_comp in
-                                               (arg,
-                                                 FStar_Pervasives_Native.None,
-                                                 uu___11) in
-                                             uu___10 :: outargs in
-                                           (subst1, uu___9, (arg ::
-                                             arg_rets), guard, fvs) in
-                                         tc_args head_info uu___8 rest args1)))
-                      | ({ FStar_Syntax_Syntax.binder_bv = x;
-                           FStar_Syntax_Syntax.binder_qual = bqual;
-                           FStar_Syntax_Syntax.binder_attrs = b_attrs;_}::rest,
-                         (e, aq)::rest') ->
-                          let aq1 =
-                            let uu___2 = FStar_Compiler_List.hd bs in
-                            check_expected_aqual_for_binder aq uu___2
-                              e.FStar_Syntax_Syntax.pos in
-                          let targ =
-                            FStar_Syntax_Subst.subst subst
-                              x.FStar_Syntax_Syntax.sort in
-                          let bqual1 =
-                            FStar_Syntax_Subst.subst_bqual subst bqual in
-                          let x1 =
-                            {
-                              FStar_Syntax_Syntax.ppname =
-                                (x.FStar_Syntax_Syntax.ppname);
-                              FStar_Syntax_Syntax.index =
-                                (x.FStar_Syntax_Syntax.index);
-                              FStar_Syntax_Syntax.sort = targ
-                            } in
-                          ((let uu___3 =
-                              FStar_TypeChecker_Env.debug env
-                                FStar_Options.Extreme in
-                            if uu___3
-                            then
-                              let uu___4 = FStar_Syntax_Print.bv_to_string x1 in
-                              let uu___5 =
-                                FStar_Syntax_Print.term_to_string
-                                  x1.FStar_Syntax_Syntax.sort in
-                              let uu___6 =
-                                FStar_Syntax_Print.term_to_string e in
-                              let uu___7 =
-                                FStar_Syntax_Print.subst_to_string subst in
-                              let uu___8 =
-                                FStar_Syntax_Print.term_to_string targ in
-                              FStar_Compiler_Util.print5
-                                "\tFormal is %s : %s\tType of arg %s (after subst %s) = %s\n"
-                                uu___4 uu___5 uu___6 uu___7 uu___8
-                            else ());
-                           (let uu___3 =
-                              check_no_escape
-                                (FStar_Pervasives_Native.Some head) env fvs
-                                targ in
-                            match uu___3 with
-                            | (targ1, g_ex) ->
-                                let env1 =
-                                  FStar_TypeChecker_Env.set_expected_typ_maybe_eq
-                                    env targ1 (is_eq bqual1) in
-                                ((let uu___5 =
-                                    FStar_TypeChecker_Env.debug env1
-                                      FStar_Options.High in
-                                  if uu___5
-                                  then
-                                    let uu___6 =
-                                      FStar_Syntax_Print.tag_of_term e in
-                                    let uu___7 =
-                                      FStar_Syntax_Print.term_to_string e in
-                                    let uu___8 =
-                                      FStar_Syntax_Print.term_to_string targ1 in
-                                    let uu___9 =
-                                      let uu___10 =
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          bqual1 is_eq in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___10
-                                        FStar_Compiler_Util.string_of_bool in
-                                    FStar_Compiler_Util.print4
-                                      "Checking arg (%s) %s at type %s with use_eq:%s\n"
-                                      uu___6 uu___7 uu___8 uu___9
-                                  else ());
-                                 (let uu___5 = tc_term env1 e in
-                                  match uu___5 with
-                                  | (e1, c, g_e) ->
-                                      let g1 =
-                                        let uu___6 =
-                                          FStar_TypeChecker_Env.conj_guard g
-                                            g_e in
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (FStar_TypeChecker_Env.conj_guard
-                                             g_ex) uu___6 in
-                                      let arg = (e1, aq1) in
-                                      let xterm =
-                                        let uu___6 =
-                                          FStar_Syntax_Syntax.bv_to_name x1 in
-                                        (uu___6, aq1) in
-                                      let uu___6 =
-                                        (FStar_TypeChecker_Common.is_tot_or_gtot_lcomp
-                                           c)
-                                          ||
-                                          (FStar_TypeChecker_Util.is_pure_or_ghost_effect
-                                             env1
-                                             c.FStar_TypeChecker_Common.eff_name) in
-                                      if uu___6
-                                      then
-                                        let subst1 =
-                                          let uu___7 =
-                                            FStar_Compiler_List.hd bs in
-                                          maybe_extend_subst subst uu___7 e1 in
-                                        tc_args head_info
-                                          (subst1,
-                                            ((arg,
-                                               (FStar_Pervasives_Native.Some
-                                                  x1), c) :: outargs), (xterm
-                                            :: arg_rets), g1, fvs) rest rest'
-                                      else
-                                        tc_args head_info
-                                          (subst,
-                                            ((arg,
-                                               (FStar_Pervasives_Native.Some
-                                                  x1), c) :: outargs), (xterm
-                                            :: arg_rets), g1, (x1 :: fvs))
-                                          rest rest'))))
-                      | (uu___2, []) ->
-                          monadic_application head_info subst outargs
-                            arg_rets g fvs bs
-                      | ([], arg::uu___2) ->
-                          let uu___3 =
-                            monadic_application head_info subst outargs
-                              arg_rets g fvs [] in
-                          (match uu___3 with
-                           | (head1, chead1, ghead1) ->
-                               let uu___4 =
-                                 let uu___5 =
-                                   FStar_TypeChecker_Common.lcomp_comp chead1 in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                   (fun uu___6 ->
-                                      match uu___6 with
-                                      | (c, g1) ->
-                                          let uu___7 =
-                                            FStar_TypeChecker_Env.conj_guard
-                                              ghead1 g1 in
-                                          (c, uu___7)) in
-                               (match uu___4 with
-                                | (chead2, ghead2) ->
-                                    let rec aux norm1 solve ghead3 tres =
-                                      let tres1 =
-                                        let uu___5 =
-                                          FStar_Syntax_Subst.compress tres in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___5 FStar_Syntax_Util.unrefine in
-                                      match tres1.FStar_Syntax_Syntax.n with
-                                      | FStar_Syntax_Syntax.Tm_arrow
-                                          (bs1, cres') ->
-                                          let uu___5 =
-                                            FStar_Syntax_Subst.open_comp bs1
-                                              cres' in
-                                          (match uu___5 with
-                                           | (bs2, cres'1) ->
-                                               let head_info1 =
-                                                 (head1, chead2, ghead3,
-                                                   cres'1) in
-                                               ((let uu___7 =
-                                                   FStar_TypeChecker_Env.debug
-                                                     env FStar_Options.Low in
-                                                 if uu___7
-                                                 then
-                                                   FStar_Errors.log_issue
-                                                     tres1.FStar_Syntax_Syntax.pos
-                                                     (FStar_Errors.Warning_RedundantExplicitCurrying,
-                                                       "Potentially redundant explicit currying of a function type")
-                                                 else ());
-                                                tc_args head_info1
-                                                  ([], [], [],
-                                                    FStar_TypeChecker_Env.trivial_guard,
-                                                    []) bs2 args1))
-                                      | uu___5 when Prims.op_Negation norm1
-                                          ->
-                                          let rec norm_tres tres2 =
-                                            let tres3 =
-                                              let uu___6 =
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  tres2
-                                                  (FStar_TypeChecker_Normalize.unfold_whnf
-                                                     env) in
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                uu___6
-                                                FStar_Syntax_Util.unascribe in
-                                            let uu___6 =
-                                              let uu___7 =
-                                                FStar_Syntax_Subst.compress
-                                                  tres3 in
-                                              uu___7.FStar_Syntax_Syntax.n in
-                                            match uu___6 with
-                                            | FStar_Syntax_Syntax.Tm_refine
-                                                ({
-                                                   FStar_Syntax_Syntax.ppname
-                                                     = uu___7;
-                                                   FStar_Syntax_Syntax.index
-                                                     = uu___8;
-                                                   FStar_Syntax_Syntax.sort =
-                                                     tres4;_},
-                                                 uu___9)
-                                                -> norm_tres tres4
-                                            | uu___7 -> tres3 in
-                                          let uu___6 = norm_tres tres1 in
-                                          aux true solve ghead3 uu___6
-                                      | uu___5 when Prims.op_Negation solve
-                                          ->
-                                          let ghead4 =
-                                            FStar_TypeChecker_Rel.solve_deferred_constraints
-                                              env ghead3 in
-                                          aux norm1 true ghead4 tres1
-                                      | uu___5 ->
-                                          let uu___6 =
-                                            let uu___7 =
-                                              let uu___8 =
-                                                FStar_TypeChecker_Normalize.term_to_string
-                                                  env thead in
-                                              let uu___9 =
-                                                FStar_Compiler_Util.string_of_int
-                                                  n_args in
-                                              let uu___10 =
-                                                FStar_Syntax_Print.term_to_string
-                                                  tres1 in
-                                              FStar_Compiler_Util.format3
-                                                "Too many arguments to function of type %s; got %s arguments, remaining type is %s"
-                                                uu___8 uu___9 uu___10 in
-                                            (FStar_Errors.Fatal_ToManyArgumentToFunction,
-                                              uu___7) in
-                                          let uu___7 =
-                                            FStar_Syntax_Syntax.argpos arg in
-                                          FStar_Errors.raise_error uu___6
-                                            uu___7 in
-                                    aux false false ghead2
-                                      (FStar_Syntax_Util.comp_result chead2)))) in
-               let rec check_function_app tf guard =
-                 let uu___1 =
-                   let uu___2 =
-                     FStar_TypeChecker_Normalize.unfold_whnf env tf in
-                   uu___2.FStar_Syntax_Syntax.n in
-                 match uu___1 with
-                 | FStar_Syntax_Syntax.Tm_uvar uu___2 ->
-                     let uu___3 =
-                       FStar_Compiler_List.fold_right
-                         (fun uu___4 ->
-                            fun uu___5 ->
-                              match uu___5 with
-                              | (bs, guard1) ->
-                                  let uu___6 =
-                                    let uu___7 =
-                                      let uu___8 =
-                                        FStar_Syntax_Util.type_u () in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___8 FStar_Pervasives_Native.fst in
-                                    FStar_TypeChecker_Util.new_implicit_var
-                                      "formal parameter"
-                                      tf.FStar_Syntax_Syntax.pos env uu___7 in
-                                  (match uu___6 with
-                                   | (t, uu___7, g) ->
-                                       let uu___8 =
-                                         let uu___9 =
-                                           FStar_Syntax_Syntax.null_binder t in
-                                         uu___9 :: bs in
-                                       let uu___9 =
-                                         FStar_TypeChecker_Env.conj_guard g
-                                           guard1 in
-                                       (uu___8, uu___9))) args ([], guard) in
-                     (match uu___3 with
-                      | (bs, guard1) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 = FStar_Syntax_Util.type_u () in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                  FStar_Pervasives_Native.fst in
-                              FStar_TypeChecker_Util.new_implicit_var
-                                "result type" tf.FStar_Syntax_Syntax.pos env
-                                uu___6 in
-                            match uu___5 with
-                            | (t, uu___6, g) ->
-                                let uu___7 = FStar_Options.ml_ish () in
-                                if uu___7
-                                then
-                                  let uu___8 = FStar_Syntax_Util.ml_comp t r in
-                                  let uu___9 =
-                                    FStar_TypeChecker_Env.conj_guard guard1 g in
-                                  (uu___8, uu___9)
-                                else
-                                  (let uu___9 =
-                                     FStar_Syntax_Syntax.mk_Total t in
-                                   let uu___10 =
-                                     FStar_TypeChecker_Env.conj_guard guard1
-                                       g in
-                                   (uu___9, uu___10)) in
-                          (match uu___4 with
-                           | (cres, guard2) ->
-                               let bs_cres = FStar_Syntax_Util.arrow bs cres in
-                               ((let uu___6 =
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env)
-                                     FStar_Options.Extreme in
-                                 if uu___6
-                                 then
-                                   let uu___7 =
-                                     FStar_Syntax_Print.term_to_string head in
-                                   let uu___8 =
-                                     FStar_Syntax_Print.term_to_string tf in
-                                   let uu___9 =
-                                     FStar_Syntax_Print.term_to_string
-                                       bs_cres in
-                                   FStar_Compiler_Util.print3
-                                     "Forcing the type of %s from %s to %s\n"
-                                     uu___7 uu___8 uu___9
-                                 else ());
-                                (let g =
-                                   let uu___6 =
-                                     FStar_TypeChecker_Rel.teq env tf bs_cres in
-                                   FStar_TypeChecker_Rel.solve_deferred_constraints
-                                     env uu___6 in
-                                 let uu___6 =
-                                   FStar_TypeChecker_Env.conj_guard g guard2 in
-                                 check_function_app bs_cres uu___6))))
-                 | FStar_Syntax_Syntax.Tm_app
-                     ({
-                        FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_uvar
-                          uu___2;
-                        FStar_Syntax_Syntax.pos = uu___3;
-                        FStar_Syntax_Syntax.vars = uu___4;
-                        FStar_Syntax_Syntax.hash_code = uu___5;_},
-                      uu___6)
-                     ->
-                     let uu___7 =
-                       FStar_Compiler_List.fold_right
-                         (fun uu___8 ->
-                            fun uu___9 ->
-                              match uu___9 with
-                              | (bs, guard1) ->
-                                  let uu___10 =
-                                    let uu___11 =
-                                      let uu___12 =
-                                        FStar_Syntax_Util.type_u () in
-                                      FStar_Compiler_Effect.op_Bar_Greater
-                                        uu___12 FStar_Pervasives_Native.fst in
-                                    FStar_TypeChecker_Util.new_implicit_var
-                                      "formal parameter"
-                                      tf.FStar_Syntax_Syntax.pos env uu___11 in
-                                  (match uu___10 with
-                                   | (t, uu___11, g) ->
-                                       let uu___12 =
-                                         let uu___13 =
-                                           FStar_Syntax_Syntax.null_binder t in
-                                         uu___13 :: bs in
-                                       let uu___13 =
-                                         FStar_TypeChecker_Env.conj_guard g
-                                           guard1 in
-                                       (uu___12, uu___13))) args ([], guard) in
-                     (match uu___7 with
-                      | (bs, guard1) ->
-                          let uu___8 =
-                            let uu___9 =
-                              let uu___10 =
-                                let uu___11 = FStar_Syntax_Util.type_u () in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___11
-                                  FStar_Pervasives_Native.fst in
-                              FStar_TypeChecker_Util.new_implicit_var
-                                "result type" tf.FStar_Syntax_Syntax.pos env
-                                uu___10 in
-                            match uu___9 with
-                            | (t, uu___10, g) ->
-                                let uu___11 = FStar_Options.ml_ish () in
-                                if uu___11
-                                then
-                                  let uu___12 = FStar_Syntax_Util.ml_comp t r in
-                                  let uu___13 =
-                                    FStar_TypeChecker_Env.conj_guard guard1 g in
-                                  (uu___12, uu___13)
-                                else
-                                  (let uu___13 =
-                                     FStar_Syntax_Syntax.mk_Total t in
-                                   let uu___14 =
-                                     FStar_TypeChecker_Env.conj_guard guard1
-                                       g in
-                                   (uu___13, uu___14)) in
-                          (match uu___8 with
-                           | (cres, guard2) ->
-                               let bs_cres = FStar_Syntax_Util.arrow bs cres in
-                               ((let uu___10 =
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env)
-                                     FStar_Options.Extreme in
-                                 if uu___10
-                                 then
-                                   let uu___11 =
-                                     FStar_Syntax_Print.term_to_string head in
-                                   let uu___12 =
-                                     FStar_Syntax_Print.term_to_string tf in
-                                   let uu___13 =
-                                     FStar_Syntax_Print.term_to_string
-                                       bs_cres in
-                                   FStar_Compiler_Util.print3
-                                     "Forcing the type of %s from %s to %s\n"
-                                     uu___11 uu___12 uu___13
-                                 else ());
-                                (let g =
-                                   let uu___10 =
-                                     FStar_TypeChecker_Rel.teq env tf bs_cres in
-                                   FStar_TypeChecker_Rel.solve_deferred_constraints
-                                     env uu___10 in
-                                 let uu___10 =
-                                   FStar_TypeChecker_Env.conj_guard g guard2 in
-                                 check_function_app bs_cres uu___10))))
-                 | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                     let uu___2 = FStar_Syntax_Subst.open_comp bs c in
-                     (match uu___2 with
-                      | (bs1, c1) ->
-                          let head_info = (head, chead, ghead, c1) in
-                          ((let uu___4 =
-                              FStar_TypeChecker_Env.debug env
-                                FStar_Options.Extreme in
-                            if uu___4
-                            then
-                              let uu___5 =
-                                FStar_Syntax_Print.term_to_string head in
-                              let uu___6 =
-                                FStar_Syntax_Print.term_to_string tf in
-                              let uu___7 =
-                                FStar_Syntax_Print.binders_to_string ", " bs1 in
-                              let uu___8 =
-                                FStar_Syntax_Print.comp_to_string c1 in
-                              FStar_Compiler_Util.print4
-                                "######tc_args of head %s @ %s with formals=%s and result type=%s\n"
-                                uu___5 uu___6 uu___7 uu___8
-                            else ());
-                           tc_args head_info ([], [], [], guard, []) bs1 args))
-                 | FStar_Syntax_Syntax.Tm_refine (bv, uu___2) ->
-                     check_function_app bv.FStar_Syntax_Syntax.sort guard
-                 | FStar_Syntax_Syntax.Tm_ascribed (t, uu___2, uu___3) ->
-                     check_function_app t guard
-                 | uu___2 ->
-                     let uu___3 =
-                       FStar_TypeChecker_Err.expected_function_typ env tf in
-                     FStar_Errors.raise_error uu___3
-                       head.FStar_Syntax_Syntax.pos in
-               check_function_app thead FStar_TypeChecker_Env.trivial_guard)
-and (check_short_circuit_args :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_TypeChecker_Env.guard_t ->
-          (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-            FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-            Prims.list ->
-            (FStar_Syntax_Syntax.typ * Prims.bool)
-              FStar_Pervasives_Native.option ->
-              (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-                FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun head ->
-      fun chead ->
-        fun g_head ->
-          fun args ->
-            fun expected_topt ->
-              let r = FStar_TypeChecker_Env.get_range env in
-              let tf =
-                FStar_Syntax_Subst.compress
-                  (FStar_Syntax_Util.comp_result chead) in
-              match tf.FStar_Syntax_Syntax.n with
-              | FStar_Syntax_Syntax.Tm_arrow (bs, c) when
-                  (FStar_Syntax_Util.is_total_comp c) &&
-                    ((FStar_Compiler_List.length bs) =
-                       (FStar_Compiler_List.length args))
-                  ->
-                  let res_t = FStar_Syntax_Util.comp_result c in
-                  let uu___ =
-                    FStar_Compiler_List.fold_left2
-                      (fun uu___1 ->
-                         fun uu___2 ->
-                           fun b ->
-                             match (uu___1, uu___2) with
-                             | ((seen, guard, ghost), (e, aq)) ->
-                                 let aq1 =
-                                   check_expected_aqual_for_binder aq b
-                                     e.FStar_Syntax_Syntax.pos in
-                                 let uu___3 =
-                                   tc_check_tot_or_gtot_term env e
-                                     (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                                     "arguments to short circuiting operators must be pure or ghost" in
-                                 (match uu___3 with
-                                  | (e1, c1, g) ->
-                                      let short =
-                                        FStar_TypeChecker_Util.short_circuit
-                                          head seen in
-                                      let g1 =
-                                        let uu___4 =
-                                          FStar_TypeChecker_Env.guard_of_guard_formula
-                                            short in
-                                        FStar_TypeChecker_Env.imp_guard
-                                          uu___4 g in
-                                      let ghost1 =
-                                        ghost ||
-                                          ((let uu___4 =
-                                              FStar_TypeChecker_Common.is_total_lcomp
-                                                c1 in
-                                            Prims.op_Negation uu___4) &&
-                                             (let uu___4 =
-                                                FStar_TypeChecker_Util.is_pure_effect
-                                                  env
-                                                  c1.FStar_TypeChecker_Common.eff_name in
-                                              Prims.op_Negation uu___4)) in
-                                      let uu___4 =
-                                        FStar_TypeChecker_Env.conj_guard
-                                          guard g1 in
-                                      ((FStar_Compiler_List.op_At seen
-                                          [(e1, aq1)]), uu___4, ghost1)))
-                      ([], g_head, false) args bs in
-                  (match uu___ with
-                   | (args1, guard, ghost) ->
-                       let e = FStar_Syntax_Syntax.mk_Tm_app head args1 r in
-                       let c1 =
-                         if ghost
-                         then
-                           let uu___1 = FStar_Syntax_Syntax.mk_GTotal res_t in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___1
-                             FStar_TypeChecker_Common.lcomp_of_comp
-                         else FStar_TypeChecker_Common.lcomp_of_comp c in
-                       let uu___1 =
-                         FStar_TypeChecker_Util.strengthen_precondition
-                           FStar_Pervasives_Native.None env e c1 guard in
-                       (match uu___1 with | (c2, g) -> (e, c2, g)))
-              | uu___ ->
-                  check_application_args env head chead g_head args
-                    expected_topt
-and (tc_pat :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.pat ->
-        (FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.bv Prims.list *
-          FStar_Syntax_Syntax.term Prims.list * FStar_TypeChecker_Env.env *
-          FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.term *
-          FStar_TypeChecker_Env.guard_t * Prims.bool))
-  =
-  fun env ->
-    fun pat_t ->
-      fun p0 ->
-        let fail msg =
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_MismatchedPatternType, msg)
-            p0.FStar_Syntax_Syntax.p in
-        let expected_pat_typ env1 pos scrutinee_t =
-          let rec aux norm1 t =
-            let t1 = FStar_Syntax_Util.unrefine t in
-            let uu___ = FStar_Syntax_Util.head_and_args t1 in
-            match uu___ with
-            | (head, args) ->
-                let uu___1 =
-                  let uu___2 = FStar_Syntax_Subst.compress head in
-                  uu___2.FStar_Syntax_Syntax.n in
-                (match uu___1 with
-                 | FStar_Syntax_Syntax.Tm_uinst
-                     ({
-                        FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar f;
-                        FStar_Syntax_Syntax.pos = uu___2;
-                        FStar_Syntax_Syntax.vars = uu___3;
-                        FStar_Syntax_Syntax.hash_code = uu___4;_},
-                      us)
-                     -> unfold_once t1 f us args
-                 | FStar_Syntax_Syntax.Tm_fvar f -> unfold_once t1 f [] args
-                 | uu___2 ->
-                     if norm1
-                     then t1
-                     else
-                       (let uu___4 =
-                          FStar_TypeChecker_Normalize.normalize
-                            [FStar_TypeChecker_Env.HNF;
-                            FStar_TypeChecker_Env.Unmeta;
-                            FStar_TypeChecker_Env.Unascribe;
-                            FStar_TypeChecker_Env.UnfoldUntil
-                              FStar_Syntax_Syntax.delta_constant] env1 t1 in
-                        aux true uu___4))
-          and unfold_once t f us args =
-            let uu___ =
-              FStar_TypeChecker_Env.is_type_constructor env1
-                (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-            if uu___
-            then t
-            else
-              (let uu___2 =
-                 FStar_TypeChecker_Env.lookup_definition
-                   [FStar_TypeChecker_Env.Unfold
-                      FStar_Syntax_Syntax.delta_constant] env1
-                   (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-               match uu___2 with
-               | FStar_Pervasives_Native.None -> t
-               | FStar_Pervasives_Native.Some head_def_ts ->
-                   let uu___3 =
-                     FStar_TypeChecker_Env.inst_tscheme_with head_def_ts us in
-                   (match uu___3 with
-                    | (uu___4, head_def) ->
-                        let t' =
-                          FStar_Syntax_Syntax.mk_Tm_app head_def args
-                            t.FStar_Syntax_Syntax.pos in
-                        let t'1 =
-                          FStar_TypeChecker_Normalize.normalize
-                            [FStar_TypeChecker_Env.Beta;
-                            FStar_TypeChecker_Env.Iota] env1 t' in
-                        aux false t'1)) in
-          let uu___ =
-            FStar_TypeChecker_Normalize.normalize
-              [FStar_TypeChecker_Env.Beta; FStar_TypeChecker_Env.Iota] env1
-              scrutinee_t in
-          aux false uu___ in
-        let pat_typ_ok env1 pat_t1 scrutinee_t =
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_TypeChecker_Env.debug env1)
-               (FStar_Options.Other "Patterns") in
-           if uu___1
-           then
-             let uu___2 = FStar_Syntax_Print.term_to_string pat_t1 in
-             let uu___3 = FStar_Syntax_Print.term_to_string scrutinee_t in
-             FStar_Compiler_Util.print2 "$$$$$$$$$$$$pat_typ_ok? %s vs. %s\n"
-               uu___2 uu___3
-           else ());
-          (let fail1 msg =
-             let msg1 =
-               let uu___1 = FStar_Syntax_Print.term_to_string pat_t1 in
-               let uu___2 = FStar_Syntax_Print.term_to_string scrutinee_t in
-               FStar_Compiler_Util.format3
-                 "Type of pattern (%s) does not match type of scrutinee (%s)%s"
-                 uu___1 uu___2 msg in
-             FStar_Errors.raise_error
-               (FStar_Errors.Fatal_MismatchedPatternType, msg1)
-               p0.FStar_Syntax_Syntax.p in
-           let uu___1 = FStar_Syntax_Util.head_and_args scrutinee_t in
-           match uu___1 with
-           | (head_s, args_s) ->
-               let pat_t2 =
-                 FStar_TypeChecker_Normalize.normalize
-                   [FStar_TypeChecker_Env.Beta] env1 pat_t1 in
-               let uu___2 = FStar_Syntax_Util.un_uinst head_s in
-               (match uu___2 with
-                | {
-                    FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                      uu___3;
-                    FStar_Syntax_Syntax.pos = uu___4;
-                    FStar_Syntax_Syntax.vars = uu___5;
-                    FStar_Syntax_Syntax.hash_code = uu___6;_} ->
-                    let uu___7 = FStar_Syntax_Util.head_and_args pat_t2 in
-                    (match uu___7 with
-                     | (head_p, args_p) ->
-                         let uu___8 =
-                           FStar_TypeChecker_Rel.teq_nosmt_force env1 head_p
-                             head_s in
-                         if uu___8
-                         then
-                           let uu___9 =
-                             let uu___10 = FStar_Syntax_Util.un_uinst head_p in
-                             uu___10.FStar_Syntax_Syntax.n in
-                           (match uu___9 with
-                            | FStar_Syntax_Syntax.Tm_fvar f ->
-                                ((let uu___11 =
-                                    let uu___12 =
-                                      let uu___13 =
-                                        FStar_Syntax_Syntax.lid_of_fv f in
-                                      FStar_TypeChecker_Env.is_type_constructor
-                                        env1 uu___13 in
-                                    FStar_Compiler_Effect.op_Less_Bar
-                                      Prims.op_Negation uu___12 in
-                                  if uu___11
-                                  then
-                                    fail1
-                                      "Pattern matching a non-inductive type"
-                                  else ());
-                                 if
-                                   (FStar_Compiler_List.length args_p) <>
-                                     (FStar_Compiler_List.length args_s)
-                                 then fail1 ""
-                                 else ();
-                                 (let uu___12 =
-                                    let uu___13 =
-                                      let uu___14 =
-                                        FStar_Syntax_Syntax.lid_of_fv f in
-                                      FStar_TypeChecker_Env.num_inductive_ty_params
-                                        env1 uu___14 in
-                                    match uu___13 with
-                                    | FStar_Pervasives_Native.None ->
-                                        (args_p, args_s)
-                                    | FStar_Pervasives_Native.Some n ->
-                                        let uu___14 =
-                                          FStar_Compiler_Util.first_N n
-                                            args_p in
-                                        (match uu___14 with
-                                         | (params_p, uu___15) ->
-                                             let uu___16 =
-                                               FStar_Compiler_Util.first_N n
-                                                 args_s in
-                                             (match uu___16 with
-                                              | (params_s, uu___17) ->
-                                                  (params_p, params_s))) in
-                                  match uu___12 with
-                                  | (params_p, params_s) ->
-                                      FStar_Compiler_List.fold_left2
-                                        (fun out ->
-                                           fun uu___13 ->
-                                             fun uu___14 ->
-                                               match (uu___13, uu___14) with
-                                               | ((p, uu___15), (s, uu___16))
-                                                   ->
-                                                   let uu___17 =
-                                                     FStar_TypeChecker_Rel.teq_nosmt
-                                                       env1 p s in
-                                                   (match uu___17 with
-                                                    | FStar_Pervasives_Native.None
-                                                        ->
-                                                        let uu___18 =
-                                                          let uu___19 =
-                                                            FStar_Syntax_Print.term_to_string
-                                                              p in
-                                                          let uu___20 =
-                                                            FStar_Syntax_Print.term_to_string
-                                                              s in
-                                                          FStar_Compiler_Util.format2
-                                                            "; parameter %s <> parameter %s"
-                                                            uu___19 uu___20 in
-                                                        fail1 uu___18
-                                                    | FStar_Pervasives_Native.Some
-                                                        g ->
-                                                        let g1 =
-                                                          FStar_TypeChecker_Rel.discharge_guard_no_smt
-                                                            env1 g in
-                                                        FStar_TypeChecker_Env.conj_guard
-                                                          g1 out))
-                                        FStar_TypeChecker_Env.trivial_guard
-                                        params_p params_s))
-                            | uu___10 ->
-                                fail1 "Pattern matching a non-inductive type")
-                         else
-                           (let uu___10 =
-                              let uu___11 =
-                                FStar_Syntax_Print.term_to_string head_p in
-                              let uu___12 =
-                                FStar_Syntax_Print.term_to_string head_s in
-                              FStar_Compiler_Util.format2
-                                "; head mismatch %s vs %s" uu___11 uu___12 in
-                            fail1 uu___10))
-                | uu___3 ->
-                    let uu___4 =
-                      FStar_TypeChecker_Rel.teq_nosmt env1 pat_t2 scrutinee_t in
-                    (match uu___4 with
-                     | FStar_Pervasives_Native.None -> fail1 ""
-                     | FStar_Pervasives_Native.Some g ->
-                         let g1 =
-                           FStar_TypeChecker_Rel.discharge_guard_no_smt env1
-                             g in
-                         g1))) in
-        let type_of_simple_pat env1 e =
-          let uu___ = FStar_Syntax_Util.head_and_args e in
-          match uu___ with
-          | (head, args) ->
-              (match head.FStar_Syntax_Syntax.n with
-               | FStar_Syntax_Syntax.Tm_uinst
-                   ({
-                      FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar
-                        uu___1;
-                      FStar_Syntax_Syntax.pos = uu___2;
-                      FStar_Syntax_Syntax.vars = uu___3;
-                      FStar_Syntax_Syntax.hash_code = uu___4;_},
-                    uu___5)
-                   ->
-                   let uu___6 =
-                     match head.FStar_Syntax_Syntax.n with
-                     | FStar_Syntax_Syntax.Tm_uinst (head1, us) ->
-                         let uu___7 = head1.FStar_Syntax_Syntax.n in
-                         (match uu___7 with
-                          | FStar_Syntax_Syntax.Tm_fvar f ->
-                              let res =
-                                FStar_TypeChecker_Env.try_lookup_and_inst_lid
-                                  env1 us
-                                  (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                              (match res with
-                               | FStar_Pervasives_Native.Some (t, uu___8)
-                                   when
-                                   FStar_TypeChecker_Env.is_datacon env1
-                                     (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                   -> (head1, (us, t))
-                               | uu___8 ->
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Ident.string_of_lid
-                                         (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                     FStar_Compiler_Util.format1
-                                       "Could not find constructor: %s"
-                                       uu___10 in
-                                   fail uu___9))
-                     | FStar_Syntax_Syntax.Tm_fvar f ->
-                         let uu___7 =
-                           FStar_TypeChecker_Env.lookup_datacon env1
-                             (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                         (head, uu___7) in
-                   (match uu___6 with
-                    | (head1, (us, t_f)) ->
-                        let uu___7 = FStar_Syntax_Util.arrow_formals t_f in
-                        (match uu___7 with
-                         | (formals, t) ->
-                             let erasable =
-                               FStar_TypeChecker_Env.non_informative env1 t in
-                             (if
-                                (FStar_Compiler_List.length formals) <>
-                                  (FStar_Compiler_List.length args)
-                              then
-                                fail
-                                  "Pattern is not a fully-applied data constructor"
-                              else ();
-                              (let rec aux uu___9 formals1 args1 =
-                                 match uu___9 with
-                                 | (subst, args_out, bvs, guard) ->
-                                     (match (formals1, args1) with
-                                      | ([], []) ->
-                                          let head2 =
-                                            FStar_Syntax_Syntax.mk_Tm_uinst
-                                              head1 us in
-                                          let pat_e =
-                                            FStar_Syntax_Syntax.mk_Tm_app
-                                              head2 args_out
-                                              e.FStar_Syntax_Syntax.pos in
-                                          let uu___10 =
-                                            FStar_Syntax_Subst.subst subst t in
-                                          (pat_e, uu___10, bvs, guard,
-                                            erasable)
-                                      | ({ FStar_Syntax_Syntax.binder_bv = f;
-                                           FStar_Syntax_Syntax.binder_qual =
-                                             uu___10;
-                                           FStar_Syntax_Syntax.binder_attrs =
-                                             uu___11;_}::formals2,
-                                         (a, imp_a)::args2) ->
-                                          let t_f1 =
-                                            FStar_Syntax_Subst.subst subst
-                                              f.FStar_Syntax_Syntax.sort in
-                                          let uu___12 =
-                                            let uu___13 =
-                                              let uu___14 =
-                                                FStar_Syntax_Subst.compress a in
-                                              uu___14.FStar_Syntax_Syntax.n in
-                                            match uu___13 with
-                                            | FStar_Syntax_Syntax.Tm_name x
-                                                ->
-                                                let x1 =
-                                                  {
-                                                    FStar_Syntax_Syntax.ppname
-                                                      =
-                                                      (x.FStar_Syntax_Syntax.ppname);
-                                                    FStar_Syntax_Syntax.index
-                                                      =
-                                                      (x.FStar_Syntax_Syntax.index);
-                                                    FStar_Syntax_Syntax.sort
-                                                      = t_f1
-                                                  } in
-                                                let a1 =
-                                                  FStar_Syntax_Syntax.bv_to_name
-                                                    x1 in
-                                                let subst1 =
-                                                  (FStar_Syntax_Syntax.NT
-                                                     (f, a1))
-                                                  :: subst in
-                                                ((a1, imp_a), subst1,
-                                                  (FStar_Compiler_List.op_At
-                                                     bvs [x1]),
-                                                  FStar_TypeChecker_Env.trivial_guard)
-                                            | FStar_Syntax_Syntax.Tm_uvar
-                                                uu___14 ->
-                                                let use_eq = true in
-                                                let env2 =
-                                                  FStar_TypeChecker_Env.set_expected_typ_maybe_eq
-                                                    env1 t_f1 use_eq in
-                                                let uu___15 =
-                                                  tc_tot_or_gtot_term_maybe_solve_deferred
-                                                    env2 a "" false in
-                                                (match uu___15 with
-                                                 | (a1, uu___16, g) ->
-                                                     let subst1 =
-                                                       (FStar_Syntax_Syntax.NT
-                                                          (f, a1))
-                                                       :: subst in
-                                                     ((a1, imp_a), subst1,
-                                                       bvs, g))
-                                            | uu___14 ->
-                                                let a1 =
-                                                  FStar_Syntax_Subst.subst
-                                                    subst a in
-                                                let env2 =
-                                                  FStar_TypeChecker_Env.set_expected_typ
-                                                    env1 t_f1 in
-                                                let uu___15 =
-                                                  tc_tot_or_gtot_term env2 a1 in
-                                                (match uu___15 with
-                                                 | (a2, uu___16, g) ->
-                                                     let subst1 =
-                                                       (FStar_Syntax_Syntax.NT
-                                                          (f, a2))
-                                                       :: subst in
-                                                     ((a2, imp_a), subst1,
-                                                       bvs, g)) in
-                                          (match uu___12 with
-                                           | (a1, subst1, bvs1, g) ->
-                                               let uu___13 =
-                                                 let uu___14 =
-                                                   FStar_TypeChecker_Env.conj_guard
-                                                     g guard in
-                                                 (subst1,
-                                                   (FStar_Compiler_List.op_At
-                                                      args_out [a1]), bvs1,
-                                                   uu___14) in
-                                               aux uu___13 formals2 args2)
-                                      | uu___10 ->
-                                          fail "Not a fully applied pattern") in
-                               aux
-                                 ([], [], [],
-                                   FStar_TypeChecker_Env.trivial_guard)
-                                 formals args))))
-               | FStar_Syntax_Syntax.Tm_fvar uu___1 ->
-                   let uu___2 =
-                     match head.FStar_Syntax_Syntax.n with
-                     | FStar_Syntax_Syntax.Tm_uinst (head1, us) ->
-                         let uu___3 = head1.FStar_Syntax_Syntax.n in
-                         (match uu___3 with
-                          | FStar_Syntax_Syntax.Tm_fvar f ->
-                              let res =
-                                FStar_TypeChecker_Env.try_lookup_and_inst_lid
-                                  env1 us
-                                  (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                              (match res with
-                               | FStar_Pervasives_Native.Some (t, uu___4)
-                                   when
-                                   FStar_TypeChecker_Env.is_datacon env1
-                                     (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v
-                                   -> (head1, (us, t))
-                               | uu___4 ->
-                                   let uu___5 =
-                                     let uu___6 =
-                                       FStar_Ident.string_of_lid
-                                         (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                                     FStar_Compiler_Util.format1
-                                       "Could not find constructor: %s"
-                                       uu___6 in
-                                   fail uu___5))
-                     | FStar_Syntax_Syntax.Tm_fvar f ->
-                         let uu___3 =
-                           FStar_TypeChecker_Env.lookup_datacon env1
-                             (f.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                         (head, uu___3) in
-                   (match uu___2 with
-                    | (head1, (us, t_f)) ->
-                        let uu___3 = FStar_Syntax_Util.arrow_formals t_f in
-                        (match uu___3 with
-                         | (formals, t) ->
-                             let erasable =
-                               FStar_TypeChecker_Env.non_informative env1 t in
-                             (if
-                                (FStar_Compiler_List.length formals) <>
-                                  (FStar_Compiler_List.length args)
-                              then
-                                fail
-                                  "Pattern is not a fully-applied data constructor"
-                              else ();
-                              (let rec aux uu___5 formals1 args1 =
-                                 match uu___5 with
-                                 | (subst, args_out, bvs, guard) ->
-                                     (match (formals1, args1) with
-                                      | ([], []) ->
-                                          let head2 =
-                                            FStar_Syntax_Syntax.mk_Tm_uinst
-                                              head1 us in
-                                          let pat_e =
-                                            FStar_Syntax_Syntax.mk_Tm_app
-                                              head2 args_out
-                                              e.FStar_Syntax_Syntax.pos in
-                                          let uu___6 =
-                                            FStar_Syntax_Subst.subst subst t in
-                                          (pat_e, uu___6, bvs, guard,
-                                            erasable)
-                                      | ({ FStar_Syntax_Syntax.binder_bv = f;
-                                           FStar_Syntax_Syntax.binder_qual =
-                                             uu___6;
-                                           FStar_Syntax_Syntax.binder_attrs =
-                                             uu___7;_}::formals2,
-                                         (a, imp_a)::args2) ->
-                                          let t_f1 =
-                                            FStar_Syntax_Subst.subst subst
-                                              f.FStar_Syntax_Syntax.sort in
-                                          let uu___8 =
-                                            let uu___9 =
-                                              let uu___10 =
-                                                FStar_Syntax_Subst.compress a in
-                                              uu___10.FStar_Syntax_Syntax.n in
-                                            match uu___9 with
-                                            | FStar_Syntax_Syntax.Tm_name x
-                                                ->
-                                                let x1 =
-                                                  {
-                                                    FStar_Syntax_Syntax.ppname
-                                                      =
-                                                      (x.FStar_Syntax_Syntax.ppname);
-                                                    FStar_Syntax_Syntax.index
-                                                      =
-                                                      (x.FStar_Syntax_Syntax.index);
-                                                    FStar_Syntax_Syntax.sort
-                                                      = t_f1
-                                                  } in
-                                                let a1 =
-                                                  FStar_Syntax_Syntax.bv_to_name
-                                                    x1 in
-                                                let subst1 =
-                                                  (FStar_Syntax_Syntax.NT
-                                                     (f, a1))
-                                                  :: subst in
-                                                ((a1, imp_a), subst1,
-                                                  (FStar_Compiler_List.op_At
-                                                     bvs [x1]),
-                                                  FStar_TypeChecker_Env.trivial_guard)
-                                            | FStar_Syntax_Syntax.Tm_uvar
-                                                uu___10 ->
-                                                let use_eq = true in
-                                                let env2 =
-                                                  FStar_TypeChecker_Env.set_expected_typ_maybe_eq
-                                                    env1 t_f1 use_eq in
-                                                let uu___11 =
-                                                  tc_tot_or_gtot_term_maybe_solve_deferred
-                                                    env2 a "" false in
-                                                (match uu___11 with
-                                                 | (a1, uu___12, g) ->
-                                                     let subst1 =
-                                                       (FStar_Syntax_Syntax.NT
-                                                          (f, a1))
-                                                       :: subst in
-                                                     ((a1, imp_a), subst1,
-                                                       bvs, g))
-                                            | uu___10 ->
-                                                let a1 =
-                                                  FStar_Syntax_Subst.subst
-                                                    subst a in
-                                                let env2 =
-                                                  FStar_TypeChecker_Env.set_expected_typ
-                                                    env1 t_f1 in
-                                                let uu___11 =
-                                                  tc_tot_or_gtot_term env2 a1 in
-                                                (match uu___11 with
-                                                 | (a2, uu___12, g) ->
-                                                     let subst1 =
-                                                       (FStar_Syntax_Syntax.NT
-                                                          (f, a2))
-                                                       :: subst in
-                                                     ((a2, imp_a), subst1,
-                                                       bvs, g)) in
-                                          (match uu___8 with
-                                           | (a1, subst1, bvs1, g) ->
-                                               let uu___9 =
-                                                 let uu___10 =
-                                                   FStar_TypeChecker_Env.conj_guard
-                                                     g guard in
-                                                 (subst1,
-                                                   (FStar_Compiler_List.op_At
-                                                      args_out [a1]), bvs1,
-                                                   uu___10) in
-                                               aux uu___9 formals2 args2)
-                                      | uu___6 ->
-                                          fail "Not a fully applied pattern") in
-                               aux
-                                 ([], [], [],
-                                   FStar_TypeChecker_Env.trivial_guard)
-                                 formals args))))
-               | uu___1 -> fail "Not a simple pattern") in
-        let rec check_nested_pattern env1 p t =
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_TypeChecker_Env.debug env1)
-               (FStar_Options.Other "Patterns") in
-           if uu___1
-           then
-             let uu___2 = FStar_Syntax_Print.pat_to_string p in
-             let uu___3 = FStar_Syntax_Print.term_to_string t in
-             FStar_Compiler_Util.print2 "Checking pattern %s at type %s\n"
-               uu___2 uu___3
-           else ());
-          (let id t1 =
-             let uu___1 =
-               FStar_Syntax_Syntax.fvar FStar_Parser_Const.id_lid
-                 (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-                 FStar_Pervasives_Native.None in
-             let uu___2 =
-               let uu___3 = FStar_Syntax_Syntax.iarg t1 in [uu___3] in
-             FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2
-               t1.FStar_Syntax_Syntax.pos in
-           let mk_disc_t disc inner_t =
-             let x_b =
-               let uu___1 =
-                 FStar_Syntax_Syntax.gen_bv "x" FStar_Pervasives_Native.None
-                   t in
-               FStar_Compiler_Effect.op_Bar_Greater uu___1
-                 FStar_Syntax_Syntax.mk_binder in
-             let ty_args =
-               let uu___1 = FStar_Syntax_Util.head_and_args t in
-               match uu___1 with
-               | (hd, args) ->
-                   let uu___2 =
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Compiler_Effect.op_Bar_Greater hd
-                           FStar_Syntax_Subst.compress in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___4
-                         FStar_Syntax_Util.un_uinst in
-                     uu___3.FStar_Syntax_Syntax.n in
-                   (match uu___2 with
-                    | FStar_Syntax_Syntax.Tm_fvar fv ->
-                        let uu___3 =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Compiler_Effect.op_Bar_Greater fv
-                                FStar_Syntax_Syntax.lid_of_fv in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___5
-                              (FStar_TypeChecker_Env.num_inductive_ty_params
-                                 env1) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___4
-                            (fun nopt ->
-                               let uu___5 =
-                                 FStar_Compiler_Effect.op_Bar_Greater nopt
-                                   (FStar_Compiler_Util.map_option
-                                      (fun n ->
-                                         if
-                                           (FStar_Compiler_List.length args)
-                                             >= n
-                                         then
-                                           let uu___6 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               args
-                                               (FStar_Compiler_List.splitAt n) in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___6
-                                             FStar_Pervasives_Native.fst
-                                         else [])) in
-                               FStar_Compiler_Util.dflt [] uu___5) in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___3
-                          (FStar_Compiler_List.map
-                             (fun uu___4 ->
-                                match uu___4 with
-                                | (t1, uu___5) -> FStar_Syntax_Syntax.iarg t1))
-                    | uu___3 -> []) in
-             let tm =
-               let uu___1 =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_Effect.op_Bar_Greater
-                         x_b.FStar_Syntax_Syntax.binder_bv
-                         FStar_Syntax_Syntax.bv_to_name in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___4
-                       FStar_Syntax_Syntax.as_arg in
-                   [uu___3] in
-                 FStar_Compiler_List.op_At ty_args uu___2 in
-               FStar_Syntax_Syntax.mk_Tm_app disc uu___1
-                 FStar_Compiler_Range.dummyRange in
-             let tm1 =
-               let uu___1 =
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater tm
-                     FStar_Syntax_Syntax.as_arg in
-                 [uu___2] in
-               FStar_Syntax_Syntax.mk_Tm_app inner_t uu___1
-                 FStar_Compiler_Range.dummyRange in
-             FStar_Syntax_Util.abs [x_b] tm1 FStar_Pervasives_Native.None in
-           match p.FStar_Syntax_Syntax.v with
-           | FStar_Syntax_Syntax.Pat_dot_term uu___1 ->
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Print.pat_to_string p in
-                 FStar_Compiler_Util.format1
-                   "Impossible: Expected an undecorated pattern, got %s"
-                   uu___3 in
-               failwith uu___2
-           | FStar_Syntax_Syntax.Pat_wild x ->
-               let x1 =
-                 {
-                   FStar_Syntax_Syntax.ppname =
-                     (x.FStar_Syntax_Syntax.ppname);
-                   FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                   FStar_Syntax_Syntax.sort = t
-                 } in
-               let uu___1 = let uu___2 = id t in [uu___2] in
-               let uu___2 = FStar_Syntax_Syntax.bv_to_name x1 in
-               ([x1], uu___1, uu___2,
-                 {
-                   FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_wild x1);
-                   FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                 }, FStar_TypeChecker_Env.trivial_guard, false)
-           | FStar_Syntax_Syntax.Pat_var x ->
-               let x1 =
-                 {
-                   FStar_Syntax_Syntax.ppname =
-                     (x.FStar_Syntax_Syntax.ppname);
-                   FStar_Syntax_Syntax.index = (x.FStar_Syntax_Syntax.index);
-                   FStar_Syntax_Syntax.sort = t
-                 } in
-               let uu___1 = let uu___2 = id t in [uu___2] in
-               let uu___2 = FStar_Syntax_Syntax.bv_to_name x1 in
-               ([x1], uu___1, uu___2,
-                 {
-                   FStar_Syntax_Syntax.v = (FStar_Syntax_Syntax.Pat_var x1);
-                   FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                 }, FStar_TypeChecker_Env.trivial_guard, false)
-           | FStar_Syntax_Syntax.Pat_constant c ->
-               ((match c with
-                 | FStar_Const.Const_unit -> ()
-                 | FStar_Const.Const_bool uu___2 -> ()
-                 | FStar_Const.Const_int uu___2 -> ()
-                 | FStar_Const.Const_char uu___2 -> ()
-                 | FStar_Const.Const_string uu___2 -> ()
-                 | uu___2 ->
-                     let uu___3 =
-                       let uu___4 = FStar_Syntax_Print.const_to_string c in
-                       FStar_Compiler_Util.format1
-                         "Pattern matching a constant that does not have decidable equality: %s"
-                         uu___4 in
-                     fail uu___3);
-                (let uu___2 =
-                   FStar_TypeChecker_PatternUtils.pat_as_exp false false env1
-                     p in
-                 match uu___2 with
-                 | (uu___3, e_c, uu___4, uu___5) ->
-                     let uu___6 = tc_tot_or_gtot_term env1 e_c in
-                     (match uu___6 with
-                      | (e_c1, lc, g) ->
-                          (FStar_TypeChecker_Rel.force_trivial_guard env1 g;
-                           (let expected_t =
-                              expected_pat_typ env1 p0.FStar_Syntax_Syntax.p
-                                t in
-                            (let uu___9 =
-                               let uu___10 =
-                                 FStar_TypeChecker_Rel.teq_nosmt_force env1
-                                   lc.FStar_TypeChecker_Common.res_typ
-                                   expected_t in
-                               Prims.op_Negation uu___10 in
-                             if uu___9
-                             then
-                               let uu___10 =
-                                 let uu___11 =
-                                   FStar_Syntax_Print.term_to_string
-                                     lc.FStar_TypeChecker_Common.res_typ in
-                                 let uu___12 =
-                                   FStar_Syntax_Print.term_to_string
-                                     expected_t in
-                                 FStar_Compiler_Util.format2
-                                   "Type of pattern (%s) does not match type of scrutinee (%s)"
-                                   uu___11 uu___12 in
-                               fail uu___10
-                             else ());
-                            ([], [], e_c1, p,
-                              FStar_TypeChecker_Env.trivial_guard, false))))))
-           | FStar_Syntax_Syntax.Pat_cons
-               ({ FStar_Syntax_Syntax.fv_name = uu___1;
-                  FStar_Syntax_Syntax.fv_delta = uu___2;
-                  FStar_Syntax_Syntax.fv_qual = FStar_Pervasives_Native.Some
-                    (FStar_Syntax_Syntax.Unresolved_constructor uc);_},
-                us_opt, sub_pats)
-               ->
-               let uu___3 =
-                 FStar_TypeChecker_Util.find_record_or_dc_from_typ env1
-                   (FStar_Pervasives_Native.Some t) uc
-                   p.FStar_Syntax_Syntax.p in
-               (match uu___3 with
-                | (rdc, uu___4, constructor_fv) ->
-                    let f_sub_pats =
-                      FStar_Compiler_List.zip
-                        uc.FStar_Syntax_Syntax.uc_fields sub_pats in
-                    let sub_pats1 =
-                      FStar_TypeChecker_Util.make_record_fields_in_order env1
-                        uc
-                        (FStar_Pervasives_Native.Some
-                           (FStar_Pervasives.Inl t)) rdc f_sub_pats
-                        (fun uu___5 ->
-                           let x =
-                             FStar_Syntax_Syntax.new_bv
-                               FStar_Pervasives_Native.None
-                               FStar_Syntax_Syntax.tun in
-                           let uu___6 =
-                             let uu___7 =
-                               FStar_Syntax_Syntax.withinfo
-                                 (FStar_Syntax_Syntax.Pat_wild x)
-                                 p.FStar_Syntax_Syntax.p in
-                             (uu___7, false) in
-                           FStar_Pervasives_Native.Some uu___6)
-                        p.FStar_Syntax_Syntax.p in
-                    let p1 =
-                      {
-                        FStar_Syntax_Syntax.v =
-                          (FStar_Syntax_Syntax.Pat_cons
-                             (constructor_fv, us_opt, sub_pats1));
-                        FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                      } in
-                    let p2 =
-                      FStar_TypeChecker_PatternUtils.elaborate_pat env1 p1 in
-                    check_nested_pattern env1 p2 t)
-           | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, sub_pats) ->
-               let simple_pat =
-                 let simple_sub_pats =
-                   FStar_Compiler_List.map
-                     (fun uu___1 ->
-                        match uu___1 with
-                        | (p1, b) ->
-                            (match p1.FStar_Syntax_Syntax.v with
-                             | FStar_Syntax_Syntax.Pat_dot_term uu___2 ->
-                                 (p1, b)
-                             | uu___2 ->
-                                 let uu___3 =
-                                   let uu___4 =
-                                     let uu___5 =
-                                       FStar_Syntax_Syntax.new_bv
-                                         (FStar_Pervasives_Native.Some
-                                            (p1.FStar_Syntax_Syntax.p))
-                                         FStar_Syntax_Syntax.tun in
-                                     FStar_Syntax_Syntax.Pat_var uu___5 in
-                                   FStar_Syntax_Syntax.withinfo uu___4
-                                     p1.FStar_Syntax_Syntax.p in
-                                 (uu___3, b))) sub_pats in
-                 {
-                   FStar_Syntax_Syntax.v =
-                     (FStar_Syntax_Syntax.Pat_cons
-                        (fv, us_opt, simple_sub_pats));
-                   FStar_Syntax_Syntax.p = (p.FStar_Syntax_Syntax.p)
-                 } in
-               let sub_pats1 =
-                 FStar_Compiler_Effect.op_Bar_Greater sub_pats
-                   (FStar_Compiler_List.filter
-                      (fun uu___1 ->
-                         match uu___1 with
-                         | (x, uu___2) ->
-                             (match x.FStar_Syntax_Syntax.v with
-                              | FStar_Syntax_Syntax.Pat_dot_term uu___3 ->
-                                  false
-                              | uu___3 -> true))) in
-               let uu___1 =
-                 FStar_TypeChecker_PatternUtils.pat_as_exp false false env1
-                   simple_pat in
-               (match uu___1 with
-                | (simple_bvs_pat, simple_pat_e, g0, simple_pat_elab) ->
-                    (if
-                       (FStar_Compiler_List.length simple_bvs_pat) <>
-                         (FStar_Compiler_List.length sub_pats1)
-                     then
-                       (let uu___3 =
-                          let uu___4 =
-                            FStar_Compiler_Range.string_of_range
-                              p.FStar_Syntax_Syntax.p in
-                          let uu___5 =
-                            FStar_Syntax_Print.pat_to_string simple_pat in
-                          let uu___6 =
-                            FStar_Compiler_Util.string_of_int
-                              (FStar_Compiler_List.length sub_pats1) in
-                          let uu___7 =
-                            FStar_Compiler_Util.string_of_int
-                              (FStar_Compiler_List.length simple_bvs_pat) in
-                          FStar_Compiler_Util.format4
-                            "(%s) Impossible: pattern bvar mismatch: %s; expected %s sub pats; got %s"
-                            uu___4 uu___5 uu___6 uu___7 in
-                        failwith uu___3)
-                     else ();
-                     (let uu___3 =
-                        let uu___4 = type_of_simple_pat env1 simple_pat_e in
-                        match uu___4 with
-                        | (simple_pat_e1, simple_pat_t, simple_bvs, guard,
-                           erasable) ->
-                            let simple_bvs1 =
-                              let uu___5 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  simple_bvs
-                                  (FStar_Compiler_Util.first_N
-                                     ((FStar_Compiler_List.length simple_bvs)
-                                        -
-                                        (FStar_Compiler_List.length
-                                           simple_bvs_pat))) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                FStar_Pervasives_Native.snd in
-                            let g' =
-                              let uu___5 =
-                                expected_pat_typ env1
-                                  p0.FStar_Syntax_Syntax.p t in
-                              pat_typ_ok env1 simple_pat_t uu___5 in
-                            let guard1 =
-                              let fml =
-                                FStar_TypeChecker_Env.guard_form guard in
-                              let guard2 =
-                                FStar_TypeChecker_Rel.discharge_guard_no_smt
-                                  env1
-                                  {
-                                    FStar_TypeChecker_Common.guard_f =
-                                      FStar_TypeChecker_Common.Trivial;
-                                    FStar_TypeChecker_Common.deferred_to_tac
-                                      =
-                                      (guard.FStar_TypeChecker_Common.deferred_to_tac);
-                                    FStar_TypeChecker_Common.deferred =
-                                      (guard.FStar_TypeChecker_Common.deferred);
-                                    FStar_TypeChecker_Common.univ_ineqs =
-                                      (guard.FStar_TypeChecker_Common.univ_ineqs);
-                                    FStar_TypeChecker_Common.implicits =
-                                      (guard.FStar_TypeChecker_Common.implicits)
-                                  } in
-                              {
-                                FStar_TypeChecker_Common.guard_f = fml;
-                                FStar_TypeChecker_Common.deferred_to_tac =
-                                  (guard2.FStar_TypeChecker_Common.deferred_to_tac);
-                                FStar_TypeChecker_Common.deferred =
-                                  (guard2.FStar_TypeChecker_Common.deferred);
-                                FStar_TypeChecker_Common.univ_ineqs =
-                                  (guard2.FStar_TypeChecker_Common.univ_ineqs);
-                                FStar_TypeChecker_Common.implicits =
-                                  (guard2.FStar_TypeChecker_Common.implicits)
-                              } in
-                            let guard2 =
-                              FStar_TypeChecker_Env.conj_guard guard1 g' in
-                            ((let uu___6 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env1)
-                                  (FStar_Options.Other "Patterns") in
-                              if uu___6
-                              then
-                                let uu___7 =
-                                  FStar_Syntax_Print.term_to_string
-                                    simple_pat_e1 in
-                                let uu___8 =
-                                  FStar_Syntax_Print.term_to_string
-                                    simple_pat_t in
-                                let uu___9 =
-                                  let uu___10 =
-                                    FStar_Compiler_List.map
-                                      (fun x ->
-                                         let uu___11 =
-                                           let uu___12 =
-                                             FStar_Syntax_Print.bv_to_string
-                                               x in
-                                           let uu___13 =
-                                             let uu___14 =
-                                               let uu___15 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   x.FStar_Syntax_Syntax.sort in
-                                               Prims.op_Hat uu___15 ")" in
-                                             Prims.op_Hat " : " uu___14 in
-                                           Prims.op_Hat uu___12 uu___13 in
-                                         Prims.op_Hat "(" uu___11)
-                                      simple_bvs1 in
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    uu___10 (FStar_String.concat " ") in
-                                FStar_Compiler_Util.print3
-                                  "$$$$$$$$$$$$Checked simple pattern %s at type %s with bvs=%s\n"
-                                  uu___7 uu___8 uu___9
-                              else ());
-                             (simple_pat_e1, simple_bvs1, guard2, erasable)) in
-                      match uu___3 with
-                      | (simple_pat_e1, simple_bvs, g1, erasable) ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_TypeChecker_Env.conj_guard g0 g1 in
-                              ([], [], [], [], uu___6, erasable,
-                                Prims.int_zero) in
-                            FStar_Compiler_List.fold_left2
-                              (fun uu___6 ->
-                                 fun uu___7 ->
-                                   fun x ->
-                                     match (uu___6, uu___7) with
-                                     | ((bvs, tms, pats, subst, g, erasable1,
-                                         i),
-                                        (p1, b)) ->
-                                         let expected_t =
-                                           FStar_Syntax_Subst.subst subst
-                                             x.FStar_Syntax_Syntax.sort in
-                                         let env2 =
-                                           FStar_TypeChecker_Env.push_bvs
-                                             env1 bvs in
-                                         let uu___8 =
-                                           check_nested_pattern env2 p1
-                                             expected_t in
-                                         (match uu___8 with
-                                          | (bvs_p, tms_p, e_p, p2, g',
-                                             erasable_p) ->
-                                              let g'1 =
-                                                let uu___9 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    bvs
-                                                    (FStar_Compiler_List.map
-                                                       FStar_Syntax_Syntax.mk_binder) in
-                                                FStar_TypeChecker_Env.close_guard
-                                                  env2 uu___9 g' in
-                                              let tms_p1 =
-                                                let disc_tm =
-                                                  let uu___9 =
-                                                    FStar_Syntax_Syntax.lid_of_fv
-                                                      fv in
-                                                  FStar_TypeChecker_Util.get_field_projector_name
-                                                    env2 uu___9 i in
-                                                let uu___9 =
-                                                  let uu___10 =
-                                                    let uu___11 =
-                                                      FStar_Syntax_Syntax.fvar
-                                                        disc_tm
-                                                        (FStar_Syntax_Syntax.Delta_constant_at_level
-                                                           Prims.int_one)
-                                                        FStar_Pervasives_Native.None in
-                                                    mk_disc_t uu___11 in
-                                                  FStar_Compiler_List.map
-                                                    uu___10 in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  tms_p uu___9 in
-                                              let uu___9 =
-                                                FStar_TypeChecker_Env.conj_guard
-                                                  g g'1 in
-                                              ((FStar_Compiler_List.op_At bvs
-                                                  bvs_p),
-                                                (FStar_Compiler_List.op_At
-                                                   tms tms_p1),
-                                                (FStar_Compiler_List.op_At
-                                                   pats [(p2, b)]),
-                                                ((FStar_Syntax_Syntax.NT
-                                                    (x, e_p)) :: subst),
-                                                uu___9,
-                                                (erasable1 || erasable_p),
-                                                (i + Prims.int_one)))) uu___5
-                              sub_pats1 simple_bvs in
-                          (match uu___4 with
-                           | (bvs, tms, checked_sub_pats, subst, g,
-                              erasable1, uu___5) ->
-                               let pat_e =
-                                 FStar_Syntax_Subst.subst subst simple_pat_e1 in
-                               let reconstruct_nested_pat pat =
-                                 let rec aux simple_pats bvs1 sub_pats2 =
-                                   match simple_pats with
-                                   | [] -> []
-                                   | (hd, b)::simple_pats1 ->
-                                       (match hd.FStar_Syntax_Syntax.v with
-                                        | FStar_Syntax_Syntax.Pat_dot_term
-                                            eopt ->
-                                            let eopt1 =
-                                              FStar_Compiler_Util.map_option
-                                                (FStar_Syntax_Subst.subst
-                                                   subst) eopt in
-                                            let hd1 =
-                                              {
-                                                FStar_Syntax_Syntax.v =
-                                                  (FStar_Syntax_Syntax.Pat_dot_term
-                                                     eopt1);
-                                                FStar_Syntax_Syntax.p =
-                                                  (hd.FStar_Syntax_Syntax.p)
-                                              } in
-                                            let uu___6 =
-                                              aux simple_pats1 bvs1 sub_pats2 in
-                                            (hd1, b) :: uu___6
-                                        | FStar_Syntax_Syntax.Pat_var x ->
-                                            (match (bvs1, sub_pats2) with
-                                             | (x'::bvs2,
-                                                (hd1, uu___6)::sub_pats3)
-                                                 when
-                                                 FStar_Syntax_Syntax.bv_eq x
-                                                   x'
-                                                 ->
-                                                 let uu___7 =
-                                                   aux simple_pats1 bvs2
-                                                     sub_pats3 in
-                                                 (hd1, b) :: uu___7
-                                             | uu___6 ->
-                                                 failwith
-                                                   "Impossible: simple pat variable mismatch")
-                                        | uu___6 ->
-                                            failwith
-                                              "Impossible: expected a simple pattern") in
-                                 let us =
-                                   let uu___6 =
-                                     FStar_Syntax_Util.head_and_args
-                                       simple_pat_e1 in
-                                   match uu___6 with
-                                   | (hd, uu___7) ->
-                                       let uu___8 =
-                                         let uu___9 =
-                                           FStar_Syntax_Subst.compress hd in
-                                         uu___9.FStar_Syntax_Syntax.n in
-                                       (match uu___8 with
-                                        | FStar_Syntax_Syntax.Tm_fvar uu___9
-                                            -> []
-                                        | FStar_Syntax_Syntax.Tm_uinst
-                                            (uu___9, us1) -> us1
-                                        | uu___9 -> failwith "Impossible") in
-                                 match pat.FStar_Syntax_Syntax.v with
-                                 | FStar_Syntax_Syntax.Pat_cons
-                                     (fv1, uu___6, simple_pats) ->
-                                     let nested_pats =
-                                       aux simple_pats simple_bvs
-                                         checked_sub_pats in
-                                     {
-                                       FStar_Syntax_Syntax.v =
-                                         (FStar_Syntax_Syntax.Pat_cons
-                                            (fv1,
-                                              (FStar_Pervasives_Native.Some
-                                                 us), nested_pats));
-                                       FStar_Syntax_Syntax.p =
-                                         (pat.FStar_Syntax_Syntax.p)
-                                     }
-                                 | uu___6 -> failwith "Impossible" in
-                               let uu___6 =
-                                 reconstruct_nested_pat simple_pat_elab in
-                               (bvs, tms, pat_e, uu___6, g, erasable1)))))) in
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar
-             (FStar_TypeChecker_Env.debug env)
-             (FStar_Options.Other "Patterns") in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.pat_to_string p0 in
-           FStar_Compiler_Util.print1 "Checking pattern: %s\n" uu___2
-         else ());
-        (let uu___1 =
-           let uu___2 =
-             let uu___3 = FStar_TypeChecker_Env.clear_expected_typ env in
-             FStar_Compiler_Effect.op_Bar_Greater uu___3
-               FStar_Pervasives_Native.fst in
-           let uu___3 = FStar_TypeChecker_PatternUtils.elaborate_pat env p0 in
-           let uu___4 = expected_pat_typ env p0.FStar_Syntax_Syntax.p pat_t in
-           check_nested_pattern uu___2 uu___3 uu___4 in
-         match uu___1 with
-         | (bvs, tms, pat_e, pat, g, erasable) ->
-             ((let uu___3 =
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (FStar_TypeChecker_Env.debug env)
-                   (FStar_Options.Other "Patterns") in
-               if uu___3
-               then
-                 let uu___4 = FStar_Syntax_Print.pat_to_string pat in
-                 let uu___5 = FStar_Syntax_Print.term_to_string pat_e in
-                 FStar_Compiler_Util.print2
-                   "Done checking pattern %s as expression %s\n" uu___4
-                   uu___5
-               else ());
-              (let uu___3 = FStar_TypeChecker_Env.push_bvs env bvs in
-               let uu___4 =
-                 FStar_TypeChecker_Normalize.normalize
-                   [FStar_TypeChecker_Env.Beta] env pat_e in
-               (pat, bvs, tms, uu___3, pat_e, uu___4, g, erasable))))
-and (tc_eqn :
-  FStar_Syntax_Syntax.bv ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.match_returns_ascription
-        FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.branch ->
-          ((FStar_Syntax_Syntax.pat * FStar_Syntax_Syntax.term
-            FStar_Pervasives_Native.option * FStar_Syntax_Syntax.term) *
-            FStar_Syntax_Syntax.formula * FStar_Ident.lident *
-            FStar_Syntax_Syntax.cflag Prims.list
-            FStar_Pervasives_Native.option *
-            (Prims.bool -> FStar_TypeChecker_Common.lcomp)
-            FStar_Pervasives_Native.option * FStar_TypeChecker_Env.guard_t *
-            Prims.bool))
-  =
-  fun scrutinee ->
-    fun env ->
-      fun ret_opt ->
-        fun branch ->
-          let uu___ = FStar_Syntax_Subst.open_branch branch in
-          match uu___ with
-          | (pattern, when_clause, branch_exp) ->
-              let uu___1 = branch in
-              (match uu___1 with
-               | (cpat, uu___2, cbr) ->
-                   let pat_t = scrutinee.FStar_Syntax_Syntax.sort in
-                   let scrutinee_tm =
-                     FStar_Syntax_Syntax.bv_to_name scrutinee in
-                   let uu___3 =
-                     let uu___4 = FStar_TypeChecker_Env.push_bv env scrutinee in
-                     FStar_Compiler_Effect.op_Bar_Greater uu___4
-                       FStar_TypeChecker_Env.clear_expected_typ in
-                   (match uu___3 with
-                    | (scrutinee_env, uu___4) ->
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_TypeChecker_Env.push_bv env scrutinee in
-                          tc_pat uu___6 pat_t pattern in
-                        (match uu___5 with
-                         | (pattern1, pat_bvs, pat_bv_tms, pat_env, pat_exp,
-                            norm_pat_exp, guard_pat, erasable) ->
-                             ((let uu___7 =
-                                 FStar_Compiler_Effect.op_Less_Bar
-                                   (FStar_TypeChecker_Env.debug env)
-                                   FStar_Options.Extreme in
-                               if uu___7
-                               then
-                                 let uu___8 =
-                                   FStar_Syntax_Print.pat_to_string pattern1 in
-                                 let uu___9 =
-                                   FStar_Syntax_Print.bvs_to_string ";"
-                                     pat_bvs in
-                                 let uu___10 =
-                                   FStar_Compiler_List.fold_left
-                                     (fun s ->
-                                        fun t ->
-                                          let uu___11 =
-                                            let uu___12 =
-                                              FStar_Syntax_Print.term_to_string
-                                                t in
-                                            Prims.op_Hat ";" uu___12 in
-                                          Prims.op_Hat s uu___11) ""
-                                     pat_bv_tms in
-                                 FStar_Compiler_Util.print3
-                                   "tc_eqn: typechecked pattern %s with bvs %s and pat_bv_tms %s\n"
-                                   uu___8 uu___9 uu___10
-                               else ());
-                              (let uu___7 =
-                                 match when_clause with
-                                 | FStar_Pervasives_Native.None ->
-                                     (FStar_Pervasives_Native.None,
-                                       FStar_TypeChecker_Env.trivial_guard)
-                                 | FStar_Pervasives_Native.Some e ->
-                                     let uu___8 =
-                                       FStar_TypeChecker_Env.should_verify
-                                         env in
-                                     if uu___8
-                                     then
-                                       FStar_Errors.raise_error
-                                         (FStar_Errors.Fatal_WhenClauseNotSupported,
-                                           "When clauses are not yet supported in --verify mode; they will be some day")
-                                         e.FStar_Syntax_Syntax.pos
-                                     else
-                                       (let uu___10 =
-                                          let uu___11 =
-                                            FStar_TypeChecker_Env.set_expected_typ
-                                              pat_env
-                                              FStar_Syntax_Util.t_bool in
-                                          tc_term uu___11 e in
-                                        match uu___10 with
-                                        | (e1, c, g) ->
-                                            ((FStar_Pervasives_Native.Some e1),
-                                              g)) in
-                               match uu___7 with
-                               | (when_clause1, g_when) ->
-                                   let uu___8 =
-                                     let branch_exp1 =
-                                       match ret_opt with
-                                       | FStar_Pervasives_Native.None ->
-                                           branch_exp
-                                       | FStar_Pervasives_Native.Some
-                                           (b, asc) ->
-                                           let uu___9 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               asc
-                                               (FStar_Syntax_Subst.subst_ascription
-                                                  [FStar_Syntax_Syntax.NT
-                                                     ((b.FStar_Syntax_Syntax.binder_bv),
-                                                       norm_pat_exp)]) in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___9
-                                             (FStar_Syntax_Util.ascribe
-                                                branch_exp) in
-                                     let uu___9 = tc_term pat_env branch_exp1 in
-                                     match uu___9 with
-                                     | (branch_exp2, c, g_branch) ->
-                                         let branch_exp3 =
-                                           match ret_opt with
-                                           | FStar_Pervasives_Native.None ->
-                                               branch_exp2
-                                           | uu___10 ->
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Syntax_Subst.compress
-                                                     branch_exp2 in
-                                                 uu___12.FStar_Syntax_Syntax.n in
-                                               (match uu___11 with
-                                                | FStar_Syntax_Syntax.Tm_ascribed
-                                                    (branch_exp4, uu___12,
-                                                     uu___13)
-                                                    -> branch_exp4
-                                                | uu___12 ->
-                                                    failwith
-                                                      "Impossible (expected the match branch with an ascription)") in
-                                         (branch_exp3, c, g_branch) in
-                                   (match uu___8 with
-                                    | (branch_exp1, c, g_branch) ->
-                                        (FStar_TypeChecker_Env.def_check_guard_wf
-                                           cbr.FStar_Syntax_Syntax.pos
-                                           "tc_eqn.1" pat_env g_branch;
-                                         (let when_condition =
-                                            match when_clause1 with
-                                            | FStar_Pervasives_Native.None ->
-                                                FStar_Pervasives_Native.None
-                                            | FStar_Pervasives_Native.Some w
-                                                ->
-                                                let uu___10 =
-                                                  FStar_Syntax_Util.mk_eq2
-                                                    FStar_Syntax_Syntax.U_zero
-                                                    FStar_Syntax_Util.t_bool
-                                                    w
-                                                    FStar_Syntax_Util.exp_true_bool in
-                                                FStar_Compiler_Effect.op_Less_Bar
-                                                  (fun uu___11 ->
-                                                     FStar_Pervasives_Native.Some
-                                                       uu___11) uu___10 in
-                                          let branch_guard =
-                                            let uu___10 =
-                                              let uu___11 =
-                                                FStar_TypeChecker_Env.should_verify
-                                                  env in
-                                              Prims.op_Negation uu___11 in
-                                            if uu___10
-                                            then
-                                              FStar_Syntax_Util.exp_true_bool
-                                            else
-                                              (let rec build_branch_guard
-                                                 scrutinee_tm1 pattern2
-                                                 pat_exp1 =
-                                                 let discriminate
-                                                   scrutinee_tm2 f =
-                                                   let uu___12 =
-                                                     let uu___13 =
-                                                       FStar_TypeChecker_Env.typ_of_datacon
-                                                         env
-                                                         f.FStar_Syntax_Syntax.v in
-                                                     FStar_TypeChecker_Env.datacons_of_typ
-                                                       env uu___13 in
-                                                   match uu___12 with
-                                                   | (is_induc, datacons) ->
-                                                       if
-                                                         (Prims.op_Negation
-                                                            is_induc)
-                                                           ||
-                                                           ((FStar_Compiler_List.length
-                                                               datacons)
-                                                              > Prims.int_one)
-                                                       then
-                                                         let discriminator =
-                                                           FStar_Syntax_Util.mk_discriminator
-                                                             f.FStar_Syntax_Syntax.v in
-                                                         let uu___13 =
-                                                           FStar_TypeChecker_Env.try_lookup_lid
-                                                             env
-                                                             discriminator in
-                                                         (match uu___13 with
-                                                          | FStar_Pervasives_Native.None
-                                                              -> []
-                                                          | uu___14 ->
-                                                              let disc =
-                                                                FStar_Syntax_Syntax.fvar
-                                                                  discriminator
-                                                                  (FStar_Syntax_Syntax.Delta_equational_at_level
-                                                                    Prims.int_one)
-                                                                  FStar_Pervasives_Native.None in
-                                                              let uu___15 =
-                                                                let uu___16 =
-                                                                  let uu___17
-                                                                    =
-                                                                    FStar_Syntax_Syntax.as_arg
-                                                                    scrutinee_tm2 in
-                                                                  [uu___17] in
-                                                                FStar_Syntax_Syntax.mk_Tm_app
-                                                                  disc
-                                                                  uu___16
-                                                                  scrutinee_tm2.FStar_Syntax_Syntax.pos in
-                                                              [uu___15])
-                                                       else [] in
-                                                 let fail uu___12 =
-                                                   let uu___13 =
-                                                     let uu___14 =
-                                                       FStar_Compiler_Range.string_of_range
-                                                         pat_exp1.FStar_Syntax_Syntax.pos in
-                                                     let uu___15 =
-                                                       FStar_Syntax_Print.term_to_string
-                                                         pat_exp1 in
-                                                     let uu___16 =
-                                                       FStar_Syntax_Print.tag_of_term
-                                                         pat_exp1 in
-                                                     FStar_Compiler_Util.format3
-                                                       "tc_eqn: Impossible (%s) %s (%s)"
-                                                       uu___14 uu___15
-                                                       uu___16 in
-                                                   failwith uu___13 in
-                                                 let rec head_constructor t =
-                                                   match t.FStar_Syntax_Syntax.n
-                                                   with
-                                                   | FStar_Syntax_Syntax.Tm_fvar
-                                                       fv ->
-                                                       fv.FStar_Syntax_Syntax.fv_name
-                                                   | FStar_Syntax_Syntax.Tm_uinst
-                                                       (t1, uu___12) ->
-                                                       head_constructor t1
-                                                   | uu___12 -> fail () in
-                                                 let force_scrutinee uu___12
-                                                   =
-                                                   match scrutinee_tm1 with
-                                                   | FStar_Pervasives_Native.None
-                                                       ->
-                                                       let uu___13 =
-                                                         let uu___14 =
-                                                           FStar_Compiler_Range.string_of_range
-                                                             pattern2.FStar_Syntax_Syntax.p in
-                                                         let uu___15 =
-                                                           FStar_Syntax_Print.pat_to_string
-                                                             pattern2 in
-                                                         FStar_Compiler_Util.format2
-                                                           "Impossible (%s): scrutinee of match is not defined %s"
-                                                           uu___14 uu___15 in
-                                                       failwith uu___13
-                                                   | FStar_Pervasives_Native.Some
-                                                       t -> t in
-                                                 let pat_exp2 =
-                                                   let uu___12 =
-                                                     FStar_Syntax_Subst.compress
-                                                       pat_exp1 in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___12
-                                                     FStar_Syntax_Util.unmeta in
-                                                 match ((pattern2.FStar_Syntax_Syntax.v),
-                                                         (pat_exp2.FStar_Syntax_Syntax.n))
-                                                 with
-                                                 | (uu___12,
-                                                    FStar_Syntax_Syntax.Tm_name
-                                                    uu___13) -> []
-                                                 | (uu___12,
-                                                    FStar_Syntax_Syntax.Tm_constant
-                                                    (FStar_Const.Const_unit))
-                                                     -> []
-                                                 | (FStar_Syntax_Syntax.Pat_constant
-                                                    _c,
-                                                    FStar_Syntax_Syntax.Tm_constant
-                                                    c1) ->
-                                                     let uu___12 =
-                                                       let uu___13 =
-                                                         tc_constant env
-                                                           pat_exp2.FStar_Syntax_Syntax.pos
-                                                           c1 in
-                                                       let uu___14 =
-                                                         force_scrutinee () in
-                                                       FStar_Syntax_Util.mk_decidable_eq
-                                                         uu___13 uu___14
-                                                         pat_exp2 in
-                                                     [uu___12]
-                                                 | (FStar_Syntax_Syntax.Pat_constant
-                                                    (FStar_Const.Const_int
-                                                    (uu___12,
-                                                     FStar_Pervasives_Native.Some
-                                                     uu___13)),
-                                                    uu___14) ->
-                                                     let uu___15 =
-                                                       let uu___16 =
-                                                         FStar_TypeChecker_Env.clear_expected_typ
-                                                           env in
-                                                       match uu___16 with
-                                                       | (env1, uu___17) ->
-                                                           env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                             env1 pat_exp2
-                                                             true in
-                                                     (match uu___15 with
-                                                      | (uu___16, t, uu___17)
-                                                          ->
-                                                          let uu___18 =
-                                                            let uu___19 =
-                                                              force_scrutinee
-                                                                () in
-                                                            FStar_Syntax_Util.mk_decidable_eq
-                                                              t uu___19
-                                                              pat_exp2 in
-                                                          [uu___18])
-                                                 | (FStar_Syntax_Syntax.Pat_cons
-                                                    (uu___12, uu___13, []),
-                                                    FStar_Syntax_Syntax.Tm_uinst
-                                                    uu___14) ->
-                                                     let f =
-                                                       head_constructor
-                                                         pat_exp2 in
-                                                     let uu___15 =
-                                                       let uu___16 =
-                                                         FStar_TypeChecker_Env.is_datacon
-                                                           env
-                                                           f.FStar_Syntax_Syntax.v in
-                                                       Prims.op_Negation
-                                                         uu___16 in
-                                                     if uu___15
-                                                     then
-                                                       failwith
-                                                         "Impossible: nullary patterns must be data constructors"
-                                                     else
-                                                       (let uu___17 =
-                                                          force_scrutinee () in
-                                                        let uu___18 =
-                                                          head_constructor
-                                                            pat_exp2 in
-                                                        discriminate uu___17
-                                                          uu___18)
-                                                 | (FStar_Syntax_Syntax.Pat_cons
-                                                    (uu___12, uu___13, []),
-                                                    FStar_Syntax_Syntax.Tm_fvar
-                                                    uu___14) ->
-                                                     let f =
-                                                       head_constructor
-                                                         pat_exp2 in
-                                                     let uu___15 =
-                                                       let uu___16 =
-                                                         FStar_TypeChecker_Env.is_datacon
-                                                           env
-                                                           f.FStar_Syntax_Syntax.v in
-                                                       Prims.op_Negation
-                                                         uu___16 in
-                                                     if uu___15
-                                                     then
-                                                       failwith
-                                                         "Impossible: nullary patterns must be data constructors"
-                                                     else
-                                                       (let uu___17 =
-                                                          force_scrutinee () in
-                                                        let uu___18 =
-                                                          head_constructor
-                                                            pat_exp2 in
-                                                        discriminate uu___17
-                                                          uu___18)
-                                                 | (FStar_Syntax_Syntax.Pat_cons
-                                                    (uu___12, uu___13,
-                                                     pat_args),
-                                                    FStar_Syntax_Syntax.Tm_app
-                                                    (head, args)) ->
-                                                     let f =
-                                                       head_constructor head in
-                                                     let uu___14 =
-                                                       (let uu___15 =
-                                                          FStar_TypeChecker_Env.is_datacon
-                                                            env
-                                                            f.FStar_Syntax_Syntax.v in
-                                                        Prims.op_Negation
-                                                          uu___15)
-                                                         ||
-                                                         ((FStar_Compiler_List.length
-                                                             pat_args)
-                                                            <>
-                                                            (FStar_Compiler_List.length
-                                                               args)) in
-                                                     if uu___14
-                                                     then
-                                                       failwith
-                                                         "Impossible: application patterns must be fully-applied data constructors"
-                                                     else
-                                                       (let sub_term_guards =
-                                                          let uu___16 =
-                                                            let uu___17 =
-                                                              FStar_Compiler_List.zip
-                                                                pat_args args in
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              uu___17
-                                                              (FStar_Compiler_List.mapi
-                                                                 (fun i ->
-                                                                    fun
-                                                                    uu___18
-                                                                    ->
-                                                                    match uu___18
-                                                                    with
-                                                                    | 
-                                                                    ((pi,
-                                                                    uu___19),
-                                                                    (ei,
-                                                                    uu___20))
-                                                                    ->
-                                                                    let projector
-                                                                    =
-                                                                    FStar_TypeChecker_Env.lookup_projector
-                                                                    env
-                                                                    f.FStar_Syntax_Syntax.v
-                                                                    i in
-                                                                    let scrutinee_tm2
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_TypeChecker_Env.try_lookup_lid
-                                                                    env
-                                                                    projector in
-                                                                    match uu___21
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    ->
-                                                                    FStar_Pervasives_Native.None
-                                                                    | 
-                                                                    uu___22
-                                                                    ->
-                                                                    let proj
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    FStar_Ident.set_lid_range
-                                                                    projector
-                                                                    f.FStar_Syntax_Syntax.p in
-                                                                    FStar_Syntax_Syntax.fvar
-                                                                    uu___23
-                                                                    (FStar_Syntax_Syntax.Delta_equational_at_level
-                                                                    Prims.int_one)
-                                                                    FStar_Pervasives_Native.None in
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    let uu___25
-                                                                    =
-                                                                    let uu___26
-                                                                    =
-                                                                    force_scrutinee
-                                                                    () in
-                                                                    FStar_Syntax_Syntax.as_arg
-                                                                    uu___26 in
-                                                                    [uu___25] in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    proj
-                                                                    uu___24
-                                                                    f.FStar_Syntax_Syntax.p in
-                                                                    FStar_Pervasives_Native.Some
-                                                                    uu___23 in
-                                                                    build_branch_guard
-                                                                    scrutinee_tm2
-                                                                    pi ei)) in
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            uu___16
-                                                            FStar_Compiler_List.flatten in
-                                                        let uu___16 =
-                                                          let uu___17 =
-                                                            force_scrutinee
-                                                              () in
-                                                          discriminate
-                                                            uu___17 f in
-                                                        FStar_Compiler_List.op_At
-                                                          uu___16
-                                                          sub_term_guards)
-                                                 | (FStar_Syntax_Syntax.Pat_dot_term
-                                                    uu___12, uu___13) -> []
-                                                 | uu___12 ->
-                                                     let uu___13 =
-                                                       let uu___14 =
-                                                         FStar_Syntax_Print.pat_to_string
-                                                           pattern2 in
-                                                       let uu___15 =
-                                                         FStar_Syntax_Print.term_to_string
-                                                           pat_exp2 in
-                                                       FStar_Compiler_Util.format2
-                                                         "Internal error: unexpected elaborated pattern: %s and pattern expression %s"
-                                                         uu___14 uu___15 in
-                                                     failwith uu___13 in
-                                               let build_and_check_branch_guard
-                                                 scrutinee_tm1 pattern2 pat =
-                                                 let uu___12 =
-                                                   let uu___13 =
-                                                     FStar_TypeChecker_Env.should_verify
-                                                       env in
-                                                   Prims.op_Negation uu___13 in
-                                                 if uu___12
-                                                 then
-                                                   FStar_Syntax_Util.exp_true_bool
-                                                 else
-                                                   (let t =
-                                                      let uu___14 =
-                                                        build_branch_guard
-                                                          scrutinee_tm1
-                                                          pattern2 pat in
-                                                      FStar_Compiler_Effect.op_Less_Bar
-                                                        FStar_Syntax_Util.mk_and_l
-                                                        uu___14 in
-                                                    let uu___14 =
-                                                      tc_check_tot_or_gtot_term
-                                                        scrutinee_env t
-                                                        FStar_Syntax_Util.t_bool
-                                                        "" in
-                                                    match uu___14 with
-                                                    | (t1, uu___15, uu___16)
-                                                        -> t1) in
-                                               let branch_guard1 =
-                                                 build_and_check_branch_guard
-                                                   (FStar_Pervasives_Native.Some
-                                                      scrutinee_tm) pattern1
-                                                   norm_pat_exp in
-                                               let branch_guard2 =
-                                                 match when_condition with
-                                                 | FStar_Pervasives_Native.None
-                                                     -> branch_guard1
-                                                 | FStar_Pervasives_Native.Some
-                                                     w ->
-                                                     FStar_Syntax_Util.mk_and
-                                                       branch_guard1 w in
-                                               branch_guard2) in
-                                          (let uu___11 =
-                                             FStar_Compiler_Effect.op_Less_Bar
-                                               (FStar_TypeChecker_Env.debug
-                                                  env) FStar_Options.Extreme in
-                                           if uu___11
-                                           then
-                                             let uu___12 =
-                                               FStar_Syntax_Print.term_to_string
-                                                 branch_guard in
-                                             FStar_Compiler_Util.print1
-                                               "tc_eqn: branch guard : %s\n"
-                                               uu___12
-                                           else ());
-                                          (let uu___11 =
-                                             let eqs =
-                                               let env1 = pat_env in
-                                               let uu___12 =
-                                                 let uu___13 =
-                                                   FStar_TypeChecker_Env.should_verify
-                                                     env1 in
-                                                 Prims.op_Negation uu___13 in
-                                               if uu___12
-                                               then
-                                                 FStar_Pervasives_Native.None
-                                               else
-                                                 (let e =
-                                                    FStar_Syntax_Subst.compress
-                                                      pat_exp in
-                                                  let uu___14 =
-                                                    let uu___15 =
-                                                      env1.FStar_TypeChecker_Env.universe_of
-                                                        env1 pat_t in
-                                                    FStar_Syntax_Util.mk_eq2
-                                                      uu___15 pat_t
-                                                      scrutinee_tm e in
-                                                  FStar_Pervasives_Native.Some
-                                                    uu___14) in
-                                             match ret_opt with
-                                             | FStar_Pervasives_Native.Some
-                                                 (uu___12,
-                                                  (FStar_Pervasives.Inr c1,
-                                                   uu___13, uu___14))
-                                                 ->
-                                                 let pat_bs =
-                                                   FStar_Compiler_List.map
-                                                     FStar_Syntax_Syntax.mk_binder
-                                                     pat_bvs in
-                                                 let g_branch1 =
-                                                   let uu___15 =
-                                                     let uu___16 =
-                                                       let uu___17 =
-                                                         FStar_Compiler_Effect.op_Bar_Greater
-                                                           eqs
-                                                           FStar_Compiler_Util.is_some in
-                                                       if uu___17
-                                                       then
-                                                         let uu___18 =
-                                                           FStar_Compiler_Effect.op_Bar_Greater
-                                                             eqs
-                                                             FStar_Compiler_Util.must in
-                                                         FStar_TypeChecker_Common.weaken_guard_formula
-                                                           g_branch uu___18
-                                                       else g_branch in
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       uu___16
-                                                       (FStar_TypeChecker_Env.close_guard
-                                                          env pat_bs) in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___15
-                                                     (FStar_TypeChecker_Util.close_guard_implicits
-                                                        env true pat_bs) in
-                                                 ((FStar_Syntax_Util.comp_effect_name
-                                                     c1),
-                                                   FStar_Pervasives_Native.None,
-                                                   FStar_Pervasives_Native.None,
-                                                   g_when, g_branch1)
-                                             | uu___12 ->
-                                                 let uu___13 =
-                                                   FStar_TypeChecker_Util.strengthen_precondition
-                                                     FStar_Pervasives_Native.None
-                                                     env branch_exp1 c
-                                                     g_branch in
-                                                 (match uu___13 with
-                                                  | (c1, g_branch1) ->
-                                                      let branch_has_layered_effect
-                                                        =
-                                                        let uu___14 =
-                                                          FStar_Compiler_Effect.op_Bar_Greater
-                                                            c1.FStar_TypeChecker_Common.eff_name
-                                                            (FStar_TypeChecker_Env.norm_eff_name
-                                                               env) in
-                                                        FStar_Compiler_Effect.op_Bar_Greater
-                                                          uu___14
-                                                          (FStar_TypeChecker_Env.is_layered_effect
-                                                             env) in
-                                                      let uu___14 =
-                                                        if
-                                                          branch_has_layered_effect
-                                                        then
-                                                          let c2 =
-                                                            let uu___15 =
-                                                              let uu___16 =
-                                                                FStar_Syntax_Util.b2t
-                                                                  branch_guard in
-                                                              FStar_TypeChecker_Common.NonTrivial
-                                                                uu___16 in
-                                                            FStar_TypeChecker_Util.weaken_precondition
-                                                              pat_env c1
-                                                              uu___15 in
-                                                          (c2,
-                                                            FStar_TypeChecker_Env.trivial_guard)
-                                                        else
-                                                          (match (eqs,
-                                                                   when_condition)
-                                                           with
-                                                           | uu___16 when
-                                                               let uu___17 =
-                                                                 FStar_TypeChecker_Env.should_verify
-                                                                   pat_env in
-                                                               Prims.op_Negation
-                                                                 uu___17
-                                                               ->
-                                                               (c1, g_when)
-                                                           | (FStar_Pervasives_Native.None,
-                                                              FStar_Pervasives_Native.None)
-                                                               ->
-                                                               (c1, g_when)
-                                                           | (FStar_Pervasives_Native.Some
-                                                              f,
-                                                              FStar_Pervasives_Native.None)
-                                                               ->
-                                                               let gf =
-                                                                 FStar_TypeChecker_Common.NonTrivial
-                                                                   f in
-                                                               let g =
-                                                                 FStar_TypeChecker_Env.guard_of_guard_formula
-                                                                   gf in
-                                                               let uu___16 =
-                                                                 FStar_TypeChecker_Util.weaken_precondition
-                                                                   pat_env c1
-                                                                   gf in
-                                                               let uu___17 =
-                                                                 FStar_TypeChecker_Env.imp_guard
-                                                                   g g_when in
-                                                               (uu___16,
-                                                                 uu___17)
-                                                           | (FStar_Pervasives_Native.Some
-                                                              f,
-                                                              FStar_Pervasives_Native.Some
-                                                              w) ->
-                                                               let g_f =
-                                                                 FStar_TypeChecker_Common.NonTrivial
-                                                                   f in
-                                                               let g_fw =
-                                                                 let uu___16
-                                                                   =
-                                                                   FStar_Syntax_Util.mk_conj
-                                                                    f w in
-                                                                 FStar_TypeChecker_Common.NonTrivial
-                                                                   uu___16 in
-                                                               let uu___16 =
-                                                                 FStar_TypeChecker_Util.weaken_precondition
-                                                                   pat_env c1
-                                                                   g_fw in
-                                                               let uu___17 =
-                                                                 let uu___18
-                                                                   =
-                                                                   FStar_TypeChecker_Env.guard_of_guard_formula
-                                                                    g_f in
-                                                                 FStar_TypeChecker_Env.imp_guard
-                                                                   uu___18
-                                                                   g_when in
-                                                               (uu___16,
-                                                                 uu___17)
-                                                           | (FStar_Pervasives_Native.None,
-                                                              FStar_Pervasives_Native.Some
-                                                              w) ->
-                                                               let g_w =
-                                                                 FStar_TypeChecker_Common.NonTrivial
-                                                                   w in
-                                                               let g =
-                                                                 FStar_TypeChecker_Env.guard_of_guard_formula
-                                                                   g_w in
-                                                               let uu___16 =
-                                                                 FStar_TypeChecker_Util.weaken_precondition
-                                                                   pat_env c1
-                                                                   g_w in
-                                                               (uu___16,
-                                                                 g_when)) in
-                                                      (match uu___14 with
-                                                       | (c_weak,
-                                                          g_when_weak) ->
-                                                           let binders =
-                                                             FStar_Compiler_List.map
-                                                               FStar_Syntax_Syntax.mk_binder
-                                                               pat_bvs in
-                                                           let maybe_return_c_weak
-                                                             should_return =
-                                                             let c_weak1 =
-                                                               let uu___15 =
-                                                                 should_return
-                                                                   &&
-                                                                   (FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                                                                    c_weak) in
-                                                               if uu___15
-                                                               then
-                                                                 FStar_TypeChecker_Util.maybe_assume_result_eq_pure_term
-                                                                   env
-                                                                   branch_exp1
-                                                                   c_weak
-                                                               else c_weak in
-                                                             if
-                                                               branch_has_layered_effect
-                                                             then
-                                                               ((let uu___16
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env)
-                                                                    (FStar_Options.Other
-                                                                    "LayeredEffects") in
-                                                                 if uu___16
-                                                                 then
-                                                                   FStar_Compiler_Util.print_string
-                                                                    "Typechecking pat_bv_tms ...\n"
-                                                                 else ());
-                                                                (let pat_bv_tms1
-                                                                   =
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    pat_bv_tms
-                                                                    (FStar_Compiler_List.map
-                                                                    (fun
-                                                                    pat_bv_tm
-                                                                    ->
-                                                                    let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    scrutinee_tm
-                                                                    FStar_Syntax_Syntax.as_arg in
-                                                                    [uu___17] in
-                                                                    FStar_Syntax_Syntax.mk_Tm_app
-                                                                    pat_bv_tm
-                                                                    uu___16
-                                                                    FStar_Compiler_Range.dummyRange)) in
-                                                                 let pat_bv_tms2
-                                                                   =
-                                                                   let env1 =
-                                                                    let uu___16
-                                                                    =
-                                                                    FStar_TypeChecker_Env.push_bv
-                                                                    env
-                                                                    scrutinee in
-                                                                    {
-                                                                    FStar_TypeChecker_Env.solver
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.solver);
-                                                                    FStar_TypeChecker_Env.range
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.range);
-                                                                    FStar_TypeChecker_Env.curmodule
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.curmodule);
-                                                                    FStar_TypeChecker_Env.gamma
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.gamma);
-                                                                    FStar_TypeChecker_Env.gamma_sig
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.gamma_sig);
-                                                                    FStar_TypeChecker_Env.gamma_cache
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.gamma_cache);
-                                                                    FStar_TypeChecker_Env.modules
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.modules);
-                                                                    FStar_TypeChecker_Env.expected_typ
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.expected_typ);
-                                                                    FStar_TypeChecker_Env.sigtab
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.sigtab);
-                                                                    FStar_TypeChecker_Env.attrtab
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.attrtab);
-                                                                    FStar_TypeChecker_Env.instantiate_imp
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.instantiate_imp);
-                                                                    FStar_TypeChecker_Env.effects
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.effects);
-                                                                    FStar_TypeChecker_Env.generalize
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.generalize);
-                                                                    FStar_TypeChecker_Env.letrecs
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.letrecs);
-                                                                    FStar_TypeChecker_Env.top_level
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.top_level);
-                                                                    FStar_TypeChecker_Env.check_uvars
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.check_uvars);
-                                                                    FStar_TypeChecker_Env.use_eq_strict
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.use_eq_strict);
-                                                                    FStar_TypeChecker_Env.is_iface
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.is_iface);
-                                                                    FStar_TypeChecker_Env.admit
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.admit);
-                                                                    FStar_TypeChecker_Env.lax
-                                                                    = true;
-                                                                    FStar_TypeChecker_Env.lax_universes
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.lax_universes);
-                                                                    FStar_TypeChecker_Env.phase1
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.phase1);
-                                                                    FStar_TypeChecker_Env.failhard
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.failhard);
-                                                                    FStar_TypeChecker_Env.nosynth
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.nosynth);
-                                                                    FStar_TypeChecker_Env.uvar_subtyping
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.uvar_subtyping);
-                                                                    FStar_TypeChecker_Env.tc_term
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.tc_term);
-                                                                    FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.universe_of
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.universe_of);
-                                                                    FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                                                    FStar_TypeChecker_Env.teq_nosmt_force
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.teq_nosmt_force);
-                                                                    FStar_TypeChecker_Env.subtype_nosmt_force
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                                                    FStar_TypeChecker_Env.qtbl_name_and_index
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                                                    FStar_TypeChecker_Env.normalized_eff_names
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.normalized_eff_names);
-                                                                    FStar_TypeChecker_Env.fv_delta_depths
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.fv_delta_depths);
-                                                                    FStar_TypeChecker_Env.proof_ns
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.proof_ns);
-                                                                    FStar_TypeChecker_Env.synth_hook
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.synth_hook);
-                                                                    FStar_TypeChecker_Env.try_solve_implicits_hook
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                                                    FStar_TypeChecker_Env.splice
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.splice);
-                                                                    FStar_TypeChecker_Env.mpreprocess
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.mpreprocess);
-                                                                    FStar_TypeChecker_Env.postprocess
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.postprocess);
-                                                                    FStar_TypeChecker_Env.identifier_info
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.identifier_info);
-                                                                    FStar_TypeChecker_Env.tc_hooks
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.tc_hooks);
-                                                                    FStar_TypeChecker_Env.dsenv
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.dsenv);
-                                                                    FStar_TypeChecker_Env.nbe
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.nbe);
-                                                                    FStar_TypeChecker_Env.strict_args_tab
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.strict_args_tab);
-                                                                    FStar_TypeChecker_Env.erasable_types_tab
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.erasable_types_tab);
-                                                                    FStar_TypeChecker_Env.enable_defer_to_tac
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                                                    FStar_TypeChecker_Env.unif_allow_ref_guards
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                                                    FStar_TypeChecker_Env.erase_erasable_args
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.erase_erasable_args);
-                                                                    FStar_TypeChecker_Env.core_check
-                                                                    =
-                                                                    (uu___16.FStar_TypeChecker_Env.core_check)
-                                                                    } in
-                                                                   let uu___16
-                                                                    =
-                                                                    let uu___17
-                                                                    =
-                                                                    FStar_Compiler_List.fold_left2
-                                                                    (fun
-                                                                    uu___18
-                                                                    ->
-                                                                    fun
-                                                                    pat_bv_tm
-                                                                    ->
-                                                                    fun bv ->
-                                                                    match uu___18
-                                                                    with
-                                                                    | 
-                                                                    (substs,
-                                                                    acc) ->
-                                                                    let expected_t
-                                                                    =
-                                                                    FStar_Syntax_Subst.subst
-                                                                    substs
-                                                                    bv.FStar_Syntax_Syntax.sort in
-                                                                    let pat_bv_tm1
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    pat_bv_tm
-                                                                    (FStar_Syntax_Subst.subst
-                                                                    substs) in
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_TypeChecker_Env.set_expected_typ
-                                                                    env1
-                                                                    expected_t in
-                                                                    tc_trivial_guard
-                                                                    uu___22 in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___20
-                                                                    uu___21 in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___19
-                                                                    FStar_Pervasives_Native.fst in
-                                                                    ((FStar_Compiler_List.op_At
-                                                                    substs
-                                                                    [
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    (bv,
-                                                                    pat_bv_tm1)]),
-                                                                    (FStar_Compiler_List.op_At
-                                                                    acc
-                                                                    [pat_bv_tm1])))
-                                                                    ([], [])
-                                                                    pat_bv_tms1
-                                                                    pat_bvs in
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___17
-                                                                    FStar_Pervasives_Native.snd in
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___16
-                                                                    (FStar_Compiler_List.map
-                                                                    (FStar_TypeChecker_Normalize.normalize
-                                                                    [FStar_TypeChecker_Env.Beta]
-                                                                    env1)) in
-                                                                 (let uu___17
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Less_Bar
-                                                                    (FStar_TypeChecker_Env.debug
-                                                                    env)
-                                                                    (FStar_Options.Other
-                                                                    "LayeredEffects") in
-                                                                  if uu___17
-                                                                  then
-                                                                    let uu___18
-                                                                    =
-                                                                    FStar_Compiler_List.fold_left
-                                                                    (fun s ->
-                                                                    fun t ->
-                                                                    let uu___19
-                                                                    =
-                                                                    let uu___20
-                                                                    =
-                                                                    FStar_Syntax_Print.term_to_string
-                                                                    t in
-                                                                    Prims.op_Hat
-                                                                    ";"
-                                                                    uu___20 in
-                                                                    Prims.op_Hat
-                                                                    s uu___19)
-                                                                    ""
-                                                                    pat_bv_tms2 in
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Compiler_List.fold_left
-                                                                    (fun s ->
-                                                                    fun t ->
-                                                                    let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    FStar_Syntax_Print.bv_to_string
-                                                                    t in
-                                                                    Prims.op_Hat
-                                                                    ";"
-                                                                    uu___21 in
-                                                                    Prims.op_Hat
-                                                                    s uu___20)
-                                                                    ""
-                                                                    pat_bvs in
-                                                                    FStar_Compiler_Util.print2
-                                                                    "tc_eqn: typechecked pat_bv_tms %s (pat_bvs : %s)\n"
-                                                                    uu___18
-                                                                    uu___19
-                                                                  else ());
-                                                                 (let uu___17
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    c_weak1
-                                                                    (FStar_TypeChecker_Common.apply_lcomp
-                                                                    (fun c2
-                                                                    -> c2)
-                                                                    (fun g ->
-                                                                    match eqs
-                                                                    with
-                                                                    | 
-                                                                    FStar_Pervasives_Native.None
-                                                                    -> g
-                                                                    | 
-                                                                    FStar_Pervasives_Native.Some
-                                                                    eqs1 ->
-                                                                    FStar_TypeChecker_Common.weaken_guard_formula
-                                                                    g eqs1)) in
-                                                                  let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_TypeChecker_Env.push_bv
-                                                                    env
-                                                                    scrutinee in
-                                                                    FStar_TypeChecker_Util.close_layered_lcomp
-                                                                    uu___19
-                                                                    pat_bvs
-                                                                    pat_bv_tms2 in
-                                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___17
-                                                                    uu___18)))
-                                                             else
-                                                               (let uu___16 =
-                                                                  FStar_TypeChecker_Env.push_bv
-                                                                    env
-                                                                    scrutinee in
-                                                                FStar_TypeChecker_Util.close_wp_lcomp
-                                                                  uu___16
-                                                                  pat_bvs
-                                                                  c_weak1) in
-                                                           let uu___15 =
-                                                             FStar_TypeChecker_Env.close_guard
-                                                               env binders
-                                                               g_when_weak in
-                                                           let uu___16 =
-                                                             FStar_TypeChecker_Env.conj_guard
-                                                               guard_pat
-                                                               g_branch1 in
-                                                           ((c_weak.FStar_TypeChecker_Common.eff_name),
-                                                             (FStar_Pervasives_Native.Some
-                                                                (c_weak.FStar_TypeChecker_Common.cflags)),
-                                                             (FStar_Pervasives_Native.Some
-                                                                maybe_return_c_weak),
-                                                             uu___15,
-                                                             uu___16))) in
-                                           match uu___11 with
-                                           | (effect_label, cflags,
-                                              maybe_return_c, g_when1,
-                                              g_branch1) ->
-                                               let guard =
-                                                 FStar_TypeChecker_Env.conj_guard
-                                                   g_when1 g_branch1 in
-                                               ((let uu___13 =
-                                                   FStar_TypeChecker_Env.debug
-                                                     env FStar_Options.High in
-                                                 if uu___13
-                                                 then
-                                                   let uu___14 =
-                                                     FStar_TypeChecker_Rel.guard_to_string
-                                                       env guard in
-                                                   FStar_Compiler_Effect.op_Less_Bar
-                                                     (FStar_Compiler_Util.print1
-                                                        "Carrying guard from match: %s\n")
-                                                     uu___14
-                                                 else ());
-                                                (let uu___13 =
-                                                   FStar_Syntax_Subst.close_branch
-                                                     (pattern1, when_clause1,
-                                                       branch_exp1) in
-                                                 let uu___14 =
-                                                   let uu___15 =
-                                                     FStar_Compiler_List.map
-                                                       FStar_Syntax_Syntax.mk_binder
-                                                       pat_bvs in
-                                                   FStar_TypeChecker_Util.close_guard_implicits
-                                                     env false uu___15 guard in
-                                                 (uu___13, branch_guard,
-                                                   effect_label, cflags,
-                                                   maybe_return_c, uu___14,
-                                                   erasable))))))))))))
-and (check_top_level_let :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      let env1 = instantiate_both env in
-      match e.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), e2) ->
-          let uu___ = check_let_bound_def true env1 lb in
-          (match uu___ with
-           | (e1, univ_vars, c1, g1, annotated) ->
-               let uu___1 =
-                 if
-                   annotated &&
-                     (Prims.op_Negation env1.FStar_TypeChecker_Env.generalize)
-                 then
-                   let uu___2 =
-                     FStar_TypeChecker_Normalize.reduce_uvar_solutions env1
-                       e1 in
-                   (g1, uu___2, univ_vars, c1)
-                 else
-                   (let g11 =
-                      let uu___3 =
-                        FStar_TypeChecker_Rel.solve_deferred_constraints env1
-                          g1 in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___3
-                        (FStar_TypeChecker_Rel.resolve_implicits env1) in
-                    let uu___3 = FStar_TypeChecker_Common.lcomp_comp c1 in
-                    match uu___3 with
-                    | (comp1, g_comp1) ->
-                        let g12 =
-                          FStar_TypeChecker_Env.conj_guard g11 g_comp1 in
-                        let uu___4 =
-                          let uu___5 =
-                            FStar_TypeChecker_Generalize.generalize env1
-                              false
-                              [((lb.FStar_Syntax_Syntax.lbname), e1, comp1)] in
-                          FStar_Compiler_List.hd uu___5 in
-                        (match uu___4 with
-                         | (uu___5, univs, e11, c11, gvs) ->
-                             let g13 =
-                               FStar_TypeChecker_Rel.resolve_generalization_implicits
-                                 env1 g12 in
-                             let g14 =
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_TypeChecker_Env.map_guard g13)
-                                 (FStar_TypeChecker_Normalize.normalize
-                                    [FStar_TypeChecker_Env.Beta;
-                                    FStar_TypeChecker_Env.DoNotUnfoldPureLets;
-                                    FStar_TypeChecker_Env.CompressUvars;
-                                    FStar_TypeChecker_Env.NoFullNorm;
-                                    FStar_TypeChecker_Env.Exclude
-                                      FStar_TypeChecker_Env.Zeta] env1) in
-                             let g15 =
-                               FStar_TypeChecker_Env.abstract_guard_n gvs g14 in
-                             let uu___6 =
-                               FStar_TypeChecker_Common.lcomp_of_comp c11 in
-                             (g15, e11, univs, uu___6))) in
-               (match uu___1 with
-                | (g11, e11, univ_vars1, c11) ->
-                    let uu___2 =
-                      let uu___3 =
-                        FStar_TypeChecker_Util.check_top_level env1 g11 c11 in
-                      match uu___3 with
-                      | (ok, c12) ->
-                          if ok
-                          then (e2, c12)
-                          else
-                            ((let uu___6 =
-                                FStar_TypeChecker_Env.get_range env1 in
-                              FStar_Errors.log_issue uu___6
-                                FStar_TypeChecker_Err.top_level_effect);
-                             (let uu___6 =
-                                FStar_Syntax_Syntax.mk
-                                  (FStar_Syntax_Syntax.Tm_meta
-                                     (e2,
-                                       (FStar_Syntax_Syntax.Meta_desugared
-                                          FStar_Syntax_Syntax.Masked_effect)))
-                                  e2.FStar_Syntax_Syntax.pos in
-                              (uu___6, c12))) in
-                    (match uu___2 with
-                     | (e21, c12) ->
-                         ((let uu___4 =
-                             FStar_TypeChecker_Env.debug env1
-                               FStar_Options.Medium in
-                           if uu___4
-                           then
-                             let uu___5 =
-                               FStar_Syntax_Print.term_to_string e11 in
-                             FStar_Compiler_Util.print1
-                               "Let binding BEFORE tcnorm: %s\n" uu___5
-                           else ());
-                          (let e12 =
-                             let uu___4 = FStar_Options.tcnorm () in
-                             if uu___4
-                             then
-                               FStar_TypeChecker_Normalize.normalize
-                                 [FStar_TypeChecker_Env.UnfoldAttr
-                                    [FStar_Parser_Const.tcnorm_attr];
-                                 FStar_TypeChecker_Env.Exclude
-                                   FStar_TypeChecker_Env.Beta;
-                                 FStar_TypeChecker_Env.Exclude
-                                   FStar_TypeChecker_Env.Zeta;
-                                 FStar_TypeChecker_Env.NoFullNorm;
-                                 FStar_TypeChecker_Env.DoNotUnfoldPureLets]
-                                 env1 e11
-                             else e11 in
-                           (let uu___5 =
-                              FStar_TypeChecker_Env.debug env1
-                                FStar_Options.Medium in
-                            if uu___5
-                            then
-                              let uu___6 =
-                                FStar_Syntax_Print.term_to_string e12 in
-                              FStar_Compiler_Util.print1
-                                "Let binding AFTER tcnorm: %s\n" uu___6
-                            else ());
-                           (let cres =
-                              FStar_Syntax_Syntax.mk_Total
-                                FStar_Syntax_Syntax.t_unit in
-                            let lb1 =
-                              FStar_Syntax_Util.close_univs_and_mk_letbinding
-                                FStar_Pervasives_Native.None
-                                lb.FStar_Syntax_Syntax.lbname univ_vars1
-                                (FStar_Syntax_Util.comp_result c12)
-                                (FStar_Syntax_Util.comp_effect_name c12) e12
-                                lb.FStar_Syntax_Syntax.lbattrs
-                                lb.FStar_Syntax_Syntax.lbpos in
-                            let uu___5 =
-                              FStar_Syntax_Syntax.mk
-                                (FStar_Syntax_Syntax.Tm_let
-                                   ((false, [lb1]), e21))
-                                e.FStar_Syntax_Syntax.pos in
-                            let uu___6 =
-                              FStar_TypeChecker_Common.lcomp_of_comp cres in
-                            (uu___5, uu___6,
-                              FStar_TypeChecker_Env.trivial_guard)))))))
-      | uu___ -> failwith "Impossible"
-and (maybe_intro_smt_lemma :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun lem_typ ->
-      fun c2 ->
-        let uu___ = FStar_Syntax_Util.is_smt_lemma lem_typ in
-        if uu___
-        then
-          let universe_of_binders bs =
-            let uu___1 =
-              FStar_Compiler_List.fold_left
-                (fun uu___2 ->
-                   fun b ->
-                     match uu___2 with
-                     | (env1, us) ->
-                         let u =
-                           env1.FStar_TypeChecker_Env.universe_of env1
-                             (b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                         let env2 =
-                           FStar_TypeChecker_Env.push_binders env1 [b] in
-                         (env2, (u :: us))) (env, []) bs in
-            match uu___1 with | (uu___2, us) -> FStar_Compiler_List.rev us in
-          let quant =
-            FStar_Syntax_Util.smt_lemma_as_forall lem_typ universe_of_binders in
-          FStar_TypeChecker_Util.weaken_precondition env c2
-            (FStar_TypeChecker_Common.NonTrivial quant)
-        else c2
-and (check_inner_let :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      let env1 = instantiate_both env in
-      match e.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_let ((false, lb::[]), e2) ->
-          let env2 =
-            {
-              FStar_TypeChecker_Env.solver =
-                (env1.FStar_TypeChecker_Env.solver);
-              FStar_TypeChecker_Env.range =
-                (env1.FStar_TypeChecker_Env.range);
-              FStar_TypeChecker_Env.curmodule =
-                (env1.FStar_TypeChecker_Env.curmodule);
-              FStar_TypeChecker_Env.gamma =
-                (env1.FStar_TypeChecker_Env.gamma);
-              FStar_TypeChecker_Env.gamma_sig =
-                (env1.FStar_TypeChecker_Env.gamma_sig);
-              FStar_TypeChecker_Env.gamma_cache =
-                (env1.FStar_TypeChecker_Env.gamma_cache);
-              FStar_TypeChecker_Env.modules =
-                (env1.FStar_TypeChecker_Env.modules);
-              FStar_TypeChecker_Env.expected_typ =
-                (env1.FStar_TypeChecker_Env.expected_typ);
-              FStar_TypeChecker_Env.sigtab =
-                (env1.FStar_TypeChecker_Env.sigtab);
-              FStar_TypeChecker_Env.attrtab =
-                (env1.FStar_TypeChecker_Env.attrtab);
-              FStar_TypeChecker_Env.instantiate_imp =
-                (env1.FStar_TypeChecker_Env.instantiate_imp);
-              FStar_TypeChecker_Env.effects =
-                (env1.FStar_TypeChecker_Env.effects);
-              FStar_TypeChecker_Env.generalize =
-                (env1.FStar_TypeChecker_Env.generalize);
-              FStar_TypeChecker_Env.letrecs =
-                (env1.FStar_TypeChecker_Env.letrecs);
-              FStar_TypeChecker_Env.top_level = false;
-              FStar_TypeChecker_Env.check_uvars =
-                (env1.FStar_TypeChecker_Env.check_uvars);
-              FStar_TypeChecker_Env.use_eq_strict =
-                (env1.FStar_TypeChecker_Env.use_eq_strict);
-              FStar_TypeChecker_Env.is_iface =
-                (env1.FStar_TypeChecker_Env.is_iface);
-              FStar_TypeChecker_Env.admit =
-                (env1.FStar_TypeChecker_Env.admit);
-              FStar_TypeChecker_Env.lax = (env1.FStar_TypeChecker_Env.lax);
-              FStar_TypeChecker_Env.lax_universes =
-                (env1.FStar_TypeChecker_Env.lax_universes);
-              FStar_TypeChecker_Env.phase1 =
-                (env1.FStar_TypeChecker_Env.phase1);
-              FStar_TypeChecker_Env.failhard =
-                (env1.FStar_TypeChecker_Env.failhard);
-              FStar_TypeChecker_Env.nosynth =
-                (env1.FStar_TypeChecker_Env.nosynth);
-              FStar_TypeChecker_Env.uvar_subtyping =
-                (env1.FStar_TypeChecker_Env.uvar_subtyping);
-              FStar_TypeChecker_Env.tc_term =
-                (env1.FStar_TypeChecker_Env.tc_term);
-              FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-              FStar_TypeChecker_Env.universe_of =
-                (env1.FStar_TypeChecker_Env.universe_of);
-              FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-              FStar_TypeChecker_Env.teq_nosmt_force =
-                (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-              FStar_TypeChecker_Env.subtype_nosmt_force =
-                (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-              FStar_TypeChecker_Env.qtbl_name_and_index =
-                (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-              FStar_TypeChecker_Env.normalized_eff_names =
-                (env1.FStar_TypeChecker_Env.normalized_eff_names);
-              FStar_TypeChecker_Env.fv_delta_depths =
-                (env1.FStar_TypeChecker_Env.fv_delta_depths);
-              FStar_TypeChecker_Env.proof_ns =
-                (env1.FStar_TypeChecker_Env.proof_ns);
-              FStar_TypeChecker_Env.synth_hook =
-                (env1.FStar_TypeChecker_Env.synth_hook);
-              FStar_TypeChecker_Env.try_solve_implicits_hook =
-                (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-              FStar_TypeChecker_Env.splice =
-                (env1.FStar_TypeChecker_Env.splice);
-              FStar_TypeChecker_Env.mpreprocess =
-                (env1.FStar_TypeChecker_Env.mpreprocess);
-              FStar_TypeChecker_Env.postprocess =
-                (env1.FStar_TypeChecker_Env.postprocess);
-              FStar_TypeChecker_Env.identifier_info =
-                (env1.FStar_TypeChecker_Env.identifier_info);
-              FStar_TypeChecker_Env.tc_hooks =
-                (env1.FStar_TypeChecker_Env.tc_hooks);
-              FStar_TypeChecker_Env.dsenv =
-                (env1.FStar_TypeChecker_Env.dsenv);
-              FStar_TypeChecker_Env.nbe = (env1.FStar_TypeChecker_Env.nbe);
-              FStar_TypeChecker_Env.strict_args_tab =
-                (env1.FStar_TypeChecker_Env.strict_args_tab);
-              FStar_TypeChecker_Env.erasable_types_tab =
-                (env1.FStar_TypeChecker_Env.erasable_types_tab);
-              FStar_TypeChecker_Env.enable_defer_to_tac =
-                (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-              FStar_TypeChecker_Env.unif_allow_ref_guards =
-                (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-              FStar_TypeChecker_Env.erase_erasable_args =
-                (env1.FStar_TypeChecker_Env.erase_erasable_args);
-              FStar_TypeChecker_Env.core_check =
-                (env1.FStar_TypeChecker_Env.core_check)
-            } in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.clear_expected_typ env2 in
-              FStar_Compiler_Effect.op_Bar_Greater uu___2
-                FStar_Pervasives_Native.fst in
-            check_let_bound_def false uu___1 lb in
-          (match uu___ with
-           | (e1, uu___1, c1, g1, annotated) ->
-               let pure_or_ghost =
-                 FStar_TypeChecker_Common.is_pure_or_ghost_lcomp c1 in
-               let is_inline_let =
-                 FStar_Compiler_Util.for_some
-                   (FStar_Syntax_Util.is_fvar
-                      FStar_Parser_Const.inline_let_attr)
-                   lb.FStar_Syntax_Syntax.lbattrs in
-               ((let uu___3 =
-                   is_inline_let &&
-                     (let uu___4 =
-                        pure_or_ghost ||
-                          (FStar_TypeChecker_Env.is_erasable_effect env2
-                             c1.FStar_TypeChecker_Common.eff_name) in
-                      Prims.op_Negation uu___4) in
-                 if uu___3
-                 then
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Syntax_Print.term_to_string e1 in
-                       let uu___7 =
-                         FStar_Syntax_Print.lid_to_string
-                           c1.FStar_TypeChecker_Common.eff_name in
-                       FStar_Compiler_Util.format2
-                         "Definitions marked @inline_let are expected to be pure or ghost; got an expression \"%s\" with effect \"%s\""
-                         uu___6 uu___7 in
-                     (FStar_Errors.Fatal_ExpectedPureExpression, uu___5) in
-                   FStar_Errors.raise_error uu___4 e1.FStar_Syntax_Syntax.pos
-                 else ());
-                (let x =
-                   let uu___3 =
-                     FStar_Compiler_Util.left lb.FStar_Syntax_Syntax.lbname in
-                   {
-                     FStar_Syntax_Syntax.ppname =
-                       (uu___3.FStar_Syntax_Syntax.ppname);
-                     FStar_Syntax_Syntax.index =
-                       (uu___3.FStar_Syntax_Syntax.index);
-                     FStar_Syntax_Syntax.sort =
-                       (c1.FStar_TypeChecker_Common.res_typ)
-                   } in
-                 let uu___3 =
-                   let uu___4 =
-                     let uu___5 = FStar_Syntax_Syntax.mk_binder x in [uu___5] in
-                   FStar_Syntax_Subst.open_term uu___4 e2 in
-                 match uu___3 with
-                 | (xb, e21) ->
-                     let xbinder = FStar_Compiler_List.hd xb in
-                     let x1 = xbinder.FStar_Syntax_Syntax.binder_bv in
-                     let env_x = FStar_TypeChecker_Env.push_bv env2 x1 in
-                     let uu___4 =
-                       let uu___5 = tc_term env_x e21 in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___5
-                         (fun uu___6 ->
-                            match uu___6 with
-                            | (e22, c2, g2) ->
-                                let uu___7 =
-                                  let uu___8 =
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      (fun uu___9 ->
-                                         "folding guard g2 of e2 in the lcomp")
-                                      (fun uu___9 ->
-                                         FStar_Pervasives_Native.Some uu___9) in
-                                  FStar_TypeChecker_Util.strengthen_precondition
-                                    uu___8 env_x e22 c2 g2 in
-                                (match uu___7 with
-                                 | (c21, g21) -> (e22, c21, g21))) in
-                     (match uu___4 with
-                      | (e22, c2, g2) ->
-                          let c21 =
-                            maybe_intro_smt_lemma env_x
-                              c1.FStar_TypeChecker_Common.res_typ c2 in
-                          let cres =
-                            FStar_TypeChecker_Util.maybe_return_e2_and_bind
-                              e1.FStar_Syntax_Syntax.pos env2
-                              (FStar_Pervasives_Native.Some e1) c1 e22
-                              ((FStar_Pervasives_Native.Some x1), c21) in
-                          let e11 =
-                            FStar_TypeChecker_Util.maybe_lift env2 e1
-                              c1.FStar_TypeChecker_Common.eff_name
-                              cres.FStar_TypeChecker_Common.eff_name
-                              c1.FStar_TypeChecker_Common.res_typ in
-                          let e23 =
-                            FStar_TypeChecker_Util.maybe_lift env2 e22
-                              c21.FStar_TypeChecker_Common.eff_name
-                              cres.FStar_TypeChecker_Common.eff_name
-                              c21.FStar_TypeChecker_Common.res_typ in
-                          let lb1 =
-                            let attrs =
-                              let add_inline_let =
-                                (Prims.op_Negation is_inline_let) &&
-                                  ((pure_or_ghost &&
-                                      (FStar_Syntax_Util.is_unit
-                                         c1.FStar_TypeChecker_Common.res_typ))
-                                     ||
-                                     ((FStar_TypeChecker_Env.is_erasable_effect
-                                         env2
-                                         c1.FStar_TypeChecker_Common.eff_name)
-                                        &&
-                                        (let uu___5 =
-                                           FStar_TypeChecker_Env.is_erasable_effect
-                                             env2
-                                             cres.FStar_TypeChecker_Common.eff_name in
-                                         Prims.op_Negation uu___5))) in
-                              if add_inline_let
-                              then FStar_Syntax_Util.inline_let_attr ::
-                                (lb.FStar_Syntax_Syntax.lbattrs)
-                              else lb.FStar_Syntax_Syntax.lbattrs in
-                            FStar_Syntax_Util.mk_letbinding
-                              (FStar_Pervasives.Inl x1) []
-                              c1.FStar_TypeChecker_Common.res_typ
-                              cres.FStar_TypeChecker_Common.eff_name e11
-                              attrs lb.FStar_Syntax_Syntax.lbpos in
-                          let e3 =
-                            let uu___5 =
-                              let uu___6 =
-                                let uu___7 = FStar_Syntax_Subst.close xb e23 in
-                                ((false, [lb1]), uu___7) in
-                              FStar_Syntax_Syntax.Tm_let uu___6 in
-                            FStar_Syntax_Syntax.mk uu___5
-                              e.FStar_Syntax_Syntax.pos in
-                          let e4 =
-                            FStar_TypeChecker_Util.maybe_monadic env2 e3
-                              cres.FStar_TypeChecker_Common.eff_name
-                              cres.FStar_TypeChecker_Common.res_typ in
-                          let g21 =
-                            let uu___5 =
-                              let uu___6 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  cres.FStar_TypeChecker_Common.eff_name
-                                  (FStar_TypeChecker_Env.norm_eff_name env2) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                (FStar_TypeChecker_Env.is_layered_effect env2) in
-                            FStar_TypeChecker_Util.close_guard_implicits env2
-                              uu___5 xb g2 in
-                          let guard = FStar_TypeChecker_Env.conj_guard g1 g21 in
-                          let uu___5 =
-                            let uu___6 =
-                              FStar_TypeChecker_Env.expected_typ env2 in
-                            FStar_Compiler_Option.isSome uu___6 in
-                          if uu___5
-                          then
-                            let tt =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_TypeChecker_Env.expected_typ env2 in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___7
-                                  FStar_Compiler_Option.get in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                FStar_Pervasives_Native.fst in
-                            ((let uu___7 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env2)
-                                  (FStar_Options.Other "Exports") in
-                              if uu___7
-                              then
-                                let uu___8 =
-                                  FStar_Syntax_Print.term_to_string tt in
-                                let uu___9 =
-                                  FStar_Syntax_Print.term_to_string
-                                    cres.FStar_TypeChecker_Common.res_typ in
-                                FStar_Compiler_Util.print2
-                                  "Got expected type from env %s\ncres.res_typ=%s\n"
-                                  uu___8 uu___9
-                              else ());
-                             (e4, cres, guard))
-                          else
-                            (let uu___7 =
-                               check_no_escape FStar_Pervasives_Native.None
-                                 env2 [x1]
-                                 cres.FStar_TypeChecker_Common.res_typ in
-                             match uu___7 with
-                             | (t, g_ex) ->
-                                 ((let uu___9 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (FStar_TypeChecker_Env.debug env2)
-                                       (FStar_Options.Other "Exports") in
-                                   if uu___9
-                                   then
-                                     let uu___10 =
-                                       FStar_Syntax_Print.term_to_string
-                                         cres.FStar_TypeChecker_Common.res_typ in
-                                     let uu___11 =
-                                       FStar_Syntax_Print.term_to_string t in
-                                     FStar_Compiler_Util.print2
-                                       "Checked %s has no escaping types; normalized to %s\n"
-                                       uu___10 uu___11
-                                   else ());
-                                  (let uu___9 =
-                                     FStar_TypeChecker_Env.conj_guard g_ex
-                                       guard in
-                                   (e4,
-                                     {
-                                       FStar_TypeChecker_Common.eff_name =
-                                         (cres.FStar_TypeChecker_Common.eff_name);
-                                       FStar_TypeChecker_Common.res_typ = t;
-                                       FStar_TypeChecker_Common.cflags =
-                                         (cres.FStar_TypeChecker_Common.cflags);
-                                       FStar_TypeChecker_Common.comp_thunk =
-                                         (cres.FStar_TypeChecker_Common.comp_thunk)
-                                     }, uu___9))))))))
-      | uu___ -> failwith "Impossible (inner let with more than one lb)"
-and (check_top_level_let_rec :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun top ->
-      let env1 = instantiate_both env in
-      match top.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_let ((true, lbs), e2) ->
-          let uu___ = FStar_Syntax_Subst.open_let_rec lbs e2 in
-          (match uu___ with
-           | (lbs1, e21) ->
-               let uu___1 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-               (match uu___1 with
-                | (env0, topt) ->
-                    let uu___2 = build_let_rec_env true env0 lbs1 in
-                    (match uu___2 with
-                     | (lbs2, rec_env, g_t) ->
-                         let uu___3 = check_let_recs rec_env lbs2 in
-                         (match uu___3 with
-                          | (lbs3, g_lbs) ->
-                              let g_lbs1 =
-                                let uu___4 =
-                                  let uu___5 =
-                                    FStar_TypeChecker_Env.conj_guard g_t
-                                      g_lbs in
-                                  FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                    (FStar_TypeChecker_Rel.solve_deferred_constraints
-                                       env1) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                                  (FStar_TypeChecker_Rel.resolve_implicits
-                                     env1) in
-                              let all_lb_names =
-                                let uu___4 =
-                                  FStar_Compiler_Effect.op_Bar_Greater lbs3
-                                    (FStar_Compiler_List.map
-                                       (fun lb ->
-                                          FStar_Compiler_Util.right
-                                            lb.FStar_Syntax_Syntax.lbname)) in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                                  (fun uu___5 ->
-                                     FStar_Pervasives_Native.Some uu___5) in
-                              let uu___4 =
-                                if
-                                  Prims.op_Negation
-                                    env1.FStar_TypeChecker_Env.generalize
-                                then
-                                  let lbs4 =
-                                    FStar_Compiler_Effect.op_Bar_Greater lbs3
-                                      (FStar_Compiler_List.map
-                                         (fun lb ->
-                                            let lbdef =
-                                              FStar_TypeChecker_Normalize.reduce_uvar_solutions
-                                                env1
-                                                lb.FStar_Syntax_Syntax.lbdef in
-                                            if
-                                              lb.FStar_Syntax_Syntax.lbunivs
-                                                = []
-                                            then lb
-                                            else
-                                              FStar_Syntax_Util.close_univs_and_mk_letbinding
-                                                all_lb_names
-                                                lb.FStar_Syntax_Syntax.lbname
-                                                lb.FStar_Syntax_Syntax.lbunivs
-                                                lb.FStar_Syntax_Syntax.lbtyp
-                                                lb.FStar_Syntax_Syntax.lbeff
-                                                lbdef
-                                                lb.FStar_Syntax_Syntax.lbattrs
-                                                lb.FStar_Syntax_Syntax.lbpos)) in
-                                  (lbs4, g_lbs1)
-                                else
-                                  (let ecs =
-                                     let uu___6 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         lbs3
-                                         (FStar_Compiler_List.map
-                                            (fun lb ->
-                                               let uu___7 =
-                                                 FStar_Syntax_Syntax.mk_Total
-                                                   lb.FStar_Syntax_Syntax.lbtyp in
-                                               ((lb.FStar_Syntax_Syntax.lbname),
-                                                 (lb.FStar_Syntax_Syntax.lbdef),
-                                                 uu___7))) in
-                                     FStar_TypeChecker_Generalize.generalize
-                                       env1 true uu___6 in
-                                   let lbs4 =
-                                     FStar_Compiler_List.map2
-                                       (fun uu___6 ->
-                                          fun lb ->
-                                            match uu___6 with
-                                            | (x, uvs, e, c, gvs) ->
-                                                FStar_Syntax_Util.close_univs_and_mk_letbinding
-                                                  all_lb_names x uvs
-                                                  (FStar_Syntax_Util.comp_result
-                                                     c)
-                                                  (FStar_Syntax_Util.comp_effect_name
-                                                     c) e
-                                                  lb.FStar_Syntax_Syntax.lbattrs
-                                                  lb.FStar_Syntax_Syntax.lbpos)
-                                       ecs lbs3 in
-                                   let g_lbs2 =
-                                     FStar_TypeChecker_Rel.resolve_generalization_implicits
-                                       env1 g_lbs1 in
-                                   (lbs4, g_lbs2)) in
-                              (match uu___4 with
-                               | (lbs4, g_lbs2) ->
-                                   let cres =
-                                     let uu___5 =
-                                       FStar_Syntax_Syntax.mk_Total
-                                         FStar_Syntax_Syntax.t_unit in
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       FStar_TypeChecker_Common.lcomp_of_comp
-                                       uu___5 in
-                                   let uu___5 =
-                                     FStar_Syntax_Subst.close_let_rec lbs4
-                                       e21 in
-                                   (match uu___5 with
-                                    | (lbs5, e22) ->
-                                        ((let uu___7 =
-                                            FStar_TypeChecker_Rel.discharge_guard
-                                              env1 g_lbs2 in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___7
-                                            (FStar_TypeChecker_Rel.force_trivial_guard
-                                               env1));
-                                         (let uu___7 =
-                                            FStar_Syntax_Syntax.mk
-                                              (FStar_Syntax_Syntax.Tm_let
-                                                 ((true, lbs5), e22))
-                                              top.FStar_Syntax_Syntax.pos in
-                                          (uu___7, cres,
-                                            FStar_TypeChecker_Env.trivial_guard)))))))))
-      | uu___ -> failwith "Impossible"
-and (check_inner_let_rec :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun top ->
-      let env1 = instantiate_both env in
-      match top.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_let ((true, lbs), e2) ->
-          let uu___ = FStar_Syntax_Subst.open_let_rec lbs e2 in
-          (match uu___ with
-           | (lbs1, e21) ->
-               let uu___1 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-               (match uu___1 with
-                | (env0, topt) ->
-                    let uu___2 = build_let_rec_env false env0 lbs1 in
-                    (match uu___2 with
-                     | (lbs2, rec_env, g_t) ->
-                         let uu___3 =
-                           let uu___4 = check_let_recs rec_env lbs2 in
-                           FStar_Compiler_Effect.op_Bar_Greater uu___4
-                             (fun uu___5 ->
-                                match uu___5 with
-                                | (lbs3, g) ->
-                                    let uu___6 =
-                                      FStar_TypeChecker_Env.conj_guard g_t g in
-                                    (lbs3, uu___6)) in
-                         (match uu___3 with
-                          | (lbs3, g_lbs) ->
-                              let uu___4 =
-                                FStar_Compiler_Effect.op_Bar_Greater lbs3
-                                  (FStar_Compiler_Util.fold_map
-                                     (fun env2 ->
-                                        fun lb ->
-                                          let x =
-                                            let uu___5 =
-                                              FStar_Compiler_Util.left
-                                                lb.FStar_Syntax_Syntax.lbname in
-                                            {
-                                              FStar_Syntax_Syntax.ppname =
-                                                (uu___5.FStar_Syntax_Syntax.ppname);
-                                              FStar_Syntax_Syntax.index =
-                                                (uu___5.FStar_Syntax_Syntax.index);
-                                              FStar_Syntax_Syntax.sort =
-                                                (lb.FStar_Syntax_Syntax.lbtyp)
-                                            } in
-                                          let lb1 =
-                                            {
-                                              FStar_Syntax_Syntax.lbname =
-                                                (FStar_Pervasives.Inl x);
-                                              FStar_Syntax_Syntax.lbunivs =
-                                                (lb.FStar_Syntax_Syntax.lbunivs);
-                                              FStar_Syntax_Syntax.lbtyp =
-                                                (lb.FStar_Syntax_Syntax.lbtyp);
-                                              FStar_Syntax_Syntax.lbeff =
-                                                (lb.FStar_Syntax_Syntax.lbeff);
-                                              FStar_Syntax_Syntax.lbdef =
-                                                (lb.FStar_Syntax_Syntax.lbdef);
-                                              FStar_Syntax_Syntax.lbattrs =
-                                                (lb.FStar_Syntax_Syntax.lbattrs);
-                                              FStar_Syntax_Syntax.lbpos =
-                                                (lb.FStar_Syntax_Syntax.lbpos)
-                                            } in
-                                          let env3 =
-                                            FStar_TypeChecker_Env.push_let_binding
-                                              env2
-                                              lb1.FStar_Syntax_Syntax.lbname
-                                              ([],
-                                                (lb1.FStar_Syntax_Syntax.lbtyp)) in
-                                          (env3, lb1)) env1) in
-                              (match uu___4 with
-                               | (env2, lbs4) ->
-                                   let bvs =
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       lbs4
-                                       (FStar_Compiler_List.map
-                                          (fun lb ->
-                                             FStar_Compiler_Util.left
-                                               lb.FStar_Syntax_Syntax.lbname)) in
-                                   let uu___5 = tc_term env2 e21 in
-                                   (match uu___5 with
-                                    | (e22, cres, g2) ->
-                                        let cres1 =
-                                          FStar_Compiler_List.fold_right
-                                            (fun lb ->
-                                               fun cres2 ->
-                                                 maybe_intro_smt_lemma env2
-                                                   lb.FStar_Syntax_Syntax.lbtyp
-                                                   cres2) lbs4 cres in
-                                        let cres2 =
-                                          FStar_TypeChecker_Util.maybe_assume_result_eq_pure_term
-                                            env2 e22 cres1 in
-                                        let cres3 =
-                                          FStar_TypeChecker_Common.lcomp_set_flags
-                                            cres2
-                                            [FStar_Syntax_Syntax.SHOULD_NOT_INLINE] in
-                                        let guard =
-                                          let uu___6 =
-                                            let uu___7 =
-                                              FStar_Compiler_List.map
-                                                FStar_Syntax_Syntax.mk_binder
-                                                bvs in
-                                            FStar_TypeChecker_Env.close_guard
-                                              env2 uu___7 g2 in
-                                          FStar_TypeChecker_Env.conj_guard
-                                            g_lbs uu___6 in
-                                        let cres4 =
-                                          let uu___6 =
-                                            let uu___7 =
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                cres3.FStar_TypeChecker_Common.eff_name
-                                                (FStar_TypeChecker_Env.norm_eff_name
-                                                   env2) in
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              uu___7
-                                              (FStar_TypeChecker_Env.is_layered_effect
-                                                 env2) in
-                                          if uu___6
-                                          then
-                                            let bvss =
-                                              FStar_Compiler_Util.as_set bvs
-                                                FStar_Syntax_Syntax.order_bv in
-                                            FStar_TypeChecker_Common.apply_lcomp
-                                              (fun c ->
-                                                 let uu___7 =
-                                                   let uu___8 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       c
-                                                       FStar_Syntax_Util.comp_effect_args in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___8
-                                                     (FStar_Compiler_List.existsb
-                                                        (fun uu___9 ->
-                                                           match uu___9 with
-                                                           | (t, uu___10) ->
-                                                               let uu___11 =
-                                                                 let uu___12
-                                                                   =
-                                                                   let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    t
-                                                                    FStar_Syntax_Free.names in
-                                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                                    uu___13
-                                                                    (FStar_Compiler_Util.set_intersect
-                                                                    bvss) in
-                                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                                   uu___12
-                                                                   FStar_Compiler_Util.set_is_empty in
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 uu___11
-                                                                 Prims.op_Negation)) in
-                                                 if uu___7
-                                                 then
-                                                   FStar_Errors.raise_error
-                                                     (FStar_Errors.Fatal_EscapedBoundVar,
-                                                       "One of the inner let recs escapes in the effect argument(s), try adding a type annotation")
-                                                     top.FStar_Syntax_Syntax.pos
-                                                 else c) (fun g -> g) cres3
-                                          else
-                                            FStar_TypeChecker_Util.close_wp_lcomp
-                                              env2 bvs cres3 in
-                                        let tres =
-                                          norm env2
-                                            cres4.FStar_TypeChecker_Common.res_typ in
-                                        let cres5 =
-                                          {
-                                            FStar_TypeChecker_Common.eff_name
-                                              =
-                                              (cres4.FStar_TypeChecker_Common.eff_name);
-                                            FStar_TypeChecker_Common.res_typ
-                                              = tres;
-                                            FStar_TypeChecker_Common.cflags =
-                                              (cres4.FStar_TypeChecker_Common.cflags);
-                                            FStar_TypeChecker_Common.comp_thunk
-                                              =
-                                              (cres4.FStar_TypeChecker_Common.comp_thunk)
-                                          } in
-                                        let guard1 =
-                                          let bs =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              lbs4
-                                              (FStar_Compiler_List.map
-                                                 (fun lb ->
-                                                    let uu___6 =
-                                                      FStar_Compiler_Util.left
-                                                        lb.FStar_Syntax_Syntax.lbname in
-                                                    FStar_Syntax_Syntax.mk_binder
-                                                      uu___6)) in
-                                          FStar_TypeChecker_Util.close_guard_implicits
-                                            env2 false bs guard in
-                                        let uu___6 =
-                                          FStar_Syntax_Subst.close_let_rec
-                                            lbs4 e22 in
-                                        (match uu___6 with
-                                         | (lbs5, e23) ->
-                                             let e =
-                                               FStar_Syntax_Syntax.mk
-                                                 (FStar_Syntax_Syntax.Tm_let
-                                                    ((true, lbs5), e23))
-                                                 top.FStar_Syntax_Syntax.pos in
-                                             (match topt with
-                                              | FStar_Pervasives_Native.Some
-                                                  uu___7 ->
-                                                  (e, cres5, guard1)
-                                              | FStar_Pervasives_Native.None
-                                                  ->
-                                                  let uu___7 =
-                                                    check_no_escape
-                                                      FStar_Pervasives_Native.None
-                                                      env2 bvs tres in
-                                                  (match uu___7 with
-                                                   | (tres1, g_ex) ->
-                                                       let cres6 =
-                                                         {
-                                                           FStar_TypeChecker_Common.eff_name
-                                                             =
-                                                             (cres5.FStar_TypeChecker_Common.eff_name);
-                                                           FStar_TypeChecker_Common.res_typ
-                                                             = tres1;
-                                                           FStar_TypeChecker_Common.cflags
-                                                             =
-                                                             (cres5.FStar_TypeChecker_Common.cflags);
-                                                           FStar_TypeChecker_Common.comp_thunk
-                                                             =
-                                                             (cres5.FStar_TypeChecker_Common.comp_thunk)
-                                                         } in
-                                                       let uu___8 =
-                                                         FStar_TypeChecker_Env.conj_guard
-                                                           g_ex guard1 in
-                                                       (e, cres6, uu___8))))))))))
-      | uu___ -> failwith "Impossible"
-and (build_let_rec_env :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.letbinding Prims.list ->
-        (FStar_Syntax_Syntax.letbinding Prims.list *
-          FStar_TypeChecker_Env.env_t * FStar_TypeChecker_Env.guard_t))
-  =
-  fun _top_level ->
-    fun env ->
-      fun lbs ->
-        let env0 = env in
-        let termination_check_enabled lbname lbdef lbtyp =
-          let uu___ = FStar_Options.ml_ish () in
-          if uu___
-          then FStar_Pervasives_Native.None
-          else
-            (let lbtyp0 = lbtyp in
-             let uu___2 = FStar_Syntax_Util.abs_formals lbdef in
-             match uu___2 with
-             | (actuals, body, body_lc) ->
-                 let actuals1 =
-                   let uu___3 =
-                     FStar_TypeChecker_Env.set_expected_typ env lbtyp in
-                   FStar_TypeChecker_Util.maybe_add_implicit_binders uu___3
-                     actuals in
-                 let nactuals = FStar_Compiler_List.length actuals1 in
-                 let uu___3 =
-                   FStar_TypeChecker_Normalize.get_n_binders env nactuals
-                     lbtyp in
-                 (match uu___3 with
-                  | (formals, c) ->
-                      (if
-                         (FStar_Compiler_List.isEmpty formals) ||
-                           (FStar_Compiler_List.isEmpty actuals1)
-                       then
-                         (let uu___5 =
-                            let uu___6 =
-                              let uu___7 =
-                                FStar_Syntax_Print.tag_of_term lbdef in
-                              let uu___8 =
-                                FStar_Syntax_Print.term_to_string lbdef in
-                              let uu___9 =
-                                FStar_Syntax_Print.term_to_string lbtyp in
-                              FStar_Compiler_Util.format3
-                                "Only function literals with arrow types can be defined recursively; got (%s) %s : %s"
-                                uu___7 uu___8 uu___9 in
-                            (FStar_Errors.Fatal_RecursiveFunctionLiteral,
-                              uu___6) in
-                          FStar_Errors.raise_error uu___5
-                            lbtyp.FStar_Syntax_Syntax.pos)
-                       else ();
-                       (let nformals = FStar_Compiler_List.length formals in
-                        let uu___5 =
-                          let uu___6 =
-                            FStar_Compiler_Effect.op_Bar_Greater
-                              (FStar_Syntax_Util.comp_effect_name c)
-                              (FStar_TypeChecker_Env.lookup_effect_quals env) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___6
-                            (FStar_Compiler_List.contains
-                               FStar_Syntax_Syntax.TotalEffect) in
-                        if uu___5
-                        then
-                          let uu___6 =
-                            let uu___7 =
-                              FStar_Syntax_Util.abs actuals1 body body_lc in
-                            (nformals, uu___7) in
-                          FStar_Pervasives_Native.Some uu___6
-                        else FStar_Pervasives_Native.None)))) in
-        let check_annot univ_vars t =
-          let env01 = FStar_TypeChecker_Env.push_univ_vars env0 univ_vars in
-          let uu___ =
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Util.type_u () in
-              FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.fst
-                uu___2 in
-            tc_check_tot_or_gtot_term
-              {
-                FStar_TypeChecker_Env.solver =
-                  (env01.FStar_TypeChecker_Env.solver);
-                FStar_TypeChecker_Env.range =
-                  (env01.FStar_TypeChecker_Env.range);
-                FStar_TypeChecker_Env.curmodule =
-                  (env01.FStar_TypeChecker_Env.curmodule);
-                FStar_TypeChecker_Env.gamma =
-                  (env01.FStar_TypeChecker_Env.gamma);
-                FStar_TypeChecker_Env.gamma_sig =
-                  (env01.FStar_TypeChecker_Env.gamma_sig);
-                FStar_TypeChecker_Env.gamma_cache =
-                  (env01.FStar_TypeChecker_Env.gamma_cache);
-                FStar_TypeChecker_Env.modules =
-                  (env01.FStar_TypeChecker_Env.modules);
-                FStar_TypeChecker_Env.expected_typ =
-                  (env01.FStar_TypeChecker_Env.expected_typ);
-                FStar_TypeChecker_Env.sigtab =
-                  (env01.FStar_TypeChecker_Env.sigtab);
-                FStar_TypeChecker_Env.attrtab =
-                  (env01.FStar_TypeChecker_Env.attrtab);
-                FStar_TypeChecker_Env.instantiate_imp =
-                  (env01.FStar_TypeChecker_Env.instantiate_imp);
-                FStar_TypeChecker_Env.effects =
-                  (env01.FStar_TypeChecker_Env.effects);
-                FStar_TypeChecker_Env.generalize =
-                  (env01.FStar_TypeChecker_Env.generalize);
-                FStar_TypeChecker_Env.letrecs =
-                  (env01.FStar_TypeChecker_Env.letrecs);
-                FStar_TypeChecker_Env.top_level =
-                  (env01.FStar_TypeChecker_Env.top_level);
-                FStar_TypeChecker_Env.check_uvars = true;
-                FStar_TypeChecker_Env.use_eq_strict =
-                  (env01.FStar_TypeChecker_Env.use_eq_strict);
-                FStar_TypeChecker_Env.is_iface =
-                  (env01.FStar_TypeChecker_Env.is_iface);
-                FStar_TypeChecker_Env.admit =
-                  (env01.FStar_TypeChecker_Env.admit);
-                FStar_TypeChecker_Env.lax = (env01.FStar_TypeChecker_Env.lax);
-                FStar_TypeChecker_Env.lax_universes =
-                  (env01.FStar_TypeChecker_Env.lax_universes);
-                FStar_TypeChecker_Env.phase1 =
-                  (env01.FStar_TypeChecker_Env.phase1);
-                FStar_TypeChecker_Env.failhard =
-                  (env01.FStar_TypeChecker_Env.failhard);
-                FStar_TypeChecker_Env.nosynth =
-                  (env01.FStar_TypeChecker_Env.nosynth);
-                FStar_TypeChecker_Env.uvar_subtyping =
-                  (env01.FStar_TypeChecker_Env.uvar_subtyping);
-                FStar_TypeChecker_Env.tc_term =
-                  (env01.FStar_TypeChecker_Env.tc_term);
-                FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                  (env01.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                FStar_TypeChecker_Env.universe_of =
-                  (env01.FStar_TypeChecker_Env.universe_of);
-                FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                  (env01.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                FStar_TypeChecker_Env.teq_nosmt_force =
-                  (env01.FStar_TypeChecker_Env.teq_nosmt_force);
-                FStar_TypeChecker_Env.subtype_nosmt_force =
-                  (env01.FStar_TypeChecker_Env.subtype_nosmt_force);
-                FStar_TypeChecker_Env.qtbl_name_and_index =
-                  (env01.FStar_TypeChecker_Env.qtbl_name_and_index);
-                FStar_TypeChecker_Env.normalized_eff_names =
-                  (env01.FStar_TypeChecker_Env.normalized_eff_names);
-                FStar_TypeChecker_Env.fv_delta_depths =
-                  (env01.FStar_TypeChecker_Env.fv_delta_depths);
-                FStar_TypeChecker_Env.proof_ns =
-                  (env01.FStar_TypeChecker_Env.proof_ns);
-                FStar_TypeChecker_Env.synth_hook =
-                  (env01.FStar_TypeChecker_Env.synth_hook);
-                FStar_TypeChecker_Env.try_solve_implicits_hook =
-                  (env01.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                FStar_TypeChecker_Env.splice =
-                  (env01.FStar_TypeChecker_Env.splice);
-                FStar_TypeChecker_Env.mpreprocess =
-                  (env01.FStar_TypeChecker_Env.mpreprocess);
-                FStar_TypeChecker_Env.postprocess =
-                  (env01.FStar_TypeChecker_Env.postprocess);
-                FStar_TypeChecker_Env.identifier_info =
-                  (env01.FStar_TypeChecker_Env.identifier_info);
-                FStar_TypeChecker_Env.tc_hooks =
-                  (env01.FStar_TypeChecker_Env.tc_hooks);
-                FStar_TypeChecker_Env.dsenv =
-                  (env01.FStar_TypeChecker_Env.dsenv);
-                FStar_TypeChecker_Env.nbe = (env01.FStar_TypeChecker_Env.nbe);
-                FStar_TypeChecker_Env.strict_args_tab =
-                  (env01.FStar_TypeChecker_Env.strict_args_tab);
-                FStar_TypeChecker_Env.erasable_types_tab =
-                  (env01.FStar_TypeChecker_Env.erasable_types_tab);
-                FStar_TypeChecker_Env.enable_defer_to_tac =
-                  (env01.FStar_TypeChecker_Env.enable_defer_to_tac);
-                FStar_TypeChecker_Env.unif_allow_ref_guards =
-                  (env01.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                FStar_TypeChecker_Env.erase_erasable_args =
-                  (env01.FStar_TypeChecker_Env.erase_erasable_args);
-                FStar_TypeChecker_Env.core_check =
-                  (env01.FStar_TypeChecker_Env.core_check)
-              } t uu___1 "" in
-          match uu___ with
-          | (t1, uu___1, g) ->
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_Effect.op_Bar_Greater g
-                    (FStar_TypeChecker_Rel.resolve_implicits env) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  (FStar_TypeChecker_Rel.discharge_guard env01) in
-              (env01, uu___2, t1) in
-        let uu___ =
-          FStar_Compiler_List.fold_left
-            (fun uu___1 ->
-               fun lb ->
-                 match uu___1 with
-                 | (lbs1, env1, g_acc) ->
-                     let uu___2 =
-                       FStar_TypeChecker_Util.extract_let_rec_annotation env1
-                         lb in
-                     (match uu___2 with
-                      | (univ_vars, lbtyp, lbdef, check_t) ->
-                          let env2 =
-                            FStar_TypeChecker_Env.push_univ_vars env1
-                              univ_vars in
-                          let uu___3 =
-                            if Prims.op_Negation check_t
-                            then (g_acc, lbtyp)
-                            else
-                              (let uu___5 = check_annot univ_vars lbtyp in
-                               match uu___5 with
-                               | (uu___6, g, t) ->
-                                   let uu___7 =
-                                     FStar_TypeChecker_Env.conj_guard g_acc g in
-                                   (uu___7, t)) in
-                          (match uu___3 with
-                           | (g, lbtyp1) ->
-                               let uu___4 =
-                                 let uu___5 =
-                                   termination_check_enabled
-                                     lb.FStar_Syntax_Syntax.lbname lbdef
-                                     lbtyp1 in
-                                 match uu___5 with
-                                 | FStar_Pervasives_Native.Some
-                                     (arity, lbdef1) ->
-                                     ((let uu___7 =
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           (FStar_TypeChecker_Env.debug env2)
-                                           FStar_Options.Extreme in
-                                       if uu___7
-                                       then
-                                         let uu___8 =
-                                           FStar_Compiler_Util.string_of_int
-                                             arity in
-                                         let uu___9 =
-                                           FStar_Syntax_Print.term_to_string
-                                             lbdef1 in
-                                         FStar_Compiler_Util.print2
-                                           "termination_check_enabled returned arity: %s and lbdef: %s\n"
-                                           uu___8 uu___9
-                                       else ());
-                                      (let lb1 =
-                                         {
-                                           FStar_Syntax_Syntax.lbname =
-                                             (lb.FStar_Syntax_Syntax.lbname);
-                                           FStar_Syntax_Syntax.lbunivs =
-                                             univ_vars;
-                                           FStar_Syntax_Syntax.lbtyp = lbtyp1;
-                                           FStar_Syntax_Syntax.lbeff =
-                                             (lb.FStar_Syntax_Syntax.lbeff);
-                                           FStar_Syntax_Syntax.lbdef = lbdef1;
-                                           FStar_Syntax_Syntax.lbattrs =
-                                             (lb.FStar_Syntax_Syntax.lbattrs);
-                                           FStar_Syntax_Syntax.lbpos =
-                                             (lb.FStar_Syntax_Syntax.lbpos)
-                                         } in
-                                       let env3 =
-                                         {
-                                           FStar_TypeChecker_Env.solver =
-                                             (env2.FStar_TypeChecker_Env.solver);
-                                           FStar_TypeChecker_Env.range =
-                                             (env2.FStar_TypeChecker_Env.range);
-                                           FStar_TypeChecker_Env.curmodule =
-                                             (env2.FStar_TypeChecker_Env.curmodule);
-                                           FStar_TypeChecker_Env.gamma =
-                                             (env2.FStar_TypeChecker_Env.gamma);
-                                           FStar_TypeChecker_Env.gamma_sig =
-                                             (env2.FStar_TypeChecker_Env.gamma_sig);
-                                           FStar_TypeChecker_Env.gamma_cache
-                                             =
-                                             (env2.FStar_TypeChecker_Env.gamma_cache);
-                                           FStar_TypeChecker_Env.modules =
-                                             (env2.FStar_TypeChecker_Env.modules);
-                                           FStar_TypeChecker_Env.expected_typ
-                                             =
-                                             (env2.FStar_TypeChecker_Env.expected_typ);
-                                           FStar_TypeChecker_Env.sigtab =
-                                             (env2.FStar_TypeChecker_Env.sigtab);
-                                           FStar_TypeChecker_Env.attrtab =
-                                             (env2.FStar_TypeChecker_Env.attrtab);
-                                           FStar_TypeChecker_Env.instantiate_imp
-                                             =
-                                             (env2.FStar_TypeChecker_Env.instantiate_imp);
-                                           FStar_TypeChecker_Env.effects =
-                                             (env2.FStar_TypeChecker_Env.effects);
-                                           FStar_TypeChecker_Env.generalize =
-                                             (env2.FStar_TypeChecker_Env.generalize);
-                                           FStar_TypeChecker_Env.letrecs =
-                                             (((lb1.FStar_Syntax_Syntax.lbname),
-                                                arity, lbtyp1, univ_vars) ::
-                                             (env2.FStar_TypeChecker_Env.letrecs));
-                                           FStar_TypeChecker_Env.top_level =
-                                             (env2.FStar_TypeChecker_Env.top_level);
-                                           FStar_TypeChecker_Env.check_uvars
-                                             =
-                                             (env2.FStar_TypeChecker_Env.check_uvars);
-                                           FStar_TypeChecker_Env.use_eq_strict
-                                             =
-                                             (env2.FStar_TypeChecker_Env.use_eq_strict);
-                                           FStar_TypeChecker_Env.is_iface =
-                                             (env2.FStar_TypeChecker_Env.is_iface);
-                                           FStar_TypeChecker_Env.admit =
-                                             (env2.FStar_TypeChecker_Env.admit);
-                                           FStar_TypeChecker_Env.lax =
-                                             (env2.FStar_TypeChecker_Env.lax);
-                                           FStar_TypeChecker_Env.lax_universes
-                                             =
-                                             (env2.FStar_TypeChecker_Env.lax_universes);
-                                           FStar_TypeChecker_Env.phase1 =
-                                             (env2.FStar_TypeChecker_Env.phase1);
-                                           FStar_TypeChecker_Env.failhard =
-                                             (env2.FStar_TypeChecker_Env.failhard);
-                                           FStar_TypeChecker_Env.nosynth =
-                                             (env2.FStar_TypeChecker_Env.nosynth);
-                                           FStar_TypeChecker_Env.uvar_subtyping
-                                             =
-                                             (env2.FStar_TypeChecker_Env.uvar_subtyping);
-                                           FStar_TypeChecker_Env.tc_term =
-                                             (env2.FStar_TypeChecker_Env.tc_term);
-                                           FStar_TypeChecker_Env.typeof_tot_or_gtot_term
-                                             =
-                                             (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                                           FStar_TypeChecker_Env.universe_of
-                                             =
-                                             (env2.FStar_TypeChecker_Env.universe_of);
-                                           FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                                             =
-                                             (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                                           FStar_TypeChecker_Env.teq_nosmt_force
-                                             =
-                                             (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-                                           FStar_TypeChecker_Env.subtype_nosmt_force
-                                             =
-                                             (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                                           FStar_TypeChecker_Env.qtbl_name_and_index
-                                             =
-                                             (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                                           FStar_TypeChecker_Env.normalized_eff_names
-                                             =
-                                             (env2.FStar_TypeChecker_Env.normalized_eff_names);
-                                           FStar_TypeChecker_Env.fv_delta_depths
-                                             =
-                                             (env2.FStar_TypeChecker_Env.fv_delta_depths);
-                                           FStar_TypeChecker_Env.proof_ns =
-                                             (env2.FStar_TypeChecker_Env.proof_ns);
-                                           FStar_TypeChecker_Env.synth_hook =
-                                             (env2.FStar_TypeChecker_Env.synth_hook);
-                                           FStar_TypeChecker_Env.try_solve_implicits_hook
-                                             =
-                                             (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                                           FStar_TypeChecker_Env.splice =
-                                             (env2.FStar_TypeChecker_Env.splice);
-                                           FStar_TypeChecker_Env.mpreprocess
-                                             =
-                                             (env2.FStar_TypeChecker_Env.mpreprocess);
-                                           FStar_TypeChecker_Env.postprocess
-                                             =
-                                             (env2.FStar_TypeChecker_Env.postprocess);
-                                           FStar_TypeChecker_Env.identifier_info
-                                             =
-                                             (env2.FStar_TypeChecker_Env.identifier_info);
-                                           FStar_TypeChecker_Env.tc_hooks =
-                                             (env2.FStar_TypeChecker_Env.tc_hooks);
-                                           FStar_TypeChecker_Env.dsenv =
-                                             (env2.FStar_TypeChecker_Env.dsenv);
-                                           FStar_TypeChecker_Env.nbe =
-                                             (env2.FStar_TypeChecker_Env.nbe);
-                                           FStar_TypeChecker_Env.strict_args_tab
-                                             =
-                                             (env2.FStar_TypeChecker_Env.strict_args_tab);
-                                           FStar_TypeChecker_Env.erasable_types_tab
-                                             =
-                                             (env2.FStar_TypeChecker_Env.erasable_types_tab);
-                                           FStar_TypeChecker_Env.enable_defer_to_tac
-                                             =
-                                             (env2.FStar_TypeChecker_Env.enable_defer_to_tac);
-                                           FStar_TypeChecker_Env.unif_allow_ref_guards
-                                             =
-                                             (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                                           FStar_TypeChecker_Env.erase_erasable_args
-                                             =
-                                             (env2.FStar_TypeChecker_Env.erase_erasable_args);
-                                           FStar_TypeChecker_Env.core_check =
-                                             (env2.FStar_TypeChecker_Env.core_check)
-                                         } in
-                                       (lb1, env3)))
-                                 | FStar_Pervasives_Native.None ->
-                                     let lb1 =
-                                       {
-                                         FStar_Syntax_Syntax.lbname =
-                                           (lb.FStar_Syntax_Syntax.lbname);
-                                         FStar_Syntax_Syntax.lbunivs =
-                                           univ_vars;
-                                         FStar_Syntax_Syntax.lbtyp = lbtyp1;
-                                         FStar_Syntax_Syntax.lbeff =
-                                           (lb.FStar_Syntax_Syntax.lbeff);
-                                         FStar_Syntax_Syntax.lbdef = lbdef;
-                                         FStar_Syntax_Syntax.lbattrs =
-                                           (lb.FStar_Syntax_Syntax.lbattrs);
-                                         FStar_Syntax_Syntax.lbpos =
-                                           (lb.FStar_Syntax_Syntax.lbpos)
-                                       } in
-                                     let uu___6 =
-                                       FStar_TypeChecker_Env.push_let_binding
-                                         env2 lb1.FStar_Syntax_Syntax.lbname
-                                         (univ_vars, lbtyp1) in
-                                     (lb1, uu___6) in
-                               (match uu___4 with
-                                | (lb1, env3) -> ((lb1 :: lbs1), env3, g)))))
-            ([], env, FStar_TypeChecker_Env.trivial_guard) lbs in
-        match uu___ with
-        | (lbs1, env1, g) -> ((FStar_Compiler_List.rev lbs1), env1, g)
-and (check_let_recs :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Syntax_Syntax.letbinding Prims.list ->
-      (FStar_Syntax_Syntax.letbinding Prims.list *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun lbts ->
-      let uu___ =
-        let uu___1 =
-          FStar_Compiler_Effect.op_Bar_Greater lbts
-            (FStar_Compiler_List.map
-               (fun lb ->
-                  let uu___2 =
-                    FStar_Syntax_Util.abs_formals
-                      lb.FStar_Syntax_Syntax.lbdef in
-                  match uu___2 with
-                  | (bs, t, lcomp) ->
-                      (match bs with
-                       | [] ->
-                           let uu___3 =
-                             let uu___4 =
-                               let uu___5 =
-                                 FStar_Syntax_Print.lbname_to_string
-                                   lb.FStar_Syntax_Syntax.lbname in
-                               let uu___6 =
-                                 FStar_Syntax_Print.term_to_string
-                                   lb.FStar_Syntax_Syntax.lbdef in
-                               FStar_Compiler_Util.format2
-                                 "Only function literals may be defined recursively; %s is defined to be %s"
-                                 uu___5 uu___6 in
-                             (FStar_Errors.Fatal_RecursiveFunctionLiteral,
-                               uu___4) in
-                           let uu___4 =
-                             FStar_Syntax_Syntax.range_of_lbname
-                               lb.FStar_Syntax_Syntax.lbname in
-                           FStar_Errors.raise_error uu___3 uu___4
-                       | uu___3 ->
-                           let arity =
-                             let uu___5 =
-                               FStar_TypeChecker_Env.get_letrec_arity env
-                                 lb.FStar_Syntax_Syntax.lbname in
-                             match uu___5 with
-                             | FStar_Pervasives_Native.Some n -> n
-                             | FStar_Pervasives_Native.None ->
-                                 FStar_Compiler_List.length bs in
-                           let uu___5 = FStar_Compiler_List.splitAt arity bs in
-                           (match uu___5 with
-                            | (bs0, bs1) ->
-                                let def =
-                                  if FStar_Compiler_List.isEmpty bs1
-                                  then FStar_Syntax_Util.abs bs0 t lcomp
-                                  else
-                                    (let inner =
-                                       FStar_Syntax_Util.abs bs1 t lcomp in
-                                     let inner1 =
-                                       FStar_Syntax_Subst.close bs0 inner in
-                                     let bs01 =
-                                       FStar_Syntax_Subst.close_binders bs0 in
-                                     FStar_Syntax_Syntax.mk
-                                       (FStar_Syntax_Syntax.Tm_abs
-                                          (bs01, inner1,
-                                            FStar_Pervasives_Native.None))
-                                       inner1.FStar_Syntax_Syntax.pos) in
-                                let lb1 =
-                                  {
-                                    FStar_Syntax_Syntax.lbname =
-                                      (lb.FStar_Syntax_Syntax.lbname);
-                                    FStar_Syntax_Syntax.lbunivs =
-                                      (lb.FStar_Syntax_Syntax.lbunivs);
-                                    FStar_Syntax_Syntax.lbtyp =
-                                      (lb.FStar_Syntax_Syntax.lbtyp);
-                                    FStar_Syntax_Syntax.lbeff =
-                                      (lb.FStar_Syntax_Syntax.lbeff);
-                                    FStar_Syntax_Syntax.lbdef = def;
-                                    FStar_Syntax_Syntax.lbattrs =
-                                      (lb.FStar_Syntax_Syntax.lbattrs);
-                                    FStar_Syntax_Syntax.lbpos =
-                                      (lb.FStar_Syntax_Syntax.lbpos)
-                                  } in
-                                let uu___6 =
-                                  let uu___7 =
-                                    FStar_TypeChecker_Env.set_expected_typ
-                                      env lb1.FStar_Syntax_Syntax.lbtyp in
-                                  tc_tot_or_gtot_term uu___7
-                                    lb1.FStar_Syntax_Syntax.lbdef in
-                                (match uu___6 with
-                                 | (e, c, g) ->
-                                     ((let uu___8 =
-                                         let uu___9 =
-                                           FStar_TypeChecker_Common.is_total_lcomp
-                                             c in
-                                         Prims.op_Negation uu___9 in
-                                       if uu___8
-                                       then
-                                         FStar_Errors.raise_error
-                                           (FStar_Errors.Fatal_UnexpectedGTotForLetRec,
-                                             "Expected let rec to be a Tot term; got effect GTot")
-                                           e.FStar_Syntax_Syntax.pos
-                                       else ());
-                                      (let lb2 =
-                                         FStar_Syntax_Util.mk_letbinding
-                                           lb1.FStar_Syntax_Syntax.lbname
-                                           lb1.FStar_Syntax_Syntax.lbunivs
-                                           lb1.FStar_Syntax_Syntax.lbtyp
-                                           FStar_Parser_Const.effect_Tot_lid
-                                           e lb1.FStar_Syntax_Syntax.lbattrs
-                                           lb1.FStar_Syntax_Syntax.lbpos in
-                                       (lb2, g)))))))) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___1 FStar_Compiler_List.unzip in
-      match uu___ with
-      | (lbs, gs) ->
-          let g_lbs =
-            FStar_Compiler_List.fold_right FStar_TypeChecker_Env.conj_guard
-              gs FStar_TypeChecker_Env.trivial_guard in
-          (lbs, g_lbs)
-and (check_let_bound_def :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.letbinding ->
-        (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.univ_names *
-          FStar_TypeChecker_Common.lcomp * FStar_TypeChecker_Env.guard_t *
-          Prims.bool))
-  =
-  fun top_level ->
-    fun env ->
-      fun lb ->
-        let uu___ = FStar_TypeChecker_Env.clear_expected_typ env in
-        match uu___ with
-        | (env1, uu___1) ->
-            let e1 = lb.FStar_Syntax_Syntax.lbdef in
-            let uu___2 = check_lbtyp top_level env lb in
-            (match uu___2 with
-             | (topt, wf_annot, univ_vars, univ_opening, env11) ->
-                 (if (Prims.op_Negation top_level) && (univ_vars <> [])
-                  then
-                    FStar_Errors.raise_error
-                      (FStar_Errors.Fatal_UniversePolymorphicInnerLetBound,
-                        "Inner let-bound definitions cannot be universe polymorphic")
-                      e1.FStar_Syntax_Syntax.pos
-                  else ();
-                  (let e11 = FStar_Syntax_Subst.subst univ_opening e1 in
-                   let uu___5 =
-                     tc_maybe_toplevel_term
-                       {
-                         FStar_TypeChecker_Env.solver =
-                           (env11.FStar_TypeChecker_Env.solver);
-                         FStar_TypeChecker_Env.range =
-                           (env11.FStar_TypeChecker_Env.range);
-                         FStar_TypeChecker_Env.curmodule =
-                           (env11.FStar_TypeChecker_Env.curmodule);
-                         FStar_TypeChecker_Env.gamma =
-                           (env11.FStar_TypeChecker_Env.gamma);
-                         FStar_TypeChecker_Env.gamma_sig =
-                           (env11.FStar_TypeChecker_Env.gamma_sig);
-                         FStar_TypeChecker_Env.gamma_cache =
-                           (env11.FStar_TypeChecker_Env.gamma_cache);
-                         FStar_TypeChecker_Env.modules =
-                           (env11.FStar_TypeChecker_Env.modules);
-                         FStar_TypeChecker_Env.expected_typ =
-                           (env11.FStar_TypeChecker_Env.expected_typ);
-                         FStar_TypeChecker_Env.sigtab =
-                           (env11.FStar_TypeChecker_Env.sigtab);
-                         FStar_TypeChecker_Env.attrtab =
-                           (env11.FStar_TypeChecker_Env.attrtab);
-                         FStar_TypeChecker_Env.instantiate_imp =
-                           (env11.FStar_TypeChecker_Env.instantiate_imp);
-                         FStar_TypeChecker_Env.effects =
-                           (env11.FStar_TypeChecker_Env.effects);
-                         FStar_TypeChecker_Env.generalize =
-                           (env11.FStar_TypeChecker_Env.generalize);
-                         FStar_TypeChecker_Env.letrecs =
-                           (env11.FStar_TypeChecker_Env.letrecs);
-                         FStar_TypeChecker_Env.top_level = top_level;
-                         FStar_TypeChecker_Env.check_uvars =
-                           (env11.FStar_TypeChecker_Env.check_uvars);
-                         FStar_TypeChecker_Env.use_eq_strict =
-                           (env11.FStar_TypeChecker_Env.use_eq_strict);
-                         FStar_TypeChecker_Env.is_iface =
-                           (env11.FStar_TypeChecker_Env.is_iface);
-                         FStar_TypeChecker_Env.admit =
-                           (env11.FStar_TypeChecker_Env.admit);
-                         FStar_TypeChecker_Env.lax =
-                           (env11.FStar_TypeChecker_Env.lax);
-                         FStar_TypeChecker_Env.lax_universes =
-                           (env11.FStar_TypeChecker_Env.lax_universes);
-                         FStar_TypeChecker_Env.phase1 =
-                           (env11.FStar_TypeChecker_Env.phase1);
-                         FStar_TypeChecker_Env.failhard =
-                           (env11.FStar_TypeChecker_Env.failhard);
-                         FStar_TypeChecker_Env.nosynth =
-                           (env11.FStar_TypeChecker_Env.nosynth);
-                         FStar_TypeChecker_Env.uvar_subtyping =
-                           (env11.FStar_TypeChecker_Env.uvar_subtyping);
-                         FStar_TypeChecker_Env.tc_term =
-                           (env11.FStar_TypeChecker_Env.tc_term);
-                         FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                           (env11.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.universe_of =
-                           (env11.FStar_TypeChecker_Env.universe_of);
-                         FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                           =
-                           (env11.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.teq_nosmt_force =
-                           (env11.FStar_TypeChecker_Env.teq_nosmt_force);
-                         FStar_TypeChecker_Env.subtype_nosmt_force =
-                           (env11.FStar_TypeChecker_Env.subtype_nosmt_force);
-                         FStar_TypeChecker_Env.qtbl_name_and_index =
-                           (env11.FStar_TypeChecker_Env.qtbl_name_and_index);
-                         FStar_TypeChecker_Env.normalized_eff_names =
-                           (env11.FStar_TypeChecker_Env.normalized_eff_names);
-                         FStar_TypeChecker_Env.fv_delta_depths =
-                           (env11.FStar_TypeChecker_Env.fv_delta_depths);
-                         FStar_TypeChecker_Env.proof_ns =
-                           (env11.FStar_TypeChecker_Env.proof_ns);
-                         FStar_TypeChecker_Env.synth_hook =
-                           (env11.FStar_TypeChecker_Env.synth_hook);
-                         FStar_TypeChecker_Env.try_solve_implicits_hook =
-                           (env11.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                         FStar_TypeChecker_Env.splice =
-                           (env11.FStar_TypeChecker_Env.splice);
-                         FStar_TypeChecker_Env.mpreprocess =
-                           (env11.FStar_TypeChecker_Env.mpreprocess);
-                         FStar_TypeChecker_Env.postprocess =
-                           (env11.FStar_TypeChecker_Env.postprocess);
-                         FStar_TypeChecker_Env.identifier_info =
-                           (env11.FStar_TypeChecker_Env.identifier_info);
-                         FStar_TypeChecker_Env.tc_hooks =
-                           (env11.FStar_TypeChecker_Env.tc_hooks);
-                         FStar_TypeChecker_Env.dsenv =
-                           (env11.FStar_TypeChecker_Env.dsenv);
-                         FStar_TypeChecker_Env.nbe =
-                           (env11.FStar_TypeChecker_Env.nbe);
-                         FStar_TypeChecker_Env.strict_args_tab =
-                           (env11.FStar_TypeChecker_Env.strict_args_tab);
-                         FStar_TypeChecker_Env.erasable_types_tab =
-                           (env11.FStar_TypeChecker_Env.erasable_types_tab);
-                         FStar_TypeChecker_Env.enable_defer_to_tac =
-                           (env11.FStar_TypeChecker_Env.enable_defer_to_tac);
-                         FStar_TypeChecker_Env.unif_allow_ref_guards =
-                           (env11.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                         FStar_TypeChecker_Env.erase_erasable_args =
-                           (env11.FStar_TypeChecker_Env.erase_erasable_args);
-                         FStar_TypeChecker_Env.core_check =
-                           (env11.FStar_TypeChecker_Env.core_check)
-                       } e11 in
-                   match uu___5 with
-                   | (e12, c1, g1) ->
-                       let uu___6 =
-                         let uu___7 =
-                           FStar_TypeChecker_Env.set_range env11
-                             e12.FStar_Syntax_Syntax.pos in
-                         FStar_TypeChecker_Util.strengthen_precondition
-                           (FStar_Pervasives_Native.Some
-                              (fun uu___8 ->
-                                 FStar_Compiler_Util.return_all
-                                   FStar_TypeChecker_Err.ill_kinded_type))
-                           uu___7 e12 c1 wf_annot in
-                       (match uu___6 with
-                        | (c11, guard_f) ->
-                            let g11 =
-                              FStar_TypeChecker_Env.conj_guard g1 guard_f in
-                            ((let uu___8 =
-                                FStar_TypeChecker_Env.debug env
-                                  FStar_Options.Extreme in
-                              if uu___8
-                              then
-                                let uu___9 =
-                                  FStar_Syntax_Print.lbname_to_string
-                                    lb.FStar_Syntax_Syntax.lbname in
-                                let uu___10 =
-                                  FStar_TypeChecker_Common.lcomp_to_string
-                                    c11 in
-                                let uu___11 =
-                                  FStar_TypeChecker_Rel.guard_to_string env
-                                    g11 in
-                                FStar_Compiler_Util.print3
-                                  "checked let-bound def %s : %s guard is %s\n"
-                                  uu___9 uu___10 uu___11
-                              else ());
-                             (e12, univ_vars, c11, g11,
-                               (FStar_Compiler_Option.isSome topt)))))))
-and (check_lbtyp :
-  Prims.bool ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.letbinding ->
-        (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option *
-          FStar_TypeChecker_Env.guard_t * FStar_Syntax_Syntax.univ_names *
-          FStar_Syntax_Syntax.subst_elt Prims.list *
-          FStar_TypeChecker_Env.env))
-  =
-  fun top_level ->
-    fun env ->
-      fun lb ->
-        let t = FStar_Syntax_Subst.compress lb.FStar_Syntax_Syntax.lbtyp in
-        match t.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_unknown ->
-            let uu___ =
-              FStar_Syntax_Subst.univ_var_opening
-                lb.FStar_Syntax_Syntax.lbunivs in
-            (match uu___ with
-             | (univ_opening, univ_vars) ->
-                 let uu___1 =
-                   FStar_TypeChecker_Env.push_univ_vars env univ_vars in
-                 (FStar_Pervasives_Native.None,
-                   FStar_TypeChecker_Env.trivial_guard, univ_vars,
-                   univ_opening, uu___1))
-        | uu___ ->
-            let uu___1 =
-              FStar_Syntax_Subst.univ_var_opening
-                lb.FStar_Syntax_Syntax.lbunivs in
-            (match uu___1 with
-             | (univ_opening, univ_vars) ->
-                 let t1 = FStar_Syntax_Subst.subst univ_opening t in
-                 let env1 =
-                   FStar_TypeChecker_Env.push_univ_vars env univ_vars in
-                 if
-                   top_level &&
-                     (Prims.op_Negation env.FStar_TypeChecker_Env.generalize)
-                 then
-                   let uu___2 =
-                     FStar_TypeChecker_Env.set_expected_typ env1 t1 in
-                   ((FStar_Pervasives_Native.Some t1),
-                     FStar_TypeChecker_Env.trivial_guard, univ_vars,
-                     univ_opening, uu___2)
-                 else
-                   (let uu___3 = FStar_Syntax_Util.type_u () in
-                    match uu___3 with
-                    | (k, uu___4) ->
-                        let uu___5 = tc_check_tot_or_gtot_term env1 t1 k "" in
-                        (match uu___5 with
-                         | (t2, uu___6, g) ->
-                             ((let uu___8 =
-                                 FStar_TypeChecker_Env.debug env
-                                   FStar_Options.Medium in
-                               if uu___8
-                               then
-                                 let uu___9 =
-                                   let uu___10 =
-                                     FStar_Syntax_Util.range_of_lbname
-                                       lb.FStar_Syntax_Syntax.lbname in
-                                   FStar_Compiler_Range.string_of_range
-                                     uu___10 in
-                                 let uu___10 =
-                                   FStar_Syntax_Print.term_to_string t2 in
-                                 FStar_Compiler_Util.print2
-                                   "(%s) Checked type annotation %s\n" uu___9
-                                   uu___10
-                               else ());
-                              (let t3 = norm env1 t2 in
-                               let uu___8 =
-                                 FStar_TypeChecker_Env.set_expected_typ env1
-                                   t3 in
-                               ((FStar_Pervasives_Native.Some t3), g,
-                                 univ_vars, univ_opening, uu___8))))))
-and (tc_binder :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binder ->
-      (FStar_Syntax_Syntax.binder * FStar_TypeChecker_Env.env *
-        FStar_TypeChecker_Env.guard_t * FStar_Syntax_Syntax.universe))
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | { FStar_Syntax_Syntax.binder_bv = x;
-          FStar_Syntax_Syntax.binder_qual = imp;
-          FStar_Syntax_Syntax.binder_attrs = attrs;_} ->
-          let uu___1 = FStar_Syntax_Util.type_u () in
-          (match uu___1 with
-           | (tu, u) ->
-               ((let uu___3 =
-                   FStar_TypeChecker_Env.debug env FStar_Options.Extreme in
-                 if uu___3
-                 then
-                   let uu___4 = FStar_Syntax_Print.bv_to_string x in
-                   let uu___5 =
-                     FStar_Syntax_Print.term_to_string
-                       x.FStar_Syntax_Syntax.sort in
-                   let uu___6 = FStar_Syntax_Print.term_to_string tu in
-                   FStar_Compiler_Util.print3
-                     "Checking binder %s:%s at type %s\n" uu___4 uu___5
-                     uu___6
-                 else ());
-                (let uu___3 =
-                   tc_check_tot_or_gtot_term env x.FStar_Syntax_Syntax.sort
-                     tu "" in
-                 match uu___3 with
-                 | (t, uu___4, g) ->
-                     let uu___5 =
-                       match imp with
-                       | FStar_Pervasives_Native.Some
-                           (FStar_Syntax_Syntax.Meta tau) ->
-                           let uu___6 =
-                             tc_tactic FStar_Syntax_Syntax.t_unit
-                               FStar_Syntax_Syntax.t_unit env tau in
-                           (match uu___6 with
-                            | (tau1, uu___7, g1) ->
-                                ((FStar_Pervasives_Native.Some
-                                    (FStar_Syntax_Syntax.Meta tau1)), g1))
-                       | uu___6 -> (imp, FStar_TypeChecker_Env.trivial_guard) in
-                     (match uu___5 with
-                      | (imp1, g') ->
-                          let attrs1 = tc_attributes env attrs in
-                          (check_erasable_binder_attributes env attrs1 t;
-                           (let x1 =
-                              FStar_Syntax_Syntax.mk_binder_with_attrs
-                                {
-                                  FStar_Syntax_Syntax.ppname =
-                                    (x.FStar_Syntax_Syntax.ppname);
-                                  FStar_Syntax_Syntax.index =
-                                    (x.FStar_Syntax_Syntax.index);
-                                  FStar_Syntax_Syntax.sort = t
-                                } imp1 attrs1 in
-                            (let uu___8 =
-                               FStar_TypeChecker_Env.debug env
-                                 FStar_Options.High in
-                             if uu___8
-                             then
-                               let uu___9 =
-                                 FStar_Syntax_Print.bv_to_string
-                                   x1.FStar_Syntax_Syntax.binder_bv in
-                               let uu___10 =
-                                 FStar_Syntax_Print.term_to_string t in
-                               FStar_Compiler_Util.print2
-                                 "Pushing binder %s at type %s\n" uu___9
-                                 uu___10
-                             else ());
-                            (let uu___8 = push_binding env x1 in
-                             (x1, uu___8, g, u))))))))
-and (tc_binders :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      (FStar_Syntax_Syntax.binders * FStar_TypeChecker_Env.env *
-        FStar_TypeChecker_Env.guard_t * FStar_Syntax_Syntax.universes))
-  =
-  fun env ->
-    fun bs ->
-      (let uu___1 = FStar_TypeChecker_Env.debug env FStar_Options.Extreme in
-       if uu___1
-       then
-         let uu___2 = FStar_Syntax_Print.binders_to_string ", " bs in
-         FStar_Compiler_Util.print1 "Checking binders %s\n" uu___2
-       else ());
-      (let rec aux env1 bs1 =
-         match bs1 with
-         | [] -> ([], env1, FStar_TypeChecker_Env.trivial_guard, [])
-         | b::bs2 ->
-             let uu___1 = tc_binder env1 b in
-             (match uu___1 with
-              | (b1, env', g, u) ->
-                  let uu___2 = aux env' bs2 in
-                  (match uu___2 with
-                   | (bs3, env'1, g', us) ->
-                       let uu___3 =
-                         let uu___4 =
-                           FStar_TypeChecker_Env.close_guard_univs [u] 
-                             [b1] g' in
-                         FStar_TypeChecker_Env.conj_guard g uu___4 in
-                       ((b1 :: bs3), env'1, uu___3, (u :: us)))) in
-       aux env bs)
-and (tc_smt_pats :
-  FStar_TypeChecker_Env.env ->
-    (FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-      FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-      Prims.list Prims.list ->
-      ((FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax *
-        FStar_Syntax_Syntax.arg_qualifier FStar_Pervasives_Native.option)
-        Prims.list Prims.list * FStar_TypeChecker_Common.guard_t))
-  =
-  fun en ->
-    fun pats ->
-      let tc_args en1 args =
-        FStar_Compiler_List.fold_right
-          (fun uu___ ->
-             fun uu___1 ->
-               match (uu___, uu___1) with
-               | ((t, imp), (args1, g)) ->
-                   (FStar_Compiler_Effect.op_Bar_Greater t
-                      (check_no_smt_theory_symbols en1);
-                    (let uu___3 = tc_term en1 t in
-                     match uu___3 with
-                     | (t1, uu___4, g') ->
-                         let uu___5 = FStar_TypeChecker_Env.conj_guard g g' in
-                         (((t1, imp) :: args1), uu___5)))) args
-          ([], FStar_TypeChecker_Env.trivial_guard) in
-      FStar_Compiler_List.fold_right
-        (fun p ->
-           fun uu___ ->
-             match uu___ with
-             | (pats1, g) ->
-                 let uu___1 = tc_args en p in
-                 (match uu___1 with
-                  | (args, g') ->
-                      let uu___2 = FStar_TypeChecker_Env.conj_guard g g' in
-                      ((args :: pats1), uu___2))) pats
-        ([], FStar_TypeChecker_Env.trivial_guard)
-and (tc_tot_or_gtot_term_maybe_solve_deferred :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      Prims.string ->
-        Prims.bool ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun msg ->
-        fun solve_deferred ->
-          let uu___ = tc_maybe_toplevel_term env e in
-          match uu___ with
-          | (e1, c, g) ->
-              let uu___1 = FStar_TypeChecker_Common.is_tot_or_gtot_lcomp c in
-              if uu___1
-              then (e1, c, g)
-              else
-                (let g1 =
-                   if solve_deferred
-                   then
-                     FStar_TypeChecker_Rel.solve_deferred_constraints env g
-                   else g in
-                 let uu___3 = FStar_TypeChecker_Common.lcomp_comp c in
-                 match uu___3 with
-                 | (c1, g_c) ->
-                     let c2 = norm_c env c1 in
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_TypeChecker_Util.is_pure_effect env
-                           (FStar_Syntax_Util.comp_effect_name c2) in
-                       if uu___5
-                       then
-                         let uu___6 =
-                           FStar_Syntax_Syntax.mk_Total
-                             (FStar_Syntax_Util.comp_result c2) in
-                         (uu___6, false)
-                       else
-                         (let uu___7 =
-                            FStar_Syntax_Syntax.mk_GTotal
-                              (FStar_Syntax_Util.comp_result c2) in
-                          (uu___7, true)) in
-                     (match uu___4 with
-                      | (target_comp, allow_ghost) ->
-                          let uu___5 =
-                            FStar_TypeChecker_Rel.sub_comp env c2 target_comp in
-                          (match uu___5 with
-                           | FStar_Pervasives_Native.Some g' ->
-                               let uu___6 =
-                                 FStar_TypeChecker_Common.lcomp_of_comp
-                                   target_comp in
-                               let uu___7 =
-                                 let uu___8 =
-                                   FStar_TypeChecker_Env.conj_guard g_c g' in
-                                 FStar_TypeChecker_Env.conj_guard g1 uu___8 in
-                               (e1, uu___6, uu___7)
-                           | uu___6 ->
-                               if allow_ghost
-                               then
-                                 let uu___7 =
-                                   FStar_TypeChecker_Err.expected_ghost_expression
-                                     e1 c2 msg in
-                                 FStar_Errors.raise_error uu___7
-                                   e1.FStar_Syntax_Syntax.pos
-                               else
-                                 (let uu___8 =
-                                    FStar_TypeChecker_Err.expected_pure_expression
-                                      e1 c2 msg in
-                                  FStar_Errors.raise_error uu___8
-                                    e1.FStar_Syntax_Syntax.pos))))
-and (tc_tot_or_gtot_term' :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      Prims.string ->
-        (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-          FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun msg -> tc_tot_or_gtot_term_maybe_solve_deferred env e msg true
-and (tc_tot_or_gtot_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-        FStar_TypeChecker_Env.guard_t))
-  = fun env -> fun e -> tc_tot_or_gtot_term' env e ""
-and (tc_check_tot_or_gtot_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        Prims.string ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun t ->
-        fun msg ->
-          let env1 = FStar_TypeChecker_Env.set_expected_typ env t in
-          tc_tot_or_gtot_term' env1 e msg
-and (tc_trivial_guard :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp))
-  =
-  fun env ->
-    fun t ->
-      let uu___ = tc_tot_or_gtot_term env t in
-      match uu___ with
-      | (t1, c, g) ->
-          (FStar_TypeChecker_Rel.force_trivial_guard env g; (t1, c))
-and (tc_attributes :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term Prims.list ->
-      FStar_Syntax_Syntax.term Prims.list)
-  =
-  fun env ->
-    fun attrs ->
-      FStar_Compiler_List.map
-        (fun attr ->
-           let uu___ = tc_trivial_guard env attr in
-           FStar_Pervasives_Native.fst uu___) attrs
-let (tc_check_trivial_guard :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun t ->
-      fun k ->
-        let uu___ = tc_check_tot_or_gtot_term env t k "" in
-        match uu___ with
-        | (t1, uu___1, g) ->
-            (FStar_TypeChecker_Rel.force_trivial_guard env g; t1)
-let (typeof_tot_or_gtot_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      Prims.bool ->
-        (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.typ *
-          FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun must_tot ->
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar
-             (FStar_TypeChecker_Env.debug env)
-             (FStar_Options.Other "RelCheck") in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.term_to_string e in
-           FStar_Compiler_Util.print1 "Checking term %s\n" uu___2
-         else ());
-        (let env1 =
-           {
-             FStar_TypeChecker_Env.solver =
-               (env.FStar_TypeChecker_Env.solver);
-             FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-             FStar_TypeChecker_Env.curmodule =
-               (env.FStar_TypeChecker_Env.curmodule);
-             FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-             FStar_TypeChecker_Env.gamma_sig =
-               (env.FStar_TypeChecker_Env.gamma_sig);
-             FStar_TypeChecker_Env.gamma_cache =
-               (env.FStar_TypeChecker_Env.gamma_cache);
-             FStar_TypeChecker_Env.modules =
-               (env.FStar_TypeChecker_Env.modules);
-             FStar_TypeChecker_Env.expected_typ =
-               (env.FStar_TypeChecker_Env.expected_typ);
-             FStar_TypeChecker_Env.sigtab =
-               (env.FStar_TypeChecker_Env.sigtab);
-             FStar_TypeChecker_Env.attrtab =
-               (env.FStar_TypeChecker_Env.attrtab);
-             FStar_TypeChecker_Env.instantiate_imp =
-               (env.FStar_TypeChecker_Env.instantiate_imp);
-             FStar_TypeChecker_Env.effects =
-               (env.FStar_TypeChecker_Env.effects);
-             FStar_TypeChecker_Env.generalize =
-               (env.FStar_TypeChecker_Env.generalize);
-             FStar_TypeChecker_Env.letrecs = [];
-             FStar_TypeChecker_Env.top_level = false;
-             FStar_TypeChecker_Env.check_uvars =
-               (env.FStar_TypeChecker_Env.check_uvars);
-             FStar_TypeChecker_Env.use_eq_strict =
-               (env.FStar_TypeChecker_Env.use_eq_strict);
-             FStar_TypeChecker_Env.is_iface =
-               (env.FStar_TypeChecker_Env.is_iface);
-             FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-             FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-             FStar_TypeChecker_Env.lax_universes =
-               (env.FStar_TypeChecker_Env.lax_universes);
-             FStar_TypeChecker_Env.phase1 =
-               (env.FStar_TypeChecker_Env.phase1);
-             FStar_TypeChecker_Env.failhard =
-               (env.FStar_TypeChecker_Env.failhard);
-             FStar_TypeChecker_Env.nosynth =
-               (env.FStar_TypeChecker_Env.nosynth);
-             FStar_TypeChecker_Env.uvar_subtyping =
-               (env.FStar_TypeChecker_Env.uvar_subtyping);
-             FStar_TypeChecker_Env.tc_term =
-               (env.FStar_TypeChecker_Env.tc_term);
-             FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-               (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-             FStar_TypeChecker_Env.universe_of =
-               (env.FStar_TypeChecker_Env.universe_of);
-             FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-               (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-             FStar_TypeChecker_Env.teq_nosmt_force =
-               (env.FStar_TypeChecker_Env.teq_nosmt_force);
-             FStar_TypeChecker_Env.subtype_nosmt_force =
-               (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-             FStar_TypeChecker_Env.qtbl_name_and_index =
-               (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-             FStar_TypeChecker_Env.normalized_eff_names =
-               (env.FStar_TypeChecker_Env.normalized_eff_names);
-             FStar_TypeChecker_Env.fv_delta_depths =
-               (env.FStar_TypeChecker_Env.fv_delta_depths);
-             FStar_TypeChecker_Env.proof_ns =
-               (env.FStar_TypeChecker_Env.proof_ns);
-             FStar_TypeChecker_Env.synth_hook =
-               (env.FStar_TypeChecker_Env.synth_hook);
-             FStar_TypeChecker_Env.try_solve_implicits_hook =
-               (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-             FStar_TypeChecker_Env.splice =
-               (env.FStar_TypeChecker_Env.splice);
-             FStar_TypeChecker_Env.mpreprocess =
-               (env.FStar_TypeChecker_Env.mpreprocess);
-             FStar_TypeChecker_Env.postprocess =
-               (env.FStar_TypeChecker_Env.postprocess);
-             FStar_TypeChecker_Env.identifier_info =
-               (env.FStar_TypeChecker_Env.identifier_info);
-             FStar_TypeChecker_Env.tc_hooks =
-               (env.FStar_TypeChecker_Env.tc_hooks);
-             FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-             FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-             FStar_TypeChecker_Env.strict_args_tab =
-               (env.FStar_TypeChecker_Env.strict_args_tab);
-             FStar_TypeChecker_Env.erasable_types_tab =
-               (env.FStar_TypeChecker_Env.erasable_types_tab);
-             FStar_TypeChecker_Env.enable_defer_to_tac =
-               (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-             FStar_TypeChecker_Env.unif_allow_ref_guards =
-               (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-             FStar_TypeChecker_Env.erase_erasable_args =
-               (env.FStar_TypeChecker_Env.erase_erasable_args);
-             FStar_TypeChecker_Env.core_check =
-               (env.FStar_TypeChecker_Env.core_check)
-           } in
-         let uu___1 =
-           try
-             (fun uu___2 -> match () with | () -> tc_tot_or_gtot_term env1 e)
-               ()
-           with
-           | FStar_Errors.Error (e1, msg, uu___3, ctx) ->
-               let uu___4 =
-                 let uu___5 =
-                   let uu___6 = FStar_TypeChecker_Env.get_range env1 in
-                   (e1, msg, uu___6, ctx) in
-                 FStar_Errors.Error uu___5 in
-               FStar_Compiler_Effect.raise uu___4 in
-         match uu___1 with
-         | (t, c, g) ->
-             if must_tot
-             then
-               let c1 =
-                 FStar_TypeChecker_Normalize.maybe_ghost_to_pure_lcomp env1 c in
-               let uu___2 = FStar_TypeChecker_Common.is_total_lcomp c1 in
-               (if uu___2
-                then (t, (c1.FStar_TypeChecker_Common.res_typ), g)
-                else
-                  (let uu___4 =
-                     let uu___5 =
-                       let uu___6 = FStar_Syntax_Print.term_to_string e in
-                       FStar_Compiler_Util.format1
-                         "Implicit argument: Expected a total term; got a ghost term: %s"
-                         uu___6 in
-                     (FStar_Errors.Fatal_UnexpectedImplictArgument, uu___5) in
-                   let uu___5 = FStar_TypeChecker_Env.get_range env1 in
-                   FStar_Errors.raise_error uu___4 uu___5))
-             else (t, (c.FStar_TypeChecker_Common.res_typ), g))
-let level_of_type_fail :
-  'uuuuu .
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term -> Prims.string -> 'uuuuu
-  =
-  fun env ->
-    fun e ->
-      fun t ->
-        let uu___ =
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.term_to_string e in
-            FStar_Compiler_Util.format2
-              "Expected a term of type 'Type'; got %s : %s" uu___2 t in
-          (FStar_Errors.Fatal_UnexpectedTermType, uu___1) in
-        let uu___1 = FStar_TypeChecker_Env.get_range env in
-        FStar_Errors.raise_error uu___ uu___1
-let (level_of_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.universe)
-  =
-  fun env ->
-    fun e ->
-      fun t ->
-        let rec aux retry t1 =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Util.unrefine t1 in
-            uu___1.FStar_Syntax_Syntax.n in
-          match uu___ with
-          | FStar_Syntax_Syntax.Tm_type u -> u
-          | uu___1 ->
-              if retry
-              then
-                let t2 =
-                  FStar_TypeChecker_Normalize.normalize
-                    [FStar_TypeChecker_Env.UnfoldUntil
-                       FStar_Syntax_Syntax.delta_constant] env t1 in
-                aux false t2
-              else
-                (let uu___3 = FStar_Syntax_Util.type_u () in
-                 match uu___3 with
-                 | (t_u, u) ->
-                     let env1 =
-                       {
-                         FStar_TypeChecker_Env.solver =
-                           (env.FStar_TypeChecker_Env.solver);
-                         FStar_TypeChecker_Env.range =
-                           (env.FStar_TypeChecker_Env.range);
-                         FStar_TypeChecker_Env.curmodule =
-                           (env.FStar_TypeChecker_Env.curmodule);
-                         FStar_TypeChecker_Env.gamma =
-                           (env.FStar_TypeChecker_Env.gamma);
-                         FStar_TypeChecker_Env.gamma_sig =
-                           (env.FStar_TypeChecker_Env.gamma_sig);
-                         FStar_TypeChecker_Env.gamma_cache =
-                           (env.FStar_TypeChecker_Env.gamma_cache);
-                         FStar_TypeChecker_Env.modules =
-                           (env.FStar_TypeChecker_Env.modules);
-                         FStar_TypeChecker_Env.expected_typ =
-                           (env.FStar_TypeChecker_Env.expected_typ);
-                         FStar_TypeChecker_Env.sigtab =
-                           (env.FStar_TypeChecker_Env.sigtab);
-                         FStar_TypeChecker_Env.attrtab =
-                           (env.FStar_TypeChecker_Env.attrtab);
-                         FStar_TypeChecker_Env.instantiate_imp =
-                           (env.FStar_TypeChecker_Env.instantiate_imp);
-                         FStar_TypeChecker_Env.effects =
-                           (env.FStar_TypeChecker_Env.effects);
-                         FStar_TypeChecker_Env.generalize =
-                           (env.FStar_TypeChecker_Env.generalize);
-                         FStar_TypeChecker_Env.letrecs =
-                           (env.FStar_TypeChecker_Env.letrecs);
-                         FStar_TypeChecker_Env.top_level =
-                           (env.FStar_TypeChecker_Env.top_level);
-                         FStar_TypeChecker_Env.check_uvars =
-                           (env.FStar_TypeChecker_Env.check_uvars);
-                         FStar_TypeChecker_Env.use_eq_strict =
-                           (env.FStar_TypeChecker_Env.use_eq_strict);
-                         FStar_TypeChecker_Env.is_iface =
-                           (env.FStar_TypeChecker_Env.is_iface);
-                         FStar_TypeChecker_Env.admit =
-                           (env.FStar_TypeChecker_Env.admit);
-                         FStar_TypeChecker_Env.lax = true;
-                         FStar_TypeChecker_Env.lax_universes =
-                           (env.FStar_TypeChecker_Env.lax_universes);
-                         FStar_TypeChecker_Env.phase1 =
-                           (env.FStar_TypeChecker_Env.phase1);
-                         FStar_TypeChecker_Env.failhard =
-                           (env.FStar_TypeChecker_Env.failhard);
-                         FStar_TypeChecker_Env.nosynth =
-                           (env.FStar_TypeChecker_Env.nosynth);
-                         FStar_TypeChecker_Env.uvar_subtyping =
-                           (env.FStar_TypeChecker_Env.uvar_subtyping);
-                         FStar_TypeChecker_Env.tc_term =
-                           (env.FStar_TypeChecker_Env.tc_term);
-                         FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                           (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.universe_of =
-                           (env.FStar_TypeChecker_Env.universe_of);
-                         FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                           =
-                           (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.teq_nosmt_force =
-                           (env.FStar_TypeChecker_Env.teq_nosmt_force);
-                         FStar_TypeChecker_Env.subtype_nosmt_force =
-                           (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-                         FStar_TypeChecker_Env.qtbl_name_and_index =
-                           (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-                         FStar_TypeChecker_Env.normalized_eff_names =
-                           (env.FStar_TypeChecker_Env.normalized_eff_names);
-                         FStar_TypeChecker_Env.fv_delta_depths =
-                           (env.FStar_TypeChecker_Env.fv_delta_depths);
-                         FStar_TypeChecker_Env.proof_ns =
-                           (env.FStar_TypeChecker_Env.proof_ns);
-                         FStar_TypeChecker_Env.synth_hook =
-                           (env.FStar_TypeChecker_Env.synth_hook);
-                         FStar_TypeChecker_Env.try_solve_implicits_hook =
-                           (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                         FStar_TypeChecker_Env.splice =
-                           (env.FStar_TypeChecker_Env.splice);
-                         FStar_TypeChecker_Env.mpreprocess =
-                           (env.FStar_TypeChecker_Env.mpreprocess);
-                         FStar_TypeChecker_Env.postprocess =
-                           (env.FStar_TypeChecker_Env.postprocess);
-                         FStar_TypeChecker_Env.identifier_info =
-                           (env.FStar_TypeChecker_Env.identifier_info);
-                         FStar_TypeChecker_Env.tc_hooks =
-                           (env.FStar_TypeChecker_Env.tc_hooks);
-                         FStar_TypeChecker_Env.dsenv =
-                           (env.FStar_TypeChecker_Env.dsenv);
-                         FStar_TypeChecker_Env.nbe =
-                           (env.FStar_TypeChecker_Env.nbe);
-                         FStar_TypeChecker_Env.strict_args_tab =
-                           (env.FStar_TypeChecker_Env.strict_args_tab);
-                         FStar_TypeChecker_Env.erasable_types_tab =
-                           (env.FStar_TypeChecker_Env.erasable_types_tab);
-                         FStar_TypeChecker_Env.enable_defer_to_tac =
-                           (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-                         FStar_TypeChecker_Env.unif_allow_ref_guards =
-                           (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                         FStar_TypeChecker_Env.erase_erasable_args =
-                           (env.FStar_TypeChecker_Env.erase_erasable_args);
-                         FStar_TypeChecker_Env.core_check =
-                           (env.FStar_TypeChecker_Env.core_check)
-                       } in
-                     let g = FStar_TypeChecker_Rel.teq env1 t1 t_u in
-                     ((match g.FStar_TypeChecker_Common.guard_f with
-                       | FStar_TypeChecker_Common.NonTrivial f ->
-                           let uu___5 = FStar_Syntax_Print.term_to_string t1 in
-                           level_of_type_fail env1 e uu___5
-                       | uu___5 ->
-                           FStar_TypeChecker_Rel.force_trivial_guard env1 g);
-                      u)) in
-        aux true t
-let rec (apply_well_typed :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      FStar_Syntax_Syntax.args ->
-        FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t_hd ->
-      fun args ->
-        if (FStar_Compiler_List.length args) = Prims.int_zero
-        then FStar_Pervasives_Native.Some t_hd
-        else
-          (let uu___1 =
-             let uu___2 = FStar_TypeChecker_Normalize.unfold_whnf env t_hd in
-             uu___2.FStar_Syntax_Syntax.n in
-           match uu___1 with
-           | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-               let n_args = FStar_Compiler_List.length args in
-               let n_bs = FStar_Compiler_List.length bs in
-               let uu___2 =
-                 if n_args < n_bs
-                 then
-                   let uu___3 = FStar_Compiler_Util.first_N n_args bs in
-                   match uu___3 with
-                   | (bs1, rest) ->
-                       let t =
-                         FStar_Syntax_Syntax.mk
-                           (FStar_Syntax_Syntax.Tm_arrow (rest, c))
-                           t_hd.FStar_Syntax_Syntax.pos in
-                       let uu___4 =
-                         let uu___5 = FStar_Syntax_Syntax.mk_Total t in
-                         FStar_Syntax_Subst.open_comp bs1 uu___5 in
-                       (match uu___4 with
-                        | (bs2, c1) ->
-                            (bs2, args, (FStar_Syntax_Util.comp_result c1),
-                              []))
-                 else
-                   (let uu___4 = FStar_Syntax_Subst.open_comp bs c in
-                    match uu___4 with
-                    | (bs1, c1) ->
-                        let uu___5 = FStar_Compiler_List.splitAt n_bs args in
-                        (match uu___5 with
-                         | (args1, remaining_args) ->
-                             (bs1, args1, (FStar_Syntax_Util.comp_result c1),
-                               remaining_args))) in
-               (match uu___2 with
-                | (bs1, args1, t, remaining_args) ->
-                    let subst =
-                      FStar_Compiler_List.map2
-                        (fun b ->
-                           fun a ->
-                             FStar_Syntax_Syntax.NT
-                               ((b.FStar_Syntax_Syntax.binder_bv),
-                                 (FStar_Pervasives_Native.fst a))) bs1 args1 in
-                    let t1 = FStar_Syntax_Subst.subst subst t in
-                    apply_well_typed env t1 remaining_args)
-           | FStar_Syntax_Syntax.Tm_refine (x, uu___2) ->
-               apply_well_typed env x.FStar_Syntax_Syntax.sort args
-           | FStar_Syntax_Syntax.Tm_ascribed (t, uu___2, uu___3) ->
-               apply_well_typed env t args
-           | uu___2 -> FStar_Pervasives_Native.None)
-let rec (universe_of_aux :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-      FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun e ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress e in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_bvar uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string e in
-            Prims.op_Hat "TcTerm.universe_of:Impossible (bvar/unknown/lazy) "
-              uu___3 in
-          failwith uu___2
-      | FStar_Syntax_Syntax.Tm_unknown ->
-          let uu___1 =
-            let uu___2 = FStar_Syntax_Print.term_to_string e in
-            Prims.op_Hat "TcTerm.universe_of:Impossible (bvar/unknown/lazy) "
-              uu___2 in
-          failwith uu___1
-      | FStar_Syntax_Syntax.Tm_delayed uu___1 ->
-          let uu___2 =
-            let uu___3 = FStar_Syntax_Print.term_to_string e in
-            Prims.op_Hat "TcTerm.universe_of:Impossible (bvar/unknown/lazy) "
-              uu___3 in
-          failwith uu___2
-      | FStar_Syntax_Syntax.Tm_let uu___1 ->
-          let e1 = FStar_TypeChecker_Normalize.normalize [] env e in
-          universe_of_aux env e1
-      | FStar_Syntax_Syntax.Tm_abs (bs, t, uu___1) ->
-          level_of_type_fail env e "arrow type"
-      | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-          let uu___1 = FStar_Syntax_Util.ctx_uvar_typ u in
-          FStar_Syntax_Subst.subst' s uu___1
-      | FStar_Syntax_Syntax.Tm_meta (t, uu___1) -> universe_of_aux env t
-      | FStar_Syntax_Syntax.Tm_name n ->
-          let uu___1 = FStar_TypeChecker_Env.lookup_bv env n in
-          (match uu___1 with | (t, _rng) -> t)
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let uu___1 =
-            FStar_TypeChecker_Env.lookup_lid env
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___1 with | ((uu___2, t), uu___3) -> t)
-      | FStar_Syntax_Syntax.Tm_lazy i ->
-          let uu___1 = FStar_Syntax_Util.unfold_lazy i in
-          universe_of_aux env uu___1
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (uu___1, (FStar_Pervasives.Inl t, uu___2, uu___3), uu___4) -> t
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (uu___1, (FStar_Pervasives.Inr c, uu___2, uu___3), uu___4) ->
-          FStar_Syntax_Util.comp_result c
-      | FStar_Syntax_Syntax.Tm_type u ->
-          FStar_Syntax_Syntax.mk
-            (FStar_Syntax_Syntax.Tm_type (FStar_Syntax_Syntax.U_succ u))
-            e.FStar_Syntax_Syntax.pos
-      | FStar_Syntax_Syntax.Tm_quoted uu___1 -> FStar_Syntax_Util.ktype0
-      | FStar_Syntax_Syntax.Tm_constant sc ->
-          tc_constant env e.FStar_Syntax_Syntax.pos sc
-      | FStar_Syntax_Syntax.Tm_uinst
-          ({ FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_fvar fv;
-             FStar_Syntax_Syntax.pos = uu___1;
-             FStar_Syntax_Syntax.vars = uu___2;
-             FStar_Syntax_Syntax.hash_code = uu___3;_},
-           us)
-          ->
-          let uu___4 =
-            FStar_TypeChecker_Env.lookup_lid env
-              (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          (match uu___4 with
-           | ((us', t), uu___5) ->
-               (if
-                  (FStar_Compiler_List.length us) <>
-                    (FStar_Compiler_List.length us')
-                then
-                  (let uu___7 = FStar_TypeChecker_Env.get_range env in
-                   FStar_Errors.raise_error
-                     (FStar_Errors.Fatal_UnexpectedNumberOfUniverse,
-                       "Unexpected number of universe instantiations") uu___7)
-                else ();
-                FStar_Compiler_List.iter2
-                  (fun ul ->
-                     fun ur ->
-                       match (ul, ur) with
-                       | (FStar_Syntax_Syntax.U_unif u'', uu___8) ->
-                           FStar_Syntax_Unionfind.univ_change u'' ur
-                       | (FStar_Syntax_Syntax.U_name n1,
-                          FStar_Syntax_Syntax.U_name n2) when
-                           FStar_Ident.ident_equals n1 n2 -> ()
-                       | uu___8 ->
-                           let uu___9 =
-                             let uu___10 =
-                               let uu___11 =
-                                 FStar_Syntax_Print.fv_to_string fv in
-                               let uu___12 =
-                                 FStar_Syntax_Print.univ_to_string ul in
-                               let uu___13 =
-                                 FStar_Syntax_Print.univ_to_string ur in
-                               FStar_Compiler_Util.format3
-                                 "Incompatible universe application for %s, expected %s got %s\n"
-                                 uu___11 uu___12 uu___13 in
-                             (FStar_Errors.Fatal_IncompatibleUniverse,
-                               uu___10) in
-                           let uu___10 = FStar_TypeChecker_Env.get_range env in
-                           FStar_Errors.raise_error uu___9 uu___10) us' us;
-                t))
-      | FStar_Syntax_Syntax.Tm_uinst uu___1 ->
-          failwith "Impossible: Tm_uinst's head must be an fvar"
-      | FStar_Syntax_Syntax.Tm_refine (x, uu___1) ->
-          universe_of_aux env x.FStar_Syntax_Syntax.sort
-      | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-          let uu___1 = FStar_Syntax_Subst.open_comp bs c in
-          (match uu___1 with
-           | (bs1, c1) ->
-               let env1 = FStar_TypeChecker_Env.push_binders env bs1 in
-               let us =
-                 FStar_Compiler_List.map
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | { FStar_Syntax_Syntax.binder_bv = b;
-                          FStar_Syntax_Syntax.binder_qual = uu___3;
-                          FStar_Syntax_Syntax.binder_attrs = uu___4;_} ->
-                          let uu___5 =
-                            universe_of_aux env1 b.FStar_Syntax_Syntax.sort in
-                          level_of_type env1 b.FStar_Syntax_Syntax.sort
-                            uu___5) bs1 in
-               let u_res =
-                 let res = FStar_Syntax_Util.comp_result c1 in
-                 let uu___2 = universe_of_aux env1 res in
-                 level_of_type env1 res uu___2 in
-               let u_c =
-                 FStar_Compiler_Effect.op_Bar_Greater c1
-                   (FStar_TypeChecker_Util.universe_of_comp env1 u_res) in
-               let u =
-                 FStar_TypeChecker_Normalize.normalize_universe env1
-                   (FStar_Syntax_Syntax.U_max (u_c :: us)) in
-               FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-                 e.FStar_Syntax_Syntax.pos)
-      | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-          let rec type_of_head retry env1 hd1 args1 =
-            let hd2 = FStar_Syntax_Subst.compress hd1 in
-            match hd2.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Tm_unknown -> failwith "Impossible"
-            | FStar_Syntax_Syntax.Tm_bvar uu___1 -> failwith "Impossible"
-            | FStar_Syntax_Syntax.Tm_delayed uu___1 -> failwith "Impossible"
-            | FStar_Syntax_Syntax.Tm_fvar uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_name uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_uvar uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_uinst uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_ascribed uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_constant uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_meta uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_type uu___1 ->
-                let uu___2 = universe_of_aux env1 hd2 in (uu___2, args1)
-            | FStar_Syntax_Syntax.Tm_match
-                (uu___1, uu___2, b::uu___3, uu___4) ->
-                let uu___5 = FStar_Syntax_Subst.open_branch b in
-                (match uu___5 with
-                 | (pat, uu___6, tm) ->
-                     let bvs = FStar_Syntax_Syntax.pat_bvs pat in
-                     let uu___7 = FStar_Syntax_Util.head_and_args tm in
-                     (match uu___7 with
-                      | (hd3, args') ->
-                          let uu___8 =
-                            FStar_TypeChecker_Env.push_bvs env1 bvs in
-                          type_of_head retry uu___8 hd3
-                            (FStar_Compiler_List.op_At args' args1)))
-            | uu___1 when retry ->
-                let e1 =
-                  FStar_TypeChecker_Normalize.normalize
-                    [FStar_TypeChecker_Env.Beta;
-                    FStar_TypeChecker_Env.DoNotUnfoldPureLets] env1 e in
-                let uu___2 = FStar_Syntax_Util.head_and_args e1 in
-                (match uu___2 with
-                 | (hd3, args2) -> type_of_head false env1 hd3 args2)
-            | uu___1 ->
-                let uu___2 = FStar_TypeChecker_Env.clear_expected_typ env1 in
-                (match uu___2 with
-                 | (env2, uu___3) ->
-                     let env3 =
-                       {
-                         FStar_TypeChecker_Env.solver =
-                           (env2.FStar_TypeChecker_Env.solver);
-                         FStar_TypeChecker_Env.range =
-                           (env2.FStar_TypeChecker_Env.range);
-                         FStar_TypeChecker_Env.curmodule =
-                           (env2.FStar_TypeChecker_Env.curmodule);
-                         FStar_TypeChecker_Env.gamma =
-                           (env2.FStar_TypeChecker_Env.gamma);
-                         FStar_TypeChecker_Env.gamma_sig =
-                           (env2.FStar_TypeChecker_Env.gamma_sig);
-                         FStar_TypeChecker_Env.gamma_cache =
-                           (env2.FStar_TypeChecker_Env.gamma_cache);
-                         FStar_TypeChecker_Env.modules =
-                           (env2.FStar_TypeChecker_Env.modules);
-                         FStar_TypeChecker_Env.expected_typ =
-                           (env2.FStar_TypeChecker_Env.expected_typ);
-                         FStar_TypeChecker_Env.sigtab =
-                           (env2.FStar_TypeChecker_Env.sigtab);
-                         FStar_TypeChecker_Env.attrtab =
-                           (env2.FStar_TypeChecker_Env.attrtab);
-                         FStar_TypeChecker_Env.instantiate_imp =
-                           (env2.FStar_TypeChecker_Env.instantiate_imp);
-                         FStar_TypeChecker_Env.effects =
-                           (env2.FStar_TypeChecker_Env.effects);
-                         FStar_TypeChecker_Env.generalize =
-                           (env2.FStar_TypeChecker_Env.generalize);
-                         FStar_TypeChecker_Env.letrecs =
-                           (env2.FStar_TypeChecker_Env.letrecs);
-                         FStar_TypeChecker_Env.top_level = false;
-                         FStar_TypeChecker_Env.check_uvars =
-                           (env2.FStar_TypeChecker_Env.check_uvars);
-                         FStar_TypeChecker_Env.use_eq_strict =
-                           (env2.FStar_TypeChecker_Env.use_eq_strict);
-                         FStar_TypeChecker_Env.is_iface =
-                           (env2.FStar_TypeChecker_Env.is_iface);
-                         FStar_TypeChecker_Env.admit =
-                           (env2.FStar_TypeChecker_Env.admit);
-                         FStar_TypeChecker_Env.lax = true;
-                         FStar_TypeChecker_Env.lax_universes =
-                           (env2.FStar_TypeChecker_Env.lax_universes);
-                         FStar_TypeChecker_Env.phase1 =
-                           (env2.FStar_TypeChecker_Env.phase1);
-                         FStar_TypeChecker_Env.failhard =
-                           (env2.FStar_TypeChecker_Env.failhard);
-                         FStar_TypeChecker_Env.nosynth =
-                           (env2.FStar_TypeChecker_Env.nosynth);
-                         FStar_TypeChecker_Env.uvar_subtyping =
-                           (env2.FStar_TypeChecker_Env.uvar_subtyping);
-                         FStar_TypeChecker_Env.tc_term =
-                           (env2.FStar_TypeChecker_Env.tc_term);
-                         FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                           (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.universe_of =
-                           (env2.FStar_TypeChecker_Env.universe_of);
-                         FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term
-                           =
-                           (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-                         FStar_TypeChecker_Env.teq_nosmt_force =
-                           (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-                         FStar_TypeChecker_Env.subtype_nosmt_force =
-                           (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-                         FStar_TypeChecker_Env.qtbl_name_and_index =
-                           (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-                         FStar_TypeChecker_Env.normalized_eff_names =
-                           (env2.FStar_TypeChecker_Env.normalized_eff_names);
-                         FStar_TypeChecker_Env.fv_delta_depths =
-                           (env2.FStar_TypeChecker_Env.fv_delta_depths);
-                         FStar_TypeChecker_Env.proof_ns =
-                           (env2.FStar_TypeChecker_Env.proof_ns);
-                         FStar_TypeChecker_Env.synth_hook =
-                           (env2.FStar_TypeChecker_Env.synth_hook);
-                         FStar_TypeChecker_Env.try_solve_implicits_hook =
-                           (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-                         FStar_TypeChecker_Env.splice =
-                           (env2.FStar_TypeChecker_Env.splice);
-                         FStar_TypeChecker_Env.mpreprocess =
-                           (env2.FStar_TypeChecker_Env.mpreprocess);
-                         FStar_TypeChecker_Env.postprocess =
-                           (env2.FStar_TypeChecker_Env.postprocess);
-                         FStar_TypeChecker_Env.identifier_info =
-                           (env2.FStar_TypeChecker_Env.identifier_info);
-                         FStar_TypeChecker_Env.tc_hooks =
-                           (env2.FStar_TypeChecker_Env.tc_hooks);
-                         FStar_TypeChecker_Env.dsenv =
-                           (env2.FStar_TypeChecker_Env.dsenv);
-                         FStar_TypeChecker_Env.nbe =
-                           (env2.FStar_TypeChecker_Env.nbe);
-                         FStar_TypeChecker_Env.strict_args_tab =
-                           (env2.FStar_TypeChecker_Env.strict_args_tab);
-                         FStar_TypeChecker_Env.erasable_types_tab =
-                           (env2.FStar_TypeChecker_Env.erasable_types_tab);
-                         FStar_TypeChecker_Env.enable_defer_to_tac =
-                           (env2.FStar_TypeChecker_Env.enable_defer_to_tac);
-                         FStar_TypeChecker_Env.unif_allow_ref_guards =
-                           (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-                         FStar_TypeChecker_Env.erase_erasable_args =
-                           (env2.FStar_TypeChecker_Env.erase_erasable_args);
-                         FStar_TypeChecker_Env.core_check =
-                           (env2.FStar_TypeChecker_Env.core_check)
-                       } in
-                     ((let uu___5 =
-                         FStar_Compiler_Effect.op_Less_Bar
-                           (FStar_TypeChecker_Env.debug env3)
-                           (FStar_Options.Other "UniverseOf") in
-                       if uu___5
-                       then
-                         let uu___6 =
-                           let uu___7 = FStar_TypeChecker_Env.get_range env3 in
-                           FStar_Compiler_Range.string_of_range uu___7 in
-                         let uu___7 = FStar_Syntax_Print.term_to_string hd2 in
-                         FStar_Compiler_Util.print2
-                           "%s: About to type-check %s\n" uu___6 uu___7
-                       else ());
-                      (let uu___5 = tc_term env3 hd2 in
-                       match uu___5 with
-                       | (uu___6,
-                          { FStar_TypeChecker_Common.eff_name = uu___7;
-                            FStar_TypeChecker_Common.res_typ = t;
-                            FStar_TypeChecker_Common.cflags = uu___8;
-                            FStar_TypeChecker_Common.comp_thunk = uu___9;_},
-                          g) ->
-                           ((let uu___11 =
-                               FStar_TypeChecker_Rel.solve_deferred_constraints
-                                 env3 g in
-                             FStar_Compiler_Effect.op_Bar_Greater uu___11
-                               (fun uu___12 -> ()));
-                            (t, args1))))) in
-          let uu___1 = type_of_head true env hd args in
-          (match uu___1 with
-           | (t, args1) ->
-               let uu___2 = apply_well_typed env t args1 in
-               (match uu___2 with
-                | FStar_Pervasives_Native.Some t1 -> t1
-                | FStar_Pervasives_Native.None ->
-                    let uu___3 = FStar_Syntax_Print.term_to_string t in
-                    level_of_type_fail env e uu___3))
-      | FStar_Syntax_Syntax.Tm_match (uu___1, uu___2, b::uu___3, uu___4) ->
-          let uu___5 = FStar_Syntax_Subst.open_branch b in
-          (match uu___5 with
-           | (pat, uu___6, tm) ->
-               let bvs = FStar_Syntax_Syntax.pat_bvs pat in
-               let uu___7 = FStar_TypeChecker_Env.push_bvs env bvs in
-               universe_of_aux uu___7 tm)
-      | FStar_Syntax_Syntax.Tm_match (uu___1, uu___2, [], uu___3) ->
-          level_of_type_fail env e "empty match cases"
-let (universe_of :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.universe)
-  =
-  fun env ->
-    fun e ->
-      FStar_Errors.with_ctx "While attempting to compute a universe level"
-        (fun uu___ ->
-           (let uu___2 = FStar_TypeChecker_Env.debug env FStar_Options.High in
-            if uu___2
-            then
-              let uu___3 = FStar_Syntax_Print.term_to_string e in
-              FStar_Compiler_Util.print1
-                "Calling universe_of_aux with %s {\n" uu___3
-            else ());
-           FStar_TypeChecker_Env.def_check_closed_in_env
-             e.FStar_Syntax_Syntax.pos "universe_of entry" env e;
-           (let r = universe_of_aux env e in
-            (let uu___4 = FStar_TypeChecker_Env.debug env FStar_Options.High in
-             if uu___4
-             then
-               let uu___5 = FStar_Syntax_Print.term_to_string r in
-               FStar_Compiler_Util.print1
-                 "Got result from universe_of_aux = %s }\n" uu___5
-             else ());
-            level_of_type env e r))
-let (tc_tparams :
-  FStar_TypeChecker_Env.env_t ->
-    FStar_Syntax_Syntax.binders ->
-      (FStar_Syntax_Syntax.binders * FStar_TypeChecker_Env.env *
-        FStar_Syntax_Syntax.universes))
-  =
-  fun env0 ->
-    fun tps ->
-      let uu___ = tc_binders env0 tps in
-      match uu___ with
-      | (tps1, env, g, us) ->
-          (FStar_TypeChecker_Rel.force_trivial_guard env0 g; (tps1, env, us))
-let rec (__typeof_tot_or_gtot_term_fastpath :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      Prims.bool -> FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t ->
-      fun must_tot ->
-        let mk_tm_type u =
-          FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_type u)
-            t.FStar_Syntax_Syntax.pos in
-        let effect_ok k =
-          (Prims.op_Negation must_tot) ||
-            (FStar_TypeChecker_Normalize.non_info_norm env k) in
-        let t1 = FStar_Syntax_Subst.compress t in
-        match t1.FStar_Syntax_Syntax.n with
-        | FStar_Syntax_Syntax.Tm_delayed uu___ ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-              Prims.op_Hat "Impossible: " uu___2 in
-            failwith uu___1
-        | FStar_Syntax_Syntax.Tm_bvar uu___ ->
-            let uu___1 =
-              let uu___2 = FStar_Syntax_Print.term_to_string t1 in
-              Prims.op_Hat "Impossible: " uu___2 in
-            failwith uu___1
-        | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify) ->
-            FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reflect uu___)
-            -> FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Tm_name uu___ ->
-            let uu___1 = universe_of_aux env t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        | FStar_Syntax_Syntax.Tm_fvar uu___ ->
-            let uu___1 = universe_of_aux env t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        | FStar_Syntax_Syntax.Tm_uinst uu___ ->
-            let uu___1 = universe_of_aux env t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        | FStar_Syntax_Syntax.Tm_constant uu___ ->
-            let uu___1 = universe_of_aux env t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        | FStar_Syntax_Syntax.Tm_type uu___ ->
-            let uu___1 = universe_of_aux env t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        | FStar_Syntax_Syntax.Tm_arrow uu___ ->
-            let uu___1 = universe_of_aux env t1 in
-            FStar_Compiler_Effect.op_Bar_Greater uu___1
-              (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-        | FStar_Syntax_Syntax.Tm_lazy i ->
-            let uu___ = FStar_Syntax_Util.unfold_lazy i in
-            __typeof_tot_or_gtot_term_fastpath env uu___ must_tot
-        | FStar_Syntax_Syntax.Tm_abs
-            (bs, body, FStar_Pervasives_Native.Some
-             { FStar_Syntax_Syntax.residual_effect = eff;
-               FStar_Syntax_Syntax.residual_typ = tbody;
-               FStar_Syntax_Syntax.residual_flags = uu___;_})
-            ->
-            let mk_comp =
-              let uu___1 =
-                FStar_Ident.lid_equals eff FStar_Parser_Const.effect_Tot_lid in
-              if uu___1
-              then FStar_Pervasives_Native.Some FStar_Syntax_Syntax.mk_Total
-              else
-                (let uu___3 =
-                   FStar_Ident.lid_equals eff
-                     FStar_Parser_Const.effect_GTot_lid in
-                 if uu___3
-                 then
-                   FStar_Pervasives_Native.Some FStar_Syntax_Syntax.mk_GTotal
-                 else FStar_Pervasives_Native.None) in
-            FStar_Compiler_Util.bind_opt mk_comp
-              (fun f ->
-                 let tbody1 =
-                   match tbody with
-                   | FStar_Pervasives_Native.Some uu___1 -> tbody
-                   | FStar_Pervasives_Native.None ->
-                       let uu___1 = FStar_Syntax_Subst.open_term bs body in
-                       (match uu___1 with
-                        | (bs1, body1) ->
-                            let uu___2 =
-                              let uu___3 =
-                                FStar_TypeChecker_Env.push_binders env bs1 in
-                              __typeof_tot_or_gtot_term_fastpath uu___3 body1
-                                false in
-                            FStar_Compiler_Util.map_opt uu___2
-                              (FStar_Syntax_Subst.close bs1)) in
-                 FStar_Compiler_Util.bind_opt tbody1
-                   (fun tbody2 ->
-                      let uu___1 = FStar_Syntax_Subst.open_term bs tbody2 in
-                      match uu___1 with
-                      | (bs1, tbody3) ->
-                          let u =
-                            let uu___2 =
-                              FStar_TypeChecker_Env.push_binders env bs1 in
-                            universe_of uu___2 tbody3 in
-                          let uu___2 =
-                            let uu___3 = f tbody3 in
-                            FStar_Syntax_Util.arrow bs1 uu___3 in
-                          FStar_Pervasives_Native.Some uu___2))
-        | FStar_Syntax_Syntax.Tm_abs uu___ -> FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Tm_refine (x, uu___) ->
-            __typeof_tot_or_gtot_term_fastpath env x.FStar_Syntax_Syntax.sort
-              must_tot
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_range_of);
-               FStar_Syntax_Syntax.pos = uu___;
-               FStar_Syntax_Syntax.vars = uu___1;
-               FStar_Syntax_Syntax.hash_code = uu___2;_},
-             a::hd::rest)
-            ->
-            let rest1 = hd :: rest in
-            let uu___3 = FStar_Syntax_Util.head_and_args t1 in
-            (match uu___3 with
-             | (unary_op, uu___4) ->
-                 let head =
-                   let uu___5 =
-                     FStar_Compiler_Range.union_ranges
-                       unary_op.FStar_Syntax_Syntax.pos
-                       (FStar_Pervasives_Native.fst a).FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (unary_op, [a])) uu___5 in
-                 let t2 =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (head, rest1))
-                     t1.FStar_Syntax_Syntax.pos in
-                 __typeof_tot_or_gtot_term_fastpath env t2 must_tot)
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_set_range_of);
-               FStar_Syntax_Syntax.pos = uu___;
-               FStar_Syntax_Syntax.vars = uu___1;
-               FStar_Syntax_Syntax.hash_code = uu___2;_},
-             a1::a2::hd::rest)
-            ->
-            let rest1 = hd :: rest in
-            let uu___3 = FStar_Syntax_Util.head_and_args t1 in
-            (match uu___3 with
-             | (unary_op, uu___4) ->
-                 let head =
-                   let uu___5 =
-                     FStar_Compiler_Range.union_ranges
-                       unary_op.FStar_Syntax_Syntax.pos
-                       (FStar_Pervasives_Native.fst a1).FStar_Syntax_Syntax.pos in
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (unary_op, [a1; a2])) uu___5 in
-                 let t2 =
-                   FStar_Syntax_Syntax.mk
-                     (FStar_Syntax_Syntax.Tm_app (head, rest1))
-                     t1.FStar_Syntax_Syntax.pos in
-                 __typeof_tot_or_gtot_term_fastpath env t2 must_tot)
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_range_of);
-               FStar_Syntax_Syntax.pos = uu___;
-               FStar_Syntax_Syntax.vars = uu___1;
-               FStar_Syntax_Syntax.hash_code = uu___2;_},
-             uu___3::[])
-            -> FStar_Pervasives_Native.Some FStar_Syntax_Syntax.t_range
-        | FStar_Syntax_Syntax.Tm_app
-            ({
-               FStar_Syntax_Syntax.n = FStar_Syntax_Syntax.Tm_constant
-                 (FStar_Const.Const_set_range_of);
-               FStar_Syntax_Syntax.pos = uu___;
-               FStar_Syntax_Syntax.vars = uu___1;
-               FStar_Syntax_Syntax.hash_code = uu___2;_},
-             (t2, uu___3)::uu___4::[])
-            -> __typeof_tot_or_gtot_term_fastpath env t2 must_tot
-        | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-            let t_hd = __typeof_tot_or_gtot_term_fastpath env hd must_tot in
-            FStar_Compiler_Util.bind_opt t_hd
-              (fun t_hd1 ->
-                 let uu___ = apply_well_typed env t_hd1 args in
-                 FStar_Compiler_Util.bind_opt uu___
-                   (fun t2 ->
-                      let uu___1 =
-                        (effect_ok t2) ||
-                          (FStar_Compiler_List.for_all
-                             (fun uu___2 ->
-                                match uu___2 with
-                                | (a, uu___3) ->
-                                    let uu___4 =
-                                      __typeof_tot_or_gtot_term_fastpath env
-                                        a must_tot in
-                                    FStar_Compiler_Effect.op_Bar_Greater
-                                      uu___4 FStar_Compiler_Util.is_some)
-                             args) in
-                      if uu___1
-                      then FStar_Pervasives_Native.Some t2
-                      else FStar_Pervasives_Native.None))
-        | FStar_Syntax_Syntax.Tm_ascribed
-            (t2, (FStar_Pervasives.Inl k, uu___, uu___1), uu___2) ->
-            let uu___3 = effect_ok k in
-            if uu___3
-            then FStar_Pervasives_Native.Some k
-            else __typeof_tot_or_gtot_term_fastpath env t2 must_tot
-        | FStar_Syntax_Syntax.Tm_ascribed
-            (uu___, (FStar_Pervasives.Inr c, uu___1, uu___2), uu___3) ->
-            let k = FStar_Syntax_Util.comp_result c in
-            let uu___4 =
-              ((Prims.op_Negation must_tot) ||
-                 (let uu___5 =
-                    let uu___6 =
-                      FStar_Compiler_Effect.op_Bar_Greater c
-                        FStar_Syntax_Util.comp_effect_name in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___6
-                      (FStar_TypeChecker_Env.norm_eff_name env) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___5
-                    (FStar_Ident.lid_equals
-                       FStar_Parser_Const.effect_PURE_lid)))
-                || (FStar_TypeChecker_Normalize.non_info_norm env k) in
-            if uu___4
-            then FStar_Pervasives_Native.Some k
-            else FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Tm_uvar (u, s) ->
-            if Prims.op_Negation must_tot
-            then
-              let uu___ =
-                let uu___1 = FStar_Syntax_Util.ctx_uvar_typ u in
-                FStar_Syntax_Subst.subst' s uu___1 in
-              FStar_Pervasives_Native.Some uu___
-            else FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Tm_quoted (tm, qi) ->
-            if Prims.op_Negation must_tot
-            then FStar_Pervasives_Native.Some FStar_Syntax_Syntax.t_term
-            else FStar_Pervasives_Native.None
-        | FStar_Syntax_Syntax.Tm_meta (t2, uu___) ->
-            __typeof_tot_or_gtot_term_fastpath env t2 must_tot
-        | FStar_Syntax_Syntax.Tm_match
-            (uu___, uu___1, uu___2, FStar_Pervasives_Native.Some rc) ->
-            rc.FStar_Syntax_Syntax.residual_typ
-        | FStar_Syntax_Syntax.Tm_match uu___ ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.tag_of_term t1 in
-                Prims.op_Hat uu___3 ")" in
-              Prims.op_Hat "Impossible! (" uu___2 in
-            failwith uu___1
-        | FStar_Syntax_Syntax.Tm_let uu___ ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.tag_of_term t1 in
-                Prims.op_Hat uu___3 ")" in
-              Prims.op_Hat "Impossible! (" uu___2 in
-            failwith uu___1
-        | FStar_Syntax_Syntax.Tm_unknown ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Print.tag_of_term t1 in
-                Prims.op_Hat uu___2 ")" in
-              Prims.op_Hat "Impossible! (" uu___1 in
-            failwith uu___
-        | uu___ ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.tag_of_term t1 in
-                Prims.op_Hat uu___3 ")" in
-              Prims.op_Hat "Impossible! (" uu___2 in
-            failwith uu___1
-let (typeof_tot_or_gtot_term_fastpath :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Env.must_tot ->
-        FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t ->
-      fun must_tot ->
-        FStar_TypeChecker_Env.def_check_closed_in_env
-          t.FStar_Syntax_Syntax.pos "fastpath" env t;
-        FStar_Errors.with_ctx "In a call to typeof_tot_or_gtot_term_fastpath"
-          (fun uu___1 -> __typeof_tot_or_gtot_term_fastpath env t must_tot)
-let rec (effectof_tot_or_gtot_term_fastpath :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Ident.lident FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun t ->
-      let uu___ =
-        let uu___1 = FStar_Syntax_Subst.compress t in
-        uu___1.FStar_Syntax_Syntax.n in
-      match uu___ with
-      | FStar_Syntax_Syntax.Tm_delayed uu___1 -> failwith "Impossible!"
-      | FStar_Syntax_Syntax.Tm_bvar uu___1 -> failwith "Impossible!"
-      | FStar_Syntax_Syntax.Tm_name uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_lazy uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_fvar uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_uinst uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_constant uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_type uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_abs uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_refine uu___1 ->
-          FStar_Compiler_Effect.op_Bar_Greater
-            FStar_Parser_Const.effect_PURE_lid
-            (fun uu___2 -> FStar_Pervasives_Native.Some uu___2)
-      | FStar_Syntax_Syntax.Tm_app (hd, args) ->
-          let join_effects eff1 eff2 =
-            let uu___1 =
-              let uu___2 = FStar_TypeChecker_Env.norm_eff_name env eff1 in
-              let uu___3 = FStar_TypeChecker_Env.norm_eff_name env eff2 in
-              (uu___2, uu___3) in
-            match uu___1 with
-            | (eff11, eff21) ->
-                let uu___2 =
-                  (FStar_Parser_Const.effect_PURE_lid,
-                    FStar_Parser_Const.effect_GHOST_lid) in
-                (match uu___2 with
-                 | (pure, ghost) ->
-                     let uu___3 =
-                       (FStar_Ident.lid_equals eff11 pure) &&
-                         (FStar_Ident.lid_equals eff21 pure) in
-                     if uu___3
-                     then FStar_Pervasives_Native.Some pure
-                     else
-                       (let uu___5 =
-                          ((FStar_Ident.lid_equals eff11 ghost) ||
-                             (FStar_Ident.lid_equals eff11 pure))
-                            &&
-                            ((FStar_Ident.lid_equals eff21 ghost) ||
-                               (FStar_Ident.lid_equals eff21 pure)) in
-                        if uu___5
-                        then FStar_Pervasives_Native.Some ghost
-                        else FStar_Pervasives_Native.None)) in
-          let uu___1 = effectof_tot_or_gtot_term_fastpath env hd in
-          FStar_Compiler_Util.bind_opt uu___1
-            (fun eff_hd ->
-               let uu___2 =
-                 FStar_Compiler_List.fold_left
-                   (fun eff_opt ->
-                      fun arg ->
-                        FStar_Compiler_Util.bind_opt eff_opt
-                          (fun eff ->
-                             let uu___3 =
-                               effectof_tot_or_gtot_term_fastpath env
-                                 (FStar_Pervasives_Native.fst arg) in
-                             FStar_Compiler_Util.bind_opt uu___3
-                               (join_effects eff)))
-                   (FStar_Pervasives_Native.Some eff_hd) args in
-               FStar_Compiler_Util.bind_opt uu___2
-                 (fun eff_hd_and_args ->
-                    let uu___3 = typeof_tot_or_gtot_term_fastpath env hd true in
-                    FStar_Compiler_Util.bind_opt uu___3
-                      (fun t_hd ->
-                         let rec maybe_arrow t1 =
-                           let t2 =
-                             FStar_TypeChecker_Normalize.unfold_whnf env t1 in
-                           match t2.FStar_Syntax_Syntax.n with
-                           | FStar_Syntax_Syntax.Tm_arrow uu___4 -> t2
-                           | FStar_Syntax_Syntax.Tm_refine (x, uu___4) ->
-                               maybe_arrow x.FStar_Syntax_Syntax.sort
-                           | FStar_Syntax_Syntax.Tm_ascribed
-                               (t3, uu___4, uu___5) -> maybe_arrow t3
-                           | uu___4 -> t2 in
-                         let uu___4 =
-                           let uu___5 = maybe_arrow t_hd in
-                           uu___5.FStar_Syntax_Syntax.n in
-                         match uu___4 with
-                         | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                             let eff_app =
-                               if
-                                 (FStar_Compiler_List.length args) <
-                                   (FStar_Compiler_List.length bs)
-                               then FStar_Parser_Const.effect_PURE_lid
-                               else FStar_Syntax_Util.comp_effect_name c in
-                             join_effects eff_hd_and_args eff_app
-                         | uu___5 -> FStar_Pervasives_Native.None)))
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (t1, (FStar_Pervasives.Inl uu___1, uu___2, uu___3), uu___4) ->
-          effectof_tot_or_gtot_term_fastpath env t1
-      | FStar_Syntax_Syntax.Tm_ascribed
-          (uu___1, (FStar_Pervasives.Inr c, uu___2, uu___3), uu___4) ->
-          let c_eff =
-            let uu___5 =
-              FStar_Compiler_Effect.op_Bar_Greater c
-                FStar_Syntax_Util.comp_effect_name in
-            FStar_Compiler_Effect.op_Bar_Greater uu___5
-              (FStar_TypeChecker_Env.norm_eff_name env) in
-          let uu___5 =
-            (FStar_Ident.lid_equals c_eff FStar_Parser_Const.effect_PURE_lid)
-              ||
-              (FStar_Ident.lid_equals c_eff
-                 FStar_Parser_Const.effect_GHOST_lid) in
-          if uu___5
-          then FStar_Pervasives_Native.Some c_eff
-          else FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_uvar uu___1 -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_quoted uu___1 -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_meta (t1, uu___1) ->
-          effectof_tot_or_gtot_term_fastpath env t1
-      | FStar_Syntax_Syntax.Tm_match uu___1 -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_let uu___1 -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_unknown -> FStar_Pervasives_Native.None
-      | FStar_Syntax_Syntax.Tm_uinst uu___1 -> FStar_Pervasives_Native.None
-      | uu___1 -> FStar_Pervasives_Native.None
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_TypeChecker_Util.ml b/src/ocaml-output/FStar_TypeChecker_Util.ml
deleted file mode 100644
index 5e7d5c9712a..00000000000
--- a/src/ocaml-output/FStar_TypeChecker_Util.ml
+++ /dev/null
@@ -1,8596 +0,0 @@
-open Prims
-type lcomp_with_binder =
-  (FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option *
-    FStar_TypeChecker_Common.lcomp)
-let (report : FStar_TypeChecker_Env.env -> Prims.string Prims.list -> unit) =
-  fun env ->
-    fun errs ->
-      let uu___ = FStar_TypeChecker_Env.get_range env in
-      let uu___1 = FStar_TypeChecker_Err.failed_to_prove_specification errs in
-      FStar_Errors.log_issue uu___ uu___1
-let (new_implicit_var :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      FStar_TypeChecker_Env.env ->
-        FStar_Syntax_Syntax.typ ->
-          (FStar_Syntax_Syntax.term * (FStar_Syntax_Syntax.ctx_uvar *
-            FStar_Compiler_Range.range) Prims.list *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun reason ->
-    fun r ->
-      fun env ->
-        fun k ->
-          FStar_TypeChecker_Env.new_implicit_var_aux reason r env k
-            FStar_Syntax_Syntax.Strict FStar_Pervasives_Native.None
-let (close_guard_implicits :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_TypeChecker_Env.guard_t -> FStar_TypeChecker_Env.guard_t)
-  =
-  fun env ->
-    fun solve_deferred ->
-      fun xs ->
-        fun g ->
-          let uu___ = (FStar_Options.eager_subtyping ()) || solve_deferred in
-          if uu___
-          then
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater
-                g.FStar_TypeChecker_Common.deferred
-                (FStar_Compiler_List.partition
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (uu___3, uu___4, p) ->
-                          FStar_TypeChecker_Rel.flex_prob_closing env xs p)) in
-            match uu___1 with
-            | (solve_now, defer) ->
-                ((let uu___3 =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_TypeChecker_Env.debug env)
-                      (FStar_Options.Other "Rel") in
-                  if uu___3
-                  then
-                    (FStar_Compiler_Util.print_string
-                       "SOLVE BEFORE CLOSING:\n";
-                     FStar_Compiler_List.iter
-                       (fun uu___6 ->
-                          match uu___6 with
-                          | (uu___7, s, p) ->
-                              let uu___8 =
-                                FStar_TypeChecker_Rel.prob_to_string env p in
-                              FStar_Compiler_Util.print2 "%s: %s\n" s uu___8)
-                       solve_now;
-                     FStar_Compiler_Util.print_string
-                       " ...DEFERRED THE REST:\n";
-                     FStar_Compiler_List.iter
-                       (fun uu___8 ->
-                          match uu___8 with
-                          | (uu___9, s, p) ->
-                              let uu___10 =
-                                FStar_TypeChecker_Rel.prob_to_string env p in
-                              FStar_Compiler_Util.print2 "%s: %s\n" s uu___10)
-                       defer;
-                     FStar_Compiler_Util.print_string "END\n")
-                  else ());
-                 (let g1 =
-                    FStar_TypeChecker_Rel.solve_non_tactic_deferred_constraints
-                      false env
-                      {
-                        FStar_TypeChecker_Common.guard_f =
-                          (g.FStar_TypeChecker_Common.guard_f);
-                        FStar_TypeChecker_Common.deferred_to_tac =
-                          (g.FStar_TypeChecker_Common.deferred_to_tac);
-                        FStar_TypeChecker_Common.deferred = solve_now;
-                        FStar_TypeChecker_Common.univ_ineqs =
-                          (g.FStar_TypeChecker_Common.univ_ineqs);
-                        FStar_TypeChecker_Common.implicits =
-                          (g.FStar_TypeChecker_Common.implicits)
-                      } in
-                  let g2 =
-                    {
-                      FStar_TypeChecker_Common.guard_f =
-                        (g1.FStar_TypeChecker_Common.guard_f);
-                      FStar_TypeChecker_Common.deferred_to_tac =
-                        (g1.FStar_TypeChecker_Common.deferred_to_tac);
-                      FStar_TypeChecker_Common.deferred = defer;
-                      FStar_TypeChecker_Common.univ_ineqs =
-                        (g1.FStar_TypeChecker_Common.univ_ineqs);
-                      FStar_TypeChecker_Common.implicits =
-                        (g1.FStar_TypeChecker_Common.implicits)
-                    } in
-                  g2))
-          else g
-let (check_uvars :
-  FStar_Compiler_Range.range -> FStar_Syntax_Syntax.typ -> unit) =
-  fun r ->
-    fun t ->
-      let uvs = FStar_Syntax_Free.uvars t in
-      let uu___ =
-        let uu___1 = FStar_Compiler_Util.set_is_empty uvs in
-        Prims.op_Negation uu___1 in
-      if uu___
-      then
-        let us =
-          let uu___1 =
-            let uu___2 = FStar_Compiler_Util.set_elements uvs in
-            FStar_Compiler_List.map
-              (fun u ->
-                 FStar_Syntax_Print.uvar_to_string
-                   u.FStar_Syntax_Syntax.ctx_uvar_head) uu___2 in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            (FStar_String.concat ", ") in
-        (FStar_Options.push ();
-         FStar_Options.set_option "hide_uvar_nums" (FStar_Options.Bool false);
-         FStar_Options.set_option "print_implicits" (FStar_Options.Bool true);
-         (let uu___5 =
-            let uu___6 =
-              let uu___7 = FStar_Syntax_Print.term_to_string t in
-              FStar_Compiler_Util.format2
-                "Unconstrained unification variables %s in type signature %s; please add an annotation"
-                us uu___7 in
-            (FStar_Errors.Error_UncontrainedUnificationVar, uu___6) in
-          FStar_Errors.log_issue r uu___5);
-         FStar_Options.pop ())
-      else ()
-let (extract_let_rec_annotation :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.letbinding ->
-      (FStar_Syntax_Syntax.univ_names * FStar_Syntax_Syntax.typ *
-        FStar_Syntax_Syntax.term * Prims.bool))
-  =
-  fun env ->
-    fun uu___ ->
-      match uu___ with
-      | { FStar_Syntax_Syntax.lbname = lbname;
-          FStar_Syntax_Syntax.lbunivs = univ_vars;
-          FStar_Syntax_Syntax.lbtyp = t; FStar_Syntax_Syntax.lbeff = uu___1;
-          FStar_Syntax_Syntax.lbdef = e;
-          FStar_Syntax_Syntax.lbattrs = uu___2;
-          FStar_Syntax_Syntax.lbpos = uu___3;_} ->
-          let rng = FStar_Syntax_Syntax.range_of_lbname lbname in
-          let t1 = FStar_Syntax_Subst.compress t in
-          let uu___4 = FStar_Syntax_Subst.univ_var_opening univ_vars in
-          (match uu___4 with
-           | (u_subst, univ_vars1) ->
-               let e1 = FStar_Syntax_Subst.subst u_subst e in
-               let t2 = FStar_Syntax_Subst.subst u_subst t1 in
-               ((let uu___6 =
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (FStar_TypeChecker_Env.debug env)
-                     (FStar_Options.Other "Dec") in
-                 if uu___6
-                 then
-                   let uu___7 = FStar_Syntax_Print.term_to_string e1 in
-                   let uu___8 = FStar_Syntax_Print.term_to_string t2 in
-                   FStar_Compiler_Util.print2
-                     "extract_let_rec_annotation lbdef=%s; lbtyp=%s\n" uu___7
-                     uu___8
-                 else ());
-                (let env1 =
-                   FStar_TypeChecker_Env.push_univ_vars env univ_vars1 in
-                 let un_arrow t3 =
-                   let uu___6 =
-                     let uu___7 = FStar_Syntax_Subst.compress t3 in
-                     uu___7.FStar_Syntax_Syntax.n in
-                   match uu___6 with
-                   | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                       FStar_Syntax_Subst.open_comp bs c
-                   | uu___7 ->
-                       FStar_Errors.raise_error
-                         (FStar_Errors.Fatal_LetRecArgumentMismatch,
-                           "Recursive functions must be introduced at arrow types")
-                         rng in
-                 let reconcile_let_rec_ascription_and_body_type tarr
-                   lbtyp_opt =
-                   let get_decreases c =
-                     FStar_Compiler_Effect.op_Bar_Greater
-                       (FStar_Syntax_Util.comp_flags c)
-                       (FStar_Compiler_Util.prefix_until
-                          (fun uu___6 ->
-                             match uu___6 with
-                             | FStar_Syntax_Syntax.DECREASES uu___7 -> true
-                             | uu___7 -> false)) in
-                   match lbtyp_opt with
-                   | FStar_Pervasives_Native.None ->
-                       let uu___6 = un_arrow tarr in
-                       (match uu___6 with
-                        | (bs, c) ->
-                            let uu___7 = get_decreases c in
-                            (match uu___7 with
-                             | FStar_Pervasives_Native.Some
-                                 (pfx, FStar_Syntax_Syntax.DECREASES d, sfx)
-                                 ->
-                                 let c1 =
-                                   FStar_TypeChecker_Env.comp_set_flags env1
-                                     c (FStar_Compiler_List.op_At pfx sfx) in
-                                 let uu___8 = FStar_Syntax_Util.arrow bs c1 in
-                                 (uu___8, tarr, true)
-                             | uu___8 -> (tarr, tarr, true)))
-                   | FStar_Pervasives_Native.Some annot ->
-                       let uu___6 = un_arrow tarr in
-                       (match uu___6 with
-                        | (bs, c) ->
-                            let uu___7 = un_arrow annot in
-                            (match uu___7 with
-                             | (bs', c') ->
-                                 (if
-                                    (FStar_Compiler_List.length bs) <>
-                                      (FStar_Compiler_List.length bs')
-                                  then
-                                    FStar_Errors.raise_error
-                                      (FStar_Errors.Fatal_LetRecArgumentMismatch,
-                                        "Arity mismatch on let rec annotation")
-                                      rng
-                                  else ();
-                                  (let move_decreases d flags flags' =
-                                     let d' =
-                                       let s =
-                                         FStar_Syntax_Util.rename_binders bs
-                                           bs' in
-                                       FStar_Syntax_Subst.subst_decreasing_order
-                                         s d in
-                                     let c1 =
-                                       let uu___9 =
-                                         FStar_TypeChecker_Env.push_binders
-                                           env1 bs in
-                                       FStar_TypeChecker_Env.comp_set_flags
-                                         uu___9 c flags in
-                                     let tarr1 =
-                                       FStar_Syntax_Util.arrow bs c1 in
-                                     let c'1 =
-                                       let uu___9 =
-                                         FStar_TypeChecker_Env.push_binders
-                                           env1 bs' in
-                                       FStar_TypeChecker_Env.comp_set_flags
-                                         uu___9 c'
-                                         ((FStar_Syntax_Syntax.DECREASES d')
-                                         :: flags') in
-                                     let tannot =
-                                       FStar_Syntax_Util.arrow bs' c'1 in
-                                     (tarr1, tannot, true) in
-                                   let uu___9 =
-                                     let uu___10 = get_decreases c in
-                                     let uu___11 = get_decreases c' in
-                                     (uu___10, uu___11) in
-                                   match uu___9 with
-                                   | (FStar_Pervasives_Native.None, uu___10)
-                                       -> (tarr, annot, false)
-                                   | (FStar_Pervasives_Native.Some
-                                      (pfx, FStar_Syntax_Syntax.DECREASES d,
-                                       sfx),
-                                      FStar_Pervasives_Native.Some
-                                      (pfx', FStar_Syntax_Syntax.DECREASES
-                                       d', sfx')) ->
-                                       (FStar_Errors.log_issue rng
-                                          (FStar_Errors.Warning_DeprecatedGeneric,
-                                            "Multiple decreases clauses on this definition; the decreases clause on the declaration is ignored, please remove it");
-                                        move_decreases d
-                                          (FStar_Compiler_List.op_At pfx sfx)
-                                          (FStar_Compiler_List.op_At pfx'
-                                             sfx'))
-                                   | (FStar_Pervasives_Native.Some
-                                      (pfx, FStar_Syntax_Syntax.DECREASES d,
-                                       sfx),
-                                      FStar_Pervasives_Native.None) ->
-                                       move_decreases d
-                                         (FStar_Compiler_List.op_At pfx sfx)
-                                         (FStar_Syntax_Util.comp_flags c')
-                                   | uu___10 -> failwith "Impossible")))) in
-                 let extract_annot_from_body lbtyp_opt =
-                   let rec aux_lbdef e2 =
-                     let e3 = FStar_Syntax_Subst.compress e2 in
-                     match e3.FStar_Syntax_Syntax.n with
-                     | FStar_Syntax_Syntax.Tm_meta (e', m) ->
-                         let uu___6 = aux_lbdef e' in
-                         (match uu___6 with
-                          | (t3, e'1, recheck) ->
-                              (t3,
-                                {
-                                  FStar_Syntax_Syntax.n =
-                                    (FStar_Syntax_Syntax.Tm_meta (e'1, m));
-                                  FStar_Syntax_Syntax.pos =
-                                    (e3.FStar_Syntax_Syntax.pos);
-                                  FStar_Syntax_Syntax.vars =
-                                    (e3.FStar_Syntax_Syntax.vars);
-                                  FStar_Syntax_Syntax.hash_code =
-                                    (e3.FStar_Syntax_Syntax.hash_code)
-                                }, recheck))
-                     | FStar_Syntax_Syntax.Tm_ascribed
-                         (e', (FStar_Pervasives.Inr c, tac_opt, use_eq),
-                          lopt)
-                         ->
-                         let uu___6 = FStar_Syntax_Util.is_total_comp c in
-                         if uu___6
-                         then
-                           let uu___7 =
-                             reconcile_let_rec_ascription_and_body_type
-                               (FStar_Syntax_Util.comp_result c) lbtyp_opt in
-                           (match uu___7 with
-                            | (t3, lbtyp, recheck) ->
-                                let e4 =
-                                  let uu___8 =
-                                    let uu___9 =
-                                      let uu___10 =
-                                        let uu___11 =
-                                          let uu___12 =
-                                            FStar_Syntax_Syntax.mk_Total t3 in
-                                          FStar_Pervasives.Inr uu___12 in
-                                        (uu___11, tac_opt, use_eq) in
-                                      (e', uu___10, lopt) in
-                                    FStar_Syntax_Syntax.Tm_ascribed uu___9 in
-                                  {
-                                    FStar_Syntax_Syntax.n = uu___8;
-                                    FStar_Syntax_Syntax.pos =
-                                      (e3.FStar_Syntax_Syntax.pos);
-                                    FStar_Syntax_Syntax.vars =
-                                      (e3.FStar_Syntax_Syntax.vars);
-                                    FStar_Syntax_Syntax.hash_code =
-                                      (e3.FStar_Syntax_Syntax.hash_code)
-                                  } in
-                                (lbtyp, e4, recheck))
-                         else
-                           (let uu___8 =
-                              let uu___9 =
-                                let uu___10 =
-                                  FStar_Syntax_Print.comp_to_string c in
-                                FStar_Compiler_Util.format1
-                                  "Expected a 'let rec' to be annotated with a value type; got a computation type %s"
-                                  uu___10 in
-                              (FStar_Errors.Fatal_UnexpectedComputationTypeForLetRec,
-                                uu___9) in
-                            FStar_Errors.raise_error uu___8 rng)
-                     | FStar_Syntax_Syntax.Tm_ascribed
-                         (e', (FStar_Pervasives.Inl t3, tac_opt, use_eq),
-                          lopt)
-                         ->
-                         let uu___6 =
-                           reconcile_let_rec_ascription_and_body_type t3
-                             lbtyp_opt in
-                         (match uu___6 with
-                          | (t4, lbtyp, recheck) ->
-                              let e4 =
-                                {
-                                  FStar_Syntax_Syntax.n =
-                                    (FStar_Syntax_Syntax.Tm_ascribed
-                                       (e',
-                                         ((FStar_Pervasives.Inl t4), tac_opt,
-                                           use_eq), lopt));
-                                  FStar_Syntax_Syntax.pos =
-                                    (e3.FStar_Syntax_Syntax.pos);
-                                  FStar_Syntax_Syntax.vars =
-                                    (e3.FStar_Syntax_Syntax.vars);
-                                  FStar_Syntax_Syntax.hash_code =
-                                    (e3.FStar_Syntax_Syntax.hash_code)
-                                } in
-                              (lbtyp, e4, recheck))
-                     | FStar_Syntax_Syntax.Tm_abs uu___6 ->
-                         let uu___7 =
-                           FStar_Syntax_Util.abs_formals_maybe_unascribe_body
-                             false e3 in
-                         (match uu___7 with
-                          | (bs, body, rcopt) ->
-                              let mk_comp t3 =
-                                let uu___8 = FStar_Options.ml_ish () in
-                                if uu___8
-                                then
-                                  FStar_Syntax_Util.ml_comp t3
-                                    t3.FStar_Syntax_Syntax.pos
-                                else FStar_Syntax_Syntax.mk_Total t3 in
-                              let mk_arrow c = FStar_Syntax_Util.arrow bs c in
-                              let rec aux_abs_body body1 =
-                                let body2 = FStar_Syntax_Subst.compress body1 in
-                                match body2.FStar_Syntax_Syntax.n with
-                                | FStar_Syntax_Syntax.Tm_meta (body3, m) ->
-                                    let uu___8 = aux_abs_body body3 in
-                                    (match uu___8 with
-                                     | (t3, body', recheck) ->
-                                         let body4 =
-                                           {
-                                             FStar_Syntax_Syntax.n =
-                                               (FStar_Syntax_Syntax.Tm_meta
-                                                  (body', m));
-                                             FStar_Syntax_Syntax.pos =
-                                               (body3.FStar_Syntax_Syntax.pos);
-                                             FStar_Syntax_Syntax.vars =
-                                               (body3.FStar_Syntax_Syntax.vars);
-                                             FStar_Syntax_Syntax.hash_code =
-                                               (body3.FStar_Syntax_Syntax.hash_code)
-                                           } in
-                                         (t3, body4, recheck))
-                                | FStar_Syntax_Syntax.Tm_ascribed
-                                    (uu___8,
-                                     (FStar_Pervasives.Inl t3, uu___9,
-                                      use_eq),
-                                     uu___10)
-                                    ->
-                                    (if use_eq
-                                     then
-                                       (let uu___12 =
-                                          let uu___13 =
-                                            let uu___14 =
-                                              FStar_Syntax_Print.term_to_string
-                                                t3 in
-                                            FStar_Compiler_Util.format1
-                                              "Equality ascription in this case (%s) is not yet supported, please use subtyping"
-                                              uu___14 in
-                                          (FStar_Errors.Fatal_NotSupported,
-                                            uu___13) in
-                                        FStar_Errors.raise_error uu___12
-                                          t3.FStar_Syntax_Syntax.pos)
-                                     else ();
-                                     (match lbtyp_opt with
-                                      | FStar_Pervasives_Native.Some lbtyp ->
-                                          (lbtyp, body2, false)
-                                      | FStar_Pervasives_Native.None ->
-                                          let t4 =
-                                            let uu___12 = mk_comp t3 in
-                                            mk_arrow uu___12 in
-                                          (t4, body2, true)))
-                                | FStar_Syntax_Syntax.Tm_ascribed
-                                    (body',
-                                     (FStar_Pervasives.Inr c, tac_opt,
-                                      use_eq),
-                                     lopt)
-                                    ->
-                                    let tarr = mk_arrow c in
-                                    let uu___8 =
-                                      reconcile_let_rec_ascription_and_body_type
-                                        tarr lbtyp_opt in
-                                    (match uu___8 with
-                                     | (tarr1, lbtyp, recheck) ->
-                                         let uu___9 = un_arrow tarr1 in
-                                         (match uu___9 with
-                                          | (bs', c1) ->
-                                              if
-                                                (FStar_Compiler_List.length
-                                                   bs')
-                                                  <>
-                                                  (FStar_Compiler_List.length
-                                                     bs)
-                                              then failwith "Impossible"
-                                              else
-                                                (let subst =
-                                                   FStar_Syntax_Util.rename_binders
-                                                     bs' bs in
-                                                 let c2 =
-                                                   FStar_Syntax_Subst.subst_comp
-                                                     subst c1 in
-                                                 let body3 =
-                                                   {
-                                                     FStar_Syntax_Syntax.n =
-                                                       (FStar_Syntax_Syntax.Tm_ascribed
-                                                          (body',
-                                                            ((FStar_Pervasives.Inr
-                                                                c2), tac_opt,
-                                                              use_eq), lopt));
-                                                     FStar_Syntax_Syntax.pos
-                                                       =
-                                                       (body2.FStar_Syntax_Syntax.pos);
-                                                     FStar_Syntax_Syntax.vars
-                                                       =
-                                                       (body2.FStar_Syntax_Syntax.vars);
-                                                     FStar_Syntax_Syntax.hash_code
-                                                       =
-                                                       (body2.FStar_Syntax_Syntax.hash_code)
-                                                   } in
-                                                 (lbtyp, body3, recheck))))
-                                | uu___8 ->
-                                    (match lbtyp_opt with
-                                     | FStar_Pervasives_Native.Some lbtyp ->
-                                         (lbtyp, body2, false)
-                                     | FStar_Pervasives_Native.None ->
-                                         let tarr =
-                                           let uu___9 =
-                                             mk_comp FStar_Syntax_Syntax.tun in
-                                           mk_arrow uu___9 in
-                                         (tarr, body2, true)) in
-                              let uu___8 = aux_abs_body body in
-                              (match uu___8 with
-                               | (lbtyp, body1, recheck) ->
-                                   let uu___9 =
-                                     FStar_Syntax_Util.abs bs body1 rcopt in
-                                   (lbtyp, uu___9, recheck)))
-                     | uu___6 ->
-                         let uu___7 =
-                           let uu___8 =
-                             let uu___9 =
-                               FStar_Syntax_Print.term_to_string e3 in
-                             FStar_Compiler_Util.format1
-                               "Expected the definition of a 'let rec' to be a function literal; got %s"
-                               uu___9 in
-                           (FStar_Errors.Fatal_UnexpectedComputationTypeForLetRec,
-                             uu___8) in
-                         FStar_Errors.raise_error uu___7
-                           e3.FStar_Syntax_Syntax.pos in
-                   aux_lbdef e1 in
-                 match t2.FStar_Syntax_Syntax.n with
-                 | FStar_Syntax_Syntax.Tm_unknown ->
-                     let uu___6 =
-                       extract_annot_from_body FStar_Pervasives_Native.None in
-                     (match uu___6 with
-                      | (lbtyp, e2, uu___7) -> (univ_vars1, lbtyp, e2, true))
-                 | uu___6 ->
-                     let uu___7 = FStar_Syntax_Util.arrow_formals_comp t2 in
-                     (match uu___7 with
-                      | (uu___8, c) ->
-                          let uu___9 =
-                            let uu___10 =
-                              let uu___11 =
-                                FStar_Compiler_Effect.op_Bar_Greater
-                                  (FStar_Syntax_Util.comp_effect_name c)
-                                  (FStar_TypeChecker_Env.lookup_effect_quals
-                                     env1) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___11
-                                (FStar_Compiler_List.contains
-                                   FStar_Syntax_Syntax.TotalEffect) in
-                            Prims.op_Negation uu___10 in
-                          if uu___9
-                          then (univ_vars1, t2, e1, false)
-                          else
-                            (let uu___11 =
-                               extract_annot_from_body
-                                 (FStar_Pervasives_Native.Some t2) in
-                             match uu___11 with
-                             | (lbtyp, e2, check_lbtyp) ->
-                                 (univ_vars1, lbtyp, e2, check_lbtyp))))))
-let rec (decorated_pattern_as_term :
-  FStar_Syntax_Syntax.pat ->
-    (FStar_Syntax_Syntax.bv Prims.list * FStar_Syntax_Syntax.term))
-  =
-  fun pat ->
-    let mk f = FStar_Syntax_Syntax.mk f pat.FStar_Syntax_Syntax.p in
-    let pat_as_arg uu___ =
-      match uu___ with
-      | (p, i) ->
-          let uu___1 = decorated_pattern_as_term p in
-          (match uu___1 with
-           | (vars, te) ->
-               let uu___2 =
-                 let uu___3 = FStar_Syntax_Syntax.as_aqual_implicit i in
-                 (te, uu___3) in
-               (vars, uu___2)) in
-    match pat.FStar_Syntax_Syntax.v with
-    | FStar_Syntax_Syntax.Pat_constant c ->
-        let uu___ = mk (FStar_Syntax_Syntax.Tm_constant c) in ([], uu___)
-    | FStar_Syntax_Syntax.Pat_wild x ->
-        let uu___ = mk (FStar_Syntax_Syntax.Tm_name x) in ([x], uu___)
-    | FStar_Syntax_Syntax.Pat_var x ->
-        let uu___ = mk (FStar_Syntax_Syntax.Tm_name x) in ([x], uu___)
-    | FStar_Syntax_Syntax.Pat_cons (fv, us_opt, pats) ->
-        let uu___ =
-          let uu___1 =
-            FStar_Compiler_Effect.op_Bar_Greater pats
-              (FStar_Compiler_List.map pat_as_arg) in
-          FStar_Compiler_Effect.op_Bar_Greater uu___1
-            FStar_Compiler_List.unzip in
-        (match uu___ with
-         | (vars, args) ->
-             let vars1 = FStar_Compiler_List.flatten vars in
-             let head = FStar_Syntax_Syntax.fv_to_tm fv in
-             let head1 =
-               match us_opt with
-               | FStar_Pervasives_Native.None -> head
-               | FStar_Pervasives_Native.Some us ->
-                   FStar_Syntax_Syntax.mk_Tm_uinst head us in
-             let uu___1 = mk (FStar_Syntax_Syntax.Tm_app (head1, args)) in
-             (vars1, uu___1))
-    | FStar_Syntax_Syntax.Pat_dot_term eopt ->
-        (match eopt with
-         | FStar_Pervasives_Native.None ->
-             failwith
-               "TcUtil::decorated_pattern_as_term: dot pattern not resolved"
-         | FStar_Pervasives_Native.Some e -> ([], e))
-let (comp_univ_opt :
-  FStar_Syntax_Syntax.comp' FStar_Syntax_Syntax.syntax ->
-    FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option)
-  =
-  fun c ->
-    match c.FStar_Syntax_Syntax.n with
-    | FStar_Syntax_Syntax.Total uu___ -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.GTotal uu___ -> FStar_Pervasives_Native.None
-    | FStar_Syntax_Syntax.Comp c1 ->
-        (match c1.FStar_Syntax_Syntax.comp_univs with
-         | [] -> FStar_Pervasives_Native.None
-         | hd::uu___ -> FStar_Pervasives_Native.Some hd)
-let (lcomp_univ_opt :
-  FStar_TypeChecker_Common.lcomp ->
-    (FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option *
-      FStar_TypeChecker_Env.guard_t))
-  =
-  fun lc ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater lc
-        FStar_TypeChecker_Common.lcomp_comp in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (fun uu___1 -> match uu___1 with | (c, g) -> ((comp_univ_opt c), g))
-let (destruct_wp_comp :
-  FStar_Syntax_Syntax.comp_typ ->
-    (FStar_Syntax_Syntax.universe * FStar_Syntax_Syntax.typ *
-      FStar_Syntax_Syntax.typ))
-  = fun c -> FStar_Syntax_Util.destruct_comp c
-let (mk_comp_l :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.cflag Prims.list -> FStar_Syntax_Syntax.comp)
-  =
-  fun mname ->
-    fun u_result ->
-      fun result ->
-        fun wp ->
-          fun flags ->
-            let uu___ =
-              let uu___1 =
-                let uu___2 = FStar_Syntax_Syntax.as_arg wp in [uu___2] in
-              {
-                FStar_Syntax_Syntax.comp_univs = [u_result];
-                FStar_Syntax_Syntax.effect_name = mname;
-                FStar_Syntax_Syntax.result_typ = result;
-                FStar_Syntax_Syntax.effect_args = uu___1;
-                FStar_Syntax_Syntax.flags = flags
-              } in
-            FStar_Syntax_Syntax.mk_Comp uu___
-let (mk_comp :
-  FStar_Syntax_Syntax.eff_decl ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.cflag Prims.list -> FStar_Syntax_Syntax.comp)
-  = fun md -> mk_comp_l md.FStar_Syntax_Syntax.mname
-let (effect_args_from_repr :
-  FStar_Syntax_Syntax.term ->
-    Prims.bool ->
-      FStar_Compiler_Range.range -> FStar_Syntax_Syntax.term Prims.list)
-  =
-  fun repr ->
-    fun is_layered ->
-      fun r ->
-        let err uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Print.term_to_string repr in
-              let uu___4 = FStar_Compiler_Util.string_of_bool is_layered in
-              FStar_Compiler_Util.format2
-                "Could not get effect args from repr %s with is_layered %s"
-                uu___3 uu___4 in
-            (FStar_Errors.Fatal_UnexpectedEffect, uu___2) in
-          FStar_Errors.raise_error uu___1 r in
-        let repr1 = FStar_Syntax_Subst.compress repr in
-        if is_layered
-        then
-          match repr1.FStar_Syntax_Syntax.n with
-          | FStar_Syntax_Syntax.Tm_app (uu___, uu___1::is) ->
-              FStar_Compiler_Effect.op_Bar_Greater is
-                (FStar_Compiler_List.map FStar_Pervasives_Native.fst)
-          | uu___ -> err ()
-        else
-          (match repr1.FStar_Syntax_Syntax.n with
-           | FStar_Syntax_Syntax.Tm_arrow (uu___1, c) ->
-               let uu___2 =
-                 FStar_Compiler_Effect.op_Bar_Greater c
-                   FStar_Syntax_Util.comp_eff_name_res_and_args in
-               FStar_Compiler_Effect.op_Bar_Greater uu___2
-                 (fun uu___3 ->
-                    match uu___3 with
-                    | (uu___4, uu___5, args) ->
-                        FStar_Compiler_Effect.op_Bar_Greater args
-                          (FStar_Compiler_List.map
-                             FStar_Pervasives_Native.fst))
-           | uu___1 -> err ())
-let (mk_wp_return :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Compiler_Range.range -> FStar_Syntax_Syntax.comp)
-  =
-  fun env ->
-    fun ed ->
-      fun u_a ->
-        fun a ->
-          fun e ->
-            fun r ->
-              let c =
-                let uu___ =
-                  let uu___1 =
-                    FStar_TypeChecker_Env.lid_exists env
-                      FStar_Parser_Const.effect_GTot_lid in
-                  FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___1 in
-                if uu___
-                then FStar_Syntax_Syntax.mk_Total a
-                else
-                  (let uu___2 = FStar_Syntax_Util.is_unit a in
-                   if uu___2
-                   then FStar_Syntax_Syntax.mk_Total a
-                   else
-                     (let wp =
-                        let uu___4 =
-                          env.FStar_TypeChecker_Env.lax &&
-                            (FStar_Options.ml_ish ()) in
-                        if uu___4
-                        then FStar_Syntax_Syntax.tun
-                        else
-                          (let ret_wp =
-                             FStar_Compiler_Effect.op_Bar_Greater ed
-                               FStar_Syntax_Util.get_return_vc_combinator in
-                           let uu___6 =
-                             FStar_TypeChecker_Env.inst_effect_fun_with 
-                               [u_a] env ed ret_wp in
-                           let uu___7 =
-                             let uu___8 = FStar_Syntax_Syntax.as_arg a in
-                             let uu___9 =
-                               let uu___10 = FStar_Syntax_Syntax.as_arg e in
-                               [uu___10] in
-                             uu___8 :: uu___9 in
-                           FStar_Syntax_Syntax.mk_Tm_app uu___6 uu___7
-                             e.FStar_Syntax_Syntax.pos) in
-                      mk_comp ed u_a a wp [FStar_Syntax_Syntax.RETURN])) in
-              (let uu___1 =
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (FStar_TypeChecker_Env.debug env)
-                   (FStar_Options.Other "Return") in
-               if uu___1
-               then
-                 let uu___2 =
-                   FStar_Compiler_Range.string_of_range
-                     e.FStar_Syntax_Syntax.pos in
-                 let uu___3 = FStar_Syntax_Print.term_to_string e in
-                 let uu___4 =
-                   FStar_TypeChecker_Normalize.comp_to_string env c in
-                 FStar_Compiler_Util.print3
-                   "(%s) returning %s at comp type %s\n" uu___2 uu___3 uu___4
-               else ());
-              c
-let (label :
-  Prims.string ->
-    FStar_Compiler_Range.range ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun reason ->
-    fun r ->
-      fun f ->
-        FStar_Syntax_Syntax.mk
-          (FStar_Syntax_Syntax.Tm_meta
-             (f, (FStar_Syntax_Syntax.Meta_labeled (reason, r, false))))
-          f.FStar_Syntax_Syntax.pos
-let (label_opt :
-  FStar_TypeChecker_Env.env ->
-    (unit -> Prims.string) FStar_Pervasives_Native.option ->
-      FStar_Compiler_Range.range ->
-        FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.typ)
-  =
-  fun env ->
-    fun reason ->
-      fun r ->
-        fun f ->
-          match reason with
-          | FStar_Pervasives_Native.None -> f
-          | FStar_Pervasives_Native.Some reason1 ->
-              let uu___ =
-                let uu___1 = FStar_TypeChecker_Env.should_verify env in
-                FStar_Compiler_Effect.op_Less_Bar Prims.op_Negation uu___1 in
-              if uu___
-              then f
-              else (let uu___2 = reason1 () in label uu___2 r f)
-let (label_guard :
-  FStar_Compiler_Range.range ->
-    Prims.string ->
-      FStar_TypeChecker_Env.guard_t -> FStar_TypeChecker_Env.guard_t)
-  =
-  fun r ->
-    fun reason ->
-      fun g ->
-        match g.FStar_TypeChecker_Common.guard_f with
-        | FStar_TypeChecker_Common.Trivial -> g
-        | FStar_TypeChecker_Common.NonTrivial f ->
-            let uu___ =
-              let uu___1 = label reason r f in
-              FStar_TypeChecker_Common.NonTrivial uu___1 in
-            {
-              FStar_TypeChecker_Common.guard_f = uu___;
-              FStar_TypeChecker_Common.deferred_to_tac =
-                (g.FStar_TypeChecker_Common.deferred_to_tac);
-              FStar_TypeChecker_Common.deferred =
-                (g.FStar_TypeChecker_Common.deferred);
-              FStar_TypeChecker_Common.univ_ineqs =
-                (g.FStar_TypeChecker_Common.univ_ineqs);
-              FStar_TypeChecker_Common.implicits =
-                (g.FStar_TypeChecker_Common.implicits)
-            }
-let (lift_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp_typ ->
-      FStar_TypeChecker_Env.mlift ->
-        (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c ->
-      fun lift ->
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater
-            {
-              FStar_Syntax_Syntax.comp_univs =
-                (c.FStar_Syntax_Syntax.comp_univs);
-              FStar_Syntax_Syntax.effect_name =
-                (c.FStar_Syntax_Syntax.effect_name);
-              FStar_Syntax_Syntax.result_typ =
-                (c.FStar_Syntax_Syntax.result_typ);
-              FStar_Syntax_Syntax.effect_args =
-                (c.FStar_Syntax_Syntax.effect_args);
-              FStar_Syntax_Syntax.flags = []
-            } FStar_Syntax_Syntax.mk_Comp in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (lift.FStar_TypeChecker_Env.mlift_wp env)
-let (join_effects :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident -> FStar_Ident.lident -> FStar_Ident.lident)
-  =
-  fun env ->
-    fun l1_in ->
-      fun l2_in ->
-        let uu___ =
-          let uu___1 = FStar_TypeChecker_Env.norm_eff_name env l1_in in
-          let uu___2 = FStar_TypeChecker_Env.norm_eff_name env l2_in in
-          (uu___1, uu___2) in
-        match uu___ with
-        | (l1, l2) ->
-            let uu___1 = FStar_TypeChecker_Env.join_opt env l1 l2 in
-            (match uu___1 with
-             | FStar_Pervasives_Native.Some (m, uu___2, uu___3) -> m
-             | FStar_Pervasives_Native.None ->
-                 let uu___2 =
-                   FStar_TypeChecker_Env.exists_polymonadic_bind env l1 l2 in
-                 (match uu___2 with
-                  | FStar_Pervasives_Native.Some (m, uu___3) -> m
-                  | FStar_Pervasives_Native.None ->
-                      let uu___3 =
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Print.lid_to_string l1_in in
-                          let uu___6 = FStar_Syntax_Print.lid_to_string l2_in in
-                          FStar_Compiler_Util.format2
-                            "Effects %s and %s cannot be composed" uu___5
-                            uu___6 in
-                        (FStar_Errors.Fatal_EffectsCannotBeComposed, uu___4) in
-                      FStar_Errors.raise_error uu___3
-                        env.FStar_TypeChecker_Env.range))
-let (join_lcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.lcomp ->
-      FStar_TypeChecker_Common.lcomp -> FStar_Ident.lident)
-  =
-  fun env ->
-    fun c1 ->
-      fun c2 ->
-        let uu___ =
-          (FStar_TypeChecker_Common.is_total_lcomp c1) &&
-            (FStar_TypeChecker_Common.is_total_lcomp c2) in
-        if uu___
-        then FStar_Parser_Const.effect_Tot_lid
-        else
-          join_effects env c1.FStar_TypeChecker_Common.eff_name
-            c2.FStar_TypeChecker_Common.eff_name
-let (maybe_push :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-      FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun b ->
-      match b with
-      | FStar_Pervasives_Native.None -> env
-      | FStar_Pervasives_Native.Some bv ->
-          FStar_TypeChecker_Env.push_bv env bv
-let (lift_comps_sep_guards :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-          Prims.bool ->
-            (FStar_Ident.lident * FStar_Syntax_Syntax.comp *
-              FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c1 ->
-      fun c2 ->
-        fun b ->
-          fun for_bind ->
-            let c11 = FStar_TypeChecker_Env.unfold_effect_abbrev env c1 in
-            let env2 = maybe_push env b in
-            let c21 = FStar_TypeChecker_Env.unfold_effect_abbrev env2 c2 in
-            let uu___ =
-              FStar_TypeChecker_Env.join_opt env
-                c11.FStar_Syntax_Syntax.effect_name
-                c21.FStar_Syntax_Syntax.effect_name in
-            match uu___ with
-            | FStar_Pervasives_Native.Some (m, lift1, lift2) ->
-                let uu___1 = lift_comp env c11 lift1 in
-                (match uu___1 with
-                 | (c12, g1) ->
-                     let uu___2 =
-                       if Prims.op_Negation for_bind
-                       then lift_comp env2 c21 lift2
-                       else
-                         (let x_a =
-                            match b with
-                            | FStar_Pervasives_Native.None ->
-                                FStar_Syntax_Syntax.null_binder
-                                  (FStar_Syntax_Util.comp_result c12)
-                            | FStar_Pervasives_Native.Some x ->
-                                FStar_Syntax_Syntax.mk_binder x in
-                          let env_x =
-                            FStar_TypeChecker_Env.push_binders env [x_a] in
-                          let uu___4 = lift_comp env_x c21 lift2 in
-                          match uu___4 with
-                          | (c22, g2) ->
-                              let uu___5 =
-                                FStar_TypeChecker_Env.close_guard env 
-                                  [x_a] g2 in
-                              (c22, uu___5)) in
-                     (match uu___2 with | (c22, g2) -> (m, c12, c22, g1, g2)))
-            | FStar_Pervasives_Native.None ->
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Syntax_Print.lid_to_string
-                        c11.FStar_Syntax_Syntax.effect_name in
-                    let uu___4 =
-                      FStar_Syntax_Print.lid_to_string
-                        c21.FStar_Syntax_Syntax.effect_name in
-                    FStar_Compiler_Util.format2
-                      "Effects %s and %s cannot be composed" uu___3 uu___4 in
-                  (FStar_Errors.Fatal_EffectsCannotBeComposed, uu___2) in
-                FStar_Errors.raise_error uu___1
-                  env.FStar_TypeChecker_Env.range
-let (lift_comps :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-          Prims.bool ->
-            (FStar_Ident.lident * FStar_Syntax_Syntax.comp *
-              FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c1 ->
-      fun c2 ->
-        fun b ->
-          fun for_bind ->
-            let uu___ = lift_comps_sep_guards env c1 c2 b for_bind in
-            match uu___ with
-            | (l, c11, c21, g1, g2) ->
-                let uu___1 = FStar_TypeChecker_Env.conj_guard g1 g2 in
-                (l, c11, c21, uu___1)
-let (is_pure_effect :
-  FStar_TypeChecker_Env.env -> FStar_Ident.lident -> Prims.bool) =
-  fun env ->
-    fun l ->
-      let l1 = FStar_TypeChecker_Env.norm_eff_name env l in
-      FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_PURE_lid
-let (is_ghost_effect :
-  FStar_TypeChecker_Env.env -> FStar_Ident.lident -> Prims.bool) =
-  fun env ->
-    fun l ->
-      let l1 = FStar_TypeChecker_Env.norm_eff_name env l in
-      FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_GHOST_lid
-let (is_pure_or_ghost_effect :
-  FStar_TypeChecker_Env.env -> FStar_Ident.lident -> Prims.bool) =
-  fun env ->
-    fun l ->
-      let l1 = FStar_TypeChecker_Env.norm_eff_name env l in
-      (FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_PURE_lid) ||
-        (FStar_Ident.lid_equals l1 FStar_Parser_Const.effect_GHOST_lid)
-let (lax_mk_tot_or_comp_l :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-        FStar_Syntax_Syntax.cflag Prims.list -> FStar_Syntax_Syntax.comp)
-  =
-  fun mname ->
-    fun u_result ->
-      fun result ->
-        fun flags ->
-          let uu___ =
-            FStar_Ident.lid_equals mname FStar_Parser_Const.effect_Tot_lid in
-          if uu___
-          then FStar_Syntax_Syntax.mk_Total result
-          else mk_comp_l mname u_result result FStar_Syntax_Syntax.tun flags
-let (is_function : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun t ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Subst.compress t in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_arrow uu___1 -> true
-    | uu___1 -> false
-let (close_wp_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.bv Prims.list ->
-      FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.comp)
-  =
-  fun env ->
-    fun bvs ->
-      fun c ->
-        (let uu___1 = FStar_TypeChecker_Env.push_bvs env bvs in
-         FStar_TypeChecker_Env.def_check_comp_closed_in_env
-           c.FStar_Syntax_Syntax.pos "close_wp_comp" uu___1 c);
-        (let uu___1 = FStar_Syntax_Util.is_ml_comp c in
-         if uu___1
-         then c
-         else
-           (let uu___3 =
-              env.FStar_TypeChecker_Env.lax && (FStar_Options.ml_ish ()) in
-            if uu___3
-            then c
-            else
-              (let env_bvs = FStar_TypeChecker_Env.push_bvs env bvs in
-               let close_wp u_res md res_t bvs1 wp0 =
-                 let close =
-                   let uu___5 =
-                     FStar_Compiler_Effect.op_Bar_Greater md
-                       FStar_Syntax_Util.get_wp_close_combinator in
-                   FStar_Compiler_Effect.op_Bar_Greater uu___5
-                     FStar_Compiler_Util.must in
-                 FStar_Compiler_List.fold_right
-                   (fun x ->
-                      fun wp ->
-                        let bs =
-                          let uu___5 = FStar_Syntax_Syntax.mk_binder x in
-                          [uu___5] in
-                        let us =
-                          let uu___5 =
-                            let uu___6 =
-                              env.FStar_TypeChecker_Env.universe_of env_bvs
-                                x.FStar_Syntax_Syntax.sort in
-                            [uu___6] in
-                          u_res :: uu___5 in
-                        let wp1 =
-                          FStar_Syntax_Util.abs bs wp
-                            (FStar_Pervasives_Native.Some
-                               (FStar_Syntax_Util.mk_residual_comp
-                                  FStar_Parser_Const.effect_Tot_lid
-                                  FStar_Pervasives_Native.None
-                                  [FStar_Syntax_Syntax.TOTAL])) in
-                        let uu___5 =
-                          FStar_TypeChecker_Env.inst_effect_fun_with us env
-                            md close in
-                        let uu___6 =
-                          let uu___7 = FStar_Syntax_Syntax.as_arg res_t in
-                          let uu___8 =
-                            let uu___9 =
-                              FStar_Syntax_Syntax.as_arg
-                                x.FStar_Syntax_Syntax.sort in
-                            let uu___10 =
-                              let uu___11 = FStar_Syntax_Syntax.as_arg wp1 in
-                              [uu___11] in
-                            uu___9 :: uu___10 in
-                          uu___7 :: uu___8 in
-                        FStar_Syntax_Syntax.mk_Tm_app uu___5 uu___6
-                          wp0.FStar_Syntax_Syntax.pos) bvs1 wp0 in
-               let c1 = FStar_TypeChecker_Env.unfold_effect_abbrev env_bvs c in
-               let uu___5 = destruct_wp_comp c1 in
-               match uu___5 with
-               | (u_res_t, res_t, wp) ->
-                   let md =
-                     FStar_TypeChecker_Env.get_effect_decl env
-                       c1.FStar_Syntax_Syntax.effect_name in
-                   let wp1 = close_wp u_res_t md res_t bvs wp in
-                   let uu___6 =
-                     FStar_Compiler_Effect.op_Bar_Greater
-                       c1.FStar_Syntax_Syntax.flags
-                       (FStar_Compiler_List.filter
-                          (fun uu___7 ->
-                             match uu___7 with
-                             | FStar_Syntax_Syntax.MLEFFECT -> true
-                             | FStar_Syntax_Syntax.SHOULD_NOT_INLINE -> true
-                             | uu___8 -> false)) in
-                   mk_comp md u_res_t c1.FStar_Syntax_Syntax.result_typ wp1
-                     uu___6)))
-let (close_wp_lcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.bv Prims.list ->
-      FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun bvs ->
-      fun lc ->
-        let bs =
-          FStar_Compiler_Effect.op_Bar_Greater bvs
-            (FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder) in
-        FStar_Compiler_Effect.op_Bar_Greater lc
-          (FStar_TypeChecker_Common.apply_lcomp (close_wp_comp env bvs)
-             (fun g ->
-                let uu___ =
-                  FStar_Compiler_Effect.op_Bar_Greater g
-                    (FStar_TypeChecker_Env.close_guard env bs) in
-                FStar_Compiler_Effect.op_Bar_Greater uu___
-                  (close_guard_implicits env false bs)))
-let (close_layered_lcomp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.bv Prims.list ->
-      FStar_Syntax_Syntax.term Prims.list ->
-        FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun bvs ->
-      fun tms ->
-        fun lc ->
-          let bs =
-            FStar_Compiler_Effect.op_Bar_Greater bvs
-              (FStar_Compiler_List.map FStar_Syntax_Syntax.mk_binder) in
-          let substs =
-            FStar_Compiler_List.map2
-              (fun bv -> fun tm -> FStar_Syntax_Syntax.NT (bv, tm)) bvs tms in
-          FStar_Compiler_Effect.op_Bar_Greater lc
-            (FStar_TypeChecker_Common.apply_lcomp
-               (FStar_Syntax_Subst.subst_comp substs)
-               (fun g ->
-                  let uu___ =
-                    FStar_Compiler_Effect.op_Bar_Greater g
-                      (FStar_TypeChecker_Env.close_guard env bs) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___
-                    (close_guard_implicits env false bs)))
-let (should_not_inline_lc : FStar_TypeChecker_Common.lcomp -> Prims.bool) =
-  fun lc ->
-    FStar_Compiler_Effect.op_Bar_Greater lc.FStar_TypeChecker_Common.cflags
-      (FStar_Compiler_Util.for_some
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.SHOULD_NOT_INLINE -> true
-            | uu___1 -> false))
-let (should_return :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-      FStar_TypeChecker_Common.lcomp -> Prims.bool)
-  =
-  fun env ->
-    fun eopt ->
-      fun lc ->
-        let lc_is_unit_or_effectful =
-          let c =
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater
-                lc.FStar_TypeChecker_Common.res_typ
-                FStar_Syntax_Util.arrow_formals_comp in
-            FStar_Compiler_Effect.op_Bar_Greater uu___
-              FStar_Pervasives_Native.snd in
-          let uu___ = FStar_TypeChecker_Env.is_reifiable_comp env c in
-          if uu___
-          then
-            let c_eff_name =
-              let uu___1 =
-                FStar_Compiler_Effect.op_Bar_Greater c
-                  FStar_Syntax_Util.comp_effect_name in
-              FStar_Compiler_Effect.op_Bar_Greater uu___1
-                (FStar_TypeChecker_Env.norm_eff_name env) in
-            let uu___1 =
-              (FStar_TypeChecker_Common.is_pure_or_ghost_lcomp lc) &&
-                (FStar_Ident.lid_equals c_eff_name
-                   FStar_Parser_Const.effect_TAC_lid) in
-            (if uu___1
-             then false
-             else
-               FStar_Compiler_Effect.op_Bar_Greater c_eff_name
-                 (FStar_TypeChecker_Env.is_layered_effect env))
-          else
-            (let uu___2 = FStar_Syntax_Util.is_pure_or_ghost_comp c in
-             if uu___2
-             then
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Compiler_Effect.op_Bar_Greater c
-                     FStar_Syntax_Util.comp_result in
-                 FStar_Compiler_Effect.op_Bar_Greater uu___4
-                   (FStar_TypeChecker_Normalize.unfold_whnf env) in
-               FStar_Compiler_Effect.op_Bar_Greater uu___3
-                 FStar_Syntax_Util.is_unit
-             else true) in
-        match eopt with
-        | FStar_Pervasives_Native.None -> false
-        | FStar_Pervasives_Native.Some e ->
-            (((FStar_TypeChecker_Common.is_pure_or_ghost_lcomp lc) &&
-                (Prims.op_Negation lc_is_unit_or_effectful))
-               &&
-               (let uu___ = FStar_Syntax_Util.head_and_args_full e in
-                match uu___ with
-                | (head, uu___1) ->
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Util.un_uinst head in
-                      uu___3.FStar_Syntax_Syntax.n in
-                    (match uu___2 with
-                     | FStar_Syntax_Syntax.Tm_fvar fv ->
-                         let uu___3 =
-                           let uu___4 = FStar_Syntax_Syntax.lid_of_fv fv in
-                           FStar_TypeChecker_Env.is_irreducible env uu___4 in
-                         Prims.op_Negation uu___3
-                     | uu___3 -> true)))
-              &&
-              (let uu___ = should_not_inline_lc lc in Prims.op_Negation uu___)
-let (substitutive_indexed_bind_substs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.eff_decl ->
-        FStar_Syntax_Syntax.eff_decl ->
-          FStar_Syntax_Syntax.binders ->
-            FStar_Syntax_Syntax.indexed_effect_binder_kind Prims.list ->
-              FStar_Syntax_Syntax.comp_typ ->
-                FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                  FStar_Syntax_Syntax.comp_typ ->
-                    FStar_Compiler_Range.range ->
-                      Prims.int ->
-                        Prims.bool ->
-                          (FStar_Syntax_Syntax.subst_elt Prims.list *
-                            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun m_ed ->
-      fun n_ed ->
-        fun p_ed ->
-          fun bs ->
-            fun binder_kinds ->
-              fun ct1 ->
-                fun b ->
-                  fun ct2 ->
-                    fun r1 ->
-                      fun num_effect_params ->
-                        fun has_range_binders ->
-                          let debug =
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (FStar_TypeChecker_Env.debug env)
-                              (FStar_Options.Other "LayeredEffectsApp") in
-                          let bind_name uu___ =
-                            if debug
-                            then
-                              let uu___1 =
-                                let uu___2 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    m_ed.FStar_Syntax_Syntax.mname
-                                    FStar_Ident.ident_of_lid in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___2
-                                  FStar_Ident.string_of_id in
-                              let uu___2 =
-                                let uu___3 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    n_ed.FStar_Syntax_Syntax.mname
-                                    FStar_Ident.ident_of_lid in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                  FStar_Ident.string_of_id in
-                              let uu___3 =
-                                let uu___4 =
-                                  FStar_Compiler_Effect.op_Bar_Greater
-                                    p_ed.FStar_Syntax_Syntax.mname
-                                    FStar_Ident.ident_of_lid in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___4
-                                  FStar_Ident.string_of_id in
-                              FStar_Compiler_Util.format3 "(%s, %s) |> %s"
-                                uu___1 uu___2 uu___3
-                            else "" in
-                          let uu___ =
-                            let uu___1 = bs in
-                            match uu___1 with
-                            | a_b::b_b::bs1 ->
-                                let uu___2 =
-                                  let uu___3 =
-                                    FStar_Compiler_List.splitAt
-                                      (Prims.of_int (2)) binder_kinds in
-                                  FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                    FStar_Pervasives_Native.snd in
-                                (bs1, uu___2,
-                                  [FStar_Syntax_Syntax.NT
-                                     ((a_b.FStar_Syntax_Syntax.binder_bv),
-                                       (ct1.FStar_Syntax_Syntax.result_typ));
-                                  FStar_Syntax_Syntax.NT
-                                    ((b_b.FStar_Syntax_Syntax.binder_bv),
-                                      (ct2.FStar_Syntax_Syntax.result_typ))]) in
-                          match uu___ with
-                          | (bs1, binder_kinds1, subst) ->
-                              let uu___1 =
-                                if num_effect_params = Prims.int_zero
-                                then
-                                  (bs1, binder_kinds1, subst,
-                                    FStar_TypeChecker_Env.trivial_guard,
-                                    (ct1.FStar_Syntax_Syntax.effect_args),
-                                    (ct2.FStar_Syntax_Syntax.effect_args))
-                                else
-                                  (let split l =
-                                     FStar_Compiler_List.splitAt
-                                       num_effect_params l in
-                                   let uu___3 = split bs1 in
-                                   match uu___3 with
-                                   | (eff_params_bs, bs2) ->
-                                       let uu___4 = split binder_kinds1 in
-                                       (match uu___4 with
-                                        | (uu___5, binder_kinds2) ->
-                                            let uu___6 =
-                                              split
-                                                ct1.FStar_Syntax_Syntax.effect_args in
-                                            (match uu___6 with
-                                             | (param_args1, args1) ->
-                                                 let uu___7 =
-                                                   split
-                                                     ct2.FStar_Syntax_Syntax.effect_args in
-                                                 (match uu___7 with
-                                                  | (param_args2, args2) ->
-                                                      let g =
-                                                        FStar_Compiler_List.fold_left2
-                                                          (fun g1 ->
-                                                             fun uu___8 ->
-                                                               fun uu___9 ->
-                                                                 match 
-                                                                   (uu___8,
-                                                                    uu___9)
-                                                                 with
-                                                                 | ((arg1,
-                                                                    uu___10),
-                                                                    (arg2,
-                                                                    uu___11))
-                                                                    ->
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_TypeChecker_Rel.layered_effect_teq
-                                                                    env arg1
-                                                                    arg2
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "effect param bind") in
-                                                                    FStar_TypeChecker_Env.conj_guard
-                                                                    g1
-                                                                    uu___12)
-                                                          FStar_TypeChecker_Env.trivial_guard
-                                                          param_args1
-                                                          param_args2 in
-                                                      let param_subst =
-                                                        FStar_Compiler_List.map2
-                                                          (fun b1 ->
-                                                             fun uu___8 ->
-                                                               match uu___8
-                                                               with
-                                                               | (arg,
-                                                                  uu___9) ->
-                                                                   FStar_Syntax_Syntax.NT
-                                                                    ((b1.FStar_Syntax_Syntax.binder_bv),
-                                                                    arg))
-                                                          eff_params_bs
-                                                          param_args1 in
-                                                      (bs2, binder_kinds2,
-                                                        (FStar_Compiler_List.op_At
-                                                           subst param_subst),
-                                                        g, args1, args2))))) in
-                              (match uu___1 with
-                               | (bs2, binder_kinds2, subst1, guard, args1,
-                                  args2) ->
-                                   let uu___2 =
-                                     let m_num_effect_args =
-                                       FStar_Compiler_List.length args1 in
-                                     let uu___3 =
-                                       FStar_Compiler_List.splitAt
-                                         m_num_effect_args bs2 in
-                                     match uu___3 with
-                                     | (f_bs, bs3) ->
-                                         let f_subst =
-                                           FStar_Compiler_List.map2
-                                             (fun f_b ->
-                                                fun arg ->
-                                                  FStar_Syntax_Syntax.NT
-                                                    ((f_b.FStar_Syntax_Syntax.binder_bv),
-                                                      (FStar_Pervasives_Native.fst
-                                                         arg))) f_bs args1 in
-                                         let uu___4 =
-                                           let uu___5 =
-                                             FStar_Compiler_List.splitAt
-                                               m_num_effect_args
-                                               binder_kinds2 in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___5
-                                             FStar_Pervasives_Native.snd in
-                                         (bs3, uu___4,
-                                           (FStar_Compiler_List.op_At subst1
-                                              f_subst)) in
-                                   (match uu___2 with
-                                    | (bs3, binder_kinds3, subst2) ->
-                                        let uu___3 =
-                                          let n_num_effect_args =
-                                            FStar_Compiler_List.length args2 in
-                                          let uu___4 =
-                                            FStar_Compiler_List.splitAt
-                                              n_num_effect_args bs3 in
-                                          match uu___4 with
-                                          | (g_bs, bs4) ->
-                                              let g_bs_kinds =
-                                                let uu___5 =
-                                                  FStar_Compiler_List.splitAt
-                                                    n_num_effect_args
-                                                    binder_kinds3 in
-                                                FStar_Compiler_Effect.op_Bar_Greater
-                                                  uu___5
-                                                  FStar_Pervasives_Native.fst in
-                                              let x_bv =
-                                                match b with
-                                                | FStar_Pervasives_Native.None
-                                                    ->
-                                                    FStar_Syntax_Syntax.null_bv
-                                                      ct1.FStar_Syntax_Syntax.result_typ
-                                                | FStar_Pervasives_Native.Some
-                                                    x -> x in
-                                              let uu___5 =
-                                                let uu___6 =
-                                                  FStar_Compiler_List.zip
-                                                    g_bs g_bs_kinds in
-                                                FStar_Compiler_List.fold_left2
-                                                  (fun uu___7 ->
-                                                     fun uu___8 ->
-                                                       fun arg ->
-                                                         match (uu___7,
-                                                                 uu___8)
-                                                         with
-                                                         | ((ss, g),
-                                                            (g_b, g_b_kind))
-                                                             ->
-                                                             if
-                                                               g_b_kind =
-                                                                 FStar_Syntax_Syntax.Substitutive_binder
-                                                             then
-                                                               let arg_t =
-                                                                 let uu___9 =
-                                                                   let uu___10
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    x_bv
-                                                                    FStar_Syntax_Syntax.mk_binder in
-                                                                   [uu___10] in
-                                                                 FStar_Syntax_Util.abs
-                                                                   uu___9
-                                                                   (FStar_Pervasives_Native.fst
-                                                                    arg)
-                                                                   FStar_Pervasives_Native.None in
-                                                               ((FStar_Compiler_List.op_At
-                                                                   ss
-                                                                   [FStar_Syntax_Syntax.NT
-                                                                    ((g_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    arg_t)]),
-                                                                 g)
-                                                             else
-                                                               if
-                                                                 g_b_kind =
-                                                                   FStar_Syntax_Syntax.BindCont_no_abstraction_binder
-                                                               then
-                                                                 (let uu___10
-                                                                    =
-                                                                    FStar_TypeChecker_Env.uvars_for_binders
-                                                                    env 
-                                                                    [g_b] ss
-                                                                    (fun b1
-                                                                    ->
-                                                                    if debug
-                                                                    then
-                                                                    let uu___11
-                                                                    =
-                                                                    FStar_Syntax_Print.binder_to_string
-                                                                    b1 in
-                                                                    let uu___12
-                                                                    =
-                                                                    bind_name
-                                                                    () in
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Range.string_of_range
-                                                                    r1 in
-                                                                    FStar_Compiler_Util.format3
-                                                                    "implicit var for no abs g binder %s of %s at %s"
-                                                                    uu___11
-                                                                    uu___12
-                                                                    uu___13
-                                                                    else
-                                                                    "substitutive_indexed_bind_substs.1")
-                                                                    r1 in
-                                                                  match uu___10
-                                                                  with
-                                                                  | (uv_t::[],
-                                                                    g_uv) ->
-                                                                    let g_unif
-                                                                    =
-                                                                    let uu___11
-                                                                    =
-                                                                    let uu___12
-                                                                    =
-                                                                    let uu___13
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    x_bv
-                                                                    FStar_Syntax_Syntax.mk_binder in
-                                                                    [uu___13] in
-                                                                    FStar_TypeChecker_Env.push_binders
-                                                                    env
-                                                                    uu___12 in
-                                                                    let uu___12
-                                                                    =
-                                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                                    arg
-                                                                    FStar_Pervasives_Native.fst in
-                                                                    FStar_TypeChecker_Rel.layered_effect_teq
-                                                                    uu___11
-                                                                    uv_t
-                                                                    uu___12
-                                                                    (FStar_Pervasives_Native.Some
-                                                                    "") in
-                                                                    let uu___11
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guards
-                                                                    [g;
-                                                                    g_uv;
-                                                                    g_unif] in
-                                                                    ((FStar_Compiler_List.op_At
-                                                                    ss
-                                                                    [
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    ((g_b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uv_t)]),
-                                                                    uu___11))
-                                                               else
-                                                                 failwith
-                                                                   "Impossible (standard bind with unexpected binder kind)")
-                                                  (subst2, guard) uu___6
-                                                  args2 in
-                                              (match uu___5 with
-                                               | (subst3, guard1) ->
-                                                   (bs4, subst3, guard1)) in
-                                        (match uu___3 with
-                                         | (bs4, subst3, guard1) ->
-                                             let bs5 =
-                                               if has_range_binders
-                                               then
-                                                 let uu___4 =
-                                                   FStar_Compiler_List.splitAt
-                                                     (Prims.of_int (2)) bs4 in
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   uu___4
-                                                   FStar_Pervasives_Native.snd
-                                               else bs4 in
-                                             let bs6 =
-                                               let uu___4 =
-                                                 FStar_Compiler_List.splitAt
-                                                   ((FStar_Compiler_List.length
-                                                       bs5)
-                                                      - (Prims.of_int (2)))
-                                                   bs5 in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___4
-                                                 FStar_Pervasives_Native.fst in
-                                             FStar_Compiler_List.fold_left
-                                               (fun uu___4 ->
-                                                  fun b1 ->
-                                                    match uu___4 with
-                                                    | (ss, g) ->
-                                                        let uu___5 =
-                                                          FStar_TypeChecker_Env.uvars_for_binders
-                                                            env [b1] ss
-                                                            (fun b2 ->
-                                                               if debug
-                                                               then
-                                                                 let uu___6 =
-                                                                   FStar_Syntax_Print.binder_to_string
-                                                                    b2 in
-                                                                 let uu___7 =
-                                                                   bind_name
-                                                                    () in
-                                                                 let uu___8 =
-                                                                   FStar_Compiler_Range.string_of_range
-                                                                    r1 in
-                                                                 FStar_Compiler_Util.format3
-                                                                   "implicit var for additional g binder %s of %s at %s"
-                                                                   uu___6
-                                                                   uu___7
-                                                                   uu___8
-                                                               else
-                                                                 "substitutive_indexed_bind_substs.2")
-                                                            r1 in
-                                                        (match uu___5 with
-                                                         | (uv_t::[], g_uv)
-                                                             ->
-                                                             let uu___6 =
-                                                               FStar_TypeChecker_Env.conj_guard
-                                                                 g g_uv in
-                                                             ((FStar_Compiler_List.op_At
-                                                                 ss
-                                                                 [FStar_Syntax_Syntax.NT
-                                                                    ((b1.FStar_Syntax_Syntax.binder_bv),
-                                                                    uv_t)]),
-                                                               uu___6)))
-                                               (subst3, guard1) bs6)))
-let (ad_hoc_indexed_bind_substs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.eff_decl ->
-        FStar_Syntax_Syntax.eff_decl ->
-          FStar_Syntax_Syntax.binders ->
-            FStar_Syntax_Syntax.comp_typ ->
-              FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                FStar_Syntax_Syntax.comp_typ ->
-                  FStar_Compiler_Range.range ->
-                    Prims.bool ->
-                      (FStar_Syntax_Syntax.subst_elt Prims.list *
-                        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun m_ed ->
-      fun n_ed ->
-        fun p_ed ->
-          fun bs ->
-            fun ct1 ->
-              fun b ->
-                fun ct2 ->
-                  fun r1 ->
-                    fun has_range_binders ->
-                      let debug =
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (FStar_TypeChecker_Env.debug env)
-                          (FStar_Options.Other "LayeredEffectsApp") in
-                      let bind_name uu___ =
-                        if debug
-                        then
-                          let uu___1 =
-                            let uu___2 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                m_ed.FStar_Syntax_Syntax.mname
-                                FStar_Ident.ident_of_lid in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___2
-                              FStar_Ident.string_of_id in
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                n_ed.FStar_Syntax_Syntax.mname
-                                FStar_Ident.ident_of_lid in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___3
-                              FStar_Ident.string_of_id in
-                          let uu___3 =
-                            let uu___4 =
-                              FStar_Compiler_Effect.op_Bar_Greater
-                                p_ed.FStar_Syntax_Syntax.mname
-                                FStar_Ident.ident_of_lid in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___4
-                              FStar_Ident.string_of_id in
-                          FStar_Compiler_Util.format3 "(%s, %s) |> %s" uu___1
-                            uu___2 uu___3
-                        else "" in
-                      let bind_t_shape_error s =
-                        let uu___ =
-                          let uu___1 = bind_name () in
-                          FStar_Compiler_Util.format2
-                            "bind %s does not have proper shape (reason:%s)"
-                            uu___1 s in
-                        (FStar_Errors.Fatal_UnexpectedEffect, uu___) in
-                      let num_range_binders =
-                        if has_range_binders
-                        then (Prims.of_int (2))
-                        else Prims.int_zero in
-                      let uu___ =
-                        if
-                          (FStar_Compiler_List.length bs) >=
-                            (num_range_binders + (Prims.of_int (4)))
-                        then
-                          let uu___1 = bs in
-                          match uu___1 with
-                          | a_b::b_b::bs1 ->
-                              let uu___2 =
-                                let uu___3 =
-                                  FStar_Compiler_List.splitAt
-                                    (((FStar_Compiler_List.length bs1) -
-                                        (Prims.of_int (2)))
-                                       - num_range_binders) bs1 in
-                                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                  (fun uu___4 ->
-                                     match uu___4 with
-                                     | (l1, l2) ->
-                                         let uu___5 =
-                                           FStar_Compiler_List.splitAt
-                                             num_range_binders l2 in
-                                         (match uu___5 with
-                                          | (uu___6, l21) ->
-                                              let uu___7 =
-                                                FStar_Compiler_List.hd l21 in
-                                              let uu___8 =
-                                                let uu___9 =
-                                                  FStar_Compiler_List.tl l21 in
-                                                FStar_Compiler_List.hd uu___9 in
-                                              (l1, uu___7, uu___8))) in
-                              (match uu___2 with
-                               | (rest_bs, f_b, g_b) ->
-                                   (a_b, b_b, rest_bs, f_b, g_b))
-                        else
-                          (let uu___2 =
-                             bind_t_shape_error
-                               "Either not an arrow or not enough binders" in
-                           FStar_Errors.raise_error uu___2 r1) in
-                      match uu___ with
-                      | (a_b, b_b, rest_bs, f_b, g_b) ->
-                          let uu___1 =
-                            FStar_TypeChecker_Env.uvars_for_binders env
-                              rest_bs
-                              [FStar_Syntax_Syntax.NT
-                                 ((a_b.FStar_Syntax_Syntax.binder_bv),
-                                   (ct1.FStar_Syntax_Syntax.result_typ));
-                              FStar_Syntax_Syntax.NT
-                                ((b_b.FStar_Syntax_Syntax.binder_bv),
-                                  (ct2.FStar_Syntax_Syntax.result_typ))]
-                              (fun b1 ->
-                                 if debug
-                                 then
-                                   let uu___2 =
-                                     FStar_Syntax_Print.binder_to_string b1 in
-                                   let uu___3 = bind_name () in
-                                   let uu___4 =
-                                     FStar_Compiler_Range.string_of_range r1 in
-                                   FStar_Compiler_Util.format3
-                                     "implicit var for binder %s of %s at %s"
-                                     uu___2 uu___3 uu___4
-                                 else "ad_hoc_indexed_bind_substs") r1 in
-                          (match uu___1 with
-                           | (rest_bs_uvars, g_uvars) ->
-                               ((let uu___3 =
-                                   FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env)
-                                     (FStar_Options.Other
-                                        "ResolveImplicitsHook") in
-                                 if uu___3
-                                 then
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     rest_bs_uvars
-                                     (FStar_Compiler_List.iter
-                                        (fun t ->
-                                           let uu___4 =
-                                             let uu___5 =
-                                               FStar_Syntax_Subst.compress t in
-                                             uu___5.FStar_Syntax_Syntax.n in
-                                           match uu___4 with
-                                           | FStar_Syntax_Syntax.Tm_uvar
-                                               (u, uu___5) ->
-                                               let uu___6 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   t in
-                                               let uu___7 =
-                                                 match u.FStar_Syntax_Syntax.ctx_uvar_meta
-                                                 with
-                                                 | FStar_Pervasives_Native.Some
-                                                     (FStar_Syntax_Syntax.Ctx_uvar_meta_attr
-                                                     a) ->
-                                                     FStar_Syntax_Print.term_to_string
-                                                       a
-                                                 | uu___8 -> "<no attr>" in
-                                               FStar_Compiler_Util.print2
-                                                 "Generated uvar %s with attribute %s\n"
-                                                 uu___6 uu___7
-                                           | uu___5 ->
-                                               let uu___6 =
-                                                 let uu___7 =
-                                                   FStar_Syntax_Print.term_to_string
-                                                     t in
-                                                 Prims.op_Hat
-                                                   "Impossible, expected a uvar, got : "
-                                                   uu___7 in
-                                               failwith uu___6))
-                                 else ());
-                                (let subst =
-                                   FStar_Compiler_List.map2
-                                     (fun b1 ->
-                                        fun t ->
-                                          FStar_Syntax_Syntax.NT
-                                            ((b1.FStar_Syntax_Syntax.binder_bv),
-                                              t)) (a_b :: b_b :: rest_bs)
-                                     ((ct1.FStar_Syntax_Syntax.result_typ) ::
-                                     (ct2.FStar_Syntax_Syntax.result_typ) ::
-                                     rest_bs_uvars) in
-                                 let f_guard =
-                                   let f_sort_is =
-                                     let uu___3 =
-                                       let uu___4 =
-                                         FStar_Syntax_Subst.compress
-                                           (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                       let uu___5 =
-                                         FStar_Syntax_Util.is_layered m_ed in
-                                       effect_args_from_repr uu___4 uu___5 r1 in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___3
-                                       (FStar_Compiler_List.map
-                                          (FStar_Syntax_Subst.subst subst)) in
-                                   let uu___3 =
-                                     FStar_Compiler_List.map
-                                       FStar_Pervasives_Native.fst
-                                       ct1.FStar_Syntax_Syntax.effect_args in
-                                   FStar_Compiler_List.fold_left2
-                                     (fun g ->
-                                        fun i1 ->
-                                          fun f_i1 ->
-                                            (let uu___5 =
-                                               FStar_Compiler_Effect.op_Less_Bar
-                                                 (FStar_TypeChecker_Env.debug
-                                                    env)
-                                                 (FStar_Options.Other
-                                                    "ResolveImplicitsHook") in
-                                             if uu___5
-                                             then
-                                               let uu___6 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   i1 in
-                                               let uu___7 =
-                                                 FStar_Syntax_Print.term_to_string
-                                                   f_i1 in
-                                               FStar_Compiler_Util.print2
-                                                 "Generating constraint %s = %s\n"
-                                                 uu___6 uu___7
-                                             else ());
-                                            (let uu___5 =
-                                               let uu___6 =
-                                                 let uu___7 = bind_name () in
-                                                 FStar_Pervasives_Native.Some
-                                                   uu___7 in
-                                               FStar_TypeChecker_Rel.layered_effect_teq
-                                                 env i1 f_i1 uu___6 in
-                                             FStar_TypeChecker_Env.conj_guard
-                                               g uu___5))
-                                     FStar_TypeChecker_Env.trivial_guard
-                                     uu___3 f_sort_is in
-                                 let g_guard =
-                                   let x_a =
-                                     match b with
-                                     | FStar_Pervasives_Native.None ->
-                                         FStar_Syntax_Syntax.null_binder
-                                           ct1.FStar_Syntax_Syntax.result_typ
-                                     | FStar_Pervasives_Native.Some x ->
-                                         FStar_Syntax_Syntax.mk_binder
-                                           {
-                                             FStar_Syntax_Syntax.ppname =
-                                               (x.FStar_Syntax_Syntax.ppname);
-                                             FStar_Syntax_Syntax.index =
-                                               (x.FStar_Syntax_Syntax.index);
-                                             FStar_Syntax_Syntax.sort =
-                                               (ct1.FStar_Syntax_Syntax.result_typ)
-                                           } in
-                                   let g_sort_is =
-                                     let uu___3 =
-                                       let uu___4 =
-                                         FStar_Syntax_Subst.compress
-                                           (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                                       uu___4.FStar_Syntax_Syntax.n in
-                                     match uu___3 with
-                                     | FStar_Syntax_Syntax.Tm_arrow (bs1, c)
-                                         ->
-                                         let uu___4 =
-                                           FStar_Syntax_Subst.open_comp bs1 c in
-                                         (match uu___4 with
-                                          | (bs2, c1) ->
-                                              let bs_subst =
-                                                let uu___5 =
-                                                  let uu___6 =
-                                                    let uu___7 =
-                                                      FStar_Compiler_List.hd
-                                                        bs2 in
-                                                    uu___7.FStar_Syntax_Syntax.binder_bv in
-                                                  let uu___7 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      x_a.FStar_Syntax_Syntax.binder_bv
-                                                      FStar_Syntax_Syntax.bv_to_name in
-                                                  (uu___6, uu___7) in
-                                                FStar_Syntax_Syntax.NT uu___5 in
-                                              let c2 =
-                                                FStar_Syntax_Subst.subst_comp
-                                                  [bs_subst] c1 in
-                                              let uu___5 =
-                                                let uu___6 =
-                                                  FStar_Syntax_Subst.compress
-                                                    (FStar_Syntax_Util.comp_result
-                                                       c2) in
-                                                let uu___7 =
-                                                  FStar_Syntax_Util.is_layered
-                                                    n_ed in
-                                                effect_args_from_repr uu___6
-                                                  uu___7 r1 in
-                                              FStar_Compiler_Effect.op_Bar_Greater
-                                                uu___5
-                                                (FStar_Compiler_List.map
-                                                   (FStar_Syntax_Subst.subst
-                                                      subst)))
-                                     | uu___4 ->
-                                         failwith
-                                           "impossible: mk_indexed_bind" in
-                                   let env_g =
-                                     FStar_TypeChecker_Env.push_binders env
-                                       [x_a] in
-                                   let uu___3 =
-                                     let uu___4 =
-                                       FStar_Compiler_List.map
-                                         FStar_Pervasives_Native.fst
-                                         ct2.FStar_Syntax_Syntax.effect_args in
-                                     FStar_Compiler_List.fold_left2
-                                       (fun g ->
-                                          fun i1 ->
-                                            fun g_i1 ->
-                                              (let uu___6 =
-                                                 FStar_Compiler_Effect.op_Less_Bar
-                                                   (FStar_TypeChecker_Env.debug
-                                                      env)
-                                                   (FStar_Options.Other
-                                                      "ResolveImplicitsHook") in
-                                               if uu___6
-                                               then
-                                                 let uu___7 =
-                                                   FStar_Syntax_Print.term_to_string
-                                                     i1 in
-                                                 let uu___8 =
-                                                   FStar_Syntax_Print.term_to_string
-                                                     g_i1 in
-                                                 FStar_Compiler_Util.print2
-                                                   "Generating constraint %s = %s\n"
-                                                   uu___7 uu___8
-                                               else ());
-                                              (let uu___6 =
-                                                 let uu___7 =
-                                                   let uu___8 = bind_name () in
-                                                   FStar_Pervasives_Native.Some
-                                                     uu___8 in
-                                                 FStar_TypeChecker_Rel.layered_effect_teq
-                                                   env_g i1 g_i1 uu___7 in
-                                               FStar_TypeChecker_Env.conj_guard
-                                                 g uu___6))
-                                       FStar_TypeChecker_Env.trivial_guard
-                                       uu___4 g_sort_is in
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     uu___3
-                                     (FStar_TypeChecker_Env.close_guard env
-                                        [x_a]) in
-                                 let uu___3 =
-                                   FStar_TypeChecker_Env.conj_guards
-                                     [g_uvars; f_guard; g_guard] in
-                                 (subst, uu___3))))
-let (mk_indexed_return :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun ed ->
-      fun u_a ->
-        fun a ->
-          fun e ->
-            fun r ->
-              let debug =
-                FStar_Compiler_Effect.op_Less_Bar
-                  (FStar_TypeChecker_Env.debug env)
-                  (FStar_Options.Other "LayeredEffectsApp") in
-              if debug
-              then
-                (let uu___1 =
-                   FStar_Ident.string_of_lid ed.FStar_Syntax_Syntax.mname in
-                 let uu___2 = FStar_Syntax_Print.univ_to_string u_a in
-                 let uu___3 = FStar_Syntax_Print.term_to_string a in
-                 let uu___4 = FStar_Syntax_Print.term_to_string e in
-                 FStar_Compiler_Util.print4
-                   "Computing %s.return for u_a:%s, a:%s, and e:%s{\n" uu___1
-                   uu___2 uu___3 uu___4)
-              else ();
-              (let uu___1 =
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater ed
-                     FStar_Syntax_Util.get_return_vc_combinator in
-                 FStar_TypeChecker_Env.inst_tscheme_with uu___2 [u_a] in
-               match uu___1 with
-               | (uu___2, return_t) ->
-                   let return_t_shape_error s =
-                     let uu___3 =
-                       let uu___4 =
-                         FStar_Ident.string_of_lid
-                           ed.FStar_Syntax_Syntax.mname in
-                       let uu___5 =
-                         FStar_Syntax_Print.term_to_string return_t in
-                       FStar_Compiler_Util.format3
-                         "%s.return %s does not have proper shape (reason:%s)"
-                         uu___4 uu___5 s in
-                     (FStar_Errors.Fatal_UnexpectedEffect, uu___3) in
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_Syntax_Subst.compress return_t in
-                       uu___5.FStar_Syntax_Syntax.n in
-                     match uu___4 with
-                     | FStar_Syntax_Syntax.Tm_arrow (bs, c) when
-                         (FStar_Compiler_List.length bs) >=
-                           (Prims.of_int (2))
-                         ->
-                         let uu___5 = FStar_Syntax_Subst.open_comp bs c in
-                         (match uu___5 with
-                          | (a_b::x_b::bs1, c1) ->
-                              (a_b, x_b, bs1,
-                                (FStar_Syntax_Util.comp_result c1)))
-                     | uu___5 ->
-                         let uu___6 =
-                           return_t_shape_error
-                             "Either not an arrow or not enough binders" in
-                         FStar_Errors.raise_error uu___6 r in
-                   (match uu___3 with
-                    | (a_b, x_b, rest_bs, return_typ) ->
-                        let uu___4 =
-                          FStar_TypeChecker_Env.uvars_for_binders env rest_bs
-                            [FStar_Syntax_Syntax.NT
-                               ((a_b.FStar_Syntax_Syntax.binder_bv), a);
-                            FStar_Syntax_Syntax.NT
-                              ((x_b.FStar_Syntax_Syntax.binder_bv), e)]
-                            (fun b ->
-                               if debug
-                               then
-                                 let uu___5 =
-                                   FStar_Syntax_Print.binder_to_string b in
-                                 let uu___6 =
-                                   let uu___7 =
-                                     FStar_Ident.string_of_lid
-                                       ed.FStar_Syntax_Syntax.mname in
-                                   FStar_Compiler_Util.format1 "%s.return"
-                                     uu___7 in
-                                 let uu___7 =
-                                   FStar_Compiler_Range.string_of_range r in
-                                 FStar_Compiler_Util.format3
-                                   "implicit var for binder %s of %s at %s"
-                                   uu___5 uu___6 uu___7
-                               else "mk_indexed_return_env") r in
-                        (match uu___4 with
-                         | (rest_bs_uvars, g_uvars) ->
-                             let subst =
-                               FStar_Compiler_List.map2
-                                 (fun b ->
-                                    fun t ->
-                                      FStar_Syntax_Syntax.NT
-                                        ((b.FStar_Syntax_Syntax.binder_bv),
-                                          t)) (a_b :: x_b :: rest_bs) (a :: e
-                                 :: rest_bs_uvars) in
-                             let is =
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Syntax_Subst.compress return_typ in
-                                 let uu___7 = FStar_Syntax_Util.is_layered ed in
-                                 effect_args_from_repr uu___6 uu___7 r in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                 (FStar_Compiler_List.map
-                                    (FStar_Syntax_Subst.subst subst)) in
-                             let c =
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Compiler_Effect.op_Bar_Greater is
-                                     (FStar_Compiler_List.map
-                                        FStar_Syntax_Syntax.as_arg) in
-                                 {
-                                   FStar_Syntax_Syntax.comp_univs = [u_a];
-                                   FStar_Syntax_Syntax.effect_name =
-                                     (ed.FStar_Syntax_Syntax.mname);
-                                   FStar_Syntax_Syntax.result_typ = a;
-                                   FStar_Syntax_Syntax.effect_args = uu___6;
-                                   FStar_Syntax_Syntax.flags = []
-                                 } in
-                               FStar_Syntax_Syntax.mk_Comp uu___5 in
-                             (if debug
-                              then
-                                (let uu___6 =
-                                   FStar_Syntax_Print.comp_to_string c in
-                                 FStar_Compiler_Util.print1
-                                   "} c after return %s\n" uu___6)
-                              else ();
-                              (c, g_uvars)))))
-let (mk_indexed_bind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.tscheme ->
-            FStar_Syntax_Syntax.indexed_effect_combinator_kind ->
-              FStar_Syntax_Syntax.comp_typ ->
-                FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-                  FStar_Syntax_Syntax.comp_typ ->
-                    FStar_Syntax_Syntax.cflag Prims.list ->
-                      FStar_Compiler_Range.range ->
-                        Prims.int ->
-                          Prims.bool ->
-                            (FStar_Syntax_Syntax.comp *
-                              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun m ->
-      fun n ->
-        fun p ->
-          fun bind_t ->
-            fun bind_combinator_kind ->
-              fun ct1 ->
-                fun b ->
-                  fun ct2 ->
-                    fun flags ->
-                      fun r1 ->
-                        fun num_effect_params ->
-                          fun has_range_binders ->
-                            let debug =
-                              FStar_Compiler_Effect.op_Less_Bar
-                                (FStar_TypeChecker_Env.debug env)
-                                (FStar_Options.Other "LayeredEffectsApp") in
-                            if debug
-                            then
-                              (let uu___1 =
-                                 let uu___2 = FStar_Syntax_Syntax.mk_Comp ct1 in
-                                 FStar_Syntax_Print.comp_to_string uu___2 in
-                               let uu___2 =
-                                 let uu___3 = FStar_Syntax_Syntax.mk_Comp ct2 in
-                                 FStar_Syntax_Print.comp_to_string uu___3 in
-                               FStar_Compiler_Util.print2
-                                 "Binding indexed effects: c1:%s and c2:%s {\n"
-                                 uu___1 uu___2)
-                            else ();
-                            (let uu___2 =
-                               FStar_Compiler_Effect.op_Less_Bar
-                                 (FStar_TypeChecker_Env.debug env)
-                                 (FStar_Options.Other "ResolveImplicitsHook") in
-                             if uu___2
-                             then
-                               let uu___3 =
-                                 let uu___4 =
-                                   FStar_TypeChecker_Env.get_range env in
-                                 FStar_Compiler_Range.string_of_range uu___4 in
-                               let uu___4 =
-                                 FStar_Syntax_Print.tscheme_to_string bind_t in
-                               FStar_Compiler_Util.print2
-                                 "///////////////////////////////Bind at %s/////////////////////\nwith bind_t = %s\n"
-                                 uu___3 uu___4
-                             else ());
-                            (let uu___2 =
-                               let uu___3 =
-                                 FStar_TypeChecker_Env.get_effect_decl env m in
-                               let uu___4 =
-                                 FStar_TypeChecker_Env.get_effect_decl env n in
-                               let uu___5 =
-                                 FStar_TypeChecker_Env.get_effect_decl env p in
-                               (uu___3, uu___4, uu___5) in
-                             match uu___2 with
-                             | (m_ed, n_ed, p_ed) ->
-                                 let bind_name uu___3 =
-                                   let uu___4 =
-                                     let uu___5 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         m_ed.FStar_Syntax_Syntax.mname
-                                         FStar_Ident.ident_of_lid in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___5 FStar_Ident.string_of_id in
-                                   let uu___5 =
-                                     let uu___6 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         n_ed.FStar_Syntax_Syntax.mname
-                                         FStar_Ident.ident_of_lid in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___6 FStar_Ident.string_of_id in
-                                   let uu___6 =
-                                     let uu___7 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         p_ed.FStar_Syntax_Syntax.mname
-                                         FStar_Ident.ident_of_lid in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___7 FStar_Ident.string_of_id in
-                                   FStar_Compiler_Util.format3
-                                     "(%s, %s) |> %s" uu___4 uu___5 uu___6 in
-                                 ((let uu___4 =
-                                     (((FStar_TypeChecker_Env.is_erasable_effect
-                                          env m)
-                                         &&
-                                         (let uu___5 =
-                                            FStar_TypeChecker_Env.is_erasable_effect
-                                              env p in
-                                          Prims.op_Negation uu___5))
-                                        &&
-                                        (let uu___5 =
-                                           FStar_TypeChecker_Normalize.non_info_norm
-                                             env
-                                             ct1.FStar_Syntax_Syntax.result_typ in
-                                         Prims.op_Negation uu___5))
-                                       ||
-                                       (((FStar_TypeChecker_Env.is_erasable_effect
-                                            env n)
-                                           &&
-                                           (let uu___5 =
-                                              FStar_TypeChecker_Env.is_erasable_effect
-                                                env p in
-                                            Prims.op_Negation uu___5))
-                                          &&
-                                          (let uu___5 =
-                                             FStar_TypeChecker_Normalize.non_info_norm
-                                               env
-                                               ct2.FStar_Syntax_Syntax.result_typ in
-                                           Prims.op_Negation uu___5)) in
-                                   if uu___4
-                                   then
-                                     let uu___5 =
-                                       let uu___6 =
-                                         let uu___7 = bind_name () in
-                                         let uu___8 =
-                                           FStar_Ident.string_of_lid p in
-                                         FStar_Compiler_Util.format2
-                                           "Cannot apply bind %s since %s is not erasable and one of the computations is informative"
-                                           uu___7 uu___8 in
-                                       (FStar_Errors.Fatal_UnexpectedEffect,
-                                         uu___6) in
-                                     FStar_Errors.raise_error uu___5 r1
-                                   else ());
-                                  (let uu___4 =
-                                     let uu___5 =
-                                       let uu___6 =
-                                         FStar_Compiler_List.hd
-                                           ct1.FStar_Syntax_Syntax.comp_univs in
-                                       let uu___7 =
-                                         let uu___8 =
-                                           FStar_Compiler_List.hd
-                                             ct2.FStar_Syntax_Syntax.comp_univs in
-                                         [uu___8] in
-                                       uu___6 :: uu___7 in
-                                     FStar_TypeChecker_Env.inst_tscheme_with
-                                       bind_t uu___5 in
-                                   match uu___4 with
-                                   | (uu___5, bind_t1) ->
-                                       let uu___6 =
-                                         FStar_Syntax_Util.arrow_formals_comp
-                                           bind_t1 in
-                                       (match uu___6 with
-                                        | (bind_t_bs, bind_c) ->
-                                            let uu___7 =
-                                              if
-                                                bind_combinator_kind =
-                                                  FStar_Syntax_Syntax.Ad_hoc_combinator
-                                              then
-                                                ad_hoc_indexed_bind_substs
-                                                  env m_ed n_ed p_ed
-                                                  bind_t_bs ct1 b ct2 r1
-                                                  has_range_binders
-                                              else
-                                                (let uu___9 =
-                                                   bind_combinator_kind in
-                                                 match uu___9 with
-                                                 | FStar_Syntax_Syntax.Substitutive_combinator
-                                                     binder_kinds ->
-                                                     substitutive_indexed_bind_substs
-                                                       env m_ed n_ed p_ed
-                                                       bind_t_bs binder_kinds
-                                                       ct1 b ct2 r1
-                                                       num_effect_params
-                                                       has_range_binders) in
-                                            (match uu___7 with
-                                             | (subst, g) ->
-                                                 let bind_ct =
-                                                   let uu___8 =
-                                                     FStar_Compiler_Effect.op_Bar_Greater
-                                                       bind_c
-                                                       (FStar_Syntax_Subst.subst_comp
-                                                          subst) in
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uu___8
-                                                     (FStar_TypeChecker_Env.comp_to_comp_typ
-                                                        env) in
-                                                 let fml =
-                                                   let uu___8 =
-                                                     let uu___9 =
-                                                       FStar_Compiler_List.hd
-                                                         bind_ct.FStar_Syntax_Syntax.comp_univs in
-                                                     let uu___10 =
-                                                       let uu___11 =
-                                                         FStar_Compiler_List.hd
-                                                           bind_ct.FStar_Syntax_Syntax.effect_args in
-                                                       FStar_Pervasives_Native.fst
-                                                         uu___11 in
-                                                     (uu___9, uu___10) in
-                                                   match uu___8 with
-                                                   | (u, wp) ->
-                                                       FStar_TypeChecker_Env.pure_precondition_for_trivial_post
-                                                         env u
-                                                         bind_ct.FStar_Syntax_Syntax.result_typ
-                                                         wp
-                                                         FStar_Compiler_Range.dummyRange in
-                                                 let is =
-                                                   let uu___8 =
-                                                     FStar_Syntax_Subst.compress
-                                                       bind_ct.FStar_Syntax_Syntax.result_typ in
-                                                   let uu___9 =
-                                                     FStar_Syntax_Util.is_layered
-                                                       p_ed in
-                                                   effect_args_from_repr
-                                                     uu___8 uu___9 r1 in
-                                                 let c =
-                                                   let uu___8 =
-                                                     let uu___9 =
-                                                       FStar_Compiler_List.map
-                                                         FStar_Syntax_Syntax.as_arg
-                                                         is in
-                                                     {
-                                                       FStar_Syntax_Syntax.comp_univs
-                                                         =
-                                                         (ct2.FStar_Syntax_Syntax.comp_univs);
-                                                       FStar_Syntax_Syntax.effect_name
-                                                         =
-                                                         (p_ed.FStar_Syntax_Syntax.mname);
-                                                       FStar_Syntax_Syntax.result_typ
-                                                         =
-                                                         (ct2.FStar_Syntax_Syntax.result_typ);
-                                                       FStar_Syntax_Syntax.effect_args
-                                                         = uu___9;
-                                                       FStar_Syntax_Syntax.flags
-                                                         = flags
-                                                     } in
-                                                   FStar_Syntax_Syntax.mk_Comp
-                                                     uu___8 in
-                                                 (if debug
-                                                  then
-                                                    (let uu___9 =
-                                                       FStar_Syntax_Print.comp_to_string
-                                                         c in
-                                                     FStar_Compiler_Util.print1
-                                                       "} c after bind: %s\n"
-                                                       uu___9)
-                                                  else ();
-                                                  (let guard =
-                                                     let uu___9 =
-                                                       let uu___10 =
-                                                         let uu___11 =
-                                                           FStar_TypeChecker_Env.guard_of_guard_formula
-                                                             (FStar_TypeChecker_Common.NonTrivial
-                                                                fml) in
-                                                         [uu___11] in
-                                                       g :: uu___10 in
-                                                     FStar_TypeChecker_Env.conj_guards
-                                                       uu___9 in
-                                                   (let uu___10 =
-                                                      FStar_Compiler_Effect.op_Less_Bar
-                                                        (FStar_TypeChecker_Env.debug
-                                                           env)
-                                                        (FStar_Options.Other
-                                                           "ResolveImplicitsHook") in
-                                                    if uu___10
-                                                    then
-                                                      let uu___11 =
-                                                        let uu___12 =
-                                                          FStar_TypeChecker_Env.get_range
-                                                            env in
-                                                        FStar_Compiler_Range.string_of_range
-                                                          uu___12 in
-                                                      let uu___12 =
-                                                        FStar_TypeChecker_Rel.guard_to_string
-                                                          env guard in
-                                                      FStar_Compiler_Util.print2
-                                                        "///////////////////////////////EndBind at %s/////////////////////\nguard = %s\n"
-                                                        uu___11 uu___12
-                                                    else ());
-                                                   (c, guard))))))))
-let (mk_wp_bind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.comp_typ ->
-        FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-          FStar_Syntax_Syntax.comp_typ ->
-            FStar_Syntax_Syntax.cflag Prims.list ->
-              FStar_Compiler_Range.range -> FStar_Syntax_Syntax.comp)
-  =
-  fun env ->
-    fun m ->
-      fun ct1 ->
-        fun b ->
-          fun ct2 ->
-            fun flags ->
-              fun r1 ->
-                let uu___ =
-                  let md = FStar_TypeChecker_Env.get_effect_decl env m in
-                  let uu___1 = FStar_TypeChecker_Env.wp_signature env m in
-                  match uu___1 with
-                  | (a, kwp) ->
-                      let uu___2 = destruct_wp_comp ct1 in
-                      let uu___3 = destruct_wp_comp ct2 in
-                      ((md, a, kwp), uu___2, uu___3) in
-                match uu___ with
-                | ((md, a, kwp), (u_t1, t1, wp1), (u_t2, t2, wp2)) ->
-                    let bs =
-                      match b with
-                      | FStar_Pervasives_Native.None ->
-                          let uu___1 = FStar_Syntax_Syntax.null_binder t1 in
-                          [uu___1]
-                      | FStar_Pervasives_Native.Some x ->
-                          let uu___1 = FStar_Syntax_Syntax.mk_binder x in
-                          [uu___1] in
-                    let mk_lam wp =
-                      FStar_Syntax_Util.abs bs wp
-                        (FStar_Pervasives_Native.Some
-                           (FStar_Syntax_Util.mk_residual_comp
-                              FStar_Parser_Const.effect_Tot_lid
-                              FStar_Pervasives_Native.None
-                              [FStar_Syntax_Syntax.TOTAL])) in
-                    let wp_args =
-                      let uu___1 = FStar_Syntax_Syntax.as_arg t1 in
-                      let uu___2 =
-                        let uu___3 = FStar_Syntax_Syntax.as_arg t2 in
-                        let uu___4 =
-                          let uu___5 = FStar_Syntax_Syntax.as_arg wp1 in
-                          let uu___6 =
-                            let uu___7 =
-                              let uu___8 = mk_lam wp2 in
-                              FStar_Syntax_Syntax.as_arg uu___8 in
-                            [uu___7] in
-                          uu___5 :: uu___6 in
-                        uu___3 :: uu___4 in
-                      uu___1 :: uu___2 in
-                    let uu___1 =
-                      FStar_Compiler_Effect.op_Bar_Greater md
-                        FStar_Syntax_Util.get_bind_vc_combinator in
-                    (match uu___1 with
-                     | (bind_wp, uu___2) ->
-                         let wp =
-                           let uu___3 =
-                             FStar_TypeChecker_Env.inst_effect_fun_with
-                               [u_t1; u_t2] env md bind_wp in
-                           FStar_Syntax_Syntax.mk_Tm_app uu___3 wp_args
-                             t2.FStar_Syntax_Syntax.pos in
-                         mk_comp md u_t2 t2 wp flags)
-let (mk_bind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.bv FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.comp ->
-          FStar_Syntax_Syntax.cflag Prims.list ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c1 ->
-      fun b ->
-        fun c2 ->
-          fun flags ->
-            fun r1 ->
-              let env2 = maybe_push env b in
-              let uu___ =
-                let uu___1 =
-                  FStar_TypeChecker_Env.unfold_effect_abbrev env c1 in
-                let uu___2 =
-                  FStar_TypeChecker_Env.unfold_effect_abbrev env2 c2 in
-                (uu___1, uu___2) in
-              match uu___ with
-              | (ct1, ct2) ->
-                  let uu___1 =
-                    FStar_TypeChecker_Env.exists_polymonadic_bind env
-                      ct1.FStar_Syntax_Syntax.effect_name
-                      ct2.FStar_Syntax_Syntax.effect_name in
-                  (match uu___1 with
-                   | FStar_Pervasives_Native.Some (p, f_bind) ->
-                       f_bind env ct1 b ct2 flags r1
-                   | FStar_Pervasives_Native.None ->
-                       let uu___2 = lift_comps env c1 c2 b true in
-                       (match uu___2 with
-                        | (m, c11, c21, g_lift) ->
-                            let uu___3 =
-                              let uu___4 =
-                                FStar_TypeChecker_Env.comp_to_comp_typ env
-                                  c11 in
-                              let uu___5 =
-                                FStar_TypeChecker_Env.comp_to_comp_typ env2
-                                  c21 in
-                              (uu___4, uu___5) in
-                            (match uu___3 with
-                             | (ct11, ct21) ->
-                                 let uu___4 =
-                                   let uu___5 =
-                                     FStar_TypeChecker_Env.is_layered_effect
-                                       env m in
-                                   if uu___5
-                                   then
-                                     let m_ed =
-                                       FStar_Compiler_Effect.op_Bar_Greater m
-                                         (FStar_TypeChecker_Env.get_effect_decl
-                                            env) in
-                                     let num_effect_params =
-                                       match m_ed.FStar_Syntax_Syntax.signature
-                                       with
-                                       | FStar_Syntax_Syntax.Layered_eff_sig
-                                           (n, uu___6) -> n
-                                       | uu___6 ->
-                                           failwith
-                                             "Impossible (mk_bind expected an indexed effect)" in
-                                     let uu___6 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         m_ed
-                                         FStar_Syntax_Util.get_bind_vc_combinator in
-                                     match uu___6 with
-                                     | (bind_t, bind_kind) ->
-                                         let has_range_args =
-                                           FStar_Syntax_Util.has_attribute
-                                             m_ed.FStar_Syntax_Syntax.eff_attrs
-                                             FStar_Parser_Const.bind_has_range_args_attr in
-                                         let uu___7 =
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             bind_kind
-                                             FStar_Compiler_Util.must in
-                                         mk_indexed_bind env m m m bind_t
-                                           uu___7 ct11 b ct21 flags r1
-                                           num_effect_params has_range_args
-                                   else
-                                     (let uu___7 =
-                                        mk_wp_bind env m ct11 b ct21 flags r1 in
-                                      (uu___7,
-                                        FStar_TypeChecker_Env.trivial_guard)) in
-                                 (match uu___4 with
-                                  | (c, g_bind) ->
-                                      let uu___5 =
-                                        FStar_TypeChecker_Env.conj_guard
-                                          g_lift g_bind in
-                                      (c, uu___5)))))
-let (strengthen_comp :
-  FStar_TypeChecker_Env.env ->
-    (unit -> Prims.string) FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.comp ->
-        FStar_Syntax_Syntax.formula ->
-          FStar_Syntax_Syntax.cflag Prims.list ->
-            (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun reason ->
-      fun c ->
-        fun f ->
-          fun flags ->
-            let uu___ =
-              env.FStar_TypeChecker_Env.lax ||
-                (FStar_TypeChecker_Env.too_early_in_prims env) in
-            if uu___
-            then (c, FStar_TypeChecker_Env.trivial_guard)
-            else
-              (let r = FStar_TypeChecker_Env.get_range env in
-               let pure_assert_wp =
-                 let uu___2 =
-                   FStar_Syntax_Syntax.lid_as_fv
-                     FStar_Parser_Const.pure_assert_wp_lid
-                     (FStar_Syntax_Syntax.Delta_constant_at_level
-                        Prims.int_one) FStar_Pervasives_Native.None in
-                 FStar_Syntax_Syntax.fv_to_tm uu___2 in
-               let pure_assert_wp1 =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 = label_opt env reason r f in
-                     FStar_Compiler_Effect.op_Less_Bar
-                       FStar_Syntax_Syntax.as_arg uu___4 in
-                   [uu___3] in
-                 FStar_Syntax_Syntax.mk_Tm_app pure_assert_wp uu___2 r in
-               let r1 = FStar_TypeChecker_Env.get_range env in
-               let pure_c =
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Compiler_Effect.op_Bar_Greater pure_assert_wp1
-                         FStar_Syntax_Syntax.as_arg in
-                     [uu___4] in
-                   {
-                     FStar_Syntax_Syntax.comp_univs =
-                       [FStar_Syntax_Syntax.U_zero];
-                     FStar_Syntax_Syntax.effect_name =
-                       FStar_Parser_Const.effect_PURE_lid;
-                     FStar_Syntax_Syntax.result_typ =
-                       FStar_Syntax_Syntax.t_unit;
-                     FStar_Syntax_Syntax.effect_args = uu___3;
-                     FStar_Syntax_Syntax.flags = []
-                   } in
-                 FStar_Syntax_Syntax.mk_Comp uu___2 in
-               mk_bind env pure_c FStar_Pervasives_Native.None c flags r1)
-let (mk_return :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Compiler_Range.range ->
-              (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun ed ->
-      fun u_a ->
-        fun a ->
-          fun e ->
-            fun r ->
-              let uu___ =
-                FStar_Compiler_Effect.op_Bar_Greater ed
-                  FStar_Syntax_Util.is_layered in
-              if uu___
-              then mk_indexed_return env ed u_a a e r
-              else
-                (let uu___2 = mk_wp_return env ed u_a a e r in
-                 (uu___2, FStar_TypeChecker_Env.trivial_guard))
-let (return_value :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option ->
-        FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax ->
-            (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun eff_lid ->
-      fun u_t_opt ->
-        fun t ->
-          fun v ->
-            let u =
-              match u_t_opt with
-              | FStar_Pervasives_Native.None ->
-                  env.FStar_TypeChecker_Env.universe_of env t
-              | FStar_Pervasives_Native.Some u1 -> u1 in
-            let uu___ = FStar_TypeChecker_Env.get_effect_decl env eff_lid in
-            mk_return env uu___ u t v v.FStar_Syntax_Syntax.pos
-let (weaken_flags :
-  FStar_Syntax_Syntax.cflag Prims.list ->
-    FStar_Syntax_Syntax.cflag Prims.list)
-  =
-  fun flags ->
-    let uu___ =
-      FStar_Compiler_Effect.op_Bar_Greater flags
-        (FStar_Compiler_Util.for_some
-           (fun uu___1 ->
-              match uu___1 with
-              | FStar_Syntax_Syntax.SHOULD_NOT_INLINE -> true
-              | uu___2 -> false)) in
-    if uu___
-    then [FStar_Syntax_Syntax.SHOULD_NOT_INLINE]
-    else
-      FStar_Compiler_Effect.op_Bar_Greater flags
-        (FStar_Compiler_List.collect
-           (fun uu___2 ->
-              match uu___2 with
-              | FStar_Syntax_Syntax.TOTAL ->
-                  [FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION]
-              | FStar_Syntax_Syntax.RETURN ->
-                  [FStar_Syntax_Syntax.PARTIAL_RETURN;
-                  FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION]
-              | f -> [f]))
-let (weaken_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c ->
-      fun formula ->
-        let uu___ = FStar_Syntax_Util.is_ml_comp c in
-        if uu___
-        then (c, FStar_TypeChecker_Env.trivial_guard)
-        else
-          (let ct = FStar_TypeChecker_Env.unfold_effect_abbrev env c in
-           let pure_assume_wp =
-             let uu___2 =
-               FStar_Syntax_Syntax.lid_as_fv
-                 FStar_Parser_Const.pure_assume_wp_lid
-                 (FStar_Syntax_Syntax.Delta_constant_at_level Prims.int_one)
-                 FStar_Pervasives_Native.None in
-             FStar_Syntax_Syntax.fv_to_tm uu___2 in
-           let pure_assume_wp1 =
-             let uu___2 =
-               let uu___3 =
-                 FStar_Compiler_Effect.op_Less_Bar FStar_Syntax_Syntax.as_arg
-                   formula in
-               [uu___3] in
-             let uu___3 = FStar_TypeChecker_Env.get_range env in
-             FStar_Syntax_Syntax.mk_Tm_app pure_assume_wp uu___2 uu___3 in
-           let r = FStar_TypeChecker_Env.get_range env in
-           let pure_c =
-             let uu___2 =
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Compiler_Effect.op_Bar_Greater pure_assume_wp1
-                     FStar_Syntax_Syntax.as_arg in
-                 [uu___4] in
-               {
-                 FStar_Syntax_Syntax.comp_univs =
-                   [FStar_Syntax_Syntax.U_zero];
-                 FStar_Syntax_Syntax.effect_name =
-                   FStar_Parser_Const.effect_PURE_lid;
-                 FStar_Syntax_Syntax.result_typ = FStar_Syntax_Syntax.t_unit;
-                 FStar_Syntax_Syntax.effect_args = uu___3;
-                 FStar_Syntax_Syntax.flags = []
-               } in
-             FStar_Syntax_Syntax.mk_Comp uu___2 in
-           let uu___2 = weaken_flags ct.FStar_Syntax_Syntax.flags in
-           mk_bind env pure_c FStar_Pervasives_Native.None c uu___2 r)
-let (weaken_precondition :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Common.lcomp ->
-      FStar_TypeChecker_Common.guard_formula ->
-        FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun lc ->
-      fun f ->
-        let weaken uu___ =
-          let uu___1 = FStar_TypeChecker_Common.lcomp_comp lc in
-          match uu___1 with
-          | (c, g_c) ->
-              let uu___2 =
-                env.FStar_TypeChecker_Env.lax && (FStar_Options.ml_ish ()) in
-              if uu___2
-              then (c, g_c)
-              else
-                (match f with
-                 | FStar_TypeChecker_Common.Trivial -> (c, g_c)
-                 | FStar_TypeChecker_Common.NonTrivial f1 ->
-                     let uu___4 = weaken_comp env c f1 in
-                     (match uu___4 with
-                      | (c1, g_w) ->
-                          let uu___5 =
-                            FStar_TypeChecker_Env.conj_guard g_c g_w in
-                          (c1, uu___5))) in
-        let uu___ = weaken_flags lc.FStar_TypeChecker_Common.cflags in
-        FStar_TypeChecker_Common.mk_lcomp
-          lc.FStar_TypeChecker_Common.eff_name
-          lc.FStar_TypeChecker_Common.res_typ uu___ weaken
-let (strengthen_precondition :
-  (unit -> Prims.string) FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term ->
-        FStar_TypeChecker_Common.lcomp ->
-          FStar_TypeChecker_Env.guard_t ->
-            (FStar_TypeChecker_Common.lcomp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun reason ->
-    fun env ->
-      fun e_for_debugging_only ->
-        fun lc ->
-          fun g0 ->
-            let uu___ = FStar_TypeChecker_Env.is_trivial_guard_formula g0 in
-            if uu___
-            then (lc, g0)
-            else
-              (let flags =
-                 let uu___2 =
-                   let uu___3 =
-                     FStar_TypeChecker_Common.is_tot_or_gtot_lcomp lc in
-                   if uu___3
-                   then (true, [FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION])
-                   else (false, []) in
-                 match uu___2 with
-                 | (maybe_trivial_post, flags1) ->
-                     let uu___3 =
-                       FStar_Compiler_Effect.op_Bar_Greater
-                         lc.FStar_TypeChecker_Common.cflags
-                         (FStar_Compiler_List.collect
-                            (fun uu___4 ->
-                               match uu___4 with
-                               | FStar_Syntax_Syntax.RETURN ->
-                                   [FStar_Syntax_Syntax.PARTIAL_RETURN]
-                               | FStar_Syntax_Syntax.PARTIAL_RETURN ->
-                                   [FStar_Syntax_Syntax.PARTIAL_RETURN]
-                               | FStar_Syntax_Syntax.SOMETRIVIAL when
-                                   Prims.op_Negation maybe_trivial_post ->
-                                   [FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION]
-                               | FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION
-                                   when Prims.op_Negation maybe_trivial_post
-                                   ->
-                                   [FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION]
-                               | FStar_Syntax_Syntax.SHOULD_NOT_INLINE ->
-                                   [FStar_Syntax_Syntax.SHOULD_NOT_INLINE]
-                               | uu___5 -> [])) in
-                     FStar_Compiler_List.op_At flags1 uu___3 in
-               let strengthen uu___2 =
-                 let uu___3 = FStar_TypeChecker_Common.lcomp_comp lc in
-                 match uu___3 with
-                 | (c, g_c) ->
-                     if env.FStar_TypeChecker_Env.lax
-                     then (c, g_c)
-                     else
-                       (let g01 = FStar_TypeChecker_Rel.simplify_guard env g0 in
-                        let uu___5 = FStar_TypeChecker_Env.guard_form g01 in
-                        match uu___5 with
-                        | FStar_TypeChecker_Common.Trivial -> (c, g_c)
-                        | FStar_TypeChecker_Common.NonTrivial f ->
-                            ((let uu___7 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env)
-                                  FStar_Options.Extreme in
-                              if uu___7
-                              then
-                                let uu___8 =
-                                  FStar_TypeChecker_Normalize.term_to_string
-                                    env e_for_debugging_only in
-                                let uu___9 =
-                                  FStar_TypeChecker_Normalize.term_to_string
-                                    env f in
-                                FStar_Compiler_Util.print2
-                                  "-------------Strengthening pre-condition of term %s with guard %s\n"
-                                  uu___8 uu___9
-                              else ());
-                             (let uu___7 =
-                                strengthen_comp env reason c f flags in
-                              match uu___7 with
-                              | (c1, g_s) ->
-                                  let uu___8 =
-                                    FStar_TypeChecker_Env.conj_guard g_c g_s in
-                                  (c1, uu___8)))) in
-               let uu___2 =
-                 let uu___3 =
-                   FStar_TypeChecker_Env.norm_eff_name env
-                     lc.FStar_TypeChecker_Common.eff_name in
-                 FStar_TypeChecker_Common.mk_lcomp uu___3
-                   lc.FStar_TypeChecker_Common.res_typ flags strengthen in
-               (uu___2,
-                 {
-                   FStar_TypeChecker_Common.guard_f =
-                     FStar_TypeChecker_Common.Trivial;
-                   FStar_TypeChecker_Common.deferred_to_tac =
-                     (g0.FStar_TypeChecker_Common.deferred_to_tac);
-                   FStar_TypeChecker_Common.deferred =
-                     (g0.FStar_TypeChecker_Common.deferred);
-                   FStar_TypeChecker_Common.univ_ineqs =
-                     (g0.FStar_TypeChecker_Common.univ_ineqs);
-                   FStar_TypeChecker_Common.implicits =
-                     (g0.FStar_TypeChecker_Common.implicits)
-                 }))
-let (lcomp_has_trivial_postcondition :
-  FStar_TypeChecker_Common.lcomp -> Prims.bool) =
-  fun lc ->
-    (FStar_TypeChecker_Common.is_tot_or_gtot_lcomp lc) ||
-      (FStar_Compiler_Util.for_some
-         (fun uu___ ->
-            match uu___ with
-            | FStar_Syntax_Syntax.SOMETRIVIAL -> true
-            | FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION -> true
-            | uu___1 -> false) lc.FStar_TypeChecker_Common.cflags)
-let (maybe_add_with_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.universe FStar_Pervasives_Native.option ->
-      FStar_TypeChecker_Common.lcomp ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.term' FStar_Syntax_Syntax.syntax)
-  =
-  fun env ->
-    fun uopt ->
-      fun lc ->
-        fun e ->
-          let uu___ =
-            (FStar_TypeChecker_Common.is_lcomp_partial_return lc) ||
-              env.FStar_TypeChecker_Env.lax in
-          if uu___
-          then e
-          else
-            (let uu___2 =
-               (lcomp_has_trivial_postcondition lc) &&
-                 (let uu___3 =
-                    FStar_TypeChecker_Env.try_lookup_lid env
-                      FStar_Parser_Const.with_type_lid in
-                  FStar_Compiler_Option.isSome uu___3) in
-             if uu___2
-             then
-               let u =
-                 match uopt with
-                 | FStar_Pervasives_Native.Some u1 -> u1
-                 | FStar_Pervasives_Native.None ->
-                     env.FStar_TypeChecker_Env.universe_of env
-                       lc.FStar_TypeChecker_Common.res_typ in
-               FStar_Syntax_Util.mk_with_type u
-                 lc.FStar_TypeChecker_Common.res_typ e
-             else e)
-let (maybe_capture_unit_refinement :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.bv ->
-        FStar_Syntax_Syntax.comp ->
-          (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun t ->
-      fun x ->
-        fun c ->
-          let t1 =
-            FStar_TypeChecker_Normalize.normalize_refinement
-              FStar_TypeChecker_Normalize.whnf_steps env t in
-          match t1.FStar_Syntax_Syntax.n with
-          | FStar_Syntax_Syntax.Tm_refine (b, phi) ->
-              let is_unit =
-                match (b.FStar_Syntax_Syntax.sort).FStar_Syntax_Syntax.n with
-                | FStar_Syntax_Syntax.Tm_fvar fv ->
-                    FStar_Syntax_Syntax.fv_eq_lid fv
-                      FStar_Parser_Const.unit_lid
-                | uu___ -> false in
-              if is_unit
-              then
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bar_Greater c
-                        FStar_Syntax_Util.comp_effect_name in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___2
-                      (FStar_TypeChecker_Env.norm_eff_name env) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___1
-                    (FStar_TypeChecker_Env.is_layered_effect env) in
-                (if uu___
-                 then
-                   let uu___1 = FStar_Syntax_Subst.open_term_bv b phi in
-                   match uu___1 with
-                   | (b1, phi1) ->
-                       let phi2 =
-                         FStar_Syntax_Subst.subst
-                           [FStar_Syntax_Syntax.NT
-                              (b1, FStar_Syntax_Syntax.unit_const)] phi1 in
-                       weaken_comp env c phi2
-                 else
-                   (let uu___2 = close_wp_comp env [x] c in
-                    (uu___2, FStar_TypeChecker_Env.trivial_guard)))
-              else (c, FStar_TypeChecker_Env.trivial_guard)
-          | uu___ -> (c, FStar_TypeChecker_Env.trivial_guard)
-let (bind :
-  FStar_Compiler_Range.range ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-        FStar_TypeChecker_Common.lcomp ->
-          lcomp_with_binder -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun r1 ->
-    fun env ->
-      fun e1opt ->
-        fun lc1 ->
-          fun uu___ ->
-            match uu___ with
-            | (b, lc2) ->
-                let debug f =
-                  let uu___1 =
-                    (FStar_TypeChecker_Env.debug env FStar_Options.Extreme)
-                      ||
-                      (FStar_Compiler_Effect.op_Less_Bar
-                         (FStar_TypeChecker_Env.debug env)
-                         (FStar_Options.Other "bind")) in
-                  if uu___1 then f () else () in
-                let uu___1 =
-                  FStar_TypeChecker_Normalize.ghost_to_pure_lcomp2 env
-                    (lc1, lc2) in
-                (match uu___1 with
-                 | (lc11, lc21) ->
-                     let joined_eff = join_lcomp env lc11 lc21 in
-                     let bind_flags =
-                       let uu___2 =
-                         (should_not_inline_lc lc11) ||
-                           (should_not_inline_lc lc21) in
-                       if uu___2
-                       then [FStar_Syntax_Syntax.SHOULD_NOT_INLINE]
-                       else
-                         (let flags =
-                            let uu___4 =
-                              FStar_TypeChecker_Common.is_total_lcomp lc11 in
-                            if uu___4
-                            then
-                              let uu___5 =
-                                FStar_TypeChecker_Common.is_total_lcomp lc21 in
-                              (if uu___5
-                               then [FStar_Syntax_Syntax.TOTAL]
-                               else
-                                 (let uu___7 =
-                                    FStar_TypeChecker_Common.is_tot_or_gtot_lcomp
-                                      lc21 in
-                                  if uu___7
-                                  then [FStar_Syntax_Syntax.SOMETRIVIAL]
-                                  else []))
-                            else
-                              (let uu___6 =
-                                 (FStar_TypeChecker_Common.is_tot_or_gtot_lcomp
-                                    lc11)
-                                   &&
-                                   (FStar_TypeChecker_Common.is_tot_or_gtot_lcomp
-                                      lc21) in
-                               if uu___6
-                               then [FStar_Syntax_Syntax.SOMETRIVIAL]
-                               else []) in
-                          let uu___4 = lcomp_has_trivial_postcondition lc21 in
-                          if uu___4
-                          then FStar_Syntax_Syntax.TRIVIAL_POSTCONDITION ::
-                            flags
-                          else flags) in
-                     let bind_it uu___2 =
-                       let uu___3 =
-                         env.FStar_TypeChecker_Env.lax &&
-                           (FStar_Options.ml_ish ()) in
-                       if uu___3
-                       then
-                         let u_t =
-                           env.FStar_TypeChecker_Env.universe_of env
-                             lc21.FStar_TypeChecker_Common.res_typ in
-                         let uu___4 =
-                           lax_mk_tot_or_comp_l joined_eff u_t
-                             lc21.FStar_TypeChecker_Common.res_typ [] in
-                         (uu___4, FStar_TypeChecker_Env.trivial_guard)
-                       else
-                         (let uu___5 =
-                            FStar_TypeChecker_Common.lcomp_comp lc11 in
-                          match uu___5 with
-                          | (c1, g_c1) ->
-                              let uu___6 =
-                                FStar_TypeChecker_Common.lcomp_comp lc21 in
-                              (match uu___6 with
-                               | (c2, g_c2) ->
-                                   let trivial_guard =
-                                     let uu___7 =
-                                       match b with
-                                       | FStar_Pervasives_Native.Some x ->
-                                           let b1 =
-                                             FStar_Syntax_Syntax.mk_binder x in
-                                           let uu___8 =
-                                             FStar_Syntax_Syntax.is_null_binder
-                                               b1 in
-                                           if uu___8
-                                           then g_c2
-                                           else
-                                             FStar_TypeChecker_Env.close_guard
-                                               env [b1] g_c2
-                                       | FStar_Pervasives_Native.None -> g_c2 in
-                                     FStar_TypeChecker_Env.conj_guard g_c1
-                                       uu___7 in
-                                   (debug
-                                      (fun uu___8 ->
-                                         let uu___9 =
-                                           FStar_Syntax_Print.comp_to_string
-                                             c1 in
-                                         let uu___10 =
-                                           match b with
-                                           | FStar_Pervasives_Native.None ->
-                                               "none"
-                                           | FStar_Pervasives_Native.Some x
-                                               ->
-                                               FStar_Syntax_Print.bv_to_string
-                                                 x in
-                                         let uu___11 =
-                                           FStar_Syntax_Print.comp_to_string
-                                             c2 in
-                                         let uu___12 =
-                                           match e1opt with
-                                           | FStar_Pervasives_Native.None ->
-                                               "none"
-                                           | FStar_Pervasives_Native.Some e1
-                                               ->
-                                               FStar_Syntax_Print.term_to_string
-                                                 e1 in
-                                         FStar_Compiler_Util.print4
-                                           "(1) bind: \n\tc1=%s\n\tx=%s\n\tc2=%s\n\te1=%s\n(1. end bind)\n"
-                                           uu___9 uu___10 uu___11 uu___12);
-                                    (let aux uu___8 =
-                                       let uu___9 =
-                                         FStar_Syntax_Util.is_trivial_wp c1 in
-                                       if uu___9
-                                       then
-                                         match b with
-                                         | FStar_Pervasives_Native.None ->
-                                             FStar_Pervasives.Inl
-                                               (c2, "trivial no binder")
-                                         | FStar_Pervasives_Native.Some
-                                             uu___10 ->
-                                             let uu___11 =
-                                               FStar_Syntax_Util.is_ml_comp
-                                                 c2 in
-                                             (if uu___11
-                                              then
-                                                FStar_Pervasives.Inl
-                                                  (c2, "trivial ml")
-                                              else
-                                                FStar_Pervasives.Inr
-                                                  "c1 trivial; but c2 is not ML")
-                                       else
-                                         (let uu___11 =
-                                            (FStar_Syntax_Util.is_ml_comp c1)
-                                              &&
-                                              (FStar_Syntax_Util.is_ml_comp
-                                                 c2) in
-                                          if uu___11
-                                          then
-                                            FStar_Pervasives.Inl
-                                              (c2, "both ml")
-                                          else
-                                            FStar_Pervasives.Inr
-                                              "c1 not trivial, and both are not ML") in
-                                     let try_simplify uu___8 =
-                                       let aux_with_trivial_guard uu___9 =
-                                         let uu___10 = aux () in
-                                         match uu___10 with
-                                         | FStar_Pervasives.Inl (c, reason)
-                                             ->
-                                             FStar_Pervasives.Inl
-                                               (c, trivial_guard, reason)
-                                         | FStar_Pervasives.Inr reason ->
-                                             FStar_Pervasives.Inr reason in
-                                       let uu___9 =
-                                         FStar_TypeChecker_Env.too_early_in_prims
-                                           env in
-                                       if uu___9
-                                       then
-                                         FStar_Pervasives.Inl
-                                           (c2, trivial_guard,
-                                             "Early in prims; we don't have bind yet")
-                                       else
-                                         (let uu___11 =
-                                            FStar_Syntax_Util.is_total_comp
-                                              c1 in
-                                          if uu___11
-                                          then
-                                            let close_with_type_of_x x c =
-                                              let x1 =
-                                                {
-                                                  FStar_Syntax_Syntax.ppname
-                                                    =
-                                                    (x.FStar_Syntax_Syntax.ppname);
-                                                  FStar_Syntax_Syntax.index =
-                                                    (x.FStar_Syntax_Syntax.index);
-                                                  FStar_Syntax_Syntax.sort =
-                                                    (FStar_Syntax_Util.comp_result
-                                                       c1)
-                                                } in
-                                              maybe_capture_unit_refinement
-                                                env
-                                                x1.FStar_Syntax_Syntax.sort
-                                                x1 c in
-                                            match (e1opt, b) with
-                                            | (FStar_Pervasives_Native.Some
-                                               e,
-                                               FStar_Pervasives_Native.Some
-                                               x) ->
-                                                let uu___12 =
-                                                  let uu___13 =
-                                                    FStar_Compiler_Effect.op_Bar_Greater
-                                                      c2
-                                                      (FStar_Syntax_Subst.subst_comp
-                                                         [FStar_Syntax_Syntax.NT
-                                                            (x, e)]) in
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    uu___13
-                                                    (close_with_type_of_x x) in
-                                                (match uu___12 with
-                                                 | (c21, g_close) ->
-                                                     let uu___13 =
-                                                       let uu___14 =
-                                                         let uu___15 =
-                                                           let uu___16 =
-                                                             let uu___17 =
-                                                               FStar_TypeChecker_Env.map_guard
-                                                                 g_c2
-                                                                 (FStar_Syntax_Subst.subst
-                                                                    [
-                                                                    FStar_Syntax_Syntax.NT
-                                                                    (x, e)]) in
-                                                             [uu___17;
-                                                             g_close] in
-                                                           g_c1 :: uu___16 in
-                                                         FStar_TypeChecker_Env.conj_guards
-                                                           uu___15 in
-                                                       (c21, uu___14,
-                                                         "c1 Tot") in
-                                                     FStar_Pervasives.Inl
-                                                       uu___13)
-                                            | (uu___12,
-                                               FStar_Pervasives_Native.Some
-                                               x) ->
-                                                let uu___13 =
-                                                  FStar_Compiler_Effect.op_Bar_Greater
-                                                    c2
-                                                    (close_with_type_of_x x) in
-                                                (match uu___13 with
-                                                 | (c21, g_close) ->
-                                                     let uu___14 =
-                                                       let uu___15 =
-                                                         let uu___16 =
-                                                           let uu___17 =
-                                                             let uu___18 =
-                                                               let uu___19 =
-                                                                 let uu___20
-                                                                   =
-                                                                   FStar_Syntax_Syntax.mk_binder
-                                                                    x in
-                                                                 [uu___20] in
-                                                               FStar_TypeChecker_Env.close_guard
-                                                                 env uu___19
-                                                                 g_c2 in
-                                                             [uu___18;
-                                                             g_close] in
-                                                           g_c1 :: uu___17 in
-                                                         FStar_TypeChecker_Env.conj_guards
-                                                           uu___16 in
-                                                       (c21, uu___15,
-                                                         "c1 Tot only close") in
-                                                     FStar_Pervasives.Inl
-                                                       uu___14)
-                                            | (uu___12, uu___13) ->
-                                                aux_with_trivial_guard ()
-                                          else
-                                            (let uu___13 =
-                                               (FStar_Syntax_Util.is_tot_or_gtot_comp
-                                                  c1)
-                                                 &&
-                                                 (FStar_Syntax_Util.is_tot_or_gtot_comp
-                                                    c2) in
-                                             if uu___13
-                                             then
-                                               let uu___14 =
-                                                 let uu___15 =
-                                                   FStar_Syntax_Syntax.mk_GTotal
-                                                     (FStar_Syntax_Util.comp_result
-                                                        c2) in
-                                                 (uu___15, trivial_guard,
-                                                   "both GTot") in
-                                               FStar_Pervasives.Inl uu___14
-                                             else aux_with_trivial_guard ())) in
-                                     let uu___8 = try_simplify () in
-                                     match uu___8 with
-                                     | FStar_Pervasives.Inl (c, g, reason) ->
-                                         (debug
-                                            (fun uu___10 ->
-                                               let uu___11 =
-                                                 FStar_Syntax_Print.comp_to_string
-                                                   c in
-                                               FStar_Compiler_Util.print2
-                                                 "(2) bind: Simplified (because %s) to\n\t%s\n"
-                                                 reason uu___11);
-                                          (c, g))
-                                     | FStar_Pervasives.Inr reason ->
-                                         (debug
-                                            (fun uu___10 ->
-                                               FStar_Compiler_Util.print1
-                                                 "(2) bind: Not simplified because %s\n"
-                                                 reason);
-                                          (let mk_bind1 c11 b1 c21 g =
-                                             let uu___10 =
-                                               mk_bind env c11 b1 c21
-                                                 bind_flags r1 in
-                                             match uu___10 with
-                                             | (c, g_bind) ->
-                                                 let uu___11 =
-                                                   FStar_TypeChecker_Env.conj_guard
-                                                     g g_bind in
-                                                 (c, uu___11) in
-                                           let mk_seq c11 b1 c21 =
-                                             let c12 =
-                                               FStar_TypeChecker_Env.unfold_effect_abbrev
-                                                 env c11 in
-                                             let c22 =
-                                               FStar_TypeChecker_Env.unfold_effect_abbrev
-                                                 env c21 in
-                                             let uu___10 =
-                                               FStar_TypeChecker_Env.join env
-                                                 c12.FStar_Syntax_Syntax.effect_name
-                                                 c22.FStar_Syntax_Syntax.effect_name in
-                                             match uu___10 with
-                                             | (m, uu___11, lift2) ->
-                                                 let uu___12 =
-                                                   lift_comp env c22 lift2 in
-                                                 (match uu___12 with
-                                                  | (c23, g2) ->
-                                                      let uu___13 =
-                                                        destruct_wp_comp c12 in
-                                                      (match uu___13 with
-                                                       | (u1, t1, wp1) ->
-                                                           let md_pure_or_ghost
-                                                             =
-                                                             FStar_TypeChecker_Env.get_effect_decl
-                                                               env
-                                                               c12.FStar_Syntax_Syntax.effect_name in
-                                                           let trivial =
-                                                             let uu___14 =
-                                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                                 md_pure_or_ghost
-                                                                 FStar_Syntax_Util.get_wp_trivial_combinator in
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               uu___14
-                                                               FStar_Compiler_Util.must in
-                                                           let vc1 =
-                                                             let uu___14 =
-                                                               FStar_TypeChecker_Env.inst_effect_fun_with
-                                                                 [u1] env
-                                                                 md_pure_or_ghost
-                                                                 trivial in
-                                                             let uu___15 =
-                                                               let uu___16 =
-                                                                 FStar_Syntax_Syntax.as_arg
-                                                                   t1 in
-                                                               let uu___17 =
-                                                                 let uu___18
-                                                                   =
-                                                                   FStar_Syntax_Syntax.as_arg
-                                                                    wp1 in
-                                                                 [uu___18] in
-                                                               uu___16 ::
-                                                                 uu___17 in
-                                                             FStar_Syntax_Syntax.mk_Tm_app
-                                                               uu___14
-                                                               uu___15 r1 in
-                                                           let uu___14 =
-                                                             strengthen_comp
-                                                               env
-                                                               FStar_Pervasives_Native.None
-                                                               c23 vc1
-                                                               bind_flags in
-                                                           (match uu___14
-                                                            with
-                                                            | (c, g_s) ->
-                                                                let uu___15 =
-                                                                  FStar_TypeChecker_Env.conj_guards
-                                                                    [g_c1;
-                                                                    g_c2;
-                                                                    g2;
-                                                                    g_s] in
-                                                                (c, uu___15)))) in
-                                           let uu___10 =
-                                             let t =
-                                               FStar_Syntax_Util.comp_result
-                                                 c1 in
-                                             match comp_univ_opt c1 with
-                                             | FStar_Pervasives_Native.None
-                                                 ->
-                                                 let uu___11 =
-                                                   env.FStar_TypeChecker_Env.universe_of
-                                                     env t in
-                                                 (uu___11, t)
-                                             | FStar_Pervasives_Native.Some u
-                                                 -> (u, t) in
-                                           match uu___10 with
-                                           | (u_res_t1, res_t1) ->
-                                               let uu___11 =
-                                                 (FStar_Compiler_Option.isSome
-                                                    b)
-                                                   &&
-                                                   (should_return env e1opt
-                                                      lc11) in
-                                               if uu___11
-                                               then
-                                                 let e1 =
-                                                   FStar_Compiler_Option.get
-                                                     e1opt in
-                                                 let x =
-                                                   FStar_Compiler_Option.get
-                                                     b in
-                                                 let uu___12 =
-                                                   FStar_Syntax_Util.is_partial_return
-                                                     c1 in
-                                                 (if uu___12
-                                                  then
-                                                    (debug
-                                                       (fun uu___14 ->
-                                                          let uu___15 =
-                                                            FStar_TypeChecker_Normalize.term_to_string
-                                                              env e1 in
-                                                          let uu___16 =
-                                                            FStar_Syntax_Print.bv_to_string
-                                                              x in
-                                                          FStar_Compiler_Util.print2
-                                                            "(3) bind (case a): Substituting %s for %s\n"
-                                                            uu___15 uu___16);
-                                                     (let c21 =
-                                                        FStar_Syntax_Subst.subst_comp
-                                                          [FStar_Syntax_Syntax.NT
-                                                             (x, e1)] c2 in
-                                                      let g =
-                                                        let uu___14 =
-                                                          FStar_TypeChecker_Env.map_guard
-                                                            g_c2
-                                                            (FStar_Syntax_Subst.subst
-                                                               [FStar_Syntax_Syntax.NT
-                                                                  (x, e1)]) in
-                                                        FStar_TypeChecker_Env.conj_guard
-                                                          g_c1 uu___14 in
-                                                      mk_bind1 c1 b c21 g))
-                                                  else
-                                                    (let uu___14 =
-                                                       ((FStar_Options.vcgen_optimize_bind_as_seq
-                                                           ())
-                                                          &&
-                                                          (lcomp_has_trivial_postcondition
-                                                             lc11))
-                                                         &&
-                                                         (let uu___15 =
-                                                            FStar_TypeChecker_Env.try_lookup_lid
-                                                              env
-                                                              FStar_Parser_Const.with_type_lid in
-                                                          FStar_Compiler_Option.isSome
-                                                            uu___15) in
-                                                     if uu___14
-                                                     then
-                                                       let e1' =
-                                                         let uu___15 =
-                                                           FStar_Options.vcgen_decorate_with_type
-                                                             () in
-                                                         if uu___15
-                                                         then
-                                                           FStar_Syntax_Util.mk_with_type
-                                                             u_res_t1 res_t1
-                                                             e1
-                                                         else e1 in
-                                                       (debug
-                                                          (fun uu___16 ->
-                                                             let uu___17 =
-                                                               FStar_TypeChecker_Normalize.term_to_string
-                                                                 env e1' in
-                                                             let uu___18 =
-                                                               FStar_Syntax_Print.bv_to_string
-                                                                 x in
-                                                             FStar_Compiler_Util.print2
-                                                               "(3) bind (case b): Substituting %s for %s\n"
-                                                               uu___17
-                                                               uu___18);
-                                                        (let c21 =
-                                                           FStar_Syntax_Subst.subst_comp
-                                                             [FStar_Syntax_Syntax.NT
-                                                                (x, e1')] c2 in
-                                                         mk_seq c1 b c21))
-                                                     else
-                                                       (debug
-                                                          (fun uu___17 ->
-                                                             let uu___18 =
-                                                               FStar_TypeChecker_Normalize.term_to_string
-                                                                 env e1 in
-                                                             let uu___19 =
-                                                               FStar_Syntax_Print.bv_to_string
-                                                                 x in
-                                                             FStar_Compiler_Util.print2
-                                                               "(3) bind (case c): Adding equality %s = %s\n"
-                                                               uu___18
-                                                               uu___19);
-                                                        (let c21 =
-                                                           FStar_Syntax_Subst.subst_comp
-                                                             [FStar_Syntax_Syntax.NT
-                                                                (x, e1)] c2 in
-                                                         let x_eq_e =
-                                                           let uu___17 =
-                                                             FStar_Syntax_Syntax.bv_to_name
-                                                               x in
-                                                           FStar_Syntax_Util.mk_eq2
-                                                             u_res_t1 res_t1
-                                                             e1 uu___17 in
-                                                         let uu___17 =
-                                                           let uu___18 =
-                                                             let uu___19 =
-                                                               let uu___20 =
-                                                                 FStar_Syntax_Syntax.mk_binder
-                                                                   x in
-                                                               [uu___20] in
-                                                             FStar_TypeChecker_Env.push_binders
-                                                               env uu___19 in
-                                                           weaken_comp
-                                                             uu___18 c21
-                                                             x_eq_e in
-                                                         match uu___17 with
-                                                         | (c22, g_w) ->
-                                                             let g =
-                                                               let uu___18 =
-                                                                 let uu___19
-                                                                   =
-                                                                   let uu___20
-                                                                    =
-                                                                    let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    x in
-                                                                    [uu___22] in
-                                                                    FStar_TypeChecker_Env.close_guard
-                                                                    env
-                                                                    uu___21
-                                                                    g_w in
-                                                                   let uu___21
-                                                                    =
-                                                                    let uu___22
-                                                                    =
-                                                                    let uu___23
-                                                                    =
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_Syntax_Syntax.mk_binder
-                                                                    x in
-                                                                    [uu___24] in
-                                                                    let uu___24
-                                                                    =
-                                                                    FStar_TypeChecker_Common.weaken_guard_formula
-                                                                    g_c2
-                                                                    x_eq_e in
-                                                                    FStar_TypeChecker_Env.close_guard
-                                                                    env
-                                                                    uu___23
-                                                                    uu___24 in
-                                                                    [uu___22] in
-                                                                   uu___20 ::
-                                                                    uu___21 in
-                                                                 g_c1 ::
-                                                                   uu___19 in
-                                                               FStar_TypeChecker_Env.conj_guards
-                                                                 uu___18 in
-                                                             mk_bind1 c1 b
-                                                               c22 g))))
-                                               else
-                                                 mk_bind1 c1 b c2
-                                                   trivial_guard)))))) in
-                     FStar_TypeChecker_Common.mk_lcomp joined_eff
-                       lc21.FStar_TypeChecker_Common.res_typ bind_flags
-                       bind_it)
-let (weaken_guard :
-  FStar_TypeChecker_Common.guard_formula ->
-    FStar_TypeChecker_Common.guard_formula ->
-      FStar_TypeChecker_Common.guard_formula)
-  =
-  fun g1 ->
-    fun g2 ->
-      match (g1, g2) with
-      | (FStar_TypeChecker_Common.NonTrivial f1,
-         FStar_TypeChecker_Common.NonTrivial f2) ->
-          let g = FStar_Syntax_Util.mk_imp f1 f2 in
-          FStar_TypeChecker_Common.NonTrivial g
-      | uu___ -> g2
-let (assume_result_eq_pure_term_in_m :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.term ->
-        FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun m_opt ->
-      fun e ->
-        fun lc ->
-          let m =
-            let uu___ =
-              (FStar_Compiler_Effect.op_Bar_Greater m_opt
-                 FStar_Compiler_Util.is_none)
-                || (is_ghost_effect env lc.FStar_TypeChecker_Common.eff_name) in
-            if uu___
-            then FStar_Parser_Const.effect_PURE_lid
-            else
-              FStar_Compiler_Effect.op_Bar_Greater m_opt
-                FStar_Compiler_Util.must in
-          let flags =
-            let uu___ = FStar_TypeChecker_Common.is_total_lcomp lc in
-            if uu___
-            then FStar_Syntax_Syntax.RETURN ::
-              (lc.FStar_TypeChecker_Common.cflags)
-            else FStar_Syntax_Syntax.PARTIAL_RETURN ::
-              (lc.FStar_TypeChecker_Common.cflags) in
-          let refine uu___ =
-            let uu___1 = FStar_TypeChecker_Common.lcomp_comp lc in
-            match uu___1 with
-            | (c, g_c) ->
-                let u_t =
-                  match comp_univ_opt c with
-                  | FStar_Pervasives_Native.Some u_t1 -> u_t1
-                  | FStar_Pervasives_Native.None ->
-                      env.FStar_TypeChecker_Env.universe_of env
-                        (FStar_Syntax_Util.comp_result c) in
-                let uu___2 = FStar_Syntax_Util.is_tot_or_gtot_comp c in
-                if uu___2
-                then
-                  let uu___3 =
-                    return_value env m (FStar_Pervasives_Native.Some u_t)
-                      (FStar_Syntax_Util.comp_result c) e in
-                  (match uu___3 with
-                   | (retc, g_retc) ->
-                       let g_c1 = FStar_TypeChecker_Env.conj_guard g_c g_retc in
-                       let uu___4 =
-                         let uu___5 = FStar_Syntax_Util.is_pure_comp c in
-                         Prims.op_Negation uu___5 in
-                       if uu___4
-                       then
-                         let retc1 =
-                           FStar_TypeChecker_Env.comp_to_comp_typ env retc in
-                         let retc2 =
-                           {
-                             FStar_Syntax_Syntax.comp_univs =
-                               (retc1.FStar_Syntax_Syntax.comp_univs);
-                             FStar_Syntax_Syntax.effect_name =
-                               FStar_Parser_Const.effect_GHOST_lid;
-                             FStar_Syntax_Syntax.result_typ =
-                               (retc1.FStar_Syntax_Syntax.result_typ);
-                             FStar_Syntax_Syntax.effect_args =
-                               (retc1.FStar_Syntax_Syntax.effect_args);
-                             FStar_Syntax_Syntax.flags = flags
-                           } in
-                         let uu___5 = FStar_Syntax_Syntax.mk_Comp retc2 in
-                         (uu___5, g_c1)
-                       else
-                         (let uu___6 =
-                            FStar_TypeChecker_Env.comp_set_flags env retc
-                              flags in
-                          (uu___6, g_c1)))
-                else
-                  (let c1 = FStar_TypeChecker_Env.unfold_effect_abbrev env c in
-                   let t = c1.FStar_Syntax_Syntax.result_typ in
-                   let c2 = FStar_Syntax_Syntax.mk_Comp c1 in
-                   let x =
-                     FStar_Syntax_Syntax.new_bv
-                       (FStar_Pervasives_Native.Some
-                          (t.FStar_Syntax_Syntax.pos)) t in
-                   let xexp = FStar_Syntax_Syntax.bv_to_name x in
-                   let env_x = FStar_TypeChecker_Env.push_bv env x in
-                   let uu___4 =
-                     return_value env_x m (FStar_Pervasives_Native.Some u_t)
-                       t xexp in
-                   match uu___4 with
-                   | (ret, g_ret) ->
-                       let ret1 =
-                         let uu___5 =
-                           FStar_TypeChecker_Env.comp_set_flags env_x ret
-                             [FStar_Syntax_Syntax.PARTIAL_RETURN] in
-                         FStar_Compiler_Effect.op_Less_Bar
-                           FStar_TypeChecker_Common.lcomp_of_comp uu___5 in
-                       let eq = FStar_Syntax_Util.mk_eq2 u_t t xexp e in
-                       let eq_ret =
-                         weaken_precondition env_x ret1
-                           (FStar_TypeChecker_Common.NonTrivial eq) in
-                       let uu___5 =
-                         let uu___6 =
-                           let uu___7 =
-                             FStar_TypeChecker_Common.lcomp_of_comp c2 in
-                           bind e.FStar_Syntax_Syntax.pos env
-                             FStar_Pervasives_Native.None uu___7
-                             ((FStar_Pervasives_Native.Some x), eq_ret) in
-                         FStar_TypeChecker_Common.lcomp_comp uu___6 in
-                       (match uu___5 with
-                        | (bind_c, g_bind) ->
-                            let uu___6 =
-                              FStar_TypeChecker_Env.comp_set_flags env bind_c
-                                flags in
-                            let uu___7 =
-                              FStar_TypeChecker_Env.conj_guards
-                                [g_c; g_ret; g_bind] in
-                            (uu___6, uu___7))) in
-          let uu___ = should_not_inline_lc lc in
-          if uu___
-          then
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Print.term_to_string e in
-                FStar_Compiler_Util.format1
-                  "assume_result_eq_pure_term cannot inline an non-inlineable lc : %s"
-                  uu___3 in
-              (FStar_Errors.Fatal_UnexpectedTerm, uu___2) in
-            FStar_Errors.raise_error uu___1 e.FStar_Syntax_Syntax.pos
-          else
-            (let uu___2 = refine () in
-             match uu___2 with
-             | (c, g) -> FStar_TypeChecker_Common.lcomp_of_comp_guard c g)
-let (maybe_assume_result_eq_pure_term_in_m :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.term ->
-        FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun m_opt ->
-      fun e ->
-        fun lc ->
-          let should_return1 =
-            (((Prims.op_Negation env.FStar_TypeChecker_Env.lax) &&
-                (let uu___ = FStar_TypeChecker_Env.too_early_in_prims env in
-                 Prims.op_Negation uu___))
-               && (should_return env (FStar_Pervasives_Native.Some e) lc))
-              &&
-              (let uu___ =
-                 FStar_TypeChecker_Common.is_lcomp_partial_return lc in
-               Prims.op_Negation uu___) in
-          if Prims.op_Negation should_return1
-          then lc
-          else assume_result_eq_pure_term_in_m env m_opt e lc
-let (maybe_assume_result_eq_pure_term :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        maybe_assume_result_eq_pure_term_in_m env
-          FStar_Pervasives_Native.None e lc
-let (maybe_return_e2_and_bind :
-  FStar_Compiler_Range.range ->
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.term FStar_Pervasives_Native.option ->
-        FStar_TypeChecker_Common.lcomp ->
-          FStar_Syntax_Syntax.term ->
-            lcomp_with_binder -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun r ->
-    fun env ->
-      fun e1opt ->
-        fun lc1 ->
-          fun e2 ->
-            fun uu___ ->
-              match uu___ with
-              | (x, lc2) ->
-                  let env_x =
-                    match x with
-                    | FStar_Pervasives_Native.None -> env
-                    | FStar_Pervasives_Native.Some x1 ->
-                        FStar_TypeChecker_Env.push_bv env x1 in
-                  let uu___1 =
-                    FStar_TypeChecker_Normalize.ghost_to_pure_lcomp2 env
-                      (lc1, lc2) in
-                  (match uu___1 with
-                   | (lc11, lc21) ->
-                       let lc22 =
-                         let eff1 =
-                           FStar_TypeChecker_Env.norm_eff_name env
-                             lc11.FStar_TypeChecker_Common.eff_name in
-                         let eff2 =
-                           FStar_TypeChecker_Env.norm_eff_name env
-                             lc21.FStar_TypeChecker_Common.eff_name in
-                         let uu___2 =
-                           ((FStar_Ident.lid_equals eff2
-                               FStar_Parser_Const.effect_PURE_lid)
-                              &&
-                              (let uu___3 =
-                                 FStar_TypeChecker_Env.join_opt env eff1 eff2 in
-                               FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                 FStar_Compiler_Util.is_none))
-                             &&
-                             (let uu___3 =
-                                FStar_TypeChecker_Env.exists_polymonadic_bind
-                                  env eff1 eff2 in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___3
-                                FStar_Compiler_Util.is_none) in
-                         if uu___2
-                         then
-                           let uu___3 =
-                             FStar_Compiler_Effect.op_Bar_Greater eff1
-                               (fun uu___4 ->
-                                  FStar_Pervasives_Native.Some uu___4) in
-                           assume_result_eq_pure_term_in_m env_x uu___3 e2
-                             lc21
-                         else
-                           (let uu___4 =
-                              ((let uu___5 = is_pure_or_ghost_effect env eff1 in
-                                Prims.op_Negation uu___5) ||
-                                 (should_not_inline_lc lc11))
-                                && (is_pure_or_ghost_effect env eff2) in
-                            if uu___4
-                            then
-                              let uu___5 =
-                                FStar_Compiler_Effect.op_Bar_Greater eff1
-                                  (fun uu___6 ->
-                                     FStar_Pervasives_Native.Some uu___6) in
-                              maybe_assume_result_eq_pure_term_in_m env_x
-                                uu___5 e2 lc21
-                            else lc21) in
-                       bind r env e1opt lc11 (x, lc22))
-let (fvar_const :
-  FStar_TypeChecker_Env.env -> FStar_Ident.lident -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun lid ->
-      let uu___ =
-        let uu___1 = FStar_TypeChecker_Env.get_range env in
-        FStar_Ident.set_lid_range lid uu___1 in
-      FStar_Syntax_Syntax.fvar uu___ FStar_Syntax_Syntax.delta_constant
-        FStar_Pervasives_Native.None
-let (substitutive_indexed_ite_substs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.indexed_effect_combinator_kind ->
-      FStar_Syntax_Syntax.binders ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Syntax_Syntax.term ->
-            FStar_Syntax_Syntax.comp_typ ->
-              FStar_Syntax_Syntax.comp_typ ->
-                Prims.int ->
-                  FStar_Compiler_Range.range ->
-                    (FStar_Syntax_Syntax.subst_elt Prims.list *
-                      FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun k ->
-      fun bs ->
-        fun a ->
-          fun p ->
-            fun ct_then ->
-              fun ct_else ->
-                fun num_effect_params ->
-                  fun r ->
-                    let debug =
-                      FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_TypeChecker_Env.debug env)
-                        (FStar_Options.Other "LayeredEffectsApp") in
-                    let uu___ =
-                      let uu___1 = bs in
-                      match uu___1 with
-                      | a_b::bs1 ->
-                          (bs1,
-                            [FStar_Syntax_Syntax.NT
-                               ((a_b.FStar_Syntax_Syntax.binder_bv), a)]) in
-                    match uu___ with
-                    | (bs1, subst) ->
-                        let uu___1 =
-                          if num_effect_params = Prims.int_zero
-                          then
-                            (bs1, subst, FStar_TypeChecker_Env.trivial_guard,
-                              (ct_then.FStar_Syntax_Syntax.effect_args),
-                              (ct_else.FStar_Syntax_Syntax.effect_args))
-                          else
-                            (let split l =
-                               FStar_Compiler_List.splitAt num_effect_params
-                                 l in
-                             let uu___3 = split bs1 in
-                             match uu___3 with
-                             | (eff_params_bs, bs2) ->
-                                 let uu___4 =
-                                   split
-                                     ct_then.FStar_Syntax_Syntax.effect_args in
-                                 (match uu___4 with
-                                  | (param_args1, args1) ->
-                                      let uu___5 =
-                                        split
-                                          ct_else.FStar_Syntax_Syntax.effect_args in
-                                      (match uu___5 with
-                                       | (param_args2, args2) ->
-                                           let g =
-                                             FStar_Compiler_List.fold_left2
-                                               (fun g1 ->
-                                                  fun uu___6 ->
-                                                    fun uu___7 ->
-                                                      match (uu___6, uu___7)
-                                                      with
-                                                      | ((arg1, uu___8),
-                                                         (arg2, uu___9)) ->
-                                                          let uu___10 =
-                                                            FStar_TypeChecker_Rel.layered_effect_teq
-                                                              env arg1 arg2
-                                                              (FStar_Pervasives_Native.Some
-                                                                 "effect param ite") in
-                                                          FStar_TypeChecker_Env.conj_guard
-                                                            g1 uu___10)
-                                               FStar_TypeChecker_Env.trivial_guard
-                                               param_args1 param_args2 in
-                                           let param_subst =
-                                             FStar_Compiler_List.map2
-                                               (fun b ->
-                                                  fun uu___6 ->
-                                                    match uu___6 with
-                                                    | (arg, uu___7) ->
-                                                        FStar_Syntax_Syntax.NT
-                                                          ((b.FStar_Syntax_Syntax.binder_bv),
-                                                            arg))
-                                               eff_params_bs param_args1 in
-                                           (bs2,
-                                             (FStar_Compiler_List.op_At subst
-                                                param_subst), g, args1,
-                                             args2)))) in
-                        (match uu___1 with
-                         | (bs2, subst1, guard, args1, args2) ->
-                             let uu___2 =
-                               let m_num_effect_args =
-                                 FStar_Compiler_List.length args1 in
-                               let uu___3 =
-                                 FStar_Compiler_List.splitAt
-                                   m_num_effect_args bs2 in
-                               match uu___3 with
-                               | (f_bs, bs3) ->
-                                   let f_subst =
-                                     FStar_Compiler_List.map2
-                                       (fun f_b ->
-                                          fun uu___4 ->
-                                            match uu___4 with
-                                            | (arg, uu___5) ->
-                                                FStar_Syntax_Syntax.NT
-                                                  ((f_b.FStar_Syntax_Syntax.binder_bv),
-                                                    arg)) f_bs args1 in
-                                   (bs3,
-                                     (FStar_Compiler_List.op_At subst1
-                                        f_subst)) in
-                             (match uu___2 with
-                              | (bs3, subst2) ->
-                                  let uu___3 =
-                                    if
-                                      FStar_Syntax_Syntax.uu___is_Substitutive_combinator
-                                        k
-                                    then
-                                      let n_num_effect_args =
-                                        FStar_Compiler_List.length args2 in
-                                      let uu___4 =
-                                        FStar_Compiler_List.splitAt
-                                          n_num_effect_args bs3 in
-                                      match uu___4 with
-                                      | (g_bs, bs4) ->
-                                          let g_subst =
-                                            FStar_Compiler_List.map2
-                                              (fun g_b ->
-                                                 fun uu___5 ->
-                                                   match uu___5 with
-                                                   | (arg, uu___6) ->
-                                                       FStar_Syntax_Syntax.NT
-                                                         ((g_b.FStar_Syntax_Syntax.binder_bv),
-                                                           arg)) g_bs args2 in
-                                          (bs4,
-                                            (FStar_Compiler_List.op_At subst2
-                                               g_subst), guard)
-                                    else
-                                      if
-                                        FStar_Syntax_Syntax.uu___is_Substitutive_invariant_combinator
-                                          k
-                                      then
-                                        (let uu___5 =
-                                           FStar_Compiler_List.fold_left2
-                                             (fun guard1 ->
-                                                fun uu___6 ->
-                                                  fun uu___7 ->
-                                                    match (uu___6, uu___7)
-                                                    with
-                                                    | ((arg1, uu___8),
-                                                       (arg2, uu___9)) ->
-                                                        let uu___10 =
-                                                          FStar_TypeChecker_Rel.layered_effect_teq
-                                                            env arg1 arg2
-                                                            (FStar_Pervasives_Native.Some
-                                                               "substitutive_inv ite args") in
-                                                        FStar_TypeChecker_Env.conj_guard
-                                                          guard1 uu___10)
-                                             guard args1 args2 in
-                                         (bs3, subst2, uu___5))
-                                      else
-                                        failwith
-                                          "Impossible (substitutive_indexed_ite: unexpected k)" in
-                                  (match uu___3 with
-                                   | (bs4, subst3, guard1) ->
-                                       let uu___4 =
-                                         FStar_Compiler_List.splitAt
-                                           ((FStar_Compiler_List.length bs4)
-                                              - (Prims.of_int (3))) bs4 in
-                                       (match uu___4 with
-                                        | (bs5, uu___5::uu___6::p_b::[]) ->
-                                            let uu___7 =
-                                              FStar_Compiler_List.fold_left
-                                                (fun uu___8 ->
-                                                   fun b ->
-                                                     match uu___8 with
-                                                     | (subst4, g) ->
-                                                         let uu___9 =
-                                                           FStar_TypeChecker_Env.uvars_for_binders
-                                                             env [b] subst4
-                                                             (fun b1 ->
-                                                                if debug
-                                                                then
-                                                                  let uu___10
-                                                                    =
-                                                                    FStar_Syntax_Print.binder_to_string
-                                                                    b1 in
-                                                                  let uu___11
-                                                                    =
-                                                                    FStar_Ident.string_of_lid
-                                                                    ct_then.FStar_Syntax_Syntax.effect_name in
-                                                                  let uu___12
-                                                                    =
-                                                                    FStar_Compiler_Range.string_of_range
-                                                                    r in
-                                                                  FStar_Compiler_Util.format3
-                                                                    "implicit var for additional ite binder %s of %s at %s)"
-                                                                    uu___10
-                                                                    uu___11
-                                                                    uu___12
-                                                                else
-                                                                  "substitutive_indexed_ite_substs")
-                                                             r in
-                                                         (match uu___9 with
-                                                          | (uv_t::[], g_uv)
-                                                              ->
-                                                              let uu___10 =
-                                                                FStar_TypeChecker_Env.conj_guard
-                                                                  g g_uv in
-                                                              ((FStar_Compiler_List.op_At
-                                                                  subst4
-                                                                  [FStar_Syntax_Syntax.NT
-                                                                    ((b.FStar_Syntax_Syntax.binder_bv),
-                                                                    uv_t)]),
-                                                                uu___10)))
-                                                (subst3, guard1) bs5 in
-                                            (match uu___7 with
-                                             | (subst4, g) ->
-                                                 ((FStar_Compiler_List.op_At
-                                                     subst4
-                                                     [FStar_Syntax_Syntax.NT
-                                                        ((p_b.FStar_Syntax_Syntax.binder_bv),
-                                                          p)]), g))))))
-let (ad_hoc_indexed_ite_substs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.comp_typ ->
-            FStar_Syntax_Syntax.comp_typ ->
-              FStar_Compiler_Range.range ->
-                (FStar_Syntax_Syntax.subst_elt Prims.list *
-                  FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun bs ->
-      fun a ->
-        fun p ->
-          fun ct_then ->
-            fun ct_else ->
-              fun r ->
-                let debug =
-                  FStar_Compiler_Effect.op_Less_Bar
-                    (FStar_TypeChecker_Env.debug env)
-                    (FStar_Options.Other "LayeredEffectsApp") in
-                let conjunction_name uu___ =
-                  if debug
-                  then
-                    let uu___1 =
-                      FStar_Ident.string_of_lid
-                        ct_then.FStar_Syntax_Syntax.effect_name in
-                    FStar_Compiler_Util.format1 "%s.conjunction" uu___1
-                  else "" in
-                let conjunction_t_error s =
-                  let uu___ =
-                    let uu___1 =
-                      FStar_Ident.string_of_lid
-                        ct_then.FStar_Syntax_Syntax.effect_name in
-                    FStar_Compiler_Util.format2
-                      "conjunction %s does not have proper shape (reason:%s)"
-                      uu___1 s in
-                  (FStar_Errors.Fatal_UnexpectedEffect, uu___) in
-                let uu___ =
-                  if (FStar_Compiler_List.length bs) >= (Prims.of_int (4))
-                  then
-                    let uu___1 = bs in
-                    match uu___1 with
-                    | a_b::bs1 ->
-                        let uu___2 =
-                          FStar_Compiler_List.splitAt
-                            ((FStar_Compiler_List.length bs1) -
-                               (Prims.of_int (3))) bs1 in
-                        (match uu___2 with
-                         | (rest_bs, f_b::g_b::p_b::[]) ->
-                             (a_b, rest_bs, f_b, g_b, p_b))
-                  else
-                    (let uu___2 =
-                       conjunction_t_error
-                         "Either not an abstraction or not enough binders" in
-                     FStar_Errors.raise_error uu___2 r) in
-                match uu___ with
-                | (a_b, rest_bs, f_b, g_b, p_b) ->
-                    let uu___1 =
-                      FStar_TypeChecker_Env.uvars_for_binders env rest_bs
-                        [FStar_Syntax_Syntax.NT
-                           ((a_b.FStar_Syntax_Syntax.binder_bv), a)]
-                        (fun b ->
-                           if debug
-                           then
-                             let uu___2 =
-                               FStar_Syntax_Print.binder_to_string b in
-                             let uu___3 =
-                               FStar_Ident.string_of_lid
-                                 ct_then.FStar_Syntax_Syntax.effect_name in
-                             let uu___4 =
-                               FStar_Compiler_Effect.op_Bar_Greater r
-                                 FStar_Compiler_Range.string_of_range in
-                             FStar_Compiler_Util.format3
-                               "implicit var for binder %s of %s:conjunction at %s"
-                               uu___2 uu___3 uu___4
-                           else "ad_hoc_indexed_ite_substs") r in
-                    (match uu___1 with
-                     | (rest_bs_uvars, g_uvars) ->
-                         let substs =
-                           FStar_Compiler_List.map2
-                             (fun b ->
-                                fun t ->
-                                  FStar_Syntax_Syntax.NT
-                                    ((b.FStar_Syntax_Syntax.binder_bv), t))
-                             (a_b ::
-                             (FStar_Compiler_List.op_At rest_bs [p_b])) (a ::
-                             (FStar_Compiler_List.op_At rest_bs_uvars [p])) in
-                         let f_guard =
-                           let f_sort_is =
-                             let uu___2 =
-                               let uu___3 =
-                                 FStar_Syntax_Subst.compress
-                                   (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                               uu___3.FStar_Syntax_Syntax.n in
-                             match uu___2 with
-                             | FStar_Syntax_Syntax.Tm_app
-                                 (uu___3, uu___4::is) ->
-                                 let uu___5 =
-                                   FStar_Compiler_Effect.op_Bar_Greater is
-                                     (FStar_Compiler_List.map
-                                        FStar_Pervasives_Native.fst) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                   (FStar_Compiler_List.map
-                                      (FStar_Syntax_Subst.subst substs))
-                             | uu___3 ->
-                                 let uu___4 =
-                                   conjunction_t_error
-                                     "f's type is not a repr type" in
-                                 FStar_Errors.raise_error uu___4 r in
-                           let uu___2 =
-                             FStar_Compiler_List.map
-                               FStar_Pervasives_Native.fst
-                               ct_then.FStar_Syntax_Syntax.effect_args in
-                           FStar_Compiler_List.fold_left2
-                             (fun g ->
-                                fun i1 ->
-                                  fun f_i ->
-                                    let uu___3 =
-                                      let uu___4 =
-                                        let uu___5 = conjunction_name () in
-                                        FStar_Pervasives_Native.Some uu___5 in
-                                      FStar_TypeChecker_Rel.layered_effect_teq
-                                        env i1 f_i uu___4 in
-                                    FStar_TypeChecker_Env.conj_guard g uu___3)
-                             FStar_TypeChecker_Env.trivial_guard uu___2
-                             f_sort_is in
-                         let g_guard =
-                           let g_sort_is =
-                             let uu___2 =
-                               let uu___3 =
-                                 FStar_Syntax_Subst.compress
-                                   (g_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort in
-                               uu___3.FStar_Syntax_Syntax.n in
-                             match uu___2 with
-                             | FStar_Syntax_Syntax.Tm_app
-                                 (uu___3, uu___4::is) ->
-                                 let uu___5 =
-                                   FStar_Compiler_Effect.op_Bar_Greater is
-                                     (FStar_Compiler_List.map
-                                        FStar_Pervasives_Native.fst) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                   (FStar_Compiler_List.map
-                                      (FStar_Syntax_Subst.subst substs))
-                             | uu___3 ->
-                                 let uu___4 =
-                                   conjunction_t_error
-                                     "g's type is not a repr type" in
-                                 FStar_Errors.raise_error uu___4 r in
-                           let uu___2 =
-                             FStar_Compiler_List.map
-                               FStar_Pervasives_Native.fst
-                               ct_else.FStar_Syntax_Syntax.effect_args in
-                           FStar_Compiler_List.fold_left2
-                             (fun g ->
-                                fun i2 ->
-                                  fun g_i ->
-                                    let uu___3 =
-                                      let uu___4 =
-                                        let uu___5 = conjunction_name () in
-                                        FStar_Pervasives_Native.Some uu___5 in
-                                      FStar_TypeChecker_Rel.layered_effect_teq
-                                        env i2 g_i uu___4 in
-                                    FStar_TypeChecker_Env.conj_guard g uu___3)
-                             FStar_TypeChecker_Env.trivial_guard uu___2
-                             g_sort_is in
-                         let uu___2 =
-                           FStar_TypeChecker_Env.conj_guards
-                             [g_uvars; f_guard; g_guard] in
-                         (substs, uu___2))
-let (mk_layered_conjunction :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.typ ->
-            FStar_Syntax_Syntax.comp_typ ->
-              FStar_Syntax_Syntax.comp_typ ->
-                FStar_Compiler_Range.range ->
-                  (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun ed ->
-      fun u_a ->
-        fun a ->
-          fun p ->
-            fun ct1 ->
-              fun ct2 ->
-                fun r ->
-                  let debug =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_TypeChecker_Env.debug env)
-                      (FStar_Options.Other "LayeredEffectsApp") in
-                  let conjunction_t_error s =
-                    let uu___ =
-                      let uu___1 =
-                        FStar_Ident.string_of_lid
-                          ct1.FStar_Syntax_Syntax.effect_name in
-                      FStar_Compiler_Util.format2
-                        "conjunction %s does not have proper shape (reason:%s)"
-                        uu___1 s in
-                    (FStar_Errors.Fatal_UnexpectedEffect, uu___) in
-                  let uu___ =
-                    let uu___1 =
-                      let uu___2 =
-                        FStar_Compiler_Effect.op_Bar_Greater ed
-                          FStar_Syntax_Util.get_layered_if_then_else_combinator in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___2
-                        FStar_Compiler_Util.must in
-                    match uu___1 with
-                    | (ts, kopt) ->
-                        let uu___2 =
-                          FStar_TypeChecker_Env.inst_tscheme_with ts [u_a] in
-                        (match uu___2 with
-                         | (uu___3, conjunction) ->
-                             let uu___4 =
-                               FStar_Compiler_Effect.op_Bar_Greater kopt
-                                 FStar_Compiler_Util.must in
-                             (conjunction, uu___4)) in
-                  match uu___ with
-                  | (conjunction, kind) ->
-                      let uu___1 = FStar_Syntax_Util.abs_formals conjunction in
-                      (match uu___1 with
-                       | (bs, body, uu___2) ->
-                           (if debug
-                            then
-                              (let uu___4 =
-                                 let uu___5 =
-                                   FStar_Compiler_Effect.op_Bar_Greater ct1
-                                     FStar_Syntax_Syntax.mk_Comp in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___5
-                                   FStar_Syntax_Print.comp_to_string in
-                               let uu___5 =
-                                 let uu___6 =
-                                   FStar_Compiler_Effect.op_Bar_Greater ct2
-                                     FStar_Syntax_Syntax.mk_Comp in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                   FStar_Syntax_Print.comp_to_string in
-                               FStar_Compiler_Util.print2
-                                 "layered_ite c1: %s and c2: %s {\n" uu___4
-                                 uu___5)
-                            else ();
-                            (let uu___4 =
-                               if
-                                 kind = FStar_Syntax_Syntax.Ad_hoc_combinator
-                               then
-                                 ad_hoc_indexed_ite_substs env bs a p ct1 ct2
-                                   r
-                               else
-                                 (let num_effect_params =
-                                    match ed.FStar_Syntax_Syntax.signature
-                                    with
-                                    | FStar_Syntax_Syntax.Layered_eff_sig
-                                        (n, uu___6) -> n
-                                    | uu___6 -> failwith "Impossible!" in
-                                  substitutive_indexed_ite_substs env kind bs
-                                    a p ct1 ct2 num_effect_params r) in
-                             match uu___4 with
-                             | (substs, g) ->
-                                 let body1 =
-                                   FStar_Syntax_Subst.subst substs body in
-                                 let is =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       FStar_Syntax_Subst.compress body1 in
-                                     uu___6.FStar_Syntax_Syntax.n in
-                                   match uu___5 with
-                                   | FStar_Syntax_Syntax.Tm_app
-                                       (uu___6, a1::args) ->
-                                       FStar_Compiler_List.map
-                                         FStar_Pervasives_Native.fst args
-                                   | uu___6 ->
-                                       let uu___7 =
-                                         conjunction_t_error
-                                           "body is not a repr type" in
-                                       FStar_Errors.raise_error uu___7 r in
-                                 let c =
-                                   let uu___5 =
-                                     let uu___6 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         is
-                                         (FStar_Compiler_List.map
-                                            FStar_Syntax_Syntax.as_arg) in
-                                     {
-                                       FStar_Syntax_Syntax.comp_univs = [u_a];
-                                       FStar_Syntax_Syntax.effect_name =
-                                         (ed.FStar_Syntax_Syntax.mname);
-                                       FStar_Syntax_Syntax.result_typ = a;
-                                       FStar_Syntax_Syntax.effect_args =
-                                         uu___6;
-                                       FStar_Syntax_Syntax.flags = []
-                                     } in
-                                   FStar_Syntax_Syntax.mk_Comp uu___5 in
-                                 (if debug
-                                  then
-                                    FStar_Compiler_Util.print_string "\n}\n"
-                                  else ();
-                                  (c, g)))))
-let (mk_non_layered_conjunction :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.eff_decl ->
-      FStar_Syntax_Syntax.universe ->
-        FStar_Syntax_Syntax.term ->
-          FStar_Syntax_Syntax.typ ->
-            FStar_Syntax_Syntax.comp_typ ->
-              FStar_Syntax_Syntax.comp_typ ->
-                FStar_Compiler_Range.range ->
-                  (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun ed ->
-      fun u_a ->
-        fun a ->
-          fun p ->
-            fun ct1 ->
-              fun ct2 ->
-                fun uu___ ->
-                  let p1 = FStar_Syntax_Util.b2t p in
-                  let if_then_else =
-                    let uu___1 =
-                      FStar_Compiler_Effect.op_Bar_Greater ed
-                        FStar_Syntax_Util.get_wp_if_then_else_combinator in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___1
-                      FStar_Compiler_Util.must in
-                  let uu___1 = destruct_wp_comp ct1 in
-                  match uu___1 with
-                  | (uu___2, uu___3, wp_t) ->
-                      let uu___4 = destruct_wp_comp ct2 in
-                      (match uu___4 with
-                       | (uu___5, uu___6, wp_e) ->
-                           let wp =
-                             let uu___7 =
-                               FStar_TypeChecker_Env.inst_effect_fun_with
-                                 [u_a] env ed if_then_else in
-                             let uu___8 =
-                               let uu___9 = FStar_Syntax_Syntax.as_arg a in
-                               let uu___10 =
-                                 let uu___11 = FStar_Syntax_Syntax.as_arg p1 in
-                                 let uu___12 =
-                                   let uu___13 =
-                                     FStar_Syntax_Syntax.as_arg wp_t in
-                                   let uu___14 =
-                                     let uu___15 =
-                                       FStar_Syntax_Syntax.as_arg wp_e in
-                                     [uu___15] in
-                                   uu___13 :: uu___14 in
-                                 uu___11 :: uu___12 in
-                               uu___9 :: uu___10 in
-                             let uu___9 =
-                               FStar_Compiler_Range.union_ranges
-                                 wp_t.FStar_Syntax_Syntax.pos
-                                 wp_e.FStar_Syntax_Syntax.pos in
-                             FStar_Syntax_Syntax.mk_Tm_app uu___7 uu___8
-                               uu___9 in
-                           let uu___7 = mk_comp ed u_a a wp [] in
-                           (uu___7, FStar_TypeChecker_Env.trivial_guard))
-let (comp_pure_wp_false :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.comp)
-  =
-  fun env ->
-    fun u ->
-      fun t ->
-        let post_k =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.null_binder t in [uu___1] in
-          let uu___1 = FStar_Syntax_Syntax.mk_Total FStar_Syntax_Util.ktype0 in
-          FStar_Syntax_Util.arrow uu___ uu___1 in
-        let kwp =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.null_binder post_k in [uu___1] in
-          let uu___1 = FStar_Syntax_Syntax.mk_Total FStar_Syntax_Util.ktype0 in
-          FStar_Syntax_Util.arrow uu___ uu___1 in
-        let post =
-          FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None post_k in
-        let wp =
-          let uu___ =
-            let uu___1 = FStar_Syntax_Syntax.mk_binder post in [uu___1] in
-          let uu___1 = fvar_const env FStar_Parser_Const.false_lid in
-          FStar_Syntax_Util.abs uu___ uu___1
-            (FStar_Pervasives_Native.Some
-               (FStar_Syntax_Util.mk_residual_comp
-                  FStar_Parser_Const.effect_Tot_lid
-                  FStar_Pervasives_Native.None [FStar_Syntax_Syntax.TOTAL])) in
-        let md =
-          FStar_TypeChecker_Env.get_effect_decl env
-            FStar_Parser_Const.effect_PURE_lid in
-        mk_comp md u t wp []
-let (get_neg_branch_conds :
-  FStar_Syntax_Syntax.formula Prims.list ->
-    (FStar_Syntax_Syntax.formula Prims.list * FStar_Syntax_Syntax.formula))
-  =
-  fun branch_conds ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 =
-          FStar_Compiler_Effect.op_Bar_Greater branch_conds
-            (FStar_Compiler_List.fold_left
-               (fun uu___3 ->
-                  fun g ->
-                    match uu___3 with
-                    | (conds, acc) ->
-                        let cond =
-                          let uu___4 =
-                            let uu___5 =
-                              FStar_Compiler_Effect.op_Bar_Greater g
-                                FStar_Syntax_Util.b2t in
-                            FStar_Compiler_Effect.op_Bar_Greater uu___5
-                              FStar_Syntax_Util.mk_neg in
-                          FStar_Syntax_Util.mk_conj acc uu___4 in
-                        ((FStar_Compiler_List.op_At conds [cond]), cond))
-               ([FStar_Syntax_Util.t_true], FStar_Syntax_Util.t_true)) in
-        FStar_Compiler_Effect.op_Bar_Greater uu___2
-          FStar_Pervasives_Native.fst in
-      FStar_Compiler_Effect.op_Bar_Greater uu___1
-        (fun l ->
-           FStar_Compiler_List.splitAt
-             ((FStar_Compiler_List.length l) - Prims.int_one) l) in
-    FStar_Compiler_Effect.op_Bar_Greater uu___
-      (fun uu___1 ->
-         match uu___1 with
-         | (l1, l2) -> let uu___2 = FStar_Compiler_List.hd l2 in (l1, uu___2))
-let (bind_cases :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ ->
-      (FStar_Syntax_Syntax.typ * FStar_Ident.lident *
-        FStar_Syntax_Syntax.cflag Prims.list *
-        (Prims.bool -> FStar_TypeChecker_Common.lcomp)) Prims.list ->
-        FStar_Syntax_Syntax.bv -> FStar_TypeChecker_Common.lcomp)
-  =
-  fun env0 ->
-    fun res_t ->
-      fun lcases ->
-        fun scrutinee ->
-          let env =
-            let uu___ =
-              let uu___1 =
-                FStar_Compiler_Effect.op_Bar_Greater scrutinee
-                  FStar_Syntax_Syntax.mk_binder in
-              [uu___1] in
-            FStar_TypeChecker_Env.push_binders env0 uu___ in
-          let eff =
-            FStar_Compiler_List.fold_left
-              (fun eff1 ->
-                 fun uu___ ->
-                   match uu___ with
-                   | (uu___1, eff_label, uu___2, uu___3) ->
-                       join_effects env eff1 eff_label)
-              FStar_Parser_Const.effect_PURE_lid lcases in
-          let uu___ =
-            let uu___1 =
-              FStar_Compiler_Effect.op_Bar_Greater lcases
-                (FStar_Compiler_Util.for_some
-                   (fun uu___2 ->
-                      match uu___2 with
-                      | (uu___3, uu___4, flags, uu___5) ->
-                          FStar_Compiler_Effect.op_Bar_Greater flags
-                            (FStar_Compiler_Util.for_some
-                               (fun uu___6 ->
-                                  match uu___6 with
-                                  | FStar_Syntax_Syntax.SHOULD_NOT_INLINE ->
-                                      true
-                                  | uu___7 -> false)))) in
-            if uu___1
-            then (true, [FStar_Syntax_Syntax.SHOULD_NOT_INLINE])
-            else (false, []) in
-          match uu___ with
-          | (should_not_inline_whole_match, bind_cases_flags) ->
-              let bind_cases1 uu___1 =
-                let u_res_t = env.FStar_TypeChecker_Env.universe_of env res_t in
-                let uu___2 =
-                  env.FStar_TypeChecker_Env.lax && (FStar_Options.ml_ish ()) in
-                if uu___2
-                then
-                  let uu___3 = lax_mk_tot_or_comp_l eff u_res_t res_t [] in
-                  (uu___3, FStar_TypeChecker_Env.trivial_guard)
-                else
-                  (let maybe_return eff_label_then cthen =
-                     let uu___4 =
-                       should_not_inline_whole_match ||
-                         (let uu___5 = is_pure_or_ghost_effect env eff in
-                          Prims.op_Negation uu___5) in
-                     if uu___4 then cthen true else cthen false in
-                   let uu___4 =
-                     let uu___5 =
-                       FStar_Compiler_Effect.op_Bar_Greater lcases
-                         (FStar_Compiler_List.map
-                            (fun uu___6 ->
-                               match uu___6 with
-                               | (g, uu___7, uu___8, uu___9) -> g)) in
-                     get_neg_branch_conds uu___5 in
-                   match uu___4 with
-                   | (neg_branch_conds, exhaustiveness_branch_cond) ->
-                       let uu___5 =
-                         match lcases with
-                         | [] ->
-                             let uu___6 =
-                               comp_pure_wp_false env u_res_t res_t in
-                             (FStar_Pervasives_Native.None, uu___6,
-                               FStar_TypeChecker_Env.trivial_guard)
-                         | uu___6 ->
-                             let uu___7 =
-                               let uu___8 =
-                                 let uu___9 =
-                                   FStar_Compiler_Effect.op_Bar_Greater
-                                     neg_branch_conds
-                                     (FStar_Compiler_List.splitAt
-                                        ((FStar_Compiler_List.length lcases)
-                                           - Prims.int_one)) in
-                                 FStar_Compiler_Effect.op_Bar_Greater uu___9
-                                   (fun uu___10 ->
-                                      match uu___10 with
-                                      | (l1, l2) ->
-                                          let uu___11 =
-                                            FStar_Compiler_List.hd l2 in
-                                          (l1, uu___11)) in
-                               match uu___8 with
-                               | (neg_branch_conds1, neg_last) ->
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_Compiler_Effect.op_Bar_Greater
-                                         lcases
-                                         (FStar_Compiler_List.splitAt
-                                            ((FStar_Compiler_List.length
-                                                lcases)
-                                               - Prims.int_one)) in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___10
-                                       (fun uu___11 ->
-                                          match uu___11 with
-                                          | (l1, l2) ->
-                                              let uu___12 =
-                                                FStar_Compiler_List.hd l2 in
-                                              (l1, uu___12)) in
-                                   (match uu___9 with
-                                    | (lcases1,
-                                       (g_last, eff_last, uu___10, c_last))
-                                        ->
-                                        let uu___11 =
-                                          let lc =
-                                            maybe_return eff_last c_last in
-                                          let uu___12 =
-                                            FStar_TypeChecker_Common.lcomp_comp
-                                              lc in
-                                          match uu___12 with
-                                          | (c, g) ->
-                                              let uu___13 =
-                                                let uu___14 =
-                                                  let uu___15 =
-                                                    FStar_Syntax_Util.b2t
-                                                      g_last in
-                                                  FStar_Syntax_Util.mk_conj
-                                                    uu___15 neg_last in
-                                                FStar_TypeChecker_Common.weaken_guard_formula
-                                                  g uu___14 in
-                                              (c, uu___13) in
-                                        (match uu___11 with
-                                         | (c, g) ->
-                                             let uu___12 =
-                                               let uu___13 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   eff_last
-                                                   (FStar_TypeChecker_Env.norm_eff_name
-                                                      env) in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___13
-                                                 (FStar_TypeChecker_Env.get_effect_decl
-                                                    env) in
-                                             (lcases1, neg_branch_conds1,
-                                               uu___12, c, g))) in
-                             (match uu___7 with
-                              | (lcases1, neg_branch_conds1, md, comp,
-                                 g_comp) ->
-                                  FStar_Compiler_List.fold_right2
-                                    (fun uu___8 ->
-                                       fun neg_cond ->
-                                         fun uu___9 ->
-                                           match (uu___8, uu___9) with
-                                           | ((g, eff_label, uu___10, cthen),
-                                              (uu___11, celse, g_comp1)) ->
-                                               let uu___12 =
-                                                 let uu___13 =
-                                                   maybe_return eff_label
-                                                     cthen in
-                                                 FStar_TypeChecker_Common.lcomp_comp
-                                                   uu___13 in
-                                               (match uu___12 with
-                                                | (cthen1, g_then) ->
-                                                    let uu___13 =
-                                                      let uu___14 =
-                                                        lift_comps_sep_guards
-                                                          env cthen1 celse
-                                                          FStar_Pervasives_Native.None
-                                                          false in
-                                                      match uu___14 with
-                                                      | (m, cthen2, celse1,
-                                                         g_lift_then,
-                                                         g_lift_else) ->
-                                                          let md1 =
-                                                            FStar_TypeChecker_Env.get_effect_decl
-                                                              env m in
-                                                          let uu___15 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              cthen2
-                                                              (FStar_TypeChecker_Env.comp_to_comp_typ
-                                                                 env) in
-                                                          let uu___16 =
-                                                            FStar_Compiler_Effect.op_Bar_Greater
-                                                              celse1
-                                                              (FStar_TypeChecker_Env.comp_to_comp_typ
-                                                                 env) in
-                                                          (md1, uu___15,
-                                                            uu___16,
-                                                            g_lift_then,
-                                                            g_lift_else) in
-                                                    (match uu___13 with
-                                                     | (md1, ct_then,
-                                                        ct_else, g_lift_then,
-                                                        g_lift_else) ->
-                                                         let fn =
-                                                           let uu___14 =
-                                                             FStar_Compiler_Effect.op_Bar_Greater
-                                                               md1
-                                                               FStar_Syntax_Util.is_layered in
-                                                           if uu___14
-                                                           then
-                                                             mk_layered_conjunction
-                                                           else
-                                                             mk_non_layered_conjunction in
-                                                         let uu___14 =
-                                                           let uu___15 =
-                                                             FStar_TypeChecker_Env.get_range
-                                                               env in
-                                                           fn env md1 u_res_t
-                                                             res_t g ct_then
-                                                             ct_else uu___15 in
-                                                         (match uu___14 with
-                                                          | (c,
-                                                             g_conjunction)
-                                                              ->
-                                                              let uu___15 =
-                                                                let g1 =
-                                                                  FStar_Syntax_Util.b2t
-                                                                    g in
-                                                                let uu___16 =
-                                                                  let uu___17
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guard
-                                                                    g_then
-                                                                    g_lift_then in
-                                                                  let uu___18
-                                                                    =
-                                                                    FStar_Syntax_Util.mk_conj
-                                                                    neg_cond
-                                                                    g1 in
-                                                                  FStar_TypeChecker_Common.weaken_guard_formula
-                                                                    uu___17
-                                                                    uu___18 in
-                                                                let uu___17 =
-                                                                  let uu___18
-                                                                    =
-                                                                    let uu___19
-                                                                    =
-                                                                    FStar_Syntax_Util.mk_neg
-                                                                    g1 in
-                                                                    FStar_Syntax_Util.mk_conj
-                                                                    neg_cond
-                                                                    uu___19 in
-                                                                  FStar_TypeChecker_Common.weaken_guard_formula
-                                                                    g_lift_else
-                                                                    uu___18 in
-                                                                (uu___16,
-                                                                  uu___17) in
-                                                              (match uu___15
-                                                               with
-                                                               | (g_then1,
-                                                                  g_else) ->
-                                                                   let uu___16
-                                                                    =
-                                                                    FStar_TypeChecker_Env.conj_guards
-                                                                    [g_comp1;
-                                                                    g_then1;
-                                                                    g_else;
-                                                                    g_conjunction] in
-                                                                   ((FStar_Pervasives_Native.Some
-                                                                    md1), c,
-                                                                    uu___16))))))
-                                    lcases1 neg_branch_conds1
-                                    ((FStar_Pervasives_Native.Some md), comp,
-                                      g_comp)) in
-                       (match uu___5 with
-                        | (md, comp, g_comp) ->
-                            let uu___6 =
-                              let uu___7 =
-                                let check =
-                                  FStar_Syntax_Util.mk_imp
-                                    exhaustiveness_branch_cond
-                                    FStar_Syntax_Util.t_false in
-                                let check1 =
-                                  let uu___8 =
-                                    FStar_TypeChecker_Env.get_range env in
-                                  label
-                                    FStar_TypeChecker_Err.exhaustiveness_check
-                                    uu___8 check in
-                                strengthen_comp env
-                                  FStar_Pervasives_Native.None comp check1
-                                  bind_cases_flags in
-                              match uu___7 with
-                              | (c, g) ->
-                                  let uu___8 =
-                                    FStar_TypeChecker_Env.conj_guard g_comp g in
-                                  (c, uu___8) in
-                            (match uu___6 with
-                             | (comp1, g_comp1) ->
-                                 (match lcases with
-                                  | [] -> (comp1, g_comp1)
-                                  | uu___7::[] -> (comp1, g_comp1)
-                                  | uu___7 ->
-                                      let uu___8 =
-                                        let uu___9 =
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            md FStar_Compiler_Util.must in
-                                        FStar_Compiler_Effect.op_Bar_Greater
-                                          uu___9 FStar_Syntax_Util.is_layered in
-                                      if uu___8
-                                      then (comp1, g_comp1)
-                                      else
-                                        (let comp2 =
-                                           FStar_TypeChecker_Env.comp_to_comp_typ
-                                             env comp1 in
-                                         let md1 =
-                                           FStar_TypeChecker_Env.get_effect_decl
-                                             env
-                                             comp2.FStar_Syntax_Syntax.effect_name in
-                                         let uu___10 = destruct_wp_comp comp2 in
-                                         match uu___10 with
-                                         | (uu___11, uu___12, wp) ->
-                                             let ite_wp =
-                                               let uu___13 =
-                                                 FStar_Compiler_Effect.op_Bar_Greater
-                                                   md1
-                                                   FStar_Syntax_Util.get_wp_ite_combinator in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___13
-                                                 FStar_Compiler_Util.must in
-                                             let wp1 =
-                                               let uu___13 =
-                                                 FStar_TypeChecker_Env.inst_effect_fun_with
-                                                   [u_res_t] env md1 ite_wp in
-                                               let uu___14 =
-                                                 let uu___15 =
-                                                   FStar_Syntax_Syntax.as_arg
-                                                     res_t in
-                                                 let uu___16 =
-                                                   let uu___17 =
-                                                     FStar_Syntax_Syntax.as_arg
-                                                       wp in
-                                                   [uu___17] in
-                                                 uu___15 :: uu___16 in
-                                               FStar_Syntax_Syntax.mk_Tm_app
-                                                 uu___13 uu___14
-                                                 wp.FStar_Syntax_Syntax.pos in
-                                             let uu___13 =
-                                               mk_comp md1 u_res_t res_t wp1
-                                                 bind_cases_flags in
-                                             (uu___13, g_comp1)))))) in
-              FStar_TypeChecker_Common.mk_lcomp eff res_t bind_cases_flags
-                bind_cases1
-let (check_comp :
-  FStar_TypeChecker_Env.env ->
-    Prims.bool ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.comp ->
-          FStar_Syntax_Syntax.comp ->
-            (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.comp *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun use_eq ->
-      fun e ->
-        fun c ->
-          fun c' ->
-            (let uu___1 =
-               FStar_Compiler_Effect.op_Less_Bar
-                 (FStar_TypeChecker_Env.debug env) FStar_Options.Extreme in
-             if uu___1
-             then
-               let uu___2 = FStar_Syntax_Print.term_to_string e in
-               let uu___3 = FStar_Syntax_Print.comp_to_string c in
-               let uu___4 = FStar_Syntax_Print.comp_to_string c' in
-               FStar_Compiler_Util.print4
-                 "Checking comp relation:\n%s has type %s\n\t %s \n%s\n"
-                 uu___2 uu___3 (if use_eq then "$:" else "<:") uu___4
-             else ());
-            (let f =
-               if use_eq
-               then FStar_TypeChecker_Rel.eq_comp
-               else FStar_TypeChecker_Rel.sub_comp in
-             let uu___1 = f env c c' in
-             match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 if use_eq
-                 then
-                   let uu___2 =
-                     FStar_TypeChecker_Err.computed_computation_type_does_not_match_annotation_eq
-                       env e c c' in
-                   let uu___3 = FStar_TypeChecker_Env.get_range env in
-                   FStar_Errors.raise_error uu___2 uu___3
-                 else
-                   (let uu___3 =
-                      FStar_TypeChecker_Err.computed_computation_type_does_not_match_annotation
-                        env e c c' in
-                    let uu___4 = FStar_TypeChecker_Env.get_range env in
-                    FStar_Errors.raise_error uu___3 uu___4)
-             | FStar_Pervasives_Native.Some g -> (e, c', g))
-let (universe_of_comp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.universe ->
-      FStar_Syntax_Syntax.comp -> FStar_Syntax_Syntax.universe)
-  =
-  fun env ->
-    fun u_res ->
-      fun c ->
-        let c_lid =
-          let uu___ =
-            FStar_Compiler_Effect.op_Bar_Greater c
-              FStar_Syntax_Util.comp_effect_name in
-          FStar_Compiler_Effect.op_Bar_Greater uu___
-            (FStar_TypeChecker_Env.norm_eff_name env) in
-        let uu___ = FStar_Syntax_Util.is_pure_or_ghost_effect c_lid in
-        if uu___
-        then u_res
-        else
-          (let is_total =
-             let uu___2 = FStar_TypeChecker_Env.lookup_effect_quals env c_lid in
-             FStar_Compiler_Effect.op_Bar_Greater uu___2
-               (FStar_Compiler_List.existsb
-                  (fun q -> q = FStar_Syntax_Syntax.TotalEffect)) in
-           if Prims.op_Negation is_total
-           then FStar_Syntax_Syntax.U_zero
-           else
-             (let uu___3 = FStar_TypeChecker_Env.effect_repr env c u_res in
-              match uu___3 with
-              | FStar_Pervasives_Native.None ->
-                  let uu___4 =
-                    let uu___5 =
-                      let uu___6 = FStar_Syntax_Print.lid_to_string c_lid in
-                      FStar_Compiler_Util.format1
-                        "Effect %s is marked total but does not have a repr"
-                        uu___6 in
-                    (FStar_Errors.Fatal_EffectCannotBeReified, uu___5) in
-                  FStar_Errors.raise_error uu___4 c.FStar_Syntax_Syntax.pos
-              | FStar_Pervasives_Native.Some tm ->
-                  env.FStar_TypeChecker_Env.universe_of env tm))
-let (check_trivial_precondition_wp :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      (FStar_Syntax_Syntax.comp_typ * FStar_Syntax_Syntax.formula *
-        FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun c ->
-      let ct =
-        FStar_Compiler_Effect.op_Bar_Greater c
-          (FStar_TypeChecker_Env.unfold_effect_abbrev env) in
-      let md =
-        FStar_TypeChecker_Env.get_effect_decl env
-          ct.FStar_Syntax_Syntax.effect_name in
-      let uu___ = destruct_wp_comp ct in
-      match uu___ with
-      | (u_t, t, wp) ->
-          let vc =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 =
-                  FStar_Compiler_Effect.op_Bar_Greater md
-                    FStar_Syntax_Util.get_wp_trivial_combinator in
-                FStar_Compiler_Effect.op_Bar_Greater uu___3
-                  FStar_Compiler_Util.must in
-              FStar_TypeChecker_Env.inst_effect_fun_with [u_t] env md uu___2 in
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.as_arg t in
-              let uu___4 =
-                let uu___5 = FStar_Syntax_Syntax.as_arg wp in [uu___5] in
-              uu___3 :: uu___4 in
-            let uu___3 = FStar_TypeChecker_Env.get_range env in
-            FStar_Syntax_Syntax.mk_Tm_app uu___1 uu___2 uu___3 in
-          let uu___1 =
-            FStar_Compiler_Effect.op_Less_Bar
-              FStar_TypeChecker_Env.guard_of_guard_formula
-              (FStar_TypeChecker_Common.NonTrivial vc) in
-          (ct, vc, uu___1)
-let (maybe_lift :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun e ->
-      fun c1 ->
-        fun c2 ->
-          fun t ->
-            let m1 = FStar_TypeChecker_Env.norm_eff_name env c1 in
-            let m2 = FStar_TypeChecker_Env.norm_eff_name env c2 in
-            let uu___ =
-              ((FStar_Ident.lid_equals m1 m2) ||
-                 ((FStar_Syntax_Util.is_pure_effect c1) &&
-                    (FStar_Syntax_Util.is_ghost_effect c2)))
-                ||
-                ((FStar_Syntax_Util.is_pure_effect c2) &&
-                   (FStar_Syntax_Util.is_ghost_effect c1)) in
-            if uu___
-            then e
-            else
-              FStar_Syntax_Syntax.mk
-                (FStar_Syntax_Syntax.Tm_meta
-                   (e, (FStar_Syntax_Syntax.Meta_monadic_lift (m1, m2, t))))
-                e.FStar_Syntax_Syntax.pos
-let (maybe_monadic :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.typ -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun e ->
-      fun c ->
-        fun t ->
-          let m = FStar_TypeChecker_Env.norm_eff_name env c in
-          let uu___ =
-            ((is_pure_or_ghost_effect env m) ||
-               (FStar_Ident.lid_equals m FStar_Parser_Const.effect_Tot_lid))
-              ||
-              (FStar_Ident.lid_equals m FStar_Parser_Const.effect_GTot_lid) in
-          if uu___
-          then e
-          else
-            FStar_Syntax_Syntax.mk
-              (FStar_Syntax_Syntax.Tm_meta
-                 (e, (FStar_Syntax_Syntax.Meta_monadic (m, t))))
-              e.FStar_Syntax_Syntax.pos
-let (coerce_with :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp ->
-        FStar_Syntax_Syntax.typ ->
-          FStar_Ident.lident ->
-            FStar_Syntax_Syntax.universes ->
-              FStar_Syntax_Syntax.args ->
-                (FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.comp) ->
-                  (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp))
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        fun ty ->
-          fun f ->
-            fun us ->
-              fun eargs ->
-                fun mkcomp ->
-                  let uu___ = FStar_TypeChecker_Env.try_lookup_lid env f in
-                  match uu___ with
-                  | FStar_Pervasives_Native.Some uu___1 ->
-                      ((let uu___3 =
-                          FStar_TypeChecker_Env.debug env
-                            (FStar_Options.Other "Coercions") in
-                        if uu___3
-                        then
-                          let uu___4 = FStar_Ident.string_of_lid f in
-                          FStar_Compiler_Util.print1 "Coercing with %s!\n"
-                            uu___4
-                        else ());
-                       (let lc2 =
-                          let uu___3 = mkcomp ty in
-                          FStar_Compiler_Effect.op_Less_Bar
-                            FStar_TypeChecker_Common.lcomp_of_comp uu___3 in
-                        let lc_res =
-                          bind e.FStar_Syntax_Syntax.pos env
-                            (FStar_Pervasives_Native.Some e) lc
-                            (FStar_Pervasives_Native.None, lc2) in
-                        let coercion =
-                          let uu___3 =
-                            FStar_Ident.set_lid_range f
-                              e.FStar_Syntax_Syntax.pos in
-                          FStar_Syntax_Syntax.fvar uu___3
-                            (FStar_Syntax_Syntax.Delta_constant_at_level
-                               Prims.int_one) FStar_Pervasives_Native.None in
-                        let coercion1 =
-                          FStar_Syntax_Syntax.mk_Tm_uinst coercion us in
-                        let e1 =
-                          let uu___3 =
-                            FStar_TypeChecker_Common.is_pure_or_ghost_lcomp
-                              lc in
-                          if uu___3
-                          then
-                            let uu___4 =
-                              let uu___5 =
-                                let uu___6 = FStar_Syntax_Syntax.as_arg e in
-                                [uu___6] in
-                              FStar_Compiler_List.op_At eargs uu___5 in
-                            FStar_Syntax_Syntax.mk_Tm_app coercion1 uu___4
-                              e.FStar_Syntax_Syntax.pos
-                          else
-                            (let x =
-                               FStar_Syntax_Syntax.new_bv
-                                 (FStar_Pervasives_Native.Some
-                                    (e.FStar_Syntax_Syntax.pos))
-                                 lc.FStar_TypeChecker_Common.res_typ in
-                             let e2 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   let uu___7 =
-                                     let uu___8 =
-                                       FStar_Compiler_Effect.op_Bar_Greater x
-                                         FStar_Syntax_Syntax.bv_to_name in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___8 FStar_Syntax_Syntax.as_arg in
-                                   [uu___7] in
-                                 FStar_Compiler_List.op_At eargs uu___6 in
-                               FStar_Syntax_Syntax.mk_Tm_app coercion1 uu___5
-                                 e.FStar_Syntax_Syntax.pos in
-                             let e3 =
-                               maybe_lift env e
-                                 lc.FStar_TypeChecker_Common.eff_name
-                                 lc_res.FStar_TypeChecker_Common.eff_name
-                                 lc.FStar_TypeChecker_Common.res_typ in
-                             let e21 =
-                               let uu___5 =
-                                 FStar_TypeChecker_Env.push_bv env x in
-                               maybe_lift uu___5 e2
-                                 lc2.FStar_TypeChecker_Common.eff_name
-                                 lc_res.FStar_TypeChecker_Common.eff_name ty in
-                             let lb =
-                               FStar_Syntax_Util.mk_letbinding
-                                 (FStar_Pervasives.Inl x) []
-                                 lc.FStar_TypeChecker_Common.res_typ
-                                 lc_res.FStar_TypeChecker_Common.eff_name e3
-                                 [] e3.FStar_Syntax_Syntax.pos in
-                             let e4 =
-                               let uu___5 =
-                                 let uu___6 =
-                                   let uu___7 =
-                                     let uu___8 =
-                                       let uu___9 =
-                                         FStar_Syntax_Syntax.mk_binder x in
-                                       [uu___9] in
-                                     FStar_Syntax_Subst.close uu___8 e21 in
-                                   ((false, [lb]), uu___7) in
-                                 FStar_Syntax_Syntax.Tm_let uu___6 in
-                               FStar_Syntax_Syntax.mk uu___5
-                                 e3.FStar_Syntax_Syntax.pos in
-                             maybe_monadic env e4
-                               lc_res.FStar_TypeChecker_Common.eff_name
-                               lc_res.FStar_TypeChecker_Common.res_typ) in
-                        (e1, lc_res)))
-                  | FStar_Pervasives_Native.None ->
-                      ((let uu___2 =
-                          let uu___3 =
-                            let uu___4 = FStar_Ident.string_of_lid f in
-                            FStar_Compiler_Util.format1
-                              "Coercion %s was not found in the environment, not coercing."
-                              uu___4 in
-                          (FStar_Errors.Warning_CoercionNotFound, uu___3) in
-                        FStar_Errors.log_issue e.FStar_Syntax_Syntax.pos
-                          uu___2);
-                       (e, lc))
-type isErased =
-  | Yes of FStar_Syntax_Syntax.term 
-  | Maybe 
-  | No 
-let (uu___is_Yes : isErased -> Prims.bool) =
-  fun projectee -> match projectee with | Yes _0 -> true | uu___ -> false
-let (__proj__Yes__item___0 : isErased -> FStar_Syntax_Syntax.term) =
-  fun projectee -> match projectee with | Yes _0 -> _0
-let (uu___is_Maybe : isErased -> Prims.bool) =
-  fun projectee -> match projectee with | Maybe -> true | uu___ -> false
-let (uu___is_No : isErased -> Prims.bool) =
-  fun projectee -> match projectee with | No -> true | uu___ -> false
-let rec (check_erased :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> isErased) =
-  fun env ->
-    fun t ->
-      let norm' =
-        FStar_TypeChecker_Normalize.normalize
-          [FStar_TypeChecker_Env.Beta;
-          FStar_TypeChecker_Env.Eager_unfolding;
-          FStar_TypeChecker_Env.UnfoldUntil
-            FStar_Syntax_Syntax.delta_constant;
-          FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta;
-          FStar_TypeChecker_Env.Primops;
-          FStar_TypeChecker_Env.Weak;
-          FStar_TypeChecker_Env.HNF;
-          FStar_TypeChecker_Env.Iota] in
-      let t1 = norm' env t in
-      let t2 = FStar_Syntax_Util.unrefine t1 in
-      let uu___ = FStar_Syntax_Util.head_and_args t2 in
-      match uu___ with
-      | (h, args) ->
-          let h1 = FStar_Syntax_Util.un_uinst h in
-          let r =
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Subst.compress h1 in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            match uu___1 with
-            | (FStar_Syntax_Syntax.Tm_fvar fv,
-               (a, FStar_Pervasives_Native.None)::[]) when
-                FStar_Syntax_Syntax.fv_eq_lid fv
-                  FStar_Parser_Const.erased_lid
-                -> Yes a
-            | (FStar_Syntax_Syntax.Tm_uvar uu___2, uu___3) -> Maybe
-            | (FStar_Syntax_Syntax.Tm_unknown, uu___2) -> Maybe
-            | (FStar_Syntax_Syntax.Tm_match
-               (uu___2, uu___3, branches, uu___4), uu___5) ->
-                FStar_Compiler_Effect.op_Bar_Greater branches
-                  (FStar_Compiler_List.fold_left
-                     (fun acc ->
-                        fun br ->
-                          match acc with
-                          | Yes uu___6 -> Maybe
-                          | Maybe -> Maybe
-                          | No ->
-                              let uu___6 = FStar_Syntax_Subst.open_branch br in
-                              (match uu___6 with
-                               | (uu___7, uu___8, br_body) ->
-                                   let uu___9 =
-                                     let uu___10 =
-                                       let uu___11 =
-                                         let uu___12 =
-                                           let uu___13 =
-                                             FStar_Compiler_Effect.op_Bar_Greater
-                                               br_body
-                                               FStar_Syntax_Free.names in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___13
-                                             FStar_Compiler_Util.set_elements in
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           uu___12
-                                           (FStar_TypeChecker_Env.push_bvs
-                                              env) in
-                                       check_erased uu___11 in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       br_body uu___10 in
-                                   (match uu___9 with
-                                    | No -> No
-                                    | uu___10 -> Maybe))) No)
-            | uu___2 -> No in
-          r
-let (maybe_coerce_lc :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp ->
-        FStar_Syntax_Syntax.typ ->
-          (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-            FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        fun exp_t ->
-          let should_coerce =
-            (env.FStar_TypeChecker_Env.phase1 ||
-               env.FStar_TypeChecker_Env.lax)
-              || (FStar_Options.lax ()) in
-          if Prims.op_Negation should_coerce
-          then (e, lc, FStar_TypeChecker_Env.trivial_guard)
-          else
-            (let is_t_term t =
-               let t1 = FStar_TypeChecker_Normalize.unfold_whnf env t in
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress t1 in
-                 uu___2.FStar_Syntax_Syntax.n in
-               match uu___1 with
-               | FStar_Syntax_Syntax.Tm_fvar fv ->
-                   FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.term_lid
-               | uu___2 -> false in
-             let is_t_term_view t =
-               let t1 = FStar_TypeChecker_Normalize.unfold_whnf env t in
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress t1 in
-                 uu___2.FStar_Syntax_Syntax.n in
-               match uu___1 with
-               | FStar_Syntax_Syntax.Tm_fvar fv ->
-                   FStar_Syntax_Syntax.fv_eq_lid fv
-                     FStar_Parser_Const.term_view_lid
-               | uu___2 -> false in
-             let is_type t =
-               let t1 = FStar_TypeChecker_Normalize.unfold_whnf env t in
-               let t2 = FStar_Syntax_Util.unrefine t1 in
-               let uu___1 =
-                 let uu___2 = FStar_Syntax_Subst.compress t2 in
-                 uu___2.FStar_Syntax_Syntax.n in
-               match uu___1 with
-               | FStar_Syntax_Syntax.Tm_type uu___2 -> true
-               | uu___2 -> false in
-             let res_typ =
-               FStar_Syntax_Util.unrefine lc.FStar_TypeChecker_Common.res_typ in
-             let uu___1 = FStar_Syntax_Util.head_and_args res_typ in
-             match uu___1 with
-             | (head, args) ->
-                 ((let uu___3 =
-                     FStar_TypeChecker_Env.debug env
-                       (FStar_Options.Other "Coercions") in
-                   if uu___3
-                   then
-                     let uu___4 =
-                       FStar_Compiler_Range.string_of_range
-                         e.FStar_Syntax_Syntax.pos in
-                     let uu___5 = FStar_Syntax_Print.term_to_string e in
-                     let uu___6 = FStar_Syntax_Print.term_to_string res_typ in
-                     let uu___7 = FStar_Syntax_Print.term_to_string exp_t in
-                     FStar_Compiler_Util.print4
-                       "(%s) Trying to coerce %s from type (%s) to type (%s)\n"
-                       uu___4 uu___5 uu___6 uu___7
-                   else ());
-                  (let mk_erased u t =
-                     let uu___3 =
-                       let uu___4 =
-                         fvar_const env FStar_Parser_Const.erased_lid in
-                       FStar_Syntax_Syntax.mk_Tm_uinst uu___4 [u] in
-                     let uu___4 =
-                       let uu___5 = FStar_Syntax_Syntax.as_arg t in [uu___5] in
-                     FStar_Syntax_Util.mk_app uu___3 uu___4 in
-                   let uu___3 =
-                     let uu___4 =
-                       let uu___5 = FStar_Syntax_Util.un_uinst head in
-                       uu___5.FStar_Syntax_Syntax.n in
-                     (uu___4, args) in
-                   match uu___3 with
-                   | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.bool_lid)
-                         && (is_type exp_t)
-                       ->
-                       let uu___4 =
-                         coerce_with env e lc FStar_Syntax_Util.ktype0
-                           FStar_Parser_Const.b2t_lid [] []
-                           FStar_Syntax_Syntax.mk_Total in
-                       (match uu___4 with
-                        | (e1, lc1) ->
-                            (e1, lc1, FStar_TypeChecker_Env.trivial_guard))
-                   | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.term_lid)
-                         && (is_t_term_view exp_t)
-                       ->
-                       let uu___4 =
-                         coerce_with env e lc FStar_Syntax_Syntax.t_term_view
-                           FStar_Parser_Const.inspect [] []
-                           FStar_Syntax_Syntax.mk_Tac in
-                       (match uu___4 with
-                        | (e1, lc1) ->
-                            (e1, lc1, FStar_TypeChecker_Env.trivial_guard))
-                   | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.term_view_lid)
-                         && (is_t_term exp_t)
-                       ->
-                       let uu___4 =
-                         coerce_with env e lc FStar_Syntax_Syntax.t_term
-                           FStar_Parser_Const.pack [] []
-                           FStar_Syntax_Syntax.mk_Tac in
-                       (match uu___4 with
-                        | (e1, lc1) ->
-                            (e1, lc1, FStar_TypeChecker_Env.trivial_guard))
-                   | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                       (FStar_Syntax_Syntax.fv_eq_lid fv
-                          FStar_Parser_Const.binder_lid)
-                         && (is_t_term exp_t)
-                       ->
-                       let uu___4 =
-                         coerce_with env e lc FStar_Syntax_Syntax.t_term
-                           FStar_Parser_Const.binder_to_term [] []
-                           FStar_Syntax_Syntax.mk_Tac in
-                       (match uu___4 with
-                        | (e1, lc1) ->
-                            (e1, lc1, FStar_TypeChecker_Env.trivial_guard))
-                   | uu___4 ->
-                       let uu___5 =
-                         let uu___6 = check_erased env res_typ in
-                         let uu___7 = check_erased env exp_t in
-                         (uu___6, uu___7) in
-                       (match uu___5 with
-                        | (No, Yes ty) ->
-                            let u =
-                              env.FStar_TypeChecker_Env.universe_of env ty in
-                            let uu___6 =
-                              FStar_TypeChecker_Rel.get_subtyping_predicate
-                                env res_typ ty in
-                            (match uu___6 with
-                             | FStar_Pervasives_Native.None ->
-                                 (e, lc, FStar_TypeChecker_Env.trivial_guard)
-                             | FStar_Pervasives_Native.Some g ->
-                                 let g1 =
-                                   FStar_TypeChecker_Env.apply_guard g e in
-                                 let uu___7 =
-                                   let uu___8 =
-                                     let uu___9 = FStar_Syntax_Syntax.iarg ty in
-                                     [uu___9] in
-                                   coerce_with env e lc exp_t
-                                     FStar_Parser_Const.hide [u] uu___8
-                                     FStar_Syntax_Syntax.mk_Total in
-                                 (match uu___7 with
-                                  | (e1, lc1) -> (e1, lc1, g1)))
-                        | (Yes ty, No) ->
-                            let u =
-                              env.FStar_TypeChecker_Env.universe_of env ty in
-                            let uu___6 =
-                              let uu___7 =
-                                let uu___8 = FStar_Syntax_Syntax.iarg ty in
-                                [uu___8] in
-                              coerce_with env e lc ty
-                                FStar_Parser_Const.reveal [u] uu___7
-                                FStar_Syntax_Syntax.mk_GTotal in
-                            (match uu___6 with
-                             | (e1, lc1) ->
-                                 (e1, lc1,
-                                   FStar_TypeChecker_Env.trivial_guard))
-                        | uu___6 ->
-                            (e, lc, FStar_TypeChecker_Env.trivial_guard)))))
-let (coerce_views :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp ->
-        (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp)
-          FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        let rt = lc.FStar_TypeChecker_Common.res_typ in
-        let rt1 = FStar_Syntax_Util.unrefine rt in
-        let uu___ = FStar_Syntax_Util.head_and_args rt1 in
-        match uu___ with
-        | (hd, args) ->
-            let uu___1 =
-              let uu___2 =
-                let uu___3 = FStar_Syntax_Subst.compress hd in
-                uu___3.FStar_Syntax_Syntax.n in
-              (uu___2, args) in
-            (match uu___1 with
-             | (FStar_Syntax_Syntax.Tm_fvar fv, []) when
-                 FStar_Syntax_Syntax.fv_eq_lid fv FStar_Parser_Const.term_lid
-                 ->
-                 let uu___2 =
-                   coerce_with env e lc FStar_Syntax_Syntax.t_term_view
-                     FStar_Parser_Const.inspect [] []
-                     FStar_Syntax_Syntax.mk_Tac in
-                 FStar_Compiler_Effect.op_Less_Bar
-                   (fun uu___3 -> FStar_Pervasives_Native.Some uu___3) uu___2
-             | uu___2 -> FStar_Pervasives_Native.None)
-let (weaken_result_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp ->
-        FStar_Syntax_Syntax.typ ->
-          Prims.bool ->
-            (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        fun t ->
-          fun use_eq ->
-            (let uu___1 = FStar_TypeChecker_Env.debug env FStar_Options.High in
-             if uu___1
-             then
-               let uu___2 = FStar_Syntax_Print.term_to_string e in
-               let uu___3 = FStar_TypeChecker_Common.lcomp_to_string lc in
-               let uu___4 = FStar_Syntax_Print.term_to_string t in
-               FStar_Compiler_Util.print3
-                 "weaken_result_typ e=(%s) lc=(%s) t=(%s)\n" uu___2 uu___3
-                 uu___4
-             else ());
-            (let use_eq1 =
-               (use_eq || env.FStar_TypeChecker_Env.use_eq_strict) ||
-                 (let uu___1 =
-                    FStar_TypeChecker_Env.effect_decl_opt env
-                      lc.FStar_TypeChecker_Common.eff_name in
-                  match uu___1 with
-                  | FStar_Pervasives_Native.Some (ed, qualifiers) ->
-                      FStar_Compiler_Effect.op_Bar_Greater qualifiers
-                        (FStar_Compiler_List.contains
-                           FStar_Syntax_Syntax.Reifiable)
-                  | uu___2 -> false) in
-             let gopt =
-               if use_eq1
-               then
-                 let uu___1 =
-                   FStar_TypeChecker_Rel.try_teq true env
-                     lc.FStar_TypeChecker_Common.res_typ t in
-                 (uu___1, false)
-               else
-                 (let uu___2 =
-                    FStar_TypeChecker_Rel.get_subtyping_predicate env
-                      lc.FStar_TypeChecker_Common.res_typ t in
-                  (uu___2, true)) in
-             match gopt with
-             | (FStar_Pervasives_Native.None, uu___1) ->
-                 if env.FStar_TypeChecker_Env.failhard
-                 then
-                   let uu___2 =
-                     FStar_TypeChecker_Err.basic_type_error env
-                       (FStar_Pervasives_Native.Some e) t
-                       lc.FStar_TypeChecker_Common.res_typ in
-                   FStar_Errors.raise_error uu___2 e.FStar_Syntax_Syntax.pos
-                 else
-                   (FStar_TypeChecker_Rel.subtype_fail env e
-                      lc.FStar_TypeChecker_Common.res_typ t;
-                    (e,
-                      {
-                        FStar_TypeChecker_Common.eff_name =
-                          (lc.FStar_TypeChecker_Common.eff_name);
-                        FStar_TypeChecker_Common.res_typ = t;
-                        FStar_TypeChecker_Common.cflags =
-                          (lc.FStar_TypeChecker_Common.cflags);
-                        FStar_TypeChecker_Common.comp_thunk =
-                          (lc.FStar_TypeChecker_Common.comp_thunk)
-                      }, FStar_TypeChecker_Env.trivial_guard))
-             | (FStar_Pervasives_Native.Some g, apply_guard) ->
-                 let uu___1 = FStar_TypeChecker_Env.guard_form g in
-                 (match uu___1 with
-                  | FStar_TypeChecker_Common.Trivial ->
-                      let strengthen_trivial uu___2 =
-                        let uu___3 = FStar_TypeChecker_Common.lcomp_comp lc in
-                        match uu___3 with
-                        | (c, g_c) ->
-                            let res_t = FStar_Syntax_Util.comp_result c in
-                            let set_result_typ c1 =
-                              FStar_Syntax_Util.set_result_typ c1 t in
-                            let uu___4 =
-                              let uu___5 = FStar_Syntax_Util.eq_tm t res_t in
-                              uu___5 = FStar_Syntax_Util.Equal in
-                            if uu___4
-                            then
-                              ((let uu___6 =
-                                  FStar_Compiler_Effect.op_Less_Bar
-                                    (FStar_TypeChecker_Env.debug env)
-                                    FStar_Options.Extreme in
-                                if uu___6
-                                then
-                                  let uu___7 =
-                                    FStar_Syntax_Print.term_to_string res_t in
-                                  let uu___8 =
-                                    FStar_Syntax_Print.term_to_string t in
-                                  FStar_Compiler_Util.print2
-                                    "weaken_result_type::strengthen_trivial: res_t:%s is same as t:%s\n"
-                                    uu___7 uu___8
-                                else ());
-                               (let uu___6 = set_result_typ c in
-                                (uu___6, g_c)))
-                            else
-                              (let is_res_t_refinement =
-                                 let res_t1 =
-                                   FStar_TypeChecker_Normalize.normalize_refinement
-                                     FStar_TypeChecker_Normalize.whnf_steps
-                                     env res_t in
-                                 match res_t1.FStar_Syntax_Syntax.n with
-                                 | FStar_Syntax_Syntax.Tm_refine uu___6 ->
-                                     true
-                                 | uu___6 -> false in
-                               if is_res_t_refinement
-                               then
-                                 let x =
-                                   FStar_Syntax_Syntax.new_bv
-                                     (FStar_Pervasives_Native.Some
-                                        (res_t.FStar_Syntax_Syntax.pos))
-                                     res_t in
-                                 let uu___6 =
-                                   let uu___7 =
-                                     let uu___8 =
-                                       FStar_Compiler_Effect.op_Bar_Greater c
-                                         FStar_Syntax_Util.comp_effect_name in
-                                     FStar_Compiler_Effect.op_Bar_Greater
-                                       uu___8
-                                       (FStar_TypeChecker_Env.norm_eff_name
-                                          env) in
-                                   let uu___8 =
-                                     FStar_Syntax_Syntax.bv_to_name x in
-                                   return_value env uu___7 (comp_univ_opt c)
-                                     res_t uu___8 in
-                                 match uu___6 with
-                                 | (cret, gret) ->
-                                     let lc1 =
-                                       let uu___7 =
-                                         FStar_TypeChecker_Common.lcomp_of_comp
-                                           c in
-                                       let uu___8 =
-                                         let uu___9 =
-                                           FStar_TypeChecker_Common.lcomp_of_comp
-                                             cret in
-                                         ((FStar_Pervasives_Native.Some x),
-                                           uu___9) in
-                                       bind e.FStar_Syntax_Syntax.pos env
-                                         (FStar_Pervasives_Native.Some e)
-                                         uu___7 uu___8 in
-                                     ((let uu___8 =
-                                         FStar_Compiler_Effect.op_Less_Bar
-                                           (FStar_TypeChecker_Env.debug env)
-                                           FStar_Options.Extreme in
-                                       if uu___8
-                                       then
-                                         let uu___9 =
-                                           FStar_Syntax_Print.term_to_string
-                                             e in
-                                         let uu___10 =
-                                           FStar_Syntax_Print.comp_to_string
-                                             c in
-                                         let uu___11 =
-                                           FStar_Syntax_Print.term_to_string
-                                             t in
-                                         let uu___12 =
-                                           FStar_TypeChecker_Common.lcomp_to_string
-                                             lc1 in
-                                         FStar_Compiler_Util.print4
-                                           "weaken_result_type::strengthen_trivial: inserting a return for e: %s, c: %s, t: %s, and then post return lc: %s\n"
-                                           uu___9 uu___10 uu___11 uu___12
-                                       else ());
-                                      (let uu___8 =
-                                         FStar_TypeChecker_Common.lcomp_comp
-                                           lc1 in
-                                       match uu___8 with
-                                       | (c1, g_lc) ->
-                                           let uu___9 = set_result_typ c1 in
-                                           let uu___10 =
-                                             FStar_TypeChecker_Env.conj_guards
-                                               [g_c; gret; g_lc] in
-                                           (uu___9, uu___10)))
-                               else
-                                 ((let uu___8 =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (FStar_TypeChecker_Env.debug env)
-                                       FStar_Options.Extreme in
-                                   if uu___8
-                                   then
-                                     let uu___9 =
-                                       FStar_Syntax_Print.term_to_string
-                                         res_t in
-                                     let uu___10 =
-                                       FStar_Syntax_Print.comp_to_string c in
-                                     FStar_Compiler_Util.print2
-                                       "weaken_result_type::strengthen_trivial: res_t:%s is not a refinement, leaving c:%s as is\n"
-                                       uu___9 uu___10
-                                   else ());
-                                  (let uu___8 = set_result_typ c in
-                                   (uu___8, g_c)))) in
-                      let lc1 =
-                        FStar_TypeChecker_Common.mk_lcomp
-                          lc.FStar_TypeChecker_Common.eff_name t
-                          lc.FStar_TypeChecker_Common.cflags
-                          strengthen_trivial in
-                      (e, lc1, g)
-                  | FStar_TypeChecker_Common.NonTrivial f ->
-                      let g1 =
-                        {
-                          FStar_TypeChecker_Common.guard_f =
-                            FStar_TypeChecker_Common.Trivial;
-                          FStar_TypeChecker_Common.deferred_to_tac =
-                            (g.FStar_TypeChecker_Common.deferred_to_tac);
-                          FStar_TypeChecker_Common.deferred =
-                            (g.FStar_TypeChecker_Common.deferred);
-                          FStar_TypeChecker_Common.univ_ineqs =
-                            (g.FStar_TypeChecker_Common.univ_ineqs);
-                          FStar_TypeChecker_Common.implicits =
-                            (g.FStar_TypeChecker_Common.implicits)
-                        } in
-                      let strengthen uu___2 =
-                        let uu___3 =
-                          env.FStar_TypeChecker_Env.lax &&
-                            (FStar_Options.ml_ish ()) in
-                        if uu___3
-                        then FStar_TypeChecker_Common.lcomp_comp lc
-                        else
-                          (let f1 =
-                             FStar_TypeChecker_Normalize.normalize
-                               [FStar_TypeChecker_Env.Beta;
-                               FStar_TypeChecker_Env.Eager_unfolding;
-                               FStar_TypeChecker_Env.Simplify;
-                               FStar_TypeChecker_Env.Primops] env f in
-                           let uu___5 =
-                             let uu___6 = FStar_Syntax_Subst.compress f1 in
-                             uu___6.FStar_Syntax_Syntax.n in
-                           match uu___5 with
-                           | FStar_Syntax_Syntax.Tm_abs
-                               (uu___6,
-                                {
-                                  FStar_Syntax_Syntax.n =
-                                    FStar_Syntax_Syntax.Tm_fvar fv;
-                                  FStar_Syntax_Syntax.pos = uu___7;
-                                  FStar_Syntax_Syntax.vars = uu___8;
-                                  FStar_Syntax_Syntax.hash_code = uu___9;_},
-                                uu___10)
-                               when
-                               FStar_Syntax_Syntax.fv_eq_lid fv
-                                 FStar_Parser_Const.true_lid
-                               ->
-                               let lc1 =
-                                 {
-                                   FStar_TypeChecker_Common.eff_name =
-                                     (lc.FStar_TypeChecker_Common.eff_name);
-                                   FStar_TypeChecker_Common.res_typ = t;
-                                   FStar_TypeChecker_Common.cflags =
-                                     (lc.FStar_TypeChecker_Common.cflags);
-                                   FStar_TypeChecker_Common.comp_thunk =
-                                     (lc.FStar_TypeChecker_Common.comp_thunk)
-                                 } in
-                               FStar_TypeChecker_Common.lcomp_comp lc1
-                           | uu___6 ->
-                               let uu___7 =
-                                 FStar_TypeChecker_Common.lcomp_comp lc in
-                               (match uu___7 with
-                                | (c, g_c) ->
-                                    ((let uu___9 =
-                                        FStar_Compiler_Effect.op_Less_Bar
-                                          (FStar_TypeChecker_Env.debug env)
-                                          FStar_Options.Extreme in
-                                      if uu___9
-                                      then
-                                        let uu___10 =
-                                          FStar_TypeChecker_Normalize.term_to_string
-                                            env
-                                            lc.FStar_TypeChecker_Common.res_typ in
-                                        let uu___11 =
-                                          FStar_TypeChecker_Normalize.term_to_string
-                                            env t in
-                                        let uu___12 =
-                                          FStar_TypeChecker_Normalize.comp_to_string
-                                            env c in
-                                        let uu___13 =
-                                          FStar_TypeChecker_Normalize.term_to_string
-                                            env f1 in
-                                        FStar_Compiler_Util.print4
-                                          "Weakened from %s to %s\nStrengthening %s with guard %s\n"
-                                          uu___10 uu___11 uu___12 uu___13
-                                      else ());
-                                     (let u_t_opt = comp_univ_opt c in
-                                      let x =
-                                        FStar_Syntax_Syntax.new_bv
-                                          (FStar_Pervasives_Native.Some
-                                             (t.FStar_Syntax_Syntax.pos)) t in
-                                      let xexp =
-                                        FStar_Syntax_Syntax.bv_to_name x in
-                                      let uu___9 =
-                                        let uu___10 =
-                                          let uu___11 =
-                                            FStar_Compiler_Effect.op_Bar_Greater
-                                              c
-                                              FStar_Syntax_Util.comp_effect_name in
-                                          FStar_Compiler_Effect.op_Bar_Greater
-                                            uu___11
-                                            (FStar_TypeChecker_Env.norm_eff_name
-                                               env) in
-                                        return_value env uu___10 u_t_opt t
-                                          xexp in
-                                      match uu___9 with
-                                      | (cret, gret) ->
-                                          let guard =
-                                            if apply_guard
-                                            then
-                                              let uu___10 =
-                                                let uu___11 =
-                                                  FStar_Syntax_Syntax.as_arg
-                                                    xexp in
-                                                [uu___11] in
-                                              FStar_Syntax_Syntax.mk_Tm_app
-                                                f1 uu___10
-                                                f1.FStar_Syntax_Syntax.pos
-                                            else f1 in
-                                          let uu___10 =
-                                            let uu___11 =
-                                              FStar_Compiler_Effect.op_Less_Bar
-                                                (fun uu___12 ->
-                                                   FStar_Pervasives_Native.Some
-                                                     uu___12)
-                                                (FStar_TypeChecker_Err.subtyping_failed
-                                                   env
-                                                   lc.FStar_TypeChecker_Common.res_typ
-                                                   t) in
-                                            let uu___12 =
-                                              let uu___13 =
-                                                FStar_TypeChecker_Env.push_bvs
-                                                  env [x] in
-                                              FStar_TypeChecker_Env.set_range
-                                                uu___13
-                                                e.FStar_Syntax_Syntax.pos in
-                                            let uu___13 =
-                                              FStar_TypeChecker_Common.lcomp_of_comp
-                                                cret in
-                                            let uu___14 =
-                                              FStar_Compiler_Effect.op_Less_Bar
-                                                FStar_TypeChecker_Env.guard_of_guard_formula
-                                                (FStar_TypeChecker_Common.NonTrivial
-                                                   guard) in
-                                            strengthen_precondition uu___11
-                                              uu___12 e uu___13 uu___14 in
-                                          (match uu___10 with
-                                           | (eq_ret,
-                                              _trivial_so_ok_to_discard) ->
-                                               let x1 =
-                                                 {
-                                                   FStar_Syntax_Syntax.ppname
-                                                     =
-                                                     (x.FStar_Syntax_Syntax.ppname);
-                                                   FStar_Syntax_Syntax.index
-                                                     =
-                                                     (x.FStar_Syntax_Syntax.index);
-                                                   FStar_Syntax_Syntax.sort =
-                                                     (lc.FStar_TypeChecker_Common.res_typ)
-                                                 } in
-                                               let c1 =
-                                                 let uu___11 =
-                                                   FStar_TypeChecker_Common.lcomp_of_comp
-                                                     c in
-                                                 bind
-                                                   e.FStar_Syntax_Syntax.pos
-                                                   env
-                                                   (FStar_Pervasives_Native.Some
-                                                      e) uu___11
-                                                   ((FStar_Pervasives_Native.Some
-                                                       x1), eq_ret) in
-                                               let uu___11 =
-                                                 FStar_TypeChecker_Common.lcomp_comp
-                                                   c1 in
-                                               (match uu___11 with
-                                                | (c2, g_lc) ->
-                                                    ((let uu___13 =
-                                                        FStar_Compiler_Effect.op_Less_Bar
-                                                          (FStar_TypeChecker_Env.debug
-                                                             env)
-                                                          FStar_Options.Extreme in
-                                                      if uu___13
-                                                      then
-                                                        let uu___14 =
-                                                          FStar_TypeChecker_Normalize.comp_to_string
-                                                            env c2 in
-                                                        FStar_Compiler_Util.print1
-                                                          "Strengthened to %s\n"
-                                                          uu___14
-                                                      else ());
-                                                     (let uu___13 =
-                                                        FStar_TypeChecker_Env.conj_guards
-                                                          [g_c; gret; g_lc] in
-                                                      (c2, uu___13))))))))) in
-                      let flags =
-                        FStar_Compiler_Effect.op_Bar_Greater
-                          lc.FStar_TypeChecker_Common.cflags
-                          (FStar_Compiler_List.collect
-                             (fun uu___2 ->
-                                match uu___2 with
-                                | FStar_Syntax_Syntax.RETURN ->
-                                    [FStar_Syntax_Syntax.PARTIAL_RETURN]
-                                | FStar_Syntax_Syntax.PARTIAL_RETURN ->
-                                    [FStar_Syntax_Syntax.PARTIAL_RETURN]
-                                | FStar_Syntax_Syntax.CPS ->
-                                    [FStar_Syntax_Syntax.CPS]
-                                | uu___3 -> [])) in
-                      let lc1 =
-                        let uu___2 =
-                          FStar_TypeChecker_Env.norm_eff_name env
-                            lc.FStar_TypeChecker_Common.eff_name in
-                        FStar_TypeChecker_Common.mk_lcomp uu___2 t flags
-                          strengthen in
-                      let g2 =
-                        {
-                          FStar_TypeChecker_Common.guard_f =
-                            FStar_TypeChecker_Common.Trivial;
-                          FStar_TypeChecker_Common.deferred_to_tac =
-                            (g1.FStar_TypeChecker_Common.deferred_to_tac);
-                          FStar_TypeChecker_Common.deferred =
-                            (g1.FStar_TypeChecker_Common.deferred);
-                          FStar_TypeChecker_Common.univ_ineqs =
-                            (g1.FStar_TypeChecker_Common.univ_ineqs);
-                          FStar_TypeChecker_Common.implicits =
-                            (g1.FStar_TypeChecker_Common.implicits)
-                        } in
-                      (e, lc1, g2)))
-let (pure_or_ghost_pre_and_post :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.comp ->
-      (FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option *
-        FStar_Syntax_Syntax.typ))
-  =
-  fun env ->
-    fun comp ->
-      let mk_post_type res_t ens =
-        let x = FStar_Syntax_Syntax.new_bv FStar_Pervasives_Native.None res_t in
-        let uu___ =
-          let uu___1 =
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Syntax.bv_to_name x in
-              FStar_Syntax_Syntax.as_arg uu___3 in
-            [uu___2] in
-          FStar_Syntax_Syntax.mk_Tm_app ens uu___1
-            res_t.FStar_Syntax_Syntax.pos in
-        FStar_Syntax_Util.refine x uu___ in
-      let norm t =
-        FStar_TypeChecker_Normalize.normalize
-          [FStar_TypeChecker_Env.Beta;
-          FStar_TypeChecker_Env.Eager_unfolding;
-          FStar_TypeChecker_Env.EraseUniverses] env t in
-      let uu___ = FStar_Syntax_Util.is_tot_or_gtot_comp comp in
-      if uu___
-      then
-        (FStar_Pervasives_Native.None, (FStar_Syntax_Util.comp_result comp))
-      else
-        (match comp.FStar_Syntax_Syntax.n with
-         | FStar_Syntax_Syntax.GTotal uu___2 -> failwith "Impossible"
-         | FStar_Syntax_Syntax.Total uu___2 -> failwith "Impossible"
-         | FStar_Syntax_Syntax.Comp ct ->
-             let uu___2 =
-               (FStar_Ident.lid_equals ct.FStar_Syntax_Syntax.effect_name
-                  FStar_Parser_Const.effect_Pure_lid)
-                 ||
-                 (FStar_Ident.lid_equals ct.FStar_Syntax_Syntax.effect_name
-                    FStar_Parser_Const.effect_Ghost_lid) in
-             if uu___2
-             then
-               (match ct.FStar_Syntax_Syntax.effect_args with
-                | (req, uu___3)::(ens, uu___4)::uu___5 ->
-                    let uu___6 =
-                      let uu___7 = norm req in
-                      FStar_Pervasives_Native.Some uu___7 in
-                    let uu___7 =
-                      let uu___8 =
-                        mk_post_type ct.FStar_Syntax_Syntax.result_typ ens in
-                      FStar_Compiler_Effect.op_Less_Bar norm uu___8 in
-                    (uu___6, uu___7)
-                | uu___3 ->
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 = FStar_Syntax_Print.comp_to_string comp in
-                        FStar_Compiler_Util.format1
-                          "Effect constructor is not fully applied; got %s"
-                          uu___6 in
-                      (FStar_Errors.Fatal_EffectConstructorNotFullyApplied,
-                        uu___5) in
-                    FStar_Errors.raise_error uu___4
-                      comp.FStar_Syntax_Syntax.pos)
-             else
-               (let ct1 = FStar_TypeChecker_Env.unfold_effect_abbrev env comp in
-                match ct1.FStar_Syntax_Syntax.effect_args with
-                | (wp, uu___4)::uu___5 ->
-                    let uu___6 =
-                      let uu___7 =
-                        FStar_TypeChecker_Env.lookup_lid env
-                          FStar_Parser_Const.as_requires in
-                      FStar_Compiler_Effect.op_Less_Bar
-                        FStar_Pervasives_Native.fst uu___7 in
-                    (match uu___6 with
-                     | (us_r, uu___7) ->
-                         let uu___8 =
-                           let uu___9 =
-                             FStar_TypeChecker_Env.lookup_lid env
-                               FStar_Parser_Const.as_ensures in
-                           FStar_Compiler_Effect.op_Less_Bar
-                             FStar_Pervasives_Native.fst uu___9 in
-                         (match uu___8 with
-                          | (us_e, uu___9) ->
-                              let r =
-                                (ct1.FStar_Syntax_Syntax.result_typ).FStar_Syntax_Syntax.pos in
-                              let as_req =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_Ident.set_lid_range
-                                      FStar_Parser_Const.as_requires r in
-                                  FStar_Syntax_Syntax.fvar uu___11
-                                    FStar_Syntax_Syntax.delta_equational
-                                    FStar_Pervasives_Native.None in
-                                FStar_Syntax_Syntax.mk_Tm_uinst uu___10 us_r in
-                              let as_ens =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_Ident.set_lid_range
-                                      FStar_Parser_Const.as_ensures r in
-                                  FStar_Syntax_Syntax.fvar uu___11
-                                    FStar_Syntax_Syntax.delta_equational
-                                    FStar_Pervasives_Native.None in
-                                FStar_Syntax_Syntax.mk_Tm_uinst uu___10 us_e in
-                              let req =
-                                let uu___10 =
-                                  let uu___11 =
-                                    let uu___12 =
-                                      FStar_Syntax_Syntax.as_aqual_implicit
-                                        true in
-                                    ((ct1.FStar_Syntax_Syntax.result_typ),
-                                      uu___12) in
-                                  let uu___12 =
-                                    let uu___13 =
-                                      FStar_Syntax_Syntax.as_arg wp in
-                                    [uu___13] in
-                                  uu___11 :: uu___12 in
-                                FStar_Syntax_Syntax.mk_Tm_app as_req uu___10
-                                  (ct1.FStar_Syntax_Syntax.result_typ).FStar_Syntax_Syntax.pos in
-                              let ens =
-                                let uu___10 =
-                                  let uu___11 =
-                                    let uu___12 =
-                                      FStar_Syntax_Syntax.as_aqual_implicit
-                                        true in
-                                    ((ct1.FStar_Syntax_Syntax.result_typ),
-                                      uu___12) in
-                                  let uu___12 =
-                                    let uu___13 =
-                                      FStar_Syntax_Syntax.as_arg wp in
-                                    [uu___13] in
-                                  uu___11 :: uu___12 in
-                                FStar_Syntax_Syntax.mk_Tm_app as_ens uu___10
-                                  (ct1.FStar_Syntax_Syntax.result_typ).FStar_Syntax_Syntax.pos in
-                              let uu___10 =
-                                let uu___11 = norm req in
-                                FStar_Pervasives_Native.Some uu___11 in
-                              let uu___11 =
-                                let uu___12 =
-                                  mk_post_type
-                                    ct1.FStar_Syntax_Syntax.result_typ ens in
-                                norm uu___12 in
-                              (uu___10, uu___11)))
-                | uu___4 -> failwith "Impossible"))
-let (reify_body :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Env.steps ->
-      FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun steps ->
-      fun t ->
-        FStar_TypeChecker_Env.def_check_closed_in_env
-          t.FStar_Syntax_Syntax.pos "reify_body" env t;
-        (let tm = FStar_Syntax_Util.mk_reify t in
-         let tm' =
-           FStar_TypeChecker_Normalize.normalize
-             (FStar_Compiler_List.op_At
-                [FStar_TypeChecker_Env.Beta;
-                FStar_TypeChecker_Env.Reify;
-                FStar_TypeChecker_Env.Eager_unfolding;
-                FStar_TypeChecker_Env.EraseUniverses;
-                FStar_TypeChecker_Env.AllowUnboundUniverses;
-                FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta]
-                steps) env tm in
-         (let uu___2 =
-            FStar_Compiler_Effect.op_Less_Bar
-              (FStar_TypeChecker_Env.debug env)
-              (FStar_Options.Other "SMTEncodingReify") in
-          if uu___2
-          then
-            let uu___3 = FStar_Syntax_Print.term_to_string tm in
-            let uu___4 = FStar_Syntax_Print.term_to_string tm' in
-            FStar_Compiler_Util.print2 "Reified body %s \nto %s\n" uu___3
-              uu___4
-          else ());
-         tm')
-let (reify_body_with_arg :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Env.steps ->
-      FStar_Syntax_Syntax.term ->
-        FStar_Syntax_Syntax.arg -> FStar_Syntax_Syntax.term)
-  =
-  fun env ->
-    fun steps ->
-      fun head ->
-        fun arg ->
-          let tm =
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (head, [arg]))
-              head.FStar_Syntax_Syntax.pos in
-          let tm' =
-            FStar_TypeChecker_Normalize.normalize
-              (FStar_Compiler_List.op_At
-                 [FStar_TypeChecker_Env.Beta;
-                 FStar_TypeChecker_Env.Reify;
-                 FStar_TypeChecker_Env.Eager_unfolding;
-                 FStar_TypeChecker_Env.EraseUniverses;
-                 FStar_TypeChecker_Env.AllowUnboundUniverses;
-                 FStar_TypeChecker_Env.Exclude FStar_TypeChecker_Env.Zeta]
-                 steps) env tm in
-          (let uu___1 =
-             FStar_Compiler_Effect.op_Less_Bar
-               (FStar_TypeChecker_Env.debug env)
-               (FStar_Options.Other "SMTEncodingReify") in
-           if uu___1
-           then
-             let uu___2 = FStar_Syntax_Print.term_to_string tm in
-             let uu___3 = FStar_Syntax_Print.term_to_string tm' in
-             FStar_Compiler_Util.print2 "Reified body %s \nto %s\n" uu___2
-               uu___3
-           else ());
-          tm'
-let (remove_reify : FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term) =
-  fun t ->
-    let uu___ =
-      let uu___1 =
-        let uu___2 = FStar_Syntax_Subst.compress t in
-        uu___2.FStar_Syntax_Syntax.n in
-      match uu___1 with
-      | FStar_Syntax_Syntax.Tm_app uu___2 -> false
-      | uu___2 -> true in
-    if uu___
-    then t
-    else
-      (let uu___2 = FStar_Syntax_Util.head_and_args t in
-       match uu___2 with
-       | (head, args) ->
-           let uu___3 =
-             let uu___4 =
-               let uu___5 = FStar_Syntax_Subst.compress head in
-               uu___5.FStar_Syntax_Syntax.n in
-             match uu___4 with
-             | FStar_Syntax_Syntax.Tm_constant (FStar_Const.Const_reify) ->
-                 true
-             | uu___5 -> false in
-           if uu___3
-           then
-             (match args with
-              | x::[] -> FStar_Pervasives_Native.fst x
-              | uu___4 ->
-                  failwith
-                    "Impossible : Reify applied to multiple arguments after normalization.")
-           else t)
-let (maybe_implicit_with_meta_or_attr :
-  FStar_Syntax_Syntax.bqual ->
-    FStar_Syntax_Syntax.attribute Prims.list -> Prims.bool)
-  =
-  fun aq ->
-    fun attrs ->
-      match (aq, attrs) with
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta uu___),
-         uu___1) -> true
-      | (FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit uu___),
-         uu___1::uu___2) -> true
-      | uu___ -> false
-let (maybe_instantiate :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        (FStar_Syntax_Syntax.term * FStar_Syntax_Syntax.typ *
-          FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun t ->
-        let torig = FStar_Syntax_Subst.compress t in
-        if Prims.op_Negation env.FStar_TypeChecker_Env.instantiate_imp
-        then (e, torig, FStar_TypeChecker_Env.trivial_guard)
-        else
-          ((let uu___2 = FStar_TypeChecker_Env.debug env FStar_Options.High in
-            if uu___2
-            then
-              let uu___3 = FStar_Syntax_Print.term_to_string e in
-              let uu___4 = FStar_Syntax_Print.term_to_string t in
-              let uu___5 =
-                let uu___6 = FStar_TypeChecker_Env.expected_typ env in
-                match uu___6 with
-                | FStar_Pervasives_Native.None -> "None"
-                | FStar_Pervasives_Native.Some (t1, uu___7) ->
-                    FStar_Syntax_Print.term_to_string t1 in
-              FStar_Compiler_Util.print3
-                "maybe_instantiate: starting check for (%s) of type (%s), expected type is %s\n"
-                uu___3 uu___4 uu___5
-            else ());
-           (let unfolded_arrow_formals t1 =
-              let rec aux bs t2 =
-                let t3 = FStar_TypeChecker_Normalize.unfold_whnf env t2 in
-                let uu___2 = FStar_Syntax_Util.arrow_formals t3 in
-                match uu___2 with
-                | (bs', t4) ->
-                    (match bs' with
-                     | [] -> bs
-                     | bs'1 -> aux (FStar_Compiler_List.op_At bs bs'1) t4) in
-              aux [] t1 in
-            let number_of_implicits t1 =
-              let formals = unfolded_arrow_formals t1 in
-              let n_implicits =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater formals
-                    (FStar_Compiler_Util.prefix_until
-                       (fun uu___3 ->
-                          match uu___3 with
-                          | { FStar_Syntax_Syntax.binder_bv = uu___4;
-                              FStar_Syntax_Syntax.binder_qual = imp;
-                              FStar_Syntax_Syntax.binder_attrs = uu___5;_} ->
-                              (FStar_Compiler_Option.isNone imp) ||
-                                (let uu___6 =
-                                   FStar_Syntax_Util.eq_bqual imp
-                                     (FStar_Pervasives_Native.Some
-                                        FStar_Syntax_Syntax.Equality) in
-                                 uu___6 = FStar_Syntax_Util.Equal))) in
-                match uu___2 with
-                | FStar_Pervasives_Native.None ->
-                    FStar_Compiler_List.length formals
-                | FStar_Pervasives_Native.Some
-                    (implicits, _first_explicit, _rest) ->
-                    FStar_Compiler_List.length implicits in
-              n_implicits in
-            let inst_n_binders t1 =
-              let uu___2 = FStar_TypeChecker_Env.expected_typ env in
-              match uu___2 with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some (expected_t, uu___3) ->
-                  let n_expected = number_of_implicits expected_t in
-                  let n_available = number_of_implicits t1 in
-                  if n_available < n_expected
-                  then
-                    let uu___4 =
-                      let uu___5 =
-                        let uu___6 =
-                          FStar_Compiler_Util.string_of_int n_expected in
-                        let uu___7 = FStar_Syntax_Print.term_to_string e in
-                        let uu___8 =
-                          FStar_Compiler_Util.string_of_int n_available in
-                        FStar_Compiler_Util.format3
-                          "Expected a term with %s implicit arguments, but %s has only %s"
-                          uu___6 uu___7 uu___8 in
-                      (FStar_Errors.Fatal_MissingImplicitArguments, uu___5) in
-                    let uu___5 = FStar_TypeChecker_Env.get_range env in
-                    FStar_Errors.raise_error uu___4 uu___5
-                  else
-                    FStar_Pervasives_Native.Some (n_available - n_expected) in
-            let decr_inst uu___2 =
-              match uu___2 with
-              | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-              | FStar_Pervasives_Native.Some i ->
-                  FStar_Pervasives_Native.Some (i - Prims.int_one) in
-            let t1 = FStar_TypeChecker_Normalize.unfold_whnf env t in
-            match t1.FStar_Syntax_Syntax.n with
-            | FStar_Syntax_Syntax.Tm_arrow (bs, c) ->
-                let uu___2 = FStar_Syntax_Subst.open_comp bs c in
-                (match uu___2 with
-                 | (bs1, c1) ->
-                     let rec aux subst inst_n bs2 =
-                       match (inst_n, bs2) with
-                       | (FStar_Pervasives_Native.Some uu___3, uu___4) when
-                           uu___3 = Prims.int_zero ->
-                           ([], bs2, subst,
-                             FStar_TypeChecker_Env.trivial_guard)
-                       | (uu___3,
-                          { FStar_Syntax_Syntax.binder_bv = x;
-                            FStar_Syntax_Syntax.binder_qual =
-                              FStar_Pervasives_Native.Some
-                              (FStar_Syntax_Syntax.Implicit uu___4);
-                            FStar_Syntax_Syntax.binder_attrs = [];_}::rest)
-                           ->
-                           let t2 =
-                             FStar_Syntax_Subst.subst subst
-                               x.FStar_Syntax_Syntax.sort in
-                           let uu___5 =
-                             new_implicit_var
-                               "Instantiation of implicit argument"
-                               e.FStar_Syntax_Syntax.pos env t2 in
-                           (match uu___5 with
-                            | (v, uu___6, g) ->
-                                ((let uu___8 =
-                                    FStar_TypeChecker_Env.debug env
-                                      FStar_Options.High in
-                                  if uu___8
-                                  then
-                                    let uu___9 =
-                                      FStar_Syntax_Print.term_to_string v in
-                                    FStar_Compiler_Util.print1
-                                      "maybe_instantiate: Instantiating implicit with %s\n"
-                                      uu___9
-                                  else ());
-                                 (let subst1 =
-                                    (FStar_Syntax_Syntax.NT (x, v)) :: subst in
-                                  let aq =
-                                    let uu___8 = FStar_Compiler_List.hd bs2 in
-                                    FStar_Syntax_Util.aqual_of_binder uu___8 in
-                                  let uu___8 =
-                                    aux subst1 (decr_inst inst_n) rest in
-                                  match uu___8 with
-                                  | (args, bs3, subst2, g') ->
-                                      let uu___9 =
-                                        FStar_TypeChecker_Env.conj_guard g g' in
-                                      (((v, aq) :: args), bs3, subst2,
-                                        uu___9))))
-                       | (uu___3,
-                          { FStar_Syntax_Syntax.binder_bv = x;
-                            FStar_Syntax_Syntax.binder_qual = qual;
-                            FStar_Syntax_Syntax.binder_attrs = attrs;_}::rest)
-                           when maybe_implicit_with_meta_or_attr qual attrs
-                           ->
-                           let t2 =
-                             FStar_Syntax_Subst.subst subst
-                               x.FStar_Syntax_Syntax.sort in
-                           let meta_t =
-                             match (qual, attrs) with
-                             | (FStar_Pervasives_Native.Some
-                                (FStar_Syntax_Syntax.Meta tau), uu___4) ->
-                                 let uu___5 =
-                                   let uu___6 = FStar_Compiler_Dyn.mkdyn env in
-                                   (uu___6, tau) in
-                                 FStar_Syntax_Syntax.Ctx_uvar_meta_tac uu___5
-                             | (uu___4, attr::uu___5) ->
-                                 FStar_Syntax_Syntax.Ctx_uvar_meta_attr attr
-                             | uu___4 ->
-                                 failwith
-                                   "Impossible, match is under a guard, did not expect this case" in
-                           let uu___4 =
-                             FStar_TypeChecker_Env.new_implicit_var_aux
-                               "Instantiation of meta argument"
-                               e.FStar_Syntax_Syntax.pos env t2
-                               FStar_Syntax_Syntax.Strict
-                               (FStar_Pervasives_Native.Some meta_t) in
-                           (match uu___4 with
-                            | (v, uu___5, g) ->
-                                ((let uu___7 =
-                                    FStar_TypeChecker_Env.debug env
-                                      FStar_Options.High in
-                                  if uu___7
-                                  then
-                                    let uu___8 =
-                                      FStar_Syntax_Print.term_to_string v in
-                                    FStar_Compiler_Util.print1
-                                      "maybe_instantiate: Instantiating meta argument with %s\n"
-                                      uu___8
-                                  else ());
-                                 (let subst1 =
-                                    (FStar_Syntax_Syntax.NT (x, v)) :: subst in
-                                  let aq =
-                                    let uu___7 = FStar_Compiler_List.hd bs2 in
-                                    FStar_Syntax_Util.aqual_of_binder uu___7 in
-                                  let uu___7 =
-                                    aux subst1 (decr_inst inst_n) rest in
-                                  match uu___7 with
-                                  | (args, bs3, subst2, g') ->
-                                      let uu___8 =
-                                        FStar_TypeChecker_Env.conj_guard g g' in
-                                      (((v, aq) :: args), bs3, subst2,
-                                        uu___8))))
-                       | (uu___3, bs3) ->
-                           ([], bs3, subst,
-                             FStar_TypeChecker_Env.trivial_guard) in
-                     let uu___3 =
-                       let uu___4 = inst_n_binders t1 in aux [] uu___4 bs1 in
-                     (match uu___3 with
-                      | (args, bs2, subst, guard) ->
-                          (match (args, bs2) with
-                           | ([], uu___4) -> (e, torig, guard)
-                           | (uu___4, []) when
-                               let uu___5 =
-                                 FStar_Syntax_Util.is_total_comp c1 in
-                               Prims.op_Negation uu___5 ->
-                               (e, torig,
-                                 FStar_TypeChecker_Env.trivial_guard)
-                           | uu___4 ->
-                               let t2 =
-                                 match bs2 with
-                                 | [] -> FStar_Syntax_Util.comp_result c1
-                                 | uu___5 -> FStar_Syntax_Util.arrow bs2 c1 in
-                               let t3 = FStar_Syntax_Subst.subst subst t2 in
-                               let e1 =
-                                 FStar_Syntax_Syntax.mk_Tm_app e args
-                                   e.FStar_Syntax_Syntax.pos in
-                               (e1, t3, guard))))
-            | uu___2 -> (e, torig, FStar_TypeChecker_Env.trivial_guard)))
-let (check_has_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_Syntax_Syntax.typ ->
-        FStar_Syntax_Syntax.typ ->
-          Prims.bool -> FStar_TypeChecker_Env.guard_t)
-  =
-  fun env ->
-    fun e ->
-      fun t1 ->
-        fun t2 ->
-          fun use_eq ->
-            let env1 =
-              FStar_TypeChecker_Env.set_range env e.FStar_Syntax_Syntax.pos in
-            let g_opt =
-              if env1.FStar_TypeChecker_Env.use_eq_strict
-              then
-                let uu___ = FStar_TypeChecker_Rel.teq_nosmt_force env1 t1 t2 in
-                (if uu___
-                 then
-                   FStar_Compiler_Effect.op_Bar_Greater
-                     FStar_TypeChecker_Env.trivial_guard
-                     (fun uu___1 -> FStar_Pervasives_Native.Some uu___1)
-                 else FStar_Pervasives_Native.None)
-              else
-                if use_eq
-                then FStar_TypeChecker_Rel.try_teq true env1 t1 t2
-                else
-                  (let uu___2 =
-                     FStar_TypeChecker_Rel.get_subtyping_predicate env1 t1 t2 in
-                   match uu___2 with
-                   | FStar_Pervasives_Native.None ->
-                       FStar_Pervasives_Native.None
-                   | FStar_Pervasives_Native.Some f ->
-                       let uu___3 = FStar_TypeChecker_Env.apply_guard f e in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___3
-                         (fun uu___4 -> FStar_Pervasives_Native.Some uu___4)) in
-            match g_opt with
-            | FStar_Pervasives_Native.None ->
-                let uu___ =
-                  FStar_TypeChecker_Err.expected_expression_of_type env1 t2 e
-                    t1 in
-                let uu___1 = FStar_TypeChecker_Env.get_range env1 in
-                FStar_Errors.raise_error uu___ uu___1
-            | FStar_Pervasives_Native.Some g -> g
-let (check_has_type_maybe_coerce :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.term ->
-      FStar_TypeChecker_Common.lcomp ->
-        FStar_Syntax_Syntax.typ ->
-          Prims.bool ->
-            (FStar_Syntax_Syntax.term * FStar_TypeChecker_Common.lcomp *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun e ->
-      fun lc ->
-        fun t2 ->
-          fun use_eq ->
-            let env1 =
-              FStar_TypeChecker_Env.set_range env e.FStar_Syntax_Syntax.pos in
-            let uu___ = maybe_coerce_lc env1 e lc t2 in
-            match uu___ with
-            | (e1, lc1, g_c) ->
-                let g =
-                  check_has_type env1 e1 lc1.FStar_TypeChecker_Common.res_typ
-                    t2 use_eq in
-                ((let uu___2 =
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_TypeChecker_Env.debug env1)
-                      (FStar_Options.Other "Rel") in
-                  if uu___2
-                  then
-                    let uu___3 = FStar_TypeChecker_Rel.guard_to_string env1 g in
-                    FStar_Compiler_Effect.op_Less_Bar
-                      (FStar_Compiler_Util.print1 "Applied guard is %s\n")
-                      uu___3
-                  else ());
-                 (let uu___2 = FStar_TypeChecker_Env.conj_guard g g_c in
-                  (e1, lc1, uu___2)))
-let (check_top_level :
-  FStar_TypeChecker_Env.env ->
-    FStar_TypeChecker_Env.guard_t ->
-      FStar_TypeChecker_Common.lcomp ->
-        (Prims.bool * FStar_Syntax_Syntax.comp))
-  =
-  fun env ->
-    fun g ->
-      fun lc ->
-        FStar_Errors.with_ctx "While checking for top-level effects"
-          (fun uu___ ->
-             (let uu___2 =
-                FStar_TypeChecker_Env.debug env FStar_Options.Medium in
-              if uu___2
-              then
-                let uu___3 = FStar_TypeChecker_Common.lcomp_to_string lc in
-                FStar_Compiler_Util.print1 "check_top_level, lc = %s\n"
-                  uu___3
-              else ());
-             (let discharge g1 =
-                FStar_TypeChecker_Rel.force_trivial_guard env g1;
-                FStar_TypeChecker_Common.is_pure_lcomp lc in
-              let g1 = FStar_TypeChecker_Rel.solve_deferred_constraints env g in
-              let uu___2 = FStar_TypeChecker_Common.lcomp_comp lc in
-              match uu___2 with
-              | (c, g_c) ->
-                  let uu___3 = FStar_TypeChecker_Common.is_total_lcomp lc in
-                  if uu___3
-                  then
-                    let uu___4 =
-                      let uu___5 = FStar_TypeChecker_Env.conj_guard g1 g_c in
-                      discharge uu___5 in
-                    (uu___4, c)
-                  else
-                    (let c1 =
-                       FStar_TypeChecker_Env.unfold_effect_abbrev env c in
-                     let us = c1.FStar_Syntax_Syntax.comp_univs in
-                     let uu___5 =
-                       FStar_TypeChecker_Env.is_layered_effect env
-                         c1.FStar_Syntax_Syntax.effect_name in
-                     if uu___5
-                     then
-                       let c_eff = c1.FStar_Syntax_Syntax.effect_name in
-                       let ret_comp =
-                         FStar_Compiler_Effect.op_Bar_Greater c1
-                           FStar_Syntax_Syntax.mk_Comp in
-                       let steps =
-                         [FStar_TypeChecker_Env.Eager_unfolding;
-                         FStar_TypeChecker_Env.Simplify;
-                         FStar_TypeChecker_Env.Primops;
-                         FStar_TypeChecker_Env.NoFullNorm] in
-                       let c2 =
-                         let uu___6 =
-                           FStar_Compiler_Effect.op_Bar_Greater c1
-                             FStar_Syntax_Syntax.mk_Comp in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___6
-                           (FStar_TypeChecker_Normalize.normalize_comp steps
-                              env) in
-                       let top_level_eff_opt =
-                         FStar_TypeChecker_Env.get_top_level_effect env c_eff in
-                       match top_level_eff_opt with
-                       | FStar_Pervasives_Native.None ->
-                           let uu___6 =
-                             let uu___7 =
-                               let uu___8 =
-                                 FStar_Compiler_Effect.op_Bar_Greater c_eff
-                                   FStar_Ident.string_of_lid in
-                               FStar_Compiler_Util.format1
-                                 "Indexed effect %s cannot be used as a top-level effect"
-                                 uu___8 in
-                             (FStar_Errors.Fatal_UnexpectedEffect, uu___7) in
-                           let uu___7 = FStar_TypeChecker_Env.get_range env in
-                           FStar_Errors.raise_error uu___6 uu___7
-                       | FStar_Pervasives_Native.Some top_level_eff ->
-                           let uu___6 =
-                             FStar_Ident.lid_equals top_level_eff c_eff in
-                           (if uu___6
-                            then
-                              let uu___7 = discharge g_c in
-                              (uu___7, ret_comp)
-                            else
-                              (let bc_opt =
-                                 FStar_TypeChecker_Env.lookup_effect_abbrev
-                                   env us top_level_eff in
-                               match bc_opt with
-                               | FStar_Pervasives_Native.None ->
-                                   let uu___8 =
-                                     let uu___9 =
-                                       let uu___10 =
-                                         FStar_Ident.string_of_lid
-                                           top_level_eff in
-                                       let uu___11 =
-                                         FStar_Compiler_Effect.op_Bar_Greater
-                                           c_eff FStar_Ident.string_of_lid in
-                                       FStar_Compiler_Util.format2
-                                         "Could not find top-level effect abbreviation %s for %s"
-                                         uu___10 uu___11 in
-                                     (FStar_Errors.Fatal_UnexpectedEffect,
-                                       uu___9) in
-                                   let uu___9 =
-                                     FStar_TypeChecker_Env.get_range env in
-                                   FStar_Errors.raise_error uu___8 uu___9
-                               | FStar_Pervasives_Native.Some (bs, uu___8) ->
-                                   let debug =
-                                     FStar_Compiler_Effect.op_Less_Bar
-                                       (FStar_TypeChecker_Env.debug env)
-                                       (FStar_Options.Other
-                                          "LayeredEffectsApp") in
-                                   let uu___9 =
-                                     FStar_Syntax_Subst.open_binders bs in
-                                   (match uu___9 with
-                                    | a::bs1 ->
-                                        let uu___10 =
-                                          let uu___11 =
-                                            FStar_TypeChecker_Env.get_range
-                                              env in
-                                          FStar_TypeChecker_Env.uvars_for_binders
-                                            env bs1
-                                            [FStar_Syntax_Syntax.NT
-                                               ((a.FStar_Syntax_Syntax.binder_bv),
-                                                 (FStar_Syntax_Util.comp_result
-                                                    c2))]
-                                            (fun b ->
-                                               if debug
-                                               then
-                                                 let uu___12 =
-                                                   FStar_Syntax_Print.binder_to_string
-                                                     b in
-                                                 let uu___13 =
-                                                   FStar_Ident.string_of_lid
-                                                     top_level_eff in
-                                                 FStar_Compiler_Util.format2
-                                                   "implicit for binder %s in effect abbreviation %s while checking top-level effect"
-                                                   uu___12 uu___13
-                                               else "check_top_level")
-                                            uu___11 in
-                                        (match uu___10 with
-                                         | (uvs, g_uvs) ->
-                                             let top_level_comp =
-                                               let uu___11 =
-                                                 let uu___12 =
-                                                   FStar_Compiler_Effect.op_Bar_Greater
-                                                     uvs
-                                                     (FStar_Compiler_List.map
-                                                        FStar_Syntax_Syntax.as_arg) in
-                                                 {
-                                                   FStar_Syntax_Syntax.comp_univs
-                                                     = us;
-                                                   FStar_Syntax_Syntax.effect_name
-                                                     = top_level_eff;
-                                                   FStar_Syntax_Syntax.result_typ
-                                                     =
-                                                     (FStar_Syntax_Util.comp_result
-                                                        c2);
-                                                   FStar_Syntax_Syntax.effect_args
-                                                     = uu___12;
-                                                   FStar_Syntax_Syntax.flags
-                                                     = []
-                                                 } in
-                                               FStar_Compiler_Effect.op_Bar_Greater
-                                                 uu___11
-                                                 FStar_Syntax_Syntax.mk_Comp in
-                                             let gopt =
-                                               FStar_TypeChecker_Rel.eq_comp
-                                                 env top_level_comp c2 in
-                                             (match gopt with
-                                              | FStar_Pervasives_Native.None
-                                                  ->
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      let uu___13 =
-                                                        FStar_Syntax_Print.comp_to_string
-                                                          top_level_comp in
-                                                      let uu___14 =
-                                                        FStar_Syntax_Print.comp_to_string
-                                                          c2 in
-                                                      FStar_Compiler_Util.format2
-                                                        "Could not unify %s and %s when checking top-level effect"
-                                                        uu___13 uu___14 in
-                                                    (FStar_Errors.Fatal_UnexpectedEffect,
-                                                      uu___12) in
-                                                  let uu___12 =
-                                                    FStar_TypeChecker_Env.get_range
-                                                      env in
-                                                  FStar_Errors.raise_error
-                                                    uu___11 uu___12
-                                              | FStar_Pervasives_Native.Some
-                                                  g2 ->
-                                                  let uu___11 =
-                                                    let uu___12 =
-                                                      FStar_TypeChecker_Env.conj_guards
-                                                        [g_c; g_uvs; g2] in
-                                                    discharge uu___12 in
-                                                  (uu___11, ret_comp))))))
-                     else
-                       (let steps =
-                          [FStar_TypeChecker_Env.Beta;
-                          FStar_TypeChecker_Env.NoFullNorm;
-                          FStar_TypeChecker_Env.DoNotUnfoldPureLets] in
-                        let c2 =
-                          let uu___7 =
-                            FStar_Compiler_Effect.op_Bar_Greater c1
-                              FStar_Syntax_Syntax.mk_Comp in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___7
-                            (FStar_TypeChecker_Normalize.normalize_comp steps
-                               env) in
-                        let uu___7 = check_trivial_precondition_wp env c2 in
-                        match uu___7 with
-                        | (ct, vc, g_pre) ->
-                            ((let uu___9 =
-                                FStar_Compiler_Effect.op_Less_Bar
-                                  (FStar_TypeChecker_Env.debug env)
-                                  (FStar_Options.Other "Simplification") in
-                              if uu___9
-                              then
-                                let uu___10 =
-                                  FStar_Syntax_Print.term_to_string vc in
-                                FStar_Compiler_Util.print1
-                                  "top-level VC: %s\n" uu___10
-                              else ());
-                             (let uu___9 =
-                                let uu___10 =
-                                  let uu___11 =
-                                    FStar_TypeChecker_Env.conj_guard g_c
-                                      g_pre in
-                                  FStar_TypeChecker_Env.conj_guard g1 uu___11 in
-                                discharge uu___10 in
-                              let uu___10 =
-                                FStar_Compiler_Effect.op_Bar_Greater ct
-                                  FStar_Syntax_Syntax.mk_Comp in
-                              (uu___9, uu___10)))))))
-let (short_circuit :
-  FStar_Syntax_Syntax.term ->
-    FStar_Syntax_Syntax.args -> FStar_TypeChecker_Common.guard_formula)
-  =
-  fun head ->
-    fun seen_args ->
-      let short_bin_op f uu___ =
-        match uu___ with
-        | [] -> FStar_TypeChecker_Common.Trivial
-        | (fst, uu___1)::[] -> f fst
-        | uu___1 -> failwith "Unexpexted args to binary operator" in
-      let op_and_e e =
-        let uu___ = FStar_Syntax_Util.b2t e in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (fun uu___1 -> FStar_TypeChecker_Common.NonTrivial uu___1) in
-      let op_or_e e =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Util.b2t e in
-          FStar_Syntax_Util.mk_neg uu___1 in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (fun uu___1 -> FStar_TypeChecker_Common.NonTrivial uu___1) in
-      let op_and_t t =
-        FStar_Compiler_Effect.op_Bar_Greater t
-          (fun uu___ -> FStar_TypeChecker_Common.NonTrivial uu___) in
-      let op_or_t t =
-        let uu___ =
-          FStar_Compiler_Effect.op_Bar_Greater t FStar_Syntax_Util.mk_neg in
-        FStar_Compiler_Effect.op_Bar_Greater uu___
-          (fun uu___1 -> FStar_TypeChecker_Common.NonTrivial uu___1) in
-      let op_imp_t t =
-        FStar_Compiler_Effect.op_Bar_Greater t
-          (fun uu___ -> FStar_TypeChecker_Common.NonTrivial uu___) in
-      let short_op_ite uu___ =
-        match uu___ with
-        | [] -> FStar_TypeChecker_Common.Trivial
-        | (guard, uu___1)::[] -> FStar_TypeChecker_Common.NonTrivial guard
-        | _then::(guard, uu___1)::[] ->
-            let uu___2 = FStar_Syntax_Util.mk_neg guard in
-            FStar_Compiler_Effect.op_Bar_Greater uu___2
-              (fun uu___3 -> FStar_TypeChecker_Common.NonTrivial uu___3)
-        | uu___1 -> failwith "Unexpected args to ITE" in
-      let table =
-        let uu___ =
-          let uu___1 = short_bin_op op_and_e in
-          (FStar_Parser_Const.op_And, uu___1) in
-        let uu___1 =
-          let uu___2 =
-            let uu___3 = short_bin_op op_or_e in
-            (FStar_Parser_Const.op_Or, uu___3) in
-          let uu___3 =
-            let uu___4 =
-              let uu___5 = short_bin_op op_and_t in
-              (FStar_Parser_Const.and_lid, uu___5) in
-            let uu___5 =
-              let uu___6 =
-                let uu___7 = short_bin_op op_or_t in
-                (FStar_Parser_Const.or_lid, uu___7) in
-              let uu___7 =
-                let uu___8 =
-                  let uu___9 = short_bin_op op_imp_t in
-                  (FStar_Parser_Const.imp_lid, uu___9) in
-                [uu___8; (FStar_Parser_Const.ite_lid, short_op_ite)] in
-              uu___6 :: uu___7 in
-            uu___4 :: uu___5 in
-          uu___2 :: uu___3 in
-        uu___ :: uu___1 in
-      match head.FStar_Syntax_Syntax.n with
-      | FStar_Syntax_Syntax.Tm_fvar fv ->
-          let lid = (fv.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-          let uu___ =
-            FStar_Compiler_Util.find_map table
-              (fun uu___1 ->
-                 match uu___1 with
-                 | (x, mk) ->
-                     let uu___2 = FStar_Ident.lid_equals x lid in
-                     if uu___2
-                     then
-                       let uu___3 = mk seen_args in
-                       FStar_Pervasives_Native.Some uu___3
-                     else FStar_Pervasives_Native.None) in
-          (match uu___ with
-           | FStar_Pervasives_Native.None -> FStar_TypeChecker_Common.Trivial
-           | FStar_Pervasives_Native.Some g -> g)
-      | uu___ -> FStar_TypeChecker_Common.Trivial
-let (short_circuit_head : FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun l ->
-    let uu___ =
-      let uu___1 = FStar_Syntax_Util.un_uinst l in
-      uu___1.FStar_Syntax_Syntax.n in
-    match uu___ with
-    | FStar_Syntax_Syntax.Tm_fvar fv ->
-        FStar_Compiler_Util.for_some (FStar_Syntax_Syntax.fv_eq_lid fv)
-          [FStar_Parser_Const.op_And;
-          FStar_Parser_Const.op_Or;
-          FStar_Parser_Const.and_lid;
-          FStar_Parser_Const.or_lid;
-          FStar_Parser_Const.imp_lid;
-          FStar_Parser_Const.ite_lid]
-    | uu___1 -> false
-let (maybe_add_implicit_binders :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders -> FStar_Syntax_Syntax.binders)
-  =
-  fun env ->
-    fun bs ->
-      let is_implicit_binder uu___ =
-        match uu___ with
-        | { FStar_Syntax_Syntax.binder_bv = uu___1;
-            FStar_Syntax_Syntax.binder_qual = q;
-            FStar_Syntax_Syntax.binder_attrs = uu___2;_} ->
-            (match q with
-             | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Implicit
-                 uu___3) -> true
-             | FStar_Pervasives_Native.Some (FStar_Syntax_Syntax.Meta uu___3)
-                 -> true
-             | uu___3 -> false) in
-      let pos bs1 =
-        match bs1 with
-        | { FStar_Syntax_Syntax.binder_bv = hd;
-            FStar_Syntax_Syntax.binder_qual = uu___;
-            FStar_Syntax_Syntax.binder_attrs = uu___1;_}::uu___2 ->
-            FStar_Syntax_Syntax.range_of_bv hd
-        | uu___ -> FStar_TypeChecker_Env.get_range env in
-      match bs with
-      | b::uu___ when is_implicit_binder b -> bs
-      | uu___ ->
-          let uu___1 = FStar_TypeChecker_Env.expected_typ env in
-          (match uu___1 with
-           | FStar_Pervasives_Native.None -> bs
-           | FStar_Pervasives_Native.Some (t, uu___2) ->
-               let uu___3 =
-                 let uu___4 = FStar_Syntax_Subst.compress t in
-                 uu___4.FStar_Syntax_Syntax.n in
-               (match uu___3 with
-                | FStar_Syntax_Syntax.Tm_arrow (bs', uu___4) ->
-                    let uu___5 =
-                      FStar_Compiler_Util.prefix_until
-                        (fun b ->
-                           let uu___6 = is_implicit_binder b in
-                           Prims.op_Negation uu___6) bs' in
-                    (match uu___5 with
-                     | FStar_Pervasives_Native.None -> bs
-                     | FStar_Pervasives_Native.Some ([], uu___6, uu___7) ->
-                         bs
-                     | FStar_Pervasives_Native.Some (imps, uu___6, uu___7) ->
-                         let r = pos bs in
-                         let imps1 =
-                           FStar_Compiler_Effect.op_Bar_Greater imps
-                             (FStar_Compiler_List.map
-                                (fun b ->
-                                   let uu___8 =
-                                     FStar_Syntax_Syntax.set_range_of_bv
-                                       b.FStar_Syntax_Syntax.binder_bv r in
-                                   {
-                                     FStar_Syntax_Syntax.binder_bv = uu___8;
-                                     FStar_Syntax_Syntax.binder_qual =
-                                       (b.FStar_Syntax_Syntax.binder_qual);
-                                     FStar_Syntax_Syntax.binder_attrs =
-                                       (b.FStar_Syntax_Syntax.binder_attrs)
-                                   })) in
-                         FStar_Compiler_List.op_At imps1 bs)
-                | uu___4 -> bs))
-let (d : Prims.string -> unit) =
-  fun s -> FStar_Compiler_Util.print1 "\027[01;36m%s\027[00m\n" s
-let (mk_toplevel_definition :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_Syntax.term ->
-        (FStar_Syntax_Syntax.sigelt * FStar_Syntax_Syntax.term))
-  =
-  fun env ->
-    fun lident ->
-      fun def ->
-        (let uu___1 =
-           FStar_TypeChecker_Env.debug env (FStar_Options.Other "ED") in
-         if uu___1
-         then
-           ((let uu___3 = FStar_Ident.string_of_lid lident in d uu___3);
-            (let uu___3 = FStar_Ident.string_of_lid lident in
-             let uu___4 = FStar_Syntax_Print.term_to_string def in
-             FStar_Compiler_Util.print2
-               "Registering top-level definition: %s\n%s\n" uu___3 uu___4))
-         else ());
-        (let fv =
-           let uu___1 = FStar_Syntax_Util.incr_delta_qualifier def in
-           FStar_Syntax_Syntax.lid_as_fv lident uu___1
-             FStar_Pervasives_Native.None in
-         let lbname = FStar_Pervasives.Inr fv in
-         let lb =
-           (false,
-             [FStar_Syntax_Util.mk_letbinding lbname []
-                FStar_Syntax_Syntax.tun FStar_Parser_Const.effect_Tot_lid def
-                [] FStar_Compiler_Range.dummyRange]) in
-         let sig_ctx =
-           FStar_Syntax_Syntax.mk_sigelt
-             (FStar_Syntax_Syntax.Sig_let (lb, [lident])) in
-         let uu___1 =
-           FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_fvar fv)
-             FStar_Compiler_Range.dummyRange in
-         ({
-            FStar_Syntax_Syntax.sigel = (sig_ctx.FStar_Syntax_Syntax.sigel);
-            FStar_Syntax_Syntax.sigrng = (sig_ctx.FStar_Syntax_Syntax.sigrng);
-            FStar_Syntax_Syntax.sigquals =
-              [FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen];
-            FStar_Syntax_Syntax.sigmeta =
-              (sig_ctx.FStar_Syntax_Syntax.sigmeta);
-            FStar_Syntax_Syntax.sigattrs =
-              (sig_ctx.FStar_Syntax_Syntax.sigattrs);
-            FStar_Syntax_Syntax.sigopts =
-              (sig_ctx.FStar_Syntax_Syntax.sigopts)
-          }, uu___1))
-let (check_sigelt_quals :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.sigelt -> unit) =
-  fun env ->
-    fun se ->
-      let visibility uu___ =
-        match uu___ with
-        | FStar_Syntax_Syntax.Private -> true
-        | uu___1 -> false in
-      let reducibility uu___ =
-        match uu___ with
-        | FStar_Syntax_Syntax.Irreducible -> true
-        | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen -> true
-        | FStar_Syntax_Syntax.Visible_default -> true
-        | FStar_Syntax_Syntax.Inline_for_extraction -> true
-        | uu___1 -> false in
-      let assumption uu___ =
-        match uu___ with
-        | FStar_Syntax_Syntax.Assumption -> true
-        | FStar_Syntax_Syntax.New -> true
-        | uu___1 -> false in
-      let reification uu___ =
-        match uu___ with
-        | FStar_Syntax_Syntax.Reifiable -> true
-        | FStar_Syntax_Syntax.Reflectable uu___1 -> true
-        | uu___1 -> false in
-      let inferred uu___ =
-        match uu___ with
-        | FStar_Syntax_Syntax.Discriminator uu___1 -> true
-        | FStar_Syntax_Syntax.Projector uu___1 -> true
-        | FStar_Syntax_Syntax.RecordType uu___1 -> true
-        | FStar_Syntax_Syntax.RecordConstructor uu___1 -> true
-        | FStar_Syntax_Syntax.ExceptionConstructor -> true
-        | FStar_Syntax_Syntax.HasMaskedEffect -> true
-        | FStar_Syntax_Syntax.Effect -> true
-        | uu___1 -> false in
-      let has_eq uu___ =
-        match uu___ with
-        | FStar_Syntax_Syntax.Noeq -> true
-        | FStar_Syntax_Syntax.Unopteq -> true
-        | uu___1 -> false in
-      let quals_combo_ok quals q =
-        match q with
-        | FStar_Syntax_Syntax.Assumption ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    ((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                          (inferred x))
-                         || (visibility x))
-                        || (assumption x))
-                       ||
-                       (env.FStar_TypeChecker_Env.is_iface &&
-                          (x = FStar_Syntax_Syntax.Inline_for_extraction)))
-                      || (x = FStar_Syntax_Syntax.NoExtract)))
-        | FStar_Syntax_Syntax.New ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((x = q) || (inferred x)) || (visibility x)) ||
-                      (assumption x)))
-        | FStar_Syntax_Syntax.Inline_for_extraction ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    ((((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                            (visibility x))
-                           || (reducibility x))
-                          || (reification x))
-                         || (inferred x))
-                        || (has_eq x))
-                       ||
-                       (env.FStar_TypeChecker_Env.is_iface &&
-                          (x = FStar_Syntax_Syntax.Assumption)))
-                      || (x = FStar_Syntax_Syntax.NoExtract)))
-        | FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                           (x = FStar_Syntax_Syntax.Inline_for_extraction))
-                          || (x = FStar_Syntax_Syntax.NoExtract))
-                         || (has_eq x))
-                        || (inferred x))
-                       || (visibility x))
-                      || (reification x)))
-        | FStar_Syntax_Syntax.Visible_default ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                           (x = FStar_Syntax_Syntax.Inline_for_extraction))
-                          || (x = FStar_Syntax_Syntax.NoExtract))
-                         || (has_eq x))
-                        || (inferred x))
-                       || (visibility x))
-                      || (reification x)))
-        | FStar_Syntax_Syntax.Irreducible ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                           (x = FStar_Syntax_Syntax.Inline_for_extraction))
-                          || (x = FStar_Syntax_Syntax.NoExtract))
-                         || (has_eq x))
-                        || (inferred x))
-                       || (visibility x))
-                      || (reification x)))
-        | FStar_Syntax_Syntax.Noeq ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                           (x = FStar_Syntax_Syntax.Inline_for_extraction))
-                          || (x = FStar_Syntax_Syntax.NoExtract))
-                         || (has_eq x))
-                        || (inferred x))
-                       || (visibility x))
-                      || (reification x)))
-        | FStar_Syntax_Syntax.Unopteq ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((((((x = q) || (x = FStar_Syntax_Syntax.Logic)) ||
-                           (x = FStar_Syntax_Syntax.Inline_for_extraction))
-                          || (x = FStar_Syntax_Syntax.NoExtract))
-                         || (has_eq x))
-                        || (inferred x))
-                       || (visibility x))
-                      || (reification x)))
-        | FStar_Syntax_Syntax.TotalEffect ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    (((x = q) || (inferred x)) || (visibility x)) ||
-                      (reification x)))
-        | FStar_Syntax_Syntax.Logic ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    ((((x = q) || (x = FStar_Syntax_Syntax.Assumption)) ||
-                        (inferred x))
-                       || (visibility x))
-                      || (reducibility x)))
-        | FStar_Syntax_Syntax.Reifiable ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    ((((reification x) || (inferred x)) || (visibility x)) ||
-                       (x = FStar_Syntax_Syntax.TotalEffect))
-                      || (x = FStar_Syntax_Syntax.Visible_default)))
-        | FStar_Syntax_Syntax.Reflectable uu___ ->
-            FStar_Compiler_Effect.op_Bar_Greater quals
-              (FStar_Compiler_List.for_all
-                 (fun x ->
-                    ((((reification x) || (inferred x)) || (visibility x)) ||
-                       (x = FStar_Syntax_Syntax.TotalEffect))
-                      || (x = FStar_Syntax_Syntax.Visible_default)))
-        | FStar_Syntax_Syntax.Private -> true
-        | uu___ -> true in
-      let check_erasable quals se1 r =
-        let lids = FStar_Syntax_Util.lids_of_sigelt se1 in
-        let val_exists =
-          FStar_Compiler_Effect.op_Bar_Greater lids
-            (FStar_Compiler_Util.for_some
-               (fun l ->
-                  let uu___ = FStar_TypeChecker_Env.try_lookup_val_decl env l in
-                  FStar_Compiler_Option.isSome uu___)) in
-        let val_has_erasable_attr =
-          FStar_Compiler_Effect.op_Bar_Greater lids
-            (FStar_Compiler_Util.for_some
-               (fun l ->
-                  let attrs_opt =
-                    FStar_TypeChecker_Env.lookup_attrs_of_lid env l in
-                  (FStar_Compiler_Option.isSome attrs_opt) &&
-                    (let uu___ = FStar_Compiler_Option.get attrs_opt in
-                     FStar_Syntax_Util.has_attribute uu___
-                       FStar_Parser_Const.erasable_attr))) in
-        let se_has_erasable_attr =
-          FStar_Syntax_Util.has_attribute se1.FStar_Syntax_Syntax.sigattrs
-            FStar_Parser_Const.erasable_attr in
-        if
-          (val_exists && val_has_erasable_attr) &&
-            (Prims.op_Negation se_has_erasable_attr)
-        then
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_QulifierListNotPermitted,
-              "Mismatch of attributes between declaration and definition: Declaration is marked `erasable` but the definition is not")
-            r
-        else ();
-        if
-          (val_exists && (Prims.op_Negation val_has_erasable_attr)) &&
-            se_has_erasable_attr
-        then
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_QulifierListNotPermitted,
-              "Mismatch of attributed between declaration and definition: Definition is marked `erasable` but the declaration is not")
-            r
-        else ();
-        if se_has_erasable_attr
-        then
-          (match se1.FStar_Syntax_Syntax.sigel with
-           | FStar_Syntax_Syntax.Sig_bundle uu___2 ->
-               let uu___3 =
-                 let uu___4 =
-                   FStar_Compiler_Effect.op_Bar_Greater quals
-                     (FStar_Compiler_Util.for_some
-                        (fun uu___5 ->
-                           match uu___5 with
-                           | FStar_Syntax_Syntax.Noeq -> true
-                           | uu___6 -> false)) in
-                 Prims.op_Negation uu___4 in
-               if uu___3
-               then
-                 FStar_Errors.raise_error
-                   (FStar_Errors.Fatal_QulifierListNotPermitted,
-                     "Incompatible attributes and qualifiers: erasable types do not support decidable equality and must be marked `noeq`")
-                   r
-               else ()
-           | FStar_Syntax_Syntax.Sig_declare_typ uu___2 -> ()
-           | FStar_Syntax_Syntax.Sig_fail uu___2 -> ()
-           | FStar_Syntax_Syntax.Sig_let ((false, lb::[]), uu___2) ->
-               let uu___3 =
-                 FStar_Syntax_Util.abs_formals lb.FStar_Syntax_Syntax.lbdef in
-               (match uu___3 with
-                | (uu___4, body, uu___5) ->
-                    let uu___6 =
-                      let uu___7 =
-                        FStar_TypeChecker_Normalize.non_info_norm env body in
-                      Prims.op_Negation uu___7 in
-                    if uu___6
-                    then
-                      let uu___7 =
-                        let uu___8 =
-                          let uu___9 = FStar_Syntax_Print.term_to_string body in
-                          FStar_Compiler_Util.format1
-                            "Illegal attribute: the `erasable` attribute is only permitted on inductive type definitions and abbreviations for non-informative types. %s is considered informative."
-                            uu___9 in
-                        (FStar_Errors.Fatal_QulifierListNotPermitted, uu___8) in
-                      FStar_Errors.raise_error uu___7
-                        body.FStar_Syntax_Syntax.pos
-                    else ())
-           | FStar_Syntax_Syntax.Sig_new_effect
-               { FStar_Syntax_Syntax.mname = eff_name;
-                 FStar_Syntax_Syntax.cattributes = uu___2;
-                 FStar_Syntax_Syntax.univs = uu___3;
-                 FStar_Syntax_Syntax.binders = uu___4;
-                 FStar_Syntax_Syntax.signature = uu___5;
-                 FStar_Syntax_Syntax.combinators = uu___6;
-                 FStar_Syntax_Syntax.actions = uu___7;
-                 FStar_Syntax_Syntax.eff_attrs = uu___8;_}
-               ->
-               if
-                 Prims.op_Negation
-                   (FStar_Compiler_List.contains
-                      FStar_Syntax_Syntax.TotalEffect quals)
-               then
-                 let uu___9 =
-                   let uu___10 =
-                     let uu___11 = FStar_Ident.string_of_lid eff_name in
-                     FStar_Compiler_Util.format1
-                       "Effect %s is marked erasable but only total effects are allowed to be erasable"
-                       uu___11 in
-                   (FStar_Errors.Fatal_QulifierListNotPermitted, uu___10) in
-                 FStar_Errors.raise_error uu___9 r
-               else ()
-           | uu___2 ->
-               FStar_Errors.raise_error
-                 (FStar_Errors.Fatal_QulifierListNotPermitted,
-                   "Illegal attribute: the `erasable` attribute is only permitted on inductive type definitions and abbreviations for non-informative types")
-                 r)
-        else () in
-      let check_no_subtyping_attribute se1 =
-        let uu___ =
-          (FStar_Syntax_Util.has_attribute se1.FStar_Syntax_Syntax.sigattrs
-             FStar_Parser_Const.no_subtping_attr_lid)
-            &&
-            (match se1.FStar_Syntax_Syntax.sigel with
-             | FStar_Syntax_Syntax.Sig_let uu___1 -> false
-             | uu___1 -> true) in
-        if uu___
-        then
-          FStar_Errors.raise_error
-            (FStar_Errors.Fatal_InconsistentQualifierAnnotation,
-              "Illegal attribute: no_subtyping attribute is allowed only on let-bindings")
-            se1.FStar_Syntax_Syntax.sigrng
-        else () in
-      check_no_subtyping_attribute se;
-      (let quals =
-         FStar_Compiler_Effect.op_Bar_Greater
-           (FStar_Syntax_Util.quals_of_sigelt se)
-           (FStar_Compiler_List.filter
-              (fun x -> Prims.op_Negation (x = FStar_Syntax_Syntax.Logic))) in
-       let uu___1 =
-         let uu___2 =
-           FStar_Compiler_Effect.op_Bar_Greater quals
-             (FStar_Compiler_Util.for_some
-                (fun uu___3 ->
-                   match uu___3 with
-                   | FStar_Syntax_Syntax.OnlyName -> true
-                   | uu___4 -> false)) in
-         FStar_Compiler_Effect.op_Bar_Greater uu___2 Prims.op_Negation in
-       if uu___1
-       then
-         let r = FStar_Syntax_Util.range_of_sigelt se in
-         let no_dup_quals =
-           FStar_Compiler_Util.remove_dups (fun x -> fun y -> x = y) quals in
-         let err' msg =
-           let uu___2 =
-             let uu___3 =
-               let uu___4 = FStar_Syntax_Print.quals_to_string quals in
-               FStar_Compiler_Util.format2
-                 "The qualifier list \"[%s]\" is not permissible for this element%s"
-                 uu___4 msg in
-             (FStar_Errors.Fatal_QulifierListNotPermitted, uu___3) in
-           FStar_Errors.raise_error uu___2 r in
-         let err msg = err' (Prims.op_Hat ": " msg) in
-         let err'1 uu___2 = err' "" in
-         (if
-            (FStar_Compiler_List.length quals) <>
-              (FStar_Compiler_List.length no_dup_quals)
-          then err "duplicate qualifiers"
-          else ();
-          (let uu___4 =
-             let uu___5 =
-               FStar_Compiler_Effect.op_Bar_Greater quals
-                 (FStar_Compiler_List.for_all (quals_combo_ok quals)) in
-             Prims.op_Negation uu___5 in
-           if uu___4 then err "ill-formed combination" else ());
-          check_erasable quals se r;
-          (match se.FStar_Syntax_Syntax.sigel with
-           | FStar_Syntax_Syntax.Sig_let ((is_rec, uu___5), uu___6) ->
-               ((let uu___8 =
-                   is_rec &&
-                     (FStar_Compiler_Effect.op_Bar_Greater quals
-                        (FStar_Compiler_List.contains
-                           FStar_Syntax_Syntax.Unfold_for_unification_and_vcgen)) in
-                 if uu___8
-                 then err "recursive definitions cannot be marked inline"
-                 else ());
-                (let uu___8 =
-                   FStar_Compiler_Effect.op_Bar_Greater quals
-                     (FStar_Compiler_Util.for_some
-                        (fun x -> (assumption x) || (has_eq x))) in
-                 if uu___8
-                 then
-                   err
-                     "definitions cannot be assumed or marked with equality qualifiers"
-                 else ()))
-           | FStar_Syntax_Syntax.Sig_bundle uu___5 ->
-               ((let uu___7 =
-                   let uu___8 =
-                     FStar_Compiler_Effect.op_Bar_Greater quals
-                       (FStar_Compiler_Util.for_all
-                          (fun x ->
-                             ((((x =
-                                   FStar_Syntax_Syntax.Inline_for_extraction)
-                                  || (x = FStar_Syntax_Syntax.NoExtract))
-                                 || (inferred x))
-                                || (visibility x))
-                               || (has_eq x))) in
-                   Prims.op_Negation uu___8 in
-                 if uu___7 then err'1 () else ());
-                (let uu___7 =
-                   (FStar_Compiler_Effect.op_Bar_Greater quals
-                      (FStar_Compiler_List.existsb
-                         (fun uu___8 ->
-                            match uu___8 with
-                            | FStar_Syntax_Syntax.Unopteq -> true
-                            | uu___9 -> false)))
-                     &&
-                     (FStar_Syntax_Util.has_attribute
-                        se.FStar_Syntax_Syntax.sigattrs
-                        FStar_Parser_Const.erasable_attr) in
-                 if uu___7
-                 then
-                   err
-                     "unopteq is not allowed on an erasable inductives since they don't have decidable equality"
-                 else ()))
-           | FStar_Syntax_Syntax.Sig_declare_typ uu___5 ->
-               let uu___6 =
-                 FStar_Compiler_Effect.op_Bar_Greater quals
-                   (FStar_Compiler_Util.for_some has_eq) in
-               if uu___6 then err'1 () else ()
-           | FStar_Syntax_Syntax.Sig_assume uu___5 ->
-               let uu___6 =
-                 let uu___7 =
-                   FStar_Compiler_Effect.op_Bar_Greater quals
-                     (FStar_Compiler_Util.for_all
-                        (fun x ->
-                           ((visibility x) ||
-                              (x = FStar_Syntax_Syntax.Assumption))
-                             || (x = FStar_Syntax_Syntax.InternalAssumption))) in
-                 Prims.op_Negation uu___7 in
-               if uu___6 then err'1 () else ()
-           | FStar_Syntax_Syntax.Sig_new_effect uu___5 ->
-               let uu___6 =
-                 let uu___7 =
-                   FStar_Compiler_Effect.op_Bar_Greater quals
-                     (FStar_Compiler_Util.for_all
-                        (fun x ->
-                           (((x = FStar_Syntax_Syntax.TotalEffect) ||
-                               (inferred x))
-                              || (visibility x))
-                             || (reification x))) in
-                 Prims.op_Negation uu___7 in
-               if uu___6 then err'1 () else ()
-           | FStar_Syntax_Syntax.Sig_effect_abbrev uu___5 ->
-               let uu___6 =
-                 let uu___7 =
-                   FStar_Compiler_Effect.op_Bar_Greater quals
-                     (FStar_Compiler_Util.for_all
-                        (fun x -> (inferred x) || (visibility x))) in
-                 Prims.op_Negation uu___7 in
-               if uu___6 then err'1 () else ()
-           | uu___5 -> ()))
-       else ())
-let (must_erase_for_extraction :
-  FStar_TypeChecker_Env.env -> FStar_Syntax_Syntax.term -> Prims.bool) =
-  fun g ->
-    fun t ->
-      let rec descend env t1 =
-        let uu___ =
-          let uu___1 = FStar_Syntax_Subst.compress t1 in
-          uu___1.FStar_Syntax_Syntax.n in
-        match uu___ with
-        | FStar_Syntax_Syntax.Tm_arrow uu___1 ->
-            let uu___2 = FStar_Syntax_Util.arrow_formals_comp t1 in
-            (match uu___2 with
-             | (bs, c) ->
-                 let env1 = FStar_TypeChecker_Env.push_binders env bs in
-                 (FStar_TypeChecker_Env.is_erasable_effect env1
-                    (FStar_Syntax_Util.comp_effect_name c))
-                   ||
-                   ((FStar_Syntax_Util.is_pure_or_ghost_comp c) &&
-                      (aux env1 (FStar_Syntax_Util.comp_result c))))
-        | FStar_Syntax_Syntax.Tm_refine
-            ({ FStar_Syntax_Syntax.ppname = uu___1;
-               FStar_Syntax_Syntax.index = uu___2;
-               FStar_Syntax_Syntax.sort = t2;_},
-             uu___3)
-            -> aux env t2
-        | FStar_Syntax_Syntax.Tm_app (head, uu___1) -> descend env head
-        | FStar_Syntax_Syntax.Tm_uinst (head, uu___1) -> descend env head
-        | FStar_Syntax_Syntax.Tm_fvar fv ->
-            FStar_TypeChecker_Env.fv_has_attr env fv
-              FStar_Parser_Const.must_erase_for_extraction_attr
-        | uu___1 -> false
-      and aux env t1 =
-        let t2 =
-          FStar_TypeChecker_Normalize.normalize
-            [FStar_TypeChecker_Env.Primops;
-            FStar_TypeChecker_Env.Weak;
-            FStar_TypeChecker_Env.HNF;
-            FStar_TypeChecker_Env.UnfoldUntil
-              FStar_Syntax_Syntax.delta_constant;
-            FStar_TypeChecker_Env.Beta;
-            FStar_TypeChecker_Env.AllowUnboundUniverses;
-            FStar_TypeChecker_Env.Zeta;
-            FStar_TypeChecker_Env.Iota;
-            FStar_TypeChecker_Env.Unascribe] env t1 in
-        let res =
-          (FStar_TypeChecker_Env.non_informative env t2) || (descend env t2) in
-        (let uu___1 =
-           FStar_Compiler_Effect.op_Less_Bar
-             (FStar_TypeChecker_Env.debug env)
-             (FStar_Options.Other "Extraction") in
-         if uu___1
-         then
-           let uu___2 = FStar_Syntax_Print.term_to_string t2 in
-           FStar_Compiler_Util.print2 "must_erase=%s: %s\n"
-             (if res then "true" else "false") uu___2
-         else ());
-        res in
-      aux g t
-let (fresh_effect_repr :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.tscheme ->
-          FStar_Syntax_Syntax.tscheme FStar_Pervasives_Native.option ->
-            FStar_Syntax_Syntax.universe ->
-              FStar_Syntax_Syntax.term ->
-                (FStar_Syntax_Syntax.term * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun r ->
-      fun eff_name ->
-        fun signature_ts ->
-          fun repr_ts_opt ->
-            fun u ->
-              fun a_tm ->
-                let fail t =
-                  let uu___ =
-                    FStar_TypeChecker_Err.unexpected_signature_for_monad env
-                      eff_name t in
-                  FStar_Errors.raise_error uu___ r in
-                let uu___ = FStar_TypeChecker_Env.inst_tscheme signature_ts in
-                match uu___ with
-                | (uu___1, signature) ->
-                    let debug =
-                      FStar_Compiler_Effect.op_Less_Bar
-                        (FStar_TypeChecker_Env.debug env)
-                        (FStar_Options.Other "LayeredEffectsApp") in
-                    let uu___2 =
-                      let uu___3 = FStar_Syntax_Subst.compress signature in
-                      uu___3.FStar_Syntax_Syntax.n in
-                    (match uu___2 with
-                     | FStar_Syntax_Syntax.Tm_arrow (bs, uu___3) ->
-                         let bs1 = FStar_Syntax_Subst.open_binders bs in
-                         (match bs1 with
-                          | a::bs2 ->
-                              let uu___4 =
-                                FStar_TypeChecker_Env.uvars_for_binders env
-                                  bs2
-                                  [FStar_Syntax_Syntax.NT
-                                     ((a.FStar_Syntax_Syntax.binder_bv),
-                                       a_tm)]
-                                  (fun b ->
-                                     if debug
-                                     then
-                                       let uu___5 =
-                                         FStar_Syntax_Print.binder_to_string
-                                           b in
-                                       let uu___6 =
-                                         FStar_Ident.string_of_lid eff_name in
-                                       let uu___7 =
-                                         FStar_Compiler_Range.string_of_range
-                                           r in
-                                       FStar_Compiler_Util.format3
-                                         "uvar for binder %s when creating a fresh repr for %s at %s"
-                                         uu___5 uu___6 uu___7
-                                     else "fresh_effect_repr") r in
-                              (match uu___4 with
-                               | (is, g) ->
-                                   let uu___5 =
-                                     match repr_ts_opt with
-                                     | FStar_Pervasives_Native.None ->
-                                         let eff_c =
-                                           let uu___6 =
-                                             let uu___7 =
-                                               FStar_Compiler_List.map
-                                                 FStar_Syntax_Syntax.as_arg
-                                                 is in
-                                             {
-                                               FStar_Syntax_Syntax.comp_univs
-                                                 = [u];
-                                               FStar_Syntax_Syntax.effect_name
-                                                 = eff_name;
-                                               FStar_Syntax_Syntax.result_typ
-                                                 = a_tm;
-                                               FStar_Syntax_Syntax.effect_args
-                                                 = uu___7;
-                                               FStar_Syntax_Syntax.flags = []
-                                             } in
-                                           FStar_Syntax_Syntax.mk_Comp uu___6 in
-                                         let uu___6 =
-                                           let uu___7 =
-                                             let uu___8 =
-                                               let uu___9 =
-                                                 FStar_Syntax_Syntax.null_binder
-                                                   FStar_Syntax_Syntax.t_unit in
-                                               [uu___9] in
-                                             (uu___8, eff_c) in
-                                           FStar_Syntax_Syntax.Tm_arrow
-                                             uu___7 in
-                                         FStar_Syntax_Syntax.mk uu___6 r
-                                     | FStar_Pervasives_Native.Some repr_ts
-                                         ->
-                                         let repr =
-                                           let uu___6 =
-                                             FStar_TypeChecker_Env.inst_tscheme_with
-                                               repr_ts [u] in
-                                           FStar_Compiler_Effect.op_Bar_Greater
-                                             uu___6
-                                             FStar_Pervasives_Native.snd in
-                                         let is_args =
-                                           FStar_Compiler_List.map2
-                                             (fun i ->
-                                                fun b ->
-                                                  let uu___6 =
-                                                    FStar_Syntax_Util.aqual_of_binder
-                                                      b in
-                                                  (i, uu___6)) is bs2 in
-                                         let uu___6 =
-                                           let uu___7 =
-                                             FStar_Syntax_Syntax.as_arg a_tm in
-                                           uu___7 :: is_args in
-                                         FStar_Syntax_Syntax.mk_Tm_app repr
-                                           uu___6 r in
-                                   (uu___5, g))
-                          | uu___4 -> fail signature)
-                     | uu___3 -> fail signature)
-let (fresh_effect_repr_en :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.universe ->
-          FStar_Syntax_Syntax.term ->
-            (FStar_Syntax_Syntax.term * FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun r ->
-      fun eff_name ->
-        fun u ->
-          fun a_tm ->
-            let uu___ =
-              FStar_Compiler_Effect.op_Bar_Greater eff_name
-                (FStar_TypeChecker_Env.get_effect_decl env) in
-            FStar_Compiler_Effect.op_Bar_Greater uu___
-              (fun ed ->
-                 let uu___1 =
-                   FStar_Syntax_Util.effect_sig_ts
-                     ed.FStar_Syntax_Syntax.signature in
-                 let uu___2 =
-                   FStar_Compiler_Effect.op_Bar_Greater ed
-                     FStar_Syntax_Util.get_eff_repr in
-                 fresh_effect_repr env r eff_name uu___1 uu___2 u a_tm)
-let (layered_effect_indices_as_binders :
-  FStar_TypeChecker_Env.env ->
-    FStar_Compiler_Range.range ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.tscheme ->
-          FStar_Syntax_Syntax.universe ->
-            FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.binders)
-  =
-  fun env ->
-    fun r ->
-      fun eff_name ->
-        fun sig_ts ->
-          fun u ->
-            fun a_tm ->
-              let uu___ = FStar_TypeChecker_Env.inst_tscheme_with sig_ts [u] in
-              match uu___ with
-              | (uu___1, sig_tm) ->
-                  let fail t =
-                    let uu___2 =
-                      FStar_TypeChecker_Err.unexpected_signature_for_monad
-                        env eff_name t in
-                    FStar_Errors.raise_error uu___2 r in
-                  let uu___2 =
-                    let uu___3 = FStar_Syntax_Subst.compress sig_tm in
-                    uu___3.FStar_Syntax_Syntax.n in
-                  (match uu___2 with
-                   | FStar_Syntax_Syntax.Tm_arrow (bs, uu___3) ->
-                       let bs1 = FStar_Syntax_Subst.open_binders bs in
-                       (match bs1 with
-                        | { FStar_Syntax_Syntax.binder_bv = a';
-                            FStar_Syntax_Syntax.binder_qual = uu___4;
-                            FStar_Syntax_Syntax.binder_attrs = uu___5;_}::bs2
-                            ->
-                            FStar_Compiler_Effect.op_Bar_Greater bs2
-                              (FStar_Syntax_Subst.subst_binders
-                                 [FStar_Syntax_Syntax.NT (a', a_tm)])
-                        | uu___4 -> fail sig_tm)
-                   | uu___3 -> fail sig_tm)
-let (check_non_informative_type_for_lift :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Syntax_Syntax.term -> FStar_Compiler_Range.range -> unit)
-  =
-  fun env ->
-    fun m1 ->
-      fun m2 ->
-        fun t ->
-          fun r ->
-            let uu___ =
-              ((FStar_TypeChecker_Env.is_erasable_effect env m1) &&
-                 (let uu___1 =
-                    FStar_TypeChecker_Env.is_erasable_effect env m2 in
-                  Prims.op_Negation uu___1))
-                &&
-                (let uu___1 = FStar_TypeChecker_Normalize.non_info_norm env t in
-                 Prims.op_Negation uu___1) in
-            if uu___
-            then
-              let uu___1 =
-                let uu___2 =
-                  let uu___3 = FStar_Ident.string_of_lid m1 in
-                  let uu___4 = FStar_Ident.string_of_lid m2 in
-                  let uu___5 = FStar_Syntax_Print.term_to_string t in
-                  FStar_Compiler_Util.format3
-                    "Cannot lift erasable expression from %s ~> %s since its type %s is informative"
-                    uu___3 uu___4 uu___5 in
-                (FStar_Errors.Error_TypeError, uu___2) in
-              FStar_Errors.raise_error uu___1 r
-            else ()
-let (substitutive_indexed_lift_substs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp_typ ->
-        Prims.string ->
-          FStar_Compiler_Range.range ->
-            (FStar_Syntax_Syntax.subst_elt Prims.list *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun bs ->
-      fun ct ->
-        fun lift_name ->
-          fun r ->
-            let debug =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env)
-                (FStar_Options.Other "LayeredEffectsApp") in
-            let uu___ =
-              let uu___1 = bs in
-              match uu___1 with
-              | a_b::bs1 ->
-                  (bs1,
-                    [FStar_Syntax_Syntax.NT
-                       ((a_b.FStar_Syntax_Syntax.binder_bv),
-                         (ct.FStar_Syntax_Syntax.result_typ))]) in
-            match uu___ with
-            | (bs1, subst) ->
-                let uu___1 =
-                  let m_num_effect_args =
-                    FStar_Compiler_List.length
-                      ct.FStar_Syntax_Syntax.effect_args in
-                  let uu___2 =
-                    FStar_Compiler_List.splitAt m_num_effect_args bs1 in
-                  match uu___2 with
-                  | (f_bs, bs2) ->
-                      let f_subst =
-                        FStar_Compiler_List.map2
-                          (fun f_b ->
-                             fun uu___3 ->
-                               match uu___3 with
-                               | (arg, uu___4) ->
-                                   FStar_Syntax_Syntax.NT
-                                     ((f_b.FStar_Syntax_Syntax.binder_bv),
-                                       arg)) f_bs
-                          ct.FStar_Syntax_Syntax.effect_args in
-                      (bs2, (FStar_Compiler_List.op_At subst f_subst)) in
-                (match uu___1 with
-                 | (bs2, subst1) ->
-                     let bs3 =
-                       let uu___2 =
-                         FStar_Compiler_List.splitAt
-                           ((FStar_Compiler_List.length bs2) - Prims.int_one)
-                           bs2 in
-                       FStar_Compiler_Effect.op_Bar_Greater uu___2
-                         FStar_Pervasives_Native.fst in
-                     FStar_Compiler_List.fold_left
-                       (fun uu___2 ->
-                          fun b ->
-                            match uu___2 with
-                            | (subst2, g) ->
-                                let uu___3 =
-                                  FStar_TypeChecker_Env.uvars_for_binders env
-                                    [b] subst2
-                                    (fun b1 ->
-                                       if debug
-                                       then
-                                         let uu___4 =
-                                           FStar_Syntax_Print.binder_to_string
-                                             b1 in
-                                         let uu___5 =
-                                           FStar_Compiler_Range.string_of_range
-                                             r in
-                                         FStar_Compiler_Util.format3
-                                           "implicit var for additional lift binder %s of %s at %s)"
-                                           uu___4 lift_name uu___5
-                                       else
-                                         "substitutive_indexed_lift_substs")
-                                    r in
-                                (match uu___3 with
-                                 | (uv_t::[], g_uv) ->
-                                     let uu___4 =
-                                       FStar_TypeChecker_Env.conj_guard g
-                                         g_uv in
-                                     ((FStar_Compiler_List.op_At subst2
-                                         [FStar_Syntax_Syntax.NT
-                                            ((b.FStar_Syntax_Syntax.binder_bv),
-                                              uv_t)]), uu___4)))
-                       (subst1, FStar_TypeChecker_Env.trivial_guard) bs3)
-let (ad_hoc_indexed_lift_substs :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.binders ->
-      FStar_Syntax_Syntax.comp_typ ->
-        Prims.string ->
-          FStar_Compiler_Range.range ->
-            (FStar_Syntax_Syntax.subst_elt Prims.list *
-              FStar_TypeChecker_Env.guard_t))
-  =
-  fun env ->
-    fun bs ->
-      fun ct ->
-        fun lift_name ->
-          fun r ->
-            let debug =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env)
-                (FStar_Options.Other "LayeredEffectsApp") in
-            let lift_t_shape_error s =
-              FStar_Compiler_Util.format2
-                "Lift %s has unexpected shape, reason: %s" lift_name s in
-            let uu___ =
-              if (FStar_Compiler_List.length bs) >= (Prims.of_int (2))
-              then
-                let uu___1 = bs in
-                match uu___1 with
-                | a_b::bs1 ->
-                    let uu___2 =
-                      FStar_Compiler_List.splitAt
-                        ((FStar_Compiler_List.length bs1) - Prims.int_one)
-                        bs1 in
-                    (a_b, uu___2)
-              else
-                (let uu___2 =
-                   let uu___3 =
-                     lift_t_shape_error
-                       "either not an arrow or not enough binders" in
-                   (FStar_Errors.Fatal_UnexpectedEffect, uu___3) in
-                 FStar_Errors.raise_error uu___2 r) in
-            match uu___ with
-            | (a_b, (rest_bs, f_b::[])) ->
-                let uu___1 =
-                  FStar_TypeChecker_Env.uvars_for_binders env rest_bs
-                    [FStar_Syntax_Syntax.NT
-                       ((a_b.FStar_Syntax_Syntax.binder_bv),
-                         (ct.FStar_Syntax_Syntax.result_typ))]
-                    (fun b ->
-                       if debug
-                       then
-                         let uu___2 = FStar_Syntax_Print.binder_to_string b in
-                         let uu___3 = FStar_Compiler_Range.string_of_range r in
-                         FStar_Compiler_Util.format3
-                           "implicit var for binder %s of %s at %s" uu___2
-                           lift_name uu___3
-                       else "ad_hoc_indexed_lift_substs") r in
-                (match uu___1 with
-                 | (rest_bs_uvars, g) ->
-                     let substs =
-                       FStar_Compiler_List.map2
-                         (fun b ->
-                            fun t ->
-                              FStar_Syntax_Syntax.NT
-                                ((b.FStar_Syntax_Syntax.binder_bv), t)) (a_b
-                         :: rest_bs) ((ct.FStar_Syntax_Syntax.result_typ) ::
-                         rest_bs_uvars) in
-                     let guard_f =
-                       let f_sort =
-                         let uu___2 =
-                           FStar_Compiler_Effect.op_Bar_Greater
-                             (f_b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort
-                             (FStar_Syntax_Subst.subst substs) in
-                         FStar_Compiler_Effect.op_Bar_Greater uu___2
-                           FStar_Syntax_Subst.compress in
-                       let f_sort_is =
-                         let uu___2 =
-                           FStar_TypeChecker_Env.is_layered_effect env
-                             ct.FStar_Syntax_Syntax.effect_name in
-                         effect_args_from_repr f_sort uu___2 r in
-                       let uu___2 =
-                         FStar_Compiler_List.map FStar_Pervasives_Native.fst
-                           ct.FStar_Syntax_Syntax.effect_args in
-                       FStar_Compiler_List.fold_left2
-                         (fun g1 ->
-                            fun i1 ->
-                              fun i2 ->
-                                let uu___3 =
-                                  FStar_TypeChecker_Rel.layered_effect_teq
-                                    env i1 i2
-                                    (FStar_Pervasives_Native.Some lift_name) in
-                                FStar_TypeChecker_Env.conj_guard g1 uu___3)
-                         FStar_TypeChecker_Env.trivial_guard uu___2 f_sort_is in
-                     let uu___2 = FStar_TypeChecker_Env.conj_guard g guard_f in
-                     (substs, uu___2))
-let (lift_tf_layered_effect :
-  FStar_Ident.lident ->
-    FStar_Syntax_Syntax.tscheme ->
-      FStar_Syntax_Syntax.indexed_effect_combinator_kind ->
-        FStar_TypeChecker_Env.env ->
-          FStar_Syntax_Syntax.comp ->
-            (FStar_Syntax_Syntax.comp * FStar_TypeChecker_Env.guard_t))
-  =
-  fun tgt ->
-    fun lift_ts ->
-      fun kind ->
-        fun env ->
-          fun c ->
-            let debug =
-              FStar_Compiler_Effect.op_Less_Bar
-                (FStar_TypeChecker_Env.debug env)
-                (FStar_Options.Other "LayeredEffectsApp") in
-            if debug
-            then
-              (let uu___1 = FStar_Syntax_Print.comp_to_string c in
-               let uu___2 = FStar_Syntax_Print.lid_to_string tgt in
-               FStar_Compiler_Util.print2
-                 "Lifting indexed comp %s to  %s {\n" uu___1 uu___2)
-            else ();
-            (let r = FStar_TypeChecker_Env.get_range env in
-             let ct = FStar_TypeChecker_Env.comp_to_comp_typ env c in
-             check_non_informative_type_for_lift env
-               ct.FStar_Syntax_Syntax.effect_name tgt
-               ct.FStar_Syntax_Syntax.result_typ r;
-             (let lift_name uu___2 =
-                if debug
-                then
-                  let uu___3 =
-                    FStar_Ident.string_of_lid
-                      ct.FStar_Syntax_Syntax.effect_name in
-                  let uu___4 = FStar_Ident.string_of_lid tgt in
-                  FStar_Compiler_Util.format2 "%s ~> %s" uu___3 uu___4
-                else "" in
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 =
-                    FStar_Compiler_List.hd ct.FStar_Syntax_Syntax.comp_univs in
-                  [uu___4] in
-                FStar_TypeChecker_Env.inst_tscheme_with lift_ts uu___3 in
-              match uu___2 with
-              | (uu___3, lift_t) ->
-                  let uu___4 = FStar_Syntax_Util.arrow_formals_comp lift_t in
-                  (match uu___4 with
-                   | (bs, lift_c) ->
-                       let uu___5 =
-                         if kind = FStar_Syntax_Syntax.Ad_hoc_combinator
-                         then
-                           let uu___6 = lift_name () in
-                           ad_hoc_indexed_lift_substs env bs ct uu___6 r
-                         else
-                           (let uu___7 = lift_name () in
-                            substitutive_indexed_lift_substs env bs ct uu___7
-                              r) in
-                       (match uu___5 with
-                        | (substs, g) ->
-                            let lift_ct =
-                              let uu___6 =
-                                FStar_Compiler_Effect.op_Bar_Greater lift_c
-                                  (FStar_Syntax_Subst.subst_comp substs) in
-                              FStar_Compiler_Effect.op_Bar_Greater uu___6
-                                (FStar_TypeChecker_Env.comp_to_comp_typ env) in
-                            let is =
-                              let uu___6 =
-                                FStar_TypeChecker_Env.is_layered_effect env
-                                  tgt in
-                              effect_args_from_repr
-                                lift_ct.FStar_Syntax_Syntax.result_typ uu___6
-                                r in
-                            let fml =
-                              let uu___6 =
-                                let uu___7 =
-                                  FStar_Compiler_List.hd
-                                    lift_ct.FStar_Syntax_Syntax.comp_univs in
-                                let uu___8 =
-                                  let uu___9 =
-                                    FStar_Compiler_List.hd
-                                      lift_ct.FStar_Syntax_Syntax.effect_args in
-                                  FStar_Pervasives_Native.fst uu___9 in
-                                (uu___7, uu___8) in
-                              match uu___6 with
-                              | (u, wp) ->
-                                  FStar_TypeChecker_Env.pure_precondition_for_trivial_post
-                                    env u
-                                    lift_ct.FStar_Syntax_Syntax.result_typ wp
-                                    FStar_Compiler_Range.dummyRange in
-                            ((let uu___7 =
-                                (FStar_Compiler_Effect.op_Less_Bar
-                                   (FStar_TypeChecker_Env.debug env)
-                                   (FStar_Options.Other "LayeredEffects"))
-                                  &&
-                                  (FStar_Compiler_Effect.op_Less_Bar
-                                     (FStar_TypeChecker_Env.debug env)
-                                     FStar_Options.Extreme) in
-                              if uu___7
-                              then
-                                let uu___8 =
-                                  FStar_Syntax_Print.term_to_string fml in
-                                FStar_Compiler_Util.print1
-                                  "Guard for lift is: %s" uu___8
-                              else ());
-                             (let c1 =
-                                let uu___7 =
-                                  let uu___8 =
-                                    FStar_Compiler_Effect.op_Bar_Greater is
-                                      (FStar_Compiler_List.map
-                                         FStar_Syntax_Syntax.as_arg) in
-                                  {
-                                    FStar_Syntax_Syntax.comp_univs =
-                                      (ct.FStar_Syntax_Syntax.comp_univs);
-                                    FStar_Syntax_Syntax.effect_name = tgt;
-                                    FStar_Syntax_Syntax.result_typ =
-                                      (ct.FStar_Syntax_Syntax.result_typ);
-                                    FStar_Syntax_Syntax.effect_args = uu___8;
-                                    FStar_Syntax_Syntax.flags = []
-                                  } in
-                                FStar_Syntax_Syntax.mk_Comp uu___7 in
-                              if debug
-                              then
-                                (let uu___8 =
-                                   FStar_Syntax_Print.comp_to_string c1 in
-                                 FStar_Compiler_Util.print1
-                                   "} Lifted comp: %s\n" uu___8)
-                              else ();
-                              (let g1 =
-                                 let uu___8 =
-                                   let uu___9 =
-                                     let uu___10 =
-                                       FStar_TypeChecker_Env.guard_of_guard_formula
-                                         (FStar_TypeChecker_Common.NonTrivial
-                                            fml) in
-                                     [uu___10] in
-                                   g :: uu___9 in
-                                 FStar_TypeChecker_Env.conj_guards uu___8 in
-                               (c1, g1))))))))
-let lift_tf_layered_effect_term :
-  'uuuuu .
-    'uuuuu ->
-      FStar_Syntax_Syntax.sub_eff ->
-        FStar_Syntax_Syntax.universe ->
-          FStar_Syntax_Syntax.typ ->
-            FStar_Syntax_Syntax.term -> FStar_Syntax_Syntax.term
-  =
-  fun env ->
-    fun sub ->
-      fun u ->
-        fun a ->
-          fun e ->
-            let lift =
-              let uu___ =
-                let uu___1 =
-                  FStar_Compiler_Effect.op_Bar_Greater
-                    sub.FStar_Syntax_Syntax.lift FStar_Compiler_Util.must in
-                FStar_Compiler_Effect.op_Bar_Greater uu___1
-                  (fun ts -> FStar_TypeChecker_Env.inst_tscheme_with ts [u]) in
-              FStar_Compiler_Effect.op_Bar_Greater uu___
-                FStar_Pervasives_Native.snd in
-            let rest_bs =
-              let lift_t =
-                FStar_Compiler_Effect.op_Bar_Greater
-                  sub.FStar_Syntax_Syntax.lift_wp FStar_Compiler_Util.must in
-              let uu___ =
-                let uu___1 =
-                  let uu___2 =
-                    FStar_Compiler_Effect.op_Bar_Greater lift_t
-                      FStar_Pervasives_Native.snd in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___2
-                    FStar_Syntax_Subst.compress in
-                uu___1.FStar_Syntax_Syntax.n in
-              match uu___ with
-              | FStar_Syntax_Syntax.Tm_arrow (uu___1::bs, uu___2) when
-                  (FStar_Compiler_List.length bs) >= Prims.int_one ->
-                  let uu___3 =
-                    FStar_Compiler_Effect.op_Bar_Greater bs
-                      (FStar_Compiler_List.splitAt
-                         ((FStar_Compiler_List.length bs) - Prims.int_one)) in
-                  FStar_Compiler_Effect.op_Bar_Greater uu___3
-                    FStar_Pervasives_Native.fst
-              | uu___1 ->
-                  let uu___2 =
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Syntax_Print.tscheme_to_string lift_t in
-                      FStar_Compiler_Util.format1
-                        "lift_t tscheme %s is not an arrow with enough binders"
-                        uu___4 in
-                    (FStar_Errors.Fatal_UnexpectedEffect, uu___3) in
-                  FStar_Errors.raise_error uu___2
-                    (FStar_Pervasives_Native.snd lift_t).FStar_Syntax_Syntax.pos in
-            let args =
-              let uu___ = FStar_Syntax_Syntax.as_arg a in
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater rest_bs
-                    (FStar_Compiler_List.map
-                       (fun uu___3 ->
-                          FStar_Syntax_Syntax.as_arg
-                            FStar_Syntax_Syntax.unit_const)) in
-                let uu___3 =
-                  let uu___4 = FStar_Syntax_Syntax.as_arg e in [uu___4] in
-                FStar_Compiler_List.op_At uu___2 uu___3 in
-              uu___ :: uu___1 in
-            FStar_Syntax_Syntax.mk (FStar_Syntax_Syntax.Tm_app (lift, args))
-              e.FStar_Syntax_Syntax.pos
-let (get_field_projector_name :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident -> Prims.int -> FStar_Ident.lident)
-  =
-  fun env ->
-    fun datacon ->
-      fun index ->
-        let uu___ = FStar_TypeChecker_Env.lookup_datacon env datacon in
-        match uu___ with
-        | (uu___1, t) ->
-            let err n =
-              let uu___2 =
-                let uu___3 =
-                  let uu___4 = FStar_Ident.string_of_lid datacon in
-                  let uu___5 = FStar_Compiler_Util.string_of_int n in
-                  let uu___6 = FStar_Compiler_Util.string_of_int index in
-                  FStar_Compiler_Util.format3
-                    "Data constructor %s does not have enough binders (has %s, tried %s)"
-                    uu___4 uu___5 uu___6 in
-                (FStar_Errors.Fatal_UnexpectedDataConstructor, uu___3) in
-              let uu___3 = FStar_TypeChecker_Env.get_range env in
-              FStar_Errors.raise_error uu___2 uu___3 in
-            let uu___2 =
-              let uu___3 = FStar_Syntax_Subst.compress t in
-              uu___3.FStar_Syntax_Syntax.n in
-            (match uu___2 with
-             | FStar_Syntax_Syntax.Tm_arrow (bs, uu___3) ->
-                 let bs1 =
-                   FStar_Compiler_Effect.op_Bar_Greater bs
-                     (FStar_Compiler_List.filter
-                        (fun uu___4 ->
-                           match uu___4 with
-                           | { FStar_Syntax_Syntax.binder_bv = uu___5;
-                               FStar_Syntax_Syntax.binder_qual = q;
-                               FStar_Syntax_Syntax.binder_attrs = uu___6;_}
-                               ->
-                               (match q with
-                                | FStar_Pervasives_Native.Some
-                                    (FStar_Syntax_Syntax.Implicit (true)) ->
-                                    false
-                                | uu___7 -> true))) in
-                 if (FStar_Compiler_List.length bs1) <= index
-                 then err (FStar_Compiler_List.length bs1)
-                 else
-                   (let b = FStar_Compiler_List.nth bs1 index in
-                    FStar_Syntax_Util.mk_field_projector_name datacon
-                      b.FStar_Syntax_Syntax.binder_bv index)
-             | uu___3 -> err Prims.int_zero)
-let (get_mlift_for_subeff :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sub_eff -> FStar_TypeChecker_Env.mlift)
-  =
-  fun env ->
-    fun sub ->
-      let uu___ =
-        (FStar_TypeChecker_Env.is_layered_effect env
-           sub.FStar_Syntax_Syntax.source)
-          ||
-          (FStar_TypeChecker_Env.is_layered_effect env
-             sub.FStar_Syntax_Syntax.target) in
-      if uu___
-      then
-        let uu___1 =
-          let uu___2 =
-            FStar_Compiler_Effect.op_Bar_Greater
-              sub.FStar_Syntax_Syntax.lift_wp FStar_Compiler_Util.must in
-          let uu___3 =
-            FStar_Compiler_Effect.op_Bar_Greater sub.FStar_Syntax_Syntax.kind
-              FStar_Compiler_Util.must in
-          lift_tf_layered_effect sub.FStar_Syntax_Syntax.target uu___2 uu___3 in
-        {
-          FStar_TypeChecker_Env.mlift_wp = uu___1;
-          FStar_TypeChecker_Env.mlift_term =
-            (FStar_Pervasives_Native.Some
-               (lift_tf_layered_effect_term env sub))
-        }
-      else
-        (let mk_mlift_wp ts env1 c =
-           let ct = FStar_TypeChecker_Env.comp_to_comp_typ env1 c in
-           check_non_informative_type_for_lift env1
-             ct.FStar_Syntax_Syntax.effect_name
-             sub.FStar_Syntax_Syntax.target ct.FStar_Syntax_Syntax.result_typ
-             env1.FStar_TypeChecker_Env.range;
-           (let uu___3 =
-              FStar_TypeChecker_Env.inst_tscheme_with ts
-                ct.FStar_Syntax_Syntax.comp_univs in
-            match uu___3 with
-            | (uu___4, lift_t) ->
-                let wp =
-                  FStar_Compiler_List.hd ct.FStar_Syntax_Syntax.effect_args in
-                let uu___5 =
-                  let uu___6 =
-                    let uu___7 =
-                      let uu___8 =
-                        let uu___9 =
-                          let uu___10 =
-                            let uu___11 =
-                              let uu___12 =
-                                let uu___13 =
-                                  FStar_Syntax_Syntax.as_arg
-                                    ct.FStar_Syntax_Syntax.result_typ in
-                                [uu___13; wp] in
-                              (lift_t, uu___12) in
-                            FStar_Syntax_Syntax.Tm_app uu___11 in
-                          FStar_Syntax_Syntax.mk uu___10
-                            (FStar_Pervasives_Native.fst wp).FStar_Syntax_Syntax.pos in
-                        FStar_Compiler_Effect.op_Bar_Greater uu___9
-                          FStar_Syntax_Syntax.as_arg in
-                      [uu___8] in
-                    {
-                      FStar_Syntax_Syntax.comp_univs =
-                        (ct.FStar_Syntax_Syntax.comp_univs);
-                      FStar_Syntax_Syntax.effect_name =
-                        (sub.FStar_Syntax_Syntax.target);
-                      FStar_Syntax_Syntax.result_typ =
-                        (ct.FStar_Syntax_Syntax.result_typ);
-                      FStar_Syntax_Syntax.effect_args = uu___7;
-                      FStar_Syntax_Syntax.flags =
-                        (ct.FStar_Syntax_Syntax.flags)
-                    } in
-                  FStar_Syntax_Syntax.mk_Comp uu___6 in
-                (uu___5, FStar_TypeChecker_Common.trivial_guard)) in
-         let mk_mlift_term ts u r e =
-           let uu___2 = FStar_TypeChecker_Env.inst_tscheme_with ts [u] in
-           match uu___2 with
-           | (uu___3, lift_t) ->
-               let uu___4 =
-                 let uu___5 =
-                   let uu___6 =
-                     let uu___7 = FStar_Syntax_Syntax.as_arg r in
-                     let uu___8 =
-                       let uu___9 =
-                         FStar_Syntax_Syntax.as_arg FStar_Syntax_Syntax.tun in
-                       let uu___10 =
-                         let uu___11 = FStar_Syntax_Syntax.as_arg e in
-                         [uu___11] in
-                       uu___9 :: uu___10 in
-                     uu___7 :: uu___8 in
-                   (lift_t, uu___6) in
-                 FStar_Syntax_Syntax.Tm_app uu___5 in
-               FStar_Syntax_Syntax.mk uu___4 e.FStar_Syntax_Syntax.pos in
-         let uu___2 =
-           let uu___3 =
-             FStar_Compiler_Effect.op_Bar_Greater
-               sub.FStar_Syntax_Syntax.lift_wp FStar_Compiler_Util.must in
-           FStar_Compiler_Effect.op_Bar_Greater uu___3 mk_mlift_wp in
-         {
-           FStar_TypeChecker_Env.mlift_wp = uu___2;
-           FStar_TypeChecker_Env.mlift_term =
-             (match sub.FStar_Syntax_Syntax.lift with
-              | FStar_Pervasives_Native.None ->
-                  FStar_Pervasives_Native.Some
-                    ((fun uu___3 ->
-                        fun uu___4 ->
-                          fun e -> FStar_Compiler_Util.return_all e))
-              | FStar_Pervasives_Native.Some ts ->
-                  FStar_Pervasives_Native.Some (mk_mlift_term ts))
-         })
-let (update_env_sub_eff :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.sub_eff ->
-      FStar_Compiler_Range.range -> FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun sub ->
-      fun r ->
-        let r0 = env.FStar_TypeChecker_Env.range in
-        let env1 =
-          let uu___ = get_mlift_for_subeff env sub in
-          FStar_TypeChecker_Env.update_effect_lattice
-            {
-              FStar_TypeChecker_Env.solver =
-                (env.FStar_TypeChecker_Env.solver);
-              FStar_TypeChecker_Env.range = r;
-              FStar_TypeChecker_Env.curmodule =
-                (env.FStar_TypeChecker_Env.curmodule);
-              FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-              FStar_TypeChecker_Env.gamma_sig =
-                (env.FStar_TypeChecker_Env.gamma_sig);
-              FStar_TypeChecker_Env.gamma_cache =
-                (env.FStar_TypeChecker_Env.gamma_cache);
-              FStar_TypeChecker_Env.modules =
-                (env.FStar_TypeChecker_Env.modules);
-              FStar_TypeChecker_Env.expected_typ =
-                (env.FStar_TypeChecker_Env.expected_typ);
-              FStar_TypeChecker_Env.sigtab =
-                (env.FStar_TypeChecker_Env.sigtab);
-              FStar_TypeChecker_Env.attrtab =
-                (env.FStar_TypeChecker_Env.attrtab);
-              FStar_TypeChecker_Env.instantiate_imp =
-                (env.FStar_TypeChecker_Env.instantiate_imp);
-              FStar_TypeChecker_Env.effects =
-                (env.FStar_TypeChecker_Env.effects);
-              FStar_TypeChecker_Env.generalize =
-                (env.FStar_TypeChecker_Env.generalize);
-              FStar_TypeChecker_Env.letrecs =
-                (env.FStar_TypeChecker_Env.letrecs);
-              FStar_TypeChecker_Env.top_level =
-                (env.FStar_TypeChecker_Env.top_level);
-              FStar_TypeChecker_Env.check_uvars =
-                (env.FStar_TypeChecker_Env.check_uvars);
-              FStar_TypeChecker_Env.use_eq_strict =
-                (env.FStar_TypeChecker_Env.use_eq_strict);
-              FStar_TypeChecker_Env.is_iface =
-                (env.FStar_TypeChecker_Env.is_iface);
-              FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-              FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-              FStar_TypeChecker_Env.lax_universes =
-                (env.FStar_TypeChecker_Env.lax_universes);
-              FStar_TypeChecker_Env.phase1 =
-                (env.FStar_TypeChecker_Env.phase1);
-              FStar_TypeChecker_Env.failhard =
-                (env.FStar_TypeChecker_Env.failhard);
-              FStar_TypeChecker_Env.nosynth =
-                (env.FStar_TypeChecker_Env.nosynth);
-              FStar_TypeChecker_Env.uvar_subtyping =
-                (env.FStar_TypeChecker_Env.uvar_subtyping);
-              FStar_TypeChecker_Env.tc_term =
-                (env.FStar_TypeChecker_Env.tc_term);
-              FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-              FStar_TypeChecker_Env.universe_of =
-                (env.FStar_TypeChecker_Env.universe_of);
-              FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-              FStar_TypeChecker_Env.teq_nosmt_force =
-                (env.FStar_TypeChecker_Env.teq_nosmt_force);
-              FStar_TypeChecker_Env.subtype_nosmt_force =
-                (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-              FStar_TypeChecker_Env.qtbl_name_and_index =
-                (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-              FStar_TypeChecker_Env.normalized_eff_names =
-                (env.FStar_TypeChecker_Env.normalized_eff_names);
-              FStar_TypeChecker_Env.fv_delta_depths =
-                (env.FStar_TypeChecker_Env.fv_delta_depths);
-              FStar_TypeChecker_Env.proof_ns =
-                (env.FStar_TypeChecker_Env.proof_ns);
-              FStar_TypeChecker_Env.synth_hook =
-                (env.FStar_TypeChecker_Env.synth_hook);
-              FStar_TypeChecker_Env.try_solve_implicits_hook =
-                (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-              FStar_TypeChecker_Env.splice =
-                (env.FStar_TypeChecker_Env.splice);
-              FStar_TypeChecker_Env.mpreprocess =
-                (env.FStar_TypeChecker_Env.mpreprocess);
-              FStar_TypeChecker_Env.postprocess =
-                (env.FStar_TypeChecker_Env.postprocess);
-              FStar_TypeChecker_Env.identifier_info =
-                (env.FStar_TypeChecker_Env.identifier_info);
-              FStar_TypeChecker_Env.tc_hooks =
-                (env.FStar_TypeChecker_Env.tc_hooks);
-              FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-              FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-              FStar_TypeChecker_Env.strict_args_tab =
-                (env.FStar_TypeChecker_Env.strict_args_tab);
-              FStar_TypeChecker_Env.erasable_types_tab =
-                (env.FStar_TypeChecker_Env.erasable_types_tab);
-              FStar_TypeChecker_Env.enable_defer_to_tac =
-                (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-              FStar_TypeChecker_Env.unif_allow_ref_guards =
-                (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-              FStar_TypeChecker_Env.erase_erasable_args =
-                (env.FStar_TypeChecker_Env.erase_erasable_args);
-              FStar_TypeChecker_Env.core_check =
-                (env.FStar_TypeChecker_Env.core_check)
-            } sub.FStar_Syntax_Syntax.source sub.FStar_Syntax_Syntax.target
-            uu___ in
-        {
-          FStar_TypeChecker_Env.solver = (env1.FStar_TypeChecker_Env.solver);
-          FStar_TypeChecker_Env.range = r0;
-          FStar_TypeChecker_Env.curmodule =
-            (env1.FStar_TypeChecker_Env.curmodule);
-          FStar_TypeChecker_Env.gamma = (env1.FStar_TypeChecker_Env.gamma);
-          FStar_TypeChecker_Env.gamma_sig =
-            (env1.FStar_TypeChecker_Env.gamma_sig);
-          FStar_TypeChecker_Env.gamma_cache =
-            (env1.FStar_TypeChecker_Env.gamma_cache);
-          FStar_TypeChecker_Env.modules =
-            (env1.FStar_TypeChecker_Env.modules);
-          FStar_TypeChecker_Env.expected_typ =
-            (env1.FStar_TypeChecker_Env.expected_typ);
-          FStar_TypeChecker_Env.sigtab = (env1.FStar_TypeChecker_Env.sigtab);
-          FStar_TypeChecker_Env.attrtab =
-            (env1.FStar_TypeChecker_Env.attrtab);
-          FStar_TypeChecker_Env.instantiate_imp =
-            (env1.FStar_TypeChecker_Env.instantiate_imp);
-          FStar_TypeChecker_Env.effects =
-            (env1.FStar_TypeChecker_Env.effects);
-          FStar_TypeChecker_Env.generalize =
-            (env1.FStar_TypeChecker_Env.generalize);
-          FStar_TypeChecker_Env.letrecs =
-            (env1.FStar_TypeChecker_Env.letrecs);
-          FStar_TypeChecker_Env.top_level =
-            (env1.FStar_TypeChecker_Env.top_level);
-          FStar_TypeChecker_Env.check_uvars =
-            (env1.FStar_TypeChecker_Env.check_uvars);
-          FStar_TypeChecker_Env.use_eq_strict =
-            (env1.FStar_TypeChecker_Env.use_eq_strict);
-          FStar_TypeChecker_Env.is_iface =
-            (env1.FStar_TypeChecker_Env.is_iface);
-          FStar_TypeChecker_Env.admit = (env1.FStar_TypeChecker_Env.admit);
-          FStar_TypeChecker_Env.lax = (env1.FStar_TypeChecker_Env.lax);
-          FStar_TypeChecker_Env.lax_universes =
-            (env1.FStar_TypeChecker_Env.lax_universes);
-          FStar_TypeChecker_Env.phase1 = (env1.FStar_TypeChecker_Env.phase1);
-          FStar_TypeChecker_Env.failhard =
-            (env1.FStar_TypeChecker_Env.failhard);
-          FStar_TypeChecker_Env.nosynth =
-            (env1.FStar_TypeChecker_Env.nosynth);
-          FStar_TypeChecker_Env.uvar_subtyping =
-            (env1.FStar_TypeChecker_Env.uvar_subtyping);
-          FStar_TypeChecker_Env.tc_term =
-            (env1.FStar_TypeChecker_Env.tc_term);
-          FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-            (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-          FStar_TypeChecker_Env.universe_of =
-            (env1.FStar_TypeChecker_Env.universe_of);
-          FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-            (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-          FStar_TypeChecker_Env.teq_nosmt_force =
-            (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-          FStar_TypeChecker_Env.subtype_nosmt_force =
-            (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-          FStar_TypeChecker_Env.qtbl_name_and_index =
-            (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-          FStar_TypeChecker_Env.normalized_eff_names =
-            (env1.FStar_TypeChecker_Env.normalized_eff_names);
-          FStar_TypeChecker_Env.fv_delta_depths =
-            (env1.FStar_TypeChecker_Env.fv_delta_depths);
-          FStar_TypeChecker_Env.proof_ns =
-            (env1.FStar_TypeChecker_Env.proof_ns);
-          FStar_TypeChecker_Env.synth_hook =
-            (env1.FStar_TypeChecker_Env.synth_hook);
-          FStar_TypeChecker_Env.try_solve_implicits_hook =
-            (env1.FStar_TypeChecker_Env.try_solve_implicits_hook);
-          FStar_TypeChecker_Env.splice = (env1.FStar_TypeChecker_Env.splice);
-          FStar_TypeChecker_Env.mpreprocess =
-            (env1.FStar_TypeChecker_Env.mpreprocess);
-          FStar_TypeChecker_Env.postprocess =
-            (env1.FStar_TypeChecker_Env.postprocess);
-          FStar_TypeChecker_Env.identifier_info =
-            (env1.FStar_TypeChecker_Env.identifier_info);
-          FStar_TypeChecker_Env.tc_hooks =
-            (env1.FStar_TypeChecker_Env.tc_hooks);
-          FStar_TypeChecker_Env.dsenv = (env1.FStar_TypeChecker_Env.dsenv);
-          FStar_TypeChecker_Env.nbe = (env1.FStar_TypeChecker_Env.nbe);
-          FStar_TypeChecker_Env.strict_args_tab =
-            (env1.FStar_TypeChecker_Env.strict_args_tab);
-          FStar_TypeChecker_Env.erasable_types_tab =
-            (env1.FStar_TypeChecker_Env.erasable_types_tab);
-          FStar_TypeChecker_Env.enable_defer_to_tac =
-            (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-          FStar_TypeChecker_Env.unif_allow_ref_guards =
-            (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-          FStar_TypeChecker_Env.erase_erasable_args =
-            (env1.FStar_TypeChecker_Env.erase_erasable_args);
-          FStar_TypeChecker_Env.core_check =
-            (env1.FStar_TypeChecker_Env.core_check)
-        }
-let (update_env_polymonadic_bind :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Ident.lident ->
-        FStar_Ident.lident ->
-          FStar_Syntax_Syntax.tscheme ->
-            FStar_Syntax_Syntax.indexed_effect_combinator_kind ->
-              FStar_TypeChecker_Env.env)
-  =
-  fun env ->
-    fun m ->
-      fun n ->
-        fun p ->
-          fun ty ->
-            fun k ->
-              FStar_TypeChecker_Env.add_polymonadic_bind env m n p
-                (fun env1 ->
-                   fun c1 ->
-                     fun bv_opt ->
-                       fun c2 ->
-                         fun flags ->
-                           fun r ->
-                             mk_indexed_bind env1 m n p ty k c1 bv_opt c2
-                               flags r Prims.int_zero false)
-let (try_lookup_record_type :
-  FStar_TypeChecker_Env.env ->
-    FStar_Ident.lident ->
-      FStar_Syntax_DsEnv.record_or_dc FStar_Pervasives_Native.option)
-  =
-  fun env ->
-    fun typename ->
-      try
-        (fun uu___ ->
-           match () with
-           | () ->
-               let uu___1 =
-                 FStar_TypeChecker_Env.datacons_of_typ env typename in
-               (match uu___1 with
-                | (uu___2, dc::[]) ->
-                    let se = FStar_TypeChecker_Env.lookup_sigelt env dc in
-                    (match se with
-                     | FStar_Pervasives_Native.Some
-                         {
-                           FStar_Syntax_Syntax.sigel =
-                             FStar_Syntax_Syntax.Sig_datacon
-                             (uu___3, uu___4, t, uu___5, nparms, uu___6);
-                           FStar_Syntax_Syntax.sigrng = uu___7;
-                           FStar_Syntax_Syntax.sigquals = uu___8;
-                           FStar_Syntax_Syntax.sigmeta = uu___9;
-                           FStar_Syntax_Syntax.sigattrs = uu___10;
-                           FStar_Syntax_Syntax.sigopts = uu___11;_}
-                         ->
-                         let uu___12 = FStar_Syntax_Util.arrow_formals t in
-                         (match uu___12 with
-                          | (formals, c) ->
-                              if
-                                nparms < (FStar_Compiler_List.length formals)
-                              then
-                                let uu___13 =
-                                  FStar_Compiler_List.splitAt nparms formals in
-                                (match uu___13 with
-                                 | (uu___14, fields) ->
-                                     let fields1 =
-                                       FStar_Compiler_List.filter
-                                         (fun b ->
-                                            match b.FStar_Syntax_Syntax.binder_qual
-                                            with
-                                            | FStar_Pervasives_Native.Some
-                                                (FStar_Syntax_Syntax.Implicit
-                                                uu___15) -> false
-                                            | uu___15 -> true) fields in
-                                     let fields2 =
-                                       FStar_Compiler_List.map
-                                         (fun b ->
-                                            (((b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.ppname),
-                                              ((b.FStar_Syntax_Syntax.binder_bv).FStar_Syntax_Syntax.sort)))
-                                         fields1 in
-                                     let is_rec =
-                                       FStar_TypeChecker_Env.is_record env
-                                         typename in
-                                     let r =
-                                       let uu___15 =
-                                         FStar_Ident.ident_of_lid dc in
-                                       {
-                                         FStar_Syntax_DsEnv.typename =
-                                           typename;
-                                         FStar_Syntax_DsEnv.constrname =
-                                           uu___15;
-                                         FStar_Syntax_DsEnv.parms = [];
-                                         FStar_Syntax_DsEnv.fields = fields2;
-                                         FStar_Syntax_DsEnv.is_private =
-                                           false;
-                                         FStar_Syntax_DsEnv.is_record =
-                                           is_rec
-                                       } in
-                                     FStar_Pervasives_Native.Some r)
-                              else
-                                ((let uu___15 =
-                                    FStar_Compiler_Util.string_of_int nparms in
-                                  let uu___16 =
-                                    FStar_Syntax_Print.term_to_string t in
-                                  let uu___17 =
-                                    FStar_Syntax_Print.binders_to_string ", "
-                                      formals in
-                                  FStar_Compiler_Util.print3
-                                    "Not enough formals; nparms=%s; type = %s; formals=%s\n"
-                                    uu___15 uu___16 uu___17);
-                                 FStar_Pervasives_Native.None))
-                     | uu___3 ->
-                         ((let uu___5 = FStar_Ident.string_of_lid dc in
-                           FStar_Compiler_Util.print1 "Could not find %s\n"
-                             uu___5);
-                          FStar_Pervasives_Native.None))
-                | (uu___2, dcs) ->
-                    ((let uu___4 = FStar_Ident.string_of_lid typename in
-                      FStar_Compiler_Util.print1
-                        "Could not find type %s ... Got %s\n" uu___4);
-                     FStar_Pervasives_Native.None))) ()
-      with | uu___ -> FStar_Pervasives_Native.None
-let (find_record_or_dc_from_typ :
-  FStar_TypeChecker_Env.env ->
-    FStar_Syntax_Syntax.typ FStar_Pervasives_Native.option ->
-      FStar_Syntax_Syntax.unresolved_constructor ->
-        FStar_Compiler_Range.range ->
-          (FStar_Syntax_DsEnv.record_or_dc * FStar_Ident.lident *
-            FStar_Syntax_Syntax.fv))
-  =
-  fun env ->
-    fun t ->
-      fun uc ->
-        fun rng ->
-          let default_rdc uu___ =
-            match uc.FStar_Syntax_Syntax.uc_typename with
-            | FStar_Pervasives_Native.None ->
-                let f =
-                  FStar_Compiler_List.hd uc.FStar_Syntax_Syntax.uc_fields in
-                let uu___1 =
-                  let uu___2 =
-                    let uu___3 = FStar_Ident.string_of_lid f in
-                    FStar_Compiler_Util.format1
-                      "Field name %s could not be resolved" uu___3 in
-                  (FStar_Errors.Fatal_IdentifierNotFound, uu___2) in
-                let uu___2 = FStar_Ident.range_of_lid f in
-                FStar_Errors.raise_error uu___1 uu___2
-            | FStar_Pervasives_Native.Some tn ->
-                let uu___1 = try_lookup_record_type env tn in
-                (match uu___1 with
-                 | FStar_Pervasives_Native.Some rdc -> rdc
-                 | FStar_Pervasives_Native.None ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = FStar_Ident.string_of_lid tn in
-                         FStar_Compiler_Util.format1
-                           "Record name %s not found" uu___4 in
-                       (FStar_Errors.Fatal_NameNotFound, uu___3) in
-                     let uu___3 = FStar_Ident.range_of_lid tn in
-                     FStar_Errors.raise_error uu___2 uu___3) in
-          let rdc =
-            match t with
-            | FStar_Pervasives_Native.None -> default_rdc ()
-            | FStar_Pervasives_Native.Some t1 ->
-                let uu___ =
-                  let uu___1 =
-                    FStar_TypeChecker_Normalize.unfold_whnf'
-                      [FStar_TypeChecker_Env.Unascribe;
-                      FStar_TypeChecker_Env.Unmeta;
-                      FStar_TypeChecker_Env.Unrefine] env t1 in
-                  FStar_Syntax_Util.head_and_args uu___1 in
-                (match uu___ with
-                 | (thead, uu___1) ->
-                     let uu___2 =
-                       let uu___3 =
-                         let uu___4 = FStar_Syntax_Util.un_uinst thead in
-                         FStar_Syntax_Subst.compress uu___4 in
-                       uu___3.FStar_Syntax_Syntax.n in
-                     (match uu___2 with
-                      | FStar_Syntax_Syntax.Tm_fvar type_name ->
-                          let uu___3 =
-                            try_lookup_record_type env
-                              (type_name.FStar_Syntax_Syntax.fv_name).FStar_Syntax_Syntax.v in
-                          (match uu___3 with
-                           | FStar_Pervasives_Native.None -> default_rdc ()
-                           | FStar_Pervasives_Native.Some r -> r)
-                      | uu___3 -> default_rdc ())) in
-          let constrname =
-            let name =
-              let uu___ =
-                let uu___1 =
-                  FStar_Ident.ns_of_lid rdc.FStar_Syntax_DsEnv.typename in
-                FStar_Compiler_List.op_At uu___1
-                  [rdc.FStar_Syntax_DsEnv.constrname] in
-              FStar_Ident.lid_of_ids uu___ in
-            FStar_Ident.set_lid_range name rng in
-          let constructor =
-            let qual =
-              if rdc.FStar_Syntax_DsEnv.is_record
-              then
-                let uu___ =
-                  let uu___1 =
-                    let uu___2 =
-                      FStar_Compiler_Effect.op_Bar_Greater
-                        rdc.FStar_Syntax_DsEnv.fields
-                        (FStar_Compiler_List.map FStar_Pervasives_Native.fst) in
-                    ((rdc.FStar_Syntax_DsEnv.typename), uu___2) in
-                  FStar_Syntax_Syntax.Record_ctor uu___1 in
-                FStar_Pervasives_Native.Some uu___
-              else FStar_Pervasives_Native.None in
-            FStar_Syntax_Syntax.lid_as_fv constrname
-              FStar_Syntax_Syntax.delta_constant qual in
-          (rdc, constrname, constructor)
-let (field_name_matches :
-  FStar_Ident.lident ->
-    FStar_Syntax_DsEnv.record_or_dc -> FStar_Ident.ident -> Prims.bool)
-  =
-  fun field_name ->
-    fun rdc ->
-      fun field ->
-        (let uu___ = FStar_Ident.ident_of_lid field_name in
-         FStar_Ident.ident_equals field uu___) &&
-          (let uu___ =
-             let uu___1 = FStar_Ident.ns_of_lid field_name in uu___1 <> [] in
-           if uu___
-           then
-             let uu___1 = FStar_Ident.nsstr field_name in
-             let uu___2 = FStar_Ident.nsstr rdc.FStar_Syntax_DsEnv.typename in
-             uu___1 = uu___2
-           else true)
-let make_record_fields_in_order :
-  'a .
-    FStar_TypeChecker_Env.env ->
-      FStar_Syntax_Syntax.unresolved_constructor ->
-        (FStar_Syntax_Syntax.typ, FStar_Syntax_Syntax.typ)
-          FStar_Pervasives.either FStar_Pervasives_Native.option ->
-          FStar_Syntax_DsEnv.record_or_dc ->
-            (FStar_Ident.lident * 'a) Prims.list ->
-              (FStar_Ident.ident -> 'a FStar_Pervasives_Native.option) ->
-                FStar_Compiler_Range.range -> 'a Prims.list
-  =
-  fun env ->
-    fun uc ->
-      fun topt ->
-        fun rdc ->
-          fun fas ->
-            fun not_found ->
-              fun rng ->
-                let debug uu___ =
-                  let print_rdc rdc1 =
-                    let uu___1 =
-                      FStar_Ident.string_of_lid
-                        rdc1.FStar_Syntax_DsEnv.typename in
-                    let uu___2 =
-                      FStar_Ident.string_of_id
-                        rdc1.FStar_Syntax_DsEnv.constrname in
-                    let uu___3 =
-                      let uu___4 =
-                        FStar_Compiler_List.map
-                          (fun uu___5 ->
-                             match uu___5 with
-                             | (i, uu___6) -> FStar_Ident.string_of_id i)
-                          rdc1.FStar_Syntax_DsEnv.fields in
-                      FStar_Compiler_Effect.op_Bar_Greater uu___4
-                        (FStar_String.concat "; ") in
-                    FStar_Compiler_Util.format3
-                      "{typename=%s; constrname=%s; fields=[%s]}" uu___1
-                      uu___2 uu___3 in
-                  let print_fas fas1 =
-                    let uu___1 =
-                      FStar_Compiler_List.map
-                        (fun uu___2 ->
-                           match uu___2 with
-                           | (i, uu___3) -> FStar_Ident.string_of_lid i) fas1 in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___1
-                      (FStar_String.concat "; ") in
-                  let print_topt topt1 =
-                    match topt1 with
-                    | FStar_Pervasives_Native.None ->
-                        let uu___1 =
-                          find_record_or_dc_from_typ env
-                            FStar_Pervasives_Native.None uc rng in
-                        (match uu___1 with
-                         | (rdc1, uu___2, uu___3) ->
-                             let uu___4 = print_rdc rdc1 in
-                             FStar_Compiler_Util.format1 "topt=None; rdc=%s"
-                               uu___4)
-                    | FStar_Pervasives_Native.Some (FStar_Pervasives.Inl t)
-                        ->
-                        let uu___1 =
-                          find_record_or_dc_from_typ env
-                            FStar_Pervasives_Native.None uc rng in
-                        (match uu___1 with
-                         | (rdc1, uu___2, uu___3) ->
-                             let uu___4 = FStar_Syntax_Print.term_to_string t in
-                             let uu___5 = print_rdc rdc1 in
-                             FStar_Compiler_Util.format2
-                               "topt=Some (Inl %s); rdc=%s" uu___4 uu___5)
-                    | FStar_Pervasives_Native.Some (FStar_Pervasives.Inr t)
-                        ->
-                        let uu___1 =
-                          find_record_or_dc_from_typ env
-                            FStar_Pervasives_Native.None uc rng in
-                        (match uu___1 with
-                         | (rdc1, uu___2, uu___3) ->
-                             let uu___4 = FStar_Syntax_Print.term_to_string t in
-                             let uu___5 = print_rdc rdc1 in
-                             FStar_Compiler_Util.format2
-                               "topt=Some (Inr %s); rdc=%s" uu___4 uu___5) in
-                  let uu___1 =
-                    match uc.FStar_Syntax_Syntax.uc_typename with
-                    | FStar_Pervasives_Native.None -> "none"
-                    | FStar_Pervasives_Native.Some tn ->
-                        FStar_Ident.string_of_lid tn in
-                  let uu___2 =
-                    let uu___3 =
-                      FStar_Compiler_List.map FStar_Ident.string_of_lid
-                        uc.FStar_Syntax_Syntax.uc_fields in
-                    FStar_Compiler_Effect.op_Bar_Greater uu___3
-                      (FStar_String.concat "; ") in
-                  let uu___3 = print_topt topt in
-                  let uu___4 = print_rdc rdc in
-                  let uu___5 = print_fas fas in
-                  FStar_Compiler_Util.print5
-                    "Resolved uc={typename=%s;fields=%s}\n\ttopt=%s\n\t{rdc = %s\n\tfield assignments=[%s]}\n"
-                    uu___1 uu___2 uu___3 uu___4 uu___5 in
-                let uu___ =
-                  FStar_Compiler_List.fold_left
-                    (fun uu___1 ->
-                       fun uu___2 ->
-                         match (uu___1, uu___2) with
-                         | ((fields, as_rev), (field_name, uu___3)) ->
-                             let uu___4 =
-                               FStar_Compiler_List.partition
-                                 (fun uu___5 ->
-                                    match uu___5 with
-                                    | (fn, uu___6) ->
-                                        field_name_matches fn rdc field_name)
-                                 fields in
-                             (match uu___4 with
-                              | (matching, rest) ->
-                                  (match matching with
-                                   | (uu___5, a1)::[] ->
-                                       (rest, (a1 :: as_rev))
-                                   | [] ->
-                                       let uu___5 = not_found field_name in
-                                       (match uu___5 with
-                                        | FStar_Pervasives_Native.None ->
-                                            let uu___6 =
-                                              let uu___7 =
-                                                let uu___8 =
-                                                  FStar_Ident.string_of_id
-                                                    field_name in
-                                                let uu___9 =
-                                                  FStar_Ident.string_of_lid
-                                                    rdc.FStar_Syntax_DsEnv.typename in
-                                                FStar_Compiler_Util.format2
-                                                  "Field %s of record type %s is missing"
-                                                  uu___8 uu___9 in
-                                              (FStar_Errors.Fatal_MissingFieldInRecord,
-                                                uu___7) in
-                                            FStar_Errors.raise_error uu___6
-                                              rng
-                                        | FStar_Pervasives_Native.Some a1 ->
-                                            (rest, (a1 :: as_rev)))
-                                   | uu___5 ->
-                                       let uu___6 =
-                                         let uu___7 =
-                                           let uu___8 =
-                                             FStar_Ident.string_of_id
-                                               field_name in
-                                           let uu___9 =
-                                             FStar_Ident.string_of_lid
-                                               rdc.FStar_Syntax_DsEnv.typename in
-                                           FStar_Compiler_Util.format2
-                                             "Field %s of record type %s is given multiple assignments"
-                                             uu___8 uu___9 in
-                                         (FStar_Errors.Fatal_MissingFieldInRecord,
-                                           uu___7) in
-                                       FStar_Errors.raise_error uu___6 rng)))
-                    (fas, []) rdc.FStar_Syntax_DsEnv.fields in
-                match uu___ with
-                | (rest, as_rev) ->
-                    ((match rest with
-                      | [] -> ()
-                      | (f, uu___2)::uu___3 ->
-                          let uu___4 =
-                            let uu___5 =
-                              let uu___6 = FStar_Ident.string_of_lid f in
-                              let uu___7 =
-                                FStar_Ident.string_of_lid
-                                  rdc.FStar_Syntax_DsEnv.typename in
-                              FStar_Compiler_Util.format2
-                                "Field %s is redundant for type %s" uu___6
-                                uu___7 in
-                            (FStar_Errors.Fatal_MissingFieldInRecord, uu___5) in
-                          FStar_Errors.raise_error uu___4 rng);
-                     FStar_Compiler_List.rev as_rev)
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_Universal.ml b/src/ocaml-output/FStar_Universal.ml
deleted file mode 100644
index a6e8251849d..00000000000
--- a/src/ocaml-output/FStar_Universal.ml
+++ /dev/null
@@ -1,1343 +0,0 @@
-open Prims
-type uenv = FStar_Extraction_ML_UEnv.uenv
-let (module_or_interface_name :
-  FStar_Syntax_Syntax.modul -> (Prims.bool * FStar_Ident.lid)) =
-  fun m ->
-    ((m.FStar_Syntax_Syntax.is_interface), (m.FStar_Syntax_Syntax.name))
-let with_dsenv_of_tcenv :
-  'a .
-    FStar_TypeChecker_Env.env ->
-      'a FStar_Syntax_DsEnv.withenv -> ('a * FStar_TypeChecker_Env.env)
-  =
-  fun tcenv ->
-    fun f ->
-      let uu___ = f tcenv.FStar_TypeChecker_Env.dsenv in
-      match uu___ with
-      | (a1, dsenv) ->
-          (a1,
-            {
-              FStar_TypeChecker_Env.solver =
-                (tcenv.FStar_TypeChecker_Env.solver);
-              FStar_TypeChecker_Env.range =
-                (tcenv.FStar_TypeChecker_Env.range);
-              FStar_TypeChecker_Env.curmodule =
-                (tcenv.FStar_TypeChecker_Env.curmodule);
-              FStar_TypeChecker_Env.gamma =
-                (tcenv.FStar_TypeChecker_Env.gamma);
-              FStar_TypeChecker_Env.gamma_sig =
-                (tcenv.FStar_TypeChecker_Env.gamma_sig);
-              FStar_TypeChecker_Env.gamma_cache =
-                (tcenv.FStar_TypeChecker_Env.gamma_cache);
-              FStar_TypeChecker_Env.modules =
-                (tcenv.FStar_TypeChecker_Env.modules);
-              FStar_TypeChecker_Env.expected_typ =
-                (tcenv.FStar_TypeChecker_Env.expected_typ);
-              FStar_TypeChecker_Env.sigtab =
-                (tcenv.FStar_TypeChecker_Env.sigtab);
-              FStar_TypeChecker_Env.attrtab =
-                (tcenv.FStar_TypeChecker_Env.attrtab);
-              FStar_TypeChecker_Env.instantiate_imp =
-                (tcenv.FStar_TypeChecker_Env.instantiate_imp);
-              FStar_TypeChecker_Env.effects =
-                (tcenv.FStar_TypeChecker_Env.effects);
-              FStar_TypeChecker_Env.generalize =
-                (tcenv.FStar_TypeChecker_Env.generalize);
-              FStar_TypeChecker_Env.letrecs =
-                (tcenv.FStar_TypeChecker_Env.letrecs);
-              FStar_TypeChecker_Env.top_level =
-                (tcenv.FStar_TypeChecker_Env.top_level);
-              FStar_TypeChecker_Env.check_uvars =
-                (tcenv.FStar_TypeChecker_Env.check_uvars);
-              FStar_TypeChecker_Env.use_eq_strict =
-                (tcenv.FStar_TypeChecker_Env.use_eq_strict);
-              FStar_TypeChecker_Env.is_iface =
-                (tcenv.FStar_TypeChecker_Env.is_iface);
-              FStar_TypeChecker_Env.admit =
-                (tcenv.FStar_TypeChecker_Env.admit);
-              FStar_TypeChecker_Env.lax = (tcenv.FStar_TypeChecker_Env.lax);
-              FStar_TypeChecker_Env.lax_universes =
-                (tcenv.FStar_TypeChecker_Env.lax_universes);
-              FStar_TypeChecker_Env.phase1 =
-                (tcenv.FStar_TypeChecker_Env.phase1);
-              FStar_TypeChecker_Env.failhard =
-                (tcenv.FStar_TypeChecker_Env.failhard);
-              FStar_TypeChecker_Env.nosynth =
-                (tcenv.FStar_TypeChecker_Env.nosynth);
-              FStar_TypeChecker_Env.uvar_subtyping =
-                (tcenv.FStar_TypeChecker_Env.uvar_subtyping);
-              FStar_TypeChecker_Env.tc_term =
-                (tcenv.FStar_TypeChecker_Env.tc_term);
-              FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-                (tcenv.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-              FStar_TypeChecker_Env.universe_of =
-                (tcenv.FStar_TypeChecker_Env.universe_of);
-              FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-                (tcenv.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-              FStar_TypeChecker_Env.teq_nosmt_force =
-                (tcenv.FStar_TypeChecker_Env.teq_nosmt_force);
-              FStar_TypeChecker_Env.subtype_nosmt_force =
-                (tcenv.FStar_TypeChecker_Env.subtype_nosmt_force);
-              FStar_TypeChecker_Env.qtbl_name_and_index =
-                (tcenv.FStar_TypeChecker_Env.qtbl_name_and_index);
-              FStar_TypeChecker_Env.normalized_eff_names =
-                (tcenv.FStar_TypeChecker_Env.normalized_eff_names);
-              FStar_TypeChecker_Env.fv_delta_depths =
-                (tcenv.FStar_TypeChecker_Env.fv_delta_depths);
-              FStar_TypeChecker_Env.proof_ns =
-                (tcenv.FStar_TypeChecker_Env.proof_ns);
-              FStar_TypeChecker_Env.synth_hook =
-                (tcenv.FStar_TypeChecker_Env.synth_hook);
-              FStar_TypeChecker_Env.try_solve_implicits_hook =
-                (tcenv.FStar_TypeChecker_Env.try_solve_implicits_hook);
-              FStar_TypeChecker_Env.splice =
-                (tcenv.FStar_TypeChecker_Env.splice);
-              FStar_TypeChecker_Env.mpreprocess =
-                (tcenv.FStar_TypeChecker_Env.mpreprocess);
-              FStar_TypeChecker_Env.postprocess =
-                (tcenv.FStar_TypeChecker_Env.postprocess);
-              FStar_TypeChecker_Env.identifier_info =
-                (tcenv.FStar_TypeChecker_Env.identifier_info);
-              FStar_TypeChecker_Env.tc_hooks =
-                (tcenv.FStar_TypeChecker_Env.tc_hooks);
-              FStar_TypeChecker_Env.dsenv = dsenv;
-              FStar_TypeChecker_Env.nbe = (tcenv.FStar_TypeChecker_Env.nbe);
-              FStar_TypeChecker_Env.strict_args_tab =
-                (tcenv.FStar_TypeChecker_Env.strict_args_tab);
-              FStar_TypeChecker_Env.erasable_types_tab =
-                (tcenv.FStar_TypeChecker_Env.erasable_types_tab);
-              FStar_TypeChecker_Env.enable_defer_to_tac =
-                (tcenv.FStar_TypeChecker_Env.enable_defer_to_tac);
-              FStar_TypeChecker_Env.unif_allow_ref_guards =
-                (tcenv.FStar_TypeChecker_Env.unif_allow_ref_guards);
-              FStar_TypeChecker_Env.erase_erasable_args =
-                (tcenv.FStar_TypeChecker_Env.erase_erasable_args);
-              FStar_TypeChecker_Env.core_check =
-                (tcenv.FStar_TypeChecker_Env.core_check)
-            })
-let with_tcenv_of_env :
-  'a .
-    uenv ->
-      (FStar_TypeChecker_Env.env -> ('a * FStar_TypeChecker_Env.env)) ->
-        ('a * uenv)
-  =
-  fun e ->
-    fun f ->
-      let uu___ =
-        let uu___1 = FStar_Extraction_ML_UEnv.tcenv_of_uenv e in f uu___1 in
-      match uu___ with
-      | (a1, t') ->
-          let uu___1 = FStar_Extraction_ML_UEnv.set_tcenv e t' in
-          (a1, uu___1)
-let with_dsenv_of_env :
-  'a . uenv -> 'a FStar_Syntax_DsEnv.withenv -> ('a * uenv) =
-  fun e ->
-    fun f ->
-      let uu___ =
-        let uu___1 = FStar_Extraction_ML_UEnv.tcenv_of_uenv e in
-        with_dsenv_of_tcenv uu___1 f in
-      match uu___ with
-      | (a1, tcenv) ->
-          let uu___1 = FStar_Extraction_ML_UEnv.set_tcenv e tcenv in
-          (a1, uu___1)
-let (push_env : uenv -> uenv) =
-  fun env ->
-    let uu___ =
-      with_tcenv_of_env env
-        (fun tcenv ->
-           let uu___1 =
-             let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env in
-             FStar_TypeChecker_Env.push uu___2 "top-level: push_env" in
-           ((), uu___1)) in
-    FStar_Pervasives_Native.snd uu___
-let (pop_env : uenv -> uenv) =
-  fun env ->
-    let uu___ =
-      with_tcenv_of_env env
-        (fun tcenv ->
-           let uu___1 = FStar_TypeChecker_Env.pop tcenv "top-level: pop_env" in
-           ((), uu___1)) in
-    FStar_Pervasives_Native.snd uu___
-let with_env : 'a . uenv -> (uenv -> 'a) -> 'a =
-  fun env ->
-    fun f ->
-      let env1 = push_env env in
-      let res = f env1 in let uu___ = pop_env env1 in res
-let (env_of_tcenv :
-  FStar_TypeChecker_Env.env -> FStar_Extraction_ML_UEnv.uenv) =
-  fun env -> FStar_Extraction_ML_UEnv.new_uenv env
-let (parse :
-  uenv ->
-    Prims.string FStar_Pervasives_Native.option ->
-      Prims.string -> (FStar_Syntax_Syntax.modul * uenv))
-  =
-  fun env ->
-    fun pre_fn ->
-      fun fn ->
-        let uu___ = FStar_Parser_Driver.parse_file fn in
-        match uu___ with
-        | (ast, uu___1) ->
-            let uu___2 =
-              match pre_fn with
-              | FStar_Pervasives_Native.None -> (ast, env)
-              | FStar_Pervasives_Native.Some pre_fn1 ->
-                  let uu___3 = FStar_Parser_Driver.parse_file pre_fn1 in
-                  (match uu___3 with
-                   | (pre_ast, uu___4) ->
-                       (match (pre_ast, ast) with
-                        | (FStar_Parser_AST.Interface (lid1, decls1, uu___5),
-                           FStar_Parser_AST.Module (lid2, decls2)) when
-                            FStar_Ident.lid_equals lid1 lid2 ->
-                            let uu___6 =
-                              let uu___7 =
-                                FStar_ToSyntax_Interleave.initialize_interface
-                                  lid1 decls1 in
-                              with_dsenv_of_env env uu___7 in
-                            (match uu___6 with
-                             | (uu___7, env1) ->
-                                 let uu___8 =
-                                   FStar_ToSyntax_Interleave.interleave_module
-                                     ast true in
-                                 with_dsenv_of_env env1 uu___8)
-                        | uu___5 ->
-                            FStar_Errors.raise_err
-                              (FStar_Errors.Fatal_PreModuleMismatch,
-                                "mismatch between pre-module and module\n"))) in
-            (match uu___2 with
-             | (ast1, env1) ->
-                 let uu___3 = FStar_ToSyntax_ToSyntax.ast_modul_to_modul ast1 in
-                 with_dsenv_of_env env1 uu___3)
-let (core_check : FStar_TypeChecker_Env.core_check_t) =
-  fun env ->
-    fun tm ->
-      fun t ->
-        fun must_tot ->
-          let uu___ =
-            let uu___1 = FStar_Options.compat_pre_core_should_check () in
-            Prims.op_Negation uu___1 in
-          if uu___
-          then FStar_Pervasives.Inl FStar_Pervasives_Native.None
-          else
-            (let uu___2 = FStar_TypeChecker_Core.check_term env tm t must_tot in
-             match uu___2 with
-             | FStar_Pervasives.Inl (FStar_Pervasives_Native.None) ->
-                 FStar_Pervasives.Inl FStar_Pervasives_Native.None
-             | FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g) ->
-                 let uu___3 = FStar_Options.compat_pre_core_set () in
-                 if uu___3
-                 then FStar_Pervasives.Inl FStar_Pervasives_Native.None
-                 else FStar_Pervasives.Inl (FStar_Pervasives_Native.Some g)
-             | FStar_Pervasives.Inr err ->
-                 FStar_Pervasives.Inr
-                   ((fun b ->
-                       if b
-                       then FStar_TypeChecker_Core.print_error_short err
-                       else FStar_TypeChecker_Core.print_error err)))
-let (init_env : FStar_Parser_Dep.deps -> FStar_TypeChecker_Env.env) =
-  fun deps ->
-    let solver =
-      let uu___ = FStar_Options.lax () in
-      if uu___
-      then FStar_SMTEncoding_Solver.dummy
-      else
-        {
-          FStar_TypeChecker_Env.init =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.init);
-          FStar_TypeChecker_Env.push =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.push);
-          FStar_TypeChecker_Env.pop =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.pop);
-          FStar_TypeChecker_Env.snapshot =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.snapshot);
-          FStar_TypeChecker_Env.rollback =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.rollback);
-          FStar_TypeChecker_Env.encode_sig =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.encode_sig);
-          FStar_TypeChecker_Env.preprocess = FStar_Tactics_Hooks.preprocess;
-          FStar_TypeChecker_Env.spinoff_strictly_positive_goals =
-            (FStar_Pervasives_Native.Some
-               FStar_Tactics_Hooks.spinoff_strictly_positive_goals);
-          FStar_TypeChecker_Env.handle_smt_goal =
-            FStar_Tactics_Hooks.handle_smt_goal;
-          FStar_TypeChecker_Env.solve =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.solve);
-          FStar_TypeChecker_Env.finish =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.finish);
-          FStar_TypeChecker_Env.refresh =
-            (FStar_SMTEncoding_Solver.solver.FStar_TypeChecker_Env.refresh)
-        } in
-    let env =
-      let uu___ =
-        let uu___1 = FStar_Tactics_Interpreter.primitive_steps () in
-        FStar_TypeChecker_NBE.normalize uu___1 in
-      FStar_TypeChecker_Env.initial_env deps FStar_TypeChecker_TcTerm.tc_term
-        FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term
-        FStar_TypeChecker_TcTerm.typeof_tot_or_gtot_term_fastpath
-        FStar_TypeChecker_TcTerm.universe_of
-        FStar_TypeChecker_Rel.teq_nosmt_force
-        FStar_TypeChecker_Rel.subtype_nosmt_force solver
-        FStar_Parser_Const.prims_lid uu___ core_check in
-    let env1 =
-      {
-        FStar_TypeChecker_Env.solver = (env.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (env.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (env.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (env.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (env.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (env.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (env.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (env.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (env.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (env.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (env.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (env.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (env.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (env.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (env.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (env.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (env.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface = (env.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (env.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (env.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (env.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (env.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard = (env.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (env.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (env.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (env.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (env.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (env.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (env.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (env.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (env.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (env.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (env.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (env.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns = (env.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook = FStar_Tactics_Hooks.synthesize;
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (env.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (env.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (env.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (env.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (env.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks = (env.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (env.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (env.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (env.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (env.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (env.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (env.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (env.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (env.FStar_TypeChecker_Env.core_check)
-      } in
-    let env2 =
-      {
-        FStar_TypeChecker_Env.solver = (env1.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (env1.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (env1.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (env1.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (env1.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (env1.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (env1.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (env1.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (env1.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (env1.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (env1.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (env1.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (env1.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (env1.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (env1.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (env1.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (env1.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (env1.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (env1.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (env1.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (env1.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (env1.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (env1.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (env1.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (env1.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (env1.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (env1.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (env1.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (env1.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (env1.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (env1.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (env1.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (env1.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (env1.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (env1.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (env1.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          FStar_Tactics_Hooks.solve_implicits;
-        FStar_TypeChecker_Env.splice = (env1.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (env1.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (env1.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (env1.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (env1.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (env1.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (env1.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (env1.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (env1.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (env1.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (env1.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (env1.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (env1.FStar_TypeChecker_Env.core_check)
-      } in
-    let env3 =
-      {
-        FStar_TypeChecker_Env.solver = (env2.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (env2.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (env2.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (env2.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (env2.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (env2.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (env2.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (env2.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (env2.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (env2.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (env2.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (env2.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (env2.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (env2.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (env2.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (env2.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (env2.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (env2.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (env2.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (env2.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (env2.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (env2.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (env2.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (env2.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (env2.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (env2.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (env2.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (env2.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (env2.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (env2.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (env2.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (env2.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (env2.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (env2.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (env2.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (env2.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (env2.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = FStar_Tactics_Hooks.splice;
-        FStar_TypeChecker_Env.mpreprocess =
-          (env2.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess =
-          (env2.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (env2.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (env2.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (env2.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (env2.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (env2.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (env2.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (env2.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (env2.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (env2.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (env2.FStar_TypeChecker_Env.core_check)
-      } in
-    let env4 =
-      {
-        FStar_TypeChecker_Env.solver = (env3.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (env3.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (env3.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (env3.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (env3.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (env3.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (env3.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (env3.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (env3.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (env3.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (env3.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (env3.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (env3.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (env3.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (env3.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (env3.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (env3.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (env3.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (env3.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (env3.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (env3.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (env3.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (env3.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (env3.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (env3.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (env3.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (env3.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (env3.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (env3.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (env3.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (env3.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (env3.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (env3.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (env3.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (env3.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (env3.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (env3.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (env3.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess = FStar_Tactics_Hooks.mpreprocess;
-        FStar_TypeChecker_Env.postprocess =
-          (env3.FStar_TypeChecker_Env.postprocess);
-        FStar_TypeChecker_Env.identifier_info =
-          (env3.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (env3.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (env3.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (env3.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (env3.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (env3.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (env3.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (env3.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (env3.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (env3.FStar_TypeChecker_Env.core_check)
-      } in
-    let env5 =
-      {
-        FStar_TypeChecker_Env.solver = (env4.FStar_TypeChecker_Env.solver);
-        FStar_TypeChecker_Env.range = (env4.FStar_TypeChecker_Env.range);
-        FStar_TypeChecker_Env.curmodule =
-          (env4.FStar_TypeChecker_Env.curmodule);
-        FStar_TypeChecker_Env.gamma = (env4.FStar_TypeChecker_Env.gamma);
-        FStar_TypeChecker_Env.gamma_sig =
-          (env4.FStar_TypeChecker_Env.gamma_sig);
-        FStar_TypeChecker_Env.gamma_cache =
-          (env4.FStar_TypeChecker_Env.gamma_cache);
-        FStar_TypeChecker_Env.modules = (env4.FStar_TypeChecker_Env.modules);
-        FStar_TypeChecker_Env.expected_typ =
-          (env4.FStar_TypeChecker_Env.expected_typ);
-        FStar_TypeChecker_Env.sigtab = (env4.FStar_TypeChecker_Env.sigtab);
-        FStar_TypeChecker_Env.attrtab = (env4.FStar_TypeChecker_Env.attrtab);
-        FStar_TypeChecker_Env.instantiate_imp =
-          (env4.FStar_TypeChecker_Env.instantiate_imp);
-        FStar_TypeChecker_Env.effects = (env4.FStar_TypeChecker_Env.effects);
-        FStar_TypeChecker_Env.generalize =
-          (env4.FStar_TypeChecker_Env.generalize);
-        FStar_TypeChecker_Env.letrecs = (env4.FStar_TypeChecker_Env.letrecs);
-        FStar_TypeChecker_Env.top_level =
-          (env4.FStar_TypeChecker_Env.top_level);
-        FStar_TypeChecker_Env.check_uvars =
-          (env4.FStar_TypeChecker_Env.check_uvars);
-        FStar_TypeChecker_Env.use_eq_strict =
-          (env4.FStar_TypeChecker_Env.use_eq_strict);
-        FStar_TypeChecker_Env.is_iface =
-          (env4.FStar_TypeChecker_Env.is_iface);
-        FStar_TypeChecker_Env.admit = (env4.FStar_TypeChecker_Env.admit);
-        FStar_TypeChecker_Env.lax = (env4.FStar_TypeChecker_Env.lax);
-        FStar_TypeChecker_Env.lax_universes =
-          (env4.FStar_TypeChecker_Env.lax_universes);
-        FStar_TypeChecker_Env.phase1 = (env4.FStar_TypeChecker_Env.phase1);
-        FStar_TypeChecker_Env.failhard =
-          (env4.FStar_TypeChecker_Env.failhard);
-        FStar_TypeChecker_Env.nosynth = (env4.FStar_TypeChecker_Env.nosynth);
-        FStar_TypeChecker_Env.uvar_subtyping =
-          (env4.FStar_TypeChecker_Env.uvar_subtyping);
-        FStar_TypeChecker_Env.tc_term = (env4.FStar_TypeChecker_Env.tc_term);
-        FStar_TypeChecker_Env.typeof_tot_or_gtot_term =
-          (env4.FStar_TypeChecker_Env.typeof_tot_or_gtot_term);
-        FStar_TypeChecker_Env.universe_of =
-          (env4.FStar_TypeChecker_Env.universe_of);
-        FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term =
-          (env4.FStar_TypeChecker_Env.typeof_well_typed_tot_or_gtot_term);
-        FStar_TypeChecker_Env.teq_nosmt_force =
-          (env4.FStar_TypeChecker_Env.teq_nosmt_force);
-        FStar_TypeChecker_Env.subtype_nosmt_force =
-          (env4.FStar_TypeChecker_Env.subtype_nosmt_force);
-        FStar_TypeChecker_Env.qtbl_name_and_index =
-          (env4.FStar_TypeChecker_Env.qtbl_name_and_index);
-        FStar_TypeChecker_Env.normalized_eff_names =
-          (env4.FStar_TypeChecker_Env.normalized_eff_names);
-        FStar_TypeChecker_Env.fv_delta_depths =
-          (env4.FStar_TypeChecker_Env.fv_delta_depths);
-        FStar_TypeChecker_Env.proof_ns =
-          (env4.FStar_TypeChecker_Env.proof_ns);
-        FStar_TypeChecker_Env.synth_hook =
-          (env4.FStar_TypeChecker_Env.synth_hook);
-        FStar_TypeChecker_Env.try_solve_implicits_hook =
-          (env4.FStar_TypeChecker_Env.try_solve_implicits_hook);
-        FStar_TypeChecker_Env.splice = (env4.FStar_TypeChecker_Env.splice);
-        FStar_TypeChecker_Env.mpreprocess =
-          (env4.FStar_TypeChecker_Env.mpreprocess);
-        FStar_TypeChecker_Env.postprocess = FStar_Tactics_Hooks.postprocess;
-        FStar_TypeChecker_Env.identifier_info =
-          (env4.FStar_TypeChecker_Env.identifier_info);
-        FStar_TypeChecker_Env.tc_hooks =
-          (env4.FStar_TypeChecker_Env.tc_hooks);
-        FStar_TypeChecker_Env.dsenv = (env4.FStar_TypeChecker_Env.dsenv);
-        FStar_TypeChecker_Env.nbe = (env4.FStar_TypeChecker_Env.nbe);
-        FStar_TypeChecker_Env.strict_args_tab =
-          (env4.FStar_TypeChecker_Env.strict_args_tab);
-        FStar_TypeChecker_Env.erasable_types_tab =
-          (env4.FStar_TypeChecker_Env.erasable_types_tab);
-        FStar_TypeChecker_Env.enable_defer_to_tac =
-          (env4.FStar_TypeChecker_Env.enable_defer_to_tac);
-        FStar_TypeChecker_Env.unif_allow_ref_guards =
-          (env4.FStar_TypeChecker_Env.unif_allow_ref_guards);
-        FStar_TypeChecker_Env.erase_erasable_args =
-          (env4.FStar_TypeChecker_Env.erase_erasable_args);
-        FStar_TypeChecker_Env.core_check =
-          (env4.FStar_TypeChecker_Env.core_check)
-      } in
-    (env5.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.init env5; env5
-let (tc_one_fragment :
-  FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option ->
-    FStar_TypeChecker_Env.env_t ->
-      FStar_Parser_ParseIt.input_frag ->
-        (FStar_Syntax_Syntax.modul FStar_Pervasives_Native.option *
-          FStar_TypeChecker_Env.env))
-  =
-  fun curmod ->
-    fun env ->
-      fun frag ->
-        let fname env1 =
-          let uu___ = FStar_Options.lsp_server () in
-          if uu___
-          then
-            let uu___1 = FStar_TypeChecker_Env.get_range env1 in
-            FStar_Compiler_Range.file_of_range uu___1
-          else
-            (let uu___2 = FStar_Options.file_list () in
-             FStar_Compiler_List.hd uu___2) in
-        let acceptable_mod_name modul =
-          let uu___ =
-            let uu___1 = fname env in
-            FStar_Parser_Dep.lowercase_module_name uu___1 in
-          let uu___1 =
-            let uu___2 =
-              FStar_Ident.string_of_lid modul.FStar_Syntax_Syntax.name in
-            FStar_String.lowercase uu___2 in
-          uu___ = uu___1 in
-        let range_of_first_mod_decl modul =
-          match modul with
-          | FStar_Parser_AST.Module
-              (uu___,
-               { FStar_Parser_AST.d = uu___1; FStar_Parser_AST.drange = d;
-                 FStar_Parser_AST.quals = uu___2;
-                 FStar_Parser_AST.attrs = uu___3;_}::uu___4)
-              -> d
-          | FStar_Parser_AST.Interface
-              (uu___,
-               { FStar_Parser_AST.d = uu___1; FStar_Parser_AST.drange = d;
-                 FStar_Parser_AST.quals = uu___2;
-                 FStar_Parser_AST.attrs = uu___3;_}::uu___4,
-               uu___5)
-              -> d
-          | uu___ -> FStar_Compiler_Range.dummyRange in
-        let uu___ = FStar_Parser_Driver.parse_fragment frag in
-        match uu___ with
-        | FStar_Parser_Driver.Empty -> (curmod, env)
-        | FStar_Parser_Driver.Decls [] -> (curmod, env)
-        | FStar_Parser_Driver.Modul ast_modul ->
-            let uu___1 =
-              let uu___2 =
-                FStar_ToSyntax_Interleave.interleave_module ast_modul false in
-              FStar_Compiler_Effect.op_Less_Bar (with_dsenv_of_tcenv env)
-                uu___2 in
-            (match uu___1 with
-             | (ast_modul1, env1) ->
-                 let uu___2 =
-                   let uu___3 =
-                     FStar_ToSyntax_ToSyntax.partial_ast_modul_to_modul
-                       curmod ast_modul1 in
-                   FStar_Compiler_Effect.op_Less_Bar
-                     (with_dsenv_of_tcenv env1) uu___3 in
-                 (match uu___2 with
-                  | (modul, env2) ->
-                      ((let uu___4 =
-                          let uu___5 = acceptable_mod_name modul in
-                          Prims.op_Negation uu___5 in
-                        if uu___4
-                        then
-                          let msg =
-                            let uu___5 =
-                              let uu___6 = fname env2 in
-                              FStar_Parser_Dep.module_name_of_file uu___6 in
-                            FStar_Compiler_Util.format1
-                              "Interactive mode only supports a single module at the top-level. Expected module %s"
-                              uu___5 in
-                          FStar_Errors.raise_error
-                            (FStar_Errors.Fatal_NonSingletonTopLevelModule,
-                              msg) (range_of_first_mod_decl ast_modul1)
-                        else ());
-                       (let uu___4 =
-                          let uu___5 =
-                            FStar_Syntax_DsEnv.syntax_only
-                              env2.FStar_TypeChecker_Env.dsenv in
-                          if uu___5
-                          then (modul, env2)
-                          else
-                            FStar_TypeChecker_Tc.tc_partial_modul env2 modul in
-                        match uu___4 with
-                        | (modul1, env3) ->
-                            ((FStar_Pervasives_Native.Some modul1), env3)))))
-        | FStar_Parser_Driver.Decls ast_decls ->
-            (match curmod with
-             | FStar_Pervasives_Native.None ->
-                 let uu___1 = FStar_Compiler_List.hd ast_decls in
-                 (match uu___1 with
-                  | { FStar_Parser_AST.d = uu___2;
-                      FStar_Parser_AST.drange = rng;
-                      FStar_Parser_AST.quals = uu___3;
-                      FStar_Parser_AST.attrs = uu___4;_} ->
-                      FStar_Errors.raise_error
-                        (FStar_Errors.Fatal_ModuleFirstStatement,
-                          "First statement must be a module declaration") rng)
-             | FStar_Pervasives_Native.Some modul ->
-                 let uu___1 =
-                   FStar_Compiler_Util.fold_map
-                     (fun env1 ->
-                        fun a_decl ->
-                          let uu___2 =
-                            let uu___3 =
-                              FStar_ToSyntax_Interleave.prefix_with_interface_decls
-                                modul.FStar_Syntax_Syntax.name a_decl in
-                            FStar_Compiler_Effect.op_Less_Bar
-                              (with_dsenv_of_tcenv env1) uu___3 in
-                          match uu___2 with | (decls, env2) -> (env2, decls))
-                     env ast_decls in
-                 (match uu___1 with
-                  | (env1, ast_decls_l) ->
-                      let uu___2 =
-                        let uu___3 =
-                          FStar_ToSyntax_ToSyntax.decls_to_sigelts
-                            (FStar_Compiler_List.flatten ast_decls_l) in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (with_dsenv_of_tcenv env1) uu___3 in
-                      (match uu___2 with
-                       | (sigelts, env2) ->
-                           let uu___3 =
-                             let uu___4 =
-                               FStar_Syntax_DsEnv.syntax_only
-                                 env2.FStar_TypeChecker_Env.dsenv in
-                             if uu___4
-                             then (modul, [], env2)
-                             else
-                               FStar_TypeChecker_Tc.tc_more_partial_modul
-                                 env2 modul sigelts in
-                           (match uu___3 with
-                            | (modul1, uu___4, env3) ->
-                                ((FStar_Pervasives_Native.Some modul1), env3)))))
-let (load_interface_decls :
-  FStar_TypeChecker_Env.env -> Prims.string -> FStar_TypeChecker_Env.env_t) =
-  fun env ->
-    fun interface_file_name ->
-      let r =
-        FStar_Parser_ParseIt.parse
-          (FStar_Parser_ParseIt.Filename interface_file_name) in
-      match r with
-      | FStar_Parser_ParseIt.ASTFragment
-          (FStar_Pervasives.Inl (FStar_Parser_AST.Interface
-           (l, decls, uu___)), uu___1)
-          ->
-          let uu___2 =
-            let uu___3 =
-              FStar_ToSyntax_Interleave.initialize_interface l decls in
-            FStar_Compiler_Effect.op_Less_Bar (with_dsenv_of_tcenv env)
-              uu___3 in
-          FStar_Pervasives_Native.snd uu___2
-      | FStar_Parser_ParseIt.ASTFragment uu___ ->
-          let uu___1 =
-            let uu___2 =
-              FStar_Compiler_Util.format1
-                "Unexpected result from parsing %s; expected a single interface"
-                interface_file_name in
-            (FStar_Errors.Fatal_ParseErrors, uu___2) in
-          FStar_Errors.raise_err uu___1
-      | FStar_Parser_ParseIt.ParseError (err, msg, rng) ->
-          FStar_Compiler_Effect.raise
-            (FStar_Errors.Error (err, msg, rng, []))
-      | FStar_Parser_ParseIt.Term uu___ ->
-          failwith
-            "Impossible: parsing a Toplevel always results in an ASTFragment"
-let (emit : FStar_Extraction_ML_Syntax.mllib Prims.list -> unit) =
-  fun mllibs ->
-    let opt = FStar_Options.codegen () in
-    if opt <> FStar_Pervasives_Native.None
-    then
-      let ext =
-        match opt with
-        | FStar_Pervasives_Native.Some (FStar_Options.FSharp) -> ".fs"
-        | FStar_Pervasives_Native.Some (FStar_Options.OCaml) -> ".ml"
-        | FStar_Pervasives_Native.Some (FStar_Options.Plugin) -> ".ml"
-        | FStar_Pervasives_Native.Some (FStar_Options.Krml) -> ".krml"
-        | uu___ -> failwith "Unrecognized option" in
-      match opt with
-      | FStar_Pervasives_Native.Some (FStar_Options.FSharp) ->
-          let outdir = FStar_Options.output_dir () in
-          FStar_Compiler_List.iter
-            (FStar_Extraction_ML_PrintML.print outdir ext) mllibs
-      | FStar_Pervasives_Native.Some (FStar_Options.OCaml) ->
-          let outdir = FStar_Options.output_dir () in
-          FStar_Compiler_List.iter
-            (FStar_Extraction_ML_PrintML.print outdir ext) mllibs
-      | FStar_Pervasives_Native.Some (FStar_Options.Plugin) ->
-          let outdir = FStar_Options.output_dir () in
-          FStar_Compiler_List.iter
-            (FStar_Extraction_ML_PrintML.print outdir ext) mllibs
-      | FStar_Pervasives_Native.Some (FStar_Options.Krml) ->
-          let programs =
-            FStar_Compiler_List.collect FStar_Extraction_Krml.translate
-              mllibs in
-          let bin = (FStar_Extraction_Krml.current_version, programs) in
-          (match programs with
-           | (name, uu___)::[] ->
-               let uu___1 =
-                 FStar_Options.prepend_output_dir (Prims.op_Hat name ext) in
-               FStar_Compiler_Util.save_value_to_file uu___1 bin
-           | uu___ ->
-               let uu___1 = FStar_Options.prepend_output_dir "out.krml" in
-               FStar_Compiler_Util.save_value_to_file uu___1 bin)
-      | uu___ -> failwith "Unrecognized option"
-    else ()
-let (tc_one_file :
-  uenv ->
-    Prims.string FStar_Pervasives_Native.option ->
-      Prims.string ->
-        FStar_Parser_Dep.parsing_data ->
-          (FStar_CheckedFiles.tc_result * FStar_Extraction_ML_Syntax.mllib
-            FStar_Pervasives_Native.option * uenv))
-  =
-  fun env ->
-    fun pre_fn ->
-      fun fn ->
-        fun parsing_data ->
-          FStar_Ident.reset_gensym ();
-          (let maybe_restore_opts uu___1 =
-             let uu___2 =
-               let uu___3 = FStar_Options.interactive () in
-               Prims.op_Negation uu___3 in
-             if uu___2
-             then
-               let uu___3 = FStar_Options.restore_cmd_line_options true in
-               FStar_Compiler_Effect.op_Bar_Greater uu___3 (fun uu___4 -> ())
-             else () in
-           let maybe_extract_mldefs tcmod env1 =
-             let uu___1 = FStar_Options.codegen () in
-             match uu___1 with
-             | FStar_Pervasives_Native.None ->
-                 (FStar_Pervasives_Native.None, Prims.int_zero)
-             | FStar_Pervasives_Native.Some tgt ->
-                 let uu___2 =
-                   let uu___3 =
-                     let uu___4 =
-                       FStar_Ident.string_of_lid
-                         tcmod.FStar_Syntax_Syntax.name in
-                     FStar_Options.should_extract uu___4 tgt in
-                   Prims.op_Negation uu___3 in
-                 if uu___2
-                 then (FStar_Pervasives_Native.None, Prims.int_zero)
-                 else
-                   FStar_Compiler_Util.record_time
-                     (fun uu___4 ->
-                        with_env env1
-                          (fun env2 ->
-                             let uu___5 =
-                               FStar_Extraction_ML_Modul.extract env2 tcmod in
-                             match uu___5 with | (uu___6, defs) -> defs)) in
-           let maybe_extract_ml_iface tcmod env1 =
-             let uu___1 =
-               let uu___2 = FStar_Options.codegen () in
-               uu___2 = FStar_Pervasives_Native.None in
-             if uu___1
-             then (env1, Prims.int_zero)
-             else
-               FStar_Compiler_Util.record_time
-                 (fun uu___3 ->
-                    let uu___4 =
-                      with_env env1
-                        (fun env2 ->
-                           FStar_Extraction_ML_Modul.extract_iface env2 tcmod) in
-                    match uu___4 with | (env2, uu___5) -> env2) in
-           let tc_source_file uu___1 =
-             let uu___2 = parse env pre_fn fn in
-             match uu___2 with
-             | (fmod, env1) ->
-                 let mii =
-                   let uu___3 =
-                     let uu___4 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env1 in
-                     uu___4.FStar_TypeChecker_Env.dsenv in
-                   FStar_Syntax_DsEnv.inclusion_info uu___3
-                     fmod.FStar_Syntax_Syntax.name in
-                 let check_mod uu___3 =
-                   let check env2 =
-                     (let uu___5 =
-                        let uu___6 = FStar_Options.lax () in
-                        Prims.op_Negation uu___6 in
-                      if uu___5 then FStar_SMTEncoding_Z3.refresh () else ());
-                     with_tcenv_of_env env2
-                       (fun tcenv ->
-                          (match tcenv.FStar_TypeChecker_Env.gamma with
-                           | [] -> ()
-                           | uu___6 ->
-                               failwith
-                                 "Impossible: gamma contains leaked names");
-                          (let uu___6 =
-                             FStar_TypeChecker_Tc.check_module tcenv fmod
-                               (FStar_Compiler_Util.is_some pre_fn) in
-                           match uu___6 with
-                           | (modul, env3) ->
-                               (maybe_restore_opts ();
-                                (let smt_decls =
-                                   let uu___8 =
-                                     let uu___9 = FStar_Options.lax () in
-                                     Prims.op_Negation uu___9 in
-                                   if uu___8
-                                   then
-                                     FStar_SMTEncoding_Encode.encode_modul
-                                       env3 modul
-                                   else ([], []) in
-                                 ((modul, smt_decls), env3))))) in
-                   let uu___4 =
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Ident.string_of_lid
-                           fmod.FStar_Syntax_Syntax.name in
-                       FStar_Pervasives_Native.Some uu___6 in
-                     FStar_Profiling.profile (fun uu___6 -> check env1)
-                       uu___5 "FStar.Universal.tc_source_file" in
-                   match uu___4 with
-                   | ((tcmod, smt_decls), env2) ->
-                       let tc_time = Prims.int_zero in
-                       let uu___5 = maybe_extract_mldefs tcmod env2 in
-                       (match uu___5 with
-                        | (extracted_defs, extract_time) ->
-                            let uu___6 = maybe_extract_ml_iface tcmod env2 in
-                            (match uu___6 with
-                             | (env3, iface_extraction_time) ->
-                                 ({
-                                    FStar_CheckedFiles.checked_module = tcmod;
-                                    FStar_CheckedFiles.mii = mii;
-                                    FStar_CheckedFiles.smt_decls = smt_decls;
-                                    FStar_CheckedFiles.tc_time = tc_time;
-                                    FStar_CheckedFiles.extraction_time =
-                                      (extract_time + iface_extraction_time)
-                                  }, extracted_defs, env3))) in
-                 let uu___3 =
-                   (let uu___4 =
-                      FStar_Ident.string_of_lid fmod.FStar_Syntax_Syntax.name in
-                    FStar_Options.should_verify uu___4) &&
-                     ((FStar_Options.record_hints ()) ||
-                        (FStar_Options.use_hints ())) in
-                 if uu___3
-                 then
-                   let uu___4 = FStar_Parser_ParseIt.find_file fn in
-                   FStar_SMTEncoding_Solver.with_hints_db uu___4 check_mod
-                 else check_mod () in
-           let uu___1 =
-             let uu___2 = FStar_Options.cache_off () in
-             Prims.op_Negation uu___2 in
-           if uu___1
-           then
-             let r = FStar_CheckedFiles.load_module_from_cache env fn in
-             let r1 =
-               let uu___2 =
-                 (FStar_Options.force ()) &&
-                   (FStar_Options.should_check_file fn) in
-               if uu___2 then FStar_Pervasives_Native.None else r in
-             match r1 with
-             | FStar_Pervasives_Native.None ->
-                 ((let uu___3 =
-                     let uu___4 = FStar_Parser_Dep.module_name_of_file fn in
-                     FStar_Options.should_be_already_cached uu___4 in
-                   if uu___3
-                   then
-                     let uu___4 =
-                       let uu___5 =
-                         FStar_Compiler_Util.format1
-                           "Expected %s to already be checked" fn in
-                       (FStar_Errors.Error_AlreadyCachedAssertionFailure,
-                         uu___5) in
-                     FStar_Errors.raise_err uu___4
-                   else ());
-                  (let uu___4 =
-                     (let uu___5 = FStar_Options.codegen () in
-                      FStar_Compiler_Option.isSome uu___5) &&
-                       (FStar_Options.cmi ()) in
-                   if uu___4
-                   then
-                     let uu___5 =
-                       let uu___6 =
-                         FStar_Compiler_Util.format1
-                           "Cross-module inlining expects all modules to be checked first; %s was not checked"
-                           fn in
-                       (FStar_Errors.Error_AlreadyCachedAssertionFailure,
-                         uu___6) in
-                     FStar_Errors.raise_err uu___5
-                   else ());
-                  (let uu___4 = tc_source_file () in
-                   match uu___4 with
-                   | (tc_result, mllib, env1) ->
-                       ((let uu___6 =
-                           (let uu___7 = FStar_Errors.get_err_count () in
-                            uu___7 = Prims.int_zero) &&
-                             ((FStar_Options.lax ()) ||
-                                (let uu___7 =
-                                   FStar_Ident.string_of_lid
-                                     (tc_result.FStar_CheckedFiles.checked_module).FStar_Syntax_Syntax.name in
-                                 FStar_Options.should_verify uu___7)) in
-                         if uu___6
-                         then
-                           FStar_CheckedFiles.store_module_to_cache env1 fn
-                             parsing_data tc_result
-                         else ());
-                        (tc_result, mllib, env1))))
-             | FStar_Pervasives_Native.Some tc_result ->
-                 let tcmod = tc_result.FStar_CheckedFiles.checked_module in
-                 let smt_decls = tc_result.FStar_CheckedFiles.smt_decls in
-                 ((let uu___3 =
-                     let uu___4 =
-                       FStar_Ident.string_of_lid
-                         tcmod.FStar_Syntax_Syntax.name in
-                     FStar_Options.dump_module uu___4 in
-                   if uu___3
-                   then
-                     let uu___4 = FStar_Syntax_Print.modul_to_string tcmod in
-                     FStar_Compiler_Util.print1
-                       "Module after type checking:\n%s\n" uu___4
-                   else ());
-                  (let extend_tcenv tcmod1 tcenv =
-                     (let uu___4 =
-                        let uu___5 = FStar_Options.lax () in
-                        Prims.op_Negation uu___5 in
-                      if uu___4 then FStar_SMTEncoding_Z3.refresh () else ());
-                     (let uu___4 =
-                        let uu___5 =
-                          FStar_ToSyntax_ToSyntax.add_modul_to_env tcmod1
-                            tc_result.FStar_CheckedFiles.mii
-                            (FStar_TypeChecker_Normalize.erase_universes
-                               tcenv) in
-                        FStar_Compiler_Effect.op_Less_Bar
-                          (with_dsenv_of_tcenv tcenv) uu___5 in
-                      match uu___4 with
-                      | (uu___5, tcenv1) ->
-                          let env1 =
-                            FStar_TypeChecker_Tc.load_checked_module tcenv1
-                              tcmod1 in
-                          (maybe_restore_opts ();
-                           (let uu___8 =
-                              let uu___9 = FStar_Options.lax () in
-                              Prims.op_Negation uu___9 in
-                            if uu___8
-                            then
-                              FStar_SMTEncoding_Encode.encode_modul_from_cache
-                                env1 tcmod1 smt_decls
-                            else ());
-                           ((), env1))) in
-                   let env1 =
-                     FStar_Profiling.profile
-                       (fun uu___3 ->
-                          let uu___4 =
-                            with_tcenv_of_env env (extend_tcenv tcmod) in
-                          FStar_Compiler_Effect.op_Bar_Greater uu___4
-                            FStar_Pervasives_Native.snd)
-                       FStar_Pervasives_Native.None
-                       "FStar.Universal.extend_tcenv" in
-                   let mllib =
-                     let uu___3 = FStar_Options.codegen () in
-                     match uu___3 with
-                     | FStar_Pervasives_Native.None ->
-                         FStar_Pervasives_Native.None
-                     | FStar_Pervasives_Native.Some tgt ->
-                         let uu___4 =
-                           (let uu___5 =
-                              FStar_Ident.string_of_lid
-                                tcmod.FStar_Syntax_Syntax.name in
-                            FStar_Options.should_extract uu___5 tgt) &&
-                             ((Prims.op_Negation
-                                 tcmod.FStar_Syntax_Syntax.is_interface)
-                                || (tgt = FStar_Options.Krml)) in
-                         if uu___4
-                         then
-                           let uu___5 = maybe_extract_mldefs tcmod env1 in
-                           (match uu___5 with
-                            | (extracted_defs, _extraction_time) ->
-                                extracted_defs)
-                         else FStar_Pervasives_Native.None in
-                   let uu___3 = maybe_extract_ml_iface tcmod env1 in
-                   match uu___3 with
-                   | (env2, _time) -> (tc_result, mllib, env2)))
-           else
-             (let uu___3 = tc_source_file () in
-              match uu___3 with
-              | (tc_result, mllib, env1) -> (tc_result, mllib, env1)))
-let (tc_one_file_for_ide :
-  FStar_TypeChecker_Env.env_t ->
-    Prims.string FStar_Pervasives_Native.option ->
-      Prims.string ->
-        FStar_Parser_Dep.parsing_data ->
-          (FStar_CheckedFiles.tc_result * FStar_TypeChecker_Env.env_t))
-  =
-  fun env ->
-    fun pre_fn ->
-      fun fn ->
-        fun parsing_data ->
-          let env1 = env_of_tcenv env in
-          let uu___ = tc_one_file env1 pre_fn fn parsing_data in
-          match uu___ with
-          | (tc_result, uu___1, env2) ->
-              let uu___2 = FStar_Extraction_ML_UEnv.tcenv_of_uenv env2 in
-              (tc_result, uu___2)
-let (needs_interleaving : Prims.string -> Prims.string -> Prims.bool) =
-  fun intf ->
-    fun impl ->
-      let m1 = FStar_Parser_Dep.lowercase_module_name intf in
-      let m2 = FStar_Parser_Dep.lowercase_module_name impl in
-      ((m1 = m2) &&
-         (let uu___ = FStar_Compiler_Util.get_file_extension intf in
-          FStar_Compiler_List.mem uu___ ["fsti"; "fsi"]))
-        &&
-        (let uu___ = FStar_Compiler_Util.get_file_extension impl in
-         FStar_Compiler_List.mem uu___ ["fst"; "fs"])
-let (tc_one_file_from_remaining :
-  Prims.string Prims.list ->
-    uenv ->
-      FStar_Parser_Dep.deps ->
-        (Prims.string Prims.list * FStar_CheckedFiles.tc_result *
-          FStar_Extraction_ML_Syntax.mllib FStar_Pervasives_Native.option *
-          uenv))
-  =
-  fun remaining ->
-    fun env ->
-      fun deps ->
-        let uu___ =
-          match remaining with
-          | intf::impl::remaining1 when needs_interleaving intf impl ->
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater impl
-                    (FStar_Parser_Dep.parsing_data_of deps) in
-                tc_one_file env (FStar_Pervasives_Native.Some intf) impl
-                  uu___2 in
-              (match uu___1 with
-               | (m, mllib, env1) -> (remaining1, (m, mllib, env1)))
-          | intf_or_impl::remaining1 ->
-              let uu___1 =
-                let uu___2 =
-                  FStar_Compiler_Effect.op_Bar_Greater intf_or_impl
-                    (FStar_Parser_Dep.parsing_data_of deps) in
-                tc_one_file env FStar_Pervasives_Native.None intf_or_impl
-                  uu___2 in
-              (match uu___1 with
-               | (m, mllib, env1) -> (remaining1, (m, mllib, env1)))
-          | [] -> failwith "Impossible: Empty remaining modules" in
-        match uu___ with
-        | (remaining1, (nmods, mllib, env1)) ->
-            (remaining1, nmods, mllib, env1)
-let rec (tc_fold_interleave :
-  FStar_Parser_Dep.deps ->
-    (FStar_CheckedFiles.tc_result Prims.list *
-      FStar_Extraction_ML_Syntax.mllib Prims.list * uenv) ->
-      Prims.string Prims.list ->
-        (FStar_CheckedFiles.tc_result Prims.list *
-          FStar_Extraction_ML_Syntax.mllib Prims.list * uenv))
-  =
-  fun deps ->
-    fun acc ->
-      fun remaining ->
-        let as_list uu___ =
-          match uu___ with
-          | FStar_Pervasives_Native.None -> []
-          | FStar_Pervasives_Native.Some l -> [l] in
-        match remaining with
-        | [] -> acc
-        | uu___ ->
-            let uu___1 = acc in
-            (match uu___1 with
-             | (mods, mllibs, env) ->
-                 let uu___2 = tc_one_file_from_remaining remaining env deps in
-                 (match uu___2 with
-                  | (remaining1, nmod, mllib, env1) ->
-                      ((let uu___4 =
-                          let uu___5 =
-                            FStar_Options.profile_group_by_decls () in
-                          Prims.op_Negation uu___5 in
-                        if uu___4
-                        then
-                          let uu___5 =
-                            FStar_Ident.string_of_lid
-                              (nmod.FStar_CheckedFiles.checked_module).FStar_Syntax_Syntax.name in
-                          FStar_Profiling.report_and_clear uu___5
-                        else ());
-                       tc_fold_interleave deps
-                         ((FStar_Compiler_List.op_At mods [nmod]),
-                           (FStar_Compiler_List.op_At mllibs (as_list mllib)),
-                           env1) remaining1)))
-let (batch_mode_tc :
-  Prims.string Prims.list ->
-    FStar_Parser_Dep.deps ->
-      (FStar_CheckedFiles.tc_result Prims.list * uenv * (uenv -> uenv)))
-  =
-  fun filenames ->
-    fun dep_graph ->
-      (let uu___1 =
-         FStar_Options.debug_at_level_no_module (FStar_Options.Other "Dep") in
-       if uu___1
-       then
-         (FStar_Compiler_Util.print_endline
-            "Auto-deps kicked in; here's some info.";
-          FStar_Compiler_Util.print1
-            "Here's the list of filenames we will process: %s\n"
-            (FStar_String.concat " " filenames);
-          (let uu___4 =
-             let uu___5 =
-               FStar_Compiler_Effect.op_Bar_Greater filenames
-                 (FStar_Compiler_List.filter FStar_Options.should_verify_file) in
-             FStar_String.concat " " uu___5 in
-           FStar_Compiler_Util.print1
-             "Here's the list of modules we will verify: %s\n" uu___4))
-       else ());
-      (let env =
-         let uu___1 = init_env dep_graph in
-         FStar_Extraction_ML_UEnv.new_uenv uu___1 in
-       let uu___1 = tc_fold_interleave dep_graph ([], [], env) filenames in
-       match uu___1 with
-       | (all_mods, mllibs, env1) ->
-           ((let uu___3 =
-               let uu___4 = FStar_Errors.get_err_count () in
-               uu___4 = Prims.int_zero in
-             if uu___3 then emit mllibs else ());
-            (let solver_refresh env2 =
-               let uu___3 =
-                 with_tcenv_of_env env2
-                   (fun tcenv ->
-                      (let uu___5 =
-                         (FStar_Options.interactive ()) &&
-                           (let uu___6 = FStar_Errors.get_err_count () in
-                            uu___6 = Prims.int_zero) in
-                       if uu___5
-                       then
-                         (tcenv.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.refresh
-                           ()
-                       else
-                         (tcenv.FStar_TypeChecker_Env.solver).FStar_TypeChecker_Env.finish
-                           ());
-                      ((), tcenv)) in
-               FStar_Compiler_Effect.op_Less_Bar FStar_Pervasives_Native.snd
-                 uu___3 in
-             (all_mods, env1, solver_refresh))))
\ No newline at end of file
diff --git a/src/ocaml-output/FStar_VConfig.ml b/src/ocaml-output/FStar_VConfig.ml
deleted file mode 100644
index cd98b92f00f..00000000000
--- a/src/ocaml-output/FStar_VConfig.ml
+++ /dev/null
@@ -1,348 +0,0 @@
-open Prims
-type vconfig =
-  {
-  initial_fuel: Prims.int ;
-  max_fuel: Prims.int ;
-  initial_ifuel: Prims.int ;
-  max_ifuel: Prims.int ;
-  detail_errors: Prims.bool ;
-  detail_hint_replay: Prims.bool ;
-  no_smt: Prims.bool ;
-  quake_lo: Prims.int ;
-  quake_hi: Prims.int ;
-  quake_keep: Prims.bool ;
-  retry: Prims.bool ;
-  smtencoding_elim_box: Prims.bool ;
-  smtencoding_nl_arith_repr: Prims.string ;
-  smtencoding_l_arith_repr: Prims.string ;
-  smtencoding_valid_intro: Prims.bool ;
-  smtencoding_valid_elim: Prims.bool ;
-  tcnorm: Prims.bool ;
-  no_plugins: Prims.bool ;
-  no_tactics: Prims.bool ;
-  vcgen_optimize_bind_as_seq: Prims.string FStar_Pervasives_Native.option ;
-  z3cliopt: Prims.string Prims.list ;
-  z3smtopt: Prims.string Prims.list ;
-  z3refresh: Prims.bool ;
-  z3rlimit: Prims.int ;
-  z3rlimit_factor: Prims.int ;
-  z3seed: Prims.int ;
-  trivial_pre_for_unannotated_effectful_fns: Prims.bool ;
-  reuse_hint_for: Prims.string FStar_Pervasives_Native.option }
-let (__proj__Mkvconfig__item__initial_fuel : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> initial_fuel
-let (__proj__Mkvconfig__item__max_fuel : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> max_fuel
-let (__proj__Mkvconfig__item__initial_ifuel : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> initial_ifuel
-let (__proj__Mkvconfig__item__max_ifuel : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> max_ifuel
-let (__proj__Mkvconfig__item__detail_errors : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> detail_errors
-let (__proj__Mkvconfig__item__detail_hint_replay : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> detail_hint_replay
-let (__proj__Mkvconfig__item__no_smt : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> no_smt
-let (__proj__Mkvconfig__item__quake_lo : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> quake_lo
-let (__proj__Mkvconfig__item__quake_hi : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> quake_hi
-let (__proj__Mkvconfig__item__quake_keep : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> quake_keep
-let (__proj__Mkvconfig__item__retry : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> retry
-let (__proj__Mkvconfig__item__smtencoding_elim_box : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> smtencoding_elim_box
-let (__proj__Mkvconfig__item__smtencoding_nl_arith_repr :
-  vconfig -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> smtencoding_nl_arith_repr
-let (__proj__Mkvconfig__item__smtencoding_l_arith_repr :
-  vconfig -> Prims.string) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> smtencoding_l_arith_repr
-let (__proj__Mkvconfig__item__smtencoding_valid_intro :
-  vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> smtencoding_valid_intro
-let (__proj__Mkvconfig__item__smtencoding_valid_elim : vconfig -> Prims.bool)
-  =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> smtencoding_valid_elim
-let (__proj__Mkvconfig__item__tcnorm : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> tcnorm
-let (__proj__Mkvconfig__item__no_plugins : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> no_plugins
-let (__proj__Mkvconfig__item__no_tactics : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> no_tactics
-let (__proj__Mkvconfig__item__vcgen_optimize_bind_as_seq :
-  vconfig -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> vcgen_optimize_bind_as_seq
-let (__proj__Mkvconfig__item__z3cliopt : vconfig -> Prims.string Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> z3cliopt
-let (__proj__Mkvconfig__item__z3smtopt : vconfig -> Prims.string Prims.list)
-  =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> z3smtopt
-let (__proj__Mkvconfig__item__z3refresh : vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> z3refresh
-let (__proj__Mkvconfig__item__z3rlimit : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> z3rlimit
-let (__proj__Mkvconfig__item__z3rlimit_factor : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> z3rlimit_factor
-let (__proj__Mkvconfig__item__z3seed : vconfig -> Prims.int) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> z3seed
-let (__proj__Mkvconfig__item__trivial_pre_for_unannotated_effectful_fns :
-  vconfig -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> trivial_pre_for_unannotated_effectful_fns
-let (__proj__Mkvconfig__item__reuse_hint_for :
-  vconfig -> Prims.string FStar_Pervasives_Native.option) =
-  fun projectee ->
-    match projectee with
-    | { initial_fuel; max_fuel; initial_ifuel; max_ifuel; detail_errors;
-        detail_hint_replay; no_smt; quake_lo; quake_hi; quake_keep; retry;
-        smtencoding_elim_box; smtencoding_nl_arith_repr;
-        smtencoding_l_arith_repr; smtencoding_valid_intro;
-        smtencoding_valid_elim; tcnorm; no_plugins; no_tactics;
-        vcgen_optimize_bind_as_seq; z3cliopt; z3smtopt; z3refresh; z3rlimit;
-        z3rlimit_factor; z3seed; trivial_pre_for_unannotated_effectful_fns;
-        reuse_hint_for;_} -> reuse_hint_for
\ No newline at end of file

From 330ef4616ef40bc66d3706c1d189da0d347e9c1b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 24 Feb 2023 19:21:29 -0800
Subject: [PATCH 393/513] do not use `trivial`, which normalizes too much and
 blows up

---
 ulib/experimental/Steel.ST.GenElim.Base.fsti | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.ST.GenElim.Base.fsti b/ulib/experimental/Steel.ST.GenElim.Base.fsti
index bc5d80a8296..afc9b560438 100644
--- a/ulib/experimental/Steel.ST.GenElim.Base.fsti
+++ b/ulib/experimental/Steel.ST.GenElim.Base.fsti
@@ -619,6 +619,12 @@ let solve_gen_elim_nondep (enable_nondep_opt: bool) (t: T.term) : T.Tac T.term =
           p', T.Q_Explicit;
         ]
 
+let trefl_or_smt () : T.Tac unit =
+  let ty = T.cur_goal () in
+  match T.term_as_formula ty with
+  | T.Comp _ _ _ -> T.trefl ()
+  | _ -> T.smt (); T.qed ()
+
 let solve_gen_elim_prop
   ()
 : T.Tac unit
@@ -655,7 +661,7 @@ let solve_gen_elim_prop
         T.focus (fun _ -> norm (); T.trefl ()) // tprop
       end;
       T.focus (fun _ -> norm (); T.trefl ()); // p
-      T.focus (fun _ -> norm (); T.trivial (); T.qed ()); // j
+      T.focus (fun _ -> norm (); trefl_or_smt ()); // j
       T.focus (fun _ -> norm (); T.trefl ()); // a
       T.focus (fun _ -> norm (); T.trefl ()); // q
       T.focus (fun _ -> norm (); T.trefl ()) // post

From 99f2d51448d02c02d57002bf6fb4ebdc26f1719c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Sun, 26 Feb 2023 16:32:58 -0800
Subject: [PATCH 394/513] snap

---
 .../generated/Steel_ST_GenElim_Base.ml        | 534 +++++++++---------
 1 file changed, 275 insertions(+), 259 deletions(-)

diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index f50533bf38f..d68e5880c75 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -2009,20 +2009,60 @@ let (solve_gen_elim_nondep :
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
+let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
+  fun uu___ ->
+    FStar_Tactics_Effect.tac_bind
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
+         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
+         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
+      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
+      (fun uu___1 ->
+         (fun ty ->
+            Obj.magic
+              (FStar_Tactics_Effect.tac_bind
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (8))
+                    (Prims.of_int (624)) (Prims.of_int (28)))
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (2))
+                    (Prims.of_int (626)) (Prims.of_int (27)))
+                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
+                 (fun uu___1 ->
+                    (fun uu___1 ->
+                       match uu___1 with
+                       | FStar_Reflection_Formula.Comp
+                           (uu___2, uu___3, uu___4) ->
+                           Obj.magic (FStar_Tactics_Derived.trefl ())
+                       | uu___2 ->
+                           Obj.magic
+                             (FStar_Tactics_Effect.tac_bind
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (9))
+                                   (Prims.of_int (626)) (Prims.of_int (17)))
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (19))
+                                   (Prims.of_int (626)) (Prims.of_int (27)))
+                                (Obj.magic (FStar_Tactics_Derived.smt ()))
+                                (fun uu___3 ->
+                                   (fun uu___3 ->
+                                      Obj.magic
+                                        (FStar_Tactics_Derived.qed ()))
+                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-         (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-         (Prims.of_int (2)) (Prims.of_int (664)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-               (Prims.of_int (31)) (Prims.of_int (626)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-               (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2034,27 +2074,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (627)) (Prims.of_int (2))
-                        (Prims.of_int (628)) (Prims.of_int (33)))
+                        (Prims.of_int (633)) (Prims.of_int (2))
+                        (Prims.of_int (634)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (629)) (Prims.of_int (2))
-                        (Prims.of_int (664)) (Prims.of_int (35)))
+                        (Prims.of_int (635)) (Prims.of_int (2))
+                        (Prims.of_int (670)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (627)) (Prims.of_int (5))
-                              (Prims.of_int (627)) (Prims.of_int (23)))
+                              (Prims.of_int (633)) (Prims.of_int (5))
+                              (Prims.of_int (633)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (627)) (Prims.of_int (2))
-                              (Prims.of_int (628)) (Prims.of_int (33)))
+                              (Prims.of_int (633)) (Prims.of_int (2))
+                              (Prims.of_int (634)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (627)) (Prims.of_int (9))
-                                    (Prims.of_int (627)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (9))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (627)) (Prims.of_int (5))
-                                    (Prims.of_int (627)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (5))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2080,15 +2120,15 @@ let (solve_gen_elim_prop :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (631))
+                                       (Prims.of_int (637))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (631))
+                                       (Prims.of_int (637))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (631))
+                                       (Prims.of_int (637))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (663))
+                                       (Prims.of_int (669))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2102,15 +2142,15 @@ let (solve_gen_elim_prop :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (632))
+                                                      (Prims.of_int (638))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (633))
+                                                      (Prims.of_int (639))
                                                       (Prims.of_int (42)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (634))
+                                                      (Prims.of_int (640))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (662))
+                                                      (Prims.of_int (668))
                                                       (Prims.of_int (44)))
                                                    (if
                                                       Prims.op_Negation
@@ -2151,15 +2191,15 @@ let (solve_gen_elim_prop :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (74)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2177,15 +2217,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2199,15 +2239,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2231,29 +2271,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2304,15 +2344,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (646))
+                                                                    (Prims.of_int (652))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (653))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2348,15 +2388,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2366,15 +2406,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2402,15 +2442,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2437,15 +2477,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2455,15 +2495,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2487,15 +2527,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (658))
-                                                                    (Prims.of_int (56)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (49)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2505,16 +2545,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (658))
-                                                                    (Prims.of_int (55)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (48)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2524,32 +2564,8 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
-                                                                    (Prims.of_int (33))
-                                                                    (Prims.of_int (658))
-                                                                    (Prims.of_int (45)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
-                                                                    (Prims.of_int (47))
-                                                                    (Prims.of_int (658))
-                                                                    (Prims.of_int (55)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.trivial
+                                                                    (trefl_or_smt
                                                                     ()))
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Derived.qed
-                                                                    ()))
-                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2561,15 +2577,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2579,15 +2595,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2611,15 +2627,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2629,15 +2645,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2665,15 +2681,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2708,16 +2724,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-         (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-         (Prims.of_int (2)) (Prims.of_int (706)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-               (Prims.of_int (31)) (Prims.of_int (670)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-               (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2729,27 +2745,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (671)) (Prims.of_int (2))
-                        (Prims.of_int (672)) (Prims.of_int (33)))
+                        (Prims.of_int (677)) (Prims.of_int (2))
+                        (Prims.of_int (678)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (673)) (Prims.of_int (2))
-                        (Prims.of_int (706)) (Prims.of_int (35)))
+                        (Prims.of_int (679)) (Prims.of_int (2))
+                        (Prims.of_int (712)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (671)) (Prims.of_int (5))
-                              (Prims.of_int (671)) (Prims.of_int (23)))
+                              (Prims.of_int (677)) (Prims.of_int (5))
+                              (Prims.of_int (677)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (671)) (Prims.of_int (2))
-                              (Prims.of_int (672)) (Prims.of_int (33)))
+                              (Prims.of_int (677)) (Prims.of_int (2))
+                              (Prims.of_int (678)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (671)) (Prims.of_int (9))
-                                    (Prims.of_int (671)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (9))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (671)) (Prims.of_int (5))
-                                    (Prims.of_int (671)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (5))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2775,15 +2791,15 @@ let (solve_gen_elim_prop_placeholder :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (675))
+                                       (Prims.of_int (681))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (675))
+                                       (Prims.of_int (681))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (675))
+                                       (Prims.of_int (681))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (705))
+                                       (Prims.of_int (711))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2797,15 +2813,15 @@ let (solve_gen_elim_prop_placeholder :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (676))
+                                                      (Prims.of_int (682))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (677))
+                                                      (Prims.of_int (683))
                                                       (Prims.of_int (54)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (678))
+                                                      (Prims.of_int (684))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (704))
+                                                      (Prims.of_int (710))
                                                       (Prims.of_int (56)))
                                                    (if
                                                       Prims.op_Negation
@@ -2846,43 +2862,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (681))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (681))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2928,29 +2944,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2974,29 +2990,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3020,29 +3036,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (685))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3066,15 +3082,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (685))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -3105,15 +3121,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -3131,15 +3147,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -3153,15 +3169,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -3176,15 +3192,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3206,15 +3222,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3243,15 +3259,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (37)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_to_string
@@ -3265,15 +3281,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3287,15 +3303,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3322,15 +3338,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3357,15 +3373,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
-                                                                    (Prims.of_int (6))
                                                                     (Prims.of_int (703))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3380,15 +3396,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3403,15 +3419,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3426,15 +3442,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3449,15 +3465,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3472,15 +3488,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3495,15 +3511,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma

From 3445a74443ba9c4fdc2c35f7ea3ccfdad1995cd1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 24 Feb 2023 19:22:17 -0800
Subject: [PATCH 395/513] WIP; solved gen_elim issue

---
 ulib/experimental/Steel.C.Types.fst  | 8 ++------
 ulib/experimental/Steel.C.Types.fsti | 1 +
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 419694c30ee..7af01a79fb5 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -824,9 +824,6 @@ let has_struct_field
   r field r'
 = has_struct_field1 r field r'
 
-#push-options "--z3rlimit 16"
-#restart-solver
-
 let has_struct_field_dup'
   (#opened: _)
   (#field_t: eqtype)
@@ -839,7 +836,7 @@ let has_struct_field_dup'
     (fun _ -> has_struct_field1 r field r' `star` has_struct_field1 r field r')
 =
   ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = ST.gen_elim_dep () in
+  let _ = ST.gen_elim () in
   HR.share r;
   HR.share r';
   ST.noop ();
@@ -847,8 +844,7 @@ let has_struct_field_dup'
   ST.noop ();
   ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
 
-#pop-options
-
+(*
 let has_struct_field_gen_inj
   (#opened: _)
   (#field_t: eqtype)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 3b8e7c9e668..3f72b80e0c6 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -502,6 +502,7 @@ val has_struct_field
   (r': ref (fields.fd_typedef field))
 : Tot vprop
 
+(*
 val has_struct_field_dup
   (#opened: _)
   (#tn: Type0)

From 0638457730cf87b8113c473cf49a12021e29f7ed Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 14:56:50 -0800
Subject: [PATCH 396/513] returned squash needs explicit let binding

---
 ulib/experimental/Steel.HigherReference.fst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.HigherReference.fst b/ulib/experimental/Steel.HigherReference.fst
index cbd747822b3..798f7c5b22b 100644
--- a/ulib/experimental/Steel.HigherReference.fst
+++ b/ulib/experimental/Steel.HigherReference.fst
@@ -258,7 +258,7 @@ let gather_atomic_raw (#a:Type) (#uses:_) (#p0 #p1:perm) (r:ref a) (v0:erased a)
       (pts_to_raw r p1 v1)
       (RP.pts_to r (Ghost.reveal (Some (Ghost.reveal v1, p1))))
       (fun _ -> ());
-    RP.gather r (Some (Ghost.reveal v0, p0)) (Some (Ghost.reveal v1, p1));
+    let _ = RP.gather r (Some (Ghost.reveal v0, p0)) (Some (Ghost.reveal v1, p1)) in
     rewrite_slprop
       (RP.pts_to r _)
       (pts_to_raw r (sum_perm p0 p1) v0)

From 68a6174de0f23099bd2e29f0c3953d9e32ce3083 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 15:00:09 -0800
Subject: [PATCH 397/513] explicit lemmas to reveal ghost_ref, ghost_pts_to

suggested by @nikswamy
---
 ulib/experimental/Steel.HigherReference.fst  |  4 ++++
 ulib/experimental/Steel.HigherReference.fsti | 13 +++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/ulib/experimental/Steel.HigherReference.fst b/ulib/experimental/Steel.HigherReference.fst
index 798f7c5b22b..61a90ac4cc6 100644
--- a/ulib/experimental/Steel.HigherReference.fst
+++ b/ulib/experimental/Steel.HigherReference.fst
@@ -367,6 +367,10 @@ let ghost_ref a = erased (ref a)
 [@@__reduce__]
 let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
 
+let reveal_ghost_ref _ = ()
+
+let reveal_ghost_pts_to_sl _ _ _ = ()
+
 let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
   let aux (x y : erased a) (m:mem)
     : Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
diff --git a/ulib/experimental/Steel.HigherReference.fsti b/ulib/experimental/Steel.HigherReference.fsti
index da3b3e723c3..42d2995c721 100644
--- a/ulib/experimental/Steel.HigherReference.fsti
+++ b/ulib/experimental/Steel.HigherReference.fsti
@@ -173,6 +173,19 @@ val ghost_ref (a:Type u#1) : Type u#0
 
 val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1
 
+/// Lemmas to break the abstraction, if one needs to manipulate both
+/// ghost and non-ghost references. These lemmas have no SMT patterns
+/// so that the normalizer or SMT won't silently unfold the
+/// definitions of ghost_ref or ghost_pts_to_sl. These should be
+/// harmless since ghost_ref is erasable
+val reveal_ghost_ref (a: Type u#1) : Lemma
+  (ghost_ref a == erased (ref a))
+
+val reveal_ghost_pts_to_sl
+  (#a: _) (r: ghost_ref a) (p: perm) (x: a)
+: Lemma
+  (ghost_pts_to_sl r p x == pts_to_sl (reveal (coerce_eq (reveal_ghost_ref a) r)) p x)
+
 [@@ __steel_reduce__]
 unfold let ghost_pts_to (#a:_) (r:ghost_ref a) (p:perm) (x:a) : vprop =
   to_vprop (ghost_pts_to_sl r p x)

From d6b9445aa3e4660fac194555aad5b141fd524c38 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 15:26:56 -0800
Subject: [PATCH 398/513] WIP

blocked at ghost_struct_field because I cannot ghostly allocate
the outer reference
---
 ulib/experimental/Steel.C.Types.fst  | 156 ++++++++++++++++++++-------
 ulib/experimental/Steel.C.Types.fsti |   5 +-
 2 files changed, 121 insertions(+), 40 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 7af01a79fb5..256ba0cb351 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -275,7 +275,7 @@ let pts_to_equiv'
   (#t: Type)
   (#td: typedef t)
   (r1 r2: ref td)
-  (v: t)
+  (v: Ghost.erased t)
 : ST.STGhostT unit opened
     (ref_equiv r1 r2 `star` pts_to r1 v)
     (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
@@ -678,9 +678,15 @@ let struct_set_field
   f v s
 = t_struct_set_field f v s
 
+[@@noextract_to "krml"] // proof-only
+let t_struct_get_field
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t) (s: struct_t1 fields) (f: field_t)
+: Tot (fields.fd_type f)
+= s f
+
 let struct_get_field
   s field
-= s field
+= t_struct_get_field s field
 
 let struct_eq
   s1 s2
@@ -844,42 +850,111 @@ let has_struct_field_dup'
   ST.noop ();
   ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
 
-(*
-let has_struct_field_gen_inj
+let has_struct_field_dup
+  r field r'
+= has_struct_field_dup' r field r'
+
+let has_struct_field_inj'
   (#opened: _)
   (#field_t: eqtype)
-  (fields: field_description_gen_t field_t)
+  (#fields: field_description_gen_t field_t)
   (r: ref (struct1 fields))
   (field: field_t)
   (r1 r2: ref (fields.fd_typedef field))
-: SteelGhost unit opened
-    emp
-    (fun _ -> emp)
-    (fun _ ->
-      Ghost.reveal (mem_inv opened _inv) == false /\
-      has_struct_field_gen fields r field r1 /\
-      has_struct_field_gen fields r field r2
-    )
-    (fun _ _ _ -> r1 == r2)
-= TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
+: ST.STGhostT unit opened
+    (has_struct_field1 r field r1 `star` has_struct_field1 r field r2)
+    (fun _ -> has_struct_field1 r field r1 `star` has_struct_field1 r field r2 `star` ref_equiv r1 r2)
+=
+  ST.rewrite (has_struct_field1 r field r1) (has_struct_field0 r field r1);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  let w1 = ST.vpattern_replace (HR.pts_to r1 _) in
+  ST.rewrite (has_struct_field1 r field r2) (has_struct_field0 r field r2);
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  ST.vpattern_rewrite (HR.pts_to r2 _) w1;
+  hr_share r;
+  hr_share r1;
+  ST.rewrite (has_struct_field0 r field r1) (has_struct_field1 r field r1);
+  hr_share r2;
+  ST.rewrite (has_struct_field0 r field r2) (has_struct_field1 r field r2);
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 let has_struct_field_inj
   r field r1 r2
-= has_struct_field_gen_inj _ r field r1 r2
+= has_struct_field_inj' r field r1 r2
 
-#push-options "--z3rlimit 32"
+let has_struct_field_equiv_from'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r1: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+  (r2: ref (struct1 fields))
+: ST.STGhostT unit opened
+    (ref_equiv r1 r2 `star` has_struct_field1 r1 field r')
+    (fun _ -> ref_equiv r1 r2 `star` has_struct_field1 r2 field r')
+= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  ST.rewrite (has_struct_field1 r1 field r') (has_struct_field0 r1 field r');
+  let _ = ST.gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  ST.rewrite (has_struct_field0 r2 field r') (has_struct_field1 r2 field r');
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
-#restart-solver
+let has_struct_field_equiv_from
+  r1 field r' r2
+= has_struct_field_equiv_from' r1 field r' r2
 
-let ghost_struct_field_focus
-  #_ #tn #_ #n #fields #v r0 field r'0
-= let r : R.ref (struct_pcm _) = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
+let has_struct_field_equiv_to'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r1': ref (fields.fd_typedef field))
+  (r2': ref (fields.fd_typedef field))
+: ST.STGhostT unit opened
+    (ref_equiv r1' r2' `star` has_struct_field1 r field r1')
+    (fun _ -> ref_equiv r1' r2' `star` has_struct_field1 r field r2')
+= ST.rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  ST.rewrite (has_struct_field1 r field r1') (has_struct_field0 r field r1');
+  let _ = ST.gen_elim () in
+  hr_gather w r1';
+  hr_share r2';
+  ST.rewrite (has_struct_field0 r field r2') (has_struct_field1 r field r2');
+  ST.rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+
+let has_struct_field_equiv_to
+  r field r1 r2
+= has_struct_field_equiv_to' r field r1 r2
+
+let ghost_struct_field_focus'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: ST.STGhostT unit opened
+    (has_struct_field1 r field r' `star` pts_to r v)
+    (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field))
+= ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  let w' = ST.vpattern_replace (HR.pts_to r' _) in
+  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
   let prf
-    (f': field_t fields)
+    (f': field_t)
     (x: (fields.fd_type f'))
   : Lemma
     (let p = (fields.fd_typedef f').pcm in
@@ -889,20 +964,25 @@ let ghost_struct_field_focus
   = is_unit (fields.fd_typedef f').pcm x
   in
   Classical.forall_intro_2 prf;
-  let v' = struct_set_field field (unknown (fields.fd_typedef field)) v in
-  let vf = S.field_to_struct_f (struct_field_pcm _) field (struct_get_field v field) in
+  let v' = t_struct_set_field field (unknown (fields.fd_typedef field)) v in
+  let vf = S.field_to_struct_f (struct_field_pcm _) field (t_struct_get_field v field) in
   assert (composable (struct_pcm _) v' vf);
   assert (op (struct_pcm _) v' vf `FX.feq` v);
-  R.split r _ v' vf;
-  R.gfocus r (S.struct_field (struct_field_pcm _) field) vf (struct_get_field v field);
-  rewrite_slprop
-    (R.pts_to r _)
-    (pts_to r0 _)
-    (fun _ -> ());
-  rewrite_slprop
-    (R.pts_to _ _)
-    (pts_to r'0 _)
-    (fun _ -> ())
+  RST.split w.ref _ v' vf;
+  RST.gfocus w.ref (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
+  hr_share r;
+  hr_share r';
+  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  ST.weaken (pts_to0 r v') (pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v)) (fun _ -> ());
+  ST.rewrite (R.pts_to _ _) (r_pts_to w'.ref (t_struct_get_field v field));
+  ST.weaken (pts_to0 r' (t_struct_get_field v field)) (pts_to r' (t_struct_get_field v field)) (fun _ -> ())
+  
+let ghost_struct_field_focus
+  r field r'
+= noop (); // FIXME: WHY WHY WHY? without this noop, z3 fails to prove precondition of field_description_t.fd_typedef . But also works if I put noop () after the function call
+  ghost_struct_field_focus' r field r'
+
+(*
 
 let ghost_struct_field
   #_ #tn #_ #n #fields #v r field
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 3f72b80e0c6..e232b026bd6 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -159,7 +159,7 @@ val pts_to_equiv
   (#t: Type)
   (#td: typedef t)
   (r1 r2: ref td)
-  (v: t)
+  (v: Ghost.erased t)
 : SteelGhostT unit opened
     (ref_equiv r1 r2 `star` pts_to r1 v)
     (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
@@ -502,7 +502,6 @@ val has_struct_field
   (r': ref (fields.fd_typedef field))
 : Tot vprop
 
-(*
 val has_struct_field_dup
   (#opened: _)
   (#tn: Type0)
@@ -571,6 +570,8 @@ val ghost_struct_field_focus
     (has_struct_field r field r' `star` pts_to r v)
     (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
 
+(*
+
 val ghost_struct_field
   (#opened: _)
   (#tn: Type0)

From b53560946e27904068d5dcda10c6d77f4fe5bf25 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 16:09:18 -0800
Subject: [PATCH 399/513] Steel.ST.GhostHigherReference

---
 .../Steel.ST.GhostHigherReference.fst         |  74 +++++++++++
 .../Steel.ST.GhostHigherReference.fsti        | 125 ++++++++++++++++++
 2 files changed, 199 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.GhostHigherReference.fst
 create mode 100644 ulib/experimental/Steel.ST.GhostHigherReference.fsti

diff --git a/ulib/experimental/Steel.ST.GhostHigherReference.fst b/ulib/experimental/Steel.ST.GhostHigherReference.fst
new file mode 100644
index 00000000000..30d6f831d8e
--- /dev/null
+++ b/ulib/experimental/Steel.ST.GhostHigherReference.fst
@@ -0,0 +1,74 @@
+module Steel.ST.GhostHigherReference
+
+// needed because I need to know that `Steel.ST.HigherReference.ref a`
+// can be turned into `Steel.HigherReference.ref a`
+friend Steel.ST.HigherReference
+
+module RST = Steel.ST.HigherReference
+module R = Steel.HigherReference
+
+module STC = Steel.ST.Coercions
+
+// FIXME: WHY WHY WHY in `Ghost.reveal (ref a)` is `a` not strictly positive?
+
+[@@erasable]
+noeq
+type ref' ([@@@strictly_positive] a : Type u#1) : Type0
+= | Hide: (reveal: R.ref a) -> ref' a
+
+let ref a = ref' a
+
+let pts_to r p v = RST.pts_to r.reveal p v
+
+let reveal_ref r = r.reveal
+
+let hide_ref r = Hide r
+
+let hide_reveal_ref r = ()
+
+let reveal_pts_to r p x =
+  equiv_refl (Steel.ST.HigherReference.pts_to (reveal_ref r) p x)
+
+let pts_to_injective_eq
+  #_ #_ #p0 #p1 #v0 #v1 r
+= rewrite (pts_to r p0 v0) (RST.pts_to r.reveal p0 v0);
+  rewrite (pts_to r p1 v1) (RST.pts_to r.reveal p1 v1);
+  RST.pts_to_injective_eq #_ #_ #_ #_ #v0 #v1 r.reveal;
+  rewrite (RST.pts_to r.reveal p0 v0) (pts_to r p0 v0);
+  rewrite (RST.pts_to r.reveal p1 v0) (pts_to r p1 v0)
+
+let alloc
+  #_ #a x
+= let gr = STC.coerce_ghost (fun _ -> R.ghost_alloc x) in
+  let r = Hide (Ghost.reveal (coerce_eq (R.reveal_ghost_ref a) gr)) in
+  weaken (R.ghost_pts_to gr full_perm x) (pts_to r full_perm x) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm x
+  );
+  r
+
+let write
+  #_ #a #v r x
+= let gr : R.ghost_ref a = coerce_eq (R.reveal_ghost_ref a) (Ghost.hide r.reveal) in
+  weaken (pts_to r full_perm v) (R.ghost_pts_to gr full_perm v) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm v
+  );
+  STC.coerce_ghost (fun _ -> R.ghost_write gr x);
+  weaken (R.ghost_pts_to gr full_perm x) (pts_to r full_perm x) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm x
+  )
+
+let free
+  #_ #a #v r
+= let gr : R.ghost_ref a = coerce_eq (R.reveal_ghost_ref a) (Ghost.hide r.reveal) in
+  weaken (pts_to r full_perm v) (R.ghost_pts_to gr full_perm v) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm v
+  );
+  STC.coerce_ghost (fun _ -> R.ghost_free gr)
+
+let share
+  r
+= RST.share r.reveal
+
+let gather
+  p1 r
+= RST.gather p1 r.reveal
diff --git a/ulib/experimental/Steel.ST.GhostHigherReference.fsti b/ulib/experimental/Steel.ST.GhostHigherReference.fsti
new file mode 100644
index 00000000000..0112373a5a2
--- /dev/null
+++ b/ulib/experimental/Steel.ST.GhostHigherReference.fsti
@@ -0,0 +1,125 @@
+(*
+   Copyright 2021 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.ST.GhostHigherReference
+open FStar.Ghost
+open Steel.ST.Util
+
+/// The main ref type.
+///
+/// It's in universe zero, so refs can be stored in the heap, you can
+/// have [ref (ref a)] etc.
+[@@erasable]
+val ref ([@@@ strictly_positive] a:Type u#1)
+  : Type0
+
+/// The main representation predicate
+///
+/// Both the permissions [p] and the value [v] are marked with the
+/// [smt_fallback] attribute. This allows the Steel unifier to produce
+/// equality goals discharged by SMT to relate instances of the
+/// [pts_to] predicate that differ on the [p] and [v] arguments.
+///
+/// For instance, [pts_to r (sum_perm (half_perm p) (half_perm p)) (v + 1)]
+/// is unifiable with [pts_to r p (1 + v)]
+val pts_to (#a:Type)
+           (r:ref a)
+           ([@@@smt_fallback] p:perm)
+           ([@@@smt_fallback] v:a)
+  : vprop
+
+/// Lemmas to break the abstraction, if one needs to manipulate both
+/// ghost and non-ghost references. These lemmas have no SMT patterns
+/// so that the normalizer or SMT won't silently unfold the
+/// definitions of ref or pts_to. These should be
+/// harmless since ref is erasable
+val reveal_ref (#a: Type u#1) (r: ref a) : GTot (Steel.ST.HigherReference.ref a)
+
+val hide_ref (#a: Type u#1) (r: Steel.ST.HigherReference.ref a) : Pure (ref a)
+  (requires True)
+  (ensures (fun r' -> reveal_ref r' == r))
+
+val hide_reveal_ref (#a: Type u#1) (r: ref a) : Lemma
+  (hide_ref (reveal_ref r) == r)
+
+val reveal_pts_to
+  (#a: _) (r: ref a) (p: perm) (x: a)
+: Lemma
+  (pts_to r p x `equiv` Steel.ST.HigherReference.pts_to (reveal_ref r) p x)
+
+/// A reference can point to at most one value
+val pts_to_injective_eq (#a: Type)
+                        (#opened:inames)
+                        (#p0 #p1:perm)
+                        (#v0 #v1: a)
+                        (r: ref a)
+  : STGhost unit opened
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+                    
+/// Allocating a reference returns full-permission to a non-null
+/// reference pointing to the initializer [x].
+///
+/// We do not model memory exhaustion
+val alloc (#opened: _) (#a:Type) (x:a)
+  : STGhost (ref a) opened
+      emp 
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> True)
+
+/// Writes value `x` in the reference `r`, as long as we have full
+/// ownership of `r`
+val write (#opened: _) (#a:Type)
+          (#v:erased a)
+          (r:ref a)
+          (x:a)
+  : STGhostT unit opened
+      (pts_to r full_perm v)
+      (fun _ -> pts_to r full_perm x)
+
+/// Frees reference [r], as long as we have full ownership of [r]
+val free (#opened: _) (#a:Type)
+         (#v:erased a)
+         (r:ref a)
+  : STGhostT unit opened
+    (pts_to r full_perm v) (fun _ -> emp)
+
+/// Splits the permission on reference [r] into two. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val share (#a:Type)
+          (#uses:_)
+          (#p:perm)
+          (#v:erased a)
+          (r:ref a)
+  : STGhostT unit uses
+      (pts_to r p v)
+      (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
+
+/// Combines permissions on reference [r]. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val gather (#a:Type)
+           (#uses:_) 
+           (#p0 p1:perm)
+           (#v0 #v1:erased a)
+           (r:ref a)
+  : STGhost unit uses
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r (sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)

From 9523c0fefe8267dfa96b2729863e4a9308cf2002 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 16:39:50 -0800
Subject: [PATCH 400/513] ghost_struct_field

---
 ulib/experimental/Steel.C.Types.fst  | 39 ++++++++++++++++++++++++++++
 ulib/experimental/Steel.C.Types.fsti |  4 +--
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 256ba0cb351..dd1f9535307 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -982,6 +982,45 @@ let ghost_struct_field_focus
 = noop (); // FIXME: WHY WHY WHY? without this noop, z3 fails to prove precondition of field_description_t.fd_typedef . But also works if I put noop () after the function call
   ghost_struct_field_focus' r field r'
 
+module GHR = Steel.ST.GhostHigherReference
+
+let ghost_struct_field'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+: SteelGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+    (pts_to r v)
+    (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
+  }
+  in
+  let gr' = GHR.alloc w' in
+  let r1' = GHR.reveal_ref gr' in
+  GHR.reveal_pts_to gr' P.full_perm w';
+  ST.rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  HR.pts_to_not_null r1';
+  let r' = Ghost.hide r1' in
+  ST.rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  hr_share r;
+  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  ghost_struct_field_focus' r field r';
+  r'
+
+let ghost_struct_field
+  r field
+= noop (); // FIXME: WHY WHY WHY? (same as ghost_struct_field_focus above)
+  ghost_struct_field' r field
+
 (*
 
 let ghost_struct_field
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index e232b026bd6..f082a5b60fa 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -570,8 +570,6 @@ val ghost_struct_field_focus
     (has_struct_field r field r' `star` pts_to r v)
     (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
 
-(*
-
 val ghost_struct_field
   (#opened: _)
   (#tn: Type0)
@@ -585,6 +583,8 @@ val ghost_struct_field
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
 
+(*
+
 [@@noextract_to "krml"] // primitive
 val struct_field0
   (#tn: Type0)

From 8befbab2e57f34347bbbba31711ba4d399f7afca Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 15:00:09 -0800
Subject: [PATCH 401/513] explicit lemmas to reveal ghost_ref, ghost_pts_to

suggested by @nikswamy
---
 ulib/experimental/Steel.HigherReference.fst  |  4 ++++
 ulib/experimental/Steel.HigherReference.fsti | 13 +++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/ulib/experimental/Steel.HigherReference.fst b/ulib/experimental/Steel.HigherReference.fst
index 4975551282a..7e42d2b7a63 100644
--- a/ulib/experimental/Steel.HigherReference.fst
+++ b/ulib/experimental/Steel.HigherReference.fst
@@ -366,6 +366,10 @@ let ghost_ref a = erased (ref a)
 [@@__reduce__]
 let ghost_pts_to_sl #a (r:ghost_ref a) (p:perm) (x:a) = pts_to_sl (reveal r) p x
 
+let reveal_ghost_ref _ = ()
+
+let reveal_ghost_pts_to_sl _ _ _ = ()
+
 let ghost_pts_to_witinv (#a:Type) (r:ghost_ref a) (p:perm) : Lemma (is_witness_invariant (ghost_pts_to_sl r p)) =
   let aux (x y : erased a) (m:mem)
     : Lemma (requires (interp (ghost_pts_to_sl r p x) m /\ interp (ghost_pts_to_sl r p y) m))
diff --git a/ulib/experimental/Steel.HigherReference.fsti b/ulib/experimental/Steel.HigherReference.fsti
index da3b3e723c3..42d2995c721 100644
--- a/ulib/experimental/Steel.HigherReference.fsti
+++ b/ulib/experimental/Steel.HigherReference.fsti
@@ -173,6 +173,19 @@ val ghost_ref (a:Type u#1) : Type u#0
 
 val ghost_pts_to_sl (#a:_) (r:ghost_ref a) (p:perm) (x:a) : slprop u#1
 
+/// Lemmas to break the abstraction, if one needs to manipulate both
+/// ghost and non-ghost references. These lemmas have no SMT patterns
+/// so that the normalizer or SMT won't silently unfold the
+/// definitions of ghost_ref or ghost_pts_to_sl. These should be
+/// harmless since ghost_ref is erasable
+val reveal_ghost_ref (a: Type u#1) : Lemma
+  (ghost_ref a == erased (ref a))
+
+val reveal_ghost_pts_to_sl
+  (#a: _) (r: ghost_ref a) (p: perm) (x: a)
+: Lemma
+  (ghost_pts_to_sl r p x == pts_to_sl (reveal (coerce_eq (reveal_ghost_ref a) r)) p x)
+
 [@@ __steel_reduce__]
 unfold let ghost_pts_to (#a:_) (r:ghost_ref a) (p:perm) (x:a) : vprop =
   to_vprop (ghost_pts_to_sl r p x)

From 82e4da61c7714b84f05d11b1310abad30a4170ac Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Feb 2023 18:49:33 -0800
Subject: [PATCH 402/513] Steel.ST.HigherReference

---
 .../experimental/Steel.ST.HigherReference.fst | 188 ++++++++++++++++
 .../Steel.ST.HigherReference.fsti             | 205 ++++++++++++++++++
 2 files changed, 393 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.HigherReference.fst
 create mode 100644 ulib/experimental/Steel.ST.HigherReference.fsti

diff --git a/ulib/experimental/Steel.ST.HigherReference.fst b/ulib/experimental/Steel.ST.HigherReference.fst
new file mode 100644
index 00000000000..313822f34fe
--- /dev/null
+++ b/ulib/experimental/Steel.ST.HigherReference.fst
@@ -0,0 +1,188 @@
+(*
+   Copyright 2020 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.ST.HigherReference
+open FStar.Ghost
+open Steel.ST.Util
+open Steel.ST.Coercions
+module R = Steel.HigherReference
+
+let ref (a:Type u#1)
+  : Type0
+  = R.ref a
+
+let null (#a:Type)
+  : ref a
+  = R.null #a
+
+let is_null (#a:Type) (r:ref a)
+  : b:bool{b <==> r == null}
+  = R.is_null r
+
+let pts_to (#a:Type)
+           (r:ref a)
+           ([@@@smt_fallback] p:perm)
+           ([@@@smt_fallback] v:a)
+  : vprop
+  = R.pts_to r p v
+
+let pts_to_injective_eq
+      (#a: Type)
+      (#opened:inames)
+      (#p0 #p1:perm)
+      (#v0 #v1:a)
+      (r: ref a)
+  : STGhost unit opened
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+  = coerce_ghost
+    (fun _ -> R.higher_ref_pts_to_injective_eq #a #opened #p0 #p1 #(hide v0) #(hide v1) r)
+
+let pts_to_not_null #a #opened #p #v r
+  = extract_fact #opened (pts_to r p v) (r =!= null) (R.pts_to_not_null r p v);
+    ()
+
+let alloc (#a:Type) (x:a)
+  : ST (ref a)
+      emp
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> not (is_null r))
+  = let r = coerce_steel (fun _ -> R.alloc x) in
+    r
+
+let read (#a:Type)
+         (#p:perm)
+         (#v:erased a)
+         (r:ref a)
+  : ST a
+      (pts_to r p v)
+      (fun _ -> pts_to r p v)
+      (requires True)
+      (ensures fun x -> x == Ghost.reveal v)
+  = let u = coerce_steel (fun _ -> R.read r) in
+    return u
+
+let write (#a:Type)
+          (#v:erased a)
+          (r:ref a)
+          (x:a)
+  : STT unit
+      (pts_to r full_perm v)
+      (fun _ -> pts_to r full_perm x)
+  = coerce_steel (fun _ -> R.write r x);
+    return ()
+
+let free (#a:Type)
+         (#v:erased a)
+         (r:ref a)
+  : STT unit
+        (pts_to r full_perm v)
+        (fun _ -> emp)
+  = coerce_steel(fun _ -> R.free r);
+    return ()
+
+/// Local primitive, to be extracted to Low* EPushFrame.  To remember
+/// that we need to call some pop_frame later, we insert some dummy
+/// vprop into the context.
+let _stack_frame : vprop = pure True
+let _push_frame () : STT unit emp (fun _ -> _stack_frame) =
+  rewrite (pure True) _stack_frame
+
+/// Local primitive, to be extracted to Low* EBufCreate
+let _alloca (#a:Type) (x:a)
+  : ST (ref a)
+      emp
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> not (is_null r))
+= alloc x
+
+/// Local primitive, to be extracted to Low* EPopFrame
+let _free_and_pop_frame
+  (#a:Type)
+  (#v:erased a)
+  (r:ref a)
+: STT unit
+    (pts_to r full_perm v `star` _stack_frame)
+    (fun _ -> emp)
+= free r;
+  rewrite _stack_frame (pure True);
+  elim_pure _
+
+let with_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+= _push_frame ();
+  let r = _alloca init in
+  let v = body r in
+  let _ = elim_exists () in
+  _free_and_pop_frame r;
+  return v
+
+let with_named_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (name: string)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+= _push_frame ();
+  [@(rename_let name)]
+  let r = _alloca init in
+  let v = body r in
+  let _ = elim_exists () in
+  _free_and_pop_frame r;
+  return v
+
+let share (#a:Type)
+          (#uses:_)
+          (#p:perm)
+          (#v:erased a)
+          (r:ref a)
+  : STGhostT unit uses
+      (pts_to r p v)
+      (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
+  = coerce_ghost (fun _ -> R.share r)
+
+let gather (#a:Type)
+           (#uses:_)
+           (#p0 p1:perm)
+           (#v0 #v1:erased a)
+           (r:ref a)
+  : STGhost unit uses
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r (sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+  = coerce_ghost (fun _ -> R.gather #a #uses #p0 #p1 #v0 #v1 r)
diff --git a/ulib/experimental/Steel.ST.HigherReference.fsti b/ulib/experimental/Steel.ST.HigherReference.fsti
new file mode 100644
index 00000000000..1a2f568fd87
--- /dev/null
+++ b/ulib/experimental/Steel.ST.HigherReference.fsti
@@ -0,0 +1,205 @@
+(*
+   Copyright 2021 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.ST.HigherReference
+open FStar.Ghost
+open Steel.ST.Util
+
+module U32 = FStar.UInt32
+
+(** This module provides a reference whose ownership is controlled
+    using fractional permissions.
+    
+    It provides a distinguished null reference too, which is
+    extractable to C as a null pointer. *)
+
+/// The main ref type.
+///
+/// It's in universe zero, so refs can be stored in the heap, you can
+/// have [ref (ref a)] etc.
+val ref ([@@@ strictly_positive] a:Type u#1)
+  : Type0
+
+/// The null reference
+val null (#a:Type) 
+  : ref a
+
+/// Nullness is decidable with a pure function
+val is_null (#a:Type) (r:ref a)
+  : b:bool{b <==> r == null}
+
+/// The main representation predicate
+///
+/// Both the permissions [p] and the value [v] are marked with the
+/// [smt_fallback] attribute. This allows the Steel unifier to produce
+/// equality goals discharged by SMT to relate instances of the
+/// [pts_to] predicate that differ on the [p] and [v] arguments.
+///
+/// For instance, [pts_to r (sum_perm (half_perm p) (half_perm p)) (v + 1)]
+/// is unifiable with [pts_to r p (1 + v)]
+val pts_to (#a:Type)
+           (r:ref a)
+           ([@@@smt_fallback] p:perm)
+           ([@@@smt_fallback] v:a)
+  : vprop
+
+/// A reference can point to at most one value
+val pts_to_injective_eq (#a: Type)
+                        (#opened:inames)
+                        (#p0 #p1:perm)
+                        (#v0 #v1: a)
+                        (r: ref a)
+  : STGhost unit opened
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+
+/// Null references can't point to anything
+val pts_to_not_null (#a:Type)
+                    (#opened:inames)
+                    (#p:perm)
+                    (#v:a)
+                    (r:ref a)
+  : STGhost unit opened
+      (pts_to r p v)
+      (fun _ -> pts_to r p v)
+      (requires True)
+      (ensures fun _ -> r =!= null)
+                    
+/// Allocating a reference returns full-permission to a non-null
+/// reference pointing to the initializer [x].
+///
+/// We do not model memory exhaustion
+val alloc (#a:Type) (x:a)
+  : ST (ref a)
+      emp 
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> not (is_null r))
+
+/// Reads the value in reference [r]. The postcondition ensures that
+/// the returned value is equal to the index [v].
+val read (#a:Type)
+         (#p:perm)
+         (#v:erased a)
+         (r:ref a)
+  : ST a
+      (pts_to r p v)
+      (fun x -> pts_to r p v)
+      (requires True)
+      (ensures fun x -> x == Ghost.reveal v)
+
+/// Writes value `x` in the reference `r`, as long as we have full
+/// ownership of `r`
+val write (#a:Type)
+          (#v:erased a)
+          (r:ref a)
+          (x:a)
+  : STT unit
+      (pts_to r full_perm v)
+      (fun _ -> pts_to r full_perm x)
+
+/// Frees reference [r], as long as we have full ownership of [r]
+val free (#a:Type)
+         (#v:erased a)
+         (r:ref a)
+  : STT unit
+    (pts_to r full_perm v) (fun _ -> emp)
+
+/// Executes a code block with a local variable temporarily allocated
+/// on the stack. This function is declared in the `STF` effect so
+/// that the pre- and post-resources can be properly inferred by the
+/// Steel tactic from the caller's context.
+///
+/// From the extraction point of view, `with_local init body` is to behave
+/// similarly as the following Low* code:
+///
+/// <<<
+/// push_frame ();
+/// let r = alloca 1ul init in
+/// let res = body r in
+/// pop_frame ();
+/// r
+/// >>>
+///
+/// and thus, is to be extracted to C as:
+/// <<<
+/// ret_t res;
+/// {
+///   t r = init;
+///   res = <body r>;
+/// }
+/// >>>
+///
+/// To this end, we mimic the Low* behavior by defining local
+/// primitives with primitive extraction in the `.fst`, and have them
+/// called by `with_local`. This is why we mark `with_local` as
+/// `inline_for_extraction`.
+inline_for_extraction
+val with_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+
+/// Same as with_local, with an additional string argument to set the
+/// name of the local variable in the extracted C code.
+inline_for_extraction
+val with_named_local
+  (#t: Type)
+  (init: t)
+  (#pre: vprop)
+  (#ret_t: Type)
+  (#post: ret_t -> vprop)
+  (name: string)
+  (body: (r: ref t) ->
+    STT ret_t
+    (pts_to r full_perm init `star` pre)
+    (fun v -> exists_ (pts_to r full_perm) `star` post v)
+  )
+: STF ret_t pre post True (fun _ -> True)
+
+/// Splits the permission on reference [r] into two. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val share (#a:Type)
+          (#uses:_)
+          (#p:perm)
+          (#v:erased a)
+          (r:ref a)
+  : STGhostT unit uses
+      (pts_to r p v)
+      (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
+
+/// Combines permissions on reference [r]. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val gather (#a:Type)
+           (#uses:_) 
+           (#p0 p1:perm)
+           (#v0 #v1:erased a)
+           (r:ref a)
+  : STGhost unit uses
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r (sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)

From 3988c6597b9b7384a12691ccef8d5596ce8a2b46 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Feb 2023 16:09:18 -0800
Subject: [PATCH 403/513] Steel.ST.GhostHigherReference

---
 .../Steel.ST.GhostHigherReference.fst         |  74 +++++++++++
 .../Steel.ST.GhostHigherReference.fsti        | 125 ++++++++++++++++++
 2 files changed, 199 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.GhostHigherReference.fst
 create mode 100644 ulib/experimental/Steel.ST.GhostHigherReference.fsti

diff --git a/ulib/experimental/Steel.ST.GhostHigherReference.fst b/ulib/experimental/Steel.ST.GhostHigherReference.fst
new file mode 100644
index 00000000000..30d6f831d8e
--- /dev/null
+++ b/ulib/experimental/Steel.ST.GhostHigherReference.fst
@@ -0,0 +1,74 @@
+module Steel.ST.GhostHigherReference
+
+// needed because I need to know that `Steel.ST.HigherReference.ref a`
+// can be turned into `Steel.HigherReference.ref a`
+friend Steel.ST.HigherReference
+
+module RST = Steel.ST.HigherReference
+module R = Steel.HigherReference
+
+module STC = Steel.ST.Coercions
+
+// FIXME: WHY WHY WHY in `Ghost.reveal (ref a)` is `a` not strictly positive?
+
+[@@erasable]
+noeq
+type ref' ([@@@strictly_positive] a : Type u#1) : Type0
+= | Hide: (reveal: R.ref a) -> ref' a
+
+let ref a = ref' a
+
+let pts_to r p v = RST.pts_to r.reveal p v
+
+let reveal_ref r = r.reveal
+
+let hide_ref r = Hide r
+
+let hide_reveal_ref r = ()
+
+let reveal_pts_to r p x =
+  equiv_refl (Steel.ST.HigherReference.pts_to (reveal_ref r) p x)
+
+let pts_to_injective_eq
+  #_ #_ #p0 #p1 #v0 #v1 r
+= rewrite (pts_to r p0 v0) (RST.pts_to r.reveal p0 v0);
+  rewrite (pts_to r p1 v1) (RST.pts_to r.reveal p1 v1);
+  RST.pts_to_injective_eq #_ #_ #_ #_ #v0 #v1 r.reveal;
+  rewrite (RST.pts_to r.reveal p0 v0) (pts_to r p0 v0);
+  rewrite (RST.pts_to r.reveal p1 v0) (pts_to r p1 v0)
+
+let alloc
+  #_ #a x
+= let gr = STC.coerce_ghost (fun _ -> R.ghost_alloc x) in
+  let r = Hide (Ghost.reveal (coerce_eq (R.reveal_ghost_ref a) gr)) in
+  weaken (R.ghost_pts_to gr full_perm x) (pts_to r full_perm x) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm x
+  );
+  r
+
+let write
+  #_ #a #v r x
+= let gr : R.ghost_ref a = coerce_eq (R.reveal_ghost_ref a) (Ghost.hide r.reveal) in
+  weaken (pts_to r full_perm v) (R.ghost_pts_to gr full_perm v) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm v
+  );
+  STC.coerce_ghost (fun _ -> R.ghost_write gr x);
+  weaken (R.ghost_pts_to gr full_perm x) (pts_to r full_perm x) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm x
+  )
+
+let free
+  #_ #a #v r
+= let gr : R.ghost_ref a = coerce_eq (R.reveal_ghost_ref a) (Ghost.hide r.reveal) in
+  weaken (pts_to r full_perm v) (R.ghost_pts_to gr full_perm v) (fun _ ->
+    R.reveal_ghost_pts_to_sl gr full_perm v
+  );
+  STC.coerce_ghost (fun _ -> R.ghost_free gr)
+
+let share
+  r
+= RST.share r.reveal
+
+let gather
+  p1 r
+= RST.gather p1 r.reveal
diff --git a/ulib/experimental/Steel.ST.GhostHigherReference.fsti b/ulib/experimental/Steel.ST.GhostHigherReference.fsti
new file mode 100644
index 00000000000..0112373a5a2
--- /dev/null
+++ b/ulib/experimental/Steel.ST.GhostHigherReference.fsti
@@ -0,0 +1,125 @@
+(*
+   Copyright 2021 Microsoft Research
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+*)
+
+module Steel.ST.GhostHigherReference
+open FStar.Ghost
+open Steel.ST.Util
+
+/// The main ref type.
+///
+/// It's in universe zero, so refs can be stored in the heap, you can
+/// have [ref (ref a)] etc.
+[@@erasable]
+val ref ([@@@ strictly_positive] a:Type u#1)
+  : Type0
+
+/// The main representation predicate
+///
+/// Both the permissions [p] and the value [v] are marked with the
+/// [smt_fallback] attribute. This allows the Steel unifier to produce
+/// equality goals discharged by SMT to relate instances of the
+/// [pts_to] predicate that differ on the [p] and [v] arguments.
+///
+/// For instance, [pts_to r (sum_perm (half_perm p) (half_perm p)) (v + 1)]
+/// is unifiable with [pts_to r p (1 + v)]
+val pts_to (#a:Type)
+           (r:ref a)
+           ([@@@smt_fallback] p:perm)
+           ([@@@smt_fallback] v:a)
+  : vprop
+
+/// Lemmas to break the abstraction, if one needs to manipulate both
+/// ghost and non-ghost references. These lemmas have no SMT patterns
+/// so that the normalizer or SMT won't silently unfold the
+/// definitions of ref or pts_to. These should be
+/// harmless since ref is erasable
+val reveal_ref (#a: Type u#1) (r: ref a) : GTot (Steel.ST.HigherReference.ref a)
+
+val hide_ref (#a: Type u#1) (r: Steel.ST.HigherReference.ref a) : Pure (ref a)
+  (requires True)
+  (ensures (fun r' -> reveal_ref r' == r))
+
+val hide_reveal_ref (#a: Type u#1) (r: ref a) : Lemma
+  (hide_ref (reveal_ref r) == r)
+
+val reveal_pts_to
+  (#a: _) (r: ref a) (p: perm) (x: a)
+: Lemma
+  (pts_to r p x `equiv` Steel.ST.HigherReference.pts_to (reveal_ref r) p x)
+
+/// A reference can point to at most one value
+val pts_to_injective_eq (#a: Type)
+                        (#opened:inames)
+                        (#p0 #p1:perm)
+                        (#v0 #v1: a)
+                        (r: ref a)
+  : STGhost unit opened
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r p0 v0 `star` pts_to r p1 v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+                    
+/// Allocating a reference returns full-permission to a non-null
+/// reference pointing to the initializer [x].
+///
+/// We do not model memory exhaustion
+val alloc (#opened: _) (#a:Type) (x:a)
+  : STGhost (ref a) opened
+      emp 
+      (fun r -> pts_to r full_perm x)
+      (requires True)
+      (ensures fun r -> True)
+
+/// Writes value `x` in the reference `r`, as long as we have full
+/// ownership of `r`
+val write (#opened: _) (#a:Type)
+          (#v:erased a)
+          (r:ref a)
+          (x:a)
+  : STGhostT unit opened
+      (pts_to r full_perm v)
+      (fun _ -> pts_to r full_perm x)
+
+/// Frees reference [r], as long as we have full ownership of [r]
+val free (#opened: _) (#a:Type)
+         (#v:erased a)
+         (r:ref a)
+  : STGhostT unit opened
+    (pts_to r full_perm v) (fun _ -> emp)
+
+/// Splits the permission on reference [r] into two. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val share (#a:Type)
+          (#uses:_)
+          (#p:perm)
+          (#v:erased a)
+          (r:ref a)
+  : STGhostT unit uses
+      (pts_to r p v)
+      (fun _ -> pts_to r (half_perm p) v `star` pts_to r (half_perm p) v)
+
+/// Combines permissions on reference [r]. This function is
+/// computationally irrelevant (it has effect SteelGhost)
+val gather (#a:Type)
+           (#uses:_) 
+           (#p0 p1:perm)
+           (#v0 #v1:erased a)
+           (r:ref a)
+  : STGhost unit uses
+      (pts_to r p0 v0 `star` pts_to r p1 v1)
+      (fun _ -> pts_to r (sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)

From 083877d7617e602d8d136e3a115a2dc972fa92e9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Feb 2023 10:52:02 -0800
Subject: [PATCH 404/513] make ref_focus Tot (it's a model anyway)

---
 ulib/experimental/Steel.C.Model.Ref.Base.fsti | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Ref.Base.fsti b/ulib/experimental/Steel.C.Model.Ref.Base.fsti
index 164b5d525ee..e1e2c304c95 100644
--- a/ulib/experimental/Steel.C.Model.Ref.Base.fsti
+++ b/ulib/experimental/Steel.C.Model.Ref.Base.fsti
@@ -25,11 +25,13 @@ let ref (a: Type u#0) (#b: Type u#b) (q: pcm b) : Type u#b =
 
 (** Given a reference to an element of PCM p and a connection l from p to q,
     [ref_focus r l] is a reference to an element of q. The intuition is that
-    q represents a "part of" p (e.g. a struct field, union case, or array slice). *)
+    q represents a "part of" p (e.g. a struct field, union case, or array slice).
+    This is a model, so we do not need to worry about ghost vs. pure
+ *)
 val ref_focus
   (#a:Type) (#b:Type) (#c:Type) (#p: pcm b)
   (r: ref a p) (#q: pcm c) (l: connection p q)
-: GTot (ref a q)
+: Tot (ref a q)
 
 val ref_focus_id
   (#a:Type) (#b:Type) (#p: pcm b)

From d773a16bee99002ce364807e1b35013e773fb42f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Feb 2023 15:57:14 -0800
Subject: [PATCH 405/513] structs and unions

---
 ulib/experimental/Steel.C.Types.fst  | 491 +++++++++++++++++----------
 ulib/experimental/Steel.C.Types.fsti |  21 +-
 2 files changed, 319 insertions(+), 193 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index dd1f9535307..c01916bf157 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -991,7 +991,7 @@ let ghost_struct_field'
   (#v: Ghost.erased (struct_t1 fields))
   (r: ref (struct1 fields))
   (field: field_t)
-: SteelGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+: ST.STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
     (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
 = ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
@@ -1021,97 +1021,89 @@ let ghost_struct_field
 = noop (); // FIXME: WHY WHY WHY? (same as ghost_struct_field_focus above)
   ghost_struct_field' r field
 
-(*
-
-let ghost_struct_field
-  #_ #tn #_ #n #fields #v r field
-= let tok' = TD.get_token (fields.fd_type field) in
-  let r' : ref (fields.fd_typedef field) = Some ({
-    dest = tok';
-    typedef = fields.fd_typedef field;
-    ref = R.ref_focus (Some?.v r).ref (S.struct_field (struct_field_pcm (fd_gen_of_nonempty_fd fields)) field);
-  })
-  in
-  let gr' = Ghost.hide r' in
-  ghost_struct_field_focus r field gr';
-  gr'
-
-[@@noextract_to "krml"] // primitive
 let struct_field'
-  (#tn: Type0)
-  (#tf: Type0)
-  (#opened: _)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r0: ref (struct0 tn n fields))
-  (field: field_t fields)
-: SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
-    (pts_to r0 v)
-    (fun r' -> pts_to r0 (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ -> has_struct_field r0 field r')
-= let r : R.ref (struct_pcm _) = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
-  let prf
-    (f': field_t fields)
-    (x: (fields.fd_type f'))
-  : Lemma
-    (let p = (fields.fd_typedef f').pcm in
-      composable p x (one p) /\
-      op p x (one p) == x
-    )
-  = is_unit (fields.fd_typedef f').pcm x
-  in
-  Classical.forall_intro_2 prf;
-  let v' = Ghost.hide (struct_set_field field (unknown (fields.fd_typedef field)) v) in
-  let vf = Ghost.hide (S.field_to_struct_f (struct_field_pcm _) field (struct_get_field v field)) in
-  assert (composable (struct_pcm _) v' vf);
-  assert (op (struct_pcm _) v' vf `FX.feq` v);
-  R.split r _ v' vf;
-  let r' = R.focus r (S.struct_field (struct_field_pcm _) field) vf (struct_get_field v field) in
-  let tok' = TD.get_token (fields.fd_type field) in
-  let res : ref (fields.fd_typedef field) = Some ({
-    dest = tok';
-    typedef = fields.fd_typedef field;
-    ref = r';
-  })
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+: ST.STT (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = HR.read r in
+  ST.vpattern_rewrite (HR.pts_to r _) w;
+  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
+  }
   in
-  rewrite_slprop
-    (R.pts_to r _)
-    (pts_to r0 _)
-    (fun _ -> ());
-  rewrite_slprop
-    (R.pts_to _ _)
-    (pts_to res _)
-    (fun _ -> ());
-  return res
+  let r' = HR.alloc w' in
+  hr_share r;
+  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  ghost_struct_field_focus' r field r';
+  ST.return r'
 
 let struct_field0
-  t' r field td'
-=
-  let r' = struct_field' r field in
-  let res : ref td' = r' in
-  change_equal_slprop (pts_to r' _) (pts_to res _);
-  return res
-
-let unstruct_field
-  #_ #tn #_ #n #fields #v r0 field #v' r'0
-= let r : R.ref (struct_pcm _) = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
-  let r' : R.ref (fields.fd_typedef field).pcm = (Some?.v r'0).ref in
-  rewrite_slprop
-    (pts_to r'0 v')
-    (R.pts_to r' v')
-    (fun _ -> ());
+  t' #_ #_ #v r field td'
+= let r1' = struct_field' r field in
+  let r' : ref td' = r1' in
+  ST.rewrite (pts_to r1' _) (pts_to r' (struct_get_field v field));
+  ST.rewrite (has_struct_field1 _ _ _) (has_struct_field r field r');
+  ST.return r'
+
+let r_unfocus (#opened:_)
+  (#ta #ta' #tb #tc: Type)
+  (#p: pcm tb)
+  (#q: pcm tc)
+  (r: R.ref ta q) (r': R.ref ta' p)
+  (l: Steel.C.Model.Connection.connection p q) (x: tc)
+: ST.STGhost (Ghost.erased tb) opened
+    (r `R.pts_to` x)
+    (fun x' -> r' `R.pts_to` x')
+    (requires
+      ta == ta' /\
+      r == R.ref_focus r' l)
+    (ensures fun x' -> Ghost.reveal x' == l.conn_small_to_large.morph x)
+= let r1 : R.ref ta' q = r in
+  ST.rewrite (r `R.pts_to` x) (r1 `R.pts_to` x);
+  RST.unfocus r1 r' l x;
+  let x' = ST.vpattern_replace_erased (R.pts_to r') in
+  x'
+
+let unstruct_field'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: ST.STGhost unit opened
+    (has_struct_field1 r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field v' v))
+    (
+      t_struct_get_field v field == unknown (fields.fd_typedef field)
+    )
+    (fun _ -> True)
+= ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  let w' = ST.vpattern_replace (HR.pts_to r' _) in
+  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  ST.rewrite (r_pts_to _ (Ghost.reveal v)) (R.pts_to w.ref (Ghost.reveal v));
+  ST.weaken (pts_to r' v') (pts_to0 r' v') (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w' r';
+  ST.rewrite (r_pts_to _ (Ghost.reveal v')) (R.pts_to w'.ref (Ghost.reveal v'));
   let prf
-    (f': field_t fields)
+    (f': field_t)
     (x: (fields.fd_type f'))
   : Lemma
     (let p = (fields.fd_typedef f').pcm in
@@ -1123,15 +1115,16 @@ let unstruct_field
   Classical.forall_intro_2 prf;
   let vf = S.field_to_struct_f (struct_field_pcm _) field v' in
   assert (composable (struct_pcm _) v vf);
-  assert (op (struct_pcm _) v vf `FX.feq` struct_set_field field v' v);
-  R.unfocus r' r (S.struct_field (struct_field_pcm _) field) _;
-  R.gather r v _;
-  rewrite_slprop
-    (R.pts_to r _)
-    (pts_to r0 _)
-    (fun _ -> ())
+  assert (op (struct_pcm _) v vf `FX.feq` t_struct_set_field field v' v);
+  let _ = r_unfocus w'.ref w.ref (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
+  let _ = RST.gather w.ref (Ghost.reveal v) _ in
+  hr_share r;
+  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  ST.weaken (pts_to0 r _) (pts_to r _) (fun _ -> ())
 
-#pop-options
+let unstruct_field
+  r field r'
+= unstruct_field' r field r'
 
 let fractionable_struct _ = ()
 let mk_fraction_struct _ _ _ = ()
@@ -1406,80 +1399,170 @@ let full_union
 = Classical.move_requires (U.exclusive_union_intro (union_field_pcm fields) s) (Some field);
   Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
 
+let has_union_field_gen
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref0_v (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref0_v (fields.fd_typedef field))
+: GTot prop
+= r'.base == r.base /\
+  r'.ref == R.ref_focus r.ref (U.union_field (union_field_pcm fields) (Some field))
+
+[@@__reduce__]
+let has_union_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= ST.exists_ (fun p -> ST.exists_ (fun w -> ST.exists_ (fun p' -> ST.exists_ (fun w' ->
+    HR.pts_to r p w `star`
+    HR.pts_to r' p' w' `star`
+    ST.pure (has_union_field_gen w field w')
+  ))))
+
 let has_union_field
-  #_ #_ #_ #fields r field r'
-= (Some?.v r').ref == R.ref_focus (Some?.v r).ref (U.union_field (union_field_pcm fields) (Some field))
+  r field r'
+= has_union_field0 r field r'
+
+#push-options "--split_queries"
+
+let has_union_field_dup
+  r field r'
+= ST.rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = ST.gen_elim () in
+  hr_share r;
+  hr_share r';
+  ST.noop ();
+  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
+  ST.noop ();
+  ST.rewrite (has_union_field0 r field r') (has_union_field r field r')
+
+#push-options "--z3rlimit 16"
 
 let has_union_field_inj
-  #_ #_ #_ #fields r field r1 r2
-= TD.type_of_token_inj (Some?.v r1).dest (Some?.v r2).dest
+  r field r1 r2
+= ST.rewrite (has_union_field r field r1) (has_union_field0 r field r1);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  ST.rewrite (has_union_field r field r2) (has_union_field0 r field r2);
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  hr_share r;
+  hr_share r1;
+  ST.rewrite (has_union_field0 r field r1) (has_union_field r field r1);
+  hr_share r2;
+  ST.rewrite (has_union_field0 r field r2) (has_union_field r field r2);
+  let w' = ST.vpattern_replace (HR.pts_to r1 _) in
+  ST.vpattern_rewrite (HR.pts_to r2 _) w';
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+#pop-options
+
+let has_union_field_equiv_from
+  r1 r2 field r'
+= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  ST.rewrite (has_union_field r1 field r') (has_union_field0 r1 field r');
+  let _ = ST.gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  ST.rewrite (has_union_field0 r2 field r') (has_union_field r2 field r');
+  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let has_union_field_equiv_to
+  r field r1' r2'
+= ST.rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  ST.rewrite (has_union_field r field r1') (has_union_field0 r field r1');
+  let _ = ST.gen_elim () in
+  hr_gather w r1';
+  hr_share r2';
+  ST.rewrite (has_union_field0 r field r2') (has_union_field r field r2');
+  ST.rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
 
 #push-options "--z3rlimit 16"
 
 #restart-solver
+
 let ghost_union_field_focus
-  #_ #tn #_ #n #fields #v r0 field r'0
-= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
+  #_ #tn #_ #n #fields #v r field r'
+= ST.rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  let w' = ST.vpattern_replace (HR.pts_to r' _) in
+  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather w r;
+  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
   let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
   assert (v' `FX.feq` v);
-  R.gfocus r (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
-  rewrite_slprop
-    (R.pts_to _ _)
-    (pts_to r'0 _)
-    (fun _ -> ())
+  RST.gfocus w.ref (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
+  ST.rewrite (R.pts_to _ _) (R.pts_to w'.ref (union_get_field v field));
+  hr_share r';
+  ST.weaken (pts_to0 r' _) (pts_to r' _) (fun _ -> ());
+  ST.rewrite (has_union_field0 r field r') (has_union_field r field r')
 
 let ghost_union_field
   #_ #tn #_ #n #fields #v r field
-= let tok' = TD.get_token (fields.fd_type field) in
-  let r' : ref (fields.fd_typedef field) = Some ({
-    dest = tok';
-    typedef = fields.fd_typedef field;
-    ref = R.ref_focus (Some?.v r).ref (U.union_field (union_field_pcm fields) (Some field));
-  })
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
+  }
   in
-  let gr' = Ghost.hide r' in
-  ghost_union_field_focus r field gr';
-  gr'
+  let gr' = GHR.alloc w' in
+  let r1' = GHR.reveal_ref gr' in
+  GHR.reveal_pts_to gr' P.full_perm w';
+  ST.rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  HR.pts_to_not_null r1';
+  let r' = Ghost.hide r1' in
+  ST.rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  hr_share r;
+  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
+  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  ghost_union_field_focus r field r';
+  r'
 
 [@@noextract_to "krml"] // primitive
 let union_field'
   (#tn: Type0)
   (#tf: Type0)
-  (#opened: _)
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (union_t0 tn n fields))
-  (r0: ref (union0 tn n fields))
+  (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: SteelAtomicBase (ref (fields.fd_typedef field)) false opened Unobservable
-    (pts_to r0 v)
-    (fun r' -> pts_to r' (union_get_field v field))
-    (fun _ -> Ghost.reveal (mem_inv opened _inv) == false)
-    (fun _ r' _ -> has_union_field r0 field r')
-= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
-  let v' = Ghost.hide (U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field)) in
-  assert (v' `FX.feq` v);
-  let r' = R.focus r (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field) in
-  let tok' = TD.get_token (fields.fd_type field) in
-  let res : ref (fields.fd_typedef field) = Some ({
-    dest = tok';
-    typedef = fields.fd_typedef field;
-    ref = r';
-  })
+: SteelT (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = HR.read r in
+  ST.vpattern_rewrite (HR.pts_to r _) w;
+  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
+  }
   in
-  rewrite_slprop
-    (R.pts_to _ _)
-    (pts_to res _)
-    (fun _ -> ());
-  return res
+  let r' = HR.alloc w' in
+  hr_share r;
+  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
+  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  ghost_union_field_focus r field r';
+  ST.return r'
 
 let union_field0
   t' r field td'
@@ -1487,21 +1570,31 @@ let union_field0
   let r' = union_field' r field in
   let res : ref td' = r' in
   change_equal_slprop (pts_to r' _) (pts_to res _);
+  ST.rewrite (has_union_field r field _) (has_union_field r field res);
   return res
 
+#pop-options
+
+
+#push-options "--z3rlimit 32"
+
+#restart-solver
+
 let ununion_field
-  #_ #tn #_ #n #fields r0 field #v' r'0
-= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
-  let r' : R.ref (fields.fd_typedef field).pcm = (Some?.v r'0).ref in
-  rewrite_slprop
-    (pts_to r'0 v')
-    (R.pts_to r' v')
-    (fun _ -> ());
-  R.unfocus r' r (U.union_field (union_field_pcm fields) (Some field)) _;
-  rewrite_slprop
-    (R.pts_to r _)
-    (pts_to r0 _)
-    (fun _ -> ())
+  #_ #tn #_ #n #fields r field #v' r'
+= ST.rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  let w' = ST.vpattern_replace (HR.pts_to r' _) in
+  ST.weaken (pts_to r' v') (pts_to0 r' v') (fun _ -> ());
+  let _= ST.gen_elim () in
+  hr_gather w' r';
+  ST.rewrite (r_pts_to _ _) (R.pts_to w'.ref (Ghost.reveal v'));
+  let _ = r_unfocus w'.ref w.ref (coerce_eq () (U.union_field (union_field_pcm fields) (Some field))) _ in
+  hr_share r;
+  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
+  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
+  ST.admit_ ()
 
 [@@noextract_to "krml"] // primitive
 let union_switch_field'
@@ -1510,37 +1603,77 @@ let union_switch_field'
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (union_t0 tn n fields))
-  (r0: ref (union0 tn n fields))
+  (r: ref (union0 tn n fields))
   (field: field_t fields)
 : Steel (ref (fields.fd_typedef field))
-    (pts_to r0 v)
-    (fun r' -> pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
     (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> has_union_field r0 field r')
-= let r : R.ref (union_pcm tn n fields) = (Some?.v r0).ref in
-  rewrite_slprop
-    (pts_to r0 v)
-    (R.pts_to r v)
-    (fun _ -> ());
-  let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
-  R.ref_upd r _ _ (R.base_fpu (union_pcm tn n fields) _ v');
-  rewrite_slprop
-    (R.pts_to _ _)
-    (pts_to r0 v')
-    (fun _ -> ());
-  let r' = union_field' r0 field in
-  return r'
+    (fun _ r' _ -> True)
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = HR.read r in
+  ST.vpattern_rewrite (HR.pts_to r _) w;
+  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let v' : union_t0 tn n fields = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
+  RST.ref_upd w.ref _ _ (R.base_fpu (union_pcm tn n fields) _ v');
+  ST.weaken (pts_to0 r v') (pts_to r v') (fun _ -> ());
+  let r' = union_field' r field in
+  ST.rewrite (pts_to r' _) (pts_to r' (uninitialized (fields.fd_typedef field)));
+  ST.return r'
+
+#pop-options
+
+[@@noextract_to "krml"] // primitive
+let union_switch_field1'
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+: ST.ST (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
+    (full (union0 tn n fields) v)
+    (fun _ -> True)
+= STC.coerce_steel (fun _ -> union_switch_field' r field)
+
+[@@noextract_to "krml"] // primitive
+let union_switch_field0'
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (td': typedef t')
+  (sq: squash (
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  ))
+: ST.ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+    (pts_to r v)
+    (fun r' -> has_union_field r field (coerce_eq () r') `star` pts_to r' (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))))
+    (full (union0 tn n fields) v)
+    (fun _ -> True)
+= let r' = union_switch_field1' #tn #tf #n #fields #v r field in
+  let res : ref td' = r' in
+  ST.rewrite (pts_to r' _) (pts_to res (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))));
+  ST.rewrite (has_union_field r field _) (has_union_field r field (coerce_eq () res));
+  ST.return res
 
 let union_switch_field0
   t' r field td'
-=
-  let r' = union_switch_field' r field in
-  let res : ref td' = r' in
-  change_equal_slprop (pts_to r' _) (pts_to res _);
-  return res
+= union_switch_field0' t' r field td' ()
 
 #pop-options
 
+(*
+
 /// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
 
 module A = Steel.C.Model.Array
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index f082a5b60fa..c5ab5babd8b 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -583,14 +583,11 @@ val ghost_struct_field
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
 
-(*
-
 [@@noextract_to "krml"] // primitive
 val struct_field0
   (#tn: Type0)
   (#tf: Type0)
   (t': Type0)
-  (#opened: _)
   (#n: string)
   (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
@@ -600,7 +597,7 @@ val struct_field0
     t' ==  fields.fd_type field /\
     td' == fields.fd_typedef field
   })
-: SteelAtomicBase (ref td') false opened Unobservable
+: Steel (ref td')
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
     (fun _ -> True)
@@ -610,13 +607,12 @@ inline_for_extraction [@@noextract_to "krml"] // primitive
 let struct_field
   (#tn: Type0)
   (#tf: Type0)
-  (#opened: _)
   (#n: string)
   (#fields: nonempty_field_description_t tf)
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
+: Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field) `star` has_struct_field r field r')
     (fun _ -> True)
@@ -963,7 +959,6 @@ val union_field0
   (#tn: Type0)
   (#tf: Type0)
   (t': Type0)
-  (#opened: _)
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (union_t0 tn n fields))
@@ -973,7 +968,7 @@ val union_field0
     t' ==  fields.fd_type field /\
     td' == fields.fd_typedef field
   })
-: SteelAtomicBase (ref td') false opened Unobservable
+: Steel (ref td')
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
     (fun _ -> True)
@@ -983,13 +978,12 @@ inline_for_extraction [@@noextract_to "krml"] // primitive
 let union_field
   (#tn: Type0)
   (#tf: Type0)
-  (#opened: _)
   (#n: string)
   (#fields: field_description_t tf)
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: SteelAtomicBase (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) false opened Unobservable
+: Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
     (fun _ -> True)
@@ -1058,6 +1052,7 @@ let union_switch_field
 
 module SZ = FStar.SizeT
 
+(*
 // To be extracted as: t[tn]
 // Per the C standard, base array types must be of nonzero size
 inline_for_extraction [@@noextract_to "krml"]
@@ -1579,14 +1574,13 @@ val ghost_array_cell
 
 [@@noextract_to "krml"] // primitive
 val array_ref_cell
-  (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (#s: Ghost.erased (Seq.seq t))
   (a: array_ref td)
   (len: array_len_t a)
   (i: SZ.t)
-: SteelAtomicBase (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len }) false opened Unobservable
+: Steel (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len })
     (array_pts_to (| a, len |) s)
     (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell (| a, len |) i r)
     (fun _ ->
@@ -1596,13 +1590,12 @@ val array_ref_cell
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_cell
-  (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: SteelAtomicBase (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) false opened Unobservable
+: Steel (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
     (array_pts_to a s)
     (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
     (fun _ ->

From fa82ba6ea5eb60ef7356c5ecbdaab62386b3a918 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 1 Mar 2023 16:32:45 -0800
Subject: [PATCH 406/513] define arrays

---
 ulib/experimental/Steel.C.Types.fst  | 255 ++++++++++++++++++++++-----
 ulib/experimental/Steel.C.Types.fsti |   4 +-
 2 files changed, 209 insertions(+), 50 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index c01916bf157..5a682684b82 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -1672,27 +1672,35 @@ let union_switch_field0
 
 #pop-options
 
-(*
 
 /// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
 
 module A = Steel.C.Model.Array
 
-let base_array_t t _ n = A.array_pcm_carrier t n
+let base_array_t'
+  (t: Type0)
+  (n: Ghost.erased array_size_t)
+: Tot Type0
+= A.array_pcm_carrier t (Ghost.hide (Ghost.reveal n))
+
+let base_array_t t _ n = base_array_t' t n
 
 [@@noextract_to "krml"] // proof-only
 let base_array_fd
   (#t: Type)
   (td: typedef t)
-  (n: array_size_t)
+  (n: Ghost.erased array_size_t)
 : Tot (field_description_gen_t (base_array_index_t n))
 = {
     fd_nonempty = (let _ : base_array_index_t n = 0sz in ());
-    fd_type = A.array_range t n;
+    fd_type = A.array_range t (Ghost.hide (Ghost.reveal n));
     fd_typedef = (fun _ -> td);
   }
 
-let base_array0 tn td n = struct1 (base_array_fd td n)
+[@@noextract_to "krml"]
+let base_array1 (#t: Type0) (td: typedef t) (n: Ghost.erased array_size_t) : Tot (typedef (base_array_t' t n)) = struct1 (base_array_fd td n)
+
+let base_array0 tn td n = base_array1 td n
 
 let base_array_index a i = a i
 
@@ -1714,89 +1722,240 @@ let base_array_index_uninitialized tn n td i = ()
 
 let base_array_index_full td x = ()
 
-let has_base_array_cell #_ #_ #n #td r i r' =
-  SZ.v i < SZ.v n /\
-  has_struct_field_gen (base_array_fd td n) r i r'
+let base_array_index_t' (n: Ghost.erased array_size_t) : Tot eqtype =
+  A.array_domain (Ghost.hide (Ghost.reveal n))
+
+let base_array_index_t'_eq
+  (n: array_size_t)
+: Lemma
+  (base_array_index_t n == base_array_index_t' n)
+  [SMTPat (base_array_index_t n)]
+= // syntactic equality of refinement types
+  assert (base_array_index_t n == base_array_index_t' n) by (FStar.Tactics.trefl ())
+
+let array_as_field_marker
+  (n: Ghost.erased array_size_t)
+  (i: SZ.t)
+  (j: base_array_index_t' n)
+: Tot (base_array_index_t' n)
+= j
+
+#set-options "--print_implicits"
+
+let base_array1_eq
+  (#t: Type)
+  (n: Ghost.erased array_size_t)
+  (td: typedef t)
+: Lemma
+  (ref (base_array1 td n) == ref (struct1 #(base_array_index_t' n) (base_array_fd td n)))
+//  [SMTPat (ref (base_array1 td n))]
+= () // assert (ref (base_array1 td n) == ref (struct1 #(base_array_index_t' n) (base_array_fd td n))) by (FStar.Tactics.trefl ())
+
+[@@__reduce__]
+let has_base_array_cell_as_struct_field0
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (j: base_array_index_t' n)
+  (r': ref td)
+: Tot vprop
+= has_struct_field1 #(base_array_index_t' n) #(base_array_fd td n) r (array_as_field_marker n i j) r'
+
+let has_base_array_cell_as_struct_field
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (j: base_array_index_t' n)
+  (r': ref td)
+: Tot vprop
+= has_base_array_cell_as_struct_field0 r i j r'
+
+[@@__reduce__]
+let has_base_array_cell0
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: Tot vprop
+= ST.exists_ (fun j ->
+    has_base_array_cell_as_struct_field r i j r' `star`
+    ST.pure (i == j)
+  )
+
+let has_base_array_cell1
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: Tot vprop
+= has_base_array_cell0 r i r'
+
+let has_base_array_cell
+  r i r'
+= has_base_array_cell0 r i r'
+
+let has_base_array_cell_dup'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: ST.STGhostT unit opened
+    (has_base_array_cell1 r i r')
+    (fun _ -> has_base_array_cell1 r i r' `star` has_base_array_cell1 r i r')
+= ST.rewrite (has_base_array_cell1 r i r') (has_base_array_cell0 r i r');
+  let _ = ST.gen_elim () in
+  has_struct_field_dup'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ _;
+  ST.rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r');
+  ST.noop ();
+  ST.rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r')
+
+let has_base_array_cell_dup
+  r i r'
+= has_base_array_cell_dup' r i r'
+
+let has_base_array_cell_inj'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: ST.STGhostT unit opened
+    (has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2)
+    (fun _ -> has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
+= ST.rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
+  let _ = ST.gen_elim () in
+  let j = ST.vpattern_replace (fun j -> has_base_array_cell_as_struct_field r i j _) in
+  ST.rewrite (has_base_array_cell1 r i r2) (has_base_array_cell0 r i r2);
+  let _ = ST.gen_elim () in
+  ST.vpattern_rewrite (fun j' -> has_base_array_cell_as_struct_field r i j _ `star` has_base_array_cell_as_struct_field r i j' _) j;
+  has_struct_field_inj' #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ r1 r2;
+  ST.rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2);
+  ST.rewrite (has_base_array_cell0 r i r1) (has_base_array_cell1 r i r1)
 
 let has_base_array_cell_inj
-  #_ #_ #_ #n #td r i r1 r2
-= has_struct_field_gen_inj (base_array_fd td n) r i r1 r2
+  r i r1 r2
+= has_base_array_cell_inj' r i r1 r2
+
+let has_base_array_cell_equiv_from'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r1 r2: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: ST.STGhostT unit opened
+    (has_base_array_cell1 r1 i r' `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell1 r2 i r' `star` ref_equiv r1 r2)
+= ST.rewrite (has_base_array_cell1 r1 i r') (has_base_array_cell0 r1 i r');
+  let _ = ST.gen_elim () in
+  has_struct_field_equiv_from'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r1) _ r' (r2);
+  ST.rewrite (has_base_array_cell0 r2 i r') (has_base_array_cell1 r2 i r')
+
+let has_base_array_cell_equiv_from
+  r1 r2 i r'
+= has_base_array_cell_equiv_from' r1 r2 i r'
+
+let has_base_array_cell_equiv_to'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: ST.STGhostT unit opened
+    (has_base_array_cell1 r i r1 `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
+= ST.rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
+  let _ = ST.gen_elim () in
+  has_struct_field_equiv_to' r _ r1 r2;
+  ST.rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2)
+
+let has_base_array_cell_equiv_to
+  r i r1 r2
+= has_base_array_cell_equiv_to' r i r1 r2
 
 /// Array pointers (with decay)
 
 noeq
 type array_ref #t td = {
-  ar_base_size_token: TD.token;
   ar_base_size: Ghost.erased array_size_t;
-  ar_base: ref (base_array0 #t (TD.type_of_token ar_base_size_token) td ar_base_size);
+  ar_base: ref (base_array1 #t td ar_base_size);
   ar_offset: base_array_index_t ar_base_size;
 }
-let array_ref_base_size_type ar = TD.type_of_token ar.ar_base_size_token
 let array_ref_base_size ar = ar.ar_base_size
-let array_ref_base ar = ar.ar_base
+let has_array_ref_base ar r = ar.ar_base == r
+let has_array_ref_base_inj ar r1 r2 = ()
 let array_ref_offset ar = ar.ar_offset
-let array_ref_base_offset_inj a1 a2 =
-  TD.type_of_token_inj a1.ar_base_size_token a2.ar_base_size_token
+let array_ref_base_offset_inj a1 r1 a2 r2 = ()
 
-#push-options "--z3rlimit 16"
-
-#restart-solver
 let base_array_pcm_eq
   (#t: Type)
   (td: typedef t)
-  (n: array_size_t)
-  (tn: Type0)
+  (n: Ghost.erased array_size_t)
 : Lemma
-  (A.array_pcm td.pcm n == (base_array0 tn td n).pcm)
-  [SMTPat (base_array0 tn td n).pcm]
-= pcm0_ext (A.array_pcm td.pcm n) (base_array0 tn td n).pcm
+  (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n)) == (base_array1 td n).pcm)
+  [SMTPat (base_array1 td n).pcm]
+= pcm0_ext (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n))) (base_array1 td n).pcm
     (fun _ _ -> ())
     (fun x1 x2 ->
-      assert (op (A.array_pcm td.pcm n) x1 x2 `FX.feq` op (base_array0 tn td n).pcm x1 x2)
+      assert (op (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n))) x1 x2 `FX.feq` op (base_array1 td n).pcm x1 x2)
     )
     (fun _ -> ())
     ()
 
-#pop-options
-
-[@@noextract_to "krml"] // proof-only
-let coerce (#t1 t2: Type) (x1: t1) : Pure t2
-  (requires (t1 == t2))
-  (ensures (fun x2 ->
-    t1 == t2 /\
-    x1 == x2
-  ))
-= x1
-
 [@@noextract_to "krml"] // proof-only
 let model_array_of_array
   (#t: Type)
   (#td: typedef t)
   (a: array td)
-: Tot (A.array td.pcm)
+  (base: ref0_v (base_array1 td (dfst a).ar_base_size))
+: Tot (A.array base.base td.pcm)
 = let (| al, len |) = a in
   {
     base_len = Ghost.hide (Ghost.reveal al.ar_base_size);
-    base = coerce _ ((Some?.v al.ar_base).ref);
+    base = base.ref;
     offset = al.ar_offset;
     len = len;
     prf = ();
   }
 
+[@@__reduce__]
+let array_pts_to0
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: Tot vprop
+= ST.exists_ (fun br -> ST.exists_ (fun p ->
+    HR.pts_to (dfst r).ar_base p br `star`
+    A.pts_to (model_array_of_array r br) v
+  ))
+
 let array_pts_to' r v =
-  A.pts_to (model_array_of_array r) v
+  array_pts_to0 r v
 
 let array_pts_to_length r v =
-  rewrite_slprop
-    (array_pts_to _ _)
-    (A.pts_to (model_array_of_array r) v)
-    (fun _ -> ());
-  A.pts_to_length _ _;
-  rewrite_slprop
-    (A.pts_to _ _)
-    (array_pts_to _ _)
-    (fun _ -> ())
+  ST.weaken (array_pts_to r v) (array_pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let _ = A.pts_to_length _ _ in
+  ST.weaken (array_pts_to0 r v) (array_pts_to r v) (fun _ -> ())
 
+(*
 #push-options "--z3rlimit 16"
 
 let ghost_array_of_base_focus
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index c5ab5babd8b..848937c62f6 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -1052,13 +1052,12 @@ let union_switch_field
 
 module SZ = FStar.SizeT
 
-(*
 // To be extracted as: t[tn]
 // Per the C standard, base array types must be of nonzero size
 inline_for_extraction [@@noextract_to "krml"]
 let array_size_t = (n: SZ.t { SZ.v n > 0 })
 val base_array_t (t: Type0) (tn: Type0 (* using Typenat (or Typestring for `#define`d constants) *)) (n: array_size_t) : Type0
-inline_for_extraction [@@noextract_to "krml"]
+inline_for_extraction [@@noextract_to "krml"] // MUST be syntactically equal to Steel.C.Model.Array.array_domain
 let base_array_index_t (n: array_size_t) : Tot eqtype = (i: SZ.t { SZ.v i < SZ.v n })
 [@@noextract_to "krml"]
 val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: array_size_t) : Tot (typedef (base_array_t t tn n))
@@ -1293,6 +1292,7 @@ let seq_of_base_array
 : GTot (Seq.lseq t (SZ.v n))
 = Seq.init_ghost (SZ.v n) (fun i -> base_array_index v (SZ.uint_to_t i))
 
+(*
 val ghost_array_of_base_focus
   (#t: Type)
   (#tn: Type0)

From 849abfe603a41fea38cfb560429a11cadb619eec Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 1 Mar 2023 17:52:34 -0800
Subject: [PATCH 407/513] wip: need annotations on .fsti otherwise .fst fails
 to verify

---
 ulib/experimental/Steel.C.Types.fsti | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 848937c62f6..a515189590d 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -1253,6 +1253,7 @@ val array_pts_to_length
     (fun _ -> True)
     (fun _ _ _ -> Seq.length v == SZ.v (dsnd r))
 
+(*
 let has_array_of_base
   (#t: Type)
   (#tn: Type0)
@@ -1292,7 +1293,6 @@ let seq_of_base_array
 : GTot (Seq.lseq t (SZ.v n))
 = Seq.init_ghost (SZ.v n) (fun i -> base_array_index v (SZ.uint_to_t i))
 
-(*
 val ghost_array_of_base_focus
   (#t: Type)
   (#tn: Type0)

From e00be4a568aeaa92921a6234dfd739786a502d67 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 8 Mar 2023 15:02:54 -0800
Subject: [PATCH 408/513] arrays: split, join, share, gather

---
 ulib/experimental/Steel.C.Model.Array.fst |   5 +-
 ulib/experimental/Steel.C.Types.fst       | 467 +++++++++++++++++++---
 ulib/experimental/Steel.C.Types.fsti      |  85 ++--
 3 files changed, 470 insertions(+), 87 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index a78debb1e80..7b336a50da4 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -556,8 +556,7 @@ let gather
       Seq.length s1 == Seq.length s /\
       Seq.length s2 == Seq.length s /\
       (forall (i: nat) .
-        i < Seq.length s ==> (
-        composable p (Seq.index s1 i) (Seq.index s2 i) /\
+        (i < Seq.length s /\ composable p (Seq.index s1 i) (Seq.index s2 i)) ==> (
         op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
       ))
     )
@@ -566,11 +565,11 @@ let gather
   let _ = elim_pts_to r s2 in
   let a1 = array_pcm_carrier_of_seq r.len s1 in
   let a2 = array_pcm_carrier_of_seq r.len s2 in
+  let _ = R.gather _ (array_pcm_carrier_of_seq r.len s1) _ in
   assert (
     composable (array_pcm p r.len) a1 a2 /\
     op (array_pcm p r.len) a1 a2 `feq` array_pcm_carrier_of_seq r.len s
   );
-  let _ = R.gather _ (array_pcm_carrier_of_seq r.len s1) _ in
   intro_pts_to0 r _ s
 
 let sub
diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 5a682684b82..c345748d092 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -1166,6 +1166,7 @@ let full_struct_gen
 
 let full_struct s = full_struct_gen s
 
+(*
 module U = Steel.C.Model.Union
 
 let define_union0 _ _ _ = unit
@@ -1671,6 +1672,7 @@ let union_switch_field0
 = union_switch_field0' t' r field td' ()
 
 #pop-options
+*)
 
 
 /// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
@@ -1733,7 +1735,7 @@ let base_array_index_t'_eq
 = // syntactic equality of refinement types
   assert (base_array_index_t n == base_array_index_t' n) by (FStar.Tactics.trefl ())
 
-let array_as_field_marker
+let array_index_as_field_marker
   (n: Ghost.erased array_size_t)
   (i: SZ.t)
   (j: base_array_index_t' n)
@@ -1761,7 +1763,7 @@ let has_base_array_cell_as_struct_field0
   (j: base_array_index_t' n)
   (r': ref td)
 : Tot vprop
-= has_struct_field1 #(base_array_index_t' n) #(base_array_fd td n) r (array_as_field_marker n i j) r'
+= has_struct_field1 #(base_array_index_t' n) #(base_array_fd td n) r (array_index_as_field_marker n i j) r'
 
 let has_base_array_cell_as_struct_field
   (#t: Type)
@@ -1802,6 +1804,12 @@ let has_base_array_cell
   r i r'
 = has_base_array_cell0 r i r'
 
+let has_base_array_cell_post
+  r i r'
+= ST.rewrite (has_base_array_cell r i r') (has_base_array_cell0 r i r');
+  let _ = ST.gen_elim () in
+  ST.rewrite (has_base_array_cell0 r i r') (has_base_array_cell r i r')
+
 let has_base_array_cell_dup'
   (#opened: _)
   (#t: Type)
@@ -1895,7 +1903,8 @@ noeq
 type array_ref #t td = {
   ar_base_size: Ghost.erased array_size_t;
   ar_base: ref (base_array1 #t td ar_base_size);
-  ar_offset: base_array_index_t ar_base_size;
+  ar_offset: SZ.t;
+  ar_prf: squash (SZ.v ar_offset <= SZ.v ar_base_size);
 }
 let array_ref_base_size ar = ar.ar_base_size
 let has_array_ref_base ar r = ar.ar_base == r
@@ -1955,70 +1964,163 @@ let array_pts_to_length r v =
   let _ = A.pts_to_length _ _ in
   ST.weaken (array_pts_to0 r v) (array_pts_to r v) (fun _ -> ())
 
-(*
 #push-options "--z3rlimit 16"
+#restart-solver
 
 let ghost_array_of_base_focus
-  #_ #tn #_ #n #td #v r a
-= let mr : R.ref (A.array_pcm td.pcm n) = coerce _ (Some?.v r).ref in
-  let m : A.array td.pcm = {
-    base_len = Ghost.hide n;
-    base = mr;
-    offset = 0sz;
-    len = n;
-    prf = ();
-  }
-  in
-  rewrite_slprop (pts_to r v) (R.pts_to m.base v) (fun _ -> ());
+  #_ #_ #_ #_ #td #v r a
+= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = ST.vpattern_replace (HR.pts_to r _) in
+  let w' : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () w in
+  assert ((model_array_of_array a w').base == w.ref);
+  ST.rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
   assert (seq_of_base_array v `Seq.equal` A.seq_of_array_pcm_carrier v);
   A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
-  A.pts_to_intro_from_base m v (seq_of_base_array v);
-  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ())
+  A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array v);
+  let p = ST.vpattern_replace (fun p -> HR.pts_to _ p _) in
+  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
+  ST.weaken (array_pts_to0 a (seq_of_base_array v)) (array_pts_to a (seq_of_base_array v)) (fun _ -> ())
 
 #pop-options
 
 let ghost_array_of_base
   #_ #tn #_ #n #td #v r
-= let tok = TD.get_token tn in
-  let ar : array_ref td = {
-    ar_base_size_token = tok;
-    ar_base_size = Ghost.hide (n <: SZ.t);
+=
+  let al : array_ref td = {
+    ar_base_size = n;
     ar_base = r;
     ar_offset = 0sz;
+    ar_prf = ();
   }
   in
-  let res : (a: Ghost.erased (array td)  { has_array_of_base r a }) = Ghost.hide (| ar, Ghost.hide n |) in
-  ghost_array_of_base_focus r res;
-  res
+  let a : (a: Ghost.erased (array td) { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
+  ghost_array_of_base_focus r a;
+  a
 
-let array_ref_of_base
-  #_ #tn #_ #n #td #v r
-= let tok = TD.get_token tn in
-  let ar : array_ref td = {
-    ar_base_size_token = tok;
-    ar_base_size = Ghost.hide (n <: SZ.t);
+[@@noextract_to "krml"] // primitive
+let array_of_base0
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: SteelAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to a (seq_of_base_array v))
+    (fun _ -> True)
+    (fun _ _ _ -> True)
+=
+  let al : array_ref td = {
+    ar_base_size = n;
     ar_base = r;
     ar_offset = 0sz;
+    ar_prf = ();
   }
   in
-  ghost_array_of_base_focus r (| ar, Ghost.hide n |);
-  return ar
+  let a : (a: array td { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
+  ghost_array_of_base_focus r a;
+  ST.return a
+
+let array_ref_of_base
+  #_ #tn #_ #n #td #v r
+= let ar : array td = array_of_base0 r in
+  let a : array_ref td = dfst ar in
+  intro_pure _;
+  intro_exists ar (fun (ar: array td) ->
+      array_pts_to ar (seq_of_base_array v) `star` pure (
+        dfst ar == a /\
+        array_ref_base_size a == Ghost.reveal n /\
+        array_ref_offset a == 0sz /\
+        has_array_of_base r ar /\
+        Ghost.reveal (dsnd ar) == Ghost.reveal n
+    ));
+  return a
 
 #push-options "--z3rlimit 16 --split_queries"
 
 #restart-solver
+
+let base_array_index' (#t: Type0) (#n: array_size_t) (a: base_array_t' t n)
+(i: base_array_index_t n) : GTot t
+= a i
+
+let seq_of_base_array0
+  (#t: Type)
+  (#n: array_size_t)
+  (v: base_array_t' t n)
+: GTot (Seq.lseq t (SZ.v n))
+= Seq.init_ghost (SZ.v n) (fun i -> base_array_index' v (SZ.uint_to_t i))
+
+let has_array_of_base'
+  (#t: Type)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (a: array td)
+: GTot prop
+=   let (| al, len |) = a in
+    array_ref_base_size al == n /\
+    al.ar_base == r /\
+    array_ref_offset al == 0sz /\
+    Ghost.reveal len == n
+
+let a_pts_to_elim_to_base
+  (#opened: _)
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (x: Seq.seq t)
+: SteelGhost (Ghost.erased (A.array_pcm_carrier t r.base_len)) opened
+    (A.pts_to r x)
+    (fun y -> r_pts_to r.base y)
+    (fun _ -> True)
+    (fun _ y _ ->
+      Seq.length x == A.size_v r.len /\
+      Ghost.reveal y == (A.ref_of_array_conn r).conn_small_to_large.morph (A.array_pcm_carrier_of_seq r.len x) /\
+      Ghost.reveal y == S.substruct_to_struct_f (A.array_elements_pcm p r.base_len) (A.array_elements_pcm p r.len) (A.small_to_large_index r.base_len r.offset r.len ()) (A.large_to_small_index r.base_len r.offset r.len ()) () (A.array_pcm_carrier_of_seq r.len x)
+    )
+= A.pts_to_elim_to_base r x
+
+let unarray_of_base0
+  (#t: Type)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (Seq.seq t))
+  (r: ref (base_array1 td n))
+  (a: array td)
+: SteelGhost (Ghost.erased (base_array_t' t n)) opened
+    (array_pts_to a v)
+    (fun v' -> pts_to r v')
+    (fun _ ->
+      has_array_of_base' r a
+    )
+    (fun _ v' _ -> Ghost.reveal v `Seq.equal` seq_of_base_array0 v')
+= ST.weaken (array_pts_to a v) (array_pts_to0 a v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let p = ST.vpattern_replace (fun p -> HR.pts_to _ p _) in
+  let ba = ST.vpattern_replace (HR.pts_to _ _) in
+  let ba' : ref0_v (base_array1 td n) = coerce_eq () ba in
+  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba');
+  let m = model_array_of_array a ba in
+  ST.rewrite (A.pts_to _ _) (A.pts_to m v);
+  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = a_pts_to_elim_to_base m v in
+  let y' : Ghost.erased (base_array_t' t n) = Ghost.hide (Ghost.reveal y) in
+  change_equal_slprop (r_pts_to _ _) (r_pts_to ba'.ref (Ghost.reveal y'));
+  ST.weaken (pts_to0 r y') (pts_to r y') (fun _ -> ());
+  y'
+
 let unarray_of_base
   #t #tn #_ #n #td #v r a
-=
-  let m = model_array_of_array a in
-  rewrite_slprop (array_pts_to _ _) (A.pts_to m v) (fun _ -> ());
-  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = A.pts_to_elim_to_base m v in
-  let y' : Ghost.erased (base_array_t t tn n) = Ghost.hide (Ghost.reveal y) in
-  rewrite_slprop (R.pts_to m.base y) (pts_to r y') (fun _ -> ());
-  y'
+= unarray_of_base0 r a
 
 #pop-options
 
+(*
 let has_array_of_ref
   r a
 = TD.type_of_token (dfst a).ar_base_size_token == unit /\
@@ -2079,21 +2181,68 @@ let array_ref_of_ref
   return res
 
 let unarray_of_ref = magic ()
+*)
 
-unfold
-let has_base_array_cell0
+[@@noextract_to "krml"]
+let array_index_as_base_array_index_marker
+  (index: SZ.t)
+  (base_index: SZ.t)
+: Tot SZ.t
+= base_index
+
+[@@__reduce__]
+let has_array_cell0
   (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
   (#td: typedef t)
-  (r: ref (base_array0 tn td n))
+  (a: array td)
   (i: SZ.t)
-  (r': ref td)
-: Ghost prop
-    (requires True)
-    (fun p -> p ==> has_base_array_cell r i r')
-= SZ.v i < SZ.v n /\
-  has_struct_field_gen (base_array_fd td n) r i r'
+  (r: ref td)
+: Tot vprop
+= ST.exists_ (fun (j: SZ.t) ->
+    has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r `star`
+    ST.pure (SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i)
+  )
+
+let has_array_cell1
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: Tot vprop
+= has_array_cell0 a i r
+
+let has_array_cell
+  a i r
+= has_array_cell0 a i r
+
+let has_array_cell_has_base_array_cell
+  a i r br
+= ST.rewrite (has_array_cell a i r) (has_array_cell0 a i r);
+  let _ = ST.gen_elim () in
+  let j = ST.vpattern_replace_erased (fun j -> has_base_array_cell1 _ j r) in
+  ST.rewrite (has_base_array_cell1 _ _ _) (has_base_array_cell br j r);
+  j
+
+let has_base_array_cell_has_array_cell
+  a i r br
+= let j : Ghost.erased SZ.t = Ghost.hide (i `SZ.sub` (dfst a).ar_offset) in
+  ST.rewrite (has_base_array_cell br i r) (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker j i) r);
+  ST.rewrite (has_array_cell0 a j r) (has_array_cell a j r);
+  j
+
+let has_array_cell_inj
+  #_ #_ #td a i r1 r2
+= let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
+  let j1 = has_array_cell_has_base_array_cell a i r1 br in
+  let j2 = has_array_cell_has_base_array_cell a i r2 br in
+  ST.vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
+  has_base_array_cell_inj br j1 r1 r2;
+  let _ = has_base_array_cell_has_array_cell a j1 r1 br in
+  ST.vpattern_rewrite (fun i -> has_array_cell _ i r1) i;
+  let _ = has_base_array_cell_has_array_cell a j1 r2 br in
+  ST.vpattern_rewrite (fun i -> has_array_cell _ i r2) i
+  
 
 #restart-solver
 let struct_field_eq_cell
@@ -2103,9 +2252,10 @@ let struct_field_eq_cell
   (k: base_array_index_t n)
 : Lemma
   (Steel.C.Model.Struct.struct_field (struct_field_pcm (base_array_fd td n)) k == A.cell td.pcm n k)
-= assert_norm (A.array_domain n == base_array_index_t n);
+= // assert_norm (A.array_domain n == base_array_index_t n);
   Steel.C.Model.Struct.struct_field_ext #(A.array_domain n) #(A.array_range t n) (struct_field_pcm (base_array_fd td n)) (A.array_elements_pcm td.pcm n) (fun _ -> ()) k
 
+(*
 #push-options "--split_queries --z3rlimit 16"
 
 #restart-solver
@@ -2121,6 +2271,7 @@ let has_array_cell_array_of_ref
   assert (has_base_array_cell0 (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` 0sz) r)
 
 #pop-options
+*)
 
 let ghost_array_cell_focus = magic ()
 
@@ -2134,14 +2285,216 @@ let array_ref_cell = magic ()
 
 let unarray_cell = magic ()
 
-let array_ref_shift = magic ()
+#push-options "--split_queries --z3rlimit 16"
+
+let t_array_ref_shift
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_ref td)
+  (i: SZ.t)
+: Pure (array_ref td)
+    (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
+    (ensures (fun y -> 
+      array_ref_base_size y == array_ref_base_size a /\
+      (forall ty r . has_array_ref_base a #ty r ==> has_array_ref_base y #ty (coerce_eq () r)) /\
+      array_ref_offset y == array_ref_offset a `SZ.add` i
+    ))
+= {
+    a with
+    ar_offset = a.ar_offset `SZ.add` i
+  }
+
+let array_ref_shift
+  a i
+= t_array_ref_shift a i
+
+let ghost_array_split
+  #_ #_ #td #s a i
+= array_pts_to_length _ _;
+  let sq : squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)) = () in
+  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let br : Ghost.erased (ref0_v (base_array1 td (dfst a).ar_base_size)) = ST.vpattern_replace_erased (HR.pts_to _ _) in
+  A.g_split _ _ i ();
+  HR.share _;
+  let p = ST.vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
+  let br_l : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_l a i)).ar_base_size)) = coerce_eq () br in
+  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_l a i)).ar_base p br_l);
+  ST.rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
+  ST.noop ();
+  ST.weaken (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (fun _ -> ());
+  let br_r : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_r a i)).ar_base_size)) = coerce_eq () br in
+  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_r a i)).ar_base p br_r);
+  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
+  ST.noop ();
+  ST.weaken (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (fun _ -> ());
+  sq
+
+let t_array_split_r
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+: Pure (array td)
+   (requires (SZ.v i <= SZ.v (dsnd a)))
+   (ensures (fun _ -> True))
+= let (| al, len |) = a in
+  (| t_array_ref_shift al i, Ghost.hide (len `SZ.sub` i) |)
+
+let array_ref_split
+  #_ #td #s al len i
+= let _ = ghost_array_split (| al, len |) i in
+  let ar: (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len}) = t_array_ref_shift al i in
+  return ar
 
-let ghost_array_split = magic ()
+let hr_gather_by_perm
+  (#opened: _)
+  (#t1: Type)
+  (#r1: HR.ref t1)
+  (#v1: t1)
+  (#t2: Type)
+  (#r2: HR.ref t2)
+  (#v2: t2)
+  (p1: P.perm)
+  (p2: P.perm)
+: ST.STGhost unit opened
+    (HR.pts_to r1 p1 v1 `star` HR.pts_to r2 p2 v2)
+    (fun _ -> HR.pts_to r1 (p1 `P.sum_perm` p2) v1)
+    (t1 == t2 /\
+      r1 == r2)
+    (fun _ ->
+      t1 == t2 /\
+      r1 == r2 /\
+      v1 == v2)
+= ST.rewrite (HR.pts_to r2 p2 v2) (HR.pts_to r1 p2 (coerce_eq () v2));
+  HR.gather p2 r1
+
+let ar_join
+  (#opened: _)
+  (#base_t #base_tl #base_tr: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (a: A.array base_t p)
+  (i: SZ.t)
+  (al: A.array base_tl p)
+  (ar: A.array base_tr p)
+  (sl0 sr0: Seq.seq t)
+: SteelGhost unit opened
+    (A.pts_to al sl0 `star` A.pts_to ar sr0)
+    (fun _ -> A.pts_to a (sl0 `Seq.append` sr0))
+    (fun _ ->
+      SZ.v i <= SZ.v a.len /\
+      base_t == base_tl /\
+      base_t == base_tr /\
+      al == A.split_l a i /\
+      ar == A.split_r a i
+    )
+    (fun _ _ _ -> True)
+= let al' : A.array base_t p = coerce_eq () al in
+  let ar' : A.array base_t p = coerce_eq () ar in
+  ST.rewrite (A.pts_to al sl0) (A.pts_to al' sl0);
+  ST.rewrite (A.pts_to ar sr0) (A.pts_to ar' sr0);
+  A.join a i al' ar' _ _
+
+let array_join
+  #_ #_ #td #sl #sr a al ar i
+= ST.weaken (array_pts_to al sl) (array_pts_to0 al sl) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let br_l : ref0_v (base_array1 td (dfst al).ar_base_size) = ST.vpattern_replace (HR.pts_to _ _) in
+  let pl = ST.vpattern_replace (fun p -> HR.pts_to _ p _) in
+  let br : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () br_l in
+  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base pl br);
+  ST.weaken (array_pts_to ar sr) (array_pts_to0 ar sr) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let pr = ST.vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
+  hr_gather_by_perm pl pr;
+  ar_join (model_array_of_array a br) i _ _ sl sr;
+  ST.weaken (array_pts_to0 a (sl `Seq.append` sr)) (array_pts_to a (sl `Seq.append` sr)) (fun _ -> ())
 
-let array_ref_split = magic ()
+let ar_share
+  (#opened: _)
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (s s1 s2: Seq.seq t)
+  (prf: (
+    (i: nat) ->
+    Lemma
+    (requires (i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2))
+    (ensures (
+      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
+      composable p (Seq.index s1 i) (Seq.index s2 i) /\
+      op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+    ))
+  ))
+: SteelGhost unit opened
+    (A.pts_to r s)
+    (fun _ -> A.pts_to r s1 `star` A.pts_to r s2)
+    (fun _ ->
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s
+    )
+    (fun _ _ _ -> True)
+= Classical.forall_intro (Classical.move_requires prf);
+  A.share r s s1 s2
 
-let array_join = magic ()
+let mk_fraction_seq_split_gen
+  #_ #_ #td r v p p1 p2
+= ST.weaken (array_pts_to r (mk_fraction_seq td v p)) (array_pts_to0 r (mk_fraction_seq td v p)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let br = ST.vpattern_replace (HR.pts_to _ _) in
+  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p));
+  ar_share _ _ (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
+    td.mk_fraction_split (Seq.index v i) p1 p2;
+    td.mk_fraction_join (Seq.index v i) p1 p2
+  );
+  HR.share _;
+  ST.weaken (array_pts_to0 r (mk_fraction_seq td v p1)) (array_pts_to r (mk_fraction_seq td v p1)) (fun _ -> ());
+  ST.weaken (array_pts_to0 r (mk_fraction_seq td v p2)) (array_pts_to r (mk_fraction_seq td v p2)) (fun _ -> ())
 
-let mk_fraction_seq_split_gen = magic ()
+let ar_gather
+  (#opened: _)
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (s s1 s2: Seq.seq t)
+  (prf: (
+    (i: nat) ->
+    Lemma
+    (requires (
+      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
+      composable p (Seq.index s1 i) (Seq.index s2 i)
+    ))
+    (ensures (
+      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
+      composable p (Seq.index s1 i) (Seq.index s2 i) /\
+      op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+    ))
+  ))
+: SteelGhost unit opened
+    (A.pts_to r s1 `star` A.pts_to r s2)
+    (fun _ -> A.pts_to r s)
+    (fun _ ->
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s
+    )
+    (fun _ _ _ -> True)
+= Classical.forall_intro (Classical.move_requires prf);
+  A.gather r s s1 s2
 
-let mk_fraction_seq_join = magic ()
+let mk_fraction_seq_join
+  #_ #_ #td r v p1 p2
+= ST.weaken (array_pts_to r (mk_fraction_seq td v p1)) (array_pts_to0 r (mk_fraction_seq td v p1)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let br = ST.vpattern_replace (HR.pts_to _ _) in
+  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
+  ST.weaken (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2)) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather br (dfst r).ar_base;
+  ST.rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
+  ar_gather _ (mk_fraction_seq td v (p1 `P.sum_perm` p2)) (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
+    td.mk_fraction_join (Seq.index v i) p1 p2
+  );
+  ST.weaken (array_pts_to0 r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (fun _ -> ())
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index a515189590d..7632fc2ef28 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -693,6 +693,7 @@ val full_struct
   (full (struct0 tn n fields) s <==> (forall field . full (fields.fd_typedef field) (struct_get_field s field)))
   [SMTPat (full (struct0 tn n fields) s)]
 
+(*
 [@@noextract_to "krml"] // primitive
 val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
 inline_for_extraction [@@noextract_to "krml"]
@@ -1049,6 +1050,7 @@ let union_switch_field
     r
     field
     (fields.fd_typedef field)
+*)
 
 module SZ = FStar.SizeT
 
@@ -1129,6 +1131,21 @@ val has_base_array_cell
   (r': ref td)
 : Tot vprop
 
+val has_base_array_cell_post
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: SteelGhost unit opened
+    (has_base_array_cell r i r')
+    (fun _ -> has_base_array_cell r i r')
+    (fun _ -> True)
+    (fun _ _ _ -> SZ.v i < SZ.v n)
+
 val has_base_array_cell_dup
   (#opened: _)
   (#t: Type)
@@ -1203,7 +1220,7 @@ val has_array_ref_base_inj (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: T
   (ensures (r1 == r2))
 val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ref td) : Ghost SZ.t
   (requires True)
-  (ensures (fun y -> SZ.v y < SZ.v (array_ref_base_size a)))
+  (ensures (fun y -> SZ.v y <= SZ.v (array_ref_base_size a)))
 val array_ref_base_offset_inj (#t: Type) (#td: typedef t) (#ty: Type) (a1: array_ref td) (r1: ref (base_array0 ty td (array_ref_base_size a1))) (a2: array_ref td) (r2: ref (base_array0 ty td (array_ref_base_size a2))) : Lemma
   (requires (
     array_ref_base_size a1 == array_ref_base_size a2 /\
@@ -1253,7 +1270,8 @@ val array_pts_to_length
     (fun _ -> True)
     (fun _ _ _ -> Seq.length v == SZ.v (dsnd r))
 
-(*
+#set-options "--print_implicits"
+
 let has_array_of_base
   (#t: Type)
   (#tn: Type0)
@@ -1264,7 +1282,7 @@ let has_array_of_base
 : GTot prop
 =   let (| al, len |) = a in
     array_ref_base_size al == n /\
-    has_array_ref_base al r /\
+    has_array_ref_base al #tn r /\
     array_ref_offset al == 0sz /\
     Ghost.reveal len == n
 
@@ -1277,13 +1295,13 @@ let has_array_of_base_inj
   (a1 a2: array td)
 : Lemma
   (requires (
-      has_array_of_base r a1 /\
-      has_array_of_base r a2
+      has_array_of_base #t #tn #n #td r a1 /\
+      has_array_of_base #t #tn #n #td r a2
   ))
   (ensures (a1 == a2))
 = let (| ar1, _ |) = a1 in
   let (| ar2, _ |) = a2 in
-  array_ref_base_offset_inj ar1 r ar2 r
+  array_ref_base_offset_inj #t #td #tn ar1 r ar2 r
 
 let seq_of_base_array
   (#t: Type)
@@ -1326,13 +1344,20 @@ val array_ref_of_base
   (#t: Type)
   (#tn: Type0)
   (#opened: _)
-  (#n: array_size_t)
+  (#n: Ghost.erased array_size_t)
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
-: SteelAtomicBase (a: array_ref td { array_ref_base_size a == n /\ array_ref_offset a == 0sz /\ has_array_of_base r (| a, Ghost.hide n |) }) false opened Unobservable
+: SteelAtomicBase (array_ref td) false opened Unobservable
     (pts_to r v)
-    (fun a -> array_pts_to (| a, Ghost.hide (n <: SZ.t) |) (seq_of_base_array v))
+    (fun a -> h_exists (fun (ar: array td) ->
+      array_pts_to ar (seq_of_base_array v) `star` pure (
+        dfst ar == a /\
+        array_ref_base_size a == Ghost.reveal n /\
+        array_ref_offset a == 0sz /\
+        has_array_of_base r ar /\
+        Ghost.reveal (dsnd ar) == Ghost.reveal n
+    )))
     (fun _ -> True)
     (fun _ _ _ -> True)
 
@@ -1341,7 +1366,7 @@ let array_of_base
   (#t: Type)
   (#tn: Type0)
   (#opened: _)
-  (#n: array_size_t)
+  (#n: Ghost.erased array_size_t)
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
@@ -1351,6 +1376,8 @@ let array_of_base
     (fun _ -> True)
     (fun _ _ _ -> True)
 = let al = array_ref_of_base r in
+  let _ = witness_exists () in
+  elim_pure _;
   let a = (| al, Ghost.hide (n <: SZ.t) |) in
   change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
   return a
@@ -1372,6 +1399,7 @@ val unarray_of_base
     )
     (fun _ v' _ -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
 
+(*
 val has_array_of_ref
   (#t: Type)
   (#td: typedef t)
@@ -1396,7 +1424,6 @@ val has_array_of_ref_post
       Ghost.reveal len == 1sz
     )
 
-(*
 val has_array_of_ref_inj
   (#t: Type)
   (#td: typedef t)
@@ -1408,7 +1435,6 @@ val has_array_of_ref_inj
       has_array_of_ref r a2
     ))
     (ensures a1 == a2)
-*)
 
 val ghost_array_of_ref_focus
   (#t: Type)
@@ -1435,11 +1461,10 @@ val ghost_array_of_ref
 [@@noextract_to "krml"] // primitive
 val array_ref_of_ref
   (#t: Type)
-  (#opened: _)
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: SteelAtomicBase (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz }) false opened Unobservable
+: Steel (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz })
     (pts_to r v)
     (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r (| a, Ghost.hide 1sz |))
     (fun _ -> True)
@@ -1448,11 +1473,10 @@ val array_ref_of_ref
 inline_for_extraction [@@noextract_to "krml"]
 let array_of_ref
   (#t: Type)
-  (#opened: _)
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: SteelAtomicBase (array td) false opened Unobservable
+: Steel (array td)
     (pts_to r v)
     (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
     (fun _ -> True)
@@ -1473,6 +1497,7 @@ val unarray_of_ref
 : SteelGhostT (squash (Seq.length s == 1)) opened
     (array_pts_to a s `star` has_array_of_ref r a)
     (fun _ -> pts_to r (Seq.index s 0) `star` has_array_of_ref r a)
+*)
 
 val has_array_cell
   (#t: Type)
@@ -1495,11 +1520,13 @@ val has_array_cell_has_base_array_cell
   (r: ref td)
   (#ty: Type)
   (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
-: SteelGhost unit opened
+: SteelGhost (Ghost.erased SZ.t) opened
     (has_array_cell a i r)
-    (fun _ -> has_base_array_cell br i r)
+    (fun j -> has_base_array_cell br j r)
     (fun _ -> has_array_ref_base (dfst a) br)
-    (fun _ _ _ -> True)
+    (fun _ j _ ->
+      SZ.v j == SZ.v (array_ref_offset (dfst a)) + SZ.v i
+    )
 
 val has_base_array_cell_has_array_cell
   (#opened: _)
@@ -1510,11 +1537,15 @@ val has_base_array_cell_has_array_cell
   (r: ref td)
   (#ty: Type)
   (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
-: SteelGhost unit opened
+: SteelGhost (Ghost.erased SZ.t) opened
     (has_base_array_cell br i r)
-    (fun _ -> has_array_cell a i r)
-    (fun _ -> has_array_ref_base (dfst a) br)
-    (fun _ _ _ -> True)
+    (fun j -> has_array_cell a j r)
+    (fun _ -> has_array_ref_base (dfst a) br /\
+      SZ.v i >= SZ.v (array_ref_offset (dfst a))
+    )
+    (fun _ j _ ->
+      SZ.v i == SZ.v (array_ref_offset (dfst a)) + SZ.v j
+    )
 
 val has_array_cell_inj
   (#opened: _)
@@ -1535,6 +1566,7 @@ val has_array_cell_inj
     )
 // = has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
 
+(*
 val has_array_cell_array_of_ref
   (#opened: _)
   (#t: Type)
@@ -1544,6 +1576,7 @@ val has_array_cell_array_of_ref
 : SteelGhostT unit opened
     (has_array_of_ref r a)
     (fun _ -> has_array_of_ref r a `star` has_array_cell a 0sz r)
+*)
 
 val ghost_array_cell_focus
   (#opened: _)
@@ -1678,14 +1711,13 @@ val ghost_array_split
 
 [@@noextract_to "krml"] // primitive
 val array_ref_split
-  (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (#s: Ghost.erased (Seq.seq t))
   (al: array_ref td)
   (len: array_len_t al)
   (i: SZ.t)
-: SteelAtomicBase (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len}) false opened Unobservable
+: Steel (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len})
     (array_pts_to (| al, len |) s)
     (fun _ -> array_pts_to (array_split_l (| al, len |) i) (Seq.slice s 0 (SZ.v i)) `star`
       array_pts_to (array_split_r (| al, len |) i) (Seq.slice s (SZ.v i) (Seq.length s)))
@@ -1694,13 +1726,12 @@ val array_ref_split
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_split
-  (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: SteelAtomicBase (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)}) false opened Unobservable
+: Steel (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)})
     (array_pts_to a s)
     (fun a' -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
       array_pts_to a' (Seq.slice s (SZ.v i) (Seq.length s)))

From 4360336c76b75005a0b4755025e06a0ea8960e59 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 8 Mar 2023 19:42:42 -0800
Subject: [PATCH 409/513] array_cell

---
 ulib/experimental/Steel.C.Model.Array.fst |  18 +-
 ulib/experimental/Steel.C.Types.fst       | 201 +++++++++++++++++++++-
 2 files changed, 210 insertions(+), 9 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.C.Model.Array.fst
index 7b336a50da4..7dd9b84d224 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.C.Model.Array.fst
@@ -396,6 +396,21 @@ let cell
     (ensures (fun _ -> True))
 = struct_field (array_elements_pcm p len) i
 
+let ref_of_array_eq
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array base_t p)
+  (i: size_t)
+: Lemma
+  (requires (size_v i < size_v r.len))
+  (ensures (
+    R.ref_focus (ref_of_array r) (cell p r.len i) ==
+    R.ref_focus r.base (cell p r.base_len (r.offset `size_add` i))
+  ))
+= ref_focus_comp r.base (ref_of_array_conn r) (cell p r.len i);
+  substruct_field (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () i
+
 let g_focus_cell
   (#opened: _)
   (#base_t: Type)
@@ -479,8 +494,7 @@ let focus_cell
       r' == ref_focus (ref_of_array r) (cell p r.len i)
     )
 = let y = pts_to_elim_to_base r _ in
-  ref_focus_comp r.base (ref_of_array_conn r) (cell p r.len i);
-  substruct_field (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () i;
+  ref_of_array_eq r i;
   let r' = addr_of_struct_field r.base (r.offset `size_add` i) _ in
   pts_to_intro_from_base r _ _;
   A.change_equal_slprop (R.pts_to r' _) (R.pts_to r' _);
diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index c345748d092..4ff41ad3ee6 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -2273,15 +2273,202 @@ let has_array_cell_array_of_ref
 #pop-options
 *)
 
-let ghost_array_cell_focus = magic ()
+let has_struct_field1_intro
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+  (p: P.perm)
+  (w: ref0_v (struct1 fields))
+  (p': P.perm)
+  (w': ref0_v (fields.fd_typedef field))
+  ()
+: ST.STGhost unit opened
+    (HR.pts_to r p w `star` HR.pts_to r' p' w')
+    (fun _ ->
+      has_struct_field1 r field r'
+    )
+    (
+      has_struct_field_gen fields w field w'
+    )
+    (fun _ -> True)
+= ST.noop ();
+  ST.rewrite
+    (has_struct_field0 r field r')
+    (has_struct_field1 r field r')
 
-let ghost_array_cell = magic ()
-(*
-  #_ #_ #_ #s a i
-= let ma = model_array_of_array a in
-*)
+let has_array_cell_drop
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (#p': P.perm)
+  (#b': ref0_v td)
+  (i: SZ.t)
+  (r: ref td)
+: ST.STGhostT unit opened
+    (has_array_cell1 a i r `star`
+      HR.pts_to r p' b'
+    )
+    (fun _ -> has_array_cell1 a i r)
+= ST.rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
+  let _ = ST.gen_elim () in
+  let j = ST.vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
+  ST.rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  let _ = ST.gen_elim () in
+  let j' : base_array_index_t' (dfst a).ar_base_size = ST.vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  ST.rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let _ = ST.gen_elim () in
+  HR.gather p' r;
+  has_struct_field1_intro
+    #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
+  ST.rewrite
+    (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r)
+    (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+  ST.rewrite
+    (has_base_array_cell0 (dfst a).ar_base j r)
+    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+  ST.rewrite
+    (has_array_cell0 a i r)
+    (has_array_cell a i r)
 
-let array_ref_cell = magic ()
+assume
+val has_array_cell_elim
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#p: P.perm)
+  (a: array td)
+  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (i: SZ.t)
+  (r: ref td)
+: ST.STGhost (Ghost.erased (ref0_v td)) opened
+    (has_array_cell1 a i r `star`
+      HR.pts_to (dfst a).ar_base p b
+    )
+    (fun b' -> has_array_cell1 a i r `star`
+      HR.pts_to (dfst a).ar_base p b `star`
+      ST.exists_ (fun p' -> HR.pts_to r p' b')
+    )
+    True
+    (fun b' ->
+      let ar = model_array_of_array a b in
+      SZ.v i < SZ.v ar.len /\
+      b'.base == b.base /\
+      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+    )
+
+let ghost_array_cell_focus
+  #_ #_ #td #s a i r
+= ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let b = ST.vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let r' = has_array_cell_elim a i r in
+  let _ = ST.gen_elim () in
+  let _ = A.g_focus_cell _ _ i () in
+  ST.rewrite (R.pts_to _ _) (R.pts_to r'.ref (Seq.index s (SZ.v i)));
+  ST.weaken (pts_to0 r (Seq.index s (SZ.v i))) (pts_to r (Seq.index s (SZ.v i))) (fun _ -> ());
+  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
+  ST.weaken (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td))) (fun _ -> ())
+
+assume
+val has_array_cell_intro
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#p: P.perm)
+  (a: array td)
+  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (#p': P.perm)
+  (#b': ref0_v td)
+  (i: SZ.t)
+  (r: ref td)
+: ST.STGhost unit opened
+    (HR.pts_to (dfst a).ar_base p b `star`
+      HR.pts_to r p' b'
+    )
+    (fun _ -> has_array_cell1 a i r)
+    (
+      let ar = model_array_of_array a b in
+      SZ.v i < SZ.v ar.len /\
+      b'.base == b.base /\
+      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+    )
+    (fun _ -> True)
+
+let ghost_array_cell
+  #_ #_ #td #s a i
+= array_pts_to_length _ _;
+  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  HR.share _;
+  ST.weaken (array_pts_to0 a s) (array_pts_to a s) (fun _ -> ());
+  let b = ST.vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let ar = model_array_of_array a b in
+  let b' = {
+    base = b.base;
+    ref = R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i);
+  }
+  in
+  let ghr = GHR.alloc b' in
+  GHR.reveal_pts_to ghr P.full_perm b';
+  let hr = GHR.reveal_ref ghr in
+  ST.rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to hr P.full_perm b');
+  HR.pts_to_not_null hr;
+  let r : (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
+  ST.vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
+  has_array_cell_intro a i r;
+  let _ = ghost_array_cell_focus a i r in
+  ST.noop ();
+  r
+
+[@@ noextract_to "krml"]
+let array_cell0
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: Steel (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
+    (array_pts_to a s)
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
+    (fun _ ->
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
+    )
+    (fun _ _ _ -> True)
+= array_pts_to_length _ _;
+  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  HR.share _;
+  ST.weaken (array_pts_to0 a s) (array_pts_to a s) (fun _ -> ());
+  let b = HR.read (dfst a).ar_base in
+  ST.vpattern_rewrite (HR.pts_to (dfst a).ar_base _) b;
+  let ar = model_array_of_array a b in
+  A.ref_of_array_eq ar i;
+  let b' = {
+    base = b.base;
+    ref = R.ref_focus ar.base (A.cell td.pcm ar.base_len (ar.offset `SZ.add`  i));
+  }
+  in
+  let hr = HR.alloc b' in
+  HR.pts_to_not_null hr;
+  let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
+  ST.vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
+  has_array_cell_intro a i r;
+  let _ = ghost_array_cell_focus a i r in
+  ST.noop ();
+  return r
+
+let array_ref_cell
+  #_ #td #s a len i
+= let r0 : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd ((| a, len |) <: array td)) }) = array_cell0 _ _ in
+  let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len }) = r0 in
+  ST.vpattern_rewrite (fun r -> pts_to r _) r;
+  ST.vpattern_rewrite (has_array_cell _ _) r;
+  ST.noop ();
+  return r
 
 let unarray_cell = magic ()
 

From 5c360ff058e0520e9e8cb10fa80c59ef2c457ad5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 10:47:36 -0800
Subject: [PATCH 410/513] solve last admits on arrays (except array_of_ref)

---
 ulib/experimental/Steel.C.Types.fst  | 104 ++++++++++++++++++++++++---
 ulib/experimental/Steel.C.Types.fsti |  16 ++++-
 2 files changed, 109 insertions(+), 11 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 4ff41ad3ee6..8894d9a1ee3 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -2200,7 +2200,10 @@ let has_array_cell0
 : Tot vprop
 = ST.exists_ (fun (j: SZ.t) ->
     has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r `star`
-    ST.pure (SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i)
+    ST.pure (
+      SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i /\
+      SZ.v i < SZ.v (dsnd a)
+    )
   )
 
 let has_array_cell1
@@ -2216,6 +2219,12 @@ let has_array_cell
   a i r
 = has_array_cell0 a i r
 
+let has_array_cell_post
+  a i r
+= ST.rewrite (has_array_cell a i r) (has_array_cell0 a i r);
+  let _ = ST.gen_elim () in
+  ST.rewrite (has_array_cell0 a i r) (has_array_cell a i r)
+
 let has_array_cell_has_base_array_cell
   a i r br
 = ST.rewrite (has_array_cell a i r) (has_array_cell0 a i r);
@@ -2233,7 +2242,8 @@ let has_base_array_cell_has_array_cell
 
 let has_array_cell_inj
   #_ #_ #td a i r1 r2
-= let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
+= has_array_cell_post a i r1;
+  let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
   let j1 = has_array_cell_has_base_array_cell a i r1 br in
   let j2 = has_array_cell_has_base_array_cell a i r2 br in
   ST.vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
@@ -2334,8 +2344,7 @@ let has_array_cell_drop
     (has_array_cell0 a i r)
     (has_array_cell a i r)
 
-assume
-val has_array_cell_elim
+let has_array_cell_elim
   (#opened: _)
   (#t: Type)
   (#td: typedef t)
@@ -2349,9 +2358,10 @@ val has_array_cell_elim
       HR.pts_to (dfst a).ar_base p b
     )
     (fun b' -> has_array_cell1 a i r `star`
-      HR.pts_to (dfst a).ar_base p b `star`
-      ST.exists_ (fun p' -> HR.pts_to r p' b')
-    )
+      ST.exists_ (fun p -> ST.exists_ (fun p' ->
+        HR.pts_to (dfst a).ar_base p b `star`
+        HR.pts_to r p' b'
+    )))
     True
     (fun b' ->
       let ar = model_array_of_array a b in
@@ -2359,6 +2369,31 @@ val has_array_cell_elim
       b'.base == b.base /\
       b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
     )
+= 
+  ST.rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
+  let _ = ST.gen_elim () in
+  let j = ST.vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
+  ST.rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  let _ = ST.gen_elim () in
+  let j' : base_array_index_t' (dfst a).ar_base_size = ST.vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  ST.rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let _ = ST.gen_elim () in
+  hr_gather b (dfst a).ar_base;
+  HR.share r;
+  HR.share (dfst a).ar_base;
+  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
+  ST.rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+  ST.rewrite
+    (has_base_array_cell0 (dfst a).ar_base j r)
+    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+  ST.rewrite
+    (has_array_cell0 a i r)
+    (has_array_cell a i r);
+  A.ref_of_array_eq (model_array_of_array a b) i;
+  struct_field_eq_cell td (dfst a).ar_base_size j';
+  let b' = ST.vpattern_replace_erased (HR.pts_to r _) in
+  ST.noop ();
+  b'
 
 let ghost_array_cell_focus
   #_ #_ #td #s a i r
@@ -2373,8 +2408,7 @@ let ghost_array_cell_focus
   ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
   ST.weaken (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td))) (fun _ -> ())
 
-assume
-val has_array_cell_intro
+let has_array_cell_intro
   (#opened: _)
   (#t: Type)
   (#td: typedef t)
@@ -2397,6 +2431,18 @@ val has_array_cell_intro
       b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
     )
     (fun _ -> True)
+= 
+  A.ref_of_array_eq (model_array_of_array a b) i;
+  let j : base_array_index_t' (dfst a).ar_base_size = (dfst a).ar_offset `SZ.add` i in
+  struct_field_eq_cell td (dfst a).ar_base_size j;
+  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r _ _ _ _ ();
+  ST.rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j r);
+  ST.rewrite
+    (has_base_array_cell0 (dfst a).ar_base j r)
+    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+  ST.rewrite
+    (has_array_cell0 a i r)
+    (has_array_cell a i r)
 
 let ghost_array_cell
   #_ #_ #td #s a i
@@ -2470,7 +2516,45 @@ let array_ref_cell
   ST.noop ();
   return r
 
-let unarray_cell = magic ()
+let ar_unfocus_cell
+  (#opened: _)
+  (#base_t #base_t': Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (s: Seq.seq t)
+  (i: SZ.t)
+  (r': R.ref base_t' p)
+  (v: t)
+  (sq: squash (SZ.v i < SZ.v r.len /\ SZ.v i < Seq.length s))
+: SteelGhost unit opened
+    (A.pts_to r s `star` R.pts_to r' v)
+    (fun _ -> A.pts_to r (Seq.upd s (SZ.v i) v))
+    (fun _ -> 
+      base_t' == base_t /\
+      r' == R.ref_focus (A.ref_of_array r) (A.cell p r.len i) /\
+      Seq.index s (SZ.v i) == one p
+    )
+    (fun _ _ _ -> True)
+= let r1' : R.ref base_t p = coerce_eq () r' in
+  ST.rewrite (R.pts_to r' v) (R.pts_to r1' v);
+  A.unfocus_cell r s i r1' v ()
+
+let unarray_cell
+  #_ #_ #td #s #v a i r
+= array_pts_to_length _ _;
+  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  let w = has_array_cell_elim a i r in
+  let _ = ST.gen_elim () in
+  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
+  let _ = ST.gen_elim () in
+  hr_gather (Ghost.reveal w) r;
+  ar_unfocus_cell _ _ i _ _ ();
+  let b = ST.vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
+  ST.weaken (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v)) (fun _ -> ());
+  has_array_cell_drop _ _ _
 
 #push-options "--split_queries --z3rlimit 16"
 
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 7632fc2ef28..99fbfe09143 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -1511,6 +1511,19 @@ val has_array_cell
   has_base_array_cell (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r
 *)
 
+val has_array_cell_post
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r': ref td)
+: SteelGhost unit opened
+    (has_array_cell a i r')
+    (fun _ -> has_array_cell a i r')
+    (fun _ -> True)
+    (fun _ _ _ -> SZ.v i < SZ.v (dsnd a))
+
 val has_array_cell_has_base_array_cell
   (#opened: _)
   (#t: Type)
@@ -1541,7 +1554,8 @@ val has_base_array_cell_has_array_cell
     (has_base_array_cell br i r)
     (fun j -> has_array_cell a j r)
     (fun _ -> has_array_ref_base (dfst a) br /\
-      SZ.v i >= SZ.v (array_ref_offset (dfst a))
+      SZ.v i >= SZ.v (array_ref_offset (dfst a)) /\
+      SZ.v i < SZ.v (array_ref_offset (dfst a)) + SZ.v (dsnd a)
     )
     (fun _ j _ ->
       SZ.v i == SZ.v (array_ref_offset (dfst a)) + SZ.v j

From c3aec714aaf938f4d3fa4d9299a94b078a2660c6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 13:33:52 -0800
Subject: [PATCH 411/513] ununion_field

---
 ulib/experimental/Steel.C.Types.fst  | 4 +---
 ulib/experimental/Steel.C.Types.fsti | 2 --
 2 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 8894d9a1ee3..5bb848d3f58 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -1166,7 +1166,6 @@ let full_struct_gen
 
 let full_struct s = full_struct_gen s
 
-(*
 module U = Steel.C.Model.Union
 
 let define_union0 _ _ _ = unit
@@ -1595,7 +1594,7 @@ let ununion_field
   hr_share r;
   ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
   ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
-  ST.admit_ ()
+  ST.weaken (pts_to0 r (union_set_field tn n fields field (Ghost.reveal v'))) (pts_to r (union_set_field tn n fields field (Ghost.reveal v'))) (fun _ -> ())
 
 [@@noextract_to "krml"] // primitive
 let union_switch_field'
@@ -1672,7 +1671,6 @@ let union_switch_field0
 = union_switch_field0' t' r field td' ()
 
 #pop-options
-*)
 
 
 /// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.C.Types.fsti
index 99fbfe09143..0464116bf39 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.C.Types.fsti
@@ -693,7 +693,6 @@ val full_struct
   (full (struct0 tn n fields) s <==> (forall field . full (fields.fd_typedef field) (struct_get_field s field)))
   [SMTPat (full (struct0 tn n fields) s)]
 
-(*
 [@@noextract_to "krml"] // primitive
 val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
 inline_for_extraction [@@noextract_to "krml"]
@@ -1050,7 +1049,6 @@ let union_switch_field
     r
     field
     (fields.fd_typedef field)
-*)
 
 module SZ = FStar.SizeT
 

From 10a3a487aa775609d209128a54a2e3a49df97cd8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 14:17:29 -0800
Subject: [PATCH 412/513] revert snap for FStar_Extraction_Krml.ml

---
 .../generated/FStar_Extraction_Krml.ml        | 962 +-----------------
 1 file changed, 15 insertions(+), 947 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 9ba78c814d9..c4f540b06c3 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -706,102 +691,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -958,8 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -969,9 +857,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -989,63 +876,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1058,8 +888,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1096,21 +925,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1170,14 +996,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1190,36 +1015,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1883,66 +1691,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2036,48 +1784,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2803,505 +2514,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3715,72 +2927,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3793,85 +2939,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From e3f7ac4cb803f49cba5912a58629ee38b60bc0cb Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 15:07:29 -0800
Subject: [PATCH 413/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 962 +++++++++++++++++-
 1 file changed, 947 insertions(+), 15 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..28a46818a24 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,63 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1058,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1096,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1170,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1190,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1883,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2036,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2803,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___6;
+                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___10;
+             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
+          when
+          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___13 = "Steel.C.Types.struct_field0" ->
+          let uu___13 =
+            let uu___14 =
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___17 in
+                TQualified uu___16 in
+              let uu___16 =
+                let uu___17 =
+                  let uu___18 = translate_expr env1 r in
+                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___17 in
+              (uu___15, uu___16, field_name) in
+            EField uu___14 in
+          EAddrOf uu___13
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3715,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3793,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 259957ea43151228eb48f5c7bf5a0a7f42cb4a88 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 16:10:58 -0800
Subject: [PATCH 414/513] rlimit

---
 ulib/experimental/Steel.C.Types.fst | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.C.Types.fst
index 5bb848d3f58..bfebda82060 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.C.Types.fst
@@ -2083,6 +2083,11 @@ let a_pts_to_elim_to_base
     )
 = A.pts_to_elim_to_base r x
 
+#pop-options
+
+#push-options "--z3rlimit 32"
+#restart-solver
+
 let unarray_of_base0
   (#t: Type)
   (#opened: _)
@@ -2112,12 +2117,12 @@ let unarray_of_base0
   ST.weaken (pts_to0 r y') (pts_to r y') (fun _ -> ());
   y'
 
+#pop-options
+
 let unarray_of_base
   #t #tn #_ #n #td #v r a
 = unarray_of_base0 r a
 
-#pop-options
-
 (*
 let has_array_of_ref
   r a

From 3215e33aa5851c48d3ec73910d965fa013bfca69 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 16:31:57 -0800
Subject: [PATCH 415/513] Steel vs. Steel.ST: Ref

---
 ulib/experimental/Steel.C.Model.Ref.fst    | 133 +-----------------
 ulib/experimental/Steel.C.Model.Ref.fsti   |  82 +----------
 ulib/experimental/Steel.ST.C.Model.Ref.fst | 152 +++++++++++++++++----
 3 files changed, 125 insertions(+), 242 deletions(-)

diff --git a/ulib/experimental/Steel.C.Model.Ref.fst b/ulib/experimental/Steel.C.Model.Ref.fst
index f884352c66f..275f2228e55 100644
--- a/ulib/experimental/Steel.C.Model.Ref.fst
+++ b/ulib/experimental/Steel.C.Model.Ref.fst
@@ -5,137 +5,6 @@ open FStar.FunctionalExtensionality
 
 friend Steel.C.Model.Ref.Base
 
-let mk_id_ref
-  (#a: Type0)
-  (p: pcm a)
-  (r0: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)))
-: Tot (ref a p)
-=
-  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
-  let fp = fstar_pcm_of_pcm p' in
-  NonNull ({ p = p; q = p; pl = connection_id p; r = r0 })
-
-#push-options "--z3rlimit 16"
-
-let ref_alloc #a p x =
-  let x' : U.raise_t u#0 u#1 a = U.raise_val u#0 u#1 x in
-  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
-//  let fp : P.pcm u#1 _ = fstar_pcm_of_pcm p' in // FIXME: I can define this local definition, but WHY WHY WHY can't I USE it?
-  compatible_refl p' x';
-  let r0 : Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) = Steel.PCMReference.alloc #_ #(fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) x' in
-  let r : ref a p = mk_id_ref p r0 in
-  connection_compose_id_right (lower_conn r);
-  A.change_equal_slprop (r0 `mpts_to` _) (r `pts_to` x);
-  A.return r
-
-let ref_free #a #b #p #x r =
-  // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.Model.PCM
-  A.drop (pts_to _ _)
-
-#pop-options
-
-let gfocus r l s x =
-  connection_compose_assoc (lower_conn r) (NonNull?.v r).pl l;
-  A.change_equal_slprop
-    (r `pts_to` s)
-    (ref_focus r l `pts_to` x)
-
-let focus r l s x =
-  let r' = t_ref_focus r l in
-  gfocus r l s x;
-  A.change_equal_slprop
-    (ref_focus r l `pts_to` x)
-    (r' `pts_to` x);
-  A.return r'
-
-let unfocus r r' l x =
-  connection_compose_assoc (lower_conn r') (NonNull?.v r').pl l;
-  A.change_equal_slprop
-    (r `pts_to` x)
-    (r' `pts_to` l.conn_small_to_large.morph x)
-
-let split r xy x y =
-  let c = raise_pl r in
-  let xy2 = Ghost.hide (c.conn_small_to_large.morph xy) in
-  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
-  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
-  assert (composable (raise_p r) x2 y2);
-  A.change_equal_slprop
-    (r `pts_to` xy)
-    ((NonNull?.v r).r `mpts_to` xy2);
-  Steel.PCMReference.split (NonNull?.v r).r
-    xy2
-    x2
-    y2;
-  A.change_equal_slprop
-    ((NonNull?.v r).r `mpts_to` x2)
-    (r `pts_to` x);
-  A.change_equal_slprop
-    ((NonNull?.v r).r `mpts_to` y2)
-    (r `pts_to` y)
-
-let mgather
-  (#inames: _) (#a:Type) (#p:P.pcm a)
-  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
-: A.SteelGhostT (_:unit{P.composable p v0 v1}) inames
-    (mpts_to r v0 `star` mpts_to r v1)
-    (fun _ -> mpts_to r (P.op p v0 v1))
-= Steel.PCMReference.gather r v0 v1
-
-let gather #inames #a #b #p r x y =
-  let c = raise_pl r in
-  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
-  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
-  A.change_equal_slprop
-    (r `pts_to` x)
-    ((NonNull?.v r).r `mpts_to` x2);
-  A.change_equal_slprop
-    (r `pts_to` y)
-    ((NonNull?.v r).r `mpts_to` y2);
-  mgather (NonNull?.v r).r
-    x2
-    y2;
-  assert (composable (raise_p r) x2 y2);
-  assert (
-    let x' = c.conn_large_to_small.morph x2 in
-    let y' = c.conn_large_to_small.morph y2 in
-    composable p x' y' /\
-    Ghost.reveal x == x' /\ Ghost.reveal y == y'
-  );
-  A.change_equal_slprop _ (r `pts_to` op p x y)
-
-let ref_read (#p: pcm 'b) (#x: Ghost.erased 'b) (r: ref 'a p)
-: Steel 'b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible p x x')
-= let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
-  A.change_equal_slprop (r `pts_to` x) ((NonNull?.v r).r `mpts_to` w);
-  let w' = Steel.PCMReference.read (NonNull?.v r).r w in
-  A.change_equal_slprop ((NonNull?.v r).r `mpts_to` w) (r `pts_to` x);
-  let x' = (raise_pl r).conn_large_to_small.morph w' in
-  compatible_morphism (raise_pl r).conn_large_to_small w w';
-  A.return x'
-
-let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
-: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
-= let c = raise_pl r in
-  let x' = Ghost.hide (c.conn_small_to_large.morph x) in
-  let y' = Ghost.hide (c.conn_small_to_large.morph y) in
-  M.upd_gen Set.empty (NonNull?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
-
-let as_action (#p:vprop)
-              (#q:vprop)
-              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
-: SteelT unit p (fun x -> q)
-= A.change_slprop_rel p (to_vprop (hp_of p)) (fun _ _ -> True) (fun m -> ());
-  let x = Steel.Effect.as_action f in
-  A.change_slprop_rel (to_vprop (hp_of q)) q (fun _ _ -> True) (fun m -> ());
-  A.return x
-
-let ref_upd r x y f = as_action (ref_upd_act r x y f)
-
 let pts_to_view_explicit
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
@@ -367,6 +236,8 @@ let compatible_elim'
   })
 = compatible_elim pcm x y
 
+module STC = Steel.ST.Coercions
+
 let ref_read_sel
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
   (r: ref a p)
diff --git a/ulib/experimental/Steel.C.Model.Ref.fsti b/ulib/experimental/Steel.C.Model.Ref.fsti
index d3b172f7825..762c0f64a19 100644
--- a/ulib/experimental/Steel.C.Model.Ref.fsti
+++ b/ulib/experimental/Steel.C.Model.Ref.fsti
@@ -2,7 +2,7 @@ module Steel.C.Model.Ref
 open FStar.FunctionalExtensionality
 open Steel.C.Model.PCM
 open Steel.C.Model.Connection
-include Steel.C.Model.Ref.Base
+include Steel.ST.C.Model.Ref
 
 #push-options "--print_universes"
 
@@ -10,88 +10,8 @@ open Steel.Effect
 
 module A = Steel.Effect.Atomic
 
-(** Allocate a reference containing value x. *)
-val ref_alloc
-  (#a:Type0) (p: pcm a) (x: a)
-: Steel (ref a p)
-    emp
-    (fun r -> r `pts_to` x)
-    (requires fun _ -> p_refine p x)
-    (ensures fun _ r _ -> freeable r)
-
-(** Free a "base" (freeable) reference containing a "whole" (p_refine) value x. *)
-val ref_free
-  (#a #b:Type0) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
-: Steel unit
-    (r `pts_to` x)
-    (fun _ -> emp)
-    (requires fun _ -> p_refine p x /\ freeable r)
-    (ensures fun _ _ _ -> True)
-
-
-(** Take a pointer to a "substructure" of a reference. *)
-val gfocus (#inames: _) (#p: pcm 'b) (r: ref 'a p)
-  (#q: pcm 'c)
-  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: A.SteelGhost unit inames
-    (r `pts_to` s)
-    (fun _ -> ref_focus r l `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
-    (fun _ _ _ -> True)
-
-val focus (#opened: _) (#p: pcm 'b) (r: ref 'a p)
-  (#q: pcm 'c)
-  (l: connection p q) (s: Ghost.erased 'b) (x: Ghost.erased 'c)
-: A.SteelAtomicBase (ref 'a q)
-    false opened A.Unobservable
-    (r `pts_to` s)
-    (fun r' -> r' `pts_to` x)
-    (fun _ -> Ghost.reveal s == l.conn_small_to_large.morph x)
-    (fun _ r' _ -> r' == ref_focus r l)
-
 module M = Steel.Memory
 
-(** Inverse of focus. *)
-val unfocus (#opened:M.inames)
-  (#p: pcm 'b)
-  (#q: pcm 'c)
-  (r: ref 'a q) (r': ref 'a p)
-  (l: connection p q) (x: Ghost.erased 'c)
-: A.SteelGhost unit opened
-    (r `pts_to` x)
-    (fun _ -> r' `pts_to` l.conn_small_to_large.morph x)
-    (requires fun _ -> r == ref_focus r' l)
-    (ensures fun _ _ _ -> True)
-
-(** Split the permissions on a reference into two halves. *)
-val split (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (xy x y: Ghost.erased b)
-: A.SteelGhost unit inames
-    (r `pts_to` xy)
-    (fun _ -> (r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> composable p x y /\ xy == Ghost.hide (op p x y))
-    (fun _ _ _ -> True)
-
-(** Inverse of split. *)
-val gather (#inames: _) (#a:Type) (#b:Type) (#p: pcm b) (r: ref a p) (x y: Ghost.erased b)
-: A.SteelGhostT (_:unit{composable p x y}) inames
-    ((r `pts_to` x) `star` (r `pts_to` y))
-    (fun _ -> r `pts_to` op p x y)
-
-(** Read a PCM carrier value. *)
-val ref_read
-  (#a:Type) (#b:Type) (#p: pcm b) (#x: Ghost.erased b) (r: ref a p)
-: Steel b
-    (r `pts_to` x)
-    (fun _ -> r `pts_to` x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> compatible p x x')
-
-(** Write a PCM carrier value. *)
-val ref_upd
-  (#a:Type) (#b:Type) (#p: pcm b)
-  (r: ref a p) (x: Ghost.erased b { ~ (Ghost.reveal x == one p) }) (y: Ghost.erased b) (f: frame_preserving_upd p x y)
-: SteelT unit (r `pts_to` x) (fun _ -> r `pts_to` y)
-
 (** PCM carrier values are cumbersome to work with directly. To
     abstract over them, we define "view"s, which are essentially
     lossless partial functions from PCM carrier values to "view
diff --git a/ulib/experimental/Steel.ST.C.Model.Ref.fst b/ulib/experimental/Steel.ST.C.Model.Ref.fst
index fa148f706a0..a1d605ae59b 100644
--- a/ulib/experimental/Steel.ST.C.Model.Ref.fst
+++ b/ulib/experimental/Steel.ST.C.Model.Ref.fst
@@ -1,42 +1,134 @@
 module Steel.ST.C.Model.Ref
+module P = FStar.PCM
+module U = Steel.C.Model.Universe
+open FStar.FunctionalExtensionality
 
-// FIXME: in fact, to avoid those explicit coercions below, we should
-// swap Steel.ST.C.Model.Ref.fst and Steel.C.Model.Ref.fst for the
-// non-view operations, thus benefitting from the automatic effect
-// liftings
+friend Steel.C.Model.Ref.Base
 
-module STC = Steel.ST.Coercions
-module SR = Steel.C.Model.Ref
+let mk_id_ref
+  (#a: Type0)
+  (p: pcm a)
+  (r0: Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)))
+: Tot (ref a p)
+=
+  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
+  let fp = fstar_pcm_of_pcm p' in
+  NonNull ({ p = p; q = p; pl = connection_id p; r = r0 })
 
-let ref_alloc
-  p x
-= STC.coerce_steel (fun _ -> SR.ref_alloc p x)
+#push-options "--z3rlimit 16"
 
-let ref_free
-  r
-= STC.coerce_steel (fun _ -> SR.ref_free r)
+let ref_alloc #a p x =
+  let x' : U.raise_t u#0 u#1 a = U.raise_val u#0 u#1 x in
+  let p' : pcm u#1 _ = U.raise_pcm u#0 u#1 p in
+//  let fp : P.pcm u#1 _ = fstar_pcm_of_pcm p' in // FIXME: I can define this local definition, but WHY WHY WHY can't I USE it?
+  compatible_refl p' x';
+  let r0 : Steel.Memory.ref (U.raise_t u#0 u#1 a) (fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) = Steel.ST.PCMReference.alloc #_ #(fstar_pcm_of_pcm (U.raise_pcm u#0 u#1 p)) x' in
+  let r : ref a p = mk_id_ref p r0 in
+  connection_compose_id_right (lower_conn r);
+  rewrite (r0 `mpts_to` _) (r `pts_to` x);
+  return r
 
-let gfocus
-  r l s x
-= STC.coerce_ghost (fun _ -> SR.gfocus r l s x)
+let ref_free #a #b #p #x r =
+  // TODO: use Steel.PCMReference.free, but we are blocked by (p.refine (one p)), which we explicitly excluded in Steel.C.Model.PCM
+  drop (pts_to _ _)
 
-let focus
-  r l s x
-= STC.coerce_atomic (fun _ -> SR.focus r l s x)
+#pop-options
 
-let unfocus
-  r r' l x
-= STC.coerce_ghost (fun _ -> SR.unfocus r r' l x)
+let gfocus r l s x =
+  connection_compose_assoc (lower_conn r) (NonNull?.v r).pl l;
+  rewrite
+    (r `pts_to` s)
+    (ref_focus r l `pts_to` x)
 
-let split r xy x y
-= STC.coerce_ghost (fun _ -> SR.split r xy x y)
+let focus r l s x =
+  let r' = t_ref_focus r l in
+  gfocus r l s x;
+  rewrite
+    (ref_focus r l `pts_to` x)
+    (r' `pts_to` x);
+  return r'
 
-let gather r x y
-= STC.coerce_ghost (fun _ -> SR.gather r x y)
+let unfocus r r' l x =
+  connection_compose_assoc (lower_conn r') (NonNull?.v r').pl l;
+  rewrite
+    (r `pts_to` x)
+    (r' `pts_to` l.conn_small_to_large.morph x)
 
-let ref_read r
-= STC.coerce_steel (fun _ -> SR.ref_read r)
+let split r xy x y =
+  let c = raise_pl r in
+  let xy2 = Ghost.hide (c.conn_small_to_large.morph xy) in
+  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
+  assert (composable (raise_p r) x2 y2);
+  rewrite
+    (r `pts_to` xy)
+    ((NonNull?.v r).r `mpts_to` xy2);
+  Steel.ST.PCMReference.split (NonNull?.v r).r
+    xy2
+    x2
+    y2;
+  rewrite
+    ((NonNull?.v r).r `mpts_to` x2)
+    (r `pts_to` x);
+  rewrite
+    ((NonNull?.v r).r `mpts_to` y2)
+    (r `pts_to` y)
 
-let ref_upd
-  r x y f
-= STC.coerce_steel (fun _ -> SR.ref_upd r x y f)
+let mgather
+  (#inames: _) (#a:Type) (#p:P.pcm a)
+  (r:Steel.Memory.ref a p) (v0:Ghost.erased a) (v1:Ghost.erased a)
+: STGhostT (_:unit{P.composable p v0 v1}) inames
+    (mpts_to r v0 `star` mpts_to r v1)
+    (fun _ -> mpts_to r (P.op p v0 v1))
+= Steel.ST.PCMReference.gather r v0 v1
+
+let gather #inames #a #b #p r x y =
+  let c = raise_pl r in
+  let x2 = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y2 = Ghost.hide (c.conn_small_to_large.morph y) in
+  rewrite
+    (r `pts_to` x)
+    ((NonNull?.v r).r `mpts_to` x2);
+  rewrite
+    (r `pts_to` y)
+    ((NonNull?.v r).r `mpts_to` y2);
+  let _ = mgather (NonNull?.v r).r
+    x2
+    y2
+  in
+  assert (composable (raise_p r) x2 y2);
+  assert (
+    let x' = c.conn_large_to_small.morph x2 in
+    let y' = c.conn_large_to_small.morph y2 in
+    composable p x' y' /\
+    Ghost.reveal x == x' /\ Ghost.reveal y == y'
+  );
+  rewrite _ (r `pts_to` op p x y)
+
+let ref_read
+  #_ #_ #p #x r
+= let w = Ghost.hide ((raise_pl r).conn_small_to_large.morph x) in
+  rewrite (r `pts_to` x) ((NonNull?.v r).r `mpts_to` w);
+  let w' = Steel.ST.PCMReference.read (NonNull?.v r).r w in
+  rewrite ((NonNull?.v r).r `mpts_to` w) (r `pts_to` x);
+  let x' = (raise_pl r).conn_large_to_small.morph w' in
+  compatible_morphism (raise_pl r).conn_large_to_small w w';
+  return x'
+
+let ref_upd_act (r: ref 'a 'p) (x: Ghost.erased 'b { ~ (Ghost.reveal x == one 'p) }) (y: Ghost.erased 'b) (f: frame_preserving_upd 'p x y)
+: Tot (M.action_except unit Set.empty (hp_of (r `pts_to` x)) (fun _ -> hp_of (r `pts_to` y)))
+= let c = raise_pl r in
+  let x' = Ghost.hide (c.conn_small_to_large.morph x) in
+  let y' = Ghost.hide (c.conn_small_to_large.morph y) in
+  M.upd_gen Set.empty (NonNull?.v r).r x' y' (fstar_fpu_of_fpu (raise_p r) x' y' (mk_restricted_frame_preserving_upd (c.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = restricted_frame_preserving_upd_intro f; }) )))
+
+let as_action (#p:vprop)
+              (#q:vprop)
+              (f:M.action_except unit Set.empty (hp_of p) (fun _ -> hp_of q))
+: STT unit p (fun x -> q)
+= weaken p (to_vprop (hp_of p)) (fun m -> ());
+  let x = Steel.ST.Coercions.coerce_steel (fun _ -> Steel.Effect.as_action f) in
+  weaken (to_vprop (hp_of q)) q (fun m -> ());
+  return x
+
+let ref_upd r x y f = as_action (ref_upd_act r x y f)

From 7727837f426235aff8517f8dd467262055a0e4af Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 18:04:24 -0800
Subject: [PATCH 416/513] frac

---
 ulib/experimental/Steel.C.Model.Frac.fst      | 86 ++++++++++---------
 ulib/experimental/Steel.ST.C.Model.Frac.fst   | 44 ++++++++++
 ...l.Frac.fsti => Steel.ST.C.Model.Frac.fsti} | 62 ++-----------
 3 files changed, 97 insertions(+), 95 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Frac.fst
 rename ulib/experimental/{Steel.C.Model.Frac.fsti => Steel.ST.C.Model.Frac.fsti} (53%)

diff --git a/ulib/experimental/Steel.C.Model.Frac.fst b/ulib/experimental/Steel.C.Model.Frac.fst
index 0ed30fd7334..ca26bee69e6 100644
--- a/ulib/experimental/Steel.C.Model.Frac.fst
+++ b/ulib/experimental/Steel.C.Model.Frac.fst
@@ -1,51 +1,53 @@
 module Steel.C.Model.Frac
+include Steel.ST.C.Model.Frac
 
+module STC = Steel.ST.Coercions // to use frac_pcm_write
+module P = FStar.PCM
 open Steel.C.Model.PCM
 open Steel.C.Model.Ref
 open Steel.Effect
-open Steel.Effect.Atomic
-  
 open Steel.FractionalPermission
 
-let frac_pcm_write r x y
-= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y);
-  change_equal_slprop (r `pts_to` _) (r `pts_to` _)
+let frac_view
+  (a: Type)
+  (p: perm)
+: Tot (sel_view (pcm_frac #a) a false)
+= {
+  to_view_prop = (fun x -> Some? x == true);
+  to_view = (fun x -> let Some (v, _) = x in v);
+  to_carrier = (fun v -> Some (v, p));
+  to_carrier_not_one = ();
+  to_view_frame = (fun v frame -> ());
+}
 
-let frac_pcm_read r x
-= let y' = ref_read r in
-  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
-  fst (Some?.v y')
+let frac_read_sel
+  (#a: Type u#0) (#b: Type u#0)
+  (#p: perm)
+  (r: ref a (pcm_frac #b))
+: Steel b
+  (pts_to_view r (frac_view _ p))
+  (fun _ -> pts_to_view r (frac_view _ p))
+  (requires (fun _ -> True))
+  (ensures (fun h res h' ->
+    res == h (pts_to_view r (frac_view _ p)) /\
+    res == h' (pts_to_view r (frac_view _ p))
+  ))
+= ref_read_sel r (frac_view _ p)
+
+let frac_write_sel
+  (#a: Type u#0) (#b: Type u#0)
+  (#p: perm)
+  (r: ref a (pcm_frac #b))
+  (w: b)
+: Steel unit
+  (pts_to_view r (frac_view _ p))
+  (fun _ -> pts_to_view r (frac_view _ p))
+  (requires (fun _ -> p == full_perm))
+  (ensures (fun h _ h' ->
+    w == h' (pts_to_view r (frac_view _ p))
+  ))
+=
+  let _ = pts_to_view_elim r (frac_view _ _) in
+  frac_pcm_write r _ w;
+  pts_to_view_intro r _ (frac_view _ p) w
 
-let exclusive_frac
-  (#a: Type)
-  (x: option (a & perm))
-: Lemma
-  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
-= match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      let frame = Some (y, full_perm) in
-      assert (~ (frame == one pcm_frac));
-      assert (composable pcm_frac x frame)
-    end else begin
-      let phi
-        (frame: option (a & perm))
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some (z, _) -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some (y, p) ->
-    assert (exists (z: a) . True);
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
-    then ()
-    else begin
-      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
-      assert (composable pcm_frac x frame);
-      assert (~ (frame == one pcm_frac))
-    end
diff --git a/ulib/experimental/Steel.ST.C.Model.Frac.fst b/ulib/experimental/Steel.ST.C.Model.Frac.fst
new file mode 100644
index 00000000000..7d87edc07a7
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Frac.fst
@@ -0,0 +1,44 @@
+module Steel.ST.C.Model.Frac
+
+let frac_pcm_write r x y
+= ref_upd r x (Some (y, full_perm)) (frac_pcm_fpu x y);
+  rewrite (r `pts_to` _) (r `pts_to` _)
+
+let frac_pcm_read r x
+= let y' = ref_read r in
+  assert (Some? y' /\ fst (Some?.v (Ghost.reveal x)) == fst (Some?.v y'));
+  fst (Some?.v y')
+
+let exclusive_frac
+  (#a: Type)
+  (x: option (a & perm))
+: Lemma
+  (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
+= match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      let frame = Some (y, full_perm) in
+      assert (~ (frame == one pcm_frac));
+      assert (composable pcm_frac x frame)
+    end else begin
+      let phi
+        (frame: option (a & perm))
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some (z, _) -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some (y, p) ->
+    assert (exists (z: a) . True);
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (full_perm `lesser_equal_perm` p)
+    then ()
+    else begin
+      let frame = Some (y, MkPerm (let open FStar.Real in one -. p.v)) in
+      assert (composable pcm_frac x frame);
+      assert (~ (frame == one pcm_frac))
+    end
diff --git a/ulib/experimental/Steel.C.Model.Frac.fsti b/ulib/experimental/Steel.ST.C.Model.Frac.fsti
similarity index 53%
rename from ulib/experimental/Steel.C.Model.Frac.fsti
rename to ulib/experimental/Steel.ST.C.Model.Frac.fsti
index ef499716912..ce256985e55 100644
--- a/ulib/experimental/Steel.C.Model.Frac.fsti
+++ b/ulib/experimental/Steel.ST.C.Model.Frac.fsti
@@ -1,9 +1,9 @@
-module Steel.C.Model.Frac
+module Steel.ST.C.Model.Frac
+open Steel.ST.Util
 
 module P = FStar.PCM
 open Steel.C.Model.PCM
-open Steel.C.Model.Ref
-open Steel.Effect
+open Steel.ST.C.Model.Ref
 
 /// Fractional permissions: from Steel.HigherReference
 open Steel.FractionalPermission
@@ -48,63 +48,19 @@ let frac_pcm_fpu
 val frac_pcm_write
   (#a:Type) (#b: Type)
   (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
-  (requires (fun _ -> Some? x /\ snd (Some?.v x) == full_perm))
-  (ensures (fun _ _ _ -> True))
+: ST unit (r `pts_to` x) (fun _ -> r `pts_to` Some (y, full_perm))
+  (requires (Some? x /\ snd (Some?.v x) == full_perm))
+  (ensures (fun _ -> True))
 
 val frac_pcm_read
   (#a:Type) (#b: Type)
   (r: ref a (pcm_frac #b)) (x: Ghost.erased (fractional b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
+: ST b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (Some? x))
+  (ensures (fun y -> Some? x /\ y == fst (Some?.v (Ghost.reveal x))))
 
 val exclusive_frac
   (#a: Type)
   (x: option (a & perm))
 : Lemma
   (exclusive pcm_frac x <==> ((exists (y: a) . True) ==> (Some? x /\ full_perm `lesser_equal_perm` snd (Some?.v x))))
-
-let frac_view
-  (a: Type)
-  (p: perm)
-: Tot (sel_view (pcm_frac #a) a false)
-= {
-  to_view_prop = (fun x -> Some? x == true);
-  to_view = (fun x -> let Some (v, _) = x in v);
-  to_carrier = (fun v -> Some (v, p));
-  to_carrier_not_one = ();
-  to_view_frame = (fun v frame -> ());
-}
-
-let frac_read_sel
-  (#a: Type u#0) (#b: Type u#0)
-  (#p: perm)
-  (r: ref a (pcm_frac #b))
-: Steel b
-  (pts_to_view r (frac_view _ p))
-  (fun _ -> pts_to_view r (frac_view _ p))
-  (requires (fun _ -> True))
-  (ensures (fun h res h' ->
-    res == h (pts_to_view r (frac_view _ p)) /\
-    res == h' (pts_to_view r (frac_view _ p))
-  ))
-= ref_read_sel r (frac_view _ p)
-
-let frac_write_sel
-  (#a: Type u#0) (#b: Type u#0)
-  (#p: perm)
-  (r: ref a (pcm_frac #b))
-  (w: b)
-: Steel unit
-  (pts_to_view r (frac_view _ p))
-  (fun _ -> pts_to_view r (frac_view _ p))
-  (requires (fun _ -> p == full_perm))
-  (ensures (fun h _ h' ->
-    w == h' (pts_to_view r (frac_view _ p))
-  ))
-=
-  let _ = pts_to_view_elim r (frac_view _ _) in
-  frac_pcm_write r _ w;
-  pts_to_view_intro r _ (frac_view _ p) w
-

From 636bee75821d901ec82669e1656ed74525a8aa9d Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 9 Mar 2023 18:25:44 -0800
Subject: [PATCH 417/513] opt

---
 ulib/experimental/Steel.C.Opt.fst     |  50 +++++-------
 ulib/experimental/Steel.C.Opt.fsti    | 107 ++------------------------
 ulib/experimental/Steel.ST.C.Opt.fst  |  46 +++++++++++
 ulib/experimental/Steel.ST.C.Opt.fsti |  78 +++++++++++++++++++
 4 files changed, 149 insertions(+), 132 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Opt.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Opt.fsti

diff --git a/ulib/experimental/Steel.C.Opt.fst b/ulib/experimental/Steel.C.Opt.fst
index eb283821ec7..eac2b3e4836 100644
--- a/ulib/experimental/Steel.C.Opt.fst
+++ b/ulib/experimental/Steel.C.Opt.fst
@@ -2,37 +2,27 @@ module Steel.C.Opt
 
 open Steel.C.Model.PCM
 module A = Steel.Effect.Atomic
+module STC = Steel.ST.Coercions
 
-let opt_read r =
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  let Some x = ref_read r in
-  x
-
-let opt_write #a #b #x r y =
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
-
-let opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ _ _ -> True))
-= A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  ref_upd r x (Some y) (opt_pcm_fpu x y);
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
-
-let opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-= A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  let y' = ref_read r in
-  assert (Ghost.reveal x == y');
-  Some?.v y'
+
+let opt_read_sel
+  #a #b r
+= ref_read_sel r (opt_view b)
+
+let opt_write_sel
+  #a #b r w
+=
+  let _ = pts_to_view_elim r (opt_view _) in
+  opt_pcm_write r _ w;
+  pts_to_view_intro r _ (opt_view _) w
+
+let ref_opt_read
+  #a #b r
+= ref_read_sel r (opt_view b)
+
+let ref_opt_write
+  #a #b r w
+= opt_write_sel r w
 
 let malloc
   #c x
diff --git a/ulib/experimental/Steel.C.Opt.fsti b/ulib/experimental/Steel.C.Opt.fsti
index c445567a8d6..b0ae13221a0 100644
--- a/ulib/experimental/Steel.C.Opt.fsti
+++ b/ulib/experimental/Steel.C.Opt.fsti
@@ -1,55 +1,11 @@
 module Steel.C.Opt
+include Steel.ST.C.Opt
 
 module P = FStar.PCM
 open Steel.C.Model.PCM
 open Steel.C.Model.Ref
 open Steel.Effect
 
-/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
-
-let opt_comp (x y: option 'a): prop = match x, y with
-  | None, _ | _, None -> True
-  | _, _ -> False
-
-let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
-  | None, z | z, None -> z
-
-let fstar_opt_pcm #a : P.pcm (option a) = let open P in {
-  p = {composable = opt_comp; op = opt_op; one = None};
-  comm = (fun _ _ -> ());
-  assoc = (fun _ _ _ -> ());
-  assoc_r = (fun _ _ _ -> ());
-  is_unit = (fun _ -> ());
-  refine = (fun x -> Some? x == true);
-}
-
-let opt_pcm #a : pcm (option a) = pcm_of_fstar_pcm fstar_opt_pcm
-
-let option: Type u#a -> Type u#a = option
-
-let none #a: Ghost.erased (option a) = None
-
-[@@__reduce__]
-let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
-
-let some_v (x: Ghost.erased (option 'a){Some? x}): Ghost.erased 'a = Some?.v x
-
-val opt_read
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (r: ref a (opt_pcm #b))
-: Steel b
-    (r `pts_to` Some #b x)
-    (fun _ -> r `pts_to` Some #b x)
-    (requires fun _ -> True)
-    (ensures fun _ x' _ -> Ghost.reveal x == x')
-
-val opt_write
-  (#a:Type) (#b:Type) (#x: Ghost.erased b)
-  (r: ref a (opt_pcm #b)) (y: b)
-: SteelT unit
-    (r `pts_to` Some #b x)
-    (fun _ -> r `pts_to` Some y)
-
 let opt_view
   (a: Type)
 : Tot (sel_view (opt_pcm #a) a false)
@@ -61,53 +17,7 @@ let opt_view
   to_view_frame = (fun x frame -> ());
 }
 
-let exclusive_opt
-  (#a: Type)
-  (x: option a)
-: Lemma
-  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
-=
-  match x with
-  | None ->
-    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
-    then begin
-      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
-      assert (composable opt_pcm x (Some y))
-    end else begin
-      let phi
-        (frame: option a)
-      : Lemma
-        (frame == None)
-      = match frame with
-        | None -> ()
-        | Some z -> assert (exists (y: a) . True)
-      in
-      Classical.forall_intro phi
-    end
-  | Some _ -> ()
-
-let opt_pcm_fpu
-  (#a: Type)
-  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
-  (y: a)
-: Tot (frame_preserving_upd opt_pcm x (Some y))
-= base_fpu opt_pcm x (Some y)
-
-val opt_pcm_write
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
-: Steel unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ _ _ -> True))
-
-val opt_pcm_read
-  (#a:Type) (#b: Type)
-  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
-: Steel b (r `pts_to` x) (fun _ -> r `pts_to` x)
-  (requires (fun _ -> Some? x))
-  (ensures (fun _ y _ -> Ghost.reveal x == Some y))
-
-let opt_read_sel
+val opt_read_sel
   (#a: Type u#0) (#b: Type u#0)
   (r: ref a (opt_pcm #b))
 : Steel b
@@ -118,9 +28,8 @@ let opt_read_sel
     res == h (pts_to_view r (opt_view b)) /\
     res == h' (pts_to_view r (opt_view b))
   ))
-= ref_read_sel r (opt_view b)
 
-let opt_write_sel
+val opt_write_sel
   (#a: Type u#0) (#b: Type u#0)
   (r: ref a (opt_pcm #b))
   (w: b)
@@ -131,14 +40,10 @@ let opt_write_sel
   (ensures (fun _ _ h' ->
     w == h' (pts_to_view r (opt_view b))
   ))
-=
-  let _ = pts_to_view_elim r (opt_view _) in
-  opt_pcm_write r _ w;
-  pts_to_view_intro r _ (opt_view _) w
 
 open Steel.C.Reference
 
-let ref_opt_read
+val ref_opt_read
   (#a: Type u#0) (#b: Type u#0)
   (r: ref a b (opt_pcm #b))
 : Steel b
@@ -149,9 +54,8 @@ let ref_opt_read
     res == h (pts_to_view r (opt_view b)) /\
     res == h' (pts_to_view r (opt_view b))
   ))
-= ref_read_sel r (opt_view b)
 
-let ref_opt_write
+val ref_opt_write
   (#a: Type u#0) (#b: Type u#0)
   (r: ref a b (opt_pcm #b))
   (w: b)
@@ -162,7 +66,6 @@ let ref_opt_write
   (ensures (fun _ _ h' ->
     w == h' (pts_to_view r (opt_view b))
   ))
-= opt_write_sel r w
 
 val malloc
   (#c:Type0) (x: c)
diff --git a/ulib/experimental/Steel.ST.C.Opt.fst b/ulib/experimental/Steel.ST.C.Opt.fst
new file mode 100644
index 00000000000..e03b4b3d7f9
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Opt.fst
@@ -0,0 +1,46 @@
+module Steel.ST.C.Opt
+
+let opt_read r =
+  rewrite (r `pts_to` _) (r `pts_to` _);
+  let Some x = ref_read r in
+  x
+
+let opt_write #a #b #x r y =
+  rewrite (r `pts_to` _) (r `pts_to` _);
+  ref_upd r (Some (Ghost.reveal x)) (Some y) (fun (Some _) -> Some y);
+  rewrite (r `pts_to` _) (r `pts_to` _)
+
+let exclusive_opt
+  #a x
+=
+  match x with
+  | None ->
+    if FStar.StrongExcludedMiddle.strong_excluded_middle (exists (y: a). True)
+    then begin
+      let y = FStar.IndefiniteDescription.indefinite_description_ghost a (fun _ -> True) in
+      assert (composable opt_pcm x (Some y))
+    end else begin
+      let phi
+        (frame: option a)
+      : Lemma
+        (frame == None)
+      = match frame with
+        | None -> ()
+        | Some z -> assert (exists (y: a) . True)
+      in
+      Classical.forall_intro phi
+    end
+  | Some _ -> ()
+
+let opt_pcm_read
+  #a #b r x
+= rewrite (r `pts_to` _) (r `pts_to` _);
+  let y' = ref_read r in
+  assert (Ghost.reveal x == y');
+  Some?.v y'
+
+let opt_pcm_write
+  #a #b r x y
+= rewrite (r `pts_to` _) (r `pts_to` _);
+  ref_upd r x (Some y) (opt_pcm_fpu x y);
+  rewrite (r `pts_to` _) (r `pts_to` _)
diff --git a/ulib/experimental/Steel.ST.C.Opt.fsti b/ulib/experimental/Steel.ST.C.Opt.fsti
new file mode 100644
index 00000000000..1b5fb94e1f1
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Opt.fsti
@@ -0,0 +1,78 @@
+module Steel.ST.C.Opt
+
+module P = FStar.PCM
+open Steel.ST.Util
+open Steel.C.Model.PCM
+open Steel.ST.C.Model.Ref
+
+/// If no custom PCM is needed, p and q can be instantiated with an all-or-none PCM:
+
+let opt_comp (x y: option 'a): prop = match x, y with
+  | None, _ | _, None -> True
+  | _, _ -> False
+
+let opt_op (x: option 'a) (y: option 'a{opt_comp x y}): option 'a = match x, y with
+  | None, z | z, None -> z
+
+let fstar_opt_pcm #a : P.pcm (option a) = let open P in {
+  p = {composable = opt_comp; op = opt_op; one = None};
+  comm = (fun _ _ -> ());
+  assoc = (fun _ _ _ -> ());
+  assoc_r = (fun _ _ _ -> ());
+  is_unit = (fun _ -> ());
+  refine = (fun x -> Some? x == true);
+}
+
+let opt_pcm #a : pcm (option a) = pcm_of_fstar_pcm fstar_opt_pcm
+
+let option: Type u#a -> Type u#a = option
+
+let none #a: Ghost.erased (option a) = None
+
+[@@__reduce__]
+let some (x: Ghost.erased 'a): Ghost.erased (option 'a) = Some (Ghost.reveal x)
+
+let some_v (x: Ghost.erased (option 'a){Some? x}): Ghost.erased 'a = Some?.v x
+
+val opt_read
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (opt_pcm #b))
+: ST b
+    (r `pts_to` Some #b x)
+    (fun _ -> r `pts_to` Some #b x)
+    (requires True)
+    (ensures fun x' -> Ghost.reveal x == x')
+
+val opt_write
+  (#a:Type) (#b:Type) (#x: Ghost.erased b)
+  (r: ref a (opt_pcm #b)) (y: b)
+: STT unit
+    (r `pts_to` Some #b x)
+    (fun _ -> r `pts_to` Some y)
+
+val exclusive_opt
+  (#a: Type)
+  (x: option a)
+: Lemma
+  (exclusive opt_pcm x <==> ((exists (y: a) . True) ==> Some? x))
+
+let opt_pcm_fpu
+  (#a: Type)
+  (x: Ghost.erased (option a) { ~ (Ghost.reveal x == one opt_pcm) })
+  (y: a)
+: Tot (frame_preserving_upd opt_pcm x (Some y))
+= base_fpu opt_pcm x (Some y)
+
+val opt_pcm_read
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b))
+: ST b (r `pts_to` x) (fun _ -> r `pts_to` x)
+  (requires (Some? x))
+  (ensures (fun y -> Ghost.reveal x == Some y))
+
+val opt_pcm_write
+  (#a:Type) (#b: Type)
+  (r: ref a (opt_pcm #b)) (x: Ghost.erased (option b)) (y: b)
+: ST unit (r `pts_to` x) (fun _ -> r `pts_to` Some y)
+  (requires (Some? x))
+  (ensures (fun _ -> True))

From d5f4318a77711a60ee2c7872440cc3148eb7a9ee Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 08:59:53 -0800
Subject: [PATCH 418/513] struct

---
 ulib/experimental/Steel.C.Model.Struct.fst    | 880 +----------------
 ulib/experimental/Steel.ST.C.Model.Struct.fst | 889 ++++++++++++++++++
 2 files changed, 891 insertions(+), 878 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Struct.fst

diff --git a/ulib/experimental/Steel.C.Model.Struct.fst b/ulib/experimental/Steel.C.Model.Struct.fst
index 474a4c52039..a33a74de09c 100644
--- a/ulib/experimental/Steel.C.Model.Struct.fst
+++ b/ulib/experimental/Steel.C.Model.Struct.fst
@@ -1,5 +1,7 @@
 module Steel.C.Model.Struct
+include Steel.ST.C.Model.Struct
 
+module STC = Steel.ST.Coercions
 module P = FStar.PCM
 open Steel.C.Model.PCM
 open Steel.C.Model.Connection
@@ -8,887 +10,9 @@ open Steel.C.Model.Ref
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-(** A PCM for structs *)
-
-/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
-
 open FStar.FunctionalExtensionality
 open FStar.Classical
-let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
-  extensionality 'a 'b f g;
-  forall_intro fg
-
-let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
-  forall k. composable (p k) (x k) (y k)
-
-let prod_op (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: restricted_t 'a 'b
-= on_domain 'a (fun k -> op (p k) (x k) (y k) <: 'b k)
-
-let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
-  on_domain 'a (fun k -> one (p k))
-
-let prod_comm (p:(k:'a -> pcm ('b k)))
-  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
-: Lemma (prod_op p x y == prod_op p y x)
-= ext (prod_op p x y) (prod_op p y x) (fun k -> ())
-
-let prod_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
-: Lemma (prod_comp p x y /\
-         prod_comp p (prod_op p x y) z /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (x k) (y k) /\
-           composable (p k) (op (p k) (x k) (y k)) (z k)) 
-    [SMTPat (p k)]
-  = ()
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> ())
-
-let prod_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
-: Lemma (prod_comp p y z /\
-         prod_comp p x (prod_op p y z) /\
-         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
-= let aux k
-  : Lemma (composable (p k) (y k) (z k) /\
-           composable (p k) (x k) (op (p k) (y k) (z k)))
-    [SMTPat (p k)]
-  = ()
-  in
-  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
-    (fun k -> ())
-
-let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
-: Lemma (prod_comp p x (prod_one p) /\
-         prod_op p x (prod_one p) == x)
-= let is_unit k
-  : Lemma (composable (p k) (x k) (prod_one p k))
-    [SMTPat (p k)]
-  = ()
-  in ext (prod_op p x (prod_one p)) x (fun k -> ())
-
-let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
-  (exists (k: 'a). True) /\ (forall k. p_refine (p k) (x k))
-
-let fstar_prod_pcm (p:(k:'a -> pcm ('b k))): P.pcm (restricted_t 'a 'b) = let open P in {
-  comm = prod_comm p;
-  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
-  assoc = prod_assoc p;
-  assoc_r = prod_assoc_r p;
-  is_unit = prod_is_unit p;
-  refine = prod_refine p
-}
-
-let prod_pcm' (p:(k:'a -> pcm ('b k))): pcm0 (restricted_t 'a 'b) = pcm_of_fstar_pcm (fstar_prod_pcm p)
-
-let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
-  let p' = prod_pcm' p in
-  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
-    x `feq` one p' /\ y `feq` one p'
-  ));
-  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
-  prod_pcm' p
-
-let prod_pcm_ext
-  (#a: Type)
-  (#b: (a -> Type))
-  (p1 p2: ((k: a) -> pcm (b k)))
-  (p_eq: (
-    (k: a) ->
-    Lemma
-    (p1 k == p2 k)
-  ))
-: Lemma
-  (prod_pcm p1 == prod_pcm p2)
-= Classical.forall_intro p_eq;
-  pcm0_ext (prod_pcm p1) (prod_pcm p2)
-    (fun x y -> ())
-    (fun x y -> assert (op (prod_pcm p1) x y `feq` op (prod_pcm p2) x y))
-    (fun _ -> ())
-    (assert (one (prod_pcm p1) `feq` one (prod_pcm p2)))
-
-let prod_pcm_composable_intro0
-  (p:(k:'a -> pcm ('b k)))
-  (x y: restricted_t 'a 'b)
-: Lemma
-  ((composable (prod_pcm p) x y <==> prod_comp p x y) /\
-  (composable (prod_pcm p) x y ==> op (prod_pcm p) x y == prod_op p x y))
-  [SMTPat (composable (prod_pcm p) x y)]
-= ()
-
-let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
-  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
-: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
-
-let field_to_struct_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-: Pure (restricted_t a b)
-  (requires True)
-  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
-= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
-
-let field_to_struct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (p k) (prod_pcm p))
-= mkmorphism
-    (field_to_struct_f p k)
-    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
-    (fun x1 x2 ->
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
-        ())
-
-let struct_to_field_f
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: restricted_t a b)
-: Tot (b k)
-= x k
-
-let struct_to_field
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (prod_pcm p) (p k))
-= mkmorphism
-    (struct_to_field_f p k) ()
-    (fun x1 x2 -> ())
-
-let struct_field_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: restricted_t a b {
-    p_refine (prod_pcm p) v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Tot (restricted_t a b)
-= 
-    on_dom a (fun k' ->
-      if k' = k
-      then f (v k) <: b k'
-      else v k'
-    )
-
-#push-options "--query_stats --z3rlimit 30"
-#restart-solver
-
-let struct_field_lift_fpu_prf
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: restricted_t a b {
-    p_refine (prod_pcm p) v /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
-  })
-: Lemma
-  (let v_new = struct_field_lift_fpu' p k x y f v in
-    p_refine (prod_pcm p) v_new /\
-    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
-    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
-  )
-=
-  let y' = (field_to_struct p k).morph y in
-  let v_new = struct_field_lift_fpu' p k x y f v in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  assert (forall (frame: b k) .
-    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
-    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
-    composable (prod_pcm p) y' frame' /\
-    op (prod_pcm p) frame' y' `feq` v_new
-  ));
-  assert (compatible (prod_pcm p) y' v_new);
-  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
-       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
-       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
-  ()
-
-#pop-options
-
-let struct_field_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
-= fun v ->
-    struct_field_lift_fpu_prf p k x y f v;
-    struct_field_lift_fpu' p k x y f v
-
-let struct_field
-  (#a: eqtype)
-  (#b: a -> Type u#b)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (connection (prod_pcm p) (p k))
-= mkconnection
-    (field_to_struct p k)
-    (struct_to_field p k)
-    ()
-    (struct_field_lift_fpu p k)
-
-#push-options "--split_queries"
-
-#restart-solver
-let struct_field_ext
-  (#a: eqtype)
-  (#b: a -> Type u#b)
-  (p1 p2:(k: a -> pcm (b k)))
-  (p_eq: (
-    (k: a) ->
-    Lemma
-    (p1 k == p2 k)
-  ))
-  (k: a)
-: Lemma
-  (prod_pcm p1 == prod_pcm p2 /\
-    p1 k == p2 k /\
-    struct_field p1 k === struct_field p2 k
-  )
-= prod_pcm_ext p1 p2 p_eq;
-  p_eq k;
-  Classical.forall_intro p_eq;
-  let l = struct_field p1 k in
-  let m : connection (prod_pcm p1) (p1 k) = coerce_eq () (struct_field p2 k) in
-  assert (forall x . field_to_struct_f p1 k x `feq` field_to_struct_f p2 k x);
-  connection_eq_gen
-    l
-    m
-    ()
-    (fun x y f v ->
-      struct_field_lift_fpu_prf p1 k x y f v;
-      struct_field_lift_fpu_prf p2 k x y f v;
-      assert (forall k' . struct_field_lift_fpu' p1 k x y f v k' == struct_field_lift_fpu' p2 k x y f v k');
-      assert (struct_field_lift_fpu' p1 k x y f v == struct_field_lift_fpu' p2 k x y f v);
-      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
-    )
-
-#pop-options
-
-let is_substruct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-: Tot prop
-= (forall (k: a') . b' k == b (inj k) /\ p' k == p (inj k)) /\
-  (forall (k: a') . surj (inj k) == Some k) /\
-  (forall (k: a) . (match surj k with None -> True | Some k' -> inj k' == k))
-
-let substruct_to_struct_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (x: restricted_t a' b')
-: Pure (restricted_t a b)
-  (requires True)
-  (ensures (fun y -> forall k . y k == (match surj k with Some k' -> (x k' <: b k) | _ -> one (p k))))
-= on_dom a (fun k -> match surj k with Some k' -> (x k' <: b k) | _ -> one (p k))
-
-let substruct_to_struct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-: Tot (morphism (prod_pcm p') (prod_pcm p))
-= mkmorphism
-    (substruct_to_struct_f p p' inj surj sq)
-    (assert (substruct_to_struct_f p p' inj surj sq (one (prod_pcm p')) `feq` one (prod_pcm p)))
-    (fun x1 x2 ->
-      assert (prod_op p (substruct_to_struct_f p p' inj surj sq x1) (substruct_to_struct_f p p' inj surj sq x2) `feq` substruct_to_struct_f p p' inj surj sq (prod_op p' x1 x2))
-    )
-
-let struct_to_substruct_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (x: restricted_t a b)
-: Pure (restricted_t a' b')
-  (requires True)
-  (ensures (fun y -> forall k . y k == x (inj k)))
-= on_dom a' (fun k -> x (inj k) <: b' k)
-
-let struct_to_substruct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-: Tot (morphism (prod_pcm p) (prod_pcm p'))
-= mkmorphism
-    (struct_to_substruct_f p p' inj surj sq)
-    (assert (struct_to_substruct_f p p' inj surj sq (one (prod_pcm p)) `feq` one (prod_pcm p')))
-    (fun x1 x2 ->
-      assert (prod_op p' (struct_to_substruct_f p p' inj surj sq x1) (struct_to_substruct_f p p' inj surj sq x2) `feq` struct_to_substruct_f p p' inj surj sq (prod_op p x1 x2))
-    )
-
-let substruct_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
-  (y': Ghost.erased (restricted_t a' b'))
-  (f': frame_preserving_upd (prod_pcm p') x' y')
-  (v: restricted_t a b {
-    p_refine (prod_pcm p) v /\
-    compatible (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') v
-  })
-: Tot (restricted_t a b)
-= 
-    on_dom a (fun k ->
-      let v' = ((struct_to_substruct p p' inj surj sq).morph v) in
-      let x = Ghost.hide ((substruct_to_struct p p' inj surj sq).morph x') in
-      assert (forall frame . (composable (prod_pcm p) x frame /\ op (prod_pcm p) x frame == v) ==> (
-        let frame' = (struct_to_substruct p p' inj surj sq).morph frame in
-        composable (prod_pcm p') x' frame' /\ op (prod_pcm p') x' frame' `feq` v'
-      ));
-      assert ((~ (exists (k' : a') . True)) ==> Ghost.reveal x' `feq` one (prod_pcm p'));
-      match surj k with
-      | Some k' -> f' v' k' <: b k
-      | _ -> v k
-    )
-
-#push-options "--query_stats --z3rlimit 64 --split_queries"
-
-#restart-solver
-let substruct_lift_fpu_prf
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
-  (y': Ghost.erased (restricted_t a' b'))
-  (f': frame_preserving_upd (prod_pcm p') x' y')
-  (v: restricted_t a b {
-    p_refine (prod_pcm p) v /\
-    compatible (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') v
-  })
-: Lemma
-  (let v_new = substruct_lift_fpu' p p' inj surj sq x' y' f' v in
-    frame_preserving_upd_post (prod_pcm p)
-    ((substruct_to_struct p p' inj surj sq).morph x')
-    ((substruct_to_struct p p' inj surj sq).morph y')
-    v
-    (substruct_lift_fpu' p p' inj surj sq x' y' f' v)
-  )
-=
-  let y = (substruct_to_struct p p' inj surj sq).morph y' in
-  let v_new = substruct_lift_fpu' p p' inj surj sq x' y' f' v in
-  let v' = ((struct_to_substruct p p' inj surj sq).morph v) in
-  let x = Ghost.hide ((substruct_to_struct p p' inj surj sq).morph x') in
-  assert (forall frame . (composable (prod_pcm p) x frame /\ op (prod_pcm p) x frame == v) ==> (
-    let frame' = (struct_to_substruct p p' inj surj sq).morph frame in
-    composable (prod_pcm p') x' frame' /\ op (prod_pcm p') x' frame' `feq` v'
-  ));
-  assert ((~ (exists (k' : a') . True)) ==> Ghost.reveal x' `feq` one (prod_pcm p'));
-  assert (compatible (prod_pcm p') y' (f' v'));
-  assert (forall (frame': restricted_t a' b') .
-    (composable (prod_pcm p') y' frame' /\ op (prod_pcm p') frame' y' == f' v') ==> (
-    let frame : restricted_t a b = on_dom a (fun k -> match surj k with None -> v_new k | Some k' -> frame' k' <: b k) in
-    composable (prod_pcm p) y frame /\
-    op (prod_pcm p) frame y `feq` v_new
-  ));
-  assert (compatible (prod_pcm p) y v_new);
-  assert (p_refine (prod_pcm p) v_new);
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  let prf (frame: restricted_t a b) : Lemma
-    (requires (
-      composable (prod_pcm p) x frame
-    ))
-    (ensures (
-      composable (prod_pcm p) x frame /\
-      composable (prod_pcm p) y frame /\
-      (op (prod_pcm p) x frame == v ==> op (prod_pcm p) y frame `feq` v_new)
-    ))
-  =
-    let frame' = struct_to_substruct_f p p' inj surj sq frame in
-    assert (composable (prod_pcm p') x' frame');
-    assert (composable (prod_pcm p') y' frame');
-    assert (op (prod_pcm p) x frame == v ==> op (prod_pcm p') x' frame' `feq` v');
-    ()
-  in
-  Classical.forall_intro (Classical.move_requires prf)
-
-#pop-options
-
-let substruct_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
-  (y': Ghost.erased (restricted_t a' b'))
-  (f': frame_preserving_upd (prod_pcm p') x' y')
-: Tot (frame_preserving_upd (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') ((substruct_to_struct p p' inj surj sq).morph y'))
-= fun v ->
-    substruct_lift_fpu_prf p p' inj surj sq x' y' f' v;
-    substruct_lift_fpu' p p' inj surj sq x' y' f' v
-
-let substruct
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-: Tot (connection (prod_pcm p) (prod_pcm p'))
-= mkconnection
-    (substruct_to_struct p p' inj surj sq)
-    (struct_to_substruct p p' inj surj sq)
-    (assert (forall x .
-      struct_to_substruct_f p p' inj surj sq (substruct_to_struct_f p p' inj surj sq x) `feq` x
-    ))
-    (substruct_lift_fpu p p' inj surj sq)
-
-#push-options "--query_stats --z3rlimit 64"
-
-#restart-solver
-let substruct_id
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (inj: (a -> a))
-  (surj: (a -> option a))
-  (sq: squash (
-    (forall x . inj x == x) /\
-    (forall x . surj x == Some x)
-  ))
-: Lemma
-  (substruct p p inj surj () == connection_id (prod_pcm p))
-= let l = substruct p p inj surj () in
-  let m = connection_id (prod_pcm p) in
-  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
-    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
-  in
-  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) = () in
-  connection_eq_gen
-    l
-    m
-    ()
-    (fun x y f v ->
-      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
-    )
-
-#pop-options
-
-#push-options "--query_stats --z3rlimit 256"
-
-#restart-solver
-let substruct_compose
-  (#a1: eqtype)
-  (#b1: a1 -> Type)
-  (p1:(k: a1 -> pcm (b1 k)))
-  (#a2: eqtype)
-  (#b2: (a2 -> Type))
-  (p2: (k: a2 -> pcm (b2 k)))
-  (inj21: (a2 -> a1))
-  (surj12: (a1 -> option a2))
-  (sq12: squash (is_substruct p1 p2 inj21 surj12))
-  (#a3: eqtype)
-  (#b3: (a3 -> Type))
-  (p3: (k: a3 -> pcm (b3 k)))
-  (inj32: (a3 -> a2))
-  (surj23: (a2 -> option a3))
-  (sq23: squash (is_substruct p2 p3 inj32 surj23))
-  (inj31: (a3 -> a1))
-  (surj13: (a1 -> option a3))
-  (sq13: squash (is_substruct p1 p3 inj31 surj13))
-: Lemma
-  (requires (
-    (forall x3 . inj31 x3 == inj21 (inj32 x3)) /\
-    (forall x1 . surj13 x1 == (match surj12 x1 with
-    | None -> None
-    | Some x2 -> surj23 x2
-  ))))
-  (ensures (
-    substruct p1 p3 inj31 surj13 sq13 ==
-      substruct p1 p2 inj21 surj12 sq12 `connection_compose`
-      substruct p2 p3 inj32 surj23 sq23
-  ))
-=
-  let c12 = substruct p1 p2 inj21 surj12 sq12 in
-  let c23 = substruct p2 p3 inj32 surj23 sq23 in
-  let l = substruct p1 p3 inj31 surj13 sq13 in
-  let m = connection_compose c12 c23 in
-  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
-    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
-  in
-  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) =
-    assert (forall x . l.conn_large_to_small.morph x `feq` m.conn_large_to_small.morph x)
-  in
-  connection_eq_gen
-    l
-    m
-    ()
-    (fun x y f v ->
-      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
-    )
-
-#pop-options
-
-#push-options "--query_stats --z3rlimit 64"
-
-#restart-solver
-let substruct_field
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (field': a')
-: Lemma
-  (substruct p p' inj surj sq `connection_compose` struct_field p' field' ==
-    struct_field p (inj field')
-  )
-=
-  let l = substruct p p' inj surj sq `connection_compose` struct_field p' field' in
-  let m = struct_field p (inj field') in
-  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
-    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
-  in
-  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) = () in
-  connection_eq_gen
-    l
-    m
-    ()
-    (fun x y f v ->
-      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
-    )
-
-#pop-options
-
-let substruct_erase_fields
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (surj: (a -> option a'))
-  (f: restricted_t a b)
-: Tot (restricted_t a b)
-= on_dom a (fun x -> if Some? (surj x) then one (p x) else f x)
-
-let substruct_erase_fields_op
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (f: restricted_t a b)
-: Lemma
-  (
-    let f_sub = substruct_to_struct_f p p' inj surj sq (struct_to_substruct_f p p' inj surj sq f) in
-    let f_rem = substruct_erase_fields p surj f in
-    composable (prod_pcm p) f_sub f_rem /\
-    op (prod_pcm p) f_sub f_rem `feq` f
-  )
-= Classical.forall_intro_2 (fun k -> is_unit (p k))
-
-let substruct_composable
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (f: restricted_t a b)
-  (g': restricted_t a' b')
-: Lemma
-  (requires (
-    forall x' . f (inj x') == one (p' x')
-  ))
-  (ensures (
-    let g = substruct_to_struct_f p p' inj surj sq g' in
-    composable (prod_pcm p) f g /\
-    (forall x . op (prod_pcm p) f g x == (match surj x with None -> f x | Some x' -> g' x' <: b x))
-  ))
-= Classical.forall_intro_2 (fun k -> is_unit (p k))
-
-let substruct_pts_to_intro
-  (#opened: _)
-  (#base: Type)
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (r: ref base (prod_pcm p))
-  (f: restricted_t a b)
-: A.SteelGhostT unit opened
-    (pts_to r f)
-    (fun _ ->
-      pts_to r (substruct_erase_fields p surj f) `star`
-      pts_to (r `ref_focus` substruct p p' inj surj sq) (struct_to_substruct_f p p' inj surj sq f)
-    )
-= substruct_erase_fields_op p p' inj surj sq f;
-  split r _ (substruct_erase_fields p surj f) (substruct_to_struct_f p p' inj surj sq (struct_to_substruct_f p p' inj surj sq f));
-  gfocus r (substruct p p' inj surj sq) (substruct_to_struct_f _ _ _ _ _ _) _
-
-let substruct_pts_to_elim
-  (#opened: _)
-  (#base: Type)
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (#a': eqtype)
-  (#b': (a' -> Type))
-  (p': (k: a' -> pcm (b' k)))
-  (inj: (a' -> a))
-  (surj: (a -> option a'))
-  (sq: squash (is_substruct p p' inj surj))
-  (r: ref base (prod_pcm p))
-  (f: restricted_t a b)
-  (g': restricted_t a' b')
-: A.SteelGhost (Ghost.erased (restricted_t a b)) opened
-    (pts_to r f `star` pts_to (r `ref_focus` substruct p p' inj surj sq) g')
-    (fun res -> pts_to r res)
-    (fun _ ->
-      forall x' . f (inj x') == one (p' x')
-    )
-    (fun _ res _ ->
-      let g = substruct_to_struct_f p p' inj surj sq g' in
-      composable (prod_pcm p) f g /\
-      Ghost.reveal res == op (prod_pcm p) f g /\
-      (forall x . Ghost.reveal res x == (match surj x with None -> f x | Some x' -> g' x' <: b x))
-    )
-= substruct_composable p p' inj surj sq f g';
-  let g = substruct_to_struct_f p p' inj surj sq g' in
-  let res = Ghost.hide (op (prod_pcm p) f g) in
-  unfocus (r `ref_focus` _) r (substruct p p' inj surj sq) _;
-  let _ = gather r f _ in
-  A.change_equal_slprop
-    (pts_to r _)
-    (pts_to r res);
-  res
-
-let exclusive_struct_intro
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (x: restricted_t a b)
-: Lemma
-  (requires (
-    forall k . exclusive (p k) (struct_to_field_f p k x)
-  ))
-  (ensures (
-    exclusive (prod_pcm p) x
-  ))
-  [SMTPat (exclusive (prod_pcm p) x)]
-=
-  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
-
-let exclusive_struct_elim
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (x: restricted_t a b)
-  (k: a)
-: Lemma
-  (requires (exclusive (prod_pcm p) x))
-  (ensures (exclusive (p k) (struct_to_field_f p k x)))
-=
-  let phi
-    frame
-  : Lemma
-    (requires (composable (p k) (struct_to_field_f p k x) frame))
-    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
-    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
-  = let x' = struct_to_field_f p k x in
-    let f' = field_to_struct_f p k frame in
-    let psi
-      k'
-    : Lemma
-      (composable (p k') (x k') (f' k'))
-      [SMTPat (composable (p k') (x k') (f' k'))]
-    = if k' = k
-      then ()
-      else is_unit (p k') (x k')
-    in
-    ()
-  in
-  ()
-
-let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (xs: restricted_t a b)
-: restricted_t a b
-= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
-
-let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (xs: restricted_t a b)
-: Lemma (
-    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
-    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
-
-let g_addr_of_struct_field
-  (#opened: _)
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: A.SteelGhostT unit opened
-    (r `pts_to` xs)
-    (fun _ ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (ref_focus r (struct_field p k) `pts_to` Ghost.reveal xs k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  gfocus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
-
-let addr_of_struct_field
-  (#opened: _)
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: ref base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: A.SteelAtomicBase (ref base (p k)) false opened A.Unobservable
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _);
-  A.return r
-
-(*
-let ptr_addr_of_struct_field
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
-  (r: Ptr.ptr base (prod_pcm p)) (k:a)
-  (xs: Ghost.erased (restricted_t a b))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun s ->
-      (r `pts_to` struct_without_field p k xs) `star` 
-      (s `pts_to` Ghost.reveal xs k))
-    (requires fun _ -> True)
-    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
-= struct_peel p k xs;
-  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
-  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.return r
-*)
-
-let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (x:b k) (xs: restricted_t a b)
-: restricted_t a b
-= on_dom a (fun k' -> if k' = k then x else xs k')
-
-let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
-  (x: b k) (xs: restricted_t a b)
-: Lemma
-    (requires xs k == one (p k))
-    (ensures
-      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
-      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
-= Classical.forall_intro_2 (fun k -> is_unit (p k));
-  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
 
-let unaddr_of_struct_field
-  (#opened: _)
-  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (prod_pcm p))
-  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
-: A.SteelGhost unit opened
-    ((r `pts_to` xs) `star` (r' `pts_to` x))
-    (fun s -> r `pts_to` struct_with_field p k x xs)
-    (requires fun _ -> r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
-    (ensures fun _ _ _ -> True)
-= unfocus r' r (struct_field p k) x;
-  let _ = gather r xs (field_to_struct_f p k x) in
-  struct_unpeel p k x xs;
-  A.change_equal_slprop (r `pts_to` _) (r `pts_to` _)
 
 (*
 let struct_view_to_view_prop
diff --git a/ulib/experimental/Steel.ST.C.Model.Struct.fst b/ulib/experimental/Steel.ST.C.Model.Struct.fst
new file mode 100644
index 00000000000..c4bacb8737d
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Struct.fst
@@ -0,0 +1,889 @@
+module Steel.ST.C.Model.Struct
+open Steel.ST.Util
+
+module P = FStar.PCM
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+open Steel.ST.C.Model.Ref
+
+(** A PCM for structs *)
+
+/// We can generalize to 'a-ary products (k:'a -> 'b k), given a PCM for each k:
+
+open FStar.FunctionalExtensionality
+open FStar.Classical
+let ext (f g: restricted_t 'a 'b) (fg:(x:'a -> Lemma (f x == g x))) : Lemma (f == g) =
+  extensionality 'a 'b f g;
+  forall_intro fg
+
+let prod_comp (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b): prop =
+  forall k. composable (p k) (x k) (y k)
+
+let prod_op (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: restricted_t 'a 'b
+= on_domain 'a (fun k -> op (p k) (x k) (y k) <: 'b k)
+
+let prod_one (p:(k:'a -> pcm ('b k))): restricted_t 'a 'b =
+  on_domain 'a (fun k -> one (p k))
+
+let prod_comm (p:(k:'a -> pcm ('b k)))
+  (x: restricted_t 'a 'b) (y: restricted_t 'a 'b{prod_comp p x y})
+: Lemma (prod_op p x y == prod_op p y x)
+= ext (prod_op p x y) (prod_op p y x) (fun k -> ())
+
+let prod_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p y z /\ prod_comp p x (prod_op p y z)})
+: Lemma (prod_comp p x y /\
+         prod_comp p (prod_op p x y) z /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (x k) (y k) /\
+           composable (p k) (op (p k) (x k) (y k)) (z k)) 
+    [SMTPat (p k)]
+  = ()
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> ())
+
+let prod_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+  (z: restricted_t 'a 'b{prod_comp p x y /\ prod_comp p (prod_op p x y) z})
+: Lemma (prod_comp p y z /\
+         prod_comp p x (prod_op p y z) /\
+         prod_op p x (prod_op p y z) == prod_op p (prod_op p x y) z)
+= let aux k
+  : Lemma (composable (p k) (y k) (z k) /\
+           composable (p k) (x k) (op (p k) (y k) (z k)))
+    [SMTPat (p k)]
+  = ()
+  in
+  ext (prod_op p x (prod_op p y z)) (prod_op p (prod_op p x y) z)
+    (fun k -> ())
+
+let prod_is_unit (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b)
+: Lemma (prod_comp p x (prod_one p) /\
+         prod_op p x (prod_one p) == x)
+= let is_unit k
+  : Lemma (composable (p k) (x k) (prod_one p k))
+    [SMTPat (p k)]
+  = ()
+  in ext (prod_op p x (prod_one p)) x (fun k -> ())
+
+let prod_refine (p:(k:'a -> pcm ('b k))) (x: restricted_t 'a 'b): prop =
+  (exists (k: 'a). True) /\ (forall k. p_refine (p k) (x k))
+
+let fstar_prod_pcm (p:(k:'a -> pcm ('b k))): P.pcm (restricted_t 'a 'b) = let open P in {
+  comm = prod_comm p;
+  p = {composable = prod_comp p; op = prod_op p; one = prod_one p};
+  assoc = prod_assoc p;
+  assoc_r = prod_assoc_r p;
+  is_unit = prod_is_unit p;
+  refine = prod_refine p
+}
+
+let prod_pcm' (p:(k:'a -> pcm ('b k))): pcm0 (restricted_t 'a 'b) = pcm_of_fstar_pcm (fstar_prod_pcm p)
+
+let prod_pcm (p:(k:'a -> pcm ('b k))): pcm (restricted_t 'a 'b) =
+  let p' = prod_pcm' p in
+  assert (forall x y . (composable p' x y /\ op p' x y == one p') ==> (
+    x `feq` one p' /\ y `feq` one p'
+  ));
+  assert (forall x frame . (prod_refine p x /\ prod_comp p x frame) ==> frame `feq` prod_one p);
+  prod_pcm' p
+
+let prod_pcm_ext
+  (#a: Type)
+  (#b: (a -> Type))
+  (p1 p2: ((k: a) -> pcm (b k)))
+  (p_eq: (
+    (k: a) ->
+    Lemma
+    (p1 k == p2 k)
+  ))
+: Lemma
+  (prod_pcm p1 == prod_pcm p2)
+= Classical.forall_intro p_eq;
+  pcm0_ext (prod_pcm p1) (prod_pcm p2)
+    (fun x y -> ())
+    (fun x y -> assert (op (prod_pcm p1) x y `feq` op (prod_pcm p2) x y))
+    (fun _ -> ())
+    (assert (one (prod_pcm p1) `feq` one (prod_pcm p2)))
+
+let prod_pcm_composable_intro0
+  (p:(k:'a -> pcm ('b k)))
+  (x y: restricted_t 'a 'b)
+: Lemma
+  ((composable (prod_pcm p) x y <==> prod_comp p x y) /\
+  (composable (prod_pcm p) x y ==> op (prod_pcm p) x y == prod_op p x y))
+  [SMTPat (composable (prod_pcm p) x y)]
+= ()
+
+let prod_pcm_composable_intro (p:(k:'a -> pcm ('b k))) (x y: restricted_t 'a 'b)
+  (h:(k:'a -> Lemma (composable (p k) (x k) (y k))))
+: Lemma (composable (prod_pcm p) x y) = FStar.Classical.forall_intro h
+
+let field_to_struct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (restricted_t a b)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let field_to_struct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (prod_pcm p))
+= mkmorphism
+    (field_to_struct_f p k)
+    (assert (field_to_struct_f p k (one (p k)) `feq` one (prod_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (prod_op p (field_to_struct_f p k x1) (field_to_struct_f p k x2) `feq` field_to_struct_f p k (op (p k) x1 x2));
+        ())
+
+let struct_to_field_f
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: restricted_t a b)
+: Tot (b k)
+= x k
+
+let struct_to_field
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (prod_pcm p) (p k))
+= mkmorphism
+    (struct_to_field_f p k) ()
+    (fun x1 x2 -> ())
+
+let struct_field_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    p_refine (prod_pcm p) v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Tot (restricted_t a b)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else v k'
+    )
+
+#push-options "--query_stats --z3rlimit 30"
+#restart-solver
+
+let struct_field_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: restricted_t a b {
+    p_refine (prod_pcm p) v /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph x) v
+  })
+: Lemma
+  (let v_new = struct_field_lift_fpu' p k x y f v in
+    p_refine (prod_pcm p) v_new /\
+    compatible (prod_pcm p) ((field_to_struct p k).morph y) v_new /\
+    (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame == v_new))
+  )
+=
+  let y' = (field_to_struct p k).morph y in
+  let v_new = struct_field_lift_fpu' p k x y f v in
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  assert (forall (frame: b k) .
+    (composable (p k) y frame /\ op (p k) frame y == f (v k)) ==> (
+    let frame' : restricted_t a b = on_dom a (fun k' -> if k' = k then (frame <: b k') else v_new k') in
+    composable (prod_pcm p) y' frame' /\
+    op (prod_pcm p) frame' y' `feq` v_new
+  ));
+  assert (compatible (prod_pcm p) y' v_new);
+  assert (forall (frame:_{composable (prod_pcm p) ((field_to_struct p k).morph x) frame}).
+       composable (prod_pcm p) ((field_to_struct p k).morph y) frame /\
+       (op (prod_pcm p) ((field_to_struct p k).morph x) frame == v ==> op (prod_pcm p) ((field_to_struct p k).morph y) frame `feq` v_new));
+  ()
+
+#pop-options
+
+let struct_field_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (prod_pcm p) ((field_to_struct p k).morph x) ((field_to_struct p k).morph y))
+= fun v ->
+    struct_field_lift_fpu_prf p k x y f v;
+    struct_field_lift_fpu' p k x y f v
+
+let struct_field
+  (#a: eqtype)
+  (#b: a -> Type u#b)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (prod_pcm p) (p k))
+= mkconnection
+    (field_to_struct p k)
+    (struct_to_field p k)
+    ()
+    (struct_field_lift_fpu p k)
+
+#push-options "--split_queries"
+
+#restart-solver
+let struct_field_ext
+  (#a: eqtype)
+  (#b: a -> Type u#b)
+  (p1 p2:(k: a -> pcm (b k)))
+  (p_eq: (
+    (k: a) ->
+    Lemma
+    (p1 k == p2 k)
+  ))
+  (k: a)
+: Lemma
+  (prod_pcm p1 == prod_pcm p2 /\
+    p1 k == p2 k /\
+    struct_field p1 k === struct_field p2 k
+  )
+= prod_pcm_ext p1 p2 p_eq;
+  p_eq k;
+  Classical.forall_intro p_eq;
+  let l = struct_field p1 k in
+  let m : connection (prod_pcm p1) (p1 k) = coerce_eq () (struct_field p2 k) in
+  assert (forall x . field_to_struct_f p1 k x `feq` field_to_struct_f p2 k x);
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      struct_field_lift_fpu_prf p1 k x y f v;
+      struct_field_lift_fpu_prf p2 k x y f v;
+      assert (forall k' . struct_field_lift_fpu' p1 k x y f v k' == struct_field_lift_fpu' p2 k x y f v k');
+      assert (struct_field_lift_fpu' p1 k x y f v == struct_field_lift_fpu' p2 k x y f v);
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v == (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
+let is_substruct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+: Tot prop
+= (forall (k: a') . b' k == b (inj k) /\ p' k == p (inj k)) /\
+  (forall (k: a') . surj (inj k) == Some k) /\
+  (forall (k: a) . (match surj k with None -> True | Some k' -> inj k' == k))
+
+let substruct_to_struct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x: restricted_t a' b')
+: Pure (restricted_t a b)
+  (requires True)
+  (ensures (fun y -> forall k . y k == (match surj k with Some k' -> (x k' <: b k) | _ -> one (p k))))
+= on_dom a (fun k -> match surj k with Some k' -> (x k' <: b k) | _ -> one (p k))
+
+let substruct_to_struct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+: Tot (morphism (prod_pcm p') (prod_pcm p))
+= mkmorphism
+    (substruct_to_struct_f p p' inj surj sq)
+    (assert (substruct_to_struct_f p p' inj surj sq (one (prod_pcm p')) `feq` one (prod_pcm p)))
+    (fun x1 x2 ->
+      assert (prod_op p (substruct_to_struct_f p p' inj surj sq x1) (substruct_to_struct_f p p' inj surj sq x2) `feq` substruct_to_struct_f p p' inj surj sq (prod_op p' x1 x2))
+    )
+
+let struct_to_substruct_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x: restricted_t a b)
+: Pure (restricted_t a' b')
+  (requires True)
+  (ensures (fun y -> forall k . y k == x (inj k)))
+= on_dom a' (fun k -> x (inj k) <: b' k)
+
+let struct_to_substruct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+: Tot (morphism (prod_pcm p) (prod_pcm p'))
+= mkmorphism
+    (struct_to_substruct_f p p' inj surj sq)
+    (assert (struct_to_substruct_f p p' inj surj sq (one (prod_pcm p)) `feq` one (prod_pcm p')))
+    (fun x1 x2 ->
+      assert (prod_op p' (struct_to_substruct_f p p' inj surj sq x1) (struct_to_substruct_f p p' inj surj sq x2) `feq` struct_to_substruct_f p p' inj surj sq (prod_op p x1 x2))
+    )
+
+let substruct_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
+  (y': Ghost.erased (restricted_t a' b'))
+  (f': frame_preserving_upd (prod_pcm p') x' y')
+  (v: restricted_t a b {
+    p_refine (prod_pcm p) v /\
+    compatible (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') v
+  })
+: Tot (restricted_t a b)
+= 
+    on_dom a (fun k ->
+      let v' = ((struct_to_substruct p p' inj surj sq).morph v) in
+      let x = Ghost.hide ((substruct_to_struct p p' inj surj sq).morph x') in
+      assert (forall frame . (composable (prod_pcm p) x frame /\ op (prod_pcm p) x frame == v) ==> (
+        let frame' = (struct_to_substruct p p' inj surj sq).morph frame in
+        composable (prod_pcm p') x' frame' /\ op (prod_pcm p') x' frame' `feq` v'
+      ));
+      assert ((~ (exists (k' : a') . True)) ==> Ghost.reveal x' `feq` one (prod_pcm p'));
+      match surj k with
+      | Some k' -> f' v' k' <: b k
+      | _ -> v k
+    )
+
+#push-options "--query_stats --z3rlimit 64 --split_queries"
+
+#restart-solver
+let substruct_lift_fpu_prf
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
+  (y': Ghost.erased (restricted_t a' b'))
+  (f': frame_preserving_upd (prod_pcm p') x' y')
+  (v: restricted_t a b {
+    p_refine (prod_pcm p) v /\
+    compatible (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') v
+  })
+: Lemma
+  (let v_new = substruct_lift_fpu' p p' inj surj sq x' y' f' v in
+    frame_preserving_upd_post (prod_pcm p)
+    ((substruct_to_struct p p' inj surj sq).morph x')
+    ((substruct_to_struct p p' inj surj sq).morph y')
+    v
+    (substruct_lift_fpu' p p' inj surj sq x' y' f' v)
+  )
+=
+  let y = (substruct_to_struct p p' inj surj sq).morph y' in
+  let v_new = substruct_lift_fpu' p p' inj surj sq x' y' f' v in
+  let v' = ((struct_to_substruct p p' inj surj sq).morph v) in
+  let x = Ghost.hide ((substruct_to_struct p p' inj surj sq).morph x') in
+  assert (forall frame . (composable (prod_pcm p) x frame /\ op (prod_pcm p) x frame == v) ==> (
+    let frame' = (struct_to_substruct p p' inj surj sq).morph frame in
+    composable (prod_pcm p') x' frame' /\ op (prod_pcm p') x' frame' `feq` v'
+  ));
+  assert ((~ (exists (k' : a') . True)) ==> Ghost.reveal x' `feq` one (prod_pcm p'));
+  assert (compatible (prod_pcm p') y' (f' v'));
+  assert (forall (frame': restricted_t a' b') .
+    (composable (prod_pcm p') y' frame' /\ op (prod_pcm p') frame' y' == f' v') ==> (
+    let frame : restricted_t a b = on_dom a (fun k -> match surj k with None -> v_new k | Some k' -> frame' k' <: b k) in
+    composable (prod_pcm p) y frame /\
+    op (prod_pcm p) frame y `feq` v_new
+  ));
+  assert (compatible (prod_pcm p) y v_new);
+  assert (p_refine (prod_pcm p) v_new);
+  Classical.forall_intro_2 (fun k -> is_unit (p k));
+  let prf (frame: restricted_t a b) : Lemma
+    (requires (
+      composable (prod_pcm p) x frame
+    ))
+    (ensures (
+      composable (prod_pcm p) x frame /\
+      composable (prod_pcm p) y frame /\
+      (op (prod_pcm p) x frame == v ==> op (prod_pcm p) y frame `feq` v_new)
+    ))
+  =
+    let frame' = struct_to_substruct_f p p' inj surj sq frame in
+    assert (composable (prod_pcm p') x' frame');
+    assert (composable (prod_pcm p') y' frame');
+    assert (op (prod_pcm p) x frame == v ==> op (prod_pcm p') x' frame' `feq` v');
+    ()
+  in
+  Classical.forall_intro (Classical.move_requires prf)
+
+#pop-options
+
+let substruct_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (x': Ghost.erased (restricted_t a' b') { ~ (Ghost.reveal x' == one (prod_pcm p')) })
+  (y': Ghost.erased (restricted_t a' b'))
+  (f': frame_preserving_upd (prod_pcm p') x' y')
+: Tot (frame_preserving_upd (prod_pcm p) ((substruct_to_struct p p' inj surj sq).morph x') ((substruct_to_struct p p' inj surj sq).morph y'))
+= fun v ->
+    substruct_lift_fpu_prf p p' inj surj sq x' y' f' v;
+    substruct_lift_fpu' p p' inj surj sq x' y' f' v
+
+let substruct
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+: Tot (connection (prod_pcm p) (prod_pcm p'))
+= mkconnection
+    (substruct_to_struct p p' inj surj sq)
+    (struct_to_substruct p p' inj surj sq)
+    (assert (forall x .
+      struct_to_substruct_f p p' inj surj sq (substruct_to_struct_f p p' inj surj sq x) `feq` x
+    ))
+    (substruct_lift_fpu p p' inj surj sq)
+
+#push-options "--query_stats --z3rlimit 64"
+
+#restart-solver
+let substruct_id
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (inj: (a -> a))
+  (surj: (a -> option a))
+  (sq: squash (
+    (forall x . inj x == x) /\
+    (forall x . surj x == Some x)
+  ))
+: Lemma
+  (substruct p p inj surj () == connection_id (prod_pcm p))
+= let l = substruct p p inj surj () in
+  let m = connection_id (prod_pcm p) in
+  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
+    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
+  in
+  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) = () in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
+#push-options "--query_stats --z3rlimit 256"
+
+#restart-solver
+let substruct_compose
+  (#a1: eqtype)
+  (#b1: a1 -> Type)
+  (p1:(k: a1 -> pcm (b1 k)))
+  (#a2: eqtype)
+  (#b2: (a2 -> Type))
+  (p2: (k: a2 -> pcm (b2 k)))
+  (inj21: (a2 -> a1))
+  (surj12: (a1 -> option a2))
+  (sq12: squash (is_substruct p1 p2 inj21 surj12))
+  (#a3: eqtype)
+  (#b3: (a3 -> Type))
+  (p3: (k: a3 -> pcm (b3 k)))
+  (inj32: (a3 -> a2))
+  (surj23: (a2 -> option a3))
+  (sq23: squash (is_substruct p2 p3 inj32 surj23))
+  (inj31: (a3 -> a1))
+  (surj13: (a1 -> option a3))
+  (sq13: squash (is_substruct p1 p3 inj31 surj13))
+: Lemma
+  (requires (
+    (forall x3 . inj31 x3 == inj21 (inj32 x3)) /\
+    (forall x1 . surj13 x1 == (match surj12 x1 with
+    | None -> None
+    | Some x2 -> surj23 x2
+  ))))
+  (ensures (
+    substruct p1 p3 inj31 surj13 sq13 ==
+      substruct p1 p2 inj21 surj12 sq12 `connection_compose`
+      substruct p2 p3 inj32 surj23 sq23
+  ))
+=
+  let c12 = substruct p1 p2 inj21 surj12 sq12 in
+  let c23 = substruct p2 p3 inj32 surj23 sq23 in
+  let l = substruct p1 p3 inj31 surj13 sq13 in
+  let m = connection_compose c12 c23 in
+  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
+    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
+  in
+  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) =
+    assert (forall x . l.conn_large_to_small.morph x `feq` m.conn_large_to_small.morph x)
+  in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
+#push-options "--query_stats --z3rlimit 64"
+
+#restart-solver
+let substruct_field
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (field': a')
+: Lemma
+  (substruct p p' inj surj sq `connection_compose` struct_field p' field' ==
+    struct_field p (inj field')
+  )
+=
+  let l = substruct p p' inj surj sq `connection_compose` struct_field p' field' in
+  let m = struct_field p (inj field') in
+  let _ : squash (l.conn_small_to_large.morph `feq` m.conn_small_to_large.morph) =
+    assert (forall x . l.conn_small_to_large.morph x `feq` m.conn_small_to_large.morph x)
+  in
+  let _ : squash (l.conn_large_to_small.morph `feq` m.conn_large_to_small.morph) = () in
+  connection_eq_gen
+    l
+    m
+    ()
+    (fun x y f v ->
+      assert ((l.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v `feq` (m.conn_lift_frame_preserving_upd ({ fpu_lift_dom_x = x; fpu_lift_dom_y = y; fpu_lift_dom_f = f; })).fpu_f v)
+    )
+
+#pop-options
+
+let substruct_erase_fields
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (surj: (a -> option a'))
+  (f: restricted_t a b)
+: Tot (restricted_t a b)
+= on_dom a (fun x -> if Some? (surj x) then one (p x) else f x)
+
+let substruct_erase_fields_op
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (f: restricted_t a b)
+: Lemma
+  (
+    let f_sub = substruct_to_struct_f p p' inj surj sq (struct_to_substruct_f p p' inj surj sq f) in
+    let f_rem = substruct_erase_fields p surj f in
+    composable (prod_pcm p) f_sub f_rem /\
+    op (prod_pcm p) f_sub f_rem `feq` f
+  )
+= Classical.forall_intro_2 (fun k -> is_unit (p k))
+
+let substruct_composable
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (f: restricted_t a b)
+  (g': restricted_t a' b')
+: Lemma
+  (requires (
+    forall x' . f (inj x') == one (p' x')
+  ))
+  (ensures (
+    let g = substruct_to_struct_f p p' inj surj sq g' in
+    composable (prod_pcm p) f g /\
+    (forall x . op (prod_pcm p) f g x == (match surj x with None -> f x | Some x' -> g' x' <: b x))
+  ))
+= Classical.forall_intro_2 (fun k -> is_unit (p k))
+
+let substruct_pts_to_intro
+  (#opened: _)
+  (#base: Type)
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (r: ref base (prod_pcm p))
+  (f: restricted_t a b)
+: STGhostT unit opened
+    (pts_to r f)
+    (fun _ ->
+      pts_to r (substruct_erase_fields p surj f) `star`
+      pts_to (r `ref_focus` substruct p p' inj surj sq) (struct_to_substruct_f p p' inj surj sq f)
+    )
+= substruct_erase_fields_op p p' inj surj sq f;
+  split r _ (substruct_erase_fields p surj f) (substruct_to_struct_f p p' inj surj sq (struct_to_substruct_f p p' inj surj sq f));
+  gfocus r (substruct p p' inj surj sq) (substruct_to_struct_f _ _ _ _ _ _) _
+
+let substruct_pts_to_elim
+  (#opened: _)
+  (#base: Type)
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (#a': eqtype)
+  (#b': (a' -> Type))
+  (p': (k: a' -> pcm (b' k)))
+  (inj: (a' -> a))
+  (surj: (a -> option a'))
+  (sq: squash (is_substruct p p' inj surj))
+  (r: ref base (prod_pcm p))
+  (f: restricted_t a b)
+  (g': restricted_t a' b')
+: STGhost (Ghost.erased (restricted_t a b)) opened
+    (pts_to r f `star` pts_to (r `ref_focus` substruct p p' inj surj sq) g')
+    (fun res -> pts_to r res)
+    (
+      forall x' . f (inj x') == one (p' x')
+    )
+    (fun res ->
+      let g = substruct_to_struct_f p p' inj surj sq g' in
+      composable (prod_pcm p) f g /\
+      Ghost.reveal res == op (prod_pcm p) f g /\
+      (forall x . Ghost.reveal res x == (match surj x with None -> f x | Some x' -> g' x' <: b x))
+    )
+= substruct_composable p p' inj surj sq f g';
+  let g = substruct_to_struct_f p p' inj surj sq g' in
+  let res = Ghost.hide (op (prod_pcm p) f g) in
+  unfocus (r `ref_focus` _) r (substruct p p' inj surj sq) _;
+  let _ = gather r f _ in
+  rewrite
+    (pts_to r _)
+    (pts_to r res);
+  res
+
+let exclusive_struct_intro
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+: Lemma
+  (requires (
+    forall k . exclusive (p k) (struct_to_field_f p k x)
+  ))
+  (ensures (
+    exclusive (prod_pcm p) x
+  ))
+  [SMTPat (exclusive (prod_pcm p) x)]
+=
+  assert (forall frame . prod_comp p x frame ==> frame `feq` prod_one p)
+
+let exclusive_struct_elim
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (x: restricted_t a b)
+  (k: a)
+: Lemma
+  (requires (exclusive (prod_pcm p) x))
+  (ensures (exclusive (p k) (struct_to_field_f p k x)))
+=
+  let phi
+    frame
+  : Lemma
+    (requires (composable (p k) (struct_to_field_f p k x) frame))
+    (ensures (composable (prod_pcm p) x (field_to_struct_f p k frame)))
+    [SMTPat (composable (p k) (struct_to_field_f p k x) frame)]
+  = let x' = struct_to_field_f p k x in
+    let f' = field_to_struct_f p k frame in
+    let psi
+      k'
+    : Lemma
+      (composable (p k') (x k') (f' k'))
+      [SMTPat (composable (p k') (x k') (f' k'))]
+    = if k' = k
+      then ()
+      else is_unit (p k') (x k')
+    in
+    ()
+  in
+  ()
+
+let struct_without_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then one (p k) else xs k')
+
+let struct_peel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (xs: restricted_t a b)
+: Lemma (
+    composable (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)) /\
+    xs == op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  assert (xs `feq` op (prod_pcm p) (struct_without_field p k xs) (field_to_struct_f p k (xs k)))
+
+let g_addr_of_struct_field
+  (#opened: _)
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: STGhostT unit opened
+    (r `pts_to` xs)
+    (fun _ ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (ref_focus r (struct_field p k) `pts_to` Ghost.reveal xs k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  rewrite (r `pts_to` _) (r `pts_to` _);
+  gfocus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k)
+
+let addr_of_struct_field
+  (#opened: _)
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: ref base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: STAtomicBase (ref base (p k)) false opened Unobservable
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires True)
+    (ensures fun r' -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  rewrite (r `pts_to` _) (r `pts_to` _);
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  rewrite (r `pts_to` _) (r `pts_to` _);
+  return r
+
+(*
+let ptr_addr_of_struct_field
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k)))
+  (r: Ptr.ptr base (prod_pcm p)) (k:a)
+  (xs: Ghost.erased (restricted_t a b))
+: Steel (ref base (p k))
+    (r `pts_to` xs)
+    (fun s ->
+      (r `pts_to` struct_without_field p k xs) `star` 
+      (s `pts_to` Ghost.reveal xs k))
+    (requires fun _ -> True)
+    (ensures fun _ r' _ -> r' == ref_focus r (struct_field p k))
+= struct_peel p k xs;
+  split r xs (struct_without_field p k xs) (field_to_struct_f p k (Ghost.reveal xs k));
+  let r = focus r (struct_field p k) (field_to_struct_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  return r
+*)
+
+let struct_with_field (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (x:b k) (xs: restricted_t a b)
+: restricted_t a b
+= on_dom a (fun k' -> if k' = k then x else xs k')
+
+let struct_unpeel (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (x: b k) (xs: restricted_t a b)
+: Lemma
+    (requires xs k == one (p k))
+    (ensures
+      composable (prod_pcm p) xs (field_to_struct_f p k x) /\
+      struct_with_field p k x xs == op (prod_pcm p) xs (field_to_struct_f p k x))
+= Classical.forall_intro_2 (fun k -> is_unit (p k));
+  assert (struct_with_field p k x xs `feq` op (prod_pcm p) xs (field_to_struct_f p k x))
+
+let unaddr_of_struct_field
+  (#opened: _)
+  (#base:Type) (#a:eqtype) (#b: a -> Type u#b) (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (prod_pcm p))
+  (xs: Ghost.erased (restricted_t a b)) (x: Ghost.erased (b k))
+: STGhost unit opened
+    ((r `pts_to` xs) `star` (r' `pts_to` x))
+    (fun s -> r `pts_to` struct_with_field p k x xs)
+    (requires r' == ref_focus r (struct_field p k) /\ Ghost.reveal xs k == one (p k))
+    (ensures fun _ -> True)
+= unfocus r' r (struct_field p k) x;
+  let _ = gather r xs (field_to_struct_f p k x) in
+  struct_unpeel p k x xs;
+  rewrite (r `pts_to` _) (r `pts_to` _)

From 6ba13bb8afe0ed09046103c49f0c53e8dc2027d1 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 09:57:10 -0800
Subject: [PATCH 419/513] union

---
 ulib/experimental/Steel.C.Model.Union.fst    | 476 +-----------------
 ulib/experimental/Steel.ST.C.Model.Union.fst | 484 +++++++++++++++++++
 2 files changed, 486 insertions(+), 474 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Union.fst

diff --git a/ulib/experimental/Steel.C.Model.Union.fst b/ulib/experimental/Steel.C.Model.Union.fst
index 22d83da2762..6d08780758a 100644
--- a/ulib/experimental/Steel.C.Model.Union.fst
+++ b/ulib/experimental/Steel.C.Model.Union.fst
@@ -1,5 +1,7 @@
 module Steel.C.Model.Union
+include Steel.ST.C.Model.Union
 
+module STC = Steel.ST.Coercions
 module P = FStar.PCM
 open Steel.C.Model.PCM
 open Steel.C.Model.Connection
@@ -8,482 +10,8 @@ open Steel.C.Model.Struct
 open Steel.Effect
 module A = Steel.Effect.Atomic
 
-(** A PCM for unions *)
-
 open FStar.FunctionalExtensionality
 
-let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
-  forall k'. ~ (k == k') ==> f k' == one (p k')
-
-let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
-: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
-
-let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
-    (ensures f == one (prod_pcm p))
-= ext f (one (prod_pcm p)) (fun k -> ())
-
-let is_union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) (f: restricted_t a b) =
-  (exists (k:a). True) ==> (exists k. case_refinement_f p k f)
-  (** precondition is there because we don't care if 'a is inhabited *)
-
-let union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) = f:restricted_t a b{is_union p f}
-
-let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
-  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
-    [SMTPat (case_refinement_f p k f)]))
-: Lemma (forall (j:'a). goal)
-= let _ = cont in ()
-
-let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
-  (k:'a{case_refinement_f p k f})
-: Lemma (is_union p f)
-= ()
-
-let union_comp0 (p:(k:'a -> pcm ('b k))) (f g: union p) : Tot prop =
-  forall j k.
-  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
-  j == k /\ composable (p k) (f k) (g k)
-
-let union_comp (p:(k:'a -> pcm ('b k))) : Tot (P.symrel (union p)) =
-  union_comp0 p
-
-let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (h:(j:'a -> k:'a ->
-    Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures j == k /\ composable (p k) (f k) (g k))
-      [SMTPat (f j); SMTPat (g k)]))
-: Lemma (union_comp p f g)
-= let _ = h in ()
-
-let union_comp_elim (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (j:'a) (k:'a)
-: Lemma
-  (requires (union_comp p f g /\ ~ (f j == one (p j)) /\ ~ (g k == one (p k))))
-  (ensures j == k /\ composable (p k) (f k) (g k))
-= ()
-
-let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
-: Lemma
-    (requires union_comp p f g)
-    (ensures prod_comp p f g)
-    [SMTPat (union_comp p f g)]
-= prod_pcm_composable_intro p f g (fun k -> is_unit (p k) (f k); is_unit (p k) (g k))
-
-let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p k f /\ f k == one (p k))
-    (ensures f == one (prod_pcm p))
-    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
-= ext f (one (prod_pcm p)) (fun _ -> ())
-
-let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
-: Lemma
-    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
-    (ensures
-      f == one (prod_pcm p) \/
-      g == one (prod_pcm p) \/ 
-      case_refinement_f p k (prod_op p f g))
-    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
-= let fj_or_gk_one
-  : squash
-      (f j == one (p j) \/ g k == one (p k) ==>
-       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
-  = ()
-  in let fj_gk_both_not_one ()
-  : Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures case_refinement_f p k (prod_op p f g))
-  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> is_unit (p k') (g k'))
-  in
-  FStar.Classical.move_requires fj_gk_both_not_one ();
-  assert
-   ((f j == one (p j) \/ g k == one (p k)) ==>
-    f == one (prod_pcm p) \/
-    g == one (prod_pcm p) \/ 
-    case_refinement_f p k (prod_op p f g))
-
-let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
-  let h = prod_op p f g in
-  let goal = is_union p h in
-  union_elim p f goal (fun j ->
-  union_elim p g goal (fun k ->
-  case_refinement_f_op p j k f g;
-  is_unit (prod_pcm p) g));
-  h
-
-let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
-
-let union_refine (p:(k:'a -> pcm ('b k))) (u: union p): Tot prop = exists k. p_refine (p k) (u k)
-
-let union_assoc (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
-: Lemma (union_comp p x y /\
-         union_comp p (union_op p x y) z /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc p x y z;
-  union_comp_intro p x y (fun j k -> is_unit (prod_pcm p) y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ());
-  assert (union_op p x (union_op p y z) `feq` union_op p (union_op p x y) z)
-
-let union_assoc_r (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
-: Lemma (union_comp p y z /\
-         union_comp p x (union_op p y z) /\
-         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
-= prod_assoc_r p x y z;
-  union_comp_intro p x y (fun j k -> is_unit (prod_pcm p) y);
-  union_comp_intro p (union_op p x y) z (fun j k -> ());
-  assert (union_op p x (union_op p y z) `feq` union_op p (union_op p x y) z)
-
-let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
-: Lemma (union_comp p x (union_one p) /\
-         union_op p x (union_one p) == x)
-= is_unit (prod_pcm p) x
-
-let fstar_union_pcm (p:(k:'a -> pcm ('b k))): P.pcm (union p) = let open P in {
-    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
-    comm = (fun x y -> prod_comm p x y);
-    assoc = union_assoc p;
-    assoc_r = union_assoc_r p;
-    is_unit = union_is_unit p;
-    refine = union_refine p;
-  }
-
-let union_pcm' (p:(k:'a -> pcm ('b k))): pcm0 (union p) = pcm_of_fstar_pcm (fstar_union_pcm p)
-
-let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
-  let p' = union_pcm' p in
-  let aux (x:union p) (y:union p{composable p' x y})
-  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
-    [SMTPat (op p' x y)]
-  = ext x (one p') (fun k -> let _ = p k in ());
-    ext y (one p') (fun k -> let _ = p k in ())
-  in
-  assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
-  union_pcm' p
-
-let union_pcm_composable_intro0
-  (p:(k:'a -> pcm ('b k)))
-  (x y: union p)
-: Lemma
-  ((composable (union_pcm p) x y <==> union_comp p x y) /\
-  (composable (union_pcm p) x y ==> op (union_pcm p) x y == union_op p x y))
-  [SMTPat (composable (union_pcm p) x y)]
-= ()
-
-let union_comp_intro0 (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (h:(j:'a -> k:'a ->
-    Lemma
-      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
-      (ensures j == k /\ composable (p k) (f k) (g k))
-      [SMTPat (f j); SMTPat (g k)]))
-: Lemma (composable (union_pcm p) f g)
-= let _ = h in ()
-
-let union_comp_elim0 (p:(k:'a -> pcm ('b k))) (f g: union p)
-  (j:'a) (k:'a)
-: Lemma
-  (requires (composable (union_pcm p) f g /\ ~ (f j == one (p j)) /\ ~ (g k == one (p k))))
-  (ensures j == k /\ composable (p k) (f k) (g k))
-= ()
-
-let field_to_union_f
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-: Pure (union p)
-  (requires True)
-  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
-= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
-
-let field_to_union
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (p k) (union_pcm p))
-= mkmorphism
-    (field_to_union_f p k)
-    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
-    (fun x1 x2 ->
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
-        ())
-
-let field_to_union_elim (#a: eqtype) (#b: a -> Type) (p: (k: a -> pcm (b k)))
-  (k: a)
-  (x: b k)
-  (k': a)
-: Lemma
-  (requires (~ ((field_to_union p k).morph x k' == one (p k'))))
-  (ensures (k == k'))
-= ()
-
-let union_to_field_f
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: union p)
-: Tot (b k)
-= x k
-
-let union_to_field
-  (#a: Type)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (morphism (union_pcm p) (p k))
-= mkmorphism
-    (union_to_field_f p k) ()
-    (fun x1 x2 -> ())
-
-let union_field_lift_fpu'
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_struct p k).morph x))
-: Tot (union p)
-= 
-    on_dom a (fun k' ->
-      if k' = k
-      then f (v k) <: b k'
-      else one (p k')
-    )
-
-#restart-solver
-
-#push-options "--z3rlimit 30 --query_stats --fuel 2 --ifuel 4"
-
-let union_field_lift_fpu0_prf1
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
-: Lemma
-  (frame_preserving_upd_goal1 (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v)
-=
-      let y' = (field_to_union p k).morph y in
-      let v_new = union_field_lift_fpu' p k x y f v in
-      assert (p_refine (union_pcm p) v_new);
-      Classical.forall_intro_2 (fun k -> is_unit (p k));
-      let frame : b k = compatible_elim (p k) y (f (v k)) in
-      let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
-      assert (composable (union_pcm p) y' frame');
-      assert (op (union_pcm p) frame' y' `feq` v_new);
-      compatible_intro (union_pcm p) y' v_new frame'
-
-#pop-options
-
-#restart-solver
-
-#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 64"
-
-let union_field_lift_fpu0_prf2
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
-  (frame: union p)
-: Lemma
-  (requires (
-    frame_preserving_upd_goal2_pre (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
-  ))
-  (ensures (
-    frame_preserving_upd_goal2_post (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
-  ))
-=
-  union_comp_intro0
-    p
-    ((field_to_union p k).morph y)
-    frame
-    (fun j' k' ->
-      field_to_union_elim p k y j';
-      union_comp_elim0 p ((field_to_union p k).morph x) frame k k';
-      let _ = f (v k) in
-      assert (composable (p k) x (frame k));
-      assert (composable (p k) y (frame k))
-  )
-
-#pop-options
-
-#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 128"
-
-#restart-solver
-
-let union_field_lift_fpu0_prf3
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
-  (frame: union p)
-: Lemma
-  (requires (
-    frame_preserving_upd_goal3_pre (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
-  ))
-  (ensures (
-    frame_preserving_upd_goal3_post (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
-  ))
-=
-  let w = op (union_pcm p) ((field_to_union p k).morph x) frame in
-  union_pcm_composable_intro0 p ((field_to_union p k).morph x) frame;
-  assert (w == union_op p ((field_to_union p k).morph x) frame);
-  assert (w == prod_op p ((field_to_union p k).morph x) frame);
-  assert (w k == op (p k) x (frame k));
-  assert (w k == v k);
-  let v'k = f (v k) in
-  let w' = op (union_pcm p) ((field_to_union p k).morph y) frame in
-  union_pcm_composable_intro0 p ((field_to_union p k).morph y) frame;
-  assert (w' == union_op p ((field_to_union p k).morph y) frame);
-  assert (w' == prod_op p ((field_to_union p k).morph y) frame);
-  assert (w' k == op (p k) y (frame k));
-  assert (w' k == v'k);
-  assert (union_op p ((field_to_union p k).morph y) frame `feq` 
-    union_field_lift_fpu' p k x y f v)
-
-#pop-options
-
-let union_field_lift_fpu
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
-  (y: Ghost.erased (b k))
-  (f: frame_preserving_upd (p k) x y)
-: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
-=
-  let y' = Ghost.hide ((field_to_union p k).morph y) in
-  frame_preserving_upd_intro
-    (union_pcm p)
-    ((field_to_union p k).morph x)
-    ((field_to_union p k).morph y)
-    (union_field_lift_fpu' p k x y f)
-    (union_field_lift_fpu0_prf1 p k x y f)
-    (union_field_lift_fpu0_prf2 p k x y f)
-    (union_field_lift_fpu0_prf3 p k x y f)
-
-let union_field
-  (#a: eqtype)
-  (#b: a -> Type)
-  (p:(k: a -> pcm (b k)))
-  (k: a)
-: Tot (connection (union_pcm p) (p k))
-= mkconnection
-    (field_to_union p k)
-    (union_to_field p k)
-    ()
-    (union_field_lift_fpu p k)
-
-module I = FStar.IndefiniteDescription
-let case_of_union (p:(k:'a -> pcm ('b k))) (u: union p)
-: GTot (k:option 'a{match k with Some k -> ~ (u k == one (p k)) | None -> u == one (union_pcm p)})
-= if I.strong_excluded_middle (exists k. ~ (u k == one (p k))) then
-    let k = I.indefinite_description_ghost 'a (fun k -> ~ (u k == one (p k))) in
-    Some k
-  else begin
-    assert (u `feq` one (union_pcm p));
-    None
-  end
-
-let exclusive_union_intro
-  (#a: Type)
-  (#b: _)
-  (p:(k: a -> pcm (b k)))
-  (x: union p)
-  (k: a)
-: Lemma
-  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
-  (ensures (exclusive (union_pcm p) x))
-= let phi
-    (frame: union p)
-  : Lemma
-    (requires (composable (union_pcm p) x frame))
-    (ensures (frame `feq` union_one p))
-    [SMTPat (composable (union_pcm p) x frame)]
-  = ()
-  in
-  ()
-
-let exclusive_union_elim
-  (#a: eqtype)
-  (#b: _)
-  (p: (k: a -> pcm (b k)))
-  (x: union p)
-  (k: a)
-: Lemma
-  (requires (exclusive (union_pcm p) x))
-  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
-= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
-  then ()
-  else
-    let phi
-      (frame: b k)
-    : Lemma
-      (requires (composable (p k) (x k) frame))
-      (ensures (frame == one (p k)))
-      [SMTPat (composable (p k) (x k) frame)]
-    = let frame' = field_to_union_f p k frame in
-      ()
-    in
-    ()
-    
-let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
-  (xs: union p{~ (xs k == one (p k))})
-: Lemma (xs == field_to_union_f p k (xs k))
-= assert (xs `feq` field_to_union_f p k (xs k))
-
-let addr_of_union_field
-  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
-  (r: ref base (union_pcm p)) (k:a)
-  (xs: Ghost.erased (union p))
-: Steel (ref base (p k))
-    (r `pts_to` xs)
-    (fun r' -> r' `pts_to` Ghost.reveal xs k)
-    (requires fun _ -> ~ (Ghost.reveal xs k == one (p k)))
-    (ensures fun _ r' _ -> r' == ref_focus r (union_field p k))
-= union_peel p k xs;
-  A.change_equal_slprop (r `pts_to` xs) (r `pts_to` _);
-  let s = focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
-  A.change_equal_slprop (s `pts_to` _) (s `pts_to` _);
-  A.return s
-
-module M = Steel.Memory 
-let unaddr_of_union_field
-  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
-  (r': ref base (p k)) (r: ref base (union_pcm p))
-  (x: Ghost.erased (b k))
-: A.SteelGhost unit opened
-    (r' `pts_to` x)
-    (fun s -> r `pts_to` field_to_union_f p k x)
-    (requires fun _ -> r' == ref_focus r (union_field p k))
-    (ensures fun _ _ _ -> True)
-= unfocus r' r (union_field p k) x
-
 let union_view_to_view_prop
   (#a:Type) (#b: a -> Type) (#p:(k:a -> pcm (b k)))
   (#view_t:a -> Type) (case_view:(k:a -> sel_view (p k) (view_t k) false))
diff --git a/ulib/experimental/Steel.ST.C.Model.Union.fst b/ulib/experimental/Steel.ST.C.Model.Union.fst
new file mode 100644
index 00000000000..321c7cbafd3
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Union.fst
@@ -0,0 +1,484 @@
+module Steel.ST.C.Model.Union
+open Steel.ST.Util
+
+module P = FStar.PCM
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+open Steel.ST.C.Model.Ref
+open Steel.ST.C.Model.Struct
+
+(** A PCM for unions *)
+
+open FStar.FunctionalExtensionality
+
+let case_refinement_f (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b): prop =
+  forall k'. ~ (k == k') ==> f k' == one (p k')
+
+let case_refinement_f_intro (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+  (h:(k':'a{~ (k == k')} -> Lemma (f k' == one (p k'))))
+: Lemma (case_refinement_f p k f) = FStar.Classical.forall_intro h
+
+let case_refinement_f_uniq (p:(k:'a -> pcm ('b k))) (j k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k f /\ ~ (j == k))
+    (ensures f == one (prod_pcm p))
+= ext f (one (prod_pcm p)) (fun k -> ())
+
+let is_union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) (f: restricted_t a b) =
+  (exists (k:a). True) ==> (exists k. case_refinement_f p k f)
+  (** precondition is there because we don't care if 'a is inhabited *)
+
+let union (#a:Type) (#b:a->Type) (p:(k:a -> pcm (b k))) = f:restricted_t a b{is_union p f}
+
+let union_elim (p:(k:'a -> pcm ('b k))) (f: union p) (goal:Type)
+  (cont:(k:'a -> Lemma (requires case_refinement_f p k f) (ensures goal)
+    [SMTPat (case_refinement_f p k f)]))
+: Lemma (forall (j:'a). goal)
+= let _ = cont in ()
+
+let is_union_intro (p:(k:'a -> pcm ('b k))) (f: restricted_t 'a 'b)
+  (k:'a{case_refinement_f p k f})
+: Lemma (is_union p f)
+= ()
+
+let union_comp0 (p:(k:'a -> pcm ('b k))) (f g: union p) : Tot prop =
+  forall j k.
+  ~ (f j == one (p j)) /\ ~ (g k == one (p k)) ==>
+  j == k /\ composable (p k) (f k) (g k)
+
+let union_comp (p:(k:'a -> pcm ('b k))) : Tot (P.symrel (union p)) =
+  union_comp0 p
+
+let union_comp_intro (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (union_comp p f g)
+= let _ = h in ()
+
+let union_comp_elim (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (j:'a) (k:'a)
+: Lemma
+  (requires (union_comp p f g /\ ~ (f j == one (p j)) /\ ~ (g k == one (p k))))
+  (ensures j == k /\ composable (p k) (f k) (g k))
+= ()
+
+let union_comp_prod_comp (p:(k:'a -> pcm ('b k))) (f g: union p)
+: Lemma
+    (requires union_comp p f g)
+    (ensures prod_comp p f g)
+    [SMTPat (union_comp p f g)]
+= prod_pcm_composable_intro p f g (fun k -> is_unit (p k) (f k); is_unit (p k) (g k))
+
+let case_refinement_f_one (p:(k:'a -> pcm ('b k))) (k:'a) (f: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p k f /\ f k == one (p k))
+    (ensures f == one (prod_pcm p))
+    [SMTPat (case_refinement_f p k f); SMTPat (f k == one (p k))]
+= ext f (one (prod_pcm p)) (fun _ -> ())
+
+let case_refinement_f_op (p:(k:'a -> pcm ('b k))) (j k:'a) (f g: restricted_t 'a 'b)
+: Lemma
+    (requires case_refinement_f p j f /\ case_refinement_f p k g /\ union_comp p f g)
+    (ensures
+      f == one (prod_pcm p) \/
+      g == one (prod_pcm p) \/ 
+      case_refinement_f p k (prod_op p f g))
+    [SMTPat (case_refinement_f p j f); SMTPat (case_refinement_f p k g)]
+= let fj_or_gk_one
+  : squash
+      (f j == one (p j) \/ g k == one (p k) ==>
+       feq f (one (prod_pcm p)) \/ feq g (one (prod_pcm p)))
+  = ()
+  in let fj_gk_both_not_one ()
+  : Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures case_refinement_f p k (prod_op p f g))
+  = case_refinement_f_intro p k (prod_op p f g) (fun k' -> is_unit (p k') (g k'))
+  in
+  FStar.Classical.move_requires fj_gk_both_not_one ();
+  assert
+   ((f j == one (p j) \/ g k == one (p k)) ==>
+    f == one (prod_pcm p) \/
+    g == one (prod_pcm p) \/ 
+    case_refinement_f p k (prod_op p f g))
+
+let union_op (p:(k:'a -> pcm ('b k))) (f: union p) (g: union p{union_comp p f g}): union p =
+  let h = prod_op p f g in
+  let goal = is_union p h in
+  union_elim p f goal (fun j ->
+  union_elim p g goal (fun k ->
+  case_refinement_f_op p j k f g;
+  is_unit (prod_pcm p) g));
+  h
+
+let union_one (p:(k:'a -> pcm ('b k))): union p = prod_one p
+
+let union_refine (p:(k:'a -> pcm ('b k))) (u: union p): Tot prop = exists k. p_refine (p k) (u k)
+
+let union_assoc (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p y z /\ union_comp p x (union_op p y z)})
+: Lemma (union_comp p x y /\
+         union_comp p (union_op p x y) z /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc p x y z;
+  union_comp_intro p x y (fun j k -> is_unit (prod_pcm p) y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ());
+  assert (union_op p x (union_op p y z) `feq` union_op p (union_op p x y) z)
+
+let union_assoc_r (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+  (z: union p{union_comp p x y /\ union_comp p (union_op p x y) z})
+: Lemma (union_comp p y z /\
+         union_comp p x (union_op p y z) /\
+         union_op p x (union_op p y z) == union_op p (union_op p x y) z)
+= prod_assoc_r p x y z;
+  union_comp_intro p x y (fun j k -> is_unit (prod_pcm p) y);
+  union_comp_intro p (union_op p x y) z (fun j k -> ());
+  assert (union_op p x (union_op p y z) `feq` union_op p (union_op p x y) z)
+
+let union_is_unit (p:(k:'a -> pcm ('b k))) (x: union p)
+: Lemma (union_comp p x (union_one p) /\
+         union_op p x (union_one p) == x)
+= is_unit (prod_pcm p) x
+
+let fstar_union_pcm (p:(k:'a -> pcm ('b k))): P.pcm (union p) = let open P in {
+    FStar.PCM.p = {composable = union_comp p; op = union_op p; one = union_one p};
+    comm = (fun x y -> prod_comm p x y);
+    assoc = union_assoc p;
+    assoc_r = union_assoc_r p;
+    is_unit = union_is_unit p;
+    refine = union_refine p;
+  }
+
+let union_pcm' (p:(k:'a -> pcm ('b k))): pcm0 (union p) = pcm_of_fstar_pcm (fstar_union_pcm p)
+
+let union_pcm (p:(k:'a -> pcm ('b k))): pcm (union p) =
+  let p' = union_pcm' p in
+  let aux (x:union p) (y:union p{composable p' x y})
+  : Lemma (requires op p' x y == one p') (ensures x == one p' /\ y == one p')
+    [SMTPat (op p' x y)]
+  = ext x (one p') (fun k -> let _ = p k in ());
+    ext y (one p') (fun k -> let _ = p k in ())
+  in
+  assert (forall x frame . (union_refine p x /\ union_comp p x frame) ==> frame `feq` union_one p);
+  union_pcm' p
+
+let union_pcm_composable_intro0
+  (p:(k:'a -> pcm ('b k)))
+  (x y: union p)
+: Lemma
+  ((composable (union_pcm p) x y <==> union_comp p x y) /\
+  (composable (union_pcm p) x y ==> op (union_pcm p) x y == union_op p x y))
+  [SMTPat (composable (union_pcm p) x y)]
+= ()
+
+let union_comp_intro0 (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (h:(j:'a -> k:'a ->
+    Lemma
+      (requires ~ (f j == one (p j)) /\ ~ (g k == one (p k)))
+      (ensures j == k /\ composable (p k) (f k) (g k))
+      [SMTPat (f j); SMTPat (g k)]))
+: Lemma (composable (union_pcm p) f g)
+= let _ = h in ()
+
+let union_comp_elim0 (p:(k:'a -> pcm ('b k))) (f g: union p)
+  (j:'a) (k:'a)
+: Lemma
+  (requires (composable (union_pcm p) f g /\ ~ (f j == one (p j)) /\ ~ (g k == one (p k))))
+  (ensures j == k /\ composable (p k) (f k) (g k))
+= ()
+
+let field_to_union_f
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+: Pure (union p)
+  (requires True)
+  (ensures (fun y -> forall k' . y k' == (if k' = k then (x <: b k') else one (p k'))))
+= on_dom a (fun k' -> if k' = k then (x <: b k') else one (p k'))
+
+let field_to_union
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (p k) (union_pcm p))
+= mkmorphism
+    (field_to_union_f p k)
+    (assert (field_to_union_f p k (one (p k)) `feq` one (union_pcm p)))
+    (fun x1 x2 ->
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      assert (union_op p (field_to_union_f p k x1) (field_to_union_f p k x2) `feq` field_to_union_f p k (op (p k) x1 x2));
+        ())
+
+let field_to_union_elim (#a: eqtype) (#b: a -> Type) (p: (k: a -> pcm (b k)))
+  (k: a)
+  (x: b k)
+  (k': a)
+: Lemma
+  (requires (~ ((field_to_union p k).morph x k' == one (p k'))))
+  (ensures (k == k'))
+= ()
+
+let union_to_field_f
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: union p)
+: Tot (b k)
+= x k
+
+let union_to_field
+  (#a: Type)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (morphism (union_pcm p) (p k))
+= mkmorphism
+    (union_to_field_f p k) ()
+    (fun x1 x2 -> ())
+
+let union_field_lift_fpu'
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_struct p k).morph x))
+: Tot (union p)
+= 
+    on_dom a (fun k' ->
+      if k' = k
+      then f (v k) <: b k'
+      else one (p k')
+    )
+
+#restart-solver
+
+#push-options "--z3rlimit 30 --query_stats --fuel 2 --ifuel 4"
+
+let union_field_lift_fpu0_prf1
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
+: Lemma
+  (frame_preserving_upd_goal1 (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v)
+=
+      let y' = (field_to_union p k).morph y in
+      let v_new = union_field_lift_fpu' p k x y f v in
+      assert (p_refine (union_pcm p) v_new);
+      Classical.forall_intro_2 (fun k -> is_unit (p k));
+      let frame : b k = compatible_elim (p k) y (f (v k)) in
+      let frame' : union p = on_dom a (fun k' -> if k' = k then (frame <: b k') else one (p k')) in
+      assert (composable (union_pcm p) y' frame');
+      assert (op (union_pcm p) frame' y' `feq` v_new);
+      compatible_intro (union_pcm p) y' v_new frame'
+
+#pop-options
+
+#restart-solver
+
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 64"
+
+let union_field_lift_fpu0_prf2
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
+  (frame: union p)
+: Lemma
+  (requires (
+    frame_preserving_upd_goal2_pre (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+  (ensures (
+    frame_preserving_upd_goal2_post (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+=
+  union_comp_intro0
+    p
+    ((field_to_union p k).morph y)
+    frame
+    (fun j' k' ->
+      field_to_union_elim p k y j';
+      union_comp_elim0 p ((field_to_union p k).morph x) frame k k';
+      let _ = f (v k) in
+      assert (composable (p k) x (frame k));
+      assert (composable (p k) y (frame k))
+  )
+
+#pop-options
+
+#push-options "--query_stats --fuel 2 --ifuel 4 --z3rlimit 128"
+
+#restart-solver
+
+let union_field_lift_fpu0_prf3
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+  (v: frame_preserving_upd_dom (union_pcm p) ((field_to_union p k).morph x))
+  (frame: union p)
+: Lemma
+  (requires (
+    frame_preserving_upd_goal3_pre (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+  (ensures (
+    frame_preserving_upd_goal3_post (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y) (union_field_lift_fpu' p k x y f) v frame
+  ))
+=
+  let w = op (union_pcm p) ((field_to_union p k).morph x) frame in
+  union_pcm_composable_intro0 p ((field_to_union p k).morph x) frame;
+  assert (w == union_op p ((field_to_union p k).morph x) frame);
+  assert (w == prod_op p ((field_to_union p k).morph x) frame);
+  assert (w k == op (p k) x (frame k));
+  assert (w k == v k);
+  let v'k = f (v k) in
+  let w' = op (union_pcm p) ((field_to_union p k).morph y) frame in
+  union_pcm_composable_intro0 p ((field_to_union p k).morph y) frame;
+  assert (w' == union_op p ((field_to_union p k).morph y) frame);
+  assert (w' == prod_op p ((field_to_union p k).morph y) frame);
+  assert (w' k == op (p k) y (frame k));
+  assert (w' k == v'k);
+  assert (union_op p ((field_to_union p k).morph y) frame `feq` 
+    union_field_lift_fpu' p k x y f v)
+
+#pop-options
+
+let union_field_lift_fpu
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+  (x: Ghost.erased (b k) { ~ (Ghost.reveal x == one (p k)) })
+  (y: Ghost.erased (b k))
+  (f: frame_preserving_upd (p k) x y)
+: Tot (frame_preserving_upd (union_pcm p) ((field_to_union p k).morph x) ((field_to_union p k).morph y))
+=
+  let y' = Ghost.hide ((field_to_union p k).morph y) in
+  frame_preserving_upd_intro
+    (union_pcm p)
+    ((field_to_union p k).morph x)
+    ((field_to_union p k).morph y)
+    (union_field_lift_fpu' p k x y f)
+    (union_field_lift_fpu0_prf1 p k x y f)
+    (union_field_lift_fpu0_prf2 p k x y f)
+    (union_field_lift_fpu0_prf3 p k x y f)
+
+let union_field
+  (#a: eqtype)
+  (#b: a -> Type)
+  (p:(k: a -> pcm (b k)))
+  (k: a)
+: Tot (connection (union_pcm p) (p k))
+= mkconnection
+    (field_to_union p k)
+    (union_to_field p k)
+    ()
+    (union_field_lift_fpu p k)
+
+module I = FStar.IndefiniteDescription
+let case_of_union (p:(k:'a -> pcm ('b k))) (u: union p)
+: GTot (k:option 'a{match k with Some k -> ~ (u k == one (p k)) | None -> u == one (union_pcm p)})
+= if I.strong_excluded_middle (exists k. ~ (u k == one (p k))) then
+    let k = I.indefinite_description_ghost 'a (fun k -> ~ (u k == one (p k))) in
+    Some k
+  else begin
+    assert (u `feq` one (union_pcm p));
+    None
+  end
+
+let exclusive_union_intro
+  (#a: Type)
+  (#b: _)
+  (p:(k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (p k) (x k) /\ (~ (x k == one (p k)))))
+  (ensures (exclusive (union_pcm p) x))
+= let phi
+    (frame: union p)
+  : Lemma
+    (requires (composable (union_pcm p) x frame))
+    (ensures (frame `feq` union_one p))
+    [SMTPat (composable (union_pcm p) x frame)]
+  = ()
+  in
+  ()
+
+let exclusive_union_elim
+  (#a: eqtype)
+  (#b: _)
+  (p: (k: a -> pcm (b k)))
+  (x: union p)
+  (k: a)
+: Lemma
+  (requires (exclusive (union_pcm p) x))
+  (ensures (x k == one (p k) \/ exclusive (p k) (x k)))
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (x k == one (p k))
+  then ()
+  else
+    let phi
+      (frame: b k)
+    : Lemma
+      (requires (composable (p k) (x k) frame))
+      (ensures (frame == one (p k)))
+      [SMTPat (composable (p k) (x k) frame)]
+    = let frame' = field_to_union_f p k frame in
+      ()
+    in
+    ()
+    
+let union_peel (#a:eqtype) #b (p:(k:a -> pcm (b k))) (k:a)
+  (xs: union p{~ (xs k == one (p k))})
+: Lemma (xs == field_to_union_f p k (xs k))
+= assert (xs `feq` field_to_union_f p k (xs k))
+
+let addr_of_union_field
+  #base (#a:eqtype) #b (#p:(k:a -> pcm (b k)))
+  (r: ref base (union_pcm p)) (k:a)
+  (xs: Ghost.erased (union p))
+: ST (ref base (p k))
+    (r `pts_to` xs)
+    (fun r' -> r' `pts_to` Ghost.reveal xs k)
+    (requires ~ (Ghost.reveal xs k == one (p k)))
+    (ensures fun r' -> r' == ref_focus r (union_field p k))
+= union_peel p k xs;
+  rewrite (r `pts_to` xs) (r `pts_to` _);
+  let s = focus r (union_field p k) (field_to_union_f p k (Ghost.reveal xs k)) (Ghost.reveal xs k) in
+  rewrite (s `pts_to` _) (s `pts_to` _);
+  return s
+
+module M = Steel.Memory 
+let unaddr_of_union_field
+  (#opened:M.inames) #base (#a:eqtype) #b (#p:(k:a -> pcm (b k))) (k:a)
+  (r': ref base (p k)) (r: ref base (union_pcm p))
+  (x: Ghost.erased (b k))
+: STGhost unit opened
+    (r' `pts_to` x)
+    (fun s -> r `pts_to` field_to_union_f p k x)
+    (requires r' == ref_focus r (union_field p k))
+    (ensures fun _ -> True)
+= unfocus r' r (union_field p k) x

From dde259f47f0c6c4bc496d1785ba3cfae077f5f02 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 10:19:33 -0800
Subject: [PATCH 420/513] array

---
 ...l.Array.fst => Steel.ST.C.Model.Array.fst} | 152 +++++++++---------
 1 file changed, 74 insertions(+), 78 deletions(-)
 rename ulib/experimental/{Steel.C.Model.Array.fst => Steel.ST.C.Model.Array.fst} (90%)

diff --git a/ulib/experimental/Steel.C.Model.Array.fst b/ulib/experimental/Steel.ST.C.Model.Array.fst
similarity index 90%
rename from ulib/experimental/Steel.C.Model.Array.fst
rename to ulib/experimental/Steel.ST.C.Model.Array.fst
index 7dd9b84d224..231df93e647 100644
--- a/ulib/experimental/Steel.C.Model.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Model.Array.fst
@@ -1,12 +1,11 @@
-module Steel.C.Model.Array
+module Steel.ST.C.Model.Array
+open Steel.ST.Util
 
 open Steel.C.Model.PCM
 open Steel.C.Model.Connection
-open Steel.C.Model.Ref
-open Steel.C.Model.Struct
-open Steel.Effect
-module R = Steel.C.Model.Ref
-module A = Steel.Effect.Atomic
+open Steel.ST.C.Model.Ref
+open Steel.ST.C.Model.Struct
+module R = Steel.ST.C.Model.Ref
 module SZ = FStar.SizeT
 
 (* Base array type *)
@@ -247,10 +246,10 @@ let intro_pts_to'
   (#p: pcm t)
   (r: array base_t p)
   (x: Seq.lseq t (size_v r.len))
-: A.SteelGhostT unit opened
+: STGhostT unit opened
    (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
    (fun _ -> pts_to r x)
-= A.rewrite_slprop
+= weaken
     (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
     (pts_to r x)
     (fun _ -> ())
@@ -262,11 +261,11 @@ let intro_pts_to
   (#p: pcm t)
   (r: array base_t p)
   (s: array_pcm_carrier t r.len)
-: A.SteelGhostT unit opened
+: STGhostT unit opened
    (R.pts_to (ref_of_array r) s)
    (fun _ -> pts_to r (seq_of_array_pcm_carrier s))
 = array_pcm_carrier_of_seq_of_array_pcm_carrier s;
-  A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _);
+  rewrite (R.pts_to _ _) (R.pts_to _ _);
   intro_pts_to' r (seq_of_array_pcm_carrier s)
 
 let intro_pts_to0
@@ -277,13 +276,13 @@ let intro_pts_to0
   (r: array base_t p)
   (s: array_pcm_carrier t r.len)
   (s': Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
    (R.pts_to (ref_of_array r) s)
    (fun _ -> pts_to r s')
-   (fun _ -> seq_of_array_pcm_carrier s `Seq.equal` s')
-   (fun _ _ _ -> True)
+   (seq_of_array_pcm_carrier s `Seq.equal` s')
+   (fun _ -> True)
 = intro_pts_to r s;
-  A.change_equal_slprop (pts_to r (seq_of_array_pcm_carrier s)) (pts_to r s')
+  rewrite (pts_to r (seq_of_array_pcm_carrier s)) (pts_to r s')
 
 let intro_pts_to1
   (#opened: _)
@@ -294,15 +293,15 @@ let intro_pts_to1
   (r0: R.ref base_t (array_pcm p r.len))
   (s: array_pcm_carrier t r.len)
   (s': Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
    (R.pts_to r0 s)
    (fun _ -> pts_to r s')
-   (fun _ ->
+   (
      r0 == ref_of_array r /\
      seq_of_array_pcm_carrier s `Seq.equal` s'
    )
-   (fun _ _ _ -> True)
-= A.change_equal_slprop (R.pts_to r0 s) (R.pts_to (ref_of_array r) s);
+   (fun _ -> True)
+= rewrite (R.pts_to r0 s) (R.pts_to (ref_of_array r) s);
   intro_pts_to0 r s s'
 
 let intro_pts_to2
@@ -317,18 +316,18 @@ let intro_pts_to2
   (r0: R.ref base_t0 p0)
   (s: t0)
   (s': Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
    (R.pts_to r0 s)
    (fun _ -> pts_to r s')
-   (fun _ ->
+   (
      base_t0 == base_t /\
      t0 == array_pcm_carrier t r.len /\
      p0 == array_pcm p r.len /\
      r0 == ref_of_array r /\
      seq_of_array_pcm_carrier (s <: array_pcm_carrier t r.len) `Seq.equal` s'
    )
-   (fun _ _ _ -> True)
-= A.change_equal_slprop
+   (fun _ -> True)
+= rewrite
     (R.pts_to r0 s)
     (R.pts_to (r0 <: R.ref base_t (array_pcm p r.len)) s);
   intro_pts_to1 r r0 s s'
@@ -340,35 +339,32 @@ let elim_pts_to
   (#p: pcm t)
   (r: array base_t p)
   (x: Seq.seq t)
-: A.SteelGhostT (squash (Seq.length x == size_v r.len)) opened
+: STGhostT (squash (Seq.length x == size_v r.len)) opened
    (pts_to r x)
    (fun _ -> R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len (x <: Seq.lseq t (size_v r.len))))
 = if Seq.length x = size_v r.len
   then begin
     let sq : squash (Seq.length x == size_v r.len) = () in
-    A.rewrite_slprop
+    weaken
       (pts_to r x)
       (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len (x <: Seq.lseq t (size_v r.len))))
       (fun _ -> ());
     let sq : squash (Seq.length x == size_v r.len) = () in
-    A.noop ();
+    noop ();
     sq
   end else begin
-    A.change_slprop_rel
+    weaken
       (pts_to r x)
       (pure False)
-      (fun _ _ -> False)
-      (fun m -> 
-        assert (Steel.Memory.interp (hp_of (pure False)) m);
-        Steel.Memory.pure_interp False m 
-      );
+      (fun _ -> ());
+    elim_pure False;
     assert False;
-    A.rewrite_slprop
+    weaken
       (pure False)
       (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x))
       (fun _ -> ());
     let sq : squash (Seq.length x == size_v r.len) = () in
-    A.noop ();
+    noop ();
     sq
   end
 
@@ -379,7 +375,7 @@ let pts_to_length
   (#p: pcm t)
   (r: array base_t p)
   (x: Seq.seq t)
-: A.SteelGhostT (squash (Seq.length x == size_v r.len)) opened
+: STGhostT (squash (Seq.length x == size_v r.len)) opened
     (pts_to r x)
     (fun _ -> pts_to r x)
 =
@@ -420,13 +416,13 @@ let g_focus_cell
   (s: Seq.seq t)
   (i: size_t)
   (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
-: A.SteelGhostT (squash (size_v i < size_v r.len /\ size_v r.len == Seq.length s)) opened
+: STGhostT (squash (size_v i < size_v r.len /\ size_v r.len == Seq.length s)) opened
     (pts_to r s)
     (fun _ -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to (ref_focus (ref_of_array r) (cell p r.len i)) (Seq.index s (size_v i)))
 = let _ = elim_pts_to r _ in
   g_addr_of_struct_field (ref_of_array r) i _;
   intro_pts_to0 r _ (Seq.upd s (size_v i) (one p));
-  A.change_equal_slprop (R.pts_to (ref_focus _ _) _) (R.pts_to (ref_focus _ _) _)
+  rewrite (R.pts_to (ref_focus _ _) _) (R.pts_to (ref_focus _ _) _)
 
 #push-options "--z3rlimit 16"
 
@@ -437,11 +433,11 @@ let pts_to_elim_to_base
   (#p: pcm t)
   (r: array base_t p)
   (x: Seq.seq t)
-: A.SteelGhost (Ghost.erased (array_pcm_carrier t r.base_len)) opened
+: STGhost (Ghost.erased (array_pcm_carrier t r.base_len)) opened
     (pts_to r x)
     (fun y -> R.pts_to r.base y)
-    (fun _ -> True)
-    (fun _ y _ ->
+    (True)
+    (fun y ->
       Seq.length x == size_v r.len /\
       Ghost.reveal y == (ref_of_array_conn r).conn_small_to_large.morph (array_pcm_carrier_of_seq r.len x) /\
       Ghost.reveal y == substruct_to_struct_f (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () (array_pcm_carrier_of_seq r.len x)
@@ -449,7 +445,7 @@ let pts_to_elim_to_base
 = let _ = elim_pts_to r _ in
   unfocus (ref_of_array r) r.base (ref_of_array_conn r) _;
   let y = Ghost.hide ((ref_of_array_conn r).conn_small_to_large.morph (array_pcm_carrier_of_seq r.len x)) in
-  A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _);
+  rewrite (R.pts_to _ _) (R.pts_to _ _);
   y
 
 #pop-options
@@ -462,16 +458,16 @@ let pts_to_intro_from_base
   (r: array base_t p)
   (y: array_pcm_carrier t r.base_len)
   (x: Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
     (R.pts_to r.base y)
     (fun _ -> pts_to r x)
-    (fun _ ->
+    (
       Seq.length x == size_v r.len /\
       y `feq` substruct_to_struct_f (array_elements_pcm p r.base_len) (array_elements_pcm p r.len) (small_to_large_index r.base_len r.offset r.len ()) (large_to_small_index r.base_len r.offset r.len ()) () (array_pcm_carrier_of_seq r.len x)
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = gfocus r.base (ref_of_array_conn r) _ (array_pcm_carrier_of_seq r.len x);
-  A.change_equal_slprop (R.pts_to _ _) (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x));
+  rewrite (R.pts_to _ _) (R.pts_to (ref_of_array r) (array_pcm_carrier_of_seq r.len x));
   intro_pts_to0 r _ x
 
 #push-options "--z3rlimit 16 --split_queries"
@@ -486,19 +482,19 @@ let focus_cell
   (s: Ghost.erased (Seq.seq t))
   (i: size_t)
   (sq: squash (size_v i < size_v r.len \/ size_v i < Seq.length s))
-: A.SteelAtomicBase (_: ref base_t p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) }) false opened Unobservable
+: STAtomicBase (_: ref base_t p { (size_v i < size_v r.len /\ size_v r.len == Seq.length s) }) false opened Unobservable
     (pts_to r s)
     (fun r' -> pts_to r (Seq.upd s (size_v i) (one p)) `star` R.pts_to r' (Seq.index s (size_v i)))
-    (fun _ -> True)
-    (fun _ r' _ ->
+    (True)
+    (fun r' ->
       r' == ref_focus (ref_of_array r) (cell p r.len i)
     )
 = let y = pts_to_elim_to_base r _ in
   ref_of_array_eq r i;
   let r' = addr_of_struct_field r.base (r.offset `size_add` i) _ in
   pts_to_intro_from_base r _ _;
-  A.change_equal_slprop (R.pts_to r' _) (R.pts_to r' _);
-  A.return r'
+  rewrite (R.pts_to r' _) (R.pts_to r' _);
+  return r'
 
 #pop-options
 
@@ -513,14 +509,14 @@ let unfocus_cell
   (r': R.ref base_t p)
   (v: t)
   (sq: squash (size_v i < size_v r.len /\ size_v i < Seq.length s))
-: A.SteelGhost unit opened
+: STGhost unit opened
     (pts_to r s `star` R.pts_to r' v)
     (fun _ -> pts_to r (Seq.upd s (size_v i) v))
-    (fun _ -> 
+    (
       r' == ref_focus (ref_of_array r) (cell p r.len i) /\
       Seq.index s (size_v i) == one p
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = let _ = elim_pts_to r _ in
   unaddr_of_struct_field #_ #_ #_ #_ #(array_elements_pcm p r.len) i r' (ref_of_array r) _ _;
   intro_pts_to0 r _ (Seq.upd s (size_v i) v)
@@ -532,10 +528,10 @@ let share
   (#p: pcm t)
   (r: array base_t p)
   (s s1 s2: Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
     (pts_to r s)
     (fun _ -> pts_to r s1 `star` pts_to r s2)
-    (fun _ ->
+    (
       Seq.length s1 == Seq.length s /\
       Seq.length s2 == Seq.length s /\
       (forall (i: nat) .
@@ -544,7 +540,7 @@ let share
         op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
       ))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = let _ = elim_pts_to r _ in
   let a1 = array_pcm_carrier_of_seq r.len s1 in
   let a2 = array_pcm_carrier_of_seq r.len s2 in
@@ -563,10 +559,10 @@ let gather
   (#p: pcm t)
   (r: array base_t p)
   (s s1 s2: Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
     (pts_to r s1 `star` pts_to r s2)
     (fun _ -> pts_to r s)
-    (fun _ ->
+    (
       Seq.length s1 == Seq.length s /\
       Seq.length s2 == Seq.length s /\
       (forall (i: nat) .
@@ -574,7 +570,7 @@ let gather
         op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
       ))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = let _ = elim_pts_to r s1 in
   let _ = elim_pts_to r s2 in
   let a1 = array_pcm_carrier_of_seq r.len s1 in
@@ -640,15 +636,15 @@ let g_focus_sub
   (sl: Seq.lseq t (size_v a.len))
   (al: array base_t p)
   (sl0: Seq.lseq t (size_v len))
-: A.SteelGhost unit opened
+: STGhost unit opened
     (pts_to a sl)
     (fun _ -> pts_to al sl0)
-    (fun _ ->
+    (
       al == sub a offset len /\
       sl0 `Seq.equal` Seq.slice s (size_v offset) (size_v offset + size_v len) /\
       sl `Seq.equal` (Seq.create (size_v offset) (one p) `Seq.append` sl0 `Seq.append` Seq.create (size_v a.len - size_v len - size_v offset) (one p))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 =
   substruct_compose
     (array_elements_pcm p a.base_len)
@@ -705,7 +701,7 @@ let g_split
   (s: Seq.seq t)
   (i: size_t)
   (sq: squash (size_v i <= size_v a.len))
-: A.SteelGhostT (squash (Seq.length s == size_v a.len)) opened
+: STGhostT (squash (Seq.length s == size_v a.len)) opened
     (pts_to a s)
     (fun _ -> pts_to (split_l a i) (Seq.slice s 0 (size_v i)) `star` pts_to (split_r a i) (Seq.slice s (size_v i) (size_v a.len)))
 = let _ = pts_to_length a _ in
@@ -736,15 +732,15 @@ let unfocus_sub
   (sl: Seq.lseq t (size_v a.len))
   (al: array base_t p)
   (sl0: Seq.lseq t (size_v len))
-: A.SteelGhost unit opened
+: STGhost unit opened
     (pts_to al sl0)
     (fun _ -> pts_to a sl)
-    (fun _ ->
+    (
       al == sub a offset len /\
       sl0 `Seq.equal` Seq.slice s (size_v offset) (size_v offset + size_v len) /\
       sl `Seq.equal` (Seq.create (size_v offset) (one p) `Seq.append` sl0 `Seq.append` Seq.create (size_v a.len - size_v len - size_v offset) (one p))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 =
   substruct_compose
     (array_elements_pcm p a.base_len)
@@ -809,15 +805,15 @@ let join
   (i: size_t)
   (al ar: array base_t p)
   (sl0 sr0: Seq.seq t)
-: A.SteelGhost unit opened
+: STGhost unit opened
     (pts_to al sl0 `star` pts_to ar sr0)
     (fun _ -> pts_to a (sl0 `Seq.append` sr0))
-    (fun _ ->
+    (
       size_v i <= size_v a.len /\
       al == split_l a i /\
       ar == split_r a i
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 =
   let _ = pts_to_length al _ in
   let _ = pts_to_length ar _ in
@@ -829,7 +825,7 @@ let join
   unfocus_sub a s 0sz i () sl al sl0;
   unfocus_sub a s i (a.len `size_sub` i) () sr ar sr0;
   gather a s sl sr;
-  A.change_equal_slprop (pts_to a _) (pts_to a _)
+  rewrite (pts_to a _) (pts_to a _)
 
 #pop-options
 
@@ -945,7 +941,7 @@ let ghost_array_of_ref
   (#p: pcm t)
   (#v: t)
   (r: ref base_t p)
-: A.SteelGhostT unit opened
+: STGhostT unit opened
     (R.pts_to r v)
     (fun _ -> pts_to (g_array_of_ref r) (Seq.create 1 v))
 = assert_norm (size_v 0sz == 0);
@@ -964,11 +960,11 @@ let array_of_ref
   (#p: pcm t)
   (#v: Ghost.erased t)
   (r: ref base_t p)
-: A.SteelAtomicBase (array base_t p) false opened Unobservable
+: STAtomicBase (array base_t p) false opened Unobservable
     (R.pts_to r v)
     (fun a -> pts_to a (Seq.create 1 (Ghost.reveal v)))
-    (fun _ -> True)
-    (fun _ a _ -> a == g_array_of_ref r)
+    (True)
+    (fun a -> a == g_array_of_ref r)
 = assert_norm (size_v 0sz == 0);
   assert_norm (size_v 1sz == 1);
   let v' : Ghost.erased (array_pcm_carrier t 1sz) = Ghost.hide (field_to_struct_f (array_elements_pcm p 1sz) 0sz v) in
@@ -984,7 +980,7 @@ let array_of_ref
   in
   ref_of_array_of_ref_base r;
   intro_pts_to1 a _ _ _;
-  A.return a
+  return a
 
 #push-options "--split_queries --z3rlimit 32 --query_stats"
 
@@ -997,11 +993,11 @@ let unarray_of_ref
   (#v: Seq.seq t)
   (r: ref base_t p)
   (a: array base_t p)
-: A.SteelGhost (squash (Seq.length v == 1)) opened
+: STGhost (squash (Seq.length v == 1)) opened
     (pts_to a v)
     (fun _ -> R.pts_to r (Seq.index v 0))
-    (fun _ -> a == g_array_of_ref r)
-    (fun _ _ _ -> True)
+    (a == g_array_of_ref r)
+    (fun _ -> True)
 = assert_norm (size_v 0sz == 0);
   assert_norm (size_v 1sz == 1);
   let _ = elim_pts_to _ _ in
@@ -1011,6 +1007,6 @@ let unarray_of_ref
   assert_norm ((array_of_ref_conn p).conn_small_to_large.morph x == x 0sz);
   array_pcm_carrier_of_seq_eq a.len v 0sz;
   assert (x 0sz == Seq.index v 0);
-  A.change_equal_slprop (R.pts_to _ _) (R.pts_to _ _)
+  rewrite (R.pts_to _ _) (R.pts_to _ _)
 
 #pop-options

From c7916880f3a97a84e9b2329c29a8deab44fc0626 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 15:00:54 -0800
Subject: [PATCH 421/513] Types

---
 ...Steel.C.Types.fst => Steel.ST.C.Types.fst} | 1160 ++++++++---------
 ...eel.C.Types.fsti => Steel.ST.C.Types.fsti} |  405 +++---
 2 files changed, 694 insertions(+), 871 deletions(-)
 rename ulib/experimental/{Steel.C.Types.fst => Steel.ST.C.Types.fst} (64%)
 rename ulib/experimental/{Steel.C.Types.fsti => Steel.ST.C.Types.fsti} (86%)

diff --git a/ulib/experimental/Steel.C.Types.fst b/ulib/experimental/Steel.ST.C.Types.fst
similarity index 64%
rename from ulib/experimental/Steel.C.Types.fst
rename to ulib/experimental/Steel.ST.C.Types.fst
index bfebda82060..a2370297ba6 100644
--- a/ulib/experimental/Steel.C.Types.fst
+++ b/ulib/experimental/Steel.ST.C.Types.fst
@@ -1,5 +1,6 @@
-module Steel.C.Types
+module Steel.ST.C.Types
 open Steel.C.Model.PCM
+open Steel.ST.GenElim
 
 #set-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
 
@@ -91,9 +92,7 @@ let unknown td = one td.pcm
 let mk_fraction_unknown td p = td.mk_fraction_one p
 let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
 
-module R = Steel.C.Model.Ref
-module RST = Steel.ST.C.Model.Ref
-module ST = Steel.ST.GenElim
+module R = Steel.ST.C.Model.Ref
 
 noeq
 type ref0_v (#t: Type) (td: typedef t) : Type u#1 = {
@@ -133,12 +132,12 @@ let pts_to0
   (r: ptr td)
   (v: t)
 : Tot vprop
-= ST.exists_ (fun p -> ST.exists_ (fun w ->
+= exists_ (fun p -> exists_ (fun w ->
     HR.pts_to r p w `star`
     r_pts_to w.ref v
   ))
 
-let _pts_to r v = hp_of (pts_to0 r v)
+let pts_to r v = pts_to0 r v
 
 let pts_to_intro
   (#opened: _)
@@ -148,13 +147,13 @@ let pts_to_intro
   (p: P.perm)
   (w1 w2: ref0_v td)
   (v: t)
-: ST.STGhost unit opened
+: STGhost unit opened
     (HR.pts_to r p w1 `star` R.pts_to w2.ref v)
     (fun _ -> pts_to r v)
     (w1 == w2)
     (fun _ -> True)
-= ST.vpattern_rewrite (HR.pts_to r p) w2;
-  ST.weaken (pts_to0 r v) (pts_to r v) (fun _ -> ())
+= vpattern_rewrite (HR.pts_to r p) w2;
+  rewrite (pts_to0 r v) (pts_to r v)
 
 let is_null
   p
@@ -167,7 +166,7 @@ let ref_equiv0
   (#td: typedef t)
   (r1 r2: ref td)
 : Tot vprop
-= ST.exists_ (fun p1 -> ST.exists_ (fun p2 -> ST.exists_ (fun w ->
+= exists_ (fun p1 -> exists_ (fun p2 -> exists_ (fun w ->
     HR.pts_to r1 p1 w `star`
     HR.pts_to r2 p2 w
   )))
@@ -184,37 +183,37 @@ let ref_equiv_dup'
   (#t: Type)
   (#td: typedef t)
   (r1 r2: ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2)
     (fun _ -> ref_equiv r1 r2 `star` ref_equiv r1 r2)
-= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
   HR.share r1;
   HR.share r2;
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
-  ST.noop ();
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
+  noop ();
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 let ref_equiv_sym'
   (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (r1 r2: ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2)
     (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r1)
 = ref_equiv_dup' r1 r2;
-  ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
-  ST.noop ();
-  ST.rewrite (ref_equiv0 r2 r1) (ref_equiv r2 r1)
+  rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  noop ();
+  rewrite (ref_equiv0 r2 r1) (ref_equiv r2 r1)
 
 let hr_share (#a:Type)
           (#uses:_)
           (#p:P.perm)
           (#v:a)
           (r:HR.ref a)
-  : ST.STGhostT unit uses
+  : STGhostT unit uses
       (HR.pts_to r p v)
       (fun _ -> HR.pts_to r (P.half_perm p) v `star` HR.pts_to r (P.half_perm p) v)
 = HR.share #_ #_ #_ #v r
@@ -225,7 +224,7 @@ let hr_gather
   (#p0 #p1:P.perm)
   (v0 #v1:a)
   (r:HR.ref a)
-: ST.STGhost unit uses
+: STGhost unit uses
       (HR.pts_to r p0 v0 `star` HR.pts_to r p1 v1)
       (fun _ -> HR.pts_to r (P.sum_perm p0 p1) v0)
       (requires True)
@@ -237,62 +236,51 @@ let ref_equiv_trans'
   (#t: Type)
   (#td: typedef t)
   (r1 r2 r3: ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2 `star` ref_equiv r2 r3)
     (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r3 `star` ref_equiv r1 r3)
-= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  let p2 = ST.vpattern_replace (fun p -> HR.pts_to r2 p _) in
-  ST.rewrite (ref_equiv r2 r3) (ref_equiv0 r2 r3);
-  let _ = ST.gen_elim () in
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  let p2 = vpattern_replace (fun p -> HR.pts_to r2 p _) in
+  rewrite (ref_equiv r2 r3) (ref_equiv0 r2 r3);
+  let _ = gen_elim () in
   HR.pts_to_injective_eq #_ #_ #_ #_ #w #_ r2;
-  ST.vpattern_rewrite (HR.pts_to r3 _) w;
+  vpattern_rewrite (HR.pts_to r3 _) w;
   hr_share r1;
   hr_share r3;
   HR.gather p2 r2;
   hr_share r2;
-  ST.noop ();
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
-  ST.rewrite (ref_equiv0 r2 r3) (ref_equiv r2 r3);
-  ST.rewrite (ref_equiv0 r1 r3) (ref_equiv r1 r3)
+  noop ();
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
+  rewrite (ref_equiv0 r2 r3) (ref_equiv r2 r3);
+  rewrite (ref_equiv0 r1 r3) (ref_equiv r1 r3)
 
 let hr_share_imbalance (#a:Type)
           (#uses:_)
           (#p:P.perm)
           (#v:a)
           (r:HR.ref a)
-  : ST.STGhostT P.perm uses
+  : STGhostT P.perm uses
       (HR.pts_to r p v)
-      (fun p1 -> HR.pts_to r p1 v `star` ST.exists_ (fun p2 -> HR.pts_to r p2 v))
+      (fun p1 -> HR.pts_to r p1 v `star` exists_ (fun p2 -> HR.pts_to r p2 v))
 = HR.share #_ #_ #_ #v r;
   _
 
 #set-options "--ide_id_info_off"
 
-let pts_to_equiv'
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-  (v: Ghost.erased t)
-: ST.STGhostT unit opened
-    (ref_equiv r1 r2 `star` pts_to r1 v)
-    (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
-= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  ST.weaken (pts_to r1 v) (pts_to0 r1 v) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  hr_gather w r1;
-  hr_share r2;
-  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref v);
-  ST.weaken (pts_to0 r2 v) (pts_to r2 v) (fun _ -> ());
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
 let pts_to_equiv
   r1 r2 v
-= pts_to_equiv' r1 r2 v
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (pts_to r1 v) (pts_to0 r1 v);
+  let _ = gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  rewrite (pts_to0 r2 v) (pts_to r2 v);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 [@@__steel_reduce__; __reduce__]
 let freeable0
@@ -300,159 +288,96 @@ let freeable0
   (#td: typedef t)
   (r: ref td)
 : Tot vprop
-= ST.exists_ (fun p -> ST.exists_ (fun w ->
+= exists_ (fun p -> exists_ (fun w ->
     HR.pts_to r p w `star`
-    ST.pure (R.freeable w.ref)
+    pure (R.freeable w.ref)
   ))
 
 let freeable
   r
 = freeable0 r
 
-let freeable_dup'
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-: ST.STGhostT unit opened
-    (freeable r)
-    (fun _ -> freeable r `star` freeable r)
-= ST.rewrite (freeable r) (freeable0 r);
-  let _ = ST.gen_elim () in
-  HR.share r;
-  ST.noop ();
-  ST.rewrite (freeable0 r) (freeable r);
-  ST.noop ();
-  ST.rewrite (freeable0 r) (freeable r)
-
-module STC = Steel.ST.Coercions
-
 let freeable_dup
   r
-= let _ = freeable_dup' r in
-  noop ()
-
-let freeable_equiv'
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: ST.STGhostT unit opened
-    (ref_equiv r1 r2 `star` freeable r1)
-    (fun _ -> ref_equiv r1 r2 `star` freeable r2)
-= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  ST.rewrite (freeable r1) (freeable0 r1);
-  let _ = ST.gen_elim () in
-  hr_gather w r1;
-  HR.share r2;
-  ST.rewrite (freeable0 r2) (freeable r2);
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+= rewrite (freeable r) (freeable0 r);
+  let _ = gen_elim () in
+  HR.share r;
+  noop ();
+  rewrite (freeable0 r) (freeable r);
+  noop ();
+  rewrite (freeable0 r) (freeable r)
 
 let freeable_equiv
   r1 r2
-= freeable_equiv' r1 r2
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (freeable r1) (freeable0 r1);
+  let _ = gen_elim () in
+  hr_gather w r1;
+  HR.share r2;
+  rewrite (freeable0 r2) (freeable r2);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
-let alloc'
-  (#t: Type)
-  (td: typedef t)
-: ST.STT (ptr td)
-    emp
-    (fun p -> pts_to_or_null p (uninitialized td) `star` freeable_or_null p)
-= let r = RST.ref_alloc td.pcm td.uninitialized in
+let alloc
+  td
+= let r = R.ref_alloc td.pcm td.uninitialized in
   let w = {
     base = _;
     ref = r;
   }
   in
-  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (uninitialized td));
+  rewrite (R.pts_to _ _) (R.pts_to w.ref (uninitialized td));
   let res = HR.alloc w in
   HR.share res;
   HR.pts_to_not_null res;
-  ST.weaken (pts_to0 res (uninitialized td)) (pts_to_or_null res (uninitialized td)) (fun _ -> ());
-  ST.weaken (freeable0 res) (freeable_or_null res) (fun _ -> ());
-  ST.return res
-
-let alloc
-  td
-= alloc' td
+  rewrite (pts_to0 res (uninitialized td)) (pts_to_or_null res (uninitialized td));
+  rewrite (freeable0 res) (freeable_or_null res);
+  return res
 
-let free'
-  (#t: Type)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (r: ref td)
-: ST.ST unit
-    (pts_to r v `star` freeable r)
-    (fun _ -> emp)
-    (
-      full td v
-    )
-    (fun _ -> True)
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+let free
+  #_ #_ #v r
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   let w = HR.read r in
-  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref v);
-  ST.rewrite (freeable r) (freeable0 r);
-  let _ = ST.gen_elim () in
+  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  rewrite (freeable r) (freeable0 r);
+  let _ = gen_elim () in
   hr_gather w r;
-  RST.ref_free w.ref;
-  ST.drop (HR.pts_to _ _ _);
-  ST.return ()
+  R.ref_free w.ref;
+  drop (HR.pts_to _ _ _);
+  return ()
 
-let free
-  r
-= free' r
-
-let mk_fraction_split_gen'
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm)
-: ST.STGhost unit opened
-  (pts_to r (mk_fraction td v p))
-  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
-  (fun _ -> True)
-= ST.weaken (pts_to _ _) (pts_to0 r (mk_fraction td v p)) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
+let mk_fraction_split_gen
+  #_ #_ #td r v p p1 p2
+= rewrite (pts_to _ _) (pts_to0 r (mk_fraction td v p));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
   td.mk_fraction_split v p1 p2;
   td.mk_fraction_join v p1 p2;
-  ST.rewrite
+  rewrite
     (R.pts_to _ _)
     (R.pts_to w.ref (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)));
-  RST.split _ _ (td.mk_fraction v p1) (td.mk_fraction v p2);
+  R.split _ _ (td.mk_fraction v p1) (td.mk_fraction v p2);
   HR.share r;
-  ST.weaken (pts_to0 r (td.mk_fraction v p1)) (pts_to r (mk_fraction td v p1)) (fun _ -> ());
-  ST.weaken (pts_to0 r (td.mk_fraction v p2)) (pts_to r (mk_fraction td v p2)) (fun _ -> ())
+  rewrite (pts_to0 r (td.mk_fraction v p1)) (pts_to r (mk_fraction td v p1));
+  rewrite (pts_to0 r (td.mk_fraction v p2)) (pts_to r (mk_fraction td v p2))
 
-let mk_fraction_split_gen
-  r v p p1 p2
-= mk_fraction_split_gen' r v p p1 p2
-
-let mk_fraction_join'
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p1 p2: P.perm)
-: ST.STGhostT unit opened
-  (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
-= ST.weaken (pts_to r (mk_fraction td v p1)) (pts_to0 r (mk_fraction td v p1)) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (td.mk_fraction v p1));
-  ST.weaken (pts_to r (mk_fraction td v p2)) (pts_to0 r (mk_fraction td v p2)) (fun _ -> ());
-  let _ = ST.gen_elim () in
+let mk_fraction_join
+  #_ #_ #td r v p1 p2
+= rewrite (pts_to r (mk_fraction td v p1)) (pts_to0 r (mk_fraction td v p1));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (R.pts_to _ _) (R.pts_to w.ref (td.mk_fraction v p1));
+  rewrite (pts_to r (mk_fraction td v p2)) (pts_to0 r (mk_fraction td v p2));
+  let _ = gen_elim () in
   hr_gather w r;
-  ST.rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to w.ref (td.mk_fraction v p2));
-  let _ = RST.gather w.ref (td.mk_fraction v p1) _ in
+  rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to w.ref (td.mk_fraction v p2));
+  let _ = R.gather w.ref (td.mk_fraction v p1) _ in
   td.mk_fraction_join v p1 p2;
-  ST.weaken (pts_to0 r _) (pts_to r _) (fun _ -> ())
-
-let mk_fraction_join
-  r v p1 p2
-= mk_fraction_join' r v p1 p2
+  rewrite (pts_to0 r _) (pts_to r _)
 
-module F = Steel.C.Model.Frac
+module F = Steel.ST.C.Model.Frac
 
 let scalar_t t = F.fractional (option t)
 
@@ -531,75 +456,48 @@ let mk_scalar_inj v1 v2 p1 p2 = ()
 
 #restart-solver
 
-let scalar_unique'
-  (#opened: _)
-  (#t: Type)
-  (v1 v2: t)
-  (p1 p2: P.perm)
-  (r: ref (scalar t))
-: ST.STGhost unit opened
-    (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
-    (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
-    True
-    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
-= ST.weaken (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1))) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  ST.rewrite (r_pts_to _ (Some (Some v1, p1))) (R.pts_to w.ref (Some (Some v1, p1)));
-  ST.weaken (pts_to r _) (pts_to0 r (Some (Some v2, p2))) (fun _ -> ());
-  let _ = ST.gen_elim () in
+let scalar_unique
+  #_ #t v1 v2 p1 p2 r
+= rewrite (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1)));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (r_pts_to _ (Some (Some v1, p1))) (R.pts_to w.ref (Some (Some v1, p1)));
+  rewrite (pts_to r _) (pts_to0 r (Some (Some v2, p2)));
+  let _ = gen_elim () in
   hr_gather w r;
-  ST.rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to w.ref (Some (Some v2, p2)));
-  let _ = RST.gather w.ref (Some (Some v1, p1)) (Some (Some v2, p2)) in
-  RST.split w.ref _ (Some (Some v1, p1)) (Some (Some v2, p2));
+  rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to w.ref (Some (Some v2, p2)));
+  let _ = R.gather w.ref (Some (Some v1, p1)) (Some (Some v2, p2)) in
+  R.split w.ref _ (Some (Some v1, p1)) (Some (Some v2, p2));
   HR.share r;
-  ST.noop (); // FIXME: WHY WHY WHY?
-  ST.weaken (pts_to0 r (Some (Some v1, p1))) (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1)) (fun _ -> ());
-  ST.weaken (pts_to0 r (Some (Some v2, p2))) (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2)) (fun _ -> ())
-
-let scalar_unique
-  v1 v2 p1 p2 r0
-= scalar_unique' v1 v2 p1 p2 r0
+  noop (); // FIXME: WHY WHY WHY?
+  rewrite (pts_to0 r (Some (Some v1, p1))) (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1));
+  rewrite (pts_to0 r (Some (Some v2, p2))) (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
 
 #pop-options
 
-let read0' (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : ST.ST t
-  (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-  (True)
-  (fun v' -> v' == Ghost.reveal v)
-= ST.weaken (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p))) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = HR.read r in
-  ST.vpattern_rewrite (HR.pts_to r _) w;
-  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Some (Some (Ghost.reveal v), p)));
-  let v' = RST.ref_read w.ref in
-  let Some (Some v0, _) = v' in
-  ST.rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v), p)));
-  ST.weaken (pts_to0 r (Some (Some (Ghost.reveal v), p))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p)) (fun _ -> ());
-  ST.return v0
-
 let read0
-  r0
-= read0' r0
-
-let write' (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : ST.ST unit
-  (pts_to r v)
-  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
-  (full (scalar t) v)
-  (fun _ -> True)
-= ST.weaken (pts_to r _) (pts_to0 r (Ghost.reveal v)) (fun _ -> ());
-  let _ = ST.gen_elim () in
+  #t #v #p r
+= rewrite (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p)));
+  let _ = gen_elim () in
   let w = HR.read r in
-  ST.vpattern_rewrite (HR.pts_to r _) w;
-  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
-  RST.ref_upd w.ref _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
-  ST.rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v'), P.full_perm)));
-  ST.weaken (pts_to0 r (Some (Some (Ghost.reveal v'), P.full_perm))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v')) P.full_perm)) (fun _ -> ())
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Some (Some (Ghost.reveal v), p)));
+  let v' = R.ref_read w.ref in
+  let Some (Some v0, _) = v' in
+  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v), p)));
+  rewrite (pts_to0 r (Some (Some (Ghost.reveal v), p))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p));
+  return v0
 
 let write
-  r0 v'
-= write' r0 v'
+  #t #v r v'
+= rewrite (pts_to r _) (pts_to0 r (Ghost.reveal v));
+  let _ = gen_elim () in
+  let w = HR.read r in
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  R.ref_upd w.ref _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
+  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v'), P.full_perm)));
+  rewrite (pts_to0 r (Some (Some (Ghost.reveal v'), P.full_perm))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v')) P.full_perm))
 
 let field_t_nil = unit
 let field_t_cons _ _ _ = unit
@@ -642,7 +540,7 @@ let fd_gen_of_nonempty_fd (#tf: Type0) (fd: nonempty_field_description_t tf) : T
   fd_typedef = (fun (s: field_t fd) -> fd.fd_typedef s);
 }
 
-module S = Steel.C.Model.Struct
+module S = Steel.ST.C.Model.Struct
 
 [@@noextract_to "krml"] // proof-only
 let struct_field_pcm
@@ -811,10 +709,10 @@ let has_struct_field0
   (field: field_t)
   (r': ref (fields.fd_typedef field))
 : Tot vprop
-= ST.exists_ (fun p -> ST.exists_ (fun w -> ST.exists_ (fun p' -> ST.exists_ (fun w' ->
+= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
     HR.pts_to r p w `star`
     HR.pts_to r' p' w' `star`
-    ST.pure (has_struct_field_gen fields w field w')
+    pure (has_struct_field_gen fields w field w')
   ))))
 
 let has_struct_field1
@@ -837,18 +735,18 @@ let has_struct_field_dup'
   (r: ref (struct1 fields))
   (field: field_t)
   (r': ref (fields.fd_typedef field))
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_struct_field1 r field r')
     (fun _ -> has_struct_field1 r field r' `star` has_struct_field1 r field r')
 =
-  ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = ST.gen_elim () in
+  rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = gen_elim () in
   HR.share r;
   HR.share r';
-  ST.noop ();
-  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  ST.noop ();
-  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
+  noop ();
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  noop ();
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
 
 let has_struct_field_dup
   r field r'
@@ -861,24 +759,24 @@ let has_struct_field_inj'
   (r: ref (struct1 fields))
   (field: field_t)
   (r1 r2: ref (fields.fd_typedef field))
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_struct_field1 r field r1 `star` has_struct_field1 r field r2)
     (fun _ -> has_struct_field1 r field r1 `star` has_struct_field1 r field r2 `star` ref_equiv r1 r2)
 =
-  ST.rewrite (has_struct_field1 r field r1) (has_struct_field0 r field r1);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  let w1 = ST.vpattern_replace (HR.pts_to r1 _) in
-  ST.rewrite (has_struct_field1 r field r2) (has_struct_field0 r field r2);
-  let _ = ST.gen_elim () in
+  rewrite (has_struct_field1 r field r1) (has_struct_field0 r field r1);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w1 = vpattern_replace (HR.pts_to r1 _) in
+  rewrite (has_struct_field1 r field r2) (has_struct_field0 r field r2);
+  let _ = gen_elim () in
   hr_gather w r;
-  ST.vpattern_rewrite (HR.pts_to r2 _) w1;
+  vpattern_rewrite (HR.pts_to r2 _) w1;
   hr_share r;
   hr_share r1;
-  ST.rewrite (has_struct_field0 r field r1) (has_struct_field1 r field r1);
+  rewrite (has_struct_field0 r field r1) (has_struct_field1 r field r1);
   hr_share r2;
-  ST.rewrite (has_struct_field0 r field r2) (has_struct_field1 r field r2);
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+  rewrite (has_struct_field0 r field r2) (has_struct_field1 r field r2);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 let has_struct_field_inj
   r field r1 r2
@@ -892,18 +790,18 @@ let has_struct_field_equiv_from'
   (field: field_t)
   (r': ref (fields.fd_typedef field))
   (r2: ref (struct1 fields))
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2 `star` has_struct_field1 r1 field r')
     (fun _ -> ref_equiv r1 r2 `star` has_struct_field1 r2 field r')
-= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  ST.rewrite (has_struct_field1 r1 field r') (has_struct_field0 r1 field r');
-  let _ = ST.gen_elim () in
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (has_struct_field1 r1 field r') (has_struct_field0 r1 field r');
+  let _ = gen_elim () in
   hr_gather w r1;
   hr_share r2;
-  ST.rewrite (has_struct_field0 r2 field r') (has_struct_field1 r2 field r');
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+  rewrite (has_struct_field0 r2 field r') (has_struct_field1 r2 field r');
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 let has_struct_field_equiv_from
   r1 field r' r2
@@ -917,18 +815,18 @@ let has_struct_field_equiv_to'
   (field: field_t)
   (r1': ref (fields.fd_typedef field))
   (r2': ref (fields.fd_typedef field))
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1' r2' `star` has_struct_field1 r field r1')
     (fun _ -> ref_equiv r1' r2' `star` has_struct_field1 r field r2')
-= ST.rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
-  ST.rewrite (has_struct_field1 r field r1') (has_struct_field0 r field r1');
-  let _ = ST.gen_elim () in
+= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  rewrite (has_struct_field1 r field r1') (has_struct_field0 r field r1');
+  let _ = gen_elim () in
   hr_gather w r1';
   hr_share r2';
-  ST.rewrite (has_struct_field0 r field r2') (has_struct_field1 r field r2');
-  ST.rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+  rewrite (has_struct_field0 r field r2') (has_struct_field1 r field r2');
+  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
 
 let has_struct_field_equiv_to
   r field r1 r2
@@ -942,17 +840,17 @@ let ghost_struct_field_focus'
   (r: ref (struct1 fields))
   (field: field_t)
   (r': ref (fields.fd_typedef field))
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_struct_field1 r field r' `star` pts_to r v)
     (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field))
-= ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  let w' = ST.vpattern_replace (HR.pts_to r' _) in
-  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   hr_gather w r;
-  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
   let prf
     (f': field_t)
     (x: (fields.fd_type f'))
@@ -968,14 +866,14 @@ let ghost_struct_field_focus'
   let vf = S.field_to_struct_f (struct_field_pcm _) field (t_struct_get_field v field) in
   assert (composable (struct_pcm _) v' vf);
   assert (op (struct_pcm _) v' vf `FX.feq` v);
-  RST.split w.ref _ v' vf;
-  RST.gfocus w.ref (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
+  R.split w.ref _ v' vf;
+  R.gfocus w.ref (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
   hr_share r;
   hr_share r';
-  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  ST.weaken (pts_to0 r v') (pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v)) (fun _ -> ());
-  ST.rewrite (R.pts_to _ _) (r_pts_to w'.ref (t_struct_get_field v field));
-  ST.weaken (pts_to0 r' (t_struct_get_field v field)) (pts_to r' (t_struct_get_field v field)) (fun _ -> ())
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r v') (pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v));
+  rewrite (R.pts_to _ _) (r_pts_to w'.ref (t_struct_get_field v field));
+  rewrite (pts_to0 r' (t_struct_get_field v field)) (pts_to r' (t_struct_get_field v field))
   
 let ghost_struct_field_focus
   r field r'
@@ -991,13 +889,13 @@ let ghost_struct_field'
   (#v: Ghost.erased (struct_t1 fields))
   (r: ref (struct1 fields))
   (field: field_t)
-: ST.STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
     (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
   let w' = {
     base = w.base;
     ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
@@ -1006,13 +904,13 @@ let ghost_struct_field'
   let gr' = GHR.alloc w' in
   let r1' = GHR.reveal_ref gr' in
   GHR.reveal_pts_to gr' P.full_perm w';
-  ST.rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
   HR.pts_to_not_null r1';
   let r' = Ghost.hide r1' in
-  ST.rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
   hr_share r;
-  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
   ghost_struct_field_focus' r field r';
   r'
 
@@ -1027,14 +925,14 @@ let struct_field'
   (#v: Ghost.erased (struct_t1 fields))
   (r: ref (struct1 fields))
   (field: field_t)
-: ST.STT (ref (fields.fd_typedef field))
+: STT (ref (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   let w = HR.read r in
-  ST.vpattern_rewrite (HR.pts_to r _) w;
-  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
   let w' = {
     base = w.base;
     ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
@@ -1042,18 +940,18 @@ let struct_field'
   in
   let r' = HR.alloc w' in
   hr_share r;
-  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
   ghost_struct_field_focus' r field r';
-  ST.return r'
+  return r'
 
 let struct_field0
   t' #_ #_ #v r field td'
 = let r1' = struct_field' r field in
   let r' : ref td' = r1' in
-  ST.rewrite (pts_to r1' _) (pts_to r' (struct_get_field v field));
-  ST.rewrite (has_struct_field1 _ _ _) (has_struct_field r field r');
-  ST.return r'
+  rewrite (pts_to r1' _) (pts_to r' (struct_get_field v field));
+  rewrite (has_struct_field1 _ _ _) (has_struct_field r field r');
+  return r'
 
 let r_unfocus (#opened:_)
   (#ta #ta' #tb #tc: Type)
@@ -1061,7 +959,7 @@ let r_unfocus (#opened:_)
   (#q: pcm tc)
   (r: R.ref ta q) (r': R.ref ta' p)
   (l: Steel.C.Model.Connection.connection p q) (x: tc)
-: ST.STGhost (Ghost.erased tb) opened
+: STGhost (Ghost.erased tb) opened
     (r `R.pts_to` x)
     (fun x' -> r' `R.pts_to` x')
     (requires
@@ -1069,9 +967,9 @@ let r_unfocus (#opened:_)
       r == R.ref_focus r' l)
     (ensures fun x' -> Ghost.reveal x' == l.conn_small_to_large.morph x)
 = let r1 : R.ref ta' q = r in
-  ST.rewrite (r `R.pts_to` x) (r1 `R.pts_to` x);
-  RST.unfocus r1 r' l x;
-  let x' = ST.vpattern_replace_erased (R.pts_to r') in
+  rewrite (r `R.pts_to` x) (r1 `R.pts_to` x);
+  R.unfocus r1 r' l x;
+  let x' = vpattern_replace_erased (R.pts_to r') in
   x'
 
 let unstruct_field'
@@ -1083,25 +981,25 @@ let unstruct_field'
   (field: field_t)
   (#v': Ghost.erased (fields.fd_type field))
   (r': ref (fields.fd_typedef field))
-: ST.STGhost unit opened
+: STGhost unit opened
     (has_struct_field1 r field r' `star` pts_to r v `star` pts_to r' v')
     (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field v' v))
     (
       t_struct_get_field v field == unknown (fields.fd_typedef field)
     )
     (fun _ -> True)
-= ST.rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  let w' = ST.vpattern_replace (HR.pts_to r' _) in
-  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   hr_gather w r;
-  ST.rewrite (r_pts_to _ (Ghost.reveal v)) (R.pts_to w.ref (Ghost.reveal v));
-  ST.weaken (pts_to r' v') (pts_to0 r' v') (fun _ -> ());
-  let _ = ST.gen_elim () in
+  rewrite (r_pts_to _ (Ghost.reveal v)) (R.pts_to w.ref (Ghost.reveal v));
+  rewrite (pts_to r' v') (pts_to0 r' v');
+  let _ = gen_elim () in
   hr_gather w' r';
-  ST.rewrite (r_pts_to _ (Ghost.reveal v')) (R.pts_to w'.ref (Ghost.reveal v'));
+  rewrite (r_pts_to _ (Ghost.reveal v')) (R.pts_to w'.ref (Ghost.reveal v'));
   let prf
     (f': field_t)
     (x: (fields.fd_type f'))
@@ -1117,10 +1015,10 @@ let unstruct_field'
   assert (composable (struct_pcm _) v vf);
   assert (op (struct_pcm _) v vf `FX.feq` t_struct_set_field field v' v);
   let _ = r_unfocus w'.ref w.ref (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
-  let _ = RST.gather w.ref (Ghost.reveal v) _ in
+  let _ = R.gather w.ref (Ghost.reveal v) _ in
   hr_share r;
-  ST.rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  ST.weaken (pts_to0 r _) (pts_to r _) (fun _ -> ())
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r _) (pts_to r _)
 
 let unstruct_field
   r field r'
@@ -1166,7 +1064,7 @@ let full_struct_gen
 
 let full_struct s = full_struct_gen s
 
-module U = Steel.C.Model.Union
+module U = Steel.ST.C.Model.Union
 
 let define_union0 _ _ _ = unit
 
@@ -1421,10 +1319,10 @@ let has_union_field0
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
 : Tot vprop
-= ST.exists_ (fun p -> ST.exists_ (fun w -> ST.exists_ (fun p' -> ST.exists_ (fun w' ->
+= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
     HR.pts_to r p w `star`
     HR.pts_to r' p' w' `star`
-    ST.pure (has_union_field_gen w field w')
+    pure (has_union_field_gen w field w')
   ))))
 
 let has_union_field
@@ -1435,59 +1333,59 @@ let has_union_field
 
 let has_union_field_dup
   r field r'
-= ST.rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = ST.gen_elim () in
+= rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = gen_elim () in
   hr_share r;
   hr_share r';
-  ST.noop ();
-  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
-  ST.noop ();
-  ST.rewrite (has_union_field0 r field r') (has_union_field r field r')
+  noop ();
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  noop ();
+  rewrite (has_union_field0 r field r') (has_union_field r field r')
 
 #push-options "--z3rlimit 16"
 
 let has_union_field_inj
   r field r1 r2
-= ST.rewrite (has_union_field r field r1) (has_union_field0 r field r1);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  ST.rewrite (has_union_field r field r2) (has_union_field0 r field r2);
-  let _ = ST.gen_elim () in
+= rewrite (has_union_field r field r1) (has_union_field0 r field r1);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (has_union_field r field r2) (has_union_field0 r field r2);
+  let _ = gen_elim () in
   hr_gather w r;
   hr_share r;
   hr_share r1;
-  ST.rewrite (has_union_field0 r field r1) (has_union_field r field r1);
+  rewrite (has_union_field0 r field r1) (has_union_field r field r1);
   hr_share r2;
-  ST.rewrite (has_union_field0 r field r2) (has_union_field r field r2);
-  let w' = ST.vpattern_replace (HR.pts_to r1 _) in
-  ST.vpattern_rewrite (HR.pts_to r2 _) w';
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+  rewrite (has_union_field0 r field r2) (has_union_field r field r2);
+  let w' = vpattern_replace (HR.pts_to r1 _) in
+  vpattern_rewrite (HR.pts_to r2 _) w';
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 #pop-options
 
 let has_union_field_equiv_from
   r1 r2 field r'
-= ST.rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  ST.rewrite (has_union_field r1 field r') (has_union_field0 r1 field r');
-  let _ = ST.gen_elim () in
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (has_union_field r1 field r') (has_union_field0 r1 field r');
+  let _ = gen_elim () in
   hr_gather w r1;
   hr_share r2;
-  ST.rewrite (has_union_field0 r2 field r') (has_union_field r2 field r');
-  ST.rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+  rewrite (has_union_field0 r2 field r') (has_union_field r2 field r');
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 let has_union_field_equiv_to
   r field r1' r2'
-= ST.rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
-  ST.rewrite (has_union_field r field r1') (has_union_field0 r field r1');
-  let _ = ST.gen_elim () in
+= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  rewrite (has_union_field r field r1') (has_union_field0 r field r1');
+  let _ = gen_elim () in
   hr_gather w r1';
   hr_share r2';
-  ST.rewrite (has_union_field0 r field r2') (has_union_field r field r2');
-  ST.rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+  rewrite (has_union_field0 r field r2') (has_union_field r field r2');
+  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
 
 #push-options "--z3rlimit 16"
 
@@ -1495,28 +1393,28 @@ let has_union_field_equiv_to
 
 let ghost_union_field_focus
   #_ #tn #_ #n #fields #v r field r'
-= ST.rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  let w' = ST.vpattern_replace (HR.pts_to r' _) in
-  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+= rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   hr_gather w r;
-  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
   let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
   assert (v' `FX.feq` v);
-  RST.gfocus w.ref (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
-  ST.rewrite (R.pts_to _ _) (R.pts_to w'.ref (union_get_field v field));
+  R.gfocus w.ref (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
+  rewrite (R.pts_to _ _) (R.pts_to w'.ref (union_get_field v field));
   hr_share r';
-  ST.weaken (pts_to0 r' _) (pts_to r' _) (fun _ -> ());
-  ST.rewrite (has_union_field0 r field r') (has_union_field r field r')
+  rewrite (pts_to0 r' _) (pts_to r' _);
+  rewrite (has_union_field0 r field r') (has_union_field r field r')
 
 let ghost_union_field
   #_ #tn #_ #n #fields #v r field
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
   let w' = {
     base = w.base;
     ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
@@ -1525,13 +1423,13 @@ let ghost_union_field
   let gr' = GHR.alloc w' in
   let r1' = GHR.reveal_ref gr' in
   GHR.reveal_pts_to gr' P.full_perm w';
-  ST.rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
   HR.pts_to_not_null r1';
   let r' = Ghost.hide r1' in
-  ST.rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
   hr_share r;
-  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
-  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
   ghost_union_field_focus r field r';
   r'
 
@@ -1544,14 +1442,14 @@ let union_field'
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: SteelT (ref (fields.fd_typedef field))
+: STT (ref (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   let w = HR.read r in
-  ST.vpattern_rewrite (HR.pts_to r _) w;
-  ST.rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
   let w' = {
     base = w.base;
     ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
@@ -1559,18 +1457,18 @@ let union_field'
   in
   let r' = HR.alloc w' in
   hr_share r;
-  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
-  ST.weaken (pts_to0 r (Ghost.reveal v)) (pts_to r v) (fun _ -> ());
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
   ghost_union_field_focus r field r';
-  ST.return r'
+  return r'
 
 let union_field0
   t' r field td'
 =
   let r' = union_field' r field in
   let res : ref td' = r' in
-  change_equal_slprop (pts_to r' _) (pts_to res _);
-  ST.rewrite (has_union_field r field _) (has_union_field r field res);
+  rewrite (pts_to r' _) (pts_to res _);
+  rewrite (has_union_field r field _) (has_union_field r field res);
   return res
 
 #pop-options
@@ -1582,19 +1480,19 @@ let union_field0
 
 let ununion_field
   #_ #tn #_ #n #fields r field #v' r'
-= ST.rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
-  let w' = ST.vpattern_replace (HR.pts_to r' _) in
-  ST.weaken (pts_to r' v') (pts_to0 r' v') (fun _ -> ());
-  let _= ST.gen_elim () in
+= rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r' v') (pts_to0 r' v');
+  let _= gen_elim () in
   hr_gather w' r';
-  ST.rewrite (r_pts_to _ _) (R.pts_to w'.ref (Ghost.reveal v'));
+  rewrite (r_pts_to _ _) (R.pts_to w'.ref (Ghost.reveal v'));
   let _ = r_unfocus w'.ref w.ref (coerce_eq () (U.union_field (union_field_pcm fields) (Some field))) _ in
   hr_share r;
-  ST.rewrite (has_union_field0 r field r') (has_union_field r field r');
-  ST.rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
-  ST.weaken (pts_to0 r (union_set_field tn n fields field (Ghost.reveal v'))) (pts_to r (union_set_field tn n fields field (Ghost.reveal v'))) (fun _ -> ())
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
+  rewrite (pts_to0 r (union_set_field tn n fields field (Ghost.reveal v'))) (pts_to r (union_set_field tn n fields field (Ghost.reveal v')))
 
 [@@noextract_to "krml"] // primitive
 let union_switch_field'
@@ -1605,41 +1503,25 @@ let union_switch_field'
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields)
-: Steel (ref (fields.fd_typedef field))
+: ST (ref (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
-    (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> True)
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+    (full (union0 tn n fields) v)
+    (fun _ -> True)
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   let w = HR.read r in
-  ST.vpattern_rewrite (HR.pts_to r _) w;
-  ST.rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
   let v' : union_t0 tn n fields = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
-  RST.ref_upd w.ref _ _ (R.base_fpu (union_pcm tn n fields) _ v');
-  ST.weaken (pts_to0 r v') (pts_to r v') (fun _ -> ());
+  R.ref_upd w.ref _ _ (R.base_fpu (union_pcm tn n fields) _ v');
+  rewrite (pts_to0 r v') (pts_to r v');
   let r' = union_field' r field in
-  ST.rewrite (pts_to r' _) (pts_to r' (uninitialized (fields.fd_typedef field)));
-  ST.return r'
+  rewrite (pts_to r' _) (pts_to r' (uninitialized (fields.fd_typedef field)));
+  return r'
 
 #pop-options
 
-[@@noextract_to "krml"] // primitive
-let union_switch_field1'
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-: ST.ST (ref (fields.fd_typedef field))
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
-    (full (union0 tn n fields) v)
-    (fun _ -> True)
-= STC.coerce_steel (fun _ -> union_switch_field' r field)
-
 [@@noextract_to "krml"] // primitive
 let union_switch_field0'
   (#tn: Type0)
@@ -1655,16 +1537,16 @@ let union_switch_field0'
     t' ==  fields.fd_type field /\
     td' == fields.fd_typedef field
   ))
-: ST.ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
     (pts_to r v)
     (fun r' -> has_union_field r field (coerce_eq () r') `star` pts_to r' (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))))
     (full (union0 tn n fields) v)
     (fun _ -> True)
-= let r' = union_switch_field1' #tn #tf #n #fields #v r field in
+= let r' = union_switch_field' #tn #tf #n #fields #v r field in
   let res : ref td' = r' in
-  ST.rewrite (pts_to r' _) (pts_to res (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))));
-  ST.rewrite (has_union_field r field _) (has_union_field r field (coerce_eq () res));
-  ST.return res
+  rewrite (pts_to r' _) (pts_to res (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))));
+  rewrite (has_union_field r field _) (has_union_field r field (coerce_eq () res));
+  return res
 
 let union_switch_field0
   t' r field td'
@@ -1675,7 +1557,7 @@ let union_switch_field0
 
 /// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
 
-module A = Steel.C.Model.Array
+module A = Steel.ST.C.Model.Array
 
 let base_array_t'
   (t: Type0)
@@ -1783,9 +1665,9 @@ let has_base_array_cell0
   (i: SZ.t)
   (r': ref td)
 : Tot vprop
-= ST.exists_ (fun j ->
+= exists_ (fun j ->
     has_base_array_cell_as_struct_field r i j r' `star`
-    ST.pure (i == j)
+    pure (i == j)
   )
 
 let has_base_array_cell1
@@ -1804,9 +1686,9 @@ let has_base_array_cell
 
 let has_base_array_cell_post
   r i r'
-= ST.rewrite (has_base_array_cell r i r') (has_base_array_cell0 r i r');
-  let _ = ST.gen_elim () in
-  ST.rewrite (has_base_array_cell0 r i r') (has_base_array_cell r i r')
+= rewrite (has_base_array_cell r i r') (has_base_array_cell0 r i r');
+  let _ = gen_elim () in
+  rewrite (has_base_array_cell0 r i r') (has_base_array_cell r i r')
 
 let has_base_array_cell_dup'
   (#opened: _)
@@ -1816,15 +1698,15 @@ let has_base_array_cell_dup'
   (r: ref (base_array1 td n))
   (i: SZ.t)
   (r': ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell1 r i r')
     (fun _ -> has_base_array_cell1 r i r' `star` has_base_array_cell1 r i r')
-= ST.rewrite (has_base_array_cell1 r i r') (has_base_array_cell0 r i r');
-  let _ = ST.gen_elim () in
+= rewrite (has_base_array_cell1 r i r') (has_base_array_cell0 r i r');
+  let _ = gen_elim () in
   has_struct_field_dup'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ _;
-  ST.rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r');
-  ST.noop ();
-  ST.rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r')
+  rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r');
+  noop ();
+  rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r')
 
 let has_base_array_cell_dup
   r i r'
@@ -1838,18 +1720,18 @@ let has_base_array_cell_inj'
   (r: ref (base_array1 td n))
   (i: SZ.t)
   (r1 r2: ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2)
     (fun _ -> has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
-= ST.rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
-  let _ = ST.gen_elim () in
-  let j = ST.vpattern_replace (fun j -> has_base_array_cell_as_struct_field r i j _) in
-  ST.rewrite (has_base_array_cell1 r i r2) (has_base_array_cell0 r i r2);
-  let _ = ST.gen_elim () in
-  ST.vpattern_rewrite (fun j' -> has_base_array_cell_as_struct_field r i j _ `star` has_base_array_cell_as_struct_field r i j' _) j;
+= rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
+  let _ = gen_elim () in
+  let j = vpattern_replace (fun j -> has_base_array_cell_as_struct_field r i j _) in
+  rewrite (has_base_array_cell1 r i r2) (has_base_array_cell0 r i r2);
+  let _ = gen_elim () in
+  vpattern_rewrite (fun j' -> has_base_array_cell_as_struct_field r i j _ `star` has_base_array_cell_as_struct_field r i j' _) j;
   has_struct_field_inj' #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ r1 r2;
-  ST.rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2);
-  ST.rewrite (has_base_array_cell0 r i r1) (has_base_array_cell1 r i r1)
+  rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2);
+  rewrite (has_base_array_cell0 r i r1) (has_base_array_cell1 r i r1)
 
 let has_base_array_cell_inj
   r i r1 r2
@@ -1863,13 +1745,13 @@ let has_base_array_cell_equiv_from'
   (r1 r2: ref (base_array1 td n))
   (i: SZ.t)
   (r': ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell1 r1 i r' `star` ref_equiv r1 r2)
     (fun _ -> has_base_array_cell1 r2 i r' `star` ref_equiv r1 r2)
-= ST.rewrite (has_base_array_cell1 r1 i r') (has_base_array_cell0 r1 i r');
-  let _ = ST.gen_elim () in
+= rewrite (has_base_array_cell1 r1 i r') (has_base_array_cell0 r1 i r');
+  let _ = gen_elim () in
   has_struct_field_equiv_from'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r1) _ r' (r2);
-  ST.rewrite (has_base_array_cell0 r2 i r') (has_base_array_cell1 r2 i r')
+  rewrite (has_base_array_cell0 r2 i r') (has_base_array_cell1 r2 i r')
 
 let has_base_array_cell_equiv_from
   r1 r2 i r'
@@ -1883,13 +1765,13 @@ let has_base_array_cell_equiv_to'
   (r: ref (base_array1 td n))
   (i: SZ.t)
   (r1 r2: ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell1 r i r1 `star` ref_equiv r1 r2)
     (fun _ -> has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
-= ST.rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
-  let _ = ST.gen_elim () in
+= rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
+  let _ = gen_elim () in
   has_struct_field_equiv_to' r _ r1 r2;
-  ST.rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2)
+  rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2)
 
 let has_base_array_cell_equiv_to
   r i r1 r2
@@ -1948,37 +1830,37 @@ let array_pts_to0
   (r: array td)
   (v: Ghost.erased (Seq.seq t))
 : Tot vprop
-= ST.exists_ (fun br -> ST.exists_ (fun p ->
+= exists_ (fun br -> exists_ (fun p ->
     HR.pts_to (dfst r).ar_base p br `star`
     A.pts_to (model_array_of_array r br) v
   ))
 
-let array_pts_to' r v =
+let array_pts_to r v =
   array_pts_to0 r v
 
 let array_pts_to_length r v =
-  ST.weaken (array_pts_to r v) (array_pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+  rewrite (array_pts_to r v) (array_pts_to0 r v);
+  let _ = gen_elim () in
   let _ = A.pts_to_length _ _ in
-  ST.weaken (array_pts_to0 r v) (array_pts_to r v) (fun _ -> ())
+  rewrite (array_pts_to0 r v) (array_pts_to r v)
 
 #push-options "--z3rlimit 16"
 #restart-solver
 
 let ghost_array_of_base_focus
   #_ #_ #_ #_ #td #v r a
-= ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let w = ST.vpattern_replace (HR.pts_to r _) in
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
   let w' : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () w in
   assert ((model_array_of_array a w').base == w.ref);
-  ST.rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
+  rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
   assert (seq_of_base_array v `Seq.equal` A.seq_of_array_pcm_carrier v);
   A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
   A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array v);
-  let p = ST.vpattern_replace (fun p -> HR.pts_to _ p _) in
-  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
-  ST.weaken (array_pts_to0 a (seq_of_base_array v)) (array_pts_to a (seq_of_base_array v)) (fun _ -> ())
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
+  rewrite (array_pts_to0 a (seq_of_base_array v)) (array_pts_to a (seq_of_base_array v))
 
 #pop-options
 
@@ -2005,11 +1887,11 @@ let array_of_base0
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
-: SteelAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
     (pts_to r v)
     (fun a -> array_pts_to a (seq_of_base_array v))
+    (True)
     (fun _ -> True)
-    (fun _ _ _ -> True)
 =
   let al : array_ref td = {
     ar_base_size = n;
@@ -2020,21 +1902,13 @@ let array_of_base0
   in
   let a : (a: array td { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
   ghost_array_of_base_focus r a;
-  ST.return a
+  return a
 
 let array_ref_of_base
   #_ #tn #_ #n #td #v r
-= let ar : array td = array_of_base0 r in
+=
+  let ar = array_of_base0 r in
   let a : array_ref td = dfst ar in
-  intro_pure _;
-  intro_exists ar (fun (ar: array td) ->
-      array_pts_to ar (seq_of_base_array v) `star` pure (
-        dfst ar == a /\
-        array_ref_base_size a == Ghost.reveal n /\
-        array_ref_offset a == 0sz /\
-        has_array_of_base r ar /\
-        Ghost.reveal (dsnd ar) == Ghost.reveal n
-    ));
   return a
 
 #push-options "--z3rlimit 16 --split_queries"
@@ -2065,27 +1939,9 @@ let has_array_of_base'
     array_ref_offset al == 0sz /\
     Ghost.reveal len == n
 
-let a_pts_to_elim_to_base
-  (#opened: _)
-  (#base_t: Type)
-  (#t: Type)
-  (#p: pcm t)
-  (r: A.array base_t p)
-  (x: Seq.seq t)
-: SteelGhost (Ghost.erased (A.array_pcm_carrier t r.base_len)) opened
-    (A.pts_to r x)
-    (fun y -> r_pts_to r.base y)
-    (fun _ -> True)
-    (fun _ y _ ->
-      Seq.length x == A.size_v r.len /\
-      Ghost.reveal y == (A.ref_of_array_conn r).conn_small_to_large.morph (A.array_pcm_carrier_of_seq r.len x) /\
-      Ghost.reveal y == S.substruct_to_struct_f (A.array_elements_pcm p r.base_len) (A.array_elements_pcm p r.len) (A.small_to_large_index r.base_len r.offset r.len ()) (A.large_to_small_index r.base_len r.offset r.len ()) () (A.array_pcm_carrier_of_seq r.len x)
-    )
-= A.pts_to_elim_to_base r x
-
 #pop-options
 
-#push-options "--z3rlimit 32"
+#push-options "--z3rlimit 64"
 #restart-solver
 
 let unarray_of_base0
@@ -2096,25 +1952,25 @@ let unarray_of_base0
   (#v: Ghost.erased (Seq.seq t))
   (r: ref (base_array1 td n))
   (a: array td)
-: SteelGhost (Ghost.erased (base_array_t' t n)) opened
+: STGhost (Ghost.erased (base_array_t' t n)) opened
     (array_pts_to a v)
     (fun v' -> pts_to r v')
-    (fun _ ->
+    (
       has_array_of_base' r a
     )
-    (fun _ v' _ -> Ghost.reveal v `Seq.equal` seq_of_base_array0 v')
-= ST.weaken (array_pts_to a v) (array_pts_to0 a v) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let p = ST.vpattern_replace (fun p -> HR.pts_to _ p _) in
-  let ba = ST.vpattern_replace (HR.pts_to _ _) in
+    (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array0 v')
+= rewrite (array_pts_to a v) (array_pts_to0 a v);
+  let _ = gen_elim () in
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
+  let ba = vpattern_replace (HR.pts_to _ _) in
   let ba' : ref0_v (base_array1 td n) = coerce_eq () ba in
-  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba');
+  rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba');
   let m = model_array_of_array a ba in
-  ST.rewrite (A.pts_to _ _) (A.pts_to m v);
-  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = a_pts_to_elim_to_base m v in
+  rewrite (A.pts_to _ _) (A.pts_to m v);
+  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = A.pts_to_elim_to_base m v in
   let y' : Ghost.erased (base_array_t' t n) = Ghost.hide (Ghost.reveal y) in
-  change_equal_slprop (r_pts_to _ _) (r_pts_to ba'.ref (Ghost.reveal y'));
-  ST.weaken (pts_to0 r y') (pts_to r y') (fun _ -> ());
+  rewrite (r_pts_to _ _) (r_pts_to ba'.ref (Ghost.reveal y'));
+  rewrite (pts_to0 r y') (pts_to r y');
   y'
 
 #pop-options
@@ -2201,9 +2057,9 @@ let has_array_cell0
   (i: SZ.t)
   (r: ref td)
 : Tot vprop
-= ST.exists_ (fun (j: SZ.t) ->
+= exists_ (fun (j: SZ.t) ->
     has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r `star`
-    ST.pure (
+    pure (
       SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i /\
       SZ.v i < SZ.v (dsnd a)
     )
@@ -2224,23 +2080,23 @@ let has_array_cell
 
 let has_array_cell_post
   a i r
-= ST.rewrite (has_array_cell a i r) (has_array_cell0 a i r);
-  let _ = ST.gen_elim () in
-  ST.rewrite (has_array_cell0 a i r) (has_array_cell a i r)
+= rewrite (has_array_cell a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  rewrite (has_array_cell0 a i r) (has_array_cell a i r)
 
 let has_array_cell_has_base_array_cell
   a i r br
-= ST.rewrite (has_array_cell a i r) (has_array_cell0 a i r);
-  let _ = ST.gen_elim () in
-  let j = ST.vpattern_replace_erased (fun j -> has_base_array_cell1 _ j r) in
-  ST.rewrite (has_base_array_cell1 _ _ _) (has_base_array_cell br j r);
+= rewrite (has_array_cell a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  let j = vpattern_replace_erased (fun j -> has_base_array_cell1 _ j r) in
+  rewrite (has_base_array_cell1 _ _ _) (has_base_array_cell br j r);
   j
 
 let has_base_array_cell_has_array_cell
   a i r br
 = let j : Ghost.erased SZ.t = Ghost.hide (i `SZ.sub` (dfst a).ar_offset) in
-  ST.rewrite (has_base_array_cell br i r) (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker j i) r);
-  ST.rewrite (has_array_cell0 a j r) (has_array_cell a j r);
+  rewrite (has_base_array_cell br i r) (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker j i) r);
+  rewrite (has_array_cell0 a j r) (has_array_cell a j r);
   j
 
 let has_array_cell_inj
@@ -2249,12 +2105,12 @@ let has_array_cell_inj
   let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
   let j1 = has_array_cell_has_base_array_cell a i r1 br in
   let j2 = has_array_cell_has_base_array_cell a i r2 br in
-  ST.vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
+  vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
   has_base_array_cell_inj br j1 r1 r2;
   let _ = has_base_array_cell_has_array_cell a j1 r1 br in
-  ST.vpattern_rewrite (fun i -> has_array_cell _ i r1) i;
+  vpattern_rewrite (fun i -> has_array_cell _ i r1) i;
   let _ = has_base_array_cell_has_array_cell a j1 r2 br in
-  ST.vpattern_rewrite (fun i -> has_array_cell _ i r2) i
+  vpattern_rewrite (fun i -> has_array_cell _ i r2) i
   
 
 #restart-solver
@@ -2264,9 +2120,9 @@ let struct_field_eq_cell
   (n: array_size_t)
   (k: base_array_index_t n)
 : Lemma
-  (Steel.C.Model.Struct.struct_field (struct_field_pcm (base_array_fd td n)) k == A.cell td.pcm n k)
+  (Steel.ST.C.Model.Struct.struct_field (struct_field_pcm (base_array_fd td n)) k == A.cell td.pcm n k)
 = // assert_norm (A.array_domain n == base_array_index_t n);
-  Steel.C.Model.Struct.struct_field_ext #(A.array_domain n) #(A.array_range t n) (struct_field_pcm (base_array_fd td n)) (A.array_elements_pcm td.pcm n) (fun _ -> ()) k
+  Steel.ST.C.Model.Struct.struct_field_ext #(A.array_domain n) #(A.array_range t n) (struct_field_pcm (base_array_fd td n)) (A.array_elements_pcm td.pcm n) (fun _ -> ()) k
 
 (*
 #push-options "--split_queries --z3rlimit 16"
@@ -2298,7 +2154,7 @@ let has_struct_field1_intro
   (p': P.perm)
   (w': ref0_v (fields.fd_typedef field))
   ()
-: ST.STGhost unit opened
+: STGhost unit opened
     (HR.pts_to r p w `star` HR.pts_to r' p' w')
     (fun _ ->
       has_struct_field1 r field r'
@@ -2307,8 +2163,8 @@ let has_struct_field1_intro
       has_struct_field_gen fields w field w'
     )
     (fun _ -> True)
-= ST.noop ();
-  ST.rewrite
+= noop ();
+  rewrite
     (has_struct_field0 r field r')
     (has_struct_field1 r field r')
 
@@ -2321,29 +2177,29 @@ let has_array_cell_drop
   (#b': ref0_v td)
   (i: SZ.t)
   (r: ref td)
-: ST.STGhostT unit opened
+: STGhostT unit opened
     (has_array_cell1 a i r `star`
       HR.pts_to r p' b'
     )
     (fun _ -> has_array_cell1 a i r)
-= ST.rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
-  let _ = ST.gen_elim () in
-  let j = ST.vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
-  ST.rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
-  let _ = ST.gen_elim () in
-  let j' : base_array_index_t' (dfst a).ar_base_size = ST.vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
-  ST.rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
-  let _ = ST.gen_elim () in
+= rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
+  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  let _ = gen_elim () in
+  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let _ = gen_elim () in
   HR.gather p' r;
   has_struct_field1_intro
     #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
-  ST.rewrite
+  rewrite
     (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r)
     (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
-  ST.rewrite
+  rewrite
     (has_base_array_cell0 (dfst a).ar_base j r)
     (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
-  ST.rewrite
+  rewrite
     (has_array_cell0 a i r)
     (has_array_cell a i r)
 
@@ -2356,12 +2212,12 @@ let has_array_cell_elim
   (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
   (i: SZ.t)
   (r: ref td)
-: ST.STGhost (Ghost.erased (ref0_v td)) opened
+: STGhost (Ghost.erased (ref0_v td)) opened
     (has_array_cell1 a i r `star`
       HR.pts_to (dfst a).ar_base p b
     )
     (fun b' -> has_array_cell1 a i r `star`
-      ST.exists_ (fun p -> ST.exists_ (fun p' ->
+      exists_ (fun p -> exists_ (fun p' ->
         HR.pts_to (dfst a).ar_base p b `star`
         HR.pts_to r p' b'
     )))
@@ -2373,43 +2229,43 @@ let has_array_cell_elim
       b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
     )
 = 
-  ST.rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
-  let _ = ST.gen_elim () in
-  let j = ST.vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
-  ST.rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
-  let _ = ST.gen_elim () in
-  let j' : base_array_index_t' (dfst a).ar_base_size = ST.vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
-  ST.rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
-  let _ = ST.gen_elim () in
+  rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
+  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  let _ = gen_elim () in
+  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let _ = gen_elim () in
   hr_gather b (dfst a).ar_base;
   HR.share r;
   HR.share (dfst a).ar_base;
   has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
-  ST.rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
-  ST.rewrite
+  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+  rewrite
     (has_base_array_cell0 (dfst a).ar_base j r)
     (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
-  ST.rewrite
+  rewrite
     (has_array_cell0 a i r)
     (has_array_cell a i r);
   A.ref_of_array_eq (model_array_of_array a b) i;
   struct_field_eq_cell td (dfst a).ar_base_size j';
-  let b' = ST.vpattern_replace_erased (HR.pts_to r _) in
-  ST.noop ();
+  let b' = vpattern_replace_erased (HR.pts_to r _) in
+  noop ();
   b'
 
 let ghost_array_cell_focus
   #_ #_ #td #s a i r
-= ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let b = ST.vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+= rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
   let r' = has_array_cell_elim a i r in
-  let _ = ST.gen_elim () in
+  let _ = gen_elim () in
   let _ = A.g_focus_cell _ _ i () in
-  ST.rewrite (R.pts_to _ _) (R.pts_to r'.ref (Seq.index s (SZ.v i)));
-  ST.weaken (pts_to0 r (Seq.index s (SZ.v i))) (pts_to r (Seq.index s (SZ.v i))) (fun _ -> ());
-  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
-  ST.weaken (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td))) (fun _ -> ())
+  rewrite (R.pts_to _ _) (R.pts_to r'.ref (Seq.index s (SZ.v i)));
+  rewrite (pts_to0 r (Seq.index s (SZ.v i))) (pts_to r (Seq.index s (SZ.v i)));
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
+  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td)))
 
 let has_array_cell_intro
   (#opened: _)
@@ -2422,7 +2278,7 @@ let has_array_cell_intro
   (#b': ref0_v td)
   (i: SZ.t)
   (r: ref td)
-: ST.STGhost unit opened
+: STGhost unit opened
     (HR.pts_to (dfst a).ar_base p b `star`
       HR.pts_to r p' b'
     )
@@ -2439,22 +2295,22 @@ let has_array_cell_intro
   let j : base_array_index_t' (dfst a).ar_base_size = (dfst a).ar_offset `SZ.add` i in
   struct_field_eq_cell td (dfst a).ar_base_size j;
   has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r _ _ _ _ ();
-  ST.rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j r);
-  ST.rewrite
+  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j r);
+  rewrite
     (has_base_array_cell0 (dfst a).ar_base j r)
     (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
-  ST.rewrite
+  rewrite
     (has_array_cell0 a i r)
     (has_array_cell a i r)
 
 let ghost_array_cell
   #_ #_ #td #s a i
 = array_pts_to_length _ _;
-  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
-  let _ = ST.gen_elim () in
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
   HR.share _;
-  ST.weaken (array_pts_to0 a s) (array_pts_to a s) (fun _ -> ());
-  let b = ST.vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  rewrite (array_pts_to0 a s) (array_pts_to a s);
+  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
   let ar = model_array_of_array a b in
   let b' = {
     base = b.base;
@@ -2464,13 +2320,13 @@ let ghost_array_cell
   let ghr = GHR.alloc b' in
   GHR.reveal_pts_to ghr P.full_perm b';
   let hr = GHR.reveal_ref ghr in
-  ST.rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to hr P.full_perm b');
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to hr P.full_perm b');
   HR.pts_to_not_null hr;
   let r : (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
-  ST.vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
+  vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
   has_array_cell_intro a i r;
   let _ = ghost_array_cell_focus a i r in
-  ST.noop ();
+  noop ();
   r
 
 [@@ noextract_to "krml"]
@@ -2480,20 +2336,20 @@ let array_cell0
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: Steel (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
+: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
     (array_pts_to a s)
     (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-    (fun _ ->
+    (
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = array_pts_to_length _ _;
-  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
-  let _ = ST.gen_elim () in
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
   HR.share _;
-  ST.weaken (array_pts_to0 a s) (array_pts_to a s) (fun _ -> ());
+  rewrite (array_pts_to0 a s) (array_pts_to a s);
   let b = HR.read (dfst a).ar_base in
-  ST.vpattern_rewrite (HR.pts_to (dfst a).ar_base _) b;
+  vpattern_rewrite (HR.pts_to (dfst a).ar_base _) b;
   let ar = model_array_of_array a b in
   A.ref_of_array_eq ar i;
   let b' = {
@@ -2504,19 +2360,19 @@ let array_cell0
   let hr = HR.alloc b' in
   HR.pts_to_not_null hr;
   let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
-  ST.vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
+  vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
   has_array_cell_intro a i r;
   let _ = ghost_array_cell_focus a i r in
-  ST.noop ();
+  noop ();
   return r
 
 let array_ref_cell
   #_ #td #s a len i
 = let r0 : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd ((| a, len |) <: array td)) }) = array_cell0 _ _ in
   let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len }) = r0 in
-  ST.vpattern_rewrite (fun r -> pts_to r _) r;
-  ST.vpattern_rewrite (has_array_cell _ _) r;
-  ST.noop ();
+  vpattern_rewrite (fun r -> pts_to r _) r;
+  vpattern_rewrite (has_array_cell _ _) r;
+  noop ();
   return r
 
 let ar_unfocus_cell
@@ -2530,33 +2386,33 @@ let ar_unfocus_cell
   (r': R.ref base_t' p)
   (v: t)
   (sq: squash (SZ.v i < SZ.v r.len /\ SZ.v i < Seq.length s))
-: SteelGhost unit opened
+: STGhost unit opened
     (A.pts_to r s `star` R.pts_to r' v)
     (fun _ -> A.pts_to r (Seq.upd s (SZ.v i) v))
-    (fun _ -> 
+    (
       base_t' == base_t /\
       r' == R.ref_focus (A.ref_of_array r) (A.cell p r.len i) /\
       Seq.index s (SZ.v i) == one p
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = let r1' : R.ref base_t p = coerce_eq () r' in
-  ST.rewrite (R.pts_to r' v) (R.pts_to r1' v);
+  rewrite (R.pts_to r' v) (R.pts_to r1' v);
   A.unfocus_cell r s i r1' v ()
 
 let unarray_cell
   #_ #_ #td #s #v a i r
 = array_pts_to_length _ _;
-  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
-  let _ = ST.gen_elim () in
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
   let w = has_array_cell_elim a i r in
-  let _ = ST.gen_elim () in
-  ST.weaken (pts_to r v) (pts_to0 r v) (fun _ -> ());
-  let _ = ST.gen_elim () in
+  let _ = gen_elim () in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
   hr_gather (Ghost.reveal w) r;
   ar_unfocus_cell _ _ i _ _ ();
-  let b = ST.vpattern_replace (HR.pts_to (dfst a).ar_base _) in
-  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
-  ST.weaken (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v)) (fun _ -> ());
+  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
+  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v));
   has_array_cell_drop _ _ _
 
 #push-options "--split_queries --z3rlimit 16"
@@ -2586,22 +2442,22 @@ let ghost_array_split
   #_ #_ #td #s a i
 = array_pts_to_length _ _;
   let sq : squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)) = () in
-  ST.weaken (array_pts_to a s) (array_pts_to0 a s) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let br : Ghost.erased (ref0_v (base_array1 td (dfst a).ar_base_size)) = ST.vpattern_replace_erased (HR.pts_to _ _) in
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  let br : Ghost.erased (ref0_v (base_array1 td (dfst a).ar_base_size)) = vpattern_replace_erased (HR.pts_to _ _) in
   A.g_split _ _ i ();
   HR.share _;
-  let p = ST.vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
   let br_l : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_l a i)).ar_base_size)) = coerce_eq () br in
-  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_l a i)).ar_base p br_l);
-  ST.rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
-  ST.noop ();
-  ST.weaken (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (fun _ -> ());
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_l a i)).ar_base p br_l);
+  rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
+  noop ();
+  rewrite (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)));
   let br_r : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_r a i)).ar_base_size)) = coerce_eq () br in
-  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_r a i)).ar_base p br_r);
-  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
-  ST.noop ();
-  ST.weaken (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (fun _ -> ());
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_r a i)).ar_base p br_r);
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
+  noop ();
+  rewrite (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)));
   sq
 
 let t_array_split_r
@@ -2631,7 +2487,7 @@ let hr_gather_by_perm
   (#v2: t2)
   (p1: P.perm)
   (p2: P.perm)
-: ST.STGhost unit opened
+: STGhost unit opened
     (HR.pts_to r1 p1 v1 `star` HR.pts_to r2 p2 v2)
     (fun _ -> HR.pts_to r1 (p1 `P.sum_perm` p2) v1)
     (t1 == t2 /\
@@ -2640,7 +2496,7 @@ let hr_gather_by_perm
       t1 == t2 /\
       r1 == r2 /\
       v1 == v2)
-= ST.rewrite (HR.pts_to r2 p2 v2) (HR.pts_to r1 p2 (coerce_eq () v2));
+= rewrite (HR.pts_to r2 p2 v2) (HR.pts_to r1 p2 (coerce_eq () v2));
   HR.gather p2 r1
 
 let ar_join
@@ -2653,37 +2509,37 @@ let ar_join
   (al: A.array base_tl p)
   (ar: A.array base_tr p)
   (sl0 sr0: Seq.seq t)
-: SteelGhost unit opened
+: STGhost unit opened
     (A.pts_to al sl0 `star` A.pts_to ar sr0)
     (fun _ -> A.pts_to a (sl0 `Seq.append` sr0))
-    (fun _ ->
+    (
       SZ.v i <= SZ.v a.len /\
       base_t == base_tl /\
       base_t == base_tr /\
       al == A.split_l a i /\
       ar == A.split_r a i
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = let al' : A.array base_t p = coerce_eq () al in
   let ar' : A.array base_t p = coerce_eq () ar in
-  ST.rewrite (A.pts_to al sl0) (A.pts_to al' sl0);
-  ST.rewrite (A.pts_to ar sr0) (A.pts_to ar' sr0);
+  rewrite (A.pts_to al sl0) (A.pts_to al' sl0);
+  rewrite (A.pts_to ar sr0) (A.pts_to ar' sr0);
   A.join a i al' ar' _ _
 
 let array_join
   #_ #_ #td #sl #sr a al ar i
-= ST.weaken (array_pts_to al sl) (array_pts_to0 al sl) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let br_l : ref0_v (base_array1 td (dfst al).ar_base_size) = ST.vpattern_replace (HR.pts_to _ _) in
-  let pl = ST.vpattern_replace (fun p -> HR.pts_to _ p _) in
+= rewrite (array_pts_to al sl) (array_pts_to0 al sl);
+  let _ = gen_elim () in
+  let br_l : ref0_v (base_array1 td (dfst al).ar_base_size) = vpattern_replace (HR.pts_to _ _) in
+  let pl = vpattern_replace (fun p -> HR.pts_to _ p _) in
   let br : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () br_l in
-  ST.rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base pl br);
-  ST.weaken (array_pts_to ar sr) (array_pts_to0 ar sr) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let pr = ST.vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base pl br);
+  rewrite (array_pts_to ar sr) (array_pts_to0 ar sr);
+  let _ = gen_elim () in
+  let pr = vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
   hr_gather_by_perm pl pr;
   ar_join (model_array_of_array a br) i _ _ sl sr;
-  ST.weaken (array_pts_to0 a (sl `Seq.append` sr)) (array_pts_to a (sl `Seq.append` sr)) (fun _ -> ())
+  rewrite (array_pts_to0 a (sl `Seq.append` sr)) (array_pts_to a (sl `Seq.append` sr))
 
 let ar_share
   (#opened: _)
@@ -2702,30 +2558,30 @@ let ar_share
       op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
     ))
   ))
-: SteelGhost unit opened
+: STGhost unit opened
     (A.pts_to r s)
     (fun _ -> A.pts_to r s1 `star` A.pts_to r s2)
-    (fun _ ->
+    (
       Seq.length s1 == Seq.length s /\
       Seq.length s2 == Seq.length s
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = Classical.forall_intro (Classical.move_requires prf);
   A.share r s s1 s2
 
 let mk_fraction_seq_split_gen
   #_ #_ #td r v p p1 p2
-= ST.weaken (array_pts_to r (mk_fraction_seq td v p)) (array_pts_to0 r (mk_fraction_seq td v p)) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let br = ST.vpattern_replace (HR.pts_to _ _) in
-  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p));
+= rewrite (array_pts_to r (mk_fraction_seq td v p)) (array_pts_to0 r (mk_fraction_seq td v p));
+  let _ = gen_elim () in
+  let br = vpattern_replace (HR.pts_to _ _) in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p));
   ar_share _ _ (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
     td.mk_fraction_split (Seq.index v i) p1 p2;
     td.mk_fraction_join (Seq.index v i) p1 p2
   );
   HR.share _;
-  ST.weaken (array_pts_to0 r (mk_fraction_seq td v p1)) (array_pts_to r (mk_fraction_seq td v p1)) (fun _ -> ());
-  ST.weaken (array_pts_to0 r (mk_fraction_seq td v p2)) (array_pts_to r (mk_fraction_seq td v p2)) (fun _ -> ())
+  rewrite (array_pts_to0 r (mk_fraction_seq td v p1)) (array_pts_to r (mk_fraction_seq td v p1));
+  rewrite (array_pts_to0 r (mk_fraction_seq td v p2)) (array_pts_to r (mk_fraction_seq td v p2))
 
 let ar_gather
   (#opened: _)
@@ -2747,28 +2603,28 @@ let ar_gather
       op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
     ))
   ))
-: SteelGhost unit opened
+: STGhost unit opened
     (A.pts_to r s1 `star` A.pts_to r s2)
     (fun _ -> A.pts_to r s)
-    (fun _ ->
+    (
       Seq.length s1 == Seq.length s /\
       Seq.length s2 == Seq.length s
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = Classical.forall_intro (Classical.move_requires prf);
   A.gather r s s1 s2
 
 let mk_fraction_seq_join
   #_ #_ #td r v p1 p2
-= ST.weaken (array_pts_to r (mk_fraction_seq td v p1)) (array_pts_to0 r (mk_fraction_seq td v p1)) (fun _ -> ());
-  let _ = ST.gen_elim () in
-  let br = ST.vpattern_replace (HR.pts_to _ _) in
-  ST.rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
-  ST.weaken (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2)) (fun _ -> ());
-  let _ = ST.gen_elim () in
+= rewrite (array_pts_to r (mk_fraction_seq td v p1)) (array_pts_to0 r (mk_fraction_seq td v p1));
+  let _ = gen_elim () in
+  let br = vpattern_replace (HR.pts_to _ _) in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
+  rewrite (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2));
+  let _ = gen_elim () in
   hr_gather br (dfst r).ar_base;
-  ST.rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
+  rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
   ar_gather _ (mk_fraction_seq td v (p1 `P.sum_perm` p2)) (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
     td.mk_fraction_join (Seq.index v i) p1 p2
   );
-  ST.weaken (array_pts_to0 r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (fun _ -> ())
+  rewrite (array_pts_to0 r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
diff --git a/ulib/experimental/Steel.C.Types.fsti b/ulib/experimental/Steel.ST.C.Types.fsti
similarity index 86%
rename from ulib/experimental/Steel.C.Types.fsti
rename to ulib/experimental/Steel.ST.C.Types.fsti
index 0464116bf39..2844cd9a2dd 100644
--- a/ulib/experimental/Steel.C.Types.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.fsti
@@ -1,9 +1,7 @@
-module Steel.C.Types
+module Steel.ST.C.Types
 open Steel.C.Typenat
 open Steel.C.Typestring
-include Steel.Effect.Common
-include Steel.Effect
-include Steel.Effect.Atomic
+open Steel.ST.Util
 
 module P = Steel.FractionalPermission
 
@@ -87,28 +85,14 @@ val null (#t: Type) (td: typedef t) : Tot (ptr td)
 inline_for_extraction [@@noextract_to "krml"]
 let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
 
-val _pts_to (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t) : Steel.Memory.slprop u#1
-let trivial_selector (hp: Steel.Memory.slprop u#1) : selector unit hp = fun _ -> ()
-[@@__steel_reduce__]
-let pts_to (#t: Type) (#td: typedef t) (r: ref td) ([@@@ smt_fallback ] v: Ghost.erased t) : vprop = VUnit ({
-  hp = _pts_to r v;
-  t = _;
-  sel = trivial_selector _;
-})
+val pts_to (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t) : vprop
 
-let pts_to_or_null' 
+let pts_to_or_null
   (#t: Type) (#td: typedef t) (p: ptr td) (v: Ghost.erased t) : vprop
 = if FStar.StrongExcludedMiddle.strong_excluded_middle (p == null _)
   then emp
   else pts_to p v
 
-[@@__steel_reduce__]
-let pts_to_or_null (#t: Type) (#td: typedef t) (p: ptr td) ([@@@ smt_fallback ] v: Ghost.erased t) : vprop = VUnit ({
-  hp = hp_of (pts_to_or_null' p v);
-  t = _;
-  sel = trivial_selector _;
-})
-
 [@@noextract_to "krml"] // primitive
 val is_null
   (#t: Type)
@@ -116,11 +100,11 @@ val is_null
   (#td: typedef t)
   (#v: Ghost.erased t)
   (p: ptr td)
-: SteelAtomicBase bool false opened Unobservable
+: STAtomicBase bool false opened Unobservable
     (pts_to_or_null p v)
     (fun _ -> pts_to_or_null p v)
-    (fun _ -> True)
-    (fun _ res _ -> res == true <==> p == null _)
+    (True)
+    (fun res -> res == true <==> p == null _)
 
 let assert_null
   (#t: Type)
@@ -128,12 +112,12 @@ let assert_null
   (#td: typedef t)
   (#v: Ghost.erased t)
   (p: ptr td)
-: SteelGhost unit opened
+: STGhost unit opened
     (pts_to_or_null p v)
     (fun _ -> emp)
-    (fun _ -> p == null _)
-    (fun _ _ _ -> True)
-= rewrite_slprop (pts_to_or_null p v) emp (fun _ -> ())
+    (p == null _)
+    (fun _ -> True)
+= rewrite (pts_to_or_null p v) emp
 
 let assert_not_null
   (#t: Type)
@@ -141,12 +125,12 @@ let assert_not_null
   (#td: typedef t)
   (#v: Ghost.erased t)
   (p: ptr td)
-: SteelGhost (squash (~ (p == null _))) opened
+: STGhost (squash (~ (p == null _))) opened
     (pts_to_or_null p v)
     (fun _ -> pts_to p v)
-    (fun _ -> ~ (p == null _))
-    (fun _ _ _ -> True)
-= change_equal_slprop (pts_to_or_null p v) (pts_to p v)
+    (~ (p == null _))
+    (fun _ -> True)
+= rewrite (pts_to_or_null p v) (pts_to p v)
 
 val ref_equiv
   (#t: Type)
@@ -160,7 +144,7 @@ val pts_to_equiv
   (#td: typedef t)
   (r1 r2: ref td)
   (v: Ghost.erased t)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2 `star` pts_to r1 v)
     (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
 
@@ -175,7 +159,7 @@ val freeable_dup
   (#t: Type)
   (#td: typedef t)
   (r: ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (freeable r)
     (fun _ -> freeable r `star` freeable r)
 
@@ -184,11 +168,11 @@ val freeable_equiv
   (#t: Type)
   (#td: typedef t)
   (r1 r2: ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2 `star` freeable r1)
     (fun _ -> ref_equiv r1 r2 `star` freeable r2)
 
-let freeable_or_null'
+let freeable_or_null
   (#t: Type)
   (#td: typedef t)
   (r: ptr td)
@@ -197,13 +181,6 @@ let freeable_or_null'
   then emp
   else freeable r
 
-[@@__steel_reduce__]
-let freeable_or_null (#t: Type) (#td: typedef t) (p: ptr td) : vprop = VUnit ({
-  hp = hp_of (freeable_or_null' p);
-  t = _;
-  sel = trivial_selector _;
-})
-
 (*
 let freeable_or_null_dup
   (#opened: _)
@@ -222,7 +199,7 @@ let freeable_or_null_dup
 val alloc
   (#t: Type)
   (td: typedef t)
-: SteelT (ptr td)
+: STT (ptr td)
     emp
     (fun p -> pts_to_or_null p (uninitialized td) `star` freeable_or_null p)
 
@@ -232,37 +209,37 @@ val free
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: Steel unit
+: ST unit
     (pts_to r v `star` freeable r)
     (fun _ -> emp)
-    (fun _ ->
+    (
       full td v
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 
 val mk_fraction_split_gen
   (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm) : SteelGhost unit opened
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm) : STGhost unit opened
   (pts_to r (mk_fraction td v p))
   (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (fun _ -> p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
-  (fun _ _ _ -> True)
+  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ -> True)
 
 let mk_fraction_split
   (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p1 p2: P.perm) : SteelGhost unit opened
+  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p1 p2: P.perm) : STGhost unit opened
   (pts_to r v)
   (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (fun _ -> P.full_perm == p1 `P.sum_perm` p2)
-  (fun _ _ _ -> True)
+  (P.full_perm == p1 `P.sum_perm` p2)
+  (fun _ -> True)
 = mk_fraction_full td v;
-  change_equal_slprop (pts_to _ _) (pts_to _ _);
+  rewrite (pts_to _ _) (pts_to _ _);
   mk_fraction_split_gen r v P.full_perm p1 p2
 
 val mk_fraction_join
   (#opened: _)
   (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p1 p2: P.perm)
-: SteelGhostT unit opened
+: STGhostT unit opened
   (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
   (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
 
@@ -301,18 +278,18 @@ val scalar_unique
   (v1 v2: t)
   (p1 p2: P.perm)
   (r: ref (scalar t))
-: SteelGhost unit opened
+: STGhost unit opened
     (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
     (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
-    (fun _ -> True)
-    (fun _ _ _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+    (True)
+    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
 
 [@@noextract_to "krml"] // primitive
-val read0 (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : Steel t
+val read0 (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : ST t
   (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
   (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-  (fun _ -> True)
-  (fun _ v' _ -> v' == Ghost.reveal v)
+  (True)
+  (fun v' -> v' == Ghost.reveal v)
 
 let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
   (mk_scalar v == mk_fraction (scalar t) (mk_scalar v) P.full_perm)
@@ -320,11 +297,11 @@ let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
 = ()
 
 inline_for_extraction [@@noextract_to "krml"]
-let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : Steel t
+let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : ST t
   (pts_to r v)
   (fun _ -> pts_to r v)
-  (fun _ -> exists v0 p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p)
-  (fun _ v1 _ -> forall v0 p . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p ==> v0 == v1)
+  (exists v0 p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p)
+  (fun v1 -> forall v0 p . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p ==> v0 == v1)
 = let v0 = FStar.IndefiniteDescription.indefinite_description_tot _ (fun v0 -> exists p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p) in
   let p = FStar.IndefiniteDescription.indefinite_description_tot _ (fun p -> Ghost.reveal v == mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p) in
   let prf v0' p' : Lemma
@@ -337,17 +314,17 @@ let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : Steel
   = Classical.move_requires (prf v0') p'
   in
   Classical.forall_intro_2 prf';
-  change_equal_slprop (pts_to _ _) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p));
+  rewrite (pts_to _ _) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p));
   let v1 = read0 r in
-  change_equal_slprop (pts_to _ _) (pts_to r v);
+  rewrite (pts_to _ _) (pts_to r v);
   return v1
 
 [@@noextract_to "krml"] // primitive
-val write (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : Steel unit
+val write (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : ST unit
   (pts_to r v)
   (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
-  (fun _ -> full (scalar t) v)
-  (fun _ _ _ -> True)
+  (full (scalar t) v)
+  (fun _ -> True)
 
 // To be extracted as: struct t { fields ... }
 [@@noextract_to "krml"] // primitive
@@ -511,7 +488,7 @@ val has_struct_field_dup
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_struct_field r field r')
     (fun _ -> has_struct_field r field r' `star` has_struct_field r field r')
 
@@ -524,7 +501,7 @@ val has_struct_field_inj
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
   (r1 r2: ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_struct_field r field r1 `star` has_struct_field r field r2)
     (fun _ -> has_struct_field r field r1 `star` has_struct_field r field r2 `star` ref_equiv r1 r2)
 
@@ -538,7 +515,7 @@ val has_struct_field_equiv_from
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
   (r2: ref (struct0 tn n fields))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1 r2 `star` has_struct_field r1 field r')
     (fun _ -> ref_equiv r1 r2 `star` has_struct_field r2 field r')
 
@@ -552,7 +529,7 @@ val has_struct_field_equiv_to
   (field: field_t fields)
   (r1': ref (fields.fd_typedef field))
   (r2': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (ref_equiv r1' r2' `star` has_struct_field r field r1')
     (fun _ -> ref_equiv r1' r2' `star` has_struct_field r field r2')
 
@@ -566,7 +543,7 @@ val ghost_struct_field_focus
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_struct_field r field r' `star` pts_to r v)
     (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
 
@@ -579,7 +556,7 @@ val ghost_struct_field
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: SteelGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
 
@@ -597,11 +574,9 @@ val struct_field0
     t' ==  fields.fd_type field /\
     td' == fields.fd_typedef field
   })
-: Steel (ref td')
+: STT (ref td')
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
-    (fun _ -> True)
-    (fun _ _ _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let struct_field
@@ -612,11 +587,9 @@ let struct_field
   (#v: Ghost.erased (struct_t0 tn n fields))
   (r: ref (struct0 tn n fields))
   (field: field_t fields)
-: Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
+: STT (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field) `star` has_struct_field r field r')
-    (fun _ -> True)
-    (fun _ _ _ -> True)
 = struct_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -634,13 +607,13 @@ val unstruct_field
   (field: field_t fields)
   (#v': Ghost.erased (fields.fd_type field))
   (r': ref (fields.fd_typedef field))
-: SteelGhost unit opened
+: STGhost unit opened
     (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
     (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field v' v))
-    (fun _ ->
+    (
       struct_get_field v field == unknown (fields.fd_typedef field)
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 
 val fractionable_struct
   (#tn: Type0)
@@ -884,7 +857,7 @@ val has_union_field_dup
   (r: ref (union0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_union_field r field r')
     (fun _ -> has_union_field r field r' `star` has_union_field r field r')
 
@@ -897,7 +870,7 @@ val has_union_field_inj
   (r: ref (union0 tn n fields))
   (field: field_t fields)
   (r1 r2: ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_union_field r field r1 `star` has_union_field r field r2)
     (fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 r2)
 
@@ -910,7 +883,7 @@ val has_union_field_equiv_from
   (r1 r2: ref (union0 tn n fields))
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_union_field r1 field r' `star` ref_equiv r1 r2)
     (fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
 
@@ -923,7 +896,7 @@ val has_union_field_equiv_to
   (r: ref (union0 tn n fields))
   (field: field_t fields)
   (r1 r2: ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_union_field r field r1 `star` ref_equiv r1 r2)
     (fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
 
@@ -937,7 +910,7 @@ val ghost_union_field_focus
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
   (r': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_union_field r field r' `star` pts_to r v)
     (fun _ -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
 
@@ -950,7 +923,7 @@ val ghost_union_field
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: SteelGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
 
@@ -968,11 +941,9 @@ val union_field0
     t' ==  fields.fd_type field /\
     td' == fields.fd_typedef field
   })
-: Steel (ref td')
+: STT (ref td')
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let union_field
@@ -983,11 +954,9 @@ let union_field
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields {union_get_case v == Some field})
-: Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
+: STT (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
-    (fun _ -> True)
-    (fun _ r' _ -> True) 
 = union_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -1004,7 +973,7 @@ val ununion_field
   (field: field_t fields)
   (#v': Ghost.erased (fields.fd_type field))
   (r': ref (fields.fd_typedef field))
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_union_field r field r' `star` pts_to r' v')
     (fun _ -> has_union_field r field r' `star` pts_to r (union_set_field tn n fields field v'))
 
@@ -1024,11 +993,11 @@ val union_switch_field0
     t' ==  fields.fd_type field /\
     td' == fields.fd_typedef field
   })
-: Steel (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
-    (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> True)
+    (full (union0 tn n fields) v)
+    (fun r' -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
 let union_switch_field
@@ -1039,11 +1008,11 @@ let union_switch_field
   (#v: Ghost.erased (union_t0 tn n fields))
   (r: ref (union0 tn n fields))
   (field: field_t fields)
-: Steel (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+: ST (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) // need to write the pcm carrier value, so this cannot be Ghost or Atomic
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
-    (fun _ -> full (union0 tn n fields) v)
-    (fun _ r' _ -> True)
+    (full (union0 tn n fields) v)
+    (fun r' -> True)
 = union_switch_field0
     (norm norm_field_steps (fields.fd_type field))
     r
@@ -1138,11 +1107,11 @@ val has_base_array_cell_post
   (r: ref (base_array0 tn td n))
   (i: SZ.t)
   (r': ref td)
-: SteelGhost unit opened
+: STGhost unit opened
     (has_base_array_cell r i r')
     (fun _ -> has_base_array_cell r i r')
-    (fun _ -> True)
-    (fun _ _ _ -> SZ.v i < SZ.v n)
+    (True)
+    (fun _ -> SZ.v i < SZ.v n)
 
 val has_base_array_cell_dup
   (#opened: _)
@@ -1153,7 +1122,7 @@ val has_base_array_cell_dup
   (r: ref (base_array0 tn td n))
   (i: SZ.t)
   (r': ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell r i r')
     (fun _ -> has_base_array_cell r i r' `star` has_base_array_cell r i r')
 
@@ -1166,7 +1135,7 @@ val has_base_array_cell_inj
   (r: ref (base_array0 tn td n))
   (i: SZ.t)
   (r1 r2: ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell r i r1 `star` has_base_array_cell r i r2)
     (fun _ -> has_base_array_cell r i r1 `star` has_base_array_cell r i r2 `star` ref_equiv r1 r2)
 
@@ -1179,7 +1148,7 @@ val has_base_array_cell_equiv_from
   (r1 r2: ref (base_array0 tn td n))
   (i: SZ.t)
   (r': ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell r1 i r' `star` ref_equiv r1 r2)
     (fun _ -> has_base_array_cell r2 i r' `star` ref_equiv r1 r2)
 
@@ -1192,7 +1161,7 @@ val has_base_array_cell_equiv_to
   (r: ref (base_array0 tn td n))
   (i: SZ.t)
   (r1 r2: ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (has_base_array_cell r i r1 `star` ref_equiv r1 r2)
     (fun _ -> has_base_array_cell r i r2 `star` ref_equiv r1 r2)
 
@@ -1236,25 +1205,12 @@ let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
 inline_for_extraction [@@noextract_to "krml"]
 let array (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ref td & array_len_t r)
 
-val array_pts_to'
-  (#t: Type)
-  (#td: typedef t)
-  (r: array td)
-  (v: Ghost.erased (Seq.seq t))
-: Tot vprop
-
-[@@__steel_reduce__]
-let array_pts_to
+val array_pts_to
   (#t: Type)
   (#td: typedef t)
   (r: array td)
   (v: Ghost.erased (Seq.seq t))
 : Tot vprop
-= VUnit ({
-    hp = hp_of (array_pts_to' r v);
-    t = _;
-    sel = trivial_selector _;
-  })
 
 val array_pts_to_length
   (#opened: _)
@@ -1262,11 +1218,11 @@ val array_pts_to_length
   (#td: typedef t)
   (r: array td)
   (v: Ghost.erased (Seq.seq t))
-: SteelGhost unit opened
+: STGhost unit opened
     (array_pts_to r v)
     (fun _ -> array_pts_to r v)
-    (fun _ -> True)
-    (fun _ _ _ -> Seq.length v == SZ.v (dsnd r))
+    (True)
+    (fun _ -> Seq.length v == SZ.v (dsnd r))
 
 #set-options "--print_implicits"
 
@@ -1318,11 +1274,11 @@ val ghost_array_of_base_focus
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
   (a: array td)
-: SteelGhost unit opened
+: STGhost unit opened
     (pts_to r v)
     (fun _ -> array_pts_to a (seq_of_base_array v))
-    (fun _ -> has_array_of_base r a)
-    (fun _ _ _ -> True)
+    (has_array_of_base r a)
+    (fun _ -> True)
 
 val ghost_array_of_base
   (#t: Type)
@@ -1332,10 +1288,27 @@ val ghost_array_of_base
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
-: SteelGhostT (a: Ghost.erased (array td) { has_array_of_base r a }) opened
+: STGhostT (a: Ghost.erased (array td) { has_array_of_base r a }) opened
     (pts_to r v)
     (fun a -> array_pts_to a (seq_of_base_array v))
 
+let array_ref_of_base_post
+  (#t: Type)
+  (#tn: Type0)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+  (a: array_ref td)
+  (ar: array td)
+: GTot prop
+=
+       dfst ar == a /\
+        array_ref_base_size a == Ghost.reveal n /\
+        array_ref_offset a == 0sz /\
+        has_array_of_base r ar /\
+        Ghost.reveal (dsnd ar) == Ghost.reveal n
+ 
 // to be extracted to just r
 [@@noextract_to "krml"] // primitive
 val array_ref_of_base
@@ -1346,18 +1319,14 @@ val array_ref_of_base
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
-: SteelAtomicBase (array_ref td) false opened Unobservable
+: STAtomicBase (array_ref td) false opened Unobservable
     (pts_to r v)
-    (fun a -> h_exists (fun (ar: array td) ->
+    (fun a -> exists_ (fun (ar: array td) ->
       array_pts_to ar (seq_of_base_array v) `star` pure (
-        dfst ar == a /\
-        array_ref_base_size a == Ghost.reveal n /\
-        array_ref_offset a == 0sz /\
-        has_array_of_base r ar /\
-        Ghost.reveal (dsnd ar) == Ghost.reveal n
+      array_ref_of_base_post v r a ar
     )))
+    (True)
     (fun _ -> True)
-    (fun _ _ _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_of_base
@@ -1368,16 +1337,16 @@ let array_of_base
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t t tn n))
   (r: ref (base_array0 tn td n))
-: SteelAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
     (pts_to r v)
     (fun a -> array_pts_to a (seq_of_base_array v))
+    (True)
     (fun _ -> True)
-    (fun _ _ _ -> True)
 = let al = array_ref_of_base r in
-  let _ = witness_exists () in
+  let _ = elim_exists () in
   elim_pure _;
   let a = (| al, Ghost.hide (n <: SZ.t) |) in
-  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
   return a
 
 val unarray_of_base
@@ -1389,13 +1358,13 @@ val unarray_of_base
   (#v: Ghost.erased (Seq.seq t))
   (r: ref (base_array0 tn td n))
   (a: array td)
-: SteelGhost (Ghost.erased (base_array_t t tn n)) opened
+: STGhost (Ghost.erased (base_array_t t tn n)) opened
     (array_pts_to a v)
     (fun v' -> pts_to r v')
-    (fun _ ->
+    (
       has_array_of_base r a
     )
-    (fun _ v' _ -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
+    (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
 
 (*
 val has_array_of_ref
@@ -1411,28 +1380,28 @@ val has_array_of_ref_post
   (#td: typedef t)
   (r: ref td)
   (a: array td)
-: SteelGhost unit opened
+: STGhost unit opened
     (has_array_of_ref r a)
     (fun _ -> has_array_of_ref r a)
-    (fun _ -> True)
-    (fun _ _ _ ->
+    (True)
+    (fun _ ->
       let (| al, len |) = a in
       array_ref_base_size al == 1sz /\
       array_ref_offset al == 0sz /\
       Ghost.reveal len == 1sz
     )
 
-val has_array_of_ref_inj
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-  (a1 a2: array td)
-: Lemma
-    (requires (
-      has_array_of_ref r a1 /\
-      has_array_of_ref r a2
-    ))
-    (ensures a1 == a2)
+// val has_array_of_ref_inj
+//   (#t: Type)
+//   (#td: typedef t)
+//   (r: ref td)
+//   (a1 a2: array td)
+// : Lemma
+//     (requires (
+//       has_array_of_ref r a1 /\
+//       has_array_of_ref r a2
+//     ))
+//     (ensures a1 == a2)
 
 val ghost_array_of_ref_focus
   (#t: Type)
@@ -1441,7 +1410,7 @@ val ghost_array_of_ref_focus
   (#v: Ghost.erased t)
   (r: ref td)
   (a: array td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (pts_to r v `star` has_array_of_ref r a)
     (fun _ -> has_array_of_ref r a `star` array_pts_to a (Seq.create 1 (Ghost.reveal v)))
 
@@ -1451,7 +1420,7 @@ val ghost_array_of_ref
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: SteelGhostT (Ghost.erased (array td)) opened
+: STGhostT (Ghost.erased (array td)) opened
     (pts_to r v)
     (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
 
@@ -1462,11 +1431,9 @@ val array_ref_of_ref
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: Steel (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz })
+: STT (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz })
     (pts_to r v)
     (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r (| a, Ghost.hide 1sz |))
-    (fun _ -> True)
-    (fun _ _ _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_of_ref
@@ -1474,15 +1441,13 @@ let array_of_ref
   (#td: typedef t)
   (#v: Ghost.erased t)
   (r: ref td)
-: Steel (array td)
+: STT (array td)
     (pts_to r v)
     (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
-    (fun _ -> True)
-    (fun _ _ _ -> True)
 = let al = array_ref_of_ref r in
   let a : array td = (| al, Ghost.hide 1sz |) in
-  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
-  change_equal_slprop (has_array_of_ref _ _) (has_array_of_ref r a);
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
+  rewrite (has_array_of_ref _ _) (has_array_of_ref r a);
   return a
 
 val unarray_of_ref
@@ -1492,7 +1457,7 @@ val unarray_of_ref
   (#s: Ghost.erased (Seq.seq t))
   (r: ref td)
   (a: array td)
-: SteelGhostT (squash (Seq.length s == 1)) opened
+: STGhostT (squash (Seq.length s == 1)) opened
     (array_pts_to a s `star` has_array_of_ref r a)
     (fun _ -> pts_to r (Seq.index s 0) `star` has_array_of_ref r a)
 *)
@@ -1516,11 +1481,11 @@ val has_array_cell_post
   (a: array td)
   (i: SZ.t)
   (r': ref td)
-: SteelGhost unit opened
+: STGhost unit opened
     (has_array_cell a i r')
     (fun _ -> has_array_cell a i r')
-    (fun _ -> True)
-    (fun _ _ _ -> SZ.v i < SZ.v (dsnd a))
+    (True)
+    (fun _ -> SZ.v i < SZ.v (dsnd a))
 
 val has_array_cell_has_base_array_cell
   (#opened: _)
@@ -1531,11 +1496,11 @@ val has_array_cell_has_base_array_cell
   (r: ref td)
   (#ty: Type)
   (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
-: SteelGhost (Ghost.erased SZ.t) opened
+: STGhost (Ghost.erased SZ.t) opened
     (has_array_cell a i r)
     (fun j -> has_base_array_cell br j r)
-    (fun _ -> has_array_ref_base (dfst a) br)
-    (fun _ j _ ->
+    (has_array_ref_base (dfst a) br)
+    (fun j ->
       SZ.v j == SZ.v (array_ref_offset (dfst a)) + SZ.v i
     )
 
@@ -1548,14 +1513,14 @@ val has_base_array_cell_has_array_cell
   (r: ref td)
   (#ty: Type)
   (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
-: SteelGhost (Ghost.erased SZ.t) opened
+: STGhost (Ghost.erased SZ.t) opened
     (has_base_array_cell br i r)
     (fun j -> has_array_cell a j r)
-    (fun _ -> has_array_ref_base (dfst a) br /\
+    (has_array_ref_base (dfst a) br /\
       SZ.v i >= SZ.v (array_ref_offset (dfst a)) /\
       SZ.v i < SZ.v (array_ref_offset (dfst a)) + SZ.v (dsnd a)
     )
-    (fun _ j _ ->
+    (fun j ->
       SZ.v i == SZ.v (array_ref_offset (dfst a)) + SZ.v j
     )
 
@@ -1566,7 +1531,7 @@ val has_array_cell_inj
   (a: array td)
   (i: SZ.t)
   (r1 r2: ref td)
-: SteelGhostT unit opened
+: STGhostT unit opened
     (
       has_array_cell a i r1 `star`
       has_array_cell a i r2
@@ -1598,7 +1563,7 @@ val ghost_array_cell_focus
   (a: array td)
   (i: SZ.t)
   (r: ref td)
-: SteelGhostT (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
+: STGhostT (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
     (array_pts_to a s `star` has_array_cell a i r)
     (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
 
@@ -1609,13 +1574,13 @@ val ghost_array_cell
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: SteelGhost (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) opened
+: STGhost (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) opened
     (array_pts_to a s)
     (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-    (fun _ ->
+    (
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 
 [@@noextract_to "krml"] // primitive
 val array_ref_cell
@@ -1625,13 +1590,13 @@ val array_ref_cell
   (a: array_ref td)
   (len: array_len_t a)
   (i: SZ.t)
-: Steel (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len })
+: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len })
     (array_pts_to (| a, len |) s)
     (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell (| a, len |) i r)
-    (fun _ ->
+    (
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v len)
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_cell
@@ -1640,18 +1605,18 @@ let array_cell
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: Steel (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
+: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
     (array_pts_to a s)
     (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-    (fun _ ->
+    (
       (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 = let (| al, len |) = a in
-  change_equal_slprop (array_pts_to _ _) (array_pts_to _ s);
+  rewrite (array_pts_to _ _) (array_pts_to _ s);
   let r = array_ref_cell al len i in
-  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
-  change_equal_slprop (has_array_cell _ _ _) (has_array_cell a i r);
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
+  rewrite (has_array_cell _ _ _) (has_array_cell a i r);
   return r
 
 val unarray_cell
@@ -1663,13 +1628,13 @@ val unarray_cell
   (a: array td)
   (i: SZ.t)
   (r: ref td)
-: SteelGhost (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
+: STGhost (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
     (array_pts_to a s `star` pts_to r v `star` has_array_cell a i r)
     (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) v) `star` has_array_cell a i r)
-    (fun _ ->
+    (
       (SZ.v i < Seq.length s ==> Seq.index s (SZ.v i) == unknown td)
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 
 val array_ref_shift
   (#t: Type)
@@ -1714,12 +1679,12 @@ val ghost_array_split
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: SteelGhost (squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a))) opened
+: STGhost (squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a))) opened
     (array_pts_to a s)
     (fun _ -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
       array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)))
-    (fun _ -> SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
-    (fun _ _ _ -> True)
+    (SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
+    (fun _ -> True)
 
 [@@noextract_to "krml"] // primitive
 val array_ref_split
@@ -1729,12 +1694,12 @@ val array_ref_split
   (al: array_ref td)
   (len: array_len_t al)
   (i: SZ.t)
-: Steel (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len})
+: ST (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len})
     (array_pts_to (| al, len |) s)
     (fun _ -> array_pts_to (array_split_l (| al, len |) i) (Seq.slice s 0 (SZ.v i)) `star`
       array_pts_to (array_split_r (| al, len |) i) (Seq.slice s (SZ.v i) (Seq.length s)))
-    (fun _ -> SZ.v i <= SZ.v len \/ SZ.v i <= Seq.length s)
-    (fun _ ar _ -> ar == dfst (array_split_r (| al, len |) i))
+    (SZ.v i <= SZ.v len \/ SZ.v i <= Seq.length s)
+    (fun ar -> ar == dfst (array_split_r (| al, len |) i))
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_split
@@ -1743,18 +1708,18 @@ let array_split
   (#s: Ghost.erased (Seq.seq t))
   (a: array td)
   (i: SZ.t)
-: Steel (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)})
+: ST (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)})
     (array_pts_to a s)
     (fun a' -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
       array_pts_to a' (Seq.slice s (SZ.v i) (Seq.length s)))
-    (fun _ -> SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
-    (fun _ a' _ -> a' == array_split_r a i)
+    (SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
+    (fun a' -> a' == array_split_r a i)
 = let (| al, len |) = a in
-  change_equal_slprop (array_pts_to _ _) (array_pts_to _ s);
+  rewrite (array_pts_to _ _) (array_pts_to _ s);
   let ar = array_ref_split al len i in
   let a' = (| ar, Ghost.hide (len `SZ.sub` i) |) in
-  change_equal_slprop (array_pts_to (array_split_l _ _) _) (array_pts_to (array_split_l a _) _);
-  change_equal_slprop (array_pts_to (array_split_r _ _) _) (array_pts_to a' _);
+  rewrite (array_pts_to (array_split_l _ _) _) (array_pts_to (array_split_l a _) _);
+  rewrite (array_pts_to (array_split_r _ _) _) (array_pts_to a' _);
   return a'
 
 val array_join
@@ -1764,15 +1729,15 @@ val array_join
   (#sl #sr: Ghost.erased (Seq.seq t))
   (a al ar: array td)
   (i: SZ.t)
-: SteelGhost unit opened
+: STGhost unit opened
     (array_pts_to al sl `star` array_pts_to ar sr)
     (fun _ -> array_pts_to a (sl `Seq.append` sr))
-    (fun _ ->
+    (
       SZ.v i <= SZ.v (dsnd a) /\
       al == array_split_l a i /\
       ar == array_split_r a i
     )
-    (fun _ _ _ -> True)
+    (fun _ -> True)
 
 let fractionable_seq (#t: Type) (td: typedef t) (s: Seq.seq t) : GTot prop =
   forall (i: nat). i < Seq.length s ==> fractionable td (Seq.index s i)
@@ -1790,26 +1755,28 @@ let mk_fraction_seq_full (#t: Type0) (td: typedef t) (x: Seq.seq t) : Lemma
 
 val mk_fraction_seq_split_gen
   (#opened: _)
-  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p p1 p2: P.perm) : SteelGhost unit opened
+  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p p1 p2: P.perm)
+: STGhost unit opened
   (array_pts_to r (mk_fraction_seq td v p))
   (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
-  (fun _ -> p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
-  (fun _ _ _ -> True)
+  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ -> True)
 
 let mk_fraction_seq_split
   (#opened: _)
-  (#t: Type) (#td: typedef t) (r: array td) (v: Ghost.erased (Seq.seq t) { fractionable_seq td v }) (p1 p2: P.perm) : SteelGhost unit opened
+  (#t: Type) (#td: typedef t) (r: array td) (v: Ghost.erased (Seq.seq t) { fractionable_seq td v }) (p1 p2: P.perm)
+: STGhost unit opened
   (array_pts_to r v)
   (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
-  (fun _ -> P.full_perm == p1 `P.sum_perm` p2)
-  (fun _ _ _ -> True)
+  (P.full_perm == p1 `P.sum_perm` p2)
+  (fun _ -> True)
 = mk_fraction_seq_full td v;
-  change_equal_slprop (array_pts_to _ _) (array_pts_to _ _);
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
   mk_fraction_seq_split_gen r v P.full_perm p1 p2
 
 val mk_fraction_seq_join
   (#opened: _)
   (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p1 p2: P.perm)
-: SteelGhostT unit opened
+: STGhostT unit opened
   (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
   (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))

From b9dc48d50c28f0e5bafdb75274fa5178ba0d3c43 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 17:38:46 -0800
Subject: [PATCH 422/513] enable smt_fallback

---
 ulib/experimental/Steel.ST.C.Types.fsti | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.fsti b/ulib/experimental/Steel.ST.C.Types.fsti
index 2844cd9a2dd..13409712482 100644
--- a/ulib/experimental/Steel.ST.C.Types.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.fsti
@@ -85,7 +85,7 @@ val null (#t: Type) (td: typedef t) : Tot (ptr td)
 inline_for_extraction [@@noextract_to "krml"]
 let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
 
-val pts_to (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t) : vprop
+val pts_to (#t: Type) (#td: typedef t) (r: ref td) ([@@@smt_fallback] v: Ghost.erased t) : vprop
 
 let pts_to_or_null
   (#t: Type) (#td: typedef t) (p: ptr td) (v: Ghost.erased t) : vprop

From 75bd0b7a3fb3ade0a1884d09c78a2cb59eff7301 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 17:38:59 -0800
Subject: [PATCH 423/513] start removing legacy StructLiteral

---
 ulib/experimental/Steel.C.StructLiteral.fst  | 376 -------------------
 ulib/experimental/Steel.C.StructLiteral.fsti |  18 +-
 2 files changed, 9 insertions(+), 385 deletions(-)
 delete mode 100644 ulib/experimental/Steel.C.StructLiteral.fst

diff --git a/ulib/experimental/Steel.C.StructLiteral.fst b/ulib/experimental/Steel.C.StructLiteral.fst
deleted file mode 100644
index 48a3c91d794..00000000000
--- a/ulib/experimental/Steel.C.StructLiteral.fst
+++ /dev/null
@@ -1,376 +0,0 @@
-module Steel.C.StructLiteral
-
-open Steel.Memory
-open Steel.Effect
-open Steel.Effect.Common
-open Steel.Effect.Atomic
-
-open Steel.C.Model.PCM
-open Steel.C.Model.Struct
-open Steel.C.Typedef
-open Steel.C.Model.Ref
-open Steel.C.Model.Connection
-open Steel.C.Opt
-open Steel.C.Fields
-
-open FStar.List.Tot
-open FStar.FunctionalExtensionality
-
-let mk_struct_def (tag: Type0) (field_descriptions: Type0): Type0 = unit
-
-let field_of' (fields: c_fields) = field:string{fields.has_field field == true}
-
-let struct_dom (fields: c_fields) (excluded: excluded_fields) =
-  refine (field_of' fields) (notin excluded)
-
-let struct_cod (fields: c_fields) (excluded: excluded_fields) (field: struct_dom fields excluded) =
-  (fields.get_field field).view_type
-
-let struct' tag fields excluded =
-  restricted_t (struct_dom fields excluded) (struct_cod fields excluded)
-
-let mk_nil tag = on_dom _ (fun _ -> ())
-
-let mk_cons tag fields field td x v =
-  on_dom (struct_dom (fields_cons field td fields) emptyset) (fun field' ->
-    if field = field' then x
-    else v field' <: ((fields_cons field td fields).get_field field').view_type)
-
-let struct_pcm_carrier_cod (fields: c_fields) (field: field_of' fields) =
-  (fields.get_field field).carrier
-
-let struct_pcms (fields: c_fields) (field: field_of' fields)
-: pcm (struct_pcm_carrier_cod fields field)
-= (fields.get_field field).pcm
-
-let struct_pcm_carrier tag fields =
-  restricted_t (field_of' fields) (struct_pcm_carrier_cod fields)
-
-let struct_pcm tag fields = prod_pcm (struct_pcms fields)
-
-let struct_get x field = x field
-let struct_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
-      
-let struct_get_put x field v = ()
-
-let struct_put_get x field =
-  assert (struct_put x field (x `struct_get` field) `feq` x)
-
-let struct_put_put x field v w =
-  assert (struct_put (struct_put x field v) field w `feq` struct_put x field w)
-
-let struct_get_put_ne x field1 field2 v = ()
-
-let struct_put_put_ne x field1 v field2 w = 
-  assert (
-    struct_put (struct_put x field1 v) field2 w `feq`
-    struct_put (struct_put x field2 w) field1 v)
-
-let struct_pcm_get x field = x field
-let struct_pcm_put x field v = on_dom _ (fun field' -> if field = field' then v else x field')
-
-let struct_pcm_get_put x field v = ()
-
-let struct_pcm_put_get x field =
-  assert (struct_pcm_put x field (x `struct_pcm_get` field) `feq` x)
-
-let struct_pcm_put_put x field v w =
-  assert (struct_pcm_put (struct_pcm_put x field v) field w `feq` struct_pcm_put x field w)
-
-let struct_pcm_get_put_ne x field1 field2 v = ()
-
-let struct_pcm_put_put_ne x field1 v field2 w =
-   assert (
-     struct_pcm_put (struct_pcm_put x field1 v) field2 w `feq`
-     struct_pcm_put (struct_pcm_put x field2 w) field1 v)
-
-let struct_view_to_view_prop (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-: struct_pcm_carrier tag fields -> prop
-= fun x -> forall (field: struct_dom fields excluded).
-  (fields.get_field field).view.to_view_prop (x field) /\
-  (fields.has_field field == false ==> x field =!= one (fields.get_field field).pcm)
-
-let struct_view_to_view (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-: refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded) -> 
-  struct' tag fields excluded
-= fun x -> on_dom (struct_dom fields excluded) (fun field -> (fields.get_field field).view.to_view (x field))
-
-let struct_view_to_carrier (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-: struct' tag fields excluded ->
-  refine (struct_pcm_carrier tag fields) (struct_view_to_view_prop tag fields excluded)
-= fun x ->
-  let y: struct_pcm_carrier tag fields =
-    on_dom (field_of' fields) (fun field ->
-      if excluded field then one (fields.get_field field).pcm else
-      if field = "" then Some () else
-      (fields.get_field field).view.to_carrier (x field)
-      <: (fields.get_field field).carrier)
-  in y
-
-module S = FStar.String
-
-(*
-let rec max_len (excluded: list string)
-: Ghost nat True (fun n -> forall s'. memP s' excluded ==> n >= S.strlen s')
-= match excluded with
-  | [] -> 0
-  | field :: excluded -> 
-    let ih = max_len excluded in
-    if S.strlen field > ih then S.strlen field else ih
-    
-let arbitrary_unexcluded_witness (excluded: list string)
-: Ghost string True (fun s -> forall s'. memP s' excluded ==> S.strlen s > S.strlen s')
-= S.make (max_len excluded + 1) ' '
-
-let arbitrary_unexcluded (excluded: excluded_fields): GTot (struct_dom fields excluded) =
-  arbitrary_unexcluded_witness (set_as_list excluded)
-  *)
-
-let struct_view_to_carrier_not_one (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-: Lemma 
-    (~ (exists x. struct_view_to_carrier tag fields excluded x == one (struct_pcm tag fields)) /\
-     ~ (struct_view_to_view_prop tag fields excluded (one (struct_pcm tag fields))))
-= (fields.get_field "").view.to_carrier_not_one
-
-let struct_view_to_view_frame (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-: (x: struct' tag fields excluded) ->
-  (frame: struct_pcm_carrier tag fields) ->
-  Lemma
-    (requires (composable (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame))
-    (ensures
-      struct_view_to_view_prop tag fields excluded
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) /\
-      struct_view_to_view tag fields excluded
-        (op (struct_pcm tag fields) (struct_view_to_carrier tag fields excluded x) frame) == x)
-= fun x frame ->
-  let p = struct_pcms fields in
-  Classical.forall_intro_2 (fun k -> is_unit (p k));
-  let aux (k:struct_dom fields excluded)
-  : Lemma (
-      (fields.get_field k).view.to_view_prop
-        (op (p k) (struct_view_to_carrier tag fields excluded x k) (frame k)) /\
-      (fields.get_field k).view.to_view
-        (op (p k) (struct_view_to_carrier tag fields excluded x k) (frame k)) == x k)
-  = assert (composable (p k) ((fields.get_field k).view.to_carrier (x k)) (frame k));
-    (fields.get_field k).view.to_view_frame (x k) (frame k)
-  in FStar.Classical.forall_intro aux;
-  assert (
-    struct_view_to_view tag fields excluded
-       (op (prod_pcm p) (struct_view_to_carrier tag fields excluded x) frame) `feq` x)
-
-let struct_view tag fields excluded = {
-  to_view_prop = struct_view_to_view_prop tag fields excluded;
-  to_view = struct_view_to_view tag fields excluded;
-  to_carrier = struct_view_to_carrier tag fields excluded;
-  to_carrier_not_one = Classical.move_requires (struct_view_to_carrier_not_one tag fields) excluded;
-  to_view_frame = struct_view_to_view_frame tag fields excluded;
-}
-
-let rec struct_is_unit_aux (tag: Type0) (fields: c_fields)
-  (fields_list: list string)
-  (v: struct_pcm_carrier tag fields)
-: Pure bool
-    (requires forall field. field `mem` fields_list ==> fields.has_field field == true)
-    (ensures fun b -> b <==> (forall (field: string). field `mem` fields_list ==> v field == one (struct_pcm tag fields) field))
-    (decreases fields_list)
-= match fields_list with
-  | [] -> true
-  | field :: fields_list ->
-    (fields.get_field field).is_unit (v field) &&
-    struct_is_unit_aux tag fields fields_list v
-
-let struct_is_unit tag fields v
-: b:bool{b <==> v == one (struct_pcm tag fields)}
-= let b = struct_is_unit_aux tag fields fields.cfields v in
-  assert (b <==> v `feq` one (struct_pcm tag fields));
-  b
-
-let struct_field tag fields field = struct_field (struct_pcms fields) field
-
-let struct'_without_field
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_t)
-  (v: struct' tag fields excluded)
-: struct' tag fields (insert field excluded)
-= on_dom (struct_dom fields (insert field excluded)) v
-
-#push-options "--z3rlimit 30"
-let struct_without_field_to_carrier
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_of fields)
-  (s: struct_pcm_carrier tag fields)
-  (v: struct' tag fields excluded)
-: Lemma
-    (requires s == (struct_view tag fields excluded).to_carrier v)
-    (ensures
-      struct_without_field (struct_pcms fields) field s
-      == (struct_view tag fields (insert field excluded)).to_carrier
-           (struct'_without_field tag fields excluded field v))
-= assert (
-    struct_without_field (struct_pcms fields) field s
-    `feq` (struct_view tag fields (insert field excluded)).to_carrier
-         (struct'_without_field tag fields excluded field v))
-#pop-options
-
-let extract_field
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-  (field: field_of fields)
-  (v: struct' tag fields excluded)
-: Pure (struct' tag fields (insert field excluded) & (fields.get_field field).view_type)
-    (requires not (excluded field))
-    (ensures fun _ -> True)
-= (struct'_without_field tag fields excluded field v, v field)
-
-let extract_field_extracted
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-  (field: field_of fields)
-  (v: struct' tag fields excluded)
-= ()
-
-let extract_field_unextracted
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-  (field: field_of fields)
-  (field': field_of fields)
-  (v: struct' tag fields excluded)
-= ()
-
-let extract_field_unextracted'
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-  (field: field_of fields)
-  (v: struct' tag fields excluded)
-= let aux (field': field_of fields)
-  : Lemma ( (not (excluded field) /\ not (excluded field') /\ (field =!= field')) ==>
-    (fst (extract_field tag fields excluded field v) `struct_get` field' == v `struct_get` field'))
-  = Classical.move_requires (extract_field_unextracted tag fields excluded field field') v
-  in
-  Classical.forall_intro aux
-
-(*
-val addr_of_struct_field_ref'
-  (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
-  (field: field_of fields)
-  (p: ref 'a (struct_pcm tag fields))
-: Steel (ref 'a (fields.get_field field).pcm)
-    (p `pts_to_view` struct_view tag fields excluded)
-    (fun q ->
-      (p `pts_to_view` struct_view tag fields (insert field excluded)) `star`
-      (q `pts_to_view` (fields.get_field field).view))
-    (requires fun _ -> not (excluded field))
-    (ensures fun h q h' -> 
-      not (excluded field) /\
-      q == ref_focus p (struct_field tag fields field) /\
-      fst (extract_field tag fields excluded field
-        (h (p `pts_to_view` struct_view tag fields excluded)))
-       ==
-        h' (p `pts_to_view` struct_view tag fields (insert field excluded)) /\
-      snd
-        (extract_field tag fields excluded field
-          (h (p `pts_to_view` struct_view tag fields excluded)))
-       ==
-        h' (q `pts_to_view` (fields.get_field field).view))
-
-#push-options "--z3rlimit 30"
-let addr_of_struct_field_ref' #a #tag #fields #excluded field p =
-  let v: Ghost.erased (struct' tag fields excluded) =
-    gget (p `pts_to_view` struct_view tag fields excluded)
-  in
-  let s: Ghost.erased (struct_pcm_carrier tag fields) =
-    pts_to_view_elim p (struct_view tag fields excluded)
-  in
-  let q = addr_of_struct_field p field s in
-  change_equal_slprop (p `pts_to` _) (p `pts_to` _);
-  change_equal_slprop (q `pts_to` _) (q `pts_to` _);
-  struct_without_field_to_carrier tag fields excluded field s v;
-  pts_to_view_intro p (struct_without_field (struct_pcms fields) field s)
-    (struct_view tag fields (insert field excluded))
-    (struct'_without_field tag fields excluded field v);
-  pts_to_view_intro q (Ghost.reveal s field)
-    (fields.get_field field).view
-    (Ghost.reveal v field);
-  return q
-#pop-options
-
-let addr_of_struct_field_ref #a #tag #fields #excluded field p =
-  addr_of_struct_field_ref' field p
-
-let struct'_with_field
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-  (field: field_of fields) (w: (fields.get_field field).view_type)
-  (v: struct' tag fields excluded)
-: Pure (struct' tag fields (remove field excluded))
-    (requires excluded field == true)
-    (ensures fun _ -> True)
-= on_dom (struct_dom fields (remove field excluded))
-    (fun field' -> if field = field' then w else v field')
-
-#push-options "--z3rlimit 30"
-let struct_with_field_to_carrier'
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields) (field: field_of fields)
-  (s: struct_pcm_carrier tag fields)
-  (t: (fields.get_field field).carrier)
-  (v: struct' tag fields excluded)
-  (w: (fields.get_field field).view_type)
-  (h1: squash (excluded field == true))
-  (h2: squash (s == (struct_view tag fields excluded).to_carrier v))
-  (h3: squash (t == (fields.get_field field).view.to_carrier w))
-: Lemma
-    (struct_with_field (struct_pcms fields) field t s
-      == (struct_view tag fields (remove field excluded)).to_carrier
-           (struct'_with_field tag fields excluded field w v))
-= assert
-    (struct_with_field (struct_pcms fields) field t s
-      `feq` (struct_view tag fields (remove field excluded)).to_carrier
-           (struct'_with_field tag fields excluded field w v))
-#pop-options
-
-let extract_field_with_field
-  (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
-  (field: field_of fields)
-  (v: struct' tag fields excluded)
-  (w: (fields.get_field field).view_type)
-: Lemma
-    (requires excluded field == true)
-    (ensures
-      extract_field tag fields (remove field excluded) field
-         (struct'_with_field tag fields excluded field w v)
-         == (v, w))
-= assert (struct'_without_field tag fields (remove field excluded) field
-    (struct'_with_field tag fields excluded field w v)
-    `feq` v)
-
-#push-options "--z3rlimit 50"
-let unaddr_of_struct_field_ref' #a #tag #fields #excluded field p q =
-  let v: Ghost.erased (struct' tag fields excluded) =
-    gget (p `pts_to_view` struct_view tag fields excluded)
-  in
-  let s: Ghost.erased (struct_pcm_carrier tag fields) =
-    pts_to_view_elim p (struct_view tag fields excluded)
-  in
-  let w: Ghost.erased (fields.get_field field).view_type =
-    gget (q `pts_to_view` (fields.get_field field).view)
-  in
-  let t: Ghost.erased (fields.get_field field).carrier =
-    pts_to_view_elim q (fields.get_field field).view
-  in
-  unaddr_of_struct_field #_ #_ #_ #(struct_pcms fields) field q p s t;
-  let h1: squash (excluded field == true) = () in
-  let h2: squash (Ghost.reveal s == (struct_view tag fields excluded).to_carrier v) = () in
-  let h3: squash (Ghost.reveal t == (fields.get_field field).view.to_carrier w) = () in
-  struct_with_field_to_carrier' tag fields excluded field
-    (Ghost.reveal s) (Ghost.reveal t) (Ghost.reveal v) (Ghost.reveal w)
-    h1 h2 h3; // TODO why need pass explicitly
-  pts_to_view_intro p
-    (struct_with_field (struct_pcms fields) field t s)
-    (struct_view tag fields (remove field excluded))
-    (struct'_with_field tag fields excluded field w v);
-  extract_field_with_field tag fields excluded field (Ghost.reveal v) (Ghost.reveal w);
-  return ()
-#pop-options
-
-#restart-solver
-
-#push-options "--admit_smt_queries true"
-
-let dummy_def = ()
-
-let unaddr_of_struct_field_ref #a #tag #fields #excluded field p q =
-  unaddr_of_struct_field_ref' field p q
-#pop-options
diff --git a/ulib/experimental/Steel.C.StructLiteral.fsti b/ulib/experimental/Steel.C.StructLiteral.fsti
index 7facb07d3d4..d6d5dc4ec3b 100644
--- a/ulib/experimental/Steel.C.StructLiteral.fsti
+++ b/ulib/experimental/Steel.C.StructLiteral.fsti
@@ -265,7 +265,6 @@ val extract_field_unextracted'
     (fst (extract_field tag fields excluded field v) `struct_get` field' == v `struct_get` field'))
     [SMTPat (extract_field tag fields excluded field v)]
 
-(*
 val addr_of_struct_field_ref
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
@@ -352,8 +351,7 @@ val unaddr_of_struct_field_ref
 
 open Steel.C.Reference
 
-(* TODO make abstract *)
-let addr_of_struct_field''
+val addr_of_struct_field''
   (return_view_type: Type0)
   (return_carrier: Type0)
   (tag: Type0) (fields: c_fields) (excluded: excluded_fields)
@@ -385,7 +383,7 @@ let addr_of_struct_field''
         snd (extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded))) ==
          h' (q `pts_to_view` (fields.get_field field).view))
-= addr_of_struct_field_ref #'a #tag #fields #excluded field p
+// = addr_of_struct_field_ref #'a #tag #fields #excluded field p
 
 (** Take the address of a field of a struct.
     The above definitions are set up so that calls to addr_of_struct_field are erased to calls to addr_of_struct_field'' with
@@ -399,8 +397,7 @@ let addr_of_struct_field''
     Calls to [norm] are used to compute the type of values pointed to
     by the returned reference, and to ensure that the Steel tactic
     will be able to unify vprops properly. *)
-inline_for_extraction noextract
-let addr_of_struct_field
+val addr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
@@ -430,13 +427,16 @@ let addr_of_struct_field
         snd (extract_field tag fields excluded field
         (h (p `pts_to_view` struct_view tag fields excluded)))
         == h' (q `pts_to_view` (fields.get_field field).view))
+
+(*
 = addr_of_struct_field''
     (normalize (fields.get_field field).view_type)
     (normalize (fields.get_field field).carrier)
     tag fields excluded field p
+*)
 
 (** Inverse of unaddr_of_struct_field. *)
-let unaddr_of_struct_field
+val unaddr_of_struct_field
   (#tag: Type0) (#fields: c_fields) (#excluded: excluded_fields)
   (field: field_of fields)
   (p: ref 'a (struct tag fields) (struct_pcm tag fields))
@@ -466,7 +466,7 @@ let unaddr_of_struct_field
         snd (extract_field tag fields (remove field excluded) field
         (h' (p `pts_to_view` struct_view tag fields (remove field excluded)))) ==
          h (q `pts_to_view` (fields.get_field field).view))
-=
+// =
 //let unaddr_of_struct_field #a #tag #fields #excluded field p q =
-  unaddr_of_struct_field_ref' field p q
+ // unaddr_of_struct_field_ref' field p q
 

From afcc8e552cde047139a074e219a09b4221937980 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 17:40:01 -0800
Subject: [PATCH 424/513] convert PointStruct2

---
 examples/steel/arraystructs/PointStruct2.fst | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/examples/steel/arraystructs/PointStruct2.fst b/examples/steel/arraystructs/PointStruct2.fst
index 307e3e80f6b..12357ea2b6c 100644
--- a/examples/steel/arraystructs/PointStruct2.fst
+++ b/examples/steel/arraystructs/PointStruct2.fst
@@ -1,10 +1,11 @@
 module PointStruct2
-open Steel.C.Types
+open Steel.ST.Util
+open Steel.ST.C.Types
 
 module U32 = FStar.UInt32
 module C = C // for _zero_for_deref
 
-let swap (#v1 #v2: Ghost.erased U32.t) (r1 r2: ref (scalar U32.t)) : SteelT unit
+let swap (#v1 #v2: Ghost.erased U32.t) (r1 r2: ref (scalar U32.t)) : STT unit
   ((r1 `pts_to` mk_scalar (Ghost.reveal v1)) `star` (r2 `pts_to` mk_scalar (Ghost.reveal v2)))
   (fun _ -> (r1 `pts_to` mk_scalar (Ghost.reveal v2)) `star` (r2 `pts_to` mk_scalar (Ghost.reveal v1)))
 = let x1 = read r1 in
@@ -29,13 +30,13 @@ let point = struct "PointStruct2.point" point_fields
 #push-options "--query_stats --fuel 0"
 
 let swap_struct (p: ref point) (v: Ghost.erased (typeof point))
-: Steel (Ghost.erased (typeof point))
+: ST (Ghost.erased (typeof point))
     (p `pts_to` v)
     (fun v' -> p `pts_to` v')
-    (requires fun _ ->
+    (requires
       exists (vx vy: U32.t) . struct_get_field v "x" == mk_scalar vx /\ struct_get_field v "y" == mk_scalar vy
     )
-    (ensures fun _ v' _ ->
+    (ensures fun v' ->
       struct_get_field v' "x" == struct_get_field v "y" /\
       struct_get_field v' "y" == struct_get_field v "x"
     )
@@ -47,6 +48,8 @@ let swap_struct (p: ref point) (v: Ghost.erased (typeof point))
   write py x;
   unstruct_field p "x" px;
   unstruct_field p "y" py;
+  drop (has_struct_field _ _ px);
+  drop (has_struct_field _ _ _);
   return _
 
 #pop-options

From e0af7ad98f786662b24922747c15622269fe99db Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 17:40:23 -0800
Subject: [PATCH 425/513] (TEMP) disable extraction of arraystruct examples

---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 2caf053cbf0..879599e0131 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -9,7 +9,7 @@ ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
 endif
 
-world: verify test
+world: verify # test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \

From ca34b826539ad1fb830329a94f47e9e144df630f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 10 Mar 2023 17:40:48 -0800
Subject: [PATCH 426/513] (TEMP) disable LList

---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 879599e0131..8763efe01f5 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -20,7 +20,7 @@ FSTAR_OPTIONS = --cache_checked_modules \
 
 FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 
-ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
+ALL_SOURCE_FILES = $(filter-out LList.fst,$(wildcard *.fst *.fsti))
 
 # We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
 # since the KaRaMeL AST does not have a node for null

From 210af9d737d7b78ed58c8eccd857390d06cd5bc9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 12:32:24 -0700
Subject: [PATCH 427/513] Revert "(TEMP) disable LList"

This reverts commit ca34b826539ad1fb830329a94f47e9e144df630f.
---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 8763efe01f5..879599e0131 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -20,7 +20,7 @@ FSTAR_OPTIONS = --cache_checked_modules \
 
 FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 
-ALL_SOURCE_FILES = $(filter-out LList.fst,$(wildcard *.fst *.fsti))
+ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
 
 # We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
 # since the KaRaMeL AST does not have a node for null

From ba7c73a0c1e5f2faf3f2c57d5fd92c6d15d243cf Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 12:34:35 -0700
Subject: [PATCH 428/513] Revert "(TEMP) disable extraction of arraystruct
 examples"

This reverts commit e0af7ad98f786662b24922747c15622269fe99db.
---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 879599e0131..2caf053cbf0 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -9,7 +9,7 @@ ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
 endif
 
-world: verify # test
+world: verify test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \

From f8b091004770bb33905a9d1fb90a5f3c2508318f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 12:48:59 -0700
Subject: [PATCH 429/513] Revert "snap"

This reverts commit e3f7ac4cb803f49cba5912a58629ee38b60bc0cb.
---
 .../generated/FStar_Extraction_Krml.ml        | 962 +-----------------
 1 file changed, 15 insertions(+), 947 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 28a46818a24..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -706,102 +691,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -958,8 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -969,9 +857,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -989,63 +876,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.C.Types.struct_t0" ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1058,8 +888,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1096,21 +925,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1170,14 +996,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1190,36 +1015,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1883,66 +1691,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2036,48 +1784,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2803,505 +2514,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___6;
-                     FStar_Extraction_ML_Syntax.loc = uu___7;_}::uu___8::uu___9::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___10;
-             FStar_Extraction_ML_Syntax.loc = uu___11;_}::uu___12::[])
-          when
-          let uu___13 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___13 = "Steel.C.Types.struct_field0" ->
-          let uu___13 =
-            let uu___14 =
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___17 in
-                TQualified uu___16 in
-              let uu___16 =
-                let uu___17 =
-                  let uu___18 = translate_expr env1 r in
-                  (uu___18, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___17 in
-              (uu___15, uu___16, field_name) in
-            EField uu___14 in
-          EAddrOf uu___13
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3715,72 +2927,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3793,85 +2939,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 7dee5c4db0a8dc6a6c658d2b23c27648d90614d7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 13:01:30 -0700
Subject: [PATCH 430/513] extraction: Steel.C.Types -> Steel.ST.C.Types, remove
 some opened args

---
 src/extraction/FStar.Extraction.Krml.fst | 30 ++++++++++++------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 2e105ccc2b3..99c08254106 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -472,7 +472,7 @@ let rec translate_type_without_decay env t: typ =
       TQualified (must (lident_of_typestring tag))
 
   | MLTY_Named ([tag; _; _; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.Types.struct_t0"
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.struct_t0"
     ->
       TQualified (must (lident_of_typestring tag))
 
@@ -487,12 +487,12 @@ let rec translate_type_without_decay env t: typ =
       TBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg; _], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Types.ptr"
+    Syntax.string_of_mlpath p = "Steel.ST.C.Types.ptr"
     ->
       TBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Types.scalar_t"
+    Syntax.string_of_mlpath p = "Steel.ST.C.Types.scalar_t"
     ->
       translate_type_without_decay env arg
 
@@ -814,7 +814,7 @@ and translate_expr env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
     when (
-          string_of_mlpath p = "Steel.C.Types.alloc" ||
+          string_of_mlpath p = "Steel.ST.C.Types.alloc" ||
           false) ->
       EBufCreateNoInit (ManuallyManaged, EConstant (UInt32, "1"))
 
@@ -851,7 +851,7 @@ and translate_expr env e: expr =
       EBufFree (translate_expr env e2)
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *); _ (* v *); e ]) when
-       string_of_mlpath p = "Steel.C.Types.free" ->
+       string_of_mlpath p = "Steel.ST.C.Types.free" ->
       EBufFree (translate_expr env e)
 
   (* Generic buffer operations. *)
@@ -1061,7 +1061,7 @@ and translate_expr env e: expr =
     -> generate_is_null (translate_type env t) (translate_expr env e)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); _ (* td *); _ (* v *); e])
-    when string_of_mlpath p = "Steel.C.Types.is_null"
+    when string_of_mlpath p = "Steel.ST.C.Types.is_null"
     -> generate_is_null (translate_type env t) (translate_expr env e)
   
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, _)
@@ -1070,7 +1070,7 @@ and translate_expr env e: expr =
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
     when string_of_mlpath p = "Steel.C.Reference.null"
-    || string_of_mlpath p = "Steel.C.Types.null"
+    || string_of_mlpath p = "Steel.ST.C.Types.null"
     -> EBufNull (translate_type env t)
 
 (* END support for the Steel null pointer *)
@@ -1093,15 +1093,15 @@ and translate_expr env e: expr =
         field_name))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)},
-             [_ (* opened *)
-               ; ({expr=MLE_Const (MLC_String struct_name)})
+             [
+               ({expr=MLE_Const (MLC_String struct_name)})
                ; _ (* fields *)
                ; _ (* v *)
                ; r
                ; ({expr=MLE_Const (MLC_String field_name)})
                ; _ (* td' *)
              ])
-    when string_of_mlpath p = "Steel.C.Types.struct_field0" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.struct_field0" ->
       EAddrOf (EField (
         TQualified (must (lident_of_string struct_name)),
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
@@ -1136,11 +1136,11 @@ and translate_expr env e: expr =
         translate_expr env x)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *) ; _ (* perm *) ; r])
-    when string_of_mlpath p = "Steel.C.Types.read0" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.read0" ->
       EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *); r; x])
-    when string_of_mlpath p = "Steel.C.Types.write" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.write" ->
       EAssign (
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
         translate_expr env x)
@@ -1365,12 +1365,12 @@ let parse_steel_c_fields env (fields: mlty): option (list _) =
         match fields with
         | MLTY_Named ([], p)
           when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
-          || Syntax.string_of_mlpath p = "Steel.C.Types.field_t_nil"
+          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_nil"
           -> Some []
           
         | MLTY_Named ([field; t; fields], p)
           when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
-          || Syntax.string_of_mlpath p = "Steel.C.Types.field_t_cons"
+          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_cons"
           ->
           opt_bind (string_of_typestring field) (fun field ->
           if field = "" then go fields else
@@ -1430,7 +1430,7 @@ let translate_type_decl env ty: option decl =
       define_struct tag fields
 
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
-      when Syntax.string_of_mlpath p = "Steel.C.Types.define_struct0"
+      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_struct0"
       ->
       define_struct tag fields
 

From ac51d957105659f807506c29f09695aab44e1101 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 13:01:50 -0700
Subject: [PATCH 431/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 963 +++++++++++++++++-
 1 file changed, 948 insertions(+), 15 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..96e78be5b5a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,64 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___3 "Steel.ST.C.Types.struct_t0"
+          ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.ST.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.ST.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1059,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1097,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1171,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1191,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1884,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.ST.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2037,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2804,505 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.ST.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_}::uu___7::uu___8::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___9;
+             FStar_Extraction_ML_Syntax.loc = uu___10;_}::uu___11::[])
+          when
+          let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___12 = "Steel.ST.C.Types.struct_field0" ->
+          let uu___12 =
+            let uu___13 =
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___16 in
+                TQualified uu___15 in
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = translate_expr env1 r in
+                  (uu___17, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___16 in
+              (uu___14, uu___15, field_name) in
+            EField uu___13 in
+          EAddrOf uu___12
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.ST.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3716,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.ST.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.ST.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3794,85 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.ST.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From abf0403f00eab04224049d56a82c853cbfb9b3ce Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 13:02:09 -0700
Subject: [PATCH 432/513] disable extraction for old-style examples

---
 examples/steel/arraystructs/Makefile | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 2caf053cbf0..173aff9bac7 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -20,15 +20,19 @@ FSTAR_OPTIONS = --cache_checked_modules \
 
 FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 
-ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
+ALL_SOURCE_FILES = $(filter-out LList.fst,$(wildcard *.fst *.fsti))
+NO_EXTRACT_MODULES=PointStruct HaclExample ScalarUnion
+EXTRACT_SOURCE_FILES = $(filter-out $(addsuffix .fst,$(NO_EXTRACT_MODULES)),$(ALL_SOURCE_FILES))
 
 # We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
 # since the KaRaMeL AST does not have a node for null
 # TODO: This should be removed, and support for Steel.C null should be directly added to KaRaMeL instead
 SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst
 
+comma=,
+
 .depend: $(ALL_SOURCE_FILES) Makefile
-	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:*,-Prims,-FStar.MSTTotal,-FStar.NMSTTotal,-FStar.MST,-FStar.NMST' > $@.tmp
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:* $(addprefix -,$(NO_EXTRACT_MODULES))'  > $@.tmp
 	mv $@.tmp $@
 
 depend: .depend
@@ -60,7 +64,7 @@ ifdef KRML_HOME
 	$(FSTAR) $(notdir $(subst .checked,,$<)) --codegen krml \
 	--extract_module $(basename $(notdir $(subst .checked,,$<)))
 
-ALL_MODULE_NAMES=$(basename $(ALL_SOURCE_FILES))
+ALL_MODULE_NAMES=$(basename $(EXTRACT_SOURCE_FILES))
 FILTERED_KRML_FILES=$(filter-out FStar_NMST.krml Steel_%.krml,$(ALL_KRML_FILES))
 
 extract: $(FILTERED_KRML_FILES)

From 92f44aa8570ef8fb308423c20a134a12a29f1110 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 15:47:42 -0700
Subject: [PATCH 433/513] Revert "snap"

This reverts commit ac51d957105659f807506c29f09695aab44e1101.
---
 .../generated/FStar_Extraction_Krml.ml        | 963 +-----------------
 1 file changed, 15 insertions(+), 948 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 96e78be5b5a..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -706,102 +691,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -958,8 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -969,9 +857,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -989,64 +876,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___3 "Steel.ST.C.Types.struct_t0"
-          ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.ST.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.ST.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1059,8 +888,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1097,21 +925,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1171,14 +996,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1191,36 +1015,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1884,66 +1691,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.ST.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2037,48 +1784,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2804,505 +2514,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.ST.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_}::uu___7::uu___8::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___9;
-             FStar_Extraction_ML_Syntax.loc = uu___10;_}::uu___11::[])
-          when
-          let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___12 = "Steel.ST.C.Types.struct_field0" ->
-          let uu___12 =
-            let uu___13 =
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___16 in
-                TQualified uu___15 in
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = translate_expr env1 r in
-                  (uu___17, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___16 in
-              (uu___14, uu___15, field_name) in
-            EField uu___13 in
-          EAddrOf uu___12
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.ST.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3716,72 +2927,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.ST.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.ST.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3794,85 +2939,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.ST.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From ed28eca6e1e907c376c3471bed0b2cc093b9718d Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 16:20:54 -0700
Subject: [PATCH 434/513] full_not_unknown

---
 ulib/experimental/Steel.C.Model.PCM.fsti | 2 +-
 ulib/experimental/Steel.ST.C.Types.fst   | 4 ++++
 ulib/experimental/Steel.ST.C.Types.fsti  | 9 +++++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.C.Model.PCM.fsti b/ulib/experimental/Steel.C.Model.PCM.fsti
index c01ec0063dc..e177ae81c08 100644
--- a/ulib/experimental/Steel.C.Model.PCM.fsti
+++ b/ulib/experimental/Steel.C.Model.PCM.fsti
@@ -408,5 +408,5 @@ let pcm (a: Type) : Tot Type =
     (forall (x:a) (y:a{composable p x y}).{:pattern (composable p x y)}
       op p x y == one p ==> x == one p /\ y == one p) /\ // necessary to lift frame-preserving updates to unions
     (forall (x:a) . {:pattern (p_refine p x)} p_refine p x ==> exclusive p x) /\ // nice to have, but not used yet
-    (~ (p_refine p (one p))) // necessary to maintain (refine ==> exclusive) for uninit
+    (~ (p_refine p (one p))) // necessary to maintain (refine ==> exclusive) for uninit, also necessary to prove full_not_unknown
   })
diff --git a/ulib/experimental/Steel.ST.C.Types.fst b/ulib/experimental/Steel.ST.C.Types.fst
index a2370297ba6..b53a9860313 100644
--- a/ulib/experimental/Steel.ST.C.Types.fst
+++ b/ulib/experimental/Steel.ST.C.Types.fst
@@ -89,6 +89,10 @@ let uninitialized td = td.uninitialized
 
 let unknown td = one td.pcm
 
+let full_not_unknown
+  td v
+= ()
+
 let mk_fraction_unknown td p = td.mk_fraction_one p
 let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
 
diff --git a/ulib/experimental/Steel.ST.C.Types.fsti b/ulib/experimental/Steel.ST.C.Types.fsti
index 13409712482..9922e8b6743 100644
--- a/ulib/experimental/Steel.ST.C.Types.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.fsti
@@ -45,6 +45,15 @@ val unknown (#t: Type0) (td: typedef t) : Ghost t
   (requires True)
   (ensures (fun y -> fractionable td y))
 
+val full_not_unknown
+  (#t: Type)
+  (td: typedef t)
+  (v: t)
+: Lemma
+  (requires (full td v))
+  (ensures (~ (v == unknown td)))
+  [SMTPat (full td v)]
+
 val mk_fraction_unknown (#t: Type0) (td: typedef t) (p: P.perm) : Lemma
   (ensures (mk_fraction td (unknown td) p == unknown td))
 

From b8b988e6b51421a52a6d1471f3626f0e49f32dc3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 16:21:05 -0700
Subject: [PATCH 435/513] extract unions

---
 src/extraction/FStar.Extraction.Krml.fst | 26 +++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 99c08254106..eec3b3ea8f3 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -473,6 +473,7 @@ let rec translate_type_without_decay env t: typ =
 
   | MLTY_Named ([tag; _; _; _], p) when
     BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.struct_t0"
+    || BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.union_t0"
     ->
       TQualified (must (lident_of_typestring tag))
 
@@ -1101,7 +1102,10 @@ and translate_expr env e: expr =
                ; ({expr=MLE_Const (MLC_String field_name)})
                ; _ (* td' *)
              ])
-    when string_of_mlpath p = "Steel.ST.C.Types.struct_field0" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.struct_field0"
+    || string_of_mlpath p = "Steel.ST.C.Types.union_field0"
+    || string_of_mlpath p = "Steel.ST.C.Types.union_switch_field0"
+    ->
       EAddrOf (EField (
         TQualified (must (lident_of_string struct_name)),
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
@@ -1423,6 +1427,21 @@ let translate_type_decl env ty: option decl =
             List.map (fun (field, ty) -> (field, (ty, true))) fields))
         end
     in
+    let define_union
+      tag fields
+    =
+        (* JL: TODO remove/improve these print commands *)
+        print_endline "Parsing union definition.";
+        begin match lident_of_typestring tag with
+        | None ->
+          BU.print1 "Failed to parse union tag from %s.\n"
+            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
+          None
+        | Some p ->
+          let fields = must (parse_steel_c_fields env fields) in
+          Some (DUntaggedUnion (p, [], 0, fields))
+        end
+    in
     match ty with
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
       when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
@@ -1434,6 +1453,11 @@ let translate_type_decl env ty: option decl =
       ->
       define_struct tag fields
 
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
+      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_union0"
+      ->
+      define_union tag fields
+
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
       when Syntax.string_of_mlpath p = "Steel.C.UnionLiteral.mk_union_def"
       ->

From 0a7e8fd9a9659ad2e56d2fe76fd81d595a357b13 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 16:21:11 -0700
Subject: [PATCH 436/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 1004 ++++++++++++++++-
 1 file changed, 989 insertions(+), 15 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..f0f417516c8 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,69 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           FStar_Compiler_Util.starts_with uu___3
+             "Steel.ST.C.Types.struct_t0")
+            ||
+            (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             FStar_Compiler_Util.starts_with uu___3
+               "Steel.ST.C.Types.union_t0")
+          ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.ST.C.Types.ptr" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.ST.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1064,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1102,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1176,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1196,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1889,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.ST.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2042,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2809,511 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.ST.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_}::uu___7::uu___8::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___9;
+             FStar_Extraction_ML_Syntax.loc = uu___10;_}::uu___11::[])
+          when
+          ((let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___12 = "Steel.ST.C.Types.struct_field0") ||
+             (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___12 = "Steel.ST.C.Types.union_field0"))
+            ||
+            (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___12 = "Steel.ST.C.Types.union_switch_field0")
+          ->
+          let uu___12 =
+            let uu___13 =
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___16 in
+                TQualified uu___15 in
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = translate_expr env1 r in
+                  (uu___17, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___16 in
+              (uu___14, uu___15, field_name) in
+            EField uu___13 in
+          EAddrOf uu___12
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.ST.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3727,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.ST.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.ST.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3805,115 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         let define_union tag fields =
+           FStar_Compiler_Util.print_endline "Parsing union definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse union tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                FStar_Pervasives_Native.Some
+                  (DUntaggedUnion (p, [], Prims.int_zero, fields1))) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.ST.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.ST.C.Types.define_union0" ->
+             define_union tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 83c19b42198a7ac19d0b1b0b8fbba464b95b9bf6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 16:21:31 -0700
Subject: [PATCH 437/513] port ScalarUnion example

---
 examples/steel/arraystructs/ScalarUnion2.fst | 78 ++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 examples/steel/arraystructs/ScalarUnion2.fst

diff --git a/examples/steel/arraystructs/ScalarUnion2.fst b/examples/steel/arraystructs/ScalarUnion2.fst
new file mode 100644
index 00000000000..2f278941c23
--- /dev/null
+++ b/examples/steel/arraystructs/ScalarUnion2.fst
@@ -0,0 +1,78 @@
+module ScalarUnion2
+open Steel.ST.Util
+open Steel.ST.C.Types
+
+module U32 = FStar.UInt32
+module U16 = FStar.UInt16
+
+(** Like structs, unions are labelled by tags to enforce nominality.
+    For a more detailed explanation see PointStruct2.fst *)
+
+noextract
+inline_for_extraction
+[@@ norm_field_attr]
+let u32_or_u16_fields =
+  field_description_cons "as_u32" (scalar U32.t) (
+  field_description_cons "as_u16" (scalar U16.t) (
+  field_description_nil))
+
+(** Define the union. Like with mk_c_struct, Karamel detects this
+    definition at extraction type and emits the corresponding typedef. *)
+let _ = define_union "ScalarUnion2.u32_or_u16" u32_or_u16_fields
+
+(** The type of (union u32_or_u16) values. *)
+noextract inline_for_extraction
+let u32_or_u16 = union "ScalarUnion2.u32_or_u16" u32_or_u16_fields
+
+noextract inline_for_extraction
+let u32_or_u16_t = typeof u32_or_u16
+
+#push-options "--fuel 0"
+
+#push-options "--print_universes --print_implicits"
+// --z3rlimit 30"
+
+(** Switch a case of the union to the u16 case, by writing x to it. *)
+val switch_to_u16
+  (#v: Ghost.erased u32_or_u16_t)
+  (p: ref u32_or_u16)
+  (x: U16.t)
+: ST unit
+    (p `pts_to` v)
+    (fun _ -> p `pts_to` union_set_field _ _ _ "as_u16" (mk_scalar x))
+    (requires full u32_or_u16 v)
+    (ensures fun _ -> True)
+
+#push-options "--fuel 0 --print_bound_var_types"
+
+let switch_to_u16 p x =
+  let p16 = union_switch_field  p "as_u16" in
+  write p16 x;
+  ununion_field p "as_u16" _;
+  drop (has_union_field _ _ _);
+  return ()
+
+(** Helper function that zeros the memory location pointed to by p. *)
+let zero_u32_ref (#v: Ghost.erased (scalar_t U32.t)) (p:ref (scalar U32.t))
+: ST unit
+  (p `pts_to` v)
+  (fun _ -> p `pts_to` mk_scalar 0ul)
+  (requires full (scalar U32.t) v)
+  (ensures fun _ -> True)
+= write p 0ul;
+  return ()
+
+(** Given a union in the u32 case, set the u32 to zero. *)
+val zero_u32_of_union (#v: Ghost.erased u32_or_u16_t) (p: ref u32_or_u16)
+: ST unit
+    (p `pts_to` v)
+    (fun _ -> p `pts_to` union_set_field _ _ _ "as_u32" (mk_scalar 0ul))
+    (requires exists (v0: scalar_t U32.t) . Ghost.reveal v == union_set_field _ _ _ "as_u32" v0 /\ full (scalar U32.t) v0)
+    (ensures fun _ -> True)
+
+let zero_u32_of_union #v p =
+  let q = union_field p "as_u32" in
+  zero_u32_ref q;
+  ununion_field p "as_u32" _;
+  drop (has_union_field _ _ _);
+  return ()

From 3d326c3b0b3facfe636f4389bb4404257a04b13a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 23:00:26 -0700
Subject: [PATCH 438/513] some adjustments for structs and arrays

---
 ulib/experimental/Steel.ST.C.Types.fsti | 68 ++++++++++++++++++++++++-
 1 file changed, 66 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.fsti b/ulib/experimental/Steel.ST.C.Types.fsti
index 9922e8b6743..f5c81c601cc 100644
--- a/ulib/experimental/Steel.ST.C.Types.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.fsti
@@ -449,12 +449,28 @@ val struct_get_field_other
 : Lemma
   (requires (field' <> field))
   (ensures (struct_get_field (struct_set_field field v s) field' == struct_get_field s field'))
+
+let struct_get_field_pat
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+  (field': field_t fields)
+: Lemma
+  (struct_get_field (struct_set_field field v s) field' == (if field' = field then v else struct_get_field s field'))
   [SMTPat (struct_get_field (struct_set_field field v s) field')]
+= if field' = field
+  then ()
+  else struct_get_field_other s field v field'
 
 [@@noextract_to "krml"] // proof-only
 val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
 
-[@@noextract_to "krml"] // proof-only
+inline_for_extraction
+[@@noextract_to "krml"; norm_field_attr] // proof-only
 let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
 = struct0 tn #tf n fields
 
@@ -624,6 +640,29 @@ val unstruct_field
     )
     (fun _ -> True)
 
+let unstruct_field_alt
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: STGhost (Ghost.erased (struct_t0 tn n fields)) opened
+    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun s' -> has_struct_field r field r' `star` pts_to r s')
+    (
+      struct_get_field v field == unknown (fields.fd_typedef field)
+    )
+    (fun s' -> 
+      Ghost.reveal s' == struct_set_field field v' v
+    )
+= unstruct_field r field r';
+  _
+
 val fractionable_struct
   (#tn: Type0)
   (#tf: Type0)
@@ -745,7 +784,8 @@ val union_set_field_same
 [@@noextract_to "krml"] // proof-only
 val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
 
-[@@noextract_to "krml"] // proof-only
+inline_for_extraction
+[@@noextract_to "krml"; norm_field_attr] // proof-only
 let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
 = union0 tn #tf n fields
 
@@ -1039,6 +1079,12 @@ inline_for_extraction [@@noextract_to "krml"] // MUST be syntactically equal to
 let base_array_index_t (n: array_size_t) : Tot eqtype = (i: SZ.t { SZ.v i < SZ.v n })
 [@@noextract_to "krml"]
 val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: array_size_t) : Tot (typedef (base_array_t t tn n))
+
+inline_for_extraction
+[@@noextract_to "krml"] // proof-only
+let base_array (#t: Type0) (#tn: Type0) (td: typedef t) (n: nat {SZ.fits n /\ n > 0}) (# [solve_nat_t_of_nat ()] prf: squash (norm norm_typenat (nat_t_of_nat n == tn))) : Tot (typedef (base_array_t t tn (SZ.uint_to_t n)))
+= base_array0 tn td (SZ.uint_to_t n)
+
 val base_array_index (#t: Type0) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (i: base_array_index_t n) : GTot t
 val base_array_eq (#t: Type0) (#tn: Type0) (#n: array_size_t) (a1 a2: base_array_t t tn n) : Ghost prop
   (requires True)
@@ -1214,6 +1260,13 @@ let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
 inline_for_extraction [@@noextract_to "krml"]
 let array (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ref td & array_len_t r)
 
+let array_length
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+: GTot nat
+= SZ.v (dsnd a)
+
 val array_pts_to
   (#t: Type)
   (#td: typedef t)
@@ -1789,3 +1842,14 @@ val mk_fraction_seq_join
 : STGhostT unit opened
   (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
   (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
+
+let full_seq (#t: Type) (td: typedef t) (v: Seq.seq t) : GTot prop =
+  forall (i: nat { i < Seq.length v }) . {:pattern (Seq.index v i)} full td (Seq.index v i)
+
+let full_seq_seq_of_base_array
+  (#t: Type0) (tn: Type0) (td: typedef t) (#n: array_size_t)
+  (b: base_array_t t tn n)
+: Lemma
+  (ensures (full_seq td (seq_of_base_array b) <==> full (base_array0 tn td n) b))
+  [SMTPat (full_seq td (seq_of_base_array b))]
+= assert (forall (i: base_array_index_t n) . base_array_index b i == Seq.index (seq_of_base_array b) (SZ.v i))

From 3b6d23e50d598261962756a096627deba6003e56 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 23:02:52 -0700
Subject: [PATCH 439/513] port HaclExample (except array alloc)

---
 examples/steel/arraystructs/HaclExample2.fst | 127 +++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 examples/steel/arraystructs/HaclExample2.fst

diff --git a/examples/steel/arraystructs/HaclExample2.fst b/examples/steel/arraystructs/HaclExample2.fst
new file mode 100644
index 00000000000..81df2e6a421
--- /dev/null
+++ b/examples/steel/arraystructs/HaclExample2.fst
@@ -0,0 +1,127 @@
+module HaclExample2
+open Steel.ST.GenElim
+open Steel.ST.C.Types
+open Steel.C.Typenat
+open Steel.C.Typestring
+
+module SZ = FStar.SizeT
+module U64 = FStar.UInt64
+
+(** In this file we demonstrate how Steel could be used to manipulate the following data type used in Hacl*:
+      https://github.com/project-everest/hacl-star/blob/master/code/poly1305/Hacl.Impl.Poly1305.fsti#L18
+    This Low* definition amounts to the struct definition
+      struct poly1305_ctx { uint64_t limbs[5]; uint64_t precomp[20]; };
+    and, with our new model of structs and arrays and pointer-to-field, can be expresesd directly in Steel.
+
+    See PointStruct.fst for more detailed explanations of the various definitions needed below.
+*)
+
+noextract inline_for_extraction let five = normalize (nat_t_of_nat 5)
+noextract inline_for_extraction let twenty = normalize (nat_t_of_nat 20)
+noextract inline_for_extraction let comp_name = normalize (mk_string_t "HaclExample2.comp")
+
+noextract
+inline_for_extraction
+[@@norm_field_attr]
+let comp_fields =
+  field_description_cons "limbs" (base_array0 five (scalar U64.t) 5sz) (
+  field_description_cons "precomp" (base_array0 twenty (scalar U64.t) 20sz) (
+  field_description_nil
+  ))
+
+noextract inline_for_extraction
+let comp = struct0 comp_name "HaclExample2.comp" comp_fields
+
+let _ = define_struct0 comp_name "HaclExample2.comp" comp_fields
+
+(** To demonstrate how our model could be used, we write a simple
+    function that takes pointers to the limbs and precomp fields and
+    passes them to helper functions (which in this case simply set on
+    element of the corresponding array to zero) *)
+
+let do_something_with_limbs
+  (#v: Ghost.erased (Seq.seq (scalar_t U64.t)))
+  (a: array (scalar U64.t))
+: ST (Ghost.erased (Seq.seq (scalar_t U64.t)))
+    (array_pts_to a v)
+    (fun v' -> array_pts_to a v')
+    (requires
+      array_length a == 5 /\
+      full_seq (scalar U64.t) v
+    )
+    (ensures (fun v' ->
+      full_seq (scalar U64.t) v'
+    ))
+= let p = array_cell a 2sz in
+  write p 0uL;
+  unarray_cell _ _ _;
+  drop (has_array_cell _ _ _); 
+  return _
+
+let do_something_with_precomp
+  (#v: Ghost.erased (Seq.seq (scalar_t U64.t)))
+  (a: array (scalar U64.t))
+: ST (ptr (scalar U64.t))
+    (array_pts_to a v)
+    (fun _ -> exists_ (fun (v': Seq.seq (scalar_t U64.t)) ->
+      array_pts_to a v' `star`
+      pure (full_seq (scalar U64.t) v')
+    ))
+    (requires
+      array_length a == 20 /\
+      full_seq (scalar U64.t) v
+    )
+    (ensures fun _ -> True)
+= let p = array_cell a 19sz in
+  write p 0uL;
+  unarray_cell _ _ _;
+  drop (has_array_cell _ _ _);
+  noop ();
+  return (null _)
+
+(*
+let test_alloc_free
+  ()
+: STT unit
+    emp
+    (fun _ -> emp)
+=
+  let a = alloc (scalar bool) true (mk_size_t 42ul) in
+  if Steel.C.Array.is_null a
+  then begin
+    Steel.C.Array.elim_varray_or_null_none a
+  end else begin
+    Steel.C.Array.elim_varray_or_null_some a;
+    free a
+  end;
+  return ()
+*)
+
+#push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 128"
+#restart-solver
+
+let test
+  (#v: Ghost.erased (typeof comp))
+  (p: ref comp)
+: ST (Ghost.erased (typeof comp))
+    (p `pts_to` v)
+    (fun v' -> p `pts_to` v')
+    (full comp v)
+    (fun v' -> full comp v')
+= let q = p `struct_field` "limbs" in
+  let a = array_of_base q in
+  let r = p `struct_field` "precomp" in
+  let _ = vpattern_replace_erased (pts_to p) in // FIXME: WHY WHY WHY?
+  let b = array_of_base r in
+  let _ = do_something_with_limbs a in
+  let _ = do_something_with_precomp b in
+  let _ = gen_elim () in
+  let _ = unarray_of_base q a in
+  let _ = unarray_of_base r b in
+  let _ = unstruct_field_alt p "precomp" r in
+  let _ = unstruct_field_alt p "limbs" q in
+  drop (has_struct_field p "limbs" q);
+  drop (has_struct_field p "precomp" r);
+  return _
+
+#pop-options

From 68612eafc09788ffe0a9f8b4820c22acc062ed08 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 23:04:13 -0700
Subject: [PATCH 440/513] Revert "snap"

This reverts commit 0a7e8fd9a9659ad2e56d2fe76fd81d595a357b13.
---
 .../generated/FStar_Extraction_Krml.ml        | 1004 +----------------
 1 file changed, 15 insertions(+), 989 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index f0f417516c8..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -706,102 +691,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -958,8 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -969,9 +857,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -989,69 +876,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           FStar_Compiler_Util.starts_with uu___3
-             "Steel.ST.C.Types.struct_t0")
-            ||
-            (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             FStar_Compiler_Util.starts_with uu___3
-               "Steel.ST.C.Types.union_t0")
-          ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.ST.C.Types.ptr" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.ST.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1064,8 +888,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1102,21 +925,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1176,14 +996,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1196,36 +1015,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1889,66 +1691,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.ST.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2042,48 +1784,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2809,511 +2514,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.ST.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_}::uu___7::uu___8::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___9;
-             FStar_Extraction_ML_Syntax.loc = uu___10;_}::uu___11::[])
-          when
-          ((let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___12 = "Steel.ST.C.Types.struct_field0") ||
-             (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___12 = "Steel.ST.C.Types.union_field0"))
-            ||
-            (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___12 = "Steel.ST.C.Types.union_switch_field0")
-          ->
-          let uu___12 =
-            let uu___13 =
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___16 in
-                TQualified uu___15 in
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = translate_expr env1 r in
-                  (uu___17, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___16 in
-              (uu___14, uu___15, field_name) in
-            EField uu___13 in
-          EAddrOf uu___12
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.ST.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3727,72 +2927,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.ST.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.ST.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3805,115 +2939,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         let define_union tag fields =
-           FStar_Compiler_Util.print_endline "Parsing union definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse union tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                FStar_Pervasives_Native.Some
-                  (DUntaggedUnion (p, [], Prims.int_zero, fields1))) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.ST.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.ST.C.Types.define_union0" ->
-             define_union tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From f58ea7291bec987f125ff33e9dd197ec9d893022 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 23:28:23 -0700
Subject: [PATCH 441/513] extract arrays

---
 src/extraction/FStar.Extraction.Krml.fst | 25 ++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index eec3b3ea8f3..cf741cdab16 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -489,6 +489,7 @@ let rec translate_type_without_decay env t: typ =
 
   | MLTY_Named ([arg; _], p) when
     Syntax.string_of_mlpath p = "Steel.ST.C.Types.ptr"
+    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.array_ref"
     ->
       TBuf (translate_type_without_decay env arg)
 
@@ -499,6 +500,7 @@ let rec translate_type_without_decay env t: typ =
 
   | MLTY_Named ([t; n; s], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
+     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.base_array_t"
     ->
       TArray (
         translate_type_without_decay env t,
@@ -1149,6 +1151,29 @@ and translate_expr env e: expr =
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
         translate_expr env x)
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [
+      _ (* opened *);
+      _ (* n *);
+      _ (* typedef *);
+      _ (* v *);
+      r
+    ])
+    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_of_base" ->
+      // this is not a true read, this is how Karamel models arrays decaying into pointers
+      EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [
+      _ (* typedef *);
+      _ (* s *);
+      a;
+      _ (* len *);
+      i
+    ])
+    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_cell"
+    || string_of_mlpath p = "Steel.ST.C.Types.array_ref_split"
+    ->
+      EBufSub (translate_expr env a, translate_expr env i)
+
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
       translate_expr env r

From 0c443ed72dc7ae10c3e1dcfb4537f18d52c38db3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 13 Mar 2023 23:28:51 -0700
Subject: [PATCH 442/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 1053 ++++++++++++++++-
 1 file changed, 1038 insertions(+), 15 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..1fe13092ae2 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -691,6 +706,102 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
+let opt_bind :
+  'a 'b .
+    'a FStar_Pervasives_Native.option ->
+      ('a -> 'b FStar_Pervasives_Native.option) ->
+        'b FStar_Pervasives_Native.option
+  =
+  fun m ->
+    fun k ->
+      match m with
+      | FStar_Pervasives_Native.Some x -> k x
+      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
+let (char_of_typechar :
+  FStar_Extraction_ML_Syntax.mlty ->
+    FStar_BaseTypes.char FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    match t with
+    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
+        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+        if p1 = "Steel.C.Typestring.cdot"
+        then FStar_Pervasives_Native.Some 46
+        else
+          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
+          then
+            (let uu___1 =
+               FStar_String.get p1
+                 (FStar_String.strlen "Steel.C.Typestring.c") in
+             FStar_Pervasives_Native.Some uu___1)
+          else FStar_Pervasives_Native.None
+    | uu___ -> FStar_Pervasives_Native.None
+let (string_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty ->
+    Prims.string FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_nil" ->
+          FStar_Pervasives_Native.Some []
+      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typestring.string_cons" ->
+          let uu___ = char_of_typechar c in
+          opt_bind uu___
+            (fun c' ->
+               let uu___1 = go t2 in
+               opt_bind uu___1
+                 (fun s' ->
+                    let uu___2 =
+                      let uu___3 = FStar_String.make Prims.int_one c' in
+                      uu___3 :: s' in
+                    FStar_Pervasives_Native.Some uu___2))
+      | uu___ -> FStar_Pervasives_Native.None in
+    let uu___ = go t in
+    opt_bind uu___
+      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
+let (lident_of_string :
+  Prims.string -> lident FStar_Pervasives_Native.option) =
+  fun s ->
+    let path = FStar_String.split [46] s in
+    let rec go p =
+      match p with
+      | [] -> FStar_Pervasives_Native.None
+      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
+      | s1::p1 ->
+          let uu___ = go p1 in
+          opt_bind uu___
+            (fun uu___1 ->
+               match uu___1 with
+               | (names, name) ->
+                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
+    go path
+let (lident_of_typestring :
+  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
+  fun t ->
+    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
+let (int_of_typenat :
+  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
+  =
+  fun t ->
+    let rec go t1 =
+      match t1 with
+      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.z" ->
+          FStar_Pervasives_Native.Some Prims.int_zero
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.C.Typenat.s" ->
+          let uu___ = go t2 in
+          opt_bind uu___
+            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
+      | uu___ -> FStar_Pervasives_Native.None in
+    go t
 type env =
   {
   names: name Prims.list ;
@@ -847,7 +958,8 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +969,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -876,6 +989,75 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___2
+            "Steel.C.StructLiteral.struct'"
+          ->
+          let uu___2 =
+            let uu___3 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___3 in
+          TQualified uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (tag::uu___::uu___1::uu___2::[], p) when
+          (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           FStar_Compiler_Util.starts_with uu___3
+             "Steel.ST.C.Types.struct_t0")
+            ||
+            (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             FStar_Compiler_Util.starts_with uu___3
+               "Steel.ST.C.Types.union_t0")
+          ->
+          let uu___3 =
+            let uu___4 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___4 in
+          TQualified uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
+          ->
+          let uu___1 =
+            let uu___2 = lident_of_typestring tag in
+            FStar_Compiler_Util.must uu___2 in
+          TQualified uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named
+          (uu___::arg::uu___1::uu___2::[], p) when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.C.Reference.ptr" ->
+          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
+          (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___1 = "Steel.ST.C.Types.ptr") ||
+            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___1 = "Steel.ST.C.Types.array_ref")
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.ST.C.Types.scalar_t" ->
+          translate_type_without_decay env1 arg
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
+          (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___ = "Steel.C.Array.Base.array_view_type_sized") ||
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.ST.C.Types.base_array_t")
+          ->
+          let uu___ =
+            let uu___1 = translate_type_without_decay env1 t1 in
+            let uu___2 =
+              let uu___3 =
+                let uu___4 =
+                  let uu___5 = int_of_typenat n in
+                  FStar_Compiler_Util.must uu___5 in
+                FStar_Compiler_Util.string_of_int uu___4 in
+              (UInt32, uu___3) in
+            (uu___1, uu___2) in
+          TArray uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -888,7 +1070,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1108,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1182,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1202,36 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
+          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
+      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
+          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___1 = "Steel.C.Array.Base.array_view_type" ->
+          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
+      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1691,6 +1895,66 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Array.Base.malloc_from") || false
+          ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 e1 in
+            let uu___8 = translate_expr env1 e2 in
+            (ManuallyManaged, uu___7, uu___8) in
+          EBufCreate uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.C.Opt.malloc") || false
+          ->
+          let uu___5 =
+            let uu___6 = translate_expr env1 e1 in
+            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
+          EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.ST.C.Types.alloc") || false
+          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1784,11 +2048,48 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.rfree") ||
+          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___5 = "FStar.Buffer.rfree") ||
+             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "Steel.C.Opt.free"))
+            ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::uu___5::uu___6::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.C.Array.Base.free_from") || false
+          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.free" ->
+          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2514,6 +2815,554 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::e1::uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.is_null_from" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Reference.is_null" ->
+          let uu___8 = translate_type env1 t in
+          let uu___9 = translate_expr env1 e1 in
+          generate_is_null uu___8 uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4::uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.is_null" ->
+          let uu___7 = translate_type env1 t in
+          let uu___8 = translate_expr env1 e1 in
+          generate_is_null uu___7 uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.C.Array.Base.null_from" ->
+          let uu___5 = translate_type env1 t in EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::[])
+          when
+          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___6 = "Steel.C.Reference.null") ||
+            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.ST.C.Types.null")
+          -> let uu___6 = translate_type env1 t in EBufNull uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5)
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::uu___4::struct_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_},
+           uu___7::uu___8::{
+                             FStar_Extraction_ML_Syntax.expr =
+                               FStar_Extraction_ML_Syntax.MLE_Const
+                               (FStar_Extraction_ML_Syntax.MLC_String
+                               field_name);
+                             FStar_Extraction_ML_Syntax.mlty = uu___9;
+                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
+          when
+          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+          let uu___11 =
+            let uu___12 =
+              let uu___13 =
+                let uu___14 =
+                  let uu___15 = lident_of_typestring struct_name in
+                  FStar_Compiler_Util.must uu___15 in
+                TQualified uu___14 in
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = translate_expr env1 r in
+                  (uu___16, (EConstant (UInt32, "0"))) in
+                EBufRead uu___15 in
+              (uu___13, uu___14, field_name) in
+            EField uu___12 in
+          EAddrOf uu___11
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String struct_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___5;
+             FStar_Extraction_ML_Syntax.loc = uu___6;_}::uu___7::uu___8::r::
+           {
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Const
+               (FStar_Extraction_ML_Syntax.MLC_String field_name);
+             FStar_Extraction_ML_Syntax.mlty = uu___9;
+             FStar_Extraction_ML_Syntax.loc = uu___10;_}::uu___11::[])
+          when
+          ((let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___12 = "Steel.ST.C.Types.struct_field0") ||
+             (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___12 = "Steel.ST.C.Types.union_field0"))
+            ||
+            (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___12 = "Steel.ST.C.Types.union_switch_field0")
+          ->
+          let uu___12 =
+            let uu___13 =
+              let uu___14 =
+                let uu___15 =
+                  let uu___16 = lident_of_string struct_name in
+                  FStar_Compiler_Util.must uu___16 in
+                TQualified uu___15 in
+              let uu___15 =
+                let uu___16 =
+                  let uu___17 = translate_expr env1 r in
+                  (uu___17, (EQualified (["C"], "_zero_for_deref"))) in
+                EBufRead uu___16 in
+              (uu___14, uu___15, field_name) in
+            EField uu___13 in
+          EAddrOf uu___12
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 = lident_of_typestring union_name in
+                  FStar_Compiler_Util.must uu___13 in
+                TQualified uu___12 in
+              let uu___12 =
+                let uu___13 =
+                  let uu___14 = translate_expr env1 r in
+                  (uu___14, (EConstant (UInt32, "0"))) in
+                EBufRead uu___13 in
+              (uu___11, uu___12, field_name) in
+            EField uu___10 in
+          EAddrOf uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::union_name::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::{
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_Const
+                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
+                     FStar_Extraction_ML_Syntax.mlty = uu___7;
+                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
+          let uu___9 =
+            let uu___10 =
+              let uu___11 =
+                let uu___12 =
+                  let uu___13 =
+                    let uu___14 = lident_of_typestring union_name in
+                    FStar_Compiler_Util.must uu___14 in
+                  TQualified uu___13 in
+                let uu___13 =
+                  let uu___14 =
+                    let uu___15 = translate_expr env1 r in
+                    (uu___15, (EConstant (UInt32, "0"))) in
+                  EBufRead uu___14 in
+                (uu___12, uu___13, field_name) in
+              EField uu___11 in
+            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
+          EAssign uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_read_sel" ->
+          let uu___6 =
+            let uu___7 = translate_expr env1 r in
+            (uu___7, (EConstant (UInt32, "0"))) in
+          EBufRead uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.C.Opt.opt_write_sel" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EConstant (UInt32, "0"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.C.Types.read0" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::x::[])
+          when
+          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___6 = "Steel.ST.C.Types.write" ->
+          let uu___6 =
+            let uu___7 =
+              let uu___8 =
+                let uu___9 = translate_expr env1 r in
+                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
+              EBufRead uu___8 in
+            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
+          EAssign uu___6
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::uu___7::uu___8::r::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.ST.C.Types.array_ref_of_base" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EQualified (["C"], "_zero_for_deref"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::a::uu___7::i::[])
+          when
+          (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___8 = "Steel.ST.C.Types.array_ref_cell") ||
+            (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.ST.C.Types.array_ref_split")
+          ->
+          let uu___8 =
+            let uu___9 = translate_expr env1 a in
+            let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+          EBufSub uu___8
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::r::uu___6::uu___7::[])
+          when
+          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::r::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+          translate_expr env1 r
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::uu___7::r::uu___8::[])
+          when
+          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
+          let uu___9 =
+            let uu___10 = translate_expr env1 r in
+            (uu___10, (EConstant (UInt32, "0"))) in
+          EBufRead uu___9
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.index_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
+          EBufRead uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           r::uu___6::i::x::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.upd_from" ->
+          let uu___7 =
+            let uu___8 = translate_expr env1 r in
+            let uu___9 = translate_expr env1 i in
+            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
+          EBufWrite uu___7
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2::uu___3::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___4;
+             FStar_Extraction_ML_Syntax.loc = uu___5;_},
+           uu___6::a::i::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.C.Array.Base.split_right_from" ->
+          let uu___7 =
+            let uu___8 =
+              let uu___9 = translate_expr env1 a in
+              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
+            EBufRead uu___8 in
+          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,6 +3776,72 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
+let (parse_steel_c_fields :
+  env ->
+    FStar_Extraction_ML_Syntax.mlty ->
+      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun fields ->
+      let rec go fields1 =
+        match fields1 with
+        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.ST.C.Types.field_t_nil")
+            -> FStar_Pervasives_Native.Some []
+        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
+            when
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
+              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+               uu___ = "Steel.ST.C.Types.field_t_cons")
+            ->
+            let uu___ = string_of_typestring field in
+            opt_bind uu___
+              (fun field1 ->
+                 if field1 = ""
+                 then go fields2
+                 else
+                   (let uu___2 = go fields2 in
+                    opt_bind uu___2
+                      (fun fields3 ->
+                         FStar_Pervasives_Native.Some ((field1, t) ::
+                           fields3))))
+        | uu___ -> FStar_Pervasives_Native.None in
+      let uu___ = go fields in
+      match uu___ with
+      | FStar_Pervasives_Native.None ->
+          ((let uu___2 =
+              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
+            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
+              uu___2);
+           FStar_Pervasives_Native.None)
+      | FStar_Pervasives_Native.Some fields1 ->
+          (FStar_Compiler_Util.print_endline "Got fields:";
+           FStar_Compiler_List.fold_left
+             (fun uu___3 ->
+                fun uu___4 ->
+                  match uu___4 with
+                  | (field, ty) ->
+                      let uu___5 =
+                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
+                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
+             () fields1;
+           (let uu___3 =
+              FStar_Compiler_List.map
+                (fun uu___4 ->
+                   match uu___4 with
+                   | (field, ty) ->
+                       ((let uu___6 =
+                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
+                             ty in
+                         FStar_Compiler_Util.print1 "Translating %s.\n"
+                           uu___6);
+                        (let uu___6 = translate_type_without_decay env1 ty in
+                         (field, uu___6)))) fields1 in
+            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -2939,7 +3854,115 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (match ty with
+        (let define_struct tag fields =
+           FStar_Compiler_Util.print_endline "Parsing struct definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse struct tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                let uu___3 =
+                  let uu___4 =
+                    let uu___5 =
+                      FStar_Compiler_List.map
+                        (fun uu___6 ->
+                           match uu___6 with
+                           | (field, ty1) -> (field, (ty1, true))) fields1 in
+                    (p, [], Prims.int_zero, uu___5) in
+                  DTypeFlat uu___4 in
+                FStar_Pervasives_Native.Some uu___3) in
+         let define_union tag fields =
+           FStar_Compiler_Util.print_endline "Parsing union definition.";
+           (let uu___2 = lident_of_typestring tag in
+            match uu___2 with
+            | FStar_Pervasives_Native.None ->
+                ((let uu___4 =
+                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                  FStar_Compiler_Util.print1
+                    "Failed to parse union tag from %s.\n" uu___4);
+                 FStar_Pervasives_Native.None)
+            | FStar_Pervasives_Native.Some p ->
+                let fields1 =
+                  let uu___3 = parse_steel_c_fields env1 fields in
+                  FStar_Compiler_Util.must uu___3 in
+                FStar_Pervasives_Native.Some
+                  (DUntaggedUnion (p, [], Prims.int_zero, fields1))) in
+         match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.ST.C.Types.define_struct0" ->
+             define_struct tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named
+               (tag::fields::uu___6::uu___7::[], p)));_}
+             when
+             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.ST.C.Types.define_union0" ->
+             define_union tag fields
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
+               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
+             when
+             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
+             (FStar_Compiler_Util.print_endline "Parsing union definition.";
+              (let uu___7 = lident_of_typestring tag in
+               match uu___7 with
+               | FStar_Pervasives_Native.None ->
+                   ((let uu___9 =
+                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
+                     FStar_Compiler_Util.print1
+                       "Failed to parse struct tag from %s.\n" uu___9);
+                    FStar_Pervasives_Native.None)
+               | FStar_Pervasives_Native.Some p1 ->
+                   let fields1 =
+                     let uu___8 = parse_steel_c_fields env1 fields in
+                     FStar_Compiler_Util.must uu___8 in
+                   FStar_Pervasives_Native.Some
+                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From 9947816c4f72a46555e3f2da4591a0f307f1f6a5 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 11:03:26 -0700
Subject: [PATCH 443/513] split Steel.ST.C.Types into one module per C type
 construct

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  | 1085 +++++++
 ulib/experimental/Steel.ST.C.Types.Array.fsti |  791 +++++
 ulib/experimental/Steel.ST.C.Types.Base.fst   |  402 +++
 ulib/experimental/Steel.ST.C.Types.Base.fsti  |  251 ++
 ulib/experimental/Steel.ST.C.Types.Fields.fst |    6 +
 .../experimental/Steel.ST.C.Types.Fields.fsti |   56 +
 ulib/experimental/Steel.ST.C.Types.Scalar.fst |  132 +
 .../experimental/Steel.ST.C.Types.Scalar.fsti |   88 +
 .../Steel.ST.C.Types.Struct.Aux.fst           |  444 +++
 .../Steel.ST.C.Types.Struct.Aux.fsti          |    4 +
 ulib/experimental/Steel.ST.C.Types.Struct.fst |  115 +
 .../experimental/Steel.ST.C.Types.Struct.fsti |  334 +++
 ulib/experimental/Steel.ST.C.Types.Union.fst  |  511 ++++
 ulib/experimental/Steel.ST.C.Types.Union.fsti |  360 +++
 ulib/experimental/Steel.ST.C.Types.fst        | 2636 +----------------
 ulib/experimental/Steel.ST.C.Types.fsti       | 1855 ------------
 16 files changed, 4583 insertions(+), 4487 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Array.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Array.fsti
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Base.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Base.fsti
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Fields.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Fields.fsti
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Scalar.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Scalar.fsti
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Struct.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Struct.fsti
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Union.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Union.fsti
 delete mode 100644 ulib/experimental/Steel.ST.C.Types.fsti

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
new file mode 100644
index 00000000000..db8e4929f36
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -0,0 +1,1085 @@
+module Steel.ST.C.Types.Array
+open Steel.ST.GenElim
+friend Steel.ST.C.Types.Base
+friend Steel.ST.C.Types.Struct.Aux
+open Steel.ST.C.Types.Struct.Aux
+
+open Steel.C.Model.PCM
+
+/// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
+
+module GHR = Steel.ST.GhostHigherReference
+module R = Steel.ST.C.Model.Ref
+module HR = Steel.ST.HigherReference
+module FX = FStar.FunctionalExtensionality
+module A = Steel.ST.C.Model.Array
+
+let base_array_t'
+  (t: Type0)
+  (n: Ghost.erased array_size_t)
+: Tot Type0
+= A.array_pcm_carrier t (Ghost.hide (Ghost.reveal n))
+
+let base_array_t t _ n = base_array_t' t n
+
+[@@noextract_to "krml"] // proof-only
+let base_array_fd
+  (#t: Type)
+  (td: typedef t)
+  (n: Ghost.erased array_size_t)
+: Tot (field_description_gen_t (base_array_index_t n))
+= {
+    fd_nonempty = (let _ : base_array_index_t n = 0sz in ());
+    fd_type = A.array_range t (Ghost.hide (Ghost.reveal n));
+    fd_typedef = (fun _ -> td);
+  }
+
+[@@noextract_to "krml"]
+let base_array1 (#t: Type0) (td: typedef t) (n: Ghost.erased array_size_t) : Tot (typedef (base_array_t' t n)) = struct1 (base_array_fd td n)
+
+let base_array0 tn td n = base_array1 td n
+
+let base_array_index a i = a i
+
+let base_array_eq #_ #_ #n a1 a2 =
+  assert (a1 `FX.feq` a2 <==> (forall (i: base_array_index_t n) . a1 i == a2 i));
+  a1 `FX.feq` a2
+
+let mk_base_array _ n v = A.array_pcm_carrier_of_seq n v
+
+let mk_base_array_index _ _ _ _ = ()
+
+let base_array_fractionable a td = ()
+
+let base_array_mk_fraction a td p i = ()
+
+let base_array_index_unknown tn n td i = ()
+
+let base_array_index_uninitialized tn n td i = ()
+
+let base_array_index_full td x = ()
+
+let base_array_index_t' (n: Ghost.erased array_size_t) : Tot eqtype =
+  A.array_domain (Ghost.hide (Ghost.reveal n))
+
+let base_array_index_t'_eq
+  (n: array_size_t)
+: Lemma
+  (base_array_index_t n == base_array_index_t' n)
+  [SMTPat (base_array_index_t n)]
+= // syntactic equality of refinement types
+  assert (base_array_index_t n == base_array_index_t' n) by (FStar.Tactics.trefl ())
+
+let array_index_as_field_marker
+  (n: Ghost.erased array_size_t)
+  (i: SZ.t)
+  (j: base_array_index_t' n)
+: Tot (base_array_index_t' n)
+= j
+
+#set-options "--print_implicits"
+
+let base_array1_eq
+  (#t: Type)
+  (n: Ghost.erased array_size_t)
+  (td: typedef t)
+: Lemma
+  (ref (base_array1 td n) == ref (struct1 #(base_array_index_t' n) (base_array_fd td n)))
+//  [SMTPat (ref (base_array1 td n))]
+= () // assert (ref (base_array1 td n) == ref (struct1 #(base_array_index_t' n) (base_array_fd td n))) by (FStar.Tactics.trefl ())
+
+[@@__reduce__]
+let has_base_array_cell_as_struct_field0
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (j: base_array_index_t' n)
+  (r': ref td)
+: Tot vprop
+= has_struct_field1 #(base_array_index_t' n) #(base_array_fd td n) r (array_index_as_field_marker n i j) r'
+
+let has_base_array_cell_as_struct_field
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (j: base_array_index_t' n)
+  (r': ref td)
+: Tot vprop
+= has_base_array_cell_as_struct_field0 r i j r'
+
+[@@__reduce__]
+let has_base_array_cell0
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: Tot vprop
+= exists_ (fun j ->
+    has_base_array_cell_as_struct_field r i j r' `star`
+    pure (i == j)
+  )
+
+let has_base_array_cell1
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: Tot vprop
+= has_base_array_cell0 r i r'
+
+let has_base_array_cell
+  r i r'
+= has_base_array_cell0 r i r'
+
+let has_base_array_cell_post
+  r i r'
+= rewrite (has_base_array_cell r i r') (has_base_array_cell0 r i r');
+  let _ = gen_elim () in
+  rewrite (has_base_array_cell0 r i r') (has_base_array_cell r i r')
+
+let has_base_array_cell_dup'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: STGhostT unit opened
+    (has_base_array_cell1 r i r')
+    (fun _ -> has_base_array_cell1 r i r' `star` has_base_array_cell1 r i r')
+= rewrite (has_base_array_cell1 r i r') (has_base_array_cell0 r i r');
+  let _ = gen_elim () in
+  has_struct_field_dup'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ _;
+  rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r');
+  noop ();
+  rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r')
+
+let has_base_array_cell_dup
+  r i r'
+= has_base_array_cell_dup' r i r'
+
+let has_base_array_cell_inj'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2)
+    (fun _ -> has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
+= rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
+  let _ = gen_elim () in
+  let j = vpattern_replace (fun j -> has_base_array_cell_as_struct_field r i j _) in
+  rewrite (has_base_array_cell1 r i r2) (has_base_array_cell0 r i r2);
+  let _ = gen_elim () in
+  vpattern_rewrite (fun j' -> has_base_array_cell_as_struct_field r i j _ `star` has_base_array_cell_as_struct_field r i j' _) j;
+  has_struct_field_inj' #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ r1 r2;
+  rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2);
+  rewrite (has_base_array_cell0 r i r1) (has_base_array_cell1 r i r1)
+
+let has_base_array_cell_inj
+  r i r1 r2
+= has_base_array_cell_inj' r i r1 r2
+
+let has_base_array_cell_equiv_from'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r1 r2: ref (base_array1 td n))
+  (i: SZ.t)
+  (r': ref td)
+: STGhostT unit opened
+    (has_base_array_cell1 r1 i r' `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell1 r2 i r' `star` ref_equiv r1 r2)
+= rewrite (has_base_array_cell1 r1 i r') (has_base_array_cell0 r1 i r');
+  let _ = gen_elim () in
+  has_struct_field_equiv_from'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r1) _ r' (r2);
+  rewrite (has_base_array_cell0 r2 i r') (has_base_array_cell1 r2 i r')
+
+let has_base_array_cell_equiv_from
+  r1 r2 i r'
+= has_base_array_cell_equiv_from' r1 r2 i r'
+
+let has_base_array_cell_equiv_to'
+  (#opened: _)
+  (#t: Type)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (has_base_array_cell1 r i r1 `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
+= rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
+  let _ = gen_elim () in
+  has_struct_field_equiv_to' r _ r1 r2;
+  rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2)
+
+let has_base_array_cell_equiv_to
+  r i r1 r2
+= has_base_array_cell_equiv_to' r i r1 r2
+
+/// Array pointers (with decay)
+
+noeq
+type array_ref #t td = {
+  ar_base_size: Ghost.erased array_size_t;
+  ar_base: ref (base_array1 #t td ar_base_size);
+  ar_offset: SZ.t;
+  ar_prf: squash (SZ.v ar_offset <= SZ.v ar_base_size);
+}
+let array_ref_base_size ar = ar.ar_base_size
+let has_array_ref_base ar r = ar.ar_base == r
+let has_array_ref_base_inj ar r1 r2 = ()
+let array_ref_offset ar = ar.ar_offset
+let array_ref_base_offset_inj a1 r1 a2 r2 = ()
+
+let base_array_pcm_eq
+  (#t: Type)
+  (td: typedef t)
+  (n: Ghost.erased array_size_t)
+: Lemma
+  (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n)) == (base_array1 td n).pcm)
+  [SMTPat (base_array1 td n).pcm]
+= pcm0_ext (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n))) (base_array1 td n).pcm
+    (fun _ _ -> ())
+    (fun x1 x2 ->
+      assert (op (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n))) x1 x2 `FX.feq` op (base_array1 td n).pcm x1 x2)
+    )
+    (fun _ -> ())
+    ()
+
+[@@noextract_to "krml"] // proof-only
+let model_array_of_array
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (base: ref0_v (base_array1 td (dfst a).ar_base_size))
+: Tot (A.array base.base td.pcm)
+= let (| al, len |) = a in
+  {
+    base_len = Ghost.hide (Ghost.reveal al.ar_base_size);
+    base = base.ref;
+    offset = al.ar_offset;
+    len = len;
+    prf = ();
+  }
+
+[@@__reduce__]
+let array_pts_to0
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: Tot vprop
+= exists_ (fun br -> exists_ (fun p ->
+    HR.pts_to (dfst r).ar_base p br `star`
+    A.pts_to (model_array_of_array r br) v
+  ))
+
+let array_pts_to r v =
+  array_pts_to0 r v
+
+let array_pts_to_length r v =
+  rewrite (array_pts_to r v) (array_pts_to0 r v);
+  let _ = gen_elim () in
+  let _ = A.pts_to_length _ _ in
+  rewrite (array_pts_to0 r v) (array_pts_to r v)
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let ghost_array_of_base_focus
+  #_ #_ #_ #_ #td #v r a
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () w in
+  assert ((model_array_of_array a w').base == w.ref);
+  rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
+  assert (seq_of_base_array v `Seq.equal` A.seq_of_array_pcm_carrier v);
+  A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
+  A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array v);
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
+  rewrite (array_pts_to0 a (seq_of_base_array v)) (array_pts_to a (seq_of_base_array v))
+
+#pop-options
+
+let ghost_array_of_base
+  #_ #tn #_ #n #td #v r
+=
+  let al : array_ref td = {
+    ar_base_size = n;
+    ar_base = r;
+    ar_offset = 0sz;
+    ar_prf = ();
+  }
+  in
+  let a : (a: Ghost.erased (array td) { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
+  ghost_array_of_base_focus r a;
+  a
+
+[@@noextract_to "krml"] // primitive
+let array_of_base0
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to a (seq_of_base_array v))
+    (True)
+    (fun _ -> True)
+=
+  let al : array_ref td = {
+    ar_base_size = n;
+    ar_base = r;
+    ar_offset = 0sz;
+    ar_prf = ();
+  }
+  in
+  let a : (a: array td { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
+  ghost_array_of_base_focus r a;
+  return a
+
+let array_ref_of_base
+  #_ #tn #_ #n #td #v r
+=
+  let ar = array_of_base0 r in
+  let a : array_ref td = dfst ar in
+  return a
+
+#push-options "--z3rlimit 16 --split_queries"
+
+#restart-solver
+
+let base_array_index' (#t: Type0) (#n: array_size_t) (a: base_array_t' t n)
+(i: base_array_index_t n) : GTot t
+= a i
+
+let seq_of_base_array0
+  (#t: Type)
+  (#n: array_size_t)
+  (v: base_array_t' t n)
+: GTot (Seq.lseq t (SZ.v n))
+= Seq.init_ghost (SZ.v n) (fun i -> base_array_index' v (SZ.uint_to_t i))
+
+let has_array_of_base'
+  (#t: Type)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (a: array td)
+: GTot prop
+=   let (| al, len |) = a in
+    array_ref_base_size al == n /\
+    al.ar_base == r /\
+    array_ref_offset al == 0sz /\
+    Ghost.reveal len == n
+
+#pop-options
+
+#push-options "--z3rlimit 64"
+#restart-solver
+
+let unarray_of_base0
+  (#t: Type)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (Seq.seq t))
+  (r: ref (base_array1 td n))
+  (a: array td)
+: STGhost (Ghost.erased (base_array_t' t n)) opened
+    (array_pts_to a v)
+    (fun v' -> pts_to r v')
+    (
+      has_array_of_base' r a
+    )
+    (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array0 v')
+= rewrite (array_pts_to a v) (array_pts_to0 a v);
+  let _ = gen_elim () in
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
+  let ba = vpattern_replace (HR.pts_to _ _) in
+  let ba' : ref0_v (base_array1 td n) = coerce_eq () ba in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba');
+  let m = model_array_of_array a ba in
+  rewrite (A.pts_to _ _) (A.pts_to m v);
+  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = A.pts_to_elim_to_base m v in
+  let y' : Ghost.erased (base_array_t' t n) = Ghost.hide (Ghost.reveal y) in
+  rewrite (r_pts_to _ _) (r_pts_to ba'.ref (Ghost.reveal y'));
+  rewrite (pts_to0 r y') (pts_to r y');
+  y'
+
+#pop-options
+
+let unarray_of_base
+  #t #tn #_ #n #td #v r a
+= unarray_of_base0 r a
+
+(*
+let has_array_of_ref
+  r a
+= TD.type_of_token (dfst a).ar_base_size_token == unit /\
+  model_array_of_array a == A.g_array_of_ref (coerce _ (Some?.v r).ref)
+
+let has_array_of_ref_inj
+  r a1 a2
+= TD.type_of_token_inj (dfst a1).ar_base_size_token (dfst a2).ar_base_size_token;
+  TD.type_of_token_inj (Some?.v (dfst a1).ar_base).dest (Some?.v (dfst a2).ar_base).dest
+
+let ghost_array_of_ref_focus
+  #t #_ #td #v r a
+= let mr : R.ref td.pcm = (Some?.v r).ref in
+  rewrite_slprop (pts_to _ _) (R.pts_to mr v) (fun _ -> ());
+  let ma = A.ghost_array_of_ref mr in
+  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ())
+
+let ghost_array_of_ref
+  #t #_ #td #v r
+= let mr : R.ref td.pcm = (Some?.v r).ref in
+  let ma = A.g_array_of_ref mr in
+  let tok_unit = TD.get_token unit in
+  let tok_array = TD.get_token (A.array_pcm_carrier t 1sz) in
+  let ar = {
+    ar_base_size_token = tok_unit;
+    ar_base_size = 1sz;
+    ar_base = Some ({
+      dest = tok_array;
+      typedef = base_array0 unit td 1sz;
+      ref = coerce _ ma.base;
+    });
+    ar_offset = 0sz;
+  }
+  in
+  let res: (a: Ghost.erased (array td) { has_array_of_ref r a }) = Ghost.hide (| ar, Ghost.hide 1sz |) in
+  ghost_array_of_ref_focus r res;
+  res
+
+let array_ref_of_ref
+  #t #_ #td #v r
+= let mr : R.ref td.pcm = (Some?.v r).ref in
+  rewrite_slprop (pts_to _ _) (R.pts_to mr v) (fun _ -> ());
+  let ma = A.array_of_ref mr in
+  let tok_unit = TD.get_token unit in
+  let tok_array = TD.get_token (A.array_pcm_carrier t 1sz) in
+  let res = {
+    ar_base_size_token = tok_unit;
+    ar_base_size = 1sz;
+    ar_base = Some ({
+      dest = tok_array;
+      typedef = base_array0 unit td 1sz;
+      ref = coerce _ ma.base;
+    });
+    ar_offset = 0sz;
+  }
+  in
+  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ());
+  return res
+
+let unarray_of_ref = magic ()
+*)
+
+[@@noextract_to "krml"]
+let array_index_as_base_array_index_marker
+  (index: SZ.t)
+  (base_index: SZ.t)
+: Tot SZ.t
+= base_index
+
+[@@__reduce__]
+let has_array_cell0
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: Tot vprop
+= exists_ (fun (j: SZ.t) ->
+    has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r `star`
+    pure (
+      SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i /\
+      SZ.v i < SZ.v (dsnd a)
+    )
+  )
+
+let has_array_cell1
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: Tot vprop
+= has_array_cell0 a i r
+
+let has_array_cell
+  a i r
+= has_array_cell0 a i r
+
+let has_array_cell_post
+  a i r
+= rewrite (has_array_cell a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  rewrite (has_array_cell0 a i r) (has_array_cell a i r)
+
+let has_array_cell_has_base_array_cell
+  a i r br
+= rewrite (has_array_cell a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  let j = vpattern_replace_erased (fun j -> has_base_array_cell1 _ j r) in
+  rewrite (has_base_array_cell1 _ _ _) (has_base_array_cell br j r);
+  j
+
+let has_base_array_cell_has_array_cell
+  a i r br
+= let j : Ghost.erased SZ.t = Ghost.hide (i `SZ.sub` (dfst a).ar_offset) in
+  rewrite (has_base_array_cell br i r) (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker j i) r);
+  rewrite (has_array_cell0 a j r) (has_array_cell a j r);
+  j
+
+let has_array_cell_inj
+  #_ #_ #td a i r1 r2
+= has_array_cell_post a i r1;
+  let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
+  let j1 = has_array_cell_has_base_array_cell a i r1 br in
+  let j2 = has_array_cell_has_base_array_cell a i r2 br in
+  vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
+  has_base_array_cell_inj br j1 r1 r2;
+  let _ = has_base_array_cell_has_array_cell a j1 r1 br in
+  vpattern_rewrite (fun i -> has_array_cell _ i r1) i;
+  let _ = has_base_array_cell_has_array_cell a j1 r2 br in
+  vpattern_rewrite (fun i -> has_array_cell _ i r2) i
+  
+
+#restart-solver
+let struct_field_eq_cell
+  (#t: Type)
+  (td: typedef t)
+  (n: array_size_t)
+  (k: base_array_index_t n)
+: Lemma
+  (Steel.ST.C.Model.Struct.struct_field (struct_field_pcm (base_array_fd td n)) k == A.cell td.pcm n k)
+= // assert_norm (A.array_domain n == base_array_index_t n);
+  Steel.ST.C.Model.Struct.struct_field_ext #(A.array_domain n) #(A.array_range t n) (struct_field_pcm (base_array_fd td n)) (A.array_elements_pcm td.pcm n) (fun _ -> ()) k
+
+(*
+#push-options "--split_queries --z3rlimit 16"
+
+#restart-solver
+let has_array_cell_array_of_ref
+  #_ #td r a
+= assert_norm (SZ.v 0sz == 0);
+  assert_norm (SZ.v 1sz == 1);
+  A.ref_of_array_of_ref (Some?.v r).ref;
+  A.ref_of_array_of_ref_base (Some?.v r).ref;
+  assert (Ghost.reveal (dsnd a) == 1sz);
+  assert ((dfst a).ar_offset == 0sz);
+  struct_field_eq_cell td 1sz 0sz;
+  assert (has_base_array_cell0 (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` 0sz) r)
+
+#pop-options
+*)
+
+let has_struct_field1_intro
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+  (p: P.perm)
+  (w: ref0_v (struct1 fields))
+  (p': P.perm)
+  (w': ref0_v (fields.fd_typedef field))
+  ()
+: STGhost unit opened
+    (HR.pts_to r p w `star` HR.pts_to r' p' w')
+    (fun _ ->
+      has_struct_field1 r field r'
+    )
+    (
+      has_struct_field_gen fields w field w'
+    )
+    (fun _ -> True)
+= noop ();
+  rewrite
+    (has_struct_field0 r field r')
+    (has_struct_field1 r field r')
+
+let has_array_cell_drop
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (#p': P.perm)
+  (#b': ref0_v td)
+  (i: SZ.t)
+  (r: ref td)
+: STGhostT unit opened
+    (has_array_cell1 a i r `star`
+      HR.pts_to r p' b'
+    )
+    (fun _ -> has_array_cell1 a i r)
+= rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
+  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  let _ = gen_elim () in
+  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let _ = gen_elim () in
+  HR.gather p' r;
+  has_struct_field1_intro
+    #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
+  rewrite
+    (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r)
+    (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+  rewrite
+    (has_base_array_cell0 (dfst a).ar_base j r)
+    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+  rewrite
+    (has_array_cell0 a i r)
+    (has_array_cell a i r)
+
+let has_array_cell_elim
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#p: P.perm)
+  (a: array td)
+  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (i: SZ.t)
+  (r: ref td)
+: STGhost (Ghost.erased (ref0_v td)) opened
+    (has_array_cell1 a i r `star`
+      HR.pts_to (dfst a).ar_base p b
+    )
+    (fun b' -> has_array_cell1 a i r `star`
+      exists_ (fun p -> exists_ (fun p' ->
+        HR.pts_to (dfst a).ar_base p b `star`
+        HR.pts_to r p' b'
+    )))
+    True
+    (fun b' ->
+      let ar = model_array_of_array a b in
+      SZ.v i < SZ.v ar.len /\
+      b'.base == b.base /\
+      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+    )
+= 
+  rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
+  let _ = gen_elim () in
+  let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
+  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  let _ = gen_elim () in
+  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let _ = gen_elim () in
+  hr_gather b (dfst a).ar_base;
+  HR.share r;
+  HR.share (dfst a).ar_base;
+  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
+  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+  rewrite
+    (has_base_array_cell0 (dfst a).ar_base j r)
+    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+  rewrite
+    (has_array_cell0 a i r)
+    (has_array_cell a i r);
+  A.ref_of_array_eq (model_array_of_array a b) i;
+  struct_field_eq_cell td (dfst a).ar_base_size j';
+  let b' = vpattern_replace_erased (HR.pts_to r _) in
+  noop ();
+  b'
+
+let ghost_array_cell_focus
+  #_ #_ #td #s a i r
+= rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let r' = has_array_cell_elim a i r in
+  let _ = gen_elim () in
+  let _ = A.g_focus_cell _ _ i () in
+  rewrite (R.pts_to _ _) (R.pts_to r'.ref (Seq.index s (SZ.v i)));
+  rewrite (pts_to0 r (Seq.index s (SZ.v i))) (pts_to r (Seq.index s (SZ.v i)));
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
+  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td)))
+
+let has_array_cell_intro
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#p: P.perm)
+  (a: array td)
+  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (#p': P.perm)
+  (#b': ref0_v td)
+  (i: SZ.t)
+  (r: ref td)
+: STGhost unit opened
+    (HR.pts_to (dfst a).ar_base p b `star`
+      HR.pts_to r p' b'
+    )
+    (fun _ -> has_array_cell1 a i r)
+    (
+      let ar = model_array_of_array a b in
+      SZ.v i < SZ.v ar.len /\
+      b'.base == b.base /\
+      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+    )
+    (fun _ -> True)
+= 
+  A.ref_of_array_eq (model_array_of_array a b) i;
+  let j : base_array_index_t' (dfst a).ar_base_size = (dfst a).ar_offset `SZ.add` i in
+  struct_field_eq_cell td (dfst a).ar_base_size j;
+  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r _ _ _ _ ();
+  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j r);
+  rewrite
+    (has_base_array_cell0 (dfst a).ar_base j r)
+    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+  rewrite
+    (has_array_cell0 a i r)
+    (has_array_cell a i r)
+
+let ghost_array_cell
+  #_ #_ #td #s a i
+= array_pts_to_length _ _;
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  HR.share _;
+  rewrite (array_pts_to0 a s) (array_pts_to a s);
+  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let ar = model_array_of_array a b in
+  let b' = {
+    base = b.base;
+    ref = R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i);
+  }
+  in
+  let ghr = GHR.alloc b' in
+  GHR.reveal_pts_to ghr P.full_perm b';
+  let hr = GHR.reveal_ref ghr in
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to hr P.full_perm b');
+  HR.pts_to_not_null hr;
+  let r : (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
+  vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
+  has_array_cell_intro a i r;
+  let _ = ghost_array_cell_focus a i r in
+  noop ();
+  r
+
+[@@ noextract_to "krml"]
+let array_cell0
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
+    (array_pts_to a s)
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
+    (
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
+    )
+    (fun _ -> True)
+= array_pts_to_length _ _;
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  HR.share _;
+  rewrite (array_pts_to0 a s) (array_pts_to a s);
+  let b = HR.read (dfst a).ar_base in
+  vpattern_rewrite (HR.pts_to (dfst a).ar_base _) b;
+  let ar = model_array_of_array a b in
+  A.ref_of_array_eq ar i;
+  let b' = {
+    base = b.base;
+    ref = R.ref_focus ar.base (A.cell td.pcm ar.base_len (ar.offset `SZ.add`  i));
+  }
+  in
+  let hr = HR.alloc b' in
+  HR.pts_to_not_null hr;
+  let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
+  vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
+  has_array_cell_intro a i r;
+  let _ = ghost_array_cell_focus a i r in
+  noop ();
+  return r
+
+let array_ref_cell
+  #_ #td #s a len i
+= let r0 : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd ((| a, len |) <: array td)) }) = array_cell0 _ _ in
+  let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len }) = r0 in
+  vpattern_rewrite (fun r -> pts_to r _) r;
+  vpattern_rewrite (has_array_cell _ _) r;
+  noop ();
+  return r
+
+let ar_unfocus_cell
+  (#opened: _)
+  (#base_t #base_t': Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (s: Seq.seq t)
+  (i: SZ.t)
+  (r': R.ref base_t' p)
+  (v: t)
+  (sq: squash (SZ.v i < SZ.v r.len /\ SZ.v i < Seq.length s))
+: STGhost unit opened
+    (A.pts_to r s `star` R.pts_to r' v)
+    (fun _ -> A.pts_to r (Seq.upd s (SZ.v i) v))
+    (
+      base_t' == base_t /\
+      r' == R.ref_focus (A.ref_of_array r) (A.cell p r.len i) /\
+      Seq.index s (SZ.v i) == one p
+    )
+    (fun _ -> True)
+= let r1' : R.ref base_t p = coerce_eq () r' in
+  rewrite (R.pts_to r' v) (R.pts_to r1' v);
+  A.unfocus_cell r s i r1' v ()
+
+let unarray_cell
+  #_ #_ #td #s #v a i r
+= array_pts_to_length _ _;
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  let w = has_array_cell_elim a i r in
+  let _ = gen_elim () in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  hr_gather (Ghost.reveal w) r;
+  ar_unfocus_cell _ _ i _ _ ();
+  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
+  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v));
+  has_array_cell_drop _ _ _
+
+#push-options "--split_queries --z3rlimit 16"
+
+let t_array_ref_shift
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_ref td)
+  (i: SZ.t)
+: Pure (array_ref td)
+    (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
+    (ensures (fun y -> 
+      array_ref_base_size y == array_ref_base_size a /\
+      (forall ty r . has_array_ref_base a #ty r ==> has_array_ref_base y #ty (coerce_eq () r)) /\
+      array_ref_offset y == array_ref_offset a `SZ.add` i
+    ))
+= {
+    a with
+    ar_offset = a.ar_offset `SZ.add` i
+  }
+
+let array_ref_shift
+  a i
+= t_array_ref_shift a i
+
+let ghost_array_split
+  #_ #_ #td #s a i
+= array_pts_to_length _ _;
+  let sq : squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)) = () in
+  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = gen_elim () in
+  let br : Ghost.erased (ref0_v (base_array1 td (dfst a).ar_base_size)) = vpattern_replace_erased (HR.pts_to _ _) in
+  A.g_split _ _ i ();
+  HR.share _;
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
+  let br_l : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_l a i)).ar_base_size)) = coerce_eq () br in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_l a i)).ar_base p br_l);
+  rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
+  noop ();
+  rewrite (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)));
+  let br_r : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_r a i)).ar_base_size)) = coerce_eq () br in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_r a i)).ar_base p br_r);
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
+  noop ();
+  rewrite (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)));
+  sq
+
+let t_array_split_r
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+: Pure (array td)
+   (requires (SZ.v i <= SZ.v (dsnd a)))
+   (ensures (fun _ -> True))
+= let (| al, len |) = a in
+  (| t_array_ref_shift al i, Ghost.hide (len `SZ.sub` i) |)
+
+let array_ref_split
+  #_ #td #s al len i
+= let _ = ghost_array_split (| al, len |) i in
+  let ar: (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len}) = t_array_ref_shift al i in
+  return ar
+
+let hr_gather_by_perm
+  (#opened: _)
+  (#t1: Type)
+  (#r1: HR.ref t1)
+  (#v1: t1)
+  (#t2: Type)
+  (#r2: HR.ref t2)
+  (#v2: t2)
+  (p1: P.perm)
+  (p2: P.perm)
+: STGhost unit opened
+    (HR.pts_to r1 p1 v1 `star` HR.pts_to r2 p2 v2)
+    (fun _ -> HR.pts_to r1 (p1 `P.sum_perm` p2) v1)
+    (t1 == t2 /\
+      r1 == r2)
+    (fun _ ->
+      t1 == t2 /\
+      r1 == r2 /\
+      v1 == v2)
+= rewrite (HR.pts_to r2 p2 v2) (HR.pts_to r1 p2 (coerce_eq () v2));
+  HR.gather p2 r1
+
+let ar_join
+  (#opened: _)
+  (#base_t #base_tl #base_tr: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (a: A.array base_t p)
+  (i: SZ.t)
+  (al: A.array base_tl p)
+  (ar: A.array base_tr p)
+  (sl0 sr0: Seq.seq t)
+: STGhost unit opened
+    (A.pts_to al sl0 `star` A.pts_to ar sr0)
+    (fun _ -> A.pts_to a (sl0 `Seq.append` sr0))
+    (
+      SZ.v i <= SZ.v a.len /\
+      base_t == base_tl /\
+      base_t == base_tr /\
+      al == A.split_l a i /\
+      ar == A.split_r a i
+    )
+    (fun _ -> True)
+= let al' : A.array base_t p = coerce_eq () al in
+  let ar' : A.array base_t p = coerce_eq () ar in
+  rewrite (A.pts_to al sl0) (A.pts_to al' sl0);
+  rewrite (A.pts_to ar sr0) (A.pts_to ar' sr0);
+  A.join a i al' ar' _ _
+
+let array_join
+  #_ #_ #td #sl #sr a al ar i
+= rewrite (array_pts_to al sl) (array_pts_to0 al sl);
+  let _ = gen_elim () in
+  let br_l : ref0_v (base_array1 td (dfst al).ar_base_size) = vpattern_replace (HR.pts_to _ _) in
+  let pl = vpattern_replace (fun p -> HR.pts_to _ p _) in
+  let br : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () br_l in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base pl br);
+  rewrite (array_pts_to ar sr) (array_pts_to0 ar sr);
+  let _ = gen_elim () in
+  let pr = vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
+  hr_gather_by_perm pl pr;
+  ar_join (model_array_of_array a br) i _ _ sl sr;
+  rewrite (array_pts_to0 a (sl `Seq.append` sr)) (array_pts_to a (sl `Seq.append` sr))
+
+let ar_share
+  (#opened: _)
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (s s1 s2: Seq.seq t)
+  (prf: (
+    (i: nat) ->
+    Lemma
+    (requires (i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2))
+    (ensures (
+      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
+      composable p (Seq.index s1 i) (Seq.index s2 i) /\
+      op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+    ))
+  ))
+: STGhost unit opened
+    (A.pts_to r s)
+    (fun _ -> A.pts_to r s1 `star` A.pts_to r s2)
+    (
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s
+    )
+    (fun _ -> True)
+= Classical.forall_intro (Classical.move_requires prf);
+  A.share r s s1 s2
+
+let mk_fraction_seq_split_gen
+  #_ #_ #td r v p p1 p2
+= rewrite (array_pts_to r (mk_fraction_seq td v p)) (array_pts_to0 r (mk_fraction_seq td v p));
+  let _ = gen_elim () in
+  let br = vpattern_replace (HR.pts_to _ _) in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p));
+  ar_share _ _ (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
+    td.mk_fraction_split (Seq.index v i) p1 p2;
+    td.mk_fraction_join (Seq.index v i) p1 p2
+  );
+  HR.share _;
+  rewrite (array_pts_to0 r (mk_fraction_seq td v p1)) (array_pts_to r (mk_fraction_seq td v p1));
+  rewrite (array_pts_to0 r (mk_fraction_seq td v p2)) (array_pts_to r (mk_fraction_seq td v p2))
+
+let ar_gather
+  (#opened: _)
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: A.array base_t p)
+  (s s1 s2: Seq.seq t)
+  (prf: (
+    (i: nat) ->
+    Lemma
+    (requires (
+      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
+      composable p (Seq.index s1 i) (Seq.index s2 i)
+    ))
+    (ensures (
+      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
+      composable p (Seq.index s1 i) (Seq.index s2 i) /\
+      op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+    ))
+  ))
+: STGhost unit opened
+    (A.pts_to r s1 `star` A.pts_to r s2)
+    (fun _ -> A.pts_to r s)
+    (
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s
+    )
+    (fun _ -> True)
+= Classical.forall_intro (Classical.move_requires prf);
+  A.gather r s s1 s2
+
+let mk_fraction_seq_join
+  #_ #_ #td r v p1 p2
+= rewrite (array_pts_to r (mk_fraction_seq td v p1)) (array_pts_to0 r (mk_fraction_seq td v p1));
+  let _ = gen_elim () in
+  let br = vpattern_replace (HR.pts_to _ _) in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
+  rewrite (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2));
+  let _ = gen_elim () in
+  hr_gather br (dfst r).ar_base;
+  rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
+  ar_gather _ (mk_fraction_seq td v (p1 `P.sum_perm` p2)) (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
+    td.mk_fraction_join (Seq.index v i) p1 p2
+  );
+  rewrite (array_pts_to0 r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
new file mode 100644
index 00000000000..248bf5bd22e
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -0,0 +1,791 @@
+module Steel.ST.C.Types.Array
+open Steel.ST.Util
+include Steel.ST.C.Types.Base
+open Steel.C.Typenat
+
+module P = Steel.FractionalPermission
+module SZ = FStar.SizeT
+
+// To be extracted as: t[tn]
+// Per the C standard, base array types must be of nonzero size
+inline_for_extraction [@@noextract_to "krml"]
+let array_size_t = (n: SZ.t { SZ.v n > 0 })
+val base_array_t (t: Type0) (tn: Type0 (* using Typenat (or Typestring for `#define`d constants) *)) (n: array_size_t) : Type0
+inline_for_extraction [@@noextract_to "krml"] // MUST be syntactically equal to Steel.C.Model.Array.array_domain
+let base_array_index_t (n: array_size_t) : Tot eqtype = (i: SZ.t { SZ.v i < SZ.v n })
+[@@noextract_to "krml"]
+val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: array_size_t) : Tot (typedef (base_array_t t tn n))
+
+inline_for_extraction
+[@@noextract_to "krml"] // proof-only
+let base_array (#t: Type0) (#tn: Type0) (td: typedef t) (n: nat {SZ.fits n /\ n > 0}) (# [solve_nat_t_of_nat ()] prf: squash (norm norm_typenat (nat_t_of_nat n == tn))) : Tot (typedef (base_array_t t tn (SZ.uint_to_t n)))
+= base_array0 tn td (SZ.uint_to_t n)
+
+val base_array_index (#t: Type0) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (i: base_array_index_t n) : GTot t
+val base_array_eq (#t: Type0) (#tn: Type0) (#n: array_size_t) (a1 a2: base_array_t t tn n) : Ghost prop
+  (requires True)
+  (ensures (fun y ->
+    (y <==> (a1 == a2)) /\
+    (y <==> (forall (i: base_array_index_t n) . base_array_index a1 i == base_array_index a2 i))
+  ))
+val mk_base_array (#t: Type) (tn: Type0) (n: array_size_t) (v: Seq.seq t) : Ghost (base_array_t t tn n)
+  (requires (
+    Seq.length v == SZ.v n
+  ))
+  (ensures (fun y -> True))
+val mk_base_array_index (#t: Type) (tn: Type) (n: array_size_t) (v: Seq.seq t) (i: base_array_index_t n) : Lemma
+  (requires (Seq.length v == SZ.v n))
+  (ensures (
+    Seq.length v == SZ.v n /\
+    base_array_index (mk_base_array tn n v) i == Seq.index v (SZ.v i)
+  ))
+  [SMTPat (base_array_index (mk_base_array tn n v) i)]
+
+let mk_base_array_inj  (#t: Type) (tn: Type0) (n: array_size_t) (v1 v2: Seq.seq t) : Lemma
+  (requires (
+    Seq.length v1 == SZ.v n /\
+    Seq.length v2 == SZ.v n /\
+    mk_base_array tn n v1 == mk_base_array tn n v2
+  ))
+  (ensures (v1 == v2))
+  [SMTPat (mk_base_array tn n v1); SMTPat (mk_base_array tn n v2)]
+= assert (forall (i: nat) . i < SZ.v n ==> base_array_index (mk_base_array tn n v1) (SZ.uint_to_t i) == base_array_index (mk_base_array tn n v2) (SZ.uint_to_t i));
+  assert (v1 `Seq.equal` v2)
+val base_array_fractionable (#t: Type) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (td: typedef t) : Lemma
+  (
+    fractionable (base_array0 tn td n) a <==>
+      (forall (i: base_array_index_t n) . fractionable td (base_array_index a i))
+  )
+  [SMTPat (fractionable (base_array0 tn td n) a)]
+val base_array_mk_fraction   (#t: Type) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (td: typedef t) (p: P.perm) (i: base_array_index_t n) : Lemma
+  (requires (
+    fractionable (base_array0 tn td n) a
+  ))
+  (ensures (
+    fractionable (base_array0 tn td n) a /\
+    base_array_index (mk_fraction (base_array0 tn td n) a p) i == mk_fraction td (base_array_index a i) p
+  ))
+  [SMTPat (base_array_index (mk_fraction (base_array0 tn td n) a p) i)]
+
+val base_array_index_unknown (#t: Type) (tn: Type0) (n: array_size_t) (td: typedef t) (i: base_array_index_t n) : Lemma
+  (base_array_index (unknown (base_array0 tn td n)) i == unknown td)
+  [SMTPat (base_array_index (unknown (base_array0 tn td n)) i)]
+
+val base_array_index_uninitialized (#t: Type) (tn: Type0) (n: array_size_t) (td: typedef t) (i: base_array_index_t n) : Lemma
+  (base_array_index (uninitialized (base_array0 tn td n)) i == uninitialized td)
+  [SMTPat (base_array_index (uninitialized (base_array0 tn td n)) i)]
+
+val base_array_index_full (#t: Type) (#tn: Type0) (#n: array_size_t) (td: typedef t) (x: base_array_t t tn n) : Lemma
+  (full (base_array0 tn td n) x <==> (forall (i: base_array_index_t n) . full td (base_array_index x i)))
+  [SMTPat (full (base_array0 tn td n) x)]
+
+val has_base_array_cell
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: Tot vprop
+
+val has_base_array_cell_post
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: STGhost unit opened
+    (has_base_array_cell r i r')
+    (fun _ -> has_base_array_cell r i r')
+    (True)
+    (fun _ -> SZ.v i < SZ.v n)
+
+val has_base_array_cell_dup
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: STGhostT unit opened
+    (has_base_array_cell r i r')
+    (fun _ -> has_base_array_cell r i r' `star` has_base_array_cell r i r')
+
+val has_base_array_cell_inj
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (has_base_array_cell r i r1 `star` has_base_array_cell r i r2)
+    (fun _ -> has_base_array_cell r i r1 `star` has_base_array_cell r i r2 `star` ref_equiv r1 r2)
+
+val has_base_array_cell_equiv_from
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r1 r2: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r': ref td)
+: STGhostT unit opened
+    (has_base_array_cell r1 i r' `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell r2 i r' `star` ref_equiv r1 r2)
+
+val has_base_array_cell_equiv_to
+  (#opened: _)
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (i: SZ.t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (has_base_array_cell r i r1 `star` ref_equiv r1 r2)
+    (fun _ -> has_base_array_cell r i r2 `star` ref_equiv r1 r2)
+
+// contrary to array fields, one is not supposed to take an array cell directly from a base array. one should use arrays instead
+
+// To be extracted to: t*  (array type decays to pointer type)
+
+// We still want to prove that cutting off some cell range on the
+// right-hand end of an array won't change the C pointer to which an
+// array extracts to. This is why we separately introduce `array_ref`
+// to represent the "base+offset" pointer, and `array` which holds the
+// ghost length of an array.
+
+[@@noextract_to "krml"] // primitive
+val array_ref (#t: Type) (td: typedef t) : Tot Type0
+(*
+val array_ref_base_size_type (#t: Type) (#td: typedef t) (a: array_ref td) : GTot Type0
+*)
+val array_ref_base_size (#t: Type) (#td: typedef t) (a: array_ref td) : GTot array_size_t
+val has_array_ref_base (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r: ref (base_array0 ty td (array_ref_base_size a))) : GTot prop
+val has_array_ref_base_inj (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r1 r2: ref (base_array0 ty td (array_ref_base_size a))) : Lemma
+  (requires (has_array_ref_base a r1 /\ has_array_ref_base a r2))
+  (ensures (r1 == r2))
+val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ref td) : Ghost SZ.t
+  (requires True)
+  (ensures (fun y -> SZ.v y <= SZ.v (array_ref_base_size a)))
+val array_ref_base_offset_inj (#t: Type) (#td: typedef t) (#ty: Type) (a1: array_ref td) (r1: ref (base_array0 ty td (array_ref_base_size a1))) (a2: array_ref td) (r2: ref (base_array0 ty td (array_ref_base_size a2))) : Lemma
+  (requires (
+    array_ref_base_size a1 == array_ref_base_size a2 /\
+    has_array_ref_base a1 r1 /\
+    has_array_ref_base a2 r2 /\
+    r1 == coerce_eq () r2 /\
+    array_ref_offset a1 == array_ref_offset a2
+  ))
+  (ensures (a1 == a2))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
+  (len: Ghost.erased SZ.t { SZ.v (array_ref_offset r) + SZ.v len <= SZ.v (array_ref_base_size r) })
+
+inline_for_extraction [@@noextract_to "krml"]
+let array (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ref td & array_len_t r)
+
+let array_length
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+: GTot nat
+= SZ.v (dsnd a)
+
+val array_pts_to
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: Tot vprop
+
+val array_pts_to_length
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: STGhost unit opened
+    (array_pts_to r v)
+    (fun _ -> array_pts_to r v)
+    (True)
+    (fun _ -> Seq.length v == SZ.v (dsnd r))
+
+#set-options "--print_implicits"
+
+let has_array_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (a: array td)
+: GTot prop
+=   let (| al, len |) = a in
+    array_ref_base_size al == n /\
+    has_array_ref_base al #tn r /\
+    array_ref_offset al == 0sz /\
+    Ghost.reveal len == n
+
+let has_array_of_base_inj
+  (#t: Type)
+  (#tn: Type0)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array0 tn td n))
+  (a1 a2: array td)
+: Lemma
+  (requires (
+      has_array_of_base #t #tn #n #td r a1 /\
+      has_array_of_base #t #tn #n #td r a2
+  ))
+  (ensures (a1 == a2))
+= let (| ar1, _ |) = a1 in
+  let (| ar2, _ |) = a2 in
+  array_ref_base_offset_inj #t #td #tn ar1 r ar2 r
+
+let seq_of_base_array
+  (#t: Type)
+  (#tn: Type)
+  (#n: array_size_t)
+  (v: base_array_t t tn n)
+: GTot (Seq.lseq t (SZ.v n))
+= Seq.init_ghost (SZ.v n) (fun i -> base_array_index v (SZ.uint_to_t i))
+
+val ghost_array_of_base_focus
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+  (a: array td)
+: STGhost unit opened
+    (pts_to r v)
+    (fun _ -> array_pts_to a (seq_of_base_array v))
+    (has_array_of_base r a)
+    (fun _ -> True)
+
+val ghost_array_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: STGhostT (a: Ghost.erased (array td) { has_array_of_base r a }) opened
+    (pts_to r v)
+    (fun a -> array_pts_to a (seq_of_base_array v))
+
+let array_ref_of_base_post
+  (#t: Type)
+  (#tn: Type0)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+  (a: array_ref td)
+  (ar: array td)
+: GTot prop
+=
+       dfst ar == a /\
+        array_ref_base_size a == Ghost.reveal n /\
+        array_ref_offset a == 0sz /\
+        has_array_of_base r ar /\
+        Ghost.reveal (dsnd ar) == Ghost.reveal n
+ 
+// to be extracted to just r
+[@@noextract_to "krml"] // primitive
+val array_ref_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: STAtomicBase (array_ref td) false opened Unobservable
+    (pts_to r v)
+    (fun a -> exists_ (fun (ar: array td) ->
+      array_pts_to ar (seq_of_base_array v) `star` pure (
+      array_ref_of_base_post v r a ar
+    )))
+    (True)
+    (fun _ -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t t tn n))
+  (r: ref (base_array0 tn td n))
+: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+    (pts_to r v)
+    (fun a -> array_pts_to a (seq_of_base_array v))
+    (True)
+    (fun _ -> True)
+= let al = array_ref_of_base r in
+  let _ = elim_exists () in
+  elim_pure _;
+  let a = (| al, Ghost.hide (n <: SZ.t) |) in
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
+  return a
+
+val unarray_of_base
+  (#t: Type)
+  (#tn: Type0)
+  (#opened: _)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (Seq.seq t))
+  (r: ref (base_array0 tn td n))
+  (a: array td)
+: STGhost (Ghost.erased (base_array_t t tn n)) opened
+    (array_pts_to a v)
+    (fun v' -> pts_to r v')
+    (
+      has_array_of_base r a
+    )
+    (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
+
+(*
+val has_array_of_ref
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a: array td)
+: Tot vprop
+
+val has_array_of_ref_post
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a: array td)
+: STGhost unit opened
+    (has_array_of_ref r a)
+    (fun _ -> has_array_of_ref r a)
+    (True)
+    (fun _ ->
+      let (| al, len |) = a in
+      array_ref_base_size al == 1sz /\
+      array_ref_offset al == 0sz /\
+      Ghost.reveal len == 1sz
+    )
+
+// val has_array_of_ref_inj
+//   (#t: Type)
+//   (#td: typedef t)
+//   (r: ref td)
+//   (a1 a2: array td)
+// : Lemma
+//     (requires (
+//       has_array_of_ref r a1 /\
+//       has_array_of_ref r a2
+//     ))
+//     (ensures a1 == a2)
+
+val ghost_array_of_ref_focus
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+  (a: array td)
+: STGhostT unit opened
+    (pts_to r v `star` has_array_of_ref r a)
+    (fun _ -> has_array_of_ref r a `star` array_pts_to a (Seq.create 1 (Ghost.reveal v)))
+
+val ghost_array_of_ref
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: STGhostT (Ghost.erased (array td)) opened
+    (pts_to r v)
+    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
+
+// to be extracted to just r
+[@@noextract_to "krml"] // primitive
+val array_ref_of_ref
+  (#t: Type)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: STT (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz })
+    (pts_to r v)
+    (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r (| a, Ghost.hide 1sz |))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_of_ref
+  (#t: Type)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: STT (array td)
+    (pts_to r v)
+    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
+= let al = array_ref_of_ref r in
+  let a : array td = (| al, Ghost.hide 1sz |) in
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
+  rewrite (has_array_of_ref _ _) (has_array_of_ref r a);
+  return a
+
+val unarray_of_ref
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (r: ref td)
+  (a: array td)
+: STGhostT (squash (Seq.length s == 1)) opened
+    (array_pts_to a s `star` has_array_of_ref r a)
+    (fun _ -> pts_to r (Seq.index s 0) `star` has_array_of_ref r a)
+*)
+
+val has_array_cell
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: Tot vprop
+(*
+= SZ.v i < SZ.v (dsnd a) /\
+  has_base_array_cell (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r
+*)
+
+val has_array_cell_post
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r': ref td)
+: STGhost unit opened
+    (has_array_cell a i r')
+    (fun _ -> has_array_cell a i r')
+    (True)
+    (fun _ -> SZ.v i < SZ.v (dsnd a))
+
+val has_array_cell_has_base_array_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+  (#ty: Type)
+  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
+: STGhost (Ghost.erased SZ.t) opened
+    (has_array_cell a i r)
+    (fun j -> has_base_array_cell br j r)
+    (has_array_ref_base (dfst a) br)
+    (fun j ->
+      SZ.v j == SZ.v (array_ref_offset (dfst a)) + SZ.v i
+    )
+
+val has_base_array_cell_has_array_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+  (#ty: Type)
+  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
+: STGhost (Ghost.erased SZ.t) opened
+    (has_base_array_cell br i r)
+    (fun j -> has_array_cell a j r)
+    (has_array_ref_base (dfst a) br /\
+      SZ.v i >= SZ.v (array_ref_offset (dfst a)) /\
+      SZ.v i < SZ.v (array_ref_offset (dfst a)) + SZ.v (dsnd a)
+    )
+    (fun j ->
+      SZ.v i == SZ.v (array_ref_offset (dfst a)) + SZ.v j
+    )
+
+val has_array_cell_inj
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (
+      has_array_cell a i r1 `star`
+      has_array_cell a i r2
+    )
+    (fun _ ->
+      has_array_cell a i r1 `star`
+      has_array_cell a i r2 `star`
+      ref_equiv r1 r2
+    )
+// = has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
+
+(*
+val has_array_cell_array_of_ref
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (a: array td)
+: SteelGhostT unit opened
+    (has_array_of_ref r a)
+    (fun _ -> has_array_of_ref r a `star` has_array_cell a 0sz r)
+*)
+
+val ghost_array_cell_focus
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: STGhostT (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s `star` has_array_cell a i r)
+    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
+
+val ghost_array_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: STGhost (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) opened
+    (array_pts_to a s)
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
+    (
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
+    )
+    (fun _ -> True)
+
+[@@noextract_to "krml"] // primitive
+val array_ref_cell
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array_ref td)
+  (len: array_len_t a)
+  (i: SZ.t)
+: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len })
+    (array_pts_to (| a, len |) s)
+    (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell (| a, len |) i r)
+    (
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v len)
+    )
+    (fun _ -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_cell
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
+    (array_pts_to a s)
+    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
+    (
+      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
+    )
+    (fun _ -> True)
+= let (| al, len |) = a in
+  rewrite (array_pts_to _ _) (array_pts_to _ s);
+  let r = array_ref_cell al len i in
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
+  rewrite (has_array_cell _ _ _) (has_array_cell a i r);
+  return r
+
+val unarray_cell
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (#v: Ghost.erased t)
+  (a: array td)
+  (i: SZ.t)
+  (r: ref td)
+: STGhost (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s `star` pts_to r v `star` has_array_cell a i r)
+    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) v) `star` has_array_cell a i r)
+    (
+      (SZ.v i < Seq.length s ==> Seq.index s (SZ.v i) == unknown td)
+    )
+    (fun _ -> True)
+
+val array_ref_shift
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_ref td)
+  (i: SZ.t)
+: Ghost (array_ref td)
+    (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
+    (ensures (fun y -> 
+      array_ref_base_size y == array_ref_base_size a /\
+      (forall ty r . has_array_ref_base a #ty r ==> has_array_ref_base y #ty (coerce_eq () r)) /\
+      array_ref_offset y == array_ref_offset a `SZ.add` i
+    ))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_split_l
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+: Pure (array td)
+   (requires (SZ.v i <= SZ.v (dsnd a)))
+   (ensures (fun _ -> True))
+= let (| al, _ |) = a in
+  (| al, Ghost.hide i |)
+
+let array_split_r
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (i: SZ.t)
+: Ghost (array td)
+   (requires (SZ.v i <= SZ.v (dsnd a)))
+   (ensures (fun _ -> True))
+= let (| al, len |) = a in
+  (| array_ref_shift al i, Ghost.hide (len `SZ.sub` i) |)
+
+val ghost_array_split
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: STGhost (squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a))) opened
+    (array_pts_to a s)
+    (fun _ -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
+      array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)))
+    (SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
+    (fun _ -> True)
+
+[@@noextract_to "krml"] // primitive
+val array_ref_split
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (al: array_ref td)
+  (len: array_len_t al)
+  (i: SZ.t)
+: ST (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len})
+    (array_pts_to (| al, len |) s)
+    (fun _ -> array_pts_to (array_split_l (| al, len |) i) (Seq.slice s 0 (SZ.v i)) `star`
+      array_pts_to (array_split_r (| al, len |) i) (Seq.slice s (SZ.v i) (Seq.length s)))
+    (SZ.v i <= SZ.v len \/ SZ.v i <= Seq.length s)
+    (fun ar -> ar == dfst (array_split_r (| al, len |) i))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_split
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+  (i: SZ.t)
+: ST (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)})
+    (array_pts_to a s)
+    (fun a' -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
+      array_pts_to a' (Seq.slice s (SZ.v i) (Seq.length s)))
+    (SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
+    (fun a' -> a' == array_split_r a i)
+= let (| al, len |) = a in
+  rewrite (array_pts_to _ _) (array_pts_to _ s);
+  let ar = array_ref_split al len i in
+  let a' = (| ar, Ghost.hide (len `SZ.sub` i) |) in
+  rewrite (array_pts_to (array_split_l _ _) _) (array_pts_to (array_split_l a _) _);
+  rewrite (array_pts_to (array_split_r _ _) _) (array_pts_to a' _);
+  return a'
+
+val array_join
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#sl #sr: Ghost.erased (Seq.seq t))
+  (a al ar: array td)
+  (i: SZ.t)
+: STGhost unit opened
+    (array_pts_to al sl `star` array_pts_to ar sr)
+    (fun _ -> array_pts_to a (sl `Seq.append` sr))
+    (
+      SZ.v i <= SZ.v (dsnd a) /\
+      al == array_split_l a i /\
+      ar == array_split_r a i
+    )
+    (fun _ -> True)
+
+let fractionable_seq (#t: Type) (td: typedef t) (s: Seq.seq t) : GTot prop =
+  forall (i: nat). i < Seq.length s ==> fractionable td (Seq.index s i)
+
+let mk_fraction_seq (#t: Type) (td: typedef t) (s: Seq.seq t) (p: P.perm) : Ghost (Seq.seq t)
+  (requires (fractionable_seq td s))
+  (ensures (fun _ -> True))
+= Seq.init_ghost (Seq.length s) (fun i -> mk_fraction td (Seq.index s i) p)
+
+let mk_fraction_seq_full (#t: Type0) (td: typedef t) (x: Seq.seq t) : Lemma
+  (requires (fractionable_seq td x))
+  (ensures (mk_fraction_seq td x P.full_perm == x))
+  [SMTPat (mk_fraction_seq td x P.full_perm)]
+= assert (mk_fraction_seq td x P.full_perm `Seq.equal` x)
+
+val mk_fraction_seq_split_gen
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p p1 p2: P.perm)
+: STGhost unit opened
+  (array_pts_to r (mk_fraction_seq td v p))
+  (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
+  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ -> True)
+
+let mk_fraction_seq_split
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: array td) (v: Ghost.erased (Seq.seq t) { fractionable_seq td v }) (p1 p2: P.perm)
+: STGhost unit opened
+  (array_pts_to r v)
+  (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
+  (P.full_perm == p1 `P.sum_perm` p2)
+  (fun _ -> True)
+= mk_fraction_seq_full td v;
+  rewrite (array_pts_to _ _) (array_pts_to _ _);
+  mk_fraction_seq_split_gen r v P.full_perm p1 p2
+
+val mk_fraction_seq_join
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p1 p2: P.perm)
+: STGhostT unit opened
+  (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
+  (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
+
+let full_seq (#t: Type) (td: typedef t) (v: Seq.seq t) : GTot prop =
+  forall (i: nat { i < Seq.length v }) . {:pattern (Seq.index v i)} full td (Seq.index v i)
+
+let full_seq_seq_of_base_array
+  (#t: Type0) (tn: Type0) (td: typedef t) (#n: array_size_t)
+  (b: base_array_t t tn n)
+: Lemma
+  (ensures (full_seq td (seq_of_base_array b) <==> full (base_array0 tn td n) b))
+  [SMTPat (full_seq td (seq_of_base_array b))]
+= assert (forall (i: base_array_index_t n) . base_array_index b i == Seq.index (seq_of_base_array b) (SZ.v i))
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fst b/ulib/experimental/Steel.ST.C.Types.Base.fst
new file mode 100644
index 00000000000..7a548937c5b
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fst
@@ -0,0 +1,402 @@
+module Steel.ST.C.Types.Base
+
+open Steel.C.Model.PCM
+open Steel.ST.GenElim
+
+#set-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
+
+let prod_perm
+  p1 p2
+= let w = let open FStar.Real in P.MkPerm?.v p1 *. P.MkPerm?.v p2 in
+  assert (let open FStar.Real in (p2 `P.lesser_equal_perm` P.full_perm ==> w <=. P.MkPerm?.v p1 *. 1.0R));
+  P.MkPerm w
+
+noeq
+type typedef (t: Type0) : Type0 = {
+  pcm: pcm t;
+  fractionable: (t -> GTot bool);
+  mk_fraction: (
+    (x: t) ->
+    (p: P.perm) ->
+    Pure t
+    (requires (fractionable x))
+    (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> fractionable y))
+  );
+  mk_fraction_full: (
+    (x: t) ->
+    Lemma
+    (requires (fractionable x))
+    (ensures (fractionable x /\ mk_fraction x P.full_perm == x))
+  );
+  mk_fraction_compose: (
+    (x: t) ->
+    (p1: P.perm) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (fractionable x /\ p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm))
+    (ensures (mk_fraction (mk_fraction x p1) p2 == mk_fraction x (p1 `prod_perm` p2)))
+  );
+  fractionable_one: squash (fractionable (one pcm));
+  mk_fraction_one: (
+    (p: P.perm) ->
+    Lemma
+    (mk_fraction (one pcm) p == one pcm)
+  );
+  uninitialized: (y: t {
+    exclusive pcm y /\
+    fractionable y /\
+    p_refine pcm y
+  });
+  mk_fraction_split: (
+    (v: t) ->
+    (p1: P.perm) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (fractionable v /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm))
+    (ensures (
+      composable pcm (mk_fraction v p1) (mk_fraction v p2)
+    ))
+  );
+  mk_fraction_join: (
+    (v: t) ->
+    (p1: P.perm) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (
+      fractionable v /\
+      composable pcm (mk_fraction v p1) (mk_fraction v p2)
+    ))
+    (ensures (
+      op pcm (mk_fraction v p1) (mk_fraction v p2) == mk_fraction v (p1 `P.sum_perm` p2)
+    ))
+  );
+  mk_fraction_eq_one: (
+    (v: t) ->
+    (p: P.perm) ->
+    Lemma
+    (requires (fractionable v /\ mk_fraction v p == one pcm))
+    (ensures (v == one pcm))
+  );
+}
+
+let fractionable td x = td.fractionable x == true
+let mk_fraction td x p = td.mk_fraction x p
+let mk_fraction_full td x = td.mk_fraction_full x
+let mk_fraction_compose td x p1 p2 = td.mk_fraction_compose x p1 p2
+
+let full td v = exclusive td.pcm v /\ p_refine td.pcm v
+
+let uninitialized td = td.uninitialized
+
+let unknown td = one td.pcm
+
+let full_not_unknown
+  td v
+= ()
+
+let mk_fraction_unknown td p = td.mk_fraction_one p
+let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
+
+module R = Steel.ST.C.Model.Ref
+
+noeq
+type ref0_v (#t: Type) (td: typedef t) : Type u#1 = {
+  base: Type0;
+  ref: R.ref base td.pcm;
+}
+
+module HR = Steel.ST.HigherReference
+
+let ptr #t td = HR.ref (ref0_v td)
+let null td = HR.null
+
+(*
+noeq
+type ref0 : Type0 = {
+  dest: TD.token;
+  typedef: typedef (TD.type_of_token dest);
+  ref: R.ref typedef.pcm;
+}
+
+let void_ptr = option ref0
+let void_null = None
+let type_of_ptr p = TD.type_of_token (Some?.v p).dest
+let typedef_of_ptr p = (Some?.v p).typedef
+*)
+
+let r_pts_to
+  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
+  (r: R.ref a p) (v: b)
+: vprop
+= R.pts_to r v
+
+[@@__reduce__]
+let pts_to0
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+  (v: t)
+: Tot vprop
+= exists_ (fun p -> exists_ (fun w ->
+    HR.pts_to r p w `star`
+    r_pts_to w.ref v
+  ))
+
+let pts_to r v = pts_to0 r v
+
+let pts_to_intro
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (p: P.perm)
+  (w1 w2: ref0_v td)
+  (v: t)
+: STGhost unit opened
+    (HR.pts_to r p w1 `star` R.pts_to w2.ref v)
+    (fun _ -> pts_to r v)
+    (w1 == w2)
+    (fun _ -> True)
+= vpattern_rewrite (HR.pts_to r p) w2;
+  rewrite (pts_to0 r v) (pts_to r v)
+
+let is_null
+  p
+= let res = HR.is_null p in
+  return res
+
+[@@__reduce__]
+let ref_equiv0
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: Tot vprop
+= exists_ (fun p1 -> exists_ (fun p2 -> exists_ (fun w ->
+    HR.pts_to r1 p1 w `star`
+    HR.pts_to r2 p2 w
+  )))
+
+let ref_equiv
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: Tot vprop
+= ref_equiv0 r1 r2
+
+let ref_equiv_dup'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (ref_equiv r1 r2)
+    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r1 r2)
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  HR.share r1;
+  HR.share r2;
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
+  noop ();
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let ref_equiv_sym'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (ref_equiv r1 r2)
+    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r1)
+= ref_equiv_dup' r1 r2;
+  rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  noop ();
+  rewrite (ref_equiv0 r2 r1) (ref_equiv r2 r1)
+
+let hr_share (#a:Type)
+          (#uses:_)
+          (#p:P.perm)
+          (#v:a)
+          (r:HR.ref a)
+  : STGhostT unit uses
+      (HR.pts_to r p v)
+      (fun _ -> HR.pts_to r (P.half_perm p) v `star` HR.pts_to r (P.half_perm p) v)
+= HR.share #_ #_ #_ #v r
+
+let hr_gather
+  (#a:Type)
+  (#uses:_) 
+  (#p0 #p1:P.perm)
+  (v0 #v1:a)
+  (r:HR.ref a)
+: STGhost unit uses
+      (HR.pts_to r p0 v0 `star` HR.pts_to r p1 v1)
+      (fun _ -> HR.pts_to r (P.sum_perm p0 p1) v0)
+      (requires True)
+      (ensures fun _ -> v0 == v1)
+= HR.gather p1 r
+
+let ref_equiv_trans'
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2 r3: ref td)
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` ref_equiv r2 r3)
+    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r3 `star` ref_equiv r1 r3)
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  let p2 = vpattern_replace (fun p -> HR.pts_to r2 p _) in
+  rewrite (ref_equiv r2 r3) (ref_equiv0 r2 r3);
+  let _ = gen_elim () in
+  HR.pts_to_injective_eq #_ #_ #_ #_ #w #_ r2;
+  vpattern_rewrite (HR.pts_to r3 _) w;
+  hr_share r1;
+  hr_share r3;
+  HR.gather p2 r2;
+  hr_share r2;
+  noop ();
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
+  rewrite (ref_equiv0 r2 r3) (ref_equiv r2 r3);
+  rewrite (ref_equiv0 r1 r3) (ref_equiv r1 r3)
+
+let hr_share_imbalance (#a:Type)
+          (#uses:_)
+          (#p:P.perm)
+          (#v:a)
+          (r:HR.ref a)
+  : STGhostT P.perm uses
+      (HR.pts_to r p v)
+      (fun p1 -> HR.pts_to r p1 v `star` exists_ (fun p2 -> HR.pts_to r p2 v))
+= HR.share #_ #_ #_ #v r;
+  _
+
+#set-options "--ide_id_info_off"
+
+let pts_to_equiv
+  r1 r2 v
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (pts_to r1 v) (pts_to0 r1 v);
+  let _ = gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  rewrite (pts_to0 r2 v) (pts_to r2 v);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+[@@__steel_reduce__; __reduce__]
+let freeable0
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: Tot vprop
+= exists_ (fun p -> exists_ (fun w ->
+    HR.pts_to r p w `star`
+    pure (R.freeable w.ref)
+  ))
+
+let freeable
+  r
+= freeable0 r
+
+let freeable_dup
+  r
+= rewrite (freeable r) (freeable0 r);
+  let _ = gen_elim () in
+  HR.share r;
+  noop ();
+  rewrite (freeable0 r) (freeable r);
+  noop ();
+  rewrite (freeable0 r) (freeable r)
+
+let freeable_equiv
+  r1 r2
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (freeable r1) (freeable0 r1);
+  let _ = gen_elim () in
+  hr_gather w r1;
+  HR.share r2;
+  rewrite (freeable0 r2) (freeable r2);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let alloc
+  td
+= let r = R.ref_alloc td.pcm td.uninitialized in
+  let w = {
+    base = _;
+    ref = r;
+  }
+  in
+  rewrite (R.pts_to _ _) (R.pts_to w.ref (uninitialized td));
+  let res = HR.alloc w in
+  HR.share res;
+  HR.pts_to_not_null res;
+  rewrite (pts_to0 res (uninitialized td)) (pts_to_or_null res (uninitialized td));
+  rewrite (freeable0 res) (freeable_or_null res);
+  return res
+
+let free
+  #_ #_ #v r
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = HR.read r in
+  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  rewrite (freeable r) (freeable0 r);
+  let _ = gen_elim () in
+  hr_gather w r;
+  R.ref_free w.ref;
+  drop (HR.pts_to _ _ _);
+  return ()
+
+let mk_fraction_split_gen
+  #_ #_ #td r v p p1 p2
+= rewrite (pts_to _ _) (pts_to0 r (mk_fraction td v p));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  td.mk_fraction_split v p1 p2;
+  td.mk_fraction_join v p1 p2;
+  rewrite
+    (R.pts_to _ _)
+    (R.pts_to w.ref (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)));
+  R.split _ _ (td.mk_fraction v p1) (td.mk_fraction v p2);
+  HR.share r;
+  rewrite (pts_to0 r (td.mk_fraction v p1)) (pts_to r (mk_fraction td v p1));
+  rewrite (pts_to0 r (td.mk_fraction v p2)) (pts_to r (mk_fraction td v p2))
+
+let mk_fraction_join
+  #_ #_ #td r v p1 p2
+= rewrite (pts_to r (mk_fraction td v p1)) (pts_to0 r (mk_fraction td v p1));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (R.pts_to _ _) (R.pts_to w.ref (td.mk_fraction v p1));
+  rewrite (pts_to r (mk_fraction td v p2)) (pts_to0 r (mk_fraction td v p2));
+  let _ = gen_elim () in
+  hr_gather w r;
+  rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to w.ref (td.mk_fraction v p2));
+  let _ = R.gather w.ref (td.mk_fraction v p1) _ in
+  td.mk_fraction_join v p1 p2;
+  rewrite (pts_to0 r _) (pts_to r _)
+
+let r_unfocus (#opened:_)
+  (#ta #ta' #tb #tc: Type)
+  (#p: pcm tb)
+  (#q: pcm tc)
+  (r: R.ref ta q) (r': R.ref ta' p)
+  (l: Steel.C.Model.Connection.connection p q) (x: tc)
+: STGhost (Ghost.erased tb) opened
+    (r `R.pts_to` x)
+    (fun x' -> r' `R.pts_to` x')
+    (requires
+      ta == ta' /\
+      r == R.ref_focus r' l)
+    (ensures fun x' -> Ghost.reveal x' == l.conn_small_to_large.morph x)
+= let r1 : R.ref ta' q = r in
+  rewrite (r `R.pts_to` x) (r1 `R.pts_to` x);
+  R.unfocus r1 r' l x;
+  let x' = vpattern_replace_erased (R.pts_to r') in
+  x'
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fsti b/ulib/experimental/Steel.ST.C.Types.Base.fsti
new file mode 100644
index 00000000000..c84f93aaf66
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fsti
@@ -0,0 +1,251 @@
+module Steel.ST.C.Types.Base
+open Steel.ST.Util
+
+module P = Steel.FractionalPermission
+
+/// Helper to compose two permissions into one
+val prod_perm (p1 p2: P.perm) : Pure P.perm
+  (requires True)
+  (ensures (fun p ->
+    ((p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm) ==>
+    p `P.lesser_equal_perm` P.full_perm) /\
+    p.v == (let open FStar.Real in p1.v *. p2.v)
+  ))
+
+[@@noextract_to "krml"] // proof-only
+val typedef (t: Type0) : Type0
+
+inline_for_extraction [@@noextract_to "krml"]
+let typeof (#t: Type0) (td: typedef t) : Tot Type0 = t
+
+val fractionable (#t: Type0) (td: typedef t) (x: t) : GTot prop
+
+val mk_fraction (#t: Type0) (td: typedef t) (x: t) (p: P.perm) : Ghost t
+  (requires (fractionable td x))
+  (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> fractionable td y))
+
+val mk_fraction_full (#t: Type0) (td: typedef t) (x: t) : Lemma
+  (requires (fractionable td x))
+  (ensures (mk_fraction td x P.full_perm == x))
+  [SMTPat (mk_fraction td x P.full_perm)]
+
+val mk_fraction_compose (#t: Type0) (td: typedef t) (x: t) (p1 p2: P.perm) : Lemma
+  (requires (fractionable td x /\ p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm))
+  (ensures (mk_fraction td (mk_fraction td x p1) p2 == mk_fraction td x (p1 `prod_perm` p2)))
+
+val full (#t: Type0) (td: typedef t) (v: t) : GTot prop
+
+val uninitialized (#t: Type0) (td: typedef t) : Ghost t
+  (requires True)
+  (ensures (fun y -> full td y /\ fractionable td y))
+
+val unknown (#t: Type0) (td: typedef t) : Ghost t
+  (requires True)
+  (ensures (fun y -> fractionable td y))
+
+val full_not_unknown
+  (#t: Type)
+  (td: typedef t)
+  (v: t)
+: Lemma
+  (requires (full td v))
+  (ensures (~ (v == unknown td)))
+  [SMTPat (full td v)]
+
+val mk_fraction_unknown (#t: Type0) (td: typedef t) (p: P.perm) : Lemma
+  (ensures (mk_fraction td (unknown td) p == unknown td))
+
+val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemma
+  (requires (fractionable td v /\ mk_fraction td v p == unknown td))
+  (ensures (v == unknown td))
+
+
+(*
+// To be extracted as: void*
+
+// FIXME: Currently, Karamel does not directly support
+// void*. examples/steel/arraystructs currently has a stopgap in
+// lib/steel_c.h, whose contents should be moved to krmllib.h, unless
+// direct support for void* is added to Karamel.
+
+[@@noextract_to "krml"] // primitive
+val void_ptr : Type0
+ 
+// To be extracted as: NULL
+[@@noextract_to "krml"] // primitive
+val void_null: void_ptr
+
+[@@noextract_to "krml"] // proof-only
+val type_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot Type0
+val typedef_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot (typedef (type_of_ptr p))
+
+// To be extracted as: *t
+[@@noextract_to "krml"] // primitive
+let ptr (#t: Type) (td: typedef t) : Tot Type0 = (p: void_ptr { (~ (p == void_null)) ==> (type_of_ptr p == t /\ typedef_of_ptr p == td) })
+[@@noextract_to "krml"] // primitive
+let null (#t: Type) (td: typedef t) : Tot (ptr td) = void_null
+*)
+
+val ptr (#t: Type) (td: typedef t) : Tot Type0
+val null (#t: Type) (td: typedef t) : Tot (ptr td)
+
+inline_for_extraction [@@noextract_to "krml"]
+let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
+
+val pts_to (#t: Type) (#td: typedef t) (r: ref td) ([@@@smt_fallback] v: Ghost.erased t) : vprop
+
+let pts_to_or_null
+  (#t: Type) (#td: typedef t) (p: ptr td) (v: Ghost.erased t) : vprop
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (p == null _)
+  then emp
+  else pts_to p v
+
+[@@noextract_to "krml"] // primitive
+val is_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (p: ptr td)
+: STAtomicBase bool false opened Unobservable
+    (pts_to_or_null p v)
+    (fun _ -> pts_to_or_null p v)
+    (True)
+    (fun res -> res == true <==> p == null _)
+
+let assert_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (p: ptr td)
+: STGhost unit opened
+    (pts_to_or_null p v)
+    (fun _ -> emp)
+    (p == null _)
+    (fun _ -> True)
+= rewrite (pts_to_or_null p v) emp
+
+let assert_not_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (p: ptr td)
+: STGhost (squash (~ (p == null _))) opened
+    (pts_to_or_null p v)
+    (fun _ -> pts_to p v)
+    (~ (p == null _))
+    (fun _ -> True)
+= rewrite (pts_to_or_null p v) (pts_to p v)
+
+val ref_equiv
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: Tot vprop
+
+val pts_to_equiv
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+  (v: Ghost.erased t)
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` pts_to r1 v)
+    (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
+
+val freeable
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: Tot vprop
+
+val freeable_dup
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+: STGhostT unit opened
+    (freeable r)
+    (fun _ -> freeable r `star` freeable r)
+
+val freeable_equiv
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r1 r2: ref td)
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` freeable r1)
+    (fun _ -> ref_equiv r1 r2 `star` freeable r2)
+
+let freeable_or_null
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+: Tot vprop
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (r == null _)
+  then emp
+  else freeable r
+
+(*
+let freeable_or_null_dup
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+: SteelGhostT vprop opened
+    (freeable_or_null r)
+    (fun _ -> freeable_or_null r `star` freeable_or_null r)
+= if FStar.StrongExcludedMiddle.strong_excluded_middle (r == null _)
+  then ()
+  else freeable r
+*)
+
+[@@noextract_to "krml"] // primitive
+val alloc
+  (#t: Type)
+  (td: typedef t)
+: STT (ptr td)
+    emp
+    (fun p -> pts_to_or_null p (uninitialized td) `star` freeable_or_null p)
+
+[@@noextract_to "krml"] // primitive
+val free
+  (#t: Type)
+  (#td: typedef t)
+  (#v: Ghost.erased t)
+  (r: ref td)
+: ST unit
+    (pts_to r v `star` freeable r)
+    (fun _ -> emp)
+    (
+      full td v
+    )
+    (fun _ -> True)
+
+val mk_fraction_split_gen
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm) : STGhost unit opened
+  (pts_to r (mk_fraction td v p))
+  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (fun _ -> True)
+
+let mk_fraction_split
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p1 p2: P.perm) : STGhost unit opened
+  (pts_to r v)
+  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (P.full_perm == p1 `P.sum_perm` p2)
+  (fun _ -> True)
+= mk_fraction_full td v;
+  rewrite (pts_to _ _) (pts_to _ _);
+  mk_fraction_split_gen r v P.full_perm p1 p2
+
+val mk_fraction_join
+  (#opened: _)
+  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p1 p2: P.perm)
+: STGhostT unit opened
+  (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
+  (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
diff --git a/ulib/experimental/Steel.ST.C.Types.Fields.fst b/ulib/experimental/Steel.ST.C.Types.Fields.fst
new file mode 100644
index 00000000000..df9f7f56d0c
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Fields.fst
@@ -0,0 +1,6 @@
+module Steel.ST.C.Types.Fields
+
+let field_t_nil = unit
+let field_t_cons _ _ _ = unit
+
+irreducible let norm_field_attr = ()
diff --git a/ulib/experimental/Steel.ST.C.Types.Fields.fsti b/ulib/experimental/Steel.ST.C.Types.Fields.fsti
new file mode 100644
index 00000000000..4922c665623
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Fields.fsti
@@ -0,0 +1,56 @@
+module Steel.ST.C.Types.Fields
+include Steel.ST.C.Types.Base
+open Steel.C.Typestring
+open Steel.ST.Util
+
+[@@noextract_to "krml"] // primitive
+val field_t_nil: Type0
+[@@noextract_to "krml"] // primitive
+val field_t_cons (fn: Type0) (ft: Type0) (fc: Type0): Type0
+
+val norm_field_attr : unit
+
+noextract
+let norm_field_steps = [
+  delta_attr [`%norm_field_attr];
+  iota; zeta; primops;
+]
+
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
+noeq
+type field_description_t (t: Type0) : Type u#1 = {
+  fd_def: (string -> GTot bool);
+  fd_empty: (fd_empty: bool { fd_empty == true <==> (forall s . fd_def s == false) });
+  fd_type: (string -> Type0);
+  fd_typedef: ((s: string) -> Pure (typedef (fd_type s)) (requires (fd_def s)) (ensures (fun _ -> True)));
+}
+
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
+let nonempty_field_description_t (t: Type0) =
+  (fd: field_description_t t { fd.fd_empty == false })
+
+[@@noextract_to "krml"] // proof-only
+let field_t (#t: Type0) (fd: field_description_t t) : Tot eqtype = (s: string { fd.fd_def s })
+
+inline_for_extraction [@@noextract_to "krml"]
+let field_description_nil : field_description_t field_t_nil = {
+  fd_def = (fun _ -> false);
+  fd_empty = true;
+  fd_type = (fun _ -> unit);
+  fd_typedef = (fun _ -> false_elim ());
+}
+
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
+let field_description_cons0
+  (fn: Type0) (#ft: Type0) (#fc: Type0) (n: string) (t: typedef ft) (fd: field_description_t fc)
+: Tot (nonempty_field_description_t (field_t_cons fn ft fc))
+= {
+    fd_def = (fun n' -> n = n' || fd.fd_def n');
+    fd_empty = false;
+    fd_type = (fun n' -> if n = n' then ft else fd.fd_type n');
+    fd_typedef = (fun n' -> if n = n' then t else fd.fd_typedef n');
+  }
+
+inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
+let field_description_cons (#ft: Type0) (#fc: Type0) (n: string) (#fn: Type0) (# [ solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == fn))) (t: typedef ft) (fd: field_description_t fc) : Tot (nonempty_field_description_t (field_t_cons fn ft fc)) =
+  field_description_cons0 fn #ft #fc n t fd
diff --git a/ulib/experimental/Steel.ST.C.Types.Scalar.fst b/ulib/experimental/Steel.ST.C.Types.Scalar.fst
new file mode 100644
index 00000000000..195a667375e
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Scalar.fst
@@ -0,0 +1,132 @@
+module Steel.ST.C.Types.Scalar
+open Steel.ST.GenElim
+friend Steel.ST.C.Types.Base
+open Steel.ST.C.Types.Base
+
+open Steel.C.Model.PCM
+
+module R = Steel.ST.C.Model.Ref
+module HR = Steel.ST.HigherReference
+module F = Steel.ST.C.Model.Frac
+
+let scalar_t t = F.fractional (option t)
+
+let scalar_fractionable
+  (#t: Type)
+  (s: scalar_t t)
+: GTot bool
+= match s with
+  | Some (_, p) -> p `P.lesser_equal_perm` P.full_perm
+  | _ -> true
+
+[@@noextract_to "krml"] // proof-only
+let scalar_mk_fraction
+  (#t: Type)
+  (x: scalar_t t)
+  (p: P.perm)
+: Pure (scalar_t t)
+    (requires (scalar_fractionable x))
+    (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> scalar_fractionable y))
+= match x with
+  | (Some (v, p')) ->
+    (Some (v, p `prod_perm` p'))
+  | _ -> x
+
+#set-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native" // for mk_fraction_split
+
+#restart-solver
+let scalar t = {
+  pcm = F.pcm_frac;
+  fractionable = scalar_fractionable #t;
+  mk_fraction = scalar_mk_fraction #t;
+  mk_fraction_full = (fun x ->
+    match x with
+    | (Some (v, p)) ->
+      assert_norm ((P.full_perm `prod_perm` p).v == (let open FStar.Real in 1.0R *. p.v));
+      assert (P.full_perm `prod_perm` p == p)
+    | _ -> ()
+  );
+  mk_fraction_compose = (fun w p1 p2 ->
+    match w with
+    | (Some (v, p)) ->
+      assert_norm (let open FStar.Real in ((p1 `prod_perm` p2) `prod_perm` p).v == (p1.v *. p2.v) *. p.v);
+      assert_norm (let open FStar.Real in (p2 `prod_perm` (p1 `prod_perm` p)).v == p2.v *. (p1.v *. p.v));
+      assert ((p1 `prod_perm` p2) `prod_perm` p == p2 `prod_perm` (p1 `prod_perm` p))
+    | _ -> ()
+  );
+  fractionable_one = ();
+  mk_fraction_one = (fun _ -> ());
+  uninitialized = Some (None, P.full_perm);
+  mk_fraction_split = (fun w p1 p2 ->
+    match w with
+    | (Some (v, p)) ->
+      assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
+      assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
+      assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p));
+      assert (composable (F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2));
+()   //   assert (op (U.pcm_uninit F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2) == scalar_mk_fraction w (p1 `P.sum_perm` p2))
+    | _ -> ()
+  );
+  mk_fraction_join = (fun w p1 p2 ->
+    match w with
+    | (Some (v, p)) ->
+      assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
+      assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
+      assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p))
+    | _ -> ()
+  );
+  mk_fraction_eq_one = (fun v p -> ());
+}
+
+let mk_scalar v = (Some (Some v, P.full_perm))
+
+let mk_scalar_fractionable v p = ()
+
+let mk_scalar_inj v1 v2 p1 p2 = ()
+
+#push-options "--z3rlimit 16"
+
+#restart-solver
+
+let scalar_unique
+  #_ #t v1 v2 p1 p2 r
+= rewrite (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1)));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (r_pts_to _ (Some (Some v1, p1))) (R.pts_to w.ref (Some (Some v1, p1)));
+  rewrite (pts_to r _) (pts_to0 r (Some (Some v2, p2)));
+  let _ = gen_elim () in
+  hr_gather w r;
+  rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to w.ref (Some (Some v2, p2)));
+  let _ = R.gather w.ref (Some (Some v1, p1)) (Some (Some v2, p2)) in
+  R.split w.ref _ (Some (Some v1, p1)) (Some (Some v2, p2));
+  HR.share r;
+  noop (); // FIXME: WHY WHY WHY?
+  rewrite (pts_to0 r (Some (Some v1, p1))) (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1));
+  rewrite (pts_to0 r (Some (Some v2, p2))) (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
+
+#pop-options
+
+let read0
+  #t #v #p r
+= rewrite (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p)));
+  let _ = gen_elim () in
+  let w = HR.read r in
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Some (Some (Ghost.reveal v), p)));
+  let v' = R.ref_read w.ref in
+  let Some (Some v0, _) = v' in
+  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v), p)));
+  rewrite (pts_to0 r (Some (Some (Ghost.reveal v), p))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p));
+  return v0
+
+let write
+  #t #v r v'
+= rewrite (pts_to r _) (pts_to0 r (Ghost.reveal v));
+  let _ = gen_elim () in
+  let w = HR.read r in
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  R.ref_upd w.ref _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
+  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v'), P.full_perm)));
+  rewrite (pts_to0 r (Some (Some (Ghost.reveal v'), P.full_perm))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v')) P.full_perm))
diff --git a/ulib/experimental/Steel.ST.C.Types.Scalar.fsti b/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
new file mode 100644
index 00000000000..3fc8f9acf13
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
@@ -0,0 +1,88 @@
+module Steel.ST.C.Types.Scalar
+open Steel.ST.Util
+include Steel.ST.C.Types.Base
+
+module P = Steel.FractionalPermission
+
+// To be extracted as: t
+[@@noextract_to "krml"] // primitive
+val scalar_t (t: Type0) : Type0
+[@@noextract_to "krml"] // proof-only
+val scalar (t: Type) : typedef (scalar_t t)
+val mk_scalar (#t: Type) (v: t) : Ghost (scalar_t t)
+  (requires True)
+  (ensures (fun y ->
+    fractionable (scalar t) y /\
+    full (scalar t) y
+  ))
+
+val mk_scalar_fractionable
+  (#t: Type)
+  (v: t)
+  (p: P.perm)
+: Lemma
+  (requires (fractionable (scalar t) (mk_fraction (scalar t) (mk_scalar v) p)))
+  (ensures (p `P.lesser_equal_perm` P.full_perm))
+
+val mk_scalar_inj
+  (#t: Type)
+  (v1 v2: t)
+  (p1 p2: P.perm)
+: Lemma
+  (requires (mk_fraction (scalar t) (mk_scalar v1) p1 == mk_fraction (scalar t) (mk_scalar v2) p2))
+  (ensures (v1 == v2 /\ p1 == p2))
+  [SMTPat [mk_fraction (scalar t) (mk_scalar v1) p1; mk_fraction (scalar t) (mk_scalar v2) p2]]
+
+val scalar_unique
+  (#opened: _)
+  (#t: Type)
+  (v1 v2: t)
+  (p1 p2: P.perm)
+  (r: ref (scalar t))
+: STGhost unit opened
+    (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
+    (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
+    (True)
+    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+
+[@@noextract_to "krml"] // primitive
+val read0 (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : ST t
+  (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
+  (True)
+  (fun v' -> v' == Ghost.reveal v)
+
+let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
+  (mk_scalar v == mk_fraction (scalar t) (mk_scalar v) P.full_perm)
+  [SMTPat (mk_scalar v)]
+= ()
+
+inline_for_extraction [@@noextract_to "krml"]
+let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : ST t
+  (pts_to r v)
+  (fun _ -> pts_to r v)
+  (exists v0 p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p)
+  (fun v1 -> forall v0 p . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p ==> v0 == v1)
+= let v0 = FStar.IndefiniteDescription.indefinite_description_tot _ (fun v0 -> exists p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p) in
+  let p = FStar.IndefiniteDescription.indefinite_description_tot _ (fun p -> Ghost.reveal v == mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p) in
+  let prf v0' p' : Lemma
+    (requires (Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0') p'))
+    (ensures (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
+  = mk_scalar_inj (Ghost.reveal v0) v0' p p'
+  in
+  let prf' v0' p' : Lemma
+    (Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0') p' ==> (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
+  = Classical.move_requires (prf v0') p'
+  in
+  Classical.forall_intro_2 prf';
+  rewrite (pts_to _ _) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p));
+  let v1 = read0 r in
+  rewrite (pts_to _ _) (pts_to r v);
+  return v1
+
+[@@noextract_to "krml"] // primitive
+val write (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : ST unit
+  (pts_to r v)
+  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
+  (full (scalar t) v)
+  (fun _ -> True)
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
new file mode 100644
index 00000000000..7b24d4d0a67
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
@@ -0,0 +1,444 @@
+module Steel.ST.C.Types.Struct.Aux
+open Steel.ST.GenElim
+friend Steel.ST.C.Types.Base
+open Steel.ST.C.Types.Base
+
+open Steel.C.Model.PCM
+
+module P = Steel.FractionalPermission
+module R = Steel.ST.C.Model.Ref
+module HR = Steel.ST.HigherReference
+
+[@@noextract_to "krml"]
+noeq
+type field_description_gen_t (field_t: eqtype) : Type u#1 = {
+  fd_nonempty: squash (exists (f: field_t) . True);
+  fd_type: (field_t -> Type0);
+  fd_typedef: ((s: field_t) -> Tot (typedef (fd_type s)));
+}
+
+module S = Steel.ST.C.Model.Struct
+
+[@@noextract_to "krml"] // proof-only
+let struct_field_pcm
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+  (f: field_t)
+: Tot (pcm (fields.fd_type f))
+= (fields.fd_typedef f).pcm
+
+module FX = FStar.FunctionalExtensionality
+
+[@@noextract_to "krml"] // primitive
+let struct_t1 (#field_t: eqtype) (fields: field_description_gen_t field_t) : Tot Type0 =
+  FX.restricted_t field_t fields.fd_type
+
+[@@noextract_to "krml"] // proof-only
+let struct_pcm
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+: Tot (pcm (struct_t1 fields))
+= S.prod_pcm (struct_field_pcm fields)
+
+[@@noextract_to "krml"] // proof-only
+let t_struct_set_field
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t) (f: field_t) (v: fields.fd_type f) (s: struct_t1 fields)
+: Tot (struct_t1 fields)
+= FX.on_dom (field_t) (fun f' -> if f = f' then v else s f')
+
+let struct_eq_intro
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (s1 s2: struct_t1 fields)
+  (prf: (
+    (f: field_t) ->
+    Lemma
+    (s1 f == s2 f)
+  ))
+: Lemma
+  (s1 == s2)
+= Classical.forall_intro prf;
+  assert (s1 `FX.feq` s2)
+
+let struct_fractionable
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t)
+  (s: struct_t1 fields)
+: GTot bool
+= FStar.StrongExcludedMiddle.strong_excluded_middle (forall (f: field_t) . (fields.fd_typedef f).fractionable (s f))
+
+[@@noextract_to "krml"] // proof-only
+let struct_mk_fraction
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t)
+  (s: struct_t1 fields)
+  (p: P.perm)
+: Pure (struct_t1 fields)
+  (requires (struct_fractionable s))
+  (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> struct_fractionable s'))
+= FX.on_dom field_t (fun f -> (fields.fd_typedef f).mk_fraction (s f) p)
+
+[@@noextract_to "krml"] // proof-only
+let struct_uninitialized
+  (#field_t: eqtype) (fields: field_description_gen_t field_t)
+: Pure (struct_t1 fields)
+    (requires True)
+    (ensures (fun y -> p_refine (struct_pcm fields) y))
+= FX.on_dom field_t (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f)
+
+let struct1
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+= {
+  pcm = struct_pcm fields;
+  fractionable = struct_fractionable;
+  mk_fraction = struct_mk_fraction;
+  mk_fraction_full = (fun x ->
+    struct_eq_intro (struct_mk_fraction x P.full_perm) x (fun f ->
+      (fields.fd_typedef f).mk_fraction_full (x f)
+    )
+  );
+  mk_fraction_compose = (fun x p1 p2 ->
+    struct_eq_intro (struct_mk_fraction (struct_mk_fraction x p1) p2) (struct_mk_fraction x (p1 `prod_perm` p2)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_compose (x f) p1 p2
+    )
+  );
+  fractionable_one = ();
+  mk_fraction_one = (fun p ->
+    struct_eq_intro (struct_mk_fraction (one (struct_pcm fields)) p) (one (struct_pcm fields)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_one p
+    )
+  );
+  uninitialized = struct_uninitialized _;
+  mk_fraction_split = (fun v p1 p2 ->
+    let prf
+      (f: field_t)
+    : Lemma
+      (composable (fields.fd_typedef f).pcm (mk_fraction (fields.fd_typedef f) (v f) p1) (mk_fraction (fields.fd_typedef f) (v f) p2))
+    = (fields.fd_typedef f).mk_fraction_split (v f) p1 p2
+    in
+    Classical.forall_intro prf
+  );
+  mk_fraction_join = (fun v p1 p2 ->
+    struct_eq_intro (op (struct_pcm fields) (struct_mk_fraction v p1) (struct_mk_fraction v p2)) (struct_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_join (v f) p1 p2
+    )
+  );
+  mk_fraction_eq_one = (fun v p ->
+    struct_eq_intro v (one (struct_pcm fields)) (fun f ->
+      (fields.fd_typedef f).mk_fraction_eq_one (v f) p
+    )
+  );
+}
+
+
+let has_struct_field_gen
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+  (r: ref0_v (struct1 fields))
+  (field: field_t)
+  (r': ref0_v (fields.fd_typedef field))
+: GTot prop
+= r'.base == r.base /\
+  r'.ref == R.ref_focus r.ref (S.struct_field (struct_field_pcm fields) field)
+
+[@@__reduce__]
+let has_struct_field0
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
+    HR.pts_to r p w `star`
+    HR.pts_to r' p' w' `star`
+    pure (has_struct_field_gen fields w field w')
+  ))))
+
+let has_struct_field1
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= has_struct_field0 r field r'
+
+let has_struct_field_dup'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field1 r field r')
+    (fun _ -> has_struct_field1 r field r' `star` has_struct_field1 r field r')
+=
+  rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = gen_elim () in
+  HR.share r;
+  HR.share r';
+  noop ();
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  noop ();
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
+
+let has_struct_field_inj'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r1 r2: ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field1 r field r1 `star` has_struct_field1 r field r2)
+    (fun _ -> has_struct_field1 r field r1 `star` has_struct_field1 r field r2 `star` ref_equiv r1 r2)
+=
+  rewrite (has_struct_field1 r field r1) (has_struct_field0 r field r1);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w1 = vpattern_replace (HR.pts_to r1 _) in
+  rewrite (has_struct_field1 r field r2) (has_struct_field0 r field r2);
+  let _ = gen_elim () in
+  hr_gather w r;
+  vpattern_rewrite (HR.pts_to r2 _) w1;
+  hr_share r;
+  hr_share r1;
+  rewrite (has_struct_field0 r field r1) (has_struct_field1 r field r1);
+  hr_share r2;
+  rewrite (has_struct_field0 r field r2) (has_struct_field1 r field r2);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let has_struct_field_equiv_from'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r1: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+  (r2: ref (struct1 fields))
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` has_struct_field1 r1 field r')
+    (fun _ -> ref_equiv r1 r2 `star` has_struct_field1 r2 field r')
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (has_struct_field1 r1 field r') (has_struct_field0 r1 field r');
+  let _ = gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  rewrite (has_struct_field0 r2 field r') (has_struct_field1 r2 field r');
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let has_struct_field_equiv_to'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r1': ref (fields.fd_typedef field))
+  (r2': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (ref_equiv r1' r2' `star` has_struct_field1 r field r1')
+    (fun _ -> ref_equiv r1' r2' `star` has_struct_field1 r field r2')
+= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  rewrite (has_struct_field1 r field r1') (has_struct_field0 r field r1');
+  let _ = gen_elim () in
+  hr_gather w r1';
+  hr_share r2';
+  rewrite (has_struct_field0 r field r2') (has_struct_field1 r field r2');
+  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+
+[@@noextract_to "krml"] // proof-only
+let t_struct_get_field
+  (#field_t: eqtype) (#fields: field_description_gen_t field_t) (s: struct_t1 fields) (f: field_t)
+: Tot (fields.fd_type f)
+= s f
+
+let ghost_struct_field_focus'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field1 r field r' `star` pts_to r v)
+    (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field))
+= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  hr_gather w r;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let prf
+    (f': field_t)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 prf;
+  let v' = t_struct_set_field field (unknown (fields.fd_typedef field)) v in
+  let vf = S.field_to_struct_f (struct_field_pcm _) field (t_struct_get_field v field) in
+  assert (composable (struct_pcm _) v' vf);
+  assert (op (struct_pcm _) v' vf `FX.feq` v);
+  R.split w.ref _ v' vf;
+  R.gfocus w.ref (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
+  hr_share r;
+  hr_share r';
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r v') (pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v));
+  rewrite (R.pts_to _ _) (r_pts_to w'.ref (t_struct_get_field v field));
+  rewrite (pts_to0 r' (t_struct_get_field v field)) (pts_to r' (t_struct_get_field v field))
+
+module GHR = Steel.ST.GhostHigherReference
+
+let ghost_struct_field'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+    (pts_to r v)
+    (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
+  }
+  in
+  let gr' = GHR.alloc w' in
+  let r1' = GHR.reveal_ref gr' in
+  GHR.reveal_pts_to gr' P.full_perm w';
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  HR.pts_to_not_null r1';
+  let r' = Ghost.hide r1' in
+  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  hr_share r;
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  ghost_struct_field_focus' r field r';
+  r'
+
+let struct_field'
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+: STT (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = HR.read r in
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
+  }
+  in
+  let r' = HR.alloc w' in
+  hr_share r;
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  ghost_struct_field_focus' r field r';
+  return r'
+
+let unstruct_field'
+  (#opened: _)
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (#v: Ghost.erased (struct_t1 fields))
+  (r: ref (struct1 fields))
+  (field: field_t)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: STGhost unit opened
+    (has_struct_field1 r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field v' v))
+    (
+      t_struct_get_field v field == unknown (fields.fd_typedef field)
+    )
+    (fun _ -> True)
+= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  hr_gather w r;
+  rewrite (r_pts_to _ (Ghost.reveal v)) (R.pts_to w.ref (Ghost.reveal v));
+  rewrite (pts_to r' v') (pts_to0 r' v');
+  let _ = gen_elim () in
+  hr_gather w' r';
+  rewrite (r_pts_to _ (Ghost.reveal v')) (R.pts_to w'.ref (Ghost.reveal v'));
+  let prf
+    (f': field_t)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 prf;
+  let vf = S.field_to_struct_f (struct_field_pcm _) field v' in
+  assert (composable (struct_pcm _) v vf);
+  assert (op (struct_pcm _) v vf `FX.feq` t_struct_set_field field v' v);
+  let _ = r_unfocus w'.ref w.ref (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
+  let _ = R.gather w.ref (Ghost.reveal v) _ in
+  hr_share r;
+  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  rewrite (pts_to0 r _) (pts_to r _)
+
+let full_struct_gen
+  (#field_t: eqtype)
+  (#fields: field_description_gen_t field_t)
+  (s: struct_t1 fields)
+: Lemma
+  (full (struct1 fields) s <==> (forall field . full (fields.fd_typedef field) (s field)))
+=
+  let is_unit'
+    (f': field_t)
+    (x: (fields.fd_type f'))
+  : Lemma
+    (let p = (fields.fd_typedef f').pcm in
+      composable p x (one p) /\
+      op p x (one p) == x
+    )
+  = is_unit (fields.fd_typedef f').pcm x
+  in
+  Classical.forall_intro_2 is_unit';
+  let prf
+    (field: field_t)
+  : Lemma
+    (requires (full (struct1 fields) s))
+    (ensures (full (fields.fd_typedef field) (s field)))
+  = let prf'
+      (x: fields.fd_type field)
+    : Lemma
+      (requires (composable (fields.fd_typedef field).pcm (s field) x))
+      (ensures (x == one (fields.fd_typedef field).pcm))
+    = let s' = t_struct_set_field field x (one (struct_pcm fields)) in
+      assert (composable (struct_pcm fields) s s')
+    in
+    Classical.forall_intro (Classical.move_requires prf')
+  in
+  Classical.forall_intro (Classical.move_requires prf)
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti
new file mode 100644
index 00000000000..c25b145f274
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti
@@ -0,0 +1,4 @@
+module Steel.ST.C.Types.Struct.Aux
+include Steel.ST.C.Types.Base
+
+// This module is `friend`ed by Steel.ST.C.Types.Struct and Steel.ST.C.Types.Array
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.fst b/ulib/experimental/Steel.ST.C.Types.Struct.fst
new file mode 100644
index 00000000000..a0cd5afcaae
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.fst
@@ -0,0 +1,115 @@
+module Steel.ST.C.Types.Struct
+open Steel.ST.GenElim
+friend Steel.ST.C.Types.Base
+friend Steel.ST.C.Types.Struct.Aux
+open Steel.ST.C.Types.Struct.Aux
+
+module FX = FStar.FunctionalExtensionality
+
+let define_struct0 _ _ _ = unit
+
+let nonempty_field_description_nonempty
+  (#tf: Type)
+  (fd: nonempty_field_description_t tf)
+: Lemma
+  (exists (f: field_t fd) . True)
+= if StrongExcludedMiddle.strong_excluded_middle (exists (f: field_t fd) . True)
+  then ()
+  else begin
+    let prf
+      (f: string)
+    : Lemma
+      (fd.fd_def f == false)
+    = if fd.fd_def f
+      then Classical.exists_intro (fun (f: field_t fd) -> True) f
+      else ()
+    in
+    Classical.forall_intro prf
+  end
+
+[@@noextract_to "krml"]
+let fd_gen_of_nonempty_fd (#tf: Type0) (fd: nonempty_field_description_t tf) : Tot (field_description_gen_t (field_t fd)) = {
+  fd_nonempty = nonempty_field_description_nonempty fd;
+  fd_type = fd.fd_type;
+  fd_typedef = (fun (s: field_t fd) -> fd.fd_typedef s);
+}
+
+let struct_t0 _ n fields =
+  struct_t1 (fd_gen_of_nonempty_fd fields)
+
+let struct_set_field
+  f v s
+= t_struct_set_field f v s
+
+let struct_get_field
+  s field
+= t_struct_get_field s field
+
+let struct_eq
+  s1 s2
+= s1 `FX.feq` s2
+
+let struct_get_field_same
+  s field v
+= ()
+
+let struct_get_field_other
+  s field v field'
+= ()
+
+let struct0 _ _ _ = struct1 _
+
+let struct_get_field_unknown
+  tn n fields field
+= ()
+
+let struct_get_field_uninitialized
+  tn n fields field
+= ()
+
+let has_struct_field
+  r field r'
+= has_struct_field1 r field r'
+
+let has_struct_field_dup
+  r field r'
+= has_struct_field_dup' r field r'
+
+let has_struct_field_inj
+  r field r1 r2
+= has_struct_field_inj' r field r1 r2
+
+let has_struct_field_equiv_from
+  r1 field r' r2
+= has_struct_field_equiv_from' r1 field r' r2
+
+let has_struct_field_equiv_to
+  r field r1 r2
+= has_struct_field_equiv_to' r field r1 r2
+  
+let ghost_struct_field_focus
+  r field r'
+= noop (); // FIXME: WHY WHY WHY? without this noop, z3 fails to prove precondition of field_description_t.fd_typedef . But also works if I put noop () after the function call
+  ghost_struct_field_focus' r field r'
+
+let ghost_struct_field
+  r field
+= noop (); // FIXME: WHY WHY WHY? (same as ghost_struct_field_focus above)
+  ghost_struct_field' r field
+
+let struct_field0
+  t' #_ #_ #v r field td'
+= let r1' = struct_field' r field in
+  let r' : ref td' = r1' in
+  rewrite (pts_to r1' _) (pts_to r' (struct_get_field v field));
+  rewrite (has_struct_field1 _ _ _) (has_struct_field r field r');
+  return r'
+
+let unstruct_field
+  r field r'
+= unstruct_field' r field r'
+
+let fractionable_struct _ = ()
+let mk_fraction_struct _ _ _ = ()
+
+let full_struct s = full_struct_gen s
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.fsti b/ulib/experimental/Steel.ST.C.Types.Struct.fsti
new file mode 100644
index 00000000000..cc0ceecaaff
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.fsti
@@ -0,0 +1,334 @@
+module Steel.ST.C.Types.Struct
+open Steel.ST.Util
+include Steel.ST.C.Types.Fields
+open Steel.C.Typestring
+
+module P = Steel.FractionalPermission
+
+// To be extracted as: struct t { fields ... }
+
+[@@noextract_to "krml"] // primitive
+val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let define_struct (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
+= define_struct0 tn #tf n fields
+
+// To be extracted as: struct t
+[@@noextract_to "krml"] // primitive
+val struct_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let struct_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
+= struct_t0 tn #tf n fields
+
+val struct_set_field (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields) : GTot (struct_t0 tn n fields)
+
+val struct_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+: GTot (fields.fd_type field)
+
+val struct_eq
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s1 s2: struct_t0 tn n fields)
+: Ghost prop
+  (requires True)
+  (ensures (fun y ->
+    (y <==> (s1 == s2)) /\
+    (y <==> (forall field . struct_get_field s1 field == struct_get_field s2 field))
+  ))
+
+val struct_get_field_same
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+: Lemma
+  (struct_get_field (struct_set_field field v s) field == v)
+  [SMTPat (struct_get_field (struct_set_field field v s) field)]
+
+val struct_get_field_other
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+  (field': field_t fields)
+: Lemma
+  (requires (field' <> field))
+  (ensures (struct_get_field (struct_set_field field v s) field' == struct_get_field s field'))
+
+let struct_get_field_pat
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+  (field': field_t fields)
+: Lemma
+  (struct_get_field (struct_set_field field v s) field' == (if field' = field then v else struct_get_field s field'))
+  [SMTPat (struct_get_field (struct_set_field field v s) field')]
+= if field' = field
+  then ()
+  else struct_get_field_other s field v field'
+
+[@@noextract_to "krml"] // proof-only
+val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
+
+inline_for_extraction
+[@@noextract_to "krml"; norm_field_attr] // proof-only
+let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
+= struct0 tn #tf n fields
+
+val struct_get_field_unknown
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: nonempty_field_description_t tf)
+  (field: field_t fields)
+: Lemma
+  (struct_get_field (unknown (struct0 tn n fields)) field == unknown (fields.fd_typedef field))
+  [SMTPat (struct_get_field (unknown (struct0 tn n fields)) field)]
+
+val struct_get_field_uninitialized
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: nonempty_field_description_t tf)
+  (field: field_t fields)
+: Lemma
+  (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))
+  [SMTPat (struct_get_field (uninitialized (struct0 tn n fields)) field)]
+
+val has_struct_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+
+val has_struct_field_dup
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field r field r')
+    (fun _ -> has_struct_field r field r' `star` has_struct_field r field r')
+
+val has_struct_field_inj
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r1 r2: ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field r field r1 `star` has_struct_field r field r2)
+    (fun _ -> has_struct_field r field r1 `star` has_struct_field r field r2 `star` ref_equiv r1 r2)
+
+val has_struct_field_equiv_from
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r1: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+  (r2: ref (struct0 tn n fields))
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` has_struct_field r1 field r')
+    (fun _ -> ref_equiv r1 r2 `star` has_struct_field r2 field r')
+
+val has_struct_field_equiv_to
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r1': ref (fields.fd_typedef field))
+  (r2': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (ref_equiv r1' r2' `star` has_struct_field r field r1')
+    (fun _ -> ref_equiv r1' r2' `star` has_struct_field r field r2')
+
+val ghost_struct_field_focus
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field r field r' `star` pts_to r v)
+    (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
+
+val ghost_struct_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+    (pts_to r v)
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
+
+[@@noextract_to "krml"] // primitive
+val struct_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (td': typedef t' {
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  })
+: STT (ref td')
+    (pts_to r v)
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
+
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let struct_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+: STT (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field) `star` has_struct_field r field r')
+= struct_field0
+    (norm norm_field_steps (fields.fd_type field))
+    r
+    field
+    (fields.fd_typedef field)
+
+val unstruct_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: STGhost unit opened
+    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field v' v))
+    (
+      struct_get_field v field == unknown (fields.fd_typedef field)
+    )
+    (fun _ -> True)
+
+let unstruct_field_alt
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (#v: Ghost.erased (struct_t0 tn n fields))
+  (r: ref (struct0 tn n fields))
+  (field: field_t fields)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: STGhost (Ghost.erased (struct_t0 tn n fields)) opened
+    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun s' -> has_struct_field r field r' `star` pts_to r s')
+    (
+      struct_get_field v field == unknown (fields.fd_typedef field)
+    )
+    (fun s' -> 
+      Ghost.reveal s' == struct_set_field field v' v
+    )
+= unstruct_field r field r';
+  _
+
+val fractionable_struct
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+: Lemma
+  (fractionable (struct0 tn n fields) s <==> (forall field . fractionable (fields.fd_typedef field) (struct_get_field s field)))
+  [SMTPat (fractionable (struct0 tn n fields) s)]
+
+val mk_fraction_struct
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (p: P.perm)
+  (field: field_t fields)
+: Lemma
+  (requires (fractionable (struct0 tn n fields) s))
+  (ensures (struct_get_field (mk_fraction (struct0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (struct_get_field s field) p))
+  [SMTPat (struct_get_field (mk_fraction (struct0 tn n fields) s p) field)]
+
+(*
+val mk_fraction_struct_recip
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (p: P.perm)
+: Ghost (struct_t0 tn n fields)
+  (requires (
+    (forall field . exists v . fractionable (fields.fd_typedef field) v /\ struct_get_field s field == mk_fraction (fields.fd_typedef field) v p)
+  ))
+  (ensures (fun s' ->
+    fractionable (struct0 tn n fields) s' /\
+    s == mk_fraction (struct0 tn n fields) s' p
+  ))
+*)
+
+val full_struct
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+: Lemma
+  (full (struct0 tn n fields) s <==> (forall field . full (fields.fd_typedef field) (struct_get_field s field)))
+  [SMTPat (full (struct0 tn n fields) s)]
diff --git a/ulib/experimental/Steel.ST.C.Types.Union.fst b/ulib/experimental/Steel.ST.C.Types.Union.fst
new file mode 100644
index 00000000000..216a05a74a5
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Union.fst
@@ -0,0 +1,511 @@
+module Steel.ST.C.Types.Union
+open Steel.ST.GenElim
+friend Steel.ST.C.Types.Base
+open Steel.ST.C.Types.Fields
+open Steel.ST.C.Types.Scalar
+
+open Steel.C.Model.PCM
+
+module GHR = Steel.ST.GhostHigherReference
+module R = Steel.ST.C.Model.Ref
+module HR = Steel.ST.HigherReference
+module U = Steel.ST.C.Model.Union
+
+let define_union0 _ _ _ = unit
+
+[@@noextract_to "krml"] // proof-only
+let union_field_t
+  (#t: Type)
+  (fd: field_description_t t)
+: Tot Type0
+= option (field_t fd)
+
+[@@noextract_to "krml"] // proof-only
+let union_field_type
+  (#t: Type)
+  (fd: field_description_t t)
+  (field: union_field_t fd)
+: Tot Type0
+= match field with
+  | None -> scalar_t unit
+  | Some f -> fd.fd_type f
+
+[@@noextract_to "krml"] // proof-only
+let union_field_typedef
+  (#t: Type)
+  (fd: field_description_t t)
+  (field: union_field_t fd)
+: Tot (typedef (union_field_type fd field))
+= match field with
+  | None -> scalar unit
+  | Some f -> fd.fd_typedef f
+
+[@@noextract_to "krml"] // proof-only
+let union_field_pcm
+  (#t: Type)
+  (fd: field_description_t t)
+  (field: union_field_t fd)
+: Tot (pcm (union_field_type fd field))
+= (union_field_typedef fd field).pcm
+
+let union_t0
+  tn n fields
+= U.union (union_field_pcm fields)
+
+let union_set_field
+  tn n fields f v
+= U.field_to_union_f (union_field_pcm fields) (Some f) v
+
+let union_get_case
+  u
+= match U.case_of_union _ u with
+  | None -> None
+  | Some s -> s
+
+let union_get_field
+  u field
+= U.union_to_field_f _ (Some field) u
+
+let union_get_field_same
+  tn n fields field v
+= ()
+
+module FX = FStar.FunctionalExtensionality
+
+let union_set_field_same
+  #tn #_ #n #fields  s field
+= assert (union_set_field tn n fields field (union_get_field s field) `FX.feq` s)
+
+let union_fractionable
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+: GTot bool
+= match U.case_of_union (union_field_pcm fields) s with
+  | Some f -> (union_field_typedef fields f).fractionable (s f)
+  | _ -> true
+
+let union_fractionable_fields
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (f: union_field_t fields)
+: Lemma
+  (requires (union_fractionable s))
+  (ensures (fractionable (union_field_typedef fields f) (s f)))
+= ()
+
+[@@noextract_to "krml"] // proof-only
+let union_mk_fraction
+  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (p: P.perm)
+: Pure (union_t0 tn n fields)
+  (requires (union_fractionable s))
+  (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> union_fractionable s'))
+= let prf
+    (f: union_field_t fields)
+  : Lemma
+    (let u = one (union_field_typedef fields f).pcm in
+      (union_field_typedef fields f).mk_fraction u p == u
+    )
+  = (union_field_typedef fields f).mk_fraction_one p
+  in
+  Classical.forall_intro prf;
+  FX.on_dom (union_field_t fields) (fun f ->
+    (union_field_typedef fields f).mk_fraction (s f) p
+  )
+
+[@@noextract_to "krml"] // proof-only
+let union_pcm
+  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+: Tot (pcm (union_t0 tn n fields))
+= U.union_pcm (union_field_pcm fields)
+
+let union_eq_intro
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s1 s2: union_t0 tn n fields)
+  (prf: (
+    (f: union_field_t fields) ->
+    Lemma
+    (s1 f == s2 f)
+  ))
+: Lemma
+  (s1 == s2)
+= Classical.forall_intro prf;
+  assert (s1 `FX.feq` s2)
+
+[@@noextract_to "krml"] // proof-only
+let union_uninitialized
+  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
+: Pure (union_t0 tn n fields)
+  (requires True)
+  (ensures (fun y -> exclusive (union_pcm tn n fields) y /\ p_refine (union_pcm tn n fields) y))
+= let y : union_t0 tn n fields =
+    U.field_to_union_f (union_field_pcm fields) None (scalar unit).uninitialized
+  in
+  U.exclusive_union_intro (union_field_pcm fields) y None;
+  y
+
+#push-options "--z3rlimit 16"
+
+#restart-solver
+let union0
+  tn n fields
+= {
+  pcm = union_pcm tn n fields;
+  fractionable = union_fractionable;
+  mk_fraction = union_mk_fraction;
+  mk_fraction_full = (fun x ->
+    union_eq_intro (union_mk_fraction x P.full_perm) x (fun f ->
+      (union_field_typedef fields f).mk_fraction_full (x f)
+    )
+  );
+  mk_fraction_compose = (fun x p1 p2 ->
+    union_eq_intro (union_mk_fraction (union_mk_fraction x p1) p2) (union_mk_fraction x (p1 `prod_perm` p2)) (fun f ->
+      union_fractionable_fields x f;
+      (union_field_typedef fields f).mk_fraction_compose (x f) p1 p2
+    )
+  );
+  fractionable_one = ();
+  mk_fraction_one = (fun p ->
+    union_eq_intro (union_mk_fraction (one (union_pcm tn n fields)) p) (one (union_pcm tn n fields)) (fun f ->
+      (union_field_typedef fields f).mk_fraction_one p
+    )
+  );
+  uninitialized = union_uninitialized _ _ _;
+  mk_fraction_split = (fun v p1 p2 ->
+    U.union_comp_intro (union_field_pcm fields) (union_mk_fraction v p1) (union_mk_fraction v p2) (fun j k ->
+      (union_field_typedef fields j).mk_fraction_one p1;
+      (union_field_typedef fields k).mk_fraction_one p2;
+      assert (j == k);
+      (union_field_typedef fields j).mk_fraction_split (v j) p1 p2
+    )
+  );
+  mk_fraction_join = (fun v p1 p2 ->
+    union_eq_intro (op (union_pcm tn n fields) (union_mk_fraction v p1) (union_mk_fraction v p2)) (union_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
+      (union_field_typedef fields f).mk_fraction_join (v f) p1 p2
+    )
+  );
+  mk_fraction_eq_one = (fun v p ->
+    union_eq_intro v (one (union_pcm tn n fields)) (fun f ->
+      (union_field_typedef fields f).mk_fraction_eq_one (v f) p
+    )
+  );
+}
+
+#pop-options
+
+let union_get_case_unknown
+  tn n fields
+= ()
+
+let union_set_field_unknown
+  tn n fields field
+= ()
+
+let union_get_case_uninitialized
+  tn n fields
+= ()
+
+let mk_fraction_union_get_case
+  #tn #_ #n #fields s p
+= match U.case_of_union (union_field_pcm fields) s with
+  | None -> (union0 tn n fields).mk_fraction_one p
+  | Some f ->
+    Classical.move_requires ((union_field_typedef fields f).mk_fraction_eq_one (s f)) p
+
+let fractionable_union_get_field
+  s field
+= ()
+
+let mk_fraction_union_get_field
+  s p field
+= ()
+
+let mk_fraction_union_set_field
+  tn n fields field v p
+= 
+  assert (fractionable (union0 tn n fields) (union_set_field tn n fields field v));
+  let prf
+    (f: union_field_t fields)
+  : Lemma
+    (let u = one (union_field_typedef fields f).pcm in
+      (union_field_typedef fields f).mk_fraction u p == u
+    )
+  = (union_field_typedef fields f).mk_fraction_one p
+  in
+  Classical.forall_intro prf;
+  assert (mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p `FX.feq` union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p))
+
+let full_union
+  #_ #_ #_ #fields s field
+= Classical.move_requires (U.exclusive_union_intro (union_field_pcm fields) s) (Some field);
+  Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
+
+let has_union_field_gen
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref0_v (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref0_v (fields.fd_typedef field))
+: GTot prop
+= r'.base == r.base /\
+  r'.ref == R.ref_focus r.ref (U.union_field (union_field_pcm fields) (Some field))
+
+let has_union_field_gen_inj
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref0_v (union0 tn n fields))
+  (field: field_t fields)
+  (r1': ref0_v (fields.fd_typedef field))
+  (r2': ref0_v (fields.fd_typedef field))
+: Lemma
+  (requires (has_union_field_gen r field r1' /\ has_union_field_gen r field r2'))
+  (ensures (r1' == r2'))
+= ()
+
+[@@__reduce__]
+let has_union_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
+    HR.pts_to r p w `star`
+    HR.pts_to r' p' w' `star`
+    pure (has_union_field_gen w field w')
+  ))))
+
+let has_union_field
+  r field r'
+= has_union_field0 r field r'
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let has_union_field_dup
+  r field r'
+= rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = gen_elim () in
+  hr_share r;
+  hr_share r';
+  noop ();
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  noop ();
+  rewrite (has_union_field0 r field r') (has_union_field r field r')
+
+#pop-options
+
+#push-options "--z3rlimit 64"
+
+let has_union_field_inj
+  r field r1 r2
+= rewrite (has_union_field r field r1) (has_union_field0 r field r1);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (has_union_field r field r2) (has_union_field0 r field r2);
+  let _ = gen_elim () in
+  hr_gather w r;
+  hr_share r;
+  hr_share r1;
+  rewrite (has_union_field0 r field r1) (has_union_field r field r1);
+  hr_share r2;
+  rewrite (has_union_field0 r field r2) (has_union_field r field r2);
+  let w' = vpattern_replace (HR.pts_to r1 _) in
+  let w2' = vpattern_replace (HR.pts_to r2 _) in
+  has_union_field_gen_inj w field w' w2';
+  vpattern_rewrite (HR.pts_to r2 _) w';
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+#pop-options
+
+#push-options "--z3rlimit 32"
+#restart-solver
+
+let has_union_field_equiv_from
+  r1 r2 field r'
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (has_union_field r1 field r') (has_union_field0 r1 field r');
+  let _ = gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  rewrite (has_union_field0 r2 field r') (has_union_field r2 field r');
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let has_union_field_equiv_to
+  r field r1' r2'
+= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  rewrite (has_union_field r field r1') (has_union_field0 r field r1');
+  let _ = gen_elim () in
+  hr_gather w r1';
+  hr_share r2';
+  rewrite (has_union_field0 r field r2') (has_union_field r field r2');
+  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+
+let ghost_union_field_focus
+  #_ #tn #_ #n #fields #v r field r'
+= rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  hr_gather w r;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
+  assert (v' `FX.feq` v);
+  R.gfocus w.ref (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
+  rewrite (R.pts_to _ _) (R.pts_to w'.ref (union_get_field v field));
+  hr_share r';
+  rewrite (pts_to0 r' _) (pts_to r' _);
+  rewrite (has_union_field0 r field r') (has_union_field r field r')
+
+let ghost_union_field
+  #_ #tn #_ #n #fields #v r field
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
+  }
+  in
+  let gr' = GHR.alloc w' in
+  let r1' = GHR.reveal_ref gr' in
+  GHR.reveal_pts_to gr' P.full_perm w';
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  HR.pts_to_not_null r1';
+  let r' = Ghost.hide r1' in
+  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  hr_share r;
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  ghost_union_field_focus r field r';
+  r'
+
+[@@noextract_to "krml"] // primitive
+let union_field'
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+: STT (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = HR.read r in
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let w' = {
+    base = w.base;
+    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
+  }
+  in
+  let r' = HR.alloc w' in
+  hr_share r;
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  ghost_union_field_focus r field r';
+  return r'
+
+let union_field0
+  t' r field td'
+=
+  let r' = union_field' r field in
+  let res : ref td' = r' in
+  rewrite (pts_to r' _) (pts_to res _);
+  rewrite (has_union_field r field _) (has_union_field r field res);
+  return res
+
+let ununion_field
+  #_ #tn #_ #n #fields r field #v' r'
+= rewrite (has_union_field r field r') (has_union_field0 r field r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r' v') (pts_to0 r' v');
+  let _= gen_elim () in
+  hr_gather w' r';
+  rewrite (r_pts_to _ _) (R.pts_to w'.ref (Ghost.reveal v'));
+  let _ = r_unfocus w'.ref w.ref (coerce_eq () (U.union_field (union_field_pcm fields) (Some field))) _ in
+  hr_share r;
+  rewrite (has_union_field0 r field r') (has_union_field r field r');
+  rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
+  rewrite (pts_to0 r (union_set_field tn n fields field (Ghost.reveal v'))) (pts_to r (union_set_field tn n fields field (Ghost.reveal v')))
+
+[@@noextract_to "krml"] // primitive
+let union_switch_field'
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+: ST (ref (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
+    (full (union0 tn n fields) v)
+    (fun _ -> True)
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = HR.read r in
+  vpattern_rewrite (HR.pts_to r _) w;
+  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let v' : union_t0 tn n fields = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
+  R.ref_upd w.ref _ _ (R.base_fpu (union_pcm tn n fields) _ v');
+  rewrite (pts_to0 r v') (pts_to r v');
+  let r' = union_field' r field in
+  rewrite (pts_to r' _) (pts_to r' (uninitialized (fields.fd_typedef field)));
+  return r'
+
+[@@noextract_to "krml"] // primitive
+let union_switch_field0'
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (td': typedef t')
+  (sq: squash (
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  ))
+: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+    (pts_to r v)
+    (fun r' -> has_union_field r field (coerce_eq () r') `star` pts_to r' (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))))
+    (full (union0 tn n fields) v)
+    (fun _ -> True)
+= let r' = union_switch_field' #tn #tf #n #fields #v r field in
+  let res : ref td' = r' in
+  rewrite (pts_to r' _) (pts_to res (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))));
+  rewrite (has_union_field r field _) (has_union_field r field (coerce_eq () res));
+  return res
+
+let union_switch_field0
+  t' r field td'
+= union_switch_field0' t' r field td' ()
+
+#pop-options
diff --git a/ulib/experimental/Steel.ST.C.Types.Union.fsti b/ulib/experimental/Steel.ST.C.Types.Union.fsti
new file mode 100644
index 00000000000..831b4e15af0
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Union.fsti
@@ -0,0 +1,360 @@
+module Steel.ST.C.Types.Union
+open Steel.ST.Util
+include Steel.ST.C.Types.Fields
+open Steel.C.Typestring
+
+module P = Steel.FractionalPermission
+
+[@@noextract_to "krml"] // primitive
+val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+= define_union0 tn #tf n fields
+
+// To be extracted as: union t
+[@@noextract_to "krml"] // primitive
+val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"]
+let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
+= union_t0 tn #tf n fields
+
+val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
+
+val union_get_case
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (u: union_t0 tn n fields)
+: GTot (option (field_t fields))
+
+val union_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (u: union_t0 tn n fields)
+  (field: field_t fields)
+: Ghost (fields.fd_type field)
+    (requires (union_get_case u == Some field))
+    (ensures (fun _ -> True))
+
+val union_get_field_same
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+: Lemma
+  (requires (~ (v == unknown (fields.fd_typedef field))))
+  (ensures (
+    let u = union_set_field tn n fields field v in
+    union_get_case u == Some field /\
+    union_get_field u field == v
+  ))
+  [SMTPatOr [
+    [SMTPat (union_get_case (union_set_field tn n fields field v))];
+    [SMTPat (union_get_field (union_set_field tn n fields field v) field)];
+  ]]
+
+val union_set_field_same
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (field: field_t fields)
+: Lemma
+  (requires (union_get_case s == Some field))
+  (ensures (
+    union_set_field tn n fields field (union_get_field s field) == s
+  ))
+  [SMTPat (union_set_field tn n fields (union_get_field s field))]
+
+[@@noextract_to "krml"] // proof-only
+val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
+
+inline_for_extraction
+[@@noextract_to "krml"; norm_field_attr] // proof-only
+let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
+= union0 tn #tf n fields
+
+val union_get_case_unknown
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+: Lemma
+  (union_get_case (unknown (union0 tn n fields)) == None)
+  [SMTPat (unknown (union0 tn n fields))]
+
+val union_set_field_unknown
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+: Lemma
+  (union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
+  [SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
+
+val union_get_case_uninitialized
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+: Lemma
+  (union_get_case (uninitialized (union0 tn n fields)) == None)
+  [SMTPat (uninitialized (union0 tn n fields))]
+
+val mk_fraction_union_get_case
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (p: P.perm)
+: Lemma
+  (requires (fractionable (union0 tn n fields) s))
+  (ensures (
+    union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
+  ))
+  [SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
+
+val fractionable_union_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (field: field_t fields)
+: Lemma
+  (requires (union_get_case s == Some field))
+  (ensures (
+    fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
+  ))
+  [SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
+
+val mk_fraction_union_get_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (p: P.perm)
+  (field: field_t fields)
+: Lemma
+  (requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
+  (ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
+  [SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
+
+val mk_fraction_union_set_field
+  (tn: Type0)
+  (#tf: Type0)
+  (n: string)
+  (fields: field_description_t tf)
+  (field: field_t fields)
+  (v: fields.fd_type field)
+  (p: P.perm)
+: Lemma
+  (requires (fractionable (fields.fd_typedef field) v))
+  (ensures (
+    fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
+    mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
+  ))
+
+val full_union
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (s: union_t0 tn n fields)
+  (field: field_t fields)
+: Lemma
+  (requires (union_get_case s == Some field))
+  (ensures (
+    full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
+  ))
+  [SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
+
+val has_union_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+
+val has_union_field_dup
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_union_field r field r')
+    (fun _ -> has_union_field r field r' `star` has_union_field r field r')
+
+val has_union_field_inj
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r1 r2: ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_union_field r field r1 `star` has_union_field r field r2)
+    (fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 r2)
+
+val has_union_field_equiv_from
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r1 r2: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_union_field r1 field r' `star` ref_equiv r1 r2)
+    (fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
+
+val has_union_field_equiv_to
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (r1 r2: ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_union_field r field r1 `star` ref_equiv r1 r2)
+    (fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
+
+val ghost_union_field_focus
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_union_field r field r' `star` pts_to r v)
+    (fun _ -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
+
+val ghost_union_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
+
+[@@noextract_to "krml"] // primitive
+val union_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+  (td': typedef t' {
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  })
+: STT (ref td')
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
+
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let union_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields {union_get_case v == Some field})
+: STT (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
+= union_field0
+    (norm norm_field_steps (fields.fd_type field))
+    r
+    field
+    (fields.fd_typedef field)
+
+val ununion_field
+  (#opened: _)
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (#v': Ghost.erased (fields.fd_type field))
+  (r': ref (fields.fd_typedef field))
+: STGhostT unit opened
+    (has_union_field r field r' `star` pts_to r' v')
+    (fun _ -> has_union_field r field r' `star` pts_to r (union_set_field tn n fields field v'))
+
+// NOTE: we DO NOT support preservation of struct prefixes
+
+[@@noextract_to "krml"] // primitive
+val union_switch_field0
+  (#tn: Type0)
+  (#tf: Type0)
+  (t': Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+  (td': typedef t' {
+    t' ==  fields.fd_type field /\
+    td' == fields.fd_typedef field
+  })
+: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
+    (full (union0 tn n fields) v)
+    (fun r' -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let union_switch_field
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: field_description_t tf)
+  (#v: Ghost.erased (union_t0 tn n fields))
+  (r: ref (union0 tn n fields))
+  (field: field_t fields)
+: ST (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) // need to write the pcm carrier value, so this cannot be Ghost or Atomic
+    (pts_to r v)
+    (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
+    (full (union0 tn n fields) v)
+    (fun r' -> True)
+= union_switch_field0
+    (norm norm_field_steps (fields.fd_type field))
+    r
+    field
+    (fields.fd_typedef field)
diff --git a/ulib/experimental/Steel.ST.C.Types.fst b/ulib/experimental/Steel.ST.C.Types.fst
index b53a9860313..933041ca47d 100644
--- a/ulib/experimental/Steel.ST.C.Types.fst
+++ b/ulib/experimental/Steel.ST.C.Types.fst
@@ -1,2634 +1,6 @@
 module Steel.ST.C.Types
-open Steel.C.Model.PCM
-open Steel.ST.GenElim
 
-#set-options "--smtencoding.elim_box true --smtencoding.l_arith_repr native --smtencoding.nl_arith_repr native"
-
-let prod_perm
-  p1 p2
-= let w = let open FStar.Real in P.MkPerm?.v p1 *. P.MkPerm?.v p2 in
-  assert (let open FStar.Real in (p2 `P.lesser_equal_perm` P.full_perm ==> w <=. P.MkPerm?.v p1 *. 1.0R));
-  P.MkPerm w
-
-noeq
-type typedef (t: Type0) : Type0 = {
-  pcm: pcm t;
-  fractionable: (t -> GTot bool);
-  mk_fraction: (
-    (x: t) ->
-    (p: P.perm) ->
-    Pure t
-    (requires (fractionable x))
-    (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> fractionable y))
-  );
-  mk_fraction_full: (
-    (x: t) ->
-    Lemma
-    (requires (fractionable x))
-    (ensures (fractionable x /\ mk_fraction x P.full_perm == x))
-  );
-  mk_fraction_compose: (
-    (x: t) ->
-    (p1: P.perm) ->
-    (p2: P.perm) ->
-    Lemma
-    (requires (fractionable x /\ p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm))
-    (ensures (mk_fraction (mk_fraction x p1) p2 == mk_fraction x (p1 `prod_perm` p2)))
-  );
-  fractionable_one: squash (fractionable (one pcm));
-  mk_fraction_one: (
-    (p: P.perm) ->
-    Lemma
-    (mk_fraction (one pcm) p == one pcm)
-  );
-  uninitialized: (y: t {
-    exclusive pcm y /\
-    fractionable y /\
-    p_refine pcm y
-  });
-  mk_fraction_split: (
-    (v: t) ->
-    (p1: P.perm) ->
-    (p2: P.perm) ->
-    Lemma
-    (requires (fractionable v /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm))
-    (ensures (
-      composable pcm (mk_fraction v p1) (mk_fraction v p2)
-    ))
-  );
-  mk_fraction_join: (
-    (v: t) ->
-    (p1: P.perm) ->
-    (p2: P.perm) ->
-    Lemma
-    (requires (
-      fractionable v /\
-      composable pcm (mk_fraction v p1) (mk_fraction v p2)
-    ))
-    (ensures (
-      op pcm (mk_fraction v p1) (mk_fraction v p2) == mk_fraction v (p1 `P.sum_perm` p2)
-    ))
-  );
-  mk_fraction_eq_one: (
-    (v: t) ->
-    (p: P.perm) ->
-    Lemma
-    (requires (fractionable v /\ mk_fraction v p == one pcm))
-    (ensures (v == one pcm))
-  );
-}
-
-let fractionable td x = td.fractionable x == true
-let mk_fraction td x p = td.mk_fraction x p
-let mk_fraction_full td x = td.mk_fraction_full x
-let mk_fraction_compose td x p1 p2 = td.mk_fraction_compose x p1 p2
-
-let full td v = exclusive td.pcm v /\ p_refine td.pcm v
-
-let uninitialized td = td.uninitialized
-
-let unknown td = one td.pcm
-
-let full_not_unknown
-  td v
-= ()
-
-let mk_fraction_unknown td p = td.mk_fraction_one p
-let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
-
-module R = Steel.ST.C.Model.Ref
-
-noeq
-type ref0_v (#t: Type) (td: typedef t) : Type u#1 = {
-  base: Type0;
-  ref: R.ref base td.pcm;
-}
-
-module HR = Steel.ST.HigherReference
-
-let ptr #t td = HR.ref (ref0_v td)
-let null td = HR.null
-
-(*
-noeq
-type ref0 : Type0 = {
-  dest: TD.token;
-  typedef: typedef (TD.type_of_token dest);
-  ref: R.ref typedef.pcm;
-}
-
-let void_ptr = option ref0
-let void_null = None
-let type_of_ptr p = TD.type_of_token (Some?.v p).dest
-let typedef_of_ptr p = (Some?.v p).typedef
-*)
-
-let r_pts_to
-  (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
-  (r: R.ref a p) (v: b)
-: vprop
-= R.pts_to r v
-
-[@@__reduce__]
-let pts_to0
-  (#t: Type)
-  (#td: typedef t)
-  (r: ptr td)
-  (v: t)
-: Tot vprop
-= exists_ (fun p -> exists_ (fun w ->
-    HR.pts_to r p w `star`
-    r_pts_to w.ref v
-  ))
-
-let pts_to r v = pts_to0 r v
-
-let pts_to_intro
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-  (p: P.perm)
-  (w1 w2: ref0_v td)
-  (v: t)
-: STGhost unit opened
-    (HR.pts_to r p w1 `star` R.pts_to w2.ref v)
-    (fun _ -> pts_to r v)
-    (w1 == w2)
-    (fun _ -> True)
-= vpattern_rewrite (HR.pts_to r p) w2;
-  rewrite (pts_to0 r v) (pts_to r v)
-
-let is_null
-  p
-= let res = HR.is_null p in
-  return res
-
-[@@__reduce__]
-let ref_equiv0
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: Tot vprop
-= exists_ (fun p1 -> exists_ (fun p2 -> exists_ (fun w ->
-    HR.pts_to r1 p1 w `star`
-    HR.pts_to r2 p2 w
-  )))
-
-let ref_equiv
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: Tot vprop
-= ref_equiv0 r1 r2
-
-let ref_equiv_dup'
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (ref_equiv r1 r2)
-    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r1 r2)
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  HR.share r1;
-  HR.share r2;
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
-  noop ();
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-let ref_equiv_sym'
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (ref_equiv r1 r2)
-    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r1)
-= ref_equiv_dup' r1 r2;
-  rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  noop ();
-  rewrite (ref_equiv0 r2 r1) (ref_equiv r2 r1)
-
-let hr_share (#a:Type)
-          (#uses:_)
-          (#p:P.perm)
-          (#v:a)
-          (r:HR.ref a)
-  : STGhostT unit uses
-      (HR.pts_to r p v)
-      (fun _ -> HR.pts_to r (P.half_perm p) v `star` HR.pts_to r (P.half_perm p) v)
-= HR.share #_ #_ #_ #v r
-
-let hr_gather
-  (#a:Type)
-  (#uses:_) 
-  (#p0 #p1:P.perm)
-  (v0 #v1:a)
-  (r:HR.ref a)
-: STGhost unit uses
-      (HR.pts_to r p0 v0 `star` HR.pts_to r p1 v1)
-      (fun _ -> HR.pts_to r (P.sum_perm p0 p1) v0)
-      (requires True)
-      (ensures fun _ -> v0 == v1)
-= HR.gather p1 r
-
-let ref_equiv_trans'
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2 r3: ref td)
-: STGhostT unit opened
-    (ref_equiv r1 r2 `star` ref_equiv r2 r3)
-    (fun _ -> ref_equiv r1 r2 `star` ref_equiv r2 r3 `star` ref_equiv r1 r3)
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  let p2 = vpattern_replace (fun p -> HR.pts_to r2 p _) in
-  rewrite (ref_equiv r2 r3) (ref_equiv0 r2 r3);
-  let _ = gen_elim () in
-  HR.pts_to_injective_eq #_ #_ #_ #_ #w #_ r2;
-  vpattern_rewrite (HR.pts_to r3 _) w;
-  hr_share r1;
-  hr_share r3;
-  HR.gather p2 r2;
-  hr_share r2;
-  noop ();
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2);
-  rewrite (ref_equiv0 r2 r3) (ref_equiv r2 r3);
-  rewrite (ref_equiv0 r1 r3) (ref_equiv r1 r3)
-
-let hr_share_imbalance (#a:Type)
-          (#uses:_)
-          (#p:P.perm)
-          (#v:a)
-          (r:HR.ref a)
-  : STGhostT P.perm uses
-      (HR.pts_to r p v)
-      (fun p1 -> HR.pts_to r p1 v `star` exists_ (fun p2 -> HR.pts_to r p2 v))
-= HR.share #_ #_ #_ #v r;
-  _
-
-#set-options "--ide_id_info_off"
-
-let pts_to_equiv
-  r1 r2 v
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  rewrite (pts_to r1 v) (pts_to0 r1 v);
-  let _ = gen_elim () in
-  hr_gather w r1;
-  hr_share r2;
-  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
-  rewrite (pts_to0 r2 v) (pts_to r2 v);
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-[@@__steel_reduce__; __reduce__]
-let freeable0
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-: Tot vprop
-= exists_ (fun p -> exists_ (fun w ->
-    HR.pts_to r p w `star`
-    pure (R.freeable w.ref)
-  ))
-
-let freeable
-  r
-= freeable0 r
-
-let freeable_dup
-  r
-= rewrite (freeable r) (freeable0 r);
-  let _ = gen_elim () in
-  HR.share r;
-  noop ();
-  rewrite (freeable0 r) (freeable r);
-  noop ();
-  rewrite (freeable0 r) (freeable r)
-
-let freeable_equiv
-  r1 r2
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  rewrite (freeable r1) (freeable0 r1);
-  let _ = gen_elim () in
-  hr_gather w r1;
-  HR.share r2;
-  rewrite (freeable0 r2) (freeable r2);
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-let alloc
-  td
-= let r = R.ref_alloc td.pcm td.uninitialized in
-  let w = {
-    base = _;
-    ref = r;
-  }
-  in
-  rewrite (R.pts_to _ _) (R.pts_to w.ref (uninitialized td));
-  let res = HR.alloc w in
-  HR.share res;
-  HR.pts_to_not_null res;
-  rewrite (pts_to0 res (uninitialized td)) (pts_to_or_null res (uninitialized td));
-  rewrite (freeable0 res) (freeable_or_null res);
-  return res
-
-let free
-  #_ #_ #v r
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = HR.read r in
-  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
-  rewrite (freeable r) (freeable0 r);
-  let _ = gen_elim () in
-  hr_gather w r;
-  R.ref_free w.ref;
-  drop (HR.pts_to _ _ _);
-  return ()
-
-let mk_fraction_split_gen
-  #_ #_ #td r v p p1 p2
-= rewrite (pts_to _ _) (pts_to0 r (mk_fraction td v p));
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  td.mk_fraction_split v p1 p2;
-  td.mk_fraction_join v p1 p2;
-  rewrite
-    (R.pts_to _ _)
-    (R.pts_to w.ref (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)));
-  R.split _ _ (td.mk_fraction v p1) (td.mk_fraction v p2);
-  HR.share r;
-  rewrite (pts_to0 r (td.mk_fraction v p1)) (pts_to r (mk_fraction td v p1));
-  rewrite (pts_to0 r (td.mk_fraction v p2)) (pts_to r (mk_fraction td v p2))
-
-let mk_fraction_join
-  #_ #_ #td r v p1 p2
-= rewrite (pts_to r (mk_fraction td v p1)) (pts_to0 r (mk_fraction td v p1));
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (R.pts_to _ _) (R.pts_to w.ref (td.mk_fraction v p1));
-  rewrite (pts_to r (mk_fraction td v p2)) (pts_to0 r (mk_fraction td v p2));
-  let _ = gen_elim () in
-  hr_gather w r;
-  rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to w.ref (td.mk_fraction v p2));
-  let _ = R.gather w.ref (td.mk_fraction v p1) _ in
-  td.mk_fraction_join v p1 p2;
-  rewrite (pts_to0 r _) (pts_to r _)
-
-module F = Steel.ST.C.Model.Frac
-
-let scalar_t t = F.fractional (option t)
-
-let scalar_fractionable
-  (#t: Type)
-  (s: scalar_t t)
-: GTot bool
-= match s with
-  | Some (_, p) -> p `P.lesser_equal_perm` P.full_perm
-  | _ -> true
-
-[@@noextract_to "krml"] // proof-only
-let scalar_mk_fraction
-  (#t: Type)
-  (x: scalar_t t)
-  (p: P.perm)
-: Pure (scalar_t t)
-    (requires (scalar_fractionable x))
-    (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> scalar_fractionable y))
-= match x with
-  | (Some (v, p')) ->
-    (Some (v, p `prod_perm` p'))
-  | _ -> x
-
-#restart-solver
-let scalar t = {
-  pcm = F.pcm_frac;
-  fractionable = scalar_fractionable #t;
-  mk_fraction = scalar_mk_fraction #t;
-  mk_fraction_full = (fun x ->
-    match x with
-    | (Some (v, p)) ->
-      assert_norm ((P.full_perm `prod_perm` p).v == (let open FStar.Real in 1.0R *. p.v));
-      assert (P.full_perm `prod_perm` p == p)
-    | _ -> ()
-  );
-  mk_fraction_compose = (fun w p1 p2 ->
-    match w with
-    | (Some (v, p)) ->
-      assert_norm (let open FStar.Real in ((p1 `prod_perm` p2) `prod_perm` p).v == (p1.v *. p2.v) *. p.v);
-      assert_norm (let open FStar.Real in (p2 `prod_perm` (p1 `prod_perm` p)).v == p2.v *. (p1.v *. p.v));
-      assert ((p1 `prod_perm` p2) `prod_perm` p == p2 `prod_perm` (p1 `prod_perm` p))
-    | _ -> ()
-  );
-  fractionable_one = ();
-  mk_fraction_one = (fun _ -> ());
-  uninitialized = Some (None, P.full_perm);
-  mk_fraction_split = (fun w p1 p2 ->
-    match w with
-    | (Some (v, p)) ->
-      assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
-      assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
-      assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p));
-      assert (composable (F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2));
-()   //   assert (op (U.pcm_uninit F.pcm_frac) (scalar_mk_fraction w p1) (scalar_mk_fraction w p2) == scalar_mk_fraction w (p1 `P.sum_perm` p2))
-    | _ -> ()
-  );
-  mk_fraction_join = (fun w p1 p2 ->
-    match w with
-    | (Some (v, p)) ->
-      assert_norm (((p1 `P.sum_perm` p2) `prod_perm` p).v == (let open FStar.Real in (p1.v +. p2.v) *. p.v));
-      assert_norm (((p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p)).v == (let open FStar.Real in (p1.v *. p.v) +. (p2.v *. p.v)));
-      assert ((p1 `P.sum_perm` p2) `prod_perm` p == (p1 `prod_perm` p) `P.sum_perm` (p2 `prod_perm` p))
-    | _ -> ()
-  );
-  mk_fraction_eq_one = (fun v p -> ());
-}
-
-let mk_scalar v = (Some (Some v, P.full_perm))
-
-let mk_scalar_fractionable v p = ()
-
-let mk_scalar_inj v1 v2 p1 p2 = ()
-
-#push-options "--z3rlimit 16"
-
-#restart-solver
-
-let scalar_unique
-  #_ #t v1 v2 p1 p2 r
-= rewrite (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1)));
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (r_pts_to _ (Some (Some v1, p1))) (R.pts_to w.ref (Some (Some v1, p1)));
-  rewrite (pts_to r _) (pts_to0 r (Some (Some v2, p2)));
-  let _ = gen_elim () in
-  hr_gather w r;
-  rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to w.ref (Some (Some v2, p2)));
-  let _ = R.gather w.ref (Some (Some v1, p1)) (Some (Some v2, p2)) in
-  R.split w.ref _ (Some (Some v1, p1)) (Some (Some v2, p2));
-  HR.share r;
-  noop (); // FIXME: WHY WHY WHY?
-  rewrite (pts_to0 r (Some (Some v1, p1))) (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1));
-  rewrite (pts_to0 r (Some (Some v2, p2))) (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
-
-#pop-options
-
-let read0
-  #t #v #p r
-= rewrite (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p)));
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Some (Some (Ghost.reveal v), p)));
-  let v' = R.ref_read w.ref in
-  let Some (Some v0, _) = v' in
-  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v), p)));
-  rewrite (pts_to0 r (Some (Some (Ghost.reveal v), p))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p));
-  return v0
-
-let write
-  #t #v r v'
-= rewrite (pts_to r _) (pts_to0 r (Ghost.reveal v));
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
-  R.ref_upd w.ref _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
-  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v'), P.full_perm)));
-  rewrite (pts_to0 r (Some (Some (Ghost.reveal v'), P.full_perm))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v')) P.full_perm))
-
-let field_t_nil = unit
-let field_t_cons _ _ _ = unit
-
-irreducible let norm_field_attr = ()
-
-let define_struct0 _ _ _ = unit
-
-[@@noextract_to "krml"]
-noeq
-type field_description_gen_t (field_t: eqtype) : Type u#1 = {
-  fd_nonempty: squash (exists (f: field_t) . True);
-  fd_type: (field_t -> Type0);
-  fd_typedef: ((s: field_t) -> Tot (typedef (fd_type s)));
-}
-
-let nonempty_field_description_nonempty
-  (#tf: Type)
-  (fd: nonempty_field_description_t tf)
-: Lemma
-  (exists (f: field_t fd) . True)
-= if StrongExcludedMiddle.strong_excluded_middle (exists (f: field_t fd) . True)
-  then ()
-  else begin
-    let prf
-      (f: string)
-    : Lemma
-      (fd.fd_def f == false)
-    = if fd.fd_def f
-      then Classical.exists_intro (fun (f: field_t fd) -> True) f
-      else ()
-    in
-    Classical.forall_intro prf
-  end
-
-[@@noextract_to "krml"]
-let fd_gen_of_nonempty_fd (#tf: Type0) (fd: nonempty_field_description_t tf) : Tot (field_description_gen_t (field_t fd)) = {
-  fd_nonempty = nonempty_field_description_nonempty fd;
-  fd_type = fd.fd_type;
-  fd_typedef = (fun (s: field_t fd) -> fd.fd_typedef s);
-}
-
-module S = Steel.ST.C.Model.Struct
-
-[@@noextract_to "krml"] // proof-only
-let struct_field_pcm
-  (#field_t: eqtype)
-  (fields: field_description_gen_t field_t)
-  (f: field_t)
-: Tot (pcm (fields.fd_type f))
-= (fields.fd_typedef f).pcm
-
-module FX = FStar.FunctionalExtensionality
-
-[@@noextract_to "krml"] // primitive
-let struct_t1 (#field_t: eqtype) (fields: field_description_gen_t field_t) : Tot Type0 =
-  FX.restricted_t field_t fields.fd_type
-
-let struct_t0 _ n fields =
-  struct_t1 (fd_gen_of_nonempty_fd fields)
-
-[@@noextract_to "krml"] // proof-only
-let struct_pcm
-  (#field_t: eqtype)
-  (fields: field_description_gen_t field_t)
-: Tot (pcm (struct_t1 fields))
-= S.prod_pcm (struct_field_pcm fields)
-
-[@@noextract_to "krml"] // proof-only
-let t_struct_set_field
-  (#field_t: eqtype) (#fields: field_description_gen_t field_t) (f: field_t) (v: fields.fd_type f) (s: struct_t1 fields)
-: Tot (struct_t1 fields)
-= FX.on_dom (field_t) (fun f' -> if f = f' then v else s f')
-
-let struct_set_field
-  f v s
-= t_struct_set_field f v s
-
-[@@noextract_to "krml"] // proof-only
-let t_struct_get_field
-  (#field_t: eqtype) (#fields: field_description_gen_t field_t) (s: struct_t1 fields) (f: field_t)
-: Tot (fields.fd_type f)
-= s f
-
-let struct_get_field
-  s field
-= t_struct_get_field s field
-
-let struct_eq
-  s1 s2
-= s1 `FX.feq` s2
-
-let struct_eq_intro
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (s1 s2: struct_t1 fields)
-  (prf: (
-    (f: field_t) ->
-    Lemma
-    (s1 f == s2 f)
-  ))
-: Lemma
-  (s1 == s2)
-= Classical.forall_intro prf;
-  assert (s1 `FX.feq` s2)
-
-let struct_get_field_same
-  s field v
-= ()
-
-let struct_get_field_other
-  s field v field'
-= ()
-
-let struct_fractionable
-  (#field_t: eqtype) (#fields: field_description_gen_t field_t)
-  (s: struct_t1 fields)
-: GTot bool
-= FStar.StrongExcludedMiddle.strong_excluded_middle (forall (f: field_t) . (fields.fd_typedef f).fractionable (s f))
-
-[@@noextract_to "krml"] // proof-only
-let struct_mk_fraction
-  (#field_t: eqtype) (#fields: field_description_gen_t field_t)
-  (s: struct_t1 fields)
-  (p: P.perm)
-: Pure (struct_t1 fields)
-  (requires (struct_fractionable s))
-  (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> struct_fractionable s'))
-= FX.on_dom field_t (fun f -> (fields.fd_typedef f).mk_fraction (s f) p)
-
-[@@noextract_to "krml"] // proof-only
-let struct_uninitialized
-  (#field_t: eqtype) (fields: field_description_gen_t field_t)
-: Pure (struct_t1 fields)
-    (requires True)
-    (ensures (fun y -> p_refine (struct_pcm fields) y))
-= FX.on_dom field_t (fun f -> (fields.fd_typedef f).uninitialized <: fields.fd_type f)
-
-let struct1
-  (#field_t: eqtype)
-  (fields: field_description_gen_t field_t)
-= {
-  pcm = struct_pcm fields;
-  fractionable = struct_fractionable;
-  mk_fraction = struct_mk_fraction;
-  mk_fraction_full = (fun x ->
-    struct_eq_intro (struct_mk_fraction x P.full_perm) x (fun f ->
-      (fields.fd_typedef f).mk_fraction_full (x f)
-    )
-  );
-  mk_fraction_compose = (fun x p1 p2 ->
-    struct_eq_intro (struct_mk_fraction (struct_mk_fraction x p1) p2) (struct_mk_fraction x (p1 `prod_perm` p2)) (fun f ->
-      (fields.fd_typedef f).mk_fraction_compose (x f) p1 p2
-    )
-  );
-  fractionable_one = ();
-  mk_fraction_one = (fun p ->
-    struct_eq_intro (struct_mk_fraction (one (struct_pcm fields)) p) (one (struct_pcm fields)) (fun f ->
-      (fields.fd_typedef f).mk_fraction_one p
-    )
-  );
-  uninitialized = struct_uninitialized _;
-  mk_fraction_split = (fun v p1 p2 ->
-    let prf
-      (f: field_t)
-    : Lemma
-      (composable (fields.fd_typedef f).pcm (mk_fraction (fields.fd_typedef f) (v f) p1) (mk_fraction (fields.fd_typedef f) (v f) p2))
-    = (fields.fd_typedef f).mk_fraction_split (v f) p1 p2
-    in
-    Classical.forall_intro prf
-  );
-  mk_fraction_join = (fun v p1 p2 ->
-    struct_eq_intro (op (struct_pcm fields) (struct_mk_fraction v p1) (struct_mk_fraction v p2)) (struct_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
-      (fields.fd_typedef f).mk_fraction_join (v f) p1 p2
-    )
-  );
-  mk_fraction_eq_one = (fun v p ->
-    struct_eq_intro v (one (struct_pcm fields)) (fun f ->
-      (fields.fd_typedef f).mk_fraction_eq_one (v f) p
-    )
-  );
-}
-
-let struct0 _ _ _ = struct1 _
-
-let struct_get_field_unknown
-  tn n fields field
-= ()
-
-let struct_get_field_uninitialized
-  tn n fields field
-= ()
-
-let has_struct_field_gen
-  (#field_t: eqtype)
-  (fields: field_description_gen_t field_t)
-  (r: ref0_v (struct1 fields))
-  (field: field_t)
-  (r': ref0_v (fields.fd_typedef field))
-: GTot prop
-= r'.base == r.base /\
-  r'.ref == R.ref_focus r.ref (S.struct_field (struct_field_pcm fields) field)
-
-[@@__reduce__]
-let has_struct_field0
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r': ref (fields.fd_typedef field))
-: Tot vprop
-= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
-    HR.pts_to r p w `star`
-    HR.pts_to r' p' w' `star`
-    pure (has_struct_field_gen fields w field w')
-  ))))
-
-let has_struct_field1
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r': ref (fields.fd_typedef field))
-: Tot vprop
-= has_struct_field0 r field r'
-
-let has_struct_field
-  r field r'
-= has_struct_field1 r field r'
-
-let has_struct_field_dup'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_struct_field1 r field r')
-    (fun _ -> has_struct_field1 r field r' `star` has_struct_field1 r field r')
-=
-  rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = gen_elim () in
-  HR.share r;
-  HR.share r';
-  noop ();
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  noop ();
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
-
-let has_struct_field_dup
-  r field r'
-= has_struct_field_dup' r field r'
-
-let has_struct_field_inj'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r1 r2: ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_struct_field1 r field r1 `star` has_struct_field1 r field r2)
-    (fun _ -> has_struct_field1 r field r1 `star` has_struct_field1 r field r2 `star` ref_equiv r1 r2)
-=
-  rewrite (has_struct_field1 r field r1) (has_struct_field0 r field r1);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w1 = vpattern_replace (HR.pts_to r1 _) in
-  rewrite (has_struct_field1 r field r2) (has_struct_field0 r field r2);
-  let _ = gen_elim () in
-  hr_gather w r;
-  vpattern_rewrite (HR.pts_to r2 _) w1;
-  hr_share r;
-  hr_share r1;
-  rewrite (has_struct_field0 r field r1) (has_struct_field1 r field r1);
-  hr_share r2;
-  rewrite (has_struct_field0 r field r2) (has_struct_field1 r field r2);
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-let has_struct_field_inj
-  r field r1 r2
-= has_struct_field_inj' r field r1 r2
-
-let has_struct_field_equiv_from'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r1: ref (struct1 fields))
-  (field: field_t)
-  (r': ref (fields.fd_typedef field))
-  (r2: ref (struct1 fields))
-: STGhostT unit opened
-    (ref_equiv r1 r2 `star` has_struct_field1 r1 field r')
-    (fun _ -> ref_equiv r1 r2 `star` has_struct_field1 r2 field r')
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  rewrite (has_struct_field1 r1 field r') (has_struct_field0 r1 field r');
-  let _ = gen_elim () in
-  hr_gather w r1;
-  hr_share r2;
-  rewrite (has_struct_field0 r2 field r') (has_struct_field1 r2 field r');
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-let has_struct_field_equiv_from
-  r1 field r' r2
-= has_struct_field_equiv_from' r1 field r' r2
-
-let has_struct_field_equiv_to'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r1': ref (fields.fd_typedef field))
-  (r2': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (ref_equiv r1' r2' `star` has_struct_field1 r field r1')
-    (fun _ -> ref_equiv r1' r2' `star` has_struct_field1 r field r2')
-= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
-  rewrite (has_struct_field1 r field r1') (has_struct_field0 r field r1');
-  let _ = gen_elim () in
-  hr_gather w r1';
-  hr_share r2';
-  rewrite (has_struct_field0 r field r2') (has_struct_field1 r field r2');
-  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
-
-let has_struct_field_equiv_to
-  r field r1 r2
-= has_struct_field_equiv_to' r field r1 r2
-
-let ghost_struct_field_focus'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (#v: Ghost.erased (struct_t1 fields))
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_struct_field1 r field r' `star` pts_to r v)
-    (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field))
-= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w' = vpattern_replace (HR.pts_to r' _) in
-  rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  hr_gather w r;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
-  let prf
-    (f': field_t)
-    (x: (fields.fd_type f'))
-  : Lemma
-    (let p = (fields.fd_typedef f').pcm in
-      composable p x (one p) /\
-      op p x (one p) == x
-    )
-  = is_unit (fields.fd_typedef f').pcm x
-  in
-  Classical.forall_intro_2 prf;
-  let v' = t_struct_set_field field (unknown (fields.fd_typedef field)) v in
-  let vf = S.field_to_struct_f (struct_field_pcm _) field (t_struct_get_field v field) in
-  assert (composable (struct_pcm _) v' vf);
-  assert (op (struct_pcm _) v' vf `FX.feq` v);
-  R.split w.ref _ v' vf;
-  R.gfocus w.ref (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
-  hr_share r;
-  hr_share r';
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r v') (pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v));
-  rewrite (R.pts_to _ _) (r_pts_to w'.ref (t_struct_get_field v field));
-  rewrite (pts_to0 r' (t_struct_get_field v field)) (pts_to r' (t_struct_get_field v field))
-  
-let ghost_struct_field_focus
-  r field r'
-= noop (); // FIXME: WHY WHY WHY? without this noop, z3 fails to prove precondition of field_description_t.fd_typedef . But also works if I put noop () after the function call
-  ghost_struct_field_focus' r field r'
-
-module GHR = Steel.ST.GhostHigherReference
-
-let ghost_struct_field'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (#v: Ghost.erased (struct_t1 fields))
-  (r: ref (struct1 fields))
-  (field: field_t)
-: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
-    (pts_to r v)
-    (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
-  let w' = {
-    base = w.base;
-    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
-  }
-  in
-  let gr' = GHR.alloc w' in
-  let r1' = GHR.reveal_ref gr' in
-  GHR.reveal_pts_to gr' P.full_perm w';
-  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
-  HR.pts_to_not_null r1';
-  let r' = Ghost.hide r1' in
-  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
-  hr_share r;
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
-  ghost_struct_field_focus' r field r';
-  r'
-
-let ghost_struct_field
-  r field
-= noop (); // FIXME: WHY WHY WHY? (same as ghost_struct_field_focus above)
-  ghost_struct_field' r field
-
-let struct_field'
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (#v: Ghost.erased (struct_t1 fields))
-  (r: ref (struct1 fields))
-  (field: field_t)
-: STT (ref (fields.fd_typedef field))
-    (pts_to r v)
-    (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
-  let w' = {
-    base = w.base;
-    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
-  }
-  in
-  let r' = HR.alloc w' in
-  hr_share r;
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
-  ghost_struct_field_focus' r field r';
-  return r'
-
-let struct_field0
-  t' #_ #_ #v r field td'
-= let r1' = struct_field' r field in
-  let r' : ref td' = r1' in
-  rewrite (pts_to r1' _) (pts_to r' (struct_get_field v field));
-  rewrite (has_struct_field1 _ _ _) (has_struct_field r field r');
-  return r'
-
-let r_unfocus (#opened:_)
-  (#ta #ta' #tb #tc: Type)
-  (#p: pcm tb)
-  (#q: pcm tc)
-  (r: R.ref ta q) (r': R.ref ta' p)
-  (l: Steel.C.Model.Connection.connection p q) (x: tc)
-: STGhost (Ghost.erased tb) opened
-    (r `R.pts_to` x)
-    (fun x' -> r' `R.pts_to` x')
-    (requires
-      ta == ta' /\
-      r == R.ref_focus r' l)
-    (ensures fun x' -> Ghost.reveal x' == l.conn_small_to_large.morph x)
-= let r1 : R.ref ta' q = r in
-  rewrite (r `R.pts_to` x) (r1 `R.pts_to` x);
-  R.unfocus r1 r' l x;
-  let x' = vpattern_replace_erased (R.pts_to r') in
-  x'
-
-let unstruct_field'
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (#v: Ghost.erased (struct_t1 fields))
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (#v': Ghost.erased (fields.fd_type field))
-  (r': ref (fields.fd_typedef field))
-: STGhost unit opened
-    (has_struct_field1 r field r' `star` pts_to r v `star` pts_to r' v')
-    (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field v' v))
-    (
-      t_struct_get_field v field == unknown (fields.fd_typedef field)
-    )
-    (fun _ -> True)
-= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w' = vpattern_replace (HR.pts_to r' _) in
-  rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  hr_gather w r;
-  rewrite (r_pts_to _ (Ghost.reveal v)) (R.pts_to w.ref (Ghost.reveal v));
-  rewrite (pts_to r' v') (pts_to0 r' v');
-  let _ = gen_elim () in
-  hr_gather w' r';
-  rewrite (r_pts_to _ (Ghost.reveal v')) (R.pts_to w'.ref (Ghost.reveal v'));
-  let prf
-    (f': field_t)
-    (x: (fields.fd_type f'))
-  : Lemma
-    (let p = (fields.fd_typedef f').pcm in
-      composable p x (one p) /\
-      op p x (one p) == x
-    )
-  = is_unit (fields.fd_typedef f').pcm x
-  in
-  Classical.forall_intro_2 prf;
-  let vf = S.field_to_struct_f (struct_field_pcm _) field v' in
-  assert (composable (struct_pcm _) v vf);
-  assert (op (struct_pcm _) v vf `FX.feq` t_struct_set_field field v' v);
-  let _ = r_unfocus w'.ref w.ref (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
-  let _ = R.gather w.ref (Ghost.reveal v) _ in
-  hr_share r;
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r _) (pts_to r _)
-
-let unstruct_field
-  r field r'
-= unstruct_field' r field r'
-
-let fractionable_struct _ = ()
-let mk_fraction_struct _ _ _ = ()
-
-let full_struct_gen
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (s: struct_t1 fields)
-: Lemma
-  (full (struct1 fields) s <==> (forall field . full (fields.fd_typedef field) (s field)))
-=
-  let is_unit'
-    (f': field_t)
-    (x: (fields.fd_type f'))
-  : Lemma
-    (let p = (fields.fd_typedef f').pcm in
-      composable p x (one p) /\
-      op p x (one p) == x
-    )
-  = is_unit (fields.fd_typedef f').pcm x
-  in
-  Classical.forall_intro_2 is_unit';
-  let prf
-    (field: field_t)
-  : Lemma
-    (requires (full (struct1 fields) s))
-    (ensures (full (fields.fd_typedef field) (s field)))
-  = let prf'
-      (x: fields.fd_type field)
-    : Lemma
-      (requires (composable (fields.fd_typedef field).pcm (s field) x))
-      (ensures (x == one (fields.fd_typedef field).pcm))
-    = let s' = t_struct_set_field field x (one (struct_pcm fields)) in
-      assert (composable (struct_pcm fields) s s')
-    in
-    Classical.forall_intro (Classical.move_requires prf')
-  in
-  Classical.forall_intro (Classical.move_requires prf)
-
-let full_struct s = full_struct_gen s
-
-module U = Steel.ST.C.Model.Union
-
-let define_union0 _ _ _ = unit
-
-[@@noextract_to "krml"] // proof-only
-let union_field_t
-  (#t: Type)
-  (fd: field_description_t t)
-: Tot Type0
-= option (field_t fd)
-
-[@@noextract_to "krml"] // proof-only
-let union_field_type
-  (#t: Type)
-  (fd: field_description_t t)
-  (field: union_field_t fd)
-: Tot Type0
-= match field with
-  | None -> scalar_t unit
-  | Some f -> fd.fd_type f
-
-[@@noextract_to "krml"] // proof-only
-let union_field_typedef
-  (#t: Type)
-  (fd: field_description_t t)
-  (field: union_field_t fd)
-: Tot (typedef (union_field_type fd field))
-= match field with
-  | None -> scalar unit
-  | Some f -> fd.fd_typedef f
-
-[@@noextract_to "krml"] // proof-only
-let union_field_pcm
-  (#t: Type)
-  (fd: field_description_t t)
-  (field: union_field_t fd)
-: Tot (pcm (union_field_type fd field))
-= (union_field_typedef fd field).pcm
-
-let union_t0
-  tn n fields
-= U.union (union_field_pcm fields)
-
-let union_set_field
-  tn n fields f v
-= U.field_to_union_f (union_field_pcm fields) (Some f) v
-
-let union_get_case
-  u
-= match U.case_of_union _ u with
-  | None -> None
-  | Some s -> s
-
-let union_get_field
-  u field
-= U.union_to_field_f _ (Some field) u
-
-let union_get_field_same
-  tn n fields field v
-= ()
-
-let union_set_field_same
-  #tn #_ #n #fields  s field
-= assert (union_set_field tn n fields field (union_get_field s field) `FX.feq` s)
-
-let union_fractionable
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-: GTot bool
-= match U.case_of_union (union_field_pcm fields) s with
-  | Some f -> (union_field_typedef fields f).fractionable (s f)
-  | _ -> true
-
-let union_fractionable_fields
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (f: union_field_t fields)
-: Lemma
-  (requires (union_fractionable s))
-  (ensures (fractionable (union_field_typedef fields f) (s f)))
-= ()
-
-[@@noextract_to "krml"] // proof-only
-let union_mk_fraction
-  (#tn: Type0) (#tf: Type0) (#n: string) (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (p: P.perm)
-: Pure (union_t0 tn n fields)
-  (requires (union_fractionable s))
-  (ensures (fun s' -> p `P.lesser_equal_perm` P.full_perm ==> union_fractionable s'))
-= let prf
-    (f: union_field_t fields)
-  : Lemma
-    (let u = one (union_field_typedef fields f).pcm in
-      (union_field_typedef fields f).mk_fraction u p == u
-    )
-  = (union_field_typedef fields f).mk_fraction_one p
-  in
-  Classical.forall_intro prf;
-  FX.on_dom (union_field_t fields) (fun f ->
-    (union_field_typedef fields f).mk_fraction (s f) p
-  )
-
-[@@noextract_to "krml"] // proof-only
-let union_pcm
-  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
-: Tot (pcm (union_t0 tn n fields))
-= U.union_pcm (union_field_pcm fields)
-
-let union_eq_intro
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (s1 s2: union_t0 tn n fields)
-  (prf: (
-    (f: union_field_t fields) ->
-    Lemma
-    (s1 f == s2 f)
-  ))
-: Lemma
-  (s1 == s2)
-= Classical.forall_intro prf;
-  assert (s1 `FX.feq` s2)
-
-[@@noextract_to "krml"] // proof-only
-let union_uninitialized
-  (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf)
-: Pure (union_t0 tn n fields)
-  (requires True)
-  (ensures (fun y -> exclusive (union_pcm tn n fields) y /\ p_refine (union_pcm tn n fields) y))
-= let y : union_t0 tn n fields =
-    U.field_to_union_f (union_field_pcm fields) None (scalar unit).uninitialized
-  in
-  U.exclusive_union_intro (union_field_pcm fields) y None;
-  y
-
-#push-options "--z3rlimit 16"
-
-#restart-solver
-let union0
-  tn n fields
-= {
-  pcm = union_pcm tn n fields;
-  fractionable = union_fractionable;
-  mk_fraction = union_mk_fraction;
-  mk_fraction_full = (fun x ->
-    union_eq_intro (union_mk_fraction x P.full_perm) x (fun f ->
-      (union_field_typedef fields f).mk_fraction_full (x f)
-    )
-  );
-  mk_fraction_compose = (fun x p1 p2 ->
-    union_eq_intro (union_mk_fraction (union_mk_fraction x p1) p2) (union_mk_fraction x (p1 `prod_perm` p2)) (fun f ->
-      union_fractionable_fields x f;
-      (union_field_typedef fields f).mk_fraction_compose (x f) p1 p2
-    )
-  );
-  fractionable_one = ();
-  mk_fraction_one = (fun p ->
-    union_eq_intro (union_mk_fraction (one (union_pcm tn n fields)) p) (one (union_pcm tn n fields)) (fun f ->
-      (union_field_typedef fields f).mk_fraction_one p
-    )
-  );
-  uninitialized = union_uninitialized _ _ _;
-  mk_fraction_split = (fun v p1 p2 ->
-    U.union_comp_intro (union_field_pcm fields) (union_mk_fraction v p1) (union_mk_fraction v p2) (fun j k ->
-      (union_field_typedef fields j).mk_fraction_one p1;
-      (union_field_typedef fields k).mk_fraction_one p2;
-      assert (j == k);
-      (union_field_typedef fields j).mk_fraction_split (v j) p1 p2
-    )
-  );
-  mk_fraction_join = (fun v p1 p2 ->
-    union_eq_intro (op (union_pcm tn n fields) (union_mk_fraction v p1) (union_mk_fraction v p2)) (union_mk_fraction v (p1 `P.sum_perm` p2)) (fun f ->
-      (union_field_typedef fields f).mk_fraction_join (v f) p1 p2
-    )
-  );
-  mk_fraction_eq_one = (fun v p ->
-    union_eq_intro v (one (union_pcm tn n fields)) (fun f ->
-      (union_field_typedef fields f).mk_fraction_eq_one (v f) p
-    )
-  );
-}
-
-#pop-options
-
-let union_get_case_unknown
-  tn n fields
-= ()
-
-let union_set_field_unknown
-  tn n fields field
-= ()
-
-let union_get_case_uninitialized
-  tn n fields
-= ()
-
-let mk_fraction_union_get_case
-  #tn #_ #n #fields s p
-= match U.case_of_union (union_field_pcm fields) s with
-  | None -> (union0 tn n fields).mk_fraction_one p
-  | Some f ->
-    Classical.move_requires ((union_field_typedef fields f).mk_fraction_eq_one (s f)) p
-
-let fractionable_union_get_field
-  s field
-= ()
-
-let mk_fraction_union_get_field
-  s p field
-= ()
-
-let mk_fraction_union_set_field
-  tn n fields field v p
-= 
-  assert (fractionable (union0 tn n fields) (union_set_field tn n fields field v));
-  let prf
-    (f: union_field_t fields)
-  : Lemma
-    (let u = one (union_field_typedef fields f).pcm in
-      (union_field_typedef fields f).mk_fraction u p == u
-    )
-  = (union_field_typedef fields f).mk_fraction_one p
-  in
-  Classical.forall_intro prf;
-  assert (mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p `FX.feq` union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p))
-
-let full_union
-  #_ #_ #_ #fields s field
-= Classical.move_requires (U.exclusive_union_intro (union_field_pcm fields) s) (Some field);
-  Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
-
-let has_union_field_gen
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (r: ref0_v (union0 tn n fields))
-  (field: field_t fields)
-  (r': ref0_v (fields.fd_typedef field))
-: GTot prop
-= r'.base == r.base /\
-  r'.ref == R.ref_focus r.ref (U.union_field (union_field_pcm fields) (Some field))
-
-[@@__reduce__]
-let has_union_field0
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: Tot vprop
-= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
-    HR.pts_to r p w `star`
-    HR.pts_to r' p' w' `star`
-    pure (has_union_field_gen w field w')
-  ))))
-
-let has_union_field
-  r field r'
-= has_union_field0 r field r'
-
-#push-options "--split_queries"
-
-let has_union_field_dup
-  r field r'
-= rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = gen_elim () in
-  hr_share r;
-  hr_share r';
-  noop ();
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  noop ();
-  rewrite (has_union_field0 r field r') (has_union_field r field r')
-
-#push-options "--z3rlimit 16"
-
-let has_union_field_inj
-  r field r1 r2
-= rewrite (has_union_field r field r1) (has_union_field0 r field r1);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (has_union_field r field r2) (has_union_field0 r field r2);
-  let _ = gen_elim () in
-  hr_gather w r;
-  hr_share r;
-  hr_share r1;
-  rewrite (has_union_field0 r field r1) (has_union_field r field r1);
-  hr_share r2;
-  rewrite (has_union_field0 r field r2) (has_union_field r field r2);
-  let w' = vpattern_replace (HR.pts_to r1 _) in
-  vpattern_rewrite (HR.pts_to r2 _) w';
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-#pop-options
-
-let has_union_field_equiv_from
-  r1 r2 field r'
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  rewrite (has_union_field r1 field r') (has_union_field0 r1 field r');
-  let _ = gen_elim () in
-  hr_gather w r1;
-  hr_share r2;
-  rewrite (has_union_field0 r2 field r') (has_union_field r2 field r');
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-let has_union_field_equiv_to
-  r field r1' r2'
-= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
-  rewrite (has_union_field r field r1') (has_union_field0 r field r1');
-  let _ = gen_elim () in
-  hr_gather w r1';
-  hr_share r2';
-  rewrite (has_union_field0 r field r2') (has_union_field r field r2');
-  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
-
-#push-options "--z3rlimit 16"
-
-#restart-solver
-
-let ghost_union_field_focus
-  #_ #tn #_ #n #fields #v r field r'
-= rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w' = vpattern_replace (HR.pts_to r' _) in
-  rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  hr_gather w r;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
-  let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
-  assert (v' `FX.feq` v);
-  R.gfocus w.ref (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
-  rewrite (R.pts_to _ _) (R.pts_to w'.ref (union_get_field v field));
-  hr_share r';
-  rewrite (pts_to0 r' _) (pts_to r' _);
-  rewrite (has_union_field0 r field r') (has_union_field r field r')
-
-let ghost_union_field
-  #_ #tn #_ #n #fields #v r field
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
-  let w' = {
-    base = w.base;
-    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
-  }
-  in
-  let gr' = GHR.alloc w' in
-  let r1' = GHR.reveal_ref gr' in
-  GHR.reveal_pts_to gr' P.full_perm w';
-  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
-  HR.pts_to_not_null r1';
-  let r' = Ghost.hide r1' in
-  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
-  hr_share r;
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
-  ghost_union_field_focus r field r';
-  r'
-
-[@@noextract_to "krml"] // primitive
-let union_field'
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields {union_get_case v == Some field})
-: STT (ref (fields.fd_typedef field))
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
-  let w' = {
-    base = w.base;
-    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
-  }
-  in
-  let r' = HR.alloc w' in
-  hr_share r;
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
-  ghost_union_field_focus r field r';
-  return r'
-
-let union_field0
-  t' r field td'
-=
-  let r' = union_field' r field in
-  let res : ref td' = r' in
-  rewrite (pts_to r' _) (pts_to res _);
-  rewrite (has_union_field r field _) (has_union_field r field res);
-  return res
-
-#pop-options
-
-
-#push-options "--z3rlimit 32"
-
-#restart-solver
-
-let ununion_field
-  #_ #tn #_ #n #fields r field #v' r'
-= rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w' = vpattern_replace (HR.pts_to r' _) in
-  rewrite (pts_to r' v') (pts_to0 r' v');
-  let _= gen_elim () in
-  hr_gather w' r';
-  rewrite (r_pts_to _ _) (R.pts_to w'.ref (Ghost.reveal v'));
-  let _ = r_unfocus w'.ref w.ref (coerce_eq () (U.union_field (union_field_pcm fields) (Some field))) _ in
-  hr_share r;
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
-  rewrite (pts_to0 r (union_set_field tn n fields field (Ghost.reveal v'))) (pts_to r (union_set_field tn n fields field (Ghost.reveal v')))
-
-[@@noextract_to "krml"] // primitive
-let union_switch_field'
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-: ST (ref (fields.fd_typedef field))
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
-    (full (union0 tn n fields) v)
-    (fun _ -> True)
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
-  let v' : union_t0 tn n fields = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
-  R.ref_upd w.ref _ _ (R.base_fpu (union_pcm tn n fields) _ v');
-  rewrite (pts_to0 r v') (pts_to r v');
-  let r' = union_field' r field in
-  rewrite (pts_to r' _) (pts_to r' (uninitialized (fields.fd_typedef field)));
-  return r'
-
-#pop-options
-
-[@@noextract_to "krml"] // primitive
-let union_switch_field0'
-  (#tn: Type0)
-  (#tf: Type0)
-  (t': Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (td': typedef t')
-  (sq: squash (
-    t' ==  fields.fd_type field /\
-    td' == fields.fd_typedef field
-  ))
-: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
-    (pts_to r v)
-    (fun r' -> has_union_field r field (coerce_eq () r') `star` pts_to r' (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))))
-    (full (union0 tn n fields) v)
-    (fun _ -> True)
-= let r' = union_switch_field' #tn #tf #n #fields #v r field in
-  let res : ref td' = r' in
-  rewrite (pts_to r' _) (pts_to res (Ghost.hide (coerce_eq () (uninitialized (fields.fd_typedef field)))));
-  rewrite (has_union_field r field _) (has_union_field r field (coerce_eq () res));
-  return res
-
-let union_switch_field0
-  t' r field td'
-= union_switch_field0' t' r field td' ()
-
-#pop-options
-
-
-/// Base arrays (without decay: explicit array types as top-level arrays or struct/union fields of array type)
-
-module A = Steel.ST.C.Model.Array
-
-let base_array_t'
-  (t: Type0)
-  (n: Ghost.erased array_size_t)
-: Tot Type0
-= A.array_pcm_carrier t (Ghost.hide (Ghost.reveal n))
-
-let base_array_t t _ n = base_array_t' t n
-
-[@@noextract_to "krml"] // proof-only
-let base_array_fd
-  (#t: Type)
-  (td: typedef t)
-  (n: Ghost.erased array_size_t)
-: Tot (field_description_gen_t (base_array_index_t n))
-= {
-    fd_nonempty = (let _ : base_array_index_t n = 0sz in ());
-    fd_type = A.array_range t (Ghost.hide (Ghost.reveal n));
-    fd_typedef = (fun _ -> td);
-  }
-
-[@@noextract_to "krml"]
-let base_array1 (#t: Type0) (td: typedef t) (n: Ghost.erased array_size_t) : Tot (typedef (base_array_t' t n)) = struct1 (base_array_fd td n)
-
-let base_array0 tn td n = base_array1 td n
-
-let base_array_index a i = a i
-
-let base_array_eq #_ #_ #n a1 a2 =
-  assert (a1 `FX.feq` a2 <==> (forall (i: base_array_index_t n) . a1 i == a2 i));
-  a1 `FX.feq` a2
-
-let mk_base_array _ n v = A.array_pcm_carrier_of_seq n v
-
-let mk_base_array_index _ _ _ _ = ()
-
-let base_array_fractionable a td = ()
-
-let base_array_mk_fraction a td p i = ()
-
-let base_array_index_unknown tn n td i = ()
-
-let base_array_index_uninitialized tn n td i = ()
-
-let base_array_index_full td x = ()
-
-let base_array_index_t' (n: Ghost.erased array_size_t) : Tot eqtype =
-  A.array_domain (Ghost.hide (Ghost.reveal n))
-
-let base_array_index_t'_eq
-  (n: array_size_t)
-: Lemma
-  (base_array_index_t n == base_array_index_t' n)
-  [SMTPat (base_array_index_t n)]
-= // syntactic equality of refinement types
-  assert (base_array_index_t n == base_array_index_t' n) by (FStar.Tactics.trefl ())
-
-let array_index_as_field_marker
-  (n: Ghost.erased array_size_t)
-  (i: SZ.t)
-  (j: base_array_index_t' n)
-: Tot (base_array_index_t' n)
-= j
-
-#set-options "--print_implicits"
-
-let base_array1_eq
-  (#t: Type)
-  (n: Ghost.erased array_size_t)
-  (td: typedef t)
-: Lemma
-  (ref (base_array1 td n) == ref (struct1 #(base_array_index_t' n) (base_array_fd td n)))
-//  [SMTPat (ref (base_array1 td n))]
-= () // assert (ref (base_array1 td n) == ref (struct1 #(base_array_index_t' n) (base_array_fd td n))) by (FStar.Tactics.trefl ())
-
-[@@__reduce__]
-let has_base_array_cell_as_struct_field0
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (j: base_array_index_t' n)
-  (r': ref td)
-: Tot vprop
-= has_struct_field1 #(base_array_index_t' n) #(base_array_fd td n) r (array_index_as_field_marker n i j) r'
-
-let has_base_array_cell_as_struct_field
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (j: base_array_index_t' n)
-  (r': ref td)
-: Tot vprop
-= has_base_array_cell_as_struct_field0 r i j r'
-
-[@@__reduce__]
-let has_base_array_cell0
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (r': ref td)
-: Tot vprop
-= exists_ (fun j ->
-    has_base_array_cell_as_struct_field r i j r' `star`
-    pure (i == j)
-  )
-
-let has_base_array_cell1
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (r': ref td)
-: Tot vprop
-= has_base_array_cell0 r i r'
-
-let has_base_array_cell
-  r i r'
-= has_base_array_cell0 r i r'
-
-let has_base_array_cell_post
-  r i r'
-= rewrite (has_base_array_cell r i r') (has_base_array_cell0 r i r');
-  let _ = gen_elim () in
-  rewrite (has_base_array_cell0 r i r') (has_base_array_cell r i r')
-
-let has_base_array_cell_dup'
-  (#opened: _)
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (r': ref td)
-: STGhostT unit opened
-    (has_base_array_cell1 r i r')
-    (fun _ -> has_base_array_cell1 r i r' `star` has_base_array_cell1 r i r')
-= rewrite (has_base_array_cell1 r i r') (has_base_array_cell0 r i r');
-  let _ = gen_elim () in
-  has_struct_field_dup'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ _;
-  rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r');
-  noop ();
-  rewrite (has_base_array_cell0 r i r') (has_base_array_cell1 r i r')
-
-let has_base_array_cell_dup
-  r i r'
-= has_base_array_cell_dup' r i r'
-
-let has_base_array_cell_inj'
-  (#opened: _)
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2)
-    (fun _ -> has_base_array_cell1 r i r1 `star` has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
-= rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
-  let _ = gen_elim () in
-  let j = vpattern_replace (fun j -> has_base_array_cell_as_struct_field r i j _) in
-  rewrite (has_base_array_cell1 r i r2) (has_base_array_cell0 r i r2);
-  let _ = gen_elim () in
-  vpattern_rewrite (fun j' -> has_base_array_cell_as_struct_field r i j _ `star` has_base_array_cell_as_struct_field r i j' _) j;
-  has_struct_field_inj' #_ #(base_array_index_t' n) #(base_array_fd td n) (r) _ r1 r2;
-  rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2);
-  rewrite (has_base_array_cell0 r i r1) (has_base_array_cell1 r i r1)
-
-let has_base_array_cell_inj
-  r i r1 r2
-= has_base_array_cell_inj' r i r1 r2
-
-let has_base_array_cell_equiv_from'
-  (#opened: _)
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r1 r2: ref (base_array1 td n))
-  (i: SZ.t)
-  (r': ref td)
-: STGhostT unit opened
-    (has_base_array_cell1 r1 i r' `star` ref_equiv r1 r2)
-    (fun _ -> has_base_array_cell1 r2 i r' `star` ref_equiv r1 r2)
-= rewrite (has_base_array_cell1 r1 i r') (has_base_array_cell0 r1 i r');
-  let _ = gen_elim () in
-  has_struct_field_equiv_from'  #_ #(base_array_index_t' n) #(base_array_fd td n) (r1) _ r' (r2);
-  rewrite (has_base_array_cell0 r2 i r') (has_base_array_cell1 r2 i r')
-
-let has_base_array_cell_equiv_from
-  r1 r2 i r'
-= has_base_array_cell_equiv_from' r1 r2 i r'
-
-let has_base_array_cell_equiv_to'
-  (#opened: _)
-  (#t: Type)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (i: SZ.t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (has_base_array_cell1 r i r1 `star` ref_equiv r1 r2)
-    (fun _ -> has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
-= rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
-  let _ = gen_elim () in
-  has_struct_field_equiv_to' r _ r1 r2;
-  rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2)
-
-let has_base_array_cell_equiv_to
-  r i r1 r2
-= has_base_array_cell_equiv_to' r i r1 r2
-
-/// Array pointers (with decay)
-
-noeq
-type array_ref #t td = {
-  ar_base_size: Ghost.erased array_size_t;
-  ar_base: ref (base_array1 #t td ar_base_size);
-  ar_offset: SZ.t;
-  ar_prf: squash (SZ.v ar_offset <= SZ.v ar_base_size);
-}
-let array_ref_base_size ar = ar.ar_base_size
-let has_array_ref_base ar r = ar.ar_base == r
-let has_array_ref_base_inj ar r1 r2 = ()
-let array_ref_offset ar = ar.ar_offset
-let array_ref_base_offset_inj a1 r1 a2 r2 = ()
-
-let base_array_pcm_eq
-  (#t: Type)
-  (td: typedef t)
-  (n: Ghost.erased array_size_t)
-: Lemma
-  (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n)) == (base_array1 td n).pcm)
-  [SMTPat (base_array1 td n).pcm]
-= pcm0_ext (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n))) (base_array1 td n).pcm
-    (fun _ _ -> ())
-    (fun x1 x2 ->
-      assert (op (A.array_pcm td.pcm (Ghost.hide (Ghost.reveal n))) x1 x2 `FX.feq` op (base_array1 td n).pcm x1 x2)
-    )
-    (fun _ -> ())
-    ()
-
-[@@noextract_to "krml"] // proof-only
-let model_array_of_array
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (base: ref0_v (base_array1 td (dfst a).ar_base_size))
-: Tot (A.array base.base td.pcm)
-= let (| al, len |) = a in
-  {
-    base_len = Ghost.hide (Ghost.reveal al.ar_base_size);
-    base = base.ref;
-    offset = al.ar_offset;
-    len = len;
-    prf = ();
-  }
-
-[@@__reduce__]
-let array_pts_to0
-  (#t: Type)
-  (#td: typedef t)
-  (r: array td)
-  (v: Ghost.erased (Seq.seq t))
-: Tot vprop
-= exists_ (fun br -> exists_ (fun p ->
-    HR.pts_to (dfst r).ar_base p br `star`
-    A.pts_to (model_array_of_array r br) v
-  ))
-
-let array_pts_to r v =
-  array_pts_to0 r v
-
-let array_pts_to_length r v =
-  rewrite (array_pts_to r v) (array_pts_to0 r v);
-  let _ = gen_elim () in
-  let _ = A.pts_to_length _ _ in
-  rewrite (array_pts_to0 r v) (array_pts_to r v)
-
-#push-options "--z3rlimit 16"
-#restart-solver
-
-let ghost_array_of_base_focus
-  #_ #_ #_ #_ #td #v r a
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w' : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () w in
-  assert ((model_array_of_array a w').base == w.ref);
-  rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
-  assert (seq_of_base_array v `Seq.equal` A.seq_of_array_pcm_carrier v);
-  A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
-  A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array v);
-  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
-  rewrite (array_pts_to0 a (seq_of_base_array v)) (array_pts_to a (seq_of_base_array v))
-
-#pop-options
-
-let ghost_array_of_base
-  #_ #tn #_ #n #td #v r
-=
-  let al : array_ref td = {
-    ar_base_size = n;
-    ar_base = r;
-    ar_offset = 0sz;
-    ar_prf = ();
-  }
-  in
-  let a : (a: Ghost.erased (array td) { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
-  ghost_array_of_base_focus r a;
-  a
-
-[@@noextract_to "krml"] // primitive
-let array_of_base0
-  (#t: Type)
-  (#tn: Type0)
-  (#opened: _)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
-    (pts_to r v)
-    (fun a -> array_pts_to a (seq_of_base_array v))
-    (True)
-    (fun _ -> True)
-=
-  let al : array_ref td = {
-    ar_base_size = n;
-    ar_base = r;
-    ar_offset = 0sz;
-    ar_prf = ();
-  }
-  in
-  let a : (a: array td { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
-  ghost_array_of_base_focus r a;
-  return a
-
-let array_ref_of_base
-  #_ #tn #_ #n #td #v r
-=
-  let ar = array_of_base0 r in
-  let a : array_ref td = dfst ar in
-  return a
-
-#push-options "--z3rlimit 16 --split_queries"
-
-#restart-solver
-
-let base_array_index' (#t: Type0) (#n: array_size_t) (a: base_array_t' t n)
-(i: base_array_index_t n) : GTot t
-= a i
-
-let seq_of_base_array0
-  (#t: Type)
-  (#n: array_size_t)
-  (v: base_array_t' t n)
-: GTot (Seq.lseq t (SZ.v n))
-= Seq.init_ghost (SZ.v n) (fun i -> base_array_index' v (SZ.uint_to_t i))
-
-let has_array_of_base'
-  (#t: Type)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (a: array td)
-: GTot prop
-=   let (| al, len |) = a in
-    array_ref_base_size al == n /\
-    al.ar_base == r /\
-    array_ref_offset al == 0sz /\
-    Ghost.reveal len == n
-
-#pop-options
-
-#push-options "--z3rlimit 64"
-#restart-solver
-
-let unarray_of_base0
-  (#t: Type)
-  (#opened: _)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (Seq.seq t))
-  (r: ref (base_array1 td n))
-  (a: array td)
-: STGhost (Ghost.erased (base_array_t' t n)) opened
-    (array_pts_to a v)
-    (fun v' -> pts_to r v')
-    (
-      has_array_of_base' r a
-    )
-    (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array0 v')
-= rewrite (array_pts_to a v) (array_pts_to0 a v);
-  let _ = gen_elim () in
-  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  let ba = vpattern_replace (HR.pts_to _ _) in
-  let ba' : ref0_v (base_array1 td n) = coerce_eq () ba in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba');
-  let m = model_array_of_array a ba in
-  rewrite (A.pts_to _ _) (A.pts_to m v);
-  let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = A.pts_to_elim_to_base m v in
-  let y' : Ghost.erased (base_array_t' t n) = Ghost.hide (Ghost.reveal y) in
-  rewrite (r_pts_to _ _) (r_pts_to ba'.ref (Ghost.reveal y'));
-  rewrite (pts_to0 r y') (pts_to r y');
-  y'
-
-#pop-options
-
-let unarray_of_base
-  #t #tn #_ #n #td #v r a
-= unarray_of_base0 r a
-
-(*
-let has_array_of_ref
-  r a
-= TD.type_of_token (dfst a).ar_base_size_token == unit /\
-  model_array_of_array a == A.g_array_of_ref (coerce _ (Some?.v r).ref)
-
-let has_array_of_ref_inj
-  r a1 a2
-= TD.type_of_token_inj (dfst a1).ar_base_size_token (dfst a2).ar_base_size_token;
-  TD.type_of_token_inj (Some?.v (dfst a1).ar_base).dest (Some?.v (dfst a2).ar_base).dest
-
-let ghost_array_of_ref_focus
-  #t #_ #td #v r a
-= let mr : R.ref td.pcm = (Some?.v r).ref in
-  rewrite_slprop (pts_to _ _) (R.pts_to mr v) (fun _ -> ());
-  let ma = A.ghost_array_of_ref mr in
-  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ())
-
-let ghost_array_of_ref
-  #t #_ #td #v r
-= let mr : R.ref td.pcm = (Some?.v r).ref in
-  let ma = A.g_array_of_ref mr in
-  let tok_unit = TD.get_token unit in
-  let tok_array = TD.get_token (A.array_pcm_carrier t 1sz) in
-  let ar = {
-    ar_base_size_token = tok_unit;
-    ar_base_size = 1sz;
-    ar_base = Some ({
-      dest = tok_array;
-      typedef = base_array0 unit td 1sz;
-      ref = coerce _ ma.base;
-    });
-    ar_offset = 0sz;
-  }
-  in
-  let res: (a: Ghost.erased (array td) { has_array_of_ref r a }) = Ghost.hide (| ar, Ghost.hide 1sz |) in
-  ghost_array_of_ref_focus r res;
-  res
-
-let array_ref_of_ref
-  #t #_ #td #v r
-= let mr : R.ref td.pcm = (Some?.v r).ref in
-  rewrite_slprop (pts_to _ _) (R.pts_to mr v) (fun _ -> ());
-  let ma = A.array_of_ref mr in
-  let tok_unit = TD.get_token unit in
-  let tok_array = TD.get_token (A.array_pcm_carrier t 1sz) in
-  let res = {
-    ar_base_size_token = tok_unit;
-    ar_base_size = 1sz;
-    ar_base = Some ({
-      dest = tok_array;
-      typedef = base_array0 unit td 1sz;
-      ref = coerce _ ma.base;
-    });
-    ar_offset = 0sz;
-  }
-  in
-  rewrite_slprop (A.pts_to _ _) (array_pts_to _ _) (fun _ -> ());
-  return res
-
-let unarray_of_ref = magic ()
-*)
-
-[@@noextract_to "krml"]
-let array_index_as_base_array_index_marker
-  (index: SZ.t)
-  (base_index: SZ.t)
-: Tot SZ.t
-= base_index
-
-[@@__reduce__]
-let has_array_cell0
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-: Tot vprop
-= exists_ (fun (j: SZ.t) ->
-    has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r `star`
-    pure (
-      SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i /\
-      SZ.v i < SZ.v (dsnd a)
-    )
-  )
-
-let has_array_cell1
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-: Tot vprop
-= has_array_cell0 a i r
-
-let has_array_cell
-  a i r
-= has_array_cell0 a i r
-
-let has_array_cell_post
-  a i r
-= rewrite (has_array_cell a i r) (has_array_cell0 a i r);
-  let _ = gen_elim () in
-  rewrite (has_array_cell0 a i r) (has_array_cell a i r)
-
-let has_array_cell_has_base_array_cell
-  a i r br
-= rewrite (has_array_cell a i r) (has_array_cell0 a i r);
-  let _ = gen_elim () in
-  let j = vpattern_replace_erased (fun j -> has_base_array_cell1 _ j r) in
-  rewrite (has_base_array_cell1 _ _ _) (has_base_array_cell br j r);
-  j
-
-let has_base_array_cell_has_array_cell
-  a i r br
-= let j : Ghost.erased SZ.t = Ghost.hide (i `SZ.sub` (dfst a).ar_offset) in
-  rewrite (has_base_array_cell br i r) (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker j i) r);
-  rewrite (has_array_cell0 a j r) (has_array_cell a j r);
-  j
-
-let has_array_cell_inj
-  #_ #_ #td a i r1 r2
-= has_array_cell_post a i r1;
-  let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
-  let j1 = has_array_cell_has_base_array_cell a i r1 br in
-  let j2 = has_array_cell_has_base_array_cell a i r2 br in
-  vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
-  has_base_array_cell_inj br j1 r1 r2;
-  let _ = has_base_array_cell_has_array_cell a j1 r1 br in
-  vpattern_rewrite (fun i -> has_array_cell _ i r1) i;
-  let _ = has_base_array_cell_has_array_cell a j1 r2 br in
-  vpattern_rewrite (fun i -> has_array_cell _ i r2) i
-  
-
-#restart-solver
-let struct_field_eq_cell
-  (#t: Type)
-  (td: typedef t)
-  (n: array_size_t)
-  (k: base_array_index_t n)
-: Lemma
-  (Steel.ST.C.Model.Struct.struct_field (struct_field_pcm (base_array_fd td n)) k == A.cell td.pcm n k)
-= // assert_norm (A.array_domain n == base_array_index_t n);
-  Steel.ST.C.Model.Struct.struct_field_ext #(A.array_domain n) #(A.array_range t n) (struct_field_pcm (base_array_fd td n)) (A.array_elements_pcm td.pcm n) (fun _ -> ()) k
-
-(*
-#push-options "--split_queries --z3rlimit 16"
-
-#restart-solver
-let has_array_cell_array_of_ref
-  #_ #td r a
-= assert_norm (SZ.v 0sz == 0);
-  assert_norm (SZ.v 1sz == 1);
-  A.ref_of_array_of_ref (Some?.v r).ref;
-  A.ref_of_array_of_ref_base (Some?.v r).ref;
-  assert (Ghost.reveal (dsnd a) == 1sz);
-  assert ((dfst a).ar_offset == 0sz);
-  struct_field_eq_cell td 1sz 0sz;
-  assert (has_base_array_cell0 (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` 0sz) r)
-
-#pop-options
-*)
-
-let has_struct_field1_intro
-  (#opened: _)
-  (#field_t: eqtype)
-  (#fields: field_description_gen_t field_t)
-  (r: ref (struct1 fields))
-  (field: field_t)
-  (r': ref (fields.fd_typedef field))
-  (p: P.perm)
-  (w: ref0_v (struct1 fields))
-  (p': P.perm)
-  (w': ref0_v (fields.fd_typedef field))
-  ()
-: STGhost unit opened
-    (HR.pts_to r p w `star` HR.pts_to r' p' w')
-    (fun _ ->
-      has_struct_field1 r field r'
-    )
-    (
-      has_struct_field_gen fields w field w'
-    )
-    (fun _ -> True)
-= noop ();
-  rewrite
-    (has_struct_field0 r field r')
-    (has_struct_field1 r field r')
-
-let has_array_cell_drop
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (#p': P.perm)
-  (#b': ref0_v td)
-  (i: SZ.t)
-  (r: ref td)
-: STGhostT unit opened
-    (has_array_cell1 a i r `star`
-      HR.pts_to r p' b'
-    )
-    (fun _ -> has_array_cell1 a i r)
-= rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
-  let _ = gen_elim () in
-  let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
-  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
-  let _ = gen_elim () in
-  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
-  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
-  let _ = gen_elim () in
-  HR.gather p' r;
-  has_struct_field1_intro
-    #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
-  rewrite
-    (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r)
-    (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
-  rewrite
-    (has_base_array_cell0 (dfst a).ar_base j r)
-    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
-  rewrite
-    (has_array_cell0 a i r)
-    (has_array_cell a i r)
-
-let has_array_cell_elim
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#p: P.perm)
-  (a: array td)
-  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
-  (i: SZ.t)
-  (r: ref td)
-: STGhost (Ghost.erased (ref0_v td)) opened
-    (has_array_cell1 a i r `star`
-      HR.pts_to (dfst a).ar_base p b
-    )
-    (fun b' -> has_array_cell1 a i r `star`
-      exists_ (fun p -> exists_ (fun p' ->
-        HR.pts_to (dfst a).ar_base p b `star`
-        HR.pts_to r p' b'
-    )))
-    True
-    (fun b' ->
-      let ar = model_array_of_array a b in
-      SZ.v i < SZ.v ar.len /\
-      b'.base == b.base /\
-      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
-    )
-= 
-  rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
-  let _ = gen_elim () in
-  let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
-  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
-  let _ = gen_elim () in
-  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
-  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
-  let _ = gen_elim () in
-  hr_gather b (dfst a).ar_base;
-  HR.share r;
-  HR.share (dfst a).ar_base;
-  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
-  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
-  rewrite
-    (has_base_array_cell0 (dfst a).ar_base j r)
-    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
-  rewrite
-    (has_array_cell0 a i r)
-    (has_array_cell a i r);
-  A.ref_of_array_eq (model_array_of_array a b) i;
-  struct_field_eq_cell td (dfst a).ar_base_size j';
-  let b' = vpattern_replace_erased (HR.pts_to r _) in
-  noop ();
-  b'
-
-let ghost_array_cell_focus
-  #_ #_ #td #s a i r
-= rewrite (array_pts_to a s) (array_pts_to0 a s);
-  let _ = gen_elim () in
-  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
-  let r' = has_array_cell_elim a i r in
-  let _ = gen_elim () in
-  let _ = A.g_focus_cell _ _ i () in
-  rewrite (R.pts_to _ _) (R.pts_to r'.ref (Seq.index s (SZ.v i)));
-  rewrite (pts_to0 r (Seq.index s (SZ.v i))) (pts_to r (Seq.index s (SZ.v i)));
-  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
-  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td)))
-
-let has_array_cell_intro
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#p: P.perm)
-  (a: array td)
-  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
-  (#p': P.perm)
-  (#b': ref0_v td)
-  (i: SZ.t)
-  (r: ref td)
-: STGhost unit opened
-    (HR.pts_to (dfst a).ar_base p b `star`
-      HR.pts_to r p' b'
-    )
-    (fun _ -> has_array_cell1 a i r)
-    (
-      let ar = model_array_of_array a b in
-      SZ.v i < SZ.v ar.len /\
-      b'.base == b.base /\
-      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
-    )
-    (fun _ -> True)
-= 
-  A.ref_of_array_eq (model_array_of_array a b) i;
-  let j : base_array_index_t' (dfst a).ar_base_size = (dfst a).ar_offset `SZ.add` i in
-  struct_field_eq_cell td (dfst a).ar_base_size j;
-  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r _ _ _ _ ();
-  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j r);
-  rewrite
-    (has_base_array_cell0 (dfst a).ar_base j r)
-    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
-  rewrite
-    (has_array_cell0 a i r)
-    (has_array_cell a i r)
-
-let ghost_array_cell
-  #_ #_ #td #s a i
-= array_pts_to_length _ _;
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
-  let _ = gen_elim () in
-  HR.share _;
-  rewrite (array_pts_to0 a s) (array_pts_to a s);
-  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
-  let ar = model_array_of_array a b in
-  let b' = {
-    base = b.base;
-    ref = R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i);
-  }
-  in
-  let ghr = GHR.alloc b' in
-  GHR.reveal_pts_to ghr P.full_perm b';
-  let hr = GHR.reveal_ref ghr in
-  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to hr P.full_perm b');
-  HR.pts_to_not_null hr;
-  let r : (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
-  vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
-  has_array_cell_intro a i r;
-  let _ = ghost_array_cell_focus a i r in
-  noop ();
-  r
-
-[@@ noextract_to "krml"]
-let array_cell0
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array td)
-  (i: SZ.t)
-: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
-    (array_pts_to a s)
-    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-    (
-      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
-    )
-    (fun _ -> True)
-= array_pts_to_length _ _;
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
-  let _ = gen_elim () in
-  HR.share _;
-  rewrite (array_pts_to0 a s) (array_pts_to a s);
-  let b = HR.read (dfst a).ar_base in
-  vpattern_rewrite (HR.pts_to (dfst a).ar_base _) b;
-  let ar = model_array_of_array a b in
-  A.ref_of_array_eq ar i;
-  let b' = {
-    base = b.base;
-    ref = R.ref_focus ar.base (A.cell td.pcm ar.base_len (ar.offset `SZ.add`  i));
-  }
-  in
-  let hr = HR.alloc b' in
-  HR.pts_to_not_null hr;
-  let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) = hr in
-  vpattern_rewrite (fun hr -> HR.pts_to hr P.full_perm b') r;
-  has_array_cell_intro a i r;
-  let _ = ghost_array_cell_focus a i r in
-  noop ();
-  return r
-
-let array_ref_cell
-  #_ #td #s a len i
-= let r0 : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd ((| a, len |) <: array td)) }) = array_cell0 _ _ in
-  let r : (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len }) = r0 in
-  vpattern_rewrite (fun r -> pts_to r _) r;
-  vpattern_rewrite (has_array_cell _ _) r;
-  noop ();
-  return r
-
-let ar_unfocus_cell
-  (#opened: _)
-  (#base_t #base_t': Type)
-  (#t: Type)
-  (#p: pcm t)
-  (r: A.array base_t p)
-  (s: Seq.seq t)
-  (i: SZ.t)
-  (r': R.ref base_t' p)
-  (v: t)
-  (sq: squash (SZ.v i < SZ.v r.len /\ SZ.v i < Seq.length s))
-: STGhost unit opened
-    (A.pts_to r s `star` R.pts_to r' v)
-    (fun _ -> A.pts_to r (Seq.upd s (SZ.v i) v))
-    (
-      base_t' == base_t /\
-      r' == R.ref_focus (A.ref_of_array r) (A.cell p r.len i) /\
-      Seq.index s (SZ.v i) == one p
-    )
-    (fun _ -> True)
-= let r1' : R.ref base_t p = coerce_eq () r' in
-  rewrite (R.pts_to r' v) (R.pts_to r1' v);
-  A.unfocus_cell r s i r1' v ()
-
-let unarray_cell
-  #_ #_ #td #s #v a i r
-= array_pts_to_length _ _;
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
-  let _ = gen_elim () in
-  let w = has_array_cell_elim a i r in
-  let _ = gen_elim () in
-  rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  hr_gather (Ghost.reveal w) r;
-  ar_unfocus_cell _ _ i _ _ ();
-  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
-  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
-  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v));
-  has_array_cell_drop _ _ _
-
-#push-options "--split_queries --z3rlimit 16"
-
-let t_array_ref_shift
-  (#t: Type)
-  (#td: typedef t)
-  (a: array_ref td)
-  (i: SZ.t)
-: Pure (array_ref td)
-    (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
-    (ensures (fun y -> 
-      array_ref_base_size y == array_ref_base_size a /\
-      (forall ty r . has_array_ref_base a #ty r ==> has_array_ref_base y #ty (coerce_eq () r)) /\
-      array_ref_offset y == array_ref_offset a `SZ.add` i
-    ))
-= {
-    a with
-    ar_offset = a.ar_offset `SZ.add` i
-  }
-
-let array_ref_shift
-  a i
-= t_array_ref_shift a i
-
-let ghost_array_split
-  #_ #_ #td #s a i
-= array_pts_to_length _ _;
-  let sq : squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)) = () in
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
-  let _ = gen_elim () in
-  let br : Ghost.erased (ref0_v (base_array1 td (dfst a).ar_base_size)) = vpattern_replace_erased (HR.pts_to _ _) in
-  A.g_split _ _ i ();
-  HR.share _;
-  let p = vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
-  let br_l : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_l a i)).ar_base_size)) = coerce_eq () br in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_l a i)).ar_base p br_l);
-  rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
-  noop ();
-  rewrite (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)));
-  let br_r : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_r a i)).ar_base_size)) = coerce_eq () br in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_r a i)).ar_base p br_r);
-  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
-  noop ();
-  rewrite (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)));
-  sq
-
-let t_array_split_r
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-: Pure (array td)
-   (requires (SZ.v i <= SZ.v (dsnd a)))
-   (ensures (fun _ -> True))
-= let (| al, len |) = a in
-  (| t_array_ref_shift al i, Ghost.hide (len `SZ.sub` i) |)
-
-let array_ref_split
-  #_ #td #s al len i
-= let _ = ghost_array_split (| al, len |) i in
-  let ar: (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len}) = t_array_ref_shift al i in
-  return ar
-
-let hr_gather_by_perm
-  (#opened: _)
-  (#t1: Type)
-  (#r1: HR.ref t1)
-  (#v1: t1)
-  (#t2: Type)
-  (#r2: HR.ref t2)
-  (#v2: t2)
-  (p1: P.perm)
-  (p2: P.perm)
-: STGhost unit opened
-    (HR.pts_to r1 p1 v1 `star` HR.pts_to r2 p2 v2)
-    (fun _ -> HR.pts_to r1 (p1 `P.sum_perm` p2) v1)
-    (t1 == t2 /\
-      r1 == r2)
-    (fun _ ->
-      t1 == t2 /\
-      r1 == r2 /\
-      v1 == v2)
-= rewrite (HR.pts_to r2 p2 v2) (HR.pts_to r1 p2 (coerce_eq () v2));
-  HR.gather p2 r1
-
-let ar_join
-  (#opened: _)
-  (#base_t #base_tl #base_tr: Type)
-  (#t: Type)
-  (#p: pcm t)
-  (a: A.array base_t p)
-  (i: SZ.t)
-  (al: A.array base_tl p)
-  (ar: A.array base_tr p)
-  (sl0 sr0: Seq.seq t)
-: STGhost unit opened
-    (A.pts_to al sl0 `star` A.pts_to ar sr0)
-    (fun _ -> A.pts_to a (sl0 `Seq.append` sr0))
-    (
-      SZ.v i <= SZ.v a.len /\
-      base_t == base_tl /\
-      base_t == base_tr /\
-      al == A.split_l a i /\
-      ar == A.split_r a i
-    )
-    (fun _ -> True)
-= let al' : A.array base_t p = coerce_eq () al in
-  let ar' : A.array base_t p = coerce_eq () ar in
-  rewrite (A.pts_to al sl0) (A.pts_to al' sl0);
-  rewrite (A.pts_to ar sr0) (A.pts_to ar' sr0);
-  A.join a i al' ar' _ _
-
-let array_join
-  #_ #_ #td #sl #sr a al ar i
-= rewrite (array_pts_to al sl) (array_pts_to0 al sl);
-  let _ = gen_elim () in
-  let br_l : ref0_v (base_array1 td (dfst al).ar_base_size) = vpattern_replace (HR.pts_to _ _) in
-  let pl = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  let br : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () br_l in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base pl br);
-  rewrite (array_pts_to ar sr) (array_pts_to0 ar sr);
-  let _ = gen_elim () in
-  let pr = vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
-  hr_gather_by_perm pl pr;
-  ar_join (model_array_of_array a br) i _ _ sl sr;
-  rewrite (array_pts_to0 a (sl `Seq.append` sr)) (array_pts_to a (sl `Seq.append` sr))
-
-let ar_share
-  (#opened: _)
-  (#base_t: Type)
-  (#t: Type)
-  (#p: pcm t)
-  (r: A.array base_t p)
-  (s s1 s2: Seq.seq t)
-  (prf: (
-    (i: nat) ->
-    Lemma
-    (requires (i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2))
-    (ensures (
-      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
-      composable p (Seq.index s1 i) (Seq.index s2 i) /\
-      op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
-    ))
-  ))
-: STGhost unit opened
-    (A.pts_to r s)
-    (fun _ -> A.pts_to r s1 `star` A.pts_to r s2)
-    (
-      Seq.length s1 == Seq.length s /\
-      Seq.length s2 == Seq.length s
-    )
-    (fun _ -> True)
-= Classical.forall_intro (Classical.move_requires prf);
-  A.share r s s1 s2
-
-let mk_fraction_seq_split_gen
-  #_ #_ #td r v p p1 p2
-= rewrite (array_pts_to r (mk_fraction_seq td v p)) (array_pts_to0 r (mk_fraction_seq td v p));
-  let _ = gen_elim () in
-  let br = vpattern_replace (HR.pts_to _ _) in
-  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p));
-  ar_share _ _ (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
-    td.mk_fraction_split (Seq.index v i) p1 p2;
-    td.mk_fraction_join (Seq.index v i) p1 p2
-  );
-  HR.share _;
-  rewrite (array_pts_to0 r (mk_fraction_seq td v p1)) (array_pts_to r (mk_fraction_seq td v p1));
-  rewrite (array_pts_to0 r (mk_fraction_seq td v p2)) (array_pts_to r (mk_fraction_seq td v p2))
-
-let ar_gather
-  (#opened: _)
-  (#base_t: Type)
-  (#t: Type)
-  (#p: pcm t)
-  (r: A.array base_t p)
-  (s s1 s2: Seq.seq t)
-  (prf: (
-    (i: nat) ->
-    Lemma
-    (requires (
-      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
-      composable p (Seq.index s1 i) (Seq.index s2 i)
-    ))
-    (ensures (
-      i < Seq.length s /\ i < Seq.length s1 /\ i < Seq.length s2 /\
-      composable p (Seq.index s1 i) (Seq.index s2 i) /\
-      op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
-    ))
-  ))
-: STGhost unit opened
-    (A.pts_to r s1 `star` A.pts_to r s2)
-    (fun _ -> A.pts_to r s)
-    (
-      Seq.length s1 == Seq.length s /\
-      Seq.length s2 == Seq.length s
-    )
-    (fun _ -> True)
-= Classical.forall_intro (Classical.move_requires prf);
-  A.gather r s s1 s2
-
-let mk_fraction_seq_join
-  #_ #_ #td r v p1 p2
-= rewrite (array_pts_to r (mk_fraction_seq td v p1)) (array_pts_to0 r (mk_fraction_seq td v p1));
-  let _ = gen_elim () in
-  let br = vpattern_replace (HR.pts_to _ _) in
-  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
-  rewrite (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2));
-  let _ = gen_elim () in
-  hr_gather br (dfst r).ar_base;
-  rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
-  ar_gather _ (mk_fraction_seq td v (p1 `P.sum_perm` p2)) (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
-    td.mk_fraction_join (Seq.index v i) p1 p2
-  );
-  rewrite (array_pts_to0 r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
+include Steel.ST.C.Types.Scalar
+include Steel.ST.C.Types.Struct
+include Steel.ST.C.Types.Union
+include Steel.ST.C.Types.Array
diff --git a/ulib/experimental/Steel.ST.C.Types.fsti b/ulib/experimental/Steel.ST.C.Types.fsti
deleted file mode 100644
index f5c81c601cc..00000000000
--- a/ulib/experimental/Steel.ST.C.Types.fsti
+++ /dev/null
@@ -1,1855 +0,0 @@
-module Steel.ST.C.Types
-open Steel.C.Typenat
-open Steel.C.Typestring
-open Steel.ST.Util
-
-module P = Steel.FractionalPermission
-
-/// Helper to compose two permissions into one
-val prod_perm (p1 p2: P.perm) : Pure P.perm
-  (requires True)
-  (ensures (fun p ->
-    ((p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm) ==>
-    p `P.lesser_equal_perm` P.full_perm) /\
-    p.v == (let open FStar.Real in p1.v *. p2.v)
-  ))
-
-[@@noextract_to "krml"] // proof-only
-val typedef (t: Type0) : Type0
-
-inline_for_extraction [@@noextract_to "krml"]
-let typeof (#t: Type0) (td: typedef t) : Tot Type0 = t
-
-val fractionable (#t: Type0) (td: typedef t) (x: t) : GTot prop
-
-val mk_fraction (#t: Type0) (td: typedef t) (x: t) (p: P.perm) : Ghost t
-  (requires (fractionable td x))
-  (ensures (fun y -> p `P.lesser_equal_perm` P.full_perm ==> fractionable td y))
-
-val mk_fraction_full (#t: Type0) (td: typedef t) (x: t) : Lemma
-  (requires (fractionable td x))
-  (ensures (mk_fraction td x P.full_perm == x))
-  [SMTPat (mk_fraction td x P.full_perm)]
-
-val mk_fraction_compose (#t: Type0) (td: typedef t) (x: t) (p1 p2: P.perm) : Lemma
-  (requires (fractionable td x /\ p1 `P.lesser_equal_perm` P.full_perm /\ p2 `P.lesser_equal_perm` P.full_perm))
-  (ensures (mk_fraction td (mk_fraction td x p1) p2 == mk_fraction td x (p1 `prod_perm` p2)))
-
-val full (#t: Type0) (td: typedef t) (v: t) : GTot prop
-
-val uninitialized (#t: Type0) (td: typedef t) : Ghost t
-  (requires True)
-  (ensures (fun y -> full td y /\ fractionable td y))
-
-val unknown (#t: Type0) (td: typedef t) : Ghost t
-  (requires True)
-  (ensures (fun y -> fractionable td y))
-
-val full_not_unknown
-  (#t: Type)
-  (td: typedef t)
-  (v: t)
-: Lemma
-  (requires (full td v))
-  (ensures (~ (v == unknown td)))
-  [SMTPat (full td v)]
-
-val mk_fraction_unknown (#t: Type0) (td: typedef t) (p: P.perm) : Lemma
-  (ensures (mk_fraction td (unknown td) p == unknown td))
-
-val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemma
-  (requires (fractionable td v /\ mk_fraction td v p == unknown td))
-  (ensures (v == unknown td))
-
-
-(*
-// To be extracted as: void*
-
-// FIXME: Currently, Karamel does not directly support
-// void*. examples/steel/arraystructs currently has a stopgap in
-// lib/steel_c.h, whose contents should be moved to krmllib.h, unless
-// direct support for void* is added to Karamel.
-
-[@@noextract_to "krml"] // primitive
-val void_ptr : Type0
- 
-// To be extracted as: NULL
-[@@noextract_to "krml"] // primitive
-val void_null: void_ptr
-
-[@@noextract_to "krml"] // proof-only
-val type_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot Type0
-val typedef_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot (typedef (type_of_ptr p))
-
-// To be extracted as: *t
-[@@noextract_to "krml"] // primitive
-let ptr (#t: Type) (td: typedef t) : Tot Type0 = (p: void_ptr { (~ (p == void_null)) ==> (type_of_ptr p == t /\ typedef_of_ptr p == td) })
-[@@noextract_to "krml"] // primitive
-let null (#t: Type) (td: typedef t) : Tot (ptr td) = void_null
-*)
-
-val ptr (#t: Type) (td: typedef t) : Tot Type0
-val null (#t: Type) (td: typedef t) : Tot (ptr td)
-
-inline_for_extraction [@@noextract_to "krml"]
-let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
-
-val pts_to (#t: Type) (#td: typedef t) (r: ref td) ([@@@smt_fallback] v: Ghost.erased t) : vprop
-
-let pts_to_or_null
-  (#t: Type) (#td: typedef t) (p: ptr td) (v: Ghost.erased t) : vprop
-= if FStar.StrongExcludedMiddle.strong_excluded_middle (p == null _)
-  then emp
-  else pts_to p v
-
-[@@noextract_to "krml"] // primitive
-val is_null
-  (#t: Type)
-  (#opened: _)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (p: ptr td)
-: STAtomicBase bool false opened Unobservable
-    (pts_to_or_null p v)
-    (fun _ -> pts_to_or_null p v)
-    (True)
-    (fun res -> res == true <==> p == null _)
-
-let assert_null
-  (#t: Type)
-  (#opened: _)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (p: ptr td)
-: STGhost unit opened
-    (pts_to_or_null p v)
-    (fun _ -> emp)
-    (p == null _)
-    (fun _ -> True)
-= rewrite (pts_to_or_null p v) emp
-
-let assert_not_null
-  (#t: Type)
-  (#opened: _)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (p: ptr td)
-: STGhost (squash (~ (p == null _))) opened
-    (pts_to_or_null p v)
-    (fun _ -> pts_to p v)
-    (~ (p == null _))
-    (fun _ -> True)
-= rewrite (pts_to_or_null p v) (pts_to p v)
-
-val ref_equiv
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: Tot vprop
-
-val pts_to_equiv
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-  (v: Ghost.erased t)
-: STGhostT unit opened
-    (ref_equiv r1 r2 `star` pts_to r1 v)
-    (fun _ -> ref_equiv r1 r2 `star` pts_to r2 v)
-
-val freeable
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-: Tot vprop
-
-val freeable_dup
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-: STGhostT unit opened
-    (freeable r)
-    (fun _ -> freeable r `star` freeable r)
-
-val freeable_equiv
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (ref_equiv r1 r2 `star` freeable r1)
-    (fun _ -> ref_equiv r1 r2 `star` freeable r2)
-
-let freeable_or_null
-  (#t: Type)
-  (#td: typedef t)
-  (r: ptr td)
-: Tot vprop
-= if FStar.StrongExcludedMiddle.strong_excluded_middle (r == null _)
-  then emp
-  else freeable r
-
-(*
-let freeable_or_null_dup
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: ptr td)
-: SteelGhostT vprop opened
-    (freeable_or_null r)
-    (fun _ -> freeable_or_null r `star` freeable_or_null r)
-= if FStar.StrongExcludedMiddle.strong_excluded_middle (r == null _)
-  then ()
-  else freeable r
-*)
-
-[@@noextract_to "krml"] // primitive
-val alloc
-  (#t: Type)
-  (td: typedef t)
-: STT (ptr td)
-    emp
-    (fun p -> pts_to_or_null p (uninitialized td) `star` freeable_or_null p)
-
-[@@noextract_to "krml"] // primitive
-val free
-  (#t: Type)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (r: ref td)
-: ST unit
-    (pts_to r v `star` freeable r)
-    (fun _ -> emp)
-    (
-      full td v
-    )
-    (fun _ -> True)
-
-val mk_fraction_split_gen
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p p1 p2: P.perm) : STGhost unit opened
-  (pts_to r (mk_fraction td v p))
-  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
-  (fun _ -> True)
-
-let mk_fraction_split
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: Ghost.erased t { fractionable td v }) (p1 p2: P.perm) : STGhost unit opened
-  (pts_to r v)
-  (fun _ -> pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (P.full_perm == p1 `P.sum_perm` p2)
-  (fun _ -> True)
-= mk_fraction_full td v;
-  rewrite (pts_to _ _) (pts_to _ _);
-  mk_fraction_split_gen r v P.full_perm p1 p2
-
-val mk_fraction_join
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: ref td) (v: t { fractionable td v }) (p1 p2: P.perm)
-: STGhostT unit opened
-  (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
-  (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
-
-// To be extracted as: t
-[@@noextract_to "krml"] // primitive
-val scalar_t (t: Type0) : Type0
-[@@noextract_to "krml"] // proof-only
-val scalar (t: Type) : typedef (scalar_t t)
-val mk_scalar (#t: Type) (v: t) : Ghost (scalar_t t)
-  (requires True)
-  (ensures (fun y ->
-    fractionable (scalar t) y /\
-    full (scalar t) y
-  ))
-
-val mk_scalar_fractionable
-  (#t: Type)
-  (v: t)
-  (p: P.perm)
-: Lemma
-  (requires (fractionable (scalar t) (mk_fraction (scalar t) (mk_scalar v) p)))
-  (ensures (p `P.lesser_equal_perm` P.full_perm))
-
-val mk_scalar_inj
-  (#t: Type)
-  (v1 v2: t)
-  (p1 p2: P.perm)
-: Lemma
-  (requires (mk_fraction (scalar t) (mk_scalar v1) p1 == mk_fraction (scalar t) (mk_scalar v2) p2))
-  (ensures (v1 == v2 /\ p1 == p2))
-  [SMTPat [mk_fraction (scalar t) (mk_scalar v1) p1; mk_fraction (scalar t) (mk_scalar v2) p2]]
-
-val scalar_unique
-  (#opened: _)
-  (#t: Type)
-  (v1 v2: t)
-  (p1 p2: P.perm)
-  (r: ref (scalar t))
-: STGhost unit opened
-    (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
-    (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
-    (True)
-    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
-
-[@@noextract_to "krml"] // primitive
-val read0 (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : ST t
-  (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p))
-  (True)
-  (fun v' -> v' == Ghost.reveal v)
-
-let mk_fraction_full_scalar (#t: Type) (v: t) : Lemma
-  (mk_scalar v == mk_fraction (scalar t) (mk_scalar v) P.full_perm)
-  [SMTPat (mk_scalar v)]
-= ()
-
-inline_for_extraction [@@noextract_to "krml"]
-let read (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) : ST t
-  (pts_to r v)
-  (fun _ -> pts_to r v)
-  (exists v0 p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p)
-  (fun v1 -> forall v0 p . (* {:pattern (mk_fraction (scalar t) (mk_scalar v0) p)} *) Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p ==> v0 == v1)
-= let v0 = FStar.IndefiniteDescription.indefinite_description_tot _ (fun v0 -> exists p . Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0) p) in
-  let p = FStar.IndefiniteDescription.indefinite_description_tot _ (fun p -> Ghost.reveal v == mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p) in
-  let prf v0' p' : Lemma
-    (requires (Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0') p'))
-    (ensures (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
-  = mk_scalar_inj (Ghost.reveal v0) v0' p p'
-  in
-  let prf' v0' p' : Lemma
-    (Ghost.reveal v == mk_fraction (scalar t) (mk_scalar v0') p' ==> (v0' == Ghost.reveal v0 /\ p' == Ghost.reveal p))
-  = Classical.move_requires (prf v0') p'
-  in
-  Classical.forall_intro_2 prf';
-  rewrite (pts_to _ _) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v0)) p));
-  let v1 = read0 r in
-  rewrite (pts_to _ _) (pts_to r v);
-  return v1
-
-[@@noextract_to "krml"] // primitive
-val write (#t: Type) (#v: Ghost.erased (scalar_t t)) (r: ref (scalar t)) (v': t) : ST unit
-  (pts_to r v)
-  (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v') P.full_perm))
-  (full (scalar t) v)
-  (fun _ -> True)
-
-// To be extracted as: struct t { fields ... }
-[@@noextract_to "krml"] // primitive
-val field_t_nil: Type0
-[@@noextract_to "krml"] // primitive
-val field_t_cons (fn: Type0) (ft: Type0) (fc: Type0): Type0
-
-val norm_field_attr : unit
-
-noextract
-let norm_field_steps = [
-  delta_attr [`%norm_field_attr];
-  iota; zeta; primops;
-]
-
-inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
-noeq
-type field_description_t (t: Type0) : Type u#1 = {
-  fd_def: (string -> GTot bool);
-  fd_empty: (fd_empty: bool { fd_empty == true <==> (forall s . fd_def s == false) });
-  fd_type: (string -> Type0);
-  fd_typedef: ((s: string) -> Pure (typedef (fd_type s)) (requires (fd_def s)) (ensures (fun _ -> True)));
-}
-
-inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
-let nonempty_field_description_t (t: Type0) =
-  (fd: field_description_t t { fd.fd_empty == false })
-
-[@@noextract_to "krml"] // proof-only
-let field_t (#t: Type0) (fd: field_description_t t) : Tot eqtype = (s: string { fd.fd_def s })
-
-inline_for_extraction [@@noextract_to "krml"]
-let field_description_nil : field_description_t field_t_nil = {
-  fd_def = (fun _ -> false);
-  fd_empty = true;
-  fd_type = (fun _ -> unit);
-  fd_typedef = (fun _ -> false_elim ());
-}
-
-inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
-let field_description_cons0
-  (fn: Type0) (#ft: Type0) (#fc: Type0) (n: string) (t: typedef ft) (fd: field_description_t fc)
-: Tot (nonempty_field_description_t (field_t_cons fn ft fc))
-= {
-    fd_def = (fun n' -> n = n' || fd.fd_def n');
-    fd_empty = false;
-    fd_type = (fun n' -> if n = n' then ft else fd.fd_type n');
-    fd_typedef = (fun n' -> if n = n' then t else fd.fd_typedef n');
-  }
-
-inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
-let field_description_cons (#ft: Type0) (#fc: Type0) (n: string) (#fn: Type0) (# [ solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == fn))) (t: typedef ft) (fd: field_description_t fc) : Tot (nonempty_field_description_t (field_t_cons fn ft fc)) =
-  field_description_cons0 fn #ft #fc n t fd
-
-[@@noextract_to "krml"] // primitive
-val define_struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
-inline_for_extraction [@@noextract_to "krml"]
-let define_struct (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
-= define_struct0 tn #tf n fields
-
-// To be extracted as: struct t
-[@@noextract_to "krml"] // primitive
-val struct_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot Type0
-inline_for_extraction [@@noextract_to "krml"]
-let struct_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot Type0
-= struct_t0 tn #tf n fields
-
-val struct_set_field (#tn: Type0) (#tf: Type0) (#n: string) (#fields: nonempty_field_description_t tf) (f: field_t fields) (v: fields.fd_type f) (s: struct_t0 tn n fields) : GTot (struct_t0 tn n fields)
-
-val struct_get_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-  (field: field_t fields)
-: GTot (fields.fd_type field)
-
-val struct_eq
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s1 s2: struct_t0 tn n fields)
-: Ghost prop
-  (requires True)
-  (ensures (fun y ->
-    (y <==> (s1 == s2)) /\
-    (y <==> (forall field . struct_get_field s1 field == struct_get_field s2 field))
-  ))
-
-val struct_get_field_same
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-  (field: field_t fields)
-  (v: fields.fd_type field)
-: Lemma
-  (struct_get_field (struct_set_field field v s) field == v)
-  [SMTPat (struct_get_field (struct_set_field field v s) field)]
-
-val struct_get_field_other
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-  (field: field_t fields)
-  (v: fields.fd_type field)
-  (field': field_t fields)
-: Lemma
-  (requires (field' <> field))
-  (ensures (struct_get_field (struct_set_field field v s) field' == struct_get_field s field'))
-
-let struct_get_field_pat
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-  (field: field_t fields)
-  (v: fields.fd_type field)
-  (field': field_t fields)
-: Lemma
-  (struct_get_field (struct_set_field field v s) field' == (if field' = field then v else struct_get_field s field'))
-  [SMTPat (struct_get_field (struct_set_field field v s) field')]
-= if field' = field
-  then ()
-  else struct_get_field_other s field v field'
-
-[@@noextract_to "krml"] // proof-only
-val struct0 (tn: Type0) (#tf: Type0) (n: string) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
-
-inline_for_extraction
-[@@noextract_to "krml"; norm_field_attr] // proof-only
-let struct (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: nonempty_field_description_t tf) : Tot (typedef (struct_t0 tn n fields))
-= struct0 tn #tf n fields
-
-val struct_get_field_unknown
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: nonempty_field_description_t tf)
-  (field: field_t fields)
-: Lemma
-  (struct_get_field (unknown (struct0 tn n fields)) field == unknown (fields.fd_typedef field))
-  [SMTPat (struct_get_field (unknown (struct0 tn n fields)) field)]
-
-val struct_get_field_uninitialized
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: nonempty_field_description_t tf)
-  (field: field_t fields)
-: Lemma
-  (struct_get_field (uninitialized (struct0 tn n fields)) field == uninitialized (fields.fd_typedef field))
-  [SMTPat (struct_get_field (uninitialized (struct0 tn n fields)) field)]
-
-val has_struct_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: Tot vprop
-
-val has_struct_field_dup
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_struct_field r field r')
-    (fun _ -> has_struct_field r field r' `star` has_struct_field r field r')
-
-val has_struct_field_inj
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (r1 r2: ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_struct_field r field r1 `star` has_struct_field r field r2)
-    (fun _ -> has_struct_field r field r1 `star` has_struct_field r field r2 `star` ref_equiv r1 r2)
-
-val has_struct_field_equiv_from
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r1: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-  (r2: ref (struct0 tn n fields))
-: STGhostT unit opened
-    (ref_equiv r1 r2 `star` has_struct_field r1 field r')
-    (fun _ -> ref_equiv r1 r2 `star` has_struct_field r2 field r')
-
-val has_struct_field_equiv_to
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (r1': ref (fields.fd_typedef field))
-  (r2': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (ref_equiv r1' r2' `star` has_struct_field r field r1')
-    (fun _ -> ref_equiv r1' r2' `star` has_struct_field r field r2')
-
-val ghost_struct_field_focus
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_struct_field r field r' `star` pts_to r v)
-    (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field))
-
-val ghost_struct_field
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
-    (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
-
-[@@noextract_to "krml"] // primitive
-val struct_field0
-  (#tn: Type0)
-  (#tf: Type0)
-  (t': Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (td': typedef t' {
-    t' ==  fields.fd_type field /\
-    td' == fields.fd_typedef field
-  })
-: STT (ref td')
-    (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (struct_get_field v field) `star` has_struct_field r field r')
-
-inline_for_extraction [@@noextract_to "krml"] // primitive
-let struct_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-: STT (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
-    (pts_to r v)
-    (fun r' -> pts_to r (struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (struct_get_field v field) `star` has_struct_field r field r')
-= struct_field0
-    (norm norm_field_steps (fields.fd_type field))
-    r
-    field
-    (fields.fd_typedef field)
-
-val unstruct_field
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (#v': Ghost.erased (fields.fd_type field))
-  (r': ref (fields.fd_typedef field))
-: STGhost unit opened
-    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
-    (fun _ -> has_struct_field r field r' `star` pts_to r (struct_set_field field v' v))
-    (
-      struct_get_field v field == unknown (fields.fd_typedef field)
-    )
-    (fun _ -> True)
-
-let unstruct_field_alt
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (#v: Ghost.erased (struct_t0 tn n fields))
-  (r: ref (struct0 tn n fields))
-  (field: field_t fields)
-  (#v': Ghost.erased (fields.fd_type field))
-  (r': ref (fields.fd_typedef field))
-: STGhost (Ghost.erased (struct_t0 tn n fields)) opened
-    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
-    (fun s' -> has_struct_field r field r' `star` pts_to r s')
-    (
-      struct_get_field v field == unknown (fields.fd_typedef field)
-    )
-    (fun s' -> 
-      Ghost.reveal s' == struct_set_field field v' v
-    )
-= unstruct_field r field r';
-  _
-
-val fractionable_struct
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-: Lemma
-  (fractionable (struct0 tn n fields) s <==> (forall field . fractionable (fields.fd_typedef field) (struct_get_field s field)))
-  [SMTPat (fractionable (struct0 tn n fields) s)]
-
-val mk_fraction_struct
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-  (p: P.perm)
-  (field: field_t fields)
-: Lemma
-  (requires (fractionable (struct0 tn n fields) s))
-  (ensures (struct_get_field (mk_fraction (struct0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (struct_get_field s field) p))
-  [SMTPat (struct_get_field (mk_fraction (struct0 tn n fields) s p) field)]
-
-(*
-val mk_fraction_struct_recip
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-  (p: P.perm)
-: Ghost (struct_t0 tn n fields)
-  (requires (
-    (forall field . exists v . fractionable (fields.fd_typedef field) v /\ struct_get_field s field == mk_fraction (fields.fd_typedef field) v p)
-  ))
-  (ensures (fun s' ->
-    fractionable (struct0 tn n fields) s' /\
-    s == mk_fraction (struct0 tn n fields) s' p
-  ))
-*)
-
-val full_struct
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (s: struct_t0 tn n fields)
-: Lemma
-  (full (struct0 tn n fields) s <==> (forall field . full (fields.fd_typedef field) (struct_get_field s field)))
-  [SMTPat (full (struct0 tn n fields) s)]
-
-[@@noextract_to "krml"] // primitive
-val define_union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
-inline_for_extraction [@@noextract_to "krml"]
-let define_union (n: string) (#tf: Type0) (#tn: Type0) (#[solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
-= define_union0 tn #tf n fields
-
-// To be extracted as: union t
-[@@noextract_to "krml"] // primitive
-val union_t0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot Type0
-inline_for_extraction [@@noextract_to "krml"]
-let union_t (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot Type0
-= union_t0 tn #tf n fields
-
-val union_set_field (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) (f: field_t fields) (v: fields.fd_type f) : GTot (union_t0 tn n fields)
-
-val union_get_case
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (u: union_t0 tn n fields)
-: GTot (option (field_t fields))
-
-val union_get_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (u: union_t0 tn n fields)
-  (field: field_t fields)
-: Ghost (fields.fd_type field)
-    (requires (union_get_case u == Some field))
-    (ensures (fun _ -> True))
-
-val union_get_field_same
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: field_description_t tf)
-  (field: field_t fields)
-  (v: fields.fd_type field)
-: Lemma
-  (requires (~ (v == unknown (fields.fd_typedef field))))
-  (ensures (
-    let u = union_set_field tn n fields field v in
-    union_get_case u == Some field /\
-    union_get_field u field == v
-  ))
-  [SMTPatOr [
-    [SMTPat (union_get_case (union_set_field tn n fields field v))];
-    [SMTPat (union_get_field (union_set_field tn n fields field v) field)];
-  ]]
-
-val union_set_field_same
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (field: field_t fields)
-: Lemma
-  (requires (union_get_case s == Some field))
-  (ensures (
-    union_set_field tn n fields field (union_get_field s field) == s
-  ))
-  [SMTPat (union_set_field tn n fields (union_get_field s field))]
-
-[@@noextract_to "krml"] // proof-only
-val union0 (tn: Type0) (#tf: Type0) (n: string) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
-
-inline_for_extraction
-[@@noextract_to "krml"; norm_field_attr] // proof-only
-let union (#tf: Type0) (n: string) (#tn: Type0) (# [solve_mk_string_t ()] prf: squash (norm norm_typestring (mk_string_t n == tn))) (fields: field_description_t tf) : Tot (typedef (union_t0 tn n fields))
-= union0 tn #tf n fields
-
-val union_get_case_unknown
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: field_description_t tf)
-: Lemma
-  (union_get_case (unknown (union0 tn n fields)) == None)
-  [SMTPat (unknown (union0 tn n fields))]
-
-val union_set_field_unknown
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: field_description_t tf)
-  (field: field_t fields)
-: Lemma
-  (union_set_field tn n fields field (unknown (fields.fd_typedef field)) == unknown (union0 tn n fields))
-  [SMTPat (union_set_field tn n fields field (unknown (fields.fd_typedef field)))]
-
-val union_get_case_uninitialized
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: field_description_t tf)
-: Lemma
-  (union_get_case (uninitialized (union0 tn n fields)) == None)
-  [SMTPat (uninitialized (union0 tn n fields))]
-
-val mk_fraction_union_get_case
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (p: P.perm)
-: Lemma
-  (requires (fractionable (union0 tn n fields) s))
-  (ensures (
-    union_get_case (mk_fraction (union0 tn n fields) s p) == union_get_case s
-  ))
-  [SMTPat (union_get_case (mk_fraction (union0 tn n fields) s p))]
-
-val fractionable_union_get_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (field: field_t fields)
-: Lemma
-  (requires (union_get_case s == Some field))
-  (ensures (
-    fractionable (union0 tn n fields) s <==> fractionable (fields.fd_typedef field) (union_get_field s field)
-  ))
-  [SMTPat (fractionable (union0 tn n fields) s); SMTPat (union_get_field s field)]
-
-val mk_fraction_union_get_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (p: P.perm)
-  (field: field_t fields)
-: Lemma
-  (requires (fractionable (union0 tn n fields) s /\ union_get_case s == Some field))
-  (ensures (union_get_field (mk_fraction (union0 tn n fields) s p) field == mk_fraction (fields.fd_typedef field) (union_get_field s field) p))
-  [SMTPat (union_get_field (mk_fraction (union0 tn n fields) s p) field)]
-
-val mk_fraction_union_set_field
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (fields: field_description_t tf)
-  (field: field_t fields)
-  (v: fields.fd_type field)
-  (p: P.perm)
-: Lemma
-  (requires (fractionable (fields.fd_typedef field) v))
-  (ensures (
-    fractionable (union0 tn n fields) (union_set_field tn n fields field v) /\
-    mk_fraction (union0 tn n fields) (union_set_field tn n fields field v) p == union_set_field tn n fields field (mk_fraction (fields.fd_typedef field) v p)
-  ))
-
-val full_union
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (s: union_t0 tn n fields)
-  (field: field_t fields)
-: Lemma
-  (requires (union_get_case s == Some field))
-  (ensures (
-    full (union0 tn n fields) s <==> full (fields.fd_typedef field) (union_get_field s field)
-  ))
-  [SMTPat (full (union0 tn n fields) s); SMTPat (union_get_field s field)]
-
-val has_union_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: Tot vprop
-
-val has_union_field_dup
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_union_field r field r')
-    (fun _ -> has_union_field r field r' `star` has_union_field r field r')
-
-val has_union_field_inj
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (r1 r2: ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_union_field r field r1 `star` has_union_field r field r2)
-    (fun _ -> has_union_field r field r1 `star` has_union_field r field r2 `star` ref_equiv r1 r2)
-
-val has_union_field_equiv_from
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r1 r2: ref (union0 tn n fields))
-  (field: field_t fields)
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_union_field r1 field r' `star` ref_equiv r1 r2)
-    (fun _ -> has_union_field r2 field r' `star` ref_equiv r1 r2)
-
-val has_union_field_equiv_to
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: nonempty_field_description_t tf)
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (r1 r2: ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_union_field r field r1 `star` ref_equiv r1 r2)
-    (fun _ -> has_union_field r field r2 `star` ref_equiv r1 r2)
-
-val ghost_union_field_focus
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields {union_get_case v == Some field})
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_union_field r field r' `star` pts_to r v)
-    (fun _ -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-
-val ghost_union_field
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields {union_get_case v == Some field})
-: STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-
-[@@noextract_to "krml"] // primitive
-val union_field0
-  (#tn: Type0)
-  (#tf: Type0)
-  (t': Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields {union_get_case v == Some field})
-  (td': typedef t' {
-    t' ==  fields.fd_type field /\
-    td' == fields.fd_typedef field
-  })
-: STT (ref td')
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-
-inline_for_extraction [@@noextract_to "krml"] // primitive
-let union_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields {union_get_case v == Some field})
-: STT (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field))
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (union_get_field v field))
-= union_field0
-    (norm norm_field_steps (fields.fd_type field))
-    r
-    field
-    (fields.fd_typedef field)
-
-val ununion_field
-  (#opened: _)
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (#v': Ghost.erased (fields.fd_type field))
-  (r': ref (fields.fd_typedef field))
-: STGhostT unit opened
-    (has_union_field r field r' `star` pts_to r' v')
-    (fun _ -> has_union_field r field r' `star` pts_to r (union_set_field tn n fields field v'))
-
-// NOTE: we DO NOT support preservation of struct prefixes
-
-[@@noextract_to "krml"] // primitive
-val union_switch_field0
-  (#tn: Type0)
-  (#tf: Type0)
-  (t': Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-  (td': typedef t' {
-    t' ==  fields.fd_type field /\
-    td' == fields.fd_typedef field
-  })
-: ST (ref td') // need to write the pcm carrier value, so this cannot be Ghost or Atomic
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to r' (uninitialized (fields.fd_typedef field)))
-    (full (union0 tn n fields) v)
-    (fun r' -> True)
-
-inline_for_extraction [@@noextract_to "krml"]
-let union_switch_field
-  (#tn: Type0)
-  (#tf: Type0)
-  (#n: string)
-  (#fields: field_description_t tf)
-  (#v: Ghost.erased (union_t0 tn n fields))
-  (r: ref (union0 tn n fields))
-  (field: field_t fields)
-: ST (ref #(norm norm_field_steps (fields.fd_type field)) (fields.fd_typedef field)) // need to write the pcm carrier value, so this cannot be Ghost or Atomic
-    (pts_to r v)
-    (fun r' -> has_union_field r field r' `star` pts_to #(norm norm_field_steps (fields.fd_type field)) r' (uninitialized (fields.fd_typedef field)))
-    (full (union0 tn n fields) v)
-    (fun r' -> True)
-= union_switch_field0
-    (norm norm_field_steps (fields.fd_type field))
-    r
-    field
-    (fields.fd_typedef field)
-
-module SZ = FStar.SizeT
-
-// To be extracted as: t[tn]
-// Per the C standard, base array types must be of nonzero size
-inline_for_extraction [@@noextract_to "krml"]
-let array_size_t = (n: SZ.t { SZ.v n > 0 })
-val base_array_t (t: Type0) (tn: Type0 (* using Typenat (or Typestring for `#define`d constants) *)) (n: array_size_t) : Type0
-inline_for_extraction [@@noextract_to "krml"] // MUST be syntactically equal to Steel.C.Model.Array.array_domain
-let base_array_index_t (n: array_size_t) : Tot eqtype = (i: SZ.t { SZ.v i < SZ.v n })
-[@@noextract_to "krml"]
-val base_array0 (#t: Type0) (tn: Type0) (td: typedef t) (n: array_size_t) : Tot (typedef (base_array_t t tn n))
-
-inline_for_extraction
-[@@noextract_to "krml"] // proof-only
-let base_array (#t: Type0) (#tn: Type0) (td: typedef t) (n: nat {SZ.fits n /\ n > 0}) (# [solve_nat_t_of_nat ()] prf: squash (norm norm_typenat (nat_t_of_nat n == tn))) : Tot (typedef (base_array_t t tn (SZ.uint_to_t n)))
-= base_array0 tn td (SZ.uint_to_t n)
-
-val base_array_index (#t: Type0) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (i: base_array_index_t n) : GTot t
-val base_array_eq (#t: Type0) (#tn: Type0) (#n: array_size_t) (a1 a2: base_array_t t tn n) : Ghost prop
-  (requires True)
-  (ensures (fun y ->
-    (y <==> (a1 == a2)) /\
-    (y <==> (forall (i: base_array_index_t n) . base_array_index a1 i == base_array_index a2 i))
-  ))
-val mk_base_array (#t: Type) (tn: Type0) (n: array_size_t) (v: Seq.seq t) : Ghost (base_array_t t tn n)
-  (requires (
-    Seq.length v == SZ.v n
-  ))
-  (ensures (fun y -> True))
-val mk_base_array_index (#t: Type) (tn: Type) (n: array_size_t) (v: Seq.seq t) (i: base_array_index_t n) : Lemma
-  (requires (Seq.length v == SZ.v n))
-  (ensures (
-    Seq.length v == SZ.v n /\
-    base_array_index (mk_base_array tn n v) i == Seq.index v (SZ.v i)
-  ))
-  [SMTPat (base_array_index (mk_base_array tn n v) i)]
-
-let mk_base_array_inj  (#t: Type) (tn: Type0) (n: array_size_t) (v1 v2: Seq.seq t) : Lemma
-  (requires (
-    Seq.length v1 == SZ.v n /\
-    Seq.length v2 == SZ.v n /\
-    mk_base_array tn n v1 == mk_base_array tn n v2
-  ))
-  (ensures (v1 == v2))
-  [SMTPat (mk_base_array tn n v1); SMTPat (mk_base_array tn n v2)]
-= assert (forall (i: nat) . i < SZ.v n ==> base_array_index (mk_base_array tn n v1) (SZ.uint_to_t i) == base_array_index (mk_base_array tn n v2) (SZ.uint_to_t i));
-  assert (v1 `Seq.equal` v2)
-val base_array_fractionable (#t: Type) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (td: typedef t) : Lemma
-  (
-    fractionable (base_array0 tn td n) a <==>
-      (forall (i: base_array_index_t n) . fractionable td (base_array_index a i))
-  )
-  [SMTPat (fractionable (base_array0 tn td n) a)]
-val base_array_mk_fraction   (#t: Type) (#tn: Type0) (#n: array_size_t) (a: base_array_t t tn n) (td: typedef t) (p: P.perm) (i: base_array_index_t n) : Lemma
-  (requires (
-    fractionable (base_array0 tn td n) a
-  ))
-  (ensures (
-    fractionable (base_array0 tn td n) a /\
-    base_array_index (mk_fraction (base_array0 tn td n) a p) i == mk_fraction td (base_array_index a i) p
-  ))
-  [SMTPat (base_array_index (mk_fraction (base_array0 tn td n) a p) i)]
-
-val base_array_index_unknown (#t: Type) (tn: Type0) (n: array_size_t) (td: typedef t) (i: base_array_index_t n) : Lemma
-  (base_array_index (unknown (base_array0 tn td n)) i == unknown td)
-  [SMTPat (base_array_index (unknown (base_array0 tn td n)) i)]
-
-val base_array_index_uninitialized (#t: Type) (tn: Type0) (n: array_size_t) (td: typedef t) (i: base_array_index_t n) : Lemma
-  (base_array_index (uninitialized (base_array0 tn td n)) i == uninitialized td)
-  [SMTPat (base_array_index (uninitialized (base_array0 tn td n)) i)]
-
-val base_array_index_full (#t: Type) (#tn: Type0) (#n: array_size_t) (td: typedef t) (x: base_array_t t tn n) : Lemma
-  (full (base_array0 tn td n) x <==> (forall (i: base_array_index_t n) . full td (base_array_index x i)))
-  [SMTPat (full (base_array0 tn td n) x)]
-
-val has_base_array_cell
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (i: SZ.t)
-  (r': ref td)
-: Tot vprop
-
-val has_base_array_cell_post
-  (#opened: _)
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (i: SZ.t)
-  (r': ref td)
-: STGhost unit opened
-    (has_base_array_cell r i r')
-    (fun _ -> has_base_array_cell r i r')
-    (True)
-    (fun _ -> SZ.v i < SZ.v n)
-
-val has_base_array_cell_dup
-  (#opened: _)
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (i: SZ.t)
-  (r': ref td)
-: STGhostT unit opened
-    (has_base_array_cell r i r')
-    (fun _ -> has_base_array_cell r i r' `star` has_base_array_cell r i r')
-
-val has_base_array_cell_inj
-  (#opened: _)
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (i: SZ.t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (has_base_array_cell r i r1 `star` has_base_array_cell r i r2)
-    (fun _ -> has_base_array_cell r i r1 `star` has_base_array_cell r i r2 `star` ref_equiv r1 r2)
-
-val has_base_array_cell_equiv_from
-  (#opened: _)
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r1 r2: ref (base_array0 tn td n))
-  (i: SZ.t)
-  (r': ref td)
-: STGhostT unit opened
-    (has_base_array_cell r1 i r' `star` ref_equiv r1 r2)
-    (fun _ -> has_base_array_cell r2 i r' `star` ref_equiv r1 r2)
-
-val has_base_array_cell_equiv_to
-  (#opened: _)
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (i: SZ.t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (has_base_array_cell r i r1 `star` ref_equiv r1 r2)
-    (fun _ -> has_base_array_cell r i r2 `star` ref_equiv r1 r2)
-
-// contrary to array fields, one is not supposed to take an array cell directly from a base array. one should use arrays instead
-
-// To be extracted to: t*  (array type decays to pointer type)
-
-// We still want to prove that cutting off some cell range on the
-// right-hand end of an array won't change the C pointer to which an
-// array extracts to. This is why we separately introduce `array_ref`
-// to represent the "base+offset" pointer, and `array` which holds the
-// ghost length of an array.
-
-[@@noextract_to "krml"] // primitive
-val array_ref (#t: Type) (td: typedef t) : Tot Type0
-(*
-val array_ref_base_size_type (#t: Type) (#td: typedef t) (a: array_ref td) : GTot Type0
-*)
-val array_ref_base_size (#t: Type) (#td: typedef t) (a: array_ref td) : GTot array_size_t
-val has_array_ref_base (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r: ref (base_array0 ty td (array_ref_base_size a))) : GTot prop
-val has_array_ref_base_inj (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r1 r2: ref (base_array0 ty td (array_ref_base_size a))) : Lemma
-  (requires (has_array_ref_base a r1 /\ has_array_ref_base a r2))
-  (ensures (r1 == r2))
-val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ref td) : Ghost SZ.t
-  (requires True)
-  (ensures (fun y -> SZ.v y <= SZ.v (array_ref_base_size a)))
-val array_ref_base_offset_inj (#t: Type) (#td: typedef t) (#ty: Type) (a1: array_ref td) (r1: ref (base_array0 ty td (array_ref_base_size a1))) (a2: array_ref td) (r2: ref (base_array0 ty td (array_ref_base_size a2))) : Lemma
-  (requires (
-    array_ref_base_size a1 == array_ref_base_size a2 /\
-    has_array_ref_base a1 r1 /\
-    has_array_ref_base a2 r2 /\
-    r1 == coerce_eq () r2 /\
-    array_ref_offset a1 == array_ref_offset a2
-  ))
-  (ensures (a1 == a2))
-
-inline_for_extraction [@@noextract_to "krml"]
-let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
-  (len: Ghost.erased SZ.t { SZ.v (array_ref_offset r) + SZ.v len <= SZ.v (array_ref_base_size r) })
-
-inline_for_extraction [@@noextract_to "krml"]
-let array (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ref td & array_len_t r)
-
-let array_length
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-: GTot nat
-= SZ.v (dsnd a)
-
-val array_pts_to
-  (#t: Type)
-  (#td: typedef t)
-  (r: array td)
-  (v: Ghost.erased (Seq.seq t))
-: Tot vprop
-
-val array_pts_to_length
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: array td)
-  (v: Ghost.erased (Seq.seq t))
-: STGhost unit opened
-    (array_pts_to r v)
-    (fun _ -> array_pts_to r v)
-    (True)
-    (fun _ -> Seq.length v == SZ.v (dsnd r))
-
-#set-options "--print_implicits"
-
-let has_array_of_base
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (a: array td)
-: GTot prop
-=   let (| al, len |) = a in
-    array_ref_base_size al == n /\
-    has_array_ref_base al #tn r /\
-    array_ref_offset al == 0sz /\
-    Ghost.reveal len == n
-
-let has_array_of_base_inj
-  (#t: Type)
-  (#tn: Type0)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array0 tn td n))
-  (a1 a2: array td)
-: Lemma
-  (requires (
-      has_array_of_base #t #tn #n #td r a1 /\
-      has_array_of_base #t #tn #n #td r a2
-  ))
-  (ensures (a1 == a2))
-= let (| ar1, _ |) = a1 in
-  let (| ar2, _ |) = a2 in
-  array_ref_base_offset_inj #t #td #tn ar1 r ar2 r
-
-let seq_of_base_array
-  (#t: Type)
-  (#tn: Type)
-  (#n: array_size_t)
-  (v: base_array_t t tn n)
-: GTot (Seq.lseq t (SZ.v n))
-= Seq.init_ghost (SZ.v n) (fun i -> base_array_index v (SZ.uint_to_t i))
-
-val ghost_array_of_base_focus
-  (#t: Type)
-  (#tn: Type0)
-  (#opened: _)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-  (a: array td)
-: STGhost unit opened
-    (pts_to r v)
-    (fun _ -> array_pts_to a (seq_of_base_array v))
-    (has_array_of_base r a)
-    (fun _ -> True)
-
-val ghost_array_of_base
-  (#t: Type)
-  (#tn: Type0)
-  (#opened: _)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-: STGhostT (a: Ghost.erased (array td) { has_array_of_base r a }) opened
-    (pts_to r v)
-    (fun a -> array_pts_to a (seq_of_base_array v))
-
-let array_ref_of_base_post
-  (#t: Type)
-  (#tn: Type0)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-  (a: array_ref td)
-  (ar: array td)
-: GTot prop
-=
-       dfst ar == a /\
-        array_ref_base_size a == Ghost.reveal n /\
-        array_ref_offset a == 0sz /\
-        has_array_of_base r ar /\
-        Ghost.reveal (dsnd ar) == Ghost.reveal n
- 
-// to be extracted to just r
-[@@noextract_to "krml"] // primitive
-val array_ref_of_base
-  (#t: Type)
-  (#tn: Type0)
-  (#opened: _)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-: STAtomicBase (array_ref td) false opened Unobservable
-    (pts_to r v)
-    (fun a -> exists_ (fun (ar: array td) ->
-      array_pts_to ar (seq_of_base_array v) `star` pure (
-      array_ref_of_base_post v r a ar
-    )))
-    (True)
-    (fun _ -> True)
-
-inline_for_extraction [@@noextract_to "krml"]
-let array_of_base
-  (#t: Type)
-  (#tn: Type0)
-  (#opened: _)
-  (#n: Ghost.erased array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
-    (pts_to r v)
-    (fun a -> array_pts_to a (seq_of_base_array v))
-    (True)
-    (fun _ -> True)
-= let al = array_ref_of_base r in
-  let _ = elim_exists () in
-  elim_pure _;
-  let a = (| al, Ghost.hide (n <: SZ.t) |) in
-  rewrite (array_pts_to _ _) (array_pts_to _ _);
-  return a
-
-val unarray_of_base
-  (#t: Type)
-  (#tn: Type0)
-  (#opened: _)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (#v: Ghost.erased (Seq.seq t))
-  (r: ref (base_array0 tn td n))
-  (a: array td)
-: STGhost (Ghost.erased (base_array_t t tn n)) opened
-    (array_pts_to a v)
-    (fun v' -> pts_to r v')
-    (
-      has_array_of_base r a
-    )
-    (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
-
-(*
-val has_array_of_ref
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-  (a: array td)
-: Tot vprop
-
-val has_array_of_ref_post
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-  (a: array td)
-: STGhost unit opened
-    (has_array_of_ref r a)
-    (fun _ -> has_array_of_ref r a)
-    (True)
-    (fun _ ->
-      let (| al, len |) = a in
-      array_ref_base_size al == 1sz /\
-      array_ref_offset al == 0sz /\
-      Ghost.reveal len == 1sz
-    )
-
-// val has_array_of_ref_inj
-//   (#t: Type)
-//   (#td: typedef t)
-//   (r: ref td)
-//   (a1 a2: array td)
-// : Lemma
-//     (requires (
-//       has_array_of_ref r a1 /\
-//       has_array_of_ref r a2
-//     ))
-//     (ensures a1 == a2)
-
-val ghost_array_of_ref_focus
-  (#t: Type)
-  (#opened: _)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (r: ref td)
-  (a: array td)
-: STGhostT unit opened
-    (pts_to r v `star` has_array_of_ref r a)
-    (fun _ -> has_array_of_ref r a `star` array_pts_to a (Seq.create 1 (Ghost.reveal v)))
-
-val ghost_array_of_ref
-  (#t: Type)
-  (#opened: _)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (r: ref td)
-: STGhostT (Ghost.erased (array td)) opened
-    (pts_to r v)
-    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
-
-// to be extracted to just r
-[@@noextract_to "krml"] // primitive
-val array_ref_of_ref
-  (#t: Type)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (r: ref td)
-: STT (a: array_ref td { array_ref_base_size a == 1sz /\ array_ref_offset a == 0sz })
-    (pts_to r v)
-    (fun a -> array_pts_to (| a, Ghost.hide 1sz |) (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r (| a, Ghost.hide 1sz |))
-
-inline_for_extraction [@@noextract_to "krml"]
-let array_of_ref
-  (#t: Type)
-  (#td: typedef t)
-  (#v: Ghost.erased t)
-  (r: ref td)
-: STT (array td)
-    (pts_to r v)
-    (fun a -> array_pts_to a (Seq.create 1 (Ghost.reveal v)) `star` has_array_of_ref r a)
-= let al = array_ref_of_ref r in
-  let a : array td = (| al, Ghost.hide 1sz |) in
-  rewrite (array_pts_to _ _) (array_pts_to _ _);
-  rewrite (has_array_of_ref _ _) (has_array_of_ref r a);
-  return a
-
-val unarray_of_ref
-  (#t: Type)
-  (#opened: _)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (r: ref td)
-  (a: array td)
-: STGhostT (squash (Seq.length s == 1)) opened
-    (array_pts_to a s `star` has_array_of_ref r a)
-    (fun _ -> pts_to r (Seq.index s 0) `star` has_array_of_ref r a)
-*)
-
-val has_array_cell
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-: Tot vprop
-(*
-= SZ.v i < SZ.v (dsnd a) /\
-  has_base_array_cell (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r
-*)
-
-val has_array_cell_post
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r': ref td)
-: STGhost unit opened
-    (has_array_cell a i r')
-    (fun _ -> has_array_cell a i r')
-    (True)
-    (fun _ -> SZ.v i < SZ.v (dsnd a))
-
-val has_array_cell_has_base_array_cell
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-  (#ty: Type)
-  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
-: STGhost (Ghost.erased SZ.t) opened
-    (has_array_cell a i r)
-    (fun j -> has_base_array_cell br j r)
-    (has_array_ref_base (dfst a) br)
-    (fun j ->
-      SZ.v j == SZ.v (array_ref_offset (dfst a)) + SZ.v i
-    )
-
-val has_base_array_cell_has_array_cell
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-  (#ty: Type)
-  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
-: STGhost (Ghost.erased SZ.t) opened
-    (has_base_array_cell br i r)
-    (fun j -> has_array_cell a j r)
-    (has_array_ref_base (dfst a) br /\
-      SZ.v i >= SZ.v (array_ref_offset (dfst a)) /\
-      SZ.v i < SZ.v (array_ref_offset (dfst a)) + SZ.v (dsnd a)
-    )
-    (fun j ->
-      SZ.v i == SZ.v (array_ref_offset (dfst a)) + SZ.v j
-    )
-
-val has_array_cell_inj
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-  (r1 r2: ref td)
-: STGhostT unit opened
-    (
-      has_array_cell a i r1 `star`
-      has_array_cell a i r2
-    )
-    (fun _ ->
-      has_array_cell a i r1 `star`
-      has_array_cell a i r2 `star`
-      ref_equiv r1 r2
-    )
-// = has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
-
-(*
-val has_array_cell_array_of_ref
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (r: ref td)
-  (a: array td)
-: SteelGhostT unit opened
-    (has_array_of_ref r a)
-    (fun _ -> has_array_of_ref r a `star` has_array_cell a 0sz r)
-*)
-
-val ghost_array_cell_focus
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-: STGhostT (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
-    (array_pts_to a s `star` has_array_cell a i r)
-    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-
-val ghost_array_cell
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array td)
-  (i: SZ.t)
-: STGhost (r: Ghost.erased (ref td) { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) }) opened
-    (array_pts_to a s)
-    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-    (
-      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
-    )
-    (fun _ -> True)
-
-[@@noextract_to "krml"] // primitive
-val array_ref_cell
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array_ref td)
-  (len: array_len_t a)
-  (i: SZ.t)
-: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v len })
-    (array_pts_to (| a, len |) s)
-    (fun r -> array_pts_to (| a, len |) (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell (| a, len |) i r)
-    (
-      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v len)
-    )
-    (fun _ -> True)
-
-inline_for_extraction [@@noextract_to "krml"]
-let array_cell
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array td)
-  (i: SZ.t)
-: ST (r: ref td { SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a) })
-    (array_pts_to a s)
-    (fun r -> array_pts_to a (Seq.upd s (SZ.v i) (unknown td)) `star` pts_to r (Seq.index s (SZ.v i)) `star` has_array_cell a i r)
-    (
-      (SZ.v i < Seq.length s \/ SZ.v i < SZ.v (dsnd a))
-    )
-    (fun _ -> True)
-= let (| al, len |) = a in
-  rewrite (array_pts_to _ _) (array_pts_to _ s);
-  let r = array_ref_cell al len i in
-  rewrite (array_pts_to _ _) (array_pts_to _ _);
-  rewrite (has_array_cell _ _ _) (has_array_cell a i r);
-  return r
-
-val unarray_cell
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (#v: Ghost.erased t)
-  (a: array td)
-  (i: SZ.t)
-  (r: ref td)
-: STGhost (squash (SZ.v i < Seq.length s /\ Seq.length s == SZ.v (dsnd a))) opened
-    (array_pts_to a s `star` pts_to r v `star` has_array_cell a i r)
-    (fun _ -> array_pts_to a (Seq.upd s (SZ.v i) v) `star` has_array_cell a i r)
-    (
-      (SZ.v i < Seq.length s ==> Seq.index s (SZ.v i) == unknown td)
-    )
-    (fun _ -> True)
-
-val array_ref_shift
-  (#t: Type)
-  (#td: typedef t)
-  (a: array_ref td)
-  (i: SZ.t)
-: Ghost (array_ref td)
-    (requires (SZ.v (array_ref_offset a) + SZ.v i <= SZ.v (array_ref_base_size a)))
-    (ensures (fun y -> 
-      array_ref_base_size y == array_ref_base_size a /\
-      (forall ty r . has_array_ref_base a #ty r ==> has_array_ref_base y #ty (coerce_eq () r)) /\
-      array_ref_offset y == array_ref_offset a `SZ.add` i
-    ))
-
-inline_for_extraction [@@noextract_to "krml"]
-let array_split_l
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-: Pure (array td)
-   (requires (SZ.v i <= SZ.v (dsnd a)))
-   (ensures (fun _ -> True))
-= let (| al, _ |) = a in
-  (| al, Ghost.hide i |)
-
-let array_split_r
-  (#t: Type)
-  (#td: typedef t)
-  (a: array td)
-  (i: SZ.t)
-: Ghost (array td)
-   (requires (SZ.v i <= SZ.v (dsnd a)))
-   (ensures (fun _ -> True))
-= let (| al, len |) = a in
-  (| array_ref_shift al i, Ghost.hide (len `SZ.sub` i) |)
-
-val ghost_array_split
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array td)
-  (i: SZ.t)
-: STGhost (squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a))) opened
-    (array_pts_to a s)
-    (fun _ -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
-      array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)))
-    (SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
-    (fun _ -> True)
-
-[@@noextract_to "krml"] // primitive
-val array_ref_split
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (al: array_ref td)
-  (len: array_len_t al)
-  (i: SZ.t)
-: ST (ar: array_ref td { SZ.v i <= SZ.v len /\ Seq.length s == SZ.v len})
-    (array_pts_to (| al, len |) s)
-    (fun _ -> array_pts_to (array_split_l (| al, len |) i) (Seq.slice s 0 (SZ.v i)) `star`
-      array_pts_to (array_split_r (| al, len |) i) (Seq.slice s (SZ.v i) (Seq.length s)))
-    (SZ.v i <= SZ.v len \/ SZ.v i <= Seq.length s)
-    (fun ar -> ar == dfst (array_split_r (| al, len |) i))
-
-inline_for_extraction [@@noextract_to "krml"]
-let array_split
-  (#t: Type)
-  (#td: typedef t)
-  (#s: Ghost.erased (Seq.seq t))
-  (a: array td)
-  (i: SZ.t)
-: ST (a': array td {SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)})
-    (array_pts_to a s)
-    (fun a' -> array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)) `star`
-      array_pts_to a' (Seq.slice s (SZ.v i) (Seq.length s)))
-    (SZ.v i <= SZ.v (dsnd a) \/ SZ.v i <= Seq.length s)
-    (fun a' -> a' == array_split_r a i)
-= let (| al, len |) = a in
-  rewrite (array_pts_to _ _) (array_pts_to _ s);
-  let ar = array_ref_split al len i in
-  let a' = (| ar, Ghost.hide (len `SZ.sub` i) |) in
-  rewrite (array_pts_to (array_split_l _ _) _) (array_pts_to (array_split_l a _) _);
-  rewrite (array_pts_to (array_split_r _ _) _) (array_pts_to a' _);
-  return a'
-
-val array_join
-  (#opened: _)
-  (#t: Type)
-  (#td: typedef t)
-  (#sl #sr: Ghost.erased (Seq.seq t))
-  (a al ar: array td)
-  (i: SZ.t)
-: STGhost unit opened
-    (array_pts_to al sl `star` array_pts_to ar sr)
-    (fun _ -> array_pts_to a (sl `Seq.append` sr))
-    (
-      SZ.v i <= SZ.v (dsnd a) /\
-      al == array_split_l a i /\
-      ar == array_split_r a i
-    )
-    (fun _ -> True)
-
-let fractionable_seq (#t: Type) (td: typedef t) (s: Seq.seq t) : GTot prop =
-  forall (i: nat). i < Seq.length s ==> fractionable td (Seq.index s i)
-
-let mk_fraction_seq (#t: Type) (td: typedef t) (s: Seq.seq t) (p: P.perm) : Ghost (Seq.seq t)
-  (requires (fractionable_seq td s))
-  (ensures (fun _ -> True))
-= Seq.init_ghost (Seq.length s) (fun i -> mk_fraction td (Seq.index s i) p)
-
-let mk_fraction_seq_full (#t: Type0) (td: typedef t) (x: Seq.seq t) : Lemma
-  (requires (fractionable_seq td x))
-  (ensures (mk_fraction_seq td x P.full_perm == x))
-  [SMTPat (mk_fraction_seq td x P.full_perm)]
-= assert (mk_fraction_seq td x P.full_perm `Seq.equal` x)
-
-val mk_fraction_seq_split_gen
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p p1 p2: P.perm)
-: STGhost unit opened
-  (array_pts_to r (mk_fraction_seq td v p))
-  (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
-  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
-  (fun _ -> True)
-
-let mk_fraction_seq_split
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: array td) (v: Ghost.erased (Seq.seq t) { fractionable_seq td v }) (p1 p2: P.perm)
-: STGhost unit opened
-  (array_pts_to r v)
-  (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
-  (P.full_perm == p1 `P.sum_perm` p2)
-  (fun _ -> True)
-= mk_fraction_seq_full td v;
-  rewrite (array_pts_to _ _) (array_pts_to _ _);
-  mk_fraction_seq_split_gen r v P.full_perm p1 p2
-
-val mk_fraction_seq_join
-  (#opened: _)
-  (#t: Type) (#td: typedef t) (r: array td) (v: Seq.seq t { fractionable_seq td v }) (p1 p2: P.perm)
-: STGhostT unit opened
-  (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
-  (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
-
-let full_seq (#t: Type) (td: typedef t) (v: Seq.seq t) : GTot prop =
-  forall (i: nat { i < Seq.length v }) . {:pattern (Seq.index v i)} full td (Seq.index v i)
-
-let full_seq_seq_of_base_array
-  (#t: Type0) (tn: Type0) (td: typedef t) (#n: array_size_t)
-  (b: base_array_t t tn n)
-: Lemma
-  (ensures (full_seq td (seq_of_base_array b) <==> full (base_array0 tn td n) b))
-  [SMTPat (full_seq td (seq_of_base_array b))]
-= assert (forall (i: base_array_index_t n) . base_array_index b i == Seq.index (seq_of_base_array b) (SZ.v i))

From 76990828259694054da374b07e2e36e1f0cceb08 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 11:05:21 -0700
Subject: [PATCH 444/513] (TEMP) disable extraction of arraystruct examples

---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 173aff9bac7..17a37d1cb5f 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -9,7 +9,7 @@ ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
 endif
 
-world: verify test
+world: verify # test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \

From c6643f48c82d16b0d24becaeaa67ed9e1536a50a Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 14:33:56 -0700
Subject: [PATCH 445/513] Revert "snap"

This reverts commit 0c443ed72dc7ae10c3e1dcfb4537f18d52c38db3.
---
 .../generated/FStar_Extraction_Krml.ml        | 1053 +----------------
 1 file changed, 15 insertions(+), 1038 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 1fe13092ae2..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -706,102 +691,6 @@ let (is_op : Prims.string -> Prims.bool) =
   fun op1 -> (mk_op op1) <> FStar_Pervasives_Native.None
 let (is_machine_int : Prims.string -> Prims.bool) =
   fun m -> (mk_width m) <> FStar_Pervasives_Native.None
-let opt_bind :
-  'a 'b .
-    'a FStar_Pervasives_Native.option ->
-      ('a -> 'b FStar_Pervasives_Native.option) ->
-        'b FStar_Pervasives_Native.option
-  =
-  fun m ->
-    fun k ->
-      match m with
-      | FStar_Pervasives_Native.Some x -> k x
-      | FStar_Pervasives_Native.None -> FStar_Pervasives_Native.None
-let (char_of_typechar :
-  FStar_Extraction_ML_Syntax.mlty ->
-    FStar_BaseTypes.char FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    match t with
-    | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) ->
-        let p1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-        if p1 = "Steel.C.Typestring.cdot"
-        then FStar_Pervasives_Native.Some 46
-        else
-          if FStar_Compiler_Util.starts_with p1 "Steel.C.Typestring.c"
-          then
-            (let uu___1 =
-               FStar_String.get p1
-                 (FStar_String.strlen "Steel.C.Typestring.c") in
-             FStar_Pervasives_Native.Some uu___1)
-          else FStar_Pervasives_Native.None
-    | uu___ -> FStar_Pervasives_Native.None
-let (string_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty ->
-    Prims.string FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_nil" ->
-          FStar_Pervasives_Native.Some []
-      | FStar_Extraction_ML_Syntax.MLTY_Named (c::t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typestring.string_cons" ->
-          let uu___ = char_of_typechar c in
-          opt_bind uu___
-            (fun c' ->
-               let uu___1 = go t2 in
-               opt_bind uu___1
-                 (fun s' ->
-                    let uu___2 =
-                      let uu___3 = FStar_String.make Prims.int_one c' in
-                      uu___3 :: s' in
-                    FStar_Pervasives_Native.Some uu___2))
-      | uu___ -> FStar_Pervasives_Native.None in
-    let uu___ = go t in
-    opt_bind uu___
-      (fun ss -> FStar_Pervasives_Native.Some (FStar_String.concat "" ss))
-let (lident_of_string :
-  Prims.string -> lident FStar_Pervasives_Native.option) =
-  fun s ->
-    let path = FStar_String.split [46] s in
-    let rec go p =
-      match p with
-      | [] -> FStar_Pervasives_Native.None
-      | s1::[] -> FStar_Pervasives_Native.Some ([], s1)
-      | s1::p1 ->
-          let uu___ = go p1 in
-          opt_bind uu___
-            (fun uu___1 ->
-               match uu___1 with
-               | (names, name) ->
-                   FStar_Pervasives_Native.Some ((s1 :: names), name)) in
-    go path
-let (lident_of_typestring :
-  FStar_Extraction_ML_Syntax.mlty -> lident FStar_Pervasives_Native.option) =
-  fun t ->
-    let uu___ = string_of_typestring t in opt_bind uu___ lident_of_string
-let (int_of_typenat :
-  FStar_Extraction_ML_Syntax.mlty -> Prims.int FStar_Pervasives_Native.option)
-  =
-  fun t ->
-    let rec go t1 =
-      match t1 with
-      | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.z" ->
-          FStar_Pervasives_Native.Some Prims.int_zero
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t2::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.C.Typenat.s" ->
-          let uu___ = go t2 in
-          opt_bind uu___
-            (fun n -> FStar_Pervasives_Native.Some (n + Prims.int_one))
-      | uu___ -> FStar_Pervasives_Native.None in
-    go t
 type env =
   {
   names: name Prims.list ;
@@ -958,8 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -969,9 +857,8 @@ let rec (translate_type_without_decay :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -989,75 +876,6 @@ let rec (translate_type_without_decay :
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Monotonic.HyperStack.mem" -> TUnit
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::uu___1::[], p)
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___2
-            "Steel.C.StructLiteral.struct'"
-          ->
-          let uu___2 =
-            let uu___3 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___3 in
-          TQualified uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (tag::uu___::uu___1::uu___2::[], p) when
-          (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           FStar_Compiler_Util.starts_with uu___3
-             "Steel.ST.C.Types.struct_t0")
-            ||
-            (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             FStar_Compiler_Util.starts_with uu___3
-               "Steel.ST.C.Types.union_t0")
-          ->
-          let uu___3 =
-            let uu___4 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___4 in
-          TQualified uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (tag::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          FStar_Compiler_Util.starts_with uu___1 "Steel.C.UnionLiteral.union"
-          ->
-          let uu___1 =
-            let uu___2 = lident_of_typestring tag in
-            FStar_Compiler_Util.must uu___2 in
-          TQualified uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named
-          (uu___::arg::uu___1::uu___2::[], p) when
-          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___3 = "Steel.C.Reference.ptr" ->
-          let uu___3 = translate_type_without_decay env1 arg in TBuf uu___3
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
-          (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___1 = "Steel.ST.C.Types.ptr") ||
-            (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___1 = "Steel.ST.C.Types.array_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
-      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "Steel.ST.C.Types.scalar_t" ->
-          translate_type_without_decay env1 arg
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::n::s::[], p) when
-          (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___ = "Steel.C.Array.Base.array_view_type_sized") ||
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.ST.C.Types.base_array_t")
-          ->
-          let uu___ =
-            let uu___1 = translate_type_without_decay env1 t1 in
-            let uu___2 =
-              let uu___3 =
-                let uu___4 =
-                  let uu___5 = int_of_typenat n in
-                  FStar_Compiler_Util.must uu___5 in
-                FStar_Compiler_Util.string_of_int uu___4 in
-              (UInt32, uu___3) in
-            (uu___1, uu___2) in
-          TArray uu___
-      | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_or_null_from" ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::uu___1::[], p)
           when
           (((let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1070,8 +888,7 @@ let rec (translate_type_without_decay :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1108,21 +925,18 @@ let rec (translate_type_without_decay :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1182,14 +996,13 @@ let rec (translate_type_without_decay :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1202,36 +1015,19 @@ let rec (translate_type_without_decay :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      match t with
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::uu___1::[], p) when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.C.Array.Base.array_view_type_sized" ->
-          let uu___2 = translate_type_without_decay env1 t1 in TBuf uu___2
-      | FStar_Extraction_ML_Syntax.MLTY_Named (t1::uu___::[], p) when
-          let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___1 = "Steel.C.Array.Base.array_view_type" ->
-          let uu___1 = translate_type_without_decay env1 t1 in TBuf uu___1
-      | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1895,66 +1691,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::e2::uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Array.Base.malloc_from") || false
-          ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 e1 in
-            let uu___8 = translate_expr env1 e2 in
-            (ManuallyManaged, uu___7, uu___8) in
-          EBufCreate uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.C.Opt.malloc") || false
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.ST.C.Types.alloc") || false
-          -> EBufCreateNoInit (ManuallyManaged, (EConstant (UInt32, "1")))
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2048,48 +1784,11 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e2::[])
           when
-          ((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___5 = "FStar.Buffer.rfree") ||
-             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "Steel.C.Opt.free"))
-            ||
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "FStar.Buffer.rfree") ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.Monotonic.Buffer.free")
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e2::uu___5::uu___6::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.C.Array.Base.free_from") || false
-          -> let uu___7 = translate_expr env1 e2 in EBufFree uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.free" ->
-          let uu___7 = translate_expr env1 e1 in EBufFree uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2815,554 +2514,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::e1::uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.is_null_from" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Reference.is_null" ->
-          let uu___8 = translate_type env1 t in
-          let uu___9 = translate_expr env1 e1 in
-          generate_is_null uu___8 uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4::uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.is_null" ->
-          let uu___7 = translate_type env1 t in
-          let uu___8 = translate_expr env1 e1 in
-          generate_is_null uu___7 uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.C.Array.Base.null_from" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::[])
-          when
-          (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___6 = "Steel.C.Reference.null") ||
-            (let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.ST.C.Types.null")
-          -> let uu___6 = translate_type env1 t in EBufNull uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.StructLiteral.unaddr_of_struct_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5)
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.UnionLiteral.unaddr_of_union_field" -> EUnit
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::uu___4::struct_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_},
-           uu___7::uu___8::{
-                             FStar_Extraction_ML_Syntax.expr =
-                               FStar_Extraction_ML_Syntax.MLE_Const
-                               (FStar_Extraction_ML_Syntax.MLC_String
-                               field_name);
-                             FStar_Extraction_ML_Syntax.mlty = uu___9;
-                             FStar_Extraction_ML_Syntax.loc = uu___10;_}::r::[])
-          when
-          let uu___11 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___11 = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-          let uu___11 =
-            let uu___12 =
-              let uu___13 =
-                let uu___14 =
-                  let uu___15 = lident_of_typestring struct_name in
-                  FStar_Compiler_Util.must uu___15 in
-                TQualified uu___14 in
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = translate_expr env1 r in
-                  (uu___16, (EConstant (UInt32, "0"))) in
-                EBufRead uu___15 in
-              (uu___13, uu___14, field_name) in
-            EField uu___12 in
-          EAddrOf uu___11
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String struct_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___5;
-             FStar_Extraction_ML_Syntax.loc = uu___6;_}::uu___7::uu___8::r::
-           {
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Const
-               (FStar_Extraction_ML_Syntax.MLC_String field_name);
-             FStar_Extraction_ML_Syntax.mlty = uu___9;
-             FStar_Extraction_ML_Syntax.loc = uu___10;_}::uu___11::[])
-          when
-          ((let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___12 = "Steel.ST.C.Types.struct_field0") ||
-             (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___12 = "Steel.ST.C.Types.union_field0"))
-            ||
-            (let uu___12 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___12 = "Steel.ST.C.Types.union_switch_field0")
-          ->
-          let uu___12 =
-            let uu___13 =
-              let uu___14 =
-                let uu___15 =
-                  let uu___16 = lident_of_string struct_name in
-                  FStar_Compiler_Util.must uu___16 in
-                TQualified uu___15 in
-              let uu___15 =
-                let uu___16 =
-                  let uu___17 = translate_expr env1 r in
-                  (uu___17, (EQualified (["C"], "_zero_for_deref"))) in
-                EBufRead uu___16 in
-              (uu___14, uu___15, field_name) in
-            EField uu___13 in
-          EAddrOf uu___12
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 = lident_of_typestring union_name in
-                  FStar_Compiler_Util.must uu___13 in
-                TQualified uu___12 in
-              let uu___12 =
-                let uu___13 =
-                  let uu___14 = translate_expr env1 r in
-                  (uu___14, (EConstant (UInt32, "0"))) in
-                EBufRead uu___13 in
-              (uu___11, uu___12, field_name) in
-            EField uu___10 in
-          EAddrOf uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::union_name::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::{
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_Const
-                       (FStar_Extraction_ML_Syntax.MLC_String field_name);
-                     FStar_Extraction_ML_Syntax.mlty = uu___7;
-                     FStar_Extraction_ML_Syntax.loc = uu___8;_}::new_value::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.UnionLiteral.switch_union_field'" ->
-          let uu___9 =
-            let uu___10 =
-              let uu___11 =
-                let uu___12 =
-                  let uu___13 =
-                    let uu___14 = lident_of_typestring union_name in
-                    FStar_Compiler_Util.must uu___14 in
-                  TQualified uu___13 in
-                let uu___13 =
-                  let uu___14 =
-                    let uu___15 = translate_expr env1 r in
-                    (uu___15, (EConstant (UInt32, "0"))) in
-                  EBufRead uu___14 in
-                (uu___12, uu___13, field_name) in
-              EField uu___11 in
-            let uu___11 = translate_expr env1 new_value in (uu___10, uu___11) in
-          EAssign uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_read_sel" ->
-          let uu___6 =
-            let uu___7 = translate_expr env1 r in
-            (uu___7, (EConstant (UInt32, "0"))) in
-          EBufRead uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.C.Opt.opt_write_sel" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EConstant (UInt32, "0"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.C.Types.read0" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            (uu___8, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::x::[])
-          when
-          let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___6 = "Steel.ST.C.Types.write" ->
-          let uu___6 =
-            let uu___7 =
-              let uu___8 =
-                let uu___9 = translate_expr env1 r in
-                (uu___9, (EQualified (["C"], "_zero_for_deref"))) in
-              EBufRead uu___8 in
-            let uu___8 = translate_expr env1 x in (uu___7, uu___8) in
-          EAssign uu___6
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::uu___7::uu___8::r::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.ST.C.Types.array_ref_of_base" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::a::uu___7::i::[])
-          when
-          (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___8 = "Steel.ST.C.Types.array_ref_cell") ||
-            (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.ST.C.Types.array_ref_split")
-          ->
-          let uu___8 =
-            let uu___9 = translate_expr env1 a in
-            let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-          EBufSub uu___8
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::r::uu___6::uu___7::[])
-          when
-          let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___8 = "Steel.C.Array.Base.ref_of_array_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::r::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-          translate_expr env1 r
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::uu___7::r::uu___8::[])
-          when
-          let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___9 = "Steel.C.Array.Base.intro_varray_from" ->
-          let uu___9 =
-            let uu___10 = translate_expr env1 r in
-            (uu___10, (EConstant (UInt32, "0"))) in
-          EBufRead uu___9
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.index_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in (uu___8, uu___9) in
-          EBufRead uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           r::uu___6::i::x::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.upd_from" ->
-          let uu___7 =
-            let uu___8 = translate_expr env1 r in
-            let uu___9 = translate_expr env1 i in
-            let uu___10 = translate_expr env1 x in (uu___8, uu___9, uu___10) in
-          EBufWrite uu___7
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2::uu___3::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___4;
-             FStar_Extraction_ML_Syntax.loc = uu___5;_},
-           uu___6::a::i::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.C.Array.Base.split_right_from" ->
-          let uu___7 =
-            let uu___8 =
-              let uu___9 = translate_expr env1 a in
-              let uu___10 = translate_expr env1 i in (uu___9, uu___10) in
-            EBufRead uu___8 in
-          EAddrOf uu___7
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3776,72 +2927,6 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (parse_steel_c_fields :
-  env ->
-    FStar_Extraction_ML_Syntax.mlty ->
-      (Prims.string * typ) Prims.list FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun fields ->
-      let rec go fields1 =
-        match fields1 with
-        | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_nil") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.ST.C.Types.field_t_nil")
-            -> FStar_Pervasives_Native.Some []
-        | FStar_Extraction_ML_Syntax.MLTY_Named (field::t::fields2::[], p)
-            when
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.C.Fields.c_fields_t_cons") ||
-              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.ST.C.Types.field_t_cons")
-            ->
-            let uu___ = string_of_typestring field in
-            opt_bind uu___
-              (fun field1 ->
-                 if field1 = ""
-                 then go fields2
-                 else
-                   (let uu___2 = go fields2 in
-                    opt_bind uu___2
-                      (fun fields3 ->
-                         FStar_Pervasives_Native.Some ((field1, t) ::
-                           fields3))))
-        | uu___ -> FStar_Pervasives_Native.None in
-      let uu___ = go fields in
-      match uu___ with
-      | FStar_Pervasives_Native.None ->
-          ((let uu___2 =
-              FStar_Extraction_ML_Code.string_of_mlty ([], "") fields in
-            FStar_Compiler_Util.print1 "Failed to parse fields from %s.\n"
-              uu___2);
-           FStar_Pervasives_Native.None)
-      | FStar_Pervasives_Native.Some fields1 ->
-          (FStar_Compiler_Util.print_endline "Got fields:";
-           FStar_Compiler_List.fold_left
-             (fun uu___3 ->
-                fun uu___4 ->
-                  match uu___4 with
-                  | (field, ty) ->
-                      let uu___5 =
-                        FStar_Extraction_ML_Code.string_of_mlty ([], "") ty in
-                      FStar_Compiler_Util.print2 "  %s : %s\n" field uu___5)
-             () fields1;
-           (let uu___3 =
-              FStar_Compiler_List.map
-                (fun uu___4 ->
-                   match uu___4 with
-                   | (field, ty) ->
-                       ((let uu___6 =
-                           FStar_Extraction_ML_Code.string_of_mlty ([], "")
-                             ty in
-                         FStar_Compiler_Util.print1 "Translating %s.\n"
-                           uu___6);
-                        (let uu___6 = translate_type_without_decay env1 ty in
-                         (field, uu___6)))) fields1 in
-            FStar_Pervasives_Native.Some uu___3))
 let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
@@ -3854,115 +2939,7 @@ let (translate_type_decl :
           ty.FStar_Extraction_ML_Syntax.tydecl_meta
       then FStar_Pervasives_Native.None
       else
-        (let define_struct tag fields =
-           FStar_Compiler_Util.print_endline "Parsing struct definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse struct tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                let uu___3 =
-                  let uu___4 =
-                    let uu___5 =
-                      FStar_Compiler_List.map
-                        (fun uu___6 ->
-                           match uu___6 with
-                           | (field, ty1) -> (field, (ty1, true))) fields1 in
-                    (p, [], Prims.int_zero, uu___5) in
-                  DTypeFlat uu___4 in
-                FStar_Pervasives_Native.Some uu___3) in
-         let define_union tag fields =
-           FStar_Compiler_Util.print_endline "Parsing union definition.";
-           (let uu___2 = lident_of_typestring tag in
-            match uu___2 with
-            | FStar_Pervasives_Native.None ->
-                ((let uu___4 =
-                    FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                  FStar_Compiler_Util.print1
-                    "Failed to parse union tag from %s.\n" uu___4);
-                 FStar_Pervasives_Native.None)
-            | FStar_Pervasives_Native.Some p ->
-                let fields1 =
-                  let uu___3 = parse_steel_c_fields env1 fields in
-                  FStar_Compiler_Util.must uu___3 in
-                FStar_Pervasives_Native.Some
-                  (DUntaggedUnion (p, [], Prims.int_zero, fields1))) in
-         match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.StructLiteral.mk_struct_def" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.ST.C.Types.define_struct0" ->
-             define_struct tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named
-               (tag::fields::uu___6::uu___7::[], p)));_}
-             when
-             let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.ST.C.Types.define_union0" ->
-             define_union tag fields
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___5;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev
-               (FStar_Extraction_ML_Syntax.MLTY_Named (tag::fields::[], p)));_}
-             when
-             let uu___6 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___6 = "Steel.C.UnionLiteral.mk_union_def" ->
-             (FStar_Compiler_Util.print_endline "Parsing union definition.";
-              (let uu___7 = lident_of_typestring tag in
-               match uu___7 with
-               | FStar_Pervasives_Native.None ->
-                   ((let uu___9 =
-                       FStar_Extraction_ML_Code.string_of_mlty ([], "") tag in
-                     FStar_Compiler_Util.print1
-                       "Failed to parse struct tag from %s.\n" uu___9);
-                    FStar_Pervasives_Native.None)
-               | FStar_Pervasives_Native.Some p1 ->
-                   let fields1 =
-                     let uu___8 = parse_steel_c_fields env1 fields in
-                     FStar_Compiler_Util.must uu___8 in
-                   FStar_Pervasives_Native.Some
-                     (DUntaggedUnion (p1, [], Prims.int_zero, fields1))))
+        (match ty with
          | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
              FStar_Extraction_ML_Syntax.tydecl_name = name1;
              FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;

From b6873af4f42a1aa2cedddcdaab33120a859ee71f Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 08:38:40 -0700
Subject: [PATCH 446/513] move Steel.C extraction away, make
 FStar.Extraction.Krml "extensible"

---
 .../arraystructs/my_fstar/ExtractSteelC.fst   | 443 ++++++++++++++++
 .../arraystructs/my_fstar/ExtractSteelC.fsti  |   2 +
 examples/steel/arraystructs/my_fstar/Makefile |  10 +
 src/extraction/FStar.Extraction.Krml.fst      | 486 +++---------------
 4 files changed, 532 insertions(+), 409 deletions(-)
 create mode 100644 examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
 create mode 100644 examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
 create mode 100644 examples/steel/arraystructs/my_fstar/Makefile

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
new file mode 100644
index 00000000000..b55acb02437
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -0,0 +1,443 @@
+module ExtractSteelC
+
+friend FStar.Extraction.Krml
+open FStar.Compiler.Effect
+open FStar.Compiler.List
+open FStar
+open FStar.Compiler
+open FStar.Compiler.Util
+open FStar.Extraction
+open FStar.Extraction.ML
+open FStar.Extraction.ML.Syntax
+open FStar.Const
+open FStar.BaseTypes
+open FStar.Extraction.Krml
+module K = FStar.Extraction.Krml
+module BU = FStar.Compiler.Util
+
+(* JL: TODO: in stdlib somewhere? *)
+let opt_bind (m: option 'a) (k: 'a -> option 'b): option 'b =
+  match m with Some x -> k x | None -> None
+
+let char_of_typechar (t: mlty): option char =
+  match t with
+  | MLTY_Named ([], p) ->
+    let p = Syntax.string_of_mlpath p in
+    if p = "Steel.C.Typestring.cdot" then
+      Some '.'
+    else if BU.starts_with p "Steel.C.Typestring.c" then
+      Some (FStar.String.get p (FStar.String.strlen "Steel.C.Typestring.c"))
+    else
+      None
+
+  | _ -> None
+
+let string_of_typestring (t: mlty): option string =
+  let rec go t: option (list string) =
+    match t with
+    | MLTY_Named ([], p)
+      when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_nil"
+      ->
+      Some []
+
+    | MLTY_Named ([c; t], p)
+      when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_cons"
+      ->
+      opt_bind (char_of_typechar c) (fun c' ->
+      opt_bind (go t) (fun s' ->
+      Some (String.make 1 c' :: s')))
+      
+    | _ -> None
+  in
+  opt_bind (go t) (fun ss -> Some (FStar.String.concat "" ss))
+
+let lident_of_string (s: string): option lident =
+  let path = FStar.String.split ['.'] s in
+  let rec go p =
+    match p with
+    | [] -> None
+    | [s] -> Some ([], s)
+    | s :: p ->
+      opt_bind (go p) (fun (names, name) ->
+      Some (s :: names, name))
+  in go path
+
+let lident_of_typestring (t: mlty): option lident =
+  opt_bind (string_of_typestring t) lident_of_string
+
+let int_of_typenat (t: mlty): option int =
+  let rec go t =
+    match t with
+    | MLTY_Named ([], p)
+      when Syntax.string_of_mlpath p = "Steel.C.Typenat.z"
+      ->
+      Some 0
+
+    | MLTY_Named ([t], p)
+      when Syntax.string_of_mlpath p = "Steel.C.Typenat.s"
+      ->
+      opt_bind (go t) (fun n -> Some (n + 1))
+
+    | _ ->
+      None
+  in
+  go t
+
+let _ = register_translate_type_without_decay begin fun env t ->
+  match t with
+  
+  | MLTY_Named ([tag; _; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
+    ->
+      TQualified (must (lident_of_typestring tag))
+
+  | MLTY_Named ([tag; _; _; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.struct_t0"
+    || BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.union_t0"
+    ->
+      TQualified (must (lident_of_typestring tag))
+
+  | MLTY_Named ([tag; _], p) when
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
+    ->
+      TQualified (must (lident_of_typestring tag))
+  
+  | MLTY_Named ([_; arg; _; _], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Reference.ptr"
+    ->
+      TBuf (translate_type_without_decay env arg)
+
+  | MLTY_Named ([arg; _], p) when
+    Syntax.string_of_mlpath p = "Steel.ST.C.Types.ptr"
+    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.array_ref"
+    ->
+      TBuf (translate_type_without_decay env arg)
+
+  | MLTY_Named ([arg], p) when
+    Syntax.string_of_mlpath p = "Steel.ST.C.Types.scalar_t"
+    ->
+      translate_type_without_decay env arg
+
+  | MLTY_Named ([t; n; s], p)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
+     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.base_array_t"
+    ->
+      TArray (
+        translate_type_without_decay env t,
+        (UInt32, string_of_int (must (int_of_typenat n))))
+  
+  | MLTY_Named ([_; arg], p) when
+    Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_or_null_from"
+    ->
+      TBuf (translate_type_without_decay env arg)
+
+  | _ -> raise NotSupportedByKrmlExtension
+end
+
+let _ = register_translate_type begin fun env t ->
+  match t with
+  | MLTY_Named ([t; _; _], p)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
+     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.base_array_t"
+    ->
+      TBuf (translate_type_without_decay env t)
+      
+  | MLTY_Named ([t; _], p)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type"
+    ->
+      TBuf (translate_type_without_decay env t)
+
+  | _ -> raise NotSupportedByKrmlExtension
+end
+
+let _ = register_translate_expr begin fun env e ->
+  match e.expr with
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
+    when (
+          string_of_mlpath p = "Steel.ST.C.Types.alloc" ||
+          false) ->
+      EBufCreateNoInit (ManuallyManaged, EConstant (UInt32, "1"))
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _ (* sq *) ])
+    when (
+          string_of_mlpath p = "Steel.C.Array.Base.malloc_from" ||
+          false) ->
+      EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e ])
+    when (
+          string_of_mlpath p = "Steel.C.Opt.malloc" ||
+          false) ->
+      EBufCreate (ManuallyManaged, translate_expr env e, EConstant (UInt32, "1"))
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ])
+    when string_of_mlpath p = "Steel.C.Opt.free"
+      ->
+      EBufFree (translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2; _ (* a' *); _ (* sq *) ])
+    when (
+          string_of_mlpath p = "Steel.C.Array.Base.free_from" ||
+          false) ->
+      EBufFree (translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *); _ (* v *); e ]) when
+       string_of_mlpath p = "Steel.ST.C.Types.free" ->
+      EBufFree (translate_expr env e)
+
+(* BEGIN support for the Steel null pointer. *)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
+    when string_of_mlpath p = "Steel.C.Array.Base.is_null_from"
+    -> generate_is_null (translate_type env t) (translate_expr env e)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; t])}, [_ (* opened *); _ (* pcm *); e; _ (* view *)])
+    when string_of_mlpath p = "Steel.C.Reference.is_null"
+    -> generate_is_null (translate_type env t) (translate_expr env e)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); _ (* td *); _ (* v *); e])
+    when string_of_mlpath p = "Steel.ST.C.Types.is_null"
+    -> generate_is_null (translate_type env t) (translate_expr env e)
+  
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, _)
+    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.null_from"
+    -> EBufNull (translate_type env t)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
+    when string_of_mlpath p = "Steel.C.Reference.null"
+    || string_of_mlpath p = "Steel.ST.C.Types.null"
+    -> EBufNull (translate_type env t)
+
+(* END support for the Steel null pointer *)
+
+
+  (* Operations on Steel.C.Reference.ref *)
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
+    when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->
+      EUnit
+      
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
+    when string_of_mlpath p = "Steel.C.UnionLiteral.unaddr_of_union_field" ->
+      EUnit
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
+             [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
+    when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field''" ->
+      EAddrOf (EField (
+        TQualified (must (lident_of_typestring struct_name)),
+        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
+        field_name))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)},
+             [
+               ({expr=MLE_Const (MLC_String struct_name)})
+               ; _ (* fields *)
+               ; _ (* v *)
+               ; r
+               ; ({expr=MLE_Const (MLC_String field_name)})
+               ; _ (* td' *)
+             ])
+    when string_of_mlpath p = "Steel.ST.C.Types.struct_field0"
+    || string_of_mlpath p = "Steel.ST.C.Types.union_field0"
+    || string_of_mlpath p = "Steel.ST.C.Types.union_switch_field0"
+    ->
+      EAddrOf (EField (
+        TQualified (must (lident_of_string struct_name)),
+        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
+        field_name))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
+             [_; {expr=MLE_Const (MLC_String field_name)}; r])
+    when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
+      EAddrOf (EField (
+        TQualified (must (lident_of_typestring union_name)),
+        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
+        field_name))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
+             [_; {expr=MLE_Const (MLC_String field_name)}; new_value; r])
+    when string_of_mlpath p = "Steel.C.UnionLiteral.switch_union_field'" ->
+      EAssign (
+        EField (
+          TQualified (must (lident_of_typestring union_name)),
+          EBufRead (translate_expr env r, EConstant (UInt32, "0")),
+          field_name),
+        translate_expr env new_value)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
+    when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
+      EBufRead (translate_expr env r, EConstant (UInt32, "0"))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; x])
+    when string_of_mlpath p = "Steel.C.Opt.opt_write_sel" ->
+      EAssign (
+        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
+        translate_expr env x)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *) ; _ (* perm *) ; r])
+    when string_of_mlpath p = "Steel.ST.C.Types.read0" ->
+      EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *); r; x])
+    when string_of_mlpath p = "Steel.ST.C.Types.write" ->
+      EAssign (
+        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
+        translate_expr env x)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [
+      _ (* opened *);
+      _ (* n *);
+      _ (* typedef *);
+      _ (* v *);
+      r
+    ])
+    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_of_base" ->
+      // this is not a true read, this is how Karamel models arrays decaying into pointers
+      EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [
+      _ (* typedef *);
+      _ (* s *);
+      a;
+      _ (* len *);
+      i
+    ])
+    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_cell"
+    || string_of_mlpath p = "Steel.ST.C.Types.array_ref_split"
+    ->
+      EBufSub (translate_expr env a, translate_expr env i)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
+    when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
+      translate_expr env r
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r])
+    when string_of_mlpath p = "Steel.C.Array.Base.mk_array_of_ref_from" ->
+      translate_expr env r
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
+    when string_of_mlpath p = "Steel.C.Array.Base.intro_varray_from" ->
+      EBufRead (translate_expr env r, EConstant (UInt32, "0"))
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i])
+    when string_of_mlpath p = "Steel.C.Array.index_from" ->
+      EBufRead (translate_expr env r, translate_expr env i)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i; x])
+    when string_of_mlpath p = "Steel.C.Array.upd_from" ->
+      EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
+    when string_of_mlpath p = "Steel.C.Array.Base.split_right_from" ->
+      EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
+
+  | _ -> raise NotSupportedByKrmlExtension
+end
+
+let parse_steel_c_fields env (fields: mlty): option (list _) =
+      let rec go fields =
+        match fields with
+        | MLTY_Named ([], p)
+          when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
+          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_nil"
+          -> Some []
+          
+        | MLTY_Named ([field; t; fields], p)
+          when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
+          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_cons"
+          ->
+          opt_bind (string_of_typestring field) (fun field ->
+          if field = "" then go fields else
+          opt_bind (go fields) (fun fields ->
+          Some ((field, t) :: fields)))
+
+        | _ ->
+          None
+      in
+      match go fields with
+      | None ->
+        BU.print1 "Failed to parse fields from %s.\n"
+          (FStar.Extraction.ML.Code.string_of_mlty ([], "") fields);
+        None
+
+      | Some fields ->
+          print_endline "Got fields:";
+          List.fold_left
+            (fun () (field, ty) ->
+               BU.print2 "  %s : %s\n"
+                 field
+                 (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty))
+            ()
+            fields;
+          Some (
+            List.map
+              (fun (field, ty) ->
+                 BU.print1 "Translating %s.\n"
+                   (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
+                 (field, translate_type_without_decay env ty))
+              fields)
+
+let define_struct
+  env tag fields
+=
+  (* JL: TODO remove/improve these print commands *)
+  print_endline "Parsing struct definition.";
+  match lident_of_typestring tag with
+  | None ->
+    BU.print1 "Failed to parse struct tag from %s.\n"
+      (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
+    None
+  | Some p ->
+    let fields = must (parse_steel_c_fields env fields) in
+    Some (DTypeFlat (p, [], 0,
+      List.map (fun (field, ty) -> (field, (ty, true))) fields))
+
+let define_union
+  env tag fields
+=
+  (* JL: TODO remove/improve these print commands *)
+  print_endline "Parsing union definition.";
+  match lident_of_typestring tag with
+  | None ->
+    BU.print1 "Failed to parse union tag from %s.\n"
+      (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
+    None
+  | Some p ->
+    let fields = must (parse_steel_c_fields env fields) in
+    Some (DUntaggedUnion (p, [], 0, fields))
+
+let _ = register_translate_type_decl begin fun env ty ->
+    match ty with
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
+      ->
+      define_struct env tag fields
+
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
+      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_struct0"
+      ->
+      define_struct env tag fields
+
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
+      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_union0"
+      ->
+      define_union env tag fields
+
+    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
+      when Syntax.string_of_mlpath p = "Steel.C.UnionLiteral.mk_union_def"
+      ->
+      begin
+        (* JL: TODO remove/improve these print commands *)
+        print_endline "Parsing union definition.";
+        begin match lident_of_typestring tag with
+        | None ->
+          BU.print1 "Failed to parse struct tag from %s.\n"
+            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
+          None
+        | Some p ->
+          let fields = must (parse_steel_c_fields env fields) in
+          Some (DUntaggedUnion (p, [], 0, fields))
+        end
+      end
+    | _ -> raise NotSupportedByKrmlExtension
+end
diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
new file mode 100644
index 00000000000..75e86a536d4
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
@@ -0,0 +1,2 @@
+module ExtractSteelC
+
diff --git a/examples/steel/arraystructs/my_fstar/Makefile b/examples/steel/arraystructs/my_fstar/Makefile
new file mode 100644
index 00000000000..46f3d742f56
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/Makefile
@@ -0,0 +1,10 @@
+all:
+
+FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
+FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
+
+include $(FSTAR_HOME)/.common.mk
+include $(FSTAR_HOME)/ulib/gmake/z3.mk    # This pins $(Z3) ...
+include $(FSTAR_HOME)/ulib/gmake/fstar.mk # and $(FSTAR) for all sub-make calls
+include $(FSTAR_HOME)/src/Makefile.boot.common
+
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index cf741cdab16..4f31eaf6c5f 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -282,74 +282,6 @@ let is_op op =
 let is_machine_int m =
   mk_width m <> None
 
-(* JL: TODO: in stdlib somewhere? *)
-let opt_bind (m: option 'a) (k: 'a -> option 'b): option 'b =
-  match m with Some x -> k x | None -> None
-
-let char_of_typechar (t: mlty): option char =
-  match t with
-  | MLTY_Named ([], p) ->
-    let p = Syntax.string_of_mlpath p in
-    if p = "Steel.C.Typestring.cdot" then
-      Some '.'
-    else if BU.starts_with p "Steel.C.Typestring.c" then
-      Some (FStar.String.get p (FStar.String.strlen "Steel.C.Typestring.c"))
-    else
-      None
-
-  | _ -> None
-
-let string_of_typestring (t: mlty): option string =
-  let rec go t: option (list string) =
-    match t with
-    | MLTY_Named ([], p)
-      when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_nil"
-      ->
-      Some []
-
-    | MLTY_Named ([c; t], p)
-      when Syntax.string_of_mlpath p = "Steel.C.Typestring.string_cons"
-      ->
-      opt_bind (char_of_typechar c) (fun c' ->
-      opt_bind (go t) (fun s' ->
-      Some (String.make 1 c' :: s')))
-      
-    | _ -> None
-  in
-  opt_bind (go t) (fun ss -> Some (FStar.String.concat "" ss))
-
-let lident_of_string (s: string): option lident =
-  let path = FStar.String.split ['.'] s in
-  let rec go p =
-    match p with
-    | [] -> None
-    | [s] -> Some ([], s)
-    | s :: p ->
-      opt_bind (go p) (fun (names, name) ->
-      Some (s :: names, name))
-  in go path
-
-let lident_of_typestring (t: mlty): option lident =
-  opt_bind (string_of_typestring t) lident_of_string
-
-let int_of_typenat (t: mlty): option int =
-  let rec go t =
-    match t with
-    | MLTY_Named ([], p)
-      when Syntax.string_of_mlpath p = "Steel.C.Typenat.z"
-      ->
-      Some 0
-
-    | MLTY_Named ([t], p)
-      when Syntax.string_of_mlpath p = "Steel.C.Typenat.s"
-      ->
-      opt_bind (go t) (fun n -> Some (n + 1))
-
-    | _ ->
-      None
-  in
-  go t
-
 (* Environments **************************************************************)
 
 type env = {
@@ -444,7 +376,74 @@ let generate_is_null
 = let dummy = UInt64 in
   EApp (ETypApp (EOp (Eq, dummy), [TBuf t]), [x; EBufNull t])
 
-let rec translate_type_without_decay env t: typ =
+exception NotSupportedByKrmlExtension
+
+let translate_type_without_decay_t = env -> mlty -> ML typ
+let ref_translate_type_without_decay : ref translate_type_without_decay_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_translate_type_without_decay
+  (f: translate_type_without_decay_t)
+: ML unit
+= let before : translate_type_without_decay_t = !ref_translate_type_without_decay in
+  let after : translate_type_without_decay_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_type_without_decay := after
+
+let translate_type_without_decay env t = !ref_translate_type_without_decay env t
+
+// The outermost array type constructor decays to pointer
+let translate_type_t = env -> mlty -> ML typ
+let ref_translate_type : ref translate_type_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_translate_type
+  (f: translate_type_t)
+: ML unit
+= let before : translate_type_t = !ref_translate_type in
+  let after : translate_type_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_type := after
+
+let translate_type env t = !ref_translate_type env t
+
+let translate_expr_t = env -> mlexpr -> ML expr
+let ref_translate_expr : ref translate_expr_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_translate_expr
+  (f: translate_expr_t)
+: ML unit
+= let before : translate_expr_t = !ref_translate_expr in
+  let after : translate_expr_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_expr := after
+
+let translate_expr (env: env) (e: mlexpr) = !ref_translate_expr env e
+
+let translate_type_decl_t = env -> one_mltydecl -> ML (option decl)
+let ref_translate_type_decl : ref translate_type_decl_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_translate_type_decl
+  (f: translate_type_decl_t)
+: ML unit
+= let before : translate_type_decl_t = !ref_translate_type_decl in
+  let after : translate_type_decl_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_type_decl := after
+
+let translate_type_decl env ty: option decl =
+  if List.mem Syntax.NoExtract ty.tydecl_meta then
+    None
+  else
+    !ref_translate_type_decl env ty
+
+let rec translate_type_without_decay' env t: typ =
   match t with
   | MLTY_Tuple []
   | MLTY_Top ->
@@ -466,51 +465,6 @@ let rec translate_type_without_decay env t: typ =
   | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
       TUnit
   
-  | MLTY_Named ([tag; _; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.StructLiteral.struct'"
-    ->
-      TQualified (must (lident_of_typestring tag))
-
-  | MLTY_Named ([tag; _; _; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.struct_t0"
-    || BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.union_t0"
-    ->
-      TQualified (must (lident_of_typestring tag))
-
-  | MLTY_Named ([tag; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.C.UnionLiteral.union"
-    ->
-      TQualified (must (lident_of_typestring tag))
-  
-  | MLTY_Named ([_; arg; _; _], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Reference.ptr"
-    ->
-      TBuf (translate_type_without_decay env arg)
-
-  | MLTY_Named ([arg; _], p) when
-    Syntax.string_of_mlpath p = "Steel.ST.C.Types.ptr"
-    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.array_ref"
-    ->
-      TBuf (translate_type_without_decay env arg)
-
-  | MLTY_Named ([arg], p) when
-    Syntax.string_of_mlpath p = "Steel.ST.C.Types.scalar_t"
-    ->
-      translate_type_without_decay env arg
-
-  | MLTY_Named ([t; n; s], p)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
-     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.base_array_t"
-    ->
-      TArray (
-        translate_type_without_decay env t,
-        (UInt32, string_of_int (must (int_of_typenat n))))
-  
-  | MLTY_Named ([_; arg], p) when
-    Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_or_null_from"
-    ->
-      TBuf (translate_type_without_decay env arg)
-  
   | MLTY_Named ([_; arg; _], p) when
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||
@@ -592,18 +546,9 @@ let rec translate_type_without_decay env t: typ =
   | MLTY_Tuple ts ->
       TTuple (List.map (translate_type_without_decay env) ts)
   
-and translate_type env t: typ =
+and translate_type' env t: typ =
   // The outermost array type constructor decays to pointer
   match t with
-  | MLTY_Named ([t; _; _], p)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
-    ->
-      TBuf (translate_type_without_decay env t)
-      
-  | MLTY_Named ([t; _], p)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type"
-    ->
-      TBuf (translate_type_without_decay env t)
       
   | t -> translate_type_without_decay env t
 
@@ -613,7 +558,7 @@ and translate_binders env args =
 and translate_binder env (name, typ) =
   { name = name; typ = translate_type env typ; mut = false }
 
-and translate_expr env e: expr =
+and translate_expr' env e: expr =
   match e.expr with
   | MLE_Tuple [] ->
       EUnit
@@ -803,24 +748,6 @@ and translate_expr env e: expr =
           string_of_mlpath p = "LowStar.ImmutableBuffer.imalloc") ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _ (* sq *) ])
-    when (
-          string_of_mlpath p = "Steel.C.Array.Base.malloc_from" ||
-          false) ->
-      EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e ])
-    when (
-          string_of_mlpath p = "Steel.C.Opt.malloc" ||
-          false) ->
-      EBufCreate (ManuallyManaged, translate_expr env e, EConstant (UInt32, "1"))
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
-    when (
-          string_of_mlpath p = "Steel.ST.C.Types.alloc" ||
-          false) ->
-      EBufCreateNoInit (ManuallyManaged, EConstant (UInt32, "1"))
-
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e0; e1 ])
     when string_of_mlpath p = "Steel.ST.HigherArray.malloc_ptr" ->
       EBufCreate (ManuallyManaged, translate_expr env e0, translate_expr env e1)
@@ -843,20 +770,9 @@ and translate_expr env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ])
     when (string_of_mlpath p = "FStar.Buffer.rfree" ||
-          string_of_mlpath p = "Steel.C.Opt.free" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.free") ->
       EBufFree (translate_expr env e2)
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2; _ (* a' *); _ (* sq *) ])
-    when (
-          string_of_mlpath p = "Steel.C.Array.Base.free_from" ||
-          false) ->
-      EBufFree (translate_expr env e2)
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *); _ (* v *); e ]) when
-       string_of_mlpath p = "Steel.ST.C.Types.free" ->
-      EBufFree (translate_expr env e)
-
   (* Generic buffer operations. *)
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; _e3 ]) when (string_of_mlpath p = "FStar.Buffer.sub") ->
       EBufSub (translate_expr env e1, translate_expr env e2)
@@ -1053,151 +969,6 @@ and translate_expr env e: expr =
     when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
     translate_expr env e
 
-(* BEGIN support for the Steel null pointer. *)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
-    when string_of_mlpath p = "Steel.C.Array.Base.is_null_from"
-    -> generate_is_null (translate_type env t) (translate_expr env e)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; t])}, [_ (* opened *); _ (* pcm *); e; _ (* view *)])
-    when string_of_mlpath p = "Steel.C.Reference.is_null"
-    -> generate_is_null (translate_type env t) (translate_expr env e)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); _ (* td *); _ (* v *); e])
-    when string_of_mlpath p = "Steel.ST.C.Types.is_null"
-    -> generate_is_null (translate_type env t) (translate_expr env e)
-  
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, _)
-    when Syntax.string_of_mlpath p = "Steel.C.Array.Base.null_from"
-    -> EBufNull (translate_type env t)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
-    when string_of_mlpath p = "Steel.C.Reference.null"
-    || string_of_mlpath p = "Steel.ST.C.Types.null"
-    -> EBufNull (translate_type env t)
-
-(* END support for the Steel null pointer *)
-
-  (* Operations on Steel.C.Reference.ref *)
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
-    when string_of_mlpath p = "Steel.C.StructLiteral.unaddr_of_struct_field" ->
-      EUnit
-      
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, _)
-    when string_of_mlpath p = "Steel.C.UnionLiteral.unaddr_of_union_field" ->
-      EUnit
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; _; struct_name])},
-             [_; _; {expr=MLE_Const (MLC_String field_name)}; r])
-    when string_of_mlpath p = "Steel.C.StructLiteral.addr_of_struct_field''" ->
-      EAddrOf (EField (
-        TQualified (must (lident_of_typestring struct_name)),
-        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
-        field_name))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)},
-             [
-               ({expr=MLE_Const (MLC_String struct_name)})
-               ; _ (* fields *)
-               ; _ (* v *)
-               ; r
-               ; ({expr=MLE_Const (MLC_String field_name)})
-               ; _ (* td' *)
-             ])
-    when string_of_mlpath p = "Steel.ST.C.Types.struct_field0"
-    || string_of_mlpath p = "Steel.ST.C.Types.union_field0"
-    || string_of_mlpath p = "Steel.ST.C.Types.union_switch_field0"
-    ->
-      EAddrOf (EField (
-        TQualified (must (lident_of_string struct_name)),
-        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
-        field_name))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
-             [_; {expr=MLE_Const (MLC_String field_name)}; r])
-    when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->
-      EAddrOf (EField (
-        TQualified (must (lident_of_typestring union_name)),
-        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
-        field_name))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
-             [_; {expr=MLE_Const (MLC_String field_name)}; new_value; r])
-    when string_of_mlpath p = "Steel.C.UnionLiteral.switch_union_field'" ->
-      EAssign (
-        EField (
-          TQualified (must (lident_of_typestring union_name)),
-          EBufRead (translate_expr env r, EConstant (UInt32, "0")),
-          field_name),
-        translate_expr env new_value)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r])
-    when string_of_mlpath p = "Steel.C.Opt.opt_read_sel" ->
-      EBufRead (translate_expr env r, EConstant (UInt32, "0"))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; x])
-    when string_of_mlpath p = "Steel.C.Opt.opt_write_sel" ->
-      EAssign (
-        EBufRead (translate_expr env r, EConstant (UInt32, "0")),
-        translate_expr env x)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *) ; _ (* perm *) ; r])
-    when string_of_mlpath p = "Steel.ST.C.Types.read0" ->
-      EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *); r; x])
-    when string_of_mlpath p = "Steel.ST.C.Types.write" ->
-      EAssign (
-        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
-        translate_expr env x)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [
-      _ (* opened *);
-      _ (* n *);
-      _ (* typedef *);
-      _ (* v *);
-      r
-    ])
-    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_of_base" ->
-      // this is not a true read, this is how Karamel models arrays decaying into pointers
-      EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [
-      _ (* typedef *);
-      _ (* s *);
-      a;
-      _ (* len *);
-      i
-    ])
-    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_cell"
-    || string_of_mlpath p = "Steel.ST.C.Types.array_ref_split"
-    ->
-      EBufSub (translate_expr env a, translate_expr env i)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* opened *); r; _ (* r_to *); _ (* sq *) ])
-    when string_of_mlpath p = "Steel.C.Array.Base.ref_of_array_from" ->
-      translate_expr env r
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened *); r])
-    when string_of_mlpath p = "Steel.C.Array.Base.mk_array_of_ref_from" ->
-      translate_expr env r
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_ (* opened*); _ (* n *); r; _ (* squash *)])
-    when string_of_mlpath p = "Steel.C.Array.Base.intro_varray_from" ->
-      EBufRead (translate_expr env r, EConstant (UInt32, "0"))
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i])
-    when string_of_mlpath p = "Steel.C.Array.index_from" ->
-      EBufRead (translate_expr env r, translate_expr env i)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [r; _ (* r' *); i; x])
-    when string_of_mlpath p = "Steel.C.Array.upd_from" ->
-      EBufWrite (translate_expr env r, translate_expr env i, translate_expr env x)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _])}, [_; a; i])
-    when string_of_mlpath p = "Steel.C.Array.Base.split_right_from" ->
-      EAddrOf (EBufRead (translate_expr env a, translate_expr env i))
-
   | MLE_App ({ expr = MLE_Name p }, [ arg ])
     when string_of_mlpath p = "FStar.SizeT.uint16_to_sizet" ||
          string_of_mlpath p = "FStar.SizeT.uint32_to_sizet" ||
@@ -1389,117 +1160,8 @@ and translate_constant c: expr =
 and mk_op_app env w op args =
   EApp (EOp (op, w), List.map (translate_expr env) args)
 
-let parse_steel_c_fields env (fields: mlty): option (list _) =
-      let rec go fields =
-        match fields with
-        | MLTY_Named ([], p)
-          when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
-          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_nil"
-          -> Some []
-          
-        | MLTY_Named ([field; t; fields], p)
-          when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
-          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_cons"
-          ->
-          opt_bind (string_of_typestring field) (fun field ->
-          if field = "" then go fields else
-          opt_bind (go fields) (fun fields ->
-          Some ((field, t) :: fields)))
-
-        | _ ->
-          None
-      in
-      match go fields with
-      | None ->
-        BU.print1 "Failed to parse fields from %s.\n"
-          (FStar.Extraction.ML.Code.string_of_mlty ([], "") fields);
-        None
-
-      | Some fields ->
-          print_endline "Got fields:";
-          List.fold_left
-            (fun () (field, ty) ->
-               BU.print2 "  %s : %s\n"
-                 field
-                 (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty))
-            ()
-            fields;
-          Some (
-            List.map
-              (fun (field, ty) ->
-                 BU.print1 "Translating %s.\n"
-                   (FStar.Extraction.ML.Code.string_of_mlty ([], "") ty);
-                 (field, translate_type_without_decay env ty))
-              fields)
-
-let translate_type_decl env ty: option decl =
-  if List.mem Syntax.NoExtract ty.tydecl_meta then
-    None
-  else
-    let define_struct
-      tag fields
-    =
-        (* JL: TODO remove/improve these print commands *)
-        print_endline "Parsing struct definition.";
-        begin match lident_of_typestring tag with
-        | None ->
-          BU.print1 "Failed to parse struct tag from %s.\n"
-            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
-          None
-        | Some p ->
-          let fields = must (parse_steel_c_fields env fields) in
-          Some (DTypeFlat (p, [], 0,
-            List.map (fun (field, ty) -> (field, (ty, true))) fields))
-        end
-    in
-    let define_union
-      tag fields
-    =
-        (* JL: TODO remove/improve these print commands *)
-        print_endline "Parsing union definition.";
-        begin match lident_of_typestring tag with
-        | None ->
-          BU.print1 "Failed to parse union tag from %s.\n"
-            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
-          None
-        | Some p ->
-          let fields = must (parse_steel_c_fields env fields) in
-          Some (DUntaggedUnion (p, [], 0, fields))
-        end
-    in
+let translate_type_decl' env ty: option decl =
     match ty with
-    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
-      when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
-      ->
-      define_struct tag fields
-
-    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
-      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_struct0"
-      ->
-      define_struct tag fields
-
-    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
-      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_union0"
-      ->
-      define_union tag fields
-
-    | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
-      when Syntax.string_of_mlpath p = "Steel.C.UnionLiteral.mk_union_def"
-      ->
-      begin
-        (* JL: TODO remove/improve these print commands *)
-        print_endline "Parsing union definition.";
-        begin match lident_of_typestring tag with
-        | None ->
-          BU.print1 "Failed to parse struct tag from %s.\n"
-            (FStar.Extraction.ML.Code.string_of_mlty ([], "") tag);
-          None
-        | Some p ->
-          let fields = must (parse_steel_c_fields env fields) in
-          Some (DUntaggedUnion (p, [], 0, fields))
-        end
-      end
-
     | {tydecl_assumed=assumed;
        tydecl_name=name;
        tydecl_parameters=args;
@@ -1717,3 +1379,9 @@ let translate (MLLib modules): list file =
           m_name (BU.print_exn e);
         None
   ) modules
+
+let _ =
+  register_translate_type_without_decay translate_type_without_decay';
+  register_translate_type translate_type';
+  register_translate_type_decl translate_type_decl';
+  register_translate_expr translate_expr'

From 5a0dff93fe693c1fa788af99842b0b6794d84d14 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 08:40:14 -0700
Subject: [PATCH 447/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 397 ++++++++++++------
 1 file changed, 267 insertions(+), 130 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..68500935892 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,102 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +967,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +999,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1037,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1111,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1131,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1166,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2637,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3066,121 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 = translate_type env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3520,9 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (uu___1931 : unit) =
+  register_translate_type_without_decay translate_type_without_decay';
+  register_translate_type translate_type';
+  register_translate_type_decl translate_type_decl';
+  register_translate_expr translate_expr'
\ No newline at end of file

From fd608c66d4c041f94beb090c0f1b0a58d1093aab Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 15:32:48 -0700
Subject: [PATCH 448/513] compile my own F* for arraystruct examples

---
 examples/steel/arraystructs/Makefile          | 12 ++++++++---
 .../steel/arraystructs/my_fstar/.gitignore    |  2 ++
 examples/steel/arraystructs/my_fstar/Makefile | 20 ++++++++++++++++++-
 examples/steel/arraystructs/my_fstar/dune     | 17 ++++++++++++++++
 .../steel/arraystructs/my_fstar/dune-project  |  8 ++++++++
 examples/steel/arraystructs/my_fstar/main.ml  |  4 ++++
 6 files changed, 59 insertions(+), 4 deletions(-)
 create mode 100644 examples/steel/arraystructs/my_fstar/.gitignore
 create mode 100644 examples/steel/arraystructs/my_fstar/dune
 create mode 100644 examples/steel/arraystructs/my_fstar/dune-project
 create mode 100644 examples/steel/arraystructs/my_fstar/main.ml

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 17a37d1cb5f..7179b56be12 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -1,7 +1,10 @@
 all: world
 
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
-FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
+export FSTAR_HOME
+FSTAR_EXE = $(CURDIR)/my_fstar/bin/fstar.exe
+FSTAR_LIB ?= $(realpath $(FSTAR_HOME)/ulib)
+export FSTAR_LIB
 
 INCLUDE_PATH = $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj
 
@@ -31,14 +34,17 @@ SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOM
 
 comma=,
 
-.depend: $(ALL_SOURCE_FILES) Makefile
-	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:* $(addprefix -,$(NO_EXTRACT_MODULES))'  > $@.tmp
+.depend: $(ALL_SOURCE_FILES) Makefile $(FSTAR_EXE)
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:* -FStar $(addprefix -,$(NO_EXTRACT_MODULES))'  > $@.tmp
 	mv $@.tmp $@
 
 depend: .depend
 
 -include .depend
 
+$(FSTAR_EXE):
+	+$(MAKE) -C my_fstar
+
 $(ALL_CHECKED_FILES): %.checked:
 	$(FSTAR) $<
 	@touch -c $@
diff --git a/examples/steel/arraystructs/my_fstar/.gitignore b/examples/steel/arraystructs/my_fstar/.gitignore
new file mode 100644
index 00000000000..0f759af2541
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/.gitignore
@@ -0,0 +1,2 @@
+ExtractSteelC.ml
+lib
diff --git a/examples/steel/arraystructs/my_fstar/Makefile b/examples/steel/arraystructs/my_fstar/Makefile
index 46f3d742f56..fa0c08f53fc 100644
--- a/examples/steel/arraystructs/my_fstar/Makefile
+++ b/examples/steel/arraystructs/my_fstar/Makefile
@@ -1,4 +1,6 @@
-all:
+all: world
+
+world: $(CURDIR)/bin/fstar.exe
 
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
 FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
@@ -8,3 +10,19 @@ include $(FSTAR_HOME)/ulib/gmake/z3.mk    # This pins $(Z3) ...
 include $(FSTAR_HOME)/ulib/gmake/fstar.mk # and $(FSTAR) for all sub-make calls
 include $(FSTAR_HOME)/src/Makefile.boot.common
 
+OUTPUT_DIRECTORY = $(CURDIR)
+FSTAR_C=$(RUNLIM) $(FSTAR_EXE) $(SIL) $(FSTAR_BOOT_OPTIONS) --already_cached 'FStar'
+
+extract: ExtractSteelC.ml
+
+# And then, in a separate invocation, from each .checked.lax we
+# extract an .ml file
+%.ml: %.fst
+	$(call msg, "EXTRACT", $(notdir $@))
+	$(Q)$(BENCHMARK_PRE) $(FSTAR_C) $< \
+		   --odir "$(OUTPUT_DIRECTORY)" \
+                   --codegen OCaml \
+                   --extract_module $(basename $(notdir $<))
+
+$(CURDIR)/bin/fstar.exe: ExtractSteelC.fst ExtractSteelC.fsti Makefile
+	OCAMLPATH=$(FSTAR_HOME)/lib dune build && dune install --prefix=$(CURDIR)
diff --git a/examples/steel/arraystructs/my_fstar/dune b/examples/steel/arraystructs/my_fstar/dune
new file mode 100644
index 00000000000..c81c03adc43
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/dune
@@ -0,0 +1,17 @@
+(executable
+ (name main)
+ (public_name fstar.exe)
+ (libraries
+    fstar.lib
+ )
+ (modules Main ExtractSteelC)
+ (link_flags "-linkall")
+ (modes (native exe))
+ (flags (:standard -w -A))
+)
+
+(rule
+  (target "ExtractSteelC.ml")
+  (deps "ExtractSteelC.fst" "ExtractSteelC.fsti" "Makefile")
+  (action (run make extract))
+)
diff --git a/examples/steel/arraystructs/my_fstar/dune-project b/examples/steel/arraystructs/my_fstar/dune-project
new file mode 100644
index 00000000000..841110fda04
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/dune-project
@@ -0,0 +1,8 @@
+(lang dune 3.2)
+(name fstar-steel-c)
+(generate_opam_files false)
+
+(package
+  (name fstar-steel-c)
+  (synopsis "The F* programming language and proof assistant with extraction of Steel files to C")
+)
diff --git a/examples/steel/arraystructs/my_fstar/main.ml b/examples/steel/arraystructs/my_fstar/main.ml
new file mode 100644
index 00000000000..f86e3acc6bf
--- /dev/null
+++ b/examples/steel/arraystructs/my_fstar/main.ml
@@ -0,0 +1,4 @@
+let x =
+      Printexc.record_backtrace true;
+      Gc.set { (Gc.get()) with Gc.minor_heap_size = 1048576; Gc.major_heap_increment = 4194304; Gc.space_overhead = 150; };
+      FStar_Main.main ()

From 04fdc441046ea09d12869d0d5129580ccc7a9505 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 15:34:49 -0700
Subject: [PATCH 449/513] Revert "(TEMP) disable extraction of arraystruct
 examples"

This reverts commit 76990828259694054da374b07e2e36e1f0cceb08.
---
 examples/steel/arraystructs/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 7179b56be12..023fdc2c9d8 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -12,7 +12,7 @@ ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
 endif
 
-world: verify # test
+world: verify test
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \

From 5b2f139299f0b872c393d78299a4932f7972eb98 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 16:11:45 -0700
Subject: [PATCH 450/513] update extraction of Steel.ST.C.Types primitives with
 base qualifiers

---
 .../arraystructs/my_fstar/ExtractSteelC.fst   | 46 +++++++++----------
 1 file changed, 23 insertions(+), 23 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index b55acb02437..e7acfa1850d 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -92,8 +92,8 @@ let _ = register_translate_type_without_decay begin fun env t ->
       TQualified (must (lident_of_typestring tag))
 
   | MLTY_Named ([tag; _; _; _], p) when
-    BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.struct_t0"
-    || BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.union_t0"
+    BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.Struct.struct_t0"
+    || BU.starts_with (Syntax.string_of_mlpath p) "Steel.ST.C.Types.Union.union_t0"
     ->
       TQualified (must (lident_of_typestring tag))
 
@@ -108,19 +108,19 @@ let _ = register_translate_type_without_decay begin fun env t ->
       TBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg; _], p) when
-    Syntax.string_of_mlpath p = "Steel.ST.C.Types.ptr"
-    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.array_ref"
+    Syntax.string_of_mlpath p = "Steel.ST.C.Types.Base.ptr"
+    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ref"
     ->
       TBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg], p) when
-    Syntax.string_of_mlpath p = "Steel.ST.C.Types.scalar_t"
+    Syntax.string_of_mlpath p = "Steel.ST.C.Types.Scalar.scalar_t"
     ->
       translate_type_without_decay env arg
 
   | MLTY_Named ([t; n; s], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
-     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.base_array_t"
+     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.base_array_t"
     ->
       TArray (
         translate_type_without_decay env t,
@@ -138,7 +138,7 @@ let _ = register_translate_type begin fun env t ->
   match t with
   | MLTY_Named ([t; _; _], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
-     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.base_array_t"
+     || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.base_array_t"
     ->
       TBuf (translate_type_without_decay env t)
       
@@ -154,7 +154,7 @@ let _ = register_translate_expr begin fun env e ->
   match e.expr with
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
     when (
-          string_of_mlpath p = "Steel.ST.C.Types.alloc" ||
+          string_of_mlpath p = "Steel.ST.C.Types.Base.alloc" ||
           false) ->
       EBufCreateNoInit (ManuallyManaged, EConstant (UInt32, "1"))
 
@@ -182,7 +182,7 @@ let _ = register_translate_expr begin fun env e ->
       EBufFree (translate_expr env e2)
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *); _ (* v *); e ]) when
-       string_of_mlpath p = "Steel.ST.C.Types.free" ->
+       string_of_mlpath p = "Steel.ST.C.Types.Base.free" ->
       EBufFree (translate_expr env e)
 
 (* BEGIN support for the Steel null pointer. *)
@@ -196,7 +196,7 @@ let _ = register_translate_expr begin fun env e ->
     -> generate_is_null (translate_type env t) (translate_expr env e)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); _ (* td *); _ (* v *); e])
-    when string_of_mlpath p = "Steel.ST.C.Types.is_null"
+    when string_of_mlpath p = "Steel.ST.C.Types.Base.is_null"
     -> generate_is_null (translate_type env t) (translate_expr env e)
   
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, _)
@@ -205,7 +205,7 @@ let _ = register_translate_expr begin fun env e ->
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
     when string_of_mlpath p = "Steel.C.Reference.null"
-    || string_of_mlpath p = "Steel.ST.C.Types.null"
+    || string_of_mlpath p = "Steel.ST.C.Types.Base.null"
     -> EBufNull (translate_type env t)
 
 (* END support for the Steel null pointer *)
@@ -237,9 +237,9 @@ let _ = register_translate_expr begin fun env e ->
                ; ({expr=MLE_Const (MLC_String field_name)})
                ; _ (* td' *)
              ])
-    when string_of_mlpath p = "Steel.ST.C.Types.struct_field0"
-    || string_of_mlpath p = "Steel.ST.C.Types.union_field0"
-    || string_of_mlpath p = "Steel.ST.C.Types.union_switch_field0"
+    when string_of_mlpath p = "Steel.ST.C.Types.Struct.struct_field0"
+    || string_of_mlpath p = "Steel.ST.C.Types.Union.union_field0"
+    || string_of_mlpath p = "Steel.ST.C.Types.Union.union_switch_field0"
     ->
       EAddrOf (EField (
         TQualified (must (lident_of_string struct_name)),
@@ -275,11 +275,11 @@ let _ = register_translate_expr begin fun env e ->
         translate_expr env x)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *) ; _ (* perm *) ; r])
-    when string_of_mlpath p = "Steel.ST.C.Types.read0" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.Scalar.read0" ->
       EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_ (* value *); r; x])
-    when string_of_mlpath p = "Steel.ST.C.Types.write" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.Scalar.write" ->
       EAssign (
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
         translate_expr env x)
@@ -291,7 +291,7 @@ let _ = register_translate_expr begin fun env e ->
       _ (* v *);
       r
     ])
-    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_of_base" ->
+    when string_of_mlpath p = "Steel.ST.C.Types.Array.array_ref_of_base" ->
       // this is not a true read, this is how Karamel models arrays decaying into pointers
       EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref"))
 
@@ -302,8 +302,8 @@ let _ = register_translate_expr begin fun env e ->
       _ (* len *);
       i
     ])
-    when string_of_mlpath p = "Steel.ST.C.Types.array_ref_cell"
-    || string_of_mlpath p = "Steel.ST.C.Types.array_ref_split"
+    when string_of_mlpath p = "Steel.ST.C.Types.Array.array_ref_cell"
+    || string_of_mlpath p = "Steel.ST.C.Types.Array.array_ref_split"
     ->
       EBufSub (translate_expr env a, translate_expr env i)
 
@@ -339,12 +339,12 @@ let parse_steel_c_fields env (fields: mlty): option (list _) =
         match fields with
         | MLTY_Named ([], p)
           when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_nil"
-          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_nil"
+          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Fields.field_t_nil"
           -> Some []
           
         | MLTY_Named ([field; t; fields], p)
           when Syntax.string_of_mlpath p = "Steel.C.Fields.c_fields_t_cons"
-          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.field_t_cons"
+          || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Fields.field_t_cons"
           ->
           opt_bind (string_of_typestring field) (fun field ->
           if field = "" then go fields else
@@ -414,12 +414,12 @@ let _ = register_translate_type_decl begin fun env ty ->
       define_struct env tag fields
 
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
-      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_struct0"
+      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.Struct.define_struct0"
       ->
       define_struct env tag fields
 
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields; _; _], p)))}
-      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.define_union0"
+      when Syntax.string_of_mlpath p = "Steel.ST.C.Types.Union.define_union0"
       ->
       define_union env tag fields
 

From 2010ec0346132be94adf4437d84cb18721029c81 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 16:14:40 -0700
Subject: [PATCH 451/513] explicit registration needed?

---
 .../steel/arraystructs/my_fstar/ExtractSteelC.fst | 15 +++++++++++----
 .../arraystructs/my_fstar/ExtractSteelC.fsti      |  1 +
 examples/steel/arraystructs/my_fstar/main.ml      |  1 +
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index e7acfa1850d..f064fb8e98b 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -83,7 +83,8 @@ let int_of_typenat (t: mlty): option int =
   in
   go t
 
-let _ = register_translate_type_without_decay begin fun env t ->
+let my_types_without_decay () = 
+  register_translate_type_without_decay begin fun env t ->
   match t with
   
   | MLTY_Named ([tag; _; _], p) when
@@ -134,7 +135,7 @@ let _ = register_translate_type_without_decay begin fun env t ->
   | _ -> raise NotSupportedByKrmlExtension
 end
 
-let _ = register_translate_type begin fun env t ->
+let my_types () = register_translate_type begin fun env t ->
   match t with
   | MLTY_Named ([t; _; _], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
@@ -150,7 +151,7 @@ let _ = register_translate_type begin fun env t ->
   | _ -> raise NotSupportedByKrmlExtension
 end
 
-let _ = register_translate_expr begin fun env e ->
+let my_exprs () = register_translate_expr begin fun env e ->
   match e.expr with
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
     when (
@@ -406,7 +407,7 @@ let define_union
     let fields = must (parse_steel_c_fields env fields) in
     Some (DUntaggedUnion (p, [], 0, fields))
 
-let _ = register_translate_type_decl begin fun env ty ->
+let my_type_decls () = register_translate_type_decl begin fun env ty ->
     match ty with
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
       when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
@@ -441,3 +442,9 @@ let _ = register_translate_type_decl begin fun env ty ->
       end
     | _ -> raise NotSupportedByKrmlExtension
 end
+
+let register () =
+  my_types_without_decay ();
+  my_types ();
+  my_exprs ();
+  my_type_decls ()
diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
index 75e86a536d4..d0fc494727c 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
@@ -1,2 +1,3 @@
 module ExtractSteelC
 
+val register: unit -> FStar.Compiler.Effect.ML unit
diff --git a/examples/steel/arraystructs/my_fstar/main.ml b/examples/steel/arraystructs/my_fstar/main.ml
index f86e3acc6bf..53598d57c2d 100644
--- a/examples/steel/arraystructs/my_fstar/main.ml
+++ b/examples/steel/arraystructs/my_fstar/main.ml
@@ -1,4 +1,5 @@
 let x =
+      ExtractSteelC.register ();
       Printexc.record_backtrace true;
       Gc.set { (Gc.get()) with Gc.minor_heap_size = 1048576; Gc.major_heap_increment = 4194304; Gc.space_overhead = 150; };
       FStar_Main.main ()

From 95839549a6bd2d6cbb58fcb6229b95c896bfd5db Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 16:18:30 -0700
Subject: [PATCH 452/513] my fstar.exe depends on main.ml

---
 examples/steel/arraystructs/my_fstar/Makefile | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/Makefile b/examples/steel/arraystructs/my_fstar/Makefile
index fa0c08f53fc..51d8fef684c 100644
--- a/examples/steel/arraystructs/my_fstar/Makefile
+++ b/examples/steel/arraystructs/my_fstar/Makefile
@@ -13,16 +13,17 @@ include $(FSTAR_HOME)/src/Makefile.boot.common
 OUTPUT_DIRECTORY = $(CURDIR)
 FSTAR_C=$(RUNLIM) $(FSTAR_EXE) $(SIL) $(FSTAR_BOOT_OPTIONS) --already_cached 'FStar'
 
-extract: ExtractSteelC.ml
+EXTRACT_FILES=ExtractSteelC.ml
+extract: $(EXTRACT_FILES)
 
 # And then, in a separate invocation, from each .checked.lax we
 # extract an .ml file
-%.ml: %.fst
+$(EXTRACT_FILES): %.ml: %.fst
 	$(call msg, "EXTRACT", $(notdir $@))
 	$(Q)$(BENCHMARK_PRE) $(FSTAR_C) $< \
 		   --odir "$(OUTPUT_DIRECTORY)" \
                    --codegen OCaml \
                    --extract_module $(basename $(notdir $<))
 
-$(CURDIR)/bin/fstar.exe: ExtractSteelC.fst ExtractSteelC.fsti Makefile
+$(CURDIR)/bin/fstar.exe: ExtractSteelC.fst ExtractSteelC.fsti Makefile main.ml
 	OCAMLPATH=$(FSTAR_HOME)/lib dune build && dune install --prefix=$(CURDIR)

From d4c3417154a2b9b8a38ca831e7e03c94e32afd70 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 14 Mar 2023 16:36:23 -0700
Subject: [PATCH 453/513] what if Karamel is not installed?

---
 examples/steel/arraystructs/Makefile         | 23 +++++++++++++-------
 examples/steel/arraystructs/PointStruct2.fst |  2 +-
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 023fdc2c9d8..84c5ea741d5 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -2,14 +2,19 @@ all: world
 
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
 export FSTAR_HOME
+ifdef KRML_HOME # FIXME: should be HAS_OCAML
 FSTAR_EXE = $(CURDIR)/my_fstar/bin/fstar.exe
+else # no KRML_HOME
+FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
+endif
 FSTAR_LIB ?= $(realpath $(FSTAR_HOME)/ulib)
 export FSTAR_LIB
 
-INCLUDE_PATH = $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj
+INCLUDE_PATH := $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental
 
 ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
+INCLUDE_PATH += $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj
 endif
 
 world: verify test
@@ -27,14 +32,19 @@ ALL_SOURCE_FILES = $(filter-out LList.fst,$(wildcard *.fst *.fsti))
 NO_EXTRACT_MODULES=PointStruct HaclExample ScalarUnion
 EXTRACT_SOURCE_FILES = $(filter-out $(addsuffix .fst,$(NO_EXTRACT_MODULES)),$(ALL_SOURCE_FILES))
 
+comma=,
+
+ifdef KRML_HOME # FIXME: should be HAS_OCAML
 # We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
 # since the KaRaMeL AST does not have a node for null
 # TODO: This should be removed, and support for Steel.C null should be directly added to KaRaMeL instead
-SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst
-
-comma=,
+SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst $(KRML_HOME)/krmllib/C.fst
+MY_FSTAR=$(FSTAR_EXE)
+$(FSTAR_EXE):
+	+$(MAKE) -C my_fstar
+endif
 
-.depend: $(ALL_SOURCE_FILES) Makefile $(FSTAR_EXE)
+.depend: $(ALL_SOURCE_FILES) Makefile $(MY_FSTAR)
 	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:* -FStar $(addprefix -,$(NO_EXTRACT_MODULES))'  > $@.tmp
 	mv $@.tmp $@
 
@@ -42,9 +52,6 @@ depend: .depend
 
 -include .depend
 
-$(FSTAR_EXE):
-	+$(MAKE) -C my_fstar
-
 $(ALL_CHECKED_FILES): %.checked:
 	$(FSTAR) $<
 	@touch -c $@
diff --git a/examples/steel/arraystructs/PointStruct2.fst b/examples/steel/arraystructs/PointStruct2.fst
index 12357ea2b6c..d47110023e2 100644
--- a/examples/steel/arraystructs/PointStruct2.fst
+++ b/examples/steel/arraystructs/PointStruct2.fst
@@ -3,7 +3,7 @@ open Steel.ST.Util
 open Steel.ST.C.Types
 
 module U32 = FStar.UInt32
-module C = C // for _zero_for_deref
+// module C = C // for _zero_for_deref
 
 let swap (#v1 #v2: Ghost.erased U32.t) (r1 r2: ref (scalar U32.t)) : STT unit
   ((r1 `pts_to` mk_scalar (Ghost.reveal v1)) `star` (r2 `pts_to` mk_scalar (Ghost.reveal v2)))

From 551125b2d41b2847a14cd6ce05996a2155f97856 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 08:44:38 -0700
Subject: [PATCH 454/513] Revert "snap"

This reverts commit 5a0dff93fe693c1fa788af99842b0b6794d84d14.
---
 .../generated/FStar_Extraction_Krml.ml        | 397 ++++++------------
 1 file changed, 130 insertions(+), 267 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 68500935892..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,102 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -967,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -999,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1037,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1111,14 +996,13 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1131,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1166,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2637,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3066,121 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 = translate_type env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3520,9 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (uu___1931 : unit) =
-  register_translate_type_without_decay translate_type_without_decay';
-  register_translate_type translate_type';
-  register_translate_type_decl translate_type_decl';
-  register_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file

From d04cad0de03187dc5ea22a5179c87bf1dfa160a3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 08:55:43 -0700
Subject: [PATCH 455/513] avoid `let _ =` in FStar.Extraction.Krml

---
 .../arraystructs/my_fstar/ExtractSteelC.fst   | 12 ++--
 .../arraystructs/my_fstar/ExtractSteelC.fsti  |  2 +-
 examples/steel/arraystructs/my_fstar/main.ml  |  3 +-
 src/extraction/FStar.Extraction.Krml.fst      | 62 +++++++++++++++----
 src/extraction/FStar.Extraction.Krml.fsti     |  3 +
 src/fstar/FStar.Main.fst                      |  1 +
 6 files changed, 63 insertions(+), 20 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index f064fb8e98b..74d4a0d97ad 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -84,7 +84,7 @@ let int_of_typenat (t: mlty): option int =
   go t
 
 let my_types_without_decay () = 
-  register_translate_type_without_decay begin fun env t ->
+  register_pre_translate_type_without_decay begin fun env t ->
   match t with
   
   | MLTY_Named ([tag; _; _], p) when
@@ -135,7 +135,7 @@ let my_types_without_decay () =
   | _ -> raise NotSupportedByKrmlExtension
 end
 
-let my_types () = register_translate_type begin fun env t ->
+let my_types () = register_pre_translate_type begin fun env t ->
   match t with
   | MLTY_Named ([t; _; _], p)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.array_view_type_sized"
@@ -151,7 +151,7 @@ let my_types () = register_translate_type begin fun env t ->
   | _ -> raise NotSupportedByKrmlExtension
 end
 
-let my_exprs () = register_translate_expr begin fun env e ->
+let my_exprs () = register_pre_translate_expr begin fun env e ->
   match e.expr with
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *) ])
     when (
@@ -407,7 +407,7 @@ let define_union
     let fields = must (parse_steel_c_fields env fields) in
     Some (DUntaggedUnion (p, [], 0, fields))
 
-let my_type_decls () = register_translate_type_decl begin fun env ty ->
+let my_type_decls () = register_pre_translate_type_decl begin fun env ty ->
     match ty with
     | {tydecl_defn=Some (MLTD_Abbrev (MLTY_Named ([tag; fields], p)))}
       when Syntax.string_of_mlpath p = "Steel.C.StructLiteral.mk_struct_def"
@@ -448,3 +448,7 @@ let register () =
   my_types ();
   my_exprs ();
   my_type_decls ()
+
+let main () =
+  register ();
+  FStar.Main.main ()
diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
index d0fc494727c..be7526e3523 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
@@ -1,3 +1,3 @@
 module ExtractSteelC
 
-val register: unit -> FStar.Compiler.Effect.ML unit
+val main: unit -> FStar.Compiler.Effect.ML unit
diff --git a/examples/steel/arraystructs/my_fstar/main.ml b/examples/steel/arraystructs/my_fstar/main.ml
index 53598d57c2d..fc95fadebc7 100644
--- a/examples/steel/arraystructs/my_fstar/main.ml
+++ b/examples/steel/arraystructs/my_fstar/main.ml
@@ -1,5 +1,4 @@
 let x =
-      ExtractSteelC.register ();
       Printexc.record_backtrace true;
       Gc.set { (Gc.get()) with Gc.minor_heap_size = 1048576; Gc.major_heap_increment = 4194304; Gc.space_overhead = 150; };
-      FStar_Main.main ()
+      ExtractSteelC.main ()
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 4f31eaf6c5f..a7bf0769ba5 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -380,7 +380,7 @@ exception NotSupportedByKrmlExtension
 
 let translate_type_without_decay_t = env -> mlty -> ML typ
 let ref_translate_type_without_decay : ref translate_type_without_decay_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
-let register_translate_type_without_decay
+let register_pre_translate_type_without_decay
   (f: translate_type_without_decay_t)
 : ML unit
 = let before : translate_type_without_decay_t = !ref_translate_type_without_decay in
@@ -390,13 +390,22 @@ let register_translate_type_without_decay
     with NotSupportedByKrmlExtension -> before e t
   in
   ref_translate_type_without_decay := after
-
+let register_post_translate_type_without_decay
+  (f: translate_type_without_decay_t)
+: ML unit
+= let before : translate_type_without_decay_t = !ref_translate_type_without_decay in
+  let after : translate_type_without_decay_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_type_without_decay := after
 let translate_type_without_decay env t = !ref_translate_type_without_decay env t
 
 // The outermost array type constructor decays to pointer
 let translate_type_t = env -> mlty -> ML typ
 let ref_translate_type : ref translate_type_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
-let register_translate_type
+let register_pre_translate_type
   (f: translate_type_t)
 : ML unit
 = let before : translate_type_t = !ref_translate_type in
@@ -406,12 +415,21 @@ let register_translate_type
     with NotSupportedByKrmlExtension -> before e t
   in
   ref_translate_type := after
-
+let register_post_translate_type
+  (f: translate_type_t)
+: ML unit
+= let before : translate_type_t = !ref_translate_type in
+  let after : translate_type_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_type := after
 let translate_type env t = !ref_translate_type env t
 
 let translate_expr_t = env -> mlexpr -> ML expr
 let ref_translate_expr : ref translate_expr_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
-let register_translate_expr
+let register_pre_translate_expr
   (f: translate_expr_t)
 : ML unit
 = let before : translate_expr_t = !ref_translate_expr in
@@ -421,12 +439,21 @@ let register_translate_expr
     with NotSupportedByKrmlExtension -> before e t
   in
   ref_translate_expr := after
-
+let register_post_translate_expr
+  (f: translate_expr_t)
+: ML unit
+= let before : translate_expr_t = !ref_translate_expr in
+  let after : translate_expr_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_expr := after
 let translate_expr (env: env) (e: mlexpr) = !ref_translate_expr env e
 
 let translate_type_decl_t = env -> one_mltydecl -> ML (option decl)
 let ref_translate_type_decl : ref translate_type_decl_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
-let register_translate_type_decl
+let register_pre_translate_type_decl
   (f: translate_type_decl_t)
 : ML unit
 = let before : translate_type_decl_t = !ref_translate_type_decl in
@@ -436,7 +463,16 @@ let register_translate_type_decl
     with NotSupportedByKrmlExtension -> before e t
   in
   ref_translate_type_decl := after
-
+let register_post_translate_type_decl
+  (f: translate_type_decl_t)
+: ML unit
+= let before : translate_type_decl_t = !ref_translate_type_decl in
+  let after : translate_type_decl_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_type_decl := after
 let translate_type_decl env ty: option decl =
   if List.mem Syntax.NoExtract ty.tydecl_meta then
     None
@@ -1380,8 +1416,8 @@ let translate (MLLib modules): list file =
         None
   ) modules
 
-let _ =
-  register_translate_type_without_decay translate_type_without_decay';
-  register_translate_type translate_type';
-  register_translate_type_decl translate_type_decl';
-  register_translate_expr translate_expr'
+let init () =
+  register_post_translate_type_without_decay translate_type_without_decay';
+  register_post_translate_type translate_type';
+  register_post_translate_type_decl translate_type_decl';
+  register_post_translate_expr translate_expr'
diff --git a/src/extraction/FStar.Extraction.Krml.fsti b/src/extraction/FStar.Extraction.Krml.fsti
index 0241772fcd4..7b22d5b7d4d 100644
--- a/src/extraction/FStar.Extraction.Krml.fsti
+++ b/src/extraction/FStar.Extraction.Krml.fsti
@@ -26,3 +26,6 @@ type binary_format = version * list file
 
 val current_version: version
 val translate : FStar.Extraction.ML.Syntax.mllib -> list file
+
+(* Called by FStar.Main.main () to initialize code translators *)
+val init : unit -> FStar.Compiler.Effect.ML unit
diff --git a/src/fstar/FStar.Main.fst b/src/fstar/FStar.Main.fst
index 79bc492b625..3d21a45981d 100644
--- a/src/fstar/FStar.Main.fst
+++ b/src/fstar/FStar.Main.fst
@@ -219,6 +219,7 @@ let setup_hooks () =
     FStar.Syntax.Syntax.lazy_chooser := Some lazy_chooser;
     FStar.Syntax.Util.tts_f := Some FStar.Syntax.Print.term_to_string;
     FStar.TypeChecker.Normalize.unembed_binder_knot := Some FStar.Reflection.Embeddings.e_binder;
+    FStar.Extraction.Krml.init ();
     ()
 
 let handle_error e =

From bf9a3eb3990c781245a15ce3b24e170ef7111421 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 08:56:13 -0700
Subject: [PATCH 456/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 429 ++++++++++++------
 ocaml/fstar-lib/generated/FStar_Main.ml       |   3 +-
 2 files changed, 301 insertions(+), 131 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..9aa9e37c95f 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,13 +1142,14 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1015,19 +1162,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1197,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2668,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3097,121 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 = translate_type env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3551,10 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (init : unit -> unit) =
+  fun uu___ ->
+    register_post_translate_type_without_decay translate_type_without_decay';
+    register_post_translate_type translate_type';
+    register_post_translate_type_decl translate_type_decl';
+    register_post_translate_expr translate_expr'
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index 8ad6b788389..d763e38153f 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,7 +294,8 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
+    FStar_Extraction_Krml.init ()
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in

From 43527289139ec74dde5e77407f7cccdc1a47f10d Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 13:29:43 -0700
Subject: [PATCH 457/513] arrays can be null

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  | 22 +++++++++++++++----
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 20 ++++++++++++-----
 2 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index db8e4929f36..bbaca5e9123 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -235,13 +235,25 @@ let has_base_array_cell_equiv_to
 /// Array pointers (with decay)
 
 noeq
-type array_ref #t td = {
+type array_ptr #t td = {
+  ar_is_null: Ghost.erased bool;
   ar_base_size: Ghost.erased array_size_t;
-  ar_base: ref (base_array1 #t td ar_base_size);
+  ar_base: ptr (base_array1 #t td ar_base_size);
   ar_offset: SZ.t;
-  ar_prf: squash (SZ.v ar_offset <= SZ.v ar_base_size);
+  ar_prf: squash (
+    SZ.v ar_offset <= SZ.v ar_base_size /\
+    (Ghost.reveal ar_is_null == true <==> ar_base == null _) /\
+    (ar_base == null _ ==> (SZ.v ar_base_size == 1 /\ SZ.v ar_offset == 0))
+  );
+}
+let null_array_ptr td = {
+  ar_is_null = true;
+  ar_base_size = 1sz;
+  ar_base = null _;
+  ar_offset = 0sz;
+  ar_prf = ();
 }
-let array_ref_base_size ar = ar.ar_base_size
+let array_ref_base_size ar = if ar.ar_is_null then 0sz else ar.ar_base_size
 let has_array_ref_base ar r = ar.ar_base == r
 let has_array_ref_base_inj ar r1 r2 = ()
 let array_ref_offset ar = ar.ar_offset
@@ -323,6 +335,7 @@ let ghost_array_of_base
   #_ #tn #_ #n #td #v r
 =
   let al : array_ref td = {
+    ar_is_null = false;
     ar_base_size = n;
     ar_base = r;
     ar_offset = 0sz;
@@ -349,6 +362,7 @@ let array_of_base0
     (fun _ -> True)
 =
   let al : array_ref td = {
+    ar_is_null = false;
     ar_base_size = n;
     ar_base = r;
     ar_offset = 0sz;
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index 248bf5bd22e..e3a8865a159 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -167,16 +167,23 @@ val has_base_array_cell_equiv_to
 // ghost length of an array.
 
 [@@noextract_to "krml"] // primitive
-val array_ref (#t: Type) (td: typedef t) : Tot Type0
+val array_ptr (#t: Type) (td: typedef t) : Tot Type0
+[@@noextract_to "krml"] // primitive
+val null_array_ptr (#t: Type) (td: typedef t) : GTot (array_ptr td)
+inline_for_extraction [@@noextract_to "krml"]
+let array_ref (#t: Type) (td: typedef t) = (a: array_ptr td { ~ (a == null_array_ptr td) })
+
 (*
 val array_ref_base_size_type (#t: Type) (#td: typedef t) (a: array_ref td) : GTot Type0
 *)
-val array_ref_base_size (#t: Type) (#td: typedef t) (a: array_ref td) : GTot array_size_t
+val array_ref_base_size (#t: Type) (#td: typedef t) (a: array_ptr td) : Ghost SZ.t
+  (requires True)
+  (ensures (fun y -> SZ.v y == 0 <==> a == null_array_ptr _))
 val has_array_ref_base (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r: ref (base_array0 ty td (array_ref_base_size a))) : GTot prop
 val has_array_ref_base_inj (#t: Type) (#td: typedef t) (a: array_ref td) (#ty: Type) (r1 r2: ref (base_array0 ty td (array_ref_base_size a))) : Lemma
   (requires (has_array_ref_base a r1 /\ has_array_ref_base a r2))
   (ensures (r1 == r2))
-val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ref td) : Ghost SZ.t
+val array_ref_offset (#t: Type) (#td: typedef t) (a: array_ptr td) : Ghost SZ.t
   (requires True)
   (ensures (fun y -> SZ.v y <= SZ.v (array_ref_base_size a)))
 val array_ref_base_offset_inj (#t: Type) (#td: typedef t) (#ty: Type) (a1: array_ref td) (r1: ref (base_array0 ty td (array_ref_base_size a1))) (a2: array_ref td) (r2: ref (base_array0 ty td (array_ref_base_size a2))) : Lemma
@@ -190,11 +197,14 @@ val array_ref_base_offset_inj (#t: Type) (#td: typedef t) (#ty: Type) (a1: array
   (ensures (a1 == a2))
 
 inline_for_extraction [@@noextract_to "krml"]
-let array_len_t (#t: Type) (#td: typedef t) (r: array_ref td) : Tot Type0 =
+let array_len_t (#t: Type) (#td: typedef t) (r: array_ptr td) : Tot Type0 =
   (len: Ghost.erased SZ.t { SZ.v (array_ref_offset r) + SZ.v len <= SZ.v (array_ref_base_size r) })
 
 inline_for_extraction [@@noextract_to "krml"]
-let array (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ref td & array_len_t r)
+let array_or_null (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ptr td & array_len_t r)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array (#t: Type) (td: typedef t) : Tot Type0 = (a: array_or_null td { ~ (dfst a == null_array_ptr _) })
 
 let array_length
   (#t: Type)

From 9a56e344c2d0e9bd7d711b53b2c0d129f5229777 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 14:36:11 -0700
Subject: [PATCH 458/513] array_is_null

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  |  5 +++
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 33 +++++++++++++++++--
 2 files changed, 36 insertions(+), 2 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index bbaca5e9123..ff192f09094 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -253,6 +253,7 @@ let null_array_ptr td = {
   ar_offset = 0sz;
   ar_prf = ();
 }
+let g_array_ptr_is_null a = a.ar_is_null 
 let array_ref_base_size ar = if ar.ar_is_null then 0sz else ar.ar_base_size
 let has_array_ref_base ar r = ar.ar_base == r
 let has_array_ref_base_inj ar r1 r2 = ()
@@ -305,6 +306,10 @@ let array_pts_to0
 let array_pts_to r v =
   array_pts_to0 r v
 
+let array_is_null
+  r
+= return (HR.is_null (dfst r).ar_base)
+
 let array_pts_to_length r v =
   rewrite (array_pts_to r v) (array_pts_to0 r v);
   let _ = gen_elim () in
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index e3a8865a159..21d31bcedb2 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -170,8 +170,11 @@ val has_base_array_cell_equiv_to
 val array_ptr (#t: Type) (td: typedef t) : Tot Type0
 [@@noextract_to "krml"] // primitive
 val null_array_ptr (#t: Type) (td: typedef t) : GTot (array_ptr td)
+val g_array_ptr_is_null (#t: Type) (#td: typedef t) (a: array_ptr td) : Ghost bool
+  (requires True)
+  (ensures (fun y -> y == true <==> a == null_array_ptr _))
 inline_for_extraction [@@noextract_to "krml"]
-let array_ref (#t: Type) (td: typedef t) = (a: array_ptr td { ~ (a == null_array_ptr td) })
+let array_ref (#t: Type) (td: typedef t) = (a: array_ptr td { g_array_ptr_is_null a == false })
 
 (*
 val array_ref_base_size_type (#t: Type) (#td: typedef t) (a: array_ref td) : GTot Type0
@@ -203,8 +206,11 @@ let array_len_t (#t: Type) (#td: typedef t) (r: array_ptr td) : Tot Type0 =
 inline_for_extraction [@@noextract_to "krml"]
 let array_or_null (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ptr td & array_len_t r)
 
+let g_array_is_null (#t: Type) (#td: typedef t) (a: array_or_null td) : GTot bool =
+  g_array_ptr_is_null (dfst a)
+
 inline_for_extraction [@@noextract_to "krml"]
-let array (#t: Type) (td: typedef t) : Tot Type0 = (a: array_or_null td { ~ (dfst a == null_array_ptr _) })
+let array (#t: Type) (td: typedef t) : Tot Type0 = (a: array_or_null td { g_array_is_null a == false })
 
 let array_length
   (#t: Type)
@@ -220,6 +226,29 @@ val array_pts_to
   (v: Ghost.erased (Seq.seq t))
 : Tot vprop
 
+let array_pts_to_or_null
+  (#t: Type)
+  (#td: typedef t)
+  (r: array_or_null td)
+  (v: Ghost.erased (Seq.seq t))
+: Tot vprop
+= if g_array_is_null r
+  then emp
+  else array_pts_to r v
+
+inline_for_extraction [@@noextract_to "krml"]
+val array_is_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased (Seq.seq t))
+  (r: array_or_null td)
+: STAtomicBase bool false opened Unobservable
+    (array_pts_to_or_null r v)
+    (fun _ -> array_pts_to_or_null r v)
+    (True)
+    (fun b -> b == g_array_is_null r)
+
 val array_pts_to_length
   (#opened: _)
   (#t: Type)

From 9e3c61804fad63f259d98dc30a2b88c0ac3c7e33 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 15:45:36 -0700
Subject: [PATCH 459/513] array_alloc

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  | 122 ++++++++++++------
 ulib/experimental/Steel.ST.C.Types.Array.fsti |  40 +++++-
 2 files changed, 119 insertions(+), 43 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index ff192f09094..a823498e69b 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -316,23 +316,69 @@ let array_pts_to_length r v =
   let _ = A.pts_to_length _ _ in
   rewrite (array_pts_to0 r v) (array_pts_to r v)
 
+let has_array_of_base'
+  (#t: Type)
+  (#n: array_size_t)
+  (#td: typedef t)
+  (r: ref (base_array1 td n))
+  (a: array td)
+: GTot prop
+=   let (| al, len |) = a in
+    array_ref_base_size al == n /\
+    al.ar_base == r /\
+    array_ref_offset al == 0sz /\
+    Ghost.reveal len == n
+
+#push-options "--z3rlimit 16 --split_queries"
+
+#restart-solver
+
+let base_array_index' (#t: Type0) (#n: array_size_t) (a: base_array_t' t n)
+(i: base_array_index_t n) : GTot t
+= a i
+
+let seq_of_base_array0
+  (#t: Type)
+  (#n: array_size_t)
+  (v: base_array_t' t n)
+: GTot (Seq.lseq t (SZ.v n))
+= Seq.init_ghost (SZ.v n) (fun i -> base_array_index' v (SZ.uint_to_t i))
+
+#pop-options
+
+
 #push-options "--z3rlimit 16"
 #restart-solver
 
-let ghost_array_of_base_focus
-  #_ #_ #_ #_ #td #v r a
+let ghost_array_of_base_focus'
+  (#t: Type)
+  (#opened: _)
+  (#n: Ghost.erased array_size_t)
+  (#td: typedef t)
+  (#v: Ghost.erased (base_array_t' t n))
+  (r: ref (base_array1 td n))
+  (a: array td)
+: STGhost unit opened
+    (pts_to r v)
+    (fun _ -> array_pts_to a (seq_of_base_array0 v))
+    (has_array_of_base' r a)
+    (fun _ -> True)
 = rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
   let w' : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () w in
   assert ((model_array_of_array a w').base == w.ref);
   rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
-  assert (seq_of_base_array v `Seq.equal` A.seq_of_array_pcm_carrier v);
+  assert (seq_of_base_array0 v `Seq.equal` A.seq_of_array_pcm_carrier v);
   A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
-  A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array v);
+  A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array0 v);
   let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
   rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
-  rewrite (array_pts_to0 a (seq_of_base_array v)) (array_pts_to a (seq_of_base_array v))
+  rewrite (array_pts_to0 a (seq_of_base_array0 v)) (array_pts_to a (seq_of_base_array0 v))
+
+let ghost_array_of_base_focus
+  #_ #_ #_ #_ #td #v r a
+= ghost_array_of_base_focus' r a
 
 #pop-options
 
@@ -354,15 +400,14 @@ let ghost_array_of_base
 [@@noextract_to "krml"] // primitive
 let array_of_base0
   (#t: Type)
-  (#tn: Type0)
   (#opened: _)
   (#n: Ghost.erased array_size_t)
   (#td: typedef t)
-  (#v: Ghost.erased (base_array_t t tn n))
-  (r: ref (base_array0 tn td n))
-: STAtomicBase (a: array td { has_array_of_base r a }) false opened Unobservable
+  (#v: Ghost.erased (base_array_t' t n))
+  (r: ref (base_array1 td n))
+: STAtomicBase (a: array td { has_array_of_base' r a }) false opened Unobservable
     (pts_to r v)
-    (fun a -> array_pts_to a (seq_of_base_array v))
+    (fun a -> array_pts_to a (seq_of_base_array0 v))
     (True)
     (fun _ -> True)
 =
@@ -374,8 +419,8 @@ let array_of_base0
     ar_prf = ();
   }
   in
-  let a : (a: array td { has_array_of_base r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
-  ghost_array_of_base_focus r a;
+  let a : (a: array td { has_array_of_base' r a }) = (| al, Ghost.hide (Ghost.reveal n) |) in
+  ghost_array_of_base_focus' r a;
   return a
 
 let array_ref_of_base
@@ -385,36 +430,6 @@ let array_ref_of_base
   let a : array_ref td = dfst ar in
   return a
 
-#push-options "--z3rlimit 16 --split_queries"
-
-#restart-solver
-
-let base_array_index' (#t: Type0) (#n: array_size_t) (a: base_array_t' t n)
-(i: base_array_index_t n) : GTot t
-= a i
-
-let seq_of_base_array0
-  (#t: Type)
-  (#n: array_size_t)
-  (v: base_array_t' t n)
-: GTot (Seq.lseq t (SZ.v n))
-= Seq.init_ghost (SZ.v n) (fun i -> base_array_index' v (SZ.uint_to_t i))
-
-let has_array_of_base'
-  (#t: Type)
-  (#n: array_size_t)
-  (#td: typedef t)
-  (r: ref (base_array1 td n))
-  (a: array td)
-: GTot prop
-=   let (| al, len |) = a in
-    array_ref_base_size al == n /\
-    al.ar_base == r /\
-    array_ref_offset al == 0sz /\
-    Ghost.reveal len == n
-
-#pop-options
-
 #push-options "--z3rlimit 64"
 #restart-solver
 
@@ -453,6 +468,29 @@ let unarray_of_base
   #t #tn #_ #n #td #v r a
 = unarray_of_base0 r a
 
+let array_ptr_alloc
+  #t td sz
+= let base = alloc (base_array1 td sz) in
+  if is_null base
+  then begin
+    noop ();
+    let a = null_array_ptr td in
+    let ar : array_or_null td = (| a, Ghost.hide 0sz |) in
+    rewrite (pts_to_or_null _ _) (array_pts_to_or_null ar (seq_of_base_array0 (uninitialized (base_array1 td sz))));
+    drop (freeable_or_null _);
+    return a
+  end else begin
+    noop ();
+    let sq: squash (~ (base == null _)) = () in
+    noop ();
+    rewrite (pts_to_or_null _ _) (pts_to base (uninitialized (base_array1 td sz)));
+    let ar : array td = array_of_base0 base in
+    rewrite (array_pts_to ar _) (array_pts_to_or_null ar (seq_of_base_array0 (uninitialized (base_array1 td sz))));
+    let a = dfst ar in
+    drop (freeable_or_null _);
+    return a
+  end
+
 (*
 let has_array_of_ref
   r a
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index 21d31bcedb2..d3db844b165 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -169,7 +169,7 @@ val has_base_array_cell_equiv_to
 [@@noextract_to "krml"] // primitive
 val array_ptr (#t: Type) (td: typedef t) : Tot Type0
 [@@noextract_to "krml"] // primitive
-val null_array_ptr (#t: Type) (td: typedef t) : GTot (array_ptr td)
+val null_array_ptr (#t: Type) (td: typedef t) : Tot (array_ptr td)
 val g_array_ptr_is_null (#t: Type) (#td: typedef t) (a: array_ptr td) : Ghost bool
   (requires True)
   (ensures (fun y -> y == true <==> a == null_array_ptr _))
@@ -403,6 +403,44 @@ val unarray_of_base
     )
     (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
 
+[@@noextract_to "krml"] // primitive
+val array_ptr_alloc
+  (#t: Type)
+  (td: typedef t)
+  (sz: SZ.t { SZ.v sz > 0 })
+: STT (array_ptr td)
+    emp
+    (fun a ->
+      exists_ (fun (ar: array_or_null td) -> exists_ (fun (s: Seq.seq t) ->
+      array_pts_to_or_null ar s `star` pure (
+      dfst ar == a /\
+      (g_array_is_null ar == false ==> array_length ar == SZ.v sz) /\
+      Ghost.reveal s `Seq.equal` FStar.Seq.create (SZ.v sz) (uninitialized td)
+    ))))
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_alloc
+  (#t: Type)
+  (td: typedef t)
+  (sz: SZ.t { SZ.v sz > 0 })
+: STT (array_or_null td)
+    emp
+    (fun ar ->
+      exists_ (fun s ->
+      array_pts_to_or_null ar s `star` pure (
+      (g_array_is_null ar == false ==> array_length ar == SZ.v sz) /\
+      Ghost.reveal s == FStar.Seq.create (SZ.v sz) (uninitialized td)
+    )))
+= let a : array_ptr td = array_ptr_alloc td sz in
+  let ar' : Ghost.erased (array_or_null td) = elim_exists () in
+  let s = elim_exists () in
+  elim_pure _;
+  let len : array_len_t a = dsnd ar' in
+  let ar = (| a, len |) in
+  rewrite (array_pts_to_or_null _ _) (array_pts_to_or_null ar s);
+  noop ();
+  return ar
+
 (*
 val has_array_of_ref
   (#t: Type)

From fad847a97a3dcdae997ffbae1be372fbb39705cd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 16:37:33 -0700
Subject: [PATCH 460/513] array_free

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  | 45 ++++++++++--
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 70 ++++++++++++++++---
 2 files changed, 100 insertions(+), 15 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index a823498e69b..264276a8855 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -405,11 +405,11 @@ let array_of_base0
   (#td: typedef t)
   (#v: Ghost.erased (base_array_t' t n))
   (r: ref (base_array1 td n))
-: STAtomicBase (a: array td { has_array_of_base' r a }) false opened Unobservable
+: STAtomicBase (array td) false opened Unobservable
     (pts_to r v)
     (fun a -> array_pts_to a (seq_of_base_array0 v))
     (True)
-    (fun _ -> True)
+    (fun a -> has_array_of_base' r a)
 =
   let al : array_ref td = {
     ar_is_null = false;
@@ -468,6 +468,17 @@ let unarray_of_base
   #t #tn #_ #n #td #v r a
 = unarray_of_base0 r a
 
+[@@ __reduce__ ]
+let freeable_array0
+  (#t: Type) (#td: typedef t) (a: array td)
+: Tot vprop
+= freeable (dfst a).ar_base `star`
+  pure (has_array_of_base' (dfst a).ar_base a)
+
+let freeable_array
+  a
+= freeable_array0 a
+
 let array_ptr_alloc
   #t td sz
 = let base = alloc (base_array1 td sz) in
@@ -477,7 +488,7 @@ let array_ptr_alloc
     let a = null_array_ptr td in
     let ar : array_or_null td = (| a, Ghost.hide 0sz |) in
     rewrite (pts_to_or_null _ _) (array_pts_to_or_null ar (seq_of_base_array0 (uninitialized (base_array1 td sz))));
-    drop (freeable_or_null _);
+    rewrite (freeable_or_null _) (freeable_or_null_array ar);
     return a
   end else begin
     noop ();
@@ -487,10 +498,36 @@ let array_ptr_alloc
     let ar : array td = array_of_base0 base in
     rewrite (array_pts_to ar _) (array_pts_to_or_null ar (seq_of_base_array0 (uninitialized (base_array1 td sz))));
     let a = dfst ar in
-    drop (freeable_or_null _);
+    rewrite (freeable_or_null _) (freeable (dfst ar).ar_base);
+    rewrite (freeable_array0 ar) (freeable_or_null_array ar);
     return a
   end
 
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let full_seq_seq_of_base_array'
+  (#t: Type0) (td: typedef t) (#n: array_size_t)
+  (b: base_array_t' t n)
+: Lemma
+  (ensures (full_seq td (seq_of_base_array0 b) <==> full (base_array1 td n) b))
+= assert (forall (i: base_array_index_t n) . base_array_index' b i == Seq.index (seq_of_base_array0 b) (SZ.v i))
+
+let array_ref_free
+  #t #td #s a len
+= rewrite (freeable_array _) (freeable_array0 (| a, len |));
+  elim_pure _;
+  let len0 : Ghost.erased array_size_t = Ghost.hide (Ghost.reveal len) in
+  let r : ref (base_array1 td len0) = a.ar_base in
+  array_pts_to_length _ _;
+  let s' = unarray_of_base0 r (| a, len |) in
+  full_seq_seq_of_base_array' td s';
+  rewrite (pts_to _ _) (pts_to r s');
+  rewrite (freeable _) (freeable r);
+  free r
+
+#pop-options
+
 (*
 let has_array_of_ref
   r a
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index d3db844b165..e71c3980321 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -403,6 +403,21 @@ val unarray_of_base
     )
     (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array v')
 
+val freeable_array
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+: Tot vprop
+
+let freeable_or_null_array
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_or_null td)
+: Tot vprop
+= if g_array_is_null a
+  then emp
+  else freeable_array a
+
 [@@noextract_to "krml"] // primitive
 val array_ptr_alloc
   (#t: Type)
@@ -412,6 +427,7 @@ val array_ptr_alloc
     emp
     (fun a ->
       exists_ (fun (ar: array_or_null td) -> exists_ (fun (s: Seq.seq t) ->
+      freeable_or_null_array ar `star`
       array_pts_to_or_null ar s `star` pure (
       dfst ar == a /\
       (g_array_is_null ar == false ==> array_length ar == SZ.v sz) /\
@@ -426,6 +442,7 @@ let array_alloc
 : STT (array_or_null td)
     emp
     (fun ar ->
+      freeable_or_null_array ar `star`
       exists_ (fun s ->
       array_pts_to_or_null ar s `star` pure (
       (g_array_is_null ar == false ==> array_length ar == SZ.v sz) /\
@@ -438,9 +455,51 @@ let array_alloc
   let len : array_len_t a = dsnd ar' in
   let ar = (| a, len |) in
   rewrite (array_pts_to_or_null _ _) (array_pts_to_or_null ar s);
+  rewrite (freeable_or_null_array _) (freeable_or_null_array ar);
   noop ();
   return ar
 
+let full_seq (#t: Type) (td: typedef t) (v: Seq.seq t) : GTot prop =
+  forall (i: nat { i < Seq.length v }) . {:pattern (Seq.index v i)} full td (Seq.index v i)
+
+let full_seq_seq_of_base_array
+  (#t: Type0) (tn: Type0) (td: typedef t) (#n: array_size_t)
+  (b: base_array_t t tn n)
+: Lemma
+  (ensures (full_seq td (seq_of_base_array b) <==> full (base_array0 tn td n) b))
+  [SMTPat (full_seq td (seq_of_base_array b))]
+= assert (forall (i: base_array_index_t n) . base_array_index b i == Seq.index (seq_of_base_array b) (SZ.v i))
+
+[@@noextract_to "krml"] // primitive
+val array_ref_free
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array_ref td)
+  (n: array_len_t a)
+: ST unit
+    (freeable_array (| a, n |) `star` array_pts_to (| a, n |) s)
+    (fun _ -> emp)
+    (full_seq td s)
+    (fun _ -> True)
+
+inline_for_extraction [@@noextract_to "krml"]
+let array_free
+  (#t: Type)
+  (#td: typedef t)
+  (#s: Ghost.erased (Seq.seq t))
+  (a: array td)
+: ST unit
+    (freeable_array a `star` array_pts_to a s)
+    (fun _ -> emp)
+    (full_seq td s)
+    (fun _ -> True)
+= let al = dfst a in
+  let n: array_len_t al = dsnd a in
+  rewrite (freeable_array _) (freeable_array (| al, n |));
+  rewrite (array_pts_to _ _) (array_pts_to (| al, n |) s);
+  array_ref_free al n
+
 (*
 val has_array_of_ref
   (#t: Type)
@@ -855,14 +914,3 @@ val mk_fraction_seq_join
 : STGhostT unit opened
   (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
   (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
-
-let full_seq (#t: Type) (td: typedef t) (v: Seq.seq t) : GTot prop =
-  forall (i: nat { i < Seq.length v }) . {:pattern (Seq.index v i)} full td (Seq.index v i)
-
-let full_seq_seq_of_base_array
-  (#t: Type0) (tn: Type0) (td: typedef t) (#n: array_size_t)
-  (b: base_array_t t tn n)
-: Lemma
-  (ensures (full_seq td (seq_of_base_array b) <==> full (base_array0 tn td n) b))
-  [SMTPat (full_seq td (seq_of_base_array b))]
-= assert (forall (i: base_array_index_t n) . base_array_index b i == Seq.index (seq_of_base_array b) (SZ.v i))

From 5df6e822ca7e2254da70362237e59f9143fe15ce Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 18:11:00 -0700
Subject: [PATCH 461/513] array_ptr_is_null

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  |  6 ++---
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 22 ++++++++++++++++++-
 2 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index 264276a8855..bfb1be1b85d 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -306,9 +306,9 @@ let array_pts_to0
 let array_pts_to r v =
   array_pts_to0 r v
 
-let array_is_null
-  r
-= return (HR.is_null (dfst r).ar_base)
+let array_ptr_is_null
+  r _
+= return (HR.is_null r.ar_base)
 
 let array_pts_to_length r v =
   rewrite (array_pts_to r v) (array_pts_to0 r v);
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index e71c3980321..961492df571 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -236,8 +236,22 @@ let array_pts_to_or_null
   then emp
   else array_pts_to r v
 
+[@@noextract_to "krml"] // primitive
+val array_ptr_is_null
+  (#t: Type)
+  (#opened: _)
+  (#td: typedef t)
+  (#v: Ghost.erased (Seq.seq t))
+  (r: array_ptr td)
+  (len: array_len_t r)
+: STAtomicBase bool false opened Unobservable
+    (array_pts_to_or_null (| r, len |) v)
+    (fun _ -> array_pts_to_or_null (| r, len |) v)
+    (True)
+    (fun b -> b == g_array_is_null (| r, len |))
+
 inline_for_extraction [@@noextract_to "krml"]
-val array_is_null
+let array_is_null
   (#t: Type)
   (#opened: _)
   (#td: typedef t)
@@ -248,6 +262,12 @@ val array_is_null
     (fun _ -> array_pts_to_or_null r v)
     (True)
     (fun b -> b == g_array_is_null r)
+= let a = dfst r in
+  let len : array_len_t a = dsnd r in
+  rewrite (array_pts_to_or_null _ _) (array_pts_to_or_null (| a, len |) v);
+  let res = array_ptr_is_null a len in
+  rewrite (array_pts_to_or_null _ _) (array_pts_to_or_null r v);
+  return res
 
 val array_pts_to_length
   (#opened: _)

From 2cc789f36e37f8c2fbca9ea5697cba76dd3cf11b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 18:27:14 -0700
Subject: [PATCH 462/513] dfst -> inline_for_extraction array_ptr_of

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  | 124 +++++++++---------
 ulib/experimental/Steel.ST.C.Types.Array.fsti |  37 +++---
 2 files changed, 83 insertions(+), 78 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index bfb1be1b85d..c50a3918030 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -280,7 +280,7 @@ let model_array_of_array
   (#t: Type)
   (#td: typedef t)
   (a: array td)
-  (base: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (base: ref0_v (base_array1 td (array_ptr_of a).ar_base_size))
 : Tot (A.array base.base td.pcm)
 = let (| al, len |) = a in
   {
@@ -299,7 +299,7 @@ let array_pts_to0
   (v: Ghost.erased (Seq.seq t))
 : Tot vprop
 = exists_ (fun br -> exists_ (fun p ->
-    HR.pts_to (dfst r).ar_base p br `star`
+    HR.pts_to (array_ptr_of r).ar_base p br `star`
     A.pts_to (model_array_of_array r br) v
   ))
 
@@ -366,14 +366,14 @@ let ghost_array_of_base_focus'
 = rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  let w' : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () w in
+  let w' : ref0_v (base_array1 td (array_ptr_of a).ar_base_size) = coerce_eq () w in
   assert ((model_array_of_array a w').base == w.ref);
   rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
   assert (seq_of_base_array0 v `Seq.equal` A.seq_of_array_pcm_carrier v);
   A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
   A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array0 v);
   let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base p w');
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of a).ar_base p w');
   rewrite (array_pts_to0 a (seq_of_base_array0 v)) (array_pts_to a (seq_of_base_array0 v))
 
 let ghost_array_of_base_focus
@@ -427,7 +427,7 @@ let array_ref_of_base
   #_ #tn #_ #n #td #v r
 =
   let ar = array_of_base0 r in
-  let a : array_ref td = dfst ar in
+  let a : array_ref td = array_ptr_of ar in
   return a
 
 #push-options "--z3rlimit 64"
@@ -472,8 +472,8 @@ let unarray_of_base
 let freeable_array0
   (#t: Type) (#td: typedef t) (a: array td)
 : Tot vprop
-= freeable (dfst a).ar_base `star`
-  pure (has_array_of_base' (dfst a).ar_base a)
+= freeable (array_ptr_of a).ar_base `star`
+  pure (has_array_of_base' (array_ptr_of a).ar_base a)
 
 let freeable_array
   a
@@ -497,8 +497,8 @@ let array_ptr_alloc
     rewrite (pts_to_or_null _ _) (pts_to base (uninitialized (base_array1 td sz)));
     let ar : array td = array_of_base0 base in
     rewrite (array_pts_to ar _) (array_pts_to_or_null ar (seq_of_base_array0 (uninitialized (base_array1 td sz))));
-    let a = dfst ar in
-    rewrite (freeable_or_null _) (freeable (dfst ar).ar_base);
+    let a = array_ptr_of ar in
+    rewrite (freeable_or_null _) (freeable (array_ptr_of ar).ar_base);
     rewrite (freeable_array0 ar) (freeable_or_null_array ar);
     return a
   end
@@ -531,13 +531,13 @@ let array_ref_free
 (*
 let has_array_of_ref
   r a
-= TD.type_of_token (dfst a).ar_base_size_token == unit /\
+= TD.type_of_token (array_ptr_of a).ar_base_size_token == unit /\
   model_array_of_array a == A.g_array_of_ref (coerce _ (Some?.v r).ref)
 
 let has_array_of_ref_inj
   r a1 a2
-= TD.type_of_token_inj (dfst a1).ar_base_size_token (dfst a2).ar_base_size_token;
-  TD.type_of_token_inj (Some?.v (dfst a1).ar_base).dest (Some?.v (dfst a2).ar_base).dest
+= TD.type_of_token_inj (array_ptr_of a1).ar_base_size_token (array_ptr_of a2).ar_base_size_token;
+  TD.type_of_token_inj (Some?.v (array_ptr_of a1).ar_base).dest (Some?.v (array_ptr_of a2).ar_base).dest
 
 let ghost_array_of_ref_focus
   #t #_ #td #v r a
@@ -607,9 +607,9 @@ let has_array_cell0
   (r: ref td)
 : Tot vprop
 = exists_ (fun (j: SZ.t) ->
-    has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r `star`
+    has_base_array_cell1 (array_ptr_of a).ar_base (array_index_as_base_array_index_marker i j) r `star`
     pure (
-      SZ.v j == SZ.v ((dfst a).ar_offset) + SZ.v i /\
+      SZ.v j == SZ.v ((array_ptr_of a).ar_offset) + SZ.v i /\
       SZ.v i < SZ.v (dsnd a)
     )
   )
@@ -643,15 +643,15 @@ let has_array_cell_has_base_array_cell
 
 let has_base_array_cell_has_array_cell
   a i r br
-= let j : Ghost.erased SZ.t = Ghost.hide (i `SZ.sub` (dfst a).ar_offset) in
-  rewrite (has_base_array_cell br i r) (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker j i) r);
+= let j : Ghost.erased SZ.t = Ghost.hide (i `SZ.sub` (array_ptr_of a).ar_offset) in
+  rewrite (has_base_array_cell br i r) (has_base_array_cell1 (array_ptr_of a).ar_base (array_index_as_base_array_index_marker j i) r);
   rewrite (has_array_cell0 a j r) (has_array_cell a j r);
   j
 
 let has_array_cell_inj
   #_ #_ #td a i r1 r2
 = has_array_cell_post a i r1;
-  let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (dfst a))) = (dfst a).ar_base in
+  let br : ref (base_array0 unit (* dummy *) td (array_ref_base_size (array_ptr_of a))) = (array_ptr_of a).ar_base in
   let j1 = has_array_cell_has_base_array_cell a i r1 br in
   let j2 = has_array_cell_has_base_array_cell a i r2 br in
   vpattern_rewrite (fun j2 -> has_base_array_cell _ j2 r2) j1;
@@ -684,9 +684,9 @@ let has_array_cell_array_of_ref
   A.ref_of_array_of_ref (Some?.v r).ref;
   A.ref_of_array_of_ref_base (Some?.v r).ref;
   assert (Ghost.reveal (dsnd a) == 1sz);
-  assert ((dfst a).ar_offset == 0sz);
+  assert ((array_ptr_of a).ar_offset == 0sz);
   struct_field_eq_cell td 1sz 0sz;
-  assert (has_base_array_cell0 (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` 0sz) r)
+  assert (has_base_array_cell0 (array_ref_base (array_ptr_of a)) (array_ref_offset (array_ptr_of a) `SZ.add` 0sz) r)
 
 #pop-options
 *)
@@ -734,20 +734,20 @@ let has_array_cell_drop
 = rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
   let _ = gen_elim () in
   let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
-  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  rewrite (has_base_array_cell1 (array_ptr_of a).ar_base j r) (has_base_array_cell0 (array_ptr_of a).ar_base j r);
   let _ = gen_elim () in
-  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
-  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let j' : base_array_index_t' (array_ptr_of a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  rewrite (has_base_array_cell_as_struct_field (array_ptr_of a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j' r);
   let _ = gen_elim () in
   HR.gather p' r;
   has_struct_field1_intro
-    #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
+    #_ #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j' r _ _ _ _ ();
   rewrite
-    (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r)
-    (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+    (has_struct_field1 #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j' r)
+    (has_base_array_cell_as_struct_field (array_ptr_of a).ar_base j j' r);
   rewrite
-    (has_base_array_cell0 (dfst a).ar_base j r)
-    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+    (has_base_array_cell0 (array_ptr_of a).ar_base j r)
+    (has_base_array_cell1 (array_ptr_of a).ar_base (array_index_as_base_array_index_marker i j) r);
   rewrite
     (has_array_cell0 a i r)
     (has_array_cell a i r)
@@ -758,16 +758,16 @@ let has_array_cell_elim
   (#td: typedef t)
   (#p: P.perm)
   (a: array td)
-  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (#b: ref0_v (base_array1 td (array_ptr_of a).ar_base_size))
   (i: SZ.t)
   (r: ref td)
 : STGhost (Ghost.erased (ref0_v td)) opened
     (has_array_cell1 a i r `star`
-      HR.pts_to (dfst a).ar_base p b
+      HR.pts_to (array_ptr_of a).ar_base p b
     )
     (fun b' -> has_array_cell1 a i r `star`
       exists_ (fun p -> exists_ (fun p' ->
-        HR.pts_to (dfst a).ar_base p b `star`
+        HR.pts_to (array_ptr_of a).ar_base p b `star`
         HR.pts_to r p' b'
     )))
     True
@@ -781,24 +781,24 @@ let has_array_cell_elim
   rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
   let _ = gen_elim () in
   let j = vpattern_replace (fun j -> has_base_array_cell1 _ j _) in
-  rewrite (has_base_array_cell1 (dfst a).ar_base j r) (has_base_array_cell0 (dfst a).ar_base j r);
+  rewrite (has_base_array_cell1 (array_ptr_of a).ar_base j r) (has_base_array_cell0 (array_ptr_of a).ar_base j r);
   let _ = gen_elim () in
-  let j' : base_array_index_t' (dfst a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
-  rewrite (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r);
+  let j' : base_array_index_t' (array_ptr_of a).ar_base_size = vpattern_replace (fun j' -> has_base_array_cell_as_struct_field _ _ j' _) in
+  rewrite (has_base_array_cell_as_struct_field (array_ptr_of a).ar_base j j' r) (has_struct_field0 #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j' r);
   let _ = gen_elim () in
-  hr_gather b (dfst a).ar_base;
+  hr_gather b (array_ptr_of a).ar_base;
   HR.share r;
-  HR.share (dfst a).ar_base;
-  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r _ _ _ _ ();
-  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j' r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j' r);
+  HR.share (array_ptr_of a).ar_base;
+  has_struct_field1_intro #_ #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j' r _ _ _ _ ();
+  rewrite (has_struct_field1 #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j' r) (has_base_array_cell_as_struct_field (array_ptr_of a).ar_base j j' r);
   rewrite
-    (has_base_array_cell0 (dfst a).ar_base j r)
-    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+    (has_base_array_cell0 (array_ptr_of a).ar_base j r)
+    (has_base_array_cell1 (array_ptr_of a).ar_base (array_index_as_base_array_index_marker i j) r);
   rewrite
     (has_array_cell0 a i r)
     (has_array_cell a i r);
   A.ref_of_array_eq (model_array_of_array a b) i;
-  struct_field_eq_cell td (dfst a).ar_base_size j';
+  struct_field_eq_cell td (array_ptr_of a).ar_base_size j';
   let b' = vpattern_replace_erased (HR.pts_to r _) in
   noop ();
   b'
@@ -807,7 +807,7 @@ let ghost_array_cell_focus
   #_ #_ #td #s a i r
 = rewrite (array_pts_to a s) (array_pts_to0 a s);
   let _ = gen_elim () in
-  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let b = vpattern_replace (HR.pts_to (array_ptr_of a).ar_base _) in
   let r' = has_array_cell_elim a i r in
   let _ = gen_elim () in
   let _ = A.g_focus_cell _ _ i () in
@@ -822,13 +822,13 @@ let has_array_cell_intro
   (#td: typedef t)
   (#p: P.perm)
   (a: array td)
-  (#b: ref0_v (base_array1 td (dfst a).ar_base_size))
+  (#b: ref0_v (base_array1 td (array_ptr_of a).ar_base_size))
   (#p': P.perm)
   (#b': ref0_v td)
   (i: SZ.t)
   (r: ref td)
 : STGhost unit opened
-    (HR.pts_to (dfst a).ar_base p b `star`
+    (HR.pts_to (array_ptr_of a).ar_base p b `star`
       HR.pts_to r p' b'
     )
     (fun _ -> has_array_cell1 a i r)
@@ -841,13 +841,13 @@ let has_array_cell_intro
     (fun _ -> True)
 = 
   A.ref_of_array_eq (model_array_of_array a b) i;
-  let j : base_array_index_t' (dfst a).ar_base_size = (dfst a).ar_offset `SZ.add` i in
-  struct_field_eq_cell td (dfst a).ar_base_size j;
-  has_struct_field1_intro #_ #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r _ _ _ _ ();
-  rewrite (has_struct_field1 #(base_array_index_t' (dfst a).ar_base_size) #(base_array_fd td (dfst a).ar_base_size) (dfst a).ar_base j r) (has_base_array_cell_as_struct_field (dfst a).ar_base j j r);
+  let j : base_array_index_t' (array_ptr_of a).ar_base_size = (array_ptr_of a).ar_offset `SZ.add` i in
+  struct_field_eq_cell td (array_ptr_of a).ar_base_size j;
+  has_struct_field1_intro #_ #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j r _ _ _ _ ();
+  rewrite (has_struct_field1 #(base_array_index_t' (array_ptr_of a).ar_base_size) #(base_array_fd td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base j r) (has_base_array_cell_as_struct_field (array_ptr_of a).ar_base j j r);
   rewrite
-    (has_base_array_cell0 (dfst a).ar_base j r)
-    (has_base_array_cell1 (dfst a).ar_base (array_index_as_base_array_index_marker i j) r);
+    (has_base_array_cell0 (array_ptr_of a).ar_base j r)
+    (has_base_array_cell1 (array_ptr_of a).ar_base (array_index_as_base_array_index_marker i j) r);
   rewrite
     (has_array_cell0 a i r)
     (has_array_cell a i r)
@@ -859,7 +859,7 @@ let ghost_array_cell
   let _ = gen_elim () in
   HR.share _;
   rewrite (array_pts_to0 a s) (array_pts_to a s);
-  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let b = vpattern_replace (HR.pts_to (array_ptr_of a).ar_base _) in
   let ar = model_array_of_array a b in
   let b' = {
     base = b.base;
@@ -897,8 +897,8 @@ let array_cell0
   let _ = gen_elim () in
   HR.share _;
   rewrite (array_pts_to0 a s) (array_pts_to a s);
-  let b = HR.read (dfst a).ar_base in
-  vpattern_rewrite (HR.pts_to (dfst a).ar_base _) b;
+  let b = HR.read (array_ptr_of a).ar_base in
+  vpattern_rewrite (HR.pts_to (array_ptr_of a).ar_base _) b;
   let ar = model_array_of_array a b in
   A.ref_of_array_eq ar i;
   let b' = {
@@ -959,7 +959,7 @@ let unarray_cell
   let _ = gen_elim () in
   hr_gather (Ghost.reveal w) r;
   ar_unfocus_cell _ _ i _ _ ();
-  let b = vpattern_replace (HR.pts_to (dfst a).ar_base _) in
+  let b = vpattern_replace (HR.pts_to (array_ptr_of a).ar_base _) in
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
   rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v));
   has_array_cell_drop _ _ _
@@ -993,17 +993,17 @@ let ghost_array_split
   let sq : squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)) = () in
   rewrite (array_pts_to a s) (array_pts_to0 a s);
   let _ = gen_elim () in
-  let br : Ghost.erased (ref0_v (base_array1 td (dfst a).ar_base_size)) = vpattern_replace_erased (HR.pts_to _ _) in
+  let br : Ghost.erased (ref0_v (base_array1 td (array_ptr_of a).ar_base_size)) = vpattern_replace_erased (HR.pts_to _ _) in
   A.g_split _ _ i ();
   HR.share _;
   let p = vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
-  let br_l : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_l a i)).ar_base_size)) = coerce_eq () br in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_l a i)).ar_base p br_l);
+  let br_l : Ghost.erased (ref0_v (base_array1 td (array_ptr_of (array_split_l a i)).ar_base_size)) = coerce_eq () br in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of (array_split_l a i)).ar_base p br_l);
   rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
   noop ();
   rewrite (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)));
-  let br_r : Ghost.erased (ref0_v (base_array1 td (dfst (array_split_r a i)).ar_base_size)) = coerce_eq () br in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst (array_split_r a i)).ar_base p br_r);
+  let br_r : Ghost.erased (ref0_v (base_array1 td (array_ptr_of (array_split_r a i)).ar_base_size)) = coerce_eq () br in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of (array_split_r a i)).ar_base p br_r);
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
   noop ();
   rewrite (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)));
@@ -1079,10 +1079,10 @@ let array_join
   #_ #_ #td #sl #sr a al ar i
 = rewrite (array_pts_to al sl) (array_pts_to0 al sl);
   let _ = gen_elim () in
-  let br_l : ref0_v (base_array1 td (dfst al).ar_base_size) = vpattern_replace (HR.pts_to _ _) in
+  let br_l : ref0_v (base_array1 td (array_ptr_of al).ar_base_size) = vpattern_replace (HR.pts_to _ _) in
   let pl = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  let br : ref0_v (base_array1 td (dfst a).ar_base_size) = coerce_eq () br_l in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (dfst a).ar_base pl br);
+  let br : ref0_v (base_array1 td (array_ptr_of a).ar_base_size) = coerce_eq () br_l in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of a).ar_base pl br);
   rewrite (array_pts_to ar sr) (array_pts_to0 ar sr);
   let _ = gen_elim () in
   let pr = vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
@@ -1171,7 +1171,7 @@ let mk_fraction_seq_join
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
   rewrite (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2));
   let _ = gen_elim () in
-  hr_gather br (dfst r).ar_base;
+  hr_gather br (array_ptr_of r).ar_base;
   rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
   ar_gather _ (mk_fraction_seq td v (p1 `P.sum_perm` p2)) (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
     td.mk_fraction_join (Seq.index v i) p1 p2
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index 961492df571..83ae6f9c39b 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -206,8 +206,13 @@ let array_len_t (#t: Type) (#td: typedef t) (r: array_ptr td) : Tot Type0 =
 inline_for_extraction [@@noextract_to "krml"]
 let array_or_null (#t: Type) (td: typedef t) : Tot Type0 = (r: array_ptr td & array_len_t r)
 
+inline_for_extraction [@@noextract_to "krml"]
+let array_ptr_of (#t: Type) (#td: typedef t) (ar: array_or_null td) : Tot (array_ptr td) =
+  match ar with
+  | (| a, _ |) -> a
+
 let g_array_is_null (#t: Type) (#td: typedef t) (a: array_or_null td) : GTot bool =
-  g_array_ptr_is_null (dfst a)
+  g_array_ptr_is_null (array_ptr_of a)
 
 inline_for_extraction [@@noextract_to "krml"]
 let array (#t: Type) (td: typedef t) : Tot Type0 = (a: array_or_null td { g_array_is_null a == false })
@@ -262,7 +267,7 @@ let array_is_null
     (fun _ -> array_pts_to_or_null r v)
     (True)
     (fun b -> b == g_array_is_null r)
-= let a = dfst r in
+= let a = array_ptr_of r in
   let len : array_len_t a = dsnd r in
   rewrite (array_pts_to_or_null _ _) (array_pts_to_or_null (| a, len |) v);
   let res = array_ptr_is_null a len in
@@ -360,7 +365,7 @@ let array_ref_of_base_post
   (ar: array td)
 : GTot prop
 =
-       dfst ar == a /\
+       array_ptr_of ar == a /\
         array_ref_base_size a == Ghost.reveal n /\
         array_ref_offset a == 0sz /\
         has_array_of_base r ar /\
@@ -449,7 +454,7 @@ val array_ptr_alloc
       exists_ (fun (ar: array_or_null td) -> exists_ (fun (s: Seq.seq t) ->
       freeable_or_null_array ar `star`
       array_pts_to_or_null ar s `star` pure (
-      dfst ar == a /\
+      array_ptr_of ar == a /\
       (g_array_is_null ar == false ==> array_length ar == SZ.v sz) /\
       Ghost.reveal s `Seq.equal` FStar.Seq.create (SZ.v sz) (uninitialized td)
     ))))
@@ -514,7 +519,7 @@ let array_free
     (fun _ -> emp)
     (full_seq td s)
     (fun _ -> True)
-= let al = dfst a in
+= let al = array_ptr_of a in
   let n: array_len_t al = dsnd a in
   rewrite (freeable_array _) (freeable_array (| al, n |));
   rewrite (array_pts_to _ _) (array_pts_to (| al, n |) s);
@@ -625,7 +630,7 @@ val has_array_cell
 : Tot vprop
 (*
 = SZ.v i < SZ.v (dsnd a) /\
-  has_base_array_cell (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r
+  has_base_array_cell (array_ref_base (array_ptr_of a)) (array_ref_offset (array_ptr_of a) `SZ.add` i) r
 *)
 
 val has_array_cell_post
@@ -649,13 +654,13 @@ val has_array_cell_has_base_array_cell
   (i: SZ.t)
   (r: ref td)
   (#ty: Type)
-  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
+  (br: ref (base_array0 ty td (array_ref_base_size (array_ptr_of a))))
 : STGhost (Ghost.erased SZ.t) opened
     (has_array_cell a i r)
     (fun j -> has_base_array_cell br j r)
-    (has_array_ref_base (dfst a) br)
+    (has_array_ref_base (array_ptr_of a) br)
     (fun j ->
-      SZ.v j == SZ.v (array_ref_offset (dfst a)) + SZ.v i
+      SZ.v j == SZ.v (array_ref_offset (array_ptr_of a)) + SZ.v i
     )
 
 val has_base_array_cell_has_array_cell
@@ -666,16 +671,16 @@ val has_base_array_cell_has_array_cell
   (i: SZ.t)
   (r: ref td)
   (#ty: Type)
-  (br: ref (base_array0 ty td (array_ref_base_size (dfst a))))
+  (br: ref (base_array0 ty td (array_ref_base_size (array_ptr_of a))))
 : STGhost (Ghost.erased SZ.t) opened
     (has_base_array_cell br i r)
     (fun j -> has_array_cell a j r)
-    (has_array_ref_base (dfst a) br /\
-      SZ.v i >= SZ.v (array_ref_offset (dfst a)) /\
-      SZ.v i < SZ.v (array_ref_offset (dfst a)) + SZ.v (dsnd a)
+    (has_array_ref_base (array_ptr_of a) br /\
+      SZ.v i >= SZ.v (array_ref_offset (array_ptr_of a)) /\
+      SZ.v i < SZ.v (array_ref_offset (array_ptr_of a)) + SZ.v (dsnd a)
     )
     (fun j ->
-      SZ.v i == SZ.v (array_ref_offset (dfst a)) + SZ.v j
+      SZ.v i == SZ.v (array_ref_offset (array_ptr_of a)) + SZ.v j
     )
 
 val has_array_cell_inj
@@ -695,7 +700,7 @@ val has_array_cell_inj
       has_array_cell a i r2 `star`
       ref_equiv r1 r2
     )
-// = has_base_array_cell_inj (array_ref_base (dfst a)) (array_ref_offset (dfst a) `SZ.add` i) r1 r2
+// = has_base_array_cell_inj (array_ref_base (array_ptr_of a)) (array_ref_offset (array_ptr_of a) `SZ.add` i) r1 r2
 
 (*
 val has_array_cell_array_of_ref
@@ -853,7 +858,7 @@ val array_ref_split
     (fun _ -> array_pts_to (array_split_l (| al, len |) i) (Seq.slice s 0 (SZ.v i)) `star`
       array_pts_to (array_split_r (| al, len |) i) (Seq.slice s (SZ.v i) (Seq.length s)))
     (SZ.v i <= SZ.v len \/ SZ.v i <= Seq.length s)
-    (fun ar -> ar == dfst (array_split_r (| al, len |) i))
+    (fun ar -> ar == array_ptr_of (array_split_r (| al, len |) i))
 
 inline_for_extraction [@@noextract_to "krml"]
 let array_split

From ba6f3e47b84bd8ac06c3e9b7606ec3e0887f2d65 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 18:27:33 -0700
Subject: [PATCH 463/513] extract array operations

---
 .../arraystructs/my_fstar/ExtractSteelC.fst   | 19 ++++++++++++++++++-
 examples/steel/arraystructs/my_fstar/Makefile |  2 +-
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index 74d4a0d97ad..142b9d4b10d 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -110,7 +110,7 @@ let my_types_without_decay () =
 
   | MLTY_Named ([arg; _], p) when
     Syntax.string_of_mlpath p = "Steel.ST.C.Types.Base.ptr"
-    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ref"
+    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr"
     ->
       TBuf (translate_type_without_decay env arg)
 
@@ -165,6 +165,12 @@ let my_exprs () = register_pre_translate_expr begin fun env e ->
           false) ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* td *); sz ])
+    when (
+          string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr_alloc" ||
+          false) ->
+      EBufCreateNoInit (ManuallyManaged, translate_expr env sz)
+
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e ])
     when (
           string_of_mlpath p = "Steel.C.Opt.malloc" ||
@@ -182,12 +188,22 @@ let my_exprs () = register_pre_translate_expr begin fun env e ->
           false) ->
       EBufFree (translate_expr env e2)
 
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _(* td *); _ (* s *); e2; _ (* len *) ])
+    when (
+          string_of_mlpath p = "Steel.ST.C.Types.Array.array_ref_free" ||
+          false) ->
+      EBufFree (translate_expr env e2)
+
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _ (* typedef *); _ (* v *); e ]) when
        string_of_mlpath p = "Steel.ST.C.Types.Base.free" ->
       EBufFree (translate_expr env e)
 
 (* BEGIN support for the Steel null pointer. *)
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); _ (* td *); _ (* v *); e; _ (* len *) ])
+    when string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr_is_null"
+    -> generate_is_null (translate_type env t) (translate_expr env e)
+
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, [_ (* opened *); e; _ (* a' *); _ (* sq *) ])
     when string_of_mlpath p = "Steel.C.Array.Base.is_null_from"
     -> generate_is_null (translate_type env t) (translate_expr env e)
@@ -202,6 +218,7 @@ let my_exprs () = register_pre_translate_expr begin fun env e ->
   
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [t])}, _)
     when Syntax.string_of_mlpath p = "Steel.C.Array.Base.null_from"
+    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.null_array_ptr"
     -> EBufNull (translate_type env t)
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
diff --git a/examples/steel/arraystructs/my_fstar/Makefile b/examples/steel/arraystructs/my_fstar/Makefile
index 51d8fef684c..d533ba44314 100644
--- a/examples/steel/arraystructs/my_fstar/Makefile
+++ b/examples/steel/arraystructs/my_fstar/Makefile
@@ -11,7 +11,7 @@ include $(FSTAR_HOME)/ulib/gmake/fstar.mk # and $(FSTAR) for all sub-make calls
 include $(FSTAR_HOME)/src/Makefile.boot.common
 
 OUTPUT_DIRECTORY = $(CURDIR)
-FSTAR_C=$(RUNLIM) $(FSTAR_EXE) $(SIL) $(FSTAR_BOOT_OPTIONS) --already_cached 'FStar'
+FSTAR_C=$(RUNLIM) $(FSTAR_EXE) $(SIL) $(FSTAR_BOOT_OPTIONS)
 
 EXTRACT_FILES=ExtractSteelC.ml
 extract: $(EXTRACT_FILES)

From 81e08ef3cee189816c1dbb3732a92ec5887eab03 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 15 Mar 2023 18:28:13 -0700
Subject: [PATCH 464/513] restore array alloc example

---
 examples/steel/arraystructs/HaclExample2.fst | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/examples/steel/arraystructs/HaclExample2.fst b/examples/steel/arraystructs/HaclExample2.fst
index 81df2e6a421..f0b7afccbfa 100644
--- a/examples/steel/arraystructs/HaclExample2.fst
+++ b/examples/steel/arraystructs/HaclExample2.fst
@@ -79,23 +79,25 @@ let do_something_with_precomp
   noop ();
   return (null _)
 
-(*
 let test_alloc_free
   ()
 : STT unit
     emp
     (fun _ -> emp)
 =
-  let a = alloc (scalar bool) true (mk_size_t 42ul) in
-  if Steel.C.Array.is_null a
+  let a = array_alloc (scalar bool) 42sz in
+  let _ = gen_elim () in
+  if array_is_null a
   then begin
-    Steel.C.Array.elim_varray_or_null_none a
+    rewrite (array_pts_to_or_null _ _) emp;
+    rewrite (freeable_or_null_array _) emp;
+    noop ()
   end else begin
-    Steel.C.Array.elim_varray_or_null_some a;
-    free a
-  end;
-  return ()
-*)
+    let s = vpattern_replace (array_pts_to_or_null _) in
+    rewrite (array_pts_to_or_null _ _) (array_pts_to a s);
+    rewrite (freeable_or_null_array _) (freeable_array a);
+    array_free a
+  end
 
 #push-options "--fuel 0 --print_universes --print_implicits --z3rlimit 128"
 #restart-solver

From 8315ed18682b40225e6778d07bf26578d8e7c4bd Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Mar 2023 18:33:14 -0700
Subject: [PATCH 465/513] support void*

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  | 215 ++++++++++++------
 ulib/experimental/Steel.ST.C.Types.Base.fst   | 188 +++++++++++----
 ulib/experimental/Steel.ST.C.Types.Base.fsti  |  16 +-
 ulib/experimental/Steel.ST.C.Types.Scalar.fst |  31 +--
 .../Steel.ST.C.Types.Struct.Aux.fst           |  49 ++--
 ulib/experimental/Steel.ST.C.Types.Union.fst  |  71 +++---
 6 files changed, 378 insertions(+), 192 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index c50a3918030..e0af7a2f1f6 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -225,7 +225,7 @@ let has_base_array_cell_equiv_to'
     (fun _ -> has_base_array_cell1 r i r2 `star` ref_equiv r1 r2)
 = rewrite (has_base_array_cell1 r i r1) (has_base_array_cell0 r i r1);
   let _ = gen_elim () in
-  has_struct_field_equiv_to' r _ r1 r2;
+  has_struct_field_equiv_to'  #_ #(base_array_index_t' n) #(base_array_fd td n) r _ r1 (r2);
   rewrite (has_base_array_cell0 r i r2) (has_base_array_cell1 r i r2)
 
 let has_base_array_cell_equiv_to
@@ -275,13 +275,27 @@ let base_array_pcm_eq
     (fun _ -> ())
     ()
 
+let model_array_of_array_precond
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (base: ref0_v)
+: GTot prop
+=
+  base.t == base_array_t' t (array_ptr_of a).ar_base_size /\
+  base.td == base_array1 td (array_ptr_of a).ar_base_size
+      
 [@@noextract_to "krml"] // proof-only
 let model_array_of_array
   (#t: Type)
   (#td: typedef t)
   (a: array td)
-  (base: ref0_v (base_array1 td (array_ptr_of a).ar_base_size))
-: Tot (A.array base.base td.pcm)
+  (base: ref0_v)
+: Pure (A.array base.base td.pcm)
+    (requires (
+      model_array_of_array_precond a base
+    ))
+    (ensures (fun _ -> True))
 = let (| al, len |) = a in
   {
     base_len = Ghost.hide (Ghost.reveal al.ar_base_size);
@@ -291,6 +305,17 @@ let model_array_of_array
     prf = ();
   }
 
+let has_model_array_of_array
+  (#t: Type)
+  (#td: typedef t)
+  (a: array td)
+  (base: ref0_v)
+  (ar: A.array base.base td.pcm)
+: GTot prop
+= 
+  model_array_of_array_precond a base /\
+  model_array_of_array a base == ar
+
 [@@__reduce__]
 let array_pts_to0
   (#t: Type)
@@ -298,23 +323,75 @@ let array_pts_to0
   (r: array td)
   (v: Ghost.erased (Seq.seq t))
 : Tot vprop
-= exists_ (fun br -> exists_ (fun p ->
+= exists_ (fun br -> exists_ (fun p -> exists_ (fun (a: A.array br.base td.pcm) ->
     HR.pts_to (array_ptr_of r).ar_base p br `star`
-    A.pts_to (model_array_of_array r br) v
-  ))
+    A.pts_to a v `star`
+    pure (has_model_array_of_array r br a)
+  )))
 
 let array_pts_to r v =
   array_pts_to0 r v
 
+let array_pts_to_intro
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+  (br: ref0_v)
+  (p: P.perm)
+  (sq: squash (model_array_of_array_precond r br))
+: STGhostT unit opened
+    (
+      HR.pts_to (array_ptr_of r).ar_base p br `star`
+      A.pts_to (model_array_of_array r br) v
+    )
+    (fun _ -> array_pts_to r v)
+= noop ();
+  intro_exists p (fun p -> exists_ (fun (a: A.array br.base td.pcm) ->
+    HR.pts_to (array_ptr_of r).ar_base p br `star`
+    A.pts_to a v `star`
+    pure (has_model_array_of_array r br a)
+  ));
+  rewrite (array_pts_to0 r v) (array_pts_to r v)
+
+let array_pts_to_res_t
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+: Tot Type
+= (br: Ghost.erased ref0_v { model_array_of_array_precond r br })
+
+let array_pts_to_elim
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: array td)
+  (v: Ghost.erased (Seq.seq t))
+: STGhostT (array_pts_to_res_t r) opened
+    (array_pts_to r v)
+    (fun br -> exists_ (fun p ->
+      HR.pts_to (array_ptr_of r).ar_base p br `star`
+      A.pts_to (model_array_of_array r br) v
+    ))
+= rewrite (array_pts_to _ _) (array_pts_to0 r v);
+  let _ = gen_elim () in
+  let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
+  let br0 = vpattern_replace_erased (HR.pts_to _ _) in
+  let br : array_pts_to_res_t r = br0 in
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of r).ar_base p br);
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) v);
+  br
+
 let array_ptr_is_null
   r _
 = return (HR.is_null r.ar_base)
 
 let array_pts_to_length r v =
-  rewrite (array_pts_to r v) (array_pts_to0 r v);
+  let _ = array_pts_to_elim _ _ in
   let _ = gen_elim () in
   let _ = A.pts_to_length _ _ in
-  rewrite (array_pts_to0 r v) (array_pts_to r v)
+  array_pts_to_intro _ _ _ _ ()
 
 let has_array_of_base'
   (#t: Type)
@@ -366,15 +443,15 @@ let ghost_array_of_base_focus'
 = rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  let w' : ref0_v (base_array1 td (array_ptr_of a).ar_base_size) = coerce_eq () w in
-  assert ((model_array_of_array a w').base == w.ref);
-  rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w').base v);
+  let rr = get_ref r in
+  assert ((model_array_of_array a w).base == rr);
+  rewrite (r_pts_to _ _) (R.pts_to (model_array_of_array a w).base v);
   assert (seq_of_base_array0 v `Seq.equal` A.seq_of_array_pcm_carrier v);
   A.array_pcm_carrier_of_seq_of_array_pcm_carrier v;
-  A.pts_to_intro_from_base (model_array_of_array a w')  v (seq_of_base_array0 v);
+  A.pts_to_intro_from_base (model_array_of_array a w)  v (seq_of_base_array0 v);
   let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of a).ar_base p w');
-  rewrite (array_pts_to0 a (seq_of_base_array0 v)) (array_pts_to a (seq_of_base_array0 v))
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of a).ar_base p w);
+  array_pts_to_intro a (seq_of_base_array0 v) w _ ()
 
 let ghost_array_of_base_focus
   #_ #_ #_ #_ #td #v r a
@@ -448,18 +525,17 @@ let unarray_of_base0
       has_array_of_base' r a
     )
     (fun v' -> Ghost.reveal v `Seq.equal` seq_of_base_array0 v')
-= rewrite (array_pts_to a v) (array_pts_to0 a v);
+= let ba = array_pts_to_elim a v in
   let _ = gen_elim () in
   let p = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  let ba = vpattern_replace (HR.pts_to _ _) in
-  let ba' : ref0_v (base_array1 td n) = coerce_eq () ba in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba');
+  rewrite (HR.pts_to _ _ _) (HR.pts_to r p ba);
   let m = model_array_of_array a ba in
   rewrite (A.pts_to _ _) (A.pts_to m v);
   let y : Ghost.erased (A.array_pcm_carrier t m.base_len) = A.pts_to_elim_to_base m v in
+  let rr : R.ref ba.base (base_array1 td n).pcm = coerce_eq () m.base in
   let y' : Ghost.erased (base_array_t' t n) = Ghost.hide (Ghost.reveal y) in
-  rewrite (r_pts_to _ _) (r_pts_to ba'.ref (Ghost.reveal y'));
-  rewrite (pts_to0 r y') (pts_to r y');
+  rewrite (R.pts_to _ _) (r_pts_to rr y');
+  pts_to_intro r p ba rr y';
   y'
 
 #pop-options
@@ -699,9 +775,9 @@ let has_struct_field1_intro
   (field: field_t)
   (r': ref (fields.fd_typedef field))
   (p: P.perm)
-  (w: ref0_v (struct1 fields))
+  (w: ref0_v)
   (p': P.perm)
-  (w': ref0_v (fields.fd_typedef field))
+  (w': ref0_v)
   ()
 : STGhost unit opened
     (HR.pts_to r p w `star` HR.pts_to r' p' w')
@@ -723,7 +799,7 @@ let has_array_cell_drop
   (#td: typedef t)
   (a: array td)
   (#p': P.perm)
-  (#b': ref0_v td)
+  (#b': ref0_v)
   (i: SZ.t)
   (r: ref td)
 : STGhostT unit opened
@@ -758,10 +834,10 @@ let has_array_cell_elim
   (#td: typedef t)
   (#p: P.perm)
   (a: array td)
-  (#b: ref0_v (base_array1 td (array_ptr_of a).ar_base_size))
+  (#b: ref0_v)
   (i: SZ.t)
   (r: ref td)
-: STGhost (Ghost.erased (ref0_v td)) opened
+: STGhost (Ghost.erased (ref0_v)) opened
     (has_array_cell1 a i r `star`
       HR.pts_to (array_ptr_of a).ar_base p b
     )
@@ -772,10 +848,14 @@ let has_array_cell_elim
     )))
     True
     (fun b' ->
-      let ar = model_array_of_array a b in
-      SZ.v i < SZ.v ar.len /\
+      model_array_of_array_precond a b /\
       b'.base == b.base /\
-      b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+      b'.t == t /\
+      b'.td == td /\
+      begin let ar = model_array_of_array a b in
+        SZ.v i < SZ.v ar.len /\
+        b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+      end
     )
 = 
   rewrite (has_array_cell1 a i r) (has_array_cell0 a i r);
@@ -811,10 +891,9 @@ let ghost_array_cell_focus
   let r' = has_array_cell_elim a i r in
   let _ = gen_elim () in
   let _ = A.g_focus_cell _ _ i () in
-  rewrite (R.pts_to _ _) (R.pts_to r'.ref (Seq.index s (SZ.v i)));
-  rewrite (pts_to0 r (Seq.index s (SZ.v i))) (pts_to r (Seq.index s (SZ.v i)));
+  pts_to_intro_rewrite r _ (Seq.index s (SZ.v i));
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) (unknown td)));
-  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) (unknown td))) (array_pts_to a (Seq.upd s (SZ.v i) (unknown td)))
+  array_pts_to_intro a (Seq.upd s (SZ.v i) (unknown td)) _ _ ()
 
 let has_array_cell_intro
   (#opened: _)
@@ -822,9 +901,9 @@ let has_array_cell_intro
   (#td: typedef t)
   (#p: P.perm)
   (a: array td)
-  (#b: ref0_v (base_array1 td (array_ptr_of a).ar_base_size))
+  (#b: ref0_v)
   (#p': P.perm)
-  (#b': ref0_v td)
+  (#b': ref0_v)
   (i: SZ.t)
   (r: ref td)
 : STGhost unit opened
@@ -833,10 +912,14 @@ let has_array_cell_intro
     )
     (fun _ -> has_array_cell1 a i r)
     (
-      let ar = model_array_of_array a b in
+      model_array_of_array_precond a b /\
+      begin let ar = model_array_of_array a b in
       SZ.v i < SZ.v ar.len /\
       b'.base == b.base /\
+      b'.t == t /\
+      b'.td == td /\
       b'.ref == R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i)
+      end
     )
     (fun _ -> True)
 = 
@@ -855,13 +938,14 @@ let has_array_cell_intro
 let ghost_array_cell
   #_ #_ #td #s a i
 = array_pts_to_length _ _;
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let b = array_pts_to_elim a s in
   let _ = gen_elim () in
   HR.share _;
-  rewrite (array_pts_to0 a s) (array_pts_to a s);
-  let b = vpattern_replace (HR.pts_to (array_ptr_of a).ar_base _) in
+  array_pts_to_intro a s _ _ ();
   let ar = model_array_of_array a b in
   let b' = {
+    t = _;
+    td = td;
     base = b.base;
     ref = R.ref_focus (A.ref_of_array ar) (A.cell td.pcm ar.len i);
   }
@@ -893,15 +977,17 @@ let array_cell0
     )
     (fun _ -> True)
 = array_pts_to_length _ _;
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let _ = array_pts_to_elim a s in
   let _ = gen_elim () in
   HR.share _;
-  rewrite (array_pts_to0 a s) (array_pts_to a s);
+  array_pts_to_intro a s _ _ ();
   let b = HR.read (array_ptr_of a).ar_base in
   vpattern_rewrite (HR.pts_to (array_ptr_of a).ar_base _) b;
   let ar = model_array_of_array a b in
   A.ref_of_array_eq ar i;
   let b' = {
+    t = _;
+    td = td;
     base = b.base;
     ref = R.ref_focus ar.base (A.cell td.pcm ar.base_len (ar.offset `SZ.add`  i));
   }
@@ -951,7 +1037,7 @@ let ar_unfocus_cell
 let unarray_cell
   #_ #_ #td #s #v a i r
 = array_pts_to_length _ _;
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let b = array_pts_to_elim a s in
   let _ = gen_elim () in
   let w = has_array_cell_elim a i r in
   let _ = gen_elim () in
@@ -959,9 +1045,8 @@ let unarray_cell
   let _ = gen_elim () in
   hr_gather (Ghost.reveal w) r;
   ar_unfocus_cell _ _ i _ _ ();
-  let b = vpattern_replace (HR.pts_to (array_ptr_of a).ar_base _) in
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array a b) (Seq.upd s (SZ.v i) v));
-  rewrite (array_pts_to0 a (Seq.upd s (SZ.v i) v)) (array_pts_to a (Seq.upd s (SZ.v i) v));
+  array_pts_to_intro a (Seq.upd s (SZ.v i) v) _ _ ();
   has_array_cell_drop _ _ _
 
 #push-options "--split_queries --z3rlimit 16"
@@ -991,22 +1076,17 @@ let ghost_array_split
   #_ #_ #td #s a i
 = array_pts_to_length _ _;
   let sq : squash (SZ.v i <= SZ.v (dsnd a) /\ Seq.length s == SZ.v (dsnd a)) = () in
-  rewrite (array_pts_to a s) (array_pts_to0 a s);
+  let br = array_pts_to_elim a s in
   let _ = gen_elim () in
-  let br : Ghost.erased (ref0_v (base_array1 td (array_ptr_of a).ar_base_size)) = vpattern_replace_erased (HR.pts_to _ _) in
   A.g_split _ _ i ();
   HR.share _;
   let p = vpattern_replace (fun p -> HR.pts_to _ p _ `star` HR.pts_to _ p _) in
-  let br_l : Ghost.erased (ref0_v (base_array1 td (array_ptr_of (array_split_l a i)).ar_base_size)) = coerce_eq () br in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of (array_split_l a i)).ar_base p br_l);
-  rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br_l) (Seq.slice s 0 (SZ.v i)));
-  noop ();
-  rewrite (array_pts_to0 (array_split_l a i) (Seq.slice s 0 (SZ.v i))) (array_pts_to (array_split_l a i) (Seq.slice s 0 (SZ.v i)));
-  let br_r : Ghost.erased (ref0_v (base_array1 td (array_ptr_of (array_split_r a i)).ar_base_size)) = coerce_eq () br in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of (array_split_r a i)).ar_base p br_r);
-  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br_r) (Seq.slice s (SZ.v i) (Seq.length s)));
-  noop ();
-  rewrite (array_pts_to0 (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s))) (array_pts_to (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)));
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of (array_split_l a i)).ar_base p br);
+  rewrite (A.pts_to _ (Seq.slice s 0 _)) (A.pts_to (model_array_of_array (array_split_l a i) br) (Seq.slice s 0 (SZ.v i)));
+  array_pts_to_intro (array_split_l a i) (Seq.slice s 0 (SZ.v i)) _ _ ();
+  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of (array_split_r a i)).ar_base p br);
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array (array_split_r a i) br) (Seq.slice s (SZ.v i) (Seq.length s)));
+  array_pts_to_intro (array_split_r a i) (Seq.slice s (SZ.v i) (Seq.length s)) _ _ ();
   sq
 
 let t_array_split_r
@@ -1077,18 +1157,17 @@ let ar_join
 
 let array_join
   #_ #_ #td #sl #sr a al ar i
-= rewrite (array_pts_to al sl) (array_pts_to0 al sl);
+= let br = array_pts_to_elim al sl in
   let _ = gen_elim () in
-  let br_l : ref0_v (base_array1 td (array_ptr_of al).ar_base_size) = vpattern_replace (HR.pts_to _ _) in
   let pl = vpattern_replace (fun p -> HR.pts_to _ p _) in
-  let br : ref0_v (base_array1 td (array_ptr_of a).ar_base_size) = coerce_eq () br_l in
-  rewrite (HR.pts_to _ _ _) (HR.pts_to (array_ptr_of a).ar_base pl br);
-  rewrite (array_pts_to ar sr) (array_pts_to0 ar sr);
+  vpattern_rewrite (fun x -> HR.pts_to x pl _) (array_ptr_of a).ar_base;
+  let _ = array_pts_to_elim ar sr in
   let _ = gen_elim () in
   let pr = vpattern_replace (fun pr -> HR.pts_to _ pl _ `star` HR.pts_to _ pr _) in
+  vpattern_rewrite (fun x -> HR.pts_to x pr _) (array_ptr_of a).ar_base;
   hr_gather_by_perm pl pr;
   ar_join (model_array_of_array a br) i _ _ sl sr;
-  rewrite (array_pts_to0 a (sl `Seq.append` sr)) (array_pts_to a (sl `Seq.append` sr))
+  array_pts_to_intro a (sl `Seq.append` sr) _ _ ()
 
 let ar_share
   (#opened: _)
@@ -1120,17 +1199,16 @@ let ar_share
 
 let mk_fraction_seq_split_gen
   #_ #_ #td r v p p1 p2
-= rewrite (array_pts_to r (mk_fraction_seq td v p)) (array_pts_to0 r (mk_fraction_seq td v p));
+= let br = array_pts_to_elim r (mk_fraction_seq td v p) in
   let _ = gen_elim () in
-  let br = vpattern_replace (HR.pts_to _ _) in
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p));
   ar_share _ _ (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
     td.mk_fraction_split (Seq.index v i) p1 p2;
     td.mk_fraction_join (Seq.index v i) p1 p2
   );
   HR.share _;
-  rewrite (array_pts_to0 r (mk_fraction_seq td v p1)) (array_pts_to r (mk_fraction_seq td v p1));
-  rewrite (array_pts_to0 r (mk_fraction_seq td v p2)) (array_pts_to r (mk_fraction_seq td v p2))
+  array_pts_to_intro r (mk_fraction_seq td v p1) _ _ ();
+  array_pts_to_intro r (mk_fraction_seq td v p2) _ _ ()
 
 let ar_gather
   (#opened: _)
@@ -1165,15 +1243,14 @@ let ar_gather
 
 let mk_fraction_seq_join
   #_ #_ #td r v p1 p2
-= rewrite (array_pts_to r (mk_fraction_seq td v p1)) (array_pts_to0 r (mk_fraction_seq td v p1));
+= let br = array_pts_to_elim r (mk_fraction_seq td v p1) in
   let _ = gen_elim () in
-  let br = vpattern_replace (HR.pts_to _ _) in
   rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p1));
-  rewrite (array_pts_to r (mk_fraction_seq td v p2)) (array_pts_to0 r (mk_fraction_seq td v p2));
+  let _ = array_pts_to_elim r (mk_fraction_seq td v p2) in
   let _ = gen_elim () in
-  hr_gather br (array_ptr_of r).ar_base;
+  hr_gather (Ghost.reveal br) (array_ptr_of r).ar_base;
   rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v p2));
   ar_gather _ (mk_fraction_seq td v (p1 `P.sum_perm` p2)) (mk_fraction_seq td v p1) (mk_fraction_seq td v p2) (fun i ->
     td.mk_fraction_join (Seq.index v i) p1 p2
   );
-  rewrite (array_pts_to0 r (mk_fraction_seq td v (p1 `P.sum_perm` p2))) (array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
+  array_pts_to_intro r (mk_fraction_seq td v (p1 `P.sum_perm` p2)) _ _ ()
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fst b/ulib/experimental/Steel.ST.C.Types.Base.fst
index 7a548937c5b..202e0b11456 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fst
@@ -100,29 +100,17 @@ let mk_fraction_eq_unknown td v p = td.mk_fraction_eq_one v p
 module R = Steel.ST.C.Model.Ref
 
 noeq
-type ref0_v (#t: Type) (td: typedef t) : Type u#1 = {
+type ref0_v : Type u#1 = {
   base: Type0;
+  t: Type;
+  td: typedef t;
   ref: R.ref base td.pcm;
 }
 
 module HR = Steel.ST.HigherReference
 
-let ptr #t td = HR.ref (ref0_v td)
-let null td = HR.null
-
-(*
-noeq
-type ref0 : Type0 = {
-  dest: TD.token;
-  typedef: typedef (TD.type_of_token dest);
-  ref: R.ref typedef.pcm;
-}
-
-let void_ptr = option ref0
-let void_null = None
-let type_of_ptr p = TD.type_of_token (Some?.v p).dest
-let typedef_of_ptr p = (Some?.v p).typedef
-*)
+let void_ptr = HR.ref ref0_v
+let void_null = HR.null
 
 let r_pts_to
   (#a: Type u#0) (#b: Type u#b) (#p: pcm b)
@@ -130,6 +118,18 @@ let r_pts_to
 : vprop
 = R.pts_to r v
 
+let pts_to_cond
+  (#t: Type)
+  (#td: typedef t)
+  (r: ptr td)
+  (w: ref0_v)
+  (r': R.ref w.base td.pcm)
+: GTot prop
+=
+      t == w.t /\
+      td == w.td /\
+      r' == w.ref
+
 [@@__reduce__]
 let pts_to0
   (#t: Type)
@@ -137,27 +137,50 @@ let pts_to0
   (r: ptr td)
   (v: t)
 : Tot vprop
-= exists_ (fun p -> exists_ (fun w ->
+= exists_ (fun p -> exists_ (fun w -> exists_ (fun (r': R.ref w.base td.pcm) ->
     HR.pts_to r p w `star`
-    r_pts_to w.ref v
-  ))
+    r_pts_to r' v `star`
+    pure (pts_to_cond r w r')
+  )))
 
 let pts_to r v = pts_to0 r v
 
+let pts_to_intro_precond
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (w: ref0_v)
+  (#tbase: Type)
+  (r': R.ref tbase td.pcm)
+: GTot prop
+= tbase == w.base /\
+      t == w.t /\
+      td == w.td /\
+      r' == w.ref
+
 let pts_to_intro
   (#opened: _)
   (#t: Type)
   (#td: typedef t)
   (r: ref td)
   (p: P.perm)
-  (w1 w2: ref0_v td)
+  (w: ref0_v)
+  (#tbase: Type)
+  (r': R.ref tbase td.pcm)
   (v: t)
 : STGhost unit opened
-    (HR.pts_to r p w1 `star` R.pts_to w2.ref v)
+    (HR.pts_to r p w `star` R.pts_to r' v)
     (fun _ -> pts_to r v)
-    (w1 == w2)
+    (pts_to_intro_precond r w r')
     (fun _ -> True)
-= vpattern_rewrite (HR.pts_to r p) w2;
+= let r2 : R.ref w.base td.pcm = coerce_eq () r' in
+  rewrite (R.pts_to r' v) (r_pts_to #w.base #t #td.pcm r2 v);
+  intro_pure (pts_to_cond r w r2);
+  intro_exists r2 (fun (r': R.ref w.base td.pcm) ->
+    HR.pts_to r p w `star`
+    r_pts_to r' v `star`
+    pure (pts_to_cond r w r')
+  );
   rewrite (pts_to0 r v) (pts_to r v)
 
 let is_null
@@ -283,8 +306,7 @@ let pts_to_equiv
   let _ = gen_elim () in
   hr_gather w r1;
   hr_share r2;
-  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
-  rewrite (pts_to0 r2 v) (pts_to r2 v);
+  pts_to_intro r2 _ _ _ _;
   rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
 [@@__steel_reduce__; __reduce__]
@@ -329,58 +351,142 @@ let alloc
 = let r = R.ref_alloc td.pcm td.uninitialized in
   let w = {
     base = _;
+    t = _;
+    td = td;
     ref = r;
   }
   in
-  rewrite (R.pts_to _ _) (R.pts_to w.ref (uninitialized td));
-  let res = HR.alloc w in
+  let res : ptr td = HR.alloc w in
   HR.share res;
   HR.pts_to_not_null res;
-  rewrite (pts_to0 res (uninitialized td)) (pts_to_or_null res (uninitialized td));
+  pts_to_intro res _ _ r _;
+  rewrite (pts_to _ _) (pts_to_or_null res (uninitialized td));
   rewrite (freeable0 res) (freeable_or_null res);
   return res
 
+[@@noextract_to "krml"]
+let read_ref
+  (#t: Type)
+  (#td: typedef t)
+  (#p: P.perm)
+  (#v: Ghost.erased t)
+  (#w: Ghost.erased ref0_v)
+  (#tbase: Type0)
+  (#r': Ghost.erased (R.ref tbase td.pcm))
+  (r: ref td)
+: ST (R.ref w.base td.pcm)
+    (HR.pts_to r p w `star`
+      r_pts_to r' v)
+    (fun r' -> HR.pts_to r p w `star`
+      R.pts_to r' v)
+    (tbase == w.base /\
+      t == w.t /\
+      td == w.td /\
+      Ghost.reveal r' == coerce_eq () w.ref
+    )
+    (fun r' ->
+    tbase == w.base /\
+      t == w.t /\
+      td == w.td /\
+      r' == coerce_eq () w.ref
+    )
+= let w0 = HR.read r in
+  let res : R.ref w.base td.pcm = coerce_eq () w0.ref in
+  rewrite (r_pts_to _ _) (R.pts_to res v);
+  return res
+
 let free
   #_ #_ #v r
 = rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
-  let w = HR.read r in
-  rewrite (R.pts_to _ _) (R.pts_to w.ref v);
+  let w = vpattern_replace_erased (HR.pts_to r _) in
+  let r' = read_ref r in
   rewrite (freeable r) (freeable0 r);
   let _ = gen_elim () in
-  hr_gather w r;
-  R.ref_free w.ref;
+  hr_gather (Ghost.reveal w) r;
+  R.ref_free r';
   drop (HR.pts_to _ _ _);
   return ()
 
+let get_ref
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (#p: P.perm)
+  (#v: t)
+  (#w: ref0_v)
+  (#tbase: Type0)
+  (#r': R.ref tbase td.pcm)
+  (r: ref td)
+: STGhost (R.ref w.base td.pcm) opened
+    (HR.pts_to r p w `star`
+      r_pts_to r' v)
+    (fun r' -> HR.pts_to r p w `star`
+      R.pts_to r' v)
+    (tbase == w.base /\
+      t == w.t /\
+      td == w.td /\
+      Ghost.reveal r' == coerce_eq () w.ref
+    )
+    (fun r' ->
+    tbase == w.base /\
+      t == w.t /\
+      td == w.td /\
+      r' == coerce_eq () w.ref
+    )
+= let res : R.ref w.base td.pcm = coerce_eq () w.ref in
+  rewrite (r_pts_to _ _) (R.pts_to res v);
+  res
+
+let pts_to_intro_rewrite
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (r: ref td)
+  (#p: P.perm)
+  (#w: ref0_v)
+  (#tbase: Type)
+  (r': R.ref tbase td.pcm)
+  (#v: t)
+  (v': Ghost.erased t)
+: STGhost unit opened
+    (HR.pts_to r p w `star` R.pts_to r' v)
+    (fun _ -> pts_to r v')
+    (pts_to_intro_precond r w r' /\
+      v == Ghost.reveal v'
+    )
+    (fun _ -> True)
+= pts_to_intro r p w r' v;
+  vpattern_rewrite (pts_to r) v'
+
 let mk_fraction_split_gen
   #_ #_ #td r v p p1 p2
 = rewrite (pts_to _ _) (pts_to0 r (mk_fraction td v p));
   let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
+  let r' = get_ref r in
   td.mk_fraction_split v p1 p2;
   td.mk_fraction_join v p1 p2;
   rewrite
     (R.pts_to _ _)
-    (R.pts_to w.ref (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)));
+    (R.pts_to r' (op td.pcm (td.mk_fraction v p1) (td.mk_fraction v p2)));
   R.split _ _ (td.mk_fraction v p1) (td.mk_fraction v p2);
   HR.share r;
-  rewrite (pts_to0 r (td.mk_fraction v p1)) (pts_to r (mk_fraction td v p1));
-  rewrite (pts_to0 r (td.mk_fraction v p2)) (pts_to r (mk_fraction td v p2))
+  pts_to_intro_rewrite r r' #(td.mk_fraction v p1) (mk_fraction td v p1);
+  pts_to_intro_rewrite r r' #(td.mk_fraction v p2) (mk_fraction td v p2)
 
 let mk_fraction_join
   #_ #_ #td r v p1 p2
 = rewrite (pts_to r (mk_fraction td v p1)) (pts_to0 r (mk_fraction td v p1));
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (R.pts_to _ _) (R.pts_to w.ref (td.mk_fraction v p1));
+  let r' = get_ref r in
   rewrite (pts_to r (mk_fraction td v p2)) (pts_to0 r (mk_fraction td v p2));
   let _ = gen_elim () in
   hr_gather w r;
-  rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to w.ref (td.mk_fraction v p2));
-  let _ = R.gather w.ref (td.mk_fraction v p1) _ in
+  rewrite (R.pts_to _ (mk_fraction _ _ p2)) (R.pts_to r' (td.mk_fraction v p2));
+  let _ = R.gather r' (mk_fraction td v p1) _ in
   td.mk_fraction_join v p1 p2;
-  rewrite (pts_to0 r _) (pts_to r _)
+  pts_to_intro_rewrite r r' _
 
 let r_unfocus (#opened:_)
   (#ta #ta' #tb #tc: Type)
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fsti b/ulib/experimental/Steel.ST.C.Types.Base.fsti
index c84f93aaf66..7c63b8ca038 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fsti
@@ -60,7 +60,6 @@ val mk_fraction_eq_unknown (#t: Type0) (td: typedef t) (v: t) (p: P.perm) : Lemm
   (ensures (v == unknown td))
 
 
-(*
 // To be extracted as: void*
 
 // FIXME: Currently, Karamel does not directly support
@@ -75,19 +74,16 @@ val void_ptr : Type0
 [@@noextract_to "krml"] // primitive
 val void_null: void_ptr
 
-[@@noextract_to "krml"] // proof-only
-val type_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot Type0
-val typedef_of_ptr (p: void_ptr { ~ (p == void_null) }) : GTot (typedef (type_of_ptr p))
-
 // To be extracted as: *t
 [@@noextract_to "krml"] // primitive
-let ptr (#t: Type) (td: typedef t) : Tot Type0 = (p: void_ptr { (~ (p == void_null)) ==> (type_of_ptr p == t /\ typedef_of_ptr p == td) })
+let ptr_gen (t: Type) : Tot Type0 = void_ptr
 [@@noextract_to "krml"] // primitive
-let null (#t: Type) (td: typedef t) : Tot (ptr td) = void_null
-*)
+let null_gen (t: Type) : Tot (ptr_gen t) = void_null
 
-val ptr (#t: Type) (td: typedef t) : Tot Type0
-val null (#t: Type) (td: typedef t) : Tot (ptr td)
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let ptr (#t: Type) (td: typedef t) : Tot Type0 = ptr_gen t
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let null (#t: Type) (td: typedef t) : Tot (ptr td) = null_gen t
 
 inline_for_extraction [@@noextract_to "krml"]
 let ref (#t: Type) (td: typedef t) : Tot Type0 = (p: ptr td { ~ (p == null td) })
diff --git a/ulib/experimental/Steel.ST.C.Types.Scalar.fst b/ulib/experimental/Steel.ST.C.Types.Scalar.fst
index 195a667375e..cf1d428a0c1 100644
--- a/ulib/experimental/Steel.ST.C.Types.Scalar.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Scalar.fst
@@ -93,17 +93,16 @@ let scalar_unique
 = rewrite (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1)));
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (r_pts_to _ (Some (Some v1, p1))) (R.pts_to w.ref (Some (Some v1, p1)));
+  let r' = get_ref r in
   rewrite (pts_to r _) (pts_to0 r (Some (Some v2, p2)));
   let _ = gen_elim () in
   hr_gather w r;
-  rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to w.ref (Some (Some v2, p2)));
-  let _ = R.gather w.ref (Some (Some v1, p1)) (Some (Some v2, p2)) in
-  R.split w.ref _ (Some (Some v1, p1)) (Some (Some v2, p2));
+  rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to r' (Some (Some v2, p2)));
+  let _ = R.gather r' (Some (Some v1, p1)) (Some (Some v2, p2)) in
+  R.split r' _ (Some (Some v1, p1)) (Some (Some v2, p2));
   HR.share r;
-  noop (); // FIXME: WHY WHY WHY?
-  rewrite (pts_to0 r (Some (Some v1, p1))) (pts_to r (mk_fraction (scalar _) (mk_scalar v1) p1));
-  rewrite (pts_to0 r (Some (Some v2, p2))) (pts_to r (mk_fraction (scalar _) (mk_scalar v2) p2))
+  pts_to_intro_rewrite r r' #(Some (Some v1, p1)) (mk_fraction (scalar _) (mk_scalar v1) p1);
+  pts_to_intro_rewrite r r' #(Some (Some v2, p2)) (mk_fraction (scalar _) (mk_scalar v2) p2)
 
 #pop-options
 
@@ -111,22 +110,16 @@ let read0
   #t #v #p r
 = rewrite (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p)));
   let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Some (Some (Ghost.reveal v), p)));
-  let v' = R.ref_read w.ref in
+  let r' = read_ref r in
+  let v' = R.ref_read r' in
   let Some (Some v0, _) = v' in
-  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v), p)));
-  rewrite (pts_to0 r (Some (Some (Ghost.reveal v), p))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v)) p));
+  pts_to_intro_rewrite r r' _;
   return v0
 
 let write
   #t #v r v'
 = rewrite (pts_to r _) (pts_to0 r (Ghost.reveal v));
   let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
-  R.ref_upd w.ref _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
-  rewrite (R.pts_to _ _) (r_pts_to w.ref (Some (Some (Ghost.reveal v'), P.full_perm)));
-  rewrite (pts_to0 r (Some (Some (Ghost.reveal v'), P.full_perm))) (pts_to r (mk_fraction (scalar t) (mk_scalar (Ghost.reveal v')) P.full_perm))
+  let r' = read_ref r in
+  R.ref_upd r' _ _ (R.base_fpu _ _ (Some (Some v', P.full_perm)));
+  pts_to_intro_rewrite r r' _
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
index 7b24d4d0a67..f6d1ae0df3a 100644
--- a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
@@ -129,16 +129,19 @@ let struct1
   );
 }
 
-
 let has_struct_field_gen
   (#field_t: eqtype)
   (fields: field_description_gen_t field_t)
-  (r: ref0_v (struct1 fields))
+  (r: ref0_v)
   (field: field_t)
-  (r': ref0_v (fields.fd_typedef field))
+  (r': ref0_v)
 : GTot prop
 = r'.base == r.base /\
-  r'.ref == R.ref_focus r.ref (S.struct_field (struct_field_pcm fields) field)
+  r.t == struct_t1 fields /\
+  r.td == struct1 fields /\
+  r'.t == fields.fd_type field /\
+  r'.td == fields.fd_typedef field /\
+  r'.ref == coerce_eq () (R.ref_focus r.ref (S.struct_field (struct_field_pcm fields) field))
 
 [@@__reduce__]
 let has_struct_field0
@@ -271,11 +274,10 @@ let ghost_struct_field_focus'
 = rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  let w' = vpattern_replace (HR.pts_to r' _) in
   rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   hr_gather w r;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let rr = get_ref r in
   let prf
     (f': field_t)
     (x: (fields.fd_type f'))
@@ -291,14 +293,13 @@ let ghost_struct_field_focus'
   let vf = S.field_to_struct_f (struct_field_pcm _) field (t_struct_get_field v field) in
   assert (composable (struct_pcm _) v' vf);
   assert (op (struct_pcm _) v' vf `FX.feq` v);
-  R.split w.ref _ v' vf;
-  R.gfocus w.ref (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
+  R.split rr _ v' vf;
+  R.gfocus rr (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
   hr_share r;
   hr_share r';
   rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r v') (pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v));
-  rewrite (R.pts_to _ _) (r_pts_to w'.ref (t_struct_get_field v field));
-  rewrite (pts_to0 r' (t_struct_get_field v field)) (pts_to r' (t_struct_get_field v field))
+  pts_to_intro_rewrite r rr _;
+  pts_to_intro_rewrite r' _ _
 
 module GHR = Steel.ST.GhostHigherReference
 
@@ -315,10 +316,12 @@ let ghost_struct_field'
 = rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let rr = get_ref r in
   let w' = {
     base = w.base;
-    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
+    t = fields.fd_type field;
+    td = fields.fd_typedef field;
+    ref = R.ref_focus rr (S.struct_field (struct_field_pcm (fields)) field);
   }
   in
   let gr' = GHR.alloc w' in
@@ -330,7 +333,7 @@ let ghost_struct_field'
   rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
   hr_share r;
   rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  pts_to_intro r _ _ rr _;
   ghost_struct_field_focus' r field r';
   r'
 
@@ -347,16 +350,18 @@ let struct_field'
   let _ = gen_elim () in
   let w = HR.read r in
   vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let rr = read_ref r in
   let w' = {
     base = w.base;
-    ref = R.ref_focus w.ref (S.struct_field (struct_field_pcm (fields)) field);
+    t = fields.fd_type field;
+    td = fields.fd_typedef field;
+    ref = R.ref_focus rr (S.struct_field (struct_field_pcm (fields)) field);
   }
   in
   let r' = HR.alloc w' in
   hr_share r;
   rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  pts_to_intro r _ _ rr _;
   ghost_struct_field_focus' r field r';
   return r'
 
@@ -383,11 +388,11 @@ let unstruct_field'
   rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   hr_gather w r;
-  rewrite (r_pts_to _ (Ghost.reveal v)) (R.pts_to w.ref (Ghost.reveal v));
+  let rr = get_ref r in
   rewrite (pts_to r' v') (pts_to0 r' v');
   let _ = gen_elim () in
   hr_gather w' r';
-  rewrite (r_pts_to _ (Ghost.reveal v')) (R.pts_to w'.ref (Ghost.reveal v'));
+  let rr' = get_ref r' in
   let prf
     (f': field_t)
     (x: (fields.fd_type f'))
@@ -402,11 +407,11 @@ let unstruct_field'
   let vf = S.field_to_struct_f (struct_field_pcm _) field v' in
   assert (composable (struct_pcm _) v vf);
   assert (op (struct_pcm _) v vf `FX.feq` t_struct_set_field field v' v);
-  let _ = r_unfocus w'.ref w.ref (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
-  let _ = R.gather w.ref (Ghost.reveal v) _ in
+  let _ = r_unfocus rr' rr (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
+  let _ = R.gather rr (Ghost.reveal v) _ in
   hr_share r;
   rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  rewrite (pts_to0 r _) (pts_to r _)
+  pts_to_intro_rewrite r rr _
 
 let full_struct_gen
   (#field_t: eqtype)
diff --git a/ulib/experimental/Steel.ST.C.Types.Union.fst b/ulib/experimental/Steel.ST.C.Types.Union.fst
index 216a05a74a5..e1f5e946059 100644
--- a/ulib/experimental/Steel.ST.C.Types.Union.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Union.fst
@@ -245,28 +245,32 @@ let full_union
   Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
 
 let has_union_field_gen
-  (#tn: Type0)
+  (tn: Type0)
   (#tf: Type0)
-  (#n: string)
+  (n: string)
   (#fields: field_description_t tf)
-  (r: ref0_v (union0 tn n fields))
+  (r: ref0_v)
   (field: field_t fields)
-  (r': ref0_v (fields.fd_typedef field))
+  (r': ref0_v)
 : GTot prop
 = r'.base == r.base /\
+  r.t == union_t0 tn n fields /\
+  r.td == union0 tn n fields /\
+  r'.t == fields.fd_type field /\
+  r'.td == fields.fd_typedef field /\
   r'.ref == R.ref_focus r.ref (U.union_field (union_field_pcm fields) (Some field))
 
 let has_union_field_gen_inj
-  (#tn: Type0)
+  (tn: Type0)
   (#tf: Type0)
-  (#n: string)
+  (n: string)
   (#fields: field_description_t tf)
-  (r: ref0_v (union0 tn n fields))
+  (r: ref0_v)
   (field: field_t fields)
-  (r1': ref0_v (fields.fd_typedef field))
-  (r2': ref0_v (fields.fd_typedef field))
+  (r1': ref0_v)
+  (r2': ref0_v)
 : Lemma
-  (requires (has_union_field_gen r field r1' /\ has_union_field_gen r field r2'))
+  (requires (has_union_field_gen tn n r field r1' /\ has_union_field_gen tn n r field r2'))
   (ensures (r1' == r2'))
 = ()
 
@@ -283,7 +287,7 @@ let has_union_field0
 = exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
     HR.pts_to r p w `star`
     HR.pts_to r' p' w' `star`
-    pure (has_union_field_gen w field w')
+    pure (has_union_field_gen tn n w field w')
   ))))
 
 let has_union_field
@@ -309,7 +313,7 @@ let has_union_field_dup
 #push-options "--z3rlimit 64"
 
 let has_union_field_inj
-  r field r1 r2
+  #_ #tn #_ #n r field r1 r2
 = rewrite (has_union_field r field r1) (has_union_field0 r field r1);
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
@@ -323,7 +327,7 @@ let has_union_field_inj
   rewrite (has_union_field0 r field r2) (has_union_field r field r2);
   let w' = vpattern_replace (HR.pts_to r1 _) in
   let w2' = vpattern_replace (HR.pts_to r2 _) in
-  has_union_field_gen_inj w field w' w2';
+  has_union_field_gen_inj tn n w field w' w2';
   vpattern_rewrite (HR.pts_to r2 _) w';
   rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
 
@@ -365,13 +369,14 @@ let ghost_union_field_focus
   rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   hr_gather w r;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let rr = get_ref r in
   let v' = U.field_to_union_f (union_field_pcm fields) (Some field) (union_get_field v field) in
   assert (v' `FX.feq` v);
-  R.gfocus w.ref (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
-  rewrite (R.pts_to _ _) (R.pts_to w'.ref (union_get_field v field));
+  R.gfocus rr (U.union_field (union_field_pcm fields) (Some field)) v (union_get_field v field);
+//  let rr' = get_ref r' in
   hr_share r';
-  rewrite (pts_to0 r' _) (pts_to r' _);
+//  pts_to_intro_rewrite r' rr' _ ;
+  pts_to_intro_rewrite r' _ _ ;
   rewrite (has_union_field0 r field r') (has_union_field r field r')
 
 let ghost_union_field
@@ -379,10 +384,12 @@ let ghost_union_field
 = rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let rr = get_ref r in
   let w' = {
     base = w.base;
-    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
+    t = fields.fd_type field;
+    td = fields.fd_typedef field;
+    ref = R.ref_focus rr (U.union_field (union_field_pcm (fields)) (Some field));
   }
   in
   let gr' = GHR.alloc w' in
@@ -394,7 +401,7 @@ let ghost_union_field
   rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
   hr_share r;
   rewrite (has_union_field0 r field r') (has_union_field r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  pts_to_intro r _ _ rr _;
   ghost_union_field_focus r field r';
   r'
 
@@ -414,16 +421,18 @@ let union_field'
   let _ = gen_elim () in
   let w = HR.read r in
   vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (r_pts_to w.ref (Ghost.reveal v));
+  let rr = read_ref r in
   let w' = {
     base = w.base;
-    ref = R.ref_focus w.ref (U.union_field (union_field_pcm (fields)) (Some field));
+    t = fields.fd_type field;
+    td = fields.fd_typedef field;
+    ref = R.ref_focus rr (U.union_field (union_field_pcm (fields)) (Some field));
   }
   in
   let r' = HR.alloc w' in
   hr_share r;
   rewrite (has_union_field0 r field r') (has_union_field r field r');
-  rewrite (pts_to0 r (Ghost.reveal v)) (pts_to r v);
+  pts_to_intro r _ _ rr _;
   ghost_union_field_focus r field r';
   return r'
 
@@ -443,14 +452,14 @@ let ununion_field
   let w = vpattern_replace (HR.pts_to r _) in
   let w' = vpattern_replace (HR.pts_to r' _) in
   rewrite (pts_to r' v') (pts_to0 r' v');
-  let _= gen_elim () in
+  let _ = gen_elim () in
   hr_gather w' r';
-  rewrite (r_pts_to _ _) (R.pts_to w'.ref (Ghost.reveal v'));
-  let _ = r_unfocus w'.ref w.ref (coerce_eq () (U.union_field (union_field_pcm fields) (Some field))) _ in
+  let rr : R.ref w.base (union0 tn n fields).pcm = coerce_eq () w.ref in
+  let rr' = get_ref r' in
+  let x = r_unfocus rr' rr (coerce_eq () (U.union_field (union_field_pcm fields) (Some field))) _ in
   hr_share r;
   rewrite (has_union_field0 r field r') (has_union_field r field r');
-  rewrite (R.pts_to _ _) (R.pts_to w.ref (union_set_field tn n fields field (Ghost.reveal v')));
-  rewrite (pts_to0 r (union_set_field tn n fields field (Ghost.reveal v'))) (pts_to r (union_set_field tn n fields field (Ghost.reveal v')))
+  pts_to_intro_rewrite r rr #x _
 
 [@@noextract_to "krml"] // primitive
 let union_switch_field'
@@ -470,10 +479,10 @@ let union_switch_field'
   let _ = gen_elim () in
   let w = HR.read r in
   vpattern_rewrite (HR.pts_to r _) w;
-  rewrite (r_pts_to _ _) (R.pts_to w.ref (Ghost.reveal v));
+  let rr = read_ref r in
   let v' : union_t0 tn n fields = U.field_to_union_f (union_field_pcm fields) (Some field) (fields.fd_typedef field).uninitialized in
-  R.ref_upd w.ref _ _ (R.base_fpu (union_pcm tn n fields) _ v');
-  rewrite (pts_to0 r v') (pts_to r v');
+  R.ref_upd rr _ _ (R.base_fpu (union_pcm tn n fields) _ v');
+  pts_to_intro r _ _ rr v' ;
   let r' = union_field' r field in
   rewrite (pts_to r' _) (pts_to r' (uninitialized (fields.fd_typedef field)));
   return r'

From b9116697e565a6db46323a8f2a5b65dee9b5394b Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Thu, 16 Mar 2023 20:31:10 -0700
Subject: [PATCH 466/513] extract ptr_gen, null_gen instead of ptr, null

---
 .../steel/arraystructs/my_fstar/ExtractSteelC.fst   | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index 142b9d4b10d..842cc5dfdfc 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -109,8 +109,12 @@ let my_types_without_decay () =
       TBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg; _], p) when
-    Syntax.string_of_mlpath p = "Steel.ST.C.Types.Base.ptr"
-    || Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr"
+      Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr"
+    ->
+      TBuf (translate_type_without_decay env arg)
+
+  | MLTY_Named ([arg], p) when
+      Syntax.string_of_mlpath p = "Steel.ST.C.Types.Base.ptr_gen"
     ->
       TBuf (translate_type_without_decay env arg)
 
@@ -223,7 +227,10 @@ let my_exprs () = register_pre_translate_expr begin fun env e ->
 
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, t::_)}, [_ (* pcm *)])
     when string_of_mlpath p = "Steel.C.Reference.null"
-    || string_of_mlpath p = "Steel.ST.C.Types.Base.null"
+    -> EBufNull (translate_type env t)
+
+  | MLE_TApp ({expr=MLE_Name p}, [t]) when
+      string_of_mlpath p = "Steel.ST.C.Types.Base.null_gen"
     -> EBufNull (translate_type env t)
 
 (* END support for the Steel null pointer *)

From db58eaaa2eb18970d49514deca2a9b533a1b0d70 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 09:47:00 -0700
Subject: [PATCH 467/513] restore LList example (with void*)

---
 examples/steel/arraystructs/LList.fst     | 216 +++++++++-------------
 examples/steel/arraystructs/Makefile      |   2 +-
 examples/steel/arraystructs/lib/steel_c.h |   2 +-
 3 files changed, 93 insertions(+), 127 deletions(-)

diff --git a/examples/steel/arraystructs/LList.fst b/examples/steel/arraystructs/LList.fst
index 7d892c536df..f14025af0f4 100644
--- a/examples/steel/arraystructs/LList.fst
+++ b/examples/steel/arraystructs/LList.fst
@@ -1,5 +1,6 @@
 module LList
-open Steel.C.Types
+open Steel.ST.GenElim
+open Steel.ST.C.Types
 
 module U32 = FStar.UInt32
 
@@ -19,117 +20,83 @@ let _ = define_struct0 cell_n "LList.cell" cell_fields
 inline_for_extraction noextract
 let cell = struct0 cell_n "LList.cell" cell_fields
 
-let rec llist' (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop (decreases (Ghost.reveal l)) =
+[@@__reduce__]
+let llist_nil (p: ptr cell) : Tot vprop =
+  pure (p == null _)
+
+[@@__reduce__]
+let llist_cons (p: ptr cell) (a: U32.t) (q: Ghost.erased (list U32.t)) (llist: (ptr cell -> (l: Ghost.erased (list U32.t) { List.Tot.length l < List.Tot.length (a :: q) }) -> Tot vprop)) : Tot vprop =
+  exists_ (fun (p1: ref cell) -> exists_ (fun (p2: ptr cell) ->
+    pts_to p1 (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p2 <: void_ptr)) (unknown cell))) `star`
+    llist p2 q `star`
+    freeable p1 `star`
+    pure (p == p1)
+  ))
+
+let rec llist (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop (decreases (List.Tot.length l)) =
   match Ghost.reveal l with
-  | [] -> pure (p == null _)
-  | a :: q ->
-    h_exists (fun (_: squash (~ (p == null _) /\ freeable p)) ->
-      h_exists (fun (p' : ptr cell) ->
-      pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
-      llist' p' q
-    ))
-
-[@@__steel_reduce__]
-let llist (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop = VUnit ({
-  hp = hp_of (llist' p l);
-  t = _;
-  sel = trivial_selector _;
-})
-
-let change_slprop_by_norm
-  (#opened: _) (p q: vprop)
-: SteelGhost unit opened p (fun _ -> q) (fun _ -> normalize (hp_of p == hp_of q)) (fun _ _ _ -> True)
-= rewrite_slprop p q (fun _ -> ())
-
-let llist_intro_nil (#opened: _) (p: ptr cell) : SteelGhost unit opened
-  emp
-  (fun _ -> llist p [])
-  (fun _ -> p == null _)
-  (fun _ _ _ -> True)
-= intro_pure (p == null _);
-  change_slprop_by_norm
-    (pure (p == null _))
-    (llist p [])
-
-let llist_intro_cons (#opened: _) (p: ref cell) (s: Ghost.erased (typeof cell)) (a: U32.t) (p' : ptr cell) (q: Ghost.erased (list U32.t)) : SteelGhost unit opened
-  (pts_to p s `star` llist p' q)
-  (fun _ -> llist p (a :: q))
-  (fun _ ->
-    freeable p /\
-    s `struct_eq` struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))
-  )
-  (fun _ _ _ -> True)
-= change_equal_slprop (pts_to p s) (pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))));
-  intro_exists p' (fun (p' : ptr cell) -> pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
-      llist p' q
-  );
-  intro_exists () (fun (_: squash (~ (p == null _) /\ freeable p)) ->
-    h_exists (fun (p' : ptr cell) -> pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
-      llist p' q
-  ));
-  change_slprop_by_norm
-    (h_exists _)
-    (llist p (a :: q))
-
-let llist_elim_nil (#opened: _) (p: ptr cell) (l: Ghost.erased (list U32.t)) : SteelGhost unit opened
-  (llist p l)
-  (fun _ -> emp)
-  (fun _ -> Nil? l)
-  (fun _ _ _ -> p == null _)
-= change_equal_slprop (llist p l) (llist p []);
-  change_slprop_by_norm
-    (llist p [])
-    (pure (p == null _));
-  elim_pure _
-
-let llist_elim_cons (#opened: _) (p: ptr cell) (l: Ghost.erased (list U32.t)) (sq: squash (Cons? l))
-: SteelGhostT (p': Ghost.erased (ptr cell) { ~ (p == null _) /\ freeable p }) opened
-  (llist p l)
-  (fun p' ->
-    pts_to p (struct_set_field "hd" (mk_scalar (List.Tot.hd l)) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
-    llist p' (List.Tot.tl l)
-  )
-= let a :: q = Ghost.reveal l in
-  change_equal_slprop (llist p l) (llist p (a :: q));
-  change_slprop_by_norm
-    (llist p (a :: q))
-    (h_exists (fun (_: squash (~ (p == null _) /\ freeable p)) ->
-      h_exists (fun (p' : ptr cell) ->
-      pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))) `star`
-      llist p' q
-    )));
-  let prf : Ghost.erased (squash (~ (p == null _) /\ freeable p)) = witness_exists () in
-  let _ = Ghost.reveal prf in
-  let p1 = witness_exists () in
-  let p' : (p': Ghost.erased (ptr cell) { ~ (p == null _) /\ freeable p }) = p1 in
-  change_equal_slprop
-    (pts_to p (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p1 <: void_ptr)) (unknown cell))))
-    (pts_to p (struct_set_field "hd" (mk_scalar (List.Tot.hd l)) (struct_set_field "tl" (mk_scalar (p' <: void_ptr)) (unknown cell))));
-  change_equal_slprop
-    (llist _ q)
-    (llist p' (List.Tot.tl l));
-  p'
-
-[@@__steel_reduce__]
-let pllist
+  | [] -> llist_nil p
+  | a :: q -> llist_cons p a q llist
+
+let intro_llist_cons
+  (#opened: _)
+  (p1: ref cell) (#v1: Ghost.erased (typeof cell)) (p2: ptr cell) (a: U32.t) (q: Ghost.erased (list U32.t))
+: STGhost unit opened
+    (pts_to p1 v1 `star`
+      llist p2 q `star`
+      freeable p1
+    )
+    (fun _ -> llist p1 (a :: q))
+    (Ghost.reveal v1 `struct_eq` struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p2 <: void_ptr)) (unknown cell)))
+    (fun _ -> True)
+= noop ();
+  rewrite_with_tactic (llist_cons p1 a q llist) (llist p1 (a :: q))
+
+let elim_llist_cons
+  (#opened: _)
+  (p1: ptr cell) (a: U32.t) (q: Ghost.erased (list U32.t))
+: STGhostT (p2: Ghost.erased (ptr cell) { ~ (p1 == null _) }) opened
+    (llist p1 (a :: q))
+    (fun p2 ->
+      pts_to p1 (struct_set_field "hd" (mk_scalar a) (struct_set_field "tl" (mk_scalar (p2 <: void_ptr)) (unknown cell))) `star`
+      llist p2 q `star`
+      freeable p1
+    )
+= rewrite_with_tactic (llist p1 (a :: q)) (llist_cons p1 a q llist);
+  let _ = gen_elim () in
+  let p2' = vpattern_erased (fun x -> llist x q) in
+  let p2 : (p2: Ghost.erased (ptr cell) { ~ (p1 == null _) }) = p2' in
+  vpattern_rewrite (fun x -> llist x q) p2;
+  rewrite (pts_to _ _) (pts_to _ _);
+  rewrite (freeable _) (freeable _);
+  _
+
+[@@__reduce__]
+let pllist0
   (p: ref (scalar (ptr cell)))
   (l: Ghost.erased (list U32.t))
 : Tot vprop
-= h_exists (fun (pc: ptr cell) ->
+= exists_ (fun (pc: ptr cell) ->
     pts_to p (mk_scalar pc) `star`
     llist pc l
   )
 
+let pllist
+  (p: ref (scalar (ptr cell)))
+  (l: Ghost.erased (list U32.t))
+: Tot vprop
+= pllist0 p l
+
 let pllist_get
   (#l: Ghost.erased (list U32.t))
   (p: ref (scalar (ptr cell)))
-: SteelT (ptr cell)
+: STT (ptr cell)
     (pllist p l)
     (fun pc -> pts_to p (mk_scalar (Ghost.reveal pc)) `star` llist pc l)
-= let _ = witness_exists () in
+= rewrite (pllist p l) (pllist0 p l);
+  let _ = gen_elim () in
   let pc = read p in
-  change_equal_slprop (pts_to p _) (pts_to p (mk_scalar (Ghost.reveal pc)));
-  change_equal_slprop (llist _ _) (llist pc l);
+  vpattern_rewrite (fun x -> llist x l) pc;
   return pc
 
 let pllist_put
@@ -137,37 +104,30 @@ let pllist_put
   (#l: Ghost.erased (list U32.t))
   (p: ref (scalar (ptr cell)))
   (pc: ptr cell)
-: Steel unit
+: ST unit
     (pts_to p v `star` llist pc l)
     (fun _ -> pllist p l)
-    (fun _ -> full (scalar (ptr cell)) v)
-    (fun _ _ _ -> True)
+    (full (scalar (ptr cell)) v)
+    (fun _ -> True)
 = write p pc;
-  intro_exists pc (fun (pc: ptr cell) ->
-    pts_to p (mk_scalar pc) `star`
-    llist pc l
-  );
-  change_slprop_by_norm
-    (h_exists (fun (pc: ptr cell) ->
-      pts_to p (mk_scalar pc) `star`
-      llist pc l
-    ))
-    (pllist p l)
+  rewrite (pllist0 p l) (pllist p l)
 
 let push
   (#l: Ghost.erased (list U32.t))
   (a: U32.t)
   (p: ref (scalar (ptr cell)))
-: SteelT bool
+: STT bool
     (pllist p l)
     (fun b -> pllist p (if b then a :: l else l))
 = let c = alloc cell in
   if is_null c
   then begin
-    assert_null c;
+    rewrite (pts_to_or_null _ _) emp;
+    rewrite (freeable_or_null _) emp;
     return false
   end else begin
-    assert_not_null c;
+    rewrite (pts_to_or_null _ _) (pts_to c (uninitialized cell));
+    rewrite (freeable_or_null c) (freeable c);
     let p_tl = pllist_get p in
     let c_hd = struct_field c "hd" in
     let c_tl = struct_field c "tl" in
@@ -175,8 +135,10 @@ let push
     write c_tl p_tl;
     unstruct_field c "tl" c_tl;
     unstruct_field c "hd" c_hd;
-    llist_intro_cons c _ a p_tl _;
+    intro_llist_cons c p_tl a l;
     pllist_put p c;
+    drop (has_struct_field c "hd" _);
+    drop (has_struct_field _ _ _);
     return true
   end
 
@@ -184,31 +146,35 @@ let pop
   (#l: Ghost.erased (list U32.t))
   (p: ref (scalar (ptr cell)))
   (sq: squash (Cons? l))
-: Steel U32.t
+: ST U32.t
     (pllist p l)
     (fun _ -> pllist p (List.Tot.tl l))
-    (fun _ -> True)
-    (fun _ res _ -> res == List.Tot.hd l)
-= let c = pllist_get p in
-  let _ = llist_elim_cons c _ () in
+    (True)
+    (fun res -> res == List.Tot.hd l)
+= rewrite (pllist p l) (pllist p (List.Tot.hd l :: List.Tot.tl l));
+  let c = pllist_get p in
+  let _ = elim_llist_cons c (List.Tot.hd l) (List.Tot.tl l) in
   let c_hd = struct_field c "hd" in
   let c_tl = struct_field c "tl" in
   let res = read c_hd in
   let p_tl = read c_tl in
+  vpattern_rewrite (fun x -> llist x _) p_tl;
   unstruct_field c "tl" c_tl;
   unstruct_field c "hd" c_hd;
   free c;
-  change_equal_slprop (llist _ _) (llist p_tl (List.Tot.tl l));
   pllist_put p p_tl;
+  drop (has_struct_field c "hd" _);
+  drop (has_struct_field _ _ _);
   return res
 
 let init
   (#v: Ghost.erased (scalar_t (ptr cell)))
   (r: ref (scalar (ptr cell)))
-: Steel unit
+: ST unit
     (pts_to r v)
     (fun _ -> pllist r [])
-    (fun _ -> full (scalar (ptr cell)) v)
-    (fun _ _ _ -> True)
-= llist_intro_nil (null _);
+    (full (scalar (ptr cell)) v)
+    (fun _ -> True)
+= noop ();
+  rewrite (llist_nil (null _)) (llist (null _) []);
   pllist_put r (null _)
diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 84c5ea741d5..d0385857933 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -28,7 +28,7 @@ FSTAR_OPTIONS = --cache_checked_modules \
 
 FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 
-ALL_SOURCE_FILES = $(filter-out LList.fst,$(wildcard *.fst *.fsti))
+ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
 NO_EXTRACT_MODULES=PointStruct HaclExample ScalarUnion
 EXTRACT_SOURCE_FILES = $(filter-out $(addsuffix .fst,$(NO_EXTRACT_MODULES)),$(ALL_SOURCE_FILES))
 
diff --git a/examples/steel/arraystructs/lib/steel_c.h b/examples/steel/arraystructs/lib/steel_c.h
index 9059f8b1b5b..d8a2e116c1a 100644
--- a/examples/steel/arraystructs/lib/steel_c.h
+++ b/examples/steel/arraystructs/lib/steel_c.h
@@ -5,6 +5,6 @@
 // Ideally, it should be empty, and its contents should be added to
 // krmllib.h
 
-typedef void* Steel_C_Types_void_ptr;
+typedef void* Steel_ST_C_Types_Base_void_ptr;
 
 #endif // ndef __STEEL_C

From fc65b5d6d34077b5ce89c24b3aedbad67b2815d2 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 10:22:48 -0700
Subject: [PATCH 468/513] rewrite pcm

---
 .../experimental/Steel.ST.C.Model.Rewrite.fst | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Rewrite.fst

diff --git a/ulib/experimental/Steel.ST.C.Model.Rewrite.fst b/ulib/experimental/Steel.ST.C.Model.Rewrite.fst
new file mode 100644
index 00000000000..1517ec020d8
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Rewrite.fst
@@ -0,0 +1,64 @@
+module Steel.ST.C.Model.Rewrite
+
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+
+module P = FStar.PCM
+
+noeq
+type rewrite_elts (from: Type) (to: Type) = {
+  rewrite_from_to : (from -> Tot to);
+  rewrite_to_from: (to -> Tot from);
+  rewrite_equiv : squash (
+    (forall (x: from) . rewrite_to_from (rewrite_from_to x) == x) /\
+    (forall (y: to) . rewrite_from_to (rewrite_to_from y) == y)
+  );
+}
+
+let fstar_rewrite_pcm
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+: Tot (P.pcm to)
+= let fp = fstar_pcm_of_pcm p in
+  {
+    P.p = {
+      P.composable = (fun y1 y2 -> composable p (rewrite.rewrite_to_from y1) (rewrite.rewrite_to_from y2));
+      P.op = (fun y1 y2 -> rewrite.rewrite_from_to (op p (rewrite.rewrite_to_from y1) (rewrite.rewrite_to_from y2)));
+      P.one = rewrite.rewrite_from_to (one p);
+    };
+    P.comm = (fun _ _ -> ());
+    P.assoc = (fun _ _ _ -> ());
+    P.assoc_r = (fun _ _ _ -> ());
+    P.is_unit = (fun _ -> ());
+    P.refine = (fun y -> p_refine p (rewrite.rewrite_to_from y));
+  }
+
+let rewrite_pcm
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+: Tot (pcm to)
+= let fp = fstar_pcm_of_pcm p in
+  pcm_of_fstar_pcm (fstar_rewrite_pcm p rewrite)
+
+let rewrite_iso
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+: Tot (isomorphism p (rewrite_pcm p rewrite))
+= mkisomorphism
+    (mkmorphism
+      rewrite.rewrite_from_to
+      ()
+      (fun _ _ -> ())
+    )
+    (mkmorphism
+      rewrite.rewrite_to_from
+      ()
+      (fun _ _ -> ())
+    )
+    ()
+    ()
+    (fun _ -> ())
+    (fun _ -> ())

From 14b16bfa32a1c957cedebef374f17029e2ac1e36 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 10:32:57 -0700
Subject: [PATCH 469/513] rewrite typedefs

---
 .../experimental/Steel.ST.C.Types.Rewrite.fst | 26 +++++++++++++++++++
 .../Steel.ST.C.Types.Rewrite.fsti             |  2 ++
 2 files changed, 28 insertions(+)
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Rewrite.fst
 create mode 100644 ulib/experimental/Steel.ST.C.Types.Rewrite.fsti

diff --git a/ulib/experimental/Steel.ST.C.Types.Rewrite.fst b/ulib/experimental/Steel.ST.C.Types.Rewrite.fst
new file mode 100644
index 00000000000..118146709e9
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Rewrite.fst
@@ -0,0 +1,26 @@
+module Steel.ST.C.Types.Rewrite
+open Steel.ST.Util
+
+friend Steel.ST.C.Types.Base
+open Steel.ST.C.Types.Base
+
+module RW = Steel.ST.C.Model.Rewrite
+
+let rewrite_typedef
+  (#from #to: Type)
+  (td: typedef from)
+  (rewrite: RW.rewrite_elts from to)
+: Tot (typedef to)
+= {
+    pcm = RW.rewrite_pcm td.pcm rewrite;
+    fractionable = (fun y -> td.fractionable (rewrite.rewrite_to_from y));
+    mk_fraction = (fun y p -> rewrite.rewrite_from_to (td.mk_fraction (rewrite.rewrite_to_from y) p));
+    mk_fraction_full = (fun y -> td.mk_fraction_full (rewrite.rewrite_to_from y));
+    mk_fraction_compose = (fun y p1 p2 -> td.mk_fraction_compose (rewrite.rewrite_to_from y) p1 p2);
+    fractionable_one = ();
+    mk_fraction_one = (fun p -> td.mk_fraction_one p);
+    uninitialized = rewrite.rewrite_from_to td.uninitialized;
+    mk_fraction_split = (fun y p1 p2 -> td.mk_fraction_split (rewrite.rewrite_to_from y) p1 p2);
+    mk_fraction_join = (fun y p1 p2 -> td.mk_fraction_join (rewrite.rewrite_to_from y) p1 p2);
+    mk_fraction_eq_one = (fun y p -> td.mk_fraction_eq_one (rewrite.rewrite_to_from y) p);
+  }
diff --git a/ulib/experimental/Steel.ST.C.Types.Rewrite.fsti b/ulib/experimental/Steel.ST.C.Types.Rewrite.fsti
new file mode 100644
index 00000000000..8deb566e255
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.Rewrite.fsti
@@ -0,0 +1,2 @@
+module Steel.ST.C.Types.Rewrite
+

From 4e597d0440e7a5de25f797facc04dd4680967848 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 11:41:46 -0700
Subject: [PATCH 470/513] specify user structs

---
 ulib/experimental/Steel.ST.C.Types.Base.fst   |   2 +
 ulib/experimental/Steel.ST.C.Types.Base.fsti  |   8 +
 ulib/experimental/Steel.ST.C.Types.Fields.fst |   2 -
 .../experimental/Steel.ST.C.Types.Fields.fsti |   8 -
 .../Steel.ST.C.Types.Struct.Aux.fst           |   8 -
 .../Steel.ST.C.Types.Struct.Aux.fsti          |   9 +
 .../Steel.ST.C.Types.UserStruct.fsti          | 238 ++++++++++++++++++
 7 files changed, 257 insertions(+), 18 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Types.UserStruct.fsti

diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fst b/ulib/experimental/Steel.ST.C.Types.Base.fst
index 202e0b11456..c2e1dbae09f 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fst
@@ -506,3 +506,5 @@ let r_unfocus (#opened:_)
   R.unfocus r1 r' l x;
   let x' = vpattern_replace_erased (R.pts_to r') in
   x'
+
+irreducible let norm_field_attr = ()
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fsti b/ulib/experimental/Steel.ST.C.Types.Base.fsti
index 7c63b8ca038..ccdb7702199 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fsti
@@ -245,3 +245,11 @@ val mk_fraction_join
 : STGhostT unit opened
   (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
   (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
+
+val norm_field_attr : unit
+
+noextract
+let norm_field_steps = [
+  delta_attr [`%norm_field_attr];
+  iota; zeta; primops;
+]
diff --git a/ulib/experimental/Steel.ST.C.Types.Fields.fst b/ulib/experimental/Steel.ST.C.Types.Fields.fst
index df9f7f56d0c..081c9bd71bb 100644
--- a/ulib/experimental/Steel.ST.C.Types.Fields.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Fields.fst
@@ -2,5 +2,3 @@ module Steel.ST.C.Types.Fields
 
 let field_t_nil = unit
 let field_t_cons _ _ _ = unit
-
-irreducible let norm_field_attr = ()
diff --git a/ulib/experimental/Steel.ST.C.Types.Fields.fsti b/ulib/experimental/Steel.ST.C.Types.Fields.fsti
index 4922c665623..9371f709878 100644
--- a/ulib/experimental/Steel.ST.C.Types.Fields.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Fields.fsti
@@ -8,14 +8,6 @@ val field_t_nil: Type0
 [@@noextract_to "krml"] // primitive
 val field_t_cons (fn: Type0) (ft: Type0) (fc: Type0): Type0
 
-val norm_field_attr : unit
-
-noextract
-let norm_field_steps = [
-  delta_attr [`%norm_field_attr];
-  iota; zeta; primops;
-]
-
 inline_for_extraction [@@noextract_to "krml"; norm_field_attr]
 noeq
 type field_description_t (t: Type0) : Type u#1 = {
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
index f6d1ae0df3a..bf2cf2af442 100644
--- a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
@@ -9,14 +9,6 @@ module P = Steel.FractionalPermission
 module R = Steel.ST.C.Model.Ref
 module HR = Steel.ST.HigherReference
 
-[@@noextract_to "krml"]
-noeq
-type field_description_gen_t (field_t: eqtype) : Type u#1 = {
-  fd_nonempty: squash (exists (f: field_t) . True);
-  fd_type: (field_t -> Type0);
-  fd_typedef: ((s: field_t) -> Tot (typedef (fd_type s)));
-}
-
 module S = Steel.ST.C.Model.Struct
 
 [@@noextract_to "krml"] // proof-only
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti
index c25b145f274..fd77470e287 100644
--- a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fsti
@@ -2,3 +2,12 @@ module Steel.ST.C.Types.Struct.Aux
 include Steel.ST.C.Types.Base
 
 // This module is `friend`ed by Steel.ST.C.Types.Struct and Steel.ST.C.Types.Array
+
+[@@noextract_to "krml"; norm_field_attr]
+inline_for_extraction
+noeq
+type field_description_gen_t (field_t: eqtype) : Type u#1 = {
+  fd_nonempty: squash (exists (f: field_t) . True);
+  fd_type: (field_t -> Type0);
+  fd_typedef: ((s: field_t) -> Tot (typedef (fd_type s)));
+}
diff --git a/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti b/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti
new file mode 100644
index 00000000000..39f1e10561e
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti
@@ -0,0 +1,238 @@
+module Steel.ST.C.Types.UserStruct
+open Steel.ST.Util
+open Steel.ST.C.Types.Struct.Aux
+
+module Set = FStar.Set
+
+(* This library allows the user to define their own struct type, with
+a constructor from field values, and a destructor to field values for
+each field. This may be necessary for recursive structs *)
+
+[@@noextract_to "krml"]
+let field_t (s: Set.set string) : Tot eqtype =
+  (f: string { Set.mem f s })
+
+[@@noextract_to "krml"; norm_field_attr]
+inline_for_extraction // for field_desc.fd_type
+noeq
+type struct_def (t: Type) = {
+  fields: Set.set string;
+  field_desc: field_description_gen_t (field_t fields);
+  mk: ((f: field_t fields) -> Tot (field_desc.fd_type f)) -> Tot t;
+  get: (t -> (f: field_t fields) -> Tot (field_desc.fd_type f));
+  get_mk: (phi: ((f: field_t fields) -> Tot (field_desc.fd_type f))) -> (f: field_t fields) -> Lemma
+    (get (mk phi) f == phi f);
+  extensionality: (x1: t) -> (x2: t) -> ((f: field_t fields) -> Lemma (get x1 f == get x2 f)) -> Lemma (x1 == x2);
+}
+
+let nonempty_set_nonempty_type (x: string) (s: Set.set string) : Lemma
+  (requires (x `Set.mem` s))
+  (ensures (exists (x: field_t s) . True))
+= Classical.exists_intro (fun (_: field_t s) -> True) x
+
+[@@noextract_to "krml"]
+let set_aux
+  (#t: Type) (sd: struct_def t) (x: t) (f: field_t sd.fields) (v: sd.field_desc.fd_type f) (f': field_t sd.fields)
+: Tot (sd.field_desc.fd_type f')
+= if f = f' then v else sd.get x f'
+
+[@@noextract_to "krml"]
+let set (#t: Type) (sd: struct_def t) (x: t) (f: field_t sd.fields) (v: sd.field_desc.fd_type f) : Tot t =
+  sd.mk (set_aux sd x f v)
+
+[@@noextract_to "krml"]
+val struct_typedef
+  (#t: Type)
+  (sd: struct_def t)
+: Tot (typedef t)
+
+val has_struct_field
+  (#t: Type)
+  (#sd: struct_def t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r': ref (sd.field_desc.fd_typedef field))
+: Tot vprop
+
+val has_struct_field_dup
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r': ref (sd.field_desc.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field r field r')
+    (fun _ -> has_struct_field r field r' `star` has_struct_field r field r')
+
+val has_struct_field_inj
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r1 r2: ref (sd.field_desc.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field r field r1 `star` has_struct_field r field r2)
+    (fun _ -> has_struct_field r field r1 `star` has_struct_field r field r2 `star` ref_equiv r1 r2)
+
+val has_struct_field_equiv_from
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (r1: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r': ref (sd.field_desc.fd_typedef field))
+  (r2: ref (struct_typedef sd))
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` has_struct_field r1 field r')
+    (fun _ -> ref_equiv r1 r2 `star` has_struct_field r2 field r')
+
+val has_struct_field_equiv_to
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r1' r2': ref (sd.field_desc.fd_typedef field))
+: STGhostT unit opened
+    (ref_equiv r1' r2' `star` has_struct_field r field r1')
+    (fun _ -> ref_equiv r1' r2' `star` has_struct_field r field r2')
+
+val ghost_struct_field_focus
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r': ref (sd.field_desc.fd_typedef field))
+: STGhostT unit opened
+    (has_struct_field r field r' `star` pts_to r v)
+    (fun _ -> has_struct_field r field r' `star` pts_to r (set sd v field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to r' (sd.get v field))
+
+val ghost_struct_field
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+: STGhostT (Ghost.erased (ref (sd.field_desc.fd_typedef field))) opened
+    (pts_to r v)
+    (fun r' -> has_struct_field r field r' `star` pts_to r (set sd v field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to r' (sd.get v field))
+
+[@@noextract_to "krml"] // primitive
+val struct_field0
+  (#t: Type)
+  (t': Type0)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (td': typedef t' {
+    t' ==  sd.field_desc.fd_type field /\
+    td' == sd.field_desc.fd_typedef field
+  })
+: STT (ref td')
+    (pts_to r v)
+    (fun r' -> has_struct_field r field r' `star` pts_to r (set sd v field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to r' (sd.get v field))
+
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let struct_field
+  (#t: Type)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+: STT (ref #(norm norm_field_steps (sd.field_desc.fd_type field)) (sd.field_desc.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> pts_to r (set sd v field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to #(norm norm_field_steps (sd.field_desc.fd_type field)) r' (sd.get v field) `star` has_struct_field r field r')
+= struct_field0
+    (norm norm_field_steps (sd.field_desc.fd_type field))
+    r
+    field
+    (sd.field_desc.fd_typedef field)
+
+val unstruct_field
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (#v': Ghost.erased (sd.field_desc.fd_type field))
+  (r': ref (sd.field_desc.fd_typedef field))
+: STGhost unit opened
+    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun _ -> has_struct_field r field r' `star` pts_to r (set sd v field v'))
+    (
+      sd.get v field == unknown (sd.field_desc.fd_typedef field)
+    )
+    (fun _ -> True)
+
+let unstruct_field_alt
+  (#opened: _)
+  (#t: Type)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (#v': Ghost.erased (sd.field_desc.fd_type field))
+  (r': ref (sd.field_desc.fd_typedef field))
+: STGhost (Ghost.erased t) opened
+    (has_struct_field r field r' `star` pts_to r v `star` pts_to r' v')
+    (fun s' -> has_struct_field r field r' `star` pts_to r s')
+    (
+      sd.get v field == unknown (sd.field_desc.fd_typedef field)
+    )
+    (fun s' -> Ghost.reveal s' == set sd v field v')
+= unstruct_field r field r';
+  _
+
+val fractionable_struct
+  (#t: Type)
+  (sd: struct_def t)
+  (s: t)
+: Lemma
+  (fractionable (struct_typedef sd) s <==> (forall field . fractionable (sd.field_desc.fd_typedef field) (sd.get s field)))
+  [SMTPat (fractionable (struct_typedef sd) s)]
+
+module P = Steel.FractionalPermission
+
+val mk_fraction_struct
+  (#t: Type)
+  (sd: struct_def t)
+  (s: t)
+  (p: P.perm)
+  (field: field_t sd.fields)
+: Lemma
+  (requires (fractionable (struct_typedef sd) s))
+  (ensures (sd.get (mk_fraction (struct_typedef sd) s p) field == mk_fraction (sd.field_desc.fd_typedef field) (sd.get s field) p))
+  [SMTPat (sd.get (mk_fraction (struct_typedef sd) s p) field)]
+
+(*
+val mk_fraction_struct_recip
+  (#tn: Type0)
+  (#tf: Type0)
+  (#n: string)
+  (#fields: nonempty_field_description_t tf)
+  (s: struct_t0 tn n fields)
+  (p: P.perm)
+: Ghost (struct_t0 tn n fields)
+  (requires (
+    (forall field . exists v . fractionable (fields.fd_typedef field) v /\ struct_get_field s field == mk_fraction (fields.fd_typedef field) v p)
+  ))
+  (ensures (fun s' ->
+    fractionable (struct0 tn n fields) s' /\
+    s == mk_fraction (struct0 tn n fields) s' p
+  ))
+*)
+
+val full_struct
+  (#t: Type)
+  (sd: struct_def t)
+  (s: t)
+: Lemma
+  (full (struct_typedef sd) s <==> (forall field . full (sd.field_desc.fd_typedef field) (sd.get s field)))
+  [SMTPat (full (struct_typedef sd) s)]

From 5474dc03c143588455a4c8a4bffd122cb737cec3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 18:13:20 -0700
Subject: [PATCH 471/513] some positivity annotations, typedef-independent
 array_ptr_gen

---
 ulib/experimental/Steel.ST.C.Types.Array.fst   | 14 +++++++-------
 ulib/experimental/Steel.ST.C.Types.Array.fsti  |  6 ++++--
 ulib/experimental/Steel.ST.C.Types.Scalar.fsti |  2 +-
 3 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index e0af7a2f1f6..9eda0988cc0 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -235,21 +235,21 @@ let has_base_array_cell_equiv_to
 /// Array pointers (with decay)
 
 noeq
-type array_ptr #t td = {
+type array_ptr_gen t = {
   ar_is_null: Ghost.erased bool;
   ar_base_size: Ghost.erased array_size_t;
-  ar_base: ptr (base_array1 #t td ar_base_size);
+  ar_base: ptr_gen (base_array_t' t ar_base_size);
   ar_offset: SZ.t;
   ar_prf: squash (
     SZ.v ar_offset <= SZ.v ar_base_size /\
-    (Ghost.reveal ar_is_null == true <==> ar_base == null _) /\
-    (ar_base == null _ ==> (SZ.v ar_base_size == 1 /\ SZ.v ar_offset == 0))
+    (Ghost.reveal ar_is_null == true <==> ar_base == void_null) /\
+    (ar_base == void_null ==> (SZ.v ar_base_size == 1 /\ SZ.v ar_offset == 0))
   );
 }
 let null_array_ptr td = {
   ar_is_null = true;
   ar_base_size = 1sz;
-  ar_base = null _;
+  ar_base = null_gen _;
   ar_offset = 0sz;
   ar_prf = ();
 }
@@ -548,7 +548,7 @@ let unarray_of_base
 let freeable_array0
   (#t: Type) (#td: typedef t) (a: array td)
 : Tot vprop
-= freeable (array_ptr_of a).ar_base `star`
+= freeable #_ #(base_array1 #t td (array_ptr_of a).ar_base_size) (array_ptr_of a).ar_base `star`
   pure (has_array_of_base' (array_ptr_of a).ar_base a)
 
 let freeable_array
@@ -574,7 +574,7 @@ let array_ptr_alloc
     let ar : array td = array_of_base0 base in
     rewrite (array_pts_to ar _) (array_pts_to_or_null ar (seq_of_base_array0 (uninitialized (base_array1 td sz))));
     let a = array_ptr_of ar in
-    rewrite (freeable_or_null _) (freeable (array_ptr_of ar).ar_base);
+    rewrite (freeable_or_null _) (freeable #_ #(base_array1 #t td (array_ptr_of ar).ar_base_size) (array_ptr_of ar).ar_base);
     rewrite (freeable_array0 ar) (freeable_or_null_array ar);
     return a
   end
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index 83ae6f9c39b..7323d6136e8 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -10,7 +10,7 @@ module SZ = FStar.SizeT
 // Per the C standard, base array types must be of nonzero size
 inline_for_extraction [@@noextract_to "krml"]
 let array_size_t = (n: SZ.t { SZ.v n > 0 })
-val base_array_t (t: Type0) (tn: Type0 (* using Typenat (or Typestring for `#define`d constants) *)) (n: array_size_t) : Type0
+val base_array_t ([@@@strictly_positive] t: Type0) (tn: Type0 (* using Typenat (or Typestring for `#define`d constants) *)) (n: array_size_t) : Type0
 inline_for_extraction [@@noextract_to "krml"] // MUST be syntactically equal to Steel.C.Model.Array.array_domain
 let base_array_index_t (n: array_size_t) : Tot eqtype = (i: SZ.t { SZ.v i < SZ.v n })
 [@@noextract_to "krml"]
@@ -167,7 +167,9 @@ val has_base_array_cell_equiv_to
 // ghost length of an array.
 
 [@@noextract_to "krml"] // primitive
-val array_ptr (#t: Type) (td: typedef t) : Tot Type0
+val array_ptr_gen ([@@@strictly_positive] t: Type0) : Tot Type0
+inline_for_extraction [@@noextract_to "krml"] // primitive
+let array_ptr (#t: Type) (td: typedef t) = array_ptr_gen t
 [@@noextract_to "krml"] // primitive
 val null_array_ptr (#t: Type) (td: typedef t) : Tot (array_ptr td)
 val g_array_ptr_is_null (#t: Type) (#td: typedef t) (a: array_ptr td) : Ghost bool
diff --git a/ulib/experimental/Steel.ST.C.Types.Scalar.fsti b/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
index 3fc8f9acf13..6453804a581 100644
--- a/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
@@ -6,7 +6,7 @@ module P = Steel.FractionalPermission
 
 // To be extracted as: t
 [@@noextract_to "krml"] // primitive
-val scalar_t (t: Type0) : Type0
+val scalar_t ( [@@@strictly_positive] t: Type0) : Type0
 [@@noextract_to "krml"] // proof-only
 val scalar (t: Type) : typedef (scalar_t t)
 val mk_scalar (#t: Type) (v: t) : Ghost (scalar_t t)

From 1431ef13225c023993d30353a81c4086656c5abb Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 18:13:51 -0700
Subject: [PATCH 472/513] extract user structs; array_ptr_gen instead of
 array_ptr

---
 .../arraystructs/my_fstar/ExtractSteelC.fst   | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index 842cc5dfdfc..95f6f7e5e61 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -108,8 +108,8 @@ let my_types_without_decay () =
     ->
       TBuf (translate_type_without_decay env arg)
 
-  | MLTY_Named ([arg; _], p) when
-      Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr"
+  | MLTY_Named ([arg], p) when
+      Syntax.string_of_mlpath p = "Steel.ST.C.Types.Array.array_ptr_gen"
     ->
       TBuf (translate_type_without_decay env arg)
 
@@ -271,6 +271,21 @@ let my_exprs () = register_pre_translate_expr begin fun env e ->
         EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
         field_name))
 
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)},
+             [
+               _ (* struct_def *)
+               ; _ (* v *)
+               ; r
+               ; ({expr=MLE_Const (MLC_String field_name)})
+               ; _ (* td' *)
+             ])
+    when string_of_mlpath p = "Steel.ST.C.Types.UserStruct.struct_field0"
+    ->
+      EAddrOf (EField (
+        assert_lid env r.mlty,
+        EBufRead (translate_expr env r, EQualified (["C"], "_zero_for_deref")),
+        field_name))
+
   | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, [_; _; union_name])},
              [_; {expr=MLE_Const (MLC_String field_name)}; r])
     when string_of_mlpath p = "Steel.C.UnionLiteral.addr_of_union_field''" ->

From bf224f3dfc4fa8bec86316ca241d738819f75168 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Fri, 17 Mar 2023 18:14:18 -0700
Subject: [PATCH 473/513] linked lists without void*

---
 examples/steel/arraystructs/LList2.fst | 196 +++++++++++++++++++++++++
 1 file changed, 196 insertions(+)
 create mode 100644 examples/steel/arraystructs/LList2.fst

diff --git a/examples/steel/arraystructs/LList2.fst b/examples/steel/arraystructs/LList2.fst
new file mode 100644
index 00000000000..eb625ba7f61
--- /dev/null
+++ b/examples/steel/arraystructs/LList2.fst
@@ -0,0 +1,196 @@
+module LList2
+open Steel.ST.GenElim
+open Steel.ST.C.Types
+open Steel.ST.C.Types.Struct.Aux
+open Steel.ST.C.Types.UserStruct // hides Struct
+
+module U32 = FStar.UInt32
+
+noeq
+type cell_t = {
+  hd: scalar_t U32.t;
+  tl: scalar_t (ptr_gen cell_t);
+}
+
+noextract
+inline_for_extraction
+[@@ norm_field_attr]
+let cell_struct_def : struct_def cell_t =
+  let fields = FStar.Set.add "hd" (FStar.Set.singleton "tl") in
+  let field_desc : field_description_gen_t (field_t fields) = {
+    fd_nonempty = nonempty_set_nonempty_type "hd" fields;
+    fd_type = (fun (n: field_t fields) -> match n with "hd" -> scalar_t U32.t | "tl" -> scalar_t (ptr_gen cell_t));
+    fd_typedef = (fun (n: field_t fields) -> match n with "hd" -> scalar U32.t | "tl" -> scalar (ptr_gen cell_t));
+  }
+  in {
+  fields = fields;
+  field_desc = field_desc;
+  mk = (fun f -> Mkcell_t (f "hd") (f "tl"));
+  get = (fun x (f: field_t fields) -> match f with "hd" -> x.hd | "tl" -> x.tl);
+  get_mk = (fun _ _ -> ());
+  extensionality = (fun s1 s2 phi -> phi "hd"; phi "tl");
+}
+
+noextract
+inline_for_extraction
+[@@ norm_field_attr]
+let cell = struct_typedef cell_struct_def
+
+[@@__reduce__]
+let llist_nil (p: ptr cell) : Tot vprop =
+  pure (p == null _)
+
+[@@__reduce__]
+let llist_cons (p: ptr cell) (a: U32.t) (q: Ghost.erased (list U32.t)) (llist: (ptr cell -> (l: Ghost.erased (list U32.t) { List.Tot.length l < List.Tot.length (a :: q) }) -> Tot vprop)) : Tot vprop =
+  exists_ (fun (p1: ref cell) -> exists_ (fun (p2: ptr cell) ->
+    pts_to p1 ({ hd = mk_scalar a; tl = mk_scalar p2 }) `star`
+    llist p2 q `star`
+    freeable p1 `star`
+    pure (p == p1)
+  ))
+
+let rec llist (p: ptr cell) (l: Ghost.erased (list U32.t)) : Tot vprop (decreases (List.Tot.length l)) =
+  match Ghost.reveal l with
+  | [] -> llist_nil p
+  | a :: q -> llist_cons p a q llist
+
+let intro_llist_cons
+  (#opened: _)
+  (p1: ref cell) (#v1: Ghost.erased (typeof cell)) (p2: ptr cell) (a: U32.t) (q: Ghost.erased (list U32.t))
+: STGhost unit opened
+    (pts_to p1 v1 `star`
+      llist p2 q `star`
+      freeable p1
+    )
+    (fun _ -> llist p1 (a :: q))
+    (Ghost.reveal v1 == ({ hd = mk_scalar a; tl = mk_scalar p2 }))
+    (fun _ -> True)
+= noop ();
+  rewrite_with_tactic (llist_cons p1 a q llist) (llist p1 (a :: q))
+
+let elim_llist_cons
+  (#opened: _)
+  (p1: ptr cell) (a: U32.t) (q: Ghost.erased (list U32.t))
+: STGhostT (p2: Ghost.erased (ptr cell) { ~ (p1 == null _) }) opened
+    (llist p1 (a :: q))
+    (fun p2 ->
+      pts_to p1 ({ hd = mk_scalar a; tl = mk_scalar (Ghost.reveal p2) }) `star`
+      llist p2 q `star`
+      freeable p1
+    )
+= rewrite_with_tactic (llist p1 (a :: q)) (llist_cons p1 a q llist);
+  let _ = gen_elim () in
+  let p2' = vpattern_erased (fun x -> llist x q) in
+  let p2 : (p2: Ghost.erased (ptr cell) { ~ (p1 == null _) }) = p2' in
+  vpattern_rewrite (fun x -> llist x q) p2;
+  rewrite (pts_to _ _) (pts_to _ _);
+  rewrite (freeable _) (freeable _);
+  _
+
+[@@__reduce__]
+let pllist0
+  (p: ref (scalar (ptr cell)))
+  (l: Ghost.erased (list U32.t))
+: Tot vprop
+= exists_ (fun (pc: ptr cell) ->
+    pts_to p (mk_scalar pc) `star`
+    llist pc l
+  )
+
+let pllist
+  (p: ref (scalar (ptr cell)))
+  (l: Ghost.erased (list U32.t))
+: Tot vprop
+= pllist0 p l
+
+let pllist_get
+  (#l: Ghost.erased (list U32.t))
+  (p: ref (scalar (ptr cell)))
+: STT (ptr cell)
+    (pllist p l)
+    (fun pc -> pts_to p (mk_scalar (Ghost.reveal pc)) `star` llist pc l)
+= rewrite (pllist p l) (pllist0 p l);
+  let _ = gen_elim () in
+  let pc = read p in
+  vpattern_rewrite (fun x -> llist x l) pc;
+  return pc
+
+let pllist_put
+  (#v: Ghost.erased (scalar_t (ptr cell)))
+  (#l: Ghost.erased (list U32.t))
+  (p: ref (scalar (ptr cell)))
+  (pc: ptr cell)
+: ST unit
+    (pts_to p v `star` llist pc l)
+    (fun _ -> pllist p l)
+    (full (scalar (ptr cell)) v)
+    (fun _ -> True)
+= write p pc;
+  rewrite (pllist0 p l) (pllist p l)
+
+let push
+  (#l: Ghost.erased (list U32.t))
+  (a: U32.t)
+  (p: ref (scalar (ptr cell)))
+: STT bool
+    (pllist p l)
+    (fun b -> pllist p (if b then a :: l else l))
+= let c = alloc cell in
+  if is_null c
+  then begin
+    rewrite (pts_to_or_null _ _) emp;
+    rewrite (freeable_or_null _) emp;
+    return false
+  end else begin
+    rewrite (pts_to_or_null _ _) (pts_to c (uninitialized cell));
+    rewrite (freeable_or_null c) (freeable c);
+    let p_tl = pllist_get p in
+    let c_hd = struct_field c "hd" in
+    let c_tl = struct_field c "tl" in
+    write c_hd a;
+    write c_tl p_tl;
+    unstruct_field c "tl" c_tl;
+    unstruct_field c "hd" c_hd;
+    intro_llist_cons c p_tl a l;
+    pllist_put p c;
+    drop (has_struct_field c "hd" _);
+    drop (has_struct_field _ _ _);
+    return true
+  end
+
+let pop
+  (#l: Ghost.erased (list U32.t))
+  (p: ref (scalar (ptr cell)))
+  (sq: squash (Cons? l))
+: ST U32.t
+    (pllist p l)
+    (fun _ -> pllist p (List.Tot.tl l))
+    (True)
+    (fun res -> res == List.Tot.hd l)
+= rewrite (pllist p l) (pllist p (List.Tot.hd l :: List.Tot.tl l));
+  let c = pllist_get p in
+  let _ = elim_llist_cons c (List.Tot.hd l) (List.Tot.tl l) in
+  let c_hd = struct_field c "hd" in
+  let c_tl = struct_field c "tl" in
+  let res = read c_hd in
+  let p_tl = read c_tl in
+  vpattern_rewrite (fun x -> llist x _) p_tl;
+  unstruct_field c "tl" c_tl;
+  unstruct_field c "hd" c_hd;
+  free c;
+  pllist_put p p_tl;
+  drop (has_struct_field c "hd" _);
+  drop (has_struct_field _ _ _);
+  return res
+
+let init
+  (#v: Ghost.erased (scalar_t (ptr cell)))
+  (r: ref (scalar (ptr cell)))
+: ST unit
+    (pts_to r v)
+    (fun _ -> pllist r [])
+    (full (scalar (ptr cell)) v)
+    (fun _ -> True)
+= noop ();
+  rewrite (llist_nil (null _)) (llist (null _) []);
+  pllist_put r (null _)

From 67023e57bf5955ab913947a4690d0aaee6f26618 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Mar 2023 10:00:34 -0700
Subject: [PATCH 474/513] has_ref_focus: generalize has_struct_field, etc. to
 any connections

---
 ulib/experimental/Steel.ST.C.Types.Base.fst | 259 ++++++++++++++++++++
 1 file changed, 259 insertions(+)

diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fst b/ulib/experimental/Steel.ST.C.Types.Base.fst
index c2e1dbae09f..1ca1524d803 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fst
@@ -508,3 +508,262 @@ let r_unfocus (#opened:_)
   x'
 
 irreducible let norm_field_attr = ()
+
+let has_focus_ref_gen
+  (#t1: Type)
+  (td1: typedef t1)
+  (r: ref0_v)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (r': ref0_v)
+: GTot prop
+= r'.base == r.base /\
+  r.t == t1 /\
+  r.td == td1 /\
+  r'.t == t2 /\
+  r'.td == td2 /\
+  r'.ref == coerce_eq () (R.ref_focus r.ref c)
+
+[@@__reduce__]
+let has_focus_ref0
+  (#t1: Type)
+  (#td1: typedef t1)
+  (p1: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (p2: ref td2)
+: Tot vprop
+= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
+    HR.pts_to p1 p w `star`
+    HR.pts_to p2 p' w' `star`
+    pure (has_focus_ref_gen td1 w td2 c w')
+  ))))
+
+let has_focus_ref
+  (#t1: Type)
+  (#td1: typedef t1)
+  (p1: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (p2: ref td2)
+: Tot vprop
+= has_focus_ref0 p1 c p2
+
+module GHR = Steel.ST.GhostHigherReference
+
+let ghost_focus_ref
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (#v: Ghost.erased t1)
+  (r: ref td1)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+: STGhostT (Ghost.erased (ref td2)) opened
+    (pts_to r v)
+    (fun r' -> pts_to r v `star` has_focus_ref r c r')
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let rr = get_ref r in
+  let w' = {
+    base = w.base;
+    t = t2;
+    td = td2;
+    ref = R.ref_focus rr c;
+  }
+  in
+  let gr' = GHR.alloc w' in
+  let r1' = GHR.reveal_ref gr' in
+  GHR.reveal_pts_to gr' P.full_perm w';
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  HR.pts_to_not_null r1';
+  let r' = Ghost.hide r1' in
+  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  hr_share r;
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r');
+  pts_to_intro r _ _ rr _;
+  r'
+
+[@@noextract_to "krml"] // proof-only
+let focus_ref
+  (#t1: Type)
+  (#td1: typedef t1)
+  (#v: Ghost.erased t1)
+  (r: ref td1)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+: STT (ref td2)
+    (pts_to r v)
+    (fun r' -> pts_to r v `star` has_focus_ref r c r')
+= rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let w = vpattern_replace_erased (HR.pts_to r _) in
+  let rr = read_ref r in
+  let w' = {
+    base = w.base;
+    t = t2;
+    td = td2;
+    ref = R.ref_focus rr c;
+  }
+  in
+  let r' = HR.alloc w' in
+  HR.pts_to_not_null r';
+  hr_share r;
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r');
+  pts_to_intro r _ _ rr _;
+  return r'
+
+let has_focus_ref_dup
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (r': ref td2)
+: STGhostT unit opened
+    (has_focus_ref r c r')
+    (fun _ -> has_focus_ref r c r' `star` has_focus_ref r c r')
+=
+  rewrite (has_focus_ref r c r') (has_focus_ref0 r c r');
+  let _ = gen_elim () in
+  HR.share r;
+  HR.share r';
+  noop ();
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r');
+  noop ();
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r')
+
+let has_focus_ref_inj
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (r1 r2: ref td2)
+: STGhostT unit opened
+    (has_focus_ref r c r1 `star` has_focus_ref r c r2)
+    (fun _ -> has_focus_ref r c r1 `star` has_focus_ref r c r2 `star` ref_equiv r1 r2)
+=
+  rewrite (has_focus_ref r c r1) (has_focus_ref0 r c r1);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w1 = vpattern_replace (HR.pts_to r1 _) in
+  rewrite (has_focus_ref r c r2) (has_focus_ref0 r c r2);
+  let _ = gen_elim () in
+  hr_gather w r;
+  vpattern_rewrite (HR.pts_to r2 _) w1;
+  hr_share r;
+  hr_share r1;
+  rewrite (has_focus_ref0 r c r1) (has_focus_ref r c r1);
+  hr_share r2;
+  rewrite (has_focus_ref0 r c r2) (has_focus_ref r c r2);
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let has_focus_ref_equiv_from
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r1: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (r': ref td2)
+  (r2: ref td1)
+: STGhostT unit opened
+    (ref_equiv r1 r2 `star` has_focus_ref r1 c r')
+    (fun _ -> ref_equiv r1 r2 `star` has_focus_ref r2 c r')
+= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
+  rewrite (has_focus_ref r1 c r') (has_focus_ref0 r1 c r');
+  let _ = gen_elim () in
+  hr_gather w r1;
+  hr_share r2;
+  rewrite (has_focus_ref0 r2 c r') (has_focus_ref r2 c r');
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+let has_focus_ref_equiv_to
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (r1' r2': ref td2)
+: STGhostT unit opened
+    (ref_equiv r1' r2' `star` has_focus_ref r c r1')
+    (fun _ -> ref_equiv r1' r2' `star` has_focus_ref r c r2')
+= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
+  let _ = gen_elim () in
+  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
+  rewrite (has_focus_ref r c r1') (has_focus_ref0 r c r1');
+  let _ = gen_elim () in
+  hr_gather w r1';
+  hr_share r2';
+  rewrite (has_focus_ref0 r c r2') (has_focus_ref r c r2');
+  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+
+#push-options "--split_queries"
+#restart-solver
+
+let has_focus_ref_id
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r1: ref td1)
+  (r2: ref td1)
+: STGhostT unit opened
+    (has_focus_ref r1 (Steel.C.Model.Connection.connection_id td1.pcm) r2)
+    (fun _ -> has_focus_ref r1 (Steel.C.Model.Connection.connection_id td1.pcm) r2 `star` ref_equiv r1 r2)
+= has_focus_ref_dup r1 (Steel.C.Model.Connection.connection_id td1.pcm) r2;
+  rewrite (has_focus_ref _ _ _) (has_focus_ref0 r1 (Steel.C.Model.Connection.connection_id td1.pcm) r2);
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r1 _) in
+  R.ref_focus_id #w.base #_ #td1.pcm (coerce_eq () w.ref);
+  vpattern_rewrite (HR.pts_to r2 _) w;
+  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+
+#pop-options
+
+let has_focus_ref_compose
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r1: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c12: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+  (r2: ref td2)
+  (#t3: Type)
+  (#td3: typedef t3)
+  (c23: Steel.C.Model.Connection.connection td2.pcm td3.pcm)
+  (r3: ref td3)
+: STGhostT unit opened
+    (has_focus_ref r1 c12 r2 `star` has_focus_ref r2 c23 r3)
+    (fun _ -> has_focus_ref r1 c12 r2 `star` has_focus_ref r2 c23 r3 `star` has_focus_ref r1 (Steel.C.Model.Connection.connection_compose c12 c23) r3)
+= rewrite (has_focus_ref r1 c12 r2) (has_focus_ref0 r1 c12 r2);
+  let _ = gen_elim () in
+  let w1 = vpattern_replace (HR.pts_to r1 _) in
+  let w2 = vpattern_replace (HR.pts_to r2 _) in
+  rewrite (has_focus_ref r2 c23 r3) (has_focus_ref0 r2 c23 r3);
+  let _ = gen_elim () in
+  let w3 = vpattern_replace (HR.pts_to r3 _) in
+  hr_gather w2 r2;
+  R.ref_focus_comp #_ #_ #_ #_ #td1.pcm #td2.pcm #td3.pcm (coerce_eq () w1.ref <: R.ref w1.base _) c12 c23;
+  HR.share r1;
+  HR.share r2;
+  rewrite (has_focus_ref0 r1 c12 r2) (has_focus_ref r1 c12 r2);
+  HR.share r3;
+  rewrite (has_focus_ref0 r2 c23 r3) (has_focus_ref r2 c23 r3);
+  rewrite (has_focus_ref0 r1 (Steel.C.Model.Connection.connection_compose c12 c23) r3) (has_focus_ref r1 (Steel.C.Model.Connection.connection_compose c12 c23) r3)

From 8e5ca98cd135c48bcdbcf22e20f1e7315a6beb71 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Mar 2023 13:46:43 -0700
Subject: [PATCH 475/513] Struct.Aux: use generic focus_ref

---
 ulib/experimental/Steel.ST.C.Types.Array.fst  |  15 ++
 .../Steel.ST.C.Types.Struct.Aux.fst           | 188 +++++-------------
 2 files changed, 67 insertions(+), 136 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/ulib/experimental/Steel.ST.C.Types.Array.fst
index 9eda0988cc0..418090ccd8e 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fst
@@ -767,6 +767,21 @@ let has_array_cell_array_of_ref
 #pop-options
 *)
 
+let has_struct_field_gen
+  (#field_t: eqtype)
+  (fields: field_description_gen_t field_t)
+  (r: ref0_v)
+  (field: field_t)
+  (r': ref0_v)
+: GTot prop
+= r'.base == r.base /\
+  r.t == struct_t1 fields /\
+  r.td == struct1 fields /\
+  r'.t == fields.fd_type field /\
+  r'.td == fields.fd_typedef field /\
+  r'.ref == coerce_eq () (R.ref_focus r.ref (Steel.ST.C.Model.Struct.struct_field (struct_field_pcm fields) field))
+
+
 let has_struct_field1_intro
   (#opened: _)
   (#field_t: eqtype)
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
index bf2cf2af442..5462f1e3288 100644
--- a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
@@ -121,33 +121,25 @@ let struct1
   );
 }
 
-let has_struct_field_gen
+[@@__reduce__]
+let has_struct_field0
   (#field_t: eqtype)
-  (fields: field_description_gen_t field_t)
-  (r: ref0_v)
+  (#fields: field_description_gen_t field_t)
+  (r: ref (struct1 fields))
   (field: field_t)
-  (r': ref0_v)
-: GTot prop
-= r'.base == r.base /\
-  r.t == struct_t1 fields /\
-  r.td == struct1 fields /\
-  r'.t == fields.fd_type field /\
-  r'.td == fields.fd_typedef field /\
-  r'.ref == coerce_eq () (R.ref_focus r.ref (S.struct_field (struct_field_pcm fields) field))
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= has_focus_ref0 r (S.struct_field (struct_field_pcm fields) field) r'
 
 [@@__reduce__]
-let has_struct_field0
+let has_struct_field05
   (#field_t: eqtype)
   (#fields: field_description_gen_t field_t)
   (r: ref (struct1 fields))
   (field: field_t)
   (r': ref (fields.fd_typedef field))
 : Tot vprop
-= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
-    HR.pts_to r p w `star`
-    HR.pts_to r' p' w' `star`
-    pure (has_struct_field_gen fields w field w')
-  ))))
+= has_focus_ref r (S.struct_field (struct_field_pcm fields) field) r'
 
 let has_struct_field1
   (#field_t: eqtype)
@@ -168,15 +160,10 @@ let has_struct_field_dup'
 : STGhostT unit opened
     (has_struct_field1 r field r')
     (fun _ -> has_struct_field1 r field r' `star` has_struct_field1 r field r')
-=
-  rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
-  let _ = gen_elim () in
-  HR.share r;
-  HR.share r';
-  noop ();
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  noop ();
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r')
+= rewrite (has_struct_field1 r field r') (has_struct_field05 r field r');
+  has_focus_ref_dup r _ r';
+  rewrite (has_struct_field05 r field r') (has_struct_field1 r field r');
+  rewrite (has_struct_field05 r field r') (has_struct_field1 r field r')
 
 let has_struct_field_inj'
   (#opened: _)
@@ -188,21 +175,11 @@ let has_struct_field_inj'
 : STGhostT unit opened
     (has_struct_field1 r field r1 `star` has_struct_field1 r field r2)
     (fun _ -> has_struct_field1 r field r1 `star` has_struct_field1 r field r2 `star` ref_equiv r1 r2)
-=
-  rewrite (has_struct_field1 r field r1) (has_struct_field0 r field r1);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let w1 = vpattern_replace (HR.pts_to r1 _) in
-  rewrite (has_struct_field1 r field r2) (has_struct_field0 r field r2);
-  let _ = gen_elim () in
-  hr_gather w r;
-  vpattern_rewrite (HR.pts_to r2 _) w1;
-  hr_share r;
-  hr_share r1;
-  rewrite (has_struct_field0 r field r1) (has_struct_field1 r field r1);
-  hr_share r2;
-  rewrite (has_struct_field0 r field r2) (has_struct_field1 r field r2);
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+= rewrite (has_struct_field1 r field r1) (has_struct_field05 r field r1);
+  rewrite (has_struct_field1 r field r2) (has_struct_field05 r field r2);
+  has_focus_ref_inj r _ r1 r2;
+  rewrite (has_struct_field05 r field r1) (has_struct_field1 r field r1);
+  rewrite (has_struct_field05 r field r2) (has_struct_field1 r field r2)
 
 let has_struct_field_equiv_from'
   (#opened: _)
@@ -215,15 +192,9 @@ let has_struct_field_equiv_from'
 : STGhostT unit opened
     (ref_equiv r1 r2 `star` has_struct_field1 r1 field r')
     (fun _ -> ref_equiv r1 r2 `star` has_struct_field1 r2 field r')
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  rewrite (has_struct_field1 r1 field r') (has_struct_field0 r1 field r');
-  let _ = gen_elim () in
-  hr_gather w r1;
-  hr_share r2;
-  rewrite (has_struct_field0 r2 field r') (has_struct_field1 r2 field r');
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+= rewrite (has_struct_field1 r1 field r') (has_struct_field05 r1 field r');
+  has_focus_ref_equiv_from r1 _ r' r2;
+  rewrite (has_struct_field05 r2 field r') (has_struct_field1 r2 field r')
 
 let has_struct_field_equiv_to'
   (#opened: _)
@@ -236,15 +207,9 @@ let has_struct_field_equiv_to'
 : STGhostT unit opened
     (ref_equiv r1' r2' `star` has_struct_field1 r field r1')
     (fun _ -> ref_equiv r1' r2' `star` has_struct_field1 r field r2')
-= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
-  rewrite (has_struct_field1 r field r1') (has_struct_field0 r field r1');
-  let _ = gen_elim () in
-  hr_gather w r1';
-  hr_share r2';
-  rewrite (has_struct_field0 r field r2') (has_struct_field1 r field r2');
-  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+= rewrite (has_struct_field1 r field r1') (has_struct_field05 r field r1');
+  has_focus_ref_equiv_to r _ r1' r2';
+  rewrite (has_struct_field05 r field r2') (has_struct_field1 r field r2')
 
 [@@noextract_to "krml"] // proof-only
 let t_struct_get_field
@@ -263,38 +228,20 @@ let ghost_struct_field_focus'
 : STGhostT unit opened
     (has_struct_field1 r field r' `star` pts_to r v)
     (fun _ -> has_struct_field1 r field r' `star` pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field))
-= rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
+= has_struct_field_dup' r field r';
+  rewrite (has_struct_field1 r field r') (has_struct_field0 r field r');
   let _ = gen_elim () in
   let w = vpattern_replace (HR.pts_to r _) in
   rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   hr_gather w r;
   let rr = get_ref r in
-  let prf
-    (f': field_t)
-    (x: (fields.fd_type f'))
-  : Lemma
-    (let p = (fields.fd_typedef f').pcm in
-      composable p x (one p) /\
-      op p x (one p) == x
-    )
-  = is_unit (fields.fd_typedef f').pcm x
-  in
-  Classical.forall_intro_2 prf;
-  let v' = t_struct_set_field field (unknown (fields.fd_typedef field)) v in
-  let vf = S.field_to_struct_f (struct_field_pcm _) field (t_struct_get_field v field) in
-  assert (composable (struct_pcm _) v' vf);
-  assert (op (struct_pcm _) v' vf `FX.feq` v);
-  R.split rr _ v' vf;
-  R.gfocus rr (S.struct_field (struct_field_pcm _) field) vf (t_struct_get_field v field);
-  hr_share r;
-  hr_share r';
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
+  S.g_addr_of_struct_field rr field v;
+  assert (t_struct_set_field field (unknown (fields.fd_typedef field)) v `FX.feq` S.struct_without_field (struct_field_pcm fields) field v);
+  noop ();
   pts_to_intro_rewrite r rr _;
   pts_to_intro_rewrite r' _ _
 
-module GHR = Steel.ST.GhostHigherReference
-
 let ghost_struct_field'
   (#opened: _)
   (#field_t: eqtype)
@@ -305,27 +252,8 @@ let ghost_struct_field'
 : STGhostT (Ghost.erased (ref (fields.fd_typedef field))) opened
     (pts_to r v)
     (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let rr = get_ref r in
-  let w' = {
-    base = w.base;
-    t = fields.fd_type field;
-    td = fields.fd_typedef field;
-    ref = R.ref_focus rr (S.struct_field (struct_field_pcm (fields)) field);
-  }
-  in
-  let gr' = GHR.alloc w' in
-  let r1' = GHR.reveal_ref gr' in
-  GHR.reveal_pts_to gr' P.full_perm w';
-  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
-  HR.pts_to_not_null r1';
-  let r' = Ghost.hide r1' in
-  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
-  hr_share r;
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  pts_to_intro r _ _ rr _;
+= let r' = ghost_focus_ref r (fields.fd_typedef field) (S.struct_field (struct_field_pcm fields) field) in
+  rewrite (has_struct_field05 r field r') (has_struct_field1 r field r');
   ghost_struct_field_focus' r field r';
   r'
 
@@ -338,25 +266,27 @@ let struct_field'
 : STT (ref (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> pts_to r (t_struct_set_field field (unknown (fields.fd_typedef field)) v) `star` pts_to r' (t_struct_get_field v field) `star` has_struct_field1 r field r')
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  let rr = read_ref r in
-  let w' = {
-    base = w.base;
-    t = fields.fd_type field;
-    td = fields.fd_typedef field;
-    ref = R.ref_focus rr (S.struct_field (struct_field_pcm (fields)) field);
-  }
-  in
-  let r' = HR.alloc w' in
-  hr_share r;
-  rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
-  pts_to_intro r _ _ rr _;
+= let r' = focus_ref r (fields.fd_typedef field) (S.struct_field (struct_field_pcm fields) field) in
+  rewrite (has_struct_field05 r field r') (has_struct_field1 r field r');
   ghost_struct_field_focus' r field r';
   return r'
 
+let r_unaddr_of_struct_field
+  (#opened: _)
+  (#base #base':Type) (#a:eqtype) (#b: a -> Type u#b) (p:(k:a -> pcm (b k))) (k:a)
+  (r': R.ref base' (p k)) (r: R.ref base (S.prod_pcm p))
+  (xs: Ghost.erased (FX.restricted_t a b)) (x: Ghost.erased (b k))
+: STGhost unit opened
+    ((r `R.pts_to` xs) `star` (r' `R.pts_to` x))
+    (fun s -> r `R.pts_to` S.struct_with_field p k x xs)
+    (requires
+      base' == base /\
+      r' == R.ref_focus r (S.struct_field p k) /\ Ghost.reveal xs k == one (p k))
+    (ensures fun _ -> True)
+= let r0' : R.ref base (p k) = coerce_eq () r' in
+  rewrite (r' `R.pts_to` _) (r0' `R.pts_to` x);
+  S.unaddr_of_struct_field k r0' r xs x
+
 let unstruct_field'
   (#opened: _)
   (#field_t: eqtype)
@@ -380,27 +310,13 @@ let unstruct_field'
   rewrite (pts_to r v) (pts_to0 r v);
   let _ = gen_elim () in
   hr_gather w r;
-  let rr = get_ref r in
+  let rr : R.ref w.base (struct_pcm fields) = get_ref r in
   rewrite (pts_to r' v') (pts_to0 r' v');
   let _ = gen_elim () in
   hr_gather w' r';
   let rr' = get_ref r' in
-  let prf
-    (f': field_t)
-    (x: (fields.fd_type f'))
-  : Lemma
-    (let p = (fields.fd_typedef f').pcm in
-      composable p x (one p) /\
-      op p x (one p) == x
-    )
-  = is_unit (fields.fd_typedef f').pcm x
-  in
-  Classical.forall_intro_2 prf;
-  let vf = S.field_to_struct_f (struct_field_pcm _) field v' in
-  assert (composable (struct_pcm _) v vf);
-  assert (op (struct_pcm _) v vf `FX.feq` t_struct_set_field field v' v);
-  let _ = r_unfocus rr' rr (coerce_eq () (S.struct_field (struct_field_pcm fields) field)) _ in
-  let _ = R.gather rr (Ghost.reveal v) _ in
+  r_unaddr_of_struct_field (struct_field_pcm fields) field rr' rr v v';
+  assert (t_struct_set_field field v' v `FX.feq` S.struct_with_field (struct_field_pcm fields) field v' v);
   hr_share r;
   rewrite (has_struct_field0 r field r') (has_struct_field1 r field r');
   pts_to_intro_rewrite r rr _

From 45ede4b973ad65dbfdccff53b90767767d5f1883 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Mar 2023 15:40:16 -0700
Subject: [PATCH 476/513] use focus_ref with unions

---
 ulib/experimental/Steel.ST.C.Types.Union.fst | 159 ++++---------------
 1 file changed, 34 insertions(+), 125 deletions(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Union.fst b/ulib/experimental/Steel.ST.C.Types.Union.fst
index e1f5e946059..7fd69ebeed1 100644
--- a/ulib/experimental/Steel.ST.C.Types.Union.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Union.fst
@@ -244,38 +244,20 @@ let full_union
 = Classical.move_requires (U.exclusive_union_intro (union_field_pcm fields) s) (Some field);
   Classical.move_requires (U.exclusive_union_elim (union_field_pcm fields) s) (Some field) 
 
-let has_union_field_gen
-  (tn: Type0)
-  (#tf: Type0)
-  (n: string)
-  (#fields: field_description_t tf)
-  (r: ref0_v)
-  (field: field_t fields)
-  (r': ref0_v)
-: GTot prop
-= r'.base == r.base /\
-  r.t == union_t0 tn n fields /\
-  r.td == union0 tn n fields /\
-  r'.t == fields.fd_type field /\
-  r'.td == fields.fd_typedef field /\
-  r'.ref == R.ref_focus r.ref (U.union_field (union_field_pcm fields) (Some field))
-
-let has_union_field_gen_inj
-  (tn: Type0)
+[@@__reduce__]
+let has_union_field0
+  (#tn: Type0)
   (#tf: Type0)
-  (n: string)
+  (#n: string)
   (#fields: field_description_t tf)
-  (r: ref0_v)
+  (r: ref (union0 tn n fields))
   (field: field_t fields)
-  (r1': ref0_v)
-  (r2': ref0_v)
-: Lemma
-  (requires (has_union_field_gen tn n r field r1' /\ has_union_field_gen tn n r field r2'))
-  (ensures (r1' == r2'))
-= ()
+  (r': ref (fields.fd_typedef field))
+: Tot vprop
+= has_focus_ref0 r (U.union_field (union_field_pcm fields) (Some field)) r'
 
 [@@__reduce__]
-let has_union_field0
+let has_union_field05
   (#tn: Type0)
   (#tf: Type0)
   (#n: string)
@@ -284,81 +266,38 @@ let has_union_field0
   (field: field_t fields)
   (r': ref (fields.fd_typedef field))
 : Tot vprop
-= exists_ (fun p -> exists_ (fun w -> exists_ (fun p' -> exists_ (fun w' ->
-    HR.pts_to r p w `star`
-    HR.pts_to r' p' w' `star`
-    pure (has_union_field_gen tn n w field w')
-  ))))
+= has_focus_ref r (U.union_field (union_field_pcm fields) (Some field)) r'
 
 let has_union_field
   r field r'
 = has_union_field0 r field r'
 
-#push-options "--z3rlimit 16"
-#restart-solver
-
 let has_union_field_dup
   r field r'
-= rewrite (has_union_field r field r') (has_union_field0 r field r');
-  let _ = gen_elim () in
-  hr_share r;
-  hr_share r';
-  noop ();
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  noop ();
-  rewrite (has_union_field0 r field r') (has_union_field r field r')
-
-#pop-options
-
-#push-options "--z3rlimit 64"
+= rewrite (has_union_field r field r') (has_union_field05 r field r');
+  has_focus_ref_dup r _ r';
+  rewrite (has_union_field05 r field r') (has_union_field r field r');
+  rewrite (has_union_field05 r field r') (has_union_field r field r')
 
 let has_union_field_inj
   #_ #tn #_ #n r field r1 r2
-= rewrite (has_union_field r field r1) (has_union_field0 r field r1);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  rewrite (has_union_field r field r2) (has_union_field0 r field r2);
-  let _ = gen_elim () in
-  hr_gather w r;
-  hr_share r;
-  hr_share r1;
-  rewrite (has_union_field0 r field r1) (has_union_field r field r1);
-  hr_share r2;
-  rewrite (has_union_field0 r field r2) (has_union_field r field r2);
-  let w' = vpattern_replace (HR.pts_to r1 _) in
-  let w2' = vpattern_replace (HR.pts_to r2 _) in
-  has_union_field_gen_inj tn n w field w' w2';
-  vpattern_rewrite (HR.pts_to r2 _) w';
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
-
-#pop-options
-
-#push-options "--z3rlimit 32"
-#restart-solver
+= rewrite (has_union_field r field r1) (has_union_field05 r field r1);
+  rewrite (has_union_field r field r2) (has_union_field05 r field r2);
+  has_focus_ref_inj r _ r1 r2;
+  rewrite (has_union_field05 r field r1) (has_union_field r field r1);
+  rewrite (has_union_field05 r field r2) (has_union_field r field r2)
 
 let has_union_field_equiv_from
   r1 r2 field r'
-= rewrite (ref_equiv r1 r2) (ref_equiv0 r1 r2);
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1 _ w `star` HR.pts_to r2 _ w) in
-  rewrite (has_union_field r1 field r') (has_union_field0 r1 field r');
-  let _ = gen_elim () in
-  hr_gather w r1;
-  hr_share r2;
-  rewrite (has_union_field0 r2 field r') (has_union_field r2 field r');
-  rewrite (ref_equiv0 r1 r2) (ref_equiv r1 r2)
+= rewrite (has_union_field r1 field r') (has_union_field05 r1 field r');
+  has_focus_ref_equiv_from r1 _ r' r2;
+  rewrite (has_union_field05 r2 field r') (has_union_field r2 field r')
 
 let has_union_field_equiv_to
   r field r1' r2'
-= rewrite (ref_equiv r1' r2') (ref_equiv0 r1' r2');
-  let _ = gen_elim () in
-  let w = vpattern_replace (fun w -> HR.pts_to r1' _ w `star` HR.pts_to r2' _ w) in
-  rewrite (has_union_field r field r1') (has_union_field0 r field r1');
-  let _ = gen_elim () in
-  hr_gather w r1';
-  hr_share r2';
-  rewrite (has_union_field0 r field r2') (has_union_field r field r2');
-  rewrite (ref_equiv0 r1' r2') (ref_equiv r1' r2')
+= rewrite (has_union_field r field r1') (has_union_field05 r field r1');
+  has_focus_ref_equiv_to r _ r1' r2';
+  rewrite (has_union_field05 r field r2') (has_union_field r field r2')
 
 let ghost_union_field_focus
   #_ #tn #_ #n #fields #v r field r'
@@ -381,27 +320,8 @@ let ghost_union_field_focus
 
 let ghost_union_field
   #_ #tn #_ #n #fields #v r field
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let rr = get_ref r in
-  let w' = {
-    base = w.base;
-    t = fields.fd_type field;
-    td = fields.fd_typedef field;
-    ref = R.ref_focus rr (U.union_field (union_field_pcm (fields)) (Some field));
-  }
-  in
-  let gr' = GHR.alloc w' in
-  let r1' = GHR.reveal_ref gr' in
-  GHR.reveal_pts_to gr' P.full_perm w';
-  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
-  HR.pts_to_not_null r1';
-  let r' = Ghost.hide r1' in
-  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
-  hr_share r;
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  pts_to_intro r _ _ rr _;
+= let r' = ghost_focus_ref r (fields.fd_typedef field) (U.union_field (union_field_pcm fields) (Some field)) in
+  rewrite (has_union_field05 r field r') (has_union_field r field r');
   ghost_union_field_focus r field r';
   r'
 
@@ -417,22 +337,8 @@ let union_field'
 : STT (ref (fields.fd_typedef field))
     (pts_to r v)
     (fun r' -> has_union_field r field r' `star` pts_to r' (union_get_field v field))
-= rewrite (pts_to r v) (pts_to0 r v);
-  let _ = gen_elim () in
-  let w = HR.read r in
-  vpattern_rewrite (HR.pts_to r _) w;
-  let rr = read_ref r in
-  let w' = {
-    base = w.base;
-    t = fields.fd_type field;
-    td = fields.fd_typedef field;
-    ref = R.ref_focus rr (U.union_field (union_field_pcm (fields)) (Some field));
-  }
-  in
-  let r' = HR.alloc w' in
-  hr_share r;
-  rewrite (has_union_field0 r field r') (has_union_field r field r');
-  pts_to_intro r _ _ rr _;
+= let r' = focus_ref r (fields.fd_typedef field) (U.union_field (union_field_pcm fields) (Some field)) in
+  rewrite (has_union_field05 r field r') (has_union_field r field r');
   ghost_union_field_focus r field r';
   return r'
 
@@ -445,6 +351,9 @@ let union_field0
   rewrite (has_union_field r field _) (has_union_field r field res);
   return res
 
+#push-options "--z3rlimit 16"
+#restart-solver
+
 let ununion_field
   #_ #tn #_ #n #fields r field #v' r'
 = rewrite (has_union_field r field r') (has_union_field0 r field r');
@@ -461,6 +370,8 @@ let ununion_field
   rewrite (has_union_field0 r field r') (has_union_field r field r');
   pts_to_intro_rewrite r rr #x _
 
+#pop-options
+
 [@@noextract_to "krml"] // primitive
 let union_switch_field'
   (#tn: Type0)
@@ -516,5 +427,3 @@ let union_switch_field0'
 let union_switch_field0
   t' r field td'
 = union_switch_field0' t' r field td' ()
-
-#pop-options

From 696eedd3174ac10b4897b2e7dccdf8a52b2d3678 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 20 Mar 2023 20:44:14 -0700
Subject: [PATCH 477/513] an interface for Model.Rewrite

---
 .../experimental/Steel.ST.C.Model.Rewrite.fst |  48 +++-----
 .../Steel.ST.C.Model.Rewrite.fsti             | 113 ++++++++++++++++++
 2 files changed, 128 insertions(+), 33 deletions(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Model.Rewrite.fsti

diff --git a/ulib/experimental/Steel.ST.C.Model.Rewrite.fst b/ulib/experimental/Steel.ST.C.Model.Rewrite.fst
index 1517ec020d8..b6b69c490cc 100644
--- a/ulib/experimental/Steel.ST.C.Model.Rewrite.fst
+++ b/ulib/experimental/Steel.ST.C.Model.Rewrite.fst
@@ -1,20 +1,7 @@
 module Steel.ST.C.Model.Rewrite
 
-open Steel.C.Model.PCM
-open Steel.C.Model.Connection
-
 module P = FStar.PCM
 
-noeq
-type rewrite_elts (from: Type) (to: Type) = {
-  rewrite_from_to : (from -> Tot to);
-  rewrite_to_from: (to -> Tot from);
-  rewrite_equiv : squash (
-    (forall (x: from) . rewrite_to_from (rewrite_from_to x) == x) /\
-    (forall (y: to) . rewrite_from_to (rewrite_to_from y) == y)
-  );
-}
-
 let fstar_rewrite_pcm
   (#from #to: Type)
   (p: pcm from)
@@ -42,23 +29,18 @@ let rewrite_pcm
 = let fp = fstar_pcm_of_pcm p in
   pcm_of_fstar_pcm (fstar_rewrite_pcm p rewrite)
 
-let rewrite_iso
-  (#from #to: Type)
-  (p: pcm from)
-  (rewrite: rewrite_elts from to)
-: Tot (isomorphism p (rewrite_pcm p rewrite))
-= mkisomorphism
-    (mkmorphism
-      rewrite.rewrite_from_to
-      ()
-      (fun _ _ -> ())
-    )
-    (mkmorphism
-      rewrite.rewrite_to_from
-      ()
-      (fun _ _ -> ())
-    )
-    ()
-    ()
-    (fun _ -> ())
-    (fun _ -> ())
+let rewrite_pcm_composable
+  p rewrite x1 x2
+= ()
+
+let rewrite_pcm_op
+  p rewrite x1 x2
+= ()
+
+let rewrite_pcm_one
+  p rewrite
+= ()
+
+let rewrite_pcm_refine
+  p rewrite x
+= ()
diff --git a/ulib/experimental/Steel.ST.C.Model.Rewrite.fsti b/ulib/experimental/Steel.ST.C.Model.Rewrite.fsti
new file mode 100644
index 00000000000..2304dfe899a
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Model.Rewrite.fsti
@@ -0,0 +1,113 @@
+module Steel.ST.C.Model.Rewrite
+
+open Steel.C.Model.PCM
+open Steel.C.Model.Connection
+
+let rewrite_forall_from
+  (#from #to: Type)
+  (rewrite_from_to : (from -> Tot to))
+  (rewrite_to_from: (to -> Tot from))
+: GTot prop
+= forall (x: from) . rewrite_to_from (rewrite_from_to x) == x
+
+let rewrite_forall_from_intro
+  (#from #to: Type)
+  (rewrite_from_to : (from -> Tot to))
+  (rewrite_to_from: (to -> Tot from))
+  (f: (x: from) -> Lemma
+    (rewrite_to_from (rewrite_from_to x) == x)
+  )
+: Lemma
+  (rewrite_forall_from rewrite_from_to rewrite_to_from)
+= Classical.forall_intro f
+
+let rewrite_forall_to
+  (#from #to: Type)
+  (rewrite_from_to : (from -> Tot to))
+  (rewrite_to_from: (to -> Tot from))
+: GTot prop
+= forall (y: to) . rewrite_from_to (rewrite_to_from y) == y
+
+let rewrite_forall_to_intro
+  (#from #to: Type)
+  (rewrite_from_to : (from -> Tot to))
+  (rewrite_to_from: (to -> Tot from))
+  (f: (x: to) -> Lemma
+    (rewrite_from_to (rewrite_to_from x) == x)
+  )
+: Lemma
+  (rewrite_forall_to rewrite_from_to rewrite_to_from)
+= Classical.forall_intro f
+
+noeq
+type rewrite_elts (from: Type) (to: Type) = {
+  rewrite_from_to : (from -> Tot to);
+  rewrite_to_from: (to -> Tot from);
+  rewrite_equiv : squash (
+    rewrite_forall_from rewrite_from_to rewrite_to_from /\
+    rewrite_forall_to rewrite_from_to rewrite_to_from
+  );
+}
+
+val rewrite_pcm
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+: Tot (pcm to)
+
+val rewrite_pcm_composable
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+  (x1 x2: to)
+: Lemma
+  (composable (rewrite_pcm p rewrite) x1 x2 <==> composable p (rewrite.rewrite_to_from x1) (rewrite.rewrite_to_from x2))
+  [SMTPat (composable (rewrite_pcm p rewrite) x1 x2)]
+
+val rewrite_pcm_op
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+  (x1 x2: to)
+: Lemma
+  (requires (composable (rewrite_pcm p rewrite) x1 x2))
+  (ensures (op (rewrite_pcm p rewrite) x1 x2 == rewrite.rewrite_from_to (op p (rewrite.rewrite_to_from x1) (rewrite.rewrite_to_from x2))))
+  [SMTPat (op (rewrite_pcm p rewrite) x1 x2)]
+
+val rewrite_pcm_one
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+: Lemma
+  (one (rewrite_pcm p rewrite) == rewrite.rewrite_from_to (one p))
+  [SMTPat (one (rewrite_pcm p rewrite))]
+
+val rewrite_pcm_refine
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+  (x: to)
+: Lemma
+  (p_refine (rewrite_pcm p rewrite) x <==> p_refine p (rewrite.rewrite_to_from x))
+  [SMTPat (p_refine (rewrite_pcm p rewrite) x)]
+
+let rewrite_iso
+  (#from #to: Type)
+  (p: pcm from)
+  (rewrite: rewrite_elts from to)
+: Tot (isomorphism p (rewrite_pcm p rewrite))
+= mkisomorphism
+    (mkmorphism
+      rewrite.rewrite_from_to
+      ()
+      (fun _ _ -> ())
+    )
+    (mkmorphism
+      rewrite.rewrite_to_from
+      ()
+      (fun _ _ -> ())
+    )
+    ()
+    ()
+    (fun _ -> ())
+    (fun _ -> ())

From 56f9600ea5c36d2d8d15a7f68584e1ab17d94456 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 01:55:22 -0700
Subject: [PATCH 478/513] general C ref lemmas on connections

---
 ulib/experimental/Steel.ST.C.Types.Base.fst | 210 ++++++++++++++++++++
 1 file changed, 210 insertions(+)

diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fst b/ulib/experimental/Steel.ST.C.Types.Base.fst
index 1ca1524d803..59637b74eb8 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fst
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fst
@@ -767,3 +767,213 @@ let has_focus_ref_compose
   HR.share r3;
   rewrite (has_focus_ref0 r2 c23 r3) (has_focus_ref r2 c23 r3);
   rewrite (has_focus_ref0 r1 (Steel.C.Model.Connection.connection_compose c12 c23) r3) (has_focus_ref r1 (Steel.C.Model.Connection.connection_compose c12 c23) r3)
+
+module Conn = Steel.C.Model.Connection
+
+let focus_ref_iso
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (#v: Ghost.erased t1)
+  (r: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (r': ref td2)
+  (c: Conn.isomorphism td1.pcm td2.pcm)
+: STGhost (Ghost.erased t2) opened
+    (pts_to r v `star` has_focus_ref r (Conn.connection_of_isomorphism c) r')
+    (fun v' -> pts_to r' v' `star` has_focus_ref r (Conn.connection_of_isomorphism c) r')
+    True
+    (fun v' -> Ghost.reveal v' == c.iso_1_2.morph v)
+= rewrite (has_focus_ref r (Conn.connection_of_isomorphism c) r') (has_focus_ref0 r (Conn.connection_of_isomorphism c) r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r v) (pts_to0 r v);
+  let _ = gen_elim () in
+  let rr = get_ref r in
+  hr_gather w r;
+  let v' = c.iso_1_2.morph v in
+  R.gfocus rr (Conn.connection_of_isomorphism c) v v';
+  hr_share r';
+  rewrite (has_focus_ref0 r (Conn.connection_of_isomorphism c) r') (has_focus_ref r (Conn.connection_of_isomorphism c) r');
+  pts_to_intro r' _ _ _ _;
+  _
+
+let unfocus_ref
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (#v': Ghost.erased t2)
+  (r': ref td2)
+  (c: Steel.C.Model.Connection.connection td1.pcm td2.pcm)
+: STGhost (Ghost.erased t1) opened
+    (pts_to r' v' `star` has_focus_ref r c r')
+    (fun v -> pts_to r v `star` has_focus_ref r c r')
+    True
+    (fun v -> Ghost.reveal v == c.conn_small_to_large.morph v')
+= rewrite (has_focus_ref r c r') (has_focus_ref0 r c r');
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let w' = vpattern_replace (HR.pts_to r' _) in
+  rewrite (pts_to r' v') (pts_to0 r' v');
+  let _ = gen_elim () in
+  hr_gather w' r';
+  let rr' = get_ref r' in
+  let rr : R.ref w'.base td1.pcm = coerce_eq () w.ref in
+  R.unfocus rr' rr c _;
+  hr_share r;
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r');
+  pts_to_intro r _ _ _ _;
+  _
+
+let has_focus_ref_compose_12_13
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r1: ref td1)
+  (#t2: Type)
+  (#td2: typedef t2)
+  (c12: Conn.connection td1.pcm td2.pcm)
+  (r2: ref td2)
+  (#t3: Type)
+  (#td3: typedef t3)
+  (c23: Conn.connection td2.pcm td3.pcm)
+  (r3: ref td3)
+: STGhostT unit opened
+    (has_focus_ref r1 c12 r2 `star` has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+    (fun _ -> has_focus_ref r1 c12 r2 `star` has_focus_ref r2 c23 r3 `star` has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+= rewrite (has_focus_ref r1 c12 r2) (has_focus_ref0 r1 c12 r2);
+  let _ = gen_elim () in
+  let w1 = vpattern_replace (HR.pts_to r1 _) in
+  let w2 = vpattern_replace (HR.pts_to r2 _) in
+  rewrite (has_focus_ref r1 (Conn.connection_compose c12 c23) r3) (has_focus_ref0 r1 (Conn.connection_compose c12 c23) r3);
+  let _ = gen_elim () in
+  let w3 = vpattern_replace (HR.pts_to r3 _) in
+  hr_gather w1 r1;
+  R.ref_focus_comp #_ #_ #_ #_ #td1.pcm #td2.pcm #td3.pcm (coerce_eq () w1.ref <: R.ref w1.base _) c12 c23;
+  HR.share r1;
+  HR.share r2;
+  rewrite (has_focus_ref0 r1 c12 r2) (has_focus_ref r1 c12 r2);
+  HR.share r3;
+  rewrite (has_focus_ref0 r2 c23 r3) (has_focus_ref r2 c23 r3);
+  rewrite (has_focus_ref0 r1 (Conn.connection_compose c12 c23) r3) (has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+
+let ghost_focus_ref_gen
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (#p: P.perm)
+  (#w: ref0_v)
+  (r: ref td1)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c: Conn.connection td1.pcm td2.pcm)
+: STGhost (Ghost.erased (ref td2)) opened
+    (HR.pts_to r p w)
+    (fun r' -> exists_ (fun p' -> HR.pts_to r p' w `star` has_focus_ref r c r'))
+    (t1 == w.t /\
+      td1 == w.td
+    )
+    (fun _ -> True)
+= let rr : R.ref w.base td1.pcm = coerce_eq () w.ref in
+  let w' = {
+    base = w.base;
+    t = t2;
+    td = td2;
+    ref = R.ref_focus rr c;
+  }
+  in
+  let gr' = GHR.alloc w' in
+  let r1' = GHR.reveal_ref gr' in
+  GHR.reveal_pts_to gr' P.full_perm w';
+  rewrite_equiv (GHR.pts_to _ _ _) (HR.pts_to r1' P.full_perm w');
+  HR.pts_to_not_null r1';
+  let r' = Ghost.hide r1' in
+  rewrite (HR.pts_to r1' P.full_perm w') (HR.pts_to r' P.full_perm w');
+  hr_share r;
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r');
+  noop ();
+  r'
+
+[@@noextract_to "krml"] // proof-only
+let focus_ref_gen
+  (#t1: Type)
+  (#td1: typedef t1)
+  (#p: P.perm)
+  (#v: Ghost.erased ref0_v)
+  (r: ref td1)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c: Conn.connection td1.pcm td2.pcm)
+: ST (ref td2)
+    (HR.pts_to r p v)
+    (fun r' -> exists_ (fun p' -> HR.pts_to r p' v `star` has_focus_ref r c r'))
+    (t1 == v.t /\
+      td1 == v.td
+    )
+    (fun _ -> True)
+= let w = HR.read r in
+  let rr : R.ref w.base td1.pcm = coerce_eq () w.ref in
+  let w' = {
+    base = w.base;
+    t = t2;
+    td = td2;
+    ref = R.ref_focus rr c;
+  }
+  in
+  let r' = HR.alloc w' in
+  HR.pts_to_not_null r';
+  hr_share r;
+  rewrite (has_focus_ref0 r c r') (has_focus_ref r c r');
+  return r'
+
+let ghost_focus_ref_compose_12_13
+  (#opened: _)
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r1: ref td1)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c12: Conn.connection td1.pcm td2.pcm)
+  (#t3: Type)
+  (#td3: typedef t3)
+  (c23: Conn.connection td2.pcm td3.pcm)
+  (r3: ref td3)
+: STGhostT (Ghost.erased (ref td2)) opened
+    (has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+    (fun r2 -> has_focus_ref r1 c12 r2 `star` has_focus_ref r2 c23 r3 `star` has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+= rewrite (has_focus_ref r1 (Conn.connection_compose c12 c23) r3) (has_focus_ref0 r1 (Conn.connection_compose c12 c23) r3);
+  let _ = gen_elim () in
+  let r2 = ghost_focus_ref_gen r1 td2 c12 in
+  let _ = gen_elim () in
+  rewrite (has_focus_ref0 r1 (Conn.connection_compose c12 c23) r3) (has_focus_ref r1 (Conn.connection_compose c12 c23) r3);
+  has_focus_ref_compose_12_13 r1 c12 r2 c23 r3;
+  r2
+
+[@@noextract_to "krml"] // proof-only
+let focus_ref_compose_12_13
+  (#t1: Type)
+  (#td1: typedef t1)
+  (r1: ref td1)
+  (#t2: Type)
+  (td2: typedef t2)
+  (c12: Conn.connection td1.pcm td2.pcm)
+  (#t3: Type)
+  (#td3: typedef t3)
+  (c23: Conn.connection td2.pcm td3.pcm)
+  (r3: ref td3)
+: STT (ref td2)
+    (has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+    (fun r2 -> has_focus_ref r1 c12 r2 `star` has_focus_ref r2 c23 r3 `star` has_focus_ref r1 (Conn.connection_compose c12 c23) r3)
+= rewrite (has_focus_ref r1 (Conn.connection_compose c12 c23) r3) (has_focus_ref0 r1 (Conn.connection_compose c12 c23) r3);
+  let _ = gen_elim () in
+  let r2 = focus_ref_gen r1 td2 c12 in
+  let _ = gen_elim () in
+  rewrite (has_focus_ref0 r1 (Conn.connection_compose c12 c23) r3) (has_focus_ref r1 (Conn.connection_compose c12 c23) r3);
+  has_focus_ref_compose_12_13 r1 c12 r2 c23 r3;
+  return r2
+

From 6796530bf4e56340701fca165e1ae9901fe87bd3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 03:01:01 -0700
Subject: [PATCH 479/513] prove UserStruct

---
 .../Steel.ST.C.Types.UserStruct.fst           | 204 ++++++++++++++++++
 .../Steel.ST.C.Types.UserStruct.fsti          |   7 +-
 2 files changed, 210 insertions(+), 1 deletion(-)
 create mode 100644 ulib/experimental/Steel.ST.C.Types.UserStruct.fst

diff --git a/ulib/experimental/Steel.ST.C.Types.UserStruct.fst b/ulib/experimental/Steel.ST.C.Types.UserStruct.fst
new file mode 100644
index 00000000000..5c00a8a7bed
--- /dev/null
+++ b/ulib/experimental/Steel.ST.C.Types.UserStruct.fst
@@ -0,0 +1,204 @@
+module Steel.ST.C.Types.UserStruct
+open Steel.ST.GenElim
+open Steel.ST.C.Types.Base
+module RW = Steel.ST.C.Types.Rewrite
+module MRW = Steel.ST.C.Model.Rewrite
+module S = Steel.ST.C.Types.Struct.Aux
+module FX = FStar.FunctionalExtensionality
+module Conn = Steel.C.Model.Connection
+module MS = Steel.ST.C.Model.Struct
+
+friend Steel.ST.C.Types.Base
+friend Steel.ST.C.Types.Struct.Aux
+friend Steel.ST.C.Types.Rewrite
+
+[@@noextract_to "krml"]
+let rewrite_from_struct
+  (#t: Type)
+  (sd: struct_def t)
+  (f: S.struct_t1 sd.field_desc)
+: Tot t
+= sd.mk f
+
+[@@noextract_to "krml"]
+let rewrite_to_struct
+  (#t: Type)
+  (sd: struct_def t)
+  (f: t)
+: Tot (S.struct_t1 sd.field_desc)
+= FX.on_dom (field_t sd.fields) (sd.get f)
+
+let rewrite_forall_struct
+  (#t: Type)
+  (sd: struct_def t)
+: Lemma
+  (MRW.rewrite_forall_from (rewrite_from_struct sd) (rewrite_to_struct sd))
+= MRW.rewrite_forall_from_intro (rewrite_from_struct sd) (rewrite_to_struct sd) (fun (x: S.struct_t1 sd.field_desc) ->
+    Classical.forall_intro (sd.get_mk x);
+    assert (x `FX.feq` rewrite_to_struct sd (sd.mk x))
+  )
+
+let rewrite_forall_t
+  (#t: Type)
+  (sd: struct_def t)
+: Lemma
+  (MRW.rewrite_forall_to (rewrite_from_struct sd) (rewrite_to_struct sd))
+= MRW.rewrite_forall_to_intro (rewrite_from_struct sd) (rewrite_to_struct sd) (fun (x: t) ->
+    sd.extensionality (rewrite_from_struct sd (rewrite_to_struct sd x)) x (fun (f: field_t sd.fields) ->
+      sd.get_mk (rewrite_to_struct sd x) f
+    )
+  )
+
+[@@noextract_to "krml"]
+let rewrite_struct
+  (#t: Type)
+  (sd: struct_def t)
+: Tot (MRW.rewrite_elts (S.struct_t1 sd.field_desc) t)
+= {
+    rewrite_from_to = rewrite_from_struct sd;
+    rewrite_to_from = rewrite_to_struct sd;
+    rewrite_equiv = begin
+      rewrite_forall_struct sd;
+      rewrite_forall_t sd;
+      ()
+    end;
+  }
+
+let struct_typedef sd =
+  S.struct1 sd.field_desc `RW.rewrite_typedef` rewrite_struct sd
+
+let iso_to_struct
+  (#t: Type)
+  (sd: struct_def t)
+: Tot (Conn.isomorphism (struct_typedef sd).pcm (S.struct1 sd.field_desc).pcm)
+= coerce_eq () (Conn.isomorphism_inverse (MRW.rewrite_iso (S.struct_pcm sd.field_desc) (rewrite_struct sd))) // without the coercion, F* blows up memory
+
+let conn_to_struct
+  (#t: Type)
+  (sd: struct_def t)
+: Tot (Conn.connection (struct_typedef sd).pcm (S.struct1 sd.field_desc).pcm)
+= Conn.connection_of_isomorphism (iso_to_struct sd)
+
+let conn_struct_field
+  (#t: Type)
+  (sd: struct_def t)
+  (field: field_t sd.fields)
+: Tot (Conn.connection (S.struct1 sd.field_desc).pcm (sd.field_desc.fd_typedef field).pcm)
+= MS.struct_field (struct_field_pcm sd.field_desc) field
+
+[@@__reduce__]
+let has_struct_field0
+  (#t: Type)
+  (#sd: struct_def t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+  (r': ref (sd.field_desc.fd_typedef field))
+: Tot vprop
+= has_focus_ref r (conn_to_struct sd `Conn.connection_compose` conn_struct_field sd field) r'
+
+let has_struct_field
+  r field r'
+= has_struct_field0 r field r'
+
+let has_struct_field_dup
+  r field r'
+= rewrite (has_struct_field r field r') (has_struct_field0 r field r');
+  has_focus_ref_dup r _ r';
+  rewrite (has_struct_field0 r field r') (has_struct_field r field r');
+  rewrite (has_struct_field0 r field r') (has_struct_field r field r')
+
+let has_struct_field_inj
+  r field r1 r2
+= rewrite (has_struct_field r field r1) (has_struct_field0 r field r1);
+  rewrite (has_struct_field r field r2) (has_struct_field0 r field r2);
+  has_focus_ref_inj r _ r1 r2;
+  rewrite (has_struct_field0 r field r1) (has_struct_field r field r1);
+  rewrite (has_struct_field0 r field r2) (has_struct_field r field r2)
+
+let has_struct_field_equiv_from
+  r1 field r' r2
+= rewrite (has_struct_field r1 field r') (has_struct_field0 r1 field r');
+  has_focus_ref_equiv_from r1 _ r' r2;
+  rewrite (has_struct_field0 r2 field r') (has_struct_field r2 field r')
+
+let has_struct_field_equiv_to
+  r field r1' r2'
+= rewrite (has_struct_field r field r1') (has_struct_field0 r field r1');
+  has_focus_ref_equiv_to r _ r1' r2';
+  rewrite (has_struct_field0 r field r2') (has_struct_field r field r2')
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let ghost_struct_field_focus
+  #_ #_ #sd #v r field r'
+= rewrite (has_struct_field r field r') (has_struct_field0 r field r');
+  let r1 = ghost_focus_ref r (struct1 sd.field_desc) (conn_to_struct sd) in
+  has_focus_ref_compose_12_13 r _ r1 _ r';
+  let v1 = focus_ref_iso r r1 _ in
+  S.ghost_struct_field_focus' r1 field r';
+  drop (has_focus_ref r1 _ _);
+  let v' = unfocus_ref r r1 _ in
+  drop (has_focus_ref _ _ r1);
+  rewrite (has_struct_field0 r field r') (has_struct_field r field r');
+  sd.extensionality v' (set sd v field (unknown (sd.field_desc.fd_typedef field))) (fun f' -> sd.get_mk v1 f');
+  noop ();
+  rewrite (pts_to r _) (pts_to r _);
+  rewrite (pts_to r' _) (pts_to r' _)
+
+#pop-options
+
+let ghost_struct_field
+  #_ #_ #sd r field
+= let r' = ghost_focus_ref r (sd.field_desc.fd_typedef field) (conn_to_struct sd `Conn.connection_compose` conn_struct_field sd field) in
+  rewrite (has_struct_field0 r field r') (has_struct_field r field r');
+  ghost_struct_field_focus r field r';
+  r'
+
+let struct_field_1
+  (#t: Type)
+  (#sd: struct_def t)
+  (#v: Ghost.erased t)
+  (r: ref (struct_typedef sd))
+  (field: field_t sd.fields)
+: STT (ref (sd.field_desc.fd_typedef field))
+    (pts_to r v)
+    (fun r' -> has_struct_field r field r' `star` pts_to r (set sd v field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to r' (sd.get v field))
+= let r' = focus_ref r (sd.field_desc.fd_typedef field) (conn_to_struct sd `Conn.connection_compose` conn_struct_field sd field) in
+  rewrite (has_struct_field0 r field r') (has_struct_field r field r');
+  ghost_struct_field_focus r field r';
+  return r'
+
+let struct_field0
+  #t _ #sd #v r field td'
+= let r1' = struct_field_1 #t #sd #v r field in
+  let r' : ref td' = coerce_eq () r1' in
+  rewrite (pts_to r1' _) (pts_to #_ #(sd.field_desc.fd_typedef field) (coerce_eq () r') (sd.get (Ghost.reveal v) field));
+  rewrite (has_struct_field _ _ _) (has_struct_field r field (coerce_eq () r'));
+  return r'
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let unstruct_field
+  #_ #_ #sd #v r field #v' r'
+= rewrite (has_struct_field r field r') (has_struct_field0 r field r');
+  let r1 = ghost_focus_ref r (struct1 sd.field_desc) (conn_to_struct sd) in
+  has_focus_ref_compose_12_13 r _ r1 _ r';
+  let v1 = focus_ref_iso r r1 _ in
+  S.unstruct_field' r1 field r';
+  drop (has_focus_ref r1 _ _);
+  let vf = unfocus_ref r r1 _ in
+  drop (has_focus_ref _ _ r1);
+  rewrite (has_struct_field0 r field r') (has_struct_field r field r');
+  sd.extensionality vf (set sd v field v') (fun f' -> sd.get_mk v1 f');
+  noop ();
+  rewrite (pts_to r _) (pts_to r _)
+
+#pop-options
+
+let fractionable_struct sd s = ()
+
+let mk_fraction_struct sd s p field = ()
+
+let full_struct sd s = ()
diff --git a/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti b/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti
index 39f1e10561e..163a49d60f5 100644
--- a/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.UserStruct.fsti
@@ -40,6 +40,11 @@ let set_aux
 let set (#t: Type) (sd: struct_def t) (x: t) (f: field_t sd.fields) (v: sd.field_desc.fd_type f) : Tot t =
   sd.mk (set_aux sd x f v)
 
+let get_set (#t: Type) (sd: struct_def t) (x: t) (f: field_t sd.fields) (v: sd.field_desc.fd_type f) (f' : field_t sd.fields) : Lemma
+  (sd.get (set sd x f v) f' == (if f = f' then v else sd.get x f'))
+  [SMTPat (sd.get (set sd x f v) f')]
+= sd.get_mk (set_aux sd x f v) f'
+
 [@@noextract_to "krml"]
 val struct_typedef
   (#t: Type)
@@ -136,7 +141,7 @@ val struct_field0
   })
 : STT (ref td')
     (pts_to r v)
-    (fun r' -> has_struct_field r field r' `star` pts_to r (set sd v field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to r' (sd.get v field))
+    (fun r' -> has_struct_field r field (coerce_eq () r') `star` pts_to r (set sd (Ghost.reveal v) field (unknown (sd.field_desc.fd_typedef field))) `star` pts_to #_ #(sd.field_desc.fd_typedef field) (coerce_eq () r') (sd.get (Ghost.reveal v) field))
 
 inline_for_extraction [@@noextract_to "krml"] // primitive
 let struct_field

From 0d6bd3081400a8c210ddfa17c1225737554ec4a6 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 08:52:53 -0700
Subject: [PATCH 480/513] Hacl example with user struct

---
 examples/steel/arraystructs/HaclExample3.fst | 146 +++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 examples/steel/arraystructs/HaclExample3.fst

diff --git a/examples/steel/arraystructs/HaclExample3.fst b/examples/steel/arraystructs/HaclExample3.fst
new file mode 100644
index 00000000000..0c9bc6bee49
--- /dev/null
+++ b/examples/steel/arraystructs/HaclExample3.fst
@@ -0,0 +1,146 @@
+module HaclExample3
+open Steel.ST.GenElim
+open Steel.ST.C.Types
+open Steel.C.Typenat
+open Steel.C.Typestring
+open Steel.ST.C.Types.Struct.Aux
+open Steel.ST.C.Types.UserStruct // hides Struct
+
+module SZ = FStar.SizeT
+module U64 = FStar.UInt64
+
+(** In this file we demonstrate how Steel could be used to manipulate the following data type used in Hacl*:
+      https://github.com/project-everest/hacl-star/blob/master/code/poly1305/Hacl.Impl.Poly1305.fsti#L18
+    This Low* definition amounts to the struct definition
+      struct poly1305_ctx { uint64_t limbs[5]; uint64_t precomp[20]; };
+    and, with our new model of structs and arrays and pointer-to-field, can be expresesd directly in Steel.
+
+    See PointStruct.fst for more detailed explanations of the various definitions needed below.
+*)
+
+noextract inline_for_extraction let five = normalize (nat_t_of_nat 5)
+noextract inline_for_extraction let twenty = normalize (nat_t_of_nat 20)
+noextract inline_for_extraction let comp_name = normalize (mk_string_t "HaclExample2.comp")
+
+noeq
+type comp_t = {
+  limbs: base_array_t (scalar_t U64.t)  five 5sz;
+  precomp: base_array_t (scalar_t U64.t)  twenty 20sz;
+}
+
+noextract
+inline_for_extraction
+[@@ norm_field_attr]
+let comp_struct_def : struct_def comp_t =
+  let fields = FStar.Set.add "limbs" (FStar.Set.singleton "precomp") in
+  let fd_type (n: field_t fields) : Tot Type0 = match n with "limbs" -> base_array_t (scalar_t U64.t)  five 5sz | "precomp" -> base_array_t (scalar_t U64.t) twenty 20sz in
+  let field_desc : field_description_gen_t (field_t fields) = {
+    fd_nonempty = nonempty_set_nonempty_type "limbs" fields;
+    fd_type = fd_type;
+    fd_typedef = (fun (n: field_t fields) -> match n returns typedef (fd_type n) with "limbs" -> base_array0 five (scalar U64.t) 5sz | "precomp" -> base_array0 twenty (scalar U64.t) 20sz);
+  }
+  in {
+    fields = fields;
+    field_desc = field_desc;
+    mk = (fun f -> Mkcomp_t (f "limbs") (f "precomp"));
+    get = (fun x f -> match f with "limbs" -> x.limbs | "precomp" -> x.precomp);
+    get_mk = (fun _ _ -> ());
+    extensionality = (fun s1 s2 phi -> phi "limbs"; phi "precomp");
+  }
+
+noextract inline_for_extraction
+let comp = struct_typedef comp_struct_def
+
+(** To demonstrate how our model could be used, we write a simple
+    function that takes pointers to the limbs and precomp fields and
+    passes them to helper functions (which in this case simply set on
+    element of the corresponding array to zero) *)
+
+let do_something_with_limbs
+  (#v: Ghost.erased (Seq.seq (scalar_t U64.t)))
+  (a: array (scalar U64.t))
+: ST (Ghost.erased (Seq.seq (scalar_t U64.t)))
+    (array_pts_to a v)
+    (fun v' -> array_pts_to a v')
+    (requires
+      array_length a == 5 /\
+      full_seq (scalar U64.t) v
+    )
+    (ensures (fun v' ->
+      full_seq (scalar U64.t) v'
+    ))
+= let p = array_cell a 2sz in
+  write p 0uL;
+  unarray_cell _ _ _;
+  drop (has_array_cell _ _ _); 
+  return _
+
+let do_something_with_precomp
+  (#v: Ghost.erased (Seq.seq (scalar_t U64.t)))
+  (a: array (scalar U64.t))
+: ST (ptr (scalar U64.t))
+    (array_pts_to a v)
+    (fun _ -> exists_ (fun (v': Seq.seq (scalar_t U64.t)) ->
+      array_pts_to a v' `star`
+      pure (full_seq (scalar U64.t) v')
+    ))
+    (requires
+      array_length a == 20 /\
+      full_seq (scalar U64.t) v
+    )
+    (ensures fun _ -> True)
+= let p = array_cell a 19sz in
+  write p 0uL;
+  unarray_cell _ _ _;
+  drop (has_array_cell _ _ _);
+  noop ();
+  return (null _)
+
+let test_alloc_free
+  ()
+: STT unit
+    emp
+    (fun _ -> emp)
+=
+  let a = array_alloc (scalar bool) 42sz in
+  let _ = gen_elim () in
+  if array_is_null a
+  then begin
+    rewrite (array_pts_to_or_null _ _) emp;
+    rewrite (freeable_or_null_array _) emp;
+    noop ()
+  end else begin
+    let s = vpattern_replace (array_pts_to_or_null _) in
+    rewrite (array_pts_to_or_null _ _) (array_pts_to a s);
+    rewrite (freeable_or_null_array _) (freeable_array a);
+    array_free a
+  end
+
+#push-options "--z3rlimit 16"
+#restart-solver
+
+let test
+  (#v: Ghost.erased (typeof comp))
+  (p: ref comp)
+: ST (Ghost.erased (typeof comp))
+    (p `pts_to` v)
+    (fun v' -> p `pts_to` v')
+    (full comp v)
+    (fun v' -> full comp v')
+= let q = p `struct_field` "limbs" in
+  let a = array_of_base q in
+  let r = p `struct_field` "precomp" in
+  let _ = vpattern_replace_erased (pts_to p) in // FIXME: WHY WHY WHY?
+  let b = array_of_base r in
+  let _ = do_something_with_limbs a in
+  let _ = do_something_with_precomp b in
+  let _ = gen_elim () in
+  let _ = unarray_of_base q a in
+  let _ = unarray_of_base r b in
+  let _ = unstruct_field p "precomp" r in
+  let _ = unstruct_field p "limbs" q in
+  drop (has_struct_field p "limbs" q);
+  drop (has_struct_field p "precomp" r);
+  return _
+
+#pop-options

From 79de29e02d1dec9dbd33cf3cba77de4860f6ee74 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 08:54:01 -0700
Subject: [PATCH 481/513] do not decay F* struct/union field types, universes

---
 src/extraction/FStar.Extraction.Krml.fst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index a7bf0769ba5..d6be5cdc5e5 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -561,7 +561,7 @@ let rec translate_type_without_decay' env t: typ =
   | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "FStar.Universe.raise_t"
     ->
-      translate_type env arg
+      translate_type_without_decay env arg
 
   | MLTY_Named ([_], p) when (Syntax.string_of_mlpath p = "FStar.Ghost.erased") ->
       TAny
@@ -1222,7 +1222,7 @@ let translate_type_decl' env ty: option decl =
         let name = env.module_name, name in
         let env = List.fold_left (fun env name -> extend_t env name) env args in
         Some (DTypeFlat (name, translate_flags flags, List.length args, List.map (fun (f, t) ->
-          f, (translate_type env t, false)) fields))
+          f, (translate_type_without_decay env t, false)) fields))
 
     | {tydecl_name=name;
        tydecl_parameters=args;
@@ -1233,7 +1233,7 @@ let translate_type_decl' env ty: option decl =
         let env = List.fold_left extend_t env args in
         Some (DTypeVariant (name, flags, List.length args, List.map (fun (cons, ts) ->
           cons, List.map (fun (name, t) ->
-            name, (translate_type env t, false)
+            name, (translate_type_without_decay env t, false)
           ) ts
         ) branches))
     | {tydecl_name=name} ->

From cb49c861ff18e23113343295b686d3994a8547db Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 08:54:49 -0700
Subject: [PATCH 482/513] Revert "snap"

This reverts commit bf9a3eb3990c781245a15ce3b24e170ef7111421.
---
 .../generated/FStar_Extraction_Krml.ml        | 429 ++++++------------
 ocaml/fstar-lib/generated/FStar_Main.ml       |   3 +-
 2 files changed, 131 insertions(+), 301 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 9aa9e37c95f..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,14 +996,13 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
@@ -1162,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1197,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2668,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3097,121 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 = translate_type env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3551,10 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (init : unit -> unit) =
-  fun uu___ ->
-    register_post_translate_type_without_decay translate_type_without_decay';
-    register_post_translate_type translate_type';
-    register_post_translate_type_decl translate_type_decl';
-    register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index d763e38153f..8ad6b788389 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,8 +294,7 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
-    FStar_Extraction_Krml.init ()
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in

From 848eedc5310498c71a6f4f740e1da6922437fabc Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 08:58:10 -0700
Subject: [PATCH 483/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 433 ++++++++++++------
 ocaml/fstar-lib/generated/FStar_Main.ml       |   3 +-
 2 files changed, 304 insertions(+), 132 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..dd7c2505755 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,16 +1142,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1163,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1198,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2669,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3098,122 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3553,10 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (init : unit -> unit) =
+  fun uu___ ->
+    register_post_translate_type_without_decay translate_type_without_decay';
+    register_post_translate_type translate_type';
+    register_post_translate_type_decl translate_type_decl';
+    register_post_translate_expr translate_expr'
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index 8ad6b788389..d763e38153f 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,7 +294,8 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
+    FStar_Extraction_Krml.init ()
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in

From c59eff9d32e213877adcf05b30f2da4d1f49254e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 10:36:24 -0700
Subject: [PATCH 484/513] Revert "snap"

This reverts commit 99f2d51448d02c02d57002bf6fb4ebdc26f1719c.
---
 .../generated/Steel_ST_GenElim_Base.ml        | 534 +++++++++---------
 1 file changed, 259 insertions(+), 275 deletions(-)

diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index d68e5880c75..f50533bf38f 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -2009,60 +2009,20 @@ let (solve_gen_elim_nondep :
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
-let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
-  fun uu___ ->
-    FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
-         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
-         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
-      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
-      (fun uu___1 ->
-         (fun ty ->
-            Obj.magic
-              (FStar_Tactics_Effect.tac_bind
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (8))
-                    (Prims.of_int (624)) (Prims.of_int (28)))
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (2))
-                    (Prims.of_int (626)) (Prims.of_int (27)))
-                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
-                 (fun uu___1 ->
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | FStar_Reflection_Formula.Comp
-                           (uu___2, uu___3, uu___4) ->
-                           Obj.magic (FStar_Tactics_Derived.trefl ())
-                       | uu___2 ->
-                           Obj.magic
-                             (FStar_Tactics_Effect.tac_bind
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (9))
-                                   (Prims.of_int (626)) (Prims.of_int (17)))
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (19))
-                                   (Prims.of_int (626)) (Prims.of_int (27)))
-                                (Obj.magic (FStar_Tactics_Derived.smt ()))
-                                (fun uu___3 ->
-                                   (fun uu___3 ->
-                                      Obj.magic
-                                        (FStar_Tactics_Derived.qed ()))
-                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+         (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+         (Prims.of_int (2)) (Prims.of_int (664)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+               (Prims.of_int (31)) (Prims.of_int (626)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
+               (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2074,27 +2034,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (633)) (Prims.of_int (2))
-                        (Prims.of_int (634)) (Prims.of_int (33)))
+                        (Prims.of_int (627)) (Prims.of_int (2))
+                        (Prims.of_int (628)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (635)) (Prims.of_int (2))
-                        (Prims.of_int (670)) (Prims.of_int (35)))
+                        (Prims.of_int (629)) (Prims.of_int (2))
+                        (Prims.of_int (664)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (5))
-                              (Prims.of_int (633)) (Prims.of_int (23)))
+                              (Prims.of_int (627)) (Prims.of_int (5))
+                              (Prims.of_int (627)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (2))
-                              (Prims.of_int (634)) (Prims.of_int (33)))
+                              (Prims.of_int (627)) (Prims.of_int (2))
+                              (Prims.of_int (628)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (9))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (627)) (Prims.of_int (9))
+                                    (Prims.of_int (627)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (5))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (627)) (Prims.of_int (5))
+                                    (Prims.of_int (627)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2120,15 +2080,15 @@ let (solve_gen_elim_prop :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (637))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (637))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (637))
+                                       (Prims.of_int (631))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (669))
+                                       (Prims.of_int (663))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2142,15 +2102,15 @@ let (solve_gen_elim_prop :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (638))
+                                                      (Prims.of_int (632))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (639))
+                                                      (Prims.of_int (633))
                                                       (Prims.of_int (42)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (640))
+                                                      (Prims.of_int (634))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (668))
+                                                      (Prims.of_int (662))
                                                       (Prims.of_int (44)))
                                                    (if
                                                       Prims.op_Negation
@@ -2191,15 +2151,15 @@ let (solve_gen_elim_prop :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (74)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2217,15 +2177,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2239,15 +2199,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2271,29 +2231,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2344,15 +2304,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (652))
+                                                                    (Prims.of_int (646))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (653))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2388,15 +2348,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2406,15 +2366,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (654))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2442,15 +2402,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (655))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2477,15 +2437,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2495,15 +2455,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (657))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2527,15 +2487,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (49)))
+                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2545,16 +2505,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (658))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (48)))
+                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2564,8 +2524,32 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (trefl_or_smt
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (33))
+                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (45)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (47))
+                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (55)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.trivial
                                                                     ()))
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Derived.qed
+                                                                    ()))
+                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2577,15 +2561,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2595,15 +2579,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2627,15 +2611,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2645,15 +2629,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2681,15 +2665,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2724,16 +2708,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+         (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+         (Prims.of_int (2)) (Prims.of_int (706)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+               (Prims.of_int (31)) (Prims.of_int (670)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
+               (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2745,27 +2729,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (677)) (Prims.of_int (2))
-                        (Prims.of_int (678)) (Prims.of_int (33)))
+                        (Prims.of_int (671)) (Prims.of_int (2))
+                        (Prims.of_int (672)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (679)) (Prims.of_int (2))
-                        (Prims.of_int (712)) (Prims.of_int (35)))
+                        (Prims.of_int (673)) (Prims.of_int (2))
+                        (Prims.of_int (706)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (5))
-                              (Prims.of_int (677)) (Prims.of_int (23)))
+                              (Prims.of_int (671)) (Prims.of_int (5))
+                              (Prims.of_int (671)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (2))
-                              (Prims.of_int (678)) (Prims.of_int (33)))
+                              (Prims.of_int (671)) (Prims.of_int (2))
+                              (Prims.of_int (672)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (9))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (671)) (Prims.of_int (9))
+                                    (Prims.of_int (671)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (5))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (671)) (Prims.of_int (5))
+                                    (Prims.of_int (671)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2791,15 +2775,15 @@ let (solve_gen_elim_prop_placeholder :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (681))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (681))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (681))
+                                       (Prims.of_int (675))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (711))
+                                       (Prims.of_int (705))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2813,15 +2797,15 @@ let (solve_gen_elim_prop_placeholder :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (682))
+                                                      (Prims.of_int (676))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (683))
+                                                      (Prims.of_int (677))
                                                       (Prims.of_int (54)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (684))
+                                                      (Prims.of_int (678))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (710))
+                                                      (Prims.of_int (704))
                                                       (Prims.of_int (56)))
                                                    (if
                                                       Prims.op_Negation
@@ -2862,43 +2846,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (681))
                                                                     (Prims.of_int (47)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (681))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (680))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2944,29 +2928,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (682))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2990,29 +2974,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (683))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3036,29 +3020,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (685))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (684))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3082,15 +3066,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (685))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -3121,15 +3105,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -3147,15 +3131,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -3169,15 +3153,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -3192,15 +3176,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3222,15 +3206,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3259,15 +3243,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (37)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_to_string
@@ -3281,15 +3265,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3303,15 +3287,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3338,15 +3322,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3373,15 +3357,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3396,15 +3380,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3419,15 +3403,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3442,15 +3426,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (699))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3465,15 +3449,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3488,15 +3472,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3511,15 +3495,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma

From 21822f4feb8ab769524764e01ebb2d0fa78561f3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 10:37:02 -0700
Subject: [PATCH 485/513] Revert "snap"

This reverts commit 32d012938d2220869035c1b41bfb7527edc153e7.
---
 .../generated/Steel_ST_GenElim_Base.ml        | 1484 +++++++----------
 1 file changed, 579 insertions(+), 905 deletions(-)

diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index f50533bf38f..ad134920e48 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (5))
-                          (Prims.of_int (342)) (Prims.of_int (28)))
+                          (Prims.of_int (310)) (Prims.of_int (5))
+                          (Prims.of_int (310)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (2))
-                          (Prims.of_int (352)) (Prims.of_int (12)))
+                          (Prims.of_int (310)) (Prims.of_int (2))
+                          (Prims.of_int (320)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (352))
+                                          (Prims.of_int (320))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (350))
+                                                                 (Prims.of_int (318))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (23))
-                         (Prims.of_int (361)) (Prims.of_int (40)))
+                         (Prims.of_int (329)) (Prims.of_int (23))
+                         (Prims.of_int (329)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (8))
-                         (Prims.of_int (372)) (Prims.of_int (47)))
+                         (Prims.of_int (329)) (Prims.of_int (8))
+                         (Prims.of_int (340)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (372))
+                                             (Prims.of_int (340))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -243,15 +243,15 @@ let rec (solve_gen_unit_elim :
                                                             FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (367))
+                                                                 (Prims.of_int (335))
                                                                  (Prims.of_int (20))
-                                                                 (Prims.of_int (367))
+                                                                 (Prims.of_int (335))
                                                                  (Prims.of_int (42)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (368))
+                                                                 (Prims.of_int (336))
                                                                  (Prims.of_int (10))
-                                                                 (Prims.of_int (369))
+                                                                 (Prims.of_int (337))
                                                                  (Prims.of_int (68)))
                                                               (Obj.magic
                                                                  (solve_gen_unit_elim
@@ -262,15 +262,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -321,10 +321,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -342,53 +342,22 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
-let rec (get_universe :
-  FStar_Reflection_Types.universe ->
-    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
-  =
-  fun uu___ ->
-    (fun u ->
-       match FStar_Reflection_Builtins.inspect_universe u with
-       | FStar_Reflection_Data.Uv_Zero ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.lift_div_tac
-                   (fun uu___ -> Prims.int_zero)))
-       | FStar_Reflection_Data.Uv_Succ u1 ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.tac_bind
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (23))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (19))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Obj.magic (get_universe u1))
-                   (fun uu___ ->
-                      FStar_Tactics_Effect.lift_div_tac
-                        (fun uu___1 -> Prims.int_one + uu___))))
-       | uu___ ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Derived.fail
-                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -405,11 +374,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (395)) (Prims.of_int (17))
-                      (Prims.of_int (395)) (Prims.of_int (40)))
+                      (Prims.of_int (355)) (Prims.of_int (17))
+                      (Prims.of_int (355)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (396)) (Prims.of_int (8))
-                      (Prims.of_int (396)) (Prims.of_int (45)))
+                      (Prims.of_int (356)) (Prims.of_int (8))
+                      (Prims.of_int (356)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -428,11 +397,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (26))
-                      (Prims.of_int (398)) (Prims.of_int (43)))
+                      (Prims.of_int (358)) (Prims.of_int (26))
+                      (Prims.of_int (358)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (8))
-                      (Prims.of_int (458)) (Prims.of_int (68)))
+                      (Prims.of_int (358)) (Prims.of_int (8))
+                      (Prims.of_int (399)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -445,126 +414,94 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (401))
-                                       (Prims.of_int (25))
-                                       (Prims.of_int (403))
-                                       (Prims.of_int (63)))
+                                       (Prims.of_int (362))
+                                       (Prims.of_int (12))
+                                       (Prims.of_int (365))
+                                       (Prims.of_int (46)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (405))
+                                       (Prims.of_int (361))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (437))
+                                       (Prims.of_int (378))
                                        (Prims.of_int (13)))
-                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
-                                             hd
-                                     with
-                                     | FStar_Reflection_Data.Tv_UInst
-                                         (uu___3, u::uu___4) ->
-                                         Obj.magic (get_universe u)
+                                    (match lbody with
+                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
+                                         (body,
+                                          FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         Obj.magic
+                                           (Obj.repr
+                                              (FStar_Tactics_Effect.lift_div_tac
+                                                 (fun uu___3 ->
+                                                    ([(ty,
+                                                        FStar_Reflection_Data.Q_Implicit)],
+                                                      body))))
+                                     | (body,
+                                        FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         Obj.magic
+                                           (Obj.repr
+                                              (FStar_Tactics_Effect.lift_div_tac
+                                                 (fun uu___3 -> ([], body))))
                                      | uu___3 ->
                                          Obj.magic
-                                           (FStar_Tactics_Derived.fail
-                                              "ill-formed exists_: no universe found"))
+                                           (Obj.repr
+                                              (FStar_Tactics_Derived.fail
+                                                 "ill-formed exists_")))
                                     (fun uu___3 ->
-                                       (fun universe ->
-                                          Obj.magic
-                                            (FStar_Tactics_Effect.tac_bind
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (406))
-                                                  (Prims.of_int (12))
-                                                  (Prims.of_int (409))
-                                                  (Prims.of_int (46)))
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (405))
-                                                  (Prims.of_int (10))
-                                                  (Prims.of_int (437))
-                                                  (Prims.of_int (13)))
-                                               (match lbody with
-                                                | (ty,
-                                                   FStar_Reflection_Data.Q_Implicit)::
-                                                    (body,
-                                                     FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    Obj.magic
-                                                      (Obj.repr
-                                                         (FStar_Tactics_Effect.lift_div_tac
-                                                            (fun uu___3 ->
-                                                               ([(ty,
-                                                                   FStar_Reflection_Data.Q_Implicit)],
-                                                                 body))))
-                                                | (body,
-                                                   FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    Obj.magic
-                                                      (Obj.repr
-                                                         (FStar_Tactics_Effect.lift_div_tac
-                                                            (fun uu___3 ->
-                                                               ([], body))))
-                                                | uu___3 ->
-                                                    Obj.magic
-                                                      (Obj.repr
-                                                         (FStar_Tactics_Derived.fail
-                                                            "ill-formed exists_")))
-                                               (fun uu___3 ->
-                                                  (fun uu___3 ->
-                                                     match uu___3 with
-                                                     | (ty, body) ->
-                                                         Obj.magic
-                                                           (FStar_Tactics_Effect.tac_bind
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (22))
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (36)))
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (16))
-                                                                 (Prims.of_int (436))
-                                                                 (Prims.of_int (21)))
-                                                              (Obj.magic
-                                                                 (FStar_Tactics_Builtins.inspect
-                                                                    body))
-                                                              (fun uu___4 ->
-                                                                 (fun uu___4
-                                                                    ->
-                                                                    match uu___4
-                                                                    with
-                                                                    | 
-                                                                    FStar_Reflection_Data.Tv_Abs
-                                                                    (b,
-                                                                    abody) ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.tac_bind
+                                       (fun uu___3 ->
+                                          match uu___3 with
+                                          | (ty, body) ->
+                                              Obj.magic
+                                                (FStar_Tactics_Effect.tac_bind
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (22))
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (36)))
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (16))
+                                                      (Prims.of_int (377))
+                                                      (Prims.of_int (45)))
+                                                   (Obj.magic
+                                                      (FStar_Tactics_Builtins.inspect
+                                                         body))
+                                                   (fun uu___4 ->
+                                                      (fun uu___4 ->
+                                                         match uu___4 with
+                                                         | FStar_Reflection_Data.Tv_Abs
+                                                             (b, abody) ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -593,16 +530,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -614,58 +551,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -695,32 +632,14 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___8
-                                                                    when
-                                                                    uu___8 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsUnit0"]))
-                                                                    | 
-                                                                    uu___8 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit1"])))
+                                                                    "GEExistsUnit"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -728,16 +647,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -749,58 +668,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (78)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -830,86 +749,48 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___9
-                                                                    when
-                                                                    uu___9 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExists0"]))
-                                                                    | 
-                                                                    uu___9 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists1"])))
+                                                                    "GEExists"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                                    | 
-                                                                    uu___5 ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                         | uu___5 ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___7
-                                                                    when
-                                                                    uu___7 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsNoAbs0"]))
-                                                                    | 
-                                                                    uu___7 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs1"])))
+                                                                    "GEExistsNoAbs"])))
                                                                     lbody))))
-                                                                   uu___4)))
-                                                    uu___3))) uu___3))
+                                                        uu___4))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (458))
+                                       (Prims.of_int (399))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -927,15 +808,15 @@ let rec (solve_gen_elim :
                                                       FStar_Tactics_Effect.tac_bind
                                                         (Prims.mk_range
                                                            "Steel.ST.GenElim.Base.fsti"
-                                                           (Prims.of_int (442))
+                                                           (Prims.of_int (383))
                                                            (Prims.of_int (15))
-                                                           (Prims.of_int (442))
+                                                           (Prims.of_int (383))
                                                            (Prims.of_int (42)))
                                                         (Prims.mk_range
                                                            "Steel.ST.GenElim.Base.fsti"
-                                                           (Prims.of_int (442))
+                                                           (Prims.of_int (383))
                                                            (Prims.of_int (12))
-                                                           (Prims.of_int (455))
+                                                           (Prims.of_int (396))
                                                            (Prims.of_int (72)))
                                                         (Obj.magic
                                                            (term_has_head tl
@@ -955,15 +836,15 @@ let rec (solve_gen_elim :
                                                                   (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -976,15 +857,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -1006,15 +887,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1043,15 +924,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1082,15 +963,15 @@ let rec (solve_gen_elim :
                                                                   (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1103,15 +984,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1194,11 +1075,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (19))
-                            (Prims.of_int (547)) (Prims.of_int (34)))
+                            (Prims.of_int (488)) (Prims.of_int (19))
+                            (Prims.of_int (488)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (4))
-                            (Prims.of_int (592)) (Prims.of_int (13)))
+                            (Prims.of_int (488)) (Prims.of_int (4))
+                            (Prims.of_int (532)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1218,15 +1099,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (552))
+                                                     (Prims.of_int (493))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (554))
-                                                     (Prims.of_int (88)))
+                                                     (Prims.of_int (495))
+                                                     (Prims.of_int (85)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (556))
+                                                     (Prims.of_int (497))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (582))
+                                                     (Prims.of_int (522))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1236,16 +1117,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (554))
-                                                                   (Prims.of_int (88)))
+                                                                   (Prims.of_int (495))
+                                                                   (Prims.of_int (85)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1264,16 +1145,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (495))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (554))
-                                                                    (Prims.of_int (88)))
+                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (85)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1291,9 +1172,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1306,15 +1185,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (497))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (556))
-                                                                (Prims.of_int (84)))
+                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (79)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (557))
+                                                                (Prims.of_int (498))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (582))
+                                                                (Prims.of_int (522))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1339,9 +1218,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1352,15 +1229,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (558))
+                                                                    (Prims.of_int (499))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1377,15 +1254,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (560))
+                                                                    (Prims.of_int (501))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (564))
+                                                                    (Prims.of_int (505))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (566))
+                                                                    (Prims.of_int (507))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1398,16 +1275,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1419,16 +1296,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (504))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1450,9 +1327,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1487,69 +1362,23 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (39))
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (81)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
-                                                                    (Prims.of_int (9)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.fresh_binder
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))))
-                                                                    (fun
-                                                                    uu___3 ->
-                                                                    (fun
-                                                                    dummy_raised_unit_binder
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (510))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (120)))
+                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.append
-                                                                    (FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders))
-                                                                    [dummy_raised_unit_binder]))
+                                                                    rev_types_and_binders)))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1559,15 +1388,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1587,15 +1416,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1608,88 +1437,37 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (573))
-                                                                    (Prims.of_int (151)))
+                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (113)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    = "_";
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (964));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    })
-                                                                    FStar_Reflection_Data.Q_Explicit
-                                                                    []),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"])))))))),
+                                                                    "vprop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1699,15 +1477,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1720,86 +1498,35 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (575))
-                                                                    (Prims.of_int (150)))
+                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (112)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (516))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    = "_";
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (967));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    })
-                                                                    FStar_Reflection_Data.Q_Explicit
-                                                                    []),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"])))))))),
+                                                                    "prop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1814,7 +1541,6 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
-                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1841,15 +1567,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (589))
+                                                         (Prims.of_int (529))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1910,11 +1636,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (599)) (Prims.of_int (17))
-                                 (Prims.of_int (599)) (Prims.of_int (64)))
+                                 (Prims.of_int (539)) (Prims.of_int (17))
+                                 (Prims.of_int (539)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (600)) (Prims.of_int (6))
-                                 (Prims.of_int (601)) (Prims.of_int (37)))
+                                 (Prims.of_int (540)) (Prims.of_int (6))
+                                 (Prims.of_int (541)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1933,15 +1659,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1975,10 +1701,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1993,17 +1719,13 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_UInst
-                            ((FStar_Reflection_Builtins.pack_fv
-                                ["Steel";
-                                "ST";
-                                "GenElim";
-                                "Base";
-                                "mk_gen_elim_nondep_by_tac"]),
-                              [FStar_Reflection_Builtins.pack_universe
-                                 (FStar_Reflection_Data.Uv_Succ
-                                    (FStar_Reflection_Builtins.pack_universe
-                                       FStar_Reflection_Data.Uv_Zero))])))
+                         (FStar_Reflection_Data.Tv_FVar
+                            (FStar_Reflection_Builtins.pack_fv
+                               ["Steel";
+                               "ST";
+                               "GenElim";
+                               "Base";
+                               "mk_gen_elim_nondep_by_tac"])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
@@ -2013,16 +1735,16 @@ let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-         (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-         (Prims.of_int (2)) (Prims.of_int (664)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-               (Prims.of_int (31)) (Prims.of_int (626)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (626))
-               (Prims.of_int (17)) (Prims.of_int (626)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2034,27 +1756,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (627)) (Prims.of_int (2))
-                        (Prims.of_int (628)) (Prims.of_int (33)))
+                        (Prims.of_int (567)) (Prims.of_int (2))
+                        (Prims.of_int (568)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (629)) (Prims.of_int (2))
-                        (Prims.of_int (664)) (Prims.of_int (35)))
+                        (Prims.of_int (569)) (Prims.of_int (2))
+                        (Prims.of_int (604)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (627)) (Prims.of_int (5))
-                              (Prims.of_int (627)) (Prims.of_int (23)))
+                              (Prims.of_int (567)) (Prims.of_int (5))
+                              (Prims.of_int (567)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (627)) (Prims.of_int (2))
-                              (Prims.of_int (628)) (Prims.of_int (33)))
+                              (Prims.of_int (567)) (Prims.of_int (2))
+                              (Prims.of_int (568)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (627)) (Prims.of_int (9))
-                                    (Prims.of_int (627)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (9))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (627)) (Prims.of_int (5))
-                                    (Prims.of_int (627)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (5))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2080,15 +1802,15 @@ let (solve_gen_elim_prop :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (631))
+                                       (Prims.of_int (571))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (631))
+                                       (Prims.of_int (571))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (631))
+                                       (Prims.of_int (571))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (663))
+                                       (Prims.of_int (603))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2102,15 +1824,15 @@ let (solve_gen_elim_prop :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (632))
+                                                      (Prims.of_int (572))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (633))
+                                                      (Prims.of_int (573))
                                                       (Prims.of_int (42)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (634))
+                                                      (Prims.of_int (574))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (662))
+                                                      (Prims.of_int (602))
                                                       (Prims.of_int (44)))
                                                    (if
                                                       Prims.op_Negation
@@ -2151,15 +1873,15 @@ let (solve_gen_elim_prop :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (74)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2177,15 +1899,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2199,15 +1921,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2231,29 +1953,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2304,15 +2026,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (646))
+                                                                    (Prims.of_int (586))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (653))
+                                                                    (Prims.of_int (593))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2348,15 +2070,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2366,15 +2088,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (654))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2402,15 +2124,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (655))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2437,15 +2159,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2455,15 +2177,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (657))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2487,15 +2209,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2505,15 +2227,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2527,15 +2249,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (45)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (47))
-                                                                    (Prims.of_int (658))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.trivial
@@ -2561,15 +2283,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2579,15 +2301,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2611,15 +2333,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2629,15 +2351,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2665,15 +2387,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2708,16 +2430,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-         (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-         (Prims.of_int (2)) (Prims.of_int (706)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-               (Prims.of_int (31)) (Prims.of_int (670)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (670))
-               (Prims.of_int (17)) (Prims.of_int (670)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2729,27 +2451,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (671)) (Prims.of_int (2))
-                        (Prims.of_int (672)) (Prims.of_int (33)))
+                        (Prims.of_int (611)) (Prims.of_int (2))
+                        (Prims.of_int (612)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (673)) (Prims.of_int (2))
-                        (Prims.of_int (706)) (Prims.of_int (35)))
+                        (Prims.of_int (613)) (Prims.of_int (2))
+                        (Prims.of_int (644)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (671)) (Prims.of_int (5))
-                              (Prims.of_int (671)) (Prims.of_int (23)))
+                              (Prims.of_int (611)) (Prims.of_int (5))
+                              (Prims.of_int (611)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (671)) (Prims.of_int (2))
-                              (Prims.of_int (672)) (Prims.of_int (33)))
+                              (Prims.of_int (611)) (Prims.of_int (2))
+                              (Prims.of_int (612)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (671)) (Prims.of_int (9))
-                                    (Prims.of_int (671)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (9))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (671)) (Prims.of_int (5))
-                                    (Prims.of_int (671)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (5))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2775,15 +2497,15 @@ let (solve_gen_elim_prop_placeholder :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (675))
+                                       (Prims.of_int (615))
                                        (Prims.of_int (21))
-                                       (Prims.of_int (675))
+                                       (Prims.of_int (615))
                                        (Prims.of_int (40)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (675))
+                                       (Prims.of_int (615))
                                        (Prims.of_int (4))
-                                       (Prims.of_int (705))
+                                       (Prims.of_int (643))
                                        (Prims.of_int (7)))
                                     (FStar_Tactics_Effect.lift_div_tac
                                        (fun uu___3 ->
@@ -2797,15 +2519,15 @@ let (solve_gen_elim_prop_placeholder :
                                                 (FStar_Tactics_Effect.tac_bind
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (676))
+                                                      (Prims.of_int (616))
                                                       (Prims.of_int (4))
-                                                      (Prims.of_int (677))
+                                                      (Prims.of_int (617))
                                                       (Prims.of_int (54)))
                                                    (Prims.mk_range
                                                       "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (678))
+                                                      (Prims.of_int (618))
                                                       (Prims.of_int (10))
-                                                      (Prims.of_int (704))
+                                                      (Prims.of_int (642))
                                                       (Prims.of_int (56)))
                                                    (if
                                                       Prims.op_Negation
@@ -2846,43 +2568,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                (FStar_Tactics_Effect.tac_bind
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (681))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                   (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                   (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (681))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (680))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2928,29 +2650,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (682))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2974,29 +2696,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (683))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3020,29 +2742,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (685))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (684))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3066,15 +2788,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (685))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (626))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -3105,15 +2827,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -3131,15 +2853,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -3153,15 +2875,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -3176,15 +2898,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3206,21 +2928,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (691))
-                                                                    (Prims.of_int (89)))
+                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
-                                                                    (FStar_Tactics_Effect.lift_div_tac
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    FStar_Reflection_Derived.mk_app
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -3233,7 +2953,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)]))
+                                                                    FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -3243,59 +2963,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (692))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (692))
-                                                                    (Prims.of_int (37)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Builtins.term_to_string
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun
-                                                                    a'_ts ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (693))
-                                                                    (Prims.of_int (27)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun a'1
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
-                                                                    (Prims.of_int (15))
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3322,15 +2998,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3357,15 +3033,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3380,19 +3056,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'1))
+                                                                    a'))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3403,15 +3079,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3426,15 +3102,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3449,15 +3125,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3472,15 +3148,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3495,15 +3171,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3535,8 +3211,6 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
-                                                                    uu___12)))
-                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From 0810afff86537a764cdeab1d321b4cdc26135460 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 10:37:37 -0700
Subject: [PATCH 486/513] Revert "snap"

This reverts commit 848eedc5310498c71a6f4f740e1da6922437fabc.
---
 .../generated/FStar_Extraction_Krml.ml        | 433 ++++++------------
 ocaml/fstar-lib/generated/FStar_Main.ml       |   3 +-
 2 files changed, 132 insertions(+), 304 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index dd7c2505755..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,18 +996,16 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" ->
-          translate_type_without_decay env1 arg
+          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1163,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1198,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2669,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3098,122 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type_without_decay env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 =
-                                        translate_type_without_decay env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3553,10 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (init : unit -> unit) =
-  fun uu___ ->
-    register_post_translate_type_without_decay translate_type_without_decay';
-    register_post_translate_type translate_type';
-    register_post_translate_type_decl translate_type_decl';
-    register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index d763e38153f..8ad6b788389 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,8 +294,7 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
-    FStar_Extraction_Krml.init ()
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in

From 1a8c308927fbd73a2cf29e749ac2217a413609f2 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 10:42:11 -0700
Subject: [PATCH 487/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        |  433 +++--
 ocaml/fstar-lib/generated/FStar_Main.ml       |    3 +-
 .../generated/Steel_ST_GenElim_Base.ml        | 1538 ++++++++++-------
 3 files changed, 1245 insertions(+), 729 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..dd7c2505755 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,16 +1142,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1163,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1198,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2669,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3098,122 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3553,10 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (init : unit -> unit) =
+  fun uu___ ->
+    register_post_translate_type_without_decay translate_type_without_decay';
+    register_post_translate_type translate_type';
+    register_post_translate_type_decl translate_type_decl';
+    register_post_translate_expr translate_expr'
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index 8ad6b788389..d763e38153f 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,7 +294,8 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
+    FStar_Extraction_Krml.init ()
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index 2ca503ea1dc..9695b1193f2 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (5))
-                          (Prims.of_int (310)) (Prims.of_int (28)))
+                          (Prims.of_int (342)) (Prims.of_int (5))
+                          (Prims.of_int (342)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (2))
-                          (Prims.of_int (320)) (Prims.of_int (12)))
+                          (Prims.of_int (342)) (Prims.of_int (2))
+                          (Prims.of_int (352)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (320))
+                                          (Prims.of_int (352))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (318))
+                                                                 (Prims.of_int (350))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (23))
-                         (Prims.of_int (329)) (Prims.of_int (40)))
+                         (Prims.of_int (361)) (Prims.of_int (23))
+                         (Prims.of_int (361)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (8))
-                         (Prims.of_int (340)) (Prims.of_int (47)))
+                         (Prims.of_int (361)) (Prims.of_int (8))
+                         (Prims.of_int (372)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (340))
+                                             (Prims.of_int (372))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,22 +347,53 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
+let rec (get_universe :
+  FStar_Reflection_Types.universe ->
+    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
+  =
+  fun uu___ ->
+    (fun u ->
+       match FStar_Reflection_Builtins.inspect_universe u with
+       | FStar_Reflection_Data.Uv_Zero ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.lift_div_tac
+                   (fun uu___ -> Prims.int_zero)))
+       | FStar_Reflection_Data.Uv_Succ u1 ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.tac_bind
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (23))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (19))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Obj.magic (get_universe u1))
+                   (fun uu___ ->
+                      FStar_Tactics_Effect.lift_div_tac
+                        (fun uu___1 -> Prims.int_one + uu___))))
+       | uu___ ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Derived.fail
+                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -379,11 +410,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (355)) (Prims.of_int (17))
-                      (Prims.of_int (355)) (Prims.of_int (40)))
+                      (Prims.of_int (395)) (Prims.of_int (17))
+                      (Prims.of_int (395)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (356)) (Prims.of_int (8))
-                      (Prims.of_int (356)) (Prims.of_int (45)))
+                      (Prims.of_int (396)) (Prims.of_int (8))
+                      (Prims.of_int (396)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -402,11 +433,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (26))
-                      (Prims.of_int (358)) (Prims.of_int (43)))
+                      (Prims.of_int (398)) (Prims.of_int (26))
+                      (Prims.of_int (398)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (8))
-                      (Prims.of_int (399)) (Prims.of_int (68)))
+                      (Prims.of_int (398)) (Prims.of_int (8))
+                      (Prims.of_int (458)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -419,88 +450,122 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (362))
-                                       (Prims.of_int (12))
-                                       (Prims.of_int (365))
-                                       (Prims.of_int (46)))
+                                       (Prims.of_int (401))
+                                       (Prims.of_int (25))
+                                       (Prims.of_int (403))
+                                       (Prims.of_int (63)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (361))
+                                       (Prims.of_int (405))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (378))
+                                       (Prims.of_int (437))
                                        (Prims.of_int (13)))
-                                    (match lbody with
-                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
-                                         (body,
-                                          FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 ->
-                                              ([(ty,
-                                                  FStar_Reflection_Data.Q_Implicit)],
-                                                body))
-                                     | (body,
-                                        FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 -> ([], body))
+                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
+                                             hd
+                                     with
+                                     | FStar_Reflection_Data.Tv_UInst
+                                         (uu___3, u::uu___4) ->
+                                         Obj.magic
+                                           (Obj.repr (get_universe u))
                                      | uu___3 ->
-                                         FStar_Tactics_Derived.fail
-                                           "ill-formed exists_")
+                                         Obj.magic
+                                           (Obj.repr
+                                              (FStar_Tactics_Derived.fail
+                                                 "ill-formed exists_: no universe found")))
                                     (fun uu___3 ->
-                                       (fun uu___3 ->
-                                          match uu___3 with
-                                          | (ty, body) ->
-                                              Obj.magic
-                                                (FStar_Tactics_Effect.tac_bind
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (22))
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (36)))
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (16))
-                                                      (Prims.of_int (377))
-                                                      (Prims.of_int (45)))
-                                                   (Obj.magic
-                                                      (FStar_Tactics_Builtins.inspect
-                                                         body))
-                                                   (fun uu___4 ->
-                                                      (fun uu___4 ->
-                                                         match uu___4 with
-                                                         | FStar_Reflection_Data.Tv_Abs
-                                                             (b, abody) ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.tac_bind
+                                       (fun universe ->
+                                          Obj.magic
+                                            (FStar_Tactics_Effect.tac_bind
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (406))
+                                                  (Prims.of_int (12))
+                                                  (Prims.of_int (409))
+                                                  (Prims.of_int (46)))
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (405))
+                                                  (Prims.of_int (10))
+                                                  (Prims.of_int (437))
+                                                  (Prims.of_int (13)))
+                                               (match lbody with
+                                                | (ty,
+                                                   FStar_Reflection_Data.Q_Implicit)::
+                                                    (body,
+                                                     FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([(ty,
+                                                             FStar_Reflection_Data.Q_Implicit)],
+                                                           body))
+                                                | (body,
+                                                   FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([], body))
+                                                | uu___3 ->
+                                                    FStar_Tactics_Derived.fail
+                                                      "ill-formed exists_")
+                                               (fun uu___3 ->
+                                                  (fun uu___3 ->
+                                                     match uu___3 with
+                                                     | (ty, body) ->
+                                                         Obj.magic
+                                                           (FStar_Tactics_Effect.tac_bind
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (22))
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (36)))
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (16))
+                                                                 (Prims.of_int (436))
+                                                                 (Prims.of_int (21)))
+                                                              (Obj.magic
+                                                                 (FStar_Tactics_Builtins.inspect
+                                                                    body))
+                                                              (fun uu___4 ->
+                                                                 (fun uu___4
+                                                                    ->
+                                                                    match uu___4
+                                                                    with
+                                                                    | 
+                                                                    FStar_Reflection_Data.Tv_Abs
+                                                                    (b,
+                                                                    abody) ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -529,16 +594,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -550,58 +615,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (82)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -631,14 +696,32 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___8
+                                                                    when
+                                                                    uu___8 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit"])))
+                                                                    "GEExistsUnit0"]))
+                                                                    | 
+                                                                    uu___8 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsUnit1"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -646,16 +729,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -667,58 +750,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (78)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -748,48 +831,86 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___9
+                                                                    when
+                                                                    uu___9 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists"])))
+                                                                    "GEExists0"]))
+                                                                    | 
+                                                                    uu___9 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExists1"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                         | uu___5 ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.lift_div_tac
+                                                                    | 
+                                                                    uu___5 ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___7
+                                                                    when
+                                                                    uu___7 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs"])))
+                                                                    "GEExistsNoAbs0"]))
+                                                                    | 
+                                                                    uu___7 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsNoAbs1"])))
                                                                     lbody))))
-                                                        uu___4))) uu___3))
+                                                                   uu___4)))
+                                                    uu___3))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (399))
+                                       (Prims.of_int (458))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -808,15 +929,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (396))
+                                                              (Prims.of_int (455))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -837,15 +958,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -858,15 +979,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -888,15 +1009,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -925,15 +1046,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -964,15 +1085,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -985,15 +1106,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1077,11 +1198,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (19))
-                            (Prims.of_int (488)) (Prims.of_int (34)))
+                            (Prims.of_int (547)) (Prims.of_int (19))
+                            (Prims.of_int (547)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (4))
-                            (Prims.of_int (532)) (Prims.of_int (13)))
+                            (Prims.of_int (547)) (Prims.of_int (4))
+                            (Prims.of_int (592)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1101,15 +1222,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (493))
+                                                     (Prims.of_int (552))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (495))
-                                                     (Prims.of_int (85)))
+                                                     (Prims.of_int (554))
+                                                     (Prims.of_int (88)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (497))
+                                                     (Prims.of_int (556))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (522))
+                                                     (Prims.of_int (582))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1119,16 +1240,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (495))
-                                                                   (Prims.of_int (85)))
+                                                                   (Prims.of_int (554))
+                                                                   (Prims.of_int (88)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1147,16 +1268,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (554))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (495))
-                                                                    (Prims.of_int (85)))
+                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (88)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1174,7 +1295,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1187,15 +1310,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (556))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (497))
-                                                                (Prims.of_int (79)))
+                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (84)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (498))
+                                                                (Prims.of_int (557))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (522))
+                                                                (Prims.of_int (582))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1220,7 +1343,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1231,15 +1356,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (499))
+                                                                    (Prims.of_int (558))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1256,15 +1381,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (501))
+                                                                    (Prims.of_int (560))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (505))
+                                                                    (Prims.of_int (564))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (507))
+                                                                    (Prims.of_int (566))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1277,16 +1402,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1298,16 +1423,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (563))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1329,7 +1454,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1364,23 +1491,69 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (39))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (81)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (8))
+                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (9)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.fresh_binder
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))))
+                                                                    (fun
+                                                                    uu___3 ->
+                                                                    (fun
+                                                                    dummy_raised_unit_binder
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (510))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (120)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.append
+                                                                    (FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders)))
+                                                                    rev_types_and_binders))
+                                                                    [dummy_raised_unit_binder]))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1390,15 +1563,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1418,15 +1591,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1439,37 +1612,88 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (513))
-                                                                    (Prims.of_int (113)))
+                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (151)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    = "_";
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (964));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    })
+                                                                    FStar_Reflection_Data.Q_Explicit
+                                                                    []),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"]))),
+                                                                    "vprop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1479,15 +1703,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1500,35 +1724,86 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (515))
-                                                                    (Prims.of_int (112)))
+                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (150)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (516))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    = "_";
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (967));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    })
+                                                                    FStar_Reflection_Data.Q_Explicit
+                                                                    []),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"]))),
+                                                                    "prop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1543,6 +1818,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
+                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1569,15 +1845,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (529))
+                                                         (Prims.of_int (589))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1638,11 +1914,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (539)) (Prims.of_int (17))
-                                 (Prims.of_int (539)) (Prims.of_int (64)))
+                                 (Prims.of_int (599)) (Prims.of_int (17))
+                                 (Prims.of_int (599)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (540)) (Prims.of_int (6))
-                                 (Prims.of_int (541)) (Prims.of_int (37)))
+                                 (Prims.of_int (600)) (Prims.of_int (6))
+                                 (Prims.of_int (601)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1661,15 +1937,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1703,10 +1979,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1721,32 +1997,76 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_FVar
-                            (FStar_Reflection_Builtins.pack_fv
-                               ["Steel";
-                               "ST";
-                               "GenElim";
-                               "Base";
-                               "mk_gen_elim_nondep_by_tac"])))
+                         (FStar_Reflection_Data.Tv_UInst
+                            ((FStar_Reflection_Builtins.pack_fv
+                                ["Steel";
+                                "ST";
+                                "GenElim";
+                                "Base";
+                                "mk_gen_elim_nondep_by_tac"]),
+                              [FStar_Reflection_Builtins.pack_universe
+                                 (FStar_Reflection_Data.Uv_Succ
+                                    (FStar_Reflection_Builtins.pack_universe
+                                       FStar_Reflection_Data.Uv_Zero))])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
+let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
+  fun uu___ ->
+    FStar_Tactics_Effect.tac_bind
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
+         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
+         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
+      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
+      (fun uu___1 ->
+         (fun ty ->
+            Obj.magic
+              (FStar_Tactics_Effect.tac_bind
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (8))
+                    (Prims.of_int (624)) (Prims.of_int (28)))
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (2))
+                    (Prims.of_int (626)) (Prims.of_int (27)))
+                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
+                 (fun uu___1 ->
+                    (fun uu___1 ->
+                       match uu___1 with
+                       | FStar_Reflection_Formula.Comp
+                           (uu___2, uu___3, uu___4) ->
+                           Obj.magic (FStar_Tactics_Derived.trefl ())
+                       | uu___2 ->
+                           Obj.magic
+                             (FStar_Tactics_Effect.tac_bind
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (9))
+                                   (Prims.of_int (626)) (Prims.of_int (17)))
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (19))
+                                   (Prims.of_int (626)) (Prims.of_int (27)))
+                                (Obj.magic (FStar_Tactics_Derived.smt ()))
+                                (fun uu___3 ->
+                                   (fun uu___3 ->
+                                      Obj.magic
+                                        (FStar_Tactics_Derived.qed ()))
+                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -1758,27 +2078,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (567)) (Prims.of_int (2))
-                        (Prims.of_int (568)) (Prims.of_int (33)))
+                        (Prims.of_int (633)) (Prims.of_int (2))
+                        (Prims.of_int (634)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (569)) (Prims.of_int (2))
-                        (Prims.of_int (604)) (Prims.of_int (35)))
+                        (Prims.of_int (635)) (Prims.of_int (2))
+                        (Prims.of_int (670)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (5))
-                              (Prims.of_int (567)) (Prims.of_int (23)))
+                              (Prims.of_int (633)) (Prims.of_int (5))
+                              (Prims.of_int (633)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (2))
-                              (Prims.of_int (568)) (Prims.of_int (33)))
+                              (Prims.of_int (633)) (Prims.of_int (2))
+                              (Prims.of_int (634)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (9))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (9))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (5))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (5))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -1800,15 +2120,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (603))
+                                          (Prims.of_int (669))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -1822,15 +2142,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (572))
+                                                         (Prims.of_int (638))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (573))
+                                                         (Prims.of_int (639))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (574))
+                                                         (Prims.of_int (640))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (602))
+                                                         (Prims.of_int (668))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -1869,15 +2189,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -1895,15 +2215,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1917,15 +2237,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1949,29 +2269,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2022,15 +2342,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (586))
+                                                                    (Prims.of_int (652))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (593))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2066,15 +2386,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2084,15 +2404,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2120,15 +2440,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2155,15 +2475,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2173,15 +2493,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2205,15 +2525,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (56)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (49)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2223,16 +2543,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (48)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2242,32 +2562,8 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (45)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (47))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.trivial
-                                                                    ()))
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Derived.qed
+                                                                    (trefl_or_smt
                                                                     ()))
-                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2279,15 +2575,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2297,15 +2593,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2329,15 +2625,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2347,15 +2643,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2383,15 +2679,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2429,16 +2725,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2450,27 +2746,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (611)) (Prims.of_int (2))
-                        (Prims.of_int (612)) (Prims.of_int (33)))
+                        (Prims.of_int (677)) (Prims.of_int (2))
+                        (Prims.of_int (678)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (613)) (Prims.of_int (2))
-                        (Prims.of_int (644)) (Prims.of_int (35)))
+                        (Prims.of_int (679)) (Prims.of_int (2))
+                        (Prims.of_int (712)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (5))
-                              (Prims.of_int (611)) (Prims.of_int (23)))
+                              (Prims.of_int (677)) (Prims.of_int (5))
+                              (Prims.of_int (677)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (2))
-                              (Prims.of_int (612)) (Prims.of_int (33)))
+                              (Prims.of_int (677)) (Prims.of_int (2))
+                              (Prims.of_int (678)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (9))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (9))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (5))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (5))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2492,15 +2788,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (643))
+                                          (Prims.of_int (711))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2514,15 +2810,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (616))
+                                                         (Prims.of_int (682))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (617))
+                                                         (Prims.of_int (683))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (618))
+                                                         (Prims.of_int (684))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (642))
+                                                         (Prims.of_int (710))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2561,43 +2857,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2635,29 +2931,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2681,29 +2977,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2727,29 +3023,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2773,15 +3069,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (626))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -2808,15 +3104,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2834,15 +3130,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2856,15 +3152,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -2879,15 +3175,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2909,19 +3205,21 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (631))
-                                                                    (Prims.of_int (101)))
+                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    (FStar_Reflection_Derived.mk_app
+                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -2934,7 +3232,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)])))
+                                                                    FStar_Reflection_Data.Q_Explicit)]))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -2944,15 +3242,59 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (37)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Builtins.term_to_string
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun
+                                                                    a'_ts ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (15))
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (27)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun a'1
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -2979,15 +3321,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3014,15 +3356,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3037,19 +3379,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'))
+                                                                    a'1))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3060,15 +3402,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3083,15 +3425,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3106,15 +3448,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3129,15 +3471,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3152,15 +3494,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3192,6 +3534,8 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
+                                                                    uu___12)))
+                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From 826100b32402dd12a7a9716f2bc99d952509d7db Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 14:17:19 -0700
Subject: [PATCH 488/513] move slow .fst to examples

---
 examples/steel/arraystructs/Makefile          |  7 +++-
 examples/steel/arraystructs/fstlib/Makefile   | 41 +++++++++++++++++++
 examples/steel/arraystructs/fstlib/README     |  6 +++
 .../fstlib}/Steel.C.Array.Base.fst            |  0
 .../arraystructs/fstlib}/Steel.C.Array.fst    |  0
 .../fstlib}/Steel.ST.C.Types.Array.fst        |  0
 .../fstlib}/Steel.ST.C.Types.Base.fst         |  0
 .../fstlib}/Steel.ST.C.Types.Fields.fst       |  0
 .../fstlib}/Steel.ST.C.Types.Rewrite.fst      |  0
 .../fstlib}/Steel.ST.C.Types.Scalar.fst       |  0
 .../fstlib}/Steel.ST.C.Types.Struct.Aux.fst   |  0
 .../fstlib}/Steel.ST.C.Types.Struct.fst       |  0
 .../fstlib}/Steel.ST.C.Types.Union.fst        |  0
 .../fstlib}/Steel.ST.C.Types.UserStruct.fst   |  0
 14 files changed, 52 insertions(+), 2 deletions(-)
 create mode 100644 examples/steel/arraystructs/fstlib/Makefile
 create mode 100644 examples/steel/arraystructs/fstlib/README
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.C.Array.Base.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.C.Array.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Array.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Base.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Fields.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Rewrite.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Scalar.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Struct.Aux.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Struct.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.Union.fst (100%)
 rename {ulib/experimental => examples/steel/arraystructs/fstlib}/Steel.ST.C.Types.UserStruct.fst (100%)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index d0385857933..6398d2915d8 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -17,7 +17,10 @@ KRML_EXE = $(KRML_HOME)/krml
 INCLUDE_PATH += $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj
 endif
 
-world: verify test
+world: verify test fstlib
+
+fstlib:
+	+$(MAKE) -C $@
 
 FSTAR_OPTIONS = --cache_checked_modules \
 		--cmi \
@@ -104,4 +107,4 @@ test:
 
 endif # KRML_HOME
 
-.PHONY: all world verify clean depend test
+.PHONY: all world verify clean depend test fstlib
diff --git a/examples/steel/arraystructs/fstlib/Makefile b/examples/steel/arraystructs/fstlib/Makefile
new file mode 100644
index 00000000000..88b83b24caf
--- /dev/null
+++ b/examples/steel/arraystructs/fstlib/Makefile
@@ -0,0 +1,41 @@
+all: verify
+
+FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
+export FSTAR_HOME
+FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
+
+INCLUDE_PATH := $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental
+
+FSTAR_OPTIONS = --cache_checked_modules \
+		--cmi \
+		--compat_pre_typed_indexed_effects \
+	        --already_cached '*,-Steel.C.Array,-Steel.ST.C.Types' \
+		$(addprefix --include ,$(INCLUDE_PATH)) \
+		$(OTHERFLAGS)
+
+FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
+
+ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
+
+.depend: $(ALL_SOURCE_FILES) Makefile
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) > $@.tmp
+	mv $@.tmp $@
+
+depend: .depend
+
+-include .depend
+
+$(ALL_CHECKED_FILES): %.checked:
+	$(FSTAR) $<
+	@touch -c $@
+
+verify: $(ALL_CHECKED_FILES)
+	echo $*
+
+%.fst-in %.fsti-in:
+	@echo $(FSTAR_OPTIONS)
+
+clean:
+	-rm -rf *.checked .depend .depend.tmp
+
+.PHONY: all verify clean depend
diff --git a/examples/steel/arraystructs/fstlib/README b/examples/steel/arraystructs/fstlib/README
new file mode 100644
index 00000000000..a55ab4f2ad7
--- /dev/null
+++ b/examples/steel/arraystructs/fstlib/README
@@ -0,0 +1,6 @@
+This directory contains the .fst implementations of SteelC modules
+that used to be part of ulib/experimental, but take too long to
+verify.
+
+Those .fst here all have corresponding .fsti files in
+ulib/experimental.
diff --git a/ulib/experimental/Steel.C.Array.Base.fst b/examples/steel/arraystructs/fstlib/Steel.C.Array.Base.fst
similarity index 100%
rename from ulib/experimental/Steel.C.Array.Base.fst
rename to examples/steel/arraystructs/fstlib/Steel.C.Array.Base.fst
diff --git a/ulib/experimental/Steel.C.Array.fst b/examples/steel/arraystructs/fstlib/Steel.C.Array.fst
similarity index 100%
rename from ulib/experimental/Steel.C.Array.fst
rename to examples/steel/arraystructs/fstlib/Steel.C.Array.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Array.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Base.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Base.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Base.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Fields.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Fields.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Fields.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Fields.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Rewrite.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Rewrite.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Rewrite.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Rewrite.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Scalar.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Scalar.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Scalar.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Scalar.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.Aux.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Struct.Aux.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.Aux.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Struct.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Struct.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.Union.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Union.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.Union.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Union.fst
diff --git a/ulib/experimental/Steel.ST.C.Types.UserStruct.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.UserStruct.fst
similarity index 100%
rename from ulib/experimental/Steel.ST.C.Types.UserStruct.fst
rename to examples/steel/arraystructs/fstlib/Steel.ST.C.Types.UserStruct.fst

From 17e49bad8a48d00e57eecf554f3747d0d5b64ec4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 21 Mar 2023 15:39:19 -0700
Subject: [PATCH 489/513] ignore branch for CI, already covered by PR

---
 .github/workflows/linux-x64.yaml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/linux-x64.yaml b/.github/workflows/linux-x64.yaml
index 9dbfb75ac89..6960558e42e 100644
--- a/.github/workflows/linux-x64.yaml
+++ b/.github/workflows/linux-x64.yaml
@@ -3,6 +3,7 @@ on:
   push:
     branches-ignore:
     - _**
+    - john_ml_steel_c
   pull_request:
   workflow_dispatch:
     inputs:

From 3ced567db8124d354d4e082f0e846d329378a6da Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Mar 2023 22:24:47 -0700
Subject: [PATCH 490/513] Revert "snap"

This reverts commit 1a8c308927fbd73a2cf29e749ac2217a413609f2.
---
 .../generated/FStar_Extraction_Krml.ml        |  433 ++---
 ocaml/fstar-lib/generated/FStar_Main.ml       |    3 +-
 .../generated/Steel_ST_GenElim_Base.ml        | 1538 +++++++----------
 3 files changed, 729 insertions(+), 1245 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index dd7c2505755..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,18 +996,16 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" ->
-          translate_type_without_decay env1 arg
+          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1163,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1198,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2669,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3098,122 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type_without_decay env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 =
-                                        translate_type_without_decay env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3553,10 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (init : unit -> unit) =
-  fun uu___ ->
-    register_post_translate_type_without_decay translate_type_without_decay';
-    register_post_translate_type translate_type';
-    register_post_translate_type_decl translate_type_decl';
-    register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index d763e38153f..8ad6b788389 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,8 +294,7 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
-    FStar_Extraction_Krml.init ()
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index 9695b1193f2..2ca503ea1dc 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (5))
-                          (Prims.of_int (342)) (Prims.of_int (28)))
+                          (Prims.of_int (310)) (Prims.of_int (5))
+                          (Prims.of_int (310)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (2))
-                          (Prims.of_int (352)) (Prims.of_int (12)))
+                          (Prims.of_int (310)) (Prims.of_int (2))
+                          (Prims.of_int (320)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (352))
+                                          (Prims.of_int (320))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (350))
+                                                                 (Prims.of_int (318))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (23))
-                         (Prims.of_int (361)) (Prims.of_int (40)))
+                         (Prims.of_int (329)) (Prims.of_int (23))
+                         (Prims.of_int (329)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (8))
-                         (Prims.of_int (372)) (Prims.of_int (47)))
+                         (Prims.of_int (329)) (Prims.of_int (8))
+                         (Prims.of_int (340)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (372))
+                                             (Prims.of_int (340))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (367))
+                                                                    (Prims.of_int (335))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (367))
+                                                                    (Prims.of_int (335))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,53 +347,22 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
-let rec (get_universe :
-  FStar_Reflection_Types.universe ->
-    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
-  =
-  fun uu___ ->
-    (fun u ->
-       match FStar_Reflection_Builtins.inspect_universe u with
-       | FStar_Reflection_Data.Uv_Zero ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.lift_div_tac
-                   (fun uu___ -> Prims.int_zero)))
-       | FStar_Reflection_Data.Uv_Succ u1 ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.tac_bind
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (23))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (19))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Obj.magic (get_universe u1))
-                   (fun uu___ ->
-                      FStar_Tactics_Effect.lift_div_tac
-                        (fun uu___1 -> Prims.int_one + uu___))))
-       | uu___ ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Derived.fail
-                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -410,11 +379,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (395)) (Prims.of_int (17))
-                      (Prims.of_int (395)) (Prims.of_int (40)))
+                      (Prims.of_int (355)) (Prims.of_int (17))
+                      (Prims.of_int (355)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (396)) (Prims.of_int (8))
-                      (Prims.of_int (396)) (Prims.of_int (45)))
+                      (Prims.of_int (356)) (Prims.of_int (8))
+                      (Prims.of_int (356)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -433,11 +402,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (26))
-                      (Prims.of_int (398)) (Prims.of_int (43)))
+                      (Prims.of_int (358)) (Prims.of_int (26))
+                      (Prims.of_int (358)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (8))
-                      (Prims.of_int (458)) (Prims.of_int (68)))
+                      (Prims.of_int (358)) (Prims.of_int (8))
+                      (Prims.of_int (399)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -450,122 +419,88 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (401))
-                                       (Prims.of_int (25))
-                                       (Prims.of_int (403))
-                                       (Prims.of_int (63)))
+                                       (Prims.of_int (362))
+                                       (Prims.of_int (12))
+                                       (Prims.of_int (365))
+                                       (Prims.of_int (46)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (405))
+                                       (Prims.of_int (361))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (437))
+                                       (Prims.of_int (378))
                                        (Prims.of_int (13)))
-                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
-                                             hd
-                                     with
-                                     | FStar_Reflection_Data.Tv_UInst
-                                         (uu___3, u::uu___4) ->
-                                         Obj.magic
-                                           (Obj.repr (get_universe u))
+                                    (match lbody with
+                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
+                                         (body,
+                                          FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         FStar_Tactics_Effect.lift_div_tac
+                                           (fun uu___3 ->
+                                              ([(ty,
+                                                  FStar_Reflection_Data.Q_Implicit)],
+                                                body))
+                                     | (body,
+                                        FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         FStar_Tactics_Effect.lift_div_tac
+                                           (fun uu___3 -> ([], body))
                                      | uu___3 ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Derived.fail
-                                                 "ill-formed exists_: no universe found")))
+                                         FStar_Tactics_Derived.fail
+                                           "ill-formed exists_")
                                     (fun uu___3 ->
-                                       (fun universe ->
-                                          Obj.magic
-                                            (FStar_Tactics_Effect.tac_bind
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (406))
-                                                  (Prims.of_int (12))
-                                                  (Prims.of_int (409))
-                                                  (Prims.of_int (46)))
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (405))
-                                                  (Prims.of_int (10))
-                                                  (Prims.of_int (437))
-                                                  (Prims.of_int (13)))
-                                               (match lbody with
-                                                | (ty,
-                                                   FStar_Reflection_Data.Q_Implicit)::
-                                                    (body,
-                                                     FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    FStar_Tactics_Effect.lift_div_tac
-                                                      (fun uu___3 ->
-                                                         ([(ty,
-                                                             FStar_Reflection_Data.Q_Implicit)],
-                                                           body))
-                                                | (body,
-                                                   FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    FStar_Tactics_Effect.lift_div_tac
-                                                      (fun uu___3 ->
-                                                         ([], body))
-                                                | uu___3 ->
-                                                    FStar_Tactics_Derived.fail
-                                                      "ill-formed exists_")
-                                               (fun uu___3 ->
-                                                  (fun uu___3 ->
-                                                     match uu___3 with
-                                                     | (ty, body) ->
-                                                         Obj.magic
-                                                           (FStar_Tactics_Effect.tac_bind
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (22))
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (36)))
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (16))
-                                                                 (Prims.of_int (436))
-                                                                 (Prims.of_int (21)))
-                                                              (Obj.magic
-                                                                 (FStar_Tactics_Builtins.inspect
-                                                                    body))
-                                                              (fun uu___4 ->
-                                                                 (fun uu___4
-                                                                    ->
-                                                                    match uu___4
-                                                                    with
-                                                                    | 
-                                                                    FStar_Reflection_Data.Tv_Abs
-                                                                    (b,
-                                                                    abody) ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.tac_bind
+                                       (fun uu___3 ->
+                                          match uu___3 with
+                                          | (ty, body) ->
+                                              Obj.magic
+                                                (FStar_Tactics_Effect.tac_bind
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (22))
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (36)))
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (16))
+                                                      (Prims.of_int (377))
+                                                      (Prims.of_int (45)))
+                                                   (Obj.magic
+                                                      (FStar_Tactics_Builtins.inspect
+                                                         body))
+                                                   (fun uu___4 ->
+                                                      (fun uu___4 ->
+                                                         match uu___4 with
+                                                         | FStar_Reflection_Data.Tv_Abs
+                                                             (b, abody) ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -594,16 +529,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -615,58 +550,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -696,32 +631,14 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___8
-                                                                    when
-                                                                    uu___8 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsUnit0"]))
-                                                                    | 
-                                                                    uu___8 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit1"])))
+                                                                    "GEExistsUnit"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -729,16 +646,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -750,58 +667,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (78)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -831,86 +748,48 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___9
-                                                                    when
-                                                                    uu___9 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExists0"]))
-                                                                    | 
-                                                                    uu___9 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists1"])))
+                                                                    "GEExists"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                                    | 
-                                                                    uu___5 ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                         | uu___5 ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___7
-                                                                    when
-                                                                    uu___7 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsNoAbs0"]))
-                                                                    | 
-                                                                    uu___7 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs1"])))
+                                                                    "GEExistsNoAbs"])))
                                                                     lbody))))
-                                                                   uu___4)))
-                                                    uu___3))) uu___3))
+                                                        uu___4))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (458))
+                                       (Prims.of_int (399))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -929,15 +808,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (455))
+                                                              (Prims.of_int (396))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -958,15 +837,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -979,15 +858,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -1009,15 +888,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1046,15 +925,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1085,15 +964,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1106,15 +985,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1198,11 +1077,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (19))
-                            (Prims.of_int (547)) (Prims.of_int (34)))
+                            (Prims.of_int (488)) (Prims.of_int (19))
+                            (Prims.of_int (488)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (4))
-                            (Prims.of_int (592)) (Prims.of_int (13)))
+                            (Prims.of_int (488)) (Prims.of_int (4))
+                            (Prims.of_int (532)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1222,15 +1101,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (552))
+                                                     (Prims.of_int (493))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (554))
-                                                     (Prims.of_int (88)))
+                                                     (Prims.of_int (495))
+                                                     (Prims.of_int (85)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (556))
+                                                     (Prims.of_int (497))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (582))
+                                                     (Prims.of_int (522))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1240,16 +1119,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (554))
-                                                                   (Prims.of_int (88)))
+                                                                   (Prims.of_int (495))
+                                                                   (Prims.of_int (85)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1268,16 +1147,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (495))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (554))
-                                                                    (Prims.of_int (88)))
+                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (85)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1295,9 +1174,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1310,15 +1187,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (497))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (556))
-                                                                (Prims.of_int (84)))
+                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (79)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (557))
+                                                                (Prims.of_int (498))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (582))
+                                                                (Prims.of_int (522))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1343,9 +1220,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1356,15 +1231,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (558))
+                                                                    (Prims.of_int (499))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1381,15 +1256,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (560))
+                                                                    (Prims.of_int (501))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (564))
+                                                                    (Prims.of_int (505))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (566))
+                                                                    (Prims.of_int (507))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1402,16 +1277,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1423,16 +1298,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (504))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1454,9 +1329,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1491,69 +1364,23 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (39))
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (81)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
-                                                                    (Prims.of_int (9)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.fresh_binder
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))))
-                                                                    (fun
-                                                                    uu___3 ->
-                                                                    (fun
-                                                                    dummy_raised_unit_binder
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (510))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (120)))
+                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.append
-                                                                    (FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders))
-                                                                    [dummy_raised_unit_binder]))
+                                                                    rev_types_and_binders)))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1563,15 +1390,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1591,15 +1418,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1612,88 +1439,37 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (573))
-                                                                    (Prims.of_int (151)))
+                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (113)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    = "_";
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (964));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    })
-                                                                    FStar_Reflection_Data.Q_Explicit
-                                                                    []),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"])))))))),
+                                                                    "vprop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1703,15 +1479,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1724,86 +1500,35 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (575))
-                                                                    (Prims.of_int (150)))
+                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (112)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (516))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    = "_";
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (967));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    })
-                                                                    FStar_Reflection_Data.Q_Explicit
-                                                                    []),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"])))))))),
+                                                                    "prop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1818,7 +1543,6 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
-                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1845,15 +1569,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (589))
+                                                         (Prims.of_int (529))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1914,11 +1638,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (599)) (Prims.of_int (17))
-                                 (Prims.of_int (599)) (Prims.of_int (64)))
+                                 (Prims.of_int (539)) (Prims.of_int (17))
+                                 (Prims.of_int (539)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (600)) (Prims.of_int (6))
-                                 (Prims.of_int (601)) (Prims.of_int (37)))
+                                 (Prims.of_int (540)) (Prims.of_int (6))
+                                 (Prims.of_int (541)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1937,15 +1661,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1979,10 +1703,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1997,76 +1721,32 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_UInst
-                            ((FStar_Reflection_Builtins.pack_fv
-                                ["Steel";
-                                "ST";
-                                "GenElim";
-                                "Base";
-                                "mk_gen_elim_nondep_by_tac"]),
-                              [FStar_Reflection_Builtins.pack_universe
-                                 (FStar_Reflection_Data.Uv_Succ
-                                    (FStar_Reflection_Builtins.pack_universe
-                                       FStar_Reflection_Data.Uv_Zero))])))
+                         (FStar_Reflection_Data.Tv_FVar
+                            (FStar_Reflection_Builtins.pack_fv
+                               ["Steel";
+                               "ST";
+                               "GenElim";
+                               "Base";
+                               "mk_gen_elim_nondep_by_tac"])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
-let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
-  fun uu___ ->
-    FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
-         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
-         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
-      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
-      (fun uu___1 ->
-         (fun ty ->
-            Obj.magic
-              (FStar_Tactics_Effect.tac_bind
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (8))
-                    (Prims.of_int (624)) (Prims.of_int (28)))
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (2))
-                    (Prims.of_int (626)) (Prims.of_int (27)))
-                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
-                 (fun uu___1 ->
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | FStar_Reflection_Formula.Comp
-                           (uu___2, uu___3, uu___4) ->
-                           Obj.magic (FStar_Tactics_Derived.trefl ())
-                       | uu___2 ->
-                           Obj.magic
-                             (FStar_Tactics_Effect.tac_bind
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (9))
-                                   (Prims.of_int (626)) (Prims.of_int (17)))
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (19))
-                                   (Prims.of_int (626)) (Prims.of_int (27)))
-                                (Obj.magic (FStar_Tactics_Derived.smt ()))
-                                (fun uu___3 ->
-                                   (fun uu___3 ->
-                                      Obj.magic
-                                        (FStar_Tactics_Derived.qed ()))
-                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2078,27 +1758,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (633)) (Prims.of_int (2))
-                        (Prims.of_int (634)) (Prims.of_int (33)))
+                        (Prims.of_int (567)) (Prims.of_int (2))
+                        (Prims.of_int (568)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (635)) (Prims.of_int (2))
-                        (Prims.of_int (670)) (Prims.of_int (35)))
+                        (Prims.of_int (569)) (Prims.of_int (2))
+                        (Prims.of_int (604)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (5))
-                              (Prims.of_int (633)) (Prims.of_int (23)))
+                              (Prims.of_int (567)) (Prims.of_int (5))
+                              (Prims.of_int (567)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (2))
-                              (Prims.of_int (634)) (Prims.of_int (33)))
+                              (Prims.of_int (567)) (Prims.of_int (2))
+                              (Prims.of_int (568)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (9))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (9))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (5))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (5))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2120,15 +1800,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (669))
+                                          (Prims.of_int (603))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2142,15 +1822,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (638))
+                                                         (Prims.of_int (572))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (639))
+                                                         (Prims.of_int (573))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (640))
+                                                         (Prims.of_int (574))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (668))
+                                                         (Prims.of_int (602))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -2189,15 +1869,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2215,15 +1895,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2237,15 +1917,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2269,29 +1949,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2342,15 +2022,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (652))
+                                                                    (Prims.of_int (586))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (593))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2386,15 +2066,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2404,15 +2084,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2440,15 +2120,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2475,15 +2155,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2493,15 +2173,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2525,15 +2205,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (49)))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2543,16 +2223,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (48)))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2562,8 +2242,32 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (trefl_or_smt
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (33))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (45)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (47))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (55)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.trivial
+                                                                    ()))
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Derived.qed
                                                                     ()))
+                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2575,15 +2279,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2593,15 +2297,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2625,15 +2329,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2643,15 +2347,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2679,15 +2383,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2725,16 +2429,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2746,27 +2450,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (677)) (Prims.of_int (2))
-                        (Prims.of_int (678)) (Prims.of_int (33)))
+                        (Prims.of_int (611)) (Prims.of_int (2))
+                        (Prims.of_int (612)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (679)) (Prims.of_int (2))
-                        (Prims.of_int (712)) (Prims.of_int (35)))
+                        (Prims.of_int (613)) (Prims.of_int (2))
+                        (Prims.of_int (644)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (5))
-                              (Prims.of_int (677)) (Prims.of_int (23)))
+                              (Prims.of_int (611)) (Prims.of_int (5))
+                              (Prims.of_int (611)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (2))
-                              (Prims.of_int (678)) (Prims.of_int (33)))
+                              (Prims.of_int (611)) (Prims.of_int (2))
+                              (Prims.of_int (612)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (9))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (9))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (5))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (5))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2788,15 +2492,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (711))
+                                          (Prims.of_int (643))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2810,15 +2514,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (682))
+                                                         (Prims.of_int (616))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (683))
+                                                         (Prims.of_int (617))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (684))
+                                                         (Prims.of_int (618))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (710))
+                                                         (Prims.of_int (642))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2857,43 +2561,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2931,29 +2635,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2977,29 +2681,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3023,29 +2727,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3069,15 +2773,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (626))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -3104,15 +2808,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -3130,15 +2834,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -3152,15 +2856,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -3175,15 +2879,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3205,21 +2909,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (697))
-                                                                    (Prims.of_int (89)))
+                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
-                                                                    (FStar_Tactics_Effect.lift_div_tac
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    FStar_Reflection_Derived.mk_app
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -3232,7 +2934,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)]))
+                                                                    FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -3242,59 +2944,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (698))
-                                                                    (Prims.of_int (37)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Builtins.term_to_string
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun
-                                                                    a'_ts ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (15))
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (27)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun a'1
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3321,15 +2979,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3356,15 +3014,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3379,19 +3037,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'1))
+                                                                    a'))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3402,15 +3060,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3425,15 +3083,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3448,15 +3106,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3471,15 +3129,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3494,15 +3152,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3534,8 +3192,6 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
-                                                                    uu___12)))
-                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From e7259a50b53c8ee9004b5cbf7a2db23b6b4794e4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Mar 2023 22:33:12 -0700
Subject: [PATCH 491/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        |  433 +++--
 ocaml/fstar-lib/generated/FStar_Main.ml       |    3 +-
 .../generated/Steel_ST_GenElim_Base.ml        | 1556 ++++++++++-------
 3 files changed, 1263 insertions(+), 729 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..dd7c2505755 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,16 +1142,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1163,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1198,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2669,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3098,122 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3553,10 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (init : unit -> unit) =
+  fun uu___ ->
+    register_post_translate_type_without_decay translate_type_without_decay';
+    register_post_translate_type translate_type';
+    register_post_translate_type_decl translate_type_decl';
+    register_post_translate_expr translate_expr'
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index 8ad6b788389..d763e38153f 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,7 +294,8 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
+    FStar_Extraction_Krml.init ()
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index 2ca503ea1dc..b23bdfc10ec 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (5))
-                          (Prims.of_int (310)) (Prims.of_int (28)))
+                          (Prims.of_int (342)) (Prims.of_int (5))
+                          (Prims.of_int (342)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (2))
-                          (Prims.of_int (320)) (Prims.of_int (12)))
+                          (Prims.of_int (342)) (Prims.of_int (2))
+                          (Prims.of_int (352)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (320))
+                                          (Prims.of_int (352))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (318))
+                                                                 (Prims.of_int (350))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (23))
-                         (Prims.of_int (329)) (Prims.of_int (40)))
+                         (Prims.of_int (361)) (Prims.of_int (23))
+                         (Prims.of_int (361)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (8))
-                         (Prims.of_int (340)) (Prims.of_int (47)))
+                         (Prims.of_int (361)) (Prims.of_int (8))
+                         (Prims.of_int (372)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (340))
+                                             (Prims.of_int (372))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,22 +347,53 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
+let rec (get_universe :
+  FStar_Reflection_Types.universe ->
+    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
+  =
+  fun uu___ ->
+    (fun u ->
+       match FStar_Reflection_Builtins.inspect_universe u with
+       | FStar_Reflection_Data.Uv_Zero ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.lift_div_tac
+                   (fun uu___ -> Prims.int_zero)))
+       | FStar_Reflection_Data.Uv_Succ u1 ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.tac_bind
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (23))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (19))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Obj.magic (get_universe u1))
+                   (fun uu___ ->
+                      FStar_Tactics_Effect.lift_div_tac
+                        (fun uu___1 -> Prims.int_one + uu___))))
+       | uu___ ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Derived.fail
+                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -379,11 +410,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (355)) (Prims.of_int (17))
-                      (Prims.of_int (355)) (Prims.of_int (40)))
+                      (Prims.of_int (395)) (Prims.of_int (17))
+                      (Prims.of_int (395)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (356)) (Prims.of_int (8))
-                      (Prims.of_int (356)) (Prims.of_int (45)))
+                      (Prims.of_int (396)) (Prims.of_int (8))
+                      (Prims.of_int (396)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -402,11 +433,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (26))
-                      (Prims.of_int (358)) (Prims.of_int (43)))
+                      (Prims.of_int (398)) (Prims.of_int (26))
+                      (Prims.of_int (398)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (8))
-                      (Prims.of_int (399)) (Prims.of_int (68)))
+                      (Prims.of_int (398)) (Prims.of_int (8))
+                      (Prims.of_int (458)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -419,88 +450,122 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (362))
-                                       (Prims.of_int (12))
-                                       (Prims.of_int (365))
-                                       (Prims.of_int (46)))
+                                       (Prims.of_int (401))
+                                       (Prims.of_int (25))
+                                       (Prims.of_int (403))
+                                       (Prims.of_int (63)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (361))
+                                       (Prims.of_int (405))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (378))
+                                       (Prims.of_int (437))
                                        (Prims.of_int (13)))
-                                    (match lbody with
-                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
-                                         (body,
-                                          FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 ->
-                                              ([(ty,
-                                                  FStar_Reflection_Data.Q_Implicit)],
-                                                body))
-                                     | (body,
-                                        FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 -> ([], body))
+                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
+                                             hd
+                                     with
+                                     | FStar_Reflection_Data.Tv_UInst
+                                         (uu___3, u::uu___4) ->
+                                         Obj.magic
+                                           (Obj.repr (get_universe u))
                                      | uu___3 ->
-                                         FStar_Tactics_Derived.fail
-                                           "ill-formed exists_")
+                                         Obj.magic
+                                           (Obj.repr
+                                              (FStar_Tactics_Derived.fail
+                                                 "ill-formed exists_: no universe found")))
                                     (fun uu___3 ->
-                                       (fun uu___3 ->
-                                          match uu___3 with
-                                          | (ty, body) ->
-                                              Obj.magic
-                                                (FStar_Tactics_Effect.tac_bind
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (22))
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (36)))
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (16))
-                                                      (Prims.of_int (377))
-                                                      (Prims.of_int (45)))
-                                                   (Obj.magic
-                                                      (FStar_Tactics_Builtins.inspect
-                                                         body))
-                                                   (fun uu___4 ->
-                                                      (fun uu___4 ->
-                                                         match uu___4 with
-                                                         | FStar_Reflection_Data.Tv_Abs
-                                                             (b, abody) ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.tac_bind
+                                       (fun universe ->
+                                          Obj.magic
+                                            (FStar_Tactics_Effect.tac_bind
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (406))
+                                                  (Prims.of_int (12))
+                                                  (Prims.of_int (409))
+                                                  (Prims.of_int (46)))
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (405))
+                                                  (Prims.of_int (10))
+                                                  (Prims.of_int (437))
+                                                  (Prims.of_int (13)))
+                                               (match lbody with
+                                                | (ty,
+                                                   FStar_Reflection_Data.Q_Implicit)::
+                                                    (body,
+                                                     FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([(ty,
+                                                             FStar_Reflection_Data.Q_Implicit)],
+                                                           body))
+                                                | (body,
+                                                   FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([], body))
+                                                | uu___3 ->
+                                                    FStar_Tactics_Derived.fail
+                                                      "ill-formed exists_")
+                                               (fun uu___3 ->
+                                                  (fun uu___3 ->
+                                                     match uu___3 with
+                                                     | (ty, body) ->
+                                                         Obj.magic
+                                                           (FStar_Tactics_Effect.tac_bind
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (22))
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (36)))
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (16))
+                                                                 (Prims.of_int (436))
+                                                                 (Prims.of_int (21)))
+                                                              (Obj.magic
+                                                                 (FStar_Tactics_Builtins.inspect
+                                                                    body))
+                                                              (fun uu___4 ->
+                                                                 (fun uu___4
+                                                                    ->
+                                                                    match uu___4
+                                                                    with
+                                                                    | 
+                                                                    FStar_Reflection_Data.Tv_Abs
+                                                                    (b,
+                                                                    abody) ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -529,16 +594,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -550,58 +615,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (82)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -631,14 +696,32 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___8
+                                                                    when
+                                                                    uu___8 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit"])))
+                                                                    "GEExistsUnit0"]))
+                                                                    | 
+                                                                    uu___8 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsUnit1"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -646,16 +729,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -667,58 +750,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (78)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -748,48 +831,86 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___9
+                                                                    when
+                                                                    uu___9 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists"])))
+                                                                    "GEExists0"]))
+                                                                    | 
+                                                                    uu___9 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExists1"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                         | uu___5 ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.lift_div_tac
+                                                                    | 
+                                                                    uu___5 ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___7
+                                                                    when
+                                                                    uu___7 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs"])))
+                                                                    "GEExistsNoAbs0"]))
+                                                                    | 
+                                                                    uu___7 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsNoAbs1"])))
                                                                     lbody))))
-                                                        uu___4))) uu___3))
+                                                                   uu___4)))
+                                                    uu___3))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (399))
+                                       (Prims.of_int (458))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -808,15 +929,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (396))
+                                                              (Prims.of_int (455))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -837,15 +958,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -858,15 +979,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -888,15 +1009,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -925,15 +1046,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -964,15 +1085,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -985,15 +1106,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1077,11 +1198,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (19))
-                            (Prims.of_int (488)) (Prims.of_int (34)))
+                            (Prims.of_int (547)) (Prims.of_int (19))
+                            (Prims.of_int (547)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (4))
-                            (Prims.of_int (532)) (Prims.of_int (13)))
+                            (Prims.of_int (547)) (Prims.of_int (4))
+                            (Prims.of_int (592)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1101,15 +1222,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (493))
+                                                     (Prims.of_int (552))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (495))
-                                                     (Prims.of_int (85)))
+                                                     (Prims.of_int (554))
+                                                     (Prims.of_int (88)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (497))
+                                                     (Prims.of_int (556))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (522))
+                                                     (Prims.of_int (582))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1119,16 +1240,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (495))
-                                                                   (Prims.of_int (85)))
+                                                                   (Prims.of_int (554))
+                                                                   (Prims.of_int (88)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1147,16 +1268,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (554))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (495))
-                                                                    (Prims.of_int (85)))
+                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (88)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1174,7 +1295,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1187,15 +1310,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (556))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (497))
-                                                                (Prims.of_int (79)))
+                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (84)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (498))
+                                                                (Prims.of_int (557))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (522))
+                                                                (Prims.of_int (582))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1220,7 +1343,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1231,15 +1356,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (499))
+                                                                    (Prims.of_int (558))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1256,15 +1381,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (501))
+                                                                    (Prims.of_int (560))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (505))
+                                                                    (Prims.of_int (564))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (507))
+                                                                    (Prims.of_int (566))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1277,16 +1402,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1298,16 +1423,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (563))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1329,7 +1454,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1364,23 +1491,69 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (39))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (81)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (8))
+                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (9)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.fresh_binder
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))))
+                                                                    (fun
+                                                                    uu___3 ->
+                                                                    (fun
+                                                                    dummy_raised_unit_binder
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (510))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (120)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.append
+                                                                    (FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders)))
+                                                                    rev_types_and_binders))
+                                                                    [dummy_raised_unit_binder]))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1390,15 +1563,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1418,15 +1591,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1439,37 +1612,97 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (513))
-                                                                    (Prims.of_int (113)))
+                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (151)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    {
+                                                                    FStar_Reflection_Data.binder_bv
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    =
+                                                                    (FStar_Sealed.seal
+                                                                    "_");
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (964));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    });
+                                                                    FStar_Reflection_Data.binder_qual
+                                                                    =
+                                                                    FStar_Reflection_Data.Q_Explicit;
+                                                                    FStar_Reflection_Data.binder_attrs
+                                                                    = []
+                                                                    }),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"]))),
+                                                                    "vprop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1479,15 +1712,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1500,35 +1733,95 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (515))
-                                                                    (Prims.of_int (112)))
+                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (150)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (516))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    {
+                                                                    FStar_Reflection_Data.binder_bv
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    =
+                                                                    (FStar_Sealed.seal
+                                                                    "_");
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (967));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    });
+                                                                    FStar_Reflection_Data.binder_qual
+                                                                    =
+                                                                    FStar_Reflection_Data.Q_Explicit;
+                                                                    FStar_Reflection_Data.binder_attrs
+                                                                    = []
+                                                                    }),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"]))),
+                                                                    "prop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1543,6 +1836,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
+                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1569,15 +1863,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (529))
+                                                         (Prims.of_int (589))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1638,11 +1932,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (539)) (Prims.of_int (17))
-                                 (Prims.of_int (539)) (Prims.of_int (64)))
+                                 (Prims.of_int (599)) (Prims.of_int (17))
+                                 (Prims.of_int (599)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (540)) (Prims.of_int (6))
-                                 (Prims.of_int (541)) (Prims.of_int (37)))
+                                 (Prims.of_int (600)) (Prims.of_int (6))
+                                 (Prims.of_int (601)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1661,15 +1955,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1703,10 +1997,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1721,32 +2015,76 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_FVar
-                            (FStar_Reflection_Builtins.pack_fv
-                               ["Steel";
-                               "ST";
-                               "GenElim";
-                               "Base";
-                               "mk_gen_elim_nondep_by_tac"])))
+                         (FStar_Reflection_Data.Tv_UInst
+                            ((FStar_Reflection_Builtins.pack_fv
+                                ["Steel";
+                                "ST";
+                                "GenElim";
+                                "Base";
+                                "mk_gen_elim_nondep_by_tac"]),
+                              [FStar_Reflection_Builtins.pack_universe
+                                 (FStar_Reflection_Data.Uv_Succ
+                                    (FStar_Reflection_Builtins.pack_universe
+                                       FStar_Reflection_Data.Uv_Zero))])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
+let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
+  fun uu___ ->
+    FStar_Tactics_Effect.tac_bind
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
+         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
+         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
+      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
+      (fun uu___1 ->
+         (fun ty ->
+            Obj.magic
+              (FStar_Tactics_Effect.tac_bind
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (8))
+                    (Prims.of_int (624)) (Prims.of_int (28)))
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (2))
+                    (Prims.of_int (626)) (Prims.of_int (27)))
+                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
+                 (fun uu___1 ->
+                    (fun uu___1 ->
+                       match uu___1 with
+                       | FStar_Reflection_Formula.Comp
+                           (uu___2, uu___3, uu___4) ->
+                           Obj.magic (FStar_Tactics_Derived.trefl ())
+                       | uu___2 ->
+                           Obj.magic
+                             (FStar_Tactics_Effect.tac_bind
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (9))
+                                   (Prims.of_int (626)) (Prims.of_int (17)))
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (19))
+                                   (Prims.of_int (626)) (Prims.of_int (27)))
+                                (Obj.magic (FStar_Tactics_Derived.smt ()))
+                                (fun uu___3 ->
+                                   (fun uu___3 ->
+                                      Obj.magic
+                                        (FStar_Tactics_Derived.qed ()))
+                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -1758,27 +2096,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (567)) (Prims.of_int (2))
-                        (Prims.of_int (568)) (Prims.of_int (33)))
+                        (Prims.of_int (633)) (Prims.of_int (2))
+                        (Prims.of_int (634)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (569)) (Prims.of_int (2))
-                        (Prims.of_int (604)) (Prims.of_int (35)))
+                        (Prims.of_int (635)) (Prims.of_int (2))
+                        (Prims.of_int (670)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (5))
-                              (Prims.of_int (567)) (Prims.of_int (23)))
+                              (Prims.of_int (633)) (Prims.of_int (5))
+                              (Prims.of_int (633)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (2))
-                              (Prims.of_int (568)) (Prims.of_int (33)))
+                              (Prims.of_int (633)) (Prims.of_int (2))
+                              (Prims.of_int (634)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (9))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (9))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (5))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (5))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -1800,15 +2138,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (603))
+                                          (Prims.of_int (669))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -1822,15 +2160,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (572))
+                                                         (Prims.of_int (638))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (573))
+                                                         (Prims.of_int (639))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (574))
+                                                         (Prims.of_int (640))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (602))
+                                                         (Prims.of_int (668))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -1869,15 +2207,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -1895,15 +2233,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1917,15 +2255,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1949,29 +2287,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2022,15 +2360,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (586))
+                                                                    (Prims.of_int (652))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (593))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2066,15 +2404,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2084,15 +2422,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2120,15 +2458,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2155,15 +2493,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2173,15 +2511,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2205,15 +2543,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (56)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (49)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2223,16 +2561,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (48)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2242,32 +2580,8 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (45)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (47))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.trivial
-                                                                    ()))
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Derived.qed
+                                                                    (trefl_or_smt
                                                                     ()))
-                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2279,15 +2593,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2297,15 +2611,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2329,15 +2643,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2347,15 +2661,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2383,15 +2697,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2429,16 +2743,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2450,27 +2764,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (611)) (Prims.of_int (2))
-                        (Prims.of_int (612)) (Prims.of_int (33)))
+                        (Prims.of_int (677)) (Prims.of_int (2))
+                        (Prims.of_int (678)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (613)) (Prims.of_int (2))
-                        (Prims.of_int (644)) (Prims.of_int (35)))
+                        (Prims.of_int (679)) (Prims.of_int (2))
+                        (Prims.of_int (712)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (5))
-                              (Prims.of_int (611)) (Prims.of_int (23)))
+                              (Prims.of_int (677)) (Prims.of_int (5))
+                              (Prims.of_int (677)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (2))
-                              (Prims.of_int (612)) (Prims.of_int (33)))
+                              (Prims.of_int (677)) (Prims.of_int (2))
+                              (Prims.of_int (678)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (9))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (9))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (5))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (5))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2492,15 +2806,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (643))
+                                          (Prims.of_int (711))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2514,15 +2828,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (616))
+                                                         (Prims.of_int (682))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (617))
+                                                         (Prims.of_int (683))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (618))
+                                                         (Prims.of_int (684))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (642))
+                                                         (Prims.of_int (710))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2561,43 +2875,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2635,29 +2949,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2681,29 +2995,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2727,29 +3041,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2773,15 +3087,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (626))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -2808,15 +3122,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2834,15 +3148,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2856,15 +3170,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -2879,15 +3193,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2909,19 +3223,21 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (631))
-                                                                    (Prims.of_int (101)))
+                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    (FStar_Reflection_Derived.mk_app
+                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -2934,7 +3250,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)])))
+                                                                    FStar_Reflection_Data.Q_Explicit)]))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -2944,15 +3260,59 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (37)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Builtins.term_to_string
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun
+                                                                    a'_ts ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (15))
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (27)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun a'1
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -2979,15 +3339,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3014,15 +3374,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3037,19 +3397,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'))
+                                                                    a'1))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3060,15 +3420,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3083,15 +3443,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3106,15 +3466,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3129,15 +3489,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3152,15 +3512,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3192,6 +3552,8 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
+                                                                    uu___12)))
+                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From 49c397f683f78a7b53447ccebce6212e417c46c4 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 27 Mar 2023 23:46:54 -0700
Subject: [PATCH 492/513] Revert "pts_to ~ vptr `vrefine` equals"

This reverts commit b59399acfd4ab14a4f6203942f06d21089a5d562.
---
 ulib/experimental/Steel.ST.Reference.fst  | 48 -----------------------
 ulib/experimental/Steel.ST.Reference.fsti | 31 ---------------
 2 files changed, 79 deletions(-)

diff --git a/ulib/experimental/Steel.ST.Reference.fst b/ulib/experimental/Steel.ST.Reference.fst
index 0b7198e1f07..c0084911f93 100644
--- a/ulib/experimental/Steel.ST.Reference.fst
+++ b/ulib/experimental/Steel.ST.Reference.fst
@@ -197,51 +197,3 @@ let atomic_write_u32 r x =
 
 let cas_u32 #uses v r v_old v_new =
   coerce_atomic (fun _ -> R.cas_pt_u32 #uses r v v_old v_new)
-
-let ptrp r p = R.ptrp r p
-let ptrp_sel r p = R.ptrp_sel r p
-
-module SA = Steel.Effect.Atomic
-
-let vptrp_intro'
-  (#inames: _)
-  (#a: Type) (r: ref a) (p: perm) (v: a)
-: SA.SteelGhostT unit inames
-    (pts_to r p v)
-    (fun _ -> vptrp r p `vrefine` C.equals v)
-=
-  R.intro_vptr r p v;
-  SA.change_slprop
-    (R.vptrp r p)
-    (vptrp r p)
-    v
-    v
-    (fun _ -> ());
-  SA.intro_vrefine (vptrp r p) (C.equals v)
-
-let vptrp_intro r p v =
-  coerce_ghost (fun _ -> vptrp_intro' r p v)
-
-let vptrp_elim'
-  (#inames: _)
-  (#a: Type) (r: ref a) (p: perm) (v: a)
-: SA.SteelGhostT unit inames
-    (vptrp r p `vrefine` C.equals v)
-    (fun _ -> pts_to r p v)
-=
-  SA.elim_vrefine (vptrp r p) (C.equals v);
-  SA.change_slprop
-    (vptrp r p)
-    (R.vptrp r p)
-    v
-    v
-    (fun _ -> ());
-  let v' = R.elim_vptr r p in
-  SA.change_slprop_rel
-    (R.pts_to r p v')
-    (R.pts_to r p v)
-    (fun _ _ -> True)
-    (fun _ -> ())
-
-let vptrp_elim r p v =
-  coerce_ghost (fun _ -> vptrp_elim' r p v)
diff --git a/ulib/experimental/Steel.ST.Reference.fsti b/ulib/experimental/Steel.ST.Reference.fsti
index f93ae0dae22..9ba1a235e9c 100644
--- a/ulib/experimental/Steel.ST.Reference.fsti
+++ b/ulib/experimental/Steel.ST.Reference.fsti
@@ -236,34 +236,3 @@ val cas_u32 (#uses:inames)
       uses
       (pts_to r full_perm v)
       (fun b -> if b then pts_to r full_perm v_new else pts_to r full_perm v)
-
-// A reinterpretation of pts_to with selectors
-
-module C = Steel.ST.Combinators
-
-val ptrp (#a:Type0) (r:ref a) ([@@@smt_fallback] p: perm) : slprop u#1
-val ptrp_sel (#a:Type0) (r:ref a) (p: perm) : selector a (ptrp r p)
-
-[@@ __steel_reduce__]
-let vptr' #a r p : vprop' =
-  {hp = ptrp r p;
-   t = a;
-   sel = ptrp_sel r p}
-
-[@@ __steel_reduce__]
-unfold
-let vptrp (#a: Type) (r: ref a) ([@@@smt_fallback] p: perm) = VUnit (vptr' r p)
-
-val vptrp_intro
-  (#inames: _)
-  (#a: Type) (r: ref a) (p: perm) (v: a)
-: STGhostT unit inames
-    (pts_to r p v)
-    (fun _ -> vptrp r p `vrefine` C.equals v)
-
-val vptrp_elim
-  (#inames: _)
-  (#a: Type) (r: ref a) (p: perm) (v: a)
-: STGhostT unit inames
-    (vptrp r p `vrefine` C.equals v)
-    (fun _ -> pts_to r p v)

From b6d8d46d932b4d9cbc0be571932bb616dc6435fe Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Mar 2023 15:02:03 -0700
Subject: [PATCH 493/513] array_ref_shift_zero, array_ref_shift_assoc

---
 .../fstlib/Steel.ST.C.Types.Array.fst         |  8 ++++++++
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 20 +++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
index 418090ccd8e..2480957dbe1 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
@@ -1087,6 +1087,14 @@ let array_ref_shift
   a i
 = t_array_ref_shift a i
 
+let array_ref_shift_zero
+  a
+= ()
+
+let array_ref_shift_assoc
+  a i1 i2
+= ()
+
 let ghost_array_split
   #_ #_ #td #s a i
 = array_pts_to_length _ _;
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index 7323d6136e8..71f1c8fa37a 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -810,6 +810,26 @@ val array_ref_shift
       array_ref_offset y == array_ref_offset a `SZ.add` i
     ))
 
+val array_ref_shift_zero
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_ref td)
+: Lemma
+    (ensures (
+      array_ref_shift a 0sz == a
+    ))
+
+val array_ref_shift_assoc
+  (#t: Type)
+  (#td: typedef t)
+  (a: array_ref td)
+  (i1 i2: SZ.t)
+: Lemma
+    (requires (SZ.v (array_ref_offset a) + SZ.v i1 + SZ.v i2 <= SZ.v (array_ref_base_size a)))
+    (ensures (
+      array_ref_shift a (SZ.add i1 i2) == array_ref_shift (array_ref_shift a i1) i2
+    ))
+
 inline_for_extraction [@@noextract_to "krml"]
 let array_split_l
   (#t: Type)

From eeb2d346a85acece61ba23b39d23c1609e39ec6c Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Mar 2023 15:25:01 -0700
Subject: [PATCH 494/513] mk_fraction_seq_split_gen: allow empty sequences

---
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index 71f1c8fa37a..d8a66496540 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -940,7 +940,7 @@ val mk_fraction_seq_split_gen
 : STGhost unit opened
   (array_pts_to r (mk_fraction_seq td v p))
   (fun _ -> array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
-  (p == p1 `P.sum_perm` p2 /\ p `P.lesser_equal_perm` P.full_perm)
+  (p == p1 `P.sum_perm` p2 /\ (p `P.lesser_equal_perm` P.full_perm \/ Seq.length v == 0))
   (fun _ -> True)
 
 let mk_fraction_seq_split

From df0d53e8c8316b609712ae0517716d6218c9c9eb Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Mar 2023 18:43:51 -0700
Subject: [PATCH 495/513] ghost_pts_to_perm

---
 ulib/experimental/Steel.HigherReference.fst    | 13 +++++++++++++
 ulib/experimental/Steel.HigherReference.fsti   |  8 ++++++++
 ulib/experimental/Steel.Reference.fst          |  2 ++
 ulib/experimental/Steel.Reference.fsti         |  8 ++++++++
 ulib/experimental/Steel.ST.GhostReference.fst  |  2 ++
 ulib/experimental/Steel.ST.GhostReference.fsti |  8 ++++++++
 6 files changed, 41 insertions(+)

diff --git a/ulib/experimental/Steel.HigherReference.fst b/ulib/experimental/Steel.HigherReference.fst
index 61a90ac4cc6..3d850125d3d 100644
--- a/ulib/experimental/Steel.HigherReference.fst
+++ b/ulib/experimental/Steel.HigherReference.fst
@@ -414,6 +414,19 @@ let ghost_gather r = gather (reveal r)
 let ghost_pts_to_injective_eq #_ #_ #p0 #p1 r v0 v1 =
   higher_ref_pts_to_injective_eq #_ #_ #p0 #p1 #v0 #v1 (reveal r)
 
+let ghost_pts_to_perm #a #_ #p #v r =
+  let v_old : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
+    rewrite_slprop
+      (ghost_pts_to r p v)
+      (RP.pts_to r v_old `star` pure (perm_ok p))
+      (fun _ -> ());
+    elim_pure (perm_ok p);
+    intro_pure (perm_ok p);
+    rewrite_slprop
+      (RP.pts_to r v_old `star` pure (perm_ok p))
+      (ghost_pts_to r p v)
+      (fun _ -> ())
+
 let ghost_read #a #u #p #v r
   = let v1 : erased (fractional a) = Ghost.hide (Some (Ghost.reveal v, p)) in
     rewrite_slprop (pts_to r p v) (RP.pts_to r v1 `star` pure (perm_ok p)) (fun _ -> ());
diff --git a/ulib/experimental/Steel.HigherReference.fsti b/ulib/experimental/Steel.HigherReference.fsti
index 42d2995c721..588953d66f0 100644
--- a/ulib/experimental/Steel.HigherReference.fsti
+++ b/ulib/experimental/Steel.HigherReference.fsti
@@ -227,6 +227,14 @@ val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Gho
     (requires fun _ -> True)
     (ensures fun _ _ _ -> v0 == v1)
 
+/// A permission is always no greater than one
+val ghost_pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ghost_ref a)
+  : SteelGhost unit u
+      (ghost_pts_to r p v)
+      (fun _ -> ghost_pts_to r p v)
+      (fun _ -> True)
+      (fun _ _ _ -> p `lesser_equal_perm` full_perm)
+
 val ghost_read (#a:Type) (#u:_) (#p:perm) (#v:erased a) (r:ghost_ref a)
   : SteelGhost (erased a) u (ghost_pts_to r p v) (fun x -> ghost_pts_to r p x)
            (requires fun _ -> True)
diff --git a/ulib/experimental/Steel.Reference.fst b/ulib/experimental/Steel.Reference.fst
index 3a10e855c3f..b5485fb9bb0 100644
--- a/ulib/experimental/Steel.Reference.fst
+++ b/ulib/experimental/Steel.Reference.fst
@@ -410,6 +410,8 @@ let ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Gho
     (ensures fun _ _ _ -> v0 == v1)
   = H.ghost_pts_to_injective_eq #_ #_ #p #q r (raise_erased v0) (raise_erased v1)
 
+let ghost_pts_to_perm r = H.ghost_pts_to_perm r
+
 let ghost_read_pt #a #u #p #v r =
   let x = H.ghost_read r in
   let x' = hide (U.downgrade_val (reveal x)) in
diff --git a/ulib/experimental/Steel.Reference.fsti b/ulib/experimental/Steel.Reference.fsti
index af44af9b864..643522a2f5b 100644
--- a/ulib/experimental/Steel.Reference.fsti
+++ b/ulib/experimental/Steel.Reference.fsti
@@ -400,6 +400,14 @@ val ghost_pts_to_injective_eq (#a:_) (#u:_) (#p #q:_) (r:ghost_ref a) (v0 v1:Gho
     (requires fun _ -> True)
     (ensures fun _ _ _ -> v0 == v1)
 
+/// A permission is always no greater than one
+val ghost_pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ghost_ref a)
+  : SteelGhost unit u
+      (ghost_pts_to r p v)
+      (fun _ -> ghost_pts_to r p v)
+      (fun _ -> True)
+      (fun _ _ _ -> p `lesser_equal_perm` full_perm)
+
 val ghost_read_pt (#a:Type) (#u:_) (#p:perm) (#v:erased a) (r:ghost_ref a)
   : SteelGhost (erased a) u (ghost_pts_to r p v) (fun x -> ghost_pts_to r p x)
            (requires fun _ -> True)
diff --git a/ulib/experimental/Steel.ST.GhostReference.fst b/ulib/experimental/Steel.ST.GhostReference.fst
index 941d896b097..8d5c34c2bcb 100644
--- a/ulib/experimental/Steel.ST.GhostReference.fst
+++ b/ulib/experimental/Steel.ST.GhostReference.fst
@@ -44,6 +44,8 @@ let pts_to_injective_eq (#a:_)
   = coerce_ghost
     (fun _ -> R.ghost_pts_to_injective_eq #a #u #p #q r (hide v0) (hide v1))
 
+let pts_to_perm r = coerce_ghost (fun _ -> R.ghost_pts_to_perm r)
+
 let alloc (#a:Type)
           (#u:_)
           (x:erased a)
diff --git a/ulib/experimental/Steel.ST.GhostReference.fsti b/ulib/experimental/Steel.ST.GhostReference.fsti
index 39fd3c7658d..91f7c75b4a6 100644
--- a/ulib/experimental/Steel.ST.GhostReference.fsti
+++ b/ulib/experimental/Steel.ST.GhostReference.fsti
@@ -54,6 +54,14 @@ val pts_to_injective_eq (#a:_)
       (requires True)
       (ensures fun _ -> v0 == v1)
 
+/// A permission is always no greater than one
+val pts_to_perm (#a: _) (#u: _) (#p: _) (#v: _) (r: ref a)
+  : STGhost unit u
+      (pts_to r p v)
+      (fun _ -> pts_to r p v)
+      True
+      (fun _ -> p `lesser_equal_perm` full_perm)
+
 /// Allocating a ghost reference, with an erased initial value
 val alloc (#a:Type)
           (#u:_)

From 6bd4d58aed68b1652f84222e0730b913421ab825 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Tue, 28 Mar 2023 22:49:35 -0700
Subject: [PATCH 496/513] fractional permissions theorem

---
 .../fstlib/Steel.ST.C.Types.Array.fst         | 43 ++++++++++++++++++
 .../fstlib/Steel.ST.C.Types.Base.fst          | 45 +++++++++++++++++++
 .../fstlib/Steel.ST.C.Types.Rewrite.fst       |  1 +
 .../fstlib/Steel.ST.C.Types.Scalar.fst        | 23 +---------
 .../fstlib/Steel.ST.C.Types.Struct.Aux.fst    |  7 +++
 .../fstlib/Steel.ST.C.Types.Union.fst         | 16 +++++++
 ulib/experimental/Steel.ST.C.Model.Array.fst  | 45 ++++++++++++++++---
 ulib/experimental/Steel.ST.C.Types.Array.fsti | 14 ++++++
 ulib/experimental/Steel.ST.C.Types.Base.fsti  | 14 ++++++
 .../experimental/Steel.ST.C.Types.Scalar.fsti |  4 +-
 10 files changed, 182 insertions(+), 30 deletions(-)

diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
index 2480957dbe1..ac3c3926bbd 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Array.fst
@@ -1277,3 +1277,46 @@ let mk_fraction_seq_join
     td.mk_fraction_join (Seq.index v i) p1 p2
   );
   array_pts_to_intro r (mk_fraction_seq td v (p1 `P.sum_perm` p2)) _ _ ()
+
+#restart-solver
+
+let array_fractional_permissions_theorem
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (v1: Seq.seq t { fractionable_seq td v1 })
+  (v2: Seq.seq t { fractionable_seq td v2 })
+  (p1 p2: P.perm)
+  (r: array td)
+: STGhost unit opened
+    (array_pts_to r (mk_fraction_seq td v1 p1) `star` array_pts_to r (mk_fraction_seq td v2 p2))
+    (fun _ -> array_pts_to r (mk_fraction_seq td v1 p1) `star` array_pts_to r (mk_fraction_seq td v2 p2))
+    (full_seq td v1 /\ full_seq td v2)
+    (fun _ -> v1 == v2 /\ (array_length r > 0 ==> (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm))
+= array_pts_to_length r (mk_fraction_seq td v1 p1);
+  array_pts_to_length r (mk_fraction_seq td v2 p2);
+  let br = array_pts_to_elim r (mk_fraction_seq td v1 p1) in
+  let _ = gen_elim () in
+  rewrite (A.pts_to _ _) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v1 p1));
+  let _ = array_pts_to_elim r (mk_fraction_seq td v2 p2) in
+  let _ = gen_elim () in
+  hr_gather (Ghost.reveal br) (array_ptr_of r).ar_base;
+  rewrite (A.pts_to _ (mk_fraction_seq _ _ p2)) (A.pts_to (model_array_of_array r br) (mk_fraction_seq td v2 p2));
+  let _ = A.gather_exists _ (mk_fraction_seq td v1 p1) (mk_fraction_seq td v2 p2) in
+  let prf
+    (i: nat)
+  : Lemma
+    (requires (i < array_length r))
+    (ensures (
+      i < array_length r /\
+      Seq.index v1 i == Seq.index v2 i /\
+      (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm
+    ))
+  = td.mk_fraction_full_composable (Seq.index v1 i) p1 (Seq.index v2 i) p2
+  in
+  Classical.forall_intro (Classical.move_requires prf);
+  assert (v1 `Seq.equal` v2);
+  A.share _ _ (mk_fraction_seq td v1 p1) (mk_fraction_seq td v2 p2);
+  HR.share _;
+  array_pts_to_intro r (mk_fraction_seq td v1 p1) _ _ ();
+  array_pts_to_intro r (mk_fraction_seq td v2 p2) _ _ ()
diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Base.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Base.fst
index 59637b74eb8..9aedbfeb610 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Base.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Base.fst
@@ -77,6 +77,23 @@ type typedef (t: Type0) : Type0 = {
     (requires (fractionable v /\ mk_fraction v p == one pcm))
     (ensures (v == one pcm))
   );
+  mk_fraction_full_composable: (
+    (v1: t) ->
+    (p1: P.perm) ->
+    (v2: t) ->
+    (p2: P.perm) ->
+    Lemma
+    (requires (
+      exclusive pcm v1 /\ p_refine pcm v1 /\
+      exclusive pcm v2 /\ p_refine pcm v2 /\
+      fractionable v1 /\ fractionable v2 /\
+      composable pcm (mk_fraction v1 p1) (mk_fraction v2 p2)
+    ))
+    (ensures (
+      v1 == v2 /\
+      (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm
+    ))
+  );
 }
 
 let fractionable td x = td.fractionable x == true
@@ -488,6 +505,34 @@ let mk_fraction_join
   td.mk_fraction_join v p1 p2;
   pts_to_intro_rewrite r r' _
 
+let fractional_permissions_theorem
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (v1: t { fractionable td v1 })
+  (v2: t { fractionable td v2 })
+  (p1 p2: P.perm)
+  (r: ref td)
+: STGhost unit opened
+    (pts_to r (mk_fraction td v1 p1) `star` pts_to r (mk_fraction td v2 p2))
+    (fun _ -> pts_to r (mk_fraction td v1 p1) `star` pts_to r (mk_fraction td v2 p2))
+    (full td v1 /\ full td v2)
+    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+= rewrite (pts_to r (mk_fraction td v1 p1)) (pts_to0 r (mk_fraction td v1 p1));
+  let _ = gen_elim () in
+  let w = vpattern_replace (HR.pts_to r _) in
+  let rr = get_ref r in
+  rewrite (pts_to r (mk_fraction td v2 p2)) (pts_to0 r (mk_fraction td v2 p2));
+  let _ = gen_elim () in
+  hr_gather w r;
+  rewrite (R.pts_to _ (mk_fraction td v2 p2)) (R.pts_to rr (mk_fraction td v2 p2));
+  let _ = R.gather rr (mk_fraction td v1 p1) (mk_fraction td v2 p2) in
+  td.mk_fraction_full_composable v1 p1 v2 p2;
+  R.split rr _ (mk_fraction td v1 p1) (mk_fraction td v2 p2);
+  hr_share r;
+  rewrite (pts_to0 r (mk_fraction td v2 p2)) (pts_to r (mk_fraction td v2 p2));
+  rewrite (pts_to0 r (mk_fraction td v1 p1)) (pts_to r (mk_fraction td v1 p1))
+
 let r_unfocus (#opened:_)
   (#ta #ta' #tb #tc: Type)
   (#p: pcm tb)
diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Rewrite.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Rewrite.fst
index 118146709e9..4a6930ece5a 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Rewrite.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Rewrite.fst
@@ -23,4 +23,5 @@ let rewrite_typedef
     mk_fraction_split = (fun y p1 p2 -> td.mk_fraction_split (rewrite.rewrite_to_from y) p1 p2);
     mk_fraction_join = (fun y p1 p2 -> td.mk_fraction_join (rewrite.rewrite_to_from y) p1 p2);
     mk_fraction_eq_one = (fun y p -> td.mk_fraction_eq_one (rewrite.rewrite_to_from y) p);
+    mk_fraction_full_composable = (fun v1 p1 v2 p2 -> td.mk_fraction_full_composable (rewrite.rewrite_to_from v1) p1 (rewrite.rewrite_to_from v2) p2);
   }
diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Scalar.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Scalar.fst
index cf1d428a0c1..684dcda17ab 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Scalar.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Scalar.fst
@@ -76,6 +76,7 @@ let scalar t = {
     | _ -> ()
   );
   mk_fraction_eq_one = (fun v p -> ());
+  mk_fraction_full_composable = (fun _ _ _ _ -> ());
 }
 
 let mk_scalar v = (Some (Some v, P.full_perm))
@@ -84,28 +85,6 @@ let mk_scalar_fractionable v p = ()
 
 let mk_scalar_inj v1 v2 p1 p2 = ()
 
-#push-options "--z3rlimit 16"
-
-#restart-solver
-
-let scalar_unique
-  #_ #t v1 v2 p1 p2 r
-= rewrite (pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1)) (pts_to0 r (Some (Some v1, p1)));
-  let _ = gen_elim () in
-  let w = vpattern_replace (HR.pts_to r _) in
-  let r' = get_ref r in
-  rewrite (pts_to r _) (pts_to0 r (Some (Some v2, p2)));
-  let _ = gen_elim () in
-  hr_gather w r;
-  rewrite (r_pts_to _ (Some (Some v2, p2))) (R.pts_to r' (Some (Some v2, p2)));
-  let _ = R.gather r' (Some (Some v1, p1)) (Some (Some v2, p2)) in
-  R.split r' _ (Some (Some v1, p1)) (Some (Some v2, p2));
-  HR.share r;
-  pts_to_intro_rewrite r r' #(Some (Some v1, p1)) (mk_fraction (scalar _) (mk_scalar v1) p1);
-  pts_to_intro_rewrite r r' #(Some (Some v2, p2)) (mk_fraction (scalar _) (mk_scalar v2) p2)
-
-#pop-options
-
 let read0
   #t #v #p r
 = rewrite (pts_to r _) (pts_to0 r (Some (Some (Ghost.reveal v), p)));
diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.Aux.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.Aux.fst
index 5462f1e3288..58339b2b92b 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.Aux.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Struct.Aux.fst
@@ -119,6 +119,13 @@ let struct1
       (fields.fd_typedef f).mk_fraction_eq_one (v f) p
     )
   );
+  mk_fraction_full_composable = (fun v1 p1 v2 p2 ->
+    let f = FStar.IndefiniteDescription.indefinite_description_ghost field_t (fun _ -> True) in
+    (fields.fd_typedef f).mk_fraction_full_composable (v1 f) p1 (v2 f) p2;
+    struct_eq_intro v1 v2 (fun f ->
+      (fields.fd_typedef f).mk_fraction_full_composable (v1 f) p1 (v2 f) p2
+    )
+  );    
 }
 
 [@@__reduce__]
diff --git a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Union.fst b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Union.fst
index 7fd69ebeed1..84810cad0fd 100644
--- a/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Union.fst
+++ b/examples/steel/arraystructs/fstlib/Steel.ST.C.Types.Union.fst
@@ -193,6 +193,22 @@ let union0
       (union_field_typedef fields f).mk_fraction_eq_one (v f) p
     )
   );
+  mk_fraction_full_composable = (fun v1 p1 v2 p2 ->
+    let co1 = U.case_of_union _ v1 in
+    let co2 = U.case_of_union _ v2 in
+    assert (Some? co1);
+    assert (Some? co2);
+    let Some c1 = co1 in
+    let Some c2 = co2 in
+    U.exclusive_union_elim (union_field_pcm fields) v1 c1;
+    U.exclusive_union_elim (union_field_pcm fields) v2 c2;
+    Classical.move_requires ((union_field_typedef fields c1).mk_fraction_eq_one (v1 c1)) p1;
+    Classical.move_requires ((union_field_typedef fields c2).mk_fraction_eq_one (v2 c2)) p2;
+    U.union_comp_elim0 (union_field_pcm fields) (union_mk_fraction v1 p1) (union_mk_fraction v2 p2) c1 c2;
+    assert (c1 == c2);
+    (union_field_typedef fields c1).mk_fraction_full_composable (v1 c1) p1 (v2 c1) p2;
+    assert (v1 `FX.feq` v2)
+  );
 }
 
 #pop-options
diff --git a/ulib/experimental/Steel.ST.C.Model.Array.fst b/ulib/experimental/Steel.ST.C.Model.Array.fst
index 231df93e647..d4a0432b146 100644
--- a/ulib/experimental/Steel.ST.C.Model.Array.fst
+++ b/ulib/experimental/Steel.ST.C.Model.Array.fst
@@ -552,35 +552,66 @@ let share
   intro_pts_to0 r a1 s1;
   intro_pts_to0 r a2 s2
 
-let gather
+let gather_exists
   (#opened: _)
   (#base_t: Type)
   (#t: Type)
   (#p: pcm t)
   (r: array base_t p)
-  (s s1 s2: Seq.seq t)
-: STGhost unit opened
+  (s1 s2: Seq.seq t)
+: STGhost (Ghost.erased (Seq.seq t)) opened
     (pts_to r s1 `star` pts_to r s2)
-    (fun _ -> pts_to r s)
+    (fun s -> pts_to r s)
     (
+      Seq.length s1 == Seq.length s2
+    )
+    (fun s ->
       Seq.length s1 == Seq.length s /\
       Seq.length s2 == Seq.length s /\
       (forall (i: nat) .
-        (i < Seq.length s /\ composable p (Seq.index s1 i) (Seq.index s2 i)) ==> (
+        i < Seq.length s ==> (
+        composable p (Seq.index s1 i) (Seq.index s2 i) /\
         op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
       ))
     )
-    (fun _ -> True)
 = let _ = elim_pts_to r s1 in
   let _ = elim_pts_to r s2 in
   let a1 = array_pcm_carrier_of_seq r.len s1 in
   let a2 = array_pcm_carrier_of_seq r.len s2 in
   let _ = R.gather _ (array_pcm_carrier_of_seq r.len s1) _ in
+  let v = vpattern_replace (R.pts_to _) in
+  let s = seq_of_array_pcm_carrier v in 
   assert (
     composable (array_pcm p r.len) a1 a2 /\
     op (array_pcm p r.len) a1 a2 `feq` array_pcm_carrier_of_seq r.len s
   );
-  intro_pts_to0 r _ s
+  assert (forall (i: nat) . i < Seq.length s ==>  composable p (a1 (SZ.uint_to_t i)) (a2 (SZ.uint_to_t i)));
+  intro_pts_to0 r _ s;
+  noop ();
+  s
+
+let gather
+  (#opened: _)
+  (#base_t: Type)
+  (#t: Type)
+  (#p: pcm t)
+  (r: array base_t p)
+  (s s1 s2: Seq.seq t)
+: STGhost unit opened
+    (pts_to r s1 `star` pts_to r s2)
+    (fun _ -> pts_to r s)
+    (
+      Seq.length s1 == Seq.length s /\
+      Seq.length s2 == Seq.length s /\
+      (forall (i: nat) .
+        (i < Seq.length s /\ composable p (Seq.index s1 i) (Seq.index s2 i)) ==> (
+        op p (Seq.index s1 i) (Seq.index s2 i) == Seq.index s i
+      ))
+    )
+    (fun _ -> True)
+= let s' = gather_exists r s1 s2 in
+  assert (s `Seq.equal` s');
+  vpattern_rewrite (pts_to r) s
 
 let sub
   (#base_t: Type)
diff --git a/ulib/experimental/Steel.ST.C.Types.Array.fsti b/ulib/experimental/Steel.ST.C.Types.Array.fsti
index d8a66496540..4e38d9ac690 100644
--- a/ulib/experimental/Steel.ST.C.Types.Array.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Array.fsti
@@ -961,3 +961,17 @@ val mk_fraction_seq_join
 : STGhostT unit opened
   (array_pts_to r (mk_fraction_seq td v p1) `star` array_pts_to r (mk_fraction_seq td v p2))
   (fun _ -> array_pts_to r (mk_fraction_seq td v (p1 `P.sum_perm` p2)))
+
+val array_fractional_permissions_theorem
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (v1: Seq.seq t { fractionable_seq td v1 })
+  (v2: Seq.seq t { fractionable_seq td v2 })
+  (p1 p2: P.perm)
+  (r: array td)
+: STGhost unit opened
+    (array_pts_to r (mk_fraction_seq td v1 p1) `star` array_pts_to r (mk_fraction_seq td v2 p2))
+    (fun _ -> array_pts_to r (mk_fraction_seq td v1 p1) `star` array_pts_to r (mk_fraction_seq td v2 p2))
+    (full_seq td v1 /\ full_seq td v2)
+    (fun _ -> v1 == v2 /\ (array_length r > 0 ==> (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm))
diff --git a/ulib/experimental/Steel.ST.C.Types.Base.fsti b/ulib/experimental/Steel.ST.C.Types.Base.fsti
index ccdb7702199..17d79145dd4 100644
--- a/ulib/experimental/Steel.ST.C.Types.Base.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Base.fsti
@@ -246,6 +246,20 @@ val mk_fraction_join
   (pts_to r (mk_fraction td v p1) `star` pts_to r (mk_fraction td v p2))
   (fun _ -> pts_to r (mk_fraction td v (p1 `P.sum_perm` p2)))
 
+val fractional_permissions_theorem
+  (#opened: _)
+  (#t: Type)
+  (#td: typedef t)
+  (v1: t { fractionable td v1 })
+  (v2: t { fractionable td v2 })
+  (p1 p2: P.perm)
+  (r: ref td)
+: STGhost unit opened
+    (pts_to r (mk_fraction td v1 p1) `star` pts_to r (mk_fraction td v2 p2))
+    (fun _ -> pts_to r (mk_fraction td v1 p1) `star` pts_to r (mk_fraction td v2 p2))
+    (full td v1 /\ full td v2)
+    (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+
 val norm_field_attr : unit
 
 noextract
diff --git a/ulib/experimental/Steel.ST.C.Types.Scalar.fsti b/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
index 6453804a581..4428be9910a 100644
--- a/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
+++ b/ulib/experimental/Steel.ST.C.Types.Scalar.fsti
@@ -33,7 +33,7 @@ val mk_scalar_inj
   (ensures (v1 == v2 /\ p1 == p2))
   [SMTPat [mk_fraction (scalar t) (mk_scalar v1) p1; mk_fraction (scalar t) (mk_scalar v2) p2]]
 
-val scalar_unique
+let scalar_unique
   (#opened: _)
   (#t: Type)
   (v1 v2: t)
@@ -44,6 +44,8 @@ val scalar_unique
     (fun _ -> pts_to r (mk_fraction (scalar t) (mk_scalar v1) p1) `star` pts_to r (mk_fraction (scalar t) (mk_scalar v2) p2))
     (True)
     (fun _ -> v1 == v2 /\ (p1 `P.sum_perm` p2) `P.lesser_equal_perm` P.full_perm)
+= fractional_permissions_theorem (mk_scalar v1) (mk_scalar v2) p1 p2 r;
+  mk_scalar_inj v1 v2 P.full_perm P.full_perm
 
 [@@noextract_to "krml"] // primitive
 val read0 (#t: Type) (#v: Ghost.erased t) (#p: P.perm) (r: ref (scalar t)) : ST t

From 5f2b500f3ced296eed7c276624b2d1a953e6f051 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 3 Apr 2023 19:18:19 -0700
Subject: [PATCH 497/513] build and dynamically load a plugin instead of a
 custom fstar.exe

---
 examples/steel/arraystructs/Makefile          | 21 +++++++++----------
 .../arraystructs/my_fstar/ExtractSteelC.fst   |  6 +-----
 .../arraystructs/my_fstar/ExtractSteelC.fsti  |  3 +--
 examples/steel/arraystructs/my_fstar/Makefile |  6 ++++--
 examples/steel/arraystructs/my_fstar/dune     | 11 +++++-----
 .../steel/arraystructs/my_fstar/dune-project  |  4 ++--
 examples/steel/arraystructs/my_fstar/main.ml  |  4 ----
 7 files changed, 23 insertions(+), 32 deletions(-)
 delete mode 100644 examples/steel/arraystructs/my_fstar/main.ml

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 6398d2915d8..2aeb0f40e0f 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -2,19 +2,14 @@ all: world
 
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
 export FSTAR_HOME
-ifdef KRML_HOME # FIXME: should be HAS_OCAML
-FSTAR_EXE = $(CURDIR)/my_fstar/bin/fstar.exe
-else # no KRML_HOME
 FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
-endif
-FSTAR_LIB ?= $(realpath $(FSTAR_HOME)/ulib)
-export FSTAR_LIB
 
 INCLUDE_PATH := $(FSTAR_HOME)/ulib/.cache $(FSTAR_HOME)/ulib/experimental
 
 ifdef KRML_HOME
 KRML_EXE = $(KRML_HOME)/krml
-INCLUDE_PATH += $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj
+MY_FSTAR_PATH=$(CURDIR)/my_fstar
+INCLUDE_PATH += $(KRML_HOME)/krmllib $(KRML_HOME)/krmllib/obj $(MY_FSTAR_PATH)/lib/steel_c
 endif
 
 world: verify test fstlib
@@ -22,13 +17,17 @@ world: verify test fstlib
 fstlib:
 	+$(MAKE) -C $@
 
-FSTAR_OPTIONS = --cache_checked_modules \
+FSTAR_OPTIONS := --cache_checked_modules \
 		--cmi \
 		--compat_pre_typed_indexed_effects \
 	        --already_cached 'Prims,FStar,LowStar,Steel' \
 		$(addprefix --include ,$(INCLUDE_PATH)) \
 		$(OTHERFLAGS)
 
+ifdef KRML_HOME
+FSTAR_OPTIONS += --load ExtractSteelC
+endif
+
 FSTAR = $(FSTAR_EXE) $(FSTAR_OPTIONS)
 
 ALL_SOURCE_FILES = $(wildcard *.fst *.fsti)
@@ -42,9 +41,9 @@ ifdef KRML_HOME # FIXME: should be HAS_OCAML
 # since the KaRaMeL AST does not have a node for null
 # TODO: This should be removed, and support for Steel.C null should be directly added to KaRaMeL instead
 SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst $(KRML_HOME)/krmllib/C.fst
-MY_FSTAR=$(FSTAR_EXE)
-$(FSTAR_EXE):
-	+$(MAKE) -C my_fstar
+MY_FSTAR=$(MY_FSTAR_PATH)/lib/steel_c/ExtractSteelC.cmxs
+$(MY_FSTAR):
+	+$(MAKE) -C $(MY_FSTAR_PATH)
 endif
 
 .depend: $(ALL_SOURCE_FILES) Makefile $(MY_FSTAR)
diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
index 95f6f7e5e61..28543f73f36 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fst
@@ -482,12 +482,8 @@ let my_type_decls () = register_pre_translate_type_decl begin fun env ty ->
     | _ -> raise NotSupportedByKrmlExtension
 end
 
-let register () =
+let _ =
   my_types_without_decay ();
   my_types ();
   my_exprs ();
   my_type_decls ()
-
-let main () =
-  register ();
-  FStar.Main.main ()
diff --git a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
index be7526e3523..8fbbb054759 100644
--- a/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
+++ b/examples/steel/arraystructs/my_fstar/ExtractSteelC.fsti
@@ -1,3 +1,2 @@
 module ExtractSteelC
-
-val main: unit -> FStar.Compiler.Effect.ML unit
+(* this interface is necessary because ExtractSteelC `friend`s FStar.Extraction.Krml *)
diff --git a/examples/steel/arraystructs/my_fstar/Makefile b/examples/steel/arraystructs/my_fstar/Makefile
index d533ba44314..c28ac9cbab0 100644
--- a/examples/steel/arraystructs/my_fstar/Makefile
+++ b/examples/steel/arraystructs/my_fstar/Makefile
@@ -1,6 +1,8 @@
 all: world
 
-world: $(CURDIR)/bin/fstar.exe
+MY_OBJ=$(CURDIR)/lib/steel_c/ExtractSteelC.cmxs
+
+world: $(MY_OBJ)
 
 FSTAR_HOME ?= $(realpath $(dir $(shell which fstar.exe))/..)
 FSTAR_EXE = $(FSTAR_HOME)/bin/fstar.exe
@@ -25,5 +27,5 @@ $(EXTRACT_FILES): %.ml: %.fst
                    --codegen OCaml \
                    --extract_module $(basename $(notdir $<))
 
-$(CURDIR)/bin/fstar.exe: ExtractSteelC.fst ExtractSteelC.fsti Makefile main.ml
+$(MY_OBJ): ExtractSteelC.fst ExtractSteelC.fsti Makefile
 	OCAMLPATH=$(FSTAR_HOME)/lib dune build && dune install --prefix=$(CURDIR)
diff --git a/examples/steel/arraystructs/my_fstar/dune b/examples/steel/arraystructs/my_fstar/dune
index c81c03adc43..bd1dd1cabfd 100644
--- a/examples/steel/arraystructs/my_fstar/dune
+++ b/examples/steel/arraystructs/my_fstar/dune
@@ -1,12 +1,11 @@
-(executable
- (name main)
- (public_name fstar.exe)
+(library
+ (name ExtractSteelC)
+ (public_name steel_c)
  (libraries
     fstar.lib
  )
- (modules Main ExtractSteelC)
- (link_flags "-linkall")
- (modes (native exe))
+ (modes native)
+ (wrapped false)
  (flags (:standard -w -A))
 )
 
diff --git a/examples/steel/arraystructs/my_fstar/dune-project b/examples/steel/arraystructs/my_fstar/dune-project
index 841110fda04..45dd1bc1e23 100644
--- a/examples/steel/arraystructs/my_fstar/dune-project
+++ b/examples/steel/arraystructs/my_fstar/dune-project
@@ -1,8 +1,8 @@
 (lang dune 3.2)
-(name fstar-steel-c)
+(name steel_c)
 (generate_opam_files false)
 
 (package
-  (name fstar-steel-c)
+  (name steel_c)
   (synopsis "The F* programming language and proof assistant with extraction of Steel files to C")
 )
diff --git a/examples/steel/arraystructs/my_fstar/main.ml b/examples/steel/arraystructs/my_fstar/main.ml
deleted file mode 100644
index fc95fadebc7..00000000000
--- a/examples/steel/arraystructs/my_fstar/main.ml
+++ /dev/null
@@ -1,4 +0,0 @@
-let x =
-      Printexc.record_backtrace true;
-      Gc.set { (Gc.get()) with Gc.minor_heap_size = 1048576; Gc.major_heap_increment = 4194304; Gc.space_overhead = 150; };
-      ExtractSteelC.main ()

From ca7a91f8a394dbf2e4e520ae81ca3197e15b2594 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 10 Apr 2023 10:43:09 -0700
Subject: [PATCH 498/513] Revert "snap"

This reverts commit e7259a50b53c8ee9004b5cbf7a2db23b6b4794e4.
---
 .../generated/FStar_Extraction_Krml.ml        |  433 ++---
 ocaml/fstar-lib/generated/FStar_Main.ml       |    3 +-
 .../generated/Steel_ST_GenElim_Base.ml        | 1556 +++++++----------
 3 files changed, 729 insertions(+), 1263 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index dd7c2505755..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,18 +996,16 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" ->
-          translate_type_without_decay env1 arg
+          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1163,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1198,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2669,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3098,122 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type_without_decay env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 =
-                                        translate_type_without_decay env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3553,10 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (init : unit -> unit) =
-  fun uu___ ->
-    register_post_translate_type_without_decay translate_type_without_decay';
-    register_post_translate_type translate_type';
-    register_post_translate_type_decl translate_type_decl';
-    register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index d763e38153f..8ad6b788389 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -294,8 +294,7 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
-    FStar_Extraction_Krml.init ()
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index b23bdfc10ec..2ca503ea1dc 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (5))
-                          (Prims.of_int (342)) (Prims.of_int (28)))
+                          (Prims.of_int (310)) (Prims.of_int (5))
+                          (Prims.of_int (310)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (2))
-                          (Prims.of_int (352)) (Prims.of_int (12)))
+                          (Prims.of_int (310)) (Prims.of_int (2))
+                          (Prims.of_int (320)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (352))
+                                          (Prims.of_int (320))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (350))
+                                                                 (Prims.of_int (318))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (23))
-                         (Prims.of_int (361)) (Prims.of_int (40)))
+                         (Prims.of_int (329)) (Prims.of_int (23))
+                         (Prims.of_int (329)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (8))
-                         (Prims.of_int (372)) (Prims.of_int (47)))
+                         (Prims.of_int (329)) (Prims.of_int (8))
+                         (Prims.of_int (340)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (372))
+                                             (Prims.of_int (340))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (367))
+                                                                    (Prims.of_int (335))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (367))
+                                                                    (Prims.of_int (335))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,53 +347,22 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
-let rec (get_universe :
-  FStar_Reflection_Types.universe ->
-    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
-  =
-  fun uu___ ->
-    (fun u ->
-       match FStar_Reflection_Builtins.inspect_universe u with
-       | FStar_Reflection_Data.Uv_Zero ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.lift_div_tac
-                   (fun uu___ -> Prims.int_zero)))
-       | FStar_Reflection_Data.Uv_Succ u1 ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.tac_bind
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (23))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (19))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Obj.magic (get_universe u1))
-                   (fun uu___ ->
-                      FStar_Tactics_Effect.lift_div_tac
-                        (fun uu___1 -> Prims.int_one + uu___))))
-       | uu___ ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Derived.fail
-                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -410,11 +379,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (395)) (Prims.of_int (17))
-                      (Prims.of_int (395)) (Prims.of_int (40)))
+                      (Prims.of_int (355)) (Prims.of_int (17))
+                      (Prims.of_int (355)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (396)) (Prims.of_int (8))
-                      (Prims.of_int (396)) (Prims.of_int (45)))
+                      (Prims.of_int (356)) (Prims.of_int (8))
+                      (Prims.of_int (356)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -433,11 +402,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (26))
-                      (Prims.of_int (398)) (Prims.of_int (43)))
+                      (Prims.of_int (358)) (Prims.of_int (26))
+                      (Prims.of_int (358)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (8))
-                      (Prims.of_int (458)) (Prims.of_int (68)))
+                      (Prims.of_int (358)) (Prims.of_int (8))
+                      (Prims.of_int (399)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -450,122 +419,88 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (401))
-                                       (Prims.of_int (25))
-                                       (Prims.of_int (403))
-                                       (Prims.of_int (63)))
+                                       (Prims.of_int (362))
+                                       (Prims.of_int (12))
+                                       (Prims.of_int (365))
+                                       (Prims.of_int (46)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (405))
+                                       (Prims.of_int (361))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (437))
+                                       (Prims.of_int (378))
                                        (Prims.of_int (13)))
-                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
-                                             hd
-                                     with
-                                     | FStar_Reflection_Data.Tv_UInst
-                                         (uu___3, u::uu___4) ->
-                                         Obj.magic
-                                           (Obj.repr (get_universe u))
+                                    (match lbody with
+                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
+                                         (body,
+                                          FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         FStar_Tactics_Effect.lift_div_tac
+                                           (fun uu___3 ->
+                                              ([(ty,
+                                                  FStar_Reflection_Data.Q_Implicit)],
+                                                body))
+                                     | (body,
+                                        FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         FStar_Tactics_Effect.lift_div_tac
+                                           (fun uu___3 -> ([], body))
                                      | uu___3 ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Derived.fail
-                                                 "ill-formed exists_: no universe found")))
+                                         FStar_Tactics_Derived.fail
+                                           "ill-formed exists_")
                                     (fun uu___3 ->
-                                       (fun universe ->
-                                          Obj.magic
-                                            (FStar_Tactics_Effect.tac_bind
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (406))
-                                                  (Prims.of_int (12))
-                                                  (Prims.of_int (409))
-                                                  (Prims.of_int (46)))
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (405))
-                                                  (Prims.of_int (10))
-                                                  (Prims.of_int (437))
-                                                  (Prims.of_int (13)))
-                                               (match lbody with
-                                                | (ty,
-                                                   FStar_Reflection_Data.Q_Implicit)::
-                                                    (body,
-                                                     FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    FStar_Tactics_Effect.lift_div_tac
-                                                      (fun uu___3 ->
-                                                         ([(ty,
-                                                             FStar_Reflection_Data.Q_Implicit)],
-                                                           body))
-                                                | (body,
-                                                   FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    FStar_Tactics_Effect.lift_div_tac
-                                                      (fun uu___3 ->
-                                                         ([], body))
-                                                | uu___3 ->
-                                                    FStar_Tactics_Derived.fail
-                                                      "ill-formed exists_")
-                                               (fun uu___3 ->
-                                                  (fun uu___3 ->
-                                                     match uu___3 with
-                                                     | (ty, body) ->
-                                                         Obj.magic
-                                                           (FStar_Tactics_Effect.tac_bind
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (22))
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (36)))
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (16))
-                                                                 (Prims.of_int (436))
-                                                                 (Prims.of_int (21)))
-                                                              (Obj.magic
-                                                                 (FStar_Tactics_Builtins.inspect
-                                                                    body))
-                                                              (fun uu___4 ->
-                                                                 (fun uu___4
-                                                                    ->
-                                                                    match uu___4
-                                                                    with
-                                                                    | 
-                                                                    FStar_Reflection_Data.Tv_Abs
-                                                                    (b,
-                                                                    abody) ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.tac_bind
+                                       (fun uu___3 ->
+                                          match uu___3 with
+                                          | (ty, body) ->
+                                              Obj.magic
+                                                (FStar_Tactics_Effect.tac_bind
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (22))
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (36)))
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (16))
+                                                      (Prims.of_int (377))
+                                                      (Prims.of_int (45)))
+                                                   (Obj.magic
+                                                      (FStar_Tactics_Builtins.inspect
+                                                         body))
+                                                   (fun uu___4 ->
+                                                      (fun uu___4 ->
+                                                         match uu___4 with
+                                                         | FStar_Reflection_Data.Tv_Abs
+                                                             (b, abody) ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -594,16 +529,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -615,58 +550,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -696,32 +631,14 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___8
-                                                                    when
-                                                                    uu___8 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsUnit0"]))
-                                                                    | 
-                                                                    uu___8 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit1"])))
+                                                                    "GEExistsUnit"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -729,16 +646,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -750,58 +667,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (78)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -831,86 +748,48 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___9
-                                                                    when
-                                                                    uu___9 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExists0"]))
-                                                                    | 
-                                                                    uu___9 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists1"])))
+                                                                    "GEExists"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                                    | 
-                                                                    uu___5 ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                         | uu___5 ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___7
-                                                                    when
-                                                                    uu___7 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsNoAbs0"]))
-                                                                    | 
-                                                                    uu___7 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs1"])))
+                                                                    "GEExistsNoAbs"])))
                                                                     lbody))))
-                                                                   uu___4)))
-                                                    uu___3))) uu___3))
+                                                        uu___4))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (458))
+                                       (Prims.of_int (399))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -929,15 +808,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (455))
+                                                              (Prims.of_int (396))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -958,15 +837,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -979,15 +858,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -1009,15 +888,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1046,15 +925,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1085,15 +964,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1106,15 +985,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1198,11 +1077,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (19))
-                            (Prims.of_int (547)) (Prims.of_int (34)))
+                            (Prims.of_int (488)) (Prims.of_int (19))
+                            (Prims.of_int (488)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (4))
-                            (Prims.of_int (592)) (Prims.of_int (13)))
+                            (Prims.of_int (488)) (Prims.of_int (4))
+                            (Prims.of_int (532)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1222,15 +1101,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (552))
+                                                     (Prims.of_int (493))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (554))
-                                                     (Prims.of_int (88)))
+                                                     (Prims.of_int (495))
+                                                     (Prims.of_int (85)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (556))
+                                                     (Prims.of_int (497))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (582))
+                                                     (Prims.of_int (522))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1240,16 +1119,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (554))
-                                                                   (Prims.of_int (88)))
+                                                                   (Prims.of_int (495))
+                                                                   (Prims.of_int (85)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1268,16 +1147,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (495))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (554))
-                                                                    (Prims.of_int (88)))
+                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (85)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1295,9 +1174,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1310,15 +1187,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (497))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (556))
-                                                                (Prims.of_int (84)))
+                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (79)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (557))
+                                                                (Prims.of_int (498))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (582))
+                                                                (Prims.of_int (522))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1343,9 +1220,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1356,15 +1231,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (558))
+                                                                    (Prims.of_int (499))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1381,15 +1256,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (560))
+                                                                    (Prims.of_int (501))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (564))
+                                                                    (Prims.of_int (505))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (566))
+                                                                    (Prims.of_int (507))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1402,16 +1277,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1423,16 +1298,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (504))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1454,9 +1329,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1491,69 +1364,23 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (39))
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (81)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
-                                                                    (Prims.of_int (9)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.fresh_binder
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))))
-                                                                    (fun
-                                                                    uu___3 ->
-                                                                    (fun
-                                                                    dummy_raised_unit_binder
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (510))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (120)))
+                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.append
-                                                                    (FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders))
-                                                                    [dummy_raised_unit_binder]))
+                                                                    rev_types_and_binders)))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1563,15 +1390,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1591,15 +1418,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1612,97 +1439,37 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (573))
-                                                                    (Prims.of_int (151)))
+                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (113)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    {
-                                                                    FStar_Reflection_Data.binder_bv
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    =
-                                                                    (FStar_Sealed.seal
-                                                                    "_");
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (964));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    });
-                                                                    FStar_Reflection_Data.binder_qual
-                                                                    =
-                                                                    FStar_Reflection_Data.Q_Explicit;
-                                                                    FStar_Reflection_Data.binder_attrs
-                                                                    = []
-                                                                    }),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"])))))))),
+                                                                    "vprop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1712,15 +1479,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1733,95 +1500,35 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (575))
-                                                                    (Prims.of_int (150)))
+                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (112)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (516))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    {
-                                                                    FStar_Reflection_Data.binder_bv
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    =
-                                                                    (FStar_Sealed.seal
-                                                                    "_");
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (967));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    });
-                                                                    FStar_Reflection_Data.binder_qual
-                                                                    =
-                                                                    FStar_Reflection_Data.Q_Explicit;
-                                                                    FStar_Reflection_Data.binder_attrs
-                                                                    = []
-                                                                    }),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"])))))))),
+                                                                    "prop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1836,7 +1543,6 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
-                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1863,15 +1569,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (589))
+                                                         (Prims.of_int (529))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1932,11 +1638,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (599)) (Prims.of_int (17))
-                                 (Prims.of_int (599)) (Prims.of_int (64)))
+                                 (Prims.of_int (539)) (Prims.of_int (17))
+                                 (Prims.of_int (539)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (600)) (Prims.of_int (6))
-                                 (Prims.of_int (601)) (Prims.of_int (37)))
+                                 (Prims.of_int (540)) (Prims.of_int (6))
+                                 (Prims.of_int (541)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1955,15 +1661,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1997,10 +1703,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -2015,76 +1721,32 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_UInst
-                            ((FStar_Reflection_Builtins.pack_fv
-                                ["Steel";
-                                "ST";
-                                "GenElim";
-                                "Base";
-                                "mk_gen_elim_nondep_by_tac"]),
-                              [FStar_Reflection_Builtins.pack_universe
-                                 (FStar_Reflection_Data.Uv_Succ
-                                    (FStar_Reflection_Builtins.pack_universe
-                                       FStar_Reflection_Data.Uv_Zero))])))
+                         (FStar_Reflection_Data.Tv_FVar
+                            (FStar_Reflection_Builtins.pack_fv
+                               ["Steel";
+                               "ST";
+                               "GenElim";
+                               "Base";
+                               "mk_gen_elim_nondep_by_tac"])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
-let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
-  fun uu___ ->
-    FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
-         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
-         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
-      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
-      (fun uu___1 ->
-         (fun ty ->
-            Obj.magic
-              (FStar_Tactics_Effect.tac_bind
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (8))
-                    (Prims.of_int (624)) (Prims.of_int (28)))
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (2))
-                    (Prims.of_int (626)) (Prims.of_int (27)))
-                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
-                 (fun uu___1 ->
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | FStar_Reflection_Formula.Comp
-                           (uu___2, uu___3, uu___4) ->
-                           Obj.magic (FStar_Tactics_Derived.trefl ())
-                       | uu___2 ->
-                           Obj.magic
-                             (FStar_Tactics_Effect.tac_bind
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (9))
-                                   (Prims.of_int (626)) (Prims.of_int (17)))
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (19))
-                                   (Prims.of_int (626)) (Prims.of_int (27)))
-                                (Obj.magic (FStar_Tactics_Derived.smt ()))
-                                (fun uu___3 ->
-                                   (fun uu___3 ->
-                                      Obj.magic
-                                        (FStar_Tactics_Derived.qed ()))
-                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2096,27 +1758,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (633)) (Prims.of_int (2))
-                        (Prims.of_int (634)) (Prims.of_int (33)))
+                        (Prims.of_int (567)) (Prims.of_int (2))
+                        (Prims.of_int (568)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (635)) (Prims.of_int (2))
-                        (Prims.of_int (670)) (Prims.of_int (35)))
+                        (Prims.of_int (569)) (Prims.of_int (2))
+                        (Prims.of_int (604)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (5))
-                              (Prims.of_int (633)) (Prims.of_int (23)))
+                              (Prims.of_int (567)) (Prims.of_int (5))
+                              (Prims.of_int (567)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (2))
-                              (Prims.of_int (634)) (Prims.of_int (33)))
+                              (Prims.of_int (567)) (Prims.of_int (2))
+                              (Prims.of_int (568)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (9))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (9))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (5))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (5))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2138,15 +1800,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (669))
+                                          (Prims.of_int (603))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2160,15 +1822,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (638))
+                                                         (Prims.of_int (572))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (639))
+                                                         (Prims.of_int (573))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (640))
+                                                         (Prims.of_int (574))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (668))
+                                                         (Prims.of_int (602))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -2207,15 +1869,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2233,15 +1895,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2255,15 +1917,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2287,29 +1949,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2360,15 +2022,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (652))
+                                                                    (Prims.of_int (586))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (593))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2404,15 +2066,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2422,15 +2084,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2458,15 +2120,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2493,15 +2155,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2511,15 +2173,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2543,15 +2205,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (49)))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2561,16 +2223,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (48)))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2580,8 +2242,32 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (trefl_or_smt
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (33))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (45)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (47))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (55)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.trivial
+                                                                    ()))
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Derived.qed
                                                                     ()))
+                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2593,15 +2279,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2611,15 +2297,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2643,15 +2329,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2661,15 +2347,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2697,15 +2383,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2743,16 +2429,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2764,27 +2450,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (677)) (Prims.of_int (2))
-                        (Prims.of_int (678)) (Prims.of_int (33)))
+                        (Prims.of_int (611)) (Prims.of_int (2))
+                        (Prims.of_int (612)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (679)) (Prims.of_int (2))
-                        (Prims.of_int (712)) (Prims.of_int (35)))
+                        (Prims.of_int (613)) (Prims.of_int (2))
+                        (Prims.of_int (644)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (5))
-                              (Prims.of_int (677)) (Prims.of_int (23)))
+                              (Prims.of_int (611)) (Prims.of_int (5))
+                              (Prims.of_int (611)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (2))
-                              (Prims.of_int (678)) (Prims.of_int (33)))
+                              (Prims.of_int (611)) (Prims.of_int (2))
+                              (Prims.of_int (612)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (9))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (9))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (5))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (5))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2806,15 +2492,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (711))
+                                          (Prims.of_int (643))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2828,15 +2514,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (682))
+                                                         (Prims.of_int (616))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (683))
+                                                         (Prims.of_int (617))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (684))
+                                                         (Prims.of_int (618))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (710))
+                                                         (Prims.of_int (642))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2875,43 +2561,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2949,29 +2635,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2995,29 +2681,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3041,29 +2727,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3087,15 +2773,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (626))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -3122,15 +2808,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -3148,15 +2834,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -3170,15 +2856,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -3193,15 +2879,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3223,21 +2909,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (697))
-                                                                    (Prims.of_int (89)))
+                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
-                                                                    (FStar_Tactics_Effect.lift_div_tac
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    FStar_Reflection_Derived.mk_app
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -3250,7 +2934,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)]))
+                                                                    FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -3260,59 +2944,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (698))
-                                                                    (Prims.of_int (37)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Builtins.term_to_string
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun
-                                                                    a'_ts ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (15))
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (27)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun a'1
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3339,15 +2979,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3374,15 +3014,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3397,19 +3037,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'1))
+                                                                    a'))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3420,15 +3060,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3443,15 +3083,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3466,15 +3106,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3489,15 +3129,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3512,15 +3152,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3552,8 +3192,6 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
-                                                                    uu___12)))
-                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From 5c2ed8d3b67d2c0e279404026abd761f99ba67ff Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 10 Apr 2023 10:57:31 -0700
Subject: [PATCH 499/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        |  433 +++--
 ocaml/fstar-lib/generated/FStar_Main.ml       |    3 +-
 .../generated/Steel_ST_GenElim_Base.ml        | 1556 ++++++++++-------
 3 files changed, 1263 insertions(+), 729 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..dd7c2505755 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,16 +1142,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1163,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1198,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2669,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3098,122 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3553,10 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (init : unit -> unit) =
+  fun uu___ ->
+    register_post_translate_type_without_decay translate_type_without_decay';
+    register_post_translate_type translate_type';
+    register_post_translate_type_decl translate_type_decl';
+    register_post_translate_expr translate_expr'
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index 9881890396c..588e5b12300 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -297,7 +297,8 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
+    FStar_Extraction_Krml.init ()
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index 2ca503ea1dc..b23bdfc10ec 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (5))
-                          (Prims.of_int (310)) (Prims.of_int (28)))
+                          (Prims.of_int (342)) (Prims.of_int (5))
+                          (Prims.of_int (342)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (2))
-                          (Prims.of_int (320)) (Prims.of_int (12)))
+                          (Prims.of_int (342)) (Prims.of_int (2))
+                          (Prims.of_int (352)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (320))
+                                          (Prims.of_int (352))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (318))
+                                                                 (Prims.of_int (350))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (23))
-                         (Prims.of_int (329)) (Prims.of_int (40)))
+                         (Prims.of_int (361)) (Prims.of_int (23))
+                         (Prims.of_int (361)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (8))
-                         (Prims.of_int (340)) (Prims.of_int (47)))
+                         (Prims.of_int (361)) (Prims.of_int (8))
+                         (Prims.of_int (372)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (340))
+                                             (Prims.of_int (372))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,22 +347,53 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
+let rec (get_universe :
+  FStar_Reflection_Types.universe ->
+    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
+  =
+  fun uu___ ->
+    (fun u ->
+       match FStar_Reflection_Builtins.inspect_universe u with
+       | FStar_Reflection_Data.Uv_Zero ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.lift_div_tac
+                   (fun uu___ -> Prims.int_zero)))
+       | FStar_Reflection_Data.Uv_Succ u1 ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.tac_bind
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (23))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (19))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Obj.magic (get_universe u1))
+                   (fun uu___ ->
+                      FStar_Tactics_Effect.lift_div_tac
+                        (fun uu___1 -> Prims.int_one + uu___))))
+       | uu___ ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Derived.fail
+                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -379,11 +410,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (355)) (Prims.of_int (17))
-                      (Prims.of_int (355)) (Prims.of_int (40)))
+                      (Prims.of_int (395)) (Prims.of_int (17))
+                      (Prims.of_int (395)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (356)) (Prims.of_int (8))
-                      (Prims.of_int (356)) (Prims.of_int (45)))
+                      (Prims.of_int (396)) (Prims.of_int (8))
+                      (Prims.of_int (396)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -402,11 +433,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (26))
-                      (Prims.of_int (358)) (Prims.of_int (43)))
+                      (Prims.of_int (398)) (Prims.of_int (26))
+                      (Prims.of_int (398)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (8))
-                      (Prims.of_int (399)) (Prims.of_int (68)))
+                      (Prims.of_int (398)) (Prims.of_int (8))
+                      (Prims.of_int (458)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -419,88 +450,122 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (362))
-                                       (Prims.of_int (12))
-                                       (Prims.of_int (365))
-                                       (Prims.of_int (46)))
+                                       (Prims.of_int (401))
+                                       (Prims.of_int (25))
+                                       (Prims.of_int (403))
+                                       (Prims.of_int (63)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (361))
+                                       (Prims.of_int (405))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (378))
+                                       (Prims.of_int (437))
                                        (Prims.of_int (13)))
-                                    (match lbody with
-                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
-                                         (body,
-                                          FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 ->
-                                              ([(ty,
-                                                  FStar_Reflection_Data.Q_Implicit)],
-                                                body))
-                                     | (body,
-                                        FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 -> ([], body))
+                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
+                                             hd
+                                     with
+                                     | FStar_Reflection_Data.Tv_UInst
+                                         (uu___3, u::uu___4) ->
+                                         Obj.magic
+                                           (Obj.repr (get_universe u))
                                      | uu___3 ->
-                                         FStar_Tactics_Derived.fail
-                                           "ill-formed exists_")
+                                         Obj.magic
+                                           (Obj.repr
+                                              (FStar_Tactics_Derived.fail
+                                                 "ill-formed exists_: no universe found")))
                                     (fun uu___3 ->
-                                       (fun uu___3 ->
-                                          match uu___3 with
-                                          | (ty, body) ->
-                                              Obj.magic
-                                                (FStar_Tactics_Effect.tac_bind
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (22))
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (36)))
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (16))
-                                                      (Prims.of_int (377))
-                                                      (Prims.of_int (45)))
-                                                   (Obj.magic
-                                                      (FStar_Tactics_Builtins.inspect
-                                                         body))
-                                                   (fun uu___4 ->
-                                                      (fun uu___4 ->
-                                                         match uu___4 with
-                                                         | FStar_Reflection_Data.Tv_Abs
-                                                             (b, abody) ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.tac_bind
+                                       (fun universe ->
+                                          Obj.magic
+                                            (FStar_Tactics_Effect.tac_bind
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (406))
+                                                  (Prims.of_int (12))
+                                                  (Prims.of_int (409))
+                                                  (Prims.of_int (46)))
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (405))
+                                                  (Prims.of_int (10))
+                                                  (Prims.of_int (437))
+                                                  (Prims.of_int (13)))
+                                               (match lbody with
+                                                | (ty,
+                                                   FStar_Reflection_Data.Q_Implicit)::
+                                                    (body,
+                                                     FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([(ty,
+                                                             FStar_Reflection_Data.Q_Implicit)],
+                                                           body))
+                                                | (body,
+                                                   FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([], body))
+                                                | uu___3 ->
+                                                    FStar_Tactics_Derived.fail
+                                                      "ill-formed exists_")
+                                               (fun uu___3 ->
+                                                  (fun uu___3 ->
+                                                     match uu___3 with
+                                                     | (ty, body) ->
+                                                         Obj.magic
+                                                           (FStar_Tactics_Effect.tac_bind
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (22))
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (36)))
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (16))
+                                                                 (Prims.of_int (436))
+                                                                 (Prims.of_int (21)))
+                                                              (Obj.magic
+                                                                 (FStar_Tactics_Builtins.inspect
+                                                                    body))
+                                                              (fun uu___4 ->
+                                                                 (fun uu___4
+                                                                    ->
+                                                                    match uu___4
+                                                                    with
+                                                                    | 
+                                                                    FStar_Reflection_Data.Tv_Abs
+                                                                    (b,
+                                                                    abody) ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -529,16 +594,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -550,58 +615,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (82)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -631,14 +696,32 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___8
+                                                                    when
+                                                                    uu___8 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit"])))
+                                                                    "GEExistsUnit0"]))
+                                                                    | 
+                                                                    uu___8 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsUnit1"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -646,16 +729,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -667,58 +750,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (78)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -748,48 +831,86 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___9
+                                                                    when
+                                                                    uu___9 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists"])))
+                                                                    "GEExists0"]))
+                                                                    | 
+                                                                    uu___9 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExists1"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                         | uu___5 ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.lift_div_tac
+                                                                    | 
+                                                                    uu___5 ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___7
+                                                                    when
+                                                                    uu___7 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs"])))
+                                                                    "GEExistsNoAbs0"]))
+                                                                    | 
+                                                                    uu___7 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsNoAbs1"])))
                                                                     lbody))))
-                                                        uu___4))) uu___3))
+                                                                   uu___4)))
+                                                    uu___3))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (399))
+                                       (Prims.of_int (458))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -808,15 +929,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (396))
+                                                              (Prims.of_int (455))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -837,15 +958,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -858,15 +979,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -888,15 +1009,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -925,15 +1046,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -964,15 +1085,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -985,15 +1106,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1077,11 +1198,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (19))
-                            (Prims.of_int (488)) (Prims.of_int (34)))
+                            (Prims.of_int (547)) (Prims.of_int (19))
+                            (Prims.of_int (547)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (4))
-                            (Prims.of_int (532)) (Prims.of_int (13)))
+                            (Prims.of_int (547)) (Prims.of_int (4))
+                            (Prims.of_int (592)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1101,15 +1222,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (493))
+                                                     (Prims.of_int (552))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (495))
-                                                     (Prims.of_int (85)))
+                                                     (Prims.of_int (554))
+                                                     (Prims.of_int (88)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (497))
+                                                     (Prims.of_int (556))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (522))
+                                                     (Prims.of_int (582))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1119,16 +1240,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (495))
-                                                                   (Prims.of_int (85)))
+                                                                   (Prims.of_int (554))
+                                                                   (Prims.of_int (88)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1147,16 +1268,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (554))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (495))
-                                                                    (Prims.of_int (85)))
+                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (88)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1174,7 +1295,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1187,15 +1310,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (556))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (497))
-                                                                (Prims.of_int (79)))
+                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (84)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (498))
+                                                                (Prims.of_int (557))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (522))
+                                                                (Prims.of_int (582))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1220,7 +1343,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1231,15 +1356,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (499))
+                                                                    (Prims.of_int (558))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1256,15 +1381,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (501))
+                                                                    (Prims.of_int (560))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (505))
+                                                                    (Prims.of_int (564))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (507))
+                                                                    (Prims.of_int (566))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1277,16 +1402,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1298,16 +1423,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (563))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1329,7 +1454,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1364,23 +1491,69 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (39))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (81)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (8))
+                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (9)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.fresh_binder
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))))
+                                                                    (fun
+                                                                    uu___3 ->
+                                                                    (fun
+                                                                    dummy_raised_unit_binder
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (510))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (120)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.append
+                                                                    (FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders)))
+                                                                    rev_types_and_binders))
+                                                                    [dummy_raised_unit_binder]))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1390,15 +1563,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1418,15 +1591,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1439,37 +1612,97 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (513))
-                                                                    (Prims.of_int (113)))
+                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (151)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    {
+                                                                    FStar_Reflection_Data.binder_bv
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    =
+                                                                    (FStar_Sealed.seal
+                                                                    "_");
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (964));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    });
+                                                                    FStar_Reflection_Data.binder_qual
+                                                                    =
+                                                                    FStar_Reflection_Data.Q_Explicit;
+                                                                    FStar_Reflection_Data.binder_attrs
+                                                                    = []
+                                                                    }),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"]))),
+                                                                    "vprop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1479,15 +1712,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1500,35 +1733,95 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (515))
-                                                                    (Prims.of_int (112)))
+                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (150)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (516))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    {
+                                                                    FStar_Reflection_Data.binder_bv
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    =
+                                                                    (FStar_Sealed.seal
+                                                                    "_");
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (967));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    });
+                                                                    FStar_Reflection_Data.binder_qual
+                                                                    =
+                                                                    FStar_Reflection_Data.Q_Explicit;
+                                                                    FStar_Reflection_Data.binder_attrs
+                                                                    = []
+                                                                    }),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"]))),
+                                                                    "prop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1543,6 +1836,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
+                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1569,15 +1863,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (529))
+                                                         (Prims.of_int (589))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1638,11 +1932,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (539)) (Prims.of_int (17))
-                                 (Prims.of_int (539)) (Prims.of_int (64)))
+                                 (Prims.of_int (599)) (Prims.of_int (17))
+                                 (Prims.of_int (599)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (540)) (Prims.of_int (6))
-                                 (Prims.of_int (541)) (Prims.of_int (37)))
+                                 (Prims.of_int (600)) (Prims.of_int (6))
+                                 (Prims.of_int (601)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1661,15 +1955,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1703,10 +1997,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1721,32 +2015,76 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_FVar
-                            (FStar_Reflection_Builtins.pack_fv
-                               ["Steel";
-                               "ST";
-                               "GenElim";
-                               "Base";
-                               "mk_gen_elim_nondep_by_tac"])))
+                         (FStar_Reflection_Data.Tv_UInst
+                            ((FStar_Reflection_Builtins.pack_fv
+                                ["Steel";
+                                "ST";
+                                "GenElim";
+                                "Base";
+                                "mk_gen_elim_nondep_by_tac"]),
+                              [FStar_Reflection_Builtins.pack_universe
+                                 (FStar_Reflection_Data.Uv_Succ
+                                    (FStar_Reflection_Builtins.pack_universe
+                                       FStar_Reflection_Data.Uv_Zero))])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
+let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
+  fun uu___ ->
+    FStar_Tactics_Effect.tac_bind
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
+         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
+         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
+      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
+      (fun uu___1 ->
+         (fun ty ->
+            Obj.magic
+              (FStar_Tactics_Effect.tac_bind
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (8))
+                    (Prims.of_int (624)) (Prims.of_int (28)))
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (2))
+                    (Prims.of_int (626)) (Prims.of_int (27)))
+                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
+                 (fun uu___1 ->
+                    (fun uu___1 ->
+                       match uu___1 with
+                       | FStar_Reflection_Formula.Comp
+                           (uu___2, uu___3, uu___4) ->
+                           Obj.magic (FStar_Tactics_Derived.trefl ())
+                       | uu___2 ->
+                           Obj.magic
+                             (FStar_Tactics_Effect.tac_bind
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (9))
+                                   (Prims.of_int (626)) (Prims.of_int (17)))
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (19))
+                                   (Prims.of_int (626)) (Prims.of_int (27)))
+                                (Obj.magic (FStar_Tactics_Derived.smt ()))
+                                (fun uu___3 ->
+                                   (fun uu___3 ->
+                                      Obj.magic
+                                        (FStar_Tactics_Derived.qed ()))
+                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -1758,27 +2096,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (567)) (Prims.of_int (2))
-                        (Prims.of_int (568)) (Prims.of_int (33)))
+                        (Prims.of_int (633)) (Prims.of_int (2))
+                        (Prims.of_int (634)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (569)) (Prims.of_int (2))
-                        (Prims.of_int (604)) (Prims.of_int (35)))
+                        (Prims.of_int (635)) (Prims.of_int (2))
+                        (Prims.of_int (670)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (5))
-                              (Prims.of_int (567)) (Prims.of_int (23)))
+                              (Prims.of_int (633)) (Prims.of_int (5))
+                              (Prims.of_int (633)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (2))
-                              (Prims.of_int (568)) (Prims.of_int (33)))
+                              (Prims.of_int (633)) (Prims.of_int (2))
+                              (Prims.of_int (634)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (9))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (9))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (5))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (5))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -1800,15 +2138,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (603))
+                                          (Prims.of_int (669))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -1822,15 +2160,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (572))
+                                                         (Prims.of_int (638))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (573))
+                                                         (Prims.of_int (639))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (574))
+                                                         (Prims.of_int (640))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (602))
+                                                         (Prims.of_int (668))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -1869,15 +2207,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -1895,15 +2233,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1917,15 +2255,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1949,29 +2287,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2022,15 +2360,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (586))
+                                                                    (Prims.of_int (652))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (593))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2066,15 +2404,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2084,15 +2422,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2120,15 +2458,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2155,15 +2493,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2173,15 +2511,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2205,15 +2543,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (56)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (49)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2223,16 +2561,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (48)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2242,32 +2580,8 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (45)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (47))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.trivial
-                                                                    ()))
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Derived.qed
+                                                                    (trefl_or_smt
                                                                     ()))
-                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2279,15 +2593,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2297,15 +2611,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2329,15 +2643,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2347,15 +2661,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2383,15 +2697,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2429,16 +2743,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2450,27 +2764,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (611)) (Prims.of_int (2))
-                        (Prims.of_int (612)) (Prims.of_int (33)))
+                        (Prims.of_int (677)) (Prims.of_int (2))
+                        (Prims.of_int (678)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (613)) (Prims.of_int (2))
-                        (Prims.of_int (644)) (Prims.of_int (35)))
+                        (Prims.of_int (679)) (Prims.of_int (2))
+                        (Prims.of_int (712)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (5))
-                              (Prims.of_int (611)) (Prims.of_int (23)))
+                              (Prims.of_int (677)) (Prims.of_int (5))
+                              (Prims.of_int (677)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (2))
-                              (Prims.of_int (612)) (Prims.of_int (33)))
+                              (Prims.of_int (677)) (Prims.of_int (2))
+                              (Prims.of_int (678)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (9))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (9))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (5))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (5))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2492,15 +2806,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (643))
+                                          (Prims.of_int (711))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2514,15 +2828,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (616))
+                                                         (Prims.of_int (682))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (617))
+                                                         (Prims.of_int (683))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (618))
+                                                         (Prims.of_int (684))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (642))
+                                                         (Prims.of_int (710))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2561,43 +2875,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2635,29 +2949,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2681,29 +2995,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2727,29 +3041,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2773,15 +3087,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (626))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -2808,15 +3122,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2834,15 +3148,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2856,15 +3170,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -2879,15 +3193,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2909,19 +3223,21 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (631))
-                                                                    (Prims.of_int (101)))
+                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    (FStar_Reflection_Derived.mk_app
+                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -2934,7 +3250,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)])))
+                                                                    FStar_Reflection_Data.Q_Explicit)]))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -2944,15 +3260,59 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (37)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Builtins.term_to_string
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun
+                                                                    a'_ts ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (15))
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (27)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun a'1
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -2979,15 +3339,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3014,15 +3374,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3037,19 +3397,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'))
+                                                                    a'1))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3060,15 +3420,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3083,15 +3443,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3106,15 +3466,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3129,15 +3489,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3152,15 +3512,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3192,6 +3552,8 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
+                                                                    uu___12)))
+                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From f5fd0d48005fa2ad08c2775f9d183d3c81153b58 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Mon, 10 Apr 2023 11:42:49 -0700
Subject: [PATCH 500/513] do not extract Low* (except C._zero_for_deref)

---
 examples/steel/arraystructs/Makefile | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/examples/steel/arraystructs/Makefile b/examples/steel/arraystructs/Makefile
index 2aeb0f40e0f..295945c2365 100644
--- a/examples/steel/arraystructs/Makefile
+++ b/examples/steel/arraystructs/Makefile
@@ -20,7 +20,7 @@ fstlib:
 FSTAR_OPTIONS := --cache_checked_modules \
 		--cmi \
 		--compat_pre_typed_indexed_effects \
-	        --already_cached 'Prims,FStar,LowStar,Steel' \
+	        --already_cached 'Prims,FStar,LowStar,Steel,C' \
 		$(addprefix --include ,$(INCLUDE_PATH)) \
 		$(OTHERFLAGS)
 
@@ -37,17 +37,16 @@ EXTRACT_SOURCE_FILES = $(filter-out $(addsuffix .fst,$(NO_EXTRACT_MODULES)),$(AL
 comma=,
 
 ifdef KRML_HOME # FIXME: should be HAS_OCAML
-# We need to add some Low* files to the dependency roots, because F* extracts Steel.C null to LowStar null
-# since the KaRaMeL AST does not have a node for null
-# TODO: This should be removed, and support for Steel.C null should be directly added to KaRaMeL instead
-SOME_LOWSTAR_FILES = $(FSTAR_HOME)/ulib/LowStar.Monotonic.Buffer.fst $(FSTAR_HOME)/ulib/LowStar.Buffer.fst $(KRML_HOME)/krmllib/C.fst
+# We need to add some Low* files to the dependency roots, because
+# of C._zero_for_deref
+SOME_LOWSTAR_FILES = $(KRML_HOME)/krmllib/C.fst
 MY_FSTAR=$(MY_FSTAR_PATH)/lib/steel_c/ExtractSteelC.cmxs
 $(MY_FSTAR):
 	+$(MAKE) -C $(MY_FSTAR_PATH)
 endif
 
 .depend: $(ALL_SOURCE_FILES) Makefile $(MY_FSTAR)
-	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:* -FStar $(addprefix -,$(NO_EXTRACT_MODULES))'  > $@.tmp
+	$(FSTAR) --dep full $(ALL_SOURCE_FILES) $(SOME_LOWSTAR_FILES) --extract 'krml:* -FStar -LowStar $(addprefix -,$(NO_EXTRACT_MODULES))'  > $@.tmp
 	mv $@.tmp $@
 
 depend: .depend

From 4e0aabe5202bbcc7e82362f3b589ec0d2de9771e Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 10:57:45 -0700
Subject: [PATCH 501/513] Karamel AST: add union and array types

from FStarLang/FStar#2349 by @john-ml (more precisely
unions: tahina-pro/FStar@341afa83111874cd035837cfca60649aa59f6b3b
arrays: tahina-pro/FStar@aa80cc9035cf8e247af6e614ffc4a6d2444c8b6f
)
---
 src/extraction/FStar.Extraction.Krml.fst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 65d4bedd2f4..bc8275f4da3 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -53,6 +53,7 @@ type decl =
   | DTypeVariant of lident * list flag * int * branches_t
   | DTypeAbstractStruct of lident
   | DExternal of option cc * list flag * lident * typ * list ident
+  | DUntaggedUnion of lident * list flag * int * list (ident * typ)
 
 and cc =
   | StdCall
@@ -190,6 +191,7 @@ and typ =
   | TApp of lident * list typ
   | TTuple of list typ
   | TConstBuf of typ
+  | TArray of typ * constant
 
 
 let current_version: version = 28

From a16763c560e078f3902384e0f67d66a250b04343 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 10:58:08 -0700
Subject: [PATCH 502/513] translate_type_without_decay; make C extraction
 modular

from FStarLang/FStar#2349 (more precisely:
translate_type_without_decay by @john-ml at tahina-pro/FStar@be7a64de497c6c4a857999081de78cfcf1d36329
modular C extraction at tahina-pro/FStar@b6873af4f42a1aa2cedddcdaab33120a859ee71f
file as of tahina-pro/FStar@79de29e02d1dec9dbd33cf3cba77de4860f6ee74
)
---
 src/extraction/FStar.Extraction.Krml.fst  | 175 ++++++++++++++++++----
 src/extraction/FStar.Extraction.Krml.fsti |   3 +
 2 files changed, 149 insertions(+), 29 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index bc8275f4da3..d6be5cdc5e5 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -376,7 +376,110 @@ let generate_is_null
 = let dummy = UInt64 in
   EApp (ETypApp (EOp (Eq, dummy), [TBuf t]), [x; EBufNull t])
 
-let rec translate_type env t: typ =
+exception NotSupportedByKrmlExtension
+
+let translate_type_without_decay_t = env -> mlty -> ML typ
+let ref_translate_type_without_decay : ref translate_type_without_decay_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_pre_translate_type_without_decay
+  (f: translate_type_without_decay_t)
+: ML unit
+= let before : translate_type_without_decay_t = !ref_translate_type_without_decay in
+  let after : translate_type_without_decay_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_type_without_decay := after
+let register_post_translate_type_without_decay
+  (f: translate_type_without_decay_t)
+: ML unit
+= let before : translate_type_without_decay_t = !ref_translate_type_without_decay in
+  let after : translate_type_without_decay_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_type_without_decay := after
+let translate_type_without_decay env t = !ref_translate_type_without_decay env t
+
+// The outermost array type constructor decays to pointer
+let translate_type_t = env -> mlty -> ML typ
+let ref_translate_type : ref translate_type_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_pre_translate_type
+  (f: translate_type_t)
+: ML unit
+= let before : translate_type_t = !ref_translate_type in
+  let after : translate_type_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_type := after
+let register_post_translate_type
+  (f: translate_type_t)
+: ML unit
+= let before : translate_type_t = !ref_translate_type in
+  let after : translate_type_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_type := after
+let translate_type env t = !ref_translate_type env t
+
+let translate_expr_t = env -> mlexpr -> ML expr
+let ref_translate_expr : ref translate_expr_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_pre_translate_expr
+  (f: translate_expr_t)
+: ML unit
+= let before : translate_expr_t = !ref_translate_expr in
+  let after : translate_expr_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_expr := after
+let register_post_translate_expr
+  (f: translate_expr_t)
+: ML unit
+= let before : translate_expr_t = !ref_translate_expr in
+  let after : translate_expr_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_expr := after
+let translate_expr (env: env) (e: mlexpr) = !ref_translate_expr env e
+
+let translate_type_decl_t = env -> one_mltydecl -> ML (option decl)
+let ref_translate_type_decl : ref translate_type_decl_t = mk_ref (fun _ _ -> raise NotSupportedByKrmlExtension)
+let register_pre_translate_type_decl
+  (f: translate_type_decl_t)
+: ML unit
+= let before : translate_type_decl_t = !ref_translate_type_decl in
+  let after : translate_type_decl_t = fun e t ->
+    try
+      f e t
+    with NotSupportedByKrmlExtension -> before e t
+  in
+  ref_translate_type_decl := after
+let register_post_translate_type_decl
+  (f: translate_type_decl_t)
+: ML unit
+= let before : translate_type_decl_t = !ref_translate_type_decl in
+  let after : translate_type_decl_t = fun e t ->
+    try
+      before e t
+    with NotSupportedByKrmlExtension -> f e t
+  in
+  ref_translate_type_decl := after
+let translate_type_decl env ty: option decl =
+  if List.mem Syntax.NoExtract ty.tydecl_meta then
+    None
+  else
+    !ref_translate_type_decl env ty
+
+let rec translate_type_without_decay' env t: typ =
   match t with
   | MLTY_Tuple []
   | MLTY_Top ->
@@ -384,7 +487,7 @@ let rec translate_type env t: typ =
   | MLTY_Var name ->
       TBound (find_t env name)
   | MLTY_Fun (t1, _, t2) ->
-      TArrow (translate_type env t1, translate_type env t2)
+      TArrow (translate_type_without_decay env t1, translate_type_without_decay env t2)
   | MLTY_Erased ->
       TUnit
   | MLTY_Named ([], p) when (Syntax.string_of_mlpath p = "Prims.unit") ->
@@ -397,15 +500,15 @@ let rec translate_type env t: typ =
       TInt (must (mk_width m))
   | MLTY_Named ([arg], p) when (Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mem") ->
       TUnit
-
+  
   | MLTY_Named ([_; arg; _], p) when
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.s_mref" ||
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperHeap.mrref"  ||
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.m_rref" ||
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_mref"
     ->
-      TBuf (translate_type env arg)
-
+      TBuf (translate_type_without_decay env arg)
+  
   | MLTY_Named ([arg; _], p) when
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mreference" ||
     Syntax.string_of_mlpath p = "FStar.Monotonic.HyperStack.mstackref" ||
@@ -419,14 +522,14 @@ let rec translate_type env t: typ =
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmstackref" ||
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmmref"
     ->
-      TBuf (translate_type env arg)
-
+      TBuf (translate_type_without_decay env arg)
+  
   | MLTY_Named ([arg; _; _], p) when
-    Syntax.string_of_mlpath p = "LowStar.Monotonic.Buffer.mbuffer" -> TBuf (translate_type env arg)
-
+    Syntax.string_of_mlpath p = "LowStar.Monotonic.Buffer.mbuffer" -> TBuf (translate_type_without_decay env arg)
+  
   | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "LowStar.ConstBuffer.const_buffer" ||
-    Syntax.string_of_mlpath p = "Steel.TLArray.t" -> TConstBuf (translate_type env arg)
+    Syntax.string_of_mlpath p = "Steel.TLArray.t" -> TConstBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "FStar.Buffer.buffer" ||
@@ -447,37 +550,43 @@ let rec translate_type env t: typ =
     Syntax.string_of_mlpath p = "Steel.ST.Reference.ref" ||
     Syntax.string_of_mlpath p = "Steel.ST.HigherArray.ptr"
     ->
-      TBuf (translate_type env arg)
-
+      TBuf (translate_type_without_decay env arg)
+  
   | MLTY_Named ([_;arg], p) when
     Syntax.string_of_mlpath p = "FStar.HyperStack.s_ref" ||
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.s_ref"
     ->
-      TBuf (translate_type env arg)
-
+      TBuf (translate_type_without_decay env arg)
+  
   | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "FStar.Universe.raise_t"
     ->
-      translate_type env arg
+      translate_type_without_decay env arg
 
   | MLTY_Named ([_], p) when (Syntax.string_of_mlpath p = "FStar.Ghost.erased") ->
       TAny
-
+  
   | MLTY_Named ([], (path, type_name)) ->
       // Generate an unbound reference... to be filled in later by glue code.
       TQualified (path, type_name)
-
+  
   | MLTY_Named (args, (ns, t)) when (ns = ["Prims"] || ns = ["FStar"; "Pervasives"; "Native"]) && BU.starts_with t "tuple" ->
-      TTuple (List.map (translate_type env) args)
-
+      TTuple (List.map (translate_type_without_decay env) args)
+  
   | MLTY_Named (args, lid) ->
       if List.length args > 0 then
-        TApp (lid, List.map (translate_type env) args)
+        TApp (lid, List.map (translate_type_without_decay env) args)
       else
         TQualified lid
-
+  
   | MLTY_Tuple ts ->
-      TTuple (List.map (translate_type env) ts)
+      TTuple (List.map (translate_type_without_decay env) ts)
+  
+and translate_type' env t: typ =
+  // The outermost array type constructor decays to pointer
+  match t with
+      
+  | t -> translate_type_without_decay env t
 
 and translate_binders env args =
   List.map (translate_binder env) args
@@ -485,7 +594,7 @@ and translate_binders env args =
 and translate_binder env (name, typ) =
   { name = name; typ = translate_type env typ; mut = false }
 
-and translate_expr env e: expr =
+and translate_expr' env e: expr =
   match e.expr with
   | MLE_Tuple [] ->
       EUnit
@@ -890,6 +999,11 @@ and translate_expr env e: expr =
         ECast (translate_expr env arg, TInt Int8)
       else
         EApp (EQualified ([ "FStar"; "Int"; "Cast" ], c), [ translate_expr env arg ])
+        
+  (* Misc. Steel operations *)
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
+    when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
+    translate_expr env e
 
   | MLE_App ({ expr = MLE_Name p }, [ arg ])
     when string_of_mlpath p = "FStar.SizeT.uint16_to_sizet" ||
@@ -1082,10 +1196,7 @@ and translate_constant c: expr =
 and mk_op_app env w op args =
   EApp (EOp (op, w), List.map (translate_expr env) args)
 
-let translate_type_decl env ty: option decl =
-  if List.mem Syntax.NoExtract ty.tydecl_meta then
-    None
-  else
+let translate_type_decl' env ty: option decl =
     match ty with
     | {tydecl_assumed=assumed;
        tydecl_name=name;
@@ -1111,7 +1222,7 @@ let translate_type_decl env ty: option decl =
         let name = env.module_name, name in
         let env = List.fold_left (fun env name -> extend_t env name) env args in
         Some (DTypeFlat (name, translate_flags flags, List.length args, List.map (fun (f, t) ->
-          f, (translate_type env t, false)) fields))
+          f, (translate_type_without_decay env t, false)) fields))
 
     | {tydecl_name=name;
        tydecl_parameters=args;
@@ -1122,7 +1233,7 @@ let translate_type_decl env ty: option decl =
         let env = List.fold_left extend_t env args in
         Some (DTypeVariant (name, flags, List.length args, List.map (fun (cons, ts) ->
           cons, List.map (fun (name, t) ->
-            name, (translate_type env t, false)
+            name, (translate_type_without_decay env t, false)
           ) ts
         ) branches))
     | {tydecl_name=name} ->
@@ -1304,3 +1415,9 @@ let translate (MLLib modules): list file =
           m_name (BU.print_exn e);
         None
   ) modules
+
+let init () =
+  register_post_translate_type_without_decay translate_type_without_decay';
+  register_post_translate_type translate_type';
+  register_post_translate_type_decl translate_type_decl';
+  register_post_translate_expr translate_expr'
diff --git a/src/extraction/FStar.Extraction.Krml.fsti b/src/extraction/FStar.Extraction.Krml.fsti
index 0241772fcd4..7b22d5b7d4d 100644
--- a/src/extraction/FStar.Extraction.Krml.fsti
+++ b/src/extraction/FStar.Extraction.Krml.fsti
@@ -26,3 +26,6 @@ type binary_format = version * list file
 
 val current_version: version
 val translate : FStar.Extraction.ML.Syntax.mllib -> list file
+
+(* Called by FStar.Main.main () to initialize code translators *)
+val init : unit -> FStar.Compiler.Effect.ML unit

From 7ef4eabc6801a1ff9232fabf6ab33951fc2b68d0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 11:01:55 -0700
Subject: [PATCH 503/513] use `let _ =`

---
 src/extraction/FStar.Extraction.Krml.fst  | 2 +-
 src/extraction/FStar.Extraction.Krml.fsti | 3 ---
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index d6be5cdc5e5..ccf706f1fb9 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -1416,7 +1416,7 @@ let translate (MLLib modules): list file =
         None
   ) modules
 
-let init () =
+let _ =
   register_post_translate_type_without_decay translate_type_without_decay';
   register_post_translate_type translate_type';
   register_post_translate_type_decl translate_type_decl';
diff --git a/src/extraction/FStar.Extraction.Krml.fsti b/src/extraction/FStar.Extraction.Krml.fsti
index 7b22d5b7d4d..0241772fcd4 100644
--- a/src/extraction/FStar.Extraction.Krml.fsti
+++ b/src/extraction/FStar.Extraction.Krml.fsti
@@ -26,6 +26,3 @@ type binary_format = version * list file
 
 val current_version: version
 val translate : FStar.Extraction.ML.Syntax.mllib -> list file
-
-(* Called by FStar.Main.main () to initialize code translators *)
-val init : unit -> FStar.Compiler.Effect.ML unit

From 38cef8c27da21f1006309b7cc481fbbc1c9591a0 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 11:19:40 -0700
Subject: [PATCH 504/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 432 ++++++++++++------
 1 file changed, 301 insertions(+), 131 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..113de7287c7 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,16 +1142,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1163,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1198,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2669,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,128 +3098,122 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3388,4 +3553,9 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (uu___1975 : unit) =
+  register_post_translate_type_without_decay translate_type_without_decay';
+  register_post_translate_type translate_type';
+  register_post_translate_type_decl translate_type_decl';
+  register_post_translate_expr translate_expr'
\ No newline at end of file

From 849368d85ff11c95902aaf8096057a025dc7ae55 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 13:17:45 -0700
Subject: [PATCH 505/513] Revert "snap"

This reverts commit 5c2ed8d3b67d2c0e279404026abd761f99ba67ff.
---
 .../generated/FStar_Extraction_Krml.ml        |  433 ++---
 ocaml/fstar-lib/generated/FStar_Main.ml       |    3 +-
 .../generated/Steel_ST_GenElim_Base.ml        | 1556 +++++++----------
 3 files changed, 729 insertions(+), 1263 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index dd7c2505755..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,18 +996,16 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" ->
-          translate_type_without_decay env1 arg
+          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1163,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1198,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2669,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3098,122 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type_without_decay env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 =
-                                        translate_type_without_decay env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3553,10 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (init : unit -> unit) =
-  fun uu___ ->
-    register_post_translate_type_without_decay translate_type_without_decay';
-    register_post_translate_type translate_type';
-    register_post_translate_type_decl translate_type_decl';
-    register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Main.ml b/ocaml/fstar-lib/generated/FStar_Main.ml
index 588e5b12300..9881890396c 100644
--- a/ocaml/fstar-lib/generated/FStar_Main.ml
+++ b/ocaml/fstar-lib/generated/FStar_Main.ml
@@ -297,8 +297,7 @@ let (setup_hooks : unit -> unit) =
       (FStar_Pervasives_Native.Some FStar_Syntax_Print.term_to_string);
     FStar_Compiler_Effect.op_Colon_Equals
       FStar_TypeChecker_Normalize.unembed_binder_knot
-      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder);
-    FStar_Extraction_Krml.init ()
+      (FStar_Pervasives_Native.Some FStar_Reflection_Embeddings.e_binder)
 let (handle_error : Prims.exn -> unit) =
   fun e ->
     (let uu___1 = FStar_Errors.handleable e in
diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index b23bdfc10ec..2ca503ea1dc 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
-           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
+           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (5))
-                          (Prims.of_int (342)) (Prims.of_int (28)))
+                          (Prims.of_int (310)) (Prims.of_int (5))
+                          (Prims.of_int (310)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (342)) (Prims.of_int (2))
-                          (Prims.of_int (352)) (Prims.of_int (12)))
+                          (Prims.of_int (310)) (Prims.of_int (2))
+                          (Prims.of_int (320)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (344))
+                                          (Prims.of_int (312))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (352))
+                                          (Prims.of_int (320))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (348))
+                                                                 (Prims.of_int (316))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (350))
+                                                                 (Prims.of_int (318))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
-               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
+               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (23))
-                         (Prims.of_int (361)) (Prims.of_int (40)))
+                         (Prims.of_int (329)) (Prims.of_int (23))
+                         (Prims.of_int (329)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (361)) (Prims.of_int (8))
-                         (Prims.of_int (372)) (Prims.of_int (47)))
+                         (Prims.of_int (329)) (Prims.of_int (8))
+                         (Prims.of_int (340)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (364))
+                                             (Prims.of_int (332))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (372))
+                                             (Prims.of_int (340))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (367))
+                                                                    (Prims.of_int (335))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (367))
+                                                                    (Prims.of_int (335))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (368))
+                                                                    (Prims.of_int (336))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (337))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
-         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
+         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,53 +347,22 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
-let rec (get_universe :
-  FStar_Reflection_Types.universe ->
-    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
-  =
-  fun uu___ ->
-    (fun u ->
-       match FStar_Reflection_Builtins.inspect_universe u with
-       | FStar_Reflection_Data.Uv_Zero ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.lift_div_tac
-                   (fun uu___ -> Prims.int_zero)))
-       | FStar_Reflection_Data.Uv_Succ u1 ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Effect.tac_bind
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (23))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (386)) (Prims.of_int (19))
-                      (Prims.of_int (386)) (Prims.of_int (37)))
-                   (Obj.magic (get_universe u1))
-                   (fun uu___ ->
-                      FStar_Tactics_Effect.lift_div_tac
-                        (fun uu___1 -> Prims.int_one + uu___))))
-       | uu___ ->
-           Obj.magic
-             (Obj.repr
-                (FStar_Tactics_Derived.fail
-                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
-               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
+               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -410,11 +379,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (395)) (Prims.of_int (17))
-                      (Prims.of_int (395)) (Prims.of_int (40)))
+                      (Prims.of_int (355)) (Prims.of_int (17))
+                      (Prims.of_int (355)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (396)) (Prims.of_int (8))
-                      (Prims.of_int (396)) (Prims.of_int (45)))
+                      (Prims.of_int (356)) (Prims.of_int (8))
+                      (Prims.of_int (356)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -433,11 +402,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (26))
-                      (Prims.of_int (398)) (Prims.of_int (43)))
+                      (Prims.of_int (358)) (Prims.of_int (26))
+                      (Prims.of_int (358)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (398)) (Prims.of_int (8))
-                      (Prims.of_int (458)) (Prims.of_int (68)))
+                      (Prims.of_int (358)) (Prims.of_int (8))
+                      (Prims.of_int (399)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -450,122 +419,88 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (401))
-                                       (Prims.of_int (25))
-                                       (Prims.of_int (403))
-                                       (Prims.of_int (63)))
+                                       (Prims.of_int (362))
+                                       (Prims.of_int (12))
+                                       (Prims.of_int (365))
+                                       (Prims.of_int (46)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (405))
+                                       (Prims.of_int (361))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (437))
+                                       (Prims.of_int (378))
                                        (Prims.of_int (13)))
-                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
-                                             hd
-                                     with
-                                     | FStar_Reflection_Data.Tv_UInst
-                                         (uu___3, u::uu___4) ->
-                                         Obj.magic
-                                           (Obj.repr (get_universe u))
+                                    (match lbody with
+                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
+                                         (body,
+                                          FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         FStar_Tactics_Effect.lift_div_tac
+                                           (fun uu___3 ->
+                                              ([(ty,
+                                                  FStar_Reflection_Data.Q_Implicit)],
+                                                body))
+                                     | (body,
+                                        FStar_Reflection_Data.Q_Explicit)::[]
+                                         ->
+                                         FStar_Tactics_Effect.lift_div_tac
+                                           (fun uu___3 -> ([], body))
                                      | uu___3 ->
-                                         Obj.magic
-                                           (Obj.repr
-                                              (FStar_Tactics_Derived.fail
-                                                 "ill-formed exists_: no universe found")))
+                                         FStar_Tactics_Derived.fail
+                                           "ill-formed exists_")
                                     (fun uu___3 ->
-                                       (fun universe ->
-                                          Obj.magic
-                                            (FStar_Tactics_Effect.tac_bind
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (406))
-                                                  (Prims.of_int (12))
-                                                  (Prims.of_int (409))
-                                                  (Prims.of_int (46)))
-                                               (Prims.mk_range
-                                                  "Steel.ST.GenElim.Base.fsti"
-                                                  (Prims.of_int (405))
-                                                  (Prims.of_int (10))
-                                                  (Prims.of_int (437))
-                                                  (Prims.of_int (13)))
-                                               (match lbody with
-                                                | (ty,
-                                                   FStar_Reflection_Data.Q_Implicit)::
-                                                    (body,
-                                                     FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    FStar_Tactics_Effect.lift_div_tac
-                                                      (fun uu___3 ->
-                                                         ([(ty,
-                                                             FStar_Reflection_Data.Q_Implicit)],
-                                                           body))
-                                                | (body,
-                                                   FStar_Reflection_Data.Q_Explicit)::[]
-                                                    ->
-                                                    FStar_Tactics_Effect.lift_div_tac
-                                                      (fun uu___3 ->
-                                                         ([], body))
-                                                | uu___3 ->
-                                                    FStar_Tactics_Derived.fail
-                                                      "ill-formed exists_")
-                                               (fun uu___3 ->
-                                                  (fun uu___3 ->
-                                                     match uu___3 with
-                                                     | (ty, body) ->
-                                                         Obj.magic
-                                                           (FStar_Tactics_Effect.tac_bind
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (22))
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (36)))
-                                                              (Prims.mk_range
-                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (411))
-                                                                 (Prims.of_int (16))
-                                                                 (Prims.of_int (436))
-                                                                 (Prims.of_int (21)))
-                                                              (Obj.magic
-                                                                 (FStar_Tactics_Builtins.inspect
-                                                                    body))
-                                                              (fun uu___4 ->
-                                                                 (fun uu___4
-                                                                    ->
-                                                                    match uu___4
-                                                                    with
-                                                                    | 
-                                                                    FStar_Reflection_Data.Tv_Abs
-                                                                    (b,
-                                                                    abody) ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.tac_bind
+                                       (fun uu___3 ->
+                                          match uu___3 with
+                                          | (ty, body) ->
+                                              Obj.magic
+                                                (FStar_Tactics_Effect.tac_bind
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (22))
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (36)))
+                                                   (Prims.mk_range
+                                                      "Steel.ST.GenElim.Base.fsti"
+                                                      (Prims.of_int (367))
+                                                      (Prims.of_int (16))
+                                                      (Prims.of_int (377))
+                                                      (Prims.of_int (45)))
+                                                   (Obj.magic
+                                                      (FStar_Tactics_Builtins.inspect
+                                                         body))
+                                                   (fun uu___4 ->
+                                                      (fun uu___4 ->
+                                                         match uu___4 with
+                                                         | FStar_Reflection_Data.Tv_Abs
+                                                             (b, abody) ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (413))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -594,16 +529,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (415))
+                                                                    (Prims.of_int (371))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -615,58 +550,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (416))
+                                                                    (Prims.of_int (372))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (98)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (63))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (97)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (421))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (64))
+                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (96)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -696,32 +631,14 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___8
-                                                                    when
-                                                                    uu___8 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsUnit0"]))
-                                                                    | 
-                                                                    uu___8 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit1"])))
+                                                                    "GEExistsUnit"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -729,16 +646,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (423))
+                                                                    (Prims.of_int (374))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -750,58 +667,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (424))
+                                                                    (Prims.of_int (375))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (37))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (94)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (40))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (74)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (59))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (93)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (59)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (78)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (429))
-                                                                    (Prims.of_int (73)))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (60))
+                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (92)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -831,86 +748,48 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___9
-                                                                    when
-                                                                    uu___9 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExists0"]))
-                                                                    | 
-                                                                    uu___9 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists1"])))
+                                                                    "GEExists"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                                    | 
-                                                                    uu___5 ->
-                                                                    Obj.magic
-                                                                    (Obj.repr
-                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                         | uu___5 ->
+                                                             Obj.magic
+                                                               (Obj.repr
+                                                                  (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (match universe
-                                                                    with
-                                                                    | 
-                                                                    uu___7
-                                                                    when
-                                                                    uu___7 =
-                                                                    Prims.int_zero
-                                                                    ->
-                                                                    FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Steel";
-                                                                    "ST";
-                                                                    "GenElim";
-                                                                    "Base";
-                                                                    "GEExistsNoAbs0"]))
-                                                                    | 
-                                                                    uu___7 ->
-                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs1"])))
+                                                                    "GEExistsNoAbs"])))
                                                                     lbody))))
-                                                                   uu___4)))
-                                                    uu___3))) uu___3))
+                                                        uu___4))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (438))
+                                       (Prims.of_int (379))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (458))
+                                       (Prims.of_int (399))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -929,15 +808,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (442))
+                                                              (Prims.of_int (383))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (455))
+                                                              (Prims.of_int (396))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -958,15 +837,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (444))
+                                                                    (Prims.of_int (385))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -979,15 +858,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (445))
+                                                                    (Prims.of_int (386))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -1009,15 +888,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (447))
+                                                                    (Prims.of_int (388))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (448))
+                                                                    (Prims.of_int (389))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1046,15 +925,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (450))
+                                                                    (Prims.of_int (391))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (451))
+                                                                    (Prims.of_int (392))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1085,15 +964,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (453))
+                                                                    (Prims.of_int (394))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -1106,15 +985,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (454))
+                                                                    (Prims.of_int (395))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (455))
+                                                                    (Prims.of_int (396))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1198,11 +1077,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (19))
-                            (Prims.of_int (547)) (Prims.of_int (34)))
+                            (Prims.of_int (488)) (Prims.of_int (19))
+                            (Prims.of_int (488)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (547)) (Prims.of_int (4))
-                            (Prims.of_int (592)) (Prims.of_int (13)))
+                            (Prims.of_int (488)) (Prims.of_int (4))
+                            (Prims.of_int (532)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1222,15 +1101,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (552))
+                                                     (Prims.of_int (493))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (554))
-                                                     (Prims.of_int (88)))
+                                                     (Prims.of_int (495))
+                                                     (Prims.of_int (85)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (556))
+                                                     (Prims.of_int (497))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (582))
+                                                     (Prims.of_int (522))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1240,16 +1119,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (552))
+                                                                   (Prims.of_int (493))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (554))
-                                                                   (Prims.of_int (88)))
+                                                                   (Prims.of_int (495))
+                                                                   (Prims.of_int (85)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1268,16 +1147,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (553))
+                                                                    (Prims.of_int (494))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (495))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (554))
-                                                                    (Prims.of_int (88)))
+                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (85)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1295,9 +1174,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1310,15 +1187,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (497))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (556))
-                                                                (Prims.of_int (84)))
+                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (79)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (557))
+                                                                (Prims.of_int (498))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (582))
+                                                                (Prims.of_int (522))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1343,9 +1220,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1356,15 +1231,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (557))
+                                                                    (Prims.of_int (498))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (558))
+                                                                    (Prims.of_int (499))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1381,15 +1256,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (560))
+                                                                    (Prims.of_int (501))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (564))
+                                                                    (Prims.of_int (505))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (566))
+                                                                    (Prims.of_int (507))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1402,16 +1277,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (561))
+                                                                    (Prims.of_int (502))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1423,16 +1298,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (562))
+                                                                    (Prims.of_int (503))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (504))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (563))
-                                                                    (Prims.of_int (47)))
+                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (42)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1454,9 +1329,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))),
+                                                                    FStar_Reflection_Data.Uv_Zero))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1491,69 +1364,23 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (39))
-                                                                    (Prims.of_int (569))
-                                                                    (Prims.of_int (81)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
-                                                                    (Prims.of_int (9)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.fresh_binder
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))))
-                                                                    (fun
-                                                                    uu___3 ->
-                                                                    (fun
-                                                                    dummy_raised_unit_binder
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (510))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (570))
-                                                                    (Prims.of_int (120)))
+                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.append
-                                                                    (FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders))
-                                                                    [dummy_raised_unit_binder]))
+                                                                    rev_types_and_binders)))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1563,15 +1390,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (571))
+                                                                    (Prims.of_int (511))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1591,15 +1418,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (572))
+                                                                    (Prims.of_int (512))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1612,97 +1439,37 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (513))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (573))
-                                                                    (Prims.of_int (151)))
+                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (113)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    {
-                                                                    FStar_Reflection_Data.binder_bv
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    =
-                                                                    (FStar_Sealed.seal
-                                                                    "_");
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (964));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    });
-                                                                    FStar_Reflection_Data.binder_qual
-                                                                    =
-                                                                    FStar_Reflection_Data.Q_Explicit;
-                                                                    FStar_Reflection_Data.binder_attrs
-                                                                    = []
-                                                                    }),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"])))))))),
+                                                                    "vprop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1712,15 +1479,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (574))
+                                                                    (Prims.of_int (514))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1733,95 +1500,35 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (515))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (575))
-                                                                    (Prims.of_int (150)))
+                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (112)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (516))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (522))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero));
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))])))
+                                                                    "curried_function_type"])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_Arrow
-                                                                    ((FStar_Reflection_Builtins.pack_binder
-                                                                    {
-                                                                    FStar_Reflection_Data.binder_bv
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_bv
-                                                                    {
-                                                                    FStar_Reflection_Data.bv_ppname
-                                                                    =
-                                                                    (FStar_Sealed.seal
-                                                                    "_");
-                                                                    FStar_Reflection_Data.bv_index
-                                                                    =
-                                                                    (Prims.of_int (967));
-                                                                    FStar_Reflection_Data.bv_sort
-                                                                    =
-                                                                    (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_App
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_UInst
-                                                                    ((FStar_Reflection_Builtins.pack_fv
-                                                                    ["FStar";
-                                                                    "Universe";
-                                                                    "raise_t"]),
-                                                                    [
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Unk;
-                                                                    FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    (FStar_Reflection_Data.Uv_Succ
-                                                                    (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
-                                                                    ((FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
-                                                                    ["Prims";
-                                                                    "unit"]))),
-                                                                    FStar_Reflection_Data.Q_Explicit))))
-                                                                    });
-                                                                    FStar_Reflection_Data.binder_qual
-                                                                    =
-                                                                    FStar_Reflection_Data.Q_Explicit;
-                                                                    FStar_Reflection_Data.binder_attrs
-                                                                    = []
-                                                                    }),
-                                                                    (FStar_Reflection_Builtins.pack_comp
-                                                                    (FStar_Reflection_Data.C_Total
-                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"])))))))),
+                                                                    "prop"]))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1836,7 +1543,6 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
-                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1863,15 +1569,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (587))
+                                                         (Prims.of_int (527))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (589))
+                                                         (Prims.of_int (529))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1932,11 +1638,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (599)) (Prims.of_int (17))
-                                 (Prims.of_int (599)) (Prims.of_int (64)))
+                                 (Prims.of_int (539)) (Prims.of_int (17))
+                                 (Prims.of_int (539)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (600)) (Prims.of_int (6))
-                                 (Prims.of_int (601)) (Prims.of_int (37)))
+                                 (Prims.of_int (540)) (Prims.of_int (6))
+                                 (Prims.of_int (541)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1955,15 +1661,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (600))
+                                            (Prims.of_int (540))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (601))
+                                            (Prims.of_int (541))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1997,10 +1703,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
-           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
+           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -2015,76 +1721,32 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_UInst
-                            ((FStar_Reflection_Builtins.pack_fv
-                                ["Steel";
-                                "ST";
-                                "GenElim";
-                                "Base";
-                                "mk_gen_elim_nondep_by_tac"]),
-                              [FStar_Reflection_Builtins.pack_universe
-                                 (FStar_Reflection_Data.Uv_Succ
-                                    (FStar_Reflection_Builtins.pack_universe
-                                       FStar_Reflection_Data.Uv_Zero))])))
+                         (FStar_Reflection_Data.Tv_FVar
+                            (FStar_Reflection_Builtins.pack_fv
+                               ["Steel";
+                               "ST";
+                               "GenElim";
+                               "Base";
+                               "mk_gen_elim_nondep_by_tac"])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
-let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
-  fun uu___ ->
-    FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
-         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
-         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
-      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
-      (fun uu___1 ->
-         (fun ty ->
-            Obj.magic
-              (FStar_Tactics_Effect.tac_bind
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (8))
-                    (Prims.of_int (624)) (Prims.of_int (28)))
-                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                    (Prims.of_int (624)) (Prims.of_int (2))
-                    (Prims.of_int (626)) (Prims.of_int (27)))
-                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
-                 (fun uu___1 ->
-                    (fun uu___1 ->
-                       match uu___1 with
-                       | FStar_Reflection_Formula.Comp
-                           (uu___2, uu___3, uu___4) ->
-                           Obj.magic (FStar_Tactics_Derived.trefl ())
-                       | uu___2 ->
-                           Obj.magic
-                             (FStar_Tactics_Effect.tac_bind
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (9))
-                                   (Prims.of_int (626)) (Prims.of_int (17)))
-                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                   (Prims.of_int (626)) (Prims.of_int (19))
-                                   (Prims.of_int (626)) (Prims.of_int (27)))
-                                (Obj.magic (FStar_Tactics_Derived.smt ()))
-                                (fun uu___3 ->
-                                   (fun uu___3 ->
-                                      Obj.magic
-                                        (FStar_Tactics_Derived.qed ()))
-                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
-               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
+               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2096,27 +1758,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (633)) (Prims.of_int (2))
-                        (Prims.of_int (634)) (Prims.of_int (33)))
+                        (Prims.of_int (567)) (Prims.of_int (2))
+                        (Prims.of_int (568)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (635)) (Prims.of_int (2))
-                        (Prims.of_int (670)) (Prims.of_int (35)))
+                        (Prims.of_int (569)) (Prims.of_int (2))
+                        (Prims.of_int (604)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (5))
-                              (Prims.of_int (633)) (Prims.of_int (23)))
+                              (Prims.of_int (567)) (Prims.of_int (5))
+                              (Prims.of_int (567)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (633)) (Prims.of_int (2))
-                              (Prims.of_int (634)) (Prims.of_int (33)))
+                              (Prims.of_int (567)) (Prims.of_int (2))
+                              (Prims.of_int (568)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (9))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (9))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (633)) (Prims.of_int (5))
-                                    (Prims.of_int (633)) (Prims.of_int (23)))
+                                    (Prims.of_int (567)) (Prims.of_int (5))
+                                    (Prims.of_int (567)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2138,15 +1800,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (637))
+                                          (Prims.of_int (571))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (669))
+                                          (Prims.of_int (603))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2160,15 +1822,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (638))
+                                                         (Prims.of_int (572))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (639))
+                                                         (Prims.of_int (573))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (640))
+                                                         (Prims.of_int (574))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (668))
+                                                         (Prims.of_int (602))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -2207,15 +1869,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (642))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2233,15 +1895,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (643))
+                                                                    (Prims.of_int (577))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2255,15 +1917,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (644))
+                                                                    (Prims.of_int (578))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2287,29 +1949,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (645))
+                                                                    (Prims.of_int (579))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2360,15 +2022,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (652))
+                                                                    (Prims.of_int (586))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (659))
+                                                                    (Prims.of_int (593))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2404,15 +2066,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2422,15 +2084,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (660))
+                                                                    (Prims.of_int (594))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2458,15 +2120,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (661))
+                                                                    (Prims.of_int (595))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2493,15 +2155,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2511,15 +2173,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (663))
+                                                                    (Prims.of_int (597))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2543,15 +2205,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (49)))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (56)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2561,16 +2223,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (598))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (664))
-                                                                    (Prims.of_int (48)))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (55)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2580,8 +2242,32 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (trefl_or_smt
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (33))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (45)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (47))
+                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (55)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.trivial
+                                                                    ()))
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    (fun
+                                                                    uu___14
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Derived.qed
                                                                     ()))
+                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2593,15 +2279,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2611,15 +2297,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (665))
+                                                                    (Prims.of_int (599))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2643,15 +2329,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2661,15 +2347,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (666))
+                                                                    (Prims.of_int (600))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2697,15 +2383,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (667))
+                                                                    (Prims.of_int (601))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2743,16 +2429,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
-               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
+               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2764,27 +2450,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (677)) (Prims.of_int (2))
-                        (Prims.of_int (678)) (Prims.of_int (33)))
+                        (Prims.of_int (611)) (Prims.of_int (2))
+                        (Prims.of_int (612)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (679)) (Prims.of_int (2))
-                        (Prims.of_int (712)) (Prims.of_int (35)))
+                        (Prims.of_int (613)) (Prims.of_int (2))
+                        (Prims.of_int (644)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (5))
-                              (Prims.of_int (677)) (Prims.of_int (23)))
+                              (Prims.of_int (611)) (Prims.of_int (5))
+                              (Prims.of_int (611)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (677)) (Prims.of_int (2))
-                              (Prims.of_int (678)) (Prims.of_int (33)))
+                              (Prims.of_int (611)) (Prims.of_int (2))
+                              (Prims.of_int (612)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (9))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (9))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (677)) (Prims.of_int (5))
-                                    (Prims.of_int (677)) (Prims.of_int (23)))
+                                    (Prims.of_int (611)) (Prims.of_int (5))
+                                    (Prims.of_int (611)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2806,15 +2492,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (681))
+                                          (Prims.of_int (615))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (711))
+                                          (Prims.of_int (643))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2828,15 +2514,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (682))
+                                                         (Prims.of_int (616))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (683))
+                                                         (Prims.of_int (617))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (684))
+                                                         (Prims.of_int (618))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (710))
+                                                         (Prims.of_int (642))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2875,43 +2561,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (687))
+                                                                    (Prims.of_int (621))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (686))
+                                                                    (Prims.of_int (620))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2949,29 +2635,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (688))
+                                                                    (Prims.of_int (622))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2995,29 +2681,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (689))
+                                                                    (Prims.of_int (623))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3041,29 +2727,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (690))
+                                                                    (Prims.of_int (624))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -3087,15 +2773,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (691))
+                                                                    (Prims.of_int (625))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (692))
+                                                                    (Prims.of_int (626))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -3122,15 +2808,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (693))
+                                                                    (Prims.of_int (627))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -3148,15 +2834,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (694))
+                                                                    (Prims.of_int (628))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -3170,15 +2856,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (695))
+                                                                    (Prims.of_int (629))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -3193,15 +2879,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (696))
+                                                                    (Prims.of_int (630))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -3223,21 +2909,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (631))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (697))
-                                                                    (Prims.of_int (89)))
+                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
-                                                                    (FStar_Tactics_Effect.lift_div_tac
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    FStar_Reflection_Derived.mk_app
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -3250,7 +2934,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)]))
+                                                                    FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -3260,59 +2944,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (698))
-                                                                    (Prims.of_int (18))
-                                                                    (Prims.of_int (698))
-                                                                    (Prims.of_int (37)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Builtins.term_to_string
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun
-                                                                    a'_ts ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (15))
-                                                                    (Prims.of_int (699))
-                                                                    (Prims.of_int (27)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
-                                                                    (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
-                                                                    (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    a'))
-                                                                    (fun
-                                                                    uu___12
-                                                                    ->
-                                                                    (fun a'1
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (632))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3339,15 +2979,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (701))
+                                                                    (Prims.of_int (633))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3374,15 +3014,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (702))
+                                                                    (Prims.of_int (634))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3397,19 +3037,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (703))
+                                                                    (Prims.of_int (635))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'1))
+                                                                    a'))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3420,15 +3060,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (704))
+                                                                    (Prims.of_int (636))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3443,15 +3083,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (705))
+                                                                    (Prims.of_int (637))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3466,15 +3106,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (706))
+                                                                    (Prims.of_int (638))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3489,15 +3129,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (707))
+                                                                    (Prims.of_int (639))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3512,15 +3152,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (708))
+                                                                    (Prims.of_int (640))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (641))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3552,8 +3192,6 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
-                                                                    uu___12)))
-                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From f426c837e78db01f02ceab3403193aa8620278e8 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 13:18:38 -0700
Subject: [PATCH 506/513] FStar.Extraction.Krml.init () no longer exists

---
 src/extraction/FStar.Extraction.Krml.fsti | 3 ---
 src/fstar/FStar.Main.fst                  | 1 -
 2 files changed, 4 deletions(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fsti b/src/extraction/FStar.Extraction.Krml.fsti
index 7b22d5b7d4d..0241772fcd4 100644
--- a/src/extraction/FStar.Extraction.Krml.fsti
+++ b/src/extraction/FStar.Extraction.Krml.fsti
@@ -26,6 +26,3 @@ type binary_format = version * list file
 
 val current_version: version
 val translate : FStar.Extraction.ML.Syntax.mllib -> list file
-
-(* Called by FStar.Main.main () to initialize code translators *)
-val init : unit -> FStar.Compiler.Effect.ML unit
diff --git a/src/fstar/FStar.Main.fst b/src/fstar/FStar.Main.fst
index 0b765f4f2c7..cf838592c64 100644
--- a/src/fstar/FStar.Main.fst
+++ b/src/fstar/FStar.Main.fst
@@ -222,7 +222,6 @@ let setup_hooks () =
     FStar.Syntax.Syntax.lazy_chooser := Some lazy_chooser;
     FStar.Syntax.Util.tts_f := Some FStar.Syntax.Print.term_to_string;
     FStar.TypeChecker.Normalize.unembed_binder_knot := Some FStar.Reflection.Embeddings.e_binder;
-    FStar.Extraction.Krml.init ();
     ()
 
 let handle_error e =

From d79793fb0b639667713e6f0e70f010a375c350fc Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 13:30:28 -0700
Subject: [PATCH 507/513] snap

---
 .../generated/Steel_ST_GenElim_Base.ml        | 1556 ++++++++++-------
 1 file changed, 959 insertions(+), 597 deletions(-)

diff --git a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
index 2ca503ea1dc..b23bdfc10ec 100644
--- a/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
+++ b/ocaml/fstar-lib/generated/Steel_ST_GenElim_Base.ml
@@ -34,10 +34,10 @@ let rec (term_has_head :
   fun t ->
     fun head ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (17)) (Prims.of_int (309)) (Prims.of_int (32)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (309))
-           (Prims.of_int (2)) (Prims.of_int (320)) (Prims.of_int (12)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (17)) (Prims.of_int (341)) (Prims.of_int (32)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (341))
+           (Prims.of_int (2)) (Prims.of_int (352)) (Prims.of_int (12)))
         (FStar_Tactics_Effect.lift_div_tac
            (fun uu___ -> FStar_Reflection_Derived.collect_app t))
         (fun uu___ ->
@@ -47,11 +47,11 @@ let rec (term_has_head :
                   Obj.magic
                     (FStar_Tactics_Effect.tac_bind
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (5))
-                          (Prims.of_int (310)) (Prims.of_int (28)))
+                          (Prims.of_int (342)) (Prims.of_int (5))
+                          (Prims.of_int (342)) (Prims.of_int (28)))
                        (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                          (Prims.of_int (310)) (Prims.of_int (2))
-                          (Prims.of_int (320)) (Prims.of_int (12)))
+                          (Prims.of_int (342)) (Prims.of_int (2))
+                          (Prims.of_int (352)) (Prims.of_int (12)))
                        (Obj.magic
                           (FStar_Tactics_Builtins.term_eq_old hd head))
                        (fun uu___1 ->
@@ -68,15 +68,15 @@ let rec (term_has_head :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (10))
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (29)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (312))
+                                          (Prims.of_int (344))
                                           (Prims.of_int (7))
-                                          (Prims.of_int (320))
+                                          (Prims.of_int (352))
                                           (Prims.of_int (12)))
                                        (Obj.magic (is_star_or_vstar hd))
                                        (fun uu___3 ->
@@ -95,15 +95,15 @@ let rec (term_has_head :
                                                            (FStar_Tactics_Effect.tac_bind
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (9))
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (30)))
                                                               (Prims.mk_range
                                                                  "Steel.ST.GenElim.Base.fsti"
-                                                                 (Prims.of_int (316))
+                                                                 (Prims.of_int (348))
                                                                  (Prims.of_int (6))
-                                                                 (Prims.of_int (318))
+                                                                 (Prims.of_int (350))
                                                                  (Prims.of_int (32)))
                                                               (Obj.magic
                                                                  (term_has_head
@@ -142,16 +142,16 @@ let rec (solve_gen_unit_elim :
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-         (Prims.of_int (6)) (Prims.of_int (340)) (Prims.of_int (47)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+         (Prims.of_int (6)) (Prims.of_int (372)) (Prims.of_int (47)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (13)) (Prims.of_int (326)) (Prims.of_int (40)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (326))
-               (Prims.of_int (9)) (Prims.of_int (326)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (13)) (Prims.of_int (358)) (Prims.of_int (40)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (358))
+               (Prims.of_int (9)) (Prims.of_int (358)) (Prims.of_int (40)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -184,11 +184,11 @@ let rec (solve_gen_unit_elim :
                 (Obj.repr
                    (FStar_Tactics_Effect.tac_bind
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (23))
-                         (Prims.of_int (329)) (Prims.of_int (40)))
+                         (Prims.of_int (361)) (Prims.of_int (23))
+                         (Prims.of_int (361)) (Prims.of_int (40)))
                       (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                         (Prims.of_int (329)) (Prims.of_int (8))
-                         (Prims.of_int (340)) (Prims.of_int (47)))
+                         (Prims.of_int (361)) (Prims.of_int (8))
+                         (Prims.of_int (372)) (Prims.of_int (47)))
                       (FStar_Tactics_Effect.lift_div_tac
                          (fun uu___2 ->
                             FStar_Reflection_Derived.collect_app tl'))
@@ -217,15 +217,15 @@ let rec (solve_gen_unit_elim :
                                        (FStar_Tactics_Effect.tac_bind
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (16))
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (35)))
                                           (Prims.mk_range
                                              "Steel.ST.GenElim.Base.fsti"
-                                             (Prims.of_int (332))
+                                             (Prims.of_int (364))
                                              (Prims.of_int (13))
-                                             (Prims.of_int (340))
+                                             (Prims.of_int (372))
                                              (Prims.of_int (47)))
                                           (Obj.magic (is_star_or_vstar hd))
                                           (fun uu___4 ->
@@ -244,15 +244,15 @@ let rec (solve_gen_unit_elim :
                                                               (FStar_Tactics_Effect.tac_bind
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (335))
+                                                                    (Prims.of_int (367))
                                                                     (Prims.of_int (42)))
                                                                  (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                  (Obj.magic
                                                                     (
@@ -266,15 +266,15 @@ let rec (solve_gen_unit_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (336))
+                                                                    (Prims.of_int (368))
                                                                     (Prims.of_int (42)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (337))
+                                                                    (Prims.of_int (369))
                                                                     (Prims.of_int (68)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -326,10 +326,10 @@ let (abstr_has_exists :
   =
   fun t ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (8)) (Prims.of_int (345)) (Prims.of_int (19)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (345))
-         (Prims.of_int (2)) (Prims.of_int (347)) (Prims.of_int (14)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (8)) (Prims.of_int (377)) (Prims.of_int (19)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (377))
+         (Prims.of_int (2)) (Prims.of_int (379)) (Prims.of_int (14)))
       (Obj.magic (FStar_Tactics_Builtins.inspect t))
       (fun uu___ ->
          (fun uu___ ->
@@ -347,22 +347,53 @@ let (abstr_has_exists :
                   (Obj.repr
                      (FStar_Tactics_Effect.lift_div_tac (fun uu___2 -> false))))
            uu___)
+let rec (get_universe :
+  FStar_Reflection_Types.universe ->
+    (Prims.nat, unit) FStar_Tactics_Effect.tac_repr)
+  =
+  fun uu___ ->
+    (fun u ->
+       match FStar_Reflection_Builtins.inspect_universe u with
+       | FStar_Reflection_Data.Uv_Zero ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.lift_div_tac
+                   (fun uu___ -> Prims.int_zero)))
+       | FStar_Reflection_Data.Uv_Succ u1 ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Effect.tac_bind
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (23))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                      (Prims.of_int (386)) (Prims.of_int (19))
+                      (Prims.of_int (386)) (Prims.of_int (37)))
+                   (Obj.magic (get_universe u1))
+                   (fun uu___ ->
+                      FStar_Tactics_Effect.lift_div_tac
+                        (fun uu___1 -> Prims.int_one + uu___))))
+       | uu___ ->
+           Obj.magic
+             (Obj.repr
+                (FStar_Tactics_Derived.fail
+                   "get_universe: not an universe instantiation"))) uu___
 let rec (solve_gen_elim :
   FStar_Reflection_Types.term ->
     (FStar_Reflection_Types.term, unit) FStar_Tactics_Effect.tac_repr)
   =
   fun tl' ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-         (Prims.of_int (6)) (Prims.of_int (399)) (Prims.of_int (68)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+         (Prims.of_int (6)) (Prims.of_int (458)) (Prims.of_int (68)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (13)) (Prims.of_int (353)) (Prims.of_int (43)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (353))
-               (Prims.of_int (9)) (Prims.of_int (353)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (13)) (Prims.of_int (393)) (Prims.of_int (43)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (393))
+               (Prims.of_int (9)) (Prims.of_int (393)) (Prims.of_int (43)))
             (Obj.magic
                (term_has_head tl'
                   (FStar_Reflection_Builtins.pack_ln
@@ -379,11 +410,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (355)) (Prims.of_int (17))
-                      (Prims.of_int (355)) (Prims.of_int (40)))
+                      (Prims.of_int (395)) (Prims.of_int (17))
+                      (Prims.of_int (395)) (Prims.of_int (40)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (356)) (Prims.of_int (8))
-                      (Prims.of_int (356)) (Prims.of_int (45)))
+                      (Prims.of_int (396)) (Prims.of_int (8))
+                      (Prims.of_int (396)) (Prims.of_int (45)))
                    (Obj.magic (solve_gen_unit_elim tl'))
                    (fun t' ->
                       FStar_Tactics_Effect.lift_div_tac
@@ -402,11 +433,11 @@ let rec (solve_gen_elim :
               Obj.magic
                 (FStar_Tactics_Effect.tac_bind
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (26))
-                      (Prims.of_int (358)) (Prims.of_int (43)))
+                      (Prims.of_int (398)) (Prims.of_int (26))
+                      (Prims.of_int (398)) (Prims.of_int (43)))
                    (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                      (Prims.of_int (358)) (Prims.of_int (8))
-                      (Prims.of_int (399)) (Prims.of_int (68)))
+                      (Prims.of_int (398)) (Prims.of_int (8))
+                      (Prims.of_int (458)) (Prims.of_int (68)))
                    (FStar_Tactics_Effect.lift_div_tac
                       (fun uu___2 -> FStar_Reflection_Derived.collect_app tl'))
                    (fun uu___2 ->
@@ -419,88 +450,122 @@ let rec (solve_gen_elim :
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (362))
-                                       (Prims.of_int (12))
-                                       (Prims.of_int (365))
-                                       (Prims.of_int (46)))
+                                       (Prims.of_int (401))
+                                       (Prims.of_int (25))
+                                       (Prims.of_int (403))
+                                       (Prims.of_int (63)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (361))
+                                       (Prims.of_int (405))
                                        (Prims.of_int (10))
-                                       (Prims.of_int (378))
+                                       (Prims.of_int (437))
                                        (Prims.of_int (13)))
-                                    (match lbody with
-                                     | (ty, FStar_Reflection_Data.Q_Implicit)::
-                                         (body,
-                                          FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 ->
-                                              ([(ty,
-                                                  FStar_Reflection_Data.Q_Implicit)],
-                                                body))
-                                     | (body,
-                                        FStar_Reflection_Data.Q_Explicit)::[]
-                                         ->
-                                         FStar_Tactics_Effect.lift_div_tac
-                                           (fun uu___3 -> ([], body))
+                                    (match FStar_Reflection_Derived.inspect_ln_unascribe
+                                             hd
+                                     with
+                                     | FStar_Reflection_Data.Tv_UInst
+                                         (uu___3, u::uu___4) ->
+                                         Obj.magic
+                                           (Obj.repr (get_universe u))
                                      | uu___3 ->
-                                         FStar_Tactics_Derived.fail
-                                           "ill-formed exists_")
+                                         Obj.magic
+                                           (Obj.repr
+                                              (FStar_Tactics_Derived.fail
+                                                 "ill-formed exists_: no universe found")))
                                     (fun uu___3 ->
-                                       (fun uu___3 ->
-                                          match uu___3 with
-                                          | (ty, body) ->
-                                              Obj.magic
-                                                (FStar_Tactics_Effect.tac_bind
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (22))
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (36)))
-                                                   (Prims.mk_range
-                                                      "Steel.ST.GenElim.Base.fsti"
-                                                      (Prims.of_int (367))
-                                                      (Prims.of_int (16))
-                                                      (Prims.of_int (377))
-                                                      (Prims.of_int (45)))
-                                                   (Obj.magic
-                                                      (FStar_Tactics_Builtins.inspect
-                                                         body))
-                                                   (fun uu___4 ->
-                                                      (fun uu___4 ->
-                                                         match uu___4 with
-                                                         | FStar_Reflection_Data.Tv_Abs
-                                                             (b, abody) ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.tac_bind
+                                       (fun universe ->
+                                          Obj.magic
+                                            (FStar_Tactics_Effect.tac_bind
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (406))
+                                                  (Prims.of_int (12))
+                                                  (Prims.of_int (409))
+                                                  (Prims.of_int (46)))
+                                               (Prims.mk_range
+                                                  "Steel.ST.GenElim.Base.fsti"
+                                                  (Prims.of_int (405))
+                                                  (Prims.of_int (10))
+                                                  (Prims.of_int (437))
+                                                  (Prims.of_int (13)))
+                                               (match lbody with
+                                                | (ty,
+                                                   FStar_Reflection_Data.Q_Implicit)::
+                                                    (body,
+                                                     FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([(ty,
+                                                             FStar_Reflection_Data.Q_Implicit)],
+                                                           body))
+                                                | (body,
+                                                   FStar_Reflection_Data.Q_Explicit)::[]
+                                                    ->
+                                                    FStar_Tactics_Effect.lift_div_tac
+                                                      (fun uu___3 ->
+                                                         ([], body))
+                                                | uu___3 ->
+                                                    FStar_Tactics_Derived.fail
+                                                      "ill-formed exists_")
+                                               (fun uu___3 ->
+                                                  (fun uu___3 ->
+                                                     match uu___3 with
+                                                     | (ty, body) ->
+                                                         Obj.magic
+                                                           (FStar_Tactics_Effect.tac_bind
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (22))
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (36)))
+                                                              (Prims.mk_range
+                                                                 "Steel.ST.GenElim.Base.fsti"
+                                                                 (Prims.of_int (411))
+                                                                 (Prims.of_int (16))
+                                                                 (Prims.of_int (436))
+                                                                 (Prims.of_int (21)))
+                                                              (Obj.magic
+                                                                 (FStar_Tactics_Builtins.inspect
+                                                                    body))
+                                                              (fun uu___4 ->
+                                                                 (fun uu___4
+                                                                    ->
+                                                                    match uu___4
+                                                                    with
+                                                                    | 
+                                                                    FStar_Reflection_Data.Tv_Abs
+                                                                    (b,
+                                                                    abody) ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (21))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (369))
+                                                                    (Prims.of_int (413))
                                                                     (Prims.of_int (53)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -529,16 +594,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (371))
+                                                                    (Prims.of_int (415))
                                                                     (Prims.of_int (53)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
                                                                     abody))
@@ -550,58 +615,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
+                                                                    (Prims.of_int (416))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (41))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (98)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (63))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (97)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (82)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (64))
-                                                                    (Prims.of_int (372))
-                                                                    (Prims.of_int (96)))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (421))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -631,14 +696,32 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___7 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___8
+                                                                    when
+                                                                    uu___8 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsUnit"])))
+                                                                    "GEExistsUnit0"]))
+                                                                    | 
+                                                                    uu___8 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsUnit1"])))
                                                                     uu___6))))
                                                                     uu___6))
                                                                     else
@@ -646,16 +729,16 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (28))
-                                                                    (Prims.of_int (374))
+                                                                    (Prims.of_int (423))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
                                                                     abody))
@@ -667,58 +750,58 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
+                                                                    (Prims.of_int (424))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (37))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (94)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (75)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (59))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (93)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (40))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (78)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (59)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (60))
-                                                                    (Prims.of_int (375))
-                                                                    (Prims.of_int (92)))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (41))
+                                                                    (Prims.of_int (429))
+                                                                    (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
                                                                     [b] body'))
@@ -748,48 +831,86 @@ let rec (solve_gen_elim :
                                                                     (fun
                                                                     uu___8 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___9
+                                                                    when
+                                                                    uu___9 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExists"])))
+                                                                    "GEExists0"]))
+                                                                    | 
+                                                                    uu___9 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExists1"])))
                                                                     uu___7))))
                                                                     uu___7)))
                                                                     uu___5)))
-                                                         | uu___5 ->
-                                                             Obj.magic
-                                                               (Obj.repr
-                                                                  (FStar_Tactics_Effect.lift_div_tac
+                                                                    | 
+                                                                    uu___5 ->
+                                                                    Obj.magic
+                                                                    (Obj.repr
+                                                                    (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___6 ->
                                                                     FStar_Reflection_Derived.mk_app
-                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (match universe
+                                                                    with
+                                                                    | 
+                                                                    uu___7
+                                                                    when
+                                                                    uu___7 =
+                                                                    Prims.int_zero
+                                                                    ->
+                                                                    FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "GEExistsNoAbs"])))
+                                                                    "GEExistsNoAbs0"]))
+                                                                    | 
+                                                                    uu___7 ->
+                                                                    FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Steel";
+                                                                    "ST";
+                                                                    "GenElim";
+                                                                    "Base";
+                                                                    "GEExistsNoAbs1"])))
                                                                     lbody))))
-                                                        uu___4))) uu___3))
+                                                                   uu___4)))
+                                                    uu___3))) uu___3))
                              else
                                Obj.magic
                                  (FStar_Tactics_Effect.tac_bind
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (16))
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (35)))
                                     (Prims.mk_range
                                        "Steel.ST.GenElim.Base.fsti"
-                                       (Prims.of_int (379))
+                                       (Prims.of_int (438))
                                        (Prims.of_int (13))
-                                       (Prims.of_int (399))
+                                       (Prims.of_int (458))
                                        (Prims.of_int (68)))
                                     (Obj.magic (is_star_or_vstar hd))
                                     (fun uu___4 ->
@@ -808,15 +929,15 @@ let rec (solve_gen_elim :
                                                         (FStar_Tactics_Effect.tac_bind
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (15))
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (42)))
                                                            (Prims.mk_range
                                                               "Steel.ST.GenElim.Base.fsti"
-                                                              (Prims.of_int (383))
+                                                              (Prims.of_int (442))
                                                               (Prims.of_int (12))
-                                                              (Prims.of_int (396))
+                                                              (Prims.of_int (455))
                                                               (Prims.of_int (72)))
                                                            (Obj.magic
                                                               (term_has_head
@@ -837,15 +958,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (385))
+                                                                    (Prims.of_int (444))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -858,15 +979,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (386))
+                                                                    (Prims.of_int (445))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (term_has_head
@@ -888,15 +1009,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (388))
+                                                                    (Prims.of_int (447))
                                                                     (Prims.of_int (43)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (389))
+                                                                    (Prims.of_int (448))
                                                                     (Prims.of_int (73)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -925,15 +1046,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (391))
+                                                                    (Prims.of_int (450))
                                                                     (Prims.of_int (48)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (16))
-                                                                    (Prims.of_int (392))
+                                                                    (Prims.of_int (451))
                                                                     (Prims.of_int (74)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -964,15 +1085,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (394))
+                                                                    (Prims.of_int (453))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_unit_elim
@@ -985,15 +1106,15 @@ let rec (solve_gen_elim :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (395))
+                                                                    (Prims.of_int (454))
                                                                     (Prims.of_int (41)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (14))
-                                                                    (Prims.of_int (396))
+                                                                    (Prims.of_int (455))
                                                                     (Prims.of_int (72)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1077,11 +1198,11 @@ let rec (solve_gen_elim_nondep' :
                    (Obj.repr
                       (FStar_Tactics_Effect.tac_bind
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (19))
-                            (Prims.of_int (488)) (Prims.of_int (34)))
+                            (Prims.of_int (547)) (Prims.of_int (19))
+                            (Prims.of_int (547)) (Prims.of_int (34)))
                          (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                            (Prims.of_int (488)) (Prims.of_int (4))
-                            (Prims.of_int (532)) (Prims.of_int (13)))
+                            (Prims.of_int (547)) (Prims.of_int (4))
+                            (Prims.of_int (592)) (Prims.of_int (13)))
                          (FStar_Tactics_Effect.lift_div_tac
                             (fun uu___1 ->
                                FStar_Reflection_Derived.collect_app t))
@@ -1101,15 +1222,15 @@ let rec (solve_gen_elim_nondep' :
                                                (FStar_Tactics_Effect.tac_bind
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (493))
+                                                     (Prims.of_int (552))
                                                      (Prims.of_int (8))
-                                                     (Prims.of_int (495))
-                                                     (Prims.of_int (85)))
+                                                     (Prims.of_int (554))
+                                                     (Prims.of_int (88)))
                                                   (Prims.mk_range
                                                      "Steel.ST.GenElim.Base.fsti"
-                                                     (Prims.of_int (497))
+                                                     (Prims.of_int (556))
                                                      (Prims.of_int (6))
-                                                     (Prims.of_int (522))
+                                                     (Prims.of_int (582))
                                                      (Prims.of_int (9)))
                                                   (FStar_Tactics_Effect.lift_div_tac
                                                      (fun uu___2 ->
@@ -1119,16 +1240,16 @@ let rec (solve_gen_elim_nondep' :
                                                               FStar_Tactics_Effect.tac_bind
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (22))
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (24)))
                                                                 (Prims.mk_range
                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                   (Prims.of_int (493))
+                                                                   (Prims.of_int (552))
                                                                    (Prims.of_int (8))
-                                                                   (Prims.of_int (495))
-                                                                   (Prims.of_int (85)))
+                                                                   (Prims.of_int (554))
+                                                                   (Prims.of_int (88)))
                                                                 (FStar_Tactics_Effect.lift_div_tac
                                                                    (fun
                                                                     uu___4 ->
@@ -1147,16 +1268,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (494))
+                                                                    (Prims.of_int (553))
                                                                     (Prims.of_int (24)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (495))
+                                                                    (Prims.of_int (554))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (495))
-                                                                    (Prims.of_int (85)))
+                                                                    (Prims.of_int (554))
+                                                                    (Prims.of_int (88)))
                                                                     (Obj.magic
                                                                     (accu ()))
                                                                     (fun tl1
@@ -1174,7 +1295,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit);
                                                                     (ty,
                                                                     FStar_Reflection_Data.Q_Explicit);
@@ -1187,15 +1310,15 @@ let rec (solve_gen_elim_nondep' :
                                                           (FStar_Tactics_Effect.tac_bind
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (497))
+                                                                (Prims.of_int (556))
                                                                 (Prims.of_int (39))
-                                                                (Prims.of_int (497))
-                                                                (Prims.of_int (79)))
+                                                                (Prims.of_int (556))
+                                                                (Prims.of_int (84)))
                                                              (Prims.mk_range
                                                                 "Steel.ST.GenElim.Base.fsti"
-                                                                (Prims.of_int (498))
+                                                                (Prims.of_int (557))
                                                                 (Prims.of_int (6))
-                                                                (Prims.of_int (522))
+                                                                (Prims.of_int (582))
                                                                 (Prims.of_int (9)))
                                                              (FStar_Tactics_Effect.lift_div_tac
                                                                 (fun uu___3
@@ -1220,7 +1343,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Implicit)])))
                                                                     uu___3
                                                                     uu___2))
@@ -1231,15 +1356,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (498))
+                                                                    (Prims.of_int (557))
                                                                     (Prims.of_int (84)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (499))
+                                                                    (Prims.of_int (558))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_List_Tot_Base.fold_left
@@ -1256,15 +1381,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (501))
+                                                                    (Prims.of_int (560))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (505))
+                                                                    (Prims.of_int (564))
                                                                     (Prims.of_int (23)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (507))
+                                                                    (Prims.of_int (566))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.try_with
@@ -1277,16 +1402,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (502))
+                                                                    (Prims.of_int (561))
                                                                     (Prims.of_int (30)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.cur_env
                                                                     ()))
@@ -1298,16 +1423,16 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (19))
-                                                                    (Prims.of_int (503))
+                                                                    (Prims.of_int (562))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (504))
+                                                                    (Prims.of_int (563))
                                                                     (Prims.of_int (10))
-                                                                    (Prims.of_int (504))
-                                                                    (Prims.of_int (42)))
+                                                                    (Prims.of_int (563))
+                                                                    (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.tc
                                                                     env
@@ -1329,7 +1454,9 @@ let rec (solve_gen_elim_nondep' :
                                                                     ((FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_Type
                                                                     (FStar_Reflection_Builtins.pack_universe
-                                                                    FStar_Reflection_Data.Uv_Zero))),
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))),
                                                                     FStar_Reflection_Data.Q_Explicit))))))
                                                                     uu___3)))
                                                                     uu___3))
@@ -1364,23 +1491,69 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (510))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (39))
+                                                                    (Prims.of_int (569))
+                                                                    (Prims.of_int (81)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (8))
+                                                                    (Prims.of_int (582))
+                                                                    (Prims.of_int (9)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Derived.fresh_binder
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))))
+                                                                    (fun
+                                                                    uu___3 ->
+                                                                    (fun
+                                                                    dummy_raised_unit_binder
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (570))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (510))
-                                                                    (Prims.of_int (75)))
+                                                                    (Prims.of_int (570))
+                                                                    (Prims.of_int (120)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
                                                                     uu___3 ->
-                                                                    FStar_List_Tot_Base.map
+                                                                    FStar_List_Tot_Base.append
+                                                                    (FStar_List_Tot_Base.map
                                                                     FStar_Pervasives_Native.snd
                                                                     (FStar_List_Tot_Base.rev
-                                                                    rev_types_and_binders)))
+                                                                    rev_types_and_binders))
+                                                                    [dummy_raised_unit_binder]))
                                                                     (fun
                                                                     uu___3 ->
                                                                     (fun
@@ -1390,15 +1563,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (511))
+                                                                    (Prims.of_int (571))
                                                                     (Prims.of_int (82)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1418,15 +1591,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (512))
+                                                                    (Prims.of_int (572))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1439,37 +1612,97 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (513))
+                                                                    (Prims.of_int (573))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (513))
-                                                                    (Prims.of_int (113)))
+                                                                    (Prims.of_int (573))
+                                                                    (Prims.of_int (151)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    {
+                                                                    FStar_Reflection_Data.binder_bv
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    =
+                                                                    (FStar_Sealed.seal
+                                                                    "_");
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (964));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    });
+                                                                    FStar_Reflection_Data.binder_qual
+                                                                    =
+                                                                    FStar_Reflection_Data.Q_Explicit;
+                                                                    FStar_Reflection_Data.binder_attrs
+                                                                    = []
+                                                                    }),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "Effect";
                                                                     "Common";
-                                                                    "vprop"]))),
+                                                                    "vprop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun
                                                                     uu___3 ->
@@ -1479,15 +1712,15 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (17))
-                                                                    (Prims.of_int (514))
+                                                                    (Prims.of_int (574))
                                                                     (Prims.of_int (35)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.mk_abs
@@ -1500,35 +1733,95 @@ let rec (solve_gen_elim_nondep' :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (515))
+                                                                    (Prims.of_int (575))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (515))
-                                                                    (Prims.of_int (112)))
+                                                                    (Prims.of_int (575))
+                                                                    (Prims.of_int (150)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (516))
+                                                                    (Prims.of_int (576))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (522))
+                                                                    (Prims.of_int (582))
                                                                     (Prims.of_int (9)))
                                                                     (Obj.magic
                                                                     (norm_term
                                                                     (FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
-                                                                    (FStar_Reflection_Data.Tv_FVar
-                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
                                                                     ["Steel";
                                                                     "ST";
                                                                     "GenElim";
                                                                     "Base";
-                                                                    "curried_function_type"])))
+                                                                    "curried_function_type"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero));
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))])))
                                                                     [
                                                                     (type_list,
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_Arrow
+                                                                    ((FStar_Reflection_Builtins.pack_binder
+                                                                    {
+                                                                    FStar_Reflection_Data.binder_bv
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_bv
+                                                                    {
+                                                                    FStar_Reflection_Data.bv_ppname
+                                                                    =
+                                                                    (FStar_Sealed.seal
+                                                                    "_");
+                                                                    FStar_Reflection_Data.bv_index
+                                                                    =
+                                                                    (Prims.of_int (967));
+                                                                    FStar_Reflection_Data.bv_sort
+                                                                    =
+                                                                    (FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_App
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_UInst
+                                                                    ((FStar_Reflection_Builtins.pack_fv
+                                                                    ["FStar";
+                                                                    "Universe";
+                                                                    "raise_t"]),
+                                                                    [
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Unk;
+                                                                    FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    (FStar_Reflection_Data.Uv_Succ
+                                                                    (FStar_Reflection_Builtins.pack_universe
+                                                                    FStar_Reflection_Data.Uv_Zero))))]))),
+                                                                    ((FStar_Reflection_Builtins.pack_ln
+                                                                    (FStar_Reflection_Data.Tv_FVar
+                                                                    (FStar_Reflection_Builtins.pack_fv
+                                                                    ["Prims";
+                                                                    "unit"]))),
+                                                                    FStar_Reflection_Data.Q_Explicit))))
+                                                                    });
+                                                                    FStar_Reflection_Data.binder_qual
+                                                                    =
+                                                                    FStar_Reflection_Data.Q_Explicit;
+                                                                    FStar_Reflection_Data.binder_attrs
+                                                                    = []
+                                                                    }),
+                                                                    (FStar_Reflection_Builtins.pack_comp
+                                                                    (FStar_Reflection_Data.C_Total
+                                                                    (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
                                                                     ["Prims";
-                                                                    "prop"]))),
+                                                                    "prop"])))))))),
                                                                     FStar_Reflection_Data.Q_Explicit)])))
                                                                     (fun tp'
                                                                     ->
@@ -1543,6 +1836,7 @@ let rec (solve_gen_elim_nondep' :
                                                                     uu___3)))
                                                                     uu___3)))
                                                                     uu___3)))
+                                                                    uu___3)))
                                                                     uu___3))))
                                                                     uu___2)))
                                                                     uu___2)))
@@ -1569,15 +1863,15 @@ let rec (solve_gen_elim_nondep' :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (18))
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (29)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (527))
+                                                         (Prims.of_int (587))
                                                          (Prims.of_int (12))
-                                                         (Prims.of_int (529))
+                                                         (Prims.of_int (589))
                                                          (Prims.of_int (17)))
                                                       (Obj.magic
                                                          (FStar_Tactics_Builtins.inspect
@@ -1638,11 +1932,11 @@ let (solve_gen_elim_nondep0 :
                         | () ->
                             FStar_Tactics_Effect.tac_bind
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (539)) (Prims.of_int (17))
-                                 (Prims.of_int (539)) (Prims.of_int (64)))
+                                 (Prims.of_int (599)) (Prims.of_int (17))
+                                 (Prims.of_int (599)) (Prims.of_int (64)))
                               (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                 (Prims.of_int (540)) (Prims.of_int (6))
-                                 (Prims.of_int (541)) (Prims.of_int (37)))
+                                 (Prims.of_int (600)) (Prims.of_int (6))
+                                 (Prims.of_int (601)) (Prims.of_int (37)))
                               (FStar_Tactics_Effect.lift_div_tac
                                  (fun uu___1 ->
                                     FStar_Reflection_Derived.mk_app
@@ -1661,15 +1955,15 @@ let (solve_gen_elim_nondep0 :
                                       (FStar_Tactics_Effect.tac_bind
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (15))
-                                            (Prims.of_int (540))
+                                            (Prims.of_int (600))
                                             (Prims.of_int (76)))
                                          (Prims.mk_range
                                             "Steel.ST.GenElim.Base.fsti"
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (6))
-                                            (Prims.of_int (541))
+                                            (Prims.of_int (601))
                                             (Prims.of_int (37)))
                                          (Obj.magic
                                             (FStar_Tactics_Derived.norm_term
@@ -1703,10 +1997,10 @@ let (solve_gen_elim_nondep :
   fun enable_nondep_opt ->
     fun t ->
       FStar_Tactics_Effect.tac_bind
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (8)) (Prims.of_int (546)) (Prims.of_int (50)))
-        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (546))
-           (Prims.of_int (2)) (Prims.of_int (560)) (Prims.of_int (9)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (8)) (Prims.of_int (606)) (Prims.of_int (50)))
+        (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (606))
+           (Prims.of_int (2)) (Prims.of_int (620)) (Prims.of_int (9)))
         (Obj.magic (solve_gen_elim_nondep0 enable_nondep_opt t))
         (fun uu___ ->
            FStar_Tactics_Effect.lift_div_tac
@@ -1721,32 +2015,76 @@ let (solve_gen_elim_nondep :
                     ->
                     FStar_Reflection_Derived.mk_app
                       (FStar_Reflection_Builtins.pack_ln
-                         (FStar_Reflection_Data.Tv_FVar
-                            (FStar_Reflection_Builtins.pack_fv
-                               ["Steel";
-                               "ST";
-                               "GenElim";
-                               "Base";
-                               "mk_gen_elim_nondep_by_tac"])))
+                         (FStar_Reflection_Data.Tv_UInst
+                            ((FStar_Reflection_Builtins.pack_fv
+                                ["Steel";
+                                "ST";
+                                "GenElim";
+                                "Base";
+                                "mk_gen_elim_nondep_by_tac"]),
+                              [FStar_Reflection_Builtins.pack_universe
+                                 (FStar_Reflection_Data.Uv_Succ
+                                    (FStar_Reflection_Builtins.pack_universe
+                                       FStar_Reflection_Data.Uv_Zero))])))
                       [(type_list, FStar_Reflection_Data.Q_Explicit);
                       (tv', FStar_Reflection_Data.Q_Explicit);
                       (v', FStar_Reflection_Data.Q_Explicit);
                       (tp', FStar_Reflection_Data.Q_Explicit);
                       (p', FStar_Reflection_Data.Q_Explicit)]))
+let (trefl_or_smt : unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
+  fun uu___ ->
+    FStar_Tactics_Effect.tac_bind
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (623))
+         (Prims.of_int (11)) (Prims.of_int (623)) (Prims.of_int (24)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (624))
+         (Prims.of_int (2)) (Prims.of_int (626)) (Prims.of_int (27)))
+      (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
+      (fun uu___1 ->
+         (fun ty ->
+            Obj.magic
+              (FStar_Tactics_Effect.tac_bind
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (8))
+                    (Prims.of_int (624)) (Prims.of_int (28)))
+                 (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                    (Prims.of_int (624)) (Prims.of_int (2))
+                    (Prims.of_int (626)) (Prims.of_int (27)))
+                 (Obj.magic (FStar_Reflection_Formula.term_as_formula ty))
+                 (fun uu___1 ->
+                    (fun uu___1 ->
+                       match uu___1 with
+                       | FStar_Reflection_Formula.Comp
+                           (uu___2, uu___3, uu___4) ->
+                           Obj.magic (FStar_Tactics_Derived.trefl ())
+                       | uu___2 ->
+                           Obj.magic
+                             (FStar_Tactics_Effect.tac_bind
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (9))
+                                   (Prims.of_int (626)) (Prims.of_int (17)))
+                                (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
+                                   (Prims.of_int (626)) (Prims.of_int (19))
+                                   (Prims.of_int (626)) (Prims.of_int (27)))
+                                (Obj.magic (FStar_Tactics_Derived.smt ()))
+                                (fun uu___3 ->
+                                   (fun uu___3 ->
+                                      Obj.magic
+                                        (FStar_Tactics_Derived.qed ()))
+                                     uu___3))) uu___1))) uu___1)
 let (solve_gen_elim_prop :
   unit -> (unit, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-         (Prims.of_int (2)) (Prims.of_int (604)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+         (Prims.of_int (2)) (Prims.of_int (670)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (31)) (Prims.of_int (566)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (566))
-               (Prims.of_int (17)) (Prims.of_int (566)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (31)) (Prims.of_int (632)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (632))
+               (Prims.of_int (17)) (Prims.of_int (632)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -1758,27 +2096,27 @@ let (solve_gen_elim_prop :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (567)) (Prims.of_int (2))
-                        (Prims.of_int (568)) (Prims.of_int (33)))
+                        (Prims.of_int (633)) (Prims.of_int (2))
+                        (Prims.of_int (634)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (569)) (Prims.of_int (2))
-                        (Prims.of_int (604)) (Prims.of_int (35)))
+                        (Prims.of_int (635)) (Prims.of_int (2))
+                        (Prims.of_int (670)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (5))
-                              (Prims.of_int (567)) (Prims.of_int (23)))
+                              (Prims.of_int (633)) (Prims.of_int (5))
+                              (Prims.of_int (633)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (567)) (Prims.of_int (2))
-                              (Prims.of_int (568)) (Prims.of_int (33)))
+                              (Prims.of_int (633)) (Prims.of_int (2))
+                              (Prims.of_int (634)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (9))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (9))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (567)) (Prims.of_int (5))
-                                    (Prims.of_int (567)) (Prims.of_int (23)))
+                                    (Prims.of_int (633)) (Prims.of_int (5))
+                                    (Prims.of_int (633)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -1800,15 +2138,15 @@ let (solve_gen_elim_prop :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (571))
+                                          (Prims.of_int (637))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (603))
+                                          (Prims.of_int (669))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -1822,15 +2160,15 @@ let (solve_gen_elim_prop :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (572))
+                                                         (Prims.of_int (638))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (573))
+                                                         (Prims.of_int (639))
                                                          (Prims.of_int (42)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (574))
+                                                         (Prims.of_int (640))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (602))
+                                                         (Prims.of_int (668))
                                                          (Prims.of_int (44)))
                                                       (if
                                                          Prims.op_Negation
@@ -1869,15 +2207,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (576))
+                                                                    (Prims.of_int (642))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -1895,15 +2233,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (577))
+                                                                    (Prims.of_int (643))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -1917,15 +2255,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (20))
-                                                                    (Prims.of_int (578))
+                                                                    (Prims.of_int (644))
                                                                     (Prims.of_int (73)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -1949,29 +2287,29 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (61)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (579))
+                                                                    (Prims.of_int (645))
                                                                     (Prims.of_int (12))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep0
@@ -2022,15 +2360,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (586))
+                                                                    (Prims.of_int (652))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (593))
+                                                                    (Prims.of_int (659))
                                                                     (Prims.of_int (10)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -2066,15 +2404,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (8))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2084,15 +2422,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (594))
+                                                                    (Prims.of_int (660))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2120,15 +2458,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (26))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (33)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (35))
-                                                                    (Prims.of_int (595))
+                                                                    (Prims.of_int (661))
                                                                     (Prims.of_int (45)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2155,15 +2493,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2173,15 +2511,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (597))
+                                                                    (Prims.of_int (663))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2205,15 +2543,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (56)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (49)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2223,16 +2561,16 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
+                                                                    (Prims.of_int (664))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
+                                                                    (Prims.of_int (664))
+                                                                    (Prims.of_int (48)))
                                                                     (Obj.magic
                                                                     (norm ()))
                                                                     (fun
@@ -2242,32 +2580,8 @@ let (solve_gen_elim_prop :
                                                                     uu___13
                                                                     ->
                                                                     Obj.magic
-                                                                    (FStar_Tactics_Effect.tac_bind
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (33))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (45)))
-                                                                    (Prims.mk_range
-                                                                    "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (47))
-                                                                    (Prims.of_int (598))
-                                                                    (Prims.of_int (55)))
-                                                                    (Obj.magic
-                                                                    (FStar_Tactics_Derived.trivial
-                                                                    ()))
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    (fun
-                                                                    uu___14
-                                                                    ->
-                                                                    Obj.magic
-                                                                    (FStar_Tactics_Derived.qed
+                                                                    (trefl_or_smt
                                                                     ()))
-                                                                    uu___14)))
                                                                     uu___13))))
                                                                     (fun
                                                                     uu___12
@@ -2279,15 +2593,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2297,15 +2611,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (599))
+                                                                    (Prims.of_int (665))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2329,15 +2643,15 @@ let (solve_gen_elim_prop :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (44)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (44)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.focus
@@ -2347,15 +2661,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (600))
+                                                                    (Prims.of_int (666))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2383,15 +2697,15 @@ let (solve_gen_elim_prop :
                                                                     FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (24))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (601))
+                                                                    (Prims.of_int (667))
                                                                     (Prims.of_int (43)))
                                                                     (Obj.magic
                                                                     (norm ()))
@@ -2429,16 +2743,16 @@ let (solve_gen_elim_prop_placeholder :
   unit -> (Prims.bool, unit) FStar_Tactics_Effect.tac_repr) =
   fun uu___ ->
     FStar_Tactics_Effect.tac_bind
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
-      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-         (Prims.of_int (2)) (Prims.of_int (644)) (Prims.of_int (35)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
+      (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+         (Prims.of_int (2)) (Prims.of_int (712)) (Prims.of_int (35)))
       (Obj.magic
          (FStar_Tactics_Effect.tac_bind
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (31)) (Prims.of_int (610)) (Prims.of_int (46)))
-            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (610))
-               (Prims.of_int (17)) (Prims.of_int (610)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (31)) (Prims.of_int (676)) (Prims.of_int (46)))
+            (Prims.mk_range "Steel.ST.GenElim.Base.fsti" (Prims.of_int (676))
+               (Prims.of_int (17)) (Prims.of_int (676)) (Prims.of_int (46)))
             (Obj.magic (FStar_Tactics_Derived.cur_goal ()))
             (fun uu___1 ->
                FStar_Tactics_Effect.lift_div_tac
@@ -2450,27 +2764,27 @@ let (solve_gen_elim_prop_placeholder :
                 Obj.magic
                   (FStar_Tactics_Effect.tac_bind
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (611)) (Prims.of_int (2))
-                        (Prims.of_int (612)) (Prims.of_int (33)))
+                        (Prims.of_int (677)) (Prims.of_int (2))
+                        (Prims.of_int (678)) (Prims.of_int (33)))
                      (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                        (Prims.of_int (613)) (Prims.of_int (2))
-                        (Prims.of_int (644)) (Prims.of_int (35)))
+                        (Prims.of_int (679)) (Prims.of_int (2))
+                        (Prims.of_int (712)) (Prims.of_int (35)))
                      (Obj.magic
                         (FStar_Tactics_Effect.tac_bind
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (5))
-                              (Prims.of_int (611)) (Prims.of_int (23)))
+                              (Prims.of_int (677)) (Prims.of_int (5))
+                              (Prims.of_int (677)) (Prims.of_int (23)))
                            (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                              (Prims.of_int (611)) (Prims.of_int (2))
-                              (Prims.of_int (612)) (Prims.of_int (33)))
+                              (Prims.of_int (677)) (Prims.of_int (2))
+                              (Prims.of_int (678)) (Prims.of_int (33)))
                            (Obj.magic
                               (FStar_Tactics_Effect.tac_bind
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (9))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (9))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Prims.mk_range "Steel.ST.GenElim.Base.fsti"
-                                    (Prims.of_int (611)) (Prims.of_int (5))
-                                    (Prims.of_int (611)) (Prims.of_int (23)))
+                                    (Prims.of_int (677)) (Prims.of_int (5))
+                                    (Prims.of_int (677)) (Prims.of_int (23)))
                                  (Obj.magic (is_squash hd))
                                  (fun uu___2 ->
                                     FStar_Tactics_Effect.lift_div_tac
@@ -2492,15 +2806,15 @@ let (solve_gen_elim_prop_placeholder :
                                     (FStar_Tactics_Effect.tac_bind
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (21))
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (40)))
                                        (Prims.mk_range
                                           "Steel.ST.GenElim.Base.fsti"
-                                          (Prims.of_int (615))
+                                          (Prims.of_int (681))
                                           (Prims.of_int (4))
-                                          (Prims.of_int (643))
+                                          (Prims.of_int (711))
                                           (Prims.of_int (7)))
                                        (FStar_Tactics_Effect.lift_div_tac
                                           (fun uu___3 ->
@@ -2514,15 +2828,15 @@ let (solve_gen_elim_prop_placeholder :
                                                    (FStar_Tactics_Effect.tac_bind
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (616))
+                                                         (Prims.of_int (682))
                                                          (Prims.of_int (4))
-                                                         (Prims.of_int (617))
+                                                         (Prims.of_int (683))
                                                          (Prims.of_int (54)))
                                                       (Prims.mk_range
                                                          "Steel.ST.GenElim.Base.fsti"
-                                                         (Prims.of_int (618))
+                                                         (Prims.of_int (684))
                                                          (Prims.of_int (10))
-                                                         (Prims.of_int (642))
+                                                         (Prims.of_int (710))
                                                          (Prims.of_int (56)))
                                                       (if
                                                          Prims.op_Negation
@@ -2561,43 +2875,43 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (621))
+                                                                    (Prims.of_int (687))
                                                                     (Prims.of_int (47)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (27)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (9))
-                                                                    (Prims.of_int (620))
+                                                                    (Prims.of_int (686))
                                                                     (Prims.of_int (32)))
                                                                     (Obj.magic
                                                                     (Steel_Effect_Common.slterm_nbr_uvars
@@ -2635,29 +2949,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (622))
+                                                                    (Prims.of_int (688))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2681,29 +2995,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (33))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (623))
+                                                                    (Prims.of_int (689))
                                                                     (Prims.of_int (46)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2727,29 +3041,29 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (36))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (25))
-                                                                    (Prims.of_int (624))
+                                                                    (Prims.of_int (690))
                                                                     (Prims.of_int (52)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.inspect
@@ -2773,15 +3087,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (625))
+                                                                    (Prims.of_int (691))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (626))
+                                                                    (Prims.of_int (692))
                                                                     (Prims.of_int (63)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (if
                                                                     Prims.op_Negation
@@ -2808,15 +3122,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (30))
-                                                                    (Prims.of_int (627))
+                                                                    (Prims.of_int (693))
                                                                     (Prims.of_int (74)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.term_eq_old
@@ -2834,15 +3148,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (628))
+                                                                    (Prims.of_int (694))
                                                                     (Prims.of_int (31)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim
@@ -2856,15 +3170,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (629))
+                                                                    (Prims.of_int (695))
                                                                     (Prims.of_int (57)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (solve_gen_elim_nondep
@@ -2879,15 +3193,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (22))
-                                                                    (Prims.of_int (630))
+                                                                    (Prims.of_int (696))
                                                                     (Prims.of_int (80)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (FStar_Tactics_Effect.lift_div_tac
                                                                     (fun
@@ -2909,19 +3223,21 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (631))
+                                                                    (Prims.of_int (697))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (631))
-                                                                    (Prims.of_int (101)))
+                                                                    (Prims.of_int (697))
+                                                                    (Prims.of_int (89)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
-                                                                    (Obj.magic
-                                                                    (norm_term
-                                                                    (FStar_Reflection_Derived.mk_app
+                                                                    (FStar_Tactics_Effect.lift_div_tac
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    FStar_Reflection_Derived.mk_app
                                                                     (FStar_Reflection_Builtins.pack_ln
                                                                     (FStar_Reflection_Data.Tv_FVar
                                                                     (FStar_Reflection_Builtins.pack_fv
@@ -2934,7 +3250,7 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (i',
                                                                     FStar_Reflection_Data.Q_Explicit);
                                                                     (j',
-                                                                    FStar_Reflection_Data.Q_Explicit)])))
+                                                                    FStar_Reflection_Data.Q_Explicit)]))
                                                                     (fun
                                                                     uu___12
                                                                     ->
@@ -2944,15 +3260,59 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (18))
+                                                                    (Prims.of_int (698))
+                                                                    (Prims.of_int (37)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (FStar_Tactics_Builtins.term_to_string
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun
+                                                                    a'_ts ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (15))
+                                                                    (Prims.of_int (699))
+                                                                    (Prims.of_int (27)))
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
+                                                                    (Prims.of_int (6))
+                                                                    (Prims.of_int (709))
+                                                                    (Prims.of_int (10)))
+                                                                    (Obj.magic
+                                                                    (norm_term
+                                                                    a'))
+                                                                    (fun
+                                                                    uu___12
+                                                                    ->
+                                                                    (fun a'1
+                                                                    ->
+                                                                    Obj.magic
+                                                                    (FStar_Tactics_Effect.tac_bind
+                                                                    (Prims.mk_range
+                                                                    "Steel.ST.GenElim.Base.fsti"
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (15))
-                                                                    (Prims.of_int (632))
+                                                                    (Prims.of_int (700))
                                                                     (Prims.of_int (101)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -2979,15 +3339,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (18))
-                                                                    (Prims.of_int (633))
+                                                                    (Prims.of_int (701))
                                                                     (Prims.of_int (107)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (norm_term
@@ -3014,15 +3374,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (634))
+                                                                    (Prims.of_int (702))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3037,19 +3397,19 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (635))
+                                                                    (Prims.of_int (703))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
-                                                                    a'))
+                                                                    a'1))
                                                                     (fun
                                                                     uu___13
                                                                     ->
@@ -3060,15 +3420,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (636))
+                                                                    (Prims.of_int (704))
                                                                     (Prims.of_int (18)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3083,15 +3443,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (637))
+                                                                    (Prims.of_int (705))
                                                                     (Prims.of_int (16)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3106,15 +3466,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (638))
+                                                                    (Prims.of_int (706))
                                                                     (Prims.of_int (21)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Builtins.unshelve
@@ -3129,15 +3489,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (639))
+                                                                    (Prims.of_int (707))
                                                                     (Prims.of_int (19)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.exact
@@ -3152,15 +3512,15 @@ let (solve_gen_elim_prop_placeholder :
                                                                     (FStar_Tactics_Effect.tac_bind
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (640))
+                                                                    (Prims.of_int (708))
                                                                     (Prims.of_int (54)))
                                                                     (Prims.mk_range
                                                                     "Steel.ST.GenElim.Base.fsti"
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (6))
-                                                                    (Prims.of_int (641))
+                                                                    (Prims.of_int (709))
                                                                     (Prims.of_int (10)))
                                                                     (Obj.magic
                                                                     (FStar_Tactics_Derived.apply_lemma
@@ -3192,6 +3552,8 @@ let (solve_gen_elim_prop_placeholder :
                                                                     uu___12)))
                                                                     uu___12)))
                                                                     uu___12)))
+                                                                    uu___12)))
+                                                                    uu___12)))
                                                                     uu___11)))
                                                                     uu___11)))
                                                                     uu___11)))

From 57e1ab807a32ebcfa055eefd01a622fa7cc66599 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 13:56:25 -0700
Subject: [PATCH 508/513] also make translate_let extensible

---
 src/extraction/FStar.Extraction.Krml.fst | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index ccf706f1fb9..76a0013d667 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -1241,7 +1241,7 @@ let translate_type_decl' env ty: option decl =
         Errors. log_issue Range.dummyRange (Errors.Warning_DefinitionNotTranslated, (BU.format1 "Error extracting type definition %s to KaRaMeL\n" name));
         None
 
-let translate_let env flavor lb: option decl =
+let translate_let' env flavor lb: option decl =
   match lb with
   | {
       mllb_name = name;
@@ -1366,6 +1366,22 @@ let translate_let env flavor lb: option decl =
       end;
       None
 
+let translate_let_t = env -> mlletflavor -> mllb -> ML (option decl)
+(* translate_let' is not recursive, so we can directly use it to initialize ref_translate_let *)
+let ref_translate_let : ref translate_let_t = mk_ref translate_let'
+let register_pre_translate_let
+  (f: translate_let_t)
+: ML unit
+= let before : translate_let_t = !ref_translate_let in
+  let after : translate_let_t = fun e fl lb ->
+    try
+      f e fl lb
+    with NotSupportedByKrmlExtension -> before e fl lb
+  in
+  ref_translate_let := after
+let translate_let env flavor lb: option decl =
+  !ref_translate_let env flavor lb
+
 let translate_decl env d: list decl =
   match d with
   | MLM_Let (flavor, lbs) ->

From b012c901846107244ed3ba18725c421ebd022713 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 13:57:08 -0700
Subject: [PATCH 509/513] Revert "snap"

This reverts commit 38cef8c27da21f1006309b7cc481fbbc1c9591a0.
---
 .../generated/FStar_Extraction_Krml.ml        | 432 ++++++------------
 1 file changed, 131 insertions(+), 301 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 113de7287c7..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,18 +996,16 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" ->
-          translate_type_without_decay env1 arg
+          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1163,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1198,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2669,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3098,122 +2927,128 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type_without_decay env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 =
-                                        translate_type_without_decay env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
 let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
@@ -3553,9 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (uu___1975 : unit) =
-  register_post_translate_type_without_decay translate_type_without_decay';
-  register_post_translate_type translate_type';
-  register_post_translate_type_decl translate_type_decl';
-  register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file

From 17acd9e4d5483060335aa83d7285d77ca6cf02d3 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 14:01:36 -0700
Subject: [PATCH 510/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 457 +++++++++++++-----
 1 file changed, 325 insertions(+), 132 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..16cd4d30003 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,18 +1068,21 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -996,16 +1142,18 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1163,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1198,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2514,6 +2669,22 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2927,129 +3098,123 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
-let (translate_let :
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
+let (translate_let' :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
       FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
@@ -3320,6 +3485,29 @@ let (translate_let :
                     (FStar_String.concat ", " idents) uu___6
               | FStar_Pervasives_Native.None -> ());
              FStar_Pervasives_Native.None)
+type translate_let_t =
+  env ->
+    FStar_Extraction_ML_Syntax.mlletflavor ->
+      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option
+let (ref_translate_let : translate_let_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref translate_let'
+let (register_pre_translate_let : translate_let_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_let in
+    let after e fl lb =
+      try (fun uu___ -> match () with | () -> f e fl lb) ()
+      with | NotSupportedByKrmlExtension -> before e fl lb in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_let after
+let (translate_let :
+  env ->
+    FStar_Extraction_ML_Syntax.mlletflavor ->
+      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun flavor ->
+      fun lb ->
+        let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_let in
+        uu___ env1 flavor lb
 let (translate_decl :
   env -> FStar_Extraction_ML_Syntax.mlmodule1 -> decl Prims.list) =
   fun env1 ->
@@ -3388,4 +3576,9 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (uu___1993 : unit) =
+  register_post_translate_type_without_decay translate_type_without_decay';
+  register_post_translate_type translate_type';
+  register_post_translate_type_decl translate_type_decl';
+  register_post_translate_expr translate_expr'
\ No newline at end of file

From 92b495cf75e54a146939744917717bff33833899 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 14:33:09 -0700
Subject: [PATCH 511/513] Revert "snap"

This reverts commit 17acd9e4d5483060335aa83d7285d77ca6cf02d3.
---
 .../generated/FStar_Extraction_Krml.ml        | 457 +++++-------------
 1 file changed, 132 insertions(+), 325 deletions(-)

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 16cd4d30003..8d18834a86a 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,8 +17,6 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
-  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
-  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -148,7 +146,6 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
-  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -215,14 +212,6 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
-let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
-  fun projectee ->
-    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
-let (__proj__DUntaggedUnion__item___0 :
-  decl ->
-    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
-      (Prims.string * typ) Prims.list))
-  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -607,10 +596,6 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
-let (uu___is_TArray : typ -> Prims.bool) =
-  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
-let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
-  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -862,133 +847,7 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-exception NotSupportedByKrmlExtension 
-let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
-  fun projectee ->
-    match projectee with
-    | NotSupportedByKrmlExtension -> true
-    | uu___ -> false
-type translate_type_without_decay_t =
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type_without_decay :
-  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (register_post_translate_type_without_decay :
-  translate_type_without_decay_t -> unit) =
-  fun f ->
-    let before =
-      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
-      after
-let (translate_type_without_decay :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ =
-        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
-      uu___ env1 t
-type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
-let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (register_post_translate_type : translate_type_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
-let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
-      uu___ env1 t
-type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
-let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (register_post_translate_expr : translate_expr_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
-let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
-  fun env1 ->
-    fun e ->
-      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
-      uu___ env1 e
-type translate_type_decl_t =
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option
-let (ref_translate_type_decl :
-  translate_type_decl_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref
-    (fun uu___ ->
-       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
-let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> f e t) ()
-      with | NotSupportedByKrmlExtension -> before e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-    let after e t =
-      try (fun uu___ -> match () with | () -> before e t) ()
-      with | NotSupportedByKrmlExtension -> f e t in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
-let (translate_type_decl :
-  env ->
-    FStar_Extraction_ML_Syntax.one_mltydecl ->
-      decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
-         uu___1 env1 ty)
-let rec (translate_type_without_decay' :
-  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -998,9 +857,8 @@ let rec (translate_type_without_decay' :
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type_without_decay env1 t1 in
-            let uu___3 = translate_type_without_decay env1 t2 in
-            (uu___2, uu___3) in
+            let uu___2 = translate_type env1 t1 in
+            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -1030,8 +888,7 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          -> let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1068,21 +925,18 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
+          let uu___2 = translate_type env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___ = "LowStar.ConstBuffer.const_buffer") ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.TLArray.t")
-          ->
-          let uu___ = translate_type_without_decay env1 arg in
-          TConstBuf uu___
+          -> let uu___ = translate_type env1 arg in TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           ((((((((((((((((let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -1142,18 +996,16 @@ let rec (translate_type_without_decay' :
             ||
             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
+          -> let uu___ = translate_type env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          ->
-          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
+          -> let uu___1 = translate_type env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" ->
-          translate_type_without_decay env1 arg
+          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1163,26 +1015,19 @@ let rec (translate_type_without_decay' :
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) args in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 =
-                FStar_Compiler_List.map (translate_type_without_decay env1)
-                  args in
+              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ =
-            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
+          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
           TTuple uu___
-and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
-  fun env1 ->
-    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1198,7 +1043,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -2669,22 +2514,6 @@ and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
                              ((EQualified (["FStar"; "Int"; "Cast"], c)),
                                uu___11) in
                            EApp uu___10)
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.Effect.Atomic.return" -> translate_expr env1 e1
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -3098,123 +2927,129 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl' :
+let (translate_type_decl :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      match ty with
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          if
-            assumed &&
-              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
-                 flags)
-          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-          else
-            if assumed
-            then
-              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-               FStar_Compiler_Util.print1_warning
-                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                 name3;
-               FStar_Pervasives_Native.None)
-            else
-              (let uu___3 =
-                 let uu___4 =
-                   let uu___5 = translate_flags flags in
-                   let uu___6 = translate_type env2 t in
-                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-                 DTypeAlias uu___4 in
-               FStar_Pervasives_Native.Some uu___3)
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let env2 =
-            FStar_Compiler_List.fold_left
-              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 = translate_flags flags in
-              let uu___5 =
-                FStar_Compiler_List.map
-                  (fun uu___6 ->
-                     match uu___6 with
-                     | (f, t) ->
-                         let uu___7 =
-                           let uu___8 = translate_type_without_decay env2 t in
-                           (uu___8, false) in
-                         (f, uu___7)) fields in
-              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
-            DTypeFlat uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-          FStar_Extraction_ML_Syntax.tydecl_defn =
-            FStar_Pervasives_Native.Some
-            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-          ->
-          let name2 = ((env1.module_name), name1) in
-          let flags1 = translate_flags flags in
-          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                FStar_Compiler_List.map
-                  (fun uu___5 ->
-                     match uu___5 with
-                     | (cons, ts) ->
-                         let uu___6 =
-                           FStar_Compiler_List.map
-                             (fun uu___7 ->
-                                match uu___7 with
-                                | (name3, t) ->
-                                    let uu___8 =
-                                      let uu___9 =
-                                        translate_type_without_decay env2 t in
-                                      (uu___9, false) in
-                                    (name3, uu___8)) ts in
-                         (cons, uu___6)) branches1 in
-              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
-            DTypeVariant uu___3 in
-          FStar_Pervasives_Native.Some uu___2
-      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
-          FStar_Extraction_ML_Syntax.tydecl_name = name1;
-          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
-          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
-          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
-          ((let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.format1
-                  "Error extracting type definition %s to KaRaMeL\n" name1 in
-              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
-            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
-           FStar_Pervasives_Native.None)
-let (translate_let' :
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (match ty with
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             if
+               assumed &&
+                 (FStar_Compiler_List.mem
+                    FStar_Extraction_ML_Syntax.CAbstract flags)
+             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+             else
+               if assumed
+               then
+                 (let name3 =
+                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+                  FStar_Compiler_Util.print1_warning
+                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                    name3;
+                  FStar_Pervasives_Native.None)
+               else
+                 (let uu___4 =
+                    let uu___5 =
+                      let uu___6 = translate_flags flags in
+                      let uu___7 = translate_type env2 t in
+                      (name2, uu___6, (FStar_Compiler_List.length args),
+                        uu___7) in
+                    DTypeAlias uu___5 in
+                  FStar_Pervasives_Native.Some uu___4)
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let env2 =
+               FStar_Compiler_List.fold_left
+                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 = translate_flags flags in
+                 let uu___6 =
+                   FStar_Compiler_List.map
+                     (fun uu___7 ->
+                        match uu___7 with
+                        | (f, t) ->
+                            let uu___8 =
+                              let uu___9 = translate_type env2 t in
+                              (uu___9, false) in
+                            (f, uu___8)) fields in
+                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+               DTypeFlat uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+             FStar_Extraction_ML_Syntax.tydecl_defn =
+               FStar_Pervasives_Native.Some
+               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+             ->
+             let name2 = ((env1.module_name), name1) in
+             let flags1 = translate_flags flags in
+             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+             let uu___3 =
+               let uu___4 =
+                 let uu___5 =
+                   FStar_Compiler_List.map
+                     (fun uu___6 ->
+                        match uu___6 with
+                        | (cons, ts) ->
+                            let uu___7 =
+                              FStar_Compiler_List.map
+                                (fun uu___8 ->
+                                   match uu___8 with
+                                   | (name3, t) ->
+                                       let uu___9 =
+                                         let uu___10 = translate_type env2 t in
+                                         (uu___10, false) in
+                                       (name3, uu___9)) ts in
+                            (cons, uu___7)) branches1 in
+                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
+               DTypeVariant uu___4 in
+             FStar_Pervasives_Native.Some uu___3
+         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
+             FStar_Extraction_ML_Syntax.tydecl_name = name1;
+             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
+             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
+             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
+             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
+             ((let uu___7 =
+                 let uu___8 =
+                   FStar_Compiler_Util.format1
+                     "Error extracting type definition %s to KaRaMeL\n" name1 in
+                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
+               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
+              FStar_Pervasives_Native.None))
+let (translate_let :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
       FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
@@ -3485,29 +3320,6 @@ let (translate_let' :
                     (FStar_String.concat ", " idents) uu___6
               | FStar_Pervasives_Native.None -> ());
              FStar_Pervasives_Native.None)
-type translate_let_t =
-  env ->
-    FStar_Extraction_ML_Syntax.mlletflavor ->
-      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option
-let (ref_translate_let : translate_let_t FStar_Compiler_Effect.ref) =
-  FStar_Compiler_Util.mk_ref translate_let'
-let (register_pre_translate_let : translate_let_t -> unit) =
-  fun f ->
-    let before = FStar_Compiler_Effect.op_Bang ref_translate_let in
-    let after e fl lb =
-      try (fun uu___ -> match () with | () -> f e fl lb) ()
-      with | NotSupportedByKrmlExtension -> before e fl lb in
-    FStar_Compiler_Effect.op_Colon_Equals ref_translate_let after
-let (translate_let :
-  env ->
-    FStar_Extraction_ML_Syntax.mlletflavor ->
-      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
-  =
-  fun env1 ->
-    fun flavor ->
-      fun lb ->
-        let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_let in
-        uu___ env1 flavor lb
 let (translate_decl :
   env -> FStar_Extraction_ML_Syntax.mlmodule1 -> decl Prims.list) =
   fun env1 ->
@@ -3576,9 +3388,4 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
-let (uu___1993 : unit) =
-  register_post_translate_type_without_decay translate_type_without_decay';
-  register_post_translate_type translate_type';
-  register_post_translate_type_decl translate_type_decl';
-  register_post_translate_expr translate_expr'
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file

From e0a4da834fd48a91d1c92ca95228e12ca957f6b9 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 14:58:19 -0700
Subject: [PATCH 512/513] split off the Steel extraction rules

---
 src/Makefile.boot                             |   1 +
 .../FStar.Extraction.Krml.Steel.fst           | 191 ++++++++++++++++++
 .../FStar.Extraction.Krml.Steel.fsti          |   3 +
 src/extraction/FStar.Extraction.Krml.fst      | 128 +-----------
 4 files changed, 205 insertions(+), 118 deletions(-)
 create mode 100644 src/extraction/FStar.Extraction.Krml.Steel.fst
 create mode 100644 src/extraction/FStar.Extraction.Krml.Steel.fsti

diff --git a/src/Makefile.boot b/src/Makefile.boot
index e80aca1c630..5db72dc2920 100644
--- a/src/Makefile.boot
+++ b/src/Makefile.boot
@@ -91,6 +91,7 @@ EXTRACT = $(addprefix --extract_module , $(EXTRACT_MODULES))		\
 	$(Q)$(FSTAR_C) --dep full		\
 		fstar/FStar.Main.fst		\
 		boot/FStar.Tests.Test.fst	\
+		extraction/FStar.Extraction.Krml.Steel.fst \
 		--odir $(OUTPUT_DIRECTORY)	\
 		$(EXTRACT)			> ._depend
 	@# We've generated deps for everything into fstar-lib/generated.
diff --git a/src/extraction/FStar.Extraction.Krml.Steel.fst b/src/extraction/FStar.Extraction.Krml.Steel.fst
new file mode 100644
index 00000000000..543d3edd6ef
--- /dev/null
+++ b/src/extraction/FStar.Extraction.Krml.Steel.fst
@@ -0,0 +1,191 @@
+module FStar.Extraction.Krml.Steel
+friend FStar.Extraction.Krml
+
+(* IMPORTANT: these `open` directives come from FStar.Extraction.Krml.
+   Without them, spurious dependencies on F* ulib will be introduced *)
+open FStar.Compiler.Effect
+open FStar.Compiler.List
+open FStar
+open FStar.Compiler
+open FStar.Compiler.Util
+open FStar.Extraction
+open FStar.Extraction.ML
+open FStar.Extraction.ML.Syntax
+open FStar.Const
+open FStar.BaseTypes
+
+module BU = FStar.Compiler.Util
+module FC = FStar.Const
+
+open FStar.Extraction.Krml
+
+let steel_translate_type_without_decay : translate_type_without_decay_t = fun env t ->
+  match t with
+  | MLTY_Named ([arg], p) when
+    Syntax.string_of_mlpath p = "Steel.TLArray.t" ->
+      TConstBuf (translate_type_without_decay env arg)
+
+  | MLTY_Named ([arg], p) when
+    Syntax.string_of_mlpath p = "Steel.Reference.ref" ||
+    Syntax.string_of_mlpath p = "Steel.ST.Reference.ref" ||
+    Syntax.string_of_mlpath p = "Steel.ST.HigherArray.ptr"
+    ->
+      TBuf (translate_type_without_decay env arg)
+
+  | _ -> raise NotSupportedByKrmlExtension
+
+let steel_translate_expr : translate_expr_t = fun env e ->
+  match e.expr with
+  | MLE_App ({expr = MLE_TApp ({expr = MLE_Name p}, [t]) }, _)
+    when string_of_mlpath p = "Steel.ST.HigherArray.null_ptr"
+    ->
+    EBufNull (translate_type env t)
+  | MLE_App ({expr = MLE_TApp ({expr = MLE_Name p }, [t])}, [arg])
+    when string_of_mlpath p = "Steel.ST.HigherArray.is_null_ptr"
+    ->
+    generate_is_null (translate_type env t) (translate_expr env arg)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p}, _) }, [ _perm0; _perm1; _seq0; _seq1; e0; _len0; e1; _len1])
+    when string_of_mlpath p = "Steel.ST.HigherArray.ptrdiff_ptr" ->
+    EBufDiff (translate_expr env e0, translate_expr env e1)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
+    when string_of_mlpath p = "Steel.TLArray.get" ->
+    EBufRead (translate_expr env e1, translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _perm; e1; _len; _seq; e2 ])
+    when string_of_mlpath p = "Steel.ST.HigherArray.index_ptr" ->
+      EBufRead (translate_expr env e1, translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e ])
+    when string_of_mlpath p = "Steel.Reference.read" ->
+      EBufRead (translate_expr env e, EQualified (["C"], "_zero_for_deref"))
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _perm; _v; e ])
+    when string_of_mlpath p = "Steel.ST.Reference.read" ->
+      EBufRead (translate_expr env e, EQualified (["C"], "_zero_for_deref"))
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) } , [ init ])
+    when (
+      string_of_mlpath p = "Steel.ST.Reference._alloca"
+    ) ->
+    EBufCreate (Stack, translate_expr env init, EConstant (UInt32, "1"))
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) } , [ init ])
+    when (string_of_mlpath p = "Steel.Reference.malloc" ||
+          string_of_mlpath p = "Steel.ST.Reference.alloc") ->
+      EBufCreate (ManuallyManaged, translate_expr env init, EConstant (UInt32, "1"))
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e0; e1 ])
+    when string_of_mlpath p = "Steel.ST.HigherArray.malloc_ptr" ->
+      EBufCreate (ManuallyManaged, translate_expr env e0, translate_expr env e1)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ]) when
+      string_of_mlpath p = "Steel.Reference.free" ->
+      EBufFree (translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _v; e2 ]) when
+       string_of_mlpath p = "Steel.ST.HigherArray.free_ptr" ||
+       string_of_mlpath p = "Steel.ST.Reference.free" ->
+      EBufFree (translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
+    when string_of_mlpath p = "Steel.ST.HigherArray.ptr_shift" ->
+      EBufSub (translate_expr env e1, translate_expr env e2)
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; _len; _s; e2; e3 ])
+    when string_of_mlpath p = "Steel.ST.HigherArray.upd_ptr" ->
+      EBufWrite (translate_expr env e1, translate_expr env e2, translate_expr env e3)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; _len; _s; e2; e3 ])
+    when string_of_mlpath p = "Steel.ST.HigherArray.upd_ptr" ->
+      EBufWrite (translate_expr env e1, translate_expr env e2, translate_expr env e3)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
+    when string_of_mlpath p = "Steel.Reference.write" ->
+      EBufWrite (translate_expr env e1, EQualified (["C"], "_zero_for_deref"), translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _v; e1; e2 ])
+    when string_of_mlpath p = "Steel.ST.Reference.write" ->
+      EBufWrite (translate_expr env e1, EQualified (["C"], "_zero_for_deref"), translate_expr env e2)
+
+  | MLE_App ({ expr = MLE_Name p }, [ _ ]) when (
+        string_of_mlpath p = "Steel.ST.Reference._push_frame"
+      ) ->
+      EPushFrame
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _; _ ]) when (string_of_mlpath p = "Steel.ST.Reference._free_and_pop_frame") ->
+      EPopFrame
+
+  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _; _; _; e1; _; e2; e3; _; e4; e5 ]) when (
+      string_of_mlpath p = "Steel.ST.HigherArray.blit_ptr"
+    ) ->
+      EBufBlit (translate_expr env e1, translate_expr env e2, translate_expr env e3, translate_expr env e4, translate_expr env e5)
+
+  (* Misc. Steel operations *)
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
+    when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
+    translate_expr env e
+
+  | MLE_App ({expr=MLE_Name p}, [ _inv; test; body ])
+    when (string_of_mlpath p = "Steel.ST.Loops.while_loop") ->
+    EApp (EQualified (["Steel"; "Loops"], "while_loop"), [ EUnit; translate_expr env test; translate_expr env body ])
+
+  (* Piggyback Steel.ST.Printf primitives to LowStar.Printf *)
+  | MLE_App ({ expr = MLE_Name (["Steel"; "ST"; "Printf"], fn) }, args) ->
+        EApp (EQualified ([ "LowStar"; "Printf" ], fn), List.map (translate_expr env) args)
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
+    when string_of_mlpath p = "Steel.Effect.Atomic.return" ||
+         string_of_mlpath p = "Steel.ST.Util.return" ->
+    translate_expr env e
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_fp; _fp'; _opened; _p; _i; {expr=MLE_Fun (_, body)}])
+    when string_of_mlpath p = "Steel.ST.Util.with_invariant" ||
+         string_of_mlpath p = "Steel.Effect.Atomic.with_invariant" ->
+    translate_expr env body
+
+  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_fp; _fp'; _opened; _p; _i; e])
+    when string_of_mlpath p = "Steel.ST.Util.with_invariant" ||
+         string_of_mlpath p = "Steel.Effect.Atomic.with_invariant" ->
+    Errors.raise_error
+      (Errors.Fatal_ExtractionUnsupported,
+       BU.format2
+         "Extraction of with_invariant requires its argument to be a function literal \
+         at extraction time, try marking its argument inline_for_extraction (%s, %s)"
+         (string_of_int (fst e.loc))
+         (snd e.loc))
+      Range.dummyRange
+
+  | _ -> raise NotSupportedByKrmlExtension
+
+let steel_translate_let : translate_let_t = fun env flavor lb ->
+  match lb with
+    | {
+      mllb_name = name;
+      mllb_tysc = Some (tvars, t);
+      mllb_def = { expr = MLE_App ({
+        expr = MLE_TApp ({expr = MLE_Name p}, _)}, [ l ] ) };
+      mllb_meta = meta
+    }
+    when string_of_mlpath p = "Steel.TLArray.create" ->
+    if List.mem Syntax.NoExtract meta then
+      None
+    else
+      // This is a global const array, defined using Steel.TLArray
+      let meta = translate_flags meta in
+      let env = List.fold_left (fun env name -> extend_t env name) env tvars in
+      let t = translate_type env t in
+      let name = env.module_name, name in
+      begin try
+        let expr = List.map (translate_expr env) (list_elements l) in
+        Some (DGlobal (meta, name, List.length tvars, t, EBufCreateL (Eternal, expr)))
+      with e ->
+          Errors. log_issue Range.dummyRange (Errors.Warning_DefinitionNotTranslated, (BU.format2 "Error extracting %s to KaRaMeL (%s)\n" (Syntax.string_of_mlpath name) (BU.print_exn e)));
+          Some (DGlobal (meta, name, List.length tvars, t, EAny))
+        end
+    | _ -> raise NotSupportedByKrmlExtension
+
+let _ =
+  register_pre_translate_type_without_decay steel_translate_type_without_decay;
+  register_pre_translate_expr steel_translate_expr;
+  register_pre_translate_let steel_translate_let
diff --git a/src/extraction/FStar.Extraction.Krml.Steel.fsti b/src/extraction/FStar.Extraction.Krml.Steel.fsti
new file mode 100644
index 00000000000..b6477e00f20
--- /dev/null
+++ b/src/extraction/FStar.Extraction.Krml.Steel.fsti
@@ -0,0 +1,3 @@
+module FStar.Extraction.Krml.Steel
+
+// this fsti is necessary because we are `friend`ing FStar.Extraction.Krml
diff --git a/src/extraction/FStar.Extraction.Krml.fst b/src/extraction/FStar.Extraction.Krml.fst
index 76a0013d667..47d841aaa19 100644
--- a/src/extraction/FStar.Extraction.Krml.fst
+++ b/src/extraction/FStar.Extraction.Krml.fst
@@ -529,7 +529,8 @@ let rec translate_type_without_decay' env t: typ =
   
   | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "LowStar.ConstBuffer.const_buffer" ||
-    Syntax.string_of_mlpath p = "Steel.TLArray.t" -> TConstBuf (translate_type_without_decay env arg)
+    false
+    -> TConstBuf (translate_type_without_decay env arg)
 
   | MLTY_Named ([arg], p) when
     Syntax.string_of_mlpath p = "FStar.Buffer.buffer" ||
@@ -546,9 +547,7 @@ let rec translate_type_without_decay' env t: typ =
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.ref" ||
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmstackref" ||
     Syntax.string_of_mlpath p = "FStar.HyperStack.ST.mmref" ||
-    Syntax.string_of_mlpath p = "Steel.Reference.ref" ||
-    Syntax.string_of_mlpath p = "Steel.ST.Reference.ref" ||
-    Syntax.string_of_mlpath p = "Steel.ST.HigherArray.ptr"
+    false
     ->
       TBuf (translate_type_without_decay env arg)
   
@@ -634,14 +633,6 @@ and translate_expr' env e: expr =
 
   // We recognize certain distinguished names from [FStar.HST] and other
   // modules, and translate them into built-in Karamel constructs
-  | MLE_App ({expr = MLE_TApp ({expr = MLE_Name p}, [t]) }, _)
-    when string_of_mlpath p = "Steel.ST.HigherArray.null_ptr"
-    ->
-    EBufNull (translate_type env t)
-  | MLE_App ({expr = MLE_TApp ({expr = MLE_Name p }, [t])}, [arg])
-    when string_of_mlpath p = "Steel.ST.HigherArray.is_null_ptr"
-    ->
-    generate_is_null (translate_type env t) (translate_expr env arg)
   | MLE_App({expr=MLE_TApp ({ expr = MLE_Name p }, [t])}, [arg])
     when string_of_mlpath p = "FStar.Dyn.undyn" ->
       ECast (translate_expr env arg, translate_type env t)
@@ -671,29 +662,17 @@ and translate_expr' env e: expr =
     ->
     translate_expr env e
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p}, _) }, [ _perm0; _perm1; _seq0; _seq1; e0; _len0; e1; _len1])
-    when string_of_mlpath p = "Steel.ST.HigherArray.ptrdiff_ptr" ->
-    EBufDiff (translate_expr env e0, translate_expr env e1)
-
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
     when string_of_mlpath p = "FStar.Buffer.index" || string_of_mlpath p = "FStar.Buffer.op_Array_Access"
       || string_of_mlpath p = "LowStar.Monotonic.Buffer.index"
       || string_of_mlpath p = "LowStar.UninitializedBuffer.uindex"
       || string_of_mlpath p = "LowStar.ConstBuffer.index"
-      || string_of_mlpath p = "Steel.TLArray.get" ->
-      EBufRead (translate_expr env e1, translate_expr env e2)
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _perm; e1; _len; _seq; e2 ])
-    when string_of_mlpath p = "Steel.ST.HigherArray.index_ptr" ->
+      ->
       EBufRead (translate_expr env e1, translate_expr env e2)
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e ])
     when string_of_mlpath p = "FStar.HyperStack.ST.op_Bang"
-       || string_of_mlpath p = "Steel.Reference.read" ->
-      EBufRead (translate_expr env e, EQualified (["C"], "_zero_for_deref"))
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _perm; _v; e ])
-    when string_of_mlpath p = "Steel.ST.Reference.read" ->
+      ->
       EBufRead (translate_expr env e, EQualified (["C"], "_zero_for_deref"))
 
   (* Flatten all universes *)
@@ -721,7 +700,7 @@ and translate_expr' env e: expr =
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) } , [ init ])
     when (
       string_of_mlpath p = "FStar.HyperStack.ST.salloc" ||
-      string_of_mlpath p = "Steel.ST.Reference._alloca"
+      false
     ) ->
       EBufCreate (Stack, translate_expr env init, EConstant (UInt32, "1"))
 
@@ -772,11 +751,6 @@ and translate_expr' env e: expr =
          (string_of_mlpath p = "FStar.HyperStack.ST.ralloc_drgn_mm") ->
       EBufCreate (ManuallyManaged, translate_expr env init, EConstant (UInt32, "1"))
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) } , [ init ])
-    when (string_of_mlpath p = "Steel.Reference.malloc" ||
-          string_of_mlpath p = "Steel.ST.Reference.alloc") ->
-      EBufCreate (ManuallyManaged, translate_expr env init, EConstant (UInt32, "1"))
-
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _e0; e1; e2 ])
     when (string_of_mlpath p = "FStar.Buffer.rcreate_mm" ||
           string_of_mlpath p = "LowStar.Monotonic.Buffer.mmalloc" ||
@@ -784,11 +758,6 @@ and translate_expr' env e: expr =
           string_of_mlpath p = "LowStar.ImmutableBuffer.imalloc") ->
       EBufCreate (ManuallyManaged, translate_expr env e1, translate_expr env e2)
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e0; e1 ])
-    when string_of_mlpath p = "Steel.ST.HigherArray.malloc_ptr" ->
-      EBufCreate (ManuallyManaged, translate_expr env e0, translate_expr env e1)
-
-
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _erid; elen ])
     when string_of_mlpath p = "LowStar.UninitializedBuffer.umalloc" ->
       EBufCreateNoInit (ManuallyManaged, translate_expr env elen)
@@ -796,12 +765,7 @@ and translate_expr' env e: expr =
   (* Only manually-managed references and buffers can be freed. *)
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ]) when
       (string_of_mlpath p = "FStar.HyperStack.ST.rfree" ||
-       string_of_mlpath p = "Steel.Reference.free") ->
-      EBufFree (translate_expr env e2)
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _v; e2 ]) when
-       string_of_mlpath p = "Steel.ST.HigherArray.free_ptr" ||
-       string_of_mlpath p = "Steel.ST.Reference.free" ->
+       false) ->
       EBufFree (translate_expr env e2)
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e2 ])
@@ -823,7 +787,7 @@ and translate_expr' env e: expr =
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
     when string_of_mlpath p = "FStar.Buffer.offset"
-      || string_of_mlpath p = "Steel.ST.HigherArray.ptr_shift" ->
+      ->
       EBufSub (translate_expr env e1, translate_expr env e2)
 
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ]) when string_of_mlpath p = "LowStar.Monotonic.Buffer.moffset" ->
@@ -836,38 +800,24 @@ and translate_expr' env e: expr =
     ->
       EBufWrite (translate_expr env e1, translate_expr env e2, translate_expr env e3)
 
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; _len; _s; e2; e3 ])
-    when string_of_mlpath p = "Steel.ST.HigherArray.upd_ptr" ->
-      EBufWrite (translate_expr env e1, translate_expr env e2, translate_expr env e3)
-
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2 ])
     when string_of_mlpath p = "FStar.HyperStack.ST.op_Colon_Equals"
-      || string_of_mlpath p = "Steel.Reference.write" ->
-      EBufWrite (translate_expr env e1, EQualified (["C"], "_zero_for_deref"), translate_expr env e2)
-
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _v; e1; e2 ])
-    when string_of_mlpath p = "Steel.ST.Reference.write" ->
+      ->
       EBufWrite (translate_expr env e1, EQualified (["C"], "_zero_for_deref"), translate_expr env e2)
 
   | MLE_App ({ expr = MLE_Name p }, [ _ ]) when (
         string_of_mlpath p = "FStar.HyperStack.ST.push_frame" ||
-        string_of_mlpath p = "Steel.ST.Reference._push_frame"
+        false
       ) ->
       EPushFrame
   | MLE_App ({ expr = MLE_Name p }, [ _ ]) when (string_of_mlpath p = "FStar.HyperStack.ST.pop_frame") ->
       EPopFrame
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _; _ ]) when (string_of_mlpath p = "Steel.ST.Reference._free_and_pop_frame") ->
-      EPopFrame
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; e3; e4; e5 ]) when (
       string_of_mlpath p = "FStar.Buffer.blit" ||
       string_of_mlpath p = "LowStar.Monotonic.Buffer.blit" ||
       string_of_mlpath p = "LowStar.UninitializedBuffer.ublit"
     ) ->
       EBufBlit (translate_expr env e1, translate_expr env e2, translate_expr env e3, translate_expr env e4, translate_expr env e5)
-  | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ _; _; _; e1; _; e2; e3; _; e4; e5 ]) when (
-      string_of_mlpath p = "Steel.ST.HigherArray.blit_ptr"
-    ) ->
-      EBufBlit (translate_expr env e1, translate_expr env e2, translate_expr env e3, translate_expr env e4, translate_expr env e5)
   | MLE_App ({ expr = MLE_TApp({ expr = MLE_Name p }, _) }, [ e1; e2; e3 ])
     when (let s = string_of_mlpath p in (s = "FStar.Buffer.fill" || s = "LowStar.Monotonic.Buffer.fill" )) ->
       EBufFill (translate_expr env e1, translate_expr env e2, translate_expr env e3)
@@ -1000,11 +950,6 @@ and translate_expr' env e: expr =
       else
         EApp (EQualified ([ "FStar"; "Int"; "Cast" ], c), [ translate_expr env arg ])
         
-  (* Misc. Steel operations *)
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
-    when string_of_mlpath p = "Steel.Effect.Atomic.return" ->
-    translate_expr env e
-
   | MLE_App ({ expr = MLE_Name p }, [ arg ])
     when string_of_mlpath p = "FStar.SizeT.uint16_to_sizet" ||
          string_of_mlpath p = "FStar.SizeT.uint32_to_sizet" ||
@@ -1016,36 +961,6 @@ and translate_expr' env e: expr =
     when string_of_mlpath p = "FStar.SizeT.sizet_to_uint32" ->
       ECast (translate_expr env arg, TInt UInt32)
 
-  | MLE_App ({expr=MLE_Name p}, [ _inv; test; body ])
-    when (string_of_mlpath p = "Steel.ST.Loops.while_loop") ->
-    EApp (EQualified (["Steel"; "Loops"], "while_loop"), [ EUnit; translate_expr env test; translate_expr env body ])
-
-  (* Piggyback Steel.ST.Printf primitives to LowStar.Printf *)
-  | MLE_App ({ expr = MLE_Name (["Steel"; "ST"; "Printf"], fn) }, args) ->
-        EApp (EQualified ([ "LowStar"; "Printf" ], fn), List.map (translate_expr env) args)
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_; _; e])
-    when string_of_mlpath p = "Steel.Effect.Atomic.return" ||
-         string_of_mlpath p = "Steel.ST.Util.return" ->
-    translate_expr env e
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_fp; _fp'; _opened; _p; _i; {expr=MLE_Fun (_, body)}])
-    when string_of_mlpath p = "Steel.ST.Util.with_invariant" ||
-         string_of_mlpath p = "Steel.Effect.Atomic.with_invariant" ->
-    translate_expr env body
-
-  | MLE_App ({expr=MLE_TApp ({expr=MLE_Name p}, _)}, [_fp; _fp'; _opened; _p; _i; e])
-    when string_of_mlpath p = "Steel.ST.Util.with_invariant" ||
-         string_of_mlpath p = "Steel.Effect.Atomic.with_invariant" ->
-    Errors.raise_error
-      (Errors.Fatal_ExtractionUnsupported,
-       BU.format2
-         "Extraction of with_invariant requires its argument to be a function literal \
-         at extraction time, try marking its argument inline_for_extraction (%s, %s)"
-         (string_of_int (fst e.loc))
-         (snd e.loc))
-      Range.dummyRange
-
   | MLE_App (head, args) ->
       EApp (translate_expr env head, List.map (translate_expr env) args)
 
@@ -1308,29 +1223,6 @@ let translate_let' env flavor lb: option decl =
           Some (DFunction (cc, meta, List.length tvars, t, name, binders, EAbortS msg))
         end
 
-  | {
-      mllb_name = name;
-      mllb_tysc = Some (tvars, t);
-      mllb_def = { expr = MLE_App ({
-        expr = MLE_TApp ({expr = MLE_Name p}, _)}, [ l ] ) };
-      mllb_meta = meta
-    }
-    when string_of_mlpath p = "Steel.TLArray.create" ->
-    if List.mem Syntax.NoExtract meta then
-      None
-    else
-      // This is a global const array, defined using Steel.TLArray
-      let meta = translate_flags meta in
-      let env = List.fold_left (fun env name -> extend_t env name) env tvars in
-      let t = translate_type env t in
-      let name = env.module_name, name in
-      begin try
-        let expr = List.map (translate_expr env) (list_elements l) in
-        Some (DGlobal (meta, name, List.length tvars, t, EBufCreateL (Eternal, expr)))
-      with e ->
-          Errors. log_issue Range.dummyRange (Errors.Warning_DefinitionNotTranslated, (BU.format2 "Error extracting %s to KaRaMeL (%s)\n" (Syntax.string_of_mlpath name) (BU.print_exn e)));
-          Some (DGlobal (meta, name, List.length tvars, t, EAny))
-        end
   | {
       mllb_name = name;
       mllb_tysc = Some (tvars, t);

From 52183ffef22e299d03e3374c841974e708169ab7 Mon Sep 17 00:00:00 2001
From: Tahina Ramananandro <taramana@microsoft.com>
Date: Wed, 12 Apr 2023 15:10:33 -0700
Subject: [PATCH 513/513] snap

---
 .../generated/FStar_Extraction_Krml.ml        | 952 +++++++-----------
 .../generated/FStar_Extraction_Krml_Steel.ml  | 664 ++++++++++++
 2 files changed, 1004 insertions(+), 612 deletions(-)
 create mode 100644 ocaml/fstar-lib/generated/FStar_Extraction_Krml_Steel.ml

diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
index 8d18834a86a..2c35af96712 100644
--- a/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml.ml
@@ -17,6 +17,8 @@ type decl =
   | DTypeAbstractStruct of (Prims.string Prims.list * Prims.string) 
   | DExternal of (cc FStar_Pervasives_Native.option * flag Prims.list *
   (Prims.string Prims.list * Prims.string) * typ * Prims.string Prims.list) 
+  | DUntaggedUnion of ((Prims.string Prims.list * Prims.string) * flag
+  Prims.list * Prims.int * (Prims.string * typ) Prims.list) 
 and cc =
   | StdCall 
   | CDecl 
@@ -146,6 +148,7 @@ and typ =
   | TApp of ((Prims.string Prims.list * Prims.string) * typ Prims.list) 
   | TTuple of typ Prims.list 
   | TConstBuf of typ 
+  | TArray of (typ * (width * Prims.string)) 
 let (uu___is_DGlobal : decl -> Prims.bool) =
   fun projectee -> match projectee with | DGlobal _0 -> true | uu___ -> false
 let (__proj__DGlobal__item___0 :
@@ -212,6 +215,14 @@ let (__proj__DExternal__item___0 :
     (cc FStar_Pervasives_Native.option * flag Prims.list * (Prims.string
       Prims.list * Prims.string) * typ * Prims.string Prims.list))
   = fun projectee -> match projectee with | DExternal _0 -> _0
+let (uu___is_DUntaggedUnion : decl -> Prims.bool) =
+  fun projectee ->
+    match projectee with | DUntaggedUnion _0 -> true | uu___ -> false
+let (__proj__DUntaggedUnion__item___0 :
+  decl ->
+    ((Prims.string Prims.list * Prims.string) * flag Prims.list * Prims.int *
+      (Prims.string * typ) Prims.list))
+  = fun projectee -> match projectee with | DUntaggedUnion _0 -> _0
 let (uu___is_StdCall : cc -> Prims.bool) =
   fun projectee -> match projectee with | StdCall -> true | uu___ -> false
 let (uu___is_CDecl : cc -> Prims.bool) =
@@ -596,6 +607,10 @@ let (uu___is_TConstBuf : typ -> Prims.bool) =
     match projectee with | TConstBuf _0 -> true | uu___ -> false
 let (__proj__TConstBuf__item___0 : typ -> typ) =
   fun projectee -> match projectee with | TConstBuf _0 -> _0
+let (uu___is_TArray : typ -> Prims.bool) =
+  fun projectee -> match projectee with | TArray _0 -> true | uu___ -> false
+let (__proj__TArray__item___0 : typ -> (typ * (width * Prims.string))) =
+  fun projectee -> match projectee with | TArray _0 -> _0
 type ident = Prims.string
 type fields_t = (Prims.string * (typ * Prims.bool)) Prims.list
 type branches_t =
@@ -847,7 +862,133 @@ let (generate_is_null : typ -> expr -> expr) =
     fun x ->
       let dummy = UInt64 in
       EApp ((ETypApp ((EOp (Eq, dummy)), [TBuf t])), [x; EBufNull t])
-let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+exception NotSupportedByKrmlExtension 
+let (uu___is_NotSupportedByKrmlExtension : Prims.exn -> Prims.bool) =
+  fun projectee ->
+    match projectee with
+    | NotSupportedByKrmlExtension -> true
+    | uu___ -> false
+type translate_type_without_decay_t =
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type_without_decay :
+  translate_type_without_decay_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (register_post_translate_type_without_decay :
+  translate_type_without_decay_t -> unit) =
+  fun f ->
+    let before =
+      FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_without_decay
+      after
+let (translate_type_without_decay :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ =
+        FStar_Compiler_Effect.op_Bang ref_translate_type_without_decay in
+      uu___ env1 t
+type translate_type_t = env -> FStar_Extraction_ML_Syntax.mlty -> typ
+let (ref_translate_type : translate_type_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (register_post_translate_type : translate_type_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type after
+let (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_type in
+      uu___ env1 t
+type translate_expr_t = env -> FStar_Extraction_ML_Syntax.mlexpr -> expr
+let (ref_translate_expr : translate_expr_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (register_post_translate_expr : translate_expr_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_expr after
+let (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+  fun env1 ->
+    fun e ->
+      let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_expr in
+      uu___ env1 e
+type translate_type_decl_t =
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option
+let (ref_translate_type_decl :
+  translate_type_decl_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref
+    (fun uu___ ->
+       fun uu___1 -> FStar_Compiler_Effect.raise NotSupportedByKrmlExtension)
+let (register_pre_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> f e t) ()
+      with | NotSupportedByKrmlExtension -> before e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (register_post_translate_type_decl : translate_type_decl_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+    let after e t =
+      try (fun uu___ -> match () with | () -> before e t) ()
+      with | NotSupportedByKrmlExtension -> f e t in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_type_decl after
+let (translate_type_decl :
+  env ->
+    FStar_Extraction_ML_Syntax.one_mltydecl ->
+      decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun ty ->
+      if
+        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+          ty.FStar_Extraction_ML_Syntax.tydecl_meta
+      then FStar_Pervasives_Native.None
+      else
+        (let uu___1 = FStar_Compiler_Effect.op_Bang ref_translate_type_decl in
+         uu___1 env1 ty)
+let rec (translate_type_without_decay' :
+  env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
   fun env1 ->
     fun t ->
       match t with
@@ -857,8 +998,9 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           let uu___ = find_t env1 name1 in TBound uu___
       | FStar_Extraction_ML_Syntax.MLTY_Fun (t1, uu___, t2) ->
           let uu___1 =
-            let uu___2 = translate_type env1 t1 in
-            let uu___3 = translate_type env1 t2 in (uu___2, uu___3) in
+            let uu___2 = translate_type_without_decay env1 t1 in
+            let uu___3 = translate_type_without_decay env1 t2 in
+            (uu___2, uu___3) in
           TArrow uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Erased -> TUnit
       | FStar_Extraction_ML_Syntax.MLTY_Named ([], p) when
@@ -888,7 +1030,8 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___2 = "FStar.HyperStack.ST.s_mref")
-          -> let uu___2 = translate_type env1 arg in TBuf uu___2
+          ->
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::[], p) when
           ((((((((((let uu___1 =
                       FStar_Extraction_ML_Syntax.string_of_mlpath p in
@@ -925,87 +1068,80 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
             ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.mmmref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::uu___::uu___1::[], p)
           when
           let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___2 = "LowStar.Monotonic.Buffer.mbuffer" ->
-          let uu___2 = translate_type env1 arg in TBuf uu___2
+          let uu___2 = translate_type_without_decay env1 arg in TBuf uu___2
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___ = "LowStar.ConstBuffer.const_buffer") ||
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.TLArray.t")
-          -> let uu___ = translate_type env1 arg in TConstBuf uu___
+           uu___ = "LowStar.ConstBuffer.const_buffer") || false
+          ->
+          let uu___ = translate_type_without_decay env1 arg in
+          TConstBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
-          ((((((((((((((((let uu___ =
-                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                          uu___ = "FStar.Buffer.buffer") ||
-                           (let uu___ =
-                              FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                            uu___ = "LowStar.Buffer.buffer"))
-                          ||
-                          (let uu___ =
-                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                           uu___ = "LowStar.ImmutableBuffer.ibuffer"))
-                         ||
+          ((((((((((((((let uu___ =
+                          FStar_Extraction_ML_Syntax.string_of_mlpath p in
+                        uu___ = "FStar.Buffer.buffer") ||
                          (let uu___ =
                             FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                          uu___ = "LowStar.UninitializedBuffer.ubuffer"))
+                          uu___ = "LowStar.Buffer.buffer"))
                         ||
                         (let uu___ =
                            FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                         uu___ = "FStar.HyperStack.reference"))
+                         uu___ = "LowStar.ImmutableBuffer.ibuffer"))
                        ||
                        (let uu___ =
                           FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                        uu___ = "FStar.HyperStack.stackref"))
+                        uu___ = "LowStar.UninitializedBuffer.ubuffer"))
                       ||
                       (let uu___ =
                          FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                       uu___ = "FStar.HyperStack.ref"))
+                       uu___ = "FStar.HyperStack.reference"))
                      ||
                      (let uu___ =
                         FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                      uu___ = "FStar.HyperStack.mmstackref"))
+                      uu___ = "FStar.HyperStack.stackref"))
                     ||
                     (let uu___ =
                        FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                     uu___ = "FStar.HyperStack.mmref"))
+                     uu___ = "FStar.HyperStack.ref"))
                    ||
                    (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                    uu___ = "FStar.HyperStack.ST.reference"))
+                    uu___ = "FStar.HyperStack.mmstackref"))
                   ||
                   (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                   uu___ = "FStar.HyperStack.ST.stackref"))
+                   uu___ = "FStar.HyperStack.mmref"))
                  ||
                  (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                  uu___ = "FStar.HyperStack.ST.ref"))
+                  uu___ = "FStar.HyperStack.ST.reference"))
                 ||
                 (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___ = "FStar.HyperStack.ST.mmstackref"))
+                 uu___ = "FStar.HyperStack.ST.stackref"))
                ||
                (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___ = "FStar.HyperStack.ST.mmref"))
+                uu___ = "FStar.HyperStack.ST.ref"))
               ||
               (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___ = "Steel.Reference.ref"))
+               uu___ = "FStar.HyperStack.ST.mmstackref"))
              ||
              (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___ = "Steel.ST.Reference.ref"))
-            ||
-            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___ = "Steel.ST.HigherArray.ptr")
-          -> let uu___ = translate_type env1 arg in TBuf uu___
+              uu___ = "FStar.HyperStack.ST.mmref"))
+            || false
+          -> let uu___ = translate_type_without_decay env1 arg in TBuf uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::arg::[], p) when
           (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
            uu___1 = "FStar.HyperStack.s_ref") ||
             (let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___1 = "FStar.HyperStack.ST.s_ref")
-          -> let uu___1 = translate_type env1 arg in TBuf uu___1
+          ->
+          let uu___1 = translate_type_without_decay env1 arg in TBuf uu___1
       | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
           let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___ = "FStar.Universe.raise_t" -> translate_type env1 arg
+          uu___ = "FStar.Universe.raise_t" ->
+          translate_type_without_decay env1 arg
       | FStar_Extraction_ML_Syntax.MLTY_Named (uu___::[], p) when
           let uu___1 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___1 = "FStar.Ghost.erased" -> TAny
@@ -1015,19 +1151,26 @@ let rec (translate_type : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
           ((ns = ["Prims"]) || (ns = ["FStar"; "Pervasives"; "Native"])) &&
             (FStar_Compiler_Util.starts_with t1 "tuple")
           ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) args in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) args in
           TTuple uu___
       | FStar_Extraction_ML_Syntax.MLTY_Named (args, lid) ->
           if (FStar_Compiler_List.length args) > Prims.int_zero
           then
             let uu___ =
-              let uu___1 = FStar_Compiler_List.map (translate_type env1) args in
+              let uu___1 =
+                FStar_Compiler_List.map (translate_type_without_decay env1)
+                  args in
               (lid, uu___1) in
             TApp uu___
           else TQualified lid
       | FStar_Extraction_ML_Syntax.MLTY_Tuple ts ->
-          let uu___ = FStar_Compiler_List.map (translate_type env1) ts in
+          let uu___ =
+            FStar_Compiler_List.map (translate_type_without_decay env1) ts in
           TTuple uu___
+and (translate_type' : env -> FStar_Extraction_ML_Syntax.mlty -> typ) =
+  fun env1 ->
+    fun t -> match t with | t1 -> translate_type_without_decay env1 t1
 and (translate_binders :
   env ->
     (Prims.string * FStar_Extraction_ML_Syntax.mlty) Prims.list ->
@@ -1043,7 +1186,7 @@ and (translate_binder :
       | (name1, typ1) ->
           let uu___1 = translate_type env1 typ1 in
           { name = name1; typ = uu___1; mut = false }
-and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
+and (translate_expr' : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
   fun env1 ->
     fun e ->
       match e.FStar_Extraction_ML_Syntax.expr with
@@ -1089,42 +1232,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___2 = translate_branches env1 branches1 in
             (uu___1, uu___2) in
           EMatch uu___
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           uu___4)
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.null_ptr" ->
-          let uu___5 = translate_type env1 t in EBufNull uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                t::[]);
-             FStar_Extraction_ML_Syntax.mlty = uu___2;
-             FStar_Extraction_ML_Syntax.loc = uu___3;_},
-           arg::[])
-          when
-          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___4 = "Steel.ST.HigherArray.is_null_ptr" ->
-          let uu___4 = translate_type env1 t in
-          let uu___5 = translate_expr env1 arg in
-          generate_is_null uu___4 uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1243,26 +1350,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
              uu___5 = "LowStar.ToFStarBuffer.old_to_new_st")
           -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _perm0::_perm1::_seq0::_seq1::e0::_len0::e1::_len1::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.ptrdiff_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e0 in
-            let uu___7 = translate_expr env1 e1 in (uu___6, uu___7) in
-          EBufDiff uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1277,47 +1364,24 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e1::e2::[])
           when
-          (((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "FStar.Buffer.index") ||
-                (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                 uu___5 = "FStar.Buffer.op_Array_Access"))
-               ||
+          ((((let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___5 = "FStar.Buffer.index") ||
                (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-                uu___5 = "LowStar.Monotonic.Buffer.index"))
+                uu___5 = "FStar.Buffer.op_Array_Access"))
               ||
               (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-               uu___5 = "LowStar.UninitializedBuffer.uindex"))
+               uu___5 = "LowStar.Monotonic.Buffer.index"))
              ||
              (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-              uu___5 = "LowStar.ConstBuffer.index"))
+              uu___5 = "LowStar.UninitializedBuffer.uindex"))
             ||
             (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.TLArray.get")
+             uu___5 = "LowStar.ConstBuffer.index")
           ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
             let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
           EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _perm::e1::_len::_seq::e2::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.index_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
-          EBufRead uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1332,31 +1396,8 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e1::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.op_Bang") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.read")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            (uu___6, (EQualified (["C"], "_zero_for_deref"))) in
-          EBufRead uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _perm::_v::e1::[])
-          when
           let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.Reference.read" ->
+          uu___5 = "FStar.HyperStack.ST.op_Bang" ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
             (uu___6, (EQualified (["C"], "_zero_for_deref"))) in
@@ -1453,9 +1494,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            init::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.salloc") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.Reference._alloca")
+           uu___5 = "FStar.HyperStack.ST.salloc") || false
           ->
           let uu___5 =
             let uu___6 = translate_expr env1 init in
@@ -1638,29 +1677,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___6 = translate_expr env1 init in
             (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           init::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.Reference.malloc") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.Reference.alloc")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 init in
-            (ManuallyManaged, uu___6, (EConstant (UInt32, "1"))) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1691,27 +1707,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             (ManuallyManaged, uu___6, uu___7) in
           EBufCreate uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e0::e1::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.malloc_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e0 in
-            let uu___7 = translate_expr env1 e1 in
-            (ManuallyManaged, uu___6, uu___7) in
-          EBufCreate uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1747,28 +1742,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            e2::[])
           when
           (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.rfree") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.free")
-          -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _v::e2::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.ST.HigherArray.free_ptr") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.Reference.free")
+           uu___5 = "FStar.HyperStack.ST.rfree") || false
           -> let uu___5 = translate_expr env1 e2 in EBufFree uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -1862,11 +1836,8 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e1::e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.Buffer.offset") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.ST.HigherArray.ptr_shift")
-          ->
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "FStar.Buffer.offset" ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
             let uu___7 = translate_expr env1 e2 in (uu___6, uu___7) in
@@ -1921,27 +1892,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___7 = translate_expr env1 e2 in
             let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
           EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           e1::_len::_s::e2::e3::[])
-          when
-          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.HigherArray.upd_ptr" ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            let uu___8 = translate_expr env1 e3 in (uu___6, uu___7, uu___8) in
-          EBufWrite uu___5
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -1956,32 +1906,8 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
              FStar_Extraction_ML_Syntax.loc = uu___4;_},
            e1::e2::[])
           when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "FStar.HyperStack.ST.op_Colon_Equals") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Reference.write")
-          ->
-          let uu___5 =
-            let uu___6 = translate_expr env1 e1 in
-            let uu___7 = translate_expr env1 e2 in
-            (uu___6, (EQualified (["C"], "_zero_for_deref")), uu___7) in
-          EBufWrite uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _v::e1::e2::[])
-          when
           let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___5 = "Steel.ST.Reference.write" ->
+          uu___5 = "FStar.HyperStack.ST.op_Colon_Equals" ->
           let uu___5 =
             let uu___6 = translate_expr env1 e1 in
             let uu___7 = translate_expr env1 e2 in
@@ -1996,9 +1922,7 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
            uu___2::[])
           when
           (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___3 = "FStar.HyperStack.ST.push_frame") ||
-            (let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___3 = "Steel.ST.Reference._push_frame")
+           uu___3 = "FStar.HyperStack.ST.push_frame") || false
           -> EPushFrame
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
@@ -2010,22 +1934,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
           when
           let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
           uu___3 = "FStar.HyperStack.ST.pop_frame" -> EPopFrame
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::[])
-          when
-          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___7 = "Steel.ST.Reference._free_and_pop_frame" -> EPopFrame
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2056,30 +1964,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
             let uu___10 = translate_expr env1 e5 in
             (uu___6, uu___7, uu___8, uu___9, uu___10) in
           EBufBlit uu___5
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::uu___7::e1::uu___8::e2::e3::uu___9::e4::e5::[])
-          when
-          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___10 = "Steel.ST.HigherArray.blit_ptr" ->
-          let uu___10 =
-            let uu___11 = translate_expr env1 e1 in
-            let uu___12 = translate_expr env1 e2 in
-            let uu___13 = translate_expr env1 e3 in
-            let uu___14 = translate_expr env1 e4 in
-            let uu___15 = translate_expr env1 e5 in
-            (uu___11, uu___12, uu___13, uu___14, uu___15) in
-          EBufBlit uu___10
       | FStar_Extraction_ML_Syntax.MLE_App
           ({
              FStar_Extraction_ML_Syntax.expr =
@@ -2549,116 +2433,6 @@ and (translate_expr : env -> FStar_Extraction_ML_Syntax.mlexpr -> expr) =
           let uu___2 =
             let uu___3 = translate_expr env1 arg in (uu___3, (TInt UInt32)) in
           ECast uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name p;
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           _inv::test::body::[])
-          when
-          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-          uu___2 = "Steel.ST.Loops.while_loop" ->
-          let uu___2 =
-            let uu___3 =
-              let uu___4 =
-                let uu___5 = translate_expr env1 test in
-                let uu___6 =
-                  let uu___7 = translate_expr env1 body in [uu___7] in
-                uu___5 :: uu___6 in
-              EUnit :: uu___4 in
-            ((EQualified (["Steel"; "Loops"], "while_loop")), uu___3) in
-          EApp uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_Name
-               ("Steel"::"ST"::"Printf"::[], fn);
-             FStar_Extraction_ML_Syntax.mlty = uu___;
-             FStar_Extraction_ML_Syntax.loc = uu___1;_},
-           args)
-          ->
-          let uu___2 =
-            let uu___3 = FStar_Compiler_List.map (translate_expr env1) args in
-            ((EQualified (["LowStar"; "Printf"], fn)), uu___3) in
-          EApp uu___2
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           uu___5::uu___6::e1::[])
-          when
-          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___7 = "Steel.Effect.Atomic.return") ||
-            (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___7 = "Steel.ST.Util.return")
-          -> translate_expr env1 e1
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _fp::_fp'::_opened::_p::_i::{
-                                         FStar_Extraction_ML_Syntax.expr =
-                                           FStar_Extraction_ML_Syntax.MLE_Fun
-                                           (uu___5, body);
-                                         FStar_Extraction_ML_Syntax.mlty =
-                                           uu___6;
-                                         FStar_Extraction_ML_Syntax.loc =
-                                           uu___7;_}::[])
-          when
-          (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___8 = "Steel.ST.Util.with_invariant") ||
-            (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___8 = "Steel.Effect.Atomic.with_invariant")
-          -> translate_expr env1 body
-      | FStar_Extraction_ML_Syntax.MLE_App
-          ({
-             FStar_Extraction_ML_Syntax.expr =
-               FStar_Extraction_ML_Syntax.MLE_TApp
-               ({
-                  FStar_Extraction_ML_Syntax.expr =
-                    FStar_Extraction_ML_Syntax.MLE_Name p;
-                  FStar_Extraction_ML_Syntax.mlty = uu___;
-                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
-                uu___2);
-             FStar_Extraction_ML_Syntax.mlty = uu___3;
-             FStar_Extraction_ML_Syntax.loc = uu___4;_},
-           _fp::_fp'::_opened::_p::_i::e1::[])
-          when
-          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-           uu___5 = "Steel.ST.Util.with_invariant") ||
-            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-             uu___5 = "Steel.Effect.Atomic.with_invariant")
-          ->
-          let uu___5 =
-            let uu___6 =
-              let uu___7 =
-                FStar_Compiler_Util.string_of_int
-                  (FStar_Pervasives_Native.fst
-                     e1.FStar_Extraction_ML_Syntax.loc) in
-              FStar_Compiler_Util.format2
-                "Extraction of with_invariant requires its argument to be a function literal at extraction time, try marking its argument inline_for_extraction (%s, %s)"
-                uu___7
-                (FStar_Pervasives_Native.snd
-                   e1.FStar_Extraction_ML_Syntax.loc) in
-            (FStar_Errors_Codes.Fatal_ExtractionUnsupported, uu___6) in
-          FStar_Errors.raise_error uu___5 FStar_Compiler_Range.dummyRange
       | FStar_Extraction_ML_Syntax.MLE_App (head, args) ->
           let uu___ =
             let uu___1 = translate_expr env1 head in
@@ -2927,129 +2701,123 @@ and (mk_op_app :
             let uu___1 = FStar_Compiler_List.map (translate_expr env1) args in
             ((EOp (op1, w)), uu___1) in
           EApp uu___
-let (translate_type_decl :
+let (translate_type_decl' :
   env ->
     FStar_Extraction_ML_Syntax.one_mltydecl ->
       decl FStar_Pervasives_Native.option)
   =
   fun env1 ->
     fun ty ->
-      if
-        FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-          ty.FStar_Extraction_ML_Syntax.tydecl_meta
-      then FStar_Pervasives_Native.None
-      else
-        (match ty with
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             if
-               assumed &&
-                 (FStar_Compiler_List.mem
-                    FStar_Extraction_ML_Syntax.CAbstract flags)
-             then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
-             else
-               if assumed
-               then
-                 (let name3 =
-                    FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                  FStar_Compiler_Util.print1_warning
-                    "Not extracting type definition %s to KaRaMeL (assumed type)\n"
-                    name3;
-                  FStar_Pervasives_Native.None)
-               else
-                 (let uu___4 =
-                    let uu___5 =
-                      let uu___6 = translate_flags flags in
-                      let uu___7 = translate_type env2 t in
-                      (name2, uu___6, (FStar_Compiler_List.length args),
-                        uu___7) in
-                    DTypeAlias uu___5 in
-                  FStar_Pervasives_Native.Some uu___4)
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let env2 =
-               FStar_Compiler_List.fold_left
-                 (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 = translate_flags flags in
-                 let uu___6 =
-                   FStar_Compiler_List.map
-                     (fun uu___7 ->
-                        match uu___7 with
-                        | (f, t) ->
-                            let uu___8 =
-                              let uu___9 = translate_type env2 t in
-                              (uu___9, false) in
-                            (f, uu___8)) fields in
-                 (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
-               DTypeFlat uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = args;
-             FStar_Extraction_ML_Syntax.tydecl_meta = flags;
-             FStar_Extraction_ML_Syntax.tydecl_defn =
-               FStar_Pervasives_Native.Some
-               (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
-             ->
-             let name2 = ((env1.module_name), name1) in
-             let flags1 = translate_flags flags in
-             let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
-             let uu___3 =
-               let uu___4 =
-                 let uu___5 =
-                   FStar_Compiler_List.map
-                     (fun uu___6 ->
-                        match uu___6 with
-                        | (cons, ts) ->
-                            let uu___7 =
-                              FStar_Compiler_List.map
-                                (fun uu___8 ->
-                                   match uu___8 with
-                                   | (name3, t) ->
-                                       let uu___9 =
-                                         let uu___10 = translate_type env2 t in
-                                         (uu___10, false) in
-                                       (name3, uu___9)) ts in
-                            (cons, uu___7)) branches1 in
-                 (name2, flags1, (FStar_Compiler_List.length args), uu___5) in
-               DTypeVariant uu___4 in
-             FStar_Pervasives_Native.Some uu___3
-         | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___1;
-             FStar_Extraction_ML_Syntax.tydecl_name = name1;
-             FStar_Extraction_ML_Syntax.tydecl_ignored = uu___2;
-             FStar_Extraction_ML_Syntax.tydecl_parameters = uu___3;
-             FStar_Extraction_ML_Syntax.tydecl_meta = uu___4;
-             FStar_Extraction_ML_Syntax.tydecl_defn = uu___5;_} ->
-             ((let uu___7 =
-                 let uu___8 =
-                   FStar_Compiler_Util.format1
-                     "Error extracting type definition %s to KaRaMeL\n" name1 in
-                 (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___8) in
-               FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___7);
-              FStar_Pervasives_Native.None))
-let (translate_let :
+      match ty with
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = assumed;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Abbrev t);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          if
+            assumed &&
+              (FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.CAbstract
+                 flags)
+          then FStar_Pervasives_Native.Some (DTypeAbstractStruct name2)
+          else
+            if assumed
+            then
+              (let name3 = FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
+               FStar_Compiler_Util.print1_warning
+                 "Not extracting type definition %s to KaRaMeL (assumed type)\n"
+                 name3;
+               FStar_Pervasives_Native.None)
+            else
+              (let uu___3 =
+                 let uu___4 =
+                   let uu___5 = translate_flags flags in
+                   let uu___6 = translate_type env2 t in
+                   (name2, uu___5, (FStar_Compiler_List.length args), uu___6) in
+                 DTypeAlias uu___4 in
+               FStar_Pervasives_Native.Some uu___3)
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_Record fields);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let env2 =
+            FStar_Compiler_List.fold_left
+              (fun env3 -> fun name3 -> extend_t env3 name3) env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 = translate_flags flags in
+              let uu___5 =
+                FStar_Compiler_List.map
+                  (fun uu___6 ->
+                     match uu___6 with
+                     | (f, t) ->
+                         let uu___7 =
+                           let uu___8 = translate_type_without_decay env2 t in
+                           (uu___8, false) in
+                         (f, uu___7)) fields in
+              (name2, uu___4, (FStar_Compiler_List.length args), uu___5) in
+            DTypeFlat uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = args;
+          FStar_Extraction_ML_Syntax.tydecl_meta = flags;
+          FStar_Extraction_ML_Syntax.tydecl_defn =
+            FStar_Pervasives_Native.Some
+            (FStar_Extraction_ML_Syntax.MLTD_DType branches1);_}
+          ->
+          let name2 = ((env1.module_name), name1) in
+          let flags1 = translate_flags flags in
+          let env2 = FStar_Compiler_List.fold_left extend_t env1 args in
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                FStar_Compiler_List.map
+                  (fun uu___5 ->
+                     match uu___5 with
+                     | (cons, ts) ->
+                         let uu___6 =
+                           FStar_Compiler_List.map
+                             (fun uu___7 ->
+                                match uu___7 with
+                                | (name3, t) ->
+                                    let uu___8 =
+                                      let uu___9 =
+                                        translate_type_without_decay env2 t in
+                                      (uu___9, false) in
+                                    (name3, uu___8)) ts in
+                         (cons, uu___6)) branches1 in
+              (name2, flags1, (FStar_Compiler_List.length args), uu___4) in
+            DTypeVariant uu___3 in
+          FStar_Pervasives_Native.Some uu___2
+      | { FStar_Extraction_ML_Syntax.tydecl_assumed = uu___;
+          FStar_Extraction_ML_Syntax.tydecl_name = name1;
+          FStar_Extraction_ML_Syntax.tydecl_ignored = uu___1;
+          FStar_Extraction_ML_Syntax.tydecl_parameters = uu___2;
+          FStar_Extraction_ML_Syntax.tydecl_meta = uu___3;
+          FStar_Extraction_ML_Syntax.tydecl_defn = uu___4;_} ->
+          ((let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.format1
+                  "Error extracting type definition %s to KaRaMeL\n" name1 in
+              (FStar_Errors_Codes.Warning_DefinitionNotTranslated, uu___7) in
+            FStar_Errors.log_issue FStar_Compiler_Range.dummyRange uu___6);
+           FStar_Pervasives_Native.None)
+let (translate_let' :
   env ->
     FStar_Extraction_ML_Syntax.mlletflavor ->
       FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
@@ -3185,74 +2953,6 @@ let (translate_let :
                                 (cc1, meta1,
                                   (FStar_Compiler_List.length tvars), t1,
                                   name2, binders, (EAbortS msg1))))))))
-        | { FStar_Extraction_ML_Syntax.mllb_name = name1;
-            FStar_Extraction_ML_Syntax.mllb_tysc =
-              FStar_Pervasives_Native.Some (tvars, t);
-            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
-            FStar_Extraction_ML_Syntax.mllb_def =
-              {
-                FStar_Extraction_ML_Syntax.expr =
-                  FStar_Extraction_ML_Syntax.MLE_App
-                  ({
-                     FStar_Extraction_ML_Syntax.expr =
-                       FStar_Extraction_ML_Syntax.MLE_TApp
-                       ({
-                          FStar_Extraction_ML_Syntax.expr =
-                            FStar_Extraction_ML_Syntax.MLE_Name p;
-                          FStar_Extraction_ML_Syntax.mlty = uu___1;
-                          FStar_Extraction_ML_Syntax.loc = uu___2;_},
-                        uu___3);
-                     FStar_Extraction_ML_Syntax.mlty = uu___4;
-                     FStar_Extraction_ML_Syntax.loc = uu___5;_},
-                   l::[]);
-                FStar_Extraction_ML_Syntax.mlty = uu___6;
-                FStar_Extraction_ML_Syntax.loc = uu___7;_};
-            FStar_Extraction_ML_Syntax.mllb_meta = meta;
-            FStar_Extraction_ML_Syntax.print_typ = uu___8;_} when
-            let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
-            uu___9 = "Steel.TLArray.create" ->
-            if
-              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
-                meta
-            then FStar_Pervasives_Native.None
-            else
-              (let meta1 = translate_flags meta in
-               let env2 =
-                 FStar_Compiler_List.fold_left
-                   (fun env3 -> fun name2 -> extend_t env3 name2) env1 tvars in
-               let t1 = translate_type env2 t in
-               let name2 = ((env2.module_name), name1) in
-               try
-                 (fun uu___10 ->
-                    match () with
-                    | () ->
-                        let expr1 =
-                          let uu___11 = list_elements l in
-                          FStar_Compiler_List.map (translate_expr env2)
-                            uu___11 in
-                        FStar_Pervasives_Native.Some
-                          (DGlobal
-                             (meta1, name2,
-                               (FStar_Compiler_List.length tvars), t1,
-                               (EBufCreateL (Eternal, expr1))))) ()
-               with
-               | uu___10 ->
-                   ((let uu___12 =
-                       let uu___13 =
-                         let uu___14 =
-                           FStar_Extraction_ML_Syntax.string_of_mlpath name2 in
-                         let uu___15 = FStar_Compiler_Util.print_exn uu___10 in
-                         FStar_Compiler_Util.format2
-                           "Error extracting %s to KaRaMeL (%s)\n" uu___14
-                           uu___15 in
-                       (FStar_Errors_Codes.Warning_DefinitionNotTranslated,
-                         uu___13) in
-                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
-                       uu___12);
-                    FStar_Pervasives_Native.Some
-                      (DGlobal
-                         (meta1, name2, (FStar_Compiler_List.length tvars),
-                           t1, EAny))))
         | { FStar_Extraction_ML_Syntax.mllb_name = name1;
             FStar_Extraction_ML_Syntax.mllb_tysc =
               FStar_Pervasives_Native.Some (tvars, t);
@@ -3320,6 +3020,29 @@ let (translate_let :
                     (FStar_String.concat ", " idents) uu___6
               | FStar_Pervasives_Native.None -> ());
              FStar_Pervasives_Native.None)
+type translate_let_t =
+  env ->
+    FStar_Extraction_ML_Syntax.mlletflavor ->
+      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option
+let (ref_translate_let : translate_let_t FStar_Compiler_Effect.ref) =
+  FStar_Compiler_Util.mk_ref translate_let'
+let (register_pre_translate_let : translate_let_t -> unit) =
+  fun f ->
+    let before = FStar_Compiler_Effect.op_Bang ref_translate_let in
+    let after e fl lb =
+      try (fun uu___ -> match () with | () -> f e fl lb) ()
+      with | NotSupportedByKrmlExtension -> before e fl lb in
+    FStar_Compiler_Effect.op_Colon_Equals ref_translate_let after
+let (translate_let :
+  env ->
+    FStar_Extraction_ML_Syntax.mlletflavor ->
+      FStar_Extraction_ML_Syntax.mllb -> decl FStar_Pervasives_Native.option)
+  =
+  fun env1 ->
+    fun flavor ->
+      fun lb ->
+        let uu___ = FStar_Compiler_Effect.op_Bang ref_translate_let in
+        uu___ env1 flavor lb
 let (translate_decl :
   env -> FStar_Extraction_ML_Syntax.mlmodule1 -> decl Prims.list) =
   fun env1 ->
@@ -3388,4 +3111,9 @@ let (translate : FStar_Extraction_ML_Syntax.mllib -> file Prims.list) =
                    FStar_Compiler_Util.print2
                      "Unable to translate module: %s because:\n  %s\n" m_name
                      uu___3);
-                  FStar_Pervasives_Native.None)) modules
\ No newline at end of file
+                  FStar_Pervasives_Native.None)) modules
+let (uu___1713 : unit) =
+  register_post_translate_type_without_decay translate_type_without_decay';
+  register_post_translate_type translate_type';
+  register_post_translate_type_decl translate_type_decl';
+  register_post_translate_expr translate_expr'
\ No newline at end of file
diff --git a/ocaml/fstar-lib/generated/FStar_Extraction_Krml_Steel.ml b/ocaml/fstar-lib/generated/FStar_Extraction_Krml_Steel.ml
new file mode 100644
index 00000000000..cb9afa780da
--- /dev/null
+++ b/ocaml/fstar-lib/generated/FStar_Extraction_Krml_Steel.ml
@@ -0,0 +1,664 @@
+open Prims
+let (steel_translate_type_without_decay :
+  FStar_Extraction_Krml.translate_type_without_decay_t) =
+  fun env ->
+    fun t ->
+      match t with
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___ = "Steel.TLArray.t" ->
+          let uu___ =
+            FStar_Extraction_Krml.translate_type_without_decay env arg in
+          FStar_Extraction_Krml.TConstBuf uu___
+      | FStar_Extraction_ML_Syntax.MLTY_Named (arg::[], p) when
+          ((let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___ = "Steel.Reference.ref") ||
+             (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+              uu___ = "Steel.ST.Reference.ref"))
+            ||
+            (let uu___ = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___ = "Steel.ST.HigherArray.ptr")
+          ->
+          let uu___ =
+            FStar_Extraction_Krml.translate_type_without_decay env arg in
+          FStar_Extraction_Krml.TBuf uu___
+      | uu___ ->
+          FStar_Compiler_Effect.raise
+            FStar_Extraction_Krml.NotSupportedByKrmlExtension
+let (steel_translate_expr : FStar_Extraction_Krml.translate_expr_t) =
+  fun env ->
+    fun e ->
+      match e.FStar_Extraction_ML_Syntax.expr with
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           uu___4)
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.null_ptr" ->
+          let uu___5 = FStar_Extraction_Krml.translate_type env t in
+          FStar_Extraction_Krml.EBufNull uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                t::[]);
+             FStar_Extraction_ML_Syntax.mlty = uu___2;
+             FStar_Extraction_ML_Syntax.loc = uu___3;_},
+           arg::[])
+          when
+          let uu___4 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___4 = "Steel.ST.HigherArray.is_null_ptr" ->
+          let uu___4 = FStar_Extraction_Krml.translate_type env t in
+          let uu___5 = FStar_Extraction_Krml.translate_expr env arg in
+          FStar_Extraction_Krml.generate_is_null uu___4 uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _perm0::_perm1::_seq0::_seq1::e0::_len0::e1::_len1::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.ptrdiff_ptr" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e0 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e1 in
+            (uu___6, uu___7) in
+          FStar_Extraction_Krml.EBufDiff uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.TLArray.get" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            (uu___6, uu___7) in
+          FStar_Extraction_Krml.EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _perm::e1::_len::_seq::e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.index_ptr" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            (uu___6, uu___7) in
+          FStar_Extraction_Krml.EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.Reference.read" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            (uu___6,
+              (FStar_Extraction_Krml.EQualified (["C"], "_zero_for_deref"))) in
+          FStar_Extraction_Krml.EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _perm::_v::e1::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Reference.read" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            (uu___6,
+              (FStar_Extraction_Krml.EQualified (["C"], "_zero_for_deref"))) in
+          FStar_Extraction_Krml.EBufRead uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           init::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Reference._alloca" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env init in
+            (FStar_Extraction_Krml.Stack, uu___6,
+              (FStar_Extraction_Krml.EConstant
+                 (FStar_Extraction_Krml.UInt32, "1"))) in
+          FStar_Extraction_Krml.EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           init::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.Reference.malloc") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.ST.Reference.alloc")
+          ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env init in
+            (FStar_Extraction_Krml.ManuallyManaged, uu___6,
+              (FStar_Extraction_Krml.EConstant
+                 (FStar_Extraction_Krml.UInt32, "1"))) in
+          FStar_Extraction_Krml.EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e0::e1::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.malloc_ptr" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e0 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e1 in
+            (FStar_Extraction_Krml.ManuallyManaged, uu___6, uu___7) in
+          FStar_Extraction_Krml.EBufCreate uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.Reference.free" ->
+          let uu___5 = FStar_Extraction_Krml.translate_expr env e2 in
+          FStar_Extraction_Krml.EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _v::e2::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.ST.HigherArray.free_ptr") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.ST.Reference.free")
+          ->
+          let uu___5 = FStar_Extraction_Krml.translate_expr env e2 in
+          FStar_Extraction_Krml.EBufFree uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.ptr_shift" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            (uu___6, uu___7) in
+          FStar_Extraction_Krml.EBufSub uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::_len::_s::e2::e3::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.upd_ptr" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            let uu___8 = FStar_Extraction_Krml.translate_expr env e3 in
+            (uu___6, uu___7, uu___8) in
+          FStar_Extraction_Krml.EBufWrite uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::_len::_s::e2::e3::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.HigherArray.upd_ptr" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            let uu___8 = FStar_Extraction_Krml.translate_expr env e3 in
+            (uu___6, uu___7, uu___8) in
+          FStar_Extraction_Krml.EBufWrite uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           e1::e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.Reference.write" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            (uu___6,
+              (FStar_Extraction_Krml.EQualified (["C"], "_zero_for_deref")),
+              uu___7) in
+          FStar_Extraction_Krml.EBufWrite uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _v::e1::e2::[])
+          when
+          let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___5 = "Steel.ST.Reference.write" ->
+          let uu___5 =
+            let uu___6 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___7 = FStar_Extraction_Krml.translate_expr env e2 in
+            (uu___6,
+              (FStar_Extraction_Krml.EQualified (["C"], "_zero_for_deref")),
+              uu___7) in
+          FStar_Extraction_Krml.EBufWrite uu___5
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           uu___2::[])
+          when
+          let uu___3 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___3 = "Steel.ST.Reference._push_frame" ->
+          FStar_Extraction_Krml.EPushFrame
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.ST.Reference._free_and_pop_frame" ->
+          FStar_Extraction_Krml.EPopFrame
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::uu___7::e1::uu___8::e2::e3::uu___9::e4::e5::[])
+          when
+          let uu___10 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___10 = "Steel.ST.HigherArray.blit_ptr" ->
+          let uu___10 =
+            let uu___11 = FStar_Extraction_Krml.translate_expr env e1 in
+            let uu___12 = FStar_Extraction_Krml.translate_expr env e2 in
+            let uu___13 = FStar_Extraction_Krml.translate_expr env e3 in
+            let uu___14 = FStar_Extraction_Krml.translate_expr env e4 in
+            let uu___15 = FStar_Extraction_Krml.translate_expr env e5 in
+            (uu___11, uu___12, uu___13, uu___14, uu___15) in
+          FStar_Extraction_Krml.EBufBlit uu___10
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___7 = "Steel.Effect.Atomic.return" ->
+          FStar_Extraction_Krml.translate_expr env e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name p;
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           _inv::test::body::[])
+          when
+          let uu___2 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+          uu___2 = "Steel.ST.Loops.while_loop" ->
+          let uu___2 =
+            let uu___3 =
+              let uu___4 =
+                let uu___5 = FStar_Extraction_Krml.translate_expr env test in
+                let uu___6 =
+                  let uu___7 = FStar_Extraction_Krml.translate_expr env body in
+                  [uu___7] in
+                uu___5 :: uu___6 in
+              FStar_Extraction_Krml.EUnit :: uu___4 in
+            ((FStar_Extraction_Krml.EQualified
+                (["Steel"; "Loops"], "while_loop")), uu___3) in
+          FStar_Extraction_Krml.EApp uu___2
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_Name
+               ("Steel"::"ST"::"Printf"::[], fn);
+             FStar_Extraction_ML_Syntax.mlty = uu___;
+             FStar_Extraction_ML_Syntax.loc = uu___1;_},
+           args)
+          ->
+          let uu___2 =
+            let uu___3 =
+              FStar_Compiler_List.map
+                (FStar_Extraction_Krml.translate_expr env) args in
+            ((FStar_Extraction_Krml.EQualified (["LowStar"; "Printf"], fn)),
+              uu___3) in
+          FStar_Extraction_Krml.EApp uu___2
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           uu___5::uu___6::e1::[])
+          when
+          (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___7 = "Steel.Effect.Atomic.return") ||
+            (let uu___7 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___7 = "Steel.ST.Util.return")
+          -> FStar_Extraction_Krml.translate_expr env e1
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _fp::_fp'::_opened::_p::_i::{
+                                         FStar_Extraction_ML_Syntax.expr =
+                                           FStar_Extraction_ML_Syntax.MLE_Fun
+                                           (uu___5, body);
+                                         FStar_Extraction_ML_Syntax.mlty =
+                                           uu___6;
+                                         FStar_Extraction_ML_Syntax.loc =
+                                           uu___7;_}::[])
+          when
+          (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___8 = "Steel.ST.Util.with_invariant") ||
+            (let uu___8 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___8 = "Steel.Effect.Atomic.with_invariant")
+          -> FStar_Extraction_Krml.translate_expr env body
+      | FStar_Extraction_ML_Syntax.MLE_App
+          ({
+             FStar_Extraction_ML_Syntax.expr =
+               FStar_Extraction_ML_Syntax.MLE_TApp
+               ({
+                  FStar_Extraction_ML_Syntax.expr =
+                    FStar_Extraction_ML_Syntax.MLE_Name p;
+                  FStar_Extraction_ML_Syntax.mlty = uu___;
+                  FStar_Extraction_ML_Syntax.loc = uu___1;_},
+                uu___2);
+             FStar_Extraction_ML_Syntax.mlty = uu___3;
+             FStar_Extraction_ML_Syntax.loc = uu___4;_},
+           _fp::_fp'::_opened::_p::_i::e1::[])
+          when
+          (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+           uu___5 = "Steel.ST.Util.with_invariant") ||
+            (let uu___5 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+             uu___5 = "Steel.Effect.Atomic.with_invariant")
+          ->
+          let uu___5 =
+            let uu___6 =
+              let uu___7 =
+                FStar_Compiler_Util.string_of_int
+                  (FStar_Pervasives_Native.fst
+                     e1.FStar_Extraction_ML_Syntax.loc) in
+              FStar_Compiler_Util.format2
+                "Extraction of with_invariant requires its argument to be a function literal at extraction time, try marking its argument inline_for_extraction (%s, %s)"
+                uu___7
+                (FStar_Pervasives_Native.snd
+                   e1.FStar_Extraction_ML_Syntax.loc) in
+            (FStar_Errors_Codes.Fatal_ExtractionUnsupported, uu___6) in
+          FStar_Errors.raise_error uu___5 FStar_Compiler_Range.dummyRange
+      | uu___ ->
+          FStar_Compiler_Effect.raise
+            FStar_Extraction_Krml.NotSupportedByKrmlExtension
+let (steel_translate_let : FStar_Extraction_Krml.translate_let_t) =
+  fun env ->
+    fun flavor ->
+      fun lb ->
+        match lb with
+        | { FStar_Extraction_ML_Syntax.mllb_name = name;
+            FStar_Extraction_ML_Syntax.mllb_tysc =
+              FStar_Pervasives_Native.Some (tvars, t);
+            FStar_Extraction_ML_Syntax.mllb_add_unit = uu___;
+            FStar_Extraction_ML_Syntax.mllb_def =
+              {
+                FStar_Extraction_ML_Syntax.expr =
+                  FStar_Extraction_ML_Syntax.MLE_App
+                  ({
+                     FStar_Extraction_ML_Syntax.expr =
+                       FStar_Extraction_ML_Syntax.MLE_TApp
+                       ({
+                          FStar_Extraction_ML_Syntax.expr =
+                            FStar_Extraction_ML_Syntax.MLE_Name p;
+                          FStar_Extraction_ML_Syntax.mlty = uu___1;
+                          FStar_Extraction_ML_Syntax.loc = uu___2;_},
+                        uu___3);
+                     FStar_Extraction_ML_Syntax.mlty = uu___4;
+                     FStar_Extraction_ML_Syntax.loc = uu___5;_},
+                   l::[]);
+                FStar_Extraction_ML_Syntax.mlty = uu___6;
+                FStar_Extraction_ML_Syntax.loc = uu___7;_};
+            FStar_Extraction_ML_Syntax.mllb_meta = meta;
+            FStar_Extraction_ML_Syntax.print_typ = uu___8;_} when
+            let uu___9 = FStar_Extraction_ML_Syntax.string_of_mlpath p in
+            uu___9 = "Steel.TLArray.create" ->
+            if
+              FStar_Compiler_List.mem FStar_Extraction_ML_Syntax.NoExtract
+                meta
+            then FStar_Pervasives_Native.None
+            else
+              (let meta1 = FStar_Extraction_Krml.translate_flags meta in
+               let env1 =
+                 FStar_Compiler_List.fold_left
+                   (fun env2 ->
+                      fun name1 -> FStar_Extraction_Krml.extend_t env2 name1)
+                   env tvars in
+               let t1 = FStar_Extraction_Krml.translate_type env1 t in
+               let name1 = ((env1.FStar_Extraction_Krml.module_name), name) in
+               try
+                 (fun uu___10 ->
+                    match () with
+                    | () ->
+                        let expr =
+                          let uu___11 = FStar_Extraction_Krml.list_elements l in
+                          FStar_Compiler_List.map
+                            (FStar_Extraction_Krml.translate_expr env1)
+                            uu___11 in
+                        FStar_Pervasives_Native.Some
+                          (FStar_Extraction_Krml.DGlobal
+                             (meta1, name1,
+                               (FStar_Compiler_List.length tvars), t1,
+                               (FStar_Extraction_Krml.EBufCreateL
+                                  (FStar_Extraction_Krml.Eternal, expr)))))
+                   ()
+               with
+               | uu___10 ->
+                   ((let uu___12 =
+                       let uu___13 =
+                         let uu___14 =
+                           FStar_Extraction_ML_Syntax.string_of_mlpath name1 in
+                         let uu___15 = FStar_Compiler_Util.print_exn uu___10 in
+                         FStar_Compiler_Util.format2
+                           "Error extracting %s to KaRaMeL (%s)\n" uu___14
+                           uu___15 in
+                       (FStar_Errors_Codes.Warning_DefinitionNotTranslated,
+                         uu___13) in
+                     FStar_Errors.log_issue FStar_Compiler_Range.dummyRange
+                       uu___12);
+                    FStar_Pervasives_Native.Some
+                      (FStar_Extraction_Krml.DGlobal
+                         (meta1, name1, (FStar_Compiler_List.length tvars),
+                           t1, FStar_Extraction_Krml.EAny))))
+        | uu___ ->
+            FStar_Compiler_Effect.raise
+              FStar_Extraction_Krml.NotSupportedByKrmlExtension
+let (uu___391 : unit) =
+  FStar_Extraction_Krml.register_pre_translate_type_without_decay
+    steel_translate_type_without_decay;
+  FStar_Extraction_Krml.register_pre_translate_expr steel_translate_expr;
+  FStar_Extraction_Krml.register_pre_translate_let steel_translate_let
\ No newline at end of file